From 0ae3bce0507f9c490d4770b06a38279688cd7dd5 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Tue, 23 Aug 2022 10:52:36 +0200
Subject: [PATCH 001/602] initial commit

---
 doc/guide/guide-super.rst | 97 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 doc/guide/guide-super.rst

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
new file mode 100644
index 0000000000..65266fb4eb
--- /dev/null
+++ b/doc/guide/guide-super.rst
@@ -0,0 +1,97 @@
+.. _steady:
+
+*****************************************************
+Superoperators, Pauli Basis and Channel Contraction
+*****************************************************
+
+[Christopher Granade](http://www.cgranade.com/) <br>
+Institute for Quantum Computing
+
+$\newcommand{\ket}[1]{\left|#1\right\rangle}$
+$\newcommand{\bra}[1]{\left\langle#1\right|}$
+$\newcommand{\cnot}{{\scriptstyle \rm CNOT}}$
+$\newcommand{\Tr}{\operatorname{Tr}}$
+
+In this guide, we will demonstrate the ``tensor_contract`` function, which contracts one or more pairs of indices of a Qobj. This functionality can be used to find rectangular superoperators that implement the partial trace channel $S(\rho) = \Tr_2(\rho)$, for instance. Using this functionality, we can quickly turn a system-environment representation of an open quantum process into a superoperator representation.
+
+.. _steady-representation-plotting:
+
+Superoperator Representations and Plotting
+==========================================
+
+
+We start off by first demonstrating plotting of superoperators, as this will be useful to us in visualizing the results of a contracted channel.
+
+
+In particular, we will use Hinton diagrams as implemented by [``qutip.visualization.hinton``](https://qutip.org/docs/latest/apidoc/functions.html#qutip.visualization.hinton), which
+show the real parts of matrix elements as squares whose size and color both correspond to the magnitude of each element. To illustrate, we first plot a few density operators.
+
+
+>>> visualization.hinton(identity([2, 3]).unit()); # doctest: +SKIP
+
+
+>>> visualization.hinton(Qobj([[1, 0.5], [0.5, 1]]).unit()); # doctest: +SKIP
+
+
+We show superoperators as matrices in the *Pauli basis*, such that any Hermicity-preserving map is represented by a real-valued matrix. This is especially convienent for use with Hinton diagrams, as the plot thus carries complete information about the channel.
+
+As an example, conjugation by $\sigma_z$ leaves $\mathbb{1}$ and $\sigma_z$ invariant, but flips the sign of $\sigma_x$ and $\sigma_y$. This is indicated in Hinton diagrams by a negative-valued square for the sign change and a positive-valued square for a +1 sign.
+
+
+>>> visualization.hinton(to_super(sigmaz())); # doctest: +SKIP
+
+
+As a couple more examples, we also consider the supermatrix for a Hadamard transform and for $\sigma_z \otimes H$.
+
+
+>>> visualization.hinton(to_super(hadamard_transform())); # doctest: +SKIP
+
+
+
+>>> visualization.hinton(to_super(tensor(sigmaz(), hadamard_transform()))); # doctest: +SKIP
+
+.. _steady-reduced-channels:
+
+Reduced Channels
+================
+
+As an example of tensor contraction, we now consider the map $S(\rho) = \Tr_2[\cnot (\rho \otimes \ket{0}\bra{0}) \cnot^\dagger]$.
+We can think of the $\cnot$ here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state $\rho_{\text{anc}}$, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of [Wood diagrams](http://arxiv.org/abs/1111.6950), this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
+
+# TODO: add images
+![](images/sprep-wood-diagram.png)
+
+
+The two tensor wires on the left indicate where we must take a tensor contraction to obtain the measurement map. Numbering the tensor wires from 0 to 3, this corresponds to a ``tensor_contract`` argument of ``(1, 3)``.
+
+```python
+s_meas = qt.tensor_contract(qt.to_super(qt.identity([2, 2])), (1, 3))
+s_meas
+```
+
+Meanwhile, the ``super_tensor`` function implements the swap on the right, such that we can quickly find the preparation map.
+
+```python
+q = qt.tensor(qt.identity(2), qt.basis(2))
+s_prep = qt.sprepost(q, q.dag())
+s_prep
+```
+
+For a $\cnot$ system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary $\cnot$ channel:
+
+```python
+qt.visualization.hinton(qt.to_super(cnot()));
+```
+
+We now complete by multiplying the superunitary $\cnot$ by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
+
+```python
+qt.tensor_contract(qt.to_super(cnot()), (1, 3)) * s_prep
+```
+
+```python
+qt.visualization.hinton(qt.tensor_contract(
+                            qt.to_super(cnot()), (1, 3)) * s_prep
+                        );
+```
+

From 9682275a3fe1c990aeb9e27a6b4c629d6ad77b7f Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Wed, 24 Aug 2022 08:18:33 +0200
Subject: [PATCH 002/602] superoperator guide

---
 doc/guide/figures/sprep-wood-diagram.png | Bin 0 -> 21553 bytes
 doc/guide/guide-super.rst                |  31 +++++++----------------
 2 files changed, 9 insertions(+), 22 deletions(-)
 create mode 100644 doc/guide/figures/sprep-wood-diagram.png

diff --git a/doc/guide/figures/sprep-wood-diagram.png b/doc/guide/figures/sprep-wood-diagram.png
new file mode 100644
index 0000000000000000000000000000000000000000..f7c2b2c3d0bc5782f8f327769d552ea4a8a07250
GIT binary patch
literal 21553
zcmd43cUV*Xwk;e8MM2<=RH+(@(nUH_6ha9|k={X(U<kbk(y<XiTIe7k8hV%Bqf(@a
z1_&J@2uKH|*KdV=_PKYT`;~t`eDaWlWc}KhW6m+>T)sBY)1;$ervZULbZ{-0AqYf1
z3<8mTyg&uKBU~iM1pK1#R)rg10DgilJVFDnFM4QMcmtmwAw9@cZ)ErbZ(i|HH}^4e
zNBH<X@NxwC`T2<<-B8{R4?G;j+`XJK))m=7psOG_?5?r@+tsP3sn(8Zr&}ADaXt}z
z|6F}x^Tgl|lPb)E49XTiMQJf<aDVa&Gpn`zi?r+*TCur;OYdR|!k}c7V~Mz{a_NZs
zFp5XlMXs?y1*S5w*)u#Ff`&`R*Qb_>0*dvfvR8_Vi}W*#{z_r>r*^XZ?!)X62t;iy
z-wCI`>(-n;boRyDoz(f80)Aw``-E1$%uAe<KFoD>Ist)%_kFkGtcv>k`dnPK(#eil
z*r>P39iqCT!mmI)ojU*YrT65F_x1H@+`}^wS?sNdNTL-sc{w3$Crkw_{u<pe7Ab{-
zMl56Es>wXKZ<3kQzh#0jESC24_4R1uJ8&yuZR8x}9IX0EG$NF>WUZ`_jjx99EE436
zQ(j<o!gz~irYKffA-%Vf9w89?{7cVqvSBFrl+rFob+33hU04d4do-FyrcSkL;qRS}
z%W>NeOzDR}N91Q&Ih>M`!V>VoaB;8`SoR~-z>eWK$3N(Xhr}i$aRQSyv#QXa-Y+`r
zs)x75-i6M=Q;5oBZ|R%aE)Xlw^@>*E2!yE+rk0#QEkhon%l>vBOq}YN`wO2^J%rOK
z>V)S*AKE5A>rZdbX^e(jW=m;3y8VuN^f|K`PY880lR0Sh=jkwT32}@Jl^eATr7|nT
z$yDh&krvk#ex#LsH|iskGXb`K`eXXrHOl3`;r$i|XNzUHI=JXXRxQi?gZZ>Hi!r90
zgCN7~rMV)o^c}uzkRC;r=3&V#VWo&=8UCdc+)B7U*<e_IWWJF1Gd+PC<2Kq++P!ia
z$*My+&eRKiZ_u=_#s#6@$mpqR6Q!ywI@0E64W?d2nm!99r)J5pwVBK&TcrwOV!P@~
zJqGrt^eD%!3#2#$`^*SQ(P;1Gon3ga8t4jJ<$$yyHCz$$4f?(u3EQ{q>5+G4UqiN@
z7cJ6Lhum}4^>=_Bi|E7yt98Z*fCDk?o&n+1;eoufStT#iq|?-VGceWHJUDJ%^bdwv
zn>l1Fh1oG3tzLobN!Muuhr|nS!XPrz$yQ-&!ZS+P)1gJp_9|VG0TJ5sb>70;x2r*C
z%Z69$<OR(cK;lv8Q-P$%z%+T0A|5ozWr8PeMyo1J@#3oL@-sQ#@4X21_F-L-!SnB%
zY{%NNLwX}BH`wrsgy5fNKLO~oL{eIZfSM`xuXuRD6fGUv>cBI6HvE*MB2aF3(@aEz
zoN)>oTZk3hT_F1leR$Oy4y=t_-7i)J#27ZmJKKdC4GkoU5jP+br5E|r9Tyv-Cd@rC
zx8F!PPTS%LCi>z@#!CZFa*nFf(#FQ)q`3DXf(D_1y5a0sp{D{!`OSQd5hsGsq#<w`
zFRk?`mDQF9Wk8d(CA2OUbNqYi?YsTO-vJ9z#fQcn-WMmAiAM8(39=Cvd~v43yCR8V
z&dP7>*BYnWS0UPk>uAw7--|(K@;(%{SHd?B4;x)MDP4M*o@Oy2+_@2i-QOboq+0$w
zjH}rx?<tXPIMU>Z_mSFE!+#bpk3plTHW(pipfbU{!6WWX4g6OZNy)1CfNM8v{exDt
zY}p_YBW;{jg!$xUnQKT6VjH~5zq!uzT^S4HjH2vDh))3kx0*`L;kn$gqMIl%{jlr1
z)XN(Y*fOpv-r3KP)|YBEX=$a=nZ?|JE-_=ya>jKL4&f=RvEn?RR+1B_l8<xOnE|L@
zPqo|Gw})pq7Ppsl$O9h=F5;fKHOZ>p&cOTd1Z_?TOYiF|IbJUhP$ZMn$N#eKNUgaQ
zvAkR1G(30xqsapVB6GnR&pZ%00`lf>(Z_3~Ip0FT>4!!2Fk!4_uH!Ohq5!p7Kxa2_
zDb%jh7x!5<vDn*unb(&n;2g4Ts#S!a22-=p(r<%yHA^)O&JvPUF+Ktw8qsSGVK(86
zVSmHA_@}NeeMPVU=hpoGAxE5#u&`zE*~L{ZNa#0nOj?>R8~g}#9Yat_t$sBnPOgVW
zchHIVm8jR}HY)WM1}H-IGqHQx>6k)pNy(L)5KnJdGkBD3lxJV0a9~Hpc{N08^I*Zm
zDLLD!Xd(=&tECgI&$(@^ve|~y#r5OpI^K%|<g9xQsko^?lp-FO=!;U<Mx!IDm=J_V
zz^<#}MTn~QC&Q}*T5Is}rTzOb5qH355r~fAL3vzMkqi$6k}_ZTwWMM4<by7(-2^v{
ziw)yfTP4tOQXPZp;rKFLp@F_W1#6fHg|hPFzu#(hrG<F`3%m>ojYi9YGswHZGnDHT
z&NgoT7dJWJ95R(KU?nai@r}X8idBu7{H46eUiOJ5ekD7+0<U~M))Q09R_*!`D=k(j
zhAhI`@JDle+N!<s@JP>=FaIxqgdDUv6GSBjodA7khJP177tTSora-q}m&XcNH<utZ
znOxt@HNbvTS>5BL0t;|Pmfg-|B}NR)0tzL|N|G|eXP~(ByVo(w&?Oq;23Ed0Ug|D>
zFUnz3c*#lHR>cJG#HVyg@zOR^*J`{EEc!$?$)_2+0S~xPZ)fPYHF*iXs1?ApFTD8%
z8^|9F#}g&)o2srG+1$c>qfoY~S(-+VN|-4DxC!CoqU7X+Y;gZvk+D}Vu%&Qehv*b#
zozZV*-4$<AhVG_p^AjDg#pNwn#~;Nul$<;e+M?-=BisblnxEjN0G{oGnXzlzRcK6U
zz#2!GcUTi#GU+&dsOK~Q-#jseW8j@F?Kq_dn+@&PTnACdcPi;#)eXKa2U9U0I-OuI
zufurg_;$nEowR1Eg=>q0qGTi`Ir1!U#Ur!6!@{65tbzfn@`Zb3r@77(=I|Ntu3${l
zH6-^cD=3@nu*msv<L-tZw1RB&_1%d9%36w3>VlFL1FlYevJe_Yy~977y=e2xkQ2xj
zBayeG%st-t;+k2!>R(}t2I*7RJM+DtWgrq4N8d=55}$V{TY*^vhr7MJb$l<v4=-#c
z&32L5tHQR+7x)3N4a7@DF#S_^<>$&NqrZxW%FPz@g=RuX2HD>tnM`nV`ETW0{xhuc
zc`-J1qua@7xzO**6Xbi$D!Z7x45jy%m-$ba_H|%EdiYaZ4bGhS4qac{DbWNE_h%P;
z<8G+*AsKtd8*M|r&+DNDQ#70lCV<QMf**kD<)G6BD{Zf9RO*aV2A`Y6@)R-`@JA<Y
z<KK&qy`BBYff3L?Y{sg<)5Vv}Fv_M5#I6O5GT#zAJXYth2Fsw$PG}Q^8}VgAml|hx
z{B#=4@lE_ly7DPQJS*Rn$PygRz~meBn5{hX#?l8&S)5M_Hb2tQw@qNl6;sQhcLMmL
zy=U>Qcksnwd+~^ZfD?o8#!cApoI0*;h-L@`@w~msW0Eml|7vfA>U8Fv=^qDkiO%0f
z*gJF{z5jHrQZBHlxKXTDq|XI^G<_#F?F88*GX%5ZeqtJ(*HCK%IgKyj0maxB!fbAa
ziPGr|`^FJJKDRg{Tr%t=th?jhwYF=em>Q0o%>Hzn{KVxREd*RLY$CiIOii8vk_>kT
zwb@QRUVCWJt*Hf8-My|0k)xI4O4UpM@rw#>HSE8Z_@4QfJ1!n;8YPBztN}*_l(7k!
z>jcOnzxQRppDWC$I^S=gmSfphF4m)VL=f&r4m?9*2VOqVeQg$GdII`qa~fUm>wBcx
zerGtgPNTgFCD&e8#NCGN{5!lM%TOQkeJfcLmW_=LGh@!+d5vCn<9u!+Zdo<q9OF0T
zJpCM9|8n~&?ai2^rmyC&0a_@4vYoODio^_Yo5T*3ZyoE0`(ec3CN6q3=?+@K-L=<j
z%8K5y`H_7yvwQ)NzU+P-nH5NrOrQB^jp40zaRJoDPIWom%M-?V8L|j#UxREp*xTW^
zb;PgJUB2QXvnggDi}nwJHQ#^|#AED`{Qh);SO(=?1XkTM4-}!^&I+AnfOtNDH7EFB
z0x8U`i=RkV(HmMYd#Vu!Fy98h8+EzfzodMuVi-Ed$U95DBX$Ft^-w+gw_q`<ne6oD
zjcT)rbmr2b6?mgHo)YsddD{_g7r$+%&a;tX*5bDLt~<W5czJ8+errli0i^%zv2G1>
zaSXRDFWkYx6Izd93NyP5X`>DiU%Fy=;bryXK5E`smEtGC2KWah7fK=$T7S05K#TG>
zGHiT~>g)FpPH-ux#65N51-!A^bwU9u3wtIIeX4AL=YYNspuxHkbs(OL??(EQxBU!J
z;gNe~r=Rb5PU?o)4L9Cng~Y-e<8oLD5|S%S!+$kmDfK{laZ=es?g!WK0T-L%8Z{`8
z_Qd?i&50YaEL}&gFcGWXy#o5`fw(eb(-N?Va7<O0)L_@M*(V#8+~u=BW<%sX=5EaN
zS|+ObuCRNC)_yL;>0udXJc|!%>4o=NPEX$5p}PZ96k5{9(MIVm($fqvk6`pPRzOxd
zma@<+)Q+g7ywHc1P+8*{dAzX}k1+QDv_{PAnA*Tw;XS(E7N3bLyHg53bz<5((n^<V
z&+W7$7Rw?CKcTZwxF5*<x^GIckKkl|{hF@A%-KsO#j~o%CCKX1s3W`BS*3ttZgDg^
z-OQBZonfFptmMgEPLv(}aA~pEf$M1LFlHC5thxMovr+oeWwHWpTz%uI`$z@Ucw|x>
z$^t)BDx{6j66NwUTl=%{@HURCSl-l^r<T=J1p-mA>tDHA6Skr4eD}(#d&dcrp=`1{
z$h)Y`2iCqLZR>;}ct#38<4M_u8_KqohA+k+Qk+5RC839=e_4F_k?a*ATXRBHzHjdM
zI^Y*R_-DtD7uNIWt`TNAi>%CYa}OmkPpFm6-h|n{#6LPZ(@5w2izITXtu-Z|N<BN-
z73F4d+bUgOY{|zmBxnSQLwy^5Lw78!%AMORf3j&kX9)*u+1S{cPYNB4q*HIRV!Kbe
zFpbYR$@+{ef1v1*Tj5=%XDdJqll=Z?&c|_ky)NcGR*iNZjV<NaIQGO&@F3qB2Shfy
zv2i%AnsLc_Ns(9_t(ZJNZ!pzZ)D+4|&uQ8h^;EWyVN})L$uPTi3HJz(-On$3AmuGK
zeAkbva6R&BP1(S8I{#zUt$p`P&?RXsVZSBZ30{?9O&N4q?)6Z1K#~|IWb1nFaD^D3
zC=;kKX;!I&4lYa1V>wvhD=ArAJdB8cxKL;W|8$D|!FdCktkVecM^!FK!6V+hkCiEr
z*9i_EdiS?>dH8B+5U^__)bJ`4r>1i_^Co`Qv@~04`Orakd9b#&==pj##PdMQ*80+m
z=70Rbn|^pq#Rx<Cn^51AuGeT(B+GNPa5b&smnL;@+TKcqd2c+V;ggg^HK#B?A5xL>
zr|f*Vkk@l{-+}kx&wn;59}Le)ms;*Ko4!~!1GB;d2LGWQC}H5_f;>0#D%s_Lcfs0&
zhdH8NgIl$o*>2YmppvFyKwK&WJ-rZQjPD9hi9d93)ma|dr9fu=p3oA8(MkU<Pf~;(
zD%sD+&wtsuX!!0`bpg(Kk&;VW;?~I#ZjV1&*jXW6s<9<wTXyR{alhtisHCKo@CLc9
z;F96Hh-#?=VL0l7wN5&XuWxB{c|kyP3ziEIW0tppBjx8(ORszcMOqR#_-s_!FNLxq
zEytdR8HGg=42~`lP2nonL<RnWD$KT8S3rT9umSezFWR`A#tvrDN?E45C#Fhrzml-(
zwi>fs9VcH<j0OB_WFnF1#l}P?JB<a9H(w@v*-|oIDl;c7O}fhnI|h3KeK{I=6vhaB
zxXDyFAZS@1`)I!Kj||y*ay6)47;3A$?+fwF!K#2&sGneWlZZ#~Xc1Jp-w{22_U1<6
z_^ybDz-H3@C!&=yvj(pHUh;)AlDHNAU_~gm%@nN=pYEd$si)FTQt{Oi!j_*=PdN&A
z9wdc~Z%%TKjbNy5Hm*dZS^Pat8xlIcWh&)7$qD(A#&PI_zjJarTl-c@4L&dPOR5m!
z8G&6)=)Bp2t>3|zsx%`Da=TEeciHEvC6TW%6YyeK?H7|r#XvaxP39@O>$!>kN?qg0
zs{nWCtOi^*9znfCUX~!`U65cZ@d0iIQ`BQ`udgp~@PkVhX@=^IXGxhYADT>bn(oz!
z#Wc*ZJC{}aSWCXO12o?9hvlB1T6VG}ooU0(Az@6*XP1K9nKry{3*NJ${;SHGx%Si~
z)@)?{K~+)Lmo@hLsJ6Y24=wY!;K8FY$=j3GIhZ`HL#d^YGch0t1m|8fy?7bU6TfW<
zKU1^3xxi<db>^LLw`)4C8aldO6Pe`0DYzNxjeULt$msMX{)zOx3<ua`<lriv*c^FV
z>p72#M!L%3Z7i{cN0`O!qT$&(b$CLNrnAl=z3^e;PP}E%MkLy(Xm^ZlAGwt^%zaf?
zzM2_nFxLg0%{M8Z$dg+qR-CF}A#(#v-g-QiE@!lxfkZ~g7EFTcr;b(%)tSN26Aol&
ztQy>ov-M&Sg09#A5UN~SMHF!>ybsUb*1So?j$zlIff%9h{d|wCoIDEF?_lVu36As1
zkLQZr+OCRz{gYP|EL1FRy5aZ0H(LT8n4s#<|JV=Q3w^lzZmwJ{9bblzaJ`QIEFl}O
zVS83a(6&*ZS!N7lW!^cy1r0ITIS$8)U2VaZ>8_Bcuof$Q1MNQQP?fk1icL5)pP>pG
z`5Td*CLOC*lN3$Tu4&Slq^C#58GuYRf*0AAIDWb2=VG&F+a?|MuMbSvn#9&6O8I*{
z?Zs3>kP@|#R~nov2>@KrCEJoPW}ULEXuO$hGY;FPr66O3MDZ;d!2QT$EB^H0s`#g_
zFRk9owTSY_c9sN)h6Zj0W(>>4k}dXXMO7P9;Z&|b^yiB`9(NpG%!pqu8&XMTuG!OU
z4?Ym8p5!Fu=79WL_mm3hH}K><AJ^xS_}_o||NR?;ZkszFw3exADQnAif?(G2?JKr}
z4~}>!-jr?)4MQY|ClQlp<7jhJhch#>IZMY-NvqqKPEdK-*3chxecsp+YdNxJAhvci
zn{agec<<!oK#D>gw$8q+jsF|w4yGnMqsSW?7l%r<ub@t;1-DLH?wCdA3&3FIdpure
zbkK(nqEA@KSL%9B5i&uTT7lq@<170j71&O<V8{=fxtgiy$u@u8;^2_#j??PtMa`xS
zyYhi5-yW7)onb>!B#Q^6g1ds#pKZSl(%NsrReLs!+h?Ch2|OEKZ}UN)lv4`S^qgX3
z(C9XXEn9?XoX?F-2m4z$!+rD$e3jRDW<}XsRMb}66sA>3%Xl&qI+U%Ck)d`=+>Sw~
zO12->Wa6uhb<#nT)GpdI1fDnO>wirhlQp;YHg)my^Hb1=_ZKjImdRKomatTa<HrR;
zABId9_4VlB^TQ>>HMO$u4?Gep6w{V8kbowGuE$xj$9TT0r5|BfrE;MRf_jT0O4qBf
zcTP~m9r_^z-JZI=SOx!PWnayZE>cw*`-v9f8I+iNFy$hu-tJ{648jR}5grn#c173q
z_ZA~8=9q&E2X2G}S$wlxE|dar=;GMHzji%L9daMFiB2QK)PnQCZ3WWyy?x92_+)IQ
zyS`?-M#D-Wb%b*jrYPOU{_7Y809~&eb56#Eh_jnjNfh6y>*oPrTWWin6fA6`*Lp;O
zWGe9U!8koU60@L{p3p=O*ox$eVlJ|<tOP4Hq^)!QfoQ|@WWb85;xSUK_4ud0>y~{b
zEe*Lqj#|O=iqqAbRf>~_uBHz$jr_jzWnX}tlI7L`6GmH7ElI7$0&Y@+Q%Y!J0lxoH
zcu;YedQl8VGAaclq^d8>I<1N7e9U{f7fG{0<?zUX*uL7J(`sZRfH7ChArhdzZkvd-
z8WqxOz?6&7zbUn)>Aa8&g@9z2l<duwGFpZ=8e*u0(*bI+7);8`9Tyfle=Y{Bgrw^Q
z;dA``@jm}C^WmNk02DKuxFu0`StnommW%T9os5VS_EZ&57raV>DK;-`QWKk(2J=;t
z8h{VIyA_h-s{<@(Uhcup_BQ9mx3n&!Z{{qJN*9|Q54V@-HZb=)8J<)<G3ab-xwTWM
zTwkANL8YXmbQ`4dIec8ho!#TUzW#t|1FeK4M;ZRbGP?d2R53TpLfHwlvLN<Z+aZ{^
zJ*l3WMwbE*qeaVVMiWRlvn9jhO$ZTW|L$Vft*Xo31u|9lSC*EpFer-qahWPiNFRbo
z8-(2U1TuL5JC$&24<_|lMxNQEB^krE$#c`KKj(~>V0-*O-vai|Bo|2;=ab9FU@Qgf
zTveX1k<L!ZBxNdT-<*VWbpUQ2(}J^$BV(|y#HAb%^QL+KI(c^RD)sifSbN`i#(CwU
zucVOASBD1P(ts*tB|%PT?qV-+@+L`zM_r#9Xm64(|IIkvfD4kP2c*FI`aa&!1@fAb
zR<tKLGTfbYRRBWr0RLNbMWV^<_0|>oN=`_xNe)3BCjM^HcPN2`o}{f8jzG4kNLw;D
z3oFe3wBkMRku+(WG|M8V`Ts_eC5f>$wDJCMZ$6t$0Bk6CN9XgCFO<NA+_5_!?i{gw
zed*eUb=bI}jHcuO&jK0Y!dqDt!1OFl(i%fK-!_3rkXj+35%P0sn>2BeDEtc&`fI*3
zaDp!VI^P45kMb=+vw;?V0e~ORKKEH^(k8%;_t<DE0SieozM^jq0J^m3f1<N6H^6kA
zoOI<9NfK0nG7y$8Iz>toKiq(lsM`HMw|qhYW1HTD4iK8ya3Ihxe9H{9T4yhL%NI?F
zklOrbF6v0)^!O&KXbZQ4GbARZp$emX!!o>C?>jjj1^11AdNE09j?~SQU)=H3RftI|
zEs+WhTmhNQi@n#&W7*SpEd5;K`-Y4jTFT_7yI|QzAQ-YA$<MbjRw-)l)#anV+B{E_
z4#T?HU;NGrnTl34)z{abH%IIY$p#;8zdD_8U6^^DRtkV#iG->uJpu#g9cNMCq*3&M
zMH4Ea4?(FUW<iCLUIXtKLw?ZS@Z;L~W#DRR=&1MrIM13Qd`ZELC2hFb0*OEXcF_O7
zKj8XV?M27`+$Nny{8&oUKfsZ@ofAS;9%hKY&<y{1vSuiX1R?lxG7~1id*mSkA%hMR
zd&g8PsM_%VdD!}m_y$G4YY4(L$?2CksJDZN!kGve=l`_|VI=uK|HgkL+7|zt1e0W=
zAiX3FWZsalY5O03MG~A)jkjuy2YPJ6NYM4o0~`;4^XNpZXGhYvUN2x?Yo+(jxtLcv
z*(bM3{Cre^Qc1g|%U`HtSdM-9?{P3gqJn%$&OQJDlb!*Kx$Spt$1rc5=RaxHUqOj9
zaPNC5QlR1@x}8wwBR24#th%qApBA0|zmTh)4uY*)E_aaV0{T8hsuB2R$vjiGQSSY8
z!JSCv%AkwqhMZmoOt#94l~nLVWEM*OYv%k&YtP)jA17;4Edl{nIVX~6ew(G$-t$rG
z{>!xC%a|cy<b!{Yb52WD_<z1r`YeiJZF`1J<_Z8hs!8o3u}L3$iBygP6tP(L=^PV)
z#~@wT@;5a-Rr2D08e+3Y>i^?v{x!-UG<tecdWdup>==+gd<3{LOZ73m|FY5?b~)&I
zu@*r{Yu=9n4oU<*$7dtB^gq@_i69FGD7<QSfy9i!;R?ZRFai9ceKtBRa{q1jrtIX6
zVe6AGhjd7^lGFsMVlk2@A>HD6l7O*h`|70hze)GstoRA{XYwVmdjQ7+g%V~67?;$r
za<gi8@jT>3=rTiEFan_X|DdfBMd*83Ke`=&Xho4ScVL`pO)OQW_iGuGfsu-ZbPK3r
zzWx{N1jJ7P1K`rZ%fZdG8%6v?0c7_Kkw7M6=n!u4e{f_9))r3dJz^*h;GN&3lXS(T
zSN|K}Gy(Q4=`cRuK7u`oFC}jK(UCAgNYiE{@i9SF#p7nh|F9ts$Nxd~<=BgNewF3g
z0#>G7^yaz<P`r#q|L(U@Qvx<hC!Oveh~`3BM~O+|+J89$#-ecEf1|HEsx1|8As8t=
zd=f^i*Cr~hrVg;RjI@}RaoE3m0n(y}%<Wme|G#p?zuZjjwRg0?zu9QDBm!RSKH$Yr
z5=o?mr%9WWf|b5+02QVUr(h+3{G0geq>0qKDh#bASsT;~V0{f(=wMV`V*;POnmv03
zH<J5wc#7)PsM~=FdobV9frW5k!nq$2&fN)Xd$X$>>1Lo$uFtfW)b%$!6wIPE4yhN1
zCdcmj%LJ(#OtXw8G9}B3t>+K#KNUiH6ee}~FK^0D({L7*4)K+$9U7EP3dC7fD16$V
z4S9o2k=c|3doO-FaRATEC`{ZU`js@yR}%i(V6WC*EcErJDI5;GVMocL)5uj%`CD-P
zj1$tkd=ljgh0letf&$3{nfAn~1nB;Xo_0rytJ7MXFh@z-3|BOFf+V#<t3tn8>)6N{
zTTKY*eVYIelsB%yoVyF?e`LCGdU%6p+G3eZ`<BI^S(Lk1){dC$D)KSpyVcj$>!6vM
zyH|YroFYvE#VN|7(YYT=^Aoh#8JgMs8Id`)-Ory~0j-mBV}F-Pw!4PFMBEI=2o#vc
za5UQR9&*XR)m07u4Hu3(#nHmU19Z<`rGTS~+%li2mi28)e#bc^&OUlPZ(1#-VmtZD
zIOuCzT#}XH9>uijWLEOFH}MFvHSvmNYJqP}^U(bXlW?oQI5>o1l4jC$@~rzogQPml
z9S}2c$o%heyK3maK(?%gXTcR0xmjHrca--~*&MlB*CnXx13RulQu<Y7Wo5b9!`Br`
zd=B&Uv$KL5Md5>CvT>G{cAp~4z-<)D5QyJGQ7JP#0J5o$f3FbtZFmICO2(?$Zq(o`
ziNfA`xeP*I*h_GBP>&1I@tkn{J{U{hMpeeY<J&yKdua7stwvf)=f$!!AX8$%${NeJ
zK637JdsxEydM&KnFj>@ZFLLTPYVTgy<iV)}>i^q#U;3w<@sGk{b=()5x#ZByHY{0W
z3vsI3H4sm;m_wI-04#Uexr?GIue5;<d1p5v&2E<k%|jEVzPd>u-_5lptzmZ4wbCyf
z3vZI)iQix1Si{Qw#zSdWT<C|Bqp?ciehFfQriT+dWGNWS5I`B4t^otGW3S{i{&BAp
zhiU|gz%xMkWY;mB{>KoxTBF7nOp9CDaa6DO$Y!9ymHrB-2Z$^FX<jG=c%V+>+o6|p
zO4vI}to|w$7O-YPXqnGDnJQCOh(4_SD9i?Kbhbv{m$bd!oFtu$iH$?Bj9;v$AC-qH
zFW+(fat&~U?h+9}f&dT)wZ=8^<yt(7<^27!hrYy@5D8xBsW9|3tLE!vK_Cz<F;Q=y
z!rpyzrngMKWdm19sJ=Vhvs}(r|CDl**)V2b%EKO}m|AlaB?~<%tsbg>{o}@9VgQNJ
zoD;Uah~C&!JZJzT1_|MZE;tF7918)ognIUHyj5SPkwuQjUup9)94Kn6JuNO~04mfe
zaa71@22NH;Td!4;1qujsW6)y_sEQ=!V7fLcP9qmfiXcWgVJOQZVZfz^LuVD>P2d@7
zdddYYh5D&4`Pej^BMydFmD`9xt3NHih2mO2ec)@hT@%QFd|Be4^*l_O!G#Nw?Fnob
z3!Z`V5~t~atmrpyP0%8yGuoPWDJ+2dLmD3!m9-wtkdu151fV#Dg@I_kh6>(9?gTz!
z$ta_kW`*o67Wed()S}t0X6Cd1na1ex`93|m>G2XP3u~W`mb3k!6~MTuX3x2KfR+;l
z`ZGkkMTbpUF`aOQgz8_btymMf*w^UiTm}6lM(SR-koObah?n7-PGYE0z81!P2|<JG
z**mT~hJ6o|$;?&!M0aMBojIi8R+!}MDQY%QD_xKfG^^XvJR%Bh3ug@Tx~Jhz=!DKz
zVNUN_wjOn11T@<ByhdsiFv^$Ssw+eQO-(cX)|jMwV=UBwCrg&%0BXH}m%Sdp?M&3f
z856G=u59-|E&dq!F|#6lt@-aahtuPOH#{m?Wo2TGO-)x+LKMMZ@b>O5er87B&W<NI
zIGEFK($l4?U*?0tw27HbhiKiTs+k$9jg8G44%wJWhpt<QKDN#nuHMl~2ePc&h@CCj
zQG2lRW;nyp&$?QT*XXkw&vxp<y!mw_(e4Xn#Vqh_vTvYdGWS?CkE2+3$voh)5~yC7
z11zVOF0fIBb%U9ayYF6w2`7wIIZ3)tH$PYloPB*g=Fneu(gSQ}<2!8G@?>wyk7sAA
zbPGBQv{3PvvLDgG6L@E5yhluQ@vPyo38q?#omHqby4V!KI!J<4(oom>RYSkn!EnhB
zB4?>C?LCe64nD*x_sn)gEv>CN{`~xMGI($5ZSd}xh+XTShuKDX_kNC}%DHy7vI3R`
zS;VZh+}*|Xl@Iu2XM!YCti9m<!TGuwogqhSUCKwRUxo^e(iD7!2J>_|eCb5<uJk6x
zf<tJwHDQB?3OWij^&mEepleX&;SvW1b&OW&?+r>8u%<@4Gzqvofa<Chh^v<NpsV1$
z$s;#?-A1@rw087iZnoW4q?yOjTAlZxu54*_aDL{KqTVf`pY;zH`qCz!E@mF@l!w|N
z+g>wXzZJOa(izKRmooRHz7i{(8Qib<7-kJ!@*pnauJfzI-j4UNI~PzatK+UgJRKGS
z`o<%j&MF=xYzGlF4BxGj?fSf{)sw7GVz=+&@^cy8a^4vX87{V+zhgrV@nlBEtn%aX
zBg4Zjv=pM5!vpfbHPY!=F*q&1Qr3BFRr?@bifiA_UWXV!3`6_#xtr7~bX+Vx7Zi!z
z4zWtLJ++yB(+v;00=Iu?nvK<-ogT@q`V*`no?s6t<Q<{~CdTy%9Yzo8JGTOkL8G$}
zBlcWy?9z7LFH(%lR1_=ZX6gjg#X{85f6jRkiRgXJ=^__43ZM9e&Kd>u1@6$GVT~k>
zTA)(}2QGG*08WPEi6W{Mz0dCfU2@;0#?U(xD*0PthSnTFa$?X0sg+TLqY+7LS1GAB
zobqw0rjI!&;oqfyfWG$u<NIEbEMt3bue{oIvfk6BX|0y-_H@;NaudFGecerFCg|@g
z&VfI#(Hr1wKGBbVyy1b;hpCv|>vRe{;ARzQ$n<ZA^dt))a30Rarhrv=YkWddq;7a3
zfrQwfgNd0_U`Jf*rjmUL$iCE#qYXP>3H(~^M2r;t`7m5%NobM7oAolpj-r+79#j-*
zn+>Uu)(U`l2rfAjmLOZ18eF|4M*h1D#c(`rSg%(2;VN2A5TKv2VVdEc^n(w{mNqK2
z6K+kfxXKv;74}`*OkRcj9ykVEhN*Ukm5j%SGV!_gMheHx#Gpe<7mqT0h3bqag!o*k
zj%h~2m`Y|+>Y!BwkD1`T(vPL_IROR9&cfvnThHpiX5a~snYLw{?S?qga%(z+oE2>Q
zYVhL?)8i@7C?AQz3|xidrLNSIkFxJ`A*D-A7XPVAHhWtk5T{{g#WfkY(NgS!`gOI#
zGH3ibQ*Zfi#GV3?0k@8G#AqlH>z9vP!5&<NIy1P(Gb1jp>g}J={sMsTH6%srwOG@}
z7b8z1lR83x2FZF3xuNHmC#+!G8ZaZ)nj6LFf-7EAhOW{706k&0Itr|9m-k;|Yt}ys
z7Sh&Jq|#4nSc?8wq^eQ?m{Fh<?F(Cnj!&k9fy2APEg+Rwy_FE6bCq4(4&9ifHV3^7
zndqGn_r8~5p~rJPBIXr;vWbl=WxaVBZsT!t7AvpO`C(?@zhS)LJlgEH@q6)7Swq8f
zCb(cM@;>Wum8qn#SwZc6Qi}Bf{?}OqtR4JR_!dgEpBrmloD?wOTDQ~3<12730N(?m
z`!a-q{0JON)&-hLkXjvBpQZT)m@4iB7XrDT&b-=Z`P%91CZ8*PQ2G8=BD$X6NeNL}
zF!r3O<+sk@8-AO4m$9;cAfB;+SL7s$;tb&%LR8Z9g^!0%C6@LAFO<JP5e(c4*FDsu
zx(=|zmqQ_tnLcZbg-+41;o99uf(XQuweYCZ2zNWo9VMM28hPhLjYx;%1#+?WlFrf`
z^nhGr(H81YVvKOU%`6u-<g~$+hN@H$(lc+tuq>42Ub4(Nil7#JQj6Y~L{9b&;sV3m
zhsMhvi^wy`B@ekiLcmG_3Uk$f6yO^m6F0`|$Ms69%1F1HBpU>cc}yl<Qu$gg$#JoP
zrVTGeR{r@1SyO#qzhiibii*ngV#CzbluOO9Dc$WntD@3mbUl~c1@j9*ckpIK+2WSv
z160#Aig22tJ*k%O1R0ik!l&`&(sL24`67RaBk$p6k32S^mz8%`HcjUi$|6?r&xMnd
z6Jghh2N7Isl6eyO-&<Rifxf_b^=$#&^!94xAiI|$O1z^!#R3N<@?u&IcD6&wHu!uQ
zpPKw|Z8xpCMo%zx;w~6%(4)%IPY3U8H|M6-)FS*&{5L;QUtu$Us!Q*8@;EgFZ}P3y
z@|O@4=%KJD3K1DGhwzji`cPj6`J2%7uNDp*1r#gbeEsYY)cV7c6H;R9Re9>#oOeeo
zPbB(uc+H)#<lKM!WA$z%{ctn{0tRv)cE8FTvCvroyz$eh@BwljK403WzCU!^34Njj
zQ(5}q%%xr&pZyb<by5>sm8n^AZop!upWEoxWcK(gVW`{H(nRyE59r_BCi)p(72mEx
z1AyjbU9WS=%B6u1!9srOgoSon$4DD^eonu`ZsYplrkt_P!w9Y?k4LvSi(KpZPJ}%a
zH${+TYkN9>8iIdumPn$}FCkm^))kg>rE(h0A-!N`Gc~*dE|f(j<VUeUvK`4ld&Qi8
z&?k#pbv|b(Q*7B_v2ytYnA1dsL*r2dT?AG?q4AF>6+NY`<}&Z837qGvg%vQr+WUee
zQ)MHWs^w%Q&JCOE+?LwFQdPV8U5%mAW$a^8t+ZF%EDi@^P&wYzo*-DcE9L2Bj#oHX
z9>s5a67RiZl~aV4#iE77K7{AuWcgaIJ4L$|T`sYE+w>1g#gS&Xmc3&#H(Mm+*yV>b
zu8;6;OfppQ&sSa%n?|2pSGQa@PWW7;a3<?~nPWX)<~?V&C2-6ew4GU26j~>IPOB;{
z$O?b)X^{(xgS_oYMQyxS!8&IIxGB!EP`uAN%3`8G`fr4pp-56Cw)kztqSzxjz7`(2
zsG<J3of@hP&Gvz?x;U0y1x<WLhLxkBocRP=-q<fjpLx$N2JKipHQ1MBRGiy5Hn{XO
z?md}Sfb6EO{gur;bbU}kFz+n+JG}NuFuY4Dr~RX6h1=D0BMneIr{F0vzJ7{b0a1%U
zTOcnF2eLUm4?GI86rbM8aILlY5(6YiYP14wZ*m!~{Pp}|aaRr+a^bDkVaZtzc0{)N
ztCv@W8)rNsKONH)7a(X<pj=x&RwPt9Wan+S9AntXXj&y|*BX>`_qml@gQHsP(mIb!
zDt0d1I~+898KT0qj^dqFB(`9g6GNeeqKysJYz(&54}i0bLDNR|+L)^2xdD+1CAQs4
zaUhto0PNc1^)th*5vdk?fCDp>Z2wIZG#d5zLdOws4`qX)Cu_Ak_E&`+Kf-PR%tfh8
z@dhj=L=disAG<(}vU(2W2sjLL^{3<=)9t59t^g5Rp-HXlNBA7e+2Oo+Xg3h#nT;=)
zF27o#jv=2;ZHoKEw?=!MIMj0-j^59%2`)$P3wQ{9r?eJYQr{{3_`&#D&Dn&7F8wgS
zsmSi1yxFcA<trJ!MV2`MAEITPzgCtttt%*>9SoFzoH{Aw5Qb7gA3lK{L;XaD`POKT
zG1WrLi@dWFAA$$a`=K~lt*OstiND-kc<UgAu{F<YN<Zf`PSTU-k@;z~uQfzTpk$x3
z29udCIoL3eg3Ekh`a(9kIMLxuEud^z97Y$mq0x@?4LV8)rw!8$FXq!No(uG&p<YqA
z(dq9Bl3M>`N4ibH%Fzwa1LUPY-k7^sJoaStL4--|6c8i&Ds`6DP4@`qzy17YzW3>p
zj$LEVU%(fLU}VV4sA@rgCoRv~;DL}eGuKm%h7UbdYRKyP{SQ6C_a6vt?~rtjRE{Ok
zKBj0;c@+s2PIl$l!m$WPkmQ4FuV@{%xEPh|3Pj^}{chJ#bIZl$3%?Td^V-_72ZGnV
zU0QYs#j907Ttk>QCmcrp-DSpo!|h-T|C+W0NoYeVnf$qKvW|jNMGH|o<saEOOI-PZ
ztQfZSi@W8VZRXq!d#HyItVBUGC9U*Fs)U0nQjnXCjqPJ`r$>LbN_K3>_J_B?VT)LN
zd@-nZJ6erFDe?Aty+iH^5DE`aakx|vx+-_CAvuA2EiMzE5Yg!0s3AZySP+5o8txu3
z2=3TJ(LZbNI<UoK@YG~s^~nfB)qP-`PN506hIy9O-J0_FGAx4~%ws7x#S4gBy-#*V
zBmupnr*h&$FaPVGWHFnbDZiN({HamC9+$~lEdo$}>7q;T-$<jST&G2dAw=o^`p-;|
zzu{(pcXtQ14*zyYPJCWNMn9ZuT<veXaLs0}$O<7-&8V*!zo@kFwAkfrD>k%mtBYqK
zT6Vg=bI<=z_jUQbNpE?8mE`B%NbYy3oPK)6;r5laZC~B?XncfxbENGwDOV?@Y+E5>
zIgd?eSt!N(eqvSFT-X7w1pRnir~tAB+GHnQA@afVWmiV|=j>fe5}H6L^c8Fw&mOG3
zc@pSiuL7dlZ*p^&rnh4JDuNFFBxN-ntvAUZ{7M+}?BY6qI2V_W0uMGx#HGIr{SMR3
zPZfb+d-BPI>wquo72w_Sz^N7gv!j`TU){o;5p?T^WSd`kV=Mf(9ujQ)raDhCK!!vz
zoB=#QPOaIl)L(WDdTL%$?a%Cyj&<Ul?d>o7Kq2%gU}1Y{@GP|{)zoZzE|mOtG`h2_
zXqb<Fc)mK+Q{}n?U9tsGCTds(+{fFXKixqmD|Y4b{nJW&lV6nfO5|zRKK6<Q{Yl7v
zlw$M5V!pvL=Wr=M8$l?sSOtQ+dq7wRPY{qm;`tEY-YymHj$8kjpA!Kj5M@jxI?H+o
z)=r0sp%f!;<wJU9=Kon?;vj4Dtl(yeU%0n%p5+9>m8Jz7g-)`Llecfx&7b7nelYI?
zT>9fi>(QU#@{pvN)7`o+AyWX1MuAxO{Md+LU?9$TQr={l!*1V=;h*#w)D?EkP!2xa
zq^(Ofx^zL2!~c5W%fkwEYC_G8t5Aea02h+EYk>LFA#cNqvsx0%ikZB*A4{~)yXczQ
z_bNN8_BQskerLa}fz%)W9Xptml=<HFwsFib#I12jK&)x?7Pmi<j62}>wZo$$vw+s7
zrVK#0W6~s@y!L-aR4wJ9S`BXcty`ZS420r`hdW4-ZToA+rS)~h5<Yi(XXnSrh$f(T
zfiS5LSV&UgsdkY&sa|_hH__LYFzY`T#)Cl=AKotP?K+b_tmnOk6z~wdc~OqqU!ON`
zw>S6oVsSo*dgYqbk$d?S&LSNRd~X;B{G`yY$0l}u&R~iY$TBFN?$0S6Z+^L#rI^+)
zGtoCl9M+dq-C@ID?U;|YEo$D+I2QD{vB~FQ0IPmP#B3W9&2UV3nm6vR(I!XAH8}#=
z<(wrE2Au{rKrJV^`D1-{Le+&TJqf@*0eR+4l4z5;qn0-;?KzZnFjzR2Fq4Mk#f3w*
zMl^W*0BNzo$92bYYKzVOJyur6Ykd`y9@+HF=aPP*nQ{`upsm;PWm+29RU{44Vlxdl
z6P8lv^{xz!p3tI`jwO#E1A2Cp$G;js+gWd*Me+mnITw%%=3EVnWoxIzCaXNKav-J1
z32uC@m#l$%vGyf5Bhmgh-A%r*Lj1_eLF-^!N^6@SctyNt1z-v+G7dQ(5P*|R_6f(*
zdX4-b=PX*2cf9=|t%eb9MJ@{xrwRx=fzDPon?zf~CiQ6up=7(1Ax1$K74d}>E36A*
z?d%_<a?+(Rhq?_>Ukl~Bb;+_~(D_~?4hTXaUkgh;rN1(AbH5L59#>aXW7fyFqfIom
zX8?Nbj+{h`lyv#~9oFn^RDqyq!PHr@3K9=g2wdQ-!%HWfItsM={1p<&+E_p-6>x84
z8~rf%26<3cP;R2&PFjDk)Vy={Him$We)RU-0E#a%iVoqtT7%2ck=RW5^LBkI7VyR!
z^atLDTaRa&OknMj5YG!p{;#<>r!Wpa*MzDvnP0%r!1satmt>WIux0+)%OUrG*x8T)
zw4AuRV>BaV24qV<d2tmyDX_#>XBn%dNsap7BOV(uE2ce$Um~9^)ksz3QdsvE_SKtm
zjOoXd%N6>t$;_I1fg3DkW3>A+6(OFXnw3Khbo$q+QSql!i3piAAk*v+WpzEndh(1H
z#Y_;=_WOJb#f+hc)@WrjxTslrtnfp&w$SG3mDPEXXyCare)XzsLgO`CktG4R_<)to
z#AeA={`;ha0xJxbuU{xzSRX2bVg`Eh`H<<@J@}z0GWU~`mbX3+JA@k6KH1E?zzC7m
zXm17XpKF5KsGgeP-T5+aAip#-*EUB30bL;A3aLsS7d`=sTO3&-#2duunykd?2CN^v
zkt&rsC`!uguOiU~7X_XDgJ7OmhR!bH%5Z_<UGS=xZ|M}pmT2JaNxvuyor@_}ro31m
zqPoB|JwU0l&xL|iU$(g<GnqAX*i2pF<Y~tRVkJu<XC)tj!9uH6T&W?Im-b_@8(``L
zLY!Q+f6&b^>{G0Kxx3)HJD7V3TPCSCnmW{VPSqP<ZQew`3Dfmvec(F?cF{Y$x=EB;
zfzny7QP;Zt3I|H>P5+qVzdD#}E>ED!TLeIZVK>~sCb6igqU;SJ+a|cD9iW>|3>+A^
zL2l4~*<eT5HsQc;^#X>#Pq`u+m+Ug*jJ7$WSG=fL`ReF8d{HL8tPv$$mz0%#+izX6
z`t-nA+2GLLM&v1vqs4(4mN6D6cV+;8qOd$u>lxRdu?<|S5fpqZZ3xm&AfL$AD$TD0
z)xp{a>6D*n3YmhYtCnjymT13GMJqqy$ShZYnx}LtBs%HM^+z2&wJ83Ix{hbf{dlY*
zEor5vkWV-E$9&H8X=^sqy&@}Flv0+Rk41&RYxDumq+?AU(;44*XQ;8!;Kbj-o|CsN
z;D;XF>vbADg6W6eS?enSK@e260oAQ;D8A(7<OkcHFY8j!1bPEx*M9tQSj#0*>{LTk
zg%|S6-z2M&i5E_1H&S|zhZ0PiQUEF{bTlRz<a}9&%Y`Hs)Bp`0Xv^-+y|vQSUSg7(
zRufx^gW!Gwg;py%>J=HHfsNRCbzeANyJA`zsCi#4)WNI5bJI%uavH7A$%WKN;9Gx-
z5=FKmx$Tqentw0naCDZ?4OBramq=yGPN^Qo5*<L-DL}>0Xn>XCEpqj1NCj|<r}E}?
z?|{%7{O%+4{+H_mvXa8D&p`@Ifa4nV3d<ZYfj!o}+lbQ7eI>xHUUy)9F=#-)cDRVj
znb-XjvFz2*R6iq6G7$tp#Pv!E@B0)V$KZtX9t2<D-p2{=e^sH=$ED51-=Lic%}#+p
zp@77XdOQXG`krkcu=wM)ni{k7;w@d_<q|(2rI0UVv>9OJ3A90N=@ak2<M0P05Ks#*
zX~-iRkvCtwpJ(9ux+x6k8A<?d4MXTO-T>;lzO(k3uho1Hj8$vSQh_q8i--q>hd<B)
zv;6gw0ytv%PeV(6s5(IixQ<AE^16fQ`Bug*o)=+zo%B4<wBbD#==pyYeWSk$RJ&EM
zR4Cu%KW{ZK2zK#Yc?{WNC0?}WCB97St!yUo3&63cd3zfnQX$y$F3jgJF@Sl5b?<0V
z<TEgi<+JC$jQ@($R>D5Oa}GJ4>PSeUkSDnNq^h@hpk;+US=-5)d&6Q@U|hRf(^_XZ
zHTTz43DFTZi;D#6d)dk-;tf%PyrdSyl5c!UJo~g2pi#MFl?Gn;GF37N=;WIE>Hy?q
zjAI;4^@9iV_1%BB*{mq;DA<YGHm7=jlaB!GH5rI+Go7-7lV{FO_keup-&xkS)T(a^
zQQZmGM{;Hx1IfQ~mt-7V85R-UlkU+FhXUov>pR6E_s=(7JGZVbg(3L28X%|>b;Mf|
zB?lA}%7fQXZv)pGNOcDwM;ZP1+ih{bG_|o8Qd85kUMvtu3l4!J$gdP!2R6R(ef`F7
z6M@?no}b6Ve8{CGs}#%|eE>P*MWd4}@{^=C0^XOhHWMjVTaVU3)<Ihx4ceSBrWXmZ
zn(d78sDgX|qi|NOKX*EqLyRYRRtk3%%wQq_oV-RJAWT_+q&hoEcL8~CPKT}-oB0DE
zl4R7HQUhe^_tifd@A;qkrX>P33d=`RLQS7JiTCl2Nh$N99RQ+ErUF(<t%G-l@4c0a
ze@?GZu%Ij+^fPkIB}LSVP=Y5UKlkNI5;V3-0=k|;43GV-zgYt3nsna8a@K7VRnxi=
zveyK1X*<~k_M&w`If_M;+`cDK(B&iCYP;3DqKpx+lG|<dDwg>Ak|e;y^GJyVO`wm%
zaw0)rxqGs~n{0I9tj=%ou4$4Vdsmx^r3=$Um?!pP^qprk@DJfuiOh&wGzfvf2YoL(
zZj9cO`lq)P6OYAwe0!^#Ex`a`jd&<Bm<myVB#@=NcF@H!(==TdxqOFX@8+|cAP{3R
z>Hh_wbkX9a5#!x`xaWQ<w|CjHF*hY}1NfJ%KP;H696ay^zo>kYwb$&lI?BB_QG;Ry
zF$&!Ks#)UFEmD{NPzfY74DsHJ#<5^b?kID~0m*%>AC^r|)_!L1<r(Y0HTOBG#$e4C
z=bOkRg=MP{k`rmMbMw!+PcOHfflet4$hc|Vs{i@g*8?Z;x_a*Qe18gqMOwJ)?5s~U
zg|BNC&4e7eW<6cFLVB>Xv$M&#umM_ZK2o^sU32sCW=MI<F8j(zxzowv&gytg6ac%3
zsV2XwhaEIoL4V+{=(&LHHrgK_Y3=O3o;~T1e0UgOT58!rD7Ctx;B#X!J5(7k45z+S
zZnMf_zBHO!N=e$Tfo*NEA~!LRKLk#m>+TQP3$rq&vBh@eqPUlcC#Jt|V$7(5Kx`}u
zz)~evR#zVZV@HHe83_gh@^P%vfts0_nS_5E<yu5PJ7OTKKT5pyE1**J93A;5>fD`x
z7(D1`Vn(@n#>%~=!>{!(ms{%rf;(vQZhCrpL3z2;r)QMS`?FET#>N${6EdW<TJzJt
zk5Q=GLYm&*k|}l}^1`Mi?;0D^fr$T>%jiwFwv#98^>Z-}C!UfWjRgzkOwS%`6iwOm
zF8O|$+DjV~4_C)Mw7*N#f<mF{j=jmE5$<;=M%zL|>pB7s{>)d`)KuDkBG*$`!iw=&
zRUzo?PL|EmZp&UdD=sX|DJ*;~@4c`&WTao|G{CJ9&91JlPU$!0%L;7!BFD@=m3!-f
zfKH0o{OQq#)BfhqJ0EGfKfk0!Iy=wiL~zf(j}lV|dOKnp7_A<~vXxXG^fF5Pv{!)=
zsIp!3n+cZPXdWz%fG>ErE3ivM8|w^&T=D^>q>lam{s0D}(c<Vf`KF^r9sk+)*9~bL
zP@f4LQjVbKnw4!kpquNAUNJ;Sk~a7ytL^CgUQtm|s*Ef9`nPYHx0`}iff-Zc`pldC
zw|=V9-F*7z5s*5hx#QsAkTTG;TvYtn)zxu#^@G_Jy<Ed!i+JqieWbe|OVToixGqlC
zMnwglq2bhoVeRV!^P5H*j!tr_w0`#VC44ilbK_c{p5I$uUcM=rEMoEb_4O?OAry%t
z81>}HwDJ;MW?C~fxu3o`IobnzY!W|-9Wk&c8dpa~(f~7z31|WOXThAOL1B4$0$HJ_
zPX+Yej;=jN3g~C`l~}ac{$7avozbuS8gUrGIoQwlK_Vq%Y;P*~tWx<d3<kr<_ke)5
z7DwRNfc)somGZVMlI)xG?AqF&i>(4qXuWAeStEvXY;I+Bswu^!*mP^uA@;t7MK@5z
zEG#K`1Zex}+TFE~7GOSC1%F@RkaeRVCK~B2t?+EM0Cx)sC24c9{ifY%pR($6;UjiU
zHfR+Xr(E!xaX~PE?LcL~|DGX-`DK3iLi#OQ&m0Q9_DFk&R5||r<AX)5%M}!%<iXMI
z+P!qC*8uUyc0{qZZJ<bsxWuw1vbel8y|Gb&ib0Q?#}lZMIEpUzinm?j<0XLO{;FpF
zT<>pC)=*YA0=jnTaZ`&gz8T^|v>J^w#@ZT=vc8A&)lHu4e7^!PL|W6|9^rBWQ`1gT
zDy77tDpeZAl9`zqk^h*p7f7~z>PZrY=NeiEAlDJbkCG2jE-u&)A3jV7UhRsjQ|0=Q
zx?nt@=Z**a+3DP>JLDr?51&J$(M-)?YWnZf)8D@5s5KpjxYJ7GYF)d@**9!v8mp=j
zQfvc|xGR#%yOpsLkH24~=T`g*40Ck2Bs2tOGAc}-K496Dx!KkCjh0IT#>Xeg;ezl*
zJaPXmVwif%NTspqprTIs@JB3pMZk{pwErC4RlyZf%{y>!o$_5vOH1z}r-IJ~VyX_2
z>tO502Te&QJ+Duv-)?VUb8>zboW#C;9!$Z!EP@7ru^rPSn>NOvmG^AY4UsT)GWERy
z1|t{bZRi=J>7#wCPV>Dr_$VwqX<0vLmhr7uk07U<N7z8<>EC;)H^XCM=-ryPG)OpM
z=iqn><WER_0SN-S55K&kQ#}0r;f`TC;NdiUeWiiGVE2Cc$!A*e&CM?iK*+FYU}Dmd
zWM&HocqnxL3y*pAV+fEjBXLn}tqh^ehSVo;u<q9u_)Dk2!0ENNFY-{Z+o88OTsS=Y
zWi&4o3hV{%u-dCjOM9rqq@*n%A57W~fRDR?3`GOLdV<2j4&&8GV-u76!13nkX2|_t
zU0i!S)9W8M*Gw}b4w-03)=6_|Y1G1&xh5?&lI5&%MmLw%g-pm$Y0ITqs%ewyLYBf#
z+9{n{jg}~W$L*X-DC3Bzq2Dv-^}Ft$?;m@f?ely-@6Y@Fc|PCg`~9qNKdNf{plM9K
ziDufULZhOrqweh=4X=Iz8iDn1c0a%3lXYaOa|hs@it6h8iHRgle=nkDck4*!^`AlL
z8yk6KG%+Lu25$VXcl(FFwmHLnmBC@iYSl(;|C1Mb$H#C5kDn=!vfkAxC9zccWu0aE
zeOfD84jbG;Zrn3!zkbj5!HJzP7|f5gdqZWA5FWWrO#aRfUUPvm_<jF%>4(Xk;g;Wy
zHAmLb3<14@K3*FYWa#?f5~elF$oEXxlbQM-UR@k%91c15Yp*RNLfclWq>R^Wl~>4_
zRT~@G5D3DZdpB3Bo6e?W8bwz9WF8_8#Urk}q?|=1>nRt{ZWwQsQ9$}bLo3M-)cZZ|
z*^0wHum{Pd7-q&}#UP|m8}A`mtJ-agD`k_G)pK^e|Fp=40DU$4^|RH+G|$e?PQg`L
z7BtmZOfL0gW+)UV7Vm=pxTQvaB14dz$9|V3WokD)bKcN2aMH-v|7i(zonuLUd}YQ{
zRvP?>g(bWP;aLC@gtntH?12T2bV_<p%RbXpAfXim)(@yg9ZK>2+Jn4q^Gy2y3*nZX
zk1`Pg36MvOwR7!4TC1AZq?}F6s|2U`Z}K`%wQar8lWtIpnS1Wl`pIbdXVT#Y^+(nG
z<{=~sW!kctyS_tjN7YYDLd5!m*VYX?F=O<5NE6w&WBA>Td(85{597h|DZ!%1I$7^`
zD{!Y6apb9@Z4okn;1H)stmSp`y6*!6XdGxNs88C<b7X!pv23h0I5~;v5V2R5NR1e>
zLs2SxZP<bJ$j7~2q(0hfh^_uISN9FYTR<>s%|irONs@a4R#N`=DpQ{K!XYubmkcVk
z5<Fs~cg1?|$zziW^DD!yS;<Gp#eytaP%u10Y-nSLRn1rP(xEd429N^*?&>1xm@zWs
zm{amY1`Gt6kW}3TO)aXh5+9z9WY)mS?ZJ4r@qjB3Pn{#r6m3v`AQ;q+75GM*R5*8X
zy;SpPjLlA+(<`iQUqX5mu}O#TaJ*+n+Lb<pZ+pxzemPB;DsoUwgE~qUmsu=};V5p;
zhj)=tD4n;ea@Fn+s_EP|RJ;FDfeQxsB4PN+?hLCcy-@uV33R-x<ig+}i0qQ4V8MyC
zDd*+`nfV;q1tq19D2n{n((Bc8U%x>=-k>?ajj;ip=ytTmatq-6@Yx*Pqh5Y*ddv{A
z+cZRsl|;H<hm~I?H>e+IXBc@vGGMbW74t5M=%Y1V8j)~xDFdt<AGj8SzaMa^L5-uj
zja$mSKlbyxL+FRox@e#>dAU{Ka?rJyVQ6>X?P(l~PkK$9Usfwu&~;%eQ0+!^Y?oq0
z@u^QqA@t=!QxRd}5=c=0h76s98*9xyjb?1!)y2GW3y+KJr|MNYbRCJW0b=-9I=QOg
zWMDn*j1&(^yGXm!q}QO^MW^q$z|(^{frX@D&)@K~iT=M}(~70{8r5(XgZqRJH#lKD
zTf>X4N-D>@UaBP!0!epraIGxFroBUU-KN{bw*n4?YxSh(N;Asd1?+8gu<v?cPjP&Q
zD*pHjTb1pI3P;7R>DZcINtPbJDSdOQZFzL#ahq`jcj^W|Gnr+;g3-V1ElxlnI4;0e
zvWF-VS}L_ons$`sW+r6f!E2>fvGBZZJdd||8_^*f%U#7NJ!OnK2~FJ!H0PH?)6AZ^
zIEVM&7*se00-Au`ie<rDU{*-CYwV)4lOx1b)rkxsK@)eL`ExWAlBX@04`7xCX@)xu
zJ;(L9;^oI%KSj8!h0wcfb`dLB&}WMyH8&hL!kAi`;ezf0Y++P=D%JO4)eqWNSsz(v
zKq{@3naO<I)oa|<CA<(<_qofXq6J_ej-54K)nTRT`=nC)et25)*4N;vh5L2AgVWC+
zuHeicoSu{2l-;C%ImBIi3m;PF(I3}tErYm6!928nZ;!evz4rm1`bYBgpho0{{x3KR
zflH&WjeYX8(yH#EhM()p2n5jK!ss;E-9Ix*zsJn9nHAB-bo#XWg1;Ym_o82Zbg2F9
z)YR00D-WXN&9BMmwJnNM*~X~9Kw+Kx&@)CH=D(th!^qqAtxh>Hd5V{w{qE4vdD8x*
zi&_^$C*mh1ES}HFlDiSqokJ$3PVUzF$i?M;6-mBBT2*2G0iwwKeCe2-Rq;lJB2>4{
z!MQ6=+g2BStn1V{?<K^#YmO;ed67=?&TG3|2RyiZQH=bLLj*T+mAxo@HSq;t5bJin
zu2QMI^87Q`Of|n^eHuFc7(?#0i7!pKKWl0-lP2;lr_<ldT&_IseWHK%yg9lP#mWCm
z1EUslmDG)@D_`<(Wed4F!PmgV8S}Cn05ZP_nrg__;A`K|VvtCvvD<p)BV3aZG1zPm
z=VGZYN(7Eg2*_#5t|Aw(N%ExW&?_z}#(CkDVF}xLrh@R*U=lYP-SK2VwVICQ($+s;
z2}Tmo;EX$)ga{L;9GM4<%a`*3AJHR>22`avA*gWAST8_<OFYd-OtC9dSU;9s?gPX{
zm<Y*fYI#hqCK3qWS`_+xN;$9B8dtDntvO>WFo?sA&{ycwbBs~Mk6Wt3jKKQ9XKu=g
z+5}DQ=TRDYYx&)6fPfs!tj&qSRsYuMgGdCYt11kB8e-3St@NpLtPGDf!?8%2c?(Hq
zN3MFm@?{Z2!>F1<x#HUTj`o}Jf%O`-xC2SfJgf8(uB1Vyn!$DafBfJKMR!azFIY_I
zy9`Y&X*^!QJEQBJQj!QP&Le{(_y~^H-3s4wGgTiF=Z9S=P%UJ=YmE2=;lY-}4^0tr
z$xVmrX;op*T^~=5mwp`%0VdF{kgG&nVi#7J9!t+^z0syn!ODryd}#e7Ph(k8of{R4
zS(ReqY>Dn@U-P#w49!QpUH_v!K_2VS`J^562;)!Mkv-{&1D+^UPG}D9!D36uom0l#
z)vm=OWl9JE8l0lB6Zx|4s2laa9FgCK<@(-qB<<Y<qNj1SGBimfu}?8EjJ1{*!Oa;~
zm|_M3;Y?BWK{^0C`Ba4kMTh}T*d*~*fpLwwrNI$EbQR&NO`VwsTqT@$AF`)h<nKS%
zc_V`YbNAO3?~3=&!Fe*7)Ht99H2G!m43Dy!C5^Gb=8=A8#K(7OT{Oex65bD!(NpUL
zer)#SW}uWj02hbT{=Nq1hP;>JSZvY(4QL#0jOm;a_>nxY5d5<#p9L{5>t2(T{v#qU
zD)<$Cp+vLbgm)^H7-)mh%q~D}9VZOZz`lL-#Z;yuanZQ3azy2ql<tklD+NBLMf>?Z
zB2dxe0wqNl@2S-F<_C%{y?EoZy_)zCBT1rq$=~!*1fOYHf%PO|yVH&6O$E|I7}8&8
z2b_?Nc>88|aL`C+wy|9}b+Kh;33zKALf!~)rJ-^=4R%G&Wts$PhmSh!z<B}H;rwaQ
zdXa$`M*sGe0qU7t%l@k#3n_;B`WkxLp7PZRx)k8*0&lyv3eaR60)fb*c!0;=7?7U1
zy4nCu7705*j@O3*jIi0dt}9c(WA~h}e|ZB;;rv<2S%{kJtxa~QJ@LXw&8&%Mif65f
z*LeHj<&IHzgqKJ{#SLVa-kk<@m+TPu{wz&q$rVjim;lu>wAmz-Sz=BuY~oNk=(6xp
zRlNY5_5p$a8K@Niz@(p-ytoY{4nf#Jlzhu&r--)0fNf!qXO@XHe-B)7FM^6RX&t(?
zxtfUDOXqoA@9kygw1Gn3R1*Ih6b1>3L?Fw{a0R60<1L})U=pXNppvX}S+99fFkDj)
z<rf0k#$~aW)LaOhdNx^z$4KD%A;7W3M~YCaq+fdq{TkI6M|a9@J7)yIepzP=<SMI`
z{so@-nf<QV@i%_=dwPTwu8@Q{YCU6uS=vRTgAT$48IMrGJyH0rmN#c#`$|!n(^j-k
zlNV#UgW82U_L&7uzrRpel<}C7x#OHq85Fqs4deTXQT(;sxsUn#GOm~%fdGIJnd*Y4
zFMICmTp+q(+_h)S<^1`Zy`u-{Z@!GDMl#etJXg~NqcQPgSx37szuUktIJoZMQcR6>
zu7E-g8fiR!p4Y0?Z2SpU?(e{&Q#XuLLE-thrI*R?J}UDaNS1ZTIE2{AxB&`PB<(lD
d1>c>+Z<ScfO!q0K!0SD=0*Il6TfWqj{{$C);ZXnp

literal 0
HcmV?d00001

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index 65266fb4eb..c013fcd4a0 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -58,40 +58,27 @@ Reduced Channels
 As an example of tensor contraction, we now consider the map $S(\rho) = \Tr_2[\cnot (\rho \otimes \ket{0}\bra{0}) \cnot^\dagger]$.
 We can think of the $\cnot$ here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state $\rho_{\text{anc}}$, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of [Wood diagrams](http://arxiv.org/abs/1111.6950), this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
 
-# TODO: add images
-![](images/sprep-wood-diagram.png)
+.. figure:: figures/sprep-wood-diagram.png
+   :align: center
+   :width: 2.5in
 
 
 The two tensor wires on the left indicate where we must take a tensor contraction to obtain the measurement map. Numbering the tensor wires from 0 to 3, this corresponds to a ``tensor_contract`` argument of ``(1, 3)``.
 
-```python
-s_meas = qt.tensor_contract(qt.to_super(qt.identity([2, 2])), (1, 3))
-s_meas
-```
+>>> tensor_contract(to_super(identity([2, 2])), (1, 3)) # doctest: +SKIP
 
 Meanwhile, the ``super_tensor`` function implements the swap on the right, such that we can quickly find the preparation map.
 
-```python
-q = qt.tensor(qt.identity(2), qt.basis(2))
-s_prep = qt.sprepost(q, q.dag())
-s_prep
-```
+>>> q = tensor(identity(2), basis(2)) # doctest: +SKIP
+>>> s_prep = sprepost(q, q.dag()) # doctest: +SKIP
 
 For a $\cnot$ system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary $\cnot$ channel:
 
-```python
-qt.visualization.hinton(qt.to_super(cnot()));
-```
+>>> visualization.hinton(to_super(cnot())); # doctest: +SKIP
 
 We now complete by multiplying the superunitary $\cnot$ by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
 
-```python
-qt.tensor_contract(qt.to_super(cnot()), (1, 3)) * s_prep
-```
+>>> tensor_contract(to_super(cnot()), (1, 3)) * s_prep # doctest: +SKIP
+>>> visualization.hinton(tensor_contract(to_super(cnot()), (1, 3)) * s_prep); # doctest: +SKIP
 
-```python
-qt.visualization.hinton(qt.tensor_contract(
-                            qt.to_super(cnot()), (1, 3)) * s_prep
-                        );
-```
 

From 2f3ffb9d45024a6217495e0d0626a143bde8e0c8 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Wed, 24 Aug 2022 08:44:38 +0200
Subject: [PATCH 003/602] insert guide to toctree

---
 doc/guide/guide-super.rst | 6 +++---
 doc/guide/guide.rst       | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index c013fcd4a0..f01f071268 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -1,4 +1,4 @@
-.. _steady:
+.. _super:
 
 *****************************************************
 Superoperators, Pauli Basis and Channel Contraction
@@ -14,7 +14,7 @@ $\newcommand{\Tr}{\operatorname{Tr}}$
 
 In this guide, we will demonstrate the ``tensor_contract`` function, which contracts one or more pairs of indices of a Qobj. This functionality can be used to find rectangular superoperators that implement the partial trace channel $S(\rho) = \Tr_2(\rho)$, for instance. Using this functionality, we can quickly turn a system-environment representation of an open quantum process into a superoperator representation.
 
-.. _steady-representation-plotting:
+.. _super-representation-plotting:
 
 Superoperator Representations and Plotting
 ==========================================
@@ -50,7 +50,7 @@ As a couple more examples, we also consider the supermatrix for a Hadamard trans
 
 >>> visualization.hinton(to_super(tensor(sigmaz(), hadamard_transform()))); # doctest: +SKIP
 
-.. _steady-reduced-channels:
+.. _super-reduced-channels:
 
 Reduced Channels
 ================
diff --git a/doc/guide/guide.rst b/doc/guide/guide.rst
index 751e95f318..c6d9751775 100644
--- a/doc/guide/guide.rst
+++ b/doc/guide/guide.rst
@@ -11,6 +11,7 @@ Users Guide
    guide-basics.rst
    guide-states.rst
    guide-tensor.rst
+   guide-super.rst
    guide-dynamics.rst
    guide-heom.rst
    guide-steady.rst

From a965c0c1facc8c297397ede30590d3f23e5981c0 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Wed, 24 Aug 2022 22:02:57 +0200
Subject: [PATCH 004/602] add plot environment, update links and equations

---
 doc/guide/guide-super.rst | 54 ++++++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index f01f071268..5a11e9771f 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -3,16 +3,15 @@
 *****************************************************
 Superoperators, Pauli Basis and Channel Contraction
 *****************************************************
+written by `Christopher Granade <http://www.cgranade.com>`, Institute for Quantum Computing
 
-[Christopher Granade](http://www.cgranade.com/) <br>
-Institute for Quantum Computing
+.. math::
+    \newcommand{\ket}[1]{\left|#1\right\rangle}
+    \newcommand{\bra}[1]{\left\langle#1\right|}
+    \newcommand{\cnot}{{\scriptstyle \rm CNOT}}
+    \newcommand{\Tr}{\operatorname{Tr}}
 
-$\newcommand{\ket}[1]{\left|#1\right\rangle}$
-$\newcommand{\bra}[1]{\left\langle#1\right|}$
-$\newcommand{\cnot}{{\scriptstyle \rm CNOT}}$
-$\newcommand{\Tr}{\operatorname{Tr}}$
-
-In this guide, we will demonstrate the ``tensor_contract`` function, which contracts one or more pairs of indices of a Qobj. This functionality can be used to find rectangular superoperators that implement the partial trace channel $S(\rho) = \Tr_2(\rho)$, for instance. Using this functionality, we can quickly turn a system-environment representation of an open quantum process into a superoperator representation.
+In this guide, we will demonstrate the :func:`tensor_contract` function, which contracts one or more pairs of indices of a Qobj. This functionality can be used to find rectangular superoperators that implement the partial trace channel :math:S(\rho) = \Tr_2(\rho)`, for instance. Using this functionality, we can quickly turn a system-environment representation of an open quantum process into a superoperator representation.
 
 .. _super-representation-plotting:
 
@@ -23,31 +22,32 @@ Superoperator Representations and Plotting
 We start off by first demonstrating plotting of superoperators, as this will be useful to us in visualizing the results of a contracted channel.
 
 
-In particular, we will use Hinton diagrams as implemented by [``qutip.visualization.hinton``](https://qutip.org/docs/latest/apidoc/functions.html#qutip.visualization.hinton), which
+In particular, we will use Hinton diagrams as implemented by :func:`qutip.visualization.hinton`, which
 show the real parts of matrix elements as squares whose size and color both correspond to the magnitude of each element. To illustrate, we first plot a few density operators.
 
+.. plot::
+   :context:
 
 >>> visualization.hinton(identity([2, 3]).unit()); # doctest: +SKIP
-
-
 >>> visualization.hinton(Qobj([[1, 0.5], [0.5, 1]]).unit()); # doctest: +SKIP
 
 
 We show superoperators as matrices in the *Pauli basis*, such that any Hermicity-preserving map is represented by a real-valued matrix. This is especially convienent for use with Hinton diagrams, as the plot thus carries complete information about the channel.
 
-As an example, conjugation by $\sigma_z$ leaves $\mathbb{1}$ and $\sigma_z$ invariant, but flips the sign of $\sigma_x$ and $\sigma_y$. This is indicated in Hinton diagrams by a negative-valued square for the sign change and a positive-valued square for a +1 sign.
+As an example, conjugation by :math:`\sigma_z` leaves :math:`\mathbb{1}` and :math:`\sigma_z` invariant, but flips the sign of :math:`\sigma_x` and :math:`\sigma_y`. This is indicated in Hinton diagrams by a negative-valued square for the sign change and a positive-valued square for a +1 sign.
 
+.. plot::
+   :context:
 
 >>> visualization.hinton(to_super(sigmaz())); # doctest: +SKIP
 
 
-As a couple more examples, we also consider the supermatrix for a Hadamard transform and for $\sigma_z \otimes H$.
+As a couple more examples, we also consider the supermatrix for a Hadamard transform and for :math:`\sigma_z \otimes H`.
 
+.. plot::
+   :context:
 
 >>> visualization.hinton(to_super(hadamard_transform())); # doctest: +SKIP
-
-
-
 >>> visualization.hinton(to_super(tensor(sigmaz(), hadamard_transform()))); # doctest: +SKIP
 
 .. _super-reduced-channels:
@@ -55,30 +55,38 @@ As a couple more examples, we also consider the supermatrix for a Hadamard trans
 Reduced Channels
 ================
 
-As an example of tensor contraction, we now consider the map $S(\rho) = \Tr_2[\cnot (\rho \otimes \ket{0}\bra{0}) \cnot^\dagger]$.
-We can think of the $\cnot$ here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state $\rho_{\text{anc}}$, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of [Wood diagrams](http://arxiv.org/abs/1111.6950), this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
+As an example of tensor contraction, we now consider the map :math:`S(\rho) = \Tr_2[\cnot (\rho \otimes \ket{0}\bra{0}) \cnot^\dagger]`.
+We can think of the :math:`\cnot` here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state :math:`\rho_{\text{anc}}`, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of `Wood diagrams <http://arxiv.org/abs/1111.6950>`, this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
 
 .. figure:: figures/sprep-wood-diagram.png
    :align: center
    :width: 2.5in
 
 
-The two tensor wires on the left indicate where we must take a tensor contraction to obtain the measurement map. Numbering the tensor wires from 0 to 3, this corresponds to a ``tensor_contract`` argument of ``(1, 3)``.
+The two tensor wires on the left indicate where we must take a tensor contraction to obtain the measurement map. Numbering the tensor wires from 0 to 3, this corresponds to a :func:`tensor_contract` argument of ``(1, 3)``.
+
+.. plot::
+   :context:
 
 >>> tensor_contract(to_super(identity([2, 2])), (1, 3)) # doctest: +SKIP
 
-Meanwhile, the ``super_tensor`` function implements the swap on the right, such that we can quickly find the preparation map.
+Meanwhile, the :func:`super_tensor` function implements the swap on the right, such that we can quickly find the preparation map.
 
 >>> q = tensor(identity(2), basis(2)) # doctest: +SKIP
 >>> s_prep = sprepost(q, q.dag()) # doctest: +SKIP
 
-For a $\cnot$ system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary $\cnot$ channel:
+For a :math:`\cnot` system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary :math:`\cnot` channel:
+
+.. plot::
+   :context:
 
 >>> visualization.hinton(to_super(cnot())); # doctest: +SKIP
 
-We now complete by multiplying the superunitary $\cnot$ by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
+We now complete by multiplying the superunitary :math:`\cnot` by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
+
+.. plot::
+   :context:
 
->>> tensor_contract(to_super(cnot()), (1, 3)) * s_prep # doctest: +SKIP
 >>> visualization.hinton(tensor_contract(to_super(cnot()), (1, 3)) * s_prep); # doctest: +SKIP
 
 

From 62da2bb292f0897c05b1de71b38b1889bf85ab76 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Wed, 24 Aug 2022 22:22:10 +0200
Subject: [PATCH 005/602] remove redefinitions

---
 doc/guide/guide-super.rst | 2 --
 1 file changed, 2 deletions(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index 5a11e9771f..70700f7b72 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -6,8 +6,6 @@ Superoperators, Pauli Basis and Channel Contraction
 written by `Christopher Granade <http://www.cgranade.com>`, Institute for Quantum Computing
 
 .. math::
-    \newcommand{\ket}[1]{\left|#1\right\rangle}
-    \newcommand{\bra}[1]{\left\langle#1\right|}
     \newcommand{\cnot}{{\scriptstyle \rm CNOT}}
     \newcommand{\Tr}{\operatorname{Tr}}
 

From 90bf7b567eb0ee6136969421d9f7f25a4eee3542 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Wed, 24 Aug 2022 23:42:25 +0200
Subject: [PATCH 006/602] remove Tr definition

---
 doc/guide/guide-super.rst | 1 -
 1 file changed, 1 deletion(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index 70700f7b72..bedc31c837 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -7,7 +7,6 @@ written by `Christopher Granade <http://www.cgranade.com>`, Institute for Quantu
 
 .. math::
     \newcommand{\cnot}{{\scriptstyle \rm CNOT}}
-    \newcommand{\Tr}{\operatorname{Tr}}
 
 In this guide, we will demonstrate the :func:`tensor_contract` function, which contracts one or more pairs of indices of a Qobj. This functionality can be used to find rectangular superoperators that implement the partial trace channel :math:S(\rho) = \Tr_2(\rho)`, for instance. Using this functionality, we can quickly turn a system-environment representation of an open quantum process into a superoperator representation.
 

From 89764a1eb282f8c4ad790f18e29cc67d6f5d429d Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Thu, 25 Aug 2022 08:16:52 +0200
Subject: [PATCH 007/602] fix math section

---
 doc/guide/guide-super.rst | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index bedc31c837..5e0d288ea9 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -52,7 +52,11 @@ As a couple more examples, we also consider the supermatrix for a Hadamard trans
 Reduced Channels
 ================
 
-As an example of tensor contraction, we now consider the map :math:`S(\rho) = \Tr_2[\cnot (\rho \otimes \ket{0}\bra{0}) \cnot^\dagger]`.
+As an example of tensor contraction, we now consider the map
+
+.. math::
+    S(\rho)=\Tr_2[\cnot (\rho\otimes \ket{0}\bra{0}) \cnot^\dagger]
+
 We can think of the :math:`\cnot` here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state :math:`\rho_{\text{anc}}`, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of `Wood diagrams <http://arxiv.org/abs/1111.6950>`, this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
 
 .. figure:: figures/sprep-wood-diagram.png

From 1ded22f6ba931089a588cadef01bad2e3e5be2d2 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Thu, 25 Aug 2022 09:04:40 +0200
Subject: [PATCH 008/602] replace cnot definition

---
 doc/guide/guide-super.rst | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index 5e0d288ea9..1886488e13 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -5,8 +5,6 @@ Superoperators, Pauli Basis and Channel Contraction
 *****************************************************
 written by `Christopher Granade <http://www.cgranade.com>`, Institute for Quantum Computing
 
-.. math::
-    \newcommand{\cnot}{{\scriptstyle \rm CNOT}}
 
 In this guide, we will demonstrate the :func:`tensor_contract` function, which contracts one or more pairs of indices of a Qobj. This functionality can be used to find rectangular superoperators that implement the partial trace channel :math:S(\rho) = \Tr_2(\rho)`, for instance. Using this functionality, we can quickly turn a system-environment representation of an open quantum process into a superoperator representation.
 
@@ -55,9 +53,10 @@ Reduced Channels
 As an example of tensor contraction, we now consider the map
 
 .. math::
-    S(\rho)=\Tr_2[\cnot (\rho\otimes \ket{0}\bra{0}) \cnot^\dagger]
 
-We can think of the :math:`\cnot` here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state :math:`\rho_{\text{anc}}`, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of `Wood diagrams <http://arxiv.org/abs/1111.6950>`, this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
+    S(\rho)=\Tr_2 (\scriptstyle \rm CNOT (\rho \otimes \ket{0}\bra{0}) \scriptstyle \rm CNOT^\dagger)
+
+We can think of the :math:`\scriptstyle \rm CNOT` here as a system-environment representation of an open quantum process, in which an environment register is prepared in a state :math:`\rho_{\text{anc}}`, then a unitary acts jointly on the system of interest and environment. Finally, the environment is traced out, leaving a *channel* on the system alone. In terms of `Wood diagrams <http://arxiv.org/abs/1111.6950>`, this can be represented as the composition of a preparation map, evolution under the system-environment unitary, and then a measurement map.
 
 .. figure:: figures/sprep-wood-diagram.png
    :align: center
@@ -76,14 +75,14 @@ Meanwhile, the :func:`super_tensor` function implements the swap on the right, s
 >>> q = tensor(identity(2), basis(2)) # doctest: +SKIP
 >>> s_prep = sprepost(q, q.dag()) # doctest: +SKIP
 
-For a :math:`\cnot` system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary :math:`\cnot` channel:
+For a :math:`\scriptstyle \rm CNOT` system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary :math:`\scriptstyle \rm CNOT` channel:
 
 .. plot::
    :context:
 
 >>> visualization.hinton(to_super(cnot())); # doctest: +SKIP
 
-We now complete by multiplying the superunitary :math:`\cnot` by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
+We now complete by multiplying the superunitary :math:`\scriptstyle \rm CNOT` by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
 
 .. plot::
    :context:

From a5dade9626fc2347047b37e7015eba841c3f21d9 Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Thu, 25 Aug 2022 10:06:48 +0200
Subject: [PATCH 009/602] add changelog

---
 doc/changes/1984.doc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/1984.doc

diff --git a/doc/changes/1984.doc b/doc/changes/1984.doc
new file mode 100644
index 0000000000..e3fc5ea797
--- /dev/null
+++ b/doc/changes/1984.doc
@@ -0,0 +1 @@
+Add a guide on Superoperators, Pauli Basis and Channel Contraction.

From 9650fcb0a2002c086b6e09ab829775d21ad5e24a Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Fri, 9 Sep 2022 09:14:14 +0200
Subject: [PATCH 010/602] fix plot context

---
 doc/guide/guide-super.rst | 36 ++++++++++++++++++++++++------------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index 1886488e13..c0cc29fe50 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -21,10 +21,12 @@ In particular, we will use Hinton diagrams as implemented by :func:`qutip.visual
 show the real parts of matrix elements as squares whose size and color both correspond to the magnitude of each element. To illustrate, we first plot a few density operators.
 
 .. plot::
-   :context:
+   :context: reset
+
+    from qutip import visualization, identity, Qobj, to_super, sigmaz, tensor, hadamrd_transform, cnot, tensor_contract
 
->>> visualization.hinton(identity([2, 3]).unit()); # doctest: +SKIP
->>> visualization.hinton(Qobj([[1, 0.5], [0.5, 1]]).unit()); # doctest: +SKIP
+    visualization.hinton(identity([2, 3]).unit())
+    visualization.hinton(Qobj([[1, 0.5], [0.5, 1]]).unit())
 
 
 We show superoperators as matrices in the *Pauli basis*, such that any Hermicity-preserving map is represented by a real-valued matrix. This is especially convienent for use with Hinton diagrams, as the plot thus carries complete information about the channel.
@@ -34,7 +36,7 @@ As an example, conjugation by :math:`\sigma_z` leaves :math:`\mathbb{1}` and :ma
 .. plot::
    :context:
 
->>> visualization.hinton(to_super(sigmaz())); # doctest: +SKIP
+    visualization.hinton(to_super(sigmaz()))
 
 
 As a couple more examples, we also consider the supermatrix for a Hadamard transform and for :math:`\sigma_z \otimes H`.
@@ -42,8 +44,8 @@ As a couple more examples, we also consider the supermatrix for a Hadamard trans
 .. plot::
    :context:
 
->>> visualization.hinton(to_super(hadamard_transform())); # doctest: +SKIP
->>> visualization.hinton(to_super(tensor(sigmaz(), hadamard_transform()))); # doctest: +SKIP
+    visualization.hinton(to_super(hadamard_transform()))
+    visualization.hinton(to_super(tensor(sigmaz(), hadamard_transform())))
 
 .. _super-reduced-channels:
 
@@ -67,26 +69,36 @@ The two tensor wires on the left indicate where we must take a tensor contractio
 
 .. plot::
    :context:
-
->>> tensor_contract(to_super(identity([2, 2])), (1, 3)) # doctest: +SKIP
+   :nofigs:
+   tensor_contract(to_super(identity([2, 2])), (1, 3))
 
 Meanwhile, the :func:`super_tensor` function implements the swap on the right, such that we can quickly find the preparation map.
 
->>> q = tensor(identity(2), basis(2)) # doctest: +SKIP
->>> s_prep = sprepost(q, q.dag()) # doctest: +SKIP
+.. plot::
+   :context:
+   :nofigs:
+
+   q = tensor(identity(2), basis(2))
+   s_prep = sprepost(q, q.dag())
 
 For a :math:`\scriptstyle \rm CNOT` system-environment model, the composition of these maps should give us a completely dephasing channel. The channel on both qubits is just the superunitary :math:`\scriptstyle \rm CNOT` channel:
 
 .. plot::
    :context:
 
->>> visualization.hinton(to_super(cnot())); # doctest: +SKIP
+   visualization.hinton(to_super(cnot()))
 
 We now complete by multiplying the superunitary :math:`\scriptstyle \rm CNOT` by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
 
 .. plot::
    :context:
 
->>> visualization.hinton(tensor_contract(to_super(cnot()), (1, 3)) * s_prep); # doctest: +SKIP
+   visualization.hinton(tensor_contract(to_super(cnot()), (1, 3)) * s_prep)
 
 
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
+
+    # reset the context at the end
\ No newline at end of file

From 07a9d1b8768b93cfdcfa151cd02ac45a372b6edf Mon Sep 17 00:00:00 2001
From: christian512 <c.staufe@posteo.net>
Date: Wed, 14 Sep 2022 10:53:29 +0200
Subject: [PATCH 011/602] fix import of hadamard

---
 doc/guide/guide-super.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index c0cc29fe50..d88446d964 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -23,7 +23,7 @@ show the real parts of matrix elements as squares whose size and color both corr
 .. plot::
    :context: reset
 
-    from qutip import visualization, identity, Qobj, to_super, sigmaz, tensor, hadamrd_transform, cnot, tensor_contract
+    from qutip import visualization, identity, Qobj, to_super, sigmaz, tensor, hadamard_transform, cnot, tensor_contract
 
     visualization.hinton(identity([2, 3]).unit())
     visualization.hinton(Qobj([[1, 0.5], [0.5, 1]]).unit())

From b69405e26a1ce7f45a70c8ce6b4bc358303a5fde Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 4 Oct 2022 10:10:37 +0200
Subject: [PATCH 012/602] Add .fermionic flag to bath exponents.

---
 qutip/solver/heom/bofin_baths.py            | 10 ++++++++--
 qutip/tests/solver/heom/test_bofin_baths.py |  5 +++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
index 9dfec1a1d7..4d6f84a1d7 100644
--- a/qutip/solver/heom/bofin_baths.py
+++ b/qutip/solver/heom/bofin_baths.py
@@ -120,15 +120,20 @@ def _check_sigma_bar_k_offset(self, type, offset):
                     " specified for + and - bath exponents"
                 )
 
+    def _type_is_fermionic(self, type):
+        return type in (self.types["+"], self.types["-"])
+
+
     def __init__(
-            self, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None,
-            tag=None,
+            self, type, dim, Q, ck, vk, ck2=None,
+            sigma_bar_k_offset=None, tag=None,
     ):
         if not isinstance(type, self.types):
             type = self.types[type]
         self._check_ck2(type, ck2)
         self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
         self.type = type
+        self.fermionic = self._type_is_fermionic(type)
         self.dim = dim
         self.Q = Q
         self.ck = ck
@@ -145,6 +150,7 @@ def __repr__(self):
             f" Q.dims={dims!r}"
             f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
             f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
+            f" fermionic={self.fermionic!r}"
             f" tag={self.tag!r}>"
         )
 
diff --git a/qutip/tests/solver/heom/test_bofin_baths.py b/qutip/tests/solver/heom/test_bofin_baths.py
index 6900a30933..c6c5c80fc1 100644
--- a/qutip/tests/solver/heom/test_bofin_baths.py
+++ b/qutip/tests/solver/heom/test_bofin_baths.py
@@ -30,6 +30,7 @@ def check_exponent(
 ):
     """ Check the attributes of a BathExponent. """
     assert exp.type is BathExponent.types[type]
+    assert exp.fermionic == (type in ["+", "-"])
     assert exp.dim == dim
     assert exp.Q == Q
     assert exp.ck == pytest.approx(ck)
@@ -98,7 +99,7 @@ def test_repr(self):
         assert repr(exp1) == (
             "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
             " ck=1.0 vk=2.0 ck2=None"
-            " sigma_bar_k_offset=None tag=None>"
+            " sigma_bar_k_offset=None fermionic=False tag=None>"
         )
         exp2 = BathExponent(
             "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
@@ -107,7 +108,7 @@ def test_repr(self):
         assert repr(exp2) == (
             "<BathExponent type=+ dim=None Q.dims=None"
             " ck=1.0 vk=2.0 ck2=None"
-            " sigma_bar_k_offset=-1 tag='bath1'>"
+            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
         )
 
 

From 624e2dde8923456c1e9bfd8ff3e5005e7437616e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 4 Oct 2022 10:12:45 +0200
Subject: [PATCH 013/602] Only sum over fermionic excitations when calculating
 the signs of fermionic previous and next gradient terms.

---
 qutip/solver/heom/bofin_solvers.py | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 23266f40cd..171718a346 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -686,12 +686,6 @@ def _combine_bath_exponents(self, bath):
             exp.type in (exp.types["+"], exp.types["-"])
             for exp in exponents
         )
-        if not (all_bosonic or all_fermionic):
-            raise ValueError(
-                "Bath exponents are currently restricted to being either"
-                " all bosonic or all fermionic, but a mixture of bath"
-                " exponents was given."
-            )
         if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
             raise ValueError(
                 "All bath exponents must have system coupling operators"
@@ -755,11 +749,15 @@ def _grad_prev_bosonic(self, he_n, k):
 
     def _grad_prev_fermionic(self, he_n, k):
         ck = self.ados.ck
+        he_fermionic_n = [
+            i * int(exp.fermionic)
+            for i, exp in zip(he_n, self.ados.exponents)
+        ]
 
-        n_excite = sum(he_n)
+        n_excite = sum(he_fermionic_n)
         sign1 = (-1) ** (n_excite + 1)
 
-        n_excite_before_m = sum(he_n[:k])
+        n_excite_before_m = sum(he_fermionic_n[:k])
         sign2 = (-1) ** (n_excite_before_m)
 
         sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
@@ -807,10 +805,14 @@ def _grad_next_bosonic(self, he_n, k):
         return op
 
     def _grad_next_fermionic(self, he_n, k):
-        n_excite = sum(he_n)
+        he_fermionic_n = [
+            i * int(exp.fermionic)
+            for i, exp in zip(he_n, self.ados.exponents)
+        ]
+        n_excite = sum(he_fermionic_n)
         sign1 = (-1) ** (n_excite + 1)
 
-        n_excite_before_m = sum(he_n[:k])
+        n_excite_before_m = sum(he_fermionic_n[:k])
         sign2 = (-1) ** (n_excite_before_m)
 
         if self.ados.exponents[k].type == BathExponent.types["+"]:

From 8059a4d34ec6c63f1b61c672544660095b1cfc17 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 4 Oct 2022 10:17:52 +0200
Subject: [PATCH 014/602] Add a simple test for a fermionic bath combined with
 a completely decoupled bosonic bath.

---
 qutip/tests/solver/heom/test_bofin_solvers.py | 71 ++++++++++++++++---
 1 file changed, 61 insertions(+), 10 deletions(-)

diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index 21d0f8f7fd..764334ee96 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -348,10 +348,10 @@ def rho(self):
         """ Initial state. """
         return 0.5 * Qobj(np.ones((2, 2)))
 
-    def state_current(self, ado_state):
+    def state_current(self, ado_state, tags=None):
         level_1_aux = [
             (ado_state.extract(label), ado_state.exps(label)[0])
-            for label in ado_state.filter(level=1)
+            for label in ado_state.filter(level=1, tags=tags)
         ]
 
         def exp_sign(exp):
@@ -554,14 +554,6 @@ def test_create_bath_errors(self):
             BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
         ]
 
-        with pytest.raises(ValueError) as err:
-            HEOMSolver(H, Bath(mixed_types), 2)
-        assert str(err.value) == (
-            "Bath exponents are currently restricted to being either all"
-            " bosonic or all fermionic, but a mixture of bath exponents was"
-            " given."
-        )
-
         with pytest.raises(ValueError) as err:
             HEOMSolver(H, Bath(mixed_q_dims), 2)
         assert str(err.value) == (
@@ -813,6 +805,64 @@ def test_discrete_level_model_lorentzian_baths(
         # analytic_current = dlm.analytic_current()
         np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
 
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
+        self, evo, liouvillianize
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+        fermionic_bath = FermionicBath(
+            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
+        )
+        # very weak bosonic coupling which should not affect the dynamics of
+        # the interaction between the system and the fermionic bath:
+        eps = [1e-10] * 5
+        bosonic_Q = sigmax()
+        bosonic_bath = BosonicBath(bosonic_Q, eps, eps, eps, eps, combine=False)
+        # for a single impurity we converge with max_depth = 2
+        # we specify the bosonic bath first to ensure that the test checks
+        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
+        # mode is before the fermionic ones
+        hsolver = HEOMSolver(
+            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
+        )
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
+        analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            current = dlm.state_current(ado_state)
+            analytic_current = dlm.analytic_current()
+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+
+
     @pytest.mark.parametrize(['ado_format'], [
         pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
         pytest.param("numpy", id="numpy"),
@@ -897,6 +947,7 @@ def test_solving_with_step(self):
 
         assert states[-1] == ado_state.extract(0)
 
+
 class TestHeomsolveFunction:
     @pytest.mark.parametrize(['evo'], [
         pytest.param("qobj", id="qobj"),

From 0c55647bdea28a5dc81150aae6c2edf4a0e667e1 Mon Sep 17 00:00:00 2001
From: Eric <eric.giguere@calculquebec.ca>
Date: Tue, 25 Oct 2022 10:18:51 -0400
Subject: [PATCH 015/602] remove coeff type

---
 qutip/core/_brtensor.pyx      |  2 +-
 qutip/core/coefficient.py     | 57 ++++++++++++++------------
 qutip/core/cy/_element.pxd    | 26 ++++++------
 qutip/core/cy/_element.pyx    | 21 +++++++---
 qutip/core/cy/coefficient.pyx | 76 +++++------------------------------
 qutip/core/cy/qobjevo.pyx     | 34 ++++++++++++++--
 6 files changed, 103 insertions(+), 113 deletions(-)

diff --git a/qutip/core/_brtensor.pyx b/qutip/core/_brtensor.pyx
index ee4d3f2e9f..a40952968f 100644
--- a/qutip/core/_brtensor.pyx
+++ b/qutip/core/_brtensor.pyx
@@ -269,7 +269,7 @@ cdef class _BlochRedfieldElement(_BaseElement):
         return Qobj(self.data(t), dims=self.dims, type="super",
                     copy=False, superrep="super")
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         return 1.
 
     cpdef Data data(self, double t):
diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index db9c9fc75e..1119643a67 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -24,7 +24,7 @@
 from .data import Data
 from .cy.coefficient import (
     Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
-    ConjCoefficient, NormCoefficient, ShiftCoefficient
+    ConjCoefficient, NormCoefficient
 )
 
 
@@ -47,8 +47,20 @@ class StringParsingWarning(Warning):
     pass
 
 
+def _return(base, **kwargs):
+    return base
+
+
+coefficient_builders = {
+    Coefficient: _return,
+    np.ndarray: InterCoefficient,
+    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
+    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
+}
+
+
 def coefficient(base, *, tlist=None, args={}, args_ctypes={},
-                order=3, compile_opt=None, function_style=None):
+                order=3, compile_opt=None, function_style=None, **kwargs):
     """Coefficient for time dependent systems.
 
     The coefficients are either a function, a string or a numpy array.
@@ -117,22 +129,20 @@ def f2_t(t, args):
     scipy are converted to a function-based coefficient (the same kind of
     coefficient created from callables).
     """
-    if isinstance(base, Coefficient):
-        return base
-
-    elif isinstance(base, np.ndarray):
-        return InterCoefficient(base, tlist, order)
-
-    elif isinstance(base, scipy.interpolate.PPoly):
-        return InterCoefficient.from_PPoly(base)
-
-    elif isinstance(base, scipy.interpolate.BSpline):
-        return InterCoefficient.from_Bspline(base)
-
-    elif isinstance(base, str):
-        return coeff_from_str(base, args, args_ctypes, compile_opt)
-
-    elif callable(base):
+    kwargs.update({
+        "tlist": tlist,
+        'args': args,
+        'args_ctypes': args_ctypes,
+        'order': order,
+        'compile_opt': compile_opt,
+        'function_style': function_style,
+    })
+
+    for type_ in coefficient_builders:
+        if isinstance(base, type_):
+            return coefficient_builders[type_](base, **kwargs)
+
+    if callable(base):
         op = FunctionCoefficient(base, args.copy(), style=function_style)
         if not isinstance(op(0), numbers.Number):
             raise TypeError("The coefficient function must return a number")
@@ -153,12 +163,6 @@ def conj(coeff):
     return ConjCoefficient(coeff)
 
 
-def shift(coeff, _t0=0):
-    """ return a Coefficient in which t is shifted by _t0.
-    """
-    return ShiftCoefficient(coeff, _t0)
-
-
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 # %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -311,7 +315,7 @@ def proj(x):
     "spe": scipy.special}
 
 
-def coeff_from_str(base, args, args_ctypes, compile_opt=None):
+def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
     """
     Entry point for string based coefficients
     - Test if the string is valid
@@ -359,6 +363,9 @@ def coeff_from_str(base, args, args_ctypes, compile_opt=None):
     return coeff(base, keys, const, args)
 
 
+coefficient_builders[str] = coeff_from_str
+
+
 def try_import(file_name, parsed_in):
     """ Import the compiled coefficient if existing and check for
     name collision.
diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
index 59301e1b7c..85b823a414 100644
--- a/qutip/core/cy/_element.pxd
+++ b/qutip/core/cy/_element.pxd
@@ -8,7 +8,7 @@ from libcpp cimport bool
 cdef class _BaseElement:
     cpdef Data data(self, double t)
     cpdef object qobj(self, double t)
-    cpdef double complex coeff(self, double t) except *
+    cpdef object coeff(self, double t)
     cdef Data matmul_data_t(_BaseElement self, double t, Data state, Data out=?)
 
 
@@ -22,21 +22,21 @@ cdef class _EvoElement(_BaseElement):
 
 
 cdef class _FuncElement(_BaseElement):
-    cdef object _func
-    cdef dict _args
-    cdef tuple _previous
-    cdef bint _f_pythonic
-    cdef set _f_parameters
+    cdef readonly object _func
+    cdef readonly dict _args
+    cdef readonly tuple _previous
+    cdef readonly bint _f_pythonic
+    cdef readonly set _f_parameters
 
 
 cdef class _MapElement(_BaseElement):
-    cdef _FuncElement _base
-    cdef list _transform
-    cdef double complex _coeff
+    cdef readonly _FuncElement _base
+    cdef readonly list _transform
+    cdef readonly double complex _coeff
 
 
 cdef class _ProdElement(_BaseElement):
-    cdef _BaseElement _left
-    cdef _BaseElement _right
-    cdef list _transform
-    cdef bool _conj
+    cdef readonly _BaseElement _left
+    cdef readonly _BaseElement _right
+    cdef readonly list _transform
+    cdef readonly bool _conj
diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
index 8d46d546c8..d1ebba88d8 100644
--- a/qutip/core/cy/_element.pyx
+++ b/qutip/core/cy/_element.pyx
@@ -93,7 +93,7 @@ cdef class _BaseElement:
           "Sub-classes of _BaseElement should implement .qobj(t)."
         )
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         """
         Returns the complex coefficient of the term at time ``t``.
 
@@ -256,6 +256,12 @@ cdef class _BaseElement:
           "Sub-classes of _BaseElement should implement .replace_arguments(t)."
         )
 
+    def __call__(self, t, args=None):
+        if args:
+            cache = []
+            self = self.replace_arguments(args, cache)
+        return self.qobj(t) * self.coeff(t)
+
 
 cdef class _ConstantElement(_BaseElement):
     """
@@ -289,7 +295,7 @@ cdef class _ConstantElement(_BaseElement):
     cpdef object qobj(self, double t):
         return self._qobj
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         return 1.
 
     def linear_map(self, f, anti=False):
@@ -298,6 +304,9 @@ cdef class _ConstantElement(_BaseElement):
     def replace_arguments(self, args, cache=None):
         return self
 
+    def __call__(self, t, args=None):
+        return self._qobj
+
 
 cdef class _EvoElement(_BaseElement):
     """
@@ -339,7 +348,7 @@ cdef class _EvoElement(_BaseElement):
     cpdef object qobj(self, double t):
         return self._qobj
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         return self._coefficient(t)
 
     def linear_map(self, f, anti=False):
@@ -451,7 +460,7 @@ cdef class _FuncElement(_BaseElement):
         self._previous = (t, _qobj)
         return _qobj
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         return 1.
 
     def linear_map(self, f, anti=False):
@@ -523,7 +532,7 @@ cdef class _MapElement(_BaseElement):
             out = func(out)
         return out
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         return self._coeff
 
     def linear_map(self, f, anti=False):
@@ -581,7 +590,7 @@ cdef class _ProdElement(_BaseElement):
             out = func(out)
         return out
 
-    cpdef double complex coeff(self, double t) except *:
+    cpdef object coeff(self, double t):
         cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
         return conj(out) if self._conj else out
 
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 72f031537e..5da2a9815a 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -75,7 +75,7 @@ cdef class Coefficient:
 
     :obj:`Coefficient` are immutable.
     """
-    def __init__(self):
+    def __init__(self, **_):
         raise NotImplementedError("Only sub-classes should be initiated.")
 
     def replace_arguments(self, _args=None, **kwargs):
@@ -121,8 +121,8 @@ cdef class Coefficient:
 
     cdef double complex _call(self, double t) except *:
         """Core computation of the :obj:`Coefficient`."""
-        raise NotImplementedError("All Coefficient sub-classes "
-                                  "should overwrite this.")
+        # All Coefficient sub-classes should overwrite this or __call__
+        return complex(self(t))
 
     def __add__(left, right):
         if (
@@ -155,10 +155,6 @@ cdef class Coefficient:
         """ Return a :obj:`Coefficient` being the norm of this"""
         return NormCoefficient(self)
 
-    def _shift(self):
-        """ Return a :obj:`Coefficient` with a time shift"""
-        return ShiftCoefficient(self, 0)
-
 
 @cython.auto_pickle(True)
 cdef class FunctionCoefficient(Coefficient):
@@ -189,7 +185,7 @@ cdef class FunctionCoefficient(Coefficient):
     _UNSET = object()
 
     def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
-                 _f_parameters=_UNSET):
+                 _f_parameters=_UNSET, **_):
         if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
             if not (_f_pythonic is self._UNSET
                     and _f_parameters is self._UNSET):
@@ -208,7 +204,9 @@ cdef class FunctionCoefficient(Coefficient):
         self._f_pythonic = _f_pythonic
         self._f_parameters = _f_parameters
 
-    cdef complex _call(self, double t) except *:
+    def __call__(self, double t, dict _args=None, **kwargs):
+        if _args is not None or kwargs:
+            return self.replace_arguments(_args, **kwargs)(t)
         if self._f_pythonic:
             return self.func(t, **self.args)
         return self.func(t, self.args)
@@ -325,7 +323,7 @@ cdef class StrFunctionCoefficient(Coefficient):
         "np": np,
         "spe": scipy.special}
 
-    def __init__(self, base, dict args):
+    def __init__(self, base, dict args, **_):
         args2var = "\n".join(["    {} = args['{}']".format(key, key)
                               for key in args])
         code = f"""
@@ -396,7 +394,7 @@ cdef class InterCoefficient(Coefficient):
     cdef complex[:, :] poly
     cdef object np_arrays
 
-    def __init__(self, coeff_arr, tlist, int order):
+    def __init__(self, coeff_arr, tlist, int order, **_):
         tlist = np.array(tlist, dtype=np.float64)
         coeff_arr = np.array(coeff_arr, dtype=np.complex128)
 
@@ -503,11 +501,11 @@ cdef class InterCoefficient(Coefficient):
         return out
 
     @classmethod
-    def from_PPoly(cls, ppoly):
+    def from_PPoly(cls, ppoly, **_):
         return cls.restore(ppoly.x, ppoly.c)
 
     @classmethod
-    def from_Bspline(cls, spline):
+    def from_Bspline(cls, spline, **_):
         tlist = np.unique(spline.t)
         a = np.arange(spline.k+1)
         a[0] = 1
@@ -721,55 +719,3 @@ cdef class NormCoefficient(Coefficient):
     cpdef Coefficient copy(self):
         """Return a copy of the :obj:`Coefficient`."""
         return NormCoefficient(self.base.copy())
-
-
-@cython.auto_pickle(True)
-cdef class ShiftCoefficient(Coefficient):
-    """
-    Introduce a time shift into the :obj:`Coefficient`.
-
-    Used internally within qutip when calculating correlations.
-
-    :obj:ShiftCoefficient is returned by
-    ``qutip.coefficent.shift(Coefficient)``.
-    """
-    cdef Coefficient base
-    cdef double _t0
-
-    def __init__(self, Coefficient base, double _t0):
-        self.base = base
-        self._t0 = _t0
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        if _args:
-            kwargs.update(_args)
-        try:
-            _t0 = kwargs["_t0"]
-            del kwargs["_t0"]
-        except KeyError:
-            _t0 = self._t0
-        return ShiftCoefficient(self.base.replace_arguments(**kwargs), _t0)
-
-    cdef complex _call(self, double t) except *:
-        return self.base._call(t + self._t0)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return ShiftCoefficient(self.base.copy(), self._t0)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 1e3b4a1ae5..724175f523 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -774,6 +774,35 @@ cdef class QobjEvo:
 
         self.elements = cleaned_elements
 
+    def to_list(QobjEvo self):
+        """
+        Restore the QobjEvo to a list form.
+
+        Returns
+        -------
+        list_qevo: list
+            The QobjEvo as a list, element are either :class:`Qobj` for
+            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
+            The original format of the :class:`Coefficient` is not restored.
+            Lastly if the original `QobjEvo` is constructed with an function
+            returning a Qobj, the term is returned as a pair of :class:`Qobj`
+            and args (``dict``).
+        """
+        out = []
+        for element in self.elements:
+            if isinstance(element, _ConstantElement):
+                out.append(element.qobj(0))
+            elif isinstance(element, _EvoElement):
+                coeff = element._coefficient
+                out.append([element.qobj(0), coeff])
+            elif isinstance(element, _FuncElement):
+                func = element._func
+                args = element._args
+                out.append([func, args])
+            else:
+                out.append([element, {}])
+        return out
+
     ###########################################################################
     # properties                                                              #
     ###########################################################################
@@ -855,7 +884,7 @@ cdef class QobjEvo:
         if type(state) is Dense:
             return self._expect_dense(t, state)
         cdef _BaseElement part
-        cdef double complex out = 0., coeff
+        cdef object out = 0.
         cdef Data part_data
         cdef object expect_func
         t = self._prepare(t, state)
@@ -868,9 +897,8 @@ cdef class QobjEvo:
 
         for element in self.elements:
             part = (<_BaseElement> element)
-            coeff = part.coeff(t)
             part_data = part.data(t)
-            out += coeff * expect_func(part_data, state)
+            out += part.coeff(t) * expect_func(part_data, state)
         return out
 
     cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:

From 96930cc1a10d6e5b0c394623cd0dd7b5ddea2a93 Mon Sep 17 00:00:00 2001
From: Eric <eric.giguere@calculquebec.ca>
Date: Fri, 28 Oct 2022 17:36:28 -0400
Subject: [PATCH 016/602] pytree qobjevo

---
 qutip/core/_brtensor.pyx      |  8 +++----
 qutip/core/cy/_element.pxd    |  8 +++----
 qutip/core/cy/_element.pyx    | 40 +++++++++++++++++------------------
 qutip/core/cy/coefficient.pxd |  2 +-
 qutip/core/cy/coefficient.pyx |  8 +++----
 qutip/core/cy/qobjevo.pxd     |  6 +++---
 qutip/core/cy/qobjevo.pyx     | 37 ++++++++++++++++++++++++++------
 7 files changed, 67 insertions(+), 42 deletions(-)

diff --git a/qutip/core/_brtensor.pyx b/qutip/core/_brtensor.pyx
index a40952968f..530cf63d1b 100644
--- a/qutip/core/_brtensor.pyx
+++ b/qutip/core/_brtensor.pyx
@@ -265,14 +265,14 @@ cdef class _BlochRedfieldElement(_BaseElement):
             return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
         raise ValueError('Invalid tensortype')
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         return Qobj(self.data(t), dims=self.dims, type="super",
                     copy=False, superrep="super")
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         return 1.
 
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         cdef size_t i
         cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
         A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
@@ -281,7 +281,7 @@ cdef class _BlochRedfieldElement(_BaseElement):
             return BR_eig
         return self.H.from_eigbasis(t, BR_eig)
 
-    cdef Data matmul_data_t(self, double t, Data state, Data out=None):
+    cdef Data matmul_data_t(self, t, Data state, Data out=None):
         cdef size_t i
         cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
         cdef Data A_eig, BR_eig
diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
index 85b823a414..46f869b266 100644
--- a/qutip/core/cy/_element.pxd
+++ b/qutip/core/cy/_element.pxd
@@ -6,10 +6,10 @@ from qutip.core.data.base cimport idxint
 from libcpp cimport bool
 
 cdef class _BaseElement:
-    cpdef Data data(self, double t)
-    cpdef object qobj(self, double t)
-    cpdef object coeff(self, double t)
-    cdef Data matmul_data_t(_BaseElement self, double t, Data state, Data out=?)
+    cpdef Data data(self, t)
+    cpdef object qobj(self, t)
+    cpdef object coeff(self, t)
+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
 
 
 cdef class _ConstantElement(_BaseElement):
diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
index d1ebba88d8..999d51d06d 100644
--- a/qutip/core/cy/_element.pyx
+++ b/qutip/core/cy/_element.pyx
@@ -55,7 +55,7 @@ cdef class _BaseElement:
       All :obj:`~_BaseElement` instances are immutable and methods that would
       modify an object return a new instance instead.
     """
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         """
         Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
         of the term at time ``t``.
@@ -75,7 +75,7 @@ cdef class _BaseElement:
           "Sub-classes of _BaseElement should implement .data(t)."
         )
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         """
         Returns the :obj:`~Qobj` component of the term at time ``t``.
 
@@ -93,7 +93,7 @@ cdef class _BaseElement:
           "Sub-classes of _BaseElement should implement .qobj(t)."
         )
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         """
         Returns the complex coefficient of the term at time ``t``.
 
@@ -111,7 +111,7 @@ cdef class _BaseElement:
           "Sub-classes of _BaseElement should implement .coeff(t)."
         )
 
-    cdef Data matmul_data_t(_BaseElement self, double t, Data state, Data out=None):
+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
         """
         Possibly in-place multiplication and addition. Multiplies a given state
         by the elemen's value at time ``t`` and adds the result to ``out``.
@@ -289,13 +289,13 @@ cdef class _ConstantElement(_BaseElement):
             )
         return NotImplemented
 
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         return self._qobj.data
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         return self._qobj
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         return 1.
 
     def linear_map(self, f, anti=False):
@@ -342,13 +342,13 @@ cdef class _EvoElement(_BaseElement):
             return NotImplemented
         return _EvoElement(left._qobj * right._qobj, coefficient)
 
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         return self._qobj.data
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         return self._qobj
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         return self._coefficient(t)
 
     def linear_map(self, f, anti=False):
@@ -444,10 +444,10 @@ cdef class _FuncElement(_BaseElement):
     def __matmul__(left, right):
         return _ProdElement(left, right, [])
 
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         return self.qobj(t).data
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         cdef double _t
         cdef object _qobj
         _t, _qobj = self._previous
@@ -460,7 +460,7 @@ cdef class _FuncElement(_BaseElement):
         self._previous = (t, _qobj)
         return _qobj
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         return 1.
 
     def linear_map(self, f, anti=False):
@@ -523,16 +523,16 @@ cdef class _MapElement(_BaseElement):
     def __matmul__(left, right):
         return _ProdElement(left, right, [])
 
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         return self.qobj(t).data
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         out = self._base.qobj(t)
         for func in self._transform:
             out = func(out)
         return out
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         return self._coeff
 
     def linear_map(self, f, anti=False):
@@ -581,20 +581,20 @@ cdef class _ProdElement(_BaseElement):
     def __matmul__(left, right):
         return _ProdElement(left, right, [])
 
-    cpdef Data data(self, double t):
+    cpdef Data data(self, t):
         return self.qobj(t).data
 
-    cpdef object qobj(self, double t):
+    cpdef object qobj(self, t):
         out = self._left.qobj(t) @ self._right.qobj(t)
         for func in self._transform:
             out = func(out)
         return out
 
-    cpdef object coeff(self, double t):
+    cpdef object coeff(self, t):
         cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
         return conj(out) if self._conj else out
 
-    cdef Data matmul_data_t(_ProdElement self, double t, Data state, Data out=None):
+    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
         cdef Data temp
         if not self._transform:
             temp = self._right.matmul_data_t(t, state)
diff --git a/qutip/core/cy/coefficient.pxd b/qutip/core/cy/coefficient.pxd
index d584514839..f81858c2ef 100644
--- a/qutip/core/cy/coefficient.pxd
+++ b/qutip/core/cy/coefficient.pxd
@@ -1,5 +1,5 @@
 #cython: language_level=3
 cdef class Coefficient:
-    cdef dict args
+    cdef readonly dict args
     cdef double complex _call(self, double t) except *
     cpdef Coefficient copy(self)
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 5da2a9815a..2a5367d8f7 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -75,8 +75,8 @@ cdef class Coefficient:
 
     :obj:`Coefficient` are immutable.
     """
-    def __init__(self, **_):
-        raise NotImplementedError("Only sub-classes should be initiated.")
+    def __init__(self, args, **_):
+        self.args = args
 
     def replace_arguments(self, _args=None, **kwargs):
         """
@@ -98,7 +98,7 @@ cdef class Coefficient:
         """
         return self
 
-    def __call__(self, double t, dict _args=None, **kwargs):
+    def __call__(self, t, dict _args=None, **kwargs):
         """
         Return the coefficient value at time `t`.
         Stored arguments can overwriten with `_args` or as keywords parameters.
@@ -204,7 +204,7 @@ cdef class FunctionCoefficient(Coefficient):
         self._f_pythonic = _f_pythonic
         self._f_parameters = _f_parameters
 
-    def __call__(self, double t, dict _args=None, **kwargs):
+    def __call__(self, t, dict _args=None, **kwargs):
         if _args is not None or kwargs:
             return self.replace_arguments(_args, **kwargs)(t)
         if self._f_pythonic:
diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
index d02f3bf18b..44a92e1433 100644
--- a/qutip/core/cy/qobjevo.pxd
+++ b/qutip/core/cy/qobjevo.pxd
@@ -16,10 +16,10 @@ cdef class QobjEvo:
 
     cpdef Data _call(QobjEvo self, double t)
 
-    cdef double _prepare(QobjEvo self, double t, Data state=*)
+    cdef object _prepare(QobjEvo self, object t, Data state=*)
 
-    cpdef double complex expect_data(QobjEvo self, double t, Data state) except *
+    cpdef object expect_data(QobjEvo self, object t, Data state)
 
     cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
 
-    cpdef Data matmul_data(QobjEvo self, double t, Data state, Data out=*)
+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 724175f523..4da9c3ca8b 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -287,6 +287,28 @@ cdef class QobjEvo:
 
         return out
 
+    @classmethod
+    def _retore(cls, elements, dims, shape, type, superrep, flags):
+        # We
+        cdef QobjEvo out = cls.__new__(cls)
+        out.elements = elements
+        out.dims = dims
+        out.shape = shape
+        out.type = type
+        out.superrep = superrep
+        out._issuper, out._isoper, out._shift_dt = flags
+        return out
+
+    def _getstate(self):
+        return {
+            "elements": self.elements,
+            "dims": self.dims,
+            "shape": self.shape,
+            "type": self.type,
+            "superrep": self.superrep,
+            "flags": (self._issuper, self._isoper, self._shift_dt)
+        }
+
     def __call__(self, double t, dict _args=None, **kwargs):
         """
         Get the :class:`~Qobj` at ``t``.
@@ -355,7 +377,7 @@ cdef class QobjEvo:
             )
         return out
 
-    cdef double _prepare(QobjEvo self, double t, Data state=None):
+    cdef object _prepare(QobjEvo self, object t, Data state=None):
         """ Precomputation before computing getting the element at `t`"""
         return t + self._shift_dt
 
@@ -837,7 +859,7 @@ cdef class QobjEvo:
     ###########################################################################
     # operation methods                                                       #
     ###########################################################################
-    def expect(QobjEvo self, double t, state):
+    def expect(QobjEvo self, object t, state, check_real=True):
         """
         Expectation value of this operator at time ``t`` with the state.
 
@@ -870,11 +892,14 @@ cdef class QobjEvo:
             raise ValueError("incompatible dimensions " + str(self.dims) +
                              ", " + str(state.dims))
         out = self.expect_data(t, state.data)
-        if out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol):
+        if (
+            check_real and
+            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
+        ):
             return out.real
         return out
 
-    cpdef double complex expect_data(QobjEvo self, double t, Data state) except *:
+    cpdef object expect_data(QobjEvo self, object t, Data state):
         """
         Expectation is defined as ``state.adjoint() @ self @ state`` if
         ``state`` is a vector, or ``state`` is an operator and ``self`` is a
@@ -930,7 +955,7 @@ cdef class QobjEvo:
                 out += coeff * expect_data_dense(part_data, state)
         return out
 
-    def matmul(self, double t, state):
+    def matmul(self, t, state):
         """
         Product of this operator at time ``t`` to the state.
         ``self(t) @ state``
@@ -959,7 +984,7 @@ cdef class QobjEvo:
                     copy=False
                    )
 
-    cpdef Data matmul_data(QobjEvo self, double t, Data state, Data out=None):
+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
         """Compute ``out += self(t) @ state``"""
         cdef _BaseElement part
         t = self._prepare(t, state)

From 770af7c371010b27e9267e4d61097e43e5a50fde Mon Sep 17 00:00:00 2001
From: Eric <eric.giguere@calculquebec.ca>
Date: Tue, 1 Nov 2022 09:58:18 -0400
Subject: [PATCH 017/602] default data layer options

---
 qutip/core/cy/coefficient.pyx        | 56 ++++++++++++++++++++++++++++
 qutip/core/data/convert.pyx          | 14 ++++++-
 qutip/core/operators.py              | 52 +++++++++++++-------------
 qutip/core/options.py                |  9 +++++
 qutip/core/states.py                 | 55 +++++++++++++++------------
 qutip/random_objects.py              | 21 +++++++----
 qutip/tests/core/test_coefficient.py |  2 +-
 7 files changed, 150 insertions(+), 59 deletions(-)

diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 2a5367d8f7..3377938efd 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -155,6 +155,10 @@ cdef class Coefficient:
         """ Return a :obj:`Coefficient` being the norm of this"""
         return NormCoefficient(self)
 
+    def _shift(self):
+        """ Return a :obj:`Coefficient` with a time shift"""
+        return ShiftCoefficient(self, 0)
+
 
 @cython.auto_pickle(True)
 cdef class FunctionCoefficient(Coefficient):
@@ -719,3 +723,55 @@ cdef class NormCoefficient(Coefficient):
     cpdef Coefficient copy(self):
         """Return a copy of the :obj:`Coefficient`."""
         return NormCoefficient(self.base.copy())
+
+
+@cython.auto_pickle(True)
+cdef class ShiftCoefficient(Coefficient):
+    """
+    Introduce a time shift into the :obj:`Coefficient`.
+
+    Used internally within qutip when calculating correlations.
+
+    :obj:ShiftCoefficient is returned by
+    ``qutip.coefficent.shift(Coefficient)``.
+    """
+    cdef Coefficient base
+    cdef double _t0
+
+    def __init__(self, Coefficient base, double _t0):
+        self.base = base
+        self._t0 = _t0
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        try:
+            _t0 = kwargs["_t0"]
+            del kwargs["_t0"]
+        except KeyError:
+            _t0 = self._t0
+        return ShiftCoefficient(self.base.replace_arguments(**kwargs), _t0)
+
+    cdef complex _call(self, double t) except *:
+        return self.base._call(t + self._t0)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return ShiftCoefficient(self.base.copy(), self._t0)
diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index 1bf7713cc2..a2419fc682 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -18,7 +18,7 @@ import numbers
 
 import numpy as np
 from scipy.sparse import dok_matrix, csgraph
-
+from qutip.settings import settings
 cimport cython
 
 __all__ = ['to', 'create']
@@ -90,6 +90,16 @@ cdef class _partial_converter:
         return "<converter to " + self.to.__name__ + ">"
 
 
+cdef class _default_dtype:
+    cdef type dtype
+
+    def __init__(self, dtype):
+        self.dtype = dtype
+
+    def __call__(self):
+        return settings.core["default_dtype"] or self.dtype
+
+
 # While `_to` and `_create` are defined as objects here, they are actually
 # exported by `data.__init__.py` as singleton function objects of their
 # respective types (without the leading underscore).
@@ -309,6 +319,8 @@ cdef class _to:
             registered, or if ``dtype`` is a type, but not a known data-layer
             type.
         """
+        if type(dtype) is _default_dtype:
+            dtype = dtype()
         if type(dtype) is type:
             if dtype not in self.dtypes:
                 raise ValueError(
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 140ff82d59..806243e85c 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -18,9 +18,11 @@
 from . import data as _data
 from .qobj import Qobj
 from .dimensions import flatten
+from .data.convert import _default_dtype
 
 
-def qdiags(diagonals, offsets=None, dims=None, shape=None, *, dtype=_data.CSR):
+def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
+           dtype=_default_dtype(_data.CSR)):
     """
     Constructs an operator from an array of diagonals.
 
@@ -63,7 +65,7 @@ def qdiags(diagonals, offsets=None, dims=None, shape=None, *, dtype=_data.CSR):
     return Qobj(data, dims=dims, type='oper', copy=False)
 
 
-def jmat(j, which=None, *, dtype=_data.CSR):
+def jmat(j, which=None, *, dtype=_default_dtype(_data.CSR)):
     """Higher-order spin operators:
 
     Parameters
@@ -144,7 +146,7 @@ def jmat(j, which=None, *, dtype=_data.CSR):
     raise ValueError('Invalid spin operator: ' + which)
 
 
-def _jplus(j, *, dtype=_data.CSR):
+def _jplus(j, *, dtype=_default_dtype(_data.CSR)):
     """
     Internal functions for generating the data representing the J-plus
     operator.
@@ -154,7 +156,7 @@ def _jplus(j, *, dtype=_data.CSR):
     return _data.diag[dtype](data, 1)
 
 
-def _jz(j, *, dtype=_data.CSR):
+def _jz(j, *, dtype=_default_dtype(_data.CSR)):
     """
     Internal functions for generating the data representing the J-z operator.
     """
@@ -166,7 +168,7 @@ def _jz(j, *, dtype=_data.CSR):
 #
 # Spin j operators:
 #
-def spin_Jx(j, *, dtype=_data.CSR):
+def spin_Jx(j, *, dtype=_default_dtype(_data.CSR)):
     """Spin-j x operator
 
     Parameters
@@ -187,7 +189,7 @@ def spin_Jx(j, *, dtype=_data.CSR):
     return jmat(j, 'x', dtype=dtype)
 
 
-def spin_Jy(j, *, dtype=_data.CSR):
+def spin_Jy(j, *, dtype=_default_dtype(_data.CSR)):
     """Spin-j y operator
 
     Parameters
@@ -208,7 +210,7 @@ def spin_Jy(j, *, dtype=_data.CSR):
     return jmat(j, 'y', dtype=dtype)
 
 
-def spin_Jz(j, *, dtype=_data.CSR):
+def spin_Jz(j, *, dtype=_default_dtype(_data.CSR)):
     """Spin-j z operator
 
     Parameters
@@ -229,7 +231,7 @@ def spin_Jz(j, *, dtype=_data.CSR):
     return jmat(j, 'z', dtype=dtype)
 
 
-def spin_Jm(j, *, dtype=_data.CSR):
+def spin_Jm(j, *, dtype=_default_dtype(_data.CSR)):
     """Spin-j annihilation operator
 
     Parameters
@@ -250,7 +252,7 @@ def spin_Jm(j, *, dtype=_data.CSR):
     return jmat(j, '-', dtype=dtype)
 
 
-def spin_Jp(j, *, dtype=_data.CSR):
+def spin_Jp(j, *, dtype=_default_dtype(_data.CSR)):
     """Spin-j creation operator
 
     Parameters
@@ -271,7 +273,7 @@ def spin_Jp(j, *, dtype=_data.CSR):
     return jmat(j, '+', dtype=dtype)
 
 
-def spin_J_set(j, *, dtype=_data.CSR):
+def spin_J_set(j, *, dtype=_default_dtype(_data.CSR)):
     """Set of spin-j operators (x, y, z)
 
     Parameters
@@ -384,7 +386,7 @@ def sigmaz():
     return _SIGMAZ.copy()
 
 
-def destroy(N, offset=0, *, dtype=_data.CSR):
+def destroy(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     """
     Destruction (lowering) operator.
 
@@ -422,7 +424,7 @@ def destroy(N, offset=0, *, dtype=_data.CSR):
     return qdiags(data, 1, dtype=dtype)
 
 
-def create(N, offset=0, *, dtype=_data.CSR):
+def create(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     """
     Creation (raising) operator.
 
@@ -493,7 +495,7 @@ def _implicit_tensor_dimensions(dimensions):
     return np.prod(flat), [dimensions, dimensions]
 
 
-def qzero(dimensions, *, dtype=_data.CSR):
+def qzero(dimensions, *, dtype=_default_dtype(_data.CSR)):
     """
     Zero operator.
 
@@ -522,7 +524,7 @@ def qzero(dimensions, *, dtype=_data.CSR):
                 isherm=True, isunitary=False, copy=False)
 
 
-def qeye(dimensions, *, dtype=_data.CSR):
+def qeye(dimensions, *, dtype=_default_dtype(_data.CSR)):
     """
     Identity operator.
 
@@ -572,7 +574,7 @@ def qeye(dimensions, *, dtype=_data.CSR):
 identity = qeye
 
 
-def position(N, offset=0, *, dtype=_data.CSR):
+def position(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     """
     Position operator x=1/sqrt(2)*(a+a.dag())
 
@@ -598,7 +600,7 @@ def position(N, offset=0, *, dtype=_data.CSR):
     return np.sqrt(0.5) * (a + a.dag())
 
 
-def momentum(N, offset=0, *, dtype=_data.CSR):
+def momentum(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     """
     Momentum operator p=-1j/sqrt(2)*(a-a.dag())
 
@@ -624,7 +626,7 @@ def momentum(N, offset=0, *, dtype=_data.CSR):
     return -1j * np.sqrt(0.5) * (a - a.dag())
 
 
-def num(N, offset=0, *, dtype=_data.CSR):
+def num(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     """
     Quantum object for number operator.
 
@@ -660,7 +662,7 @@ def num(N, offset=0, *, dtype=_data.CSR):
     return qdiags(data, 0, dtype=dtype)
 
 
-def squeeze(N, z, offset=0, *, dtype=_data.CSR):
+def squeeze(N, z, offset=0, *, dtype=_default_dtype(_data.CSR)):
     """Single-mode squeezing operator.
 
     Parameters
@@ -731,7 +733,7 @@ def squeezing(a1, a2, z):
     return b.expm()
 
 
-def displace(N, alpha, offset=0, *, dtype=_data.Dense):
+def displace(N, alpha, offset=0, *, dtype=_default_dtype(_data.Dense)):
     """Single-mode displacement operator.
 
     Parameters
@@ -786,7 +788,7 @@ def commutator(A, B, kind="normal"):
         raise TypeError("Unknown commutator kind '%s'" % kind)
 
 
-def qutrit_ops(*, dtype=_data.CSR):
+def qutrit_ops(*, dtype=_default_dtype(_data.CSR)):
     """
     Operators for a three level system (qutrit).
 
@@ -815,7 +817,7 @@ def qutrit_ops(*, dtype=_data.CSR):
     return out
 
 
-def phase(N, phi0=0, *, dtype=_data.Dense):
+def phase(N, phi0=0, *, dtype=_default_dtype(_data.Dense)):
     """
     Single-mode Pegg-Barnett phase operator.
 
@@ -849,7 +851,7 @@ def phase(N, phi0=0, *, dtype=_data.Dense):
     return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
 
 
-def enr_destroy(dims, excitations, *, dtype=_data.CSR):
+def enr_destroy(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
     """
     Generate annilation operators for modes in a excitation-number-restricted
     state space. For example, consider a system consisting of 4 modes, each
@@ -913,7 +915,7 @@ def enr_destroy(dims, excitations, *, dtype=_data.CSR):
     return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
 
 
-def enr_identity(dims, excitations, *, dtype=_data.CSR):
+def enr_identity(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
     """
     Generate the identity operator for the excitation-number restricted
     state space defined by the `dims` and `exciations` arguments. See the
@@ -953,7 +955,7 @@ def enr_identity(dims, excitations, *, dtype=_data.CSR):
                 copy=False)
 
 
-def charge(Nmax, Nmin=None, frac=1, *, dtype=_data.CSR):
+def charge(Nmax, Nmin=None, frac=1, *, dtype=_default_dtype(_data.CSR)):
     """
     Generate the diagonal charge operator over charge states
     from Nmin to Nmax.
@@ -991,7 +993,7 @@ def charge(Nmax, Nmin=None, frac=1, *, dtype=_data.CSR):
     return out
 
 
-def tunneling(N, m=1, *, dtype=_data.CSR):
+def tunneling(N, m=1, *, dtype=_default_dtype(_data.CSR)):
     r"""
     Tunneling operator with elements of the form
     :math:`\\sum |N><N+m| + |N+m><N|`.
diff --git a/qutip/core/options.py b/qutip/core/options.py
index 19adef49a3..e3614120ee 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -92,6 +92,13 @@ class CoreOptions(QutipOptions):
           on the signature of the supplied function. If the function signature
           is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
           ``pythonic`` is used.
+
+    default_dtype : Nonetype, str, type {None}
+        When set, function creating :class:`Qobj` such as :func:"qeye" or
+        :func:"rand_herm" will use the specified data type. Any data-layer
+        known to `qutip.data.to` is accepted.
+        When not specified, the functions will default to either sparse ``csr``
+        or dense representation depending on the created object density.
     """
     _options = {
         # use auto tidyup
@@ -108,6 +115,8 @@ class CoreOptions(QutipOptions):
         "auto_tidyup_atol": 1e-14,
         # signature style expected by function coefficients
         "function_coefficient_style": "auto",
+        # Default Qobj dtype for Qobj create function
+        "default_dtype": None,
     }
     _settings_name = "core"
 
diff --git a/qutip/core/states.py b/qutip/core/states.py
index bd820e0d88..a0dcceb59f 100644
--- a/qutip/core/states.py
+++ b/qutip/core/states.py
@@ -16,6 +16,7 @@
 import itertools
 
 from . import data as _data
+from .data.convert import _default_dtype
 from .qobj import Qobj
 from .operators import jmat, displace, qdiags
 from .tensor import tensor
@@ -42,7 +43,8 @@ def _promote_to_zero_list(arg, length):
     raise TypeError("Dimensions must be an integer or list of integers.")
 
 
-def basis(dimensions, n=None, offset=None, *, dtype=_data.Dense):
+def basis(dimensions, n=None, offset=None,
+          *, dtype=_default_dtype(_data.Dense)):
     """Generates the vector representation of a Fock state.
 
     Parameters
@@ -129,7 +131,7 @@ def basis(dimensions, n=None, offset=None, *, dtype=_data.Dense):
                 copy=False)
 
 
-def qutrit_basis(*, dtype=_data.Dense):
+def qutrit_basis(*, dtype=_default_dtype(_data.Dense)):
     """Basis states for a three level system (qutrit)
 
     dtype : type or str
@@ -153,7 +155,8 @@ def qutrit_basis(*, dtype=_data.Dense):
 _COHERENT_METHODS = ('operator', 'analytic')
 
 
-def coherent(N, alpha, offset=0, method=None, *, dtype=_data.Dense):
+def coherent(N, alpha, offset=0, method=None, *,
+             dtype=_default_dtype(_data.Dense)):
     """Generates a coherent state with eigenvalue alpha.
 
     Constructed using displacement operator on vacuum state.
@@ -240,7 +243,8 @@ def coherent(N, alpha, offset=0, method=None, *, dtype=_data.Dense):
     )
 
 
-def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=_data.Dense):
+def coherent_dm(N, alpha, offset=0, method='operator',
+                *, dtype=_default_dtype(_data.Dense)):
     """Density matrix representation of a coherent state.
 
     Constructed via outer product of :func:`qutip.states.coherent`
@@ -296,7 +300,8 @@ def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=_data.Dense):
     return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
 
 
-def fock_dm(dimensions, n=None, offset=None, *, dtype=_data.CSR):
+def fock_dm(dimensions, n=None, offset=None,
+            *, dtype=_default_dtype(_data.CSR)):
     """Density matrix representation of a Fock state
 
     Constructed via outer product of :func:`qutip.states.fock`.
@@ -340,7 +345,8 @@ def fock_dm(dimensions, n=None, offset=None, *, dtype=_data.CSR):
     return basis(dimensions, n, offset=offset, dtype=dtype).proj()
 
 
-def fock(dimensions, n=None, offset=None, *, dtype=_data.Dense):
+def fock(dimensions, n=None, offset=None,
+         *, dtype=_default_dtype(_data.Dense)):
     """Bosonic Fock (number) state.
 
     Same as :func:`qutip.states.basis`.
@@ -383,7 +389,7 @@ def fock(dimensions, n=None, offset=None, *, dtype=_data.Dense):
     return basis(dimensions, n, offset=offset, dtype=dtype)
 
 
-def thermal_dm(N, n, method='operator', *, dtype=_data.CSR):
+def thermal_dm(N, n, method='operator', *, dtype=_default_dtype(_data.CSR)):
     """Density matrix for a thermal state of n particles
 
     Parameters
@@ -461,7 +467,7 @@ def thermal_dm(N, n, method='operator', *, dtype=_data.CSR):
         return out
 
 
-def maximally_mixed_dm(N, *, dtype=_data.CSR):
+def maximally_mixed_dm(N, *, dtype=_default_dtype(_data.CSR)):
     """
     Returns the maximally mixed density matrix for a Hilbert space of
     dimension N.
@@ -518,7 +524,7 @@ def ket2dm(Q):
     raise TypeError("Input is not a ket or bra vector.")
 
 
-def projection(N, n, m, offset=None, *, dtype=_data.CSR):
+def projection(N, n, m, offset=None, *, dtype=_default_dtype(_data.CSR)):
     r"""
     The projection operator that projects state :math:`\lvert m\rangle` on
     state :math:`\lvert n\rangle`.
@@ -548,7 +554,7 @@ def projection(N, n, m, offset=None, *, dtype=_data.CSR):
            basis(N, m, offset=offset, dtype=dtype).dag()
 
 
-def qstate(string, *, dtype=_data.Dense):
+def qstate(string, *, dtype=_default_dtype(_data.Dense)):
     r"""Creates a tensor product for a set of qubits in either
     the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
 
@@ -612,7 +618,7 @@ def _character_to_qudit(x):
     return _qubit_dict[x] if x in _qubit_dict else int(x)
 
 
-def ket(seq, dim=2, *, dtype=_data.Dense):
+def ket(seq, dim=2, *, dtype=_default_dtype(_data.Dense)):
     """
     Produces a multiparticle ket state for a list or string,
     where each element stands for state of the respective particle.
@@ -695,7 +701,7 @@ def ket(seq, dim=2, *, dtype=_data.Dense):
     return basis(dim, ns, dtype=dtype)
 
 
-def bra(seq, dim=2, *, dtype=_data.Dense):
+def bra(seq, dim=2, *, dtype=_default_dtype(_data.Dense)):
     """
     Produces a multiparticle bra state for a list or string,
     where each element stands for state of the respective particle.
@@ -866,7 +872,7 @@ def state_index_number(dims, index):
     return np.unravel_index(index, dims)
 
 
-def state_number_qobj(dims, state, *, dtype=_data.Dense):
+def state_number_qobj(dims, state, *, dtype=_default_dtype(_data.Dense)):
     """
     Return a Qobj representation of a quantum state specified by the state
     array `state`.
@@ -943,7 +949,7 @@ def enr_state_dictionaries(dims, excitations):
     return nstates, state2idx, idx2state
 
 
-def enr_fock(dims, excitations, state, *, dtype=_data.Dense):
+def enr_fock(dims, excitations, state, *, dtype=_default_dtype(_data.Dense)):
     """
     Generate the Fock state representation in a excitation-number restricted
     state space. The `dims` argument is a list of integers that define the
@@ -990,7 +996,7 @@ def enr_fock(dims, excitations, state, *, dtype=_data.Dense):
     return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
 
 
-def enr_thermal_dm(dims, excitations, n, *, dtype=_data.CSR):
+def enr_thermal_dm(dims, excitations, n, *, dtype=_default_dtype(_data.CSR)):
     """
     Generate the density operator for a thermal state in the excitation-number-
     restricted state space defined by the `dims` and `exciations` arguments.
@@ -1037,7 +1043,7 @@ def enr_thermal_dm(dims, excitations, n, *, dtype=_data.CSR):
     return out
 
 
-def phase_basis(N, m, phi0=0, *, dtype=_data.Dense):
+def phase_basis(N, m, phi0=0, *, dtype=_default_dtype(_data.Dense)):
     """
     Basis vector for the mth phase of the Pegg-Barnett phase operator.
 
@@ -1074,7 +1080,7 @@ def phase_basis(N, m, phi0=0, *, dtype=_data.Dense):
     return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
 
 
-def zero_ket(N, dims=None, *, dtype=_data.Dense):
+def zero_ket(N, dims=None, *, dtype=_default_dtype(_data.Dense)):
     """
     Creates the zero ket vector with shape Nx1 and dimensions `dims`.
 
@@ -1099,7 +1105,7 @@ def zero_ket(N, dims=None, *, dtype=_data.Dense):
     return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
 
 
-def spin_state(j, m, type='ket', *, dtype=_data.Dense):
+def spin_state(j, m, type='ket', *, dtype=_default_dtype(_data.Dense)):
     r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
     eigenstate of the spin-j Sz operator with eigenvalue m.
 
@@ -1135,7 +1141,8 @@ def spin_state(j, m, type='ket', *, dtype=_data.Dense):
         raise ValueError(f"Invalid value keyword argument type='{type}'")
 
 
-def spin_coherent(j, theta, phi, type='ket', *, dtype=_data.Dense):
+def spin_coherent(j, theta, phi, type='ket',
+                  *, dtype=_default_dtype(_data.Dense)):
     r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
 
     Parameters
@@ -1183,7 +1190,7 @@ def spin_coherent(j, theta, phi, type='ket', *, dtype=_data.Dense):
     '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
 }
 
-def bell_state(state='00', *, dtype=_data.Dense):
+def bell_state(state='00', *, dtype=_default_dtype(_data.Dense)):
     r"""
     Returns the selected Bell state:
 
@@ -1218,7 +1225,7 @@ def bell_state(state='00', *, dtype=_data.Dense):
     return _BELL_STATES[state].copy().to(dtype)
 
 
-def singlet_state(*, dtype=_data.Dense):
+def singlet_state(*, dtype=_default_dtype(_data.Dense)):
     r"""
     Returns the two particle singlet-state:
 
@@ -1242,7 +1249,7 @@ def singlet_state(*, dtype=_data.Dense):
     return bell_state('11').to(dtype)
 
 
-def triplet_states(*, dtype=_data.Dense):
+def triplet_states(*, dtype=_default_dtype(_data.Dense)):
     r"""
     Returns a list of the two particle triplet-states:
 
@@ -1271,7 +1278,7 @@ def triplet_states(*, dtype=_data.Dense):
     ]
 
 
-def w_state(N=3, *, dtype=_data.Dense):
+def w_state(N=3, *, dtype=_default_dtype(_data.Dense)):
     """
     Returns the N-qubit W-state:
         ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
@@ -1298,7 +1305,7 @@ def w_state(N=3, *, dtype=_data.Dense):
     return np.sqrt(1 / N) * state
 
 
-def ghz_state(N=3, *, dtype=_data.Dense):
+def ghz_state(N=3, *, dtype=_default_dtype(_data.Dense)):
     """
     Returns the N-qubit GHZ-state:
         ``[ |00...00> + |11...11> ] / sqrt(2)``
diff --git a/qutip/random_objects.py b/qutip/random_objects.py
index b0bcf85c18..978fc27e9e 100644
--- a/qutip/random_objects.py
+++ b/qutip/random_objects.py
@@ -24,6 +24,7 @@
                to_super, to_choi, to_chi, to_kraus, to_stinespring)
 from .core import data as _data
 from .core.dimensions import flatten
+from .core.data.convert import _default_dtype
 
 
 _RAND = default_rng()
@@ -210,7 +211,7 @@ def _merge_shuffle_blocks(blocks, generator):
 
 
 def rand_herm(dimensions, density=0.30, distribution="fill", *,
-              eigenvalues=(), seed=None, dtype=_data.CSR):
+              eigenvalues=(), seed=None, dtype=_default_dtype(_data.CSR)):
     """Creates a random sparse Hermitian quantum object.
 
     Parameters
@@ -332,7 +333,7 @@ def _rand_herm_dense(N, density, pos_def, generator):
 
 
 def rand_unitary(dimensions, density=1, distribution="haar", *,
-                 seed=None, dtype=_data.Dense):
+                 seed=None, dtype=_default_dtype(_data.Dense)):
     r"""Creates a random sparse unitary quantum object.
 
     Parameters
@@ -434,7 +435,7 @@ def _rand_unitary_haar(N, generator):
 
 
 def rand_ket(dimensions, density=1, distribution="haar", *,
-             seed=None, dtype=_data.Dense):
+             seed=None, dtype=_default_dtype(_data.Dense)):
     """Creates a random ket vector.
 
     Parameters
@@ -494,7 +495,8 @@ def rand_ket(dimensions, density=1, distribution="haar", *,
 
 
 def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
-            eigenvalues=(), rank=None, seed=None, dtype=_data.CSR):
+            eigenvalues=(), rank=None, seed=None,
+            dtype=_default_dtype(_data.CSR)):
     r"""Creates a random density matrix of the desired dimensions.
 
     Parameters
@@ -620,7 +622,8 @@ def _rand_dm_ginibre(N, rank, generator):
     return rho
 
 
-def rand_kraus_map(dimensions, *, seed=None, dtype=_data.Dense):
+def rand_kraus_map(dimensions, *, seed=None,
+                   dtype=_default_dtype(_data.Dense)):
     """
     Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
     form.
@@ -657,7 +660,8 @@ def rand_kraus_map(dimensions, *, seed=None, dtype=_data.Dense):
             for x in oper_list]
 
 
-def rand_super(dimensions, *, superrep="super", seed=None, dtype=_data.Dense):
+def rand_super(dimensions, *, superrep="super", seed=None,
+               dtype=_default_dtype(_data.Dense)):
     """
     Returns a randomly drawn superoperator acting on operators acting on
     N dimensions.
@@ -698,7 +702,8 @@ def rand_super(dimensions, *, superrep="super", seed=None, dtype=_data.Dense):
 
 
 def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
-                    superrep="super", seed=None, dtype=_data.CSR):
+                    superrep="super", seed=None,
+                    dtype=_default_dtype(_data.CSR)):
     """
     Returns a random superoperator drawn from the Bruzda
     et al ensemble for CPTP maps [BCSZ08]_. Note that due to
@@ -800,7 +805,7 @@ def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
 
 
 def rand_stochastic(dimensions, density=0.75, kind='left',
-                    *, seed=None, dtype=_data.CSR):
+                    *, seed=None, dtype=_default_dtype(_data.CSR)):
     """Generates a random stochastic matrix.
 
     Parameters
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 01847bf8fd..e2f2a851d8 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -4,7 +4,7 @@
 import numpy as np
 import scipy.interpolate as interp
 from functools import partial
-from qutip.core.coefficient import (coefficient, norm, conj, shift,
+from qutip.core.coefficient import (coefficient, norm, conj,
                                     CompilationOptions, Coefficient,
                                     clean_compiled_coefficient
                                    )

From 9b62f18f61af8372c86bc332647606be0a58d1cc Mon Sep 17 00:00:00 2001
From: Eric <eric.giguere@calculquebec.ca>
Date: Tue, 1 Nov 2022 15:58:22 -0400
Subject: [PATCH 018/602] Add tests

---
 qutip/core/coefficient.py            |  8 +++++++-
 qutip/core/cy/qobjevo.pyx            |  9 +++++++--
 qutip/tests/core/test_coefficient.py |  2 +-
 qutip/tests/core/test_operators.py   |  8 ++++++++
 qutip/tests/core/test_qobjevo.py     | 19 +++++++++++++++++++
 qutip/tests/core/test_states.py      |  8 ++++++++
 qutip/tests/test_random.py           | 26 +++++++++++++++++++++++++-
 7 files changed, 75 insertions(+), 5 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 1119643a67..0200960622 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -24,7 +24,7 @@
 from .data import Data
 from .cy.coefficient import (
     Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
-    ConjCoefficient, NormCoefficient
+    ConjCoefficient, NormCoefficient, ShiftCoefficient
 )
 
 
@@ -163,6 +163,12 @@ def conj(coeff):
     return ConjCoefficient(coeff)
 
 
+def shift(coeff, _t0=0):
+    """ return a Coefficient in which t is shifted by _t0.
+    """
+    return ShiftCoefficient(coeff, _t0)
+
+
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 # %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 4da9c3ca8b..14b0ada2fd 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -288,8 +288,8 @@ cdef class QobjEvo:
         return out
 
     @classmethod
-    def _retore(cls, elements, dims, shape, type, superrep, flags):
-        # We
+    def _restore(cls, elements, dims, shape, type, superrep, flags):
+        """ Recreate a QobjEvo without using __init__ """
         cdef QobjEvo out = cls.__new__(cls)
         out.elements = elements
         out.dims = dims
@@ -300,6 +300,11 @@ cdef class QobjEvo:
         return out
 
     def _getstate(self):
+        """ Obtain the state """
+        # For jax pytree representation
+        # auto_pickle create similar method __getstate__, but since it's
+        # automatically created, it could change depending on cython version
+        # etc. so we create our own.
         return {
             "elements": self.elements,
             "dims": self.dims,
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index e2f2a851d8..01847bf8fd 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -4,7 +4,7 @@
 import numpy as np
 import scipy.interpolate as interp
 from functools import partial
-from qutip.core.coefficient import (coefficient, norm, conj,
+from qutip.core.coefficient import (coefficient, norm, conj, shift,
                                     CompilationOptions, Coefficient,
                                     clean_compiled_coefficient
                                    )
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index 664eb2fc0f..896744da5e 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -271,6 +271,14 @@ def test_operator_type(func, args, alias, dtype):
         for obj in object:
             assert isinstance(obj.data, dtype)
 
+    with qutip.CoreOptions(default_dtype=alias):
+        object = func(*args)
+        if isinstance(object, qutip.Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
+
 
 @pytest.mark.parametrize('dims', [8, 15, [2] * 4])
 def test_qft(dims):
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index f5a04b2c87..7599ea5d17 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -301,6 +301,14 @@ def test_QobjEvo_pickle(all_qevo):
     recreated = pickle.loads(pickled)
     _assert_qobjevo_equivalent(recreated, obj)
 
+def test_QobjEvo_restore(all_qevo):
+    "QobjEvo pickle"
+    # used in parallel_map
+    obj = all_qevo
+    state = obj._getstate()
+    recreated = QobjEvo._restore(**state)
+    _assert_qobjevo_equivalent(recreated, obj)
+
 def test_shift(all_qevo):
     dt = 0.2
     obj = all_qevo
@@ -444,3 +452,14 @@ def test_QobjEvo_isherm_flag_knowcase():
     assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
     assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
     assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
+
+@pytest.mark.parametrize(
+    "coeff_type",
+    ['func_coeff', 'string', 'array', 'logarray']
+)
+def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+    as_list = qevo.to_list()
+    assert len(as_list) == 2
+    restored = QobjEvo(as_list)
+    _assert_qobjevo_equivalent(qevo, restored)
diff --git a/qutip/tests/core/test_states.py b/qutip/tests/core/test_states.py
index e790d06dd8..be17941dec 100644
--- a/qutip/tests/core/test_states.py
+++ b/qutip/tests/core/test_states.py
@@ -308,3 +308,11 @@ def test_state_type(func, args, alias, dtype):
     else:
         for obj in object:
             assert isinstance(obj.data, dtype)
+
+    with qutip.CoreOptions(default_dtype=alias):
+        object = func(*args)
+        if isinstance(object, qutip.Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
diff --git a/qutip/tests/test_random.py b/qutip/tests/test_random.py
index fcbf1b4280..13f9554bbf 100644
--- a/qutip/tests/test_random.py
+++ b/qutip/tests/test_random.py
@@ -4,7 +4,7 @@
 import scipy.linalg as la
 import pytest
 
-from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions
+from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
 from qutip import data as _data
 from qutip.random_objects import (
     rand_herm,
@@ -285,3 +285,27 @@ def test_kraus_map(dimensions, dtype):
     _assert_metadata(kmap[0], dimensions, dtype)
     with CoreOptions(atol=1e-9):
         assert kraus_to_choi(kmap).iscptp
+
+
+dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
+dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize('func', [
+    rand_herm,
+    rand_unitary,
+    rand_dm,
+    rand_ket,
+    rand_stochastic,
+    rand_super,
+    rand_super_bcsz,
+    rand_kraus_map,
+])
+def test_random_dtype(func, alias, dtype):
+    with CoreOptions(default_dtype=alias):
+        object = func(2)
+        if isinstance(object, Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)

From e0db8e7eb9a24be9d4bedd44d8b739f19428d21a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 20 Dec 2022 11:14:55 -0500
Subject: [PATCH 019/602] Stochastic for v5 idea

---
 qutip/core/data/trace.pxd                 |   3 +
 qutip/core/data/trace.pyx                 |  48 ++++++++
 qutip/solver/mcsolve.py                   |   4 +-
 qutip/solver/multitraj.py                 |   2 +-
 qutip/solver/sode/__init__.py             |   0
 qutip/solver/sode/sode.pyx                | 130 ++++++++++++++++++++++
 qutip/solver/sode/ssystem.pyx             |  96 ++++++++++++++++
 qutip/tests/core/data/test_mathematics.py |  20 ++++
 8 files changed, 300 insertions(+), 3 deletions(-)
 create mode 100644 qutip/solver/sode/__init__.py
 create mode 100644 qutip/solver/sode/sode.pyx
 create mode 100644 qutip/solver/sode/ssystem.pyx

diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index bdac487763..e231896f8f 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -4,3 +4,6 @@ from qutip.core.data cimport CSR, Dense
 
 cpdef double complex trace_csr(CSR matrix) nogil except *
 cpdef double complex trace_dense(Dense matrix) nogil except *
+
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 18756de52d..565b9b2c26 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -2,11 +2,14 @@
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
 cimport cython
+from libc.math cimport sqrt
 
 from qutip.core.data cimport Data, CSR, Dense
+from qutip.core.data cimport base
 
 __all__ = [
     'trace', 'trace_csr', 'trace_dense',
+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
 ]
 
 
@@ -17,6 +20,13 @@ cdef void _check_shape(Data matrix) nogil except *:
         ]))
 
 
+cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
+    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
+        raise ValueError("".join([
+            "matrix ", str(matrix.shape), " is not a stacked square matrix."
+        ]))
+
+
 cpdef double complex trace_csr(CSR matrix) nogil except *:
     _check_shape(matrix)
     cdef size_t row, ptr
@@ -39,6 +49,28 @@ cpdef double complex trace_dense(Dense matrix) nogil except *:
     return trace
 
 
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
+    cdef int N = <int>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef size_t row, ptr
+    cdef double complex trace = 0
+    for row in range(N):
+        if matrix.row_index[row * (N+1)] != matrix.row_index[row * (N+1) + 1]:
+            trace += matrix.data[matrix.row_index[row * (N+1)]]
+    return trace
+
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
+    cdef int N = <int>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef double complex trace = 0
+    cdef size_t ptr = 0
+    cdef size_t stride = N + 1
+    for _ in range(N):
+        trace += matrix.data[ptr]
+        ptr += stride
+    return trace
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -58,4 +90,20 @@ trace.add_specialisations([
     (Dense, trace_dense),
 ], _defer=True)
 
+trace_oper_ket = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='trace_oper_ket',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+trace_oper_ket.__doc__ =\
+    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
+trace_oper_ket.add_specialisations([
+    (CSR, trace_oper_ket_csr),
+    (Dense, trace_oper_ket_dense),
+], _defer=True)
+
 del _inspect, _Dispatcher
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 24458ce5dc..825b9eab58 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -223,12 +223,12 @@ def reset(self, hard=False):
 
     def _prob_func(self, state):
         if self.issuper:
-            return _data.norm.trace(unstack_columns(state))
+            return _data.norm.trace_oper_ket(state)
         return _data.norm.l2(state)**2
 
     def _norm_func(self, state):
         if self.issuper:
-            return _data.norm.trace(unstack_columns(state))
+            return _data.norm.trace_oper_ket(state)
         return _data.norm.l2(state)
 
     def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 73f84de66b..372ac2f675 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -6,7 +6,7 @@
 import numpy as np
 from copy import copy
 
-__all__ = ["MultiTrajSolver", "TrajectorySolver"]
+__all__ = ["MultiTrajSolver"]
 
 
 class MultiTrajSolver(Solver):
diff --git a/qutip/solver/sode/__init__.py b/qutip/solver/sode/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/qutip/solver/sode/sode.pyx b/qutip/solver/sode/sode.pyx
new file mode 100644
index 0000000000..2d72a85ec4
--- /dev/null
+++ b/qutip/solver/sode/sode.pyx
@@ -0,0 +1,130 @@
+
+
+from qutip.core import data as _data
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.data cimport Data
+
+cdef class StochasticIntegrator:
+    cdef:
+        StochasticSystem system
+        double dt
+        double t
+        bool support_time_dependant
+        bool supports_blackbox
+
+    def __init__(self, system, dt, options):
+        self.system = system
+        self.dt = dt
+        self.options = options
+
+    def set_state(self, t, state0, seed):
+          """
+          Set the state of the ODE solver.
+
+          Parameters
+          ----------
+          t : float
+              Initial time
+
+          state0 : qutip.Data
+              Initial state.
+
+          .. note:
+              It should set the flags `_is_set` to True.
+          """
+          raise NotImplementedError
+
+    def integrate(self, t, copy=True):
+          """
+          Evolve to t.
+
+          Before calling `integrate` for the first time, the initial state should
+          be set with `set_state`.
+
+          Parameters
+          ----------
+          t : float
+              Time to integrate to, should be larger than the previous time.
+
+          copy : bool [True]
+              Whether to return a copy of the state or the state itself.
+
+          Returns
+          -------
+          (t, state) : (float, qutip.Data)
+              The state of the solver at ``t``.
+          """
+          raise NotImplementedError
+
+      def get_state(self, copy=True):
+          """
+          Obtain the state of the solver as a pair (t, state).
+
+          Parameters
+          ----------
+          copy : bool (True)
+              Whether to return the data stored in the Integrator or a copy.
+
+          Returns
+          -------
+          (t, state) : (float, qutip.Data)
+              The state of the solver at ``t``.
+          """
+          raise NotImplementedError
+
+      def run(self, tlist):
+          """
+          Integrate the system yielding the state for each times in tlist.
+
+          Parameters
+          ----------
+          tlist : *list* / *array*
+              List of times to yield the state.
+
+          Yields
+          ------
+          (t, state) : (float, qutip.Data)
+              The state of the solver at each ``t`` of tlist.
+          """
+          for t in tlist[1:]:
+              yield self.integrate(t, False)
+
+    def reset(self, hard=False):
+        """Reset internal state of the ODE solver."""
+        if self._is_set:
+            state = self.get_state()
+        if hard:
+            self._prepare()
+        if self._is_set:
+            self.set_state(*state)
+
+
+    def arguments(self, args):
+        """
+        Change the argument of the system.
+        Reset the ODE solver to ensure numerical validity.
+
+        Parameters
+        ----------
+        args : dict
+            New arguments
+        """
+        self.system.arguments(args)
+        self.reset()
+
+    @property
+    def options(self):
+        # Options should be overwritten by each integrators.
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        # This does not apply the new options.
+        self._options = {
+            **self._options,
+            **{
+               key: new_options[key]
+               for key in self.integrator_options.keys()
+               if key in new_options and new_options[key] is not None
+            }
+        }
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
new file mode 100644
index 0000000000..1d6ee8a94a
--- /dev/null
+++ b/qutip/solver/sode/ssystem.pyx
@@ -0,0 +1,96 @@
+"""
+Class to represent a stochastic differential equation system.
+"""
+
+from qutip.core import data as _data
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.data cimport Data
+
+cdef class StochasticSystem:
+    """
+
+    """
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+
+    def drift(self, t, state):
+        return self.b(t, state)
+
+    def diffusion(self, t, state):
+        return self.a(t, state)
+
+
+
+cdef class StochasticClosedSystem:
+    """
+
+    """
+    cdef QobjEvo H
+    cdef list c_ops
+    cdef list cpcd_ops
+    cdef object imp
+    cdef Data state
+    cdef double t
+
+    def __init__(self, H, c_ops, dt, options=None, implicit=False):
+        self.H = H
+        self.c_ops = c_ops
+        self.cpcd_ops = [op + op.dag() for op in c_ops]
+        self.dt = dt
+
+    def drift(self, double t, Data state):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef Data temp, out
+
+        out = self.L.matmul_data(t, state)
+        for i in range(len(self.c_ops)):
+            c_op = self.cpcd_ops[i]
+            e = c_op.expect_data(t, state)
+            c_op = self.c_ops[i]
+            temp = c_op.matmul_data(t, state)
+            out = _data.add(out, state,  -0.125 * e * e)
+            out = _data.add(out, temp, 0.5 * e)
+
+    def diffusion(self, double t, Data state):
+        cdef int i
+        cdef QobjEvo c_op
+        out = []
+        for i in range(len(self.c_ops)):
+            c_op = self.c_ops[i]
+            _out = c_op.matmul_data(t, state)
+            c_op = self.cpcd_ops[i]
+            expect = c_op.expect_data(t, state)
+            out.append(_data.add(out, state, -0.5 * expect))
+        return out
+
+
+cdef class StochasticOpenSystem:
+    """
+
+    """
+    cdef QobjEvo L
+    cdef list c_ops
+    cdef object imp
+    cdef Data state
+    cdef double t
+
+    def __init__(self, H, c_ops):
+        self.L = H
+        self.c_ops = c_ops
+
+    def drift(self, double t, Data state):
+        return self.L.matmul_data(t, state)
+
+    def diffusion(self, double t, Data state):
+        cdef int i, k
+        cdef QobjEvo c_op
+        cdef complex expect
+        cdef out = []
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            vec = c_op.matmul_data(t, state)
+            expect = _data.trace_oper_ket(vec)
+            out.append(_data.add(vec, state, -expect))
+        return out
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index ceeecda9a7..459ab0d467 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -804,6 +804,26 @@ def op_numpy(self, matrix):
     ]
 
 
+class TestTrace_oper_ket(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        N = int(matrix.shape[0] ** 0.5)
+        return np.sum(np.diag(matrix.reshape((N, N))))
+
+    shapes = [
+        (pytest.param((100, 1), id="oper-ket"),),
+    ]
+    bad_shapes = [
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((99, 1), id="ket"),),
+        (pytest.param((99, 99), id="ket"),),
+        (pytest.param((2, 99), id="nonsquare"),),
+    ]
+    specialisations = [
+        pytest.param(data.trace_oper_ket_csr, CSR, complex),
+        pytest.param(data.trace_oper_ket_dense, Dense, complex),
+    ]
+
+
 class TestPow(UnaryOpMixin):
     def op_numpy(self, matrix, n):
         return np.linalg.matrix_power(matrix, n)

From 0f1cab09e57def5bcbedf2df66629d9377fcdcf4 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 20 Dec 2022 11:16:13 -0500
Subject: [PATCH 020/602] Better idea

---
 qutip/solver/sode/sode.pyx    | 2 --
 qutip/solver/sode/ssystem.pyx | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/qutip/solver/sode/sode.pyx b/qutip/solver/sode/sode.pyx
index 2d72a85ec4..7b5c44c855 100644
--- a/qutip/solver/sode/sode.pyx
+++ b/qutip/solver/sode/sode.pyx
@@ -1,5 +1,3 @@
-
-
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
 from qutip.core.data cimport Data
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 1d6ee8a94a..1a88b1c2ca 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -84,7 +84,7 @@ cdef class StochasticOpenSystem:
         return self.L.matmul_data(t, state)
 
     def diffusion(self, double t, Data state):
-        cdef int i, k
+        cdef int i
         cdef QobjEvo c_op
         cdef complex expect
         cdef out = []

From 0a3052ce1f524e3f7f2888a957bf6fc41697b4f2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 20 Dec 2022 17:34:47 -0500
Subject: [PATCH 021/602] first sode integrator

---
 qutip/solver/sode/sode.py   | 131 +++++++++++++++++++++++++
 qutip/solver/sode/sode.pyx  | 190 +++++++++++++-----------------------
 qutip/solver/stochastics.py |  85 ++++++++++++++++
 3 files changed, 283 insertions(+), 123 deletions(-)
 create mode 100644 qutip/solver/sode/sode.py
 create mode 100644 qutip/solver/stochastics.py

diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
new file mode 100644
index 0000000000..e4562cd5f4
--- /dev/null
+++ b/qutip/solver/sode/sode.py
@@ -0,0 +1,131 @@
+
+
+
+class EulerIntegrator:
+    def __init__(self, system, options):
+        self.system = system
+        self.dt = dt
+        self.options = options
+
+    def _step(self, dt, dWs):
+        t = self._t
+        state = self._state
+        a = self.system.drift(t, state)
+        bs = self.diffusion(t, state)
+        new_state = _data.add(state, a, dt)
+        for b, dW in zip(bs, dWs):
+            new_state = _data.add(new_state, b, dW)
+        self._state = new_state
+        self._t += dt
+
+    def set_state(self, t, state0, generator):
+          """
+          Set the state of the ODE solver.
+
+          Parameters
+          ----------
+          t : float
+              Initial time
+
+          state0 : qutip.Data
+              Initial state.
+
+          .. note:
+              It should set the flags `_is_set` to True.
+          """
+          raise NotImplementedError
+
+    def integrate(self, t, copy=True):
+          """
+          Evolve to t.
+
+          Before calling `integrate` for the first time, the initial state should
+          be set with `set_state`.
+
+          Parameters
+          ----------
+          t : float
+              Time to integrate to, should be larger than the previous time.
+
+          copy : bool [True]
+              Whether to return a copy of the state or the state itself.
+
+          Returns
+          -------
+          (t, state) : (float, qutip.Data)
+              The state of the solver at ``t``.
+          """
+          raise NotImplementedError
+
+      def get_state(self, copy=True):
+          """
+          Obtain the state of the solver as a pair (t, state).
+
+          Parameters
+          ----------
+          copy : bool (True)
+              Whether to return the data stored in the Integrator or a copy.
+
+          Returns
+          -------
+          (t, state) : (float, qutip.Data)
+              The state of the solver at ``t``.
+          """
+          raise NotImplementedError
+
+      def run(self, tlist):
+          """
+          Integrate the system yielding the state for each times in tlist.
+
+          Parameters
+          ----------
+          tlist : *list* / *array*
+              List of times to yield the state.
+
+          Yields
+          ------
+          (t, state) : (float, qutip.Data)
+              The state of the solver at each ``t`` of tlist.
+          """
+          for t in tlist[1:]:
+              yield self.integrate(t, False)
+
+    def reset(self, hard=False):
+        """Reset internal state of the ODE solver."""
+        if self._is_set:
+            state = self.get_state()
+        if hard:
+            self._prepare()
+        if self._is_set:
+            self.set_state(*state)
+
+
+    def arguments(self, args):
+        """
+        Change the argument of the system.
+        Reset the ODE solver to ensure numerical validity.
+
+        Parameters
+        ----------
+        args : dict
+            New arguments
+        """
+        self.system.arguments(args)
+        self.reset()
+
+    @property
+    def options(self):
+        # Options should be overwritten by each integrators.
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        # This does not apply the new options.
+        self._options = {
+            **self._options,
+            **{
+               key: new_options[key]
+               for key in self.integrator_options.keys()
+               if key in new_options and new_options[key] is not None
+            }
+        }
diff --git a/qutip/solver/sode/sode.pyx b/qutip/solver/sode/sode.pyx
index 7b5c44c855..acbdd28a3d 100644
--- a/qutip/solver/sode/sode.pyx
+++ b/qutip/solver/sode/sode.pyx
@@ -2,127 +2,71 @@ from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
 from qutip.core.data cimport Data
 
-cdef class StochasticIntegrator:
-    cdef:
-        StochasticSystem system
-        double dt
-        double t
-        bool support_time_dependant
-        bool supports_blackbox
 
-    def __init__(self, system, dt, options):
-        self.system = system
-        self.dt = dt
-        self.options = options
-
-    def set_state(self, t, state0, seed):
-          """
-          Set the state of the ODE solver.
-
-          Parameters
-          ----------
-          t : float
-              Initial time
-
-          state0 : qutip.Data
-              Initial state.
-
-          .. note:
-              It should set the flags `_is_set` to True.
-          """
-          raise NotImplementedError
-
-    def integrate(self, t, copy=True):
-          """
-          Evolve to t.
-
-          Before calling `integrate` for the first time, the initial state should
-          be set with `set_state`.
-
-          Parameters
-          ----------
-          t : float
-              Time to integrate to, should be larger than the previous time.
-
-          copy : bool [True]
-              Whether to return a copy of the state or the state itself.
-
-          Returns
-          -------
-          (t, state) : (float, qutip.Data)
-              The state of the solver at ``t``.
-          """
-          raise NotImplementedError
-
-      def get_state(self, copy=True):
-          """
-          Obtain the state of the solver as a pair (t, state).
-
-          Parameters
-          ----------
-          copy : bool (True)
-              Whether to return the data stored in the Integrator or a copy.
-
-          Returns
-          -------
-          (t, state) : (float, qutip.Data)
-              The state of the solver at ``t``.
-          """
-          raise NotImplementedError
-
-      def run(self, tlist):
-          """
-          Integrate the system yielding the state for each times in tlist.
-
-          Parameters
-          ----------
-          tlist : *list* / *array*
-              List of times to yield the state.
-
-          Yields
-          ------
-          (t, state) : (float, qutip.Data)
-              The state of the solver at each ``t`` of tlist.
-          """
-          for t in tlist[1:]:
-              yield self.integrate(t, False)
-
-    def reset(self, hard=False):
-        """Reset internal state of the ODE solver."""
-        if self._is_set:
-            state = self.get_state()
-        if hard:
-            self._prepare()
-        if self._is_set:
-            self.set_state(*state)
-
-
-    def arguments(self, args):
-        """
-        Change the argument of the system.
-        Reset the ODE solver to ensure numerical validity.
-
-        Parameters
-        ----------
-        args : dict
-            New arguments
-        """
-        self.system.arguments(args)
-        self.reset()
-
-    @property
-    def options(self):
-        # Options should be overwritten by each integrators.
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        # This does not apply the new options.
-        self._options = {
-            **self._options,
-            **{
-               key: new_options[key]
-               for key in self.integrator_options.keys()
-               if key in new_options and new_options[key] is not None
-            }
-        }
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef Data euler(StochasticSystem system, t, Data state, dt, dW):
+    """
+    Integration scheme:
+    Basic Euler order 0.5
+    dV = d1 dt + d2_i dW_i
+    Numerical Solution of Stochastic Differential Equations
+    By Peter E. Kloeden, Eckhard Platen
+    """
+    cdef int i
+    a = system.drift(t, state)
+    b = system.diffusion(t, state)
+    new_state = _data.add(state, a, dt)
+    for i in range(system.num_collapse):
+        new_state = _data.add(new_state, b[i], dW[i])
+    return new_state
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef Data platen(StochasticSystem system, t, Data state, dt, dW):
+    """
+    Platen rhs function for both master eq and schrodinger eq.
+    dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
+         + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
+         + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
+
+    Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
+    V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
+    The Theory of Open Quantum Systems
+    Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
+    """
+    cdef int i, j
+    cdef double sqrt_dt = np.sqrt(dt)
+    cdef double sqrt_dt_inv = 0.25/sqrt_dt
+    cdef double dw, dw2
+
+    d1 = _data.add(system.drift(t, state), state)
+    d2 = system.diffusion(t, state)
+
+    out = _data.mul(d1, 0.5)
+    Vt = d1.copy()
+    Vp = []
+    Vm = []
+    for i in range(system.num_collapse):
+        Vp.append(_data.add(d1, d2[i], sqrt_dt))
+        Vm.append(_data.add(d1, d2[i], -sqrt_dt))
+        Vt = _data.add(Vt, d2[i], dW[i])
+
+    d1 = system.drift(t, Vt)
+    out = _data.add(out, d1, 0.5)
+    out = _data.add(out, state, 0.5)
+    for i in range(system.num_collapse):
+        d2p = system.diffusion(t, Vp[i])
+        d2m = system.diffusion(t, Vm[i])
+        dw = dW[i] * 0.25
+        out = _data.add(out, d2m[i], dw)
+        out = _data.add(out, d2[i], 2*dw)
+        out = _data.add(out, d2p[i], dw)
+
+        for j in range(system.num_collapse):
+            dw2 = sqrt_dt_inv * (dW[i] * dW[j] - dt * (i == j))
+            out = _data.add(out, d2p[j], dw)
+            out = _data.add(out, d2m[j], -dw)
+
+    return out
diff --git a/qutip/solver/stochastics.py b/qutip/solver/stochastics.py
new file mode 100644
index 0000000000..0bfa090a18
--- /dev/null
+++ b/qutip/solver/stochastics.py
@@ -0,0 +1,85 @@
+__all__ = ["smesolve", "SMESolver"]
+
+
+
+
+
+
+class SIntegrator(Integrator):
+    def set_state(self, t, state0, generator):
+        """
+        Set the state of the SODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        raise NotImplementedError
+
+
+
+
+def smesolve(H, rho0, times, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
+             args={}, options=None):
+    """
+    Solve stochastic master equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    args : dict
+        ...
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+
+
+
+
+
+
+
+
+
+class SMESolver(MultiTrajSolver):
+    pass

From c774be85b34542e022a5a2c997342e44243ad697 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 22 Dec 2022 15:25:01 -0500
Subject: [PATCH 022/602] Start SMESolver

---
 qutip/solver/multitraj.py                 |   4 +-
 qutip/solver/sode/{sode.pyx => _sode.pyx} |   6 +-
 qutip/solver/sode/sode.py                 | 151 +++++-----------------
 qutip/solver/stochastics.py               | 130 +++++++++++++++++--
 4 files changed, 152 insertions(+), 139 deletions(-)
 rename qutip/solver/sode/{sode.pyx => _sode.pyx} (93%)

diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 372ac2f675..8f5cbc4184 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -28,7 +28,7 @@ class MultiTrajSolver(Solver):
     options : dict
         Options for the solver.
     """
-    name = "generic multi trajectory"
+    name = "stochastic master equation"
     resultclass = MultiTrajResult
     _avail_integrators = {}
 
@@ -40,7 +40,7 @@ class MultiTrajSolver(Solver):
         "store_states": None,
         "keep_runs_results": False,
         "normalize_output": False,
-        "method": "",
+        "method": "adams",
         "map": "serial",
         "job_timeout": None,
         "num_cpus": None,
diff --git a/qutip/solver/sode/sode.pyx b/qutip/solver/sode/_sode.pyx
similarity index 93%
rename from qutip/solver/sode/sode.pyx
rename to qutip/solver/sode/_sode.pyx
index acbdd28a3d..daa736e5cc 100644
--- a/qutip/solver/sode/sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -61,12 +61,12 @@ cpdef Data platen(StochasticSystem system, t, Data state, dt, dW):
         d2m = system.diffusion(t, Vm[i])
         dw = dW[i] * 0.25
         out = _data.add(out, d2m[i], dw)
-        out = _data.add(out, d2[i], 2*dw)
+        out = _data.add(out, d2[i], 2 * dw)
         out = _data.add(out, d2p[i], dw)
 
         for j in range(system.num_collapse):
             dw2 = sqrt_dt_inv * (dW[i] * dW[j] - dt * (i == j))
-            out = _data.add(out, d2p[j], dw)
-            out = _data.add(out, d2m[j], -dw)
+            out = _data.add(out, d2p[j], dw2)
+            out = _data.add(out, d2m[j], -dw2)
 
     return out
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index e4562cd5f4..7dcd20e46e 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -1,131 +1,42 @@
 
+import ._sode as sstepper
 
 
-class EulerIntegrator:
+
+class ExplicitIntegrator(SIntegrator):
+    integrator_options = {
+        "dt": 0.001,
+        "tol": 1e-7,
+    }
     def __init__(self, system, options):
         self.system = system
-        self.dt = dt
         self.options = options
+        self.dt = self.options["dt"]
+        self.tol = self.options["tol"]
+        self.stepper = getattr(sstepper, options["method"])
 
-    def _step(self, dt, dWs):
-        t = self._t
-        state = self._state
-        a = self.system.drift(t, state)
-        bs = self.diffusion(t, state)
-        new_state = _data.add(state, a, dt)
-        for b, dW in zip(bs, dWs):
-            new_state = _data.add(new_state, b, dW)
-        self._state = new_state
-        self._t += dt
+    def _step(self, dt, dW):
+        new_state = self.stepper(self.system, self.t, self.state, dt, dW)
+        self.state = new_state
+        self.t += dt
 
     def set_state(self, t, state0, generator):
-          """
-          Set the state of the ODE solver.
-
-          Parameters
-          ----------
-          t : float
-              Initial time
-
-          state0 : qutip.Data
-              Initial state.
-
-          .. note:
-              It should set the flags `_is_set` to True.
-          """
-          raise NotImplementedError
+        self.t = t
+        self.state = state0
+        self.generator = generator
 
     def integrate(self, t, copy=True):
-          """
-          Evolve to t.
-
-          Before calling `integrate` for the first time, the initial state should
-          be set with `set_state`.
-
-          Parameters
-          ----------
-          t : float
-              Time to integrate to, should be larger than the previous time.
-
-          copy : bool [True]
-              Whether to return a copy of the state or the state itself.
-
-          Returns
-          -------
-          (t, state) : (float, qutip.Data)
-              The state of the solver at ``t``.
-          """
-          raise NotImplementedError
-
-      def get_state(self, copy=True):
-          """
-          Obtain the state of the solver as a pair (t, state).
-
-          Parameters
-          ----------
-          copy : bool (True)
-              Whether to return the data stored in the Integrator or a copy.
-
-          Returns
-          -------
-          (t, state) : (float, qutip.Data)
-              The state of the solver at ``t``.
-          """
-          raise NotImplementedError
-
-      def run(self, tlist):
-          """
-          Integrate the system yielding the state for each times in tlist.
-
-          Parameters
-          ----------
-          tlist : *list* / *array*
-              List of times to yield the state.
-
-          Yields
-          ------
-          (t, state) : (float, qutip.Data)
-              The state of the solver at each ``t`` of tlist.
-          """
-          for t in tlist[1:]:
-              yield self.integrate(t, False)
-
-    def reset(self, hard=False):
-        """Reset internal state of the ODE solver."""
-        if self._is_set:
-            state = self.get_state()
-        if hard:
-            self._prepare()
-        if self._is_set:
-            self.set_state(*state)
-
-
-    def arguments(self, args):
-        """
-        Change the argument of the system.
-        Reset the ODE solver to ensure numerical validity.
-
-        Parameters
-        ----------
-        args : dict
-            New arguments
-        """
-        self.system.arguments(args)
-        self.reset()
-
-    @property
-    def options(self):
-        # Options should be overwritten by each integrators.
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        # This does not apply the new options.
-        self._options = {
-            **self._options,
-            **{
-               key: new_options[key]
-               for key in self.integrator_options.keys()
-               if key in new_options and new_options[key] is not None
-            }
-        }
+        delta_t = (t - self.t)
+        dt = self.dt
+        N, err = np.divmod(delta_t, dt)
+        if err > self.tol:
+            # Not a whole number of steps.
+            N += 1
+            dt = delta_t / N
+        dW = self.generator.normal(0, np.sqrt(dt), size=(N, self.system.num_dw))
+        for i in range(N):
+            self._step(dt, dW[i, :])
+        return self.t, self.state, np.sum(dW, axis=0) / (N * dt)
+
+    def get_state(self, copy=True):
+        return self.t, self.state, self.generator
diff --git a/qutip/solver/stochastics.py b/qutip/solver/stochastics.py
index 0bfa090a18..481812ce45 100644
--- a/qutip/solver/stochastics.py
+++ b/qutip/solver/stochastics.py
@@ -1,8 +1,8 @@
 __all__ = ["smesolve", "SMESolver"]
 
-
-
-
+from .integrator import Integrator
+from .result import MultiTrajResult, Result
+from .multitraj import MultiTrajSolver
 
 
 class SIntegrator(Integrator):
@@ -24,10 +24,61 @@ def set_state(self, t, state0, generator):
         raise NotImplementedError
 
 
+    def integrate(self, t, copy=True):
+        """
+        Evolve to t.
+
+        Before calling `integrate` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state, noise) : (float, qutip.Data, np.ndarray)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+
+    def mcstep(self, t, copy=True):
+        raise NotImplementedError
+
+
+class StochasticTrajResult(Result):
+    def _post_init(self, m_ops=()):
+        super()._post_init()
+        self.noise = []
+        self.m_ops = m_ops
+        self.measurements = [[] for _ in range(len(m_ops))]
+        self.add_processor(self._add_measurement)
+
+    def _add_measurement(self, t, state, noise):
+        expects = [m_op.expect(t, state) for m_op in self.m_ops]
+        noises = np.sum(noise, axis=0)
+        for measure, expect, dW in zip(self.measurements, expects, noises):
+            measure.append(expect + dW)
+
+    def add(t, state, noise):
+        super().add(t, state)
+        self._add_measurement(t, state, noise)
+        self.noise.append(noise)
+
+
+class StochasticResult(MultiTrajResult):
+    @property
+    def measurement(self):
+        return []
 
 
-def smesolve(H, rho0, times, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
-             args={}, options=None):
+def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
+             args={}, ntraj=500, options=None):
     """
     Solve stochastic master equation. Dispatch to specific solvers
     depending on the value of the `solver` keyword argument.
@@ -42,7 +93,7 @@ def smesolve(H, rho0, times, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     rho0 : :class:`qutip.Qobj`
         Initial density matrix or state vector (ket).
 
-    times : *list* / *array*
+    tlist : *list* / *array*
         List of times for :math:`t`. Must be uniformly spaced.
 
     c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
@@ -61,6 +112,10 @@ def smesolve(H, rho0, times, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
         Single operator or list of operators for which to evaluate
         expectation values.
 
+    m_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
     args : dict
         ...
 
@@ -72,14 +127,61 @@ def smesolve(H, rho0, times, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
         An instance of the class :class:`qutip.solver.Result`.
 
     """
-
-
-
-
-
-
-
+    L = QobjEvo(H, args=args)
+    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
+    sc_ops = [QobjEvo(c_op, args=args) for c_op in sc_ops]
+    L = liouvillian(H, c_ops)
+    sol = SMESolver(L, sc_ops, options=options)
+    return sol.run(rho0, tlist, e_ops, m_ops, ntraj)
 
 
 class SMESolver(MultiTrajSolver):
-    pass
+    name = "generic multi trajectory"
+    resultclass = StochasticResult
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "normalize_output": False,
+        "method": "platen",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+        "heterodyne": False,
+    }
+
+    def __init__(self, H, sc_ops, *, options=None):
+        if isinstance(sc_ops, (Qobj, QobjEvo)):
+            sc_ops = [sc_ops]
+        sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
+        if not H.issuper:
+            L = liouvillian(H, sc_ops)
+        else:
+            L = H + sum(lindblad_dissipator(c_op) for c_op in sc_ops)
+        rhs = StochasticOpenSystem(L, sc_ops)
+        super().__init__(rhs, options=options)
+
+        if self.options["heterodyne"]:
+            self.m_ops += [
+                sc_op + sc_op.dag(), -1j * (sc_op - sc_op.dag())
+                for sc_op in sc_ops
+            ]
+        else:
+            self.m_ops = [sc_op + sc_op.dag() for sc_op in sc_ops]
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        result = StochasticTrajResult(e_ops, self.options, m_ops=self.m_ops)
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
+        result.add(tlist[0], self._restore_state(state, copy=False), None)
+        for t in tlist[1:]:
+            t, state, noise = self._integrator.integrate(t, copy=False)
+            result.add(t, self._restore_state(state, copy=False), noise)
+        return seed, result

From e8e8b5fc36cf49a5b7958be2cb637a7fdc8c58b2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 12 Jan 2023 09:41:26 -0500
Subject: [PATCH 023/602] Working

---
 qutip/solver/integrator.py    | 82 +++++++++++++++++++++++++++++++++++
 qutip/solver/sode/_sode.pyx   | 18 +++++---
 qutip/solver/sode/sode.py     | 14 +++---
 qutip/solver/sode/ssystem.pyx | 66 ++++++++++++++++++----------
 qutip/solver/stochastics.py   | 50 +--------------------
 5 files changed, 147 insertions(+), 83 deletions(-)

diff --git a/qutip/solver/integrator.py b/qutip/solver/integrator.py
index 44df5546f1..23ab8b0039 100644
--- a/qutip/solver/integrator.py
+++ b/qutip/solver/integrator.py
@@ -238,3 +238,85 @@ def options(self, new_options):
                if key in new_options and new_options[key] is not None
             }
         }
+
+
+class SIntegrator(Integrator):
+    """
+    A wrapper around stochastic ODE solvers.
+
+    Parameters
+    ----------
+    system: qutip.StochasticSystem
+        Quantum system in which states evolve.
+
+    options: dict
+        Options for the integrator.
+
+    Class Attributes
+    ----------------
+    name : str
+        The name of the integrator.
+
+    supports_blackbox : bool
+        If True, then the integrator calls only ``system.matmul``,
+        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
+        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
+        the integrator to modify the system in creative ways. In particular,
+        the solver may modify the system depending on *both* the time ``t``
+        *and* the current ``state`` the system is being applied to.
+
+        If the integrator calls any other methods, set to False.
+
+    supports_time_dependent : bool
+        If True, then the integrator supports time dependent systems. If False,
+        ``supports_blackbox`` should usually be ``False`` too.
+
+    integrator_options : dict
+        A dictionary of options used by the integrator and their default
+        values. Once initiated, ``self.options`` will be a dict with the same
+        keys, not the full options object passed to the solver. Options' keys
+        included here will be supported by the :cls:SolverOdeOptions.
+    """
+    def set_state(self, t, state0, generator):
+        """
+        Set the state of the SODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        raise NotImplementedError
+
+
+    def integrate(self, t, copy=True):
+        """
+        Evolve to t.
+
+        Before calling `integrate` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state, noise) : (float, qutip.Data, np.ndarray)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+
+    def mcstep(self, t, copy=True):
+        raise NotImplementedError
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index daa736e5cc..09b72b5b7c 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -1,11 +1,17 @@
+#cython: language_level=3
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
 from qutip.core.data cimport Data
+from collections import defaultdict
+cimport cython
+import numpy as np
+
+N_dws = defaultdict(lambda : 1)
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cpdef Data euler(StochasticSystem system, t, Data state, dt, dW):
+cpdef Data euler(system, t, Data state, double dt, double[:, :] dW):
     """
     Integration scheme:
     Basic Euler order 0.5
@@ -18,13 +24,13 @@ cpdef Data euler(StochasticSystem system, t, Data state, dt, dW):
     b = system.diffusion(t, state)
     new_state = _data.add(state, a, dt)
     for i in range(system.num_collapse):
-        new_state = _data.add(new_state, b[i], dW[i])
+        new_state = _data.add(new_state, b[i], dW[i, 0])
     return new_state
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cpdef Data platen(StochasticSystem system, t, Data state, dt, dW):
+cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     """
     Platen rhs function for both master eq and schrodinger eq.
     dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
@@ -38,7 +44,7 @@ cpdef Data platen(StochasticSystem system, t, Data state, dt, dW):
     """
     cdef int i, j
     cdef double sqrt_dt = np.sqrt(dt)
-    cdef double sqrt_dt_inv = 0.25/sqrt_dt
+    cdef double sqrt_dt_inv = 0.25 / sqrt_dt
     cdef double dw, dw2
 
     d1 = _data.add(system.drift(t, state), state)
@@ -59,13 +65,13 @@ cpdef Data platen(StochasticSystem system, t, Data state, dt, dW):
     for i in range(system.num_collapse):
         d2p = system.diffusion(t, Vp[i])
         d2m = system.diffusion(t, Vm[i])
-        dw = dW[i] * 0.25
+        dw = dW[i, 0] * 0.25
         out = _data.add(out, d2m[i], dw)
         out = _data.add(out, d2[i], 2 * dw)
         out = _data.add(out, d2p[i], dw)
 
         for j in range(system.num_collapse):
-            dw2 = sqrt_dt_inv * (dW[i] * dW[j] - dt * (i == j))
+            dw2 = sqrt_dt_inv * (dW[i, 0] * dW[j, 0] - dt * (i == j))
             out = _data.add(out, d2p[j], dw2)
             out = _data.add(out, d2m[j], -dw2)
 
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 7dcd20e46e..8a7c3b4f4a 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -1,6 +1,6 @@
 
-import ._sode as sstepper
-
+from . import _sode as sstepper
+from ..integrator import SIntegrator
 
 
 class ExplicitIntegrator(SIntegrator):
@@ -14,6 +14,8 @@ def __init__(self, system, options):
         self.dt = self.options["dt"]
         self.tol = self.options["tol"]
         self.stepper = getattr(sstepper, options["method"])
+        self.N_dw = sstepper.N_dws[options["method"]]
+        self.N_drift = system.num_collapse
 
     def _step(self, dt, dW):
         new_state = self.stepper(self.system, self.t, self.state, dt, dW)
@@ -28,14 +30,16 @@ def set_state(self, t, state0, generator):
     def integrate(self, t, copy=True):
         delta_t = (t - self.t)
         dt = self.dt
-        N, err = np.divmod(delta_t, dt)
-        if err > self.tol:
+        N, extra = np.divmod(delta_t, dt)
+        if extra > self.tol:
             # Not a whole number of steps.
             N += 1
             dt = delta_t / N
-        dW = self.generator.normal(0, np.sqrt(dt), size=(N, self.system.num_dw))
+        dW = self.generator.normal(0, np.sqrt(dt), size=(N, self.N_drift, self.N_dw))
+
         for i in range(N):
             self._step(dt, dW[i, :])
+
         return self.t, self.state, np.sum(dW, axis=0) / (N * dt)
 
     def get_state(self, copy=True):
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 1a88b1c2ca..f84ace2e22 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -1,3 +1,4 @@
+#cython: language_level=3
 """
 Class to represent a stochastic differential equation system.
 """
@@ -5,39 +6,51 @@ Class to represent a stochastic differential equation system.
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
 from qutip.core.data cimport Data
+cimport cython
+import numpy as np
+from qutip.core import spre, spost
 
 cdef class StochasticSystem:
-    """
+    cdef object d1, d2
+    cdef int num_collapse
+    cdef double t
+    cdef double state
 
-    """
     def __init__(self, a, b):
-        self.a = a
-        self.b = b
+        self.d1 = a
+        self.d2 = b
+        self.num_collapse = 1
 
     def drift(self, t, state):
-        return self.b(t, state)
+        return self.d1(t, state)
 
     def diffusion(self, t, state):
-        return self.a(t, state)
+        return self.d2(t, state)
+
+
+    cdef void set_state(self, double t, Data state):
+        self.t = t
+        self.state = state
 
+    cdef Data a(self, double t, Data state):
+        return self.d1(self.t, self.state)
 
+    cdef object b(self, double t, Data state):
+        return self.d2(self.t, self.state)
 
-cdef class StochasticClosedSystem:
-    """
 
-    """
+
+cdef class StochasticClosedSystem(StochasticSystem):
     cdef QobjEvo H
     cdef list c_ops
     cdef list cpcd_ops
     cdef object imp
-    cdef Data state
-    cdef double t
 
-    def __init__(self, H, c_ops, dt, options=None, implicit=False):
+    def __init__(self, H, c_ops, heterodyne, implicit=False):
         self.H = H
         self.c_ops = c_ops
         self.cpcd_ops = [op + op.dag() for op in c_ops]
-        self.dt = dt
+        self.num_collapse = len(c_ops)
 
     def drift(self, double t, Data state):
         cdef int i
@@ -45,7 +58,7 @@ cdef class StochasticClosedSystem:
         cdef Data temp, out
 
         out = self.L.matmul_data(t, state)
-        for i in range(len(self.c_ops)):
+        for i in range(self.num_collapse):
             c_op = self.cpcd_ops[i]
             e = c_op.expect_data(t, state)
             c_op = self.c_ops[i]
@@ -57,7 +70,7 @@ cdef class StochasticClosedSystem:
         cdef int i
         cdef QobjEvo c_op
         out = []
-        for i in range(len(self.c_ops)):
+        for i in range(self.num_collapse):
             c_op = self.c_ops[i]
             _out = c_op.matmul_data(t, state)
             c_op = self.cpcd_ops[i]
@@ -66,19 +79,24 @@ cdef class StochasticClosedSystem:
         return out
 
 
-cdef class StochasticOpenSystem:
-    """
-
-    """
+cdef class StochasticOpenSystem(StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
     cdef object imp
-    cdef Data state
-    cdef double t
 
-    def __init__(self, H, c_ops):
+
+    def __init__(self, H, c_ops, heterodyne):
         self.L = H
-        self.c_ops = c_ops
+        if heterodyne:
+            self.c_ops = []
+            for c in c_ops:
+                self.c_ops += [
+                    (spre(c) + spost(c.dag())) / np.sqrt(2),
+                    (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)
+                ]
+        else:
+            self.c_ops = [spre(op) + spost(op.dag()) for op in c_ops]
+        self.num_collapse = len(self.c_ops)
 
     def drift(self, double t, Data state):
         return self.L.matmul_data(t, state)
@@ -88,7 +106,7 @@ cdef class StochasticOpenSystem:
         cdef QobjEvo c_op
         cdef complex expect
         cdef out = []
-        for i in range(self.num_ops):
+        for i in range(self.num_collapse):
             c_op = self.c_ops[i]
             vec = c_op.matmul_data(t, state)
             expect = _data.trace_oper_ket(vec)
diff --git a/qutip/solver/stochastics.py b/qutip/solver/stochastics.py
index 481812ce45..2e5219b244 100644
--- a/qutip/solver/stochastics.py
+++ b/qutip/solver/stochastics.py
@@ -1,56 +1,10 @@
 __all__ = ["smesolve", "SMESolver"]
 
-from .integrator import Integrator
+from .sode.sode import ExplicitIntegrator
 from .result import MultiTrajResult, Result
 from .multitraj import MultiTrajSolver
 
 
-class SIntegrator(Integrator):
-    def set_state(self, t, state0, generator):
-        """
-        Set the state of the SODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        generator : numpy.random.generator
-            Random number generator.
-        """
-        raise NotImplementedError
-
-
-    def integrate(self, t, copy=True):
-        """
-        Evolve to t.
-
-        Before calling `integrate` for the first time, the initial state should
-        be set with `set_state`.
-
-        Parameters
-        ----------
-        t : float
-            Time to integrate to, should be larger than the previous time.
-
-        copy : bool [True]
-            Whether to return a copy of the state or the state itself.
-
-        Returns
-        -------
-        (t, state, noise) : (float, qutip.Data, np.ndarray)
-            The state of the solver at ``t``.
-        """
-        raise NotImplementedError
-
-
-    def mcstep(self, t, copy=True):
-        raise NotImplementedError
-
-
 class StochasticTrajResult(Result):
     def _post_init(self, m_ops=()):
         super()._post_init()
@@ -162,7 +116,7 @@ def __init__(self, H, sc_ops, *, options=None):
             L = liouvillian(H, sc_ops)
         else:
             L = H + sum(lindblad_dissipator(c_op) for c_op in sc_ops)
-        rhs = StochasticOpenSystem(L, sc_ops)
+        rhs = StochasticOpenSystem(L, sc_ops, self.options["heterodyne"])
         super().__init__(rhs, options=options)
 
         if self.options["heterodyne"]:

From de8a752838b43515b7c315342697c73bad963566 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 18 Jan 2023 15:46:40 -0500
Subject: [PATCH 024/602] Simple smesolve run working

---
 qutip/solver/sode/_sode.pyx                   |  6 +-
 qutip/solver/sode/sode.py                     | 43 ++++++++-
 qutip/solver/sode/ssystem.pyx                 | 23 +++--
 .../solver/{stochastics.py => stochastic.py}  | 94 +++++++++++++------
 4 files changed, 122 insertions(+), 44 deletions(-)
 rename qutip/solver/{stochastics.py => stochastic.py} (67%)

diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 09b72b5b7c..92afe83927 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -47,7 +47,7 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     cdef double sqrt_dt_inv = 0.25 / sqrt_dt
     cdef double dw, dw2
 
-    d1 = _data.add(system.drift(t, state), state)
+    d1 = _data.add(state, system.drift(t, state), dt)
     d2 = system.diffusion(t, state)
 
     out = _data.mul(d1, 0.5)
@@ -57,10 +57,10 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     for i in range(system.num_collapse):
         Vp.append(_data.add(d1, d2[i], sqrt_dt))
         Vm.append(_data.add(d1, d2[i], -sqrt_dt))
-        Vt = _data.add(Vt, d2[i], dW[i])
+        Vt = _data.add(Vt, d2[i], dW[i, 0])
 
     d1 = system.drift(t, Vt)
-    out = _data.add(out, d1, 0.5)
+    out = _data.add(out, d1, 0.5 * dt)
     out = _data.add(out, state, 0.5)
     for i in range(system.num_collapse):
         d2p = system.diffusion(t, Vp[i])
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 8a7c3b4f4a..2161ce386b 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -1,15 +1,19 @@
-
+import numpy as np
 from . import _sode as sstepper
-from ..integrator import SIntegrator
-
+from ..integrator.integrator import SIntegrator, Integrator
+from ..stochastic import StochasticSolver
 
 class ExplicitIntegrator(SIntegrator):
+    """
+    Stochastic evolution solver
+    """
     integrator_options = {
         "dt": 0.001,
         "tol": 1e-7,
     }
     def __init__(self, system, options):
         self.system = system
+        self._options = self.integrator_options.copy()
         self.options = options
         self.dt = self.options["dt"]
         self.tol = self.options["tol"]
@@ -29,13 +33,23 @@ def set_state(self, t, state0, generator):
 
     def integrate(self, t, copy=True):
         delta_t = (t - self.t)
+        if delta_t < 0:
+            raise ValueError("Stochastic integration time")
+        elif delta_t == 0:
+            return self.t, self.state, np.zeros((0, self.N_drift, self.N_dw))
+
         dt = self.dt
         N, extra = np.divmod(delta_t, dt)
+        N = int(N)
         if extra > self.tol:
             # Not a whole number of steps.
             N += 1
             dt = delta_t / N
-        dW = self.generator.normal(0, np.sqrt(dt), size=(N, self.N_drift, self.N_dw))
+        dW = self.generator.normal(
+            0,
+            np.sqrt(dt),
+            size=(N, self.N_drift, self.N_dw)
+        )
 
         for i in range(N):
             self._step(dt, dW[i, :])
@@ -44,3 +58,24 @@ def integrate(self, t, copy=True):
 
     def get_state(self, copy=True):
         return self.t, self.state, self.generator
+
+    @property
+    def options(self):
+        """
+        Supported options by verner method:
+
+        dt : float, default=0.001
+            Internal time step.
+
+        tol : float, default=1e-7
+            Relative tolerance.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+StochasticSolver.add_integrator(ExplicitIntegrator, "euler")
+StochasticSolver.add_integrator(ExplicitIntegrator, "platen")
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index f84ace2e22..de7546b4f9 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -10,11 +10,19 @@ cimport cython
 import numpy as np
 from qutip.core import spre, spost
 
+__all__ = [
+    "StochasticSystem", "StochasticOpenSystem", "StochasticClosedSystem"
+]
+
+
+
 cdef class StochasticSystem:
     cdef object d1, d2
-    cdef int num_collapse
+    cdef readonly int num_collapse
     cdef double t
     cdef double state
+    cdef readonly bint issuper
+    cdef readonly object dims
 
     def __init__(self, a, b):
         self.d1 = a
@@ -27,18 +35,10 @@ cdef class StochasticSystem:
     def diffusion(self, t, state):
         return self.d2(t, state)
 
-
     cdef void set_state(self, double t, Data state):
         self.t = t
         self.state = state
 
-    cdef Data a(self, double t, Data state):
-        return self.d1(self.t, self.state)
-
-    cdef object b(self, double t, Data state):
-        return self.d2(self.t, self.state)
-
-
 
 cdef class StochasticClosedSystem(StochasticSystem):
     cdef QobjEvo H
@@ -51,6 +51,8 @@ cdef class StochasticClosedSystem(StochasticSystem):
         self.c_ops = c_ops
         self.cpcd_ops = [op + op.dag() for op in c_ops]
         self.num_collapse = len(c_ops)
+        self.issuper = False
+        self.dims = self.H.dims
 
     def drift(self, double t, Data state):
         cdef int i
@@ -84,7 +86,6 @@ cdef class StochasticOpenSystem(StochasticSystem):
     cdef list c_ops
     cdef object imp
 
-
     def __init__(self, H, c_ops, heterodyne):
         self.L = H
         if heterodyne:
@@ -97,6 +98,8 @@ cdef class StochasticOpenSystem(StochasticSystem):
         else:
             self.c_ops = [spre(op) + spost(op.dag()) for op in c_ops]
         self.num_collapse = len(self.c_ops)
+        self.issuper = True
+        self.dims = self.L.dims
 
     def drift(self, double t, Data state):
         return self.L.matmul_data(t, state)
diff --git a/qutip/solver/stochastics.py b/qutip/solver/stochastic.py
similarity index 67%
rename from qutip/solver/stochastics.py
rename to qutip/solver/stochastic.py
index 2e5219b244..39ed014674 100644
--- a/qutip/solver/stochastics.py
+++ b/qutip/solver/stochastic.py
@@ -1,8 +1,10 @@
 __all__ = ["smesolve", "SMESolver"]
 
-from .sode.sode import ExplicitIntegrator
+from .sode.ssystem import *
 from .result import MultiTrajResult, Result
 from .multitraj import MultiTrajSolver
+from ..import Qobj, QobjEvo, liouvillian, lindblad_dissipator
+import numpy as np
 
 
 class StochasticTrajResult(Result):
@@ -11,7 +13,6 @@ def _post_init(self, m_ops=()):
         self.noise = []
         self.m_ops = m_ops
         self.measurements = [[] for _ in range(len(m_ops))]
-        self.add_processor(self._add_measurement)
 
     def _add_measurement(self, t, state, noise):
         expects = [m_op.expect(t, state) for m_op in self.m_ops]
@@ -19,9 +20,10 @@ def _add_measurement(self, t, state, noise):
         for measure, expect, dW in zip(self.measurements, expects, noises):
             measure.append(expect + dW)
 
-    def add(t, state, noise):
+    def add(self, t, state, noise):
         super().add(t, state)
-        self._add_measurement(t, state, noise)
+        if noise is not None:
+            self._add_measurement(t, state, noise)
         self.noise.append(noise)
 
 
@@ -85,12 +87,55 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
     sc_ops = [QobjEvo(c_op, args=args) for c_op in sc_ops]
     L = liouvillian(H, c_ops)
-    sol = SMESolver(L, sc_ops, options=options)
-    return sol.run(rho0, tlist, e_ops, m_ops, ntraj)
+    sol = SMESolver(L, sc_ops, options=options or {}, m_ops=m_ops)
+    return sol.run(rho0, tlist, ntraj, e_ops=e_ops)
 
 
-class SMESolver(MultiTrajSolver):
-    name = "generic multi trajectory"
+class StochasticSolver(MultiTrajSolver):
+    name = "generic stochastic"
+    resultclass = StochasticResult
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "normalize_output": False,
+        "method": "euler",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+    }
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        result = StochasticTrajResult(e_ops, self.options, m_ops=self.m_ops)
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
+        state_t = self._restore_state(state, copy=False)
+        result.add(tlist[0], state_t, None)
+        for t in tlist[1:]:
+            t, state, noise = self._integrator.integrate(t, copy=False)
+            state_t = self._restore_state(state, copy=False)
+            result.add(t, state_t, noise)
+        return seed, result
+
+    @classmethod
+    def avail_integrators(cls):
+        if cls is StochasticSolver:
+            return cls._avail_integrators.copy()
+        return {
+            **StochasticSolver.avail_integrators(),
+            **cls._avail_integrators,
+        }
+
+
+class SMESolver(StochasticSolver):
+    name = "smesolve"
     resultclass = StochasticResult
     _avail_integrators = {}
     solver_options = {
@@ -108,34 +153,29 @@ class SMESolver(MultiTrajSolver):
         "heterodyne": False,
     }
 
-    def __init__(self, H, sc_ops, *, options=None):
+    def __init__(self, H, sc_ops, *, options=None, m_ops=()):
+        self._options = self.solver_options.copy()
+        self.options = options
         if isinstance(sc_ops, (Qobj, QobjEvo)):
             sc_ops = [sc_ops]
         sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
         if not H.issuper:
             L = liouvillian(H, sc_ops)
         else:
+            if any(not c_op.isoper for c_op in sc_ops):
+                raise TypeError("sc_ops must be operators")
             L = H + sum(lindblad_dissipator(c_op) for c_op in sc_ops)
         rhs = StochasticOpenSystem(L, sc_ops, self.options["heterodyne"])
         super().__init__(rhs, options=options)
 
-        if self.options["heterodyne"]:
-            self.m_ops += [
-                sc_op + sc_op.dag(), -1j * (sc_op - sc_op.dag())
-                for sc_op in sc_ops
-            ]
+
+        if len(m_ops) == rhs.num_collapse:
+            self.m_ops = m_ops
+        elif self.options["heterodyne"]:
+            self.m_ops = []
+            for sc_op in sc_ops:
+                self.m_ops += [
+                    sc_op + sc_op.dag(), -1j * (sc_op - sc_op.dag())
+                ]
         else:
             self.m_ops = [sc_op + sc_op.dag() for sc_op in sc_ops]
-
-    def _run_one_traj(self, seed, state, tlist, e_ops):
-        """
-        Run one trajectory and return the result.
-        """
-        result = StochasticTrajResult(e_ops, self.options, m_ops=self.m_ops)
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False), None)
-        for t in tlist[1:]:
-            t, state, noise = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False), noise)
-        return seed, result

From b4120f3f544b99c74fb54146d093a9d457abd418 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 19 Jan 2023 17:04:28 -0500
Subject: [PATCH 025/602] add explicit 1.5

---
 qutip/solver/integrator/integrator.py |  82 --------------
 qutip/solver/sode/_sode.pyx           | 125 ++++++++++++++++++++-
 qutip/solver/sode/sode.py             | 153 ++++++++++++++++++++++++--
 qutip/solver/sode/ssystem.pyx         |  26 +++--
 4 files changed, 285 insertions(+), 101 deletions(-)

diff --git a/qutip/solver/integrator/integrator.py b/qutip/solver/integrator/integrator.py
index 23ab8b0039..44df5546f1 100644
--- a/qutip/solver/integrator/integrator.py
+++ b/qutip/solver/integrator/integrator.py
@@ -238,85 +238,3 @@ def options(self, new_options):
                if key in new_options and new_options[key] is not None
             }
         }
-
-
-class SIntegrator(Integrator):
-    """
-    A wrapper around stochastic ODE solvers.
-
-    Parameters
-    ----------
-    system: qutip.StochasticSystem
-        Quantum system in which states evolve.
-
-    options: dict
-        Options for the integrator.
-
-    Class Attributes
-    ----------------
-    name : str
-        The name of the integrator.
-
-    supports_blackbox : bool
-        If True, then the integrator calls only ``system.matmul``,
-        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
-        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
-        the integrator to modify the system in creative ways. In particular,
-        the solver may modify the system depending on *both* the time ``t``
-        *and* the current ``state`` the system is being applied to.
-
-        If the integrator calls any other methods, set to False.
-
-    supports_time_dependent : bool
-        If True, then the integrator supports time dependent systems. If False,
-        ``supports_blackbox`` should usually be ``False`` too.
-
-    integrator_options : dict
-        A dictionary of options used by the integrator and their default
-        values. Once initiated, ``self.options`` will be a dict with the same
-        keys, not the full options object passed to the solver. Options' keys
-        included here will be supported by the :cls:SolverOdeOptions.
-    """
-    def set_state(self, t, state0, generator):
-        """
-        Set the state of the SODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        generator : numpy.random.generator
-            Random number generator.
-        """
-        raise NotImplementedError
-
-
-    def integrate(self, t, copy=True):
-        """
-        Evolve to t.
-
-        Before calling `integrate` for the first time, the initial state should
-        be set with `set_state`.
-
-        Parameters
-        ----------
-        t : float
-            Time to integrate to, should be larger than the previous time.
-
-        copy : bool [True]
-            Whether to return a copy of the state or the state itself.
-
-        Returns
-        -------
-        (t, state, noise) : (float, qutip.Data, np.ndarray)
-            The state of the solver at ``t``.
-        """
-        raise NotImplementedError
-
-
-    def mcstep(self, t, copy=True):
-        raise NotImplementedError
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 92afe83927..4a8becdaed 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -6,8 +6,6 @@ from collections import defaultdict
 cimport cython
 import numpy as np
 
-N_dws = defaultdict(lambda : 1)
-
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
@@ -20,6 +18,7 @@ cpdef Data euler(system, t, Data state, double dt, double[:, :] dW):
     By Peter E. Kloeden, Eckhard Platen
     """
     cdef int i
+
     a = system.drift(t, state)
     b = system.diffusion(t, state)
     new_state = _data.add(state, a, dt)
@@ -47,8 +46,10 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     cdef double sqrt_dt_inv = 0.25 / sqrt_dt
     cdef double dw, dw2
 
-    d1 = _data.add(state, system.drift(t, state), dt)
-    d2 = system.diffusion(t, state)
+    cdef Data d1 = _data.add(state, system.drift(t, state), dt)
+    cdef list d2 = system.diffusion(t, state)
+    cdef Data Vt, out
+    cdef list Vp, Vm
 
     out = _data.mul(d1, 0.5)
     Vt = d1.copy()
@@ -76,3 +77,119 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
             out = _data.add(out, d2m[j], -dw2)
 
     return out
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.cdivision(True)
+cdef void explicit15(system, t, Data state, double dt, double[:, :] dW):
+    """
+    Chapter 11.2 Eq. (2.13)
+    Numerical Solution of Stochastic Differential Equations
+    By Peter E. Kloeden, Eckhard Platen
+    """
+    cdef int i, j, k
+    cdef double sqrt_dt = np.sqrt(dt)
+    cdef double sqrt_dt_inv = 1./sqrt_dt
+    cdef double ddz, ddw, ddd
+    cdef double[::1] dz, dw
+    dw = np.empty(system.num_collapse)
+    dz = np.empty(system.num_collapse)
+    for i in range(system.num_collapse):
+        dw[i] = dW[i, 0]
+        dz[i] = 0.5 *(dW[i, 0] + 1./np.sqrt(3) * noise[i, 1])
+
+    d1 = system.drift(t, state)
+    d2 = system.diffusion(t, state)
+    dd2 = system.diffusion(t+dt, state)
+    # Euler part
+    out = _data.add(state, d1)
+    for i in range(system.num_collapse):
+        out = _data.add(out, d2[:], dw[i])
+
+    V = _data.add(state, d1, 1./self.num_ops)
+
+    v2p = []
+    v2m = []
+    for i in range(system.num_collapse):
+        v2p.append(_data.add(V, d2[i], sqrt_dt))
+        v2m.append(_data.add(V, d2[i], -sqrt_dt))
+
+    p2p = []
+    p2m = []
+    for i in range(system.num_collapse):
+        d2p = system.diffusion(t, v2p[i])
+        d2m = system.diffusion(t, v2m[i])
+        ddw = (dw[i] * dw[i] - dt) * 0.25 * sqrt_dt_inv  # 1.0
+        out = _data.add(out, d2p[i], ddw)
+        out = _data.add(out, d2m[i], -ddw)
+        temp_p2p = []
+        temp_p2m = []
+        for j in range(system.num_collapse):
+            temp_p2p.append(v2p[i], d2p[j], sqrt_dt)
+            temp_p2m.append(v2p[i], d2p[j], -sqrt_dt)
+        p2p.append(temp_p2p)
+        p2m.append(temp_p2m)
+
+    out = _data.add(out, d1, -0.5*(self.num_ops))
+
+    for i in range(system.num_collapse):
+        ddz = dz[i] * 0.5 / sqrt_dt  # 1.5
+        ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt  # 1.5
+
+        d1p = system.drift(t + dt/self.num_ops, v2p[i])
+        d1m = system.drift(t + dt/self.num_ops, v2m[i])
+        d2p = system.diffusion(t, v2p[i])
+        d2m = system.diffusion(t, v2m[i])
+        d2pp = system.diffusion(t, p2p[i][i])
+        d2mm = system.diffusion(t, p2m[i][i])
+
+        out = _data.add(out, d1p, 0.25 + ddz)
+        out = _data.add(out, d1m, 0.25 - ddz)
+
+        out = _data.add(out, dd2[i], dw[i] - dz[i])
+        out = _data.add(out, d2[i], dz[i] - dw[i])
+
+        out = _data.add(out, d2pp[i], ddd)
+        out = _data.add(out, d2mm[i], ddd)
+        out = _data.add(out, d2p[i], ddd)
+        out = _data.add(out, d2m[i], ddd)
+
+        for j in range(system.num_collapse):
+            ddw = 0.5 * (dw[j] - dz[j])  # O(1.5)
+            out = _data.add(out, d2p[j], ddw)
+            out = _data.add(out, d2[j], -2*ddw)
+            out = _data.add(out, d2m[j], ddw)
+
+            if j > i:
+                ddw = 0.5 * (dw[i] * dw[j]) / sqrt_dt  # O(1.0)
+                out = _data.add(out, d2p[j], ddw)
+                out = _data.add(out, d2m[j], -ddw)
+
+                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
+                d2pp = self.diffusion(t, p2p[j][i])
+                d2mm = self.diffusion(t, p2m[j][i])
+
+                out = _data.add(out, d2pp[j], ddw)
+                out = _data.add(out, d2mm[j], -ddw)
+                out = _data.add(out, d2p[j], -ddw)
+                out = _data.add(out, d2m[j], ddw)s
+
+                for k in range(j+1, system.num_collapse):
+                    ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt  # O(1.5)
+
+                    out = _data.add(out, d2pp[k], ddw)
+                    out = _data.add(out, d2mm[k], -ddw)
+                    out = _data.add(out, d2p[k], -ddw)
+                    out = _data.add(out, d2m[k], ddw)
+
+            if j < i:
+                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
+
+                d2pp = self.diffusion(t, p2p[j][i])
+                d2mm = self.diffusion(t, p2m[j][i])
+
+                out = _data.add(out, d2pp[j], ddw)
+                out = _data.add(out, d2mm[j], -ddw)
+                out = _data.add(out, d2p[j], -ddw)
+                out = _data.add(out, d2m[j], ddw)
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 2161ce386b..9cf25c9370 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -1,9 +1,92 @@
 import numpy as np
-from . import _sode as sstepper
-from ..integrator.integrator import SIntegrator, Integrator
+from . import _sode
+from ..integrator.integrator import Integrator
 from ..stochastic import StochasticSolver
 
-class ExplicitIntegrator(SIntegrator):
+
+class SIntegrator(Integrator):
+    """
+    A wrapper around stochastic ODE solvers.
+
+    Parameters
+    ----------
+    system: qutip.StochasticSystem
+        Quantum system in which states evolve.
+
+    options: dict
+        Options for the integrator.
+
+    Class Attributes
+    ----------------
+    name : str
+        The name of the integrator.
+
+    supports_blackbox : bool
+        If True, then the integrator calls only ``system.matmul``,
+        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
+        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
+        the integrator to modify the system in creative ways. In particular,
+        the solver may modify the system depending on *both* the time ``t``
+        *and* the current ``state`` the system is being applied to.
+
+        If the integrator calls any other methods, set to False.
+
+    supports_time_dependent : bool
+        If True, then the integrator supports time dependent systems. If False,
+        ``supports_blackbox`` should usually be ``False`` too.
+
+    integrator_options : dict
+        A dictionary of options used by the integrator and their default
+        values. Once initiated, ``self.options`` will be a dict with the same
+        keys, not the full options object passed to the solver. Options' keys
+        included here will be supported by the :cls:SolverOdeOptions.
+    """
+    def set_state(self, t, state0, generator):
+        """
+        Set the state of the SODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        raise NotImplementedError
+
+
+    def integrate(self, t, copy=True):
+        """
+        Evolve to t.
+
+        Before calling `integrate` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state, noise) : (float, qutip.Data, np.ndarray)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+
+    def mcstep(self, t, copy=True):
+        raise NotImplementedError
+
+
+class _Explicit_Simple_Integrator(SIntegrator):
     """
     Stochastic evolution solver
     """
@@ -11,14 +94,15 @@ class ExplicitIntegrator(SIntegrator):
         "dt": 0.001,
         "tol": 1e-7,
     }
+    stepper = None
+    N_dw = 0
+
     def __init__(self, system, options):
         self.system = system
         self._options = self.integrator_options.copy()
         self.options = options
         self.dt = self.options["dt"]
         self.tol = self.options["tol"]
-        self.stepper = getattr(sstepper, options["method"])
-        self.N_dw = sstepper.N_dws[options["method"]]
         self.N_drift = system.num_collapse
 
     def _step(self, dt, dW):
@@ -62,7 +146,7 @@ def get_state(self, copy=True):
     @property
     def options(self):
         """
-        Supported options by verner method:
+        Supported options by Explicit Stochastic Integrators:
 
         dt : float, default=0.001
             Internal time step.
@@ -76,6 +160,59 @@ def options(self):
     def options(self, new_options):
         Integrator.options.fset(self, new_options)
 
+    def __init__(self, system, options):
+        self.system = system
+        self._options = self.integrator_options.copy()
+        self.options = options
+        self.dt = self.options["dt"]
+        self.tol = self.options["tol"]
+        self.stepper = getattr(sstepper, options["method"])
+        self.N_dw = sstepper.N_dws[options["method"]]
+        self.N_drift = system.num_collapse
+
+
+class EulerSODE(_Explicit_Simple_Integrator):
+    """
+    A simple generalization of the Euler method for ordinary
+    differential equations to stochastic differential equations.  Only
+    solver which could take non-commuting ``sc_ops``.
+
+    - Order: 0.5
+    """
+    stepper = _sode.euler
+    N_dw = 1
+
+
+class PlatenSODE(_Explicit_Simple_Integrator):
+    """
+    Explicit scheme, creates the Milstein using finite differences
+    instead of analytic derivatives. Also contains some higher order
+    terms, thus converges better than Milstein while staying strong
+    order 1.0.  Does not require derivatives. See eq. (7.47) of chapter 7 of
+    H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum Systems*.
+
+    - Order: strong 1, weak 2
+    """
+    stepper = _sode.platen
+    N_dw = 1
+
+
+class Explicit1_5_SODE(_Explicit_Simple_Integrator):
+    """
+    Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
+    Taylor scheme using finite difference instead of derivatives.
+    Slower than ``taylor15`` but usable when derrivatives cannot be
+    analytically obtained.
+    See eq. (2.13) of chapter 11.2 of Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations.*
+
+    - Order: strong 1.5
+    """
+    stepper = _sode.explicit15
+    N_dw = 2
+
 
-StochasticSolver.add_integrator(ExplicitIntegrator, "euler")
-StochasticSolver.add_integrator(ExplicitIntegrator, "platen")
+StochasticSolver.add_integrator(EulerSODE, "euler")
+StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
+StochasticSolver.add_integrator(PlatenSODE, "platen")
+StochasticSolver.add_integrator(PlatenSODE, "explicit1.5")
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index de7546b4f9..5df317f417 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -15,14 +15,13 @@ __all__ = [
 ]
 
 
-
-cdef class StochasticSystem:
-    cdef object d1, d2
+cdef class _StochasticSystem:
     cdef readonly int num_collapse
-    cdef double t
-    cdef double state
     cdef readonly bint issuper
     cdef readonly object dims
+    cdef Data state
+    cdef double t
+    cdef object imp
 
     def __init__(self, a, b):
         self.d1 = a
@@ -40,11 +39,25 @@ cdef class StochasticSystem:
         self.state = state
 
 
+cdef class GeneralStochasticSystem(_StochasticSystem):
+    cdef object d1, d2
+
+    def __init__(self, a, b):
+        self.d1 = a
+        self.d2 = b
+        self.num_collapse = 1
+
+    def drift(self, t, state):
+        return self.d1(t, state)
+
+    def diffusion(self, t, state):
+        return self.d2(t, state)
+
+
 cdef class StochasticClosedSystem(StochasticSystem):
     cdef QobjEvo H
     cdef list c_ops
     cdef list cpcd_ops
-    cdef object imp
 
     def __init__(self, H, c_ops, heterodyne, implicit=False):
         self.H = H
@@ -84,7 +97,6 @@ cdef class StochasticClosedSystem(StochasticSystem):
 cdef class StochasticOpenSystem(StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
-    cdef object imp
 
     def __init__(self, H, c_ops, heterodyne):
         self.L = H

From be091be2d00bbf020cd04ba3e3c7b016024a7283 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 20 Jan 2023 16:58:49 -0500
Subject: [PATCH 026/602] debug platen1.5

---
 qutip/solve/stochastic.py     |   2 +-
 qutip/solver/sode/_sode.pyx   |  82 ++++++++++---------
 qutip/solver/sode/sode.py     |  12 +--
 qutip/solver/sode/ssystem.pyx |  13 +--
 qutip/solver/stochastic.py    | 147 +++++++++++++++++++++++-----------
 setup.py                      |   9 ++-
 6 files changed, 161 insertions(+), 104 deletions(-)

diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index d1f76e685a..dde9876911 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -121,7 +121,7 @@ def stochastic_solvers():
             - Order strong 2.0
             - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
 
-        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
+        All solvers, except taylor2.0, are usable in both smesolve and (ssesolve)
         and for both heterodyne and homodyne. taylor2.0 only works for 1
         stochastic operator independent of time with the homodyne method.
         :func:`~general_stochastic` only accepts the derivative-free
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 4a8becdaed..a1fae73183 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -41,7 +41,7 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     The Theory of Open Quantum Systems
     Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
     """
-    cdef int i, j
+    cdef int i, j, num_ops = system.num_collapse
     cdef double sqrt_dt = np.sqrt(dt)
     cdef double sqrt_dt_inv = 0.25 / sqrt_dt
     cdef double dw, dw2
@@ -55,7 +55,7 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     Vt = d1.copy()
     Vp = []
     Vm = []
-    for i in range(system.num_collapse):
+    for i in range(num_ops):
         Vp.append(_data.add(d1, d2[i], sqrt_dt))
         Vm.append(_data.add(d1, d2[i], -sqrt_dt))
         Vt = _data.add(Vt, d2[i], dW[i, 0])
@@ -63,7 +63,7 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
     d1 = system.drift(t, Vt)
     out = _data.add(out, d1, 0.5 * dt)
     out = _data.add(out, state, 0.5)
-    for i in range(system.num_collapse):
+    for i in range(num_ops):
         d2p = system.diffusion(t, Vp[i])
         d2m = system.diffusion(t, Vm[i])
         dw = dW[i, 0] * 0.25
@@ -71,7 +71,7 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
         out = _data.add(out, d2[i], 2 * dw)
         out = _data.add(out, d2p[i], dw)
 
-        for j in range(system.num_collapse):
+        for j in range(num_ops):
             dw2 = sqrt_dt_inv * (dW[i, 0] * dW[j, 0] - dt * (i == j))
             out = _data.add(out, d2p[j], dw2)
             out = _data.add(out, d2m[j], -dw2)
@@ -82,42 +82,42 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
 @cython.boundscheck(False)
 @cython.wraparound(False)
 @cython.cdivision(True)
-cdef void explicit15(system, t, Data state, double dt, double[:, :] dW):
+cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
     """
     Chapter 11.2 Eq. (2.13)
     Numerical Solution of Stochastic Differential Equations
     By Peter E. Kloeden, Eckhard Platen
     """
-    cdef int i, j, k
+    cdef int i, j, k, num_ops = system.num_collapse
     cdef double sqrt_dt = np.sqrt(dt)
     cdef double sqrt_dt_inv = 1./sqrt_dt
     cdef double ddz, ddw, ddd
     cdef double[::1] dz, dw
-    dw = np.empty(system.num_collapse)
-    dz = np.empty(system.num_collapse)
-    for i in range(system.num_collapse):
+    dw = np.empty(num_ops)
+    dz = np.empty(num_ops)
+    for i in range(num_ops):
         dw[i] = dW[i, 0]
-        dz[i] = 0.5 *(dW[i, 0] + 1./np.sqrt(3) * noise[i, 1])
+        dz[i] = 0.5 *(dW[i, 0] + 1./np.sqrt(3) * dW[i, 1])
 
     d1 = system.drift(t, state)
     d2 = system.diffusion(t, state)
-    dd2 = system.diffusion(t+dt, state)
+    dd2 = system.diffusion(t + dt, state)
     # Euler part
-    out = _data.add(state, d1)
-    for i in range(system.num_collapse):
-        out = _data.add(out, d2[:], dw[i])
+    out = _data.add(state, d1, dt)
+    for i in range(num_ops):
+        out = _data.add(out, d2[i], dw[i])
 
-    V = _data.add(state, d1, 1./self.num_ops)
+    V = _data.add(state, d1, 1./num_ops)
 
     v2p = []
     v2m = []
-    for i in range(system.num_collapse):
+    for i in range(num_ops):
         v2p.append(_data.add(V, d2[i], sqrt_dt))
         v2m.append(_data.add(V, d2[i], -sqrt_dt))
 
     p2p = []
     p2m = []
-    for i in range(system.num_collapse):
+    for i in range(num_ops):
         d2p = system.diffusion(t, v2p[i])
         d2m = system.diffusion(t, v2m[i])
         ddw = (dw[i] * dw[i] - dt) * 0.25 * sqrt_dt_inv  # 1.0
@@ -125,20 +125,21 @@ cdef void explicit15(system, t, Data state, double dt, double[:, :] dW):
         out = _data.add(out, d2m[i], -ddw)
         temp_p2p = []
         temp_p2m = []
-        for j in range(system.num_collapse):
-            temp_p2p.append(v2p[i], d2p[j], sqrt_dt)
-            temp_p2m.append(v2p[i], d2p[j], -sqrt_dt)
+        for j in range(num_ops):
+            temp_p2p.append(_data.add(v2p[i], d2p[j], sqrt_dt))
+            temp_p2m.append(_data.add(v2p[i], d2p[j], -sqrt_dt))
         p2p.append(temp_p2p)
         p2m.append(temp_p2m)
 
-    out = _data.add(out, d1, -0.5*(self.num_ops))
+    out = _data.add(out, d1, -0.5*(num_ops))
 
-    for i in range(system.num_collapse):
-        ddz = dz[i] * 0.5 / sqrt_dt  # 1.5
-        ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt  # 1.5
+    for i in range(num_ops):
+        ddz = dz[i] * 0.5 / sqrt_dt *0 # 1.5
+        ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt *0 # 1.5
+
+        d1p = system.drift(t + dt/num_ops, v2p[i])
+        d1m = system.drift(t + dt/num_ops, v2m[i])
 
-        d1p = system.drift(t + dt/self.num_ops, v2p[i])
-        d1m = system.drift(t + dt/self.num_ops, v2m[i])
         d2p = system.diffusion(t, v2p[i])
         d2m = system.diffusion(t, v2m[i])
         d2pp = system.diffusion(t, p2p[i][i])
@@ -151,12 +152,13 @@ cdef void explicit15(system, t, Data state, double dt, double[:, :] dW):
         out = _data.add(out, d2[i], dz[i] - dw[i])
 
         out = _data.add(out, d2pp[i], ddd)
-        out = _data.add(out, d2mm[i], ddd)
-        out = _data.add(out, d2p[i], ddd)
+        out = _data.add(out, d2mm[i], -ddd)
+        out = _data.add(out, d2p[i], -ddd)
         out = _data.add(out, d2m[i], ddd)
 
-        for j in range(system.num_collapse):
-            ddw = 0.5 * (dw[j] - dz[j])  # O(1.5)
+
+        for j in range(num_ops):
+            ddw = 0.5 * (dw[j] - dz[j]) * 0  # O(1.5)
             out = _data.add(out, d2p[j], ddw)
             out = _data.add(out, d2[j], -2*ddw)
             out = _data.add(out, d2m[j], ddw)
@@ -166,17 +168,17 @@ cdef void explicit15(system, t, Data state, double dt, double[:, :] dW):
                 out = _data.add(out, d2p[j], ddw)
                 out = _data.add(out, d2m[j], -ddw)
 
-                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
-                d2pp = self.diffusion(t, p2p[j][i])
-                d2mm = self.diffusion(t, p2m[j][i])
+                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt * 0  # O(1.5)
+                d2pp = system.diffusion(t, p2p[j][i])
+                d2mm = system.diffusion(t, p2m[j][i])
 
                 out = _data.add(out, d2pp[j], ddw)
                 out = _data.add(out, d2mm[j], -ddw)
                 out = _data.add(out, d2p[j], -ddw)
-                out = _data.add(out, d2m[j], ddw)s
+                out = _data.add(out, d2m[j], ddw)
 
-                for k in range(j+1, system.num_collapse):
-                    ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt  # O(1.5)
+                for k in range(j+1, num_ops):
+                    ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt * 0  # O(1.5)
 
                     out = _data.add(out, d2pp[k], ddw)
                     out = _data.add(out, d2mm[k], -ddw)
@@ -184,12 +186,14 @@ cdef void explicit15(system, t, Data state, double dt, double[:, :] dW):
                     out = _data.add(out, d2m[k], ddw)
 
             if j < i:
-                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
+                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt * 0  # O(1.5)
 
-                d2pp = self.diffusion(t, p2p[j][i])
-                d2mm = self.diffusion(t, p2m[j][i])
+                d2pp = system.diffusion(t, p2p[j][i])
+                d2mm = system.diffusion(t, p2m[j][i])
 
                 out = _data.add(out, d2pp[j], ddw)
                 out = _data.add(out, d2mm[j], -ddw)
                 out = _data.add(out, d2p[j], -ddw)
                 out = _data.add(out, d2m[j], ddw)
+
+    return out
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 9cf25c9370..4cbe348ff8 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -160,16 +160,6 @@ def options(self):
     def options(self, new_options):
         Integrator.options.fset(self, new_options)
 
-    def __init__(self, system, options):
-        self.system = system
-        self._options = self.integrator_options.copy()
-        self.options = options
-        self.dt = self.options["dt"]
-        self.tol = self.options["tol"]
-        self.stepper = getattr(sstepper, options["method"])
-        self.N_dw = sstepper.N_dws[options["method"]]
-        self.N_drift = system.num_collapse
-
 
 class EulerSODE(_Explicit_Simple_Integrator):
     """
@@ -215,4 +205,4 @@ class Explicit1_5_SODE(_Explicit_Simple_Integrator):
 StochasticSolver.add_integrator(EulerSODE, "euler")
 StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
 StochasticSolver.add_integrator(PlatenSODE, "platen")
-StochasticSolver.add_integrator(PlatenSODE, "explicit1.5")
+StochasticSolver.add_integrator(Explicit1_5_SODE, "explicit1.5")
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 5df317f417..dc1304ee21 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -11,7 +11,7 @@ import numpy as np
 from qutip.core import spre, spost
 
 __all__ = [
-    "StochasticSystem", "StochasticOpenSystem", "StochasticClosedSystem"
+    "GeneralStochasticSystem", "StochasticOpenSystem", "StochasticClosedSystem"
 ]
 
 
@@ -54,13 +54,13 @@ cdef class GeneralStochasticSystem(_StochasticSystem):
         return self.d2(t, state)
 
 
-cdef class StochasticClosedSystem(StochasticSystem):
+cdef class StochasticClosedSystem(_StochasticSystem):
     cdef QobjEvo H
     cdef list c_ops
     cdef list cpcd_ops
 
     def __init__(self, H, c_ops, heterodyne, implicit=False):
-        self.H = H
+        self.H = -1j*H
         self.c_ops = c_ops
         self.cpcd_ops = [op + op.dag() for op in c_ops]
         self.num_collapse = len(c_ops)
@@ -72,7 +72,7 @@ cdef class StochasticClosedSystem(StochasticSystem):
         cdef QobjEvo c_op
         cdef Data temp, out
 
-        out = self.L.matmul_data(t, state)
+        out = self.H.matmul_data(t, state)
         for i in range(self.num_collapse):
             c_op = self.cpcd_ops[i]
             e = c_op.expect_data(t, state)
@@ -80,6 +80,7 @@ cdef class StochasticClosedSystem(StochasticSystem):
             temp = c_op.matmul_data(t, state)
             out = _data.add(out, state,  -0.125 * e * e)
             out = _data.add(out, temp, 0.5 * e)
+        return out
 
     def diffusion(self, double t, Data state):
         cdef int i
@@ -90,11 +91,11 @@ cdef class StochasticClosedSystem(StochasticSystem):
             _out = c_op.matmul_data(t, state)
             c_op = self.cpcd_ops[i]
             expect = c_op.expect_data(t, state)
-            out.append(_data.add(out, state, -0.5 * expect))
+            out.append(_data.add(_out, state, -0.5 * expect))
         return out
 
 
-cdef class StochasticOpenSystem(StochasticSystem):
+cdef class StochasticOpenSystem(_StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
 
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 39ed014674..3effba4333 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -1,4 +1,4 @@
-__all__ = ["smesolve", "SMESolver"]
+__all__ = ["smesolve", "SMESolver", "ssesolve", "SSESolver", "StochasticSolver"]
 
 from .sode.ssystem import *
 from .result import MultiTrajResult, Result
@@ -81,18 +81,76 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     output: :class:`qutip.solver.Result`
 
         An instance of the class :class:`qutip.solver.Result`.
-
     """
-    L = QobjEvo(H, args=args)
+    H = QobjEvo(H, args=args)
     c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
     sc_ops = [QobjEvo(c_op, args=args) for c_op in sc_ops]
-    L = liouvillian(H, c_ops)
+    if H.issuper:
+        L = H + liouvillian(None, c_ops)
+    else:
+        L = liouvillian(H, c_ops)
     sol = SMESolver(L, sc_ops, options=options or {}, m_ops=m_ops)
     return sol.run(rho0, tlist, ntraj, e_ops=e_ops)
 
 
+
+def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
+             args={}, ntraj=500, options=None):
+    """
+    Solve stochastic master equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    tlist : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    m_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    args : dict
+        ...
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    H = QobjEvo(H, args=args)
+    sc_ops = [QobjEvo(c_op, args=args) for c_op in sc_ops]
+    sol = SSESolver(H, sc_ops, options=options or {}, m_ops=m_ops)
+    return sol.run(psi0, tlist, ntraj, e_ops=e_ops)
+
+
 class StochasticSolver(MultiTrajSolver):
-    name = "generic stochastic"
+    name = "StochasticSolver"
     resultclass = StochasticResult
     _avail_integrators = {}
     solver_options = {
@@ -102,13 +160,47 @@ class StochasticSolver(MultiTrajSolver):
         "store_states": None,
         "keep_runs_results": False,
         "normalize_output": False,
-        "method": "euler",
+        "method": "platen",
         "map": "serial",
         "job_timeout": None,
         "num_cpus": None,
         "bitgenerator": None,
+        "heterodyne": False,
     }
 
+    def __init__(self, H, sc_ops, heterodyne=False, *, options=None, m_ops=()):
+        self._options = self.solver_options.copy()
+        self.options = options
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("...")
+        H = QobjEvo(H)
+
+        if isinstance(sc_ops, (Qobj, QobjEvo)):
+            sc_ops = [sc_ops]
+        sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
+        if any(not c_op.isoper for c_op in sc_ops):
+            raise TypeError("sc_ops must be operators")
+
+        if H.issuper:
+            L = H + liouvillian(None, sc_ops)
+            rhs = StochasticOpenSystem(L, sc_ops, heterodyne)
+        else:
+            rhs = StochasticClosedSystem(H, sc_ops, heterodyne)
+
+        super().__init__(rhs, options=options)
+
+        if len(m_ops) == rhs.num_collapse:
+            self.m_ops = m_ops
+        elif heterodyne:
+            self.m_ops = []
+            for sc_op in sc_ops:
+                self.m_ops += [
+                    sc_op + sc_op.dag(), -1j * (sc_op - sc_op.dag())
+                ]
+        else:
+            self.m_ops = [sc_op + sc_op.dag() for sc_op in sc_ops]
+
     def _run_one_traj(self, seed, state, tlist, e_ops):
         """
         Run one trajectory and return the result.
@@ -136,46 +228,9 @@ def avail_integrators(cls):
 
 class SMESolver(StochasticSolver):
     name = "smesolve"
-    resultclass = StochasticResult
     _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "keep_runs_results": False,
-        "normalize_output": False,
-        "method": "platen",
-        "map": "serial",
-        "job_timeout": None,
-        "num_cpus": None,
-        "bitgenerator": None,
-        "heterodyne": False,
-    }
 
-    def __init__(self, H, sc_ops, *, options=None, m_ops=()):
-        self._options = self.solver_options.copy()
-        self.options = options
-        if isinstance(sc_ops, (Qobj, QobjEvo)):
-            sc_ops = [sc_ops]
-        sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
-        if not H.issuper:
-            L = liouvillian(H, sc_ops)
-        else:
-            if any(not c_op.isoper for c_op in sc_ops):
-                raise TypeError("sc_ops must be operators")
-            L = H + sum(lindblad_dissipator(c_op) for c_op in sc_ops)
-        rhs = StochasticOpenSystem(L, sc_ops, self.options["heterodyne"])
-        super().__init__(rhs, options=options)
 
-
-        if len(m_ops) == rhs.num_collapse:
-            self.m_ops = m_ops
-        elif self.options["heterodyne"]:
-            self.m_ops = []
-            for sc_op in sc_ops:
-                self.m_ops += [
-                    sc_op + sc_op.dag(), -1j * (sc_op - sc_op.dag())
-                ]
-        else:
-            self.m_ops = [sc_op + sc_op.dag() for sc_op in sc_ops]
+class SSESolver(StochasticSolver):
+    name = "ssesolve"
+    _avail_integrators = {}
diff --git a/setup.py b/setup.py
index 80e80c4157..51a3061a5f 100755
--- a/setup.py
+++ b/setup.py
@@ -44,6 +44,13 @@ def process_options():
     options = _determine_user_arguments(options)
     options = _determine_version(options)
     options = _determine_compilation_options(options)
+    options["annotate"] = False
+    if "--annotate" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("--annotate")
+    if "-a" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("-a")
     return options
 
 
@@ -269,7 +276,7 @@ def create_extension_modules(options):
                              extra_compile_args=options['cflags'],
                              extra_link_args=options['ldflags'],
                              language='c++'))
-    return cythonize(out)
+    return cythonize(out, annotate=options["annotate"])
 
 
 def print_epilogue():

From 0717e0125ff2a64156adaf1455eaf208896bc0c0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 23 Jan 2023 17:08:40 -0500
Subject: [PATCH 027/602] Fix a bug in explicit1.5

---
 qutip/solve/_stochastic.pyx   |  2 +-
 qutip/solver/sode/_sode.pyx   | 26 ++++++++++---------
 qutip/solver/sode/ssystem.pxd | 15 +++++++++++
 qutip/solver/sode/ssystem.pyx | 47 +++++++++++++++++++----------------
 qutip/solver/stochastic.py    |  3 +--
 5 files changed, 57 insertions(+), 36 deletions(-)
 create mode 100644 qutip/solver/sode/ssystem.pxd

diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
index 91799251bf..156fab6466 100644
--- a/qutip/solve/_stochastic.pyx
+++ b/qutip/solve/_stochastic.pyx
@@ -126,7 +126,7 @@ cdef void _normalize_rho(complex[::1] rho):
     cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
     cdef complex[::1,:] eivec
     cdef double[::1] eival = np.zeros(N)
-    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
+    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].to_array()
 
     _zero(rho)
     cdef int i, j, k
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index a1fae73183..a399f107c6 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -1,15 +1,17 @@
 #cython: language_level=3
+
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
 from qutip.core.data cimport Data
 from collections import defaultdict
 cimport cython
+from qutip.solver.sode.ssystem cimport _StochasticSystem
 import numpy as np
 
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cpdef Data euler(system, t, Data state, double dt, double[:, :] dW):
+cpdef Data euler(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
     """
     Integration scheme:
     Basic Euler order 0.5
@@ -29,7 +31,7 @@ cpdef Data euler(system, t, Data state, double dt, double[:, :] dW):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
+cpdef Data platen(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
     """
     Platen rhs function for both master eq and schrodinger eq.
     dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
@@ -82,7 +84,7 @@ cpdef Data platen(system, t, Data state, double dt, double[:, :] dW):
 @cython.boundscheck(False)
 @cython.wraparound(False)
 @cython.cdivision(True)
-cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
+cpdef Data explicit15(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
     """
     Chapter 11.2 Eq. (2.13)
     Numerical Solution of Stochastic Differential Equations
@@ -131,11 +133,11 @@ cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
         p2p.append(temp_p2p)
         p2m.append(temp_p2m)
 
-    out = _data.add(out, d1, -0.5*(num_ops))
+    out = _data.add(out, d1, -0.5*(num_ops) * dt)
 
     for i in range(num_ops):
-        ddz = dz[i] * 0.5 / sqrt_dt *0 # 1.5
-        ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt *0 # 1.5
+        ddz = dz[i] * 0.5 / sqrt_dt # 1.5
+        ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt # 1.5
 
         d1p = system.drift(t + dt/num_ops, v2p[i])
         d1m = system.drift(t + dt/num_ops, v2m[i])
@@ -145,8 +147,8 @@ cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
         d2pp = system.diffusion(t, p2p[i][i])
         d2mm = system.diffusion(t, p2m[i][i])
 
-        out = _data.add(out, d1p, 0.25 + ddz)
-        out = _data.add(out, d1m, 0.25 - ddz)
+        out = _data.add(out, d1p, (0.25 + ddz) * dt)
+        out = _data.add(out, d1m, (0.25 - ddz) * dt)
 
         out = _data.add(out, dd2[i], dw[i] - dz[i])
         out = _data.add(out, d2[i], dz[i] - dw[i])
@@ -158,7 +160,7 @@ cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
 
 
         for j in range(num_ops):
-            ddw = 0.5 * (dw[j] - dz[j]) * 0  # O(1.5)
+            ddw = 0.5 * (dw[j] - dz[j])  # O(1.5)
             out = _data.add(out, d2p[j], ddw)
             out = _data.add(out, d2[j], -2*ddw)
             out = _data.add(out, d2m[j], ddw)
@@ -168,7 +170,7 @@ cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
                 out = _data.add(out, d2p[j], ddw)
                 out = _data.add(out, d2m[j], -ddw)
 
-                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt * 0  # O(1.5)
+                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
                 d2pp = system.diffusion(t, p2p[j][i])
                 d2mm = system.diffusion(t, p2m[j][i])
 
@@ -178,7 +180,7 @@ cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
                 out = _data.add(out, d2m[j], ddw)
 
                 for k in range(j+1, num_ops):
-                    ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt * 0  # O(1.5)
+                    ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt  # O(1.5)
 
                     out = _data.add(out, d2pp[k], ddw)
                     out = _data.add(out, d2mm[k], -ddw)
@@ -186,7 +188,7 @@ cpdef Data explicit15(system, t, Data state, double dt, double[:, :] dW):
                     out = _data.add(out, d2m[k], ddw)
 
             if j < i:
-                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt * 0  # O(1.5)
+                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
 
                 d2pp = system.diffusion(t, p2p[j][i])
                 d2mm = system.diffusion(t, p2m[j][i])
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
new file mode 100644
index 0000000000..8c7c7e47c5
--- /dev/null
+++ b/qutip/solver/sode/ssystem.pxd
@@ -0,0 +1,15 @@
+from qutip.core.data cimport Data
+
+cdef class _StochasticSystem:
+    cdef readonly int num_collapse
+    cdef readonly bint issuper
+    cdef readonly object dims
+    cdef Data state
+    cdef double t
+    cdef object imp
+
+    cpdef Data drift(self, t, Data state)
+
+    cpdef list diffusion(self, t, Data state)
+
+    cdef void set_state(self, double t, Data state)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index dc1304ee21..777fc1290e 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -8,7 +8,7 @@ from qutip.core.cy.qobjevo cimport QobjEvo
 from qutip.core.data cimport Data
 cimport cython
 import numpy as np
-from qutip.core import spre, spost
+from qutip.core import spre, spost, liouvillian
 
 __all__ = [
     "GeneralStochasticSystem", "StochasticOpenSystem", "StochasticClosedSystem"
@@ -16,22 +16,16 @@ __all__ = [
 
 
 cdef class _StochasticSystem:
-    cdef readonly int num_collapse
-    cdef readonly bint issuper
-    cdef readonly object dims
-    cdef Data state
-    cdef double t
-    cdef object imp
 
     def __init__(self, a, b):
         self.d1 = a
         self.d2 = b
         self.num_collapse = 1
 
-    def drift(self, t, state):
+    cpdef Data drift(self, t, Data state):
         return self.d1(t, state)
 
-    def diffusion(self, t, state):
+    cpdef list diffusion(self, t, Data state):
         return self.d2(t, state)
 
     cdef void set_state(self, double t, Data state):
@@ -47,10 +41,10 @@ cdef class GeneralStochasticSystem(_StochasticSystem):
         self.d2 = b
         self.num_collapse = 1
 
-    def drift(self, t, state):
+    cpdef Data drift(self, t, Data state):
         return self.d1(t, state)
 
-    def diffusion(self, t, state):
+    cpdef list diffusion(self, t, Data state):
         return self.d2(t, state)
 
 
@@ -59,15 +53,26 @@ cdef class StochasticClosedSystem(_StochasticSystem):
     cdef list c_ops
     cdef list cpcd_ops
 
-    def __init__(self, H, c_ops, heterodyne, implicit=False):
-        self.H = -1j*H
-        self.c_ops = c_ops
-        self.cpcd_ops = [op + op.dag() for op in c_ops]
-        self.num_collapse = len(c_ops)
+    def __init__(self, H, c_ops, heterodyne):
+        self.H = -1j * H
+        if heterodyne:
+            self.c_ops = []
+            for c_op in c_ops:
+                self.c_ops.append(c_op / np.sqrt(2))
+                self.c_ops.append(c_op * (-1j / np.sqrt(2)))
+                self.cpcd_ops.append((c_op + c_op.dag()) / np.sqrt(2))
+                self.cpcd_ops.append((-c_op + c_op.dag()) * 1j / np.sqrt(2))
+        else:
+            self.c_ops = c_ops
+            self.cpcd_ops = [op + op.dag() for op in c_ops]
+
+        self.num_collapse = len(self.c_ops)
+        for c_op in self.c_ops:
+            self.H += -0.5 * c_op.dag() * c_op
         self.issuper = False
         self.dims = self.H.dims
 
-    def drift(self, double t, Data state):
+    cpdef Data drift(self, t, Data state):
         cdef int i
         cdef QobjEvo c_op
         cdef Data temp, out
@@ -82,7 +87,7 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             out = _data.add(out, temp, 0.5 * e)
         return out
 
-    def diffusion(self, double t, Data state):
+    cpdef list diffusion(self, t, Data state):
         cdef int i
         cdef QobjEvo c_op
         out = []
@@ -100,7 +105,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef list c_ops
 
     def __init__(self, H, c_ops, heterodyne):
-        self.L = H
+        self.L = H + liouvillian(None, c_ops)
         if heterodyne:
             self.c_ops = []
             for c in c_ops:
@@ -114,10 +119,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self.issuper = True
         self.dims = self.L.dims
 
-    def drift(self, double t, Data state):
+    cpdef Data drift(self, t, Data state):
         return self.L.matmul_data(t, state)
 
-    def diffusion(self, double t, Data state):
+    cpdef list diffusion(self, t, Data state):
         cdef int i
         cdef QobjEvo c_op
         cdef complex expect
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 3effba4333..1c7fba6eb6 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -183,8 +183,7 @@ def __init__(self, H, sc_ops, heterodyne=False, *, options=None, m_ops=()):
             raise TypeError("sc_ops must be operators")
 
         if H.issuper:
-            L = H + liouvillian(None, sc_ops)
-            rhs = StochasticOpenSystem(L, sc_ops, heterodyne)
+            rhs = StochasticOpenSystem(H, sc_ops, heterodyne)
         else:
             rhs = StochasticClosedSystem(H, sc_ops, heterodyne)
 

From 9a0368ea515b7d3998e3693c732d11ef3cb4e466 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 24 Jan 2023 17:49:42 -0500
Subject: [PATCH 028/602] make debugging tools

---
 qutip/solve/_stochastic.pyx   | 149 ++++++++++++++++++----------------
 qutip/solve/stochastic.py     |  26 ++++--
 qutip/solver/sode/check.py    |  11 +++
 qutip/solver/sode/ito.py      |  34 ++++++++
 qutip/solver/sode/ssystem.pxd |   1 +
 5 files changed, 141 insertions(+), 80 deletions(-)
 create mode 100644 qutip/solver/sode/check.py
 create mode 100644 qutip/solver/sode/ito.py

diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
index 156fab6466..c2cac5416c 100644
--- a/qutip/solve/_stochastic.pyx
+++ b/qutip/solve/_stochastic.pyx
@@ -25,13 +25,13 @@ cdef int ONE=1
 
 """Some of blas wrapper"""
 @cython.boundscheck(False)
-cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
+cpdef void _axpy(complex a, complex[::1] x, complex[::1] y):
     """ y += a*x"""
     cdef int l = x.shape[0]
     zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
 
 @cython.boundscheck(False)
-cdef void copy(complex[::1] x, complex[::1] y):
+cpdef void copy(complex[::1] x, complex[::1] y):
     """ y = x """
     cdef int l = x.shape[0]
     zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
@@ -55,37 +55,37 @@ cdef double _dznrm2(complex[::1] vec):
     return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
 
 @cython.boundscheck(False)
-cdef void _scale(double a, complex[::1] x):
+cpdef void _scale(double a, complex[::1] x):
     """ x *= a """
     cdef int l = x.shape[0]
     zdscal(&l, &a, <complex*>&x[0], &ONE)
 
 @cython.boundscheck(False)
-cdef void _zscale(complex a, complex[::1] x):
+cpdef void _zscale(complex a, complex[::1] x):
     """ x *= a """
     cdef int l = x.shape[0]
     zscal(&l, &a, <complex*>&x[0], &ONE)
 
 @cython.boundscheck(False)
-cdef void _zero(complex[::1] x):
+cpdef void _zero(complex[::1] x):
     """ x *= 0 """
     cdef int l = x.shape[0]
     zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
 
 @cython.boundscheck(False)
-cdef void _zero_2d(complex[:,::1] x):
+cpdef void _zero_2d(complex[:,::1] x):
     """ x *= 0 """
     cdef int l = x.shape[0]*x.shape[1]
     zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
 
 @cython.boundscheck(False)
-cdef void _zero_3d(complex[:,:,::1] x):
+cpdef void _zero_3d(complex[:,:,::1] x):
     """ x *= 0 """
     cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
     zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
 
 @cython.boundscheck(False)
-cdef void _zero_4d(complex[:,:,:,::1] x):
+cpdef void _zero_4d(complex[:,:,:,::1] x):
     """ x *= 0 """
     cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
     zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
@@ -99,7 +99,7 @@ cdef Dense _dense_wrap(double complex [::1] x):
 # functions for ensuring that the states stay physical
 @cython.cdivision(True)
 @cython.boundscheck(False)
-cdef void _normalize_inplace(complex[::1] vec):
+cpdef void _normalize_inplace(complex[::1] vec):
     """ make norm of vec equal to 1"""
     cdef int l = vec.shape[0]
     cdef double norm = 1.0/_dznrm2(vec)
@@ -117,7 +117,7 @@ def normalize_inplace(complex[::1] vec):
 
 @cython.cdivision(True)
 @cython.boundscheck(False)
-cdef void _normalize_rho(complex[::1] rho):
+cpdef void _normalize_rho(complex[::1] rho):
     """ Ensure that the density matrix trace is one and
     that the composing states are normalized.
     """
@@ -299,16 +299,17 @@ cdef class StochasticSolver:
       d1, d2 and there derivatives up to dt**2.0
       one sc_ops
     """
-    cdef int l_vec, num_ops
-    cdef Solvers solver
-    cdef int num_step, num_substeps, num_dw
-    cdef int normalize
-    cdef double dt
+    cdef readonly int l_vec, num_ops
+    cdef readonly Solvers solver
+    cdef public int num_step, num_substeps
+    cdef readonly int num_dw
+    cdef public int normalize
+    cdef readonly double dt
     cdef int noise_type
     cdef object custom_noise
     cdef double[::1] dW_factor
     cdef unsigned int[::1] seed
-    cdef object sso
+    cdef readonly object sso
 
     # buffer to not redo the initialisation at each substep
     cdef complex[:, ::1] buffer_1d
@@ -444,6 +445,10 @@ cdef class StochasticSolver:
         elif self.noise_type == 0:
             self.seed = sso.noise
 
+    def reset_solver(self, new_solver):
+        self.sso.solver = new_solver
+        self.set_solver(self.sso)
+
     def set_data(self, sso):
         """Set solver specific operator"""
         pass
@@ -606,29 +611,29 @@ cdef class StochasticSolver:
             self._normalize_inplace(vec)
         return vec
 
-    cdef void _normalize_inplace(self, complex[::1] vec):
+    cpdef void _normalize_inplace(self, complex[::1] vec):
         _normalize_inplace(vec)
 
     # Dummy functions
     # Needed for compilation since ssesolve is not stand-alone
-    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
+    cpdef void d1(self, double t, complex[::1] v, complex[::1] out):
         """ deterministic part of the evolution
         depend on schrodinger vs master vs photocurrent
         """
         pass
 
-    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
+    cpdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
         """ stochastic part of the evolution
         depend on schrodinger vs master vs photocurrent
         """
         pass
 
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+    cpdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
                        complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
         """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
         pass
 
-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+    cpdef void derivatives(self, double t, int deg, complex[::1] rho,
                               complex[::1] a, complex[:, ::1] b,
                               complex[:, :, ::1] Lb, complex[:,::1] La,
                               complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
@@ -639,7 +644,7 @@ cdef class StochasticSolver:
         """
         pass
 
-    cdef void derivativesO2(self, double t, complex[::1] rho,
+    cpdef void derivativesO2(self, double t, complex[::1] rho,
                             complex[::1] a, complex[::1] b, complex[::1] Lb,
                             complex[::1] La, complex[::1] L0b, complex[::1] LLb,
                             complex[::1] L0a,
@@ -651,21 +656,21 @@ cdef class StochasticSolver:
         """
         pass
 
-    cdef void photocurrent(self, double t, double dt, double[:] noise,
+    cpdef void photocurrent(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out):
         """Special integration scheme:
         photocurrent collapse + euler evolution
         """
         pass
 
-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+    cpdef void photocurrent_pc(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out):
         """Special integration scheme:
         photocurrent collapse + predictor-corrector evolution
         """
         pass
 
-    cdef void rouchon(self, double t, double dt, double[:] noise,
+    cpdef void rouchon(self, double t, double dt, double[:] noise,
                       complex[::1] vec, complex[::1] out):
         """Special integration scheme:
         Force valid density matrix using positive map
@@ -676,7 +681,7 @@ cdef class StochasticSolver:
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void euler(self, double t, double dt, double[:] noise,
+    cpdef void euler(self, double t, double dt, double[:] noise,
                     complex[::1] vec, complex[::1] out):
         """Integration scheme:
         Basic Euler order 0.5
@@ -696,7 +701,7 @@ cdef class StochasticSolver:
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void platen(self, double t, double dt, double[:] noise,
+    cpdef void platen(self, double t, double dt, double[:] noise,
                        complex[::1] vec, complex[::1] out):
         """
         Platen rhs function for both master eq and schrodinger eq.
@@ -759,7 +764,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void pred_corr(self, double t, double dt, double[:] noise,
+    cpdef void pred_corr(self, double t, double dt, double[:] noise,
                     complex[::1] vec, complex[::1] out):
         """
         Chapter 15.5 Eq. (5.4)
@@ -795,7 +800,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
+    cpdef void pred_corr_a(self, double t, double dt, double[:] noise,
                     complex[::1] vec, complex[::1] out):
         """
         Chapter 15.5 Eq. (5.4)
@@ -838,7 +843,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void milstein(self, double t, double dt, double[:] noise,
+    cpdef void milstein(self, double t, double dt, double[:] noise,
                     complex[::1] vec, complex[::1] out):
         """
         Chapter 10.3 Eq. (3.1)
@@ -869,7 +874,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void milstein_imp(self, double t, double dt, double[:] noise,
+    cpdef void milstein_imp(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out) except *:
         """
         Chapter 12.2 Eq. (2.9)
@@ -907,7 +912,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void taylor15(self, double t, double dt, double[:] noise,
+    cpdef void taylor15(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out):
         """
         Chapter 12.2 Eq. (2.18),
@@ -959,7 +964,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
+    cpdef void taylor15_imp(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out) except *:
         """
         Chapter 12.2 Eq. (2.18),
@@ -1017,7 +1022,7 @@ cdef class StochasticSolver:
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void platen15(self, double t, double dt, double[:] noise,
+    cpdef void platen15(self, double t, double dt, double[:] noise,
                     complex[::1] vec, complex[::1] out):
         """
         Chapter 11.2 Eq. (2.13)
@@ -1160,7 +1165,7 @@ cdef class StochasticSolver:
     @cython.wraparound(False)
     @cython.boundscheck(False)
     @cython.cdivision(True)
-    cdef void taylor20(self, double t, double dt, double[::1] noise,
+    cpdef void taylor20(self, double t, double dt, double[::1] noise,
                            complex[::1] vec, complex[::1] out):
         """
         Chapter 10.5 Eq. (5.1),
@@ -1217,11 +1222,11 @@ cdef class StochasticSolver:
 
 cdef class SSESolver(StochasticSolver):
     """stochastic Schrodinger system"""
-    cdef QobjEvo L
-    cdef object c_ops
-    cdef object cpcd_ops
-    cdef object imp
-    cdef double tol, imp_t
+    cdef readonly QobjEvo L
+    cdef readonly object c_ops
+    cdef readonly object cpcd_ops
+    cdef readonly object imp
+    cdef readonly double tol, imp_t
 
     def set_data(self, sso):
         L = sso.LH
@@ -1250,7 +1255,7 @@ cdef class SSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+    cpdef void d1(self, double t, complex[::1] vec, complex[::1] out):
         self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
         cdef int i
         cdef complex e
@@ -1269,7 +1274,7 @@ cdef class SSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+    cpdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
         cdef int i, k
         cdef QobjEvo c_op
         cdef complex expect
@@ -1283,7 +1288,7 @@ cdef class SSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void derivatives(self, double t, int deg, complex[::1] vec,
+    cpdef void derivatives(self, double t, int deg, complex[::1] vec,
                           complex[::1] a, complex[:, ::1] b,
                           complex[:, :, ::1] Lb, complex[:,::1] La,
                           complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
@@ -1432,7 +1437,7 @@ cdef class SSESolver(StochasticSolver):
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
+    cpdef void _c_vec_conj(self, double t, QobjEvo c_op,
                          complex[::1] vec, complex[::1] out):
         cdef int k
         cdef complex[::1] temp = self.func_buffer_1d[13,:]
@@ -1444,7 +1449,7 @@ cdef class SSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void derivativesO2(self, double t, complex[::1] psi,
+    cpdef void derivativesO2(self, double t, complex[::1] psi,
                             complex[::1] a, complex[::1] b, complex[::1] Lb,
                             complex[::1] La, complex[::1] L0b, complex[::1] LLb,
                             complex[::1] L0a,
@@ -1612,7 +1617,7 @@ cdef class SSESolver(StochasticSolver):
         _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
         _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
 
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+    cpdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
                                         complex[::1] out,
                                         np.ndarray[complex, ndim=1] guess) except *:
         # np.ndarray to memoryview is OK but not the reverse
@@ -1626,11 +1631,11 @@ cdef class SSESolver(StochasticSolver):
 
 cdef class SMESolver(StochasticSolver):
     """stochastic master equation system"""
-    cdef QobjEvo L
-    cdef object imp
-    cdef object c_ops
-    cdef int N_root
-    cdef double tol
+    cdef readonly QobjEvo L
+    cdef readonly object imp
+    cdef readonly object c_ops
+    cdef readonly int N_root
+    cdef readonly double tol
 
     def set_data(self, sso):
         L = sso.LH
@@ -1646,7 +1651,7 @@ cdef class SMESolver(StochasticSolver):
             self.tol = sso.tol
             self.imp = sso.imp
 
-    cdef void _normalize_inplace(self, complex[::1] vec):
+    cpdef void _normalize_inplace(self, complex[::1] vec):
         _normalize_rho(vec)
 
     @cython.boundscheck(False)
@@ -1660,13 +1665,13 @@ cdef class SMESolver(StochasticSolver):
         return e
 
     @cython.boundscheck(False)
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+    cpdef void d1(self, double t, complex[::1] rho, complex[::1] out):
         self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+    cpdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
         cdef int i, k
         cdef QobjEvo c_op
         cdef complex expect
@@ -1679,7 +1684,7 @@ cdef class SMESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+    cpdef void derivatives(self, double t, int deg, complex[::1] rho,
                           complex[::1] a, complex[:, ::1] b,
                           complex[:, :, ::1] Lb, complex[:,::1] La,
                           complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
@@ -1777,7 +1782,7 @@ cdef class SMESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void derivativesO2(self, double t, complex[::1] rho,
+    cpdef void derivativesO2(self, double t, complex[::1] rho,
                             complex[::1] a, complex[::1] b, complex[::1] Lb,
                             complex[::1] La, complex[::1] L0b, complex[::1] LLb,
                             complex[::1] L0a,
@@ -1881,7 +1886,7 @@ cdef class SMESolver(StochasticSolver):
         _axpy(-self.dt*0.5, L0Lb, L0a)
 
 
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+    cpdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
                                         complex[::1] out,
                                         np.ndarray[complex, ndim=1] guess) except *:
         # np.ndarray to memoryview is OK but not the reverse
@@ -1913,7 +1918,7 @@ cdef class PcSSESolver(StochasticSolver):
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void photocurrent(self, double t, double dt, double[:] noise,
+    cpdef void photocurrent(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out):
         cdef QobjEvo c_op
         cdef double rand
@@ -1942,7 +1947,7 @@ cdef class PcSSESolver(StochasticSolver):
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+    cpdef void photocurrent_pc(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out):
         cdef QobjEvo c_op
         cdef double expect
@@ -2002,7 +2007,7 @@ cdef class PcSSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+    cpdef void d1(self, double t, complex[::1] vec, complex[::1] out):
         self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
         cdef int i
         cdef complex e
@@ -2018,7 +2023,7 @@ cdef class PcSSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+    cpdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
         cdef int i
         cdef QobjEvo c_op
         cdef complex expect
@@ -2035,7 +2040,7 @@ cdef class PcSSESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void collapse(self, double t, int which, double expect,
+    cpdef void collapse(self, double t, int which, double expect,
                        complex[::1] vec, complex[::1] out):
         cdef QobjEvo c_op
         c_op = self.c_ops[which]
@@ -2067,12 +2072,12 @@ cdef class PcSMESolver(StochasticSolver):
             self.cdcl_ops.append(op[1])
             self.clcdr_ops.append(op[2])
 
-    cdef void _normalize_inplace(self, complex[::1] vec):
+    cpdef void _normalize_inplace(self, complex[::1] vec):
         _normalize_rho(vec)
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void photocurrent(self, double t, double dt,  double[:] noise,
+    cpdef void photocurrent(self, double t, double dt,  double[:] noise,
                            complex[::1] vec, complex[::1] out):
         cdef QobjEvo c_op
         cdef double rand
@@ -2101,7 +2106,7 @@ cdef class PcSMESolver(StochasticSolver):
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
+    cpdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
                            complex[::1] vec, complex[::1] out):
         cdef QobjEvo c_op
         cdef int i, which, num_coll=0, did_collapse
@@ -2170,7 +2175,7 @@ cdef class PcSMESolver(StochasticSolver):
         return e
 
     @cython.boundscheck(False)
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+    cpdef void d1(self, double t, complex[::1] rho, complex[::1] out):
         cdef int i
         cdef QobjEvo c_op
         cdef complex[::1] crho = self.func_buffer_1d[0,:]
@@ -2187,7 +2192,7 @@ cdef class PcSMESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+    cpdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
         cdef int i
         cdef QobjEvo c_op
         cdef complex expect
@@ -2204,7 +2209,7 @@ cdef class PcSMESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef void collapse(self, double t, int which, double expect,
+    cpdef void collapse(self, double t, int which, double expect,
                        complex[::1] vec, complex[::1] out):
         cdef QobjEvo c_op
         c_op = self.clcdr_ops[which]
@@ -2239,12 +2244,12 @@ cdef class PmSMESolver(StochasticSolver):
         self.postops2 = [op for op in sso.postops2]
         self.N_root = np.sqrt(self.l_vec)
 
-    cdef void _normalize_inplace(self, complex[::1] vec):
+    cpdef void _normalize_inplace(self, complex[::1] vec):
         _normalize_rho(vec)
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef void rouchon(self, double t, double dt, double[:] noise,
+    cpdef void rouchon(self, double t, double dt, double[:] noise,
                            complex[::1] vec, complex[::1] out):
         cdef complex[::1] dy = self.expect_buffer_1d[0,:]
         cdef complex[::1] temp = self.buffer_1d[0,:]
@@ -2325,7 +2330,7 @@ cdef class GenericSSolver(StochasticSolver):
         self.d2_func = sso.d2
 
 
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+    cpdef void d1(self, double t, complex[::1] rho, complex[::1] out):
         cdef np.ndarray[complex, ndim=1] in_np
         cdef np.ndarray[complex, ndim=1] out_np
         in_np = np.zeros((self.l_vec, ), dtype=complex)
@@ -2334,7 +2339,7 @@ cdef class GenericSSolver(StochasticSolver):
         _axpy(self.dt, out_np, out) # d1 is += and * dt
 
     @cython.boundscheck(False)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+    cpdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
         cdef np.ndarray[complex, ndim=1] in_np
         cdef np.ndarray[complex, ndim=2] out_np
         cdef int i
diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index dde9876911..36502a9296 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -123,7 +123,7 @@ def stochastic_solvers():
 
         All solvers, except taylor2.0, are usable in both smesolve and (ssesolve)
         and for both heterodyne and homodyne. taylor2.0 only works for 1
-        stochastic operator independent of time with the homodyne method.
+        stochastic opera__init__tor independent of time with the homodyne method.
         :func:`~general_stochastic` only accepts the derivative-free
         solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
 
@@ -206,7 +206,7 @@ class StochasticSolverOptions:
     sc_ops : list of time_dependent_object
         List of stochastic collapse operators. Each stochastic collapse
         operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
+        to the equation of __init__motion according to how the d1 and d2 functions
         are defined.  Each element of the list is a separate operator, like
         ``c_ops``.
 
@@ -441,16 +441,16 @@ def set_solver(self):
             self.solver_code = 100
             self.solver = 'platen'
         elif self.solver in ['pred-corr', 'predictor-corrector',
-                             'pc-euler', 101]:
+                             'pc-euler', "pred_corr", 101]:
             self.solver_code = 101
             self.solver = 'pred-corr'
         elif self.solver in ['milstein', 102, 1.0]:
             self.solver_code = 102
             self.solver = 'milstein'
-        elif self.solver in ['milstein-imp', 103]:
+        elif self.solver in ['milstein-imp', 'milstein_imp', 103]:
             self.solver_code = 103
             self.solver = 'milstein-imp'
-        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
+        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', "pred_corr_a", 104]:
             self.solver_code = 104
             self.solver = 'pred-corr-2'
         elif self.solver in ['Rouchon', 'rouchon', 120]:
@@ -464,7 +464,7 @@ def set_solver(self):
         elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
             self.solver_code = 152
             self.solver = 'taylor1.5'
-        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
+        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', "taylor15_imp", 153]:
             self.solver_code = 153
             self.solver = 'taylor1.5-imp'
         elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
@@ -511,7 +511,7 @@ def set_solver(self):
 
 
 def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, **kwargs):
+             _safe_mode=True, args={}, _dry_run=False, **kwargs):
     """
     Solve stochastic master equation. Dispatch to specific solvers
     depending on the value of the `solver` keyword argument.
@@ -629,6 +629,11 @@ def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
     sso.solver_obj = SMESolver
     sso.solver_name = "smesolve_" + sso.solver
 
+    if _dry_run:
+        ssolver = sso.solver_obj()
+        ssolver.set_solver(sso)
+        return ssolver
+
     res = _sesolve_generic(sso, sso.options, sso.progress_bar)
 
     if e_ops_dict:
@@ -638,7 +643,7 @@ def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
 
 
 def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, **kwargs):
+             _safe_mode=True, args={}, _dry_run=False, **kwargs):
     """
     Solve stochastic schrodinger equation. Dispatch to specific solvers
     depending on the value of the `solver` keyword argument.
@@ -748,6 +753,11 @@ def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
     sso.solver_obj = SSESolver
     sso.solver_name = "ssesolve_" + sso.solver
 
+    if _dry_run:
+        ssolver = sso.solver_obj()
+        ssolver.set_solver(sso)
+        return ssolver
+
     res = _sesolve_generic(sso, sso.options, sso.progress_bar)
 
     if e_ops_dict:
diff --git a/qutip/solver/sode/check.py b/qutip/solver/sode/check.py
new file mode 100644
index 0000000000..b7dfa70b78
--- /dev/null
+++ b/qutip/solver/sode/check.py
@@ -0,0 +1,11 @@
+import numpy
+
+def make_1_step(H, psi, sc_ops, solver, dt, dw=False):
+    ssolver = qt.smesolve(H, psi, [0,dt], sc_ops=c_ops, _dry_run=1, solver=solver, nsubsteps=1)
+    state = qt.operator_to_vector(ssolver.sso.state0).full().flatten()
+    func = getattr(ssolver, solver)
+    out = np.zeros_like(state)
+    if dw is False:
+        dw = np.array([1.] * 2 * len(sc_ops)) * dt**0.5
+    func(0, dt, dw, state, out)
+    return qt.Qobj( qt.unstack_columns(out))
diff --git a/qutip/solver/sode/ito.py b/qutip/solver/sode/ito.py
new file mode 100644
index 0000000000..7040fe6c2d
--- /dev/null
+++ b/qutip/solver/sode/ito.py
@@ -0,0 +1,34 @@
+import numpy as np
+
+class ItoNoise:
+    def __init__(self, T, dt):
+        N = int(np.round(T / dt))
+        self.T = T
+        self.dt = dt
+        self.noise = np.random.randn(N) * dt**0.5
+
+    def dw(self, dt):
+        # I(j)
+        N = int(np.round(dt /self.dt))
+        return self.noise.reshape(-1, N).sum(axis=1)
+
+    def dz(self, dt):
+        # I(0, j)
+        N = int(np.round(dt /self.dt))
+        return self.noise.reshape(-1, N) @ np.arange(N-0.5, 0, -1) * self.dt
+
+class MultiNoise:
+    def __init__(self, T, dt, num=1):
+        N = int(np.round(T / dt))
+        self.T = T
+        self.dt = dt
+        self.num = num
+        self.noise = np.random.randn(N, num) * dt**0.5
+
+    def dw(self, dt):
+        N = int(np.round(dt /self.dt))
+        return self.noise.reshape(-1, N, self.num).sum(axis=1)
+
+    def dz(self, dt):
+        N = int(np.round(dt /self.dt))
+        return np.einsum("ijk,j", self.noise.reshape(-1, N, self.num), np.arange(N-0.5, 0, -1)) * self.dt
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index 8c7c7e47c5..6b82236e34 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -1,3 +1,4 @@
+#cython: language_level=3
 from qutip.core.data cimport Data
 
 cdef class _StochasticSystem:

From c2027761b0271f55608d0b790ab965db33870914 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 26 Jan 2023 18:46:46 -0500
Subject: [PATCH 029/602] all explicit methods added

---
 qutip/solver/sode/_sode.pyx   |  98 ++++++++++++++-
 qutip/solver/sode/check.py    |  49 +++++++-
 qutip/solver/sode/ito.py      |  16 ++-
 qutip/solver/sode/ssystem.pxd |  12 +-
 qutip/solver/sode/ssystem.pyx | 220 +++++++++++++++++++++++++++++++++-
 5 files changed, 385 insertions(+), 10 deletions(-)

diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index a399f107c6..dbe0d2ea88 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -109,7 +109,7 @@ cpdef Data explicit15(_StochasticSystem system, t, Data state, double dt, double
     for i in range(num_ops):
         out = _data.add(out, d2[i], dw[i])
 
-    V = _data.add(state, d1, 1./num_ops)
+    V = _data.add(state, d1, dt/num_ops)
 
     v2p = []
     v2m = []
@@ -199,3 +199,99 @@ cpdef Data explicit15(_StochasticSystem system, t, Data state, double dt, double
                 out = _data.add(out, d2m[j], ddw)
 
     return out
+
+
+
+cpdef Data milstein(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
+    """
+    Chapter 10.3 Eq. (3.1)
+    Numerical Solution of Stochastic Differential Equations
+    By Peter E. Kloeden, Eckhard Platen
+
+    dV = -iH*V*dt + d1*dt + d2_i*dW_i
+    + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+    """
+    cdef int i, j, num_ops = system.num_collapse
+    cdef double dw
+
+    system.set_state(t, state)
+
+    out = _data.add_dense(state, system.a(), dt)
+
+    for i in range(num_ops):
+        _data.iadd_dense(out, system.bi(i), dW[i, 0])
+
+    for i in range(num_ops):
+        for j in range(i, num_ops):
+            dw = (dW[i, 0] * dW[j, 0] - dt * (i == j)) * (0.5 + (i != j) * 0.5)
+            _data.iadd_dense(out, system.Libj(i, j), dw)
+
+    return out
+
+
+cpdef Data pred_corr(_StochasticSystem system, t, Data state, double dt, double[:, :] dW, alpha=0.):
+    """
+    Chapter 10.3 Eq. (3.1)
+    Numerical Solution of Stochastic Differential Equations
+    By Peter E. Kloeden, Eckhard Platen
+
+    dV = -iH*V*dt + d1*dt + d2_i*dW_i
+    + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+    """
+    cdef int i, j, k, num_ops = system.num_collapse
+    cdef double eta=0.5
+
+    system.set_state(t, state)
+
+    out = _data.add_dense(state, system.a(), dt*(1-alpha))
+    euler = _data.add_dense(state, system.a(), dt)
+
+    for i in range(num_ops):
+        _data.iadd_dense(euler, system.bi(i), dW[i, 0])
+        _data.iadd_dense(out, system.bi(i), dW[i, 0]*eta)
+        _data.iadd_dense(out, system.Libj(i, i), dt*(alpha-1)*0.5)
+
+    system.set_state(t+dt, euler)
+    if alpha:
+        _data.iadd_dense(out, system.a(), dt*alpha)
+
+    for i in range(num_ops):
+        _data.iadd_dense(out, system.bi(i), dW[i, 0]*(1-eta))
+        _data.iadd_dense(out, system.Libj(i, i), -dt*alpha*0.5)
+
+    return out
+
+
+cpdef Data taylor15(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
+    """
+    Chapter 12.2 Eq. (2.18),
+    Numerical Solution of Stochastic Differential Equations
+    By Peter E. Kloeden, Eckhard Platen
+    """
+    system.set_state(t, state)
+    cdef int i, j, k, num_ops = system.num_collapse
+    cdef double[:] dz, dw
+
+    num_ops = system.num_collapse
+    dw = dW[:, 0]
+    dz = 0.5 *(dW[:, 0] + 1./np.sqrt(3) * dW[:, 1]) * dt
+
+    out = _data.add_dense(state, system.a(), dt)
+    _data.iadd_dense(out, system.L0a(), 0.5 * dt*dt)
+
+    for i in range(num_ops):
+        _data.iadd_dense(out, system.bi(i), dw[i])
+        _data.iadd_dense(out, system.Libj(i, i), 0.5*(dw[i]*dw[i]-dt))
+        _data.iadd_dense(out, system.Lia(i), dz[i])
+        _data.iadd_dense(out, system.L0bi(i), dw[i] * dt - dz[i])
+        _data.iadd_dense(out, system.LiLjbk(i, i, i),
+                         0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i])
+
+        for j in range(i+1, num_ops):
+            _data.iadd_dense(out, system.Libj(i, j), dw[i]*dw[j])
+            _data.iadd_dense(out, system.LiLjbk(i, j, j), 0.5*(dw[j]*dw[j]-dt)*dw[i])
+            _data.iadd_dense(out, system.LiLjbk(i, i, j), 0.5*(dw[i]*dw[i]-dt)*dw[j])
+            for k in range(j+1, num_ops):
+                _data.iadd_dense(out, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
+
+    return out
diff --git a/qutip/solver/sode/check.py b/qutip/solver/sode/check.py
index b7dfa70b78..606dca6363 100644
--- a/qutip/solver/sode/check.py
+++ b/qutip/solver/sode/check.py
@@ -1,4 +1,4 @@
-import numpy
+import numpy as np
 
 def make_1_step(H, psi, sc_ops, solver, dt, dw=False):
     ssolver = qt.smesolve(H, psi, [0,dt], sc_ops=c_ops, _dry_run=1, solver=solver, nsubsteps=1)
@@ -9,3 +9,50 @@ def make_1_step(H, psi, sc_ops, solver, dt, dw=False):
         dw = np.array([1.] * 2 * len(sc_ops)) * dt**0.5
     func(0, dt, dw, state, out)
     return qt.Qobj( qt.unstack_columns(out))
+
+
+def L0(system, f):
+    def _func(t, rho, dt=1e-6):
+        n = rho.shape[0]
+        f0 = f(t, rho.data)
+
+        out = (f(t+dt, rho) - f0) / dt
+
+        jac = np.zeros((n, n), dtype=complex)
+        for i in range(n):
+            dxi = qt.basis(n, i).data
+            jac[:, i] = (f(t, rho + dt * dxi) - f0).to_array().flatten() / dt
+        out = out + qt.data.Dense(jac) @ system.drift(t, rho)
+
+        for i, j in product(range(n), repeat=2):
+            dxi = qt.basis(n, i).data
+            dxj = qt.basis(n, j).data
+            sec = f(t, (rho + dxi * dt + dxj * dt))
+            sec = sec - f(t, (rho + dxj * dt))
+            sec = sec - f(t, (rho + dxi * dt))
+            sec = sec + f0
+            sec = sec / dt / dt * 0.5
+            for k in range(system.num_collapse):
+                out = out + (
+                    sec
+                    * qt.data.inner(dxi, system.diffusion(t, rho)[k])
+                    * qt.data.inner(dxj, system.diffusion(t, rho)[k])
+                )
+        return out
+    return _func
+
+
+def Li(system, ii, f):
+    def _func(t, rho, dt=1e-6):
+        n = rho.shape[0]
+        jac = np.zeros((n, n), dtype=complex)
+        f0 = f(t, rho)
+        for i in range(n):
+            dxi = qt.basis(n, i).data
+            jac[:, i] = (f(t, (rho + dt * dxi)) - f0).to_array().flatten()
+        return qt.data.Dense(jac) @ system.diffusion(t, rho)[ii] / dt
+    return _func
+
+
+def _check_equivalence(f, target, shape):
+    ...
diff --git a/qutip/solver/sode/ito.py b/qutip/solver/sode/ito.py
index 7040fe6c2d..294e517a36 100644
--- a/qutip/solver/sode/ito.py
+++ b/qutip/solver/sode/ito.py
@@ -31,4 +31,18 @@ def dw(self, dt):
 
     def dz(self, dt):
         N = int(np.round(dt /self.dt))
-        return np.einsum("ijk,j", self.noise.reshape(-1, N, self.num), np.arange(N-0.5, 0, -1)) * self.dt
+        return np.einsum(
+            "ijk,j",
+            self.noise.reshape(-1, N, self.num),
+            np.arange(N-0.5, 0, -1)
+        ) * self.dt
+
+    def dW(self, dt):
+        N = int(np.round(dt / self.dt))
+        noise = self.noise
+        if noise.shape[0] % N:
+            noise = noise[:-noise.shape[0] % N]
+        out = np.empty((self.num, 2), dtype=float)
+        out[:, 0] = noise[:N, :].sum(axis=0)
+        out[:, 1] = np.arange(N-0.5, 0, -1) @ noise[:N, :] * self.dt
+        return out.T
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index 6b82236e34..947a31270c 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -1,5 +1,5 @@
 #cython: language_level=3
-from qutip.core.data cimport Data
+from qutip.core.data cimport Data, Dense
 
 cdef class _StochasticSystem:
     cdef readonly int num_collapse
@@ -8,9 +8,17 @@ cdef class _StochasticSystem:
     cdef Data state
     cdef double t
     cdef object imp
+    cdef int is_set
 
     cpdef Data drift(self, t, Data state)
 
     cpdef list diffusion(self, t, Data state)
 
-    cdef void set_state(self, double t, Data state)
+    cpdef void set_state(self, double t, Data state)
+    cpdef Data a(self)
+    cpdef Data bi(self, int i)
+    cpdef Data Libj(self, int i, int j)
+    cpdef Data Lia(self, int i)
+    cpdef Data L0bi(self, int i)
+    cpdef Data LiLjbk(self, int i, int j, int k)
+    cpdef Data L0a(self)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 777fc1290e..ff3dab67ef 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -5,7 +5,7 @@ Class to represent a stochastic differential equation system.
 
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.data cimport Data
+from qutip.core.data cimport Data, dense, Dense
 cimport cython
 import numpy as np
 from qutip.core import spre, spost, liouvillian
@@ -14,23 +14,71 @@ __all__ = [
     "GeneralStochasticSystem", "StochasticOpenSystem", "StochasticClosedSystem"
 ]
 
+@cython.boundscheck(False)
+@cython.initializedcheck(False)
+cdef Dense _dense_wrap(double complex [::1] x):
+    return dense.wrap(&x[0], x.shape[0], 1)
 
-cdef class _StochasticSystem:
 
+cdef class _StochasticSystem:
     def __init__(self, a, b):
         self.d1 = a
         self.d2 = b
         self.num_collapse = 1
+        self.is_set = False
 
     cpdef Data drift(self, t, Data state):
-        return self.d1(t, state)
+        raise NotImplementedError
 
     cpdef list diffusion(self, t, Data state):
-        return self.d2(t, state)
+        raise NotImplementedError
 
-    cdef void set_state(self, double t, Data state):
+    cpdef void set_state(self, double t, Data state):
         self.t = t
         self.state = state
+        self.is_set = True
+
+    cpdef Data a(self):
+        """
+          Drift term
+        """
+        raise NotImplementedError
+
+    cpdef Data bi(self, int i):
+        """
+          Diffusion term for the ``i``th operator.
+        """
+        raise NotImplementedError
+
+    cpdef Data Libj(self, int i, int j):
+        """
+            bi_n * d bj / dx_n
+        """
+        raise NotImplementedError
+
+    cpdef Data Lia(self, int i):
+        """
+            bi_n * d a / dx_n
+        """
+        raise NotImplementedError
+
+    cpdef Data L0bi(self, int i):
+        """
+            d/dt + a_n * d bi / dx_n + sum_k bk_n bk_m *0.5 d**2 (bi) / (dx_n dx_m)
+        """
+        raise NotImplementedError
+
+    cpdef Data LiLjbk(self, int i, int j, int k):
+        """
+            bi_n * d/dx_n ( bj_m * d bk / dx_m)
+        """
+        raise NotImplementedError
+
+    cpdef Data L0a(self):
+        """
+            d/dt + a_n * d a / dx_n + sum_k bk_n bk_m *0.5 d**2 (a) / (dx_n dx_m)
+        """
+        raise NotImplementedError
 
 
 cdef class GeneralStochasticSystem(_StochasticSystem):
@@ -103,6 +151,14 @@ cdef class StochasticClosedSystem(_StochasticSystem):
 cdef class StochasticOpenSystem(_StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
+    cdef int state_size
+    cdef double dt
+
+    cdef readonly Dense _a, temp, _L0a
+    cdef readonly complex[::1] expect_Cv
+    cdef readonly complex[:, ::1] expect_Cb, _b, _La, _L0b
+    cdef readonly complex[:, :, ::1] _Lb
+    cdef readonly complex[:, :, :, ::1] _LLb
 
     def __init__(self, H, c_ops, heterodyne):
         self.L = H + liouvillian(None, c_ops)
@@ -118,6 +174,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self.num_collapse = len(self.c_ops)
         self.issuper = True
         self.dims = self.L.dims
+        self.state_size = self.L.shape[1]
+        self.is_set = 0
 
     cpdef Data drift(self, t, Data state):
         return self.L.matmul_data(t, state)
@@ -133,3 +191,155 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             expect = _data.trace_oper_ket(vec)
             out.append(_data.add(vec, state, -expect))
         return out
+
+    cpdef void set_state(self, double t, Data state):
+        cdef n, l
+        self.t = t
+        self.state = _data.to(_data.Dense, state)
+
+        if not self.is_set:
+            n = self.num_collapse
+            l = self.state_size
+            self.is_set = 1
+            self._a = dense.zeros(self.state_size, 1)
+            self.temp = dense.zeros(self.state_size, 1)
+            self._L0a = dense.zeros(self.state_size, 1)
+            self.expect_Cv = np.zeros(n, dtype=complex)
+            self.expect_Cb = np.zeros((n, n), dtype=complex)
+            self._b = np.zeros((n, l), dtype=complex)
+            self._L0b = np.zeros((n, l), dtype=complex)
+            self._Lb = np.zeros((n, n, l), dtype=complex)
+            self._LLb = np.zeros((n, n, n, l), dtype=complex)
+            self._La = np.zeros((n, l), dtype=complex)
+            self.dt = 1e-6  #  Make an options
+
+    cpdef Data a(self):
+
+        self.is_set = 2
+        _data.imul_dense(self._a, 0)
+        self.L.matmul_data(self.t, self.state, self._a)
+        return self._a
+
+    cpdef Data bi(self, int n):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef Dense b_vec
+
+        for i in range(self.num_collapse):
+            c_op = <QobjEvo> self.c_ops[i]
+            b_vec = <Dense> _dense_wrap(self._b[i, :])
+            _data.imul_dense(b_vec, 0)
+            c_op.matmul_data(self.t, self.state, b_vec)
+            self.expect_Cv[i] = _data.trace_oper_ket(b_vec)
+            _data.iadd_dense(b_vec, self.state, -self.expect_Cv[i])
+
+        return _dense_wrap(self._b[n, :])
+
+    cpdef Data Libj(self, int n, int m):
+        cdef int i, j
+        cdef QobjEvo c_op
+        cdef Dense b_vec, Lb_vec
+        cdef complex expect
+
+        for i in range(self.num_collapse):
+            c_op = <QobjEvo> self.c_ops[i]
+            for j in range(i, self.num_collapse):
+                b_vec = <Dense> _dense_wrap(self._b[j, :])
+                Lb_vec = <Dense> _dense_wrap(self._Lb[i, j, :])
+                _data.imul_dense(Lb_vec, 0)
+                c_op.matmul_data(self.t, b_vec, Lb_vec)
+                self.expect_Cb[i,j] = _data.trace_oper_ket(Lb_vec)
+                _data.iadd_dense(Lb_vec, b_vec, -self.expect_Cv[i])
+                _data.iadd_dense(Lb_vec, self.state, -self.expect_Cb[i,j])
+
+        if m >= n:
+            # We only support commutative diffusion
+            return _dense_wrap(self._Lb[n, m, :])
+        return _dense_wrap(self._Lb[m, n, :])
+
+    cpdef Data Lia(self, int n):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef Dense b_vec, La_vec
+
+        for i in range(self.num_collapse):
+            b_vec = <Dense> _dense_wrap(self._b[i, :])
+            La_vec = <Dense> _dense_wrap(self._La[i, :])
+            _data.imul_dense(La_vec, 0.)
+            self.L.matmul_data(self.t, b_vec, La_vec)
+
+        return _dense_wrap(self._La[n, :])
+
+    cpdef Data L0bi(self, int n):
+        # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
+        cdef int i, j
+        cdef QobjEvo c_op
+        cdef Dense b_vec, L0b_vec, a
+
+        for i in range(self.num_collapse):
+            c_op = <QobjEvo> self.c_ops[i]
+            L0b_vec = <Dense> _dense_wrap(self._L0b[i, :])
+            b_vec = <Dense> _dense_wrap(self._b[i, :])
+            _data.imul_dense(L0b_vec, 0.)
+
+            # db/dt
+            c_op.matmul_data(self.t + self.dt, self.state, L0b_vec)
+            expect = _data.trace_oper_ket(L0b_vec)
+            _data.iadd_dense(L0b_vec, self.state, -expect)
+            _data.iadd_dense(L0b_vec, b_vec, -1)
+            _data.imul_dense(L0b_vec, 1/self.dt)
+
+            # ab'
+            _data.imul_dense(self.temp, 0)
+            c_op.matmul_data(self.t, self._a, self.temp)
+            expect = _data.trace_oper_ket(self.temp)
+            _data.iadd_dense(L0b_vec, self.temp, 1)
+            _data.iadd_dense(L0b_vec, self._a, -self.expect_Cv[i])
+            _data.iadd_dense(L0b_vec, self.state, -expect)
+
+            # bbb" : expect_Cb[i,j] only defined for j>=i
+            for j in range(i):
+                b_vec = <Dense> _dense_wrap(self._b[j, :])
+                _data.iadd_dense(L0b_vec, b_vec, -self.expect_Cb[j,i])
+            for j in range(i, self.num_collapse):
+                b_vec = <Dense> _dense_wrap(self._b[j, :])
+                _data.iadd_dense(L0b_vec, b_vec, -self.expect_Cb[i,j])
+
+        return _dense_wrap(self._L0b[n, :])
+
+    cpdef Data LiLjbk(self, int n, int m, int o):
+        # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
+        # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
+        cdef int i, j, k
+        cdef QobjEvo c_op
+        cdef Dense bj_vec, bk_vec, LLb_vec, Lb_vec
+
+        for i in range(self.num_collapse):
+          for j in range(i,self.num_collapse):
+            for k in range(j,self.num_collapse):
+
+                c_op = <QobjEvo> self.c_ops[i]
+                LLb_vec = <Dense> _dense_wrap(self._LLb[i, j, k, :])
+                Lb_vec = <Dense> _dense_wrap(self._Lb[j, k, :])
+                bj_vec = <Dense> _dense_wrap(self._b[j, :])
+                bk_vec = <Dense> _dense_wrap(self._b[k, :])
+                _data.imul_dense(LLb_vec, 0.)
+
+                c_op.matmul_data(self.t, Lb_vec, LLb_vec)
+                expect = _data.trace_oper_ket(LLb_vec)
+
+                _data.iadd_dense(LLb_vec, Lb_vec, -self.expect_Cv[i])
+                _data.iadd_dense(LLb_vec, self.state, -expect)
+                _data.iadd_dense(LLb_vec, bj_vec, -self.expect_Cb[i,k])
+                _data.iadd_dense(LLb_vec, bk_vec, -self.expect_Cb[i,j])
+
+        return _dense_wrap(self._LLb[n, m, o, :])
+
+    cpdef Data L0a(self):
+        # L0a = a'a + da/dt + bba"/2  (a" = 0)
+        _data.imul_dense(self._L0a, 0.)
+        self.L.matmul_data(self.t + self.dt, self.state, self._L0a)
+        _data.iadd_dense(self._L0a, self._a, -1)
+        _data.imul_dense(self._L0a, 1/self.dt)
+        self.L.matmul_data(self.t, self._a, self._L0a)
+        return self._L0a

From 88c48a92d8060119a526aa0abee4420c0f5bb140 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 27 Jan 2023 11:32:37 -0500
Subject: [PATCH 030/602] Safe StochasticOpenSystem derrivatives

---
 qutip/solver/sode/sode.py     |  45 ++++++++++++++
 qutip/solver/sode/ssystem.pyx | 107 ++++++++++++++++++++++++++--------
 2 files changed, 128 insertions(+), 24 deletions(-)

diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 4cbe348ff8..b64823f7e6 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -202,7 +202,52 @@ class Explicit1_5_SODE(_Explicit_Simple_Integrator):
     N_dw = 2
 
 
+class Taylor1_5_SODE(_Explicit_Simple_Integrator):
+    """
+    Order 1.5 strong Taylor scheme.  Solver with more terms of the
+    Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
+    :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
+
+    - Order strong 1.5
+    """
+    stepper = _sode.taylor15
+    N_dw = 2
+
+
+class Milstein_SODE(_Explicit_Simple_Integrator):
+    """
+    An order 1.0 strong Taylor scheme.  Better approximate numerical
+    solution to stochastic differential equations.  See eq. (2.9) of
+    chapter 12.2 of [1]_.
+
+    - Order strong 1.0
+    """
+    stepper = _sode.milstein
+    N_dw = 1
+
+
+class PredCorr_SODE(_Explicit_Simple_Integrator):
+    """
+    Generalization of the trapezoidal method to stochastic differential
+    equations. More stable than explicit methods.  See eq. (5.4) of
+    chapter 15.5 of [1]_.
+
+    - Order strong 0.5, weak 1.0
+    - Codes to only correct the stochastic part (:math:`\\alpha=0`,
+      :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
+      ``'pc-euler'``
+    - Codes to correct both the stochastic and deterministic parts
+      (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
+      ``'pc-euler-2'`` or ``'pred-corr-2'``
+    """
+    stepper = _sode.pred_corr
+    N_dw = 1
+
+
 StochasticSolver.add_integrator(EulerSODE, "euler")
 StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
 StochasticSolver.add_integrator(PlatenSODE, "platen")
 StochasticSolver.add_integrator(Explicit1_5_SODE, "explicit1.5")
+StochasticSolver.add_integrator(Taylor1_5_SODE, "taylor15")
+StochasticSolver.add_integrator(PredCorr_SODE, "pred_corr")
+StochasticSolver.add_integrator(Milstein_SODE, "milstein")
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index ff3dab67ef..fdd84c9b03 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -153,6 +153,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef list c_ops
     cdef int state_size
     cdef double dt
+    cdef bint _a_set, _b_set, _Lb_set, _L0b_set, _La_set, _LLb_set, _L0a_set
 
     cdef readonly Dense _a, temp, _L0a
     cdef readonly complex[::1] expect_Cv
@@ -196,6 +197,13 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         cdef n, l
         self.t = t
         self.state = _data.to(_data.Dense, state)
+        self._a_set = False
+        self._b_set = False
+        self._Lb_set = False
+        self._L0b_set = False
+        self._La_set = False
+        self._LLb_set = False
+        self._L0a_set = False
 
         if not self.is_set:
             n = self.num_collapse
@@ -214,17 +222,28 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self.dt = 1e-6  #  Make an options
 
     cpdef Data a(self):
+        if not self._a_set:
+            self._compute_a()
+        return self._a
 
-        self.is_set = 2
+    cdef void _compute_a(self) except *:
+        if not self._is_set:
+            raise RuntimeError
         _data.imul_dense(self._a, 0)
         self.L.matmul_data(self.t, self.state, self._a)
-        return self._a
+        self._a_set = True
 
-    cpdef Data bi(self, int n):
+    cpdef Data bi(self, int i):
+        if not self._b_set:
+            self._compute_b()
+        return _dense_wrap(self._b[i, :])
+
+    cdef void _compute_b(self) except *:
+        if not self._is_set:
+            raise RuntimeError
         cdef int i
         cdef QobjEvo c_op
         cdef Dense b_vec
-
         for i in range(self.num_collapse):
             c_op = <QobjEvo> self.c_ops[i]
             b_vec = <Dense> _dense_wrap(self._b[i, :])
@@ -232,14 +251,23 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             c_op.matmul_data(self.t, self.state, b_vec)
             self.expect_Cv[i] = _data.trace_oper_ket(b_vec)
             _data.iadd_dense(b_vec, self.state, -self.expect_Cv[i])
+        self._b_set = True
 
-        return _dense_wrap(self._b[n, :])
-
-    cpdef Data Libj(self, int n, int m):
+    cpdef Data Libj(self, int i, int j):
+        if not self._Lb_set:
+            self._compute_Lb()
+        # We only support commutative diffusion
+        if i > j:
+            j, i = i, j
+        return _dense_wrap(self._Lb[i, j, :])
+
+    cdef void _compute_Lb(self) except *:
         cdef int i, j
         cdef QobjEvo c_op
         cdef Dense b_vec, Lb_vec
         cdef complex expect
+        if not self._b_set:
+            self._compute_b()
 
         for i in range(self.num_collapse):
             c_op = <QobjEvo> self.c_ops[i]
@@ -251,30 +279,41 @@ cdef class StochasticOpenSystem(_StochasticSystem):
                 self.expect_Cb[i,j] = _data.trace_oper_ket(Lb_vec)
                 _data.iadd_dense(Lb_vec, b_vec, -self.expect_Cv[i])
                 _data.iadd_dense(Lb_vec, self.state, -self.expect_Cb[i,j])
+        self._Lb_set = True
 
-        if m >= n:
-            # We only support commutative diffusion
-            return _dense_wrap(self._Lb[n, m, :])
-        return _dense_wrap(self._Lb[m, n, :])
+    cpdef Data Lia(self, int i):
+        if not self._La_set:
+            self._compute_La()
+        return _dense_wrap(self._La[i, :])
 
-    cpdef Data Lia(self, int n):
+    cdef void _compute_La(self) except *:
         cdef int i
         cdef QobjEvo c_op
         cdef Dense b_vec, La_vec
+        if not self._b_set:
+            self._compute_b()
 
         for i in range(self.num_collapse):
             b_vec = <Dense> _dense_wrap(self._b[i, :])
             La_vec = <Dense> _dense_wrap(self._La[i, :])
             _data.imul_dense(La_vec, 0.)
             self.L.matmul_data(self.t, b_vec, La_vec)
+        self._La_set = True
 
-        return _dense_wrap(self._La[n, :])
-
-    cpdef Data L0bi(self, int n):
+    cpdef Data L0bi(self, int i):
         # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
+        if not self._L0b_set:
+            self._compute_L0b()
+        return _dense_wrap(self._L0b[i, :])
+
+    cdef void _compute_L0b(self) except *:
         cdef int i, j
         cdef QobjEvo c_op
-        cdef Dense b_vec, L0b_vec, a
+        cdef Dense b_vec, L0b_vec
+        if not self._b_set:
+            self._compute_b()
+        if not self._a_set:
+            self._compute_a()
 
         for i in range(self.num_collapse):
             c_op = <QobjEvo> self.c_ops[i]
@@ -304,20 +343,34 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             for j in range(i, self.num_collapse):
                 b_vec = <Dense> _dense_wrap(self._b[j, :])
                 _data.iadd_dense(L0b_vec, b_vec, -self.expect_Cb[i,j])
+        self._L0b_set = True
 
-        return _dense_wrap(self._L0b[n, :])
-
-    cpdef Data LiLjbk(self, int n, int m, int o):
+    cpdef Data LiLjbk(self, int i, int j, int k):
+        # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
+        if not self._L0b_set:
+            self._compute_LLb()
+        # Only commutative noise supported
+        # Definied for i <= j <= k
+        # Simple bubble sort to order the terms
+        if i>j: i, j = j, i
+        if j>k:
+          j, k = k, j
+          if i>j: i, j = j, i
+
+        return _dense_wrap(self._LLb[i, j, k, :])
+
+    cdef void _compute_LLb(self) except *:
         # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
         # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
         cdef int i, j, k
         cdef QobjEvo c_op
         cdef Dense bj_vec, bk_vec, LLb_vec, Lb_vec
+        if not self._Lb_set:
+            self._compute_Lb()
 
         for i in range(self.num_collapse):
-          for j in range(i,self.num_collapse):
-            for k in range(j,self.num_collapse):
-
+          for j in range(i, self.num_collapse):
+            for k in range(j, self.num_collapse):
                 c_op = <QobjEvo> self.c_ops[i]
                 LLb_vec = <Dense> _dense_wrap(self._LLb[i, j, k, :])
                 Lb_vec = <Dense> _dense_wrap(self._Lb[j, k, :])
@@ -333,13 +386,19 @@ cdef class StochasticOpenSystem(_StochasticSystem):
                 _data.iadd_dense(LLb_vec, bj_vec, -self.expect_Cb[i,k])
                 _data.iadd_dense(LLb_vec, bk_vec, -self.expect_Cb[i,j])
 
-        return _dense_wrap(self._LLb[n, m, o, :])
+        self._LLb_set = True
 
     cpdef Data L0a(self):
+        # L0a = a'a + da/dt + bba"/2  (a" = 0)
+        if not self._L0a_set:
+            self._compute_L0a()
+        return self._L0a
+
+    cdef void _compute_L0a(self) except *:
         # L0a = a'a + da/dt + bba"/2  (a" = 0)
         _data.imul_dense(self._L0a, 0.)
         self.L.matmul_data(self.t + self.dt, self.state, self._L0a)
         _data.iadd_dense(self._L0a, self._a, -1)
         _data.imul_dense(self._L0a, 1/self.dt)
         self.L.matmul_data(self.t, self._a, self._L0a)
-        return self._L0a
+        self._L0a_set = True

From bb7e845d6162f8b7707072244e3f1b5a0dd7ad8e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 27 Jan 2023 17:04:45 -0500
Subject: [PATCH 031/602] add check code

---
 qutip/solver/sode/sode.py     |  9 ++++++---
 qutip/solver/sode/ssystem.pxd |  2 +-
 qutip/solver/sode/ssystem.pyx | 28 ++++++++++++++--------------
 3 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index b64823f7e6..5b90b312aa 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -206,7 +206,8 @@ class Taylor1_5_SODE(_Explicit_Simple_Integrator):
     """
     Order 1.5 strong Taylor scheme.  Solver with more terms of the
     Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-    :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
+    :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of Peter E. Kloeden and
+    Exkhard Platen, *Numerical Solution of Stochastic Differential Equations*.
 
     - Order strong 1.5
     """
@@ -218,7 +219,8 @@ class Milstein_SODE(_Explicit_Simple_Integrator):
     """
     An order 1.0 strong Taylor scheme.  Better approximate numerical
     solution to stochastic differential equations.  See eq. (2.9) of
-    chapter 12.2 of [1]_.
+    chapter 12.2 of Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations*..
 
     - Order strong 1.0
     """
@@ -230,7 +232,8 @@ class PredCorr_SODE(_Explicit_Simple_Integrator):
     """
     Generalization of the trapezoidal method to stochastic differential
     equations. More stable than explicit methods.  See eq. (5.4) of
-    chapter 15.5 of [1]_.
+    chapter 15.5 of Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations*.
 
     - Order strong 0.5, weak 1.0
     - Codes to only correct the stochastic part (:math:`\\alpha=0`,
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index 947a31270c..f3c5a5e5ef 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -8,7 +8,7 @@ cdef class _StochasticSystem:
     cdef Data state
     cdef double t
     cdef object imp
-    cdef int is_set
+    cdef int _is_set
 
     cpdef Data drift(self, t, Data state)
 
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index fdd84c9b03..626d80090d 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -25,7 +25,7 @@ cdef class _StochasticSystem:
         self.d1 = a
         self.d2 = b
         self.num_collapse = 1
-        self.is_set = False
+        self._is_set = False
 
     cpdef Data drift(self, t, Data state):
         raise NotImplementedError
@@ -36,7 +36,7 @@ cdef class _StochasticSystem:
     cpdef void set_state(self, double t, Data state):
         self.t = t
         self.state = state
-        self.is_set = True
+        self._is_set = True
 
     cpdef Data a(self):
         """
@@ -176,7 +176,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self.issuper = True
         self.dims = self.L.dims
         self.state_size = self.L.shape[1]
-        self.is_set = 0
+        self._is_set = 0
 
     cpdef Data drift(self, t, Data state):
         return self.L.matmul_data(t, state)
@@ -189,7 +189,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         for i in range(self.num_collapse):
             c_op = self.c_ops[i]
             vec = c_op.matmul_data(t, state)
-            expect = _data.trace_oper_ket(vec)
+            expect = _data.trace_oper_ket_dense(vec)
             out.append(_data.add(vec, state, -expect))
         return out
 
@@ -205,10 +205,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self._LLb_set = False
         self._L0a_set = False
 
-        if not self.is_set:
+        if not self._is_set:
             n = self.num_collapse
             l = self.state_size
-            self.is_set = 1
+            self._is_set = 1
             self._a = dense.zeros(self.state_size, 1)
             self.temp = dense.zeros(self.state_size, 1)
             self._L0a = dense.zeros(self.state_size, 1)
@@ -249,7 +249,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             b_vec = <Dense> _dense_wrap(self._b[i, :])
             _data.imul_dense(b_vec, 0)
             c_op.matmul_data(self.t, self.state, b_vec)
-            self.expect_Cv[i] = _data.trace_oper_ket(b_vec)
+            self.expect_Cv[i] = _data.trace_oper_ket_dense(b_vec)
             _data.iadd_dense(b_vec, self.state, -self.expect_Cv[i])
         self._b_set = True
 
@@ -276,7 +276,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
                 Lb_vec = <Dense> _dense_wrap(self._Lb[i, j, :])
                 _data.imul_dense(Lb_vec, 0)
                 c_op.matmul_data(self.t, b_vec, Lb_vec)
-                self.expect_Cb[i,j] = _data.trace_oper_ket(Lb_vec)
+                self.expect_Cb[i,j] = _data.trace_oper_ket_dense(Lb_vec)
                 _data.iadd_dense(Lb_vec, b_vec, -self.expect_Cv[i])
                 _data.iadd_dense(Lb_vec, self.state, -self.expect_Cb[i,j])
         self._Lb_set = True
@@ -310,8 +310,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         cdef int i, j
         cdef QobjEvo c_op
         cdef Dense b_vec, L0b_vec
-        if not self._b_set:
-            self._compute_b()
+        if not self._Lb_set:
+            self._compute_Lb()
         if not self._a_set:
             self._compute_a()
 
@@ -323,7 +323,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
             # db/dt
             c_op.matmul_data(self.t + self.dt, self.state, L0b_vec)
-            expect = _data.trace_oper_ket(L0b_vec)
+            expect = _data.trace_oper_ket_dense(L0b_vec)
             _data.iadd_dense(L0b_vec, self.state, -expect)
             _data.iadd_dense(L0b_vec, b_vec, -1)
             _data.imul_dense(L0b_vec, 1/self.dt)
@@ -331,7 +331,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             # ab'
             _data.imul_dense(self.temp, 0)
             c_op.matmul_data(self.t, self._a, self.temp)
-            expect = _data.trace_oper_ket(self.temp)
+            expect = _data.trace_oper_ket_dense(self.temp)
             _data.iadd_dense(L0b_vec, self.temp, 1)
             _data.iadd_dense(L0b_vec, self._a, -self.expect_Cv[i])
             _data.iadd_dense(L0b_vec, self.state, -expect)
@@ -347,7 +347,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
     cpdef Data LiLjbk(self, int i, int j, int k):
         # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
-        if not self._L0b_set:
+        if not self._LLb_set:
             self._compute_LLb()
         # Only commutative noise supported
         # Definied for i <= j <= k
@@ -379,7 +379,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
                 _data.imul_dense(LLb_vec, 0.)
 
                 c_op.matmul_data(self.t, Lb_vec, LLb_vec)
-                expect = _data.trace_oper_ket(LLb_vec)
+                expect = _data.trace_oper_ket_dense(LLb_vec)
 
                 _data.iadd_dense(LLb_vec, Lb_vec, -self.expect_Cv[i])
                 _data.iadd_dense(LLb_vec, self.state, -expect)

From d4f5bc2deee860621ce08f6864b14fe0617b1d0e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 27 Jan 2023 17:07:07 -0500
Subject: [PATCH 032/602] add check code

---
 qutip/solver/sode/check.py | 97 ++++++++++++++++++++++++++++++++------
 1 file changed, 82 insertions(+), 15 deletions(-)

diff --git a/qutip/solver/sode/check.py b/qutip/solver/sode/check.py
index 606dca6363..5fc53a874b 100644
--- a/qutip/solver/sode/check.py
+++ b/qutip/solver/sode/check.py
@@ -1,32 +1,35 @@
 import numpy as np
+from itertools import product
+from qutip.core import data as _data
+import qutip
 
 def make_1_step(H, psi, sc_ops, solver, dt, dw=False):
-    ssolver = qt.smesolve(H, psi, [0,dt], sc_ops=c_ops, _dry_run=1, solver=solver, nsubsteps=1)
-    state = qt.operator_to_vector(ssolver.sso.state0).full().flatten()
+    ssolver = qutip.smesolve(H, psi, [0,dt], sc_ops=c_ops, _dry_run=1, solver=solver, nsubsteps=1)
+    state = qutip.operator_to_vector(ssolver.sso.state0).full().flatten()
     func = getattr(ssolver, solver)
     out = np.zeros_like(state)
     if dw is False:
         dw = np.array([1.] * 2 * len(sc_ops)) * dt**0.5
     func(0, dt, dw, state, out)
-    return qt.Qobj( qt.unstack_columns(out))
+    return qutip.Qobj( qutip.unstack_columns(out))
 
 
 def L0(system, f):
     def _func(t, rho, dt=1e-6):
         n = rho.shape[0]
-        f0 = f(t, rho.data)
+        f0 = f(t, rho)
 
         out = (f(t+dt, rho) - f0) / dt
 
         jac = np.zeros((n, n), dtype=complex)
         for i in range(n):
-            dxi = qt.basis(n, i).data
+            dxi = qutip.basis(n, i).data
             jac[:, i] = (f(t, rho + dt * dxi) - f0).to_array().flatten() / dt
-        out = out + qt.data.Dense(jac) @ system.drift(t, rho)
+        out = out + qutip.data.Dense(jac) @ system.drift(t, rho)
 
         for i, j in product(range(n), repeat=2):
-            dxi = qt.basis(n, i).data
-            dxj = qt.basis(n, j).data
+            dxi = qutip.basis(n, i).data
+            dxj = qutip.basis(n, j).data
             sec = f(t, (rho + dxi * dt + dxj * dt))
             sec = sec - f(t, (rho + dxj * dt))
             sec = sec - f(t, (rho + dxi * dt))
@@ -35,24 +38,88 @@ def _func(t, rho, dt=1e-6):
             for k in range(system.num_collapse):
                 out = out + (
                     sec
-                    * qt.data.inner(dxi, system.diffusion(t, rho)[k])
-                    * qt.data.inner(dxj, system.diffusion(t, rho)[k])
+                    * qutip.data.inner(dxi, system.diffusion(t, rho)[k])
+                    * qutip.data.inner(dxj, system.diffusion(t, rho)[k])
                 )
         return out
     return _func
 
 
-def Li(system, ii, f):
+def L(system, ii, f):
     def _func(t, rho, dt=1e-6):
         n = rho.shape[0]
         jac = np.zeros((n, n), dtype=complex)
         f0 = f(t, rho)
         for i in range(n):
-            dxi = qt.basis(n, i).data
+            dxi = qutip.basis(n, i).data
             jac[:, i] = (f(t, (rho + dt * dxi)) - f0).to_array().flatten()
-        return qt.data.Dense(jac) @ system.diffusion(t, rho)[ii] / dt
+        return qutip.data.Dense(jac) @ system.diffusion(t, rho)[ii] / dt
+    return _func
+
+
+def LL(system, ii, jj, f):
+    # Can be implemented as 2 calls of ``L``, but this use 2 ``dt`` which
+    # cannot be different.
+    def _func(t, rho, dt=1e-6):
+        f0 = f(t, rho)
+        bi = system.diffusion(t, rho)[ii]
+        bj = system.diffusion(t, rho)[jj]
+        out = rho *0.
+        n = rho.shape[0]
+
+        for i, j in product(range(n), repeat=2):
+            dxi = qutip.basis(n, i, dtype="Dense").data
+            dxj = qutip.basis(n, j, dtype="Dense").data
+            sec = f(t, (rho + dxi * dt + dxj * dt))
+            sec = sec - f(t, (rho + dxj * dt))
+            sec = sec - f(t, (rho + dxi * dt))
+            sec = sec + f0
+            sec = sec / dt / dt
+
+            out = out + (
+                sec * qutip.data.inner(dxi, bi) * qutip.data.inner(dxj, bj)
+            )
+            df = (f(t, (rho + dxj * dt)) - f0) / dt
+            db = (system.diffusion(t, (rho + dxi * dt))[jj] - system.diffusion(t, rho)[jj] ) / dt
+
+            out = out + (
+                df * qutip.data.inner(dxi, bi) * qutip.data.inner(dxj, db)
+            )
+
+        return out
     return _func
 
 
-def _check_equivalence(f, target, shape):
-    ...
+def _check_equivalence(f, target, args):
+    dts = np.logspace(-5, -1, 9)
+    errors_dt = [
+        _data.norm.l2(f(*args, dt=dt) - target) / dt
+        for dt in dts
+    ]
+    poly = np.polyfit(dts, errors_dt, 1)
+    return -1 < poly[0] < 1
+
+
+def run_derr_check(solver, t, state):
+    N = solver.num_collapse
+    a = solver.drift
+    solver.set_state(t, state)
+
+    assert solver.drift(t, state) == solver.a()
+    assert _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
+
+    for i in range(N):
+        b = lambda *args: solver.diffusion(*args)[i]
+        assert b(t, state) == solver.bi(i)
+        assert _check_equivalence(L0(solver, b), solver.L0bi(i), (t, state))
+        assert _check_equivalence(L(solver, i, a), solver.Lia(i), (t, state))
+
+        for j in range(N):
+            assert _check_equivalence(
+                L(solver, j, b), solver.Libj(j, i), (t, state)
+            )
+
+            for k in range(N):
+                assert _check_equivalence(
+                    LL(solver, k, j, b), solver.LiLjbk(k, j, i), (t, state)
+                )

From 0a95382774db0b5466423cd0dc51dc0f1336326b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 31 Jan 2023 11:59:02 -0500
Subject: [PATCH 033/602] More debug tools

---
 qutip/solver/mcsolve.py     |   4 +-
 qutip/solver/sode/_sode.pyx | 661 +++++++++++++++++++++---------------
 qutip/solver/sode/sode.py   |  22 +-
 3 files changed, 390 insertions(+), 297 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index c0af05b5d6..cffe8d8668 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -225,12 +225,12 @@ def reset(self, hard=False):
 
     def _prob_func(self, state):
         if self.issuper:
-            return _data.norm.trace_oper_ket(state)
+            return _data.trace_oper_ket(state)
         return _data.norm.l2(state)**2
 
     def _norm_func(self, state):
         if self.issuper:
-            return _data.norm.trace_oper_ket(state)
+            return _data.trace_oper_ket(state)
         return _data.norm.l2(state)
 
     def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index dbe0d2ea88..470db90392 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -2,296 +2,393 @@
 
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.data cimport Data
+from qutip.core.data cimport Data, Dense
 from collections import defaultdict
 cimport cython
 from qutip.solver.sode.ssystem cimport _StochasticSystem
 import numpy as np
 
 
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef Data euler(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
-    """
-    Integration scheme:
-    Basic Euler order 0.5
-    dV = d1 dt + d2_i dW_i
-    Numerical Solution of Stochastic Differential Equations
-    By Peter E. Kloeden, Eckhard Platen
-    """
-    cdef int i
-
-    a = system.drift(t, state)
-    b = system.diffusion(t, state)
-    new_state = _data.add(state, a, dt)
-    for i in range(system.num_collapse):
-        new_state = _data.add(new_state, b[i], dW[i, 0])
-    return new_state
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef Data platen(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
-    """
-    Platen rhs function for both master eq and schrodinger eq.
-    dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
-         + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
-         + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
-
-    Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
-    V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
-    The Theory of Open Quantum Systems
-    Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
-    """
-    cdef int i, j, num_ops = system.num_collapse
-    cdef double sqrt_dt = np.sqrt(dt)
-    cdef double sqrt_dt_inv = 0.25 / sqrt_dt
-    cdef double dw, dw2
-
-    cdef Data d1 = _data.add(state, system.drift(t, state), dt)
-    cdef list d2 = system.diffusion(t, state)
-    cdef Data Vt, out
-    cdef list Vp, Vm
-
-    out = _data.mul(d1, 0.5)
-    Vt = d1.copy()
-    Vp = []
-    Vm = []
-    for i in range(num_ops):
-        Vp.append(_data.add(d1, d2[i], sqrt_dt))
-        Vm.append(_data.add(d1, d2[i], -sqrt_dt))
-        Vt = _data.add(Vt, d2[i], dW[i, 0])
-
-    d1 = system.drift(t, Vt)
-    out = _data.add(out, d1, 0.5 * dt)
-    out = _data.add(out, state, 0.5)
-    for i in range(num_ops):
-        d2p = system.diffusion(t, Vp[i])
-        d2m = system.diffusion(t, Vm[i])
-        dw = dW[i, 0] * 0.25
-        out = _data.add(out, d2m[i], dw)
-        out = _data.add(out, d2[i], 2 * dw)
-        out = _data.add(out, d2p[i], dw)
-
-        for j in range(num_ops):
-            dw2 = sqrt_dt_inv * (dW[i, 0] * dW[j, 0] - dt * (i == j))
-            out = _data.add(out, d2p[j], dw2)
-            out = _data.add(out, d2m[j], -dw2)
-
-    return out
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-@cython.cdivision(True)
-cpdef Data explicit15(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
-    """
-    Chapter 11.2 Eq. (2.13)
-    Numerical Solution of Stochastic Differential Equations
-    By Peter E. Kloeden, Eckhard Platen
-    """
-    cdef int i, j, k, num_ops = system.num_collapse
-    cdef double sqrt_dt = np.sqrt(dt)
-    cdef double sqrt_dt_inv = 1./sqrt_dt
-    cdef double ddz, ddw, ddd
-    cdef double[::1] dz, dw
-    dw = np.empty(num_ops)
-    dz = np.empty(num_ops)
-    for i in range(num_ops):
-        dw[i] = dW[i, 0]
-        dz[i] = 0.5 *(dW[i, 0] + 1./np.sqrt(3) * dW[i, 1])
-
-    d1 = system.drift(t, state)
-    d2 = system.diffusion(t, state)
-    dd2 = system.diffusion(t + dt, state)
-    # Euler part
-    out = _data.add(state, d1, dt)
-    for i in range(num_ops):
-        out = _data.add(out, d2[i], dw[i])
-
-    V = _data.add(state, d1, dt/num_ops)
-
-    v2p = []
-    v2m = []
-    for i in range(num_ops):
-        v2p.append(_data.add(V, d2[i], sqrt_dt))
-        v2m.append(_data.add(V, d2[i], -sqrt_dt))
-
-    p2p = []
-    p2m = []
-    for i in range(num_ops):
-        d2p = system.diffusion(t, v2p[i])
-        d2m = system.diffusion(t, v2m[i])
-        ddw = (dw[i] * dw[i] - dt) * 0.25 * sqrt_dt_inv  # 1.0
-        out = _data.add(out, d2p[i], ddw)
-        out = _data.add(out, d2m[i], -ddw)
-        temp_p2p = []
-        temp_p2m = []
-        for j in range(num_ops):
-            temp_p2p.append(_data.add(v2p[i], d2p[j], sqrt_dt))
-            temp_p2m.append(_data.add(v2p[i], d2p[j], -sqrt_dt))
-        p2p.append(temp_p2p)
-        p2m.append(temp_p2m)
-
-    out = _data.add(out, d1, -0.5*(num_ops) * dt)
-
-    for i in range(num_ops):
-        ddz = dz[i] * 0.5 / sqrt_dt # 1.5
-        ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt # 1.5
-
-        d1p = system.drift(t + dt/num_ops, v2p[i])
-        d1m = system.drift(t + dt/num_ops, v2m[i])
-
-        d2p = system.diffusion(t, v2p[i])
-        d2m = system.diffusion(t, v2m[i])
-        d2pp = system.diffusion(t, p2p[i][i])
-        d2mm = system.diffusion(t, p2m[i][i])
-
-        out = _data.add(out, d1p, (0.25 + ddz) * dt)
-        out = _data.add(out, d1m, (0.25 - ddz) * dt)
-
-        out = _data.add(out, dd2[i], dw[i] - dz[i])
-        out = _data.add(out, d2[i], dz[i] - dw[i])
-
-        out = _data.add(out, d2pp[i], ddd)
-        out = _data.add(out, d2mm[i], -ddd)
-        out = _data.add(out, d2p[i], -ddd)
-        out = _data.add(out, d2m[i], ddd)
-
-
-        for j in range(num_ops):
-            ddw = 0.5 * (dw[j] - dz[j])  # O(1.5)
-            out = _data.add(out, d2p[j], ddw)
-            out = _data.add(out, d2[j], -2*ddw)
-            out = _data.add(out, d2m[j], ddw)
-
-            if j > i:
-                ddw = 0.5 * (dw[i] * dw[j]) / sqrt_dt  # O(1.0)
+cdef class Euler:
+    cdef _StochasticSystem system
+
+    def __init__(self, _StochasticSystem system):
+        self.system = system
+
+    @cython.wraparound(False)
+    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
+        cdef int i
+        cdef Dense out
+        for i in range(ntraj):
+            out = self.step(t, state, dt, dW[i, :, :])
+            state = out
+        return out
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef step(self, double t, Data state, double dt, double[:, :] dW):
+        """
+        Integration scheme:
+        Basic Euler order 0.5
+        dV = d1 dt + d2_i dW_i
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i
+        cdef _StochasticSystem system = self.system
+
+        a = system.drift(t, state)
+        b = system.diffusion(t, state)
+        new_state = _data.add(state, a, dt)
+        for i in range(system.num_collapse):
+            new_state = _data.add(new_state, b[i], dW[i, 0])
+        return new_state
+
+
+cdef class Platen(Euler):
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef step(self, double t, Data state, double dt, double[:, :] dW):
+        """
+        Platen rhs function for both master eq and schrodinger eq.
+        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
+             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
+             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
+
+        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
+        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
+        The Theory of Open Quantum Systems
+        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
+        """
+        cdef _StochasticSystem system = self.system
+        cdef int i, j, num_ops = system.num_collapse
+        cdef double sqrt_dt = np.sqrt(dt)
+        cdef double sqrt_dt_inv = 0.25 / sqrt_dt
+        cdef double dw, dw2
+
+        cdef Data d1 = _data.add(state, system.drift(t, state), dt)
+        cdef list d2 = system.diffusion(t, state)
+        cdef Data Vt, out
+        cdef list Vp, Vm
+
+        out = _data.mul(d1, 0.5)
+        Vt = d1.copy()
+        Vp = []
+        Vm = []
+        for i in range(num_ops):
+            Vp.append(_data.add(d1, d2[i], sqrt_dt))
+            Vm.append(_data.add(d1, d2[i], -sqrt_dt))
+            Vt = _data.add(Vt, d2[i], dW[i, 0])
+
+        d1 = system.drift(t, Vt)
+        out = _data.add(out, d1, 0.5 * dt)
+        out = _data.add(out, state, 0.5)
+        for i in range(num_ops):
+            d2p = system.diffusion(t, Vp[i])
+            d2m = system.diffusion(t, Vm[i])
+            dw = dW[i, 0] * 0.25
+            out = _data.add(out, d2m[i], dw)
+            out = _data.add(out, d2[i], 2 * dw)
+            out = _data.add(out, d2p[i], dw)
+
+            for j in range(num_ops):
+                dw2 = sqrt_dt_inv * (dW[i, 0] * dW[j, 0] - dt * (i == j))
+                out = _data.add(out, d2p[j], dw2)
+                out = _data.add(out, d2m[j], -dw2)
+
+        return out
+
+
+cdef class Explicit15(Euler):
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef step(self, double t, Data state, double dt, double[:, :] dW):
+        """
+        Chapter 11.2 Eq. (2.13)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef _StochasticSystem system = self.system
+        cdef int i, j, k, num_ops = system.num_collapse
+        cdef double sqrt_dt = np.sqrt(dt)
+        cdef double sqrt_dt_inv = 1./sqrt_dt
+        cdef double ddz, ddw, ddd
+        cdef double[::1] dz, dw
+
+        dw = np.empty(num_ops)
+        dz = np.empty(num_ops)
+        for i in range(num_ops):
+            dw[i] = dW[i, 0]
+            dz[i] = 0.5 *(dW[i, 0] + 1./np.sqrt(3) * dW[i, 1])
+
+        d1 = system.drift(t, state)
+        d2 = system.diffusion(t, state)
+        dd2 = system.diffusion(t + dt, state)
+        # Euler part
+        out = _data.add(state, d1, dt)
+        for i in range(num_ops):
+            out = _data.add(out, d2[i], dw[i])
+
+        V = _data.add(state, d1, dt/num_ops)
+
+        v2p = []
+        v2m = []
+        for i in range(num_ops):
+            v2p.append(_data.add(V, d2[i], sqrt_dt))
+            v2m.append(_data.add(V, d2[i], -sqrt_dt))
+
+        p2p = []
+        p2m = []
+        for i in range(num_ops):
+            d2p = system.diffusion(t, v2p[i])
+            d2m = system.diffusion(t, v2m[i])
+            ddw = (dw[i] * dw[i] - dt) * 0.25 * sqrt_dt_inv  # 1.0
+            out = _data.add(out, d2p[i], ddw)
+            out = _data.add(out, d2m[i], -ddw)
+            temp_p2p = []
+            temp_p2m = []
+            for j in range(num_ops):
+                temp_p2p.append(_data.add(v2p[i], d2p[j], sqrt_dt))
+                temp_p2m.append(_data.add(v2p[i], d2p[j], -sqrt_dt))
+            p2p.append(temp_p2p)
+            p2m.append(temp_p2m)
+
+        out = _data.add(out, d1, -0.5*(num_ops) * dt)
+
+        for i in range(num_ops):
+            ddz = dz[i] * 0.5 / sqrt_dt # 1.5
+            ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt # 1.5
+
+            d1p = system.drift(t + dt/num_ops, v2p[i])
+            d1m = system.drift(t + dt/num_ops, v2m[i])
+
+            d2p = system.diffusion(t, v2p[i])
+            d2m = system.diffusion(t, v2m[i])
+            d2pp = system.diffusion(t, p2p[i][i])
+            d2mm = system.diffusion(t, p2m[i][i])
+
+            out = _data.add(out, d1p, (0.25 + ddz) * dt)
+            out = _data.add(out, d1m, (0.25 - ddz) * dt)
+
+            out = _data.add(out, dd2[i], dw[i] - dz[i])
+            out = _data.add(out, d2[i], dz[i] - dw[i])
+
+            out = _data.add(out, d2pp[i], ddd)
+            out = _data.add(out, d2mm[i], -ddd)
+            out = _data.add(out, d2p[i], -ddd)
+            out = _data.add(out, d2m[i], ddd)
+
+            for j in range(num_ops):
+                ddw = 0.5 * (dw[j] - dz[j])  # O(1.5)
                 out = _data.add(out, d2p[j], ddw)
-                out = _data.add(out, d2m[j], -ddw)
-
-                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
-                d2pp = system.diffusion(t, p2p[j][i])
-                d2mm = system.diffusion(t, p2m[j][i])
-
-                out = _data.add(out, d2pp[j], ddw)
-                out = _data.add(out, d2mm[j], -ddw)
-                out = _data.add(out, d2p[j], -ddw)
+                out = _data.add(out, d2[j], -2*ddw)
                 out = _data.add(out, d2m[j], ddw)
 
+                if j > i:
+                    ddw = 0.5 * (dw[i] * dw[j]) / sqrt_dt  # O(1.0)
+                    out = _data.add(out, d2p[j], ddw)
+                    out = _data.add(out, d2m[j], -ddw)
+
+                    ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
+                    d2pp = system.diffusion(t, p2p[j][i])
+                    d2mm = system.diffusion(t, p2m[j][i])
+
+                    out = _data.add(out, d2pp[j], ddw)
+                    out = _data.add(out, d2mm[j], -ddw)
+                    out = _data.add(out, d2p[j], -ddw)
+                    out = _data.add(out, d2m[j], ddw)
+
+                    for k in range(j+1, num_ops):
+                        ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt  # O(1.5)
+
+                        out = _data.add(out, d2pp[k], ddw)
+                        out = _data.add(out, d2mm[k], -ddw)
+                        out = _data.add(out, d2p[k], -ddw)
+                        out = _data.add(out, d2m[k], ddw)
+
+                if j < i:
+                    ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
+
+                    d2pp = system.diffusion(t, p2p[j][i])
+                    d2mm = system.diffusion(t, p2m[j][i])
+
+                    out = _data.add(out, d2pp[j], ddw)
+                    out = _data.add(out, d2mm[j], -ddw)
+                    out = _data.add(out, d2p[j], -ddw)
+                    out = _data.add(out, d2m[j], ddw)
+
+        return out
+
+
+cdef class Milstein:
+    cdef _StochasticSystem system
+
+    def __init__(self, _StochasticSystem system):
+        self.system = system
+
+    @cython.wraparound(False)
+    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
+        cdef int i
+        if type(state) != _data.Dense:
+            state = _data.to(_data.Dense, state)
+        cdef Dense out = _data.mul_dense(state, 0)
+        state = state.copy()
+
+        for i in range(ntraj):
+            self.step(t, state, dt, dW[i, :, :], out)
+            state, out = out, state
+        return state
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
+        """
+        Chapter 10.3 Eq. (3.1)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+
+        dV = -iH*V*dt + d1*dt + d2_i*dW_i
+        + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+        """
+        cdef _StochasticSystem system = self.system
+        cdef int i, j, num_ops = system.num_collapse
+        cdef double dw
+
+        system.set_state(t, state)
+
+        _data.imul_dense(out, 0.)
+        _data.iadd_dense(out, state, 1)
+        _data.iadd_dense(out, system.a(), dt)
+
+        for i in range(num_ops):
+            _data.iadd_dense(out, system.bi(i), dW[i, 0])
+
+        for i in range(num_ops):
+            for j in range(i, num_ops):
+                if i == j:
+                    dw = (dW[i, 0] * dW[j, 0] - dt) * 0.5
+                else:
+                    dw = dW[i, 0] * dW[j, 0]
+                _data.iadd_dense(out, system.Libj(i, j), dw)
+
+
+cdef class PredCorr:
+    cdef Dense euler
+    cdef double alpha, eta
+    cdef _StochasticSystem system
+
+    def __init__(self, _StochasticSystem system, double alpha=0., double eta=0.5):
+        self.system = system
+        self.alpha = alpha
+        self.eta = eta
+
+    @cython.wraparound(False)
+    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
+        cdef int i
+        if type(state) != _data.Dense:
+            state = _data.to(_data.Dense, state)
+        cdef Dense out = _data.mul_dense(state, 0)
+        self.euler = _data.mul_dense(state, 0)
+        state = state.copy()
+
+        for i in range(ntraj):
+            self.step(t, state, dt, dW[i, :, :], out)
+            state, out = out, state
+        return state
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
+        """
+        Chapter 10.3 Eq. (3.1)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+
+        dV = -iH*V*dt + d1*dt + d2_i*dW_i
+        + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+        """
+        cdef _StochasticSystem system = self.system
+        cdef int i, j, k, num_ops = system.num_collapse
+        cdef double eta=self.eta, alpha=self.alpha
+        cdef Dense euler = self.euler
+
+        system.set_state(t, state)
+
+        _data.imul_dense(out, 0.)
+        _data.iadd_dense(out, state, 1)
+        _data.iadd_dense(out, system.a(), dt*(1-alpha))
+
+        _data.imul_dense(euler, 0.)
+        _data.iadd_dense(euler, state, 1)
+        _data.iadd_dense(euler, system.a(), dt)
+
+        for i in range(num_ops):
+            _data.iadd_dense(euler, system.bi(i), dW[i, 0])
+            _data.iadd_dense(out, system.bi(i), dW[i, 0]*eta)
+            _data.iadd_dense(out, system.Libj(i, i), dt*(alpha-1)*0.5)
+
+        system.set_state(t+dt, euler)
+        if alpha:
+            _data.iadd_dense(out, system.a(), dt*alpha)
+
+        for i in range(num_ops):
+            _data.iadd_dense(out, system.bi(i), dW[i, 0]*(1-eta))
+            _data.iadd_dense(out, system.Libj(i, i), -dt*alpha*0.5)
+
+        return out
+
+
+cdef class Taylor15(Milstein):
+    @cython.wraparound(False)
+    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
+        cdef int i
+        if type(state) != _data.Dense:
+            state = _data.to(_data.Dense, state)
+        cdef Dense out = _data.mul_dense(state, 0)
+        state = state.copy()
+
+        for i in range(ntraj):
+            self.step(t, state, dt, dW[i, :, :], out)
+            state, out = out, state
+        return state
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
+        """
+        Chapter 12.2 Eq. (2.18),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef _StochasticSystem system = self.system
+        system.set_state(t, state)
+        cdef int i, j, k, num_ops = system.num_collapse
+        cdef double[:] dz, dw
+
+        num_ops = system.num_collapse
+        dw = dW[:, 0]
+        dz = 0.5 *(dW[:, 0] + 1./np.sqrt(3) * dW[:, 1]) * dt
+
+        _data.imul_dense(out, 0.)
+        _data.iadd_dense(out, state, 1)
+        _data.iadd_dense(out, system.a(), dt)
+        _data.iadd_dense(out, system.L0a(), 0.5 * dt * dt)
+
+        for i in range(num_ops):
+            _data.iadd_dense(out, system.bi(i), dw[i])
+            _data.iadd_dense(out, system.Libj(i, i), 0.5 * (dw[i] * dw[i] - dt))
+            _data.iadd_dense(out, system.Lia(i), dz[i])
+            _data.iadd_dense(out, system.L0bi(i), dw[i] * dt - dz[i])
+            _data.iadd_dense(out, system.LiLjbk(i, i, i),
+                             0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i])
+
+            for j in range(i+1, num_ops):
+                _data.iadd_dense(out, system.Libj(i, j), dw[i] * dw[j])
+                _data.iadd_dense(out, system.LiLjbk(i, j, j), 0.5 * (dw[j] * dw[j] -dt) * dw[i])
+                _data.iadd_dense(out, system.LiLjbk(i, i, j), 0.5 * (dw[i] * dw[i] -dt) * dw[j])
                 for k in range(j+1, num_ops):
-                    ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt  # O(1.5)
-
-                    out = _data.add(out, d2pp[k], ddw)
-                    out = _data.add(out, d2mm[k], -ddw)
-                    out = _data.add(out, d2p[k], -ddw)
-                    out = _data.add(out, d2m[k], ddw)
-
-            if j < i:
-                ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
-
-                d2pp = system.diffusion(t, p2p[j][i])
-                d2mm = system.diffusion(t, p2m[j][i])
-
-                out = _data.add(out, d2pp[j], ddw)
-                out = _data.add(out, d2mm[j], -ddw)
-                out = _data.add(out, d2p[j], -ddw)
-                out = _data.add(out, d2m[j], ddw)
-
-    return out
-
-
-
-cpdef Data milstein(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
-    """
-    Chapter 10.3 Eq. (3.1)
-    Numerical Solution of Stochastic Differential Equations
-    By Peter E. Kloeden, Eckhard Platen
-
-    dV = -iH*V*dt + d1*dt + d2_i*dW_i
-    + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
-    """
-    cdef int i, j, num_ops = system.num_collapse
-    cdef double dw
-
-    system.set_state(t, state)
-
-    out = _data.add_dense(state, system.a(), dt)
-
-    for i in range(num_ops):
-        _data.iadd_dense(out, system.bi(i), dW[i, 0])
-
-    for i in range(num_ops):
-        for j in range(i, num_ops):
-            dw = (dW[i, 0] * dW[j, 0] - dt * (i == j)) * (0.5 + (i != j) * 0.5)
-            _data.iadd_dense(out, system.Libj(i, j), dw)
-
-    return out
-
-
-cpdef Data pred_corr(_StochasticSystem system, t, Data state, double dt, double[:, :] dW, alpha=0.):
-    """
-    Chapter 10.3 Eq. (3.1)
-    Numerical Solution of Stochastic Differential Equations
-    By Peter E. Kloeden, Eckhard Platen
-
-    dV = -iH*V*dt + d1*dt + d2_i*dW_i
-    + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
-    """
-    cdef int i, j, k, num_ops = system.num_collapse
-    cdef double eta=0.5
-
-    system.set_state(t, state)
-
-    out = _data.add_dense(state, system.a(), dt*(1-alpha))
-    euler = _data.add_dense(state, system.a(), dt)
-
-    for i in range(num_ops):
-        _data.iadd_dense(euler, system.bi(i), dW[i, 0])
-        _data.iadd_dense(out, system.bi(i), dW[i, 0]*eta)
-        _data.iadd_dense(out, system.Libj(i, i), dt*(alpha-1)*0.5)
-
-    system.set_state(t+dt, euler)
-    if alpha:
-        _data.iadd_dense(out, system.a(), dt*alpha)
-
-    for i in range(num_ops):
-        _data.iadd_dense(out, system.bi(i), dW[i, 0]*(1-eta))
-        _data.iadd_dense(out, system.Libj(i, i), -dt*alpha*0.5)
-
-    return out
-
-
-cpdef Data taylor15(_StochasticSystem system, t, Data state, double dt, double[:, :] dW):
-    """
-    Chapter 12.2 Eq. (2.18),
-    Numerical Solution of Stochastic Differential Equations
-    By Peter E. Kloeden, Eckhard Platen
-    """
-    system.set_state(t, state)
-    cdef int i, j, k, num_ops = system.num_collapse
-    cdef double[:] dz, dw
-
-    num_ops = system.num_collapse
-    dw = dW[:, 0]
-    dz = 0.5 *(dW[:, 0] + 1./np.sqrt(3) * dW[:, 1]) * dt
-
-    out = _data.add_dense(state, system.a(), dt)
-    _data.iadd_dense(out, system.L0a(), 0.5 * dt*dt)
-
-    for i in range(num_ops):
-        _data.iadd_dense(out, system.bi(i), dw[i])
-        _data.iadd_dense(out, system.Libj(i, i), 0.5*(dw[i]*dw[i]-dt))
-        _data.iadd_dense(out, system.Lia(i), dz[i])
-        _data.iadd_dense(out, system.L0bi(i), dw[i] * dt - dz[i])
-        _data.iadd_dense(out, system.LiLjbk(i, i, i),
-                         0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i])
-
-        for j in range(i+1, num_ops):
-            _data.iadd_dense(out, system.Libj(i, j), dw[i]*dw[j])
-            _data.iadd_dense(out, system.LiLjbk(i, j, j), 0.5*(dw[j]*dw[j]-dt)*dw[i])
-            _data.iadd_dense(out, system.LiLjbk(i, i, j), 0.5*(dw[i]*dw[i]-dt)*dw[j])
-            for k in range(j+1, num_ops):
-                _data.iadd_dense(out, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
+                    _data.iadd_dense(out, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
 
-    return out
+        return out
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 5b90b312aa..088af4c1d3 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -104,11 +104,7 @@ def __init__(self, system, options):
         self.dt = self.options["dt"]
         self.tol = self.options["tol"]
         self.N_drift = system.num_collapse
-
-    def _step(self, dt, dW):
-        new_state = self.stepper(self.system, self.t, self.state, dt, dW)
-        self.state = new_state
-        self.t += dt
+        self.step_func = self.stepper(self.system).run
 
     def set_state(self, t, state0, generator):
         self.t = t
@@ -135,8 +131,8 @@ def integrate(self, t, copy=True):
             size=(N, self.N_drift, self.N_dw)
         )
 
-        for i in range(N):
-            self._step(dt, dW[i, :])
+        self.state = self.step_func(self.t, self.state, dt, dW, N)
+        self.t += dt * N
 
         return self.t, self.state, np.sum(dW, axis=0) / (N * dt)
 
@@ -169,7 +165,7 @@ class EulerSODE(_Explicit_Simple_Integrator):
 
     - Order: 0.5
     """
-    stepper = _sode.euler
+    stepper = _sode.Euler
     N_dw = 1
 
 
@@ -183,7 +179,7 @@ class PlatenSODE(_Explicit_Simple_Integrator):
 
     - Order: strong 1, weak 2
     """
-    stepper = _sode.platen
+    stepper = _sode.Platen
     N_dw = 1
 
 
@@ -198,7 +194,7 @@ class Explicit1_5_SODE(_Explicit_Simple_Integrator):
 
     - Order: strong 1.5
     """
-    stepper = _sode.explicit15
+    stepper = _sode.Explicit15
     N_dw = 2
 
 
@@ -211,7 +207,7 @@ class Taylor1_5_SODE(_Explicit_Simple_Integrator):
 
     - Order strong 1.5
     """
-    stepper = _sode.taylor15
+    stepper = _sode.Taylor15
     N_dw = 2
 
 
@@ -224,7 +220,7 @@ class Milstein_SODE(_Explicit_Simple_Integrator):
 
     - Order strong 1.0
     """
-    stepper = _sode.milstein
+    stepper = _sode.Milstein
     N_dw = 1
 
 
@@ -243,7 +239,7 @@ class PredCorr_SODE(_Explicit_Simple_Integrator):
       (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
       ``'pc-euler-2'`` or ``'pred-corr-2'``
     """
-    stepper = _sode.pred_corr
+    stepper = _sode.PredCorr
     N_dw = 1
 
 

From b33e3323e370d9c8d31590b195a1ea4b0abaa2b3 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Thu, 2 Feb 2023 19:53:22 +0900
Subject: [PATCH 034/602] Fixed imports

---
 qutip/solver/mcsolve.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index afab97a3b5..6779bdd8ab 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -3,10 +3,9 @@
 import warnings
 
 import numpy as np
-from copy import copy
-from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
+from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
 from .multitraj import MultiTrajSolver
-from .solver_base import Solver
+from .solver_base import Solver, Integrator
 from .result import McResult, Result
 from .mesolve import mesolve, MESolver
 import qutip.core.data as _data

From 711fabd89fe3faf019a2180b4bba40df4527b6d2 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Thu, 2 Feb 2023 19:57:21 +0900
Subject: [PATCH 035/602] Added time parameter to _restore_state method in all
 solvers

---
 qutip/solver/floquet.py            |  5 +++--
 qutip/solver/heom/bofin_solvers.py |  2 +-
 qutip/solver/mcsolve.py            |  6 +++---
 qutip/solver/multitraj.py          |  8 ++++----
 qutip/solver/solver_base.py        | 11 ++++++-----
 5 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
index 25fca8aff7..8d36086940 100644
--- a/qutip/solver/floquet.py
+++ b/qutip/solver/floquet.py
@@ -916,14 +916,15 @@ def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
             stats=stats,
             floquet_basis=self.floquet_basis,
         )
-        results.add(tlist[0], self._restore_state(_data0, copy=False))
+        results.add(tlist[0],
+                    self._restore_state(_data0, tlist[0], copy=False))
         stats["preparation time"] += time() - _time_start
 
         progress_bar = progess_bars[self.options["progress_bar"]]()
         progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
         for t, state in self._integrator.run(tlist):
             progress_bar.update()
-            results.add(t, self._restore_state(state, copy=False))
+            results.add(t, self._restore_state(state, t, copy=False))
         progress_bar.finished()
 
         stats["run time"] = progress_bar.total_time()
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 99131ae990..184937092e 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1089,7 +1089,7 @@ def _prepare_state(self, state):
 
         return rho0_he
 
-    def _restore_state(self, state, *, copy=True):
+    def _restore_state(self, state, t, *, copy=True):
         n = self._sys_shape
         rho_shape = (n, n)
         rho_dims = self._sys_dims
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 6779bdd8ab..aa0d5b953a 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -394,7 +394,7 @@ def __init__(self, H, c_ops, *, options=None):
 
         super().__init__(rhs, options=options)
 
-    def _restore_state(self, data, *, copy=True):
+    def _restore_state(self, data, t, *, copy=True):
         """
         Retore the Qobj state from its data.
         """
@@ -434,10 +434,10 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         result = Result(e_ops, {**self.options, "normalize_output": False})
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
+        result.add(tlist[0], self._restore_state(state, tlist[0], copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
+            result.add(t, self._restore_state(state, t, copy=False))
         result.collapse = self._integrator.collapses
         return seed, result
 
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 73f84de66b..7f1227d9ab 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -101,8 +101,8 @@ def step(self, t, *, args=None, copy=True):
         if not self._integrator._is_set:
             raise RuntimeError("The `start` method must called first.")
         self._argument(args)
-        _, state = self._integrator.integrate(t, copy=False)
-        return self._restore_state(state, copy=copy)
+        t, state = self._integrator.integrate(t, copy=False)
+        return self._restore_state(state, t, copy=copy)
 
     def run(self, state, tlist, ntraj=1, *,
             args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
@@ -202,10 +202,10 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         result = Result(e_ops, self.options)
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
+        result.add(tlist[0], self._restore_state(state, tlist[0], copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.step(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
+            result.add(t, self._restore_state(state, t, copy=False))
         return seed, result
 
     def _read_seed(self, seed, ntraj):
diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index 8c08cea223..520e483fcf 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -90,7 +90,7 @@ def _prepare_state(self, state):
             return stack_columns(state.data)
         return state.data
 
-    def _restore_state(self, data, *, copy=True):
+    def _restore_state(self, data, t, *, copy=True):
         """
         Retore the Qobj state from its data.
         """
@@ -148,14 +148,15 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
             e_ops, self.options,
             solver=self.name, stats=stats,
         )
-        results.add(tlist[0], self._restore_state(_data0, copy=False))
+        results.add(tlist[0],
+                    self._restore_state(_data0, tlist[0], copy=False))
         stats['preparation time'] += time() - _time_start
 
         progress_bar = progess_bars[self.options['progress_bar']]()
         progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
         for t, state in self._integrator.run(tlist):
             progress_bar.update()
-            results.add(t, self._restore_state(state, copy=False))
+            results.add(t, self._restore_state(state, t, copy=False))
         progress_bar.finished()
 
         stats['run time'] = progress_bar.total_time()
@@ -206,9 +207,9 @@ def step(self, t, *, args=None, copy=True):
             raise RuntimeError("The `start` method must called first")
         _time_start = time()
         self._argument(args)
-        _, state = self._integrator.integrate(t, copy=False)
+        t, state = self._integrator.integrate(t, copy=False)
         self.stats["run time"] += time() - _time_start
-        return self._restore_state(state, copy=copy)
+        return self._restore_state(state, t, copy=copy)
 
     def _get_integrator(self):
         """ Return the initialted integrator. """

From faee1be4f3cacd91fbbf70532b0a009203807685 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Thu, 2 Feb 2023 19:58:04 +0900
Subject: [PATCH 036/602] Non-Markovian MCSolver: Monte-Carlo simulations for
 Lindblad equations with negative rates

---
 qutip/solver/__init__.py   |   1 +
 qutip/solver/nm_mcsolve.py | 103 +++++++++++++++++++++++++++++++++++++
 2 files changed, 104 insertions(+)
 create mode 100644 qutip/solver/nm_mcsolve.py

diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
index 855bb29d15..26c9866f3a 100644
--- a/qutip/solver/__init__.py
+++ b/qutip/solver/__init__.py
@@ -5,6 +5,7 @@
 from .sesolve import *
 from .mesolve import *
 from .mcsolve import *
+from .nm_mcsolve import *
 from .propagator import *
 from .scattering import *
 from .correlation import *
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
new file mode 100644
index 0000000000..ec706526ca
--- /dev/null
+++ b/qutip/solver/nm_mcsolve.py
@@ -0,0 +1,103 @@
+__all__ = ['NonMarkovianMCSolver']
+
+import numpy as np
+import scipy
+from .mcsolve import MCSolver
+from ..core import QobjEvo, isket, ket2dm
+
+
+class NonMarkovianMCSolver(MCSolver):
+    r"""
+    Monte-Carlo solver for master equation with negative rates.
+    Based on the methods explained in arXiv:2209.08958 [quant-ph]
+    """
+
+    # ops_and_rates is a list of tuples (L_i, Gamma_i), where Gamma_i = Gamma_i(t) is callable
+    def __init__(self, H, ops_and_rates, *args,
+                 completeness_rtol=None, completeness_atol=None, **kwargs):
+        self.ops_and_rates = list(ops_and_rates)
+        self._a_parameter, L = self._check_completeness(ops_and_rates,
+                                                        completeness_rtol,
+                                                        completeness_atol)
+        if L is not None:
+            self.ops_and_rates.append((L, lambda t: 0))
+
+        c_ops = self._compute_paired_c_ops()
+        super().__init__(H, c_ops, *args, **kwargs)
+
+    # Check whether op = sum(Li.dag() * Li) is proportional to identity
+    # If not, creates an extra Lindblad operator so that it is
+    # Returns: * the proportionality factor a
+    #          * the extra Lindblad operator (or None if not necessary)
+    @staticmethod
+    def _check_completeness(ops_and_rates,
+                            completeness_rtol=None, completeness_atol=None):
+        tolerance_settings = {}
+        if completeness_rtol is not None:
+            tolerance_settings['rtol'] = completeness_rtol
+        if completeness_atol is not None:
+            tolerance_settings['atol'] = completeness_atol
+
+        op = sum((f[0].dag() * f[0]).full() for f in ops_and_rates)
+
+        a_candidate = op[0, 0]
+        if np.allclose(a_candidate * np.eye(len(op)), op,
+                       **tolerance_settings):
+            return np.real(a_candidate), None
+
+        w, _ = np.linalg.eig(op)
+        a = max(np.real(w))
+        L = scipy.linalg.sqrtm(a * np.eye(len(op)) - op)  # new Lindblad operator
+        return a, L
+
+    # Shifts all rate function by the function rate_shift
+    # Returns c_i = L_i * sqrt(gamma_i) as QobjEvo objects
+    def _compute_paired_c_ops(self):
+        c_ops = []
+        for f in self.ops_and_rates:
+            def sqrt_gamma(t, f=f):
+                return np.sqrt(f[1](t) + self._rate_shift(t))
+            c_ops.append(QobjEvo([f[0], sqrt_gamma]))
+        return c_ops
+
+    def _rate_shift(self, t):
+        min_rate = min(f[1](t) for f in self.ops_and_rates)
+        return 2 * abs(min(0, min_rate))
+
+    # Continuous part of the martingale evolution
+    def _continuous_martingale(self, tlist):
+        mu_c = {t: 1 for t in tlist}
+        integral = 0
+        for t1, t2 in zip(tlist, tlist[1:]):
+            # We compute the time integral for every interval and sum them together
+            integral += scipy.integrate.quad(self._rate_shift, t1, t2)[0]
+            mu_c[t2] = np.exp(self._a_parameter * integral)
+        return mu_c
+
+    # Discrete part of the martingale evolution
+    # collapses is a list of (t_k, i_k)
+    def _discrete_martingale(self, collapses):
+        o_r = self.ops_and_rates
+        factors = [o_r[ik][1](tk) / (o_r[ik][1](tk) + self._rate_shift(tk))
+                   for tk, ik in collapses]
+        return np.prod(factors)
+
+    # Override "run" to initialize continuous part of martingale evolution
+    def run(self, state, tlist, *args, **kwargs):
+        self._mu_c = self._continuous_martingale(tlist)
+        return super().run(state, tlist, *args, **kwargs)
+
+    # Override "_restore_state" to include the martingale in the state
+    def _restore_state(self, data, time, *, copy=True):
+        # find state |psi><psi|
+        state = super()._restore_state(data, time, copy=copy)
+        if isket(state):
+            # the influence martingale is for weighting density matrices, not kets!
+            state = ket2dm(state)
+
+        # find martingale mu
+        collapses = self._integrator.collapses
+        mu = self._mu_c[time] * self._discrete_martingale(collapses)
+
+        # return weighted state
+        return mu * state

From 9975978f8e3c3d14395fdab935f3464170f87067 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Fri, 3 Feb 2023 11:24:33 +0900
Subject: [PATCH 037/602] Fixed issue related to trying to pickle an inner
 function

---
 qutip/solver/nm_mcsolve.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index ec706526ca..f2ce33abbe 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -1,5 +1,6 @@
 __all__ = ['NonMarkovianMCSolver']
 
+from functools import partial
 import numpy as np
 import scipy
 from .mcsolve import MCSolver
@@ -55,14 +56,16 @@ def _check_completeness(ops_and_rates,
     def _compute_paired_c_ops(self):
         c_ops = []
         for f in self.ops_and_rates:
-            def sqrt_gamma(t, f=f):
-                return np.sqrt(f[1](t) + self._rate_shift(t))
+            sqrt_gamma = partial(self._sqrt_gamma, original_rate=f[1])
             c_ops.append(QobjEvo([f[0], sqrt_gamma]))
         return c_ops
 
     def _rate_shift(self, t):
         min_rate = min(f[1](t) for f in self.ops_and_rates)
         return 2 * abs(min(0, min_rate))
+    
+    def _sqrt_gamma(self, t, original_rate):
+        return np.sqrt(original_rate(t) + self._rate_shift(t))
 
     # Continuous part of the martingale evolution
     def _continuous_martingale(self, tlist):
@@ -88,16 +91,16 @@ def run(self, state, tlist, *args, **kwargs):
         return super().run(state, tlist, *args, **kwargs)
 
     # Override "_restore_state" to include the martingale in the state
-    def _restore_state(self, data, time, *, copy=True):
+    def _restore_state(self, data, t, *, copy=True):
         # find state |psi><psi|
-        state = super()._restore_state(data, time, copy=copy)
+        state = super()._restore_state(data, t, copy=copy)
         if isket(state):
             # the influence martingale is for weighting density matrices, not kets!
             state = ket2dm(state)
 
         # find martingale mu
         collapses = self._integrator.collapses
-        mu = self._mu_c[time] * self._discrete_martingale(collapses)
+        mu = self._mu_c[t] * self._discrete_martingale(collapses)
 
         # return weighted state
         return mu * state

From e7c5ea5bc2140499dd1adb73a12865ee7fafe449 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Fri, 3 Feb 2023 11:50:58 +0900
Subject: [PATCH 038/602] Added completeness_rtol / completeness_atol as
 options instead of class parameters

---
 qutip/solver/nm_mcsolve.py | 46 ++++++++++++++++++++++++++++----------
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index f2ce33abbe..57a30d9108 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -4,6 +4,7 @@
 import numpy as np
 import scipy
 from .mcsolve import MCSolver
+from .result import McResult
 from ..core import QobjEvo, isket, ket2dm
 
 
@@ -12,32 +13,53 @@ class NonMarkovianMCSolver(MCSolver):
     Monte-Carlo solver for master equation with negative rates.
     Based on the methods explained in arXiv:2209.08958 [quant-ph]
     """
+    name = "nm_mcsolve"
+    resultclass = McResult
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "method": "adams",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+        "mc_corr_eps": 1e-10,
+        "norm_steps": 5,
+        "norm_t_tol": 1e-6,
+        "norm_tol": 1e-4,
+        "completeness_rtol": None,
+        "completeness_atol": None,
+    }
 
     # ops_and_rates is a list of tuples (L_i, Gamma_i), where Gamma_i = Gamma_i(t) is callable
-    def __init__(self, H, ops_and_rates, *args,
-                 completeness_rtol=None, completeness_atol=None, **kwargs):
+    def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
         self.ops_and_rates = list(ops_and_rates)
-        self._a_parameter, L = self._check_completeness(ops_and_rates,
-                                                        completeness_rtol,
-                                                        completeness_atol)
+
+        self._a_parameter, L = self._check_completeness(ops_and_rates, options)
         if L is not None:
             self.ops_and_rates.append((L, lambda t: 0))
 
         c_ops = self._compute_paired_c_ops()
-        super().__init__(H, c_ops, *args, **kwargs)
+        super().__init__(H, c_ops, *args, options=options, **kwargs)
 
     # Check whether op = sum(Li.dag() * Li) is proportional to identity
     # If not, creates an extra Lindblad operator so that it is
     # Returns: * the proportionality factor a
     #          * the extra Lindblad operator (or None if not necessary)
     @staticmethod
-    def _check_completeness(ops_and_rates,
-                            completeness_rtol=None, completeness_atol=None):
+    def _check_completeness(ops_and_rates, options=None):
         tolerance_settings = {}
-        if completeness_rtol is not None:
-            tolerance_settings['rtol'] = completeness_rtol
-        if completeness_atol is not None:
-            tolerance_settings['atol'] = completeness_atol
+        if options is not None:
+            rtol = options.get('completeness_rtol', None)
+            if rtol is not None:
+                tolerance_settings['rtol'] = rtol
+
+            atol = options.get('completeness_atol', None)
+            if atol is not None:
+                tolerance_settings['atol'] = atol
 
         op = sum((f[0].dag() * f[0]).full() for f in ops_and_rates)
 

From 85b9a9b39956c8ea50c99d76e9b9d9664aabd872 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Fri, 3 Feb 2023 12:02:21 +0900
Subject: [PATCH 039/602] Bugfixes related to (N+1)st Lindblad operator

---
 qutip/solver/nm_mcsolve.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 57a30d9108..17748ba3ae 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -5,7 +5,7 @@
 import scipy
 from .mcsolve import MCSolver
 from .result import McResult
-from ..core import QobjEvo, isket, ket2dm
+from ..core import Qobj, QobjEvo, isket, ket2dm
 
 
 class NonMarkovianMCSolver(MCSolver):
@@ -40,7 +40,7 @@ def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
 
         self._a_parameter, L = self._check_completeness(ops_and_rates, options)
         if L is not None:
-            self.ops_and_rates.append((L, lambda t: 0))
+            self.ops_and_rates.append((L, float)) # float() is zero
 
         c_ops = self._compute_paired_c_ops()
         super().__init__(H, c_ops, *args, options=options, **kwargs)
@@ -71,7 +71,7 @@ def _check_completeness(ops_and_rates, options=None):
         w, _ = np.linalg.eig(op)
         a = max(np.real(w))
         L = scipy.linalg.sqrtm(a * np.eye(len(op)) - op)  # new Lindblad operator
-        return a, L
+        return a, Qobj(L)
 
     # Shifts all rate function by the function rate_shift
     # Returns c_i = L_i * sqrt(gamma_i) as QobjEvo objects

From 16141d9d48bd2009e0805267ee04147a4a9df151 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Fri, 3 Feb 2023 13:40:42 +0900
Subject: [PATCH 040/602] Modified calculation of continuous martingale part so
 that both run and start/step will work

---
 qutip/solver/nm_mcsolve.py | 46 +++++++++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 13 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 17748ba3ae..69a5787e15 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -37,10 +37,11 @@ class NonMarkovianMCSolver(MCSolver):
     # ops_and_rates is a list of tuples (L_i, Gamma_i), where Gamma_i = Gamma_i(t) is callable
     def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
         self.ops_and_rates = list(ops_and_rates)
+        self._mu_c = None
 
         self._a_parameter, L = self._check_completeness(ops_and_rates, options)
         if L is not None:
-            self.ops_and_rates.append((L, float)) # float() is zero
+            self.ops_and_rates.append((L, float))  # float() is zero
 
         c_ops = self._compute_paired_c_ops()
         super().__init__(H, c_ops, *args, options=options, **kwargs)
@@ -85,19 +86,31 @@ def _compute_paired_c_ops(self):
     def _rate_shift(self, t):
         min_rate = min(f[1](t) for f in self.ops_and_rates)
         return 2 * abs(min(0, min_rate))
-    
+
     def _sqrt_gamma(self, t, original_rate):
         return np.sqrt(original_rate(t) + self._rate_shift(t))
 
     # Continuous part of the martingale evolution
-    def _continuous_martingale(self, tlist):
-        mu_c = {t: 1 for t in tlist}
-        integral = 0
-        for t1, t2 in zip(tlist, tlist[1:]):
-            # We compute the time integral for every interval and sum them together
-            integral += scipy.integrate.quad(self._rate_shift, t1, t2)[0]
-            mu_c[t2] = np.exp(self._a_parameter * integral)
-        return mu_c
+    # Checks self._mu_c for the closest time t0 earlier than the given time t
+    #     and starts integration from there.
+    # Returns the continuous part of the martingale at time t and stores it in
+    #     self._mu_c
+    def _continuous_martingale(self, t):
+        if self._mu_c is None:
+            raise RuntimeError("The `start` method must called first.")
+        if t in self._mu_c:
+            return self._mu_c[t]
+
+        earlier_times = filter(lambda t0: t0 < t, self._mu_c.keys())
+        try:
+            t0 = max(earlier_times)
+        except ValueError as exc:
+            raise ValueError("Cannot integrate backwards in time.") from exc
+
+        integral = scipy.integrate.quad(self._rate_shift, t0, t)[0]
+        result = self._mu_c[t0] * np.exp(self._a_parameter * integral)
+        self._mu_c[t] = result
+        return result
 
     # Discrete part of the martingale evolution
     # collapses is a list of (t_k, i_k)
@@ -107,11 +120,17 @@ def _discrete_martingale(self, collapses):
                    for tk, ik in collapses]
         return np.prod(factors)
 
-    # Override "run" to initialize continuous part of martingale evolution
+    # Override "run" and "start" to initialize continuous part of martingale evolution
     def run(self, state, tlist, *args, **kwargs):
-        self._mu_c = self._continuous_martingale(tlist)
+        self._mu_c = {tlist[0]: 1}
+        for t in tlist[1:]:
+            self._continuous_martingale(t)  # precompute self._mu_c
         return super().run(state, tlist, *args, **kwargs)
 
+    def start(self, state, t0, seed=None):
+        self._mu_c = {t0: 1}
+        return super().start(state, t0, seed=seed)
+
     # Override "_restore_state" to include the martingale in the state
     def _restore_state(self, data, t, *, copy=True):
         # find state |psi><psi|
@@ -122,7 +141,8 @@ def _restore_state(self, data, t, *, copy=True):
 
         # find martingale mu
         collapses = self._integrator.collapses
-        mu = self._mu_c[t] * self._discrete_martingale(collapses)
+        mu = self._continuous_martingale(t) *\
+            self._discrete_martingale(collapses)
 
         # return weighted state
         return mu * state

From 7dbaddea4623b646b23dbb66b05a0a086b95e249 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Sat, 4 Feb 2023 12:07:41 +0900
Subject: [PATCH 041/602] Integrate changes suggested by @Ericgig,
 _check_completeness now uses only Qobj API

---
 qutip/solver/nm_mcsolve.py | 67 +++++++++++++-------------------------
 1 file changed, 23 insertions(+), 44 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 69a5787e15..71131c2335 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -5,7 +5,7 @@
 import scipy
 from .mcsolve import MCSolver
 from .result import McResult
-from ..core import Qobj, QobjEvo, isket, ket2dm
+from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
 
 
 class NonMarkovianMCSolver(MCSolver):
@@ -16,30 +16,19 @@ class NonMarkovianMCSolver(MCSolver):
     name = "nm_mcsolve"
     resultclass = McResult
     solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "keep_runs_results": False,
-        "method": "adams",
-        "map": "serial",
-        "job_timeout": None,
-        "num_cpus": None,
-        "bitgenerator": None,
-        "mc_corr_eps": 1e-10,
-        "norm_steps": 5,
-        "norm_t_tol": 1e-6,
-        "norm_tol": 1e-4,
-        "completeness_rtol": None,
-        "completeness_atol": None,
+        **MCSolver.solver_options,
+        "completeness_rtol": 1e-5,
+        "completeness_atol": 1e-8,
     }
 
-    # ops_and_rates is a list of tuples (L_i, Gamma_i), where Gamma_i = Gamma_i(t) is callable
+    # ops_and_rates is a list of tuples (L_i, Gamma_i),
+    #     where Gamma_i = Gamma_i(t) is callable
     def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
         self.ops_and_rates = list(ops_and_rates)
+        self.options = options
         self._mu_c = None
 
-        self._a_parameter, L = self._check_completeness(ops_and_rates, options)
+        self._a_parameter, L = self._check_completeness(ops_and_rates)
         if L is not None:
             self.ops_and_rates.append((L, float))  # float() is zero
 
@@ -50,29 +39,18 @@ def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
     # If not, creates an extra Lindblad operator so that it is
     # Returns: * the proportionality factor a
     #          * the extra Lindblad operator (or None if not necessary)
-    @staticmethod
-    def _check_completeness(ops_and_rates, options=None):
-        tolerance_settings = {}
-        if options is not None:
-            rtol = options.get('completeness_rtol', None)
-            if rtol is not None:
-                tolerance_settings['rtol'] = rtol
-
-            atol = options.get('completeness_atol', None)
-            if atol is not None:
-                tolerance_settings['atol'] = atol
-
-        op = sum((f[0].dag() * f[0]).full() for f in ops_and_rates)
-
-        a_candidate = op[0, 0]
-        if np.allclose(a_candidate * np.eye(len(op)), op,
-                       **tolerance_settings):
-            return np.real(a_candidate), None
-
-        w, _ = np.linalg.eig(op)
-        a = max(np.real(w))
-        L = scipy.linalg.sqrtm(a * np.eye(len(op)) - op)  # new Lindblad operator
-        return a, Qobj(L)
+    def _check_completeness(self, ops_and_rates):
+        op = sum((L.dag() * L) for L, _ in ops_and_rates)
+
+        a_candidate = op.tr() / op.shape[0]
+        with CoreOptions(rtol=self.options["completeness_rtol"],
+                         atol=self.options["completeness_atol"]):
+            if op == a_candidate * qeye(op.dims[0]):
+                return np.real(a_candidate), None
+
+        a = max(op.eigenenergies())
+        L = (a * qeye(op.dims[0]) - op).sqrtm()  # new Lindblad operator
+        return a, L
 
     # Shifts all rate function by the function rate_shift
     # Returns c_i = L_i * sqrt(gamma_i) as QobjEvo objects
@@ -120,7 +98,8 @@ def _discrete_martingale(self, collapses):
                    for tk, ik in collapses]
         return np.prod(factors)
 
-    # Override "run" and "start" to initialize continuous part of martingale evolution
+    # Override "run" and "start" to initialize continuous part
+    #     of martingale evolution
     def run(self, state, tlist, *args, **kwargs):
         self._mu_c = {tlist[0]: 1}
         for t in tlist[1:]:
@@ -136,7 +115,7 @@ def _restore_state(self, data, t, *, copy=True):
         # find state |psi><psi|
         state = super()._restore_state(data, t, copy=copy)
         if isket(state):
-            # the influence martingale is for weighting density matrices, not kets!
+            # influence martingale is for weighting density matrices, not kets!
             state = ket2dm(state)
 
         # find martingale mu

From 1b8e7cc86ac514833c8c616161a7787fbd0c6192 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 7 Feb 2023 16:50:45 +0100
Subject: [PATCH 042/602] Set version 5.0.0a1 in changelog.

---
 doc/changelog.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/changelog.rst b/doc/changelog.rst
index 872b7d92e4..071f1e5de9 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -6,8 +6,8 @@ Change Log
 
 .. towncrier release notes start
 
-Version 5.0.0 (February XX, 2023)
-+++++++++++++++++++++++++++++++++
+Version 5.0.0a1 (February 7, 2023)
+++++++++++++++++++++++++++++++++++
 
 QuTiP 5 is a redesign of many of the core components of QuTiP (``Qobj``,
 ``QobjEvo``, solvers) to make them more consistent and more flexible.

From 5856febc2b2c25ba2cd4b9e492397dbd4280b9f8 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 7 Feb 2023 14:55:27 -0500
Subject: [PATCH 043/602] Add pre release installation instruction

---
 README.md            | 11 +++++++++++
 doc/installation.rst | 22 ++++++++++++++++++++--
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index eb08599852..32e3a108ac 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,17 @@ All back releases are also available for download in the [releases section of th
 For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
 
 
+The pre release of QuTiP 5.0 is available on PyPI and can be installed from pip with:
+
+```bash
+pip install --pre qutip
+```
+
+This version breaks compatibility with QuTiP 4.7 in many small ways.
+Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
+This version should fully working, if you find any bugs, confusing documentation or missing features, please tell us on GitHub.
+
+
 Documentation
 -------------
 
diff --git a/doc/installation.rst b/doc/installation.rst
index df3308a1fd..145277dca8 100644
--- a/doc/installation.rst
+++ b/doc/installation.rst
@@ -64,7 +64,7 @@ In addition, there are several optional packages that provide additional functio
 | ``pytest``,              | 5.3+         | For running the test suite.                         |
 | ``pytest-rerunfailures`` |              |                                                     |
 +--------------------------+--------------+-----------------------------------------------------+
-| LaTeX                    | TeXLive 2009+| Needed if using LaTeX in matplotlib figures, or for |    
+| LaTeX                    | TeXLive 2009+| Needed if using LaTeX in matplotlib figures, or for |
 |                          |              | nice circuit drawings in IPython.                   |
 +--------------------------+--------------+-----------------------------------------------------+
 
@@ -128,6 +128,24 @@ You activate the new environment by running
 
 You can also install any more optional packages you want with ``conda install``, for example ``matplotlib``, ``ipython`` or ``jupyter``.
 
+
+Installation of the pre release of version 5
+============================================
+
+QuTiP version 5 has been in development for some time and bring a lot of new features, reworking heavily the core functionalities of QuTiP.
+It is available as a pre release on PyPI, anyone wanting to try the new features can install it with:
+
+.. code-block:: bash
+
+   pip install --dev qutip
+
+We keep versions available as pre release fully working.
+If you find any bugs, confusing documentation or missing features, please tell us on `github <https://github.com/qutip/qutip/issues>`_.
+
+This version breaks compatibility with QuTiP 4.7 in many small ways.
+Please see the `changelog <./changelog.html>`_ for a list of changes, new features and deprecations.
+
+
 .. _install-from-source:
 
 Installing from Source
@@ -192,7 +210,7 @@ To install OpenMP support, if available, run:
 This will attempt to load up OpenMP libraries during the compilation process, which depends on you having suitable C++ compiler and library support.
 If you are on Linux this is probably already done, but the compiler macOS ships with does not have OpenMP support.
 You will likely need to refer to external operating-system-specific guides for more detail here, as it may be very non-trivial to correctly configure.
-   
+
 If you wish to contribute to the QuTiP project, then you will want to create your own fork of `the QuTiP git repository <https://github.com/qutip/qutip>`_, clone this to a local folder, and install it into your Python environment using:
 
 .. code-block:: bash

From 33db6b001f994f8b77cee4b4f13505fd224c4484 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Tue, 7 Feb 2023 17:07:43 -0500
Subject: [PATCH 044/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 README.md            |  4 ++--
 doc/installation.rst | 14 +++++++-------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 32e3a108ac..19a901e5da 100644
--- a/README.md
+++ b/README.md
@@ -72,7 +72,7 @@ All back releases are also available for download in the [releases section of th
 For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
 
 
-The pre release of QuTiP 5.0 is available on PyPI and can be installed from pip with:
+The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
 
 ```bash
 pip install --pre qutip
@@ -80,7 +80,7 @@ pip install --pre qutip
 
 This version breaks compatibility with QuTiP 4.7 in many small ways.
 Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
-This version should fully working, if you find any bugs, confusing documentation or missing features, please tell us on GitHub.
+This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
 
 
 Documentation
diff --git a/doc/installation.rst b/doc/installation.rst
index 145277dca8..efce6af430 100644
--- a/doc/installation.rst
+++ b/doc/installation.rst
@@ -129,21 +129,21 @@ You activate the new environment by running
 You can also install any more optional packages you want with ``conda install``, for example ``matplotlib``, ``ipython`` or ``jupyter``.
 
 
-Installation of the pre release of version 5
+Installation of the pre-release of version 5
 ============================================
 
-QuTiP version 5 has been in development for some time and bring a lot of new features, reworking heavily the core functionalities of QuTiP.
-It is available as a pre release on PyPI, anyone wanting to try the new features can install it with:
+QuTiP version 5 has been in development for some time and brings many new features, heavily reworks the core functionalities of QuTiP.
+It is available as a pre-release on PyPI. Anyone wanting to try the new features can install it with:
 
 .. code-block:: bash
 
-   pip install --dev qutip
+   pip install --pre qutip
 
-We keep versions available as pre release fully working.
-If you find any bugs, confusing documentation or missing features, please tell us on `github <https://github.com/qutip/qutip/issues>`_.
+We expect the pre-release to fully work.
+If you find any bugs, confusing documentation or missing features, please tell create an issue on `github <https://github.com/qutip/qutip/issues>`_.
 
 This version breaks compatibility with QuTiP 4.7 in many small ways.
-Please see the `changelog <./changelog.html>`_ for a list of changes, new features and deprecations.
+Please see the :doc:`changelog` for a list of changes, new features and deprecations.
 
 
 .. _install-from-source:

From fadbaf375883100da2155c73488b866d63b55ff5 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Tue, 7 Feb 2023 17:25:34 +0900
Subject: [PATCH 045/602] Reverted adding time parameter to _restore_state in
 all solvers

---
 qutip/solver/floquet.py            |  5 ++---
 qutip/solver/heom/bofin_solvers.py |  2 +-
 qutip/solver/mcsolve.py            |  6 +++---
 qutip/solver/multitraj.py          |  8 ++++----
 qutip/solver/nm_mcsolve.py         | 14 +++++++++-----
 qutip/solver/solver_base.py        | 11 +++++------
 6 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
index 80d0dc772e..7ce6cc4f11 100644
--- a/qutip/solver/floquet.py
+++ b/qutip/solver/floquet.py
@@ -915,15 +915,14 @@ def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
             stats=stats,
             floquet_basis=self.floquet_basis,
         )
-        results.add(tlist[0],
-                    self._restore_state(_data0, tlist[0], copy=False))
+        results.add(tlist[0], self._restore_state(_data0, copy=False))
         stats["preparation time"] += time() - _time_start
 
         progress_bar = progess_bars[self.options["progress_bar"]]()
         progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
         for t, state in self._integrator.run(tlist):
             progress_bar.update()
-            results.add(t, self._restore_state(state, t, copy=False))
+            results.add(t, self._restore_state(state, copy=False))
         progress_bar.finished()
 
         stats["run time"] = progress_bar.total_time()
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 184937092e..99131ae990 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1089,7 +1089,7 @@ def _prepare_state(self, state):
 
         return rho0_he
 
-    def _restore_state(self, state, t, *, copy=True):
+    def _restore_state(self, state, *, copy=True):
         n = self._sys_shape
         rho_shape = (n, n)
         rho_dims = self._sys_dims
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 97c31cdbb6..e79d7aa15a 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -394,7 +394,7 @@ def __init__(self, H, c_ops, *, options=None):
 
         super().__init__(rhs, options=options)
 
-    def _restore_state(self, data, t, *, copy=True):
+    def _restore_state(self, data, *, copy=True):
         """
         Retore the Qobj state from its data.
         """
@@ -434,10 +434,10 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         result = Result(e_ops, {**self.options, "normalize_output": False})
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, tlist[0], copy=False))
+        result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, t, copy=False))
+            result.add(t, self._restore_state(state, copy=False))
         result.collapse = self._integrator.collapses
         return seed, result
 
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index c2b2c65eb8..204178d116 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -100,8 +100,8 @@ def step(self, t, *, args=None, copy=True):
         if not self._integrator._is_set:
             raise RuntimeError("The `start` method must called first.")
         self._argument(args)
-        t, state = self._integrator.integrate(t, copy=False)
-        return self._restore_state(state, t, copy=copy)
+        _, state = self._integrator.integrate(t, copy=False)
+        return self._restore_state(state, copy=copy)
 
     def run(self, state, tlist, ntraj=1, *,
             args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
@@ -201,10 +201,10 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         result = Result(e_ops, self.options)
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, tlist[0], copy=False))
+        result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.step(t, copy=False)
-            result.add(t, self._restore_state(state, t, copy=False))
+            result.add(t, self._restore_state(state, copy=False))
         return seed, result
 
     def _read_seed(self, seed, ntraj):
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 71131c2335..0ef84fdeef 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -98,6 +98,12 @@ def _discrete_martingale(self, collapses):
                    for tk, ik in collapses]
         return np.prod(factors)
 
+    def _current_martingale(self):
+        t, *_ = self._integrator.get_state(copy=False)
+        collapses = self._integrator.collapses
+        return self._continuous_martingale(t) *\
+            self._discrete_martingale(collapses)
+
     # Override "run" and "start" to initialize continuous part
     #     of martingale evolution
     def run(self, state, tlist, *args, **kwargs):
@@ -111,17 +117,15 @@ def start(self, state, t0, seed=None):
         return super().start(state, t0, seed=seed)
 
     # Override "_restore_state" to include the martingale in the state
-    def _restore_state(self, data, t, *, copy=True):
+    def _restore_state(self, data, *, copy=True):
         # find state |psi><psi|
-        state = super()._restore_state(data, t, copy=copy)
+        state = super()._restore_state(data, copy=copy)
         if isket(state):
             # influence martingale is for weighting density matrices, not kets!
             state = ket2dm(state)
 
         # find martingale mu
-        collapses = self._integrator.collapses
-        mu = self._continuous_martingale(t) *\
-            self._discrete_martingale(collapses)
+        mu = self._current_martingale()
 
         # return weighted state
         return mu * state
diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index bc5dec30f1..953bfab490 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -89,7 +89,7 @@ def _prepare_state(self, state):
             return stack_columns(state.data)
         return state.data
 
-    def _restore_state(self, data, t, *, copy=True):
+    def _restore_state(self, data, *, copy=True):
         """
         Retore the Qobj state from its data.
         """
@@ -147,15 +147,14 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
             e_ops, self.options,
             solver=self.name, stats=stats,
         )
-        results.add(tlist[0],
-                    self._restore_state(_data0, tlist[0], copy=False))
+        results.add(tlist[0], self._restore_state(_data0, copy=False))
         stats['preparation time'] += time() - _time_start
 
         progress_bar = progess_bars[self.options['progress_bar']]()
         progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
         for t, state in self._integrator.run(tlist):
             progress_bar.update()
-            results.add(t, self._restore_state(state, t, copy=False))
+            results.add(t, self._restore_state(state, copy=False))
         progress_bar.finished()
 
         stats['run time'] = progress_bar.total_time()
@@ -206,9 +205,9 @@ def step(self, t, *, args=None, copy=True):
             raise RuntimeError("The `start` method must called first")
         _time_start = time()
         self._argument(args)
-        t, state = self._integrator.integrate(t, copy=False)
+        _, state = self._integrator.integrate(t, copy=False)
         self.stats["run time"] += time() - _time_start
-        return self._restore_state(state, t, copy=copy)
+        return self._restore_state(state, copy=copy)
 
     def _get_integrator(self):
         """ Return the initialted integrator. """

From da6c54bacc4c5e31193244162d0fe5310ac946d0 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 8 Feb 2023 13:28:12 +0900
Subject: [PATCH 046/602] Save average martingale values in custom result
 object for nm_mcsolve

---
 qutip/solver/nm_mcsolve.py | 45 +++++++++++++++++++++++++++-----------
 qutip/solver/result.py     | 29 ++++++++++++++++++++++++
 2 files changed, 61 insertions(+), 13 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 0ef84fdeef..b9afffc558 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -4,17 +4,23 @@
 import numpy as np
 import scipy
 from .mcsolve import MCSolver
-from .result import McResult
+from .result import Result, NmmcResult
 from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
 
 
+def _2dm(q):
+    if isket(q):
+        return ket2dm(q)
+    return q
+
+
 class NonMarkovianMCSolver(MCSolver):
     r"""
     Monte-Carlo solver for master equation with negative rates.
     Based on the methods explained in arXiv:2209.08958 [quant-ph]
     """
     name = "nm_mcsolve"
-    resultclass = McResult
+    resultclass = NmmcResult
     solver_options = {
         **MCSolver.solver_options,
         "completeness_rtol": 1e-5,
@@ -116,16 +122,29 @@ def start(self, state, t0, seed=None):
         self._mu_c = {t0: 1}
         return super().start(state, t0, seed=seed)
 
-    # Override "_restore_state" to include the martingale in the state
-    def _restore_state(self, data, *, copy=True):
-        # find state |psi><psi|
-        state = super()._restore_state(data, copy=copy)
-        if isket(state):
-            # influence martingale is for weighting density matrices, not kets!
-            state = ket2dm(state)
+    # Override "step" to include the martingale mu in the state
+    # Note that the returned state will be a density matrix with trace=mu
+    def step(self, t, *, args=None, copy=True):
+        state = super().step(t, args=args, copy=copy)
+        state_dm = _2dm(state)
+        return state_dm * self._current_martingale()
 
-        # find martingale mu
-        mu = self._current_martingale()
+    # Override "_run_one_traj" to include and store the martingale
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        result = Result(e_ops, {**self.options, "normalize_output": False})
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
 
-        # return weighted state
-        return mu * state
+        # martingale is one at the starting time
+        result.trace = [1]
+        state_dm = _2dm(self._restore_state(state, copy=False))
+        result.add(tlist[0], state_dm)
+
+        for t in tlist[1:]:
+            t, state = self._integrator.integrate(t, copy=False)
+            state_dm = _2dm(self._restore_state(state, copy=False))
+            mu = self._current_martingale()
+            result.add(t, state_dm * mu)
+            result.trace.append(mu)
+        result.collapse = self._integrator.collapses
+        return seed, result
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index a87ad9206c..087429230f 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -970,3 +970,32 @@ def runs_photocurrent(self):
                 for i in range(self.num_c_ops)
             ])
         return measurements
+
+
+class NmmcResult(McResult):
+    def _add_trace(self, trajectory):
+        new_trace = np.array(trajectory.trace)
+        self._sum_trace += new_trace
+        avg = self._sum_trace / self.num_trajectories
+        self._sum2_trace += np.abs(new_trace)**2
+        avg2 = self._sum2_trace / self.num_trajectories
+
+        self.trace = avg
+        self.average_trace = avg
+        self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg)**2))
+
+    def _add_first_traj(self, trajectory):
+        super()._add_first_traj(trajectory)
+        self._sum_trace = np.zeros_like(trajectory.times)
+        self._sum2_trace = np.zeros_like(trajectory.times)
+
+    def _post_init(self):
+        super()._post_init()
+
+        self._sum_trace = None
+        self._sum2_trace = None
+        self.trace = []
+        self.average_trace = []
+        self.std_trace = []
+
+        self.add_processor(self._add_trace)

From 4a25709f90ed7c6dc2153011ee5a8110f3957c95 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 8 Feb 2023 15:32:35 +0900
Subject: [PATCH 047/602] Made single trajectory result class generic in
 MultiTrajSolver to avoid code duplication in MCSolver and
 NonMarkovianMCSolver

---
 qutip/solver/mcsolve.py    | 13 +++----------
 qutip/solver/multitraj.py  |  9 ++++-----
 qutip/solver/nm_mcsolve.py | 37 ++++++++-----------------------------
 qutip/solver/result.py     | 23 ++++++++++++++++++++++-
 4 files changed, 37 insertions(+), 45 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index e79d7aa15a..48150c4555 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,12 +1,10 @@
 __all__ = ['mcsolve', "MCSolver"]
 
-import warnings
-
 import numpy as np
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
 from .multitraj import MultiTrajSolver
 from .solver_base import Solver, Integrator
-from .result import McResult, Result
+from .result import McResult, McTrajectory
 from .mesolve import mesolve, MESolver
 import qutip.core.data as _data
 from time import time
@@ -349,6 +347,7 @@ class MCSolver(MultiTrajSolver):
     """
     name = "mcsolve"
     resultclass = McResult
+    trajectoryclass = McTrajectory
     solver_options = {
         "progress_bar": "text",
         "progress_kwargs": {"chunk_size": 10},
@@ -431,13 +430,7 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         # multiprocessing, but will fail with multithreading.
         # If a thread base parallel map is created, eahc trajectory should use
         # a copy of the integrator.
-        result = Result(e_ops, {**self.options, "normalize_output": False})
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
-        for t in tlist[1:]:
-            t, state = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
+        seed, result = super()._run_one_traj(seed, state, tlist, e_ops)
         result.collapse = self._integrator.collapses
         return seed, result
 
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 204178d116..08f49b1494 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -1,12 +1,10 @@
-from .. import Qobj, QobjEvo
 from .result import Result, MultiTrajResult
 from .parallel import _get_map
 from time import time
 from .solver_base import Solver
 import numpy as np
-from copy import copy
 
-__all__ = ["MultiTrajSolver", "TrajectorySolver"]
+__all__ = ["MultiTrajSolver"]
 
 
 class MultiTrajSolver(Solver):
@@ -30,6 +28,7 @@ class MultiTrajSolver(Solver):
     """
     name = "generic multi trajectory"
     resultclass = MultiTrajResult
+    trajectoryclass = Result
     _avail_integrators = {}
 
     # Class of option used by the solver
@@ -198,12 +197,12 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         """
         Run one trajectory and return the result.
         """
-        result = Result(e_ops, self.options)
+        result = self.trajectoryclass(e_ops, self.options)
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
         result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
-            t, state = self._integrator.step(t, copy=False)
+            t, state = self._integrator.integrate(t, copy=False)
             result.add(t, self._restore_state(state, copy=False))
         return seed, result
 
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index b9afffc558..c0e7646f04 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -4,16 +4,10 @@
 import numpy as np
 import scipy
 from .mcsolve import MCSolver
-from .result import Result, NmmcResult
+from .result import NmmcResult, NmmcTrajectory
 from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
 
 
-def _2dm(q):
-    if isket(q):
-        return ket2dm(q)
-    return q
-
-
 class NonMarkovianMCSolver(MCSolver):
     r"""
     Monte-Carlo solver for master equation with negative rates.
@@ -21,6 +15,8 @@ class NonMarkovianMCSolver(MCSolver):
     """
     name = "nm_mcsolve"
     resultclass = NmmcResult
+    # "solver" argument will be partially initialized in constructor
+    trajectoryclass = NmmcTrajectory
     solver_options = {
         **MCSolver.solver_options,
         "completeness_rtol": 1e-5,
@@ -30,6 +26,8 @@ class NonMarkovianMCSolver(MCSolver):
     # ops_and_rates is a list of tuples (L_i, Gamma_i),
     #     where Gamma_i = Gamma_i(t) is callable
     def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
+        self.trajectoryclass = partial(NmmcTrajectory, solver=self)
+
         self.ops_and_rates = list(ops_and_rates)
         self.options = options
         self._mu_c = None
@@ -126,25 +124,6 @@ def start(self, state, t0, seed=None):
     # Note that the returned state will be a density matrix with trace=mu
     def step(self, t, *, args=None, copy=True):
         state = super().step(t, args=args, copy=copy)
-        state_dm = _2dm(state)
-        return state_dm * self._current_martingale()
-
-    # Override "_run_one_traj" to include and store the martingale
-    def _run_one_traj(self, seed, state, tlist, e_ops):
-        result = Result(e_ops, {**self.options, "normalize_output": False})
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-
-        # martingale is one at the starting time
-        result.trace = [1]
-        state_dm = _2dm(self._restore_state(state, copy=False))
-        result.add(tlist[0], state_dm)
-
-        for t in tlist[1:]:
-            t, state = self._integrator.integrate(t, copy=False)
-            state_dm = _2dm(self._restore_state(state, copy=False))
-            mu = self._current_martingale()
-            result.add(t, state_dm * mu)
-            result.trace.append(mu)
-        result.collapse = self._integrator.collapses
-        return seed, result
+        if isket(state):
+            state = ket2dm(state)
+        return state * self._current_martingale()
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 087429230f..8d94bbdb52 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1,6 +1,6 @@
 """ Class for solve function results"""
 import numpy as np
-from ..core import Qobj, QobjEvo, expect, qzero
+from ..core import Qobj, QobjEvo, expect, isket, ket2dm, qzero
 
 __all__ = ["Result", "MultiTrajResult", "McResult"]
 
@@ -866,6 +866,12 @@ def __add__(self, other):
         return new
 
 
+class McTrajectory(Result):
+    def __init__(self, e_ops, options, *args, **kwargs):
+        super().__init__(e_ops, {**options, "normalize_output": False},
+                         *args, **kwargs)
+
+
 class McResult(MultiTrajResult):
     """
     Base class for storing solver results.
@@ -972,6 +978,21 @@ def runs_photocurrent(self):
         return measurements
 
 
+class NmmcTrajectory(McTrajectory):
+    def __init__(self, e_ops, options, solver, *args, **kwargs):
+        super().__init__(e_ops, options, *args, **kwargs)
+
+        self._solver = solver
+        self.trace = []
+
+    def add(self, t, state):
+        if isket(state):
+            state = ket2dm(state)
+        mu = self._solver._current_martingale()
+        super().add(t, state * mu)
+        self.trace.append(mu)
+
+
 class NmmcResult(McResult):
     def _add_trace(self, trajectory):
         new_trace = np.array(trajectory.trace)

From fe801a87c73a745a6fd271cb8dd745f3c206a3bb Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 8 Feb 2023 12:44:50 +0100
Subject: [PATCH 048/602] Add readthedocs configuration.

---
 .readthedocs.yaml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 .readthedocs.yaml

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 0000000000..cfd48e0e2d
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,24 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+formats:
+  - epub
+  - pdf
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+    - method: pip
+      path: .[full]
+
+sphinx:
+  configuration: docs/conf.py
+  fail_on_warning: true
\ No newline at end of file

From 1fa3ec697208078608c9acf10c1cae19f693605d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 8 Feb 2023 18:38:45 -0500
Subject: [PATCH 049/602] Add tests

---
 qutip/solver/sode/check.py                   | 145 +++-------------
 qutip/solver/sode/ito.py                     |  34 ++--
 qutip/solver/sode/ssystem.pyx                |  76 +++++++++
 qutip/tests/solver/test_stochastic_system.py | 164 +++++++++++++++++++
 4 files changed, 277 insertions(+), 142 deletions(-)
 create mode 100644 qutip/tests/solver/test_stochastic_system.py

diff --git a/qutip/solver/sode/check.py b/qutip/solver/sode/check.py
index 5fc53a874b..39193220a8 100644
--- a/qutip/solver/sode/check.py
+++ b/qutip/solver/sode/check.py
@@ -3,123 +3,30 @@
 from qutip.core import data as _data
 import qutip
 
-def make_1_step(H, psi, sc_ops, solver, dt, dw=False):
-    ssolver = qutip.smesolve(H, psi, [0,dt], sc_ops=c_ops, _dry_run=1, solver=solver, nsubsteps=1)
-    state = qutip.operator_to_vector(ssolver.sso.state0).full().flatten()
-    func = getattr(ssolver, solver)
-    out = np.zeros_like(state)
-    if dw is False:
-        dw = np.array([1.] * 2 * len(sc_ops)) * dt**0.5
-    func(0, dt, dw, state, out)
-    return qutip.Qobj( qutip.unstack_columns(out))
-
-
-def L0(system, f):
-    def _func(t, rho, dt=1e-6):
-        n = rho.shape[0]
-        f0 = f(t, rho)
-
-        out = (f(t+dt, rho) - f0) / dt
-
-        jac = np.zeros((n, n), dtype=complex)
-        for i in range(n):
-            dxi = qutip.basis(n, i).data
-            jac[:, i] = (f(t, rho + dt * dxi) - f0).to_array().flatten() / dt
-        out = out + qutip.data.Dense(jac) @ system.drift(t, rho)
-
-        for i, j in product(range(n), repeat=2):
-            dxi = qutip.basis(n, i).data
-            dxj = qutip.basis(n, j).data
-            sec = f(t, (rho + dxi * dt + dxj * dt))
-            sec = sec - f(t, (rho + dxj * dt))
-            sec = sec - f(t, (rho + dxi * dt))
-            sec = sec + f0
-            sec = sec / dt / dt * 0.5
-            for k in range(system.num_collapse):
-                out = out + (
-                    sec
-                    * qutip.data.inner(dxi, system.diffusion(t, rho)[k])
-                    * qutip.data.inner(dxj, system.diffusion(t, rho)[k])
-                )
-        return out
-    return _func
-
-
-def L(system, ii, f):
-    def _func(t, rho, dt=1e-6):
-        n = rho.shape[0]
-        jac = np.zeros((n, n), dtype=complex)
-        f0 = f(t, rho)
-        for i in range(n):
-            dxi = qutip.basis(n, i).data
-            jac[:, i] = (f(t, (rho + dt * dxi)) - f0).to_array().flatten()
-        return qutip.data.Dense(jac) @ system.diffusion(t, rho)[ii] / dt
-    return _func
-
-
-def LL(system, ii, jj, f):
-    # Can be implemented as 2 calls of ``L``, but this use 2 ``dt`` which
-    # cannot be different.
-    def _func(t, rho, dt=1e-6):
-        f0 = f(t, rho)
-        bi = system.diffusion(t, rho)[ii]
-        bj = system.diffusion(t, rho)[jj]
-        out = rho *0.
-        n = rho.shape[0]
-
-        for i, j in product(range(n), repeat=2):
-            dxi = qutip.basis(n, i, dtype="Dense").data
-            dxj = qutip.basis(n, j, dtype="Dense").data
-            sec = f(t, (rho + dxi * dt + dxj * dt))
-            sec = sec - f(t, (rho + dxj * dt))
-            sec = sec - f(t, (rho + dxi * dt))
-            sec = sec + f0
-            sec = sec / dt / dt
-
-            out = out + (
-                sec * qutip.data.inner(dxi, bi) * qutip.data.inner(dxj, bj)
-            )
-            df = (f(t, (rho + dxj * dt)) - f0) / dt
-            db = (system.diffusion(t, (rho + dxi * dt))[jj] - system.diffusion(t, rho)[jj] ) / dt
-
-            out = out + (
-                df * qutip.data.inner(dxi, bi) * qutip.data.inner(dxj, db)
-            )
-
-        return out
-    return _func
-
-
-def _check_equivalence(f, target, args):
-    dts = np.logspace(-5, -1, 9)
-    errors_dt = [
-        _data.norm.l2(f(*args, dt=dt) - target) / dt
-        for dt in dts
+def compute_step(system, method, state, ts, noise, **kw):
+    import qutip.solver.sode._sode as _sode
+    stepper = getattr(_sode, method)(system, **kw)
+    out = []
+    for t in ts:
+        out.append(stepper.run(0, state.copy(), t, noise.dW(t), 1))
+    return out
+
+
+def get_error_order(system, method):
+    num_runs = 10
+    ts = [
+        0.000001, 0.000002, 0.000005, 0.00001, 0.00002,  0.00005,
+        0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1,
     ]
-    poly = np.polyfit(dts, errors_dt, 1)
-    return -1 < poly[0] < 1
-
-
-def run_derr_check(solver, t, state):
-    N = solver.num_collapse
-    a = solver.drift
-    solver.set_state(t, state)
-
-    assert solver.drift(t, state) == solver.a()
-    assert _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
-
-    for i in range(N):
-        b = lambda *args: solver.diffusion(*args)[i]
-        assert b(t, state) == solver.bi(i)
-        assert _check_equivalence(L0(solver, b), solver.L0bi(i), (t, state))
-        assert _check_equivalence(L(solver, i, a), solver.Lia(i), (t, state))
-
-        for j in range(N):
-            assert _check_equivalence(
-                L(solver, j, b), solver.Libj(j, i), (t, state)
-            )
-
-            for k in range(N):
-                assert _check_equivalence(
-                    LL(solver, k, j, b), solver.LiLjbk(k, j, i), (t, state)
-                )
+    state = rand_ket(system.dims[0]).data
+    err = np.zeros(len(ts), dtype=float)
+    for _ in range(num_runs):
+        noise = MultiNoise(0.1, 0.000001)
+        out = compute_step(system, method, state, ts, noise)
+
+        for i, (o, t) in enumerate(zip(out, ts)):
+            got = o.to_array()[0,0]
+            target = system.analytic(t, noise.dw(t)[0,0])
+            err[i] += (np.abs(got - target))
+    err /= num_runs
+    return np.polyfit(np.log(ts), np.log(err), 1)
diff --git a/qutip/solver/sode/ito.py b/qutip/solver/sode/ito.py
index 294e517a36..d3ea5df255 100644
--- a/qutip/solver/sode/ito.py
+++ b/qutip/solver/sode/ito.py
@@ -1,21 +1,5 @@
 import numpy as np
 
-class ItoNoise:
-    def __init__(self, T, dt):
-        N = int(np.round(T / dt))
-        self.T = T
-        self.dt = dt
-        self.noise = np.random.randn(N) * dt**0.5
-
-    def dw(self, dt):
-        # I(j)
-        N = int(np.round(dt /self.dt))
-        return self.noise.reshape(-1, N).sum(axis=1)
-
-    def dz(self, dt):
-        # I(0, j)
-        N = int(np.round(dt /self.dt))
-        return self.noise.reshape(-1, N) @ np.arange(N-0.5, 0, -1) * self.dt
 
 class MultiNoise:
     def __init__(self, T, dt, num=1):
@@ -32,17 +16,21 @@ def dw(self, dt):
     def dz(self, dt):
         N = int(np.round(dt /self.dt))
         return np.einsum(
-            "ijk,j",
+            "ijk,j->ik",
             self.noise.reshape(-1, N, self.num),
             np.arange(N-0.5, 0, -1)
         ) * self.dt
 
     def dW(self, dt):
         N = int(np.round(dt / self.dt))
-        noise = self.noise
+        noise = self.noise.copy()
         if noise.shape[0] % N:
-            noise = noise[:-noise.shape[0] % N]
-        out = np.empty((self.num, 2), dtype=float)
-        out[:, 0] = noise[:N, :].sum(axis=0)
-        out[:, 1] = np.arange(N-0.5, 0, -1) @ noise[:N, :] * self.dt
-        return out.T
+            noise = noise[:-(noise.shape[0] % N)]
+        out = np.empty((noise.shape[0] // N, self.num, 2), dtype=float)
+        out[:, :, 0] = noise.reshape(-1, N, self.num).sum(axis=1)
+        out[:, :, 1] = np.einsum(
+            "ijk,j->ik",
+            self.noise.reshape(-1, N, self.num),
+            np.arange(N-0.5, 0, -1)
+        ) * self.dt
+        return out
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 626d80090d..8fb42a68f9 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -402,3 +402,79 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         _data.imul_dense(self._L0a, 1/self.dt)
         self.L.matmul_data(self.t, self._a, self._L0a)
         self._L0a_set = True
+
+
+cdef class SimpleStochasticSystem(_StochasticSystem):
+    """
+    Simple system that can be solver analytically.
+    """
+    cdef QobjEvo H
+    cdef list c_ops
+    cdef float dt
+
+    def __init__(self, H, c_ops):
+        self.H = -1j * H
+        self.c_ops = c_ops
+
+        self.num_collapse = len(self.c_ops)
+        self.issuper = False
+        self.dims = self.H.dims
+        self.dt = 1e-6
+
+    cpdef Data drift(self, t, Data state):
+        return self.H.matmul_data(t, state)
+
+    cpdef list diffusion(self, t, Data state):
+        cdef int i
+        cdef out = []
+        for i in range(self.num_collapse):
+            out.append(self.c_ops[i].matmul_data(t, state))
+        return out
+
+    cpdef void set_state(self, double t, Data state):
+        self.t = t
+        self.state = _data.to(_data.Dense, state)
+
+    cpdef Data a(self):
+        return self.H.matmul_data(self.t, self.state)
+
+    cpdef Data bi(self, int i):
+        return self.c_ops[i].matmul_data(self.t, self.state)
+
+    cpdef Data Libj(self, int i, int j):
+        bj = self.c_ops[i].matmul_data(self.t, self.state)
+        return self.c_ops[j].matmul_data(self.t, bj)
+
+    cpdef Data Lia(self, int i):
+        bi = self.c_ops[i].matmul_data(self.t, self.state)
+        return self.H.matmul_data(self.t, bi)
+
+    cpdef Data L0bi(self, int i):
+        # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
+        a = self.H.matmul_data(self.t, self.state)
+        abi = self.c_ops[i].matmul_data(self.t, a)
+        b = self.c_ops[i].matmul_data(self.t, self.state)
+        bdt = self.c_ops[i].matmul_data(self.t + self.dt, self.state)
+        return abi + (bdt - b) / self.dt
+
+    cpdef Data LiLjbk(self, int i, int j, int k):
+        bk = self.c_ops[k].matmul_data(self.t, self.state)
+        Ljbk = self.c_ops[j].matmul_data(self.t, bk)
+        return self.c_ops[i].matmul_data(self.t, Ljbk)
+
+    cpdef Data L0a(self):
+        # L0a = a'a + da/dt + bba"/2  (a" = 0)
+        a = self.H.matmul_data(self.t, self.state)
+        aa = self.H.matmul_data(self.t, a)
+        adt = self.H.matmul_data(self.t + self.dt, self.state)
+        return aa + (adt - a) / self.dt
+
+    def analytic(self, t, W):
+        """
+        Analytic solution, H and all c_ops must commute.
+        """
+        out = self.H.full() * t
+        for i in range(self.num_collapse):
+            out += self.c_ops[i].full() * W[i]
+            out -= 0.5 * self.c_ops[i].full() @ self.c_ops[i].full() * t
+        return np.exp(out)
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
new file mode 100644
index 0000000000..4925ec043f
--- /dev/null
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -0,0 +1,164 @@
+import numpy as np
+from qutip import qeye, num, destroy, create, QobjEvo, basis, rand_herm
+from qutip.solver.sode.ssystem import *
+import qutip.data as _data
+import pytest
+
+
+def L0(system, f):
+    def _func(t, rho, dt=1e-6):
+        n = rho.shape[0]
+        f0 = f(t, rho)
+
+        out = (f(t+dt, rho) - f0) / dt
+
+        jac = np.zeros((n, n), dtype=complex)
+        for i in range(n):
+            dxi = basis(n, i).data
+            jac[:, i] = (f(t, rho + dt * dxi) - f0).to_array().flatten() / dt
+        out = out + _data.Dense(jac) @ system.drift(t, rho)
+
+        for i, j in product(range(n), repeat=2):
+            dxi = basis(n, i).data
+            dxj = basis(n, j).data
+            sec = f(t, (rho + dxi * dt + dxj * dt))
+            sec = sec - f(t, (rho + dxj * dt))
+            sec = sec - f(t, (rho + dxi * dt))
+            sec = sec + f0
+            sec = sec / dt / dt * 0.5
+            for k in range(system.num_collapse):
+                out = out + (
+                    sec
+                    * _data.inner(dxi, system.diffusion(t, rho)[k])
+                    * _data.inner(dxj, system.diffusion(t, rho)[k])
+                )
+        return out
+    return _func
+
+
+def L(system, ii, f):
+    def _func(t, rho, dt=1e-6):
+        n = rho.shape[0]
+        jac = np.zeros((n, n), dtype=complex)
+        f0 = f(t, rho)
+        for i in range(n):
+            dxi = basis(n, i).data
+            jac[:, i] = (f(t, (rho + dt * dxi)) - f0).to_array().flatten()
+        return _data.Dense(jac) @ system.diffusion(t, rho)[ii] / dt
+    return _func
+
+
+def LL(system, ii, jj, f):
+    # Can be implemented as 2 calls of ``L``, but would use 2 ``dt`` which
+    # cannot be different.
+    def _func(t, rho, dt=1e-6):
+        f0 = f(t, rho)
+        bi = system.diffusion(t, rho)[ii]
+        bj = system.diffusion(t, rho)[jj]
+        out = rho *0.
+        n = rho.shape[0]
+
+        for i, j in product(range(n), repeat=2):
+            dxi = basis(n, i, dtype="Dense").data
+            dxj = basis(n, j, dtype="Dense").data
+            sec = f(t, (rho + dxi * dt + dxj * dt))
+            sec = sec - f(t, (rho + dxj * dt))
+            sec = sec - f(t, (rho + dxi * dt))
+            sec = sec + f0
+            sec = sec / dt / dt
+
+            out = out + (
+                sec * _data.inner(dxi, bi) * _data.inner(dxj, bj)
+            )
+            df = (f(t, (rho + dxj * dt)) - f0) / dt
+            db = (
+                system.diffusion(t, (rho + dxi * dt))[jj]
+                - system.diffusion(t, rho)[jj]
+            ) / dt
+
+            out = out + (
+                df * _data.inner(dxi, bi) * _data.inner(dxj, db)
+            )
+
+        return out
+    return _func
+
+
+def _check_equivalence(f, target, args):
+    """
+    Check that the error is proportional to `dt`.
+    """
+    dts = np.logspace(-5, -1, 9)
+    errors_dt = [
+        _data.norm.l2(f(*args, dt=dt) - target) / dt
+        for dt in dts
+    ]
+    poly = np.polyfit(dts, errors_dt, 1)
+    return -1 < poly[0] < 1
+
+
+def _run_derr_check(solver, state):
+    """
+
+    """
+    t = 0
+    N = solver.num_collapse
+    a = solver.drift
+    solver.set_state(t, state)
+
+    assert solver.drift(t, state) == solver.a()
+    assert _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
+
+    for i in range(N):
+        b = lambda *args: solver.diffusion(*args)[i]
+        assert b(t, state) == solver.bi(i)
+        assert _check_equivalence(L0(solver, b), solver.L0bi(i), (t, state))
+        assert _check_equivalence(L(solver, i, a), solver.Lia(i), (t, state))
+
+        for j in range(N):
+            assert _check_equivalence(
+                L(solver, j, b), solver.Libj(j, i), (t, state)
+            )
+
+            for k in range(N):
+                assert _check_equivalence(
+                    LL(solver, k, j, b), solver.LiLjbk(k, j, i), (t, state)
+                )
+
+
+def _make_oper(kind, N):
+    if kind == "qeye":
+        out = qeye(N)
+    elif kind == "destroy":
+        out = destroy(N)
+    elif kind == "destroy2":
+        out = destroy(N)**2
+    elif kind == "tridiag":
+        out = destroy(N) + num(N) + create(N)
+    elif kind == "td":
+        out = [num(N), [destroy(N) + create(N), lambda t: t]]
+    elif kind == "rand":
+        out = rand_herm(N)
+    return QobjEvo(out)
+
+
+@pytest.mark.parametrize(['H', 'c_ops'], [
+    pytest.param("qeye", ["destroy"], id='simple'),
+    pytest.param("tridiag", ["destroy"], id='simple'),
+    pytest.param("qeye", ["destroy", "destroy2"], id='2 c_ops'),
+    pytest.param("td", ["destroy"], id='H td'),
+    pytest.param("qeye", ["td"], id='c_ops td'),
+    pytest.param("rand", ["rand"], id='random'),
+])
+@pytest.mark.parametrize('type', ["sse", "sme"])
+@pytest.mark.parametrize('heterodyne', [False, True])
+def test_system(H, c_ops, type, heterodyne):
+    N = 5
+    H = _make_oper(H, N)
+    c_ops = [_make_oper(op, N) for op in c_ops]
+    if type == "sse":
+        system = StochasticClosedSystem(H, c_ops, heterodyne)
+    else:
+        system = StochasticOpenSystem(H, c_ops, heterodyne)
+    state = basis(N, N-2).data
+    _run_derr_check(system, state)

From 3d5761a7d43728e6774c4c42b04f38b5e23d1341 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 10 Feb 2023 11:57:35 +0100
Subject: [PATCH 050/602] Remove ignore of pyximport warnings in coefficient.

---
 qutip/core/coefficient.py | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 545ce271ff..1c9b0e4e38 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -32,17 +32,6 @@
            "clean_compiled_coefficient"]
 
 
-@contextmanager
-def _ignore_import_warning_for_pyximporter():
-    """
-    A helper for ignoring PyxImporter import warnings generated by Python 3.10+
-    because PyxImporter has no .find_spec method.
-    """
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", category=ImportWarning)
-        yield
-
-
 class StringParsingWarning(Warning):
     pass
 
@@ -358,8 +347,7 @@ def try_import(file_name, parsed_in):
     name collision.
     """
     try:
-        with _ignore_import_warning_for_pyximporter():
-            mod = importlib.import_module(file_name)
+        mod = importlib.import_module(file_name)
     except ModuleNotFoundError:
         # Coefficient does not exist, to compile as file_name
         return None
@@ -499,9 +487,8 @@ def compile_code(code, file_name, parsed, c_opt):
                 include_dirs=[np.get_include()],
                 language='c++'
             )
-            with _ignore_import_warning_for_pyximporter():
-                ext_modules = cythonize(coeff_file, force=True)
-                setup(ext_modules=ext_modules)
+            ext_modules = cythonize(coeff_file, force=True)
+            setup(ext_modules=ext_modules)
         except Exception as e:
             if c_opt['clean_on_error']:
                 for file in glob.glob(file_name + "*"):

From d38c1b6d16af145ba3935a200f2f9648a6526ed9 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 10 Feb 2023 12:00:14 +0100
Subject: [PATCH 051/602] Re-enable ImportWarning test errors.

---
 .github/workflows/tests.yml | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index b6c5261e85..cc89348ab3 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -69,9 +69,6 @@ jobs:
 
           # Python 3.10 and numpy 1.22
           # Use conda-forge to provide numpy 1.22
-          # Ignore ImportWarning because pyximport registered an importer
-          # PyxImporter that does not have a find_spec method and this raises
-          # a warning on Python 3.10
           # Ignore DeprecationWarnings raised by cvxpy importing scipy.sparse.X
           # under SciPy 1.8.0+.
           # Ignore DeprecationWarnings raised by versions of
@@ -82,13 +79,10 @@ jobs:
             os: ubuntu-latest
             python-version: "3.10"
             condaforge: 1
-            pytest-extra-options: "-W ignore::ImportWarning -W ignore::DeprecationWarning:cvxpy.interface.scipy_wrapper -W ignore:Absolute:DeprecationWarning"
+            pytest-extra-options: "-W ignore::DeprecationWarning:cvxpy.interface.scipy_wrapper -W ignore:Absolute:DeprecationWarning"
 
           # Python 3.11 and latest numpy
           # Use conda-forge to provide Python 3.11 and latest numpy
-          # Ignore ImportWarning because pyximport registered an importer
-          # PyxImporter that does not have a find_spec method and this raises
-          # a warning on Python 3.10
           # Ignore DeprecationWarnings raised by cvxpy importing scipy.sparse.X
           # under SciPy 1.8.0+.
           # Ignore DeprecationWarnings raised by versions of
@@ -100,7 +94,7 @@ jobs:
             python-version: "3.11"
             condaforge: 1
             conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
-            pytest-extra-options: "-W ignore::ImportWarning -W ignore::DeprecationWarning:cvxpy.interface.scipy_wrapper -W ignore:Absolute:DeprecationWarning -W ignore::DeprecationWarning:Cython.Tempita"
+            pytest-extra-options: "-W ignore::DeprecationWarning:cvxpy.interface.scipy_wrapper -W ignore:Absolute:DeprecationWarning -W ignore::DeprecationWarning:Cython.Tempita"
 
           # Windows. Once all tests pass without special options needed, this
           # can be moved to the main os list in the test matrix. All the tests
@@ -111,7 +105,7 @@ jobs:
           - case-name: Windows Latest
             os: windows-latest
             python-version: "3.10"
-            pytest-extra-options: "-W ignore::ImportWarning -k 'not (test_correlation or test_interpolate or test_mcsolve)'"
+            pytest-extra-options: "-k 'not (test_correlation or test_interpolate or test_mcsolve)'"
 
     steps:
       - uses: actions/checkout@v3

From e955c75e8498ac4e8c5efbace6996b9646d1358f Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 10 Feb 2023 14:36:43 +0100
Subject: [PATCH 052/602] Remove disabling of cvxpy warnings. These were fixed
 in cvxpy 1.3.

---
 .github/workflows/tests.yml | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index cc89348ab3..1a9fc7feb5 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -69,8 +69,6 @@ jobs:
 
           # Python 3.10 and numpy 1.22
           # Use conda-forge to provide numpy 1.22
-          # Ignore DeprecationWarnings raised by cvxpy importing scipy.sparse.X
-          # under SciPy 1.8.0+.
           # Ignore DeprecationWarnings raised by versions of
           # setuptools >= 65.0.0 during pyximport imports This can be removed
           # once https://github.com/cython/cython/issues/4985
@@ -79,12 +77,10 @@ jobs:
             os: ubuntu-latest
             python-version: "3.10"
             condaforge: 1
-            pytest-extra-options: "-W ignore::DeprecationWarning:cvxpy.interface.scipy_wrapper -W ignore:Absolute:DeprecationWarning"
+            pytest-extra-options: "-W ignore:Absolute:DeprecationWarning"
 
           # Python 3.11 and latest numpy
           # Use conda-forge to provide Python 3.11 and latest numpy
-          # Ignore DeprecationWarnings raised by cvxpy importing scipy.sparse.X
-          # under SciPy 1.8.0+.
           # Ignore DeprecationWarnings raised by versions of
           # setuptools >= 65.0.0 during pyximport imports This can be removed
           # once https://github.com/cython/cython/issues/4985
@@ -94,7 +90,7 @@ jobs:
             python-version: "3.11"
             condaforge: 1
             conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
-            pytest-extra-options: "-W ignore::DeprecationWarning:cvxpy.interface.scipy_wrapper -W ignore:Absolute:DeprecationWarning -W ignore::DeprecationWarning:Cython.Tempita"
+            pytest-extra-options: "-W ignore:Absolute:DeprecationWarning -W ignore::DeprecationWarning:Cython.Tempita"
 
           # Windows. Once all tests pass without special options needed, this
           # can be moved to the main os list in the test matrix. All the tests

From b4e5756076706fa1da6204f9a37c1b9da43cac6d Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 10 Feb 2023 14:38:34 +0100
Subject: [PATCH 053/602] Remove disabling of pyximport absolute path warnings
 (QuTiP 5 no longer uses pyximport).

---
 .github/workflows/tests.yml | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 1a9fc7feb5..c5428dfa2c 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -69,28 +69,18 @@ jobs:
 
           # Python 3.10 and numpy 1.22
           # Use conda-forge to provide numpy 1.22
-          # Ignore DeprecationWarnings raised by versions of
-          # setuptools >= 65.0.0 during pyximport imports This can be removed
-          # once https://github.com/cython/cython/issues/4985
-          # is fixed and released.
           - case-name: Python 3.10
             os: ubuntu-latest
             python-version: "3.10"
             condaforge: 1
-            pytest-extra-options: "-W ignore:Absolute:DeprecationWarning"
 
           # Python 3.11 and latest numpy
           # Use conda-forge to provide Python 3.11 and latest numpy
-          # Ignore DeprecationWarnings raised by versions of
-          # setuptools >= 65.0.0 during pyximport imports This can be removed
-          # once https://github.com/cython/cython/issues/4985
-          # is fixed and released.
           - case-name: Python 3.11
             os: ubuntu-latest
             python-version: "3.11"
             condaforge: 1
             conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
-            pytest-extra-options: "-W ignore:Absolute:DeprecationWarning -W ignore::DeprecationWarning:Cython.Tempita"
 
           # Windows. Once all tests pass without special options needed, this
           # can be moved to the main os list in the test matrix. All the tests

From 19f5bc8c3be0a134188ae02528a1b204d491da47 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 10 Feb 2023 16:39:37 +0100
Subject: [PATCH 054/602] Re-enable ignoring the cgi deprecation raised by
 Cython.Tempita.

---
 .github/workflows/tests.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index c5428dfa2c..ca207a7b95 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -76,11 +76,16 @@ jobs:
 
           # Python 3.11 and latest numpy
           # Use conda-forge to provide Python 3.11 and latest numpy
+          # Ignore deprecation of the cgi module in Python 3.11 that is
+          # still imported by Cython.Tempita. This was addressed in
+          # https://github.com/cython/cython/pull/5128 but not backported
+          # to any currently released version.
           - case-name: Python 3.11
             os: ubuntu-latest
             python-version: "3.11"
             condaforge: 1
             conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
+            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
 
           # Windows. Once all tests pass without special options needed, this
           # can be moved to the main os list in the test matrix. All the tests

From 882fa8b900c3f1d1b279ef1a0333f26a0b3f308e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 10 Feb 2023 14:16:48 -0500
Subject: [PATCH 055/602] remove shift_dt

---
 qutip/core/cy/qobjevo.pyx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index ec4983c7cd..daf2f2942f 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -294,7 +294,7 @@ cdef class QobjEvo:
         out.shape = shape
         out.type = type
         out.superrep = superrep
-        out._issuper, out._isoper, out._shift_dt = flags
+        out._issuper, out._isoper = flags
         return out
 
     def _getstate(self):
@@ -302,14 +302,14 @@ cdef class QobjEvo:
         # For jax pytree representation
         # auto_pickle create similar method __getstate__, but since it's
         # automatically created, it could change depending on cython version
-        # etc. so we create our own.
+        # etc., so we create our own.
         return {
             "elements": self.elements,
             "dims": self.dims,
             "shape": self.shape,
             "type": self.type,
             "superrep": self.superrep,
-            "flags": (self._issuper, self._isoper, self._shift_dt)
+            "flags": (self._issuper, self._isoper,)
         }
 
     def __call__(self, double t, dict _args=None, **kwargs):

From 2fa0917407df8c27ad06a1fe6f07941ed44e922a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 10 Feb 2023 16:23:59 -0500
Subject: [PATCH 056/602] Simplify default dtype

---
 qutip/core/coefficient.py   |  4 ++
 qutip/core/data/convert.pyx | 13 -------
 qutip/core/operators.py     | 69 +++++++++++++++++++--------------
 qutip/core/states.py        | 76 ++++++++++++++++++++++---------------
 qutip/partial_transpose.py  |  4 +-
 qutip/random_objects.py     | 28 +++++++++-----
 6 files changed, 111 insertions(+), 83 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 1119643a67..9aafca4dd3 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -51,6 +51,10 @@ def _return(base, **kwargs):
     return base
 
 
+# The `coefficient` function is dispatcher for the type of the `base` to the
+# function that create the `Coefficient` object. `coefficient_builders` store
+# the map `type -> function(base, **kw)`. Optional module can add their
+# `Coefficient` specialization here.
 coefficient_builders = {
     Coefficient: _return,
     np.ndarray: InterCoefficient,
diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index a2419fc682..c2feed3dd1 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -18,7 +18,6 @@ import numbers
 
 import numpy as np
 from scipy.sparse import dok_matrix, csgraph
-from qutip.settings import settings
 cimport cython
 
 __all__ = ['to', 'create']
@@ -90,16 +89,6 @@ cdef class _partial_converter:
         return "<converter to " + self.to.__name__ + ">"
 
 
-cdef class _default_dtype:
-    cdef type dtype
-
-    def __init__(self, dtype):
-        self.dtype = dtype
-
-    def __call__(self):
-        return settings.core["default_dtype"] or self.dtype
-
-
 # While `_to` and `_create` are defined as objects here, they are actually
 # exported by `data.__init__.py` as singleton function objects of their
 # respective types (without the leading underscore).
@@ -319,8 +308,6 @@ cdef class _to:
             registered, or if ``dtype`` is a type, but not a known data-layer
             type.
         """
-        if type(dtype) is _default_dtype:
-            dtype = dtype()
         if type(dtype) is type:
             if dtype not in self.dtypes:
                 raise ValueError(
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index cfc1c3ce9e..f2921882a9 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -18,11 +18,11 @@
 from . import data as _data
 from .qobj import Qobj
 from .dimensions import flatten
-from .data.convert import _default_dtype
+from .. import settings
 
 
 def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
-           dtype=_default_dtype(_data.CSR)):
+           dtype=None):
     """
     Constructs an operator from an array of diagonals.
 
@@ -60,12 +60,13 @@ def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
      [ 0.          0.          0.          0.        ]]
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     offsets = [0] if offsets is None else offsets
     data = _data.diag[dtype](diagonals, offsets, shape)
     return Qobj(data, dims=dims, type='oper', copy=False)
 
 
-def jmat(j, which=None, *, dtype=_default_dtype(_data.CSR)):
+def jmat(j, which=None, *, dtype=None):
     """Higher-order spin operators:
 
     Parameters
@@ -109,12 +110,12 @@ def jmat(j, which=None, *, dtype=_default_dtype(_data.CSR)):
      [ 0.  0.  0.]
      [ 0.  0. -1.]]]
 
-
     Notes
     -----
     If no 'args' input, then returns array of ['x','y','z'] operators.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     if int(2 * j) != 2 * j or j < 0:
         raise ValueError('j must be a non-negative integer or half-integer')
 
@@ -146,7 +147,7 @@ def jmat(j, which=None, *, dtype=_default_dtype(_data.CSR)):
     raise ValueError('Invalid spin operator: ' + which)
 
 
-def _jplus(j, *, dtype=_default_dtype(_data.CSR)):
+def _jplus(j, *, dtype=None):
     """
     Internal functions for generating the data representing the J-plus
     operator.
@@ -156,10 +157,11 @@ def _jplus(j, *, dtype=_default_dtype(_data.CSR)):
     return _data.diag[dtype](data, 1)
 
 
-def _jz(j, *, dtype=_default_dtype(_data.CSR)):
+def _jz(j, *, dtype=None):
     """
     Internal functions for generating the data representing the J-z operator.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     N = int(2*j + 1)
     data = np.array([j-k for k in range(N)], dtype=complex)
     return _data.diag[dtype](data, 0)
@@ -168,7 +170,7 @@ def _jz(j, *, dtype=_default_dtype(_data.CSR)):
 #
 # Spin j operators:
 #
-def spin_Jx(j, *, dtype=_default_dtype(_data.CSR)):
+def spin_Jx(j, *, dtype=None):
     """Spin-j x operator
 
     Parameters
@@ -189,7 +191,7 @@ def spin_Jx(j, *, dtype=_default_dtype(_data.CSR)):
     return jmat(j, 'x', dtype=dtype)
 
 
-def spin_Jy(j, *, dtype=_default_dtype(_data.CSR)):
+def spin_Jy(j, *, dtype=None):
     """Spin-j y operator
 
     Parameters
@@ -210,7 +212,7 @@ def spin_Jy(j, *, dtype=_default_dtype(_data.CSR)):
     return jmat(j, 'y', dtype=dtype)
 
 
-def spin_Jz(j, *, dtype=_default_dtype(_data.CSR)):
+def spin_Jz(j, *, dtype=None):
     """Spin-j z operator
 
     Parameters
@@ -231,7 +233,7 @@ def spin_Jz(j, *, dtype=_default_dtype(_data.CSR)):
     return jmat(j, 'z', dtype=dtype)
 
 
-def spin_Jm(j, *, dtype=_default_dtype(_data.CSR)):
+def spin_Jm(j, *, dtype=None):
     """Spin-j annihilation operator
 
     Parameters
@@ -252,7 +254,7 @@ def spin_Jm(j, *, dtype=_default_dtype(_data.CSR)):
     return jmat(j, '-', dtype=dtype)
 
 
-def spin_Jp(j, *, dtype=_default_dtype(_data.CSR)):
+def spin_Jp(j, *, dtype=None):
     """Spin-j creation operator
 
     Parameters
@@ -273,7 +275,7 @@ def spin_Jp(j, *, dtype=_default_dtype(_data.CSR)):
     return jmat(j, '+', dtype=dtype)
 
 
-def spin_J_set(j, *, dtype=_default_dtype(_data.CSR)):
+def spin_J_set(j, *, dtype=None):
     """Set of spin-j operators (x, y, z)
 
     Parameters
@@ -386,7 +388,7 @@ def sigmaz():
     return _SIGMAZ.copy()
 
 
-def destroy(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
+def destroy(N, offset=0, *, dtype=None):
     """
     Destruction (lowering) operator.
 
@@ -418,13 +420,14 @@ def destroy(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
      [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
      [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     if not isinstance(N, (int, np.integer)):  # raise error if N not integer
         raise ValueError("Hilbert space dimension must be integer value")
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
     return qdiags(data, 1, dtype=dtype)
 
 
-def create(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
+def create(N, offset=0, *, dtype=None):
     """
     Creation (raising) operator.
 
@@ -460,6 +463,7 @@ def create(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
      [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
      [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     if not isinstance(N, (int, np.integer)):  # raise error if N not integer
         raise ValueError("Hilbert space dimension must be integer value")
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
@@ -495,7 +499,7 @@ def _implicit_tensor_dimensions(dimensions):
     return np.prod(flat), [dimensions, dimensions]
 
 
-def qzero(dimensions, *, dtype=_default_dtype(_data.CSR)):
+def qzero(dimensions, *, dtype=None):
     """
     Zero operator.
 
@@ -517,6 +521,7 @@ def qzero(dimensions, *, dtype=_default_dtype(_data.CSR)):
         Zero operator Qobj.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     size, dimensions = _implicit_tensor_dimensions(dimensions)
     # A sparse matrix with no data is equal to a zero matrix.
     type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
@@ -524,7 +529,7 @@ def qzero(dimensions, *, dtype=_default_dtype(_data.CSR)):
                 isherm=True, isunitary=False, copy=False)
 
 
-def qeye(dimensions, *, dtype=_default_dtype(_data.CSR)):
+def qeye(dimensions, *, dtype=None):
     """
     Identity operator.
 
@@ -564,6 +569,7 @@ def qeye(dimensions, *, dtype=_default_dtype(_data.CSR)):
      [0. 0. 0. 1.]]
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     size, dimensions = _implicit_tensor_dimensions(dimensions)
     type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
     return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
@@ -574,7 +580,7 @@ def qeye(dimensions, *, dtype=_default_dtype(_data.CSR)):
 identity = qeye
 
 
-def position(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
+def position(N, offset=0, *, dtype=None):
     """
     Position operator x=1/sqrt(2)*(a+a.dag())
 
@@ -602,7 +608,7 @@ def position(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     return position
 
 
-def momentum(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
+def momentum(N, offset=0, *, dtype=None):
     """
     Momentum operator p=-1j/sqrt(2)*(a-a.dag())
 
@@ -630,7 +636,7 @@ def momentum(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
     return momentum
 
 
-def num(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
+def num(N, offset=0, *, dtype=None):
     """
     Quantum object for number operator.
 
@@ -662,11 +668,12 @@ def num(N, offset=0, *, dtype=_default_dtype(_data.CSR)):
      [0 0 2 0]
      [0 0 0 3]]
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     data = np.arange(offset, offset + N, dtype=complex)
     return qdiags(data, 0, dtype=dtype)
 
 
-def squeeze(N, z, offset=0, *, dtype=_default_dtype(_data.CSR)):
+def squeeze(N, z, offset=0, *, dtype=None):
     """Single-mode squeezing operator.
 
     Parameters
@@ -703,7 +710,7 @@ def squeeze(N, z, offset=0, *, dtype=_default_dtype(_data.CSR)):
      [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
 
     """
-    asq = destroy(N, offset=offset) ** 2
+    asq = destroy(N, offset=offset, dtype=dtype) ** 2
     op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
     return op.expm(dtype=dtype)
 
@@ -737,7 +744,7 @@ def squeezing(a1, a2, z):
     return b.expm()
 
 
-def displace(N, alpha, offset=0, *, dtype=_default_dtype(_data.Dense)):
+def displace(N, alpha, offset=0, *, dtype=None):
     """Single-mode displacement operator.
 
     Parameters
@@ -773,6 +780,7 @@ def displace(N, alpha, offset=0, *, dtype=_default_dtype(_data.Dense)):
      [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     a = destroy(N, offset=offset)
     return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
 
@@ -792,7 +800,7 @@ def commutator(A, B, kind="normal"):
         raise TypeError("Unknown commutator kind '%s'" % kind)
 
 
-def qutrit_ops(*, dtype=_default_dtype(_data.CSR)):
+def qutrit_ops(*, dtype=None):
     """
     Operators for a three level system (qutrit).
 
@@ -810,6 +818,7 @@ def qutrit_ops(*, dtype=_default_dtype(_data.CSR)):
     """
     from .states import qutrit_basis
 
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     out = np.empty((6,), dtype=object)
     one, two, three = qutrit_basis(dtype=dtype)
     out[0] = one * one.dag()
@@ -821,7 +830,7 @@ def qutrit_ops(*, dtype=_default_dtype(_data.CSR)):
     return out
 
 
-def phase(N, phi0=0, *, dtype=_default_dtype(_data.Dense)):
+def phase(N, phi0=0, *, dtype=None):
     """
     Single-mode Pegg-Barnett phase operator.
 
@@ -847,6 +856,7 @@ def phase(N, phi0=0, *, dtype=_default_dtype(_data.Dense)):
     The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
     n = np.arange(N)[:, np.newaxis]
     states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
@@ -855,7 +865,7 @@ def phase(N, phi0=0, *, dtype=_default_dtype(_data.Dense)):
     return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
 
 
-def enr_destroy(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
+def enr_destroy(dims, excitations, *, dtype=None):
     """
     Generate annilation operators for modes in a excitation-number-restricted
     state space. For example, consider a system consisting of 4 modes, each
@@ -901,6 +911,7 @@ def enr_destroy(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
         quantum system described by dims.
     """
     from .states import enr_state_dictionaries
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
 
     nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
 
@@ -919,7 +930,7 @@ def enr_destroy(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
     return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
 
 
-def enr_identity(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
+def enr_identity(dims, excitations, *, dtype=None):
     """
     Generate the identity operator for the excitation-number restricted
     state space defined by the `dims` and `exciations` arguments. See the
@@ -949,6 +960,7 @@ def enr_identity(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
         exication-number-restricted state space defined by `dims` and
         `exciations`.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     from .states import enr_state_dictionaries
     nstates, _, _ = enr_state_dictionaries(dims, excitations)
     return Qobj(_data.identity[dtype](nstates),
@@ -959,7 +971,7 @@ def enr_identity(dims, excitations, *, dtype=_default_dtype(_data.CSR)):
                 copy=False)
 
 
-def charge(Nmax, Nmin=None, frac=1, *, dtype=_default_dtype(_data.CSR)):
+def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
     """
     Generate the diagonal charge operator over charge states
     from Nmin to Nmax.
@@ -989,6 +1001,7 @@ def charge(Nmax, Nmin=None, frac=1, *, dtype=_default_dtype(_data.CSR)):
     .. versionadded:: 3.2
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     if Nmin is None:
         Nmin = -Nmax
     diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
@@ -997,7 +1010,7 @@ def charge(Nmax, Nmin=None, frac=1, *, dtype=_default_dtype(_data.CSR)):
     return out
 
 
-def tunneling(N, m=1, *, dtype=_default_dtype(_data.CSR)):
+def tunneling(N, m=1, *, dtype=None):
     r"""
     Tunneling operator with elements of the form
     :math:`\\sum |N><N+m| + |N+m><N|`.
diff --git a/qutip/core/states.py b/qutip/core/states.py
index 367d093556..c030e33d0b 100644
--- a/qutip/core/states.py
+++ b/qutip/core/states.py
@@ -16,10 +16,10 @@
 import itertools
 
 from . import data as _data
-from .data.convert import _default_dtype
 from .qobj import Qobj
 from .operators import jmat, displace, qdiags
 from .tensor import tensor
+from .. import settings
 
 def _promote_to_zero_list(arg, length):
     """
@@ -43,8 +43,7 @@ def _promote_to_zero_list(arg, length):
     raise TypeError("Dimensions must be an integer or list of integers.")
 
 
-def basis(dimensions, n=None, offset=None,
-          *, dtype=_default_dtype(_data.Dense)):
+def basis(dimensions, n=None, offset=None, *, dtype=None):
     """Generates the vector representation of a Fock state.
 
     Parameters
@@ -106,6 +105,7 @@ def basis(dimensions, n=None, offset=None,
         basis(N, 1) = ground state
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     # Promote all parameters to lists to simplify later logic.
     if not isinstance(dimensions, list):
         dimensions = [dimensions]
@@ -131,7 +131,7 @@ def basis(dimensions, n=None, offset=None,
                 copy=False)
 
 
-def qutrit_basis(*, dtype=_default_dtype(_data.Dense)):
+def qutrit_basis(*, dtype=None):
     """Basis states for a three level system (qutrit)
 
     dtype : type or str
@@ -144,6 +144,7 @@ def qutrit_basis(*, dtype=_default_dtype(_data.Dense)):
         Array of qutrit basis vectors
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     out = np.empty((3,), dtype=object)
     out[:] = [
         basis(3, 0, dtype=dtype),
@@ -155,8 +156,7 @@ def qutrit_basis(*, dtype=_default_dtype(_data.Dense)):
 _COHERENT_METHODS = ('operator', 'analytic')
 
 
-def coherent(N, alpha, offset=0, method=None, *,
-             dtype=_default_dtype(_data.Dense)):
+def coherent(N, alpha, offset=0, method=None, *, dtype=None):
     """Generates a coherent state with eigenvalue alpha.
 
     Constructed using displacement operator on vacuum state.
@@ -210,6 +210,7 @@ def coherent(N, alpha, offset=0, method=None, *,
     but would in that case give more accurate coefficients.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     if offset < 0:
         raise ValueError('Offset must be non-negative')
 
@@ -243,8 +244,7 @@ def coherent(N, alpha, offset=0, method=None, *,
     )
 
 
-def coherent_dm(N, alpha, offset=0, method='operator',
-                *, dtype=_default_dtype(_data.Dense)):
+def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
     """Density matrix representation of a coherent state.
 
     Constructed via outer product of :func:`qutip.states.coherent`
@@ -297,11 +297,11 @@ def coherent_dm(N, alpha, offset=0, method='operator',
     but would in that case give more accurate coefficients.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
 
 
-def fock_dm(dimensions, n=None, offset=None,
-            *, dtype=_default_dtype(_data.CSR)):
+def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
     """Density matrix representation of a Fock state
 
     Constructed via outer product of :func:`qutip.states.fock`.
@@ -342,11 +342,11 @@ def fock_dm(dimensions, n=None, offset=None,
       [ 0.+0.j  0.+0.j  0.+0.j]]
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     return basis(dimensions, n, offset=offset, dtype=dtype).proj()
 
 
-def fock(dimensions, n=None, offset=None,
-         *, dtype=_default_dtype(_data.Dense)):
+def fock(dimensions, n=None, offset=None, *, dtype=None):
     """Bosonic Fock (number) state.
 
     Same as :func:`qutip.states.basis`.
@@ -389,7 +389,7 @@ def fock(dimensions, n=None, offset=None,
     return basis(dimensions, n, offset=offset, dtype=dtype)
 
 
-def thermal_dm(N, n, method='operator', *, dtype=_default_dtype(_data.CSR)):
+def thermal_dm(N, n, method='operator', *, dtype=None):
     """Density matrix for a thermal state of n particles
 
     Parameters
@@ -446,6 +446,7 @@ def thermal_dm(N, n, method='operator', *, dtype=_default_dtype(_data.CSR)):
     if truncated too aggressively.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     if n == 0:
         return fock_dm(N, 0, dtype=dtype)
     else:
@@ -467,7 +468,7 @@ def thermal_dm(N, n, method='operator', *, dtype=_default_dtype(_data.CSR)):
         return out
 
 
-def maximally_mixed_dm(N, *, dtype=_default_dtype(_data.CSR)):
+def maximally_mixed_dm(N, *, dtype=None):
     """
     Returns the maximally mixed density matrix for a Hilbert space of
     dimension N.
@@ -486,6 +487,7 @@ def maximally_mixed_dm(N, *, dtype=_default_dtype(_data.CSR)):
     dm : qobj
         Thermal state density matrix.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     if not isinstance(N, numbers.Integral) or N <= 0:
         raise ValueError("N must be integer N > 0")
     return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
@@ -524,7 +526,7 @@ def ket2dm(Q):
     raise TypeError("Input is not a ket or bra vector.")
 
 
-def projection(N, n, m, offset=None, *, dtype=_default_dtype(_data.CSR)):
+def projection(N, n, m, offset=None, *, dtype=None):
     r"""
     The projection operator that projects state :math:`\lvert m\rangle` on
     state :math:`\lvert n\rangle`.
@@ -550,11 +552,12 @@ def projection(N, n, m, offset=None, *, dtype=_default_dtype(_data.CSR)):
     oper : qobj
          Requested projection operator.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     return basis(N, n, offset=offset, dtype=dtype) @ \
            basis(N, m, offset=offset, dtype=dtype).dag()
 
 
-def qstate(string, *, dtype=_default_dtype(_data.Dense)):
+def qstate(string, *, dtype=None):
     r"""Creates a tensor product for a set of qubits in either
     the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
 
@@ -591,6 +594,7 @@ def qstate(string, *, dtype=_default_dtype(_data.Dense)):
      [ 0.]
      [ 0.]]
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     n = len(string)
     if n != (string.count('u') + string.count('d')):
         raise TypeError('String input to QSTATE must consist ' +
@@ -618,7 +622,7 @@ def _character_to_qudit(x):
     return _qubit_dict[x] if x in _qubit_dict else int(x)
 
 
-def ket(seq, dim=2, *, dtype=_default_dtype(_data.Dense)):
+def ket(seq, dim=2, *, dtype=None):
     """
     Produces a multiparticle ket state for a list or string,
     where each element stands for state of the respective particle.
@@ -696,12 +700,13 @@ def ket(seq, dim=2, *, dtype=_default_dtype(_data.Dense)):
      [ 0.]
      [ 0.]]
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     ns = [_character_to_qudit(x) for x in seq]
     dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
     return basis(dim, ns, dtype=dtype)
 
 
-def bra(seq, dim=2, *, dtype=_default_dtype(_data.Dense)):
+def bra(seq, dim=2, *, dtype=None):
     """
     Produces a multiparticle bra state for a list or string,
     where each element stands for state of the respective particle.
@@ -755,6 +760,7 @@ def bra(seq, dim=2, *, dtype=_default_dtype(_data.Dense)):
     Qobj data =
     [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     return ket(seq, dim=dim, dtype=dtype).dag()
 
 
@@ -872,7 +878,7 @@ def state_index_number(dims, index):
     return np.unravel_index(index, dims)
 
 
-def state_number_qobj(dims, state, *, dtype=_default_dtype(_data.Dense)):
+def state_number_qobj(dims, state, *, dtype=None):
     """
     Return a Qobj representation of a quantum state specified by the state
     array `state`.
@@ -912,6 +918,7 @@ def state_number_qobj(dims, state, *, dtype=_default_dtype(_data.Dense)):
     .. note::
         Deprecated in QuTiP 5.0, use :func:`basis` instead.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     warnings.warn("basis() is a drop-in replacement for this",
                   DeprecationWarning)
     return basis(dims, state, dtype=dtype)
@@ -949,7 +956,7 @@ def enr_state_dictionaries(dims, excitations):
     return nstates, state2idx, idx2state
 
 
-def enr_fock(dims, excitations, state, *, dtype=_default_dtype(_data.Dense)):
+def enr_fock(dims, excitations, state, *, dtype=None):
     """
     Generate the Fock state representation in a excitation-number restricted
     state space. The `dims` argument is a list of integers that define the
@@ -983,6 +990,7 @@ def enr_fock(dims, excitations, state, *, dtype=_default_dtype(_data.Dense)):
         restricted state space defined by `dims` and `exciations`.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
     try:
         data =_data.one_element[dtype]((nstates, 1),
@@ -996,7 +1004,7 @@ def enr_fock(dims, excitations, state, *, dtype=_default_dtype(_data.Dense)):
     return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
 
 
-def enr_thermal_dm(dims, excitations, n, *, dtype=_default_dtype(_data.CSR)):
+def enr_thermal_dm(dims, excitations, n, *, dtype=None):
     """
     Generate the density operator for a thermal state in the excitation-number-
     restricted state space defined by the `dims` and `exciations` arguments.
@@ -1029,6 +1037,7 @@ def enr_thermal_dm(dims, excitations, n, *, dtype=_default_dtype(_data.CSR)):
     dm : Qobj
         Thermal state density matrix.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
     if not isinstance(n, (list, np.ndarray)):
         n = np.ones(len(dims)) * n
@@ -1043,7 +1052,7 @@ def enr_thermal_dm(dims, excitations, n, *, dtype=_default_dtype(_data.CSR)):
     return out
 
 
-def phase_basis(N, m, phi0=0, *, dtype=_default_dtype(_data.Dense)):
+def phase_basis(N, m, phi0=0, *, dtype=None):
     """
     Basis vector for the mth phase of the Pegg-Barnett phase operator.
 
@@ -1074,13 +1083,14 @@ def phase_basis(N, m, phi0=0, *, dtype=_default_dtype(_data.Dense)):
     Hilbert space.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     phim = phi0 + (2.0 * np.pi * m) / N
     n = np.arange(N)[:, np.newaxis]
     data = np.exp(1.0j * n * phim) / np.sqrt(N)
     return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
 
 
-def zero_ket(N, dims=None, *, dtype=_default_dtype(_data.Dense)):
+def zero_ket(N, dims=None, *, dtype=None):
     """
     Creates the zero ket vector with shape Nx1 and dimensions `dims`.
 
@@ -1102,10 +1112,11 @@ def zero_ket(N, dims=None, *, dtype=_default_dtype(_data.Dense)):
         Zero ket on given Hilbert space.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
 
 
-def spin_state(j, m, type='ket', *, dtype=_default_dtype(_data.Dense)):
+def spin_state(j, m, type='ket', *, dtype=None):
     r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
     eigenstate of the spin-j Sz operator with eigenvalue m.
 
@@ -1129,6 +1140,7 @@ def spin_state(j, m, type='ket', *, dtype=_default_dtype(_data.Dense)):
     state : qobj
         Qobj quantum object for spin state
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     J = 2*j + 1
 
     if type == 'ket':
@@ -1141,8 +1153,7 @@ def spin_state(j, m, type='ket', *, dtype=_default_dtype(_data.Dense)):
         raise ValueError(f"Invalid value keyword argument type='{type}'")
 
 
-def spin_coherent(j, theta, phi, type='ket',
-                  *, dtype=_default_dtype(_data.Dense)):
+def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
     r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
 
     Parameters
@@ -1168,6 +1179,7 @@ def spin_coherent(j, theta, phi, type='ket',
     state : qobj
         Qobj quantum object for spin coherent state
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     if type not in ['ket', 'bra', 'dm']:
         raise ValueError("Invalid value keyword argument 'type'")
     Sp = jmat(j, '+')
@@ -1190,7 +1202,7 @@ def spin_coherent(j, theta, phi, type='ket',
     '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
 }
 
-def bell_state(state='00', *, dtype=_default_dtype(_data.Dense)):
+def bell_state(state='00', *, dtype=None):
     r"""
     Returns the selected Bell state:
 
@@ -1222,10 +1234,11 @@ def bell_state(state='00', *, dtype=_default_dtype(_data.Dense)):
     Bell_state : qobj
         Bell state
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     return _BELL_STATES[state].copy().to(dtype)
 
 
-def singlet_state(*, dtype=_default_dtype(_data.Dense)):
+def singlet_state(*, dtype=None):
     r"""
     Returns the two particle singlet-state:
 
@@ -1246,10 +1259,11 @@ def singlet_state(*, dtype=_default_dtype(_data.Dense)):
     Bell_state : qobj
         :math:`\lvert B_{11}\rangle` Bell state
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     return bell_state('11').to(dtype)
 
 
-def triplet_states(*, dtype=_default_dtype(_data.Dense)):
+def triplet_states(*, dtype=None):
     r"""
     Returns a list of the two particle triplet-states:
 
@@ -1278,7 +1292,7 @@ def triplet_states(*, dtype=_default_dtype(_data.Dense)):
     ]
 
 
-def w_state(N=3, *, dtype=_default_dtype(_data.Dense)):
+def w_state(N=3, *, dtype=None):
     """
     Returns the N-qubit W-state:
         ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
@@ -1305,7 +1319,7 @@ def w_state(N=3, *, dtype=_default_dtype(_data.Dense)):
     return np.sqrt(1 / N) * state
 
 
-def ghz_state(N=3, *, dtype=_default_dtype(_data.Dense)):
+def ghz_state(N=3, *, dtype=None):
     """
     Returns the N-qubit GHZ-state:
         ``[ |00...00> + |11...11> ] / sqrt(2)``
diff --git a/qutip/partial_transpose.py b/qutip/partial_transpose.py
index 1601bffbcc..61871369d8 100644
--- a/qutip/partial_transpose.py
+++ b/qutip/partial_transpose.py
@@ -74,7 +74,7 @@ def _partial_transpose_sparse(rho, mask):
     """
 
     data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
-    rho_data = rho.data.as_scipy()
+    rho_data = rho.to("CSR").data.as_scipy()
 
     for m in range(len(rho_data.indptr) - 1):
 
@@ -117,6 +117,6 @@ def _partial_transpose_reference(rho, mask):
             n_pt = state_number_index(
                 rho.dims[0], np.choose(mask, [psi_B, psi_A]))
 
-            A_pt[m_pt, n_pt] = rho.data.as_scipy()[m, n]
+            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
 
     return Qobj(A_pt, dims=rho.dims)
diff --git a/qutip/random_objects.py b/qutip/random_objects.py
index 978fc27e9e..be759ae9db 100644
--- a/qutip/random_objects.py
+++ b/qutip/random_objects.py
@@ -24,7 +24,7 @@
                to_super, to_choi, to_chi, to_kraus, to_stinespring)
 from .core import data as _data
 from .core.dimensions import flatten
-from .core.data.convert import _default_dtype
+from . import settings
 
 
 _RAND = default_rng()
@@ -211,7 +211,7 @@ def _merge_shuffle_blocks(blocks, generator):
 
 
 def rand_herm(dimensions, density=0.30, distribution="fill", *,
-              eigenvalues=(), seed=None, dtype=_default_dtype(_data.CSR)):
+              eigenvalues=(), seed=None, dtype=None):
     """Creates a random sparse Hermitian quantum object.
 
     Parameters
@@ -275,13 +275,16 @@ def rand_herm(dimensions, density=0.30, distribution="fill", *,
         while _data.csr.nnz(out) < 0.95 * nvals:
             out = _rand_jacobi_rotation(out, generator)
         out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
+        dtype = dtype or settings.core["default_dtype"] or _data.CSR
 
     else:
         pos_def = distribution == "pos_def"
         if density < 0.5:
             M = _rand_herm_sparse(N, density, pos_def, generator)
+            dtype = dtype or settings.core["default_dtype"] or _data.CSR
         else:
             M = _rand_herm_dense(N, density, pos_def, generator)
+            dtype = dtype or settings.core["default_dtype"] or _data.Dense
 
         out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
 
@@ -333,7 +336,7 @@ def _rand_herm_dense(N, density, pos_def, generator):
 
 
 def rand_unitary(dimensions, density=1, distribution="haar", *,
-                 seed=None, dtype=_default_dtype(_data.Dense)):
+                 seed=None, dtype=None):
     r"""Creates a random sparse unitary quantum object.
 
     Parameters
@@ -367,6 +370,7 @@ def rand_unitary(dimensions, density=1, distribution="haar", *,
     oper : qobj
         Unitary quantum operator.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     N, dims = _implicit_tensor_dimensions(dimensions)
     if distribution not in ["haar", "exp"]:
         raise ValueError("distribution must be one of {'haar', 'exp'}")
@@ -435,7 +439,7 @@ def _rand_unitary_haar(N, generator):
 
 
 def rand_ket(dimensions, density=1, distribution="haar", *,
-             seed=None, dtype=_default_dtype(_data.Dense)):
+             seed=None, dtype=None):
     """Creates a random ket vector.
 
     Parameters
@@ -470,6 +474,7 @@ def rand_ket(dimensions, density=1, distribution="haar", *,
     oper : qobj
         Ket quantum state vector.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     generator = _get_generator(seed)
     N, dims = _implicit_tensor_dimensions(dimensions)
     if distribution not in ["haar", "fill"]:
@@ -496,7 +501,7 @@ def rand_ket(dimensions, density=1, distribution="haar", *,
 
 def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
             eigenvalues=(), rank=None, seed=None,
-            dtype=_default_dtype(_data.CSR)):
+            dtype=None):
     r"""Creates a random density matrix of the desired dimensions.
 
     Parameters
@@ -543,6 +548,7 @@ def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
     oper : qobj
         Density matrix quantum operator.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     generator = _get_generator(seed)
     N, dims = _implicit_tensor_dimensions(dimensions)
     distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
@@ -623,7 +629,7 @@ def _rand_dm_ginibre(N, rank, generator):
 
 
 def rand_kraus_map(dimensions, *, seed=None,
-                   dtype=_default_dtype(_data.Dense)):
+                   dtype=None):
     """
     Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
     form.
@@ -650,6 +656,7 @@ def rand_kraus_map(dimensions, *, seed=None,
         N^2 x N x N qobj operators.
 
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     N, dims = _implicit_tensor_dimensions(dimensions)
 
     # Random unitary (Stinespring Dilation)
@@ -661,7 +668,7 @@ def rand_kraus_map(dimensions, *, seed=None,
 
 
 def rand_super(dimensions, *, superrep="super", seed=None,
-               dtype=_default_dtype(_data.Dense)):
+               dtype=None):
     """
     Returns a randomly drawn superoperator acting on operators acting on
     N dimensions.
@@ -685,6 +692,7 @@ def rand_super(dimensions, *, superrep="super", seed=None,
         Storage representation. Any data-layer known to `qutip.data.to` is
         accepted.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     generator = _get_generator(seed)
     from .solver.propagator import propagator
     N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
@@ -703,7 +711,7 @@ def rand_super(dimensions, *, superrep="super", seed=None,
 
 def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
                     superrep="super", seed=None,
-                    dtype=_default_dtype(_data.CSR)):
+                    dtype=None):
     """
     Returns a random superoperator drawn from the Bruzda
     et al ensemble for CPTP maps [BCSZ08]_. Note that due to
@@ -746,6 +754,7 @@ def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
         A superoperator acting on vectorized dim × dim density operators,
         sampled from the BCSZ distribution.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
     generator = _get_generator(seed)
     N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
 
@@ -805,7 +814,7 @@ def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
 
 
 def rand_stochastic(dimensions, density=0.75, kind='left',
-                    *, seed=None, dtype=_default_dtype(_data.CSR)):
+                    *, seed=None, dtype=None):
     """Generates a random stochastic matrix.
 
     Parameters
@@ -835,6 +844,7 @@ def rand_stochastic(dimensions, density=0.75, kind='left',
     oper : qobj
         Quantum operator form of stochastic matrix.
     """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
     generator = _get_generator(seed)
     N, dims = _implicit_tensor_dimensions(dimensions)
     num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])

From 778cbba6833f6472ac1cb4c1c5eea7164cd3d70c Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 11:34:09 +0100
Subject: [PATCH 057/602] Bump versions of ipython and prompt-toolkit (see
 dependabot PR #2085).

---
 doc/requirements.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index cb4d830af3..979eb016b4 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -10,7 +10,7 @@ decorator==5.0.7
 docutils==0.16
 idna==2.10
 imagesize==1.2.0
-ipython==7.31.1
+ipython==8.10.0
 ipython-genutils==0.2.0
 jedi==0.18.0
 Jinja2==2.11.3
@@ -24,7 +24,7 @@ parso==0.8.2
 pexpect==4.8.0
 pickleshare==0.7.5
 Pillow==9.3.0
-prompt-toolkit==3.0.18
+prompt-toolkit==3.0.36
 ptyprocess==0.7.0
 Pygments==2.8.1
 pyparsing==2.4.7

From e854789ab8c1eb5b2c66b1caf9b9fe1b89bca15a Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 11:50:51 +0100
Subject: [PATCH 058/602] Fix typo in path to requirements file.

---
 .readthedocs.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index cfd48e0e2d..f5994aeae8 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -15,7 +15,7 @@ build:
 
 python:
   install:
-    - requirements: docs/requirements.txt
+    - requirements: doc/requirements.txt
     - method: pip
       path: .[full]
 

From 214d61af1284034b46e6277d15d51e57e2e2af46 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 12:06:48 +0100
Subject: [PATCH 059/602] Update doc requirements SciPy and requests to latest
 versions.

---
 doc/requirements.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index 979eb016b4..bb52a49954 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -30,8 +30,8 @@ Pygments==2.8.1
 pyparsing==2.4.7
 python-dateutil==2.8.1
 pytz==2021.1
-requests==2.25.1
-scipy==1.6.2
+requests==2.28.2
+scipy==1.10.0
 six==1.15.0
 snowballstemmer==2.1.0
 Sphinx==3.5.4

From 0fcd0e2124306e0f726c93e75212f8bff997bf45 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 12:59:59 +0100
Subject: [PATCH 060/602] Install RTD requirements using conda.

---
 .readthedocs.yaml       |  4 ++-
 doc/rtd-environment.yml | 54 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+), 1 deletion(-)
 create mode 100644 doc/rtd-environment.yml

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index f5994aeae8..31e688d547 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -13,9 +13,11 @@ build:
   tools:
     python: "3.11"
 
+conda:
+  environment: doc/rtd-environment.yml
+
 python:
   install:
-    - requirements: doc/requirements.txt
     - method: pip
       path: .[full]
 
diff --git a/doc/rtd-environment.yml b/doc/rtd-environment.yml
new file mode 100644
index 0000000000..b50ee037a4
--- /dev/null
+++ b/doc/rtd-environment.yml
@@ -0,0 +1,54 @@
+name: rtd-environment
+channels:
+- conda-forge
+dependencies:
+- alabaster==0.7.12
+- appnope==0.1.3
+- Babel==2.9.1
+- backcall==0.2.0
+- certifi==2022.12.7
+- chardet==4.0.0
+- cycler==0.10.0
+- Cython==0.29.23
+- decorator==5.0.7
+- docutils==0.16
+- idna==2.10
+- imagesize==1.2.0
+- ipython==8.10.0
+- jedi==0.18.0
+- Jinja2==2.11.3
+- kiwisolver==1.3.1
+- MarkupSafe==1.1.1
+- matplotlib==3.3.4
+- numpy==1.22.0
+- numpydoc==1.1.0
+- packaging==20.9
+- parso==0.8.2
+- pexpect==4.8.0
+- pickleshare==0.7.5
+- Pillow==9.4.0
+- prompt-toolkit==3.0.36
+- ptyprocess==0.7.0
+- Pygments==2.8.1
+- pyparsing==2.4.7
+- python-dateutil==2.8.1
+- pytz==2021.1
+- requests==2.28.2
+- scipy==1.10.0
+- six==1.15.0
+- snowballstemmer==2.1.0
+- Sphinx==3.5.4
+- sphinx-gallery==0.8.2
+- sphinx-rtd-theme==1.1.1
+- sphinxcontrib-applehelp==1.0.2
+- sphinxcontrib-bibtex==2.4.1
+- sphinxcontrib-devhelp==1.0.2
+- sphinxcontrib-htmlhelp==1.0.3
+- sphinxcontrib-jsmath==1.0.1
+- sphinxcontrib-qthelp==1.0.3
+- sphinxcontrib-serializinghtml==1.1.4
+- suitesparse
+- traitlets==5.0.5
+- urllib3==1.26.5
+- wcwidth==0.2.5
+- wheel==0.38.1
\ No newline at end of file

From e2a9128b41a855ac4e654c998c3e6d76901768e1 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 13:08:31 +0100
Subject: [PATCH 061/602] Install RTD qutip using conda.

---
 .readthedocs.yaml       | 7 +------
 doc/rtd-environment.yml | 5 ++++-
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 31e688d547..dd78dd1261 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -16,11 +16,6 @@ build:
 conda:
   environment: doc/rtd-environment.yml
 
-python:
-  install:
-    - method: pip
-      path: .[full]
-
 sphinx:
-  configuration: docs/conf.py
+  configuration: doc/conf.py
   fail_on_warning: true
\ No newline at end of file
diff --git a/doc/rtd-environment.yml b/doc/rtd-environment.yml
index b50ee037a4..bff96303cd 100644
--- a/doc/rtd-environment.yml
+++ b/doc/rtd-environment.yml
@@ -51,4 +51,7 @@ dependencies:
 - traitlets==5.0.5
 - urllib3==1.26.5
 - wcwidth==0.2.5
-- wheel==0.38.1
\ No newline at end of file
+- wheel==0.38.1
+- pip
+- pip:
+  - .[full]
\ No newline at end of file

From 71c30f7c4c098d8ce7c4d248f6ac6ba8cfeae701 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 13:13:46 +0100
Subject: [PATCH 062/602] Switch RTD to mambaforge.

---
 .readthedocs.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index dd78dd1261..621860399e 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -11,7 +11,7 @@ formats:
 build:
   os: ubuntu-22.04
   tools:
-    python: "3.11"
+    python: "mambaforge-4.10"
 
 conda:
   environment: doc/rtd-environment.yml

From 118d30f23b879ebeca928045e2da56e900222a4e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sat, 11 Feb 2023 13:23:44 +0100
Subject: [PATCH 063/602] Fix RTD path to qutip.

---
 doc/rtd-environment.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/rtd-environment.yml b/doc/rtd-environment.yml
index bff96303cd..13a0890dd3 100644
--- a/doc/rtd-environment.yml
+++ b/doc/rtd-environment.yml
@@ -54,4 +54,4 @@ dependencies:
 - wheel==0.38.1
 - pip
 - pip:
-  - .[full]
\ No newline at end of file
+  - ..[full]
\ No newline at end of file

From cfe91ab0c2dc1dc9530dc844ff23eaf2174a31b1 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 12 Feb 2023 17:17:23 +0100
Subject: [PATCH 064/602] More carefully manage plot context in all the
 dynamics guides.

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst |  9 ++++++---
 doc/guide/dynamics/dynamics-floquet.rst        | 15 ++++++++++-----
 doc/guide/dynamics/dynamics-master.rst         | 13 +++++++++----
 doc/guide/dynamics/dynamics-monte.rst          |  7 ++++++-
 doc/guide/dynamics/dynamics-stochastic.rst     |  7 ++++++-
 doc/guide/dynamics/dynamics-time.rst           |  9 +++++++--
 6 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 5ec31e0e09..892c0a651a 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -6,6 +6,7 @@ Bloch-Redfield master equation
 
 
 .. plot::
+      :context: reset
       :include-source: False
 
       import pylab as plt
@@ -392,7 +393,9 @@ A full example is:
 
     plt.show()
 
-.. plot::
-    :context: close-figs
-
 Further examples on time-dependent Bloch-Redfield simulations can be found in the online tutorials.
+
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-floquet.rst b/doc/guide/dynamics/dynamics-floquet.rst
index e3d0a3020c..7d3da8c38e 100644
--- a/doc/guide/dynamics/dynamics-floquet.rst
+++ b/doc/guide/dynamics/dynamics-floquet.rst
@@ -93,7 +93,7 @@ Consider for example the case of a strongly driven two-level atom, described by
 In QuTiP we can define this Hamiltonian as follows:
 
 .. plot::
-   :context: close-figs
+   :context: reset
 
    >>> delta = 0.2 * 2*np.pi
    >>> eps0 = 1.0 * 2*np.pi
@@ -107,7 +107,7 @@ In QuTiP we can define this Hamiltonian as follows:
 The :math:`t=0` Floquet modes corresponding to the Hamiltonian :eq:`eq_driven_qubit` can then be calculated using the :class:`qutip.FloquetBasis` class, which encapsulates the Floquet modes and the quasienergies:
 
 .. plot::
-   :context:
+   :context: close-figs
 
    >>> T = 2*np.pi / omega
    >>> floquet_basis = FloquetBasis(H, T, args)
@@ -131,7 +131,7 @@ For certain driving amplitudes the quasienergy levels cross.
 Since the quasienergies can be associated with the time-scale of the long-term dynamics due that the driving, degenerate quasienergies indicates a "freezing" of the dynamics (sometimes known as coherent destruction of tunneling).
 
 .. plot::
-   :context:
+   :context: close-figs
 
    >>> delta = 0.2 * 2 * np.pi
    >>> eps0  = 0.0 * 2 * np.pi
@@ -175,7 +175,7 @@ The purpose of calculating the Floquet modes is to find the wavefunction solutio
 To do that, we first need to decompose the initial state in the Floquet states, using the function :meth:`FloquetBasis.to_floquet_basis`
 
 .. plot::
-   :context:
+   :context: close-figs
 
    >>> psi0 = rand_ket(2)
    >>> f_coeff = floquet_basis.to_floquet_basis(psi0)
@@ -186,7 +186,7 @@ To do that, we first need to decompose the initial state in the Floquet states,
 and given this decomposition of the initial state in the Floquet states we can easily evaluate the wavefunction that is the solution to :eq:`eq_driven_qubit` at an arbitrary time :math:`t` using the function :meth:`FloquetBasis.from_floquet_basis`:
 
 .. plot::
-   :context:
+   :context: close-figs
 
    >>> t = 10 * np.random.rand()
    >>> psi_t = floquet_basis.from_floquet_basis(f_coeff, t)
@@ -283,3 +283,8 @@ Finally, :func:`qutip.solver.floquet.fmmesolve`  always expects the ``e_ops`` to
 
     output = fmmesolve(H, psi0, tlist, [sigmax()], e_ops=[num(2)], spectra_cb=[noise_spectrum], T=T, args=args)
     p_ex = output.expect[0]
+
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-master.rst b/doc/guide/dynamics/dynamics-master.rst
index 2fa7f87d9b..832b971e3f 100644
--- a/doc/guide/dynamics/dynamics-master.rst
+++ b/doc/guide/dynamics/dynamics-master.rst
@@ -30,7 +30,7 @@ It evolves the state vector and evaluates the expectation values for a set of op
 For example, the time evolution of a quantum spin-1/2 system with tunneling rate 0.1 that initially is in the up state is calculated, and the  expectation values of the :math:`\sigma_z` operator evaluated, with the following code
 
 .. plot::
-    :context:
+    :context: reset
 
     >>> H = 2*np.pi * 0.1 * sigmax()
     >>> psi0 = basis(2, 0)
@@ -47,7 +47,7 @@ Adding operators to this list results in a larger output list returned by the fu
 
 
 .. plot::
-    :context:
+    :context: close-figs
 
     >>> result = sesolve(H, psi0, times, e_ops=[sigmaz(), sigmay()])
     >>> result.expect # doctest: +NORMALIZE_WHITESPACE
@@ -64,7 +64,7 @@ Adding operators to this list results in a larger output list returned by the fu
 The resulting list of expectation values can easily be visualized using matplotlib's plotting functions:
 
 .. plot::
-    :context:
+    :context: close-figs
 
     >>> H = 2*np.pi * 0.1 * sigmax()
     >>> psi0 = basis(2, 0)
@@ -173,7 +173,7 @@ operators ``[sigmaz(), sigmay()]`` to the fifth argument.
 
 
 .. plot::
-    :context:
+    :context: close-figs
 
     >>> times = np.linspace(0.0, 10.0, 100)
     >>> result = mesolve(H, psi0, times, [np.sqrt(0.05) * sigmax()], e_ops=[sigmaz(), sigmay()])
@@ -207,3 +207,8 @@ Now a slightly more complex example: Consider a two-level atom coupled to a leak
     >>> plt.ylabel('Expectation values') # doctest: +SKIP
     >>> plt.legend(("cavity photon number", "atom excitation probability")) # doctest: +SKIP
     >>> plt.show() # doctest: +SKIP
+
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index ce05c5e912..9362bffa92 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -69,7 +69,7 @@ function for master-equation evolution, except that the initial state must be a
 To illustrate the use of the Monte Carlo evolution of quantum systems in QuTiP, let's again consider the case of a two-level atom coupled to a leaky cavity. The only differences to the master-equation treatment is that in this case we invoke the :func:`qutip.mcsolve` function instead of :func:`qutip.mesolve`
 
 .. plot::
-    :context:
+    :context: reset
 
     from qutip.solver.mcsolve import MCSolver, mcsolve
 
@@ -235,3 +235,8 @@ For example, the following code block plots expectation values for 1, 10 and 100
     plt.ylabel('Expectation values')
     plt.legend()
     plt.show()
+
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-stochastic.rst b/doc/guide/dynamics/dynamics-stochastic.rst
index 890a27457b..10ea5aad56 100644
--- a/doc/guide/dynamics/dynamics-stochastic.rst
+++ b/doc/guide/dynamics/dynamics-stochastic.rst
@@ -122,7 +122,7 @@ Below, we solve the dynamics for an optical cavity at 0K whose output is monitor
 where :math:`x` is the operator passed using ``m_ops``. The results are available in ``result.measurements``.
 
 .. plot::
-    :context: close-figs
+    :context: reset
 
     import numpy as np
     import matplotlib.pyplot as plt
@@ -164,3 +164,8 @@ where :math:`x` is the operator passed using ``m_ops``. The results are availabl
 
 
 For other examples on :func:`qutip.stochastic.smesolve`, see the `following notebook <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/development/development-smesolve-tests.ipynb>`_, as well as these notebooks available at `QuTiP Tutorials page <https://qutip.org/tutorials.html>`_: `heterodyne detection <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/examples/smesolve-heterodyne.ipynb>`_, `inneficient detection <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/examples/smesolve-inefficient-detection.ipynb>`_, and `feedback control <https://nbviewer.ipython.org/github/jrjohansson/reproduced-papers/blob/master/Reproduce-SIAM-JCO-46-445-2007-Mirrahimi.ipynb>`_.
+
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-time.rst b/doc/guide/dynamics/dynamics-time.rst
index 8902d2b94d..6be4dc5154 100644
--- a/doc/guide/dynamics/dynamics-time.rst
+++ b/doc/guide/dynamics/dynamics-time.rst
@@ -73,7 +73,7 @@ As an example, we will look at a case with a time-dependent Hamiltonian of the f
 The following code sets up the problem
 
 .. plot::
-    :context: close-figs
+    :context: reset
 
     ustate = basis(3, 0)
     excited = basis(3, 1)
@@ -107,7 +107,7 @@ The following code sets up the problem
 Given that we have a single time-dependent Hamiltonian term, and constant collapse terms, we need to specify a single Python function for the coefficient :math:`f(t)`.  In this case, one can simply do
 
 .. plot::
-    :context:
+    :context: close-figs
     :nofigs:
 
     def H1_coeff(t):
@@ -435,3 +435,8 @@ Accessing the state from solver
 ===============================
 
 In QuTiP 4.4 to 4.7, it was possible to request that the solver pass the state, expectation values or collapse operators via arguments to :class:`QobjEvo`. Support for this is not yet available in QuTiP 5.
+
+.. plot::
+    :context: reset
+    :include-source: false
+    :nofigs:
\ No newline at end of file

From 97204d6b166e91ac76f8dee7b6ba9833720b1b05 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 12 Feb 2023 17:31:21 +0100
Subject: [PATCH 065/602] Remove epub format because it is failing currently.

---
 .readthedocs.yaml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 621860399e..c5e1295754 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -5,7 +5,6 @@
 version: 2
 
 formats:
-  - epub
   - pdf
 
 build:

From 306e0aea7d77ba8e6bd1bce7befcaeda3dce80d6 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 12 Feb 2023 17:56:53 +0100
Subject: [PATCH 066/602] Fix header in HEOM Bosonic Environments guide.

---
 doc/guide/heom/bosonic.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/heom/bosonic.rst b/doc/guide/heom/bosonic.rst
index 3ca3b6e1df..48856a1187 100644
--- a/doc/guide/heom/bosonic.rst
+++ b/doc/guide/heom/bosonic.rst
@@ -1,4 +1,4 @@
-solver.heom####################
+####################
 Bosonic Environments
 ####################
 

From 6e4a67f71a2ff6974c89a4b70cc02e827eed63a3 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Feb 2023 13:16:42 +0100
Subject: [PATCH 067/602] Fix formatting of quotes around qutip-jax in
 changelog for 5.0.0.

---
 doc/changelog.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/changelog.rst b/doc/changelog.rst
index 071f1e5de9..318c2ec86b 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -63,7 +63,7 @@ significantly to test the data layer API:
 - ``qutip-tensorflow``: a TensorFlow backend by Asier Galicia (`<https://github.com/qutip/qutip-tensorflow>`)
 - ``qutip-cupy``: a CuPy GPU backend by Felipe Bivort Haiek (`<https://github.com/qutip/qutip-cupy/>`)`
 - ``qutip-tensornetwork``: a TensorNetwork backend by Asier Galicia (`<https://github.com/qutip/qutip-tensornetwork>`)
-- ``qutip-jax```: a JAX backend by Eric Giguère (`<https://github.com/qutip/qutip-jax/>`)
+- ``qutip-jax``: a JAX backend by Eric Giguère (`<https://github.com/qutip/qutip-jax/>`)
 
 We have also had many other contributors, whose specific contributions are
 detailed below:

From a4eb6331276af48023cdd893ed85c763a258a143 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Feb 2023 13:57:03 +0100
Subject: [PATCH 068/602] Remove extra blank line.

---
 qutip/solver/heom/bofin_baths.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
index 4d6f84a1d7..6653a40e75 100644
--- a/qutip/solver/heom/bofin_baths.py
+++ b/qutip/solver/heom/bofin_baths.py
@@ -123,7 +123,6 @@ def _check_sigma_bar_k_offset(self, type, offset):
     def _type_is_fermionic(self, type):
         return type in (self.types["+"], self.types["-"])
 
-
     def __init__(
             self, type, dim, Q, ck, vk, ck2=None,
             sigma_bar_k_offset=None, tag=None,

From 8608116e99b96f19d60c55ce0f49e469584f5725 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Feb 2023 14:01:47 +0100
Subject: [PATCH 069/602] Document new .fermionic attribute of BathExponent.

---
 qutip/solver/heom/bofin_baths.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
index 6653a40e75..ff64dfc610 100644
--- a/qutip/solver/heom/bofin_baths.py
+++ b/qutip/solver/heom/bofin_baths.py
@@ -91,8 +91,11 @@ class BathExponent:
 
     Attributes
     ----------
+    fermionic : bool
+        True if the type of the exponent is a Fermionic type (i.e. either
+        "+" or "-") and False otherwise.
 
-    All of the parameters are available as attributes.
+    All of the parameters are also available as attributes.
     """
     types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
 

From 62eff18b6949d286fffd65d880c00c3d5b76c33d Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Feb 2023 14:22:45 +0100
Subject: [PATCH 070/602] Simplify checks for fermionic and bosonic types and
 fix formatting errors.

---
 qutip/solver/heom/bofin_solvers.py | 45 +++++-------------------------
 1 file changed, 7 insertions(+), 38 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index b029dea9aa..1af2c5eac9 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -504,13 +504,6 @@ def heomsolve(
           Maximum lenght of one internal step. When using pulses, it should be
           less than half the width of the thinnest pulse.
 
-
-
-
-
-
-
-
     Returns
     -------
     :class:`~HEOMResult`
@@ -688,14 +681,6 @@ def _combine_bath_exponents(self, bath):
             exponents = []
             for b in bath:
                 exponents.extend(b.exponents)
-        all_bosonic = all(
-            exp.type in (exp.types.R, exp.types.I, exp.types.RI)
-            for exp in exponents
-        )
-        all_fermionic = all(
-            exp.type in (exp.types["+"], exp.types["-"])
-            for exp in exponents
-        )
         if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
             raise ValueError(
                 "All bath exponents must have system coupling operators"
@@ -716,18 +701,10 @@ def _grad_n(self, L, he_n):
 
     def _grad_prev(self, he_n, k):
         """ Get the previous gradient. """
-        if self.ados.exponents[k].type in (
-                BathExponent.types.R, BathExponent.types.I,
-                BathExponent.types.RI
-        ):
-            return self._grad_prev_bosonic(he_n, k)
-        elif self.ados.exponents[k].type in (
-                BathExponent.types["+"], BathExponent.types["-"]
-        ):
+        if self.ados.exponents[k].fermionic:
             return self._grad_prev_fermionic(he_n, k)
         else:
-            raise ValueError(
-                f"Mode {k} has unsupported type {self.ados.exponents[k].type}")
+            return self._grad_prev_bosonic(he_n, k)
 
     def _grad_prev_bosonic(self, he_n, k):
         if self.ados.exponents[k].type == BathExponent.types.R:
@@ -797,18 +774,10 @@ def _grad_prev_fermionic(self, he_n, k):
 
     def _grad_next(self, he_n, k):
         """ Get the previous gradient. """
-        if self.ados.exponents[k].type in (
-                BathExponent.types.R, BathExponent.types.I,
-                BathExponent.types.RI
-        ):
-            return self._grad_next_bosonic(he_n, k)
-        elif self.ados.exponents[k].type in (
-                BathExponent.types["+"], BathExponent.types["-"]
-        ):
+        if self.ados.exponents[k].fermionic:
             return self._grad_next_fermionic(he_n, k)
         else:
-            raise ValueError(
-                f"Mode {k} has unsupported type {self.ados.exponents[k].type}")
+            return self._grad_next_bosonic(he_n, k)
 
     def _grad_next_bosonic(self, he_n, k):
         op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
@@ -1154,8 +1123,8 @@ def options(self):
 
         state_data_type: str, default="dense"
             Name of the data type of the state used during the ODE evolution.
-            Use an empty string to keep the input state type. Many integrator can
-            only work with `Dense`.
+            Use an empty string to keep the input state type. Many integrators
+            support only work with `Dense`.
 
         store_ados : bool, default=False
             Whether or not to store the HEOM ADOs. Only relevant when using
@@ -1308,7 +1277,7 @@ def add_op(self, row_he, col_he, op):
         )
 
     def gather(self):
-        """ Create the HEOM liouvillian from a sorted list of smaller (fast) CSR
+        """ Create the HEOM liouvillian from a sorted list of smaller sparse
             matrices.
 
             .. note::

From c67a010526a5da96dca3e461f114eb07442b47aa Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Feb 2023 14:23:42 +0100
Subject: [PATCH 071/602] Add simple test for creating a HEOM solver with mixed
 bosonic and fermionic exponent types and fix PEP8 issues.

---
 qutip/tests/solver/heom/test_bofin_solvers.py | 45 ++++++++++++-------
 1 file changed, 30 insertions(+), 15 deletions(-)

diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index 27db82ac31..aa77072abe 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -52,7 +52,7 @@ def assert_raises_steady_state_time_dependent(hsolver):
         a time-dependent Hamiltonian raises the appropriate exception.
     """
     with pytest.raises(ValueError) as err:
-       hsolver.steady_state()
+        hsolver.steady_state()
     assert str(err.value) == (
        "A steady state cannot be determined for a time-dependent"
        " system"
@@ -229,7 +229,8 @@ def test_extract(self):
 
 
 class DrudeLorentzPureDephasingModel:
-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM solver.
+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+        solver.
     """
     def __init__(self, lam, gamma, T, Nk):
         self.lam = lam
@@ -266,7 +267,8 @@ def _integrand(omega, t):
         ]
 
     def bath_coefficients(self):
-        """ Correlation function expansion coefficients for the Drude-Lorentz bath.
+        """ Correlation function expansion coefficients for the Drude-Lorentz
+            bath.
         """
         lam, gamma, T = self.lam, self.gamma, self.T
         Nk = self.Nk
@@ -284,7 +286,8 @@ def bath_coefficients(self):
 
 
 class UnderdampedPureDephasingModel:
-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM solver.
+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+        solver.
     """
     def __init__(self, lam,  gamma, w0, T, Nk):
         self.lam = lam
@@ -541,14 +544,27 @@ def test_create_fermionic(self):
         assert hsolver.ados.exponents == exponents * 3
         assert hsolver.ados.max_depth == 2
 
-    def test_create_bath_errors(self):
+    def test_create_mixed_bosonic_and_fermionic(self):
         Q = sigmaz()
         H = sigmax()
-        mixed_types = [
+        exponents = [
             BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
             BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
             BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
         ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_bath_errors(self):
+        Q = sigmaz()
+        H = sigmax()
         mixed_q_dims = [
             BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
             BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
@@ -659,7 +675,6 @@ def test_pure_dephasing_model_bosonic_bath(
         else:
             assert_raises_steady_state_time_dependent(hsolver)
 
-
     @pytest.mark.parametrize(['terminator'], [
         pytest.param(True, id="terminator"),
         pytest.param(False, id="noterminator"),
@@ -767,7 +782,6 @@ def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
         else:
             assert_raises_steady_state_time_dependent(hsolver)
 
-
     @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
         pytest.param(LorentzianBath, 0.001101, id="matsubara"),
         pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
@@ -805,7 +819,6 @@ def test_discrete_level_model_lorentzian_baths(
         # analytic_current = dlm.analytic_current()
         np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
 
-
     @pytest.mark.parametrize(['evo'], [
         pytest.param("qobj"),
         pytest.param("qobjevo_const"),
@@ -838,7 +851,9 @@ def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
         # the interaction between the system and the fermionic bath:
         eps = [1e-10] * 5
         bosonic_Q = sigmax()
-        bosonic_bath = BosonicBath(bosonic_Q, eps, eps, eps, eps, combine=False)
+        bosonic_bath = BosonicBath(
+            bosonic_Q, eps, eps, eps, eps, combine=False,
+        )
         # for a single impurity we converge with max_depth = 2
         # we specify the bosonic bath first to ensure that the test checks
         # that the sums inside HEOMSolver grad-next/prev work when the bosonic
@@ -861,8 +876,6 @@ def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
         else:
             assert_raises_steady_state_time_dependent(hsolver)
 
-
-
     @pytest.mark.parametrize(['ado_format'], [
         pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
         pytest.param("numpy", id="numpy"),
@@ -972,8 +985,8 @@ def test_heomsolve_with_pure_dephasing_model(
         options = {"nsteps": 15000, "store_states": True}
 
         e_ops = {
-            "11": basis(2,0) * basis(2,0).dag(),
-            "22": basis(2,1) * basis(2,1).dag(),
+            "11": basis(2, 0) * basis(2, 0).dag(),
+            "22": basis(2, 1) * basis(2, 1).dag(),
         }
 
         tlist = np.linspace(0, 10, 21)
@@ -1003,7 +1016,9 @@ class TestHSolverDL:
         pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
         pytest.param("listevo_const", True, id="listevo-const-combined"),
         pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
-        pytest.param("qobjevo_timedep", False, id="qobjevo-timedep-uncombined"),
+        pytest.param(
+            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
+        ),
     ])
     @pytest.mark.parametrize(['liouvillianize'], [
         pytest.param(False, id="hamiltonian"),

From 3254bada85cbcef89f6c17a45a76cd59327a091e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Feb 2023 15:18:55 +0100
Subject: [PATCH 072/602] Update documentation to reflect that mixtures of
 bosonic and fermionic baths are supported.

---
 doc/guide/heom/history.rst | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/doc/guide/heom/history.rst b/doc/guide/heom/history.rst
index 1328a1e949..dedcdf4922 100644
--- a/doc/guide/heom/history.rst
+++ b/doc/guide/heom/history.rst
@@ -46,12 +46,12 @@ at https://github.com/tehruhn/bofin/tree/main/examples.
 Current implementation
 ----------------------
 
-The current implementation is a rewrite of BoFiN in pure Python. It's
-right-hand side construction has similar speed to BoFiN-fast, but is written
-in pure Python. Built-in implementations of a variety of different baths
-are provided, and a single solver is used for both fermionic and bosonic baths.
-Multiple baths of the same kind (either fermionic or bosonic) may be
-specified in a single problem, and there is good support for working with
-the auxiliary density operator (ADO) state and extracting information from it.
+The current implementation is a rewrite of BoFiN in pure Python. It's right-hand
+side construction has similar speed to BoFiN-fast, but is written in pure
+Python. Built-in implementations of a variety of different baths are provided,
+and a single solver is used for both fermionic and bosonic baths. Multiple baths
+of either the same kind, or a mixture of fermionic and bosonic baths, may be
+specified in a single problem, and there is good support for working with the
+auxiliary density operator (ADO) state and extracting information from it.
 
 The code was written by Neill Lambert and Simon Cross.

From 67b8b241c23b9975a028d35888688bb30726302a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Mon, 13 Feb 2023 15:39:54 -0500
Subject: [PATCH 073/602] Test svd sign independant

---
 qutip/tests/core/data/test_linalg.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index 01681d4e23..50729bba9c 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -104,8 +104,14 @@ def test_mathematically_correct_svd(self, shape):
         only_S = _data.svd(matrix, False)
 
         assert sum(test_S > 1e-10) == 6
-        np.testing.assert_allclose(test_U.to_array(), u, atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(test_V.to_array(), v, atol=1e-7, rtol=1e-7)
+        # columns are definied up to a sign
+        np.testing.assert_allclose(
+            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
+        )
+        # rows are definied up to a sign
+        np.testing.assert_allclose(
+            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
+        )
         np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
         np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
 

From 908756f359ff2ba06852e0ac3921be1f55e4aa95 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 14 Feb 2023 10:50:10 +0100
Subject: [PATCH 074/602] Add links and badges for Read the Docs.

---
 README.md | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 19a901e5da..4bd0de39da 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ and [J. R. Johansson](https://github.com/jrjohansson)
 [![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
 [![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
 [![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
-[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)  
+[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 [![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
 [![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
 
@@ -86,12 +86,18 @@ This version should be fully working. If you find any bugs, confusing documentat
 Documentation
 -------------
 
+[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
+[![Documentation Status - Master](https://readthedocs.org/projects/qutip/badge/?version=master)](https://qutip.readthedocs.io/en/latest/?badge=master)
+
+The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
+
 The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
+
 The latest development documentation is available in this repository in the `doc` folder.
 
 A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
-These are stored in the [qutip/qutip-notebooks repository](https://github.com/qutip/qutip-notebooks) here on GitHub.
-You can run the notebooks online using myBinder: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/qutip/qutip-notebooks/master?filepath=index.ipynb)
+These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
+
 
 Contribute
 ----------

From 84d7a9888d6d7fc58f063fe6c74a6eff09317504 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 14 Feb 2023 10:56:21 +0100
Subject: [PATCH 075/602] Remove second docs badge -- it is just confusing
 because the image is identical for both.

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 4bd0de39da..376e25b3a8 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,6 @@ Documentation
 -------------
 
 [![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
-[![Documentation Status - Master](https://readthedocs.org/projects/qutip/badge/?version=master)](https://qutip.readthedocs.io/en/latest/?badge=master)
 
 The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
 

From 0426f8a0da322700df3fa89f29b80d8e89666794 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 14 Feb 2023 13:10:01 -0500
Subject: [PATCH 076/602] Fix requirement

---
 qutip/tests/test_bloch.py | 11 +++++------
 setup.cfg                 |  4 ++++
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/qutip/tests/test_bloch.py b/qutip/tests/test_bloch.py
index f736090c2e..33e8fb2fae 100644
--- a/qutip/tests/test_bloch.py
+++ b/qutip/tests/test_bloch.py
@@ -9,14 +9,11 @@
 try:
     import matplotlib.pyplot as plt
     from matplotlib.testing.decorators import check_figures_equal
+    import IPython
+    check_pngs_equal = check_figures_equal(extensions=["png"])
 except ImportError:
-    def check_figures_equal(*args, **kw):
-        def _error(*args, **kw):
-            raise RuntimeError("matplotlib is not installed")
     plt = None
-
-
-check_pngs_equal = check_figures_equal(extensions=["png"])
+    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
 
 
 class RefBloch(Bloch):
@@ -474,6 +471,8 @@ def test_vector_errors_color_length(self, vectors, colors):
 
 
 def test_repr_svg():
+    pytest.importorskip("matplotlib")
+    pytest.importorskip("ipython")
     svg = Bloch()._repr_svg_()
     assert isinstance(svg, str)
     assert svg.startswith("<?xml")
diff --git a/setup.cfg b/setup.cfg
index f03112d113..70ee4ea220 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -56,6 +56,9 @@ tests =
     pytest-rerunfailures
 ipython =
     ipython
+extra =
+    loky
+    tqdm
 ; This uses ConfigParser's string interpolation to include all the above
 ; dependencies into one single target, convenient for testing full builds.
 full =
@@ -64,3 +67,4 @@ full =
     %(semidefinite)s
     %(tests)s
     %(ipython)s
+    %(extra)s

From df41b938a3f0eb9d376cfb16af897aae77c97821 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 14 Feb 2023 19:26:40 -0500
Subject: [PATCH 077/602] working tests

---
 qutip/core/data/matmul.pyx                   |  3 +-
 qutip/solver/sode/_sode.pyx                  |  5 +-
 qutip/solver/sode/check.py                   | 32 ----------
 qutip/solver/sode/ssystem.pyx                | 14 ++--
 qutip/tests/solver/test_sode_method.py       | 67 ++++++++++++++++++++
 qutip/tests/solver/test_stochastic_system.py | 29 ++++++---
 6 files changed, 99 insertions(+), 51 deletions(-)
 delete mode 100644 qutip/solver/sode/check.py
 create mode 100644 qutip/tests/solver/test_sode_method.py

diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 0accc05286..9429a05f37 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -196,7 +196,8 @@ cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
             "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
             + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
         )
-        warnings.warn(msg, dense.OrderEfficiencyWarning)
+        from qutip.core.data.dense import OrderEfficiencyWarning
+        warnings.warn(msg, OrderEfficiencyWarning)
         # Rather than making loads of copies of the same code, we just moan at
         # the user and then transpose one of the arrays.  We prefer to have
         # `right` in Fortran-order for cache efficiency.
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 470db90392..34665961ec 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -16,7 +16,10 @@ cdef class Euler:
         self.system = system
 
     @cython.wraparound(False)
-    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
+    def run(
+        self, double t, Data state, double dt,
+        double[:, :, ::1] dW, int ntraj
+    ):
         cdef int i
         cdef Dense out
         for i in range(ntraj):
diff --git a/qutip/solver/sode/check.py b/qutip/solver/sode/check.py
deleted file mode 100644
index 39193220a8..0000000000
--- a/qutip/solver/sode/check.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import numpy as np
-from itertools import product
-from qutip.core import data as _data
-import qutip
-
-def compute_step(system, method, state, ts, noise, **kw):
-    import qutip.solver.sode._sode as _sode
-    stepper = getattr(_sode, method)(system, **kw)
-    out = []
-    for t in ts:
-        out.append(stepper.run(0, state.copy(), t, noise.dW(t), 1))
-    return out
-
-
-def get_error_order(system, method):
-    num_runs = 10
-    ts = [
-        0.000001, 0.000002, 0.000005, 0.00001, 0.00002,  0.00005,
-        0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1,
-    ]
-    state = rand_ket(system.dims[0]).data
-    err = np.zeros(len(ts), dtype=float)
-    for _ in range(num_runs):
-        noise = MultiNoise(0.1, 0.000001)
-        out = compute_step(system, method, state, ts, noise)
-
-        for i, (o, t) in enumerate(zip(out, ts)):
-            got = o.to_array()[0,0]
-            target = system.analytic(t, noise.dw(t)[0,0])
-            err[i] += (np.abs(got - target))
-    err /= num_runs
-    return np.polyfit(np.log(ts), np.log(err), 1)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 8fb42a68f9..4a7b29502a 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -189,14 +189,14 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         for i in range(self.num_collapse):
             c_op = self.c_ops[i]
             vec = c_op.matmul_data(t, state)
-            expect = _data.trace_oper_ket_dense(vec)
+            expect = _data.trace_oper_ket(vec)
             out.append(_data.add(vec, state, -expect))
         return out
 
     cpdef void set_state(self, double t, Data state):
         cdef n, l
         self.t = t
-        self.state = _data.to(_data.Dense, state)
+        self.state = _data.to(_data.Dense, state).reorder(fortran=1)
         self._a_set = False
         self._b_set = False
         self._Lb_set = False
@@ -471,10 +471,10 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
 
     def analytic(self, t, W):
         """
-        Analytic solution, H and all c_ops must commute.
+        Analytic solution, H and all c_ops must commute and are constant.
         """
-        out = self.H.full() * t
+        out = self.H(0) * t
         for i in range(self.num_collapse):
-            out += self.c_ops[i].full() * W[i]
-            out -= 0.5 * self.c_ops[i].full() @ self.c_ops[i].full() * t
-        return np.exp(out)
+            out += self.c_ops[i](0) * W[i]
+            out -= 0.5 * self.c_ops[i](0) @ self.c_ops[i](0) * t
+        return out.expm().data
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
new file mode 100644
index 0000000000..5d3436d08a
--- /dev/null
+++ b/qutip/tests/solver/test_sode_method.py
@@ -0,0 +1,67 @@
+import numpy as np
+from itertools import product
+from qutip.core import data as _data
+from qutip import qeye, destroy, QobjEvo, rand_ket
+import qutip.solver.sode._sode as _sode
+import pytest
+from qutip.solver.sode.ssystem import SimpleStochasticSystem
+from qutip.solver.sode.ito import MultiNoise
+
+
+def get_error_order(system, state, method, plot=False, **kw):
+    stepper = getattr(_sode, method)(system, **kw)
+    num_runs = 10
+    ts = [
+        0.000001, 0.000002, 0.000005, 0.00001, 0.00002,  0.00005,
+        0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1,
+    ]
+    # state = rand_ket(system.dims[0]).data
+    err = np.zeros(len(ts), dtype=float)
+    for _ in range(num_runs):
+        noise = MultiNoise(0.1, 0.000001, system.num_collapse)
+        for i, t in enumerate(ts):
+            out = stepper.run(0, state.copy(), t, noise.dW(t), 1)
+            target = system.analytic(t, noise.dw(t)[0]) @ state
+            err[i] += _data.norm.l2(out - target)
+
+    err /= num_runs
+    if plot:
+        import matplotlib.pyplot as plt
+        plt.loglog(ts, err)
+    return np.polyfit(np.log(ts), np.log(err), 1)[0]
+
+
+def _make_oper(kind, N):
+    if kind == "qeye":
+        out = qeye(N) * np.random.rand()
+    elif kind == "destroy":
+        out = destroy(N) * np.random.rand()
+    elif kind == "destroy2":
+        out = destroy(N)**2 * np.random.rand()
+    return QobjEvo(out)
+
+
+@pytest.mark.parametrize(["method", "order", "kw"], [
+    pytest.param("Euler", 0.5, {}, id="Euler"),
+    pytest.param("Milstein", 1.0, {}, id="Milstein"),
+    pytest.param("Platen", 1.0, {}, id="Platen"),
+    pytest.param("PredCorr", 1.0, {}, id="PredCorr"),
+    pytest.param("PredCorr", 1.0, {"alpha": 0.5}, id="PredCorr_0.5"),
+    pytest.param("Taylor15", 1.5, {}, id="Taylor15"),
+    pytest.param("Explicit15", 1.5, {}, id="Explicit15"),
+])
+@pytest.mark.parametrize(['H', 'c_ops'], [
+    pytest.param("qeye", ["destroy"], id='simple'),
+    pytest.param("destroy", ["destroy"], id='simple'),
+    pytest.param("qeye", ["qeye", "destroy", "destroy2"], id='2 c_ops'),
+])
+def test_methods(H, c_ops, method, order, kw):
+    N = 5
+    H = _make_oper(H, N)
+    c_ops = [_make_oper(op, N) for op in c_ops]
+    system = SimpleStochasticSystem(H, c_ops)
+    state = rand_ket(N).data
+    error_order = get_error_order(system, state, method, **kw)
+    # The first error term of the method is dt**0.5 greater than the solver
+    # order.
+    assert (order + 0.35) < error_order
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index 4925ec043f..455e2fd35d 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -1,8 +1,12 @@
 import numpy as np
-from qutip import qeye, num, destroy, create, QobjEvo, basis, rand_herm
+from qutip import (
+    qeye, num, destroy, create, QobjEvo,
+    basis, rand_herm, fock_dm, liouvillian, operator_to_vector
+)
 from qutip.solver.sode.ssystem import *
-import qutip.data as _data
+import qutip.core.data as _data
 import pytest
+from itertools import product
 
 
 def L0(system, f):
@@ -89,12 +93,15 @@ def _check_equivalence(f, target, args):
     Check that the error is proportional to `dt`.
     """
     dts = np.logspace(-5, -1, 9)
-    errors_dt = [
-        _data.norm.l2(f(*args, dt=dt) - target) / dt
+    errors_dt = np.array([
+        _data.norm.l2(f(*args, dt=dt) - target)
         for dt in dts
-    ]
-    poly = np.polyfit(dts, errors_dt, 1)
-    return -1 < poly[0] < 1
+    ])
+    poly = np.polyfit(np.log(dts), np.log(errors_dt+1e-16), 1)[0]
+    if poly > 1.05:
+        print(poly, np.log(errors_dt))
+        print(dts, errors_dt)
+    return poly < 1.05
 
 
 def _run_derr_check(solver, state):
@@ -106,7 +113,7 @@ def _run_derr_check(solver, state):
     a = solver.drift
     solver.set_state(t, state)
 
-    assert solver.drift(t, state) == solver.a()
+    assert _data.norm.l2(solver.drift(t, state) - solver.a()) < 1e-6
     assert _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
 
     for i in range(N):
@@ -150,7 +157,7 @@ def _make_oper(kind, N):
     pytest.param("qeye", ["td"], id='c_ops td'),
     pytest.param("rand", ["rand"], id='random'),
 ])
-@pytest.mark.parametrize('type', ["sse", "sme"])
+@pytest.mark.parametrize('type', ["sme"]) # "sse"
 @pytest.mark.parametrize('heterodyne', [False, True])
 def test_system(H, c_ops, type, heterodyne):
     N = 5
@@ -158,7 +165,9 @@ def test_system(H, c_ops, type, heterodyne):
     c_ops = [_make_oper(op, N) for op in c_ops]
     if type == "sse":
         system = StochasticClosedSystem(H, c_ops, heterodyne)
+        state = basis(N, N-2).data
     else:
+        H = liouvillian(H)
         system = StochasticOpenSystem(H, c_ops, heterodyne)
-    state = basis(N, N-2).data
+        state = operator_to_vector(fock_dm(N, N-2)).data
     _run_derr_check(system, state)

From e36536a82bffcd76823a6f4c21bbcfff98f74199 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 15 Feb 2023 10:04:02 -0500
Subject: [PATCH 078/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 setup.cfg | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/setup.cfg b/setup.cfg
index 70ee4ea220..1eb1f11cd2 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -56,7 +56,7 @@ tests =
     pytest-rerunfailures
 ipython =
     ipython
-extra =
+extras =
     loky
     tqdm
 ; This uses ConfigParser's string interpolation to include all the above
@@ -67,4 +67,4 @@ full =
     %(semidefinite)s
     %(tests)s
     %(ipython)s
-    %(extra)s
+    %(extras)s

From 6663bc8d33f5c1b275201625973cfaf3c6f892c5 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 15 Feb 2023 19:29:59 +0100
Subject: [PATCH 079/602] Add a HEOM test for combined bosonic and fermionic
 baths using a system consisting of a spin, discrete level fermionic leads,
 and a damped bosonic mode.

---
 qutip/tests/solver/heom/test_bofin_solvers.py | 193 ++++++++++++++++--
 1 file changed, 180 insertions(+), 13 deletions(-)

diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index aa77072abe..c168070da9 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -8,7 +8,7 @@
 from scipy.integrate import quad
 
 from qutip import (
-    basis, destroy, expect, liouvillian, sigmax, sigmaz,
+    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
     tensor, Qobj, QobjEvo
 )
 from qutip.core import data as _data
@@ -327,29 +327,89 @@ def _integrand(omega, t):
         ]
 
 
+class BosonicMode:
+    """ A description of a bosonic mode for inclusion in a
+        DiscreteLevelCurrentModel.
+    """
+    def __init__(self, N, Lambda, Omega, gamma_b):
+        self.N = N
+        self.Lambda = Lambda
+        self.Omega = Omega
+        self.gamma_b = gamma_b
+
+    def bath_coefficients(self):
+        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
+        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
+
+        ck_imag = [
+            -1.0j * self.Omega + self.gamma_b / 2,
+            1.0j * self.Omega + self.gamma_b / 2,
+        ]
+        vk_imag = [
+            -1.0j * self.Omega + self.gamma_b / 2,
+            1.0j * self.Omega + self.gamma_b / 2,
+        ]
+        return ck_real, ck_imag, vk_real, vk_imag
+
+
 class DiscreteLevelCurrentModel:
     """ Analytic discrete level current model for testing the HEOM solver
-        with a fermionic bath.
+        with a fermionic bath (and optionally a bosonic mode).
     """
-    def __init__(self, gamma, W, T, lmax):
+    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
+        # single fermion
+        self.e1 = e1  # energy
+
+        # parameters for the fermionic leads
         self.gamma = gamma
         self.W = W
         self.T = T
         self.lmax = lmax  # Pade cut-off
         self.beta = 1. / T
+        self.theta = theta  # bias
 
-        # single fermion
-        self.e1 = 1.
-        d1 = destroy(2)
-        self.H = self.e1 * d1.dag() * d1
-        self.Q = d1
+        # bosonic_mode
+        self.bosonic_mode = bosonic_mode
 
-        # bias
-        self.theta = 2.
+        # Construct Hamiltonian and coupling operator
+        if self.bosonic_mode is None:
+            d1 = destroy(2)
+            self.H = self.e1 * d1.dag() @ d1
+            self.Q = d1
+            self._sys_occupation_op = d1.dag() @ d1
+        else:
+            d1 = destroy(2) & qeye(self.bosonic_mode.N)
+            a = qeye(2) & destroy(self.bosonic_mode.N)
+            self.H = (
+                self.e1 * d1.dag() @ d1 +
+                self.bosonic_mode.Omega * a.dag() @ a +
+                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
+            )
+            if self.bosonic_mode.gamma_b != 0:
+                # apply phenomenological damping:
+                self.H = liouvillian(
+                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
+                )
+            self.Q = d1
+            self._sys_occupation_op = d1.dag() @ d1
 
-    def rho(self):
-        """ Initial state. """
-        return 0.5 * Qobj(np.ones((2, 2)))
+    def rho(self, rho_fermion=None):
+        """ Return initial system density matrix given the density matrix for
+            the single Fermionic mode.
+        """
+        if rho_fermion is None:
+            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
+        elif rho_fermion.isket:
+            rho_fermion = rho_fermion.proj()
+        if self.bosonic_mode is None:
+            rho = rho_fermion
+        else:
+            bm0 = basis(self.bosonic_mode.N, 0)
+            rho = rho_fermion & (bm0 @ bm0.dag())
+        return rho
+
+    def sys_occupation(self, state):
+        return expect(state, self._sys_occupation_op)
 
     def state_current(self, ado_state, tags=None):
         level_1_aux = [
@@ -372,6 +432,12 @@ def exp_op(exp):
         )
 
     def analytic_current(self):
+        if self.bosonic_mode is not None:
+            raise RuntimeError(
+                "Analytic calculation of the current is not implemented in the"
+                " case where a bosonic mode is present."
+            )
+
         Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
         mu_l = self.theta / 2.
         mu_r = - self.theta / 2.
@@ -876,6 +942,107 @@ def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
         else:
             assert_raises_steady_state_time_dependent(hsolver)
 
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
+        self, evo, liouvillianize
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+        )
+        bosonic_mode = BosonicMode(
+            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
+        )
+
+        dlm_ref = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+            bosonic_mode=bosonic_mode,
+        )
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+
+        # First we construct a solver with the boson modelled as part of the
+        # system and only a single Fermionic bath. This will provide the
+        # reference result for the test:
+        fermionic_bath_ref = FermionicBath(
+            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
+        )
+
+        hsolver_ref = HEOMSolver(
+            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
+        )
+
+        # Then we construct a solver for the same system, but with the
+        # bosonic mode as a bath This is the result we would like to check:
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        fermionic_bath = FermionicBath(
+            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
+        )
+
+        bosonic_bath = BosonicBath(
+            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
+            combine=True, tag="bosonic",
+        )
+
+        hsolver = HEOMSolver(
+            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
+        )
+
+        # Calculate currents and occupations:
+        tlist = np.linspace(0, 1000, 300)
+        psi0 = basis(2, 0)
+
+        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
+        current_ref = [
+            dlm_ref.state_current(ado_state, tags=["fermionic"])
+            for ado_state in result_ref.ado_states
+        ]
+        sys_occupation_ref = dlm_ref.sys_occupation(
+            result_ref.states
+        )
+
+        result = hsolver.run(dlm.rho(psi0), tlist)
+        current = [
+            dlm.state_current(ado_state, tags=["fermionic"])
+            for ado_state in result.ado_states
+        ]
+        sys_occupation = dlm.sys_occupation(result.states)
+
+        np.testing.assert_allclose(current_ref, current, atol=1e-3)
+        np.testing.assert_allclose(
+            sys_occupation_ref, sys_occupation, atol=1e-3,
+        )
+
+        if evo != "qobjevo_timedep":
+            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
+            current_ss_ref = dlm_ref.state_current(ado_state_ref)
+            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
+
+            rho_final, ado_state = hsolver.steady_state()
+            current_ss = dlm.state_current(ado_state)
+            sys_occupation_ss = dlm.sys_occupation(rho_final)
+
+            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
+            np.testing.assert_allclose(
+                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
+            )
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
     @pytest.mark.parametrize(['ado_format'], [
         pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
         pytest.param("numpy", id="numpy"),

From 7f24ba4ce701dacf78e113e1e01f8fa38ffc3cc3 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 15 Feb 2023 17:26:55 -0500
Subject: [PATCH 080/602] smesolve work

---
 qutip/solver/__init__.py      |  1 +
 qutip/solver/mcsolve.py       |  2 +-
 qutip/solver/sode/__init__.py |  2 +
 qutip/solver/sode/_sode.pyx   | 11 ++--
 qutip/solver/sode/sode.py     | 29 +++++++----
 qutip/solver/sode/ssystem.pyx | 17 +-----
 qutip/solver/stochastic.py    | 97 +++++++++++++++++++++++++----------
 7 files changed, 100 insertions(+), 59 deletions(-)

diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
index 99d84ccd88..3ec68b68b5 100644
--- a/qutip/solver/__init__.py
+++ b/qutip/solver/__init__.py
@@ -16,3 +16,4 @@
 from .brmesolve import *
 from .krylovsolve import *
 from .parallel import *
+import qutip.solver.sode
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 4b78e095fd..74588f9d0d 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -225,7 +225,7 @@ def reset(self, hard=False):
 
     def _prob_func(self, state):
         if self.issuper:
-            return _data.trace_oper_ket(state)
+            return _data.trace_oper_ket(state).real()
         return _data.norm.l2(state)**2
 
     def _norm_func(self, state):
diff --git a/qutip/solver/sode/__init__.py b/qutip/solver/sode/__init__.py
index e69de29bb2..62d97d11f0 100644
--- a/qutip/solver/sode/__init__.py
+++ b/qutip/solver/sode/__init__.py
@@ -0,0 +1,2 @@
+from .sode import *
+from .ssystem import *
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 34665961ec..ffdb8bdbe8 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -21,11 +21,10 @@ cdef class Euler:
         double[:, :, ::1] dW, int ntraj
     ):
         cdef int i
-        cdef Dense out
+        cdef Data out
         for i in range(ntraj):
-            out = self.step(t, state, dt, dW[i, :, :])
-            state = out
-        return out
+            state = self.step(t, state, dt, dW[i, :, :])
+        return state
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
@@ -40,9 +39,9 @@ cdef class Euler:
         cdef int i
         cdef _StochasticSystem system = self.system
 
-        a = system.drift(t, state)
+        cdef Data a = system.drift(t, state)
         b = system.diffusion(t, state)
-        new_state = _data.add(state, a, dt)
+        cdef Data new_state = _data.add(state, a, dt)
         for i in range(system.num_collapse):
             new_state = _data.add(new_state, b[i], dW[i, 0])
         return new_state
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 088af4c1d3..ae9df83ebf 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -92,7 +92,7 @@ class _Explicit_Simple_Integrator(SIntegrator):
     """
     integrator_options = {
         "dt": 0.001,
-        "tol": 1e-7,
+        "tol": 1e-10,
     }
     stepper = None
     N_dw = 0
@@ -101,9 +101,6 @@ def __init__(self, system, options):
         self.system = system
         self._options = self.integrator_options.copy()
         self.options = options
-        self.dt = self.options["dt"]
-        self.tol = self.options["tol"]
-        self.N_drift = system.num_collapse
         self.step_func = self.stepper(self.system).run
 
     def set_state(self, t, state0, generator):
@@ -116,25 +113,25 @@ def integrate(self, t, copy=True):
         if delta_t < 0:
             raise ValueError("Stochastic integration time")
         elif delta_t == 0:
-            return self.t, self.state, np.zeros((0, self.N_drift, self.N_dw))
+            return self.t, self.state, np.zeros(self.N_dw)
 
-        dt = self.dt
+        dt = self.options["dt"]
         N, extra = np.divmod(delta_t, dt)
         N = int(N)
-        if extra > self.tol:
+        if extra > self.options["tol"]:
             # Not a whole number of steps.
             N += 1
             dt = delta_t / N
         dW = self.generator.normal(
             0,
             np.sqrt(dt),
-            size=(N, self.N_drift, self.N_dw)
+            size=(N, self.N_dw, self.N_dw)
         )
 
         self.state = self.step_func(self.t, self.state, dt, dW, N)
         self.t += dt * N
 
-        return self.t, self.state, np.sum(dW, axis=0) / (N * dt)
+        return self.t, self.state, np.sum(dW[:, :, 0], axis=0)
 
     def get_state(self, copy=True):
         return self.t, self.state, self.generator
@@ -239,9 +236,23 @@ class PredCorr_SODE(_Explicit_Simple_Integrator):
       (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
       ``'pc-euler-2'`` or ``'pred-corr-2'``
     """
+    integrator_options = {
+        "dt": 0.001,
+        "tol": 1e-10,
+        "alpha": 0.0,
+        "eta": 0.5,
+    }
     stepper = _sode.PredCorr
     N_dw = 1
 
+    def __init__(self, system, options):
+        self.system = system
+        self._options = self.integrator_options.copy()
+        self.options = options
+        self.step_func = self.stepper(
+            self.system, self.options["alpha"], self.options["eta"]
+        ).run
+
 
 StochasticSolver.add_integrator(EulerSODE, "euler")
 StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 4a7b29502a..bac884ec6d 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -11,7 +11,7 @@ import numpy as np
 from qutip.core import spre, spost, liouvillian
 
 __all__ = [
-    "GeneralStochasticSystem", "StochasticOpenSystem", "StochasticClosedSystem"
+    "StochasticOpenSystem", "StochasticClosedSystem"
 ]
 
 @cython.boundscheck(False)
@@ -81,21 +81,6 @@ cdef class _StochasticSystem:
         raise NotImplementedError
 
 
-cdef class GeneralStochasticSystem(_StochasticSystem):
-    cdef object d1, d2
-
-    def __init__(self, a, b):
-        self.d1 = a
-        self.d2 = b
-        self.num_collapse = 1
-
-    cpdef Data drift(self, t, Data state):
-        return self.d1(t, state)
-
-    cpdef list diffusion(self, t, Data state):
-        return self.d2(t, state)
-
-
 cdef class StochasticClosedSystem(_StochasticSystem):
     cdef QobjEvo H
     cdef list c_ops
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 1c7fba6eb6..5e798891f9 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -8,29 +8,47 @@
 
 
 class StochasticTrajResult(Result):
-    def _post_init(self, m_ops=()):
+    def _post_init(self, m_ops=(), dw_factor=()):
         super()._post_init()
         self.noise = []
         self.m_ops = m_ops
+        self.dW_factor = dw_factor
         self.measurements = [[] for _ in range(len(m_ops))]
 
     def _add_measurement(self, t, state, noise):
         expects = [m_op.expect(t, state) for m_op in self.m_ops]
         noises = np.sum(noise, axis=0)
-        for measure, expect, dW in zip(self.measurements, expects, noises):
-            measure.append(expect + dW)
+        print(self.measurements, expects, noises, self.dW_factor)
+        for measure, expect, dW, factor in zip(
+            self.measurements, expects, noises, self.dW_factor
+        ):
+            measure.append(expect + dW * factor)
 
     def add(self, t, state, noise):
         super().add(t, state)
+
         if noise is not None:
-            self._add_measurement(t, state, noise)
-        self.noise.append(noise)
+            self.noise.append(noise)
+            if self.options["store_measurement"]:
+                dt = self.times[-1] - self.times[-2]
+                self._add_measurement(t, state, noise / dt)
 
 
 class StochasticResult(MultiTrajResult):
-    @property
-    def measurement(self):
-        return []
+    def _reduce_expect(self, trajectory):
+        # Since measurements of each trajectories is kept, we keep only the
+        # array to save memory.
+        trajectory.measurements = np.array(trajectory.measurements)
+        if self.options["heterodyne"]:
+            shape = trajectory.measurements.shape
+            trajectory.measurements.reshape(-1, 2, shape[-1])
+        self.measurement.append(trajectory.measurements)
+
+    def _post_init(self):
+        super()._post_init()
+        self.measurement = []
+        if self.options['store_measurement']:
+            self.add_processor(self._reduce_measurements)
 
 
 def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
@@ -93,7 +111,6 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     return sol.run(rho0, tlist, ntraj, e_ops=e_ops)
 
 
-
 def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
              args={}, ntraj=500, options=None):
     """
@@ -153,6 +170,7 @@ class StochasticSolver(MultiTrajSolver):
     name = "StochasticSolver"
     resultclass = StochasticResult
     _avail_integrators = {}
+    system = None
     solver_options = {
         "progress_bar": "text",
         "progress_kwargs": {"chunk_size": 10},
@@ -166,45 +184,64 @@ class StochasticSolver(MultiTrajSolver):
         "num_cpus": None,
         "bitgenerator": None,
         "heterodyne": False,
+        "store_measurement": False,
+        "dw_factor": None,
     }
 
-    def __init__(self, H, sc_ops, heterodyne=False, *, options=None, m_ops=()):
-        self._options = self.solver_options.copy()
+    def __init__(self, H, sc_ops, *, options=None, m_ops=()):
         self.options = options
 
         if not isinstance(H, (Qobj, QobjEvo)):
             raise TypeError("...")
         H = QobjEvo(H)
-
         if isinstance(sc_ops, (Qobj, QobjEvo)):
             sc_ops = [sc_ops]
         sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
+
         if any(not c_op.isoper for c_op in sc_ops):
             raise TypeError("sc_ops must be operators")
 
-        if H.issuper:
-            rhs = StochasticOpenSystem(H, sc_ops, heterodyne)
-        else:
-            rhs = StochasticClosedSystem(H, sc_ops, heterodyne)
-
+        rhs = self._prep_system(H, sc_ops, self.options["heterodyne"])
         super().__init__(rhs, options=options)
 
-        if len(m_ops) == rhs.num_collapse:
-            self.m_ops = m_ops
-        elif heterodyne:
-            self.m_ops = []
-            for sc_op in sc_ops:
-                self.m_ops += [
-                    sc_op + sc_op.dag(), -1j * (sc_op - sc_op.dag())
-                ]
+        if self.options["store_measurement"]:
+            n_m_ops = len(sc_ops) * (1 + int(self.options["heterodyne"]))
+            dW_factor = self.options["dW_factor"]
+
+            if len(m_ops) == n_m_ops:
+                self.m_ops = m_ops
+            elif self.options["heterodyne"]:
+                self.m_ops = []
+                for op in sc_ops:
+                    self.m_ops += [
+                        op + op.dag(), -1j * (op - op.dag())
+                    ]
+                dW_factor = dW_factor or 2**0.5
+            else:
+                self.m_ops = [op + op.dag() for op in sc_ops]
+                dW_factor = dW_factor or 1.
+
+            if not isinstance(dW_factor, Iterable):
+                dW_factor = [dW_factor] * n_m_ops
+
+            if len(dW_factor) == len(sc_ops) and self.options["heterodyne"]:
+                dW_factor = [ i for i in dW_factor for _ in range(2) ]
+
+            if len(dW_factor) != n_m_ops:
+                raise ValueError("Bad dW_factor option")
+            self.dW_factors = dW_factor
+
         else:
-            self.m_ops = [sc_op + sc_op.dag() for sc_op in sc_ops]
+            self.m_ops = []
+            self.dW_factors = []
 
     def _run_one_traj(self, seed, state, tlist, e_ops):
         """
         Run one trajectory and return the result.
         """
-        result = StochasticTrajResult(e_ops, self.options, m_ops=self.m_ops)
+        result = StochasticTrajResult(
+            e_ops, self.options, m_ops=self.m_ops, dw_factor=self.dW_factors,
+        )
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
         state_t = self._restore_state(state, copy=False)
@@ -229,7 +266,13 @@ class SMESolver(StochasticSolver):
     name = "smesolve"
     _avail_integrators = {}
 
+    def _prep_system(self, L, sc_ops, heterodyne):
+        if not L.issuper:
+            L = liouvillian(L)
+        return StochasticOpenSystem(L, sc_ops, heterodyne)
+
 
 class SSESolver(StochasticSolver):
     name = "ssesolve"
     _avail_integrators = {}
+    _prep_system = StochasticClosedSystem

From 0a61ec52fddcb63f7b525ccd3fac0fb8ef72c337 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 16 Feb 2023 12:14:41 +0100
Subject: [PATCH 081/602] Switch bosonic and fermionic test tolerances to
 relative to better test small values.

---
 qutip/tests/solver/heom/test_bofin_solvers.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index c168070da9..72b737a91c 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -1022,9 +1022,9 @@ def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
         ]
         sys_occupation = dlm.sys_occupation(result.states)
 
-        np.testing.assert_allclose(current_ref, current, atol=1e-3)
+        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
         np.testing.assert_allclose(
-            sys_occupation_ref, sys_occupation, atol=1e-3,
+            sys_occupation_ref, sys_occupation, rtol=1e-3,
         )
 
         if evo != "qobjevo_timedep":

From 10b7aa95c5f95dd1d4f146b226e300b9a61429fc Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 16 Feb 2023 17:06:24 -0500
Subject: [PATCH 082/602] Passing test for smesolve

---
 qutip/solver/mcsolve.py                      |  4 +-
 qutip/solver/sode/sode.py                    |  6 +-
 qutip/solver/sode/ssystem.pyx                | 23 +++--
 qutip/solver/stochastic.py                   | 38 ++++++---
 qutip/tests/solver/test_stochastic.py        | 88 ++++++++++++++++++++
 qutip/tests/solver/test_stochastic_system.py | 23 ++---
 6 files changed, 146 insertions(+), 36 deletions(-)
 create mode 100644 qutip/tests/solver/test_stochastic.py

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 74588f9d0d..ed7adae017 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -225,12 +225,12 @@ def reset(self, hard=False):
 
     def _prob_func(self, state):
         if self.issuper:
-            return _data.trace_oper_ket(state).real()
+            return _data.trace_oper_ket(state).real
         return _data.norm.l2(state)**2
 
     def _norm_func(self, state):
         if self.issuper:
-            return _data.trace_oper_ket(state)
+            return _data.trace_oper_ket(state).real
         return _data.norm.l2(state)
 
     def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index ae9df83ebf..8e498d1630 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -97,8 +97,8 @@ class _Explicit_Simple_Integrator(SIntegrator):
     stepper = None
     N_dw = 0
 
-    def __init__(self, system, options):
-        self.system = system
+    def __init__(self, rhs, options):
+        self.system = rhs
         self._options = self.integrator_options.copy()
         self.options = options
         self.step_func = self.stepper(self.system).run
@@ -125,7 +125,7 @@ def integrate(self, t, copy=True):
         dW = self.generator.normal(
             0,
             np.sqrt(dt),
-            size=(N, self.N_dw, self.N_dw)
+            size=(N, self.system.num_collapse, self.N_dw)
         )
 
         self.state = self.step_func(self.t, self.state, dt, dW, N)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index bac884ec6d..7250c8779b 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -86,18 +86,18 @@ cdef class StochasticClosedSystem(_StochasticSystem):
     cdef list c_ops
     cdef list cpcd_ops
 
-    def __init__(self, H, c_ops, heterodyne):
+    def __init__(self, H, sc_ops, heterodyne=False):
         self.H = -1j * H
         if heterodyne:
             self.c_ops = []
-            for c_op in c_ops:
+            for c_op in sc_ops:
                 self.c_ops.append(c_op / np.sqrt(2))
                 self.c_ops.append(c_op * (-1j / np.sqrt(2)))
                 self.cpcd_ops.append((c_op + c_op.dag()) / np.sqrt(2))
                 self.cpcd_ops.append((-c_op + c_op.dag()) * 1j / np.sqrt(2))
         else:
-            self.c_ops = c_ops
-            self.cpcd_ops = [op + op.dag() for op in c_ops]
+            self.c_ops = sc_ops
+            self.cpcd_ops = [op + op.dag() for op in sc_ops]
 
         self.num_collapse = len(self.c_ops)
         for c_op in self.c_ops:
@@ -146,17 +146,24 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef readonly complex[:, :, ::1] _Lb
     cdef readonly complex[:, :, :, ::1] _LLb
 
-    def __init__(self, H, c_ops, heterodyne):
-        self.L = H + liouvillian(None, c_ops)
+    def __init__(self, H, sc_ops, c_ops=(), heterodyne=False):
+        print(H, sc_ops, c_ops, False)
+        if H.issuper:
+            self.L = H + liouvillian(None, sc_ops)
+        else:
+            self.L = liouvillian(H, sc_ops)
+        if c_ops:
+            self.L = self.L + liouvillian(None, c_ops)
+
         if heterodyne:
             self.c_ops = []
-            for c in c_ops:
+            for c in sc_ops:
                 self.c_ops += [
                     (spre(c) + spost(c.dag())) / np.sqrt(2),
                     (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)
                 ]
         else:
-            self.c_ops = [spre(op) + spost(op.dag()) for op in c_ops]
+            self.c_ops = [spre(op) + spost(op.dag()) for op in sc_ops]
         self.num_collapse = len(self.c_ops)
         self.issuper = True
         self.dims = self.L.dims
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 5e798891f9..cef66af232 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -5,6 +5,7 @@
 from .multitraj import MultiTrajSolver
 from ..import Qobj, QobjEvo, liouvillian, lindblad_dissipator
 import numpy as np
+from collections.abc import Iterable
 
 
 class StochasticTrajResult(Result):
@@ -17,10 +18,8 @@ def _post_init(self, m_ops=(), dw_factor=()):
 
     def _add_measurement(self, t, state, noise):
         expects = [m_op.expect(t, state) for m_op in self.m_ops]
-        noises = np.sum(noise, axis=0)
-        print(self.measurements, expects, noises, self.dW_factor)
         for measure, expect, dW, factor in zip(
-            self.measurements, expects, noises, self.dW_factor
+            self.measurements, expects, noise, self.dW_factor
         ):
             measure.append(expect + dW * factor)
 
@@ -35,13 +34,15 @@ def add(self, t, state, noise):
 
 
 class StochasticResult(MultiTrajResult):
-    def _reduce_expect(self, trajectory):
+    def _reduce_measurements(self, trajectory):
         # Since measurements of each trajectories is kept, we keep only the
         # array to save memory.
         trajectory.measurements = np.array(trajectory.measurements)
         if self.options["heterodyne"]:
             shape = trajectory.measurements.shape
-            trajectory.measurements.reshape(-1, 2, shape[-1])
+            trajectory.measurements = (
+                trajectory.measurements.reshape(-1, 2, shape[-1])
+            )
         self.measurement.append(trajectory.measurements)
 
     def _post_init(self):
@@ -188,25 +189,30 @@ class StochasticSolver(MultiTrajSolver):
         "dw_factor": None,
     }
 
-    def __init__(self, H, sc_ops, *, options=None, m_ops=()):
+    def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
         self.options = options
 
         if not isinstance(H, (Qobj, QobjEvo)):
             raise TypeError("...")
         H = QobjEvo(H)
+
         if isinstance(sc_ops, (Qobj, QobjEvo)):
             sc_ops = [sc_ops]
         sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
 
+        if isinstance(c_ops, (Qobj, QobjEvo)):
+            c_ops = [c_ops]
+        c_ops = [QobjEvo(c_op) for c_op in c_ops]
+
         if any(not c_op.isoper for c_op in sc_ops):
             raise TypeError("sc_ops must be operators")
 
-        rhs = self._prep_system(H, sc_ops, self.options["heterodyne"])
+        rhs = self._prep_system(H, sc_ops, c_ops)
         super().__init__(rhs, options=options)
 
         if self.options["store_measurement"]:
             n_m_ops = len(sc_ops) * (1 + int(self.options["heterodyne"]))
-            dW_factor = self.options["dW_factor"]
+            dW_factor = self.options["dw_factor"]
 
             if len(m_ops) == n_m_ops:
                 self.m_ops = m_ops
@@ -266,13 +272,19 @@ class SMESolver(StochasticSolver):
     name = "smesolve"
     _avail_integrators = {}
 
-    def _prep_system(self, L, sc_ops, heterodyne):
-        if not L.issuper:
-            L = liouvillian(L)
-        return StochasticOpenSystem(L, sc_ops, heterodyne)
+    def _prep_system(self, H, sc_ops, c_ops):
+        return StochasticOpenSystem(
+            H, sc_ops, c_ops, self.options["heterodyne"]
+        )
 
 
 class SSESolver(StochasticSolver):
     name = "ssesolve"
     _avail_integrators = {}
-    _prep_system = StochasticClosedSystem
+
+    def _prep_system(self, H, sc_ops, c_ops):
+        if c_ops:
+            raise ValueError("ssesolve c_ops")
+        return StochasticClosedSystem(
+            H, sc_ops, self.options["heterodyne"]
+        )
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
new file mode 100644
index 0000000000..a87259d38b
--- /dev/null
+++ b/qutip/tests/solver/test_stochastic.py
@@ -0,0 +1,88 @@
+import pytest
+import numpy as np
+from qutip import (
+    mesolve, liouvillian, QobjEvo, spre, spost,
+    destroy, coherent, qeye, fock_dm, num
+)
+from qutip.solver.stochastic import smesolve
+from qutip.core import data as _data
+
+
+def f(t, a):
+    return a * t
+
+def _make_system(N, system):
+    gamma = 0.25
+    a = destroy(N)
+
+    if system == "simple":
+        H = [a.dag() * a]
+        sc_ops = [np.sqrt(gamma) * a]
+
+    elif system == "2 c_ops":
+        H = [a.dag() * a]
+        sc_ops = [np.sqrt(gamma) * a, gamma * a * a]
+
+    elif system == "H td":
+        H = [[a.dag() * a, f]]
+        sc_ops = [np.sqrt(gamma) * a]
+
+    elif system == "complex":
+        H = [a.dag() * a + a.dag() + a]
+        sc_ops = [np.sqrt(gamma) * a, gamma * a * a]
+
+    elif system == "c_ops td":
+        H = [a.dag() * a]
+        sc_ops = [[np.sqrt(gamma) * a, f]]
+
+    return H, sc_ops
+
+
+@pytest.mark.parametrize("system", [
+    "simple", "2 c_ops", "H td", "complex", "c_ops td",
+])
+@pytest.mark.parametrize("heterodyne", [True, False])
+def test_smesolve(heterodyne, system):
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.05
+
+    N = 4
+    ntraj = 20
+
+    H, sc_ops = _make_system(N, system)
+    psi0 = coherent(N, 0.5)
+    a = destroy(N)
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a": 2})
+
+    options = {
+        "heterodyne": heterodyne,
+        "store_measurement": True,
+        "map": "serial",
+        "method": "milstein",
+    }
+
+    res = smesolve(
+        H, psi0, times, [], sc_ops, e_ops,
+        ntraj=ntraj, args={"a": 2}, options=options
+    )
+
+    for idx in range(len(e_ops)):
+        np.testing.assert_allclose(
+            res.expect[idx], res_ref.expect[idx], rtol=tol, atol=tol
+        )
+
+    assert len(res.measurement) == ntraj
+
+    if heterodyne:
+        assert all([
+            m.shape == (len(sc_ops), 2, len(times)-1) 
+            for m in res.measurement
+        ])
+    else:
+        assert all([
+            m.shape == (len(sc_ops), len(times)-1)
+            for m in res.measurement
+        ])
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index 455e2fd35d..2cdfd9d5b6 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -4,6 +4,7 @@
     basis, rand_herm, fock_dm, liouvillian, operator_to_vector
 )
 from qutip.solver.sode.ssystem import *
+from qutip.solver.sode.ssystem import SimpleStochasticSystem
 import qutip.core.data as _data
 import pytest
 from itertools import product
@@ -92,16 +93,17 @@ def _check_equivalence(f, target, args):
     """
     Check that the error is proportional to `dt`.
     """
-    dts = np.logspace(-5, -1, 9)
+    dts = np.logspace(-4, -1, 7)
     errors_dt = np.array([
         _data.norm.l2(f(*args, dt=dt) - target)
         for dt in dts
     ])
-    poly = np.polyfit(np.log(dts), np.log(errors_dt+1e-16), 1)[0]
-    if poly > 1.05:
-        print(poly, np.log(errors_dt))
-        print(dts, errors_dt)
-    return poly < 1.05
+    if np.all(errors_dt < 1e-6):
+        return True
+
+    power = np.polyfit(np.log(dts), np.log(errors_dt + 1e-16), 1)[0]
+    # Sometime the dt term is cancelled and the dt**2 term is dominant
+    return power > 0.9
 
 
 def _run_derr_check(solver, state):
@@ -128,6 +130,7 @@ def _run_derr_check(solver, state):
             )
 
             for k in range(N):
+                print(i, j, k)
                 assert _check_equivalence(
                     LL(solver, k, j, b), solver.LiLjbk(k, j, i), (t, state)
                 )
@@ -143,7 +146,7 @@ def _make_oper(kind, N):
     elif kind == "tridiag":
         out = destroy(N) + num(N) + create(N)
     elif kind == "td":
-        out = [num(N), [destroy(N) + create(N), lambda t: t]]
+        out = [num(N), [destroy(N) + create(N), lambda t: 1 + t]]
     elif kind == "rand":
         out = rand_herm(N)
     return QobjEvo(out)
@@ -157,17 +160,17 @@ def _make_oper(kind, N):
     pytest.param("qeye", ["td"], id='c_ops td'),
     pytest.param("rand", ["rand"], id='random'),
 ])
-@pytest.mark.parametrize('type', ["sme"]) # "sse"
+@pytest.mark.parametrize('type', ["sme", "sse"])
 @pytest.mark.parametrize('heterodyne', [False, True])
 def test_system(H, c_ops, type, heterodyne):
     N = 5
     H = _make_oper(H, N)
     c_ops = [_make_oper(op, N) for op in c_ops]
     if type == "sse":
-        system = StochasticClosedSystem(H, c_ops, heterodyne)
+        system = SimpleStochasticSystem(H, c_ops)
         state = basis(N, N-2).data
     else:
         H = liouvillian(H)
-        system = StochasticOpenSystem(H, c_ops, heterodyne)
+        system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
         state = operator_to_vector(fock_dm(N, N-2)).data
     _run_derr_check(system, state)

From e9f494afc6e8ef6764555922dbea6408368b20bf Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Feb 2023 18:07:39 -0500
Subject: [PATCH 083/602] Add rouchon

---
 qutip/solve/stochastic.py              | 14 +++-
 qutip/solver/sode/__init__.py          |  1 +
 qutip/solver/sode/{ito.py => noise.py} | 15 ++++-
 qutip/solver/sode/rouchon.py           | 46 +++++++++++++
 qutip/solver/sode/sode.py              | 92 ++++++++------------------
 qutip/solver/sode/taylorapprox.py      | 67 +++++++++++++++++++
 qutip/solver/stochastic.py             | 78 +++++++++++++---------
 qutip/tests/solver/test_sode_method.py |  4 +-
 8 files changed, 217 insertions(+), 100 deletions(-)
 rename qutip/solver/sode/{ito.py => noise.py} (81%)
 create mode 100644 qutip/solver/sode/rouchon.py
 create mode 100644 qutip/solver/sode/taylorapprox.py

diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index cea188bd60..bc9d50e993 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -579,8 +579,10 @@ def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
     if _safe_mode:
         _safety_checks(sso)
 
+    print(sso.solver_code)
+
     if sso.solver_code == 120:
-        return _positive_map(sso, e_ops_dict)
+        return _positive_map(sso, e_ops_dict, _dry_run)
 
     sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
     if sso.method == 'homodyne' or sso.method is None:
@@ -767,7 +769,7 @@ def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
     return res
 
 
-def _positive_map(sso, e_ops_dict):
+def _positive_map(sso, e_ops_dict, _dry_run=False):
     if sso.method == 'homodyne' or sso.method is None:
         sops = sso.sc_ops
         if sso.m_ops is None:
@@ -811,7 +813,8 @@ def _prespostdag(op):
 
     for op in sso.c_ops:
         LH += op.dag() @ op * (-sso.dt * 0.5)
-        sso.pp += spre(op) * spost(op.dag()) * sso.dt
+        opop = spre(op) * spost(op.dag())
+        sso.pp += opop * sso.dt
 
     for i, op in enumerate(sops):
         LH += (-sso.dt * 0.5) * op.dag() @ op
@@ -829,6 +832,11 @@ def _prespostdag(op):
 
     sso.solver_obj = PmSMESolver
     sso.solver_name = "smesolve_" + sso.solver
+
+    if _dry_run:
+        ssolver = sso.solver_obj()
+        ssolver.set_solver(sso)
+        return ssolver
     res = _sesolve_generic(sso, sso.options, sso.progress_bar)
 
     if e_ops_dict:
diff --git a/qutip/solver/sode/__init__.py b/qutip/solver/sode/__init__.py
index 62d97d11f0..ac3863eabd 100644
--- a/qutip/solver/sode/__init__.py
+++ b/qutip/solver/sode/__init__.py
@@ -1,2 +1,3 @@
 from .sode import *
 from .ssystem import *
+from .taylorapprox import *
diff --git a/qutip/solver/sode/ito.py b/qutip/solver/sode/noise.py
similarity index 81%
rename from qutip/solver/sode/ito.py
rename to qutip/solver/sode/noise.py
index d3ea5df255..b02681970d 100644
--- a/qutip/solver/sode/ito.py
+++ b/qutip/solver/sode/noise.py
@@ -1,7 +1,11 @@
 import numpy as np
 
+__all__ = []
 
-class MultiNoise:
+class _Noise:
+    """
+
+    """
     def __init__(self, T, dt, num=1):
         N = int(np.round(T / dt))
         self.T = T
@@ -10,10 +14,16 @@ def __init__(self, T, dt, num=1):
         self.noise = np.random.randn(N, num) * dt**0.5
 
     def dw(self, dt):
+        """
+        Ito integral I(i).
+        """
         N = int(np.round(dt /self.dt))
         return self.noise.reshape(-1, N, self.num).sum(axis=1)
 
     def dz(self, dt):
+        """
+        Ito integral I(0, i).
+        """
         N = int(np.round(dt /self.dt))
         return np.einsum(
             "ijk,j->ik",
@@ -22,6 +32,9 @@ def dz(self, dt):
         ) * self.dt
 
     def dW(self, dt):
+        """
+        Noise used for Ito-Taylor integrators of order up to 1.5.
+        """
         N = int(np.round(dt / self.dt))
         noise = self.noise.copy()
         if noise.shape[0] % N:
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
new file mode 100644
index 0000000000..2bd4e89c03
--- /dev/null
+++ b/qutip/solver/sode/rouchon.py
@@ -0,0 +1,46 @@
+
+
+import qutip as qt
+import numpy as np
+from qutip.core import data as _data
+
+class Rouchon:
+    def __init__(self, rhs, options):
+        self.H = rhs.H
+        if self.H.issuper:
+            raise TypeError("...")
+        dtype = type(self.H(0).data)
+        self.c_ops = rhs.c_ops
+        self.sc_ops = rhs.sc_ops
+        self.cpcds = [op + op.dag() for op in self.sc_ops]
+        self.M = (
+            - 1j * self.H
+            - sum(op.dag() @ op for op in self.c_ops) * 0.5
+            - sum(op.dag() @ op for op in self.sc_ops) * 0.5
+        )
+        self.num_collapses = len(self.sc_ops)
+        self.scc = [
+            [self.sc_ops[i] @ self.sc_ops[j] for i in range(j+1)]
+            for j in range(self.num_collapses)
+        ]
+
+        self.id = _data.identity[dtype](self.H.shape[0])
+
+    def step(self, t, state, dt, dW):
+        # Same output as old rouchon up to nuerical error 1e-16
+        # But  7x slower
+        dy = [
+            op.expect_data(t, state) * dt + dw
+            for op, dw in zip(self.cpcds, dW[:, 0])
+        ]
+        M = _data.add(self.id, self.M._call(t), dt)
+        for i in range(self.num_collapses):
+            M = _data.add(M, self.sc_ops[i]._call(t), dy[i])
+            M = _data.add(M, self.scc[i][i]._call(t), (dy[i]**2-dt)/2)
+            for j in range(i):
+                M = _data.add(M, self.scc[i][j]._call(t), dy[i]*dy[j])
+        out = M @ state @ M.adjoint()
+        for cop in self.c_ops:
+            op = cop._call(t)
+            out += op @ state @ op.adjoint() * dt
+        return out / _data.trace(out)
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 8e498d1630..1201ddae8a 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -1,7 +1,11 @@
 import numpy as np
 from . import _sode
 from ..integrator.integrator import Integrator
-from ..stochastic import StochasticSolver
+from ..stochastic import StochasticSolver, SMESolver
+from .rouchon import Rouchon
+
+
+__all__ = ["SIntegrator", "PlatenSODE", "PredCorr_SODE"]
 
 
 class SIntegrator(Integrator):
@@ -98,7 +102,7 @@ class _Explicit_Simple_Integrator(SIntegrator):
     N_dw = 0
 
     def __init__(self, rhs, options):
-        self.system = rhs
+        self.system = rhs()
         self._options = self.integrator_options.copy()
         self.options = options
         self.step_func = self.stepper(self.system).run
@@ -154,18 +158,6 @@ def options(self, new_options):
         Integrator.options.fset(self, new_options)
 
 
-class EulerSODE(_Explicit_Simple_Integrator):
-    """
-    A simple generalization of the Euler method for ordinary
-    differential equations to stochastic differential equations.  Only
-    solver which could take non-commuting ``sc_ops``.
-
-    - Order: 0.5
-    """
-    stepper = _sode.Euler
-    N_dw = 1
-
-
 class PlatenSODE(_Explicit_Simple_Integrator):
     """
     Explicit scheme, creates the Milstein using finite differences
@@ -180,47 +172,6 @@ class PlatenSODE(_Explicit_Simple_Integrator):
     N_dw = 1
 
 
-class Explicit1_5_SODE(_Explicit_Simple_Integrator):
-    """
-    Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
-    Taylor scheme using finite difference instead of derivatives.
-    Slower than ``taylor15`` but usable when derrivatives cannot be
-    analytically obtained.
-    See eq. (2.13) of chapter 11.2 of Peter E. Kloeden and Exkhard Platen,
-    *Numerical Solution of Stochastic Differential Equations.*
-
-    - Order: strong 1.5
-    """
-    stepper = _sode.Explicit15
-    N_dw = 2
-
-
-class Taylor1_5_SODE(_Explicit_Simple_Integrator):
-    """
-    Order 1.5 strong Taylor scheme.  Solver with more terms of the
-    Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-    :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of Peter E. Kloeden and
-    Exkhard Platen, *Numerical Solution of Stochastic Differential Equations*.
-
-    - Order strong 1.5
-    """
-    stepper = _sode.Taylor15
-    N_dw = 2
-
-
-class Milstein_SODE(_Explicit_Simple_Integrator):
-    """
-    An order 1.0 strong Taylor scheme.  Better approximate numerical
-    solution to stochastic differential equations.  See eq. (2.9) of
-    chapter 12.2 of Peter E. Kloeden and Exkhard Platen,
-    *Numerical Solution of Stochastic Differential Equations*..
-
-    - Order strong 1.0
-    """
-    stepper = _sode.Milstein
-    N_dw = 1
-
-
 class PredCorr_SODE(_Explicit_Simple_Integrator):
     """
     Generalization of the trapezoidal method to stochastic differential
@@ -245,8 +196,8 @@ class PredCorr_SODE(_Explicit_Simple_Integrator):
     stepper = _sode.PredCorr
     N_dw = 1
 
-    def __init__(self, system, options):
-        self.system = system
+    def __init__(self, rhs, options):
+        self.system = rhs()
         self._options = self.integrator_options.copy()
         self.options = options
         self.step_func = self.stepper(
@@ -254,10 +205,25 @@ def __init__(self, system, options):
         ).run
 
 
-StochasticSolver.add_integrator(EulerSODE, "euler")
-StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
+class RouchonSODE(SIntegrator):
+    """
+    Scheme keeping the positivity of the density matrix
+    (:obj:`~smesolve` only).
+    See eq. (4) Pierre Rouchon and Jason F. Ralpha,
+    *Efficient Quantum Filtering for Quantum Feedback Control*,
+    `arXiv:1410.5345 [quant-ph] <https://arxiv.org/abs/1410.5345>`_,
+    Phys. Rev. A 91, 012118, (2015).
+
+    - Order: strong 1
+    """
+    stepper = _sode.Platen
+    N_dw = 1
+
+    def __init__(self, rhs, options):
+        self._options = self.integrator_options.copy()
+        self.options = options
+        self.step_func = Rouchon(rhs)
+
+
 StochasticSolver.add_integrator(PlatenSODE, "platen")
-StochasticSolver.add_integrator(Explicit1_5_SODE, "explicit1.5")
-StochasticSolver.add_integrator(Taylor1_5_SODE, "taylor15")
-StochasticSolver.add_integrator(PredCorr_SODE, "pred_corr")
-StochasticSolver.add_integrator(Milstein_SODE, "milstein")
+SMESolver.add_integrator(PredCorr_SODE, "pred_corr")
diff --git a/qutip/solver/sode/taylorapprox.py b/qutip/solver/sode/taylorapprox.py
new file mode 100644
index 0000000000..3c0c36edf5
--- /dev/null
+++ b/qutip/solver/sode/taylorapprox.py
@@ -0,0 +1,67 @@
+import numpy as np
+from . import _sode
+from .sode import _Explicit_Simple_Integrator
+from ..stochastic import StochasticSolver, SMESolver
+
+
+__all__ = ["EulerSODE", "Milstein_SODE", "Taylor1_5_SODE", "Explicit1_5_SODE"]
+
+
+class EulerSODE(_Explicit_Simple_Integrator):
+    """
+    A simple generalization of the Euler method for ordinary
+    differential equations to stochastic differential equations.  Only
+    solver which could take non-commuting ``sc_ops``.
+
+    - Order: 0.5
+    """
+    stepper = _sode.Euler
+    N_dw = 1
+
+
+class Milstein_SODE(_Explicit_Simple_Integrator):
+    """
+    An order 1.0 strong Taylor scheme.  Better approximate numerical
+    solution to stochastic differential equations.  See eq. (2.9) of
+    chapter 12.2 of Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations*..
+
+    - Order strong 1.0
+    """
+    stepper = _sode.Milstein
+    N_dw = 1
+
+
+class Taylor1_5_SODE(_Explicit_Simple_Integrator):
+    """
+    Order 1.5 strong Taylor scheme.  Solver with more terms of the
+    Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
+    :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of Peter E. Kloeden and
+    Exkhard Platen, *Numerical Solution of Stochastic Differential Equations*.
+
+    - Order strong 1.5
+    """
+    stepper = _sode.Taylor15
+    N_dw = 2
+
+
+class Explicit1_5_SODE(_Explicit_Simple_Integrator):
+    """
+    Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
+    Taylor scheme using finite difference instead of derivatives.
+    Slower than ``taylor15`` but usable when derrivatives cannot be
+    analytically obtained.
+    See eq. (2.13) of chapter 11.2 of Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations.*
+
+    - Order: strong 1.5
+    """
+    stepper = _sode.Explicit15
+    N_dw = 2
+
+
+StochasticSolver.add_integrator(EulerSODE, "euler")
+StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
+StochasticSolver.add_integrator(Explicit1_5_SODE, "explicit1.5")
+SMESolver.add_integrator(Taylor1_5_SODE, "taylor15")
+SMESolver.add_integrator(Milstein_SODE, "milstein")
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index cef66af232..97f654b3c0 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -52,6 +52,46 @@ def _post_init(self):
             self.add_processor(self._reduce_measurements)
 
 
+class StochasticRHS:
+    def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("...")
+        self.H = QobjEvo(H)
+
+        if isinstance(sc_ops, (Qobj, QobjEvo)):
+            sc_ops = [sc_ops]
+        self.sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
+
+        if isinstance(c_ops, (Qobj, QobjEvo)):
+            c_ops = [c_ops]
+        self.c_ops = [QobjEvo(c_op) for c_op in c_ops]
+
+        if any(not c_op.isoper for c_op in c_ops):
+            raise TypeError("c_ops must be operators")
+
+        if any(not c_op.isoper for c_op in sc_ops):
+            raise TypeError("sc_ops must be operators")
+
+        self.issuper = issuper
+        self.heterodyne = heterodyne
+
+        if self.issuper and not self.H.issuper:
+            self.dims = [self.H.dims, self.H.dims]
+        else:
+            self.dims = self.H.dims
+
+    def __call__(self):
+        if self.issuper:
+            return StochasticOpenSystem(
+                self.H , self.sc_ops, self.c_ops, self.heterodyne
+            )
+        else:
+            return StochasticClosedSystem(
+                self.H , self.sc_ops, self.heterodyne
+            )
+
+
 def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
              args={}, ntraj=500, options=None):
     """
@@ -191,32 +231,20 @@ class StochasticSolver(MultiTrajSolver):
 
     def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
         self.options = options
+        heterodyne = self.options["heterodyne"]
+        if c_ops:
+            raise ValueError("ssesolve c_ops")
 
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("...")
-        H = QobjEvo(H)
-
-        if isinstance(sc_ops, (Qobj, QobjEvo)):
-            sc_ops = [sc_ops]
-        sc_ops = [QobjEvo(c_op) for c_op in sc_ops]
-
-        if isinstance(c_ops, (Qobj, QobjEvo)):
-            c_ops = [c_ops]
-        c_ops = [QobjEvo(c_op) for c_op in c_ops]
-
-        if any(not c_op.isoper for c_op in sc_ops):
-            raise TypeError("sc_ops must be operators")
-
-        rhs = self._prep_system(H, sc_ops, c_ops)
+        rhs = StochasticRHS(self.name=="smesolve", H, sc_ops, c_ops, heterodyne)
         super().__init__(rhs, options=options)
 
         if self.options["store_measurement"]:
-            n_m_ops = len(sc_ops) * (1 + int(self.options["heterodyne"]))
+            n_m_ops = len(sc_ops) * (1 + int(heterodyne))
             dW_factor = self.options["dw_factor"]
 
             if len(m_ops) == n_m_ops:
                 self.m_ops = m_ops
-            elif self.options["heterodyne"]:
+            elif heterodyne:
                 self.m_ops = []
                 for op in sc_ops:
                     self.m_ops += [
@@ -230,7 +258,7 @@ def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
             if not isinstance(dW_factor, Iterable):
                 dW_factor = [dW_factor] * n_m_ops
 
-            if len(dW_factor) == len(sc_ops) and self.options["heterodyne"]:
+            if len(dW_factor) == len(sc_ops) and heterodyne:
                 dW_factor = [ i for i in dW_factor for _ in range(2) ]
 
             if len(dW_factor) != n_m_ops:
@@ -272,19 +300,7 @@ class SMESolver(StochasticSolver):
     name = "smesolve"
     _avail_integrators = {}
 
-    def _prep_system(self, H, sc_ops, c_ops):
-        return StochasticOpenSystem(
-            H, sc_ops, c_ops, self.options["heterodyne"]
-        )
-
 
 class SSESolver(StochasticSolver):
     name = "ssesolve"
     _avail_integrators = {}
-
-    def _prep_system(self, H, sc_ops, c_ops):
-        if c_ops:
-            raise ValueError("ssesolve c_ops")
-        return StochasticClosedSystem(
-            H, sc_ops, self.options["heterodyne"]
-        )
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index 5d3436d08a..dd057eaa79 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -5,7 +5,7 @@
 import qutip.solver.sode._sode as _sode
 import pytest
 from qutip.solver.sode.ssystem import SimpleStochasticSystem
-from qutip.solver.sode.ito import MultiNoise
+from qutip.solver.sode.noise import _Noise
 
 
 def get_error_order(system, state, method, plot=False, **kw):
@@ -18,7 +18,7 @@ def get_error_order(system, state, method, plot=False, **kw):
     # state = rand_ket(system.dims[0]).data
     err = np.zeros(len(ts), dtype=float)
     for _ in range(num_runs):
-        noise = MultiNoise(0.1, 0.000001, system.num_collapse)
+        noise = _Noise(0.1, 0.000001, system.num_collapse)
         for i, t in enumerate(ts):
             out = stepper.run(0, state.copy(), t, noise.dW(t), 1)
             target = system.analytic(t, noise.dw(t)[0]) @ state

From edcdd75b50acd97eaa1bb8877b775442034d71ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Mon, 20 Feb 2023 08:59:10 -0500
Subject: [PATCH 084/602] Apply suggestions from code review

Co-authored-by: Asier Galicia <57414022+AGaliciaMartinez@users.noreply.github.com>
---
 qutip/core/coefficient.py | 4 ++--
 qutip/core/cy/qobjevo.pyx | 4 ++--
 qutip/core/options.py     | 9 ++++-----
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 9aafca4dd3..2d702fd0c9 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -52,9 +52,9 @@ def _return(base, **kwargs):
 
 
 # The `coefficient` function is dispatcher for the type of the `base` to the
-# function that create the `Coefficient` object. `coefficient_builders` store
+# function that created the `Coefficient` object. `coefficient_builders` stores
 # the map `type -> function(base, **kw)`. Optional module can add their
-# `Coefficient` specialization here.
+# `Coefficient` specializations here.
 coefficient_builders = {
     Coefficient: _return,
     np.ndarray: InterCoefficient,
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index daf2f2942f..34d95edda6 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -287,7 +287,7 @@ cdef class QobjEvo:
 
     @classmethod
     def _restore(cls, elements, dims, shape, type, superrep, flags):
-        """ Recreate a QobjEvo without using __init__ """
+        """Recreate a QobjEvo without using __init__. """
         cdef QobjEvo out = cls.__new__(cls)
         out.elements = elements
         out.dims = dims
@@ -800,7 +800,7 @@ cdef class QobjEvo:
             The QobjEvo as a list, element are either :class:`Qobj` for
             constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
             The original format of the :class:`Coefficient` is not restored.
-            Lastly if the original `QobjEvo` is constructed with an function
+            Lastly if the original `QobjEvo` is constructed with a function
             returning a Qobj, the term is returned as a pair of :class:`Qobj`
             and args (``dict``).
         """
diff --git a/qutip/core/options.py b/qutip/core/options.py
index a2b425dcd1..5a60ffa509 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -91,11 +91,10 @@ class CoreOptions(QutipOptions):
           ``pythonic`` is used.
 
     default_dtype : Nonetype, str, type {None}
-        When set, function creating :class:`Qobj` such as :func:"qeye" or
-        :func:"rand_herm" will use the specified data type. Any data-layer
-        known to `qutip.data.to` is accepted.
-        When not specified, the functions will default to either sparse ``csr``
-        or dense representation depending on the created object density.
+        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
+        :func:"rand_herm", will use the specified data type. Any data-layer
+        known to ``qutip.data.to`` is accepted.
+        When ``None``, these functions will default to a sensible data type.
     """
     _options = {
         # use auto tidyup

From eaf15e8910ad5e183226628c7345153a25f6a4a0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 20 Feb 2023 11:50:53 -0500
Subject: [PATCH 085/602] Fix docstrings

---
 qutip/core/cy/qobjevo.pyx | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 34d95edda6..8333830e41 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -801,8 +801,8 @@ cdef class QobjEvo:
             constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
             The original format of the :class:`Coefficient` is not restored.
             Lastly if the original `QobjEvo` is constructed with a function
-            returning a Qobj, the term is returned as a pair of :class:`Qobj`
-            and args (``dict``).
+            returning a Qobj, the term is returned as a pair of the original
+            function and args (``dict``).
         """
         out = []
         for element in self.elements:
@@ -861,9 +861,15 @@ cdef class QobjEvo:
         ----------
         t : float
             Time of the operator to apply.
+
         state : Qobj
             right matrix of the product
 
+        check_real : bool (True)
+            Whether to convert the result to a `real` when the imaginary part
+            is smaller than the real part by a dactor of
+            ``settings.core['rtol']``.
+
         Returns
         -------
         expect : float or complex

From 9ef000a54c4071d75b1ebc5901a2fd4fcbfd9fc6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 20 Feb 2023 17:19:02 -0500
Subject: [PATCH 086/602] Finish rouchon + test for the method

---
 qutip/solver/sode/__init__.py                 |   5 +-
 qutip/solver/sode/_sode.pyx                   |  42 +++----
 .../sode/{taylorapprox.py => itotaylor.py}    |   3 +-
 qutip/solver/sode/noise.py                    |   6 +-
 qutip/solver/sode/rouchon.py                  | 106 ++++++++++++++++--
 qutip/solver/sode/sode.py                     |  39 ++-----
 qutip/solver/sode/ssystem.pyx                 |   1 -
 qutip/tests/solver/test_sode_method.py        |  75 ++++++++++++-
 8 files changed, 204 insertions(+), 73 deletions(-)
 rename qutip/solver/sode/{taylorapprox.py => itotaylor.py} (94%)

diff --git a/qutip/solver/sode/__init__.py b/qutip/solver/sode/__init__.py
index ac3863eabd..5f9e2560fb 100644
--- a/qutip/solver/sode/__init__.py
+++ b/qutip/solver/sode/__init__.py
@@ -1,3 +1,4 @@
-from .sode import *
 from .ssystem import *
-from .taylorapprox import *
+from .sode import *
+from .itotaylor import *
+from .rouchon import *
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index ffdb8bdbe8..d86102c448 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -23,7 +23,7 @@ cdef class Euler:
         cdef int i
         cdef Data out
         for i in range(ntraj):
-            state = self.step(t, state, dt, dW[i, :, :])
+            state = self.step(t + i * dt, state, dt, dW[i, :, :])
         return state
 
     @cython.boundscheck(False)
@@ -43,7 +43,7 @@ cdef class Euler:
         b = system.diffusion(t, state)
         cdef Data new_state = _data.add(state, a, dt)
         for i in range(system.num_collapse):
-            new_state = _data.add(new_state, b[i], dW[i, 0])
+            new_state = _data.add(new_state, b[i], dW[0, i])
         return new_state
 
 
@@ -81,7 +81,7 @@ cdef class Platen(Euler):
         for i in range(num_ops):
             Vp.append(_data.add(d1, d2[i], sqrt_dt))
             Vm.append(_data.add(d1, d2[i], -sqrt_dt))
-            Vt = _data.add(Vt, d2[i], dW[i, 0])
+            Vt = _data.add(Vt, d2[i], dW[0, i])
 
         d1 = system.drift(t, Vt)
         out = _data.add(out, d1, 0.5 * dt)
@@ -89,13 +89,13 @@ cdef class Platen(Euler):
         for i in range(num_ops):
             d2p = system.diffusion(t, Vp[i])
             d2m = system.diffusion(t, Vm[i])
-            dw = dW[i, 0] * 0.25
+            dw = dW[0, i] * 0.25
             out = _data.add(out, d2m[i], dw)
             out = _data.add(out, d2[i], 2 * dw)
             out = _data.add(out, d2p[i], dw)
 
             for j in range(num_ops):
-                dw2 = sqrt_dt_inv * (dW[i, 0] * dW[j, 0] - dt * (i == j))
+                dw2 = sqrt_dt_inv * (dW[0, i] * dW[0, j] - dt * (i == j))
                 out = _data.add(out, d2p[j], dw2)
                 out = _data.add(out, d2m[j], -dw2)
 
@@ -122,8 +122,8 @@ cdef class Explicit15(Euler):
         dw = np.empty(num_ops)
         dz = np.empty(num_ops)
         for i in range(num_ops):
-            dw[i] = dW[i, 0]
-            dz[i] = 0.5 *(dW[i, 0] + 1./np.sqrt(3) * dW[i, 1])
+            dw[i] = dW[0, i]
+            dz[i] = 0.5 *(dW[0, i] + 1./np.sqrt(3) * dW[1, i])
 
         d1 = system.drift(t, state)
         d2 = system.diffusion(t, state)
@@ -239,7 +239,7 @@ cdef class Milstein:
         state = state.copy()
 
         for i in range(ntraj):
-            self.step(t, state, dt, dW[i, :, :], out)
+            self.step(t + i * dt, state, dt, dW[i, :, :], out)
             state, out = out, state
         return state
 
@@ -265,14 +265,14 @@ cdef class Milstein:
         _data.iadd_dense(out, system.a(), dt)
 
         for i in range(num_ops):
-            _data.iadd_dense(out, system.bi(i), dW[i, 0])
+            _data.iadd_dense(out, system.bi(i), dW[0, i])
 
         for i in range(num_ops):
             for j in range(i, num_ops):
                 if i == j:
-                    dw = (dW[i, 0] * dW[j, 0] - dt) * 0.5
+                    dw = (dW[0, i] * dW[0, j] - dt) * 0.5
                 else:
-                    dw = dW[i, 0] * dW[j, 0]
+                    dw = dW[0, i] * dW[0, j]
                 _data.iadd_dense(out, system.Libj(i, j), dw)
 
 
@@ -296,7 +296,7 @@ cdef class PredCorr:
         state = state.copy()
 
         for i in range(ntraj):
-            self.step(t, state, dt, dW[i, :, :], out)
+            self.step(t + i * dt, state, dt, dW[i, :, :], out)
             state, out = out, state
         return state
 
@@ -320,24 +320,24 @@ cdef class PredCorr:
 
         _data.imul_dense(out, 0.)
         _data.iadd_dense(out, state, 1)
-        _data.iadd_dense(out, system.a(), dt*(1-alpha))
+        _data.iadd_dense(out, system.a(), dt * (1-alpha))
 
         _data.imul_dense(euler, 0.)
         _data.iadd_dense(euler, state, 1)
         _data.iadd_dense(euler, system.a(), dt)
 
         for i in range(num_ops):
-            _data.iadd_dense(euler, system.bi(i), dW[i, 0])
-            _data.iadd_dense(out, system.bi(i), dW[i, 0]*eta)
-            _data.iadd_dense(out, system.Libj(i, i), dt*(alpha-1)*0.5)
+            _data.iadd_dense(euler, system.bi(i), dW[0, i])
+            _data.iadd_dense(out, system.bi(i), dW[0, i] * eta)
+            _data.iadd_dense(out, system.Libj(i, i), dt * (alpha-1) * 0.5)
 
         system.set_state(t+dt, euler)
         if alpha:
             _data.iadd_dense(out, system.a(), dt*alpha)
 
         for i in range(num_ops):
-            _data.iadd_dense(out, system.bi(i), dW[i, 0]*(1-eta))
-            _data.iadd_dense(out, system.Libj(i, i), -dt*alpha*0.5)
+            _data.iadd_dense(out, system.bi(i), dW[0, i] * (1-eta))
+            _data.iadd_dense(out, system.Libj(i, i), -dt * alpha * 0.5)
 
         return out
 
@@ -352,7 +352,7 @@ cdef class Taylor15(Milstein):
         state = state.copy()
 
         for i in range(ntraj):
-            self.step(t, state, dt, dW[i, :, :], out)
+            self.step(t + i * dt, state, dt, dW[i, :, :], out)
             state, out = out, state
         return state
 
@@ -370,8 +370,8 @@ cdef class Taylor15(Milstein):
         cdef double[:] dz, dw
 
         num_ops = system.num_collapse
-        dw = dW[:, 0]
-        dz = 0.5 *(dW[:, 0] + 1./np.sqrt(3) * dW[:, 1]) * dt
+        dw = dW[0, :]
+        dz = 0.5 * (dW[0, :] + dW[1, :] / np.sqrt(3)) * dt
 
         _data.imul_dense(out, 0.)
         _data.iadd_dense(out, state, 1)
diff --git a/qutip/solver/sode/taylorapprox.py b/qutip/solver/sode/itotaylor.py
similarity index 94%
rename from qutip/solver/sode/taylorapprox.py
rename to qutip/solver/sode/itotaylor.py
index 3c0c36edf5..0f0d895bc0 100644
--- a/qutip/solver/sode/taylorapprox.py
+++ b/qutip/solver/sode/itotaylor.py
@@ -61,7 +61,6 @@ class Explicit1_5_SODE(_Explicit_Simple_Integrator):
 
 
 StochasticSolver.add_integrator(EulerSODE, "euler")
-StochasticSolver.add_integrator(EulerSODE, "euler-maruyama")
 StochasticSolver.add_integrator(Explicit1_5_SODE, "explicit1.5")
-SMESolver.add_integrator(Taylor1_5_SODE, "taylor15")
+SMESolver.add_integrator(Taylor1_5_SODE, "taylor1.5")
 SMESolver.add_integrator(Milstein_SODE, "milstein")
diff --git a/qutip/solver/sode/noise.py b/qutip/solver/sode/noise.py
index b02681970d..891358e6ea 100644
--- a/qutip/solver/sode/noise.py
+++ b/qutip/solver/sode/noise.py
@@ -39,9 +39,9 @@ def dW(self, dt):
         noise = self.noise.copy()
         if noise.shape[0] % N:
             noise = noise[:-(noise.shape[0] % N)]
-        out = np.empty((noise.shape[0] // N, self.num, 2), dtype=float)
-        out[:, :, 0] = noise.reshape(-1, N, self.num).sum(axis=1)
-        out[:, :, 1] = np.einsum(
+        out = np.empty((noise.shape[0] // N, 2, self.num), dtype=float)
+        out[:, 0, :] = noise.reshape(-1, N, self.num).sum(axis=1)
+        out[:, 1, :] = np.einsum(
             "ijk,j->ik",
             self.noise.reshape(-1, N, self.num),
             np.arange(N-0.5, 0, -1)
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index 2bd4e89c03..c827f7873e 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -1,11 +1,34 @@
-
-
-import qutip as qt
 import numpy as np
+from qutip import unstack_columns, stack_columns
 from qutip.core import data as _data
+from ..stochastic import SMESolver
+from .sode import SIntegrator
+from ..integrator.integrator import Integrator
+
+
+__all__ = ["RouchonSODE"]
+
+
+class RouchonSODE(SIntegrator):
+    """
+    Scheme keeping the positivity of the density matrix
+    (:obj:`~smesolve` only).
+    See eq. (4) Pierre Rouchon and Jason F. Ralpha,
+    *Efficient Quantum Filtering for Quantum Feedback Control*,
+    `arXiv:1410.5345 [quant-ph] <https://arxiv.org/abs/1410.5345>`_,
+    Phys. Rev. A 91, 012118, (2015).
+
+    - Order: strong 1
+    """
+    integrator_options = {
+        "dt": 0.001,
+        "tol": 1e-7,
+    }
 
-class Rouchon:
     def __init__(self, rhs, options):
+        self._options = self.integrator_options.copy()
+        self.options = options
+
         self.H = rhs.H
         if self.H.issuper:
             raise TypeError("...")
@@ -26,12 +49,59 @@ def __init__(self, rhs, options):
 
         self.id = _data.identity[dtype](self.H.shape[0])
 
-    def step(self, t, state, dt, dW):
+    def set_state(self, t, state0, generator):
+        """
+        Set the state of the SODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        self.t = t
+        self.state = unstack_columns(state0)
+        self.generator = generator
+
+    def get_state(self, copy=True):
+        return self.t, stack_columns(self.state), self.generator
+
+    def integrate(self, t, copy=True):
+        delta_t = (t - self.t)
+        if delta_t < 0:
+            raise ValueError("Stochastic integration time")
+        elif delta_t == 0:
+            return self.t, self.state, np.zeros(self.N_dw)
+
+        dt = self.options["dt"]
+        N, extra = np.divmod(delta_t, dt)
+        N = int(N)
+        if extra > self.options["tol"]:
+            # Not a whole number of steps.
+            N += 1
+            dt = delta_t / N
+        dW = self.generator.normal(
+            0,
+            np.sqrt(dt),
+            size=(N, self.num_collapses)
+        )
+        for dw in dW:
+            self.state = self._step(self.t, self.state, dt, dw)
+            self.t += dt
+
+        return self.t, stack_columns(self.state), np.sum(dW, axis=0)
+
+    def _step(self, t, state, dt, dW):
         # Same output as old rouchon up to nuerical error 1e-16
         # But  7x slower
         dy = [
             op.expect_data(t, state) * dt + dw
-            for op, dw in zip(self.cpcds, dW[:, 0])
+            for op, dw in zip(self.cpcds, dW)
         ]
         M = _data.add(self.id, self.M._call(t), dt)
         for i in range(self.num_collapses):
@@ -39,8 +109,30 @@ def step(self, t, state, dt, dW):
             M = _data.add(M, self.scc[i][i]._call(t), (dy[i]**2-dt)/2)
             for j in range(i):
                 M = _data.add(M, self.scc[i][j]._call(t), dy[i]*dy[j])
-        out = M @ state @ M.adjoint()
+        temp = _data.matmul(M, state)
+        Mdag = M.adjoint()
+        out = _data.matmul(temp, Mdag)
         for cop in self.c_ops:
             op = cop._call(t)
             out += op @ state @ op.adjoint() * dt
         return out / _data.trace(out)
+
+    @property
+    def options(self):
+        """
+        Supported options by Explicit Stochastic Integrators:
+
+        dt : float, default=0.001
+            Internal time step.
+
+        tol : float, default=1e-7
+            Relative tolerance.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+SMESolver.add_integrator(RouchonSODE, "rouchon")
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 1201ddae8a..d996398a2b 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -2,7 +2,6 @@
 from . import _sode
 from ..integrator.integrator import Integrator
 from ..stochastic import StochasticSolver, SMESolver
-from .rouchon import Rouchon
 
 
 __all__ = ["SIntegrator", "PlatenSODE", "PredCorr_SODE"]
@@ -60,8 +59,12 @@ def set_state(self, t, state0, generator):
         generator : numpy.random.generator
             Random number generator.
         """
-        raise NotImplementedError
+        self.t = t
+        self.state = state0
+        self.generator = generator
 
+    def get_state(self, copy=True):
+        return self.t, self.state, self.generator
 
     def integrate(self, t, copy=True):
         """
@@ -107,11 +110,6 @@ def __init__(self, rhs, options):
         self.options = options
         self.step_func = self.stepper(self.system).run
 
-    def set_state(self, t, state0, generator):
-        self.t = t
-        self.state = state0
-        self.generator = generator
-
     def integrate(self, t, copy=True):
         delta_t = (t - self.t)
         if delta_t < 0:
@@ -129,16 +127,13 @@ def integrate(self, t, copy=True):
         dW = self.generator.normal(
             0,
             np.sqrt(dt),
-            size=(N, self.system.num_collapse, self.N_dw)
+            size=(N, self.N_dw, self.system.num_collapse)
         )
 
         self.state = self.step_func(self.t, self.state, dt, dW, N)
         self.t += dt * N
 
-        return self.t, self.state, np.sum(dW[:, :, 0], axis=0)
-
-    def get_state(self, copy=True):
-        return self.t, self.state, self.generator
+        return self.t, self.state, np.sum(dW[:, 0, :], axis=0)
 
     @property
     def options(self):
@@ -205,25 +200,5 @@ def __init__(self, rhs, options):
         ).run
 
 
-class RouchonSODE(SIntegrator):
-    """
-    Scheme keeping the positivity of the density matrix
-    (:obj:`~smesolve` only).
-    See eq. (4) Pierre Rouchon and Jason F. Ralpha,
-    *Efficient Quantum Filtering for Quantum Feedback Control*,
-    `arXiv:1410.5345 [quant-ph] <https://arxiv.org/abs/1410.5345>`_,
-    Phys. Rev. A 91, 012118, (2015).
-
-    - Order: strong 1
-    """
-    stepper = _sode.Platen
-    N_dw = 1
-
-    def __init__(self, rhs, options):
-        self._options = self.integrator_options.copy()
-        self.options = options
-        self.step_func = Rouchon(rhs)
-
-
 StochasticSolver.add_integrator(PlatenSODE, "platen")
 SMESolver.add_integrator(PredCorr_SODE, "pred_corr")
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 7250c8779b..1151de3506 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -147,7 +147,6 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef readonly complex[:, :, :, ::1] _LLb
 
     def __init__(self, H, sc_ops, c_ops=(), heterodyne=False):
-        print(H, sc_ops, c_ops, False)
         if H.issuper:
             self.L = H + liouvillian(None, sc_ops)
         else:
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index dd057eaa79..3b9ad0c4fe 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -1,11 +1,12 @@
 import numpy as np
 from itertools import product
 from qutip.core import data as _data
-from qutip import qeye, destroy, QobjEvo, rand_ket
+from qutip import qeye, destroy, QobjEvo, rand_ket, rand_herm, create, Qobj, operator_to_vector, fock_dm
 import qutip.solver.sode._sode as _sode
 import pytest
-from qutip.solver.sode.ssystem import SimpleStochasticSystem
+from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticOpenSystem
 from qutip.solver.sode.noise import _Noise
+from qutip.solver.stochastic import SMESolver, StochasticRHS
 
 
 def get_error_order(system, state, method, plot=False, **kw):
@@ -28,16 +29,22 @@ def get_error_order(system, state, method, plot=False, **kw):
     if plot:
         import matplotlib.pyplot as plt
         plt.loglog(ts, err)
-    return np.polyfit(np.log(ts), np.log(err), 1)[0]
+    return np.polyfit(np.log(ts), np.log(err + 1e-20), 1)[0]
 
 
 def _make_oper(kind, N):
     if kind == "qeye":
         out = qeye(N) * np.random.rand()
+    elif kind == "create":
+        out = destroy(N) * np.random.rand()
     elif kind == "destroy":
         out = destroy(N) * np.random.rand()
     elif kind == "destroy2":
         out = destroy(N)**2 * np.random.rand()
+    elif kind == "herm":
+        out = rand_herm(N)
+    elif kind == "random":
+        out = Qobj(np.random.randn(N, N) + 1j * np.random.rand(N, N))
     return QobjEvo(out)
 
 
@@ -52,8 +59,8 @@ def _make_oper(kind, N):
 ])
 @pytest.mark.parametrize(['H', 'c_ops'], [
     pytest.param("qeye", ["destroy"], id='simple'),
-    pytest.param("destroy", ["destroy"], id='simple'),
-    pytest.param("qeye", ["qeye", "destroy", "destroy2"], id='2 c_ops'),
+    pytest.param("destroy", ["destroy"], id='destroy'),
+    pytest.param("qeye", ["qeye", "destroy", "destroy2"], id='3 c_ops'),
 ])
 def test_methods(H, c_ops, method, order, kw):
     N = 5
@@ -65,3 +72,61 @@ def test_methods(H, c_ops, method, order, kw):
     # The first error term of the method is dt**0.5 greater than the solver
     # order.
     assert (order + 0.35) < error_order
+
+
+def get_error_order_integrator(integrator, ref_integrator, state, plot=False):
+    ts = [
+        0.000001, 0.000002, 0.000005, 0.00001, 0.00002,  0.00005,
+        0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1,
+    ]
+    # state = rand_ket(system.dims[0]).data
+    err = np.zeros(len(ts), dtype=float)
+    for i, t in enumerate(ts):
+        integrator.options["dt"] = 0.1
+        ref_integrator.options["dt"] = 0.1
+        integrator.set_state(0., state, np.random.default_rng(0))
+        ref_integrator.set_state(0., state, np.random.default_rng(0))
+        out = integrator.integrate(t)[1]
+        target = ref_integrator.integrate(t)[1]
+        err[i] = _data.norm.l2(out - target)
+
+    if plot:
+        import matplotlib.pyplot as plt
+        plt.loglog(ts, err)
+    if np.all(err < 1e-12):
+        # Exact match
+        return np.inf
+    return np.polyfit(np.log(ts), np.log(err + 1e-20), 1)[0]
+
+
+@pytest.mark.parametrize(["method", "order"], [
+    pytest.param("euler", 0.5, id="Euler"),
+    pytest.param("milstein", 1.0, id="Milstein"),
+    pytest.param("platen", 1.0, id="Platen"),
+    pytest.param("pred_corr", 1.0, id="PredCorr"),
+    pytest.param("rouchon", 1.0, id="rouchon"),
+    pytest.param("explicit1.5", 1.5, id="Explicit15"),
+])
+@pytest.mark.parametrize(['H', 'c_ops', 'sc_ops'], [
+    pytest.param("qeye", [], ["destroy"], id='simple'),
+    pytest.param("qeye", ["destroy"], ["destroy"], id='simple + collapse'),
+    pytest.param("herm", ["destroy", "destroy2"], [], id='2 c_ops'),
+    pytest.param("herm", [], ["destroy", "destroy2"], id='2 sc_ops'),
+    pytest.param("herm", ["create", "destroy"], ["destroy", "destroy2"],
+                 id='many terms'),
+    pytest.param("herm", [], ["random"], id='random'),
+    pytest.param("herm", ["random"], ["random"], id='complex'),
+])
+def test_integrator(method, order, H, c_ops, sc_ops):
+    N = 5
+    H = _make_oper(H, N)
+    c_ops = [_make_oper(op, N) for op in c_ops]
+    sc_ops = [_make_oper(op, N) for op in sc_ops]
+
+    rhs = StochasticRHS(StochasticOpenSystem, H, sc_ops, c_ops, False)
+    ref_sode = SMESolver.avail_integrators()["taylor1.5"](rhs, {"dt": 0.01})
+    sode = SMESolver.avail_integrators()[method](rhs, {"dt": 0.01})
+    state = operator_to_vector(fock_dm(5, 3, dtype="Dense")).data
+
+    error_order = get_error_order_integrator(sode, ref_sode, state)
+    assert (order + 0.35) < error_order

From 3884750036f08644562e4b60d29b89fe0982b502 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 21 Feb 2023 08:36:01 -0500
Subject: [PATCH 087/602] Add integrator test for time-dependant cases

---
 qutip/solver/sode/ssystem.pyx          | 14 ++++++++++----
 qutip/tests/solver/test_sode_method.py | 25 +++++++++++++++++--------
 2 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 1151de3506..3f06907bc6 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -462,10 +462,16 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
 
     def analytic(self, t, W):
         """
-        Analytic solution, H and all c_ops must commute and are constant.
+        Analytic solution, H and all c_ops must commute.
+        Support time dependance of order 2 (a + b*t + c*t**2)
         """
-        out = self.H(0) * t
+        def _intergal(f, T):
+            return (f(0) + 4 * f(T/2) + f(T)) / 6
+
+        out = _intergal(self.H, t) * t
         for i in range(self.num_collapse):
-            out += self.c_ops[i](0) * W[i]
-            out -= 0.5 * self.c_ops[i](0) @ self.c_ops[i](0) * t
+            out += _intergal(self.c_ops[i], t) * W[i]
+            out -= 0.5 * _intergal(
+                lambda t: self.c_ops[i](t) @ self.c_ops[i](t), t
+            ) * t
         return out.expm().data
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index 3b9ad0c4fe..64849f39c0 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -33,16 +33,21 @@ def get_error_order(system, state, method, plot=False, **kw):
 
 
 def _make_oper(kind, N):
+    a = destroy(N)
     if kind == "qeye":
         out = qeye(N) * np.random.rand()
     elif kind == "create":
-        out = destroy(N) * np.random.rand()
+        out = a.dag() * np.random.rand()
     elif kind == "destroy":
-        out = destroy(N) * np.random.rand()
+        out = a * np.random.rand()
+    elif kind == "destroy td":
+        out = [a, lambda t: 1 + t/2]
     elif kind == "destroy2":
-        out = destroy(N)**2 * np.random.rand()
+        out = a**2
     elif kind == "herm":
         out = rand_herm(N)
+    elif kind == "herm td":
+        out = [rand_herm(N), lambda t: -1 + t/2 + t**2]
     elif kind == "random":
         out = Qobj(np.random.randn(N, N) + 1j * np.random.rand(N, N))
     return QobjEvo(out)
@@ -57,16 +62,18 @@ def _make_oper(kind, N):
     pytest.param("Taylor15", 1.5, {}, id="Taylor15"),
     pytest.param("Explicit15", 1.5, {}, id="Explicit15"),
 ])
-@pytest.mark.parametrize(['H', 'c_ops'], [
+@pytest.mark.parametrize(['H', 'sc_ops'], [
     pytest.param("qeye", ["destroy"], id='simple'),
     pytest.param("destroy", ["destroy"], id='destroy'),
-    pytest.param("qeye", ["qeye", "destroy", "destroy2"], id='3 c_ops'),
+    pytest.param("destroy", ["destroy td"], id='sc_ops td'),
+    pytest.param("herm td", ["qeye"], id='H td'),
+    pytest.param("qeye", ["qeye", "destroy", "destroy2"], id='3 sc_ops'),
 ])
-def test_methods(H, c_ops, method, order, kw):
+def test_methods(H, sc_ops, method, order, kw):
     N = 5
     H = _make_oper(H, N)
-    c_ops = [_make_oper(op, N) for op in c_ops]
-    system = SimpleStochasticSystem(H, c_ops)
+    sc_ops = [_make_oper(op, N) for op in sc_ops]
+    system = SimpleStochasticSystem(H, sc_ops)
     state = rand_ket(N).data
     error_order = get_error_order(system, state, method, **kw)
     # The first error term of the method is dt**0.5 greater than the solver
@@ -116,6 +123,8 @@ def get_error_order_integrator(integrator, ref_integrator, state, plot=False):
                  id='many terms'),
     pytest.param("herm", [], ["random"], id='random'),
     pytest.param("herm", ["random"], ["random"], id='complex'),
+    pytest.param("herm td", ["random"], ["destroy"], id='H td'),
+    pytest.param("herm", ["random"], ["destroy td"], id='sc_ops td'),
 ])
 def test_integrator(method, order, H, c_ops, sc_ops):
     N = 5

From f6929e5492a0e80e13a093624bd5de32aa01cdf8 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 21 Feb 2023 10:09:53 -0500
Subject: [PATCH 088/602] Improve coefficient docstring

---
 qutip/core/coefficient.py | 38 ++++++++++++++++++++++++++++++++++----
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 2d702fd0c9..efd754806f 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -65,9 +65,14 @@ def _return(base, **kwargs):
 
 def coefficient(base, *, tlist=None, args={}, args_ctypes={},
                 order=3, compile_opt=None, function_style=None, **kwargs):
-    """Coefficient for time dependent systems.
+    """Build ``Coefficient`` for time dependent systems:
 
-    The coefficients are either a function, a string or a numpy array.
+    ```
+    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
+    ```
+
+    The coefficients can be a function, a string or a numpy array. Other
+    packages may add support for other kind of coefficients.
 
     For function based coefficients, the function signature must be either:
 
@@ -104,8 +109,7 @@ def f2_t(t, args):
         real imag conj abs norm arg proj
         numpy as np,
         scipy.special as spe (python interface)
-        and cython_special (cython interface)
-        [https://docs.scipy.org/doc/scipy/reference/special.cython_special.html].
+        and cython_special (scipy cython interface)
 
     *Examples*
         coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
@@ -132,6 +136,32 @@ def f2_t(t, args):
     created from ``ndarray``). Other interpolation methods from
     scipy are converted to a function-based coefficient (the same kind of
     coefficient created from callables).
+
+    Parameters
+    ----------
+    base : object
+        Base object to make into a Coefficient.
+
+    args : dict, optional
+        Dictionary of arguments to pass to the function or string coefficient.
+
+    order : int, default=3
+        Order of the spline for array based coefficient.
+
+    tlist : iterable, optional
+        Times for each element of an array based coefficient.
+
+    function_style : str, ["dict", "pythonic", None]
+        Function signature of function based coefficients.
+
+    args_ctypes : dict, optional
+        C type for the args when compiling array based coefficients.
+
+    compile_opt : CompilationOptions, optional
+        Sets of options for the compilation of string based coefficients.
+
+    **kwargs
+        Extra arguments to pass the the coefficients.
     """
     kwargs.update({
         "tlist": tlist,

From 75a353d7cd751f606ca1467b5a23798f8f77573f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 21 Feb 2023 10:33:02 -0500
Subject: [PATCH 089/602] Improve docstring format

---
 qutip/core/options.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index 5a60ffa509..fe035d6375 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -93,8 +93,8 @@ class CoreOptions(QutipOptions):
     default_dtype : Nonetype, str, type {None}
         When set, functions creating :class:`Qobj`, such as :func:"qeye" or
         :func:"rand_herm", will use the specified data type. Any data-layer
-        known to ``qutip.data.to`` is accepted.
-        When ``None``, these functions will default to a sensible data type.
+        known to ``qutip.data.to`` is accepted. When ``None``, these functions
+        will default to a sensible data type.
     """
     _options = {
         # use auto tidyup

From 158660f2177014242bb3180f8c91f4453ca5dcb2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 21 Feb 2023 18:02:09 -0500
Subject: [PATCH 090/602] sse derivative

---
 qutip/solver/sode/ssystem.pxd                |   2 +-
 qutip/solver/sode/ssystem.pyx                | 116 ++++++++++++++++++-
 qutip/tests/solver/test_stochastic_system.py |  38 +++---
 3 files changed, 134 insertions(+), 22 deletions(-)

diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index f3c5a5e5ef..ae1900e201 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -14,7 +14,7 @@ cdef class _StochasticSystem:
 
     cpdef list diffusion(self, t, Data state)
 
-    cpdef void set_state(self, double t, Data state)
+    cpdef void set_state(self, double t, Data state) except *
     cpdef Data a(self)
     cpdef Data bi(self, int i)
     cpdef Data Libj(self, int i, int j)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 3f06907bc6..3bc0076ced 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -33,7 +33,7 @@ cdef class _StochasticSystem:
     cpdef list diffusion(self, t, Data state):
         raise NotImplementedError
 
-    cpdef void set_state(self, double t, Data state):
+    cpdef void set_state(self, double t, Data state) except *:
         self.t = t
         self.state = state
         self._is_set = True
@@ -82,14 +82,21 @@ cdef class _StochasticSystem:
 
 
 cdef class StochasticClosedSystem(_StochasticSystem):
-    cdef QobjEvo H
-    cdef list c_ops
-    cdef list cpcd_ops
+    cdef readonly QobjEvo H
+    cdef readonly list c_ops
+    cdef readonly list cpcd_ops
+    cdef bint _a_set, _b_set, _Lb_set
+
+    cdef readonly Dense _a, temp
+    cdef readonly complex[::1] _e
+    cdef readonly complex[:, ::1] _b, _La, _c_vec
+    cdef readonly complex[:, :, ::1] _Lb
 
     def __init__(self, H, sc_ops, heterodyne=False):
         self.H = -1j * H
         if heterodyne:
             self.c_ops = []
+            self.cpcd_ops = []
             for c_op in sc_ops:
                 self.c_ops.append(c_op / np.sqrt(2))
                 self.c_ops.append(c_op * (-1j / np.sqrt(2)))
@@ -104,6 +111,7 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             self.H += -0.5 * c_op.dag() * c_op
         self.issuper = False
         self.dims = self.H.dims
+        self._is_set = False
 
     cpdef Data drift(self, t, Data state):
         cdef int i
@@ -132,6 +140,102 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             out.append(_data.add(_out, state, -0.5 * expect))
         return out
 
+    cpdef void set_state(self, double t, Data state) except *:
+        cdef n, l
+        self.t = t
+        self.state = _data.to(_data.Dense, state).reorder(fortran=1)
+        self._a_set = False
+        self._b_set = False
+        self._Lb_set = False
+
+        if not self._is_set:
+            n = self.num_collapse
+            l = self.H.shape[0]
+            self._is_set = 1
+            self._a = dense.zeros(l, 1)
+            self.temp = dense.zeros(l, 1)
+            self._e = np.zeros(n, dtype=complex)
+            self._c_vec = np.zeros((n, l), dtype=complex)
+            self._b = np.zeros((n, l), dtype=complex)
+            self._Lb = np.zeros((n, n, l), dtype=complex)
+
+    cpdef Data a(self):
+        if not self._a_set:
+            self._compute_a()
+        return self._a
+
+    cdef void _compute_a(self) except *:
+        if not self._is_set:
+            raise RuntimeError
+        cdef Dense c_vec
+        _data.imul_dense(self._a, 0)
+        self.H.matmul_data(self.t, self.state, self._a)
+
+        for i in range(self.num_collapse):
+            c_op = self.c_ops[i]
+            c_vec = _dense_wrap(self._c_vec[i, :])
+            _data.imul_dense(c_vec, 0)
+            c_op.matmul_data(self.t, self.state, c_vec)
+            self._e[i] = _data.inner_dense(self.state, c_vec).real
+            _data.iadd_dense(self._a, self.state,  -0.5 * self._e[i]**2)
+            _data.iadd_dense(self._a, c_vec, self._e[i])
+
+        self._a_set = True
+
+    cpdef Data bi(self, int i):
+        if not self._b_set:
+            self._compute_b()
+        return _dense_wrap(self._b[i, :])
+
+    cdef void _compute_b(self) except *:
+        if not self._a_set:
+            self._compute_a()
+        cdef int i
+        cdef QobjEvo c_op
+        cdef Dense b_vec
+        for i in range(self.num_collapse):
+            c_op = <QobjEvo> self.c_ops[i]
+            b_vec = <Dense> _dense_wrap(self._b[i, :])
+            _data.imul_dense(b_vec, 0)
+            _data.iadd_dense(b_vec, _dense_wrap(self._c_vec[i, :]))
+            _data.iadd_dense(b_vec, self.state, -self._e[i])
+        self._b_set = True
+
+    cpdef Data Libj(self, int i, int j):
+        if not self._Lb_set:
+            self._compute_Lb()
+        # We only support commutative diffusion
+        if i > j:
+            j, i = i, j
+        return _dense_wrap(self._Lb[i, j, :])
+
+    cdef void _compute_Lb(self) except *:
+        cdef int i, j
+        cdef QobjEvo c_op
+        cdef Dense Lb_vec
+        cdef complex de_dx_b
+        if not self._b_set:
+            self._compute_b()
+
+        for i in range(self.num_collapse):
+            c_op = self.c_ops[i]
+            for j in range(i, self.num_collapse):
+                Lb_vec =  <Dense> _dense_wrap(self._Lb[i, j, :])
+                _data.imul_dense(Lb_vec, 0)
+                _data.imul_dense(self.temp, 0)
+                c_op.matmul_data(self.t, <Dense> _dense_wrap(self._c_vec[j, :]), self.temp)
+                _data.iadd_dense(Lb_vec, self.temp)
+                _data.iadd_dense(Lb_vec, _dense_wrap(self._c_vec[i, :]), -0.5 * self._e[j])
+                _data.iadd_dense(Lb_vec, _dense_wrap(self._c_vec[j, :]), -0.5 * self._e[i])
+                de_dx_b = (
+                    self._e[i] * self._e[j]
+                    - _data.inner_dense(_dense_wrap(self._c_vec[i, :]), _dense_wrap(self._c_vec[j, :])).real
+                    - _data.inner_dense(self.temp, self.state).real
+                )
+                _data.iadd_dense(Lb_vec, self.state, de_dx_b)
+
+        self._Lb_set = True
+
 
 cdef class StochasticOpenSystem(_StochasticSystem):
     cdef QobjEvo L
@@ -184,7 +288,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             out.append(_data.add(vec, state, -expect))
         return out
 
-    cpdef void set_state(self, double t, Data state):
+    cpdef void set_state(self, double t, Data state) except *:
         cdef n, l
         self.t = t
         self.state = _data.to(_data.Dense, state).reorder(fortran=1)
@@ -422,7 +526,7 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
             out.append(self.c_ops[i].matmul_data(t, state))
         return out
 
-    cpdef void set_state(self, double t, Data state):
+    cpdef void set_state(self, double t, Data state) except *:
         self.t = t
         self.state = _data.to(_data.Dense, state)
 
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index 2cdfd9d5b6..645419e4fe 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -4,7 +4,7 @@
     basis, rand_herm, fock_dm, liouvillian, operator_to_vector
 )
 from qutip.solver.sode.ssystem import *
-from qutip.solver.sode.ssystem import SimpleStochasticSystem
+from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticClosedSystem
 import qutip.core.data as _data
 import pytest
 from itertools import product
@@ -99,14 +99,14 @@ def _check_equivalence(f, target, args):
         for dt in dts
     ])
     if np.all(errors_dt < 1e-6):
-        return True
+        return
 
     power = np.polyfit(np.log(dts), np.log(errors_dt + 1e-16), 1)[0]
     # Sometime the dt term is cancelled and the dt**2 term is dominant
-    return power > 0.9
+    assert power > 0.9
 
 
-def _run_derr_check(solver, state):
+def _run_derr_check(solver, state, all):
     """
 
     """
@@ -116,22 +116,28 @@ def _run_derr_check(solver, state):
     solver.set_state(t, state)
 
     assert _data.norm.l2(solver.drift(t, state) - solver.a()) < 1e-6
-    assert _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
-
     for i in range(N):
         b = lambda *args: solver.diffusion(*args)[i]
         assert b(t, state) == solver.bi(i)
-        assert _check_equivalence(L0(solver, b), solver.L0bi(i), (t, state))
-        assert _check_equivalence(L(solver, i, a), solver.Lia(i), (t, state))
-
         for j in range(N):
-            assert _check_equivalence(
+            _check_equivalence(
                 L(solver, j, b), solver.Libj(j, i), (t, state)
             )
 
+    if not all:
+        # Most method only need the Libj term.
+        return
+
+    _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
+
+    for i in range(N):
+        b = lambda *args: solver.diffusion(*args)[i]
+        _check_equivalence(L0(solver, b), solver.L0bi(i), (t, state))
+        _check_equivalence(L(solver, i, a), solver.Lia(i), (t, state))
+
+        for j in range(N):
             for k in range(N):
-                print(i, j, k)
-                assert _check_equivalence(
+                _check_equivalence(
                     LL(solver, k, j, b), solver.LiLjbk(k, j, i), (t, state)
                 )
 
@@ -160,17 +166,19 @@ def _make_oper(kind, N):
     pytest.param("qeye", ["td"], id='c_ops td'),
     pytest.param("rand", ["rand"], id='random'),
 ])
-@pytest.mark.parametrize('type', ["sme", "sse"])
 @pytest.mark.parametrize('heterodyne', [False, True])
+@pytest.mark.parametrize('type', ["sse", "sme"])
 def test_system(H, c_ops, type, heterodyne):
     N = 5
     H = _make_oper(H, N)
     c_ops = [_make_oper(op, N) for op in c_ops]
     if type == "sse":
-        system = SimpleStochasticSystem(H, c_ops)
+        system = StochasticClosedSystem(H, c_ops, heterodyne=heterodyne)
         state = basis(N, N-2).data
+        all = False
     else:
         H = liouvillian(H)
         system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
         state = operator_to_vector(fock_dm(N, N-2)).data
-    _run_derr_check(system, state)
+        all = True
+    _run_derr_check(system, state, all)

From 21a9cef7a88154a53a0faa886f099591fcd1295c Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 22 Feb 2023 14:16:02 -0500
Subject: [PATCH 091/602] sse derr only support one c_ops

---
 qutip/solver/sode/ssystem.pyx                | 78 ++++++++------------
 qutip/tests/solver/test_stochastic_system.py | 34 ++++++---
 2 files changed, 54 insertions(+), 58 deletions(-)

diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 3bc0076ced..1fcae1e4d9 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -87,10 +87,8 @@ cdef class StochasticClosedSystem(_StochasticSystem):
     cdef readonly list cpcd_ops
     cdef bint _a_set, _b_set, _Lb_set
 
-    cdef readonly Dense _a, temp
-    cdef readonly complex[::1] _e
-    cdef readonly complex[:, ::1] _b, _La, _c_vec
-    cdef readonly complex[:, :, ::1] _Lb
+    cdef readonly Dense _a, temp, _b_vec, _c_vec, _Lb
+    cdef readonly complex _e
 
     def __init__(self, H, sc_ops, heterodyne=False):
         self.H = -1j * H
@@ -148,16 +146,17 @@ cdef class StochasticClosedSystem(_StochasticSystem):
         self._b_set = False
         self._Lb_set = False
 
+        if self.num_collapse != 1:
+            raise NotImplementedError
+
         if not self._is_set:
-            n = self.num_collapse
             l = self.H.shape[0]
             self._is_set = 1
             self._a = dense.zeros(l, 1)
             self.temp = dense.zeros(l, 1)
-            self._e = np.zeros(n, dtype=complex)
-            self._c_vec = np.zeros((n, l), dtype=complex)
-            self._b = np.zeros((n, l), dtype=complex)
-            self._Lb = np.zeros((n, n, l), dtype=complex)
+            self._c_vec = dense.zeros(l, 1)
+            self._b_vec = dense.zeros(l, 1)
+            self._Lb = dense.zeros(l, 1)
 
     cpdef Data a(self):
         if not self._a_set:
@@ -167,47 +166,38 @@ cdef class StochasticClosedSystem(_StochasticSystem):
     cdef void _compute_a(self) except *:
         if not self._is_set:
             raise RuntimeError
-        cdef Dense c_vec
         _data.imul_dense(self._a, 0)
         self.H.matmul_data(self.t, self.state, self._a)
 
-        for i in range(self.num_collapse):
-            c_op = self.c_ops[i]
-            c_vec = _dense_wrap(self._c_vec[i, :])
-            _data.imul_dense(c_vec, 0)
-            c_op.matmul_data(self.t, self.state, c_vec)
-            self._e[i] = _data.inner_dense(self.state, c_vec).real
-            _data.iadd_dense(self._a, self.state,  -0.5 * self._e[i]**2)
-            _data.iadd_dense(self._a, c_vec, self._e[i])
+        c_op = self.c_ops[0]
+        _data.imul_dense(self._c_vec, 0)
+        c_op.matmul_data(self.t, self.state, self._c_vec)
+        self._e = _data.inner_dense(self.state, self._c_vec).real
+        _data.iadd_dense(self._a, self.state,  -0.5 * self._e**2)
+        _data.iadd_dense(self._a, self._c_vec, self._e)
 
         self._a_set = True
 
     cpdef Data bi(self, int i):
         if not self._b_set:
             self._compute_b()
-        return _dense_wrap(self._b[i, :])
+        return self._b_vec
 
     cdef void _compute_b(self) except *:
         if not self._a_set:
             self._compute_a()
         cdef int i
         cdef QobjEvo c_op
-        cdef Dense b_vec
-        for i in range(self.num_collapse):
-            c_op = <QobjEvo> self.c_ops[i]
-            b_vec = <Dense> _dense_wrap(self._b[i, :])
-            _data.imul_dense(b_vec, 0)
-            _data.iadd_dense(b_vec, _dense_wrap(self._c_vec[i, :]))
-            _data.iadd_dense(b_vec, self.state, -self._e[i])
+        c_op = <QobjEvo> self.c_ops[0]
+        _data.imul_dense(self._b_vec, 0)
+        _data.iadd_dense(self._b_vec, self._c_vec)
+        _data.iadd_dense(self._b_vec, self.state, -self._e)
         self._b_set = True
 
     cpdef Data Libj(self, int i, int j):
         if not self._Lb_set:
             self._compute_Lb()
-        # We only support commutative diffusion
-        if i > j:
-            j, i = i, j
-        return _dense_wrap(self._Lb[i, j, :])
+        return self._Lb
 
     cdef void _compute_Lb(self) except *:
         cdef int i, j
@@ -217,22 +207,18 @@ cdef class StochasticClosedSystem(_StochasticSystem):
         if not self._b_set:
             self._compute_b()
 
-        for i in range(self.num_collapse):
-            c_op = self.c_ops[i]
-            for j in range(i, self.num_collapse):
-                Lb_vec =  <Dense> _dense_wrap(self._Lb[i, j, :])
-                _data.imul_dense(Lb_vec, 0)
-                _data.imul_dense(self.temp, 0)
-                c_op.matmul_data(self.t, <Dense> _dense_wrap(self._c_vec[j, :]), self.temp)
-                _data.iadd_dense(Lb_vec, self.temp)
-                _data.iadd_dense(Lb_vec, _dense_wrap(self._c_vec[i, :]), -0.5 * self._e[j])
-                _data.iadd_dense(Lb_vec, _dense_wrap(self._c_vec[j, :]), -0.5 * self._e[i])
-                de_dx_b = (
-                    self._e[i] * self._e[j]
-                    - _data.inner_dense(_dense_wrap(self._c_vec[i, :]), _dense_wrap(self._c_vec[j, :])).real
-                    - _data.inner_dense(self.temp, self.state).real
-                )
-                _data.iadd_dense(Lb_vec, self.state, de_dx_b)
+        c_op = self.c_ops[0]
+        _data.imul_dense(self._Lb, 0)
+        _data.imul_dense(self.temp, 0)
+        c_op.matmul_data(self.t, self._c_vec, self.temp)
+        _data.iadd_dense(self._Lb, self.temp)
+        _data.iadd_dense(self._Lb, self._c_vec, -self._e)
+        de_dx_b = (
+            self._e * self._e
+            - _data.inner_dense(self._c_vec, self._c_vec).real
+            - _data.inner_dense(self.temp, self.state).real
+        )
+        _data.iadd_dense(self._Lb, self.state, de_dx_b)
 
         self._Lb_set = True
 
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index 645419e4fe..fb883300f2 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -167,18 +167,28 @@ def _make_oper(kind, N):
     pytest.param("rand", ["rand"], id='random'),
 ])
 @pytest.mark.parametrize('heterodyne', [False, True])
-@pytest.mark.parametrize('type', ["sse", "sme"])
-def test_system(H, c_ops, type, heterodyne):
+def test_open_system(H, c_ops, heterodyne):
     N = 5
     H = _make_oper(H, N)
     c_ops = [_make_oper(op, N) for op in c_ops]
-    if type == "sse":
-        system = StochasticClosedSystem(H, c_ops, heterodyne=heterodyne)
-        state = basis(N, N-2).data
-        all = False
-    else:
-        H = liouvillian(H)
-        system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
-        state = operator_to_vector(fock_dm(N, N-2)).data
-        all = True
-    _run_derr_check(system, state, all)
+    H = liouvillian(H)
+    system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
+    state = operator_to_vector(fock_dm(N, N-2)).data
+    _run_derr_check(system, state, True)
+
+
+@pytest.mark.parametrize(['H', 'c_ops'], [
+    pytest.param("qeye", ["destroy"], id='simple'),
+    pytest.param("tridiag", ["destroy"], id='simple'),
+    pytest.param("td", ["destroy"], id='H td'),
+    pytest.param("qeye", ["td"], id='c_ops td'),
+    pytest.param("rand", ["rand"], id='random'),
+])
+def test_closed_system(H, c_ops):
+    N = 5
+    H = _make_oper(H, N)
+    c_ops = [_make_oper(op, N) for op in c_ops]
+    system = StochasticClosedSystem(H, c_ops, heterodyne=False)
+    state = basis(N, N-2).data
+    all = False
+    _run_derr_check(system, state, False)

From 27b46dbcc24b74dd1c62852d560c8f1d6b25c855 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 22 Feb 2023 14:17:42 -0500
Subject: [PATCH 092/602] sse derr only support one c_ops

---
 qutip/tests/solver/test_stochastic_system.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index fb883300f2..ff1fc0ff26 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -1,6 +1,6 @@
 import numpy as np
 from qutip import (
-    qeye, num, destroy, create, QobjEvo,
+    qeye, num, destroy, create, QobjEvo, Qobj,
     basis, rand_herm, fock_dm, liouvillian, operator_to_vector
 )
 from qutip.solver.sode.ssystem import *
@@ -179,7 +179,7 @@ def test_open_system(H, c_ops, heterodyne):
 
 @pytest.mark.parametrize(['H', 'c_ops'], [
     pytest.param("qeye", ["destroy"], id='simple'),
-    pytest.param("tridiag", ["destroy"], id='simple'),
+    pytest.param("tridiag", ["destroy"], id='tridiag'),
     pytest.param("td", ["destroy"], id='H td'),
     pytest.param("qeye", ["td"], id='c_ops td'),
     pytest.param("rand", ["rand"], id='random'),
@@ -189,6 +189,6 @@ def test_closed_system(H, c_ops):
     H = _make_oper(H, N)
     c_ops = [_make_oper(op, N) for op in c_ops]
     system = StochasticClosedSystem(H, c_ops, heterodyne=False)
-    state = basis(N, N-2).data
+    state = Qobj([1]*N).unit().data
     all = False
     _run_derr_check(system, state, False)

From ea32f31537923fe39aefdc85040ed9b4580138a4 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 23 Feb 2023 16:03:46 -0500
Subject: [PATCH 093/602] add rouchon for sse and rm milstein

---
 qutip/solver/sode/rouchon.py                 | 36 +++++---
 qutip/solver/sode/ssystem.pxd                |  2 -
 qutip/solver/sode/ssystem.pyx                | 96 +-------------------
 qutip/tests/solver/test_sode_method.py       | 30 +++++-
 qutip/tests/solver/test_stochastic_system.py | 25 +----
 5 files changed, 56 insertions(+), 133 deletions(-)

diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index c827f7873e..03f9b98039 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -1,7 +1,7 @@
 import numpy as np
 from qutip import unstack_columns, stack_columns
 from qutip.core import data as _data
-from ..stochastic import SMESolver
+from ..stochastic import StochasticSolver
 from .sode import SIntegrator
 from ..integrator.integrator import Integrator
 
@@ -32,6 +32,7 @@ def __init__(self, rhs, options):
         self.H = rhs.H
         if self.H.issuper:
             raise TypeError("...")
+        self._issuper = rhs.issuper
         dtype = type(self.H(0).data)
         self.c_ops = rhs.c_ops
         self.sc_ops = rhs.sc_ops
@@ -65,11 +66,11 @@ def set_state(self, t, state0, generator):
             Random number generator.
         """
         self.t = t
-        self.state = unstack_columns(state0)
+        self.state = state0
         self.generator = generator
 
     def get_state(self, copy=True):
-        return self.t, stack_columns(self.state), self.generator
+        return self.t, self.state, self.generator
 
     def integrate(self, t, copy=True):
         delta_t = (t - self.t)
@@ -90,14 +91,19 @@ def integrate(self, t, copy=True):
             np.sqrt(dt),
             size=(N, self.num_collapses)
         )
+
+        if self._issuper:
+            self.state = unstack_columns(self.state)
         for dw in dW:
             self.state = self._step(self.t, self.state, dt, dw)
             self.t += dt
+        if self._issuper:
+            self.state = stack_columns(self.state)
 
-        return self.t, stack_columns(self.state), np.sum(dW, axis=0)
+        return self.t, self.state, np.sum(dW, axis=0)
 
     def _step(self, t, state, dt, dW):
-        # Same output as old rouchon up to nuerical error 1e-16
+        # Same output as old rouchon up to numerical error
         # But  7x slower
         dy = [
             op.expect_data(t, state) * dt + dw
@@ -109,13 +115,17 @@ def _step(self, t, state, dt, dW):
             M = _data.add(M, self.scc[i][i]._call(t), (dy[i]**2-dt)/2)
             for j in range(i):
                 M = _data.add(M, self.scc[i][j]._call(t), dy[i]*dy[j])
-        temp = _data.matmul(M, state)
-        Mdag = M.adjoint()
-        out = _data.matmul(temp, Mdag)
-        for cop in self.c_ops:
-            op = cop._call(t)
-            out += op @ state @ op.adjoint() * dt
-        return out / _data.trace(out)
+        out = _data.matmul(M, state)
+        if self._issuper:
+            Mdag = M.adjoint()
+            out = _data.matmul(out, Mdag)
+            for cop in self.c_ops:
+                op = cop._call(t)
+                out += op @ state @ op.adjoint() * dt
+            out = out / _data.trace(out)
+        else:
+            out = out / _data.norm.l2(out)
+        return out
 
     @property
     def options(self):
@@ -135,4 +145,4 @@ def options(self, new_options):
         Integrator.options.fset(self, new_options)
 
 
-SMESolver.add_integrator(RouchonSODE, "rouchon")
+StochasticSolver.add_integrator(RouchonSODE, "rouchon")
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index ae1900e201..77b2981ef1 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -7,8 +7,6 @@ cdef class _StochasticSystem:
     cdef readonly object dims
     cdef Data state
     cdef double t
-    cdef object imp
-    cdef int _is_set
 
     cpdef Data drift(self, t, Data state)
 
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 1fcae1e4d9..e2d716a9ab 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -22,10 +22,7 @@ cdef Dense _dense_wrap(double complex [::1] x):
 
 cdef class _StochasticSystem:
     def __init__(self, a, b):
-        self.d1 = a
-        self.d2 = b
-        self.num_collapse = 1
-        self._is_set = False
+        raise NotImplementedError
 
     cpdef Data drift(self, t, Data state):
         raise NotImplementedError
@@ -34,9 +31,7 @@ cdef class _StochasticSystem:
         raise NotImplementedError
 
     cpdef void set_state(self, double t, Data state) except *:
-        self.t = t
-        self.state = state
-        self._is_set = True
+        raise NotImplementedError
 
     cpdef Data a(self):
         """
@@ -109,7 +104,6 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             self.H += -0.5 * c_op.dag() * c_op
         self.issuper = False
         self.dims = self.H.dims
-        self._is_set = False
 
     cpdef Data drift(self, t, Data state):
         cdef int i
@@ -138,96 +132,12 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             out.append(_data.add(_out, state, -0.5 * expect))
         return out
 
-    cpdef void set_state(self, double t, Data state) except *:
-        cdef n, l
-        self.t = t
-        self.state = _data.to(_data.Dense, state).reorder(fortran=1)
-        self._a_set = False
-        self._b_set = False
-        self._Lb_set = False
-
-        if self.num_collapse != 1:
-            raise NotImplementedError
-
-        if not self._is_set:
-            l = self.H.shape[0]
-            self._is_set = 1
-            self._a = dense.zeros(l, 1)
-            self.temp = dense.zeros(l, 1)
-            self._c_vec = dense.zeros(l, 1)
-            self._b_vec = dense.zeros(l, 1)
-            self._Lb = dense.zeros(l, 1)
-
-    cpdef Data a(self):
-        if not self._a_set:
-            self._compute_a()
-        return self._a
-
-    cdef void _compute_a(self) except *:
-        if not self._is_set:
-            raise RuntimeError
-        _data.imul_dense(self._a, 0)
-        self.H.matmul_data(self.t, self.state, self._a)
-
-        c_op = self.c_ops[0]
-        _data.imul_dense(self._c_vec, 0)
-        c_op.matmul_data(self.t, self.state, self._c_vec)
-        self._e = _data.inner_dense(self.state, self._c_vec).real
-        _data.iadd_dense(self._a, self.state,  -0.5 * self._e**2)
-        _data.iadd_dense(self._a, self._c_vec, self._e)
-
-        self._a_set = True
-
-    cpdef Data bi(self, int i):
-        if not self._b_set:
-            self._compute_b()
-        return self._b_vec
-
-    cdef void _compute_b(self) except *:
-        if not self._a_set:
-            self._compute_a()
-        cdef int i
-        cdef QobjEvo c_op
-        c_op = <QobjEvo> self.c_ops[0]
-        _data.imul_dense(self._b_vec, 0)
-        _data.iadd_dense(self._b_vec, self._c_vec)
-        _data.iadd_dense(self._b_vec, self.state, -self._e)
-        self._b_set = True
-
-    cpdef Data Libj(self, int i, int j):
-        if not self._Lb_set:
-            self._compute_Lb()
-        return self._Lb
-
-    cdef void _compute_Lb(self) except *:
-        cdef int i, j
-        cdef QobjEvo c_op
-        cdef Dense Lb_vec
-        cdef complex de_dx_b
-        if not self._b_set:
-            self._compute_b()
-
-        c_op = self.c_ops[0]
-        _data.imul_dense(self._Lb, 0)
-        _data.imul_dense(self.temp, 0)
-        c_op.matmul_data(self.t, self._c_vec, self.temp)
-        _data.iadd_dense(self._Lb, self.temp)
-        _data.iadd_dense(self._Lb, self._c_vec, -self._e)
-        de_dx_b = (
-            self._e * self._e
-            - _data.inner_dense(self._c_vec, self._c_vec).real
-            - _data.inner_dense(self.temp, self.state).real
-        )
-        _data.iadd_dense(self._Lb, self.state, de_dx_b)
-
-        self._Lb_set = True
-
-
 cdef class StochasticOpenSystem(_StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
     cdef int state_size
     cdef double dt
+    cdef int _is_set
     cdef bint _a_set, _b_set, _Lb_set, _L0b_set, _La_set, _LLb_set, _L0a_set
 
     cdef readonly Dense _a, temp, _L0a
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index 64849f39c0..440f9e28a7 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -4,7 +4,7 @@
 from qutip import qeye, destroy, QobjEvo, rand_ket, rand_herm, create, Qobj, operator_to_vector, fock_dm
 import qutip.solver.sode._sode as _sode
 import pytest
-from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticOpenSystem
+from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticOpenSystem, StochasticClosedSystem
 from qutip.solver.sode.noise import _Noise
 from qutip.solver.stochastic import SMESolver, StochasticRHS
 
@@ -126,7 +126,7 @@ def get_error_order_integrator(integrator, ref_integrator, state, plot=False):
     pytest.param("herm td", ["random"], ["destroy"], id='H td'),
     pytest.param("herm", ["random"], ["destroy td"], id='sc_ops td'),
 ])
-def test_integrator(method, order, H, c_ops, sc_ops):
+def test_open_integrator(method, order, H, c_ops, sc_ops):
     N = 5
     H = _make_oper(H, N)
     c_ops = [_make_oper(op, N) for op in c_ops]
@@ -139,3 +139,29 @@ def test_integrator(method, order, H, c_ops, sc_ops):
 
     error_order = get_error_order_integrator(sode, ref_sode, state)
     assert (order + 0.35) < error_order
+
+
+@pytest.mark.parametrize(["method", "order"], [
+    pytest.param("euler", 0.5, id="Euler"),
+    pytest.param("platen", 1.0, id="Platen"),
+    pytest.param("rouchon", 1.0, id="Rouchon"),
+])
+@pytest.mark.parametrize(['H', 'sc_ops'], [
+    pytest.param("qeye", ["destroy"], id='simple'),
+    pytest.param("herm", ["destroy", "destroy2"], id='2 sc_ops'),
+    pytest.param("herm", ["random"], id='random'),
+    pytest.param("herm td", ["destroy"], id='H td'),
+    pytest.param("herm", ["destroy td"], id='sc_ops td'),
+])
+def test_closed_integrator(method, order, H, sc_ops):
+    N = 5
+    H = _make_oper(H, N)
+    sc_ops = [_make_oper(op, N) for op in sc_ops]
+
+    rhs = StochasticRHS(StochasticClosedSystem, H, sc_ops, (), False)
+    ref_sode = SMESolver.avail_integrators()["explicit1.5"](rhs, {"dt": 0.01})
+    sode = SMESolver.avail_integrators()[method](rhs, {"dt": 0.01})
+    state = operator_to_vector(fock_dm(5, 3, dtype="Dense")).data
+
+    error_order = get_error_order_integrator(sode, ref_sode, state)
+    assert (order + 0.35) < error_order
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index ff1fc0ff26..bd74c31885 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -106,7 +106,7 @@ def _check_equivalence(f, target, args):
     assert power > 0.9
 
 
-def _run_derr_check(solver, state, all):
+def _run_derr_check(solver, state):
     """
 
     """
@@ -124,10 +124,6 @@ def _run_derr_check(solver, state, all):
                 L(solver, j, b), solver.Libj(j, i), (t, state)
             )
 
-    if not all:
-        # Most method only need the Libj term.
-        return
-
     _check_equivalence(L0(solver, a), solver.L0a(), (t, state))
 
     for i in range(N):
@@ -174,21 +170,4 @@ def test_open_system(H, c_ops, heterodyne):
     H = liouvillian(H)
     system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
     state = operator_to_vector(fock_dm(N, N-2)).data
-    _run_derr_check(system, state, True)
-
-
-@pytest.mark.parametrize(['H', 'c_ops'], [
-    pytest.param("qeye", ["destroy"], id='simple'),
-    pytest.param("tridiag", ["destroy"], id='tridiag'),
-    pytest.param("td", ["destroy"], id='H td'),
-    pytest.param("qeye", ["td"], id='c_ops td'),
-    pytest.param("rand", ["rand"], id='random'),
-])
-def test_closed_system(H, c_ops):
-    N = 5
-    H = _make_oper(H, N)
-    c_ops = [_make_oper(op, N) for op in c_ops]
-    system = StochasticClosedSystem(H, c_ops, heterodyne=False)
-    state = Qobj([1]*N).unit().data
-    all = False
-    _run_derr_check(system, state, False)
+    _run_derr_check(system, state)

From c860893bb95406b1ca8efd0a1c6be6f73499e8c8 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 8 Feb 2023 14:13:22 +0900
Subject: [PATCH 094/602] Updated __all__

---
 qutip/solver/result.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 087429230f..0cf5494b50 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -2,7 +2,7 @@
 import numpy as np
 from ..core import Qobj, QobjEvo, expect, qzero
 
-__all__ = ["Result", "MultiTrajResult", "McResult"]
+__all__ = ["Result", "MultiTrajResult", "McResult", "NmmcResult"]
 
 
 class _QobjExpectEop:

From 6ebe0e20e6cd439f40b011e00867b74589cb853f Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Fri, 24 Feb 2023 17:01:46 +0900
Subject: [PATCH 095/602] Added nm_mcsolve function associated with
 NonMarkovianMCSolver class

---
 qutip/solver/nm_mcsolve.py | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index b9afffc558..d759299682 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -5,7 +5,7 @@
 import scipy
 from .mcsolve import MCSolver
 from .result import Result, NmmcResult
-from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
+from ..core import CoreOptions, QobjEvo, isket, ket2dm, mesolve, MESolver, qeye
 
 
 def _2dm(q):
@@ -14,6 +14,27 @@ def _2dm(q):
     return q
 
 
+def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
+               options=None, seeds=None, target_tol=None, timeout=None):
+    if not isinstance(ops_and_rates, (list, tuple)):
+        ops_and_rates = [ops_and_rates]
+
+    if len(ops_and_rates) == 0:
+        if options is None:
+            options = {}
+        options = {
+            key: options[key]
+            for key in options
+            if key in MESolver.solver_options
+        }
+        return mesolve(H, state, tlist, e_ops=e_ops, options=options)
+
+    nmmc = NonMarkovianMCSolver(H, ops_and_rates, options=options)
+    result = nmmc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
+                      seed=seeds, target_tol=target_tol, timeout=timeout)
+    return result
+
+
 class NonMarkovianMCSolver(MCSolver):
     r"""
     Monte-Carlo solver for master equation with negative rates.

From 44999f08f7d0785f8659c995b78d1a3435b19de4 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Sat, 25 Feb 2023 07:10:18 +0900
Subject: [PATCH 096/602] Bugfix: wrong import

---
 qutip/solver/nm_mcsolve.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index d759299682..802a1c7154 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -4,8 +4,9 @@
 import numpy as np
 import scipy
 from .mcsolve import MCSolver
+from .mesolve import MESolver, mesolve
 from .result import Result, NmmcResult
-from ..core import CoreOptions, QobjEvo, isket, ket2dm, mesolve, MESolver, qeye
+from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
 
 
 def _2dm(q):

From faf8ccdb87415be27aa146c06dc55f0954ae04b9 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Sat, 25 Feb 2023 09:51:45 +0900
Subject: [PATCH 097/602] Added Users Guide for nm_mcsolve based on
 documentation provided by Brecht Donvil

---
 doc/apidoc/functions.rst              |   3 +
 doc/biblio.rst                        |   3 +
 doc/guide/dynamics/dynamics-monte.rst | 129 ++++++++++++++++++++++++--
 qutip/solver/nm_mcsolve.py            |   7 +-
 qutip/solver/result.py                |   3 +
 5 files changed, 136 insertions(+), 9 deletions(-)

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 78a06941b5..bdfc97df6e 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -144,6 +144,9 @@ Monte Carlo Evolution
 .. automodule:: qutip.solver.mcsolve
     :members: mcsolve
 
+.. automodule:: qutip.solver.nm_mcsolve
+    :members: nm_mcsolve
+
 
 Krylov Subspace Solver
 ----------------------
diff --git a/doc/biblio.rst b/doc/biblio.rst
index 7d3de972c4..b19a97ce94 100644
--- a/doc/biblio.rst
+++ b/doc/biblio.rst
@@ -71,3 +71,6 @@ Bibliography
 .. [NKanej]
 
     N Khaneja et. al. *Optimal control of coupled spin dynamics: Design of NMR pulse sequences by gradient ascent algorithms.* J. Magn. Reson. **172**, 296–305 (2005). :doi:`10.1016/j.jmr.2004.11.004`
+
+.. [Donvil22]
+    B. Donvil, P. Muratore-Ginanneschi, *Quantum trajectory framework for general time-local master equations*, Nat Commun **13**, 4140 (2022). :doi:`10.1038/s41467-022-31533-8`.
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index 9362bffa92..f0a82e16db 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -13,30 +13,30 @@ Introduction
 Where as the density matrix formalism describes the ensemble average over many identical realizations of a quantum system, the Monte Carlo (MC), or quantum-jump approach to wave function evolution, allows for simulating an individual realization of the system dynamics.  Here, the environment is continuously monitored, resulting in a series of quantum jumps in the system wave function, conditioned on the increase in information gained about the state of the system via the environmental measurements.  In general, this evolution is governed by the Schrödinger equation with a **non-Hermitian** effective Hamiltonian
 
 .. math::
-	:label: heff
+    :label: heff
 
-	H_{\rm eff}=H_{\rm sys}-\frac{i\hbar}{2}\sum_{i}C^{+}_{n}C_{n},
+    H_{\rm eff}=H_{\rm sys}-\frac{i\hbar}{2}\sum_{i}C^{+}_{n}C_{n},
 
 where again, the :math:`C_{n}` are collapse operators, each corresponding to a separate irreversible process with rate :math:`\gamma_{n}`.  Here, the strictly negative non-Hermitian portion of Eq. :eq:`heff` gives rise to a reduction in the norm of the wave function, that to first-order in a small time :math:`\delta t`, is given by :math:`\left<\psi(t+\delta t)|\psi(t+\delta t)\right>=1-\delta p` where
 
 .. math::
-	:label: jump
+    :label: jump
 
-	\delta p =\delta t \sum_{n}\left<\psi(t)|C^{+}_{n}C_{n}|\psi(t)\right>,
+    \delta p =\delta t \sum_{n}\left<\psi(t)|C^{+}_{n}C_{n}|\psi(t)\right>,
 
 and :math:`\delta t` is such that :math:`\delta p \ll 1`.  With a probability of remaining in the state :math:`\left|\psi(t+\delta t)\right>` given by :math:`1-\delta p`, the corresponding quantum jump probability is thus Eq. :eq:`jump`.  If the environmental measurements register a quantum jump, say via the emission of a photon into the environment, or a change in the spin of a quantum dot, the wave function undergoes a jump into a state defined by projecting :math:`\left|\psi(t)\right>` using the collapse operator :math:`C_{n}` corresponding to the measurement
 
 .. math::
-	:label: project
+    :label: project
 
-	\left|\psi(t+\delta t)\right>=C_{n}\left|\psi(t)\right>/\left<\psi(t)|C_{n}^{+}C_{n}|\psi(t)\right>^{1/2}.
+    \left|\psi(t+\delta t)\right>=C_{n}\left|\psi(t)\right>/\left<\psi(t)|C_{n}^{+}C_{n}|\psi(t)\right>^{1/2}.
 
 If more than a single collapse operator is present in Eq. :eq:`heff`, the probability of collapse due to the :math:`i\mathrm{th}`-operator :math:`C_{i}` is given by
 
 .. math::
-	:label: pcn
+    :label: pcn
 
-	P_{i}(t)=\left<\psi(t)|C_{i}^{+}C_{i}|\psi(t)\right>/\delta p.
+    P_{i}(t)=\left<\psi(t)|C_{i}^{+}C_{i}|\psi(t)\right>/\delta p.
 
 Evaluating the MC evolution to first-order in time is quite tedious.  Instead, QuTiP uses the following algorithm to simulate a single realization of a quantum system.  Starting from a pure state :math:`\left|\psi(0)\right>`:
 
@@ -236,6 +236,119 @@ For example, the following code block plots expectation values for 1, 10 and 100
     plt.legend()
     plt.show()
 
+
+
+.. _monte-nonmarkov:
+
+Monte Carlo for Non-Markovian Dynamics
+--------------------------------------
+
+The Monte Carlo solver of QuTiP can also be used to solve the dynamics of time-local non-Markovian master equations, i.e., master equations of the Lindblad form
+
+.. math::
+    :label: lindblad_master_equation_with_rates
+
+    \dot\rho(t) = -\frac{i}{\hbar} [H, \rho(t)] + \sum_n \frac{\gamma_n(t)}{2} \left[2 A_n \rho(t) A_n^\dagger - \rho(t) A_n^\dagger A_n - A_n^\dagger A_n \rho(t)\right]
+
+with "rates" :math:`\gamma_n(t)` that can take negative values.
+This can be done with the :func:`qutip.nm_mcsolve` function.
+The function is based on the influence martingale formalism [Donvil22]_ and formally requires that the collapse operators :math:`A_n` satisfy a completeness relation of the form
+
+.. math::
+    :label: nmmcsolve_completeness
+
+    \sum_n A_n^\dagger A_n = \alpha \mathbb{I} ,
+
+where :math:`\mathbb{I}` is the identity operator on the system Hilbert space and :math:`\alpha>0`.
+Note that when the collapse operators of a model don't satisfy such a relation, ``qutip.nm_mcsolve`` automatically adds an extra collapse operator such that :eq:`nmmcsolve_completeness` is satisfied.
+The rate corresponding to this extra collapse operator is set to zero.
+
+Technically, the influence martingale formalism works as follows.
+We introduce an influence martingale :math:`\mu(t)`, which follows the evolution of the system state.
+When no jump happens, it evolves as
+
+.. math::
+    :label: influence_cont
+
+    \mu(t) = \exp\left( \alpha\int_0^t K(\tau) d\tau \right)
+
+where :math:`K(t)` is for now an arbitrary function.
+When a jump corresponding to the collapse operator :math:`A_n` happens, the influence martingale becomes
+
+.. math::
+    :label: influence_disc
+
+    \mu(t+\delta t) = \mu(t)\left(\frac{K(t)-\gamma_n(t)}{\gamma_n(t)}\right)
+
+Assuming that the state :math:`\bar\rho(t)` computed by the Monte Carlo average
+
+.. math::
+    :label: mc_paired_state
+
+    \bar\rho(t) = \frac{1}{N}\sum_{l=1}^N |\psi_l(t)\rangle\langle \psi_l(t)|
+
+solves a Lindblad master equation with collapse operators :math:`A_n` and rates :math:`\Gamma_n(t)`, the state :math:`\rho(t)` defined by
+
+.. math::
+    :label: mc_martingale_state
+
+    \rho(t) = \frac{1}{N}\sum_{l=1}^N \mu_l(t) |\psi_l(t)\rangle\langle \psi_l(t)|
+
+solves a Lindblad master equation with collapse operators :math:`A_n` and shifted rates :math:`\gamma_n(t)-K(t)`.
+Thus, while :math:`\Gamma_n(t) \geq 0`, the new "rates" :math:`\gamma_n(t) = \Gamma_n(t) - K(t)` satisfy no positivity requirement.
+
+The input of :func:`qutip.nm_mcsolve` is almost the same as for :func:`qutip.mcsolve`.
+The only difference is how the collapse operators and rate functions should be defined.
+``nm_mcsolve`` requires collapse operators :math:`A_n` and target "rates" :math:`\gamma_n` (which are allowed to take negative values) to be given in list form ``[[C_1, gamma_1], [C_2, gamma_2], ...]``.
+Note that we give the actual rate and not its square root, and that ``nm_mcsolve`` automatically computes associated jump rates :math:`\Gamma_n(t)\geq0` appropriate for simulation.
+
+We conclude with a simple example demonstrating the usage of the ``nm_mcsolve`` function.
+For more elaborate, physically motivated examples, we refer to example notebook 1 [TODO] and example notebook 2 [TODO].
+
+
+.. plot::
+    :context: reset
+
+    import qutip as qt
+    import numpy as np
+
+    times = np.linspace(0, 1, 201)
+    psi0 = qt.basis(2, 1)
+    a0 = qt.destroy(2)
+    H = a0.dag() * a0
+
+    # Rate functions
+    kappa = 1.0 / 0.129
+    nth = 0.063
+    def gamma1(t):
+            return kappa * nth
+    def gamma2(t): # becomes negative at times
+            return kappa * (nth+1) + 12 * np.exp(-2*t**3) * (-np.sin(15*t)**2)
+
+    # nm_mcsolve integration
+    ops_and_rates = []
+    ops_and_rates.append( [a0.dag(), gamma1] )
+    ops_and_rates.append( [a0,       gamma2] )
+    MCSol = qt.nm_mcsolve(H, psi0, times, ops_and_rates,
+                          e_ops=[a0.dag() * a0, a0 * a0.dag()], ntraj=2500)
+
+    # mesolve integration for comparison
+    d_ops = [[qt.lindblad_dissipator(a0.dag(), a0.dag()), gamma1],
+             [qt.lindblad_dissipator(a0, a0),             gamma2]]
+    MESol = qt.mesolve(H, psi0, times, d_ops, e_ops=[a0.dag() * a0, a0 * a0.dag()])
+
+    plt.figure()
+    plt.plot(times, MCSol.expect[0], 'g', times, MCSol.expect[1], 'b', times, MCSol.trace, 'r')
+    plt.plot(times, MESol.expect[0], 'g--', times, MESol.expect[1], 'b--')
+    plt.title('Monte Carlo time evolution')
+    plt.xlabel('Time')
+    plt.ylabel('Expectation values')
+    plt.legend((r'$\langle 1 | \rho | 1 \rangle$',
+                r'$\langle 0 | \rho | 0 \rangle$',
+                r'$\operatorname{tr} \rho$'))
+    plt.show()
+
+
 .. plot::
     :context: reset
     :include-source: false
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 802a1c7154..a3bbf47ba0 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -1,4 +1,4 @@
-__all__ = ['NonMarkovianMCSolver']
+__all__ = ['nm_mcsolve', 'NonMarkovianMCSolver']
 
 from functools import partial
 import numpy as np
@@ -17,6 +17,9 @@ def _2dm(q):
 
 def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
                options=None, seeds=None, target_tol=None, timeout=None):
+    r"""
+    TODO
+    """
     if not isinstance(ops_and_rates, (list, tuple)):
         ops_and_rates = [ops_and_rates]
 
@@ -40,6 +43,8 @@ class NonMarkovianMCSolver(MCSolver):
     r"""
     Monte-Carlo solver for master equation with negative rates.
     Based on the methods explained in arXiv:2209.08958 [quant-ph]
+
+    TODO
     """
     name = "nm_mcsolve"
     resultclass = NmmcResult
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 0cf5494b50..4043f5c7f5 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -973,6 +973,9 @@ def runs_photocurrent(self):
 
 
 class NmmcResult(McResult):
+    r"""
+    TODO
+    """
     def _add_trace(self, trajectory):
         new_trace = np.array(trajectory.trace)
         self._sum_trace += new_trace

From 7127405d62e47b871986fcb41b0941a6aac9f9d0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 27 Feb 2023 15:32:42 -0500
Subject: [PATCH 098/602] opt

---
 qutip/solve/_stochastic.pyx   |  2 +-
 qutip/solver/sode/ssystem.pyx | 86 ++++++++++++++++++++---------------
 2 files changed, 50 insertions(+), 38 deletions(-)

diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
index c2cac5416c..a13152e292 100644
--- a/qutip/solve/_stochastic.pyx
+++ b/qutip/solve/_stochastic.pyx
@@ -537,7 +537,7 @@ cdef class StochasticSolver:
         return states_list, noise, measurements, expect
 
     @cython.boundscheck(False)
-    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
+    cpdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
                           complex[::1] vec, int num_substeps):
         """ Do one time full step"""
         cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index e2d716a9ab..0f1f71a080 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -5,7 +5,8 @@ Class to represent a stochastic differential equation system.
 
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.data cimport Data, dense, Dense
+from qutip.core.data cimport Data, dense, Dense, imul_dense, iadd_dense
+from qutip.core.data.trace cimport trace_oper_ket_dense
 cimport cython
 import numpy as np
 from qutip.core import spre, spost, liouvillian
@@ -132,6 +133,7 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             out.append(_data.add(_out, state, -0.5 * expect))
         return out
 
+
 cdef class StochasticOpenSystem(_StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
@@ -140,11 +142,11 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef int _is_set
     cdef bint _a_set, _b_set, _Lb_set, _L0b_set, _La_set, _LLb_set, _L0a_set
 
-    cdef readonly Dense _a, temp, _L0a
-    cdef readonly complex[::1] expect_Cv
-    cdef readonly complex[:, ::1] expect_Cb, _b, _La, _L0b
-    cdef readonly complex[:, :, ::1] _Lb
-    cdef readonly complex[:, :, :, ::1] _LLb
+    cdef Dense _a, temp, _L0a
+    cdef complex[::1] expect_Cv
+    cdef complex[:, ::1] expect_Cb, _b, _La, _L0b
+    cdef complex[:, :, ::1] _Lb
+    cdef complex[:, :, :, ::1] _LLb
 
     def __init__(self, H, sc_ops, c_ops=(), heterodyne=False):
         if H.issuper:
@@ -217,10 +219,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self._compute_a()
         return self._a
 
-    cdef void _compute_a(self) except *:
+    cdef void _compute_a(StochasticOpenSystem self) except *:
         if not self._is_set:
             raise RuntimeError
-        _data.imul_dense(self._a, 0)
+        imul_dense(self._a, 0)
         self.L.matmul_data(self.t, self.state, self._a)
         self._a_set = True
 
@@ -229,6 +231,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self._compute_b()
         return _dense_wrap(self._b[i, :])
 
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
     cdef void _compute_b(self) except *:
         if not self._is_set:
             raise RuntimeError
@@ -238,10 +242,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         for i in range(self.num_collapse):
             c_op = <QobjEvo> self.c_ops[i]
             b_vec = <Dense> _dense_wrap(self._b[i, :])
-            _data.imul_dense(b_vec, 0)
+            imul_dense(b_vec, 0)
             c_op.matmul_data(self.t, self.state, b_vec)
-            self.expect_Cv[i] = _data.trace_oper_ket_dense(b_vec)
-            _data.iadd_dense(b_vec, self.state, -self.expect_Cv[i])
+            self.expect_Cv[i] = trace_oper_ket_dense(b_vec)
+            iadd_dense(b_vec, self.state, -self.expect_Cv[i])
         self._b_set = True
 
     cpdef Data Libj(self, int i, int j):
@@ -252,6 +256,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             j, i = i, j
         return _dense_wrap(self._Lb[i, j, :])
 
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
     cdef void _compute_Lb(self) except *:
         cdef int i, j
         cdef QobjEvo c_op
@@ -265,11 +271,11 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             for j in range(i, self.num_collapse):
                 b_vec = <Dense> _dense_wrap(self._b[j, :])
                 Lb_vec = <Dense> _dense_wrap(self._Lb[i, j, :])
-                _data.imul_dense(Lb_vec, 0)
+                imul_dense(Lb_vec, 0)
                 c_op.matmul_data(self.t, b_vec, Lb_vec)
-                self.expect_Cb[i,j] = _data.trace_oper_ket_dense(Lb_vec)
-                _data.iadd_dense(Lb_vec, b_vec, -self.expect_Cv[i])
-                _data.iadd_dense(Lb_vec, self.state, -self.expect_Cb[i,j])
+                self.expect_Cb[i,j] = trace_oper_ket_dense(Lb_vec)
+                iadd_dense(Lb_vec, b_vec, -self.expect_Cv[i])
+                iadd_dense(Lb_vec, self.state, -self.expect_Cb[i,j])
         self._Lb_set = True
 
     cpdef Data Lia(self, int i):
@@ -277,6 +283,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self._compute_La()
         return _dense_wrap(self._La[i, :])
 
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
     cdef void _compute_La(self) except *:
         cdef int i
         cdef QobjEvo c_op
@@ -287,7 +295,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         for i in range(self.num_collapse):
             b_vec = <Dense> _dense_wrap(self._b[i, :])
             La_vec = <Dense> _dense_wrap(self._La[i, :])
-            _data.imul_dense(La_vec, 0.)
+            imul_dense(La_vec, 0.)
             self.L.matmul_data(self.t, b_vec, La_vec)
         self._La_set = True
 
@@ -297,6 +305,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self._compute_L0b()
         return _dense_wrap(self._L0b[i, :])
 
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
     cdef void _compute_L0b(self) except *:
         cdef int i, j
         cdef QobjEvo c_op
@@ -310,30 +320,30 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             c_op = <QobjEvo> self.c_ops[i]
             L0b_vec = <Dense> _dense_wrap(self._L0b[i, :])
             b_vec = <Dense> _dense_wrap(self._b[i, :])
-            _data.imul_dense(L0b_vec, 0.)
+            imul_dense(L0b_vec, 0.)
 
             # db/dt
             c_op.matmul_data(self.t + self.dt, self.state, L0b_vec)
-            expect = _data.trace_oper_ket_dense(L0b_vec)
-            _data.iadd_dense(L0b_vec, self.state, -expect)
-            _data.iadd_dense(L0b_vec, b_vec, -1)
-            _data.imul_dense(L0b_vec, 1/self.dt)
+            expect = trace_oper_ket_dense(L0b_vec)
+            iadd_dense(L0b_vec, self.state, -expect)
+            iadd_dense(L0b_vec, b_vec, -1)
+            imul_dense(L0b_vec, 1/self.dt)
 
             # ab'
-            _data.imul_dense(self.temp, 0)
+            imul_dense(self.temp, 0)
             c_op.matmul_data(self.t, self._a, self.temp)
-            expect = _data.trace_oper_ket_dense(self.temp)
-            _data.iadd_dense(L0b_vec, self.temp, 1)
-            _data.iadd_dense(L0b_vec, self._a, -self.expect_Cv[i])
-            _data.iadd_dense(L0b_vec, self.state, -expect)
+            expect = trace_oper_ket_dense(self.temp)
+            iadd_dense(L0b_vec, self.temp, 1)
+            iadd_dense(L0b_vec, self._a, -self.expect_Cv[i])
+            iadd_dense(L0b_vec, self.state, -expect)
 
             # bbb" : expect_Cb[i,j] only defined for j>=i
             for j in range(i):
                 b_vec = <Dense> _dense_wrap(self._b[j, :])
-                _data.iadd_dense(L0b_vec, b_vec, -self.expect_Cb[j,i])
+                iadd_dense(L0b_vec, b_vec, -self.expect_Cb[j,i])
             for j in range(i, self.num_collapse):
                 b_vec = <Dense> _dense_wrap(self._b[j, :])
-                _data.iadd_dense(L0b_vec, b_vec, -self.expect_Cb[i,j])
+                iadd_dense(L0b_vec, b_vec, -self.expect_Cb[i,j])
         self._L0b_set = True
 
     cpdef Data LiLjbk(self, int i, int j, int k):
@@ -350,6 +360,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
         return _dense_wrap(self._LLb[i, j, k, :])
 
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
     cdef void _compute_LLb(self) except *:
         # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
         # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
@@ -367,15 +379,15 @@ cdef class StochasticOpenSystem(_StochasticSystem):
                 Lb_vec = <Dense> _dense_wrap(self._Lb[j, k, :])
                 bj_vec = <Dense> _dense_wrap(self._b[j, :])
                 bk_vec = <Dense> _dense_wrap(self._b[k, :])
-                _data.imul_dense(LLb_vec, 0.)
+                imul_dense(LLb_vec, 0.)
 
                 c_op.matmul_data(self.t, Lb_vec, LLb_vec)
-                expect = _data.trace_oper_ket_dense(LLb_vec)
+                expect = trace_oper_ket_dense(LLb_vec)
 
-                _data.iadd_dense(LLb_vec, Lb_vec, -self.expect_Cv[i])
-                _data.iadd_dense(LLb_vec, self.state, -expect)
-                _data.iadd_dense(LLb_vec, bj_vec, -self.expect_Cb[i,k])
-                _data.iadd_dense(LLb_vec, bk_vec, -self.expect_Cb[i,j])
+                iadd_dense(LLb_vec, Lb_vec, -self.expect_Cv[i])
+                iadd_dense(LLb_vec, self.state, -expect)
+                iadd_dense(LLb_vec, bj_vec, -self.expect_Cb[i,k])
+                iadd_dense(LLb_vec, bk_vec, -self.expect_Cb[i,j])
 
         self._LLb_set = True
 
@@ -387,10 +399,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
     cdef void _compute_L0a(self) except *:
         # L0a = a'a + da/dt + bba"/2  (a" = 0)
-        _data.imul_dense(self._L0a, 0.)
+        imul_dense(self._L0a, 0.)
         self.L.matmul_data(self.t + self.dt, self.state, self._L0a)
-        _data.iadd_dense(self._L0a, self._a, -1)
-        _data.imul_dense(self._L0a, 1/self.dt)
+        iadd_dense(self._L0a, self._a, -1)
+        imul_dense(self._L0a, 1/self.dt)
         self.L.matmul_data(self.t, self._a, self._L0a)
         self._L0a_set = True
 

From c23e25c27b929e6bf074a3d5b421ac13af6830a4 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Tue, 28 Feb 2023 13:54:35 +0900
Subject: [PATCH 099/602] Renamed trajectoryclass -> trajectory_resultclass

---
 qutip/solver/mcsolve.py    |  4 ++--
 qutip/solver/multitraj.py  |  4 ++--
 qutip/solver/nm_mcsolve.py | 10 ++++++----
 qutip/solver/result.py     |  4 ++--
 4 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 48150c4555..6f99e79c03 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -4,7 +4,7 @@
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
 from .multitraj import MultiTrajSolver
 from .solver_base import Solver, Integrator
-from .result import McResult, McTrajectory
+from .result import McResult, McTrajectoryResult
 from .mesolve import mesolve, MESolver
 import qutip.core.data as _data
 from time import time
@@ -347,7 +347,7 @@ class MCSolver(MultiTrajSolver):
     """
     name = "mcsolve"
     resultclass = McResult
-    trajectoryclass = McTrajectory
+    trajectory_resultclass = McTrajectoryResult
     solver_options = {
         "progress_bar": "text",
         "progress_kwargs": {"chunk_size": 10},
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 08f49b1494..de06a19325 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -28,7 +28,7 @@ class MultiTrajSolver(Solver):
     """
     name = "generic multi trajectory"
     resultclass = MultiTrajResult
-    trajectoryclass = Result
+    trajectory_resultclass = Result
     _avail_integrators = {}
 
     # Class of option used by the solver
@@ -197,7 +197,7 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         """
         Run one trajectory and return the result.
         """
-        result = self.trajectoryclass(e_ops, self.options)
+        result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
         result.add(tlist[0], self._restore_state(state, copy=False))
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index c0e7646f04..d547d4e86b 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -4,7 +4,7 @@
 import numpy as np
 import scipy
 from .mcsolve import MCSolver
-from .result import NmmcResult, NmmcTrajectory
+from .result import NmmcResult, NmmcTrajectoryResult
 from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
 
 
@@ -15,18 +15,20 @@ class NonMarkovianMCSolver(MCSolver):
     """
     name = "nm_mcsolve"
     resultclass = NmmcResult
-    # "solver" argument will be partially initialized in constructor
-    trajectoryclass = NmmcTrajectory
     solver_options = {
         **MCSolver.solver_options,
         "completeness_rtol": 1e-5,
         "completeness_atol": 1e-8,
     }
 
+    # "solver" argument will be partially initialized in constructor
+    trajectory_resultclass = NmmcTrajectoryResult
+
     # ops_and_rates is a list of tuples (L_i, Gamma_i),
     #     where Gamma_i = Gamma_i(t) is callable
     def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
-        self.trajectoryclass = partial(NmmcTrajectory, solver=self)
+        self.trajectory_resultclass = partial(NmmcTrajectoryResult,
+                                              solver=self)
 
         self.ops_and_rates = list(ops_and_rates)
         self.options = options
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 8d94bbdb52..e11ad96735 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -866,7 +866,7 @@ def __add__(self, other):
         return new
 
 
-class McTrajectory(Result):
+class McTrajectoryResult(Result):
     def __init__(self, e_ops, options, *args, **kwargs):
         super().__init__(e_ops, {**options, "normalize_output": False},
                          *args, **kwargs)
@@ -978,7 +978,7 @@ def runs_photocurrent(self):
         return measurements
 
 
-class NmmcTrajectory(McTrajectory):
+class NmmcTrajectoryResult(McTrajectoryResult):
     def __init__(self, e_ops, options, solver, *args, **kwargs):
         super().__init__(e_ops, options, *args, **kwargs)
 

From e3812191119c15c311c4811aa2c501c3b7796125 Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Wed, 1 Mar 2023 01:45:19 +0530
Subject: [PATCH 100/602] added __all__ to file, fix #2101

---
 qutip/core/semidefinite.py | 17 +++++++++++++++++
 qutip/measurement.py       |  9 +++++++++
 2 files changed, 26 insertions(+)

diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index ba96aeec23..0c5774fd51 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -4,6 +4,23 @@
 This module implements internal-use functions for semidefinite programming.
 """
 
+__all__ = [
+    'complex_var',
+    'herm',
+    'pos_noherm',
+    'pos',
+    'dens',
+    'kron',
+    'conj',
+    'bmat',
+    'dag',
+    'memoize',
+    'qudit_swap',
+    'initialize_constraints_on_dnorm_problem',
+    'dnorm_problem',
+    'dnorm_sparse_problem',
+]
+
 import collections
 import functools
 
diff --git a/qutip/measurement.py b/qutip/measurement.py
index 0211180a73..da90387dd0 100644
--- a/qutip/measurement.py
+++ b/qutip/measurement.py
@@ -2,6 +2,15 @@
 Module for measuring quantum objects.
 """
 
+__all__ = [
+    'measurement_statistics_povm',
+    'measurement_statistics_observable',
+    'measure_observable',
+    'measure_povm',
+    'measurement_statistics',
+    'measure'
+]
+
 import numpy as np
 
 from . import Qobj, expect, identity, tensor

From 7f13330130bc9506b849bdd6dc759b591c9cf0dc Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Feb 2023 17:05:00 -0500
Subject: [PATCH 101/602] Optimized milstein

---
 qutip/core/data/mul.pyx                      | 18 +++---
 qutip/solve/_stochastic.pyx                  |  2 +-
 qutip/solver/sode/_sode.pyx                  | 66 ++++++++++----------
 qutip/solver/sode/ssystem.pxd                |  3 +-
 qutip/solver/sode/ssystem.pyx                | 31 +++++----
 qutip/tests/solver/test_stochastic_system.py |  2 +-
 6 files changed, 68 insertions(+), 54 deletions(-)

diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 27d8e47663..7de377fcf2 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -2,6 +2,13 @@
 #cython: boundscheck=False, wrapround=False, initializedcheck=False
 
 from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
+from scipy.linalg.cython_blas cimport zscal
+
+cdef int ZERO=0
+cdef double DZERO=0
+cdef complex ZZERO=0j
+cdef complex ZNEG=-1
+cdef int ONE=1
 
 __all__ = [
     'mul', 'mul_csr', 'mul_dense',
@@ -12,10 +19,8 @@ __all__ = [
 
 cpdef CSR imul_csr(CSR matrix, double complex value):
     """Multiply this CSR `matrix` by a complex scalar `value`."""
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            matrix.data[ptr] *= value
+    cdef idxint l = csr.nnz(matrix)
+    zscal(&l, &value, matrix.data, &ONE)
     return matrix
 
 cpdef CSR mul_csr(CSR matrix, double complex value):
@@ -42,9 +47,8 @@ cpdef CSR neg_csr(CSR matrix):
 cpdef Dense imul_dense(Dense matrix, double complex value):
     """Multiply this Dense `matrix` by a complex scalar `value`."""
     cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-            matrix.data[ptr] *= value
+    cdef idxint l = matrix.shape[0]*matrix.shape[1]
+    zscal(&l, &value, matrix.data, &ONE)
     return matrix
 
 cpdef Dense mul_dense(Dense matrix, double complex value):
diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
index a13152e292..ea1c7497ae 100644
--- a/qutip/solve/_stochastic.pyx
+++ b/qutip/solve/_stochastic.pyx
@@ -1657,7 +1657,7 @@ cdef class SMESolver(StochasticSolver):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
+    cpdef complex expect(self, complex[::1] rho):
         cdef complex e = 0.
         cdef int k
         for k in range(self.N_root):
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index d86102c448..884f15ef3d 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -2,7 +2,7 @@
 
 from qutip.core import data as _data
 from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.data cimport Data, Dense
+from qutip.core.data cimport Data, Dense, imul_dense, iadd_dense
 from collections import defaultdict
 cimport cython
 from qutip.solver.sode.ssystem cimport _StochasticSystem
@@ -18,11 +18,11 @@ cdef class Euler:
     @cython.wraparound(False)
     def run(
         self, double t, Data state, double dt,
-        double[:, :, ::1] dW, int ntraj
+        double[:, :, ::1] dW, int num_step
     ):
         cdef int i
         cdef Data out
-        for i in range(ntraj):
+        for i in range(num_step):
             state = self.step(t + i * dt, state, dt, dW[i, :, :])
         return state
 
@@ -260,12 +260,12 @@ cdef class Milstein:
 
         system.set_state(t, state)
 
-        _data.imul_dense(out, 0.)
-        _data.iadd_dense(out, state, 1)
-        _data.iadd_dense(out, system.a(), dt)
+        imul_dense(out, 0.)
+        iadd_dense(out, state, 1)
+        iadd_dense(out, system.a(), dt)
 
         for i in range(num_ops):
-            _data.iadd_dense(out, system.bi(i), dW[0, i])
+            iadd_dense(out, system.bi(i), dW[0, i])
 
         for i in range(num_ops):
             for j in range(i, num_ops):
@@ -273,7 +273,7 @@ cdef class Milstein:
                     dw = (dW[0, i] * dW[0, j] - dt) * 0.5
                 else:
                     dw = dW[0, i] * dW[0, j]
-                _data.iadd_dense(out, system.Libj(i, j), dw)
+                iadd_dense(out, system.Libj(i, j), dw)
 
 
 cdef class PredCorr:
@@ -318,26 +318,26 @@ cdef class PredCorr:
 
         system.set_state(t, state)
 
-        _data.imul_dense(out, 0.)
-        _data.iadd_dense(out, state, 1)
-        _data.iadd_dense(out, system.a(), dt * (1-alpha))
+        imul_dense(out, 0.)
+        iadd_dense(out, state, 1)
+        iadd_dense(out, system.a(), dt * (1-alpha))
 
-        _data.imul_dense(euler, 0.)
-        _data.iadd_dense(euler, state, 1)
-        _data.iadd_dense(euler, system.a(), dt)
+        imul_dense(euler, 0.)
+        iadd_dense(euler, state, 1)
+        iadd_dense(euler, system.a(), dt)
 
         for i in range(num_ops):
-            _data.iadd_dense(euler, system.bi(i), dW[0, i])
-            _data.iadd_dense(out, system.bi(i), dW[0, i] * eta)
-            _data.iadd_dense(out, system.Libj(i, i), dt * (alpha-1) * 0.5)
+            iadd_dense(euler, system.bi(i), dW[0, i])
+            iadd_dense(out, system.bi(i), dW[0, i] * eta)
+            iadd_dense(out, system.Libj(i, i), dt * (alpha-1) * 0.5)
 
         system.set_state(t+dt, euler)
         if alpha:
-            _data.iadd_dense(out, system.a(), dt*alpha)
+            iadd_dense(out, system.a(), dt*alpha)
 
         for i in range(num_ops):
-            _data.iadd_dense(out, system.bi(i), dW[0, i] * (1-eta))
-            _data.iadd_dense(out, system.Libj(i, i), -dt * alpha * 0.5)
+            iadd_dense(out, system.bi(i), dW[0, i] * (1-eta))
+            iadd_dense(out, system.Libj(i, i), -dt * alpha * 0.5)
 
         return out
 
@@ -373,24 +373,24 @@ cdef class Taylor15(Milstein):
         dw = dW[0, :]
         dz = 0.5 * (dW[0, :] + dW[1, :] / np.sqrt(3)) * dt
 
-        _data.imul_dense(out, 0.)
-        _data.iadd_dense(out, state, 1)
-        _data.iadd_dense(out, system.a(), dt)
-        _data.iadd_dense(out, system.L0a(), 0.5 * dt * dt)
+        imul_dense(out, 0.)
+        iadd_dense(out, state, 1)
+        iadd_dense(out, system.a(), dt)
+        iadd_dense(out, system.L0a(), 0.5 * dt * dt)
 
         for i in range(num_ops):
-            _data.iadd_dense(out, system.bi(i), dw[i])
-            _data.iadd_dense(out, system.Libj(i, i), 0.5 * (dw[i] * dw[i] - dt))
-            _data.iadd_dense(out, system.Lia(i), dz[i])
-            _data.iadd_dense(out, system.L0bi(i), dw[i] * dt - dz[i])
-            _data.iadd_dense(out, system.LiLjbk(i, i, i),
+            iadd_dense(out, system.bi(i), dw[i])
+            iadd_dense(out, system.Libj(i, i), 0.5 * (dw[i] * dw[i] - dt))
+            iadd_dense(out, system.Lia(i), dz[i])
+            iadd_dense(out, system.L0bi(i), dw[i] * dt - dz[i])
+            iadd_dense(out, system.LiLjbk(i, i, i),
                              0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i])
 
             for j in range(i+1, num_ops):
-                _data.iadd_dense(out, system.Libj(i, j), dw[i] * dw[j])
-                _data.iadd_dense(out, system.LiLjbk(i, j, j), 0.5 * (dw[j] * dw[j] -dt) * dw[i])
-                _data.iadd_dense(out, system.LiLjbk(i, i, j), 0.5 * (dw[i] * dw[i] -dt) * dw[j])
+                iadd_dense(out, system.Libj(i, j), dw[i] * dw[j])
+                iadd_dense(out, system.LiLjbk(i, j, j), 0.5 * (dw[j] * dw[j] -dt) * dw[i])
+                iadd_dense(out, system.LiLjbk(i, i, j), 0.5 * (dw[i] * dw[i] -dt) * dw[j])
                 for k in range(j+1, num_ops):
-                    _data.iadd_dense(out, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
+                    iadd_dense(out, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
 
         return out
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index 77b2981ef1..8be43118a1 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -12,7 +12,8 @@ cdef class _StochasticSystem:
 
     cpdef list diffusion(self, t, Data state)
 
-    cpdef void set_state(self, double t, Data state) except *
+    cpdef void set_state(self, double t, Dense state) except *
+
     cpdef Data a(self)
     cpdef Data bi(self, int i)
     cpdef Data Libj(self, int i, int j)
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 0f1f71a080..c8f070f37c 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -31,7 +31,7 @@ cdef class _StochasticSystem:
     cpdef list diffusion(self, t, Data state):
         raise NotImplementedError
 
-    cpdef void set_state(self, double t, Data state) except *:
+    cpdef void set_state(self, double t, Dense state) except *:
         raise NotImplementedError
 
     cpdef Data a(self):
@@ -137,7 +137,7 @@ cdef class StochasticClosedSystem(_StochasticSystem):
 cdef class StochasticOpenSystem(_StochasticSystem):
     cdef QobjEvo L
     cdef list c_ops
-    cdef int state_size
+    cdef int state_size, N_root
     cdef double dt
     cdef int _is_set
     cdef bint _a_set, _b_set, _Lb_set, _L0b_set, _La_set, _LLb_set, _L0a_set
@@ -170,6 +170,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self.dims = self.L.dims
         self.state_size = self.L.shape[1]
         self._is_set = 0
+        self.N_root = <int> self.state_size**0.5
 
     cpdef Data drift(self, t, Data state):
         return self.L.matmul_data(t, state)
@@ -186,10 +187,12 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             out.append(_data.add(vec, state, -expect))
         return out
 
-    cpdef void set_state(self, double t, Data state) except *:
+    cpdef void set_state(self, double t, Dense state) except *:
         cdef n, l
         self.t = t
-        self.state = _data.to(_data.Dense, state).reorder(fortran=1)
+        if not state.fortran:
+            state = state.reorder(fortran=1)
+        self.state = state
         self._a_set = False
         self._b_set = False
         self._Lb_set = False
@@ -215,6 +218,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self.dt = 1e-6  #  Make an options
 
     cpdef Data a(self):
+        if not self._is_set:
+            raise RuntimeError
         if not self._a_set:
             self._compute_a()
         return self._a
@@ -227,6 +232,8 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self._a_set = True
 
     cpdef Data bi(self, int i):
+        if not self._is_set:
+            raise RuntimeError
         if not self._b_set:
             self._compute_b()
         return _dense_wrap(self._b[i, :])
@@ -238,17 +245,19 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             raise RuntimeError
         cdef int i
         cdef QobjEvo c_op
-        cdef Dense b_vec
+        cdef Dense b_vec, state=self.state
         for i in range(self.num_collapse):
             c_op = <QobjEvo> self.c_ops[i]
             b_vec = <Dense> _dense_wrap(self._b[i, :])
             imul_dense(b_vec, 0)
-            c_op.matmul_data(self.t, self.state, b_vec)
+            c_op.matmul_data(self.t, state, b_vec)
             self.expect_Cv[i] = trace_oper_ket_dense(b_vec)
-            iadd_dense(b_vec, self.state, -self.expect_Cv[i])
+            iadd_dense(b_vec, state, -self.expect_Cv[i])
         self._b_set = True
 
     cpdef Data Libj(self, int i, int j):
+        if not self._is_set:
+            raise RuntimeError
         if not self._Lb_set:
             self._compute_Lb()
         # We only support commutative diffusion
@@ -261,7 +270,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef void _compute_Lb(self) except *:
         cdef int i, j
         cdef QobjEvo c_op
-        cdef Dense b_vec, Lb_vec
+        cdef Dense b_vec, Lb_vec, state=self.state
         cdef complex expect
         if not self._b_set:
             self._compute_b()
@@ -275,7 +284,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
                 c_op.matmul_data(self.t, b_vec, Lb_vec)
                 self.expect_Cb[i,j] = trace_oper_ket_dense(Lb_vec)
                 iadd_dense(Lb_vec, b_vec, -self.expect_Cv[i])
-                iadd_dense(Lb_vec, self.state, -self.expect_Cb[i,j])
+                iadd_dense(Lb_vec, state, -self.expect_Cb[i,j])
         self._Lb_set = True
 
     cpdef Data Lia(self, int i):
@@ -434,9 +443,9 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
             out.append(self.c_ops[i].matmul_data(t, state))
         return out
 
-    cpdef void set_state(self, double t, Data state) except *:
+    cpdef void set_state(self, double t, Dense state) except *:
         self.t = t
-        self.state = _data.to(_data.Dense, state)
+        self.state = state
 
     cpdef Data a(self):
         return self.H.matmul_data(self.t, self.state)
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index bd74c31885..c03c7112be 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -169,5 +169,5 @@ def test_open_system(H, c_ops, heterodyne):
     c_ops = [_make_oper(op, N) for op in c_ops]
     H = liouvillian(H)
     system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
-    state = operator_to_vector(fock_dm(N, N-2)).data
+    state = operator_to_vector(fock_dm(N, N-2, dtype="Dense")).data
     _run_derr_check(system, state)

From 2c9496eb946f83298d2561e3a0627722cec1dc3e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 1 Mar 2023 11:30:12 -0500
Subject: [PATCH 102/602] opt pred_corr

---
 qutip/solver/sode/_sode.pyx | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 884f15ef3d..b6ed449725 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -332,12 +332,13 @@ cdef class PredCorr:
             iadd_dense(out, system.Libj(i, i), dt * (alpha-1) * 0.5)
 
         system.set_state(t+dt, euler)
-        if alpha:
-            iadd_dense(out, system.a(), dt*alpha)
-
         for i in range(num_ops):
             iadd_dense(out, system.bi(i), dW[0, i] * (1-eta))
-            iadd_dense(out, system.Libj(i, i), -dt * alpha * 0.5)
+
+        if alpha:
+            iadd_dense(out, system.a(), dt*alpha)
+            for i in range(num_ops):
+                iadd_dense(out, system.Libj(i, i), -dt * alpha * 0.5)
 
         return out
 

From 6fb6d9672994ffba9d235266b2c3ace4c1fcfc45 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 1 Mar 2023 17:29:33 -0500
Subject: [PATCH 103/602] superop rouchon

---
 qutip/core/cy/qobjevo.pxd    |  2 +-
 qutip/solver/sode/_sode.pyx  | 56 ++++++++++++++++++++++--------------
 qutip/solver/sode/rouchon.py | 41 ++++++++++++++++++++++++++
 3 files changed, 76 insertions(+), 23 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
index de310b6910..f138c89592 100644
--- a/qutip/core/cy/qobjevo.pxd
+++ b/qutip/core/cy/qobjevo.pxd
@@ -5,7 +5,7 @@ from qutip.core.data.base cimport idxint
 
 cdef class QobjEvo:
     cdef:
-        list elements
+        readonly list elements
         readonly list dims
         readonly (idxint, idxint) shape
         readonly str type
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index b6ed449725..c7b7f3ef11 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -67,7 +67,7 @@ cdef class Platen(Euler):
         cdef int i, j, num_ops = system.num_collapse
         cdef double sqrt_dt = np.sqrt(dt)
         cdef double sqrt_dt_inv = 0.25 / sqrt_dt
-        cdef double dw, dw2
+        cdef double dw, dw2, dw2p, dw2m
 
         cdef Data d1 = _data.add(state, system.drift(t, state), dt)
         cdef list d2 = system.diffusion(t, state)
@@ -90,14 +90,20 @@ cdef class Platen(Euler):
             d2p = system.diffusion(t, Vp[i])
             d2m = system.diffusion(t, Vm[i])
             dw = dW[0, i] * 0.25
-            out = _data.add(out, d2m[i], dw)
+            # out = _data.add(out, d2m[i], dw)
             out = _data.add(out, d2[i], 2 * dw)
-            out = _data.add(out, d2p[i], dw)
+            # out = _data.add(out, d2p[i], dw)
 
             for j in range(num_ops):
-                dw2 = sqrt_dt_inv * (dW[0, i] * dW[0, j] - dt * (i == j))
-                out = _data.add(out, d2p[j], dw2)
-                out = _data.add(out, d2m[j], -dw2)
+                if i == j:
+                    dw2 = sqrt_dt_inv * (dW[0, i] * dW[0, j] - dt)
+                    dw2p = dw2 + dw
+                    dw2m = -dw2 + dw
+                else:
+                    dw2p = sqrt_dt_inv * dW[0, i] * dW[0, j]
+                    dw2m = -dw2p
+                out = _data.add(out, d2p[j], dw2p)
+                out = _data.add(out, d2m[j], dw2m)
 
         return out
 
@@ -117,10 +123,12 @@ cdef class Explicit15(Euler):
         cdef double sqrt_dt = np.sqrt(dt)
         cdef double sqrt_dt_inv = 1./sqrt_dt
         cdef double ddz, ddw, ddd
-        cdef double[::1] dz, dw
+        cdef double[::1] dz, dw, dwp, dwm
 
         dw = np.empty(num_ops)
         dz = np.empty(num_ops)
+        dwp = np.zeros(num_ops)
+        dwm = np.zeros(num_ops)
         for i in range(num_ops):
             dw[i] = dW[0, i]
             dz[i] = 0.5 *(dW[0, i] + 1./np.sqrt(3) * dW[1, i])
@@ -162,6 +170,9 @@ cdef class Explicit15(Euler):
         for i in range(num_ops):
             ddz = dz[i] * 0.5 / sqrt_dt # 1.5
             ddd = 0.25 * (dw[i] * dw[i] / 3 - dt) * dw[i] / dt # 1.5
+            for j in range(num_ops):
+                dwp[j] = 0
+                dwm[j] = 0
 
             d1p = system.drift(t + dt/num_ops, v2p[i])
             d1m = system.drift(t + dt/num_ops, v2m[i])
@@ -179,47 +190,48 @@ cdef class Explicit15(Euler):
 
             out = _data.add(out, d2pp[i], ddd)
             out = _data.add(out, d2mm[i], -ddd)
-            out = _data.add(out, d2p[i], -ddd)
-            out = _data.add(out, d2m[i], ddd)
+            dwp[i] += -ddd
+            dwm[i] += ddd
 
             for j in range(num_ops):
                 ddw = 0.5 * (dw[j] - dz[j])  # O(1.5)
-                out = _data.add(out, d2p[j], ddw)
+                dwp[j] += ddw
+                dwm[j] += ddw
                 out = _data.add(out, d2[j], -2*ddw)
-                out = _data.add(out, d2m[j], ddw)
 
                 if j > i:
                     ddw = 0.5 * (dw[i] * dw[j]) / sqrt_dt  # O(1.0)
-                    out = _data.add(out, d2p[j], ddw)
-                    out = _data.add(out, d2m[j], -ddw)
+                    dwp[j] += ddw
+                    dwm[j] += -ddw
 
                     ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
                     d2pp = system.diffusion(t, p2p[j][i])
                     d2mm = system.diffusion(t, p2m[j][i])
-
                     out = _data.add(out, d2pp[j], ddw)
                     out = _data.add(out, d2mm[j], -ddw)
-                    out = _data.add(out, d2p[j], -ddw)
-                    out = _data.add(out, d2m[j], ddw)
+                    dwp[j] += -ddw
+                    dwm[j] += ddw
 
                     for k in range(j+1, num_ops):
                         ddw = 0.5 * dw[i] * dw[j] * dw[k] / dt  # O(1.5)
-
                         out = _data.add(out, d2pp[k], ddw)
                         out = _data.add(out, d2mm[k], -ddw)
-                        out = _data.add(out, d2p[k], -ddw)
-                        out = _data.add(out, d2m[k], ddw)
+                        dwp[k] += -ddw
+                        dwm[k] += ddw
 
                 if j < i:
                     ddw = 0.25 * (dw[j] * dw[j] - dt) * dw[i] / dt  # O(1.5)
-
                     d2pp = system.diffusion(t, p2p[j][i])
                     d2mm = system.diffusion(t, p2m[j][i])
 
                     out = _data.add(out, d2pp[j], ddw)
                     out = _data.add(out, d2mm[j], -ddw)
-                    out = _data.add(out, d2p[j], -ddw)
-                    out = _data.add(out, d2m[j], ddw)
+                    dwp[j] += -ddw
+                    dwm[j] += ddw
+
+            for j in range(num_ops):
+                out = _data.add(out, d2p[j], dwp[j])
+                out = _data.add(out, d2m[j], dwm[j])
 
         return out
 
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index 03f9b98039..0b9801ef31 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -37,11 +37,14 @@ def __init__(self, rhs, options):
         self.c_ops = rhs.c_ops
         self.sc_ops = rhs.sc_ops
         self.cpcds = [op + op.dag() for op in self.sc_ops]
+        for op in self.cpcds:
+            op.compress()
         self.M = (
             - 1j * self.H
             - sum(op.dag() @ op for op in self.c_ops) * 0.5
             - sum(op.dag() @ op for op in self.sc_ops) * 0.5
         )
+        self.M.compress()
         self.num_collapses = len(self.sc_ops)
         self.scc = [
             [self.sc_ops[i] @ self.sc_ops[j] for i in range(j+1)]
@@ -50,6 +53,15 @@ def __init__(self, rhs, options):
 
         self.id = _data.identity[dtype](self.H.shape[0])
 
+        self.pre_M = qt.spre(self.M)
+        self.post_M = qt.spost(self.M.dag())
+        self.pre_sc = [qt.spre(c) for c in self.sc_ops]
+        self.post_sc = [qt.spost(c.dag()) for c in self.sc_ops]
+        self.pre_cc = [[qt.spre(cc) for cc in v] for v in self.scc]
+        self.post_cc = [[qt.spost(cc.dag()) for cc in v] for v in self.scc]
+        self.pp_cc = sum([qt.sprepost(op, op.dag()) for op in self.c_ops]) + self.pre_M * 0
+        self.e_c = [qt.spre(c + c.dag()) for c in self.sc_ops]
+
     def set_state(self, t, state0, generator):
         """
         Set the state of the SODE solver.
@@ -127,6 +139,35 @@ def _step(self, t, state, dt, dW):
             out = out / _data.norm.l2(out)
         return out
 
+    def _step_superops(self, t, state, dt, dW):
+        dy = [
+            op.expect_data(t, state) * dt + dw
+            for op, dw in zip(self.e_c, dW)
+        ]
+
+        temp = self.pre_M.matmul_data(t, state)
+        Mrho = _data.add(state, temp, dt)
+
+        for i in range(self.num_collapses):
+            Mrho = _data.add(Mrho, self.pre_sc[i].matmul_data(t, state), dy[i])
+            Mrho = _data.add(Mrho, self.pre_cc[i][i].matmul_data(t, state), (dy[i]**2-dt)/2)
+            for j in range(i):
+                Mrho = _data.add(Mrho, self.pre_cc[i][j].matmul_data(t, state), dy[i]*dy[j])
+
+        temp = self.post_M.matmul_data(t, Mrho)
+        MrhoM = _data.add(Mrho, temp, dt)
+
+        dy = np.conj(dy)
+        for i in range(self.num_collapses):
+            MrhoM = _data.add(MrhoM, self.post_sc[i].matmul_data(t, Mrho), dy[i])
+            MrhoM = _data.add(MrhoM, self.post_cc[i][i].matmul_data(t, Mrho), (dy[i]**2-dt)/2)
+            for j in range(i):
+                MrhoM = _data.add(MrhoM, self.post_cc[i][j].matmul_data(t, Mrho), dy[i]*dy[j])
+
+        out = _data.add(MrhoM, self.pp_cc.matmul_data(t, state), dt)
+
+        return out / _data.trace_oper_ket(out)
+
     @property
     def options(self):
         """

From 3bb5f71983a758bd4cd39b88883aa159a904870a Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Thu, 2 Mar 2023 12:00:06 +0530
Subject: [PATCH 104/602] del. non-user fun. in __all__

---
 qutip/core/semidefinite.py | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index 0c5774fd51..c6d3762f22 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -5,18 +5,6 @@
 """
 
 __all__ = [
-    'complex_var',
-    'herm',
-    'pos_noherm',
-    'pos',
-    'dens',
-    'kron',
-    'conj',
-    'bmat',
-    'dag',
-    'memoize',
-    'qudit_swap',
-    'initialize_constraints_on_dnorm_problem',
     'dnorm_problem',
     'dnorm_sparse_problem',
 ]

From 2a168d0382dae05fe8cdb2dabc55c91d4035e941 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 2 Mar 2023 09:16:18 -0500
Subject: [PATCH 105/602] Restore towncrier checks

---
 .github/workflows/tests.yml | 2 +-
 doc/changes/2105.misc       | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
 create mode 100644 doc/changes/2105.misc

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index ca207a7b95..844b3712d5 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -205,7 +205,7 @@ jobs:
           python -m pip install towncrier
 
       - name: Verify Towncrier entry added
-        if: False # github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request'
         env:
           BASE_BRANCH: ${{ github.base_ref }}
         run: |
diff --git a/doc/changes/2105.misc b/doc/changes/2105.misc
new file mode 100644
index 0000000000..9448f7cb05
--- /dev/null
+++ b/doc/changes/2105.misc
@@ -0,0 +1 @@
+Restore towncrier check

From f714c387705c10c9e5ae63e05d77b2e3e173a32d Mon Sep 17 00:00:00 2001
From: valanm22 <valanm22@gmail.com>
Date: Fri, 3 Mar 2023 09:41:37 +0530
Subject: [PATCH 106/602] Update links in template

---
 .github/pull_request_template.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 45554412b8..d68410d7cb 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -5,8 +5,8 @@ Thank you for contributing to QuTiP! Please make sure you have finished the foll
 - [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
 You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
 - [ ] Please add tests to cover your changes if applicable.
-- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-notebooks). Feel free to ask if you are not sure.
-- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#Changelog%20Generation) for more information).
+- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
+- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
 
 Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
 

From dba8c2ed785a07c60141f4e04a320743aeb9e1d6 Mon Sep 17 00:00:00 2001
From: valanm22 <valanm22@gmail.com>
Date: Fri, 3 Mar 2023 09:56:16 +0530
Subject: [PATCH 107/602] Include changelog

---
 doc/changes/2107.bugfix | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2107.bugfix

diff --git a/doc/changes/2107.bugfix b/doc/changes/2107.bugfix
new file mode 100644
index 0000000000..85e2b12df6
--- /dev/null
+++ b/doc/changes/2107.bugfix
@@ -0,0 +1 @@
+Changed qutip-notebooks to qutip-tutorials and fixed the typo in the link redirecting to the changelog section in the PR template.
\ No newline at end of file

From 5a6e8eadced14477164b134331262290c91f3429 Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Fri, 3 Mar 2023 10:50:37 +0530
Subject: [PATCH 108/602] add changelog

---
 doc/changes/2103.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2103.misc

diff --git a/doc/changes/2103.misc b/doc/changes/2103.misc
new file mode 100644
index 0000000000..aff1b7eb93
--- /dev/null
+++ b/doc/changes/2103.misc
@@ -0,0 +1 @@
+added __all__ to qutip/measurements.py and qutip/core/semidefinite.py
\ No newline at end of file

From 4d7b8037716e9cf08c01edd580253da63c2f0165 Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Sat, 4 Mar 2023 03:01:51 +0530
Subject: [PATCH 109/602] version_table call without cython,fix #2001

---
 qutip/ipynbtools.py | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index e2d906b637..f1a5de7d01 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -5,22 +5,22 @@
 from .settings import _blas_info, available_cpu_count
 import IPython
 
-#IPython parallel routines moved to ipyparallel in V4
-#IPython parallel routines not in Anaconda by default
+# IPython parallel routines moved to ipyparallel in V4
+# IPython parallel routines not in Anaconda by default
 if IPython.version_info[0] >= 4:
     try:
         from ipyparallel import Client
         __all__ = ['version_table', 'plot_animation',
-                    'parallel_map', 'HTMLProgressBar']
+                   'parallel_map', 'HTMLProgressBar']
     except:
-         __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
+        __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
 else:
     try:
         from IPython.parallel import Client
         __all__ = ['version_table', 'plot_animation',
-                    'parallel_map', 'HTMLProgressBar']
+                   'parallel_map', 'HTMLProgressBar']
     except:
-         __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
+        __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
 
 
 from IPython.display import HTML, Javascript, display
@@ -39,10 +39,14 @@
 import qutip
 import numpy
 import scipy
-import Cython
 import matplotlib
 import IPython
 
+try:
+    import Cython
+except:
+    pass
+
 
 def version_table(verbose=False):
     """
@@ -67,7 +71,6 @@ def version_table(verbose=False):
                 ("Numpy", numpy.__version__),
                 ("SciPy", scipy.__version__),
                 ("matplotlib", matplotlib.__version__),
-                ("Cython", Cython.__version__),
                 ("Number of CPUs", available_cpu_count()),
                 ("BLAS Info", _blas_info()),
                 ("IPython", IPython.__version__),
@@ -75,6 +78,9 @@ def version_table(verbose=False):
                 ("OS", "%s [%s]" % (os.name, sys.platform))
                 ]
 
+    if "Cython" in sys.modules:
+        packages.append(("Cython", Cython.__version__))
+
     for name, version in packages:
         html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
 

From 98fdcbeaf7dfb4f3d68371d8c443ebaaba65b1f2 Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Sat, 4 Mar 2023 03:21:45 +0530
Subject: [PATCH 110/602] version_table call without cython,fix #2001

---
 qutip/ipynbtools.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index f1a5de7d01..8bbbe052b2 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -5,22 +5,22 @@
 from .settings import _blas_info, available_cpu_count
 import IPython
 
-# IPython parallel routines moved to ipyparallel in V4
-# IPython parallel routines not in Anaconda by default
+#IPython parallel routines moved to ipyparallel in V4
+#IPython parallel routines not in Anaconda by default
 if IPython.version_info[0] >= 4:
     try:
         from ipyparallel import Client
         __all__ = ['version_table', 'plot_animation',
-                   'parallel_map', 'HTMLProgressBar']
+                    'parallel_map', 'HTMLProgressBar']
     except:
-        __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
+         __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
 else:
     try:
         from IPython.parallel import Client
         __all__ = ['version_table', 'plot_animation',
-                   'parallel_map', 'HTMLProgressBar']
+                    'parallel_map', 'HTMLProgressBar']
     except:
-        __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
+         __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
 
 
 from IPython.display import HTML, Javascript, display
@@ -77,7 +77,7 @@ def version_table(verbose=False):
                 ("Python", sys.version),
                 ("OS", "%s [%s]" % (os.name, sys.platform))
                 ]
-
+    
     if "Cython" in sys.modules:
         packages.append(("Cython", Cython.__version__))
 
@@ -374,4 +374,4 @@ def update(n):
     video_encoded = b64encode(video).decode("ascii")
     video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
         video_encoded)
-    return HTML(video_tag)
+    return HTML(video_tag)
\ No newline at end of file

From 7780113c4fd810bed3a01ea64df6278c5f625042 Mon Sep 17 00:00:00 2001
From: Rushiraj Gadhvi <90374468+gadhvirushiraj@users.noreply.github.com>
Date: Sat, 4 Mar 2023 04:20:10 +0530
Subject: [PATCH 111/602] add changelog

---
 doc/changes/2110.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2110.misc

diff --git a/doc/changes/2110.misc b/doc/changes/2110.misc
new file mode 100644
index 0000000000..5ae2b8c700
--- /dev/null
+++ b/doc/changes/2110.misc
@@ -0,0 +1 @@
+qutip.ipynbtools.version_table() can now be called without Cython installed

From 8423041849ce5cbacd95ee83ad010940027bf72e Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Sat, 4 Mar 2023 12:16:23 +0530
Subject: [PATCH 112/602] Added __repr__ to QobjEvo

---
 qutip/core/cy/qobjevo.pyx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 8333830e41..cbd75a4a63 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -231,6 +231,11 @@ cdef class QobjEvo:
         if compress:
             self.compress()
 
+    def __repr__(self):
+        cls = self.__class__.__name__
+        
+        return f'<{cls} dims = {self.dims}, shape= {self.shape}, type = {self.type}, superrep = {self.superrep}, isconstant = {self.isconstant}, num_elements = {self.num_elements}>'
+
     def _read_element(self, op, copy, tlist, args, order, function_style):
         """ Read a Q_object item and return an element for that item. """
         if isinstance(op, Qobj):

From 79b5cb4b0752647ef680bec3b8562079fbf16539 Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Sat, 4 Mar 2023 12:34:30 +0530
Subject: [PATCH 113/602] Added __repr__ to QobjEvo

---
 qutip/core/cy/qobjevo.pyx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index cbd75a4a63..2f01d5faa1 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -233,7 +233,6 @@ cdef class QobjEvo:
 
     def __repr__(self):
         cls = self.__class__.__name__
-        
         return f'<{cls} dims = {self.dims}, shape= {self.shape}, type = {self.type}, superrep = {self.superrep}, isconstant = {self.isconstant}, num_elements = {self.num_elements}>'
 
     def _read_element(self, op, copy, tlist, args, order, function_style):

From 962ce51f17baee9fb150760d14310c7dc2b371c6 Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Sat, 4 Mar 2023 13:52:30 +0530
Subject: [PATCH 114/602] Added __repr__ to QobjEvo

---
 doc/changes/2099.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2099.feature

diff --git a/doc/changes/2099.feature b/doc/changes/2099.feature
new file mode 100644
index 0000000000..cd77a2093b
--- /dev/null
+++ b/doc/changes/2099.feature
@@ -0,0 +1 @@
+Added __repr__ to QobjEvo
\ No newline at end of file

From e0d1755eabddcc5309a72d0b3b5e12316928db64 Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Sat, 4 Mar 2023 14:10:13 +0530
Subject: [PATCH 115/602] Changed changes file name to the correct format:
 2111.feature Awaiting the correct label

---
 doc/changes/{2099.feature => 2111.feature} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename doc/changes/{2099.feature => 2111.feature} (100%)

diff --git a/doc/changes/2099.feature b/doc/changes/2111.feature
similarity index 100%
rename from doc/changes/2099.feature
rename to doc/changes/2111.feature

From 8712f8d4a4cac0b765a1ecafdd051381976ba34d Mon Sep 17 00:00:00 2001
From: Harsh Khilawala <harsh.khilawala27@gmail.com>
Date: Sat, 4 Mar 2023 17:34:25 +0530
Subject: [PATCH 116/602] move HTMLProgressBar to progressbar.py

---
 qutip/ipynbtools.py     | 51 --------------------------------------
 qutip/ui/progressbar.py | 54 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 51 deletions(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index e2d906b637..8454f68d0b 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -97,57 +97,6 @@ def version_table(verbose=False):
     return HTML(html)
 
 
-class HTMLProgressBar(BaseProgressBar):
-    """
-    A simple HTML progress bar for using in IPython notebooks. Based on
-    IPython ProgressBar demo notebook:
-    https://github.com/ipython/ipython/tree/master/examples/notebooks
-
-    Example usage:
-
-        n_vec = linspace(0, 10, 100)
-        pbar = HTMLProgressBar(len(n_vec))
-        for n in n_vec:
-            pbar.update(n)
-            compute_with_n(n)
-    """
-
-    def __init__(self, iterations=0, chunk_size=1.0):
-        self.divid = str(uuid.uuid4())
-        self.textid = str(uuid.uuid4())
-        self.pb = HTML("""\
-<div style="border: 2px solid grey; width: 600px">
-  <div id="%s" \
-style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
-</div>
-<p id="%s"></p>
-""" % (self.divid, self.textid))
-        display(self.pb)
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations=0, chunk_size=1.0):
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def update(self, n):
-        p = (n / self.N) * 100.0
-        if p >= self.p_chunk:
-            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
-                   "Est. remaining time: %s." % self.time_remaining_est(p))
-            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
-                       "$('p#%s').text('%s');" % (self.textid, lbl))
-            display(Javascript(js_code))
-            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
-            # p)))
-            self.p_chunk += self.p_chunk_size
-
-    def finished(self):
-        self.t_done = time.time()
-        lbl = "Elapsed time: %s" % self.time_elapsed()
-        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
-                   "$('p#%s').text('%s');" % (self.textid, lbl))
-        display(Javascript(js_code))
-
-
 def _visualize_parfor_data(metadata):
     """
     Visualizing the task scheduling meta data collected from AsyncResults.
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index c5a6829ef5..94baf83e9b 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -145,6 +145,58 @@ def finished(self):
         self.t_done = time.time()
 
 
+class HTMLProgressBar(BaseProgressBar):
+    """
+    A simple HTML progress bar for using in IPython notebooks. Based on
+    IPython ProgressBar demo notebook:
+    https://github.com/ipython/ipython/tree/master/examples/notebooks
+
+    Example usage:
+
+        n_vec = linspace(0, 10, 100)
+        pbar = HTMLProgressBar(len(n_vec))
+        for n in n_vec:
+            pbar.update(n)
+            compute_with_n(n)
+    """
+
+    def __init__(self, iterations=0, chunk_size=1.0):
+        self.divid = str(uuid.uuid4())
+        self.textid = str(uuid.uuid4())
+        self.pb = HTML("""\
+<div style="border: 2px solid grey; width: 600px">
+  <div id="%s" \
+style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
+</div>
+<p id="%s"></p>
+""" % (self.divid, self.textid))
+        display(self.pb)
+        super(HTMLProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations=0, chunk_size=1.0):
+        super(HTMLProgressBar, self).start(iterations, chunk_size)
+
+    def update(self, n):
+        p = (n / self.N) * 100.0
+        if p >= self.p_chunk:
+            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
+                   "Est. remaining time: %s." % self.time_remaining_est(p))
+            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
+                       "$('p#%s').text('%s');" % (self.textid, lbl))
+            display(Javascript(js_code))
+            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
+            # p)))
+            self.p_chunk += self.p_chunk_size
+
+    def finished(self):
+        self.t_done = time.time()
+        lbl = "Elapsed time: %s" % self.time_elapsed()
+        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
+                   "$('p#%s').text('%s');" % (self.textid, lbl))
+        display(Javascript(js_code))
+
+
+
 progess_bars = {
     "Enhanced": EnhancedTextProgressBar,
     "enhanced": EnhancedTextProgressBar,
@@ -153,6 +205,8 @@ def finished(self):
     True: TextProgressBar,
     "Tqdm": TqdmProgressBar,
     "tqdm": TqdmProgressBar,
+    "Html": HTMLProgressBar,
+    "html": HTMLProgressBar,
     "": BaseProgressBar,
     False: BaseProgressBar,
     None: BaseProgressBar,

From 6bd5baa812eba71e736b2c1109ca5dd3c28a9894 Mon Sep 17 00:00:00 2001
From: Harsh Khilawala <harsh.khilawala27@gmail.com>
Date: Sat, 4 Mar 2023 17:47:36 +0530
Subject: [PATCH 117/602] update HTMLProgressBar

---
 qutip/ipynbtools.py     | 10 +++++-----
 qutip/ui/progressbar.py |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 8454f68d0b..ca57a79867 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -1,7 +1,7 @@
 """
 This module contains utility functions for using QuTiP with IPython notebooks.
 """
-from qutip.ui.progressbar import BaseProgressBar
+from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
 from .settings import _blas_info, available_cpu_count
 import IPython
 
@@ -11,16 +11,16 @@
     try:
         from ipyparallel import Client
         __all__ = ['version_table', 'plot_animation',
-                    'parallel_map', 'HTMLProgressBar']
+                    'parallel_map']
     except:
-         __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
+         __all__ = ['version_table', 'plot_animation']
 else:
     try:
         from IPython.parallel import Client
         __all__ = ['version_table', 'plot_animation',
-                    'parallel_map', 'HTMLProgressBar']
+                    'parallel_map']
     except:
-         __all__ = ['version_table', 'plot_animation', 'HTMLProgressBar']
+         __all__ = ['version_table', 'plot_animation']
 
 
 from IPython.display import HTML, Javascript, display
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index 94baf83e9b..e92bc9a7d4 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -1,6 +1,6 @@
 __all__ = ['BaseProgressBar', 'TextProgressBar',
            'EnhancedTextProgressBar', 'TqdmProgressBar',
-           'progess_bars']
+           'progess_bars', 'HTMLProgressBar']
 
 import time
 import datetime

From 10f0b5731a8d5d2397711a719b590b18e2a4f018 Mon Sep 17 00:00:00 2001
From: Harsh Khilawala <harsh.khilawala27@gmail.com>
Date: Sat, 4 Mar 2023 17:54:51 +0530
Subject: [PATCH 118/602] add 2112.misc

---
 doc/changes/2112.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2112.misc

diff --git a/doc/changes/2112.misc b/doc/changes/2112.misc
new file mode 100644
index 0000000000..aea5f7bce7
--- /dev/null
+++ b/doc/changes/2112.misc
@@ -0,0 +1 @@
+Moved HTMLProgressBar from qutip/ipynbtools.py to qutip/ui/progressbar.py
\ No newline at end of file

From 8cfb6b87ff4d3f5dbfba07ac51138a5c9d395ae8 Mon Sep 17 00:00:00 2001
From: Harsh Khilawala <harsh.khilawala27@gmail.com>
Date: Sat, 4 Mar 2023 17:57:27 +0530
Subject: [PATCH 119/602] fix lint codeclimate test

---
 qutip/ui/progressbar.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index e92bc9a7d4..cbaf80bdd4 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -196,7 +196,6 @@ def finished(self):
         display(Javascript(js_code))
 
 
-
 progess_bars = {
     "Enhanced": EnhancedTextProgressBar,
     "enhanced": EnhancedTextProgressBar,

From 72b0f67df4c0621b053ffda9be08fc102d2aba96 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Sat, 4 Mar 2023 13:54:27 +0900
Subject: [PATCH 120/602] Keep individual traces of trajectories if
 keep_runs_results is set

---
 qutip/solver/result.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 99ff5e16bb..e51c81d163 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1007,6 +1007,9 @@ def _add_trace(self, trajectory):
         self.trace = avg
         self.average_trace = avg
         self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg)**2))
+        
+        if self.options['keep_runs_results']:
+            self.runs_trace.append(trajectory.trace)
 
     def _add_first_traj(self, trajectory):
         super()._add_first_traj(trajectory)
@@ -1021,5 +1024,6 @@ def _post_init(self):
         self.trace = []
         self.average_trace = []
         self.std_trace = []
+        self.runs_trace = []
 
         self.add_processor(self._add_trace)

From 147017b23d106d8e0ef4483405a44bace374b679 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Tue, 7 Mar 2023 18:31:56 +0900
Subject: [PATCH 121/602] Added docstring comments in all code related to
 NonMarkovianMCSolver

---
 qutip/solver/mcsolve.py    |  12 +-
 qutip/solver/nm_mcsolve.py | 218 +++++++++++++++++++++++++++++++++----
 qutip/solver/result.py     |  68 +++++++++++-
 3 files changed, 265 insertions(+), 33 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 6f99e79c03..1ac5b9be47 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -53,7 +53,7 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
     options : None / dict
         Dictionary of options for the solver.
 
-        - store_final_state : bool [False]
+        - store_final_state : bool, [False]
           Whether or not to store the final state of the evolution in the
           result class.
         - store_states : bool, NoneType, [None]
@@ -66,7 +66,7 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
           if not installed. Empty string or False will disable the bar.
         - progress_kwargs : dict, [{"chunk_size": 10}]
           kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
+        - method : str {"adams", "bdf", "dop853", "vern9", etc.}, ["adams"]
           Which differential equation integration method to use.
         - keep_runs_results : bool, [False]
           Whether to store results from all trajectories or just store the
@@ -103,7 +103,7 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
 
             seeds=prev_result.seeds
 
-    target_tol : {float, tuple, list}, optional
+    target_tol : float, tuple, list, [optional]
         Target tolerance of the evolution. The evolution will compute
         trajectories until the error on the expectation values is lower than
         this tolerance. The maximum number of trajectories employed is
@@ -112,13 +112,13 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
         relative tolerance, in that order. Lastly, it can be a list of pairs of
         (atol, rtol) for each e_ops.
 
-    timeout : float [optional]
+    timeout : float, [optional]
         Maximum time for the evolution in second. When reached, no more
-        trajectories will be computed. Overwrite the option of the same name.
+        trajectories will be computed.
 
     Returns
     -------
-    results : :class:`qutip.solver.Result`
+    results : :class:`qutip.solver.McResult`
         Object storing all results from the simulation. Which results is saved
         depends on the presence of ``e_ops`` and the options used. ``collapse``
         and ``photocurrent`` is available to Monte Carlo simulation results.
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 28c2021d74..f03bf8d9a1 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -3,6 +3,7 @@
 from functools import partial
 import numpy as np
 import scipy
+from .multitraj import MultiTrajSolver
 from .mcsolve import MCSolver
 from .mesolve import MESolver, mesolve
 from .result import NmmcResult, NmmcTrajectoryResult
@@ -11,8 +12,124 @@
 
 def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
                options=None, seeds=None, target_tol=None, timeout=None):
-    r"""
-    TODO
+    """
+    Monte-Carlo evolution corresponding to a Lindblad equation with "rates"
+    that may be negative. Usage of this function is analogous to ``mcsolve``,
+    but the ``c_ops`` parameter is replaced by an ``ops_and_rates`` parameter
+    to allow for negative rates. Options for the underlying ODE solver are
+    given by the Options class.
+
+    Parameters
+    ----------
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        ``H`` can also be a superoperator (liouvillian) if some collapse
+        operators are to be treated deterministically.
+
+    state : :class:`qutip.Qobj`
+        Initial state vector.
+
+    tlist : array_like
+        Times at which results are recorded.
+
+    ops_and_rates : list
+        A ``list`` of tuples ``(L, Gamma)``, where the Lindblad operator ``L``
+        is a :class:`qutip.Qobj` and the corresponding rate ``Gamma`` is
+        callable. That is, ``Gamma(t)`` returns the rate at time ``t``, which
+        is allowed to be negative. The Lindblad operators must be operators
+        even if ``H`` is a superoperator. If none are given, the solver will
+        defer to ``sesolve`` or ``mesolve``.
+
+    e_ops : list, [optional]
+        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
+        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
+        are given, the solver will default to save the states.
+
+    ntraj : int
+        Maximum number of trajectories to run. Can be cut short if a time limit
+        is passed with the ``timeout`` keyword or if the target tolerance is
+        reached, see ``target_tol``.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool, [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, NoneType, [None]
+          Whether or not to store the state density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str {"adams", "bdf", "dop853", "vern9", etc.}, ["adams"]
+          Which differential equation integration method to use.
+        - keep_runs_results : bool, [False]
+          Whether to store results from all trajectories or just store the
+          averages.
+        - map : str {"serial", "parallel", "loky"}, ["serial"]
+          How to run the trajectories. "parallel" uses concurrent module to run
+          in parallel while "loky" use the module of the same name to do so.
+        - job_timeout : NoneType, int, [None]
+          Maximum time to compute one trajectory.
+        - num_cpus : NoneType, int, [None]
+          Number of cpus to use when running in parallel. ``None`` detect the
+          number of available cpus.
+        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
+          Parameters used to find the collapse location. ``norm_t_tol`` and
+          ``norm_tol`` are the tolerance in time and norm respectively.
+          An error will be raised if the collapse could not be found within
+          ``norm_steps`` tries.
+        - mc_corr_eps : float, [1e-10]
+          Small number used to detect non-physical collapse caused by numerical
+          imprecision.
+        - atol, rtol : float, [1e-8, 1e-6]
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps : int [2500]
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, [0]
+          Maximum length of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+        - completeness_rtol, completeness_atol : float, float, [1e-5, 1e-8]
+          Parameters used in determining whether the given Lindblad operators
+          satisfy a certain completeness relation. If they do not, an
+          additional Lindblad operator is added automatically (with zero rate).
+
+    seeds : int, SeedSequence, list, [optional]
+        Seed for the random number generator. It can be a single seed used to
+        spawn seeds for each trajectory or a list of seeds, one for each
+        trajectory. Seeds are saved in the result and they can be reused with::
+
+            seeds=prev_result.seeds
+
+    target_tol : float, tuple, list, [optional]
+        Target tolerance of the evolution. The evolution will compute
+        trajectories until the error on the expectation values is lower than
+        this tolerance. The maximum number of trajectories employed is
+        given by ``ntraj``. The error is computed using jackknife resampling.
+        ``target_tol`` can be an absolute tolerance or a pair of absolute and
+        relative tolerance, in that order. Lastly, it can be a list of pairs of
+        (atol, rtol) for each e_ops.
+
+    timeout : float, [optional]
+        Maximum time for the evolution in seconds. When reached, no more
+        trajectories will be computed.
+
+    Returns
+    -------
+    results : :class:`qutip.solver.NmmcResult`
+        Object storing all results from the simulation. Compared to a result
+        returned by ``mcsolve``, this result contains the additional field
+        ``trace`` (and ``runs_trace`` if ``store_final_state`` is set). Note
+        that the states on the individual trajectories are not normalized. This
+        field contains the average of their trace, which will converge to one
+        in the limit of sufficiently many trajectories.
     """
     if not isinstance(ops_and_rates, (list, tuple)):
         ops_and_rates = [ops_and_rates]
@@ -34,11 +151,35 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
 
 
 class NonMarkovianMCSolver(MCSolver):
-    r"""
-    Monte-Carlo solver for master equation with negative rates.
-    Based on the methods explained in arXiv:2209.08958 [quant-ph]
+    """
+    Monte Carlo Solver for Lindblad equations with "rates" that may be
+    negative. The ``c_ops`` parameter of :class:`qutip.MCSolver` is replaced by
+    an ``ops_and_rates`` parameter to allow for negative rates. Options for the
+    underlying ODE solver are given by the Options class.
+
+    Parameters
+    ----------
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        ``H`` can also be a superoperator (liouvillian) if some collapse
+        operators are to be treated deterministically.
+
+    ops_and_rates : list
+        A ``list`` of tuples ``(L, Gamma)``, where the Lindblad operator ``L``
+        is a :class:`qutip.Qobj` and the corresponding rate ``Gamma`` is
+        callable. That is, ``Gamma(t)`` returns the rate at time ``t``, which
+        is allowed to be negative. The Lindblad operators must be operators
+        even if ``H`` is a superoperator.
+
+    options : SolverOptions, [optional]
+        Options for the evolution.
 
-    TODO
+    seed : int, SeedSequence, list, [optional]
+        Seed for the random number generator. It can be a single seed used to
+        spawn seeds for each trajectory or a list of seed, one for each
+        trajectory. Seeds are saved in the result and can be reused with::
+            seeds=prev_result.seeds
     """
     name = "nm_mcsolve"
     resultclass = NmmcResult
@@ -51,8 +192,6 @@ class NonMarkovianMCSolver(MCSolver):
     # "solver" argument will be partially initialized in constructor
     trajectory_resultclass = NmmcTrajectoryResult
 
-    # ops_and_rates is a list of tuples (L_i, Gamma_i),
-    #     where Gamma_i = Gamma_i(t) is callable
     def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
         self.trajectory_resultclass = partial(NmmcTrajectoryResult,
                                               solver=self)
@@ -68,11 +207,14 @@ def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
         c_ops = self._compute_paired_c_ops()
         super().__init__(H, c_ops, *args, options=options, **kwargs)
 
-    # Check whether op = sum(Li.dag() * Li) is proportional to identity
-    # If not, creates an extra Lindblad operator so that it is
-    # Returns: * the proportionality factor a
-    #          * the extra Lindblad operator (or None if not necessary)
     def _check_completeness(self, ops_and_rates):
+        """
+        Checks whether sum(Li.dag() * Li) is proportional to the identity
+        operator. If not, creates an extra Lindblad operator so that it is.
+
+        Returns the proportionality factor a, and the extra Lindblad operator
+        (or None if no extra Lindblad operator is necessary).
+        """
         op = sum((L.dag() * L) for L, _ in ops_and_rates)
 
         a_candidate = op.tr() / op.shape[0]
@@ -85,11 +227,20 @@ def _check_completeness(self, ops_and_rates):
         L = (a * qeye(op.dims[0]) - op).sqrtm()  # new Lindblad operator
         return a, L
 
-    # Shifts all rate function by the function rate_shift
-    # Returns c_i = L_i * sqrt(gamma_i) as QobjEvo objects
     def _compute_paired_c_ops(self):
+        """
+        Shift all given rate functions Gamma_i by the function rate_shift,
+        creating the positive definite rate functions
+            gamma_i = Gamma_i + rate_shift.
+        Returns the collapse operators
+            c_i = L_i * sqrt(gamma_i)
+        as QobjEvo objects.
+        """
         c_ops = []
         for f in self.ops_and_rates:
+            # Note that this cannot be done using a lambda expression, since
+            # lambda expressions can't be pickled and pickling is required
+            # for parallel execution.
             sqrt_gamma = partial(self._sqrt_gamma, original_rate=f[1])
             c_ops.append(QobjEvo([f[0], sqrt_gamma]))
         return c_ops
@@ -101,12 +252,14 @@ def _rate_shift(self, t):
     def _sqrt_gamma(self, t, original_rate):
         return np.sqrt(original_rate(t) + self._rate_shift(t))
 
-    # Continuous part of the martingale evolution
-    # Checks self._mu_c for the closest time t0 earlier than the given time t
-    #     and starts integration from there.
-    # Returns the continuous part of the martingale at time t and stores it in
-    #     self._mu_c
     def _continuous_martingale(self, t):
+        """
+        Continuous part of the martingale evolution. Checks the stored values
+        in self._mu_c for the closest time t0 earlier than the given time t and
+        starts integration from there.
+        Returns the continuous part of the martingale at time t and stores it
+        in self._mu_c.
+        """
         if self._mu_c is None:
             raise RuntimeError("The `start` method must called first.")
         if t in self._mu_c:
@@ -123,26 +276,38 @@ def _continuous_martingale(self, t):
         self._mu_c[t] = result
         return result
 
-    # Discrete part of the martingale evolution
-    # collapses is a list of (t_k, i_k)
     def _discrete_martingale(self, collapses):
+        """
+        Discrete part of the martingale evolution. The collapses that have
+        happened until now must be provided as a list of (t_k, i_k).
+        """
         o_r = self.ops_and_rates
         factors = [o_r[ik][1](tk) / (o_r[ik][1](tk) + self._rate_shift(tk))
                    for tk, ik in collapses]
         return np.prod(factors)
 
     def _current_martingale(self):
+        """
+        Returns the value of the influence martingale along the current
+        trajectory. The value of the martingale is the product of the
+        continuous and the discrete contribution. The current time and the
+        collapses that have happened are read out from the internal integrator.
+        """
         t, *_ = self._integrator.get_state(copy=False)
         collapses = self._integrator.collapses
         return self._continuous_martingale(t) *\
             self._discrete_martingale(collapses)
 
-    # Override "run" and "start" to initialize continuous part
-    #     of martingale evolution
+    # Override "run" and "start" to precompute
+    #     continuous part of martingale evolution
     def run(self, state, tlist, *args, **kwargs):
+        if 'args' in kwargs and kwargs['args']:
+            raise RuntimeError("args not supported by nm_mcsolve.")
+
         self._mu_c = {tlist[0]: 1}
         for t in tlist[1:]:
             self._continuous_martingale(t)  # precompute self._mu_c
+
         return super().run(state, tlist, *args, **kwargs)
 
     def start(self, state, t0, seed=None):
@@ -152,7 +317,14 @@ def start(self, state, t0, seed=None):
     # Override "step" to include the martingale mu in the state
     # Note that the returned state will be a density matrix with trace=mu
     def step(self, t, *, args=None, copy=True):
+        if args:
+            raise RuntimeError("args not supported by nm_mcsolve.")
+
         state = super().step(t, args=args, copy=copy)
         if isket(state):
             state = ket2dm(state)
         return state * self._current_martingale()
+
+    run.__doc__ = MultiTrajSolver.run.__doc__
+    start.__doc__ = MultiTrajSolver.start.__doc__
+    step.__doc__ = MultiTrajSolver.step.__doc__
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index e51c81d163..1d11461e9b 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -867,6 +867,10 @@ def __add__(self, other):
 
 
 class McTrajectoryResult(Result):
+    """
+    Result class used by the :class:`qutip.MCSolver` for single trajectories.
+    """
+
     def __init__(self, e_ops, options, *args, **kwargs):
         super().__init__(e_ops, {**options, "normalize_output": False},
                          *args, **kwargs)
@@ -874,7 +878,7 @@ def __init__(self, e_ops, options, *args, **kwargs):
 
 class McResult(MultiTrajResult):
     """
-    Base class for storing solver results.
+    Class for storing Monte-Carlo solver results.
 
     Parameters
     ----------
@@ -979,24 +983,79 @@ def runs_photocurrent(self):
 
 
 class NmmcTrajectoryResult(McTrajectoryResult):
+    """
+    Result class used by the :class:`qutip.NonMarkovianMCSolver` for single
+    trajectories. Additionally stores the trace of the state along the
+    trajectory.
+    """
+
     def __init__(self, e_ops, options, solver, *args, **kwargs):
         super().__init__(e_ops, options, *args, **kwargs)
 
         self._solver = solver
         self.trace = []
 
+    # This gets called during the Monte-Carlo simulation of the associated
+    # completely positive master equation. To obtain the state of the actual
+    # system, we simply multiply the provided state with the current martingale
+    # before storing it / computing expectation values.
     def add(self, t, state):
         if isket(state):
             state = ket2dm(state)
         mu = self._solver._current_martingale()
         super().add(t, state * mu)
         self.trace.append(mu)
+    add.__doc__ = Result.add.__doc__
 
 
 class NmmcResult(McResult):
-    r"""
-    TODO
     """
+    Class for storing the results of the non-Markovian Monte-Carlo solver.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``.expect`` attribute of this result
+        object. ``.expect`` is a list, where each item contains the values
+        of the corresponding ``e_op``.
+
+    options : :obj:`~SolverResultsOptions`
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+        Must include a value for "num_collapse".
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Properties
+    ----------
+    average_trace : list
+        The average trace (i.e., averaged over all trajectories) at each time.
+
+    std_trace : list
+        The standard deviation of the trace at each time.
+
+    runs_trace : list of lists
+        For each recorded trajectory, the trace at each time.
+        Only present if ``keep_runs_results`` is set in the options.
+
+    trace : list
+        Refers to ``average_trace`` or ``runs_trace``, depending on whether
+        ``keep_runs_results`` is set in the options.
+    """
+
     def _add_trace(self, trajectory):
         new_trace = np.array(trajectory.trace)
         self._sum_trace += new_trace
@@ -1007,9 +1066,10 @@ def _add_trace(self, trajectory):
         self.trace = avg
         self.average_trace = avg
         self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg)**2))
-        
+
         if self.options['keep_runs_results']:
             self.runs_trace.append(trajectory.trace)
+            self.trace = self.runs_trace
 
     def _add_first_traj(self, trajectory):
         super()._add_first_traj(trajectory)

From 7e58482ae4155fb191a2c306993adb8d7dc67189 Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Tue, 7 Mar 2023 21:40:42 +0530
Subject: [PATCH 122/602] Changed the format of the string from
 QobjEvo.__repr__(). Added test for the edits made.

---
 qutip/core/cy/qobjevo.pyx        | 17 +++++++++--------
 qutip/tests/core/test_qobjevo.py | 17 +++++++++++++++++
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 2f01d5faa1..942a8d38b6 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -1,5 +1,6 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+# cython: language_level=3
+# cython: boundscheck=False, wraparound=False,
+#         initializedcheck=False, cdvision=True
 
 import numpy as np
 import numbers
@@ -17,7 +18,7 @@ from qutip.settings import settings
 from qutip.core.cy._element cimport _BaseElement
 from qutip.core.data cimport Dense, Data, dense
 from qutip.core.data.expect cimport *
-from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
+from qutip.core.data.reshape cimport(column_stack_dense, column_unstack_dense)
 from qutip.core.cy.coefficient cimport Coefficient
 from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
 from libc.math cimport fabs
@@ -233,7 +234,7 @@ cdef class QobjEvo:
 
     def __repr__(self):
         cls = self.__class__.__name__
-        return f'<{cls} dims = {self.dims}, shape= {self.shape}, type = {self.type}, superrep = {self.superrep}, isconstant = {self.isconstant}, num_elements = {self.num_elements}>'
+        return f'<{cls}: dims={self.dims}, shape={self.shape}, type={self.type}, superrep={self.superrep}, isconstant={self.isconstant}, num_elements={self.num_elements}>'
 
     def _read_element(self, op, copy, tlist, args, order, function_style):
         """ Read a Q_object item and return an element for that item. """
@@ -448,13 +449,13 @@ cdef class QobjEvo:
         if isinstance(other, QobjEvo):
             if other.dims != self.dims:
                 raise TypeError("incompatible dimensions" +
-                                 str(self.dims) + ", " + str(other.dims))
+                                str(self.dims) + ", " + str(other.dims))
             for element in (<QobjEvo> other).elements:
                 self.elements.append(element)
         elif isinstance(other, Qobj):
             if other.dims != self.dims:
                 raise TypeError("incompatible dimensions" +
-                                 str(self.dims) + ", " + str(other.dims))
+                                str(self.dims) + ", " + str(other.dims))
             self.elements.append(_ConstantElement(other))
         elif (
             isinstance(other, numbers.Number) and
@@ -984,9 +985,9 @@ cdef class QobjEvo:
                              ", " + str(state.dims[0]))
 
         return Qobj(self.matmul_data(t, state.data),
-                    dims=[self.dims[0],state.dims[1]],
+                    dims=[self.dims[0], state.dims[1]],
                     copy=False
-                   )
+                    )
 
     cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
         """Compute ``out += self(t) @ state``"""
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index ddaa52b015..a53c202a77 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -131,6 +131,23 @@ def test_call(pseudo_qevo, coeff_type):
     assert not qevo.issuper
     _assert_qobjevo_equivalent(pseudo_qevo, qevo)
 
+# Test the QobjEvo.__repr__()
+def test_QobjEvo_repr():
+    # Creation of QobjEvo
+    case_1= QobjEvo([qeye(2), lambda t: t])
+    # Expected result from the __repr__()
+    expected_repr_1= "<QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=False, num_elements=1>"
+    assert case_1 == expected_repr_1
+    # Creation of QobjEvo
+    case_2= QobjEvo(qeye(2), lambda t: t)
+    case_3= QobjEvo([qeye(2)])
+    case_4= QobjEvo(qeye(2))
+    # Expected result from the __repr__()
+    expected_repr_2_3_4= "<QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=True, num_elements=1>"
+    assert case_2 == expected_repr_2_3_4
+    assert case_3 == expected_repr_2_3_4
+    assert case_4 == expected_repr_2_3_4
+
 
 @pytest.mark.parametrize('coeff_type',
                          ['func_coeff', 'string', 'array', 'logarray'])

From 2d1ba51bb4310017f16bd8aed9f4360c7ddc94de Mon Sep 17 00:00:00 2001
From: Rushiraj Gadhvi <90374468+gadhvirushiraj@users.noreply.github.com>
Date: Tue, 7 Mar 2023 22:13:50 +0530
Subject: [PATCH 123/602] updated qutip/ipynbtools.py

Co-authored-by: Asier Galicia <57414022+AGaliciaMartinez@users.noreply.github.com>
---
 qutip/ipynbtools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 8bbbe052b2..cd0989debe 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -44,7 +44,7 @@
 
 try:
     import Cython
-except:
+except ImportError:
     pass
 
 

From 9de977a802aef1a9e03f9fe885aed4c45747094c Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Tue, 7 Mar 2023 23:38:04 +0530
Subject: [PATCH 124/602] added test for version table

---
 qutip/tests/test_ipynbtools.py | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 qutip/tests/test_ipynbtools.py

diff --git a/qutip/tests/test_ipynbtools.py b/qutip/tests/test_ipynbtools.py
new file mode 100644
index 0000000000..76a46db3f8
--- /dev/null
+++ b/qutip/tests/test_ipynbtools.py
@@ -0,0 +1,9 @@
+from qutip.ipynbtools import version_table
+import sys
+
+
+def test_version_table():
+    if 'Cython' in sys.modules:
+        assert 'Cython' in version_table().data
+    else:
+        assert 'Cython' not in version_table().data

From eb14c93421c5cc58315ad0c479f6ef8b41120e44 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 8 Mar 2023 14:08:59 +0000
Subject: [PATCH 125/602] Moved compile at the end and modified its content.

---
 qutip/core/options.py | 3 ++-
 qutip/settings.py     | 5 ++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index fe035d6375..338c2642b0 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -34,7 +34,8 @@ def __setitem__(self, key, value):
     def __repr__(self):
         out = [f"<{self.__class__.__name__}("]
         for key, value in self.options.items():
-            out += [f"    '{key}': {repr(value)},"]
+            if value != self._options[key]:
+                out += [f"    '{key}': {repr(value)},"]
         out += [")>"]
         return "\n".join(out)
 
diff --git a/qutip/settings.py b/qutip/settings.py
index 7537942884..e5ba12fe7e 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -281,8 +281,11 @@ def colorblind_safe(self, value):
     def __str__(self):
         lines = ["Qutip settings:"]
         for attr in self.__dir__():
-            if not attr.startswith('_') and attr != "core":
+            if not attr.startswith('_') and attr != "core" and attr != "compile":
                 lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+        if "compile" in self.__dir__():
+            attr = "compile"
+            lines.append(f"    {attr}: {self.__getattribute__(attr)}")
         return '\n'.join(lines)
 
     def __repr__(self):

From cc014ec3f147287982c29c943521d3f8f27edc9c Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 8 Mar 2023 14:33:01 +0000
Subject: [PATCH 126/602] changed codes to follow pep8

---
 qutip/settings.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qutip/settings.py b/qutip/settings.py
index e5ba12fe7e..6e64473073 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -281,8 +281,9 @@ def colorblind_safe(self, value):
     def __str__(self):
         lines = ["Qutip settings:"]
         for attr in self.__dir__():
-            if not attr.startswith('_') and attr != "core" and attr != "compile":
-                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+            if not attr.startswith('_'):
+                if attr != "core" and attr != "compile":
+                    lines.append(f"    {attr}: {self.__getattribute__(attr)}")
         if "compile" in self.__dir__():
             attr = "compile"
             lines.append(f"    {attr}: {self.__getattribute__(attr)}")

From 8de851f1c35380a8afb1c32fb9d8d52d5c21c76f Mon Sep 17 00:00:00 2001
From: Harsh Khilawala <harsh.khilawala27@gmail.com>
Date: Wed, 8 Mar 2023 22:15:19 +0530
Subject: [PATCH 127/602] update __init__ to include HTMLProgressBar before
 progress bars

---
 qutip/ui/progressbar.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index cbaf80bdd4..8bebca7038 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -1,6 +1,6 @@
 __all__ = ['BaseProgressBar', 'TextProgressBar',
            'EnhancedTextProgressBar', 'TqdmProgressBar',
-           'progess_bars', 'HTMLProgressBar']
+           'HTMLProgressBar', 'progess_bars']
 
 import time
 import datetime

From 7d987de6a96743eaeba1d3d048185571962fe372 Mon Sep 17 00:00:00 2001
From: Rushiraj Gadhvi <90374468+gadhvirushiraj@users.noreply.github.com>
Date: Thu, 9 Mar 2023 00:02:19 +0530
Subject: [PATCH 128/602] Update qutip/ipynbtools.py

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/ipynbtools.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index cd0989debe..2bc40b5970 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -44,8 +44,9 @@
 
 try:
     import Cython
+    _cython_available = True
 except ImportError:
-    pass
+    _cython_available = False
 
 
 def version_table(verbose=False):

From 1202098823c34422abc6ac648a3d392fd1e5bdd4 Mon Sep 17 00:00:00 2001
From: Rushiraj Gadhvi <90374468+gadhvirushiraj@users.noreply.github.com>
Date: Thu, 9 Mar 2023 00:03:58 +0530
Subject: [PATCH 129/602] Update qutip/ipynbtools.py

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/ipynbtools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 2bc40b5970..633696a71d 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -79,7 +79,7 @@ def version_table(verbose=False):
                 ("OS", "%s [%s]" % (os.name, sys.platform))
                 ]
     
-    if "Cython" in sys.modules:
+    if _cython_available:
         packages.append(("Cython", Cython.__version__))
 
     for name, version in packages:

From 5b20d88c22ef1ea34ca8ce72d6046c71c3efbd1a Mon Sep 17 00:00:00 2001
From: awkwardPotato812 <srinidhi.812@gmail.com>
Date: Thu, 9 Mar 2023 20:59:22 +0530
Subject: [PATCH 130/602] Add argument for spline boundary conditions

---
 qutip/core/coefficient.py            |  7 ++++++-
 qutip/core/cy/coefficient.pyx        | 14 ++++++++++++--
 qutip/core/cy/qobjevo.pyx            | 21 ++++++++++++++++-----
 qutip/tests/core/test_coefficient.py |  4 ++++
 4 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index e878ebbece..19f8eacdc4 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -53,7 +53,8 @@ def _return(base, **kwargs):
 
 
 def coefficient(base, *, tlist=None, args={}, args_ctypes={},
-                order=3, compile_opt=None, function_style=None, **kwargs):
+                order=3, compile_opt=None, function_style=None,
+                bc_type=None, **kwargs):
     """Build ``Coefficient`` for time dependent systems:
 
     ```
@@ -148,6 +149,9 @@ def f2_t(t, args):
 
     compile_opt : CompilationOptions, optional
         Sets of options for the compilation of string based coefficients.
+    
+    bc_type: 2-tupule or None, optional
+        Specify boundary conditions for spline interpolation.
 
     **kwargs
         Extra arguments to pass the the coefficients.
@@ -159,6 +163,7 @@ def f2_t(t, args):
         'order': order,
         'compile_opt': compile_opt,
         'function_style': function_style,
+        'bc_type': bc_type
     })
 
     for type_ in coefficient_builders:
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 2a5367d8f7..659567e841 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -387,6 +387,16 @@ cdef class InterCoefficient(Coefficient):
     order : int
         Order of the interpolation. Order ``0`` uses the previous (i.e. left)
         value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
+
+    bc_type : 2-Tuple or None, optional
+        Boundary conditions for spline evaluation. Default value is `None` to
+        enable automatically choosing boundary conditions. Otherwise, a two-length
+        tuple of form (`deriv_l`, `deriv_r`) must be passed. Here, `deriv_l` denotes
+        the boundary conditions at ```t = 0``` and deriv_r, the conditions at time
+        ```t```. The condition specified must be an iterable pair of form (`order`,
+        `value`). Refer to Scipy's documentation for further details:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+
     """
     cdef int order
     cdef double dt
@@ -394,7 +404,7 @@ cdef class InterCoefficient(Coefficient):
     cdef complex[:, :] poly
     cdef object np_arrays
 
-    def __init__(self, coeff_arr, tlist, int order, **_):
+    def __init__(self, coeff_arr, tlist, int order, bc_type, **_):
         tlist = np.array(tlist, dtype=np.float64)
         coeff_arr = np.array(coeff_arr, dtype=np.complex128)
 
@@ -418,7 +428,7 @@ cdef class InterCoefficient(Coefficient):
         elif order >= 2:
             # Use scipy to compute the spline and transform it to polynomes
             # as used in scipy's PPoly which is easier for us to use.
-            spline = make_interp_spline(tlist, coeff_arr, k=order)
+            spline = make_interp_spline(tlist, coeff_arr, k=order, bc_type=bc_type)
             # Scipy can move knots, we add them to tlist
             tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
             a = np.arange(spline.k+1)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 8333830e41..881f3b04a1 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -99,6 +99,17 @@ cdef class QobjEvo:
         ``qutip.settings.core["function_coefficient_style"]``
         is used. Otherwise the supplied value overrides the global setting.
 
+
+    bc_type : 2-Tuple or None, optional
+        Boundary conditions for spline evaluation. Default value is `None` to
+        enable automatically choosing boundary conditions. Otherwise, a two-length
+        tuple of form (`deriv_l`, `deriv_r`) must be passed. Here, `deriv_l` denotes
+        the boundary conditions at ```t = 0``` and deriv_r, the conditions at time
+        ```t```. The condition specified must be an iterable pair of form (`order`,
+        `value`). Refer to Scipy's documentation for further details:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+
+
     Attributes
     ----------
     dims : list
@@ -182,7 +193,7 @@ cdef class QobjEvo:
     """
     def __init__(QobjEvo self, Q_object, args=None, tlist=None,
                  order=3, copy=True, compress=True,
-                 function_style=None):
+                 function_style=None, bc_type=None):
         if isinstance(Q_object, QobjEvo):
             self.dims = Q_object.dims.copy()
             self.shape = Q_object.shape
@@ -217,21 +228,21 @@ cdef class QobjEvo:
                 self.elements.append(
                     self._read_element(
                         op, copy=copy, tlist=tlist, args=args, order=order,
-                        function_style=function_style
+                        function_style=function_style, bc_type=bc_type
                     )
                 )
         else:
             self.elements.append(
                 self._read_element(
                     Q_object, copy=copy, tlist=tlist, args=args, order=order,
-                    function_style=function_style
+                    function_style=function_style, bc_type=bc_type
                 )
             )
 
         if compress:
             self.compress()
 
-    def _read_element(self, op, copy, tlist, args, order, function_style):
+    def _read_element(self, op, copy, tlist, args, order, function_style, bc_type):
         """ Read a Q_object item and return an element for that item. """
         if isinstance(op, Qobj):
             out = _ConstantElement(op.copy() if copy else op)
@@ -239,7 +250,7 @@ cdef class QobjEvo:
         elif isinstance(op, list):
             out = _EvoElement(
                 op[0].copy() if copy else op[0],
-                coefficient(op[1], tlist=tlist, args=args, order=order)
+                coefficient(op[1], tlist=tlist, args=args, order=order, bc_type=bc_type)
             )
             qobj = op[0]
         elif isinstance(op, _BaseElement):
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 02287c5f58..a2ac041e17 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -372,6 +372,10 @@ def test_CoeffFromScipy():
     from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
     _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
 
+    coeff = coefficient(y, tlist=tlist, order=3, bc_type=([(2, 0.0)],[(2, 0.0)]))
+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
 
 @pytest.mark.parametrize('map_func', [
     pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),

From 0d62169f9eeeff0abc5f0dfde6da9d54162dede6 Mon Sep 17 00:00:00 2001
From: awkwardPotato812 <srinidhi.812@gmail.com>
Date: Thu, 9 Mar 2023 21:18:54 +0530
Subject: [PATCH 131/602] Create new entry in changelog

---
 doc/changes/2114.misc | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 doc/changes/2114.misc

diff --git a/doc/changes/2114.misc b/doc/changes/2114.misc
new file mode 100644
index 0000000000..77a7c22f81
--- /dev/null
+++ b/doc/changes/2114.misc
@@ -0,0 +1,2 @@
+Added new argument bc_type to take boundary conditions when creating QobjEvo
+

From dd28bca79ad5c7ae3f4538c05d3a5a41ba633eae Mon Sep 17 00:00:00 2001
From: awkwardPotato812 <srinidhi.812@gmail.com>
Date: Thu, 9 Mar 2023 21:24:27 +0530
Subject: [PATCH 132/602] Fix blank whitespace

---
 qutip/core/coefficient.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 19f8eacdc4..e2e9256bdb 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -149,7 +149,7 @@ def f2_t(t, args):
 
     compile_opt : CompilationOptions, optional
         Sets of options for the compilation of string based coefficients.
-    
+
     bc_type: 2-tupule or None, optional
         Specify boundary conditions for spline interpolation.
 

From 46c89bb52c8805b1df418bc319a6db2ac7a835b0 Mon Sep 17 00:00:00 2001
From: Srinidhi P V <6483203+awkwardPotato812@users.noreply.github.com>
Date: Fri, 10 Mar 2023 10:59:48 +0530
Subject: [PATCH 133/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/coefficient.py     | 4 ++--
 qutip/core/cy/coefficient.pyx | 1 -
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index e2e9256bdb..c73799a78a 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -54,7 +54,7 @@ def _return(base, **kwargs):
 
 def coefficient(base, *, tlist=None, args={}, args_ctypes={},
                 order=3, compile_opt=None, function_style=None,
-                bc_type=None, **kwargs):
+                boundary_conditions=None, **kwargs):
     """Build ``Coefficient`` for time dependent systems:
 
     ```
@@ -163,7 +163,7 @@ def f2_t(t, args):
         'order': order,
         'compile_opt': compile_opt,
         'function_style': function_style,
-        'bc_type': bc_type
+        'bc_type': bc_type,
     })
 
     for type_ in coefficient_builders:
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 659567e841..36c79377c7 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -396,7 +396,6 @@ cdef class InterCoefficient(Coefficient):
         ```t```. The condition specified must be an iterable pair of form (`order`,
         `value`). Refer to Scipy's documentation for further details:
         https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-
     """
     cdef int order
     cdef double dt

From 550ad44e9c4b11f80bc57ee229901604e2759ccd Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Fri, 10 Mar 2023 14:47:21 +0530
Subject: [PATCH 134/602] made pep8 compliant

---
 qutip/ipynbtools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 633696a71d..4580cf782c 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -375,4 +375,4 @@ def update(n):
     video_encoded = b64encode(video).decode("ascii")
     video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
         video_encoded)
-    return HTML(video_tag)
\ No newline at end of file
+    return HTML(video_tag)

From 4dc52c3ba88b3c1ab30b5c09e59fc15926b494d0 Mon Sep 17 00:00:00 2001
From: gadhvirushiraj <gadhvirushiraj@gmail.com>
Date: Sat, 11 Mar 2023 20:27:55 +0530
Subject: [PATCH 135/602] updated tests

---
 qutip/tests/test_ipynbtools.py | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/qutip/tests/test_ipynbtools.py b/qutip/tests/test_ipynbtools.py
index 76a46db3f8..2b1c76559a 100644
--- a/qutip/tests/test_ipynbtools.py
+++ b/qutip/tests/test_ipynbtools.py
@@ -1,9 +1,24 @@
 from qutip.ipynbtools import version_table
-import sys
+import pytest
 
 
-def test_version_table():
-    if 'Cython' in sys.modules:
-        assert 'Cython' in version_table().data
-    else:
-        assert 'Cython' not in version_table().data
+@pytest.mark.parametrize('verbose', [False, True])
+def test_version_table(verbose):
+    html_data = version_table(verbose=verbose).data
+    assert "<th>Software</th>" in html_data
+    assert "<th>Version</th>" in html_data
+    assert "<td>QuTiP</td>" in html_data
+    assert "<td>Numpy</td>" in html_data
+    assert "<td>SciPy</td>" in html_data
+    assert "<td>matplotlib</td>" in html_data
+    assert "<td>IPython</td>" in html_data
+    if verbose:
+        assert "<td>Installation path</td>" in html_data
+        if pytest.importorskip("getpass") is not None:
+            assert "<td>User</td>" in html_data
+
+
+@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
+def test_version_table_with_cython():
+    html_data = version_table().data
+    assert "<td>Cython</td>" in html_data

From 5631e39239ef31726f581934ddb54afe0c334cbf Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Sat, 11 Mar 2023 21:18:45 +0530
Subject: [PATCH 136/602] Change the repr format. Added tests

---
 qutip/core/cy/qobjevo.pyx        |  2 +-
 qutip/tests/core/test_qobjevo.py | 39 ++++++++++++++++++++++----------
 2 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 942a8d38b6..4899edaa8b 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -234,7 +234,7 @@ cdef class QobjEvo:
 
     def __repr__(self):
         cls = self.__class__.__name__
-        return f'<{cls}: dims={self.dims}, shape={self.shape}, type={self.type}, superrep={self.superrep}, isconstant={self.isconstant}, num_elements={self.num_elements}>'
+        return f'{cls}: dims={self.dims}, shape={self.shape}, type={self.type}, superrep={self.superrep}, isconstant={self.isconstant}, num_elements={self.num_elements}'
 
     def _read_element(self, op, copy, tlist, args, order, function_style):
         """ Read a Q_object item and return an element for that item. """
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index a53c202a77..82033a13f5 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -1,8 +1,9 @@
 import operator
 
 import pytest
-from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
-                   rand_stochastic, rand_herm, rand_ket, liouvillian)
+from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz, 
+                   rand_stochastic, rand_herm, rand_ket, liouvillian, 
+                   basis, spre, spost, to_choi)
 import numpy as np
 from numpy.testing import assert_allclose
 
@@ -133,20 +134,34 @@ def test_call(pseudo_qevo, coeff_type):
 
 # Test the QobjEvo.__repr__()
 def test_QobjEvo_repr():
-    # Creation of QobjEvo
-    case_1= QobjEvo([qeye(2), lambda t: t])
-    # Expected result from the __repr__()
-    expected_repr_1= "<QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=False, num_elements=1>"
+    # "case_n" are cases with different types of Objects of QobjEvo with unique __repr__
+    # "expected_repr_n" are the Expected result from the __repr__() of the QobjEvo objects
+
+    case_1= repr(QobjEvo([qeye(3), lambda t: t]))
+    expected_repr_1= 'QobjEvo: dims=[[3], [3]], shape=(3, 3), type=oper, superrep=None, isconstant=False, num_elements=1'
     assert case_1 == expected_repr_1
-    # Creation of QobjEvo
-    case_2= QobjEvo(qeye(2), lambda t: t)
-    case_3= QobjEvo([qeye(2)])
-    case_4= QobjEvo(qeye(2))
-    # Expected result from the __repr__()
-    expected_repr_2_3_4= "<QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=True, num_elements=1>"
+
+    case_2= repr(QobjEvo(qeye(2), lambda t: t))
+    case_3= repr(QobjEvo([qeye(2)]))
+    case_4= repr(QobjEvo(qeye(2)))
+    expected_repr_2_3_4= 'QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=True, num_elements=1'
     assert case_2 == expected_repr_2_3_4
     assert case_3 == expected_repr_2_3_4
     assert case_4 == expected_repr_2_3_4
+    
+    case_5= repr(QobjEvo(basis(5, 2)))
+    expected_repr_5= 'QobjEvo: dims=[[5], [1]], shape=(5, 1), type=ket, superrep=None, isconstant=True, num_elements=1'
+    assert case_5 == expected_repr_5
+
+    X = sigmax()
+    S = spre(X) * spost(X.dag())
+    case_6= repr(QobjEvo(to_choi(S)))
+    expected_repr_6= 'QobjEvo: dims=[[[2], [2]], [[2], [2]]], shape=(4, 4), type=super, superrep=choi, isconstant=True, num_elements=1'
+    assert case_6 == expected_repr_6
+
+    case_7= repr(QobjEvo([[qeye(4), lambda t: t], [qeye(4), lambda t: t]], compress=False))
+    expected_repr_7= 'QobjEvo: dims=[[4], [4]], shape=(4, 4), type=oper, superrep=None, isconstant=False, num_elements=2'
+    assert case_7 == expected_repr_7
 
 
 @pytest.mark.parametrize('coeff_type',

From a5fdd1f0466bcb54037d3d2775b3c93a874c003d Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar+github@gmail.com>
Date: Sat, 11 Mar 2023 22:21:11 +0100
Subject: [PATCH 137/602] Remove trailing whitespace.

---
 qutip/ipynbtools.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 4580cf782c..1c96c29735 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -78,7 +78,6 @@ def version_table(verbose=False):
                 ("Python", sys.version),
                 ("OS", "%s [%s]" % (os.name, sys.platform))
                 ]
-    
     if _cython_available:
         packages.append(("Cython", Cython.__version__))
 

From b810f278d114ed1a4401395a4152f388ee96bcf8 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Mar 2023 14:29:56 +0100
Subject: [PATCH 138/602] Remove qutip.control package.

---
 qutip/control/__init__.py    |    1 -
 qutip/control/cy_grape.pyx   |   96 --
 qutip/control/dump.py        |  956 -----------------
 qutip/control/dynamics.py    | 1751 -------------------------------
 qutip/control/errors.py      |   83 --
 qutip/control/fidcomp.py     |  746 --------------
 qutip/control/grape.py       |  603 -----------
 qutip/control/io.py          |   55 -
 qutip/control/loadparams.py  |  193 ----
 qutip/control/optimconfig.py |   97 --
 qutip/control/optimizer.py   | 1308 -----------------------
 qutip/control/optimresult.py |  104 --
 qutip/control/propcomp.py    |  405 --------
 qutip/control/pulsegen.py    | 1250 ----------------------
 qutip/control/pulseoptim.py  | 1884 ----------------------------------
 qutip/control/stats.py       |  383 -------
 qutip/control/symplectic.py  |   39 -
 qutip/control/termcond.py    |   63 --
 qutip/control/tslotcomp.py   |  704 -------------
 19 files changed, 10721 deletions(-)
 delete mode 100644 qutip/control/__init__.py
 delete mode 100644 qutip/control/cy_grape.pyx
 delete mode 100644 qutip/control/dump.py
 delete mode 100644 qutip/control/dynamics.py
 delete mode 100644 qutip/control/errors.py
 delete mode 100644 qutip/control/fidcomp.py
 delete mode 100644 qutip/control/grape.py
 delete mode 100644 qutip/control/io.py
 delete mode 100644 qutip/control/loadparams.py
 delete mode 100644 qutip/control/optimconfig.py
 delete mode 100644 qutip/control/optimizer.py
 delete mode 100644 qutip/control/optimresult.py
 delete mode 100644 qutip/control/propcomp.py
 delete mode 100644 qutip/control/pulsegen.py
 delete mode 100644 qutip/control/pulseoptim.py
 delete mode 100644 qutip/control/stats.py
 delete mode 100644 qutip/control/symplectic.py
 delete mode 100644 qutip/control/termcond.py
 delete mode 100644 qutip/control/tslotcomp.py

diff --git a/qutip/control/__init__.py b/qutip/control/__init__.py
deleted file mode 100644
index 5a270b50c0..0000000000
--- a/qutip/control/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from qutip.control.grape import *
diff --git a/qutip/control/cy_grape.pyx b/qutip/control/cy_grape.pyx
deleted file mode 100644
index c43f3f53e8..0000000000
--- a/qutip/control/cy_grape.pyx
+++ /dev/null
@@ -1,96 +0,0 @@
-#cython: language_level=3
-
-import numpy as np
-cimport numpy as np
-cimport cython
-cimport libc.math
-
-DTYPE = np.float64
-ctypedef np.float64_t DTYPE_t
-
-ITYPE = np.int32
-ctypedef np.int32_t ITYPE_t
-
-CTYPE = np.complex128
-ctypedef np.complex128_t CTYPE_t
-
-CTYPE = np.int64
-ctypedef np.int64_t LTYPE_t
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef CTYPE_t cy_overlap(object op1, object op2):
-
-    cdef Py_ssize_t row
-    cdef CTYPE_t tr = 0.0
-
-    op1 = op1.T.tocsr()
-
-    cdef int col1, row1_idx_start, row1_idx_end
-    cdef np.ndarray[CTYPE_t, ndim=1, mode="c"] data1 = op1.data.conj()
-    cdef np.ndarray[ITYPE_t, ndim=1, mode="c"] idx1 = op1.indices
-    cdef np.ndarray[ITYPE_t, ndim=1, mode="c"] ptr1 = op1.indptr
-
-    cdef int col2, row2_idx_start, row2_idx_end
-    cdef np.ndarray[CTYPE_t, ndim=1, mode="c"] data2 = op2.data
-    cdef np.ndarray[ITYPE_t, ndim=1, mode="c"] idx2 = op2.indices
-    cdef np.ndarray[ITYPE_t, ndim=1, mode="c"] ptr2 = op2.indptr
-
-    cdef int num_rows = ptr1.shape[0]-1
-
-    for row in range(num_rows):
-
-        row1_idx_start = ptr1[row]
-        row1_idx_end = ptr1[row + 1]
-        for row1_idx from row1_idx_start <= row1_idx < row1_idx_end:
-            col1 = idx1[row1_idx]
-
-            row2_idx_start = ptr2[col1]
-            row2_idx_end = ptr2[col1 + 1]
-            for row2_idx from row2_idx_start <= row2_idx < row2_idx_end:
-                col2 = idx2[row2_idx]
-
-                if col2 == row:
-                    tr += data1[row1_idx] * data2[row2_idx]
-
-    return tr / op1.shape[0]
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef cy_grape_inner(U, np.ndarray[DTYPE_t, ndim=3, mode="c"] u,
-                     int r, int J, int M, U_b_list, U_f_list, H_ops,
-                     float dt, float eps, float alpha, float beta,
-                     int phase_sensitive,
-                     int use_u_limits, float u_min, float u_max):
-
-    cdef int j, k
-
-    for m in range(M-1):
-        P = U_b_list[m] * U
-        for j in range(J):
-            Q = 1j * dt * H_ops[j] * U_f_list[m]
-
-            if phase_sensitive:
-                du = - cy_overlap(P, Q)
-            else:
-                du = - 2 * cy_overlap(P, Q) * cy_overlap(U_f_list[m], P)
-
-            if alpha > 0.0:
-                # penalty term for high power control signals u
-                du += -2 * alpha * u[r, j, m] * dt
-
-            if beta:
-                # penalty term for late control signals u
-                du += -2 * beta * m ** 2 * u[r, j, m] * dt
-
-            u[r + 1, j, m] = u[r, j, m] + eps * du.real
-
-            if use_u_limits:
-                if u[r + 1, j, m] < u_min:
-                    u[r + 1, j, m] = u_min
-                elif u[r + 1, j, m] > u_max:
-                    u[r + 1, j, m] = u_max
-
-    for j in range(J):
-        u[r + 1, j, M-1] = u[r + 1, j, M-2]
diff --git a/qutip/control/dump.py b/qutip/control/dump.py
deleted file mode 100644
index 7e707a65cd..0000000000
--- a/qutip/control/dump.py
+++ /dev/null
@@ -1,956 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Classes that enable the storing of historical objects created during the
-pulse optimisation.
-These are intented for debugging.
-See the optimizer and dynamics objects for instrutcions on how to enable
-data dumping.
-"""
-
-import os
-import copy
-import numpy as np
-from numpy.compat import asbytes
-# QuTiP control modules
-import qutip.control.io as qtrlio
-# QuTiP logging
-import qutip.logging_utils
-logger = qutip.logging_utils.get_logger('qutip.control.dump')
-
-DUMP_DIR = "~/.qtrl_dump"
-
-
-class Dump:
-    """
-    A container for dump items.
-    The lists for dump items is depends on the type
-    Note: abstract class
-
-    Attributes
-    ----------
-    parent : some control object (Dynamics or Optimizer)
-        aka the host. Object that generates the data that is dumped and is
-        host to this dump object.
-
-    dump_dir : str
-        directory where files (if any) will be written out
-        the path and be relative or absolute
-        use ~/ to specify user home directory
-        Note: files are only written when write_to_file is True
-        of writeout is called explicitly
-        Defaults to ~/.qtrl_dump
-
-    level : string
-        level of data dumping: SUMMARY, FULL or CUSTOM
-        See property docstring for details
-        Set automatically if dump is created by the setting host dumping attrib
-
-    write_to_file : bool
-        When set True data and summaries (as configured) will be written
-        interactively to file during the processing
-        Set during instantiation by the host based on its dump_to_file attrib
-
-    dump_file_ext : str
-        Default file extension for any file names that are auto generated
-
-    fname_base : str
-        First part of any auto generated file names.
-        This is usually overridden in the subclass
-
-    dump_summary : bool
-        If True a summary is recorded each time a new item is added to the
-        the dump.
-        Default is True
-
-    summary_sep : str
-        delimiter for the summary file.
-        default is a space
-
-    data_sep : str
-        delimiter for the data files (arrays saved to file).
-        default is a space
-
-    summary_file : str
-        File path for summary file.
-        Automatically generated. Can be set specifically
-
-    """
-    def __init__(self):
-        self.parent = None
-        self.reset()
-
-    def reset(self):
-        if self.parent is not None:
-            self.log_level = self.parent.log_level
-            self.write_to_file = self.parent.dump_to_file
-        else:
-            self.write_to_file = False
-        self._dump_dir = None
-        self.dump_file_ext = "txt"
-        self._fname_base = 'dump'
-        self.dump_summary = True
-        self.summary_sep = ' '
-        self.data_sep = ' '
-        self._summary_file_path = None
-        self._summary_file_specified = False
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    @property
-    def level(self):
-        """
-        The level of data dumping that will occur.
-
-        SUMMARY
-            A summary will be recorded
-
-        FULL
-            All possible dumping
-
-        CUSTOM
-            Some customised level of dumping
-
-        When first set to CUSTOM this is equivalent to SUMMARY. It is then up
-        to the user to specify what specifically is dumped
-        """
-        lvl = 'CUSTOM'
-        if (self.dump_summary and not self.dump_any):
-            lvl = 'SUMMARY'
-        elif (self.dump_summary and self.dump_all):
-            lvl = 'FULL'
-
-        return lvl
-
-    @level.setter
-    def level(self, value):
-        self._level = value
-        self._apply_level()
-
-    @property
-    def dump_any(self):
-        raise NotImplementedError(
-            "This is an abstract class, "
-            "use subclass such as DynamicsDump or OptimDump")
-
-    @property
-    def dump_all(self):
-        raise NotImplementedError(
-            "This is an abstract class, "
-            "use subclass such as DynamicsDump or OptimDump")
-
-    @property
-    def dump_dir(self):
-        if self._dump_dir is None:
-            self.create_dump_dir()
-        return self._dump_dir
-
-    @dump_dir.setter
-    def dump_dir(self, value):
-        self._dump_dir = value
-        if not self.create_dump_dir():
-            self._dump_dir = None
-
-    def create_dump_dir(self):
-        """
-        Checks dump directory exists, creates it if not
-        """
-        if self._dump_dir is None or len(self._dump_dir) == 0:
-            self._dump_dir = DUMP_DIR
-
-        dir_ok, self._dump_dir, msg = qtrlio.create_dir(
-                    self._dump_dir, desc='dump')
-
-        if not dir_ok:
-            self.write_to_file = False
-            msg += "\ndump file output will be suppressed."
-            logger.error(msg)
-
-        return dir_ok
-
-    @property
-    def fname_base(self):
-        return self._fname_base
-
-    @fname_base.setter
-    def fname_base(self, value):
-        if not isinstance(value, str):
-            raise ValueError("File name base must be a string")
-        self._fname_base = value
-        self._summary_file_path = None
-
-    @property
-    def summary_file(self):
-        if self._summary_file_path is None:
-            fname = "{}-summary.{}".format(self._fname_base,
-                                           self.dump_file_ext)
-            self._summary_file_path = os.path.join(self.dump_dir, fname)
-        return self._summary_file_path
-
-    @summary_file.setter
-    def summary_file(self, value):
-        if not isinstance(value, str):
-            raise ValueError("File path must be a string")
-        self._summary_file_specified = True
-        if os.path.abspath(value):
-            self._summary_file_path = value
-        elif '~' in value:
-            self._summary_file_path = os.path.expanduser(value)
-        else:
-            self._summary_file_path = os.path.join(self.dump_dir, value)
-
-
-class OptimDump(Dump):
-    """
-    A container for dumps of optimisation data generated during the pulse
-    optimisation.
-
-    Attributes
-    ----------
-    dump_summary : bool
-        When True summary items are appended to the iter_summary
-
-    iter_summary : list of :class:`qutip.control.optimizer.OptimIterSummary`
-        Summary at each iteration
-
-    dump_fid_err : bool
-        When True values are appended to the fid_err_log
-
-    fid_err_log : list of float
-        Fidelity error at each call of the fid_err_func
-
-    dump_grad_norm : bool
-        When True values are appended to the fid_err_log
-
-    grad_norm_log : list of float
-        Gradient norm at each call of the grad_norm_log
-
-    dump_grad : bool
-        When True values are appended to the grad_log
-
-    grad_log : list of ndarray
-        Gradients at each call of the fid_grad_func
-
-    """
-    def __init__(self, optim, level='SUMMARY'):
-        from qutip.control.optimizer import Optimizer
-        if not isinstance(optim, Optimizer):
-            raise TypeError("Must instantiate with {} type".format(
-                                        Optimizer))
-        self.parent = optim
-        self._level = level
-        self.reset()
-
-    def reset(self):
-        Dump.reset(self)
-        self._apply_level()
-        self.iter_summary = []
-        self.fid_err_log = []
-        self.grad_norm_log = []
-        self.grad_log = []
-        self._fname_base = 'optimdump'
-        self._fid_err_file = None
-        self._grad_norm_file = None
-
-    def clear(self):
-        del self.iter_summary[:]
-        del self.fid_err_log[:]
-        del self.grad_norm_log[:]
-        del self.grad_log[:]
-
-    @property
-    def dump_any(self):
-        """True if anything other than the summary is to be dumped"""
-        return self.dump_fid_err or self.dump_grad_norm or self.dump_grad
-
-    @property
-    def dump_all(self):
-        """True if everything (ignoring the summary) is to be dumped"""
-        return self.dump_fid_err and self.dump_grad_norm and self.dump_grad
-
-    def _apply_level(self, level=None):
-        if level is None:
-            level = self._level
-        if not isinstance(level, str):
-            raise ValueError("Dump level must be a string")
-        level = level.upper()
-        if level == 'CUSTOM':
-            if self._level == 'CUSTOM':
-                # dumping level has not changed keep the same specific config
-                pass
-            else:
-                # Switching to custom, start from SUMMARY
-                level = 'SUMMARY'
-
-        if level == 'SUMMARY':
-            self.dump_summary = True
-            self.dump_fid_err = False
-            self.dump_grad_norm = False
-            self.dump_grad = False
-        elif level == 'FULL':
-            self.dump_summary = True
-            self.dump_fid_err = True
-            self.dump_grad_norm = True
-            self.dump_grad = True
-        else:
-            raise ValueError("No option for dumping level '{}'".format(level))
-
-    def add_iter_summary(self):
-        """add copy of current optimizer iteration summary"""
-        optim = self.parent
-        if optim.iter_summary is None:
-            raise RuntimeError("Cannot add iter_summary as not available")
-        ois = copy.copy(optim.iter_summary)
-        ois.idx = len(self.iter_summary)
-        self.iter_summary.append(ois)
-        if self.write_to_file:
-            if ois.idx == 0:
-                f = open(self.summary_file, 'w')
-                f.write("{}\n{}\n".format(
-                            ois.get_header_line(self.summary_sep),
-                            ois.get_value_line(self.summary_sep)))
-            else:
-                f = open(self.summary_file, 'a')
-                f.write("{}\n".format(
-                            ois.get_value_line(self.summary_sep)))
-
-            f.close()
-        return ois
-
-    @property
-    def fid_err_file(self):
-        if self._fid_err_file is None:
-            fname = "{}-fid_err_log.{}".format(self.fname_base,
-                                               self.dump_file_ext)
-            self._fid_err_file = os.path.join(self.dump_dir, fname)
-        return self._fid_err_file
-
-    def update_fid_err_log(self, fid_err):
-        """add an entry to the fid_err log"""
-        self.fid_err_log.append(fid_err)
-        if self.write_to_file:
-            if len(self.fid_err_log) == 1:
-                mode = 'w'
-            else:
-                mode = 'a'
-            f = open(self.fid_err_file, mode)
-            f.write("{}\n".format(fid_err))
-            f.close()
-
-    @property
-    def grad_norm_file(self):
-        if self._grad_norm_file is None:
-            fname = "{}-grad_norm_log.{}".format(self.fname_base,
-                                                 self.dump_file_ext)
-            self._grad_norm_file = os.path.join(self.dump_dir, fname)
-        return self._grad_norm_file
-
-    def update_grad_norm_log(self, grad_norm):
-        """add an entry to the grad_norm log"""
-        self.grad_norm_log.append(grad_norm)
-        if self.write_to_file:
-            if len(self.grad_norm_log) == 1:
-                mode = 'w'
-            else:
-                mode = 'a'
-            f = open(self.grad_norm_file, mode)
-            f.write("{}\n".format(grad_norm))
-            f.close()
-
-    def update_grad_log(self, grad):
-        """add an entry to the grad log"""
-        self.grad_log.append(grad)
-        if self.write_to_file:
-            fname = "{}-fid_err_gradients{}.{}".format(self.fname_base,
-                                                       len(self.grad_log),
-                                                       self.dump_file_ext)
-            fpath = os.path.join(self.dump_dir, fname)
-            np.savetxt(fpath, grad, delimiter=self.data_sep)
-
-    def writeout(self, f=None):
-        """write all the logs and the summary out to file(s)
-
-        Parameters
-        ----------
-        f : filename or filehandle
-            If specified then all summary and  object data will go in one file.
-            If None is specified then type specific files will be generated
-            in the dump_dir
-            If a filehandle is specified then it must be a byte mode file
-            as numpy.savetxt is used, and requires this.
-        """
-        fall = None
-        # If specific file given then write everything to it
-        if hasattr(f, 'write'):
-            if 'b' not in f.mode:
-                raise RuntimeError("File stream must be in binary mode")
-            # write all to this stream
-            fall = f
-            fs = f
-            closefall = False
-            closefs = False
-        elif f:
-            # Assume f is a filename
-            fall = open(f, 'wb')
-            fs = fall
-            closefs = False
-            closefall = True
-        else:
-            self.create_dump_dir()
-            closefall = False
-            if self.dump_summary:
-                fs = open(self.summary_file, 'wb')
-                closefs = True
-
-        if self.dump_summary:
-            for ois in self.iter_summary:
-                if ois.idx == 0:
-                    fs.write(asbytes("{}\n{}\n".format(
-                                ois.get_header_line(self.summary_sep),
-                                ois.get_value_line(self.summary_sep))))
-                else:
-                    fs.write(asbytes("{}\n".format(
-                                ois.get_value_line(self.summary_sep))))
-
-            if closefs:
-                fs.close()
-                logger.info("Optim dump summary saved to {}".format(
-                                                    self.summary_file))
-
-        if self.dump_fid_err:
-            if fall:
-                fall.write(asbytes("Fidelity errors:\n"))
-                np.savetxt(fall, self.fid_err_log)
-            else:
-                np.savetxt(self.fid_err_file, self.fid_err_log)
-
-        if self.dump_grad_norm:
-            if fall:
-                fall.write(asbytes("gradients norms:\n"))
-                np.savetxt(fall, self.grad_norm_log)
-            else:
-                np.savetxt(self.grad_norm_file, self.grad_norm_log)
-
-        if self.dump_grad:
-            g_num = 0
-            for grad in self.grad_log:
-                g_num += 1
-                if fall:
-                    fall.write(asbytes("gradients (call {}):\n".format(g_num)))
-                    np.savetxt(fall, grad)
-                else:
-                    fname =\
-                        "{}-fid_err_gradients{}.{}".format(self.fname_base,
-                                                           g_num,
-                                                           self.dump_file_ext)
-                    fpath = os.path.join(self.dump_dir, fname)
-                    np.savetxt(fpath, grad, delimiter=self.data_sep)
-
-        if closefall:
-            fall.close()
-            logger.info("Optim dump saved to {}".format(f))
-        else:
-            if fall:
-                logger.info("Optim dump saved to specified stream")
-            else:
-                logger.info("Optim dump saved to {}".format(self.dump_dir))
-
-
-class DynamicsDump(Dump):
-    """
-    A container for dumps of dynamics data. Mainly time evolution calculations.
-
-    Attributes
-    ----------
-    dump_summary : bool
-        If True a summary is recorded
-
-    evo_summary : list of :class:`tslotcomp.EvoCompSummary`
-        Summary items are appended if dump_summary is True
-        at each recomputation of the evolution.
-
-    dump_amps : bool
-        If True control amplitudes are dumped
-
-    dump_dyn_gen : bool
-        If True the dynamics generators (Hamiltonians) are dumped
-
-    dump_prop : bool
-        If True propagators are dumped
-
-    dump_prop_grad : bool
-        If True propagator gradients are dumped
-
-    dump_fwd_evo : bool
-        If True forward evolution operators are dumped
-
-    dump_onwd_evo : bool
-        If True onward evolution operators are dumped
-
-    dump_onto_evo : bool
-        If True onto (or backward) evolution operators are dumped
-
-    evo_dumps : list of :class:`EvoCompDumpItem`
-        A new dump item is appended at each recomputation of the evolution.
-        That is if any of the calculation objects are to be dumped.
-
-    """
-    def __init__(self, dynamics, level='SUMMARY'):
-        from qutip.control.dynamics import Dynamics
-        if not isinstance(dynamics, Dynamics):
-            raise TypeError("Must instantiate with {} type".format(
-                                        Dynamics))
-        self.parent = dynamics
-        self._level = level
-        self.reset()
-
-    def reset(self):
-        Dump.reset(self)
-        self._apply_level()
-        self.evo_dumps = []
-        self.evo_summary = []
-        self._fname_base = 'dyndump'
-
-    def clear(self):
-        del self.evo_dumps[:]
-        del self.evo_summary[:]
-
-    @property
-    def dump_any(self):
-        """True if any of the calculation objects are to be dumped"""
-        return any([
-            self.dump_amps,
-            self.dump_dyn_gen,
-            self.dump_prop,
-            self.dump_prop_grad,
-            self.dump_fwd_evo,
-            self.dump_onwd_evo,
-            self.dump_onto_evo,
-        ])
-
-    @property
-    def dump_all(self):
-        """True if all of the calculation objects are to be dumped"""
-        dyn = self.parent
-        return all([
-            self.dump_amps,
-            self.dump_dyn_gen,
-            self.dump_prop,
-            self.dump_prop_grad,
-            self.dump_fwd_evo,
-            self.dump_onwd_evo == dyn.fid_computer.uses_onwd_evo,
-            self.dump_onto_evo == dyn.fid_computer.uses_onto_evo,
-        ])
-
-    def _apply_level(self, level=None):
-        dyn = self.parent
-        if level is None:
-            level = self._level
-
-        if not isinstance(level, str):
-            raise ValueError("Dump level must be a string")
-        level = level.upper()
-        if level == 'CUSTOM':
-            if self._level == 'CUSTOM':
-                # dumping level has not changed keep the same specific config
-                pass
-            else:
-                # Switching to custom, start from SUMMARY
-                level = 'SUMMARY'
-
-        if level == 'SUMMARY':
-            self.dump_summary = True
-            self.dump_amps = False
-            self.dump_dyn_gen = False
-            self.dump_prop = False
-            self.dump_prop_grad = False
-            self.dump_fwd_evo = False
-            self.dump_onwd_evo = False
-            self.dump_onto_evo = False
-        elif level == 'FULL':
-            self.dump_summary = True
-            self.dump_amps = True
-            self.dump_dyn_gen = True
-            self.dump_prop = True
-            self.dump_prop_grad = True
-            self.dump_fwd_evo = True
-            self.dump_onwd_evo = dyn.fid_computer.uses_onwd_evo
-            self.dump_onto_evo = dyn.fid_computer.uses_onto_evo
-        else:
-            raise ValueError("No option for dumping level '{}'".format(level))
-
-    def add_evo_dump(self):
-        """Add dump of current time evolution generating objects"""
-        dyn = self.parent
-        item = EvoCompDumpItem(self)
-        item.idx = len(self.evo_dumps)
-        self.evo_dumps.append(item)
-        if self.dump_amps:
-            item.ctrl_amps = copy.deepcopy(dyn.ctrl_amps)
-        if self.dump_dyn_gen:
-            item.dyn_gen = copy.deepcopy(dyn._dyn_gen)
-        if self.dump_prop:
-            item.prop = copy.deepcopy(dyn._prop)
-        if self.dump_prop_grad:
-            item.prop_grad = copy.deepcopy(dyn._prop_grad)
-        if self.dump_fwd_evo:
-            item.fwd_evo = copy.deepcopy(dyn._fwd_evo)
-        if self.dump_onwd_evo:
-            item.onwd_evo = copy.deepcopy(dyn._onwd_evo)
-        if self.dump_onto_evo:
-            item.onto_evo = copy.deepcopy(dyn._onto_evo)
-
-        if self.write_to_file:
-            item.writeout()
-        return item
-
-    def add_evo_comp_summary(self, dump_item_idx=None):
-        """add copy of current evo comp summary"""
-        dyn = self.parent
-        if dyn.tslot_computer.evo_comp_summary is None:
-            raise RuntimeError("Cannot add evo_comp_summary as not available")
-        ecs = copy.copy(dyn.tslot_computer.evo_comp_summary)
-        ecs.idx = len(self.evo_summary)
-        ecs.evo_dump_idx = dump_item_idx
-        if dyn.stats:
-            ecs.iter_num = dyn.stats.num_iter
-            ecs.fid_func_call_num = dyn.stats.num_fidelity_func_calls
-            ecs.grad_func_call_num = dyn.stats.num_grad_func_calls
-
-        self.evo_summary.append(ecs)
-        if self.write_to_file:
-            if ecs.idx == 0:
-                f = open(self.summary_file, 'w')
-                f.write("{}\n{}\n".format(
-                        ecs.get_header_line(self.summary_sep),
-                        ecs.get_value_line(self.summary_sep)))
-            else:
-                f = open(self.summary_file, 'a')
-                f.write("{}\n".format(ecs.get_value_line(self.summary_sep)))
-
-            f.close()
-        return ecs
-
-    def writeout(self, f=None):
-        """
-        Write all the dump items and the summary out to file(s).
-
-        Parameters
-        ----------
-        f : filename or filehandle
-            If specified then all summary and object data will go in one file.
-            If None is specified then type specific files will be generated in
-            the dump_dir.  If a filehandle is specified then it must be a byte
-            mode file as numpy.savetxt is used, and requires this.
-        """
-        fall = None
-        # If specific file given then write everything to it
-        if hasattr(f, 'write'):
-            if 'b' not in f.mode:
-                raise RuntimeError("File stream must be in binary mode")
-            # write all to this stream
-            fall = f
-            fs = f
-            closefall = False
-            closefs = False
-        elif f:
-            # Assume f is a filename
-            fall = open(f, 'wb')
-            fs = fall
-            closefs = False
-            closefall = True
-        else:
-            self.create_dump_dir()
-            closefall = False
-            if self.dump_summary:
-                fs = open(self.summary_file, 'wb')
-                closefs = True
-
-        if self.dump_summary:
-            for ecs in self.evo_summary:
-                if ecs.idx == 0:
-                    fs.write(asbytes("{}\n{}\n".format(
-                            ecs.get_header_line(self.summary_sep),
-                            ecs.get_value_line(self.summary_sep))))
-                else:
-                    fs.write(asbytes("{}\n".format(
-                            ecs.get_value_line(self.summary_sep))))
-
-            if closefs:
-                fs.close()
-                logger.info("Dynamics dump summary saved to {}".format(
-                                                    self.summary_file))
-
-        for di in self.evo_dumps:
-            di.writeout(fall)
-
-        if closefall:
-            fall.close()
-            logger.info("Dynamics dump saved to {}".format(f))
-        else:
-            if fall:
-                logger.info("Dynamics dump saved to specified stream")
-            else:
-                logger.info("Dynamics dump saved to {}".format(self.dump_dir))
-
-
-class DumpItem:
-    """
-    An item in a dump list
-    """
-    def __init__(self):
-        pass
-
-
-class EvoCompDumpItem(DumpItem):
-    """
-    A copy of all objects generated to calculate one time evolution. Note the
-    attributes are only set if the corresponding :class:`DynamicsDump`
-    ``dump_*`` attribute is set.
-    """
-    def __init__(self, dump):
-        if not isinstance(dump, DynamicsDump):
-            raise TypeError("Must instantiate with {} type".format(
-                                        DynamicsDump))
-        self.parent = dump
-        self.reset()
-
-    def reset(self):
-        self.idx = None
-        self.ctrl_amps = None
-        self.dyn_gen = None
-        self.prop = None
-        self.prop_grad = None
-        self.fwd_evo = None
-        self.onwd_evo = None
-        self.onto_evo = None
-
-    def writeout(self, f=None):
-        """ write all the objects out to files
-
-        Parameters
-        ----------
-        f : filename or filehandle
-            If specified then all object data will go in one file.
-            If None is specified then type specific files will be generated
-            in the dump_dir
-            If a filehandle is specified then it must be a byte mode file
-            as numpy.savetxt is used, and requires this.
-        """
-        dump = self.parent
-        fall = None
-        closefall = True
-        closef = False
-        # If specific file given then write everything to it
-        if hasattr(f, 'write'):
-            if 'b' not in f.mode:
-                raise RuntimeError("File stream must be in binary mode")
-            # write all to this stream
-            fall = f
-            closefall = False
-            f.write(asbytes("EVOLUTION COMPUTATION {}\n".format(self.idx)))
-        elif f:
-            fall = open(f, 'wb')
-        else:
-            # otherwise files for each type will be created
-            fnbase = "{}-evo{}".format(dump._fname_base, self.idx)
-            closefall = False
-
-        # ctrl amps
-        if self.ctrl_amps is not None:
-            if fall:
-                f = fall
-                f.write(asbytes("Ctrl amps\n"))
-            else:
-                fname = "{}-ctrl_amps.{}".format(fnbase,
-                                                 dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            np.savetxt(f, self.ctrl_amps, fmt='%14.6g',
-                       delimiter=dump.data_sep)
-            if closef:
-                f.close()
-
-        # dynamics generators
-        if self.dyn_gen is not None:
-            k = 0
-            if fall:
-                f = fall
-                f.write(asbytes("Dynamics Generators\n"))
-            else:
-                fname = "{}-dyn_gen.{}".format(fnbase,
-                                               dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            for dg in self.dyn_gen:
-                f.write(asbytes(
-                        "dynamics generator for timeslot {}\n".format(k)))
-                np.savetxt(f, self.dyn_gen[k], delimiter=dump.data_sep)
-                k += 1
-            if closef:
-                f.close()
-
-        # Propagators
-        if self.prop is not None:
-            k = 0
-            if fall:
-                f = fall
-                f.write(asbytes("Propagators\n"))
-            else:
-                fname = "{}-prop.{}".format(fnbase,
-                                            dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            for dg in self.dyn_gen:
-                f.write(asbytes("Propagator for timeslot {}\n".format(k)))
-                np.savetxt(f, self.prop[k], delimiter=dump.data_sep)
-                k += 1
-            if closef:
-                f.close()
-
-        # Propagator gradient
-        if self.prop_grad is not None:
-            k = 0
-            if fall:
-                f = fall
-                f.write(asbytes("Propagator gradients\n"))
-            else:
-                fname = "{}-prop_grad.{}".format(fnbase,
-                                                 dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            for k in range(self.prop_grad.shape[0]):
-                for j in range(self.prop_grad.shape[1]):
-                    f.write(asbytes("Propagator gradient for timeslot {} "
-                            "control {}\n".format(k, j)))
-                    np.savetxt(f, self.prop_grad[k, j],
-                               delimiter=dump.data_sep)
-            if closef:
-                f.close()
-
-        # forward evolution
-        if self.fwd_evo is not None:
-            k = 0
-            if fall:
-                f = fall
-                f.write(asbytes("Forward evolution\n"))
-            else:
-                fname = "{}-fwd_evo.{}".format(fnbase,
-                                               dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            for dg in self.dyn_gen:
-                f.write(asbytes("Evolution from 0 to {}\n".format(k)))
-                np.savetxt(f, self.fwd_evo[k], delimiter=dump.data_sep)
-                k += 1
-            if closef:
-                f.close()
-
-        # onward evolution
-        if self.onwd_evo is not None:
-            k = 0
-            if fall:
-                f = fall
-                f.write(asbytes("Onward evolution\n"))
-            else:
-                fname = "{}-onwd_evo.{}".format(fnbase,
-                                                dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            for dg in self.dyn_gen:
-                f.write(asbytes("Evolution from {} to end\n".format(k)))
-                np.savetxt(f, self.fwd_evo[k], delimiter=dump.data_sep)
-                k += 1
-            if closef:
-                f.close()
-
-        # onto evolution
-        if self.onto_evo is not None:
-            k = 0
-            if fall:
-                f = fall
-                f.write(asbytes("Onto evolution\n"))
-            else:
-                fname = "{}-onto_evo.{}".format(fnbase,
-                                                dump.dump_file_ext)
-                f = open(os.path.join(dump.dump_dir, fname), 'wb')
-                closef = True
-            for dg in self.dyn_gen:
-                f.write(asbytes("Evolution from {} onto target\n".format(k)))
-                np.savetxt(f, self.fwd_evo[k], delimiter=dump.data_sep)
-                k += 1
-            if closef:
-                f.close()
-
-        if closefall:
-            fall.close()
-
-class DumpSummaryItem:
-    """
-    A summary of the most recent iteration.  Abstract class only.
-
-    Attributes
-    ----------
-    idx : int
-        Index in the summary list in which this is stored
-    """
-    min_col_width = 11
-    summary_property_names = ()
-    summary_property_fmt_type = ()
-    summary_property_fmt_prec = ()
-
-    @classmethod
-    def get_header_line(cls, sep=' '):
-        if sep == ' ':
-            line = ''
-            i = 0
-            for a in cls.summary_property_names:
-                if i > 0:
-                    line += sep
-                i += 1
-                line += format(a, str(max(len(a), cls.min_col_width)) + 's')
-        else:
-            line = sep.join(cls.summary_property_names)
-        return line
-
-    def reset(self):
-        self.idx = 0
-
-    def get_value_line(self, sep=' '):
-        line = ""
-        i = 0
-        for a in zip(self.summary_property_names,
-                     self.summary_property_fmt_type,
-                     self.summary_property_fmt_prec):
-            if i > 0:
-                line += sep
-            i += 1
-            v = getattr(self, a[0])
-            w = max(len(a[0]), self.min_col_width)
-            if v is not None:
-                fmt = ''
-                if sep == ' ':
-                    fmt += str(w)
-                else:
-                    fmt += '0'
-                if a[2] > 0:
-                    fmt += '.' + str(a[2])
-                fmt += a[1]
-                line += format(v, fmt)
-            else:
-                if sep == ' ':
-                    line += format('None', str(w) + 's')
-                else:
-                    line += 'None'
-
-        return line
diff --git a/qutip/control/dynamics.py b/qutip/control/dynamics.py
deleted file mode 100644
index 70600392ed..0000000000
--- a/qutip/control/dynamics.py
+++ /dev/null
@@ -1,1751 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Classes that define the dynamics of the (quantum) system and target evolution
-to be optimised.
-The contols are also defined here, i.e. the dynamics generators (Hamiltonians,
-Limbladians etc). The dynamics for the time slices are calculated here, along
-with the evolution as determined by the control amplitudes.
-
-See the subclass descriptions and choose the appropriate class for the
-application. The choice depends on the type of matrix used to define
-the dynamics.
-
-These class implement functions for getting the dynamics generators for
-the combined (drift + ctrls) dynamics with the approriate operator applied
-
-Note the methods in these classes were inspired by:
-DYNAMO - Dynamic Framework for Quantum Optimal Control
-See Machnes et.al., arXiv.1011.4874
-"""
-import warnings
-import numpy as np
-import scipy.linalg as la
-import scipy.sparse as sp
-# QuTiP
-from qutip import Qobj
-from qutip.core import data as _data
-from qutip.core.data.eigen import eigh
-from qutip.settings import settings
-# QuTiP control modules
-import qutip.control.errors as errors
-import qutip.control.tslotcomp as tslotcomp
-import qutip.control.fidcomp as fidcomp
-import qutip.control.propcomp as propcomp
-import qutip.control.symplectic as sympl
-import qutip.control.dump as qtrldump
-# QuTiP logging
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-DEF_NUM_TSLOTS = 10
-DEF_EVO_TIME = 1.0
-
-
-def _check_ctrls_container(ctrls):
-    """
-    Check through the controls container.
-    Convert to an array if its a list of lists
-    return the processed container
-    raise type error if the container structure is invalid
-    """
-    if isinstance(ctrls, (list, tuple)):
-        # Check to see if list of lists
-        try:
-            if isinstance(ctrls[0], (list, tuple)):
-                ctrls_ = np.empty((len(ctrls), len(ctrls[0])), dtype=object)
-                for i, ctrl in enumerate(ctrls):
-                    ctrls_[i, :] = ctrl
-                ctrls = ctrls_
-        except IndexError:
-            pass
-
-    if isinstance(ctrls, np.ndarray):
-        if len(ctrls.shape) != 2:
-            raise TypeError("Incorrect shape for ctrl dyn gen array")
-        for k in range(ctrls.shape[0]):
-            for j in range(ctrls.shape[1]):
-                if not isinstance(ctrls[k, j], Qobj):
-                    raise TypeError("All control dyn gen must be Qobj")
-    elif isinstance(ctrls, (list, tuple)):
-        for ctrl in ctrls:
-            if not isinstance(ctrl, Qobj):
-                raise TypeError("All control dyn gen must be Qobj")
-    else:
-        raise TypeError("Controls list or array not set correctly")
-
-    return ctrls
-
-
-def _check_drift_dyn_gen(drift):
-    if isinstance(drift, Qobj):
-        return
-    if not isinstance(drift, (list, tuple)):
-        raise TypeError("drift should be a Qobj or a list of Qobj")
-    for d in drift:
-        if not isinstance(d, Qobj):
-            raise TypeError("drift should be a Qobj or a list of Qobj")
-
-
-def _attrib_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-def _func_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-class Dynamics(object):
-    """
-    This is a base class only. See subclass descriptions and choose an
-    appropriate one for the application.
-
-    Note that initialize_controls must be called before most of the methods
-    can be used. init_timeslots can be called sometimes earlier in order
-    to access timeslot related attributes
-
-    This acts as a container for the operators that are used to calculate
-    time evolution of the system under study. That is the dynamics generators
-    (Hamiltonians, Lindbladians etc), the propagators from one timeslot to
-    the next, and the evolution operators. Due to the large number of matrix
-    additions and multiplications, for small systems at least, the optimisation
-    performance is much better using ndarrays to represent these operators.
-    However
-
-    Attributes
-    ----------
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip.logging_utils,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-
-    params:  Dictionary
-        The key value pairs are the attribute name and value
-        Note: attributes are created if they do not exist already,
-        and are overwritten if they do.
-
-    stats : Stats
-        Attributes of which give performance stats for the optimisation
-        set to None to reduce overhead of calculating stats.
-        Note it is (usually) shared with the Optimizer object
-
-    tslot_computer : TimeslotComputer (subclass instance)
-        Used to manage when the timeslot dynamics
-        generators, propagators, gradients etc are updated
-
-    prop_computer : PropagatorComputer (subclass instance)
-        Used to compute the propagators and their gradients
-
-    fid_computer : FidelityComputer (subclass instance)
-        Used to computer the fidelity error and the fidelity error
-        gradient.
-
-    memory_optimization : int
-        Level of memory optimisation. Setting to 0 (default) means that
-        execution speed is prioritized over memory.
-        Setting to 1 means that some memory prioritisation steps will be
-        taken, for instance using Qobj (and hence sparse arrays) as the
-        the internal operator data type, and not caching some operators
-        Potentially further memory saving maybe made with
-        memory_optimization > 1.
-        The options are processed in _set_memory_optimizations, see
-        this for more information. Individual memory saving  options can be
-        switched by settting them directly (see below)
-
-    oper_dtype : type
-        Data type for internal dynamics generators, propagators and time
-        evolution operators. This can be ndarray or Qobj.
-        Qobj may perform better for larger systems, and will also
-        perform better when (custom) fidelity measures use Qobj methods
-        such as partial trace.
-        See _choose_oper_dtype for how this is chosen when not specified
-
-    cache_phased_dyn_gen : bool
-        If True then the dynamics generators will be saved with and
-        without the propagation prefactor (if there is one)
-        Defaults to True when memory_optimization=0, otherwise False
-
-    cache_prop_grad : bool
-        If the True then the propagator gradients (for exact gradients) will
-        be computed when the propagator are computed and cache until
-        the are used by the fidelity computer. If False then the
-        fidelity computer will calculate them as needed.
-        Defaults to True when memory_optimization=0, otherwise False
-
-    cache_dyn_gen_eigenvectors_adj: bool
-        If True then DynamicsUnitary will cached the adjoint of
-        the Hamiltion eignvector matrix
-        Defaults to True when memory_optimization=0, otherwise False
-
-    sparse_eigen_decomp: bool
-        If True then DynamicsUnitary will use the sparse eigenvalue
-        decomposition.
-        Defaults to True when memory_optimization<=1, otherwise False
-
-    num_tslots : integer
-        Number of timeslots (aka timeslices)
-
-    num_ctrls : integer
-        Number of controls.
-        Note this is calculated as the length of ctrl_dyn_gen when first used.
-        And is recalculated during initialise_controls only.
-
-    evo_time : float
-        Total time for the evolution
-
-    tau : array[num_tslots] of float
-        Duration of each timeslot
-        Note that if this is set before initialize_controls is called
-        then num_tslots and evo_time are calculated from tau, otherwise
-        tau is generated from num_tslots and evo_time, that is
-        equal size time slices
-
-    time : array[num_tslots+1] of float
-        Cumulative time for the evolution, that is the time at the start
-        of each time slice
-
-    drift_dyn_gen : Qobj or list of Qobj
-        Drift or system dynamics generator (Hamiltonian)
-        Matrix defining the underlying dynamics of the system
-        Can also be a list of Qobj (length num_tslots) for time varying
-        drift dynamics
-
-    ctrl_dyn_gen : List of Qobj
-        Control dynamics generator (Hamiltonians)
-        List of matrices defining the control dynamics
-
-    initial : Qobj
-        Starting state / gate
-        The matrix giving the initial state / gate, i.e. at time 0
-        Typically the identity for gate evolution
-
-    target : Qobj
-        Target state / gate:
-        The matrix giving the desired state / gate for the evolution
-
-    ctrl_amps : array[num_tslots, num_ctrls] of float
-        Control amplitudes
-        The amplitude (scale factor) for each control in each timeslot
-
-    initial_ctrl_scaling : float
-        Scale factor applied to be applied the control amplitudes
-        when they are initialised
-        This is used by the PulseGens rather than in any fucntions in
-        this class
-
-    initial_ctrl_offset  : float
-        Linear offset applied to be applied the control amplitudes
-        when they are initialised
-        This is used by the PulseGens rather than in any fucntions in
-        this class
-
-    dyn_gen : List of Qobj
-        Dynamics generators
-        the combined drift and control dynamics generators
-        for each timeslot
-
-    prop : list of Qobj
-        Propagators - used to calculate time evolution from one
-        timeslot to the next
-
-    prop_grad : array[num_tslots, num_ctrls] of Qobj
-        Propagator gradient (exact gradients only)
-        Array  of Qobj that give the gradient
-        with respect to the control amplitudes in a timeslot
-        Note this attribute is only created when the selected
-        PropagatorComputer is an exact gradient type.
-
-    fwd_evo : List of Qobj
-        Forward evolution (or propagation)
-        the time evolution operator from the initial state / gate to the
-        specified timeslot as generated by the dyn_gen
-
-    onwd_evo : List of Qobj
-        Onward evolution (or propagation)
-        the time evolution operator from the specified timeslot to
-        end of the evolution time as generated by the dyn_gen
-
-    onto_evo : List of Qobj
-        'Backward' List of Qobj propagation
-        the overlap of the onward propagation with the inverse of the
-        target.
-        Note this is only used (so far) by the unitary dynamics fidelity
-
-    evo_current : Boolean
-        Used to flag that the dynamics used to calculate the evolution
-        operators is current. It is set to False when the amplitudes
-        change
-
-    fact_mat_round_prec : float
-        Rounding precision used when calculating the factor matrix
-        to determine if two eigenvalues are equivalent
-        Only used when the PropagatorComputer uses diagonalisation
-
-    def_amps_fname : string
-        Default name for the output used when save_amps is called
-
-    unitarity_check_level : int
-        If > 0 then unitarity of the system evolution is checked at at
-        evolution recomputation.
-        level 1 checks all propagators
-        level 2 checks eigen basis as well
-        Default is 0
-
-    unitarity_tol :
-        Tolerance used in checking if operator is unitary
-        Default is 1e-10
-
-    dump : :class:`qutip.control.dump.DynamicsDump`
-        Store of historical calculation data.
-        Set to None (Default) for no storing of historical data
-        Use dumping property to set level of data dumping
-
-    dumping : string
-        level of data dumping: NONE, SUMMARY, FULL or CUSTOM
-        See property docstring for details
-
-    dump_to_file : bool
-        If set True then data will be dumped to file during the calculations
-        dumping will be set to SUMMARY during init_evo if dump_to_file is True
-        and dumping not set.
-        Default is False
-
-    dump_dir : string
-        Basically a link to dump.dump_dir. Exists so that it can be set through
-        dyn_params.
-        If dump is None then will return None or will set dumping to SUMMARY
-        when setting a path
-
-    """
-    def __init__(self, optimconfig, params=None):
-        self.config = optimconfig
-        self.params = params
-        self.reset()
-
-    def reset(self):
-        # Link to optimiser object if self is linked to one
-        self.parent = None
-        # Main functional attributes
-        self.time = None
-        self.initial = None
-        self.target = None
-        self.ctrl_amps = None
-        self.initial_ctrl_scaling = 1.0
-        self.initial_ctrl_offset = 0.0
-        self.drift_dyn_gen = None
-        self.ctrl_dyn_gen = None
-        self._tau = None
-        self._evo_time = None
-        self._num_ctrls = None
-        self._num_tslots = None
-        # attributes used for processing evolution
-        self.memory_optimization = 0
-        self.oper_dtype = None
-        self.cache_phased_dyn_gen = None
-        self.cache_prop_grad = None
-        self.cache_dyn_gen_eigenvectors_adj = None
-        self.sparse_eigen_decomp = None
-        self.dyn_dims = None
-        self.dyn_shape = None
-        self.sys_dims = None
-        self.sys_shape = None
-        self.time_depend_drift = False
-        self.time_depend_ctrl_dyn_gen = False
-        # These internal attributes will be of the internal operator data type
-        # used to compute the evolution
-        # This will be either ndarray or Qobj
-        self._drift_dyn_gen = None
-        self._ctrl_dyn_gen = None
-        self._phased_ctrl_dyn_gen = None
-        self._dyn_gen_phase = None
-        self._phase_application = None
-        self._initial = None
-        self._target = None
-        self._onto_evo_target = None
-        self._dyn_gen = None
-        self._phased_dyn_gen = None
-        self._prop = None
-        self._prop_grad = None
-        self._fwd_evo = None
-        self._onwd_evo = None
-        self._onto_evo = None
-        # The _qobj attribs are Qobj representations of the equivalent
-        # internal attribute. They are only set when the extenal accessors
-        # are used
-        self._onto_evo_target_qobj = None
-        self._dyn_gen_qobj = None
-        self._prop_qobj = None
-        self._prop_grad_qobj = None
-        self._fwd_evo_qobj = None
-        self._onwd_evo_qobj = None
-        self._onto_evo_qobj = None
-        # Atrributes used in diagonalisation
-        # again in internal operator data type (see above)
-        self._decomp_curr = None
-        self._prop_eigen = None
-        self._dyn_gen_eigenvectors = None
-        self._dyn_gen_eigenvectors_adj = None
-        self._dyn_gen_factormatrix = None
-        self.fact_mat_round_prec = 1e-10
-
-        # Debug and information attribs
-        self.stats = None
-        self.id_text = 'DYN_BASE'
-        self.def_amps_fname = "ctrl_amps.txt"
-        self.log_level = self.config.log_level
-        # Internal flags
-        self._dyn_gen_mapped = False
-        self._evo_initialized = False
-        self._timeslots_initialized = False
-        self._ctrls_initialized = False
-        self._ctrl_dyn_gen_checked = False
-        self._drift_dyn_gen_checked = False
-        # Unitary checking
-        self.unitarity_check_level = 0
-        self.unitarity_tol = 1e-10
-        # Data dumping
-        self.dump = None
-        self.dump_to_file = False
-
-        self.apply_params()
-
-        # Create the computing objects
-        self._create_computers()
-
-        self.clear()
-
-    def apply_params(self, params=None):
-        """
-        Set object attributes based on the dictionary (if any) passed in the
-        instantiation, or passed as a parameter
-        This is called during the instantiation automatically.
-        The key value pairs are the attribute name and value
-        Note: attributes are created if they do not exist already,
-        and are overwritten if they do.
-        """
-        if not params:
-            params = self.params
-
-        if isinstance(params, dict):
-            self.params = params
-            for key in params:
-                setattr(self, key, params[key])
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    @property
-    def dumping(self):
-        """
-        The level of data dumping that will occur during the time evolution
-        calculation.
-
-        - NONE : No processing data dumped (Default)
-        - SUMMARY : A summary of each time evolution will be recorded
-        - FULL : All operators used or created in the calculation dumped
-        - CUSTOM : Some customised level of dumping
-
-        When first set to CUSTOM this is equivalent to SUMMARY. It is then up
-        to the user to specify which operators are dumped.  WARNING: FULL could
-        consume a lot of memory!
-        """
-        if self.dump is None:
-            lvl = 'NONE'
-        else:
-            lvl = self.dump.level
-
-        return lvl
-
-    @dumping.setter
-    def dumping(self, value):
-        if value is None:
-            self.dump = None
-        else:
-            if not isinstance(value, str):
-                raise TypeError("Value must be string value")
-            lvl = value.upper()
-            if lvl == 'NONE':
-                self.dump = None
-            else:
-                if not isinstance(self.dump, qtrldump.DynamicsDump):
-                    self.dump = qtrldump.DynamicsDump(self, level=lvl)
-                else:
-                    self.dump.level = lvl
-
-    @property
-    def dump_dir(self):
-        if self.dump:
-            return self.dump.dump_dir
-        else:
-            return None
-
-    @dump_dir.setter
-    def dump_dir(self, value):
-        if not self.dump:
-            self.dumping = 'SUMMARY'
-        self.dump.dump_dir = value
-
-    def _create_computers(self):
-        """
-        Create the default timeslot, fidelity and propagator computers
-        """
-        # The time slot computer. By default it is set to UpdateAll
-        # can be set to DynUpdate in the configuration
-        # (see class file for details)
-        if self.config.tslot_type == 'DYNAMIC':
-            self.tslot_computer = tslotcomp.TSlotCompDynUpdate(self)
-        else:
-            self.tslot_computer = tslotcomp.TSlotCompUpdateAll(self)
-
-        self.prop_computer = propcomp.PropCompFrechet(self)
-        self.fid_computer = fidcomp.FidCompTraceDiff(self)
-
-    def clear(self):
-        self.ctrl_amps = None
-        self.evo_current = False
-        if self.fid_computer is not None:
-            self.fid_computer.clear()
-
-    @property
-    def num_tslots(self):
-        if not self._timeslots_initialized:
-            self.init_timeslots()
-        return self._num_tslots
-
-    @num_tslots.setter
-    def num_tslots(self, value):
-        self._num_tslots = value
-        if self._timeslots_initialized:
-            self._tau = None
-            self.init_timeslots()
-
-    @property
-    def evo_time(self):
-        if not self._timeslots_initialized:
-            self.init_timeslots()
-        return self._evo_time
-
-    @evo_time.setter
-    def evo_time(self, value):
-        self._evo_time = value
-        if self._timeslots_initialized:
-            self._tau = None
-            self.init_timeslots()
-
-    @property
-    def tau(self):
-        if not self._timeslots_initialized:
-            self.init_timeslots()
-        return self._tau
-
-    @tau.setter
-    def tau(self, value):
-        self._tau = value
-        self.init_timeslots()
-
-    def init_timeslots(self):
-        """
-        Generate the timeslot duration array 'tau' based on the evo_time
-        and num_tslots attributes, unless the tau attribute is already set
-        in which case this step in ignored
-        Generate the cumulative time array 'time' based on the tau values
-        """
-        # set the time intervals to be equal timeslices of the total if
-        # the have not been set already (as part of user config)
-        if self._num_tslots is None:
-            self._num_tslots = DEF_NUM_TSLOTS
-        if self._evo_time is None:
-            self._evo_time = DEF_EVO_TIME
-
-        if self._tau is None:
-            self._tau = np.ones(self._num_tslots, dtype='f') * \
-                self._evo_time/self._num_tslots
-        else:
-            self._num_tslots = len(self._tau)
-            self._evo_time = np.sum(self._tau)
-
-        self.time = np.zeros(self._num_tslots+1, dtype=float)
-        # set the cumulative time by summing the time intervals
-        for t in range(self._num_tslots):
-            self.time[t+1] = self.time[t] + self._tau[t]
-
-        self._timeslots_initialized = True
-
-    def _set_memory_optimizations(self):
-        """
-        Set various memory optimisation attributes based on the
-        memory_optimization attribute
-        If they have been set already, e.g. in apply_params
-        then they will not be overridden here
-        """
-        logger.info("Setting memory optimisations for level {}".format(
-                    self.memory_optimization))
-
-        if self.oper_dtype is None:
-            self._choose_oper_dtype()
-            logger.info("Internal operator data type choosen to be {}".format(
-                            self.oper_dtype))
-        else:
-            logger.info("Using operator data type {}".format(
-                            self.oper_dtype))
-
-        if self.cache_phased_dyn_gen is None:
-            if self.memory_optimization > 0:
-                self.cache_phased_dyn_gen = False
-            else:
-                self.cache_phased_dyn_gen = True
-        logger.info("phased dynamics generator caching {}".format(
-                            self.cache_phased_dyn_gen))
-
-        if self.cache_prop_grad is None:
-            if self.memory_optimization > 0:
-                self.cache_prop_grad = False
-            else:
-                self.cache_prop_grad = True
-        logger.info("propagator gradient caching {}".format(
-                            self.cache_prop_grad))
-
-        if self.cache_dyn_gen_eigenvectors_adj is None:
-            if self.memory_optimization > 0:
-                self.cache_dyn_gen_eigenvectors_adj = False
-            else:
-                self.cache_dyn_gen_eigenvectors_adj = True
-        logger.info("eigenvector adjoint caching {}".format(
-                            self.cache_dyn_gen_eigenvectors_adj))
-
-        if self.sparse_eigen_decomp is None:
-            if self.memory_optimization > 1:
-                self.sparse_eigen_decomp = True
-            else:
-                self.sparse_eigen_decomp = False
-        logger.info("use sparse eigen decomp {}".format(
-                            self.sparse_eigen_decomp))
-
-    def _choose_oper_dtype(self):
-        """
-        Attempt select most efficient internal operator data type
-        """
-
-        if self.memory_optimization > 0:
-            self.oper_dtype = Qobj
-        else:
-            # Method taken from Qobj.expm()
-            # if method is not explicitly given, try to make a good choice
-            # between sparse and dense solvers by considering the size of the
-            # system and the number of non-zero elements.
-            if self.time_depend_drift:
-                dg = self.drift_dyn_gen[0]
-            else:
-                dg = self.drift_dyn_gen
-            if self.time_depend_ctrl_dyn_gen:
-                ctrls = self.ctrl_dyn_gen[0, :]
-            else:
-                ctrls = self.ctrl_dyn_gen
-            for c in ctrls:
-                dg = dg + c
-
-            N = dg.shape[0]
-            if isinstance(dg.data, _data.CSR):
-                n = _data.csr.nnz(dg.data)
-            else:
-                n = N**2
-
-            if N ** 2 < 100 * n:
-                # large number of nonzero elements, revert to dense solver
-                self.oper_dtype = np.ndarray
-            elif N > 400:
-                # large system, and quite sparse -> qutips sparse method
-                self.oper_dtype = Qobj
-            else:
-                # small system, but quite sparse -> qutips sparse/dense method
-                self.oper_dtype = np.ndarray
-
-        return self.oper_dtype
-
-    def _init_evo(self):
-        """
-        Create the container lists / arrays for the:
-        dynamics generations, propagators, and evolutions etc
-        Set the time slices and cumulative time
-        """
-        # check evolution operators
-        if not self._drift_dyn_gen_checked:
-            _check_drift_dyn_gen(self.drift_dyn_gen)
-        if not self._ctrl_dyn_gen_checked:
-            self.ctrl_dyn_gen = _check_ctrls_container(self.ctrl_dyn_gen)
-
-        if not isinstance(self.initial, Qobj):
-            raise TypeError("initial must be a Qobj")
-
-        if not isinstance(self.target, Qobj):
-            raise TypeError("target must be a Qobj")
-
-        self.refresh_drift_attribs()
-        self.sys_dims = self.initial.dims
-        self.sys_shape = self.initial.shape
-        # Set the phase application method
-        self._init_phase()
-
-        self._set_memory_optimizations()
-        if self.sparse_eigen_decomp and self.sys_shape[0] <= 2:
-            raise ValueError(
-                "Single qubit pulse optimization dynamics cannot use sparse"
-                " eigenvector decomposition because of limitations in"
-                " scipy.linalg.eigsh. Pleae set sparse_eigen_decomp to False"
-                " or increase the size of the system.")
-
-        n_ts = self.num_tslots
-        n_ctrls = self.num_ctrls
-        if self.oper_dtype == Qobj:
-            self._initial = self.initial
-            self._target = self.target
-            self._drift_dyn_gen = self.drift_dyn_gen
-            self._ctrl_dyn_gen = self.ctrl_dyn_gen
-        elif self.oper_dtype == np.ndarray:
-            self._initial = self.initial.full()
-            self._target = self.target.full()
-            if self.time_depend_drift:
-                self._drift_dyn_gen = [d.full() for d in self.drift_dyn_gen]
-            else:
-                self._drift_dyn_gen = self.drift_dyn_gen.full()
-            if self.time_depend_ctrl_dyn_gen:
-                self._ctrl_dyn_gen = np.empty([n_ts, n_ctrls], dtype=object)
-                for k in range(n_ts):
-                    for j in range(n_ctrls):
-                        self._ctrl_dyn_gen[k, j] = \
-                                    self.ctrl_dyn_gen[k, j].full()
-            else:
-                self._ctrl_dyn_gen = [ctrl.full()
-                                        for ctrl in self.ctrl_dyn_gen]
-        else:
-            raise ValueError(
-                "Unknown oper_dtype {!r}. The oper_dtype may be qutip.Qobj or"
-                " numpy.ndarray.".format(self.oper_dtype))
-
-        if self.cache_phased_dyn_gen:
-            if self.time_depend_ctrl_dyn_gen:
-                self._phased_ctrl_dyn_gen = np.empty([n_ts, n_ctrls],
-                                                     dtype=object)
-                for k in range(n_ts):
-                    for j in range(n_ctrls):
-                        self._phased_ctrl_dyn_gen[k, j] = self._apply_phase(
-                                    self._ctrl_dyn_gen[k, j])
-            else:
-                self._phased_ctrl_dyn_gen = [self._apply_phase(ctrl)
-                                             for ctrl in self._ctrl_dyn_gen]
-
-        self._dyn_gen = [object for x in range(self.num_tslots)]
-        if self.cache_phased_dyn_gen:
-            self._phased_dyn_gen = [object for x in range(self.num_tslots)]
-        self._prop = [object for x in range(self.num_tslots)]
-        if self.prop_computer.grad_exact and self.cache_prop_grad:
-            self._prop_grad = np.empty([self.num_tslots, self.num_ctrls],
-                                       dtype=object)
-        # Time evolution operator (forward propagation)
-        self._fwd_evo = [object for x in range(self.num_tslots+1)]
-        self._fwd_evo[0] = self._initial
-        if self.fid_computer.uses_onwd_evo:
-            # Time evolution operator (onward propagation)
-            self._onwd_evo = [object for x in range(self.num_tslots)]
-        if self.fid_computer.uses_onto_evo:
-            # Onward propagation overlap with inverse target
-            self._onto_evo = [object for x in range(self.num_tslots+1)]
-            self._onto_evo[self.num_tslots] = self._get_onto_evo_target()
-
-        if isinstance(self.prop_computer, propcomp.PropCompDiag):
-            self._create_decomp_lists()
-
-        if (
-            self.log_level <= logging.DEBUG
-            and isinstance(self, DynamicsUnitary)
-        ):
-            self.unitarity_check_level = 1
-
-        if self.dump_to_file:
-            if self.dump is None:
-                self.dumping = 'SUMMARY'
-            self.dump.write_to_file = True
-            self.dump.create_dump_dir()
-            logger.info("Dynamics dump will be written to:\n{}".format(
-                            self.dump.dump_dir))
-
-        self._evo_initialized = True
-
-    @property
-    def dyn_gen_phase(self):
-        """
-        Some op that is applied to the dyn_gen before expontiating to
-        get the propagator.
-        See `phase_application` for how this is applied
-        """
-        # Note that if this returns None then _apply_phase will never be
-        # called
-        return self._dyn_gen_phase
-
-    @dyn_gen_phase.setter
-    def dyn_gen_phase(self, value):
-        self._dyn_gen_phase = value
-
-    @property
-    def phase_application(self):
-        """
-        phase_application : scalar(string), default='preop'
-        Determines how the phase is applied to the dynamics generators
-
-        - 'preop'  : P = expm(phase*dyn_gen)
-        - 'postop' : P = expm(dyn_gen*phase)
-        - 'custom' : Customised phase application
-
-        The 'custom' option assumes that the _apply_phase method has been
-        set to a custom function.
-        """
-        return self._phase_application
-
-    @phase_application.setter
-    def phase_application(self, value):
-        self._set_phase_application(value)
-
-    def _set_phase_application(self, value):
-        self._config_phase_application(value)
-        self._phase_application = value
-
-    def _config_phase_application(self, ph_app=None):
-        """
-        Set the appropriate function for the phase application
-        """
-        err_msg = ("Invalid value '{}' for phase application. Must be either "
-                   "'preop', 'postop' or 'custom'".format(ph_app))
-
-        if ph_app is None:
-            ph_app = self._phase_application
-
-        try:
-            ph_app = ph_app.lower()
-        except AttributeError:
-            raise ValueError(err_msg)
-
-        if ph_app == 'preop':
-            self._apply_phase = self._apply_phase_preop
-        elif ph_app == 'postop':
-            self._apply_phase = self._apply_phase_postop
-        elif ph_app == 'custom':
-            # Do nothing, assume _apply_phase set elsewhere
-            pass
-        else:
-            raise ValueError(err_msg)
-
-    def _init_phase(self):
-        if self.dyn_gen_phase is not None:
-            self._config_phase_application()
-        else:
-            self.cache_phased_dyn_gen = False
-
-    def _apply_phase(self, dg):
-        """
-        This default method does nothing.
-        It will be set to another method automatically if `phase_application`
-        is 'preop' or 'postop'. It should be overridden repointed if
-        `phase_application` is 'custom'
-        It will never be called if `dyn_gen_phase` is None
-        """
-        return dg
-
-    def _apply_phase_preop(self, dg):
-        """
-        Apply phasing operator to dynamics generator.
-        This called during the propagator calculation.
-        In this case it will be applied as phase*dg
-        """
-        if hasattr(self.dyn_gen_phase, 'dot'):
-            phased_dg = self._dyn_gen_phase.dot(dg)
-        else:
-            phased_dg = self._dyn_gen_phase*dg
-        return phased_dg
-
-    def _apply_phase_postop(self, dg):
-        """
-        Apply phasing operator to dynamics generator.
-        This called during the propagator calculation.
-        In this case it will be applied as dg*phase
-        """
-        if hasattr(self.dyn_gen_phase, 'dot'):
-            phased_dg = dg.dot(self._dyn_gen_phase)
-        else:
-            phased_dg = dg*self._dyn_gen_phase
-        return phased_dg
-
-    def _create_decomp_lists(self):
-        """
-        Create lists that will hold the eigen decomposition
-        used in calculating propagators and gradients
-        Note: used with PropCompDiag propagator calcs
-        """
-        n_ts = self.num_tslots
-        self._decomp_curr = [False for x in range(n_ts)]
-        self._prop_eigen = [object for x in range(n_ts)]
-        self._dyn_gen_eigenvectors = [object for x in range(n_ts)]
-        if self.cache_dyn_gen_eigenvectors_adj:
-            self._dyn_gen_eigenvectors_adj = [object for x in range(n_ts)]
-        self._dyn_gen_factormatrix = [object for x in range(n_ts)]
-
-    def initialize_controls(self, amps, init_tslots=True):
-        """
-        Set the initial control amplitudes and time slices
-        Note this must be called after the configuration is complete
-        before any dynamics can be calculated
-        """
-        if not isinstance(self.prop_computer, propcomp.PropagatorComputer):
-            raise errors.UsageError(
-                "No prop_computer (propagator computer) "
-                "set. A default should be assigned by the Dynamics subclass")
-
-        if not isinstance(self.tslot_computer, tslotcomp.TimeslotComputer):
-            raise errors.UsageError(
-                "No tslot_computer (Timeslot computer)"
-                " set. A default should be assigned by the Dynamics class")
-
-        if not isinstance(self.fid_computer, fidcomp.FidelityComputer):
-            raise errors.UsageError(
-                "No fid_computer (Fidelity computer)"
-                " set. A default should be assigned by the Dynamics subclass")
-
-        self.ctrl_amps = None
-        if not self._timeslots_initialized:
-            init_tslots = True
-        if init_tslots:
-            self.init_timeslots()
-        self._init_evo()
-        self.tslot_computer.init_comp()
-        self.fid_computer.init_comp()
-        self._ctrls_initialized = True
-        self.update_ctrl_amps(amps)
-
-    def check_ctrls_initialized(self):
-        if not self._ctrls_initialized:
-            raise errors.UsageError(
-                "Controls not initialised. "
-                "Ensure Dynamics.initialize_controls has been "
-                "executed with the initial control amplitudes.")
-
-    def get_amp_times(self):
-        return self.time[:self.num_tslots]
-
-    def save_amps(self, file_name=None, times=None, amps=None, verbose=False):
-        """
-        Save a file with the current control amplitudes in each timeslot
-        The first column in the file will be the start time of the slot
-
-        Parameters
-        ----------
-        file_name : string
-            Name of the file
-            If None given the def_amps_fname attribuite will be used
-
-        times : List type (or string)
-            List / array of the start times for each slot
-            If None given this will be retrieved through get_amp_times()
-            If 'exclude' then times will not be saved in the file, just
-            the amplitudes
-
-        amps : Array[num_tslots, num_ctrls]
-            Amplitudes to be saved
-            If None given the ctrl_amps attribute will be used
-
-        verbose : Boolean
-            If True then an info message will be logged
-        """
-        self.check_ctrls_initialized()
-
-        inctimes = True
-        if file_name is None:
-            file_name = self.def_amps_fname
-        if amps is None:
-            amps = self.ctrl_amps
-        if times is None:
-            times = self.get_amp_times()
-        else:
-            if isinstance(times, str):
-                if times.lower() == 'exclude':
-                    inctimes = False
-                else:
-                    logger.warn("Unknown option for times '{}' "
-                                "when saving amplitudes".format(times))
-                    times = self.get_amp_times()
-
-        try:
-            if inctimes:
-                shp = amps.shape
-                data = np.empty([shp[0], shp[1] + 1], dtype=float)
-                data[:, 0] = times
-                data[:, 1:] = amps
-            else:
-                data = amps
-
-            np.savetxt(file_name, data, delimiter='\t', fmt='%14.6g')
-
-            if verbose:
-                logger.info("Amplitudes saved to file: " + file_name)
-        except Exception as e:
-            logger.error("Failed to save amplitudes due to underling "
-                         "error: {}".format(e))
-
-    def update_ctrl_amps(self, new_amps):
-        """
-        Determine if any amplitudes have changed. If so, then mark the
-        timeslots as needing recalculation
-        The actual work is completed by the compare_amps method of the
-        timeslot computer
-        """
-
-        if self.log_level <= logging.DEBUG_INTENSE:
-            logger.log(logging.DEBUG_INTENSE,
-                       "Updating amplitudes...\n"
-                       "Current control amplitudes:\n"
-                       + str(self.ctrl_amps)
-                       + "\n(potenially) new amplitudes:\n"
-                       + str(new_amps))
-
-        self.tslot_computer.compare_amps(new_amps)
-
-    def flag_system_changed(self):
-        """
-        Flag evolution, fidelity and gradients as needing recalculation
-        """
-        self.evo_current = False
-        self.fid_computer.flag_system_changed()
-
-    def get_drift_dim(self):
-        """
-        Returns the size of the matrix that defines the drift dynamics
-        that is assuming the drift is NxN, then this returns N
-        """
-        if self.dyn_shape is None:
-            self.refresh_drift_attribs()
-        return self.dyn_shape[0]
-
-    def refresh_drift_attribs(self):
-        """Reset the dyn_shape, dyn_dims and time_depend_drift attribs"""
-
-        if isinstance(self.drift_dyn_gen, (list, tuple)):
-            d0 = self.drift_dyn_gen[0]
-            self.time_depend_drift = True
-        else:
-            d0 = self.drift_dyn_gen
-            self.time_depend_drift = False
-
-        if not isinstance(d0, Qobj):
-            raise TypeError(
-                "Unable to determine drift attributes, "
-                "because drift_dyn_gen is not Qobj (nor list of)"
-            )
-
-        self.dyn_shape = d0.shape
-        self.dyn_dims = d0.dims
-
-    def get_num_ctrls(self):
-        """
-        calculate the of controls from the length of the control list
-        sets the num_ctrls property, which can be used alternatively
-        subsequently
-        """
-        _func_deprecation("'get_num_ctrls' has been replaced by "
-                          "'num_ctrls' property")
-        return self.num_ctrls
-
-    def _get_num_ctrls(self):
-        if not self._ctrl_dyn_gen_checked:
-            self.ctrl_dyn_gen = _check_ctrls_container(self.ctrl_dyn_gen)
-            self._ctrl_dyn_gen_checked = True
-        if isinstance(self.ctrl_dyn_gen, np.ndarray):
-            self._num_ctrls = self.ctrl_dyn_gen.shape[1]
-            self.time_depend_ctrl_dyn_gen = True
-        else:
-            self._num_ctrls = len(self.ctrl_dyn_gen)
-
-        return self._num_ctrls
-
-    @property
-    def num_ctrls(self):
-        """
-        calculate the of controls from the length of the control list
-        sets the num_ctrls property, which can be used alternatively
-        subsequently
-        """
-        if self._num_ctrls is None:
-            self._num_ctrls = self._get_num_ctrls()
-        return self._num_ctrls
-
-    @property
-    def onto_evo_target(self):
-        if self._onto_evo_target is None:
-            self._get_onto_evo_target()
-
-        if self._onto_evo_target_qobj is None:
-            if isinstance(self._onto_evo_target, Qobj):
-                self._onto_evo_target_qobj = self._onto_evo_target
-            else:
-                rev_dims = [self.sys_dims[1], self.sys_dims[0]]
-                self._onto_evo_target_qobj = Qobj(self._onto_evo_target,
-                                                  dims=rev_dims)
-
-        return self._onto_evo_target_qobj
-
-    def get_owd_evo_target(self):
-        _func_deprecation("'get_owd_evo_target' has been replaced by "
-                          "'onto_evo_target' property")
-        return self.onto_evo_target
-
-    def _get_onto_evo_target(self):
-        """
-        Get the inverse of the target.
-        Used for calculating the 'onto target' evolution
-        This is actually only relevant for unitary dynamics where
-        the target.dag() is what is required
-        However, for completeness, in general the inverse of the target
-        operator is is required
-        For state-to-state, the bra corresponding to the is required ket
-        """
-        if self.target.shape[0] == self.target.shape[1]:
-            # Target is operator
-            targ = la.inv(self.target.full())
-            if self.oper_dtype == Qobj:
-                rev_dims = [self.target.dims[1], self.target.dims[0]]
-                self._onto_evo_target = Qobj(targ, dims=rev_dims)
-            elif self.oper_dtype == np.ndarray:
-                self._onto_evo_target = targ
-            else:
-                assert False, f"Unknown oper_dtype {self.oper_dtype!r}"
-        else:
-            if self.oper_dtype == Qobj:
-                self._onto_evo_target = self.target.dag()
-            elif self.oper_dtype == np.ndarray:
-                self._onto_evo_target = self.target.dag().full()
-            else:
-                assert False, f"Unknown oper_dtype {self.oper_dtype!r}"
-
-        return self._onto_evo_target
-
-    def combine_dyn_gen(self, k):
-        """
-        Computes the dynamics generator for a given timeslot
-        The is the combined Hamiltion for unitary systems
-        """
-        _func_deprecation("'combine_dyn_gen' has been replaced by "
-                          "'_combine_dyn_gen'")
-        self._combine_dyn_gen(k)
-        return self._dyn_gen(k)
-
-    def _combine_dyn_gen(self, k):
-        """
-        Computes the dynamics generator for a given timeslot
-        The is the combined Hamiltion for unitary systems
-        Also applies the phase (if any required by the propagation)
-        """
-        if self.time_depend_drift:
-            dg = self._drift_dyn_gen[k]
-        else:
-            dg = self._drift_dyn_gen
-        for j in range(self._num_ctrls):
-            if self.time_depend_ctrl_dyn_gen:
-                dg = dg + self.ctrl_amps[k, j]*self._ctrl_dyn_gen[k, j]
-            else:
-                dg = dg + self.ctrl_amps[k, j]*self._ctrl_dyn_gen[j]
-
-        self._dyn_gen[k] = dg
-        if self.cache_phased_dyn_gen:
-            self._phased_dyn_gen[k] = self._apply_phase(dg)
-
-    def get_dyn_gen(self, k):
-        """
-        Get the combined dynamics generator for the timeslot
-        Not implemented in the base class. Choose a subclass
-        """
-        _func_deprecation("'get_dyn_gen' has been replaced by "
-                          "'_get_phased_dyn_gen'")
-        return self._get_phased_dyn_gen(k)
-
-    def _get_phased_dyn_gen(self, k):
-        if self.dyn_gen_phase is None:
-            return self._dyn_gen[k]
-        else:
-            if self._phased_dyn_gen is None:
-                return self._apply_phase(self._dyn_gen[k])
-            else:
-                return self._phased_dyn_gen[k]
-
-    def get_ctrl_dyn_gen(self, j):
-        """
-        Get the dynamics generator for the control
-        Not implemented in the base class. Choose a subclass
-        """
-        _func_deprecation("'get_ctrl_dyn_gen' has been replaced by "
-                          "'_get_phased_ctrl_dyn_gen'")
-        return self._get_phased_ctrl_dyn_gen(0, j)
-
-    def _get_phased_ctrl_dyn_gen(self, k, j):
-        if self._phased_ctrl_dyn_gen is not None:
-            if self.time_depend_ctrl_dyn_gen:
-                return self._phased_ctrl_dyn_gen[k, j]
-            else:
-                return self._phased_ctrl_dyn_gen[j]
-        else:
-            if self.time_depend_ctrl_dyn_gen:
-                if self.dyn_gen_phase is None:
-                    return self._ctrl_dyn_gen[k, j]
-                else:
-                    return self._apply_phase(self._ctrl_dyn_gen[k, j])
-            else:
-                if self.dyn_gen_phase is None:
-                    return self._ctrl_dyn_gen[j]
-                else:
-                    return self._apply_phase(self._ctrl_dyn_gen[j])
-
-    @property
-    def dyn_gen(self):
-        """
-        List of combined dynamics generators (Qobj) for each timeslot
-        """
-        if self._dyn_gen is not None:
-            if self._dyn_gen_qobj is None:
-                if self.oper_dtype == Qobj:
-                    self._dyn_gen_qobj = self._dyn_gen
-                else:
-                    self._dyn_gen_qobj = [Qobj(dg, dims=self.dyn_dims)
-                                          for dg in self._dyn_gen]
-        return self._dyn_gen_qobj
-
-    @property
-    def prop(self):
-        """
-        List of propagators (Qobj) for each timeslot
-        """
-        if self._prop is not None:
-            if self._prop_qobj is None:
-                if self.oper_dtype == Qobj:
-                    self._prop_qobj = self._prop
-                else:
-                    self._prop_qobj = [Qobj(dg, dims=self.dyn_dims)
-                                       for dg in self._prop]
-        return self._prop_qobj
-
-    @property
-    def prop_grad(self):
-        """
-        Array of propagator gradients (Qobj) for each timeslot, control
-        """
-        if self._prop_grad is not None:
-            if self._prop_grad_qobj is None:
-                if self.oper_dtype == Qobj:
-                    self._prop_grad_qobj = self._prop_grad
-                else:
-                    self._prop_grad_qobj = np.empty(
-                                    [self.num_tslots, self.num_ctrls],
-                                    dtype=object)
-                    for k in range(self.num_tslots):
-                        for j in range(self.num_ctrls):
-                            self._prop_grad_qobj[k, j] = Qobj(
-                                                    self._prop_grad[k, j],
-                                                    dims=self.dyn_dims)
-        return self._prop_grad_qobj
-
-    def _get_prop_grad(self, k, j):
-        if self.cache_prop_grad:
-            prop_grad = self._prop_grad[k, j]
-        else:
-            prop_grad =\
-                self.prop_computer._compute_prop_grad(k, j, compute_prop=False)
-        return prop_grad
-
-    @property
-    def evo_init2t(self):
-        _attrib_deprecation(
-            "'evo_init2t' has been replaced by '_fwd_evo'")
-        return self._fwd_evo
-
-    @property
-    def fwd_evo(self):
-        """
-        List of evolution operators (Qobj) from the initial to the given
-        timeslot
-        """
-        if self._fwd_evo is not None:
-            if self._fwd_evo_qobj is None:
-                if self.oper_dtype == Qobj:
-                    self._fwd_evo_qobj = self._fwd_evo
-                else:
-                    self._fwd_evo_qobj = [self.initial]
-                    for k in range(1, self.num_tslots+1):
-                        self._fwd_evo_qobj.append(Qobj(self._fwd_evo[k],
-                                                       dims=self.sys_dims))
-        return self._fwd_evo_qobj
-
-    def _get_full_evo(self):
-        return self._fwd_evo[self._num_tslots]
-
-    @property
-    def full_evo(self):
-        """Full evolution - time evolution at final time slot"""
-        return self.fwd_evo[self.num_tslots]
-
-    @property
-    def evo_t2end(self):
-        _attrib_deprecation(
-            "'evo_t2end' has been replaced by '_onwd_evo'")
-        return self._onwd_evo
-
-    @property
-    def onwd_evo(self):
-        """
-        List of evolution operators (Qobj) from the initial to the given
-        timeslot
-        """
-        if self._onwd_evo is not None:
-            if self._onwd_evo_qobj is None:
-                if self.oper_dtype == Qobj:
-                    self._onwd_evo_qobj = self._fwd_evo
-                else:
-                    self._onwd_evo_qobj = [Qobj(dg, dims=self.sys_dims)
-                                           for dg in self._onwd_evo]
-        return self._onwd_evo_qobj
-
-    @property
-    def evo_t2targ(self):
-        _attrib_deprecation(
-            "'evo_t2targ' has been replaced by '_onto_evo'")
-        return self._onto_evo
-
-    @property
-    def onto_evo(self):
-        """
-        List of evolution operators (Qobj) from the initial to the given
-        timeslot
-        """
-        if self._onto_evo is not None:
-            if self._onto_evo_qobj is None:
-                if self.oper_dtype == Qobj:
-                    self._onto_evo_qobj = self._onto_evo
-                else:
-                    self._onto_evo_qobj = []
-                    for k in range(0, self.num_tslots):
-                        self._onto_evo_qobj.append(Qobj(self._onto_evo[k],
-                                                        dims=self.sys_dims))
-                    self._onto_evo_qobj.append(self.onto_evo_target)
-
-        return self._onto_evo_qobj
-
-    def compute_evolution(self):
-        """
-        Recalculate the time evolution operators
-        Dynamics generators (e.g. Hamiltonian) and
-        prop (propagators) are calculated as necessary
-        Actual work is completed by the recompute_evolution method
-        of the timeslot computer
-        """
-
-        # Check if values are already current, otherwise calculate all values
-        if not self.evo_current:
-            if self.log_level <= logging.DEBUG_VERBOSE:
-                logger.log(logging.DEBUG_VERBOSE, "Computing evolution")
-            self.tslot_computer.recompute_evolution()
-            self.evo_current = True
-            return True
-        return False
-
-    def _ensure_decomp_curr(self, k):
-        """
-        Checks to see if the diagonalisation has been completed since
-        the last update of the dynamics generators
-        (after the amplitude update)
-        If not then the diagonlisation is completed
-        """
-        if self._decomp_curr is None:
-            raise errors.UsageError("Decomp lists have not been created")
-        if not self._decomp_curr[k]:
-            self._spectral_decomp(k)
-
-    def _spectral_decomp(self, k):
-        """
-        Calculate the diagonalization of the dynamics generator
-        generating lists of eigenvectors, propagators in the diagonalised
-        basis, and the 'factormatrix' used in calculating the propagator
-        gradient
-        Not implemented in this base class, because the method is specific
-        to the matrix type
-        """
-        raise errors.UsageError("Decomposition cannot be completed by "
-                                "this class. Try a(nother) subclass")
-
-    def _is_unitary(self, A):
-        """
-        Checks whether operator A is unitary
-        A can be either Qobj or ndarray
-        """
-        if isinstance(A, Qobj):
-            unitary = np.allclose(np.eye(A.shape[0]), (A*A.dag()).full(),
-                                  atol=self.unitarity_tol)
-        else:
-            unitary = np.allclose(np.eye(len(A)), A.dot(A.T.conj()),
-                                  atol=self.unitarity_tol)
-
-        return unitary
-
-    def _calc_unitary_err(self, A):
-        if isinstance(A, Qobj):
-            err = np.sum(abs(np.eye(A.shape[0]) - (A*A.dag()).full()))
-        else:
-            err = np.sum(abs(np.eye(len(A)) - A.dot(A.T.conj())))
-
-        return err
-
-    def unitarity_check(self):
-        """
-        Checks whether all propagators are unitary
-        """
-        for k in range(self.num_tslots):
-            if not self._is_unitary(self._prop[k]):
-                logger.warning(
-                    "Progator of timeslot {} is not unitary".format(k))
-
-
-class DynamicsGenMat(Dynamics):
-    """
-    This sub class can be used for any system where no additional
-    operator is applied to the dynamics generator before calculating
-    the propagator, e.g. classical dynamics, Lindbladian
-    """
-    def reset(self):
-        Dynamics.reset(self)
-        self.id_text = 'GEN_MAT'
-        self.apply_params()
-
-
-class DynamicsUnitary(Dynamics):
-    """
-    This is the subclass to use for systems with dynamics described by
-    unitary matrices. E.g. closed systems with Hermitian Hamiltonians
-    Note a matrix diagonalisation is used to compute the exponent
-    The eigen decomposition is also used to calculate the propagator gradient.
-    The method is taken from DYNAMO (see file header)
-
-    Attributes
-    ----------
-    drift_ham : Qobj
-        This is the drift Hamiltonian for unitary dynamics
-        It is mapped to drift_dyn_gen during initialize_controls
-
-    ctrl_ham : List of Qobj
-        These are the control Hamiltonians for unitary dynamics
-        It is mapped to ctrl_dyn_gen during initialize_controls
-
-    H : List of Qobj
-        The combined drift and control Hamiltonians for each timeslot
-        These are the dynamics generators for unitary dynamics.
-        It is mapped to dyn_gen during initialize_controls
-    """
-
-    def reset(self):
-        Dynamics.reset(self)
-        self.id_text = 'UNIT'
-        self.drift_ham = None
-        self.ctrl_ham = None
-        self.H = None
-        self._dyn_gen_phase = -1j
-        self._phase_application = 'preop'
-        self.apply_params()
-
-    def _create_computers(self):
-        """
-        Create the default timeslot, fidelity and propagator computers
-        """
-        # The time slot computer. By default it is set to _UpdateAll
-        # can be set to _DynUpdate in the configuration
-        # (see class file for details)
-        if self.config.tslot_type == 'DYNAMIC':
-            self.tslot_computer = tslotcomp.TSlotCompDynUpdate(self)
-        else:
-            self.tslot_computer = tslotcomp.TSlotCompUpdateAll(self)
-        # set the default fidelity computer
-        self.fid_computer = fidcomp.FidCompUnitary(self)
-        # set the default propagator computer
-        self.prop_computer = propcomp.PropCompDiag(self)
-
-    def initialize_controls(self, amplitudes, init_tslots=True):
-        # Either the _dyn_gen or _ham names can be used
-        # This assumes that one or other has been set in the configuration
-        self._map_dyn_gen_to_ham()
-        Dynamics.initialize_controls(self, amplitudes, init_tslots=init_tslots)
-
-    def _map_dyn_gen_to_ham(self):
-        if self.drift_dyn_gen is None:
-            self.drift_dyn_gen = self.drift_ham
-        else:
-            self.drift_ham = self.drift_dyn_gen
-        if self.ctrl_dyn_gen is None:
-            self.ctrl_dyn_gen = self.ctrl_ham
-        else:
-            self.ctrl_ham = self.ctrl_dyn_gen
-        self._dyn_gen_mapped = True
-
-    @property
-    def num_ctrls(self):
-        if not self._dyn_gen_mapped:
-            self._map_dyn_gen_to_ham()
-        if self._num_ctrls is None:
-            self._num_ctrls = self._get_num_ctrls()
-        return self._num_ctrls
-
-    def _get_onto_evo_target(self):
-        """
-        Get the adjoint of the target.
-        Used for calculating the 'backward' evolution
-        """
-        if self.oper_dtype == Qobj:
-            self._onto_evo_target = self.target.dag()
-        else:
-            self._onto_evo_target = self._target.T.conj()
-        return self._onto_evo_target
-
-    def _spectral_decomp(self, k):
-        """
-        Calculates the diagonalization of the dynamics generator
-        generating lists of eigenvectors, propagators in the diagonalised
-        basis, and the 'factormatrix' used in calculating the propagator
-        gradient
-        """
-
-        if self.oper_dtype == Qobj:
-            H = self._dyn_gen[k]
-            # Returns eigenvalues as array (row)
-            # and eigenvectors as rows of an array
-            _type = _data.CSR if self.sparse_eigen_decomp else _data.Dense
-            eig_val, eig_vec = _data.eigs(_data.to(_type, H.data))
-            eig_vec = eig_vec.to_array()
-
-        elif self.oper_dtype == np.ndarray:
-            H = self._dyn_gen[k]
-            # returns row vector of eigenvals, columns with the eigenvecs
-            eig_val, eig_vec = eigh(H)
-
-        else:
-            assert False, f"Unknown oper_dtype {self.oper_dtype!r}"
-
-        # assuming H is an nxn matrix, find n
-        n = self.get_drift_dim()
-
-        # Calculate the propagator in the diagonalised basis
-        eig_val_tau = -1j*eig_val*self.tau[k]
-        prop_eig = np.exp(eig_val_tau)
-
-        # Generate the factor matrix through the differences
-        # between each of the eigenvectors and the exponentiations
-        # create nxn matrix where each eigen val is repeated n times
-        # down the columns
-        o = np.ones([n, n])
-        eig_val_cols = eig_val_tau*o
-        # calculate all the differences by subtracting it from its transpose
-        eig_val_diffs = eig_val_cols - eig_val_cols.T
-        # repeat for the propagator
-        prop_eig_cols = prop_eig*o
-        prop_eig_diffs = prop_eig_cols - prop_eig_cols.T
-        # the factor matrix is the elementwise quotient of the
-        # differeneces between the exponentiated eigen vals and the
-        # differences between the eigen vals
-        # need to avoid division by zero that would arise due to denegerate
-        # eigenvalues and the diagonals
-        degen_mask = np.abs(eig_val_diffs) < self.fact_mat_round_prec
-        eig_val_diffs[degen_mask] = 1
-        factors = prop_eig_diffs / eig_val_diffs
-        # for degenerate eigenvalues the factor is just the exponent
-        factors[degen_mask] = prop_eig_cols[degen_mask]
-
-        # Store eigenvectors, propagator and factor matric
-        # for use in propagator computations
-        self._decomp_curr[k] = True
-        if isinstance(factors, np.ndarray):
-            self._dyn_gen_factormatrix[k] = factors
-        else:
-            self._dyn_gen_factormatrix[k] = np.array(factors)
-
-        if self.oper_dtype == Qobj:
-            self._prop_eigen[k] = Qobj(np.diagflat(prop_eig),
-                                       dims=self.dyn_dims)
-            self._dyn_gen_eigenvectors[k] = Qobj(eig_vec,
-                                                 dims=self.dyn_dims)
-            # The _dyn_gen_eigenvectors_adj list is not used in
-            # memory optimised modes
-            if self._dyn_gen_eigenvectors_adj is not None:
-                self._dyn_gen_eigenvectors_adj[k] = \
-                            self._dyn_gen_eigenvectors[k].dag()
-        elif self.oper_dtype == np.ndarray:
-            self._prop_eigen[k] = np.diagflat(prop_eig)
-            self._dyn_gen_eigenvectors[k] = eig_vec
-            # The _dyn_gen_eigenvectors_adj list is not used in
-            # memory optimised modes
-            if self._dyn_gen_eigenvectors_adj is not None:
-                self._dyn_gen_eigenvectors_adj[k] = \
-                            self._dyn_gen_eigenvectors[k].conj().T
-        else:
-            assert False, f"Unknown oper_dtype {self.oper_dtype!r}"
-
-    def _get_dyn_gen_eigenvectors_adj(self, k):
-        # The _dyn_gen_eigenvectors_adj list is not used in
-        # memory optimised modes
-        if self._dyn_gen_eigenvectors_adj is not None:
-            return self._dyn_gen_eigenvectors_adj[k]
-        if self.oper_dtype == Qobj:
-            return self._dyn_gen_eigenvectors[k].dag()
-        return self._dyn_gen_eigenvectors[k].conj().T
-
-    def check_unitarity(self):
-        """
-        Checks whether all propagators are unitary
-        For propagators found not to be unitary, the potential underlying
-        causes are investigated.
-        """
-        for k in range(self.num_tslots):
-            prop_unit = self._is_unitary(self._prop[k])
-            if not prop_unit:
-                logger.warning(
-                    "Progator of timeslot {} is not unitary".format(k))
-            if not prop_unit or self.unitarity_check_level > 1:
-                # Check Hamiltonian
-                H = self._dyn_gen[k]
-                if isinstance(H, Qobj):
-                    herm = H.isherm
-                else:
-                    diff = np.abs(H.T.conj() - H)
-                    herm = np.all(diff < settings.core['atol'])
-                eigval_unit = self._is_unitary(self._prop_eigen[k])
-                eigvec_unit = self._is_unitary(self._dyn_gen_eigenvectors[k])
-                if self._dyn_gen_eigenvectors_adj is not None:
-                    eigvecadj_unit = self._is_unitary(
-                                    self._dyn_gen_eigenvectors_adj[k])
-                else:
-                    eigvecadj_unit = None
-                msg = ("prop unit: {}; H herm: {}; "
-                       "eigval unit: {}; eigvec unit: {}; "
-                       "eigvecadj_unit: {}".format(
-                           prop_unit, herm, eigval_unit, eigvec_unit,
-                           eigvecadj_unit))
-                logger.info(msg)
-
-
-class DynamicsSymplectic(Dynamics):
-    """
-    Symplectic systems
-    This is the subclass to use for systems where the dynamics is described
-    by symplectic matrices, e.g. coupled oscillators, quantum optics
-
-    Attributes
-    ----------
-    omega : array[drift_dyn_gen.shape]
-        matrix used in the calculation of propagators (time evolution)
-        with symplectic systems.
-
-    """
-
-    def reset(self):
-        Dynamics.reset(self)
-        self.id_text = 'SYMPL'
-        self._omega = None
-        self._omega_qobj = None
-        self._phase_application = 'postop'
-        self.grad_exact = True
-        self.apply_params()
-
-    def _create_computers(self):
-        """
-        Create the default timeslot, fidelity and propagator computers
-        """
-        # The time slot computer. By default it is set to _UpdateAll
-        # can be set to _DynUpdate in the configuration
-        # (see class file for details)
-        if self.config.tslot_type == 'DYNAMIC':
-            self.tslot_computer = tslotcomp.TSlotCompDynUpdate(self)
-        else:
-            self.tslot_computer = tslotcomp.TSlotCompUpdateAll(self)
-
-        self.prop_computer = propcomp.PropCompFrechet(self)
-        self.fid_computer = fidcomp.FidCompTraceDiff(self)
-
-    @property
-    def omega(self):
-        if self._omega is None:
-            self._get_omega()
-        if self._omega_qobj is None:
-            self._omega_qobj = Qobj(self._omega, dims=self.dyn_dims)
-        return self._omega_qobj
-
-    def _get_omega(self):
-        if self._omega is None:
-            n = self.get_drift_dim() // 2
-            omg = sympl.calc_omega(n)
-            if self.oper_dtype == Qobj:
-                self._omega = Qobj(omg, dims=self.dyn_dims)
-                self._omega_qobj = self._omega
-            else:
-                self._omega = omg
-        return self._omega
-
-    def _set_phase_application(self, value):
-        Dynamics._set_phase_application(self, value)
-        if self._evo_initialized:
-            phase = self._get_dyn_gen_phase()
-            if phase is not None:
-                self._dyn_gen_phase = phase
-
-    def _get_dyn_gen_phase(self):
-        if self._phase_application == 'postop':
-            phase = -self._get_omega()
-        elif self._phase_application == 'preop':
-            phase = self._get_omega()
-        elif self._phase_application == 'custom':
-            phase = None
-            # Assume phase set by user
-        else:
-            raise ValueError("No option for phase_application "
-                             "'{}'".format(self._phase_application))
-        return phase
-
-    @property
-    def dyn_gen_phase(self):
-        r"""
-        The phasing operator for the symplectic group generators
-        usually refered to as \Omega
-        By default this is applied as 'postop' dyn_gen*-\Omega
-        If phase_application is 'preop' it is applied as \Omega*dyn_gen
-        """
-        # Cannot be calculated until the dyn_shape is set
-        # that is after the drift dyn gen has been set.
-        if self._dyn_gen_phase is None:
-            self._dyn_gen_phase = self._get_dyn_gen_phase()
-        return self._dyn_gen_phase
diff --git a/qutip/control/errors.py b/qutip/control/errors.py
deleted file mode 100644
index 0997502a65..0000000000
--- a/qutip/control/errors.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Exception classes for the Quantum Control library
-"""
-
-
-class Error(Exception):
-    """Base class for all qutip control exceptions"""
-    def __str__(self):
-        return repr(self.message)
-
-
-class UsageError(Error):
-    """
-    A function has been used incorrectly. Most likely when a base class
-    was used when a sub class should have been.
-        funcname: function name where error occurred
-        msg: Explanation
-    """
-    def __init__(self, msg):
-        self.message = msg
-
-
-class FunctionalError(Error):
-    """
-    A function behaved in an unexpected way
-    Attributes:
-        funcname: function name where error occurred
-        msg: Explanation
-    """
-    def __init__(self, msg):
-        self.message = msg
-
-
-class OptimizationTerminate(Error):
-    """
-    Superclass for all early terminations from the optimisation algorithm
-    """
-    pass
-
-
-class GoalAchievedTerminate(OptimizationTerminate):
-    """
-    Exception raised to terminate execution when the goal has been reached
-    during the optimisation algorithm
-    """
-    def __init__(self, fid_err):
-        self.reason = "Goal achieved"
-        self.fid_err = fid_err
-
-
-class MaxWallTimeTerminate(OptimizationTerminate):
-    """
-    Exception raised to terminate execution when the optimisation time has
-    exceeded the maximum set in the config
-    """
-    def __init__(self):
-        self.reason = "Max wall time exceeded"
-
-
-class MaxFidFuncCallTerminate(OptimizationTerminate):
-    """
-    Exception raised to terminate execution when the number of calls to the
-    fidelity error function has exceeded the maximum
-    """
-    def __init__(self):
-        self.reason = "Number of fidelity error calls has exceeded the maximum"
-
-
-class GradMinReachedTerminate(OptimizationTerminate):
-    """
-    Exception raised to terminate execution when the minimum gradient normal
-    has been reached during the optimisation algorithm
-    """
-    def __init__(self, gradient):
-        self.reason = "Gradient normal minimum reached"
-        self.gradient = gradient
diff --git a/qutip/control/fidcomp.py b/qutip/control/fidcomp.py
deleted file mode 100644
index 3ba9e65357..0000000000
--- a/qutip/control/fidcomp.py
+++ /dev/null
@@ -1,746 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Fidelity Computer
-
-These classes calculate the fidelity error - function to be minimised
-and fidelity error gradient, which is used to direct the optimisation
-
-They may calculate the fidelity as an intermediary step, as in some case
-e.g. unitary dynamics, this is more efficient
-
-The idea is that different methods for computing the fidelity can be tried
-and compared using simple configuration switches.
-
-Note the methods in these classes were inspired by:
-DYNAMO - Dynamic Framework for Quantum Optimal Control
-See Machnes et.al., arXiv.1011.4874
-The unitary dynamics fidelity is taken directly frm DYNAMO
-The other fidelity measures are extensions, and the sources are given
-in the class descriptions.
-"""
-
-import timeit
-import warnings
-import numpy as np
-# QuTiP
-from qutip import Qobj
-# QuTiP control modules
-import qutip.control.errors as errors
-# QuTiP logging
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-
-def _attrib_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-def _func_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-def _trace(A):
-    """wrapper for calculating the trace"""
-    # input is an operator (Qobj, array, sparse etc), so
-    if isinstance(A, Qobj):
-        return A.tr()
-    else:
-        return np.trace(A)
-
-
-class FidelityComputer(object):
-    """
-    Base class for all Fidelity Computers.
-    This cannot be used directly. See subclass descriptions and choose
-    one appropriate for the application
-    Note: this must be instantiated with a Dynamics object, that is the
-    container for the data that the methods operate on
-
-    Attributes
-    ----------
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip.logging_utils,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-
-    dimensional_norm : float
-        Normalisation constant
-
-    fid_norm_func : function
-        Used to normalise the fidelity
-        See SU and PSU options for the unitary dynamics
-
-    grad_norm_func : function
-        Used to normalise the fidelity gradient
-        See SU and PSU options for the unitary dynamics
-
-    uses_onwd_evo : boolean
-        flag to specify whether the onwd_evo evolution operator
-        (see Dynamics) is used by the FidelityComputer
-
-    uses_onto_evo : boolean
-        flag to specify whether the onto_evo evolution operator
-         (see Dynamics) is used by the FidelityComputer
-
-    fid_err : float
-        Last computed value of the fidelity error
-
-    fidelity : float
-        Last computed value of the normalised fidelity
-
-    fidelity_current : boolean
-        flag to specify whether the fidelity / fid_err are based on the
-        current amplitude values. Set False when amplitudes change
-
-    fid_err_grad: array[num_tslot, num_ctrls] of float
-        Last computed values for the fidelity error gradients wrt the
-        control in the timeslot
-
-    grad_norm : float
-        Last computed value for the norm of the fidelity error gradients
-        (sqrt of the sum of the squares)
-
-    fid_err_grad_current : boolean
-        flag to specify whether the fidelity / fid_err are based on the
-        current amplitude values. Set False when amplitudes change
-    """
-    def __init__(self, dynamics, params=None):
-        self.parent = dynamics
-        self.params = params
-        self.reset()
-
-    def reset(self):
-        """
-        reset any configuration data and
-        clear any temporarily held status data
-        """
-        self.log_level = self.parent.log_level
-        self.id_text = 'FID_COMP_BASE'
-        self.dimensional_norm = 1.0
-        self.fid_norm_func = None
-        self.grad_norm_func = None
-        self.uses_onwd_evo = False
-        self.uses_onto_evo = False
-        self.apply_params()
-        self.clear()
-
-    def clear(self):
-        """
-        clear any temporarily held status data
-        """
-        self.fid_err = None
-        self.fidelity = None
-        self.fid_err_grad = None
-        self.grad_norm = np.inf
-        self.fidelity_current = False
-        self.fid_err_grad_current = False
-        self.grad_norm = 0.0
-
-    def apply_params(self, params=None):
-        """
-        Set object attributes based on the dictionary (if any) passed in the
-        instantiation, or passed as a parameter
-        This is called during the instantiation automatically.
-        The key value pairs are the attribute name and value
-        Note: attributes are created if they do not exist already,
-        and are overwritten if they do.
-        """
-        if not params:
-            params = self.params
-
-        if isinstance(params, dict):
-            self.params = params
-            for key in params:
-                setattr(self, key, params[key])
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    def init_comp(self):
-        """
-        initialises the computer based on the configuration of the Dynamics
-        """
-        # optionally implemented in subclass
-        pass
-
-    def get_fid_err(self):
-        """
-        returns the absolute distance from the maximum achievable fidelity
-        """
-        # must be implemented by subclass
-        raise errors.UsageError(
-            "No method defined for getting fidelity error."
-            " Suspect base class was used where sub class should have been")
-
-    def get_fid_err_gradient(self):
-        """
-        Returns the normalised gradient of the fidelity error
-        in a (nTimeslots x n_ctrls) array wrt the timeslot control amplitude
-        """
-        # must be implemented by subclass
-        raise errors.UsageError("No method defined for getting fidelity"
-                                " error gradient. Suspect base class was"
-                                " used where sub class should have been")
-
-    def flag_system_changed(self):
-        """
-        Flag fidelity and gradients as needing recalculation
-        """
-        self.fidelity_current = False
-        # Flag gradient as needing recalculating
-        self.fid_err_grad_current = False
-
-    @property
-    def uses_evo_t2end(self):
-        _attrib_deprecation(
-                "'uses_evo_t2end' has been replaced by 'uses_onwd_evo'")
-        return self.uses_onwd_evo
-
-    @uses_evo_t2end.setter
-    def uses_evo_t2end(self, value):
-        _attrib_deprecation(
-                "'uses_evo_t2end' has been replaced by 'uses_onwd_evo'")
-        self.uses_onwd_evo = value
-
-    @property
-    def uses_evo_t2targ(self):
-        _attrib_deprecation(
-                "'uses_evo_t2targ' has been replaced by 'uses_onto_evo'")
-        return self.uses_onto_evo
-
-    @uses_evo_t2targ.setter
-    def uses_evo_t2targ(self, value):
-        _attrib_deprecation(
-                "'uses_evo_t2targ' has been replaced by 'uses_onto_evo'")
-        self.uses_onto_evo = value
-
-
-class FidCompUnitary(FidelityComputer):
-    """
-    Computes fidelity error and gradient assuming unitary dynamics, e.g.
-    closed qubit systems
-    Note fidelity and gradient calculations were taken from DYNAMO
-    (see file header)
-
-    Attributes
-    ----------
-    phase_option : string
-        determines how global phase is treated in fidelity calculations:
-            PSU - global phase ignored
-            SU - global phase included
-
-    fidelity_prenorm : complex
-        Last computed value of the fidelity before it is normalised
-        It is stored to use in the gradient normalisation calculation
-
-    fidelity_prenorm_current : boolean
-        flag to specify whether fidelity_prenorm are based on the
-        current amplitude values. Set False when amplitudes change
-    """
-    def reset(self):
-        FidelityComputer.reset(self)
-        self.id_text = 'UNIT'
-        self.uses_onto_evo = True
-        self._init_phase_option('PSU')
-        self.apply_params()
-
-    def clear(self):
-        FidelityComputer.clear(self)
-        self.fidelity_prenorm = None
-        self.fidelity_prenorm_current = False
-
-    def set_phase_option(self, phase_option=None):
-        """
-        Deprecated - use phase_option
-        Phase options are
-        SU - global phase important
-        PSU - global phase is not important
-        """
-        _func_deprecation("'set_phase_option' is deprecated. "
-                          "Use phase_option property")
-        self._init_phase_option(phase_option)
-
-    @property
-    def phase_option(self):
-        return self._phase_option
-
-    @phase_option.setter
-    def phase_option(self, value):
-        """
-        Phase options are
-         SU - global phase important
-         PSU - global phase is not important
-        """
-        self._init_phase_option(value)
-
-    def _init_phase_option(self, value):
-        self._phase_option = value
-        if value == 'PSU':
-            self.fid_norm_func = self.normalize_PSU
-            self.grad_norm_func = self.normalize_gradient_PSU
-        elif value == 'SU':
-            self.fid_norm_func = self.normalize_SU
-            self.grad_norm_func = self.normalize_gradient_SU
-        elif value is None:
-            raise errors.UsageError("phase_option cannot be set to None"
-                                    " for this FidelityComputer.")
-        else:
-            raise errors.UsageError(
-                    "No option for phase_option '{}'".format(value))
-
-    def init_comp(self):
-        """
-        Check configuration and initialise the normalisation
-        """
-        if self.fid_norm_func is None or self.grad_norm_func is None:
-            raise errors.UsageError("The phase_option must be be set"
-                                    "for this fidelity computer")
-        self.init_normalization()
-
-    def flag_system_changed(self):
-        """
-        Flag fidelity and gradients as needing recalculation
-        """
-        FidelityComputer.flag_system_changed(self)
-        # Flag the fidelity (prenormalisation) value as needing calculation
-        self.fidelity_prenorm_current = False
-
-    def init_normalization(self):
-        """
-        Calc norm of <Ufinal | Ufinal> to scale subsequent norms
-        When considering unitary time evolution operators, this basically
-        results in calculating the trace of the identity matrix
-        and is hence equal to the size of the target matrix
-        There may be situations where this is not the case, and hence it
-        is not assumed to be so.
-        The normalisation function called should be set to either the
-        PSU - global phase ignored
-        SU  - global phase respected
-        """
-        dyn = self.parent
-        self.dimensional_norm = 1.0
-        self.dimensional_norm = \
-            self.fid_norm_func(dyn.target.dag()*dyn.target)
-
-    def normalize_SU(self, A):
-        try:
-            if A.shape[0] == A.shape[1]:
-                # input is an operator (Qobj, array), so
-                norm = _trace(A)
-            else:
-                raise TypeError("Cannot compute trace (not square)")
-        except AttributeError:
-            # assume input is already scalar and hence assumed
-            # to be the prenormalised scalar value, e.g. fidelity
-            norm = A
-        return np.real(norm) / self.dimensional_norm
-
-    def normalize_gradient_SU(self, grad):
-        """
-        Normalise the gradient matrix passed as grad
-        This SU version respects global phase
-        """
-        return np.real(grad) / self.dimensional_norm
-
-    def normalize_PSU(self, A):
-        try:
-            if A.shape[0] == A.shape[1]:
-                # input is an operator (Qobj, array, sparse etc), so
-                norm = _trace(A)
-            else:
-                raise TypeError("Cannot compute trace (not square)")
-        except (AttributeError, IndexError):
-            # assume input is already scalar and hence assumed
-            # to be the prenormalised scalar value, e.g. fidelity
-            norm = A
-        return np.abs(norm) / self.dimensional_norm
-
-    def normalize_gradient_PSU(self, grad):
-        """
-        Normalise the gradient matrix passed as grad
-        This PSU version is independent of global phase
-        """
-        fid_pn = self.get_fidelity_prenorm()
-        return np.real(grad * np.exp(-1j * np.angle(fid_pn))
-                       / self.dimensional_norm)
-
-    def get_fid_err(self):
-        """
-        Gets the absolute error in the fidelity
-        """
-        return np.abs(1 - self.get_fidelity())
-
-    def get_fidelity(self):
-        """
-        Gets the appropriately normalised fidelity value
-        The normalisation is determined by the fid_norm_func pointer
-        which should be set in the config
-        """
-        if not self.fidelity_current:
-            self.fidelity = \
-                self.fid_norm_func(self.get_fidelity_prenorm())
-            self.fidelity_current = True
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Fidelity (normalised): {}".format(self.fidelity))
-        return self.fidelity
-
-    def get_fidelity_prenorm(self):
-        """
-        Gets the current fidelity value prior to normalisation
-        Note the gradient function uses this value
-        The value is cached, because it is used in the gradient calculation
-        """
-        if not self.fidelity_prenorm_current:
-            dyn = self.parent
-            k = dyn.tslot_computer._get_timeslot_for_fidelity_calc()
-            dyn.compute_evolution()
-            if dyn.oper_dtype == Qobj:
-                f = dyn._onto_evo[k]*dyn._fwd_evo[k]
-                if isinstance(f, Qobj):
-                    f = f.tr()
-            else:
-                f = _trace(dyn._onto_evo[k].dot(dyn._fwd_evo[k]))
-            self.fidelity_prenorm = f
-            self.fidelity_prenorm_current = True
-            if dyn.stats is not None:
-                dyn.stats.num_fidelity_computes += 1
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Fidelity (pre normalisation): {}".format(
-                    self.fidelity_prenorm))
-        return self.fidelity_prenorm
-
-    def get_fid_err_gradient(self):
-        """
-        Returns the normalised gradient of the fidelity error
-        in a (nTimeslots x n_ctrls) array
-        The gradients are cached in case they are requested
-        mutliple times between control updates
-        (although this is not typically found to happen)
-        """
-        if not self.fid_err_grad_current:
-            dyn = self.parent
-            grad_prenorm = self.compute_fid_grad()
-            if self.log_level <= logging.DEBUG_INTENSE:
-                logger.log(logging.DEBUG_INTENSE, "pre-normalised fidelity "
-                           "gradients:\n{}".format(grad_prenorm))
-            # AJGP: Note this check should not be necessary if dynamics are
-            #       unitary. However, if they are not then this gradient
-            #       can still be used, however the interpretation is dubious
-            if self.get_fidelity() >= 1:
-                self.fid_err_grad = self.grad_norm_func(grad_prenorm)
-            else:
-                self.fid_err_grad = -self.grad_norm_func(grad_prenorm)
-
-            self.fid_err_grad_current = True
-            if dyn.stats is not None:
-                dyn.stats.num_grad_computes += 1
-
-            self.grad_norm = np.sqrt(np.sum(self.fid_err_grad**2))
-            if self.log_level <= logging.DEBUG_INTENSE:
-                logger.log(logging.DEBUG_INTENSE, "Normalised fidelity error "
-                           "gradients:\n{}".format(self.fid_err_grad))
-
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Gradient (sum sq norm): "
-                             "{} ".format(self.grad_norm))
-
-        return self.fid_err_grad
-
-    def compute_fid_grad(self):
-        """
-        Calculates exact gradient of function wrt to each timeslot
-        control amplitudes. Note these gradients are not normalised
-        These are returned as a (nTimeslots x n_ctrls) array
-        """
-        dyn = self.parent
-        n_ctrls = dyn.num_ctrls
-        n_ts = dyn.num_tslots
-
-        # create n_ts x n_ctrls zero array for grad start point
-        grad = np.zeros([n_ts, n_ctrls], dtype=complex)
-
-        dyn.tslot_computer.flag_all_calc_now()
-        dyn.compute_evolution()
-
-        # loop through all ctrl timeslots calculating gradients
-        time_st = timeit.default_timer()
-        for j in range(n_ctrls):
-            for k in range(n_ts):
-                fwd_evo = dyn._fwd_evo[k]
-                onto_evo = dyn._onto_evo[k+1]
-                if dyn.oper_dtype == Qobj:
-                    g = onto_evo*dyn._get_prop_grad(k, j)*fwd_evo
-                    if isinstance(g, Qobj):
-                        g = g.tr()
-                else:
-                    g = _trace(onto_evo.dot(
-                                dyn._get_prop_grad(k, j)).dot(fwd_evo))
-                grad[k, j] = g
-        if dyn.stats is not None:
-            dyn.stats.wall_time_gradient_compute += \
-                timeit.default_timer() - time_st
-        return grad
-
-
-class FidCompTraceDiff(FidelityComputer):
-    """
-    Computes fidelity error and gradient for general system dynamics
-    by calculating the the fidelity error as the trace of the overlap
-    of the difference between the target and evolution resulting from
-    the pulses with the transpose of the same.
-    This should provide a distance measure for dynamics described by matrices
-    Note the gradient calculation is taken from:
-    'Robust quantum gates for open systems via optimal control:
-    Markovian versus non-Markovian dynamics'
-    Frederik F Floether, Pierre de Fouquieres, and Sophie G Schirmer
-
-    Attributes
-    ----------
-    scale_factor : float
-        The fidelity error calculated is of some arbitary scale. This
-        factor can be used to scale the fidelity error such that it may
-        represent some physical measure
-        If None is given then it is caculated as 1/2N, where N
-        is the dimension of the drift, when the Dynamics are initialised.
-    """
-
-    def reset(self):
-        FidelityComputer.reset(self)
-        self.id_text = 'TRACEDIFF'
-        self.scale_factor = None
-        self.uses_onwd_evo = True
-        if not self.parent.prop_computer.grad_exact:
-            raise errors.UsageError(
-                "This FidelityComputer can only be"
-                " used with an exact gradient PropagatorComputer.")
-        self.apply_params()
-
-    def init_comp(self):
-        """
-        initialises the computer based on the configuration of the Dynamics
-        Calculates the scale_factor is not already set
-        """
-        if self.scale_factor is None:
-            self.scale_factor = 1.0 / (2.0*self.parent.get_drift_dim())
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Scale factor calculated as {}".format(
-                    self.scale_factor))
-
-    def get_fid_err(self):
-        """
-        Gets the absolute error in the fidelity
-        """
-        if not self.fidelity_current:
-            dyn = self.parent
-            dyn.compute_evolution()
-            n_ts = dyn.num_tslots
-            evo_final = dyn._fwd_evo[n_ts]
-            evo_f_diff = dyn._target - evo_final
-            if self.log_level <= logging.DEBUG_VERBOSE:
-                logger.log(logging.DEBUG_VERBOSE, "Calculating TraceDiff "
-                           "fidelity...\n Target:\n{}\n Evo final:\n{}\n"
-                           "Evo final diff:\n{}".format(dyn._target, evo_final,
-                                                        evo_f_diff))
-
-            # Calculate the fidelity error using the trace difference norm
-            # Note that the value should have not imagnary part, so using
-            # np.real, just avoids the complex casting warning
-            if dyn.oper_dtype == Qobj:
-                self.fid_err = self.scale_factor*np.real(
-                        (evo_f_diff.dag()*evo_f_diff).tr())
-            else:
-                self.fid_err = self.scale_factor*np.real(_trace(
-                        evo_f_diff.conj().T.dot(evo_f_diff)))
-
-            if np.isnan(self.fid_err):
-                self.fid_err = np.Inf
-
-            if dyn.stats is not None:
-                dyn.stats.num_fidelity_computes += 1
-
-            self.fidelity_current = True
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Fidelity error: {}".format(self.fid_err))
-
-        return self.fid_err
-
-    def get_fid_err_gradient(self):
-        """
-        Returns the normalised gradient of the fidelity error
-        in a (nTimeslots x n_ctrls) array
-        The gradients are cached in case they are requested
-        mutliple times between control updates
-        (although this is not typically found to happen)
-        """
-        if not self.fid_err_grad_current:
-            dyn = self.parent
-            self.fid_err_grad = self.compute_fid_err_grad()
-            self.fid_err_grad_current = True
-            if dyn.stats is not None:
-                dyn.stats.num_grad_computes += 1
-
-            self.grad_norm = np.sqrt(np.sum(self.fid_err_grad**2))
-            if self.log_level <= logging.DEBUG_INTENSE:
-                logger.log(logging.DEBUG_INTENSE, "fidelity error gradients:\n"
-                           "{}".format(self.fid_err_grad))
-
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Gradient norm: "
-                             "{} ".format(self.grad_norm))
-
-        return self.fid_err_grad
-
-    def compute_fid_err_grad(self):
-        """
-        Calculate exact gradient of the fidelity error function
-        wrt to each timeslot control amplitudes.
-        Uses the trace difference norm fidelity
-        These are returned as a (nTimeslots x n_ctrls) array
-        """
-        dyn = self.parent
-        n_ctrls = dyn.num_ctrls
-        n_ts = dyn.num_tslots
-
-        # create n_ts x n_ctrls zero array for grad start point
-        grad = np.zeros([n_ts, n_ctrls])
-
-        dyn.tslot_computer.flag_all_calc_now()
-        dyn.compute_evolution()
-
-        # loop through all ctrl timeslots calculating gradients
-        time_st = timeit.default_timer()
-
-        evo_final = dyn._fwd_evo[n_ts]
-        evo_f_diff = dyn._target - evo_final
-        for j in range(n_ctrls):
-            for k in range(n_ts):
-                fwd_evo = dyn._fwd_evo[k]
-                if dyn.oper_dtype == Qobj:
-                    evo_grad = dyn._get_prop_grad(k, j)*fwd_evo
-                    if k+1 < n_ts:
-                        evo_grad = dyn._onwd_evo[k+1]*evo_grad
-                    # Note that the value should have not imagnary part, so
-                    # using np.real, just avoids the complex casting warning
-                    g = -2*self.scale_factor*np.real(
-                                    (evo_f_diff.dag()*evo_grad).tr())
-                else:
-                    evo_grad = dyn._get_prop_grad(k, j).dot(fwd_evo)
-                    if k+1 < n_ts:
-                        evo_grad = dyn._onwd_evo[k+1].dot(evo_grad)
-                    g = -2*self.scale_factor*np.real(_trace(
-                                    evo_f_diff.conj().T.dot(evo_grad)))
-                if np.isnan(g):
-                    g = np.Inf
-
-                grad[k, j] = g
-        if dyn.stats is not None:
-            dyn.stats.wall_time_gradient_compute += \
-                timeit.default_timer() - time_st
-        return grad
-
-
-class FidCompTraceDiffApprox(FidCompTraceDiff):
-    """
-    As FidCompTraceDiff, except uses the finite difference method to
-    compute approximate gradients
-
-    Attributes
-    ----------
-    epsilon : float
-        control amplitude offset to use when approximating the gradient wrt
-        a timeslot control amplitude
-    """
-    def reset(self):
-        FidelityComputer.reset(self)
-        self.id_text = 'TDAPPROX'
-        self.uses_onwd_evo = True
-        self.scale_factor = None
-        self.epsilon = 0.001
-        self.apply_params()
-
-    def compute_fid_err_grad(self):
-        """
-        Calculates gradient of function wrt to each timeslot
-        control amplitudes. Note these gradients are not normalised
-        They are calulated
-        These are returned as a (nTimeslots x n_ctrls) array
-        """
-        dyn = self.parent
-        prop_comp = dyn.prop_computer
-        n_ctrls = dyn.num_ctrls
-        n_ts = dyn.num_tslots
-
-        if self.log_level >= logging.DEBUG:
-            logger.debug("Computing fidelity error gradient")
-        # create n_ts x n_ctrls zero array for grad start point
-        grad = np.zeros([n_ts, n_ctrls])
-
-        dyn.tslot_computer.flag_all_calc_now()
-        dyn.compute_evolution()
-        curr_fid_err = self.get_fid_err()
-
-        # loop through all ctrl timeslots calculating gradients
-        time_st = timeit.default_timer()
-
-        for j in range(n_ctrls):
-            for k in range(n_ts):
-                fwd_evo = dyn._fwd_evo[k]
-                prop_eps = prop_comp._compute_diff_prop(k, j, self.epsilon)
-                if dyn.oper_dtype == Qobj:
-                    evo_final_eps = fwd_evo*prop_eps
-                    if k+1 < n_ts:
-                        evo_final_eps = evo_final_eps*dyn._onwd_evo[k+1]
-                    evo_f_diff_eps = dyn._target - evo_final_eps
-                    # Note that the value should have not imagnary part, so
-                    # using np.real, just avoids the complex casting warning
-                    fid_err_eps = self.scale_factor*np.real(
-                        (evo_f_diff_eps.dag()*evo_f_diff_eps).tr())
-                else:
-                    evo_final_eps = fwd_evo.dot(prop_eps)
-                    if k+1 < n_ts:
-                        evo_final_eps = evo_final_eps.dot(dyn._onwd_evo[k+1])
-                    evo_f_diff_eps = dyn._target - evo_final_eps
-                    fid_err_eps = self.scale_factor*np.real(_trace(
-                        evo_f_diff_eps.conj().T.dot(evo_f_diff_eps)))
-
-                g = (fid_err_eps - curr_fid_err)/self.epsilon
-                if np.isnan(g):
-                    g = np.Inf
-
-                grad[k, j] = g
-
-        if dyn.stats is not None:
-            dyn.stats.wall_time_gradient_compute += \
-                timeit.default_timer() - time_st
-
-        return grad
diff --git a/qutip/control/grape.py b/qutip/control/grape.py
deleted file mode 100644
index c174a96039..0000000000
--- a/qutip/control/grape.py
+++ /dev/null
@@ -1,603 +0,0 @@
-"""
-This module contains functions that implement the GRAPE algorithm for
-calculating pulse sequences for quantum systems.
-"""
-
-__all__ = ['plot_grape_control_fields',
-           'grape_unitary', 'cy_grape_unitary', 'grape_unitary_adaptive']
-
-import warnings
-import time
-import numpy as np
-from scipy.interpolate import interp1d
-import scipy.sparse as sp
-
-from qutip import Qobj
-from qutip.ui.progressbar import BaseProgressBar
-from qutip.control.cy_grape import cy_overlap, cy_grape_inner
-
-import qutip.logging_utils
-logger = qutip.logging_utils.get_logger('qutip.control.grape')
-
-
-class GRAPEResult:
-    """
-    Class for representing the result of a GRAPE simulation.
-
-    Attributes
-    ----------
-    u : array
-        GRAPE control pulse matrix.
-
-    H_t : time-dependent Hamiltonian
-        The time-dependent Hamiltonian that realize the GRAPE pulse sequence.
-
-    U_f : Qobj
-        The final unitary transformation that is realized by the evolution
-        of the system with the GRAPE generated pulse sequences.
-    """
-    def __init__(self, u=None, H_t=None, U_f=None):
-        self.u = u
-        self.H_t = H_t
-        self.U_f = U_f
-
-
-def plot_grape_control_fields(times, u, labels, uniform_axes=False):
-    """
-    Plot a series of plots showing the GRAPE control fields given in the
-    given control pulse matrix u.
-
-    Parameters
-    ----------
-    times : array
-        Time coordinate array.
-
-    u : array
-        Control pulse matrix.
-
-    labels : list
-        List of labels for each control pulse sequence in the control pulse
-        matrix.
-
-    uniform_axes : bool
-        Whether or not to plot all pulse sequences using the same y-axis scale.
-    """
-    import matplotlib.pyplot as plt
-    R, J, M = u.shape
-    fig, axes = plt.subplots(J, 1, figsize=(8, 2 * J), squeeze=False)
-    y_max = abs(u).max()
-    for r in range(R):
-        for j in range(J):
-            if r == R - 1:
-                lw, lc, alpha = 2.0, 'k', 1.0
-                axes[j, 0].set_ylabel(labels[j], fontsize=18)
-                axes[j, 0].set_xlabel(r'$t$', fontsize=18)
-                axes[j, 0].set_xlim(0, times[-1])
-            else:
-                lw, lc, alpha = 0.5, 'b', 0.25
-            axes[j, 0].step(times, u[r, j, :], lw=lw, color=lc, alpha=alpha)
-            if uniform_axes:
-                axes[j, 0].set_ylim(-y_max, y_max)
-    fig.tight_layout()
-    return fig, axes
-
-
-def _overlap(A, B):
-    return (A.dag() * B).tr() / A.shape[0]
-
-
-def grape_unitary(U, H0, H_ops, R, times, eps=None, u_start=None,
-                  u_limits=None, interp_kind='linear', use_interp=False,
-                  alpha=None, beta=None, phase_sensitive=True,
-                  progress_bar=None):
-    """
-    Calculate control pulses for the Hamiltonian operators in H_ops so that the
-    unitary U is realized.
-
-    Experimental: Work in progress.
-
-    Parameters
-    ----------
-    U : Qobj
-        Target unitary evolution operator.
-
-    H0 : Qobj
-        Static Hamiltonian (that cannot be tuned by the control fields).
-
-    H_ops: list of Qobj
-        A list of operators that can be tuned in the Hamiltonian via the
-        control fields.
-
-    R : int
-        Number of GRAPE iterations.
-
-    time : array / list
-        Array of time coordinates for control pulse evalutation.
-
-    u_start : array
-        Optional array with initial control pulse values.
-
-    Returns
-    -------
-        Instance of GRAPEResult, which contains the control pulses calculated
-        with GRAPE, a time-dependent Hamiltonian that is defined by the
-        control pulses, as well as the resulting propagator.
-    """
-    progress_bar = progress_bar or BaseProgressBar()
-    if eps is None:
-        eps = 0.1 * (2 * np.pi) / (times[-1])
-
-    M = len(times)
-    J = len(H_ops)
-
-    u = np.zeros((R, J, M))
-
-    if u_limits and len(u_limits) != 2:
-        raise ValueError("u_limits must be a list with two values")
-
-    if u_limits:
-        warnings.warn("Caution: Using experimental feature u_limits")
-
-    if u_limits and u_start:
-        # make sure that no values in u0 violates the u_limits conditions
-        u_start = np.array(u_start)
-        u_start[u_start < u_limits[0]] = u_limits[0]
-        u_start[u_start > u_limits[1]] = u_limits[1]
-
-    if u_start is not None:
-        for idx, u0 in enumerate(u_start):
-            u[0, idx, :] = u0
-
-    if beta:
-        warnings.warn("Causion: Using experimental feature time-penalty")
-
-    progress_bar.start(R)
-    for r in range(R - 1):
-        progress_bar.update(r)
-
-        dt = times[1] - times[0]
-
-        if use_interp:
-            ip_funcs = [interp1d(times, u[r, j, :], kind=interp_kind,
-                                 bounds_error=False, fill_value=u[r, j, -1])
-                        for j in range(J)]
-
-            def _H_t(t, args=None):
-                return H0 + sum(float(ip_funcs[j](t)) * H_ops[j]
-                                for j in range(J))
-
-            U_list = [(-1j * _H_t(times[idx]) * dt).expm()
-                      for idx in range(M-1)]
-
-        else:
-            def _H_idx(idx):
-                return H0 + sum([u[r, j, idx] * H_ops[j] for j in range(J)])
-
-            U_list = [(-1j * _H_idx(idx) * dt).expm() for idx in range(M-1)]
-
-        U_f_list = []
-        U_b_list = []
-
-        U_f = 1
-        U_b = 1
-        for n in range(M - 1):
-            U_f = U_list[n] * U_f
-            U_f_list.append(U_f)
-            U_b_list.insert(0, U_b)
-            U_b = U_list[M - 2 - n].dag() * U_b
-
-        for j in range(J):
-            for m in range(M-1):
-                P = U_b_list[m] * U
-                Q = 1j * dt * H_ops[j] * U_f_list[m]
-
-                if phase_sensitive:
-                    du = - _overlap(P, Q)
-                else:
-                    du = - 2 * _overlap(P, Q) * _overlap(U_f_list[m], P)
-
-                if alpha:
-                    # penalty term for high power control signals u
-                    du += -2 * alpha * u[r, j, m] * dt
-
-                if beta:
-                    # penalty term for late control signals u
-                    du += -2 * beta * m * u[r, j, m] * dt
-
-                u[r + 1, j, m] = u[r, j, m] + eps * du.real
-
-                if u_limits:
-                    if u[r + 1, j, m] < u_limits[0]:
-                        u[r + 1, j, m] = u_limits[0]
-                    elif u[r + 1, j, m] > u_limits[1]:
-                        u[r + 1, j, m] = u_limits[1]
-
-            u[r + 1, j, -1] = u[r + 1, j, -2]
-
-    if use_interp:
-        ip_funcs = [interp1d(times, u[R - 1, j, :], kind=interp_kind,
-                             bounds_error=False, fill_value=u[R - 1, j, -1])
-                    for j in range(J)]
-
-        H_td_func = [H0] + [[H_ops[j], lambda t, args, j=j: ip_funcs[j](t)]
-                            for j in range(J)]
-    else:
-        H_td_func = [H0] + [[H_ops[j], u[-1, j, :]] for j in range(J)]
-
-    progress_bar.finished()
-
-    # return U_f_list[-1], H_td_func, u
-    return GRAPEResult(u=u, U_f=U_f_list[-1], H_t=H_td_func)
-
-
-def cy_grape_unitary(U, H0, H_ops, R, times, eps=None, u_start=None,
-                     u_limits=None, interp_kind='linear', use_interp=False,
-                     alpha=None, beta=None, phase_sensitive=True,
-                     progress_bar=None):
-    """
-    Calculate control pulses for the Hamitonian operators in H_ops so that the
-    unitary U is realized.
-
-    Experimental: Work in progress.
-
-    Parameters
-    ----------
-    U : Qobj
-        Target unitary evolution operator.
-
-    H0 : Qobj
-        Static Hamiltonian (that cannot be tuned by the control fields).
-
-    H_ops: list of Qobj
-        A list of operators that can be tuned in the Hamiltonian via the
-        control fields.
-
-    R : int
-        Number of GRAPE iterations.
-
-    time : array / list
-        Array of time coordinates for control pulse evalutation.
-
-    u_start : array
-        Optional array with initial control pulse values.
-
-    Returns
-    -------
-        Instance of GRAPEResult, which contains the control pulses calculated
-        with GRAPE, a time-dependent Hamiltonian that is defined by the
-        control pulses, as well as the resulting propagator.
-    """
-    progress_bar = progress_bar or BaseProgressBar()
-
-    if eps is None:
-        eps = 0.1 * (2 * np.pi) / (times[-1])
-
-    M = len(times)
-    J = len(H_ops)
-
-    u = np.zeros((R, J, M))
-
-    H_ops_data = [H_op.data for H_op in H_ops]
-
-    if u_limits and len(u_limits) != 2:
-        raise ValueError("u_limits must be a list with two values")
-
-    if u_limits:
-        warnings.warn("Causion: Using experimental feature u_limits")
-
-    if u_limits and u_start:
-        # make sure that no values in u0 violates the u_limits conditions
-        u_start = np.array(u_start)
-        u_start[u_start < u_limits[0]] = u_limits[0]
-        u_start[u_start > u_limits[1]] = u_limits[1]
-
-    if u_limits:
-        use_u_limits = 1
-        u_min = u_limits[0]
-        u_max = u_limits[1]
-    else:
-        use_u_limits = 0
-        u_min = 0.0
-        u_max = 0.0
-
-    if u_start is not None:
-        for idx, u0 in enumerate(u_start):
-            u[0, idx, :] = u0
-
-    if beta:
-        warnings.warn("Causion: Using experimental feature time-penalty")
-
-    alpha_val = alpha if alpha else 0.0
-    beta_val = beta if beta else 0.0
-
-    progress_bar.start(R)
-    for r in range(R - 1):
-        progress_bar.update(r)
-
-        dt = times[1] - times[0]
-
-        if use_interp:
-            ip_funcs = [interp1d(times, u[r, j, :], kind=interp_kind,
-                                 bounds_error=False, fill_value=u[r, j, -1])
-                        for j in range(J)]
-
-            def _H_t(t, args=None):
-                return H0 + sum([float(ip_funcs[j](t)) * H_ops[j]
-                                 for j in range(J)])
-
-            U_list = [(-1j * _H_t(times[idx]) * dt).expm().data
-                      for idx in range(M-1)]
-
-        else:
-            def _H_idx(idx):
-                return H0 + sum([u[r, j, idx] * H_ops[j] for j in range(J)])
-
-            U_list = [(-1j * _H_idx(idx) * dt).expm().data
-                      for idx in range(M-1)]
-
-        U_f_list = []
-        U_b_list = []
-
-        U_f = 1
-        U_b = sp.eye(*(U.shape))
-        for n in range(M - 1):
-
-            U_f = U_list[n] * U_f
-            U_f_list.append(U_f)
-
-            U_b_list.insert(0, U_b)
-            U_b = U_list[M - 2 - n].T.conj().tocsr() * U_b
-
-        cy_grape_inner(U.data, u, r, J, M, U_b_list, U_f_list, H_ops_data,
-                       dt, eps, alpha_val, beta_val, phase_sensitive,
-                       use_u_limits, u_min, u_max)
-
-    if use_interp:
-        ip_funcs = [interp1d(times, u[R - 1, j, :], kind=interp_kind,
-                             bounds_error=False, fill_value=u[R - 1, j, -1])
-                    for j in range(J)]
-
-        H_td_func = [H0] + [[H_ops[j], lambda t, args, j=j: ip_funcs[j](t)]
-                            for j in range(J)]
-    else:
-        H_td_func = [H0] + [[H_ops[j], u[-1, j, :]] for j in range(J)]
-
-    progress_bar.finished()
-
-    return GRAPEResult(u=u, U_f=Qobj(U_f_list[-1], dims=U.dims),
-                       H_t=H_td_func)
-
-
-def grape_unitary_adaptive(U, H0, H_ops, R, times, eps=None, u_start=None,
-                           u_limits=None, interp_kind='linear',
-                           use_interp=False, alpha=None, beta=None,
-                           phase_sensitive=False, overlap_terminate=1.0,
-                           progress_bar=None):
-    """
-    Calculate control pulses for the Hamiltonian operators in H_ops so that
-    the unitary U is realized.
-
-    Experimental: Work in progress.
-
-    Parameters
-    ----------
-    U : Qobj
-        Target unitary evolution operator.
-
-    H0 : Qobj
-        Static Hamiltonian (that cannot be tuned by the control fields).
-
-    H_ops: list of Qobj
-        A list of operators that can be tuned in the Hamiltonian via the
-        control fields.
-
-    R : int
-        Number of GRAPE iterations.
-
-    time : array / list
-        Array of time coordinates for control pulse evalutation.
-
-    u_start : array
-        Optional array with initial control pulse values.
-
-    Returns
-    -------
-        Instance of GRAPEResult, which contains the control pulses calculated
-        with GRAPE, a time-dependent Hamiltonian that is defined by the
-        control pulses, as well as the resulting propagator.
-    """
-    progress_bar = progress_bar or BaseProgressBar()
-
-    if eps is None:
-        eps = 0.1 * (2 * np.pi) / (times[-1])
-
-    eps_vec = np.array([eps / 2, eps, 2 * eps])
-    eps_log = np.zeros(R)
-    overlap_log = np.zeros(R)
-
-    best_k = 0
-    _k_overlap = np.array([0.0, 0.0, 0.0])
-
-    M = len(times)
-    J = len(H_ops)
-    K = len(eps_vec)
-    Uf = [None for _ in range(K)]
-
-    u = np.zeros((R, J, M, K))
-
-    if u_limits and len(u_limits) != 2:
-        raise ValueError("u_limits must be a list with two values")
-
-    if u_limits:
-        warnings.warn("Causion: Using experimental feature u_limits")
-
-    if u_limits and u_start:
-        # make sure that no values in u0 violates the u_limits conditions
-        u_start = np.array(u_start)
-        u_start[u_start < u_limits[0]] = u_limits[0]
-        u_start[u_start > u_limits[1]] = u_limits[1]
-
-    if u_start is not None:
-        for idx, u0 in enumerate(u_start):
-            for k in range(K):
-                u[0, idx, :, k] = u0
-
-    if beta:
-        warnings.warn("Causion: Using experimental feature time-penalty")
-
-    if phase_sensitive:
-        def _fidelity_function(x): return x
-    else:
-        def _fidelity_function(x): return abs(x)**2
-
-    best_k = 1
-    _r = 0
-    _prev_overlap = 0
-
-    progress_bar.start(R)
-    for r in range(R - 1):
-        progress_bar.update(r)
-
-        _r = r
-        eps_log[r] = eps_vec[best_k]
-
-        logger.debug("eps_vec: {}".format(eps_vec))
-
-        _t0 = time.time()
-
-        dt = times[1] - times[0]
-
-        if use_interp:
-            ip_funcs = [interp1d(times, u[r, j, :, best_k], kind=interp_kind,
-                                 bounds_error=False,
-                                 fill_value=u[r, j, -1, best_k])
-                        for j in range(J)]
-
-            def _H_t(t, args=None):
-                return H0 + sum([float(ip_funcs[j](t)) * H_ops[j]
-                                 for j in range(J)])
-
-            U_list = [(-1j * _H_t(times[idx]) * dt).expm()
-                      for idx in range(M-1)]
-
-        else:
-            def _H_idx(idx):
-                return H0 + sum([u[r, j, idx, best_k] * H_ops[j]
-                                 for j in range(J)])
-
-            U_list = [(-1j * _H_idx(idx) * dt).expm() for idx in range(M-1)]
-
-        logger.debug("Time 1: %fs" % (time.time() - _t0))
-        _t0 = time.time()
-
-        U_f_list = []
-        U_b_list = []
-
-        U_f = 1
-        U_b = 1
-        for m in range(M - 1):
-
-            U_f = U_list[m] * U_f
-            U_f_list.append(U_f)
-
-            U_b_list.insert(0, U_b)
-            U_b = U_list[M - 2 - m].dag() * U_b
-
-        logger.debug("Time 2: %fs" % (time.time() - _t0))
-        _t0 = time.time()
-
-        for j in range(J):
-            for m in range(M-1):
-                P = U_b_list[m] * U
-                Q = 1j * dt * H_ops[j] * U_f_list[m]
-
-                if phase_sensitive:
-                    du = - cy_overlap(P.data, Q.data)
-                else:
-                    du = (- 2 * cy_overlap(P.data, Q.data) *
-                          cy_overlap(U_f_list[m].data, P.data))
-
-                if alpha:
-                    # penalty term for high power control signals u
-                    du += -2 * alpha * u[r, j, m, best_k] * dt
-
-                if beta:
-                    # penalty term for late control signals u
-                    du += -2 * beta * k ** 2 * u[r, j, k] * dt
-
-                for k, eps_val in enumerate(eps_vec):
-                    u[r + 1, j, m, k] = u[r, j, m, k] + eps_val * du.real
-
-                    if u_limits:
-                        if u[r + 1, j, m, k] < u_limits[0]:
-                            u[r + 1, j, m, k] = u_limits[0]
-                        elif u[r + 1, j, m, k] > u_limits[1]:
-                            u[r + 1, j, m, k] = u_limits[1]
-
-            u[r + 1, j, -1, :] = u[r + 1, j, -2, :]
-
-        logger.debug("Time 3: %fs", time.time() - _t0)
-        _t0 = time.time()
-
-        for k, eps_val in enumerate(eps_vec):
-
-            def _H_idx(idx):
-                return H0 + sum([u[r + 1, j, idx, k] * H_ops[j]
-                                 for j in range(J)])
-
-            U_list = [(-1j * _H_idx(idx) * dt).expm() for idx in range(M-1)]
-
-            Uf[k] = 1
-            for U in U_list:
-                Uf[k] = U * Uf[k]
-
-            _k_overlap[k] = _fidelity_function(cy_overlap(Uf[k].data,
-                                                          U.data)).real
-
-        best_k = np.argmax(_k_overlap)
-        logger.debug("k_overlap: %s, %e", repr(_k_overlap), best_k)
-
-        if _prev_overlap > _k_overlap[best_k]:
-            logger.debug("Regression, stepping back with smaller eps.")
-
-            u[r + 1, :, :, :] = u[r, :, :, :]
-            eps_vec /= 2
-        else:
-
-            if best_k == 0:
-                eps_vec /= 2
-
-            elif best_k == 2:
-                eps_vec *= 2
-
-            _prev_overlap = _k_overlap[best_k]
-
-        overlap_log[r] = _k_overlap[best_k]
-
-        if overlap_terminate < 1.0:
-            if _k_overlap[best_k] > overlap_terminate:
-                logger.info("Reached target fidelity, terminating.")
-                break
-
-        logger.debug("Time 4: %fs", time.time() - _t0)
-        _t0 = time.time()
-
-    if use_interp:
-        ip_funcs = [interp1d(times, u[_r, j, :, best_k], kind=interp_kind,
-                             bounds_error=False, fill_value=u[R - 1, j, -1])
-                    for j in range(J)]
-
-        H_td_func = [H0] + [[H_ops[j], lambda t, args, j=j: ip_funcs[j](t)]
-                            for j in range(J)]
-    else:
-        H_td_func = [H0] + [[H_ops[j], u[_r, j, :, best_k]] for j in range(J)]
-
-    progress_bar.finished()
-
-    result = GRAPEResult(u=u[:_r, :, :, best_k], U_f=Uf[best_k],
-                         H_t=H_td_func)
-
-    result.eps = eps_log
-    result.overlap = overlap_log
-
-    return result
diff --git a/qutip/control/io.py b/qutip/control/io.py
deleted file mode 100644
index ae9e5a2d96..0000000000
--- a/qutip/control/io.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import os
-import errno
-
-
-def create_dir(dir_name, desc='output'):
-    """
-    Checks if the given directory exists, if not it is created
-
-    Returns
-    -------
-    dir_ok : boolean
-        True if directory exists (previously or created)
-        False if failed to create the directory
-
-    dir_name : string
-        Path to the directory, which may be been made absolute
-
-    msg : string
-        Error msg if directory creation failed
-    """
-    dir_ok = True
-    if '~' in dir_name:
-        dir_name = os.path.expanduser(dir_name)
-    elif not os.path.isabs(dir_name):
-        # Assume relative path from cwd given
-        dir_name = os.path.abspath(dir_name)
-
-    msg = "{} directory is ready".format(desc)
-    errmsg = "Failed to create {} directory:\n{}\n".format(desc,
-                                                           dir_name)
-    if os.path.exists(dir_name):
-        if os.path.isfile(dir_name):
-            dir_ok = False
-            errmsg += "A file already exists with the same name"
-    else:
-        try:
-            os.makedirs(dir_name)
-            msg += ("directory {} created (recursively)".format(dir_name))
-        except OSError as e:
-            if e.errno == errno.EEXIST:
-                msg += (
-                    "Assume directory {} created "
-                    "(recursively) by some other process. ".format(dir_name)
-                )
-            else:
-                dir_ok = False
-                errmsg += "Underling error (makedirs) :({}) {}".format(
-                    type(e).__name__, e)
-
-    if dir_ok:
-        return dir_ok, dir_name, msg
-    else:
-        return dir_ok, dir_name, errmsg
diff --git a/qutip/control/loadparams.py b/qutip/control/loadparams.py
deleted file mode 100644
index 1320a7e0be..0000000000
--- a/qutip/control/loadparams.py
+++ /dev/null
@@ -1,193 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Loads parameters for config, termconds, dynamics and Optimiser objects from a
-parameter (ini) file with appropriate sections and options, these being
-Sections: optimconfig, termconds, dynamics, optimizer
-The options are assumed to be properties for these classes
-Note that new attributes will be created, even if they are not usually
-defined for that object
-"""
-
-import numpy as np
-from configparser import ConfigParser
-# QuTiP logging
-from qutip import Qobj
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-
-def load_parameters(file_name, config=None, term_conds=None,
-                    dynamics=None, optim=None, pulsegen=None,
-                    obj=None, section=None):
-    """
-    Import parameters for the optimisation objects
-    Will throw a ValueError if file_name does not exist
-    """
-    parser = ConfigParser()
-
-    readFiles = parser.read(str(file_name))
-    if len(readFiles) == 0:
-        raise ValueError("Parameter file '{}' not found".format(file_name))
-
-    if config is not None:
-        s = 'optimconfig'
-        try:
-            attr_names = parser.options(s)
-            for a in attr_names:
-                set_param(parser, s, a, config, a)
-        except Exception as e:
-            logger.warn("Unable to load {} parameters:({}) {}".format(
-                s, type(e).__name__, e))
-
-    if term_conds is not None:
-        s = 'termconds'
-        try:
-            attr_names = parser.options(s)
-            for a in attr_names:
-                set_param(parser, s, a, term_conds, a)
-        except Exception as e:
-            logger.warn("Unable to load {} parameters:({}) {}".format(
-                s, type(e).__name__, e))
-
-    if dynamics is not None:
-        s = 'dynamics'
-        try:
-            attr_names = parser.options(s)
-            for a in attr_names:
-                set_param(parser, s, a, dynamics, a)
-        except Exception as e:
-            logger.warn("Unable to load {} parameters:({}) {}".format(
-                s, type(e).__name__, e))
-
-    if optim is not None:
-        s = 'optimizer'
-        try:
-            attr_names = parser.options(s)
-            for a in attr_names:
-                set_param(parser, s, a, optim, a)
-        except Exception as e:
-            logger.warn("Unable to load {} parameters:({}) {}".format(
-                s, type(e).__name__, e))
-
-    if pulsegen is not None:
-        s = 'pulsegen'
-        try:
-            attr_names = parser.options(s)
-            for a in attr_names:
-                set_param(parser, s, a, pulsegen, a)
-        except Exception as e:
-            logger.warn("Unable to load {} parameters:({}) {}".format(
-                s, type(e).__name__, e))
-
-    if obj is not None:
-        if not isinstance(section, str):
-            raise ValueError(
-                "Section name must be given when loading "
-                "parameters of general object"
-            )
-        s = section
-        try:
-            attr_names = parser.options(s)
-            for a in attr_names:
-                set_param(parser, s, a, obj, a)
-        except Exception as e:
-            logger.warn("Unable to load {} parameters:({}) {}".format(
-                s, type(e).__name__, e))
-
-
-def set_param(parser, section, option, obj, attrib_name):
-    """
-    Set the object attribute value based on the option value from the
-    config file.
-    If the attribute exists already, then its datatype
-    is used to call the appropriate parser.get method
-    Otherwise the parameter is assumed to be a string
-
-    """
-    val = parser.get(section, attrib_name)
-
-    dtype = None
-    if hasattr(obj, attrib_name):
-        a = getattr(obj, attrib_name)
-        dtype = type(a)
-    else:
-        logger.warn("Unable to load parameter {}.{}\n"
-                    "Attribute does not exist".format(section, attrib_name))
-        return
-
-    if isinstance(a, Qobj):
-        try:
-            q = Qobj(eval(val))
-        except:
-            raise ValueError("Value '{}' cannot be used to generate a Qobj"
-                             " in parameter file [{}].{}".format(
-                                 val, section, option))
-        setattr(obj, attrib_name, q)
-    elif isinstance(a, np.ndarray):
-        try:
-            arr = np.array(eval(val), dtype=a.dtype)
-        except:
-            raise ValueError("Value '{}' cannot be used to generate an ndarray"
-                             " in parameter file [{}].{}".format(
-                                 val, section, option))
-        setattr(obj, attrib_name, arr)
-    elif isinstance(a, list):
-        try:
-            l = list(eval(val))
-        except:
-            raise ValueError("Value '{}' cannot be used to generate a list"
-                             " in parameter file [{}].{}".format(
-                                 val, section, option))
-        setattr(obj, attrib_name, l)
-    elif dtype == float:
-        try:
-            f = parser.getfloat(section, attrib_name)
-        except:
-            try:
-                f = eval(val)
-            except:
-                raise ValueError(
-                    "Value '{}' cannot be cast or evaluated as a "
-                    "float in parameter file [{}].{}".format(
-                        val, section, option))
-        setattr(obj, attrib_name, f)
-    elif dtype == complex:
-        try:
-            c = complex(val)
-        except:
-            raise ValueError("Value '{}' cannot be cast as complex"
-                             " in parameter file [{}].{}".format(
-                                 val, section, option))
-        setattr(obj, attrib_name, c)
-    elif dtype == int:
-        try:
-            i = parser.getint(section, attrib_name)
-        except:
-            raise ValueError("Value '{}' cannot be cast as an int"
-                             " in parameter file [{}].{}".format(
-                                 val, section, option))
-        setattr(obj, attrib_name, i)
-    elif dtype == bool:
-        try:
-            b = parser.getboolean(section, attrib_name)
-        except:
-            raise ValueError("Value '{}' cannot be cast as a bool"
-                             " in parameter file [{}].{}".format(
-                                 val, section, option))
-        setattr(obj, attrib_name, b)
-    else:
-        try:
-            val = parser.getfloat(section, attrib_name)
-        except:
-            try:
-                val = parser.getboolean(section, attrib_name)
-            except:
-                pass
-
-        setattr(obj, attrib_name, val)
diff --git a/qutip/control/optimconfig.py b/qutip/control/optimconfig.py
deleted file mode 100644
index dd4d5ecbfd..0000000000
--- a/qutip/control/optimconfig.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Configuration parameters for control pulse optimisation
-"""
-
-import numpy as np
-# QuTiP logging
-import qutip.logging_utils
-logger = qutip.logging_utils.get_logger('qutip.control.optimconfig')
-import qutip.control.io as qtrlio
-
-class OptimConfig(object):
-    """
-    Configuration parameters for control pulse optimisation
-
-    Attributes
-    ----------
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip.logging_utils,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-
-    dyn_type : string
-        Dynamics type, i.e. the type of matrix used to describe
-        the dynamics. Options are UNIT, GEN_MAT, SYMPL
-        (see Dynamics classes for details)
-
-    prop_type : string
-        Propagator type i.e. the method used to calculate the
-        propagtors and propagtor gradient for each timeslot
-        options are DEF, APPROX, DIAG, FRECHET, AUG_MAT
-        DEF will use the default for the specific dyn_type
-        (see PropagatorComputer classes for details)
-
-    fid_type : string
-        Fidelity error (and fidelity error gradient) computation method
-        Options are DEF, UNIT, TRACEDIFF, TD_APPROX
-        DEF will use the default for the specific dyn_type
-        (See FidelityComputer classes for details)
-    """
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.log_level = logger.getEffectiveLevel()
-        self.alg = 'GRAPE'  # Alts: 'CRAB'
-        self.optim_method = 'DEF'
-        self.dyn_type = 'DEF'
-        self.fid_type = 'DEF'
-        self.fid_type = 'DEF'
-        self.tslot_type = 'DEF'
-        self.init_pulse_type = 'DEF'
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    def check_create_output_dir(self, output_dir, desc='output'):
-        """
-        Checks if the given directory exists, if not it is created
-        Returns
-        -------
-        dir_ok : boolean
-            True if directory exists (previously or created)
-            False if failed to create the directory
-
-        output_dir : string
-            Path to the directory, which may be been made absolute
-
-        msg : string
-            Error msg if directory creation failed
-        """
-        return qtrlio.create_dir(output_dir, desc=desc)
-
-
-# create global instance
-optimconfig = OptimConfig()
diff --git a/qutip/control/optimizer.py b/qutip/control/optimizer.py
deleted file mode 100644
index 2cd0094046..0000000000
--- a/qutip/control/optimizer.py
+++ /dev/null
@@ -1,1308 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Classes here are expected to implement a run_optimization function
-that will use some method for optimising the control pulse, as defined
-by the control amplitudes. The system that the pulse acts upon are defined
-by the Dynamics object that must be passed in the instantiation.
-
-The methods are typically N dimensional function optimisers that
-find the minima of a fidelity error function. Note the number of variables
-for the fidelity function is the number of control timeslots,
-i.e. n_ctrls x Ntimeslots
-The methods will call functions on the Dynamics.fid_computer object,
-one or many times per interation,
-to get the fidelity error and gradient wrt to the amplitudes.
-The optimisation will stop when one of the termination conditions are met,
-for example: the fidelity aim has be reached, a local minima has been found,
-the maximum time allowed has been exceeded
-
-These function optimisation methods are so far from SciPy.optimize
-The two methods implemented are:
-
-    BFGS - Broyden–Fletcher–Goldfarb–Shanno algorithm
-
-        This a quasi second order Newton method. It uses successive calls to
-        the gradient function to make an estimation of the curvature (Hessian)
-        and hence direct its search for the function minima
-        The SciPy implementation is pure Python and hance is execution speed is
-        not high
-        use subclass: OptimizerBFGS
-
-    L-BFGS-B - Bounded, limited memory BFGS
-
-        This a version of the BFGS method where the Hessian approximation is
-        only based on a set of the most recent gradient calls. It generally
-        performs better where the are a large number of variables
-        The SciPy implementation of L-BFGS-B is wrapper around a well
-        established and actively maintained implementation in Fortran
-        Its is therefore very fast.
-        # See SciPy documentation for credit and details on the
-        # scipy.optimize.fmin_l_bfgs_b function
-        use subclass: OptimizerLBFGSB
-
-The baseclass Optimizer implements the function wrappers to the
-fidelity error, gradient, and iteration callback functions.
-These are called from the within the SciPy optimisation functions.
-The subclasses implement the algorithm specific pulse optimisation function.
-"""
-
-import functools
-import numpy as np
-import timeit
-import warnings
-from packaging.version import parse as _parse_version
-import scipy
-import scipy.optimize as spopt
-import copy
-import collections
-import timeit
-
-import numpy as np
-import scipy.optimize as spopt
-
-from qutip import Qobj
-import qutip.control.optimresult as optimresult
-import qutip.control.termcond as termcond
-import qutip.control.errors as errors
-import qutip.control.dynamics as dynamics
-import qutip.control.pulsegen as pulsegen
-import qutip.control.dump as qtrldump
-
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-# Older versions of SciPy use the method numpy.ndarray.tostring(), which has
-# been deprecated since Numpy 1.19 in favour of the identical-in-all-but-name
-# tobytes() method.  This is simply a deprecated call in SciPy, there's nothing
-# we or our users can do about it, and the function shouldn't actually be
-# removed from Numpy until at least 1.22, by which point we'll have been able
-# to drop support for SciPy 1.4.
-if _parse_version(scipy.__version__) < _parse_version("1.5"):
-    @functools.wraps(spopt.fmin_l_bfgs_b)
-    def fmin_l_bfgs_b(*args, **kwargs):
-        with warnings.catch_warnings():
-            message = r"tostring\(\) is deprecated\. Use tobytes\(\) instead\."
-            warnings.filterwarnings("ignore", message=message,
-                                    category=DeprecationWarning)
-            return spopt.fmin_l_bfgs_b(*args, **kwargs)
-else:
-    fmin_l_bfgs_b = spopt.fmin_l_bfgs_b
-
-
-def _is_string(var):
-    try:
-        if isinstance(var, basestring):
-            return True
-    except NameError:
-        try:
-            if isinstance(var, str):
-                return True
-        except:
-            return False
-    except:
-        return False
-
-
-
-class Optimizer(object):
-    """
-    Base class for all control pulse optimisers. This class should not be
-    instantiated, use its subclasses.  This class implements the fidelity,
-    gradient and interation callback functions.  All subclass objects must be
-    initialised with a
-
-    - ``OptimConfig`` instance - various configuration options
-    - ``Dynamics`` instance - describes the dynamics of the (quantum) system
-      to be control optimised
-
-    Attributes
-    ----------
-    log_level : integer
-        level of messaging output from the logger.  Options are attributes of
-        qutip.logging_utils, in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution, assuming
-        everything runs as expected.  The default NOTSET implies that the level
-        will be taken from the QuTiP settings file, which by default is WARN.
-
-    params:  Dictionary
-        The key value pairs are the attribute name and value. Note: attributes
-        are created if they do not exist already, and are overwritten if they
-        do.
-
-    alg : string
-        Algorithm to use in pulse optimisation.  Options are:
-
-        - 'GRAPE' (default) - GRadient Ascent Pulse Engineering
-        - 'CRAB' - Chopped RAndom Basis
-
-    alg_params : Dictionary
-        Options that are specific to the pulse optim algorithm ``alg``.
-
-    disp_conv_msg : bool
-        Set true to display a convergence message
-        (for scipy.optimize.minimize methods anyway)
-
-    optim_method : string
-        a scipy.optimize.minimize method that will be used to optimise
-        the pulse for minimum fidelity error
-
-    method_params : Dictionary
-        Options for the optim_method.
-        Note that where there is an equivalent attribute of this instance
-        or the termination_conditions (for example maxiter)
-        it will override an value in these options
-
-    approx_grad : bool
-        If set True then the method will approximate the gradient itself
-        (if it has requirement and facility for this)
-        This will mean that the fid_err_grad_wrapper will not get called
-        Note it should be left False when using the Dynamics
-        to calculate approximate gradients
-        Note it is set True automatically when the alg is CRAB
-
-    amp_lbound : float or list of floats
-        lower boundaries for the control amplitudes
-        Can be a scalar value applied to all controls
-        or a list of bounds for each control
-
-    amp_ubound : float or list of floats
-        upper boundaries for the control amplitudes
-        Can be a scalar value applied to all controls
-        or a list of bounds for each control
-
-    bounds : List of floats
-        Bounds for the parameters.
-        If not set before the run_optimization call then the list
-        is built automatically based on the amp_lbound and amp_ubound
-        attributes.
-        Setting this attribute directly allows specific bounds to be set
-        for individual parameters.
-        Note: Only some methods use bounds
-
-    dynamics : Dynamics (subclass instance)
-        describes the dynamics of the (quantum) system to be control optimised
-        (see Dynamics classes for details)
-
-    config : OptimConfig instance
-        various configuration options
-        (see OptimConfig for details)
-
-    termination_conditions : TerminationCondition instance
-        attributes determine when the optimisation will end
-
-    pulse_generator : PulseGen (subclass instance)
-        (can be) used to create initial pulses
-        not used by the class, but set by pulseoptim.create_pulse_optimizer
-
-    stats : Stats
-        attributes of which give performance stats for the optimisation
-        set to None to reduce overhead of calculating stats.
-        Note it is (usually) shared with the Dynamics instance
-
-    dump : :class:`qutip.control.dump.OptimDump`
-        Container for data dumped during the optimisation.
-        Can be set by specifying the dumping level or set directly.
-        Note this is mainly intended for user and a development debugging
-        but could be used for status information during a long optimisation.
-
-    dumping : string
-        level of data dumping: NONE, SUMMARY, FULL or CUSTOM
-        See property docstring for details
-
-    dump_to_file : bool
-        If set True then data will be dumped to file during the optimisation
-        dumping will be set to SUMMARY during init_optim
-        if dump_to_file is True and dumping not set.
-        Default is False
-
-    dump_dir : string
-        Basically a link to dump.dump_dir. Exists so that it can be set through
-        optim_params.
-        If dump is None then will return None or will set dumping to SUMMARY
-        when setting a path
-
-    iter_summary : :class:`OptimIterSummary`
-        Summary of the most recent iteration.
-        Note this is only set if dummping is on
-    """
-
-    def __init__(self, config, dyn, params=None):
-        self.dynamics = dyn
-        self.config = config
-        self.params = params
-        self.reset()
-        dyn.parent = self
-
-    def reset(self):
-        self.log_level = self.config.log_level
-        self.id_text = 'OPTIM'
-        self.termination_conditions = None
-        self.pulse_generator = None
-        self.disp_conv_msg = False
-        self.iteration_steps = None
-        self.record_iteration_steps = False
-        self.alg = 'GRAPE'
-        self.alg_params = None
-        self.method = 'l_bfgs_b'
-        self.method_params = None
-        self.method_options = None
-        self.approx_grad = False
-        self.amp_lbound = None
-        self.amp_ubound = None
-        self.bounds = None
-        self.num_iter = 0
-        self.num_fid_func_calls = 0
-        self.num_grad_func_calls = 0
-        self.stats = None
-        self.wall_time_optim_start = 0.0
-
-        self.dump_to_file = False
-        self.dump = None
-        self.iter_summary = None
-
-        # AJGP 2015-04-21:
-        # These (copying from config) are here for backward compatibility
-        if hasattr(self.config, 'amp_lbound'):
-            if self.config.amp_lbound:
-                self.amp_lbound = self.config.amp_lbound
-        if hasattr(self.config, 'amp_ubound'):
-            if self.config.amp_ubound:
-                self.amp_ubound = self.config.amp_ubound
-
-        self.apply_params()
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    def apply_params(self, params=None):
-        """
-        Set object attributes based on the dictionary (if any) passed in the
-        instantiation, or passed as a parameter
-        This is called during the instantiation automatically.
-        The key value pairs are the attribute name and value
-        Note: attributes are created if they do not exist already,
-        and are overwritten if they do.
-        """
-        if not params:
-            params = self.params
-
-        if isinstance(params, dict):
-            self.params = params
-            for key in params:
-                setattr(self, key, params[key])
-
-    @property
-    def dumping(self):
-        """
-        The level of data dumping that will occur during the optimisation
-
-        - NONE : No processing data dumped (Default)
-        - SUMMARY : A summary at each iteration will be recorded
-        - FULL : All logs will be generated and dumped
-        - CUSTOM : Some customised level of dumping
-
-        When first set to CUSTOM this is equivalent to SUMMARY. It is then up
-        to the user to specify which logs are dumped
-        """
-        if self.dump is None:
-            lvl = 'NONE'
-        else:
-            lvl = self.dump.level
-
-        return lvl
-
-    @dumping.setter
-    def dumping(self, value):
-        if value is None:
-            self.dump = None
-        else:
-            if not isinstance(value, str):
-                raise TypeError("Value must be string value")
-            lvl = value.upper()
-            if lvl == 'NONE':
-                self.dump = None
-            else:
-                if not isinstance(self.dump, qtrldump.OptimDump):
-                    self.dump = qtrldump.OptimDump(self, level=lvl)
-                else:
-                    self.dump.level = lvl
-
-    @property
-    def dump_dir(self):
-        if self.dump:
-            return self.dump.dump_dir
-        else:
-            return None
-
-    @dump_dir.setter
-    def dump_dir(self, value):
-        if not self.dump:
-            self.dumping = 'SUMMARY'
-        self.dump.dump_dir = value
-
-    def _create_result(self):
-        """
-        create the result object
-        and set the initial_amps attribute as the current amplitudes
-        """
-        result = optimresult.OptimResult()
-        result.initial_fid_err = self.dynamics.fid_computer.get_fid_err()
-        result.initial_amps = self.dynamics.ctrl_amps.copy()
-        result.evo_full_initial = self.dynamics.full_evo.copy()
-        result.time = self.dynamics.time.copy()
-        result.optimizer = self
-        return result
-
-    def init_optim(self, term_conds):
-        """
-        Check optimiser attribute status and passed parameters before
-        running the optimisation.
-        This is called by run_optimization, but could called independently
-        to check the configuration.
-        """
-        if term_conds is not None:
-            self.termination_conditions = term_conds
-        term_conds = self.termination_conditions
-
-        if not isinstance(term_conds, termcond.TerminationConditions):
-            raise errors.UsageError("No termination conditions for the "
-                                    "optimisation function")
-
-        if not isinstance(self.dynamics, dynamics.Dynamics):
-            raise errors.UsageError("No dynamics object attribute set")
-        self.dynamics.check_ctrls_initialized()
-
-        self.apply_method_params()
-
-        if term_conds.fid_err_targ is None and term_conds.fid_goal is None:
-            raise errors.UsageError("Either the goal or the fidelity "
-                                    "error tolerance must be set")
-
-        if term_conds.fid_err_targ is None:
-            term_conds.fid_err_targ = np.abs(1 - term_conds.fid_goal)
-
-        if term_conds.fid_goal is None:
-            term_conds.fid_goal = 1 - term_conds.fid_err_targ
-
-        if self.alg == 'CRAB':
-            self.approx_grad = True
-
-        if self.stats is not None:
-            self.stats.clear()
-
-        if self.dump_to_file:
-            if self.dump is None:
-                self.dumping = 'SUMMARY'
-            self.dump.write_to_file = True
-            self.dump.create_dump_dir()
-            logger.info("Optimiser dump will be written to:\n{}".format(
-                                        self.dump.dump_dir))
-
-        if self.dump:
-            self.iter_summary = OptimIterSummary()
-        else:
-            self.iter_summary = None
-
-        self.num_iter = 0
-        self.num_fid_func_calls = 0
-        self.num_grad_func_calls = 0
-        self.iteration_steps = None
-
-    def _build_method_options(self):
-        """
-        Creates the method_options dictionary for the scipy.optimize.minimize
-        function based on the attributes of this object and the
-        termination_conditions
-        It assumes that apply_method_params has already been run and
-        hence the method_options attribute may already contain items.
-        These values will NOT be overridden
-        """
-        tc = self.termination_conditions
-        if self.method_options is None:
-            self.method_options = {}
-        mo = self.method_options
-
-        if 'max_metric_corr' in mo and 'maxcor' not in mo:
-            mo['maxcor'] = mo['max_metric_corr']
-        elif hasattr(self, 'max_metric_corr') and 'maxcor' not in mo:
-            mo['maxcor'] = self.max_metric_corr
-        if 'accuracy_factor' in mo and 'ftol' not in mo:
-            mo['ftol'] = mo['accuracy_factor']
-        elif hasattr(tc, 'accuracy_factor') and 'ftol' not in mo:
-            mo['ftol'] = tc.accuracy_factor
-        if tc.max_iterations > 0 and 'maxiter' not in mo:
-            mo['maxiter'] = tc.max_iterations
-        if tc.max_fid_func_calls > 0 and 'maxfev' not in mo:
-            mo['maxfev'] = tc.max_fid_func_calls
-        if tc.min_gradient_norm > 0 and 'gtol' not in mo:
-            mo['gtol'] = tc.min_gradient_norm
-        if 'disp' not in mo:
-            mo['disp'] = self.disp_conv_msg
-        return mo
-
-    def apply_method_params(self, params=None):
-        """
-        Loops through all the method_params
-        (either passed here or the method_params attribute)
-        If the name matches an attribute of this object or the
-        termination conditions object, then the value of this attribute
-        is set. Otherwise it is assumed to a method_option for the
-        scipy.optimize.minimize function
-        """
-        if not params:
-            params = self.method_params
-
-        if isinstance(params, dict):
-            self.method_params = params
-            unused_params = {}
-            for key in params:
-                val = params[key]
-                if hasattr(self, key):
-                    setattr(self, key, val)
-                if hasattr(self.termination_conditions, key):
-                    setattr(self.termination_conditions, key, val)
-                else:
-                    unused_params[key] = val
-
-            if len(unused_params) > 0:
-                if not isinstance(self.method_options, dict):
-                    self.method_options = unused_params
-                else:
-                    self.method_options.update(unused_params)
-
-    def _build_bounds_list(self):
-        cfg = self.config
-        dyn = self.dynamics
-        n_ctrls = dyn.num_ctrls
-        self.bounds = []
-        for t in range(dyn.num_tslots):
-            for c in range(n_ctrls):
-                if isinstance(self.amp_lbound, list):
-                    lb = self.amp_lbound[c]
-                else:
-                    lb = self.amp_lbound
-                if isinstance(self.amp_ubound, list):
-                    ub = self.amp_ubound[c]
-                else:
-                    ub = self.amp_ubound
-
-                if lb is not None and np.isinf(lb):
-                    lb = None
-                if ub is not None and np.isinf(ub):
-                    ub = None
-
-                self.bounds.append((lb, ub))
-
-    def run_optimization(self, term_conds=None):
-        """
-        This default function optimisation method is a wrapper to the
-        scipy.optimize.minimize function.
-
-        It will attempt to minimise the fidelity error with respect to some
-        parameters, which are determined by _get_optim_var_vals (see below)
-
-        The optimisation end when one of the passed termination conditions
-        has been met, e.g. target achieved, wall time, or
-        function call or iteration count exceeded. Note these
-        conditions include gradient minimum met (local minima) for
-        methods that use a gradient.
-
-        The function minimisation method is taken from the optim_method
-        attribute. Note that not all of these methods have been tested.
-        Note that some of these use a gradient and some do not.
-        See the scipy documentation for details. Options specific to the
-        method can be passed setting the method_params attribute.
-
-        If the parameter term_conds=None, then the termination_conditions
-        attribute must already be set. It will be overwritten if the
-        parameter is not None
-
-        The result is returned in an OptimResult object, which includes
-        the final fidelity, time evolution, reason for termination etc
-        """
-        self.init_optim(term_conds)
-        term_conds = self.termination_conditions
-        dyn = self.dynamics
-        cfg = self.config
-        self.optim_var_vals = self._get_optim_var_vals()
-        st_time = timeit.default_timer()
-        self.wall_time_optimize_start = st_time
-
-        if self.stats is not None:
-            self.stats.wall_time_optim_start = st_time
-            self.stats.wall_time_optim_end = 0.0
-            self.stats.num_iter = 0
-
-        if self.bounds is None:
-            self._build_bounds_list()
-
-        self._build_method_options()
-
-        result = self._create_result()
-
-        if self.approx_grad:
-            jac = None
-        else:
-            jac = self.fid_err_grad_wrapper
-
-        if self.log_level <= logging.INFO:
-            msg = ("Optimising pulse(s) using {} with "
-                   "minimise '{}' method").format(self.alg, self.method)
-            if self.approx_grad:
-                msg += " (approx grad)"
-            logger.info(msg)
-
-        try:
-            opt_res = spopt.minimize(
-                self.fid_err_func_wrapper, self.optim_var_vals,
-                method=self.method,
-                jac=jac,
-                bounds=self.bounds,
-                options=self.method_options,
-                callback=self.iter_step_callback_func)
-
-            amps = self._get_ctrl_amps(opt_res.x)
-            dyn.update_ctrl_amps(amps)
-            result.termination_reason = opt_res.message
-            # Note the iterations are counted in this object as well
-            # so there are compared here for interest sake only
-            if self.num_iter != opt_res.nit:
-                logger.info("The number of iterations counted {} "
-                            " does not match the number reported {} "
-                            "by {}".format(self.num_iter, opt_res.nit,
-                                           self.method))
-            result.num_iter = opt_res.nit
-
-        except errors.OptimizationTerminate as except_term:
-            self._interpret_term_exception(except_term, result)
-
-        end_time = timeit.default_timer()
-        self._add_common_result_attribs(result, st_time, end_time)
-
-        return result
-
-    def _get_optim_var_vals(self):
-        """
-        Generate the 1d array that holds the current variable values
-        of the function to be optimised
-        By default (as used in GRAPE) these are the control amplitudes
-        in each timeslot
-        """
-        return self.dynamics.ctrl_amps.reshape([-1])
-
-    def _get_ctrl_amps(self, optim_var_vals):
-        """
-        Get the control amplitudes from the current variable values
-        of the function to be optimised.
-        that is the 1d array that is passed from the optimisation method
-        Note for GRAPE these are the function optimiser parameters
-        (and this is the default)
-
-        Returns
-        -------
-        float array[dynamics.num_tslots, dynamics.num_ctrls]
-        """
-        amps = optim_var_vals.reshape(self.dynamics.ctrl_amps.shape)
-
-        return amps
-
-    def fid_err_func_wrapper(self, *args):
-        """
-        Get the fidelity error achieved using the ctrl amplitudes passed
-        in as the first argument.
-
-        This is called by generic optimisation algorithm as the
-        func to the minimised. The argument is the current
-        variable values, i.e. control amplitudes, passed as
-        a flat array. Hence these are reshaped as [nTimeslots, n_ctrls]
-        and then used to update the stored ctrl values (if they have changed)
-
-        The error is checked against the target, and the optimisation is
-        terminated if the target has been achieved.
-        """
-        self.num_fid_func_calls += 1
-        # *** update stats ***
-        if self.stats is not None:
-            self.stats.num_fidelity_func_calls = self.num_fid_func_calls
-            if self.log_level <= logging.DEBUG:
-                logger.debug("fidelity error call {}".format(
-                    self.stats.num_fidelity_func_calls))
-
-        amps = self._get_ctrl_amps(args[0].copy())
-        self.dynamics.update_ctrl_amps(amps)
-
-        tc = self.termination_conditions
-        err = self.dynamics.fid_computer.get_fid_err()
-
-        if self.iter_summary:
-            self.iter_summary.fid_func_call_num = self.num_fid_func_calls
-            self.iter_summary.fid_err = err
-
-        if self.dump and self.dump.dump_fid_err:
-            self.dump.update_fid_err_log(err)
-
-        if err <= tc.fid_err_targ:
-            raise errors.GoalAchievedTerminate(err)
-
-        if self.num_fid_func_calls > tc.max_fid_func_calls:
-            raise errors.MaxFidFuncCallTerminate()
-
-        return err
-
-    def fid_err_grad_wrapper(self, *args):
-        """
-        Get the gradient of the fidelity error with respect to all of the
-        variables, i.e. the ctrl amplidutes in each timeslot
-
-        This is called by generic optimisation algorithm as the gradients of
-        func to the minimised wrt the variables. The argument is the current
-        variable values, i.e. control amplitudes, passed as
-        a flat array. Hence these are reshaped as [nTimeslots, n_ctrls]
-        and then used to update the stored ctrl values (if they have changed)
-
-        Although the optimisation algorithms have a check within them for
-        function convergence, i.e. local minima, the sum of the squares
-        of the normalised gradient is checked explicitly, and the
-        optimisation is terminated if this is below the min_gradient_norm
-        condition
-        """
-        # *** update stats ***
-        self.num_grad_func_calls += 1
-        if self.stats is not None:
-            self.stats.num_grad_func_calls = self.num_grad_func_calls
-            if self.log_level <= logging.DEBUG:
-                logger.debug("gradient call {}".format(
-                    self.stats.num_grad_func_calls))
-        amps = self._get_ctrl_amps(args[0].copy())
-        self.dynamics.update_ctrl_amps(amps)
-        fid_comp = self.dynamics.fid_computer
-        # gradient_norm_func is a pointer to the function set in the config
-        # that returns the normalised gradients
-        grad = fid_comp.get_fid_err_gradient()
-
-        if self.iter_summary:
-            self.iter_summary.grad_func_call_num = self.num_grad_func_calls
-            self.iter_summary.grad_norm = fid_comp.grad_norm
-
-        if self.dump:
-            if self.dump.dump_grad_norm:
-                self.dump.update_grad_norm_log(fid_comp.grad_norm)
-
-            if self.dump.dump_grad:
-                self.dump.update_grad_log(grad)
-
-        tc = self.termination_conditions
-        if fid_comp.grad_norm < tc.min_gradient_norm:
-            raise errors.GradMinReachedTerminate(fid_comp.grad_norm)
-        return grad.flatten()
-
-    def iter_step_callback_func(self, *args):
-        """
-        Check the elapsed wall time for the optimisation run so far.
-        Terminate if this has exceeded the maximum allowed time
-        """
-        self.num_iter += 1
-
-        if self.log_level <= logging.DEBUG:
-            logger.debug("Iteration callback {}".format(self.num_iter))
-
-        wall_time = timeit.default_timer() - self.wall_time_optimize_start
-
-        if self.iter_summary:
-            self.iter_summary.iter_num = self.num_iter
-            self.iter_summary.wall_time = wall_time
-
-        if self.dump and self.dump.dump_summary:
-            self.dump.add_iter_summary()
-
-        tc = self.termination_conditions
-
-        if wall_time > tc.max_wall_time:
-            raise errors.MaxWallTimeTerminate()
-
-        # *** update stats ***
-        if self.stats is not None:
-            self.stats.num_iter = self.num_iter
-
-    def _interpret_term_exception(self, except_term, result):
-        """
-        Update the result object based on the exception that occurred
-        during the optimisation
-        """
-        result.termination_reason = except_term.reason
-        if isinstance(except_term, errors.GoalAchievedTerminate):
-            result.goal_achieved = True
-        elif isinstance(except_term, errors.MaxWallTimeTerminate):
-            result.wall_time_limit_exceeded = True
-        elif isinstance(except_term, errors.GradMinReachedTerminate):
-            result.grad_norm_min_reached = True
-        elif isinstance(except_term, errors.MaxFidFuncCallTerminate):
-            result.max_fid_func_exceeded = True
-
-    def _add_common_result_attribs(self, result, st_time, end_time):
-        """
-        Update the result object attributes which are common to all
-        optimisers and outcomes
-        """
-        dyn = self.dynamics
-        result.num_iter = self.num_iter
-        result.num_fid_func_calls = self.num_fid_func_calls
-        result.wall_time = end_time - st_time
-        result.fid_err = dyn.fid_computer.get_fid_err()
-        result.grad_norm_final = dyn.fid_computer.grad_norm
-        result.final_amps = dyn.ctrl_amps
-        final_evo = dyn.full_evo
-        if isinstance(final_evo, Qobj):
-            result.evo_full_final = final_evo
-        else:
-            result.evo_full_final = Qobj(final_evo, dims=dyn.sys_dims)
-        # *** update stats ***
-        if self.stats is not None:
-            self.stats.wall_time_optim_end = end_time
-            self.stats.calculate()
-            result.stats = copy.copy(self.stats)
-
-
-class OptimizerBFGS(Optimizer):
-    """
-    Implements the run_optimization method using the BFGS algorithm
-    """
-    def reset(self):
-        Optimizer.reset(self)
-        self.id_text = 'BFGS'
-
-    def run_optimization(self, term_conds=None):
-        """
-        Optimise the control pulse amplitudes to minimise the fidelity error
-        using the BFGS (Broyden–Fletcher–Goldfarb–Shanno) algorithm
-        The optimisation end when one of the passed termination conditions
-        has been met, e.g. target achieved, gradient minimum met
-        (local minima), wall time / iteration count exceeded.
-
-        Essentially this is wrapper to the:
-        scipy.optimize.fmin_bfgs
-        function
-
-        If the parameter term_conds=None, then the termination_conditions
-        attribute must already be set. It will be overwritten if the
-        parameter is not None
-
-        The result is returned in an OptimResult object, which includes
-        the final fidelity, time evolution, reason for termination etc
-        """
-        self.init_optim(term_conds)
-        term_conds = self.termination_conditions
-        dyn = self.dynamics
-        self.optim_var_vals = self._get_optim_var_vals()
-        self._build_method_options()
-
-        st_time = timeit.default_timer()
-        self.wall_time_optimize_start = st_time
-
-        if self.stats is not None:
-            self.stats.wall_time_optim_start = st_time
-            self.stats.wall_time_optim_end = 0.0
-            self.stats.num_iter = 1
-
-        if self.approx_grad:
-            fprime = None
-        else:
-            fprime = self.fid_err_grad_wrapper
-
-        if self.log_level <= logging.INFO:
-            msg = ("Optimising pulse(s) using {} with "
-                   "'fmin_bfgs' method").format(self.alg)
-            if self.approx_grad:
-                msg += " (approx grad)"
-            logger.info(msg)
-
-        result = self._create_result()
-        try:
-            optim_var_vals, cost, grad, invHess, nFCalls, nGCalls, warn = \
-                spopt.fmin_bfgs(self.fid_err_func_wrapper,
-                                self.optim_var_vals,
-                                fprime=fprime,
-                                callback=self.iter_step_callback_func,
-                                gtol=term_conds.min_gradient_norm,
-                                maxiter=term_conds.max_iterations,
-                                full_output=True, disp=True)
-
-            amps = self._get_ctrl_amps(optim_var_vals)
-            dyn.update_ctrl_amps(amps)
-            if warn == 1:
-                result.max_iter_exceeded = True
-                result.termination_reason = "Iteration count limit reached"
-            elif warn == 2:
-                result.grad_norm_min_reached = True
-                result.termination_reason = "Gradient normal minimum reached"
-
-        except errors.OptimizationTerminate as except_term:
-            self._interpret_term_exception(except_term, result)
-
-        end_time = timeit.default_timer()
-        self._add_common_result_attribs(result, st_time, end_time)
-
-        return result
-
-
-class OptimizerLBFGSB(Optimizer):
-    """
-    Implements the run_optimization method using the L-BFGS-B algorithm
-
-    Attributes
-    ----------
-    max_metric_corr : integer
-        The maximum number of variable metric corrections used to define
-        the limited memory matrix. That is the number of previous
-        gradient values that are used to approximate the Hessian
-        see the scipy.optimize.fmin_l_bfgs_b documentation for description
-        of m argument
-    """
-
-    def reset(self):
-        Optimizer.reset(self)
-        self.id_text = 'LBFGSB'
-        self.max_metric_corr = 10
-        self.msg_level = None
-
-    def init_optim(self, term_conds):
-        """
-        Check optimiser attribute status and passed parameters before
-        running the optimisation.
-        This is called by run_optimization, but could called independently
-        to check the configuration.
-        """
-        if term_conds is None:
-            term_conds = self.termination_conditions
-
-        # AJGP 2015-04-21:
-        # These (copying from config) are here for backward compatibility
-        if hasattr(self.config, 'max_metric_corr'):
-            if self.config.max_metric_corr:
-                self.max_metric_corr = self.config.max_metric_corr
-        if hasattr(self.config, 'accuracy_factor'):
-            if self.config.accuracy_factor:
-                term_conds.accuracy_factor = self.config.accuracy_factor
-
-        Optimizer.init_optim(self, term_conds)
-
-        if not isinstance(self.msg_level, int):
-            if self.log_level < logging.DEBUG:
-                self.msg_level = 2
-            elif self.log_level <= logging.DEBUG:
-                self.msg_level = 1
-            else:
-                self.msg_level = 0
-
-    def run_optimization(self, term_conds=None):
-        """
-        Optimise the control pulse amplitudes to minimise the fidelity error
-        using the L-BFGS-B algorithm, which is the constrained
-        (bounded amplitude values), limited memory, version of the
-        Broyden–Fletcher–Goldfarb–Shanno algorithm.
-
-        The optimisation end when one of the passed termination conditions
-        has been met, e.g. target achieved, gradient minimum met
-        (local minima), wall time / iteration count exceeded.
-
-        Essentially this is wrapper to the:
-        scipy.optimize.fmin_l_bfgs_b function
-        This in turn is a warpper for well established implementation of
-        the L-BFGS-B algorithm written in Fortran, which is therefore
-        very fast. See SciPy documentation for credit and details on
-        this function.
-
-        If the parameter term_conds=None, then the termination_conditions
-        attribute must already be set. It will be overwritten if the
-        parameter is not None
-
-        The result is returned in an OptimResult object, which includes
-        the final fidelity, time evolution, reason for termination etc
-        """
-        self.init_optim(term_conds)
-        term_conds = self.termination_conditions
-        dyn = self.dynamics
-        cfg = self.config
-        self.optim_var_vals = self._get_optim_var_vals()
-        self._build_method_options()
-
-        st_time = timeit.default_timer()
-        self.wall_time_optimize_start = st_time
-
-        if self.stats is not None:
-            self.stats.wall_time_optim_start = st_time
-            self.stats.wall_time_optim_end = 0.0
-            self.stats.num_iter = 1
-
-        bounds = self._build_bounds_list()
-        result = self._create_result()
-
-        if self.approx_grad:
-            fprime = None
-        else:
-            fprime = self.fid_err_grad_wrapper
-
-        if 'accuracy_factor' in self.method_options:
-            factr = self.method_options['accuracy_factor']
-        elif 'ftol' in self.method_options:
-            factr = self.method_options['ftol']
-        elif hasattr(term_conds, 'accuracy_factor'):
-            factr = term_conds.accuracy_factor
-        else:
-            factr = 1e7
-
-        if 'max_metric_corr' in self.method_options:
-            m = self.method_options['max_metric_corr']
-        elif 'maxcor' in self.method_options:
-            m = self.method_options['maxcor']
-        elif hasattr(self, 'max_metric_corr'):
-            m = self.max_metric_corr
-        else:
-            m = 10
-
-        if self.log_level <= logging.INFO:
-            msg = ("Optimising pulse(s) using {} with "
-                   "'fmin_l_bfgs_b' method").format(self.alg)
-            if self.approx_grad:
-                msg += " (approx grad)"
-            logger.info(msg)
-        try:
-            optim_var_vals, fid, res_dict = fmin_l_bfgs_b(
-                self.fid_err_func_wrapper, self.optim_var_vals,
-                fprime=fprime,
-                approx_grad=self.approx_grad,
-                callback=self.iter_step_callback_func,
-                bounds=self.bounds, m=m, factr=factr,
-                pgtol=term_conds.min_gradient_norm,
-                disp=self.msg_level,
-                maxfun=term_conds.max_fid_func_calls,
-                maxiter=term_conds.max_iterations)
-
-            amps = self._get_ctrl_amps(optim_var_vals)
-            dyn.update_ctrl_amps(amps)
-            warn = res_dict['warnflag']
-            if warn == 0:
-                result.grad_norm_min_reached = True
-                result.termination_reason = "function converged"
-            elif warn == 1:
-                result.max_iter_exceeded = True
-                result.termination_reason = ("Iteration or fidelity "
-                                             "function call limit reached")
-            elif warn == 2:
-                result.termination_reason = res_dict['task']
-
-            result.num_iter = res_dict['nit']
-        except errors.OptimizationTerminate as except_term:
-            self._interpret_term_exception(except_term, result)
-
-        end_time = timeit.default_timer()
-        self._add_common_result_attribs(result, st_time, end_time)
-
-        return result
-
-
-class OptimizerCrab(Optimizer):
-    """
-    Optimises the pulse using the CRAB algorithm [1].
-    It uses the scipy.optimize.minimize function with the method specified
-    by the optim_method attribute. See Optimizer.run_optimization for details
-    It minimises the fidelity error function with respect to the CRAB
-    basis function coefficients.
-
-    AJGP ToDo: Add citation here
-    """
-
-    def reset(self):
-        Optimizer.reset(self)
-        self.id_text = 'CRAB'
-        self.num_optim_vars = 0
-
-    def init_optim(self, term_conds):
-        """
-        Check optimiser attribute status and passed parameters before
-        running the optimisation.
-        This is called by run_optimization, but could called independently
-        to check the configuration.
-        """
-        Optimizer.init_optim(self, term_conds)
-        dyn = self.dynamics
-
-        self.num_optim_vars = 0
-        pulse_gen_valid = True
-        # check the pulse generators match the ctrls
-        # (in terms of number)
-        # and count the number of parameters
-        if self.pulse_generator is None:
-            pulse_gen_valid = False
-            err_msg = "pulse_generator attribute is None"
-        elif not isinstance(self.pulse_generator, collections.abc.Iterable):
-            pulse_gen_valid = False
-            err_msg = "pulse_generator is not iterable"
-
-        elif len(self.pulse_generator) != dyn.num_ctrls:
-            pulse_gen_valid = False
-            err_msg = ("the number of pulse generators {} does not equal "
-                       "the number of controls {}".format(
-                           len(self.pulse_generator), dyn.num_ctrls))
-
-        if pulse_gen_valid:
-            for p_gen in self.pulse_generator:
-                if not isinstance(p_gen, pulsegen.PulseGenCrab):
-                    pulse_gen_valid = False
-                    err_msg =\
-                        "pulse_generator contained object of type '{}'".format(
-                            p_gen.__class__.__name__)
-                    break
-                self.num_optim_vars += p_gen.num_optim_vars
-
-        if not pulse_gen_valid:
-            raise errors.UsageError(
-                "The pulse_generator attribute must be set to a list of "
-                "PulseGenCrab - one for each control. Here " + err_msg)
-
-    def _build_bounds_list(self):
-        """
-        No bounds necessary here, as the bounds for the CRAB parameters
-        do not have much physical meaning.
-        This needs to override the default method, otherwise the shape
-        will be wrong
-        """
-        return None
-
-    def _get_optim_var_vals(self):
-        """
-        Generate the 1d array that holds the current variable values
-        of the function to be optimised
-        For CRAB these are the basis coefficients
-
-        Returns
-        -------
-        ndarray (1d) of float
-        """
-        pvals = []
-        for pgen in self.pulse_generator:
-            pvals.extend(pgen.get_optim_var_vals())
-
-        return np.array(pvals)
-
-    def _get_ctrl_amps(self, optim_var_vals):
-        """
-        Get the control amplitudes from the current variable values
-        of the function to be optimised.
-        that is the 1d array that is passed from the optimisation method
-        For CRAB the amplitudes will need to calculated by expanding the
-        series
-
-        Returns
-        -------
-        float array[dynamics.num_tslots, dynamics.num_ctrls]
-        """
-        dyn = self.dynamics
-
-        if self.log_level <= logging.DEBUG:
-            changed_params = self.optim_var_vals != optim_var_vals
-            logger.debug(
-                "{} out of {} optimisation parameters changed".format(
-                    changed_params.sum(), len(optim_var_vals)))
-
-        amps = np.empty([dyn.num_tslots, dyn.num_ctrls])
-        j = 0
-        param_idx_st = 0
-        for p_gen in self.pulse_generator:
-            param_idx_end = param_idx_st + p_gen.num_optim_vars
-            pg_pvals = optim_var_vals[param_idx_st:param_idx_end]
-            p_gen.set_optim_var_vals(pg_pvals)
-            amps[:, j] = p_gen.gen_pulse()
-            param_idx_st = param_idx_end
-            j += 1
-
-        self.optim_var_vals = optim_var_vals
-        return amps
-
-
-class OptimizerCrabFmin(OptimizerCrab):
-    """
-    Optimises the pulse using the CRAB algorithm [1]_, [2]_.
-    It uses the ``scipy.optimize.fmin`` function which is effectively a wrapper
-    for the Nelder-Mead method.  It minimises the fidelity error function with
-    respect to the CRAB basis function coefficients.  This is the default
-    Optimizer for CRAB.
-
-    References
-    ----------
-    .. [1] P. Doria, T. Calarco & S. Montangero. Phys. Rev. Lett. 106, 190501
-       (2011).
-    .. [2] T. Caneva, T. Calarco, & S. Montangero. Phys. Rev. A 84, 022326
-       (2011).
-    """
-
-    def reset(self):
-        OptimizerCrab.reset(self)
-        self.id_text = 'CRAB_FMIN'
-        self.xtol = 1e-4
-        self.ftol = 1e-4
-
-    def run_optimization(self, term_conds=None):
-        """
-        This function optimisation method is a wrapper to the
-        scipy.optimize.fmin function.
-
-        It will attempt to minimise the fidelity error with respect to some
-        parameters, which are determined by _get_optim_var_vals which
-        in the case of CRAB are the basis function coefficients
-
-        The optimisation end when one of the passed termination conditions
-        has been met, e.g. target achieved, wall time, or
-        function call or iteration count exceeded. Specifically to the fmin
-        method, the optimisation will stop when change parameter values
-        is less than xtol or the change in function value is below ftol.
-
-        If the parameter term_conds=None, then the termination_conditions
-        attribute must already be set. It will be overwritten if the
-        parameter is not None
-
-        The result is returned in an OptimResult object, which includes
-        the final fidelity, time evolution, reason for termination etc
-        """
-        self.init_optim(term_conds)
-        term_conds = self.termination_conditions
-        dyn = self.dynamics
-        cfg = self.config
-        self.optim_var_vals = self._get_optim_var_vals()
-        self._build_method_options()
-
-        st_time = timeit.default_timer()
-        self.wall_time_optimize_start = st_time
-
-        if self.stats is not None:
-            self.stats.wall_time_optim_start = st_time
-            self.stats.wall_time_optim_end = 0.0
-            self.stats.num_iter = 1
-
-        result = self._create_result()
-
-        if self.log_level <= logging.INFO:
-            logger.info("Optimising pulse(s) using {} with "
-                        "'fmin' (Nelder-Mead) method".format(self.alg))
-
-        try:
-            ret = spopt.fmin(
-                    self.fid_err_func_wrapper, self.optim_var_vals,
-                    xtol=self.xtol, ftol=self.ftol,
-                    maxiter=term_conds.max_iterations,
-                    maxfun=term_conds.max_fid_func_calls,
-                    full_output=True, disp=self.disp_conv_msg,
-                    retall=self.record_iteration_steps,
-                    callback=self.iter_step_callback_func)
-
-            final_param_vals = ret[0]
-            num_iter = ret[2]
-            warn_flag = ret[4]
-            if self.record_iteration_steps:
-                self.iteration_steps = ret[5]
-            amps = self._get_ctrl_amps(final_param_vals)
-            dyn.update_ctrl_amps(amps)
-
-            # Note the iterations are counted in this object as well
-            # so there are compared here for interest sake only
-            if self.num_iter != num_iter:
-                logger.info("The number of iterations counted {} "
-                            " does not match the number reported {} "
-                            "by {}".format(self.num_iter, num_iter,
-                                           self.method))
-            result.num_iter = num_iter
-            if warn_flag == 0:
-                result.termination_reason = \
-                    "Function converged (within tolerance)"
-            elif warn_flag == 1:
-                result.termination_reason = \
-                    "Maximum number of function evaluations reached"
-                result.max_fid_func_exceeded = True
-            elif warn_flag == 2:
-                result.termination_reason = \
-                    "Maximum number of iterations reached"
-                result.max_iter_exceeded = True
-            else:
-                result.termination_reason = \
-                    "Unknown (warn_flag={})".format(warn_flag)
-
-        except errors.OptimizationTerminate as except_term:
-            self._interpret_term_exception(except_term, result)
-
-        end_time = timeit.default_timer()
-        self._add_common_result_attribs(result, st_time, end_time)
-
-        return result
-
-
-class OptimIterSummary(qtrldump.DumpSummaryItem):
-    """
-    A summary of the most recent iteration of the pulse optimisation
-
-    Attributes
-    ----------
-    iter_num : int
-        Iteration number of the pulse optimisation
-
-    fid_func_call_num : int
-        Fidelity function call number of the pulse optimisation
-
-    grad_func_call_num : int
-        Gradient function call number of the pulse optimisation
-
-    fid_err : float
-        Fidelity error
-
-    grad_norm : float
-        fidelity gradient (wrt the control parameters) vector norm
-        that is the magnitude of the gradient
-
-    wall_time : float
-        Time spent computing the pulse optimisation so far
-        (in seconds of elapsed time)
-    """
-    # Note there is some duplication here with Optimizer attributes
-    # this exists solely to be copied into the summary dump
-    min_col_width = 11
-    summary_property_names = (
-        "idx", "iter_num", "fid_func_call_num", "grad_func_call_num",
-        "fid_err", "grad_norm", "wall_time"
-        )
-
-    summary_property_fmt_type = (
-        'd', 'd', 'd', 'd',
-        'g', 'g', 'g'
-        )
-
-    summary_property_fmt_prec = (
-        0, 0, 0, 0,
-        4, 4, 2
-        )
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        qtrldump.DumpSummaryItem.reset(self)
-        self.iter_num = None
-        self.fid_func_call_num = None
-        self.grad_func_call_num = None
-        self.fid_err = None
-        self.grad_norm = None
-        self.wall_time = 0.0
diff --git a/qutip/control/optimresult.py b/qutip/control/optimresult.py
deleted file mode 100644
index 35cc6bc7e4..0000000000
--- a/qutip/control/optimresult.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Class containing the results of the pulse optimisation
-"""
-
-import numpy as np
-
-
-class OptimResult(object):
-    """
-    Attributes give the result of the pulse optimisation attempt
-
-    Attributes
-    ----------
-    termination_reason : string
-        Description of the reason for terminating the optimisation
-
-    fidelity : float
-        final (normalised) fidelity that was achieved
-
-    initial_fid_err : float
-        fidelity error before optimisation starting
-
-    fid_err : float
-        final fidelity error that was achieved
-
-    goal_achieved : boolean
-        True is the fidely error achieved was below the target
-
-    grad_norm_final : float
-        Final value of the sum of the squares of the (normalised) fidelity
-        error gradients
-
-    grad_norm_min_reached : float
-        True if the optimisation terminated due to the minimum value
-        of the gradient being reached
-
-    num_iter : integer
-        Number of iterations of the optimisation algorithm completed
-
-    max_iter_exceeded : boolean
-        True if the iteration limit was reached
-
-    max_fid_func_exceeded : boolean
-        True if the fidelity function call limit was reached
-
-    wall_time : float
-        time elapsed during the optimisation
-
-    wall_time_limit_exceeded  : boolean
-        True if the wall time limit was reached
-
-    time : array[num_tslots+1] of float
-        Time are the start of each timeslot
-        with the final value being the total evolution time
-
-    initial_amps : array[num_tslots, n_ctrls]
-        The amplitudes at the start of the optimisation
-
-    final_amps : array[num_tslots, n_ctrls]
-        The amplitudes at the end of the optimisation
-
-    evo_full_final : Qobj
-        The evolution operator from t=0 to t=T based on the final amps
-
-    evo_full_initial : Qobj
-        The evolution operator from t=0 to t=T based on the initial amps
-
-    stats : Stats
-        Object contaning the stats for the run (if any collected)
-
-    optimizer : Optimizer
-        Instance of the Optimizer used to generate the result
-    """
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.fidelity = 0.0
-        self.initial_fid_err = np.Inf
-        self.fid_err = np.Inf
-        self.goal_achieved = False
-        self.grad_norm_final = 0.0
-        self.grad_norm_min_reached = False
-        self.num_iter = 0
-        self.max_iter_exceeded = False
-        self.num_fid_func_calls = 0
-        self.max_fid_func_exceeded = False
-        self.wall_time = 0.0
-        self.wall_time_limit_exceeded = False
-        self.termination_reason = "not started yet"
-        self.time = None
-        self.initial_amps = None
-        self.final_amps = None
-        self.evo_full_final = None
-        self.evo_full_initial = None
-        self.stats = None
-        self.optimizer = None
diff --git a/qutip/control/propcomp.py b/qutip/control/propcomp.py
deleted file mode 100644
index aee23b4030..0000000000
--- a/qutip/control/propcomp.py
+++ /dev/null
@@ -1,405 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Propagator Computer
-Classes used to calculate the propagators,
-and also the propagator gradient when exact gradient methods are used
-
-Note the methods in the _Diag class was inspired by:
-DYNAMO - Dynamic Framework for Quantum Optimal Control
-See Machnes et.al., arXiv.1011.4874
-"""
-
-import warnings
-import numpy as np
-import scipy.linalg as la
-import scipy.sparse as sp
-# QuTiP
-from qutip import Qobj
-# QuTiP control modules
-from qutip.control import errors
-# QuTiP logging
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-
-def _func_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-class PropagatorComputer:
-    """
-    Base for all  Propagator Computer classes
-    that are used to calculate the propagators,
-    and also the propagator gradient when exact gradient methods are used
-    Note: they must be instantiated with a Dynamics object, that is the
-    container for the data that the functions operate on
-    This base class cannot be used directly. See subclass descriptions
-    and choose the appropriate one for the application
-
-    Attributes
-    ----------
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip_utils.logging,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-
-    grad_exact : boolean
-        indicates whether the computer class instance is capable
-        of computing propagator gradients. It is used to determine
-        whether to create the Dynamics prop_grad array
-    """
-    def __init__(self, dynamics, params=None):
-        self.parent = dynamics
-        self.params = params
-        self.reset()
-
-    def reset(self):
-        """
-        reset any configuration data
-        """
-        self.id_text = 'PROP_COMP_BASE'
-        self.log_level = self.parent.log_level
-        self._grad_exact = False
-
-    def apply_params(self, params=None):
-        """
-        Set object attributes based on the dictionary (if any) passed in the
-        instantiation, or passed as a parameter
-        This is called during the instantiation automatically.
-        The key value pairs are the attribute name and value
-        Note: attributes are created if they do not exist already,
-        and are overwritten if they do.
-        """
-        if not params:
-            params = self.params
-
-        if isinstance(params, dict):
-            self.params = params
-            for key in params:
-                setattr(self, key, params[key])
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    def grad_exact(self):
-        return self._grad_exact
-
-    def compute_propagator(self, k):
-        _func_deprecation("'compute_propagator' has been replaced "
-                          "by '_compute_propagator'")
-        return self._compute_propagator(k)
-
-    def _compute_propagator(self, k):
-        """
-        calculate the progator between X(k) and X(k+1)
-        Uses matrix expm of the dyn_gen at that point (in time)
-        Assumes that the dyn_gen have been been calculated,
-        i.e. drift and ctrls combined
-        Return the propagator
-        """
-        dyn = self.parent
-        dgt = dyn._get_phased_dyn_gen(k)*dyn.tau[k]
-        if dyn.oper_dtype == Qobj:
-            prop = dgt.expm()
-        else:
-            prop = la.expm(dgt)
-        return prop
-
-    def compute_diff_prop(self, k, j, epsilon):
-        _func_deprecation("'compute_diff_prop' has been replaced "
-                          "by '_compute_diff_prop'")
-        return self._compute_diff_prop(k, j, epsilon)
-
-    def _compute_diff_prop(self, k, j, epsilon):
-        """
-        Calculate the propagator from the current point to a trial point
-        a distance 'epsilon' (change in amplitude)
-        in the direction the given control j in timeslot k
-        Returns the propagator
-        """
-        raise errors.UsageError("Not implemented in the baseclass."
-                                " Choose a subclass")
-
-    def compute_prop_grad(self, k, j, compute_prop=True):
-        _func_deprecation("'compute_prop_grad' has been replaced "
-                          "by '_compute_prop_grad'")
-        return self._compute_prop_grad(self, k, j, compute_prop=compute_prop)
-
-    def _compute_prop_grad(self, k, j, compute_prop=True):
-        """
-        Calculate the gradient of propagator wrt the control amplitude
-        in the timeslot.
-        """
-        raise errors.UsageError("Not implemented in the baseclass."
-                                " Choose a subclass")
-
-
-class PropCompApproxGrad(PropagatorComputer):
-    """
-    This subclass can be used when the propagator is calculated simply
-    by expm of the dynamics generator, i.e. when gradients will be calculated
-    using approximate methods.
-    """
-
-    def reset(self):
-        """
-        reset any configuration data
-        """
-        PropagatorComputer.reset(self)
-        self.id_text = 'APPROX'
-        self.grad_exact = False
-        self.apply_params()
-
-    def _compute_diff_prop(self, k, j, epsilon):
-        """
-        Calculate the propagator from the current point to a trial point
-        a distance 'epsilon' (change in amplitude)
-        in the direction the given control j in timeslot k
-        Returns the propagator
-        """
-        dyn = self.parent
-        dgt_eps = dyn.tau[k] * (
-            dyn._get_phased_dyn_gen(k)
-            + epsilon*dyn._get_phased_ctrl_dyn_gen(k, j)
-        )
-
-        if dyn.oper_dtype == Qobj:
-            prop_eps = dgt_eps.expm()
-        else:
-            prop_eps = la.expm(dgt_eps)
-
-        return prop_eps
-
-
-class PropCompDiag(PropagatorComputer):
-    """
-    Coumputes the propagator exponentiation using diagonalisation of
-    of the dynamics generator
-    """
-    def reset(self):
-        """
-        reset any configuration data
-        """
-        PropagatorComputer.reset(self)
-        self.id_text = 'DIAG'
-        self.grad_exact = True
-        self.apply_params()
-
-    def _compute_propagator(self, k):
-        """
-        Calculates the exponentiation of the dynamics generator (H)
-        As part of the calc the the eigen decomposition is required, which
-        is reused in the propagator gradient calculation
-        """
-        dyn = self.parent
-        dyn._ensure_decomp_curr(k)
-
-        if dyn.oper_dtype == Qobj:
-            prop = (
-                dyn._dyn_gen_eigenvectors[k]
-                * dyn._prop_eigen[k]
-                * dyn._get_dyn_gen_eigenvectors_adj(k)
-            )
-        else:
-            prop = (
-                dyn._dyn_gen_eigenvectors[k]
-                .dot(dyn._prop_eigen[k])
-                .dot(dyn._get_dyn_gen_eigenvectors_adj(k))
-            )
-
-        return prop
-
-    def _compute_prop_grad(self, k, j, compute_prop=True):
-        """
-        Calculate the gradient of propagator wrt the control amplitude
-        in the timeslot.
-
-        Returns:
-            [prop], prop_grad
-        """
-        dyn = self.parent
-        dyn._ensure_decomp_curr(k)
-
-        if compute_prop:
-            prop = self._compute_propagator(k)
-
-        if dyn.oper_dtype == Qobj:
-            # put control dyn_gen in combined dg diagonal basis
-            cdg =  (
-                dyn._get_dyn_gen_eigenvectors_adj(k)
-                * dyn._get_phased_ctrl_dyn_gen(k, j)
-                * dyn._dyn_gen_eigenvectors[k])
-            # multiply (elementwise) by timeslice and factor matrix
-            cdg = Qobj(np.multiply(cdg.full()*dyn.tau[k],
-                                   dyn._dyn_gen_factormatrix[k]),
-                       dims=dyn.dyn_dims)
-            # Return to canonical basis
-            prop_grad = (
-                dyn._dyn_gen_eigenvectors[k] * cdg
-                * dyn._get_dyn_gen_eigenvectors_adj(k))
-        else:
-            # put control dyn_gen in combined dg diagonal basis
-            cdg = (
-                dyn._get_dyn_gen_eigenvectors_adj(k)
-                .dot(dyn._get_phased_ctrl_dyn_gen(k, j))
-                .dot(dyn._dyn_gen_eigenvectors[k]))
-            # multiply (elementwise) by timeslice and factor matrix
-            cdg = np.multiply(cdg * dyn.tau[k], dyn._dyn_gen_factormatrix[k])
-            # Return to canonical basis
-            prop_grad = (
-                dyn._dyn_gen_eigenvectors[k].dot(cdg)
-                .dot(dyn._get_dyn_gen_eigenvectors_adj(k)))
-
-        if compute_prop:
-            return prop, prop_grad
-        else:
-            return prop_grad
-
-
-class PropCompAugMat(PropagatorComputer):
-    """
-    Augmented Matrix (deprecated - see _Frechet)
-
-    It should work for all systems, e.g. open, symplectic
-    There will be other PropagatorComputer subclasses that are more efficient
-    The _Frechet class should provide exactly the same functionality
-    more efficiently.
-
-    Note the propagator gradient calculation using the augmented matrix
-    is taken from:
-    'Robust quantum gates for open systems via optimal control:
-    Markovian versus non-Markovian dynamics'
-    Frederik F Floether, Pierre de Fouquieres, and Sophie G Schirmer
-    """
-    def reset(self):
-        PropagatorComputer.reset(self)
-        self.id_text = 'AUG_MAT'
-        self.grad_exact = True
-        self.apply_params()
-
-    def _get_aug_mat(self, k, j):
-        """
-        Generate the matrix [[A, E], [0, A]] where
-            A is the overall dynamics generator
-            E is the control dynamics generator
-        for a given timeslot and control
-        returns this augmented matrix
-        """
-        dyn = self.parent
-        dg = dyn._get_phased_dyn_gen(k)
-
-        if dyn.oper_dtype == Qobj:
-            A = dg.data*dyn.tau[k]
-            E = dyn._get_phased_ctrl_dyn_gen(k, j).data*dyn.tau[k]
-            Z = sp.csr_matrix(dg.data.shape)
-            aug = Qobj(sp.vstack([sp.hstack([A, E]), sp.hstack([Z, A])]))
-        else:
-            A = dg*dyn.tau[k]
-            E = dyn._get_phased_ctrl_dyn_gen(k, j)*dyn.tau[k]
-            Z = np.zeros(dg.shape)
-            aug = np.vstack([np.hstack([A, E]), np.hstack([Z, A])])
-        return aug
-
-    def _compute_prop_grad(self, k, j, compute_prop=True):
-        """
-        Calculate the gradient of propagator wrt the control amplitude
-        in the timeslot using the exponentiation of the the augmented
-        matrix.
-        The propagtor is calculated for 'free' in this method
-        and hence it is returned if compute_prop==True
-        Returns:
-            [prop], prop_grad
-        """
-        dyn = self.parent
-        dg = dyn._get_phased_dyn_gen(k)
-        aug = self._get_aug_mat(k, j)
-
-        if dyn.oper_dtype == Qobj:
-            aug_exp = aug.expm()
-            prop_grad = Qobj(aug_exp[:dg.shape[0], dg.shape[1]:],
-                             dims=dyn.dyn_dims)
-            if compute_prop:
-                prop = Qobj(aug_exp[:dg.shape[0], :dg.shape[1]],
-                            dims=dyn.dyn_dims)
-        else:
-            aug_exp = la.expm(aug)
-            prop_grad = aug_exp[:dg.shape[0], dg.shape[1]:]
-            if compute_prop:
-                prop = aug_exp[:dg.shape[0], :dg.shape[1]]
-
-        if compute_prop:
-            return prop, prop_grad
-        else:
-            return prop_grad
-
-
-class PropCompFrechet(PropagatorComputer):
-    """
-    Frechet method for calculating the propagator: exponentiating the combined
-    dynamics generator and the propagator gradient. It should work for all
-    systems, e.g. unitary, open, symplectic. There are other
-    :obj:`PropagatorComputer` subclasses that may be more efficient.
-    """
-    def reset(self):
-        PropagatorComputer.reset(self)
-        self.id_text = 'FRECHET'
-        self.grad_exact = True
-        self.apply_params()
-
-    def _compute_prop_grad(self, k, j, compute_prop=True):
-        """
-        Calculate the gradient of propagator wrt the control amplitude
-        in the timeslot using the expm_frechet method
-        The propagtor is calculated (almost) for 'free' in this method
-        and hence it is returned if compute_prop==True
-        Returns:
-            [prop], prop_grad
-        """
-        dyn = self.parent
-
-        if dyn.oper_dtype == Qobj:
-            A = dyn._get_phased_dyn_gen(k).full()*dyn.tau[k]
-            E = dyn._get_phased_ctrl_dyn_gen(k, j).full()*dyn.tau[k]
-            if compute_prop:
-                prop_dense, prop_grad_dense = la.expm_frechet(A, E)
-                prop = Qobj(prop_dense, dims=dyn.dyn_dims)
-                prop_grad = Qobj(prop_grad_dense, dims=dyn.dyn_dims)
-            else:
-                prop_grad_dense = la.expm_frechet(A, E, compute_expm=False)
-                prop_grad = Qobj(prop_grad_dense, dims=dyn.dyn_dims)
-        else:
-            A = dyn._get_phased_dyn_gen(k)*dyn.tau[k]
-            E = dyn._get_phased_ctrl_dyn_gen(k, j)*dyn.tau[k]
-            if compute_prop:
-                prop, prop_grad = la.expm_frechet(A, E)
-            else:
-                prop_grad = la.expm_frechet(A, E, compute_expm=False)
-        if compute_prop:
-            return prop, prop_grad
-        else:
-            return prop_grad
diff --git a/qutip/control/pulsegen.py b/qutip/control/pulsegen.py
deleted file mode 100644
index b01ee3a829..0000000000
--- a/qutip/control/pulsegen.py
+++ /dev/null
@@ -1,1250 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Pulse generator - Generate pulses for the timeslots
-Each class defines a gen_pulse function that produces a float array of
-size num_tslots. Each class produces a differ type of pulse.
-See the class and gen_pulse function descriptions for details
-"""
-
-import numpy as np
-
-import qutip.control.dynamics as dynamics
-import qutip.control.errors as errors
-
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-def create_pulse_gen(pulse_type='RND', dyn=None, pulse_params=None):
-    """
-    Create and return a pulse generator object matching the given type.
-    The pulse generators each produce a different type of pulse,
-    see the gen_pulse function description for details.
-    These are the random pulse options:
-
-        RND - Independent random value in each timeslot
-        RNDFOURIER - Fourier series with random coefficients
-        RNDWAVES - Summation of random waves
-        RNDWALK1 - Random change in amplitude each timeslot
-        RNDWALK2 - Random change in amp gradient each timeslot
-
-    These are the other non-periodic options:
-
-        LIN - Linear, i.e. contant gradient over the time
-        ZERO - special case of the LIN pulse, where the gradient is 0
-
-    These are the periodic options
-
-        SINE - Sine wave
-        SQUARE - Square wave
-        SAW - Saw tooth wave
-        TRIANGLE - Triangular wave
-
-    If a Dynamics object is passed in then this is used in instantiate
-    the PulseGen, meaning that some timeslot and amplitude properties
-    are copied over.
-
-    """
-    if pulse_type == 'RND':
-        return PulseGenRandom(dyn, params=pulse_params)
-    if pulse_type == 'RNDFOURIER':
-        return PulseGenRndFourier(dyn, params=pulse_params)
-    if pulse_type == 'RNDWAVES':
-        return PulseGenRndWaves(dyn, params=pulse_params)
-    if pulse_type == 'RNDWALK1':
-        return PulseGenRndWalk1(dyn, params=pulse_params)
-    if pulse_type == 'RNDWALK2':
-        return PulseGenRndWalk2(dyn, params=pulse_params)
-    elif pulse_type == 'LIN':
-        return PulseGenLinear(dyn, params=pulse_params)
-    elif pulse_type == 'ZERO':
-        return PulseGenZero(dyn, params=pulse_params)
-    elif pulse_type == 'SINE':
-        return PulseGenSine(dyn, params=pulse_params)
-    elif pulse_type == 'SQUARE':
-        return PulseGenSquare(dyn, params=pulse_params)
-    elif pulse_type == 'SAW':
-        return PulseGenSaw(dyn, params=pulse_params)
-    elif pulse_type == 'TRIANGLE':
-        return PulseGenTriangle(dyn, params=pulse_params)
-    elif pulse_type == 'GAUSSIAN':
-        return PulseGenGaussian(dyn, params=pulse_params)
-    elif pulse_type == 'CRAB_FOURIER':
-        return PulseGenCrabFourier(dyn, params=pulse_params)
-    elif pulse_type == 'GAUSSIAN_EDGE':
-        return PulseGenGaussianEdge(dyn, params=pulse_params)
-    else:
-        raise ValueError("No option for pulse_type '{}'".format(pulse_type))
-
-
-class PulseGen:
-    """
-    Pulse generator
-    Base class for all Pulse generators
-    The object can optionally be instantiated with a Dynamics object,
-    in which case the timeslots and amplitude scaling and offset
-    are copied from that.
-    Otherwise the class can be used independently by setting:
-    tau (array of timeslot durations)
-    or
-    num_tslots and pulse_time for equally spaced timeslots
-
-    Attributes
-    ----------
-    num_tslots : integer
-        Number of timeslots, aka timeslices
-        (copied from Dynamics if given)
-
-    pulse_time : float
-        total duration of the pulse
-        (copied from Dynamics.evo_time if given)
-
-    scaling : float
-        linear scaling applied to the pulse
-        (copied from Dynamics.initial_ctrl_scaling if given)
-
-    offset : float
-        linear offset applied to the pulse
-        (copied from Dynamics.initial_ctrl_offset if given)
-
-    tau : array[num_tslots] of float
-        Duration of each timeslot
-        (copied from Dynamics if given)
-
-    lbound : float
-        Lower boundary for the pulse amplitudes
-        Note that the scaling and offset attributes can be used to fully
-        bound the pulse for all generators except some of the random ones
-        This bound (if set) may result in additional shifting / scaling
-        Default is -Inf
-
-    ubound : float
-        Upper boundary for the pulse amplitudes
-        Note that the scaling and offset attributes can be used to fully
-        bound the pulse for all generators except some of the random ones
-        This bound (if set) may result in additional shifting / scaling
-        Default is Inf
-
-    periodic : boolean
-        True if the pulse generator produces periodic pulses
-
-    random : boolean
-        True if the pulse generator produces random pulses
-
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip.logging_utils,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-    """
-    def __init__(self, dyn=None, params=None):
-        self.parent = dyn
-        self.params = params
-        self.reset()
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        if isinstance(self.parent, dynamics.Dynamics):
-            dyn = self.parent
-            self.num_tslots = dyn.num_tslots
-            self.pulse_time = dyn.evo_time
-            self.scaling = dyn.initial_ctrl_scaling
-            self.offset = dyn.initial_ctrl_offset
-            self.tau = dyn.tau
-            self.log_level = dyn.log_level
-        else:
-            self.num_tslots = 100
-            self.pulse_time = 1.0
-            self.scaling = 1.0
-            self.tau = None
-            self.offset = 0.0
-
-        self._uses_time = False
-        self.time = None
-        self._pulse_initialised = False
-        self.periodic = False
-        self.random = False
-        self.lbound = None
-        self.ubound = None
-        self.ramping_pulse = None
-
-        self.apply_params()
-
-    def apply_params(self, params=None):
-        """
-        Set object attributes based on the dictionary (if any) passed in the
-        instantiation, or passed as a parameter
-        This is called during the instantiation automatically.
-        The key value pairs are the attribute name and value
-        """
-        if not params:
-            params = self.params
-
-        if isinstance(params, dict):
-            self.params = params
-            for key in params:
-                setattr(self, key, params[key])
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    def gen_pulse(self):
-        """
-        returns the pulse as an array of vales for each timeslot
-        Must be implemented by subclass
-        """
-        # must be implemented by subclass
-        raise errors.UsageError(
-            "No method defined for generating a pulse. "
-            " Suspect base class was used where sub class should have been")
-
-    def init_pulse(self):
-        """
-        Initialise the pulse parameters
-        """
-        if self.tau is None:
-            self.tau = np.ones(self.num_tslots, dtype='f') * \
-                self.pulse_time/self.num_tslots
-
-        if self._uses_time:
-            self.time = np.zeros(self.num_tslots, dtype=float)
-            for k in range(self.num_tslots-1):
-                self.time[k+1] = self.time[k] + self.tau[k]
-
-        self._pulse_initialised = True
-
-        if self.lbound is not None:
-            if np.isinf(self.lbound):
-                self.lbound = None
-        if self.ubound is not None:
-            if np.isinf(self.ubound):
-                self.ubound = None
-
-        if self.ubound is not None and self.lbound is not None:
-            if self.ubound < self.lbound:
-                raise ValueError("ubound cannot be less the lbound")
-
-    def _apply_bounds_and_offset(self, pulse):
-        """
-        Ensure that the randomly generated pulse fits within the bounds
-        (after applying the offset)
-        Assumes that pulses passed are centered around zero (on average)
-        """
-        if self.lbound is None and self.ubound is None:
-            return pulse + self.offset
-
-        max_amp = max(pulse)
-        min_amp = min(pulse)
-        if (
-            (self.ubound is None or max_amp + self.offset <= self.ubound)
-            and (self.lbound is None or min_amp + self.offset >= self.lbound)
-        ):
-            return pulse + self.offset
-
-        # Some shifting / scaling is required.
-        if self.ubound is None or self.lbound is None:
-            # One of the bounds is inf, so just shift the pulse
-            if self.lbound is None:
-                # max_amp + offset must exceed the ubound
-                return pulse + self.ubound - max_amp
-            else:
-                # min_amp + offset must exceed the lbound
-                return pulse + self.lbound - min_amp
-        else:
-            bound_range = self.ubound - self.lbound
-            amp_range = max_amp - min_amp
-            if max_amp - min_amp > bound_range:
-                # pulse range is too high, it must be scaled
-                pulse = pulse * bound_range / amp_range
-
-            # otherwise the pulse should fit anyway
-            return pulse + self.lbound - min(pulse)
-
-    def _apply_ramping_pulse(self, pulse, ramping_pulse=None):
-        if ramping_pulse is None:
-            ramping_pulse = self.ramping_pulse
-        if ramping_pulse is not None:
-            pulse = pulse*ramping_pulse
-
-        return pulse
-
-
-class PulseGenZero(PulseGen):
-    """
-    Generates a flat pulse
-    """
-    def gen_pulse(self):
-        """
-        Generate a pulse with the same value in every timeslot.
-        The value will be zero, unless the offset is not zero,
-        in which case it will be the offset
-        """
-        pulse = np.zeros(self.num_tslots)
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenRandom(PulseGen):
-    """
-    Generates random pulses as simply random values for each timeslot
-    """
-    def reset(self):
-        PulseGen.reset(self)
-        self.random = True
-        self.apply_params()
-
-    def gen_pulse(self):
-        """
-        Generate a pulse of random values between 1 and -1
-        Values are scaled using the scaling property
-        and shifted using the offset property
-        Returns the pulse as an array of vales for each timeslot
-        """
-        pulse = (2*np.random.random(self.num_tslots) - 1) * self.scaling
-
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenRndFourier(PulseGen):
-    """
-    Generates pulses by summing sine waves as a Fourier series
-    with random coefficients
-
-    Attributes
-    ----------
-    scaling : float
-        The pulses should fit approximately within -/+scaling
-        (before the offset is applied)
-        as it is used to set a maximum for each component wave
-        Use bounds to be sure
-        (copied from Dynamics.initial_ctrl_scaling if given)
-
-    min_wavelen : float
-        Minimum wavelength of any component wave
-        Set by default to 1/10th of the pulse time
-    """
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self.random = True
-        self._uses_time = True
-        try:
-            self.min_wavelen = self.pulse_time / 10.0
-        except AttributeError:
-            self.min_wavelen = 0.1
-        self.apply_params()
-
-    def gen_pulse(self, min_wavelen=None):
-        """
-        Generate a random pulse based on a Fourier series with a minimum
-        wavelength
-        """
-        if min_wavelen is not None:
-            self.min_wavelen = min_wavelen
-        min_wavelen = self.min_wavelen
-
-        if min_wavelen > self.pulse_time:
-            raise ValueError("Minimum wavelength cannot be greater than "
-                             "the pulse time")
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        # use some phase to avoid the first pulse being always 0
-
-        sum_wave = np.zeros(self.tau.shape)
-        wavelen = 2.0*self.pulse_time
-
-        t = self.time
-        wl = []
-        while wavelen > min_wavelen:
-            wl.append(wavelen)
-            wavelen = wavelen/2.0
-
-        num_comp_waves = len(wl)
-        amp_scale = np.sqrt(8)*self.scaling / float(num_comp_waves)
-
-        for wavelen in wl:
-            amp = amp_scale*(np.random.rand()*2 - 1)
-            phase_off = np.random.rand()*np.pi/2.0
-            curr_wave = amp*np.sin(2*np.pi*t/wavelen + phase_off)
-            sum_wave += curr_wave
-
-        return self._apply_bounds_and_offset(sum_wave)
-
-
-class PulseGenRndWaves(PulseGen):
-    """
-    Generates pulses by summing sine waves with random frequencies
-    amplitudes and phase offset
-
-    Attributes
-    ----------
-    scaling : float
-        The pulses should fit approximately within -/+scaling
-        (before the offset is applied)
-        as it is used to set a maximum for each component wave
-        Use bounds to be sure
-        (copied from Dynamics.initial_ctrl_scaling if given)
-
-    num_comp_waves : integer
-        Number of component waves. That is the number of waves that
-        are summed to make the pulse signal
-        Set to 20 by default.
-
-    min_wavelen : float
-        Minimum wavelength of any component wave
-        Set by default to 1/10th of the pulse time
-
-    max_wavelen : float
-        Maximum wavelength of any component wave
-        Set by default to twice the pulse time
-    """
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self.random = True
-        self._uses_time = True
-        self.num_comp_waves = 20
-        try:
-            self.min_wavelen = self.pulse_time / 10.0
-        except AttributeError:
-            self.min_wavelen = 0.1
-        try:
-            self.max_wavelen = 2*self.pulse_time
-        except AttributeError:
-            self.max_wavelen = 10.0
-        self.apply_params()
-
-    def gen_pulse(self, num_comp_waves=None,
-                  min_wavelen=None, max_wavelen=None):
-        """
-        Generate a random pulse by summing sine waves with random freq,
-        amplitude and phase offset
-        """
-
-        if num_comp_waves is not None:
-            self.num_comp_waves = num_comp_waves
-        if min_wavelen is not None:
-            self.min_wavelen = min_wavelen
-        if max_wavelen is not None:
-            self.max_wavelen = max_wavelen
-
-        num_comp_waves = self.num_comp_waves
-        min_wavelen = self.min_wavelen
-        max_wavelen = self.max_wavelen
-
-        if min_wavelen > self.pulse_time:
-            raise ValueError("Minimum wavelength cannot be greater than "
-                             "the pulse time")
-        if max_wavelen <= min_wavelen:
-            raise ValueError("Maximum wavelength must be greater than "
-                             "the minimum wavelength")
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        # use some phase to avoid the first pulse being always 0
-
-        sum_wave = np.zeros(self.tau.shape)
-
-        t = self.time
-        wl_range = max_wavelen - min_wavelen
-        amp_scale = np.sqrt(8)*self.scaling / float(num_comp_waves)
-        for n in range(num_comp_waves):
-            amp = amp_scale*(np.random.rand()*2 - 1)
-            phase_off = np.random.rand()*np.pi/2.0
-            wavelen = min_wavelen + np.random.rand()*wl_range
-            curr_wave = amp*np.sin(2*np.pi*t/wavelen + phase_off)
-            sum_wave += curr_wave
-
-        return self._apply_bounds_and_offset(sum_wave)
-
-
-class PulseGenRndWalk1(PulseGen):
-    """
-    Generates pulses by using a random walk algorithm
-
-    Attributes
-    ----------
-    scaling : float
-        Used as the range for the starting amplitude
-        Note must used bounds if values must be restricted.
-        Also scales the max_d_amp value
-        (copied from Dynamics.initial_ctrl_scaling if given)
-
-    max_d_amp : float
-        Maximum amount amplitude will change between timeslots
-        Note this is also factored by the scaling attribute
-    """
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self.random = True
-        self.max_d_amp = 0.1
-        self.apply_params()
-
-    def gen_pulse(self, max_d_amp=None):
-        """
-        Generate a pulse by changing the amplitude a random amount between
-        -max_d_amp and +max_d_amp at each timeslot. The walk will start at
-        a random amplitude between -/+scaling.
-        """
-        if max_d_amp is not None:
-            self.max_d_amp = max_d_amp
-        max_d_amp = self.max_d_amp*self.scaling
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        walk = np.zeros(self.tau.shape)
-        amp = self.scaling*(np.random.rand()*2 - 1)
-        for k in range(len(walk)):
-            walk[k] = amp
-            amp += (np.random.rand()*2 - 1)*max_d_amp
-
-        return self._apply_bounds_and_offset(walk)
-
-
-class PulseGenRndWalk2(PulseGen):
-    """
-    Generates pulses by using a random walk algorithm
-    Note this is best used with bounds as the walks tend to wander far
-
-    Attributes
-    ----------
-    scaling : float
-        Used as the range for the starting amplitude
-        Note must used bounds if values must be restricted.
-        Also scales the max_d2_amp value
-        (copied from Dynamics.initial_ctrl_scaling if given)
-
-    max_d2_amp : float
-        Maximum amount amplitude gradient will change between timeslots
-        Note this is also factored by the scaling attribute
-    """
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self.random = True
-        self.max_d2_amp = 0.01
-        self.apply_params()
-
-    def gen_pulse(self, init_grad_range=None, max_d2_amp=None):
-        """
-        Generate a pulse by changing the amplitude gradient a random amount
-        between -max_d2_amp and +max_d2_amp at each timeslot.
-        The walk will start at a random amplitude between -/+scaling.
-        The gradient will start at 0
-        """
-        if max_d2_amp is not None:
-            self.max_d2_amp = max_d2_amp
-
-        max_d2_amp = self.max_d2_amp
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        walk = np.zeros(self.tau.shape)
-        amp = self.scaling*(np.random.rand()*2 - 1)
-        print("Start amp {}".format(amp))
-        grad = 0.0
-        print("Start grad {}".format(grad))
-        for k in range(len(walk)):
-            walk[k] = amp
-            grad += (np.random.rand()*2 - 1)*max_d2_amp
-            amp += grad
-            # print("grad {}".format(grad))
-
-        return self._apply_bounds_and_offset(walk)
-
-
-class PulseGenLinear(PulseGen):
-    """
-    Generates linear pulses
-
-    Attributes
-    ----------
-    gradient : float
-        Gradient of the line.
-        Note this is calculated from the start_val and end_val if these
-        are given
-
-    start_val : float
-        Start point of the line. That is the starting amplitude
-
-    end_val : float
-        End point of the line.
-        That is the amplitude at the start of the last timeslot
-    """
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-
-        self.gradient = None
-        self.start_val = -1.0
-        self.end_val = 1.0
-        self.apply_params()
-
-    def init_pulse(self, gradient=None, start_val=None, end_val=None):
-        """
-        Calculate the gradient if pulse is defined by start and
-        end point values
-        """
-        PulseGen.init_pulse(self)
-        if start_val is not None and end_val is not None:
-            self.start_val = start_val
-            self.end_val = end_val
-
-        if self.start_val is not None and self.end_val is not None:
-            self.gradient = float(self.end_val - self.start_val) / \
-                (self.pulse_time - self.tau[-1])
-
-    def gen_pulse(self, gradient=None, start_val=None, end_val=None):
-        """
-        Generate a linear pulse using either the gradient and start value
-        or using the end point to calulate the gradient
-        Note that the scaling and offset parameters are still applied,
-        so unless these values are the default 1.0 and 0.0, then the
-        actual gradient etc will be different
-        Returns the pulse as an array of vales for each timeslot
-        """
-        if (gradient is not None or
-                start_val is not None or end_val is not None):
-            self.init_pulse(gradient, start_val, end_val)
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        pulse = np.empty(self.num_tslots)
-        t = 0.0
-        for k in range(self.num_tslots):
-            y = self.gradient*t + self.start_val
-            pulse[k] = self.scaling*y
-            t = t + self.tau[k]
-
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenPeriodic(PulseGen):
-    """
-    Intermediate class for all periodic pulse generators
-    All of the periodic pulses range from -1 to 1
-    All have a start phase that can be set between 0 and 2pi
-
-    Attributes
-    ----------
-    num_waves : float
-        Number of complete waves (cycles) that occur in the pulse.
-        wavelen and freq calculated from this if it is given
-
-    wavelen : float
-        Wavelength of the pulse (assuming the speed is 1)
-        freq is calculated from this if it is given
-
-    freq : float
-        Frequency of the pulse
-
-    start_phase : float
-        Phase of the pulse signal when t=0
-    """
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self.periodic = True
-        self.num_waves = None
-        self.freq = 1.0
-        self.wavelen = None
-        self.start_phase = 0.0
-        self.apply_params()
-
-    def init_pulse(self, num_waves=None, wavelen=None,
-                   freq=None, start_phase=None):
-        """
-        Calculate the wavelength, frequency, number of waves etc
-        from the each other and the other parameters
-        If num_waves is given then the other parameters are worked from this
-        Otherwise if the wavelength is given then it is the driver
-        Otherwise the frequency is used to calculate wavelength and num_waves
-        """
-        PulseGen.init_pulse(self)
-
-        if start_phase is not None:
-            self.start_phase = start_phase
-
-        if num_waves is not None or wavelen is not None or freq is not None:
-            self.num_waves = num_waves
-            self.wavelen = wavelen
-            self.freq = freq
-
-        if self.num_waves is not None:
-            self.freq = float(self.num_waves) / self.pulse_time
-            self.wavelen = 1.0/self.freq
-        elif self.wavelen is not None:
-            self.freq = 1.0/self.wavelen
-            self.num_waves = self.wavelen*self.pulse_time
-        else:
-            self.wavelen = 1.0/self.freq
-            self.num_waves = self.wavelen*self.pulse_time
-
-
-class PulseGenSine(PulseGenPeriodic):
-    """
-    Generates sine wave pulses
-    """
-    def gen_pulse(self, num_waves=None, wavelen=None,
-                  freq=None, start_phase=None):
-        """
-        Generate a sine wave pulse
-        If no params are provided then the class object attributes are used.
-        If they are provided, then these will reinitialise the object attribs.
-        returns the pulse as an array of vales for each timeslot
-        """
-        if start_phase is not None:
-            self.start_phase = start_phase
-
-        if num_waves is not None or wavelen is not None or freq is not None:
-            self.init_pulse(num_waves, wavelen, freq, start_phase)
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        pulse = np.empty(self.num_tslots)
-        t = 0.0
-        for k in range(self.num_tslots):
-            phase = 2*np.pi*self.freq*t + self.start_phase
-            pulse[k] = self.scaling*np.sin(phase)
-            t = t + self.tau[k]
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenSquare(PulseGenPeriodic):
-    """
-    Generates square wave pulses
-    """
-    def gen_pulse(self, num_waves=None, wavelen=None,
-                  freq=None, start_phase=None):
-        """
-        Generate a square wave pulse
-        If no parameters are pavided then the class object attributes are used.
-        If they are provided, then these will reinitialise the object attribs
-        """
-        if start_phase is not None:
-            self.start_phase = start_phase
-
-        if num_waves is not None or wavelen is not None or freq is not None:
-            self.init_pulse(num_waves, wavelen, freq, start_phase)
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        pulse = np.empty(self.num_tslots)
-        t = 0.0
-        for k in range(self.num_tslots):
-            phase = 2*np.pi*self.freq*t + self.start_phase
-            x = phase/(2*np.pi)
-            y = 4*np.floor(x) - 2*np.floor(2*x) + 1
-            pulse[k] = self.scaling*y
-            t = t + self.tau[k]
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenSaw(PulseGenPeriodic):
-    """
-    Generates saw tooth wave pulses
-    """
-    def gen_pulse(self, num_waves=None, wavelen=None,
-                  freq=None, start_phase=None):
-        """
-        Generate a saw tooth wave pulse
-        If no parameters are pavided then the class object attributes are used.
-        If they are provided, then these will reinitialise the object attribs
-        """
-        if start_phase is not None:
-            self.start_phase = start_phase
-
-        if num_waves is not None or wavelen is not None or freq is not None:
-            self.init_pulse(num_waves, wavelen, freq, start_phase)
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        pulse = np.empty(self.num_tslots)
-        t = 0.0
-        for k in range(self.num_tslots):
-            phase = 2*np.pi*self.freq*t + self.start_phase
-            x = phase/(2*np.pi)
-            y = 2*(x - np.floor(0.5 + x))
-            pulse[k] = self.scaling*y
-            t = t + self.tau[k]
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenTriangle(PulseGenPeriodic):
-    """
-    Generates triangular wave pulses
-    """
-    def gen_pulse(self, num_waves=None, wavelen=None,
-                  freq=None, start_phase=None):
-        """
-        Generate a sine wave pulse
-        If no parameters are pavided then the class object attributes are used.
-        If they are provided, then these will reinitialise the object attribs
-        """
-        if start_phase is not None:
-            self.start_phase = start_phase
-
-        if num_waves is not None or wavelen is not None or freq is not None:
-            self.init_pulse(num_waves, wavelen, freq, start_phase)
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        pulse = np.empty(self.num_tslots)
-        t = 0.0
-        for k in range(self.num_tslots):
-            phase = 2*np.pi*self.freq*t + self.start_phase + np.pi/2.0
-            x = phase/(2*np.pi)
-            y = 2*np.abs(2*(x - np.floor(0.5 + x))) - 1
-            pulse[k] = self.scaling*y
-            t = t + self.tau[k]
-
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenGaussian(PulseGen):
-    """
-    Generates pulses with a Gaussian profile
-    """
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self._uses_time = True
-        self.mean = 0.5*self.pulse_time
-        self.variance = 0.5*self.pulse_time
-        self.apply_params()
-
-    def gen_pulse(self, mean=None, variance=None):
-        """
-        Generate a pulse with Gaussian shape. The peak is centre around the
-        mean and the variance determines the breadth
-        The scaling and offset attributes are applied as an amplitude
-        and fixed linear offset. Note that the maximum amplitude will be
-        scaling + offset.
-        """
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        if mean:
-            Tm = mean
-        else:
-            Tm = self.mean
-        if variance:
-            Tv = variance
-        else:
-            Tv = self.variance
-        t = self.time
-        T = self.pulse_time
-
-        pulse = self.scaling*np.exp(-(t-Tm)**2/(2*Tv))
-        return self._apply_bounds_and_offset(pulse)
-
-
-class PulseGenGaussianEdge(PulseGen):
-    """
-    Generate pulses with inverted Gaussian ramping in and out
-    It's intended use for a ramping modulation, which is often required in
-    experimental setups.
-
-    Attributes
-    ----------
-        decay_time : float
-            Determines the ramping rate. It is approximately the time
-            required to bring the pulse to full amplitude
-            It is set to 1/10 of the pulse time by default
-    """
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self._uses_time = True
-        self.decay_time = self.pulse_time / 10.0
-        self.apply_params()
-
-    def gen_pulse(self, decay_time=None):
-        """
-        Generate a pulse that starts and ends at zero and 1.0 in between
-        then apply scaling and offset
-        The tailing in and out is an inverted Gaussian shape
-        """
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        t = self.time
-        if decay_time:
-            Td = decay_time
-        else:
-            Td = self.decay_time
-        T = self.pulse_time
-        pulse = 1.0 - np.exp(-t**2/Td) - np.exp(-(t-T)**2/Td)
-        pulse = pulse*self.scaling
-
-        return self._apply_bounds_and_offset(pulse)
-
-
-### The following are pulse generators for the CRAB algorithm ###
-# AJGP 2015-05-14:
-# The intention is to have a more general base class that allows
-# setting of general basis functions
-
-class PulseGenCrab(PulseGen):
-    """
-    Base class for all CRAB pulse generators
-    Note these are more involved in the optimisation process as they are
-    used to produce piecewise control amplitudes each time new optimisation
-    parameters are tried
-
-    Attributes
-    ----------
-    num_coeffs : integer
-        Number of coefficients used for each basis function
-
-    num_basis_funcs : integer
-        Number of basis functions
-        In this case set at 2 and should not be changed
-
-    coeffs : float array[num_coeffs, num_basis_funcs]
-        The basis coefficient values
-
-    randomize_coeffs : bool
-        If True (default) then the coefficients are set to some random values
-        when initialised, otherwise they will all be equal to self.scaling
-    """
-    def __init__(self, dyn=None, num_coeffs=None, params=None):
-        self.parent = dyn
-        self.num_coeffs = num_coeffs
-        self.params = params
-        self.reset()
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGen.reset(self)
-        self.NUM_COEFFS_WARN_LVL = 20
-        self.DEF_NUM_COEFFS = 4
-        self._BSC_ALL = 1
-        self._BSC_GT_MEAN = 2
-        self._BSC_LT_MEAN = 3
-
-        self._uses_time = True
-        self.time = None
-        self.num_basis_funcs = 2
-        self.num_optim_vars = 0
-        self.coeffs = None
-        self.randomize_coeffs = True
-        self._num_coeffs_estimated = False
-        self.guess_pulse_action = 'MODULATE'
-        self.guess_pulse = None
-        self.guess_pulse_func = None
-        self.apply_params()
-
-    def init_pulse(self, num_coeffs=None):
-        """
-        Set the initial freq and coefficient values
-        """
-        PulseGen.init_pulse(self)
-        self.init_coeffs(num_coeffs=num_coeffs)
-
-        if self.guess_pulse is not None:
-            self.init_guess_pulse()
-        self._init_bounds()
-
-        if self.log_level <= logging.DEBUG and not self._num_coeffs_estimated:
-            logger.debug(
-                    "CRAB pulse initialised with {} coefficients per basis "
-                    "function, which means a total of {} "
-                    "optimisation variables for this pulse".format(
-                            self.num_coeffs, self.num_optim_vars))
-
-#    def generate_guess_pulse(self)
-#        if isinstance(self.guess_pulsegen, PulseGen):
-#            self.guess_pulse = self.guess_pulsegen.gen_pulse()
-#        return self.guess_pulse
-
-    def init_coeffs(self, num_coeffs=None):
-        """
-        Generate the initial ceofficent values.
-
-        Parameters
-        ----------
-        num_coeffs : integer
-            Number of coefficients used for each basis function
-            If given this overides the default and sets the attribute
-            of the same name.
-        """
-        if num_coeffs:
-            self.num_coeffs = num_coeffs
-
-        self._num_coeffs_estimated = False
-        if not self.num_coeffs:
-            if isinstance(self.parent, dynamics.Dynamics):
-                dim = self.parent.get_drift_dim()
-                self.num_coeffs = self.estimate_num_coeffs(dim)
-                self._num_coeffs_estimated = True
-            else:
-                self.num_coeffs = self.DEF_NUM_COEFFS
-        self.num_optim_vars = self.num_coeffs*self.num_basis_funcs
-
-        if self._num_coeffs_estimated:
-            if self.log_level <= logging.INFO:
-                logger.info(
-                    "The number of CRAB coefficients per basis function "
-                    "has been estimated as {}, which means a total of {} "
-                    "optimisation variables for this pulse. Based on the "
-                    "dimension ({}) of the system".format(
-                            self.num_coeffs, self.num_optim_vars, dim))
-            # Issue warning if beyond the recommended level
-            if self.log_level <= logging.WARN:
-                if self.num_coeffs > self.NUM_COEFFS_WARN_LVL:
-                    logger.warn(
-                        "The estimated number of coefficients {} exceeds "
-                        "the amount ({}) recommended for efficient "
-                        "optimisation. You can set this level explicitly "
-                        "to suppress this message.".format(
-                            self.num_coeffs, self.NUM_COEFFS_WARN_LVL))
-
-        if self.randomize_coeffs:
-            r = np.random.random([self.num_coeffs, self.num_basis_funcs])
-            self.coeffs = (2*r - 1.0) * self.scaling
-        else:
-            self.coeffs = np.ones([self.num_coeffs,
-                                   self.num_basis_funcs])*self.scaling
-
-    def estimate_num_coeffs(self, dim):
-        """
-        Estimate the number coefficients based on the dimensionality of the
-        system.
-        Returns
-        -------
-        num_coeffs : int
-            estimated number of coefficients
-        """
-        num_coeffs = max(2, dim - 1)
-        return num_coeffs
-
-    def get_optim_var_vals(self):
-        """
-        Get the parameter values to be optimised
-        Returns
-        -------
-        list (or 1d array) of floats
-        """
-        return self.coeffs.ravel().tolist()
-
-    def set_optim_var_vals(self, param_vals):
-        """
-        Set the values of the any of the pulse generation parameters
-        based on new values from the optimisation method
-        Typically this will be the basis coefficients
-        """
-        # Type and size checking avoided here as this is in the
-        # main optmisation call sequence
-        self.set_coeffs(param_vals)
-
-    def set_coeffs(self, param_vals):
-        self.coeffs = param_vals.reshape(
-                    [self.num_coeffs, self.num_basis_funcs])
-
-    def init_guess_pulse(self):
-
-        self.guess_pulse_func = None
-        if not self.guess_pulse_action:
-            logger.WARN("No guess pulse action given, hence ignored.")
-        elif self.guess_pulse_action.upper() == 'MODULATE':
-            self.guess_pulse_func = self.guess_pulse_modulate
-        elif self.guess_pulse_action.upper() == 'ADD':
-            self.guess_pulse_func = self.guess_pulse_add
-        else:
-            logger.WARN("No option for guess pulse action '{}' "
-                        ", hence ignored.".format(self.guess_pulse_action))
-
-    def guess_pulse_add(self, pulse):
-        pulse = pulse + self.guess_pulse
-        return pulse
-
-    def guess_pulse_modulate(self, pulse):
-        pulse = (1.0 + pulse)*self.guess_pulse
-        return pulse
-
-    def _init_bounds(self):
-        add_guess_pulse_scale = False
-        if self.lbound is None and self.ubound is None:
-            # no bounds to apply
-            self._bound_scale_cond = None
-        elif self.lbound is None:
-            # only upper bound
-            if self.ubound > 0:
-                self._bound_mean = 0.0
-                self._bound_scale = self.ubound
-            else:
-                add_guess_pulse_scale = True
-                self._bound_scale =\
-                    self.scaling*self.num_coeffs + self.get_guess_pulse_scale()
-                self._bound_mean = -abs(self._bound_scale) + self.ubound
-            self._bound_scale_cond = self._BSC_GT_MEAN
-
-        elif self.ubound is None:
-            # only lower bound
-            if self.lbound < 0:
-                self._bound_mean = 0.0
-                self._bound_scale = abs(self.lbound)
-            else:
-                self._bound_scale = self.scaling*self.num_coeffs + \
-                            self.get_guess_pulse_scale()
-                self._bound_mean = abs(self._bound_scale) + self.lbound
-            self._bound_scale_cond = self._BSC_LT_MEAN
-
-        else:
-            # lower and upper bounds
-            self._bound_mean = 0.5*(self.ubound + self.lbound)
-            self._bound_scale = 0.5*(self.ubound - self.lbound)
-            self._bound_scale_cond = self._BSC_ALL
-
-    def get_guess_pulse_scale(self):
-        scale = 0.0
-        if self.guess_pulse is not None:
-            scale = max(np.amax(self.guess_pulse) - np.amin(self.guess_pulse),
-                        np.amax(self.guess_pulse))
-        return scale
-
-    def _apply_bounds(self, pulse):
-        """
-        Scaling the amplitudes using the tanh function if there are bounds
-        """
-        if self._bound_scale_cond == self._BSC_ALL:
-            pulse = np.tanh(pulse)*self._bound_scale + self._bound_mean
-            return pulse
-        elif self._bound_scale_cond == self._BSC_GT_MEAN:
-            scale_where = pulse > self._bound_mean
-            pulse[scale_where] = (np.tanh(pulse[scale_where])*self._bound_scale
-                                  + self._bound_mean)
-            return pulse
-        elif self._bound_scale_cond == self._BSC_LT_MEAN:
-            scale_where = pulse < self._bound_mean
-            pulse[scale_where] = (np.tanh(pulse[scale_where])*self._bound_scale
-                                  + self._bound_mean)
-            return pulse
-        else:
-            return pulse
-
-
-class PulseGenCrabFourier(PulseGenCrab):
-    """
-    Generates a pulse using the Fourier basis functions, i.e. sin and cos
-
-    Attributes
-    ----------
-    freqs : float array[num_coeffs]
-        Frequencies for the basis functions
-    randomize_freqs : bool
-        If True (default) the some random offset is applied to the frequencies
-    """
-
-    def reset(self):
-        """
-        reset attributes to default values
-        """
-        PulseGenCrab.reset(self)
-        self.freqs = None
-        self.randomize_freqs = True
-
-    def init_pulse(self, num_coeffs=None):
-        """
-        Set the initial freq and coefficient values
-        """
-        PulseGenCrab.init_pulse(self)
-
-        self.init_freqs()
-
-    def init_freqs(self):
-        """
-        Generate the frequencies
-        These are the Fourier harmonics with a uniformly distributed
-        random offset
-        """
-        self.freqs = np.empty(self.num_coeffs)
-        ff = 2*np.pi / self.pulse_time
-        for i in range(self.num_coeffs):
-            self.freqs[i] = ff*(i + 1)
-
-        if self.randomize_freqs:
-            self.freqs += np.random.random(self.num_coeffs) - 0.5
-
-    def gen_pulse(self, coeffs=None):
-        """
-        Generate a pulse using the Fourier basis with the freqs and
-        coeffs attributes.
-
-        Parameters
-        ----------
-        coeffs : float array[num_coeffs, num_basis_funcs]
-            The basis coefficient values
-            If given this overides the default and sets the attribute
-            of the same name.
-        """
-        if coeffs:
-            self.coeffs = coeffs
-
-        if not self._pulse_initialised:
-            self.init_pulse()
-
-        pulse = np.zeros(self.num_tslots)
-
-        for i in range(self.num_coeffs):
-            phase = self.freqs[i]*self.time
-            pulse += (self.coeffs[i, 0]*np.sin(phase)
-                      + self.coeffs[i, 1]*np.cos(phase))
-
-        if self.guess_pulse_func:
-            pulse = self.guess_pulse_func(pulse)
-        if self.ramping_pulse is not None:
-            pulse = self._apply_ramping_pulse(pulse)
-
-        return self._apply_bounds(pulse)
diff --git a/qutip/control/pulseoptim.py b/qutip/control/pulseoptim.py
deleted file mode 100644
index b96eec4cfa..0000000000
--- a/qutip/control/pulseoptim.py
+++ /dev/null
@@ -1,1884 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Wrapper functions that will manage the creation of the objects,
-build the configuration, and execute the algorithm required to optimise
-a set of ctrl pulses for a given (quantum) system.
-The fidelity error is some measure of distance of the system evolution
-from the given target evolution in the time allowed for the evolution.
-The functions minimise this fidelity error wrt the piecewise control
-amplitudes in the timeslots
-
-There are currently two quantum control pulse optmisations algorithms
-implemented in this library. There are accessible through the methods
-in this module. Both the algorithms use the scipy.optimize methods
-to minimise the fidelity error with respect to to variables that define
-the pulse.
-
-GRAPE
------
-The default algorithm (as it was implemented here first) is GRAPE
-GRadient Ascent Pulse Engineering [1][2]. It uses a gradient based method such
-as BFGS to minimise the fidelity error. This makes convergence very quick
-when an exact gradient can be calculated, but this limits the factors that can
-taken into account in the fidelity.
-
-CRAB
-----
-The CRAB [3][4] algorithm was developed at the University of Ulm.
-In full it is the Chopped RAndom Basis algorithm.
-The main difference is that it reduces the number of optimisation variables
-by defining the control pulses by expansions of basis functions,
-where the variables are the coefficients. Typically a Fourier series is chosen,
-i.e. the variables are the Fourier coefficients.
-Therefore it does not need to compute an explicit gradient.
-By default it uses the Nelder-Mead method for fidelity error minimisation.
-
-References
-----------
-1.  N Khaneja et. al.
-    Optimal control of coupled spin dynamics: Design of NMR pulse sequences
-    by gradient ascent algorithms. J. Magn. Reson. 172, 296–305 (2005).
-2.  Shai Machnes et.al
-    DYNAMO - Dynamic Framework for Quantum Optimal Control
-    arXiv.1011.4874
-3.  Doria, P., Calarco, T. & Montangero, S.
-    Optimal Control Technique for Many-Body Quantum Dynamics.
-    Phys. Rev. Lett. 106, 1–4 (2011).
-4.  Caneva, T., Calarco, T. & Montangero, S.
-    Chopped random-basis quantum optimization.
-    Phys. Rev. A - At. Mol. Opt. Phys. 84, (2011).
-"""
-
-import numpy as np
-import warnings
-
-# QuTiP
-from qutip import Qobj
-# QuTiP control modules
-import qutip.control.optimconfig as optimconfig
-import qutip.control.dynamics as dynamics
-import qutip.control.termcond as termcond
-import qutip.control.optimizer as optimizer
-import qutip.control.stats as stats
-import qutip.control.errors as errors
-import qutip.control.fidcomp as fidcomp
-import qutip.control.propcomp as propcomp
-import qutip.control.pulsegen as pulsegen
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-
-def _param_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-def _upper_safe(s):
-    try:
-        s = s.upper()
-    except AttributeError:
-        pass
-    return s
-
-
-def optimize_pulse(
-        drift, ctrls, initial, target,
-        num_tslots=None, evo_time=None, tau=None,
-        amp_lbound=None, amp_ubound=None,
-        fid_err_targ=1e-10, min_grad=1e-10,
-        max_iter=500, max_wall_time=180,
-        alg='GRAPE', alg_params=None,
-        optim_params=None, optim_method='DEF', method_params=None,
-        optim_alg=None, max_metric_corr=None, accuracy_factor=None,
-        dyn_type='GEN_MAT', dyn_params=None,
-        prop_type='DEF', prop_params=None,
-        fid_type='DEF', fid_params=None,
-        phase_option=None, fid_err_scale_factor=None,
-        tslot_type='DEF', tslot_params=None,
-        amp_update_mode=None,
-        init_pulse_type='DEF', init_pulse_params=None,
-        pulse_scaling=1.0, pulse_offset=0.0,
-        ramping_pulse_type=None, ramping_pulse_params=None,
-        log_level=logging.NOTSET, out_file_ext=None, gen_stats=False):
-    """
-    Optimise a control pulse to minimise the fidelity error.  The dynamics of
-    the system in any given timeslot are governed by the combined dynamics
-    generator, i.e. the sum of the ``drift + ctrl_amp[j]*ctrls[j]``.
-
-    The control pulse is an ``[n_ts, n_ctrls]`` array of piecewise amplitudes
-    Starting from an initial (typically random) pulse, a multivariable
-    optimisation algorithm attempts to determines the optimal values for the
-    control pulse to minimise the fidelity error.  The fidelity error is some
-    measure of distance of the system evolution from the given target evolution
-    in the time allowed for the evolution.
-
-    Parameters
-    ----------
-    drift : Qobj or list of Qobj
-        The underlying dynamics generator of the system can provide list (of
-        length ``num_tslots``) for time dependent drift.
-
-    ctrls : List of Qobj or array like [num_tslots, evo_time]
-        A list of control dynamics generators. These are scaled by the
-        amplitudes to alter the overall dynamics.  Array-like input can be
-        provided for time dependent control generators.
-
-    initial : Qobj
-        Starting point for the evolution.  Typically the identity matrix.
-
-    target : Qobj
-        Target transformation, e.g. gate or state, for the time evolution.
-
-    num_tslots : integer or None
-        Number of timeslots.  ``None`` implies that timeslots will be given in
-        the tau array.
-
-    evo_time : float or None
-        Total time for the evolution.  ``None`` implies that timeslots will be
-        given in the tau array.
-
-    tau : array[num_tslots] of floats or None
-        Durations for the timeslots.  If this is given then ``num_tslots`` and
-        ``evo_time`` are derived from it.  ``None`` implies that timeslot
-        durations will be equal and calculated as ``evo_time/num_tslots``.
-
-    amp_lbound : float or list of floats
-        Lower boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    amp_ubound : float or list of floats
-        Upper boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    fid_err_targ : float
-        Fidelity error target. Pulse optimisation will terminate when the
-        fidelity error falls below this value.
-
-    mim_grad : float
-        Minimum gradient. When the sum of the squares of the gradients wrt to
-        the control amplitudes falls below this value, the optimisation
-        terminates, assuming local minima.
-
-    max_iter : integer
-        Maximum number of iterations of the optimisation algorithm.
-
-    max_wall_time : float
-        Maximum allowed elapsed time for the  optimisation algorithm.
-
-    alg : string
-        Algorithm to use in pulse optimisation.  Options are:
-
-        - 'GRAPE' (default) - GRadient Ascent Pulse Engineering
-        - 'CRAB' - Chopped RAndom Basis
-
-    alg_params : Dictionary
-        Options that are specific to the algorithm see above.
-
-    optim_params : Dictionary
-        The key value pairs are the attribute name and value used to set
-        attribute values.  Note: attributes are created if they do not exist
-        already, and are overwritten if they do.  Note: ``method_params`` are
-        applied afterwards and so may override these.
-
-    optim_method : string
-        A ``scipy.optimize.minimize`` method that will be used to optimise the
-        pulse for minimum fidelity error.  Note that ``FMIN``, ``FMIN_BFGS`` &
-        ``FMIN_L_BFGS_B`` will all result in calling these specific
-        ``scipy.optimize methods``.  Note the ``LBFGSB`` is equivalent to
-        ``FMIN_L_BFGS_B`` for backwards compatibility reasons.  Supplying DEF
-        will given alg dependent result:
-
-        - GRAPE - Default ``optim_method`` is ``FMIN_L_BFGS_B``
-        - CRAB - Default ``optim_method`` is ``FMIN``
-
-    method_params : dict
-        Parameters for the ``optim_method``.  Note that where there is an
-        attribute of the :obj:`~qutip.control.optimizer.Optimizer` object or
-        the termination_conditions matching the key that attribute.
-        Otherwise, and in some case also, they are assumed to be method_options
-        for the ``scipy.optimize.minimize`` method.
-
-    optim_alg : string
-        Deprecated. Use ``optim_method``.
-
-    max_metric_corr : integer
-        Deprecated. Use ``method_params`` instead.
-
-    accuracy_factor : float
-        Deprecated. Use ``method_params`` instead.
-
-    dyn_type : string
-        Dynamics type, i.e. the type of matrix used to describe the dynamics.
-        Options are ``UNIT``, ``GEN_MAT``, ``SYMPL``
-        (see :obj:`~qutip.control.dynamics.Dynamics` classes for details).
-
-    dyn_params : dict
-        Parameters for the :obj:`~qutip.control.dynamics.Dynamics` object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    prop_type : string
-        Propagator type i.e. the method used to calculate the propagators and
-        propagator gradient for each timeslot options are DEF, APPROX, DIAG,
-        FRECHET, AUG_MAT.  DEF will use the default for the specific
-        ``dyn_type`` (see :obj:`~qutip.control.propcomp.PropagatorComputer`
-        classes for details).
-
-    prop_params : dict
-        Parameters for the :obj:`~qutip.control.propcomp.PropagatorComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs.  They applied after the object is created.
-
-    fid_type : string
-        Fidelity error (and fidelity error gradient) computation method.
-        Options are DEF, UNIT, TRACEDIFF, TD_APPROX.  DEF will use the default
-        for the specific ``dyn_type``
-        (See :obj:`~qutip.control.fidcomp.FidelityComputer` classes for
-        details).
-
-    fid_params : dict
-        Parameters for the :obj:`~qutip.control.fidcomp.FidelityComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs.  They applied after the object is created.
-
-    phase_option : string
-        Deprecated. Pass in ``fid_params`` instead.
-
-    fid_err_scale_factor : float
-        Deprecated. Use ``scale_factor`` key in ``fid_params`` instead.
-
-    tslot_type : string
-        Method for computing the dynamics generators, propagators and evolution
-        in the timeslots.  Options: DEF, UPDATE_ALL, DYNAMIC.  UPDATE_ALL is
-        the only one that currently works.
-        (See :obj:`~qutip.control.tslotcomp.TimeslotComputer` classes for
-        details.)
-
-    tslot_params : dict
-        Parameters for the :obj:`~qutip.control.tslotcomp.TimeslotComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs. They applied after the object is created.
-
-    amp_update_mode : string
-        Deprecated. Use ``tslot_type`` instead.
-
-    init_pulse_type : string
-        Type / shape of pulse(s) used to initialise the control amplitudes.
-        Options (GRAPE) include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW.
-        Default is RND. (see :obj:`~qutip.control.pulsegen.PulseGen` classes
-        for details). For the CRAB the this the ``guess_pulse_type``.
-
-    init_pulse_params : dict
-        Parameters for the initial / guess pulse generator object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    pulse_scaling : float
-        Linear scale factor for generated initial / guess pulses.  By default
-        initial pulses are generated with amplitudes in the range (-1.0, 1.0).
-        These will be scaled by this parameter.
-
-    pulse_offset : float
-        Linear offset for the pulse. That is this value will be added to any
-        initial / guess pulses generated.
-
-    ramping_pulse_type : string
-        Type of pulse used to modulate the control pulse.  It's intended use
-        for a ramping modulation, which is often required in experimental
-        setups.  This is only currently implemented in CRAB.  GAUSSIAN_EDGE was
-        added for this purpose.
-
-    ramping_pulse_params : dict
-        Parameters for the ramping pulse generator object.  The key value pairs
-        are assumed to be attribute name value pairs.  They applied after the
-        object is created.
-
-    log_level : integer
-        Level of messaging output from the logger.  Options are attributes of
-        :obj:`qutip.logging_utils`, in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL.
-        Anything WARN or above is effectively 'quiet' execution, assuming
-        everything runs as expected.  The default NOTSET implies that the level
-        will be taken from the QuTiP settings file, which by default is WARN.
-
-    out_file_ext : string or None
-        Files containing the initial and final control pulse amplitudes are
-        saved to the current directory.  The default name will be postfixed
-        with this extension.  Setting this to None will suppress the output of
-        files.
-
-    gen_stats : boolean
-        If set to True then statistics for the optimisation run will be
-        generated - accessible through attributes of the stats object.
-
-    Returns
-    -------
-    opt : OptimResult
-        Returns instance of :obj:`~qutip.control.optimresult.OptimResult`,
-        which has attributes giving the reason for termination, final fidelity
-        error, final evolution final amplitudes, statistics etc.
-    """
-    if log_level == logging.NOTSET:
-        log_level = logger.getEffectiveLevel()
-    else:
-        logger.setLevel(log_level)
-
-    # The parameters types are checked in create_pulse_optimizer
-    # so no need to do so here
-    # However, the deprecation management is repeated here
-    # so that the stack level is correct
-    if optim_alg is not None:
-        optim_method = optim_alg
-        _param_deprecation(
-            "The 'optim_alg' parameter is deprecated. "
-            "Use 'optim_method' instead")
-
-    if max_metric_corr is not None:
-        if isinstance(method_params, dict):
-            if 'max_metric_corr' not in method_params:
-                method_params['max_metric_corr'] = max_metric_corr
-        else:
-            method_params = {'max_metric_corr': max_metric_corr}
-        _param_deprecation(
-            "The 'max_metric_corr' parameter is deprecated. "
-            "Use 'max_metric_corr' in method_params instead")
-
-    if accuracy_factor is not None:
-        if isinstance(method_params, dict):
-            if 'accuracy_factor' not in method_params:
-                method_params['accuracy_factor'] = accuracy_factor
-        else:
-            method_params = {'accuracy_factor': accuracy_factor}
-        _param_deprecation(
-            "The 'accuracy_factor' parameter is deprecated. "
-            "Use 'accuracy_factor' in method_params instead")
-
-    # phase_option
-    if phase_option is not None:
-        if isinstance(fid_params, dict):
-            if 'phase_option' not in fid_params:
-                fid_params['phase_option'] = phase_option
-        else:
-            fid_params = {'phase_option': phase_option}
-        _param_deprecation(
-            "The 'phase_option' parameter is deprecated. "
-            "Use 'phase_option' in fid_params instead")
-
-    # fid_err_scale_factor
-    if fid_err_scale_factor is not None:
-        if isinstance(fid_params, dict):
-            if 'fid_err_scale_factor' not in fid_params:
-                fid_params['scale_factor'] = fid_err_scale_factor
-        else:
-            fid_params = {'scale_factor': fid_err_scale_factor}
-        _param_deprecation(
-            "The 'fid_err_scale_factor' parameter is deprecated. "
-            "Use 'scale_factor' in fid_params instead")
-
-    # amp_update_mode
-    if amp_update_mode is not None:
-        amp_update_mode_up = _upper_safe(amp_update_mode)
-        if amp_update_mode_up == 'ALL':
-            tslot_type = 'UPDATE_ALL'
-        else:
-            tslot_type = amp_update_mode
-        _param_deprecation(
-            "The 'amp_update_mode' parameter is deprecated. "
-            "Use 'tslot_type' instead")
-
-    optim = create_pulse_optimizer(
-        drift, ctrls, initial, target,
-        num_tslots=num_tslots, evo_time=evo_time, tau=tau,
-        amp_lbound=amp_lbound, amp_ubound=amp_ubound,
-        fid_err_targ=fid_err_targ, min_grad=min_grad,
-        max_iter=max_iter, max_wall_time=max_wall_time,
-        alg=alg, alg_params=alg_params, optim_params=optim_params,
-        optim_method=optim_method, method_params=method_params,
-        dyn_type=dyn_type, dyn_params=dyn_params,
-        prop_type=prop_type, prop_params=prop_params,
-        fid_type=fid_type, fid_params=fid_params,
-        init_pulse_type=init_pulse_type, init_pulse_params=init_pulse_params,
-        pulse_scaling=pulse_scaling, pulse_offset=pulse_offset,
-        ramping_pulse_type=ramping_pulse_type,
-        ramping_pulse_params=ramping_pulse_params,
-        log_level=log_level, gen_stats=gen_stats)
-
-    dyn = optim.dynamics
-
-    dyn.init_timeslots()
-    # Generate initial pulses for each control
-    init_amps = np.zeros([dyn.num_tslots, dyn.num_ctrls])
-
-    if alg == 'CRAB':
-        for j in range(dyn.num_ctrls):
-            pgen = optim.pulse_generator[j]
-            pgen.init_pulse()
-            init_amps[:, j] = pgen.gen_pulse()
-    else:
-        pgen = optim.pulse_generator
-        for j in range(dyn.num_ctrls):
-            init_amps[:, j] = pgen.gen_pulse()
-
-    # Initialise the starting amplitudes
-    dyn.initialize_controls(init_amps)
-
-    if log_level <= logging.INFO:
-        msg = "System configuration:\n"
-        dg_name = "dynamics generator"
-        if dyn_type == 'UNIT':
-            dg_name = "Hamiltonian"
-        if dyn.time_depend_drift:
-            msg += "Initial drift {}:\n".format(dg_name)
-            msg += str(dyn.drift_dyn_gen[0])
-        else:
-            msg += "Drift {}:\n".format(dg_name)
-            msg += str(dyn.drift_dyn_gen)
-        for j in range(dyn.num_ctrls):
-            msg += "\nControl {} {}:\n".format(j+1, dg_name)
-            msg += str(dyn.ctrl_dyn_gen[j])
-        msg += "\nInitial state / operator:\n"
-        msg += str(dyn.initial)
-        msg += "\nTarget state / operator:\n"
-        msg += str(dyn.target)
-        logger.info(msg)
-
-    if out_file_ext is not None:
-        # Save initial amplitudes to a text file
-        pulsefile = "ctrl_amps_initial_" + out_file_ext
-        dyn.save_amps(pulsefile)
-        if log_level <= logging.INFO:
-            logger.info("Initial amplitudes output to file: " + pulsefile)
-
-    # Start the optimisation
-    result = optim.run_optimization()
-
-    if out_file_ext is not None:
-        # Save final amplitudes to a text file
-        pulsefile = "ctrl_amps_final_" + out_file_ext
-        dyn.save_amps(pulsefile)
-        if log_level <= logging.INFO:
-            logger.info("Final amplitudes output to file: " + pulsefile)
-
-    return result
-
-def optimize_pulse_unitary(
-        H_d, H_c, U_0, U_targ,
-        num_tslots=None, evo_time=None, tau=None,
-        amp_lbound=None, amp_ubound=None,
-        fid_err_targ=1e-10, min_grad=1e-10,
-        max_iter=500, max_wall_time=180,
-        alg='GRAPE', alg_params=None,
-        optim_params=None, optim_method='DEF', method_params=None,
-        optim_alg=None, max_metric_corr=None, accuracy_factor=None,
-        phase_option='PSU',
-        dyn_params=None, prop_params=None, fid_params=None,
-        tslot_type='DEF', tslot_params=None,
-        amp_update_mode=None,
-        init_pulse_type='DEF', init_pulse_params=None,
-        pulse_scaling=1.0, pulse_offset=0.0,
-        ramping_pulse_type=None, ramping_pulse_params=None,
-        log_level=logging.NOTSET, out_file_ext=None, gen_stats=False):
-    """
-    Optimise a control pulse to minimise the fidelity error, assuming that the
-    dynamics of the system are generated by unitary operators.  This function
-    is simply a wrapper for optimize_pulse, where the appropriate options for
-    unitary dynamics are chosen and the parameter names are in the format
-    familiar to unitary dynamics The dynamics of the system  in any given
-    timeslot are governed by the combined Hamiltonian, i.e. the sum of the
-    ``H_d + ctrl_amp[j]*H_c[j]`` The control pulse is an ``[n_ts, n_ctrls]``
-    array of piecewise amplitudes Starting from an initial (typically random)
-    pulse, a multivariable optimisation algorithm attempts to determines the
-    optimal values for the control pulse to minimise the fidelity error The
-    maximum fidelity for a unitary system is 1, i.e. when the time evolution
-    resulting from the pulse is equivalent to the target.  And therefore the
-    fidelity error is ``1 - fidelity``.
-
-    Parameters
-    ----------
-    H_d : Qobj or list of Qobj
-        Drift (aka system) the underlying Hamiltonian of the system can provide
-        list (of length ``num_tslots``) for time dependent drift.
-
-    H_c : List of Qobj or array like [num_tslots, evo_time]
-        A list of control Hamiltonians. These are scaled by the amplitudes to
-        alter the overall dynamics.  Array-like input can be provided for time
-        dependent control generators.
-
-    U_0 : Qobj
-        Starting point for the evolution.  Typically the identity matrix.
-
-    U_targ : Qobj
-        Target transformation, e.g. gate or state, for the time evolution.
-
-    num_tslots : integer or None
-        Number of timeslots.  ``None`` implies that timeslots will be given in
-        the tau array.
-
-    evo_time : float or None
-        Total time for the evolution.  ``None`` implies that timeslots will be
-        given in the tau array.
-
-    tau : array[num_tslots] of floats or None
-        Durations for the timeslots.  If this is given then ``num_tslots`` and
-        ``evo_time`` are derived from it.  ``None`` implies that timeslot
-        durations will be equal and calculated as ``evo_time/num_tslots``.
-
-    amp_lbound : float or list of floats
-        Lower boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    amp_ubound : float or list of floats
-        Upper boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    fid_err_targ : float
-        Fidelity error target. Pulse optimisation will terminate when the
-        fidelity error falls below this value.
-
-    mim_grad : float
-        Minimum gradient. When the sum of the squares of the gradients wrt to
-        the control amplitudes falls below this value, the optimisation
-        terminates, assuming local minima.
-
-    max_iter : integer
-        Maximum number of iterations of the optimisation algorithm.
-
-    max_wall_time : float
-        Maximum allowed elapsed time for the optimisation algorithm.
-
-    alg : string
-        Algorithm to use in pulse optimisation.  Options are:
-
-        - 'GRAPE' (default) - GRadient Ascent Pulse Engineering
-        - 'CRAB' - Chopped RAndom Basis
-
-    alg_params : Dictionary
-        options that are specific to the algorithm see above
-
-    optim_params : Dictionary
-        The key value pairs are the attribute name and value used to set
-        attribute values.  Note: attributes are created if they do not exist
-        already, and are overwritten if they do.  Note: ``method_params`` are
-        applied afterwards and so may override these.
-
-    optim_method : string
-        A ``scipy.optimize.minimize`` method that will be used to optimise the
-        pulse for minimum fidelity error Note that ``FMIN``, ``FMIN_BFGS`` &
-        ``FMIN_L_BFGS_B`` will all result in calling these specific
-        scipy.optimize methods Note the ``LBFGSB`` is equivalent to
-        ``FMIN_L_BFGS_B`` for backwards compatibility reasons.  Supplying
-        ``DEF`` will given algorithm-dependent result:
-
-        - GRAPE - Default ``optim_method`` is FMIN_L_BFGS_B
-        - CRAB - Default ``optim_method`` is FMIN
-
-    method_params : dict
-        Parameters for the ``optim_method``.  Note that where there is an
-        attribute of the :obj:`~qutip.control.optimizer.Optimizer` object or
-        the ``termination_conditions`` matching the key that attribute.
-        Otherwise, and in some case also, they are assumed to be
-        method_options for the ``scipy.optimize.minimize`` method.
-
-    optim_alg : string
-        Deprecated. Use ``optim_method``.
-
-    max_metric_corr : integer
-        Deprecated. Use ``method_params`` instead.
-
-    accuracy_factor : float
-        Deprecated. Use ``method_params`` instead.
-
-    phase_option : string
-        Determines how global phase is treated in fidelity calculations
-        (``fid_type='UNIT'`` only). Options:
-
-        - PSU - global phase ignored
-        - SU - global phase included
-
-    dyn_params : dict
-        Parameters for the :obj:`~qutip.control.dynamics.Dynamics` object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    prop_params : dict
-        Parameters for the :obj:`~qutip.control.propcomp.PropagatorComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs.  They applied after the object is created.
-
-    fid_params : dict
-        Parameters for the :obj:`~qutip.control.fidcomp.FidelityComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs.  They applied after the object is created.
-
-    tslot_type : string
-        Method for computing the dynamics generators, propagators and evolution
-        in the timeslots.  Options: ``DEF``, ``UPDATE_ALL``, ``DYNAMIC``.
-        ``UPDATE_ALL`` is the only one that currently works.  (See
-        :obj:`~qutip.control.tslotcomp.TimeslotComputer` classes for details.)
-
-    tslot_params : dict
-        Parameters for the :obj:`~qutip.control.tslotcomp.TimeslotComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs.  They applied after the object is created.
-
-    amp_update_mode : string
-        Deprecated. Use ``tslot_type`` instead.
-
-    init_pulse_type : string
-        Type / shape of pulse(s) used to initialise the control amplitudes.
-        Options (GRAPE) include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW.
-        DEF is RND.  (see :obj:`~qutip.control.pulsegen.PulseGen` classes for
-        details.) For the CRAB the this the guess_pulse_type.
-
-    init_pulse_params : dict
-        Parameters for the initial / guess pulse generator object.  The key
-        value pairs are assumed to be attribute name value pairs.  They applied
-        after the object is created.
-
-    pulse_scaling : float
-        Linear scale factor for generated initial / guess pulses.  By default
-        initial pulses are generated with amplitudes in the range (-1.0, 1.0).
-        These will be scaled by this parameter.
-
-    pulse_offset : float
-        Linear offset for the pulse. That is this value will be added to any
-        initial / guess pulses generated.
-
-    ramping_pulse_type : string
-        Type of pulse used to modulate the control pulse.  It's intended use
-        for a ramping modulation, which is often required in experimental
-        setups.  This is only currently implemented in CRAB.  GAUSSIAN_EDGE was
-        added for this purpose.
-
-    ramping_pulse_params : dict
-        Parameters for the ramping pulse generator object.  The key value pairs
-        are assumed to be attribute name value pairs.  They applied after the
-        object is created.
-
-    log_level : integer
-        Level of messaging output from the logger.  Options are attributes of
-        :obj:`qutip.logging_utils` in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution, assuming
-        everything runs as expected.  The default NOTSET implies that the level
-        will be taken from the QuTiP settings file, which by default is WARN.
-
-    out_file_ext : string or None
-        Files containing the initial and final control pulse amplitudes are
-        saved to the current directory.  The default name will be postfixed
-        with this extension.  Setting this to ``None`` will suppress the output
-        of files.
-
-    gen_stats : boolean
-        If set to ``True`` then statistics for the optimisation run will be
-        generated - accessible through attributes of the stats object.
-
-    Returns
-    -------
-    opt : OptimResult
-        Returns instance of :obj:`~qutip.control.optimresult.OptimResult`,
-        which has attributes giving the reason for termination, final fidelity
-        error, final evolution final amplitudes, statistics etc.
-    """
-
-    # parameters are checked in create pulse optimiser
-
-    # The deprecation management is repeated here
-    # so that the stack level is correct
-    if optim_alg is not None:
-        optim_method = optim_alg
-        _param_deprecation(
-            "The 'optim_alg' parameter is deprecated. "
-            "Use 'optim_method' instead")
-
-    if max_metric_corr is not None:
-        if isinstance(method_params, dict):
-            if 'max_metric_corr' not in method_params:
-                method_params['max_metric_corr'] = max_metric_corr
-        else:
-            method_params = {'max_metric_corr': max_metric_corr}
-        _param_deprecation(
-            "The 'max_metric_corr' parameter is deprecated. "
-            "Use 'max_metric_corr' in method_params instead")
-
-    if accuracy_factor is not None:
-        if isinstance(method_params, dict):
-            if 'accuracy_factor' not in method_params:
-                method_params['accuracy_factor'] = accuracy_factor
-        else:
-            method_params = {'accuracy_factor': accuracy_factor}
-        _param_deprecation(
-            "The 'accuracy_factor' parameter is deprecated. "
-            "Use 'accuracy_factor' in method_params instead")
-
-    # amp_update_mode
-    if amp_update_mode is not None:
-        amp_update_mode_up = _upper_safe(amp_update_mode)
-        if amp_update_mode_up == 'ALL':
-            tslot_type = 'UPDATE_ALL'
-        else:
-            tslot_type = amp_update_mode
-        _param_deprecation(
-            "The 'amp_update_mode' parameter is deprecated. "
-            "Use 'tslot_type' instead")
-
-    # phase_option is still valid for this method
-    # pass it via the fid_params
-    if phase_option is not None:
-        if fid_params is None:
-            fid_params = {'phase_option': phase_option}
-        else:
-            if 'phase_option' not in fid_params:
-                fid_params['phase_option'] = phase_option
-
-    return optimize_pulse(
-            drift=H_d, ctrls=H_c, initial=U_0, target=U_targ,
-            num_tslots=num_tslots, evo_time=evo_time, tau=tau,
-            amp_lbound=amp_lbound, amp_ubound=amp_ubound,
-            fid_err_targ=fid_err_targ, min_grad=min_grad,
-            max_iter=max_iter, max_wall_time=max_wall_time,
-            alg=alg, alg_params=alg_params, optim_params=optim_params,
-            optim_method=optim_method, method_params=method_params,
-            dyn_type='UNIT', dyn_params=dyn_params,
-            prop_params=prop_params, fid_params=fid_params,
-            init_pulse_type=init_pulse_type,
-            init_pulse_params=init_pulse_params,
-            pulse_scaling=pulse_scaling, pulse_offset=pulse_offset,
-            ramping_pulse_type=ramping_pulse_type,
-            ramping_pulse_params=ramping_pulse_params,
-            log_level=log_level, out_file_ext=out_file_ext,
-            gen_stats=gen_stats)
-
-
-def opt_pulse_crab(
-        drift, ctrls, initial, target,
-        num_tslots=None, evo_time=None, tau=None,
-        amp_lbound=None, amp_ubound=None,
-        fid_err_targ=1e-5,
-        max_iter=500, max_wall_time=180,
-        alg_params=None,
-        num_coeffs=None, init_coeff_scaling=1.0,
-        optim_params=None, optim_method='fmin', method_params=None,
-        dyn_type='GEN_MAT', dyn_params=None,
-        prop_type='DEF', prop_params=None,
-        fid_type='DEF', fid_params=None,
-        tslot_type='DEF', tslot_params=None,
-        guess_pulse_type=None, guess_pulse_params=None,
-        guess_pulse_scaling=1.0, guess_pulse_offset=0.0,
-        guess_pulse_action='MODULATE',
-        ramping_pulse_type=None, ramping_pulse_params=None,
-        log_level=logging.NOTSET, out_file_ext=None, gen_stats=False):
-    """
-    Optimise a control pulse to minimise the fidelity error.
-    The dynamics of the system in any given timeslot are governed
-    by the combined dynamics generator,
-    i.e. the sum of the drift+ctrl_amp[j]*ctrls[j]
-    The control pulse is an [n_ts, n_ctrls] array of piecewise amplitudes.
-    The CRAB algorithm uses basis function coefficents as the variables to
-    optimise. It does NOT use any gradient function.
-    A multivariable optimisation algorithm attempts to determines the
-    optimal values for the control pulse to minimise the fidelity error
-    The fidelity error is some measure of distance of the system evolution
-    from the given target evolution in the time allowed for the evolution.
-
-    Parameters
-    ----------
-    drift : Qobj or list of Qobj
-        the underlying dynamics generator of the system
-        can provide list (of length num_tslots) for time dependent drift
-
-    ctrls : List of Qobj or array like [num_tslots, evo_time]
-        a list of control dynamics generators. These are scaled by
-        the amplitudes to alter the overall dynamics
-        Array like imput can be provided for time dependent control generators
-
-    initial : Qobj
-        Starting point for the evolution.  Typically the identity matrix.
-
-    target : Qobj
-        Target transformation, e.g. gate or state, for the time evolution.
-
-    num_tslots : integer or None
-        Number of timeslots.  ``None`` implies that timeslots will be given in
-        the tau array.
-
-    evo_time : float or None
-        Total time for the evolution.  ``None`` implies that timeslots will be
-        given in the tau array.
-
-    tau : array[num_tslots] of floats or None
-        Durations for the timeslots.  If this is given then ``num_tslots`` and
-        ``evo_time`` are dervived from it.
-        ``None`` implies that timeslot durations will be equal and calculated
-        as ``evo_time/num_tslots``.
-
-    amp_lbound : float or list of floats
-        Lower boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    amp_ubound : float or list of floats
-        Upper boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    fid_err_targ : float
-        Fidelity error target. Pulse optimisation will terminate when the
-        fidelity error falls below this value.
-
-    max_iter : integer
-        Maximum number of iterations of the optimisation algorithm.
-
-    max_wall_time : float
-        Maximum allowed elapsed time for the  optimisation algorithm.
-
-    alg_params : Dictionary
-        Options that are specific to the algorithm see above.
-
-    optim_params : Dictionary
-        The key value pairs are the attribute name and value used to set
-        attribute values.  Note: attributes are created if they do not exist
-        already, and are overwritten if they do.  Note: method_params are
-        applied afterwards and so may override these.
-
-    coeff_scaling : float
-        Linear scale factor for the random basis coefficients.  By default
-        these range from -1.0 to 1.0.  Note this is overridden by alg_params
-        (if given there).
-
-    num_coeffs : integer
-        Number of coefficients used for each basis function.  Note this is
-        calculated automatically based on the dimension of the dynamics if not
-        given. It is crucial to the performane of the algorithm that it is set
-        as low as possible, while still giving high enough frequencies.  Note
-        this is overridden by alg_params (if given there).
-
-    optim_method : string
-        Multi-variable optimisation method.  The only tested options are 'fmin'
-        and 'Nelder-mead'.  In theory any non-gradient method implemented in
-        scipy.optimize.mininize could be used.
-
-    method_params : dict
-        Parameters for the optim_method.  Note that where there is an attribute
-        of the :class:`~qutip.control.optimizer.Optimizer` object or the
-        termination_conditions matching the key that attribute. Otherwise,
-        and in some case also, they are assumed to be method_options for the
-        ``scipy.optimize.minimize`` method.  The commonly used parameter are:
-
-        - xtol - limit on variable change for convergence
-        - ftol - limit on fidelity error change for convergence
-
-    dyn_type : string
-        Dynamics type, i.e. the type of matrix used to describe the dynamics.
-        Options are UNIT, GEN_MAT, SYMPL (see Dynamics classes for details).
-
-    dyn_params : dict
-        Parameters for the :class:`qutip.control.dynamics.Dynamics` object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    prop_type : string
-        Propagator type i.e. the method used to calculate the propagtors and
-        propagtor gradient for each timeslot options are DEF, APPROX, DIAG,
-        FRECHET, AUG_MAT DEF will use the default for the specific dyn_type
-        (see :obj:`~qutip.control.propcomp.PropagatorComputer` classes for
-        details).
-
-    prop_params : dict
-        Parameters for the :obj:`~qutip.control.propcomp.PropagatorComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs. They applied after the object is created.
-
-    fid_type : string
-        Fidelity error (and fidelity error gradient) computation method.
-        Options are DEF, UNIT, TRACEDIFF, TD_APPROX.  DEF will use the default
-        for the specific dyn_type.
-        (See :obj:`~qutip.control.fidcomp.FidelityComputer` classes for
-        details).
-
-    fid_params : dict
-        Parameters for the :obj:`~qutip.control.fidcomp.FidelityComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs. They applied after the object is created.
-
-    tslot_type : string
-        Method for computing the dynamics generators, propagators and evolution
-        in the timeslots.  Options: DEF, UPDATE_ALL, DYNAMIC UPDATE_ALL is the
-        only one that currently works.
-        (See :obj:`~qutip.control.tslotcomp.TimeslotComputer` classes
-        for details).
-
-    tslot_params : dict
-        Parameters for the :obj:`~qutip.control.tslotcomp.TimeslotComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs. They applied after the object is created.
-
-    guess_pulse_type : string, default None
-        Type / shape of pulse(s) used modulate the control amplitudes.
-        Options include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW, GAUSSIAN.
-
-    guess_pulse_params : dict
-        Parameters for the guess pulse generator object.  The key value pairs
-        are assumed to be attribute name value pairs.  They applied after the
-        object is created.
-
-    guess_pulse_action : string, default 'MODULATE'
-        Determines how the guess pulse is applied to the pulse generated by the
-        basis expansion.  Options are: MODULATE, ADD.
-
-    pulse_scaling : float
-        Linear scale factor for generated guess pulses.  By default initial
-        pulses are generated with amplitudes in the range (-1.0, 1.0). These
-        will be scaled by this parameter.
-
-    pulse_offset : float
-        Linear offset for the pulse. That is this value will be added to any
-        guess pulses generated.
-
-    ramping_pulse_type : string
-        Type of pulse used to modulate the control pulse.  It's intended use
-        for a ramping modulation, which is often required in experimental
-        setups.  This is only currently implemented in CRAB.  GAUSSIAN_EDGE was
-        added for this purpose.
-
-    ramping_pulse_params : dict
-        Parameters for the ramping pulse generator object.  The key value pairs
-        are assumed to be attribute name value pairs.  They applied after the
-        object is created.
-
-    log_level : integer
-        level of messaging output from the logger.  Options are attributes of
-        :obj:`qutip.logging_utils`, in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution, assuming
-        everything runs as expected.  The default NOTSET implies that the level
-        will be taken from the QuTiP settings file, which by default is WARN.
-
-    out_file_ext : string or None
-        Files containing the initial and final control pulse.  Amplitudes are
-        saved to the current directory.  The default name will be postfixed
-        with this extension.  Setting this to ``None`` will suppress the output
-        of files.
-
-    gen_stats : boolean
-        If set to ``True`` then statistics for the optimisation run will be
-        generated - accessible through attributes of the stats object.
-
-    Returns
-    -------
-    opt : OptimResult
-        Returns instance of OptimResult, which has attributes giving the
-        reason for termination, final fidelity error, final evolution
-        final amplitudes, statistics etc
-    """
-
-    # The parameters are checked in create_pulse_optimizer
-    # so no need to do so here
-
-    if log_level == logging.NOTSET:
-        log_level = logger.getEffectiveLevel()
-    else:
-        logger.setLevel(log_level)
-
-    # build the algorithm options
-    if not isinstance(alg_params, dict):
-        alg_params = {'num_coeffs': num_coeffs,
-                      'init_coeff_scaling': init_coeff_scaling}
-    else:
-        if (num_coeffs is not None and 'num_coeffs' not in alg_params):
-            alg_params['num_coeffs'] = num_coeffs
-        if (
-            init_coeff_scaling is not None
-            and 'init_coeff_scaling' not in alg_params
-        ):
-            alg_params['init_coeff_scaling'] = init_coeff_scaling
-
-    # Build the guess pulse options
-    # Any options passed in the guess_pulse_params take precedence
-    # over the parameter values.
-    if guess_pulse_type:
-        if not isinstance(guess_pulse_params, dict):
-            guess_pulse_params = {}
-        if (guess_pulse_scaling is not None
-                and 'scaling' not in guess_pulse_params):
-            guess_pulse_params['scaling'] = guess_pulse_scaling
-        if (guess_pulse_offset is not None
-                and 'offset' not in guess_pulse_params):
-            guess_pulse_params['offset'] = guess_pulse_offset
-        if (guess_pulse_action is not None
-                and 'pulse_action' not in guess_pulse_params):
-            guess_pulse_params['pulse_action'] = guess_pulse_action
-
-    return optimize_pulse(
-        drift, ctrls, initial, target,
-        num_tslots=num_tslots, evo_time=evo_time, tau=tau,
-        amp_lbound=amp_lbound, amp_ubound=amp_ubound,
-        fid_err_targ=fid_err_targ, min_grad=0.0,
-        max_iter=max_iter, max_wall_time=max_wall_time,
-        alg='CRAB', alg_params=alg_params, optim_params=optim_params,
-        optim_method=optim_method, method_params=method_params,
-        dyn_type=dyn_type, dyn_params=dyn_params,
-        prop_type=prop_type, prop_params=prop_params,
-        fid_type=fid_type, fid_params=fid_params,
-        tslot_type=tslot_type, tslot_params=tslot_params,
-        init_pulse_type=guess_pulse_type,
-        init_pulse_params=guess_pulse_params,
-        ramping_pulse_type=ramping_pulse_type,
-        ramping_pulse_params=ramping_pulse_params,
-        log_level=log_level, out_file_ext=out_file_ext, gen_stats=gen_stats)
-
-
-def opt_pulse_crab_unitary(
-        H_d, H_c, U_0, U_targ,
-        num_tslots=None, evo_time=None, tau=None,
-        amp_lbound=None, amp_ubound=None,
-        fid_err_targ=1e-5,
-        max_iter=500, max_wall_time=180,
-        alg_params=None,
-        num_coeffs=None, init_coeff_scaling=1.0,
-        optim_params=None, optim_method='fmin', method_params=None,
-        phase_option='PSU',
-        dyn_params=None, prop_params=None, fid_params=None,
-        tslot_type='DEF', tslot_params=None,
-        guess_pulse_type=None, guess_pulse_params=None,
-        guess_pulse_scaling=1.0, guess_pulse_offset=0.0,
-        guess_pulse_action='MODULATE',
-        ramping_pulse_type=None, ramping_pulse_params=None,
-        log_level=logging.NOTSET, out_file_ext=None, gen_stats=False):
-    """
-    Optimise a control pulse to minimise the fidelity error, assuming that the
-    dynamics of the system are generated by unitary operators.  This function
-    is simply a wrapper for optimize_pulse, where the appropriate options for
-    unitary dynamics are chosen and the parameter names are in the format
-    familiar to unitary dynamics.  The dynamics of the system  in any given
-    timeslot are governed by the combined Hamiltonian, i.e. the sum of the
-    ``H_d + ctrl_amp[j]*H_c[j]`` The control pulse is an ``[n_ts, n_ctrls]``
-    array of piecewise amplitudes.
-
-    The CRAB algorithm uses basis function coefficents as the variables to
-    optimise. It does NOT use any gradient function.  A multivariable
-    optimisation algorithm attempts to determines the optimal values for the
-    control pulse to minimise the fidelity error.  The fidelity error is some
-    measure of distance of the system evolution from the given target evolution
-    in the time allowed for the evolution.
-
-    Parameters
-    ----------
-
-    H_d : Qobj or list of Qobj
-        Drift (aka system) the underlying Hamiltonian of the system can provide
-        list (of length num_tslots) for time dependent drift.
-
-    H_c : List of Qobj or array like [num_tslots, evo_time]
-        A list of control Hamiltonians. These are scaled by the amplitudes to
-        alter the overall dynamics.  Array like imput can be provided for time
-        dependent control generators.
-
-    U_0 : Qobj
-        Starting point for the evolution.  Typically the identity matrix.
-
-    U_targ : Qobj
-        Target transformation, e.g. gate or state, for the time evolution.
-
-    num_tslots : integer or None
-        Number of timeslots.  ``None`` implies that timeslots will be given in
-        the tau array.
-
-    evo_time : float or None
-        Total time for the evolution.  ``None`` implies that timeslots will be
-        given in the tau array.
-
-    tau : array[num_tslots] of floats or None
-        Durations for the timeslots.  If this is given then ``num_tslots`` and
-        ``evo_time`` are derived from it.  ``None`` implies that timeslot
-        durations will be equal and calculated as ``evo_time/num_tslots``.
-
-    amp_lbound : float or list of floats
-        Lower boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    amp_ubound : float or list of floats
-        Upper boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    fid_err_targ : float
-        Fidelity error target. Pulse optimisation will terminate when the
-        fidelity error falls below this value.
-
-    max_iter : integer
-        Maximum number of iterations of the optimisation algorithm.
-
-    max_wall_time : float
-        Maximum allowed elapsed time for the optimisation algorithm.
-
-    alg_params : Dictionary
-        Options that are specific to the algorithm see above.
-
-    optim_params : Dictionary
-        The key value pairs are the attribute name and value used to set
-        attribute values.  Note: attributes are created if they do not exist
-        already, and are overwritten if they do.  Note: ``method_params`` are
-        applied afterwards and so may override these.
-
-    coeff_scaling : float
-        Linear scale factor for the random basis coefficients.  By default
-        these range from -1.0 to 1.0.  Note this is overridden by
-        ``alg_params`` (if given there).
-
-    num_coeffs : integer
-        Number of coefficients used for each basis function.  Note this is
-        calculated automatically based on the dimension of the dynamics if not
-        given. It is crucial to the performance of the algorithm that it is set
-        as low as possible, while still giving high enough frequencies.  Note
-        this is overridden by ``alg_params`` (if given there).
-
-    optim_method : string
-        Multi-variable optimisation method.  The only tested options are 'fmin'
-        and 'Nelder-mead'.  In theory any non-gradient method implemented in
-        ``scipy.optimize.minimize`` could be used.
-
-    method_params : dict
-        Parameters for the ``optim_method``.  Note that where there is an
-        attribute of the :obj:`~qutip.control.optimizer.Optimizer` object or
-        the termination_conditions matching the key that attribute. Otherwise,
-        and in some case also, they are assumed to be method_options for the
-        ``scipy.optimize.minimize`` method.  The commonly used parameter are:
-
-        - xtol - limit on variable change for convergence
-        - ftol - limit on fidelity error change for convergence
-
-    phase_option : string
-        Determines how global phase is treated in fidelity calculations
-        (``fid_type='UNIT'`` only). Options:
-
-        - PSU - global phase ignored
-        - SU - global phase included
-
-    dyn_params : dict
-        Parameters for the :obj:`~qutip.control.dynamics.Dynamics` object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    prop_params : dict
-        Parameters for the :obj:`~qutip.control.propcomp.PropagatorComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs.  They applied after the object is created.
-
-    fid_params : dict
-        Parameters for the :obj:`~qutip.control.fidcomp.FidelityComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs. They applied after the object is created.
-
-    tslot_type : string
-        Method for computing the dynamics generators, propagators and evolution
-        in the timeslots.  Options: DEF, UPDATE_ALL, DYNAMIC.  UPDATE_ALL is
-        the only one that currently works.
-        (See :obj:`~qutip.control.tslotcomp.TimeslotComputer` classes for
-        details).
-
-    tslot_params : dict
-        Parameters for the :obj:`~qutip.control.tslotcomp.TimeslotComputer`
-        object. The key value pairs are assumed to be attribute name value
-        pairs. They applied after the object is created.
-
-    guess_pulse_type : string, optional
-        Type / shape of pulse(s) used modulate the control amplitudes.
-        Options include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW, GAUSSIAN.
-
-    guess_pulse_params : dict
-        Parameters for the guess pulse generator object.  The key value pairs
-        are assumed to be attribute name value pairs.  They applied after the
-        object is created.
-
-    guess_pulse_action : string, 'MODULATE'
-        Determines how the guess pulse is applied to the pulse generated by the
-        basis expansion.  Options are: MODULATE, ADD.
-
-    pulse_scaling : float
-        Linear scale factor for generated guess pulses.  By default initial
-        pulses are generated with amplitudes in the range (-1.0, 1.0). These
-        will be scaled by this parameter.
-
-    pulse_offset : float
-        Linear offset for the pulse. That is this value will be added to any
-        guess pulses generated.
-
-    ramping_pulse_type : string
-        Type of pulse used to modulate the control pulse.  It's intended use
-        for a ramping modulation, which is often required in experimental
-        setups.  This is only currently implemented in CRAB.  GAUSSIAN_EDGE was
-        added for this purpose.
-
-    ramping_pulse_params : dict
-        Parameters for the ramping pulse generator object.  The key value pairs
-        are assumed to be attribute name value pairs.  They applied after the
-        object is created.
-
-    log_level : integer
-        Level of messaging output from the logger.  Options are attributes of
-        :obj:`qutip.logging_utils`, in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL.
-        Anything WARN or above is effectively 'quiet' execution, assuming
-        everything runs as expected.  The default NOTSET implies that the level
-        will be taken from the QuTiP settings file, which by default is WARN.
-
-    out_file_ext : string or None
-        Files containing the initial and final control pulse amplitudes are
-        saved to the current directory.  The default name will be postfixed
-        with this extension.  Setting this to None will suppress the output of
-        files.
-
-    gen_stats : boolean
-        If set to ``True`` then statistics for the optimisation run will be
-        generated - accessible through attributes of the stats object.
-
-    Returns
-    -------
-    opt : OptimResult
-        Returns instance of :obj:`~qutip.control.optimresult.OptimResult`,
-        which has attributes giving the reason for termination, final fidelity
-        error, final evolution final amplitudes, statistics etc.
-    """
-
-    # The parameters are checked in create_pulse_optimizer
-    # so no need to do so here
-
-    if log_level == logging.NOTSET:
-        log_level = logger.getEffectiveLevel()
-    else:
-        logger.setLevel(log_level)
-
-    # build the algorithm options
-    if not isinstance(alg_params, dict):
-        alg_params = {'num_coeffs': num_coeffs,
-                      'init_coeff_scaling': init_coeff_scaling}
-    else:
-        if (num_coeffs is not None
-                and 'num_coeffs' not in alg_params):
-            alg_params['num_coeffs'] = num_coeffs
-        if (init_coeff_scaling is not None
-                and 'init_coeff_scaling' not in alg_params):
-            alg_params['init_coeff_scaling'] = init_coeff_scaling
-
-    # Build the guess pulse options
-    # Any options passed in the guess_pulse_params take precedence
-    # over the parameter values.
-    if guess_pulse_type:
-        if not isinstance(guess_pulse_params, dict):
-            guess_pulse_params = {}
-        if (guess_pulse_scaling is not None
-                and 'scaling' not in guess_pulse_params):
-            guess_pulse_params['scaling'] = guess_pulse_scaling
-        if (guess_pulse_offset is not None
-                and 'offset' not in guess_pulse_params):
-            guess_pulse_params['offset'] = guess_pulse_offset
-        if (guess_pulse_action is not None
-                and 'pulse_action' not in guess_pulse_params):
-            guess_pulse_params['pulse_action'] = guess_pulse_action
-
-    return optimize_pulse_unitary(
-        H_d, H_c, U_0, U_targ,
-        num_tslots=num_tslots, evo_time=evo_time, tau=tau,
-        amp_lbound=amp_lbound, amp_ubound=amp_ubound,
-        fid_err_targ=fid_err_targ, min_grad=0.0,
-        max_iter=max_iter, max_wall_time=max_wall_time,
-        alg='CRAB', alg_params=alg_params, optim_params=optim_params,
-        optim_method=optim_method, method_params=method_params,
-        phase_option=phase_option,
-        dyn_params=dyn_params, prop_params=prop_params, fid_params=fid_params,
-        tslot_type=tslot_type, tslot_params=tslot_params,
-        init_pulse_type=guess_pulse_type,
-        init_pulse_params=guess_pulse_params,
-        ramping_pulse_type=ramping_pulse_type,
-        ramping_pulse_params=ramping_pulse_params,
-        log_level=log_level, out_file_ext=out_file_ext, gen_stats=gen_stats)
-
-
-def create_pulse_optimizer(
-        drift, ctrls, initial, target,
-        num_tslots=None, evo_time=None, tau=None,
-        amp_lbound=None, amp_ubound=None,
-        fid_err_targ=1e-10, min_grad=1e-10,
-        max_iter=500, max_wall_time=180,
-        alg='GRAPE', alg_params=None,
-        optim_params=None, optim_method='DEF', method_params=None,
-        optim_alg=None, max_metric_corr=None, accuracy_factor=None,
-        dyn_type='GEN_MAT', dyn_params=None,
-        prop_type='DEF', prop_params=None,
-        fid_type='DEF', fid_params=None,
-        phase_option=None, fid_err_scale_factor=None,
-        tslot_type='DEF', tslot_params=None,
-        amp_update_mode=None,
-        init_pulse_type='DEF', init_pulse_params=None,
-        pulse_scaling=1.0, pulse_offset=0.0,
-        ramping_pulse_type=None, ramping_pulse_params=None,
-        log_level=logging.NOTSET, gen_stats=False):
-    """
-    Generate the objects of the appropriate subclasses required for the pulse
-    optmisation based on the parameters given Note this method may be
-    preferable to calling optimize_pulse if more detailed configuration is
-    required before running the optmisation algorthim, or the algorithm will be
-    run many times, for instances when trying to finding global the optimum or
-    minimum time optimisation
-
-    Parameters
-    ----------
-    drift : Qobj or list of Qobj
-        The underlying dynamics generator of the system can provide list (of
-        length num_tslots) for time dependent drift.
-
-    ctrls : List of Qobj or array like [num_tslots, evo_time]
-        A list of control dynamics generators. These are scaled by the
-        amplitudes to alter the overall dynamics.  Array-like input can be
-        provided for time dependent control generators.
-
-    initial : Qobj
-        Starting point for the evolution.  Typically the identity matrix.
-
-    target : Qobj
-        Target transformation, e.g. gate or state, for the time evolution.
-
-    num_tslots : integer or None
-        Number of timeslots.  ``None`` implies that timeslots will be given in
-        the tau array.
-
-    evo_time : float or None
-        Total time for the evolution.  ``None`` implies that timeslots will be
-        given in the tau array.
-
-    tau : array[num_tslots] of floats or None
-        Durations for the timeslots.  If this is given then ``num_tslots`` and
-        ``evo_time`` are dervived from it.  ``None`` implies that timeslot
-        durations will be equal and calculated as ``evo_time/num_tslots``.
-
-    amp_lbound : float or list of floats
-        Lower boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    amp_ubound : float or list of floats
-        Upper boundaries for the control amplitudes.  Can be a scalar value
-        applied to all controls or a list of bounds for each control.
-
-    fid_err_targ : float
-        Fidelity error target. Pulse optimisation will terminate when the
-        fidelity error falls below this value.
-
-    mim_grad : float
-        Minimum gradient. When the sum of the squares of the gradients wrt to
-        the control amplitudes falls below this value, the optimisation
-        terminates, assuming local minima.
-
-    max_iter : integer
-        Maximum number of iterations of the optimisation algorithm.
-
-    max_wall_time : float
-        Maximum allowed elapsed time for the optimisation algorithm.
-
-    alg : string
-        Algorithm to use in pulse optimisation.
-        Options are:
-
-        - 'GRAPE' (default) - GRadient Ascent Pulse Engineering
-        - 'CRAB' - Chopped RAndom Basis
-
-    alg_params : Dictionary
-        options that are specific to the algorithm see above
-
-    optim_params : Dictionary
-        The key value pairs are the attribute name and value used to set
-        attribute values.  Note: attributes are created if they do not exist
-        already, and are overwritten if they do.  Note: method_params are
-        applied afterwards and so may override these.
-
-    optim_method : string
-        a scipy.optimize.minimize method that will be used to optimise
-        the pulse for minimum fidelity error
-        Note that FMIN, FMIN_BFGS & FMIN_L_BFGS_B will all result
-        in calling these specific scipy.optimize methods
-        Note the LBFGSB is equivalent to FMIN_L_BFGS_B for backwards
-        capatibility reasons.
-        Supplying DEF will given alg dependent result:
-
-        - GRAPE - Default optim_method is FMIN_L_BFGS_B
-        - CRAB - Default optim_method is Nelder-Mead
-
-    method_params : dict
-        Parameters for the optim_method.
-        Note that where there is an attribute of the
-        :class:`~qutip.control.optimizer.Optimizer` object or the
-        termination_conditions matching the key that attribute. Otherwise,
-        and in some case also, they are assumed to be method_options
-        for the scipy.optimize.minimize method.
-
-    optim_alg : string
-        Deprecated. Use optim_method.
-
-    max_metric_corr : integer
-        Deprecated. Use method_params instead
-
-    accuracy_factor : float
-        Deprecated. Use method_params instead
-
-    dyn_type : string
-        Dynamics type, i.e. the type of matrix used to describe
-        the dynamics. Options are UNIT, GEN_MAT, SYMPL
-        (see Dynamics classes for details)
-
-    dyn_params : dict
-        Parameters for the Dynamics object
-        The key value pairs are assumed to be attribute name value pairs
-        They applied after the object is created
-
-    prop_type : string
-        Propagator type i.e. the method used to calculate the
-        propagtors and propagtor gradient for each timeslot
-        options are DEF, APPROX, DIAG, FRECHET, AUG_MAT
-        DEF will use the default for the specific dyn_type
-        (see PropagatorComputer classes for details)
-
-    prop_params : dict
-        Parameters for the PropagatorComputer object
-        The key value pairs are assumed to be attribute name value pairs
-        They applied after the object is created
-
-    fid_type : string
-        Fidelity error (and fidelity error gradient) computation method
-        Options are DEF, UNIT, TRACEDIFF, TD_APPROX
-        DEF will use the default for the specific dyn_type
-        (See FidelityComputer classes for details)
-
-    fid_params : dict
-        Parameters for the FidelityComputer object
-        The key value pairs are assumed to be attribute name value pairs
-        They applied after the object is created
-
-    phase_option : string
-        Deprecated. Pass in fid_params instead.
-
-    fid_err_scale_factor : float
-        Deprecated. Use scale_factor key in fid_params instead.
-
-    tslot_type : string
-        Method for computing the dynamics generators, propagators and
-        evolution in the timeslots.
-        Options: DEF, UPDATE_ALL, DYNAMIC
-        UPDATE_ALL is the only one that currently works
-        (See TimeslotComputer classes for details)
-
-    tslot_params : dict
-        Parameters for the TimeslotComputer object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    amp_update_mode : string
-        Deprecated. Use tslot_type instead.
-
-    init_pulse_type : string
-        type / shape of pulse(s) used to initialise the
-        the control amplitudes.
-        Options (GRAPE) include:
-
-            RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW
-            DEF is RND
-
-        (see PulseGen classes for details)
-        For the CRAB the this the guess_pulse_type.
-
-    init_pulse_params : dict
-        Parameters for the initial / guess pulse generator object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created.
-
-    pulse_scaling : float
-        Linear scale factor for generated initial / guess pulses
-        By default initial pulses are generated with amplitudes in the
-        range (-1.0, 1.0). These will be scaled by this parameter
-
-    pulse_offset : float
-        Linear offset for the pulse. That is this value will be added
-        to any initial / guess pulses generated.
-
-    ramping_pulse_type : string
-        Type of pulse used to modulate the control pulse.
-        It's intended use for a ramping modulation, which is often required in
-        experimental setups.
-        This is only currently implemented in CRAB.
-        GAUSSIAN_EDGE was added for this purpose.
-
-    ramping_pulse_params : dict
-        Parameters for the ramping pulse generator object.
-        The key value pairs are assumed to be attribute name value pairs.
-        They applied after the object is created
-
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip.logging_utils,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-
-    gen_stats : boolean
-        if set to True then statistics for the optimisation
-        run will be generated - accessible through attributes
-        of the stats object
-
-    Returns
-    -------
-    opt : Optimizer
-        Instance of an Optimizer, through which the
-        Config, Dynamics, PulseGen, and TerminationConditions objects
-        can be accessed as attributes.
-        The PropagatorComputer, FidelityComputer and TimeslotComputer objects
-        can be accessed as attributes of the Dynamics object,
-        e.g. optimizer.dynamics.fid_computer The optimisation can be run
-        through the optimizer.run_optimization
-
-    """
-
-    # check parameters
-    ctrls = dynamics._check_ctrls_container(ctrls)
-    dynamics._check_drift_dyn_gen(drift)
-
-    if not isinstance(initial, Qobj):
-        raise TypeError("initial must be a Qobj")
-
-    if not isinstance(target, Qobj):
-        raise TypeError("target must be a Qobj")
-
-    # Deprecated parameter management
-    if optim_alg is not None:
-        optim_method = optim_alg
-        _param_deprecation(
-            "The 'optim_alg' parameter is deprecated. "
-            "Use 'optim_method' instead")
-
-    if max_metric_corr is not None:
-        if isinstance(method_params, dict):
-            if 'max_metric_corr' not in method_params:
-                method_params['max_metric_corr'] = max_metric_corr
-        else:
-            method_params = {'max_metric_corr': max_metric_corr}
-        _param_deprecation(
-            "The 'max_metric_corr' parameter is deprecated. "
-            "Use 'max_metric_corr' in method_params instead")
-
-    if accuracy_factor is not None:
-        if isinstance(method_params, dict):
-            if 'accuracy_factor' not in method_params:
-                method_params['accuracy_factor'] = accuracy_factor
-        else:
-            method_params = {'accuracy_factor': accuracy_factor}
-        _param_deprecation(
-            "The 'accuracy_factor' parameter is deprecated. "
-            "Use 'accuracy_factor' in method_params instead")
-
-    # phase_option
-    if phase_option is not None:
-        if isinstance(fid_params, dict):
-            if 'phase_option' not in fid_params:
-                fid_params['phase_option'] = phase_option
-        else:
-            fid_params = {'phase_option': phase_option}
-        _param_deprecation(
-            "The 'phase_option' parameter is deprecated. "
-            "Use 'phase_option' in fid_params instead")
-
-    # fid_err_scale_factor
-    if fid_err_scale_factor is not None:
-        if isinstance(fid_params, dict):
-            if 'fid_err_scale_factor' not in fid_params:
-                fid_params['scale_factor'] = fid_err_scale_factor
-        else:
-            fid_params = {'scale_factor': fid_err_scale_factor}
-        _param_deprecation(
-            "The 'fid_err_scale_factor' parameter is deprecated. "
-            "Use 'scale_factor' in fid_params instead")
-
-    # amp_update_mode
-    if amp_update_mode is not None:
-        amp_update_mode_up = _upper_safe(amp_update_mode)
-        if amp_update_mode_up == 'ALL':
-            tslot_type = 'UPDATE_ALL'
-        else:
-            tslot_type = amp_update_mode
-        _param_deprecation(
-            "The 'amp_update_mode' parameter is deprecated. "
-            "Use 'tslot_type' instead")
-
-    # set algorithm defaults
-    alg_up = _upper_safe(alg)
-    if alg is None:
-        raise errors.UsageError(
-            "Optimisation algorithm must be specified through 'alg' parameter")
-    elif alg_up == 'GRAPE':
-        if optim_method is None or optim_method.upper() == 'DEF':
-            optim_method = 'FMIN_L_BFGS_B'
-        if init_pulse_type is None or init_pulse_type.upper() == 'DEF':
-            init_pulse_type = 'RND'
-    elif alg_up == 'CRAB':
-        if optim_method is None or optim_method.upper() == 'DEF':
-            optim_method = 'FMIN'
-        if prop_type is None or prop_type.upper() == 'DEF':
-            prop_type = 'APPROX'
-        if init_pulse_type is None or init_pulse_type.upper() == 'DEF':
-            init_pulse_type = None
-    else:
-        raise errors.UsageError(
-            "No option for pulse optimisation algorithm alg={}".format(alg))
-
-    cfg = optimconfig.OptimConfig()
-    cfg.optim_method = optim_method
-    cfg.dyn_type = dyn_type
-    cfg.prop_type = prop_type
-    cfg.fid_type = fid_type
-    cfg.init_pulse_type = init_pulse_type
-
-    if log_level == logging.NOTSET:
-        log_level = logger.getEffectiveLevel()
-    else:
-        logger.setLevel(log_level)
-
-    cfg.log_level = log_level
-
-    # Create the Dynamics instance
-    if dyn_type == 'GEN_MAT' or dyn_type is None or dyn_type == '':
-        dyn = dynamics.DynamicsGenMat(cfg)
-    elif dyn_type == 'UNIT':
-        dyn = dynamics.DynamicsUnitary(cfg)
-    elif dyn_type == 'SYMPL':
-        dyn = dynamics.DynamicsSymplectic(cfg)
-    else:
-        raise errors.UsageError("No option for dyn_type: " + dyn_type)
-    dyn.apply_params(dyn_params)
-    dyn._drift_dyn_gen_checked = True
-    dyn._ctrl_dyn_gen_checked = True
-
-    # Create the PropagatorComputer instance
-    # The default will be typically be the best option
-    if prop_type == 'DEF' or prop_type is None or prop_type == '':
-        # Do nothing use the default for the Dynamics
-        pass
-    elif prop_type == 'APPROX':
-        if not isinstance(dyn.prop_computer, propcomp.PropCompApproxGrad):
-            dyn.prop_computer = propcomp.PropCompApproxGrad(dyn)
-    elif prop_type == 'DIAG':
-        if not isinstance(dyn.prop_computer, propcomp.PropCompDiag):
-            dyn.prop_computer = propcomp.PropCompDiag(dyn)
-    elif prop_type == 'AUG_MAT':
-        if not isinstance(dyn.prop_computer, propcomp.PropCompAugMat):
-            dyn.prop_computer = propcomp.PropCompAugMat(dyn)
-    elif prop_type == 'FRECHET':
-        if not isinstance(dyn.prop_computer, propcomp.PropCompFrechet):
-            dyn.prop_computer = propcomp.PropCompFrechet(dyn)
-    else:
-        raise errors.UsageError("No option for prop_type: " + prop_type)
-    dyn.prop_computer.apply_params(prop_params)
-
-    # Create the FidelityComputer instance
-    # The default will be typically be the best option
-    # Note: the FidCompTraceDiffApprox is a subclass of FidCompTraceDiff
-    # so need to check this type first
-    fid_type_up = _upper_safe(fid_type)
-    if fid_type_up == 'DEF' or fid_type_up is None or fid_type_up == '':
-        # None given, use the default for the Dynamics
-        pass
-    elif fid_type_up == 'TDAPPROX':
-        if not isinstance(dyn.fid_computer, fidcomp.FidCompTraceDiffApprox):
-            dyn.fid_computer = fidcomp.FidCompTraceDiffApprox(dyn)
-    elif fid_type_up == 'TRACEDIFF':
-        if not isinstance(dyn.fid_computer, fidcomp.FidCompTraceDiff):
-            dyn.fid_computer = fidcomp.FidCompTraceDiff(dyn)
-    elif fid_type_up == 'UNIT':
-        if not isinstance(dyn.fid_computer, fidcomp.FidCompUnitary):
-            dyn.fid_computer = fidcomp.FidCompUnitary(dyn)
-    else:
-        raise errors.UsageError("No option for fid_type: " + fid_type)
-    dyn.fid_computer.apply_params(fid_params)
-
-    # Currently the only working option for tslot computer is
-    # TSlotCompUpdateAll.
-    # so just apply the parameters
-    dyn.tslot_computer.apply_params(tslot_params)
-
-    # Create the Optimiser instance
-    optim_method_up = _upper_safe(optim_method)
-    if optim_method is None or optim_method_up == '':
-        raise errors.UsageError("Optimisation method must be specified "
-                                "via 'optim_method' parameter")
-    elif optim_method_up == 'FMIN_BFGS':
-        optim = optimizer.OptimizerBFGS(cfg, dyn)
-    elif optim_method_up == 'LBFGSB' or optim_method_up == 'FMIN_L_BFGS_B':
-        optim = optimizer.OptimizerLBFGSB(cfg, dyn)
-    elif optim_method_up == 'FMIN':
-        if alg_up == 'CRAB':
-            optim = optimizer.OptimizerCrabFmin(cfg, dyn)
-        else:
-            raise errors.UsageError(
-                "Invalid optim_method '{}' for '{}' algorthim".format(
-                                    optim_method, alg))
-    else:
-        # Assume that the optim_method is a valid
-        # scipy.optimize.minimize method
-        # Choose an optimiser based on the algorithm
-        if alg_up == 'CRAB':
-            optim = optimizer.OptimizerCrab(cfg, dyn)
-        else:
-            optim = optimizer.Optimizer(cfg, dyn)
-
-    optim.alg = alg
-    optim.method = optim_method
-    optim.amp_lbound = amp_lbound
-    optim.amp_ubound = amp_ubound
-    optim.apply_params(optim_params)
-
-    # Create the TerminationConditions instance
-    tc = termcond.TerminationConditions()
-    tc.fid_err_targ = fid_err_targ
-    tc.min_gradient_norm = min_grad
-    tc.max_iterations = max_iter
-    tc.max_wall_time = max_wall_time
-    optim.termination_conditions = tc
-
-    optim.apply_method_params(method_params)
-
-    if gen_stats:
-        # Create a stats object
-        # Note that stats object is optional
-        # if the Dynamics and Optimizer stats attribute is not set
-        # then no stats will be collected, which could improve performance
-        if amp_update_mode == 'DYNAMIC':
-            sts = stats.StatsDynTsUpdate()
-        else:
-            sts = stats.Stats()
-
-        dyn.stats = sts
-        optim.stats = sts
-
-    # Configure the dynamics
-    dyn.drift_dyn_gen = drift
-    dyn.ctrl_dyn_gen = ctrls
-    dyn.initial = initial
-    dyn.target = target
-    if tau is None:
-        # Check that parameters have been supplied to generate the
-        # timeslot durations
-        try:
-            evo_time / num_tslots
-        except Exception:
-            raise errors.UsageError(
-                "Either the timeslot durations should be supplied as an "
-                "array 'tau' or the number of timeslots 'num_tslots' "
-                "and the evolution time 'evo_time' must be given.")
-
-        dyn.num_tslots = num_tslots
-        dyn.evo_time = evo_time
-    else:
-        dyn.tau = tau
-
-    # this function is called, so that the num_ctrls attribute will be set
-    n_ctrls = dyn.num_ctrls
-
-    ramping_pgen = None
-    if ramping_pulse_type:
-        ramping_pgen = pulsegen.create_pulse_gen(
-                            pulse_type=ramping_pulse_type, dyn=dyn,
-                            pulse_params=ramping_pulse_params)
-    if alg_up == 'CRAB':
-        # Create a pulse generator for each ctrl
-        crab_pulse_params = None
-        num_coeffs = None
-        init_coeff_scaling = None
-        if isinstance(alg_params, dict):
-            num_coeffs = alg_params.get('num_coeffs')
-            init_coeff_scaling = alg_params.get('init_coeff_scaling')
-            if 'crab_pulse_params' in alg_params:
-                crab_pulse_params = alg_params.get('crab_pulse_params')
-
-        guess_pulse_type = init_pulse_type
-        if guess_pulse_type:
-            guess_pulse_action = None
-            guess_pgen = pulsegen.create_pulse_gen(
-                                pulse_type=guess_pulse_type, dyn=dyn)
-            guess_pgen.scaling = pulse_scaling
-            guess_pgen.offset = pulse_offset
-            if init_pulse_params is not None:
-                guess_pgen.apply_params(init_pulse_params)
-                guess_pulse_action = init_pulse_params.get('pulse_action')
-
-        optim.pulse_generator = []
-        for j in range(n_ctrls):
-            crab_pgen = pulsegen.PulseGenCrabFourier(
-                                dyn=dyn, num_coeffs=num_coeffs)
-            if init_coeff_scaling is not None:
-                crab_pgen.scaling = init_coeff_scaling
-            if isinstance(crab_pulse_params, dict):
-                crab_pgen.apply_params(crab_pulse_params)
-
-            lb = None
-            if amp_lbound:
-                if isinstance(amp_lbound, list):
-                    try:
-                        lb = amp_lbound[j]
-                    except Exception:
-                        lb = amp_lbound[-1]
-                else:
-                    lb = amp_lbound
-            ub = None
-            if amp_ubound:
-                if isinstance(amp_ubound, list):
-                    try:
-                        ub = amp_ubound[j]
-                    except Exception:
-                        ub = amp_ubound[-1]
-                else:
-                    ub = amp_ubound
-            crab_pgen.lbound = lb
-            crab_pgen.ubound = ub
-
-            if guess_pulse_type:
-                guess_pgen.lbound = lb
-                guess_pgen.ubound = ub
-                crab_pgen.guess_pulse = guess_pgen.gen_pulse()
-                if guess_pulse_action:
-                    crab_pgen.guess_pulse_action = guess_pulse_action
-
-            if ramping_pgen:
-                crab_pgen.ramping_pulse = ramping_pgen.gen_pulse()
-
-            optim.pulse_generator.append(crab_pgen)
-        # This is just for the debug message now
-        pgen = optim.pulse_generator[0]
-
-    else:
-        # Create a pulse generator of the type specified
-        pgen = pulsegen.create_pulse_gen(pulse_type=init_pulse_type, dyn=dyn,
-                                         pulse_params=init_pulse_params)
-        pgen.scaling = pulse_scaling
-        pgen.offset = pulse_offset
-        pgen.lbound = amp_lbound
-        pgen.ubound = amp_ubound
-
-        optim.pulse_generator = pgen
-
-    if log_level <= logging.DEBUG:
-        logger.debug(
-            "Optimisation config summary...\n"
-            "  object classes:\n"
-            "    optimizer: " + optim.__class__.__name__ +
-            "\n    dynamics: " + dyn.__class__.__name__ +
-            "\n    tslotcomp: " + dyn.tslot_computer.__class__.__name__ +
-            "\n    fidcomp: " + dyn.fid_computer.__class__.__name__ +
-            "\n    propcomp: " + dyn.prop_computer.__class__.__name__ +
-            "\n    pulsegen: " + pgen.__class__.__name__)
-    return optim
diff --git a/qutip/control/stats.py b/qutip/control/stats.py
deleted file mode 100644
index d5e3b33b4c..0000000000
--- a/qutip/control/stats.py
+++ /dev/null
@@ -1,383 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Statistics for the optimisation
-Note that some of the stats here are redundant copies from the optimiser
-used here for calculations
-"""
-import numpy as np
-import datetime
-
-
-class Stats(object):
-    """
-    Base class for all optimisation statistics
-    Used for configurations where all timeslots are updated each iteration
-    e.g. exact gradients
-    Note that all times are generated using timeit.default_timer() and are
-    in seconds
-
-    Attributes
-    ----------
-    dyn_gen_name : string
-        Text used in some report functions.
-        Makes sense to set it to 'Hamiltonian' when using unitary dynamics
-        Default is simply 'dynamics generator'
-
-    num_iter : integer
-        Number of iterations of the optimisation algorithm
-
-    wall_time_optim_start : float
-        Start time for the optimisation
-
-    wall_time_optim_end : float
-        End time for the optimisation
-
-    wall_time_optim : float
-        Time elasped during the optimisation
-
-    wall_time_dyn_gen_compute : float
-        Total wall (elasped) time computing combined dynamics generator
-        (for example combining drift and control Hamiltonians)
-
-    wall_time_prop_compute : float
-        Total wall (elasped) time computing propagators, that is the
-        time evolution from one timeslot to the next
-        Includes calculating the propagator gradient for exact gradients
-
-    wall_time_fwd_prop_compute : float
-        Total wall (elasped) time computing combined forward propagation,
-        that is the time evolution from the start to a specific timeslot.
-        Excludes calculating the propagators themselves
-
-    wall_time_onwd_prop_compute : float
-        Total wall (elasped) time computing combined onward propagation,
-        that is the time evolution from a specific timeslot to the end time.
-        Excludes calculating the propagators themselves
-
-    wall_time_gradient_compute : float
-        Total wall (elasped) time computing the fidelity error gradient.
-        Excludes calculating the propagator gradients (in exact gradient
-        methods)
-
-    num_fidelity_func_calls : integer
-        Number of calls to fidelity function by the optimisation algorithm
-
-    num_grad_func_calls : integer
-        Number of calls to gradient function by the optimisation algorithm
-
-    num_tslot_recompute : integer
-        Number of time the timeslot evolution is recomputed
-        (It is only computed if any amplitudes changed since the last call)
-
-    num_fidelity_computes : integer
-        Number of time the fidelity is computed
-        (It is only computed if any amplitudes changed since the last call)
-
-    num_grad_computes : integer
-        Number of time the gradient is computed
-        (It is only computed if any amplitudes changed since the last call)
-
-    num_ctrl_amp_updates : integer
-        Number of times the control amplitudes are updated
-
-    mean_num_ctrl_amp_updates_per_iter : float
-        Mean number of control amplitude updates per iteration
-
-    num_timeslot_changes : integer
-        Number of times the amplitudes of a any control in a timeslot changes
-
-    mean_num_timeslot_changes_per_update : float
-        Mean average number of timeslot amplitudes that are changed per update
-
-    num_ctrl_amp_changes : integer
-        Number of times individual control amplitudes that are changed
-
-    mean_num_ctrl_amp_changes_per_update : float
-        Mean average number of control amplitudes that are changed per update
-    """
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.dyn_gen_name = "dynamics generator"
-        self.clear()
-
-    def clear(self):
-        self.num_iter = 0
-        # Duration attributes
-        self.wall_time_optim_start = 0.0
-        self.wall_time_optim_end = 0.0
-        self.wall_time_optim = 0.0
-        self.wall_time_dyn_gen_compute = 0.0
-        self.wall_time_prop_compute = 0.0
-        self.wall_time_fwd_prop_compute = 0.0
-        self.wall_time_onwd_prop_compute = 0.0
-        self.wall_time_gradient_compute = 0.0
-        # Fidelity and gradient function calls and computes
-        self.num_fidelity_func_calls = 0
-        self.num_grad_func_calls = 0
-        self.num_tslot_recompute = 0
-        self.num_fidelity_computes = 0
-        self.num_grad_computes = 0
-        # Control amplitudes
-        self.num_ctrl_amp_updates = 0
-        self.mean_num_ctrl_amp_updates_per_iter = 0.0
-        self.num_timeslot_changes = 0
-        self.mean_num_timeslot_changes_per_update = 0.0
-        self.num_ctrl_amp_changes = 0
-        self.mean_num_ctrl_amp_changes_per_update = 0.0
-
-    def calculate(self):
-        """
-        Perform the calculations (e.g. averages) that are required on the stats
-        Should be called before calling report
-        """
-        # If the optimation is still running then the optimisation
-        # time is the time so far
-        if self.wall_time_optim_end > 0.0:
-            self.wall_time_optim = \
-                self.wall_time_optim_end - self.wall_time_optim_start
-
-        try:
-            self.mean_num_ctrl_amp_updates_per_iter = \
-                self.num_ctrl_amp_updates / float(self.num_iter)
-        except Exception:
-            self.mean_num_ctrl_amp_updates_per_iter = np.NaN
-
-        try:
-            self.mean_num_timeslot_changes_per_update = \
-                self.num_timeslot_changes / float(self.num_ctrl_amp_updates)
-        except Exception:
-            self.mean_num_timeslot_changes_per_update = np.NaN
-
-        try:
-            self.mean_num_ctrl_amp_changes_per_update = \
-                self.num_ctrl_amp_changes / float(self.num_ctrl_amp_updates)
-        except Exception:
-            self.mean_num_ctrl_amp_changes_per_update = np.NaN
-
-    def _format_datetime(self, t, tot=0.0):
-        dtStr = str(datetime.timedelta(seconds=t))
-        if tot > 0:
-            percent = 100*t/tot
-            dtStr += " ({:03.2f}%)".format(percent)
-        return dtStr
-
-    def report(self):
-        """
-        Print a report of the stats to the console
-        """
-        print("\n------------------------------------"
-              "\n---- Control optimisation stats ----")
-        self.report_timings()
-        self.report_func_calls()
-        self.report_amp_updates()
-        print("------------------------------------")
-
-    def report_timings(self):
-        print("**** Timings (HH:MM:SS.US) ****")
-        tot = self.wall_time_optim
-        print("Total wall time elapsed during optimisation: " +
-              self._format_datetime(tot))
-        print("Wall time computing Hamiltonians: " +
-              self._format_datetime(self.wall_time_dyn_gen_compute, tot))
-        print("Wall time computing propagators: " +
-              self._format_datetime(self.wall_time_prop_compute, tot))
-        print("Wall time computing forward propagation: " +
-              self._format_datetime(self.wall_time_fwd_prop_compute, tot))
-        print("Wall time computing onward propagation: " +
-              self._format_datetime(self.wall_time_onwd_prop_compute, tot))
-        print("Wall time computing gradient: " +
-              self._format_datetime(self.wall_time_gradient_compute, tot))
-        print("")
-
-    def report_func_calls(self):
-        print("**** Iterations and function calls ****")
-        print("Number of iterations: {}".format(self.num_iter))
-        print("Number of fidelity function calls: "
-              "{}".format(self.num_fidelity_func_calls))
-        print("Number of times fidelity is computed: "
-              "{}".format(self.num_fidelity_computes))
-        print("Number of gradient function calls: "
-              "{}".format(self.num_grad_func_calls))
-        print("Number of times gradients are computed: "
-              "{}".format(self.num_grad_computes))
-        print("Number of times timeslot evolution is recomputed: "
-              "{}".format(self.num_tslot_recompute))
-        print("")
-
-    def report_amp_updates(self):
-        print("**** Control amplitudes ****")
-        print("Number of control amplitude updates: "
-              "{}".format(self.num_ctrl_amp_updates))
-        print("Mean number of updates per iteration: "
-              "{}".format(self.mean_num_ctrl_amp_updates_per_iter))
-        print("Number of timeslot values changed: "
-              "{}".format(self.num_timeslot_changes))
-        print("Mean number of timeslot changes per update: "
-              "{}".format(self.mean_num_timeslot_changes_per_update))
-        print("Number of amplitude values changed: "
-              "{}".format(self.num_ctrl_amp_changes))
-        print("Mean number of amplitude changes per update: "
-              "{}".format(self.mean_num_ctrl_amp_changes_per_update))
-
-
-class StatsDynTsUpdate(Stats):
-    """
-    Optimisation stats class for configurations where all timeslots are not
-    necessarily updated at each iteration. In this case it may be interesting
-    to know how many Hamiltions etc are computed each ctrl amplitude update
-
-    Attributes
-    ----------
-    num_dyn_gen_computes : integer
-        Total number of dynamics generator (Hamiltonian) computations,
-        that is combining drift and control dynamics to calculate the
-        combined dynamics generator for the timeslot
-
-    mean_num_dyn_gen_computes_per_update : float
-        # Mean average number of dynamics generator computations per update
-
-    mean_wall_time_dyn_gen_compute : float
-        # Mean average time to compute a timeslot dynamics generator
-
-    num_prop_computes : integer
-        Total number of propagator (and propagator gradient for exact
-        gradient types) computations
-
-    mean_num_prop_computes_per_update : float
-        Mean average number of propagator computations per update
-
-    mean_wall_time_prop_compute : float
-        Mean average time to compute a propagator (and its gradient)
-
-    num_fwd_prop_step_computes : integer
-        Total number of steps (matrix product) computing forward propagation
-
-    mean_num_fwd_prop_step_computes_per_update : float
-        Mean average number of steps computing forward propagation
-
-    mean_wall_time_fwd_prop_compute : float
-        Mean average time to compute forward propagation
-
-    num_onwd_prop_step_computes : integer
-        Total number of steps (matrix product) computing onward propagation
-
-    mean_num_onwd_prop_step_computes_per_update : float
-        Mean average number of steps computing onward propagation
-
-    mean_wall_time_onwd_prop_compute
-        Mean average time to compute onward propagation
-    """
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        Stats.reset(self)
-        # Dynamics generators (Hamiltonians)
-        self.num_dyn_gen_computes = 0
-        self.mean_num_dyn_gen_computes_per_update = 0.0
-        self.mean_wall_time_dyn_gen_compute = 0.0
-        # **** Propagators *****
-        self.num_prop_computes = 0
-        self.mean_num_prop_computes_per_update = 0.0
-        self.mean_wall_time_prop_compute = 0.0
-        # **** Forward propagation ****
-        self.num_fwd_prop_step_computes = 0
-        self.mean_num_fwd_prop_step_computes_per_update = 0.0
-        self.mean_wall_time_fwd_prop_compute = 0.0
-        # **** onward propagation ****
-        self.num_onwd_prop_step_computes = 0
-        self.mean_num_onwd_prop_step_computes_per_update = 0.0
-        self.mean_wall_time_onwd_prop_compute = 0.0
-
-    def calculate(self):
-        Stats.calculate(self)
-        self.mean_num_dyn_gen_computes_per_update = \
-            self.num_dyn_gen_computes / float(self.num_ctrl_amp_updates)
-
-        self.mean_wall_time_dyn_gen_compute = \
-            (self.wall_time_dyn_gen_compute /
-             float(self.num_dyn_gen_computes))
-
-        self.mean_num_prop_computes_per_update = \
-            self.num_prop_computes / float(self.num_ctrl_amp_updates)
-
-        self.mean_wall_time_prop_compute = \
-            self.wall_time_prop_compute / float(self.num_prop_computes)
-
-        self.mean_num_fwd_prop_step_computes_per_update = \
-            (self.num_fwd_prop_step_computes /
-             float(self.num_ctrl_amp_updates))
-
-        self.mean_wall_time_fwd_prop_compute = \
-            (self.wall_time_fwd_prop_compute /
-             float(self.num_fwd_prop_step_computes))
-
-        self.mean_num_onwd_prop_step_computes_per_update = \
-            (self.num_onwd_prop_step_computes /
-             float(self.num_ctrl_amp_updates))
-
-        self.mean_wall_time_onwd_prop_compute = \
-            (self.wall_time_onwd_prop_compute /
-             float(self.num_onwd_prop_step_computes))
-
-    def report(self):
-        """
-        Print a report of the stats to the console
-        """
-
-        print("\n------------------------------------"
-              "\n---- Control optimisation stats ----")
-        self.report_timings()
-        self.report_func_calls()
-        self.report_amp_updates()
-        self.report_dyn_gen_comps()
-        self.report_fwd_prop()
-        self.report_onwd_prop()
-        print("------------------------------------")
-
-    def report_dyn_gen_comps(self):
-        print("**** {} Computations ****".format(self.dyn_gen_name))
-        print("Total number of {} computations: "
-              "{}".format(self.dyn_gen_name, self.num_dyn_gen_computes))
-        print("Mean number of {} computations per update: "
-              "{}".format(self.dyn_gen_name,
-                          self.mean_num_dyn_gen_computes_per_update))
-        print("Mean wall time to compute {}s: "
-              "{} s".format(self.dyn_gen_name,
-                            self.mean_wall_time_dyn_gen_compute))
-        print("**** Propagator Computations ****")
-        print("Total number of propagator computations: "
-              "{}".format(self.num_prop_computes))
-        print("Mean number of propagator computations per update: "
-              "{}".format(self.mean_num_prop_computes_per_update))
-        print("Mean wall time to compute propagator "
-              "{} s".format(self.mean_wall_time_prop_compute))
-
-    def report_fwd_prop(self):
-        print("**** Forward Propagation ****")
-        print("Total number of forward propagation step computations: "
-              "{}".format(self.num_fwd_prop_step_computes))
-        print("Mean number of forward propagation step computations"
-              " per update: "
-              "{}".format(self.mean_num_fwd_prop_step_computes_per_update))
-        print("Mean wall time to compute forward propagation "
-              "{} s".format(self.mean_wall_time_fwd_prop_compute))
-
-    def report_onwd_prop(self):
-        print("**** Onward Propagation ****")
-        print("Total number of onward propagation step computations: "
-              "{}".format(self.num_onwd_prop_step_computes))
-        print("Mean number of onward propagation step computations"
-              " per update: "
-              "{}".format(self.mean_num_onwd_prop_step_computes_per_update))
-        print("Mean wall time to compute onward propagation "
-              "{} s".format(self.mean_wall_time_onwd_prop_compute))
diff --git a/qutip/control/symplectic.py b/qutip/control/symplectic.py
deleted file mode 100644
index 20189ebcaa..0000000000
--- a/qutip/control/symplectic.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Utility functions for symplectic matrices
-"""
-
-import numpy as np
-
-
-def calc_omega(n):
-    """
-    Calculate the 2n x 2n Omega matrix
-    Used as dynamics generator phase to calculate symplectic propagators
-
-    Parameters
-    ----------
-    n : scalar(int)
-        number of modes in oscillator system
-
-    Returns
-    -------
-    array(float)
-        Symplectic phase Omega
-    """
-
-    omg = np.zeros((2*n, 2*n))
-    for j in range(2*n):
-        for k in range(2*n):
-            if k == j+1:
-                omg[j, k] = (1 + (-1)**j)/2
-            if k == j-1:
-                omg[j, k] = -(1 - (-1)**j)/2
-
-    return omg
diff --git a/qutip/control/termcond.py b/qutip/control/termcond.py
deleted file mode 100644
index a390b3c9d8..0000000000
--- a/qutip/control/termcond.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Classes containing termination conditions for the control pulse optimisation
-i.e. attributes that will be checked during the optimisation, that
-will determine if the algorithm has completed its task / exceeded limits
-"""
-
-
-class TerminationConditions:
-    """
-    Base class for all termination conditions
-    Used to determine when to stop the optimisation algorithm
-    Note different subclasses should be used to match the type of
-    optimisation being used
-
-    Attributes
-    ----------
-    fid_err_targ : float
-        Target fidelity error
-
-    fid_goal : float
-        goal fidelity, e.g. 1 - self.fid_err_targ
-        It its typical to set this for unitary systems
-
-    max_wall_time : float
-        # maximum time for optimisation (seconds)
-
-    min_gradient_norm : float
-        Minimum normalised gradient after which optimisation will terminate
-
-    max_iterations : integer
-        Maximum iterations of the optimisation algorithm
-
-    max_fid_func_calls : integer
-        Maximum number of calls to the fidelity function during
-        the optimisation algorithm
-        
-    accuracy_factor : float
-        Determines the accuracy of the result.
-        Typical values for accuracy_factor are: 1e12 for low accuracy;
-        1e7 for moderate accuracy; 10.0 for extremely high accuracy
-        scipy.optimize.fmin_l_bfgs_b factr argument.
-        Only set for specific methods (fmin_l_bfgs_b) that uses this
-        Otherwise the same thing is passed as method_option ftol
-        (although the scale is different)
-        Hence it is not defined here, but may be set by the user
-    """
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.fid_err_targ = 1e-5
-        self.fid_goal = None
-        self.max_wall_time = 60*60.0
-        self.min_gradient_norm = 1e-5
-        self.max_iterations = 1e10
-        self.max_fid_func_calls = 1e10
diff --git a/qutip/control/tslotcomp.py b/qutip/control/tslotcomp.py
deleted file mode 100644
index 1ce070d26c..0000000000
--- a/qutip/control/tslotcomp.py
+++ /dev/null
@@ -1,704 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-
-"""
-Timeslot Computer
-These classes determine which dynamics generators, propagators and evolutions
-are recalculated when there is a control amplitude update.
-The timeslot computer processes the lists held by the dynamics object
-
-The default (UpdateAll) updates all of these each amp update, on the
-assumption that all amplitudes are changed each iteration. This is typical
-when using optimisation methods like BFGS in the GRAPE algorithm
-
-The alternative (DynUpdate) assumes that only a subset of amplitudes
-are updated each iteration and attempts to minimise the number of expensive
-calculations accordingly. This would be the appropriate class for Krotov type
-methods. Note that the Stats_DynTsUpdate class must be used for stats
-in conjunction with this class.
-NOTE: AJGP 2011-10-2014: This _DynUpdate class currently has some bug,
-no pressing need to fix it presently
-
-If all amplitudes change at each update, then the behavior of the classes is
-equivalent. _UpdateAll is easier to understand and potentially slightly faster
-in this situation.
-
-Note the methods in the _DynUpdate class were inspired by:
-DYNAMO - Dynamic Framework for Quantum Optimal Control
-See Machnes et.al., arXiv.1011.4874
-"""
-
-import warnings
-import numpy as np
-import timeit
-# QuTiP
-from qutip import Qobj
-# QuTiP control modules
-import qutip.control.errors as errors
-import qutip.control.dump as qtrldump
-# QuTiP logging
-import qutip.logging_utils as logging
-logger = logging.get_logger()
-
-
-def _func_deprecation(message, stacklevel=3):
-    """
-    Issue deprecation warning
-    Using stacklevel=3 will ensure message refers the function
-    calling with the deprecated parameter,
-    """
-    warnings.warn(message, FutureWarning, stacklevel=stacklevel)
-
-
-class TimeslotComputer:
-    """
-    Base class for all Timeslot Computers
-    Note: this must be instantiated with a Dynamics object, that is the
-    container for the data that the methods operate on
-
-    Attributes
-    ----------
-    log_level : integer
-        level of messaging output from the logger.
-        Options are attributes of qutip.logging_utils,
-        in decreasing levels of messaging, are:
-        DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL
-        Anything WARN or above is effectively 'quiet' execution,
-        assuming everything runs as expected.
-        The default NOTSET implies that the level will be taken from
-        the QuTiP settings file, which by default is WARN
-
-    evo_comp_summary : EvoCompSummary
-        A summary of the most recent evolution computation
-        Used in the stats and dump
-        Will be set to None if neither stats or dump are set
-    """
-    def __init__(self, dynamics, params=None):
-        from qutip.control.dynamics import Dynamics
-        if not isinstance(dynamics, Dynamics):
-            raise TypeError("Must instantiate with {} type".format(
-                                        Dynamics))
-        self.parent = dynamics
-        self.params = params
-        self.reset()
-
-    def reset(self):
-        self.log_level = self.parent.log_level
-        self.id_text = 'TS_COMP_BASE'
-        self.evo_comp_summary = None
-
-    def apply_params(self, params=None):
-        """
-        Set object attributes based on the dictionary (if any) passed in the
-        instantiation, or passed as a parameter
-        This is called during the instantiation automatically.
-        The key value pairs are the attribute name and value
-        Note: attributes are created if they do not exist already,
-        and are overwritten if they do.
-        """
-        if not params:
-            params = self.params
-
-        if isinstance(params, dict):
-            self.params = params
-            for key in params:
-                setattr(self, key, params[key])
-
-    def flag_all_calc_now(self):
-        pass
-
-    def init_comp(self):
-        pass
-
-    @property
-    def log_level(self):
-        return logger.level
-
-    @log_level.setter
-    def log_level(self, lvl):
-        """
-        Set the log_level attribute and set the level of the logger
-        that is call logger.setLevel(lvl)
-        """
-        logger.setLevel(lvl)
-
-    def dump_current(self):
-        """Store a copy of the current time evolution"""
-        dyn = self.parent
-        dump = dyn.dump
-        if not isinstance(dump, qtrldump.DynamicsDump):
-            raise RuntimeError("Cannot dump current evolution, "
-                               "as dynamics.dump is not set")
-
-        anything_dumped = False
-        item_idx = None
-        if dump.dump_any:
-            dump_item = dump.add_evo_dump()
-            item_idx = dump_item.idx
-            anything_dumped = True
-
-        if dump.dump_summary:
-            dump.add_evo_comp_summary(dump_item_idx=item_idx)
-            anything_dumped = True
-
-        if not anything_dumped:
-            logger.warning("Dump set, but nothing dumped, check dump config")
-
-
-class TSlotCompUpdateAll(TimeslotComputer):
-    """
-    Timeslot Computer - Update All
-    Updates all dynamics generators, propagators and evolutions when
-    ctrl amplitudes are updated
-    """
-    def reset(self):
-        TimeslotComputer.reset(self)
-        self.id_text = 'ALL'
-        self.apply_params()
-
-    def compare_amps(self, new_amps):
-        """
-        Determine if any amplitudes have changed. If so, then mark the
-        timeslots as needing recalculation
-        Returns: True if amplitudes are the same, False if they have changed
-        """
-        changed = False
-        dyn = self.parent
-
-        if (dyn.stats or dyn.dump):
-            if self.evo_comp_summary:
-                self.evo_comp_summary.reset()
-            else:
-                self.evo_comp_summary = EvoCompSummary()
-        ecs = self.evo_comp_summary
-
-        if dyn.ctrl_amps is None:
-            # Flag fidelity and gradients as needing recalculation
-            changed = True
-            if ecs:
-                ecs.num_amps_changed = len(new_amps.flat)
-                ecs.num_timeslots_changed = new_amps.shape[0]
-        else:
-            # create boolean array with same shape as ctrl_amps
-            # True where value in new_amps differs, otherwise false
-            changed_amps = dyn.ctrl_amps != new_amps
-            if np.any(changed_amps):
-                # Flag fidelity and gradients as needing recalculation
-                changed = True
-                if self.log_level <= logging.DEBUG:
-                    logger.debug("{} amplitudes changed".format(
-                        changed_amps.sum()))
-
-                if ecs:
-                    ecs.num_amps_changed = changed_amps.sum()
-                    ecs.num_timeslots_changed = np.any(changed_amps, 1).sum()
-
-            else:
-                if self.log_level <= logging.DEBUG:
-                    logger.debug("No amplitudes changed")
-
-        # *** update stats ***
-        if dyn.stats:
-            dyn.stats.num_ctrl_amp_updates += bool(ecs.num_amps_changed)
-            dyn.stats.num_ctrl_amp_changes += ecs.num_amps_changed
-            dyn.stats.num_timeslot_changes += ecs.num_timeslots_changed
-
-        if changed:
-            dyn.ctrl_amps = new_amps
-            dyn.flag_system_changed()
-            return False
-        else:
-            return True
-
-    def recompute_evolution(self):
-        """
-        Recalculates the evolution operators.
-        Dynamics generators (e.g. Hamiltonian) and
-        prop (propagators) are calculated as necessary
-        """
-
-        dyn = self.parent
-        prop_comp = dyn.prop_computer
-        n_ts = dyn.num_tslots
-        n_ctrls = dyn.num_ctrls
-
-        # Clear the public lists
-        # These are only set if (external) users access them
-        dyn._dyn_gen_qobj = None
-        dyn._prop_qobj = None
-        dyn._prop_grad_qobj = None
-        dyn._fwd_evo_qobj = None
-        dyn._onwd_evo_qobj = None
-        dyn._onto_evo_qobj = None
-
-        if (dyn.stats or dyn.dump) and not self.evo_comp_summary:
-            self.evo_comp_summary = EvoCompSummary()
-        ecs = self.evo_comp_summary
-
-        if dyn.stats is not None:
-            dyn.stats.num_tslot_recompute += 1
-            if self.log_level <= logging.DEBUG:
-                logger.log(logging.DEBUG, "recomputing evolution {} "
-                           "(UpdateAll)".format(
-                               dyn.stats.num_tslot_recompute))
-
-        # calculate the Hamiltonians
-        if ecs:
-            time_start = timeit.default_timer()
-        for k in range(n_ts):
-            dyn._combine_dyn_gen(k)
-            if dyn._decomp_curr is not None:
-                dyn._decomp_curr[k] = False
-
-        if ecs:
-            ecs.wall_time_dyn_gen_compute = \
-                timeit.default_timer() - time_start
-
-        # calculate the propagators and the propagotor gradients
-        if ecs:
-            time_start = timeit.default_timer()
-        for k in range(n_ts):
-            if prop_comp.grad_exact and dyn.cache_prop_grad:
-                for j in range(n_ctrls):
-                    if j == 0:
-                        dyn._prop[k], dyn._prop_grad[k, j] = \
-                                    prop_comp._compute_prop_grad(k, j)
-                        if self.log_level <= logging.DEBUG_INTENSE:
-                            logger.log(logging.DEBUG_INTENSE,
-                                       "propagator {}:\n{:10.3g}".format(
-                                           k, self._prop[k]))
-                    else:
-                        dyn._prop_grad[k, j] = \
-                            prop_comp._compute_prop_grad(k, j,
-                                                         compute_prop=False)
-            else:
-                dyn._prop[k] = prop_comp._compute_propagator(k)
-
-        if ecs:
-            ecs.wall_time_prop_compute = \
-                timeit.default_timer() - time_start
-
-        if ecs:
-            time_start = timeit.default_timer()
-        # compute the forward propagation
-        R = range(n_ts)
-        for k in R:
-            if dyn.oper_dtype == Qobj:
-                dyn._fwd_evo[k+1] = dyn._prop[k]*dyn._fwd_evo[k]
-            else:
-                dyn._fwd_evo[k+1] = dyn._prop[k].dot(dyn._fwd_evo[k])
-
-        if ecs:
-            ecs.wall_time_fwd_prop_compute = \
-                        timeit.default_timer() - time_start
-            time_start = timeit.default_timer()
-        # compute the onward propagation
-        if dyn.fid_computer.uses_onwd_evo:
-            dyn._onwd_evo[n_ts-1] = dyn._prop[n_ts-1]
-            R = range(n_ts-2, -1, -1)
-            for k in R:
-                if dyn.oper_dtype == Qobj:
-                    dyn._onwd_evo[k] = dyn._onwd_evo[k+1]*dyn._prop[k]
-                else:
-                    dyn._onwd_evo[k] = dyn._onwd_evo[k+1].dot(dyn._prop[k])
-
-        if dyn.fid_computer.uses_onto_evo:
-            R = range(n_ts-1, -1, -1)
-            for k in R:
-                if dyn.oper_dtype == Qobj:
-                    dyn._onto_evo[k] = dyn._onto_evo[k+1]*dyn._prop[k]
-                else:
-                    dyn._onto_evo[k] = dyn._onto_evo[k+1].dot(dyn._prop[k])
-
-        if ecs:
-            ecs.wall_time_onwd_prop_compute = \
-                            timeit.default_timer() - time_start
-
-        if dyn.stats:
-            dyn.stats.wall_time_dyn_gen_compute += \
-                                    ecs.wall_time_dyn_gen_compute
-            dyn.stats.wall_time_prop_compute += \
-                                    ecs.wall_time_prop_compute
-            dyn.stats.wall_time_fwd_prop_compute += \
-                                    ecs.wall_time_fwd_prop_compute
-            dyn.stats.wall_time_onwd_prop_compute += \
-                                    ecs.wall_time_onwd_prop_compute
-
-        if dyn.unitarity_check_level:
-            dyn.check_unitarity()
-
-        if dyn.dump:
-            self.dump_current()
-
-    def get_timeslot_for_fidelity_calc(self):
-        """
-        Returns the timeslot index that will be used calculate current fidelity
-        value.
-        This (default) method simply returns the last timeslot
-        """
-        _func_deprecation("'get_timeslot_for_fidelity_calc' is deprecated. "
-                          "Use '_get_timeslot_for_fidelity_calc'")
-        return self._get_timeslot_for_fidelity_calc
-
-    def _get_timeslot_for_fidelity_calc(self):
-        """
-        Returns the timeslot index that will be used calculate current fidelity
-        value.
-        This (default) method simply returns the last timeslot
-        """
-        return self.parent.num_tslots
-
-
-class TSlotCompDynUpdate(TimeslotComputer):
-    """
-    Timeslot Computer - Dynamic Update
-    ********************************
-    ***** CURRENTLY HAS ISSUES *****
-    ***** AJGP 2014-10-02
-    ***** and is therefore not being maintained
-    ***** i.e. changes made to _UpdateAll are not being implemented here
-    ********************************
-    Updates only the dynamics generators, propagators and evolutions as
-    required when a subset of the ctrl amplitudes are updated.
-    Will update all if all amps have changed.
-    """
-
-    def reset(self):
-        self.dyn_gen_recalc = None
-        self.prop_recalc = None
-        self.evo_init2t_recalc = None
-        self.evo_t2targ_recalc = None
-        self.dyn_gen_calc_now = None
-        self.prop_calc_now = None
-        self.evo_init2t_calc_now = None
-        self.evo_t2targ_calc_now = None
-        TimeslotComputer.reset(self)
-        self.id_text = 'DYNAMIC'
-        self.apply_params()
-
-    def init_comp(self):
-        """
-        Initialise the flags
-        """
-        ####
-        # These maps are used to determine what needs to be updated
-        ####
-        # Note _recalc means the value needs updating at some point
-        # e.g. here no values have been set, except the initial and final
-        # evolution operator vals (which never change) and hence all other
-        # values are set as requiring calculation.
-        n_ts = self.parent.num_tslots
-        self.dyn_gen_recalc = np.ones(n_ts, dtype=bool)
-        # np.ones(n_ts, dtype=bool)
-        self.prop_recalc = np.ones(n_ts, dtype=bool)
-        self.evo_init2t_recalc = np.ones(n_ts + 1, dtype=bool)
-        self.evo_init2t_recalc[0] = False
-        self.evo_t2targ_recalc = np.ones(n_ts + 1, dtype=bool)
-        self.evo_t2targ_recalc[-1] = False
-
-        # The _calc_now map is used to during the calcs to specify
-        # which values need updating immediately
-        self.dyn_gen_calc_now = np.zeros(n_ts, dtype=bool)
-        self.prop_calc_now = np.zeros(n_ts, dtype=bool)
-        self.evo_init2t_calc_now = np.zeros(n_ts + 1, dtype=bool)
-        self.evo_t2targ_calc_now = np.zeros(n_ts + 1, dtype=bool)
-
-    def compare_amps(self, new_amps):
-        """
-        Determine which timeslots will have changed Hamiltonians
-        i.e. any where control amplitudes have changed for that slot
-        and mark (using masks) them and corresponding exponentiations and
-        time evo operators for update
-        Returns: True if amplitudes are the same, False if they have changed
-        """
-        dyn = self.parent
-        n_ts = dyn.num_tslots
-        # create boolean array with same shape as ctrl_amps
-        # True where value in New_amps differs, otherwise false
-        if self.parent.ctrl_amps is None:
-            changed_amps = np.ones(new_amps.shape, dtype=bool)
-        else:
-            changed_amps = self.parent.ctrl_amps != new_amps
-
-        if self.log_level <= logging.DEBUG_VERBOSE:
-            logger.log(logging.DEBUG_VERBOSE, "changed_amps:\n{}".format(
-                changed_amps))
-        # create Boolean vector with same length as number of timeslots
-        # True where any of the amplitudes have changed, otherwise false
-        changed_ts_mask = np.any(changed_amps, 1)
-        # if any of the amplidudes have changed then mark for recalc
-        if np.any(changed_ts_mask):
-            self.dyn_gen_recalc[changed_ts_mask] = True
-            self.prop_recalc[changed_ts_mask] = True
-            dyn.ctrl_amps = new_amps
-            if self.log_level <= logging.DEBUG:
-                logger.debug("Control amplitudes updated")
-            # find first and last changed dynamics generators
-            first_changed = None
-            for i in range(n_ts):
-                if changed_ts_mask[i]:
-                    last_changed = i
-                    if first_changed is None:
-                        first_changed = i
-
-            # set all fwd evo ops after first changed Ham to be recalculated
-            self.evo_init2t_recalc[first_changed + 1:] = True
-            # set all bkwd evo ops up to (incl) last changed Ham to be
-            # recalculated
-            self.evo_t2targ_recalc[:last_changed + 1] = True
-
-            # Flag fidelity and gradients as needing recalculation
-            dyn.flag_system_changed()
-
-            # *** update stats ***
-            if dyn.stats is not None:
-                dyn.stats.num_ctrl_amp_updates += 1
-                dyn.stats.num_ctrl_amp_changes += changed_amps.sum()
-                dyn.stats.num_timeslot_changes += changed_ts_mask.sum()
-
-            return False
-        else:
-            return True
-
-    def flag_all_calc_now(self):
-        """
-        Flags all Hamiltonians, propagators and propagations to be
-        calculated now
-        """
-        # set flags for calculations
-        self.dyn_gen_calc_now[:] = True
-        self.prop_calc_now[:] = True
-        self.evo_init2t_calc_now[:-1] = True
-        self.evo_t2targ_calc_now[1:] = True
-
-    def recompute_evolution(self):
-        """
-        Recalculates the evo_init2t (forward) and evo_t2targ (onward) time
-        evolution operators
-        DynGen (Hamiltonians etc) and prop (propagator) are calculated
-        as necessary
-        """
-        if self.log_level <= logging.DEBUG_VERBOSE:
-            logger.log(logging.DEBUG_VERBOSE, "recomputing evolution "
-                       "(DynUpdate)")
-
-        dyn = self.parent
-        n_ts = dyn.num_tslots
-        # find the op slots that have been marked for update now
-        # and need recalculation
-        evo_init2t_recomp_now = self.evo_init2t_calc_now & \
-            self.evo_init2t_recalc
-        evo_t2targ_recomp_now = self.evo_t2targ_calc_now & \
-            self.evo_t2targ_recalc
-
-        # to recomupte evo_init2t, will need to start
-        #  at a cell that has been computed
-        if np.any(evo_init2t_recomp_now):
-            for k in range(n_ts, 0, -1):
-                if evo_init2t_recomp_now[k] and self.evo_init2t_recalc[k-1]:
-                    evo_init2t_recomp_now[k-1] = True
-
-        # for evo_t2targ, will also need to start
-        #  at a cell that has been computed
-        if np.any(evo_t2targ_recomp_now):
-            for k in range(0, n_ts):
-                if evo_t2targ_recomp_now[k] and self.evo_t2targ_recalc[k+1]:
-                    evo_t2targ_recomp_now[k+1] = True
-
-        # determine which dyn gen and prop need recalculating now in order to
-        # calculate the forwrd and onward evolutions
-        prop_recomp_now = (evo_init2t_recomp_now[1:]
-                           | evo_t2targ_recomp_now[:-1]
-                           | self.prop_calc_now[:]) & self.prop_recalc[:]
-        dyn_gen_recomp_now = (prop_recomp_now[:] | self.dyn_gen_calc_now[:]) \
-            & self.dyn_gen_recalc[:]
-
-        if np.any(dyn_gen_recomp_now):
-            time_start = timeit.default_timer()
-            for k in range(n_ts):
-                if dyn_gen_recomp_now[k]:
-                    # calculate the dynamics generators
-                    dyn.dyn_gen[k] = dyn.compute_dyn_gen(k)
-                    self.dyn_gen_recalc[k] = False
-            if dyn.stats is not None:
-                dyn.stats.num_dyn_gen_computes += dyn_gen_recomp_now.sum()
-                dyn.stats.wall_time_dyn_gen_compute += \
-                    timeit.default_timer() - time_start
-
-        if np.any(prop_recomp_now):
-            time_start = timeit.default_timer()
-            for k in range(n_ts):
-                if prop_recomp_now[k]:
-                    # calculate exp(H) and other per H computations needed for
-                    # the gradient function
-                    dyn.prop[k] = dyn._compute_propagator(k)
-                    self.prop_recalc[k] = False
-            if dyn.stats is not None:
-                dyn.stats.num_prop_computes += prop_recomp_now.sum()
-                dyn.stats.wall_time_prop_compute += \
-                    timeit.default_timer() - time_start
-
-        # compute the forward propagation
-        if np.any(evo_init2t_recomp_now):
-            time_start = timeit.default_timer()
-            R = range(1, n_ts + 1)
-            for k in R:
-                if evo_init2t_recomp_now[k]:
-                    dyn.evo_init2t[k] = \
-                        dyn.prop[k-1].dot(dyn.evo_init2t[k-1])
-                    self.evo_init2t_recalc[k] = False
-            if dyn.stats is not None:
-                dyn.stats.num_fwd_prop_step_computes += \
-                    evo_init2t_recomp_now.sum()
-                dyn.stats.wall_time_fwd_prop_compute += \
-                    timeit.default_timer() - time_start
-
-        if np.any(evo_t2targ_recomp_now):
-            time_start = timeit.default_timer()
-            # compute the onward propagation
-            R = range(n_ts-1, -1, -1)
-            for k in R:
-                if evo_t2targ_recomp_now[k]:
-                    dyn.evo_t2targ[k] = dyn.evo_t2targ[k+1].dot(dyn.prop[k])
-                    self.evo_t2targ_recalc[k] = False
-            if dyn.stats is not None:
-                dyn.stats.num_onwd_prop_step_computes += \
-                    evo_t2targ_recomp_now.sum()
-                dyn.stats.wall_time_onwd_prop_compute += \
-                    timeit.default_timer() - time_start
-
-        # Clear calc now flags
-        self.dyn_gen_calc_now[:] = False
-        self.prop_calc_now[:] = False
-        self.evo_init2t_calc_now[:] = False
-        self.evo_t2targ_calc_now[:] = False
-
-    def get_timeslot_for_fidelity_calc(self):
-        """
-        Returns the timeslot index that will be used calculate current fidelity
-        value. Attempts to find a timeslot where the least number of propagator
-        calculations will be required.
-        Flags the associated evolution operators for calculation now
-        """
-        dyn = self.parent
-        n_ts = dyn.num_tslots
-        kBothEvoCurrent = -1
-        kFwdEvoCurrent = -1
-        kUse = -1
-        # If no specific timeslot set in config, then determine dynamically
-        if kUse < 0:
-            for k in range(n_ts):
-                # find first timeslot where both evo_init2t and
-                # evo_t2targ are current
-                if not self.evo_init2t_recalc[k]:
-                    kFwdEvoCurrent = k
-                    if not self.evo_t2targ_recalc[k]:
-                        kBothEvoCurrent = k
-                        break
-
-            if kBothEvoCurrent >= 0:
-                kUse = kBothEvoCurrent
-            elif kFwdEvoCurrent >= 0:
-                kUse = kFwdEvoCurrent
-            else:
-                raise errors.FunctionalError("No timeslot found matching "
-                                             "criteria")
-
-        self.evo_init2t_calc_now[kUse] = True
-        self.evo_t2targ_calc_now[kUse] = True
-        return kUse
-
-
-class EvoCompSummary(qtrldump.DumpSummaryItem):
-    """
-    A summary of the most recent time evolution computation
-    Used in stats calculations and for data dumping
-
-    Attributes
-    ----------
-    evo_dump_idx : int
-        Index of the linked :class:`dump.EvoCompDumpItem`
-        None if no linked item
-
-    iter_num : int
-        Iteration number of the pulse optimisation
-        None if evolution compute outside of a pulse optimisation
-
-    fid_func_call_num : int
-        Fidelity function call number of the pulse optimisation
-        None if evolution compute outside of a pulse optimisation
-
-    grad_func_call_num : int
-        Gradient function call number of the pulse optimisation
-        None if evolution compute outside of a pulse optimisation
-
-    num_amps_changed : int
-        Number of control timeslot amplitudes changed since previous
-        evolution calculation
-
-    num_timeslots_changed : int
-        Number of timeslots in which any amplitudes changed since previous
-        evolution calculation
-
-    wall_time_dyn_gen_compute : float
-        Time spent computing dynamics generators
-        (in seconds of elapsed time)
-
-    wall_time_prop_compute : float
-        Time spent computing propagators (including and propagator gradients)
-        (in seconds of elapsed time)
-
-    wall_time_fwd_prop_compute : float
-        Time spent computing the forward evolution of the system
-        see :property:`dynamics.fwd_evo`
-        (in seconds of elapsed time)
-
-    wall_time_onwd_prop_compute : float
-        Time spent computing the 'backward' evolution of the system
-        see :property:`dynamics.onwd_evo` and :property:`dynamics.onto_evo`
-        (in seconds of elapsed time)
-    """
-
-    min_col_width = 11
-    summary_property_names = (
-        "idx", "evo_dump_idx",
-        "iter_num", "fid_func_call_num", "grad_func_call_num",
-        "num_amps_changed", "num_timeslots_changed",
-        "wall_time_dyn_gen_compute", "wall_time_prop_compute",
-        "wall_time_fwd_prop_compute", "wall_time_onwd_prop_compute")
-
-    summary_property_fmt_type = (
-        'd', 'd',
-        'd', 'd', 'd',
-        'd', 'd',
-        'g', 'g',
-        'g', 'g'
-        )
-
-    summary_property_fmt_prec = (
-        0, 0,
-        0, 0, 0,
-        0, 0,
-        3, 3,
-        3, 3
-        )
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        qtrldump.DumpSummaryItem.reset(self)
-        self.evo_dump_idx = None
-        self.iter_num = None
-        self.fid_func_call_num = None
-        self.grad_func_call_num = None
-        self.num_amps_changed = 0
-        self.num_timeslots_changed = 0
-        self.wall_time_dyn_gen_compute = 0.0
-        self.wall_time_prop_compute = 0.0
-        self.wall_time_fwd_prop_compute = 0.0
-        self.wall_time_onwd_prop_compute = 0.0

From 8852391b90a42fb707831237d8a8ec95ff99de1e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Mar 2023 14:30:56 +0100
Subject: [PATCH 139/602] Remove qutip.control tests.

---
 qutip/tests/test_control_pulseoptim.py | 501 -------------------------
 1 file changed, 501 deletions(-)
 delete mode 100644 qutip/tests/test_control_pulseoptim.py

diff --git a/qutip/tests/test_control_pulseoptim.py b/qutip/tests/test_control_pulseoptim.py
deleted file mode 100644
index fbdf023283..0000000000
--- a/qutip/tests/test_control_pulseoptim.py
+++ /dev/null
@@ -1,501 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: Alexander Pitchford
-# @email1: agp1@aber.ac.uk
-# @email2: alex.pitchford@gmail.com
-# @organization: Aberystwyth University
-# @supervisor: Daniel Burgarth
-# @date: Sep 2015
-
-import pytest
-import collections
-import os
-import pathlib
-import tempfile
-import numpy as np
-import scipy.optimize
-import scipy.sparse as sp
-
-import qutip
-from qutip.control import pulseoptim as cpo
-import qutip.control.loadparams
-
-_sx = qutip.sigmax()
-_sy = qutip.sigmay()
-_sz = qutip.sigmaz()
-_sp = qutip.sigmap()
-_sm = qutip.sigmam()
-_si = qutip.identity(2)
-_project_0 = qutip.basis(2, 0).proj()
-_hadamard = qutip.gates.snot()
-
-# We have a whole bunch of different physical systems we want to test the
-# optimiser for, but the logic for testing them is largely the same.  To avoid
-# having to explicitly parametrise over five linked parameters repeatedly, we
-# group them into a record type, so that all the optimisation functions can
-# then simply be parametrised over a single argument.
-#
-# We supply `kwargs` as a property of the system because the initial pulse type
-# and dynamics solver to use vary, especially if the system is unitary.
-_System = collections.namedtuple('_System',
-                                 ['system', 'controls', 'initial', 'target',
-                                  'kwargs'])
-
-# Simple Hadamard gate.
-_hadamard_kwargs = {'num_tslots': 10, 'evo_time': 10, 'gen_stats': True,
-                    'init_pulse_type': 'LIN', 'fid_err_targ': 1e-10,
-                    'dyn_type': 'UNIT'}
-hadamard = _System(system=_sz,
-                   controls=[_sx],
-                   initial=_si,
-                   target=_hadamard,
-                   kwargs=_hadamard_kwargs)
-
-# Quantum Fourier transform.
-_qft_system = 0.5 * sum(qutip.tensor(op, op) for op in (_sx, _sy, _sz))
-_qft_controls = [0.5*qutip.tensor(_sx, _si), 0.5*qutip.tensor(_sy, _si),
-                 0.5*qutip.tensor(_si, _sx), 0.5*qutip.tensor(_si, _sy)]
-_qft_kwargs = {'num_tslots': 10, 'evo_time': 10, 'gen_stats': True,
-               'init_pulse_type': 'LIN', 'fid_err_targ': 1e-9,
-               'dyn_type': 'UNIT'}
-qft = _System(system=_qft_system,
-              controls=_qft_controls,
-              initial=qutip.identity([2, 2]),
-              target=qutip.qft([2, 2]),
-              kwargs=_qft_kwargs)
-
-# Coupling constants are completely arbitrary.
-_ising_system = (0.9*qutip.tensor(_sx, _si) + 0.7*qutip.tensor(_si, _sx)
-                 + 0.8*qutip.tensor(_sz, _si) + 0.9*qutip.tensor(_si, _sz))
-_ising_kwargs = {'num_tslots': 10, 'evo_time': 18, 'init_pulse_type': 'LIN',
-                 'fid_err_targ': 1e-10, 'dyn_type': 'UNIT'}
-ising = _System(system=_ising_system,
-                controls=[qutip.tensor(_sz, _sz)],
-                initial=qutip.basis([2, 2], [0, 0]),
-                target=qutip.basis([2, 2], [1, 1]),
-                kwargs=_ising_kwargs)
-
-# Louivillian amplitude-damping channel system.
-_l_adc_system = 0.1 * (2*qutip.tensor(_sm, _sp.dag())
-                       - qutip.tensor(_project_0, _si)
-                       - qutip.tensor(_si, _project_0.dag()))
-_l_adc_controls = [1j * (qutip.tensor(_si, _sz) - qutip.tensor(_sz, _si)),
-                   1j * (qutip.tensor(_si, _sx) - qutip.tensor(_sx, _si))]
-_l_adc_kwargs = {'num_tslots': 10, 'evo_time': 5, 'init_pulse_type': 'LIN',
-                 'max_iter': 200, 'fid_err_targ': 1e-1, 'gen_stats': True}
-l_adc = _System(system=_l_adc_system,
-                controls=_l_adc_controls,
-                initial=qutip.identity([2, 2]),
-                target=qutip.gates.hadamard_transform(2),
-                kwargs=_l_adc_kwargs)
-
-# Two coupled oscillators with symplectic dynamics.
-_g1, _g2 = 1.0, 0.2
-_A_rotate = qutip.qdiags([[1, 1, 0, 0]], [0])
-_A_squeeze = 0.4 * qutip.qdiags([[1, -1, 0, 0]], [0])
-_A_target = qutip.qdiags([[1, 1], [1, 1]], [2, -2])
-_Omega = qutip.Qobj(qutip.control.symplectic.calc_omega(2))
-_sympl_system = qutip.qdiags([[1, 1, 1, 1], [_g1, _g2], [_g1, _g2]],
-                             [0, 2, -2])
-_sympl_target = (-0.5 * _A_target * _Omega * np.pi).expm()
-_sympl_kwargs = {'num_tslots': 20, 'evo_time': 10, 'fid_err_targ': 1e-3,
-                 'max_iter': 200, 'dyn_type': 'SYMPL',
-                 'init_pulse_type': 'ZERO', 'gen_stats': True}
-symplectic = _System(system=_sympl_system,
-                     controls=[_A_rotate, _A_squeeze],
-                     initial=qutip.identity(4),
-                     target=_sympl_target,
-                     kwargs=_sympl_kwargs)
-
-
-# Parametrise the systems and the propagation method separately so that we test
-# all combinations of both.
-
-# Test propagation with the default settings and with internal Qobj use for all
-# test cases.
-@pytest.fixture(params=[
-    pytest.param(None, id="default propagation"),
-    pytest.param({'oper_dtype': qutip.Qobj}, id="Qobj propagation"),
-    pytest.param({'oper_dtype': np.ndarray}, id="ndarray propagation"),
-])
-def propagation(request):
-    return {'dyn_params': request.param}
-
-
-# Any test requiring a system to test will parametrise over all of the ones we
-# defined above.
-@pytest.fixture(params=[
-    pytest.param(hadamard, id="Hadamard gate"),
-    pytest.param(qft, id="QFT"),
-    pytest.param(ising, id="Ising state-to-state"),
-    pytest.param(l_adc, id="Lindbladian amplitude damping channel"),
-    pytest.param(symplectic, id="Symplectic coupled oscillators"),
-])
-def system(request):
-    return request.param
-
-
-def _optimize_pulse(system):
-    """
-    Unpack the `system` record type, optimise the result and assert that it
-    succeeded.
-    """
-    result = cpo.optimize_pulse(system.system, system.controls,
-                                system.initial, system.target,
-                                **system.kwargs)
-    error = " ".join(["Infidelity: {:7.4e}".format(result.fid_err),
-                      "reason:", result.termination_reason])
-    assert result.goal_achieved, error
-    return result
-
-
-def _merge_kwargs(system, kwargs):
-    """
-    Return a copy of `system` with any passed `kwargs` updated in the
-    dictionary---this can be used to overwrite or to add new arguments.
-    """
-    out = system.kwargs.copy()
-    out.update(kwargs)
-    return system._replace(kwargs=out)
-
-
-class TestOptimization:
-    def test_basic_optimization(self, system, propagation):
-        """Test the optimiser in the base case for each system."""
-        system = _merge_kwargs(system, propagation)
-        result = _optimize_pulse(system)
-        assert result.fid_err < system.kwargs['fid_err_targ']
-
-    def test_sparse_eigen_optimization(self, system, propagation):
-        system = _merge_kwargs(system, {
-            **propagation,
-            "dyn_params": {
-                **(propagation.get("dyn_params") or {}),
-                "sparse_eigen_decomp": True,
-            }
-        })
-        if system.system.dims == [[2], [2]]:
-            with pytest.raises(ValueError, match=(
-                    r"^Single qubit pulse optimization dynamics cannot use"
-                    r" sparse eigenvector decomposition")):
-                _optimize_pulse(system)
-        else:
-            result = _optimize_pulse(system)
-            assert result.fid_err < system.kwargs['fid_err_targ']
-
-    @pytest.mark.parametrize("oper_dtype", [
-        pytest.param(sp.csr_matrix, id="csr_matrix"),
-        pytest.param(list, id="list"),
-    ])
-    def test_invalid_oper_dtype(self, system, oper_dtype):
-        system = _merge_kwargs(system, {"dyn_params": {
-            "oper_dtype": oper_dtype,
-        }})
-        with pytest.raises(ValueError) as err:
-            _optimize_pulse(system)
-        assert str(err.value) == (
-            f"Unknown oper_dtype {oper_dtype!r}. The oper_dtype may be"
-            " qutip.Qobj or numpy.ndarray."
-        )
-
-    def test_object_oriented_approach_and_gradient(self, system, propagation):
-        """
-        Test the object-oriented version of the optimiser, and ensure that the
-        system truly appears to be at an extremum.
-        """
-        system = _merge_kwargs(system, propagation)
-        base = _optimize_pulse(system)
-        optimizer = cpo.create_pulse_optimizer(system.system, system.controls,
-                                               system.initial, system.target,
-                                               **system.kwargs)
-        init_amps = np.array([optimizer.pulse_generator.gen_pulse()
-                              for _ in system.controls]).T
-        optimizer.dynamics.initialize_controls(init_amps)
-        # Check the gradient numerically.
-        func = optimizer.fid_err_func_wrapper
-        grad = optimizer.fid_err_grad_wrapper
-        loc = optimizer.dynamics.ctrl_amps.flatten()
-        assert abs(scipy.optimize.check_grad(func, grad, loc)) < 1e-5,\
-            "Gradient outside tolerance."
-        result = optimizer.run_optimization()
-        tol = system.kwargs['fid_err_targ']
-        assert abs(result.fid_err-base.fid_err) < tol,\
-            "Direct and indirect methods produce different results."
-
-    @pytest.mark.parametrize("kwargs", [
-        pytest.param({'gen_stats': False}, id="no stats"),
-        pytest.param({'num_tslots': None, 'evo_time': None,
-                      'tau': np.arange(1, 10, 1, dtype=np.float64)},
-                     id="tau array")
-    ])
-    def test_modified_optimization(self, propagation, kwargs):
-        """Test a basic system with a few different combinations of options."""
-        system = _merge_kwargs(hadamard, kwargs)
-        self.test_basic_optimization(system, propagation)
-
-    def test_optimizer_bounds(self):
-        """Test that bounds on the control fields are obeyed."""
-        bound = 1.0
-        kwargs = {'amp_lbound': -bound, 'amp_ubound': bound}
-        system = _merge_kwargs(qft, kwargs)
-        result = _optimize_pulse(system)
-        assert np.all(result.final_amps >= -bound)
-        assert np.all(result.final_amps <= bound)
-
-    def test_unitarity_via_dump(self):
-        """
-        Test that unitarity is maintained at all times throughout the
-        optimisation of the controls.
-        """
-        kwargs = {'num_tslots': 1000, 'evo_time': 4, 'fid_err_targ': 1e-9,
-                  'dyn_params': {'dumping': 'FULL'}}
-        system = _merge_kwargs(hadamard, kwargs)
-        result = _optimize_pulse(system)
-        dynamics = result.optimizer.dynamics
-        assert dynamics.dump is not None, "Dynamics dump not created"
-        # Use the dump to check unitarity of all propagators and evo_ops
-        dynamics.unitarity_tol = 1e-13 # 1e-14 for eigh but 1e-13 for eig.
-        for item, description in [('prop', 'propagators'),
-                                  ('fwd_evo', 'forward evolution operators'),
-                                  ('onto_evo', 'onto evolution operators')]:
-            non_unitary = sum(not dynamics._is_unitary(x)
-                              for dump in dynamics.dump.evo_dumps
-                              for x in getattr(dump, item))
-            assert non_unitary == 0, "Found non-unitary " + description + "."
-
-    def test_crab(self, propagation):
-        tol = 1e-5
-        evo_time = 10
-        result = cpo.opt_pulse_crab_unitary(
-            hadamard.system, hadamard.controls,
-            hadamard.initial, hadamard.target,
-            num_tslots=12, evo_time=evo_time, fid_err_targ=tol,
-            **propagation,
-            alg_params={'crab_pulse_params': {'randomize_coeffs': False,
-                                              'randomize_freqs': False}},
-            init_coeff_scaling=0.5,
-            guess_pulse_type='GAUSSIAN',
-            guess_pulse_params={'variance': evo_time * 0.1},
-            guess_pulse_scaling=1.0,
-            guess_pulse_offset=1.0,
-            amp_lbound=None,
-            amp_ubound=None,
-            ramping_pulse_type='GAUSSIAN_EDGE',
-            ramping_pulse_params={'decay_time': evo_time * 0.01},
-            gen_stats=True)
-        error = " ".join(["Infidelity: {:7.4e}".format(result.fid_err),
-                          "reason:", result.termination_reason])
-        assert result.goal_achieved, error
-        assert abs(result.fid_err) < tol
-        assert abs(result.final_amps[0, 0]) < tol, "Lead-in amplitude nonzero."
-
-
-# The full object-orientated interface to the optimiser is rather complex.  To
-# attempt to simplify the test of the configuration loading, we break it down
-# into steps here.
-
-def _load_configuration(path):
-    configuration = qutip.control.optimconfig.OptimConfig()
-    configuration.param_fname = path.name
-    configuration.param_fpath = str(path)
-    configuration.pulse_type = "ZERO"
-    qutip.control.loadparams.load_parameters(str(path), config=configuration)
-    return configuration
-
-
-def _load_dynamics(path, system, configuration, stats):
-    dynamics = qutip.control.dynamics.DynamicsUnitary(configuration)
-    dynamics.drift_dyn_gen = system.system
-    dynamics.ctrl_dyn_gen = system.controls
-    dynamics.initial = system.initial
-    dynamics.target = system.target
-    qutip.control.loadparams.load_parameters(str(path), dynamics=dynamics)
-    dynamics.init_timeslots()
-    dynamics.stats = stats
-    return dynamics
-
-
-def _load_pulse_generator(path, configuration, dynamics):
-    pulse_generator = qutip.control.pulsegen.create_pulse_gen(
-            pulse_type=configuration.pulse_type,
-            dyn=dynamics)
-    qutip.control.loadparams.load_parameters(str(path),
-                                             pulsegen=pulse_generator)
-    return pulse_generator
-
-
-def _load_termination_conditions(path):
-    conditions = qutip.control.termcond.TerminationConditions()
-    qutip.control.loadparams.load_parameters(str(path), term_conds=conditions)
-    return conditions
-
-
-def _load_optimizer(path, configuration, dynamics, pulse_generator,
-                    termination_conditions, stats):
-    method = configuration.optim_method
-    if method is None:
-        raise qutip.control.errors.UsageError(
-            "Optimization algorithm must be specified using the 'optim_method'"
-            " parameter.")
-    known = {'BFGS': 'OptimizerBFGS', 'FMIN_L_BFGS_B': 'OptimizerLBFGSB'}
-    constructor = getattr(qutip.control.optimizer,
-                          known.get(method, 'Optimizer'))
-    optimizer = constructor(configuration, dynamics)
-    optimizer.method = method
-    qutip.control.loadparams.load_parameters(str(path), optim=optimizer)
-    optimizer.config = configuration
-    optimizer.dynamics = dynamics
-    optimizer.pulse_generator = pulse_generator
-    optimizer.termination_conditions = termination_conditions
-    optimizer.stats = stats
-    return optimizer
-
-
-class TestFileIO:
-    def test_load_parameters_from_file(self):
-        system = hadamard
-        path = pathlib.Path(__file__).parent / "Hadamard_params.ini"
-        stats = qutip.control.stats.Stats()
-        configuration = _load_configuration(path)
-        dynamics = _load_dynamics(path, system, configuration, stats)
-        pulse_generator = _load_pulse_generator(path, configuration, dynamics)
-        termination_conditions = _load_termination_conditions(path)
-        optimizer = _load_optimizer(path,
-                                    configuration,
-                                    dynamics,
-                                    pulse_generator,
-                                    termination_conditions,
-                                    stats)
-        init_amps = np.array([optimizer.pulse_generator.gen_pulse()
-                              for _ in system.controls]).T
-        optimizer.dynamics.initialize_controls(init_amps)
-        result = optimizer.run_optimization()
-
-        kwargs = {'num_tslots': 6, 'evo_time': 6, 'fid_err_targ': 1e-10,
-                  'init_pulse_type': 'LIN', 'dyn_type': 'UNIT',
-                  'amp_lbound': -1, 'amp_ubound': 1,
-                  'gen_stats': True}
-        target = _optimize_pulse(system._replace(kwargs=kwargs))
-        np.testing.assert_allclose(result.final_amps, target.final_amps,
-                                   atol=1e-5)
-
-    @pytest.mark.usefixtures("in_temporary_directory")
-    def test_dumping_to_files(self):
-        N_OPTIMDUMP_FILES = 10
-        N_DYNDUMP_FILES = 49
-        dumping = {'dumping': 'FULL', 'dump_to_file': True}
-        kwargs = {'num_tslots': 1_000, 'evo_time': 4, 'fid_err_targ': 1e-9,
-                  'optim_params': {'dump_dir': 'optim', **dumping},
-                  'dyn_params': {'dump_dir': 'dyn', **dumping}}
-        system = _merge_kwargs(hadamard, kwargs)
-        result = _optimize_pulse(system)
-
-        # Check dumps were generated and have the right number of files.
-        assert result.optimizer.dump is not None
-        assert result.optimizer.dynamics.dump is not None
-        assert (len(os.listdir(result.optimizer.dump.dump_dir))
-                == N_OPTIMDUMP_FILES)
-        assert (len(os.listdir(result.optimizer.dynamics.dump.dump_dir))
-                == N_DYNDUMP_FILES)
-
-        # Dump all to specific file stream.
-        for dump, type_ in [(result.optimizer.dump, 'optimizer'),
-                            (result.optimizer.dynamics.dump, 'dynamics')]:
-            with tempfile.NamedTemporaryFile() as file:
-                dump.writeout(file)
-                assert os.stat(file.name).st_size > 0,\
-                    " ".join(["Empty", type_, "file."])
-
-
-def _count_waves(system):
-    optimizer = cpo.create_pulse_optimizer(system.system, system.controls,
-                                           system.initial, system.target,
-                                           **system.kwargs)
-    pulse = optimizer.pulse_generator.gen_pulse()
-    zero_crossings = pulse[0:-2]*pulse[1:-1] < 0
-    return (sum(zero_crossings) + 1) // 2
-
-
-@pytest.mark.parametrize('pulse_type',
-                         [pytest.param(x, id=x.lower())
-                          for x in ['SINE', 'SQUARE', 'TRIANGLE', 'SAW']])
-class TestPeriodicControlFunction:
-    num_tslots = 1_000
-    evo_time = 10
-
-    @pytest.mark.parametrize('n_waves', [1, 5, 10, 100])
-    def test_number_of_waves(self, pulse_type, n_waves):
-        kwargs = {'num_tslots': self.num_tslots, 'evo_time': self.evo_time,
-                  'init_pulse_type': pulse_type,
-                  'init_pulse_params': {'num_waves': n_waves},
-                  'gen_stats': False}
-        system = _merge_kwargs(hadamard, kwargs)
-        assert _count_waves(system) == n_waves
-
-    @pytest.mark.parametrize('frequency', [0.1, 1, 10, 20])
-    def test_frequency(self, pulse_type, frequency):
-        kwargs = {'num_tslots': self.num_tslots, 'evo_time': self.evo_time,
-                  'init_pulse_type': pulse_type,
-                  'init_pulse_params': {'freq': frequency},
-                  'fid_err_targ': 1e-5,
-                  'gen_stats': False}
-        system = _merge_kwargs(hadamard, kwargs)
-        assert _count_waves(system) == self.evo_time*frequency
-
-
-class TestTimeDependence:
-    """
-    Test that systems where the system Hamiltonian is time-dependent behave as
-    expected under the optimiser.
-    """
-    def test_drift(self):
-        """
-        Test that introducing time dependence to the system does change the
-        result of the optimisation.
-        """
-        num_tslots = 20
-        system = _merge_kwargs(hadamard, {'num_tslots': num_tslots,
-                                          'evo_time': 10})
-        result_fixed = _optimize_pulse(system)
-        system_flat = system._replace(system=[system.system]*num_tslots)
-        result_flat = _optimize_pulse(system_flat)
-        step = [0.0]*(num_tslots//2) + [1.0]*(num_tslots//2)
-        system_step = system._replace(system=[x*system.system for x in step])
-        result_step = _optimize_pulse(system_step)
-        np.testing.assert_allclose(result_fixed.final_amps,
-                                   result_flat.final_amps,
-                                   rtol=1e-9)
-        assert np.any((result_flat.final_amps-result_step.final_amps) > 1e-3),\
-            "Flat and step drights result in the same control pulses."
-
-    def test_controls_all_time_slots_equal_to_no_time_dependence(self):
-        """
-        Test that simply duplicating the system in each time slot (i.e. no
-        actual time dependence has no effect on the final result.
-        """
-        num_tslots = 20
-        system = _merge_kwargs(hadamard, {'num_tslots': num_tslots,
-                                          'evo_time': 10,
-                                          'fid_err_targ': 1e-10})
-        result_single = _optimize_pulse(system)
-        system_vary = system._replace(controls=[[_sx]]*num_tslots)
-        result_vary = _optimize_pulse(system_vary)
-        np.testing.assert_allclose(result_single.final_amps,
-                                   result_vary.final_amps,
-                                   atol=1e-9)
-
-    def test_controls_identity_operators_ignored(self):
-        """
-        Test that moments in time where the control parameters are simply the
-        identity are just ignored by the optimiser (since they'll never be able
-        to do anything.
-        """
-        num_tslots = 20
-        controls = [[_sx] if k % 3 else [_si] for k in range(num_tslots)]
-        system = _merge_kwargs(hadamard, {'num_tslots': num_tslots,
-                                          'evo_time': 10})
-        system = system._replace(controls=controls)
-        result = _optimize_pulse(system)
-        for k in range(0, num_tslots, 3):
-            np.testing.assert_allclose(result.initial_amps[k],
-                                       result.final_amps[k],
-                                       rtol=1e-9)

From 7f607aaf1db4276bd5f7ec608b4026c3f159a364 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Mar 2023 14:34:38 +0100
Subject: [PATCH 140/602] Remove qutip.control docs.

---
 doc/apidoc/classes.rst   | 132 ---------------------------------------
 doc/apidoc/functions.rst |  10 ---
 2 files changed, 142 deletions(-)

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index aea4e75e18..052faef01e 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -185,135 +185,3 @@ Distribution functions
 
 .. autoclass:: qutip.distributions.HarmonicOscillatorProbabilityFunction
     :members:
-
-
-.. _classes-control:
-
-Optimal control
----------------
-
-.. autoclass:: qutip.control.optimizer.Optimizer
-    :members:
-
-.. autoclass:: qutip.control.optimizer.OptimizerBFGS
-    :members:
-
-.. autoclass:: qutip.control.optimizer.OptimizerLBFGSB
-    :members:
-
-.. autoclass:: qutip.control.optimizer.OptimizerCrab
-    :members:
-
-.. autoclass:: qutip.control.optimizer.OptimizerCrabFmin
-    :members:
-
-.. autoclass:: qutip.control.optimizer.OptimIterSummary
-    :members:
-
-.. autoclass:: qutip.control.termcond.TerminationConditions
-    :members:
-
-.. autoclass:: qutip.control.optimresult.OptimResult
-    :members:
-
-.. autoclass:: qutip.control.dynamics.Dynamics
-    :members:
-
-.. autoclass:: qutip.control.dynamics.DynamicsGenMat
-    :members:
-
-.. autoclass:: qutip.control.dynamics.DynamicsUnitary
-    :members:
-
-.. autoclass:: qutip.control.dynamics.DynamicsSymplectic
-    :members:
-
-.. autoclass:: qutip.control.propcomp.PropagatorComputer
-    :members:
-
-.. autoclass:: qutip.control.propcomp.PropCompApproxGrad
-    :members:
-
-.. autoclass:: qutip.control.propcomp.PropCompDiag
-    :members:
-
-.. autoclass:: qutip.control.propcomp.PropCompFrechet
-    :members:
-
-.. autoclass:: qutip.control.fidcomp.FidelityComputer
-    :members:
-
-.. autoclass:: qutip.control.fidcomp.FidCompUnitary
-    :members:
-
-.. autoclass:: qutip.control.fidcomp.FidCompTraceDiff
-    :members:
-
-.. autoclass:: qutip.control.fidcomp.FidCompTraceDiffApprox
-    :members:
-
-.. autoclass:: qutip.control.tslotcomp.TimeslotComputer
-    :members:
-
-.. autoclass:: qutip.control.tslotcomp.TSlotCompUpdateAll
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGen
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenRandom
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenZero
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenLinear
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenPeriodic
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenSine
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenSquare
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenSaw
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenTriangle
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenGaussian
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenGaussianEdge
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenCrab
-    :members:
-
-.. autoclass:: qutip.control.pulsegen.PulseGenCrabFourier
-    :members:
-
-.. autoclass:: qutip.control.stats.Stats
-    :members:
-
-.. autoclass:: qutip.control.dump.Dump
-    :members:
-
-.. autoclass:: qutip.control.dump.OptimDump
-    :members:
-
-.. autoclass:: qutip.control.dump.DynamicsDump
-    :members:
-
-.. autoclass:: qutip.control.dump.DumpItem
-    :members:
-
-.. autoclass:: qutip.control.dump.EvoCompDumpItem
-    :members:
-
-.. autoclass:: qutip.control.dump.DumpSummaryItem
-    :members:
diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 78a06941b5..d9bfef677b 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -258,16 +258,6 @@ Non-Markovian Solvers
 .. automodule:: qutip.solve.nonmarkov.transfertensor
     :members: ttmsolve
 
-.. _functions-control:
-
-Optimal control
-===============
-
-.. automodule:: qutip.control.pulseoptim
-    :members: optimize_pulse, optimize_pulse_unitary, create_pulse_optimizer, opt_pulse_crab, opt_pulse_crab_unitary
-
-.. automodule:: qutip.control.pulsegen
-    :members: create_pulse_gen
 
 Utility Functions
 =================

From 223cbccadb3afc01f61d44b5cf78a050545499e6 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Mar 2023 14:35:54 +0100
Subject: [PATCH 141/602] Add qutip.control compatibility module that imports
 qutip_qtrl.

---
 qutip/control.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 qutip/control.py

diff --git a/qutip/control.py b/qutip/control.py
new file mode 100644
index 0000000000..559a6a8d27
--- /dev/null
+++ b/qutip/control.py
@@ -0,0 +1,13 @@
+"""Module replicating the qutip_qtrl package from within qutip."""
+import sys
+
+try:
+    import qutip_qtrl
+    del qutip_qtrl
+    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
+except ImportError:
+    raise ImportError(
+        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
+        "Install it with `pip install qutip-qtrl` (for more details, go to "
+        "https://qutip-qtrl.readthedocs.io/)."
+    )

From 92edcd4be9c43688fb6af9709eae7fa5bf826e73 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 13 Mar 2023 14:42:21 +0100
Subject: [PATCH 142/602] Add towncrier entry.

---
 doc/changes/2116.removal | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2116.removal

diff --git a/doc/changes/2116.removal b/doc/changes/2116.removal
new file mode 100644
index 0000000000..d6b46e7a03
--- /dev/null
+++ b/doc/changes/2116.removal
@@ -0,0 +1 @@
+Remove qutip.control and replace with qutip_qtrl.

From a09f1c3ab86cf534b66674861e10e27c86868823 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 13 Mar 2023 14:59:27 -0400
Subject: [PATCH 143/602] Adding tests

---
 .coveragerc                                  |  2 +
 qutip/solver/sode/_sode.pyx                  |  2 -
 qutip/solver/sode/rouchon.py                 | 42 +------------
 qutip/solver/sode/ssystem.pyx                | 27 ++-------
 qutip/solver/stochastic.py                   | 52 ++++++++--------
 qutip/tests/solver/test_stochastic.py        | 63 ++++++++++++++++++--
 qutip/tests/solver/test_stochastic_system.py | 20 ++++---
 7 files changed, 106 insertions(+), 102 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index 96024441ef..69f745007b 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -3,6 +3,8 @@ source = qutip
 omit =
     # QuTiP test files
     */qutip/tests/*
+    # Tool for tests
+    */qutip/solver/sode/noise.py
 
 [report]
 exclude_lines =
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index c7b7f3ef11..32f35b1e11 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -90,9 +90,7 @@ cdef class Platen(Euler):
             d2p = system.diffusion(t, Vp[i])
             d2m = system.diffusion(t, Vm[i])
             dw = dW[0, i] * 0.25
-            # out = _data.add(out, d2m[i], dw)
             out = _data.add(out, d2[i], 2 * dw)
-            # out = _data.add(out, d2p[i], dw)
 
             for j in range(num_ops):
                 if i == j:
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index 0b9801ef31..89c1e6854d 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -4,7 +4,7 @@
 from ..stochastic import StochasticSolver
 from .sode import SIntegrator
 from ..integrator.integrator import Integrator
-
+import qutip as qt
 
 __all__ = ["RouchonSODE"]
 
@@ -33,6 +33,7 @@ def __init__(self, rhs, options):
         if self.H.issuper:
             raise TypeError("...")
         self._issuper = rhs.issuper
+
         dtype = type(self.H(0).data)
         self.c_ops = rhs.c_ops
         self.sc_ops = rhs.sc_ops
@@ -45,6 +46,7 @@ def __init__(self, rhs, options):
             - sum(op.dag() @ op for op in self.sc_ops) * 0.5
         )
         self.M.compress()
+
         self.num_collapses = len(self.sc_ops)
         self.scc = [
             [self.sc_ops[i] @ self.sc_ops[j] for i in range(j+1)]
@@ -53,15 +55,6 @@ def __init__(self, rhs, options):
 
         self.id = _data.identity[dtype](self.H.shape[0])
 
-        self.pre_M = qt.spre(self.M)
-        self.post_M = qt.spost(self.M.dag())
-        self.pre_sc = [qt.spre(c) for c in self.sc_ops]
-        self.post_sc = [qt.spost(c.dag()) for c in self.sc_ops]
-        self.pre_cc = [[qt.spre(cc) for cc in v] for v in self.scc]
-        self.post_cc = [[qt.spost(cc.dag()) for cc in v] for v in self.scc]
-        self.pp_cc = sum([qt.sprepost(op, op.dag()) for op in self.c_ops]) + self.pre_M * 0
-        self.e_c = [qt.spre(c + c.dag()) for c in self.sc_ops]
-
     def set_state(self, t, state0, generator):
         """
         Set the state of the SODE solver.
@@ -139,35 +132,6 @@ def _step(self, t, state, dt, dW):
             out = out / _data.norm.l2(out)
         return out
 
-    def _step_superops(self, t, state, dt, dW):
-        dy = [
-            op.expect_data(t, state) * dt + dw
-            for op, dw in zip(self.e_c, dW)
-        ]
-
-        temp = self.pre_M.matmul_data(t, state)
-        Mrho = _data.add(state, temp, dt)
-
-        for i in range(self.num_collapses):
-            Mrho = _data.add(Mrho, self.pre_sc[i].matmul_data(t, state), dy[i])
-            Mrho = _data.add(Mrho, self.pre_cc[i][i].matmul_data(t, state), (dy[i]**2-dt)/2)
-            for j in range(i):
-                Mrho = _data.add(Mrho, self.pre_cc[i][j].matmul_data(t, state), dy[i]*dy[j])
-
-        temp = self.post_M.matmul_data(t, Mrho)
-        MrhoM = _data.add(Mrho, temp, dt)
-
-        dy = np.conj(dy)
-        for i in range(self.num_collapses):
-            MrhoM = _data.add(MrhoM, self.post_sc[i].matmul_data(t, Mrho), dy[i])
-            MrhoM = _data.add(MrhoM, self.post_cc[i][i].matmul_data(t, Mrho), (dy[i]**2-dt)/2)
-            for j in range(i):
-                MrhoM = _data.add(MrhoM, self.post_cc[i][j].matmul_data(t, Mrho), dy[i]*dy[j])
-
-        out = _data.add(MrhoM, self.pp_cc.matmul_data(t, state), dt)
-
-        return out / _data.trace_oper_ket(out)
-
     @property
     def options(self):
         """
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index c8f070f37c..ff48a89dcc 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -86,19 +86,10 @@ cdef class StochasticClosedSystem(_StochasticSystem):
     cdef readonly Dense _a, temp, _b_vec, _c_vec, _Lb
     cdef readonly complex _e
 
-    def __init__(self, H, sc_ops, heterodyne=False):
+    def __init__(self, H, sc_ops):
         self.H = -1j * H
-        if heterodyne:
-            self.c_ops = []
-            self.cpcd_ops = []
-            for c_op in sc_ops:
-                self.c_ops.append(c_op / np.sqrt(2))
-                self.c_ops.append(c_op * (-1j / np.sqrt(2)))
-                self.cpcd_ops.append((c_op + c_op.dag()) / np.sqrt(2))
-                self.cpcd_ops.append((-c_op + c_op.dag()) * 1j / np.sqrt(2))
-        else:
-            self.c_ops = sc_ops
-            self.cpcd_ops = [op + op.dag() for op in sc_ops]
+        self.c_ops = sc_ops
+        self.cpcd_ops = [op + op.dag() for op in sc_ops]
 
         self.num_collapse = len(self.c_ops)
         for c_op in self.c_ops:
@@ -148,7 +139,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef complex[:, :, ::1] _Lb
     cdef complex[:, :, :, ::1] _LLb
 
-    def __init__(self, H, sc_ops, c_ops=(), heterodyne=False):
+    def __init__(self, H, sc_ops, c_ops=()):
         if H.issuper:
             self.L = H + liouvillian(None, sc_ops)
         else:
@@ -156,15 +147,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         if c_ops:
             self.L = self.L + liouvillian(None, c_ops)
 
-        if heterodyne:
-            self.c_ops = []
-            for c in sc_ops:
-                self.c_ops += [
-                    (spre(c) + spost(c.dag())) / np.sqrt(2),
-                    (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)
-                ]
-        else:
-            self.c_ops = [spre(op) + spost(op.dag()) for op in sc_ops]
+        self.c_ops = [spre(op) + spost(op.dag()) for op in sc_ops]
         self.num_collapse = len(self.c_ops)
         self.issuper = True
         self.dims = self.L.dims
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 97f654b3c0..34e21a878e 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -55,8 +55,8 @@ def _post_init(self):
 class StochasticRHS:
     def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
 
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("...")
+        if not isinstance(H, (Qobj, QobjEvo)) or not H.isoper:
+            raise TypeError("The Hamiltonian must be am operator")
         self.H = QobjEvo(H)
 
         if isinstance(sc_ops, (Qobj, QobjEvo)):
@@ -76,6 +76,13 @@ def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
         self.issuper = issuper
         self.heterodyne = heterodyne
 
+        if heterodyne:
+            sc_ops = []
+            for c_op in self.sc_ops:
+                sc_ops.append(c_op / np.sqrt(2))
+                sc_ops.append(c_op * (-1j / np.sqrt(2)))
+            self.sc_ops = sc_ops
+
         if self.issuper and not self.H.issuper:
             self.dims = [self.H.dims, self.H.dims]
         else:
@@ -83,13 +90,9 @@ def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
 
     def __call__(self):
         if self.issuper:
-            return StochasticOpenSystem(
-                self.H , self.sc_ops, self.c_ops, self.heterodyne
-            )
+            return StochasticOpenSystem(self.H , self.sc_ops, self.c_ops)
         else:
-            return StochasticClosedSystem(
-                self.H , self.sc_ops, self.heterodyne
-            )
+            return StochasticClosedSystem(self.H , self.sc_ops)
 
 
 def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
@@ -141,14 +144,10 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
 
         An instance of the class :class:`qutip.solver.Result`.
     """
-    H = QobjEvo(H, args=args)
-    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
-    sc_ops = [QobjEvo(c_op, args=args) for c_op in sc_ops]
-    if H.issuper:
-        L = H + liouvillian(None, c_ops)
-    else:
-        L = liouvillian(H, c_ops)
-    sol = SMESolver(L, sc_ops, options=options or {}, m_ops=m_ops)
+    H = QobjEvo(H, args=args, tlist=tlist)
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+    sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
+    sol = SMESolver(H, sc_ops, c_ops=c_ops, options=options, m_ops=m_ops)
     return sol.run(rho0, tlist, ntraj, e_ops=e_ops)
 
 
@@ -201,9 +200,9 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
 
         An instance of the class :class:`qutip.solver.Result`.
     """
-    H = QobjEvo(H, args=args)
-    sc_ops = [QobjEvo(c_op, args=args) for c_op in sc_ops]
-    sol = SSESolver(H, sc_ops, options=options or {}, m_ops=m_ops)
+    H = QobjEvo(H, args=args, tlist=tlist)
+    sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
+    sol = SSESolver(H, sc_ops, options=options, m_ops=m_ops)
     return sol.run(psi0, tlist, ntraj, e_ops=e_ops)
 
 
@@ -219,7 +218,7 @@ class StochasticSolver(MultiTrajSolver):
         "store_states": None,
         "keep_runs_results": False,
         "normalize_output": False,
-        "method": "platen",
+        "method": "rouchon",
         "map": "serial",
         "job_timeout": None,
         "num_cpus": None,
@@ -232,15 +231,15 @@ class StochasticSolver(MultiTrajSolver):
     def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
         self.options = options
         heterodyne = self.options["heterodyne"]
-        if c_ops:
-            raise ValueError("ssesolve c_ops")
+        if self.name == "ssesolve" and c_ops:
+            raise ValueError("")
 
-        rhs = StochasticRHS(self.name=="smesolve", H, sc_ops, c_ops, heterodyne)
+        rhs = StochasticRHS(self._open, H, sc_ops, c_ops, heterodyne)
         super().__init__(rhs, options=options)
 
         if self.options["store_measurement"]:
             n_m_ops = len(sc_ops) * (1 + int(heterodyne))
-            dW_factor = self.options["dw_factor"]
+            dW_factor = self.options["dw_factor"] or 1.
 
             if len(m_ops) == n_m_ops:
                 self.m_ops = m_ops
@@ -250,10 +249,9 @@ def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
                     self.m_ops += [
                         op + op.dag(), -1j * (op - op.dag())
                     ]
-                dW_factor = dW_factor or 2**0.5
+                dW_factor = dW_factor * 0.5**0.5
             else:
                 self.m_ops = [op + op.dag() for op in sc_ops]
-                dW_factor = dW_factor or 1.
 
             if not isinstance(dW_factor, Iterable):
                 dW_factor = [dW_factor] * n_m_ops
@@ -299,8 +297,10 @@ def avail_integrators(cls):
 class SMESolver(StochasticSolver):
     name = "smesolve"
     _avail_integrators = {}
+    _open = True
 
 
 class SSESolver(StochasticSolver):
     name = "ssesolve"
     _avail_integrators = {}
+    _open = False
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index a87259d38b..a27eb5fdd4 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -4,7 +4,7 @@
     mesolve, liouvillian, QobjEvo, spre, spost,
     destroy, coherent, qeye, fock_dm, num
 )
-from qutip.solver.stochastic import smesolve
+from qutip.solver.stochastic import smesolve, ssesolve
 from qutip.core import data as _data
 
 
@@ -42,10 +42,61 @@ def _make_system(N, system):
     "simple", "2 c_ops", "H td", "complex", "c_ops td",
 ])
 @pytest.mark.parametrize("heterodyne", [True, False])
-def test_smesolve(heterodyne, system):
+@pytest.mark.parametrize("method", ["milstein", "platen", "rouchon"])
+def test_smesolve(method, heterodyne, system):
     "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.05
+    N = 4
+    ntraj = 20
+
+    H, sc_ops = _make_system(N, system)
+    c_ops = [destroy(N)]
+    psi0 = coherent(N, 0.5)
+    a = destroy(N)
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, c_ops + sc_ops, e_ops, args={"a": 2})
+
+    options = {
+        "heterodyne": heterodyne,
+        "store_measurement": True,
+        "map": "serial",
+        "method": method,
+    }
 
+    res = smesolve(
+        H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, c_ops=c_ops,
+        ntraj=ntraj, args={"a": 2}, options=options
+    )
+
+    for idx in range(len(e_ops)):
+        np.testing.assert_allclose(
+            res.expect[idx], res_ref.expect[idx], rtol=tol, atol=tol
+        )
+
+    assert len(res.measurement) == ntraj
+
+    if heterodyne:
+        assert all([
+            m.shape == (len(sc_ops), 2, len(times)-1)
+            for m in res.measurement
+        ])
+    else:
+        assert all([
+            m.shape == (len(sc_ops), len(times)-1)
+            for m in res.measurement
+        ])
+
+
+@pytest.mark.parametrize("system", [
+    "simple", "2 c_ops", "H td", "complex", "c_ops td",
+])
+@pytest.mark.parametrize("heterodyne", [True, False])
+@pytest.mark.parametrize("method", ["platen", "rouchon"])
+def test_ssesolve(method, heterodyne, system):
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.1
     N = 4
     ntraj = 20
 
@@ -61,11 +112,11 @@ def test_smesolve(heterodyne, system):
         "heterodyne": heterodyne,
         "store_measurement": True,
         "map": "serial",
-        "method": "milstein",
+        "method": method,
     }
 
-    res = smesolve(
-        H, psi0, times, [], sc_ops, e_ops,
+    res = ssesolve(
+        H, psi0, times, sc_ops, e_ops,
         ntraj=ntraj, args={"a": 2}, options=options
     )
 
@@ -78,7 +129,7 @@ def test_smesolve(heterodyne, system):
 
     if heterodyne:
         assert all([
-            m.shape == (len(sc_ops), 2, len(times)-1) 
+            m.shape == (len(sc_ops), 2, len(times)-1)
             for m in res.measurement
         ])
     else:
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index c03c7112be..fb0923543c 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -131,8 +131,8 @@ def _run_derr_check(solver, state):
         _check_equivalence(L0(solver, b), solver.L0bi(i), (t, state))
         _check_equivalence(L(solver, i, a), solver.Lia(i), (t, state))
 
-        for j in range(N):
-            for k in range(N):
+        for j in range(i, N):
+            for k in range(j, N):
                 _check_equivalence(
                     LL(solver, k, j, b), solver.LiLjbk(k, j, i), (t, state)
                 )
@@ -154,7 +154,7 @@ def _make_oper(kind, N):
     return QobjEvo(out)
 
 
-@pytest.mark.parametrize(['H', 'c_ops'], [
+@pytest.mark.parametrize(['H', 'sc_ops'], [
     pytest.param("qeye", ["destroy"], id='simple'),
     pytest.param("tridiag", ["destroy"], id='simple'),
     pytest.param("qeye", ["destroy", "destroy2"], id='2 c_ops'),
@@ -163,11 +163,17 @@ def _make_oper(kind, N):
     pytest.param("rand", ["rand"], id='random'),
 ])
 @pytest.mark.parametrize('heterodyne', [False, True])
-def test_open_system(H, c_ops, heterodyne):
+def test_open_system_derr(H, sc_ops, heterodyne):
     N = 5
     H = _make_oper(H, N)
-    c_ops = [_make_oper(op, N) for op in c_ops]
-    H = liouvillian(H)
-    system = StochasticOpenSystem(H, c_ops, heterodyne=heterodyne)
+    sc_ops = [_make_oper(op, N) for op in sc_ops]
+    if heterodyne:
+        new_sc_ops = []
+        for c_op in sc_ops:
+            new_sc_ops.append(c_op / np.sqrt(2))
+            new_sc_ops.append(c_op * (-1j / np.sqrt(2)))
+        sc_ops = new_sc_ops
+
+    system = StochasticOpenSystem(H, sc_ops)
     state = operator_to_vector(fock_dm(N, N-2, dtype="Dense")).data
     _run_derr_check(system, state)

From c079554bd04e3abd5514a56a6f075e54d0bfe807 Mon Sep 17 00:00:00 2001
From: awkwardPotato812 <srinidhi.812@gmail.com>
Date: Tue, 14 Mar 2023 04:25:06 +0530
Subject: [PATCH 144/602] Address review comments

---
 qutip/core/coefficient.py     |  4 ++--
 qutip/core/cy/coefficient.pyx | 16 +++++++---------
 qutip/core/cy/qobjevo.pyx     | 25 +++++++++++++------------
 3 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index c73799a78a..d029461f1a 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -150,7 +150,7 @@ def f2_t(t, args):
     compile_opt : CompilationOptions, optional
         Sets of options for the compilation of string based coefficients.
 
-    bc_type: 2-tupule or None, optional
+    boundary_conditions: 2-tupule, str or None, optional
         Specify boundary conditions for spline interpolation.
 
     **kwargs
@@ -163,7 +163,7 @@ def f2_t(t, args):
         'order': order,
         'compile_opt': compile_opt,
         'function_style': function_style,
-        'bc_type': bc_type,
+        'boundary_conditions': boundary_conditions
     })
 
     for type_ in coefficient_builders:
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 36c79377c7..39b1ff126c 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -388,13 +388,10 @@ cdef class InterCoefficient(Coefficient):
         Order of the interpolation. Order ``0`` uses the previous (i.e. left)
         value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
 
-    bc_type : 2-Tuple or None, optional
-        Boundary conditions for spline evaluation. Default value is `None` to
-        enable automatically choosing boundary conditions. Otherwise, a two-length
-        tuple of form (`deriv_l`, `deriv_r`) must be passed. Here, `deriv_l` denotes
-        the boundary conditions at ```t = 0``` and deriv_r, the conditions at time
-        ```t```. The condition specified must be an iterable pair of form (`order`,
-        `value`). Refer to Scipy's documentation for further details:
+    boundary_conditions : 2-Tuple, str or None, optional
+        Boundary conditions for spline evaluation. Default value is `None`.
+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+        Refer to Scipy's documentation for further details:
         https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
     """
     cdef int order
@@ -403,7 +400,7 @@ cdef class InterCoefficient(Coefficient):
     cdef complex[:, :] poly
     cdef object np_arrays
 
-    def __init__(self, coeff_arr, tlist, int order, bc_type, **_):
+    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
         tlist = np.array(tlist, dtype=np.float64)
         coeff_arr = np.array(coeff_arr, dtype=np.complex128)
 
@@ -427,7 +424,8 @@ cdef class InterCoefficient(Coefficient):
         elif order >= 2:
             # Use scipy to compute the spline and transform it to polynomes
             # as used in scipy's PPoly which is easier for us to use.
-            spline = make_interp_spline(tlist, coeff_arr, k=order, bc_type=bc_type)
+            spline = make_interp_spline(tlist, coeff_arr, k=order, 
+            bc_type=boundary_conditions)
             # Scipy can move knots, we add them to tlist
             tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
             a = np.arange(spline.k+1)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 881f3b04a1..1a72d84740 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -100,13 +100,10 @@ cdef class QobjEvo:
         is used. Otherwise the supplied value overrides the global setting.
 
 
-    bc_type : 2-Tuple or None, optional
-        Boundary conditions for spline evaluation. Default value is `None` to
-        enable automatically choosing boundary conditions. Otherwise, a two-length
-        tuple of form (`deriv_l`, `deriv_r`) must be passed. Here, `deriv_l` denotes
-        the boundary conditions at ```t = 0``` and deriv_r, the conditions at time
-        ```t```. The condition specified must be an iterable pair of form (`order`,
-        `value`). Refer to Scipy's documentation for further details:
+    boundary_conditions : 2-Tuple, str or None, optional
+        Boundary conditions for spline evaluation. Default value is `None`.
+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+        Refer to Scipy's documentation for further details:
         https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
 
 
@@ -193,7 +190,7 @@ cdef class QobjEvo:
     """
     def __init__(QobjEvo self, Q_object, args=None, tlist=None,
                  order=3, copy=True, compress=True,
-                 function_style=None, bc_type=None):
+                 function_style=None, boundary_conditions=None):
         if isinstance(Q_object, QobjEvo):
             self.dims = Q_object.dims.copy()
             self.shape = Q_object.shape
@@ -228,21 +225,24 @@ cdef class QobjEvo:
                 self.elements.append(
                     self._read_element(
                         op, copy=copy, tlist=tlist, args=args, order=order,
-                        function_style=function_style, bc_type=bc_type
+                        function_style=function_style, 
+                        boundary_conditions=boundary_conditions
                     )
                 )
         else:
             self.elements.append(
                 self._read_element(
                     Q_object, copy=copy, tlist=tlist, args=args, order=order,
-                    function_style=function_style, bc_type=bc_type
+                    function_style=function_style, 
+                    boundary_conditions=boundary_conditions
                 )
             )
 
         if compress:
             self.compress()
 
-    def _read_element(self, op, copy, tlist, args, order, function_style, bc_type):
+    def _read_element(self, op, copy, tlist, args, order, function_style, 
+    boundary_conditions):
         """ Read a Q_object item and return an element for that item. """
         if isinstance(op, Qobj):
             out = _ConstantElement(op.copy() if copy else op)
@@ -250,7 +250,8 @@ cdef class QobjEvo:
         elif isinstance(op, list):
             out = _EvoElement(
                 op[0].copy() if copy else op[0],
-                coefficient(op[1], tlist=tlist, args=args, order=order, bc_type=bc_type)
+                coefficient(op[1], tlist=tlist, args=args, order=order, 
+                boundary_conditions=boundary_conditions)
             )
             qobj = op[0]
         elif isinstance(op, _BaseElement):

From fb534e2f151472577efdffed447b5b7df8b634d4 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 09:27:53 +0000
Subject: [PATCH 145/602] Add full option in __repr__

---
 qutip/core/options.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index 338c2642b0..f264493a07 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -31,10 +31,10 @@ def __setitem__(self, key, value):
         # Let the dict catch the KeyError
         self.options[key] = value
 
-    def __repr__(self):
+    def __repr__(self, full=True):
         out = [f"<{self.__class__.__name__}("]
         for key, value in self.options.items():
-            if value != self._options[key]:
+            if  full or value != self._options[key]:
                 out += [f"    '{key}': {repr(value)},"]
         out += [")>"]
         return "\n".join(out)

From 3bb1be99751692260f9e3643fa2b1fd8397d46a7 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 14 Mar 2023 11:45:46 +0100
Subject: [PATCH 146/602] Disable Windows test suite warnings.

---
 .github/workflows/tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 844b3712d5..4324cb8116 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -96,7 +96,7 @@ jobs:
           - case-name: Windows Latest
             os: windows-latest
             python-version: "3.10"
-            pytest-extra-options: "-k 'not (test_correlation or test_interpolate or test_mcsolve)'"
+            #pytest-extra-options: "-k 'not (test_correlation or test_interpolate or test_mcsolve)'"
 
     steps:
       - uses: actions/checkout@v3

From 3cfe107fc073eef1929b31db6ef61a95070c3973 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 14 Mar 2023 13:06:59 +0100
Subject: [PATCH 147/602] Remove Windows warning suppression.

---
 .github/workflows/tests.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 4324cb8116..dd172510de 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -96,7 +96,6 @@ jobs:
           - case-name: Windows Latest
             os: windows-latest
             python-version: "3.10"
-            #pytest-extra-options: "-k 'not (test_correlation or test_interpolate or test_mcsolve)'"
 
     steps:
       - uses: actions/checkout@v3

From 7b30a34cf951b31afd34f5f0fc007216777f952f Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 14 Mar 2023 13:07:11 +0100
Subject: [PATCH 148/602] Add towncrier entry.

---
 doc/changes/2119.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2119.misc

diff --git a/doc/changes/2119.misc b/doc/changes/2119.misc
new file mode 100644
index 0000000000..221d3d2ca9
--- /dev/null
+++ b/doc/changes/2119.misc
@@ -0,0 +1 @@
+Remove Windows build warning suppression.

From 6b99be20fd708c19aeed0233963cc836d67f3dbc Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 16:32:17 +0000
Subject: [PATCH 149/602] Made settings print short and settings.compile print
 long

---
 qutip/core/options.py | 9 +++++++--
 qutip/settings.py     | 3 ++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index f264493a07..6f988afec3 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -33,11 +33,16 @@ def __setitem__(self, key, value):
 
     def __repr__(self, full=True):
         out = [f"<{self.__class__.__name__}("]
+        cnt = 0
         for key, value in self.options.items():
-            if  full or value != self._options[key]:
+            if full or value != self._options[key]:
                 out += [f"    '{key}': {repr(value)},"]
+                cnt += 1
         out += [")>"]
-        return "\n".join(out)
+        if cnt:
+            return "\n".join(out)
+        else:
+            return "".join(out)
 
     def __enter__(self):
         self._backup = getattr(settings, self._settings_name)
diff --git a/qutip/settings.py b/qutip/settings.py
index 6e64473073..a10e527ddb 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -286,7 +286,8 @@ def __str__(self):
                     lines.append(f"    {attr}: {self.__getattribute__(attr)}")
         if "compile" in self.__dir__():
             attr = "compile"
-            lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+            content = self.__getattribute__('compile').__repr__(full=False)
+            lines.append(f"    {attr}: {content}")
         return '\n'.join(lines)
 
     def __repr__(self):

From e2915f12adc64d9ce7e51d58dcb0a975c66d9e30 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:10:58 +0000
Subject: [PATCH 150/602] Replace _solve with _data.solve

---
 qutip/solver/countstat.py | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 58c1d135cf..dd3bde6114 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -12,6 +12,7 @@
     sprepost, spre, qeye, tensor, expect, Qobj,
     operator_to_vector, vector_to_operator
 )
+#_data.solveになる
 from ..core import data as _data
 from .steadystate import pseudo_inverse, steadystate
 from ..settings import settings
@@ -75,15 +76,10 @@ def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
 
 
 def _solve(A, V):
-    try:
-        if settings.has_mkl:
-            out = mkl_spsolve(A.tocsc(), V)
-        else:
-            A.sort_indices()
-            out = sp.linalg.splu(A, permc_spec='COLAMD').solve(V)
-    except Exception:
-        out = sp.linalg.lsqr(A, V)[0]
-    return out
+    if settings.has_mkl:
+        return _data.solve(A, V, "mkl_spsolve", {"csc": True})
+    else:
+        return _data.solve(A, V, "splu")
 
 
 def _noise_direct(L, wlist, rhoss, J_ops):
@@ -112,9 +108,8 @@ def _noise_direct(L, wlist, rhoss, J_ops):
             # helps prevent the solvers from throwing an exception.
             L_temp = 1e-15j * spre(tr_op) + L
 
-        A = _data.to(_data.CSR, L_temp.data).as_scipy()
-        X_rho = [_data.dense.fast_from_numpy(_solve(A, op))
-                 for op in Q_ops]
+        A = _data.to(_data.CSR, L_temp.data)
+        X_rho = [_data.solve(A, _data.Dense(op)) for op in Q_ops]
 
         for i, j in product(range(N_j_ops), repeat=2):
             if i == j:

From 92f6735f6355b73f73a0c4587a3b9443b5107d41 Mon Sep 17 00:00:00 2001
From: Yuji TAMAKOSHI <72233550+tamakoshi2001@users.noreply.github.com>
Date: Wed, 15 Mar 2023 02:16:52 +0900
Subject: [PATCH 151/602] Delete options.py

---
 qutip/core/options.py | 125 ------------------------------------------
 1 file changed, 125 deletions(-)
 delete mode 100644 qutip/core/options.py

diff --git a/qutip/core/options.py b/qutip/core/options.py
deleted file mode 100644
index 6f988afec3..0000000000
--- a/qutip/core/options.py
+++ /dev/null
@@ -1,125 +0,0 @@
-from ..settings import settings
-
-__all__ = ["CoreOptions"]
-
-
-class QutipOptions:
-    """
-    Class for basic functionality for qutip's options.
-
-    Define basic method to wrap an ``options`` dict.
-    Default options are in a class _options dict.
-    """
-    _options = {}
-    _settings_name = None  # Where the default is in settings
-
-    def __init__(self, **options):
-        self.options = self._options.copy()
-        for key in set(options) & set(self.options):
-            self[key] = options.pop(key)
-        if options:
-            raise KeyError(f"Options {set(options)} are not supported.")
-
-    def __contains__(self, key):
-        return key in self.options
-
-    def __getitem__(self, key):
-        # Let the dict catch the KeyError
-        return self.options[key]
-
-    def __setitem__(self, key, value):
-        # Let the dict catch the KeyError
-        self.options[key] = value
-
-    def __repr__(self, full=True):
-        out = [f"<{self.__class__.__name__}("]
-        cnt = 0
-        for key, value in self.options.items():
-            if full or value != self._options[key]:
-                out += [f"    '{key}': {repr(value)},"]
-                cnt += 1
-        out += [")>"]
-        if cnt:
-            return "\n".join(out)
-        else:
-            return "".join(out)
-
-    def __enter__(self):
-        self._backup = getattr(settings, self._settings_name)
-        setattr(settings, self._settings_name, self)
-
-    def __exit__(self, exc_type, exc_value, exc_traceback):
-        setattr(settings, self._settings_name, self._backup)
-
-
-class CoreOptions(QutipOptions):
-    """
-    Options used by the core of qutip such as the tolerance of :class:`Qobj`
-    comparison or coefficient's format.
-
-    Values can be changed in ``qutip.settings.core`` or by using context:
-    ``with CoreOptions(atol=1e-6): ...``.
-
-    Options
-    -------
-    auto_tidyup : bool
-        Whether to tidyup during sparse operations.
-
-    auto_tidyup_dims : bool [True]
-        Use auto tidyup dims on multiplication. (Not used yet)
-
-    atol : float {1e-12}
-        General absolute tolerance
-
-    rtol : float {1e-12}
-        General relative tolerance
-        Used to choose QobjEvo.expect output type
-
-    auto_tidyup_atol : float {1e-14}
-        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
-        parameter above) and the default value of ``atol`` used in
-        :method:`Qobj.tidyup`.
-
-    function_coefficient_style : str {"auto"}
-        The signature expected by function coefficients. The options are:
-
-        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
-          is the time and the ``...`` are the remaining arguments passed
-          directly into the function. E.g. ``f(t, w, b=5)``.
-
-        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
-          the time and ``args`` is a dict containing the remaining arguments.
-          E.g. ``f(t, {"w": w, "b": 5})``.
-
-        - "auto": select automatically between the two options above based
-          on the signature of the supplied function. If the function signature
-          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
-          ``pythonic`` is used.
-
-    default_dtype : Nonetype, str, type {None}
-        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
-        :func:"rand_herm", will use the specified data type. Any data-layer
-        known to ``qutip.data.to`` is accepted. When ``None``, these functions
-        will default to a sensible data type.
-    """
-    _options = {
-        # use auto tidyup
-        "auto_tidyup": True,
-        # use auto tidyup dims on multiplication
-        "auto_tidyup_dims": True,
-        # general absolute tolerance
-        "atol": 1e-12,
-        # general relative tolerance
-        "rtol": 1e-12,
-        # use auto tidyup absolute tolerance
-        "auto_tidyup_atol": 1e-14,
-        # signature style expected by function coefficients
-        "function_coefficient_style": "auto",
-        # Default Qobj dtype for Qobj create function
-        "default_dtype": None,
-    }
-    _settings_name = "core"
-
-
-# Creating the instance of core options to use everywhere.
-settings.core = CoreOptions()

From 9052312ef0c8bf67496c4db13c19a25998a29e39 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:25:20 +0000
Subject: [PATCH 152/602] Delete _solve

---
 qutip/solver/countstat.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index dd3bde6114..8c8dcc3ace 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -75,13 +75,6 @@ def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
     return current
 
 
-def _solve(A, V):
-    if settings.has_mkl:
-        return _data.solve(A, V, "mkl_spsolve", {"csc": True})
-    else:
-        return _data.solve(A, V, "splu")
-
-
 def _noise_direct(L, wlist, rhoss, J_ops):
     J_ops = [op.data for op in J_ops]
     rhoss_vec = operator_to_vector(rhoss).data

From 798399c2459d4c1220c388a12c46ce05ff520186 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:28:44 +0000
Subject: [PATCH 153/602] Delete unintended change

---
 qutip/core/options.py | 12 +++---------
 qutip/settings.py     |  9 ++-------
 2 files changed, 5 insertions(+), 16 deletions(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index 6f988afec3..fe035d6375 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -31,18 +31,12 @@ def __setitem__(self, key, value):
         # Let the dict catch the KeyError
         self.options[key] = value
 
-    def __repr__(self, full=True):
+    def __repr__(self):
         out = [f"<{self.__class__.__name__}("]
-        cnt = 0
         for key, value in self.options.items():
-            if full or value != self._options[key]:
-                out += [f"    '{key}': {repr(value)},"]
-                cnt += 1
+            out += [f"    '{key}': {repr(value)},"]
         out += [")>"]
-        if cnt:
-            return "\n".join(out)
-        else:
-            return "".join(out)
+        return "\n".join(out)
 
     def __enter__(self):
         self._backup = getattr(settings, self._settings_name)
diff --git a/qutip/settings.py b/qutip/settings.py
index a10e527ddb..7537942884 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -281,13 +281,8 @@ def colorblind_safe(self, value):
     def __str__(self):
         lines = ["Qutip settings:"]
         for attr in self.__dir__():
-            if not attr.startswith('_'):
-                if attr != "core" and attr != "compile":
-                    lines.append(f"    {attr}: {self.__getattribute__(attr)}")
-        if "compile" in self.__dir__():
-            attr = "compile"
-            content = self.__getattribute__('compile').__repr__(full=False)
-            lines.append(f"    {attr}: {content}")
+            if not attr.startswith('_') and attr != "core":
+                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
         return '\n'.join(lines)
 
     def __repr__(self):

From cfa381d4c22ac6f81f854a255914c7c882fe8314 Mon Sep 17 00:00:00 2001
From: awkwardPotato812 <srinidhi.812@gmail.com>
Date: Tue, 14 Mar 2023 23:02:44 +0530
Subject: [PATCH 154/602] Fix formatting issues

---
 qutip/core/cy/coefficient.pyx        | 4 ++--
 qutip/core/cy/qobjevo.pyx            | 8 ++++----
 qutip/tests/core/test_coefficient.py | 2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 39b1ff126c..79fd84e5ae 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -424,8 +424,8 @@ cdef class InterCoefficient(Coefficient):
         elif order >= 2:
             # Use scipy to compute the spline and transform it to polynomes
             # as used in scipy's PPoly which is easier for us to use.
-            spline = make_interp_spline(tlist, coeff_arr, k=order, 
-            bc_type=boundary_conditions)
+            spline = make_interp_spline(tlist, coeff_arr, k=order,
+                                        bc_type=boundary_conditions)
             # Scipy can move knots, we add them to tlist
             tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
             a = np.arange(spline.k+1)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 1a72d84740..85a657dcdf 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -225,7 +225,7 @@ cdef class QobjEvo:
                 self.elements.append(
                     self._read_element(
                         op, copy=copy, tlist=tlist, args=args, order=order,
-                        function_style=function_style, 
+                        function_style=function_style,
                         boundary_conditions=boundary_conditions
                     )
                 )
@@ -233,7 +233,7 @@ cdef class QobjEvo:
             self.elements.append(
                 self._read_element(
                     Q_object, copy=copy, tlist=tlist, args=args, order=order,
-                    function_style=function_style, 
+                    function_style=function_style,
                     boundary_conditions=boundary_conditions
                 )
             )
@@ -242,7 +242,7 @@ cdef class QobjEvo:
             self.compress()
 
     def _read_element(self, op, copy, tlist, args, order, function_style, 
-    boundary_conditions):
+                      boundary_conditions):
         """ Read a Q_object item and return an element for that item. """
         if isinstance(op, Qobj):
             out = _ConstantElement(op.copy() if copy else op)
@@ -251,7 +251,7 @@ cdef class QobjEvo:
             out = _EvoElement(
                 op[0].copy() if copy else op[0],
                 coefficient(op[1], tlist=tlist, args=args, order=order, 
-                boundary_conditions=boundary_conditions)
+                            boundary_conditions=boundary_conditions)
             )
             qobj = op[0]
         elif isinstance(op, _BaseElement):
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index a2ac041e17..e1a967d0ff 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -372,7 +372,7 @@ def test_CoeffFromScipy():
     from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
     _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
 
-    coeff = coefficient(y, tlist=tlist, order=3, bc_type=([(2, 0.0)],[(2, 0.0)]))
+    coeff = coefficient(y, tlist=tlist, order=3, bc_type="natural")
     from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
     _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
 

From ba722c0ae21513850de388f45334c5f57e7367bf Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:40:34 +0000
Subject: [PATCH 155/602] delete notes

---
 qutip/solver/countstat.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 8c8dcc3ace..e64db9d0bb 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -12,7 +12,7 @@
     sprepost, spre, qeye, tensor, expect, Qobj,
     operator_to_vector, vector_to_operator
 )
-#_data.solveになる
+
 from ..core import data as _data
 from .steadystate import pseudo_inverse, steadystate
 from ..settings import settings

From 446cb0a415228cca245d31a59ddf6347dc23b16d Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:41:14 +0000
Subject: [PATCH 156/602] delete indent

---
 qutip/solver/countstat.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index e64db9d0bb..8ccc12bd6f 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -12,7 +12,6 @@
     sprepost, spre, qeye, tensor, expect, Qobj,
     operator_to_vector, vector_to_operator
 )
-
 from ..core import data as _data
 from .steadystate import pseudo_inverse, steadystate
 from ..settings import settings

From d8f4909772752e243279f3cee695a06651469828 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:47:44 +0000
Subject: [PATCH 157/602] Add doc

---
 doc/changes/2120.removal | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2120.removal

diff --git a/doc/changes/2120.removal b/doc/changes/2120.removal
new file mode 100644
index 0000000000..bf31f96af5
--- /dev/null
+++ b/doc/changes/2120.removal
@@ -0,0 +1 @@
+Deleted _solve in countstat.py and used _data.solve.
\ No newline at end of file

From ef15a628c6b29af0d5c89a7b65400cbce4d3e7b7 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 14 Mar 2023 17:53:14 +0000
Subject: [PATCH 158/602] add doc

---
 doc/changes/2113.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2113.feature

diff --git a/doc/changes/2113.feature b/doc/changes/2113.feature
new file mode 100644
index 0000000000..5a18cdf084
--- /dev/null
+++ b/doc/changes/2113.feature
@@ -0,0 +1 @@
+Improve print(qutip.settings) by make it shorter
\ No newline at end of file

From 23a64eda2c8cf86ee6e03d2c79d9110cdd1fefe0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 14 Mar 2023 18:44:42 -0400
Subject: [PATCH 159/602] Add implicit methods

---
 qutip/solver/sode/_sode.pyx            | 124 +++++++++++++++++++++++++
 qutip/solver/sode/itotaylor.py         |  99 +++++++++++++++++++-
 qutip/solver/sode/sode.py              |  80 +++++++++++++++-
 qutip/solver/sode/ssystem.pxd          |   3 +
 qutip/solver/sode/ssystem.pyx          |  59 ++++++------
 qutip/solver/stochastic.py             |   6 +-
 qutip/tests/solver/test_sode_method.py |  10 ++
 7 files changed, 341 insertions(+), 40 deletions(-)

diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 32f35b1e11..e3d878d8f7 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -354,6 +354,7 @@ cdef class PredCorr:
 
 
 cdef class Taylor15(Milstein):
+    """
     @cython.wraparound(False)
     def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
         cdef int i
@@ -366,6 +367,7 @@ cdef class Taylor15(Milstein):
             self.step(t + i * dt, state, dt, dW[i, :, :], out)
             state, out = out, state
         return state
+    """
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
@@ -405,3 +407,125 @@ cdef class Taylor15(Milstein):
                     iadd_dense(out, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
 
         return out
+
+
+cdef class Milstein_imp:
+    cdef _StochasticSystem system
+    cdef bint use_inv
+    cdef QobjEvo implicit
+    cdef Data inv
+    cdef double prev_dt
+    cdef dict imp_opt
+
+    def __init__(self, _StochasticSystem system, imp_method=None, imp_options={}):
+        self.system = system
+        self.prev_dt = 0
+        if imp_method == "inv":
+            if not self.system.L.isconstant:
+                raise TypeError("")
+            self.use_inv = True
+        else:
+            self.use_inv = False
+            self.imp_opt = {"method": imp_method, "options": imp_options}
+
+
+    @cython.wraparound(False)
+    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
+        cdef int i
+        if type(state) != _data.Dense:
+            state = _data.to(_data.Dense, state)
+        cdef Dense tmp = _data.mul_dense(state, 0)
+        state = state.copy()
+
+        if dt != self.prev_dt:
+            self.implicit = 1 - self.system.L * (dt / 2)
+            if self.use_inv:
+                self.inv = _data.inv(self.implicit._call(0))
+
+        for i in range(ntraj):
+            state = self.step(t + i * dt, state, dt, dW[i, :, :], tmp)
+        return state
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef Data step(self, double t, Dense state, double dt, double[:, :] dW, Dense target):
+        """
+        Chapter 10.3 Eq. (3.1)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+
+        dV = -iH*V*dt + d1*dt + d2_i*dW_i
+        + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+        """
+        cdef _StochasticSystem system = self.system
+        cdef int i, j, num_ops = system.num_collapse
+        cdef double dw
+
+        system.set_state(t, state)
+
+        imul_dense(target, 0.)
+        iadd_dense(target, state, 1)
+        iadd_dense(target, system.a(), dt * 0.5)
+
+        for i in range(num_ops):
+            iadd_dense(target, system.bi(i), dW[0, i])
+
+        for i in range(num_ops):
+            for j in range(i, num_ops):
+                if i == j:
+                    dw = (dW[0, i] * dW[0, j] - dt) * 0.5
+                else:
+                    dw = dW[0, i] * dW[0, j]
+                iadd_dense(target, system.Libj(i, j), dw)
+
+        if self.use_inv:
+            out = _data.matmul(self.inv, target)
+        else:
+            out = _data.solve(self.implicit._call(t+dt), target, **self.imp_opt)
+
+        return out
+
+
+cdef class Taylor15_imp(Milstein_imp):
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef Data step(self, double t, Dense state, double dt, double[:, :] dW, Dense target):
+        """
+        Chapter 12.2 Eq. (2.18),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef _StochasticSystem system = self.system
+        system.set_state(t, state)
+        cdef int i, j, k, num_ops = system.num_collapse
+        cdef double[:] dz, dw
+
+        num_ops = system.num_collapse
+        dw = dW[0, :]
+        dz = 0.5 * (dW[0, :] + dW[1, :] / np.sqrt(3)) * dt
+
+        imul_dense(target, 0.)
+        iadd_dense(target, state, 1)
+        iadd_dense(target, system.a(), dt * 0.5)
+
+        for i in range(num_ops):
+            iadd_dense(target, system.bi(i), dw[i])
+            iadd_dense(target, system.Libj(i, i), 0.5 * (dw[i] * dw[i] - dt))
+            iadd_dense(target, system.Lia(i), dz[i] - dw[i] * dt * 0.5)
+            iadd_dense(target, system.L0bi(i), dw[i] * dt - dz[i])
+            iadd_dense(target, system.LiLjbk(i, i, i),
+                             0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i])
+
+            for j in range(i+1, num_ops):
+                iadd_dense(target, system.Libj(i, j), dw[i] * dw[j])
+                iadd_dense(target, system.LiLjbk(i, j, j), 0.5 * (dw[j] * dw[j] -dt) * dw[i])
+                iadd_dense(target, system.LiLjbk(i, i, j), 0.5 * (dw[i] * dw[i] -dt) * dw[j])
+                for k in range(j+1, num_ops):
+                    iadd_dense(target, system.LiLjbk(i, j, k), dw[i]*dw[j]*dw[k])
+
+        if self.use_inv:
+            out = _data.matmul(self.inv, target)
+        else:
+            out = _data.solve(self.implicit._call(t+dt), target, **self.imp_opt)
+
+        return out
diff --git a/qutip/solver/sode/itotaylor.py b/qutip/solver/sode/itotaylor.py
index 0f0d895bc0..eba58af542 100644
--- a/qutip/solver/sode/itotaylor.py
+++ b/qutip/solver/sode/itotaylor.py
@@ -1,6 +1,6 @@
 import numpy as np
 from . import _sode
-from .sode import _Explicit_Simple_Integrator
+from .sode import _Explicit_Simple_Integrator, _Implicit_Simple_Integrator
 from ..stochastic import StochasticSolver, SMESolver
 
 
@@ -22,8 +22,8 @@ class EulerSODE(_Explicit_Simple_Integrator):
 class Milstein_SODE(_Explicit_Simple_Integrator):
     """
     An order 1.0 strong Taylor scheme.  Better approximate numerical
-    solution to stochastic differential equations.  See eq. (2.9) of
-    chapter 12.2 of Peter E. Kloeden and Exkhard Platen,
+    solution to stochastic differential equations.  See eq. (3.12) of
+    chapter 10.3 of Peter E. Kloeden and Exkhard Platen,
     *Numerical Solution of Stochastic Differential Equations*..
 
     - Order strong 1.0
@@ -41,9 +41,35 @@ class Taylor1_5_SODE(_Explicit_Simple_Integrator):
 
     - Order strong 1.5
     """
+    integrator_options = {
+        "dt": 0.001,
+        "tol": 1e-10,
+        "derr_dt": 1e-6,
+    }
     stepper = _sode.Taylor15
     N_dw = 2
 
+    @property
+    def options(self):
+        """
+        Supported options by Explicit Stochastic Integrators:
+
+        dt : float, default=0.001
+            Internal time step.
+
+        tol : float, default=1e-10
+            Relative tolerance.
+
+        derr_dt : float, default=1e-6
+            Finite time difference used to compute the derrivative of the
+            hamiltonian and ``sc_ops``.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        _Explicit_Simple_Integrator.options.fset(self, new_options)
+
 
 class Explicit1_5_SODE(_Explicit_Simple_Integrator):
     """
@@ -60,7 +86,74 @@ class Explicit1_5_SODE(_Explicit_Simple_Integrator):
     N_dw = 2
 
 
+class Implicit_Milstein_SODE(_Implicit_Simple_Integrator):
+    """
+    An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
+    scheme for the numerical simulation of stiff stochastic
+    differential equations.  Eq. (2.11) with alpha=0.5 of
+    chapter 12.2 of Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations*.
+
+    - Order strong 1.0
+    """
+    stepper = _sode.Milstein_imp
+    N_dw = 1
+
+
+class Implicit_Taylor1_5_SODE(_Implicit_Simple_Integrator):
+    """
+    Order 1.5 strong Taylor scheme.  Solver with more terms of the
+    Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
+    :obj:`~ssesolve`.  Eq. (2.18) with alpha=0.5 of chapter 12.2 of
+    Peter E. Kloeden and Exkhard Platen,
+    *Numerical Solution of Stochastic Differential Equations*.
+
+    - Order strong 1.5
+    """
+    integrator_options = {
+        "dt": 0.001,
+        "tol": 1e-10,
+        "solve_method": None,
+        "solve_options": {},
+        "deff_dt": 1e-6
+    }
+    stepper = _sode.Taylor15_imp
+    N_dw = 2
+
+    @property
+    def options(self):
+        """
+        Supported options by Explicit Stochastic Integrators:
+
+        dt : float, default=0.001
+            Internal time step.
+
+        tol : float, default=1e-10
+            Tolerance for the time steps.
+
+        solve_method : str, default=None
+            Method used for solver the ``Ax=b`` of the implicit step.
+            Accept methods supported by :func:`qutip.core.data.solve`.
+            When the system is constant, the inverse of the matrix ``A`` can be
+            used by entering ``inv``.
+
+        solve_options : dict, default={}
+            Options to pass to the call to :func:`qutip.core.data.solve`.
+
+        derr_dt : float, default=1e-6
+            Finite time difference used to compute the derrivative of the
+            hamiltonian and ``sc_ops``.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        _Implicit_Simple_Integrator.options.fset(self, new_options)
+
+
 StochasticSolver.add_integrator(EulerSODE, "euler")
 StochasticSolver.add_integrator(Explicit1_5_SODE, "explicit1.5")
 SMESolver.add_integrator(Taylor1_5_SODE, "taylor1.5")
 SMESolver.add_integrator(Milstein_SODE, "milstein")
+SMESolver.add_integrator(Implicit_Milstein_SODE, "milstein_imp")
+SMESolver.add_integrator(Implicit_Taylor1_5_SODE, "taylor1.5_imp")
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index d996398a2b..113cdfed9a 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -105,9 +105,9 @@ class _Explicit_Simple_Integrator(SIntegrator):
     N_dw = 0
 
     def __init__(self, rhs, options):
-        self.system = rhs()
         self._options = self.integrator_options.copy()
         self.options = options
+        self.system = rhs(self.options)
         self.step_func = self.stepper(self.system).run
 
     def integrate(self, t, copy=True):
@@ -143,8 +143,58 @@ def options(self):
         dt : float, default=0.001
             Internal time step.
 
-        tol : float, default=1e-7
-            Relative tolerance.
+        tol : float, default=1e-10
+            Tolerance for the time steps.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class _Implicit_Simple_Integrator(_Explicit_Simple_Integrator):
+    """
+    Stochastic evolution solver
+    """
+    integrator_options = {
+        "dt": 0.001,
+        "tol": 1e-10,
+        "solve_method": None,
+        "solve_options": {},
+    }
+    stepper = None
+    N_dw = 0
+
+    def __init__(self, rhs, options):
+        self._options = self.integrator_options.copy()
+        self.options = options
+        self.system = rhs(self.options)
+        self.step_func = self.stepper(
+            self.system,
+            self.options["solve_method"],
+            self.options["solve_options"],
+        ).run
+
+    @property
+    def options(self):
+        """
+        Supported options by Explicit Stochastic Integrators:
+
+        dt : float, default=0.001
+            Internal time step.
+
+        tol : float, default=1e-10
+            Tolerance for the time steps.
+
+        solve_method : str, default=None
+            Method used for solver the ``Ax=b`` of the implicit step.
+            Accept methods supported by :func:`qutip.core.data.solve`.
+            When the system is constant, the inverse of the matrix ``A`` can be
+            used by entering ``inv``.
+
+        solve_options : dict, default={}
+            Options to pass to the call to :func:`qutip.core.data.solve`.
         """
         return self._options
 
@@ -192,13 +242,35 @@ class PredCorr_SODE(_Explicit_Simple_Integrator):
     N_dw = 1
 
     def __init__(self, rhs, options):
-        self.system = rhs()
         self._options = self.integrator_options.copy()
         self.options = options
+        self.system = rhs(self.options)
         self.step_func = self.stepper(
             self.system, self.options["alpha"], self.options["eta"]
         ).run
 
+    @property
+    def options(self):
+        """
+        Supported options by Explicit Stochastic Integrators:
+
+        dt : float, default=0.001
+            Internal time step.
+
+        tol : float, ...
+            ...
+
+        alpha : float, .,,
+
+        eta : float, ...
+            ...
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
 
 StochasticSolver.add_integrator(PlatenSODE, "platen")
 SMESolver.add_integrator(PredCorr_SODE, "pred_corr")
diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index 8be43118a1..b53e994996 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -1,7 +1,10 @@
 #cython: language_level=3
 from qutip.core.data cimport Data, Dense
+from qutip.core.cy.qobjevo cimport QobjEvo
 
 cdef class _StochasticSystem:
+    cdef readonly list c_ops
+    cdef readonly QobjEvo L
     cdef readonly int num_collapse
     cdef readonly bint issuper
     cdef readonly object dims
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index ff48a89dcc..b37e8a113c 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -78,8 +78,6 @@ cdef class _StochasticSystem:
 
 
 cdef class StochasticClosedSystem(_StochasticSystem):
-    cdef readonly QobjEvo H
-    cdef readonly list c_ops
     cdef readonly list cpcd_ops
     cdef bint _a_set, _b_set, _Lb_set
 
@@ -87,22 +85,22 @@ cdef class StochasticClosedSystem(_StochasticSystem):
     cdef readonly complex _e
 
     def __init__(self, H, sc_ops):
-        self.H = -1j * H
+        self.L = -1j * H
         self.c_ops = sc_ops
         self.cpcd_ops = [op + op.dag() for op in sc_ops]
 
         self.num_collapse = len(self.c_ops)
         for c_op in self.c_ops:
-            self.H += -0.5 * c_op.dag() * c_op
+            self.L += -0.5 * c_op.dag() * c_op
         self.issuper = False
-        self.dims = self.H.dims
+        self.dims = self.L.dims
 
     cpdef Data drift(self, t, Data state):
         cdef int i
         cdef QobjEvo c_op
         cdef Data temp, out
 
-        out = self.H.matmul_data(t, state)
+        out = self.L.matmul_data(t, state)
         for i in range(self.num_collapse):
             c_op = self.cpcd_ops[i]
             e = c_op.expect_data(t, state)
@@ -126,8 +124,6 @@ cdef class StochasticClosedSystem(_StochasticSystem):
 
 
 cdef class StochasticOpenSystem(_StochasticSystem):
-    cdef QobjEvo L
-    cdef list c_ops
     cdef int state_size, N_root
     cdef double dt
     cdef int _is_set
@@ -139,7 +135,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef complex[:, :, ::1] _Lb
     cdef complex[:, :, :, ::1] _LLb
 
-    def __init__(self, H, sc_ops, c_ops=()):
+    def __init__(self, H, sc_ops, c_ops=(), derr_dt=1e-6):
         if H.issuper:
             self.L = H + liouvillian(None, sc_ops)
         else:
@@ -154,6 +150,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self.state_size = self.L.shape[1]
         self._is_set = 0
         self.N_root = <int> self.state_size**0.5
+        self.dt = derr_dt
 
     cpdef Data drift(self, t, Data state):
         return self.L.matmul_data(t, state)
@@ -198,7 +195,6 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self._Lb = np.zeros((n, n, l), dtype=complex)
             self._LLb = np.zeros((n, n, n, l), dtype=complex)
             self._La = np.zeros((n, l), dtype=complex)
-            self.dt = 1e-6  #  Make an options
 
     cpdef Data a(self):
         if not self._is_set:
@@ -315,11 +311,12 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             imul_dense(L0b_vec, 0.)
 
             # db/dt
-            c_op.matmul_data(self.t + self.dt, self.state, L0b_vec)
-            expect = trace_oper_ket_dense(L0b_vec)
-            iadd_dense(L0b_vec, self.state, -expect)
-            iadd_dense(L0b_vec, b_vec, -1)
-            imul_dense(L0b_vec, 1/self.dt)
+            if not c_op.isconstant:
+                c_op.matmul_data(self.t + self.dt, self.state, L0b_vec)
+                expect = trace_oper_ket_dense(L0b_vec)
+                iadd_dense(L0b_vec, self.state, -expect)
+                iadd_dense(L0b_vec, b_vec, -1)
+                imul_dense(L0b_vec, 1/self.dt)
 
             # ab'
             imul_dense(self.temp, 0)
@@ -392,9 +389,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     cdef void _compute_L0a(self) except *:
         # L0a = a'a + da/dt + bba"/2  (a" = 0)
         imul_dense(self._L0a, 0.)
-        self.L.matmul_data(self.t + self.dt, self.state, self._L0a)
-        iadd_dense(self._L0a, self._a, -1)
-        imul_dense(self._L0a, 1/self.dt)
+        if not self.L.isconstant:
+            self.L.matmul_data(self.t + self.dt, self.state, self._L0a)
+            iadd_dense(self._L0a, self._a, -1)
+            imul_dense(self._L0a, 1/self.dt)
         self.L.matmul_data(self.t, self._a, self._L0a)
         self._L0a_set = True
 
@@ -402,22 +400,21 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 cdef class SimpleStochasticSystem(_StochasticSystem):
     """
     Simple system that can be solver analytically.
+    Used in tests.
     """
-    cdef QobjEvo H
-    cdef list c_ops
-    cdef float dt
+    cdef double dt
 
     def __init__(self, H, c_ops):
-        self.H = -1j * H
+        self.L = -1j * H
         self.c_ops = c_ops
 
         self.num_collapse = len(self.c_ops)
         self.issuper = False
-        self.dims = self.H.dims
+        self.dims = self.L.dims
         self.dt = 1e-6
 
     cpdef Data drift(self, t, Data state):
-        return self.H.matmul_data(t, state)
+        return self.L.matmul_data(t, state)
 
     cpdef list diffusion(self, t, Data state):
         cdef int i
@@ -431,7 +428,7 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
         self.state = state
 
     cpdef Data a(self):
-        return self.H.matmul_data(self.t, self.state)
+        return self.L.matmul_data(self.t, self.state)
 
     cpdef Data bi(self, int i):
         return self.c_ops[i].matmul_data(self.t, self.state)
@@ -442,11 +439,11 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
 
     cpdef Data Lia(self, int i):
         bi = self.c_ops[i].matmul_data(self.t, self.state)
-        return self.H.matmul_data(self.t, bi)
+        return self.L.matmul_data(self.t, bi)
 
     cpdef Data L0bi(self, int i):
         # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
-        a = self.H.matmul_data(self.t, self.state)
+        a = self.L.matmul_data(self.t, self.state)
         abi = self.c_ops[i].matmul_data(self.t, a)
         b = self.c_ops[i].matmul_data(self.t, self.state)
         bdt = self.c_ops[i].matmul_data(self.t + self.dt, self.state)
@@ -459,9 +456,9 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
 
     cpdef Data L0a(self):
         # L0a = a'a + da/dt + bba"/2  (a" = 0)
-        a = self.H.matmul_data(self.t, self.state)
-        aa = self.H.matmul_data(self.t, a)
-        adt = self.H.matmul_data(self.t + self.dt, self.state)
+        a = self.L.matmul_data(self.t, self.state)
+        aa = self.L.matmul_data(self.t, a)
+        adt = self.L.matmul_data(self.t + self.dt, self.state)
         return aa + (adt - a) / self.dt
 
     def analytic(self, t, W):
@@ -472,7 +469,7 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
         def _intergal(f, T):
             return (f(0) + 4 * f(T/2) + f(T)) / 6
 
-        out = _intergal(self.H, t) * t
+        out = _intergal(self.L, t) * t
         for i in range(self.num_collapse):
             out += _intergal(self.c_ops[i], t) * W[i]
             out -= 0.5 * _intergal(
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 34e21a878e..4c712eddcc 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -88,9 +88,11 @@ def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
         else:
             self.dims = self.H.dims
 
-    def __call__(self):
+    def __call__(self, options):
         if self.issuper:
-            return StochasticOpenSystem(self.H , self.sc_ops, self.c_ops)
+            return StochasticOpenSystem(
+                self.H , self.sc_ops, self.c_ops, options.get("dt", 1.-6)
+            )
         else:
             return StochasticClosedSystem(self.H , self.sc_ops)
 
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index 440f9e28a7..80e90f3a55 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -56,11 +56,17 @@ def _make_oper(kind, N):
 @pytest.mark.parametrize(["method", "order", "kw"], [
     pytest.param("Euler", 0.5, {}, id="Euler"),
     pytest.param("Milstein", 1.0, {}, id="Milstein"),
+    pytest.param("Milstein_imp", 1.0, {}, id="Milstein implicit"),
+    pytest.param("Milstein_imp", 1.0, {"imp_method": "inv"},
+                 id="Milstein implicit inv"),
     pytest.param("Platen", 1.0, {}, id="Platen"),
     pytest.param("PredCorr", 1.0, {}, id="PredCorr"),
     pytest.param("PredCorr", 1.0, {"alpha": 0.5}, id="PredCorr_0.5"),
     pytest.param("Taylor15", 1.5, {}, id="Taylor15"),
     pytest.param("Explicit15", 1.5, {}, id="Explicit15"),
+    pytest.param("Taylor15_imp", 1.5, {}, id="Taylor15 implicit"),
+    pytest.param("Taylor15_imp", 1.5, {"imp_method": "inv"},
+                 id="Taylor15 implicit inv"),
 ])
 @pytest.mark.parametrize(['H', 'sc_ops'], [
     pytest.param("qeye", ["destroy"], id='simple'),
@@ -70,6 +76,8 @@ def _make_oper(kind, N):
     pytest.param("qeye", ["qeye", "destroy", "destroy2"], id='3 sc_ops'),
 ])
 def test_methods(H, sc_ops, method, order, kw):
+    if kw == {"imp_method": "inv"} and ("td" in H or "td" in sc_ops[0]):
+        pytest.skip("inverse method only available for constant cases.")
     N = 5
     H = _make_oper(H, N)
     sc_ops = [_make_oper(op, N) for op in sc_ops]
@@ -109,10 +117,12 @@ def get_error_order_integrator(integrator, ref_integrator, state, plot=False):
 @pytest.mark.parametrize(["method", "order"], [
     pytest.param("euler", 0.5, id="Euler"),
     pytest.param("milstein", 1.0, id="Milstein"),
+    pytest.param("milstein_imp", 1.0, id="Milstein implicit"),
     pytest.param("platen", 1.0, id="Platen"),
     pytest.param("pred_corr", 1.0, id="PredCorr"),
     pytest.param("rouchon", 1.0, id="rouchon"),
     pytest.param("explicit1.5", 1.5, id="Explicit15"),
+    pytest.param("taylor1.5_imp", 1.5, id="Taylor15 implicit"),
 ])
 @pytest.mark.parametrize(['H', 'c_ops', 'sc_ops'], [
     pytest.param("qeye", [], ["destroy"], id='simple'),

From e701ecc937299a8ed3468b5024cd7a6f400e79a7 Mon Sep 17 00:00:00 2001
From: awkwardPotato812 <srinidhi.812@gmail.com>
Date: Wed, 15 Mar 2023 13:03:09 +0530
Subject: [PATCH 160/602] Fix failing test case

---
 qutip/tests/core/test_coefficient.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index e1a967d0ff..2fe5ff0b6d 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -372,7 +372,7 @@ def test_CoeffFromScipy():
     from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
     _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
 
-    coeff = coefficient(y, tlist=tlist, order=3, bc_type="natural")
+    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
     from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
     _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
 

From ed4f0fa120eb6f6c4f9c50ae94deb68f3812d3ae Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 15 Mar 2023 13:36:42 +0000
Subject: [PATCH 161/602] remove unnecessary variables

---
 qutip/core/options.py |  4 +---
 qutip/settings.py     | 10 +++-------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index 6f988afec3..1724c81890 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -33,13 +33,11 @@ def __setitem__(self, key, value):
 
     def __repr__(self, full=True):
         out = [f"<{self.__class__.__name__}("]
-        cnt = 0
         for key, value in self.options.items():
             if full or value != self._options[key]:
                 out += [f"    '{key}': {repr(value)},"]
-                cnt += 1
         out += [")>"]
-        if cnt:
+        if len(out)-2:
             return "\n".join(out)
         else:
             return "".join(out)
diff --git a/qutip/settings.py b/qutip/settings.py
index a10e527ddb..29ee053b75 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -281,13 +281,9 @@ def colorblind_safe(self, value):
     def __str__(self):
         lines = ["Qutip settings:"]
         for attr in self.__dir__():
-            if not attr.startswith('_'):
-                if attr != "core" and attr != "compile":
-                    lines.append(f"    {attr}: {self.__getattribute__(attr)}")
-        if "compile" in self.__dir__():
-            attr = "compile"
-            content = self.__getattribute__('compile').__repr__(full=False)
-            lines.append(f"    {attr}: {content}")
+            if not attr.startswith('_') and attr not in ["core", "compile"]:
+                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
         return '\n'.join(lines)
 
     def __repr__(self):

From 797069acb43f5d3a8a57f6ec7e3bef2dd96b601a Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 15 Mar 2023 14:20:16 +0000
Subject: [PATCH 162/602] add lsqr

---
 qutip/solver/countstat.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 8ccc12bd6f..bc0ef08a51 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -12,6 +12,7 @@
     sprepost, spre, qeye, tensor, expect, Qobj,
     operator_to_vector, vector_to_operator
 )
+#_data.solveになる
 from ..core import data as _data
 from .steadystate import pseudo_inverse, steadystate
 from ..settings import settings
@@ -74,6 +75,13 @@ def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
     return current
 
 
+def _solve(A, V):
+    try:
+        return _data.solve(A, V)
+    except Exception:
+        return _data.solve(A, V, "lsqr")
+
+
 def _noise_direct(L, wlist, rhoss, J_ops):
     J_ops = [op.data for op in J_ops]
     rhoss_vec = operator_to_vector(rhoss).data
@@ -88,8 +96,7 @@ def _noise_direct(L, wlist, rhoss, J_ops):
     Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
     Iop = _data.identity(np.prod(L.dims[0][0])**2)
     Q = _data.sub(Iop, Pop)
-    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)).to_array()
-             for op in J_ops]
+    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
 
     for k, w in enumerate(wlist):
         if w != 0.0:
@@ -101,7 +108,7 @@ def _noise_direct(L, wlist, rhoss, J_ops):
             L_temp = 1e-15j * spre(tr_op) + L
 
         A = _data.to(_data.CSR, L_temp.data)
-        X_rho = [_data.solve(A, _data.Dense(op)) for op in Q_ops]
+        X_rho = [_solve(A, op) for op in Q_ops]
 
         for i, j in product(range(N_j_ops), repeat=2):
             if i == j:

From 4edf62789f5873f7631953737e68bcb75b9356a1 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 15 Mar 2023 14:21:52 +0000
Subject: [PATCH 163/602] delete comment

---
 qutip/solver/countstat.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index bc0ef08a51..4d4c60af9a 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -12,7 +12,6 @@
     sprepost, spre, qeye, tensor, expect, Qobj,
     operator_to_vector, vector_to_operator
 )
-#_data.solveになる
 from ..core import data as _data
 from .steadystate import pseudo_inverse, steadystate
 from ..settings import settings

From 639d7ae603256ac0b62cabb4207c791a97345a7a Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 15 Mar 2023 16:23:50 +0000
Subject: [PATCH 164/602] add full option again

---
 qutip/core/options.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/options.py b/qutip/core/options.py
index f8b54e5706..1724c81890 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -31,7 +31,7 @@ def __setitem__(self, key, value):
         # Let the dict catch the KeyError
         self.options[key] = value
 
-    def __repr__(self):
+    def __repr__(self, full=True):
         out = [f"<{self.__class__.__name__}("]
         for key, value in self.options.items():
             if full or value != self._options[key]:

From e2b1c156eeccdcc8d6f67b7d49219e11ad4f74a9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 15 Mar 2023 17:33:00 -0400
Subject: [PATCH 165/602] weiner process in result

---
 qutip/solver/stochastic.py | 238 +++++++++++++++++++++++++++++--------
 1 file changed, 188 insertions(+), 50 deletions(-)

diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 4c712eddcc..332ea5238d 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -1,7 +1,7 @@
 __all__ = ["smesolve", "SMESolver", "ssesolve", "SSESolver", "StochasticSolver"]
 
 from .sode.ssystem import *
-from .result import MultiTrajResult, Result
+from .result import MultiTrajResult, Result, ExpectOp
 from .multitraj import MultiTrajSolver
 from ..import Qobj, QobjEvo, liouvillian, lindblad_dissipator
 import numpy as np
@@ -11,45 +11,139 @@
 class StochasticTrajResult(Result):
     def _post_init(self, m_ops=(), dw_factor=()):
         super()._post_init()
-        self.noise = []
-        self.m_ops = m_ops
+        self.W = []
+        self.m_ops = []
+        self.m_expect = []
         self.dW_factor = dw_factor
-        self.measurements = [[] for _ in range(len(m_ops))]
-
-    def _add_measurement(self, t, state, noise):
-        expects = [m_op.expect(t, state) for m_op in self.m_ops]
-        for measure, expect, dW, factor in zip(
-            self.measurements, expects, noise, self.dW_factor
-        ):
-            measure.append(expect + dW * factor)
+        for op in m_ops:
+            f = self._e_op_func(op)
+            self.W.append([0.])
+            self.m_expect.append([])
+            self.m_ops.append(ExpectOp(op, f, self.m_expect[-1].append))
+            self.add_processor(self.m_ops[-1]._store)
 
     def add(self, t, state, noise):
         super().add(t, state)
+        if noise is not None and self.options['store_wiener_process']:
+            for i, dW in enumerate(noise):
+                self.W[i].append(self.W[i][-1] + dW)
 
-        if noise is not None:
-            self.noise.append(noise)
-            if self.options["store_measurement"]:
-                dt = self.times[-1] - self.times[-2]
-                self._add_measurement(t, state, noise / dt)
+    @property
+    def weiner_process(self):
+        """
+        Weiner processes for each stochastic collapse operators.
 
+        The output shape is
+            (len(sc_ops), len(tlist))
+        for homodyne detection, and
+            (len(sc_ops), 2, len(tlist))
+        for heterodyne detection.
+        """
+        W = np.array(self.W)
+        if self.options["heterodyne"]:
+            W = W.reshape(-1, 2, W.shape[1])
+        return W
 
-class StochasticResult(MultiTrajResult):
-    def _reduce_measurements(self, trajectory):
-        # Since measurements of each trajectories is kept, we keep only the
-        # array to save memory.
-        trajectory.measurements = np.array(trajectory.measurements)
+    @property
+    def dW(self):
+        """
+        Weiner increment for each stochastic collapse operators.
+
+        The output shape is
+            (len(sc_ops), len(tlist)-1)
+        for homodyne detection, and
+            (len(sc_ops), 2, len(tlist)-1)
+        for heterodyne detection.
+        """
+        dw = np.diff(self.W, axis=1)
         if self.options["heterodyne"]:
-            shape = trajectory.measurements.shape
-            trajectory.measurements = (
-                trajectory.measurements.reshape(-1, 2, shape[-1])
-            )
-        self.measurement.append(trajectory.measurements)
+            dw = dw.reshape(-1, 2, dw.shape[1])
+        return dw
 
+    @property
+    def measurements(self):
+        """
+        Measurements for each stochastic collapse operators.
+
+        The output shape is
+            (len(sc_ops), len(tlist)-1)
+        for homodyne detection, and
+            (len(sc_ops), 2, len(tlist)-1)
+        for heterodyne detection.
+        """
+        dts = np.diff(self.times)
+        m_expect = np.array(self.m_expect)[:, 1:]
+        noise = self.dW_factor @ np.diff(self.W, axis=1) @ (1/dts)
+        if self.options["heterodyne"]:
+            m_expect = m_expect.reshape(-1, 2, m_expect.shape[1])
+            noise = noise.reshape(-1, 2, noise.shape[1])
+        return m_expect + noise
+
+
+class StochasticResult(MultiTrajResult):
     def _post_init(self):
         super()._post_init()
-        self.measurement = []
-        if self.options['store_measurement']:
-            self.add_processor(self._reduce_measurements)
+
+        store_measurement = self.options['store_measurement']
+        keep_runs = self.options['keep_runs_results']
+        store_wiener_process = self.options['store_wiener_process']
+
+        if (
+            store_measurement and not store_wiener_process
+            or store_wiener_process and not keep_runs
+        ):
+            raise ValueError(
+                "Keeping runs is needed to store measurements "
+                "and weiner processes."
+            )
+
+    def _trajectories_attr(self, attr):
+        if self.options['keep_runs_results']:
+            return np.array([
+                getattr(traj, attr) for traj in self.trajectories
+            ])
+        return None
+
+    @property
+    def measurements(self):
+        """
+        Measurements for each trajectories and stochastic collapse operators.
+
+        The output shape is
+            (ntraj, len(sc_ops), len(tlist)-1)
+        for homodyne detection, and
+            (ntraj, len(sc_ops), 2, len(tlist)-1)
+        for heterodyne detection.
+        """
+        return self._trajectories_attr("measurements")
+
+    @property
+    def dW(self):
+        """
+        Weiner increment for each trajectories and stochastic collapse
+        operators.
+
+        The output shape is
+            (ntraj, len(sc_ops), len(tlist)-1)
+        for homodyne detection, and
+            (ntraj, len(sc_ops), 2, len(tlist)-1)
+        for heterodyne detection.
+        """
+        return self._trajectories_attr("dW")
+
+    @property
+    def weiner_process(self):
+        """
+        Weiner processes for each trajectories and stochastic collapse
+        operators.
+
+        The output shape is
+            (ntraj, len(sc_ops), len(tlist)-1)
+        for homodyne detection, and
+            (ntraj, len(sc_ops), 2, len(tlist)-1)
+        for heterodyne detection.
+        """
+        return self._trajectories_attr("weiner_process")
 
 
 class StochasticRHS:
@@ -149,7 +243,9 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     H = QobjEvo(H, args=args, tlist=tlist)
     c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
     sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
-    sol = SMESolver(H, sc_ops, c_ops=c_ops, options=options, m_ops=m_ops)
+    sol = SMESolver(H, sc_ops, c_ops=c_ops, options=options)
+    if m_ops:
+        sol.m_ops = m_ops
     return sol.run(rho0, tlist, ntraj, e_ops=e_ops)
 
 
@@ -204,7 +300,9 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
     """
     H = QobjEvo(H, args=args, tlist=tlist)
     sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
-    sol = SSESolver(H, sc_ops, options=options, m_ops=m_ops)
+    sol = SSESolver(H, sc_ops, options=options)
+    if m_ops:
+        sol.m_ops = m_ops
     return sol.run(psi0, tlist, ntraj, e_ops=e_ops)
 
 
@@ -226,11 +324,12 @@ class StochasticSolver(MultiTrajSolver):
         "num_cpus": None,
         "bitgenerator": None,
         "heterodyne": False,
+        "store_wiener_process": False,
         "store_measurement": False,
         "dw_factor": None,
     }
 
-    def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
+    def __init__(self, H, sc_ops, *, c_ops=(), options=None):
         self.options = options
         heterodyne = self.options["heterodyne"]
         if self.name == "ssesolve" and c_ops:
@@ -240,34 +339,73 @@ def __init__(self, H, sc_ops, *, c_ops=(), options=None, m_ops=()):
         super().__init__(rhs, options=options)
 
         if self.options["store_measurement"]:
-            n_m_ops = len(sc_ops) * (1 + int(heterodyne))
+            self.options["keep_runs_results"] = True
+            self.options["store_wiener_process"] = True
             dW_factor = self.options["dw_factor"] or 1.
 
-            if len(m_ops) == n_m_ops:
-                self.m_ops = m_ops
-            elif heterodyne:
-                self.m_ops = []
+            if heterodyne:
+                self._m_ops = []
                 for op in sc_ops:
-                    self.m_ops += [
+                    self._m_ops += [
                         op + op.dag(), -1j * (op - op.dag())
                     ]
-                dW_factor = dW_factor * 0.5**0.5
+                self._dW_factors = np.ones(len(sc_ops) * 2) * 0.5**0.5
+
             else:
-                self.m_ops = [op + op.dag() for op in sc_ops]
+                self._m_ops = [op + op.dag() for op in sc_ops]
+                self._dW_factors = np.ones(len(sc_ops))
 
-            if not isinstance(dW_factor, Iterable):
-                dW_factor = [dW_factor] * n_m_ops
+        else:
+            self._m_ops = []
+            self.dW_factors = []
 
-            if len(dW_factor) == len(sc_ops) and heterodyne:
-                dW_factor = [ i for i in dW_factor for _ in range(2) ]
+    @property
+    def m_ops(self):
+        return self._m_ops
 
-            if len(dW_factor) != n_m_ops:
-                raise ValueError("Bad dW_factor option")
-            self.dW_factors = dW_factor
+    @m_ops.setter
+    def m_ops(self, new_m_ops):
+        if not self.options["store_measurement"]:
+            raise ValueError(
+                "The 'store_measurement' options must be set to "
+                "`True` to use m_ops."
+            )
 
-        else:
-            self.m_ops = []
-            self.dW_factors = []
+        if len(new_m_ops) != len(self.rhs.sc_ops):
+            if self.options["heterodyne"]:
+                raise ValueError(
+                    f"2 `m_ops` per `sc_ops`, {len(self.rhs.sc_ops)} operators"
+                    " are expected for heterodyne measurement."
+                )
+            else:
+                raise ValueError(
+                    f"{len(self.rhs.sc_ops)} measurements "
+                    "operators are expected."
+                )
+        self._m_ops = new_m_ops
+
+    @property
+    def dW_factors(self):
+        return self._dW_factors
+
+    @dW_factors.setter
+    def dW_factors(self, new_dW_factors):
+        if not self.options["store_measurement"]:
+            raise ValueError(
+                "The 'dW_factors' are only used with measurements."
+            )
+
+        if len(new_dW_factors) != len(self.rhs.sc_ops):
+            if self.options["heterodyne"]:
+                raise ValueError(
+                    f"2 `dW_factors` per `sc_ops`, {len(self.rhs.sc_ops)} "
+                    "values are expected for heterodyne measurement."
+                )
+            else:
+                raise ValueError(
+                    f"{len(self.rhs.sc_ops)} dW_factors are expected."
+                )
+        self._dW_factors = new_dW_factors
 
     def _run_one_traj(self, seed, state, tlist, e_ops):
         """

From 7d748ce3e89a238e58208b4ba5a5407ffe369c89 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 15 Mar 2023 19:54:24 -0400
Subject: [PATCH 166/602] fix naming

---
 qutip/solver/stochastic.py | 46 +++++++++++++++++++++++++-------------
 1 file changed, 30 insertions(+), 16 deletions(-)

diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 332ea5238d..79eae4753f 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -6,6 +6,7 @@
 from ..import Qobj, QobjEvo, liouvillian, lindblad_dissipator
 import numpy as np
 from collections.abc import Iterable
+from functools import partial
 
 
 class StochasticTrajResult(Result):
@@ -24,14 +25,14 @@ def _post_init(self, m_ops=(), dw_factor=()):
 
     def add(self, t, state, noise):
         super().add(t, state)
-        if noise is not None and self.options['store_wiener_process']:
+        if noise is not None and (self.options['store_wiener_process'] or self.options['store_measurement']):
             for i, dW in enumerate(noise):
                 self.W[i].append(self.W[i][-1] + dW)
 
     @property
-    def weiner_process(self):
+    def wiener_process(self):
         """
-        Weiner processes for each stochastic collapse operators.
+        Wiener processes for each stochastic collapse operators.
 
         The output shape is
             (len(sc_ops), len(tlist))
@@ -47,7 +48,7 @@ def weiner_process(self):
     @property
     def dW(self):
         """
-        Weiner increment for each stochastic collapse operators.
+        Wiener increment for each stochastic collapse operators.
 
         The output shape is
             (len(sc_ops), len(tlist)-1)
@@ -61,7 +62,7 @@ def dW(self):
         return dw
 
     @property
-    def measurements(self):
+    def measurement(self):
         """
         Measurements for each stochastic collapse operators.
 
@@ -73,7 +74,7 @@ def measurements(self):
         """
         dts = np.diff(self.times)
         m_expect = np.array(self.m_expect)[:, 1:]
-        noise = self.dW_factor @ np.diff(self.W, axis=1) @ (1/dts)
+        noise = np.einsum("i,ij,j->ij", self.dW_factor, np.diff(self.W, axis=1), (1/dts))
         if self.options["heterodyne"]:
             m_expect = m_expect.reshape(-1, 2, m_expect.shape[1])
             noise = noise.reshape(-1, 2, noise.shape[1])
@@ -90,22 +91,36 @@ def _post_init(self):
 
         if (
             store_measurement and not store_wiener_process
-            or store_wiener_process and not keep_runs
         ):
             raise ValueError(
                 "Keeping runs is needed to store measurements "
-                "and weiner processes."
+                "and wiener processes."
             )
 
+        if not keep_runs and store_wiener_process:
+            self.add_processor(partial(self._reduce_attr, attr="wiener_process"))
+            self._wiener_process = []
+            self.add_processor(partial(self._reduce_attr, attr="dW"))
+            self._dW = []
+
+        if not keep_runs and store_measurement:
+            self.add_processor(partial(self._reduce_attr, attr="measurement"))
+            self._measurement = []
+
+    def _reduce_attr(self, trajectory, attr):
+        getattr(self, "_" + attr).append(getattr(trajectory, attr))
+
     def _trajectories_attr(self, attr):
-        if self.options['keep_runs_results']:
+        if hasattr(self, "_" + attr):
+            return getattr(self, "_" + attr)
+        elif self.options['keep_runs_results']:
             return np.array([
                 getattr(traj, attr) for traj in self.trajectories
             ])
         return None
 
     @property
-    def measurements(self):
+    def measurement(self):
         """
         Measurements for each trajectories and stochastic collapse operators.
 
@@ -115,12 +130,12 @@ def measurements(self):
             (ntraj, len(sc_ops), 2, len(tlist)-1)
         for heterodyne detection.
         """
-        return self._trajectories_attr("measurements")
+        return self._trajectories_attr("measurement")
 
     @property
     def dW(self):
         """
-        Weiner increment for each trajectories and stochastic collapse
+        Wiener increment for each trajectories and stochastic collapse
         operators.
 
         The output shape is
@@ -132,9 +147,9 @@ def dW(self):
         return self._trajectories_attr("dW")
 
     @property
-    def weiner_process(self):
+    def wiener_process(self):
         """
-        Weiner processes for each trajectories and stochastic collapse
+        Wiener processes for each trajectories and stochastic collapse
         operators.
 
         The output shape is
@@ -143,7 +158,7 @@ def weiner_process(self):
             (ntraj, len(sc_ops), 2, len(tlist)-1)
         for heterodyne detection.
         """
-        return self._trajectories_attr("weiner_process")
+        return self._trajectories_attr("wiener_process")
 
 
 class StochasticRHS:
@@ -339,7 +354,6 @@ def __init__(self, H, sc_ops, *, c_ops=(), options=None):
         super().__init__(rhs, options=options)
 
         if self.options["store_measurement"]:
-            self.options["keep_runs_results"] = True
             self.options["store_wiener_process"] = True
             dW_factor = self.options["dw_factor"] or 1.
 

From a187a80b43cb5c4b49d3cf92d9de45b8166e1af7 Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Thu, 16 Mar 2023 20:37:08 +0530
Subject: [PATCH 167/602] Undo all pycodestyle changes done on cython codes.
 Removed and edited tests with bad formatting

---
 qutip/core/cy/qobjevo.pyx        |  7 +++----
 qutip/tests/core/test_qobjevo.py | 28 ++++++++++++----------------
 2 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 4899edaa8b..bb2452e81f 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -1,6 +1,5 @@
-# cython: language_level=3
-# cython: boundscheck=False, wraparound=False,
-#         initializedcheck=False, cdvision=True
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
 
 import numpy as np
 import numbers
@@ -18,7 +17,7 @@ from qutip.settings import settings
 from qutip.core.cy._element cimport _BaseElement
 from qutip.core.data cimport Dense, Data, dense
 from qutip.core.data.expect cimport *
-from qutip.core.data.reshape cimport(column_stack_dense, column_unstack_dense)
+from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
 from qutip.core.cy.coefficient cimport Coefficient
 from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
 from libc.math cimport fabs
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index 82033a13f5..7e20d91b54 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -141,27 +141,23 @@ def test_QobjEvo_repr():
     expected_repr_1= 'QobjEvo: dims=[[3], [3]], shape=(3, 3), type=oper, superrep=None, isconstant=False, num_elements=1'
     assert case_1 == expected_repr_1
 
-    case_2= repr(QobjEvo(qeye(2), lambda t: t))
-    case_3= repr(QobjEvo([qeye(2)]))
-    case_4= repr(QobjEvo(qeye(2)))
-    expected_repr_2_3_4= 'QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=True, num_elements=1'
-    assert case_2 == expected_repr_2_3_4
-    assert case_3 == expected_repr_2_3_4
-    assert case_4 == expected_repr_2_3_4
+    case_2= repr(QobjEvo(qeye(2)))
+    expected_repr_2= 'QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=True, num_elements=1'
+    assert case_2 == expected_repr_2
     
-    case_5= repr(QobjEvo(basis(5, 2)))
-    expected_repr_5= 'QobjEvo: dims=[[5], [1]], shape=(5, 1), type=ket, superrep=None, isconstant=True, num_elements=1'
-    assert case_5 == expected_repr_5
+    case_3= repr(QobjEvo(basis(5, 2)))
+    expected_repr_3= 'QobjEvo: dims=[[5], [1]], shape=(5, 1), type=ket, superrep=None, isconstant=True, num_elements=1'
+    assert case_3 == expected_repr_3
 
     X = sigmax()
     S = spre(X) * spost(X.dag())
-    case_6= repr(QobjEvo(to_choi(S)))
-    expected_repr_6= 'QobjEvo: dims=[[[2], [2]], [[2], [2]]], shape=(4, 4), type=super, superrep=choi, isconstant=True, num_elements=1'
-    assert case_6 == expected_repr_6
+    case_4= repr(QobjEvo(to_choi(S)))
+    expected_repr_4= 'QobjEvo: dims=[[[2], [2]], [[2], [2]]], shape=(4, 4), type=super, superrep=choi, isconstant=True, num_elements=1'
+    assert case_4 == expected_repr_4
 
-    case_7= repr(QobjEvo([[qeye(4), lambda t: t], [qeye(4), lambda t: t]], compress=False))
-    expected_repr_7= 'QobjEvo: dims=[[4], [4]], shape=(4, 4), type=oper, superrep=None, isconstant=False, num_elements=2'
-    assert case_7 == expected_repr_7
+    case_= repr(QobjEvo([[qeye(4), lambda t: t], [qeye(4), lambda t: t]], compress=False))
+    expected_repr_= 'QobjEvo: dims=[[4], [4]], shape=(4, 4), type=oper, superrep=None, isconstant=False, num_elements=2'
+    assert case_ == expected_repr_
 
 
 @pytest.mark.parametrize('coeff_type',

From 167300904157a15d57b5889a028a46a1b920e37f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 16 Mar 2023 15:02:00 -0400
Subject: [PATCH 168/602] Fill most doctring and error msg

---
 qutip/solver/mcsolve.py                |   8 +-
 qutip/solver/mesolve.py                |   2 +-
 qutip/solver/sode/_sode.pyx            |  29 +-
 qutip/solver/sode/itotaylor.py         |   5 +-
 qutip/solver/sode/noise.py             |  49 ---
 qutip/solver/sode/rouchon.py           |  34 +-
 qutip/solver/sode/sode.py              |  15 +-
 qutip/solver/sode/ssystem.pyx          |  55 +++-
 qutip/solver/stochastic.py             | 412 ++++++++++++++++++++-----
 qutip/tests/solver/test_sode_method.py |   8 +-
 10 files changed, 417 insertions(+), 200 deletions(-)
 delete mode 100644 qutip/solver/sode/noise.py

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index ed7adae017..bc3369b979 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -339,14 +339,8 @@ class MCSolver(MultiTrajSolver):
         (see :class:`qutip.QobjEvo`'s documentation). They must be operators
         even if ``H`` is a superoperator.
 
-    options : SolverOptions, [optional]
+    options : dict, [optional]
         Options for the evolution.
-
-    seed : int, SeedSequence, list, [optional]
-        Seed for the random number generator. It can be a single seed used to
-        spawn seeds for each trajectory or a list of seed, one for each
-        trajectory. Seeds are saved in the result and can be reused with::
-            seeds=prev_result.seeds
     """
     name = "mcsolve"
     resultclass = McResult
diff --git a/qutip/solver/mesolve.py b/qutip/solver/mesolve.py
index ed865dcabd..5792038af1 100644
--- a/qutip/solver/mesolve.py
+++ b/qutip/solver/mesolve.py
@@ -170,7 +170,7 @@ class MESolver(SESolver):
         of Liouvillian superoperators. None is equivalent to an empty list.
 
     options : dict, optional
-        Options for the solver, see :obj:`SESolver.options` and
+        Options for the solver, see :obj:`MESolver.options` and
         `Integrator <./classes.html#classes-ode>`_ for a list of all options.
 
     attributes
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index e3d878d8f7..84ca745ad9 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -257,7 +257,7 @@ cdef class Milstein:
     @cython.wraparound(False)
     cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
         """
-        Chapter 10.3 Eq. (3.1)
+        Chapter 10.3 Eq. (3.12)
         Numerical Solution of Stochastic Differential Equations
         By Peter E. Kloeden, Eckhard Platen
 
@@ -314,12 +314,9 @@ cdef class PredCorr:
     @cython.wraparound(False)
     cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
         """
-        Chapter 10.3 Eq. (3.1)
+        Chapter 15.5 Eq. (5.4)
         Numerical Solution of Stochastic Differential Equations
         By Peter E. Kloeden, Eckhard Platen
-
-        dV = -iH*V*dt + d1*dt + d2_i*dW_i
-        + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
         """
         cdef _StochasticSystem system = self.system
         cdef int i, j, k, num_ops = system.num_collapse
@@ -354,26 +351,11 @@ cdef class PredCorr:
 
 
 cdef class Taylor15(Milstein):
-    """
-    @cython.wraparound(False)
-    def run(self, double t, Data state, double dt, double[:, :, ::1] dW, int ntraj):
-        cdef int i
-        if type(state) != _data.Dense:
-            state = _data.to(_data.Dense, state)
-        cdef Dense out = _data.mul_dense(state, 0)
-        state = state.copy()
-
-        for i in range(ntraj):
-            self.step(t + i * dt, state, dt, dW[i, :, :], out)
-            state, out = out, state
-        return state
-    """
-
     @cython.boundscheck(False)
     @cython.wraparound(False)
     cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
         """
-        Chapter 12.2 Eq. (2.18),
+        Chapter 10.4 Eq. (4.6),
         Numerical Solution of Stochastic Differential Equations
         By Peter E. Kloeden, Eckhard Platen
         """
@@ -450,12 +432,9 @@ cdef class Milstein_imp:
     @cython.wraparound(False)
     cdef Data step(self, double t, Dense state, double dt, double[:, :] dW, Dense target):
         """
-        Chapter 10.3 Eq. (3.1)
+        Chapter 12.2 Eq. (2.11)
         Numerical Solution of Stochastic Differential Equations
         By Peter E. Kloeden, Eckhard Platen
-
-        dV = -iH*V*dt + d1*dt + d2_i*dW_i
-        + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
         """
         cdef _StochasticSystem system = self.system
         cdef int i, j, num_ops = system.num_collapse
diff --git a/qutip/solver/sode/itotaylor.py b/qutip/solver/sode/itotaylor.py
index eba58af542..0cc497acc0 100644
--- a/qutip/solver/sode/itotaylor.py
+++ b/qutip/solver/sode/itotaylor.py
@@ -52,7 +52,7 @@ class Taylor1_5_SODE(_Explicit_Simple_Integrator):
     @property
     def options(self):
         """
-        Supported options by Explicit Stochastic Integrators:
+        Supported options by Order 1.5 strong Taylor Stochastic Integrators:
 
         dt : float, default=0.001
             Internal time step.
@@ -123,7 +123,8 @@ class Implicit_Taylor1_5_SODE(_Implicit_Simple_Integrator):
     @property
     def options(self):
         """
-        Supported options by Explicit Stochastic Integrators:
+        Supported options by Implicit Order 1.5 strong Taylor Stochastic
+        Integrators:
 
         dt : float, default=0.001
             Internal time step.
diff --git a/qutip/solver/sode/noise.py b/qutip/solver/sode/noise.py
deleted file mode 100644
index 891358e6ea..0000000000
--- a/qutip/solver/sode/noise.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import numpy as np
-
-__all__ = []
-
-class _Noise:
-    """
-
-    """
-    def __init__(self, T, dt, num=1):
-        N = int(np.round(T / dt))
-        self.T = T
-        self.dt = dt
-        self.num = num
-        self.noise = np.random.randn(N, num) * dt**0.5
-
-    def dw(self, dt):
-        """
-        Ito integral I(i).
-        """
-        N = int(np.round(dt /self.dt))
-        return self.noise.reshape(-1, N, self.num).sum(axis=1)
-
-    def dz(self, dt):
-        """
-        Ito integral I(0, i).
-        """
-        N = int(np.round(dt /self.dt))
-        return np.einsum(
-            "ijk,j->ik",
-            self.noise.reshape(-1, N, self.num),
-            np.arange(N-0.5, 0, -1)
-        ) * self.dt
-
-    def dW(self, dt):
-        """
-        Noise used for Ito-Taylor integrators of order up to 1.5.
-        """
-        N = int(np.round(dt / self.dt))
-        noise = self.noise.copy()
-        if noise.shape[0] % N:
-            noise = noise[:-(noise.shape[0] % N)]
-        out = np.empty((noise.shape[0] // N, 2, self.num), dtype=float)
-        out[:, 0, :] = noise.reshape(-1, N, self.num).sum(axis=1)
-        out[:, 1, :] = np.einsum(
-            "ijk,j->ik",
-            self.noise.reshape(-1, N, self.num),
-            np.arange(N-0.5, 0, -1)
-        ) * self.dt
-        return out
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index 89c1e6854d..795fbdb115 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -11,8 +11,7 @@
 
 class RouchonSODE(SIntegrator):
     """
-    Scheme keeping the positivity of the density matrix
-    (:obj:`~smesolve` only).
+    Scheme keeping the positivity of the density matrix.
     See eq. (4) Pierre Rouchon and Jason F. Ralpha,
     *Efficient Quantum Filtering for Quantum Feedback Control*,
     `arXiv:1410.5345 [quant-ph] <https://arxiv.org/abs/1410.5345>`_,
@@ -31,7 +30,8 @@ def __init__(self, rhs, options):
 
         self.H = rhs.H
         if self.H.issuper:
-            raise TypeError("...")
+            raise TypeError("The rouchon stochastic integration method can't"
+                            " use a premade Liouvillian.")
         self._issuper = rhs.issuper
 
         dtype = type(self.H(0).data)
@@ -55,32 +55,10 @@ def __init__(self, rhs, options):
 
         self.id = _data.identity[dtype](self.H.shape[0])
 
-    def set_state(self, t, state0, generator):
-        """
-        Set the state of the SODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        generator : numpy.random.generator
-            Random number generator.
-        """
-        self.t = t
-        self.state = state0
-        self.generator = generator
-
-    def get_state(self, copy=True):
-        return self.t, self.state, self.generator
-
     def integrate(self, t, copy=True):
         delta_t = (t - self.t)
         if delta_t < 0:
-            raise ValueError("Stochastic integration time")
+            raise ValueError("Stochastic integration need increasing times")
         elif delta_t == 0:
             return self.t, self.state, np.zeros(self.N_dw)
 
@@ -108,8 +86,6 @@ def integrate(self, t, copy=True):
         return self.t, self.state, np.sum(dW, axis=0)
 
     def _step(self, t, state, dt, dW):
-        # Same output as old rouchon up to numerical error
-        # But  7x slower
         dy = [
             op.expect_data(t, state) * dt + dw
             for op, dw in zip(self.cpcds, dW)
@@ -135,7 +111,7 @@ def _step(self, t, state, dt, dW):
     @property
     def options(self):
         """
-        Supported options by Explicit Stochastic Integrators:
+        Supported options by Rouchon Stochastic Integrators:
 
         dt : float, default=0.001
             Internal time step.
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 113cdfed9a..31e5c5f94b 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -179,7 +179,7 @@ def __init__(self, rhs, options):
     @property
     def options(self):
         """
-        Supported options by Explicit Stochastic Integrators:
+        Supported options by Implicit Stochastic Integrators:
 
         dt : float, default=0.001
             Internal time step.
@@ -257,13 +257,16 @@ def options(self):
         dt : float, default=0.001
             Internal time step.
 
-        tol : float, ...
-            ...
+        tol : float, default=1e-10
+            Tolerance for the time steps.
 
-        alpha : float, .,,
+        alpha : float, default=0.
+            Implicit factor to the drift.
+            eff_drift ~= drift(t) * (1-alpha) + drift(t+dt) * alpha
 
-        eta : float, ...
-            ...
+        eta : float, default=0.5
+            Implicit factor to the diffusion.
+            eff_diffusion ~= diffusion(t) * (1-eta) + diffusion(t+dt) * eta
         """
         return self._options
 
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index b37e8a113c..7f3737c7e6 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -22,16 +22,39 @@ cdef Dense _dense_wrap(double complex [::1] x):
 
 
 cdef class _StochasticSystem:
+    """
+        RHS for stochastic differential equations.
+
+        Contain the deterministic drift term and the diffusion term[s] through
+        the ``drift`` and ``diffusion`` methods.
+
+        Derrivatives corresponding to the terms in the ito-tyalor expansion are
+        available through a different interface:
+        ``set_state``, ``a``, ``bi``, ``Libj`` etc.
+
+        A different interface is used since each term is not independant, but
+        which terms is needed change according to the integration method.
+        Whereas the raw drift and diffusion are independant.
+    """
     def __init__(self, a, b):
         raise NotImplementedError
 
     cpdef Data drift(self, t, Data state):
+        """
+            Compute the drift term for the ``state`` at time ``t``.
+        """
         raise NotImplementedError
 
     cpdef list diffusion(self, t, Data state):
+        """
+            Compute the diffusion terms for the ``state`` at time ``t``.
+        """
         raise NotImplementedError
 
     cpdef void set_state(self, double t, Dense state) except *:
+        """
+            Initialize the set of derrivatives.
+        """
         raise NotImplementedError
 
     cpdef Data a(self):
@@ -60,7 +83,9 @@ cdef class _StochasticSystem:
 
     cpdef Data L0bi(self, int i):
         """
-            d/dt + a_n * d bi / dx_n + sum_k bk_n bk_m *0.5 d**2 (bi) / (dx_n dx_m)
+            dbi/dt
+            + a_n * d bi / dx_n
+            + sum_k bk_n bk_m *0.5 d**2 (bi) / (dx_n dx_m)
         """
         raise NotImplementedError
 
@@ -72,12 +97,24 @@ cdef class _StochasticSystem:
 
     cpdef Data L0a(self):
         """
-            d/dt + a_n * d a / dx_n + sum_k bk_n bk_m *0.5 d**2 (a) / (dx_n dx_m)
+            da/dt
+            + a_n * d a / dx_n
+            + sum_k bk_n bk_m *0.5 d**2 (a) / (dx_n dx_m)
         """
         raise NotImplementedError
 
 
 cdef class StochasticClosedSystem(_StochasticSystem):
+    """
+        RHS for closed quantum stochastic system (ssesolve)
+
+        drift = -1H * psi
+              + sum_i (-c_i.dag * c_i / 2 + c_i * e_i / 2 - e_i**2 / 8) * psi
+
+        e_i = <psi| c_i + c_i.dag |psi>
+
+        diffusion = (c_i - e_i / 2) * psi
+    """
     cdef readonly list cpcd_ops
     cdef bint _a_set, _b_set, _Lb_set
 
@@ -124,6 +161,13 @@ cdef class StochasticClosedSystem(_StochasticSystem):
 
 
 cdef class StochasticOpenSystem(_StochasticSystem):
+    """
+        RHS for open quantum stochastic system (smesolve)
+
+        drift = liouvillian(H, sc_ops + c_ops)(rho)
+
+        diffusion = c_i @ rho + rho @ c_i/dag - tr(c_i @ rho) rho
+    """
     cdef int state_size, N_root
     cdef double dt
     cdef int _is_set
@@ -140,7 +184,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self.L = H + liouvillian(None, sc_ops)
         else:
             self.L = liouvillian(H, sc_ops)
-        if c_ops:
+        if c_ops:(c_i - e_i / 2) * psi
             self.L = self.L + liouvillian(None, c_ops)
 
         self.c_ops = [spre(op) + spost(op.dag()) for op in sc_ops]
@@ -401,6 +445,11 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
     """
     Simple system that can be solver analytically.
     Used in tests.
+
+        drift = -iH @ vec
+
+        diffusion = c_i @ vec
+
     """
     cdef double dt
 
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 79eae4753f..781f27e610 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -1,4 +1,4 @@
-__all__ = ["smesolve", "SMESolver", "ssesolve", "SSESolver", "StochasticSolver"]
+__all__ = ["smesolve", "SMESolver", "ssesolve", "SSESolver"]
 
 from .sode.ssystem import *
 from .result import MultiTrajResult, Result, ExpectOp
@@ -10,12 +10,13 @@
 
 
 class StochasticTrajResult(Result):
-    def _post_init(self, m_ops=(), dw_factor=()):
+    def _post_init(self, m_ops=(), dw_factor=(), heterodyne=False):
         super()._post_init()
         self.W = []
         self.m_ops = []
         self.m_expect = []
         self.dW_factor = dw_factor
+        self.heterodyne = heterodyne
         for op in m_ops:
             f = self._e_op_func(op)
             self.W.append([0.])
@@ -25,7 +26,11 @@ def _post_init(self, m_ops=(), dw_factor=()):
 
     def add(self, t, state, noise):
         super().add(t, state)
-        if noise is not None and (self.options['store_wiener_process'] or self.options['store_measurement']):
+        if (
+            noise is not None
+            and (self.options['store_wiener_process']
+                 or self.options['store_measurement'])
+        ):
             for i, dW in enumerate(noise):
                 self.W[i].append(self.W[i][-1] + dW)
 
@@ -41,7 +46,7 @@ def wiener_process(self):
         for heterodyne detection.
         """
         W = np.array(self.W)
-        if self.options["heterodyne"]:
+        if self.heterodyne:
             W = W.reshape(-1, 2, W.shape[1])
         return W
 
@@ -57,7 +62,7 @@ def dW(self):
         for heterodyne detection.
         """
         dw = np.diff(self.W, axis=1)
-        if self.options["heterodyne"]:
+        if self.heterodyne:
             dw = dw.reshape(-1, 2, dw.shape[1])
         return dw
 
@@ -75,7 +80,7 @@ def measurement(self):
         dts = np.diff(self.times)
         m_expect = np.array(self.m_expect)[:, 1:]
         noise = np.einsum("i,ij,j->ij", self.dW_factor, np.diff(self.W, axis=1), (1/dts))
-        if self.options["heterodyne"]:
+        if self.heterodyne:
             m_expect = m_expect.reshape(-1, 2, m_expect.shape[1])
             noise = noise.reshape(-1, 2, noise.shape[1])
         return m_expect + noise
@@ -108,9 +113,16 @@ def _post_init(self):
             self._measurement = []
 
     def _reduce_attr(self, trajectory, attr):
+        """
+        Add a result attribute to a list when the trajectories are not stored.
+        """
         getattr(self, "_" + attr).append(getattr(trajectory, attr))
 
     def _trajectories_attr(self, attr):
+        """
+        Get the result associated to the attr, whether the trajectories are
+        saved or not.
+        """
         if hasattr(self, "_" + attr):
             return getattr(self, "_" + attr)
         elif self.options['keep_runs_results']:
@@ -161,7 +173,17 @@ def wiener_process(self):
         return self._trajectories_attr("wiener_process")
 
 
-class StochasticRHS:
+class _StochasticRHS:
+    """
+    In between object to store the stochastic system.
+
+    It store the Hamiltonian (not Liouvillian when possible), and sc_ops.
+    dims and flags are provided to be usable the the base ``Solver`` class.
+
+    We don't want to use the cython rhs (``StochasticOpenSystem``, etc.) since
+    the rouchon integrator need the part but does not use the usual drift and
+    diffusion computation.
+    """
     def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
 
         if not isinstance(H, (Qobj, QobjEvo)) or not H.isoper:
@@ -207,46 +229,114 @@ def __call__(self, options):
 
 
 def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
-             args={}, ntraj=500, options=None):
+             args={}, ntraj=500, options=None, heterodyne=False,
+             seeds=None, target_tol=None, timeout=None):
     """
-    Solve stochastic master equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
+    Solve stochastic master equation.
+    **************  TODO  ******************
 
     Parameters
     ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
 
     rho0 : :class:`qutip.Qobj`
         Initial density matrix or state vector (ket).
 
     tlist : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
+        List of times for :math:`t`.
 
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
         Deterministic collapse operator which will contribute with a standard
         Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
 
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
+    sc_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        List of stochastic collapse operators.
 
-    e_ops : list of :class:`qutip.Qobj`
+    e_ops : : :class:`qutip.qobj`, callable, or list.
         Single operator or list of operators for which to evaluate
-        expectation values.
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
 
     m_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    args : dict
-        ...
+        List of measurements operators, when not provided, they are computed
+        from the sc_ops according to whether homodyne or heterodyne detection
+        is used.
+
+    args : None / *dictionary*
+        Dictionary of parameters for time-dependent Hamiltonians and
+        collapse operators.
+
+    ntraj : int [500]
+        Number of trajectories to compute.
+
+    heterodyne : bool [False]
+        Whether to use heterodyne or homodyne detection.
+
+    seeds : int, SeedSequence, list, [optional]
+        Seed for the random number generator. It can be a single seed used to
+        spawn seeds for each trajectory or a list of seeds, one for each
+        trajectory. Seeds are saved in the result and they can be reused with::
+
+            seeds=prev_result.seeds
+
+    target_tol : {float, tuple, list}, optional
+        Target tolerance of the evolution. The evolution will compute
+        trajectories until the error on the expectation values is lower than
+        this tolerance. The maximum number of trajectories employed is
+        given by ``ntraj``. The error is computed using jackknife resampling.
+        ``target_tol`` can be an absolute tolerance or a pair of absolute and
+        relative tolerance, in that order. Lastly, it can be a list of pairs of
+        (atol, rtol) for each e_ops.
+
+    timeout : float [optional]
+        Maximum time for the evolution in second. When reached, no more
+        trajectories will be computed. Overwrite the option of the same name.
+
+    options : None / dict
+        Dictionary of options for the solver.
+        - store_final_state : bool, [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None, [None]
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - store_measurement: bool, [False]
+          Whether to store the measurement for each trajectories.
+        - store_wiener_process: bool, [False]
+          Whether to store the wiener process, or brownian noise for each
+          trajectories.
+        - keep_runs_results : bool, [False]
+          Whether to store results from all trajectories or just store the
+          averages.
+        - normalize_output : bool, [False]
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str, ["rouchon"]
+          Which stochastic differential equation integration method to use.
+          Main ones are {"euler", "rouchon", "platen", "taylor1.5_imp"}
+        - map : str {"serial", "parallel", "loky"}, ["serial"]
+          How to run the trajectories. "parallel" uses concurent module to run
+          in parallel while "loky" use the module of the same name to do so.
+        - job_timeout : NoneType, int, [None]
+          Maximum time to compute one trajectory.
+        - num_cpus : NoneType, int, [None]
+          Number of cpus to use when running in parallel. ``None`` detect the
+          number of available cpus.
+        - dt : float [0.001]
+          The finite steps lenght for the Stochastic integration method.
+
+        Other options could be supported depending on the integration method,
+        see `SIntegrator <./classes.html#classes-ode>`_.
 
     Returns
     -------
@@ -258,70 +348,139 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     H = QobjEvo(H, args=args, tlist=tlist)
     c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
     sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
-    sol = SMESolver(H, sc_ops, c_ops=c_ops, options=options)
+    sol = SMESolver(H, sc_ops, c_ops=c_ops,
+                    options=options, heterodyne=heterodyne)
     if m_ops:
         sol.m_ops = m_ops
-    return sol.run(rho0, tlist, ntraj, e_ops=e_ops)
+    return sol.run(rho0, tlist, ntraj, e_ops=e_ops
+                   seed=seeds, target_tol=target_tol, timeout=timeout)
 
 
 def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
-             args={}, ntraj=500, options=None):
+             args={}, ntraj=500, options=None, heterodyne=False,
+             seeds=None, target_tol=None, timeout=None):
     """
-    Solve stochastic master equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
+    Solve stochastic Schrodinger equation.
+    **************  TODO  ******************
 
     Parameters
     ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
 
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
 
     tlist : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
+        List of times for :math:`t`.
 
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
+    sc_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        List of stochastic collapse operators.
 
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
+    e_ops : :class:`qutip.qobj`, callable, or list.
         Single operator or list of operators for which to evaluate
-        expectation values.
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
 
     m_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    args : dict
-        ...
+        List of measurements operators, when not provided, they are computed
+        from the sc_ops according to whether homodyne or heterodyne detection
+        is used.
+
+    args : None / *dictionary*
+        Dictionary of parameters for time-dependent Hamiltonians and
+        collapse operators.
+
+    ntraj : int [500]
+        Number of trajectories to compute.
+
+    heterodyne : bool [False]
+        Whether to use heterodyne or homodyne detection.
+
+    seeds : int, SeedSequence, list, [optional]
+        Seed for the random number generator. It can be a single seed used to
+        spawn seeds for each trajectory or a list of seeds, one for each
+        trajectory. Seeds are saved in the result and they can be reused with::
+
+            seeds=prev_result.seeds
+
+    target_tol : {float, tuple, list}, optional
+        Target tolerance of the evolution. The evolution will compute
+        trajectories until the error on the expectation values is lower than
+        this tolerance. The maximum number of trajectories employed is
+        given by ``ntraj``. The error is computed using jackknife resampling.
+        ``target_tol`` can be an absolute tolerance or a pair of absolute and
+        relative tolerance, in that order. Lastly, it can be a list of pairs of
+        (atol, rtol) for each e_ops.
+
+    timeout : float [optional]
+        Maximum time for the evolution in second. When reached, no more
+        trajectories will be computed. Overwrite the option of the same name.
+
+    options : None / dict
+        Dictionary of options for the solver.
+        - store_final_state : bool, [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None, [None]
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - store_measurement: bool, [False]
+          Whether to store the measurement for each trajectories.
+        - store_wiener_process: bool, [False]
+          Whether to store the wiener process, or brownian noise for each
+          trajectories.
+        - keep_runs_results : bool, [False]
+          Whether to store results from all trajectories or just store the
+          averages.
+        - normalize_output : bool, [False]
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str, ["rouchon"]
+          Which stochastic differential equation integration method to use.
+          Main ones are {"euler", "rouchon", "platen", "taylor1.5_imp"}
+        - map : str {"serial", "parallel", "loky"}, ["serial"]
+          How to run the trajectories. "parallel" uses concurent module to run
+          in parallel while "loky" use the module of the same name to do so.
+        - job_timeout : NoneType, int, [None]
+          Maximum time to compute one trajectory.
+        - num_cpus : NoneType, int, [None]
+          Number of cpus to use when running in parallel. ``None`` detect the
+          number of available cpus.
+        - dt : float [0.001]
+          The finite steps lenght for the Stochastic integration method.
+
+        Other options could be supported depending on the integration method,
+        see `SIntegrator <./classes.html#classes-ode>`_.
 
     Returns
     -------
 
     output: :class:`qutip.solver.Result`
-
         An instance of the class :class:`qutip.solver.Result`.
     """
     H = QobjEvo(H, args=args, tlist=tlist)
     sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
-    sol = SSESolver(H, sc_ops, options=options)
+    sol = SSESolver(H, sc_ops, options=options, heterodyne=heterodyne)
     if m_ops:
         sol.m_ops = m_ops
-    return sol.run(psi0, tlist, ntraj, e_ops=e_ops)
+    return sol.run(psi0, tlist, ntraj, e_ops=e_ops,
+                   seed=seeds, target_tol=target_tol, timeout=timeout)
 
 
 class StochasticSolver(MultiTrajSolver):
+    """
+    Generic stochastic solver.
+    """
     name = "StochasticSolver"
     resultclass = StochasticResult
     _avail_integrators = {}
@@ -331,6 +490,8 @@ class StochasticSolver(MultiTrajSolver):
         "progress_kwargs": {"chunk_size": 10},
         "store_final_state": False,
         "store_states": None,
+        "store_wiener_process": False,
+        "store_measurement": False,
         "keep_runs_results": False,
         "normalize_output": False,
         "method": "rouchon",
@@ -338,24 +499,19 @@ class StochasticSolver(MultiTrajSolver):
         "job_timeout": None,
         "num_cpus": None,
         "bitgenerator": None,
-        "heterodyne": False,
-        "store_wiener_process": False,
-        "store_measurement": False,
-        "dw_factor": None,
     }
 
-    def __init__(self, H, sc_ops, *, c_ops=(), options=None):
+    def __init__(self, H, sc_ops, heterodyne, *, c_ops=(), options=None):
         self.options = options
-        heterodyne = self.options["heterodyne"]
+        self._heterodyne = heterodyne
         if self.name == "ssesolve" and c_ops:
-            raise ValueError("")
+            raise ValueError("c_ops are not supported by ssesolve.")
 
-        rhs = StochasticRHS(self._open, H, sc_ops, c_ops, heterodyne)
+        rhs = _StochasticRHS(self._open, H, sc_ops, c_ops, heterodyne)
         super().__init__(rhs, options=options)
 
         if self.options["store_measurement"]:
             self.options["store_wiener_process"] = True
-            dW_factor = self.options["dw_factor"] or 1.
 
             if heterodyne:
                 self._m_ops = []
@@ -373,6 +529,10 @@ def __init__(self, H, sc_ops, *, c_ops=(), options=None):
             self._m_ops = []
             self.dW_factors = []
 
+    @property
+    def heterodyne(self):
+        return self._heterodyne
+
     @property
     def m_ops(self):
         return self._m_ops
@@ -386,7 +546,7 @@ def m_ops(self, new_m_ops):
             )
 
         if len(new_m_ops) != len(self.rhs.sc_ops):
-            if self.options["heterodyne"]:
+            if self.heterodyne:
                 raise ValueError(
                     f"2 `m_ops` per `sc_ops`, {len(self.rhs.sc_ops)} operators"
                     " are expected for heterodyne measurement."
@@ -410,7 +570,7 @@ def dW_factors(self, new_dW_factors):
             )
 
         if len(new_dW_factors) != len(self.rhs.sc_ops):
-            if self.options["heterodyne"]:
+            if self.heterodyne:
                 raise ValueError(
                     f"2 `dW_factors` per `sc_ops`, {len(self.rhs.sc_ops)} "
                     "values are expected for heterodyne measurement."
@@ -427,6 +587,7 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         """
         result = StochasticTrajResult(
             e_ops, self.options, m_ops=self.m_ops, dw_factor=self.dW_factors,
+            heterodyne=self.heterodyne
         )
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
@@ -447,14 +608,117 @@ def avail_integrators(cls):
             **cls._avail_integrators,
         }
 
+    @property
+    def options(self):
+        """
+        Options for stochastic solver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+          - store_measurement: bool, [False]
+            Whether to store the measurement for each trajectories.
+
+          - store_wiener_process: bool, [False]
+            Whether to store the wiener process, or brownian noise for each
+            trajectories.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error if
+            not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size":10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        keep_runs_results: bool
+          Whether to store results from all trajectories or just store the
+          averages.
+
+        method: str, default="rouchon"
+            Which ODE integrator methods are supported.
+
+        map: str {"serial", "parallel", "loky"}, default="serial"
+            How to run the trajectories. "parallel" uses concurent module to
+            run in parallel while "loky" use the module of the same name to do
+            so.
+
+        job_timeout: None, int, default=None
+            Maximum time to compute one trajectory.
+
+        num_cpus: None, int, default=None
+            Number of cpus to use when running in parallel. ``None`` detect the
+            number of available cpus.
+
+        bitgenerator: {None, "MT19937", "PCG64DXSM", ...}, default=None
+            Which of numpy.random's bitgenerator to use. With ``None``, your
+            numpy version's default is used.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        MultiTrajSolver.options.fset(self, new_options)
+
 
 class SMESolver(StochasticSolver):
+    r"""
+    ***************  TODO ****************
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    sc_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        List of stochastic collapse operators.
+
+    heterodyne : bool, [optional]
+        Whether to use heterodyne or homodyne detection.
+
+    options : dict, [optional]
+        Options for the solver, see :obj:`SMESolver.options` and
+        `SIntegrator <./classes.html#classes-ode>`_ for a list of all options.
+    """
     name = "smesolve"
     _avail_integrators = {}
     _open = True
 
 
 class SSESolver(StochasticSolver):
+    r"""
+    ***************  TODO ****************
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    sc_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        List of stochastic collapse operators.
+
+    heterodyne : bool, [optional]
+        Whether to use heterodyne or homodyne detection.
+
+    options : dict, [optional]
+        Options for the solver, see :obj:`SSESolver.options` and
+        `SIntegrator <./classes.html#classes-ode>`_ for a list of all options.
+    """
     name = "ssesolve"
     _avail_integrators = {}
     _open = False
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index 80e90f3a55..05e76d7ae4 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -5,8 +5,8 @@
 import qutip.solver.sode._sode as _sode
 import pytest
 from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticOpenSystem, StochasticClosedSystem
-from qutip.solver.sode.noise import _Noise
-from qutip.solver.stochastic import SMESolver, StochasticRHS
+from qutip.solver.sode._noise import _Noise
+from qutip.solver.stochastic import SMESolver, _StochasticRHS
 
 
 def get_error_order(system, state, method, plot=False, **kw):
@@ -142,7 +142,7 @@ def test_open_integrator(method, order, H, c_ops, sc_ops):
     c_ops = [_make_oper(op, N) for op in c_ops]
     sc_ops = [_make_oper(op, N) for op in sc_ops]
 
-    rhs = StochasticRHS(StochasticOpenSystem, H, sc_ops, c_ops, False)
+    rhs = _StochasticRHS(StochasticOpenSystem, H, sc_ops, c_ops, False)
     ref_sode = SMESolver.avail_integrators()["taylor1.5"](rhs, {"dt": 0.01})
     sode = SMESolver.avail_integrators()[method](rhs, {"dt": 0.01})
     state = operator_to_vector(fock_dm(5, 3, dtype="Dense")).data
@@ -168,7 +168,7 @@ def test_closed_integrator(method, order, H, sc_ops):
     H = _make_oper(H, N)
     sc_ops = [_make_oper(op, N) for op in sc_ops]
 
-    rhs = StochasticRHS(StochasticClosedSystem, H, sc_ops, (), False)
+    rhs = _StochasticRHS(StochasticClosedSystem, H, sc_ops, (), False)
     ref_sode = SMESolver.avail_integrators()["explicit1.5"](rhs, {"dt": 0.01})
     sode = SMESolver.avail_integrators()[method](rhs, {"dt": 0.01})
     state = operator_to_vector(fock_dm(5, 3, dtype="Dense")).data

From b61ba1fdf6c7f1a099d68e80daae2b2ef38740af Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 16 Mar 2023 17:35:57 -0400
Subject: [PATCH 169/602] rename file

---
 qutip/solver/sode/_noise.py | 49 +++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 qutip/solver/sode/_noise.py

diff --git a/qutip/solver/sode/_noise.py b/qutip/solver/sode/_noise.py
new file mode 100644
index 0000000000..5cd0a05a88
--- /dev/null
+++ b/qutip/solver/sode/_noise.py
@@ -0,0 +1,49 @@
+import numpy as np
+
+__all__ = []
+
+class _Noise:
+    """
+    Weiner process generator used for tests.
+    """
+    def __init__(self, T, dt, num=1):
+        N = int(np.round(T / dt))
+        self.T = T
+        self.dt = dt
+        self.num = num
+        self.noise = np.random.randn(N, num) * dt**0.5
+
+    def dw(self, dt):
+        """
+        Ito integral I(i).
+        """
+        N = int(np.round(dt /self.dt))
+        return self.noise.reshape(-1, N, self.num).sum(axis=1)
+
+    def dz(self, dt):
+        """
+        Ito integral I(0, i).
+        """
+        N = int(np.round(dt /self.dt))
+        return np.einsum(
+            "ijk,j->ik",
+            self.noise.reshape(-1, N, self.num),
+            np.arange(N-0.5, 0, -1)
+        ) * self.dt
+
+    def dW(self, dt):
+        """
+        Noise used for Ito-Taylor integrators of order up to 1.5.
+        """
+        N = int(np.round(dt / self.dt))
+        noise = self.noise.copy()
+        if noise.shape[0] % N:
+            noise = noise[:-(noise.shape[0] % N)]
+        out = np.empty((noise.shape[0] // N, 2, self.num), dtype=float)
+        out[:, 0, :] = noise.reshape(-1, N, self.num).sum(axis=1)
+        out[:, 1, :] = np.einsum(
+            "ijk,j->ik",
+            self.noise.reshape(-1, N, self.num),
+            np.arange(N-0.5, 0, -1)
+        ) * self.dt
+        return out

From 033b6e6a50fa7a47a5a4aaab05074954cc0a7705 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 09:39:14 -0400
Subject: [PATCH 170/602] Enable warning in matmul_csr_dense

---
 qutip/core/data/csr.pyx             |  3 ---
 qutip/core/data/dense.pyx           |  3 ---
 qutip/core/data/matmul.pyx          |  3 ++-
 qutip/tests/core/data/test_dense.py | 11 ++++++++++-
 4 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 18989ff235..552c5ab0e5 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -25,10 +25,7 @@ except ImportError:
 from scipy.linalg cimport cython_blas as blas
 
 from qutip.core.data cimport base, Dense
-from qutip.core.data.add cimport add_csr, sub_csr
 from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
-from qutip.core.data.mul cimport mul_csr, neg_csr
-from qutip.core.data.matmul cimport matmul_csr
 from qutip.core.data.trace cimport trace_csr
 from qutip.core.data.tidyup cimport tidyup_csr
 from .base import idxint_dtype
diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
index 99c4f28a49..38c32f5bb8 100644
--- a/qutip/core/data/dense.pyx
+++ b/qutip/core/data/dense.pyx
@@ -12,10 +12,7 @@ from scipy.linalg cimport cython_blas as blas
 
 from .base import EfficiencyWarning
 from qutip.core.data cimport base, CSR
-from qutip.core.data.add cimport add_dense, sub_dense
 from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
-from qutip.core.data.mul cimport mul_dense, neg_dense
-from qutip.core.data.matmul cimport matmul_dense
 from qutip.core.data.trace cimport trace_dense
 
 cnp.import_array()
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 0accc05286..1d05387961 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -21,6 +21,7 @@ from qutip.core.data.dense cimport Dense
 from qutip.core.data.csr cimport CSR
 from qutip.core.data cimport csr, dense
 from qutip.core.data.add cimport iadd_dense, add_csr
+from qutip.core.data.dense import OrderEfficiencyWarning
 
 cnp.import_array()
 
@@ -196,7 +197,7 @@ cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
             "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
             + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
         )
-        warnings.warn(msg, dense.OrderEfficiencyWarning)
+        warnings.warn(msg, OrderEfficiencyWarning)
         # Rather than making loads of copies of the same code, we just moan at
         # the user and then transpose one of the arrays.  We prefer to have
         # `right` in Fortran-order for cache efficiency.
diff --git a/qutip/tests/core/data/test_dense.py b/qutip/tests/core/data/test_dense.py
index 655595d1a4..072908115d 100644
--- a/qutip/tests/core/data/test_dense.py
+++ b/qutip/tests/core/data/test_dense.py
@@ -2,7 +2,7 @@
 import pytest
 
 from qutip.core import data
-from qutip.core.data import dense
+from qutip.core.data import dense, csr
 
 from . import conftest
 
@@ -286,3 +286,12 @@ def test_one_element_error(self, shape, position, value):
             base = data.one_element_dense(shape, position, value)
         assert str(exc.value).startswith("Position of the elements"
                                          " out of bound: ")
+
+
+def test_OrderEfficiencyWarning():
+    N = 5
+    M = csr.identity(N)
+    C_ordered = dense.zeros(N, 1, fortran=False)
+    fortran_ordered = dense.zeros(N, 1, fortran=True)
+    with pytest.warns(dense.OrderEfficiencyWarning):
+        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)

From a2d3d8f5cf27f75ffaf1f17209b4c1bf3e57a8f3 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 10:15:48 -0400
Subject: [PATCH 171/602] mul using blas

---
 qutip/core/data/mul.pyx | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 27d8e47663..439c6cf694 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -2,6 +2,7 @@
 #cython: boundscheck=False, wrapround=False, initializedcheck=False
 
 from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
+from scipy.linalg.cython_blas cimport zscal
 
 __all__ = [
     'mul', 'mul_csr', 'mul_dense',
@@ -12,10 +13,9 @@ __all__ = [
 
 cpdef CSR imul_csr(CSR matrix, double complex value):
     """Multiply this CSR `matrix` by a complex scalar `value`."""
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            matrix.data[ptr] *= value
+    cdef idxint l = csr.nnz(matrix)
+    cdef int ONE=1
+    zscal(&l, &value, matrix.data, &ONE)
     return matrix
 
 cpdef CSR mul_csr(CSR matrix, double complex value):
@@ -42,9 +42,9 @@ cpdef CSR neg_csr(CSR matrix):
 cpdef Dense imul_dense(Dense matrix, double complex value):
     """Multiply this Dense `matrix` by a complex scalar `value`."""
     cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-            matrix.data[ptr] *= value
+    cdef int ONE=1
+    cdef idxint l = matrix.shape[0]*matrix.shape[1]
+    zscal(&l, &value, matrix.data, &ONE)
     return matrix
 
 cpdef Dense mul_dense(Dense matrix, double complex value):

From 00b7451b87e0fd6cf043f588d0201dd7525d76c4 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 09:56:17 -0400
Subject: [PATCH 172/602] Add operation to trace oper-ket without reshaping

---
 qutip/core/data/trace.pxd                 |  3 ++
 qutip/core/data/trace.pyx                 | 48 +++++++++++++++++++++++
 qutip/solver/mcsolve.py                   | 12 ++----
 qutip/tests/core/data/test_mathematics.py | 20 ++++++++++
 4 files changed, 74 insertions(+), 9 deletions(-)

diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index bdac487763..e231896f8f 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -4,3 +4,6 @@ from qutip.core.data cimport CSR, Dense
 
 cpdef double complex trace_csr(CSR matrix) nogil except *
 cpdef double complex trace_dense(Dense matrix) nogil except *
+
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 18756de52d..565b9b2c26 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -2,11 +2,14 @@
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
 cimport cython
+from libc.math cimport sqrt
 
 from qutip.core.data cimport Data, CSR, Dense
+from qutip.core.data cimport base
 
 __all__ = [
     'trace', 'trace_csr', 'trace_dense',
+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
 ]
 
 
@@ -17,6 +20,13 @@ cdef void _check_shape(Data matrix) nogil except *:
         ]))
 
 
+cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
+    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
+        raise ValueError("".join([
+            "matrix ", str(matrix.shape), " is not a stacked square matrix."
+        ]))
+
+
 cpdef double complex trace_csr(CSR matrix) nogil except *:
     _check_shape(matrix)
     cdef size_t row, ptr
@@ -39,6 +49,28 @@ cpdef double complex trace_dense(Dense matrix) nogil except *:
     return trace
 
 
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
+    cdef int N = <int>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef size_t row, ptr
+    cdef double complex trace = 0
+    for row in range(N):
+        if matrix.row_index[row * (N+1)] != matrix.row_index[row * (N+1) + 1]:
+            trace += matrix.data[matrix.row_index[row * (N+1)]]
+    return trace
+
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
+    cdef int N = <int>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef double complex trace = 0
+    cdef size_t ptr = 0
+    cdef size_t stride = N + 1
+    for _ in range(N):
+        trace += matrix.data[ptr]
+        ptr += stride
+    return trace
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -58,4 +90,20 @@ trace.add_specialisations([
     (Dense, trace_dense),
 ], _defer=True)
 
+trace_oper_ket = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='trace_oper_ket',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+trace_oper_ket.__doc__ =\
+    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
+trace_oper_ket.add_specialisations([
+    (CSR, trace_oper_ket_csr),
+    (Dense, trace_oper_ket_dense),
+], _defer=True)
+
 del _inspect, _Dispatcher
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 3a326ce405..bc3369b979 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -225,12 +225,12 @@ def reset(self, hard=False):
 
     def _prob_func(self, state):
         if self.issuper:
-            return _data.norm.trace(unstack_columns(state))
+            return _data.trace_oper_ket(state).real
         return _data.norm.l2(state)**2
 
     def _norm_func(self, state):
         if self.issuper:
-            return _data.norm.trace(unstack_columns(state))
+            return _data.trace_oper_ket(state).real
         return _data.norm.l2(state)
 
     def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
@@ -339,14 +339,8 @@ class MCSolver(MultiTrajSolver):
         (see :class:`qutip.QobjEvo`'s documentation). They must be operators
         even if ``H`` is a superoperator.
 
-    options : SolverOptions, [optional]
+    options : dict, [optional]
         Options for the evolution.
-
-    seed : int, SeedSequence, list, [optional]
-        Seed for the random number generator. It can be a single seed used to
-        spawn seeds for each trajectory or a list of seed, one for each
-        trajectory. Seeds are saved in the result and can be reused with::
-            seeds=prev_result.seeds
     """
     name = "mcsolve"
     resultclass = McResult
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index ceeecda9a7..459ab0d467 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -804,6 +804,26 @@ def op_numpy(self, matrix):
     ]
 
 
+class TestTrace_oper_ket(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        N = int(matrix.shape[0] ** 0.5)
+        return np.sum(np.diag(matrix.reshape((N, N))))
+
+    shapes = [
+        (pytest.param((100, 1), id="oper-ket"),),
+    ]
+    bad_shapes = [
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((99, 1), id="ket"),),
+        (pytest.param((99, 99), id="ket"),),
+        (pytest.param((2, 99), id="nonsquare"),),
+    ]
+    specialisations = [
+        pytest.param(data.trace_oper_ket_csr, CSR, complex),
+        pytest.param(data.trace_oper_ket_dense, Dense, complex),
+    ]
+
+
 class TestPow(UnaryOpMixin):
     def op_numpy(self, matrix, n):
         return np.linalg.matrix_power(matrix, n)

From eafa1c8a52f4a8bab31763969f0c43c605d31502 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 10:59:52 -0400
Subject: [PATCH 173/602] Add towncrier entry

---
 doc/changes/2126.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2126.feature

diff --git a/doc/changes/2126.feature b/doc/changes/2126.feature
new file mode 100644
index 0000000000..f44b697b24
--- /dev/null
+++ b/doc/changes/2126.feature
@@ -0,0 +1 @@
+Create the `trace_oper_ket` operation

From 41129bc2924fa6fa7726c051f5560e17be2c8039 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 11:04:45 -0400
Subject: [PATCH 174/602] Fix typo in mesolve.py

---
 qutip/solver/mesolve.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/mesolve.py b/qutip/solver/mesolve.py
index ed865dcabd..5792038af1 100644
--- a/qutip/solver/mesolve.py
+++ b/qutip/solver/mesolve.py
@@ -170,7 +170,7 @@ class MESolver(SESolver):
         of Liouvillian superoperators. None is equivalent to an empty list.
 
     options : dict, optional
-        Options for the solver, see :obj:`SESolver.options` and
+        Options for the solver, see :obj:`MESolver.options` and
         `Integrator <./classes.html#classes-ode>`_ for a list of all options.
 
     attributes

From 13f6345a58bd9d36811d54ef7c8117ff5f5f6962 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 13:28:05 -0400
Subject: [PATCH 175/602] Fixed tests

---
 .coveragerc                           | 1 +
 qutip/solver/sode/ssystem.pyx         | 2 +-
 qutip/solver/stochastic.py            | 2 +-
 qutip/tests/solver/test_stochastic.py | 6 ++----
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index 69f745007b..a83955cad4 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -10,3 +10,4 @@ omit =
 exclude_lines =
     # Skip Python wrappers which help load in C extension modules.
     __bootstrap__()
+    raise NotImplementedError
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 7f3737c7e6..ef55812a02 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -184,7 +184,7 @@ cdef class StochasticOpenSystem(_StochasticSystem):
             self.L = H + liouvillian(None, sc_ops)
         else:
             self.L = liouvillian(H, sc_ops)
-        if c_ops:(c_i - e_i / 2) * psi
+        if c_ops:
             self.L = self.L + liouvillian(None, c_ops)
 
         self.c_ops = [spre(op) + spost(op.dag()) for op in sc_ops]
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 781f27e610..e83205aab4 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -352,7 +352,7 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
                     options=options, heterodyne=heterodyne)
     if m_ops:
         sol.m_ops = m_ops
-    return sol.run(rho0, tlist, ntraj, e_ops=e_ops
+    return sol.run(rho0, tlist, ntraj, e_ops=e_ops,
                    seed=seeds, target_tol=target_tol, timeout=timeout)
 
 
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index a27eb5fdd4..96899cc722 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -59,7 +59,6 @@ def test_smesolve(method, heterodyne, system):
     res_ref = mesolve(H, psi0, times, c_ops + sc_ops, e_ops, args={"a": 2})
 
     options = {
-        "heterodyne": heterodyne,
         "store_measurement": True,
         "map": "serial",
         "method": method,
@@ -67,7 +66,7 @@ def test_smesolve(method, heterodyne, system):
 
     res = smesolve(
         H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, c_ops=c_ops,
-        ntraj=ntraj, args={"a": 2}, options=options
+        ntraj=ntraj, args={"a": 2}, options=options, heterodyne=heterodyne,
     )
 
     for idx in range(len(e_ops)):
@@ -109,7 +108,6 @@ def test_ssesolve(method, heterodyne, system):
     res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a": 2})
 
     options = {
-        "heterodyne": heterodyne,
         "store_measurement": True,
         "map": "serial",
         "method": method,
@@ -117,7 +115,7 @@ def test_ssesolve(method, heterodyne, system):
 
     res = ssesolve(
         H, psi0, times, sc_ops, e_ops,
-        ntraj=ntraj, args={"a": 2}, options=options
+        ntraj=ntraj, args={"a": 2}, options=options, heterodyne=heterodyne,
     )
 
     for idx in range(len(e_ops)):

From 4d29594bb99ffefc0be7f4f16ffaef63e2ae7469 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 17 Mar 2023 16:47:58 -0400
Subject: [PATCH 176/602] More tests

---
 qutip/solver/stochastic.py                   |  12 ++
 qutip/tests/solver/test_sode_method.py       |   7 +-
 qutip/tests/solver/test_stochastic.py        | 176 +++++++++++++++++--
 qutip/tests/solver/test_stochastic_system.py |   2 +-
 4 files changed, 177 insertions(+), 20 deletions(-)

diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index e83205aab4..71402691e4 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -539,7 +539,13 @@ def m_ops(self):
 
     @m_ops.setter
     def m_ops(self, new_m_ops):
+        """
+        TODO
+        """
         if not self.options["store_measurement"]:
+            if not new_m_ops:
+                self._m_ops = []
+                return
             raise ValueError(
                 "The 'store_measurement' options must be set to "
                 "`True` to use m_ops."
@@ -564,7 +570,13 @@ def dW_factors(self):
 
     @dW_factors.setter
     def dW_factors(self, new_dW_factors):
+        """
+        TODO
+        """
         if not self.options["store_measurement"]:
+            if not new_dW_factors:
+                self._dW_factors = []
+                return
             raise ValueError(
                 "The 'dW_factors' are only used with measurements."
             )
diff --git a/qutip/tests/solver/test_sode_method.py b/qutip/tests/solver/test_sode_method.py
index 05e76d7ae4..075dbe9a13 100644
--- a/qutip/tests/solver/test_sode_method.py
+++ b/qutip/tests/solver/test_sode_method.py
@@ -1,10 +1,13 @@
 import numpy as np
 from itertools import product
 from qutip.core import data as _data
-from qutip import qeye, destroy, QobjEvo, rand_ket, rand_herm, create, Qobj, operator_to_vector, fock_dm
+from qutip import (qeye, destroy, QobjEvo, rand_ket, rand_herm, create, Qobj,
+                   operator_to_vector, fock_dm)
 import qutip.solver.sode._sode as _sode
 import pytest
-from qutip.solver.sode.ssystem import SimpleStochasticSystem, StochasticOpenSystem, StochasticClosedSystem
+from qutip.solver.sode.ssystem import (
+    SimpleStochasticSystem, StochasticOpenSystem, StochasticClosedSystem
+)
 from qutip.solver.sode._noise import _Noise
 from qutip.solver.stochastic import SMESolver, _StochasticRHS
 
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 96899cc722..9e7f5abe64 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -4,28 +4,28 @@
     mesolve, liouvillian, QobjEvo, spre, spost,
     destroy, coherent, qeye, fock_dm, num
 )
-from qutip.solver.stochastic import smesolve, ssesolve
+from qutip.solver.stochastic import smesolve, ssesolve, SMESolver, SSESolver
 from qutip.core import data as _data
 
 
-def f(t, a):
-    return a * t
+def f(t, w):
+    return w * t
 
 def _make_system(N, system):
     gamma = 0.25
     a = destroy(N)
 
     if system == "simple":
-        H = [a.dag() * a]
+        H = a.dag() * a
         sc_ops = [np.sqrt(gamma) * a]
 
     elif system == "2 c_ops":
-        H = [a.dag() * a]
+        H = QobjEvo([a.dag() * a])
         sc_ops = [np.sqrt(gamma) * a, gamma * a * a]
 
     elif system == "H td":
         H = [[a.dag() * a, f]]
-        sc_ops = [np.sqrt(gamma) * a]
+        sc_ops = [np.sqrt(gamma) * QobjEvo(a)]
 
     elif system == "complex":
         H = [a.dag() * a + a.dag() + a]
@@ -42,8 +42,7 @@ def _make_system(N, system):
     "simple", "2 c_ops", "H td", "complex", "c_ops td",
 ])
 @pytest.mark.parametrize("heterodyne", [True, False])
-@pytest.mark.parametrize("method", ["milstein", "platen", "rouchon"])
-def test_smesolve(method, heterodyne, system):
+def test_smesolve(heterodyne, system):
     "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.05
     N = 4
@@ -55,8 +54,43 @@ def test_smesolve(method, heterodyne, system):
     a = destroy(N)
     e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
 
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, c_ops + sc_ops, e_ops, args={"a": 2})
+    times = np.linspace(0, 0.1, 21)
+    res_ref = mesolve(H, psi0, times, c_ops + sc_ops, e_ops, args={"w": 2})
+
+    options = {
+        "store_measurement": False,
+        "map": "serial",
+    }
+
+    res = smesolve(
+        H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, c_ops=c_ops,
+        ntraj=ntraj, args={"w": 2}, options=options, heterodyne=heterodyne,
+        seeds=1,
+    )
+
+    for idx in range(len(e_ops)):
+        np.testing.assert_allclose(
+            res.expect[idx], res_ref.expect[idx], rtol=tol, atol=tol
+        )
+
+
+@pytest.mark.parametrize("heterodyne", [True, False])
+@pytest.mark.parametrize("method", SMESolver.avail_integrators().keys())
+def test_smesolve_methods(method, heterodyne):
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.05
+    N = 4
+    ntraj = 20
+    system = "simple"
+
+    H, sc_ops = _make_system(N, system)
+    c_ops = [destroy(N)]
+    psi0 = coherent(N, 0.5)
+    a = destroy(N)
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 0.1, 21)
+    res_ref = mesolve(H, psi0, times, c_ops + sc_ops, e_ops, args={"w": 2})
 
     options = {
         "store_measurement": True,
@@ -66,7 +100,8 @@ def test_smesolve(method, heterodyne, system):
 
     res = smesolve(
         H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, c_ops=c_ops,
-        ntraj=ntraj, args={"a": 2}, options=options, heterodyne=heterodyne,
+        ntraj=ntraj, args={"w": 2}, options=options, heterodyne=heterodyne,
+        seeds=list(range(ntraj)),
     )
 
     for idx in range(len(e_ops)):
@@ -77,11 +112,27 @@ def test_smesolve(method, heterodyne, system):
     assert len(res.measurement) == ntraj
 
     if heterodyne:
+        assert all([
+            dw.shape == (len(sc_ops), 2, len(times)-1)
+            for dw in res.dW
+        ])
+        assert all([
+            w.shape == (len(sc_ops), 2, len(times))
+            for w in res.wiener_process
+        ])
         assert all([
             m.shape == (len(sc_ops), 2, len(times)-1)
             for m in res.measurement
         ])
     else:
+        assert all([
+            dw.shape == (len(sc_ops), len(times)-1)
+            for dw in res.dW
+        ])
+        assert all([
+            w.shape == (len(sc_ops), len(times))
+            for w in res.wiener_process
+        ])
         assert all([
             m.shape == (len(sc_ops), len(times)-1)
             for m in res.measurement
@@ -92,46 +143,137 @@ def test_smesolve(method, heterodyne, system):
     "simple", "2 c_ops", "H td", "complex", "c_ops td",
 ])
 @pytest.mark.parametrize("heterodyne", [True, False])
-@pytest.mark.parametrize("method", ["platen", "rouchon"])
-def test_ssesolve(method, heterodyne, system):
+def test_ssesolve(heterodyne, system):
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.1
+    N = 4
+    ntraj = 20
+
+    H, sc_ops = _make_system(N, system)
+    psi0 = coherent(N, 0.5)
+    a = destroy(N)
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 0.1, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"w": 2})
+
+    options = {
+        "map": "serial",
+    }
+
+    res = ssesolve(
+        H, psi0, times, sc_ops, e_ops,
+        ntraj=ntraj, args={"w": 2}, options=options, heterodyne=heterodyne,
+        seeds=list(range(ntraj)),
+    )
+
+    for idx in range(len(e_ops)):
+        np.testing.assert_allclose(
+            res.expect[idx], res_ref.expect[idx], rtol=tol, atol=tol
+        )
+
+    assert res.measurement is None
+    assert res.wiener_process is None
+    assert res.dW is None
+
+
+@pytest.mark.parametrize("heterodyne", [True, False])
+@pytest.mark.parametrize("method", SSESolver.avail_integrators().keys())
+def test_ssesolve_method(method, heterodyne):
     "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.1
     N = 4
     ntraj = 20
+    system = "simple"
 
     H, sc_ops = _make_system(N, system)
     psi0 = coherent(N, 0.5)
     a = destroy(N)
     e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
 
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a": 2})
+    times = np.linspace(0, 0.1, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"w": 2})
 
     options = {
         "store_measurement": True,
         "map": "serial",
         "method": method,
+        "keep_runs_results": True,
     }
 
     res = ssesolve(
         H, psi0, times, sc_ops, e_ops,
-        ntraj=ntraj, args={"a": 2}, options=options, heterodyne=heterodyne,
+        ntraj=ntraj, args={"w": 2}, options=options, heterodyne=heterodyne,
+        seeds=1,
     )
 
     for idx in range(len(e_ops)):
         np.testing.assert_allclose(
-            res.expect[idx], res_ref.expect[idx], rtol=tol, atol=tol
+            res.average_expect[idx], res_ref.expect[idx], rtol=tol, atol=tol
         )
 
     assert len(res.measurement) == ntraj
 
     if heterodyne:
+        assert all([
+            dw.shape == (len(sc_ops), 2, len(times)-1)
+            for dw in res.dW
+        ])
+        assert all([
+            w.shape == (len(sc_ops), 2, len(times))
+            for w in res.wiener_process
+        ])
         assert all([
             m.shape == (len(sc_ops), 2, len(times)-1)
             for m in res.measurement
         ])
     else:
+        assert all([
+            dw.shape == (len(sc_ops), len(times)-1)
+            for dw in res.dW
+        ])
+        assert all([
+            w.shape == (len(sc_ops), len(times))
+            for w in res.wiener_process
+        ])
         assert all([
             m.shape == (len(sc_ops), len(times)-1)
             for m in res.measurement
         ])
+
+
+def test_reuse_seeds():
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.05
+    N = 4
+    ntraj = 5
+
+    H, sc_ops = _make_system(N, "simple")
+    c_ops = [destroy(N)]
+    psi0 = coherent(N, 0.5)
+    a = destroy(N)
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 0.1, 2)
+
+    options = {
+        "store_final_state": True,
+        "map": "serial",
+        "keep_runs_results": True,
+    }
+
+    res = smesolve(
+        H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, c_ops=c_ops,
+        ntraj=ntraj, args={"w": 2}, options=options,
+    )
+
+    res2 = smesolve(
+        H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, c_ops=c_ops,
+        ntraj=ntraj, args={"w": 2}, options=options,
+        seeds=res.seeds,
+    )
+
+    for out1, out2 in zip(res.final_state, res2.final_state):
+        assert out1 == out2
+
+    np.testing.assert_allclose(res.expect, res2.expect, atol=1e-14)
diff --git a/qutip/tests/solver/test_stochastic_system.py b/qutip/tests/solver/test_stochastic_system.py
index fb0923543c..4fa27a618b 100644
--- a/qutip/tests/solver/test_stochastic_system.py
+++ b/qutip/tests/solver/test_stochastic_system.py
@@ -108,7 +108,7 @@ def _check_equivalence(f, target, args):
 
 def _run_derr_check(solver, state):
     """
-
+    Compare each derrivatives to the finite differences equivalent.
     """
     t = 0
     N = solver.num_collapse

From bd3da8a2072ee3fda44a4d60eda8d946b54d13a7 Mon Sep 17 00:00:00 2001
From: L K Livingstone <livingstone.lk.337@gmail.com>
Date: Sun, 19 Mar 2023 19:33:13 +0530
Subject: [PATCH 177/602] Changed the repr string. Split many lines to fix
 pep8.

---
 qutip/core/cy/qobjevo.pyx        |  5 +++-
 qutip/tests/core/test_qobjevo.py | 44 ++++++++++++++++++++------------
 2 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index f227ddbbba..513d3ae519 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -243,7 +243,10 @@ cdef class QobjEvo:
 
     def __repr__(self):
         cls = self.__class__.__name__
-        return f'{cls}: dims={self.dims}, shape={self.shape}, type={self.type}, superrep={self.superrep}, isconstant={self.isconstant}, num_elements={self.num_elements}'
+        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
+        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
+        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
+        return repr_str
 
     def _read_element(self, op, copy, tlist, args, order, function_style, 
                       boundary_conditions):
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index 7e20d91b54..77fe8fba93 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -1,8 +1,8 @@
 import operator
 
 import pytest
-from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz, 
-                   rand_stochastic, rand_herm, rand_ket, liouvillian, 
+from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
+                   rand_stochastic, rand_herm, rand_ket, liouvillian,
                    basis, spre, spost, to_choi)
 import numpy as np
 from numpy.testing import assert_allclose
@@ -132,32 +132,44 @@ def test_call(pseudo_qevo, coeff_type):
     assert not qevo.issuper
     _assert_qobjevo_equivalent(pseudo_qevo, qevo)
 
+
 # Test the QobjEvo.__repr__()
 def test_QobjEvo_repr():
-    # "case_n" are cases with different types of Objects of QobjEvo with unique __repr__
-    # "expected_repr_n" are the Expected result from the __repr__() of the QobjEvo objects
+    # case_n: cases with Objects of QobjEvo with unique __repr__
+    # expected_repr_n: are the Expected result from the __repr__
 
-    case_1= repr(QobjEvo([qeye(3), lambda t: t]))
-    expected_repr_1= 'QobjEvo: dims=[[3], [3]], shape=(3, 3), type=oper, superrep=None, isconstant=False, num_elements=1'
+    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
+    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
+    expected_repr_1 += 'type = oper, superrep = None, '
+    expected_repr_1 += 'isconstant = False, num_elements = 1'
     assert case_1 == expected_repr_1
 
-    case_2= repr(QobjEvo(qeye(2)))
-    expected_repr_2= 'QobjEvo: dims=[[2], [2]], shape=(2, 2), type=oper, superrep=None, isconstant=True, num_elements=1'
+    case_2 = repr(QobjEvo(qeye(2)))
+    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
+    expected_repr_2 += 'type = oper, superrep = None, '
+    expected_repr_2 += 'isconstant = True, num_elements = 1'
     assert case_2 == expected_repr_2
-    
-    case_3= repr(QobjEvo(basis(5, 2)))
-    expected_repr_3= 'QobjEvo: dims=[[5], [1]], shape=(5, 1), type=ket, superrep=None, isconstant=True, num_elements=1'
+
+    case_3 = repr(QobjEvo(basis(5, 2)))
+    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
+    expected_repr_3 += 'type = ket, superrep = None, '
+    expected_repr_3 += 'isconstant = True, num_elements = 1'
     assert case_3 == expected_repr_3
 
     X = sigmax()
     S = spre(X) * spost(X.dag())
-    case_4= repr(QobjEvo(to_choi(S)))
-    expected_repr_4= 'QobjEvo: dims=[[[2], [2]], [[2], [2]]], shape=(4, 4), type=super, superrep=choi, isconstant=True, num_elements=1'
+    case_4 = repr(QobjEvo(to_choi(S)))
+    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
+    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
+    expected_repr_4 += 'isconstant = True, num_elements = 1'
     assert case_4 == expected_repr_4
 
-    case_= repr(QobjEvo([[qeye(4), lambda t: t], [qeye(4), lambda t: t]], compress=False))
-    expected_repr_= 'QobjEvo: dims=[[4], [4]], shape=(4, 4), type=oper, superrep=None, isconstant=False, num_elements=2'
-    assert case_ == expected_repr_
+    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
+                           [qeye(4), lambda t: t]], compress=False))
+    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
+    expected_repr_5 += 'type = oper, superrep = None, '
+    expected_repr_5 += 'isconstant = False, num_elements = 2'
+    assert case_5 == expected_repr_5
 
 
 @pytest.mark.parametrize('coeff_type',

From 823f1d5c6e481000ee25e552c77ea9f531b6d00b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 20 Mar 2023 10:24:00 -0400
Subject: [PATCH 178/602] remove unused variables

---
 qutip/core/data/trace.pyx | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 565b9b2c26..c256f537cc 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -50,24 +50,24 @@ cpdef double complex trace_dense(Dense matrix) nogil except *:
 
 
 cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
-    cdef int N = <int>sqrt(matrix.shape[0])
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
     _check_shape_oper_ket(N, matrix)
-    cdef size_t row, ptr
+    cdef size_t row
     cdef double complex trace = 0
+    cdef size_t stride = N + 1
     for row in range(N):
-        if matrix.row_index[row * (N+1)] != matrix.row_index[row * (N+1) + 1]:
-            trace += matrix.data[matrix.row_index[row * (N+1)]]
+        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
+            trace += matrix.data[matrix.row_index[row * stride]]
     return trace
 
 cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
-    cdef int N = <int>sqrt(matrix.shape[0])
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
     _check_shape_oper_ket(N, matrix)
     cdef double complex trace = 0
     cdef size_t ptr = 0
     cdef size_t stride = N + 1
-    for _ in range(N):
-        trace += matrix.data[ptr]
-        ptr += stride
+    for ptr in range(N):
+        trace += matrix.data[ptr * stride]
     return trace
 
 

From c767ab321e7c4a5ee427aad53b8065c34bdf6b0d Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 20 Mar 2023 17:29:28 +0100
Subject: [PATCH 179/602] Add CSR constructor for building a matrix from CSR
 sub-blocks.

---
 qutip/core/data/csr.pxd |  2 +
 qutip/core/data/csr.pyx | 87 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 89 insertions(+)

diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
index 44a76256c8..ba65141ca2 100644
--- a/qutip/core/data/csr.pxd
+++ b/qutip/core/data/csr.pxd
@@ -161,3 +161,5 @@ cpdef CSR from_dense(Dense matrix)
 cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
                            base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
                            double tol=*)
+cpdef CSR from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+                          base.idxint n_blocks, base.idxint block_size)
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 18989ff235..a5a32ddc96 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -847,3 +847,90 @@ def diags(diagonals, offsets=None, shape=None):
     return diags_(
         diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
     )
+
+
+cpdef CSR from_csr_blocks(
+    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+    base.idxint n_blocks, base.idxint block_size
+):
+    """
+    Construct a CSR from non-overlapping blocks.
+
+    Each operator in ``block_ops`` should be a square CSR operator with
+    shape ``(block_size, block_size)``. The output operator consists of
+    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
+    ``(n_blocks * block_size, n_blocks * block_size)``.
+
+    None of the operators should overlap (i.e. the list of block row and
+    column pairs should be unique).
+
+    Parameters
+    ----------
+    block_rows : sequence of base.idxint integers
+        The block row for each operator. The block row should be in
+        ``range(0, n_blocks)``.
+
+    block_cols : sequence of base.idxint integers
+        The block column for each operator. The block column should be in
+        ``range(0, n_blocks)``.
+
+    block_ops : sequence of CSR matrixes
+        The operators corresponding to the rows and columns in ``block_rows``
+        and ``block_cols``.
+
+    n_blocks : base.idxint
+        Number of blocks. The shape of the final matrix is
+        (N * block, N * block).
+
+    block_size : base.idxint
+        Size of each block. The shape of matrices in ``block_ops`` is
+        ``(block_size, block_size)``.
+    """
+    cdef CSR op
+    cdef base.idxint shape = n_blocks * block_size
+    cdef base.idxint nnz_ = 0
+
+    for op in block_ops:
+        nnz_ += nnz(op)
+
+    cdef CSR out = empty(shape, shape, nnz_)
+    if nnz_ == 0:
+        return out
+
+    cdef base.idxint op_len = len(block_ops)
+    cdef base.idxint op_idx = 0
+    cdef base.idxint prev_op_idx = 0
+
+    cdef base.idxint end = 0
+
+    cdef base.idxint rowpos, colpos
+    cdef base.idxint row_idx, col_idx
+    cdef base.idxint op_i, op_row, op_row_start, op_row_end, op_row_len
+
+    out.row_index[0] = 0
+
+    for row_idx in range(n_blocks):
+        prev_op_idx = op_idx
+        while op_idx < op_len:
+            #if block_rows[op_idx] < row_idx:
+            #    raise ValueError("Block row indexes (block_rows) are not sorted.")
+            if block_rows[op_idx] != row_idx:
+                break
+            op_idx += 1
+
+        rowpos = row_idx * block_size
+        for op_row in range(block_size):
+            for op_i in range(prev_op_idx, op_idx):
+                col_idx = block_cols[op_i]
+                op = block_ops[op_i]
+                colpos = col_idx * block_size
+                op_row_start = op.row_index[op_row]
+                op_row_end = op.row_index[op_row + 1]
+                op_row_len = op_row_end - op_row_start
+                for i in range(op_row_len):
+                    out.col_index[end + i] = op.col_index[op_row_start + i] + colpos
+                    out.data[end + i] = op.data[op_row_start + i]
+                end += op_row_len
+            out.row_index[rowpos + op_row + 1] = end
+
+    return out

From e8b2de8a4a509dcc13fc277799a59ef335ebfe3a Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 20 Mar 2023 17:30:39 +0100
Subject: [PATCH 180/602] Use from_csr_blocks to build CSR RHS for the HEOM.

---
 qutip/solver/heom/bofin_solvers.py | 94 +++++++++++-------------------
 1 file changed, 35 insertions(+), 59 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 1af2c5eac9..502bc94b10 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -617,7 +617,7 @@ def __init__(self, H, bath, max_depth, *, options=None):
         self._sId = _data.identity(self._sup_shape, dtype="csr")
 
         # pre-calculate superoperators required by _grad_prev and _grad_next:
-        Qs = [exp.Q for exp in self.ados.exponents]
+        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
         self._spreQ = [spre(op).data for op in Qs]
         self._spostQ = [spost(op).data for op in Qs]
         self._s_pre_minus_post_Q = [
@@ -689,14 +689,11 @@ def _combine_bath_exponents(self, bath):
             )
         return exponents
 
-    def _grad_n(self, L, he_n):
+    def _grad_n(self, he_n):
         """ Get the gradient for the hierarchy ADO at level n. """
         vk = self.ados.vk
         vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
-        if L is not None:  # time-independent case
-            op = _data.sub(L, _data.mul(self._sId, vk_sum))
-        else:  # time-dependent case
-            op = _data.mul(self._sId, -vk_sum)
+        op = _data.mul(self._sId, -vk_sum)
         return op
 
     def _grad_prev(self, he_n, k):
@@ -811,15 +808,19 @@ def _grad_next_fermionic(self, he_n, k):
             )
         return op
 
-    def _rhs(self, L):
+    def _rhs(self):
         """ Make the RHS for the HEOM. """
+        # XXX: TODO -- make this an explicit function
+        f_idx = self.ados._label_idx.__getitem__
         ops = _GatherHEOMRHS(
-            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
+            f_idx, block=self._sup_shape, nhe=self._n_ados
         )
 
         for he_n in self.ados.labels:
-            op = self._grad_n(L, he_n)
+            op = self._grad_n(he_n)
             ops.add_op(he_n, he_n, op)
+            if isinstance(op, _data.Dense):
+                breakpoint()
             for k in range(len(self.ados.dims)):
                 next_he = self.ados.next(he_n, k)
                 if next_he is not None:
@@ -834,9 +835,12 @@ def _rhs(self, L):
 
     def _calculate_rhs(self):
         """ Make the full RHS required by the solver. """
+        h_identity = _data.identity(self._n_ados, dtype="csr")
+
         if self.L_sys.isconstant:
-            L0 = self.L_sys(0)
-            rhs_mat = self._rhs(L0.data)
+            rhs_mat = self._rhs()
+            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
+
             rhs = QobjEvo(Qobj(rhs_mat, dims=[
                 self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
             ]))
@@ -853,7 +857,7 @@ def _calculate_rhs(self):
             #
             # By calling _rhs(None) we omit the Liouvillian completely from
             # the RHS and then manually add back the Liouvillian afterwards.
-            rhs_mat = self._rhs(None)
+            rhs_mat = self._rhs()
             rhs = QobjEvo(Qobj(rhs_mat))
             h_identity = _data.identity(self._n_ados, dtype="csr")
 
@@ -1265,15 +1269,15 @@ class _GatherHEOMRHS:
             The number of ADOs in the hierarchy.
     """
     def __init__(self, f_idx, block, nhe):
-        self._block = block
-        self._nhe = nhe
+        self._block_size = block
+        self._n_blocks = nhe
         self._f_idx = f_idx
         self._ops = []
 
     def add_op(self, row_he, col_he, op):
         """ Add an block operator to the list. """
         self._ops.append(
-            (self._f_idx(row_he), self._f_idx(col_he), _data.to["csr"](op))
+            (self._f_idx(row_he), self._f_idx(col_he), op)
         )
 
     def gather(self):
@@ -1294,48 +1298,20 @@ def gather(self):
             rhs : :obj:`Data`
                 A combined matrix of shape ``(block * nhe, block * ne)``.
         """
-        block = self._block
-        nhe = self._nhe
-        ops = self._ops
-        shape = (block * nhe, block * nhe)
-        if not ops:
-            return _data.zeros(*shape, dtype="csr")
-        ops.sort()
-        nnz = sum(_csr.nnz(op) for _, _, op in ops)
-        indptr = np.zeros(shape[0] + 1, dtype=np.int32)
-        indices = np.zeros(nnz, dtype=np.int32)
-        data = np.zeros(nnz, dtype=np.complex128)
-        end = 0
-        op_idx = 0
-        op_len = len(ops)
-
-        for row_idx in range(nhe):
-            prev_op_idx = op_idx
-            while op_idx < op_len:
-                if ops[op_idx][0] != row_idx:
-                    break
-                op_idx += 1
-
-            row_ops = ops[prev_op_idx: op_idx]
-            rowpos = row_idx * block
-            for op_row in range(block):
-                for _, col_idx, op in row_ops:
-                    op = op.as_scipy()  # convert CSR to SciPy csr_matrix
-                    colpos = col_idx * block
-                    op_row_start = op.indptr[op_row]
-                    op_row_end = op.indptr[op_row + 1]
-                    op_row_len = op_row_end - op_row_start
-                    if op_row_len == 0:
-                        continue
-                    indices[end: end + op_row_len] = (
-                        op.indices[op_row_start: op_row_end] + colpos
-                    )
-                    data[end: end + op_row_len] = (
-                        op.data[op_row_start: op_row_end]
-                    )
-                    end += op_row_len
-                indptr[rowpos + op_row + 1] = end
-
-        return _csr.CSR(
-            (data, indices, indptr), shape=shape, copy=False,
+        self._ops.sort()
+        block_rows = np.array(
+            [op[0] for op in self._ops],
+            dtype=_data.base.idxint_dtype,
+        )
+        block_cols = np.array(
+            [op[1] for op in self._ops],
+            dtype=_data.base.idxint_dtype,
+        )
+        block_ops = np.array(
+            [op[2] for op in self._ops],
+            dtype=object,
+        )
+        return _csr.from_csr_blocks(
+            block_rows, block_cols, block_ops,
+            self._n_blocks, self._block_size,
         )

From fe9b97379d8d105444fb82bb9bed38b918b5b713 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 20 Mar 2023 17:07:44 -0400
Subject: [PATCH 181/602] Finish documentation

---
 doc/apidoc/classes.rst                       |  33 ++
 doc/guide/dynamics/dynamics-photocurrent.rst | 104 ----
 doc/guide/dynamics/dynamics-stochastic.rst   |  72 +--
 doc/guide/guide-dynamics.rst                 |   1 -
 qutip/__init__.py                            |   1 -
 qutip/solve/pdpsolve.py                      | 575 -------------------
 qutip/solve/stochastic.py                    |  92 ---
 qutip/solver/__init__.py                     |   1 +
 qutip/solver/sode/itotaylor.py               |   5 +-
 qutip/solver/stochastic.py                   | 131 ++---
 qutip/tests/solve/test_stochastic_me.py      | 309 ----------
 qutip/tests/solve/test_stochastic_se.py      | 230 --------
 qutip/tests/solver/test_stochastic.py        |  41 +-
 13 files changed, 175 insertions(+), 1420 deletions(-)
 delete mode 100644 doc/guide/dynamics/dynamics-photocurrent.rst
 delete mode 100644 qutip/solve/pdpsolve.py
 delete mode 100644 qutip/tests/solve/test_stochastic_me.py
 delete mode 100644 qutip/tests/solve/test_stochastic_se.py

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index aea4e75e18..42cd593dc3 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -132,6 +132,39 @@ Integrator
     :members: options
 
 
+.. _classes-sode:
+
+Integrator
+----------
+
+.. autoclass:: qutip.solver.sode.rouchon.RouchonSODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.itotaylor.EulerSODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.itotaylor.Milstein_SODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.itotaylor.Taylor1_5_SODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.itotaylor.Implicit_Milstein_SODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.itotaylor.Implicit_Taylor1_5_SODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.sode.PlatenSODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.itotaylor.Explicit1_5_SODE
+    :members: options
+
+.. autoclass:: qutip.solver.sode.sode.PredCorr_SODE
+    :members: options
+
+
 .. _classes-non_markov_mc_and_tt:
 
 Non-Markovian Memory Cascade and Transfer Tensor Solvers
diff --git a/doc/guide/dynamics/dynamics-photocurrent.rst b/doc/guide/dynamics/dynamics-photocurrent.rst
deleted file mode 100644
index 5b69a338d4..0000000000
--- a/doc/guide/dynamics/dynamics-photocurrent.rst
+++ /dev/null
@@ -1,104 +0,0 @@
-.. _stochastic_photo:
-
-********************************
-Stochastic Solver - Photocurrent
-********************************
-
-.. _photocurrent-intro:
-
-Photocurrent method, like monte-carlo method, allows for simulating an
-individual realization of the system evolution under continuous measurement.
-
-Closed system
--------------
-
-.. photocurent_Schrodinger_equation
-
-Photocurrent evolution have the state evolve deterministically between quantum jumps.
-During the deterministic part, the system evolve by schrodinger equation with a
-non-hermitian, norm conserving effective Hamiltonian.
-
-.. math::
-	:label: pssesolve_heff
-
-	H_{\rm eff}=H_{\rm sys}+
-	\frac{i\hbar}{2}\left( -\sum_{n}C^{+}_{n}C_{n}+ |C_{n} \psi |^2\right).
-
-With :math:`C_{n}`, the collapse operators.
-This effective Hamiltonian is equivalent to the monte-carlo effective
-Hamiltonian with an extra term to keep the state normalized.
-At each time step of :math:`\delta t`, the wave function has a probability
-
-.. math::
-	:label: pssesolve_jump_prob
-
-	\delta p_{n} = \left<\psi(t)|C_{n}^{+}C_{n}|\psi(t)\right>  \delta t
-
-of making a quantum jump. :math:`\delta t` must be chosen small enough to keep
-that probability small :math:`\delta p << 1`. *If multiple jumps happen at the
-same time step, the state become unphysical.*
-Each jump result in a sharp variation of the state by,
-
-.. math::
-	:label: pssesolve_jump
-
-	\delta \psi = \left( \frac{C_n \psi} {\left| C_n \psi  \right|} - \psi \right)
-
-The basic photocurrent method directly integrates these equations to the first-order.
-Starting from a state :math:`\left|\psi(0)\right>`, it evolves the state according to
-
-.. math::
-	:label: pssesolve_sde
-
-	\delta \psi(t) = - i H_{\rm sys} \psi(t) \delta t + \sum_n \left(
-					 -\frac{C_n^{+} C_n}{2}  \psi(t) \delta t
-					 + \frac{ \left| C_n \psi  \right| ^2}{2} \delta t
-	                 +  \delta N_n \left( \frac{C_n \psi}
-					 {\left| C_n \psi  \right|} - \psi \right)\right),
-
-for each time-step.
-Here :math:`\delta N = 1` with a probability of :math:`\delta \omega` and
-:math:`\delta N_n = 0` with a probability of :math:`1-\delta \omega`.
-
-Trajectories obtained with this algorithm are equivalent to those obtained with
-monte-carlo evolution (up to :math:`O(\delta t^2)`).
-In most cases, :func:`qutip.mcsolve` is more efficient than
-:func:`qutip.stochastic.photocurrent_sesolve`.
-
-Open system
------------
-.. photocurent_Master_equation
-
-Photocurrent approach allows to obtain trajectories for a system with
-both measured and dissipative interaction with the bath.
-The system evolves according to the master equation between jumps with a modified
-liouvillian
-
-.. math::
-	:label: master_equation
-
-	L_{\rm eff}(\rho(t)) = L_{\rm sys}(\rho(t)) +
-	                      \sum_{n}\left(
-						  \rm{tr} \left(C_{n}^{+}C_{n}  \rho C_{n}^{+}C_{n} \right)
-						  - C_{n}^{+}C_{n}  \rho C_{n}^{+}C_{n} \right),
-
-with the probability of jumps in a time step :math:`\delta t` given by
-
-.. math::
-	:label: psmesolve_rate
-
-	\delta p = \rm{tr} \left( C \rho C^{+} \right) \delta t.
-
-After a jump, the density matrix become
-
-.. math::
-
-	\rho' = \frac{C \rho C^{+}}{\rm{tr} \left( C \rho C^{+} \right)}.
-
-The evolution of the system at each time step if thus given by
-
-.. math::
-	:label: psmesolve_sde
-
-	\rho(t + \delta t) = \rho(t) + L_{\rm eff}(\rho) \delta t + \delta N
-	\left(\frac{C \rho C^{+}}{\rm{tr} \left( C \rho C^{+} \right)} - \rho \right).
diff --git a/doc/guide/dynamics/dynamics-stochastic.rst b/doc/guide/dynamics/dynamics-stochastic.rst
index 10ea5aad56..fa555df13c 100644
--- a/doc/guide/dynamics/dynamics-stochastic.rst
+++ b/doc/guide/dynamics/dynamics-stochastic.rst
@@ -6,7 +6,8 @@ Stochastic Solver
 
 .. _stochastic-intro:
 
-When a quantum system is subjected to continuous measurement, through homodyne detection for example, it is possible to simulate the conditional quantum state using stochastic Schrodinger and master equations. The solution of these stochastic equations are quantum trajectories, which represent the conditioned evolution of the system given a specific measurement record.
+When a quantum system is subjected to continuous measurement, through homodyne detection for example, it is possible to simulate the conditional quantum state using stochastic Schrodinger and master equations.
+The solution of these stochastic equations are quantum trajectories, which represent the conditioned evolution of the system given a specific measurement record.
 
 In general, the stochastic evolution of a quantum state is calculated in
 QuTiP by solving the general equation
@@ -16,7 +17,7 @@ QuTiP by solving the general equation
 
     d \rho (t) = d_1 \rho dt + \sum_n d_{2,n} \rho dW_n,
 
-where :math:`dW_n` is a Wiener increment, which has the expectation values :math:`E[dW] = 0` and :math:`E[dW^2] = dt`. Stochastic evolution is implemented with the :func:`qutip.stochastic.general_stochastic` function.
+where :math:`dW_n` is a Wiener increment, which has the expectation values :math:`E[dW] = 0` and :math:`E[dW^2] = dt`.
 
 Stochastic Schrodinger Equation
 ===============================
@@ -29,9 +30,9 @@ The stochastic Schrodinger equation is given by (see section 4.4, [Wis09]_)
     :label: jump_ssesolve
 
     d \psi(t) = - i H \psi(t) dt
-                     - \sum_n \left( \frac{S_n^\dagger S_n}{2} -\frac{e_n}{2} S_n
-                     + \frac{e_n^2}{8} \right) \psi(t) dt
-                     + \sum_n \left( S_n - \frac{e_n}{2} \right) \psi(t) dW_n,
+                - \sum_n \left( \frac{S_n^\dagger S_n}{2} -\frac{e_n}{2} S_n
+                + \frac{e_n^2}{8} \right) \psi(t) dt
+                + \sum_n \left( S_n - \frac{e_n}{2} \right) \psi(t) dW_n,
 
 where :math:`H` is the Hamiltonian, :math:`S_n` are the stochastic collapse operators, and :math:`e_n` is
 
@@ -40,12 +41,12 @@ where :math:`H` is the Hamiltonian, :math:`S_n` are the stochastic collapse oper
 
    e_n = \left<\psi(t)|S_n + S_n^\dagger|\psi(t)\right>
 
-In QuTiP, this equation can be solved using the function :func:`qutip.stochastic.ssesolve`, which is implemented by defining :math:`d_1` and :math:`d_{2,n}` from Equation :eq:`general_form` as
+In QuTiP, this equation can be solved using the function :func:`qutip.solver.stochastic.ssesolve`, which is implemented by defining :math:`d_1` and :math:`d_{2,n}` from Equation :eq:`general_form` as
 
 .. math::
     :label: d1_def
 
-    d_1 = -iH -  \frac{1}{2} \sum_n \left(S_n^\dagger S_n - e_n S_n + \frac{e_i^2}{4}  \right),
+    d_1 = -iH - \frac{1}{2} \sum_n \left(S_n^\dagger S_n - e_n S_n + \frac{e_i^2}{4} \right),
 
 and
 
@@ -54,9 +55,11 @@ and
 
     d_{2, n} = S_n - \frac{e_n}{2}.
 
-The solver :func:`qutip.stochastic.ssesolve` will construct the operators :math:`d_1` and :math:`d_{2,n}` once the user passes the Hamiltonian (``H``) and the stochastic operator list (``sc_ops``). As with the :func:`qutip.mcsolve`, the number of trajectories and the seed for the noise realisation can be fixed using the arguments: ``ntraj`` and ``noise``, respectively. If the user also requires the measurement output, the argument ``store_measurement=True`` should be included.
+The solver :func:`qutip.solver.stochastic.ssesolve` will construct the operators :math:`d_1` and :math:`d_{2,n}` once the user passes the Hamiltonian (``H``) and the stochastic operator list (``sc_ops``).
+As with the :func:`qutip.solver.mcsolve.mcsolve`, the number of trajectories and the seed for the noise realisation can be fixed using the arguments: ``ntraj`` and ``seeds``, respectively.
+If the user also requires the measurement output, the options entry ``{"store_measurement": True}`` should be included.
 
-Additionally, homodyne and heterodyne detections can be easily simulated by passing the arguments ``method='homodyne'`` or ``method='heterodyne'`` to :func:`qutip.stochastic.ssesolve`.
+Per default, homodyne is used. Heterodyne detections can be easily simulated by passing the arguments ``'heterodyne=True'`` to :func:`qutip.solver.stochastic.ssesolve`.
 
 Examples of how to solve the stochastic Schrodinger equation using QuTiP can be found in this `development notebook <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/development/development-ssesolve-tests.ipynb>`_.
 
@@ -65,7 +68,8 @@ Stochastic Master Equation
 
 .. Stochastic Master equation
 
-When the initial state of the system is a density matrix :math:`\rho`, the stochastic master equation solver :func:`qutip.stochastic.smesolve` must be used. The stochastic master equation is given by (see section 4.4, [Wis09]_)
+When the initial state of the system is a density matrix :math:`\rho`, the stochastic master equation solver :func:`qutip.stochastic.smesolve` must be used.
+The stochastic master equation is given by (see section 4.4, [Wis09]_)
 
 .. math::
    :label: stochastic_master
@@ -88,7 +92,9 @@ and
     \mathcal{H}[A]\rho = A\rho(t) + \rho(t) A^\dagger - \tr[A\rho(t) + \rho(t) A^\dagger].
 
 
-In QuTiP, solutions for the stochastic master equation are obtained using the solver :func:`qutip.stochastic.smesolve`. The implementation takes into account 2 types of collapse operators. :math:`C_i` (``c_ops``) represent the dissipation in the environment, while :math:`S_n` (``sc_ops``) are monitored operators. The deterministic part of the evolution, described by the :math:`d_1` in Equation :eq:`general_form`, takes into account all operators :math:`C_i` and :math:`S_n`:
+In QuTiP, solutions for the stochastic master equation are obtained using the solver :func:`qutip.solver.stochastic.smesolve`.
+The implementation takes into account 2 types of collapse operators. :math:`C_i` (``c_ops``) represent the dissipation in the environment, while :math:`S_n` (``sc_ops``) are monitored operators.
+The deterministic part of the evolution, described by the :math:`d_1` in Equation :eq:`general_form`, takes into account all operators :math:`C_i` and :math:`S_n`:
 
 .. math::
     :label: liouvillian
@@ -98,7 +104,6 @@ In QuTiP, solutions for the stochastic master equation are obtained using the so
                  + \sum_n D[S_n]\rho,
 
 
-
 The stochastic part, :math:`d_{2,n}`, is given solely by the operators :math:`S_n`
 
 .. math::
@@ -107,12 +112,14 @@ The stochastic part, :math:`d_{2,n}`, is given solely by the operators :math:`S_
     d_{2,n} = S_n \rho(t) + \rho(t) S_n^\dagger - \tr \left(S_n \rho (t)
                      + \rho(t) S_n^\dagger \right)\rho(t).
 
-As in the stochastic Schrodinger equation, the detection method can be specified using the ``method`` argument.
+As in the stochastic Schrodinger equation, heterodyne detection can be chosen by passing ``heterodyne=True``.
 
 Example
 -------
 
-Below, we solve the dynamics for an optical cavity at 0K whose output is monitored using homodyne detection. The cavity decay rate is given by :math:`\kappa` and the :math:`\Delta` is the cavity detuning with respect to the driving field. The measurement operators can be passed using the option ``m_ops``. The homodyne current :math:`J_x` is calculated using
+Below, we solve the dynamics for an optical cavity at 0K whose output is monitored using homodyne detection.
+The cavity decay rate is given by :math:`\kappa` and the :math:`\Delta` is the cavity detuning with respect to the driving field.
+The measurement operators can be passed using the option ``m_ops``. The homodyne current :math:`J_x` is calculated using
 
 .. math::
     :label: measurement_result
@@ -126,32 +133,31 @@ where :math:`x` is the operator passed using ``m_ops``. The results are availabl
 
     import numpy as np
     import matplotlib.pyplot as plt
-    import qutip as qt
+    import qutip
 
     # parameters
-    DIM = 20             # Hilbert space dimension
-    DELTA = 5*2*np.pi    # cavity detuning
-    KAPPA = 2            # cavity decay rate
-    INTENSITY = 4        # intensity of initial state
+    DIM = 20               # Hilbert space dimension
+    DELTA = 5 * 2 * np.pi  # cavity detuning
+    KAPPA = 2              # cavity decay rate
+    INTENSITY = 4          # intensity of initial state
     NUMBER_OF_TRAJECTORIES = 500
 
     # operators
-    a = qt.destroy(DIM)
+    a = qutip.destroy(DIM)
     x = a + a.dag()
-    H = DELTA*a.dag()* a
+    H = DELTA * a.dag()* a
 
-    rho_0 = qt.coherent(DIM, np.sqrt(INTENSITY))
+    rho_0 = qutip.coherent(DIM, np.sqrt(INTENSITY))
     times = np.arange(0, 1, 0.0025)
 
-    stoc_solution = qt.smesolve(H, rho_0, times,
-                                c_ops=[],
-                                sc_ops=[np.sqrt(KAPPA) * a],
-                                e_ops=[x],
-                                ntraj=NUMBER_OF_TRAJECTORIES,
-                                nsubsteps=2,
-                                store_measurement=True,
-                                dW_factors=[1],
-                                method='homodyne')
+    stoc_solution = qutip.smesolve(
+        H, rho_0, times,
+        c_ops=[],
+        sc_ops=[np.sqrt(KAPPA) * a],
+        e_ops=[x],
+        ntraj=NUMBER_OF_TRAJECTORIES,
+        options={"dt": 0.00125, "store_measurement":True,}
+    )
 
     fig, ax = plt.subplots()
     ax.set_title('Stochastic Master Equation - Homodyne Detection')
@@ -163,9 +169,9 @@ where :math:`x` is the operator passed using ``m_ops``. The results are availabl
     ax.legend()
 
 
-For other examples on :func:`qutip.stochastic.smesolve`, see the `following notebook <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/development/development-smesolve-tests.ipynb>`_, as well as these notebooks available at `QuTiP Tutorials page <https://qutip.org/tutorials.html>`_: `heterodyne detection <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/examples/smesolve-heterodyne.ipynb>`_, `inneficient detection <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/examples/smesolve-inefficient-detection.ipynb>`_, and `feedback control <https://nbviewer.ipython.org/github/jrjohansson/reproduced-papers/blob/master/Reproduce-SIAM-JCO-46-445-2007-Mirrahimi.ipynb>`_.
+For other examples on :func:`qutip.solver.stochastic.smesolve`, see the `following notebook <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/development/development-smesolve-tests.ipynb>`_, as well as these notebooks available at `QuTiP Tutorials page <https://qutip.org/tutorials.html>`_: `heterodyne detection <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/examples/smesolve-heterodyne.ipynb>`_, `inefficient detection <https://nbviewer.ipython.org/github/qutip/qutip-notebooks/blob/master/examples/smesolve-inefficient-detection.ipynb>`_, and `feedback control <https://nbviewer.ipython.org/github/jrjohansson/reproduced-papers/blob/master/Reproduce-SIAM-JCO-46-445-2007-Mirrahimi.ipynb>`_.
 
 .. plot::
     :context: reset
     :include-source: false
-    :nofigs:
\ No newline at end of file
+    :nofigs:
diff --git a/doc/guide/guide-dynamics.rst b/doc/guide/guide-dynamics.rst
index 5f214bb8b3..8f6d85538c 100644
--- a/doc/guide/guide-dynamics.rst
+++ b/doc/guide/guide-dynamics.rst
@@ -12,7 +12,6 @@ Time Evolution and Quantum System Dynamics
    dynamics/dynamics-master.rst
    dynamics/dynamics-monte.rst
    dynamics/dynamics-krylov.rst
-   dynamics/dynamics-photocurrent.rst
    dynamics/dynamics-stochastic.rst
    dynamics/dynamics-time.rst
    dynamics/dynamics-bloch-redfield.rst
diff --git a/qutip/__init__.py b/qutip/__init__.py
index fc7f65b409..29841a5714 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -35,7 +35,6 @@
 from .solver import *
 from .solve import nonmarkov
 import qutip.solve.piqs as piqs
-from .solve.stochastic import *
 
 # graphics
 from .bloch import *
diff --git a/qutip/solve/pdpsolve.py b/qutip/solve/pdpsolve.py
deleted file mode 100644
index 1a1d2964d2..0000000000
--- a/qutip/solve/pdpsolve.py
+++ /dev/null
@@ -1,575 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from numpy.random import RandomState
-
-from .. import (
-    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
-)
-from ..core import data as _data
-from .solver import Result, SolverOptions
-from .parallel import serial_map
-from ..ui.progressbar import TextProgressBar
-from ..settings import settings
-debug = settings.debug
-
-
-class StochasticSolverOptions:
-    """
-    Class of options for stochastic (piecewse deterministic process) PDP
-    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
-    :func:`qutip.pdpsolve.smepdpsolve`.
-    Options can be specified either as arguments to the constructor::
-
-        sso = StochasticSolverOptions(nsubsteps=100, ...)
-
-    or by changing the class attributes after creation::
-
-        sso = StochasticSolverOptions()
-        sso.nsubsteps = 1000
-
-    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
-    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
-    the constructor of these class, and internally they use these arguments to
-    construct an instance of this class, so it is rarely needed to explicitly
-    create an instance of this class.
-
-    Attributes
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        List of deterministic collapse operators.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    m_ops : list of :class:`qutip.Qobj`
-        List of operators representing the measurement operators. The expected
-        format is a nested list with one measurement operator for each
-        stochastic increament, for each stochastic collapse operator.
-
-    args : dict / list
-        List of dictionary of additional problem-specific parameters.
-        Implicit methods can adjust tolerance via args = {'tol':value}
-
-    ntraj : int
-        Number of trajectors.
-
-    nsubsteps : int
-        Number of sub steps between each time-spep given in `times`.
-
-    d1 : function
-        Function for calculating the operator-valued coefficient to the
-        deterministic increment dt.
-
-    d2 : function
-        Function for calculating the operator-valued coefficient to the
-        stochastic increment(s) dW_n, where n is in [0, d2_len[.
-
-    d2_len : int (default 1)
-        The number of stochastic increments in the process.
-
-    dW_factors : array
-        Array of length d2_len, containing scaling factors for each
-        measurement operator in m_ops.
-
-    rhs : function
-        Function for calculating the deterministic and stochastic contributions
-        to the right-hand side of the stochastic differential equation. This
-        only needs to be specified when implementing a custom SDE solver.
-
-    generate_A_ops : function
-        Function that generates a list of pre-computed operators or super-
-        operators. These precomputed operators are used in some d1 and d2
-        functions.
-
-    generate_noise : function
-        Function for generate an array of pre-computed noise signal.
-
-    homogeneous : bool (True)
-        Wheter or not the stochastic process is homogenous. Inhomogenous
-        processes are only supported for poisson distributions.
-
-    solver : string
-        Name of the solver method to use for solving the stochastic
-        equations. Valid values are:
-        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
-        'pc-euler' is a predictor-corrector method which is more
-        stable than explicit methods,
-        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
-        'milstein-imp' is semi-implicit Milstein method,
-        3/2 order algorithms: 'taylor15',
-        'taylor15-imp' is semi-implicit Taylor 1.5 method.
-        Implicit methods can adjust tolerance via args = {'tol':value},
-        default is {'tol':1e-6}
-
-    method : string ('homodyne', 'heterodyne', 'photocurrent')
-        The name of the type of measurement process that give rise to the
-        stochastic equation to solve. Specifying a method with this keyword
-        argument is a short-hand notation for using pre-defined d1 and d2
-        functions for the corresponding stochastic processes.
-
-    distribution : string ('normal', 'poisson')
-        The name of the distribution used for the stochastic increments.
-
-    store_measurements : bool (default False)
-        Whether or not to store the measurement results in the
-        :class:`qutip.solver.Result` instance returned by the solver.
-
-    noise : array
-        Vector specifying the noise.
-
-    normalize : bool (default True)
-        Whether or not to normalize the wave function during the evolution.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options.
-
-    map_func: function
-        A map function or managing the calls to single-trajactory solvers.
-
-    map_kwargs: dictionary
-        Optional keyword arguments to the map_func function function.
-
-    progress_bar : :class:`qutip.ui.BaseProgressBar`
-        Optional progress bar class instance.
-    """
-    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
-                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
-                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
-                 generate_A_ops=None, generate_noise=None, homogeneous=True,
-                 solver=None, method=None, distribution='normal',
-                 store_measurement=False, noise=None, normalize=True,
-                 options=None, progress_bar=None, map_func=None,
-                 map_kwargs=None):
-
-        if options is None:
-            options = SolverOptions()
-
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
-        self.H = H
-        self.d1 = d1
-        self.d2 = d2
-        self.d2_len = d2_len
-        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
-        self.state0 = state0
-        self.times = times
-        self.c_ops = c_ops
-        self.sc_ops = sc_ops
-        self.e_ops = e_ops
-        self.m_ops = m_ops
-
-        self.ntraj = ntraj
-        self.nsubsteps = nsubsteps
-        self.solver = solver
-        self.method = method
-        self.distribution = distribution
-        self.homogeneous = homogeneous
-        self.rhs = rhs
-        self.options = options
-        self.progress_bar = progress_bar
-        self.store_measurement = store_measurement
-        self.store_states = options['store_states']
-        self.noise = noise
-        self.args = args
-        self.normalize = normalize
-
-        self.generate_noise = generate_noise
-        self.generate_A_ops = generate_A_ops
-
-        if self.ntraj > 1 and map_func:
-            self.map_func = map_func
-        else:
-            self.map_func = serial_map
-
-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-
-        # Does any operator depend on time?
-        self.td = False
-        if not isinstance(H, Qobj):
-            self.td = True
-        for ops in c_ops:
-            if not isinstance(ops, Qobj):
-                self.td = True
-        for ops in sc_ops:
-            if not isinstance(ops, Qobj):
-                self.td = True
-
-
-def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-    trajectory simulations.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
-                                  e_ops=e_ops, **kwargs)
-
-    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for density matrix
-    evolution.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
-                                  e_ops=e_ops, **kwargs)
-
-    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-# -----------------------------------------------------------------------------
-# Generic parameterized stochastic SE PDP solver
-#
-def _ssepdpsolve_generic(sso, options, progress_bar):
-    """
-    For internal use. See ssepdpsolve.
-    """
-    N_store = len(sso.times)
-    N_substeps = sso.nsubsteps
-    dt = (sso.times[1] - sso.times[0]) / N_substeps
-    nt = sso.ntraj
-
-    data = Result()
-    data.solver = "sepdpsolve"
-    data.times = sso.tlist
-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.jump_times = []
-    data.jump_op_idx = []
-
-    # effective hamiltonian for deterministic part
-    Heff = sso.H
-    for c in sso.c_ops:
-        Heff += -0.5j * c.dag() * c
-
-    progress_bar.start(sso.ntraj)
-    for n in range(sso.ntraj):
-        progress_bar.update(n)
-        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
-
-        states_list, jump_times, jump_op_idx = \
-            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
-                                           N_store, N_substeps,
-                                           psi_t, sso.state0.dims,
-                                           sso.c_ops, sso.e_ops)
-
-        data.states.append(states_list)
-        data.jump_times.append(jump_times)
-        data.jump_op_idx.append(jump_op_idx)
-
-    progress_bar.finished()
-
-    # average density matrices
-    if options['average_states'] and np.any(data.states):
-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-                       for n in range(len(data.times))]
-
-    # average
-    data.expect = data.expect / nt
-
-    # standard error
-    if nt > 1:
-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-    else:
-        data.se = None
-
-    # convert complex data to real if hermitian
-    data.expect = [np.real(data.expect[n, :])
-                   if e.isherm else data.expect[n, :]
-                   for n, e in enumerate(sso.e_ops)]
-
-    return data
-
-
-def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
-    """
-    Internal function. See ssepdpsolve.
-    """
-    states_list = []
-
-    phi_t = psi_t.copy()
-
-    prng = RandomState()  # todo: seed it
-    r_jump, r_op = prng.rand(2)
-
-    jump_times = []
-    jump_op_idx = []
-
-    for t_idx, t in enumerate(times):
-
-        if e_ops:
-            for e_idx, e in enumerate(e_ops):
-                s = _data.expect(e, psi_t)
-                data.expect[e_idx, t_idx] += s
-                data.ss[e_idx, t_idx] += s ** 2
-        else:
-            states_list.append(Qobj(psi_t.to_array(), dims=dims))
-
-        for j in range(N_substeps):
-
-            if _data.norm.l2(phi_t) ** 2 < r_jump:
-                # jump occurs
-                p = np.array([
-                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-                    for c in c_ops
-                ])
-                p = np.cumsum(p / np.sum(p))
-                n = np.where(p >= r_op)[0][0]
-
-                # apply jump
-                psi_t = _data.matmul(c_ops[n].data, psi_t)
-                psi_t /= _data.norm.l2(psi_t)
-                phi_t = psi_t.copy()
-
-                # store info about jump
-                jump_times.append(times[t_idx] + dt * j)
-                jump_op_idx.append(n)
-
-                # get new random numbers for next jump
-                r_jump, r_op = prng.rand(2)
-
-            # deterministic evolution wihtout correction for norm decay
-            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
-
-            # deterministic evolution with correction for norm decay
-            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
-            A = 0.5 * np.sum([
-                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-                for c in c_ops
-            ])
-            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
-
-            # increment wavefunctions
-            phi_t = _data.add(phi_t, dphi_t)
-            psi_t = _data.add(psi_t, dpsi_t)
-
-            # ensure that normalized wavefunction remains normalized
-            # this allows larger time step than otherwise would be possible
-            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
-
-    return states_list, jump_times, jump_op_idx
-
-
-# -----------------------------------------------------------------------------
-# Generic parameterized stochastic ME PDP solver
-#
-def _smepdpsolve_generic(sso, options, progress_bar):
-    """
-    For internal use. See smepdpsolve.
-    """
-    N_store = len(sso.times)
-    N_substeps = sso.nsubsteps
-    dt = (sso.times[1] - sso.times[0]) / N_substeps
-    nt = sso.ntraj
-
-    data = Result()
-    data.solver = "smepdpsolve"
-    data.times = sso.times
-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.jump_times = []
-    data.jump_op_idx = []
-
-    # Liouvillian for the deterministic part.
-    # needs to be modified for TD systems
-    L = liouvillian(sso.H, sso.c_ops)
-
-    progress_bar.start(sso.ntraj)
-
-    for n in range(sso.ntraj):
-        progress_bar.update(n)
-        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
-        rho_t = _data.column_stack_dense(rho_t)
-
-        states_list, jump_times, jump_op_idx = \
-            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
-                                           N_store, N_substeps,
-                                           rho_t, sso.rho0.dims,
-                                           sso.c_ops, sso.e_ops)
-
-        data.states.append(states_list)
-        data.jump_times.append(jump_times)
-        data.jump_op_idx.append(jump_op_idx)
-
-    progress_bar.finished()
-
-    # average density matrices
-    if options['average_states'] and np.any(data.states):
-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-                       for n in range(len(data.times))]
-
-    # average
-    data.expect = data.expect / sso.ntraj
-
-    # standard error
-    if nt > 1:
-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-    else:
-        data.se = None
-
-    return data
-
-def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
-    """
-    Internal function. See smepdpsolve.
-    """
-    states_list = []
-
-    rho_t = np.copy(rho_t)
-    sigma_t = np.copy(rho_t)
-
-    prng = RandomState()  # todo: seed it
-    r_jump, r_op = prng.rand(2)
-
-    jump_times = []
-    jump_op_idx = []
-
-    for t_idx, t in enumerate(times):
-
-        if e_ops:
-            for e_idx, e in enumerate(e_ops):
-                data.expect[e_idx, t_idx] +=\
-                    _data.expect_super(e, rho_t)
-        else:
-            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
-
-        for j in range(N_substeps):
-
-            if sigma_t.norm() < r_jump:
-                # jump occurs
-                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
-                p = np.cumsum(p / np.sum(p))
-                n = np.where(p >= r_op)[0][0]
-
-                # apply jump
-                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
-                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
-                sigma_t = np.copy(rho_t)
-
-                # store info about jump
-                jump_times.append(times[t_idx] + dt * j)
-                jump_op_idx.append(n)
-
-                # get new random numbers for next jump
-                r_jump, r_op = prng.rand(2)
-
-            # deterministic evolution wihtout correction for norm decay
-            dsigma_t = _data.matmul(L.data, sigma_t) * dt
-
-            # deterministic evolution with correction for norm decay
-            drho_t = _data.matmul(L.data, rho_t) * dt
-
-            # increment density matrices
-            sigma_t = _data.add(sigma_t, dsigma_t)
-            rho_t = _data.add(rho_t, drho_t)
-
-    return states_list, jump_times, jump_op_idx
diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index bc9d50e993..ce770b6801 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -6,7 +6,6 @@
     Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
     unstack_columns, liouvillian, lindblad_dissipator,
 )
-from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
 from ._stochastic import (
     SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
     GenericSSolver, Solvers
@@ -1330,94 +1329,3 @@ def _single_trajectory(i, sso):
     ssolver.set_solver(sso)
     result = ssolver.cy_sesolve_single_trajectory(i)
     return result
-
-
-# The code for ssepdpsolve have been moved to the file pdpsolve.
-# The call is still in stochastic for consistance.
-def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-    trajectory simulations.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
-
-
-# The code for smepdpsolve have been moved to the file pdpsolve.
-# The call is still in stochastic for consistance.
-def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for density matrix
-    evolution.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
index 3ec68b68b5..db39f53e86 100644
--- a/qutip/solver/__init__.py
+++ b/qutip/solver/__init__.py
@@ -17,3 +17,4 @@
 from .krylovsolve import *
 from .parallel import *
 import qutip.solver.sode
+from .stochastic import *
diff --git a/qutip/solver/sode/itotaylor.py b/qutip/solver/sode/itotaylor.py
index 0cc497acc0..e1f0e0c939 100644
--- a/qutip/solver/sode/itotaylor.py
+++ b/qutip/solver/sode/itotaylor.py
@@ -4,7 +4,10 @@
 from ..stochastic import StochasticSolver, SMESolver
 
 
-__all__ = ["EulerSODE", "Milstein_SODE", "Taylor1_5_SODE", "Explicit1_5_SODE"]
+__all__ = [
+    "EulerSODE", "Milstein_SODE", "Taylor1_5_SODE", "Explicit1_5_SODE",
+    "Implicit_Milstein_SODE", "Implicit_Taylor1_5_SODE"
+]
 
 
 class EulerSODE(_Explicit_Simple_Integrator):
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 71402691e4..8fe92bd38d 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -28,8 +28,7 @@ def add(self, t, state, noise):
         super().add(t, state)
         if (
             noise is not None
-            and (self.options['store_wiener_process']
-                 or self.options['store_measurement'])
+            and self.options['store_measurement']
         ):
             for i, dW in enumerate(noise):
                 self.W[i].append(self.W[i][-1] + dW)
@@ -92,17 +91,8 @@ def _post_init(self):
 
         store_measurement = self.options['store_measurement']
         keep_runs = self.options['keep_runs_results']
-        store_wiener_process = self.options['store_wiener_process']
 
-        if (
-            store_measurement and not store_wiener_process
-        ):
-            raise ValueError(
-                "Keeping runs is needed to store measurements "
-                "and wiener processes."
-            )
-
-        if not keep_runs and store_wiener_process:
+        if not keep_runs and store_measurement:
             self.add_processor(partial(self._reduce_attr, attr="wiener_process"))
             self._wiener_process = []
             self.add_processor(partial(self._reduce_attr, attr="dW"))
@@ -233,7 +223,6 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
              seeds=None, target_tol=None, timeout=None):
     """
     Solve stochastic master equation.
-    **************  TODO  ******************
 
     Parameters
     ----------
@@ -306,9 +295,7 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
           On `None` the states will be saved if no expectation operators are
           given.
         - store_measurement: bool, [False]
-          Whether to store the measurement for each trajectories.
-        - store_wiener_process: bool, [False]
-          Whether to store the wiener process, or brownian noise for each
+          Whether to store the measurement and wiener process for each
           trajectories.
         - keep_runs_results : bool, [False]
           Whether to store results from all trajectories or just store the
@@ -336,7 +323,7 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
           The finite steps lenght for the Stochastic integration method.
 
         Other options could be supported depending on the integration method,
-        see `SIntegrator <./classes.html#classes-ode>`_.
+        see `SIntegrator <./classes.html#classes-sode>`_.
 
     Returns
     -------
@@ -361,7 +348,6 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
              seeds=None, target_tol=None, timeout=None):
     """
     Solve stochastic Schrodinger equation.
-    **************  TODO  ******************
 
     Parameters
     ----------
@@ -430,10 +416,8 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
           On `None` the states will be saved if no expectation operators are
           given.
         - store_measurement: bool, [False]
-          Whether to store the measurement for each trajectories.
-        - store_wiener_process: bool, [False]
-          Whether to store the wiener process, or brownian noise for each
-          trajectories.
+          Whether to store the measurement and wiener process, or brownian
+          noise for each trajectories.
         - keep_runs_results : bool, [False]
           Whether to store results from all trajectories or just store the
           averages.
@@ -460,7 +444,7 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
           The finite steps lenght for the Stochastic integration method.
 
         Other options could be supported depending on the integration method,
-        see `SIntegrator <./classes.html#classes-ode>`_.
+        see `SIntegrator <./classes.html#classes-sode>`_.
 
     Returns
     -------
@@ -490,7 +474,6 @@ class StochasticSolver(MultiTrajSolver):
         "progress_kwargs": {"chunk_size": 10},
         "store_final_state": False,
         "store_states": None,
-        "store_wiener_process": False,
         "store_measurement": False,
         "keep_runs_results": False,
         "normalize_output": False,
@@ -510,24 +493,16 @@ def __init__(self, H, sc_ops, heterodyne, *, c_ops=(), options=None):
         rhs = _StochasticRHS(self._open, H, sc_ops, c_ops, heterodyne)
         super().__init__(rhs, options=options)
 
-        if self.options["store_measurement"]:
-            self.options["store_wiener_process"] = True
-
-            if heterodyne:
-                self._m_ops = []
-                for op in sc_ops:
-                    self._m_ops += [
-                        op + op.dag(), -1j * (op - op.dag())
-                    ]
-                self._dW_factors = np.ones(len(sc_ops) * 2) * 0.5**0.5
-
-            else:
-                self._m_ops = [op + op.dag() for op in sc_ops]
-                self._dW_factors = np.ones(len(sc_ops))
-
-        else:
+        if heterodyne:
             self._m_ops = []
-            self.dW_factors = []
+            for op in sc_ops:
+                self._m_ops += [
+                    op + op.dag(), -1j * (op - op.dag())
+                ]
+            self._dW_factors = np.ones(len(sc_ops) * 2) * 0.5**0.5
+        else:
+            self._m_ops = [op + op.dag() for op in sc_ops]
+            self._dW_factors = np.ones(len(sc_ops))
 
     @property
     def heterodyne(self):
@@ -540,18 +515,30 @@ def m_ops(self):
     @m_ops.setter
     def m_ops(self, new_m_ops):
         """
-        TODO
-        """
-        if not self.options["store_measurement"]:
-            if not new_m_ops:
-                self._m_ops = []
-                return
-            raise ValueError(
-                "The 'store_measurement' options must be set to "
-                "`True` to use m_ops."
-            )
+        Measurements operators.
 
-        if len(new_m_ops) != len(self.rhs.sc_ops):
+        Default are:
+
+            m_ops = sc_ops + sc_ops.dag()
+
+        for homodyne detection, and
+
+            m_ops = sc_ops + sc_ops.dag(), -1j*(sc_ops - sc_ops.dag())
+
+        for heterodyne detection.
+
+        Measurements opput is computed as:
+
+            expect(m_ops_i, state(t)) + dW_i / dt * dW_factors
+
+        Where ``dW`` follows a gaussian distribution with norm 0 and derivation
+        of ``dt**0.5``. ``dt`` is the time difference between step in the
+        ``tlist``.
+
+        ``m_ops`` can be overwritten, but the number of operators must be
+        constant.
+        """
+        if len(new_m_ops) != len(self.m_ops):
             if self.heterodyne:
                 raise ValueError(
                     f"2 `m_ops` per `sc_ops`, {len(self.rhs.sc_ops)} operators"
@@ -562,6 +549,12 @@ def m_ops(self, new_m_ops):
                     f"{len(self.rhs.sc_ops)} measurements "
                     "operators are expected."
                 )
+        if not all(
+            isinstance(op, Qobj) and op.dims == self.rhs.sc_ops[0].dims
+            for op in new_m_ops
+        ):
+            raise ValueError("m_ops must be Qobj with the same dimensions"
+                             " as the Hamiltonian")
         self._m_ops = new_m_ops
 
     @property
@@ -571,17 +564,11 @@ def dW_factors(self):
     @dW_factors.setter
     def dW_factors(self, new_dW_factors):
         """
-        TODO
+        Scaling of the noise on the measurements.
+        Default are ``1`` for homodyne and ``sqrt(1/2)`` for heterodyne.
+        ``dW_factors`` must be a list of the same length as ``m_ops``.
         """
-        if not self.options["store_measurement"]:
-            if not new_dW_factors:
-                self._dW_factors = []
-                return
-            raise ValueError(
-                "The 'dW_factors' are only used with measurements."
-            )
-
-        if len(new_dW_factors) != len(self.rhs.sc_ops):
+        if len(new_dW_factors) != len(self._dW_factors):
             if self.heterodyne:
                 raise ValueError(
                     f"2 `dW_factors` per `sc_ops`, {len(self.rhs.sc_ops)} "
@@ -634,12 +621,10 @@ def options(self):
             On `None` the states will be saved if no expectation operators are
             given.
 
-          - store_measurement: bool, [False]
+        store_measurement: bool, [False]
             Whether to store the measurement for each trajectories.
-
-          - store_wiener_process: bool, [False]
-            Whether to store the wiener process, or brownian noise for each
-            trajectories.
+            Storing measurements will also store the wiener process, or
+            brownian noise for each trajectories.
 
         progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
             How to present the solver progress.
@@ -682,7 +667,7 @@ def options(self, new_options):
 
 class SMESolver(StochasticSolver):
     r"""
-    ***************  TODO ****************
+    Stochastic Master Equation Solver.
 
     Parameters
     ----------
@@ -694,12 +679,12 @@ class SMESolver(StochasticSolver):
     sc_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
         List of stochastic collapse operators.
 
-    heterodyne : bool, [optional]
+    heterodyne : bool, [False]
         Whether to use heterodyne or homodyne detection.
 
     options : dict, [optional]
         Options for the solver, see :obj:`SMESolver.options` and
-        `SIntegrator <./classes.html#classes-ode>`_ for a list of all options.
+        `SIntegrator <./classes.html#classes-sode>`_ for a list of all options.
     """
     name = "smesolve"
     _avail_integrators = {}
@@ -708,7 +693,7 @@ class SMESolver(StochasticSolver):
 
 class SSESolver(StochasticSolver):
     r"""
-    ***************  TODO ****************
+    Stochastic Schrodinger Equation Solver.
 
     Parameters
     ----------
@@ -724,12 +709,12 @@ class SSESolver(StochasticSolver):
     sc_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
         List of stochastic collapse operators.
 
-    heterodyne : bool, [optional]
+    heterodyne : bool, [False]
         Whether to use heterodyne or homodyne detection.
 
     options : dict, [optional]
         Options for the solver, see :obj:`SSESolver.options` and
-        `SIntegrator <./classes.html#classes-ode>`_ for a list of all options.
+        `SIntegrator <./classes.html#classes-sode>`_ for a list of all options.
     """
     name = "ssesolve"
     _avail_integrators = {}
diff --git a/qutip/tests/solve/test_stochastic_me.py b/qutip/tests/solve/test_stochastic_me.py
deleted file mode 100644
index 27ac7c821a..0000000000
--- a/qutip/tests/solve/test_stochastic_me.py
+++ /dev/null
@@ -1,309 +0,0 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-
-from qutip import (
-    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
-    destroy, coherent, qeye, fock_dm, general_stochastic, num,
-)
-from qutip.solve.parallel import parallel_map
-from qutip.core import data as _data
-def f(t, args):
-    return args["a"] * t
-
-
-@pytest.mark.slow
-def test_smesolve_homodyne_methods():
-    "Stochastic: smesolve: homodyne methods with single jump operator"
-
-    def arccoth(x):
-        return 0.5*np.log((1.+x)/(x-1.))
-
-    th = 0.1 # Interaction parameter
-    alpha = np.cos(th)
-    beta = np.sin(th)
-    gamma = 1.
-
-    N = 30                 # number of Fock states
-    Id = qeye(N)
-    a = destroy(N)
-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-    x = (a + a.dag()) * 2**-0.5
-    H = Id
-    c_op = [gamma**0.5 * a]
-    sc_op = [s]
-    e_op = [x, x*x]
-    rho0 = fock_dm(N,0)      # initial vacuum state
-
-    T = 3.                   # final time
-    # number of time steps for which we save the expectation values
-    N_store = 121
-    Nsub = 10
-    tlist = np.linspace(0, T, N_store)
-    ddt = (tlist[1]-tlist[0])
-
-    #### Analytic solution
-    y0 = 0.5
-    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
-    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
-    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
-
-
-    list_methods_tol = [['euler-maruyama', 2e-2],
-                        ['pc-euler', 2e-3],
-                        ['pc-euler-2', 2e-3],
-                        ['platen', 1e-3],
-                        ['milstein', 1e-3],
-                        ['milstein-imp', 1e-3],
-                        ['rouchon', 1e-3],
-                        ['taylor1.5', 1e-4],
-                        ['taylor1.5-imp', 1e-4],
-                        ['explicit1.5', 1e-4],
-                        ['taylor2.0', 1e-4]]
-    for n_method in list_methods_tol:
-        # Comparisons of error between sol and sol3 depend on the stochastic
-        # noise, thus the seed, fixing the seed remove random fails.
-        np.random.seed(1)
-        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
-        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
-                       noise = sol.noise)
-        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-                        nsubsteps=Nsub*5, method='homodyne',
-                        solver = n_method[0], tol=1e-8)
-        err = 1/T * np.sum(np.abs(y_an - \
-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-        err3 = 1/T * np.sum(np.abs(y_an - \
-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
-        assert_(err < n_method[1])
-        # 5* more substep should decrease the error
-        assert_(err3 < err)
-        # just to check that noise is not affected by smesolve
-        assert_(np.all(sol.noise == sol2.noise))
-        assert_(np.all(sol.expect[0] == sol2.expect[0]))
-
-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=1)
-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=0)
-    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the same seed, sol3 differ.
-    assert_(np.all(sol.noise == sol2.noise))
-    assert_(np.all(sol.noise != sol3.noise))
-    assert_(not np.all(sol.measurement[0] == 0.+0j))
-    assert_(np.all(sol2.measurement[0] == 0.+0j))
-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the seed of traj 1 and 2 reversed.
-    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
-    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
-
-
-def test_smesolve_photocurrent():
-    "Stochastic: photocurrent_mesolve"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
-                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
-                   map_func=parallel_map)
-
-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                 for idx in range(len(e_ops))]))
-    assert_(len(res.measurement) == ntraj)
-    assert_(all([m.shape == (len(times), len(sc_ops))
-                 for m in res.measurement]))
-
-
-def test_smesolve_homodyne():
-    "Stochastic: smesolve: homodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'pc-euler',
-                        'pc-euler-2',
-                        'platen',
-                        'milstein',
-                        'milstein-imp',
-                        'rouchon',
-                        'taylor15',
-                        'taylor15-imp',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-                       method='homodyne', store_measurement=True,
-                       solver=solver, map_func=parallel_map)
-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                     for idx in range(len(e_ops))]))
-        assert_(len(res.measurement) == ntraj)
-        assert_(all([m.shape == (len(times), len(sc_ops))
-                     for m in res.measurement]))
-
-
-@pytest.mark.slow
-def test_smesolve_heterodyne():
-    "Stochastic: smesolve: heterodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a, f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'pc-euler',
-                        'pc-euler-2',
-                        'platen',
-                        'milstein',
-                        'milstein-imp',
-                        'rouchon',
-                        'taylor15',
-                        'taylor15-imp',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-                       method='heterodyne', store_measurement=True,
-                       solver=solver, map_func=parallel_map)
-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                     for idx in range(len(e_ops))]))
-        assert_(len(res.measurement) == ntraj)
-        assert_(all([m.shape == (len(times), len(sc_ops), 2)
-                     for m in res.measurement]))
-
-
-@pytest.mark.slow
-def test_general_stochastic():
-    "Stochastic: general_stochastic"
-    "Reproduce smesolve homodyne"
-    tol = 0.025
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 50
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
-    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
-    e_opsM = [spre(op) for op in e_ops]
-
-    def d1(t, vec):
-        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
-
-    def d2(t, vec):
-        out = []
-        vec_d = _data.Dense(vec)
-        for op in sc_opsM:
-            scale = -op.expect_data(t,vec_d)
-            out.append(
-                _data.add(op.matmul_data(t,vec_d),
-                          vec_d, scale)
-                )
-        return np.stack([o.to_array().ravel() for o in out])
-
-    times = np.linspace(0, 0.5, 13)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'platen',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
-                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
-                                 nsubsteps=nsubsteps, solver=solver)
-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                 for idx in range(len(e_ops))]))
-    assert_(len(res.measurement) == ntraj)
-
-
-def f_dargs(a, args):
-    return args["expect_op_3"] - 1
-
-
-@pytest.mark.xfail(reason="not working yet")
-def test_ssesolve_feedback():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [[a + a.dag(), f_dargs]]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-
-    times = np.linspace(0, 10, 101)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-                      args={"expect_op_3":qeye(N)})
-    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
-
-    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
-
-
-def test_smesolve_bad_e_ops():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [a + a.dag()]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
-
-    times = np.linspace(0, 10, 101)
-    with pytest.raises(TypeError) as exc:
-        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                       map_func=parallel_map)
diff --git a/qutip/tests/solve/test_stochastic_se.py b/qutip/tests/solve/test_stochastic_se.py
deleted file mode 100644
index 8a40f2d756..0000000000
--- a/qutip/tests/solve/test_stochastic_se.py
+++ /dev/null
@@ -1,230 +0,0 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_
-
-from qutip import (
-    ssesolve, destroy, coherent, mesolve, fock, qeye,
-    photocurrent_sesolve, num,
-)
-from qutip.solve.parallel import parallel_map
-
-def f(t, args):
-    return args["a"] * t
-
-
-@pytest.mark.slow
-def test_ssesolve_homodyne_methods():
-    "Stochastic: ssesolve: homodyne methods with single jump operator"
-
-    def arccoth(x):
-        return 0.5*np.log((1.+x)/(x-1.))
-
-    th = 0.1 # Interaction parameter
-    alpha = np.cos(th)
-    beta = np.sin(th)
-    gamma = 1.
-
-    N = 30                 # number of Fock states
-    Id = qeye(N)
-    a = destroy(N)
-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-    x = (a + a.dag()) * 2**-0.5
-    H = Id + gamma * a * a.dag()
-    sc_op = [s]
-    e_op = [x, x*x]
-    rho0 = fock(N,0)      # initial vacuum state
-
-    T = 6.                   # final time
-    # number of time steps for which we save the expectation values
-    N_store = 200
-    Nsub = 10
-    tlist = np.linspace(0, T, N_store)
-    ddt = (tlist[1]-tlist[0])
-
-    #### No analytic solution for ssesolve, taylor15 with 500 substep
-    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
-    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
-
-
-    list_methods_tol = [['euler-maruyama', 3e-2],
-                        ['pc-euler', 5e-3],
-                        ['pc-euler-2', 5e-3],
-                        ['platen', 5e-3],
-                        ['milstein', 5e-3],
-                        ['milstein-imp', 5e-3],
-                        ['taylor1.5', 5e-4],
-                        ['taylor1.5-imp', 5e-4],
-                        ['explicit1.5', 5e-4],
-                        ['taylor2.0', 5e-4]]
-    for n_method in list_methods_tol:
-        # Comparisons of error between sol and sol3 depend on the stochastic
-        # noise, thus the seed, fixing the seed remove random fails.
-        np.random.seed(1)
-        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
-        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
-                       noise = sol.noise)
-        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
-                        nsubsteps=Nsub*10, method='homodyne',
-                        solver=n_method[0], tol=1e-8)
-        err = 1/T * np.sum(np.abs(y_an - \
-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-        err3 = 1/T * np.sum(np.abs(y_an - \
-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-        assert err < n_method[1]
-        # 5* more substep should decrease the error
-        assert err3 < err
-        # just to check that noise is not affected by ssesolve
-        assert np.all(sol.noise == sol2.noise)
-        assert np.all(sol.expect[0] == sol2.expect[0])
-
-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=1)
-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=0)
-    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the same seed, sol3 differ.
-    assert np.all(sol.noise == sol2.noise)
-    assert np.all(sol.noise != sol3.noise)
-    assert not np.all(sol.measurement[0] == 0.+0j)
-    assert np.all(sol2.measurement[0] == 0.+0j)
-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the seed of traj 1 and 2 reversed.
-    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
-    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
-
-
-def test_ssesolve_photocurrent():
-    "Stochastic: photocurrent_sesolve"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
-                              nsubsteps=nsubsteps, store_measurement=True,
-                              map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
-
-
-def test_ssesolve_homodyne():
-    "Stochastic: ssesolve: homodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-                   ntraj=ntraj, nsubsteps=nsubsteps,
-                   method='homodyne', store_measurement=True,
-                   map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
-
-
-@pytest.mark.slow
-def test_ssesolve_heterodyne():
-    "Stochastic: ssesolve: heterodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-                   ntraj=ntraj, nsubsteps=nsubsteps,
-                   method='heterodyne', store_measurement=True,
-                   map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all(m.shape == (len(times), len(sc_ops), 2)
-               for m in res.measurement)
-
-
-def f_dargs(t, args):
-    return args["expect_op_3"] - 1
-
-
-@pytest.mark.xfail(reason="not yet working")
-def test_ssesolve_feedback():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [[a + a.dag(), f_dargs]]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-
-    times = np.linspace(0, 10, 101)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-                      args={"expect_op_3": qeye(N)})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-
-
-def test_ssesolve_bad_e_ops():
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-    b = destroy(N-1)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [a + a.dag()]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
-    times = np.linspace(0, 10, 101)
-    with pytest.raises(TypeError) as exc:
-        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                       map_func=parallel_map)
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 9e7f5abe64..342dbbf27e 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -2,7 +2,7 @@
 import numpy as np
 from qutip import (
     mesolve, liouvillian, QobjEvo, spre, spost,
-    destroy, coherent, qeye, fock_dm, num
+    destroy, coherent, qeye, fock_dm, num, basis
 )
 from qutip.solver.stochastic import smesolve, ssesolve, SMESolver, SSESolver
 from qutip.core import data as _data
@@ -277,3 +277,42 @@ def test_reuse_seeds():
         assert out1 == out2
 
     np.testing.assert_allclose(res.expect, res2.expect, atol=1e-14)
+
+
+@pytest.mark.parametrize("heterodyne", [True, False])
+def test_m_ops(heterodyne):
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    N = 10
+    ntraj = 1
+
+    H = num(N)
+    sc_ops = [destroy(N), qeye(N)]
+    psi0 = basis(N, N-1)
+    m_ops = [num(N), qeye(N)]
+    if heterodyne:
+        m_ops = m_ops * 2
+
+    times = np.linspace(0, 1.0, 51)
+
+    options = {"store_measurement": True,}
+
+    solver = SMESolver(H, sc_ops, heterodyne=heterodyne, options=options)
+    solver.m_ops = m_ops
+    solver.dW_factors = [0.] * len(m_ops)
+
+    res = solver.run(psi0, times, e_ops=m_ops)
+    # With dW_factors=0, measurements are computed as expectation values.
+    if heterodyne:
+        np.testing.assert_allclose(res.expect[0][1:], res.measurement[0][0][0])
+        np.testing.assert_allclose(res.expect[1][1:], res.measurement[0][0][1])
+    else:
+        np.testing.assert_allclose(res.expect[0][1:], res.measurement[0][0])
+        np.testing.assert_allclose(res.expect[1][1:], res.measurement[0][1])
+
+    solver.dW_factors = [1.] * len(m_ops)
+    # With dW_factors=0, measurements are computed as expectation values.
+    res = solver.run(psi0, times, e_ops=m_ops)
+    std = 1/times[1]**0.5
+    noise = res.expect[0][1:] - res.measurement[0][0]
+    assert np.mean(noise) == pytest.approx(0., abs=std/50**0.5 * 4)
+    assert np.std(noise) == pytest.approx(std, abs=std/50**0.5 * 4)

From da03d45d6a085250bce28c9014b6f06091eda18e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 20 Mar 2023 23:38:21 +0100
Subject: [PATCH 182/602] Specify type for i and check sorting of block rows.

---
 qutip/core/data/csr.pyx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 5b2a382b35..86a2bd7db4 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -902,15 +902,15 @@ cpdef CSR from_csr_blocks(
 
     cdef base.idxint rowpos, colpos
     cdef base.idxint row_idx, col_idx
-    cdef base.idxint op_i, op_row, op_row_start, op_row_end, op_row_len
+    cdef base.idxint op_i, op_row, op_row_start, op_row_end, op_row_len, i
 
     out.row_index[0] = 0
 
     for row_idx in range(n_blocks):
         prev_op_idx = op_idx
         while op_idx < op_len:
-            #if block_rows[op_idx] < row_idx:
-            #    raise ValueError("Block row indexes (block_rows) are not sorted.")
+            if block_rows[op_idx] < row_idx:
+                raise ValueError("Block row indexes (block_rows) are not sorted.")
             if block_rows[op_idx] != row_idx:
                 break
             op_idx += 1

From 0769771ece1031e0c17bb2ca50701225787f0f3e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 21 Mar 2023 12:59:37 +0100
Subject: [PATCH 183/602] Sanity check from_csr_blocks inputs.

---
 qutip/core/data/csr.pyx | 63 +++++++++++++++++++++++++++++------------
 1 file changed, 45 insertions(+), 18 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 86a2bd7db4..f8fe69d1b7 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -886,48 +886,75 @@ cpdef CSR from_csr_blocks(
     cdef CSR op
     cdef base.idxint shape = n_blocks * block_size
     cdef base.idxint nnz_ = 0
+    cdef base.idxint n_ops = len(block_ops)
+    cdef base.idxint i, j
+    cdef base.idxint row_idx, col_idx
+
+    # check arrays are the same length
+    if len(block_rows) != n_ops or len(block_cols) != n_ops:
+        raise ValueError(
+            "The arrays block_rows, block_cols and block_ops should have"
+            " the same length."
+        )
 
+    # check op shapes and calculate nnz
     for op in block_ops:
         nnz_ += nnz(op)
+        if op.shape[0] != block_size or op.shape[1] != block_size:
+            raise ValueError(
+                "Block operators (block_ops) do not have the correct shape."
+            )
 
     cdef CSR out = empty(shape, shape, nnz_)
+    if n_ops == 0:
+        return out
+
+    # check ops are ordered by (row, column)
+    row_idx = block_rows[0]
+    col_idx = block_cols[0]
+    for i in range(1, n_ops):
+        if (
+            block_rows[i] < row_idx or
+            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
+        ):
+            raise ValueError(
+                "The arrays block_rows and block_cols must be sorted"
+                " by (row, column)."
+            )
+        row_idx = block_rows[i]
+        col_idx = block_cols[i]
+
     if nnz_ == 0:
         return out
 
-    cdef base.idxint op_len = len(block_ops)
     cdef base.idxint op_idx = 0
     cdef base.idxint prev_op_idx = 0
-
     cdef base.idxint end = 0
-
-    cdef base.idxint rowpos, colpos
-    cdef base.idxint row_idx, col_idx
-    cdef base.idxint op_i, op_row, op_row_start, op_row_end, op_row_len, i
+    cdef base.idxint row_pos, col_pos
+    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
 
     out.row_index[0] = 0
 
     for row_idx in range(n_blocks):
         prev_op_idx = op_idx
-        while op_idx < op_len:
-            if block_rows[op_idx] < row_idx:
-                raise ValueError("Block row indexes (block_rows) are not sorted.")
+        while op_idx < n_ops:
             if block_rows[op_idx] != row_idx:
                 break
             op_idx += 1
 
-        rowpos = row_idx * block_size
+        row_pos = row_idx * block_size
         for op_row in range(block_size):
-            for op_i in range(prev_op_idx, op_idx):
-                col_idx = block_cols[op_i]
-                op = block_ops[op_i]
-                colpos = col_idx * block_size
+            for i in range(prev_op_idx, op_idx):
+                col_idx = block_cols[i]
+                op = block_ops[i]
+                col_pos = col_idx * block_size
                 op_row_start = op.row_index[op_row]
                 op_row_end = op.row_index[op_row + 1]
                 op_row_len = op_row_end - op_row_start
-                for i in range(op_row_len):
-                    out.col_index[end + i] = op.col_index[op_row_start + i] + colpos
-                    out.data[end + i] = op.data[op_row_start + i]
+                for j in range(op_row_len):
+                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
+                    out.data[end + j] = op.data[op_row_start + j]
                 end += op_row_len
-            out.row_index[rowpos + op_row + 1] = end
+            out.row_index[row_pos + op_row + 1] = end
 
     return out

From 0a41dab76cc8e1ab065defb957d9208a53e43ef7 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 21 Mar 2023 13:06:47 +0100
Subject: [PATCH 184/602] Mark from_csr_blocks as an internal function.

---
 qutip/core/data/csr.pxd            | 3 ++-
 qutip/core/data/csr.pyx            | 2 +-
 qutip/solver/heom/bofin_solvers.py | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
index ba65141ca2..65dcd3193c 100644
--- a/qutip/core/data/csr.pxd
+++ b/qutip/core/data/csr.pxd
@@ -161,5 +161,6 @@ cpdef CSR from_dense(Dense matrix)
 cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
                            base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
                            double tol=*)
-cpdef CSR from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+
+cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
                           base.idxint n_blocks, base.idxint block_size)
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index f8fe69d1b7..f40f2c8c6c 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -846,7 +846,7 @@ def diags(diagonals, offsets=None, shape=None):
     )
 
 
-cpdef CSR from_csr_blocks(
+cpdef CSR _from_csr_blocks(
     base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
     base.idxint n_blocks, base.idxint block_size
 ):
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 502bc94b10..70a267b488 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1311,7 +1311,7 @@ def gather(self):
             [op[2] for op in self._ops],
             dtype=object,
         )
-        return _csr.from_csr_blocks(
+        return _csr._from_csr_blocks(
             block_rows, block_cols, block_ops,
             self._n_blocks, self._block_size,
         )

From c815c52b039517368a4dd3c72b0a4619780c3dba Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 21 Mar 2023 13:26:16 +0100
Subject: [PATCH 185/602] Neaten up construction of block_rows, block_cols and
 block_ops arrays.

---
 qutip/solver/heom/bofin_solvers.py | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 70a267b488..5a84e69e8e 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1299,19 +1299,12 @@ def gather(self):
                 A combined matrix of shape ``(block * nhe, block * ne)``.
         """
         self._ops.sort()
-        block_rows = np.array(
-            [op[0] for op in self._ops],
-            dtype=_data.base.idxint_dtype,
-        )
-        block_cols = np.array(
-            [op[1] for op in self._ops],
-            dtype=_data.base.idxint_dtype,
-        )
-        block_ops = np.array(
-            [op[2] for op in self._ops],
-            dtype=object,
-        )
+        ops = np.array(self._ops, dtype=[
+            ("row", _data.base.idxint_dtype),
+            ("col", _data.base.idxint_dtype),
+            ("op", object),
+        ])
         return _csr._from_csr_blocks(
-            block_rows, block_cols, block_ops,
+            ops["row"], ops["col"], ops["op"],
             self._n_blocks, self._block_size,
         )

From 1318cada7afa57edde10a479bacdf62b147c898f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 21 Mar 2023 14:25:04 -0400
Subject: [PATCH 186/602] Remove old stochastic

---
 doc/guide/dynamics/dynamics-stochastic.rst |    2 +-
 qutip/solve/_stochastic.pyx                | 2350 --------------------
 qutip/solve/parallel.py                    |  241 --
 qutip/solve/stochastic.py                  | 1331 -----------
 4 files changed, 1 insertion(+), 3923 deletions(-)
 delete mode 100644 qutip/solve/_stochastic.pyx
 delete mode 100644 qutip/solve/parallel.py
 delete mode 100644 qutip/solve/stochastic.py

diff --git a/doc/guide/dynamics/dynamics-stochastic.rst b/doc/guide/dynamics/dynamics-stochastic.rst
index fa555df13c..059f539bbf 100644
--- a/doc/guide/dynamics/dynamics-stochastic.rst
+++ b/doc/guide/dynamics/dynamics-stochastic.rst
@@ -124,7 +124,7 @@ The measurement operators can be passed using the option ``m_ops``. The homodyne
 .. math::
     :label: measurement_result
 
-    J_x = \langle x \rangle + dW,
+    J_x = \langle x \rangle + dW / dt,
 
 where :math:`x` is the operator passed using ``m_ops``. The results are available in ``result.measurements``.
 
diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
deleted file mode 100644
index ea1c7497ae..0000000000
--- a/qutip/solve/_stochastic.pyx
+++ /dev/null
@@ -1,2350 +0,0 @@
-#cython: language_level=3
-
-import numpy as np
-cimport numpy as np
-cimport cython
-from cpython.exc cimport PyErr_CheckSignals
-from libc.math cimport fabs
-from qutip.core.cy.qobjevo cimport QobjEvo
-from .. import Qobj, unstack_columns
-import scipy.sparse as sp
-from scipy.sparse.linalg import LinearOperator
-from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
-from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
-
-from qutip.core.data cimport dense, Dense
-import qutip.core.data as _data
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-cdef int ZERO=0
-cdef double DZERO=0
-cdef complex ZZERO=0j
-cdef int ONE=1
-
-"""Some of blas wrapper"""
-@cython.boundscheck(False)
-cpdef void _axpy(complex a, complex[::1] x, complex[::1] y):
-    """ y += a*x"""
-    cdef int l = x.shape[0]
-    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void copy(complex[::1] x, complex[::1] y):
-    """ y = x """
-    cdef int l = x.shape[0]
-    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef complex _dot(complex[::1] x, complex[::1] y):
-    """ = x_i * y_i """
-    cdef int l = x.shape[0]
-    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef complex _dotc(complex[::1] x, complex[::1] y):
-    """ = conj(x_i) * y_i """
-    cdef int l = x.shape[0]
-    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef double _dznrm2(complex[::1] vec):
-    """ = sqrt( x_i**2 ) """
-    cdef int l = vec.shape[0]
-    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void _scale(double a, complex[::1] x):
-    """ x *= a """
-    cdef int l = x.shape[0]
-    zdscal(&l, &a, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void _zscale(complex a, complex[::1] x):
-    """ x *= a """
-    cdef int l = x.shape[0]
-    zscal(&l, &a, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void _zero(complex[::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]
-    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void _zero_2d(complex[:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]
-    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void _zero_3d(complex[:,:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
-    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
-
-@cython.boundscheck(False)
-cpdef void _zero_4d(complex[:,:,:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
-    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
-
-@cython.boundscheck(False)
-@cython.initializedcheck(False)
-cdef Dense _dense_wrap(double complex [::1] x):
-    return dense.wrap(&x[0], x.shape[0], 1)
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%
-# functions for ensuring that the states stay physical
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cpdef void _normalize_inplace(complex[::1] vec):
-    """ make norm of vec equal to 1"""
-    cdef int l = vec.shape[0]
-    cdef double norm = 1.0/_dznrm2(vec)
-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-
-# to move eventually, 10x faster than scipy's norm.
-@cython.cdivision(True)
-@cython.boundscheck(False)
-def normalize_inplace(complex[::1] vec):
-    """ make norm of vec equal to 1"""
-    cdef int l = vec.shape[0]
-    cdef double norm = 1.0/_dznrm2(vec)
-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-    return fabs(norm-1)
-
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cpdef void _normalize_rho(complex[::1] rho):
-    """ Ensure that the density matrix trace is one and
-    that the composing states are normalized.
-    """
-    cdef int l = rho.shape[0]
-    cdef int N = np.sqrt(l)
-    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
-    cdef complex[::1,:] eivec
-    cdef double[::1] eival = np.zeros(N)
-    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].to_array()
-
-    _zero(rho)
-    cdef int i, j, k
-    cdef double sum
-
-    sum = 0.
-    for i in range(N):
-        _normalize_inplace(eivec[:,i])
-        if eival[i] < 0:
-            eival[i] = 0.
-        sum += eival[i]
-    if sum != 1.:
-        for i in range(N):
-            eival[i] /= sum
-
-    for i in range(N):
-        for j in range(N):
-            for k in range(N):
-                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
-
-# Available solvers:
-cpdef enum Solvers:
-  # order 0.5
-  EULER_SOLVER           =  50
-  # order 0.5 strong, 1.0 weak?
-  PC_SOLVER              = 101
-  PC_2_SOLVER            = 104
-  # order 1.0
-  PLATEN_SOLVER          = 100
-  MILSTEIN_SOLVER        = 102
-  MILSTEIN_IMP_SOLVER    = 103
-  # order 1.5
-  EXPLICIT1_5_SOLVER     = 150
-  TAYLOR1_5_SOLVER       = 152
-  TAYLOR1_5_IMP_SOLVER   = 153
-  # order 2.0
-  TAYLOR2_0_SOLVER       = 202
-
-  # Special solvers
-  PHOTOCURRENT_SOLVER    =  60
-  PHOTOCURRENT_PC_SOLVER = 110
-  ROUCHON_SOLVER         = 120
-
-  # For initialisation
-  SOLVER_NOT_SET         =   0
-
-
-cdef class TaylorNoise:
-    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
-    Complex enough that I fell it should be kept separated from the main solver.
-    """
-    cdef:
-      int p
-      double rho, alpha
-      double aFactor, bFactor
-      double BFactor, CFactor
-      double dt, dt_sqrt
-
-    @cython.cdivision(True)
-    def __init__(self, int p, double dt):
-        self.p = p
-        self.dt = dt
-        self.dt_sqrt = dt**.5
-        cdef double pi = np.pi
-        cdef int i
-
-        cdef double rho = 0.
-        for i in range(1,p+1):
-            rho += (i+0.)**-2
-        rho = 1./3.-2*rho/(pi**2)
-        self.rho = (rho)**.5
-        self.aFactor = -(2)**.5/pi
-
-        cdef double alpha = 0.
-        for i in range(1,p+1):
-            alpha += (i+0.)**-4
-        alpha = pi/180-alpha/(2*pi**2)/pi
-        self.alpha = (alpha)**.5
-        self.bFactor = (0.5)**.5/pi**2
-
-        self.BFactor = 1/(4*pi**2)
-        self.CFactor = -1/(2*pi**2)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void order2(self, double[::1] noise, double[::1] dws):
-        cdef int p = self.p
-        cdef int r, l
-        cdef double s = 1/6.
-        cdef double a = 0
-        cdef double b = 0
-        cdef double AA = 0
-        cdef double BB = 0
-        cdef double CC = 0
-
-        for r in range(p):
-            a += noise[3+r]/(r+1.)
-            b += noise[3+r+p]/(r+1.)/(r+1.)
-            BB += (1/(r+1.)/(r+1.)) *\
-                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
-            for l in range(p):
-                if r != l:
-                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
-                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
-                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
-
-        a = self.aFactor * a + self.rho * noise[1]
-        b = self.bFactor * b + self.alpha * noise[2]
-        AA = 0.25*a*a
-        BB *= self.BFactor
-        CC *= self.CFactor
-
-        dws[0] = noise[0]                       # dw
-        dws[1] = 0.5*(noise[0]+a)               # dz
-        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
-        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
-        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
-
-
-cdef class StochasticSolver:
-    """ stochastic solver class base
-    Does most of the initialisation, drive the simulation and contain the
-    stochastic integration algorythm that do not depend on the physics.
-
-    This class is not to be used as is, the function computing the evolution's
-    derivative are specified in it's child class which define the deterministic
-    and stochastic contributions.
-
-    PYTHON METHODS:
-    set_solver:
-      Receive the data for the integration.
-      Prepare buffers
-
-    cy_sesolve_single_trajectory:
-      Run one trajectory.
-
-
-    INTERNAL METHODS
-    make_noise:
-      create the stochastic noise
-    run:
-      evolution between timestep (substep)
-    solver's method:
-      stochastic integration algorithm
-        euler
-        milstein
-        taylor
-        ...
-
-    CHILD:
-    SSESolver: stochastic schrodinger evolution
-    SMESolver: stochastic master evolution
-    PcSSESolver: photocurrent stochastic schrodinger evolution
-    PcSMESolver: photocurrent stochastic master evolution
-    PmSMESolver: positive map stochastic master evolution
-    GenericSSolver: general (user defined) stochastic evolution
-
-    CHILD METHODS:
-    set_data:
-      Read data about the system
-    d1:
-      deterministic part
-    d2:
-      non-deterministic part
-    derivatives:
-      d1, d2 and their derivatives up to dt**1.5
-      multiple sc_ops
-    derivativesO2:
-      d1, d2 and there derivatives up to dt**2.0
-      one sc_ops
-    """
-    cdef readonly int l_vec, num_ops
-    cdef readonly Solvers solver
-    cdef public int num_step, num_substeps
-    cdef readonly int num_dw
-    cdef public int normalize
-    cdef readonly double dt
-    cdef int noise_type
-    cdef object custom_noise
-    cdef double[::1] dW_factor
-    cdef unsigned int[::1] seed
-    cdef readonly object sso
-
-    # buffer to not redo the initialisation at each substep
-    cdef complex[:, ::1] buffer_1d
-    cdef complex[:, :, ::1] buffer_2d
-    cdef complex[:, :, :, ::1] buffer_3d
-    cdef complex[:, :, :, ::1] buffer_4d
-    cdef complex[:, ::1] expect_buffer_1d
-    cdef complex[:, ::1] expect_buffer_2d
-    cdef complex[:, :, ::1] expect_buffer_3d
-    cdef complex[:, ::1] func_buffer_1d
-    cdef complex[:, ::1] func_buffer_2d
-    cdef complex[:, :, ::1] func_buffer_3d
-
-    cdef TaylorNoise order2noise
-
-    def __init__(self):
-        self.l_vec = 0
-        self.num_ops = 0
-        self.solver = SOLVER_NOT_SET
-
-    def set_solver(self, sso):
-        """ Prepare the solver from the info in StochasticSolverOptions
-
-        Parameters
-        ----------
-        sso : StochasticSolverOptions
-            Data of the stochastic system
-        """
-        self.set_data(sso)
-        self.sso = sso
-
-        self.solver = sso.solver_code
-        self.dt = sso.dt
-        self.num_substeps = sso.nsubsteps
-        self.normalize = sso.normalize
-        self.num_step = len(sso.times)
-        self.num_dw = len(sso.sops)
-        if self.solver in [EXPLICIT1_5_SOLVER,
-                           TAYLOR1_5_SOLVER,
-                           TAYLOR1_5_IMP_SOLVER]:
-            self.num_dw *= 2
-        if self.solver in [TAYLOR2_0_SOLVER]:
-            self.num_dw *= 3 + 2*sso.p
-            self.order2noise = TaylorNoise(sso.p, self.dt)
-        # prepare buffers for the solvers
-        nb_solver = [0,0,0,0]
-        nb_func = [0,0,0]
-        nb_expect = [0,0,0]
-
-        # %%%%%%%%%%%%%%%%%%%%%%%%%
-        # Depending on the solver, determine the numbers of buffers of each
-        # shape to prepare. (~30% slower when not preallocating buffer)
-        # nb_solver : buffer to contain the states used by solver
-        # nb_func : buffer for states used used by d1, d2 and derivative functions
-        # nb_expect : buffer to store expectation values.
-        if self.solver is EULER_SOLVER:
-            nb_solver = [0,1,0,0]
-        elif self.solver is PHOTOCURRENT_SOLVER:
-            nb_solver = [1,0,0,0]
-            nb_func = [1,0,0]
-        elif self.solver is PLATEN_SOLVER:
-            nb_solver = [2,5,0,0]
-        elif self.solver is PC_SOLVER:
-            nb_solver = [4,1,1,0]
-        elif self.solver is MILSTEIN_SOLVER:
-            nb_solver = [0,1,1,0]
-        elif self.solver is MILSTEIN_IMP_SOLVER:
-            nb_solver = [1,1,1,0]
-        elif self.solver is PC_2_SOLVER:
-            nb_solver = [5,1,1,0]
-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-            nb_solver = [1,1,0,0]
-            nb_func = [1,0,0]
-        elif self.solver is ROUCHON_SOLVER:
-            nb_solver = [2,0,0,0]
-        elif self.solver is EXPLICIT1_5_SOLVER:
-            nb_solver = [5,8,3,0]
-        elif self.solver is TAYLOR1_5_SOLVER:
-            nb_solver = [2,3,1,1]
-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-            nb_solver = [2,3,1,1]
-        elif self.solver is TAYLOR2_0_SOLVER:
-            nb_solver = [11,0,0,0]
-
-        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
-                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-          if sso.me:
-            nb_func = [1,0,0]
-            nb_expect = [1,1,0]
-          else:
-            nb_func = [2,1,1]
-            nb_expect = [2,1,1]
-        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
-            nb_expect = [1,0,0]
-        elif self.solver is TAYLOR2_0_SOLVER:
-          if sso.me:
-            nb_func = [2,0,0]
-            nb_expect = [2,0,0]
-          else:
-            nb_func = [14,0,0]
-            nb_expect = [0,0,0]
-        elif self.solver is ROUCHON_SOLVER:
-            nb_expect = [1,0,0]
-        else:
-          if not sso.me:
-            nb_func = [1,0,0]
-
-        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
-        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
-                                  dtype=complex)
-        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
-                                        dtype=complex)
-        if nb_solver[3]:
-          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
-                                        dtype=complex)
-
-        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
-        if nb_expect[1]:
-          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
-        if nb_expect[2]:
-          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
-
-        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
-        if nb_func[1]:
-          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
-        if nb_func[2]:
-          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
-
-        self.noise_type = sso.noise_type
-        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
-        if self.noise_type == 1:
-            self.custom_noise = sso.noise
-        elif self.noise_type == 0:
-            self.seed = sso.noise
-
-    def reset_solver(self, new_solver):
-        self.sso.solver = new_solver
-        self.set_solver(self.sso)
-
-    def set_data(self, sso):
-        """Set solver specific operator"""
-        pass
-
-    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
-        """Create the random numbers for the stochastic process"""
-        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
-            # photocurrent, just seed,
-            np.random.seed(self.seed[n])
-            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
-        if self.noise_type == 0:
-            np.random.seed(self.seed[n])
-            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
-                                   np.sqrt(self.dt)
-        elif self.noise_type == 1:
-            return self.custom_noise[n,:,:,:]
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def cy_sesolve_single_trajectory(self, int n):
-        """ Run the one of the trajectories of the stochastic system.
-
-        Parameters
-        ----------
-        n : int
-            Number of the iterations
-
-        sso : StochasticSolverOptions
-            Data of the stochastic system
-
-        Returns
-        -------
-        states_list : list of qobj
-            State of the system at each time
-
-        noise : array
-            noise at each step of the solver
-
-        measurements : array
-            measurements value at each timestep for each m_ops
-
-        expect : array
-            expectation value at each timestep for each e_ops
-
-        """
-        sso = self.sso
-        cdef double[::1] times = sso.times
-        cdef complex[::1] rho_t
-        cdef double t
-        cdef int m_idx, t_idx, e_idx
-        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
-        cdef int tlast = times.shape[0]
-
-        rho_t = sso.rho0.copy()
-        dims = sso.state0.dims
-
-        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
-        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
-        states_list = []
-        for t_idx, t in enumerate(times):
-            PyErr_CheckSignals()
-            if sso.ce_ops:
-                for e_idx, e in enumerate(sso.ce_ops):
-                    s = e.expect_data(t, _dense_wrap(rho_t))
-                    expect[e_idx, t_idx] = s
-            if sso.store_states or not sso.ce_ops:
-                if sso.me:
-                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
-                        dims=dims))
-                else:
-                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
-
-            if t_idx != tlast-1:
-                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
-                                 rho_t, self.num_substeps)
-
-            if sso.store_measurement:
-                for m_idx, m in enumerate(sso.cm_ops):
-                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
-                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
-                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
-
-        if sso.method == 'heterodyne':
-            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
-
-        return states_list, noise, measurements, expect
-
-    @cython.boundscheck(False)
-    cpdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
-                          complex[::1] vec, int num_substeps):
-        """ Do one time full step"""
-        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
-        cdef int i
-        if self.solver is EULER_SOLVER:
-            for i in range(num_substeps):
-                self.euler(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PHOTOCURRENT_SOLVER:
-            for i in range(num_substeps):
-                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PLATEN_SOLVER:
-            for i in range(num_substeps):
-                self.platen(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PC_SOLVER:
-            for i in range(num_substeps):
-                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is MILSTEIN_SOLVER:
-            for i in range(num_substeps):
-                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is MILSTEIN_IMP_SOLVER:
-            for i in range(num_substeps):
-                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PC_2_SOLVER:
-            for i in range(num_substeps):
-                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-            for i in range(num_substeps):
-                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is ROUCHON_SOLVER:
-            for i in range(num_substeps):
-                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is EXPLICIT1_5_SOLVER:
-            for i in range(num_substeps):
-                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR1_5_SOLVER:
-            for i in range(num_substeps):
-                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-            for i in range(num_substeps):
-                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR2_0_SOLVER:
-            for i in range(num_substeps):
-                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        if self.normalize:
-            self._normalize_inplace(vec)
-        return vec
-
-    cpdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_inplace(vec)
-
-    # Dummy functions
-    # Needed for compilation since ssesolve is not stand-alone
-    cpdef void d1(self, double t, complex[::1] v, complex[::1] out):
-        """ deterministic part of the evolution
-        depend on schrodinger vs master vs photocurrent
-        """
-        pass
-
-    cpdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
-        """ stochastic part of the evolution
-        depend on schrodinger vs master vs photocurrent
-        """
-        pass
-
-    cpdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
-        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
-        pass
-
-    cpdef void derivatives(self, double t, int deg, complex[::1] rho,
-                              complex[::1] a, complex[:, ::1] b,
-                              complex[:, :, ::1] Lb, complex[:,::1] La,
-                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                              complex[::1] L0a):
-        """ Obtain the multiple terms for stochastic taylor expension
-        Up to order 1.5
-        multiple sc_ops
-        """
-        pass
-
-    cpdef void derivativesO2(self, double t, complex[::1] rho,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """ Obtain the multiple terms for stochastic taylor expension
-        Up to order 2.0
-        One sc_ops
-        """
-        pass
-
-    cpdef void photocurrent(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        photocurrent collapse + euler evolution
-        """
-        pass
-
-    cpdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        photocurrent collapse + predictor-corrector evolution
-        """
-        pass
-
-    cpdef void rouchon(self, double t, double dt, double[:] noise,
-                      complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        Force valid density matrix using positive map
-        Pierre Rouchon, Jason F. Ralph
-        arXiv:1410.5345 [quant-ph]
-        """
-        pass
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void euler(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """Integration scheme:
-        Basic Euler order 0.5
-        dV = d1 dt + d2_i dW_i
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        _zero_2d(d2)
-        copy(vec, out)
-        self.d1(t, vec, out)
-        self.d2(t, vec, d2)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void platen(self, double t, double dt, double[:] noise,
-                       complex[::1] vec, complex[::1] out):
-        """
-        Platen rhs function for both master eq and schrodinger eq.
-        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
-             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
-             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
-
-        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
-        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
-        The Theory of Open Quantum Systems
-        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
-        """
-        cdef int i, j, k
-        cdef double sqrt_dt = np.sqrt(dt)
-        cdef double sqrt_dt_inv = 0.25/sqrt_dt
-        cdef double dw, dw2
-        cdef complex[::1] d1 = self.buffer_1d[0,:]
-        cdef complex[::1] Vt = self.buffer_1d[1,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
-        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
-        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
-        _zero(d1)
-        _zero_2d(d2)
-
-        self.d1(t, vec, d1)
-        self.d2(t, vec, d2)
-        _axpy(1.0,vec,d1)
-        copy(d1,Vt)
-        copy(d1,out)
-        _scale(0.5,out)
-        for i in range(self.num_ops):
-            copy(d1,Vp[i,:])
-            copy(d1,Vm[i,:])
-            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
-            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
-            _axpy(noise[i],d2[i,:],Vt)
-        _zero(d1)
-        self.d1(t, Vt, d1)
-        _axpy(0.5,d1,out)
-        _axpy(0.5,vec,out)
-        for i in range(self.num_ops):
-            _zero_2d(d2p)
-            _zero_2d(d2m)
-            self.d2(t, Vp[i,:], d2p)
-            self.d2(t, Vm[i,:], d2m)
-            dw = noise[i] * 0.25
-            _axpy(dw,d2m[i,:],out)
-            _axpy(2*dw,d2[i,:],out)
-            _axpy(dw,d2p[i,:],out)
-            for j in range(self.num_ops):
-                if i == j:
-                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
-                else:
-                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
-                _axpy(dw2,d2p[j,:],out)
-                _axpy(-dw2,d2m[j,:],out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void pred_corr(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 15.5 Eq. (5.4)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        # a=0. b=0.5
-        cdef double dt_2 = dt*0.5
-        cdef complex[::1] euler = self.buffer_1d[0,:]
-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-        cdef complex[::1] b_pred = self.buffer_1d[2,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero(a_pred)
-        _zero(b_pred)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-        copy(vec, euler)
-        copy(vec, out)
-        _axpy(1.0, a_pred, euler)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], b_pred)
-            _axpy(-dt_2, dd2[i,i,:], a_pred)
-        _axpy(1.0, a_pred, out)
-        _axpy(1.0, b_pred, euler)
-        _axpy(0.5, b_pred, out)
-        _zero_2d(d2)
-        self.d2(t + dt, euler, d2)
-        for i in range(self.num_ops):
-            _axpy(noise[i]*0.5, d2[i,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void pred_corr_a(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 15.5 Eq. (5.4)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        # a=0.5, b=0.5
-        cdef int i, j, k
-        cdef complex[::1] euler = self.buffer_1d[0,:]
-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-        _zero(a_pred)
-        cdef complex[::1] a_corr = self.buffer_1d[2,:]
-        _zero(a_corr)
-        cdef complex[::1] b_pred = self.buffer_1d[3,:]
-        _zero(b_pred)
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        _zero_2d(d2)
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero_3d(dd2)
-
-        cdef double dt_2 = dt*0.5
-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-        copy(vec, euler)
-        _axpy(1.0, a_pred, euler)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], b_pred)
-            _axpy(-dt_2, dd2[i,i,:], a_pred)
-        _axpy(1.0, b_pred, euler)
-        copy(vec, out)
-        _axpy(0.5, a_pred, out)
-        _axpy(0.5, b_pred, out)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
-        for i in range(self.num_ops):
-            _axpy(noise[i]*0.5, d2[i,:], out)
-            _axpy(-dt_2, dd2[i,i,:], a_corr)
-        _axpy(0.5, a_corr, out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void milstein(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 10.3 Eq. (3.1)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-
-        dV = -iH*V*dt + d1*dt + d2_i*dW_i
-             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
-        """
-        cdef int i, j, k
-        cdef double dw
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        copy(vec,out)
-        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
-        for i in range(self.num_ops):
-            _axpy(noise[i],d2[i,:],out)
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                if (i == j):
-                    dw = (noise[i] * noise[i] - dt) * 0.5
-                else:
-                    dw = (noise[i] * noise[j])
-                _axpy(dw,dd2[i,j,:],out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void milstein_imp(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out) except *:
-        """
-        Chapter 12.2 Eq. (2.9)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j, k
-        cdef double dw
-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-                                                          dtype=complex)
-        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
-                                                         dtype=complex)
-        cdef complex[::1] a = self.buffer_1d[0,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero(a)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
-        copy(vec, dvec)
-        _axpy(0.5, a, dvec)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], dvec)
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                if (i == j):
-                    dw = (noise[i] * noise[i] - dt) * 0.5
-                else:
-                    dw = (noise[i] * noise[j])
-                _axpy(dw, dd2[i,j,:], dvec)
-        copy(dvec, guess)
-        _axpy(0.5, a, guess)
-        self.implicit(t+dt, dvec, out, guess)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void taylor15(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """
-        Chapter 12.2 Eq. (2.18),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-        cdef complex[::1] L0a = self.buffer_1d[1, :]
-        _zero(a)
-        _zero_2d(b)
-        _zero_3d(Lb)
-        _zero_2d(L0b)
-        _zero_2d(La)
-        _zero_4d(LLb)
-        _zero(L0a)
-        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
-
-        cdef int i,j,k
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-        copy(vec,out)
-        _axpy(1.0, a, out)
-        _axpy(0.5, L0a, out)
-
-        for i in range(self.num_ops):
-            _axpy(dw[i], b[i,:], out)
-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
-            _axpy(dz[i], La[i,:], out)
-            _axpy(dw[i]-dz[i], L0b[i,:], out)
-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-                        LLb[i,i,i,:], out)
-            for j in range(i+1,self.num_ops):
-                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
-                for k in range(j+1,self.num_ops):
-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void taylor15_imp(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out) except *:
-        """
-        Chapter 12.2 Eq. (2.18),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-        cdef complex[::1] L0a = self.buffer_1d[1, :]
-        _zero(a)
-        _zero_2d(b)
-        _zero_3d(Lb)
-        _zero_2d(L0b)
-        _zero_2d(La)
-        _zero_4d(LLb)
-        _zero(L0a)
-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-                   dtype=complex)
-        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
-                  dtype=complex)
-        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
-
-        cdef int i,j,k
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-        copy(vec, vec_t)
-        _axpy(0.5, a, vec_t)
-        for i in range(self.num_ops):
-            _axpy(dw[i], b[i,:], vec_t)
-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
-            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
-            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-                        LLb[i,i,i,:], vec_t)
-            for j in range(i+1,self.num_ops):
-                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
-                for k in range(j+1,self.num_ops):
-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
-        copy(vec_t, guess)
-        _axpy(0.5, a, guess)
-
-        self.implicit(t+dt, vec_t, out, guess)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void platen15(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 11.2 Eq. (2.13)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j, k
-        cdef double sqrt_dt = np.sqrt(dt)
-        cdef double sqrt_dt_inv = 1./sqrt_dt
-        cdef double ddz, ddw, ddd
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-
-        cdef complex[::1] d1 = self.buffer_1d[0,:]
-        cdef complex[::1] d1p = self.buffer_1d[1,:]
-        cdef complex[::1] d1m = self.buffer_1d[2,:]
-        cdef complex[::1] V = self.buffer_1d[3,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
-        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
-        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
-        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
-        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
-        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
-        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
-        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
-
-        _zero(d1)
-        _zero_2d(d2)
-        _zero_2d(dd2)
-        self.d1(t, vec, d1)
-        self.d2(t, vec, d2)
-        self.d2(t + dt, vec, dd2)
-        # Euler part
-        copy(vec,out)
-        _axpy(1., d1, out)
-        for i in range(self.num_ops):
-            _axpy(dw[i], d2[i,:], out)
-
-        _zero(V)
-        _axpy(1., vec, V)
-        _axpy(1./self.num_ops, d1, V)
-
-        _zero_2d(v2p)
-        _zero_2d(v2m)
-        for i in range(self.num_ops):
-            _axpy(1., V, v2p[i,:])
-            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
-            _axpy(1., V, v2m[i,:])
-            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
-
-        _zero_3d(p2p)
-        _zero_3d(p2m)
-        for i in range(self.num_ops):
-            _zero_2d(d2p)
-            _zero_2d(d2m)
-            self.d2(t, v2p[i,:], d2p)
-            self.d2(t, v2m[i,:], d2m)
-            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
-            _axpy( ddw, d2p[i,:], out)
-            _axpy(-ddw, d2m[i,:], out)
-            for j in range(self.num_ops):
-                _axpy(      1., v2p[i,:], p2p[i,j,:])
-                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
-                _axpy(      1., v2p[i,:], p2m[i,j,:])
-                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
-
-        _axpy(-0.5*(self.num_ops), d1, out)
-        for i in range(self.num_ops):
-            ddz = dz[i]*0.5/sqrt_dt  # 1.5
-            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
-            _zero(d1p)
-            _zero(d1m)
-            _zero_2d(d2m)
-            _zero_2d(d2p)
-            _zero_2d(d2pp)
-            _zero_2d(d2mm)
-            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
-            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
-            self.d2(t, v2p[i,:], d2p)
-            self.d2(t, v2m[i,:], d2m)
-            self.d2(t, p2p[i,i,:], d2pp)
-            self.d2(t, p2m[i,i,:], d2mm)
-
-            _axpy( ddz+0.25, d1p, out)
-            _axpy(-ddz+0.25, d1m, out)
-
-            _axpy((dw[i]-dz[i]), dd2[i,:], out)
-            _axpy((dz[i]-dw[i]), d2[i,:], out)
-
-            _axpy( ddd, d2pp[i,:], out)
-            _axpy(-ddd, d2mm[i,:], out)
-            _axpy(-ddd, d2p[i,:], out)
-            _axpy( ddd, d2m[i,:], out)
-
-            for j in range(self.num_ops):
-              ddw = 0.5*(dw[j]-dz[j]) # 1.5
-              _axpy(ddw, d2p[j,:], out)
-              _axpy(-2*ddw, d2[j,:], out)
-              _axpy(ddw, d2m[j,:], out)
-
-              if j>i:
-                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
-                _axpy( ddw, d2p[j,:], out)
-                _axpy(-ddw, d2m[j,:], out)
-
-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-                _zero_2d(d2pp)
-                _zero_2d(d2mm)
-                self.d2(t, p2p[j,i,:], d2pp)
-                self.d2(t, p2m[j,i,:], d2mm)
-                _axpy( ddw, d2pp[j,:], out)
-                _axpy(-ddw, d2mm[j,:], out)
-                _axpy(-ddw, d2p[j,:], out)
-                _axpy( ddw, d2m[j,:], out)
-
-                for k in range(j+1,self.num_ops):
-                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
-                    _axpy( ddw, d2pp[k,:], out)
-                    _axpy(-ddw, d2mm[k,:], out)
-                    _axpy(-ddw, d2p[k,:], out)
-                    _axpy( ddw, d2m[k,:], out)
-
-              if j<i:
-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-                _zero_2d(d2pp)
-                _zero_2d(d2mm)
-                self.d2(t, p2p[j,i,:], d2pp)
-                self.d2(t, p2m[j,i,:], d2mm)
-                _axpy( ddw, d2pp[j,:], out)
-                _axpy(-ddw, d2mm[j,:], out)
-                _axpy(-ddw, d2p[j,:], out)
-                _axpy( ddw, d2m[j,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cpdef void taylor20(self, double t, double dt, double[::1] noise,
-                           complex[::1] vec, complex[::1] out):
-        """
-        Chapter 10.5 Eq. (5.1),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef double[::1] noises = np.empty(5)
-        cdef double dwn
-        self.order2noise.order2(noise,noises)
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[::1] b = self.buffer_1d[1, :]
-        cdef complex[::1] Lb = self.buffer_1d[2, :]
-        cdef complex[::1] La = self.buffer_1d[3, :]
-        cdef complex[::1] L0b = self.buffer_1d[4, :]
-        cdef complex[::1] LLb = self.buffer_1d[5, :]
-        cdef complex[::1] L0a = self.buffer_1d[6, :]
-        cdef complex[::1] LLa = self.buffer_1d[7, :]
-        cdef complex[::1] LL0b = self.buffer_1d[8, :]
-        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
-        cdef complex[::1] LLLb = self.buffer_1d[10, :]
-        _zero(a)
-        _zero(b)
-        _zero(Lb)
-        _zero(La)
-        _zero(L0b)
-        _zero(LLb)
-        _zero(L0a)
-        _zero(LLa)
-        _zero(LL0b)
-        _zero(L0Lb)
-        _zero(LLLb)
-        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
-                           L0a, LLa, LL0b, L0Lb, LLLb)
-
-        copy(vec,out)
-        _axpy(1.0, a, out)
-
-        _axpy(noises[0], b, out)
-        dwn = noises[0]*noises[0]*0.5
-        _axpy(dwn, Lb, out)
-
-        _axpy(noises[1], La, out)
-        _axpy(noises[0]-noises[1], L0b, out)
-        dwn *= noises[0]*(1/3.)
-        _axpy(dwn, LLb, out)
-        _axpy(0.5, L0a, out)
-
-        _axpy(noises[2], L0Lb, out)
-        _axpy(noises[3], LL0b, out)
-        _axpy(noises[4], LLa, out)
-        dwn *= noises[0]*0.25
-        _axpy(dwn, LLLb, out)
-
-
-cdef class SSESolver(StochasticSolver):
-    """stochastic Schrodinger system"""
-    cdef readonly QobjEvo L
-    cdef readonly object c_ops
-    cdef readonly object cpcd_ops
-    cdef readonly object imp
-    cdef readonly double tol, imp_t
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.cpcd_ops = []
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op[0])
-            self.cpcd_ops.append(op[1])
-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-            self.tol = sso.tol
-            self.imp = LinearOperator( (self.l_vec,self.l_vec),
-                                      matvec=self.implicit_op, dtype=complex)
-
-    def implicit_op(self, vec):
-        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
-        self.d1(self.imp_t, vec, out)
-        cdef int i
-        _scale(-0.5,out)
-        _axpy(1.,vec,out)
-        return out
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
-        cdef int i
-        cdef complex e
-        cdef QobjEvo c_op
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        _zero(temp)
-        for i in range(self.num_ops):
-            c_op = self.cpcd_ops[i]
-            e = c_op.expect_data(t, _dense_wrap(vec))
-            _zero(temp)
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
-            _axpy(-0.125 * e * e * self.dt, vec, out)
-            _axpy(0.5 * e * self.dt, temp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-        cdef int i, k
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
-            c_op = self.cpcd_ops[i]
-            expect = c_op.expect_data(t, _dense_wrap(vec))
-            _axpy(-0.5*expect,vec,out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void derivatives(self, double t, int deg, complex[::1] vec,
-                          complex[::1] a, complex[:, ::1] b,
-                          complex[:, :, ::1] Lb, complex[:,::1] La,
-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                          complex[::1] L0a):
-        """
-        combinaisons of a and b derivatives for taylor order 1.5
-        dY ~ a dt + bi dwi
-                                         deg   use        noise
-        b[i.:]       bi                   >=0   d2 euler   dwi
-        a[:]         a                    >=0   d1 euler   dt
-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-
-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-        La[i,:]      ba'                  >=2   taylor15   dzi
-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-        """
-        cdef int i, j, k, l
-        cdef double dt = self.dt
-        cdef QobjEvo c_op
-        cdef complex e, de_bb
-
-        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
-        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
-        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
-        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
-        _zero_3d(dde_bb)
-        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
-        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-        _zero(temp)
-        _zero(temp2)
-        _zero_2d(Cvec)
-        _zero_3d(Cb)
-
-        # a b
-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
-            e = _dotc(vec,Cvec[i,:])
-            e_real[i] = e.real
-            _axpy(1., Cvec[i,:], b[i,:])
-            _axpy(-e_real[i], vec, b[i,:])
-            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
-            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
-
-        #Lb bb'
-        if deg >= 1:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            for j in range(self.num_ops):
-              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
-              for k in range(self.l_vec):
-                  temp[k] = conj(b[j,k])
-                  temp2[k] = 0.
-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
-                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-              _axpy(1., Cb[i,j,:], Lb[i,j,:])
-              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
-              _axpy(-de_b[i,j], vec, Lb[i,j,:])
-
-              for k in range(self.num_ops):
-                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
-                                  _dot(b[k,:], Cb[i,j,:]) + \
-                                  conj(_dotc(b[k,:], temp2)))*.5
-                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
-
-        #L0b La LLb
-        if deg >= 2:
-          for i in range(self.num_ops):
-              #ba'
-              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-              for j in range(self.num_ops):
-                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
-                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
-                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
-                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
-
-              #ab' + db/dt + bbb"/2
-              c_op = self.c_ops[i]
-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
-              for k in range(self.l_vec):
-                  temp[k] = conj(a[k])
-                  temp2[k] = 0.
-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
-                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-              _axpy(-e_real[i], a, L0b[i,:])
-              _axpy(-de_a[i], vec, L0b[i,:])
-
-              temp = np.zeros(self.l_vec, dtype=complex)
-              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
-              e = _dotc(vec,temp)
-              _axpy(1., temp, L0b[i,:])
-              _axpy(-e.real, vec, L0b[i,:])
-              _axpy(-1., b[i,:], L0b[i,:])
-
-              for j in range(self.num_ops):
-                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
-                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
-
-              #b(bb"+b'b')
-              for j in range(i,self.num_ops):
-                  for k in range(j, self.num_ops):
-                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
-                                  _dense_wrap(LLb[i,j,k,:]))
-                      for l in range(self.l_vec):
-                          temp[l] = conj(Lb[j,k,l])
-                          temp2[l] = 0.
-                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
-                               _dot(Lb[j,k,:], Cvec[i,:]) + \
-                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
-                               _dotc(vec, temp2)))*0.5
-                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
-                      _axpy(-de_bb, vec, LLb[i,j,k,:])
-                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
-                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
-                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
-
-        #da/dt + aa' + bba"
-        if deg == 2:
-          self.d1(t + dt, vec, L0a)
-          _axpy(-1.0, a, L0a)
-          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-          for j in range(self.num_ops):
-              c_op = self.c_ops[j]
-              temp = np.zeros(self.l_vec, dtype=complex)
-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
-              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
-              _axpy(e_real[j] * dt, temp, L0a[:])
-              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
-              for i in range(self.num_ops):
-                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
-                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
-                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
-                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
-                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void _c_vec_conj(self, double t, QobjEvo c_op,
-                         complex[::1] vec, complex[::1] out):
-        cdef int k
-        cdef complex[::1] temp = self.func_buffer_1d[13,:]
-        for k in range(self.l_vec):
-            temp[k] = conj(vec[k])
-            out[k] = 0.
-        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void derivativesO2(self, double t, complex[::1] psi,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """
-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-        Use Stratonovich-Taylor expansion.
-        One one sc_ops
-        dY ~ a dt + bi dwi
-
-        b[:]     b                        d2 euler    dw
-        a[:]     a- Lb/2                  d1 euler    dt
-        Lb[:]    b'b                      milstein    dw^2/2
-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-
-        LLa[:]   ...                      taylor2.0   dwdt-dz
-        LL0b[:]  ...                      taylor2.0   dz
-        L0Lb[:]  ...                      taylor2.0   dw^3/6
-        LLLb[:]  ...                      taylor2.0   dt^2/2
-        """
-        cdef double dt = self.dt
-        cdef QobjEvo c_op = self.c_ops[0]
-        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
-        cdef complex de_a, dde_ba, de_La, de_L0b
-
-        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
-        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
-        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
-        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
-        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
-        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
-        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
-        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
-        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
-        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
-        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
-        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
-        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
-        _zero(Cpsi)
-        _zero(Cb)
-        _zero(CLb)
-        _zero(CLLb)
-        _zero(Ca)
-        _zero(CLa)
-        _zero(CL0b)
-
-        # b
-        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
-        e = _dotc(psi, Cpsi).real
-        _axpy(1., Cpsi, b)
-        _axpy(-e, psi, b)
-
-        # Lb
-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
-        self._c_vec_conj(t, c_op, b, Cbc)
-        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
-                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
-        _axpy(1., Cb, Lb)
-        _axpy(-e, b, Lb)
-        _axpy(-de_b, psi, Lb)
-
-        # LLb = b'b'b + b"bb
-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
-        self._c_vec_conj(t, c_op, Lb, CLbc)
-        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
-                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
-        _axpy(1, CLb, LLb)      # b'b'b
-        _axpy(-e, Lb, LLb)      # b'b'b
-        _axpy(-de_Lb, psi, LLb) # b'b'b
-        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
-        _axpy(-dde_bb, psi, LLb) # b"bb
-        _axpy(-de_b*2, b, LLb)   # b"bb
-
-        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
-        self._c_vec_conj(t, c_op, LLb, CLLbc)
-        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
-                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
-        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
-                    conj(_dotc(b, CLbc)))*.5
-        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
-        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
-        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
-        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
-        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
-        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
-        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
-
-        # a
-        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
-        _axpy(-0.5 * e * e * dt, psi, a)
-        _axpy(e * dt, Cpsi, a)
-        _axpy(-0.5 * dt, Lb, a)
-
-        #La
-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-        _axpy(-0.5 * e * e * dt, b, La)
-        _axpy(-e * de_b * dt, psi, La)
-        _axpy(e * dt, Cb, La)
-        _axpy(de_b * dt, Cpsi, La)
-        _axpy(-0.5 * dt, LLb, La)
-
-        #LLa
-        _axpy(-2 * e * de_b * dt, b, LLa)
-        _axpy(-de_b * de_b * dt, psi, LLa)
-        _axpy(-e * dde_bb * dt, psi, LLa)
-        _axpy( 2 * de_b * dt, Cb, LLa)
-        _axpy( dde_bb * dt, Cpsi, LLa)
-
-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-        _axpy(-de_Lb * e * dt, psi, LLa)
-        _axpy(-0.5 * e * e * dt, Lb, LLa)
-        _axpy( de_Lb * dt, Cpsi, LLa)
-        _axpy( e * dt, CLb, LLa)
-
-        _axpy(-0.5 * dt, LLLb, LLa)
-
-        # L0b = b'a
-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
-        self._c_vec_conj(t, c_op, a, Cac)
-        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
-                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
-        _axpy(1.0, Ca, L0b)
-        _axpy(-e, a, L0b)
-        _axpy(-de_a, psi, L0b)
-
-        # LL0b = b"ba + b'La
-        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
-                    conj(_dotc(b, Cac)))*.5
-        _axpy(-dde_ba, psi, LL0b)
-        _axpy(-de_a, b, LL0b)
-        _axpy(-de_b, a, LL0b)
-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
-        self._c_vec_conj(t, c_op, La, CLac)
-        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
-                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
-        _axpy(1., CLa, LL0b)
-        _axpy(-e, La, LL0b)
-        _axpy(-de_La, psi, LL0b)
-
-        # L0Lb = b"ba + b'L0b
-        _axpy(-dde_ba, psi, L0Lb)
-        _axpy(-de_a, b, L0Lb)
-        _axpy(-de_b, a, L0Lb)
-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
-        self._c_vec_conj(t, c_op, L0b, CL0bc)
-        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
-                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
-        _axpy(1., CL0b, L0Lb)
-        _axpy(-e, L0b, L0Lb)
-        _axpy(-de_L0b, psi, L0Lb)
-
-        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
-        self.d1(t + dt, psi, L0a) # da/dt
-        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
-        _axpy(-1.0, a, L0a)        # da/dt
-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
-        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
-        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
-        _axpy(e * dt, Ca, L0a)              # a'_a_
-        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
-        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
-
-    cpdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                                        complex[::1] out,
-                                        np.ndarray[complex, ndim=1] guess) except *:
-        # np.ndarray to memoryview is OK but not the reverse
-        # scipy function only take np array, not memoryview
-        self.imp_t = t
-        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
-                                          tol=self.tol, atol=1e-12)
-        cdef int i
-        copy(spout, out)
-
-
-cdef class SMESolver(StochasticSolver):
-    """stochastic master equation system"""
-    cdef readonly QobjEvo L
-    cdef readonly object imp
-    cdef readonly object c_ops
-    cdef readonly int N_root
-    cdef readonly double tol
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.N_root = np.sqrt(self.l_vec)
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op)
-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-            self.tol = sso.tol
-            self.imp = sso.imp
-
-    cpdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-    @cython.boundscheck(False)
-    cpdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef int i, k
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-            expect = self.expect(out[i,:])
-            _axpy(-expect, rho, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void derivatives(self, double t, int deg, complex[::1] rho,
-                          complex[::1] a, complex[:, ::1] b,
-                          complex[:, :, ::1] Lb, complex[:,::1] La,
-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                          complex[::1] L0a):
-        """
-        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
-        dY ~ a dt + bi dwi
-                                         deg   use        noise
-        b[i.:]       bi                   >=0   d2 euler   dwi
-        a[:]         a                    >=0   d1 euler   dt
-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-        La[i,:]      ba'                  >=2   taylor15   dzi
-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-        """
-        cdef int i, j, k
-        cdef QobjEvo c_op
-        cdef QobjEvo c_opj
-        cdef complex trApp, trAbb, trAa
-        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
-        cdef complex[:, ::1] trAb = self.expect_buffer_2d
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        #_zero(temp)
-
-        # a
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-
-        # b
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            # bi
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
-            trAp[i] = self.expect(b[i,:])
-            _axpy(-trAp[i], rho, b[i,:])
-
-        # Libj = bibj', i<=j
-        # sc_ops must commute (Libj = Ljbi)
-        if deg >= 1:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            for j in range(i, self.num_ops):
-                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
-                trAb[i,j] = self.expect(Lb[i,j,:])
-                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
-                _axpy(-trAb[i,j], rho, Lb[i,j,:])
-
-        # L0b La LLb
-        if deg >= 2:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            # Lia = bia'
-            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-
-            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
-            # db/dt
-            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
-            trApp = self.expect(L0b[i,:])
-            _axpy(-trApp, rho, L0b[i,:])
-            _axpy(-1, b[i,:], L0b[i,:])
-            # ab'
-            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
-            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-            trAa = self.expect(temp)
-            _axpy(1., temp, L0b[i,:])
-            _axpy(-trAp[i], a[:], L0b[i,:])
-            _axpy(-trAa, rho, L0b[i,:])
-            # bbb" : trAb[i,j] only defined for j>=i
-            for j in range(i):
-                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-            for j in range(i,self.num_ops):
-                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-
-            # LLb
-            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
-            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
-            for j in range(i,self.num_ops):
-              for k in range(j,self.num_ops):
-                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
-                trAbb = self.expect(LLb[i,j,k,:])
-                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
-                _axpy(-trAbb, rho, LLb[i,j,k,:])
-                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
-                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
-
-        # L0a = a'a + da/dt + bba"/2  (a" = 0)
-        if deg == 2:
-            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-            _axpy(-1, a, L0a)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void derivativesO2(self, double t, complex[::1] rho,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """
-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-        Use Stratonovich-Taylor expansion.
-        One one sc_ops
-        dY ~ a dt + bi dwi
-
-        b[:]     b                        d2 euler    dw
-        a[:]     a- Lb/2                  d1 euler    dt
-        Lb[:]    b'b                      milstein    dw^2/2
-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-
-        LLa[:]   ...                      taylor2.0   dwdt-dz
-        LL0b[:]  ...                      taylor2.0   dz
-        L0Lb[:]  ...                      taylor2.0   dw^3/6
-        LLLb[:]  ...                      taylor2.0   dt^2/2
-        """
-        cdef int i, j, k
-        cdef QobjEvo c_op = self.c_ops[0]
-        cdef QobjEvo c_opj
-        cdef complex trAp, trApt
-        cdef complex trAb, trALb, trALLb
-        cdef complex trAa, trALa
-        cdef complex trAL0b
-
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-
-        # b
-        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
-        trAp = self.expect(b)
-        _axpy(-trAp, rho, b)
-
-        # Lb = b'b
-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
-        trAb = self.expect(Lb)
-        _axpy(-trAp, b, Lb)
-        _axpy(-trAb, rho, Lb)
-
-        # LLb = b'Lb+b"bb
-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
-        trALb = self.expect(LLb)
-        _axpy(-trAp, Lb, LLb)
-        _axpy(-trALb, rho, LLb)
-        _axpy(-trAb*2, b, LLb)
-
-        # LLLb = b'LLb + 3 b"bLb + b"'bbb
-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
-        trALLb = self.expect(LLLb)
-        _axpy(-trAp, LLb, LLLb)
-        _axpy(-trALLb, rho, LLLb)
-        _axpy(-trALb*3, b, LLLb)
-        _axpy(-trAb*3, Lb, LLLb)
-
-        # _a_ = a - Lb/2
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-        _axpy(-0.5*self.dt, Lb, a)
-
-        # L_a_ = ba' - LLb/2
-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-        _axpy(-0.5*self.dt, LLb, La)
-
-        # LL_a_ = b(La)' - LLLb/2
-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-        _axpy(-0.5*self.dt, LLLb, LLa)
-
-        # _L0_b = b'(_a_)
-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
-        trAa = self.expect(L0b)
-        _axpy(-trAp, a, L0b)
-        _axpy(-trAa, rho, L0b)
-
-        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
-        trAL0b = self.expect(L0Lb)
-        _axpy(-trAp, L0b, L0Lb)
-        _axpy(-trAL0b, rho, L0Lb)
-        _axpy(-trAa, b, L0Lb)
-        _axpy(-trAb, a, L0Lb)
-
-        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
-        trAL0b = self.expect(LL0b)
-        _axpy(-trAp, La, LL0b)
-        _axpy(-trAL0b, rho, LL0b)
-        _axpy(-trAa, b, LL0b)
-        _axpy(-trAb, a, LL0b)
-
-        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
-        _axpy(-1, a, L0a)
-        _axpy(-self.dt*0.5, L0Lb, L0a)
-
-
-    cpdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                                        complex[::1] out,
-                                        np.ndarray[complex, ndim=1] guess) except *:
-        # np.ndarray to memoryview is OK but not the reverse
-        # scipy function only take np array, not memoryview
-        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
-                                          dvec, x0=guess,
-                                          tol=self.tol, atol=1e-12)
-        cdef int i
-        copy(spout,out)
-
-
-cdef class PcSSESolver(StochasticSolver):
-    """photocurrent for Schrodinger equation"""
-    cdef QobjEvo L
-    cdef object c_ops
-    cdef object cdc_ops
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.cdc_ops = []
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op[0])
-            self.cdc_ops.append(op[1])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void photocurrent(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double rand
-        cdef int i, which = -1
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] d2 = self.buffer_1d[0,:]
-
-        copy(vec, out)
-        self.d1(t, vec, out)
-        rand = np.random.rand()
-        for i in range(self.num_ops):
-            c_op = self.cdc_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-            if expects[i].real * dt >= 1e-15:
-                rand -= expects[i].real *dt
-            if rand < 0:
-                which = i
-                noise[i] = 1.
-                break
-
-        if which >= 0:
-            self.collapse(t, which, expects[which].real, vec, d2)
-            _axpy(1, d2, out)
-            _axpy(-1, vec, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double expect
-        cdef int i, which=0, num_coll=0, did_collapse=0
-        cdef complex[::1] tmp = self.buffer_1d[0,:]
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef np.ndarray[int, ndim=1] colls
-
-        # Collapses are computed first
-        for i in range(self.num_ops):
-            c_op = self.cdc_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-            if expects[i].real > 0:
-                did_collapse = np.random.poisson(expects[i].real * dt)
-                num_coll += did_collapse
-                if did_collapse:
-                    which = i
-                noise[i] = did_collapse * 1.
-            else:
-                noise[i] = 0.
-
-        if num_coll == 0:
-            pass
-        elif num_coll == 1:
-            # Do one collapse
-            self.collapse(t, which, expects[which].real, vec, out)
-            copy(out, vec)
-        elif num_coll and noise[which] == num_coll:
-            # Do many collapse of one sc_ops.
-            # Recompute the expectation value, but only to check for zero.
-            c_op = self.cdc_ops[which]
-            for i in range(num_coll):
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, which, expect, vec, out)
-                    copy(out,vec)
-        elif num_coll >= 2:
-            # 2 or more collapses of different operators
-            # Ineficient, should be rare
-            coll = []
-            for i in range(self.num_ops):
-                coll += [i]*int(noise[i])
-            np.random.shuffle(coll)
-            for i in coll:
-                c_op = self.cdc_ops[i]
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, i, expect, vec, out)
-                    copy(out,vec)
-        copy(vec,tmp)
-        copy(vec,out)
-        self.d1(t, vec, tmp)
-        self.d1(t+dt, tmp, out)
-        _scale(0.5, out)
-        _axpy(0.5, tmp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        cdef int i
-        cdef complex e
-        cdef QobjEvo c_op
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        for i in range(self.num_ops):
-            _zero(temp)
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-            e = _dznrm2(temp)
-            _axpy(0.5 * e * e * self.dt, vec, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
-            expect = _dznrm2(out[i,:])
-            if expect.real >= 1e-15:
-                _zscale(1/expect, out[i,:])
-            else:
-                _zero(out[i,:])
-            _axpy(-1, vec, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void collapse(self, double t, int which, double expect,
-                       complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        c_op = self.c_ops[which]
-        _zero(out)
-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        _zscale(1/expect, out)
-
-
-cdef class PcSMESolver(StochasticSolver):
-    """photocurrent for master equation"""
-    cdef QobjEvo L
-    cdef object cdcr_cdcl_ops
-    cdef object cdcl_ops
-    cdef object clcdr_ops
-    cdef int N_root
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.cdcr_cdcl_ops = []
-        self.cdcl_ops = []
-        self.clcdr_ops = []
-        self.N_root = np.sqrt(self.l_vec)
-        for i, op in enumerate(c_ops):
-            self.cdcr_cdcl_ops.append(op[0])
-            self.cdcl_ops.append(op[1])
-            self.clcdr_ops.append(op[2])
-
-    cpdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void photocurrent(self, double t, double dt,  double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double rand
-        cdef int i, which = -1
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] d2 = self.buffer_1d[0,:]
-
-        copy(vec, out)
-        self.d1(t, vec, out)
-        rand = np.random.rand()
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-            if expects[i].real * dt >= 1e-15:
-                rand -= expects[i].real *dt
-            if rand < 0:
-                which = i
-                noise[i] = 1.
-                break
-
-        if which >= 0:
-            self.collapse(t, which, expects[which].real, vec, d2)
-            _axpy(1, d2, out)
-            _axpy(-1, vec, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef int i, which, num_coll=0, did_collapse
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] tmp = self.buffer_1d[0,:]
-        cdef double expect
-        cdef np.ndarray[int, ndim=1] colls
-
-        # Collapses are computed first
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-            if expects[i].real > 0:
-                did_collapse = np.random.poisson(expects[i].real* dt)
-                num_coll += did_collapse
-                if did_collapse:
-                    which = i
-                noise[i] = did_collapse * 1.
-            else:
-                noise[i] = 0.
-
-        if num_coll == 0:
-            pass
-        elif num_coll == 1:
-            # Do one collapse
-            self.collapse(t, which, expects[which].real, vec, out)
-            copy(out,vec)
-        elif noise[which] == num_coll:
-            # Do many collapse of one sc_ops.
-            # Recompute the expectation value, but only to check for zero.
-            c_op = self.clcdr_ops[which]
-            for i in range(num_coll):
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, which, expect, vec, out)
-                    copy(out,vec)
-        elif num_coll >= 2:
-            # 2 or more collapses of different operators
-            # Ineficient, should be rare
-            coll = []
-            for i in range(self.num_ops):
-                coll += [i] * int(noise[i])
-            np.random.shuffle(coll)
-            for i in coll:
-                c_op = self.clcdr_ops[i]
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, i, expect, vec, out)
-                    copy(out,vec)
-
-        copy(vec,tmp)
-        copy(vec,out)
-        self.d1(t, vec, tmp)
-        self.d1(t+dt, tmp, out)
-        _scale(0.5, out)
-        _axpy(0.5, tmp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-    @cython.boundscheck(False)
-    cpdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex[::1] crho = self.func_buffer_1d[0,:]
-        cdef complex expect
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-        for i in range(self.num_ops):
-            c_op = self.cdcr_cdcl_ops[i]
-            _zero(crho)
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
-            expect = self.expect(crho)
-            _axpy(0.5*expect* self.dt, rho, out)
-            _axpy(-0.5* self.dt, crho, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-            expect = self.expect(out[i,:])
-            if expect.real >= 1e-15:
-                _zscale((1.+0j)/expect, out[i,:])
-            else:
-                _zero(out[i,:])
-            _axpy(-1, rho, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void collapse(self, double t, int which, double expect,
-                       complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        c_op = self.clcdr_ops[which]
-        _zero(out)
-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        _zscale(1./expect, out)
-
-cdef class PmSMESolver(StochasticSolver):
-    """positive map for master equation"""
-    cdef object L
-    cdef QobjEvo pp_ops
-    cdef QobjEvo preLH
-    cdef QobjEvo postLH
-    cdef object sops
-    cdef object preops
-    cdef object postops
-    cdef object preops2
-    cdef object postops2
-    cdef int N_root
-
-    def set_data(self, sso):
-        c_ops = sso.sops
-        self.l_vec = sso.pp.shape[0]
-        self.num_ops = len(c_ops)
-        self.preLH = sso.preLH
-        self.postLH = sso.postLH
-        self.pp_ops = sso.pp
-        self.sops = [op for op in sso.sops]
-        self.preops = [op for op in sso.preops]
-        self.postops = [op for op in sso.postops]
-        self.preops2 = [op for op in sso.preops2]
-        self.postops2 = [op for op in sso.postops2]
-        self.N_root = np.sqrt(self.l_vec)
-
-    cpdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef void rouchon(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
-        cdef complex[::1] temp = self.buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.buffer_1d[1,:]
-        cdef int i, j, k
-        cdef QobjEvo c_op, c_opj
-        cdef complex ddw, tr
-        _zero(out)
-        _zero(temp)
-        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-        for i in range(self.num_ops):
-            c_op = self.sops[i]
-            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
-            c_op = self.preops[i]
-            _zero(temp2)
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-            _axpy(dy[i], temp2, temp)
-
-        k = 0
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                c_op = self.preops2[k]
-                if i == j:
-                    ddw = (dy[i]*dy[j] - dt) *0.5
-                else:
-                    ddw = (dy[i]*dy[j])
-
-                _zero(temp2)
-                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-                _axpy(ddw, temp2, temp)
-                k += 1
-
-        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-        for i in range(self.num_ops):
-            dy[i] = conj(dy[i])
-            c_op = self.postops[i]
-            _zero(temp2)
-            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-            _axpy(dy[i], temp2, out)
-
-        k = 0
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                c_op = self.postops2[k]
-                if i == j:
-                    ddw = (dy[i]*dy[j] - dt) *0.5
-                else:
-                    ddw = (dy[i]*dy[j])
-                _zero(temp2)
-                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-                _axpy(ddw, temp2, out)
-                k += 1
-
-        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        tr = self.expect(out)
-        _zscale(1./tr, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-
-cdef class GenericSSolver(StochasticSolver):
-    """support for user defined system"""
-    cdef object d1_func, d2_func
-
-    def set_data(self, sso):
-        self.l_vec = sso.rho0.shape[0]
-        self.num_ops = len(sso.sops)
-        self.d1_func = sso.d1
-        self.d2_func = sso.d2
-
-
-    cpdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        cdef np.ndarray[complex, ndim=1] in_np
-        cdef np.ndarray[complex, ndim=1] out_np
-        in_np = np.zeros((self.l_vec, ), dtype=complex)
-        copy(rho, in_np)
-        out_np = self.d1_func(t, in_np)
-        _axpy(self.dt, out_np, out) # d1 is += and * dt
-
-    @cython.boundscheck(False)
-    cpdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef np.ndarray[complex, ndim=1] in_np
-        cdef np.ndarray[complex, ndim=2] out_np
-        cdef int i
-        in_np = np.zeros((self.l_vec, ), dtype=complex)
-        copy(rho, in_np)
-        out_np = self.d2_func(t, in_np)
-        for i in range(self.num_ops):
-            copy(out_np[i,:], out[i,:])
diff --git a/qutip/solve/parallel.py b/qutip/solve/parallel.py
deleted file mode 100644
index 36e35b8531..0000000000
--- a/qutip/solve/parallel.py
+++ /dev/null
@@ -1,241 +0,0 @@
-"""
-This function provides functions for parallel execution of loops and function
-mappings, using the builtin Python module multiprocessing.
-"""
-__all__ = ['parallel_map', 'serial_map']
-
-from scipy import array
-import multiprocessing
-from functools import partial
-import os
-import sys
-import signal
-from qutip.settings import settings as qset
-from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
-
-
-if sys.platform == 'darwin':
-    Pool = multiprocessing.get_context('fork').Pool
-else:
-    Pool = multiprocessing.Pool
-
-
-def _task_wrapper(args):
-    try:
-        return args[0](*args[1])
-    except KeyboardInterrupt:
-        os.kill(args[2], signal.SIGINT)
-        sys.exit(1)
-
-
-def _task_wrapper_with_args(args, user_args):
-    try:
-        return args[0](*args[1], **user_args)
-    except KeyboardInterrupt:
-        os.kill(args[2], signal.SIGINT)
-        sys.exit(1)
-
-
-def parfor(func, *args, **kwargs):
-    """Executes a multi-variable function in parallel on the local machine.
-
-    Parallel execution of a for-loop over function `func` for multiple input
-    arguments and keyword arguments.
-
-    .. note::
-
-        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
-        instead of this function.
-
-    Parameters
-    ----------
-    func : function_type
-        A function to run in parallel on the local machine. The function 'func'
-        accepts a series of arguments that are passed to the function as
-        variables. In general, the function can have multiple input variables,
-        and these arguments must be passed in the same order as they are
-        defined in the function definition.  In addition, the user can pass
-        multiple keyword arguments to the function.
-
-    The following keyword argument is reserved:
-
-    num_cpus : int
-        Number of CPU's to use.  Default uses maximum number of CPU's.
-        Performance degrades if num_cpus is larger than the physical CPU
-        count of your machine.
-
-    Returns
-    -------
-    result : list
-        A ``list`` with length equal to number of input parameters
-        containing the output from `func`.
-
-    """
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    kw = _default_kwargs()
-    if 'num_cpus' in kwargs.keys():
-        kw['num_cpus'] = kwargs['num_cpus']
-        del kwargs['num_cpus']
-    if len(kwargs) != 0:
-        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
-    else:
-        task_func = _task_wrapper
-
-    # if kw['num_cpus'] > qset.num_cpus:
-    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
-    #          "is larger than physical number (%s)." % qset.num_cpus)
-    #    print("Reduce 'num_cpus' for greater performance.")
-
-    pool = Pool(processes=kw['num_cpus'])
-    args = [list(arg) for arg in args]
-    var = [[args[j][i] for j in range(len(args))]
-           for i in range(len(list(args[0])))]
-    try:
-        map_args = ((func, v, os.getpid()) for v in var)
-        par_return = list(pool.map(task_func, map_args))
-
-        pool.terminate()
-        pool.join()
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        if isinstance(par_return[0], tuple):
-            par_return = [elem for elem in par_return]
-            num_elems = len(par_return[0])
-            dt = [type(ii) for ii in par_return[0]]
-            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
-                    for ii in range(num_elems)]
-        else:
-            return par_return
-
-    except KeyboardInterrupt:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        pool.terminate()
-
-
-def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-    """
-    Serial mapping function with the same call signature as parallel_map, for
-    easy switching between serial and parallel execution. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    This function work as a drop-in replacement of
-    :func:`qutip.parallel.parallel_map`.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    progress_bar : ProgressBar
-        Progress bar class instance for showing progress.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for each
-        value in ``values``.
-
-    """
-    try:
-        progress_bar = kwargs['progress_bar']
-        if progress_bar is True:
-            progress_bar = TextProgressBar()
-    except:
-        progress_bar = BaseProgressBar()
-
-    progress_bar.start(len(values))
-    results = []
-    for n, value in enumerate(values):
-        progress_bar.update(n)
-        result = task(value, *task_args, **task_kwargs)
-        results.append(result)
-    progress_bar.finished()
-
-    return results
-
-
-def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    progress_bar : ProgressBar
-        Progress bar class instance for showing progress.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``.
-
-    """
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    kw = _default_kwargs()
-    if 'num_cpus' in kwargs:
-        kw['num_cpus'] = kwargs['num_cpus']
-
-    try:
-        progress_bar = kwargs['progress_bar']
-        if progress_bar is True:
-            progress_bar = TextProgressBar()
-    except:
-        progress_bar = BaseProgressBar()
-
-    progress_bar.start(len(values))
-    nfinished = [0]
-
-    def _update_progress_bar(x):
-        nfinished[0] += 1
-        progress_bar.update(nfinished[0])
-
-    try:
-        pool = Pool(processes=kw['num_cpus'])
-
-        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
-                                      _update_progress_bar)
-                     for value in values]
-
-        while not all([ar.ready() for ar in async_res]):
-            for ar in async_res:
-                ar.wait(timeout=0.1)
-
-        pool.terminate()
-        pool.join()
-
-    except KeyboardInterrupt as e:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        pool.terminate()
-        pool.join()
-        raise e
-
-    progress_bar.finished()
-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-    return [ar.get() for ar in async_res]
-
-
-def _default_kwargs():
-
-    settings = {'num_cpus': multiprocessing.cpu_count()}
-    return settings
diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
deleted file mode 100644
index ce770b6801..0000000000
--- a/qutip/solve/stochastic.py
+++ /dev/null
@@ -1,1331 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-import scipy.sparse as sp
-from .. import (
-    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
-    unstack_columns, liouvillian, lindblad_dissipator,
-)
-from ._stochastic import (
-    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
-    GenericSSolver, Solvers
-)
-from .solver import Result, SolverOptions, _solver_safety_check
-from .parallel import serial_map
-from ..ui.progressbar import TextProgressBar
-from qutip.core import data as _data
-
-__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
-           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
-           'stochastic_solvers', 'general_stochastic']
-
-
-def stochastic_solvers():
-    # This docstring contains several literal backslash characters inside LaTeX
-    # blocks, but it cannot be declared as a raw string because we also need to
-    # use a line continuation.  At one point we need a restructured text
-    # "definition list", where the heading _must_ be entirely on one line,
-    # however it will violate our line-length reporting if we do that.
-    """
-    This function is purely a reference point for documenting the available
-    stochastic solver methods, and takes no actions.
-
-    Notes
-    -----
-    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
-        euler-maruyama
-            A simple generalization of the Euler method for ordinary
-            differential equations to stochastic differential equations.  Only
-            solver which could take non-commuting ``sc_ops``. *not tested*
-
-            - Order 0.5
-            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
-
-        milstein
-            An order 1.0 strong Taylor scheme.  Better approximate numerical
-            solution to stochastic differential equations.  See eq. (2.9) of
-            chapter 12.2 of [1]_.
-
-            - Order strong 1.0
-            - Code: ``'milstein'`` or ``1.0``
-
-        milstein-imp
-            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
-            scheme for the numerical simulation of stiff stochastic
-            differential equations.
-
-            - Order strong 1.0
-            - Code: ``'milstein-imp'``
-
-        predictor-corrector
-            Generalization of the trapezoidal method to stochastic differential
-            equations. More stable than explicit methods.  See eq. (5.4) of
-            chapter 15.5 of [1]_.
-
-            - Order strong 0.5, weak 1.0
-            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
-              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
-              ``'pc-euler'``
-            - Codes to correct both the stochastic and deterministic parts
-              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
-              ``'pc-euler-2'`` or ``'pred-corr-2'``
-
-        platen
-            Explicit scheme, creates the Milstein using finite differences
-            instead of analytic derivatives. Also contains some higher order
-            terms, thus converges better than Milstein while staying strong
-            order 1.0.  Does not require derivatives, therefore usable by
-            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
-
-            - Order strong 1.0, weak 2.0
-            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
-
-        rouchon
-            Scheme keeping the positivity of the density matrix
-            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
-
-            - Order strong 1.0?
-            - Code: ``'rouchon'`` or ``'Rouchon'``
-
-        taylor1.5
-            Order 1.5 strong Taylor scheme.  Solver with more terms of the
-            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
-
-            - Order strong 1.5
-            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
-
-        taylor1.5-imp
-            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
-            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
-            (2.18) of chapter 12.2 of [1]_.
-
-            - Order strong 1.5
-            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
-
-        explicit1.5
-            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
-            Taylor scheme using finite difference instead of derivatives.
-            Slower than ``taylor15`` but usable by
-            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
-            [1]_.
-
-            - Order strong 1.5
-            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
-
-        taylor2.0
-            Order 2 strong Taylor scheme.  Solver with more terms of the
-            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
-
-            - Order strong 2.0
-            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
-
-        All solvers, except taylor2.0, are usable in both smesolve and (ssesolve)
-        and for both heterodyne and homodyne. taylor2.0 only works for 1
-        stochastic opera__init__tor independent of time with the homodyne method.
-        :func:`~general_stochastic` only accepts the derivative-free
-        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
-
-    Available solvers for :obj:`~photocurrent_sesolve` and \
-:obj:`~photocurrent_mesolve`
-        Photocurrent use ordinary differential equations between
-        stochastic "jump/collapse".
-
-        euler
-            Euler method for ordinary differential equations between jumps.
-            Only one jump per time interval.  Default solver.  See eqs. (4.19)
-            and (4.4) of chapter 4 of [4]_.
-
-            - Order 1.0
-            - Code: ``'euler'``
-
-        predictor–corrector
-            predictor–corrector method (PECE) for ordinary differential
-            equations.  Uses the Poisson distribution to obtain the number of
-            jumps at each timestep.
-
-            - Order 2.0
-            - Code: ``'pred-corr'``
-
-    References
-    ----------
-    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
-       Stochastic Differential Equations*.
-    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
-       Systems*.
-    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
-       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
-       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
-       (2015).
-    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
-       control*.
-    """
-
-
-class StochasticSolverOptions:
-    """Class of options for stochastic solvers such as
-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
-
-    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
-    :func:`qutip.stochastic.photocurrent_sesolve` and
-    :func:`qutip.stochastic.photocurrent_mesolve`
-    all take the same keyword arguments as
-    the constructor of these class, and internally they use these arguments to
-    construct an instance of this class, so it is rarely needed to explicitly
-    create an instance of this class.
-
-    Within the attribute list, a ``time_dependent_object`` is either
-
-    - :class:`~qutip.Qobj`: a constant term
-    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
-      where the ``Qobj`` will be multiplied by the time-dependent scalar.
-
-    For more details on all allowed time-dependent objects, see the
-    documentation for :class:`~qutip.QobjEvo`.
-
-    Attributes
-    ----------
-    H : time_dependent_object or list of time_dependent_object
-        System Hamiltonian in standard time-dependent list format.  This is the
-        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
-        If this is a list of elements, they are summed.
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix.
-
-    times : array_like of float
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of time_dependent_object
-        List of deterministic collapse operators.  Each element of the list is
-        a separate operator; unlike the Hamiltonian, there is no implicit
-        summation over the terms.
-
-    sc_ops : list of time_dependent_object
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of __init__motion according to how the d1 and d2 functions
-        are defined.  Each element of the list is a separate operator, like
-        ``c_ops``.
-
-    e_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    m_ops : list of :class:`qutip.Qobj`
-        List of operators representing the measurement operators. The expected
-        format is a nested list with one measurement operator for each
-        stochastic increament, for each stochastic collapse operator.
-
-    args : dict
-        Dictionary of parameters for time dependent systems.
-
-    tol : float
-        Tolerance of the solver for implicit methods.
-
-    ntraj : int
-        Number of trajectors.
-
-    nsubsteps : int
-        Number of sub steps between each time-spep given in `times`.
-
-    dW_factors : array
-        Array of length len(sc_ops), containing scaling factors for each
-        measurement operator in m_ops.
-
-    solver : string
-        Name of the solver method to use for solving the stochastic
-        equations. Valid values are:
-
-        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
-        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
-        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
-        - order 2 algorithms: 'taylor2.0'
-
-        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
-        for a description of the solvers.  Implicit methods can adjust
-        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
-
-    method : string ('homodyne', 'heterodyne')
-        The name of the type of measurement process that give rise to the
-        stochastic equation to solve.
-
-    store_all_expect : bool (default False)
-        Whether or not to store the e_ops expect values for all paths.
-
-    store_measurement : bool (default False)
-        Whether or not to store the measurement results in the
-        :class:`qutip.solver.Result` instance returned by the solver.
-
-    noise : int, or 1D array of int, or 4D array of float
-        - int : seed of the noise
-        - 1D array : length = ntraj, seeds for each trajectories.
-        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
-          Vector for the noise, the len of the last dimensions is doubled for
-          solvers of order 1.5. This corresponds to results.noise.
-
-    noiseDepth : int
-        Number of terms kept of the truncated series used to create the
-        noise used by taylor2.0 solver.
-
-    normalize : bool
-        (default True for (photo)ssesolve, False for (photo)smesolve)
-        Whether or not to normalize the wave function during the evolution.
-        Normalizing density matrices introduce numerical errors.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options. Only options['average_states'] and
-        options['store_states'] are used.
-
-    map_func: function
-        A map function or managing the calls to single-trajactory solvers.
-
-    map_kwargs: dictionary
-        Optional keyword arguments to the map_func function function.
-
-    progress_bar : :class:`qutip.ui.BaseProgressBar`
-        Optional progress bar class instance.
-    """
-    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
-                 e_ops=[], m_ops=None, store_all_expect=False,
-                 store_measurement=False, dW_factors=None,
-                 solver=None, method="homodyne", normalize=None,
-                 times=None, nsubsteps=1, ntraj=1, tol=None,
-                 generate_noise=None, noise=None,
-                 progress_bar=None, map_func=None, map_kwargs=None,
-                 args={}, options=None, noiseDepth=20):
-
-        if options is None:
-            options = SolverOptions()
-
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
-        # System
-        # Cast to QobjEvo so the code has only one version for both the
-        # constant and time-dependent case.
-        self.me = me
-
-        if H is not None:
-            msg = "The Hamiltonian format is not valid. "
-            try:
-                self.H = QobjEvo(H, args=args, tlist=times)
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.H = H
-
-        if sc_ops:
-            msg = ("The sc_ops format is not valid. Options are "
-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-            try:
-                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
-                               for op in sc_ops]
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.sc_ops = sc_ops
-
-        if c_ops:
-            msg = ("The c_ops format is not valid. Options are "
-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-            try:
-                self.c_ops = [QobjEvo(op, args=args, tlist=times)
-                              for op in c_ops]
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.c_ops = c_ops
-
-        self.state0 = state0
-        self.rho0 = stack_columns(state0.full()).ravel()
-
-        # Observation
-
-        for e_op in e_ops:
-            if (
-                isinstance(e_op, Qobj)
-                and self.H is not None
-                and e_op.dims[1] != self.H.dims[0]
-            ):
-                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
-                                f"with the system's ({self.H.dims})")
-        self.e_ops = e_ops
-        self.m_ops = m_ops
-        self.store_measurement = store_measurement
-        self.store_all_expect = store_all_expect
-        self.store_states = options['store_states']
-        self.dW_factors = dW_factors
-
-        # Solver
-        self.solver = solver
-        self.method = method
-        if normalize is None and me:
-            self.normalize = 0
-        elif normalize is None and not me:
-            self.normalize = 1
-        elif normalize:
-            self.normalize = 1
-        else:
-            self.normalize = 0
-
-        self.times = times
-        self.nsubsteps = nsubsteps
-        self.dt = (times[1] - times[0]) / self.nsubsteps
-        self.ntraj = ntraj
-        if tol is not None:
-            self.tol = tol
-        elif "tol" in args:
-            self.tol = args["tol"]
-        else:
-            self.tol = 1e-7
-
-        # Noise
-        if noise is not None:
-            if isinstance(noise, int):
-                # noise contain a seed
-                np.random.seed(noise)
-                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-            noise = np.array(noise)
-            if len(noise.shape) == 1:
-                if noise.shape[0] < ntraj:
-                    raise ValueError("'noise' does not have enought seeds " +
-                                     "len(noise) >= ntraj")
-                # numpy seed must be between 0 and 2**32-1
-                # 'u4': unsigned 32bit int
-                self.noise = noise.astype("u4")
-                self.noise_type = 0
-
-            elif len(noise.shape) == 4:
-                # taylor case not included
-                dw_len = (2 if method == "heterodyne" else 1)
-                dw_len_str = (" * 2" if method == "heterodyne" else "")
-                msg = "Incorrect shape for 'noise': "
-                if noise.shape[0] < ntraj:
-                    raise ValueError(msg + "shape[0] >= ntraj")
-                if noise.shape[1] < len(times):
-                    raise ValueError(msg + "shape[1] >= len(times)")
-                if noise.shape[2] < nsubsteps:
-                    raise ValueError(msg + "shape[2] >= nsubsteps")
-                if noise.shape[3] < len(self.sc_ops) * dw_len:
-                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
-                                     dw_len_str)
-                self.noise_type = 1
-                self.noise = noise
-
-        else:
-            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-            self.noise_type = 0
-
-        # Map
-        self.progress_bar = progress_bar
-        if self.ntraj > 1 and map_func:
-            self.map_func = map_func
-        else:
-            self.map_func = serial_map
-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-
-        # Other
-        self.options = options
-        self.args = args
-        self.set_solver()
-        self.p = noiseDepth
-
-    def set_solver(self):
-        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
-            self.solver_code = 50
-            self.solver = 'euler-maruyama'
-        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
-            self.solver_code = 100
-            self.solver = 'platen'
-        elif self.solver in ['pred-corr', 'predictor-corrector',
-                             'pc-euler', "pred_corr", 101]:
-            self.solver_code = 101
-            self.solver = 'pred-corr'
-        elif self.solver in ['milstein', 102, 1.0]:
-            self.solver_code = 102
-            self.solver = 'milstein'
-        elif self.solver in ['milstein-imp', 'milstein_imp', 103]:
-            self.solver_code = 103
-            self.solver = 'milstein-imp'
-        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', "pred_corr_a", 104]:
-            self.solver_code = 104
-            self.solver = 'pred-corr-2'
-        elif self.solver in ['Rouchon', 'rouchon', 120]:
-            self.solver_code = 120
-            self.solver = 'rouchon'
-            if not all((op.isconstant for op in self.sc_ops)):
-                raise ValueError("Rouchon only works with constant sc_ops")
-        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
-            self.solver_code = 150
-            self.solver = 'explicit1.5'
-        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
-            self.solver_code = 152
-            self.solver = 'taylor1.5'
-        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', "taylor15_imp", 153]:
-            self.solver_code = 153
-            self.solver = 'taylor1.5-imp'
-        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
-            self.solver_code = 202
-            self.solver = 'taylor2.0'
-            if not len(self.sc_ops) == 1 or \
-                    not self.sc_ops[0].isconstant or \
-                    not self.method == "homodyne":
-                raise ValueError(
-                    "Taylor2.0 only works with 1 constant sc_ops and for"
-                    " homodyne method"
-                )
-        else:
-            known = [
-                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
-                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
-                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
-            ]
-            raise ValueError("The solver should be one of {!r}".format(known))
-
-
-class StochasticSolverOptionsPhoto(StochasticSolverOptions):
-    """
-    Attributes
-    ----------
-
-    solver : string
-        Name of the solver method to use for solving the evolution
-        of the system.*
-        order 1 algorithms: 'euler'
-        order 2 algorithms: 'pred-corr'
-        In photocurrent evolution
-    """
-    def set_solver(self):
-        if self.solver in [None, 'euler', 1, 60]:
-            self.solver_code = 60
-            self.solver = 'euler'
-        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
-            self.solver_code = 110
-            self.solver = 'pred-corr'
-        else:
-            raise Exception("The solver should be one of " +
-                            "[None, 'euler', 'predictor-corrector']")
-
-
-def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, _dry_run=False, **kwargs):
-    """
-    Solve stochastic master equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    if "method" in kwargs and kwargs["method"] == "photocurrent":
-        print("stochastic solver with photocurrent method has been moved to "
-              "it's own function: photocurrent_mesolve")
-        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
-                                    e_ops=e_ops, _safe_mode=_safe_mode,
-                                    args=args, **kwargs)
-    if isket(rho0):
-        rho0 = ket2dm(rho0)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
-                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-                                  args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    print(sso.solver_code)
-
-    if sso.solver_code == 120:
-        return _positive_map(sso, e_ops_dict, _dry_run)
-
-    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
-    if sso.method == 'homodyne' or sso.method is None:
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sso.m_ops)
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise Exception("The len of dW_factors is not the same as m_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sso.sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
-                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-        elif len(sso.dW_factors) == len(sso.m_ops):
-            pass
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == "photocurrent":
-        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
-
-    else:
-        raise Exception("The method must be one of None, homodyne, heterodyne")
-
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-
-    if sso.solver_code in [103, 153]:
-        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
-
-    sso.solver_obj = SMESolver
-    sso.solver_name = "smesolve_" + sso.solver
-
-    if _dry_run:
-        ssolver = sso.solver_obj()
-        ssolver.set_solver(sso)
-        return ssolver
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, _dry_run=False, **kwargs):
-    """
-    Solve stochastic schrodinger equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    psi0 : :class:`qutip.Qobj`
-        State vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if "method" in kwargs and kwargs["method"] == "photocurrent":
-        print("stochastic solver with photocurrent method has been moved to "
-              "it's own function: photocurrent_sesolve")
-        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
-                                    e_ops=e_ops, _safe_mode=_safe_mode,
-                                    args=args, **kwargs)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
-                                  sc_ops=sc_ops, e_ops=e_ops,
-                                  args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.solver_code == 120:
-        raise Exception("rouchon only work with smesolve")
-
-    if sso.method == 'homodyne' or sso.method is None:
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sso.sops)
-        elif len(sso.dW_factors) != len(sso.sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sso.sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            c1 = c / np.sqrt(2)
-            c2 = c * (-1j / np.sqrt(2))
-            sso.sops += [[c1, c1 + c1.dag()],
-                         [c2, c2 + c2.dag()]]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sso.sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == "photocurrent":
-        NotImplementedError("Moved to 'photocurrent_sesolve'")
-
-    else:
-        raise Exception("The method must be one of None, homodyne, heterodyne")
-
-    sso.LH = sso.H * (-1j * sso.dt)
-    for ops in sso.sops:
-        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
-
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-
-    sso.solver_obj = SSESolver
-    sso.solver_name = "ssesolve_" + sso.solver
-
-    if _dry_run:
-        ssolver = sso.solver_obj()
-        ssolver.set_solver(sso)
-        return ssolver
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def _positive_map(sso, e_ops_dict, _dry_run=False):
-    if sso.method == 'homodyne' or sso.method is None:
-        sops = sso.sc_ops
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sops)
-        elif len(sso.dW_factors) != len(sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sops)
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-    else:
-        raise Exception("The method must be one of homodyne or heterodyne")
-
-    LH = 1 - (sso.H * 1j * sso.dt)
-    sso.pp = spre(sso.H) * 0
-    sso.sops = []
-    sso.preops = []
-    sso.postops = []
-    sso.preops2 = []
-    sso.postops2 = []
-
-    def _prespostdag(op):
-        return spre(op) * spost(op.dag())
-
-    for op in sso.c_ops:
-        LH += op.dag() @ op * (-sso.dt * 0.5)
-        opop = spre(op) * spost(op.dag())
-        sso.pp += opop * sso.dt
-
-    for i, op in enumerate(sops):
-        LH += (-sso.dt * 0.5) * op.dag() @ op
-        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
-        sso.preops += [spre(op)]
-        sso.postops += [spost(op.dag())]
-        for op2 in sops[i:]:
-            sso.preops2 += [spre(op * op2)]
-            sso.postops2 += [spost(op.dag() * op2.dag())]
-
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-    sso.preLH = spre(LH)
-    sso.postLH = spost(LH.dag())
-
-    sso.solver_obj = PmSMESolver
-    sso.solver_name = "smesolve_" + sso.solver
-
-    if _dry_run:
-        ssolver = sso.solver_obj()
-        ssolver.set_solver(sso)
-        return ssolver
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-                         _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic master equation using the photocurrent method.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isket(rho0):
-        rho0 = ket2dm(rho0)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
-                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-                                       args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.m_ops is None:
-        sso.m_ops = [op * 0 for op in sso.sc_ops]
-    if not isinstance(sso.dW_factors, list):
-        sso.dW_factors = [1] * len(sso.sc_ops)
-    elif len(sso.dW_factors) != len(sso.sc_ops):
-        raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    sso.solver_obj = PcSMESolver
-    sso.solver_name = "photocurrent_mesolve"
-    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
-
-    def _prespostdag(op):
-        return spre(op) * spost(op.dag())
-
-    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
-                 spre(op.dag() @ op),
-                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
-                         _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic schrodinger equation using the photocurrent method.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = list(e_ops.values())
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
-                                       sc_ops=sc_ops, e_ops=e_ops,
-                                       args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.m_ops is None:
-        sso.m_ops = [op * 0 for op in sso.sc_ops]
-    if not isinstance(sso.dW_factors, list):
-        sso.dW_factors = [1] * len(sso.sc_ops)
-    elif len(sso.dW_factors) != len(sso.sc_ops):
-        raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    sso.solver_obj = PcSSESolver
-    sso.solver_name = "photocurrent_sesolve"
-    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
-    sso.LH = sso.H * (-1j*sso.dt)
-    for ops in sso.sops:
-        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
-                       _safe_mode=True, len_d2=1, args={}, **kwargs):
-    """
-    Solve stochastic general equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-
-    Parameters
-    ----------
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix as a vector.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    d1 : function, callable class
-        Function representing the deterministic evolution of the system.
-
-        def d1(time (double), state (as a np.array vector)):
-            return 1d np.array
-
-    d2 : function, callable class
-        Function representing the stochastic evolution of the system.
-
-        def d2(time (double), state (as a np.array vector)):
-            return 2d np.array (N_sc_ops, len(state0))
-
-    len_d2 : int
-        Number of output vector produced by d2
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-        Must be a superoperator if the state vector is a density matrix.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    if "solver" not in kwargs:
-        kwargs["solver"] = 50
-
-    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
-                                  e_ops=e_ops, args=args, **kwargs)
-    if sso.solver_code not in [50, 100, 150]:
-        raise ValueError("Only Euler, platen, platen15 can be " +
-                         "used for the general stochastic solver.")
-
-    sso.d1 = d1
-    sso.d2 = d2
-    if _safe_mode:
-        # This state0_vec is computed as stack_columns(state0.full()).ravel()
-        # in the sso init.
-        state0_vec = sso.rho0
-        l_vec = state0_vec.shape[0]
-        try:
-            out_d1 = d1(0., sso.rho0)
-        except Exception as e:
-            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
-                               str(e)) from e
-        try:
-            out_d2 = d2(0., sso.rho0)
-        except Exception as e:
-            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
-                               str(e)) from e
-
-        msg_d1 = ("d1 must return an 1d numpy array with the same number "
-                  "of elements as the initial state as a vector.")
-        if not isinstance(out_d1, np.ndarray):
-            raise TypeError(msg_d1)
-        if (out_d1.ndim != 1
-                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
-            raise ValueError(msg_d1)
-
-        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
-                  "with the shape (len_d2, len(state0_vec) ).")
-        if not isinstance(out_d2, np.ndarray):
-            raise TypeError(msg_d2)
-        if (out_d2.ndim != 2
-                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
-            raise ValueError(msg_d2)
-        if out_d1.dtype != np.dtype('complex128') or \
-           out_d2.dtype != np.dtype('complex128'):
-            raise ValueError("Safety check: d1 and d2 must return " +
-                             "complex numpy array.")
-        msg_e_ops = ("Safety check: The shape of the e_ops "
-                     "does not fit the intial state.")
-        for op in sso.e_ops:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise ValueError(msg_e_ops)
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise ValueError(msg_e_ops +
-                                     " Expecting e_ops as superoperators.")
-
-    sso.m_ops = []
-    sso.cm_ops = []
-    if sso.store_measurement:
-        if not m_ops:
-            raise ValueError("General stochastic needs explicit " +
-                             "m_ops to store measurement.")
-        sso.m_ops = m_ops
-        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-        if sso.dW_factors is None:
-            sso.dW_factors = [1.] * len(sso.m_ops)
-        elif len(sso.dW_factors) == 1:
-            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise ValueError("The number of dW_factors must fit" +
-                             " the number of m_ops.")
-
-    if sso.dW_factors is None:
-        sso.dW_factors = [1.] * len_d2
-    sso.sops = [None] * len_d2
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-
-    sso.solver_obj = GenericSSolver
-    sso.solver_name = "general_stochastic_solver_" + sso.solver
-
-    ssolver = GenericSSolver()
-    # ssolver.set_data(sso)
-    ssolver.set_solver(sso)
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def _safety_checks(sso):
-    l_vec = sso.rho0.shape[0]
-    if sso.H.issuper:
-        if not sso.me:
-            raise ValueError(
-                "Given a Liouvillian for a Schrödinger equation problem."
-            )
-        shape_op = sso.H.shape
-        if shape_op[0] != l_vec or shape_op[1] != l_vec:
-            raise Exception("The size of the hamiltonian does "
-                            "not fit the intial state")
-    else:
-        shape_op = sso.H.shape
-        if sso.me:
-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                raise Exception("The size of the hamiltonian does "
-                                "not fit the intial state")
-        else:
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the hamiltonian does "
-                                "not fit the intial state")
-
-    for op in sso.sc_ops:
-        if op.issuper:
-            if not sso.me:
-                raise ValueError(
-                    "Given a Liouvillian for a Schrödinger equation problem."
-                )
-            shape_op = op.shape
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the sc_ops does "
-                                "not fit the intial state")
-        else:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the sc_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the sc_ops does "
-                                    "not fit the intial state")
-
-    for op in sso.c_ops:
-        if op.issuper:
-            if not sso.me:
-                raise ValueError(
-                    "Given a Liouvillian for a Schrödinger equation problem."
-                )
-            shape_op = op.shape
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the c_ops does "
-                                "not fit the intial state")
-        else:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the c_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the c_ops does "
-                                    "not fit the intial state")
-
-    for op in sso.e_ops:
-        shape_op = op.shape
-        if sso.me:
-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                raise Exception("The size of the e_ops does "
-                                "not fit the intial state")
-        else:
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the e_ops does "
-                                "not fit the intial state")
-
-    if sso.m_ops is not None:
-        for op in sso.m_ops:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the m_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the m_ops does "
-                                    "not fit the intial state")
-
-
-def _sesolve_generic(sso, options, progress_bar):
-    """
-    Internal function. See smesolve.
-    """
-    res = Result()
-    res.times = sso.times
-    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-    res.measurement = []
-    res.solver = sso.solver_name
-    res.ntraj = sso.ntraj
-    res.num_expect = len(sso.e_ops)
-
-    nt = sso.ntraj
-    task = _single_trajectory
-    map_kwargs = {'progress_bar': sso.progress_bar}
-    map_kwargs.update(sso.map_kwargs)
-    task_args = (sso,)
-    task_kwargs = {}
-
-    results = sso.map_func(task, list(range(sso.ntraj)),
-                           task_args, task_kwargs, **map_kwargs)
-    noise = []
-    for result in results:
-        states_list, dW, m, expect = result
-        res.states.append(states_list)
-        noise.append(dW)
-        res.measurement.append(m)
-        res.expect += expect
-        res.ss += expect * expect
-    res.noise = np.stack(noise)
-
-    if sso.store_all_expect:
-        paths_expect = []
-        for result in results:
-            paths_expect.append(result[3])
-        res.runs_expect = np.stack(paths_expect)
-
-    # average density matrices (vectorized maybe)
-    # ajgpitch 2019-10-25: np.any(res.states) seems to error
-    # I guess there may be a potential exception if there are no states?
-    # store individual trajectory states
-    res.traj_states = res.states
-    res.avg_states = None
-    if options['average_states'] and options['store_states']:
-        avg_states_list = []
-        for n in range(len(res.times)):
-            tslot_states = [res.states[mm][n].data for mm in range(nt)]
-            if len(tslot_states) > 0:
-                state = Qobj(np.sum(tslot_states),
-                             dims=res.states[0][n].dims).unit()
-                avg_states_list.append(state)
-        # store average states
-        res.states = res.avg_states = avg_states_list
-
-    # average
-    res.expect = res.expect / nt
-
-    # standard error
-    if nt > 1:
-        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
-    else:
-        res.se = None
-
-    # convert complex data to real if hermitian
-    res.expect = [np.real(res.expect[n, :])
-                  if e.isherm else res.expect[n, :]
-                  for n, e in enumerate(sso.e_ops)]
-
-    return res
-
-
-def _single_trajectory(i, sso):
-    # Only one step?
-    ssolver = sso.solver_obj()
-    ssolver.set_solver(sso)
-    result = ssolver.cy_sesolve_single_trajectory(i)
-    return result

From 8c588ddc47649b2fd6d1c3dfa1bf229603e932f4 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 21 Mar 2023 14:44:11 -0400
Subject: [PATCH 187/602] Docstring fixes

---
 .coveragerc                    | 3 ++-
 doc/apidoc/classes.rst         | 7 +++++++
 doc/apidoc/functions.rst       | 4 ++--
 qutip/core/cy/qobjevo.pxd      | 2 +-
 qutip/solver/multitraj.py      | 6 +++---
 qutip/solver/sode/itotaylor.py | 8 +++-----
 qutip/solver/sode/rouchon.py   | 2 +-
 7 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index a83955cad4..bcb36fe5de 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -4,10 +4,11 @@ omit =
     # QuTiP test files
     */qutip/tests/*
     # Tool for tests
-    */qutip/solver/sode/noise.py
+    */qutip/solver/sode/_noise.py
 
 [report]
 exclude_lines =
     # Skip Python wrappers which help load in C extension modules.
     __bootstrap__()
+    # Skip empty method that are never meant to be used.
     raise NotImplementedError
diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index 2924d329a0..a2e786abe4 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -53,6 +53,13 @@ Solver
 .. autoclass:: qutip.solver.brmesolve.BRSolver
     :members:
 
+.. autoclass:: qutip.solver.stochastic.SMESolver
+    :members:
+
+.. autoclass:: qutip.solver.stochastic.SSESolver
+    :members:
+
+
 
 .. _classes-non_markov_heom:
 
diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index d9bfef677b..cdcda5aae2 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -169,8 +169,8 @@ Floquet States and Floquet-Markov Master Equation
 Stochastic Schrödinger Equation and Master Equation
 ---------------------------------------------------
 
-.. automodule:: qutip.solve.stochastic
-    :members: ssesolve, photocurrent_sesolve, smepdpsolve, smesolve, photocurrent_mesolve, ssepdpsolve, stochastic_solvers, general_stochastic
+.. automodule:: qutip.solver.stochastic
+    :members: ssesolve, smesolve
 
 
 Hierarchical Equations of Motion
diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
index 08e2c320af..07e0d3df7c 100644
--- a/qutip/core/cy/qobjevo.pxd
+++ b/qutip/core/cy/qobjevo.pxd
@@ -5,7 +5,7 @@ from qutip.core.data.base cimport idxint
 
 cdef class QobjEvo:
     cdef:
-        readonly list elements
+        list elements
         readonly list dims
         readonly (idxint, idxint) shape
         readonly str type
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 80444cea36..204178d116 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -6,7 +6,7 @@
 import numpy as np
 from copy import copy
 
-__all__ = ["MultiTrajSolver"]
+__all__ = ["MultiTrajSolver", "TrajectorySolver"]
 
 
 class MultiTrajSolver(Solver):
@@ -28,7 +28,7 @@ class MultiTrajSolver(Solver):
     options : dict
         Options for the solver.
     """
-    name = "stochastic master equation"
+    name = "generic multi trajectory"
     resultclass = MultiTrajResult
     _avail_integrators = {}
 
@@ -40,7 +40,7 @@ class MultiTrajSolver(Solver):
         "store_states": None,
         "keep_runs_results": False,
         "normalize_output": False,
-        "method": "adams",
+        "method": "",
         "map": "serial",
         "job_timeout": None,
         "num_cpus": None,
diff --git a/qutip/solver/sode/itotaylor.py b/qutip/solver/sode/itotaylor.py
index e1f0e0c939..e379cd85f7 100644
--- a/qutip/solver/sode/itotaylor.py
+++ b/qutip/solver/sode/itotaylor.py
@@ -38,8 +38,7 @@ class Milstein_SODE(_Explicit_Simple_Integrator):
 class Taylor1_5_SODE(_Explicit_Simple_Integrator):
     """
     Order 1.5 strong Taylor scheme.  Solver with more terms of the
-    Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-    :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of Peter E. Kloeden and
+    Ito-Taylor expansion. See eq. (4.6) of chapter 10.4 of Peter E. Kloeden and
     Exkhard Platen, *Numerical Solution of Stochastic Differential Equations*.
 
     - Order strong 1.5
@@ -105,9 +104,8 @@ class Implicit_Milstein_SODE(_Implicit_Simple_Integrator):
 
 class Implicit_Taylor1_5_SODE(_Implicit_Simple_Integrator):
     """
-    Order 1.5 strong Taylor scheme.  Solver with more terms of the
-    Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-    :obj:`~ssesolve`.  Eq. (2.18) with alpha=0.5 of chapter 12.2 of
+    Order 1.5 implicit strong Taylor scheme.  Solver with more terms of the
+    Ito-Taylor expansion.  Eq. (2.18) with ``alpha=0.5`` of chapter 12.2 of
     Peter E. Kloeden and Exkhard Platen,
     *Numerical Solution of Stochastic Differential Equations*.
 
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index 795fbdb115..1a728a8c91 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -11,7 +11,7 @@
 
 class RouchonSODE(SIntegrator):
     """
-    Scheme keeping the positivity of the density matrix.
+    Stochastic integration method keeping the positivity of the density matrix.
     See eq. (4) Pierre Rouchon and Jason F. Ralpha,
     *Efficient Quantum Filtering for Quantum Feedback Control*,
     `arXiv:1410.5345 [quant-ph] <https://arxiv.org/abs/1410.5345>`_,

From e6f0b66a03968c198e48991029dcf33543b0a822 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 21 Mar 2023 14:45:56 -0400
Subject: [PATCH 188/602] Add annotate cython files options when installing the
 module

---
 setup.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 80e80c4157..51a3061a5f 100755
--- a/setup.py
+++ b/setup.py
@@ -44,6 +44,13 @@ def process_options():
     options = _determine_user_arguments(options)
     options = _determine_version(options)
     options = _determine_compilation_options(options)
+    options["annotate"] = False
+    if "--annotate" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("--annotate")
+    if "-a" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("-a")
     return options
 
 
@@ -269,7 +276,7 @@ def create_extension_modules(options):
                              extra_compile_args=options['cflags'],
                              extra_link_args=options['ldflags'],
                              language='c++'))
-    return cythonize(out)
+    return cythonize(out, annotate=options["annotate"])
 
 
 def print_epilogue():

From ede8caedd0b4517376c86a652b82c624c68f1cee Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 21 Mar 2023 14:46:44 -0400
Subject: [PATCH 189/602] Roll back some changes

---
 setup.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/setup.py b/setup.py
index 51a3061a5f..80e80c4157 100755
--- a/setup.py
+++ b/setup.py
@@ -44,13 +44,6 @@ def process_options():
     options = _determine_user_arguments(options)
     options = _determine_version(options)
     options = _determine_compilation_options(options)
-    options["annotate"] = False
-    if "--annotate" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("--annotate")
-    if "-a" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("-a")
     return options
 
 
@@ -276,7 +269,7 @@ def create_extension_modules(options):
                              extra_compile_args=options['cflags'],
                              extra_link_args=options['ldflags'],
                              language='c++'))
-    return cythonize(out, annotate=options["annotate"])
+    return cythonize(out)
 
 
 def print_epilogue():

From 413aa792bcd7c0eba2d3a622d4cb386836d092f8 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 21 Mar 2023 15:07:09 -0400
Subject: [PATCH 190/602] Documentation fixes

---
 doc/guide/dynamics/dynamics-stochastic.rst | 2 +-
 qutip/solver/stochastic.py                 | 5 ++++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-stochastic.rst b/doc/guide/dynamics/dynamics-stochastic.rst
index 059f539bbf..b2f943729c 100644
--- a/doc/guide/dynamics/dynamics-stochastic.rst
+++ b/doc/guide/dynamics/dynamics-stochastic.rst
@@ -161,7 +161,7 @@ where :math:`x` is the operator passed using ``m_ops``. The results are availabl
 
     fig, ax = plt.subplots()
     ax.set_title('Stochastic Master Equation - Homodyne Detection')
-    ax.plot(times, np.array(stoc_solution.measurement).mean(axis=0)[:].real,
+    ax.plot(times[1:], np.array(stoc_solution.measurement).mean(axis=0)[0, :].real,
             'r', lw=2, label=r'$J_x$')
     ax.plot(times, stoc_solution.expect[0], 'k', lw=2,
             label=r'$\langle x \rangle$')
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 8fe92bd38d..5df48befeb 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -272,6 +272,7 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
 
             seeds=prev_result.seeds
 
+
     target_tol : {float, tuple, list}, optional
         Target tolerance of the evolution. The evolution will compute
         trajectories until the error on the expectation values is lower than
@@ -279,7 +280,7 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
         given by ``ntraj``. The error is computed using jackknife resampling.
         ``target_tol`` can be an absolute tolerance or a pair of absolute and
         relative tolerance, in that order. Lastly, it can be a list of pairs of
-        (atol, rtol) for each e_ops.
+        ``(atol, rtol)`` for each e_ops.
 
     timeout : float [optional]
         Maximum time for the evolution in second. When reached, no more
@@ -287,6 +288,7 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
 
     options : None / dict
         Dictionary of options for the solver.
+
         - store_final_state : bool, [False]
           Whether or not to store the final state of the evolution in the
           result class.
@@ -408,6 +410,7 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
 
     options : None / dict
         Dictionary of options for the solver.
+
         - store_final_state : bool, [False]
           Whether or not to store the final state of the evolution in the
           result class.

From f328930d82c0923062247074d9712a235b4e1239 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 21 Mar 2023 17:14:08 -0400
Subject: [PATCH 191/602] Add towncrier entry

---
 doc/apidoc/classes.rst                     | 4 ++--
 doc/changes/2131.feature                   | 1 +
 doc/guide/dynamics/dynamics-stochastic.rst | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)
 create mode 100644 doc/changes/2131.feature

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index a2e786abe4..516977ca26 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -141,8 +141,8 @@ Integrator
 
 .. _classes-sode:
 
-Integrator
-----------
+Stochastic Integrator
+---------------------
 
 .. autoclass:: qutip.solver.sode.rouchon.RouchonSODE
     :members: options
diff --git a/doc/changes/2131.feature b/doc/changes/2131.feature
new file mode 100644
index 0000000000..38eeee6577
--- /dev/null
+++ b/doc/changes/2131.feature
@@ -0,0 +1 @@
+Rewrite the stochastic solver to use the v5 solver interface.
diff --git a/doc/guide/dynamics/dynamics-stochastic.rst b/doc/guide/dynamics/dynamics-stochastic.rst
index b2f943729c..faa2baf9a4 100644
--- a/doc/guide/dynamics/dynamics-stochastic.rst
+++ b/doc/guide/dynamics/dynamics-stochastic.rst
@@ -145,7 +145,7 @@ where :math:`x` is the operator passed using ``m_ops``. The results are availabl
     # operators
     a = qutip.destroy(DIM)
     x = a + a.dag()
-    H = DELTA * a.dag()* a
+    H = DELTA * a.dag() * a
 
     rho_0 = qutip.coherent(DIM, np.sqrt(INTENSITY))
     times = np.arange(0, 1, 0.0025)

From 3a75217a076361fdb12f6fd6a07f576e2ef1c4a7 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 11:35:47 +0100
Subject: [PATCH 192/602] Add support for empty op matrices to
 _from_csr_blocks.

---
 qutip/core/data/csr.pyx | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index f40f2c8c6c..d4ff30b598 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -877,7 +877,7 @@ cpdef CSR _from_csr_blocks(
 
     n_blocks : base.idxint
         Number of blocks. The shape of the final matrix is
-        (N * block, N * block).
+        (n_blocks * block, n_blocks * block).
 
     block_size : base.idxint
         Size of each block. The shape of matrices in ``block_ops`` is
@@ -945,8 +945,13 @@ cpdef CSR _from_csr_blocks(
         row_pos = row_idx * block_size
         for op_row in range(block_size):
             for i in range(prev_op_idx, op_idx):
-                col_idx = block_cols[i]
                 op = block_ops[i]
+                if nnz(op) == 0:
+                    # empty CSR matrices have uninitialized row_index entries.
+                    # it's unclear whether users should ever see such matrixes
+                    # but we support them here anyway.
+                    continue
+                col_idx = block_cols[i]
                 col_pos = col_idx * block_size
                 op_row_start = op.row_index[op_row]
                 op_row_end = op.row_index[op_row + 1]

From 964a989841448464ccde760add2724c9edde5a6e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 11:36:37 +0100
Subject: [PATCH 193/602] Add tests for _from_csr_blocks.

---
 qutip/tests/core/data/test_csr.py | 99 +++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
index 351edff98c..d650018e57 100644
--- a/qutip/tests/core/data/test_csr.py
+++ b/qutip/tests/core/data/test_csr.py
@@ -343,6 +343,105 @@ def test_one_element_error(self, shape, position, value):
                                          " out of bound: ")
 
 
+class TestFromCSRBlocks:
+    class _blocks:
+        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
+            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
+            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
+            if isinstance(ops, int):
+                ops = [csr.empty(block_size, block_size, 0)] * ops
+            self.ops = np.array(ops, dtype=object)
+            self.n_blocks = n_blocks
+            self.block_size = block_size
+
+        def from_csr_blocks(self):
+            return csr._from_csr_blocks(
+                self.rows, self.cols, self.ops,
+                self.n_blocks, self.block_size,
+            )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
+        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
+    ])
+    def test_input_length_error(self, blocks):
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "The arrays block_rows, block_cols and block_ops should have"
+            " the same length."
+        )
+
+    def test_op_shape_error(self):
+        blocks = self._blocks(
+            (0, 1), (0, 1),
+            (csr.empty(2, 2, 0), csr.empty(3, 3, 0)),
+        )
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "Block operators (block_ops) do not have the correct shape."
+        )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
+        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
+        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
+    ])
+    def test_op_ordering_error(self, blocks):
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "The arrays block_rows and block_cols must be sorted"
+            " by (row, column)."
+        )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((), (), ()), id='no ops'),
+        pytest.param(_blocks((0, 1), (1, 0), 2), id='empty ops'),
+    ])
+    def test_empty_output_fast_paths(self, blocks):
+        out = blocks.from_csr_blocks()
+        assert out == csr.empty(2 * 2, 2 * 2, 0)
+        assert csr.nnz(out) == 0
+
+    def test_construct_identity_with_empty(self):
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                csr.identity(2), csr.empty(2, 2, 0),
+                csr.empty(2, 2, 0), csr.identity(2),
+            ],
+        )
+        out = blocks.from_csr_blocks()
+        assert out == csr.identity(4)
+        assert csr.nnz(out) == 4
+
+    def test_construct_identity_with_zeros(self):
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                csr.identity(2), csr.zeros(2, 2),
+                csr.zeros(2, 2), csr.identity(2),
+            ],
+        )
+        out = blocks.from_csr_blocks()
+        assert out == csr.identity(4)
+        assert csr.nnz(out) == 4
+
+    def test_construct_kron(self):
+        A = np.array([[1, 2], [3, 4]])
+        B = np.array([[0.3, 0.35], [0.4, 0.45]])
+        B_op = data.to("csr", data.Dense(A))
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                A[0, 0] * B_op, A[0, 1] * B_op,
+                A[1, 0] * B_op, A[1, 1] * B_op,
+            ]
+        )
+        out = blocks.from_csr_blocks()
+        assert out == data.kron(data.Dense(A), data.Dense(A))
+        assert csr.nnz(out) == 16
+
+
 def test_tidyup():
     small = qeye(1) * 1e-5
     with CoreOptions(auto_tidyup_atol=1e-3):

From 426ad4b9a1da823441324cd0ea4123ee7d4963a1 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 11:37:49 +0100
Subject: [PATCH 194/602] Correctly use matrix B in _from_csr_blocks kron test.

---
 qutip/tests/core/data/test_csr.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
index d650018e57..237f194754 100644
--- a/qutip/tests/core/data/test_csr.py
+++ b/qutip/tests/core/data/test_csr.py
@@ -430,7 +430,7 @@ def test_construct_identity_with_zeros(self):
     def test_construct_kron(self):
         A = np.array([[1, 2], [3, 4]])
         B = np.array([[0.3, 0.35], [0.4, 0.45]])
-        B_op = data.to("csr", data.Dense(A))
+        B_op = data.to("csr", data.Dense(B))
         blocks = self._blocks(
             [0, 0, 1, 1], [0, 1, 0, 1], [
                 A[0, 0] * B_op, A[0, 1] * B_op,
@@ -438,7 +438,7 @@ def test_construct_kron(self):
             ]
         )
         out = blocks.from_csr_blocks()
-        assert out == data.kron(data.Dense(A), data.Dense(A))
+        assert out == data.kron(data.Dense(A), data.Dense(B))
         assert csr.nnz(out) == 16
 
 

From 25d2a7f6844c7d0c80fc60154a1141757c943a8a Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 12:04:56 +0100
Subject: [PATCH 195/602] Fix HEOM RHS dims to be consistent in the
 time-dependent and independent cases.

---
 qutip/solver/heom/bofin_solvers.py | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 5a84e69e8e..7e523b99bc 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -835,15 +835,17 @@ def _rhs(self):
 
     def _calculate_rhs(self):
         """ Make the full RHS required by the solver. """
+        rhs_mat = self._rhs()
+        rhs_dims = [
+            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
+        ]
         h_identity = _data.identity(self._n_ados, dtype="csr")
 
         if self.L_sys.isconstant:
-            rhs_mat = self._rhs()
+            # For the constant case, we just add the Liouvillian to the
+            # diagonal blocks of the RHS matrix.
             rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
-
-            rhs = QobjEvo(Qobj(rhs_mat, dims=[
-                self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
-            ]))
+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
         else:
             # In the time dependent case, we construct the parameters
             # for the ODE gradient function under the assumption that
@@ -854,23 +856,23 @@ def _calculate_rhs(self):
             # This assumption holds because only _grad_n dependents on
             # the system Liouvillian (and not _grad_prev or _grad_next) and
             # the bath coupling operators are not time-dependent.
-            #
-            # By calling _rhs(None) we omit the Liouvillian completely from
-            # the RHS and then manually add back the Liouvillian afterwards.
-            rhs_mat = self._rhs()
-            rhs = QobjEvo(Qobj(rhs_mat))
-            h_identity = _data.identity(self._n_ados, dtype="csr")
+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
 
             def _kron(x):
-                return Qobj(_data.kron(h_identity, x.data)).to("csr")
+                return Qobj(
+                    _data.kron(h_identity, x.data),
+                    dims=rhs_dims,
+                ).to("csr")
+
             rhs += self.L_sys.linear_map(_kron)
 
         # The assertion that rhs_mat has data type CSR is just a sanity
         # check on the RHS creation. The base solver class will still
         # convert the RHS to the type required by the ODE integrator if
-        # required.
+        # needed.
         assert isinstance(rhs_mat, _csr.CSR)
         assert isinstance(rhs, QobjEvo)
+        assert rhs.dims == rhs_dims
 
         return rhs
 

From 46ffa0aa2b0a1a80b957daa319a1fefb71dbdb0c Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 12:20:08 +0100
Subject: [PATCH 196/602] Improve performance of ADOs.idx.

---
 qutip/solver/heom/bofin_solvers.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 7e523b99bc..a0d6e50d30 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -119,6 +119,7 @@ def __init__(self, exponents, max_depth):
 
         self.labels = list(state_number_enumerate(self.dims, max_depth))
         self._label_idx = {s: i for i, s in enumerate(self.labels)}
+        self.idx = self._label_idx.__getitem__
 
     def idx(self, label):
         """
@@ -134,6 +135,13 @@ def idx(self, label):
         -------
         int
             The index of the label within the list of ADO labels.
+
+        Note
+        ----
+        This implementation of the ``.idx(...)`` method is just for
+        reference and documentation. To avoid the cost of a Python
+        function call, it is replaced with
+        ``self._label_idx.__getitem__`` when the instance is created.
         """
         return self._label_idx[label]
 
@@ -810,10 +818,8 @@ def _grad_next_fermionic(self, he_n, k):
 
     def _rhs(self):
         """ Make the RHS for the HEOM. """
-        # XXX: TODO -- make this an explicit function
-        f_idx = self.ados._label_idx.__getitem__
         ops = _GatherHEOMRHS(
-            f_idx, block=self._sup_shape, nhe=self._n_ados
+            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
         )
 
         for he_n in self.ados.labels:

From a7231d7871623c7dc058e32aa9cd47542ba5b622 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 12:20:30 +0100
Subject: [PATCH 197/602] Remove debugging breakpoint.

---
 qutip/solver/heom/bofin_solvers.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index a0d6e50d30..b2a94acc17 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -825,8 +825,6 @@ def _rhs(self):
         for he_n in self.ados.labels:
             op = self._grad_n(he_n)
             ops.add_op(he_n, he_n, op)
-            if isinstance(op, _data.Dense):
-                breakpoint()
             for k in range(len(self.ados.dims)):
                 next_he = self.ados.next(he_n, k)
                 if next_he is not None:

From 55263ef6aeea907bbff61f65519be3bf90a1736d Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 12:45:25 +0100
Subject: [PATCH 198/602] Add towncrier entry.

---
 doc/changes/2128.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2128.feature

diff --git a/doc/changes/2128.feature b/doc/changes/2128.feature
new file mode 100644
index 0000000000..832155250b
--- /dev/null
+++ b/doc/changes/2128.feature
@@ -0,0 +1 @@
+Speed up the construction of the RHS of the HEOM solver by a factor of 4x by converting the final step to Cython.

From 175169916c5c8e97bbee5e9c1fa3e76c7bbde858 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 22 Mar 2023 10:33:09 -0400
Subject: [PATCH 199/602] Move check in it's function

---
 setup.py | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/setup.py b/setup.py
index 51a3061a5f..0bf5b8def4 100755
--- a/setup.py
+++ b/setup.py
@@ -44,13 +44,7 @@ def process_options():
     options = _determine_user_arguments(options)
     options = _determine_version(options)
     options = _determine_compilation_options(options)
-    options["annotate"] = False
-    if "--annotate" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("--annotate")
-    if "-a" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("-a")
+    options = _determine_cythonize_options(options)
     return options
 
 
@@ -138,6 +132,17 @@ def _determine_compilation_options(options):
     return options
 
 
+def _determine_cythonize_options(options):
+    options["annotate"] = False
+    if "--annotate" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("--annotate")
+    if "-a" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("-a")
+    return options
+
+
 def _determine_version(options):
     """
     Adds the 'short_version', 'version' and 'release' options.

From 6472ed8d59ca6ec3dfce9ee29110972a1558a72a Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 17:02:22 +0100
Subject: [PATCH 200/602] Test _from_csr_blocks against zero CSR matrices
 rather than empty ones in most cases.

---
 qutip/tests/core/data/test_csr.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
index 237f194754..834c9febdb 100644
--- a/qutip/tests/core/data/test_csr.py
+++ b/qutip/tests/core/data/test_csr.py
@@ -349,7 +349,7 @@ def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
             self.rows = np.array(rows, dtype=data.base.idxint_dtype)
             self.cols = np.array(cols, dtype=data.base.idxint_dtype)
             if isinstance(ops, int):
-                ops = [csr.empty(block_size, block_size, 0)] * ops
+                ops = [csr.zeros(block_size, block_size)] * ops
             self.ops = np.array(ops, dtype=object)
             self.n_blocks = n_blocks
             self.block_size = block_size
@@ -375,7 +375,7 @@ def test_input_length_error(self, blocks):
     def test_op_shape_error(self):
         blocks = self._blocks(
             (0, 1), (0, 1),
-            (csr.empty(2, 2, 0), csr.empty(3, 3, 0)),
+            (csr.zeros(2, 2), csr.zeros(3, 3)),
         )
         with pytest.raises(ValueError) as exc:
             blocks.from_csr_blocks()
@@ -398,14 +398,18 @@ def test_op_ordering_error(self, blocks):
 
     @pytest.mark.parametrize(['blocks'], [
         pytest.param(_blocks((), (), ()), id='no ops'),
-        pytest.param(_blocks((0, 1), (1, 0), 2), id='empty ops'),
+        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
     ])
-    def test_empty_output_fast_paths(self, blocks):
+    def test_zeros_output_fast_paths(self, blocks):
         out = blocks.from_csr_blocks()
-        assert out == csr.empty(2 * 2, 2 * 2, 0)
+        assert out == csr.zeros(2 * 2, 2 * 2)
         assert csr.nnz(out) == 0
 
     def test_construct_identity_with_empty(self):
+        # users are not expected to be exposed to
+        # csr.empty directly, but it is good to
+        # avoid segfaults, so we test passing
+        # csr.empty(..) blocks here explicitly
         blocks = self._blocks(
             [0, 0, 1, 1], [0, 1, 0, 1], [
                 csr.identity(2), csr.empty(2, 2, 0),

From d01243e474c28684e0705dd0418c7f0218757b89 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 17:06:55 +0100
Subject: [PATCH 201/602] Return csr.zeros() rather than csr.empty() in fast
 paths -- empty CSR matrices do not yet have valid row_index entries.

---
 qutip/core/data/csr.pyx | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index d4ff30b598..6cf30b06e6 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -897,6 +897,9 @@ cpdef CSR _from_csr_blocks(
             " the same length."
         )
 
+    if n_ops == 0:
+        return zeros(shape, shape)
+
     # check op shapes and calculate nnz
     for op in block_ops:
         nnz_ += nnz(op)
@@ -905,10 +908,6 @@ cpdef CSR _from_csr_blocks(
                 "Block operators (block_ops) do not have the correct shape."
             )
 
-    cdef CSR out = empty(shape, shape, nnz_)
-    if n_ops == 0:
-        return out
-
     # check ops are ordered by (row, column)
     row_idx = block_rows[0]
     col_idx = block_cols[0]
@@ -925,8 +924,9 @@ cpdef CSR _from_csr_blocks(
         col_idx = block_cols[i]
 
     if nnz_ == 0:
-        return out
+        return zeros(shape, shape)
 
+    cdef CSR out = empty(shape, shape, nnz_)
     cdef base.idxint op_idx = 0
     cdef base.idxint prev_op_idx = 0
     cdef base.idxint end = 0

From 6348d1a0b33a6c1af0572da117800ae72b7226e3 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 17:16:40 +0100
Subject: [PATCH 202/602] Use CSR as the dtype of the temporary ops array in
 gather.

---
 qutip/solver/heom/bofin_solvers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index b2a94acc17..8ad5668548 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1308,7 +1308,7 @@ def gather(self):
         ops = np.array(self._ops, dtype=[
             ("row", _data.base.idxint_dtype),
             ("col", _data.base.idxint_dtype),
-            ("op", object),
+            ("op", _data.CSR),
         ])
         return _csr._from_csr_blocks(
             ops["row"], ops["col"], ops["op"],

From 6bdef9105882765c20e4c7ce977b3eaaa0e1d044 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 17:50:05 +0100
Subject: [PATCH 203/602] Add Monte Carlo solvers to the API class
 documentation.

---
 doc/apidoc/classes.rst | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index 052faef01e..954179959d 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -41,8 +41,8 @@ Distributions
 
 .. _classes-solver:
 
-Solver
-------
+Solvers
+-------
 
 .. autoclass:: qutip.solver.sesolve.SESolver
     :members:
@@ -54,6 +54,18 @@ Solver
     :members:
 
 
+.. _classes-monte-carlo-solver:
+
+Monte Carlo Solvers
+-------------------
+
+.. autoclass:: qutip.solver.mcsolve.MCSolver
+    :members:
+
+.. autoclass:: qutip.solver.nm_mcsolve.NonMarkovianMCSolver
+    :members:
+
+
 .. _classes-non_markov_heom:
 
 Non-Markovian HEOM Solver

From 58f82aa3eced7396ef36611ffb700a70b4f575bb Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Wed, 22 Mar 2023 18:05:18 +0100
Subject: [PATCH 204/602] Document that the RHS of the HEOMSolver has an
 underlying sparse representation.

---
 qutip/solver/heom/bofin_solvers.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 8ad5668548..740c2d5d0c 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -580,6 +580,12 @@ class HEOMSolver(Solver):
     ados : :obj:`HierarchyADOs`
         The description of the hierarchy constructed from the given bath
         and maximum depth.
+
+    rhs : :obj:`QobjEvo`
+        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
+        the system and bath coupling operators are converted to
+        :class:`qutip.data.CSR` instances during construction of the RHS,
+        so the operators in the ``rhs`` will all be sparse.
     """
 
     name = "heomsolver"

From fe439d1453c1158008bf47a47a51ecf38dde56ea Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 22 Mar 2023 13:09:36 -0400
Subject: [PATCH 205/602] Fix some style issue

---
 qutip/solver/sode/_noise.py           |  34 +++++----
 qutip/solver/sode/sode.py             |  12 +--
 qutip/solver/stochastic.py            | 103 +++++++++++++-------------
 qutip/tests/solver/test_stochastic.py |   4 +-
 4 files changed, 82 insertions(+), 71 deletions(-)

diff --git a/qutip/solver/sode/_noise.py b/qutip/solver/sode/_noise.py
index 5cd0a05a88..ab5993c8b9 100644
--- a/qutip/solver/sode/_noise.py
+++ b/qutip/solver/sode/_noise.py
@@ -2,10 +2,12 @@
 
 __all__ = []
 
+
 class _Noise:
     """
     Weiner process generator used for tests.
     """
+
     def __init__(self, T, dt, num=1):
         N = int(np.round(T / dt))
         self.T = T
@@ -17,19 +19,22 @@ def dw(self, dt):
         """
         Ito integral I(i).
         """
-        N = int(np.round(dt /self.dt))
+        N = int(np.round(dt / self.dt))
         return self.noise.reshape(-1, N, self.num).sum(axis=1)
 
     def dz(self, dt):
         """
         Ito integral I(0, i).
         """
-        N = int(np.round(dt /self.dt))
-        return np.einsum(
-            "ijk,j->ik",
-            self.noise.reshape(-1, N, self.num),
-            np.arange(N-0.5, 0, -1)
-        ) * self.dt
+        N = int(np.round(dt / self.dt))
+        return (
+            np.einsum(
+                "ijk,j->ik",
+                self.noise.reshape(-1, N, self.num),
+                np.arange(N - 0.5, 0, -1),
+            )
+            * self.dt
+        )
 
     def dW(self, dt):
         """
@@ -38,12 +43,15 @@ def dW(self, dt):
         N = int(np.round(dt / self.dt))
         noise = self.noise.copy()
         if noise.shape[0] % N:
-            noise = noise[:-(noise.shape[0] % N)]
+            noise = noise[: -(noise.shape[0] % N)]
         out = np.empty((noise.shape[0] // N, 2, self.num), dtype=float)
         out[:, 0, :] = noise.reshape(-1, N, self.num).sum(axis=1)
-        out[:, 1, :] = np.einsum(
-            "ijk,j->ik",
-            self.noise.reshape(-1, N, self.num),
-            np.arange(N-0.5, 0, -1)
-        ) * self.dt
+        out[:, 1, :] = (
+            np.einsum(
+                "ijk,j->ik",
+                self.noise.reshape(-1, N, self.num),
+                np.arange(N - 0.5, 0, -1),
+            )
+            * self.dt
+        )
         return out
diff --git a/qutip/solver/sode/sode.py b/qutip/solver/sode/sode.py
index 31e5c5f94b..94b04409a5 100644
--- a/qutip/solver/sode/sode.py
+++ b/qutip/solver/sode/sode.py
@@ -44,6 +44,7 @@ class SIntegrator(Integrator):
         keys, not the full options object passed to the solver. Options' keys
         included here will be supported by the :cls:SolverOdeOptions.
     """
+
     def set_state(self, t, state0, generator):
         """
         Set the state of the SODE solver.
@@ -88,7 +89,6 @@ def integrate(self, t, copy=True):
         """
         raise NotImplementedError
 
-
     def mcstep(self, t, copy=True):
         raise NotImplementedError
 
@@ -97,6 +97,7 @@ class _Explicit_Simple_Integrator(SIntegrator):
     """
     Stochastic evolution solver
     """
+
     integrator_options = {
         "dt": 0.001,
         "tol": 1e-10,
@@ -111,7 +112,7 @@ def __init__(self, rhs, options):
         self.step_func = self.stepper(self.system).run
 
     def integrate(self, t, copy=True):
-        delta_t = (t - self.t)
+        delta_t = t - self.t
         if delta_t < 0:
             raise ValueError("Stochastic integration time")
         elif delta_t == 0:
@@ -125,9 +126,7 @@ def integrate(self, t, copy=True):
             N += 1
             dt = delta_t / N
         dW = self.generator.normal(
-            0,
-            np.sqrt(dt),
-            size=(N, self.N_dw, self.system.num_collapse)
+            0, np.sqrt(dt), size=(N, self.N_dw, self.system.num_collapse)
         )
 
         self.state = self.step_func(self.t, self.state, dt, dW, N)
@@ -157,6 +156,7 @@ class _Implicit_Simple_Integrator(_Explicit_Simple_Integrator):
     """
     Stochastic evolution solver
     """
+
     integrator_options = {
         "dt": 0.001,
         "tol": 1e-10,
@@ -213,6 +213,7 @@ class PlatenSODE(_Explicit_Simple_Integrator):
 
     - Order: strong 1, weak 2
     """
+
     stepper = _sode.Platen
     N_dw = 1
 
@@ -232,6 +233,7 @@ class PredCorr_SODE(_Explicit_Simple_Integrator):
       (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
       ``'pc-euler-2'`` or ``'pred-corr-2'``
     """
+
     integrator_options = {
         "dt": 0.001,
         "tol": 1e-10,
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 5df48befeb..e315dd6831 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -3,7 +3,7 @@
 from .sode.ssystem import *
 from .result import MultiTrajResult, Result, ExpectOp
 from .multitraj import MultiTrajSolver
-from ..import Qobj, QobjEvo, liouvillian, lindblad_dissipator
+from .. import Qobj, QobjEvo, liouvillian, lindblad_dissipator
 import numpy as np
 from collections.abc import Iterable
 from functools import partial
@@ -19,17 +19,14 @@ def _post_init(self, m_ops=(), dw_factor=(), heterodyne=False):
         self.heterodyne = heterodyne
         for op in m_ops:
             f = self._e_op_func(op)
-            self.W.append([0.])
+            self.W.append([0.0])
             self.m_expect.append([])
             self.m_ops.append(ExpectOp(op, f, self.m_expect[-1].append))
             self.add_processor(self.m_ops[-1]._store)
 
     def add(self, t, state, noise):
         super().add(t, state)
-        if (
-            noise is not None
-            and self.options['store_measurement']
-        ):
+        if noise is not None and self.options["store_measurement"]:
             for i, dW in enumerate(noise):
                 self.W[i].append(self.W[i][-1] + dW)
 
@@ -78,7 +75,9 @@ def measurement(self):
         """
         dts = np.diff(self.times)
         m_expect = np.array(self.m_expect)[:, 1:]
-        noise = np.einsum("i,ij,j->ij", self.dW_factor, np.diff(self.W, axis=1), (1/dts))
+        noise = np.einsum(
+            "i,ij,j->ij", self.dW_factor, np.diff(self.W, axis=1), (1 / dts)
+        )
         if self.heterodyne:
             m_expect = m_expect.reshape(-1, 2, m_expect.shape[1])
             noise = noise.reshape(-1, 2, noise.shape[1])
@@ -89,11 +88,13 @@ class StochasticResult(MultiTrajResult):
     def _post_init(self):
         super()._post_init()
 
-        store_measurement = self.options['store_measurement']
-        keep_runs = self.options['keep_runs_results']
+        store_measurement = self.options["store_measurement"]
+        keep_runs = self.options["keep_runs_results"]
 
         if not keep_runs and store_measurement:
-            self.add_processor(partial(self._reduce_attr, attr="wiener_process"))
+            self.add_processor(
+                partial(self._reduce_attr, attr="wiener_process")
+            )
             self._wiener_process = []
             self.add_processor(partial(self._reduce_attr, attr="dW"))
             self._dW = []
@@ -115,7 +116,7 @@ def _trajectories_attr(self, attr):
         """
         if hasattr(self, "_" + attr):
             return getattr(self, "_" + attr)
-        elif self.options['keep_runs_results']:
+        elif self.options["keep_runs_results"]:
             return np.array([
                 getattr(traj, attr) for traj in self.trajectories
             ])
@@ -174,6 +175,7 @@ class _StochasticRHS:
     the rouchon integrator need the part but does not use the usual drift and
     diffusion computation.
     """
+
     def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
 
         if not isinstance(H, (Qobj, QobjEvo)) or not H.isoper:
@@ -212,15 +214,17 @@ def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
     def __call__(self, options):
         if self.issuper:
             return StochasticOpenSystem(
-                self.H , self.sc_ops, self.c_ops, options.get("dt", 1.-6)
+                self.H, self.sc_ops, self.c_ops, options.get("dt", 1.0 - 6)
             )
         else:
-            return StochasticClosedSystem(self.H , self.sc_ops)
+            return StochasticClosedSystem(self.H, self.sc_ops)
 
 
-def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
-             args={}, ntraj=500, options=None, heterodyne=False,
-             seeds=None, target_tol=None, timeout=None):
+def smesolve(
+    H, rho0, tlist, c_ops=(), sc_ops=(), heterodyne=False, *,
+    e_ops=(), args={}, ntraj=500, options=None,
+    seeds=None, target_tol=None, timeout=None,
+):
     """
     Solve stochastic master equation.
 
@@ -250,11 +254,6 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
         Callable signature must be, `f(t: float, state: Qobj)`.
         See :func:`expect` for more detail of operator expectation.
 
-    m_ops : list of :class:`qutip.Qobj`
-        List of measurements operators, when not provided, they are computed
-        from the sc_ops according to whether homodyne or heterodyne detection
-        is used.
-
     args : None / *dictionary*
         Dictionary of parameters for time-dependent Hamiltonians and
         collapse operators.
@@ -337,17 +336,20 @@ def smesolve(H, rho0, tlist, c_ops=(), sc_ops=(), e_ops=(), m_ops=(),
     H = QobjEvo(H, args=args, tlist=tlist)
     c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
     sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
-    sol = SMESolver(H, sc_ops, c_ops=c_ops,
-                    options=options, heterodyne=heterodyne)
-    if m_ops:
-        sol.m_ops = m_ops
-    return sol.run(rho0, tlist, ntraj, e_ops=e_ops,
-                   seed=seeds, target_tol=target_tol, timeout=timeout)
-
-
-def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
-             args={}, ntraj=500, options=None, heterodyne=False,
-             seeds=None, target_tol=None, timeout=None):
+    sol = SMESolver(
+        H, sc_ops, c_ops=c_ops, options=options, heterodyne=heterodyne
+    )
+    return sol.run(
+        rho0, tlist, ntraj, e_ops=e_ops,
+        seed=seeds, target_tol=target_tol, timeout=timeout,
+    )
+
+
+def ssesolve(
+    H, psi0, tlist, sc_ops=(), heterodyne=False, *,
+    e_ops=(), args={}, ntraj=500, options=None,
+    seeds=None, target_tol=None, timeout=None,
+):
     """
     Solve stochastic Schrodinger equation.
 
@@ -373,11 +375,6 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
         Callable signature must be, `f(t: float, state: Qobj)`.
         See :func:`expect` for more detail of operator expectation.
 
-    m_ops : list of :class:`qutip.Qobj`
-        List of measurements operators, when not provided, they are computed
-        from the sc_ops according to whether homodyne or heterodyne detection
-        is used.
-
     args : None / *dictionary*
         Dictionary of parameters for time-dependent Hamiltonians and
         collapse operators.
@@ -458,16 +455,17 @@ def ssesolve(H, psi0, tlist, sc_ops=(), e_ops=(), m_ops=(),
     H = QobjEvo(H, args=args, tlist=tlist)
     sc_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in sc_ops]
     sol = SSESolver(H, sc_ops, options=options, heterodyne=heterodyne)
-    if m_ops:
-        sol.m_ops = m_ops
-    return sol.run(psi0, tlist, ntraj, e_ops=e_ops,
-                   seed=seeds, target_tol=target_tol, timeout=timeout)
+    return sol.run(
+        psi0, tlist, ntraj, e_ops=e_ops,
+        seed=seeds, target_tol=target_tol, timeout=timeout,
+    )
 
 
 class StochasticSolver(MultiTrajSolver):
     """
     Generic stochastic solver.
     """
+
     name = "StochasticSolver"
     resultclass = StochasticResult
     _avail_integrators = {}
@@ -499,9 +497,7 @@ def __init__(self, H, sc_ops, heterodyne, *, c_ops=(), options=None):
         if heterodyne:
             self._m_ops = []
             for op in sc_ops:
-                self._m_ops += [
-                    op + op.dag(), -1j * (op - op.dag())
-                ]
+                self._m_ops += [op + op.dag(), -1j * (op - op.dag())]
             self._dW_factors = np.ones(len(sc_ops) * 2) * 0.5**0.5
         else:
             self._m_ops = [op + op.dag() for op in sc_ops]
@@ -556,8 +552,10 @@ def m_ops(self, new_m_ops):
             isinstance(op, Qobj) and op.dims == self.rhs.sc_ops[0].dims
             for op in new_m_ops
         ):
-            raise ValueError("m_ops must be Qobj with the same dimensions"
-                             " as the Hamiltonian")
+            raise ValueError(
+                "m_ops must be Qobj with the same dimensions"
+                " as the Hamiltonian"
+            )
         self._m_ops = new_m_ops
 
     @property
@@ -588,8 +586,11 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         Run one trajectory and return the result.
         """
         result = StochasticTrajResult(
-            e_ops, self.options, m_ops=self.m_ops, dw_factor=self.dW_factors,
-            heterodyne=self.heterodyne
+            e_ops,
+            self.options,
+            m_ops=self.m_ops,
+            dw_factor=self.dW_factors,
+            heterodyne=self.heterodyne,
         )
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator)
@@ -630,9 +631,9 @@ def options(self):
             brownian noise for each trajectories.
 
         progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error if
-            not installed. Empty string or False will disable the bar.
+            How to present the solver progress. 'tqdm' uses the python module
+            of the same name and raise an error if not installed. Empty string
+            or False will disable the bar.
 
         progress_kwargs: dict, default={"chunk_size":10}
             Arguments to pass to the progress_bar. Qutip's bars use
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 342dbbf27e..08503e9983 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -162,7 +162,7 @@ def test_ssesolve(heterodyne, system):
     }
 
     res = ssesolve(
-        H, psi0, times, sc_ops, e_ops,
+        H, psi0, times, sc_ops, e_ops=e_ops,
         ntraj=ntraj, args={"w": 2}, options=options, heterodyne=heterodyne,
         seeds=list(range(ntraj)),
     )
@@ -202,7 +202,7 @@ def test_ssesolve_method(method, heterodyne):
     }
 
     res = ssesolve(
-        H, psi0, times, sc_ops, e_ops,
+        H, psi0, times, sc_ops, e_ops=e_ops,
         ntraj=ntraj, args={"w": 2}, options=options, heterodyne=heterodyne,
         seeds=1,
     )

From 5d47f83efbcfc54a3a5ecc17b9a7788c67f8a5fd Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 23 Mar 2023 10:22:11 -0400
Subject: [PATCH 206/602] Add restore for parallel map

---
 qutip/solver/sode/ssystem.pxd |  2 --
 qutip/solver/sode/ssystem.pyx | 45 ++++++++++++++++++++++++++---------
 qutip/solver/stochastic.py    |  2 +-
 3 files changed, 35 insertions(+), 14 deletions(-)

diff --git a/qutip/solver/sode/ssystem.pxd b/qutip/solver/sode/ssystem.pxd
index b53e994996..a09212c1db 100644
--- a/qutip/solver/sode/ssystem.pxd
+++ b/qutip/solver/sode/ssystem.pxd
@@ -6,8 +6,6 @@ cdef class _StochasticSystem:
     cdef readonly list c_ops
     cdef readonly QobjEvo L
     cdef readonly int num_collapse
-    cdef readonly bint issuper
-    cdef readonly object dims
     cdef Data state
     cdef double t
 
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index ef55812a02..6bf93bb7b7 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -36,7 +36,7 @@ cdef class _StochasticSystem:
         which terms is needed change according to the integration method.
         Whereas the raw drift and diffusion are independant.
     """
-    def __init__(self, a, b):
+    def __init__(self):
         raise NotImplementedError
 
     cpdef Data drift(self, t, Data state):
@@ -116,10 +116,6 @@ cdef class StochasticClosedSystem(_StochasticSystem):
         diffusion = (c_i - e_i / 2) * psi
     """
     cdef readonly list cpcd_ops
-    cdef bint _a_set, _b_set, _Lb_set
-
-    cdef readonly Dense _a, temp, _b_vec, _c_vec, _Lb
-    cdef readonly complex _e
 
     def __init__(self, H, sc_ops):
         self.L = -1j * H
@@ -129,8 +125,6 @@ cdef class StochasticClosedSystem(_StochasticSystem):
         self.num_collapse = len(self.c_ops)
         for c_op in self.c_ops:
             self.L += -0.5 * c_op.dag() * c_op
-        self.issuper = False
-        self.dims = self.L.dims
 
     cpdef Data drift(self, t, Data state):
         cdef int i
@@ -159,6 +153,21 @@ cdef class StochasticClosedSystem(_StochasticSystem):
             out.append(_data.add(_out, state, -0.5 * expect))
         return out
 
+    def __reduce__(self):
+        return (
+            StochasticClosedSystem.restore,
+            (self.L, self.c_ops, self.cpcd_ops)
+        )
+
+    @classmethod
+    def restore(cls, L, c_ops, cpcd_ops):
+        cdef StochasticClosedSystem out = cls.__new__(cls)
+        out.L = L
+        out.c_ops = c_ops
+        out.cpcd_ops = cpcd_ops
+        out.num_collapse = len(c_ops)
+        return out
+
 
 cdef class StochasticOpenSystem(_StochasticSystem):
     """
@@ -189,8 +198,6 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
         self.c_ops = [spre(op) + spost(op.dag()) for op in sc_ops]
         self.num_collapse = len(self.c_ops)
-        self.issuper = True
-        self.dims = self.L.dims
         self.state_size = self.L.shape[1]
         self._is_set = 0
         self.N_root = <int> self.state_size**0.5
@@ -440,6 +447,24 @@ cdef class StochasticOpenSystem(_StochasticSystem):
         self.L.matmul_data(self.t, self._a, self._L0a)
         self._L0a_set = True
 
+    def __reduce__(self):
+        return (
+            StochasticOpenSystem.restore,
+            (self.L, self.c_ops, self.dt)
+        )
+
+    @classmethod
+    def restore(cls, L, c_ops, derr_dt):
+        cdef StochasticOpenSystem out = cls.__new__(cls)
+        out.L = L
+        out.c_ops = c_ops
+        out.num_collapse = len(c_ops)
+        out.state_size = out.L.shape[1]
+        out._is_set = 0
+        out.N_root = <int> out.state_size**0.5
+        out.dt = derr_dt
+        return out
+
 
 cdef class SimpleStochasticSystem(_StochasticSystem):
     """
@@ -458,8 +483,6 @@ cdef class SimpleStochasticSystem(_StochasticSystem):
         self.c_ops = c_ops
 
         self.num_collapse = len(self.c_ops)
-        self.issuper = False
-        self.dims = self.L.dims
         self.dt = 1e-6
 
     cpdef Data drift(self, t, Data state):
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index e315dd6831..14de1fa0d4 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -498,7 +498,7 @@ def __init__(self, H, sc_ops, heterodyne, *, c_ops=(), options=None):
             self._m_ops = []
             for op in sc_ops:
                 self._m_ops += [op + op.dag(), -1j * (op - op.dag())]
-            self._dW_factors = np.ones(len(sc_ops) * 2) * 0.5**0.5
+            self._dW_factors = np.ones(len(sc_ops) * 2) * 2**0.5
         else:
             self._m_ops = [op + op.dag() for op in sc_ops]
             self._dW_factors = np.ones(len(sc_ops))

From 47e9cdd548174f1500af7789721ada414c47c1ef Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 23 Mar 2023 10:27:01 -0400
Subject: [PATCH 207/602] Add missing properties specialization

---
 qutip/core/data/properties.pyx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
index a6a2450f47..ded226cbe7 100644
--- a/qutip/core/data/properties.pyx
+++ b/qutip/core/data/properties.pyx
@@ -255,6 +255,7 @@ isherm.__doc__ =\
         `qutip.settings.atol` is used instead.
     """
 isherm.add_specialisations([
+    (Dense, isherm_dense),
     (CSR, isherm_csr),
 ], _defer=True)
 
@@ -277,6 +278,7 @@ isdiag.__doc__ =\
         The matrix to test for diagonality.
     """
 isdiag.add_specialisations([
+    (Dense, isdiag_dense),
     (CSR, isdiag_csr),
 ], _defer=True)
 

From 0c4a6fa804afc72ad22ac7b1b860c6bde13c5003 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 23 Mar 2023 17:01:06 -0400
Subject: [PATCH 208/602] Change default method

---
 qutip/solver/sode/rouchon.py |  9 ++++++++-
 qutip/solver/stochastic.py   | 30 +++++++++++++++++++++++++++++-
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index 1a728a8c91..ecaf3fe041 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -18,9 +18,16 @@ class RouchonSODE(SIntegrator):
     Phys. Rev. A 91, 012118, (2015).
 
     - Order: strong 1
+
+    .. note::
+
+        This method should be used with very small ``dt``. Unlike other
+        methods that will return unphysical state (negative eigenvalues, Nans)
+        when the time step is too large, this method will return state that
+        seems normal.
     """
     integrator_options = {
-        "dt": 0.001,
+        "dt": 0.0001,
         "tol": 1e-7,
     }
 
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 14de1fa0d4..e70d8372cb 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -478,7 +478,7 @@ class StochasticSolver(MultiTrajSolver):
         "store_measurement": False,
         "keep_runs_results": False,
         "normalize_output": False,
-        "method": "rouchon",
+        "method": "taylor1.5",
         "map": "serial",
         "job_timeout": None,
         "num_cpus": None,
@@ -693,6 +693,20 @@ class SMESolver(StochasticSolver):
     name = "smesolve"
     _avail_integrators = {}
     _open = True
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "store_measurement": False,
+        "keep_runs_results": False,
+        "normalize_output": False,
+        "method": "taylor1.5",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+    }
 
 
 class SSESolver(StochasticSolver):
@@ -723,3 +737,17 @@ class SSESolver(StochasticSolver):
     name = "ssesolve"
     _avail_integrators = {}
     _open = False
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "store_measurement": False,
+        "keep_runs_results": False,
+        "normalize_output": False,
+        "method": "platen",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+    }

From a6f9fecc665b73c6e5a38c3690f2b19247f1bb0c Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 23 Mar 2023 17:02:22 -0400
Subject: [PATCH 209/602] Ensure that smesolve run in parallel in at least one
 test

---
 qutip/tests/solver/test_stochastic.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 08503e9983..2b05cff398 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -258,7 +258,7 @@ def test_reuse_seeds():
 
     options = {
         "store_final_state": True,
-        "map": "serial",
+        "map": "parallel",
         "keep_runs_results": True,
     }
 

From 8b74adab0a07d3bbb576f785926c17942e3907e2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 24 Mar 2023 08:36:23 -0400
Subject: [PATCH 210/602] More direct reuse test

---
 qutip/tests/solver/test_stochastic.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 2b05cff398..04ee372761 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -260,6 +260,7 @@ def test_reuse_seeds():
         "store_final_state": True,
         "map": "parallel",
         "keep_runs_results": True,
+        "store_measurement": True,
     }
 
     res = smesolve(
@@ -273,11 +274,15 @@ def test_reuse_seeds():
         seeds=res.seeds,
     )
 
-    for out1, out2 in zip(res.final_state, res2.final_state):
-        assert out1 == out2
+    np.testing.assert_allclose(
+        res.wiener_process, res2.wiener_process, atol=1e-14
+    )
 
     np.testing.assert_allclose(res.expect, res2.expect, atol=1e-14)
 
+    for out1, out2 in zip(res.final_state, res2.final_state):
+        assert out1 == out2
+
 
 @pytest.mark.parametrize("heterodyne", [True, False])
 def test_m_ops(heterodyne):

From 8f6a3c3badfcf6995d45058ed13dd41211f22778 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 24 Mar 2023 09:09:49 -0400
Subject: [PATCH 211/602] Change the parallel test

---
 qutip/solver/stochastic.py            | 1 +
 qutip/tests/solver/test_stochastic.py | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index e70d8372cb..31281c5bf8 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -271,6 +271,7 @@ def smesolve(
 
             seeds=prev_result.seeds
 
+        When using a parallel map, the trajectories can be re-ordered.
 
     target_tol : {float, tuple, list}, optional
         Target tolerance of the evolution. The evolution will compute
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 04ee372761..256bd1088a 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -94,7 +94,7 @@ def test_smesolve_methods(method, heterodyne):
 
     options = {
         "store_measurement": True,
-        "map": "serial",
+        "map": "parallel",
         "method": method,
     }
 
@@ -196,7 +196,7 @@ def test_ssesolve_method(method, heterodyne):
 
     options = {
         "store_measurement": True,
-        "map": "serial",
+        "map": "parallel",
         "method": method,
         "keep_runs_results": True,
     }
@@ -258,7 +258,7 @@ def test_reuse_seeds():
 
     options = {
         "store_final_state": True,
-        "map": "parallel",
+        "map": "serial",
         "keep_runs_results": True,
         "store_measurement": True,
     }

From 7aaf0122acf8d9775f6b6b8152f8f08e8fb1568e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 24 Mar 2023 15:36:00 -0400
Subject: [PATCH 212/602] Remove bind

---
 qutip/core/data/dispatch.pyx | 310 +++++++----------------------------
 1 file changed, 55 insertions(+), 255 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index e8abebd7bc..90e89c26db 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -13,208 +13,6 @@ from libcpp cimport bool
 
 __all__ = ['Dispatcher']
 
-cdef class _bind:
-    """
-    Cythonised implementation of inspect.Signature.bind, supporting faster
-    binding and handling of default arguments.  On construction, the signature
-    of the base function is extracted, and all parameters are parsed into
-    positional or keyword slots, using positional wherever possible, and their
-    defaults are stored.
-    """
-    # Instance of inpsect.Signature representing the function.
-    cdef object signature
-    cdef object inputs
-    # Mapping of (str: int), where str is the name of any argument which may be
-    # specified by a keyword, and int is its location in `self._pos` if
-    # available, or -1 if it is keyword-only.
-    cdef dict _locations
-    # Default values (or inspect.Parameter.empty) for every parameter which
-    # may be passed as a positional argument.
-    cdef list _pos
-    # For each dispatcher input which can be given as a positional argument,
-    # these two lists hold the index of the input in the given tuple of input
-    # names and the corresponding index into the positional arguments after
-    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
-    # effectively the same mapping as _kw_inputs (but for positional
-    # arguments), but we use two lists rather than a dictionary for speed.
-    cdef list _pos_inputs_input, _pos_inputs_pos
-    # Default values (or inspect.Parameter.empty) for every parameter which
-    # _must_ be passed as a keyword argument.
-    cdef dict _kw
-    # Mapping of (name, index into the input tuple) for each input which must
-    # be specified as a keyword argument
-    cdef list _kw_inputs
-    # Names of the keyword arguments which have default values.
-    cdef set _default_kw_names
-    # Respectively, numbers of positional parameters, keyword-only parameters
-    # and dispatcher inputs.
-    cdef Py_ssize_t n_args, n_kwargs, n_inputs
-    # Respectively, numbers of inputs which are positional and keyword-only.
-    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
-    # Respectively, numbers of positional arguments without a default, and
-    # number of keyword-only arguments which _have_ a default.
-    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
-
-
-    def __init__(self, signature, tuple inputs):
-        for arg in inputs:
-            if arg not in signature.parameters:
-                raise AttributeError("No argument matches '{}'.".format(arg))
-        self.signature = signature
-        self.inputs = inputs
-        self._locations = {}
-        self._pos = []
-        self._pos_inputs_input = []
-        self._pos_inputs_pos = []
-        self._kw = {}
-        self._kw_inputs = []
-        self._default_kw_names = set()
-        self._n_pos_no_default = 0
-        # signature.parameters is ordered for all Python versions.
-        for i, (name, parameter) in enumerate(signature.parameters.items()):
-            kind = parameter.kind
-            if (kind == parameter.VAR_POSITIONAL
-                    or kind == parameter.VAR_KEYWORD):
-                raise TypeError("Cannot dispatch with *args or **kwargs.")
-            if kind == parameter.KEYWORD_ONLY:
-                self._kw[name] = parameter.default
-                self._locations[name] = -1
-                if parameter.default is not parameter.empty:
-                    self._default_kw_names.add(name)
-                if name in inputs:
-                    self._kw_inputs.append((name, inputs.index(name)))
-            else:
-                self._pos.append(parameter.default)
-                if kind != parameter.POSITIONAL_ONLY:
-                    self._locations[name] = i
-                if parameter.default is parameter.empty:
-                    self._n_pos_no_default += 1
-                if name in inputs:
-                    # Effectively a mapping.
-                    self._pos_inputs_input.append(inputs.index(name))
-                    self._pos_inputs_pos.append(len(self._pos) - 1)
-        self.n_args = len(self._pos)
-        self.n_kwargs = len(self._kw)
-        self.n_inputs = len(inputs)
-        self._n_pos_inputs = len(self._pos_inputs_input)
-        self._n_kw_inputs = len(self._kw_inputs)
-        self._n_kw_default = len(self._default_kw_names)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef tuple bind(self, tuple args, dict kwargs):
-        """
-        Cython reimplementation of inspect.Signature.bind for binding the
-        collected `*args` and `**kwargs` of a generic call to a specific
-        signature, checking that everything matches.
-
-        The output is a parsed tuple (args, kwargs), where `args` is a list and
-        `kwargs` is a dict, however all arguments which _can_ be passed
-        positionally will be moved from `kwargs` into `args` for the output.
-        The resultant `args` and `kwargs` can be unpacked into the underlying
-        function call safely.  Default values are not filled in by this method.
-
-        This is necessary to allow a generic `Dispatcher` class to work with
-        all type signatures.  The result of this function can be fed to
-        `_bind.convert_types` and `_bind.dispatch_types`.
-        """
-        cdef Py_ssize_t location, got_pos=0, got_kw=0
-        cdef Py_ssize_t n_passed_args = len(args)
-        if n_passed_args > self.n_args:
-            raise TypeError(
-                "Too many arguments: expected at most {} but received {}."
-                .format(n_passed_args, self.n_args)
-            )
-        # _pos and _kw are filled with their defaults at initialisation, and
-        # _pos is already the correct length (no-default parameters have
-        # sentinel values).
-        cdef list out_pos = self._pos.copy()
-        cdef dict out_kw = self._kw.copy()
-        got_pos = self.n_args - self._n_pos_no_default
-        got_kw = self._n_kw_default
-        # Positional arguments unambiguously fill the first positional slots.
-        for location in range(n_passed_args):
-            out_pos[location] = args[location]
-        # How many arguments that we didn't have defaults for did we just get?
-        # Positionals with a default are always after those without one.
-        if n_passed_args > self._n_pos_no_default:
-            got_pos += self._n_pos_no_default
-        else:
-            got_pos += n_passed_args
-        # Everything else has been passed by keyword, but it may be allowed to
-        # be passed positionally, which is the case we prefer.  dict.items() is
-        # (relatively) expensive, so we use a boolean test for the fast path.
-        cdef str kw
-        cdef object arg
-        if kwargs:
-            for kw, arg in kwargs.items():
-                try:
-                    location = self._locations[kw]
-                except KeyError:
-                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
-                # _locations[kw] = -1 if kw is keyword-only, otherwise the
-                # corresponding positional location.
-                if location >= 0:
-                    if location < n_passed_args:
-                        raise TypeError("Multiple values for '{}'".format(kw))
-                    out_pos[location] = arg
-                    if location < self._n_pos_no_default:
-                        got_pos += 1
-                else:
-                    out_kw[kw] = arg
-                    if kw not in self._default_kw_names:
-                        got_kw += 1
-        if got_pos < self.n_args:
-            raise TypeError("Too few positional arguments passed.")
-        if got_kw < self.n_kwargs:
-            raise TypeError("Not all keyword arguments were filled.")
-        return out_pos, out_kw
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef list dispatch_types(self, list args, dict kwargs):
-        """
-        Get a list of the types which the dispatch should operate over, given
-        the output of `_bind.bind`.  The return value is a list of the _input_
-        types to be dispatched on, in order that they were specified at
-        `Dispatcher` creation.  The output type is not returned as part of this
-        list, because there is no way for `_bind` to know it.
-        """
-        cdef list dispatch = [None] * self.n_inputs
-        cdef str kw
-        cdef Py_ssize_t location, i
-        for location in range(self._n_pos_inputs):
-            dispatch[self._pos_inputs_input[location]]\
-                = type(args[self._pos_inputs_pos[location]])
-        for i in range(self._n_kw_inputs):
-            kw, location = self._kw_inputs[i]
-            dispatch[location] = type(kwargs[kw])
-        return dispatch
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
-        """
-        Apply the type converters `converters` to the parsed arguments `args`
-        and `kwargs`.
-
-        If there are `n` inputs which are dispatched on, `converters` should be
-        a tuple whose first `n` elements are converters (such as those obtained
-        from `data.to[to_type, from_type]`) to the desired types.
-
-        `args` and `kwargs` should be the output of `_bind.bind`; the function
-        will likely fail if called on unparsed arguments.
-        """
-        cdef str kw
-        cdef Py_ssize_t location, i
-        for location in range(self._n_pos_inputs):
-            args[location] = converters[location](args[location])
-        for i in range(self._n_kw_inputs):
-            kw, location = self._kw_inputs[i]
-            kwargs[kw] = converters[location](kwargs[kw])
-        return args, kwargs
-
 
 cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
     """
@@ -248,13 +46,12 @@ cdef class _constructed_specialisation:
     See `self.__signature__` or `self.__text_signature__` for the call
     signature of this object.
     """
-    cdef _bind _parameters
-    cdef bint _output
+    cdef readonly Py_ssize_t _output
     cdef object _call
-    cdef Py_ssize_t _n_dispatch
+    cdef readonly Py_ssize_t _n_input_converters
     cdef readonly tuple types
-    cdef tuple _converters
-    cdef str _short_name
+    cdef readonly tuple _converters
+    cdef readonly str _short_name
     cdef public str __doc__
     cdef public str __name__
     cdef public str __module__
@@ -274,31 +71,22 @@ cdef class _constructed_specialisation:
         self.__module__ = dispatcher.__module__
         self.__signature__ = dispatcher.__signature__
         self.__text_signature__ = dispatcher.__text_signature__
-        self._parameters = dispatcher._parameters
-        self._output = out
+        self._output = len(types) - 1 if out else -1
         self._call = base
-        self._n_dispatch = len(types)
         self.types = types
         self.direct = direct
         self._converters = converters
-
-    cdef object prebound(self, list args, dict kwargs):
-        """
-        Call this specialisation with pre-parsed arguments and keyword
-        arguments.  `args` and `kwargs` must be the output of the relevant
-        `_bind.bind` method for this function.
-        """
-        self._parameters.convert_types(args, kwargs, self._converters)
-        out = self._call(*args, **kwargs)
-        if self._output:
-            out = self._converters[self._n_dispatch - 1](out)
-        return out
+        self._n_input_converters = len(converters) - out
 
     def __call__(self, *args, **kwargs):
-        cdef list args_
-        cdef dict kwargs_
-        args_, kwargs_ = self._parameters.bind(args, kwargs)
-        return self.prebound(args_, kwargs_)
+        cdef int i
+        cdef list datas = []
+        for i in range(self._n_input_converters):
+            datas.append(self._converters[i](args[i]))
+        out = self._call(*datas, *args[self._n_input_converters:], **kwargs)
+        if self._output != -1:
+            out = self._converters[self._output](out)
+        return out
 
     def __repr__(self):
         if len(self.types) == 1:
@@ -328,12 +116,11 @@ cdef class Dispatcher:
     where `type1`, `type2`, etc are the dispatched arguments (with the output
     type on the end, if this is a dispatcher over the output type.
     """
-    cdef _bind _parameters
     cdef readonly dict _specialisations
-    cdef Py_ssize_t _n_dispatch
+    cdef readonly Py_ssize_t _n_dispatch
     cdef readonly dict _lookup
-    cdef set _dtypes
-    cdef bint _pass_on_dtype
+    cdef readonly set _dtypes
+    cdef readonly bint _pass_on_dtype
     cdef readonly tuple inputs
     cdef readonly bint output
     cdef public str __doc__
@@ -394,7 +181,6 @@ cdef class Dispatcher:
             self.__signature__ = signature_source
         else:
             self.__signature__ = inspect.signature(signature_source)
-        self._parameters = _bind(self.__signature__, inputs)
         if name is not None:
             self.__name__ = name
         elif not isinstance(signature_source, inspect.Signature):
@@ -411,7 +197,7 @@ cdef class Dispatcher:
         self.output = out
         self._specialisations = {}
         self._lookup = {}
-        self._n_dispatch = self._parameters.n_inputs + self.output
+        self._n_dispatch = len(self.inputs) + self.output
         self._pass_on_dtype = 'dtype' in self.__signature__.parameters
         # Add ourselves to the list of dispatchers to be updated.
         _to.dispatchers.append(self)
@@ -471,7 +257,7 @@ cdef class Dispatcher:
                 raise ValueError(
                     "specialisation " + str(arg)
                     + " has wrong number of parameters: needed types for "
-                    + str(self._parameters.inputs)
+                    + str(self.inputs)
                     + (", an output type" if self.output else "")
                     + " and a callable"
                 )
@@ -513,17 +299,21 @@ cdef class Dispatcher:
                     weight = cur
                     types = out_types
                     function = out_function
-            if self.output:
-                converters = tuple(
-                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
-                    + [_to[in_types[-1], types[-1]]]
-                )
+
+            if weight == 0:
+                self._lookup[in_types] = function
             else:
-                converters = tuple(_to[pair] for pair in zip(types, in_types))
-            self._lookup[in_types] =\
-                _constructed_specialisation(function, self, in_types,
-                                            converters, self.output,
-                                            weight == 0)
+                if self.output:
+                    converters = tuple(
+                        [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
+                        + [_to[in_types[-1], types[-1]]]
+                    )
+                else:
+                    converters = tuple(_to[pair] for pair in zip(types, in_types))
+                self._lookup[in_types] =\
+                    _constructed_specialisation(function, self, in_types,
+                                                converters, self.output,
+                                                weight == 0)
         # Now build the lookup table in the case that we dispatch on the output
         # type as well, but the user has called us without specifying it.
         # TODO: option to control default output type choice if unspecified?
@@ -539,12 +329,19 @@ cdef class Dispatcher:
                         weight = cur
                         types = out_types
                         function = out_function
-                converters = tuple(_to[pair] for pair in zip(types, in_types))
-                self._lookup[in_types] =\
-                    _constructed_specialisation(function, self,
-                                                in_types + (types[-1],),
-                                                converters, False,
-                                                weight == 0)
+
+                if weight == 0:
+                    self._lookup[in_types] = function
+                else:
+                    converters = tuple(
+                        _to[pair]
+                        for pair in zip(types, in_types)
+                    )
+                    self._lookup[in_types] =\
+                        _constructed_specialisation(function, self,
+                                                    in_types + (types[-1],),
+                                                    converters, False,
+                                                    weight == 0)
 
     def __getitem__(self, types):
         """
@@ -564,20 +361,23 @@ cdef class Dispatcher:
         return "<dispatcher: " + self.__text_signature__ + ">"
 
     def __call__(self, *args, dtype=None, **kwargs):
-        cdef list args_, dispatch
-        cdef dict kwargs_
+        cdef list dispatch
         if self._pass_on_dtype:
             kwargs['dtype'] = dtype
         if not (self._pass_on_dtype or self.output) and dtype is not None:
             raise TypeError("unknown argument 'dtype'")
-        args_, kwargs_ = self._parameters.bind(args, kwargs)
-        dispatch = self._parameters.dispatch_types(args_, kwargs_)
+        if len(args) < len(self.inputs):
+            raise TypeError(
+                "All dispatched data input must be passed "
+                "as positional arguments."
+            )
+        dispatch = [type(var) for var in args[:len(self.inputs)]]
+
         if self.output and dtype is not None:
             dtype = _to.parse(dtype)
             dispatch.append(dtype)
-        cdef _constructed_specialisation function
         try:
             function = self._lookup[tuple(dispatch)]
         except KeyError:
             raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
-        return function.prebound(args_, kwargs_)
+        return function(*args, **kwargs)

From 6fb6a48b9382de3359014618b7b4f5db82c5830d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 24 Mar 2023 16:03:36 -0400
Subject: [PATCH 213/602] Make positional_only in signatures

---
 qutip/core/data/add.pyx        |  8 ++++----
 qutip/core/data/adjoint.pyx    |  6 +++---
 qutip/core/data/eigen.py       |  6 +++---
 qutip/core/data/expect.pyx     |  8 ++++----
 qutip/core/data/expm.py        |  4 ++--
 qutip/core/data/inner.pyx      | 10 +++++-----
 qutip/core/data/kron.pyx       |  4 ++--
 qutip/core/data/linalg.py      |  4 ++--
 qutip/core/data/matmul.pyx     |  8 ++++----
 qutip/core/data/mul.pyx        |  6 +++---
 qutip/core/data/norm.pyx       |  6 +++---
 qutip/core/data/permute.pyx    |  4 ++--
 qutip/core/data/pow.pyx        |  2 +-
 qutip/core/data/project.pyx    |  2 +-
 qutip/core/data/properties.pyx |  6 +++---
 qutip/core/data/ptrace.pyx     |  2 +-
 qutip/core/data/reshape.pyx    |  8 ++++----
 qutip/core/data/solve.py       |  4 ++--
 qutip/core/data/tidyup.pyx     |  2 +-
 qutip/core/data/trace.pyx      |  4 ++--
 20 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index 4a24a193a4..e32ce46ca8 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -230,8 +230,8 @@ import inspect as _inspect
 
 add = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=1),
     ]),
@@ -254,8 +254,8 @@ add.add_specialisations([
 
 sub = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='sub',
     module=__name__,
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index ebff9e4d6c..9facfffcc3 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -114,7 +114,7 @@ import inspect as _inspect
 
 adjoint = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='adjoint',
     module=__name__,
@@ -129,7 +129,7 @@ adjoint.add_specialisations([
 
 transpose = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='transpose',
     module=__name__,
@@ -144,7 +144,7 @@ transpose.add_specialisations([
 
 conj = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='conj',
     module=__name__,
diff --git a/qutip/core/data/eigen.py b/qutip/core/data/eigen.py
index c860fc2003..a77f092b99 100644
--- a/qutip/core/data/eigen.py
+++ b/qutip/core/data/eigen.py
@@ -207,7 +207,7 @@ def _eigs_fix_eigvals(data, eigvals, sort):
     return eigvals, num_large, num_small
 
 
-def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
+def eigs_csr(data, /, isherm=None, vecs=True, sort='low', eigvals=0,
              tol=0, maxiter=100000):
     """
     Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
@@ -257,7 +257,7 @@ def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
     return (evals, Dense(evecs, copy=False)) if vecs else evals
 
 
-def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
+def eigs_dense(data, /, isherm=None, vecs=True, sort='low', eigvals=0):
     """
     Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
     keyword arguments; see the primary documentation in :func:`.eigs`.
@@ -412,7 +412,7 @@ def svd_dense(data, vecs=True, **kw):
 
 svd = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
     name='svd',
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 9b2089943e..1ab6c9ce2f 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -254,8 +254,8 @@ import inspect as _inspect
 
 expect = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='expect',
     module=__name__,
@@ -280,8 +280,8 @@ expect.add_specialisations([
 
 expect_super = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='expect_super',
     module=__name__,
diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index 27586d1678..1a24e983be 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -55,7 +55,7 @@ def expm_dense(matrix: Dense) -> Dense:
 
 expm = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='expm',
     module=__name__,
@@ -78,7 +78,7 @@ def logm_dense(matrix: Dense) -> Dense:
 
 logm = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='logm',
     module=__name__,
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index 9491970044..14b35a403c 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -193,8 +193,8 @@ import inspect as _inspect
 
 inner = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=False),
     ]),
@@ -236,9 +236,9 @@ inner.add_specialisations([
 
 inner_op = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=False),
     ]),
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index fd94adc369..262d74add7 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -70,8 +70,8 @@ import inspect as _inspect
 
 kron = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='kron',
     module=__name__,
diff --git a/qutip/core/data/linalg.py b/qutip/core/data/linalg.py
index f55077381c..b4e687923b 100644
--- a/qutip/core/data/linalg.py
+++ b/qutip/core/data/linalg.py
@@ -6,7 +6,7 @@
 __all__ = ['inv', 'inv_csr', 'inv_dense']
 
 
-def inv_dense(data):
+def inv_dense(data, /):
     """Compute the inverse of a matrix"""
     if not isinstance(data, Dense):
         raise TypeError("expected data in Dense format but got "
@@ -17,7 +17,7 @@ def inv_dense(data):
     return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
 
 
-def inv_csr(data):
+def inv_csr(data, /):
     """Compute the inverse of a sparse matrix"""
     if not isinstance(data, CSR):
         raise TypeError("expected data in CSR format but got "
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 1d05387961..0be1a87292 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -398,8 +398,8 @@ import inspect as _inspect
 
 matmul = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=1),
     ]),
@@ -435,8 +435,8 @@ matmul.add_specialisations([
 
 multiply = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='multiply',
     module=__name__,
diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 439c6cf694..9d42e4a9ea 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -71,7 +71,7 @@ import inspect as _inspect
 
 mul = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
     name='mul',
@@ -91,7 +91,7 @@ imul = _Dispatcher(
     # give expected results if used as:
     # mat = imul(mat, x)
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
     name='imul',
@@ -108,7 +108,7 @@ imul.add_specialisations([
 
 neg = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='neg',
     module=__name__,
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 998d49d1d2..7f0611ad78 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -139,7 +139,7 @@ import inspect as _inspect
 
 l2 = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='l2',
     module=__name__,
@@ -158,7 +158,7 @@ l2.add_specialisations([
 ], _defer=True)
 
 _norm_signature = _inspect.Signature([
-    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
 ])
 
 frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
@@ -201,7 +201,7 @@ one.add_specialisations([
 
 trace = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     inputs=('matrix',),
     name='trace',
diff --git a/qutip/core/data/permute.pyx b/qutip/core/data/permute.pyx
index 72f44af2af..dc4517677b 100644
--- a/qutip/core/data/permute.pyx
+++ b/qutip/core/data/permute.pyx
@@ -320,7 +320,7 @@ import inspect as _inspect
 
 dimensions = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
         _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
@@ -367,7 +367,7 @@ dimensions.add_specialisations([
 
 indices = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=None),
         _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
index b90a1a44b7..d530c44080 100644
--- a/qutip/core/data/pow.pyx
+++ b/qutip/core/data/pow.pyx
@@ -56,7 +56,7 @@ import inspect as _inspect
 
 pow = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
     name='pow',
diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
index b88771e365..9d086fa2c7 100644
--- a/qutip/core/data/project.pyx
+++ b/qutip/core/data/project.pyx
@@ -119,7 +119,7 @@ import inspect as _inspect
 
 project = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='project',
     module=__name__,
diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
index ded226cbe7..97509fda8c 100644
--- a/qutip/core/data/properties.pyx
+++ b/qutip/core/data/properties.pyx
@@ -227,7 +227,7 @@ import inspect as _inspect
 
 isherm = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=-1),
     ]),
@@ -261,7 +261,7 @@ isherm.add_specialisations([
 
 isdiag = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='isdiag',
     module=__name__,
@@ -284,7 +284,7 @@ isdiag.add_specialisations([
 
 iszero = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=-1),
     ]),
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 3e58e82d94..3dfb6b0a4c 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -169,7 +169,7 @@ import inspect as _inspect
 
 ptrace = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
         _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
index 6871e12c9b..6f18271005 100644
--- a/qutip/core/data/reshape.pyx
+++ b/qutip/core/data/reshape.pyx
@@ -135,7 +135,7 @@ import inspect as _inspect
 
 reshape = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
         _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
@@ -169,7 +169,7 @@ reshape.add_specialisations([
 
 column_stack = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='column_stack',
     module=__name__,
@@ -208,7 +208,7 @@ column_stack.add_specialisations([
 
 column_unstack = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
     ]),
     name='column_unstack',
@@ -249,7 +249,7 @@ column_unstack.add_specialisations([
 
 split_columns = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=1),
     ]),
diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index a164d4f745..57b5641d59 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -154,8 +154,8 @@ def solve_dense(matrix: Dense, target: Data, method=None,
 
 solve = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=None),
         _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
index a9b80798f1..a905dbb0a6 100644
--- a/qutip/core/data/tidyup.pyx
+++ b/qutip/core/data/tidyup.pyx
@@ -63,7 +63,7 @@ import inspect as _inspect
 
 tidyup = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
         _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
                            default=True),
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index c256f537cc..d8f5cbf88b 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -76,7 +76,7 @@ import inspect as _inspect
 
 trace = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='trace',
     module=__name__,
@@ -92,7 +92,7 @@ trace.add_specialisations([
 
 trace_oper_ket = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
     ]),
     name='trace_oper_ket',
     module=__name__,

From 838b80d458de284710ff6c0ad69ebe048521d09c Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 24 Mar 2023 17:28:32 -0400
Subject: [PATCH 214/602] Sanity check in __init__

---
 qutip/core/data/dispatch.pyx | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 90e89c26db..308efe7347 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -117,7 +117,7 @@ cdef class Dispatcher:
     type on the end, if this is a dispatcher over the output type.
     """
     cdef readonly dict _specialisations
-    cdef readonly Py_ssize_t _n_dispatch
+    cdef readonly Py_ssize_t _n_dispatch, _n_inputs
     cdef readonly dict _lookup
     cdef readonly set _dtypes
     cdef readonly bint _pass_on_dtype
@@ -148,9 +148,8 @@ cdef class Dispatcher:
             an instance of `inspect.Signature`, which will be used instead.
 
         inputs : iterable of str
-            The parameters which should be dispatched over.  These can be
-            positional or keyword arguments, but must feature in the signature
-            provided.
+            The parameters which should be dispatched over.  These must be
+            positional arguments, and must feature in the signature provided.
 
         out : bool, optional (False)
             Whether to dispatch on the output of the function.  Defaults to
@@ -181,6 +180,14 @@ cdef class Dispatcher:
             self.__signature__ = signature_source
         else:
             self.__signature__ = inspect.signature(signature_source)
+        for input in self.inputs:
+            if (
+                self.__signature__._parameters[input].kind
+                != inspect.Parameter.POSITIONAL_ONLY
+            ):
+                raise ValueError("inputs parameters must be positional only.")
+            if list(self.__signature__._parameters).index(input) >= len(inputs):
+                raise ValueError("inputs must be the first positional parameters.")
         if name is not None:
             self.__name__ = name
         elif not isinstance(signature_source, inspect.Signature):
@@ -197,6 +204,7 @@ cdef class Dispatcher:
         self.output = out
         self._specialisations = {}
         self._lookup = {}
+        self._n_inputs = len(self.inputs)
         self._n_dispatch = len(self.inputs) + self.output
         self._pass_on_dtype = 'dtype' in self.__signature__.parameters
         # Add ourselves to the list of dispatchers to be updated.
@@ -361,17 +369,19 @@ cdef class Dispatcher:
         return "<dispatcher: " + self.__text_signature__ + ">"
 
     def __call__(self, *args, dtype=None, **kwargs):
-        cdef list dispatch
+        cdef list dispatch = []
+        cdef int i
         if self._pass_on_dtype:
             kwargs['dtype'] = dtype
         if not (self._pass_on_dtype or self.output) and dtype is not None:
             raise TypeError("unknown argument 'dtype'")
-        if len(args) < len(self.inputs):
+        if len(args) < self._n_inputs:
             raise TypeError(
                 "All dispatched data input must be passed "
                 "as positional arguments."
             )
-        dispatch = [type(var) for var in args[:len(self.inputs)]]
+        for i in range(self._n_inputs):
+            dispatch.append(type(args[i]))
 
         if self.output and dtype is not None:
             dtype = _to.parse(dtype)

From f550d54ce8ee2837d6d56bdae911877c89e84981 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 27 Mar 2023 07:36:22 -0400
Subject: [PATCH 215/602] Add towncrier entry

---
 doc/changes/2135.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2135.misc

diff --git a/doc/changes/2135.misc b/doc/changes/2135.misc
new file mode 100644
index 0000000000..e3a05416b7
--- /dev/null
+++ b/doc/changes/2135.misc
@@ -0,0 +1 @@
+Optimize dispatcher by dispatching on positional only args.

From dd00413ee05fdb22d1492f507c61b99bc53be867 Mon Sep 17 00:00:00 2001
From: Gerardo Suarez <gerardofingurbe@gmail.com>
Date: Mon, 27 Mar 2023 15:59:49 +0200
Subject: [PATCH 216/602] added info about sec_cutoff to the documentation

---
 .codeclimate.yml                              |     92 +-
 .coveragerc                                   |     20 +-
 .github/ISSUE_TEMPLATE/bug_report.yaml        |    104 +-
 .github/ISSUE_TEMPLATE/feature_request.yaml   |     70 +-
 .github/ISSUE_TEMPLATE/others.yaml            |     28 +-
 .github/pull_request_template.md              |     32 +-
 .github/workflows/build.yml                   |    428 +-
 .github/workflows/build_documentation.yml     |    132 +-
 .github/workflows/tests.yml                   |    458 +-
 .gitignore                                    |     90 +-
 .mailmap                                      |     54 +-
 .readthedocs.yaml                             |     38 +-
 CITATION.bib                                  |     50 +-
 CODE_OF_CONDUCT.md                            |     50 +-
 CONTRIBUTING.md                               |     14 +-
 LICENSE.txt                                   |     54 +-
 MANIFEST.in                                   |     22 +-
 README.md                                     |    228 +-
 VERSION                                       |      2 +-
 doc/branch.diff                               | 144221 +++++++++++++++
 .../dynamics/dynamics-bloch-redfield.rst      |      6 +
 pyproject.toml                                |    108 +-
 qutip/__init__.py                             |    136 +-
 qutip/_mkl/__init__.py                        |      2 +-
 qutip/_mkl/spmv.py                            |     76 +-
 qutip/_mkl/spsolve.py                         |    810 +-
 qutip/about.py                                |    150 +-
 qutip/bloch.py                                |   1856 +-
 qutip/bloch3d.py                              |   1034 +-
 qutip/cite.py                                 |    120 +-
 qutip/continuous_variables.py                 |    518 +-
 qutip/control.py                              |     26 +-
 qutip/core/__init__.py                        |     32 +-
 qutip/core/_brtensor.pyx                      |    674 +-
 qutip/core/_brtools.pxd                       |     64 +-
 qutip/core/_brtools.pyx                       |    654 +-
 qutip/core/blochredfield.py                   |    376 +-
 qutip/core/coefficient.py                     |   1552 +-
 qutip/core/cy/_element.pxd                    |     84 +-
 qutip/core/cy/_element.pyx                    |   1250 +-
 qutip/core/cy/coefficient.pxd                 |     10 +-
 qutip/core/cy/coefficient.pyx                 |   1456 +-
 qutip/core/cy/complex_math.pxd                |     48 +-
 qutip/core/cy/math.pxd                        |     10 +-
 qutip/core/cy/math.pyx                        |    318 +-
 qutip/core/cy/openmp/bench_openmp.py          |    308 +-
 qutip/core/cy/openmp/parfuncs.pxd             |     18 +-
 qutip/core/cy/openmp/parfuncs.pyx             |     26 +-
 qutip/core/cy/openmp/src/zspmv_openmp.cpp     |    332 +-
 qutip/core/cy/openmp/utilities.py             |     82 +-
 qutip/core/cy/qobjevo.pxd                     |     48 +-
 qutip/core/cy/qobjevo.pyx                     |   2038 +-
 qutip/core/data/__init__.pxd                  |     26 +-
 qutip/core/data/__init__.py                   |    112 +-
 qutip/core/data/_creator_utils.py             |     62 +-
 qutip/core/data/add.pxd                       |     24 +-
 qutip/core/data/add.pyx                       |    552 +-
 qutip/core/data/adjoint.pxd                   |     24 +-
 qutip/core/data/adjoint.pyx                   |    320 +-
 qutip/core/data/base.pxd                      |     34 +-
 qutip/core/data/base.pyx                      |    178 +-
 qutip/core/data/constant.py                   |    146 +-
 qutip/core/data/convert.pyx                   |    872 +-
 qutip/core/data/csr.pxd                       |    332 +-
 qutip/core/data/csr.pyx                       |   1930 +-
 qutip/core/data/dense.pxd                     |     60 +-
 qutip/core/data/dense.pyx                     |    818 +-
 qutip/core/data/dispatch.pyx                  |   1166 +-
 qutip/core/data/eigen.py                      |    908 +-
 qutip/core/data/expect.pxd                    |     32 +-
 qutip/core/data/expect.pyx                    |    650 +-
 qutip/core/data/expm.py                       |    186 +-
 qutip/core/data/inner.pxd                     |     12 +-
 qutip/core/data/inner.pyx                     |    572 +-
 qutip/core/data/kron.pxd                      |     10 +-
 qutip/core/data/kron.pyx                      |    182 +-
 qutip/core/data/linalg.py                     |    110 +-
 qutip/core/data/make.py                       |    202 +-
 qutip/core/data/matmul.pxd                    |     28 +-
 qutip/core/data/matmul.pyx                    |    948 +-
 qutip/core/data/mul.pxd                       |     26 +-
 qutip/core/data/mul.pyx                       |    268 +-
 qutip/core/data/norm.pxd                      |     30 +-
 qutip/core/data/norm.pyx                      |    458 +-
 qutip/core/data/permute.pxd                   |     14 +-
 qutip/core/data/permute.pyx                   |    810 +-
 qutip/core/data/pow.pxd                       |     10 +-
 qutip/core/data/pow.pyx                       |    172 +-
 qutip/core/data/project.pxd                   |     10 +-
 qutip/core/data/project.pyx                   |    288 +-
 qutip/core/data/properties.pxd                |     16 +-
 qutip/core/data/properties.pyx                |    638 +-
 qutip/core/data/ptrace.pxd                    |     14 +-
 qutip/core/data/ptrace.pyx                    |    432 +-
 qutip/core/data/reshape.pxd                   |     24 +-
 qutip/core/data/reshape.pyx                   |    570 +-
 qutip/core/data/solve.py                      |    416 +-
 qutip/core/data/src/intdtype.h                |      4 +-
 qutip/core/data/src/matmul_csr_vector.cpp     |    232 +-
 qutip/core/data/src/matmul_csr_vector.hpp     |     34 +-
 qutip/core/data/tidyup.pxd                    |     14 +-
 qutip/core/data/tidyup.pyx                    |    212 +-
 qutip/core/data/trace.pxd                     |     18 +-
 qutip/core/data/trace.pyx                     |    218 +-
 qutip/core/dimensions.py                      |    690 +-
 qutip/core/expect.py                          |    194 +-
 qutip/core/gates.py                           |   1494 +-
 qutip/core/metrics.py                         |   1180 +-
 qutip/core/operators.py                       |   2146 +-
 qutip/core/options.py                         |    246 +-
 qutip/core/qobj.py                            |   3622 +-
 qutip/core/semidefinite.py                    |    416 +-
 qutip/core/states.py                          |   2684 +-
 qutip/core/subsystem_apply.py                 |    420 +-
 qutip/core/superop_reps.py                    |   1044 +-
 qutip/core/superoperator.py                   |    824 +-
 qutip/core/tensor.py                          |    924 +-
 qutip/distributions.py                        |    844 +-
 qutip/entropy.py                              |    752 +-
 qutip/fileio.py                               |    514 +-
 qutip/ipynbtools.py                           |    652 +-
 qutip/logging_utils.py                        |    218 +-
 qutip/matplotlib_utilities.py                 |    308 +-
 qutip/measurement.py                          |    762 +-
 qutip/orbital.py                              |    162 +-
 qutip/partial_transpose.py                    |    244 +-
 qutip/qip.py                                  |     26 +-
 qutip/random_objects.py                       |   1736 +-
 qutip/settings.py                             |    586 +-
 qutip/simdiag.py                              |    240 +-
 qutip/solve/_piqs.pyx                         |   1282 +-
 qutip/solve/_stochastic.pyx                   |   4690 +-
 qutip/solve/nonmarkov/memorycascade.py        |    810 +-
 qutip/solve/nonmarkov/transfertensor.py       |    508 +-
 qutip/solve/optionsclass.py                   |    526 +-
 qutip/solve/parallel.py                       |    482 +-
 qutip/solve/pdpsolve.py                       |   1150 +-
 qutip/solve/piqs.py                           |   3852 +-
 qutip/solve/rcsolve.py                        |    254 +-
 qutip/solve/solver.py                         |   1844 +-
 qutip/solve/stochastic.py                     |   2810 +-
 qutip/solver/__init__.py                      |     36 +-
 qutip/solver/brmesolve.py                     |    724 +-
 qutip/solver/correlation.py                   |   1034 +-
 qutip/solver/countstat.py                     |    434 +-
 qutip/solver/floquet.py                       |   1862 +-
 qutip/solver/floquet_bwcomp.py                |    488 +-
 qutip/solver/heom/__init__.py                 |    110 +-
 qutip/solver/heom/bofin_baths.py              |   1964 +-
 qutip/solver/heom/bofin_solvers.py            |   2644 +-
 qutip/solver/integrator/__init__.py           |      8 +-
 qutip/solver/integrator/explicit_rk.pxd       |    126 +-
 qutip/solver/integrator/explicit_rk.pyx       |   1020 +-
 qutip/solver/integrator/integrator.py         |    480 +-
 qutip/solver/integrator/krylov.py             |    476 +-
 qutip/solver/integrator/qutip_integrator.py   |    400 +-
 qutip/solver/integrator/scipy_integrator.py   |   1054 +-
 qutip/solver/integrator/verner7efficient.py   |    666 +-
 qutip/solver/integrator/verner9efficient.py   |   1412 +-
 qutip/solver/krylovsolve.py                   |    204 +-
 qutip/solver/mcsolve.py                       |   1054 +-
 qutip/solver/mesolve.py                       |    434 +-
 qutip/solver/multitraj.py                     |    514 +-
 qutip/solver/options.py                       |    212 +-
 qutip/solver/parallel.py                      |    740 +-
 qutip/solver/propagator.py                    |    556 +-
 qutip/solver/result.py                        |   1944 +-
 qutip/solver/scattering.py                    |    602 +-
 qutip/solver/sesolve.py                       |    378 +-
 qutip/solver/solver_base.py                   |    790 +-
 qutip/solver/spectrum.py                      |    376 +-
 qutip/solver/steadystate.py                   |   1074 +-
 qutip/testing.py                              |     68 +-
 qutip/tests/Hadamard_params.ini               |     38 +-
 qutip/tests/conftest.py                       |    316 +-
 qutip/tests/core/data/conftest.py             |    132 +-
 qutip/tests/core/data/test_convert.py         |    156 +-
 qutip/tests/core/data/test_csr.py             |    908 +-
 qutip/tests/core/data/test_dense.py           |    594 +-
 qutip/tests/core/data/test_expect.py          |    134 +-
 qutip/tests/core/data/test_linalg.py          |    278 +-
 qutip/tests/core/data/test_mathematics.py     |   1904 +-
 qutip/tests/core/data/test_norm.py            |    138 +-
 qutip/tests/core/data/test_operators.py       |    138 +-
 qutip/tests/core/data/test_properties.py      |    350 +-
 qutip/tests/core/data/test_ptrace.py          |    216 +-
 qutip/tests/core/data/test_reshape.py         |    242 +-
 qutip/tests/core/test_brtools.py              |    670 +-
 qutip/tests/core/test_coefficient.py          |    794 +-
 qutip/tests/core/test_dimensions.py           |    402 +-
 qutip/tests/core/test_eigen.py                |    236 +-
 qutip/tests/core/test_eigenstates.py          |    196 +-
 qutip/tests/core/test_expect.py               |    358 +-
 qutip/tests/core/test_gates.py                |    288 +-
 qutip/tests/core/test_metrics.py              |   1102 +-
 qutip/tests/core/test_operators.py            |    590 +-
 qutip/tests/core/test_ptrace.py               |    260 +-
 qutip/tests/core/test_qobj.py                 |   2456 +-
 qutip/tests/core/test_qobjevo.py              |   1030 +-
 qutip/tests/core/test_states.py               |    636 +-
 qutip/tests/core/test_superop_reps.py         |    694 +-
 qutip/tests/core/test_superoper.py            |    538 +-
 qutip/tests/core/test_tensor.py               |    514 +-
 qutip/tests/pytest.ini                        |     10 +-
 qutip/tests/solve/test_piqs.py                |   3072 +-
 qutip/tests/solve/test_qubit_evolution.py     |    248 +-
 qutip/tests/solve/test_stochastic_me.py       |    618 +-
 qutip/tests/solve/test_stochastic_se.py       |    460 +-
 qutip/tests/solver/heom/test_bofin_baths.py   |    930 +-
 qutip/tests/solver/heom/test_bofin_solvers.py |   2792 +-
 qutip/tests/solver/heom/test_heom.py          |     92 +-
 qutip/tests/solver/test_brmesolve.py          |    592 +-
 qutip/tests/solver/test_correlation.py        |    658 +-
 qutip/tests/solver/test_countstat.py          |    180 +-
 qutip/tests/solver/test_floquet.py            |    666 +-
 qutip/tests/solver/test_integrator.py         |    328 +-
 qutip/tests/solver/test_mcsolve.py            |    878 +-
 qutip/tests/solver/test_mesolve.py            |   1354 +-
 qutip/tests/solver/test_options.py            |    284 +-
 qutip/tests/solver/test_parallel.py           |    242 +-
 qutip/tests/solver/test_propagator.py         |    280 +-
 qutip/tests/solver/test_results.py            |    704 +-
 qutip/tests/solver/test_scattering.py         |    184 +-
 qutip/tests/solver/test_sesolve.py            |    602 +-
 qutip/tests/solver/test_steadystate.py        |    482 +-
 qutip/tests/test_basis_transformation.py      |    110 +-
 qutip/tests/test_bloch.py                     |    958 +-
 qutip/tests/test_enr_state_operator.py        |    232 +-
 qutip/tests/test_entropy.py                   |    424 +-
 qutip/tests/test_fileio.py                    |    124 +-
 qutip/tests/test_ipynbtools.py                |     48 +-
 qutip/tests/test_measurement.py               |    648 +-
 qutip/tests/test_mkl.py                       |    232 +-
 qutip/tests/test_openmp.py                    |    222 +-
 qutip/tests/test_orbital.py                   |    110 +-
 qutip/tests/test_partial_transpose.py         |    156 +-
 qutip/tests/test_qip.py                       |     92 +-
 qutip/tests/test_qpt.py                       |    100 +-
 qutip/tests/test_random.py                    |    622 +-
 qutip/tests/test_simdiag.py                   |    184 +-
 qutip/tests/test_subsys_apply.py              |    282 +-
 qutip/tests/test_three_level.py               |     54 +-
 qutip/tests/test_transfertensor.py            |     90 +-
 qutip/tests/test_utilities.py                 |    242 +-
 qutip/tests/test_wigner.py                    |   1386 +-
 qutip/three_level_atom.py                     |    148 +-
 qutip/tomography.py                           |    380 +-
 qutip/ui/__init__.py                          |      2 +-
 qutip/ui/progressbar.py                       |    424 +-
 qutip/utilities.py                            |    664 +-
 qutip/visualization.py                        |   3638 +-
 qutip/wigner.py                               |   2006 +-
 requirements.txt                              |      8 +-
 setup.cfg                                     |    140 +-
 setup.py                                      |    624 +-
 255 files changed, 215697 insertions(+), 71470 deletions(-)
 create mode 100644 doc/branch.diff

diff --git a/.codeclimate.yml b/.codeclimate.yml
index 35d5f48a17..68f82f86ac 100644
--- a/.codeclimate.yml
+++ b/.codeclimate.yml
@@ -1,46 +1,46 @@
-version: "2"
-exclude_patterns:
-- "doc/"
-- "dist/"
-- "**/tests/"
-checks:
-  argument-count:
-    config:
-      threshold: 10
-  complex-logic:
-    config:
-      threshold: 20
-  file-lines:
-    enabled: false
-  method-complexity:
-    config:
-      threshold: 20
-  method-count:
-    config:
-      threshold: 75
-  method-lines:
-    config:
-      threshold: 100
-  nested-control-flow:
-    config:
-      threshold: 4
-  return-statements:
-    config:
-      threshold: 4
-  similar-code:
-    config:
-      threshold: 64
-  identical-code:
-    config:
-      threshold: 64
-plugins:
-  fixme:
-    enabled: true
-  pep8:
-    enabled: true
-  duplication:
-    enabled: true
-    config:
-      languages:
-        python:
-          python_version: 3
+version: "2"
+exclude_patterns:
+- "doc/"
+- "dist/"
+- "**/tests/"
+checks:
+  argument-count:
+    config:
+      threshold: 10
+  complex-logic:
+    config:
+      threshold: 20
+  file-lines:
+    enabled: false
+  method-complexity:
+    config:
+      threshold: 20
+  method-count:
+    config:
+      threshold: 75
+  method-lines:
+    config:
+      threshold: 100
+  nested-control-flow:
+    config:
+      threshold: 4
+  return-statements:
+    config:
+      threshold: 4
+  similar-code:
+    config:
+      threshold: 64
+  identical-code:
+    config:
+      threshold: 64
+plugins:
+  fixme:
+    enabled: true
+  pep8:
+    enabled: true
+  duplication:
+    enabled: true
+    config:
+      languages:
+        python:
+          python_version: 3
diff --git a/.coveragerc b/.coveragerc
index 96024441ef..ca1eba23d6 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,10 +1,10 @@
-[run]
-source = qutip
-omit =
-    # QuTiP test files
-    */qutip/tests/*
-
-[report]
-exclude_lines =
-    # Skip Python wrappers which help load in C extension modules.
-    __bootstrap__()
+[run]
+source = qutip
+omit =
+    # QuTiP test files
+    */qutip/tests/*
+
+[report]
+exclude_lines =
+    # Skip Python wrappers which help load in C extension modules.
+    __bootstrap__()
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml
index b942d02aa4..b297a12bb3 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@@ -1,53 +1,53 @@
-name: 🐛 Bug Report
-description: Spotted a bug? Report it to us!
-labels: ["bug"]
-body:
-  - type: textarea
-    id: bug-description
-    attributes:
-      label: Bug Description
-      description: Tell us what went wrong (including what triggered the bug)
-      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
-    validations:
-      required: true
-  - type: textarea
-    id: code-to-reproduce
-    attributes:
-      label: Code to Reproduce the Bug
-      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
-      placeholder: "from qutip import identity\nprint(identity(2))"
-      render: shell
-  - type: textarea
-    id: bug-output
-    attributes:
-      label: Code Output
-      description: Please paste the relevant output here (automatically formatted)
-      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
-      render: shell
-  - type: textarea
-    id: expected-behaviour
-    attributes:
-      label: Expected Behaviour
-      description: What should have happened instead?
-      placeholder: "A clear and concise description of what you expected to happen"
-    validations:
-      required: true
-  - type: textarea
-    id: your-environment
-    attributes:
-      label: Your Environment
-      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
-      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: Add anything else you want to tell us. You can include images, plots, etc.
-      placeholder: "Additional information, images, graphs, plots, etc."
-  - type: markdown
-    id: thank-you
-    attributes:
+name: 🐛 Bug Report
+description: Spotted a bug? Report it to us!
+labels: ["bug"]
+body:
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: Bug Description
+      description: Tell us what went wrong (including what triggered the bug)
+      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
+    validations:
+      required: true
+  - type: textarea
+    id: code-to-reproduce
+    attributes:
+      label: Code to Reproduce the Bug
+      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
+      placeholder: "from qutip import identity\nprint(identity(2))"
+      render: shell
+  - type: textarea
+    id: bug-output
+    attributes:
+      label: Code Output
+      description: Please paste the relevant output here (automatically formatted)
+      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
+      render: shell
+  - type: textarea
+    id: expected-behaviour
+    attributes:
+      label: Expected Behaviour
+      description: What should have happened instead?
+      placeholder: "A clear and concise description of what you expected to happen"
+    validations:
+      required: true
+  - type: textarea
+    id: your-environment
+    attributes:
+      label: Your Environment
+      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
+      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add anything else you want to tell us. You can include images, plots, etc.
+      placeholder: "Additional information, images, graphs, plots, etc."
+  - type: markdown
+    id: thank-you
+    attributes:
       value: Thanks for taking the time to fill out this bug report!
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
index d0a2805406..a39ab3fc05 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yaml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yaml
@@ -1,36 +1,36 @@
-name: 🚀 Feature Request
-description: Suggest an idea for this project!
-labels: ["ENH"]
-body:
-  - type: textarea
-    id: problem-description
-    attributes:
-      label: Problem Description
-      description: Give us a clear and concise description of what the problem is!
-      placeholder: "Example - It would be better if [...]"
-    validations:
-      required: true
-  - type: textarea
-    id: proposed-solution
-    attributes:
-      label: Proposed Solution
-      description: Give us a description of your proposed solution
-      placeholder: "A clear and concise description of what you want to happen"
-    validations:
-      required: true
-  - type: textarea
-    id: alternate-solutions
-    attributes:
-      label: Alternate Solutions
-      description: Are there other ways of implementing this feature?
-      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: You can tell us more about your idea, add code snippets or images, etc.
-      placeholder: "Give us more context or screenshots about the feature request here"
-  - type: markdown
-    id: thank-you
-    attributes:
+name: 🚀 Feature Request
+description: Suggest an idea for this project!
+labels: ["ENH"]
+body:
+  - type: textarea
+    id: problem-description
+    attributes:
+      label: Problem Description
+      description: Give us a clear and concise description of what the problem is!
+      placeholder: "Example - It would be better if [...]"
+    validations:
+      required: true
+  - type: textarea
+    id: proposed-solution
+    attributes:
+      label: Proposed Solution
+      description: Give us a description of your proposed solution
+      placeholder: "A clear and concise description of what you want to happen"
+    validations:
+      required: true
+  - type: textarea
+    id: alternate-solutions
+    attributes:
+      label: Alternate Solutions
+      description: Are there other ways of implementing this feature?
+      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: You can tell us more about your idea, add code snippets or images, etc.
+      placeholder: "Give us more context or screenshots about the feature request here"
+  - type: markdown
+    id: thank-you
+    attributes:
       value: Thanks for taking the time to fill out this feature request!
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/others.yaml b/.github/ISSUE_TEMPLATE/others.yaml
index 7750f51837..77ac0ab4eb 100644
--- a/.github/ISSUE_TEMPLATE/others.yaml
+++ b/.github/ISSUE_TEMPLATE/others.yaml
@@ -1,15 +1,15 @@
-name: 🤔 Others
-description: Tell us about issues that aren't exactly bugs or features
-body:
-  - type: textarea
-    id: issue-description
-    attributes:
-      label: Describe the Issue!
-      description: Tell us about your issue. You can include screenshots, code snippets, etc.
-      placeholder: "Please describe the issue here"
-    validations:
-      required: true
-  - type: markdown
-    id: thank-you
-    attributes:
+name: 🤔 Others
+description: Tell us about issues that aren't exactly bugs or features
+body:
+  - type: textarea
+    id: issue-description
+    attributes:
+      label: Describe the Issue!
+      description: Tell us about your issue. You can include screenshots, code snippets, etc.
+      placeholder: "Please describe the issue here"
+    validations:
+      required: true
+  - type: markdown
+    id: thank-you
+    attributes:
       value: Thanks for taking the time to fill out this issue!
\ No newline at end of file
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index d68410d7cb..99453d7a6c 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,17 +1,17 @@
-**Checklist**
-Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
-
-- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
-- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
-You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
-- [ ] Please add tests to cover your changes if applicable.
-- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
-- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
-
-Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
-
-**Description**
-Describe here the proposed change.
-
-**Related issues or PRs**
+**Checklist**
+Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
+
+- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
+- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
+You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
+- [ ] Please add tests to cover your changes if applicable.
+- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
+- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
+
+Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
+
+**Description**
+Describe here the proposed change.
+
+**Related issues or PRs**
 Please mention the related issues or PRs here. If the PR fixes an issue, use the keyword fix/fixes/fixed followed by the issue id, e.g. fix #1184
\ No newline at end of file
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 45b648fa35..f0b852501a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,214 +1,214 @@
-name: Build wheels, optionally deploy to PyPI
-
-on:
-  workflow_dispatch:
-    inputs:
-      confirm_ref:
-        description: "Confirm chosen branch name to deploy to PyPI (optional):"
-        default: ""
-      override_version:
-        description: "Override version number (optional):"
-        default: ""
-
-
-jobs:
-  # The deploy_test job is part of the test of whether we should deploy to PyPI
-  # or test.PyPI. The job will succeed if either the confirmation reference is
-  # empty, 'test' or if the confirmation is the selected branch or tag name.
-  # It will fail if it is nonempty and does not match.  All later jobs depend
-  # on this job, so that they will be immediately cancelled if the confirmation
-  # is bad.  The dependency is currently necessary (2021-03) because GitHub
-  # Actions does not have a simpler method of cancelling an entire workflow---
-  # the normal use-case expects to try and run as much as possible despite one
-  # or two failures.
-  deploy_test:
-    name: Verify PyPI deployment confirmation
-    runs-on: ubuntu-latest
-    env:
-      GITHUB_REF: ${{ github.ref }}
-      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
-    steps:
-      - name: Compare confirmation to current reference
-        shell: bash
-        run: |
-          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
-          if [[ $CONFIRM_REF == "test" ]]; then
-            echo "Build and deploy to test.pypi.org."
-          elif [[ -z $CONFIRM_REF ]]; then
-            echo "Build only.  Nothing will be uploaded to PyPI."
-          else
-            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
-          fi
-
-
-  build_sdist:
-    name: Build sdist on Ubuntu
-    needs: deploy_test
-    runs-on: ubuntu-latest
-    env:
-      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          # For the sdist we should be as conservative as possible with our
-          # Python version.  This should be the lowest supported version.  This
-          # means that no unsupported syntax can sneak through.
-          python-version: '3.8'
-
-      - name: Install pip build
-        run: |
-          python -m pip install 'build'
-
-      - name: Build sdist tarball
-        shell: bash
-        run: |
-          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
-          # The build package is the reference PEP 517 package builder.  All
-          # dependencies are specified by our setup code.
-          python -m build --sdist .
-
-      # Zip files are not part of PEP 517, so we need to make our own.
-      - name: Create zipfile from tarball
-        shell: bash
-        working-directory: dist
-        run: |
-          # First assert that there is exactly one tarball, and find its name.
-          shopt -s failglob
-          tarball_pattern="*.tar.gz"
-          tarballs=($tarball_pattern)
-          [[ ${#tarballs[@]} == 1 ]]
-          tarball="${tarballs[0]}"
-          # Get the stem and make the zipfile name.
-          stem="${tarball%.tar.gz}"
-          zipfile="${stem}.zip"
-          # Extract the tarball and rezip it.
-          tar -xzf "$tarball"
-          zip "$zipfile" -r "$stem"
-          rm -r "$stem"
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: sdist
-          path: |
-            dist/*.tar.gz
-            dist/*.zip
-          if-no-files-found: error
-
-
-  build_wheels:
-    name: Build wheels on ${{ matrix.os }}
-    needs: deploy_test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    env:
-      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
-      CIBW_BUILD: "cp3{8,9,10,11}-*"
-      # Numpy and SciPy do not supply wheels for i686 or win32 for
-      # Python 3.10+, so we skip those:
-      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
-      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          # This is about the build environment, not the released wheel version.
-          python-version: '3.8'
-
-      - name: Install cibuildwheel
-        run: |
-          # cibuildwheel does the heavy lifting for us. Originally tested on
-          # 2.11.3, but should be fine at least up to any minor new release.
-          python -m pip install 'cibuildwheel==2.11.*'
-
-      - name: Build wheels
-        shell: bash
-        run: |
-          # If the version override was specified, then write it the VERSION
-          # file with it.
-          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
-          python -m cibuildwheel --output-dir wheelhouse
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: wheels
-          path: ./wheelhouse/*.whl
-
-
-  deploy:
-    name: "Deploy to PyPI if desired"
-    # The confirmation is tested explicitly in `deploy_test`, so we know it is
-    # either a missing confirmation (so we shouldn't run this job), 'test' or a
-    # valid confirmation.  We don't need to retest the value of the
-    # confirmation, beyond checking that one existed.
-    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
-    needs: [deploy_test, build_sdist, build_wheels]
-    runs-on: ubuntu-latest
-    env:
-      TWINE_USERNAME: __token__
-      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-      TWINE_NON_INTERACTIVE: 1
-      TWINE_REPOSITORY: pypi
-
-    steps:
-      - name: Download build artifacts to local runner
-        uses: actions/download-artifact@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          python-version: '3.8'
-
-      - name: Verify this is not a dev version
-        shell: bash
-        run: |
-          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
-          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
-
-      # We built the zipfile for convenience distributing to Windows users on
-      # our end, but PyPI only needs the tarball.
-      - name: Upload sdist and wheels to PyPI
-        run: |
-          python -m pip install "twine"
-          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
-
-
-  deploy_testpypi:
-    name: "Deploy to TestPyPI if desired"
-    if: ${{ github.event.inputs.confirm_ref == 'test' }}
-    needs: [deploy_test, build_sdist, build_wheels]
-    runs-on: ubuntu-latest
-    env:
-      TWINE_USERNAME: __token__
-      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
-      TWINE_NON_INTERACTIVE: 1
-
-    steps:
-      - name: Download build artifacts to local runner
-        uses: actions/download-artifact@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          python-version: '3.8'
-
-      - name: Verify this is not a dev version
-        shell: bash
-        run: |
-          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
-          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
-
-      # We built the zipfile for convenience distributing to Windows users on
-      # our end, but PyPI only needs the tarball.
-      - name: Upload sdist and wheels to TestPyPI
-        run: |
-          python -m pip install "twine"
-          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
+name: Build wheels, optionally deploy to PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      confirm_ref:
+        description: "Confirm chosen branch name to deploy to PyPI (optional):"
+        default: ""
+      override_version:
+        description: "Override version number (optional):"
+        default: ""
+
+
+jobs:
+  # The deploy_test job is part of the test of whether we should deploy to PyPI
+  # or test.PyPI. The job will succeed if either the confirmation reference is
+  # empty, 'test' or if the confirmation is the selected branch or tag name.
+  # It will fail if it is nonempty and does not match.  All later jobs depend
+  # on this job, so that they will be immediately cancelled if the confirmation
+  # is bad.  The dependency is currently necessary (2021-03) because GitHub
+  # Actions does not have a simpler method of cancelling an entire workflow---
+  # the normal use-case expects to try and run as much as possible despite one
+  # or two failures.
+  deploy_test:
+    name: Verify PyPI deployment confirmation
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_REF: ${{ github.ref }}
+      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
+    steps:
+      - name: Compare confirmation to current reference
+        shell: bash
+        run: |
+          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
+          if [[ $CONFIRM_REF == "test" ]]; then
+            echo "Build and deploy to test.pypi.org."
+          elif [[ -z $CONFIRM_REF ]]; then
+            echo "Build only.  Nothing will be uploaded to PyPI."
+          else
+            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
+          fi
+
+
+  build_sdist:
+    name: Build sdist on Ubuntu
+    needs: deploy_test
+    runs-on: ubuntu-latest
+    env:
+      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          # For the sdist we should be as conservative as possible with our
+          # Python version.  This should be the lowest supported version.  This
+          # means that no unsupported syntax can sneak through.
+          python-version: '3.8'
+
+      - name: Install pip build
+        run: |
+          python -m pip install 'build'
+
+      - name: Build sdist tarball
+        shell: bash
+        run: |
+          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
+          # The build package is the reference PEP 517 package builder.  All
+          # dependencies are specified by our setup code.
+          python -m build --sdist .
+
+      # Zip files are not part of PEP 517, so we need to make our own.
+      - name: Create zipfile from tarball
+        shell: bash
+        working-directory: dist
+        run: |
+          # First assert that there is exactly one tarball, and find its name.
+          shopt -s failglob
+          tarball_pattern="*.tar.gz"
+          tarballs=($tarball_pattern)
+          [[ ${#tarballs[@]} == 1 ]]
+          tarball="${tarballs[0]}"
+          # Get the stem and make the zipfile name.
+          stem="${tarball%.tar.gz}"
+          zipfile="${stem}.zip"
+          # Extract the tarball and rezip it.
+          tar -xzf "$tarball"
+          zip "$zipfile" -r "$stem"
+          rm -r "$stem"
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: sdist
+          path: |
+            dist/*.tar.gz
+            dist/*.zip
+          if-no-files-found: error
+
+
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    needs: deploy_test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    env:
+      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
+      CIBW_BUILD: "cp3{8,9,10,11}-*"
+      # Numpy and SciPy do not supply wheels for i686 or win32 for
+      # Python 3.10+, so we skip those:
+      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
+      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          # This is about the build environment, not the released wheel version.
+          python-version: '3.8'
+
+      - name: Install cibuildwheel
+        run: |
+          # cibuildwheel does the heavy lifting for us. Originally tested on
+          # 2.11.3, but should be fine at least up to any minor new release.
+          python -m pip install 'cibuildwheel==2.11.*'
+
+      - name: Build wheels
+        shell: bash
+        run: |
+          # If the version override was specified, then write it the VERSION
+          # file with it.
+          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
+          python -m cibuildwheel --output-dir wheelhouse
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: ./wheelhouse/*.whl
+
+
+  deploy:
+    name: "Deploy to PyPI if desired"
+    # The confirmation is tested explicitly in `deploy_test`, so we know it is
+    # either a missing confirmation (so we shouldn't run this job), 'test' or a
+    # valid confirmation.  We don't need to retest the value of the
+    # confirmation, beyond checking that one existed.
+    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
+    needs: [deploy_test, build_sdist, build_wheels]
+    runs-on: ubuntu-latest
+    env:
+      TWINE_USERNAME: __token__
+      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+      TWINE_NON_INTERACTIVE: 1
+      TWINE_REPOSITORY: pypi
+
+    steps:
+      - name: Download build artifacts to local runner
+        uses: actions/download-artifact@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          python-version: '3.8'
+
+      - name: Verify this is not a dev version
+        shell: bash
+        run: |
+          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
+          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
+
+      # We built the zipfile for convenience distributing to Windows users on
+      # our end, but PyPI only needs the tarball.
+      - name: Upload sdist and wheels to PyPI
+        run: |
+          python -m pip install "twine"
+          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
+
+
+  deploy_testpypi:
+    name: "Deploy to TestPyPI if desired"
+    if: ${{ github.event.inputs.confirm_ref == 'test' }}
+    needs: [deploy_test, build_sdist, build_wheels]
+    runs-on: ubuntu-latest
+    env:
+      TWINE_USERNAME: __token__
+      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
+      TWINE_NON_INTERACTIVE: 1
+
+    steps:
+      - name: Download build artifacts to local runner
+        uses: actions/download-artifact@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          python-version: '3.8'
+
+      - name: Verify this is not a dev version
+        shell: bash
+        run: |
+          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
+          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
+
+      # We built the zipfile for convenience distributing to Windows users on
+      # our end, but PyPI only needs the tarball.
+      - name: Upload sdist and wheels to TestPyPI
+        run: |
+          python -m pip install "twine"
+          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml
index b5c6eb9cf6..33d94a88ac 100644
--- a/.github/workflows/build_documentation.yml
+++ b/.github/workflows/build_documentation.yml
@@ -1,66 +1,66 @@
-name: Build documentation
-
-on:
-  [push, pull_request]
-
-jobs:
-  build:
-    name: Build documentation
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          python-version: '3.8'
-
-      - name: Install documentation dependencies
-        run: |
-          pip install pip --upgrade
-          python -mpip install -r doc/requirements.txt
-          sudo apt-get update
-          sudo apt-get install texlive-full
-
-      - name: Install QuTiP from GitHub
-        run: |
-          # Build without build isolation so that we use the build
-          # dependencies already installed from doc/requirements.txt.
-          python -m pip install -e .[full] --no-build-isolation
-          # Install in editable mode so it doesn't matter if we import from
-          # inside the installation directory, otherwise we can get some errors
-          # because we're importing from the wrong location.
-          python -c 'import qutip; qutip.about()'
-
-      - name: Build PDF documentation
-        working-directory: doc
-        run: |
-          make latexpdf SPHINXOPTS="-W --keep-going -T"
-          # Above flags are:
-          #   -W : turn warnings into errors
-          #   --keep-going : do not stop after the first error
-          #   -T : display a full traceback if a Python exception occurs
-
-      - name: Upload built PDF files
-        uses: actions/upload-artifact@v3
-        with:
-          name: qutip_pdf_docs
-          path: doc/_build/latex/*
-          if-no-files-found: error
-
-      - name: Build HTML documentation
-        working-directory: doc
-        run: |
-          make html SPHINXOPTS="-W --keep-going -T"
-          # Above flags are:
-          #   -W : turn warnings into errors
-          #   --keep-going : do not stop after the first error
-          #   -T : display a full traceback if a Python exception occurs
-
-      - name: Upload built HTML files
-        uses: actions/upload-artifact@v3
-        with:
-          name: qutip_html_docs
-          path: doc/_build/html/*
-          if-no-files-found: error
+name: Build documentation
+
+on:
+  [push, pull_request]
+
+jobs:
+  build:
+    name: Build documentation
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          python-version: '3.8'
+
+      - name: Install documentation dependencies
+        run: |
+          pip install pip --upgrade
+          python -mpip install -r doc/requirements.txt
+          sudo apt-get update
+          sudo apt-get install texlive-full
+
+      - name: Install QuTiP from GitHub
+        run: |
+          # Build without build isolation so that we use the build
+          # dependencies already installed from doc/requirements.txt.
+          python -m pip install -e .[full] --no-build-isolation
+          # Install in editable mode so it doesn't matter if we import from
+          # inside the installation directory, otherwise we can get some errors
+          # because we're importing from the wrong location.
+          python -c 'import qutip; qutip.about()'
+
+      - name: Build PDF documentation
+        working-directory: doc
+        run: |
+          make latexpdf SPHINXOPTS="-W --keep-going -T"
+          # Above flags are:
+          #   -W : turn warnings into errors
+          #   --keep-going : do not stop after the first error
+          #   -T : display a full traceback if a Python exception occurs
+
+      - name: Upload built PDF files
+        uses: actions/upload-artifact@v3
+        with:
+          name: qutip_pdf_docs
+          path: doc/_build/latex/*
+          if-no-files-found: error
+
+      - name: Build HTML documentation
+        working-directory: doc
+        run: |
+          make html SPHINXOPTS="-W --keep-going -T"
+          # Above flags are:
+          #   -W : turn warnings into errors
+          #   --keep-going : do not stop after the first error
+          #   -T : display a full traceback if a Python exception occurs
+
+      - name: Upload built HTML files
+        uses: actions/upload-artifact@v3
+        with:
+          name: qutip_html_docs
+          path: doc/_build/html/*
+          if-no-files-found: error
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index dd172510de..de383e1f6d 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -1,229 +1,229 @@
-# The name is short because we mostly care how it appears in the pull request
-# "checks" dialogue box - it looks like
-#     Tests / ubuntu-latest, python-3.9, defaults
-# or similar.
-name: Tests
-
-on:
-    [push, pull_request]
-
-defaults:
-  run:
-    # The slightly odd shell call is to force bash to read .bashrc, which is
-    # necessary for having conda behave sensibly.  We use bash as the shell even
-    # on Windows, since we don't run anything much complicated, and it makes
-    # things much simpler.
-    shell: bash -l -e {0}
-
-jobs:
-  cases:
-    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
-    runs-on: ${{ matrix.os }}
-    env:
-      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest]
-        # Test other versions of Python in special cases to avoid exploding the
-        # matrix size; make sure to test all supported versions in some form.
-        python-version: ["3.9"]
-        case-name: [defaults]
-        numpy-requirement: [">=1.20,<1.21"]
-        coverage-requirement: ["==6.5"]
-        # Extra special cases.  In these, the new variable defined should always
-        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
-        # the lack of a variable is _always_ false-y, and the defaults lack all
-        # the special cases.
-        include:
-          # Mac
-          # Mac has issues with MKL since september 2022.
-          - case-name: macos
-            os: macos-latest
-            python-version: "3.10"
-            condaforge: 1
-            nomkl: 1
-
-          # Scipy 1.5
-          - case-name: old SciPy
-            os: ubuntu-latest
-            python-version: "3.8"
-            numpy-requirement: ">=1.20,<1.21"
-            scipy-requirement: ">=1.5,<1.6"
-            condaforge: 1
-
-          # No MKL runs.  MKL is now the default for conda installations, but
-          # not necessarily for pip.
-          - case-name: no MKL
-            os: ubuntu-latest
-            python-version: "3.9"
-            numpy-requirement: ">=1.20,<1.21"
-            nomkl: 1
-
-          # Builds without Cython at runtime.  This is a core feature;
-          # everything should be able to run this.
-          - case-name: no Cython
-            os: ubuntu-latest
-            python-version: "3.8"
-            nocython: 1
-
-          # Python 3.10 and numpy 1.22
-          # Use conda-forge to provide numpy 1.22
-          - case-name: Python 3.10
-            os: ubuntu-latest
-            python-version: "3.10"
-            condaforge: 1
-
-          # Python 3.11 and latest numpy
-          # Use conda-forge to provide Python 3.11 and latest numpy
-          # Ignore deprecation of the cgi module in Python 3.11 that is
-          # still imported by Cython.Tempita. This was addressed in
-          # https://github.com/cython/cython/pull/5128 but not backported
-          # to any currently released version.
-          - case-name: Python 3.11
-            os: ubuntu-latest
-            python-version: "3.11"
-            condaforge: 1
-            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
-            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
-
-          # Windows. Once all tests pass without special options needed, this
-          # can be moved to the main os list in the test matrix. All the tests
-          # that fail currently seem to do so because mcsolve uses
-          # multiprocessing under the hood. Windows does not support fork()
-          # well, which makes transfering objects to the child processes
-          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
-          - case-name: Windows Latest
-            os: windows-latest
-            python-version: "3.10"
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: conda-incubator/setup-miniconda@v2
-        with:
-          auto-update-conda: true
-          python-version: ${{ matrix.python-version }}
-          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
-
-      - name: Install QuTiP and dependencies
-        # In the run, first we handle any special cases.  We do this in bash
-        # rather than in the GitHub Actions file directly, because bash gives us
-        # a proper programming language to use.
-        run: |
-          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
-          if [[ -z "${{ matrix.nocython }}" ]]; then
-            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
-          fi
-          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
-          if [[ -z "${{ matrix.nomkl }}" ]]; then
-            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
-            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
-            # pip not automatically linking to MKL.
-            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-          else
-            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-          fi
-          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
-            conda install "${{ matrix.conda-extra-pkgs }}"
-          fi
-          python -m pip install -e .[$QUTIP_TARGET]
-          python -m pip install "coverage${{ matrix.coverage-requirement }}"
-          python -m pip install pytest-cov coveralls pytest-fail-slow
-
-      - name: Package information
-        run: |
-          conda list
-          python -c "import qutip; qutip.about()"
-          python -c "import qutip; print(qutip.settings)"
-
-      - name: Environment information
-        run: |
-          uname -a
-          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
-              hostnamectl
-              lscpu
-              free -h
-          fi
-
-      - name: Run tests
-        # If our tests are running for longer than an hour, _something_ is wrong
-        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
-        # to see if something hung.
-        timeout-minutes: 60
-        run: |
-          if [[ -n "${{ matrix.openmp }}" ]]; then
-            # Force OpenMP runs to use more threads, even if there aren't
-            # actually that many CPUs.  We have to check any dispatch code is
-            # truly being executed.
-            export QUTIP_NUM_PROCESSES=2
-          fi
-          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
-          # Above flags are:
-          #  -Werror
-          #     treat warnings as errors
-          #  --strict-config
-          #     error out if the configuration file is not parseable
-          #  --strict-markers
-          #     error out if a marker is used but not defined in the
-          #     configuration file
-          #  --timeout=300
-          #     error any individual test that goes longer than the given time
-          #  --durations=0 --durations-min=1.0
-          #     at the end, show a list of all the tests that took longer than a
-          #     second to run
-          #  --verbosity=1
-          #     turn the verbosity up so pytest prints the names of the tests
-          #     it's currently working on
-          #  --cov=qutip
-          #     limit coverage reporting to code that's within the qutip package
-          #  --cov-report=
-          #     don't print the coverage report to the terminal---it just adds
-          #     cruft, and we're going to upload the .coverage file to Coveralls
-          #  --color=yes
-          #     force coloured output in the terminal
-
-      - name: Upload to Coveralls
-        env:
-          GITHUB_TOKEN: ${{ secrets.github_token }}
-          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
-          COVERALLS_PARALLEL: true
-        run: coveralls --service=github
-
-  towncrier-check:
-    name: Verify Towncrier entry added
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Install Towncrier
-        run: |
-          python -m pip install towncrier
-
-      - name: Verify Towncrier entry added
-        if: github.event_name == 'pull_request'
-        env:
-          BASE_BRANCH: ${{ github.base_ref }}
-        run: |
-          # Fetch the pull request' base branch so towncrier will be able to
-          # compare the current branch with the base branch.
-          # Source: https://github.com/actions/checkout/#fetch-all-branches.
-          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
-          towncrier check --compare-with origin/${BASE_BRANCH}
-          towncrier build --version "$(cat VERSION)" --draft
-
-  finalise:
-    name: Finalise coverage reporting
-    needs: cases
-    runs-on: ubuntu-latest
-    container: python:3-slim
-    steps:
-      - name: Finalise coverage reporting
-        env:
-          GITHUB_TOKEN: ${{ secrets.github_token }}
-        run: |
-          python -m pip install coveralls
-          coveralls --service=github --finish
+# The name is short because we mostly care how it appears in the pull request
+# "checks" dialogue box - it looks like
+#     Tests / ubuntu-latest, python-3.9, defaults
+# or similar.
+name: Tests
+
+on:
+    [push, pull_request]
+
+defaults:
+  run:
+    # The slightly odd shell call is to force bash to read .bashrc, which is
+    # necessary for having conda behave sensibly.  We use bash as the shell even
+    # on Windows, since we don't run anything much complicated, and it makes
+    # things much simpler.
+    shell: bash -l -e {0}
+
+jobs:
+  cases:
+    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
+    runs-on: ${{ matrix.os }}
+    env:
+      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        # Test other versions of Python in special cases to avoid exploding the
+        # matrix size; make sure to test all supported versions in some form.
+        python-version: ["3.9"]
+        case-name: [defaults]
+        numpy-requirement: [">=1.20,<1.21"]
+        coverage-requirement: ["==6.5"]
+        # Extra special cases.  In these, the new variable defined should always
+        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
+        # the lack of a variable is _always_ false-y, and the defaults lack all
+        # the special cases.
+        include:
+          # Mac
+          # Mac has issues with MKL since september 2022.
+          - case-name: macos
+            os: macos-latest
+            python-version: "3.10"
+            condaforge: 1
+            nomkl: 1
+
+          # Scipy 1.5
+          - case-name: old SciPy
+            os: ubuntu-latest
+            python-version: "3.8"
+            numpy-requirement: ">=1.20,<1.21"
+            scipy-requirement: ">=1.5,<1.6"
+            condaforge: 1
+
+          # No MKL runs.  MKL is now the default for conda installations, but
+          # not necessarily for pip.
+          - case-name: no MKL
+            os: ubuntu-latest
+            python-version: "3.9"
+            numpy-requirement: ">=1.20,<1.21"
+            nomkl: 1
+
+          # Builds without Cython at runtime.  This is a core feature;
+          # everything should be able to run this.
+          - case-name: no Cython
+            os: ubuntu-latest
+            python-version: "3.8"
+            nocython: 1
+
+          # Python 3.10 and numpy 1.22
+          # Use conda-forge to provide numpy 1.22
+          - case-name: Python 3.10
+            os: ubuntu-latest
+            python-version: "3.10"
+            condaforge: 1
+
+          # Python 3.11 and latest numpy
+          # Use conda-forge to provide Python 3.11 and latest numpy
+          # Ignore deprecation of the cgi module in Python 3.11 that is
+          # still imported by Cython.Tempita. This was addressed in
+          # https://github.com/cython/cython/pull/5128 but not backported
+          # to any currently released version.
+          - case-name: Python 3.11
+            os: ubuntu-latest
+            python-version: "3.11"
+            condaforge: 1
+            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
+            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
+
+          # Windows. Once all tests pass without special options needed, this
+          # can be moved to the main os list in the test matrix. All the tests
+          # that fail currently seem to do so because mcsolve uses
+          # multiprocessing under the hood. Windows does not support fork()
+          # well, which makes transfering objects to the child processes
+          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
+          - case-name: Windows Latest
+            os: windows-latest
+            python-version: "3.10"
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: conda-incubator/setup-miniconda@v2
+        with:
+          auto-update-conda: true
+          python-version: ${{ matrix.python-version }}
+          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
+
+      - name: Install QuTiP and dependencies
+        # In the run, first we handle any special cases.  We do this in bash
+        # rather than in the GitHub Actions file directly, because bash gives us
+        # a proper programming language to use.
+        run: |
+          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
+          if [[ -z "${{ matrix.nocython }}" ]]; then
+            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
+          fi
+          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
+          if [[ -z "${{ matrix.nomkl }}" ]]; then
+            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
+            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
+            # pip not automatically linking to MKL.
+            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+          else
+            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+          fi
+          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
+            conda install "${{ matrix.conda-extra-pkgs }}"
+          fi
+          python -m pip install -e .[$QUTIP_TARGET]
+          python -m pip install "coverage${{ matrix.coverage-requirement }}"
+          python -m pip install pytest-cov coveralls pytest-fail-slow
+
+      - name: Package information
+        run: |
+          conda list
+          python -c "import qutip; qutip.about()"
+          python -c "import qutip; print(qutip.settings)"
+
+      - name: Environment information
+        run: |
+          uname -a
+          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
+              hostnamectl
+              lscpu
+              free -h
+          fi
+
+      - name: Run tests
+        # If our tests are running for longer than an hour, _something_ is wrong
+        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
+        # to see if something hung.
+        timeout-minutes: 60
+        run: |
+          if [[ -n "${{ matrix.openmp }}" ]]; then
+            # Force OpenMP runs to use more threads, even if there aren't
+            # actually that many CPUs.  We have to check any dispatch code is
+            # truly being executed.
+            export QUTIP_NUM_PROCESSES=2
+          fi
+          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
+          # Above flags are:
+          #  -Werror
+          #     treat warnings as errors
+          #  --strict-config
+          #     error out if the configuration file is not parseable
+          #  --strict-markers
+          #     error out if a marker is used but not defined in the
+          #     configuration file
+          #  --timeout=300
+          #     error any individual test that goes longer than the given time
+          #  --durations=0 --durations-min=1.0
+          #     at the end, show a list of all the tests that took longer than a
+          #     second to run
+          #  --verbosity=1
+          #     turn the verbosity up so pytest prints the names of the tests
+          #     it's currently working on
+          #  --cov=qutip
+          #     limit coverage reporting to code that's within the qutip package
+          #  --cov-report=
+          #     don't print the coverage report to the terminal---it just adds
+          #     cruft, and we're going to upload the .coverage file to Coveralls
+          #  --color=yes
+          #     force coloured output in the terminal
+
+      - name: Upload to Coveralls
+        env:
+          GITHUB_TOKEN: ${{ secrets.github_token }}
+          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
+          COVERALLS_PARALLEL: true
+        run: coveralls --service=github
+
+  towncrier-check:
+    name: Verify Towncrier entry added
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install Towncrier
+        run: |
+          python -m pip install towncrier
+
+      - name: Verify Towncrier entry added
+        if: github.event_name == 'pull_request'
+        env:
+          BASE_BRANCH: ${{ github.base_ref }}
+        run: |
+          # Fetch the pull request' base branch so towncrier will be able to
+          # compare the current branch with the base branch.
+          # Source: https://github.com/actions/checkout/#fetch-all-branches.
+          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
+          towncrier check --compare-with origin/${BASE_BRANCH}
+          towncrier build --version "$(cat VERSION)" --draft
+
+  finalise:
+    name: Finalise coverage reporting
+    needs: cases
+    runs-on: ubuntu-latest
+    container: python:3-slim
+    steps:
+      - name: Finalise coverage reporting
+        env:
+          GITHUB_TOKEN: ${{ secrets.github_token }}
+        run: |
+          python -m pip install coveralls
+          coveralls --service=github --finish
diff --git a/.gitignore b/.gitignore
index e9cd9d2670..a83f90df9d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,45 +1,45 @@
-*~
-*.py[cod]
-*.so
-.DS_Store
-.f2py_f2cmap
-.idea/
-.vscode/
-
-# Packages
-*.egg
-.eggs
-*.egg-info
-dist
-build
-eggs
-parts
-bin
-var
-sdist
-develop-eggs
-.installed.cfg
-lib
-lib64
-
-
-qutip/version.py
-qutip/__config__.py
-rhs*.pyx
-
-qutip/cy/*.c
-*.cpp
-*.dat
-qutip/core/*.h
-
-
-qutip/**/*.html
-qutip/solver/ode/*.c
-
-
-*.qo
-
-benchmark/benchmark_data.js
-*-tasks.txt
-*compiled_coeff*
-result_images/
+*~
+*.py[cod]
+*.so
+.DS_Store
+.f2py_f2cmap
+.idea/
+.vscode/
+
+# Packages
+*.egg
+.eggs
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+
+
+qutip/version.py
+qutip/__config__.py
+rhs*.pyx
+
+qutip/cy/*.c
+*.cpp
+*.dat
+qutip/core/*.h
+
+
+qutip/**/*.html
+qutip/solver/ode/*.c
+
+
+*.qo
+
+benchmark/benchmark_data.js
+*-tasks.txt
+*compiled_coeff*
+result_images/
diff --git a/.mailmap b/.mailmap
index 346044be7b..3cb7a2a1b4 100644
--- a/.mailmap
+++ b/.mailmap
@@ -1,27 +1,27 @@
-Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
-Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
-Ben Criger <bcriger@gmail.com>
-Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
-Kevin Fischer <fischer.kevin.a@gmail.com>
-Eric Giguère <eric.giguere@calculquebec.ca>
-Canoming <canoming@163.com>
-Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
-Christopher Granade <cgranade@cgranade.com>
-Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
-Arne Grimsmo <arne.grimsmo@gmail.com>
-Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
-Neill Lambert <nwlambert@gmail.com>
-Boxi Li <etamin1201@gmail.com>
-Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
-Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
-Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
-Alexander Pitchford <alex.pitchford@gmail.com>
-Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
-Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
-Tarun Raheja <trolldemort9@gmail.com>
-Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
-Sidhant Saraogi <ssaraogi@uwaterloo.ca>
-Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
-Anubhav Vardhan <anubhavvardhan@gmail.com>
-Lucas Verney <phyks@phyks.me>
-Florestan Ziem <flo.zie@gmx.de>
+Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
+Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
+Ben Criger <bcriger@gmail.com>
+Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
+Kevin Fischer <fischer.kevin.a@gmail.com>
+Eric Giguère <eric.giguere@calculquebec.ca>
+Canoming <canoming@163.com>
+Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
+Christopher Granade <cgranade@cgranade.com>
+Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
+Arne Grimsmo <arne.grimsmo@gmail.com>
+Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
+Neill Lambert <nwlambert@gmail.com>
+Boxi Li <etamin1201@gmail.com>
+Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
+Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
+Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
+Alexander Pitchford <alex.pitchford@gmail.com>
+Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
+Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
+Tarun Raheja <trolldemort9@gmail.com>
+Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
+Sidhant Saraogi <ssaraogi@uwaterloo.ca>
+Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
+Anubhav Vardhan <anubhavvardhan@gmail.com>
+Lucas Verney <phyks@phyks.me>
+Florestan Ziem <flo.zie@gmx.de>
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index c5e1295754..4336b4794b 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -1,20 +1,20 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-version: 2
-
-formats:
-  - pdf
-
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "mambaforge-4.10"
-
-conda:
-  environment: doc/rtd-environment.yml
-
-sphinx:
-  configuration: doc/conf.py
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+formats:
+  - pdf
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "mambaforge-4.10"
+
+conda:
+  environment: doc/rtd-environment.yml
+
+sphinx:
+  configuration: doc/conf.py
   fail_on_warning: true
\ No newline at end of file
diff --git a/CITATION.bib b/CITATION.bib
index 143e992d27..2ea12d327e 100644
--- a/CITATION.bib
+++ b/CITATION.bib
@@ -1,26 +1,26 @@
-@article{qutip2,
-doi = {10.1016/j.cpc.2012.11.019},
-url = {https://doi.org/10.1016/j.cpc.2012.11.019},
-year  = {2013},
-month = {apr},
-publisher = {Elsevier {BV}},
-volume = {184},
-number = {4},
-pages = {1234--1240},
-author = {J.R. Johansson and P.D. Nation and F. Nori},
-title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
-journal = {Computer Physics Communications}
-}
-@article{qutip1,
-doi = {10.1016/j.cpc.2012.02.021},
-url = {https://doi.org/10.1016/j.cpc.2012.02.021},
-year  = {2012},
-month = {aug},
-publisher = {Elsevier {BV}},
-volume = {183},
-number = {8},
-pages = {1760--1772},
-author = {J.R. Johansson and P.D. Nation and F. Nori},
-title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
-journal = {Computer Physics Communications}
+@article{qutip2,
+doi = {10.1016/j.cpc.2012.11.019},
+url = {https://doi.org/10.1016/j.cpc.2012.11.019},
+year  = {2013},
+month = {apr},
+publisher = {Elsevier {BV}},
+volume = {184},
+number = {4},
+pages = {1234--1240},
+author = {J.R. Johansson and P.D. Nation and F. Nori},
+title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
+journal = {Computer Physics Communications}
+}
+@article{qutip1,
+doi = {10.1016/j.cpc.2012.02.021},
+url = {https://doi.org/10.1016/j.cpc.2012.02.021},
+year  = {2012},
+month = {aug},
+publisher = {Elsevier {BV}},
+volume = {183},
+number = {8},
+pages = {1760--1772},
+author = {J.R. Johansson and P.D. Nation and F. Nori},
+title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
+journal = {Computer Physics Communications}
 }
\ No newline at end of file
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index ddf531d0cd..23c17f3e77 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,25 +1,25 @@
-# Contributor Covenant Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic addresses, without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
-
-This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
-
-This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
-
-[homepage]: https://contributor-covenant.org
-[version]: https://contributor-covenant.org/version/1/2/
+# Contributor Covenant Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
+
+This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/2/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 104456854c..83f103e9ca 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,7 +1,7 @@
-# Contributing to QuTiP Development
-
-You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
-You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
-
-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+# Contributing to QuTiP Development
+
+You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
+You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
+All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+
+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
diff --git a/LICENSE.txt b/LICENSE.txt
index bb2d6131bb..34e8c029f3 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,27 +1,27 @@
-Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-   may be used to endorse or promote products derived from this software without
-   specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/MANIFEST.in b/MANIFEST.in
index dd7423f79c..0b5f0e2129 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,12 +1,12 @@
-include README.md
-include LICENSE.txt
-include VERSION
-include requirements.txt
-include CITATION.bib
-include pyproject.toml
-recursive-include qutip *.pyx
-recursive-include qutip *.pxd
-recursive-include qutip *.hpp
-recursive-include qutip *.cpp
-recursive-include qutip *.ini
+include README.md
+include LICENSE.txt
+include VERSION
+include requirements.txt
+include CITATION.bib
+include pyproject.toml
+recursive-include qutip *.pyx
+recursive-include qutip *.pxd
+recursive-include qutip *.hpp
+recursive-include qutip *.cpp
+recursive-include qutip *.ini
 recursive-include qutip *.h
\ No newline at end of file
diff --git a/README.md b/README.md
index 376e25b3a8..03a223d474 100644
--- a/README.md
+++ b/README.md
@@ -1,114 +1,114 @@
-QuTiP: Quantum Toolbox in Python
-================================
-
-[A. Pitchford](https://github.com/ajgpitch),
-[C. Granade](https://github.com/cgranade),
-[A. Grimsmo](https://github.com/arnelg),
-[N. Shammah](https://github.com/nathanshammah),
-[S. Ahmed](https://github.com/quantshah),
-[N. Lambert](https://github.com/nwlambert),
-[E. Giguère](https://github.com/ericgig),
-[B. Li](https://github.com/boxili),
-[J. Lishman](https://github.com/jakelishman),
-[S. Cross](https://github.com/hodgestar),
-[A. Galicia](https://github.com/AGaliciaMartinez),
-[P. D. Nation](https://github.com/nonhermitian),
-and [J. R. Johansson](https://github.com/jrjohansson)
-
-[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
-[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
-[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
-[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
-[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
-
-> **Note**
->
-> The master branch now contains the alpha version of QuTiP 5. This is major
-> revision that breaks compatibility in many small ways withh QuTiP 4.7.
->
-> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
-> please use the `qutip-4.7.X` branch.
->
-> If you need to track QuTiP 5 changes or submit  pull request for 5,
-> please use the `master` branch (and not the `dev.major` branch).
->
-> The change to master happened on 16 January 2023 in commit @fccec5d.
-
-QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
-It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
-QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
-QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
-Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
-
-Support
--------
-
-[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
-[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
-
-We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
-QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
-
-
-Installation
-------------
-
-[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
-[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
-
-QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
-You can install QuTiP from `pip` by doing
-
-```bash
-pip install qutip
-```
-
-to get the minimal installation.
-You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
-For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
-
-All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
-For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
-
-
-The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
-
-```bash
-pip install --pre qutip
-```
-
-This version breaks compatibility with QuTiP 4.7 in many small ways.
-Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
-This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
-
-
-Documentation
--------------
-
-[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
-
-The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
-
-The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
-
-The latest development documentation is available in this repository in the `doc` folder.
-
-A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
-These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
-
-
-Contribute
-----------
-
-You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
-You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
-
-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
-
-
-Citing QuTiP
-------------
-
-If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
+QuTiP: Quantum Toolbox in Python
+================================
+
+[A. Pitchford](https://github.com/ajgpitch),
+[C. Granade](https://github.com/cgranade),
+[A. Grimsmo](https://github.com/arnelg),
+[N. Shammah](https://github.com/nathanshammah),
+[S. Ahmed](https://github.com/quantshah),
+[N. Lambert](https://github.com/nwlambert),
+[E. Giguère](https://github.com/ericgig),
+[B. Li](https://github.com/boxili),
+[J. Lishman](https://github.com/jakelishman),
+[S. Cross](https://github.com/hodgestar),
+[A. Galicia](https://github.com/AGaliciaMartinez),
+[P. D. Nation](https://github.com/nonhermitian),
+and [J. R. Johansson](https://github.com/jrjohansson)
+
+[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
+[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
+[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
+[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
+[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
+
+> **Note**
+>
+> The master branch now contains the alpha version of QuTiP 5. This is major
+> revision that breaks compatibility in many small ways withh QuTiP 4.7.
+>
+> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
+> please use the `qutip-4.7.X` branch.
+>
+> If you need to track QuTiP 5 changes or submit  pull request for 5,
+> please use the `master` branch (and not the `dev.major` branch).
+>
+> The change to master happened on 16 January 2023 in commit @fccec5d.
+
+QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
+It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
+QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
+QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
+Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
+
+Support
+-------
+
+[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
+[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+
+We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
+QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
+
+
+Installation
+------------
+
+[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
+[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
+
+QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
+You can install QuTiP from `pip` by doing
+
+```bash
+pip install qutip
+```
+
+to get the minimal installation.
+You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
+For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
+
+All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
+For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
+
+
+The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
+
+```bash
+pip install --pre qutip
+```
+
+This version breaks compatibility with QuTiP 4.7 in many small ways.
+Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
+This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
+
+
+Documentation
+-------------
+
+[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
+
+The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
+
+The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
+
+The latest development documentation is available in this repository in the `doc` folder.
+
+A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
+These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
+
+
+Contribute
+----------
+
+You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
+You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
+All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+
+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+
+
+Citing QuTiP
+------------
+
+If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
diff --git a/VERSION b/VERSION
index 6f5f6c392d..706882a482 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-5.0.0.dev
+5.0.0.dev
diff --git a/doc/branch.diff b/doc/branch.diff
new file mode 100644
index 0000000000..bd053dfb84
--- /dev/null
+++ b/doc/branch.diff
@@ -0,0 +1,144221 @@
+diff --git a/.codeclimate.yml b/.codeclimate.yml
+index 35d5f48a..68f82f86 100644
+--- a/.codeclimate.yml
++++ b/.codeclimate.yml
+@@ -1,46 +1,46 @@
+-version: "2"
+-exclude_patterns:
+-- "doc/"
+-- "dist/"
+-- "**/tests/"
+-checks:
+-  argument-count:
+-    config:
+-      threshold: 10
+-  complex-logic:
+-    config:
+-      threshold: 20
+-  file-lines:
+-    enabled: false
+-  method-complexity:
+-    config:
+-      threshold: 20
+-  method-count:
+-    config:
+-      threshold: 75
+-  method-lines:
+-    config:
+-      threshold: 100
+-  nested-control-flow:
+-    config:
+-      threshold: 4
+-  return-statements:
+-    config:
+-      threshold: 4
+-  similar-code:
+-    config:
+-      threshold: 64
+-  identical-code:
+-    config:
+-      threshold: 64
+-plugins:
+-  fixme:
+-    enabled: true
+-  pep8:
+-    enabled: true
+-  duplication:
+-    enabled: true
+-    config:
+-      languages:
+-        python:
+-          python_version: 3
++version: "2"
++exclude_patterns:
++- "doc/"
++- "dist/"
++- "**/tests/"
++checks:
++  argument-count:
++    config:
++      threshold: 10
++  complex-logic:
++    config:
++      threshold: 20
++  file-lines:
++    enabled: false
++  method-complexity:
++    config:
++      threshold: 20
++  method-count:
++    config:
++      threshold: 75
++  method-lines:
++    config:
++      threshold: 100
++  nested-control-flow:
++    config:
++      threshold: 4
++  return-statements:
++    config:
++      threshold: 4
++  similar-code:
++    config:
++      threshold: 64
++  identical-code:
++    config:
++      threshold: 64
++plugins:
++  fixme:
++    enabled: true
++  pep8:
++    enabled: true
++  duplication:
++    enabled: true
++    config:
++      languages:
++        python:
++          python_version: 3
+diff --git a/.coveragerc b/.coveragerc
+index 96024441..ca1eba23 100644
+--- a/.coveragerc
++++ b/.coveragerc
+@@ -1,10 +1,10 @@
+-[run]
+-source = qutip
+-omit =
+-    # QuTiP test files
+-    */qutip/tests/*
+-
+-[report]
+-exclude_lines =
+-    # Skip Python wrappers which help load in C extension modules.
+-    __bootstrap__()
++[run]
++source = qutip
++omit =
++    # QuTiP test files
++    */qutip/tests/*
++
++[report]
++exclude_lines =
++    # Skip Python wrappers which help load in C extension modules.
++    __bootstrap__()
+diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml
+index b942d02a..b297a12b 100644
+--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
++++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
+@@ -1,53 +1,53 @@
+-name: 🐛 Bug Report
+-description: Spotted a bug? Report it to us!
+-labels: ["bug"]
+-body:
+-  - type: textarea
+-    id: bug-description
+-    attributes:
+-      label: Bug Description
+-      description: Tell us what went wrong (including what triggered the bug)
+-      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
+-    validations:
+-      required: true
+-  - type: textarea
+-    id: code-to-reproduce
+-    attributes:
+-      label: Code to Reproduce the Bug
+-      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
+-      placeholder: "from qutip import identity\nprint(identity(2))"
+-      render: shell
+-  - type: textarea
+-    id: bug-output
+-    attributes:
+-      label: Code Output
+-      description: Please paste the relevant output here (automatically formatted)
+-      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
+-      render: shell
+-  - type: textarea
+-    id: expected-behaviour
+-    attributes:
+-      label: Expected Behaviour
+-      description: What should have happened instead?
+-      placeholder: "A clear and concise description of what you expected to happen"
+-    validations:
+-      required: true
+-  - type: textarea
+-    id: your-environment
+-    attributes:
+-      label: Your Environment
+-      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
+-      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
+-      render: shell
+-    validations:
+-      required: true
+-  - type: textarea
+-    id: additional-context
+-    attributes:
+-      label: Additional Context
+-      description: Add anything else you want to tell us. You can include images, plots, etc.
+-      placeholder: "Additional information, images, graphs, plots, etc."
+-  - type: markdown
+-    id: thank-you
+-    attributes:
++name: 🐛 Bug Report
++description: Spotted a bug? Report it to us!
++labels: ["bug"]
++body:
++  - type: textarea
++    id: bug-description
++    attributes:
++      label: Bug Description
++      description: Tell us what went wrong (including what triggered the bug)
++      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
++    validations:
++      required: true
++  - type: textarea
++    id: code-to-reproduce
++    attributes:
++      label: Code to Reproduce the Bug
++      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
++      placeholder: "from qutip import identity\nprint(identity(2))"
++      render: shell
++  - type: textarea
++    id: bug-output
++    attributes:
++      label: Code Output
++      description: Please paste the relevant output here (automatically formatted)
++      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
++      render: shell
++  - type: textarea
++    id: expected-behaviour
++    attributes:
++      label: Expected Behaviour
++      description: What should have happened instead?
++      placeholder: "A clear and concise description of what you expected to happen"
++    validations:
++      required: true
++  - type: textarea
++    id: your-environment
++    attributes:
++      label: Your Environment
++      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
++      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
++      render: shell
++    validations:
++      required: true
++  - type: textarea
++    id: additional-context
++    attributes:
++      label: Additional Context
++      description: Add anything else you want to tell us. You can include images, plots, etc.
++      placeholder: "Additional information, images, graphs, plots, etc."
++  - type: markdown
++    id: thank-you
++    attributes:
+       value: Thanks for taking the time to fill out this bug report!
+\ No newline at end of file
+diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
+index d0a28054..a39ab3fc 100644
+--- a/.github/ISSUE_TEMPLATE/feature_request.yaml
++++ b/.github/ISSUE_TEMPLATE/feature_request.yaml
+@@ -1,36 +1,36 @@
+-name: 🚀 Feature Request
+-description: Suggest an idea for this project!
+-labels: ["ENH"]
+-body:
+-  - type: textarea
+-    id: problem-description
+-    attributes:
+-      label: Problem Description
+-      description: Give us a clear and concise description of what the problem is!
+-      placeholder: "Example - It would be better if [...]"
+-    validations:
+-      required: true
+-  - type: textarea
+-    id: proposed-solution
+-    attributes:
+-      label: Proposed Solution
+-      description: Give us a description of your proposed solution
+-      placeholder: "A clear and concise description of what you want to happen"
+-    validations:
+-      required: true
+-  - type: textarea
+-    id: alternate-solutions
+-    attributes:
+-      label: Alternate Solutions
+-      description: Are there other ways of implementing this feature?
+-      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
+-  - type: textarea
+-    id: additional-context
+-    attributes:
+-      label: Additional Context
+-      description: You can tell us more about your idea, add code snippets or images, etc.
+-      placeholder: "Give us more context or screenshots about the feature request here"
+-  - type: markdown
+-    id: thank-you
+-    attributes:
++name: 🚀 Feature Request
++description: Suggest an idea for this project!
++labels: ["ENH"]
++body:
++  - type: textarea
++    id: problem-description
++    attributes:
++      label: Problem Description
++      description: Give us a clear and concise description of what the problem is!
++      placeholder: "Example - It would be better if [...]"
++    validations:
++      required: true
++  - type: textarea
++    id: proposed-solution
++    attributes:
++      label: Proposed Solution
++      description: Give us a description of your proposed solution
++      placeholder: "A clear and concise description of what you want to happen"
++    validations:
++      required: true
++  - type: textarea
++    id: alternate-solutions
++    attributes:
++      label: Alternate Solutions
++      description: Are there other ways of implementing this feature?
++      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
++  - type: textarea
++    id: additional-context
++    attributes:
++      label: Additional Context
++      description: You can tell us more about your idea, add code snippets or images, etc.
++      placeholder: "Give us more context or screenshots about the feature request here"
++  - type: markdown
++    id: thank-you
++    attributes:
+       value: Thanks for taking the time to fill out this feature request!
+\ No newline at end of file
+diff --git a/.github/ISSUE_TEMPLATE/others.yaml b/.github/ISSUE_TEMPLATE/others.yaml
+index 7750f518..77ac0ab4 100644
+--- a/.github/ISSUE_TEMPLATE/others.yaml
++++ b/.github/ISSUE_TEMPLATE/others.yaml
+@@ -1,15 +1,15 @@
+-name: 🤔 Others
+-description: Tell us about issues that aren't exactly bugs or features
+-body:
+-  - type: textarea
+-    id: issue-description
+-    attributes:
+-      label: Describe the Issue!
+-      description: Tell us about your issue. You can include screenshots, code snippets, etc.
+-      placeholder: "Please describe the issue here"
+-    validations:
+-      required: true
+-  - type: markdown
+-    id: thank-you
+-    attributes:
++name: 🤔 Others
++description: Tell us about issues that aren't exactly bugs or features
++body:
++  - type: textarea
++    id: issue-description
++    attributes:
++      label: Describe the Issue!
++      description: Tell us about your issue. You can include screenshots, code snippets, etc.
++      placeholder: "Please describe the issue here"
++    validations:
++      required: true
++  - type: markdown
++    id: thank-you
++    attributes:
+       value: Thanks for taking the time to fill out this issue!
+\ No newline at end of file
+diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
+index d68410d7..99453d7a 100644
+--- a/.github/pull_request_template.md
++++ b/.github/pull_request_template.md
+@@ -1,17 +1,17 @@
+-**Checklist**
+-Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
+-
+-- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
+-- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
+-You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
+-- [ ] Please add tests to cover your changes if applicable.
+-- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
+-- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
+-
+-Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
+-
+-**Description**
+-Describe here the proposed change.
+-
+-**Related issues or PRs**
++**Checklist**
++Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
++
++- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
++- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
++You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
++- [ ] Please add tests to cover your changes if applicable.
++- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
++- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
++
++Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
++
++**Description**
++Describe here the proposed change.
++
++**Related issues or PRs**
+ Please mention the related issues or PRs here. If the PR fixes an issue, use the keyword fix/fixes/fixed followed by the issue id, e.g. fix #1184
+\ No newline at end of file
+diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
+index 45b648fa..f0b85250 100644
+--- a/.github/workflows/build.yml
++++ b/.github/workflows/build.yml
+@@ -1,214 +1,214 @@
+-name: Build wheels, optionally deploy to PyPI
+-
+-on:
+-  workflow_dispatch:
+-    inputs:
+-      confirm_ref:
+-        description: "Confirm chosen branch name to deploy to PyPI (optional):"
+-        default: ""
+-      override_version:
+-        description: "Override version number (optional):"
+-        default: ""
+-
+-
+-jobs:
+-  # The deploy_test job is part of the test of whether we should deploy to PyPI
+-  # or test.PyPI. The job will succeed if either the confirmation reference is
+-  # empty, 'test' or if the confirmation is the selected branch or tag name.
+-  # It will fail if it is nonempty and does not match.  All later jobs depend
+-  # on this job, so that they will be immediately cancelled if the confirmation
+-  # is bad.  The dependency is currently necessary (2021-03) because GitHub
+-  # Actions does not have a simpler method of cancelling an entire workflow---
+-  # the normal use-case expects to try and run as much as possible despite one
+-  # or two failures.
+-  deploy_test:
+-    name: Verify PyPI deployment confirmation
+-    runs-on: ubuntu-latest
+-    env:
+-      GITHUB_REF: ${{ github.ref }}
+-      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
+-    steps:
+-      - name: Compare confirmation to current reference
+-        shell: bash
+-        run: |
+-          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
+-          if [[ $CONFIRM_REF == "test" ]]; then
+-            echo "Build and deploy to test.pypi.org."
+-          elif [[ -z $CONFIRM_REF ]]; then
+-            echo "Build only.  Nothing will be uploaded to PyPI."
+-          else
+-            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
+-          fi
+-
+-
+-  build_sdist:
+-    name: Build sdist on Ubuntu
+-    needs: deploy_test
+-    runs-on: ubuntu-latest
+-    env:
+-      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
+-
+-    steps:
+-      - uses: actions/checkout@v3
+-
+-      - uses: actions/setup-python@v4
+-        name: Install Python
+-        with:
+-          # For the sdist we should be as conservative as possible with our
+-          # Python version.  This should be the lowest supported version.  This
+-          # means that no unsupported syntax can sneak through.
+-          python-version: '3.8'
+-
+-      - name: Install pip build
+-        run: |
+-          python -m pip install 'build'
+-
+-      - name: Build sdist tarball
+-        shell: bash
+-        run: |
+-          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
+-          # The build package is the reference PEP 517 package builder.  All
+-          # dependencies are specified by our setup code.
+-          python -m build --sdist .
+-
+-      # Zip files are not part of PEP 517, so we need to make our own.
+-      - name: Create zipfile from tarball
+-        shell: bash
+-        working-directory: dist
+-        run: |
+-          # First assert that there is exactly one tarball, and find its name.
+-          shopt -s failglob
+-          tarball_pattern="*.tar.gz"
+-          tarballs=($tarball_pattern)
+-          [[ ${#tarballs[@]} == 1 ]]
+-          tarball="${tarballs[0]}"
+-          # Get the stem and make the zipfile name.
+-          stem="${tarball%.tar.gz}"
+-          zipfile="${stem}.zip"
+-          # Extract the tarball and rezip it.
+-          tar -xzf "$tarball"
+-          zip "$zipfile" -r "$stem"
+-          rm -r "$stem"
+-
+-      - uses: actions/upload-artifact@v3
+-        with:
+-          name: sdist
+-          path: |
+-            dist/*.tar.gz
+-            dist/*.zip
+-          if-no-files-found: error
+-
+-
+-  build_wheels:
+-    name: Build wheels on ${{ matrix.os }}
+-    needs: deploy_test
+-    runs-on: ${{ matrix.os }}
+-    strategy:
+-      matrix:
+-        os: [ubuntu-latest, windows-latest, macos-latest]
+-    env:
+-      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
+-      CIBW_BUILD: "cp3{8,9,10,11}-*"
+-      # Numpy and SciPy do not supply wheels for i686 or win32 for
+-      # Python 3.10+, so we skip those:
+-      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
+-      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
+-
+-    steps:
+-      - uses: actions/checkout@v3
+-
+-      - uses: actions/setup-python@v4
+-        name: Install Python
+-        with:
+-          # This is about the build environment, not the released wheel version.
+-          python-version: '3.8'
+-
+-      - name: Install cibuildwheel
+-        run: |
+-          # cibuildwheel does the heavy lifting for us. Originally tested on
+-          # 2.11.3, but should be fine at least up to any minor new release.
+-          python -m pip install 'cibuildwheel==2.11.*'
+-
+-      - name: Build wheels
+-        shell: bash
+-        run: |
+-          # If the version override was specified, then write it the VERSION
+-          # file with it.
+-          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
+-          python -m cibuildwheel --output-dir wheelhouse
+-
+-      - uses: actions/upload-artifact@v3
+-        with:
+-          name: wheels
+-          path: ./wheelhouse/*.whl
+-
+-
+-  deploy:
+-    name: "Deploy to PyPI if desired"
+-    # The confirmation is tested explicitly in `deploy_test`, so we know it is
+-    # either a missing confirmation (so we shouldn't run this job), 'test' or a
+-    # valid confirmation.  We don't need to retest the value of the
+-    # confirmation, beyond checking that one existed.
+-    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
+-    needs: [deploy_test, build_sdist, build_wheels]
+-    runs-on: ubuntu-latest
+-    env:
+-      TWINE_USERNAME: __token__
+-      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+-      TWINE_NON_INTERACTIVE: 1
+-      TWINE_REPOSITORY: pypi
+-
+-    steps:
+-      - name: Download build artifacts to local runner
+-        uses: actions/download-artifact@v3
+-
+-      - uses: actions/setup-python@v4
+-        name: Install Python
+-        with:
+-          python-version: '3.8'
+-
+-      - name: Verify this is not a dev version
+-        shell: bash
+-        run: |
+-          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
+-          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
+-
+-      # We built the zipfile for convenience distributing to Windows users on
+-      # our end, but PyPI only needs the tarball.
+-      - name: Upload sdist and wheels to PyPI
+-        run: |
+-          python -m pip install "twine"
+-          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
+-
+-
+-  deploy_testpypi:
+-    name: "Deploy to TestPyPI if desired"
+-    if: ${{ github.event.inputs.confirm_ref == 'test' }}
+-    needs: [deploy_test, build_sdist, build_wheels]
+-    runs-on: ubuntu-latest
+-    env:
+-      TWINE_USERNAME: __token__
+-      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
+-      TWINE_NON_INTERACTIVE: 1
+-
+-    steps:
+-      - name: Download build artifacts to local runner
+-        uses: actions/download-artifact@v3
+-
+-      - uses: actions/setup-python@v4
+-        name: Install Python
+-        with:
+-          python-version: '3.8'
+-
+-      - name: Verify this is not a dev version
+-        shell: bash
+-        run: |
+-          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
+-          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
+-
+-      # We built the zipfile for convenience distributing to Windows users on
+-      # our end, but PyPI only needs the tarball.
+-      - name: Upload sdist and wheels to TestPyPI
+-        run: |
+-          python -m pip install "twine"
+-          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
++name: Build wheels, optionally deploy to PyPI
++
++on:
++  workflow_dispatch:
++    inputs:
++      confirm_ref:
++        description: "Confirm chosen branch name to deploy to PyPI (optional):"
++        default: ""
++      override_version:
++        description: "Override version number (optional):"
++        default: ""
++
++
++jobs:
++  # The deploy_test job is part of the test of whether we should deploy to PyPI
++  # or test.PyPI. The job will succeed if either the confirmation reference is
++  # empty, 'test' or if the confirmation is the selected branch or tag name.
++  # It will fail if it is nonempty and does not match.  All later jobs depend
++  # on this job, so that they will be immediately cancelled if the confirmation
++  # is bad.  The dependency is currently necessary (2021-03) because GitHub
++  # Actions does not have a simpler method of cancelling an entire workflow---
++  # the normal use-case expects to try and run as much as possible despite one
++  # or two failures.
++  deploy_test:
++    name: Verify PyPI deployment confirmation
++    runs-on: ubuntu-latest
++    env:
++      GITHUB_REF: ${{ github.ref }}
++      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
++    steps:
++      - name: Compare confirmation to current reference
++        shell: bash
++        run: |
++          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
++          if [[ $CONFIRM_REF == "test" ]]; then
++            echo "Build and deploy to test.pypi.org."
++          elif [[ -z $CONFIRM_REF ]]; then
++            echo "Build only.  Nothing will be uploaded to PyPI."
++          else
++            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
++          fi
++
++
++  build_sdist:
++    name: Build sdist on Ubuntu
++    needs: deploy_test
++    runs-on: ubuntu-latest
++    env:
++      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
++
++    steps:
++      - uses: actions/checkout@v3
++
++      - uses: actions/setup-python@v4
++        name: Install Python
++        with:
++          # For the sdist we should be as conservative as possible with our
++          # Python version.  This should be the lowest supported version.  This
++          # means that no unsupported syntax can sneak through.
++          python-version: '3.8'
++
++      - name: Install pip build
++        run: |
++          python -m pip install 'build'
++
++      - name: Build sdist tarball
++        shell: bash
++        run: |
++          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
++          # The build package is the reference PEP 517 package builder.  All
++          # dependencies are specified by our setup code.
++          python -m build --sdist .
++
++      # Zip files are not part of PEP 517, so we need to make our own.
++      - name: Create zipfile from tarball
++        shell: bash
++        working-directory: dist
++        run: |
++          # First assert that there is exactly one tarball, and find its name.
++          shopt -s failglob
++          tarball_pattern="*.tar.gz"
++          tarballs=($tarball_pattern)
++          [[ ${#tarballs[@]} == 1 ]]
++          tarball="${tarballs[0]}"
++          # Get the stem and make the zipfile name.
++          stem="${tarball%.tar.gz}"
++          zipfile="${stem}.zip"
++          # Extract the tarball and rezip it.
++          tar -xzf "$tarball"
++          zip "$zipfile" -r "$stem"
++          rm -r "$stem"
++
++      - uses: actions/upload-artifact@v3
++        with:
++          name: sdist
++          path: |
++            dist/*.tar.gz
++            dist/*.zip
++          if-no-files-found: error
++
++
++  build_wheels:
++    name: Build wheels on ${{ matrix.os }}
++    needs: deploy_test
++    runs-on: ${{ matrix.os }}
++    strategy:
++      matrix:
++        os: [ubuntu-latest, windows-latest, macos-latest]
++    env:
++      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
++      CIBW_BUILD: "cp3{8,9,10,11}-*"
++      # Numpy and SciPy do not supply wheels for i686 or win32 for
++      # Python 3.10+, so we skip those:
++      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
++      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
++
++    steps:
++      - uses: actions/checkout@v3
++
++      - uses: actions/setup-python@v4
++        name: Install Python
++        with:
++          # This is about the build environment, not the released wheel version.
++          python-version: '3.8'
++
++      - name: Install cibuildwheel
++        run: |
++          # cibuildwheel does the heavy lifting for us. Originally tested on
++          # 2.11.3, but should be fine at least up to any minor new release.
++          python -m pip install 'cibuildwheel==2.11.*'
++
++      - name: Build wheels
++        shell: bash
++        run: |
++          # If the version override was specified, then write it the VERSION
++          # file with it.
++          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
++          python -m cibuildwheel --output-dir wheelhouse
++
++      - uses: actions/upload-artifact@v3
++        with:
++          name: wheels
++          path: ./wheelhouse/*.whl
++
++
++  deploy:
++    name: "Deploy to PyPI if desired"
++    # The confirmation is tested explicitly in `deploy_test`, so we know it is
++    # either a missing confirmation (so we shouldn't run this job), 'test' or a
++    # valid confirmation.  We don't need to retest the value of the
++    # confirmation, beyond checking that one existed.
++    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
++    needs: [deploy_test, build_sdist, build_wheels]
++    runs-on: ubuntu-latest
++    env:
++      TWINE_USERNAME: __token__
++      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
++      TWINE_NON_INTERACTIVE: 1
++      TWINE_REPOSITORY: pypi
++
++    steps:
++      - name: Download build artifacts to local runner
++        uses: actions/download-artifact@v3
++
++      - uses: actions/setup-python@v4
++        name: Install Python
++        with:
++          python-version: '3.8'
++
++      - name: Verify this is not a dev version
++        shell: bash
++        run: |
++          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
++          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
++
++      # We built the zipfile for convenience distributing to Windows users on
++      # our end, but PyPI only needs the tarball.
++      - name: Upload sdist and wheels to PyPI
++        run: |
++          python -m pip install "twine"
++          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
++
++
++  deploy_testpypi:
++    name: "Deploy to TestPyPI if desired"
++    if: ${{ github.event.inputs.confirm_ref == 'test' }}
++    needs: [deploy_test, build_sdist, build_wheels]
++    runs-on: ubuntu-latest
++    env:
++      TWINE_USERNAME: __token__
++      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
++      TWINE_NON_INTERACTIVE: 1
++
++    steps:
++      - name: Download build artifacts to local runner
++        uses: actions/download-artifact@v3
++
++      - uses: actions/setup-python@v4
++        name: Install Python
++        with:
++          python-version: '3.8'
++
++      - name: Verify this is not a dev version
++        shell: bash
++        run: |
++          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
++          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
++
++      # We built the zipfile for convenience distributing to Windows users on
++      # our end, but PyPI only needs the tarball.
++      - name: Upload sdist and wheels to TestPyPI
++        run: |
++          python -m pip install "twine"
++          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
+diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml
+index b5c6eb9c..33d94a88 100644
+--- a/.github/workflows/build_documentation.yml
++++ b/.github/workflows/build_documentation.yml
+@@ -1,66 +1,66 @@
+-name: Build documentation
+-
+-on:
+-  [push, pull_request]
+-
+-jobs:
+-  build:
+-    name: Build documentation
+-    runs-on: ubuntu-latest
+-
+-    steps:
+-      - uses: actions/checkout@v3
+-
+-      - uses: actions/setup-python@v4
+-        name: Install Python
+-        with:
+-          python-version: '3.8'
+-
+-      - name: Install documentation dependencies
+-        run: |
+-          pip install pip --upgrade
+-          python -mpip install -r doc/requirements.txt
+-          sudo apt-get update
+-          sudo apt-get install texlive-full
+-
+-      - name: Install QuTiP from GitHub
+-        run: |
+-          # Build without build isolation so that we use the build
+-          # dependencies already installed from doc/requirements.txt.
+-          python -m pip install -e .[full] --no-build-isolation
+-          # Install in editable mode so it doesn't matter if we import from
+-          # inside the installation directory, otherwise we can get some errors
+-          # because we're importing from the wrong location.
+-          python -c 'import qutip; qutip.about()'
+-
+-      - name: Build PDF documentation
+-        working-directory: doc
+-        run: |
+-          make latexpdf SPHINXOPTS="-W --keep-going -T"
+-          # Above flags are:
+-          #   -W : turn warnings into errors
+-          #   --keep-going : do not stop after the first error
+-          #   -T : display a full traceback if a Python exception occurs
+-
+-      - name: Upload built PDF files
+-        uses: actions/upload-artifact@v3
+-        with:
+-          name: qutip_pdf_docs
+-          path: doc/_build/latex/*
+-          if-no-files-found: error
+-
+-      - name: Build HTML documentation
+-        working-directory: doc
+-        run: |
+-          make html SPHINXOPTS="-W --keep-going -T"
+-          # Above flags are:
+-          #   -W : turn warnings into errors
+-          #   --keep-going : do not stop after the first error
+-          #   -T : display a full traceback if a Python exception occurs
+-
+-      - name: Upload built HTML files
+-        uses: actions/upload-artifact@v3
+-        with:
+-          name: qutip_html_docs
+-          path: doc/_build/html/*
+-          if-no-files-found: error
++name: Build documentation
++
++on:
++  [push, pull_request]
++
++jobs:
++  build:
++    name: Build documentation
++    runs-on: ubuntu-latest
++
++    steps:
++      - uses: actions/checkout@v3
++
++      - uses: actions/setup-python@v4
++        name: Install Python
++        with:
++          python-version: '3.8'
++
++      - name: Install documentation dependencies
++        run: |
++          pip install pip --upgrade
++          python -mpip install -r doc/requirements.txt
++          sudo apt-get update
++          sudo apt-get install texlive-full
++
++      - name: Install QuTiP from GitHub
++        run: |
++          # Build without build isolation so that we use the build
++          # dependencies already installed from doc/requirements.txt.
++          python -m pip install -e .[full] --no-build-isolation
++          # Install in editable mode so it doesn't matter if we import from
++          # inside the installation directory, otherwise we can get some errors
++          # because we're importing from the wrong location.
++          python -c 'import qutip; qutip.about()'
++
++      - name: Build PDF documentation
++        working-directory: doc
++        run: |
++          make latexpdf SPHINXOPTS="-W --keep-going -T"
++          # Above flags are:
++          #   -W : turn warnings into errors
++          #   --keep-going : do not stop after the first error
++          #   -T : display a full traceback if a Python exception occurs
++
++      - name: Upload built PDF files
++        uses: actions/upload-artifact@v3
++        with:
++          name: qutip_pdf_docs
++          path: doc/_build/latex/*
++          if-no-files-found: error
++
++      - name: Build HTML documentation
++        working-directory: doc
++        run: |
++          make html SPHINXOPTS="-W --keep-going -T"
++          # Above flags are:
++          #   -W : turn warnings into errors
++          #   --keep-going : do not stop after the first error
++          #   -T : display a full traceback if a Python exception occurs
++
++      - name: Upload built HTML files
++        uses: actions/upload-artifact@v3
++        with:
++          name: qutip_html_docs
++          path: doc/_build/html/*
++          if-no-files-found: error
+diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
+index dd172510..de383e1f 100644
+--- a/.github/workflows/tests.yml
++++ b/.github/workflows/tests.yml
+@@ -1,229 +1,229 @@
+-# The name is short because we mostly care how it appears in the pull request
+-# "checks" dialogue box - it looks like
+-#     Tests / ubuntu-latest, python-3.9, defaults
+-# or similar.
+-name: Tests
+-
+-on:
+-    [push, pull_request]
+-
+-defaults:
+-  run:
+-    # The slightly odd shell call is to force bash to read .bashrc, which is
+-    # necessary for having conda behave sensibly.  We use bash as the shell even
+-    # on Windows, since we don't run anything much complicated, and it makes
+-    # things much simpler.
+-    shell: bash -l -e {0}
+-
+-jobs:
+-  cases:
+-    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
+-    runs-on: ${{ matrix.os }}
+-    env:
+-      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
+-    strategy:
+-      fail-fast: false
+-      matrix:
+-        os: [ubuntu-latest]
+-        # Test other versions of Python in special cases to avoid exploding the
+-        # matrix size; make sure to test all supported versions in some form.
+-        python-version: ["3.9"]
+-        case-name: [defaults]
+-        numpy-requirement: [">=1.20,<1.21"]
+-        coverage-requirement: ["==6.5"]
+-        # Extra special cases.  In these, the new variable defined should always
+-        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
+-        # the lack of a variable is _always_ false-y, and the defaults lack all
+-        # the special cases.
+-        include:
+-          # Mac
+-          # Mac has issues with MKL since september 2022.
+-          - case-name: macos
+-            os: macos-latest
+-            python-version: "3.10"
+-            condaforge: 1
+-            nomkl: 1
+-
+-          # Scipy 1.5
+-          - case-name: old SciPy
+-            os: ubuntu-latest
+-            python-version: "3.8"
+-            numpy-requirement: ">=1.20,<1.21"
+-            scipy-requirement: ">=1.5,<1.6"
+-            condaforge: 1
+-
+-          # No MKL runs.  MKL is now the default for conda installations, but
+-          # not necessarily for pip.
+-          - case-name: no MKL
+-            os: ubuntu-latest
+-            python-version: "3.9"
+-            numpy-requirement: ">=1.20,<1.21"
+-            nomkl: 1
+-
+-          # Builds without Cython at runtime.  This is a core feature;
+-          # everything should be able to run this.
+-          - case-name: no Cython
+-            os: ubuntu-latest
+-            python-version: "3.8"
+-            nocython: 1
+-
+-          # Python 3.10 and numpy 1.22
+-          # Use conda-forge to provide numpy 1.22
+-          - case-name: Python 3.10
+-            os: ubuntu-latest
+-            python-version: "3.10"
+-            condaforge: 1
+-
+-          # Python 3.11 and latest numpy
+-          # Use conda-forge to provide Python 3.11 and latest numpy
+-          # Ignore deprecation of the cgi module in Python 3.11 that is
+-          # still imported by Cython.Tempita. This was addressed in
+-          # https://github.com/cython/cython/pull/5128 but not backported
+-          # to any currently released version.
+-          - case-name: Python 3.11
+-            os: ubuntu-latest
+-            python-version: "3.11"
+-            condaforge: 1
+-            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
+-            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
+-
+-          # Windows. Once all tests pass without special options needed, this
+-          # can be moved to the main os list in the test matrix. All the tests
+-          # that fail currently seem to do so because mcsolve uses
+-          # multiprocessing under the hood. Windows does not support fork()
+-          # well, which makes transfering objects to the child processes
+-          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
+-          - case-name: Windows Latest
+-            os: windows-latest
+-            python-version: "3.10"
+-
+-    steps:
+-      - uses: actions/checkout@v3
+-
+-      - uses: conda-incubator/setup-miniconda@v2
+-        with:
+-          auto-update-conda: true
+-          python-version: ${{ matrix.python-version }}
+-          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
+-
+-      - name: Install QuTiP and dependencies
+-        # In the run, first we handle any special cases.  We do this in bash
+-        # rather than in the GitHub Actions file directly, because bash gives us
+-        # a proper programming language to use.
+-        run: |
+-          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
+-          if [[ -z "${{ matrix.nocython }}" ]]; then
+-            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
+-          fi
+-          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
+-          if [[ -z "${{ matrix.nomkl }}" ]]; then
+-            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+-          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
+-            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
+-            # pip not automatically linking to MKL.
+-            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+-          else
+-            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+-          fi
+-          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
+-            conda install "${{ matrix.conda-extra-pkgs }}"
+-          fi
+-          python -m pip install -e .[$QUTIP_TARGET]
+-          python -m pip install "coverage${{ matrix.coverage-requirement }}"
+-          python -m pip install pytest-cov coveralls pytest-fail-slow
+-
+-      - name: Package information
+-        run: |
+-          conda list
+-          python -c "import qutip; qutip.about()"
+-          python -c "import qutip; print(qutip.settings)"
+-
+-      - name: Environment information
+-        run: |
+-          uname -a
+-          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
+-              hostnamectl
+-              lscpu
+-              free -h
+-          fi
+-
+-      - name: Run tests
+-        # If our tests are running for longer than an hour, _something_ is wrong
+-        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
+-        # to see if something hung.
+-        timeout-minutes: 60
+-        run: |
+-          if [[ -n "${{ matrix.openmp }}" ]]; then
+-            # Force OpenMP runs to use more threads, even if there aren't
+-            # actually that many CPUs.  We have to check any dispatch code is
+-            # truly being executed.
+-            export QUTIP_NUM_PROCESSES=2
+-          fi
+-          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
+-          # Above flags are:
+-          #  -Werror
+-          #     treat warnings as errors
+-          #  --strict-config
+-          #     error out if the configuration file is not parseable
+-          #  --strict-markers
+-          #     error out if a marker is used but not defined in the
+-          #     configuration file
+-          #  --timeout=300
+-          #     error any individual test that goes longer than the given time
+-          #  --durations=0 --durations-min=1.0
+-          #     at the end, show a list of all the tests that took longer than a
+-          #     second to run
+-          #  --verbosity=1
+-          #     turn the verbosity up so pytest prints the names of the tests
+-          #     it's currently working on
+-          #  --cov=qutip
+-          #     limit coverage reporting to code that's within the qutip package
+-          #  --cov-report=
+-          #     don't print the coverage report to the terminal---it just adds
+-          #     cruft, and we're going to upload the .coverage file to Coveralls
+-          #  --color=yes
+-          #     force coloured output in the terminal
+-
+-      - name: Upload to Coveralls
+-        env:
+-          GITHUB_TOKEN: ${{ secrets.github_token }}
+-          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
+-          COVERALLS_PARALLEL: true
+-        run: coveralls --service=github
+-
+-  towncrier-check:
+-    name: Verify Towncrier entry added
+-    runs-on: ubuntu-latest
+-    steps:
+-      - uses: actions/checkout@v3
+-        with:
+-          fetch-depth: 0
+-
+-      - name: Install Towncrier
+-        run: |
+-          python -m pip install towncrier
+-
+-      - name: Verify Towncrier entry added
+-        if: github.event_name == 'pull_request'
+-        env:
+-          BASE_BRANCH: ${{ github.base_ref }}
+-        run: |
+-          # Fetch the pull request' base branch so towncrier will be able to
+-          # compare the current branch with the base branch.
+-          # Source: https://github.com/actions/checkout/#fetch-all-branches.
+-          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
+-          towncrier check --compare-with origin/${BASE_BRANCH}
+-          towncrier build --version "$(cat VERSION)" --draft
+-
+-  finalise:
+-    name: Finalise coverage reporting
+-    needs: cases
+-    runs-on: ubuntu-latest
+-    container: python:3-slim
+-    steps:
+-      - name: Finalise coverage reporting
+-        env:
+-          GITHUB_TOKEN: ${{ secrets.github_token }}
+-        run: |
+-          python -m pip install coveralls
+-          coveralls --service=github --finish
++# The name is short because we mostly care how it appears in the pull request
++# "checks" dialogue box - it looks like
++#     Tests / ubuntu-latest, python-3.9, defaults
++# or similar.
++name: Tests
++
++on:
++    [push, pull_request]
++
++defaults:
++  run:
++    # The slightly odd shell call is to force bash to read .bashrc, which is
++    # necessary for having conda behave sensibly.  We use bash as the shell even
++    # on Windows, since we don't run anything much complicated, and it makes
++    # things much simpler.
++    shell: bash -l -e {0}
++
++jobs:
++  cases:
++    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
++    runs-on: ${{ matrix.os }}
++    env:
++      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
++    strategy:
++      fail-fast: false
++      matrix:
++        os: [ubuntu-latest]
++        # Test other versions of Python in special cases to avoid exploding the
++        # matrix size; make sure to test all supported versions in some form.
++        python-version: ["3.9"]
++        case-name: [defaults]
++        numpy-requirement: [">=1.20,<1.21"]
++        coverage-requirement: ["==6.5"]
++        # Extra special cases.  In these, the new variable defined should always
++        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
++        # the lack of a variable is _always_ false-y, and the defaults lack all
++        # the special cases.
++        include:
++          # Mac
++          # Mac has issues with MKL since september 2022.
++          - case-name: macos
++            os: macos-latest
++            python-version: "3.10"
++            condaforge: 1
++            nomkl: 1
++
++          # Scipy 1.5
++          - case-name: old SciPy
++            os: ubuntu-latest
++            python-version: "3.8"
++            numpy-requirement: ">=1.20,<1.21"
++            scipy-requirement: ">=1.5,<1.6"
++            condaforge: 1
++
++          # No MKL runs.  MKL is now the default for conda installations, but
++          # not necessarily for pip.
++          - case-name: no MKL
++            os: ubuntu-latest
++            python-version: "3.9"
++            numpy-requirement: ">=1.20,<1.21"
++            nomkl: 1
++
++          # Builds without Cython at runtime.  This is a core feature;
++          # everything should be able to run this.
++          - case-name: no Cython
++            os: ubuntu-latest
++            python-version: "3.8"
++            nocython: 1
++
++          # Python 3.10 and numpy 1.22
++          # Use conda-forge to provide numpy 1.22
++          - case-name: Python 3.10
++            os: ubuntu-latest
++            python-version: "3.10"
++            condaforge: 1
++
++          # Python 3.11 and latest numpy
++          # Use conda-forge to provide Python 3.11 and latest numpy
++          # Ignore deprecation of the cgi module in Python 3.11 that is
++          # still imported by Cython.Tempita. This was addressed in
++          # https://github.com/cython/cython/pull/5128 but not backported
++          # to any currently released version.
++          - case-name: Python 3.11
++            os: ubuntu-latest
++            python-version: "3.11"
++            condaforge: 1
++            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
++            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
++
++          # Windows. Once all tests pass without special options needed, this
++          # can be moved to the main os list in the test matrix. All the tests
++          # that fail currently seem to do so because mcsolve uses
++          # multiprocessing under the hood. Windows does not support fork()
++          # well, which makes transfering objects to the child processes
++          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
++          - case-name: Windows Latest
++            os: windows-latest
++            python-version: "3.10"
++
++    steps:
++      - uses: actions/checkout@v3
++
++      - uses: conda-incubator/setup-miniconda@v2
++        with:
++          auto-update-conda: true
++          python-version: ${{ matrix.python-version }}
++          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
++
++      - name: Install QuTiP and dependencies
++        # In the run, first we handle any special cases.  We do this in bash
++        # rather than in the GitHub Actions file directly, because bash gives us
++        # a proper programming language to use.
++        run: |
++          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
++          if [[ -z "${{ matrix.nocython }}" ]]; then
++            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
++          fi
++          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
++          if [[ -z "${{ matrix.nomkl }}" ]]; then
++            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
++          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
++            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
++            # pip not automatically linking to MKL.
++            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
++          else
++            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
++          fi
++          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
++            conda install "${{ matrix.conda-extra-pkgs }}"
++          fi
++          python -m pip install -e .[$QUTIP_TARGET]
++          python -m pip install "coverage${{ matrix.coverage-requirement }}"
++          python -m pip install pytest-cov coveralls pytest-fail-slow
++
++      - name: Package information
++        run: |
++          conda list
++          python -c "import qutip; qutip.about()"
++          python -c "import qutip; print(qutip.settings)"
++
++      - name: Environment information
++        run: |
++          uname -a
++          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
++              hostnamectl
++              lscpu
++              free -h
++          fi
++
++      - name: Run tests
++        # If our tests are running for longer than an hour, _something_ is wrong
++        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
++        # to see if something hung.
++        timeout-minutes: 60
++        run: |
++          if [[ -n "${{ matrix.openmp }}" ]]; then
++            # Force OpenMP runs to use more threads, even if there aren't
++            # actually that many CPUs.  We have to check any dispatch code is
++            # truly being executed.
++            export QUTIP_NUM_PROCESSES=2
++          fi
++          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
++          # Above flags are:
++          #  -Werror
++          #     treat warnings as errors
++          #  --strict-config
++          #     error out if the configuration file is not parseable
++          #  --strict-markers
++          #     error out if a marker is used but not defined in the
++          #     configuration file
++          #  --timeout=300
++          #     error any individual test that goes longer than the given time
++          #  --durations=0 --durations-min=1.0
++          #     at the end, show a list of all the tests that took longer than a
++          #     second to run
++          #  --verbosity=1
++          #     turn the verbosity up so pytest prints the names of the tests
++          #     it's currently working on
++          #  --cov=qutip
++          #     limit coverage reporting to code that's within the qutip package
++          #  --cov-report=
++          #     don't print the coverage report to the terminal---it just adds
++          #     cruft, and we're going to upload the .coverage file to Coveralls
++          #  --color=yes
++          #     force coloured output in the terminal
++
++      - name: Upload to Coveralls
++        env:
++          GITHUB_TOKEN: ${{ secrets.github_token }}
++          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
++          COVERALLS_PARALLEL: true
++        run: coveralls --service=github
++
++  towncrier-check:
++    name: Verify Towncrier entry added
++    runs-on: ubuntu-latest
++    steps:
++      - uses: actions/checkout@v3
++        with:
++          fetch-depth: 0
++
++      - name: Install Towncrier
++        run: |
++          python -m pip install towncrier
++
++      - name: Verify Towncrier entry added
++        if: github.event_name == 'pull_request'
++        env:
++          BASE_BRANCH: ${{ github.base_ref }}
++        run: |
++          # Fetch the pull request' base branch so towncrier will be able to
++          # compare the current branch with the base branch.
++          # Source: https://github.com/actions/checkout/#fetch-all-branches.
++          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
++          towncrier check --compare-with origin/${BASE_BRANCH}
++          towncrier build --version "$(cat VERSION)" --draft
++
++  finalise:
++    name: Finalise coverage reporting
++    needs: cases
++    runs-on: ubuntu-latest
++    container: python:3-slim
++    steps:
++      - name: Finalise coverage reporting
++        env:
++          GITHUB_TOKEN: ${{ secrets.github_token }}
++        run: |
++          python -m pip install coveralls
++          coveralls --service=github --finish
+diff --git a/.gitignore b/.gitignore
+index e9cd9d26..a83f90df 100644
+--- a/.gitignore
++++ b/.gitignore
+@@ -1,45 +1,45 @@
+-*~
+-*.py[cod]
+-*.so
+-.DS_Store
+-.f2py_f2cmap
+-.idea/
+-.vscode/
+-
+-# Packages
+-*.egg
+-.eggs
+-*.egg-info
+-dist
+-build
+-eggs
+-parts
+-bin
+-var
+-sdist
+-develop-eggs
+-.installed.cfg
+-lib
+-lib64
+-
+-
+-qutip/version.py
+-qutip/__config__.py
+-rhs*.pyx
+-
+-qutip/cy/*.c
+-*.cpp
+-*.dat
+-qutip/core/*.h
+-
+-
+-qutip/**/*.html
+-qutip/solver/ode/*.c
+-
+-
+-*.qo
+-
+-benchmark/benchmark_data.js
+-*-tasks.txt
+-*compiled_coeff*
+-result_images/
++*~
++*.py[cod]
++*.so
++.DS_Store
++.f2py_f2cmap
++.idea/
++.vscode/
++
++# Packages
++*.egg
++.eggs
++*.egg-info
++dist
++build
++eggs
++parts
++bin
++var
++sdist
++develop-eggs
++.installed.cfg
++lib
++lib64
++
++
++qutip/version.py
++qutip/__config__.py
++rhs*.pyx
++
++qutip/cy/*.c
++*.cpp
++*.dat
++qutip/core/*.h
++
++
++qutip/**/*.html
++qutip/solver/ode/*.c
++
++
++*.qo
++
++benchmark/benchmark_data.js
++*-tasks.txt
++*compiled_coeff*
++result_images/
+diff --git a/.mailmap b/.mailmap
+index 346044be..3cb7a2a1 100644
+--- a/.mailmap
++++ b/.mailmap
+@@ -1,27 +1,27 @@
+-Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
+-Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
+-Ben Criger <bcriger@gmail.com>
+-Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
+-Kevin Fischer <fischer.kevin.a@gmail.com>
+-Eric Giguère <eric.giguere@calculquebec.ca>
+-Canoming <canoming@163.com>
+-Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
+-Christopher Granade <cgranade@cgranade.com>
+-Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
+-Arne Grimsmo <arne.grimsmo@gmail.com>
+-Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
+-Neill Lambert <nwlambert@gmail.com>
+-Boxi Li <etamin1201@gmail.com>
+-Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
+-Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
+-Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
+-Alexander Pitchford <alex.pitchford@gmail.com>
+-Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
+-Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
+-Tarun Raheja <trolldemort9@gmail.com>
+-Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
+-Sidhant Saraogi <ssaraogi@uwaterloo.ca>
+-Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
+-Anubhav Vardhan <anubhavvardhan@gmail.com>
+-Lucas Verney <phyks@phyks.me>
+-Florestan Ziem <flo.zie@gmx.de>
++Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
++Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
++Ben Criger <bcriger@gmail.com>
++Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
++Kevin Fischer <fischer.kevin.a@gmail.com>
++Eric Giguère <eric.giguere@calculquebec.ca>
++Canoming <canoming@163.com>
++Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
++Christopher Granade <cgranade@cgranade.com>
++Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
++Arne Grimsmo <arne.grimsmo@gmail.com>
++Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
++Neill Lambert <nwlambert@gmail.com>
++Boxi Li <etamin1201@gmail.com>
++Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
++Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
++Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
++Alexander Pitchford <alex.pitchford@gmail.com>
++Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
++Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
++Tarun Raheja <trolldemort9@gmail.com>
++Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
++Sidhant Saraogi <ssaraogi@uwaterloo.ca>
++Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
++Anubhav Vardhan <anubhavvardhan@gmail.com>
++Lucas Verney <phyks@phyks.me>
++Florestan Ziem <flo.zie@gmx.de>
+diff --git a/.readthedocs.yaml b/.readthedocs.yaml
+index c5e12957..4336b479 100644
+--- a/.readthedocs.yaml
++++ b/.readthedocs.yaml
+@@ -1,20 +1,20 @@
+-# .readthedocs.yaml
+-# Read the Docs configuration file
+-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+-
+-version: 2
+-
+-formats:
+-  - pdf
+-
+-build:
+-  os: ubuntu-22.04
+-  tools:
+-    python: "mambaforge-4.10"
+-
+-conda:
+-  environment: doc/rtd-environment.yml
+-
+-sphinx:
+-  configuration: doc/conf.py
++# .readthedocs.yaml
++# Read the Docs configuration file
++# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
++
++version: 2
++
++formats:
++  - pdf
++
++build:
++  os: ubuntu-22.04
++  tools:
++    python: "mambaforge-4.10"
++
++conda:
++  environment: doc/rtd-environment.yml
++
++sphinx:
++  configuration: doc/conf.py
+   fail_on_warning: true
+\ No newline at end of file
+diff --git a/CITATION.bib b/CITATION.bib
+index 143e992d..2ea12d32 100644
+--- a/CITATION.bib
++++ b/CITATION.bib
+@@ -1,26 +1,26 @@
+-@article{qutip2,
+-doi = {10.1016/j.cpc.2012.11.019},
+-url = {https://doi.org/10.1016/j.cpc.2012.11.019},
+-year  = {2013},
+-month = {apr},
+-publisher = {Elsevier {BV}},
+-volume = {184},
+-number = {4},
+-pages = {1234--1240},
+-author = {J.R. Johansson and P.D. Nation and F. Nori},
+-title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
+-journal = {Computer Physics Communications}
+-}
+-@article{qutip1,
+-doi = {10.1016/j.cpc.2012.02.021},
+-url = {https://doi.org/10.1016/j.cpc.2012.02.021},
+-year  = {2012},
+-month = {aug},
+-publisher = {Elsevier {BV}},
+-volume = {183},
+-number = {8},
+-pages = {1760--1772},
+-author = {J.R. Johansson and P.D. Nation and F. Nori},
+-title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
+-journal = {Computer Physics Communications}
++@article{qutip2,
++doi = {10.1016/j.cpc.2012.11.019},
++url = {https://doi.org/10.1016/j.cpc.2012.11.019},
++year  = {2013},
++month = {apr},
++publisher = {Elsevier {BV}},
++volume = {184},
++number = {4},
++pages = {1234--1240},
++author = {J.R. Johansson and P.D. Nation and F. Nori},
++title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
++journal = {Computer Physics Communications}
++}
++@article{qutip1,
++doi = {10.1016/j.cpc.2012.02.021},
++url = {https://doi.org/10.1016/j.cpc.2012.02.021},
++year  = {2012},
++month = {aug},
++publisher = {Elsevier {BV}},
++volume = {183},
++number = {8},
++pages = {1760--1772},
++author = {J.R. Johansson and P.D. Nation and F. Nori},
++title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
++journal = {Computer Physics Communications}
+ }
+\ No newline at end of file
+diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
+index ddf531d0..23c17f3e 100644
+--- a/CODE_OF_CONDUCT.md
++++ b/CODE_OF_CONDUCT.md
+@@ -1,25 +1,25 @@
+-# Contributor Covenant Code of Conduct
+-
+-As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+-
+-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
+-
+-Examples of unacceptable behavior by participants include:
+-
+-* The use of sexualized language or imagery
+-* Personal attacks
+-* Trolling or insulting/derogatory comments
+-* Public or private harassment
+-* Publishing other's private information, such as physical or electronic addresses, without explicit permission
+-* Other unethical or unprofessional conduct
+-
+-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
+-
+-This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
+-
+-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
+-
+-This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
+-
+-[homepage]: https://contributor-covenant.org
+-[version]: https://contributor-covenant.org/version/1/2/
++# Contributor Covenant Code of Conduct
++
++As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
++
++We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
++
++Examples of unacceptable behavior by participants include:
++
++* The use of sexualized language or imagery
++* Personal attacks
++* Trolling or insulting/derogatory comments
++* Public or private harassment
++* Publishing other's private information, such as physical or electronic addresses, without explicit permission
++* Other unethical or unprofessional conduct
++
++Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
++
++This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
++
++Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
++
++This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
++
++[homepage]: https://contributor-covenant.org
++[version]: https://contributor-covenant.org/version/1/2/
+diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
+index 10445685..83f103e9 100644
+--- a/CONTRIBUTING.md
++++ b/CONTRIBUTING.md
+@@ -1,7 +1,7 @@
+-# Contributing to QuTiP Development
+-
+-You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
+-You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
+-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+-
+-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
++# Contributing to QuTiP Development
++
++You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
++You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
++All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
++
++For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+diff --git a/LICENSE.txt b/LICENSE.txt
+index bb2d6131..34e8c029 100644
+--- a/LICENSE.txt
++++ b/LICENSE.txt
+@@ -1,27 +1,27 @@
+-Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
+-All rights reserved.
+-
+-Redistribution and use in source and binary forms, with or without modification,
+-are permitted provided that the following conditions are met:
+-
+-1. Redistributions of source code must retain the above copyright notice, this
+-   list of conditions and the following disclaimer.
+-
+-2. Redistributions in binary form must reproduce the above copyright notice,
+-   this list of conditions and the following disclaimer in the documentation
+-   and/or other materials provided with the distribution.
+-
+-3. Neither the name of the copyright holder nor the names of its contributors
+-   may be used to endorse or promote products derived from this software without
+-   specific prior written permission.
+-
+-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
++All rights reserved.
++
++Redistribution and use in source and binary forms, with or without modification,
++are permitted provided that the following conditions are met:
++
++1. Redistributions of source code must retain the above copyright notice, this
++   list of conditions and the following disclaimer.
++
++2. Redistributions in binary form must reproduce the above copyright notice,
++   this list of conditions and the following disclaimer in the documentation
++   and/or other materials provided with the distribution.
++
++3. Neither the name of the copyright holder nor the names of its contributors
++   may be used to endorse or promote products derived from this software without
++   specific prior written permission.
++
++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
++ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
++WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
++DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
++ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
++(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
++LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
++ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
++SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+diff --git a/MANIFEST.in b/MANIFEST.in
+index dd7423f7..0b5f0e21 100644
+--- a/MANIFEST.in
++++ b/MANIFEST.in
+@@ -1,12 +1,12 @@
+-include README.md
+-include LICENSE.txt
+-include VERSION
+-include requirements.txt
+-include CITATION.bib
+-include pyproject.toml
+-recursive-include qutip *.pyx
+-recursive-include qutip *.pxd
+-recursive-include qutip *.hpp
+-recursive-include qutip *.cpp
+-recursive-include qutip *.ini
++include README.md
++include LICENSE.txt
++include VERSION
++include requirements.txt
++include CITATION.bib
++include pyproject.toml
++recursive-include qutip *.pyx
++recursive-include qutip *.pxd
++recursive-include qutip *.hpp
++recursive-include qutip *.cpp
++recursive-include qutip *.ini
+ recursive-include qutip *.h
+\ No newline at end of file
+diff --git a/README.md b/README.md
+index 376e25b3..03a223d4 100644
+--- a/README.md
++++ b/README.md
+@@ -1,114 +1,114 @@
+-QuTiP: Quantum Toolbox in Python
+-================================
+-
+-[A. Pitchford](https://github.com/ajgpitch),
+-[C. Granade](https://github.com/cgranade),
+-[A. Grimsmo](https://github.com/arnelg),
+-[N. Shammah](https://github.com/nathanshammah),
+-[S. Ahmed](https://github.com/quantshah),
+-[N. Lambert](https://github.com/nwlambert),
+-[E. Giguère](https://github.com/ericgig),
+-[B. Li](https://github.com/boxili),
+-[J. Lishman](https://github.com/jakelishman),
+-[S. Cross](https://github.com/hodgestar),
+-[A. Galicia](https://github.com/AGaliciaMartinez),
+-[P. D. Nation](https://github.com/nonhermitian),
+-and [J. R. Johansson](https://github.com/jrjohansson)
+-
+-[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
+-[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
+-[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
+-[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+-[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
+-[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
+-
+-> **Note**
+->
+-> The master branch now contains the alpha version of QuTiP 5. This is major
+-> revision that breaks compatibility in many small ways withh QuTiP 4.7.
+->
+-> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
+-> please use the `qutip-4.7.X` branch.
+->
+-> If you need to track QuTiP 5 changes or submit  pull request for 5,
+-> please use the `master` branch (and not the `dev.major` branch).
+->
+-> The change to master happened on 16 January 2023 in commit @fccec5d.
+-
+-QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
+-It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
+-QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
+-QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
+-Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
+-
+-Support
+--------
+-
+-[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
+-[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+-
+-We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
+-QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
+-
+-
+-Installation
+-------------
+-
+-[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
+-[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
+-
+-QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
+-You can install QuTiP from `pip` by doing
+-
+-```bash
+-pip install qutip
+-```
+-
+-to get the minimal installation.
+-You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
+-For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
+-
+-All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
+-For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
+-
+-
+-The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
+-
+-```bash
+-pip install --pre qutip
+-```
+-
+-This version breaks compatibility with QuTiP 4.7 in many small ways.
+-Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
+-This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
+-
+-
+-Documentation
+--------------
+-
+-[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
+-
+-The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
+-
+-The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
+-
+-The latest development documentation is available in this repository in the `doc` folder.
+-
+-A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
+-These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
+-
+-
+-Contribute
+-----------
+-
+-You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
+-You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
+-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+-
+-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+-
+-
+-Citing QuTiP
+-------------
+-
+-If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
++QuTiP: Quantum Toolbox in Python
++================================
++
++[A. Pitchford](https://github.com/ajgpitch),
++[C. Granade](https://github.com/cgranade),
++[A. Grimsmo](https://github.com/arnelg),
++[N. Shammah](https://github.com/nathanshammah),
++[S. Ahmed](https://github.com/quantshah),
++[N. Lambert](https://github.com/nwlambert),
++[E. Giguère](https://github.com/ericgig),
++[B. Li](https://github.com/boxili),
++[J. Lishman](https://github.com/jakelishman),
++[S. Cross](https://github.com/hodgestar),
++[A. Galicia](https://github.com/AGaliciaMartinez),
++[P. D. Nation](https://github.com/nonhermitian),
++and [J. R. Johansson](https://github.com/jrjohansson)
++
++[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
++[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
++[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
++[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
++[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
++[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
++
++> **Note**
++>
++> The master branch now contains the alpha version of QuTiP 5. This is major
++> revision that breaks compatibility in many small ways withh QuTiP 4.7.
++>
++> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
++> please use the `qutip-4.7.X` branch.
++>
++> If you need to track QuTiP 5 changes or submit  pull request for 5,
++> please use the `master` branch (and not the `dev.major` branch).
++>
++> The change to master happened on 16 January 2023 in commit @fccec5d.
++
++QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
++It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
++QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
++QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
++Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
++
++Support
++-------
++
++[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
++[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
++
++We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
++QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
++
++
++Installation
++------------
++
++[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
++[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
++
++QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
++You can install QuTiP from `pip` by doing
++
++```bash
++pip install qutip
++```
++
++to get the minimal installation.
++You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
++For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
++
++All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
++For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
++
++
++The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
++
++```bash
++pip install --pre qutip
++```
++
++This version breaks compatibility with QuTiP 4.7 in many small ways.
++Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
++This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
++
++
++Documentation
++-------------
++
++[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
++
++The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
++
++The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
++
++The latest development documentation is available in this repository in the `doc` folder.
++
++A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
++These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
++
++
++Contribute
++----------
++
++You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
++You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
++All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
++
++For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
++
++
++Citing QuTiP
++------------
++
++If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
+diff --git a/VERSION b/VERSION
+index 6f5f6c39..706882a4 100644
+--- a/VERSION
++++ b/VERSION
+@@ -1 +1 @@
+-5.0.0.dev
++5.0.0.dev
+diff --git a/pyproject.toml b/pyproject.toml
+index f854fa46..c858ef1e 100644
+--- a/pyproject.toml
++++ b/pyproject.toml
+@@ -1,54 +1,54 @@
+-[build-system]
+-requires = [
+-    "setuptools",
+-    "packaging",
+-    "wheel",
+-    "cython>=0.29.20",
+-    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
+-    # the recommended way to build against numpy's C API:
+-    "oldest-supported-numpy",
+-    "scipy>=1.0",
+-]
+-build-backend = "setuptools.build_meta"
+-
+-[tool.cibuildwheel]
+-manylinux-x86_64-image = "manylinux2014"
+-manylinux-i686-image = "manylinux2014"
+-# Change in future version to "build"
+-build-frontend = "pip"
+-
+-[[tool.cibuildwheel.overrides]]
+-# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
+-select = "cp3{6,7}-*"
+-manylinux-x86_64-image = "manylinux2010"
+-manylinux-i686-image = "manylinux2010"
+-
+-[tool.towncrier]
+-directory = "doc/changes"
+-filename = "doc/changelog.rst"
+-name = "QuTiP"
+-package = "qutip"
+-[[tool.towncrier.type]]
+-directory = "deprecation"
+-name = "Deprecations"
+-showcontent = true
+-[[tool.towncrier.type]]
+-directory = "feature"
+-name = "Features"
+-showcontent = true
+-[[tool.towncrier.type]]
+-directory = "bugfix"
+-name = "Bug Fixes"
+-showcontent = true
+-[[tool.towncrier.type]]
+-directory = "removal"
+-name = "Removals"
+-showcontent = true
+-[[tool.towncrier.type]]
+-directory = "doc"
+-name = "Documentation"
+-showcontent = true
+-[[tool.towncrier.type]]
+-directory = "misc"
+-name = "Miscellaneous"
+-showcontent = true
++[build-system]
++requires = [
++    "setuptools",
++    "packaging",
++    "wheel",
++    "cython>=0.29.20",
++    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
++    # the recommended way to build against numpy's C API:
++    "oldest-supported-numpy",
++    "scipy>=1.0",
++]
++build-backend = "setuptools.build_meta"
++
++[tool.cibuildwheel]
++manylinux-x86_64-image = "manylinux2014"
++manylinux-i686-image = "manylinux2014"
++# Change in future version to "build"
++build-frontend = "pip"
++
++[[tool.cibuildwheel.overrides]]
++# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
++select = "cp3{6,7}-*"
++manylinux-x86_64-image = "manylinux2010"
++manylinux-i686-image = "manylinux2010"
++
++[tool.towncrier]
++directory = "doc/changes"
++filename = "doc/changelog.rst"
++name = "QuTiP"
++package = "qutip"
++[[tool.towncrier.type]]
++directory = "deprecation"
++name = "Deprecations"
++showcontent = true
++[[tool.towncrier.type]]
++directory = "feature"
++name = "Features"
++showcontent = true
++[[tool.towncrier.type]]
++directory = "bugfix"
++name = "Bug Fixes"
++showcontent = true
++[[tool.towncrier.type]]
++directory = "removal"
++name = "Removals"
++showcontent = true
++[[tool.towncrier.type]]
++directory = "doc"
++name = "Documentation"
++showcontent = true
++[[tool.towncrier.type]]
++directory = "misc"
++name = "Miscellaneous"
++showcontent = true
+diff --git a/qutip/__init__.py b/qutip/__init__.py
+index fc7f65b4..fe889959 100644
+--- a/qutip/__init__.py
++++ b/qutip/__init__.py
+@@ -1,68 +1,68 @@
+-import os
+-import warnings
+-
+-import qutip.settings
+-from qutip.settings import settings
+-import qutip.version
+-from qutip.version import version as __version__
+-
+-# -----------------------------------------------------------------------------
+-# Look to see if we are running with OPENMP
+-#
+-# Set environ variable to determin if running in parallel mode
+-# (i.e. in parfor or parallel_map)
+-os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-
+-
+-# -----------------------------------------------------------------------------
+-# Check that import modules are compatible with requested configuration
+-#
+-
+-# Check for Matplotlib
+-try:
+-    import matplotlib
+-except ImportError:
+-    warnings.warn("matplotlib not found: Graphics will not work.")
+-else:
+-    del matplotlib
+-
+-
+-# -----------------------------------------------------------------------------
+-# Load modules
+-#
+-
+-from .core import *
+-from .solver import *
+-from .solve import nonmarkov
+-import qutip.solve.piqs as piqs
+-from .solve.stochastic import *
+-
+-# graphics
+-from .bloch import *
+-from .visualization import *
+-from .orbital import *
+-from .bloch3d import *
+-from .matplotlib_utilities import *
+-
+-# library functions
+-from .tomography import *
+-from .wigner import *
+-from .random_objects import *
+-from .simdiag import *
+-from .entropy import *
+-from .partial_transpose import *
+-from .continuous_variables import *
+-from .distributions import *
+-from .three_level_atom import *
+-
+-
+-# utilities
+-from .utilities import *
+-from .fileio import *
+-from .about import *
+-from .cite import *
+-
+-# -----------------------------------------------------------------------------
+-# Clean name space
+-#
+-del os, warnings
++import os
++import warnings
++
++import qutip.settings
++from qutip.settings import settings
++import qutip.version
++from qutip.version import version as __version__
++
++# -----------------------------------------------------------------------------
++# Look to see if we are running with OPENMP
++#
++# Set environ variable to determin if running in parallel mode
++# (i.e. in parfor or parallel_map)
++os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++
++
++# -----------------------------------------------------------------------------
++# Check that import modules are compatible with requested configuration
++#
++
++# Check for Matplotlib
++try:
++    import matplotlib
++except ImportError:
++    warnings.warn("matplotlib not found: Graphics will not work.")
++else:
++    del matplotlib
++
++
++# -----------------------------------------------------------------------------
++# Load modules
++#
++
++from .core import *
++from .solver import *
++from .solve import nonmarkov
++import qutip.solve.piqs as piqs
++from .solve.stochastic import *
++
++# graphics
++from .bloch import *
++from .visualization import *
++from .orbital import *
++from .bloch3d import *
++from .matplotlib_utilities import *
++
++# library functions
++from .tomography import *
++from .wigner import *
++from .random_objects import *
++from .simdiag import *
++from .entropy import *
++from .partial_transpose import *
++from .continuous_variables import *
++from .distributions import *
++from .three_level_atom import *
++
++
++# utilities
++from .utilities import *
++from .fileio import *
++from .about import *
++from .cite import *
++
++# -----------------------------------------------------------------------------
++# Clean name space
++#
++del os, warnings
+diff --git a/qutip/_mkl/__init__.py b/qutip/_mkl/__init__.py
+index 8b137891..d3f5a12f 100644
+--- a/qutip/_mkl/__init__.py
++++ b/qutip/_mkl/__init__.py
+@@ -1 +1 @@
+-
++
+diff --git a/qutip/_mkl/spmv.py b/qutip/_mkl/spmv.py
+index ac2ca16c..909e7b4b 100644
+--- a/qutip/_mkl/spmv.py
++++ b/qutip/_mkl/spmv.py
+@@ -1,38 +1,38 @@
+-import numpy as np
+-from ctypes import POINTER, c_int, c_char, byref
+-from numpy.ctypeslib import ndpointer
+-import qutip.settings as qset
+-zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
+-
+-
+-def mkl_spmv(A, x):
+-    """
+-    sparse csr_spmv using MKL
+-    """
+-    m, _ = A.shape
+-
+-    # Pointers to data of the matrix
+-    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
+-    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
+-    indices = A.indices.ctypes.data_as(POINTER(c_int))
+-
+-    # Allocate output, using same conventions as input
+-    if x.ndim == 1:
+-        y = np.empty(m, dtype=np.complex128, order='C')
+-    elif x.ndim == 2 and x.shape[1] == 1:
+-        y = np.empty((m, 1), dtype=np.complex128, order='C')
+-    else:
+-        raise Exception('Input vector must be 1D row or 2D column vector')
+-
+-    # Now call MKL. This returns the answer in the last argument, which shares
+-    # memory with y.
+-    zcsrgemv(
+-        byref(c_char(bytes(b'N'))),
+-        byref(c_int(m)),
+-        data,
+-        indptr,
+-        indices,
+-        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
+-        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
+-    )
+-    return y
++import numpy as np
++from ctypes import POINTER, c_int, c_char, byref
++from numpy.ctypeslib import ndpointer
++import qutip.settings as qset
++zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
++
++
++def mkl_spmv(A, x):
++    """
++    sparse csr_spmv using MKL
++    """
++    m, _ = A.shape
++
++    # Pointers to data of the matrix
++    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
++    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
++    indices = A.indices.ctypes.data_as(POINTER(c_int))
++
++    # Allocate output, using same conventions as input
++    if x.ndim == 1:
++        y = np.empty(m, dtype=np.complex128, order='C')
++    elif x.ndim == 2 and x.shape[1] == 1:
++        y = np.empty((m, 1), dtype=np.complex128, order='C')
++    else:
++        raise Exception('Input vector must be 1D row or 2D column vector')
++
++    # Now call MKL. This returns the answer in the last argument, which shares
++    # memory with y.
++    zcsrgemv(
++        byref(c_char(bytes(b'N'))),
++        byref(c_int(m)),
++        data,
++        indptr,
++        indices,
++        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
++        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
++    )
++    return y
+diff --git a/qutip/_mkl/spsolve.py b/qutip/_mkl/spsolve.py
+index 7a38c515..82d2266b 100644
+--- a/qutip/_mkl/spsolve.py
++++ b/qutip/_mkl/spsolve.py
+@@ -1,405 +1,405 @@
+-import sys
+-import numpy as np
+-import scipy.sparse as sp
+-from ctypes import c_int, byref
+-from numpy.ctypeslib import ndpointer
+-import time
+-from qutip.settings import settings as qset
+-
+-# Load solver functions from mkl_lib
+-pardiso = qset.mkl_lib.pardiso
+-pardiso_delete = qset.mkl_lib.pardiso_handle_delete
+-if sys.maxsize > 2**32: #Running 64-bit
+-    pardiso_64 = qset.mkl_lib.pardiso_64
+-    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
+-
+-
+-def _pardiso_parameters(hermitian, has_perm,
+-                        max_iter_refine,
+-                        scaling_vectors,
+-                        weighted_matching):
+-    iparm = np.zeros(64, dtype=np.int32)
+-    iparm[0] = 1  # Do not use default values
+-    iparm[1] = 3  # Use openmp nested dissection
+-    if has_perm:
+-        iparm[4] = 1
+-    iparm[7] = max_iter_refine  # Max number of iterative refinements
+-    if hermitian:
+-        iparm[9] = 8
+-    else:
+-        iparm[9] = 13
+-    if not hermitian:
+-        iparm[10] = int(scaling_vectors)
+-        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
+-    iparm[17] = -1
+-    iparm[20] = 1
+-    iparm[23] = 1  # Parallel factorization
+-    iparm[26] = 0  # Check matrix structure
+-    iparm[34] = 1  # Use zero-based indexing
+-    return iparm
+-
+-
+-# Set error messages
+-pardiso_error_msgs = {
+-    '-1': 'Input inconsistant',
+-    '-2': 'Out of memory',
+-    '-3': 'Reordering problem',
+-    '-4':
+-        'Zero pivot, numerical factorization or iterative refinement problem',
+-    '-5': 'Unclassified internal error',
+-    '-6': 'Reordering failed',
+-    '-7': 'Diagonal matrix is singular',
+-    '-8': '32-bit integer overflow',
+-    '-9': 'Not enough memory for OOC',
+-    '-10': 'Error opening OOC files',
+-    '-11': 'Read/write error with OOC files',
+-    '-12': 'Pardiso-64 called from 32-bit library',
+-}
+-
+-
+-def _default_solver_args():
+-    return {
+-        'hermitian': False,
+-        'posdef': False,
+-        'max_iter_refine': 10,
+-        'scaling_vectors': True,
+-        'weighted_matching': True,
+-        'return_info': False,
+-    }
+-
+-
+-class mkl_lu:
+-    """
+-    Object pointing to LU factorization of a sparse matrix
+-    generated by mkl_splu.
+-
+-    Methods
+-    -------
+-    solve(b, verbose=False)
+-        Solve system of equations using given RHS vector 'b'.
+-        Returns solution ndarray with same shape as input.
+-
+-    info()
+-        Returns the statistics of the factorization and
+-        solution in the lu.info attribute.
+-
+-    delete()
+-        Deletes the allocated solver memory.
+-
+-    """
+-    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
+-                 indptr=None, indices=None, iparm=None, np_iparm=None,
+-                 mtype=None, perm=None, np_perm=None, factor_time=None):
+-        self._np_pt = np_pt
+-        self._dim = dim
+-        self._is_complex = is_complex
+-        self._data = data
+-        self._indptr = indptr
+-        self._indices = indices
+-        self._iparm = iparm
+-        self._np_iparm = np_iparm
+-        self._mtype = mtype
+-        self._perm = perm
+-        self._np_perm = np_perm
+-        self._factor_time = factor_time
+-        self._solve_time = None
+-
+-    def solve(self, b, verbose=None):
+-        b_shp = b.shape
+-        if b.ndim == 2 and b.shape[1] == 1:
+-            b = b.ravel()
+-            nrhs = 1
+-        elif b.ndim == 2 and b.shape[1] != 1:
+-            nrhs = b.shape[1]
+-            b = b.ravel(order='F')
+-        else:
+-            b = b.ravel()
+-            nrhs = 1
+-
+-        data_type = np.complex128 if self._is_complex else np.float64
+-        if b.dtype != data_type:
+-            b = b.astype(np.complex128, copy=False)
+-
+-        # Create solution array (x) and pointers to x and b
+-        x = np.zeros(b.shape, dtype=data_type, order='C')
+-        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+-        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+-
+-        error = np.zeros(1, dtype=np.int32)
+-        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-
+-        # Call solver
+-        _solve_start = time.time()
+-        pardiso(
+-            self._np_pt,
+-            byref(c_int(1)),
+-            byref(c_int(1)),
+-            byref(c_int(self._mtype)),
+-            byref(c_int(33)),
+-            byref(c_int(self._dim)),
+-            self._data,
+-            self._indptr,
+-            self._indices,
+-            self._np_perm,
+-            byref(c_int(nrhs)),
+-            self._np_iparm,
+-            byref(c_int(0)),
+-            np_b,
+-            np_x,
+-            np_error,
+-        )
+-        self._solve_time = time.time() - _solve_start
+-        if error[0] != 0:
+-            raise Exception(pardiso_error_msgs[str(error[0])])
+-
+-        if verbose:
+-            print('Solution Stage')
+-            print('--------------')
+-            print('Solution time:                  ',
+-                  round(self._solve_time, 4))
+-            print('Solution memory (Mb):           ',
+-                  round(self._iparm[16]/1024, 4))
+-            print('Number of iterative refinements:',
+-                  self._iparm[6])
+-            print('Total memory (Mb):              ',
+-                  round(sum(self._iparm[15:17])/1024, 4))
+-            print()
+-        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
+-
+-    def info(self):
+-        info = {'FactorTime': self._factor_time,
+-                'SolveTime': self._solve_time,
+-                'Factormem': round(self._iparm[15]/1024, 4),
+-                'Solvemem': round(self._iparm[16]/1024, 4),
+-                'IterRefine': self._iparm[6]}
+-        return info
+-
+-    def delete(self):
+-        # Delete all data
+-        error = np.zeros(1, dtype=np.int32)
+-        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-        pardiso(
+-            self._np_pt,
+-            byref(c_int(1)),
+-            byref(c_int(1)),
+-            byref(c_int(self._mtype)),
+-            byref(c_int(-1)),
+-            byref(c_int(self._dim)),
+-            self._data,
+-            self._indptr,
+-            self._indices,
+-            self._np_perm,
+-            byref(c_int(1)),
+-            self._np_iparm,
+-            byref(c_int(0)),
+-            byref(c_int(0)),
+-            byref(c_int(0)),
+-            np_error,
+-        )
+-        if error[0] == -10:
+-            raise Exception('Error freeing solver memory')
+-
+-
+-_MATRIX_TYPE_NAMES = {
+-    4: 'Complex Hermitian positive-definite',
+-    -4: 'Complex Hermitian indefinite',
+-    2: 'Real symmetric positive-definite',
+-    -2: 'Real symmetric indefinite',
+-    11: 'Real non-symmetric',
+-    13: 'Complex non-symmetric',
+-}
+-
+-
+-def _mkl_matrix_type(dtype, solver_args):
+-    if not solver_args['hermitian']:
+-        return 13 if dtype == np.complex128 else 11
+-    out = 4 if dtype == np.complex128 else 2
+-    return out if solver_args['posdef'] else -out
+-
+-
+-def mkl_splu(A, perm=None, verbose=False, **kwargs):
+-    """
+-    Returns the LU factorization of the sparse matrix A.
+-
+-    Parameters
+-    ----------
+-    A : csr_matrix
+-        Sparse input matrix.
+-    perm : ndarray (optional)
+-        User defined matrix factorization permutation.
+-    verbose : bool {False, True}
+-        Report factorization details.
+-
+-    Returns
+-    -------
+-    lu : mkl_lu
+-        Returns object containing LU factorization with a
+-        solve method for solving with a given RHS vector.
+-
+-    """
+-    if not sp.isspmatrix_csr(A):
+-        raise TypeError('Input matrix must be in sparse CSR format.')
+-
+-    if A.shape[0] != A.shape[1]:
+-        raise Exception('Input matrix must be square')
+-
+-    dim = A.shape[0]
+-    solver_args = _default_solver_args()
+-    if set(kwargs) - set(solver_args):
+-        raise ValueError(
+-            "Unknown keyword arguments pass to mkl_splu: {!r}"
+-            .format(set(kwargs) - set(solver_args))
+-        )
+-    solver_args.update(kwargs)
+-
+-    # If hermitian, then take upper-triangle of matrix only
+-    if solver_args['hermitian']:
+-        B = sp.triu(A, format='csr')
+-        A = B  # This gets around making a full copy of A in triu
+-    is_complex = bool(A.dtype == np.complex128)
+-    if not is_complex:
+-        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
+-    data_type = A.dtype
+-
+-    # Create pointer to internal memory
+-    pt = np.zeros(64, dtype=int)
+-    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
+-
+-    # Create pointers to sparse matrix arrays
+-    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+-    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-
+-    # Setup perm array
+-    if perm is None:
+-        perm = np.zeros(dim, dtype=np.int32)
+-        has_perm = 0
+-    else:
+-        has_perm = 1
+-    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-
+-    # setup iparm
+-    iparm = _pardiso_parameters(
+-        solver_args['hermitian'],
+-        has_perm,
+-        solver_args['max_iter_refine'],
+-        solver_args['scaling_vectors'],
+-        solver_args['weighted_matching'],
+-    )
+-    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-
+-    # setup call parameters
+-    mtype = _mkl_matrix_type(data_type, solver_args)
+-
+-    if verbose:
+-        print('Solver Initialization')
+-        print('---------------------')
+-        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
+-        print('Input matrix shape:', A.shape)
+-        print('Input matrix NNZ:  ', A.nnz)
+-        print()
+-
+-    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
+-    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+-    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
+-    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+-
+-    error = np.zeros(1, dtype=np.int32)
+-    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+-
+-    # Call solver
+-    _factor_start = time.time()
+-    pardiso(
+-        np_pt,
+-        byref(c_int(1)),
+-        byref(c_int(1)),
+-        byref(c_int(mtype)),
+-        byref(c_int(12)),
+-        byref(c_int(dim)),
+-        data,
+-        indptr,
+-        indices,
+-        np_perm,
+-        byref(c_int(1)),
+-        np_iparm,
+-        byref(c_int(0)),
+-        np_b,
+-        np_x,
+-        np_error,
+-    )
+-    _factor_time = time.time() - _factor_start
+-    if error[0] != 0:
+-        raise Exception(pardiso_error_msgs[str(error[0])])
+-
+-    if verbose:
+-        print('Analysis and Factorization Stage')
+-        print('--------------------------------')
+-        print('Factorization time:       ', round(_factor_time, 4))
+-        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
+-        print('NNZ in LU factors:        ', iparm[17])
+-        print()
+-
+-    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
+-                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
+-
+-
+-def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
+-    """
+-    Solves a sparse linear system of equations using the
+-    Intel MKL Pardiso solver.
+-
+-    Parameters
+-    ----------
+-    A : csr_matrix
+-        Sparse matrix.
+-    b : ndarray or sparse matrix
+-        The vector or matrix representing the right hand side of the equation.
+-        If a vector, b.shape must be (n,) or (n, 1).
+-    perm : ndarray (optional)
+-        User defined matrix factorization permutation.
+-
+-    Returns
+-    -------
+-    x : ndarray or csr_matrix
+-        The solution of the sparse linear equation.
+-        If b is a vector, then x is a vector of size A.shape[1]
+-        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
+-
+-    """
+-    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
+-    b_is_sparse = sp.isspmatrix(b)
+-    b_shp = b.shape
+-    if b_is_sparse and b.shape[1] == 1:
+-        b = b.toarray()
+-        b_is_sparse = False
+-    elif b_is_sparse and b.shape[1] != 1:
+-        nrhs = b.shape[1]
+-        if lu._is_complex:
+-            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
+-        else:
+-            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
+-
+-    # Do dense RHS solving
+-    if not b_is_sparse:
+-        x = lu.solve(b, verbose=verbose)
+-    # Solve each RHS vec individually and convert to sparse
+-    else:
+-        data_segs = []
+-        row_segs = []
+-        col_segs = []
+-        for j in range(nrhs):
+-            bj = b[:, j].A.ravel()
+-            xj = lu.solve(bj)
+-            w = np.flatnonzero(xj)
+-            segment_length = w.shape[0]
+-            row_segs.append(w)
+-            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
+-            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
+-        sp_data = np.concatenate(data_segs)
+-        sp_row = np.concatenate(row_segs)
+-        sp_col = np.concatenate(col_segs)
+-        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
+-
+-    info = lu.info()
+-    lu.delete()
+-    return (x, info) if kwargs.get('return_info', False) else x
++import sys
++import numpy as np
++import scipy.sparse as sp
++from ctypes import c_int, byref
++from numpy.ctypeslib import ndpointer
++import time
++from qutip.settings import settings as qset
++
++# Load solver functions from mkl_lib
++pardiso = qset.mkl_lib.pardiso
++pardiso_delete = qset.mkl_lib.pardiso_handle_delete
++if sys.maxsize > 2**32: #Running 64-bit
++    pardiso_64 = qset.mkl_lib.pardiso_64
++    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
++
++
++def _pardiso_parameters(hermitian, has_perm,
++                        max_iter_refine,
++                        scaling_vectors,
++                        weighted_matching):
++    iparm = np.zeros(64, dtype=np.int32)
++    iparm[0] = 1  # Do not use default values
++    iparm[1] = 3  # Use openmp nested dissection
++    if has_perm:
++        iparm[4] = 1
++    iparm[7] = max_iter_refine  # Max number of iterative refinements
++    if hermitian:
++        iparm[9] = 8
++    else:
++        iparm[9] = 13
++    if not hermitian:
++        iparm[10] = int(scaling_vectors)
++        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
++    iparm[17] = -1
++    iparm[20] = 1
++    iparm[23] = 1  # Parallel factorization
++    iparm[26] = 0  # Check matrix structure
++    iparm[34] = 1  # Use zero-based indexing
++    return iparm
++
++
++# Set error messages
++pardiso_error_msgs = {
++    '-1': 'Input inconsistant',
++    '-2': 'Out of memory',
++    '-3': 'Reordering problem',
++    '-4':
++        'Zero pivot, numerical factorization or iterative refinement problem',
++    '-5': 'Unclassified internal error',
++    '-6': 'Reordering failed',
++    '-7': 'Diagonal matrix is singular',
++    '-8': '32-bit integer overflow',
++    '-9': 'Not enough memory for OOC',
++    '-10': 'Error opening OOC files',
++    '-11': 'Read/write error with OOC files',
++    '-12': 'Pardiso-64 called from 32-bit library',
++}
++
++
++def _default_solver_args():
++    return {
++        'hermitian': False,
++        'posdef': False,
++        'max_iter_refine': 10,
++        'scaling_vectors': True,
++        'weighted_matching': True,
++        'return_info': False,
++    }
++
++
++class mkl_lu:
++    """
++    Object pointing to LU factorization of a sparse matrix
++    generated by mkl_splu.
++
++    Methods
++    -------
++    solve(b, verbose=False)
++        Solve system of equations using given RHS vector 'b'.
++        Returns solution ndarray with same shape as input.
++
++    info()
++        Returns the statistics of the factorization and
++        solution in the lu.info attribute.
++
++    delete()
++        Deletes the allocated solver memory.
++
++    """
++    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
++                 indptr=None, indices=None, iparm=None, np_iparm=None,
++                 mtype=None, perm=None, np_perm=None, factor_time=None):
++        self._np_pt = np_pt
++        self._dim = dim
++        self._is_complex = is_complex
++        self._data = data
++        self._indptr = indptr
++        self._indices = indices
++        self._iparm = iparm
++        self._np_iparm = np_iparm
++        self._mtype = mtype
++        self._perm = perm
++        self._np_perm = np_perm
++        self._factor_time = factor_time
++        self._solve_time = None
++
++    def solve(self, b, verbose=None):
++        b_shp = b.shape
++        if b.ndim == 2 and b.shape[1] == 1:
++            b = b.ravel()
++            nrhs = 1
++        elif b.ndim == 2 and b.shape[1] != 1:
++            nrhs = b.shape[1]
++            b = b.ravel(order='F')
++        else:
++            b = b.ravel()
++            nrhs = 1
++
++        data_type = np.complex128 if self._is_complex else np.float64
++        if b.dtype != data_type:
++            b = b.astype(np.complex128, copy=False)
++
++        # Create solution array (x) and pointers to x and b
++        x = np.zeros(b.shape, dtype=data_type, order='C')
++        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
++        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
++
++        error = np.zeros(1, dtype=np.int32)
++        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++
++        # Call solver
++        _solve_start = time.time()
++        pardiso(
++            self._np_pt,
++            byref(c_int(1)),
++            byref(c_int(1)),
++            byref(c_int(self._mtype)),
++            byref(c_int(33)),
++            byref(c_int(self._dim)),
++            self._data,
++            self._indptr,
++            self._indices,
++            self._np_perm,
++            byref(c_int(nrhs)),
++            self._np_iparm,
++            byref(c_int(0)),
++            np_b,
++            np_x,
++            np_error,
++        )
++        self._solve_time = time.time() - _solve_start
++        if error[0] != 0:
++            raise Exception(pardiso_error_msgs[str(error[0])])
++
++        if verbose:
++            print('Solution Stage')
++            print('--------------')
++            print('Solution time:                  ',
++                  round(self._solve_time, 4))
++            print('Solution memory (Mb):           ',
++                  round(self._iparm[16]/1024, 4))
++            print('Number of iterative refinements:',
++                  self._iparm[6])
++            print('Total memory (Mb):              ',
++                  round(sum(self._iparm[15:17])/1024, 4))
++            print()
++        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
++
++    def info(self):
++        info = {'FactorTime': self._factor_time,
++                'SolveTime': self._solve_time,
++                'Factormem': round(self._iparm[15]/1024, 4),
++                'Solvemem': round(self._iparm[16]/1024, 4),
++                'IterRefine': self._iparm[6]}
++        return info
++
++    def delete(self):
++        # Delete all data
++        error = np.zeros(1, dtype=np.int32)
++        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++        pardiso(
++            self._np_pt,
++            byref(c_int(1)),
++            byref(c_int(1)),
++            byref(c_int(self._mtype)),
++            byref(c_int(-1)),
++            byref(c_int(self._dim)),
++            self._data,
++            self._indptr,
++            self._indices,
++            self._np_perm,
++            byref(c_int(1)),
++            self._np_iparm,
++            byref(c_int(0)),
++            byref(c_int(0)),
++            byref(c_int(0)),
++            np_error,
++        )
++        if error[0] == -10:
++            raise Exception('Error freeing solver memory')
++
++
++_MATRIX_TYPE_NAMES = {
++    4: 'Complex Hermitian positive-definite',
++    -4: 'Complex Hermitian indefinite',
++    2: 'Real symmetric positive-definite',
++    -2: 'Real symmetric indefinite',
++    11: 'Real non-symmetric',
++    13: 'Complex non-symmetric',
++}
++
++
++def _mkl_matrix_type(dtype, solver_args):
++    if not solver_args['hermitian']:
++        return 13 if dtype == np.complex128 else 11
++    out = 4 if dtype == np.complex128 else 2
++    return out if solver_args['posdef'] else -out
++
++
++def mkl_splu(A, perm=None, verbose=False, **kwargs):
++    """
++    Returns the LU factorization of the sparse matrix A.
++
++    Parameters
++    ----------
++    A : csr_matrix
++        Sparse input matrix.
++    perm : ndarray (optional)
++        User defined matrix factorization permutation.
++    verbose : bool {False, True}
++        Report factorization details.
++
++    Returns
++    -------
++    lu : mkl_lu
++        Returns object containing LU factorization with a
++        solve method for solving with a given RHS vector.
++
++    """
++    if not sp.isspmatrix_csr(A):
++        raise TypeError('Input matrix must be in sparse CSR format.')
++
++    if A.shape[0] != A.shape[1]:
++        raise Exception('Input matrix must be square')
++
++    dim = A.shape[0]
++    solver_args = _default_solver_args()
++    if set(kwargs) - set(solver_args):
++        raise ValueError(
++            "Unknown keyword arguments pass to mkl_splu: {!r}"
++            .format(set(kwargs) - set(solver_args))
++        )
++    solver_args.update(kwargs)
++
++    # If hermitian, then take upper-triangle of matrix only
++    if solver_args['hermitian']:
++        B = sp.triu(A, format='csr')
++        A = B  # This gets around making a full copy of A in triu
++    is_complex = bool(A.dtype == np.complex128)
++    if not is_complex:
++        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
++    data_type = A.dtype
++
++    # Create pointer to internal memory
++    pt = np.zeros(64, dtype=int)
++    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
++
++    # Create pointers to sparse matrix arrays
++    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
++    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++
++    # Setup perm array
++    if perm is None:
++        perm = np.zeros(dim, dtype=np.int32)
++        has_perm = 0
++    else:
++        has_perm = 1
++    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++
++    # setup iparm
++    iparm = _pardiso_parameters(
++        solver_args['hermitian'],
++        has_perm,
++        solver_args['max_iter_refine'],
++        solver_args['scaling_vectors'],
++        solver_args['weighted_matching'],
++    )
++    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++
++    # setup call parameters
++    mtype = _mkl_matrix_type(data_type, solver_args)
++
++    if verbose:
++        print('Solver Initialization')
++        print('---------------------')
++        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
++        print('Input matrix shape:', A.shape)
++        print('Input matrix NNZ:  ', A.nnz)
++        print()
++
++    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
++    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
++    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
++    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
++
++    error = np.zeros(1, dtype=np.int32)
++    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
++
++    # Call solver
++    _factor_start = time.time()
++    pardiso(
++        np_pt,
++        byref(c_int(1)),
++        byref(c_int(1)),
++        byref(c_int(mtype)),
++        byref(c_int(12)),
++        byref(c_int(dim)),
++        data,
++        indptr,
++        indices,
++        np_perm,
++        byref(c_int(1)),
++        np_iparm,
++        byref(c_int(0)),
++        np_b,
++        np_x,
++        np_error,
++    )
++    _factor_time = time.time() - _factor_start
++    if error[0] != 0:
++        raise Exception(pardiso_error_msgs[str(error[0])])
++
++    if verbose:
++        print('Analysis and Factorization Stage')
++        print('--------------------------------')
++        print('Factorization time:       ', round(_factor_time, 4))
++        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
++        print('NNZ in LU factors:        ', iparm[17])
++        print()
++
++    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
++                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
++
++
++def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
++    """
++    Solves a sparse linear system of equations using the
++    Intel MKL Pardiso solver.
++
++    Parameters
++    ----------
++    A : csr_matrix
++        Sparse matrix.
++    b : ndarray or sparse matrix
++        The vector or matrix representing the right hand side of the equation.
++        If a vector, b.shape must be (n,) or (n, 1).
++    perm : ndarray (optional)
++        User defined matrix factorization permutation.
++
++    Returns
++    -------
++    x : ndarray or csr_matrix
++        The solution of the sparse linear equation.
++        If b is a vector, then x is a vector of size A.shape[1]
++        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
++
++    """
++    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
++    b_is_sparse = sp.isspmatrix(b)
++    b_shp = b.shape
++    if b_is_sparse and b.shape[1] == 1:
++        b = b.toarray()
++        b_is_sparse = False
++    elif b_is_sparse and b.shape[1] != 1:
++        nrhs = b.shape[1]
++        if lu._is_complex:
++            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
++        else:
++            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
++
++    # Do dense RHS solving
++    if not b_is_sparse:
++        x = lu.solve(b, verbose=verbose)
++    # Solve each RHS vec individually and convert to sparse
++    else:
++        data_segs = []
++        row_segs = []
++        col_segs = []
++        for j in range(nrhs):
++            bj = b[:, j].A.ravel()
++            xj = lu.solve(bj)
++            w = np.flatnonzero(xj)
++            segment_length = w.shape[0]
++            row_segs.append(w)
++            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
++            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
++        sp_data = np.concatenate(data_segs)
++        sp_row = np.concatenate(row_segs)
++        sp_col = np.concatenate(col_segs)
++        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
++
++    info = lu.info()
++    lu.delete()
++    return (x, info) if kwargs.get('return_info', False) else x
+diff --git a/qutip/about.py b/qutip/about.py
+index 0e5eb166..57e7322c 100644
+--- a/qutip/about.py
++++ b/qutip/about.py
+@@ -1,75 +1,75 @@
+-"""
+-Command line output of information on QuTiP and dependencies.
+-"""
+-__all__ = ['about']
+-
+-import sys
+-import os
+-import platform
+-import numpy
+-import scipy
+-import inspect
+-import qutip
+-from qutip.settings import _blas_info, settings
+-
+-
+-def about():
+-    """
+-    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
+-    and MatPlotLib.
+-    """
+-    print("")
+-    print("QuTiP: Quantum Toolbox in Python")
+-    print("================================")
+-    print("Copyright (c) QuTiP team 2011 and later.")
+-    print(
+-        "Current admin team: Alexander Pitchford, "
+-        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
+-        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
+-    )
+-    print(
+-        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
+-        "Franco Nori and Will Zeng."
+-    )
+-    print("Original developers: R. J. Johansson & P. D. Nation.")
+-    print("Previous lead developers: Chris Granade & A. Grimsmo.")
+-    print("Currently developed through wide collaboration. "
+-          "See https://github.com/qutip for details.")
+-    print("")
+-    print("QuTiP Version:      %s" % qutip.__version__)
+-    print("Numpy Version:      %s" % numpy.__version__)
+-    print("Scipy Version:      %s" % scipy.__version__)
+-    try:
+-        import Cython
+-        cython_ver = Cython.__version__
+-    except ImportError:
+-        cython_ver = 'None'
+-    print("Cython Version:     %s" % cython_ver)
+-    try:
+-        import matplotlib
+-        matplotlib_ver = matplotlib.__version__
+-    except ImportError:
+-        matplotlib_ver = 'None'
+-    print("Matplotlib Version: %s" % matplotlib_ver)
+-    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
+-    print("Number of CPUs:     %s" % settings.num_cpus)
+-    print("BLAS Info:          %s" % _blas_info())
+-    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
+-    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
+-    print("Platform Info:      %s (%s)" % (platform.system(),
+-                                           platform.machine()))
+-    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
+-    print("Installation path:  %s" % qutip_install_path)
+-
+-    # citation
+-    longbar = "=" * 80
+-    cite_msg = "For your convenience a bibtex reference can be easily"
+-    cite_msg += " generated using `qutip.cite()`"
+-    print(longbar)
+-    print("Please cite QuTiP in your publication.")
+-    print(longbar)
+-    print(cite_msg)
+-
+-
+-if __name__ == "__main__":
+-    about()
++"""
++Command line output of information on QuTiP and dependencies.
++"""
++__all__ = ['about']
++
++import sys
++import os
++import platform
++import numpy
++import scipy
++import inspect
++import qutip
++from qutip.settings import _blas_info, settings
++
++
++def about():
++    """
++    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
++    and MatPlotLib.
++    """
++    print("")
++    print("QuTiP: Quantum Toolbox in Python")
++    print("================================")
++    print("Copyright (c) QuTiP team 2011 and later.")
++    print(
++        "Current admin team: Alexander Pitchford, "
++        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
++        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
++    )
++    print(
++        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
++        "Franco Nori and Will Zeng."
++    )
++    print("Original developers: R. J. Johansson & P. D. Nation.")
++    print("Previous lead developers: Chris Granade & A. Grimsmo.")
++    print("Currently developed through wide collaboration. "
++          "See https://github.com/qutip for details.")
++    print("")
++    print("QuTiP Version:      %s" % qutip.__version__)
++    print("Numpy Version:      %s" % numpy.__version__)
++    print("Scipy Version:      %s" % scipy.__version__)
++    try:
++        import Cython
++        cython_ver = Cython.__version__
++    except ImportError:
++        cython_ver = 'None'
++    print("Cython Version:     %s" % cython_ver)
++    try:
++        import matplotlib
++        matplotlib_ver = matplotlib.__version__
++    except ImportError:
++        matplotlib_ver = 'None'
++    print("Matplotlib Version: %s" % matplotlib_ver)
++    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
++    print("Number of CPUs:     %s" % settings.num_cpus)
++    print("BLAS Info:          %s" % _blas_info())
++    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
++    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
++    print("Platform Info:      %s (%s)" % (platform.system(),
++                                           platform.machine()))
++    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
++    print("Installation path:  %s" % qutip_install_path)
++
++    # citation
++    longbar = "=" * 80
++    cite_msg = "For your convenience a bibtex reference can be easily"
++    cite_msg += " generated using `qutip.cite()`"
++    print(longbar)
++    print("Please cite QuTiP in your publication.")
++    print(longbar)
++    print(cite_msg)
++
++
++if __name__ == "__main__":
++    about()
+diff --git a/qutip/bloch.py b/qutip/bloch.py
+index 980502dd..e67ed504 100644
+--- a/qutip/bloch.py
++++ b/qutip/bloch.py
+@@ -1,928 +1,928 @@
+-__all__ = ['Bloch']
+-
+-import os
+-
+-import numpy as np
+-from numpy import (outer, cos, sin, ones)
+-
+-from packaging.version import parse as parse_version
+-
+-from . import Qobj, expect, sigmax, sigmay, sigmaz
+-
+-try:
+-    import matplotlib
+-    import matplotlib.pyplot as plt
+-    from mpl_toolkits.mplot3d import Axes3D
+-    from matplotlib.patches import FancyArrowPatch
+-    from mpl_toolkits.mplot3d import proj3d
+-
+-    # Define a custom _axes3D function based on the matplotlib version.
+-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+-    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
+-        def _axes3D(fig, *args, **kwargs):
+-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+-            return fig.add_axes(ax)
+-    else:
+-        def _axes3D(*args, **kwargs):
+-            return Axes3D(*args, **kwargs)
+-
+-    class Arrow3D(FancyArrowPatch):
+-        def __init__(self, xs, ys, zs, *args, **kwargs):
+-            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
+-
+-            self._verts3d = xs, ys, zs
+-
+-        def draw(self, renderer):
+-            xs3d, ys3d, zs3d = self._verts3d
+-            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+-
+-            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+-            FancyArrowPatch.draw(self, renderer)
+-
+-        def do_3d_projection(self, renderer=None):
+-            # only called by matplotlib >= 3.5
+-            xs3d, ys3d, zs3d = self._verts3d
+-            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+-            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+-            return np.min(zs)
+-except ImportError:
+-    pass
+-
+-try:
+-    from IPython.display import display
+-except ImportError:
+-    pass
+-
+-
+-class Bloch:
+-    r"""
+-    Class for plotting data on the Bloch sphere.  Valid data can be either
+-    points, vectors, or Qobj objects.
+-
+-    Attributes
+-    ----------
+-    axes : matplotlib.axes.Axes
+-        User supplied Matplotlib axes for Bloch sphere animation.
+-    fig : matplotlib.figure.Figure
+-        User supplied Matplotlib Figure instance for plotting Bloch sphere.
+-    font_color : str, default 'black'
+-        Color of font used for Bloch sphere labels.
+-    font_size : int, default 20
+-        Size of font used for Bloch sphere labels.
+-    frame_alpha : float, default 0.1
+-        Sets transparency of Bloch sphere frame.
+-    frame_color : str, default 'gray'
+-        Color of sphere wireframe.
+-    frame_width : int, default 1
+-        Width of wireframe.
+-    point_color : list, default ["b", "r", "g", "#CC6600"]
+-        List of colors for Bloch sphere point markers to cycle through, i.e.
+-        by default, points 0 and 4 will both be blue ('b').
+-    point_marker : list, default ["o", "s", "d", "^"]
+-        List of point marker shapes to cycle through.
+-    point_size : list, default [25, 32, 35, 45]
+-        List of point marker sizes. Note, not all point markers look the same
+-        size when plotted!
+-    sphere_alpha : float, default 0.2
+-        Transparency of Bloch sphere itself.
+-    sphere_color : str, default '#FFDDDD'
+-        Color of Bloch sphere.
+-    figsize : list, default [7, 7]
+-        Figure size of Bloch sphere plot.  Best to have both numbers the same;
+-        otherwise you will have a Bloch sphere that looks like a football.
+-    vector_color : list, ["g", "#CC6600", "b", "r"]
+-        List of vector colors to cycle through.
+-    vector_width : int, default 5
+-        Width of displayed vectors.
+-    vector_style : str, default '-\|>'
+-        Vector arrowhead style (from matplotlib's arrow style).
+-    vector_mutation : int, default 20
+-        Width of vectors arrowhead.
+-    view : list, default [-60, 30]
+-        Azimuthal and Elevation viewing angles.
+-    xlabel : list, default ["$x$", ""]
+-        List of strings corresponding to +x and -x axes labels, respectively.
+-    xlpos : list, default [1.1, -1.1]
+-        Positions of +x and -x labels respectively.
+-    ylabel : list, default ["$y$", ""]
+-        List of strings corresponding to +y and -y axes labels, respectively.
+-    ylpos : list, default [1.2, -1.2]
+-        Positions of +y and -y labels respectively.
+-    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
+-        List of strings corresponding to +z and -z axes labels, respectively.
+-    zlpos : list, default [1.2, -1.2]
+-        Positions of +z and -z labels respectively.
+-    """
+-    def __init__(self, fig=None, axes=None, view=None, figsize=None,
+-                 background=False):
+-        # Figure and axes
+-        self.fig = fig
+-        self._ext_fig = fig is not None
+-        self.axes = axes
+-        # Background axes, default = False
+-        self.background = background
+-        # The size of the figure in inches, default = [5,5].
+-        self.figsize = figsize if figsize else [5, 5]
+-        # Azimuthal and Elvation viewing angles, default = [-60,30].
+-        self.view = view if view else [-60, 30]
+-        # Color of Bloch sphere, default = #FFDDDD
+-        self.sphere_color = '#FFDDDD'
+-        # Transparency of Bloch sphere, default = 0.2
+-        self.sphere_alpha = 0.2
+-        # Color of wireframe, default = 'gray'
+-        self.frame_color = 'gray'
+-        # Width of wireframe, default = 1
+-        self.frame_width = 1
+-        # Transparency of wireframe, default = 0.2
+-        self.frame_alpha = 0.2
+-        # Labels for x-axis (in LaTex), default = ['$x$', '']
+-        self.xlabel = ['$x$', '']
+-        # Position of x-axis labels, default = [1.2, -1.2]
+-        self.xlpos = [1.2, -1.2]
+-        # Labels for y-axis (in LaTex), default = ['$y$', '']
+-        self.ylabel = ['$y$', '']
+-        # Position of y-axis labels, default = [1.1, -1.1]
+-        self.ylpos = [1.2, -1.2]
+-        # Labels for z-axis (in LaTex),
+-        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
+-        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
+-        # Position of z-axis labels, default = [1.2, -1.2]
+-        self.zlpos = [1.2, -1.2]
+-        # ---font options---
+-        # Color of fonts, default = 'black'
+-        self.font_color = 'black'
+-        # Size of fonts, default = 20
+-        self.font_size = 20
+-
+-        # ---vector options---
+-        # List of colors for Bloch vectors, default = ['b','g','r','y']
+-        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
+-        # List that stores the display colors for each vector
+-        self.vector_color = []
+-        #: Width of Bloch vectors, default = 5
+-        self.vector_width = 3
+-        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
+-        self.vector_style = '-|>'
+-        #: Sets the width of the vectors arrowhead
+-        self.vector_mutation = 20
+-
+-        # ---point options---
+-        # List of colors for Bloch point markers, default = ['b','g','r','y']
+-        self.point_default_color = ['b', 'r', 'g', '#CC6600']
+-        # List that stores the display colors for each set of points
+-        self.point_color = []
+-        # Size of point markers, default = 25
+-        self.point_size = [25, 32, 35, 45]
+-        # Shape of point markers, default = ['o','^','d','s']
+-        self.point_marker = ['o', 's', 'd', '^']
+-
+-        # ---data lists---
+-        # Data for point markers
+-        self.points = []
+-        # Data for Bloch vectors
+-        self.vectors = []
+-        # Transparency of vectors, alpha value from 0 to 1
+-        self.vector_alpha = []
+-        # Data for annotations
+-        self.annotations = []
+-        # Number of times sphere has been saved
+-        self.savenum = 0
+-        # Style of points, 'm' for multiple colors, 's' for single color
+-        self.point_style = []
+-        # Transparency of points, alpha value from 0 to 1
+-        self.point_alpha = []
+-        # Data for line segment
+-        self._lines = []
+-        # Data for arcs and arc style
+-        self._arcs = []
+-
+-    def set_label_convention(self, convention):
+-        """Set x, y and z labels according to one of conventions.
+-
+-        Parameters
+-        ----------
+-        convention : string
+-            One of the following:
+-
+-            - "original"
+-            - "xyz"
+-            - "sx sy sz"
+-            - "01"
+-            - "polarization jones"
+-            - "polarization jones letters"
+-              see also: https://en.wikipedia.org/wiki/Jones_calculus
+-            - "polarization stokes"
+-              see also: https://en.wikipedia.org/wiki/Stokes_parameters
+-        """
+-        ketex = "$\\left.|%s\\right\\rangle$"
+-        # \left.| is on purpose, so that every ket has the same size
+-
+-        if convention == "original":
+-            self.xlabel = ['$x$', '']
+-            self.ylabel = ['$y$', '']
+-            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
+-        elif convention == "xyz":
+-            self.xlabel = ['$x$', '']
+-            self.ylabel = ['$y$', '']
+-            self.zlabel = ['$z$', '']
+-        elif convention == "sx sy sz":
+-            self.xlabel = ['$s_x$', '']
+-            self.ylabel = ['$s_y$', '']
+-            self.zlabel = ['$s_z$', '']
+-        elif convention == "01":
+-            self.xlabel = ['', '']
+-            self.ylabel = ['', '']
+-            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
+-        elif convention == "polarization jones":
+-            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
+-                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
+-            self.ylabel = [ketex % "\\circlearrowleft", ketex %
+-                           "\\circlearrowright"]
+-            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
+-        elif convention == "polarization jones letters":
+-            self.xlabel = [ketex % "D", ketex % "A"]
+-            self.ylabel = [ketex % "L", ketex % "R"]
+-            self.zlabel = [ketex % "H", ketex % "V"]
+-        elif convention == "polarization stokes":
+-            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
+-                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
+-            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
+-            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
+-        else:
+-            raise Exception("No such convention.")
+-
+-    def __str__(self):
+-        s = ""
+-        s += "Bloch data:\n"
+-        s += "-----------\n"
+-        s += "Number of points:  " + str(len(self.points)) + "\n"
+-        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
+-        s += "\n"
+-        s += "Bloch sphere properties:\n"
+-        s += "------------------------\n"
+-        s += "font_color:      " + str(self.font_color) + "\n"
+-        s += "font_size:       " + str(self.font_size) + "\n"
+-        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
+-        s += "frame_color:     " + str(self.frame_color) + "\n"
+-        s += "frame_width:     " + str(self.frame_width) + "\n"
+-        s += "point_default_color:" + str(self.point_default_color) + "\n"
+-        s += "point_marker:    " + str(self.point_marker) + "\n"
+-        s += "point_size:      " + str(self.point_size) + "\n"
+-        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
+-        s += "sphere_color:    " + str(self.sphere_color) + "\n"
+-        s += "figsize:         " + str(self.figsize) + "\n"
+-        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
+-        s += "vector_width:    " + str(self.vector_width) + "\n"
+-        s += "vector_style:    " + str(self.vector_style) + "\n"
+-        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
+-        s += "view:            " + str(self.view) + "\n"
+-        s += "xlabel:          " + str(self.xlabel) + "\n"
+-        s += "xlpos:           " + str(self.xlpos) + "\n"
+-        s += "ylabel:          " + str(self.ylabel) + "\n"
+-        s += "ylpos:           " + str(self.ylpos) + "\n"
+-        s += "zlabel:          " + str(self.zlabel) + "\n"
+-        s += "zlpos:           " + str(self.zlpos) + "\n"
+-        return s
+-
+-    def _repr_png_(self):
+-        from IPython.core.pylabtools import print_figure
+-        self.render()
+-        fig_data = print_figure(self.fig, 'png')
+-        plt.close(self.fig)
+-        return fig_data
+-
+-    def _repr_svg_(self):
+-        from IPython.core.pylabtools import print_figure
+-        self.render()
+-        fig_data = print_figure(self.fig, 'svg')
+-        plt.close(self.fig)
+-        return fig_data
+-
+-    def clear(self):
+-        """Resets Bloch sphere data sets to empty.
+-        """
+-        self.points = []
+-        self.vectors = []
+-        self.point_style = []
+-        self.point_alpha = []
+-        self.vector_alpha = []
+-        self.annotations = []
+-        self.vector_color = []
+-        self.point_color = []
+-        self._lines = []
+-        self._arcs = []
+-
+-    def add_points(self, points, meth='s', colors=None, alpha=1.0):
+-        """Add a list of data points to bloch sphere.
+-
+-        Parameters
+-        ----------
+-        points : array_like
+-            Collection of data points.
+-
+-        meth : {'s', 'm', 'l'}
+-            Type of points to plot, use 'm' for multicolored, 'l' for points
+-            connected with a line.
+-
+-        colors : array_like
+-            Optional array with colors for the points.
+-            A single color for meth 's', and list of colors for meth 'm'
+-
+-        alpha : float, default=1.
+-            Transparency value for the vectors. Values between 0 and 1.
+-
+-        .. note::
+-
+-           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
+-           to ``0.75`` and there was no way to alter it.
+-           When the ``alpha`` parameter was added in QuTiP 4.7, the default
+-           became ``alpha=1.0`` for values of ``meth``.
+-        """
+-
+-        points = np.asarray(points)
+-
+-        if points.ndim == 1:
+-            points = points[:, np.newaxis]
+-
+-        if points.ndim != 2 or points.shape[0] != 3:
+-            raise ValueError("The included points are not valid. Points must "
+-                             "be equivalent to a 2D array where the first "
+-                             "index represents the x,y,z values and the "
+-                             "second index iterates over the points.")
+-
+-        if meth not in ['s', 'm', 'l']:
+-            raise ValueError(f"The value for meth = {meth} is not valid."
+-                             " Please use 's', 'l' or 'm'.")
+-
+-        if meth == 's' and points.shape[1] == 1:
+-            points = np.append(points[:, :1], points, axis=1)
+-
+-        self.point_style.append(meth)
+-        self.points.append(points)
+-        self.point_alpha.append(alpha)
+-        self.point_color.append(colors)
+-
+-    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
+-        """Add a state vector Qobj to Bloch sphere.
+-
+-        Parameters
+-        ----------
+-        state : Qobj
+-            Input state vector.
+-
+-        kind : {'vector', 'point'}
+-            Type of object to plot.
+-
+-        colors : array_like
+-            Optional array with colors for the states.
+-
+-        alpha : float, default=1.
+-            Transparency value for the vectors. Values between 0 and 1.
+-        """
+-        if isinstance(state, Qobj):
+-            state = [state]
+-        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
+-            colors = [colors]
+-
+-        for k, st in enumerate(state):
+-            vec = [expect(sigmax(), st),
+-                   expect(sigmay(), st),
+-                   expect(sigmaz(), st)]
+-
+-            if kind == 'vector':
+-                if colors is not None:
+-                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
+-                else:
+-                    self.add_vectors(vec)
+-            elif kind == 'point':
+-                if colors is not None:
+-                    self.add_points(vec, colors=colors[k], alpha=alpha)
+-                else:
+-                    self.add_points(vec)
+-
+-    def add_vectors(self, vectors, colors=None, alpha=1.0):
+-        """Add a list of vectors to Bloch sphere.
+-
+-        Parameters
+-        ----------
+-        vectors : array_like
+-            Array with vectors of unit length or smaller.
+-
+-        colors : array_like
+-            Optional array with colors for the vectors.
+-
+-        alpha : float, default=1.
+-            Transparency value for the vectors. Values between 0 and 1.
+-
+-        """
+-        vectors = np.asarray(vectors)
+-
+-        if vectors.ndim == 1:
+-            vectors = vectors[np.newaxis, :]
+-
+-        if vectors.ndim != 2 or vectors.shape[1] != 3:
+-            raise ValueError(
+-                "The included vectors are not valid. Vectors must "
+-                "be equivalent to a 2D array where the first "
+-                "index represents the iteration over the vectors and the "
+-                "second index represents the position in 3D of vector head.")
+-
+-        n_vectors = vectors.shape[0]
+-        if colors is None:
+-            colors = np.array([None] * n_vectors)
+-        else:
+-            colors = np.asarray(colors)
+-
+-        if colors.ndim != 1 or colors.size != n_vectors:
+-            raise ValueError("The included colors are not valid. colors must "
+-                             "be equivalent to a 1D array with the same "
+-                             "size as the number of vectors. ")
+-
+-        for k, vec in enumerate(vectors):
+-            self.vectors.append(vec)
+-            self.vector_alpha.append(alpha)
+-            self.vector_color.append(colors[k])
+-
+-    def add_annotation(self, state_or_vector, text, **kwargs):
+-        """
+-        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
+-        state or a vector.
+-
+-        Parameters
+-        ----------
+-        state_or_vector : Qobj/array/list/tuple
+-            Position for the annotaion.
+-            Qobj of a qubit or a vector of 3 elements.
+-
+-        text : str
+-            Annotation text.
+-            You can use LaTeX, but remember to use raw string
+-            e.g. r"$\\langle x \\rangle$"
+-            or escape backslashes
+-            e.g. "$\\\\langle x \\\\rangle$".
+-
+-        kwargs :
+-            Options as for mplot3d.axes3d.text, including:
+-            fontsize, color, horizontalalignment, verticalalignment.
+-
+-        """
+-        if isinstance(state_or_vector, Qobj):
+-            vec = [expect(sigmax(), state_or_vector),
+-                   expect(sigmay(), state_or_vector),
+-                   expect(sigmaz(), state_or_vector)]
+-        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
+-                and len(state_or_vector) == 3:
+-            vec = state_or_vector
+-        else:
+-            raise Exception("Position needs to be specified by a qubit " +
+-                            "state or a 3D vector.")
+-        self.annotations.append({'position': vec,
+-                                 'text': text,
+-                                 'opts': kwargs})
+-
+-    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
+-        """Adds an arc between two points on a sphere. The arc is set to be
+-        blue solid curve by default.
+-
+-        The start and end points must be on the same sphere (i.e. have the
+-        same radius) but need not be on the unit sphere.
+-
+-        Parameters
+-        ----------
+-        start : Qobj or array-like
+-            Array with cartesian coordinates of the first point, or a state
+-            vector or density matrix that can be mapped to a point on or
+-            within the Bloch sphere.
+-        end : Qobj or array-like
+-            Array with cartesian coordinates of the second point, or a state
+-            vector or density matrix that can be mapped to a point on or
+-            within the Bloch sphere.
+-        fmt : str, default: "b"
+-            A matplotlib format string for rendering the arc.
+-        steps : int, default: None
+-            The number of segments to use when rendering the arc. The default
+-            uses 100 steps times the distance between the start and end points,
+-            with a minimum of 2 steps.
+-        **kwargs : dict
+-            Additional parameters to pass to the matplotlib .plot function
+-            when rendering this arc.
+-        """
+-        if isinstance(start, Qobj):
+-            pt1 = [
+-                expect(sigmax(), start),
+-                expect(sigmay(), start),
+-                expect(sigmaz(), start),
+-            ]
+-        else:
+-            pt1 = start
+-
+-        if isinstance(end, Qobj):
+-            pt2 = [
+-                expect(sigmax(), end),
+-                expect(sigmay(), end),
+-                expect(sigmaz(), end),
+-            ]
+-        else:
+-            pt2 = end
+-
+-        pt1 = np.asarray(pt1)
+-        pt2 = np.asarray(pt2)
+-
+-        len1 = np.linalg.norm(pt1)
+-        len2 = np.linalg.norm(pt2)
+-        if len1 < 1e-12 or len2 < 1e-12:
+-            raise ValueError('Polar and azimuthal angles undefined at origin.')
+-        elif abs(len1 - len2) > 1e-12:
+-            raise ValueError("Points not on the same sphere.")
+-        elif (pt1 == pt2).all():
+-            raise ValueError(
+-                "Start and end represent the same point. No arc can be formed."
+-            )
+-        elif (pt1 == -pt2).all():
+-            raise ValueError(
+-                "Start and end are diagonally opposite, no unique arc is"
+-                " possible."
+-            )
+-
+-        if steps is None:
+-            steps = int(np.linalg.norm(pt1 - pt2) * 100)
+-            steps = max(2, steps)
+-        t = np.linspace(0, 1, steps)
+-        # All the points in this line are contained in the plane defined
+-        # by pt1, pt2 and the origin.
+-        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
+-        # Normalize all the points in the line so that are distance len1 from
+-        # the origin.
+-        arc = line * len1 / np.linalg.norm(line, axis=0)
+-        self._arcs.append([arc, fmt, kwargs])
+-
+-    def add_line(self, start, end, fmt="k", **kwargs):
+-        """Adds a line segment connecting two points on the bloch sphere.
+-
+-        The line segment is set to be a black solid line by default.
+-
+-        Parameters
+-        ----------
+-        start : Qobj or array-like
+-            Array with cartesian coordinates of the first point, or a state
+-            vector or density matrix that can be mapped to a point on or
+-            within the Bloch sphere.
+-        end : Qobj or array-like
+-            Array with cartesian coordinates of the second point, or a state
+-            vector or density matrix that can be mapped to a point on or
+-            within the Bloch sphere.
+-        fmt : str, default: "k"
+-            A matplotlib format string for rendering the line.
+-        **kwargs : dict
+-            Additional parameters to pass to the matplotlib .plot function
+-            when rendering this line.
+-        """
+-        if isinstance(start, Qobj):
+-            pt1 = [
+-                expect(sigmax(), start),
+-                expect(sigmay(), start),
+-                expect(sigmaz(), start),
+-            ]
+-        else:
+-            pt1 = start
+-
+-        if isinstance(end, Qobj):
+-            pt2 = [
+-                expect(sigmax(), end),
+-                expect(sigmay(), end),
+-                expect(sigmaz(), end),
+-            ]
+-        else:
+-            pt2 = end
+-
+-        pt1 = np.asarray(pt1)
+-        pt2 = np.asarray(pt2)
+-
+-        x = [pt1[1], pt2[1]]
+-        y = [-pt1[0], -pt2[0]]
+-        z = [pt1[2], pt2[2]]
+-        v = [x, y, z]
+-        self._lines.append([v, fmt, kwargs])
+-
+-    def make_sphere(self):
+-        """
+-        Plots Bloch sphere and data sets.
+-        """
+-        self.render()
+-
+-    def run_from_ipython(self):
+-        try:
+-            __IPYTHON__
+-            return True
+-        except NameError:
+-            return False
+-
+-    def _is_inline_backend(self):
+-        backend = matplotlib.get_backend()
+-        return backend == "module://matplotlib_inline.backend_inline"
+-
+-    def render(self):
+-        """
+-        Render the Bloch sphere and its data sets in on given figure and axes.
+-        """
+-        if not self._ext_fig and not self._is_inline_backend():
+-            # If no external figure was supplied, we check to see if the
+-            # figure we created in a previous call to .render() has been
+-            # closed, and re-create if has been. This has the unfortunate
+-            # side effect of losing any modifications made to the axes or
+-            # figure, but the alternative is to crash the matplotlib backend.
+-            #
+-            # The inline backend used by, e.g. jupyter notebooks, is happy to
+-            # use closed figures so we leave those figures intact.
+-            if (
+-                self.fig is not None and
+-                not plt.fignum_exists(self.fig.number)
+-            ):
+-                self.fig = None
+-                self.axes = None
+-
+-        if self.fig is None:
+-            self.fig = plt.figure(figsize=self.figsize)
+-            if self._is_inline_backend():
+-                # We immediately close the inline figure do avoid displaying
+-                # the figure twice when .show() calls display.
+-                plt.close(self.fig)
+-
+-        if self.axes is None:
+-            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
+-
+-        # Clearing the axes is horrifically slow and loses a lot of the
+-        # axes state, but matplotlib doesn't seem to provide a better way
+-        # to redraw Axes3D. :/
+-        self.axes.clear()
+-        self.axes.grid(False)
+-        if self.background:
+-            self.axes.set_xlim3d(-1.3, 1.3)
+-            self.axes.set_ylim3d(-1.3, 1.3)
+-            self.axes.set_zlim3d(-1.3, 1.3)
+-        else:
+-            self.axes.set_axis_off()
+-            self.axes.set_xlim3d(-0.7, 0.7)
+-            self.axes.set_ylim3d(-0.7, 0.7)
+-            self.axes.set_zlim3d(-0.7, 0.7)
+-        # Manually set aspect ratio to fit a square bounding box.
+-        # Matplotlib did this stretching for < 3.3.0, but not above.
+-        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
+-            self.axes.set_box_aspect((1, 1, 1))
+-        if not self.background:
+-            self.plot_axes()
+-
+-        self.plot_back()
+-        self.plot_points()
+-        self.plot_vectors()
+-        self.plot_lines()
+-        self.plot_arcs()
+-        self.plot_front()
+-        self.plot_axes_labels()
+-        self.plot_annotations()
+-        # Trigger an update of the Bloch sphere if it is already shown:
+-        self.fig.canvas.draw()
+-
+-    def plot_back(self):
+-        # back half of sphere
+-        u = np.linspace(0, np.pi, 25)
+-        v = np.linspace(0, np.pi, 25)
+-        x = outer(cos(u), sin(v))
+-        y = outer(sin(u), sin(v))
+-        z = outer(ones(np.size(u)), cos(v))
+-        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
+-                               color=self.sphere_color, linewidth=0,
+-                               alpha=self.sphere_alpha)
+-        # wireframe
+-        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
+-                                 color=self.frame_color,
+-                                 alpha=self.frame_alpha)
+-        # equator
+-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
+-                       lw=self.frame_width, color=self.frame_color)
+-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
+-                       lw=self.frame_width, color=self.frame_color)
+-
+-    def plot_front(self):
+-        # front half of sphere
+-        u = np.linspace(-np.pi, 0, 25)
+-        v = np.linspace(0, np.pi, 25)
+-        x = outer(cos(u), sin(v))
+-        y = outer(sin(u), sin(v))
+-        z = outer(ones(np.size(u)), cos(v))
+-        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
+-                               color=self.sphere_color, linewidth=0,
+-                               alpha=self.sphere_alpha)
+-        # wireframe
+-        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
+-                                 color=self.frame_color,
+-                                 alpha=self.frame_alpha)
+-        # equator
+-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
+-                       zs=0, zdir='z', lw=self.frame_width,
+-                       color=self.frame_color)
+-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
+-                       zs=0, zdir='x', lw=self.frame_width,
+-                       color=self.frame_color)
+-
+-    def plot_axes(self):
+-        # axes
+-        span = np.linspace(-1.0, 1.0, 2)
+-        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
+-                       lw=self.frame_width, color=self.frame_color)
+-        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
+-                       lw=self.frame_width, color=self.frame_color)
+-        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
+-                       lw=self.frame_width, color=self.frame_color)
+-
+-    def plot_axes_labels(self):
+-        # axes labels
+-        opts = {'fontsize': self.font_size,
+-                'color': self.font_color,
+-                'horizontalalignment': 'center',
+-                'verticalalignment': 'center'}
+-        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
+-        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
+-
+-        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
+-        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
+-
+-        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
+-        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
+-
+-        for a in (self.axes.xaxis.get_ticklines() +
+-                  self.axes.xaxis.get_ticklabels()):
+-            a.set_visible(False)
+-        for a in (self.axes.yaxis.get_ticklines() +
+-                  self.axes.yaxis.get_ticklabels()):
+-            a.set_visible(False)
+-        for a in (self.axes.zaxis.get_ticklines() +
+-                  self.axes.zaxis.get_ticklabels()):
+-            a.set_visible(False)
+-
+-    def plot_vectors(self):
+-        # -X and Y data are switched for plotting purposes
+-        for k, vec in enumerate(self.vectors):
+-
+-            xs3d = vec[1] * np.array([0, 1])
+-            ys3d = -vec[0] * np.array([0, 1])
+-            zs3d = vec[2] * np.array([0, 1])
+-
+-            alpha = self.vector_alpha[k]
+-            color = self.vector_color[k]
+-            if color is None:
+-                idx = k % len(self.vector_default_color)
+-                color = self.vector_default_color[idx]
+-
+-            # decorated style, with arrow heads
+-            a = Arrow3D(xs3d, ys3d, zs3d,
+-                        mutation_scale=self.vector_mutation,
+-                        lw=self.vector_width,
+-                        arrowstyle=self.vector_style,
+-                        color=color, alpha=alpha)
+-
+-            self.axes.add_artist(a)
+-
+-    def plot_points(self):
+-        # -X and Y data are switched for plotting purposes
+-        for k, points in enumerate(self.points):
+-            points = np.asarray(points)
+-            num_points = points.shape[1]
+-
+-            dist = np.linalg.norm(points, axis=0)
+-            if not np.allclose(dist, dist[0], rtol=1e-12):
+-                indperm = np.argsort(dist)
+-                points = points[:, indperm]
+-            else:
+-                indperm = np.arange(num_points)
+-
+-            s = self.point_size[np.mod(k, len(self.point_size))]
+-            marker = self.point_marker[np.mod(k, len(self.point_marker))]
+-            style = self.point_style[k]
+-            if self.point_color[k] is not None:
+-                color = self.point_color[k]
+-            elif self.point_style[k] in ['s', 'l']:
+-                color = self.point_default_color[
+-                    k % len(self.point_default_color)
+-                ]
+-            elif self.point_style[k] == 'm':
+-                length = np.ceil(num_points/len(self.point_default_color))
+-                color = np.tile(self.point_default_color, length.astype(int))
+-                color = color[indperm]
+-
+-            if self.point_style[k] in ['s', 'm']:
+-                self.axes.scatter(np.real(points[1]),
+-                                  -np.real(points[0]),
+-                                  np.real(points[2]),
+-                                  s=s,
+-                                  marker=marker,
+-                                  color=color,
+-                                  alpha=self.point_alpha[k],
+-                                  edgecolor=None,
+-                                  zdir='z',
+-                                  )
+-
+-            elif self.point_style[k] == 'l':
+-                self.axes.plot(np.real(points[1]),
+-                               -np.real(points[0]),
+-                               np.real(points[2]),
+-                               color=color,
+-                               alpha=self.point_alpha[k],
+-                               zdir='z',
+-                               )
+-
+-    def plot_annotations(self):
+-        # -X and Y data are switched for plotting purposes
+-        for annotation in self.annotations:
+-            vec = annotation['position']
+-            opts = {'fontsize': self.font_size,
+-                    'color': self.font_color,
+-                    'horizontalalignment': 'center',
+-                    'verticalalignment': 'center'}
+-            opts.update(annotation['opts'])
+-            self.axes.text(vec[1], -vec[0], vec[2],
+-                           annotation['text'], **opts)
+-
+-    def plot_lines(self):
+-        for line, fmt, kw in self._lines:
+-            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
+-
+-    def plot_arcs(self):
+-        for arc, fmt, kw in self._arcs:
+-            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
+-
+-    def show(self):
+-        """
+-        Display Bloch sphere and corresponding data sets.
+-
+-        Notes
+-        -----
+-
+-        When using inline plotting in Jupyter notebooks, any figure created
+-        in a notebook cell is displayed after the cell executes. Thus if you
+-        create a figure yourself and use it create a Bloch sphere with
+-        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
+-        cell, then the figure will be displayed twice. If you do create your
+-        own figure, the simplest solution to this is to not call ``.show()``
+-        in the cell you create the figure in.
+-        """
+-        self.render()
+-        if self.run_from_ipython():
+-            display(self.fig)
+-        else:
+-            self.fig.show()
+-
+-    def save(self, name=None, format='png', dirc=None, dpin=None):
+-        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
+-
+-        Parameters
+-        ----------
+-
+-        name : str
+-            Name of saved image. Must include path and format as well.
+-            i.e. '/Users/Paul/Desktop/bloch.png'
+-            This overrides the 'format' and 'dirc' arguments.
+-        format : str
+-            Format of output image.
+-        dirc : str
+-            Directory for output images. Defaults to current working directory.
+-        dpin : int
+-            Resolution in dots per inch.
+-
+-        Returns
+-        -------
+-        File containing plot of Bloch sphere.
+-
+-        """
+-        self.render()
+-        # Conditional variable for first argument to savefig
+-        # that is set in subsequent if-elses
+-        complete_path = ""
+-        if dirc:
+-            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
+-                os.makedirs(os.getcwd() + "/" + str(dirc))
+-        if name is None:
+-            if dirc:
+-                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
+-                                + str(self.savenum) + '.' + format
+-            else:
+-                complete_path = os.getcwd() + '/bloch_' + \
+-                                str(self.savenum) + '.' + format
+-        else:
+-            complete_path = name
+-
+-        if dpin:
+-            self.fig.savefig(complete_path, dpi=dpin)
+-        else:
+-            self.fig.savefig(complete_path)
+-        self.savenum += 1
+-        if self.fig:
+-            plt.close(self.fig)
+-
+-
+-def _hide_tick_lines_and_labels(axis):
+-    '''
+-    Set visible property of ticklines and ticklabels of an axis to False
+-    '''
+-    for a in axis.get_ticklines() + axis.get_ticklabels():
+-        a.set_visible(False)
++__all__ = ['Bloch']
++
++import os
++
++import numpy as np
++from numpy import (outer, cos, sin, ones)
++
++from packaging.version import parse as parse_version
++
++from . import Qobj, expect, sigmax, sigmay, sigmaz
++
++try:
++    import matplotlib
++    import matplotlib.pyplot as plt
++    from mpl_toolkits.mplot3d import Axes3D
++    from matplotlib.patches import FancyArrowPatch
++    from mpl_toolkits.mplot3d import proj3d
++
++    # Define a custom _axes3D function based on the matplotlib version.
++    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
++    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
++        def _axes3D(fig, *args, **kwargs):
++            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
++            return fig.add_axes(ax)
++    else:
++        def _axes3D(*args, **kwargs):
++            return Axes3D(*args, **kwargs)
++
++    class Arrow3D(FancyArrowPatch):
++        def __init__(self, xs, ys, zs, *args, **kwargs):
++            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
++
++            self._verts3d = xs, ys, zs
++
++        def draw(self, renderer):
++            xs3d, ys3d, zs3d = self._verts3d
++            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
++
++            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
++            FancyArrowPatch.draw(self, renderer)
++
++        def do_3d_projection(self, renderer=None):
++            # only called by matplotlib >= 3.5
++            xs3d, ys3d, zs3d = self._verts3d
++            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
++            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
++            return np.min(zs)
++except ImportError:
++    pass
++
++try:
++    from IPython.display import display
++except ImportError:
++    pass
++
++
++class Bloch:
++    r"""
++    Class for plotting data on the Bloch sphere.  Valid data can be either
++    points, vectors, or Qobj objects.
++
++    Attributes
++    ----------
++    axes : matplotlib.axes.Axes
++        User supplied Matplotlib axes for Bloch sphere animation.
++    fig : matplotlib.figure.Figure
++        User supplied Matplotlib Figure instance for plotting Bloch sphere.
++    font_color : str, default 'black'
++        Color of font used for Bloch sphere labels.
++    font_size : int, default 20
++        Size of font used for Bloch sphere labels.
++    frame_alpha : float, default 0.1
++        Sets transparency of Bloch sphere frame.
++    frame_color : str, default 'gray'
++        Color of sphere wireframe.
++    frame_width : int, default 1
++        Width of wireframe.
++    point_color : list, default ["b", "r", "g", "#CC6600"]
++        List of colors for Bloch sphere point markers to cycle through, i.e.
++        by default, points 0 and 4 will both be blue ('b').
++    point_marker : list, default ["o", "s", "d", "^"]
++        List of point marker shapes to cycle through.
++    point_size : list, default [25, 32, 35, 45]
++        List of point marker sizes. Note, not all point markers look the same
++        size when plotted!
++    sphere_alpha : float, default 0.2
++        Transparency of Bloch sphere itself.
++    sphere_color : str, default '#FFDDDD'
++        Color of Bloch sphere.
++    figsize : list, default [7, 7]
++        Figure size of Bloch sphere plot.  Best to have both numbers the same;
++        otherwise you will have a Bloch sphere that looks like a football.
++    vector_color : list, ["g", "#CC6600", "b", "r"]
++        List of vector colors to cycle through.
++    vector_width : int, default 5
++        Width of displayed vectors.
++    vector_style : str, default '-\|>'
++        Vector arrowhead style (from matplotlib's arrow style).
++    vector_mutation : int, default 20
++        Width of vectors arrowhead.
++    view : list, default [-60, 30]
++        Azimuthal and Elevation viewing angles.
++    xlabel : list, default ["$x$", ""]
++        List of strings corresponding to +x and -x axes labels, respectively.
++    xlpos : list, default [1.1, -1.1]
++        Positions of +x and -x labels respectively.
++    ylabel : list, default ["$y$", ""]
++        List of strings corresponding to +y and -y axes labels, respectively.
++    ylpos : list, default [1.2, -1.2]
++        Positions of +y and -y labels respectively.
++    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
++        List of strings corresponding to +z and -z axes labels, respectively.
++    zlpos : list, default [1.2, -1.2]
++        Positions of +z and -z labels respectively.
++    """
++    def __init__(self, fig=None, axes=None, view=None, figsize=None,
++                 background=False):
++        # Figure and axes
++        self.fig = fig
++        self._ext_fig = fig is not None
++        self.axes = axes
++        # Background axes, default = False
++        self.background = background
++        # The size of the figure in inches, default = [5,5].
++        self.figsize = figsize if figsize else [5, 5]
++        # Azimuthal and Elvation viewing angles, default = [-60,30].
++        self.view = view if view else [-60, 30]
++        # Color of Bloch sphere, default = #FFDDDD
++        self.sphere_color = '#FFDDDD'
++        # Transparency of Bloch sphere, default = 0.2
++        self.sphere_alpha = 0.2
++        # Color of wireframe, default = 'gray'
++        self.frame_color = 'gray'
++        # Width of wireframe, default = 1
++        self.frame_width = 1
++        # Transparency of wireframe, default = 0.2
++        self.frame_alpha = 0.2
++        # Labels for x-axis (in LaTex), default = ['$x$', '']
++        self.xlabel = ['$x$', '']
++        # Position of x-axis labels, default = [1.2, -1.2]
++        self.xlpos = [1.2, -1.2]
++        # Labels for y-axis (in LaTex), default = ['$y$', '']
++        self.ylabel = ['$y$', '']
++        # Position of y-axis labels, default = [1.1, -1.1]
++        self.ylpos = [1.2, -1.2]
++        # Labels for z-axis (in LaTex),
++        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
++        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
++        # Position of z-axis labels, default = [1.2, -1.2]
++        self.zlpos = [1.2, -1.2]
++        # ---font options---
++        # Color of fonts, default = 'black'
++        self.font_color = 'black'
++        # Size of fonts, default = 20
++        self.font_size = 20
++
++        # ---vector options---
++        # List of colors for Bloch vectors, default = ['b','g','r','y']
++        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
++        # List that stores the display colors for each vector
++        self.vector_color = []
++        #: Width of Bloch vectors, default = 5
++        self.vector_width = 3
++        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
++        self.vector_style = '-|>'
++        #: Sets the width of the vectors arrowhead
++        self.vector_mutation = 20
++
++        # ---point options---
++        # List of colors for Bloch point markers, default = ['b','g','r','y']
++        self.point_default_color = ['b', 'r', 'g', '#CC6600']
++        # List that stores the display colors for each set of points
++        self.point_color = []
++        # Size of point markers, default = 25
++        self.point_size = [25, 32, 35, 45]
++        # Shape of point markers, default = ['o','^','d','s']
++        self.point_marker = ['o', 's', 'd', '^']
++
++        # ---data lists---
++        # Data for point markers
++        self.points = []
++        # Data for Bloch vectors
++        self.vectors = []
++        # Transparency of vectors, alpha value from 0 to 1
++        self.vector_alpha = []
++        # Data for annotations
++        self.annotations = []
++        # Number of times sphere has been saved
++        self.savenum = 0
++        # Style of points, 'm' for multiple colors, 's' for single color
++        self.point_style = []
++        # Transparency of points, alpha value from 0 to 1
++        self.point_alpha = []
++        # Data for line segment
++        self._lines = []
++        # Data for arcs and arc style
++        self._arcs = []
++
++    def set_label_convention(self, convention):
++        """Set x, y and z labels according to one of conventions.
++
++        Parameters
++        ----------
++        convention : string
++            One of the following:
++
++            - "original"
++            - "xyz"
++            - "sx sy sz"
++            - "01"
++            - "polarization jones"
++            - "polarization jones letters"
++              see also: https://en.wikipedia.org/wiki/Jones_calculus
++            - "polarization stokes"
++              see also: https://en.wikipedia.org/wiki/Stokes_parameters
++        """
++        ketex = "$\\left.|%s\\right\\rangle$"
++        # \left.| is on purpose, so that every ket has the same size
++
++        if convention == "original":
++            self.xlabel = ['$x$', '']
++            self.ylabel = ['$y$', '']
++            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
++        elif convention == "xyz":
++            self.xlabel = ['$x$', '']
++            self.ylabel = ['$y$', '']
++            self.zlabel = ['$z$', '']
++        elif convention == "sx sy sz":
++            self.xlabel = ['$s_x$', '']
++            self.ylabel = ['$s_y$', '']
++            self.zlabel = ['$s_z$', '']
++        elif convention == "01":
++            self.xlabel = ['', '']
++            self.ylabel = ['', '']
++            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
++        elif convention == "polarization jones":
++            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
++                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
++            self.ylabel = [ketex % "\\circlearrowleft", ketex %
++                           "\\circlearrowright"]
++            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
++        elif convention == "polarization jones letters":
++            self.xlabel = [ketex % "D", ketex % "A"]
++            self.ylabel = [ketex % "L", ketex % "R"]
++            self.zlabel = [ketex % "H", ketex % "V"]
++        elif convention == "polarization stokes":
++            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
++                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
++            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
++            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
++        else:
++            raise Exception("No such convention.")
++
++    def __str__(self):
++        s = ""
++        s += "Bloch data:\n"
++        s += "-----------\n"
++        s += "Number of points:  " + str(len(self.points)) + "\n"
++        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
++        s += "\n"
++        s += "Bloch sphere properties:\n"
++        s += "------------------------\n"
++        s += "font_color:      " + str(self.font_color) + "\n"
++        s += "font_size:       " + str(self.font_size) + "\n"
++        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
++        s += "frame_color:     " + str(self.frame_color) + "\n"
++        s += "frame_width:     " + str(self.frame_width) + "\n"
++        s += "point_default_color:" + str(self.point_default_color) + "\n"
++        s += "point_marker:    " + str(self.point_marker) + "\n"
++        s += "point_size:      " + str(self.point_size) + "\n"
++        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
++        s += "sphere_color:    " + str(self.sphere_color) + "\n"
++        s += "figsize:         " + str(self.figsize) + "\n"
++        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
++        s += "vector_width:    " + str(self.vector_width) + "\n"
++        s += "vector_style:    " + str(self.vector_style) + "\n"
++        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
++        s += "view:            " + str(self.view) + "\n"
++        s += "xlabel:          " + str(self.xlabel) + "\n"
++        s += "xlpos:           " + str(self.xlpos) + "\n"
++        s += "ylabel:          " + str(self.ylabel) + "\n"
++        s += "ylpos:           " + str(self.ylpos) + "\n"
++        s += "zlabel:          " + str(self.zlabel) + "\n"
++        s += "zlpos:           " + str(self.zlpos) + "\n"
++        return s
++
++    def _repr_png_(self):
++        from IPython.core.pylabtools import print_figure
++        self.render()
++        fig_data = print_figure(self.fig, 'png')
++        plt.close(self.fig)
++        return fig_data
++
++    def _repr_svg_(self):
++        from IPython.core.pylabtools import print_figure
++        self.render()
++        fig_data = print_figure(self.fig, 'svg')
++        plt.close(self.fig)
++        return fig_data
++
++    def clear(self):
++        """Resets Bloch sphere data sets to empty.
++        """
++        self.points = []
++        self.vectors = []
++        self.point_style = []
++        self.point_alpha = []
++        self.vector_alpha = []
++        self.annotations = []
++        self.vector_color = []
++        self.point_color = []
++        self._lines = []
++        self._arcs = []
++
++    def add_points(self, points, meth='s', colors=None, alpha=1.0):
++        """Add a list of data points to bloch sphere.
++
++        Parameters
++        ----------
++        points : array_like
++            Collection of data points.
++
++        meth : {'s', 'm', 'l'}
++            Type of points to plot, use 'm' for multicolored, 'l' for points
++            connected with a line.
++
++        colors : array_like
++            Optional array with colors for the points.
++            A single color for meth 's', and list of colors for meth 'm'
++
++        alpha : float, default=1.
++            Transparency value for the vectors. Values between 0 and 1.
++
++        .. note::
++
++           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
++           to ``0.75`` and there was no way to alter it.
++           When the ``alpha`` parameter was added in QuTiP 4.7, the default
++           became ``alpha=1.0`` for values of ``meth``.
++        """
++
++        points = np.asarray(points)
++
++        if points.ndim == 1:
++            points = points[:, np.newaxis]
++
++        if points.ndim != 2 or points.shape[0] != 3:
++            raise ValueError("The included points are not valid. Points must "
++                             "be equivalent to a 2D array where the first "
++                             "index represents the x,y,z values and the "
++                             "second index iterates over the points.")
++
++        if meth not in ['s', 'm', 'l']:
++            raise ValueError(f"The value for meth = {meth} is not valid."
++                             " Please use 's', 'l' or 'm'.")
++
++        if meth == 's' and points.shape[1] == 1:
++            points = np.append(points[:, :1], points, axis=1)
++
++        self.point_style.append(meth)
++        self.points.append(points)
++        self.point_alpha.append(alpha)
++        self.point_color.append(colors)
++
++    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
++        """Add a state vector Qobj to Bloch sphere.
++
++        Parameters
++        ----------
++        state : Qobj
++            Input state vector.
++
++        kind : {'vector', 'point'}
++            Type of object to plot.
++
++        colors : array_like
++            Optional array with colors for the states.
++
++        alpha : float, default=1.
++            Transparency value for the vectors. Values between 0 and 1.
++        """
++        if isinstance(state, Qobj):
++            state = [state]
++        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
++            colors = [colors]
++
++        for k, st in enumerate(state):
++            vec = [expect(sigmax(), st),
++                   expect(sigmay(), st),
++                   expect(sigmaz(), st)]
++
++            if kind == 'vector':
++                if colors is not None:
++                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
++                else:
++                    self.add_vectors(vec)
++            elif kind == 'point':
++                if colors is not None:
++                    self.add_points(vec, colors=colors[k], alpha=alpha)
++                else:
++                    self.add_points(vec)
++
++    def add_vectors(self, vectors, colors=None, alpha=1.0):
++        """Add a list of vectors to Bloch sphere.
++
++        Parameters
++        ----------
++        vectors : array_like
++            Array with vectors of unit length or smaller.
++
++        colors : array_like
++            Optional array with colors for the vectors.
++
++        alpha : float, default=1.
++            Transparency value for the vectors. Values between 0 and 1.
++
++        """
++        vectors = np.asarray(vectors)
++
++        if vectors.ndim == 1:
++            vectors = vectors[np.newaxis, :]
++
++        if vectors.ndim != 2 or vectors.shape[1] != 3:
++            raise ValueError(
++                "The included vectors are not valid. Vectors must "
++                "be equivalent to a 2D array where the first "
++                "index represents the iteration over the vectors and the "
++                "second index represents the position in 3D of vector head.")
++
++        n_vectors = vectors.shape[0]
++        if colors is None:
++            colors = np.array([None] * n_vectors)
++        else:
++            colors = np.asarray(colors)
++
++        if colors.ndim != 1 or colors.size != n_vectors:
++            raise ValueError("The included colors are not valid. colors must "
++                             "be equivalent to a 1D array with the same "
++                             "size as the number of vectors. ")
++
++        for k, vec in enumerate(vectors):
++            self.vectors.append(vec)
++            self.vector_alpha.append(alpha)
++            self.vector_color.append(colors[k])
++
++    def add_annotation(self, state_or_vector, text, **kwargs):
++        """
++        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
++        state or a vector.
++
++        Parameters
++        ----------
++        state_or_vector : Qobj/array/list/tuple
++            Position for the annotaion.
++            Qobj of a qubit or a vector of 3 elements.
++
++        text : str
++            Annotation text.
++            You can use LaTeX, but remember to use raw string
++            e.g. r"$\\langle x \\rangle$"
++            or escape backslashes
++            e.g. "$\\\\langle x \\\\rangle$".
++
++        kwargs :
++            Options as for mplot3d.axes3d.text, including:
++            fontsize, color, horizontalalignment, verticalalignment.
++
++        """
++        if isinstance(state_or_vector, Qobj):
++            vec = [expect(sigmax(), state_or_vector),
++                   expect(sigmay(), state_or_vector),
++                   expect(sigmaz(), state_or_vector)]
++        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
++                and len(state_or_vector) == 3:
++            vec = state_or_vector
++        else:
++            raise Exception("Position needs to be specified by a qubit " +
++                            "state or a 3D vector.")
++        self.annotations.append({'position': vec,
++                                 'text': text,
++                                 'opts': kwargs})
++
++    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
++        """Adds an arc between two points on a sphere. The arc is set to be
++        blue solid curve by default.
++
++        The start and end points must be on the same sphere (i.e. have the
++        same radius) but need not be on the unit sphere.
++
++        Parameters
++        ----------
++        start : Qobj or array-like
++            Array with cartesian coordinates of the first point, or a state
++            vector or density matrix that can be mapped to a point on or
++            within the Bloch sphere.
++        end : Qobj or array-like
++            Array with cartesian coordinates of the second point, or a state
++            vector or density matrix that can be mapped to a point on or
++            within the Bloch sphere.
++        fmt : str, default: "b"
++            A matplotlib format string for rendering the arc.
++        steps : int, default: None
++            The number of segments to use when rendering the arc. The default
++            uses 100 steps times the distance between the start and end points,
++            with a minimum of 2 steps.
++        **kwargs : dict
++            Additional parameters to pass to the matplotlib .plot function
++            when rendering this arc.
++        """
++        if isinstance(start, Qobj):
++            pt1 = [
++                expect(sigmax(), start),
++                expect(sigmay(), start),
++                expect(sigmaz(), start),
++            ]
++        else:
++            pt1 = start
++
++        if isinstance(end, Qobj):
++            pt2 = [
++                expect(sigmax(), end),
++                expect(sigmay(), end),
++                expect(sigmaz(), end),
++            ]
++        else:
++            pt2 = end
++
++        pt1 = np.asarray(pt1)
++        pt2 = np.asarray(pt2)
++
++        len1 = np.linalg.norm(pt1)
++        len2 = np.linalg.norm(pt2)
++        if len1 < 1e-12 or len2 < 1e-12:
++            raise ValueError('Polar and azimuthal angles undefined at origin.')
++        elif abs(len1 - len2) > 1e-12:
++            raise ValueError("Points not on the same sphere.")
++        elif (pt1 == pt2).all():
++            raise ValueError(
++                "Start and end represent the same point. No arc can be formed."
++            )
++        elif (pt1 == -pt2).all():
++            raise ValueError(
++                "Start and end are diagonally opposite, no unique arc is"
++                " possible."
++            )
++
++        if steps is None:
++            steps = int(np.linalg.norm(pt1 - pt2) * 100)
++            steps = max(2, steps)
++        t = np.linspace(0, 1, steps)
++        # All the points in this line are contained in the plane defined
++        # by pt1, pt2 and the origin.
++        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
++        # Normalize all the points in the line so that are distance len1 from
++        # the origin.
++        arc = line * len1 / np.linalg.norm(line, axis=0)
++        self._arcs.append([arc, fmt, kwargs])
++
++    def add_line(self, start, end, fmt="k", **kwargs):
++        """Adds a line segment connecting two points on the bloch sphere.
++
++        The line segment is set to be a black solid line by default.
++
++        Parameters
++        ----------
++        start : Qobj or array-like
++            Array with cartesian coordinates of the first point, or a state
++            vector or density matrix that can be mapped to a point on or
++            within the Bloch sphere.
++        end : Qobj or array-like
++            Array with cartesian coordinates of the second point, or a state
++            vector or density matrix that can be mapped to a point on or
++            within the Bloch sphere.
++        fmt : str, default: "k"
++            A matplotlib format string for rendering the line.
++        **kwargs : dict
++            Additional parameters to pass to the matplotlib .plot function
++            when rendering this line.
++        """
++        if isinstance(start, Qobj):
++            pt1 = [
++                expect(sigmax(), start),
++                expect(sigmay(), start),
++                expect(sigmaz(), start),
++            ]
++        else:
++            pt1 = start
++
++        if isinstance(end, Qobj):
++            pt2 = [
++                expect(sigmax(), end),
++                expect(sigmay(), end),
++                expect(sigmaz(), end),
++            ]
++        else:
++            pt2 = end
++
++        pt1 = np.asarray(pt1)
++        pt2 = np.asarray(pt2)
++
++        x = [pt1[1], pt2[1]]
++        y = [-pt1[0], -pt2[0]]
++        z = [pt1[2], pt2[2]]
++        v = [x, y, z]
++        self._lines.append([v, fmt, kwargs])
++
++    def make_sphere(self):
++        """
++        Plots Bloch sphere and data sets.
++        """
++        self.render()
++
++    def run_from_ipython(self):
++        try:
++            __IPYTHON__
++            return True
++        except NameError:
++            return False
++
++    def _is_inline_backend(self):
++        backend = matplotlib.get_backend()
++        return backend == "module://matplotlib_inline.backend_inline"
++
++    def render(self):
++        """
++        Render the Bloch sphere and its data sets in on given figure and axes.
++        """
++        if not self._ext_fig and not self._is_inline_backend():
++            # If no external figure was supplied, we check to see if the
++            # figure we created in a previous call to .render() has been
++            # closed, and re-create if has been. This has the unfortunate
++            # side effect of losing any modifications made to the axes or
++            # figure, but the alternative is to crash the matplotlib backend.
++            #
++            # The inline backend used by, e.g. jupyter notebooks, is happy to
++            # use closed figures so we leave those figures intact.
++            if (
++                self.fig is not None and
++                not plt.fignum_exists(self.fig.number)
++            ):
++                self.fig = None
++                self.axes = None
++
++        if self.fig is None:
++            self.fig = plt.figure(figsize=self.figsize)
++            if self._is_inline_backend():
++                # We immediately close the inline figure do avoid displaying
++                # the figure twice when .show() calls display.
++                plt.close(self.fig)
++
++        if self.axes is None:
++            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
++
++        # Clearing the axes is horrifically slow and loses a lot of the
++        # axes state, but matplotlib doesn't seem to provide a better way
++        # to redraw Axes3D. :/
++        self.axes.clear()
++        self.axes.grid(False)
++        if self.background:
++            self.axes.set_xlim3d(-1.3, 1.3)
++            self.axes.set_ylim3d(-1.3, 1.3)
++            self.axes.set_zlim3d(-1.3, 1.3)
++        else:
++            self.axes.set_axis_off()
++            self.axes.set_xlim3d(-0.7, 0.7)
++            self.axes.set_ylim3d(-0.7, 0.7)
++            self.axes.set_zlim3d(-0.7, 0.7)
++        # Manually set aspect ratio to fit a square bounding box.
++        # Matplotlib did this stretching for < 3.3.0, but not above.
++        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
++            self.axes.set_box_aspect((1, 1, 1))
++        if not self.background:
++            self.plot_axes()
++
++        self.plot_back()
++        self.plot_points()
++        self.plot_vectors()
++        self.plot_lines()
++        self.plot_arcs()
++        self.plot_front()
++        self.plot_axes_labels()
++        self.plot_annotations()
++        # Trigger an update of the Bloch sphere if it is already shown:
++        self.fig.canvas.draw()
++
++    def plot_back(self):
++        # back half of sphere
++        u = np.linspace(0, np.pi, 25)
++        v = np.linspace(0, np.pi, 25)
++        x = outer(cos(u), sin(v))
++        y = outer(sin(u), sin(v))
++        z = outer(ones(np.size(u)), cos(v))
++        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
++                               color=self.sphere_color, linewidth=0,
++                               alpha=self.sphere_alpha)
++        # wireframe
++        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
++                                 color=self.frame_color,
++                                 alpha=self.frame_alpha)
++        # equator
++        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
++                       lw=self.frame_width, color=self.frame_color)
++        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
++                       lw=self.frame_width, color=self.frame_color)
++
++    def plot_front(self):
++        # front half of sphere
++        u = np.linspace(-np.pi, 0, 25)
++        v = np.linspace(0, np.pi, 25)
++        x = outer(cos(u), sin(v))
++        y = outer(sin(u), sin(v))
++        z = outer(ones(np.size(u)), cos(v))
++        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
++                               color=self.sphere_color, linewidth=0,
++                               alpha=self.sphere_alpha)
++        # wireframe
++        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
++                                 color=self.frame_color,
++                                 alpha=self.frame_alpha)
++        # equator
++        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
++                       zs=0, zdir='z', lw=self.frame_width,
++                       color=self.frame_color)
++        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
++                       zs=0, zdir='x', lw=self.frame_width,
++                       color=self.frame_color)
++
++    def plot_axes(self):
++        # axes
++        span = np.linspace(-1.0, 1.0, 2)
++        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
++                       lw=self.frame_width, color=self.frame_color)
++        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
++                       lw=self.frame_width, color=self.frame_color)
++        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
++                       lw=self.frame_width, color=self.frame_color)
++
++    def plot_axes_labels(self):
++        # axes labels
++        opts = {'fontsize': self.font_size,
++                'color': self.font_color,
++                'horizontalalignment': 'center',
++                'verticalalignment': 'center'}
++        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
++        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
++
++        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
++        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
++
++        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
++        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
++
++        for a in (self.axes.xaxis.get_ticklines() +
++                  self.axes.xaxis.get_ticklabels()):
++            a.set_visible(False)
++        for a in (self.axes.yaxis.get_ticklines() +
++                  self.axes.yaxis.get_ticklabels()):
++            a.set_visible(False)
++        for a in (self.axes.zaxis.get_ticklines() +
++                  self.axes.zaxis.get_ticklabels()):
++            a.set_visible(False)
++
++    def plot_vectors(self):
++        # -X and Y data are switched for plotting purposes
++        for k, vec in enumerate(self.vectors):
++
++            xs3d = vec[1] * np.array([0, 1])
++            ys3d = -vec[0] * np.array([0, 1])
++            zs3d = vec[2] * np.array([0, 1])
++
++            alpha = self.vector_alpha[k]
++            color = self.vector_color[k]
++            if color is None:
++                idx = k % len(self.vector_default_color)
++                color = self.vector_default_color[idx]
++
++            # decorated style, with arrow heads
++            a = Arrow3D(xs3d, ys3d, zs3d,
++                        mutation_scale=self.vector_mutation,
++                        lw=self.vector_width,
++                        arrowstyle=self.vector_style,
++                        color=color, alpha=alpha)
++
++            self.axes.add_artist(a)
++
++    def plot_points(self):
++        # -X and Y data are switched for plotting purposes
++        for k, points in enumerate(self.points):
++            points = np.asarray(points)
++            num_points = points.shape[1]
++
++            dist = np.linalg.norm(points, axis=0)
++            if not np.allclose(dist, dist[0], rtol=1e-12):
++                indperm = np.argsort(dist)
++                points = points[:, indperm]
++            else:
++                indperm = np.arange(num_points)
++
++            s = self.point_size[np.mod(k, len(self.point_size))]
++            marker = self.point_marker[np.mod(k, len(self.point_marker))]
++            style = self.point_style[k]
++            if self.point_color[k] is not None:
++                color = self.point_color[k]
++            elif self.point_style[k] in ['s', 'l']:
++                color = self.point_default_color[
++                    k % len(self.point_default_color)
++                ]
++            elif self.point_style[k] == 'm':
++                length = np.ceil(num_points/len(self.point_default_color))
++                color = np.tile(self.point_default_color, length.astype(int))
++                color = color[indperm]
++
++            if self.point_style[k] in ['s', 'm']:
++                self.axes.scatter(np.real(points[1]),
++                                  -np.real(points[0]),
++                                  np.real(points[2]),
++                                  s=s,
++                                  marker=marker,
++                                  color=color,
++                                  alpha=self.point_alpha[k],
++                                  edgecolor=None,
++                                  zdir='z',
++                                  )
++
++            elif self.point_style[k] == 'l':
++                self.axes.plot(np.real(points[1]),
++                               -np.real(points[0]),
++                               np.real(points[2]),
++                               color=color,
++                               alpha=self.point_alpha[k],
++                               zdir='z',
++                               )
++
++    def plot_annotations(self):
++        # -X and Y data are switched for plotting purposes
++        for annotation in self.annotations:
++            vec = annotation['position']
++            opts = {'fontsize': self.font_size,
++                    'color': self.font_color,
++                    'horizontalalignment': 'center',
++                    'verticalalignment': 'center'}
++            opts.update(annotation['opts'])
++            self.axes.text(vec[1], -vec[0], vec[2],
++                           annotation['text'], **opts)
++
++    def plot_lines(self):
++        for line, fmt, kw in self._lines:
++            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
++
++    def plot_arcs(self):
++        for arc, fmt, kw in self._arcs:
++            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
++
++    def show(self):
++        """
++        Display Bloch sphere and corresponding data sets.
++
++        Notes
++        -----
++
++        When using inline plotting in Jupyter notebooks, any figure created
++        in a notebook cell is displayed after the cell executes. Thus if you
++        create a figure yourself and use it create a Bloch sphere with
++        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
++        cell, then the figure will be displayed twice. If you do create your
++        own figure, the simplest solution to this is to not call ``.show()``
++        in the cell you create the figure in.
++        """
++        self.render()
++        if self.run_from_ipython():
++            display(self.fig)
++        else:
++            self.fig.show()
++
++    def save(self, name=None, format='png', dirc=None, dpin=None):
++        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
++
++        Parameters
++        ----------
++
++        name : str
++            Name of saved image. Must include path and format as well.
++            i.e. '/Users/Paul/Desktop/bloch.png'
++            This overrides the 'format' and 'dirc' arguments.
++        format : str
++            Format of output image.
++        dirc : str
++            Directory for output images. Defaults to current working directory.
++        dpin : int
++            Resolution in dots per inch.
++
++        Returns
++        -------
++        File containing plot of Bloch sphere.
++
++        """
++        self.render()
++        # Conditional variable for first argument to savefig
++        # that is set in subsequent if-elses
++        complete_path = ""
++        if dirc:
++            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
++                os.makedirs(os.getcwd() + "/" + str(dirc))
++        if name is None:
++            if dirc:
++                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
++                                + str(self.savenum) + '.' + format
++            else:
++                complete_path = os.getcwd() + '/bloch_' + \
++                                str(self.savenum) + '.' + format
++        else:
++            complete_path = name
++
++        if dpin:
++            self.fig.savefig(complete_path, dpi=dpin)
++        else:
++            self.fig.savefig(complete_path)
++        self.savenum += 1
++        if self.fig:
++            plt.close(self.fig)
++
++
++def _hide_tick_lines_and_labels(axis):
++    '''
++    Set visible property of ticklines and ticklabels of an axis to False
++    '''
++    for a in axis.get_ticklines() + axis.get_ticklabels():
++        a.set_visible(False)
+diff --git a/qutip/bloch3d.py b/qutip/bloch3d.py
+index d387b6c4..748e5cf7 100644
+--- a/qutip/bloch3d.py
++++ b/qutip/bloch3d.py
+@@ -1,517 +1,517 @@
+-__all__ = ['Bloch3d']
+-
+-import numpy as np
+-from . import Qobj, expect, sigmax, sigmay, sigmaz
+-
+-
+-class Bloch3d:
+-    """Class for plotting data on a 3D Bloch sphere using mayavi.
+-    Valid data can be either points, vectors, or qobj objects
+-    corresponding to state vectors or density matrices. for
+-    a two-state system (or subsystem).
+-
+-    Attributes
+-    ----------
+-    fig : instance {None}
+-        User supplied Matplotlib Figure instance for plotting Bloch sphere.
+-    font_color : str {'black'}
+-        Color of font used for Bloch sphere labels.
+-    font_scale : float {0.08}
+-        Scale for font used for Bloch sphere labels.
+-    frame : bool {True}
+-        Draw frame for Bloch sphere
+-    frame_alpha : float {0.05}
+-        Sets transparency of Bloch sphere frame.
+-    frame_color : str {'gray'}
+-        Color of sphere wireframe.
+-    frame_num : int {8}
+-        Number of frame elements to draw.
+-    frame_radius : floats {0.005}
+-        Width of wireframe.
+-    point_color : list {['r', 'g', 'b', 'y']}
+-        List of colors for Bloch sphere point markers to cycle through.
+-        i.e. By default, points 0 and 4 will both be blue ('r').
+-    point_mode : string {'sphere','cone','cube','cylinder','point'}
+-        Point marker shapes.
+-    point_size : float {0.075}
+-        Size of points on Bloch sphere.
+-    sphere_alpha : float {0.1}
+-        Transparency of Bloch sphere itself.
+-    sphere_color : str {'#808080'}
+-        Color of Bloch sphere.
+-    size : list {[500,500]}
+-        Size of Bloch sphere plot in pixels. Best to have both numbers the same
+-        otherwise you will have a Bloch sphere that looks like a football.
+-    vector_color : list {['r', 'g', 'b', 'y']}
+-        List of vector colors to cycle through.
+-    vector_width : int {3}
+-        Width of displayed vectors.
+-    view : list {[45,65]}
+-        Azimuthal and Elevation viewing angles.
+-    xlabel : list {``['|x>', '']``}
+-        List of strings corresponding to +x and -x axes labels, respectively.
+-    xlpos : list {[1.07,-1.07]}
+-        Positions of +x and -x labels respectively.
+-    ylabel : list {``['|y>', '']``}
+-        List of strings corresponding to +y and -y axes labels, respectively.
+-    ylpos : list {[1.07,-1.07]}
+-        Positions of +y and -y labels respectively.
+-    zlabel : list {``['|0>', '|1>']``}
+-        List of strings corresponding to +z and -z axes labels, respectively.
+-    zlpos : list {[1.07,-1.07]}
+-        Positions of +z and -z labels respectively.
+-
+-    Notes
+-    -----
+-    The use of mayavi for 3D rendering of the Bloch sphere comes with
+-    a few limitations: I) You can not embed a Bloch3d figure into a
+-    matplotlib window. II) The use of LaTex is not supported by the
+-    mayavi rendering engine. Therefore all labels must be defined using
+-    standard text. Of course you can post-process the generated figures
+-    later to add LaTeX using other software if needed.
+-
+-
+-    """
+-    def __init__(self, fig=None):
+-        # ----check for mayavi-----
+-        try:
+-            from mayavi import mlab
+-        except:
+-            raise Exception("This function requires the mayavi module.")
+-
+-        # ---Image options---
+-        self.fig = None
+-        self.user_fig = None
+-        # check if user specified figure or axes.
+-        if fig:
+-            self.user_fig = fig
+-        # The size of the figure in inches, default = [500,500].
+-        self.size = [500, 500]
+-        # Azimuthal and Elvation viewing angles, default = [45,65].
+-        self.view = [45, 65]
+-        # Image background color
+-        self.bgcolor = 'white'
+-        # Image foreground color. Other options can override.
+-        self.fgcolor = 'black'
+-
+-        # ---Sphere options---
+-        # Color of Bloch sphere, default = #808080
+-        self.sphere_color = '#808080'
+-        # Transparency of Bloch sphere, default = 0.1
+-        self.sphere_alpha = 0.1
+-
+-        # ---Frame options---
+-        # Draw frame?
+-        self.frame = True
+-        # number of lines to draw for frame
+-        self.frame_num = 8
+-        # Color of wireframe, default = 'gray'
+-        self.frame_color = 'black'
+-        # Transparency of wireframe, default = 0.2
+-        self.frame_alpha = 0.05
+-        # Radius of frame lines
+-        self.frame_radius = 0.005
+-
+-        # --Axes---
+-        # Axes color
+-        self.axes_color = 'black'
+-        # Transparency of axes
+-        self.axes_alpha = 0.4
+-        # Radius of axes lines
+-        self.axes_radius = 0.005
+-
+-        # ---Labels---
+-        # Labels for x-axis (in LaTex), default = ['$x$','']
+-        self.xlabel = ['|x>', '']
+-        # Position of x-axis labels, default = [1.2,-1.2]
+-        self.xlpos = [1.07, -1.07]
+-        # Labels for y-axis (in LaTex), default = ['$y$','']
+-        self.ylabel = ['|y>', '']
+-        # Position of y-axis labels, default = [1.1,-1.1]
+-        self.ylpos = [1.07, -1.07]
+-        # Labels for z-axis
+-        self.zlabel = ['|0>', '|1>']
+-        # Position of z-axis labels, default = [1.05,-1.05]
+-        self.zlpos = [1.07, -1.07]
+-
+-        # ---Font options---
+-        # Color of fonts, default = 'black'
+-        self.font_color = 'black'
+-        # Size of fonts, default = 20
+-        self.font_scale = 0.08
+-
+-        # ---Vector options---
+-        # Object used for representing vectors on Bloch sphere.
+-        # List of colors for Bloch vectors, default = ['b','g','r','y']
+-        self.vector_color = ['r', 'g', 'b', 'y']
+-        # Width of Bloch vectors, default = 2
+-        self.vector_width = 2.0
+-        # Height of vector head
+-        self.vector_head_height = 0.15
+-        # Radius of vector head
+-        self.vector_head_radius = 0.075
+-
+-        # ---Point options---
+-        # List of colors for Bloch point markers, default = ['b','g','r','y']
+-        self.point_color = ['r', 'g', 'b', 'y']
+-        # Size of point markers
+-        self.point_size = 0.06
+-        # Shape of point markers
+-        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
+-        # Default = 'sphere'
+-        self.point_mode = 'sphere'
+-
+-        # ---Data lists---
+-        # Data for point markers
+-        self.points = []
+-        # Data for Bloch vectors
+-        self.vectors = []
+-        # Number of times sphere has been saved
+-        self.savenum = 0
+-        # Style of points, 'm' for multiple colors, 's' for single color
+-        self.point_style = []
+-        # Transparency of points
+-        self.point_alpha = []
+-        # Transparency of vectors
+-        self.vector_alpha = []
+-
+-    def __str__(self):
+-        s = ""
+-        s += "Bloch3D data:\n"
+-        s += "-----------\n"
+-        s += "Number of points:  " + str(len(self.points)) + "\n"
+-        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
+-        s += "\n"
+-        s += "Bloch3D sphere properties:\n"
+-        s += "--------------------------\n"
+-        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
+-        s += "axes_color:         " + str(self.axes_color) + "\n"
+-        s += "axes_radius:        " + str(self.axes_radius) + "\n"
+-        s += "bgcolor:            " + str(self.bgcolor) + "\n"
+-        s += "fgcolor:            " + str(self.fgcolor) + "\n"
+-        s += "font_color:         " + str(self.font_color) + "\n"
+-        s += "font_scale:         " + str(self.font_scale) + "\n"
+-        s += "frame:              " + str(self.frame) + "\n"
+-        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
+-        s += "frame_color:        " + str(self.frame_color) + "\n"
+-        s += "frame_num:          " + str(self.frame_num) + "\n"
+-        s += "frame_radius:       " + str(self.frame_radius) + "\n"
+-        s += "point_color:        " + str(self.point_color) + "\n"
+-        s += "point_mode:         " + str(self.point_mode) + "\n"
+-        s += "point_size:         " + str(self.point_size) + "\n"
+-        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
+-        s += "sphere_color:       " + str(self.sphere_color) + "\n"
+-        s += "size:               " + str(self.size) + "\n"
+-        s += "vector_color:       " + str(self.vector_color) + "\n"
+-        s += "vector_width:       " + str(self.vector_width) + "\n"
+-        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
+-        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
+-        s += "view:               " + str(self.view) + "\n"
+-        s += "xlabel:             " + str(self.xlabel) + "\n"
+-        s += "xlpos:              " + str(self.xlpos) + "\n"
+-        s += "ylabel:             " + str(self.ylabel) + "\n"
+-        s += "ylpos:              " + str(self.ylpos) + "\n"
+-        s += "zlabel:             " + str(self.zlabel) + "\n"
+-        s += "zlpos:              " + str(self.zlpos) + "\n"
+-        return s
+-
+-    def clear(self):
+-        """Resets the Bloch sphere data sets to empty.
+-        """
+-        self.points = []
+-        self.vectors = []
+-        self.point_style = []
+-
+-    def add_points(self, points, meth='s', alpha=1.0):
+-        """Add a list of data points to bloch sphere.
+-
+-        Parameters
+-        ----------
+-        points : array/list
+-            Collection of data points.
+-
+-        meth : str {'s','m'}
+-            Type of points to plot, use 'm' for multicolored.
+-
+-        alpha : float, default=1.
+-            Transparency value for the vectors. Values between 0 and 1.
+-
+-        """
+-        if not isinstance(points[0], (list, np.ndarray)):
+-            points = [[points[0]], [points[1]], [points[2]]]
+-        points = np.array(points)
+-        if meth == 's':
+-            if len(points[0]) == 1:
+-                pnts = np.array(
+-                    [[points[0][0]], [points[1][0]], [points[2][0]]])
+-                pnts = np.append(pnts, points, axis=1)
+-            else:
+-                pnts = points
+-            self.points.append(pnts)
+-            self.point_style.append('s')
+-        else:
+-            self.points.append(points)
+-            self.point_style.append('m')
+-        self.point_alpha.append(alpha)
+-
+-    def add_states(self, state, kind='vector', alpha=1.0):
+-        """Add a state vector Qobj to Bloch sphere.
+-
+-        Parameters
+-        ----------
+-        state : qobj
+-            Input state vector.
+-
+-        kind : str {'vector','point'}
+-            Type of object to plot.
+-
+-        alpha : float, default=1.
+-            Transparency value for the vectors. Values between 0 and 1.
+-        """
+-        if isinstance(state, Qobj):
+-            state = [state]
+-        for st in state:
+-            if kind == 'vector':
+-                vec = [expect(sigmax(), st), expect(sigmay(), st),
+-                       expect(sigmaz(), st)]
+-                self.add_vectors(vec, alpha=alpha)
+-            elif kind == 'point':
+-                pnt = [expect(sigmax(), st), expect(sigmay(), st),
+-                       expect(sigmaz(), st)]
+-                self.add_points(pnt, alpha=alpha)
+-
+-    def add_vectors(self, vectors, alpha=1.0):
+-        """Add a list of vectors to Bloch sphere.
+-
+-        Parameters
+-        ----------
+-        vectors : array/list
+-            Array with vectors of unit length or smaller.
+-
+-        alpha : float, default=1.
+-            Transparency value for the vectors. Values between 0 and 1.
+-
+-        """
+-        if isinstance(vectors[0], (list, np.ndarray)):
+-            for vec in vectors:
+-                self.vectors.append(vec)
+-                self.vector_alpha.append(alpha)
+-        else:
+-            self.vectors.append(vectors)
+-            self.vector_alpha.append(alpha)
+-
+-    def plot_vectors(self):
+-        """
+-        Plots vectors on the Bloch sphere.
+-        """
+-        from mayavi import mlab
+-        from tvtk.api import tvtk
+-        import matplotlib.colors as colors
+-        ii = 0
+-        for k in range(len(self.vectors)):
+-            vec = np.array(self.vectors[k])
+-            norm = np.linalg.norm(vec)
+-            theta = np.arccos(vec[2] / norm)
+-            phi = np.arctan2(vec[1], vec[0])
+-            vec -= 0.5 * self.vector_head_height * \
+-                np.array([np.sin(theta) * np.cos(phi),
+-                          np.sin(theta) * np.sin(phi), np.cos(theta)])
+-
+-            color = colors.colorConverter.to_rgb(
+-                self.vector_color[np.mod(k, len(self.vector_color))])
+-
+-            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
+-                        name='vector' + str(ii), tube_sides=100,
+-                        line_width=self.vector_width,
+-                        opacity=self.vector_alpha[k],
+-                        color=color)
+-
+-            cone = tvtk.ConeSource(height=self.vector_head_height,
+-                                   radius=self.vector_head_radius,
+-                                   resolution=100)
+-            cone_mapper = tvtk.PolyDataMapper(
+-                input_connection=cone.output_port)
+-            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
+-            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
+-            cc.rotate_z(np.degrees(phi))
+-            cc.rotate_y(-90 + np.degrees(theta))
+-            cc.position = vec
+-            self.fig.scene.add_actor(cc)
+-
+-    def plot_points(self):
+-        """
+-        Plots points on the Bloch sphere.
+-        """
+-        from mayavi import mlab
+-        import matplotlib.colors as colors
+-        for k in range(len(self.points)):
+-            num = len(self.points[k][0])
+-            dist = [np.sqrt(self.points[k][0][j] ** 2 +
+-                            self.points[k][1][j] ** 2 +
+-                            self.points[k][2][j] ** 2) for j in range(num)]
+-            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
+-                # combine arrays so that they can be sorted together
+-                # and sort rates from lowest to highest
+-                zipped = sorted(zip(dist, range(num)))
+-                dist, indperm = zip(*zipped)
+-                indperm = np.array(indperm)
+-            else:
+-                indperm = range(num)
+-            if self.point_style[k] == 's':
+-                color = colors.colorConverter.to_rgb(
+-                    self.point_color[np.mod(k, len(self.point_color))])
+-                mlab.points3d(
+-                    self.points[k][0][indperm], self.points[k][1][indperm],
+-                    self.points[k][2][indperm], figure=self.fig,
+-                    resolution=100, scale_factor=self.point_size,
+-                    mode=self.point_mode, color=color,
+-                    opacity=self.point_alpha[k])
+-
+-            elif self.point_style[k] == 'm':
+-                pnt_colors = np.array(self.point_color * np.ceil(
+-                    num / float(len(self.point_color))))
+-                pnt_colors = pnt_colors[0:num]
+-                pnt_colors = list(pnt_colors[indperm])
+-                for kk in range(num):
+-                    mlab.points3d(
+-                        self.points[k][0][
+-                            indperm[kk]], self.points[k][1][indperm[kk]],
+-                        self.points[k][2][
+-                            indperm[kk]], figure=self.fig, resolution=100,
+-                        scale_factor=self.point_size, mode=self.point_mode,
+-                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
+-                        opacity=self.point_alpha[k])
+-
+-    def make_sphere(self):
+-        """
+-        Plots Bloch sphere and data sets.
+-        """
+-        # setup plot
+-        # Figure instance for Bloch sphere plot
+-        from mayavi import mlab
+-        import matplotlib.colors as colors
+-        if self.user_fig:
+-            self.fig = self.user_fig
+-        else:
+-            self.fig = mlab.figure(
+-                1, size=self.size,
+-                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
+-                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
+-
+-        sphere = mlab.points3d(
+-            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
+-            color=colors.colorConverter.to_rgb(self.sphere_color),
+-            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
+-
+-        # Thse commands make the sphere look better
+-        sphere.actor.property.specular = 0.45
+-        sphere.actor.property.specular_power = 5
+-        sphere.actor.property.backface_culling = True
+-
+-        # make frame for sphere surface
+-        if self.frame:
+-            theta = np.linspace(0, 2 * np.pi, 100)
+-            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
+-                xlat = np.cos(theta) * np.cos(angle)
+-                ylat = np.sin(theta) * np.cos(angle)
+-                zlat = np.ones_like(theta) * np.sin(angle)
+-                xlon = np.sin(angle) * np.sin(theta)
+-                ylon = np.cos(angle) * np.sin(theta)
+-                zlon = np.cos(theta)
+-                mlab.plot3d(
+-                    xlat, ylat, zlat,
+-                    color=colors.colorConverter.to_rgb(self.frame_color),
+-                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
+-                mlab.plot3d(
+-                    xlon, ylon, zlon,
+-                    color=colors.colorConverter.to_rgb(self.frame_color),
+-                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
+-
+-        # add axes
+-        axis = np.linspace(-1.0, 1.0, 10)
+-        other = np.zeros_like(axis)
+-        mlab.plot3d(
+-            axis, other, other,
+-            color=colors.colorConverter.to_rgb(self.axes_color),
+-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+-        mlab.plot3d(
+-            other, axis, other,
+-            color=colors.colorConverter.to_rgb(self.axes_color),
+-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+-        mlab.plot3d(
+-            other, other, axis,
+-            color=colors.colorConverter.to_rgb(self.axes_color),
+-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+-
+-        # add data to sphere
+-        self.plot_points()
+-        self.plot_vectors()
+-
+-        # #add labels
+-        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
+-                    color=colors.colorConverter.to_rgb(self.font_color),
+-                    scale=self.font_scale)
+-        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
+-                    color=colors.colorConverter.to_rgb(self.font_color),
+-                    scale=self.font_scale)
+-        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
+-                    color=colors.colorConverter.to_rgb(self.font_color),
+-                    scale=self.font_scale)
+-        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
+-                    color=colors.colorConverter.to_rgb(self.font_color),
+-                    scale=self.font_scale)
+-        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
+-                    color=colors.colorConverter.to_rgb(self.font_color),
+-                    scale=self.font_scale)
+-        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
+-                    color=colors.colorConverter.to_rgb(self.font_color),
+-                    scale=self.font_scale)
+-
+-    def show(self):
+-        """
+-        Display the Bloch sphere and corresponding data sets.
+-        """
+-        from mayavi import mlab
+-        self.make_sphere()
+-        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
+-        if self.fig:
+-            mlab.show()
+-
+-    def save(self, name=None, format='png', dirc=None):
+-        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
+-
+-        Parameters
+-        ----------
+-        name : str
+-            Name of saved image. Must include path and format as well.
+-            i.e. '/Users/Paul/Desktop/bloch.png'
+-            This overrides the 'format' and 'dirc' arguments.
+-        format : str
+-            Format of output image. Default is 'png'.
+-        dirc : str
+-            Directory for output images. Defaults to current working directory.
+-
+-        Returns
+-        -------
+-        File containing plot of Bloch sphere.
+-
+-        """
+-        from mayavi import mlab
+-        import os
+-        self.make_sphere()
+-        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
+-        if dirc:
+-            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
+-                os.makedirs(os.getcwd() + "/" + str(dirc))
+-        if name is None:
+-            if dirc:
+-                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
+-                             str(self.savenum) + '.' + format)
+-            else:
+-                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
+-                             '.' + format)
+-        else:
+-            mlab.savefig(name)
+-        self.savenum += 1
+-        if self.fig:
+-            mlab.close(self.fig)
++__all__ = ['Bloch3d']
++
++import numpy as np
++from . import Qobj, expect, sigmax, sigmay, sigmaz
++
++
++class Bloch3d:
++    """Class for plotting data on a 3D Bloch sphere using mayavi.
++    Valid data can be either points, vectors, or qobj objects
++    corresponding to state vectors or density matrices. for
++    a two-state system (or subsystem).
++
++    Attributes
++    ----------
++    fig : instance {None}
++        User supplied Matplotlib Figure instance for plotting Bloch sphere.
++    font_color : str {'black'}
++        Color of font used for Bloch sphere labels.
++    font_scale : float {0.08}
++        Scale for font used for Bloch sphere labels.
++    frame : bool {True}
++        Draw frame for Bloch sphere
++    frame_alpha : float {0.05}
++        Sets transparency of Bloch sphere frame.
++    frame_color : str {'gray'}
++        Color of sphere wireframe.
++    frame_num : int {8}
++        Number of frame elements to draw.
++    frame_radius : floats {0.005}
++        Width of wireframe.
++    point_color : list {['r', 'g', 'b', 'y']}
++        List of colors for Bloch sphere point markers to cycle through.
++        i.e. By default, points 0 and 4 will both be blue ('r').
++    point_mode : string {'sphere','cone','cube','cylinder','point'}
++        Point marker shapes.
++    point_size : float {0.075}
++        Size of points on Bloch sphere.
++    sphere_alpha : float {0.1}
++        Transparency of Bloch sphere itself.
++    sphere_color : str {'#808080'}
++        Color of Bloch sphere.
++    size : list {[500,500]}
++        Size of Bloch sphere plot in pixels. Best to have both numbers the same
++        otherwise you will have a Bloch sphere that looks like a football.
++    vector_color : list {['r', 'g', 'b', 'y']}
++        List of vector colors to cycle through.
++    vector_width : int {3}
++        Width of displayed vectors.
++    view : list {[45,65]}
++        Azimuthal and Elevation viewing angles.
++    xlabel : list {``['|x>', '']``}
++        List of strings corresponding to +x and -x axes labels, respectively.
++    xlpos : list {[1.07,-1.07]}
++        Positions of +x and -x labels respectively.
++    ylabel : list {``['|y>', '']``}
++        List of strings corresponding to +y and -y axes labels, respectively.
++    ylpos : list {[1.07,-1.07]}
++        Positions of +y and -y labels respectively.
++    zlabel : list {``['|0>', '|1>']``}
++        List of strings corresponding to +z and -z axes labels, respectively.
++    zlpos : list {[1.07,-1.07]}
++        Positions of +z and -z labels respectively.
++
++    Notes
++    -----
++    The use of mayavi for 3D rendering of the Bloch sphere comes with
++    a few limitations: I) You can not embed a Bloch3d figure into a
++    matplotlib window. II) The use of LaTex is not supported by the
++    mayavi rendering engine. Therefore all labels must be defined using
++    standard text. Of course you can post-process the generated figures
++    later to add LaTeX using other software if needed.
++
++
++    """
++    def __init__(self, fig=None):
++        # ----check for mayavi-----
++        try:
++            from mayavi import mlab
++        except:
++            raise Exception("This function requires the mayavi module.")
++
++        # ---Image options---
++        self.fig = None
++        self.user_fig = None
++        # check if user specified figure or axes.
++        if fig:
++            self.user_fig = fig
++        # The size of the figure in inches, default = [500,500].
++        self.size = [500, 500]
++        # Azimuthal and Elvation viewing angles, default = [45,65].
++        self.view = [45, 65]
++        # Image background color
++        self.bgcolor = 'white'
++        # Image foreground color. Other options can override.
++        self.fgcolor = 'black'
++
++        # ---Sphere options---
++        # Color of Bloch sphere, default = #808080
++        self.sphere_color = '#808080'
++        # Transparency of Bloch sphere, default = 0.1
++        self.sphere_alpha = 0.1
++
++        # ---Frame options---
++        # Draw frame?
++        self.frame = True
++        # number of lines to draw for frame
++        self.frame_num = 8
++        # Color of wireframe, default = 'gray'
++        self.frame_color = 'black'
++        # Transparency of wireframe, default = 0.2
++        self.frame_alpha = 0.05
++        # Radius of frame lines
++        self.frame_radius = 0.005
++
++        # --Axes---
++        # Axes color
++        self.axes_color = 'black'
++        # Transparency of axes
++        self.axes_alpha = 0.4
++        # Radius of axes lines
++        self.axes_radius = 0.005
++
++        # ---Labels---
++        # Labels for x-axis (in LaTex), default = ['$x$','']
++        self.xlabel = ['|x>', '']
++        # Position of x-axis labels, default = [1.2,-1.2]
++        self.xlpos = [1.07, -1.07]
++        # Labels for y-axis (in LaTex), default = ['$y$','']
++        self.ylabel = ['|y>', '']
++        # Position of y-axis labels, default = [1.1,-1.1]
++        self.ylpos = [1.07, -1.07]
++        # Labels for z-axis
++        self.zlabel = ['|0>', '|1>']
++        # Position of z-axis labels, default = [1.05,-1.05]
++        self.zlpos = [1.07, -1.07]
++
++        # ---Font options---
++        # Color of fonts, default = 'black'
++        self.font_color = 'black'
++        # Size of fonts, default = 20
++        self.font_scale = 0.08
++
++        # ---Vector options---
++        # Object used for representing vectors on Bloch sphere.
++        # List of colors for Bloch vectors, default = ['b','g','r','y']
++        self.vector_color = ['r', 'g', 'b', 'y']
++        # Width of Bloch vectors, default = 2
++        self.vector_width = 2.0
++        # Height of vector head
++        self.vector_head_height = 0.15
++        # Radius of vector head
++        self.vector_head_radius = 0.075
++
++        # ---Point options---
++        # List of colors for Bloch point markers, default = ['b','g','r','y']
++        self.point_color = ['r', 'g', 'b', 'y']
++        # Size of point markers
++        self.point_size = 0.06
++        # Shape of point markers
++        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
++        # Default = 'sphere'
++        self.point_mode = 'sphere'
++
++        # ---Data lists---
++        # Data for point markers
++        self.points = []
++        # Data for Bloch vectors
++        self.vectors = []
++        # Number of times sphere has been saved
++        self.savenum = 0
++        # Style of points, 'm' for multiple colors, 's' for single color
++        self.point_style = []
++        # Transparency of points
++        self.point_alpha = []
++        # Transparency of vectors
++        self.vector_alpha = []
++
++    def __str__(self):
++        s = ""
++        s += "Bloch3D data:\n"
++        s += "-----------\n"
++        s += "Number of points:  " + str(len(self.points)) + "\n"
++        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
++        s += "\n"
++        s += "Bloch3D sphere properties:\n"
++        s += "--------------------------\n"
++        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
++        s += "axes_color:         " + str(self.axes_color) + "\n"
++        s += "axes_radius:        " + str(self.axes_radius) + "\n"
++        s += "bgcolor:            " + str(self.bgcolor) + "\n"
++        s += "fgcolor:            " + str(self.fgcolor) + "\n"
++        s += "font_color:         " + str(self.font_color) + "\n"
++        s += "font_scale:         " + str(self.font_scale) + "\n"
++        s += "frame:              " + str(self.frame) + "\n"
++        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
++        s += "frame_color:        " + str(self.frame_color) + "\n"
++        s += "frame_num:          " + str(self.frame_num) + "\n"
++        s += "frame_radius:       " + str(self.frame_radius) + "\n"
++        s += "point_color:        " + str(self.point_color) + "\n"
++        s += "point_mode:         " + str(self.point_mode) + "\n"
++        s += "point_size:         " + str(self.point_size) + "\n"
++        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
++        s += "sphere_color:       " + str(self.sphere_color) + "\n"
++        s += "size:               " + str(self.size) + "\n"
++        s += "vector_color:       " + str(self.vector_color) + "\n"
++        s += "vector_width:       " + str(self.vector_width) + "\n"
++        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
++        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
++        s += "view:               " + str(self.view) + "\n"
++        s += "xlabel:             " + str(self.xlabel) + "\n"
++        s += "xlpos:              " + str(self.xlpos) + "\n"
++        s += "ylabel:             " + str(self.ylabel) + "\n"
++        s += "ylpos:              " + str(self.ylpos) + "\n"
++        s += "zlabel:             " + str(self.zlabel) + "\n"
++        s += "zlpos:              " + str(self.zlpos) + "\n"
++        return s
++
++    def clear(self):
++        """Resets the Bloch sphere data sets to empty.
++        """
++        self.points = []
++        self.vectors = []
++        self.point_style = []
++
++    def add_points(self, points, meth='s', alpha=1.0):
++        """Add a list of data points to bloch sphere.
++
++        Parameters
++        ----------
++        points : array/list
++            Collection of data points.
++
++        meth : str {'s','m'}
++            Type of points to plot, use 'm' for multicolored.
++
++        alpha : float, default=1.
++            Transparency value for the vectors. Values between 0 and 1.
++
++        """
++        if not isinstance(points[0], (list, np.ndarray)):
++            points = [[points[0]], [points[1]], [points[2]]]
++        points = np.array(points)
++        if meth == 's':
++            if len(points[0]) == 1:
++                pnts = np.array(
++                    [[points[0][0]], [points[1][0]], [points[2][0]]])
++                pnts = np.append(pnts, points, axis=1)
++            else:
++                pnts = points
++            self.points.append(pnts)
++            self.point_style.append('s')
++        else:
++            self.points.append(points)
++            self.point_style.append('m')
++        self.point_alpha.append(alpha)
++
++    def add_states(self, state, kind='vector', alpha=1.0):
++        """Add a state vector Qobj to Bloch sphere.
++
++        Parameters
++        ----------
++        state : qobj
++            Input state vector.
++
++        kind : str {'vector','point'}
++            Type of object to plot.
++
++        alpha : float, default=1.
++            Transparency value for the vectors. Values between 0 and 1.
++        """
++        if isinstance(state, Qobj):
++            state = [state]
++        for st in state:
++            if kind == 'vector':
++                vec = [expect(sigmax(), st), expect(sigmay(), st),
++                       expect(sigmaz(), st)]
++                self.add_vectors(vec, alpha=alpha)
++            elif kind == 'point':
++                pnt = [expect(sigmax(), st), expect(sigmay(), st),
++                       expect(sigmaz(), st)]
++                self.add_points(pnt, alpha=alpha)
++
++    def add_vectors(self, vectors, alpha=1.0):
++        """Add a list of vectors to Bloch sphere.
++
++        Parameters
++        ----------
++        vectors : array/list
++            Array with vectors of unit length or smaller.
++
++        alpha : float, default=1.
++            Transparency value for the vectors. Values between 0 and 1.
++
++        """
++        if isinstance(vectors[0], (list, np.ndarray)):
++            for vec in vectors:
++                self.vectors.append(vec)
++                self.vector_alpha.append(alpha)
++        else:
++            self.vectors.append(vectors)
++            self.vector_alpha.append(alpha)
++
++    def plot_vectors(self):
++        """
++        Plots vectors on the Bloch sphere.
++        """
++        from mayavi import mlab
++        from tvtk.api import tvtk
++        import matplotlib.colors as colors
++        ii = 0
++        for k in range(len(self.vectors)):
++            vec = np.array(self.vectors[k])
++            norm = np.linalg.norm(vec)
++            theta = np.arccos(vec[2] / norm)
++            phi = np.arctan2(vec[1], vec[0])
++            vec -= 0.5 * self.vector_head_height * \
++                np.array([np.sin(theta) * np.cos(phi),
++                          np.sin(theta) * np.sin(phi), np.cos(theta)])
++
++            color = colors.colorConverter.to_rgb(
++                self.vector_color[np.mod(k, len(self.vector_color))])
++
++            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
++                        name='vector' + str(ii), tube_sides=100,
++                        line_width=self.vector_width,
++                        opacity=self.vector_alpha[k],
++                        color=color)
++
++            cone = tvtk.ConeSource(height=self.vector_head_height,
++                                   radius=self.vector_head_radius,
++                                   resolution=100)
++            cone_mapper = tvtk.PolyDataMapper(
++                input_connection=cone.output_port)
++            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
++            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
++            cc.rotate_z(np.degrees(phi))
++            cc.rotate_y(-90 + np.degrees(theta))
++            cc.position = vec
++            self.fig.scene.add_actor(cc)
++
++    def plot_points(self):
++        """
++        Plots points on the Bloch sphere.
++        """
++        from mayavi import mlab
++        import matplotlib.colors as colors
++        for k in range(len(self.points)):
++            num = len(self.points[k][0])
++            dist = [np.sqrt(self.points[k][0][j] ** 2 +
++                            self.points[k][1][j] ** 2 +
++                            self.points[k][2][j] ** 2) for j in range(num)]
++            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
++                # combine arrays so that they can be sorted together
++                # and sort rates from lowest to highest
++                zipped = sorted(zip(dist, range(num)))
++                dist, indperm = zip(*zipped)
++                indperm = np.array(indperm)
++            else:
++                indperm = range(num)
++            if self.point_style[k] == 's':
++                color = colors.colorConverter.to_rgb(
++                    self.point_color[np.mod(k, len(self.point_color))])
++                mlab.points3d(
++                    self.points[k][0][indperm], self.points[k][1][indperm],
++                    self.points[k][2][indperm], figure=self.fig,
++                    resolution=100, scale_factor=self.point_size,
++                    mode=self.point_mode, color=color,
++                    opacity=self.point_alpha[k])
++
++            elif self.point_style[k] == 'm':
++                pnt_colors = np.array(self.point_color * np.ceil(
++                    num / float(len(self.point_color))))
++                pnt_colors = pnt_colors[0:num]
++                pnt_colors = list(pnt_colors[indperm])
++                for kk in range(num):
++                    mlab.points3d(
++                        self.points[k][0][
++                            indperm[kk]], self.points[k][1][indperm[kk]],
++                        self.points[k][2][
++                            indperm[kk]], figure=self.fig, resolution=100,
++                        scale_factor=self.point_size, mode=self.point_mode,
++                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
++                        opacity=self.point_alpha[k])
++
++    def make_sphere(self):
++        """
++        Plots Bloch sphere and data sets.
++        """
++        # setup plot
++        # Figure instance for Bloch sphere plot
++        from mayavi import mlab
++        import matplotlib.colors as colors
++        if self.user_fig:
++            self.fig = self.user_fig
++        else:
++            self.fig = mlab.figure(
++                1, size=self.size,
++                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
++                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
++
++        sphere = mlab.points3d(
++            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
++            color=colors.colorConverter.to_rgb(self.sphere_color),
++            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
++
++        # Thse commands make the sphere look better
++        sphere.actor.property.specular = 0.45
++        sphere.actor.property.specular_power = 5
++        sphere.actor.property.backface_culling = True
++
++        # make frame for sphere surface
++        if self.frame:
++            theta = np.linspace(0, 2 * np.pi, 100)
++            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
++                xlat = np.cos(theta) * np.cos(angle)
++                ylat = np.sin(theta) * np.cos(angle)
++                zlat = np.ones_like(theta) * np.sin(angle)
++                xlon = np.sin(angle) * np.sin(theta)
++                ylon = np.cos(angle) * np.sin(theta)
++                zlon = np.cos(theta)
++                mlab.plot3d(
++                    xlat, ylat, zlat,
++                    color=colors.colorConverter.to_rgb(self.frame_color),
++                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
++                mlab.plot3d(
++                    xlon, ylon, zlon,
++                    color=colors.colorConverter.to_rgb(self.frame_color),
++                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
++
++        # add axes
++        axis = np.linspace(-1.0, 1.0, 10)
++        other = np.zeros_like(axis)
++        mlab.plot3d(
++            axis, other, other,
++            color=colors.colorConverter.to_rgb(self.axes_color),
++            tube_radius=self.axes_radius, opacity=self.axes_alpha)
++        mlab.plot3d(
++            other, axis, other,
++            color=colors.colorConverter.to_rgb(self.axes_color),
++            tube_radius=self.axes_radius, opacity=self.axes_alpha)
++        mlab.plot3d(
++            other, other, axis,
++            color=colors.colorConverter.to_rgb(self.axes_color),
++            tube_radius=self.axes_radius, opacity=self.axes_alpha)
++
++        # add data to sphere
++        self.plot_points()
++        self.plot_vectors()
++
++        # #add labels
++        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
++                    color=colors.colorConverter.to_rgb(self.font_color),
++                    scale=self.font_scale)
++        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
++                    color=colors.colorConverter.to_rgb(self.font_color),
++                    scale=self.font_scale)
++        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
++                    color=colors.colorConverter.to_rgb(self.font_color),
++                    scale=self.font_scale)
++        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
++                    color=colors.colorConverter.to_rgb(self.font_color),
++                    scale=self.font_scale)
++        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
++                    color=colors.colorConverter.to_rgb(self.font_color),
++                    scale=self.font_scale)
++        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
++                    color=colors.colorConverter.to_rgb(self.font_color),
++                    scale=self.font_scale)
++
++    def show(self):
++        """
++        Display the Bloch sphere and corresponding data sets.
++        """
++        from mayavi import mlab
++        self.make_sphere()
++        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
++        if self.fig:
++            mlab.show()
++
++    def save(self, name=None, format='png', dirc=None):
++        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
++
++        Parameters
++        ----------
++        name : str
++            Name of saved image. Must include path and format as well.
++            i.e. '/Users/Paul/Desktop/bloch.png'
++            This overrides the 'format' and 'dirc' arguments.
++        format : str
++            Format of output image. Default is 'png'.
++        dirc : str
++            Directory for output images. Defaults to current working directory.
++
++        Returns
++        -------
++        File containing plot of Bloch sphere.
++
++        """
++        from mayavi import mlab
++        import os
++        self.make_sphere()
++        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
++        if dirc:
++            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
++                os.makedirs(os.getcwd() + "/" + str(dirc))
++        if name is None:
++            if dirc:
++                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
++                             str(self.savenum) + '.' + format)
++            else:
++                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
++                             '.' + format)
++        else:
++            mlab.savefig(name)
++        self.savenum += 1
++        if self.fig:
++            mlab.close(self.fig)
+diff --git a/qutip/cite.py b/qutip/cite.py
+index e3efb3e1..124b1197 100644
+--- a/qutip/cite.py
++++ b/qutip/cite.py
+@@ -1,60 +1,60 @@
+-"""
+-Citation generator for QuTiP
+-"""
+-import os
+-
+-__all__ = ['cite']
+-
+-
+-def cite(save=False, path=None):
+-    """
+-    Citation information and bibtex generator for QuTiP
+-
+-    Parameters
+-    ----------
+-    save: bool
+-        The flag specifying whether to save the .bib file.
+-
+-    path: str
+-        The complete directory path to generate the bibtex file.
+-        If not specified then the citation will be generated in cwd
+-    """
+-    citation = ["@article{qutip2,",
+-                "doi = {10.1016/j.cpc.2012.11.019},",
+-                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
+-                "year  = {2013},",
+-                "month = {apr},",
+-                "publisher = {Elsevier {BV}},",
+-                "volume = {184},",
+-                "number = {4},",
+-                "pages = {1234--1240},",
+-                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
+-                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
+-                "journal = {Computer Physics Communications}",
+-                "}",
+-                "@article{qutip1,",
+-                "doi = {10.1016/j.cpc.2012.02.021},",
+-                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
+-                "year  = {2012},",
+-                "month = {aug},",
+-                "publisher = {Elsevier {BV}},",
+-                "volume = {183},",
+-                "number = {8},",
+-                "pages = {1760--1772},",
+-                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
+-                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
+-                "journal = {Computer Physics Communications}",
+-                "}"]
+-    print("\n".join(citation))
+-
+-    if not path:
+-        path = os.getcwd()
+-
+-    if save:
+-        filename = "qutip.bib"
+-        with open(os.path.join(path, filename), 'w') as f:
+-            f.write("\n".join(citation))
+-
+-
+-if __name__ == "__main__":
+-    cite()
++"""
++Citation generator for QuTiP
++"""
++import os
++
++__all__ = ['cite']
++
++
++def cite(save=False, path=None):
++    """
++    Citation information and bibtex generator for QuTiP
++
++    Parameters
++    ----------
++    save: bool
++        The flag specifying whether to save the .bib file.
++
++    path: str
++        The complete directory path to generate the bibtex file.
++        If not specified then the citation will be generated in cwd
++    """
++    citation = ["@article{qutip2,",
++                "doi = {10.1016/j.cpc.2012.11.019},",
++                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
++                "year  = {2013},",
++                "month = {apr},",
++                "publisher = {Elsevier {BV}},",
++                "volume = {184},",
++                "number = {4},",
++                "pages = {1234--1240},",
++                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
++                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
++                "journal = {Computer Physics Communications}",
++                "}",
++                "@article{qutip1,",
++                "doi = {10.1016/j.cpc.2012.02.021},",
++                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
++                "year  = {2012},",
++                "month = {aug},",
++                "publisher = {Elsevier {BV}},",
++                "volume = {183},",
++                "number = {8},",
++                "pages = {1760--1772},",
++                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
++                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
++                "journal = {Computer Physics Communications}",
++                "}"]
++    print("\n".join(citation))
++
++    if not path:
++        path = os.getcwd()
++
++    if save:
++        filename = "qutip.bib"
++        with open(os.path.join(path, filename), 'w') as f:
++            f.write("\n".join(citation))
++
++
++if __name__ == "__main__":
++    cite()
+diff --git a/qutip/continuous_variables.py b/qutip/continuous_variables.py
+index 519f070f..004b5b36 100644
+--- a/qutip/continuous_variables.py
++++ b/qutip/continuous_variables.py
+@@ -1,259 +1,259 @@
+-"""
+-This module contains a collection functions for calculating continuous variable
+-quantities from fock-basis representation of the state of multi-mode fields.
+-"""
+-
+-__all__ = ['correlation_matrix', 'covariance_matrix',
+-           'correlation_matrix_field', 'correlation_matrix_quadrature',
+-           'wigner_covariance_matrix', 'logarithmic_negativity']
+-
+-from . import expect
+-import numpy as np
+-
+-
+-def correlation_matrix(basis, rho=None):
+-    r"""
+-    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
+-    matrix:
+-
+-    .. math::
+-
+-        C_{mn} = \langle a_m a_n \rangle
+-
+-    Parameters
+-    ----------
+-    basis : list
+-        List of operators that defines the basis for the correlation matrix.
+-    rho : Qobj
+-        Density matrix for which to calculate the correlation matrix. If
+-        `rho` is `None`, then a matrix of correlation matrix operators is
+-        returned instead of expectation values of those operators.
+-
+-    Returns
+-    -------
+-    corr_mat : ndarray
+-        A 2-dimensional *array* of correlation values or operators.
+-
+-
+-    """
+-    if rho is None:
+-        # return array of operators
+-        out = np.empty((len(basis), len(basis)), dtype=object)
+-        for i, op2 in enumerate(basis):
+-            out[i, :] = [op1 * op2 for op1 in basis]
+-        return out
+-    else:
+-        # return array of expectation values
+-        return np.array([[expect(op1 * op2, rho)
+-                          for op1 in basis] for op2 in basis])
+-
+-
+-def covariance_matrix(basis, rho, symmetrized=True):
+-    r"""
+-    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
+-    matrix:
+-
+-    .. math::
+-
+-        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
+-        \langle a_m \rangle \langle a_n\rangle
+-
+-    or, if of the optional argument `symmetrized=False`,
+-
+-    .. math::
+-
+-        V_{mn} = \langle a_m a_n\rangle -
+-        \langle a_m \rangle \langle a_n\rangle
+-
+-    Parameters
+-    ----------
+-    basis : list
+-        List of operators that defines the basis for the covariance matrix.
+-    rho : Qobj
+-        Density matrix for which to calculate the covariance matrix.
+-    symmetrized : bool {True, False}
+-        Flag indicating whether the symmetrized (default) or non-symmetrized
+-        correlation matrix is to be calculated.
+-
+-    Returns
+-    -------
+-    corr_mat : ndarray
+-        A 2-dimensional array of covariance values.
+-
+-    """
+-    if symmetrized:
+-        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
+-                          expect(op1, rho) * expect(op2, rho)
+-                          for op1 in basis] for op2 in basis])
+-    else:
+-        return np.array([[expect(op1 * op2, rho) -
+-                          expect(op1, rho) * expect(op2, rho)
+-                          for op1 in basis] for op2 in basis])
+-
+-
+-def correlation_matrix_field(a1, a2, rho=None):
+-    """
+-    Calculates the correlation matrix for given field operators :math:`a_1` and
+-    :math:`a_2`. If a density matrix is given the expectation values are
+-    calculated, otherwise a matrix with operators is returned.
+-
+-    Parameters
+-    ----------
+-    a1 : Qobj
+-        Field operator for mode 1.
+-    a2 : Qobj
+-        Field operator for mode 2.
+-    rho : Qobj
+-        Density matrix for which to calculate the covariance matrix.
+-
+-    Returns
+-    -------
+-    cov_mat : ndarray 
+-        Array of complex numbers or Qobj's
+-        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
+-        of operators.
+-    """
+-    basis = [a1, a1.dag(), a2, a2.dag()]
+-    return correlation_matrix(basis, rho)
+-
+-
+-def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
+-    """
+-    Calculate the quadrature correlation matrix with given field operators
+-    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
+-    values are calculated, otherwise a matrix with operators is returned.
+-
+-    Parameters
+-    ----------
+-    a1 : Qobj
+-        Field operator for mode 1.
+-    a2 : Qobj
+-        Field operator for mode 2.
+-    rho : Qobj
+-        Density matrix for which to calculate the covariance matrix.
+-    g : float
+-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+-        The value of `g` is related to the value of `hbar` in the commutation 
+-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
+-        value `hbar=1`. 
+-
+-    Returns
+-    -------
+-    corr_mat : ndarray 
+-        Array of complex numbers or Qobj's
+-        A 2-dimensional *array* of covariance values for the field quadratures,
+-        or, if rho=0, a matrix of operators.
+-
+-    """
+-    x1 = (a1 + a1.dag()) / g
+-    p1 = -1j * (a1 - a1.dag()) / g
+-    x2 = (a2 + a2.dag()) / g
+-    p2 = -1j * (a2 - a2.dag()) / g
+-    basis = [x1, p1, x2, p2]
+-    return correlation_matrix(basis, rho)
+-
+-
+-def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
+-    r"""
+-    Calculates the Wigner covariance matrix
+-    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
+-    the quadrature correlation matrix
+-    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
+-    \langle R_{i}\rangle \langle R_{j}\rangle`, where
+-    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
+-    for the two modes.
+-
+-    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
+-    for the two modes are supplied instead, the quadrature correlation matrix
+-    is constructed from the annihilation operators before then the covariance
+-    matrix is calculated.
+-
+-    Parameters
+-    ----------
+-
+-    a1 : Qobj
+-        Field operator for mode 1.
+-
+-    a2 : Qobj
+-        Field operator for mode 2.
+-
+-    R : ndarray
+-        The quadrature correlation matrix.
+-
+-    rho : Qobj
+-        Density matrix for which to calculate the covariance matrix.
+-
+-    g : float
+-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+-        The value of `g` is related to the value of `hbar` in the commutation 
+-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
+-        value `hbar=1`. 
+-
+-    Returns
+-    -------
+-    cov_mat : ndarray
+-        A 2-dimensional array of covariance values.
+-
+-    """
+-    if R is not None:
+-        if rho is None:
+-            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
+-                              for i in range(4)]
+-                             for j in range(4)], dtype=np.float64)
+-        else:
+-            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
+-                              for i in range(4)]
+-                             for j in range(4)], dtype=np.float64)
+-    elif a1 is not None and a2 is not None:
+-        if rho is not None:
+-            x1 = (a1 + a1.dag()) / g
+-            p1 = -1j * (a1 - a1.dag()) / g
+-            x2 = (a2 + a2.dag()) / g
+-            p2 = -1j * (a2 - a2.dag()) / g
+-            return covariance_matrix([x1, p1, x2, p2], rho)
+-        else:
+-            raise ValueError("Must give rho if using field operators " +
+-                             "(a1 and a2)")
+-    else:
+-        raise ValueError("Must give either field operators (a1 and a2) " +
+-                         "or a precomputed correlation matrix (R)")
+-
+-
+-def logarithmic_negativity(V, g=np.sqrt(2)):
+-    """
+-    Calculates the logarithmic negativity given a symmetrized covariance
+-    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
+-    the two-mode field state that is described by `V` must be Gaussian for this
+-    function to applicable.
+-
+-    Parameters
+-    ----------
+-
+-    V : *2d array*
+-        The covariance matrix.
+-
+-    g : float
+-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+-        The value of `g` is related to the value of `hbar` in the commutation 
+-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
+-        value `hbar=1`. 
+-
+-    Returns
+-    -------
+-
+-    N : float 
+-        The logarithmic negativity for the two-mode Gaussian state
+-        that is described by the the Wigner covariance matrix V.
+-
+-    """
+-    A = 0.5 * V[0:2, 0:2] * g ** 2
+-    B = 0.5 * V[2:4, 2:4] * g ** 2
+-    C = 0.5 * V[0:2, 2:4] * g ** 2
+-    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
+-    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
+-    if nu_ < 0.0:
+-        return 0.0
+-    nu = np.sqrt(nu_)
+-    lognu = -np.log(2 * nu)
+-    logneg = max(0, lognu)
+-    return logneg
++"""
++This module contains a collection functions for calculating continuous variable
++quantities from fock-basis representation of the state of multi-mode fields.
++"""
++
++__all__ = ['correlation_matrix', 'covariance_matrix',
++           'correlation_matrix_field', 'correlation_matrix_quadrature',
++           'wigner_covariance_matrix', 'logarithmic_negativity']
++
++from . import expect
++import numpy as np
++
++
++def correlation_matrix(basis, rho=None):
++    r"""
++    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
++    matrix:
++
++    .. math::
++
++        C_{mn} = \langle a_m a_n \rangle
++
++    Parameters
++    ----------
++    basis : list
++        List of operators that defines the basis for the correlation matrix.
++    rho : Qobj
++        Density matrix for which to calculate the correlation matrix. If
++        `rho` is `None`, then a matrix of correlation matrix operators is
++        returned instead of expectation values of those operators.
++
++    Returns
++    -------
++    corr_mat : ndarray
++        A 2-dimensional *array* of correlation values or operators.
++
++
++    """
++    if rho is None:
++        # return array of operators
++        out = np.empty((len(basis), len(basis)), dtype=object)
++        for i, op2 in enumerate(basis):
++            out[i, :] = [op1 * op2 for op1 in basis]
++        return out
++    else:
++        # return array of expectation values
++        return np.array([[expect(op1 * op2, rho)
++                          for op1 in basis] for op2 in basis])
++
++
++def covariance_matrix(basis, rho, symmetrized=True):
++    r"""
++    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
++    matrix:
++
++    .. math::
++
++        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
++        \langle a_m \rangle \langle a_n\rangle
++
++    or, if of the optional argument `symmetrized=False`,
++
++    .. math::
++
++        V_{mn} = \langle a_m a_n\rangle -
++        \langle a_m \rangle \langle a_n\rangle
++
++    Parameters
++    ----------
++    basis : list
++        List of operators that defines the basis for the covariance matrix.
++    rho : Qobj
++        Density matrix for which to calculate the covariance matrix.
++    symmetrized : bool {True, False}
++        Flag indicating whether the symmetrized (default) or non-symmetrized
++        correlation matrix is to be calculated.
++
++    Returns
++    -------
++    corr_mat : ndarray
++        A 2-dimensional array of covariance values.
++
++    """
++    if symmetrized:
++        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
++                          expect(op1, rho) * expect(op2, rho)
++                          for op1 in basis] for op2 in basis])
++    else:
++        return np.array([[expect(op1 * op2, rho) -
++                          expect(op1, rho) * expect(op2, rho)
++                          for op1 in basis] for op2 in basis])
++
++
++def correlation_matrix_field(a1, a2, rho=None):
++    """
++    Calculates the correlation matrix for given field operators :math:`a_1` and
++    :math:`a_2`. If a density matrix is given the expectation values are
++    calculated, otherwise a matrix with operators is returned.
++
++    Parameters
++    ----------
++    a1 : Qobj
++        Field operator for mode 1.
++    a2 : Qobj
++        Field operator for mode 2.
++    rho : Qobj
++        Density matrix for which to calculate the covariance matrix.
++
++    Returns
++    -------
++    cov_mat : ndarray 
++        Array of complex numbers or Qobj's
++        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
++        of operators.
++    """
++    basis = [a1, a1.dag(), a2, a2.dag()]
++    return correlation_matrix(basis, rho)
++
++
++def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
++    """
++    Calculate the quadrature correlation matrix with given field operators
++    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
++    values are calculated, otherwise a matrix with operators is returned.
++
++    Parameters
++    ----------
++    a1 : Qobj
++        Field operator for mode 1.
++    a2 : Qobj
++        Field operator for mode 2.
++    rho : Qobj
++        Density matrix for which to calculate the covariance matrix.
++    g : float
++        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
++        The value of `g` is related to the value of `hbar` in the commutation 
++        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
++        value `hbar=1`. 
++
++    Returns
++    -------
++    corr_mat : ndarray 
++        Array of complex numbers or Qobj's
++        A 2-dimensional *array* of covariance values for the field quadratures,
++        or, if rho=0, a matrix of operators.
++
++    """
++    x1 = (a1 + a1.dag()) / g
++    p1 = -1j * (a1 - a1.dag()) / g
++    x2 = (a2 + a2.dag()) / g
++    p2 = -1j * (a2 - a2.dag()) / g
++    basis = [x1, p1, x2, p2]
++    return correlation_matrix(basis, rho)
++
++
++def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
++    r"""
++    Calculates the Wigner covariance matrix
++    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
++    the quadrature correlation matrix
++    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
++    \langle R_{i}\rangle \langle R_{j}\rangle`, where
++    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
++    for the two modes.
++
++    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
++    for the two modes are supplied instead, the quadrature correlation matrix
++    is constructed from the annihilation operators before then the covariance
++    matrix is calculated.
++
++    Parameters
++    ----------
++
++    a1 : Qobj
++        Field operator for mode 1.
++
++    a2 : Qobj
++        Field operator for mode 2.
++
++    R : ndarray
++        The quadrature correlation matrix.
++
++    rho : Qobj
++        Density matrix for which to calculate the covariance matrix.
++
++    g : float
++        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
++        The value of `g` is related to the value of `hbar` in the commutation 
++        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
++        value `hbar=1`. 
++
++    Returns
++    -------
++    cov_mat : ndarray
++        A 2-dimensional array of covariance values.
++
++    """
++    if R is not None:
++        if rho is None:
++            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
++                              for i in range(4)]
++                             for j in range(4)], dtype=np.float64)
++        else:
++            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
++                              for i in range(4)]
++                             for j in range(4)], dtype=np.float64)
++    elif a1 is not None and a2 is not None:
++        if rho is not None:
++            x1 = (a1 + a1.dag()) / g
++            p1 = -1j * (a1 - a1.dag()) / g
++            x2 = (a2 + a2.dag()) / g
++            p2 = -1j * (a2 - a2.dag()) / g
++            return covariance_matrix([x1, p1, x2, p2], rho)
++        else:
++            raise ValueError("Must give rho if using field operators " +
++                             "(a1 and a2)")
++    else:
++        raise ValueError("Must give either field operators (a1 and a2) " +
++                         "or a precomputed correlation matrix (R)")
++
++
++def logarithmic_negativity(V, g=np.sqrt(2)):
++    """
++    Calculates the logarithmic negativity given a symmetrized covariance
++    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
++    the two-mode field state that is described by `V` must be Gaussian for this
++    function to applicable.
++
++    Parameters
++    ----------
++
++    V : *2d array*
++        The covariance matrix.
++
++    g : float
++        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
++        The value of `g` is related to the value of `hbar` in the commutation 
++        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
++        value `hbar=1`. 
++
++    Returns
++    -------
++
++    N : float 
++        The logarithmic negativity for the two-mode Gaussian state
++        that is described by the the Wigner covariance matrix V.
++
++    """
++    A = 0.5 * V[0:2, 0:2] * g ** 2
++    B = 0.5 * V[2:4, 2:4] * g ** 2
++    C = 0.5 * V[0:2, 2:4] * g ** 2
++    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
++    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
++    if nu_ < 0.0:
++        return 0.0
++    nu = np.sqrt(nu_)
++    lognu = -np.log(2 * nu)
++    logneg = max(0, lognu)
++    return logneg
+diff --git a/qutip/control.py b/qutip/control.py
+index 559a6a8d..7b3fb74f 100644
+--- a/qutip/control.py
++++ b/qutip/control.py
+@@ -1,13 +1,13 @@
+-"""Module replicating the qutip_qtrl package from within qutip."""
+-import sys
+-
+-try:
+-    import qutip_qtrl
+-    del qutip_qtrl
+-    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
+-except ImportError:
+-    raise ImportError(
+-        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
+-        "Install it with `pip install qutip-qtrl` (for more details, go to "
+-        "https://qutip-qtrl.readthedocs.io/)."
+-    )
++"""Module replicating the qutip_qtrl package from within qutip."""
++import sys
++
++try:
++    import qutip_qtrl
++    del qutip_qtrl
++    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
++except ImportError:
++    raise ImportError(
++        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
++        "Install it with `pip install qutip-qtrl` (for more details, go to "
++        "https://qutip-qtrl.readthedocs.io/)."
++    )
+diff --git a/qutip/core/__init__.py b/qutip/core/__init__.py
+index b12830ba..dc183518 100644
+--- a/qutip/core/__init__.py
++++ b/qutip/core/__init__.py
+@@ -1,16 +1,16 @@
+-from .options import *
+-from .coefficient import *
+-from .qobj import *
+-from .cy.qobjevo import *
+-from .expect import *
+-from .tensor import *
+-from .states import *
+-from .operators import *
+-from .metrics import *
+-from .superoperator import *
+-from .superop_reps import *
+-from .subsystem_apply import *
+-from .blochredfield import *
+-from . import gates
+-
+-del cy  # File in cy are not public facing
++from .options import *
++from .coefficient import *
++from .qobj import *
++from .cy.qobjevo import *
++from .expect import *
++from .tensor import *
++from .states import *
++from .operators import *
++from .metrics import *
++from .superoperator import *
++from .superop_reps import *
++from .subsystem_apply import *
++from .blochredfield import *
++from . import gates
++
++del cy  # File in cy are not public facing
+diff --git a/qutip/core/_brtensor.pyx b/qutip/core/_brtensor.pyx
+index 530cf63d..25788233 100644
+--- a/qutip/core/_brtensor.pyx
++++ b/qutip/core/_brtensor.pyx
+@@ -1,337 +1,337 @@
+-#cython: language_level=3
+-cimport cython
+-
+-import qutip.core.data as _data
+-from qutip.core.data cimport Dense, CSR, Data, idxint, csr
+-from qutip.core.cy.qobjevo cimport QobjEvo
+-from qutip.core.cy.coefficient cimport Coefficient
+-from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
+-from qutip.core._brtools cimport _EigenBasisTransform
+-from qutip.core.qobj import Qobj
+-
+-import numpy as np
+-from libcpp.vector cimport vector
+-from libc.math cimport fabs, fmin
+-
+-__all__ = []
+-
+-
+-cpdef enum TensorType:
+-    SPARSE = 0
+-    DENSE = 1
+-    DATA = 2
+-
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
+-                         double[:, ::1] skew, double cutoff):
+-    """
+-    Compute the contribution of A to the Bloch Redfield tensor.
+-    Computation are done using dispatched function.
+-    """
+-    cdef object cutoff_arr
+-    cdef int nrows = A.shape[0], a, b, c, d
+-    cdef Data S, I, AS, AST, out, C
+-    cdef type cls = type(A)
+-
+-    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
+-    I = _data.identity[cls](nrows)
+-    AS = _data.multiply(A, S)
+-    AST = _data.multiply(A, _data.transpose(S))
+-
+-    out = _data.kron(AST, _data.transpose(A))
+-    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
+-    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
+-    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
+-
+-    if cutoff == np.inf:
+-        return out
+-
+-    # The cutoff_arr should be sparse most of the time, but it depend on the
+-    # cutoff and we cannot easily guess a nnz to make it efficiently...
+-    # But there is probably room from improvement.
+-    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
+-    for a in range(nrows):
+-        for b in range(nrows):
+-            for c in range(nrows):
+-                for d in range(nrows):
+-                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
+-                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
+-    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
+-    return _data.multiply(out, C)
+-
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
+-                           double[:, ::1] skew, double cutoff):
+-    """
+-    Compute the contribution of A to the Bloch Redfield tensor.
+-    Allocate a Dense array and fill it.
+-    """
+-    cdef size_t nrows = A.shape[0]
+-    cdef size_t a, b, c, d, k # matrix indexing variables
+-    cdef double complex elem
+-    cdef double complex[:,:] A_mat, ac_term, bd_term
+-    cdef object np2term
+-    cdef Dense out
+-    cdef double complex[::1, :] out_array
+-
+-    if type(A) is Dense:
+-        A_mat = A.as_ndarray()
+-    else:
+-        A_mat = A.to_array()
+-
+-    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
+-    out_array = out.as_ndarray()
+-
+-    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
+-    ac_term = np2term[:, :, 0]
+-    bd_term = np2term[:, :, 1]
+-
+-
+-    for a in range(nrows):
+-        for b in range(nrows-1, -1, -1):
+-            if fabs(skew[a, b]) < cutoff:
+-                for k in range(nrows):
+-                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
+-                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
+-
+-    # TODO: we could use openmp to speed up.
+-    for a in range(nrows):
+-        for b in range(nrows):
+-            for c in range(nrows):
+-                for d in range(nrows):
+-                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
+-                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
+-                        elem *= (spectrum[c, a] + spectrum[d, b])
+-                        if a == c:
+-                            elem = elem - 0.5 * ac_term[d, b]
+-                        if b == d:
+-                            elem = elem - 0.5 * bd_term[a, c]
+-                        out_array[a * nrows + b, c * nrows + d] = elem
+-    return out
+-
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
+-                          double[:, ::1] skew, double cutoff):
+-    """
+-    Compute the contribution of A to the Bloch Redfield tensor.
+-    Create it as coo pointers and return as CSR.
+-    """
+-    cdef size_t nrows = A.shape[0]
+-    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
+-    cdef double complex elem, ac_elem, bd_elem
+-    cdef double complex[:,:] A_mat, ac_term, bd_term
+-    cdef double dskew
+-    cdef object np2term
+-    cdef vector[idxint] coo_rows, coo_cols
+-    cdef vector[double complex] coo_data
+-
+-    if type(A) is Dense:
+-        A_mat = A.as_ndarray()
+-    else:
+-        A_mat = A.to_array()
+-
+-    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
+-    ac_term = np2term[:, :, 0]
+-    bd_term = np2term[:, :, 1]
+-
+-    for a in range(nrows):
+-        for b in range(nrows-1, -1, -1):
+-            if fabs(skew[a, b]) < cutoff:
+-                for k in range(nrows):
+-                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
+-                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
+-            elif skew[a, b] > cutoff:
+-                break
+-
+-    # skew[a,b] = w[a] - w[b]
+-    # (w[a] - w[b] - w[c] + w[d]) < cutoff
+-    # w's are sorted so we can skip part of the loop.
+-    for a in range(nrows):
+-        for b in range(nrows):
+-            d_min = 0
+-            for c in range(nrows):
+-                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
+-                    break
+-                for d in range(d_min, nrows):
+-                    dskew = skew[a, b] - skew[c, d]
+-                    if -dskew > cutoff:
+-                        d_min = d
+-                    elif fabs(dskew) < cutoff:
+-                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
+-                        elem *= (spectrum[c, a] + spectrum[d, b])
+-                        if a == c:
+-                            elem -= 0.5 * ac_term[d, b]
+-                        if b == d:
+-                            elem -= 0.5 * bd_term[a, c]
+-                        if elem != 0:
+-                            coo_rows.push_back(a * nrows + b)
+-                            coo_cols.push_back(c * nrows + d)
+-                            coo_data.push_back(elem)
+-                    elif dskew >= cutoff:
+-                        break
+-
+-    return csr.from_coo_pointers(
+-        coo_rows.data(), coo_cols.data(), coo_data.data(),
+-        nrows*nrows, nrows*nrows, coo_rows.size()
+-    )
+-
+-
+-cdef class _BlochRedfieldElement(_BaseElement):
+-    """
+-    Element for individual Bloch Redfield collapse term.
+-
+-    The tensor is computed in the ``eig_basis``, but is returned in the outside
+-    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
+-    on a state expected to be in that basis. It transform the state instead of
+-    the tensor as it is usually faster, the state being a density matrix in
+-    most cases.
+-
+-    Diffenrent term can share a same instance of the eigen transform tool
+-    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
+-    only once even when needed by multiple terms.
+-    """
+-    cdef readonly _EigenBasisTransform H
+-    cdef readonly QobjEvo a_op
+-    cdef readonly Coefficient spectra
+-    cdef readonly double sec_cutoff
+-    cdef readonly size_t nrows
+-    cdef readonly (idxint, idxint) shape
+-    cdef readonly list dims
+-    cdef readonly object np_datas
+-    cdef readonly double[:, ::1] skew
+-    cdef readonly double[:, ::1] spectrum
+-    cdef readonly bint eig_basis
+-    cdef readonly TensorType tensortype
+-
+-    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
+-                 dtype=None):
+-        if isinstance(H, _EigenBasisTransform):
+-            self.H = H
+-        else:
+-            self.H = _EigenBasisTransform(H)
+-
+-        self.a_op = a_op
+-        self.spectra = spectra
+-        self.sec_cutoff = sec_cutoff
+-        self.eig_basis = eig_basis
+-        self.nrows = a_op.shape[0]
+-        self.dims = [a_op.dims, a_op.dims]
+-
+-        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
+-        self.tensortype = {
+-            'sparse': SPARSE,
+-            'dense': DENSE,
+-            'data': DATA
+-        }[dtype]
+-
+-        # Allocate some array
+-        # Let numpy manage memory
+-        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
+-                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
+-        self.skew = self.np_datas[0]
+-        self.spectrum = self.np_datas[1]
+-
+-    cpdef double _compute_spectrum(self, double t) except *:
+-        "Compute the skew, spectrum and dw_min"
+-        cdef Coefficient spec
+-        cdef double dw_min = np.inf
+-        eigvals = self.H.eigenvalues(t)
+-
+-        for col in range(0, self.nrows):
+-            self.skew[col, col] = 0.
+-            self.spectrum[col, col] = self.spectra(t, w=0).real
+-            for row in range(col, self.nrows):
+-                dw = eigvals[row] - eigvals[col]
+-                self.skew[row, col] = dw
+-                self.skew[col, row] = -dw
+-                if dw != 0:
+-                    dw_min = fmin(fabs(dw), dw_min)
+-                self.spectrum[row, col] = self.spectra(t, w=dw).real
+-                self.spectrum[col, row] = self.spectra(t, w=-dw).real
+-        return dw_min
+-
+-    cdef Data _br_term(self, Data A_eig, double cutoff):
+-        if self.tensortype == DENSE:
+-            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
+-        elif self.tensortype == SPARSE:
+-            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
+-        elif self.tensortype == DATA:
+-            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
+-        raise ValueError('Invalid tensortype')
+-
+-    cpdef object qobj(self, t):
+-        return Qobj(self.data(t), dims=self.dims, type="super",
+-                    copy=False, superrep="super")
+-
+-    cpdef object coeff(self, t):
+-        return 1.
+-
+-    cpdef Data data(self, t):
+-        cdef size_t i
+-        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
+-        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
+-        BR_eig = self._br_term(A_eig, cutoff)
+-        if self.eig_basis:
+-            return BR_eig
+-        return self.H.from_eigbasis(t, BR_eig)
+-
+-    cdef Data matmul_data_t(self, t, Data state, Data out=None):
+-        cdef size_t i
+-        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
+-        cdef Data A_eig, BR_eig
+-
+-        if not self.eig_basis:
+-            state = self.H.to_eigbasis(t, state)
+-        if not self.eig_basis and out is not None:
+-            out = self.H.to_eigbasis(t, out)
+-        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
+-        BR_eig = self._br_term(A_eig, cutoff)
+-        out = _data.add(_data.matmul(BR_eig, state), out)
+-        if not self.eig_basis:
+-            out = self.H.from_eigbasis(t, out)
+-        return out
+-
+-    def linear_map(self, f, anti=False):
+-        return _MapElement(self, [f])
+-
+-    def replace_arguments(self, args, cache=None):
+-        if cache is None:
+-            return _BlochRedfieldElement(
+-                self.H,
+-                QobjEvo(self.a_op, args=args),
+-                self.spectra,
+-                self.sec_cutoff
+-            )
+-        H = None
+-        for old, new in cache:
+-            if old is self:
+-                return new
+-            if old is self.H:
+-                H = new
+-        if H is None:
+-            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
+-                                     type(self.H.oper) is CSR)
+-        new = _BlochRedfieldElement(
+-            H, QobjEvo(self.a_op, args=args),
+-            self.spectra.replace_arguments(**args), self.sec_cutoff
+-        )
+-        cache.append((self, new))
+-        cache.append((self.H, H))
+-        return new
+-
+-    def __matmul__(left, right):
+-        return _ProdElement(left, right, [])
+-
+-    def __mul__(left, right):
+-        cdef _MapElement out
+-        if type(left) is _BlochRedfieldElement:
+-            out = _MapElement(left, [], right)
+-        if type(right) is _BlochRedfieldElement:
+-            out = _MapElement(right, [], left)
+-        return out
++#cython: language_level=3
++cimport cython
++
++import qutip.core.data as _data
++from qutip.core.data cimport Dense, CSR, Data, idxint, csr
++from qutip.core.cy.qobjevo cimport QobjEvo
++from qutip.core.cy.coefficient cimport Coefficient
++from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
++from qutip.core._brtools cimport _EigenBasisTransform
++from qutip.core.qobj import Qobj
++
++import numpy as np
++from libcpp.vector cimport vector
++from libc.math cimport fabs, fmin
++
++__all__ = []
++
++
++cpdef enum TensorType:
++    SPARSE = 0
++    DENSE = 1
++    DATA = 2
++
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
++                         double[:, ::1] skew, double cutoff):
++    """
++    Compute the contribution of A to the Bloch Redfield tensor.
++    Computation are done using dispatched function.
++    """
++    cdef object cutoff_arr
++    cdef int nrows = A.shape[0], a, b, c, d
++    cdef Data S, I, AS, AST, out, C
++    cdef type cls = type(A)
++
++    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
++    I = _data.identity[cls](nrows)
++    AS = _data.multiply(A, S)
++    AST = _data.multiply(A, _data.transpose(S))
++
++    out = _data.kron(AST, _data.transpose(A))
++    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
++    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
++    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
++
++    if cutoff == np.inf:
++        return out
++
++    # The cutoff_arr should be sparse most of the time, but it depend on the
++    # cutoff and we cannot easily guess a nnz to make it efficiently...
++    # But there is probably room from improvement.
++    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
++    for a in range(nrows):
++        for b in range(nrows):
++            for c in range(nrows):
++                for d in range(nrows):
++                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
++                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
++    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
++    return _data.multiply(out, C)
++
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
++                           double[:, ::1] skew, double cutoff):
++    """
++    Compute the contribution of A to the Bloch Redfield tensor.
++    Allocate a Dense array and fill it.
++    """
++    cdef size_t nrows = A.shape[0]
++    cdef size_t a, b, c, d, k # matrix indexing variables
++    cdef double complex elem
++    cdef double complex[:,:] A_mat, ac_term, bd_term
++    cdef object np2term
++    cdef Dense out
++    cdef double complex[::1, :] out_array
++
++    if type(A) is Dense:
++        A_mat = A.as_ndarray()
++    else:
++        A_mat = A.to_array()
++
++    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
++    out_array = out.as_ndarray()
++
++    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
++    ac_term = np2term[:, :, 0]
++    bd_term = np2term[:, :, 1]
++
++
++    for a in range(nrows):
++        for b in range(nrows-1, -1, -1):
++            if fabs(skew[a, b]) < cutoff:
++                for k in range(nrows):
++                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
++                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
++
++    # TODO: we could use openmp to speed up.
++    for a in range(nrows):
++        for b in range(nrows):
++            for c in range(nrows):
++                for d in range(nrows):
++                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
++                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
++                        elem *= (spectrum[c, a] + spectrum[d, b])
++                        if a == c:
++                            elem = elem - 0.5 * ac_term[d, b]
++                        if b == d:
++                            elem = elem - 0.5 * bd_term[a, c]
++                        out_array[a * nrows + b, c * nrows + d] = elem
++    return out
++
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
++                          double[:, ::1] skew, double cutoff):
++    """
++    Compute the contribution of A to the Bloch Redfield tensor.
++    Create it as coo pointers and return as CSR.
++    """
++    cdef size_t nrows = A.shape[0]
++    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
++    cdef double complex elem, ac_elem, bd_elem
++    cdef double complex[:,:] A_mat, ac_term, bd_term
++    cdef double dskew
++    cdef object np2term
++    cdef vector[idxint] coo_rows, coo_cols
++    cdef vector[double complex] coo_data
++
++    if type(A) is Dense:
++        A_mat = A.as_ndarray()
++    else:
++        A_mat = A.to_array()
++
++    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
++    ac_term = np2term[:, :, 0]
++    bd_term = np2term[:, :, 1]
++
++    for a in range(nrows):
++        for b in range(nrows-1, -1, -1):
++            if fabs(skew[a, b]) < cutoff:
++                for k in range(nrows):
++                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
++                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
++            elif skew[a, b] > cutoff:
++                break
++
++    # skew[a,b] = w[a] - w[b]
++    # (w[a] - w[b] - w[c] + w[d]) < cutoff
++    # w's are sorted so we can skip part of the loop.
++    for a in range(nrows):
++        for b in range(nrows):
++            d_min = 0
++            for c in range(nrows):
++                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
++                    break
++                for d in range(d_min, nrows):
++                    dskew = skew[a, b] - skew[c, d]
++                    if -dskew > cutoff:
++                        d_min = d
++                    elif fabs(dskew) < cutoff:
++                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
++                        elem *= (spectrum[c, a] + spectrum[d, b])
++                        if a == c:
++                            elem -= 0.5 * ac_term[d, b]
++                        if b == d:
++                            elem -= 0.5 * bd_term[a, c]
++                        if elem != 0:
++                            coo_rows.push_back(a * nrows + b)
++                            coo_cols.push_back(c * nrows + d)
++                            coo_data.push_back(elem)
++                    elif dskew >= cutoff:
++                        break
++
++    return csr.from_coo_pointers(
++        coo_rows.data(), coo_cols.data(), coo_data.data(),
++        nrows*nrows, nrows*nrows, coo_rows.size()
++    )
++
++
++cdef class _BlochRedfieldElement(_BaseElement):
++    """
++    Element for individual Bloch Redfield collapse term.
++
++    The tensor is computed in the ``eig_basis``, but is returned in the outside
++    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
++    on a state expected to be in that basis. It transform the state instead of
++    the tensor as it is usually faster, the state being a density matrix in
++    most cases.
++
++    Diffenrent term can share a same instance of the eigen transform tool
++    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
++    only once even when needed by multiple terms.
++    """
++    cdef readonly _EigenBasisTransform H
++    cdef readonly QobjEvo a_op
++    cdef readonly Coefficient spectra
++    cdef readonly double sec_cutoff
++    cdef readonly size_t nrows
++    cdef readonly (idxint, idxint) shape
++    cdef readonly list dims
++    cdef readonly object np_datas
++    cdef readonly double[:, ::1] skew
++    cdef readonly double[:, ::1] spectrum
++    cdef readonly bint eig_basis
++    cdef readonly TensorType tensortype
++
++    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
++                 dtype=None):
++        if isinstance(H, _EigenBasisTransform):
++            self.H = H
++        else:
++            self.H = _EigenBasisTransform(H)
++
++        self.a_op = a_op
++        self.spectra = spectra
++        self.sec_cutoff = sec_cutoff
++        self.eig_basis = eig_basis
++        self.nrows = a_op.shape[0]
++        self.dims = [a_op.dims, a_op.dims]
++
++        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
++        self.tensortype = {
++            'sparse': SPARSE,
++            'dense': DENSE,
++            'data': DATA
++        }[dtype]
++
++        # Allocate some array
++        # Let numpy manage memory
++        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
++                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
++        self.skew = self.np_datas[0]
++        self.spectrum = self.np_datas[1]
++
++    cpdef double _compute_spectrum(self, double t) except *:
++        "Compute the skew, spectrum and dw_min"
++        cdef Coefficient spec
++        cdef double dw_min = np.inf
++        eigvals = self.H.eigenvalues(t)
++
++        for col in range(0, self.nrows):
++            self.skew[col, col] = 0.
++            self.spectrum[col, col] = self.spectra(t, w=0).real
++            for row in range(col, self.nrows):
++                dw = eigvals[row] - eigvals[col]
++                self.skew[row, col] = dw
++                self.skew[col, row] = -dw
++                if dw != 0:
++                    dw_min = fmin(fabs(dw), dw_min)
++                self.spectrum[row, col] = self.spectra(t, w=dw).real
++                self.spectrum[col, row] = self.spectra(t, w=-dw).real
++        return dw_min
++
++    cdef Data _br_term(self, Data A_eig, double cutoff):
++        if self.tensortype == DENSE:
++            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
++        elif self.tensortype == SPARSE:
++            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
++        elif self.tensortype == DATA:
++            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
++        raise ValueError('Invalid tensortype')
++
++    cpdef object qobj(self, t):
++        return Qobj(self.data(t), dims=self.dims, type="super",
++                    copy=False, superrep="super")
++
++    cpdef object coeff(self, t):
++        return 1.
++
++    cpdef Data data(self, t):
++        cdef size_t i
++        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
++        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
++        BR_eig = self._br_term(A_eig, cutoff)
++        if self.eig_basis:
++            return BR_eig
++        return self.H.from_eigbasis(t, BR_eig)
++
++    cdef Data matmul_data_t(self, t, Data state, Data out=None):
++        cdef size_t i
++        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
++        cdef Data A_eig, BR_eig
++
++        if not self.eig_basis:
++            state = self.H.to_eigbasis(t, state)
++        if not self.eig_basis and out is not None:
++            out = self.H.to_eigbasis(t, out)
++        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
++        BR_eig = self._br_term(A_eig, cutoff)
++        out = _data.add(_data.matmul(BR_eig, state), out)
++        if not self.eig_basis:
++            out = self.H.from_eigbasis(t, out)
++        return out
++
++    def linear_map(self, f, anti=False):
++        return _MapElement(self, [f])
++
++    def replace_arguments(self, args, cache=None):
++        if cache is None:
++            return _BlochRedfieldElement(
++                self.H,
++                QobjEvo(self.a_op, args=args),
++                self.spectra,
++                self.sec_cutoff
++            )
++        H = None
++        for old, new in cache:
++            if old is self:
++                return new
++            if old is self.H:
++                H = new
++        if H is None:
++            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
++                                     type(self.H.oper) is CSR)
++        new = _BlochRedfieldElement(
++            H, QobjEvo(self.a_op, args=args),
++            self.spectra.replace_arguments(**args), self.sec_cutoff
++        )
++        cache.append((self, new))
++        cache.append((self.H, H))
++        return new
++
++    def __matmul__(left, right):
++        return _ProdElement(left, right, [])
++
++    def __mul__(left, right):
++        cdef _MapElement out
++        if type(left) is _BlochRedfieldElement:
++            out = _MapElement(left, [], right)
++        if type(right) is _BlochRedfieldElement:
++            out = _MapElement(right, [], left)
++        return out
+diff --git a/qutip/core/_brtools.pxd b/qutip/core/_brtools.pxd
+index ca9e3dd3..508d8460 100644
+--- a/qutip/core/_brtools.pxd
++++ b/qutip/core/_brtools.pxd
+@@ -1,32 +1,32 @@
+-#cython: language_level=3
+-from qutip.core.cy.qobjevo cimport QobjEvo
+-from qutip.core.cy.coefficient cimport Coefficient
+-from qutip.core.data cimport Data
+-
+-cdef class SpectraCoefficient(Coefficient):
+-    cdef Coefficient coeff_t
+-    cdef Coefficient coeff_w
+-    cdef double w
+-
+-cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
+-
+-cdef class _EigenBasisTransform:
+-    cdef:
+-        QobjEvo oper
+-        int size
+-        readonly bint isconstant
+-        double _t
+-        object _eigvals  # np.ndarray
+-        Data _evecs, _evecs_inv
+-
+-    cpdef object eigenvalues(self, double t)
+-    cpdef Data evecs(self, double t)
+-
+-    cpdef Data to_eigbasis(self, double t, Data fock)
+-    cpdef Data from_eigbasis(self, double t, Data eig)
+-
+-    cdef Data _inv(self, double t)
+-    cdef void _compute_eigen(self, double t) except *
+-
+-    cdef Data _S_converter(self, double t)
+-    cdef Data _S_converter_inverse(self, double t)
++#cython: language_level=3
++from qutip.core.cy.qobjevo cimport QobjEvo
++from qutip.core.cy.coefficient cimport Coefficient
++from qutip.core.data cimport Data
++
++cdef class SpectraCoefficient(Coefficient):
++    cdef Coefficient coeff_t
++    cdef Coefficient coeff_w
++    cdef double w
++
++cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
++
++cdef class _EigenBasisTransform:
++    cdef:
++        QobjEvo oper
++        int size
++        readonly bint isconstant
++        double _t
++        object _eigvals  # np.ndarray
++        Data _evecs, _evecs_inv
++
++    cpdef object eigenvalues(self, double t)
++    cpdef Data evecs(self, double t)
++
++    cpdef Data to_eigbasis(self, double t, Data fock)
++    cpdef Data from_eigbasis(self, double t, Data eig)
++
++    cdef Data _inv(self, double t)
++    cdef void _compute_eigen(self, double t) except *
++
++    cdef Data _S_converter(self, double t)
++    cdef Data _S_converter_inverse(self, double t)
+diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
+index a7e379c9..98737b0f 100644
+--- a/qutip/core/_brtools.pyx
++++ b/qutip/core/_brtools.pyx
+@@ -1,327 +1,327 @@
+-#cython: language_level=3
+-from libc.math cimport fabs, fmin
+-from libc.float cimport DBL_MAX
+-
+-cimport numpy as cnp
+-import numpy as np
+-
+-cimport cython
+-
+-from qutip.core.cy.qobjevo cimport QobjEvo
+-from qutip.core.cy.coefficient cimport Coefficient
+-from qutip.core.data cimport Data, Dense, idxint
+-import qutip.core.data as _data
+-from qutip.core import Qobj
+-from scipy.linalg cimport cython_blas as blas
+-
+-
+-__all__ = ['SpectraCoefficient']
+-
+-
+-cdef class SpectraCoefficient(Coefficient):
+-    """
+-    Change a Coefficient with `t` dependence to one with `w` dependence to use
+-    in Bloch-Redfield tensor to allow array based coefficients to be used as
+-    spectral functions.
+-    If 2 coefficients are passed, the first one is the frequence response and
+-    the second is the time response.
+-    """
+-    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
+-        self.coeff_t = coeff_t
+-        self.coeff_w = coeff_w
+-        self.w = w
+-
+-    cdef complex _call(self, double t) except *:
+-        if self.coeff_t is None:
+-            return self.coeff_w(self.w)
+-        return self.coeff_t(t) * self.coeff_w(self.w)
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
+-
+-    def replace_arguments(self, _args=None, *, w=None, **kwargs):
+-        if _args:
+-            kwargs.update(_args)
+-        if kwargs:
+-            return SpectraCoefficient(
+-                self.coeff_w.replace(**kwargs),
+-                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
+-                kwargs.get('w', w or self.w)
+-              )
+-        if w is not None:
+-            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
+-        return self
+-
+-
+-@cython.overflowcheck(True)
+-cdef size_t _mul_checked(size_t a, size_t b) except? -1:
+-    return a * b
+-
+-
+-cdef Data _apply_trans(Data original, int trans):
+-    """helper function for matmul_var_data, apply transform."""
+-    cdef Data out
+-    if trans == 0:
+-        out = original
+-    elif trans == 1:
+-        out = original.transpose()
+-    elif trans == 2:
+-        out = original.conj()
+-    elif trans == 3:
+-        out = original.adjoint()
+-    return out
+-
+-
+-cdef char _fetch_trans_code(int trans):
+-    """helper function for matmul_var_Dense, fetch the blas flag byte"""
+-    if trans == 0:
+-        return b'N'
+-    elif trans == 1:
+-        return b'T'
+-    elif trans == 3:
+-        return b'C'
+-
+-
+-cpdef Data matmul_var_data(Data left, Data right,
+-                           int transleft, int transright):
+-    """
+-    matmul which input matrices can be transposed or adjoint.
+-    out = transleft(left) @ transright(right)
+-
+-    with trans[left, right]:
+-        0 : Normal
+-        1 : Transpose
+-        2 : Conjugate
+-        3 : Adjoint
+-    """
+-    # Should this be supported in data.matmul?
+-    # A.dag() @ A is quite common.
+-    cdef int size
+-    cdef double complex beta
+-    cdef char left_code, right_code
+-    if (
+-        type(left) is Dense
+-        and type(right) is Dense
+-        and left.shape[0] == left.shape[1]
+-        and left.shape[0] == right.shape[0]
+-        and left.shape[0] == right.shape[1]
+-    ):
+-        return matmul_var_Dense(left, right, transleft, transright)
+-    left = _apply_trans(left, transleft)
+-    right = _apply_trans(right, transright)
+-    return _data.matmul(left, right)
+-
+-
+-cdef Dense matmul_var_Dense(Dense left, Dense right,
+-                            int transleft, int transright):
+-    """
+-    matmul which input matrices can be transposed or adjoint.
+-    out = transleft(left) @ transright(right)
+-
+-    with trans[left, right]:
+-       0 : Normal
+-       1 : Transpose
+-       2 : Conjugate
+-       3 : Adjoint
+-    """
+-    # blas support matmul for normal, transpose, adjoint for fortran ordered
+-    # matrices.
+-    if not (
+-        left.shape[0] == left.shape[1]
+-        and left.shape[0] == right.shape[0]
+-        and left.shape[0] == right.shape[1]
+-    ):
+-        raise ValueError("Only implemented for square operators")
+-    cdef Dense out, a, b
+-    cdef double complex alpha = 1., beta = 0.
+-    cdef int tleft, tright, size = left.shape[0]
+-
+-    # Since fortran to C equivalent to transpose, fix the codes to fortran
+-    tleft = transleft ^ (not left.fortran)
+-    tright = transright ^ (not right.fortran)
+-
+-    # blas.zgemm does not support adjoint.
+-    if tleft + tright == 5:
+-        # adjoint and conjugate, we can't transpose the output to use zgemm
+-        out = matmul_var_data(left, right, transleft-2, transright-2)
+-        return out.conj()
+-    if tleft == 2 or tright == 2:
+-        # Need a conjugate, we compute the transpose of the desired results.
+-        # A.conj @ B^op -> (B^T^op @ A.dag)^T
+-        out = _data.dense.empty(left.shape[0], right.shape[1], False)
+-        a, b = right, left
+-        tleft, tright = tright ^ 1, tleft ^ 1
+-    else:
+-        out = _data.dense.empty(left.shape[0], right.shape[1], True)
+-        a, b = left, right
+-
+-    left_code = _fetch_trans_code(tleft)
+-    right_code = _fetch_trans_code(tright)
+-    blas.zgemm(&left_code, &right_code, &size, &size, &size,
+-               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
+-               &beta, (<Dense> out).data, &size)
+-
+-    return out
+-
+-
+-class _eigen_qevo:
+-    """
+-    Callable function to represent the eigenvectors of a QobjEvo at a time
+-    ``t``.
+-    """
+-    def __init__(self, qevo):
+-        self.qevo = QobjEvo(qevo)  # Force a copy
+-        self.args = None
+-        # This is a base conversion operator, the eigen basis part of the dims
+-        # are flat.
+-        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
+-
+-    def __call__(self, t, args):
+-        if args is not self.args:
+-            self.args = args
+-            self.qevo.arguments(self.args)
+-        _, data = _data.eigs(self.qevo._call(t), True, True)
+-        return Qobj(data, copy=False, dims=self.out_dims)
+-
+-
+-cdef class _EigenBasisTransform:
+-    """
+-    For an hermitian operator, compute the eigenvalues and eigenstates and do
+-    the base change to and from that eigenbasis.
+-
+-    parameter
+-    ---------
+-    oper : QobjEvo
+-        Hermitian operator for which to compute the eigenbasis.
+-
+-    sparse : bool [False]
+-        Whether to use sparse solver for eigen decomposition.
+-    """
+-    def __init__(self, QobjEvo oper, bint sparse=False):
+-        if oper.dims[0] != oper.dims[1]:
+-            raise ValueError
+-        if type(oper(0).data) is _data.CSR and not sparse:
+-            oper = oper.to(Dense)
+-        self.oper = oper
+-        self.isconstant = oper.isconstant
+-        self.size = oper.shape[0]
+-
+-        if oper.isconstant:
+-            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
+-                                                    True, True)
+-        else:
+-            self._evecs = None
+-            self._eigvals = None
+-
+-        self._t = np.nan
+-        self._evecs_inv = None
+-
+-    def as_Qobj(self):
+-        """Make an Qobj or QobjEvo of the eigenvectors."""
+-        if self.isconstant:
+-            return Qobj(self.evecs(0), dims=self.oper.dims)
+-        else:
+-            return QobjEvo(_eigen_qevo(self.oper))
+-
+-    cdef void _compute_eigen(self, double t) except *:
+-        if self._t != t and not self.isconstant:
+-            self._t = t
+-            self._evecs_inv = None
+-            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
+-
+-    cpdef object eigenvalues(self, double t):
+-        """
+-        Return the eigenvalues at ``t``.
+-        """
+-        self._compute_eigen(t)
+-        return self._eigvals
+-
+-    cpdef Data evecs(self, double t):
+-        """
+-        Return the eigenstates at ``t``.
+-        """
+-        self._compute_eigen(t)
+-        return self._evecs
+-
+-    cdef Data _inv(self, double t):
+-        if self._evecs_inv is None:
+-            self._evecs_inv = self.evecs(t).adjoint()
+-        return self._evecs_inv
+-
+-    cdef Data _S_converter(self, double t):
+-        return _data.kron(self.evecs(t).transpose(), self._inv(t))
+-
+-    cdef Data _S_converter_inverse(self, double t):
+-        return _data.kron(self._inv(t).transpose(), self.evecs(t))
+-
+-    cpdef Data to_eigbasis(self, double t, Data fock):
+-        """
+-        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
+-        ``oper(t)`` is diagonalized.
+-        """
+-        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
+-        # Blas include A.dag @ B in one operation. We use it if we can so we
+-        # don't make unneeded copy of evecs.
+-        cdef Data temp
+-        if fock.shape[0] == self.size and fock.shape[1] == 1:
+-            return matmul_var_data(self.evecs(t), fock, 3, 0)
+-
+-        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
+-            if type(fock) is Dense and (<Dense> fock).fortran:
+-                fock = _data.column_unstack_dense(fock, self.size, True)
+-                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+-                                    self.evecs(t))
+-                fock = _data.column_stack_dense(fock, True)
+-            else:
+-                fock = _data.column_unstack(fock, self.size)
+-                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+-                                    self.evecs(t))
+-            if type(temp) is Dense:
+-                return _data.column_stack_dense(temp, True)
+-            return _data.column_stack(temp)
+-
+-        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
+-            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+-                                self.evecs(t))
+-
+-        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
+-            temp = self._S_converter_inverse(t)
+-            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
+-
+-        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
+-                         "can't guess type from shape.")
+-
+-    cpdef Data from_eigbasis(self, double t, Data eig):
+-        """
+-        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
+-        ``oper(t)`` is diagonalized to the outside basis.
+-        """
+-        cdef Data temp
+-        if eig.shape[0] == self.size and eig.shape[1] == 1:
+-            return _data.matmul(self.evecs(t), eig)
+-
+-        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
+-            if type(eig) is Dense and (<Dense> eig).fortran:
+-                eig = _data.column_unstack_dense(eig, self.size, True)
+-                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
+-                                  self.evecs(t), 0, 3)
+-                eig = _data.column_stack_dense(eig, True)
+-            else:
+-                eig = _data.column_unstack(eig, self.size)
+-                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
+-                                  self.evecs(t), 0, 3)
+-            if type(temp) is Dense:
+-                return _data.column_stack_dense(temp, True)
+-            return _data.column_stack(temp)
+-
+-        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
+-            temp = self.evecs(t)
+-            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
+-
+-        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
+-            temp = self._S_converter_inverse(t)
+-            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
+-
+-        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
+-                         "can't guess type from shape.")
++#cython: language_level=3
++from libc.math cimport fabs, fmin
++from libc.float cimport DBL_MAX
++
++cimport numpy as cnp
++import numpy as np
++
++cimport cython
++
++from qutip.core.cy.qobjevo cimport QobjEvo
++from qutip.core.cy.coefficient cimport Coefficient
++from qutip.core.data cimport Data, Dense, idxint
++import qutip.core.data as _data
++from qutip.core import Qobj
++from scipy.linalg cimport cython_blas as blas
++
++
++__all__ = ['SpectraCoefficient']
++
++
++cdef class SpectraCoefficient(Coefficient):
++    """
++    Change a Coefficient with `t` dependence to one with `w` dependence to use
++    in Bloch-Redfield tensor to allow array based coefficients to be used as
++    spectral functions.
++    If 2 coefficients are passed, the first one is the frequence response and
++    the second is the time response.
++    """
++    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
++        self.coeff_t = coeff_t
++        self.coeff_w = coeff_w
++        self.w = w
++
++    cdef complex _call(self, double t) except *:
++        if self.coeff_t is None:
++            return self.coeff_w(self.w)
++        return self.coeff_t(t) * self.coeff_w(self.w)
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
++
++    def replace_arguments(self, _args=None, *, w=None, **kwargs):
++        if _args:
++            kwargs.update(_args)
++        if kwargs:
++            return SpectraCoefficient(
++                self.coeff_w.replace(**kwargs),
++                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
++                kwargs.get('w', w or self.w)
++              )
++        if w is not None:
++            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
++        return self
++
++
++@cython.overflowcheck(True)
++cdef size_t _mul_checked(size_t a, size_t b) except? -1:
++    return a * b
++
++
++cdef Data _apply_trans(Data original, int trans):
++    """helper function for matmul_var_data, apply transform."""
++    cdef Data out
++    if trans == 0:
++        out = original
++    elif trans == 1:
++        out = original.transpose()
++    elif trans == 2:
++        out = original.conj()
++    elif trans == 3:
++        out = original.adjoint()
++    return out
++
++
++cdef char _fetch_trans_code(int trans):
++    """helper function for matmul_var_Dense, fetch the blas flag byte"""
++    if trans == 0:
++        return b'N'
++    elif trans == 1:
++        return b'T'
++    elif trans == 3:
++        return b'C'
++
++
++cpdef Data matmul_var_data(Data left, Data right,
++                           int transleft, int transright):
++    """
++    matmul which input matrices can be transposed or adjoint.
++    out = transleft(left) @ transright(right)
++
++    with trans[left, right]:
++        0 : Normal
++        1 : Transpose
++        2 : Conjugate
++        3 : Adjoint
++    """
++    # Should this be supported in data.matmul?
++    # A.dag() @ A is quite common.
++    cdef int size
++    cdef double complex beta
++    cdef char left_code, right_code
++    if (
++        type(left) is Dense
++        and type(right) is Dense
++        and left.shape[0] == left.shape[1]
++        and left.shape[0] == right.shape[0]
++        and left.shape[0] == right.shape[1]
++    ):
++        return matmul_var_Dense(left, right, transleft, transright)
++    left = _apply_trans(left, transleft)
++    right = _apply_trans(right, transright)
++    return _data.matmul(left, right)
++
++
++cdef Dense matmul_var_Dense(Dense left, Dense right,
++                            int transleft, int transright):
++    """
++    matmul which input matrices can be transposed or adjoint.
++    out = transleft(left) @ transright(right)
++
++    with trans[left, right]:
++       0 : Normal
++       1 : Transpose
++       2 : Conjugate
++       3 : Adjoint
++    """
++    # blas support matmul for normal, transpose, adjoint for fortran ordered
++    # matrices.
++    if not (
++        left.shape[0] == left.shape[1]
++        and left.shape[0] == right.shape[0]
++        and left.shape[0] == right.shape[1]
++    ):
++        raise ValueError("Only implemented for square operators")
++    cdef Dense out, a, b
++    cdef double complex alpha = 1., beta = 0.
++    cdef int tleft, tright, size = left.shape[0]
++
++    # Since fortran to C equivalent to transpose, fix the codes to fortran
++    tleft = transleft ^ (not left.fortran)
++    tright = transright ^ (not right.fortran)
++
++    # blas.zgemm does not support adjoint.
++    if tleft + tright == 5:
++        # adjoint and conjugate, we can't transpose the output to use zgemm
++        out = matmul_var_data(left, right, transleft-2, transright-2)
++        return out.conj()
++    if tleft == 2 or tright == 2:
++        # Need a conjugate, we compute the transpose of the desired results.
++        # A.conj @ B^op -> (B^T^op @ A.dag)^T
++        out = _data.dense.empty(left.shape[0], right.shape[1], False)
++        a, b = right, left
++        tleft, tright = tright ^ 1, tleft ^ 1
++    else:
++        out = _data.dense.empty(left.shape[0], right.shape[1], True)
++        a, b = left, right
++
++    left_code = _fetch_trans_code(tleft)
++    right_code = _fetch_trans_code(tright)
++    blas.zgemm(&left_code, &right_code, &size, &size, &size,
++               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
++               &beta, (<Dense> out).data, &size)
++
++    return out
++
++
++class _eigen_qevo:
++    """
++    Callable function to represent the eigenvectors of a QobjEvo at a time
++    ``t``.
++    """
++    def __init__(self, qevo):
++        self.qevo = QobjEvo(qevo)  # Force a copy
++        self.args = None
++        # This is a base conversion operator, the eigen basis part of the dims
++        # are flat.
++        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
++
++    def __call__(self, t, args):
++        if args is not self.args:
++            self.args = args
++            self.qevo.arguments(self.args)
++        _, data = _data.eigs(self.qevo._call(t), True, True)
++        return Qobj(data, copy=False, dims=self.out_dims)
++
++
++cdef class _EigenBasisTransform:
++    """
++    For an hermitian operator, compute the eigenvalues and eigenstates and do
++    the base change to and from that eigenbasis.
++
++    parameter
++    ---------
++    oper : QobjEvo
++        Hermitian operator for which to compute the eigenbasis.
++
++    sparse : bool [False]
++        Whether to use sparse solver for eigen decomposition.
++    """
++    def __init__(self, QobjEvo oper, bint sparse=False):
++        if oper.dims[0] != oper.dims[1]:
++            raise ValueError
++        if type(oper(0).data) is _data.CSR and not sparse:
++            oper = oper.to(Dense)
++        self.oper = oper
++        self.isconstant = oper.isconstant
++        self.size = oper.shape[0]
++
++        if oper.isconstant:
++            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
++                                                    True, True)
++        else:
++            self._evecs = None
++            self._eigvals = None
++
++        self._t = np.nan
++        self._evecs_inv = None
++
++    def as_Qobj(self):
++        """Make an Qobj or QobjEvo of the eigenvectors."""
++        if self.isconstant:
++            return Qobj(self.evecs(0), dims=self.oper.dims)
++        else:
++            return QobjEvo(_eigen_qevo(self.oper))
++
++    cdef void _compute_eigen(self, double t) except *:
++        if self._t != t and not self.isconstant:
++            self._t = t
++            self._evecs_inv = None
++            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
++
++    cpdef object eigenvalues(self, double t):
++        """
++        Return the eigenvalues at ``t``.
++        """
++        self._compute_eigen(t)
++        return self._eigvals
++
++    cpdef Data evecs(self, double t):
++        """
++        Return the eigenstates at ``t``.
++        """
++        self._compute_eigen(t)
++        return self._evecs
++
++    cdef Data _inv(self, double t):
++        if self._evecs_inv is None:
++            self._evecs_inv = self.evecs(t).adjoint()
++        return self._evecs_inv
++
++    cdef Data _S_converter(self, double t):
++        return _data.kron(self.evecs(t).transpose(), self._inv(t))
++
++    cdef Data _S_converter_inverse(self, double t):
++        return _data.kron(self._inv(t).transpose(), self.evecs(t))
++
++    cpdef Data to_eigbasis(self, double t, Data fock):
++        """
++        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
++        ``oper(t)`` is diagonalized.
++        """
++        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
++        # Blas include A.dag @ B in one operation. We use it if we can so we
++        # don't make unneeded copy of evecs.
++        cdef Data temp
++        if fock.shape[0] == self.size and fock.shape[1] == 1:
++            return matmul_var_data(self.evecs(t), fock, 3, 0)
++
++        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
++            if type(fock) is Dense and (<Dense> fock).fortran:
++                fock = _data.column_unstack_dense(fock, self.size, True)
++                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
++                                    self.evecs(t))
++                fock = _data.column_stack_dense(fock, True)
++            else:
++                fock = _data.column_unstack(fock, self.size)
++                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
++                                    self.evecs(t))
++            if type(temp) is Dense:
++                return _data.column_stack_dense(temp, True)
++            return _data.column_stack(temp)
++
++        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
++            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
++                                self.evecs(t))
++
++        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
++            temp = self._S_converter_inverse(t)
++            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
++
++        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
++                         "can't guess type from shape.")
++
++    cpdef Data from_eigbasis(self, double t, Data eig):
++        """
++        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
++        ``oper(t)`` is diagonalized to the outside basis.
++        """
++        cdef Data temp
++        if eig.shape[0] == self.size and eig.shape[1] == 1:
++            return _data.matmul(self.evecs(t), eig)
++
++        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
++            if type(eig) is Dense and (<Dense> eig).fortran:
++                eig = _data.column_unstack_dense(eig, self.size, True)
++                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
++                                  self.evecs(t), 0, 3)
++                eig = _data.column_stack_dense(eig, True)
++            else:
++                eig = _data.column_unstack(eig, self.size)
++                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
++                                  self.evecs(t), 0, 3)
++            if type(temp) is Dense:
++                return _data.column_stack_dense(temp, True)
++            return _data.column_stack(temp)
++
++        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
++            temp = self.evecs(t)
++            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
++
++        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
++            temp = self._S_converter_inverse(t)
++            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
++
++        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
++                         "can't guess type from shape.")
+diff --git a/qutip/core/blochredfield.py b/qutip/core/blochredfield.py
+index e23f6af9..7a3c6d25 100644
+--- a/qutip/core/blochredfield.py
++++ b/qutip/core/blochredfield.py
+@@ -1,188 +1,188 @@
+-import os
+-import inspect
+-import numpy as np
+-from qutip.settings import settings as qset
+-
+-from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
+-from ._brtools import SpectraCoefficient, _EigenBasisTransform
+-from .cy.coefficient import InterCoefficient, Coefficient
+-from ._brtensor import _BlochRedfieldElement
+-
+-
+-__all__ = ['bloch_redfield_tensor', 'brterm']
+-
+-
+-def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
+-                          fock_basis=False, sparse_eigensolver=False,
+-                          br_dtype='sparse'):
+-    """
+-    Calculates the Bloch-Redfield tensor for a system given
+-    a set of operators and corresponding spectral functions that describes the
+-    system's coupling to its environment.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+-        System Hamiltonian.
+-
+-    a_ops : list of (a_op, spectra)
+-        Nested list of system operators that couple to the environment,
+-        and the corresponding bath spectra.
+-
+-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+-            The operator coupling to the environment. Must be hermitian.
+-
+-        spectra : :class:`Coefficient`, func, str
+-            The corresponding bath spectra.
+-            Can be a :class:`~Coefficient` using an 'w' args, a function of the
+-            frequency or a string. The :class:`SpectraCoefficient` can be used for
+-            array based coefficient.
+-            The spectra can depend on ``t`` if the corresponding
+-            ``a_op`` is a :class:`QobjEvo`.
+-
+-        Example:
+-
+-        .. code-block::
+-
+-            a_ops = [
+-                (a+a.dag(), ('w>0', args={"w": 0})),
+-                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
+-                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
+-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+-            ]
+-
+-
+-    c_ops : list
+-        List of system collapse operators.
+-
+-    sec_cutoff : float {0.1}
+-        Cutoff for secular approximation. Use ``-1`` if secular approximation
+-        is not used when evaluating bath-coupling terms.
+-
+-    fock_basis : bool {False}
+-        Whether to return the tensor in the input basis or the diagonalized
+-        basis.
+-
+-    sparse_eigensolver : bool {False}
+-        Whether to use the sparse eigensolver
+-
+-    br_dtype : ['sparse', 'dense', 'data']
+-        Which data type to use when computing the brtensor.
+-        With a cutoff 'sparse' is usually the most efficient.
+-
+-    Returns
+-    -------
+-    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
+-        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
+-        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
+-        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
+-        column.
+-    """
+-    R = liouvillian(H, c_ops)
+-    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
+-
+-    if fock_basis:
+-        for (a_op, spectra) in a_ops:
+-            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
+-                        br_dtype=br_dtype)
+-        return R
+-    else:
+-        # When the Hamiltonian is time-dependent, the transformation of `L` to
+-        # eigenbasis is not optimized.
+-        if isinstance(R, QobjEvo):
+-            # The `sprepost` will be computed 2 times for each parts of `R`.
+-            # Compressing the QobjEvo will lower the number of parts.
+-            R.compress()
+-        evec = H_transform.as_Qobj()
+-        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
+-        for (a_op, spectra) in a_ops:
+-            R += brterm(H_transform, a_op, spectra, sec_cutoff,
+-                        False, br_dtype=br_dtype)[0]
+-        return R, H_transform.as_Qobj()
+-
+-
+-def brterm(H, a_op, spectra, sec_cutoff=0.1,
+-           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
+-    """
+-    Calculates the contribution of one coupling operator to the Bloch-Redfield
+-    tensor.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+-        System Hamiltonian.
+-
+-    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+-        The operator coupling to the environment. Must be hermitian.
+-
+-    spectra : :class:`Coefficient`, func, str
+-        The corresponding bath spectra.
+-        Can be a :class:`~Coefficient` using an 'w' args, a function of the
+-        frequency or a string. The :class:`SpectraCoefficient` can be used for
+-        array based coefficient.
+-        The spectra can depend on ``t`` if the corresponding
+-        ``a_op`` is a :class:`QobjEvo`.
+-
+-        Example:
+-
+-            coefficient('w>0', args={"w": 0})
+-            SpectraCoefficient(coefficient(array, tlist=...))
+-
+-    sec_cutoff : float {0.1}
+-        Cutoff for secular approximation. Use ``-1`` if secular approximation
+-        is not used when evaluating bath-coupling terms.
+-
+-    fock_basis : bool {False}
+-        Whether to return the tensor in the input basis or the diagonalized
+-        basis.
+-
+-    sparse_eigensolver : bool {False}
+-        Whether to use the sparse eigensolver on the Hamiltonian.
+-
+-    br_dtype : ['sparse', 'dense', 'data']
+-        Which data type to use when computing the brtensor.
+-        With a cutoff 'sparse' is usually the most efficient.
+-
+-    Returns
+-    -------
+-    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
+-        If ``fock_basis``, return the Bloch Redfield tensor in the outside
+-        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
+-        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
+-        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
+-        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
+-    """
+-    if isinstance(H, _EigenBasisTransform):
+-        Hdiag = H
+-    else:
+-        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
+-
+-    # convert spectra to Coefficient
+-    if isinstance(spectra, str):
+-        spectra = coefficient(spectra, args={'w': 0})
+-    elif isinstance(spectra, InterCoefficient):
+-        spectra = SpectraCoefficient(spectra)
+-    elif isinstance(spectra, Coefficient):
+-        pass
+-    elif callable(spectra):
+-        sig = inspect.signature(spectra)
+-        if tuple(sig.parameters.keys()) == ("w",):
+-            spectra = SpectraCoefficient(coefficient(spectra))
+-        else:
+-            spectra = coefficient(spectra, args={'w': 0})
+-    else:
+-        raise TypeError("a_ops's spectra not known")
+-
+-    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
+-    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
+-                sec_cutoff, not fock_basis, dtype=br_dtype))
+-
+-    if (
+-        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
+-         or isinstance(H, Qobj))
+-        and isinstance(a_op, Qobj)
+-    ):
+-        R = R(0)
+-    return R if fock_basis else (R, Hdiag.as_Qobj())
++import os
++import inspect
++import numpy as np
++from qutip.settings import settings as qset
++
++from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
++from ._brtools import SpectraCoefficient, _EigenBasisTransform
++from .cy.coefficient import InterCoefficient, Coefficient
++from ._brtensor import _BlochRedfieldElement
++
++
++__all__ = ['bloch_redfield_tensor', 'brterm']
++
++
++def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
++                          fock_basis=False, sparse_eigensolver=False,
++                          br_dtype='sparse'):
++    """
++    Calculates the Bloch-Redfield tensor for a system given
++    a set of operators and corresponding spectral functions that describes the
++    system's coupling to its environment.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
++        System Hamiltonian.
++
++    a_ops : list of (a_op, spectra)
++        Nested list of system operators that couple to the environment,
++        and the corresponding bath spectra.
++
++        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
++            The operator coupling to the environment. Must be hermitian.
++
++        spectra : :class:`Coefficient`, func, str
++            The corresponding bath spectra.
++            Can be a :class:`~Coefficient` using an 'w' args, a function of the
++            frequency or a string. The :class:`SpectraCoefficient` can be used for
++            array based coefficient.
++            The spectra can depend on ``t`` if the corresponding
++            ``a_op`` is a :class:`QobjEvo`.
++
++        Example:
++
++        .. code-block::
++
++            a_ops = [
++                (a+a.dag(), ('w>0', args={"w": 0})),
++                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
++                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
++                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
++            ]
++
++
++    c_ops : list
++        List of system collapse operators.
++
++    sec_cutoff : float {0.1}
++        Cutoff for secular approximation. Use ``-1`` if secular approximation
++        is not used when evaluating bath-coupling terms.
++
++    fock_basis : bool {False}
++        Whether to return the tensor in the input basis or the diagonalized
++        basis.
++
++    sparse_eigensolver : bool {False}
++        Whether to use the sparse eigensolver
++
++    br_dtype : ['sparse', 'dense', 'data']
++        Which data type to use when computing the brtensor.
++        With a cutoff 'sparse' is usually the most efficient.
++
++    Returns
++    -------
++    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
++        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
++        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
++        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
++        column.
++    """
++    R = liouvillian(H, c_ops)
++    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
++
++    if fock_basis:
++        for (a_op, spectra) in a_ops:
++            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
++                        br_dtype=br_dtype)
++        return R
++    else:
++        # When the Hamiltonian is time-dependent, the transformation of `L` to
++        # eigenbasis is not optimized.
++        if isinstance(R, QobjEvo):
++            # The `sprepost` will be computed 2 times for each parts of `R`.
++            # Compressing the QobjEvo will lower the number of parts.
++            R.compress()
++        evec = H_transform.as_Qobj()
++        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
++        for (a_op, spectra) in a_ops:
++            R += brterm(H_transform, a_op, spectra, sec_cutoff,
++                        False, br_dtype=br_dtype)[0]
++        return R, H_transform.as_Qobj()
++
++
++def brterm(H, a_op, spectra, sec_cutoff=0.1,
++           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
++    """
++    Calculates the contribution of one coupling operator to the Bloch-Redfield
++    tensor.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
++        System Hamiltonian.
++
++    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
++        The operator coupling to the environment. Must be hermitian.
++
++    spectra : :class:`Coefficient`, func, str
++        The corresponding bath spectra.
++        Can be a :class:`~Coefficient` using an 'w' args, a function of the
++        frequency or a string. The :class:`SpectraCoefficient` can be used for
++        array based coefficient.
++        The spectra can depend on ``t`` if the corresponding
++        ``a_op`` is a :class:`QobjEvo`.
++
++        Example:
++
++            coefficient('w>0', args={"w": 0})
++            SpectraCoefficient(coefficient(array, tlist=...))
++
++    sec_cutoff : float {0.1}
++        Cutoff for secular approximation. Use ``-1`` if secular approximation
++        is not used when evaluating bath-coupling terms.
++
++    fock_basis : bool {False}
++        Whether to return the tensor in the input basis or the diagonalized
++        basis.
++
++    sparse_eigensolver : bool {False}
++        Whether to use the sparse eigensolver on the Hamiltonian.
++
++    br_dtype : ['sparse', 'dense', 'data']
++        Which data type to use when computing the brtensor.
++        With a cutoff 'sparse' is usually the most efficient.
++
++    Returns
++    -------
++    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
++        If ``fock_basis``, return the Bloch Redfield tensor in the outside
++        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
++        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
++        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
++        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
++    """
++    if isinstance(H, _EigenBasisTransform):
++        Hdiag = H
++    else:
++        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
++
++    # convert spectra to Coefficient
++    if isinstance(spectra, str):
++        spectra = coefficient(spectra, args={'w': 0})
++    elif isinstance(spectra, InterCoefficient):
++        spectra = SpectraCoefficient(spectra)
++    elif isinstance(spectra, Coefficient):
++        pass
++    elif callable(spectra):
++        sig = inspect.signature(spectra)
++        if tuple(sig.parameters.keys()) == ("w",):
++            spectra = SpectraCoefficient(coefficient(spectra))
++        else:
++            spectra = coefficient(spectra, args={'w': 0})
++    else:
++        raise TypeError("a_ops's spectra not known")
++
++    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
++    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
++                sec_cutoff, not fock_basis, dtype=br_dtype))
++
++    if (
++        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
++         or isinstance(H, Qobj))
++        and isinstance(a_op, Qobj)
++    ):
++        R = R(0)
++    return R if fock_basis else (R, Hdiag.as_Qobj())
+diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
+index d029461f..a738e630 100644
+--- a/qutip/core/coefficient.py
++++ b/qutip/core/coefficient.py
+@@ -1,776 +1,776 @@
+-import numpy as np
+-import scipy
+-import scipy.interpolate
+-import os
+-import sys
+-import re
+-import dis
+-import hashlib
+-import glob
+-import importlib
+-import warnings
+-import numbers
+-from contextlib import contextmanager
+-from collections import defaultdict
+-from setuptools import setup, Extension
+-try:
+-    from Cython.Build import cythonize
+-    import filelock
+-except ImportError:
+-    pass
+-
+-from ..settings import settings as qset
+-from .options import QutipOptions
+-from .data import Data
+-from .cy.coefficient import (
+-    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
+-    ConjCoefficient, NormCoefficient
+-)
+-
+-
+-__all__ = ["coefficient", "CompilationOptions", "Coefficient",
+-           "clean_compiled_coefficient"]
+-
+-
+-class StringParsingWarning(Warning):
+-    pass
+-
+-
+-def _return(base, **kwargs):
+-    return base
+-
+-
+-# The `coefficient` function is dispatcher for the type of the `base` to the
+-# function that created the `Coefficient` object. `coefficient_builders` stores
+-# the map `type -> function(base, **kw)`. Optional module can add their
+-# `Coefficient` specializations here.
+-coefficient_builders = {
+-    Coefficient: _return,
+-    np.ndarray: InterCoefficient,
+-    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
+-    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
+-}
+-
+-
+-def coefficient(base, *, tlist=None, args={}, args_ctypes={},
+-                order=3, compile_opt=None, function_style=None,
+-                boundary_conditions=None, **kwargs):
+-    """Build ``Coefficient`` for time dependent systems:
+-
+-    ```
+-    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
+-    ```
+-
+-    The coefficients can be a function, a string or a numpy array. Other
+-    packages may add support for other kind of coefficients.
+-
+-    For function based coefficients, the function signature must be either:
+-
+-    * ``f(t, ...)`` where the other arguments are supplied as ordinary
+-      "pythonic" arguments (e.g. ``f(t, w, a=5))
+-    * ``f(t, args)`` where the arguments are supplied in a "dict" named
+-      ``args``
+-
+-    By default the signature style is controlled by the
+-    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
+-    may be overriden here by specifying either ``function_style="pythonic"``
+-    or ``function_style="dict"``.
+-
+-    *Examples*
+-        # pythonic style function signature
+-
+-        def f1_t(t, w):
+-            return np.exp(-1j * t * w)
+-
+-        coeff1 = coefficient(f1_t, args={"w": 1.})
+-
+-        # dict style function signature
+-
+-        def f2_t(t, args):
+-            return np.exp(-1j * t * args["w"])
+-
+-        coeff2 = coefficient(f2_t, args={"w": 1.})
+-
+-    For string based coeffients, the string must be a compilable python code
+-    resulting in a complex. The following symbols are defined:
+-        sin cos tan asin acos atan pi
+-        sinh cosh tanh asinh acosh atanh
+-        exp log log10 erf zerf sqrt
+-        real imag conj abs norm arg proj
+-        numpy as np,
+-        scipy.special as spe (python interface)
+-        and cython_special (scipy cython interface)
+-
+-    *Examples*
+-        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
+-    'args' is needed for string coefficient at compilation.
+-    It is a dict of (name:object). The keys must be a valid variables string.
+-
+-    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
+-
+-    For numpy array format, the array must be an 1d of dtype float or complex.
+-    A list of times (float64) at which the coeffients must be given (tlist).
+-    The coeffients array must have the same len as the tlist.
+-    The time of the tlist do not need to be equidistant, but must be sorted.
+-    By default, a cubic spline interpolation will be used to compute the
+-    coefficient at time t. The keyword ``order`` sets the order of the
+-    interpolation. When ``order = 0``, the interpolation is step function that
+-    evaluates to the most recent value.
+-
+-    *Examples*
+-        tlist = np.logspace(-5,0,100)
+-        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
+-
+-    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
+-    also converted to interpolated coefficients (the same kind of coefficient
+-    created from ``ndarray``). Other interpolation methods from
+-    scipy are converted to a function-based coefficient (the same kind of
+-    coefficient created from callables).
+-
+-    Parameters
+-    ----------
+-    base : object
+-        Base object to make into a Coefficient.
+-
+-    args : dict, optional
+-        Dictionary of arguments to pass to the function or string coefficient.
+-
+-    order : int, default=3
+-        Order of the spline for array based coefficient.
+-
+-    tlist : iterable, optional
+-        Times for each element of an array based coefficient.
+-
+-    function_style : str, ["dict", "pythonic", None]
+-        Function signature of function based coefficients.
+-
+-    args_ctypes : dict, optional
+-        C type for the args when compiling array based coefficients.
+-
+-    compile_opt : CompilationOptions, optional
+-        Sets of options for the compilation of string based coefficients.
+-
+-    boundary_conditions: 2-tupule, str or None, optional
+-        Specify boundary conditions for spline interpolation.
+-
+-    **kwargs
+-        Extra arguments to pass the the coefficients.
+-    """
+-    kwargs.update({
+-        "tlist": tlist,
+-        'args': args,
+-        'args_ctypes': args_ctypes,
+-        'order': order,
+-        'compile_opt': compile_opt,
+-        'function_style': function_style,
+-        'boundary_conditions': boundary_conditions
+-    })
+-
+-    for type_ in coefficient_builders:
+-        if isinstance(base, type_):
+-            return coefficient_builders[type_](base, **kwargs)
+-
+-    if callable(base):
+-        op = FunctionCoefficient(base, args.copy(), style=function_style)
+-        if not isinstance(op(0), numbers.Number):
+-            raise TypeError("The coefficient function must return a number")
+-        return op
+-    else:
+-        raise ValueError("coefficient format not understood")
+-
+-
+-def norm(coeff):
+-    """ return a Coefficient with is the norm: |c|^2.
+-    """
+-    return NormCoefficient(coeff)
+-
+-
+-def conj(coeff):
+-    """ return a Coefficient with is the conjugate.
+-    """
+-    return ConjCoefficient(coeff)
+-
+-
+-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
+-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-class CompilationOptions(QutipOptions):
+-    """
+-    Compilation options:
+-
+-    use_cython: bool
+-        Whether to compile strings as cython code or use python's ``exec``.
+-
+-    try_parse: bool [True]
+-        Whether to try parsing the string for reuse and static typing.
+-
+-    static_types : bool [True]
+-        Whether to use C types for constant and args.
+-
+-    accept_int : None, bool
+-        Whether to use the type ``int`` for integer constants and args or
+-        upgrade it to ``float`` or ``complex``.
+-        If `None`, it will only use ``int`` when subscription is found in the
+-        code.
+-
+-    accept_float : bool
+-        Whether to use the type ``float`` or upgrade them to ``complex``.
+-
+-    recompile : bool
+-        Do not use previously made files but build a new one.
+-
+-    compiler_flags : str
+-        Flags to pass to the compiler, ex: "-Wall -O3"...
+-        Flags not matching your comiler and OS may cause compilation to fail.
+-        Use "recompile=True", when trying to if the string pattern was
+-        previously used.
+-
+-    link_flags : str
+-        Libraries to link to pass to the compiler. They can not be used to add
+-        function to the string coefficient.
+-
+-    extra_import : str
+-        Cython code to add at the head of the file. Can be used to add extra
+-        import or cimport code, ex:
+-        extra_import="from scipy.linalg import det"
+-        extra_import="from qutip.core.data cimport CSR"
+-
+-    clean_on_error : bool [True]
+-        When writing a cython file that cannot be imported, erase it.
+-    """
+-    _link_flags = ""
+-    _compiler_flags = ""
+-    if sys.platform == 'win32':
+-        _compiler_flags = ''
+-    elif sys.platform == 'darwin':
+-        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
+-        _link_flags += '-mmacosx-version-min=10.9'
+-    else:
+-        _compiler_flags = '-w -O3 -funroll-loops'
+-
+-    try:
+-        import cython
+-        import filelock
+-        _use_cython = True
+-    except ImportError:
+-        _use_cython = False
+-
+-    _options = {
+-        "use_cython": _use_cython,
+-        "try_parse": True,
+-        "static_types": True,
+-        "accept_int": None,
+-        "accept_float": True,
+-        "recompile": False,
+-        "compiler_flags": _compiler_flags,
+-        "link_flags": _link_flags,
+-        "extra_import": "",
+-        "clean_on_error": True,
+-    }
+-    _settings_name = "compile"
+-
+-
+-# Create the default instance in settings.
+-qset.compile = CompilationOptions()
+-
+-
+-# Version number of the Coefficient
+-COEFF_VERSION = "1.1"
+-
+-try:
+-    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
+-    qset.coeffroot = root
+-except OSError:
+-    qset.coeffroot = "."
+-
+-
+-def clean_compiled_coefficient(all=False):
+-    """
+-    Remove previouly compiled string Coefficient.
+-
+-    Parameter:
+-    ----------
+-    all: bool
+-        If not `all` will remove only previous version.
+-    """
+-    import glob
+-    import shutil
+-    tmproot = qset.tmproot
+-    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
+-    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
+-    for folder in folders:
+-        if all or folder != root:
+-            shutil.rmtree(folder)
+-    # Recreate the empty folder.
+-    qset.coeffroot = qset.coeffroot
+-
+-
+-def proj(x):
+-    if np.isfinite(x):
+-        return (x)
+-    else:
+-        return np.inf + 0j * np.imag(x)
+-
+-
+-str_env = {
+-    "sin": np.sin,
+-    "cos": np.cos,
+-    "tan": np.tan,
+-    "asin": np.arcsin,
+-    "acos": np.arccos,
+-    "atan": np.arctan,
+-    "pi": np.pi,
+-    "sinh": np.sinh,
+-    "cosh": np.cosh,
+-    "tanh": np.tanh,
+-    "asinh": np.arcsinh,
+-    "acosh": np.arccosh,
+-    "atanh": np.arctanh,
+-    "exp": np.exp,
+-    "log": np.log,
+-    "log10": np.log10,
+-    "erf": scipy.special.erf,
+-    "zerf": scipy.special.erf,
+-    "sqrt": np.sqrt,
+-    "real": np.real,
+-    "imag": np.imag,
+-    "conj": np.conj,
+-    "abs": np.abs,
+-    "norm": lambda x: np.abs(x)**2,
+-    "arg": np.angle,
+-    "proj": proj,
+-    "np": np,
+-    "spe": scipy.special}
+-
+-
+-def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
+-    """
+-    Entry point for string based coefficients
+-    - Test if the string is valid
+-    - Parse: "cos(a*t)" and "cos( w1 * t )"
+-        should be recognised as the same compiled object.
+-    - Verify if already compiled and compile if not
+-    """
+-    # First, a sanity check before thinking of compiling
+-    if compile_opt is None:
+-        compile_opt = qset.compile
+-    if not compile_opt['extra_import']:
+-        try:
+-            env = {"t": 0}
+-            env.update(args)
+-            exec(base, str_env, env)
+-        except Exception as err:
+-            raise Exception("Invalid string coefficient") from err
+-    coeff = None
+-    # Do we compile?
+-    if not compile_opt['use_cython']:
+-        return StrFunctionCoefficient(base, args)
+-    # Parsing tries to make the code in common pattern
+-    parsed, variables, constants, raw = try_parse(base, args,
+-                                                  args_ctypes, compile_opt)
+-    # Once parsed, the code should be unique enough to get a filename
+-    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
+-    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
+-    # See if it already exist and import it.
+-    if not compile_opt['recompile']:
+-        coeff = try_import(file_name, parsed)
+-
+-    if not coeff and qset.coeff_write_ok:
+-        # Previously compiled coefficient not available: create the cython code
+-        code = make_cy_code(parsed, variables, constants,
+-                            raw, compile_opt)
+-        try :
+-            coeff = compile_code(code, file_name, parsed, compile_opt)
+-        except PermissionError:
+-            pass
+-    if coeff is None:
+-        # We don't use cython or compilation failed
+-        return StrFunctionCoefficient(base, args)
+-    keys = [key for _, key, _ in variables]
+-    const = [fromstr(val) for _, val, _ in constants]
+-    return coeff(base, keys, const, args)
+-
+-
+-coefficient_builders[str] = coeff_from_str
+-
+-
+-def try_import(file_name, parsed_in):
+-    """ Import the compiled coefficient if existing and check for
+-    name collision.
+-    """
+-    try:
+-        mod = importlib.import_module(file_name)
+-    except ModuleNotFoundError:
+-        # Coefficient does not exist, to compile as file_name
+-        return None
+-
+-    if mod.parsed_code == parsed_in:
+-        # Coefficient found!
+-        return mod.StrCoefficient
+-    else:
+-        raise ValueError("string hash collision, change the string "
+-                         "or clean files in qutip.settings.coeffroot")
+-
+-
+-def make_cy_code(code, variables, constants, raw, compile_opt):
+-    """
+-    Generate the code for the string coefficients.
+-    """
+-    cdef_cte = ""
+-    init_cte = ""
+-    copy_cte = ""
+-    for i, (name, val, ctype) in enumerate(constants):
+-        cdef_cte += "        {} {}\n".format(ctype, name[5:])
+-        copy_cte += "        out.{} = {}\n".format(name[5:], name)
+-        init_cte += "        {} = cte[{}]\n".format(name, i)
+-    cdef_var = ""
+-    init_var = ""
+-    init_arg = ""
+-    replace_var = ""
+-    call_var = ""
+-    copy_var = ""
+-    for i, (name, val, ctype) in enumerate(variables):
+-        cdef_var += "        str key{}\n".format(i)
+-        cdef_var += "        {} {}\n".format(ctype, name[5:])
+-        copy_var += "        out.key{} = self.key{}\n".format(i, i)
+-        copy_var += "        out.{} = {}\n".format(name[5:], name)
+-        if not raw:
+-            init_var += "        self.key{} = var[{}]\n".format(i, i)
+-        else:
+-            init_var += "        self.key{} = '{}'\n".format(i, val)
+-        init_arg += "        {} = args[self.key{}]\n".format(name, i)
+-        replace_var += "            if self.key{} in kwargs:\n".format(i)
+-        replace_var += ("                out.{}"
+-                        " = kwargs[self.key{}]\n".format(name[5:], i))
+-        if raw:
+-            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
+-
+-    code = f"""#cython: language_level=3
+-# This file is generated automatically by QuTiP.
+-
+-import numpy as np
+-import scipy.special as spe
+-from scipy.special cimport cython_special
+-cimport cython
+-from qutip.core.cy.coefficient cimport Coefficient
+-from qutip.core.cy.math cimport erf, zerf
+-from qutip.core.cy.complex_math cimport *
+-from qutip.core.data cimport Data
+-cdef double pi = 3.14159265358979323
+-{compile_opt['extra_import']}
+-
+-parsed_code = "{code}"
+-
+-@cython.auto_pickle(True)
+-cdef class StrCoefficient(Coefficient):
+-    \"\"\"
+-    String compiled as a :obj:`Coefficient` using cython.
+-    \"\"\"
+-    cdef:
+-        str codeString
+-{cdef_cte}{cdef_var}
+-
+-    def __init__(self, base, var, cte, args):
+-        self.codeString = base
+-{init_cte}{init_var}{init_arg}
+-
+-    cpdef Coefficient copy(self):
+-        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
+-        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
+-        out.codeString = self.codeString
+-{copy_cte}{copy_var}
+-        return out
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        \"\"\"
+-        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
+-        built from 'str' or a python function. Or a the :obj:`Coefficient`
+-        itself if the :obj:`Coefficient` does not use arguments. New arguments
+-        can be passed as a dict or as keywords.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        \"\"\"
+-        cdef StrCoefficient out
+-
+-        if _args:
+-            kwargs.update(_args)
+-        if kwargs:
+-            out = self.copy()
+-{replace_var}
+-            return out
+-        return self
+-
+-    @cython.initializedcheck(False)
+-    @cython.cdivision(True)
+-    cdef complex _call(self, double t) except *:
+-{call_var}        return {code}
+-"""
+-    return code
+-
+-
+-def compile_code(code, file_name, parsed, c_opt):
+-    pwd = os.getcwd()
+-    os.chdir(qset.coeffroot)
+-    # Files with the same name, but differents extension than the pyx file, are
+-    # erased during cythonization process, breaking filelock.
+-    # Adding a prefix make them safe to use.
+-    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
+-    try:
+-        lock.acquire(timeout=0)
+-        for file in glob.glob(file_name + "*"):
+-            os.remove(file)
+-        file_ = open(file_name + ".pyx", "w")
+-        file_.writelines(code)
+-        file_.close()
+-        oldargs = sys.argv
+-        try:
+-            sys.argv = ["setup.py", "build_ext", "--inplace"]
+-            coeff_file = Extension(
+-                file_name,
+-                sources=[file_name + ".pyx"],
+-                extra_compile_args=c_opt['compiler_flags'].split(),
+-                extra_link_args=c_opt['link_flags'].split(),
+-                include_dirs=[np.get_include()],
+-                language='c++'
+-            )
+-            ext_modules = cythonize(coeff_file, force=True)
+-            setup(ext_modules=ext_modules)
+-        except Exception as e:
+-            if c_opt['clean_on_error']:
+-                for file in glob.glob(file_name + "*"):
+-                    os.remove(file)
+-            raise Exception("Could not compile") from e
+-        finally:
+-            sys.argv = oldargs
+-    except filelock.Timeout:
+-        with lock:
+-            # We wait for the lock to be released and then retry the import.
+-            pass
+-    finally:
+-        lock.release()
+-        os.chdir(pwd)
+-    return try_import(file_name, parsed)
+-
+-
+-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
+-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-# Parsing here is extracting constants and args name to replace them with
+-# attribute of the Coefficient so similar string like:
+-# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
+-# are all reconized as the same compiled object and only compiled once.
+-# Weakness:
+-#   typing: "1" and "1j" or the type of args ("w1") make different object
+-#   complex: "1+1j" is seens as cte(double) + cte(complex)
+-#   negative: "-1" is not seens as a constant but "- constant"
+-#
+-# int and double can be seens as complex with flags in CompilationOptions
+-
+-def fromstr(base):
+-    """Read a varibles in a string"""
+-    ls = {}
+-    exec("out = " + base, {}, ls)
+-    return ls["out"]
+-
+-
+-typeCodes = {
+-    "Data": "_datalayer",
+-    "complex": "_cpl",
+-    "double": "_dbl",
+-    "int": "_int",
+-    "str": "_str",
+-    "object": "_obj"
+-}
+-
+-
+-def compileType(value):
+-    """Obtain the index of typeCodes that correspond to the value
+-    4.5 -> 'double'..."""
+-    if isinstance(value, Data):
+-        ctype = "Data"
+-    elif isinstance(value, numbers.Integral):
+-        ctype = "int"
+-    elif isinstance(value, numbers.Real):
+-        ctype = "double"
+-    elif isinstance(value, numbers.Complex):
+-        ctype = "complex"
+-    elif isinstance(value, str):
+-        ctype = "str"
+-    else:
+-        ctype = "object"
+-    return ctype
+-
+-
+-def find_type_from_str(chars):
+-    """ '1j' -> complex """
+-    try:
+-        lc = {}
+-        exec("out = " + chars, {}, lc)
+-        return compileType(lc["out"])
+-    except Exception:
+-        return None
+-
+-
+-def fix_type(ctype, accept_int, accept_float):
+-    """int and double could be complex to limit the number of compiled object.
+-    change the types is we choose not to support all.
+-    """
+-    if ctype == "int" and not accept_int:
+-        ctype = "double"
+-    if ctype == "double" and not accept_float:
+-        ctype = "complex"
+-    return ctype
+-
+-
+-def extract_constant(code):
+-    """Look for floating and complex constants and replace them with variable.
+-    """
+-    code = " " + code + " "
+-    contants = []
+-    code = extract_cte_pattern(code, contants,
+-                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
+-    code = extract_cte_pattern(code, contants,
+-                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
+-    code = extract_cte_pattern(code, contants,
+-                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
+-    code = extract_cte_pattern(code, contants,
+-                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
+-    return code, contants
+-
+-
+-def extract_cte_pattern(code, constants, pattern):
+-    """replace the constant following a pattern with variable"""
+-    const_strs = re.findall(pattern, code)
+-    for cte in const_strs:
+-        name = " _cte_temp{}_ ".format(len(constants))
+-        code = code.replace(cte, cte[0] + name, 1)
+-        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
+-    return code
+-
+-
+-def space_parts(code, names):
+-    """Force spacing: single space between element"""
+-    for name in names:
+-        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
+-                      " " + name + " ", code)
+-    code = " ".join(code.split())
+-    return code
+-
+-
+-def parse(code, args, compile_opt):
+-    """
+-    Read the code and rewrite it in a reutilisable form:
+-    Ins:
+-        '2.*cos(a*t)', {"a":5+1j}
+-    Outs:
+-        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
+-        variables = [('self._arg_cpl0', 'a', 'complex')]
+-        ordered_constants = [('self._cte_dbl0', 2, 'double')]
+-    """
+-    code, constants = extract_constant(code)
+-    names = re.findall("[0-9a-zA-Z_]+", code)
+-    code = space_parts(code, names)
+-    constants_names = [const[0] for const in constants]
+-    new_code = []
+-    ordered_constants = []
+-    variables = []
+-    typeCounts = defaultdict(lambda: 0)
+-    accept_int = compile_opt['accept_int']
+-    accept_float = compile_opt['accept_float']
+-    if accept_int is None:
+-        # If there is a subscript: a[b] int are always accepted to be safe
+-        # with TypeError
+-        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
+-    for word in code.split():
+-        if word not in names:
+-            # syntax
+-            new_code.append(word)
+-        elif word in args:
+-            # find first if the variable is use more than once and reuse
+-            var_name = [var_name for var_name, name, _ in variables
+-                        if word == name]
+-            if var_name:
+-                var_name = var_name[0]
+-            else:
+-                ctype = compileType(args[word])
+-                ctype = fix_type(ctype, accept_int, accept_float)
+-                var_name = ("self._arg" + typeCodes[ctype] +
+-                            str(typeCounts[ctype]))
+-                typeCounts[ctype] += 1
+-                variables.append((var_name, word, ctype))
+-            new_code.append(var_name)
+-        elif word in constants_names:
+-            name, val, ctype = constants[int(word[9:-1])]
+-            ctype = fix_type(ctype, accept_int, accept_float)
+-            cte_name = "self._cte" + typeCodes[ctype] +\
+-                       str(len(ordered_constants))
+-            new_code.append(cte_name)
+-            ordered_constants.append((cte_name, val, ctype))
+-        else:
+-            # Hopefully a buildin or known object
+-            new_code.append(word)
+-        code = " ".join(new_code)
+-    return code, variables, ordered_constants
+-
+-
+-def use_hinted_type(variables, code, args_ctypes):
+-    variables_manually_typed = []
+-    for i, (name, key, type_) in enumerate(variables):
+-        if key in args_ctypes:
+-            new_name = "self._custom_" + args_ctypes[key] + str(i)
+-            code = code.replace(name, new_name)
+-            variables_manually_typed.append((new_name, key, args_ctypes[key]))
+-        else:
+-            variables_manually_typed.append((name, key, type_))
+-    return code, variables_manually_typed
+-
+-
+-def try_parse(code, args, args_ctypes, compile_opt):
+-    """
+-    Try to parse and verify that the result is still usable.
+-    """
+-    if not compile_opt['try_parse']:
+-        variables = [("self." + name, name, "object") for name in args
+-                     if name in code]
+-        code, variables = use_hinted_type(variables, code, args_ctypes)
+-        return code, variables, [], True
+-    ncode, variables, constants = parse(code, args, compile_opt)
+-    if not compile_opt['static_types']:
+-        # Fallback to object
+-        variables = [(f, s, "object") for f, s, _ in variables]
+-        constants = [(f, s, "object") for f, s, _ in constants]
+-    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
+-    if (
+-        (compile_opt['extra_import']
+-         and not compile_opt['extra_import'].isspace())
+-        or test_parsed(ncode, variables, constants, args)
+-    ):
+-        return ncode, variables, constants, False
+-    else:
+-        warnings.warn("Could not find c types", StringParsingWarning)
+-        remaped_variable = []
+-        for _, name, ctype in variables:
+-            remaped_variable.append(("self." + name, name, "object"))
+-        return code, remaped_variable, [], True
+-
+-
+-def test_parsed(code, variables, constants, args):
+-    """
+-    Test if parsed code broke anything.
+-    """
+-    class DummySelf:
+-        pass
+-    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
+-    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
+-    loc_env = {"t": 0, 'self': DummySelf}
+-    try:
+-        exec(code, str_env, loc_env)
+-    except Exception as e:
+-        return False
+-    return True
++import numpy as np
++import scipy
++import scipy.interpolate
++import os
++import sys
++import re
++import dis
++import hashlib
++import glob
++import importlib
++import warnings
++import numbers
++from contextlib import contextmanager
++from collections import defaultdict
++from setuptools import setup, Extension
++try:
++    from Cython.Build import cythonize
++    import filelock
++except ImportError:
++    pass
++
++from ..settings import settings as qset
++from .options import QutipOptions
++from .data import Data
++from .cy.coefficient import (
++    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
++    ConjCoefficient, NormCoefficient
++)
++
++
++__all__ = ["coefficient", "CompilationOptions", "Coefficient",
++           "clean_compiled_coefficient"]
++
++
++class StringParsingWarning(Warning):
++    pass
++
++
++def _return(base, **kwargs):
++    return base
++
++
++# The `coefficient` function is dispatcher for the type of the `base` to the
++# function that created the `Coefficient` object. `coefficient_builders` stores
++# the map `type -> function(base, **kw)`. Optional module can add their
++# `Coefficient` specializations here.
++coefficient_builders = {
++    Coefficient: _return,
++    np.ndarray: InterCoefficient,
++    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
++    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
++}
++
++
++def coefficient(base, *, tlist=None, args={}, args_ctypes={},
++                order=3, compile_opt=None, function_style=None,
++                boundary_conditions=None, **kwargs):
++    """Build ``Coefficient`` for time dependent systems:
++
++    ```
++    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
++    ```
++
++    The coefficients can be a function, a string or a numpy array. Other
++    packages may add support for other kind of coefficients.
++
++    For function based coefficients, the function signature must be either:
++
++    * ``f(t, ...)`` where the other arguments are supplied as ordinary
++      "pythonic" arguments (e.g. ``f(t, w, a=5))
++    * ``f(t, args)`` where the arguments are supplied in a "dict" named
++      ``args``
++
++    By default the signature style is controlled by the
++    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
++    may be overriden here by specifying either ``function_style="pythonic"``
++    or ``function_style="dict"``.
++
++    *Examples*
++        # pythonic style function signature
++
++        def f1_t(t, w):
++            return np.exp(-1j * t * w)
++
++        coeff1 = coefficient(f1_t, args={"w": 1.})
++
++        # dict style function signature
++
++        def f2_t(t, args):
++            return np.exp(-1j * t * args["w"])
++
++        coeff2 = coefficient(f2_t, args={"w": 1.})
++
++    For string based coeffients, the string must be a compilable python code
++    resulting in a complex. The following symbols are defined:
++        sin cos tan asin acos atan pi
++        sinh cosh tanh asinh acosh atanh
++        exp log log10 erf zerf sqrt
++        real imag conj abs norm arg proj
++        numpy as np,
++        scipy.special as spe (python interface)
++        and cython_special (scipy cython interface)
++
++    *Examples*
++        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
++    'args' is needed for string coefficient at compilation.
++    It is a dict of (name:object). The keys must be a valid variables string.
++
++    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
++
++    For numpy array format, the array must be an 1d of dtype float or complex.
++    A list of times (float64) at which the coeffients must be given (tlist).
++    The coeffients array must have the same len as the tlist.
++    The time of the tlist do not need to be equidistant, but must be sorted.
++    By default, a cubic spline interpolation will be used to compute the
++    coefficient at time t. The keyword ``order`` sets the order of the
++    interpolation. When ``order = 0``, the interpolation is step function that
++    evaluates to the most recent value.
++
++    *Examples*
++        tlist = np.logspace(-5,0,100)
++        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
++
++    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
++    also converted to interpolated coefficients (the same kind of coefficient
++    created from ``ndarray``). Other interpolation methods from
++    scipy are converted to a function-based coefficient (the same kind of
++    coefficient created from callables).
++
++    Parameters
++    ----------
++    base : object
++        Base object to make into a Coefficient.
++
++    args : dict, optional
++        Dictionary of arguments to pass to the function or string coefficient.
++
++    order : int, default=3
++        Order of the spline for array based coefficient.
++
++    tlist : iterable, optional
++        Times for each element of an array based coefficient.
++
++    function_style : str, ["dict", "pythonic", None]
++        Function signature of function based coefficients.
++
++    args_ctypes : dict, optional
++        C type for the args when compiling array based coefficients.
++
++    compile_opt : CompilationOptions, optional
++        Sets of options for the compilation of string based coefficients.
++
++    boundary_conditions: 2-tupule, str or None, optional
++        Specify boundary conditions for spline interpolation.
++
++    **kwargs
++        Extra arguments to pass the the coefficients.
++    """
++    kwargs.update({
++        "tlist": tlist,
++        'args': args,
++        'args_ctypes': args_ctypes,
++        'order': order,
++        'compile_opt': compile_opt,
++        'function_style': function_style,
++        'boundary_conditions': boundary_conditions
++    })
++
++    for type_ in coefficient_builders:
++        if isinstance(base, type_):
++            return coefficient_builders[type_](base, **kwargs)
++
++    if callable(base):
++        op = FunctionCoefficient(base, args.copy(), style=function_style)
++        if not isinstance(op(0), numbers.Number):
++            raise TypeError("The coefficient function must return a number")
++        return op
++    else:
++        raise ValueError("coefficient format not understood")
++
++
++def norm(coeff):
++    """ return a Coefficient with is the norm: |c|^2.
++    """
++    return NormCoefficient(coeff)
++
++
++def conj(coeff):
++    """ return a Coefficient with is the conjugate.
++    """
++    return ConjCoefficient(coeff)
++
++
++# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
++# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
++# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
++class CompilationOptions(QutipOptions):
++    """
++    Compilation options:
++
++    use_cython: bool
++        Whether to compile strings as cython code or use python's ``exec``.
++
++    try_parse: bool [True]
++        Whether to try parsing the string for reuse and static typing.
++
++    static_types : bool [True]
++        Whether to use C types for constant and args.
++
++    accept_int : None, bool
++        Whether to use the type ``int`` for integer constants and args or
++        upgrade it to ``float`` or ``complex``.
++        If `None`, it will only use ``int`` when subscription is found in the
++        code.
++
++    accept_float : bool
++        Whether to use the type ``float`` or upgrade them to ``complex``.
++
++    recompile : bool
++        Do not use previously made files but build a new one.
++
++    compiler_flags : str
++        Flags to pass to the compiler, ex: "-Wall -O3"...
++        Flags not matching your comiler and OS may cause compilation to fail.
++        Use "recompile=True", when trying to if the string pattern was
++        previously used.
++
++    link_flags : str
++        Libraries to link to pass to the compiler. They can not be used to add
++        function to the string coefficient.
++
++    extra_import : str
++        Cython code to add at the head of the file. Can be used to add extra
++        import or cimport code, ex:
++        extra_import="from scipy.linalg import det"
++        extra_import="from qutip.core.data cimport CSR"
++
++    clean_on_error : bool [True]
++        When writing a cython file that cannot be imported, erase it.
++    """
++    _link_flags = ""
++    _compiler_flags = ""
++    if sys.platform == 'win32':
++        _compiler_flags = ''
++    elif sys.platform == 'darwin':
++        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
++        _link_flags += '-mmacosx-version-min=10.9'
++    else:
++        _compiler_flags = '-w -O3 -funroll-loops'
++
++    try:
++        import cython
++        import filelock
++        _use_cython = True
++    except ImportError:
++        _use_cython = False
++
++    _options = {
++        "use_cython": _use_cython,
++        "try_parse": True,
++        "static_types": True,
++        "accept_int": None,
++        "accept_float": True,
++        "recompile": False,
++        "compiler_flags": _compiler_flags,
++        "link_flags": _link_flags,
++        "extra_import": "",
++        "clean_on_error": True,
++    }
++    _settings_name = "compile"
++
++
++# Create the default instance in settings.
++qset.compile = CompilationOptions()
++
++
++# Version number of the Coefficient
++COEFF_VERSION = "1.1"
++
++try:
++    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
++    qset.coeffroot = root
++except OSError:
++    qset.coeffroot = "."
++
++
++def clean_compiled_coefficient(all=False):
++    """
++    Remove previouly compiled string Coefficient.
++
++    Parameter:
++    ----------
++    all: bool
++        If not `all` will remove only previous version.
++    """
++    import glob
++    import shutil
++    tmproot = qset.tmproot
++    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
++    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
++    for folder in folders:
++        if all or folder != root:
++            shutil.rmtree(folder)
++    # Recreate the empty folder.
++    qset.coeffroot = qset.coeffroot
++
++
++def proj(x):
++    if np.isfinite(x):
++        return (x)
++    else:
++        return np.inf + 0j * np.imag(x)
++
++
++str_env = {
++    "sin": np.sin,
++    "cos": np.cos,
++    "tan": np.tan,
++    "asin": np.arcsin,
++    "acos": np.arccos,
++    "atan": np.arctan,
++    "pi": np.pi,
++    "sinh": np.sinh,
++    "cosh": np.cosh,
++    "tanh": np.tanh,
++    "asinh": np.arcsinh,
++    "acosh": np.arccosh,
++    "atanh": np.arctanh,
++    "exp": np.exp,
++    "log": np.log,
++    "log10": np.log10,
++    "erf": scipy.special.erf,
++    "zerf": scipy.special.erf,
++    "sqrt": np.sqrt,
++    "real": np.real,
++    "imag": np.imag,
++    "conj": np.conj,
++    "abs": np.abs,
++    "norm": lambda x: np.abs(x)**2,
++    "arg": np.angle,
++    "proj": proj,
++    "np": np,
++    "spe": scipy.special}
++
++
++def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
++    """
++    Entry point for string based coefficients
++    - Test if the string is valid
++    - Parse: "cos(a*t)" and "cos( w1 * t )"
++        should be recognised as the same compiled object.
++    - Verify if already compiled and compile if not
++    """
++    # First, a sanity check before thinking of compiling
++    if compile_opt is None:
++        compile_opt = qset.compile
++    if not compile_opt['extra_import']:
++        try:
++            env = {"t": 0}
++            env.update(args)
++            exec(base, str_env, env)
++        except Exception as err:
++            raise Exception("Invalid string coefficient") from err
++    coeff = None
++    # Do we compile?
++    if not compile_opt['use_cython']:
++        return StrFunctionCoefficient(base, args)
++    # Parsing tries to make the code in common pattern
++    parsed, variables, constants, raw = try_parse(base, args,
++                                                  args_ctypes, compile_opt)
++    # Once parsed, the code should be unique enough to get a filename
++    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
++    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
++    # See if it already exist and import it.
++    if not compile_opt['recompile']:
++        coeff = try_import(file_name, parsed)
++
++    if not coeff and qset.coeff_write_ok:
++        # Previously compiled coefficient not available: create the cython code
++        code = make_cy_code(parsed, variables, constants,
++                            raw, compile_opt)
++        try :
++            coeff = compile_code(code, file_name, parsed, compile_opt)
++        except PermissionError:
++            pass
++    if coeff is None:
++        # We don't use cython or compilation failed
++        return StrFunctionCoefficient(base, args)
++    keys = [key for _, key, _ in variables]
++    const = [fromstr(val) for _, val, _ in constants]
++    return coeff(base, keys, const, args)
++
++
++coefficient_builders[str] = coeff_from_str
++
++
++def try_import(file_name, parsed_in):
++    """ Import the compiled coefficient if existing and check for
++    name collision.
++    """
++    try:
++        mod = importlib.import_module(file_name)
++    except ModuleNotFoundError:
++        # Coefficient does not exist, to compile as file_name
++        return None
++
++    if mod.parsed_code == parsed_in:
++        # Coefficient found!
++        return mod.StrCoefficient
++    else:
++        raise ValueError("string hash collision, change the string "
++                         "or clean files in qutip.settings.coeffroot")
++
++
++def make_cy_code(code, variables, constants, raw, compile_opt):
++    """
++    Generate the code for the string coefficients.
++    """
++    cdef_cte = ""
++    init_cte = ""
++    copy_cte = ""
++    for i, (name, val, ctype) in enumerate(constants):
++        cdef_cte += "        {} {}\n".format(ctype, name[5:])
++        copy_cte += "        out.{} = {}\n".format(name[5:], name)
++        init_cte += "        {} = cte[{}]\n".format(name, i)
++    cdef_var = ""
++    init_var = ""
++    init_arg = ""
++    replace_var = ""
++    call_var = ""
++    copy_var = ""
++    for i, (name, val, ctype) in enumerate(variables):
++        cdef_var += "        str key{}\n".format(i)
++        cdef_var += "        {} {}\n".format(ctype, name[5:])
++        copy_var += "        out.key{} = self.key{}\n".format(i, i)
++        copy_var += "        out.{} = {}\n".format(name[5:], name)
++        if not raw:
++            init_var += "        self.key{} = var[{}]\n".format(i, i)
++        else:
++            init_var += "        self.key{} = '{}'\n".format(i, val)
++        init_arg += "        {} = args[self.key{}]\n".format(name, i)
++        replace_var += "            if self.key{} in kwargs:\n".format(i)
++        replace_var += ("                out.{}"
++                        " = kwargs[self.key{}]\n".format(name[5:], i))
++        if raw:
++            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
++
++    code = f"""#cython: language_level=3
++# This file is generated automatically by QuTiP.
++
++import numpy as np
++import scipy.special as spe
++from scipy.special cimport cython_special
++cimport cython
++from qutip.core.cy.coefficient cimport Coefficient
++from qutip.core.cy.math cimport erf, zerf
++from qutip.core.cy.complex_math cimport *
++from qutip.core.data cimport Data
++cdef double pi = 3.14159265358979323
++{compile_opt['extra_import']}
++
++parsed_code = "{code}"
++
++@cython.auto_pickle(True)
++cdef class StrCoefficient(Coefficient):
++    \"\"\"
++    String compiled as a :obj:`Coefficient` using cython.
++    \"\"\"
++    cdef:
++        str codeString
++{cdef_cte}{cdef_var}
++
++    def __init__(self, base, var, cte, args):
++        self.codeString = base
++{init_cte}{init_var}{init_arg}
++
++    cpdef Coefficient copy(self):
++        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
++        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
++        out.codeString = self.codeString
++{copy_cte}{copy_var}
++        return out
++
++    def replace_arguments(self, _args=None, **kwargs):
++        \"\"\"
++        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
++        built from 'str' or a python function. Or a the :obj:`Coefficient`
++        itself if the :obj:`Coefficient` does not use arguments. New arguments
++        can be passed as a dict or as keywords.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        \"\"\"
++        cdef StrCoefficient out
++
++        if _args:
++            kwargs.update(_args)
++        if kwargs:
++            out = self.copy()
++{replace_var}
++            return out
++        return self
++
++    @cython.initializedcheck(False)
++    @cython.cdivision(True)
++    cdef complex _call(self, double t) except *:
++{call_var}        return {code}
++"""
++    return code
++
++
++def compile_code(code, file_name, parsed, c_opt):
++    pwd = os.getcwd()
++    os.chdir(qset.coeffroot)
++    # Files with the same name, but differents extension than the pyx file, are
++    # erased during cythonization process, breaking filelock.
++    # Adding a prefix make them safe to use.
++    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
++    try:
++        lock.acquire(timeout=0)
++        for file in glob.glob(file_name + "*"):
++            os.remove(file)
++        file_ = open(file_name + ".pyx", "w")
++        file_.writelines(code)
++        file_.close()
++        oldargs = sys.argv
++        try:
++            sys.argv = ["setup.py", "build_ext", "--inplace"]
++            coeff_file = Extension(
++                file_name,
++                sources=[file_name + ".pyx"],
++                extra_compile_args=c_opt['compiler_flags'].split(),
++                extra_link_args=c_opt['link_flags'].split(),
++                include_dirs=[np.get_include()],
++                language='c++'
++            )
++            ext_modules = cythonize(coeff_file, force=True)
++            setup(ext_modules=ext_modules)
++        except Exception as e:
++            if c_opt['clean_on_error']:
++                for file in glob.glob(file_name + "*"):
++                    os.remove(file)
++            raise Exception("Could not compile") from e
++        finally:
++            sys.argv = oldargs
++    except filelock.Timeout:
++        with lock:
++            # We wait for the lock to be released and then retry the import.
++            pass
++    finally:
++        lock.release()
++        os.chdir(pwd)
++    return try_import(file_name, parsed)
++
++
++# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
++# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
++# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
++# Parsing here is extracting constants and args name to replace them with
++# attribute of the Coefficient so similar string like:
++# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
++# are all reconized as the same compiled object and only compiled once.
++# Weakness:
++#   typing: "1" and "1j" or the type of args ("w1") make different object
++#   complex: "1+1j" is seens as cte(double) + cte(complex)
++#   negative: "-1" is not seens as a constant but "- constant"
++#
++# int and double can be seens as complex with flags in CompilationOptions
++
++def fromstr(base):
++    """Read a varibles in a string"""
++    ls = {}
++    exec("out = " + base, {}, ls)
++    return ls["out"]
++
++
++typeCodes = {
++    "Data": "_datalayer",
++    "complex": "_cpl",
++    "double": "_dbl",
++    "int": "_int",
++    "str": "_str",
++    "object": "_obj"
++}
++
++
++def compileType(value):
++    """Obtain the index of typeCodes that correspond to the value
++    4.5 -> 'double'..."""
++    if isinstance(value, Data):
++        ctype = "Data"
++    elif isinstance(value, numbers.Integral):
++        ctype = "int"
++    elif isinstance(value, numbers.Real):
++        ctype = "double"
++    elif isinstance(value, numbers.Complex):
++        ctype = "complex"
++    elif isinstance(value, str):
++        ctype = "str"
++    else:
++        ctype = "object"
++    return ctype
++
++
++def find_type_from_str(chars):
++    """ '1j' -> complex """
++    try:
++        lc = {}
++        exec("out = " + chars, {}, lc)
++        return compileType(lc["out"])
++    except Exception:
++        return None
++
++
++def fix_type(ctype, accept_int, accept_float):
++    """int and double could be complex to limit the number of compiled object.
++    change the types is we choose not to support all.
++    """
++    if ctype == "int" and not accept_int:
++        ctype = "double"
++    if ctype == "double" and not accept_float:
++        ctype = "complex"
++    return ctype
++
++
++def extract_constant(code):
++    """Look for floating and complex constants and replace them with variable.
++    """
++    code = " " + code + " "
++    contants = []
++    code = extract_cte_pattern(code, contants,
++                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
++    code = extract_cte_pattern(code, contants,
++                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
++    code = extract_cte_pattern(code, contants,
++                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
++    code = extract_cte_pattern(code, contants,
++                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
++    return code, contants
++
++
++def extract_cte_pattern(code, constants, pattern):
++    """replace the constant following a pattern with variable"""
++    const_strs = re.findall(pattern, code)
++    for cte in const_strs:
++        name = " _cte_temp{}_ ".format(len(constants))
++        code = code.replace(cte, cte[0] + name, 1)
++        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
++    return code
++
++
++def space_parts(code, names):
++    """Force spacing: single space between element"""
++    for name in names:
++        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
++                      " " + name + " ", code)
++    code = " ".join(code.split())
++    return code
++
++
++def parse(code, args, compile_opt):
++    """
++    Read the code and rewrite it in a reutilisable form:
++    Ins:
++        '2.*cos(a*t)', {"a":5+1j}
++    Outs:
++        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
++        variables = [('self._arg_cpl0', 'a', 'complex')]
++        ordered_constants = [('self._cte_dbl0', 2, 'double')]
++    """
++    code, constants = extract_constant(code)
++    names = re.findall("[0-9a-zA-Z_]+", code)
++    code = space_parts(code, names)
++    constants_names = [const[0] for const in constants]
++    new_code = []
++    ordered_constants = []
++    variables = []
++    typeCounts = defaultdict(lambda: 0)
++    accept_int = compile_opt['accept_int']
++    accept_float = compile_opt['accept_float']
++    if accept_int is None:
++        # If there is a subscript: a[b] int are always accepted to be safe
++        # with TypeError
++        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
++    for word in code.split():
++        if word not in names:
++            # syntax
++            new_code.append(word)
++        elif word in args:
++            # find first if the variable is use more than once and reuse
++            var_name = [var_name for var_name, name, _ in variables
++                        if word == name]
++            if var_name:
++                var_name = var_name[0]
++            else:
++                ctype = compileType(args[word])
++                ctype = fix_type(ctype, accept_int, accept_float)
++                var_name = ("self._arg" + typeCodes[ctype] +
++                            str(typeCounts[ctype]))
++                typeCounts[ctype] += 1
++                variables.append((var_name, word, ctype))
++            new_code.append(var_name)
++        elif word in constants_names:
++            name, val, ctype = constants[int(word[9:-1])]
++            ctype = fix_type(ctype, accept_int, accept_float)
++            cte_name = "self._cte" + typeCodes[ctype] +\
++                       str(len(ordered_constants))
++            new_code.append(cte_name)
++            ordered_constants.append((cte_name, val, ctype))
++        else:
++            # Hopefully a buildin or known object
++            new_code.append(word)
++        code = " ".join(new_code)
++    return code, variables, ordered_constants
++
++
++def use_hinted_type(variables, code, args_ctypes):
++    variables_manually_typed = []
++    for i, (name, key, type_) in enumerate(variables):
++        if key in args_ctypes:
++            new_name = "self._custom_" + args_ctypes[key] + str(i)
++            code = code.replace(name, new_name)
++            variables_manually_typed.append((new_name, key, args_ctypes[key]))
++        else:
++            variables_manually_typed.append((name, key, type_))
++    return code, variables_manually_typed
++
++
++def try_parse(code, args, args_ctypes, compile_opt):
++    """
++    Try to parse and verify that the result is still usable.
++    """
++    if not compile_opt['try_parse']:
++        variables = [("self." + name, name, "object") for name in args
++                     if name in code]
++        code, variables = use_hinted_type(variables, code, args_ctypes)
++        return code, variables, [], True
++    ncode, variables, constants = parse(code, args, compile_opt)
++    if not compile_opt['static_types']:
++        # Fallback to object
++        variables = [(f, s, "object") for f, s, _ in variables]
++        constants = [(f, s, "object") for f, s, _ in constants]
++    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
++    if (
++        (compile_opt['extra_import']
++         and not compile_opt['extra_import'].isspace())
++        or test_parsed(ncode, variables, constants, args)
++    ):
++        return ncode, variables, constants, False
++    else:
++        warnings.warn("Could not find c types", StringParsingWarning)
++        remaped_variable = []
++        for _, name, ctype in variables:
++            remaped_variable.append(("self." + name, name, "object"))
++        return code, remaped_variable, [], True
++
++
++def test_parsed(code, variables, constants, args):
++    """
++    Test if parsed code broke anything.
++    """
++    class DummySelf:
++        pass
++    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
++    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
++    loc_env = {"t": 0, 'self': DummySelf}
++    try:
++        exec(code, str_env, loc_env)
++    except Exception as e:
++        return False
++    return True
+diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
+index 46f869b2..55c6c847 100644
+--- a/qutip/core/cy/_element.pxd
++++ b/qutip/core/cy/_element.pxd
+@@ -1,42 +1,42 @@
+-#cython: language_level=3
+-
+-from qutip.core.data cimport CSR, Dense, Data
+-from qutip.core.cy.coefficient cimport Coefficient
+-from qutip.core.data.base cimport idxint
+-from libcpp cimport bool
+-
+-cdef class _BaseElement:
+-    cpdef Data data(self, t)
+-    cpdef object qobj(self, t)
+-    cpdef object coeff(self, t)
+-    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
+-
+-
+-cdef class _ConstantElement(_BaseElement):
+-    cdef readonly object _qobj
+-
+-
+-cdef class _EvoElement(_BaseElement):
+-    cdef readonly object _qobj
+-    cdef readonly Coefficient _coefficient
+-
+-
+-cdef class _FuncElement(_BaseElement):
+-    cdef readonly object _func
+-    cdef readonly dict _args
+-    cdef readonly tuple _previous
+-    cdef readonly bint _f_pythonic
+-    cdef readonly set _f_parameters
+-
+-
+-cdef class _MapElement(_BaseElement):
+-    cdef readonly _FuncElement _base
+-    cdef readonly list _transform
+-    cdef readonly double complex _coeff
+-
+-
+-cdef class _ProdElement(_BaseElement):
+-    cdef readonly _BaseElement _left
+-    cdef readonly _BaseElement _right
+-    cdef readonly list _transform
+-    cdef readonly bool _conj
++#cython: language_level=3
++
++from qutip.core.data cimport CSR, Dense, Data
++from qutip.core.cy.coefficient cimport Coefficient
++from qutip.core.data.base cimport idxint
++from libcpp cimport bool
++
++cdef class _BaseElement:
++    cpdef Data data(self, t)
++    cpdef object qobj(self, t)
++    cpdef object coeff(self, t)
++    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
++
++
++cdef class _ConstantElement(_BaseElement):
++    cdef readonly object _qobj
++
++
++cdef class _EvoElement(_BaseElement):
++    cdef readonly object _qobj
++    cdef readonly Coefficient _coefficient
++
++
++cdef class _FuncElement(_BaseElement):
++    cdef readonly object _func
++    cdef readonly dict _args
++    cdef readonly tuple _previous
++    cdef readonly bint _f_pythonic
++    cdef readonly set _f_parameters
++
++
++cdef class _MapElement(_BaseElement):
++    cdef readonly _FuncElement _base
++    cdef readonly list _transform
++    cdef readonly double complex _coeff
++
++
++cdef class _ProdElement(_BaseElement):
++    cdef readonly _BaseElement _left
++    cdef readonly _BaseElement _right
++    cdef readonly list _transform
++    cdef readonly bool _conj
+diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
+index 999d51d0..a845b63d 100644
+--- a/qutip/core/cy/_element.pyx
++++ b/qutip/core/cy/_element.pyx
+@@ -1,625 +1,625 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+-
+-from .. import data as _data
+-from qutip.core.cy.coefficient import coefficient_function_parameters
+-from qutip.core.data cimport Dense, Data, dense
+-from qutip.core.data.matmul cimport *
+-from math import nan as Nan
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex conj(double complex x)
+-
+-__all__ = ['_ConstantElement', '_EvoElement',
+-           '_FuncElement', '_MapElement', '_ProdElement']
+-
+-
+-cdef class _BaseElement:
+-    """
+-    The representation of a single time-dependent term in the list of
+-    terms used by QobjEvo and solvers to describe operators.
+-
+-    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
+-    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
+-    are functions of time. :meth:`~_BaseElement.coeff` returns the
+-    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
+-
+-    For example, a :obj:`QobjEvo` instance created by::
+-
+-      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
+-
+-    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
+-    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
+-
+-    :obj:`~_BaseElement` defines the interface to time-dependent terms.
+-    Sub-classes implement terms defined in different ways.
+-    For example, :obj:`~_ConstantElement` implements a term that
+-    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
+-    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
+-    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
+-    so on.
+-
+-    .. note::
+-
+-      There are three methods to return the factors of the term.
+-
+-      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
+-      coefficient and operator factors respectively. They are separate to
+-      avoid constructing an intermediate Python object when called from
+-      Cython code (which may take as long as the rest of the call).
+-
+-      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
+-      provides a convenience method for this common operation.
+-
+-    .. note::
+-
+-      All :obj:`~_BaseElement` instances are immutable and methods that would
+-      modify an object return a new instance instead.
+-    """
+-    cpdef Data data(self, t):
+-        """
+-        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
+-        of the term at time ``t``.
+-
+-        Parameters
+-        ----------
+-        t : double
+-          The time, ``t``.
+-
+-        Returns
+-        -------
+-        :obj:`~Data`
+-          The underlying data of the :obj:`~Qobj` component of the term
+-          at time ``t``.
+-        """
+-        raise NotImplementedError(
+-          "Sub-classes of _BaseElement should implement .data(t)."
+-        )
+-
+-    cpdef object qobj(self, t):
+-        """
+-        Returns the :obj:`~Qobj` component of the term at time ``t``.
+-
+-        Parameters
+-        ----------
+-        t : float
+-          The time, ``t``.
+-
+-        Returns
+-        -------
+-        :obj:`~Qobj`
+-          The :obj:`~Qobj` component of the term at time ``t``.
+-        """
+-        raise NotImplementedError(
+-          "Sub-classes of _BaseElement should implement .qobj(t)."
+-        )
+-
+-    cpdef object coeff(self, t):
+-        """
+-        Returns the complex coefficient of the term at time ``t``.
+-
+-        Parameters
+-        ----------
+-        t : float
+-          The time, ``t``.
+-
+-        Returns
+-        -------
+-        complex
+-          The complex coefficient of the term at time ``t``.
+-        """
+-        raise NotImplementedError(
+-          "Sub-classes of _BaseElement should implement .coeff(t)."
+-        )
+-
+-    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
+-        """
+-        Possibly in-place multiplication and addition. Multiplies a given state
+-        by the elemen's value at time ``t`` and adds the result to ``out``.
+-        Equivalent to::
+-
+-          out += self.coeff(t) * self.qobj(t) @ state
+-
+-        Sub-classes may override :meth:`~matmul_data_t` to provide an more
+-        efficient implementation.
+-
+-        Parameters
+-        ----------
+-        t : double
+-          The time, ``t``.
+-
+-        state : :obj:`~Data`
+-          The state to multiply by the element term.
+-
+-        out : :obj:`~Data` or ``NULL``
+-          The output to add the result of the multiplication to. If ``NULL``,
+-          the result of the multiplication is returned directly (i.e. ``out``
+-          is assumed to be the zero matrix).
+-
+-        Returns
+-        -------
+-        data
+-          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
+-          the addition possibly having been performed in-place on ``out``.
+-
+-        .. note::
+-
+-          Because of the possibly but not definitely in-place behaviour of
+-          this function, the result should always be assigned to some variable
+-          and surrounding code should assume that ``out`` maybe have been
+-          modified and that the result may be a reference to ``out``. The
+-          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
+-
+-        .. note::
+-
+-          This method would ideally be implemented using a special
+-          function dispatched by the data layer so that it did not have to
+-          special case the ``Dense`` operation itself, but the data layer
+-          dispatch does not yet support in-place operations. Once it does
+-          this method should be updated to use the new support.
+-        """
+-        if out is None:
+-            return _data.matmul(self.data(t), state, self.coeff(t))
+-        elif type(state) is Dense and type(out) is Dense:
+-            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
+-            return out
+-        else:
+-            return _data.add(
+-                out,
+-                _data.matmul(self.data(t), state, self.coeff(t))
+-            )
+-
+-    def linear_map(self, f, anti=False):
+-        """
+-        Return a new element representing a linear transformation ``f``
+-        of the :obj:`~Qobj` portion of this element and possibly a
+-        complex conjucation of the coefficient portion (when ``f`` is an
+-        antilinear map).
+-
+-        If this element represents ``coeff * qobj`` the returned element
+-        represents ``coeff * f(obj)`` (if ``anti=False``) or
+-        ``conj(coeff) * f(obj)`` (if ``anti=True``).
+-
+-        Parameters
+-        ----------
+-        f : function
+-          The linear transformation to apply to the :obj:`~Qobj` of this
+-          element.
+-        anti : bool
+-          Whether to take the complex conjugate of the coefficient. Default
+-          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
+-          map such as the adjoint (i.e. dagger).
+-
+-        Returns
+-        -------
+-        _BaseElement
+-          A new element with the transformation applied.
+-        """
+-        raise NotImplementedError(
+-          "Sub-classes of _BaseElement should implement .linear_map(t)."
+-        )
+-
+-    def replace_arguments(self, args, cache=None):
+-        """
+-        Return a copy of the element with the (possible) additional arguments
+-        to any time-dependent functions updated to the given argument values.
+-        The arguments of any contained :obj:`~Coefficient` instances are also
+-        replaced.
+-
+-        If the operation does not modify this element, the original element
+-        may be returned.
+-
+-        Parameters
+-        ----------
+-        args : dict
+-          A dictionary of arguments to update. Keys are the names of the
+-          arguments and values are the new argument values. Arguments
+-          not included retain their original values.
+-
+-        cache : list or ``None``
+-          A cache to add updated elements to. Unmodified elements are not
+-          added to the cache. If a cache is supplied and ``.replace_arguments``
+-          would be called again on the same element with the same arguments,
+-          the new element from the cache will be returned instead.
+-
+-          By default the cache is ``None`` and no caching is performed. Cache
+-          users should supply either ``cache=[]`` (which activates caching)
+-          or an existing cache (for example, if making calls on sub-elements
+-          of some composite element).
+-
+-        Returns
+-        -------
+-        _BaseElement
+-          A new element with the arguments replaced, or possibly this element
+-          if it would not be modified.
+-
+-        Example
+-        -------
+-
+-        If ``elem`` is a product element for ``op * op.dag()`` it will contain
+-        two references to the same element for ``op``. Calling::
+-
+-          elem = elem.replace_arguments({"theta": 3.1416})
+-
+-        will return a new element that contains two *different* copies of
+-        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
+-        to be evaluated *twice* when ``elem.qobj(t)`` is called.
+-
+-        Calling instead::
+-
+-          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
+-
+-        will return a new element that contains two references to *one* copy
+-        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
+-        performance when calling ``elem.qobj(t)`` later.
+-        """
+-        raise NotImplementedError(
+-          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
+-        )
+-
+-    def __call__(self, t, args=None):
+-        if args:
+-            cache = []
+-            self = self.replace_arguments(args, cache)
+-        return self.qobj(t) * self.coeff(t)
+-
+-
+-cdef class _ConstantElement(_BaseElement):
+-    """
+-    Constant part of a list format :obj:`QobjEvo`.
+-    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
+-
+-      qevo = QobjEvo(H0)
+-      qevo.elements = [_ConstantElement(H0)]
+-    """
+-    def __init__(self, qobj):
+-        self._qobj = qobj
+-
+-    def __mul__(left, right):
+-        if type(left) is _ConstantElement:
+-            return _ConstantElement((<_ConstantElement> left)._qobj * right)
+-        elif type(right) is _ConstantElement:
+-            return _ConstantElement((<_ConstantElement> right)._qobj * left)
+-        return NotImplemented
+-
+-    def __matmul__(left, right):
+-        if type(left) is _ConstantElement and type(right) is _ConstantElement:
+-            return _ConstantElement(
+-                (<_ConstantElement> left)._qobj @
+-                (<_ConstantElement> right)._qobj
+-            )
+-        return NotImplemented
+-
+-    cpdef Data data(self, t):
+-        return self._qobj.data
+-
+-    cpdef object qobj(self, t):
+-        return self._qobj
+-
+-    cpdef object coeff(self, t):
+-        return 1.
+-
+-    def linear_map(self, f, anti=False):
+-        return _ConstantElement(f(self._qobj))
+-
+-    def replace_arguments(self, args, cache=None):
+-        return self
+-
+-    def __call__(self, t, args=None):
+-        return self._qobj
+-
+-
+-cdef class _EvoElement(_BaseElement):
+-    """
+-    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
+-    time-dependent operator::
+-
+-      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
+-      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
+-    """
+-    def __init__(self, qobj, coefficient):
+-        self._qobj = qobj
+-        self._coefficient = coefficient
+-
+-    def __mul__(left, right):
+-        cdef _EvoElement base
+-        cdef object factor
+-        if type(left) is _EvoElement:
+-            base = left
+-            factor = right
+-        if type(right) is _EvoElement:
+-            base = right
+-            factor = left
+-        return _EvoElement(base._qobj * factor, base._coefficient)
+-
+-    def __matmul__(left, right):
+-        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
+-            coefficient = left._coefficient * right._coefficient
+-        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
+-            coefficient = left._coefficient
+-        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
+-            coefficient = right._coefficient
+-        else:
+-            return NotImplemented
+-        return _EvoElement(left._qobj * right._qobj, coefficient)
+-
+-    cpdef Data data(self, t):
+-        return self._qobj.data
+-
+-    cpdef object qobj(self, t):
+-        return self._qobj
+-
+-    cpdef object coeff(self, t):
+-        return self._coefficient(t)
+-
+-    def linear_map(self, f, anti=False):
+-        return _EvoElement(
+-            f(self._qobj),
+-            self._coefficient.conj() if anti else self._coefficient,
+-        )
+-
+-    def replace_arguments(self, args, cache=None):
+-        return _EvoElement(
+-            self._qobj.copy(),
+-            self._coefficient.replace_arguments(args)
+-        )
+-
+-
+-cdef class _FuncElement(_BaseElement):
+-    """
+-    Used with :obj:`QobjEvo` to build an evolution term from a function with
+-    either the signature: ::
+-
+-        func(t: float, ...) -> Qobj
+-
+-    or the older QuTiP 4 style signature: ::
+-
+-        func(t: float, args: dict) -> Qobj
+-
+-    In the new style, ``func`` may accept arbitrary named arguments and
+-    is called as ``func(t, **args)``.
+-
+-    A :obj:`QobjEvo` created from such a function contains one
+-    :obj:`_FuncElement`: ::
+-
+-        qevo = QobjEvo(func, args=args)
+-        qevo.elements = [_FuncElement(func, args)]
+-
+-    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
+-    of function and argument.
+-
+-    This class has a basic capacity to memoize calls to ``func`` by saving the
+-    result of the last call ::
+-
+-        op = QobjEvo(func, args=args)
+-        (op.dag() * op)(t)
+-
+-    calls ``func`` only once.
+-
+-    Parameters
+-    ----------
+-    func : callable(t : float, ...) -> Qobj
+-        Function returning the element value at time ``t``.
+-
+-    args : dict
+-        Values of the arguments to pass to ``func``.
+-
+-    style : {None, "pythonic", "dict", "auto"}
+-        The style of the signature used. If style is ``None``,
+-        the value of ``qutip.settings.core["function_coefficient_style"]``
+-        is used. Otherwise the supplied value overrides the global setting.
+-
+-    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
+-    style and parameter detection and are not intended to be part of
+-    the public interface.
+-    """
+-
+-    _UNSET = object()
+-
+-    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
+-        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
+-            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
+-                raise TypeError(
+-                    "_f_pythonic and _f_parameters should always be given together."
+-                )
+-            _f_pythonic, _f_parameters = coefficient_function_parameters(
+-                func, style=style)
+-            if _f_parameters is not None:
+-                args = {k: args[k] for k in _f_parameters & args.keys()}
+-            else:
+-                args = args.copy()
+-        self._func = func
+-        self._args = args
+-        self._f_pythonic = _f_pythonic
+-        self._f_parameters = _f_parameters
+-        self._previous = (Nan, None)
+-
+-    def __mul__(left, right):
+-        cdef _MapElement out
+-        if type(left) is _FuncElement:
+-            out = _MapElement(left, [], right)
+-        if type(right) is _FuncElement:
+-            out = _MapElement(right, [], left)
+-        return out
+-
+-    def __matmul__(left, right):
+-        return _ProdElement(left, right, [])
+-
+-    cpdef Data data(self, t):
+-        return self.qobj(t).data
+-
+-    cpdef object qobj(self, t):
+-        cdef double _t
+-        cdef object _qobj
+-        _t, _qobj = self._previous
+-        if t == _t:
+-            return _qobj
+-        if self._f_pythonic:
+-            _qobj = self._func(t, **self._args)
+-        else:
+-            _qobj = self._func(t, self._args)
+-        self._previous = (t, _qobj)
+-        return _qobj
+-
+-    cpdef object coeff(self, t):
+-        return 1.
+-
+-    def linear_map(self, f, anti=False):
+-        return _MapElement(self, [f])
+-
+-    def replace_arguments(_FuncElement self, args, cache=None):
+-        if self._f_parameters is not None:
+-            args = {k: args[k] for k in self._f_parameters & args.keys()}
+-        if not args:
+-            return self
+-        if cache is not None:
+-            for old, new in cache:
+-                if old is self:
+-                    return new
+-        new = _FuncElement(
+-                self._func,
+-                {**self._args, **args},
+-                _f_pythonic=self._f_pythonic,
+-                _f_parameters=self._f_parameters,
+-        )
+-        if cache is not None:
+-            cache.append((self, new))
+-        return new
+-
+-
+-cdef class _MapElement(_BaseElement):
+-    """
+-    :obj:`_FuncElement` decorated with linear tranformations.
+-
+-    Linear tranformations available in :obj:`QobjEvo` include transpose,
+-    adjoint, conjugate, convertion and product with number::
+-    ```
+-        op = QobjEvo(f, args=args)
+-        op2 = op.conj().dag() * 2
+-    ```
+-    Then ``op2.elements`` is::
+-        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
+-
+-    """
+-    def __init__(self, _FuncElement base, transform, coeff=1.):
+-        self._base = base
+-        self._transform = transform
+-        self._coeff = coeff
+-
+-    def __mul__(left, right):
+-        cdef _MapElement out, self
+-        cdef double complex factor
+-        if type(left) is _MapElement:
+-            self = left
+-            factor = right
+-        elif type(right) is _MapElement:
+-            self = right
+-            factor = left
+-        return _MapElement(
+-            self._base,
+-            self._transform.copy(),
+-            self._coeff*factor
+-        )
+-
+-    def __matmul__(left, right):
+-        return _ProdElement(left, right, [])
+-
+-    cpdef Data data(self, t):
+-        return self.qobj(t).data
+-
+-    cpdef object qobj(self, t):
+-        out = self._base.qobj(t)
+-        for func in self._transform:
+-            out = func(out)
+-        return out
+-
+-    cpdef object coeff(self, t):
+-        return self._coeff
+-
+-    def linear_map(self, f, anti=False):
+-        return _MapElement(
+-            self._base,
+-            self._transform + [f],
+-            conj(self._coeff) if anti else self._coeff
+-        )
+-
+-    def replace_arguments(_MapElement self, args, cache=None):
+-        return _MapElement(
+-            self._base.replace_arguments(args, cache=cache),
+-            self._transform.copy(),
+-            self._coeff,
+-        )
+-
+-
+-cdef class _ProdElement(_BaseElement):
+-    """
+-    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
+-    :obj:`_BaseElement`. Include a stack of linear transformation to be
+-    applied after the product::
+-
+-        ``op = QobjEvo(f) * qobj1``
+-    Then ``op.elements`` is::
+-        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
+-    """
+-    def __init__(self, left, right, transform, conj=False):
+-        self._left = left
+-        self._right = right
+-        self._conj = conj
+-        self._transform = transform
+-
+-    def __mul__(left, right):
+-        cdef _ProdElement self
+-        cdef double complex factor
+-        if type(left) is _ProdElement:
+-            self = left
+-            factor = right
+-        if type(right) is _ProdElement:
+-            self = right
+-            factor = left
+-        return _ProdElement(self._left, self._right * factor,
+-                            self._transform.copy(), self._conj)
+-
+-    def __matmul__(left, right):
+-        return _ProdElement(left, right, [])
+-
+-    cpdef Data data(self, t):
+-        return self.qobj(t).data
+-
+-    cpdef object qobj(self, t):
+-        out = self._left.qobj(t) @ self._right.qobj(t)
+-        for func in self._transform:
+-            out = func(out)
+-        return out
+-
+-    cpdef object coeff(self, t):
+-        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
+-        return conj(out) if self._conj else out
+-
+-    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
+-        cdef Data temp
+-        if not self._transform:
+-            temp = self._right.matmul_data_t(t, state)
+-            out = self._left.matmul_data_t(t, temp, out)
+-            return out
+-        elif type(state) is Dense and type(out) is Dense:
+-            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
+-            return out
+-        else:
+-            return _data.add(
+-                out,
+-                _data.matmul(self.data(t), state, self.coeff(t))
+-            )
+-
+-    def linear_map(self, f, anti=False):
+-        return _ProdElement(
+-            self._left, self._right,
+-            self._transform + [f],
+-            self._conj ^ anti
+-        )
+-
+-    def replace_arguments(_ProdElement self, args, cache=None):
+-        return _ProdElement(
+-            self._left.replace_arguments(args, cache=cache),
+-            self._right.replace_arguments(args, cache=cache),
+-            self._transform.copy(),
+-            self._conj
+-        )
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
++
++from .. import data as _data
++from qutip.core.cy.coefficient import coefficient_function_parameters
++from qutip.core.data cimport Dense, Data, dense
++from qutip.core.data.matmul cimport *
++from math import nan as Nan
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex conj(double complex x)
++
++__all__ = ['_ConstantElement', '_EvoElement',
++           '_FuncElement', '_MapElement', '_ProdElement']
++
++
++cdef class _BaseElement:
++    """
++    The representation of a single time-dependent term in the list of
++    terms used by QobjEvo and solvers to describe operators.
++
++    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
++    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
++    are functions of time. :meth:`~_BaseElement.coeff` returns the
++    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
++
++    For example, a :obj:`QobjEvo` instance created by::
++
++      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
++
++    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
++    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
++
++    :obj:`~_BaseElement` defines the interface to time-dependent terms.
++    Sub-classes implement terms defined in different ways.
++    For example, :obj:`~_ConstantElement` implements a term that
++    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
++    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
++    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
++    so on.
++
++    .. note::
++
++      There are three methods to return the factors of the term.
++
++      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
++      coefficient and operator factors respectively. They are separate to
++      avoid constructing an intermediate Python object when called from
++      Cython code (which may take as long as the rest of the call).
++
++      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
++      provides a convenience method for this common operation.
++
++    .. note::
++
++      All :obj:`~_BaseElement` instances are immutable and methods that would
++      modify an object return a new instance instead.
++    """
++    cpdef Data data(self, t):
++        """
++        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
++        of the term at time ``t``.
++
++        Parameters
++        ----------
++        t : double
++          The time, ``t``.
++
++        Returns
++        -------
++        :obj:`~Data`
++          The underlying data of the :obj:`~Qobj` component of the term
++          at time ``t``.
++        """
++        raise NotImplementedError(
++          "Sub-classes of _BaseElement should implement .data(t)."
++        )
++
++    cpdef object qobj(self, t):
++        """
++        Returns the :obj:`~Qobj` component of the term at time ``t``.
++
++        Parameters
++        ----------
++        t : float
++          The time, ``t``.
++
++        Returns
++        -------
++        :obj:`~Qobj`
++          The :obj:`~Qobj` component of the term at time ``t``.
++        """
++        raise NotImplementedError(
++          "Sub-classes of _BaseElement should implement .qobj(t)."
++        )
++
++    cpdef object coeff(self, t):
++        """
++        Returns the complex coefficient of the term at time ``t``.
++
++        Parameters
++        ----------
++        t : float
++          The time, ``t``.
++
++        Returns
++        -------
++        complex
++          The complex coefficient of the term at time ``t``.
++        """
++        raise NotImplementedError(
++          "Sub-classes of _BaseElement should implement .coeff(t)."
++        )
++
++    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
++        """
++        Possibly in-place multiplication and addition. Multiplies a given state
++        by the elemen's value at time ``t`` and adds the result to ``out``.
++        Equivalent to::
++
++          out += self.coeff(t) * self.qobj(t) @ state
++
++        Sub-classes may override :meth:`~matmul_data_t` to provide an more
++        efficient implementation.
++
++        Parameters
++        ----------
++        t : double
++          The time, ``t``.
++
++        state : :obj:`~Data`
++          The state to multiply by the element term.
++
++        out : :obj:`~Data` or ``NULL``
++          The output to add the result of the multiplication to. If ``NULL``,
++          the result of the multiplication is returned directly (i.e. ``out``
++          is assumed to be the zero matrix).
++
++        Returns
++        -------
++        data
++          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
++          the addition possibly having been performed in-place on ``out``.
++
++        .. note::
++
++          Because of the possibly but not definitely in-place behaviour of
++          this function, the result should always be assigned to some variable
++          and surrounding code should assume that ``out`` maybe have been
++          modified and that the result may be a reference to ``out``. The
++          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
++
++        .. note::
++
++          This method would ideally be implemented using a special
++          function dispatched by the data layer so that it did not have to
++          special case the ``Dense`` operation itself, but the data layer
++          dispatch does not yet support in-place operations. Once it does
++          this method should be updated to use the new support.
++        """
++        if out is None:
++            return _data.matmul(self.data(t), state, self.coeff(t))
++        elif type(state) is Dense and type(out) is Dense:
++            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
++            return out
++        else:
++            return _data.add(
++                out,
++                _data.matmul(self.data(t), state, self.coeff(t))
++            )
++
++    def linear_map(self, f, anti=False):
++        """
++        Return a new element representing a linear transformation ``f``
++        of the :obj:`~Qobj` portion of this element and possibly a
++        complex conjucation of the coefficient portion (when ``f`` is an
++        antilinear map).
++
++        If this element represents ``coeff * qobj`` the returned element
++        represents ``coeff * f(obj)`` (if ``anti=False``) or
++        ``conj(coeff) * f(obj)`` (if ``anti=True``).
++
++        Parameters
++        ----------
++        f : function
++          The linear transformation to apply to the :obj:`~Qobj` of this
++          element.
++        anti : bool
++          Whether to take the complex conjugate of the coefficient. Default
++          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
++          map such as the adjoint (i.e. dagger).
++
++        Returns
++        -------
++        _BaseElement
++          A new element with the transformation applied.
++        """
++        raise NotImplementedError(
++          "Sub-classes of _BaseElement should implement .linear_map(t)."
++        )
++
++    def replace_arguments(self, args, cache=None):
++        """
++        Return a copy of the element with the (possible) additional arguments
++        to any time-dependent functions updated to the given argument values.
++        The arguments of any contained :obj:`~Coefficient` instances are also
++        replaced.
++
++        If the operation does not modify this element, the original element
++        may be returned.
++
++        Parameters
++        ----------
++        args : dict
++          A dictionary of arguments to update. Keys are the names of the
++          arguments and values are the new argument values. Arguments
++          not included retain their original values.
++
++        cache : list or ``None``
++          A cache to add updated elements to. Unmodified elements are not
++          added to the cache. If a cache is supplied and ``.replace_arguments``
++          would be called again on the same element with the same arguments,
++          the new element from the cache will be returned instead.
++
++          By default the cache is ``None`` and no caching is performed. Cache
++          users should supply either ``cache=[]`` (which activates caching)
++          or an existing cache (for example, if making calls on sub-elements
++          of some composite element).
++
++        Returns
++        -------
++        _BaseElement
++          A new element with the arguments replaced, or possibly this element
++          if it would not be modified.
++
++        Example
++        -------
++
++        If ``elem`` is a product element for ``op * op.dag()`` it will contain
++        two references to the same element for ``op``. Calling::
++
++          elem = elem.replace_arguments({"theta": 3.1416})
++
++        will return a new element that contains two *different* copies of
++        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
++        to be evaluated *twice* when ``elem.qobj(t)`` is called.
++
++        Calling instead::
++
++          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
++
++        will return a new element that contains two references to *one* copy
++        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
++        performance when calling ``elem.qobj(t)`` later.
++        """
++        raise NotImplementedError(
++          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
++        )
++
++    def __call__(self, t, args=None):
++        if args:
++            cache = []
++            self = self.replace_arguments(args, cache)
++        return self.qobj(t) * self.coeff(t)
++
++
++cdef class _ConstantElement(_BaseElement):
++    """
++    Constant part of a list format :obj:`QobjEvo`.
++    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
++
++      qevo = QobjEvo(H0)
++      qevo.elements = [_ConstantElement(H0)]
++    """
++    def __init__(self, qobj):
++        self._qobj = qobj
++
++    def __mul__(left, right):
++        if type(left) is _ConstantElement:
++            return _ConstantElement((<_ConstantElement> left)._qobj * right)
++        elif type(right) is _ConstantElement:
++            return _ConstantElement((<_ConstantElement> right)._qobj * left)
++        return NotImplemented
++
++    def __matmul__(left, right):
++        if type(left) is _ConstantElement and type(right) is _ConstantElement:
++            return _ConstantElement(
++                (<_ConstantElement> left)._qobj @
++                (<_ConstantElement> right)._qobj
++            )
++        return NotImplemented
++
++    cpdef Data data(self, t):
++        return self._qobj.data
++
++    cpdef object qobj(self, t):
++        return self._qobj
++
++    cpdef object coeff(self, t):
++        return 1.
++
++    def linear_map(self, f, anti=False):
++        return _ConstantElement(f(self._qobj))
++
++    def replace_arguments(self, args, cache=None):
++        return self
++
++    def __call__(self, t, args=None):
++        return self._qobj
++
++
++cdef class _EvoElement(_BaseElement):
++    """
++    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
++    time-dependent operator::
++
++      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
++      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
++    """
++    def __init__(self, qobj, coefficient):
++        self._qobj = qobj
++        self._coefficient = coefficient
++
++    def __mul__(left, right):
++        cdef _EvoElement base
++        cdef object factor
++        if type(left) is _EvoElement:
++            base = left
++            factor = right
++        if type(right) is _EvoElement:
++            base = right
++            factor = left
++        return _EvoElement(base._qobj * factor, base._coefficient)
++
++    def __matmul__(left, right):
++        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
++            coefficient = left._coefficient * right._coefficient
++        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
++            coefficient = left._coefficient
++        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
++            coefficient = right._coefficient
++        else:
++            return NotImplemented
++        return _EvoElement(left._qobj * right._qobj, coefficient)
++
++    cpdef Data data(self, t):
++        return self._qobj.data
++
++    cpdef object qobj(self, t):
++        return self._qobj
++
++    cpdef object coeff(self, t):
++        return self._coefficient(t)
++
++    def linear_map(self, f, anti=False):
++        return _EvoElement(
++            f(self._qobj),
++            self._coefficient.conj() if anti else self._coefficient,
++        )
++
++    def replace_arguments(self, args, cache=None):
++        return _EvoElement(
++            self._qobj.copy(),
++            self._coefficient.replace_arguments(args)
++        )
++
++
++cdef class _FuncElement(_BaseElement):
++    """
++    Used with :obj:`QobjEvo` to build an evolution term from a function with
++    either the signature: ::
++
++        func(t: float, ...) -> Qobj
++
++    or the older QuTiP 4 style signature: ::
++
++        func(t: float, args: dict) -> Qobj
++
++    In the new style, ``func`` may accept arbitrary named arguments and
++    is called as ``func(t, **args)``.
++
++    A :obj:`QobjEvo` created from such a function contains one
++    :obj:`_FuncElement`: ::
++
++        qevo = QobjEvo(func, args=args)
++        qevo.elements = [_FuncElement(func, args)]
++
++    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
++    of function and argument.
++
++    This class has a basic capacity to memoize calls to ``func`` by saving the
++    result of the last call ::
++
++        op = QobjEvo(func, args=args)
++        (op.dag() * op)(t)
++
++    calls ``func`` only once.
++
++    Parameters
++    ----------
++    func : callable(t : float, ...) -> Qobj
++        Function returning the element value at time ``t``.
++
++    args : dict
++        Values of the arguments to pass to ``func``.
++
++    style : {None, "pythonic", "dict", "auto"}
++        The style of the signature used. If style is ``None``,
++        the value of ``qutip.settings.core["function_coefficient_style"]``
++        is used. Otherwise the supplied value overrides the global setting.
++
++    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
++    style and parameter detection and are not intended to be part of
++    the public interface.
++    """
++
++    _UNSET = object()
++
++    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
++        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
++            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
++                raise TypeError(
++                    "_f_pythonic and _f_parameters should always be given together."
++                )
++            _f_pythonic, _f_parameters = coefficient_function_parameters(
++                func, style=style)
++            if _f_parameters is not None:
++                args = {k: args[k] for k in _f_parameters & args.keys()}
++            else:
++                args = args.copy()
++        self._func = func
++        self._args = args
++        self._f_pythonic = _f_pythonic
++        self._f_parameters = _f_parameters
++        self._previous = (Nan, None)
++
++    def __mul__(left, right):
++        cdef _MapElement out
++        if type(left) is _FuncElement:
++            out = _MapElement(left, [], right)
++        if type(right) is _FuncElement:
++            out = _MapElement(right, [], left)
++        return out
++
++    def __matmul__(left, right):
++        return _ProdElement(left, right, [])
++
++    cpdef Data data(self, t):
++        return self.qobj(t).data
++
++    cpdef object qobj(self, t):
++        cdef double _t
++        cdef object _qobj
++        _t, _qobj = self._previous
++        if t == _t:
++            return _qobj
++        if self._f_pythonic:
++            _qobj = self._func(t, **self._args)
++        else:
++            _qobj = self._func(t, self._args)
++        self._previous = (t, _qobj)
++        return _qobj
++
++    cpdef object coeff(self, t):
++        return 1.
++
++    def linear_map(self, f, anti=False):
++        return _MapElement(self, [f])
++
++    def replace_arguments(_FuncElement self, args, cache=None):
++        if self._f_parameters is not None:
++            args = {k: args[k] for k in self._f_parameters & args.keys()}
++        if not args:
++            return self
++        if cache is not None:
++            for old, new in cache:
++                if old is self:
++                    return new
++        new = _FuncElement(
++                self._func,
++                {**self._args, **args},
++                _f_pythonic=self._f_pythonic,
++                _f_parameters=self._f_parameters,
++        )
++        if cache is not None:
++            cache.append((self, new))
++        return new
++
++
++cdef class _MapElement(_BaseElement):
++    """
++    :obj:`_FuncElement` decorated with linear tranformations.
++
++    Linear tranformations available in :obj:`QobjEvo` include transpose,
++    adjoint, conjugate, convertion and product with number::
++    ```
++        op = QobjEvo(f, args=args)
++        op2 = op.conj().dag() * 2
++    ```
++    Then ``op2.elements`` is::
++        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
++
++    """
++    def __init__(self, _FuncElement base, transform, coeff=1.):
++        self._base = base
++        self._transform = transform
++        self._coeff = coeff
++
++    def __mul__(left, right):
++        cdef _MapElement out, self
++        cdef double complex factor
++        if type(left) is _MapElement:
++            self = left
++            factor = right
++        elif type(right) is _MapElement:
++            self = right
++            factor = left
++        return _MapElement(
++            self._base,
++            self._transform.copy(),
++            self._coeff*factor
++        )
++
++    def __matmul__(left, right):
++        return _ProdElement(left, right, [])
++
++    cpdef Data data(self, t):
++        return self.qobj(t).data
++
++    cpdef object qobj(self, t):
++        out = self._base.qobj(t)
++        for func in self._transform:
++            out = func(out)
++        return out
++
++    cpdef object coeff(self, t):
++        return self._coeff
++
++    def linear_map(self, f, anti=False):
++        return _MapElement(
++            self._base,
++            self._transform + [f],
++            conj(self._coeff) if anti else self._coeff
++        )
++
++    def replace_arguments(_MapElement self, args, cache=None):
++        return _MapElement(
++            self._base.replace_arguments(args, cache=cache),
++            self._transform.copy(),
++            self._coeff,
++        )
++
++
++cdef class _ProdElement(_BaseElement):
++    """
++    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
++    :obj:`_BaseElement`. Include a stack of linear transformation to be
++    applied after the product::
++
++        ``op = QobjEvo(f) * qobj1``
++    Then ``op.elements`` is::
++        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
++    """
++    def __init__(self, left, right, transform, conj=False):
++        self._left = left
++        self._right = right
++        self._conj = conj
++        self._transform = transform
++
++    def __mul__(left, right):
++        cdef _ProdElement self
++        cdef double complex factor
++        if type(left) is _ProdElement:
++            self = left
++            factor = right
++        if type(right) is _ProdElement:
++            self = right
++            factor = left
++        return _ProdElement(self._left, self._right * factor,
++                            self._transform.copy(), self._conj)
++
++    def __matmul__(left, right):
++        return _ProdElement(left, right, [])
++
++    cpdef Data data(self, t):
++        return self.qobj(t).data
++
++    cpdef object qobj(self, t):
++        out = self._left.qobj(t) @ self._right.qobj(t)
++        for func in self._transform:
++            out = func(out)
++        return out
++
++    cpdef object coeff(self, t):
++        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
++        return conj(out) if self._conj else out
++
++    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
++        cdef Data temp
++        if not self._transform:
++            temp = self._right.matmul_data_t(t, state)
++            out = self._left.matmul_data_t(t, temp, out)
++            return out
++        elif type(state) is Dense and type(out) is Dense:
++            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
++            return out
++        else:
++            return _data.add(
++                out,
++                _data.matmul(self.data(t), state, self.coeff(t))
++            )
++
++    def linear_map(self, f, anti=False):
++        return _ProdElement(
++            self._left, self._right,
++            self._transform + [f],
++            self._conj ^ anti
++        )
++
++    def replace_arguments(_ProdElement self, args, cache=None):
++        return _ProdElement(
++            self._left.replace_arguments(args, cache=cache),
++            self._right.replace_arguments(args, cache=cache),
++            self._transform.copy(),
++            self._conj
++        )
+diff --git a/qutip/core/cy/coefficient.pxd b/qutip/core/cy/coefficient.pxd
+index f81858c2..c4824b7d 100644
+--- a/qutip/core/cy/coefficient.pxd
++++ b/qutip/core/cy/coefficient.pxd
+@@ -1,5 +1,5 @@
+-#cython: language_level=3
+-cdef class Coefficient:
+-    cdef readonly dict args
+-    cdef double complex _call(self, double t) except *
+-    cpdef Coefficient copy(self)
++#cython: language_level=3
++cdef class Coefficient:
++    cdef readonly dict args
++    cdef double complex _call(self, double t) except *
++    cpdef Coefficient copy(self)
+diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
+index 79fd84e5..b2755c3a 100644
+--- a/qutip/core/cy/coefficient.pyx
++++ b/qutip/core/cy/coefficient.pyx
+@@ -1,728 +1,728 @@
+-#cython: language_level=3
+-import inspect
+-import pickle
+-import scipy
+-from scipy.interpolate import make_interp_spline
+-import numpy as np
+-cimport numpy as cnp
+-cimport cython
+-import qutip
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex conj(double complex x)
+-    double         norm(double complex x)
+-
+-
+-def coefficient_function_parameters(func, style=None):
+-    """
+-    Return the function style (either "pythonic" or not) and a list of
+-    additional parameters accepted.
+-
+-    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
+-    call signature of the supplied function based on the given style (or
+-    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
+-    and the signature of the given function.
+-
+-    Parameters
+-    ----------
+-    func : function
+-        The :obj:`FunctionCoefficient` to inspect. The first argument
+-        of the function is assumed to be ``t`` (the time at which to
+-        evaluate the coefficient). The remaining arguments depend on
+-        the signature style (see below).
+-
+-    style : {None, "pythonic", "dict", "auto"}
+-        The style of the signature used. If style is ``None``,
+-        the value of ``qutip.settings.core["function_coefficient_style"]``
+-        is used. Otherwise the supplied value overrides the global setting.
+-
+-    Returns
+-    -------
+-    (f_pythonic, f_parameters)
+-
+-    f_pythonic : bool
+-        True if the function should be called as ``f(t, **kw)`` and False
+-        if the function should be called as ``f(t, kw_dict)``.
+-
+-    f_parameters : set or None
+-        The set of parameters (other than ``t``) of the function or
+-        ``None`` if the function accepts arbitrary parameters.
+-    """
+-    sig = inspect.signature(func)
+-    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
+-    if style is None:
+-        style = qutip.settings.core["function_coefficient_style"]
+-    if style == "auto":
+-        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
+-            # if the signature is exactly f(t, args), then assume parameters
+-            # are supplied in an argument dictionary
+-            style = "dict"
+-        else:
+-            style = "pythonic"
+-    if style == "dict" or f_has_kw:
+-        # f might accept any parameter
+-        f_parameters = None
+-    else:
+-        # f accepts only t and the named parameters
+-        f_parameters = set(list(sig.parameters.keys())[1:])
+-    return (style == "pythonic", f_parameters)
+-
+-
+-cdef class Coefficient:
+-    """
+-    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
+-    composing time-dependant operator in list format for :obj:`QobjEvo`.
+-
+-    :obj:`Coefficient` are immutable.
+-    """
+-    def __init__(self, args, **_):
+-        self.args = args
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        return self
+-
+-    def __call__(self, t, dict _args=None, **kwargs):
+-        """
+-        Return the coefficient value at time `t`.
+-        Stored arguments can overwriten with `_args` or as keywords parameters.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time at which to evaluate the :obj:`Coefficient`.
+-
+-        _args : dict
+-            Dictionary of arguments to use instead of the stored ones.
+-
+-        **kwargs
+-            Arguments to overwrite for this call.
+-        """
+-        if _args is not None or kwargs:
+-            return (<Coefficient> self.replace_arguments(_args,
+-                                                         **kwargs))._call(t)
+-        return self._call(t)
+-
+-    cdef double complex _call(self, double t) except *:
+-        """Core computation of the :obj:`Coefficient`."""
+-        # All Coefficient sub-classes should overwrite this or __call__
+-        return complex(self(t))
+-
+-    def __add__(left, right):
+-        if (
+-            isinstance(left, InterCoefficient)
+-            and isinstance(right, InterCoefficient)
+-        ):
+-            return add_inter(left, right)
+-        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
+-            return SumCoefficient(left.copy(), right.copy())
+-        return NotImplemented
+-
+-    def __mul__(left, right):
+-        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
+-            return MulCoefficient(left.copy(), right.copy())
+-        if isinstance(left, qutip.Qobj):
+-            return qutip.QobjEvo([left.copy(), right.copy()])
+-        if isinstance(right, qutip.Qobj):
+-            return qutip.QobjEvo([right.copy(), left.copy()])
+-        return NotImplemented
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return pickle.loads(pickle.dumps(self))
+-
+-    def conj(self):
+-        """ Return a conjugate :obj:`Coefficient` of this"""
+-        return ConjCoefficient(self)
+-
+-    def _cdc(self):
+-        """ Return a :obj:`Coefficient` being the norm of this"""
+-        return NormCoefficient(self)
+-
+-
+-@cython.auto_pickle(True)
+-cdef class FunctionCoefficient(Coefficient):
+-    """
+-    :obj:`Coefficient` wrapping a Python function.
+-
+-    Parameters
+-    ----------
+-    func : callable(t : float, ...) -> complex
+-        Function returning the coefficient value at time ``t``.
+-
+-    args : dict
+-        Values of the arguments to pass to ``func``.
+-
+-    style : {None, "pythonic", "dict", "auto"}
+-        The style of function signature used. If style is ``None``,
+-        the value of ``qutip.settings.core["function_coefficient_style"]``
+-        is used. Otherwise the supplied value overrides the global setting.
+-
+-    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
+-    style and parameter detection and are not intended to be part of
+-    the public interface.
+-    """
+-    cdef object func
+-    cdef bint _f_pythonic
+-    cdef set _f_parameters
+-
+-    _UNSET = object()
+-
+-    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
+-                 _f_parameters=_UNSET, **_):
+-        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
+-            if not (_f_pythonic is self._UNSET
+-                    and _f_parameters is self._UNSET):
+-                raise TypeError(
+-                    "_f_pythonic and _f_parameters should "
+-                    "always be given together."
+-                )
+-            _f_pythonic, _f_parameters = coefficient_function_parameters(
+-                func, style=style)
+-            if _f_parameters is not None:
+-                args = {k: args[k] for k in _f_parameters & args.keys()}
+-            else:
+-                args = args.copy()
+-        self.func = func
+-        self.args = args
+-        self._f_pythonic = _f_pythonic
+-        self._f_parameters = _f_parameters
+-
+-    def __call__(self, t, dict _args=None, **kwargs):
+-        if _args is not None or kwargs:
+-            return self.replace_arguments(_args, **kwargs)(t)
+-        if self._f_pythonic:
+-            return self.func(t, **self.args)
+-        return self.func(t, self.args)
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return FunctionCoefficient(
+-            self.func,
+-            self.args.copy(),
+-            _f_pythonic=self._f_pythonic,
+-            _f_parameters=self._f_parameters,
+-        )
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        if _args:
+-            kwargs.update(_args)
+-        if self._f_parameters is not None:
+-            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
+-        if not kwargs:
+-            return self
+-        return FunctionCoefficient(
+-            self.func,
+-            {**self.args, **kwargs},
+-            _f_pythonic=self._f_pythonic,
+-            _f_parameters=self._f_parameters,
+-        )
+-
+-
+-def proj(x):
+-    if np.isfinite(x):
+-        return (x)
+-    else:
+-        return np.inf + 0j * np.imag(x)
+-
+-
+-cdef class StrFunctionCoefficient(Coefficient):
+-    """
+-    A :obj:`Coefficient` defined by a string containing a simple Python
+-    expression.
+-
+-    The string should contain a compilable Python expression that results in a
+-    complex number. The time ``t`` is available as a local variable, as are the
+-    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
+-    itself is not accessible.
+-
+-    The following symbols are defined:
+-        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
+-        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
+-        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
+-        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
+-        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
+-
+-    Examples
+-    --------
+-    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
+-
+-    Parameters
+-    ----------
+-    base : str
+-        A string representing a compilable Python expression that results in a
+-        complex number.
+-
+-    args : dict
+-        A dictionary of variable used in the code string. It may include unused
+-        variables.
+-    """
+-    cdef object func
+-    cdef str base
+-
+-    str_env = {
+-        "sin": np.sin,
+-        "cos": np.cos,
+-        "tan": np.tan,
+-        "asin": np.arcsin,
+-        "acos": np.arccos,
+-        "atan": np.arctan,
+-        "pi": np.pi,
+-        "sinh": np.sinh,
+-        "cosh": np.cosh,
+-        "tanh": np.tanh,
+-        "asinh": np.arcsinh,
+-        "acosh": np.arccosh,
+-        "atanh": np.arctanh,
+-        "exp": np.exp,
+-        "log": np.log,
+-        "log10": np.log10,
+-        "erf": scipy.special.erf,
+-        "zerf": scipy.special.erf,
+-        "sqrt": np.sqrt,
+-        "real": np.real,
+-        "imag": np.imag,
+-        "conj": np.conj,
+-        "abs": np.abs,
+-        "norm": lambda x: np.abs(x)**2,
+-        "arg": np.angle,
+-        "proj": proj,
+-        "np": np,
+-        "spe": scipy.special}
+-
+-    def __init__(self, base, dict args, **_):
+-        args2var = "\n".join(["    {} = args['{}']".format(key, key)
+-                              for key in args])
+-        code = f"""
+-def coeff(t, args):
+-{args2var}
+-    return {base}"""
+-        lc = {}
+-        exec(code, self.str_env, lc)
+-        self.base = base
+-        self.func = lc["coeff"]
+-        self.args = args
+-
+-    cdef complex _call(self, double t) except *:
+-        return self.func(t, self.args)
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return StrFunctionCoefficient(self.base, self.args.copy())
+-
+-    def __reduce__(self):
+-        return (StrFunctionCoefficient, (self.base, self.args))
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        if _args:
+-            kwargs.update(_args)
+-        if kwargs:
+-            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
+-        return self
+-
+-
+-cdef class InterCoefficient(Coefficient):
+-    """
+-    A :obj:`Coefficient` built from an interpolation of a numpy array.
+-
+-    Parameters
+-    ----------
+-    coeff_arr : np.ndarray
+-        The array of coefficient values to interpolate.
+-
+-    tlist : np.ndarray
+-        An array of times corresponding to each coefficient value. The times
+-        must be increasing, but do not need to be uniformly spaced.
+-
+-    order : int
+-        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
+-        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
+-
+-    boundary_conditions : 2-Tuple, str or None, optional
+-        Boundary conditions for spline evaluation. Default value is `None`.
+-        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+-        Refer to Scipy's documentation for further details:
+-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+-    """
+-    cdef int order
+-    cdef double dt
+-    cdef double[::1] tlist
+-    cdef complex[:, :] poly
+-    cdef object np_arrays
+-
+-    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
+-        tlist = np.array(tlist, dtype=np.float64)
+-        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
+-
+-        if coeff_arr.ndim != 1:
+-            raise ValueError("The array to interpolate must be a 1D array")
+-        if coeff_arr.shape != tlist.shape:
+-            raise ValueError("tlist must be the same len "
+-                             "as the array to interpolate")
+-        if order < 0:
+-            raise ValueError("order must be a positive integer")
+-
+-        order = min(order, len(tlist) - 1)
+-
+-        if order == 0:
+-            coeff_arr = coeff_arr.reshape((1, -1))
+-        elif order == 1:
+-            coeff_arr = np.vstack([
+-                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
+-                    coeff_arr
+-                ])
+-        elif order >= 2:
+-            # Use scipy to compute the spline and transform it to polynomes
+-            # as used in scipy's PPoly which is easier for us to use.
+-            spline = make_interp_spline(tlist, coeff_arr, k=order,
+-                                        bc_type=boundary_conditions)
+-            # Scipy can move knots, we add them to tlist
+-            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
+-            a = np.arange(spline.k+1)
+-            a[0] = 1
+-            fact = np.cumprod(a)
+-            coeff_arr = np.concatenate([
+-                spline(tlist, i) / fact[i]
+-                for i in range(spline.k, -1, -1)
+-            ]).reshape((spline.k+1, -1))
+-
+-        self._prepare(tlist, coeff_arr)
+-
+-    def _prepare(self, np_tlist, np_poly, dt=None):
+-        self.np_arrays = (np_tlist, np_poly)
+-        self.tlist = np_tlist
+-        self.poly = np_poly
+-        self.order = self.poly.shape[0] - 1
+-        diff = np.diff(self.np_arrays[0])
+-        if dt is not None:
+-            self.dt = dt
+-        elif len(diff) >= 1 and np.allclose(diff[0], diff):
+-            self.dt = diff[0]
+-        else:
+-            self.dt = 0
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef size_t _binary_search(self, double x):
+-        # Binary search for the interval
+-        # return the indice of the of the biggest element where t <= x
+-        cdef size_t low = 0
+-        cdef size_t high = self.tlist.shape[0]
+-        cdef size_t middle
+-        cdef size_t count = 0
+-        while low+1 != high and count < 64:
+-            middle = (low + high)//2
+-            if x < self.tlist[middle]:
+-                high = middle
+-            else:
+-                low = middle
+-            # We keep a count to be sure that it never get into an infinit loop
+-            # even if tlist has an unexpected format.
+-            count += 1
+-        return low
+-
+-    @cython.initializedcheck(False)
+-    @cython.cdivision(True)
+-    cdef double complex _call(self, double t) except *:
+-        cdef size_t idx, i
+-        cdef double factor
+-        cdef double complex out
+-        cdef double complex[:] slice
+-        if t <= self.tlist[0]:
+-            return self.poly[-1, 0]
+-        elif t >= self.tlist[-1]:
+-            return self.poly[-1, -1]
+-        if self.dt:
+-            idx = <size_t>((t - self.tlist[0]) / self.dt)
+-        else:
+-            idx = self._binary_search(t)
+-        if self.order == 0:
+-            out = self.poly[0, idx]
+-        else:
+-            factor = t - self.tlist[idx]
+-            slice = self.poly[:, idx]
+-            out = 0.
+-            for i in range(self.order+1):
+-                out *= factor
+-                out += slice[i]
+-        return out
+-
+-    def __reduce__(self):
+-        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
+-
+-    @classmethod
+-    def restore(cls, np_tlist, np_poly, dt=None):
+-        cdef InterCoefficient out = cls.__new__(cls)
+-        out._prepare(np_tlist, np_poly, dt)
+-        return out
+-
+-    @classmethod
+-    def from_PPoly(cls, ppoly, **_):
+-        return cls.restore(ppoly.x, ppoly.c)
+-
+-    @classmethod
+-    def from_Bspline(cls, spline, **_):
+-        tlist = np.unique(spline.t)
+-        a = np.arange(spline.k+1)
+-        a[0] = 1
+-        fact = np.cumprod(a) + 0j
+-        poly = np.concatenate([
+-            spline(tlist, i) / fact[i]
+-            for i in range(spline.k, -1, -1)
+-        ]).reshape((spline.k+1, -1))
+-        return cls.restore(tlist, poly)
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return InterCoefficient.restore(*self.np_arrays, self.dt)
+-
+-
+-cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
+-    """ Add two array coefficient with matching tlist into one."""
+-    if (
+-        left.np_arrays[0].shape == right.np_arrays[0].shape
+-        and np.allclose(left.np_arrays[0], right.np_arrays[0],
+-                        rtol=1e-15, atol=1e-15)
+-        and (left.order == right.order)
+-    ):
+-        return InterCoefficient.restore(
+-            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
+-            left.dt
+-        )
+-    else:
+-        # It would be possible to add them by merging tlist.
+-        return SumCoefficient(left, right)
+-
+-
+-@cython.auto_pickle(True)
+-cdef class SumCoefficient(Coefficient):
+-    """
+-    A :obj:`Coefficient` built from the sum of two other coefficients.
+-
+-    A :obj:`SumCoefficient` is returned as the result of the addition of two
+-    coefficients, e.g. ::
+-
+-        coefficient("t * t") + coefficient("t")  # SumCoefficient
+-    """
+-    cdef Coefficient first
+-    cdef Coefficient second
+-
+-    def __init__(self, Coefficient first, Coefficient second):
+-        self.first = first
+-        self.second = second
+-
+-    cdef complex _call(self, double t) except *:
+-        return self.first._call(t) + self.second._call(t)
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return SumCoefficient(self.first.copy(), self.second.copy())
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        return SumCoefficient(
+-            self.first.replace_arguments(_args, **kwargs),
+-            self.second.replace_arguments(_args, **kwargs)
+-        )
+-
+-
+-@cython.auto_pickle(True)
+-cdef class MulCoefficient(Coefficient):
+-    """
+-    A :obj:`Coefficient` built from the product of two other coefficients.
+-
+-    A :obj:`MulCoefficient` is returned as the result of the multiplication of
+-    two coefficients, e.g. ::
+-
+-        coefficient("w * t", args={'w': 1}) * coefficient("t")
+-    """
+-    cdef Coefficient first
+-    cdef Coefficient second
+-
+-    def __init__(self, Coefficient first, Coefficient second):
+-        self.first = first
+-        self.second = second
+-
+-    cdef complex _call(self, double t) except *:
+-        return self.first._call(t) * self.second._call(t)
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return MulCoefficient(self.first.copy(), self.second.copy())
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        return MulCoefficient(
+-            self.first.replace_arguments(_args, **kwargs),
+-            self.second.replace_arguments(_args, **kwargs)
+-        )
+-
+-
+-@cython.auto_pickle(True)
+-cdef class ConjCoefficient(Coefficient):
+-    """
+-    The conjugate of a :obj:`Coefficient`.
+-
+-    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
+-    ``qutip.coefficent.conj(Coefficient)``.
+-    """
+-    cdef Coefficient base
+-
+-    def __init__(self, Coefficient base):
+-        self.base = base
+-
+-    cdef complex _call(self, double t) except *:
+-        return conj(self.base._call(t))
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return ConjCoefficient(self.base.copy())
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        return ConjCoefficient(
+-            self.base.replace_arguments(_args, **kwargs)
+-        )
+-
+-
+-@cython.auto_pickle(True)
+-cdef class NormCoefficient(Coefficient):
+-    """
+-    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
+-    ``conj(coeff) * coeff``.
+-
+-    :obj:`NormCoefficient` is returned by
+-    ``qutip.coefficent.norm(Coefficient)``.
+-    """
+-    cdef Coefficient base
+-
+-    def __init__(self, Coefficient base):
+-        self.base = base
+-
+-    def replace_arguments(self, _args=None, **kwargs):
+-        """
+-        Replace the arguments (``args``) of a coefficient.
+-
+-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+-        the original coefficient if it does not. Arguments to replace may be
+-        supplied either in a dictionary as the first position argument, or
+-        passed as keywords, or as a combination of the two. Arguments not
+-        replaced retain their previous values.
+-
+-        Parameters
+-        ----------
+-        _args : dict
+-            Dictionary of arguments to replace.
+-
+-        **kwargs
+-            Arguments to replace.
+-        """
+-        return NormCoefficient(
+-            self.base.replace_arguments(_args, **kwargs)
+-        )
+-
+-    cdef complex _call(self, double t) except *:
+-        return norm(self.base._call(t))
+-
+-    cpdef Coefficient copy(self):
+-        """Return a copy of the :obj:`Coefficient`."""
+-        return NormCoefficient(self.base.copy())
++#cython: language_level=3
++import inspect
++import pickle
++import scipy
++from scipy.interpolate import make_interp_spline
++import numpy as np
++cimport numpy as cnp
++cimport cython
++import qutip
++
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex conj(double complex x)
++    double         norm(double complex x)
++
++
++def coefficient_function_parameters(func, style=None):
++    """
++    Return the function style (either "pythonic" or not) and a list of
++    additional parameters accepted.
++
++    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
++    call signature of the supplied function based on the given style (or
++    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
++    and the signature of the given function.
++
++    Parameters
++    ----------
++    func : function
++        The :obj:`FunctionCoefficient` to inspect. The first argument
++        of the function is assumed to be ``t`` (the time at which to
++        evaluate the coefficient). The remaining arguments depend on
++        the signature style (see below).
++
++    style : {None, "pythonic", "dict", "auto"}
++        The style of the signature used. If style is ``None``,
++        the value of ``qutip.settings.core["function_coefficient_style"]``
++        is used. Otherwise the supplied value overrides the global setting.
++
++    Returns
++    -------
++    (f_pythonic, f_parameters)
++
++    f_pythonic : bool
++        True if the function should be called as ``f(t, **kw)`` and False
++        if the function should be called as ``f(t, kw_dict)``.
++
++    f_parameters : set or None
++        The set of parameters (other than ``t``) of the function or
++        ``None`` if the function accepts arbitrary parameters.
++    """
++    sig = inspect.signature(func)
++    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
++    if style is None:
++        style = qutip.settings.core["function_coefficient_style"]
++    if style == "auto":
++        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
++            # if the signature is exactly f(t, args), then assume parameters
++            # are supplied in an argument dictionary
++            style = "dict"
++        else:
++            style = "pythonic"
++    if style == "dict" or f_has_kw:
++        # f might accept any parameter
++        f_parameters = None
++    else:
++        # f accepts only t and the named parameters
++        f_parameters = set(list(sig.parameters.keys())[1:])
++    return (style == "pythonic", f_parameters)
++
++
++cdef class Coefficient:
++    """
++    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
++    composing time-dependant operator in list format for :obj:`QobjEvo`.
++
++    :obj:`Coefficient` are immutable.
++    """
++    def __init__(self, args, **_):
++        self.args = args
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        return self
++
++    def __call__(self, t, dict _args=None, **kwargs):
++        """
++        Return the coefficient value at time `t`.
++        Stored arguments can overwriten with `_args` or as keywords parameters.
++
++        Parameters
++        ----------
++        t : float
++            Time at which to evaluate the :obj:`Coefficient`.
++
++        _args : dict
++            Dictionary of arguments to use instead of the stored ones.
++
++        **kwargs
++            Arguments to overwrite for this call.
++        """
++        if _args is not None or kwargs:
++            return (<Coefficient> self.replace_arguments(_args,
++                                                         **kwargs))._call(t)
++        return self._call(t)
++
++    cdef double complex _call(self, double t) except *:
++        """Core computation of the :obj:`Coefficient`."""
++        # All Coefficient sub-classes should overwrite this or __call__
++        return complex(self(t))
++
++    def __add__(left, right):
++        if (
++            isinstance(left, InterCoefficient)
++            and isinstance(right, InterCoefficient)
++        ):
++            return add_inter(left, right)
++        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
++            return SumCoefficient(left.copy(), right.copy())
++        return NotImplemented
++
++    def __mul__(left, right):
++        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
++            return MulCoefficient(left.copy(), right.copy())
++        if isinstance(left, qutip.Qobj):
++            return qutip.QobjEvo([left.copy(), right.copy()])
++        if isinstance(right, qutip.Qobj):
++            return qutip.QobjEvo([right.copy(), left.copy()])
++        return NotImplemented
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return pickle.loads(pickle.dumps(self))
++
++    def conj(self):
++        """ Return a conjugate :obj:`Coefficient` of this"""
++        return ConjCoefficient(self)
++
++    def _cdc(self):
++        """ Return a :obj:`Coefficient` being the norm of this"""
++        return NormCoefficient(self)
++
++
++@cython.auto_pickle(True)
++cdef class FunctionCoefficient(Coefficient):
++    """
++    :obj:`Coefficient` wrapping a Python function.
++
++    Parameters
++    ----------
++    func : callable(t : float, ...) -> complex
++        Function returning the coefficient value at time ``t``.
++
++    args : dict
++        Values of the arguments to pass to ``func``.
++
++    style : {None, "pythonic", "dict", "auto"}
++        The style of function signature used. If style is ``None``,
++        the value of ``qutip.settings.core["function_coefficient_style"]``
++        is used. Otherwise the supplied value overrides the global setting.
++
++    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
++    style and parameter detection and are not intended to be part of
++    the public interface.
++    """
++    cdef object func
++    cdef bint _f_pythonic
++    cdef set _f_parameters
++
++    _UNSET = object()
++
++    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
++                 _f_parameters=_UNSET, **_):
++        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
++            if not (_f_pythonic is self._UNSET
++                    and _f_parameters is self._UNSET):
++                raise TypeError(
++                    "_f_pythonic and _f_parameters should "
++                    "always be given together."
++                )
++            _f_pythonic, _f_parameters = coefficient_function_parameters(
++                func, style=style)
++            if _f_parameters is not None:
++                args = {k: args[k] for k in _f_parameters & args.keys()}
++            else:
++                args = args.copy()
++        self.func = func
++        self.args = args
++        self._f_pythonic = _f_pythonic
++        self._f_parameters = _f_parameters
++
++    def __call__(self, t, dict _args=None, **kwargs):
++        if _args is not None or kwargs:
++            return self.replace_arguments(_args, **kwargs)(t)
++        if self._f_pythonic:
++            return self.func(t, **self.args)
++        return self.func(t, self.args)
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return FunctionCoefficient(
++            self.func,
++            self.args.copy(),
++            _f_pythonic=self._f_pythonic,
++            _f_parameters=self._f_parameters,
++        )
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        if _args:
++            kwargs.update(_args)
++        if self._f_parameters is not None:
++            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
++        if not kwargs:
++            return self
++        return FunctionCoefficient(
++            self.func,
++            {**self.args, **kwargs},
++            _f_pythonic=self._f_pythonic,
++            _f_parameters=self._f_parameters,
++        )
++
++
++def proj(x):
++    if np.isfinite(x):
++        return (x)
++    else:
++        return np.inf + 0j * np.imag(x)
++
++
++cdef class StrFunctionCoefficient(Coefficient):
++    """
++    A :obj:`Coefficient` defined by a string containing a simple Python
++    expression.
++
++    The string should contain a compilable Python expression that results in a
++    complex number. The time ``t`` is available as a local variable, as are the
++    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
++    itself is not accessible.
++
++    The following symbols are defined:
++        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
++        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
++        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
++        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
++        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
++
++    Examples
++    --------
++    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
++
++    Parameters
++    ----------
++    base : str
++        A string representing a compilable Python expression that results in a
++        complex number.
++
++    args : dict
++        A dictionary of variable used in the code string. It may include unused
++        variables.
++    """
++    cdef object func
++    cdef str base
++
++    str_env = {
++        "sin": np.sin,
++        "cos": np.cos,
++        "tan": np.tan,
++        "asin": np.arcsin,
++        "acos": np.arccos,
++        "atan": np.arctan,
++        "pi": np.pi,
++        "sinh": np.sinh,
++        "cosh": np.cosh,
++        "tanh": np.tanh,
++        "asinh": np.arcsinh,
++        "acosh": np.arccosh,
++        "atanh": np.arctanh,
++        "exp": np.exp,
++        "log": np.log,
++        "log10": np.log10,
++        "erf": scipy.special.erf,
++        "zerf": scipy.special.erf,
++        "sqrt": np.sqrt,
++        "real": np.real,
++        "imag": np.imag,
++        "conj": np.conj,
++        "abs": np.abs,
++        "norm": lambda x: np.abs(x)**2,
++        "arg": np.angle,
++        "proj": proj,
++        "np": np,
++        "spe": scipy.special}
++
++    def __init__(self, base, dict args, **_):
++        args2var = "\n".join(["    {} = args['{}']".format(key, key)
++                              for key in args])
++        code = f"""
++def coeff(t, args):
++{args2var}
++    return {base}"""
++        lc = {}
++        exec(code, self.str_env, lc)
++        self.base = base
++        self.func = lc["coeff"]
++        self.args = args
++
++    cdef complex _call(self, double t) except *:
++        return self.func(t, self.args)
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return StrFunctionCoefficient(self.base, self.args.copy())
++
++    def __reduce__(self):
++        return (StrFunctionCoefficient, (self.base, self.args))
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        if _args:
++            kwargs.update(_args)
++        if kwargs:
++            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
++        return self
++
++
++cdef class InterCoefficient(Coefficient):
++    """
++    A :obj:`Coefficient` built from an interpolation of a numpy array.
++
++    Parameters
++    ----------
++    coeff_arr : np.ndarray
++        The array of coefficient values to interpolate.
++
++    tlist : np.ndarray
++        An array of times corresponding to each coefficient value. The times
++        must be increasing, but do not need to be uniformly spaced.
++
++    order : int
++        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
++        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
++
++    boundary_conditions : 2-Tuple, str or None, optional
++        Boundary conditions for spline evaluation. Default value is `None`.
++        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
++        Refer to Scipy's documentation for further details:
++        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
++    """
++    cdef int order
++    cdef double dt
++    cdef double[::1] tlist
++    cdef complex[:, :] poly
++    cdef object np_arrays
++
++    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
++        tlist = np.array(tlist, dtype=np.float64)
++        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
++
++        if coeff_arr.ndim != 1:
++            raise ValueError("The array to interpolate must be a 1D array")
++        if coeff_arr.shape != tlist.shape:
++            raise ValueError("tlist must be the same len "
++                             "as the array to interpolate")
++        if order < 0:
++            raise ValueError("order must be a positive integer")
++
++        order = min(order, len(tlist) - 1)
++
++        if order == 0:
++            coeff_arr = coeff_arr.reshape((1, -1))
++        elif order == 1:
++            coeff_arr = np.vstack([
++                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
++                    coeff_arr
++                ])
++        elif order >= 2:
++            # Use scipy to compute the spline and transform it to polynomes
++            # as used in scipy's PPoly which is easier for us to use.
++            spline = make_interp_spline(tlist, coeff_arr, k=order,
++                                        bc_type=boundary_conditions)
++            # Scipy can move knots, we add them to tlist
++            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
++            a = np.arange(spline.k+1)
++            a[0] = 1
++            fact = np.cumprod(a)
++            coeff_arr = np.concatenate([
++                spline(tlist, i) / fact[i]
++                for i in range(spline.k, -1, -1)
++            ]).reshape((spline.k+1, -1))
++
++        self._prepare(tlist, coeff_arr)
++
++    def _prepare(self, np_tlist, np_poly, dt=None):
++        self.np_arrays = (np_tlist, np_poly)
++        self.tlist = np_tlist
++        self.poly = np_poly
++        self.order = self.poly.shape[0] - 1
++        diff = np.diff(self.np_arrays[0])
++        if dt is not None:
++            self.dt = dt
++        elif len(diff) >= 1 and np.allclose(diff[0], diff):
++            self.dt = diff[0]
++        else:
++            self.dt = 0
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef size_t _binary_search(self, double x):
++        # Binary search for the interval
++        # return the indice of the of the biggest element where t <= x
++        cdef size_t low = 0
++        cdef size_t high = self.tlist.shape[0]
++        cdef size_t middle
++        cdef size_t count = 0
++        while low+1 != high and count < 64:
++            middle = (low + high)//2
++            if x < self.tlist[middle]:
++                high = middle
++            else:
++                low = middle
++            # We keep a count to be sure that it never get into an infinit loop
++            # even if tlist has an unexpected format.
++            count += 1
++        return low
++
++    @cython.initializedcheck(False)
++    @cython.cdivision(True)
++    cdef double complex _call(self, double t) except *:
++        cdef size_t idx, i
++        cdef double factor
++        cdef double complex out
++        cdef double complex[:] slice
++        if t <= self.tlist[0]:
++            return self.poly[-1, 0]
++        elif t >= self.tlist[-1]:
++            return self.poly[-1, -1]
++        if self.dt:
++            idx = <size_t>((t - self.tlist[0]) / self.dt)
++        else:
++            idx = self._binary_search(t)
++        if self.order == 0:
++            out = self.poly[0, idx]
++        else:
++            factor = t - self.tlist[idx]
++            slice = self.poly[:, idx]
++            out = 0.
++            for i in range(self.order+1):
++                out *= factor
++                out += slice[i]
++        return out
++
++    def __reduce__(self):
++        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
++
++    @classmethod
++    def restore(cls, np_tlist, np_poly, dt=None):
++        cdef InterCoefficient out = cls.__new__(cls)
++        out._prepare(np_tlist, np_poly, dt)
++        return out
++
++    @classmethod
++    def from_PPoly(cls, ppoly, **_):
++        return cls.restore(ppoly.x, ppoly.c)
++
++    @classmethod
++    def from_Bspline(cls, spline, **_):
++        tlist = np.unique(spline.t)
++        a = np.arange(spline.k+1)
++        a[0] = 1
++        fact = np.cumprod(a) + 0j
++        poly = np.concatenate([
++            spline(tlist, i) / fact[i]
++            for i in range(spline.k, -1, -1)
++        ]).reshape((spline.k+1, -1))
++        return cls.restore(tlist, poly)
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return InterCoefficient.restore(*self.np_arrays, self.dt)
++
++
++cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
++    """ Add two array coefficient with matching tlist into one."""
++    if (
++        left.np_arrays[0].shape == right.np_arrays[0].shape
++        and np.allclose(left.np_arrays[0], right.np_arrays[0],
++                        rtol=1e-15, atol=1e-15)
++        and (left.order == right.order)
++    ):
++        return InterCoefficient.restore(
++            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
++            left.dt
++        )
++    else:
++        # It would be possible to add them by merging tlist.
++        return SumCoefficient(left, right)
++
++
++@cython.auto_pickle(True)
++cdef class SumCoefficient(Coefficient):
++    """
++    A :obj:`Coefficient` built from the sum of two other coefficients.
++
++    A :obj:`SumCoefficient` is returned as the result of the addition of two
++    coefficients, e.g. ::
++
++        coefficient("t * t") + coefficient("t")  # SumCoefficient
++    """
++    cdef Coefficient first
++    cdef Coefficient second
++
++    def __init__(self, Coefficient first, Coefficient second):
++        self.first = first
++        self.second = second
++
++    cdef complex _call(self, double t) except *:
++        return self.first._call(t) + self.second._call(t)
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return SumCoefficient(self.first.copy(), self.second.copy())
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        return SumCoefficient(
++            self.first.replace_arguments(_args, **kwargs),
++            self.second.replace_arguments(_args, **kwargs)
++        )
++
++
++@cython.auto_pickle(True)
++cdef class MulCoefficient(Coefficient):
++    """
++    A :obj:`Coefficient` built from the product of two other coefficients.
++
++    A :obj:`MulCoefficient` is returned as the result of the multiplication of
++    two coefficients, e.g. ::
++
++        coefficient("w * t", args={'w': 1}) * coefficient("t")
++    """
++    cdef Coefficient first
++    cdef Coefficient second
++
++    def __init__(self, Coefficient first, Coefficient second):
++        self.first = first
++        self.second = second
++
++    cdef complex _call(self, double t) except *:
++        return self.first._call(t) * self.second._call(t)
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return MulCoefficient(self.first.copy(), self.second.copy())
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        return MulCoefficient(
++            self.first.replace_arguments(_args, **kwargs),
++            self.second.replace_arguments(_args, **kwargs)
++        )
++
++
++@cython.auto_pickle(True)
++cdef class ConjCoefficient(Coefficient):
++    """
++    The conjugate of a :obj:`Coefficient`.
++
++    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
++    ``qutip.coefficent.conj(Coefficient)``.
++    """
++    cdef Coefficient base
++
++    def __init__(self, Coefficient base):
++        self.base = base
++
++    cdef complex _call(self, double t) except *:
++        return conj(self.base._call(t))
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return ConjCoefficient(self.base.copy())
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        return ConjCoefficient(
++            self.base.replace_arguments(_args, **kwargs)
++        )
++
++
++@cython.auto_pickle(True)
++cdef class NormCoefficient(Coefficient):
++    """
++    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
++    ``conj(coeff) * coeff``.
++
++    :obj:`NormCoefficient` is returned by
++    ``qutip.coefficent.norm(Coefficient)``.
++    """
++    cdef Coefficient base
++
++    def __init__(self, Coefficient base):
++        self.base = base
++
++    def replace_arguments(self, _args=None, **kwargs):
++        """
++        Replace the arguments (``args``) of a coefficient.
++
++        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
++        the original coefficient if it does not. Arguments to replace may be
++        supplied either in a dictionary as the first position argument, or
++        passed as keywords, or as a combination of the two. Arguments not
++        replaced retain their previous values.
++
++        Parameters
++        ----------
++        _args : dict
++            Dictionary of arguments to replace.
++
++        **kwargs
++            Arguments to replace.
++        """
++        return NormCoefficient(
++            self.base.replace_arguments(_args, **kwargs)
++        )
++
++    cdef complex _call(self, double t) except *:
++        return norm(self.base._call(t))
++
++    cpdef Coefficient copy(self):
++        """Return a copy of the :obj:`Coefficient`."""
++        return NormCoefficient(self.base.copy())
+diff --git a/qutip/core/cy/complex_math.pxd b/qutip/core/cy/complex_math.pxd
+index 43f0fd17..5271c330 100644
+--- a/qutip/core/cy/complex_math.pxd
++++ b/qutip/core/cy/complex_math.pxd
+@@ -1,24 +1,24 @@
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double         abs(double complex x)
+-    double complex acos(double complex x)
+-    double complex acosh(double complex x)
+-    double         arg(double complex x)
+-    double complex asin(double complex x)
+-    double complex asinh(double complex x)
+-    double complex atan(double complex x)
+-    double complex atanh(double complex x)
+-    double complex conj(double complex x)
+-    double complex cos(double complex x)
+-    double complex cosh(double complex x)
+-    double complex exp(double complex x)
+-    double         imag(double complex x)
+-    double complex log(double complex x)
+-    double complex log10(double complex x)
+-    double         norm(double complex x)
+-    double complex proj(double complex x)
+-    double         real(double complex x)
+-    double complex sin(double complex x)
+-    double complex sinh(double complex x)
+-    double complex sqrt(double complex x)
+-    double complex tan(double complex x)
+-    double complex tanh(double complex x)
++cdef extern from "<complex>" namespace "std" nogil:
++    double         abs(double complex x)
++    double complex acos(double complex x)
++    double complex acosh(double complex x)
++    double         arg(double complex x)
++    double complex asin(double complex x)
++    double complex asinh(double complex x)
++    double complex atan(double complex x)
++    double complex atanh(double complex x)
++    double complex conj(double complex x)
++    double complex cos(double complex x)
++    double complex cosh(double complex x)
++    double complex exp(double complex x)
++    double         imag(double complex x)
++    double complex log(double complex x)
++    double complex log10(double complex x)
++    double         norm(double complex x)
++    double complex proj(double complex x)
++    double         real(double complex x)
++    double complex sin(double complex x)
++    double complex sinh(double complex x)
++    double complex sqrt(double complex x)
++    double complex tan(double complex x)
++    double complex tanh(double complex x)
+diff --git a/qutip/core/cy/math.pxd b/qutip/core/cy/math.pxd
+index 6f304b49..6002bf9c 100644
+--- a/qutip/core/cy/math.pxd
++++ b/qutip/core/cy/math.pxd
+@@ -1,5 +1,5 @@
+-#cython: language_level=3
+-
+-cdef double erf(double x)
+-
+-cdef double complex zerf(double complex Z)
++#cython: language_level=3
++
++cdef double erf(double x)
++
++cdef double complex zerf(double complex Z)
+diff --git a/qutip/core/cy/math.pyx b/qutip/core/cy/math.pyx
+index abdda8c5..e9f113cf 100644
+--- a/qutip/core/cy/math.pyx
++++ b/qutip/core/cy/math.pyx
+@@ -1,159 +1,159 @@
+-#cython: language_level=3
+-
+-cimport cython
+-from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double real(double complex x)
+-    double imag(double complex x)
+-
+-@cython.boundscheck(False)
+-@cython.cdivision(True)
+-cdef double erf(double x):
+-    """
+-    A Cython version of the erf function from the cdflib in SciPy.
+-    """
+-    cdef double c = 0.564189583547756
+-
+-    cdef double a[5]
+-    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
+-                     0.479137145607681e-1, 0.128379167095513]
+-
+-    cdef double b[3]
+-    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
+-
+-    cdef double p[8]
+-    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
+-                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
+-                     4.51918953711873e2, 3.00459261020162e2]
+-
+-    cdef double q[8]
+-    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
+-                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
+-                     3.00459260956983e2]
+-
+-    cdef double r[5]
+-    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
+-                      4.65807828718470, 2.82094791773523e-1]
+-
+-    cdef double s[4]
+-    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
+-                     1.80124575948747e1]
+-
+-    cdef double ax = fabs(x)
+-    cdef double t, x2, top, bot, erf
+-
+-    if ax <= 0.5:
+-        t = x*x
+-        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
+-        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
+-        erf = x * (top/bot)
+-        return erf
+-    elif ax <= 4.0:
+-        x2 = x*x
+-        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
+-        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
+-        erf = 0.5 + (0.5-exp(-x2)*top/bot)
+-        if x < 0.0:
+-            erf = -erf
+-        return erf
+-    elif ax < 5.8:
+-        x2 = x*x
+-        t = 1.0/x2
+-        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
+-        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
+-        erf = (c-top/(x2*bot))/ax
+-        erf = 0.5 + (0.5-exp(-x2)*erf)
+-        if x < 0.0:
+-            erf = -erf
+-        return erf
+-    else:
+-        erf = copysign(1.0, x)
+-        return erf
+-
+-
+-#       COMPUTATION OF SPECIAL FUNCTIONS
+-#
+-#          Shanjie Zhang and Jianming Jin
+-#
+-#       Copyrighted but permission granted to use code in programs.
+-# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
+-    
+-@cython.cdivision(True)
+-@cython.boundscheck(False)
+-cdef double complex zerf(double complex Z):
+-    """
+-    Parameters
+-    ----------
+-    Z : double complex
+-        Input parameter.
+-    X : double
+-        Real part of Z.
+-    Y : double
+-        Imag part of Z.
+-
+-    Returns
+-    -------
+-    erf(z) : double complex
+-    """
+-    
+-    cdef double EPS = 1e-12
+-    cdef double X = real(Z)
+-    cdef double Y = imag(Z)
+-    cdef double X2 = X * X
+-    
+-    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
+-    
+-    cdef size_t K, N
+-    
+-    if X < 3.5:
+-        ER = 1.0
+-        R = 1.0
+-        W = 0.0
+-        for K in range(1, 100):
+-            R = R*X2/(K+0.5)
+-            ER = ER+R
+-            if (fabs(ER-W) < EPS*fabs(ER)):
+-                break
+-            W = ER
+-        C0 = 2.0/sqrt(pi)*X*exp(-X2)
+-        ER0 = C0*ER
+-    else:
+-        ER = 1.0
+-        R=1.0
+-        for K in range(1, 12):
+-            R = -R*(K-0.5)/X2
+-            ER = ER+R
+-        C0 = exp(-X2)/(X*sqrt(pi))
+-        ER0 = 1.0-C0*ER
+-    
+-    if Y == 0.0:
+-        ERR = ER0
+-        ERI = 0.0
+-    else:
+-        CS = cos(2.0*X*Y)
+-        SS = sin(2.0*X*Y)
+-        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
+-        EI1 = exp(-X2)*SS/(2.0*pi*X)
+-        ER2 = 0.0
+-        W1 = 0.0
+-        
+-        for N in range(1,100):
+-            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
+-            if (fabs((ER2-W1)/ER2) < EPS):
+-                break
+-            W1 = ER2
+-        
+-        C0 = 2.0*exp(-X2)/pi
+-        ERR = ER0+ER1+C0*ER2
+-        EI2 = 0.0
+-        W2 = 0.0
+-        
+-        for N in range(1,100):
+-            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
+-            if (fabs((EI2-W2)/EI2) < EPS):
+-                break
+-            W2 = EI2
+-        ERI = EI1+C0*EI2
+-        
+-    return ERR + 1j*ERI
++#cython: language_level=3
++
++cimport cython
++from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
++
++cdef extern from "<complex>" namespace "std" nogil:
++    double real(double complex x)
++    double imag(double complex x)
++
++@cython.boundscheck(False)
++@cython.cdivision(True)
++cdef double erf(double x):
++    """
++    A Cython version of the erf function from the cdflib in SciPy.
++    """
++    cdef double c = 0.564189583547756
++
++    cdef double a[5]
++    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
++                     0.479137145607681e-1, 0.128379167095513]
++
++    cdef double b[3]
++    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
++
++    cdef double p[8]
++    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
++                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
++                     4.51918953711873e2, 3.00459261020162e2]
++
++    cdef double q[8]
++    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
++                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
++                     3.00459260956983e2]
++
++    cdef double r[5]
++    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
++                      4.65807828718470, 2.82094791773523e-1]
++
++    cdef double s[4]
++    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
++                     1.80124575948747e1]
++
++    cdef double ax = fabs(x)
++    cdef double t, x2, top, bot, erf
++
++    if ax <= 0.5:
++        t = x*x
++        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
++        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
++        erf = x * (top/bot)
++        return erf
++    elif ax <= 4.0:
++        x2 = x*x
++        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
++        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
++        erf = 0.5 + (0.5-exp(-x2)*top/bot)
++        if x < 0.0:
++            erf = -erf
++        return erf
++    elif ax < 5.8:
++        x2 = x*x
++        t = 1.0/x2
++        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
++        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
++        erf = (c-top/(x2*bot))/ax
++        erf = 0.5 + (0.5-exp(-x2)*erf)
++        if x < 0.0:
++            erf = -erf
++        return erf
++    else:
++        erf = copysign(1.0, x)
++        return erf
++
++
++#       COMPUTATION OF SPECIAL FUNCTIONS
++#
++#          Shanjie Zhang and Jianming Jin
++#
++#       Copyrighted but permission granted to use code in programs.
++# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
++    
++@cython.cdivision(True)
++@cython.boundscheck(False)
++cdef double complex zerf(double complex Z):
++    """
++    Parameters
++    ----------
++    Z : double complex
++        Input parameter.
++    X : double
++        Real part of Z.
++    Y : double
++        Imag part of Z.
++
++    Returns
++    -------
++    erf(z) : double complex
++    """
++    
++    cdef double EPS = 1e-12
++    cdef double X = real(Z)
++    cdef double Y = imag(Z)
++    cdef double X2 = X * X
++    
++    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
++    
++    cdef size_t K, N
++    
++    if X < 3.5:
++        ER = 1.0
++        R = 1.0
++        W = 0.0
++        for K in range(1, 100):
++            R = R*X2/(K+0.5)
++            ER = ER+R
++            if (fabs(ER-W) < EPS*fabs(ER)):
++                break
++            W = ER
++        C0 = 2.0/sqrt(pi)*X*exp(-X2)
++        ER0 = C0*ER
++    else:
++        ER = 1.0
++        R=1.0
++        for K in range(1, 12):
++            R = -R*(K-0.5)/X2
++            ER = ER+R
++        C0 = exp(-X2)/(X*sqrt(pi))
++        ER0 = 1.0-C0*ER
++    
++    if Y == 0.0:
++        ERR = ER0
++        ERI = 0.0
++    else:
++        CS = cos(2.0*X*Y)
++        SS = sin(2.0*X*Y)
++        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
++        EI1 = exp(-X2)*SS/(2.0*pi*X)
++        ER2 = 0.0
++        W1 = 0.0
++        
++        for N in range(1,100):
++            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
++            if (fabs((ER2-W1)/ER2) < EPS):
++                break
++            W1 = ER2
++        
++        C0 = 2.0*exp(-X2)/pi
++        ERR = ER0+ER1+C0*ER2
++        EI2 = 0.0
++        W2 = 0.0
++        
++        for N in range(1,100):
++            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
++            if (fabs((EI2-W2)/EI2) < EPS):
++                break
++            W2 = EI2
++        ERI = EI1+C0*EI2
++        
++    return ERR + 1j*ERI
+diff --git a/qutip/core/cy/openmp/bench_openmp.py b/qutip/core/cy/openmp/bench_openmp.py
+index 84db486b..88868a82 100644
+--- a/qutip/core/cy/openmp/bench_openmp.py
++++ b/qutip/core/cy/openmp/bench_openmp.py
+@@ -1,154 +1,154 @@
+-import numpy as np
+-from qutip.settings import settings as qset
+-from timeit import default_timer as timer
+-
+-
+-def _min_timer(function, *args, **kwargs):
+-    min_time = 1e6
+-    for kk in range(10000):
+-        t0 = timer()
+-        function(*args, **kwargs)
+-        t1 = timer()
+-        min_time = min(min_time, t1-t0)
+-    return min_time
+-
+-
+-def system_bench(func, dims):
+-    from qutip.random_objects import rand_ket
+-    ratio = 0
+-    ratio_old = 0
+-    nnz_old = 0
+-    for N in dims:
+-        L = func(N).data
+-        vec = rand_ket(L.shape[0], 0.25).full().ravel()
+-        nnz = L.nnz
+-        out = np.zeros_like(vec)
+-        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
+-        out = np.zeros_like(vec)
+-        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
+-        ratio = ser/par
+-        if ratio > 1:
+-            break
+-        nnz_old = nnz
+-        ratio_old = ratio
+-    if ratio > 1:
+-        rate = (ratio-ratio_old)/(nnz-nnz_old)
+-        return int((1.0-ratio_old)/rate+nnz_old)
+-    else:
+-        return -1
+-
+-
+-def calculate_openmp_thresh():
+-    # if qset.num_cpus == 1:
+-    #    return qset.openmp_thresh
+-    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
+-    jc_result = system_bench(_jc_liouvillian, jc_dims)
+-
+-    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
+-    opto_result = system_bench(_opto_liouvillian, opto_dims)
+-
+-    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
+-    spin_result = system_bench(_spin_hamiltonian, spin_dims)
+-
+-    # Double result to be conservative
+-    thresh = 2*int(max([jc_result, opto_result, spin_result]))
+-    if thresh < 0:
+-        thresh = np.iinfo(np.int32).max
+-    return thresh
+-
+-
+-def _jc_liouvillian(N):
+-    from qutip.core import tensor, destroy, qeye, liouvillian
+-    wc = 2*np.pi * 1.0   # cavity frequency
+-    wa = 2*np.pi * 1.0   # atom frequency
+-    g = 2*np.pi * 0.05   # coupling strength
+-    kappa = 0.005        # cavity dissipation rate
+-    gamma = 0.05         # atom dissipation rate
+-    n_th_a = 1           # temperature in frequency units
+-    use_rwa = 0
+-    # operators
+-    a = tensor(destroy(N), qeye(2))
+-    sm = tensor(qeye(N), destroy(2))
+-    # Hamiltonian
+-    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
+-    c_op_list = []
+-
+-    rate = kappa * (1 + n_th_a)
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * a)
+-
+-    rate = kappa * n_th_a
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * a.dag())
+-
+-    rate = gamma
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * sm)
+-
+-    return liouvillian(H, c_op_list)
+-
+-
+-def _opto_liouvillian(N):
+-    from qutip.core import tensor, destroy, qeye, liouvillian
+-    Nc = 5                      # Number of cavity states
+-    Nm = N                     # Number of mech states
+-    kappa = 0.3                 # Cavity damping rate
+-    E = 0.1                     # Driving Amplitude
+-    g0 = 2.4*kappa              # Coupling strength
+-    Qm = 1e4                    # Mech quality factor
+-    gamma = 1/Qm                # Mech damping rate
+-    n_th = 1                    # Mech bath temperature
+-    delta = -0.43               # Detuning
+-    a = tensor(destroy(Nc), qeye(Nm))
+-    b = tensor(qeye(Nc), destroy(Nm))
+-    num_b = b.dag()*b
+-    num_a = a.dag()*a
+-    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
+-    cc = np.sqrt(kappa)*a
+-    cm = np.sqrt(gamma*(1.0 + n_th))*b
+-    cp = np.sqrt(gamma*n_th)*b.dag()
+-    c_ops = [cc, cm, cp]
+-    return liouvillian(H, c_ops)
+-
+-
+-def _spin_hamiltonian(N):
+-    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
+-    # array of spin energy splittings and coupling strengths. here we use
+-    # uniform parameters, but in general we don't have too
+-    h = 2*np.pi * 1.0 * np.ones(N)
+-    Jz = 2*np.pi * 0.1 * np.ones(N)
+-    Jx = 2*np.pi * 0.1 * np.ones(N)
+-    Jy = 2*np.pi * 0.1 * np.ones(N)
+-    # dephasing rate
+-
+-    si = qeye(2)
+-    sx = sigmax()
+-    sy = sigmay()
+-    sz = sigmaz()
+-
+-    sx_list = []
+-    sy_list = []
+-    sz_list = []
+-
+-    for n in range(N):
+-        op_list = [si] * N
+-        op_list[n] = sx
+-        sx_list.append(tensor(op_list))
+-        op_list[n] = sy
+-        sy_list.append(tensor(op_list))
+-        op_list[n] = sz
+-        sz_list.append(tensor(op_list))
+-
+-    # construct the hamiltonian
+-    H = 0
+-
+-    # energy splitting terms
+-    for n in range(N):
+-        H += - 0.5 * h[n] * sz_list[n]
+-
+-    # interaction terms
+-    for n in range(N-1):
+-        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
+-        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
+-        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
+-    return H
++import numpy as np
++from qutip.settings import settings as qset
++from timeit import default_timer as timer
++
++
++def _min_timer(function, *args, **kwargs):
++    min_time = 1e6
++    for kk in range(10000):
++        t0 = timer()
++        function(*args, **kwargs)
++        t1 = timer()
++        min_time = min(min_time, t1-t0)
++    return min_time
++
++
++def system_bench(func, dims):
++    from qutip.random_objects import rand_ket
++    ratio = 0
++    ratio_old = 0
++    nnz_old = 0
++    for N in dims:
++        L = func(N).data
++        vec = rand_ket(L.shape[0], 0.25).full().ravel()
++        nnz = L.nnz
++        out = np.zeros_like(vec)
++        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
++        out = np.zeros_like(vec)
++        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
++        ratio = ser/par
++        if ratio > 1:
++            break
++        nnz_old = nnz
++        ratio_old = ratio
++    if ratio > 1:
++        rate = (ratio-ratio_old)/(nnz-nnz_old)
++        return int((1.0-ratio_old)/rate+nnz_old)
++    else:
++        return -1
++
++
++def calculate_openmp_thresh():
++    # if qset.num_cpus == 1:
++    #    return qset.openmp_thresh
++    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
++    jc_result = system_bench(_jc_liouvillian, jc_dims)
++
++    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
++    opto_result = system_bench(_opto_liouvillian, opto_dims)
++
++    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
++    spin_result = system_bench(_spin_hamiltonian, spin_dims)
++
++    # Double result to be conservative
++    thresh = 2*int(max([jc_result, opto_result, spin_result]))
++    if thresh < 0:
++        thresh = np.iinfo(np.int32).max
++    return thresh
++
++
++def _jc_liouvillian(N):
++    from qutip.core import tensor, destroy, qeye, liouvillian
++    wc = 2*np.pi * 1.0   # cavity frequency
++    wa = 2*np.pi * 1.0   # atom frequency
++    g = 2*np.pi * 0.05   # coupling strength
++    kappa = 0.005        # cavity dissipation rate
++    gamma = 0.05         # atom dissipation rate
++    n_th_a = 1           # temperature in frequency units
++    use_rwa = 0
++    # operators
++    a = tensor(destroy(N), qeye(2))
++    sm = tensor(qeye(N), destroy(2))
++    # Hamiltonian
++    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
++    c_op_list = []
++
++    rate = kappa * (1 + n_th_a)
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * a)
++
++    rate = kappa * n_th_a
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * a.dag())
++
++    rate = gamma
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * sm)
++
++    return liouvillian(H, c_op_list)
++
++
++def _opto_liouvillian(N):
++    from qutip.core import tensor, destroy, qeye, liouvillian
++    Nc = 5                      # Number of cavity states
++    Nm = N                     # Number of mech states
++    kappa = 0.3                 # Cavity damping rate
++    E = 0.1                     # Driving Amplitude
++    g0 = 2.4*kappa              # Coupling strength
++    Qm = 1e4                    # Mech quality factor
++    gamma = 1/Qm                # Mech damping rate
++    n_th = 1                    # Mech bath temperature
++    delta = -0.43               # Detuning
++    a = tensor(destroy(Nc), qeye(Nm))
++    b = tensor(qeye(Nc), destroy(Nm))
++    num_b = b.dag()*b
++    num_a = a.dag()*a
++    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
++    cc = np.sqrt(kappa)*a
++    cm = np.sqrt(gamma*(1.0 + n_th))*b
++    cp = np.sqrt(gamma*n_th)*b.dag()
++    c_ops = [cc, cm, cp]
++    return liouvillian(H, c_ops)
++
++
++def _spin_hamiltonian(N):
++    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
++    # array of spin energy splittings and coupling strengths. here we use
++    # uniform parameters, but in general we don't have too
++    h = 2*np.pi * 1.0 * np.ones(N)
++    Jz = 2*np.pi * 0.1 * np.ones(N)
++    Jx = 2*np.pi * 0.1 * np.ones(N)
++    Jy = 2*np.pi * 0.1 * np.ones(N)
++    # dephasing rate
++
++    si = qeye(2)
++    sx = sigmax()
++    sy = sigmay()
++    sz = sigmaz()
++
++    sx_list = []
++    sy_list = []
++    sz_list = []
++
++    for n in range(N):
++        op_list = [si] * N
++        op_list[n] = sx
++        sx_list.append(tensor(op_list))
++        op_list[n] = sy
++        sy_list.append(tensor(op_list))
++        op_list[n] = sz
++        sz_list.append(tensor(op_list))
++
++    # construct the hamiltonian
++    H = 0
++
++    # energy splitting terms
++    for n in range(N):
++        H += - 0.5 * h[n] * sz_list[n]
++
++    # interaction terms
++    for n in range(N-1):
++        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
++        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
++        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
++    return H
+diff --git a/qutip/core/cy/openmp/parfuncs.pxd b/qutip/core/cy/openmp/parfuncs.pxd
+index a8a14bea..73a4186d 100644
+--- a/qutip/core/cy/openmp/parfuncs.pxd
++++ b/qutip/core/cy/openmp/parfuncs.pxd
+@@ -1,9 +1,9 @@
+-#cython: language_level=3
+-
+-cimport numpy as cnp
+-cimport cython
+-
+-cdef void spmvpy_openmp(
+-    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
+-    unsigned int nrows, unsigned int nthr,
+-)
++#cython: language_level=3
++
++cimport numpy as cnp
++cimport cython
++
++cdef void spmvpy_openmp(
++    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
++    unsigned int nrows, unsigned int nthr,
++)
+diff --git a/qutip/core/cy/openmp/parfuncs.pyx b/qutip/core/cy/openmp/parfuncs.pyx
+index 919a209e..382c75b4 100644
+--- a/qutip/core/cy/openmp/parfuncs.pyx
++++ b/qutip/core/cy/openmp/parfuncs.pyx
+@@ -1,13 +1,13 @@
+-#cython: language_level=3
+-
+-cdef extern from "src/zspmv_openmp.hpp" nogil:
+-    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
+-                double complex a, double complex *out, int nrows, int nthr)
+-
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
+-                               complex * vec, complex a, complex * out,
+-                               unsigned int nrows, unsigned int nthr):
+-    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
++#cython: language_level=3
++
++cdef extern from "src/zspmv_openmp.hpp" nogil:
++    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
++                double complex a, double complex *out, int nrows, int nthr)
++
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
++                               complex * vec, complex a, complex * out,
++                               unsigned int nrows, unsigned int nthr):
++    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
+diff --git a/qutip/core/cy/openmp/src/zspmv_openmp.cpp b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
+index 7e98b934..f6b42c3a 100644
+--- a/qutip/core/cy/openmp/src/zspmv_openmp.cpp
++++ b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
+@@ -1,166 +1,166 @@
+-#include <complex>
+-#include <omp.h>
+-
+-#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
+-#include <pmmintrin.h>
+-void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
+-            const int * __restrict__ ptr,
+-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
+-            std::complex<double> * __restrict__ out, const unsigned int nrows,
+-            const unsigned int nthr)
+-{
+-    size_t row, jj;
+-    unsigned int row_start, row_end;
+-    __m128d num1, num2, num3, num4;
+-    #pragma omp parallel for \
+-        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
+-        shared(data,ind,ptr,out,vec) schedule(static) \
+-        num_threads(nthr)
+-    for (row=0; row < nrows; row++)
+-    {
+-        num4 = _mm_setzero_pd();
+-        row_start = ptr[row];
+-        row_end = ptr[row+1];
+-        for (jj=row_start; jj <row_end; jj++)
+-        {
+-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
+-            num3 = _mm_mul_pd(num2, num1);
+-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+-            num2 = _mm_shuffle_pd(num2, num2, 1);
+-            num2 = _mm_mul_pd(num2, num1);
+-            num3 = _mm_addsub_pd(num3, num2);
+-            num4 = _mm_add_pd(num3, num4);
+-        }
+-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+-        num3 = _mm_mul_pd(num4, num1);
+-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+-        num4 = _mm_shuffle_pd(num4, num4, 1);
+-        num4 = _mm_mul_pd(num4, num1);
+-        num3 = _mm_addsub_pd(num3, num4);
+-        num2 = _mm_loadu_pd((double *)&out[row]);
+-        num3 = _mm_add_pd(num2, num3);
+-        _mm_storeu_pd((double *)&out[row], num3);
+-    }
+-}
+-#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
+-void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
+-            const int * __restrict__ ptr,
+-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
+-            std::complex<double> * __restrict__ out, const unsigned int nrows,
+-            const unsigned int nthr)
+-{
+-    size_t row, jj;
+-    unsigned int row_start, row_end;
+-    std::complex<double> dot;
+-    #pragma omp parallel for \
+-        private(row,dot,row_start,row_end,jj) \
+-        shared(data,ind,ptr,out,vec) schedule(static) \
+-        num_threads(nthr)
+-    for (row=0; row < nrows; row++)
+-    {
+-        dot = 0;
+-        row_start = ptr[row];
+-        row_end = ptr[row+1];
+-        for (jj=row_start; jj <row_end; jj++)
+-        {
+-            dot += data[jj]*vec[ind[jj]];
+-        }
+-        out[row] += a*dot;
+-    }
+-}
+-#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
+-#include <pmmintrin.h>
+-void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
+-            const int * __restrict ptr,
+-            const std::complex<double> * __restrict vec, const std::complex<double> a,
+-            std::complex<double> * __restrict out, const int nrows,
+-            const unsigned int nthr)
+-{
+-    int row, jj;
+-    int row_start, row_end;
+-    __m128d num1, num2, num3, num4;
+-    #pragma omp parallel for \
+-        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
+-        shared(data,ind,ptr,out,vec) schedule(static) \
+-        num_threads(nthr)
+-    for (row=0; row < nrows; row++)
+-    {
+-        num4 = _mm_setzero_pd();
+-        row_start = ptr[row];
+-        row_end = ptr[row+1];
+-        for (jj=row_start; jj <row_end; jj++)
+-        {
+-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
+-            num3 = _mm_mul_pd(num2, num1);
+-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+-            num2 = _mm_shuffle_pd(num2, num2, 1);
+-            num2 = _mm_mul_pd(num2, num1);
+-            num3 = _mm_addsub_pd(num3, num2);
+-            num4 = _mm_add_pd(num3, num4);
+-        }
+-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+-        num3 = _mm_mul_pd(num4, num1);
+-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+-        num4 = _mm_shuffle_pd(num4, num4, 1);
+-        num4 = _mm_mul_pd(num4, num1);
+-        num3 = _mm_addsub_pd(num3, num4);
+-        num2 = _mm_loadu_pd((double *)&out[row]);
+-        num3 = _mm_add_pd(num2, num3);
+-        _mm_storeu_pd((double *)&out[row], num3);
+-    }
+-}
+-#elif defined(_MSC_VER) // Visual Studio no AVX
+-void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
+-            const int * __restrict ptr,
+-            const std::complex<double> * __restrict vec, const std::complex<double> a,
+-            std::complex<double> * __restrict out, const int nrows,
+-            const unsigned int nthr)
+-{
+-    int row, jj;
+-    int row_start, row_end;
+-    std::complex<double> dot;
+-    #pragma omp parallel for \
+-        private(row,dot,row_start,row_end,jj) \
+-        shared(data,ind,ptr,out,vec) schedule(static) \
+-        num_threads(nthr)
+-    for (row=0; row < nrows; row++)
+-    {
+-        dot = 0;
+-        row_start = ptr[row];
+-        row_end = ptr[row+1];
+-        for (jj=row_start; jj <row_end; jj++)
+-        {
+-            dot += data[jj]*vec[ind[jj]];
+-        }
+-        out[row] += a*dot;
+-    }
+-}
+-#else // Everything else
+-void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
+-            const int * ptr,
+-            const std::complex<double> * vec, const std::complex<double> a,
+-            std::complex<double> * out, const unsigned int nrows,
+-            const unsigned int nthr)
+-{
+-    size_t row, jj;
+-    unsigned int row_start, row_end;
+-    std::complex<double> dot;
+-    #pragma omp parallel for \
+-        private(row,dot,row_start,row_end,jj) \
+-        shared(data,ind,ptr,out,vec) schedule(static) \
+-        num_threads(nthr)
+-    for (row=0; row < nrows; row++)
+-    {
+-        dot = 0;
+-        row_start = ptr[row];
+-        row_end = ptr[row+1];
+-        for (jj=row_start; jj <row_end; jj++)
+-        {
+-            dot += data[jj]*vec[ind[jj]];
+-        }
+-        out[row] += a*dot;
+-    }
+-}
+-#endif
++#include <complex>
++#include <omp.h>
++
++#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
++#include <pmmintrin.h>
++void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
++            const int * __restrict__ ptr,
++            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
++            std::complex<double> * __restrict__ out, const unsigned int nrows,
++            const unsigned int nthr)
++{
++    size_t row, jj;
++    unsigned int row_start, row_end;
++    __m128d num1, num2, num3, num4;
++    #pragma omp parallel for \
++        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
++        shared(data,ind,ptr,out,vec) schedule(static) \
++        num_threads(nthr)
++    for (row=0; row < nrows; row++)
++    {
++        num4 = _mm_setzero_pd();
++        row_start = ptr[row];
++        row_end = ptr[row+1];
++        for (jj=row_start; jj <row_end; jj++)
++        {
++            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
++            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
++            num3 = _mm_mul_pd(num2, num1);
++            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
++            num2 = _mm_shuffle_pd(num2, num2, 1);
++            num2 = _mm_mul_pd(num2, num1);
++            num3 = _mm_addsub_pd(num3, num2);
++            num4 = _mm_add_pd(num3, num4);
++        }
++        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
++        num3 = _mm_mul_pd(num4, num1);
++        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
++        num4 = _mm_shuffle_pd(num4, num4, 1);
++        num4 = _mm_mul_pd(num4, num1);
++        num3 = _mm_addsub_pd(num3, num4);
++        num2 = _mm_loadu_pd((double *)&out[row]);
++        num3 = _mm_add_pd(num2, num3);
++        _mm_storeu_pd((double *)&out[row], num3);
++    }
++}
++#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
++void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
++            const int * __restrict__ ptr,
++            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
++            std::complex<double> * __restrict__ out, const unsigned int nrows,
++            const unsigned int nthr)
++{
++    size_t row, jj;
++    unsigned int row_start, row_end;
++    std::complex<double> dot;
++    #pragma omp parallel for \
++        private(row,dot,row_start,row_end,jj) \
++        shared(data,ind,ptr,out,vec) schedule(static) \
++        num_threads(nthr)
++    for (row=0; row < nrows; row++)
++    {
++        dot = 0;
++        row_start = ptr[row];
++        row_end = ptr[row+1];
++        for (jj=row_start; jj <row_end; jj++)
++        {
++            dot += data[jj]*vec[ind[jj]];
++        }
++        out[row] += a*dot;
++    }
++}
++#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
++#include <pmmintrin.h>
++void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
++            const int * __restrict ptr,
++            const std::complex<double> * __restrict vec, const std::complex<double> a,
++            std::complex<double> * __restrict out, const int nrows,
++            const unsigned int nthr)
++{
++    int row, jj;
++    int row_start, row_end;
++    __m128d num1, num2, num3, num4;
++    #pragma omp parallel for \
++        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
++        shared(data,ind,ptr,out,vec) schedule(static) \
++        num_threads(nthr)
++    for (row=0; row < nrows; row++)
++    {
++        num4 = _mm_setzero_pd();
++        row_start = ptr[row];
++        row_end = ptr[row+1];
++        for (jj=row_start; jj <row_end; jj++)
++        {
++            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
++            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
++            num3 = _mm_mul_pd(num2, num1);
++            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
++            num2 = _mm_shuffle_pd(num2, num2, 1);
++            num2 = _mm_mul_pd(num2, num1);
++            num3 = _mm_addsub_pd(num3, num2);
++            num4 = _mm_add_pd(num3, num4);
++        }
++        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
++        num3 = _mm_mul_pd(num4, num1);
++        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
++        num4 = _mm_shuffle_pd(num4, num4, 1);
++        num4 = _mm_mul_pd(num4, num1);
++        num3 = _mm_addsub_pd(num3, num4);
++        num2 = _mm_loadu_pd((double *)&out[row]);
++        num3 = _mm_add_pd(num2, num3);
++        _mm_storeu_pd((double *)&out[row], num3);
++    }
++}
++#elif defined(_MSC_VER) // Visual Studio no AVX
++void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
++            const int * __restrict ptr,
++            const std::complex<double> * __restrict vec, const std::complex<double> a,
++            std::complex<double> * __restrict out, const int nrows,
++            const unsigned int nthr)
++{
++    int row, jj;
++    int row_start, row_end;
++    std::complex<double> dot;
++    #pragma omp parallel for \
++        private(row,dot,row_start,row_end,jj) \
++        shared(data,ind,ptr,out,vec) schedule(static) \
++        num_threads(nthr)
++    for (row=0; row < nrows; row++)
++    {
++        dot = 0;
++        row_start = ptr[row];
++        row_end = ptr[row+1];
++        for (jj=row_start; jj <row_end; jj++)
++        {
++            dot += data[jj]*vec[ind[jj]];
++        }
++        out[row] += a*dot;
++    }
++}
++#else // Everything else
++void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
++            const int * ptr,
++            const std::complex<double> * vec, const std::complex<double> a,
++            std::complex<double> * out, const unsigned int nrows,
++            const unsigned int nthr)
++{
++    size_t row, jj;
++    unsigned int row_start, row_end;
++    std::complex<double> dot;
++    #pragma omp parallel for \
++        private(row,dot,row_start,row_end,jj) \
++        shared(data,ind,ptr,out,vec) schedule(static) \
++        num_threads(nthr)
++    for (row=0; row < nrows; row++)
++    {
++        dot = 0;
++        row_start = ptr[row];
++        row_end = ptr[row+1];
++        for (jj=row_start; jj <row_end; jj++)
++        {
++            dot += data[jj]*vec[ind[jj]];
++        }
++        out[row] += a*dot;
++    }
++}
++#endif
+diff --git a/qutip/core/cy/openmp/utilities.py b/qutip/core/cy/openmp/utilities.py
+index 96275769..ac5bab86 100644
+--- a/qutip/core/cy/openmp/utilities.py
++++ b/qutip/core/cy/openmp/utilities.py
+@@ -1,41 +1,41 @@
+-import os
+-from qutip.settings import settings as qset
+-
+-
+-def check_use_openmp(options):
+-    """
+-    Check to see if OPENMP should be used in dynamic solvers.
+-    """
+-    # TODO: sort this out.
+-    return False
+-    """
+-    force_omp = False
+-    if qset.has_openmp:
+-        if options.use_openmp is None:
+-            options.use_openmp = True
+-        else:
+-            force_omp = bool(options.use_openmp)
+-    elif (not qset.has_openmp) and options.use_openmp:
+-        raise Exception('OPENMP not available.')
+-    else:
+-        options.use_openmp = False
+-        force_omp = False
+-    # Disable OPENMP in parallel mode unless explicitly set.
+-    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
+-        options.use_openmp = False"""
+-
+-
+-def use_openmp():
+-    """
+-    Check for using openmp in general cases outside of dynamics
+-    """
+-    return False
+-    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
+-        return True
+-    else:
+-        return False
+-
+-
+-def openmp_components(ptr_list):
+-    return np.array([False for ptr in ptr_list], dtype=bool)
+-    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
++import os
++from qutip.settings import settings as qset
++
++
++def check_use_openmp(options):
++    """
++    Check to see if OPENMP should be used in dynamic solvers.
++    """
++    # TODO: sort this out.
++    return False
++    """
++    force_omp = False
++    if qset.has_openmp:
++        if options.use_openmp is None:
++            options.use_openmp = True
++        else:
++            force_omp = bool(options.use_openmp)
++    elif (not qset.has_openmp) and options.use_openmp:
++        raise Exception('OPENMP not available.')
++    else:
++        options.use_openmp = False
++        force_omp = False
++    # Disable OPENMP in parallel mode unless explicitly set.
++    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
++        options.use_openmp = False"""
++
++
++def use_openmp():
++    """
++    Check for using openmp in general cases outside of dynamics
++    """
++    return False
++    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
++        return True
++    else:
++        return False
++
++
++def openmp_components(ptr_list):
++    return np.array([False for ptr in ptr_list], dtype=bool)
++    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
+diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
+index 07e0d3df..73b7f01b 100644
+--- a/qutip/core/cy/qobjevo.pxd
++++ b/qutip/core/cy/qobjevo.pxd
+@@ -1,24 +1,24 @@
+-#cython: language_level=3
+-
+-from qutip.core.data cimport Dense, Data
+-from qutip.core.data.base cimport idxint
+-
+-cdef class QobjEvo:
+-    cdef:
+-        list elements
+-        readonly list dims
+-        readonly (idxint, idxint) shape
+-        readonly str type
+-        readonly str superrep
+-        int _issuper
+-        int _isoper
+-
+-    cpdef Data _call(QobjEvo self, double t)
+-
+-    cdef object _prepare(QobjEvo self, object t, Data state=*)
+-
+-    cpdef object expect_data(QobjEvo self, object t, Data state)
+-
+-    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
+-
+-    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
++#cython: language_level=3
++
++from qutip.core.data cimport Dense, Data
++from qutip.core.data.base cimport idxint
++
++cdef class QobjEvo:
++    cdef:
++        list elements
++        readonly list dims
++        readonly (idxint, idxint) shape
++        readonly str type
++        readonly str superrep
++        int _issuper
++        int _isoper
++
++    cpdef Data _call(QobjEvo self, double t)
++
++    cdef object _prepare(QobjEvo self, object t, Data state=*)
++
++    cpdef object expect_data(QobjEvo self, object t, Data state)
++
++    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
++
++    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
+diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
+index 513d3ae5..cddeb5d0 100644
+--- a/qutip/core/cy/qobjevo.pyx
++++ b/qutip/core/cy/qobjevo.pyx
+@@ -1,1019 +1,1019 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+-
+-import numpy as np
+-import numbers
+-import itertools
+-from functools import partial
+-
+-import qutip
+-from .. import Qobj
+-from .. import data as _data
+-from ..coefficient import coefficient, CompilationOptions
+-from ._element import *
+-from ..dimensions import type_from_dims
+-from qutip.settings import settings
+-
+-from qutip.core.cy._element cimport _BaseElement
+-from qutip.core.data cimport Dense, Data, dense
+-from qutip.core.data.expect cimport *
+-from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
+-from qutip.core.cy.coefficient cimport Coefficient
+-from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
+-from libc.math cimport fabs
+-
+-__all__ = ['QobjEvo']
+-
+-cdef class QobjEvo:
+-    """
+-    A class for representing time-dependent quantum objects, such as quantum
+-    operators and states.
+-
+-    Importantly, :obj:`~QobjEvo` instances are used to represent such
+-    time-dependent quantum objects when working with QuTiP solvers.
+-
+-    A :obj:`~QobjEvo` instance may be constructed from one of the following:
+-
+-      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
+-        value of the quantum object at time ``t``.
+-
+-      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
+-        any item that can be used to construct a coefficient (e.g. a function,
+-        a numpy array of coefficient values, a string expression).
+-
+-      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
+-
+-      * a list of such callables, pairs or :obj:`~Qobj`\s.
+-
+-      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
+-        are ignored except ``args`` which, if passed, replaces the existing
+-        arguments).
+-
+-    Parameters
+-    ----------
+-    Q_object : callable, list or Qobj
+-        A specification of the time-depedent quantum object. See the
+-        paragraph above for a full description and the examples section below
+-        for examples.
+-
+-    args : dict, optional
+-        A dictionary that contains the arguments for the coefficients.
+-        Arguments may be omitted if no function or string coefficients that
+-        require arguments are present.
+-
+-    tlist : array-like, optional
+-        A list of times corresponding to the values of the coefficients
+-        supplied as numpy arrays. If no coefficients are supplied as numpy
+-        arrays, ``tlist`` may be omitted, otherwise it is required.
+-
+-        The times in ``tlist`` do not need to be equidistant, but must
+-        be sorted.
+-
+-        By default, a cubic spline interpolation will be used to interpolate
+-        the value of the (numpy array) coefficients at time ``t``. If the
+-        coefficients are to be treated as step functions, pass the argument
+-        ``order=0`` (see below).
+-
+-    order : int, default=3
+-        Order of the spline interpolation that is to be used to interpolate
+-        the value of the (numpy array) coefficients at time ``t``.
+-        ``0`` use previous or left value.
+-
+-    copy : bool, default=True
+-        Whether to make a copy of the :obj:`Qobj` instances supplied in
+-        the ``Q_object`` parameter.
+-
+-    compress : bool, default=True
+-        Whether to compress the :obj:`QobjEvo` instance terms after the
+-        instance has been created.
+-
+-        This sums the constant terms in a single term and combines
+-        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
+-        pair containing the sum of the coefficients.
+-
+-        See :meth:`compress`.
+-
+-    function_style : {None, "pythonic", "dict", "auto"}
+-        The style of function signature used by callables in ``Q_object``.
+-        If style is ``None``, the value of
+-        ``qutip.settings.core["function_coefficient_style"]``
+-        is used. Otherwise the supplied value overrides the global setting.
+-
+-
+-    boundary_conditions : 2-Tuple, str or None, optional
+-        Boundary conditions for spline evaluation. Default value is `None`.
+-        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+-        Refer to Scipy's documentation for further details:
+-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+-
+-
+-    Attributes
+-    ----------
+-    dims : list
+-        List of dimensions keeping track of the tensor structure.
+-
+-    shape : (int, int)
+-        List of dimensions keeping track of the tensor structure.
+-
+-    type : str
+-        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
+-        'operator-bra', or 'super'.
+-
+-    superrep : str
+-        Representation used if `type` is 'super'. One of 'super'
+-        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
+-
+-    Examples
+-    --------
+-
+-    A :obj:`~QobjEvo` constructed from a function:
+-
+-    .. code-block::
+-
+-        def f(t, args):
+-            return qutip.qeye(N) * np.exp(args['w'] * t)
+-
+-        QobjEvo(f, args={'w': 1j})
+-
+-
+-    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
+-    ``[Qobj, Coefficient]`` pairs:
+-
+-    .. code-block::
+-
+-        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
+-
+-    The coefficients may be specified either using a :obj:`~Coefficient`
+-    object or by a function, string, numpy array or any object that
+-    can be passed to the :func:`~coefficient` function. See the documentation
+-    of :func:`coefficient` for a full description.
+-
+-    An example of a coefficient specified by a function:
+-
+-    .. code-block::
+-
+-        def f1_t(t, args):
+-            return np.exp(-1j * t * args["w1"])
+-
+-        QobjEvo([[H1, f1_t]], args={"w1": 1.})
+-
+-    And of coefficients specified by string expressions:
+-
+-    .. code-block::
+-
+-        H = QobjEvo(
+-            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
+-            args={"w1": 1., "w2": 2.}
+-        )
+-
+-    Coefficients maybe also be expressed as numpy arrays giving a list
+-    of the coefficient values:
+-
+-    .. code-block:: python
+-
+-        tlist = np.logspace(-5, 0, 100)
+-        H = QobjEvo(
+-            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
+-            tlist=tlist
+-        )
+-
+-    The coeffients array must have the same len as the tlist.
+-
+-    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
+-    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
+-
+-    .. code-block:: python
+-
+-        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
+-        qevo = H0 + H1 * coeff
+-
+-    """
+-    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
+-                 order=3, copy=True, compress=True,
+-                 function_style=None, boundary_conditions=None):
+-        if isinstance(Q_object, QobjEvo):
+-            self.dims = Q_object.dims.copy()
+-            self.shape = Q_object.shape
+-            self.type = Q_object.type
+-            self._issuper = (<QobjEvo> Q_object)._issuper
+-            self._isoper = (<QobjEvo> Q_object)._isoper
+-            self.elements = (<QobjEvo> Q_object).elements.copy()
+-            if args:
+-                self.arguments(args)
+-            if compress:
+-                self.compress()
+-            return
+-
+-        self.elements = []
+-        self.dims = None
+-        self.shape = (0, 0)
+-        self._issuper = -1
+-        self._isoper = -1
+-        args = args or {}
+-
+-        if (
+-            isinstance(Q_object, list)
+-            and len(Q_object) == 2
+-            and isinstance(Q_object[0], Qobj)
+-            and not isinstance(Q_object[1], (Qobj, list))
+-        ):
+-            # The format is [Qobj, coefficient]
+-            Q_object = [Q_object]
+-
+-        if isinstance(Q_object, list):
+-            for op in Q_object:
+-                self.elements.append(
+-                    self._read_element(
+-                        op, copy=copy, tlist=tlist, args=args, order=order,
+-                        function_style=function_style,
+-                        boundary_conditions=boundary_conditions
+-                    )
+-                )
+-        else:
+-            self.elements.append(
+-                self._read_element(
+-                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
+-                    function_style=function_style,
+-                    boundary_conditions=boundary_conditions
+-                )
+-            )
+-
+-        if compress:
+-            self.compress()
+-
+-    def __repr__(self):
+-        cls = self.__class__.__name__
+-        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
+-        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
+-        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
+-        return repr_str
+-
+-    def _read_element(self, op, copy, tlist, args, order, function_style, 
+-                      boundary_conditions):
+-        """ Read a Q_object item and return an element for that item. """
+-        if isinstance(op, Qobj):
+-            out = _ConstantElement(op.copy() if copy else op)
+-            qobj = op
+-        elif isinstance(op, list):
+-            out = _EvoElement(
+-                op[0].copy() if copy else op[0],
+-                coefficient(op[1], tlist=tlist, args=args, order=order, 
+-                            boundary_conditions=boundary_conditions)
+-            )
+-            qobj = op[0]
+-        elif isinstance(op, _BaseElement):
+-            out = op
+-            qobj = op.qobj(0)
+-        elif callable(op):
+-            out = _FuncElement(op, args, style=function_style)
+-            qobj = out.qobj(0)
+-            if not isinstance(qobj, Qobj):
+-                raise TypeError(
+-                    "Function based time-dependent elements must have the"
+-                    " signature f(t: double, args: dict) -> Qobj, but"
+-                    " {!r} returned: {!r}".format(op, qobj)
+-                )
+-        else:
+-            raise TypeError(
+-                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
+-                " or a function f(t: double, args: dict) -> Qobj, but"
+-                " received: {!r}".format(op)
+-            )
+-
+-        if self.dims is None:
+-            self.dims = qobj.dims
+-            self.shape = qobj.shape
+-            self.type = qobj.type
+-            self.superrep = qobj.superrep
+-        elif self.dims != qobj.dims or self.shape != qobj.shape:
+-            raise ValueError(
+-                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
+-                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
+-                f" and shape {self.shape!r}."
+-            )
+-        elif self.type != qobj.type:
+-            raise ValueError(
+-                f"QobjEvo term {op!r} has type {qobj.type!r} but "
+-                f"previous terms had type {self.type!r}."
+-            )
+-        elif self.superrep != qobj.superrep:
+-            raise ValueError(
+-                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
+-                f"previous terms had superrep {self.superrep!r}."
+-            )
+-
+-        return out
+-
+-    @classmethod
+-    def _restore(cls, elements, dims, shape, type, superrep, flags):
+-        """Recreate a QobjEvo without using __init__. """
+-        cdef QobjEvo out = cls.__new__(cls)
+-        out.elements = elements
+-        out.dims = dims
+-        out.shape = shape
+-        out.type = type
+-        out.superrep = superrep
+-        out._issuper, out._isoper = flags
+-        return out
+-
+-    def _getstate(self):
+-        """ Obtain the state """
+-        # For jax pytree representation
+-        # auto_pickle create similar method __getstate__, but since it's
+-        # automatically created, it could change depending on cython version
+-        # etc., so we create our own.
+-        return {
+-            "elements": self.elements,
+-            "dims": self.dims,
+-            "shape": self.shape,
+-            "type": self.type,
+-            "superrep": self.superrep,
+-            "flags": (self._issuper, self._isoper,)
+-        }
+-
+-    def __call__(self, double t, dict _args=None, **kwargs):
+-        """
+-        Get the :class:`~Qobj` at ``t``.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time at which the ``QobjEvo`` is to be evalued.
+-
+-        _args : dict [optional]
+-            New arguments as a dict. Update args with ``arguments(new_args)``.
+-
+-        **kwargs :
+-            New arguments as a keywors. Update args with
+-            ``arguments(**new_args)``.
+-
+-        .. note::
+-            If both the positional ``_args`` and keywords are passed new values
+-            from both will be used. If a key is present with both, the
+-            ``_args`` dict value will take priority.
+-        """
+-        if _args is not None or kwargs:
+-            if _args is not None:
+-                kwargs.update(_args)
+-            return QobjEvo(self, args=kwargs)(t)
+-
+-        t = self._prepare(t, None)
+-
+-        if self.isconstant:
+-            # For constant QobjEvo's, we sum the contained Qobjs directly in
+-            # order to retain the cached values of attributes like .isherm when
+-            # possible, rather than calling _call(t) which may lose this cached
+-            # information.
+-            return sum(element.qobj(t) for element in self.elements)
+-
+-        cdef _BaseElement part = self.elements[0]
+-        cdef double complex coeff = part.coeff(t)
+-        obj = part.qobj(t)
+-        cdef Data out = _data.mul(obj.data, coeff)
+-        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
+-        for element in self.elements[1:]:
+-            part = <_BaseElement> element
+-            coeff = part.coeff(t)
+-            obj = part.qobj(t)
+-            isherm &= <bint> obj._isherm and coeff.imag == 0
+-            out = _data.add(out, obj.data, coeff)
+-
+-        return Qobj(
+-            out, dims=self.dims, copy=False, isherm=isherm or None,
+-            type=self.type, superrep=self.superrep
+-        )
+-
+-    cpdef Data _call(QobjEvo self, double t):
+-        t = self._prepare(t, None)
+-        cdef Data out
+-        cdef _BaseElement part = self.elements[0]
+-        out = _data.mul(part.data(t),
+-                        part.coeff(t))
+-        for element in self.elements[1:]:
+-            part = <_BaseElement> element
+-
+-            out = _data.add(
+-                out,
+-                part.data(t),
+-                part.coeff(t)
+-            )
+-        return out
+-
+-    cdef object _prepare(QobjEvo self, object t, Data state=None):
+-        """ Precomputation before computing getting the element at `t`"""
+-        # We keep the function for feedback eventually
+-        return t
+-
+-    def copy(QobjEvo self):
+-        """Return a copy of this `QobjEvo`"""
+-        return QobjEvo(self, compress=False)
+-
+-    def arguments(QobjEvo self, dict _args=None, **kwargs):
+-        """
+-        Update the arguments.
+-
+-        Parameters
+-        ----------
+-        _args : dict [optional]
+-            New arguments as a dict. Update args with ``arguments(new_args)``.
+-
+-        **kwargs :
+-            New arguments as a keywors. Update args with
+-            ``arguments(**new_args)``.
+-
+-        .. note::
+-            If both the positional ``_args`` and keywords are passed new values
+-            from both will be used. If a key is present with both, the ``_args``
+-            dict value will take priority.
+-        """
+-        if _args is not None:
+-            kwargs.update(_args)
+-        cache = []
+-        self.elements = [
+-            element.replace_arguments(kwargs, cache=cache)
+-            for element in self.elements
+-        ]
+-
+-
+-    ###########################################################################
+-    # Math function                                                           #
+-    ###########################################################################
+-    def __add__(left, right):
+-        if isinstance(left, QobjEvo):
+-            self = left
+-            other = right
+-        else:
+-            self = right
+-            other = left
+-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+-            return NotImplemented
+-        res = self.copy()
+-        res += other
+-        return res
+-
+-    def __radd__(self, other):
+-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+-            return NotImplemented
+-        res = self.copy()
+-        res += other
+-        return res
+-
+-    def __iadd__(QobjEvo self, other):
+-        cdef _BaseElement element
+-        if isinstance(other, QobjEvo):
+-            if other.dims != self.dims:
+-                raise TypeError("incompatible dimensions" +
+-                                str(self.dims) + ", " + str(other.dims))
+-            for element in (<QobjEvo> other).elements:
+-                self.elements.append(element)
+-        elif isinstance(other, Qobj):
+-            if other.dims != self.dims:
+-                raise TypeError("incompatible dimensions" +
+-                                str(self.dims) + ", " + str(other.dims))
+-            self.elements.append(_ConstantElement(other))
+-        elif (
+-            isinstance(other, numbers.Number) and
+-            self.dims[0] == self.dims[1]
+-        ):
+-            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
+-        else:
+-            return NotImplemented
+-        return self
+-
+-    def __sub__(left, right):
+-        if isinstance(left, QobjEvo):
+-            res = left.copy()
+-            res += -right
+-            return res
+-        else:
+-            res = -right.copy()
+-            res += left
+-            return res
+-
+-    def __rsub__(self, other):
+-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+-            return NotImplemented
+-        res = -self
+-        res += other
+-        return res
+-
+-    def __isub__(self, other):
+-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+-            return NotImplemented
+-        self += (-other)
+-        return self
+-
+-    def __matmul__(left, right):
+-        cdef QobjEvo res
+-        if isinstance(left, QobjEvo):
+-            return left.copy().__imatmul__(right)
+-        elif isinstance(left, Qobj):
+-            if left.dims[1] != (<QobjEvo> right).dims[0]:
+-                raise TypeError("incompatible dimensions" +
+-                                 str(left.dims[1]) + ", " +
+-                                 str((<QobjEvo> right).dims[0]))
+-
+-            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
+-            if type_ is None:
+-                raise TypeError(
+-                    "incompatible matmul types "
+-                    + repr(left.type) + " and " + repr(right.type)
+-                )
+-
+-            res = right.copy()
+-            res.dims = [left.dims[0], right.dims[1]]
+-            res.shape = (left.shape[0], right.shape[1])
+-            res.type = type_
+-            left = _ConstantElement(left)
+-            res.elements = [left @ element for element in res.elements]
+-            res._issuper = -1
+-            res._isoper = -1
+-            return res
+-        else:
+-            return NotImplemented
+-
+-    def __rmatmul__(QobjEvo self, other):
+-        cdef QobjEvo res
+-        if isinstance(other, Qobj):
+-            if other.dims[1] != self.dims[0]:
+-                raise TypeError("incompatible dimensions" +
+-                                 str(other.dims[1]) + ", " +
+-                                 str(self.dims[0]))
+-
+-            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
+-            if type_ is None:
+-                raise TypeError(
+-                    "incompatible matmul types "
+-                    + repr(other.type) + " and " + repr(self.type)
+-                )
+-
+-            res = self.copy()
+-            res.dims = [other.dims[0], res.dims[1]]
+-            res.shape = (other.shape[0], res.shape[1])
+-            res.type = type_
+-            other = _ConstantElement(other)
+-            res.elements = [other @ element for element in res.elements]
+-            res._issuper = -1
+-            res._isoper = -1
+-            return res
+-        else:
+-            return NotImplemented
+-
+-    def __imatmul__(QobjEvo self, other):
+-        if isinstance(other, (Qobj, QobjEvo)):
+-            if self.dims[1] != other.dims[0]:
+-                raise TypeError("incompatible dimensions" +
+-                                str(self.dims[1]) + ", " +
+-                                str(other.dims[0]))
+-
+-            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
+-            if type_ is None:
+-                raise TypeError(
+-                    "incompatible matmul types "
+-                    + repr(self.type) + " and " + repr(other.type)
+-                )
+-
+-            self.dims = [self.dims[0], other.dims[1]]
+-            self.shape = (self.shape[0], other.shape[1])
+-            self.type = type_
+-            self._issuper = -1
+-            self._isoper = -1
+-            if isinstance(other, Qobj):
+-                other = _ConstantElement(other)
+-                self.elements = [element @ other for element in self.elements]
+-
+-            elif isinstance(other, QobjEvo):
+-                self.elements = [left @ right
+-                    for left, right in itertools.product(
+-                        self.elements, (<QobjEvo> other).elements
+-                    )]
+-        else:
+-            return NotImplemented
+-        return self
+-
+-    def __mul__(left, right):
+-        if isinstance(left, QobjEvo):
+-            return left.copy().__imul__(right)
+-        elif isinstance(left, Qobj):
+-            return right.__rmatmul__(left)
+-        elif isinstance(left, (numbers.Number, Coefficient)):
+-            return right.copy().__imul__(left)
+-        else:
+-            return NotImplemented
+-
+-    def __rmul__(self, other):
+-        if isinstance(other, Qobj):
+-            return self.__rmatmul__(other)
+-        else:
+-            res = self.copy()
+-            res *= other
+-            return res
+-
+-    def __imul__(QobjEvo self, other):
+-        if isinstance(other, (Qobj, QobjEvo)):
+-            self @= other
+-        elif isinstance(other, numbers.Number):
+-            self.elements = [element * other for element in self.elements]
+-        elif isinstance(other, Coefficient):
+-            other = _EvoElement(qutip.qeye(self.dims[1]), other)
+-            self.elements = [element @ other for element in self.elements]
+-        else:
+-            return NotImplemented
+-        return self
+-
+-    def __truediv__(left, right):
+-        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
+-            res = left.copy()
+-            res *= 1 / right
+-            return res
+-        return NotImplemented
+-
+-    def __idiv__(self, other):
+-        if not isinstance(other, numbers.Number):
+-            return NotImplemented
+-        self *= 1 / other
+-        return self
+-
+-    def __neg__(self):
+-        res = self.copy()
+-        res *= -1
+-        return res
+-
+-    ###########################################################################
+-    # tensor                                                                  #
+-    ###########################################################################
+-    def __and__(left, right):
+-        """
+-        Syntax shortcut for tensor:
+-        A & B ==> tensor(A, B)
+-        """
+-        return qutip.tensor(left, right)
+-
+-    ###########################################################################
+-    # Unary transformation                                                    #
+-    ###########################################################################
+-    def trans(self):
+-        """ Transpose of the quantum object """
+-        cdef QobjEvo res = self.copy()
+-        res.elements = [element.linear_map(Qobj.trans)
+-                        for element in res.elements]
+-        return res
+-
+-    def conj(self):
+-        """Get the element-wise conjugation of the quantum object."""
+-        cdef QobjEvo res = self.copy()
+-        res.elements = [element.linear_map(Qobj.conj, True)
+-                        for element in res.elements]
+-        return res
+-
+-    def dag(self):
+-        """Get the Hermitian adjoint of the quantum object."""
+-        cdef QobjEvo res = self.copy()
+-        res.elements = [element.linear_map(Qobj.dag, True)
+-                        for element in res.elements]
+-        return res
+-
+-    def to(self, data_type):
+-        """
+-        Convert the underlying data store of all component into the desired
+-        storage representation.
+-
+-        The different storage representations available are the "data-layer
+-        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
+-        which respectively construct a dense matrix store and a compressed
+-        sparse row one.
+-
+-        The `QobjEvo` is transformed inplace.
+-
+-        Parameters
+-        ----------
+-        data_type : type
+-            The data-layer type that the data of this `Qobj` should be
+-            converted to.
+-
+-        Returns
+-        -------
+-        None
+-        """
+-        return self.linear_map(partial(Qobj.to, data_type=data_type),
+-                               _skip_check=True)
+-
+-    def tidyup(self, atol=1e-12):
+-        """Removes small elements from quantum object."""
+-        for element in self.elements:
+-            if type(element) is _ConstantElement:
+-                element = _ConstantElement(element.qobj(0).tidyup(atol))
+-            elif type(element) is _EvoElement:
+-                element = _EvoElement(element.qobj(0).tidyup(atol),
+-                                      element._coefficient)
+-        return self
+-
+-    def linear_map(self, op_mapping, *, _skip_check=False):
+-        """
+-        Apply mapping to each Qobj contribution.
+-
+-        Example:
+-        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
+-        gives the same result has
+-        ``QobjEvo([spre(sigmax()), coeff])``
+-
+-        Returns
+-        -------
+-        :class:`.QobjEvo`
+-            Modified object
+-
+-        Notes
+-        -----
+-        Does not modify the coefficients, thus ``linear_map(conj)`` would not
+-        give the the conjugate of the QobjEvo. It's only valid for linear
+-        transformations.
+-        """
+-        if not _skip_check:
+-            out = op_mapping(self(0))
+-            if not isinstance(out, Qobj):
+-                raise TypeError("The op_mapping function must return a Qobj")
+-        cdef QobjEvo res = self.copy()
+-        res.elements = [element.linear_map(op_mapping) for element in res.elements]
+-        res.dims = res.elements[0].qobj(0).dims
+-        res.shape = res.elements[0].qobj(0).shape
+-        res.type = res.elements[0].qobj(0).type
+-        res._issuper = res.elements[0].qobj(0).issuper
+-        res._isoper = res.elements[0].qobj(0).isoper
+-        if not _skip_check:
+-            if res(0) != out:
+-                raise ValueError("The mapping is not linear")
+-
+-        return res
+-
+-    ###########################################################################
+-    # Cleaning and compress                                                   #
+-    ###########################################################################
+-    def _compress_merge_qobj(self, coeff_elements):
+-        """Merge element with matching qobj:
+-        ``[A, f1], [A, f2] -> [A, f1+f2]``
+-        """
+-        cleaned_elements = []
+-        # Mimic a dict with Qobj not hashable
+-        qobjs = []
+-        coeffs = []
+-        for element in coeff_elements:
+-            for i, qobj in enumerate(qobjs):
+-                if element.qobj(0) == qobj:
+-                    coeffs[i] = coeffs[i] + element._coefficient
+-                    break
+-            else:
+-                qobjs.append(element.qobj(0))
+-                coeffs.append(element._coefficient)
+-        for qobj, coeff in zip(qobjs, coeffs):
+-            cleaned_elements.append(_EvoElement(qobj, coeff))
+-        return cleaned_elements
+-
+-    def compress(self):
+-        """
+-        Look for redundance in the :obj:`~QobjEvo` components:
+-
+-        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
+-        summed.
+-        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
+-
+-        Example:
+-        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
+-
+-        The :class:`~QobjEvo` is transformed inplace.
+-
+-        Returns
+-        -------
+-        None
+-        """
+-        cte_elements = []
+-        coeff_elements = []
+-        func_elements = []
+-        for element in self.elements:
+-            if type(element) is _ConstantElement:
+-                cte_elements.append(element)
+-            elif type(element) is _EvoElement:
+-                coeff_elements.append(element)
+-            else:
+-                func_elements.append(element)
+-
+-        cleaned_elements = []
+-        if len(cte_elements) >= 2:
+-            # Multiple constant parts
+-            cleaned_elements.append(_ConstantElement(
+-                sum(element.qobj(0) for element in cte_elements)))
+-        else:
+-            cleaned_elements += cte_elements
+-
+-        coeff_elements = self._compress_merge_qobj(coeff_elements)
+-        cleaned_elements += coeff_elements + func_elements
+-
+-        self.elements = cleaned_elements
+-
+-    def to_list(QobjEvo self):
+-        """
+-        Restore the QobjEvo to a list form.
+-
+-        Returns
+-        -------
+-        list_qevo: list
+-            The QobjEvo as a list, element are either :class:`Qobj` for
+-            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
+-            The original format of the :class:`Coefficient` is not restored.
+-            Lastly if the original `QobjEvo` is constructed with a function
+-            returning a Qobj, the term is returned as a pair of the original
+-            function and args (``dict``).
+-        """
+-        out = []
+-        for element in self.elements:
+-            if isinstance(element, _ConstantElement):
+-                out.append(element.qobj(0))
+-            elif isinstance(element, _EvoElement):
+-                coeff = element._coefficient
+-                out.append([element.qobj(0), coeff])
+-            elif isinstance(element, _FuncElement):
+-                func = element._func
+-                args = element._args
+-                out.append([func, args])
+-            else:
+-                out.append([element, {}])
+-        return out
+-
+-    ###########################################################################
+-    # properties                                                              #
+-    ###########################################################################
+-    @property
+-    def num_elements(self):
+-        """Number of parts composing the system"""
+-        return len(self.elements)
+-
+-    @property
+-    def isconstant(self):
+-        """Does the system change depending on ``t``"""
+-        return not any(type(element) is not _ConstantElement
+-                       for element in self.elements)
+-
+-    @property
+-    def isoper(self):
+-        """Indicates if the system represents an operator."""
+-        # TODO: isoper should be part of dims
+-        if self._isoper == -1:
+-            self._isoper = type_from_dims(self.dims) == "oper"
+-        return self._isoper
+-
+-    @property
+-    def issuper(self):
+-        """Indicates if the system represents a superoperator."""
+-        # TODO: issuper should/will be part of dims
+-        # remove self._issuper then
+-        if self._issuper == -1:
+-            self._issuper = type_from_dims(self.dims) == "super"
+-        return self._issuper
+-
+-    ###########################################################################
+-    # operation methods                                                       #
+-    ###########################################################################
+-    def expect(QobjEvo self, object t, state, check_real=True):
+-        """
+-        Expectation value of this operator at time ``t`` with the state.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time of the operator to apply.
+-
+-        state : Qobj
+-            right matrix of the product
+-
+-        check_real : bool (True)
+-            Whether to convert the result to a `real` when the imaginary part
+-            is smaller than the real part by a dactor of
+-            ``settings.core['rtol']``.
+-
+-        Returns
+-        -------
+-        expect : float or complex
+-            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
+-            ``trace(self @ matrix)`` is ``state`` is an operator or
+-            operator-ket.
+-        """
+-        # TODO: remove reading from `settings` for a typed value when options
+-        # support property.
+-        cdef float herm_rtol = settings.core['rtol']
+-        if not isinstance(state, Qobj):
+-            raise TypeError("A Qobj state is expected")
+-        if not (self.isoper or self.issuper):
+-            raise ValueError("Must be an operator or super operator to compute"
+-                             " an expectation value")
+-        if not (
+-            (self.dims[1] == state.dims[0]) or
+-            (self.issuper and self.dims[1] == state.dims)
+-        ):
+-            raise ValueError("incompatible dimensions " + str(self.dims) +
+-                             ", " + str(state.dims))
+-        out = self.expect_data(t, state.data)
+-        if (
+-            check_real and
+-            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
+-        ):
+-            return out.real
+-        return out
+-
+-    cpdef object expect_data(QobjEvo self, object t, Data state):
+-        """
+-        Expectation is defined as ``state.adjoint() @ self @ state`` if
+-        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
+-        superoperator.  If ``state`` is an operator and ``self`` is an
+-        operator, then expectation is ``trace(self @ matrix)``.
+-        """
+-        if type(state) is Dense:
+-            return self._expect_dense(t, state)
+-        cdef _BaseElement part
+-        cdef object out = 0.
+-        cdef Data part_data
+-        cdef object expect_func
+-        t = self._prepare(t, state)
+-        if self.issuper:
+-            if state.shape[1] != 1:
+-                state = _data.column_stack(state)
+-            expect_func = _data.expect_super
+-        else:
+-            expect_func = _data.expect
+-
+-        for element in self.elements:
+-            part = (<_BaseElement> element)
+-            part_data = part.data(t)
+-            out += part.coeff(t) * expect_func(part_data, state)
+-        return out
+-
+-    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
+-        """For Dense state, ``column_stack_dense`` can be done inplace if in
+-        fortran format."""
+-        cdef size_t nrow = state.shape[0]
+-        cdef _BaseElement part
+-        cdef double complex out = 0., coeff
+-        cdef Data part_data
+-        t = self._prepare(t, state)
+-        if self.issuper:
+-            if state.shape[1] != 1:
+-                state = column_stack_dense(state, inplace=state.fortran)
+-            try:
+-                for element in self.elements:
+-                    part = (<_BaseElement> element)
+-                    coeff = part.coeff(t)
+-                    part_data = part.data(t)
+-                    out += coeff * expect_super_data_dense(part_data, state)
+-            finally:
+-                if state.fortran:
+-                    # `state` was reshaped inplace, restore it's original shape
+-                    column_unstack_dense(state, nrow, inplace=state.fortran)
+-        else:
+-            for element in self.elements:
+-                part = (<_BaseElement> element)
+-                coeff = part.coeff(t)
+-                part_data = part.data(t)
+-                out += coeff * expect_data_dense(part_data, state)
+-        return out
+-
+-    def matmul(self, t, state):
+-        """
+-        Product of this operator at time ``t`` to the state.
+-        ``self(t) @ state``
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time of the operator to apply.
+-        state : Qobj
+-            right matrix of the product
+-
+-        Returns
+-        -------
+-        product : Qobj
+-            The result product as a Qobj
+-        """
+-        if not isinstance(state, Qobj):
+-            raise TypeError("A Qobj state is expected")
+-
+-        if self.dims[1] != state.dims[0]:
+-            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
+-                             ", " + str(state.dims[0]))
+-
+-        return Qobj(self.matmul_data(t, state.data),
+-                    dims=[self.dims[0], state.dims[1]],
+-                    copy=False
+-                    )
+-
+-    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
+-        """Compute ``out += self(t) @ state``"""
+-        cdef _BaseElement part
+-        t = self._prepare(t, state)
+-        if out is None and type(state) is Dense:
+-            out = dense.zeros(self.shape[0], state.shape[1],
+-                              (<Dense> state).fortran)
+-        elif out is None:
+-            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
+-
+-        for element in self.elements:
+-            part = (<_BaseElement> element)
+-            out = part.matmul_data_t(t, state, out)
+-        return out
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
++
++import numpy as np
++import numbers
++import itertools
++from functools import partial
++
++import qutip
++from .. import Qobj
++from .. import data as _data
++from ..coefficient import coefficient, CompilationOptions
++from ._element import *
++from ..dimensions import type_from_dims
++from qutip.settings import settings
++
++from qutip.core.cy._element cimport _BaseElement
++from qutip.core.data cimport Dense, Data, dense
++from qutip.core.data.expect cimport *
++from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
++from qutip.core.cy.coefficient cimport Coefficient
++from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
++from libc.math cimport fabs
++
++__all__ = ['QobjEvo']
++
++cdef class QobjEvo:
++    """
++    A class for representing time-dependent quantum objects, such as quantum
++    operators and states.
++
++    Importantly, :obj:`~QobjEvo` instances are used to represent such
++    time-dependent quantum objects when working with QuTiP solvers.
++
++    A :obj:`~QobjEvo` instance may be constructed from one of the following:
++
++      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
++        value of the quantum object at time ``t``.
++
++      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
++        any item that can be used to construct a coefficient (e.g. a function,
++        a numpy array of coefficient values, a string expression).
++
++      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
++
++      * a list of such callables, pairs or :obj:`~Qobj`\s.
++
++      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
++        are ignored except ``args`` which, if passed, replaces the existing
++        arguments).
++
++    Parameters
++    ----------
++    Q_object : callable, list or Qobj
++        A specification of the time-depedent quantum object. See the
++        paragraph above for a full description and the examples section below
++        for examples.
++
++    args : dict, optional
++        A dictionary that contains the arguments for the coefficients.
++        Arguments may be omitted if no function or string coefficients that
++        require arguments are present.
++
++    tlist : array-like, optional
++        A list of times corresponding to the values of the coefficients
++        supplied as numpy arrays. If no coefficients are supplied as numpy
++        arrays, ``tlist`` may be omitted, otherwise it is required.
++
++        The times in ``tlist`` do not need to be equidistant, but must
++        be sorted.
++
++        By default, a cubic spline interpolation will be used to interpolate
++        the value of the (numpy array) coefficients at time ``t``. If the
++        coefficients are to be treated as step functions, pass the argument
++        ``order=0`` (see below).
++
++    order : int, default=3
++        Order of the spline interpolation that is to be used to interpolate
++        the value of the (numpy array) coefficients at time ``t``.
++        ``0`` use previous or left value.
++
++    copy : bool, default=True
++        Whether to make a copy of the :obj:`Qobj` instances supplied in
++        the ``Q_object`` parameter.
++
++    compress : bool, default=True
++        Whether to compress the :obj:`QobjEvo` instance terms after the
++        instance has been created.
++
++        This sums the constant terms in a single term and combines
++        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
++        pair containing the sum of the coefficients.
++
++        See :meth:`compress`.
++
++    function_style : {None, "pythonic", "dict", "auto"}
++        The style of function signature used by callables in ``Q_object``.
++        If style is ``None``, the value of
++        ``qutip.settings.core["function_coefficient_style"]``
++        is used. Otherwise the supplied value overrides the global setting.
++
++
++    boundary_conditions : 2-Tuple, str or None, optional
++        Boundary conditions for spline evaluation. Default value is `None`.
++        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
++        Refer to Scipy's documentation for further details:
++        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
++
++
++    Attributes
++    ----------
++    dims : list
++        List of dimensions keeping track of the tensor structure.
++
++    shape : (int, int)
++        List of dimensions keeping track of the tensor structure.
++
++    type : str
++        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
++        'operator-bra', or 'super'.
++
++    superrep : str
++        Representation used if `type` is 'super'. One of 'super'
++        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
++
++    Examples
++    --------
++
++    A :obj:`~QobjEvo` constructed from a function:
++
++    .. code-block::
++
++        def f(t, args):
++            return qutip.qeye(N) * np.exp(args['w'] * t)
++
++        QobjEvo(f, args={'w': 1j})
++
++
++    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
++    ``[Qobj, Coefficient]`` pairs:
++
++    .. code-block::
++
++        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
++
++    The coefficients may be specified either using a :obj:`~Coefficient`
++    object or by a function, string, numpy array or any object that
++    can be passed to the :func:`~coefficient` function. See the documentation
++    of :func:`coefficient` for a full description.
++
++    An example of a coefficient specified by a function:
++
++    .. code-block::
++
++        def f1_t(t, args):
++            return np.exp(-1j * t * args["w1"])
++
++        QobjEvo([[H1, f1_t]], args={"w1": 1.})
++
++    And of coefficients specified by string expressions:
++
++    .. code-block::
++
++        H = QobjEvo(
++            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
++            args={"w1": 1., "w2": 2.}
++        )
++
++    Coefficients maybe also be expressed as numpy arrays giving a list
++    of the coefficient values:
++
++    .. code-block:: python
++
++        tlist = np.logspace(-5, 0, 100)
++        H = QobjEvo(
++            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
++            tlist=tlist
++        )
++
++    The coeffients array must have the same len as the tlist.
++
++    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
++    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
++
++    .. code-block:: python
++
++        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
++        qevo = H0 + H1 * coeff
++
++    """
++    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
++                 order=3, copy=True, compress=True,
++                 function_style=None, boundary_conditions=None):
++        if isinstance(Q_object, QobjEvo):
++            self.dims = Q_object.dims.copy()
++            self.shape = Q_object.shape
++            self.type = Q_object.type
++            self._issuper = (<QobjEvo> Q_object)._issuper
++            self._isoper = (<QobjEvo> Q_object)._isoper
++            self.elements = (<QobjEvo> Q_object).elements.copy()
++            if args:
++                self.arguments(args)
++            if compress:
++                self.compress()
++            return
++
++        self.elements = []
++        self.dims = None
++        self.shape = (0, 0)
++        self._issuper = -1
++        self._isoper = -1
++        args = args or {}
++
++        if (
++            isinstance(Q_object, list)
++            and len(Q_object) == 2
++            and isinstance(Q_object[0], Qobj)
++            and not isinstance(Q_object[1], (Qobj, list))
++        ):
++            # The format is [Qobj, coefficient]
++            Q_object = [Q_object]
++
++        if isinstance(Q_object, list):
++            for op in Q_object:
++                self.elements.append(
++                    self._read_element(
++                        op, copy=copy, tlist=tlist, args=args, order=order,
++                        function_style=function_style,
++                        boundary_conditions=boundary_conditions
++                    )
++                )
++        else:
++            self.elements.append(
++                self._read_element(
++                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
++                    function_style=function_style,
++                    boundary_conditions=boundary_conditions
++                )
++            )
++
++        if compress:
++            self.compress()
++
++    def __repr__(self):
++        cls = self.__class__.__name__
++        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
++        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
++        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
++        return repr_str
++
++    def _read_element(self, op, copy, tlist, args, order, function_style, 
++                      boundary_conditions):
++        """ Read a Q_object item and return an element for that item. """
++        if isinstance(op, Qobj):
++            out = _ConstantElement(op.copy() if copy else op)
++            qobj = op
++        elif isinstance(op, list):
++            out = _EvoElement(
++                op[0].copy() if copy else op[0],
++                coefficient(op[1], tlist=tlist, args=args, order=order, 
++                            boundary_conditions=boundary_conditions)
++            )
++            qobj = op[0]
++        elif isinstance(op, _BaseElement):
++            out = op
++            qobj = op.qobj(0)
++        elif callable(op):
++            out = _FuncElement(op, args, style=function_style)
++            qobj = out.qobj(0)
++            if not isinstance(qobj, Qobj):
++                raise TypeError(
++                    "Function based time-dependent elements must have the"
++                    " signature f(t: double, args: dict) -> Qobj, but"
++                    " {!r} returned: {!r}".format(op, qobj)
++                )
++        else:
++            raise TypeError(
++                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
++                " or a function f(t: double, args: dict) -> Qobj, but"
++                " received: {!r}".format(op)
++            )
++
++        if self.dims is None:
++            self.dims = qobj.dims
++            self.shape = qobj.shape
++            self.type = qobj.type
++            self.superrep = qobj.superrep
++        elif self.dims != qobj.dims or self.shape != qobj.shape:
++            raise ValueError(
++                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
++                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
++                f" and shape {self.shape!r}."
++            )
++        elif self.type != qobj.type:
++            raise ValueError(
++                f"QobjEvo term {op!r} has type {qobj.type!r} but "
++                f"previous terms had type {self.type!r}."
++            )
++        elif self.superrep != qobj.superrep:
++            raise ValueError(
++                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
++                f"previous terms had superrep {self.superrep!r}."
++            )
++
++        return out
++
++    @classmethod
++    def _restore(cls, elements, dims, shape, type, superrep, flags):
++        """Recreate a QobjEvo without using __init__. """
++        cdef QobjEvo out = cls.__new__(cls)
++        out.elements = elements
++        out.dims = dims
++        out.shape = shape
++        out.type = type
++        out.superrep = superrep
++        out._issuper, out._isoper = flags
++        return out
++
++    def _getstate(self):
++        """ Obtain the state """
++        # For jax pytree representation
++        # auto_pickle create similar method __getstate__, but since it's
++        # automatically created, it could change depending on cython version
++        # etc., so we create our own.
++        return {
++            "elements": self.elements,
++            "dims": self.dims,
++            "shape": self.shape,
++            "type": self.type,
++            "superrep": self.superrep,
++            "flags": (self._issuper, self._isoper,)
++        }
++
++    def __call__(self, double t, dict _args=None, **kwargs):
++        """
++        Get the :class:`~Qobj` at ``t``.
++
++        Parameters
++        ----------
++        t : float
++            Time at which the ``QobjEvo`` is to be evalued.
++
++        _args : dict [optional]
++            New arguments as a dict. Update args with ``arguments(new_args)``.
++
++        **kwargs :
++            New arguments as a keywors. Update args with
++            ``arguments(**new_args)``.
++
++        .. note::
++            If both the positional ``_args`` and keywords are passed new values
++            from both will be used. If a key is present with both, the
++            ``_args`` dict value will take priority.
++        """
++        if _args is not None or kwargs:
++            if _args is not None:
++                kwargs.update(_args)
++            return QobjEvo(self, args=kwargs)(t)
++
++        t = self._prepare(t, None)
++
++        if self.isconstant:
++            # For constant QobjEvo's, we sum the contained Qobjs directly in
++            # order to retain the cached values of attributes like .isherm when
++            # possible, rather than calling _call(t) which may lose this cached
++            # information.
++            return sum(element.qobj(t) for element in self.elements)
++
++        cdef _BaseElement part = self.elements[0]
++        cdef double complex coeff = part.coeff(t)
++        obj = part.qobj(t)
++        cdef Data out = _data.mul(obj.data, coeff)
++        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
++        for element in self.elements[1:]:
++            part = <_BaseElement> element
++            coeff = part.coeff(t)
++            obj = part.qobj(t)
++            isherm &= <bint> obj._isherm and coeff.imag == 0
++            out = _data.add(out, obj.data, coeff)
++
++        return Qobj(
++            out, dims=self.dims, copy=False, isherm=isherm or None,
++            type=self.type, superrep=self.superrep
++        )
++
++    cpdef Data _call(QobjEvo self, double t):
++        t = self._prepare(t, None)
++        cdef Data out
++        cdef _BaseElement part = self.elements[0]
++        out = _data.mul(part.data(t),
++                        part.coeff(t))
++        for element in self.elements[1:]:
++            part = <_BaseElement> element
++
++            out = _data.add(
++                out,
++                part.data(t),
++                part.coeff(t)
++            )
++        return out
++
++    cdef object _prepare(QobjEvo self, object t, Data state=None):
++        """ Precomputation before computing getting the element at `t`"""
++        # We keep the function for feedback eventually
++        return t
++
++    def copy(QobjEvo self):
++        """Return a copy of this `QobjEvo`"""
++        return QobjEvo(self, compress=False)
++
++    def arguments(QobjEvo self, dict _args=None, **kwargs):
++        """
++        Update the arguments.
++
++        Parameters
++        ----------
++        _args : dict [optional]
++            New arguments as a dict. Update args with ``arguments(new_args)``.
++
++        **kwargs :
++            New arguments as a keywors. Update args with
++            ``arguments(**new_args)``.
++
++        .. note::
++            If both the positional ``_args`` and keywords are passed new values
++            from both will be used. If a key is present with both, the ``_args``
++            dict value will take priority.
++        """
++        if _args is not None:
++            kwargs.update(_args)
++        cache = []
++        self.elements = [
++            element.replace_arguments(kwargs, cache=cache)
++            for element in self.elements
++        ]
++
++
++    ###########################################################################
++    # Math function                                                           #
++    ###########################################################################
++    def __add__(left, right):
++        if isinstance(left, QobjEvo):
++            self = left
++            other = right
++        else:
++            self = right
++            other = left
++        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
++            return NotImplemented
++        res = self.copy()
++        res += other
++        return res
++
++    def __radd__(self, other):
++        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
++            return NotImplemented
++        res = self.copy()
++        res += other
++        return res
++
++    def __iadd__(QobjEvo self, other):
++        cdef _BaseElement element
++        if isinstance(other, QobjEvo):
++            if other.dims != self.dims:
++                raise TypeError("incompatible dimensions" +
++                                str(self.dims) + ", " + str(other.dims))
++            for element in (<QobjEvo> other).elements:
++                self.elements.append(element)
++        elif isinstance(other, Qobj):
++            if other.dims != self.dims:
++                raise TypeError("incompatible dimensions" +
++                                str(self.dims) + ", " + str(other.dims))
++            self.elements.append(_ConstantElement(other))
++        elif (
++            isinstance(other, numbers.Number) and
++            self.dims[0] == self.dims[1]
++        ):
++            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
++        else:
++            return NotImplemented
++        return self
++
++    def __sub__(left, right):
++        if isinstance(left, QobjEvo):
++            res = left.copy()
++            res += -right
++            return res
++        else:
++            res = -right.copy()
++            res += left
++            return res
++
++    def __rsub__(self, other):
++        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
++            return NotImplemented
++        res = -self
++        res += other
++        return res
++
++    def __isub__(self, other):
++        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
++            return NotImplemented
++        self += (-other)
++        return self
++
++    def __matmul__(left, right):
++        cdef QobjEvo res
++        if isinstance(left, QobjEvo):
++            return left.copy().__imatmul__(right)
++        elif isinstance(left, Qobj):
++            if left.dims[1] != (<QobjEvo> right).dims[0]:
++                raise TypeError("incompatible dimensions" +
++                                 str(left.dims[1]) + ", " +
++                                 str((<QobjEvo> right).dims[0]))
++
++            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
++            if type_ is None:
++                raise TypeError(
++                    "incompatible matmul types "
++                    + repr(left.type) + " and " + repr(right.type)
++                )
++
++            res = right.copy()
++            res.dims = [left.dims[0], right.dims[1]]
++            res.shape = (left.shape[0], right.shape[1])
++            res.type = type_
++            left = _ConstantElement(left)
++            res.elements = [left @ element for element in res.elements]
++            res._issuper = -1
++            res._isoper = -1
++            return res
++        else:
++            return NotImplemented
++
++    def __rmatmul__(QobjEvo self, other):
++        cdef QobjEvo res
++        if isinstance(other, Qobj):
++            if other.dims[1] != self.dims[0]:
++                raise TypeError("incompatible dimensions" +
++                                 str(other.dims[1]) + ", " +
++                                 str(self.dims[0]))
++
++            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
++            if type_ is None:
++                raise TypeError(
++                    "incompatible matmul types "
++                    + repr(other.type) + " and " + repr(self.type)
++                )
++
++            res = self.copy()
++            res.dims = [other.dims[0], res.dims[1]]
++            res.shape = (other.shape[0], res.shape[1])
++            res.type = type_
++            other = _ConstantElement(other)
++            res.elements = [other @ element for element in res.elements]
++            res._issuper = -1
++            res._isoper = -1
++            return res
++        else:
++            return NotImplemented
++
++    def __imatmul__(QobjEvo self, other):
++        if isinstance(other, (Qobj, QobjEvo)):
++            if self.dims[1] != other.dims[0]:
++                raise TypeError("incompatible dimensions" +
++                                str(self.dims[1]) + ", " +
++                                str(other.dims[0]))
++
++            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
++            if type_ is None:
++                raise TypeError(
++                    "incompatible matmul types "
++                    + repr(self.type) + " and " + repr(other.type)
++                )
++
++            self.dims = [self.dims[0], other.dims[1]]
++            self.shape = (self.shape[0], other.shape[1])
++            self.type = type_
++            self._issuper = -1
++            self._isoper = -1
++            if isinstance(other, Qobj):
++                other = _ConstantElement(other)
++                self.elements = [element @ other for element in self.elements]
++
++            elif isinstance(other, QobjEvo):
++                self.elements = [left @ right
++                    for left, right in itertools.product(
++                        self.elements, (<QobjEvo> other).elements
++                    )]
++        else:
++            return NotImplemented
++        return self
++
++    def __mul__(left, right):
++        if isinstance(left, QobjEvo):
++            return left.copy().__imul__(right)
++        elif isinstance(left, Qobj):
++            return right.__rmatmul__(left)
++        elif isinstance(left, (numbers.Number, Coefficient)):
++            return right.copy().__imul__(left)
++        else:
++            return NotImplemented
++
++    def __rmul__(self, other):
++        if isinstance(other, Qobj):
++            return self.__rmatmul__(other)
++        else:
++            res = self.copy()
++            res *= other
++            return res
++
++    def __imul__(QobjEvo self, other):
++        if isinstance(other, (Qobj, QobjEvo)):
++            self @= other
++        elif isinstance(other, numbers.Number):
++            self.elements = [element * other for element in self.elements]
++        elif isinstance(other, Coefficient):
++            other = _EvoElement(qutip.qeye(self.dims[1]), other)
++            self.elements = [element @ other for element in self.elements]
++        else:
++            return NotImplemented
++        return self
++
++    def __truediv__(left, right):
++        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
++            res = left.copy()
++            res *= 1 / right
++            return res
++        return NotImplemented
++
++    def __idiv__(self, other):
++        if not isinstance(other, numbers.Number):
++            return NotImplemented
++        self *= 1 / other
++        return self
++
++    def __neg__(self):
++        res = self.copy()
++        res *= -1
++        return res
++
++    ###########################################################################
++    # tensor                                                                  #
++    ###########################################################################
++    def __and__(left, right):
++        """
++        Syntax shortcut for tensor:
++        A & B ==> tensor(A, B)
++        """
++        return qutip.tensor(left, right)
++
++    ###########################################################################
++    # Unary transformation                                                    #
++    ###########################################################################
++    def trans(self):
++        """ Transpose of the quantum object """
++        cdef QobjEvo res = self.copy()
++        res.elements = [element.linear_map(Qobj.trans)
++                        for element in res.elements]
++        return res
++
++    def conj(self):
++        """Get the element-wise conjugation of the quantum object."""
++        cdef QobjEvo res = self.copy()
++        res.elements = [element.linear_map(Qobj.conj, True)
++                        for element in res.elements]
++        return res
++
++    def dag(self):
++        """Get the Hermitian adjoint of the quantum object."""
++        cdef QobjEvo res = self.copy()
++        res.elements = [element.linear_map(Qobj.dag, True)
++                        for element in res.elements]
++        return res
++
++    def to(self, data_type):
++        """
++        Convert the underlying data store of all component into the desired
++        storage representation.
++
++        The different storage representations available are the "data-layer
++        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
++        which respectively construct a dense matrix store and a compressed
++        sparse row one.
++
++        The `QobjEvo` is transformed inplace.
++
++        Parameters
++        ----------
++        data_type : type
++            The data-layer type that the data of this `Qobj` should be
++            converted to.
++
++        Returns
++        -------
++        None
++        """
++        return self.linear_map(partial(Qobj.to, data_type=data_type),
++                               _skip_check=True)
++
++    def tidyup(self, atol=1e-12):
++        """Removes small elements from quantum object."""
++        for element in self.elements:
++            if type(element) is _ConstantElement:
++                element = _ConstantElement(element.qobj(0).tidyup(atol))
++            elif type(element) is _EvoElement:
++                element = _EvoElement(element.qobj(0).tidyup(atol),
++                                      element._coefficient)
++        return self
++
++    def linear_map(self, op_mapping, *, _skip_check=False):
++        """
++        Apply mapping to each Qobj contribution.
++
++        Example:
++        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
++        gives the same result has
++        ``QobjEvo([spre(sigmax()), coeff])``
++
++        Returns
++        -------
++        :class:`.QobjEvo`
++            Modified object
++
++        Notes
++        -----
++        Does not modify the coefficients, thus ``linear_map(conj)`` would not
++        give the the conjugate of the QobjEvo. It's only valid for linear
++        transformations.
++        """
++        if not _skip_check:
++            out = op_mapping(self(0))
++            if not isinstance(out, Qobj):
++                raise TypeError("The op_mapping function must return a Qobj")
++        cdef QobjEvo res = self.copy()
++        res.elements = [element.linear_map(op_mapping) for element in res.elements]
++        res.dims = res.elements[0].qobj(0).dims
++        res.shape = res.elements[0].qobj(0).shape
++        res.type = res.elements[0].qobj(0).type
++        res._issuper = res.elements[0].qobj(0).issuper
++        res._isoper = res.elements[0].qobj(0).isoper
++        if not _skip_check:
++            if res(0) != out:
++                raise ValueError("The mapping is not linear")
++
++        return res
++
++    ###########################################################################
++    # Cleaning and compress                                                   #
++    ###########################################################################
++    def _compress_merge_qobj(self, coeff_elements):
++        """Merge element with matching qobj:
++        ``[A, f1], [A, f2] -> [A, f1+f2]``
++        """
++        cleaned_elements = []
++        # Mimic a dict with Qobj not hashable
++        qobjs = []
++        coeffs = []
++        for element in coeff_elements:
++            for i, qobj in enumerate(qobjs):
++                if element.qobj(0) == qobj:
++                    coeffs[i] = coeffs[i] + element._coefficient
++                    break
++            else:
++                qobjs.append(element.qobj(0))
++                coeffs.append(element._coefficient)
++        for qobj, coeff in zip(qobjs, coeffs):
++            cleaned_elements.append(_EvoElement(qobj, coeff))
++        return cleaned_elements
++
++    def compress(self):
++        """
++        Look for redundance in the :obj:`~QobjEvo` components:
++
++        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
++        summed.
++        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
++
++        Example:
++        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
++
++        The :class:`~QobjEvo` is transformed inplace.
++
++        Returns
++        -------
++        None
++        """
++        cte_elements = []
++        coeff_elements = []
++        func_elements = []
++        for element in self.elements:
++            if type(element) is _ConstantElement:
++                cte_elements.append(element)
++            elif type(element) is _EvoElement:
++                coeff_elements.append(element)
++            else:
++                func_elements.append(element)
++
++        cleaned_elements = []
++        if len(cte_elements) >= 2:
++            # Multiple constant parts
++            cleaned_elements.append(_ConstantElement(
++                sum(element.qobj(0) for element in cte_elements)))
++        else:
++            cleaned_elements += cte_elements
++
++        coeff_elements = self._compress_merge_qobj(coeff_elements)
++        cleaned_elements += coeff_elements + func_elements
++
++        self.elements = cleaned_elements
++
++    def to_list(QobjEvo self):
++        """
++        Restore the QobjEvo to a list form.
++
++        Returns
++        -------
++        list_qevo: list
++            The QobjEvo as a list, element are either :class:`Qobj` for
++            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
++            The original format of the :class:`Coefficient` is not restored.
++            Lastly if the original `QobjEvo` is constructed with a function
++            returning a Qobj, the term is returned as a pair of the original
++            function and args (``dict``).
++        """
++        out = []
++        for element in self.elements:
++            if isinstance(element, _ConstantElement):
++                out.append(element.qobj(0))
++            elif isinstance(element, _EvoElement):
++                coeff = element._coefficient
++                out.append([element.qobj(0), coeff])
++            elif isinstance(element, _FuncElement):
++                func = element._func
++                args = element._args
++                out.append([func, args])
++            else:
++                out.append([element, {}])
++        return out
++
++    ###########################################################################
++    # properties                                                              #
++    ###########################################################################
++    @property
++    def num_elements(self):
++        """Number of parts composing the system"""
++        return len(self.elements)
++
++    @property
++    def isconstant(self):
++        """Does the system change depending on ``t``"""
++        return not any(type(element) is not _ConstantElement
++                       for element in self.elements)
++
++    @property
++    def isoper(self):
++        """Indicates if the system represents an operator."""
++        # TODO: isoper should be part of dims
++        if self._isoper == -1:
++            self._isoper = type_from_dims(self.dims) == "oper"
++        return self._isoper
++
++    @property
++    def issuper(self):
++        """Indicates if the system represents a superoperator."""
++        # TODO: issuper should/will be part of dims
++        # remove self._issuper then
++        if self._issuper == -1:
++            self._issuper = type_from_dims(self.dims) == "super"
++        return self._issuper
++
++    ###########################################################################
++    # operation methods                                                       #
++    ###########################################################################
++    def expect(QobjEvo self, object t, state, check_real=True):
++        """
++        Expectation value of this operator at time ``t`` with the state.
++
++        Parameters
++        ----------
++        t : float
++            Time of the operator to apply.
++
++        state : Qobj
++            right matrix of the product
++
++        check_real : bool (True)
++            Whether to convert the result to a `real` when the imaginary part
++            is smaller than the real part by a dactor of
++            ``settings.core['rtol']``.
++
++        Returns
++        -------
++        expect : float or complex
++            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
++            ``trace(self @ matrix)`` is ``state`` is an operator or
++            operator-ket.
++        """
++        # TODO: remove reading from `settings` for a typed value when options
++        # support property.
++        cdef float herm_rtol = settings.core['rtol']
++        if not isinstance(state, Qobj):
++            raise TypeError("A Qobj state is expected")
++        if not (self.isoper or self.issuper):
++            raise ValueError("Must be an operator or super operator to compute"
++                             " an expectation value")
++        if not (
++            (self.dims[1] == state.dims[0]) or
++            (self.issuper and self.dims[1] == state.dims)
++        ):
++            raise ValueError("incompatible dimensions " + str(self.dims) +
++                             ", " + str(state.dims))
++        out = self.expect_data(t, state.data)
++        if (
++            check_real and
++            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
++        ):
++            return out.real
++        return out
++
++    cpdef object expect_data(QobjEvo self, object t, Data state):
++        """
++        Expectation is defined as ``state.adjoint() @ self @ state`` if
++        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
++        superoperator.  If ``state`` is an operator and ``self`` is an
++        operator, then expectation is ``trace(self @ matrix)``.
++        """
++        if type(state) is Dense:
++            return self._expect_dense(t, state)
++        cdef _BaseElement part
++        cdef object out = 0.
++        cdef Data part_data
++        cdef object expect_func
++        t = self._prepare(t, state)
++        if self.issuper:
++            if state.shape[1] != 1:
++                state = _data.column_stack(state)
++            expect_func = _data.expect_super
++        else:
++            expect_func = _data.expect
++
++        for element in self.elements:
++            part = (<_BaseElement> element)
++            part_data = part.data(t)
++            out += part.coeff(t) * expect_func(part_data, state)
++        return out
++
++    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
++        """For Dense state, ``column_stack_dense`` can be done inplace if in
++        fortran format."""
++        cdef size_t nrow = state.shape[0]
++        cdef _BaseElement part
++        cdef double complex out = 0., coeff
++        cdef Data part_data
++        t = self._prepare(t, state)
++        if self.issuper:
++            if state.shape[1] != 1:
++                state = column_stack_dense(state, inplace=state.fortran)
++            try:
++                for element in self.elements:
++                    part = (<_BaseElement> element)
++                    coeff = part.coeff(t)
++                    part_data = part.data(t)
++                    out += coeff * expect_super_data_dense(part_data, state)
++            finally:
++                if state.fortran:
++                    # `state` was reshaped inplace, restore it's original shape
++                    column_unstack_dense(state, nrow, inplace=state.fortran)
++        else:
++            for element in self.elements:
++                part = (<_BaseElement> element)
++                coeff = part.coeff(t)
++                part_data = part.data(t)
++                out += coeff * expect_data_dense(part_data, state)
++        return out
++
++    def matmul(self, t, state):
++        """
++        Product of this operator at time ``t`` to the state.
++        ``self(t) @ state``
++
++        Parameters
++        ----------
++        t : float
++            Time of the operator to apply.
++        state : Qobj
++            right matrix of the product
++
++        Returns
++        -------
++        product : Qobj
++            The result product as a Qobj
++        """
++        if not isinstance(state, Qobj):
++            raise TypeError("A Qobj state is expected")
++
++        if self.dims[1] != state.dims[0]:
++            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
++                             ", " + str(state.dims[0]))
++
++        return Qobj(self.matmul_data(t, state.data),
++                    dims=[self.dims[0], state.dims[1]],
++                    copy=False
++                    )
++
++    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
++        """Compute ``out += self(t) @ state``"""
++        cdef _BaseElement part
++        t = self._prepare(t, state)
++        if out is None and type(state) is Dense:
++            out = dense.zeros(self.shape[0], state.shape[1],
++                              (<Dense> state).fortran)
++        elif out is None:
++            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
++
++        for element in self.elements:
++            part = (<_BaseElement> element)
++            out = part.matmul_data_t(t, state, out)
++        return out
+diff --git a/qutip/core/data/__init__.pxd b/qutip/core/data/__init__.pxd
+index c1b4e680..1f5c75d9 100644
+--- a/qutip/core/data/__init__.pxd
++++ b/qutip/core/data/__init__.pxd
+@@ -1,13 +1,13 @@
+-#cython: language_level=3
+-
+-# Package-level relative imports in Cython (0.29.17) are temperamental.
+-from qutip.core.data cimport dense, csr
+-from qutip.core.data.base cimport Data, idxint
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data.csr cimport CSR
+-
+-from qutip.core.data.add cimport *
+-from qutip.core.data.adjoint cimport *
+-from qutip.core.data.kron cimport *
+-from qutip.core.data.matmul cimport *
+-from qutip.core.data.mul cimport *
++#cython: language_level=3
++
++# Package-level relative imports in Cython (0.29.17) are temperamental.
++from qutip.core.data cimport dense, csr
++from qutip.core.data.base cimport Data, idxint
++from qutip.core.data.dense cimport Dense
++from qutip.core.data.csr cimport CSR
++
++from qutip.core.data.add cimport *
++from qutip.core.data.adjoint cimport *
++from qutip.core.data.kron cimport *
++from qutip.core.data.matmul cimport *
++from qutip.core.data.mul cimport *
+diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
+index 557aff5c..5fd15509 100644
+--- a/qutip/core/data/__init__.py
++++ b/qutip/core/data/__init__.py
+@@ -1,56 +1,56 @@
+-# First-class type imports
+-
+-from . import dense, csr
+-from .dense import Dense
+-from .csr import CSR
+-from .base import Data
+-
+-from .add import *
+-from .adjoint import *
+-from .constant import *
+-from .eigen import *
+-from .expect import *
+-from .expm import *
+-from .inner import *
+-from .kron import *
+-from .linalg import *
+-from .matmul import *
+-from .make import *
+-from .mul import *
+-from .pow import *
+-from .project import *
+-from .properties import *
+-from .ptrace import *
+-from .reshape import *
+-from .tidyup import *
+-from .trace import *
+-from .solve import *
+-# For operations with mulitple related versions, we just import the module.
+-from . import norm, permute
+-
+-
+-# Set up the data conversions that are known by us.  All types covered by
+-# conversions will be made available for use in the dispatcher functions.
+-
+-from .convert import to, create
+-to.add_conversions([
+-    (Dense, CSR, dense.from_csr, 1),
+-    (CSR, Dense, csr.from_dense, 1.4),
+-])
+-to.register_aliases(['csr', 'CSR'], CSR)
+-to.register_aliases(['Dense', 'dense'], Dense)
+-
+-
+-from . import _creator_utils
+-import numpy as np
+-create.add_creators([
+-    (_creator_utils.is_data, _creator_utils.data_copy, 100),
+-    (_creator_utils.isspmatrix_csr, CSR, 80),
+-    (_creator_utils.is_nparray, Dense, 80),
+-    (_creator_utils.issparse, CSR, 20),
+-    (_creator_utils.true, Dense, -np.inf),
+-])
+-del _creator_utils
+-del np
+-
+-from .dispatch import Dispatcher
++# First-class type imports
++
++from . import dense, csr
++from .dense import Dense
++from .csr import CSR
++from .base import Data
++
++from .add import *
++from .adjoint import *
++from .constant import *
++from .eigen import *
++from .expect import *
++from .expm import *
++from .inner import *
++from .kron import *
++from .linalg import *
++from .matmul import *
++from .make import *
++from .mul import *
++from .pow import *
++from .project import *
++from .properties import *
++from .ptrace import *
++from .reshape import *
++from .tidyup import *
++from .trace import *
++from .solve import *
++# For operations with mulitple related versions, we just import the module.
++from . import norm, permute
++
++
++# Set up the data conversions that are known by us.  All types covered by
++# conversions will be made available for use in the dispatcher functions.
++
++from .convert import to, create
++to.add_conversions([
++    (Dense, CSR, dense.from_csr, 1),
++    (CSR, Dense, csr.from_dense, 1.4),
++])
++to.register_aliases(['csr', 'CSR'], CSR)
++to.register_aliases(['Dense', 'dense'], Dense)
++
++
++from . import _creator_utils
++import numpy as np
++create.add_creators([
++    (_creator_utils.is_data, _creator_utils.data_copy, 100),
++    (_creator_utils.isspmatrix_csr, CSR, 80),
++    (_creator_utils.is_nparray, Dense, 80),
++    (_creator_utils.issparse, CSR, 20),
++    (_creator_utils.true, Dense, -np.inf),
++])
++del _creator_utils
++del np
++
++from .dispatch import Dispatcher
+diff --git a/qutip/core/data/_creator_utils.py b/qutip/core/data/_creator_utils.py
+index 3f3779e2..1432804b 100644
+--- a/qutip/core/data/_creator_utils.py
++++ b/qutip/core/data/_creator_utils.py
+@@ -1,31 +1,31 @@
+-"""
+-Define functions to use as Data creator for `create` in `convert.py`.
+-"""
+-
+-from scipy.sparse import isspmatrix_csr, issparse
+-import numpy as np
+-from .csr import CSR
+-from .base import Data
+-from .dense import Dense
+-
+-__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
+-
+-
+-def is_data(arg):
+-    return isinstance(arg, Data)
+-
+-
+-def is_nparray(arg):
+-    return isinstance(arg, np.ndarray)
+-
+-
+-def true(arg):
+-    return True
+-
+-
+-def data_copy(arg, shape, copy=True):
+-    if shape is not None and shape != arg.shape:
+-        raise ValueError("".join([
+-            "shapes do not match: ", str(shape), " and ", str(arg.shape),
+-        ]))
+-    return arg.copy() if copy else arg
++"""
++Define functions to use as Data creator for `create` in `convert.py`.
++"""
++
++from scipy.sparse import isspmatrix_csr, issparse
++import numpy as np
++from .csr import CSR
++from .base import Data
++from .dense import Dense
++
++__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
++
++
++def is_data(arg):
++    return isinstance(arg, Data)
++
++
++def is_nparray(arg):
++    return isinstance(arg, np.ndarray)
++
++
++def true(arg):
++    return True
++
++
++def data_copy(arg, shape, copy=True):
++    if shape is not None and shape != arg.shape:
++        raise ValueError("".join([
++            "shapes do not match: ", str(shape), " and ", str(arg.shape),
++        ]))
++    return arg.copy() if copy else arg
+diff --git a/qutip/core/data/add.pxd b/qutip/core/data/add.pxd
+index edb30f14..e0594187 100644
+--- a/qutip/core/data/add.pxd
++++ b/qutip/core/data/add.pxd
+@@ -1,12 +1,12 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-
+-cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
+-cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
+-cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
+-cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
+-
+-cpdef CSR sub_csr(CSR left, CSR right)
+-cpdef Dense sub_dense(Dense left, Dense right)
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++
++cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
++cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
++cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
++cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
++
++cpdef CSR sub_csr(CSR left, CSR right)
++cpdef Dense sub_dense(Dense left, Dense right)
+diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
+index 4a24a193..0b65d2e3 100644
+--- a/qutip/core/data/add.pyx
++++ b/qutip/core/data/add.pyx
+@@ -1,276 +1,276 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-cimport cython
+-import numpy as np
+-cimport numpy as cnp
+-from scipy.linalg cimport cython_blas as blas
+-from qutip.settings import settings
+-
+-from qutip.core.data.base cimport idxint, Data
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data.csr cimport (
+-    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
+-)
+-from qutip.core.data cimport csr, dense
+-
+-cnp.import_array()
+-
+-cdef extern from *:
+-    void *PyDataMem_NEW(size_t size)
+-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
+-    void PyDataMem_FREE(void *ptr)
+-
+-
+-__all__ = [
+-    'add', 'add_csr', 'add_dense', 'iadd_dense',
+-    'sub', 'sub_csr', 'sub_dense',
+-]
+-
+-
+-cdef int _ONE=1
+-
+-
+-cdef void _check_shape(Data left, Data right) nogil except *:
+-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+-        raise ValueError(
+-            "incompatible matrix shapes "
+-            + str(left.shape)
+-            + " and "
+-            + str(right.shape)
+-        )
+-
+-
+-cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
+-    """
+-    Perform the operation
+-        c := a + b
+-    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
+-    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
+-
+-    Return the true value of nnz(c).
+-    """
+-    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
+-    cdef idxint ncols = a.shape[1]
+-    c.row_index[0] = nnz
+-    ptr_a_max = ptr_b_max = 0
+-    for row in range(a.shape[0]):
+-        ptr_a = ptr_a_max
+-        ptr_a_max = a.row_index[row + 1]
+-        ptr_b = ptr_b_max
+-        ptr_b_max = b.row_index[row + 1]
+-        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+-        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+-        # We use this method of going through the row to give the Accumulator
+-        # the best chance of receiving the scatters in a sorted order.  We
+-        # could also safely iterate through a completely then b, which would be
+-        # more cache efficient, but would quite often require a sort within the
+-        # gather, making the algorithimic complexity worse.
+-        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
+-            if col_a < col_b:
+-                acc_scatter(acc, a.data[ptr_a], col_a)
+-                ptr_a += 1
+-                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+-            else:
+-                acc_scatter(acc, b.data[ptr_b], col_b)
+-                ptr_b += 1
+-                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+-            # There's no need to test col_a == col_b because the Accumulator
+-            # already tests that in all scatters anyway.
+-        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
+-        acc_reset(acc)
+-        c.row_index[row + 1] = nnz
+-    return nnz
+-
+-
+-cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
+-                           double complex scale, double tol) nogil:
+-    """
+-    Perform the operation
+-        c := a + scale*b
+-    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
+-    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
+-
+-    Return the true value of nnz(c).
+-    """
+-    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
+-    cdef idxint ncols = a.shape[1]
+-    c.row_index[0] = nnz
+-    ptr_a_max = ptr_b_max = 0
+-    for row in range(a.shape[0]):
+-        ptr_a = ptr_a_max
+-        ptr_a_max = a.row_index[row + 1]
+-        ptr_b = ptr_b_max
+-        ptr_b_max = b.row_index[row + 1]
+-        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+-        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+-        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
+-            if col_a < col_b:
+-                acc_scatter(acc, a.data[ptr_a], col_a)
+-                ptr_a += 1
+-                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+-            else:
+-                acc_scatter(acc, scale * b.data[ptr_b], col_b)
+-                ptr_b += 1
+-                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+-        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
+-        acc_reset(acc)
+-        c.row_index[row + 1] = nnz
+-    return nnz
+-
+-
+-cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
+-    """
+-    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
+-    `right` is multiplied by `scale`, so the full operation is
+-        ``out := left + scale*right``
+-    The two matrices must be of exactly the same shape.
+-
+-    Parameters
+-    ----------
+-    left : CSR
+-        Matrix to be added.
+-    right : CSR
+-        Matrix to be added.  If `scale` is given, this matrix will be
+-        multiplied by `scale` before addition.
+-    scale : optional double complex (1)
+-        The scalar value to multiply `right` by before addition.
+-
+-    Returns
+-    -------
+-    out : CSR
+-        The result `left + scale*right`.
+-    """
+-    _check_shape(left, right)
+-    cdef idxint left_nnz = csr.nnz(left)
+-    cdef idxint right_nnz = csr.nnz(right)
+-    cdef idxint worst_nnz = left_nnz + right_nnz
+-    cdef idxint i
+-    cdef CSR out
+-    cdef Accumulator acc
+-    cdef double tol = 0
+-    if settings.core['auto_tidyup']:
+-        tol = settings.core['auto_tidyup_atol']
+-    # Fast paths for zero matrices.
+-    if right_nnz == 0 or scale == 0:
+-        return left.copy()
+-    if left_nnz == 0:
+-        out = right.copy()
+-        # Fast path if the multiplication is a no-op.
+-        if scale != 1:
+-            for i in range(right_nnz):
+-                out.data[i] *= scale
+-        return out
+-    # Main path.
+-    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
+-    acc = acc_alloc(left.shape[1])
+-    if scale == 1:
+-        _add_csr(&acc, left, right, out, tol)
+-    else:
+-        _add_csr_scale(&acc, left, right, out, scale, tol)
+-    acc_free(&acc)
+-    return out
+-
+-
+-cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
+-    cdef int size = left.shape[0] * left.shape[1]
+-    with nogil:
+-        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
+-
+-
+-cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
+-    cdef Dense out = left.copy()
+-    cdef int size = left.shape[0] * left.shape[1]
+-    with nogil:
+-        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
+-    return out
+-
+-
+-cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
+-    _check_shape(left, right)
+-    if not (left.fortran ^ right.fortran):
+-        return _add_dense_eq_order(left, right, scale)
+-    cdef Dense out = left.copy()
+-    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
+-    # We always iterate through `left` and `out` in memory-layout order.
+-    cdef int dim1, dim2
+-    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
+-    with nogil:
+-        for idx in range(dim2):
+-            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
+-    return out
+-
+-
+-cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
+-    _check_shape(left, right)
+-    cdef int size = left.shape[0] * left.shape[1]
+-    cdef int dim1, dim2
+-    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
+-    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
+-    with nogil:
+-        if not (left.fortran ^ right.fortran):
+-            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
+-        else:
+-            for idx in range(dim2):
+-                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
+-                           left.data + idx*dim1, &_ONE)
+-    return left
+-
+-
+-cpdef CSR sub_csr(CSR left, CSR right):
+-    return add_csr(left, right, -1)
+-
+-
+-cpdef Dense sub_dense(Dense left, Dense right):
+-    return add_dense(left, right, -1)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-add = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=1),
+-    ]),
+-    name='add',
+-    module=__name__,
+-    inputs=('left', 'right'),
+-    out=True,
+-)
+-add.__doc__ =\
+-    """
+-    Perform the operation
+-        left + scale*right
+-    where `left` and `right` are matrices, and `scale` is an optional complex
+-    scalar.
+-    """
+-add.add_specialisations([
+-    (Dense, Dense, Dense, add_dense),
+-    (CSR, CSR, CSR, add_csr),
+-], _defer=True)
+-
+-sub = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='sub',
+-    module=__name__,
+-    inputs=('left', 'right'),
+-    out=True,
+-)
+-sub.__doc__ =\
+-    """
+-    Perform the operation
+-        left - right
+-    where `left` and `right` are matrices.
+-    """
+-sub.add_specialisations([
+-    (Dense, Dense, Dense, sub_dense),
+-    (CSR, CSR, CSR, sub_csr),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++cimport cython
++import numpy as np
++cimport numpy as cnp
++from scipy.linalg cimport cython_blas as blas
++from qutip.settings import settings
++
++from qutip.core.data.base cimport idxint, Data
++from qutip.core.data.dense cimport Dense
++from qutip.core.data.csr cimport (
++    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
++)
++from qutip.core.data cimport csr, dense
++
++cnp.import_array()
++
++cdef extern from *:
++    void *PyDataMem_NEW(size_t size)
++    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
++    void PyDataMem_FREE(void *ptr)
++
++
++__all__ = [
++    'add', 'add_csr', 'add_dense', 'iadd_dense',
++    'sub', 'sub_csr', 'sub_dense',
++]
++
++
++cdef int _ONE=1
++
++
++cdef void _check_shape(Data left, Data right) nogil except *:
++    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
++        raise ValueError(
++            "incompatible matrix shapes "
++            + str(left.shape)
++            + " and "
++            + str(right.shape)
++        )
++
++
++cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
++    """
++    Perform the operation
++        c := a + b
++    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
++    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
++
++    Return the true value of nnz(c).
++    """
++    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
++    cdef idxint ncols = a.shape[1]
++    c.row_index[0] = nnz
++    ptr_a_max = ptr_b_max = 0
++    for row in range(a.shape[0]):
++        ptr_a = ptr_a_max
++        ptr_a_max = a.row_index[row + 1]
++        ptr_b = ptr_b_max
++        ptr_b_max = b.row_index[row + 1]
++        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
++        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
++        # We use this method of going through the row to give the Accumulator
++        # the best chance of receiving the scatters in a sorted order.  We
++        # could also safely iterate through a completely then b, which would be
++        # more cache efficient, but would quite often require a sort within the
++        # gather, making the algorithimic complexity worse.
++        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
++            if col_a < col_b:
++                acc_scatter(acc, a.data[ptr_a], col_a)
++                ptr_a += 1
++                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
++            else:
++                acc_scatter(acc, b.data[ptr_b], col_b)
++                ptr_b += 1
++                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
++            # There's no need to test col_a == col_b because the Accumulator
++            # already tests that in all scatters anyway.
++        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
++        acc_reset(acc)
++        c.row_index[row + 1] = nnz
++    return nnz
++
++
++cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
++                           double complex scale, double tol) nogil:
++    """
++    Perform the operation
++        c := a + scale*b
++    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
++    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
++
++    Return the true value of nnz(c).
++    """
++    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
++    cdef idxint ncols = a.shape[1]
++    c.row_index[0] = nnz
++    ptr_a_max = ptr_b_max = 0
++    for row in range(a.shape[0]):
++        ptr_a = ptr_a_max
++        ptr_a_max = a.row_index[row + 1]
++        ptr_b = ptr_b_max
++        ptr_b_max = b.row_index[row + 1]
++        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
++        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
++        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
++            if col_a < col_b:
++                acc_scatter(acc, a.data[ptr_a], col_a)
++                ptr_a += 1
++                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
++            else:
++                acc_scatter(acc, scale * b.data[ptr_b], col_b)
++                ptr_b += 1
++                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
++        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
++        acc_reset(acc)
++        c.row_index[row + 1] = nnz
++    return nnz
++
++
++cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
++    """
++    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
++    `right` is multiplied by `scale`, so the full operation is
++        ``out := left + scale*right``
++    The two matrices must be of exactly the same shape.
++
++    Parameters
++    ----------
++    left : CSR
++        Matrix to be added.
++    right : CSR
++        Matrix to be added.  If `scale` is given, this matrix will be
++        multiplied by `scale` before addition.
++    scale : optional double complex (1)
++        The scalar value to multiply `right` by before addition.
++
++    Returns
++    -------
++    out : CSR
++        The result `left + scale*right`.
++    """
++    _check_shape(left, right)
++    cdef idxint left_nnz = csr.nnz(left)
++    cdef idxint right_nnz = csr.nnz(right)
++    cdef idxint worst_nnz = left_nnz + right_nnz
++    cdef idxint i
++    cdef CSR out
++    cdef Accumulator acc
++    cdef double tol = 0
++    if settings.core['auto_tidyup']:
++        tol = settings.core['auto_tidyup_atol']
++    # Fast paths for zero matrices.
++    if right_nnz == 0 or scale == 0:
++        return left.copy()
++    if left_nnz == 0:
++        out = right.copy()
++        # Fast path if the multiplication is a no-op.
++        if scale != 1:
++            for i in range(right_nnz):
++                out.data[i] *= scale
++        return out
++    # Main path.
++    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
++    acc = acc_alloc(left.shape[1])
++    if scale == 1:
++        _add_csr(&acc, left, right, out, tol)
++    else:
++        _add_csr_scale(&acc, left, right, out, scale, tol)
++    acc_free(&acc)
++    return out
++
++
++cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
++    cdef int size = left.shape[0] * left.shape[1]
++    with nogil:
++        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
++
++
++cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
++    cdef Dense out = left.copy()
++    cdef int size = left.shape[0] * left.shape[1]
++    with nogil:
++        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
++    return out
++
++
++cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
++    _check_shape(left, right)
++    if not (left.fortran ^ right.fortran):
++        return _add_dense_eq_order(left, right, scale)
++    cdef Dense out = left.copy()
++    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
++    # We always iterate through `left` and `out` in memory-layout order.
++    cdef int dim1, dim2
++    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
++    with nogil:
++        for idx in range(dim2):
++            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
++    return out
++
++
++cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
++    _check_shape(left, right)
++    cdef int size = left.shape[0] * left.shape[1]
++    cdef int dim1, dim2
++    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
++    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
++    with nogil:
++        if not (left.fortran ^ right.fortran):
++            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
++        else:
++            for idx in range(dim2):
++                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
++                           left.data + idx*dim1, &_ONE)
++    return left
++
++
++cpdef CSR sub_csr(CSR left, CSR right):
++    return add_csr(left, right, -1)
++
++
++cpdef Dense sub_dense(Dense left, Dense right):
++    return add_dense(left, right, -1)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++add = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=1),
++    ]),
++    name='add',
++    module=__name__,
++    inputs=('left', 'right'),
++    out=True,
++)
++add.__doc__ =\
++    """
++    Perform the operation
++        left + scale*right
++    where `left` and `right` are matrices, and `scale` is an optional complex
++    scalar.
++    """
++add.add_specialisations([
++    (Dense, Dense, Dense, add_dense),
++    (CSR, CSR, CSR, add_csr),
++], _defer=True)
++
++sub = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='sub',
++    module=__name__,
++    inputs=('left', 'right'),
++    out=True,
++)
++sub.__doc__ =\
++    """
++    Perform the operation
++        left - right
++    where `left` and `right` are matrices.
++    """
++sub.add_specialisations([
++    (Dense, Dense, Dense, sub_dense),
++    (CSR, CSR, CSR, sub_csr),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/adjoint.pxd b/qutip/core/data/adjoint.pxd
+index 793aac64..ced7be52 100644
+--- a/qutip/core/data/adjoint.pxd
++++ b/qutip/core/data/adjoint.pxd
+@@ -1,12 +1,12 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-
+-cpdef CSR adjoint_csr(CSR matrix)
+-cpdef CSR transpose_csr(CSR matrix)
+-cpdef CSR conj_csr(CSR matrix)
+-
+-cpdef Dense adjoint_dense(Dense matrix)
+-cpdef Dense transpose_dense(Dense matrix)
+-cpdef Dense conj_dense(Dense matrix)
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++
++cpdef CSR adjoint_csr(CSR matrix)
++cpdef CSR transpose_csr(CSR matrix)
++cpdef CSR conj_csr(CSR matrix)
++
++cpdef Dense adjoint_dense(Dense matrix)
++cpdef Dense transpose_dense(Dense matrix)
++cpdef Dense conj_dense(Dense matrix)
+diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
+index ebff9e4d..4f1543cd 100644
+--- a/qutip/core/data/adjoint.pyx
++++ b/qutip/core/data/adjoint.pyx
+@@ -1,160 +1,160 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.string cimport memset
+-
+-cimport cython
+-
+-from qutip.core.data.base cimport idxint
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data cimport csr, dense
+-
+-# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex _conj "conj"(double complex x)
+-
+-__all__ = [
+-    'adjoint', 'adjoint_csr', 'adjoint_dense',
+-    'conj', 'conj_csr', 'conj_dense',
+-    'transpose', 'transpose_csr', 'transpose_dense',
+-]
+-
+-
+-cpdef CSR transpose_csr(CSR matrix):
+-    """Transpose the CSR matrix, and return a new object."""
+-    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
+-    cdef idxint row, col, ptr, ptr_out
+-    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
+-    with nogil:
+-        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
+-        for row in range(rows_in):
+-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-                col = matrix.col_index[ptr] + 1
+-                out.row_index[col] += 1
+-        for row in range(rows_out):
+-            out.row_index[row + 1] += out.row_index[row]
+-        for row in range(rows_in):
+-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-                col = matrix.col_index[ptr]
+-                ptr_out = out.row_index[col]
+-                out.data[ptr_out] = matrix.data[ptr]
+-                out.col_index[ptr_out] = row
+-                out.row_index[col] = ptr_out + 1
+-        for row in range(rows_out, 0, -1):
+-            out.row_index[row] = out.row_index[row - 1]
+-        out.row_index[0] = 0
+-    return out
+-
+-
+-cpdef CSR adjoint_csr(CSR matrix):
+-    """Conjugate-transpose the CSR matrix, and return a new object."""
+-    cdef idxint nnz_ = csr.nnz(matrix)
+-    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
+-    cdef idxint row, col, ptr, ptr_out
+-    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
+-    with nogil:
+-        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
+-        for row in range(rows_in):
+-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-                col = matrix.col_index[ptr] + 1
+-                out.row_index[col] += 1
+-        for row in range(rows_out):
+-            out.row_index[row + 1] += out.row_index[row]
+-        for row in range(rows_in):
+-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-                col = matrix.col_index[ptr]
+-                ptr_out = out.row_index[col]
+-                out.data[ptr_out] = _conj(matrix.data[ptr])
+-                out.col_index[ptr_out] = row
+-                out.row_index[col] = ptr_out + 1
+-        for row in range(rows_out, 0, -1):
+-            out.row_index[row] = out.row_index[row - 1]
+-        out.row_index[0] = 0
+-    return out
+-
+-
+-cpdef CSR conj_csr(CSR matrix):
+-    """Conjugate the CSR matrix, and return a new object."""
+-    cdef CSR out = csr.copy_structure(matrix)
+-    cdef idxint ptr
+-    with nogil:
+-        for ptr in range(csr.nnz(matrix)):
+-            out.data[ptr] = _conj(matrix.data[ptr])
+-    return out
+-
+-
+-cpdef Dense adjoint_dense(Dense matrix):
+-    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
+-    out.shape = (out.shape[1], out.shape[0])
+-    with nogil:
+-        for ptr in range(matrix.shape[0] * matrix.shape[1]):
+-            out.data[ptr] = _conj(matrix.data[ptr])
+-    return out
+-
+-
+-cpdef Dense transpose_dense(Dense matrix):
+-    cdef Dense out = matrix.copy()
+-    out.shape = (out.shape[1], out.shape[0])
+-    out.fortran = not out.fortran
+-    return out
+-
+-
+-cpdef Dense conj_dense(Dense matrix):
+-    cdef Dense out = dense.empty_like(matrix)
+-    cdef size_t ptr
+-    with nogil:
+-        for ptr in range(matrix.shape[0] * matrix.shape[1]):
+-            out.data[ptr] = _conj(matrix.data[ptr])
+-    return out
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-adjoint = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='adjoint',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
+-adjoint.add_specialisations([
+-    (Dense, Dense, adjoint_dense),
+-    (CSR, CSR, adjoint_csr),
+-], _defer=True)
+-
+-transpose = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='transpose',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-transpose.__doc__ = """Transpose of a matrix."""
+-transpose.add_specialisations([
+-    (Dense, Dense, transpose_dense),
+-    (CSR, CSR, transpose_csr),
+-], _defer=True)
+-
+-conj = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='conj',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-conj.__doc__ = """Element-wise conjugation of a matrix."""
+-conj.add_specialisations([
+-    (Dense, Dense, conj_dense),
+-    (CSR, CSR, conj_csr),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.string cimport memset
++
++cimport cython
++
++from qutip.core.data.base cimport idxint
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++from qutip.core.data cimport csr, dense
++
++# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex _conj "conj"(double complex x)
++
++__all__ = [
++    'adjoint', 'adjoint_csr', 'adjoint_dense',
++    'conj', 'conj_csr', 'conj_dense',
++    'transpose', 'transpose_csr', 'transpose_dense',
++]
++
++
++cpdef CSR transpose_csr(CSR matrix):
++    """Transpose the CSR matrix, and return a new object."""
++    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
++    cdef idxint row, col, ptr, ptr_out
++    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
++    with nogil:
++        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
++        for row in range(rows_in):
++            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++                col = matrix.col_index[ptr] + 1
++                out.row_index[col] += 1
++        for row in range(rows_out):
++            out.row_index[row + 1] += out.row_index[row]
++        for row in range(rows_in):
++            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++                col = matrix.col_index[ptr]
++                ptr_out = out.row_index[col]
++                out.data[ptr_out] = matrix.data[ptr]
++                out.col_index[ptr_out] = row
++                out.row_index[col] = ptr_out + 1
++        for row in range(rows_out, 0, -1):
++            out.row_index[row] = out.row_index[row - 1]
++        out.row_index[0] = 0
++    return out
++
++
++cpdef CSR adjoint_csr(CSR matrix):
++    """Conjugate-transpose the CSR matrix, and return a new object."""
++    cdef idxint nnz_ = csr.nnz(matrix)
++    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
++    cdef idxint row, col, ptr, ptr_out
++    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
++    with nogil:
++        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
++        for row in range(rows_in):
++            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++                col = matrix.col_index[ptr] + 1
++                out.row_index[col] += 1
++        for row in range(rows_out):
++            out.row_index[row + 1] += out.row_index[row]
++        for row in range(rows_in):
++            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++                col = matrix.col_index[ptr]
++                ptr_out = out.row_index[col]
++                out.data[ptr_out] = _conj(matrix.data[ptr])
++                out.col_index[ptr_out] = row
++                out.row_index[col] = ptr_out + 1
++        for row in range(rows_out, 0, -1):
++            out.row_index[row] = out.row_index[row - 1]
++        out.row_index[0] = 0
++    return out
++
++
++cpdef CSR conj_csr(CSR matrix):
++    """Conjugate the CSR matrix, and return a new object."""
++    cdef CSR out = csr.copy_structure(matrix)
++    cdef idxint ptr
++    with nogil:
++        for ptr in range(csr.nnz(matrix)):
++            out.data[ptr] = _conj(matrix.data[ptr])
++    return out
++
++
++cpdef Dense adjoint_dense(Dense matrix):
++    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
++    out.shape = (out.shape[1], out.shape[0])
++    with nogil:
++        for ptr in range(matrix.shape[0] * matrix.shape[1]):
++            out.data[ptr] = _conj(matrix.data[ptr])
++    return out
++
++
++cpdef Dense transpose_dense(Dense matrix):
++    cdef Dense out = matrix.copy()
++    out.shape = (out.shape[1], out.shape[0])
++    out.fortran = not out.fortran
++    return out
++
++
++cpdef Dense conj_dense(Dense matrix):
++    cdef Dense out = dense.empty_like(matrix)
++    cdef size_t ptr
++    with nogil:
++        for ptr in range(matrix.shape[0] * matrix.shape[1]):
++            out.data[ptr] = _conj(matrix.data[ptr])
++    return out
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++adjoint = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='adjoint',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
++adjoint.add_specialisations([
++    (Dense, Dense, adjoint_dense),
++    (CSR, CSR, adjoint_csr),
++], _defer=True)
++
++transpose = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='transpose',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++transpose.__doc__ = """Transpose of a matrix."""
++transpose.add_specialisations([
++    (Dense, Dense, transpose_dense),
++    (CSR, CSR, transpose_csr),
++], _defer=True)
++
++conj = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='conj',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++conj.__doc__ = """Element-wise conjugation of a matrix."""
++conj.add_specialisations([
++    (Dense, Dense, conj_dense),
++    (CSR, CSR, conj_csr),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/base.pxd b/qutip/core/data/base.pxd
+index f34a80ff..4aa8d083 100644
+--- a/qutip/core/data/base.pxd
++++ b/qutip/core/data/base.pxd
+@@ -1,17 +1,17 @@
+-#cython: language_level=3
+-
+-cdef extern from "src/intdtype.h":
+-    # cython is smart enough to understand this int can be 32 or 64 bits.
+-    ctypedef int idxint
+-    cdef int _idxint_size
+-
+-cdef int idxint_DTYPE
+-
+-cdef class Data:
+-    cdef readonly (idxint, idxint) shape
+-    cpdef object to_array(self)
+-    cpdef double complex trace(self)
+-    cpdef Data adjoint(self)
+-    cpdef Data conj(self)
+-    cpdef Data transpose(self)
+-    cpdef Data copy(self)
++#cython: language_level=3
++
++cdef extern from "src/intdtype.h":
++    # cython is smart enough to understand this int can be 32 or 64 bits.
++    ctypedef int idxint
++    cdef int _idxint_size
++
++cdef int idxint_DTYPE
++
++cdef class Data:
++    cdef readonly (idxint, idxint) shape
++    cpdef object to_array(self)
++    cpdef double complex trace(self)
++    cpdef Data adjoint(self)
++    cpdef Data conj(self)
++    cpdef Data transpose(self)
++    cpdef Data copy(self)
+diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
+index a463bf38..a7c59939 100644
+--- a/qutip/core/data/base.pyx
++++ b/qutip/core/data/base.pyx
+@@ -1,89 +1,89 @@
+-#cython: language_level=3
+-
+-import numpy as np
+-cimport numpy as cnp
+-import qutip.core.data as _data
+-from qutip.settings import settings
+-
+-__all__ = [
+-    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
+-]
+-
+-if _idxint_size == 32:
+-    idxint_dtype = np.int32
+-    idxint_DTYPE = cnp.NPY_INT32
+-else:
+-    idxint_dtype = np.int64
+-    idxint_DTYPE = cnp.NPY_INT64
+-
+-idxint_size = _idxint_size
+-
+-# As this is an abstract base class with C entry points, we have to explicitly
+-# stub out methods since we can't mark them as abstract.
+-cdef class Data:
+-    def __init__(self, shape):
+-        self.shape = shape
+-
+-    cpdef object to_array(self):
+-        raise NotImplementedError
+-
+-    cpdef double complex trace(self):
+-        return NotImplementedError
+-
+-    cpdef Data adjoint(self):
+-        raise NotImplementedError
+-
+-    cpdef Data conj(self):
+-        raise NotImplementedError
+-
+-    cpdef Data transpose(self):
+-        raise NotImplementedError
+-
+-    cpdef Data copy(self):
+-        raise NotImplementedError
+-
+-    def __add__(left, right):
+-        if isinstance(left, Data) and isinstance(right, Data):
+-            return _data.add(left, right)
+-        return NotImplemented
+-
+-    def __sub__(left, right):
+-        if isinstance(left, Data) and isinstance(right, Data):
+-            return _data.sub(left, right)
+-        return NotImplemented
+-
+-    def __matmul__(left, right):
+-        if isinstance(left, Data) and isinstance(right, Data):
+-            return _data.matmul(left, right)
+-        return NotImplemented
+-
+-    def __mul__(left, right):
+-        data, number = (left, right) if isinstance(left, Data) else (right, left)
+-        try:
+-            return _data.mul(data, number)
+-        except TypeError:
+-            return NotImplemented
+-
+-    def __truediv__(left, right):
+-        data, number = (left, right) if isinstance(left, Data) else (right, left)
+-        try:
+-            return _data.mul(data, 1/number)
+-        except TypeError:
+-            return NotImplemented
+-
+-    def __neg__(self):
+-        return _data.neg(self)
+-
+-    def __eq__(left, right):
+-        if not (isinstance(left, Data) and isinstance(right, Data)):
+-            return NotImplemented
+-        if (
+-            left.shape[0] == right.shape[0]
+-            and left.shape[1] == right.shape[1]
+-        ):
+-            return _data.iszero(_data.sub(left, right), settings.core['atol'])
+-        return False
+-
+-
+-class EfficiencyWarning(Warning):
+-    pass
++#cython: language_level=3
++
++import numpy as np
++cimport numpy as cnp
++import qutip.core.data as _data
++from qutip.settings import settings
++
++__all__ = [
++    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
++]
++
++if _idxint_size == 32:
++    idxint_dtype = np.int32
++    idxint_DTYPE = cnp.NPY_INT32
++else:
++    idxint_dtype = np.int64
++    idxint_DTYPE = cnp.NPY_INT64
++
++idxint_size = _idxint_size
++
++# As this is an abstract base class with C entry points, we have to explicitly
++# stub out methods since we can't mark them as abstract.
++cdef class Data:
++    def __init__(self, shape):
++        self.shape = shape
++
++    cpdef object to_array(self):
++        raise NotImplementedError
++
++    cpdef double complex trace(self):
++        return NotImplementedError
++
++    cpdef Data adjoint(self):
++        raise NotImplementedError
++
++    cpdef Data conj(self):
++        raise NotImplementedError
++
++    cpdef Data transpose(self):
++        raise NotImplementedError
++
++    cpdef Data copy(self):
++        raise NotImplementedError
++
++    def __add__(left, right):
++        if isinstance(left, Data) and isinstance(right, Data):
++            return _data.add(left, right)
++        return NotImplemented
++
++    def __sub__(left, right):
++        if isinstance(left, Data) and isinstance(right, Data):
++            return _data.sub(left, right)
++        return NotImplemented
++
++    def __matmul__(left, right):
++        if isinstance(left, Data) and isinstance(right, Data):
++            return _data.matmul(left, right)
++        return NotImplemented
++
++    def __mul__(left, right):
++        data, number = (left, right) if isinstance(left, Data) else (right, left)
++        try:
++            return _data.mul(data, number)
++        except TypeError:
++            return NotImplemented
++
++    def __truediv__(left, right):
++        data, number = (left, right) if isinstance(left, Data) else (right, left)
++        try:
++            return _data.mul(data, 1/number)
++        except TypeError:
++            return NotImplemented
++
++    def __neg__(self):
++        return _data.neg(self)
++
++    def __eq__(left, right):
++        if not (isinstance(left, Data) and isinstance(right, Data)):
++            return NotImplemented
++        if (
++            left.shape[0] == right.shape[0]
++            and left.shape[1] == right.shape[1]
++        ):
++            return _data.iszero(_data.sub(left, right), settings.core['atol'])
++        return False
++
++
++class EfficiencyWarning(Warning):
++    pass
+diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
+index a60341a3..6f850d22 100644
+--- a/qutip/core/data/constant.py
++++ b/qutip/core/data/constant.py
+@@ -1,73 +1,73 @@
+-# This module exists to supply a couple of very standard constant matrices
+-# which are used in the data layer, and within `Qobj` itself.  Other matrices
+-# (e.g. `create`) should not be here, but should be defined within the
+-# higher-level components of QuTiP instead.
+-
+-from . import csr, dense
+-from .csr import CSR
+-from .dense import Dense
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-__all__ = ['zeros', 'identity']
+-
+-zeros = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='zeros',
+-    module=__name__,
+-    inputs=(),
+-    out=True,
+-)
+-zeros.__doc__ =\
+-    """
+-    Create matrix representation of 0 with the given dimensions.
+-
+-    Depending on the selected output type, this may or may not actually
+-    contained explicit values; sparse matrices will typically contain nothing
+-    (which is their representation of 0), and dense matrices will still be
+-    filled.
+-
+-    Parameters
+-    ----------
+-    rows, cols : int
+-        The number of rows and columns in the output matrix.
+-    """
+-zeros.add_specialisations([
+-    (CSR, csr.zeros),
+-    (Dense, dense.zeros),
+-], _defer=True)
+-
+-identity = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('dimension',
+-                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=1),
+-    ]),
+-    name='identity',
+-    module=__name__,
+-    inputs=(),
+-    out=True,
+-)
+-identity.__doc__ =\
+-    """
+-    Create a square identity matrix of the given dimension.  Optionally, the
+-    `scale` can be given, where all the diagonal elements will be that instead
+-    of 1.
+-
+-    Parameters
+-    ----------
+-    dimension : int
+-        The dimension of the square output identity matrix.
+-    scale : complex, optional
+-        The element which should be placed on the diagonal.
+-    """
+-identity.add_specialisations([
+-    (CSR, csr.identity),
+-    (Dense, dense.identity),
+-], _defer=True)
+-
+-del _Dispatcher, _inspect
++# This module exists to supply a couple of very standard constant matrices
++# which are used in the data layer, and within `Qobj` itself.  Other matrices
++# (e.g. `create`) should not be here, but should be defined within the
++# higher-level components of QuTiP instead.
++
++from . import csr, dense
++from .csr import CSR
++from .dense import Dense
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++__all__ = ['zeros', 'identity']
++
++zeros = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='zeros',
++    module=__name__,
++    inputs=(),
++    out=True,
++)
++zeros.__doc__ =\
++    """
++    Create matrix representation of 0 with the given dimensions.
++
++    Depending on the selected output type, this may or may not actually
++    contained explicit values; sparse matrices will typically contain nothing
++    (which is their representation of 0), and dense matrices will still be
++    filled.
++
++    Parameters
++    ----------
++    rows, cols : int
++        The number of rows and columns in the output matrix.
++    """
++zeros.add_specialisations([
++    (CSR, csr.zeros),
++    (Dense, dense.zeros),
++], _defer=True)
++
++identity = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('dimension',
++                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=1),
++    ]),
++    name='identity',
++    module=__name__,
++    inputs=(),
++    out=True,
++)
++identity.__doc__ =\
++    """
++    Create a square identity matrix of the given dimension.  Optionally, the
++    `scale` can be given, where all the diagonal elements will be that instead
++    of 1.
++
++    Parameters
++    ----------
++    dimension : int
++        The dimension of the square output identity matrix.
++    scale : complex, optional
++        The element which should be placed on the diagonal.
++    """
++identity.add_specialisations([
++    (CSR, csr.identity),
++    (Dense, dense.identity),
++], _defer=True)
++
++del _Dispatcher, _inspect
+diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
+index c2feed3d..6826ac81 100644
+--- a/qutip/core/data/convert.pyx
++++ b/qutip/core/data/convert.pyx
+@@ -1,436 +1,436 @@
+-#cython: language_level=3
+-
+-"""
+-The conversion machinery between different data-layer types, and creation
+-routines from arbitrary data.  The classes `_to` and `_create` are not intended
+-to be exported names, but are the backing machinery of the functions `data.to`
+-and `data.create`, which are built up as the last objects in the `__init__.py`
+-initialisation of the `data` module.
+-"""
+-
+-# This module is compiled by Cython because it's the core of the entire
+-# dispatch table, and having it compiled to a C extension saves about 1µs per
+-# call.  This is not much at all, and there's very little which benefits from
+-# Cython compiliation, but such core functionality is called millions of times
+-# even in a simple interactive QuTiP session, and it all adds up.
+-
+-import numbers
+-
+-import numpy as np
+-from scipy.sparse import dok_matrix, csgraph
+-cimport cython
+-
+-__all__ = ['to', 'create']
+-
+-
+-def _raise_if_unconnected(dtype_list, weights):
+-    unconnected = {}
+-    for i, type_ in enumerate(dtype_list):
+-        missing = [dtype_list[j].__name__
+-                   for j, weight in enumerate(weights[:, i])
+-                   if weight == np.inf]
+-        if missing:
+-            unconnected[type_.__name__] = missing
+-    if unconnected:
+-        message = "Conversion graph not connected.  Cannot reach:\n * "
+-        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
+-                                for to, froms in unconnected.items())
+-        raise NotImplementedError(message)
+-
+-
+-cdef class _converter:
+-    """Callable which converts objects of type `x.from_` to type `x.to`."""
+-
+-    cdef list functions
+-    cdef Py_ssize_t n_functions
+-    cdef readonly type to
+-    cdef readonly type from_
+-
+-    def __init__(self, functions, to_type, from_type):
+-        self.functions = list(functions)
+-        self.n_functions = len(self.functions)
+-        self.to = to_type
+-        self.from_ = from_type
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    def __call__(self, arg):
+-        if not isinstance(arg, self.from_):
+-            raise TypeError(str(arg) + " is not of type " + str(self.from_))
+-        cdef Py_ssize_t i
+-        for i in range(self.n_functions):
+-            arg = self.functions[i](arg)
+-        return arg
+-
+-    def __repr__(self):
+-        return ("<converter to "
+-                + self.to.__name__
+-                + " from " + self.from_.__name__
+-                + ">")
+-
+-
+-cdef class _partial_converter:
+-    """Convert from any known data-layer type into the type `x.to`."""
+-
+-    cdef dict converters
+-    cdef readonly type to
+-
+-    def __init__(self, converters, to_type):
+-        self.converters = dict(converters)
+-        self.to = to_type
+-
+-    def __call__(self, arg):
+-        try:
+-            return self.converters[type(arg)](arg)
+-        except KeyError:
+-            raise TypeError("unknown type of input: " + str(arg)) from None
+-
+-    def __repr__(self):
+-        return "<converter to " + self.to.__name__ + ">"
+-
+-
+-# While `_to` and `_create` are defined as objects here, they are actually
+-# exported by `data.__init__.py` as singleton function objects of their
+-# respective types (without the leading underscore).
+-
+-cdef class _to:
+-    """
+-    Convert data into a different type.  This object is the knowledge source
+-    for every allowable data-layer type in QuTiP, and provides the conversions
+-    between all of them.
+-
+-    The base use is to call this object as a function with signature
+-        (type, data) -> converted_data
+-    where `type` is a type object (such as `data.CSR`, or that obtained by
+-    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
+-    want to create a data-layer type from non-data-layer data, use `create`
+-    instead.
+-
+-    You can get individual converters by using the key-lookup syntax.  For
+-    example, the item
+-        to[CSR, Dense]
+-    is a callable which accepts arguments of type `Dense` and returns the
+-    equivalent item of type `CSR`.  You can also get a generic converter to a
+-    particular data type if only one type is specified, so
+-        to[Dense]
+-    is a callable which accepts all known (at the time of the lookup)
+-    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
+-    section below for more detail.
+-
+-    Internally, the conversion process may go through several steps if new
+-    data-layer types have been defined with few conversions specified between
+-    them and the pre-existing converters.  The first-class QuTiP data types
+-    `Dense` and `CSR` will typically have the best connectivity.
+-
+-
+-    Adding new types
+-    ----------------
+-    You can add new data-layer types by calling the `add_conversions` method of
+-    this object, and then rebuilding all of the mathematical dispatchers.  See
+-    the docstring of that method for more information.
+-
+-
+-    Efficiency notes
+-    ----------------
+-    From an efficiency perspective, there is very little benefit to using the
+-    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
+-    `to[to_type, type(data)]`, so storing the object elides the creation of a
+-    single tuple and a dict lookup, but the cost of this is generally less than
+-    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
+-    efficient than the general call at all, but can be used in cases where a
+-    single callable is required and is more efficient than `functools.partial`.
+-    """
+-
+-    cdef readonly set dtypes
+-    cdef readonly list dispatchers
+-    cdef dict _direct_convert
+-    cdef dict _convert
+-    cdef readonly dict weight
+-    cdef readonly dict _str2type
+-
+-    def __init__(self):
+-        self._direct_convert = {}
+-        self._convert = {}
+-        self.dtypes = set()
+-        self.weight = {}
+-        self.dispatchers = []
+-        self._str2type = {}
+-
+-    def add_conversions(self, converters):
+-        """
+-        Add conversion functions between different data types.  This is an
+-        advanced function, and is only intended for the QuTiP user who wants to
+-        add a new underlying data type to QuTiP.
+-
+-        Any new data type must have at least one converter function given to
+-        produce the new data type from an existing data type, and at least one
+-        which produces an existing data type from the new one.  You need not
+-        specify any more than this, although for efficiency reasons, you may
+-        want to specify direct conversions for all types you expect the new
+-        type to interact with frequently.
+-
+-        Parameters
+-        ----------
+-        converters : iterable of (to_type, from_type, converter, [weight])
+-            An iterable of 3- or 4-tuples describing all the new conversions.
+-            Each element can individually be a 3- or 4-tuple; they do not need
+-            to be all one or the other.
+-
+-            Elements
+-            ........
+-            to_type : type
+-                The data-layer type that is output by the converter.
+-
+-            from_type : type
+-                The data-layer type to be input to the converter.
+-
+-            converter : callable (Data -> Data)
+-                The converter function.  This should take a single argument
+-                (the input data-layer function) and output a data-layer object
+-                of `to_type`.  The converter may assume without error checking
+-                that its input will always be of `to_type`.  It is safe to
+-                specify the same conversion function for multiple inputs so
+-                long as the function handles them all safely, but it must
+-                always return a single output type.
+-
+-            weight : positive real, optional (1)
+-                The weight associated with this conversion.  This must be > 0,
+-                and defaults to `1` if not supplied (which is fixed to be the
+-                cost of conversion to `Dense` from `CSR`).  It is generally
+-                safe just to leave this blank; it is always at best an
+-                approximation.  The currently defined weights are accessible in
+-                the `weights` attribute of this object.
+-        """
+-        for arg in converters:
+-            if len(arg) == 3:
+-                to_type, from_type, converter = arg
+-                weight = 1
+-            elif len(arg) == 4:
+-                to_type, from_type, converter, weight = arg
+-            else:
+-                raise TypeError("unknown converter specification: " + str(arg))
+-            if not isinstance(to_type, type):
+-                raise TypeError(repr(to_type) + " is not a type object")
+-            if not isinstance(from_type, type):
+-                raise TypeError(repr(from_type) + " is not a type object")
+-            if not isinstance(weight, numbers.Real) or weight <= 0:
+-                raise TypeError("weight " + repr(weight) + " is not valid")
+-            self.dtypes.add(from_type)
+-            self.dtypes.add(to_type)
+-            self._direct_convert[(to_type, from_type)] = (converter, weight)
+-        # Two-way mapping to convert between the type of a dtype and an integer
+-        # enumeration value for it.
+-        order, index = [], {}
+-        for i, dtype in enumerate(self.dtypes):
+-            order.append(dtype)
+-            index[dtype] = i
+-        # Treat the conversion problem as a shortest-path graph problem.  We
+-        # build up the graph description as a matrix, then solve the
+-        # all-pairs-shortest-path problem.  We forbid negative weights and
+-        # there are unlikely to be many data types, so the choice of algorithm
+-        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
+-        graph = dok_matrix((len(order), len(order)))
+-        for (to_type, from_type), (_, weight) in self._direct_convert.items():
+-            graph[index[from_type], index[to_type]] = weight
+-        weights, predecessors =\
+-            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
+-        _raise_if_unconnected(order, weights)
+-        # Build the whole shortest path conversion lookup.  We directly store
+-        # all complete shortest paths, even though this is not the most memory
+-        # efficient, because we expect that there will generally be a small
+-        # number of available data types, and we care more about minimising the
+-        # number of lookups required.
+-        self.weight = {}
+-        self._convert = {}
+-        for i, from_t in enumerate(order):
+-            for j, to_t in enumerate(order):
+-                convert = []
+-                weight = 0
+-                cur_t = to_t
+-                pred_i = predecessors[i, j]
+-                while pred_i >= 0:
+-                    pred_t = order[pred_i]
+-                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
+-                    convert.append(_convert)
+-                    weight += _weight
+-                    cur_t = pred_t
+-                    pred_i = predecessors[i, pred_i]
+-                self.weight[(to_t, from_t)] = weight
+-                self._convert[(to_t, from_t)] =\
+-                    _converter(convert[::-1], to_t, from_t)
+-        for dispatcher in self.dispatchers:
+-            dispatcher.rebuild_lookup()
+-
+-    def register_aliases(self, aliases, layer_type):
+-        """
+-        Register a user frendly name for a data-layer type to be recognized by
+-        the :method:`parse` method.
+-
+-        Parameters
+-        ----------
+-        aliases : str or list of str
+-            Name of list of names to be understood to represent the layer_type.
+-
+-        layer_type : type
+-            Data-layer type, must have been registered with
+-            :method:`add_conversions` first.
+-        """
+-        if layer_type not in self.dtypes:
+-            raise ValueError(
+-                "Type is not a data-layer type: " + repr(layer_type))
+-        if isinstance(aliases, str):
+-            aliases = [aliases]
+-        for alias in aliases:
+-            if type(alias) is not str:
+-                raise TypeError("The alias must be a str : " + repr(alias))
+-            self._str2type[alias] = layer_type
+-
+-    def parse(self, dtype):
+-        """
+-        Return a data-layer type object given its name or the type itself.
+-
+-        Parameters
+-        ----------
+-        dtype : type, str
+-            Either the name of a data-layer type or a type itself.
+-
+-        Returns
+-        -------
+-        type
+-            A data-layer type.
+-
+-        Raises
+-        ------
+-        TypeError
+-            If ``dtype`` is neither a string nor a type.
+-        ValueError
+-            If ``dtype`` is a name, but no data-layer type of that name is
+-            registered, or if ``dtype`` is a type, but not a known data-layer
+-            type.
+-        """
+-        if type(dtype) is type:
+-            if dtype not in self.dtypes:
+-                raise ValueError(
+-                    "Type is not a data-layer type: " + repr(dtype))
+-            return dtype
+-        elif type(dtype) is str:
+-            try:
+-                return self._str2type[dtype]
+-            except KeyError:
+-                raise ValueError(
+-                    "Type name is not known to the data-layer: " + repr(dtype)
+-                    ) from None
+-
+-        raise TypeError(
+-            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    def __getitem__(self, arg):
+-        if type(arg) is not tuple:
+-            arg = (arg,)
+-        if not arg or len(arg) > 2:
+-            raise KeyError(arg)
+-        to_t = self.parse(arg[0])
+-        if len(arg) == 1:
+-            converters = {
+-                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
+-            }
+-            return _partial_converter(converters, to_t)
+-        from_t = self.parse(arg[1])
+-        return self._convert[to_t, from_t]
+-
+-    def __call__(self, to_type, data):
+-        to_type = self.parse(to_type)
+-        from_type = self.parse(type(data))
+-        if to_type == from_type:
+-            return data
+-        return self._convert[to_type, from_type](data)
+-
+-
+-cdef class _create:
+-    cdef readonly list _creators
+-
+-    def __init__(self):
+-        self._creators = []
+-
+-    def add_creators(self, creators):
+-        """
+-        Add creation functions to make a data-layer object from an arbitrary
+-        Python object.
+-
+-        Parameters
+-        ----------
+-        creators : iterable of (condition, creator, [priority])
+-            An iterable of 2- or 3-tuples describing the new data layer
+-            creation functions.
+-            Each element can individually be a 2- or 3-tuple; they do not need
+-            to be all one or the other.
+-
+-            Elements
+-            ........
+-            condition : callable (object) -> bool
+-                Function determining if the given object can be converted to a
+-                data-layer type using this creator.
+-
+-            creator function: callable (object, shape, copy=True) -> Data
+-                The creator function. It should take an object and a shape and
+-                return a data-layer type instance. The object may be any object
+-                for which the condition function returned ``True`` when tested.
+-                The ``object`` and ``shape`` parameters are passed positionally,
+-                and the ``copy`` parameter is passed by keyword.
+-
+-            priority : real, optional (0)
+-                The priority associated with this creator. Higher priority
+-                conditions will be tested first and the first valid creator
+-                (i.e. for which ``condition(object) == True``) will handle
+-                the creation.
+-
+-        Notes
+-        -----
+-        Default creators are added with the following priorities:
+-
+-        * Objects that are instances of data-layer types are
+-          converted using ``.copy`` with priority 100.
+-        * Objects that have a direct equivalent such as ``numpy.ndarray``
+-          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
+-        * Objects for which ``scipy.sparse.issparse`` is ``True``
+-          are converted using an internal CSR converter with
+-          priority 20.
+-        * If no condition are meet, ``numpy.array`` is used to try convert
+-          the input to an array (priority -inf).
+-        """
+-        for condition, creator, *priority in creators:
+-            if not callable(condition):
+-                raise TypeError(repr(condition) + " is not a callable")
+-            if not callable(create):
+-                raise TypeError(repr(create) + " is not a callable")
+-            if len(priority) >= 2:
+-                raise ValueError("Too many values to unpack for a creator, " +
+-                                 "expected 2 or 3, got "+ str(2+len(priority)))
+-            priority = float(priority[0] if priority else 0)
+-            self._creators.append((condition, creator, priority))
+-        self._creators.sort(key=lambda creator: creator[2], reverse=True)
+-
+-    def __call__(self, arg, shape=None, copy=True):
+-        """
+-        Build a :class:`qutip.data.Data` object from arg.
+-
+-        Parameters
+-        ----------
+-        arg : object
+-            Object to be converted to `qutip.data.Data`. Anything that can be
+-            converted to a numpy array are valid input.
+-
+-        shape : tuple, optional
+-            The shape of the output as (``rows``, ``columns``).
+-        """
+-        for condition, create, _ in self._creators:
+-            if condition(arg):
+-                return create(arg, shape, copy=copy)
+-        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
+-                        "qutip data format")
+-
+-
+-to = _to()
+-create = _create()
++#cython: language_level=3
++
++"""
++The conversion machinery between different data-layer types, and creation
++routines from arbitrary data.  The classes `_to` and `_create` are not intended
++to be exported names, but are the backing machinery of the functions `data.to`
++and `data.create`, which are built up as the last objects in the `__init__.py`
++initialisation of the `data` module.
++"""
++
++# This module is compiled by Cython because it's the core of the entire
++# dispatch table, and having it compiled to a C extension saves about 1µs per
++# call.  This is not much at all, and there's very little which benefits from
++# Cython compiliation, but such core functionality is called millions of times
++# even in a simple interactive QuTiP session, and it all adds up.
++
++import numbers
++
++import numpy as np
++from scipy.sparse import dok_matrix, csgraph
++cimport cython
++
++__all__ = ['to', 'create']
++
++
++def _raise_if_unconnected(dtype_list, weights):
++    unconnected = {}
++    for i, type_ in enumerate(dtype_list):
++        missing = [dtype_list[j].__name__
++                   for j, weight in enumerate(weights[:, i])
++                   if weight == np.inf]
++        if missing:
++            unconnected[type_.__name__] = missing
++    if unconnected:
++        message = "Conversion graph not connected.  Cannot reach:\n * "
++        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
++                                for to, froms in unconnected.items())
++        raise NotImplementedError(message)
++
++
++cdef class _converter:
++    """Callable which converts objects of type `x.from_` to type `x.to`."""
++
++    cdef list functions
++    cdef Py_ssize_t n_functions
++    cdef readonly type to
++    cdef readonly type from_
++
++    def __init__(self, functions, to_type, from_type):
++        self.functions = list(functions)
++        self.n_functions = len(self.functions)
++        self.to = to_type
++        self.from_ = from_type
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    def __call__(self, arg):
++        if not isinstance(arg, self.from_):
++            raise TypeError(str(arg) + " is not of type " + str(self.from_))
++        cdef Py_ssize_t i
++        for i in range(self.n_functions):
++            arg = self.functions[i](arg)
++        return arg
++
++    def __repr__(self):
++        return ("<converter to "
++                + self.to.__name__
++                + " from " + self.from_.__name__
++                + ">")
++
++
++cdef class _partial_converter:
++    """Convert from any known data-layer type into the type `x.to`."""
++
++    cdef dict converters
++    cdef readonly type to
++
++    def __init__(self, converters, to_type):
++        self.converters = dict(converters)
++        self.to = to_type
++
++    def __call__(self, arg):
++        try:
++            return self.converters[type(arg)](arg)
++        except KeyError:
++            raise TypeError("unknown type of input: " + str(arg)) from None
++
++    def __repr__(self):
++        return "<converter to " + self.to.__name__ + ">"
++
++
++# While `_to` and `_create` are defined as objects here, they are actually
++# exported by `data.__init__.py` as singleton function objects of their
++# respective types (without the leading underscore).
++
++cdef class _to:
++    """
++    Convert data into a different type.  This object is the knowledge source
++    for every allowable data-layer type in QuTiP, and provides the conversions
++    between all of them.
++
++    The base use is to call this object as a function with signature
++        (type, data) -> converted_data
++    where `type` is a type object (such as `data.CSR`, or that obtained by
++    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
++    want to create a data-layer type from non-data-layer data, use `create`
++    instead.
++
++    You can get individual converters by using the key-lookup syntax.  For
++    example, the item
++        to[CSR, Dense]
++    is a callable which accepts arguments of type `Dense` and returns the
++    equivalent item of type `CSR`.  You can also get a generic converter to a
++    particular data type if only one type is specified, so
++        to[Dense]
++    is a callable which accepts all known (at the time of the lookup)
++    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
++    section below for more detail.
++
++    Internally, the conversion process may go through several steps if new
++    data-layer types have been defined with few conversions specified between
++    them and the pre-existing converters.  The first-class QuTiP data types
++    `Dense` and `CSR` will typically have the best connectivity.
++
++
++    Adding new types
++    ----------------
++    You can add new data-layer types by calling the `add_conversions` method of
++    this object, and then rebuilding all of the mathematical dispatchers.  See
++    the docstring of that method for more information.
++
++
++    Efficiency notes
++    ----------------
++    From an efficiency perspective, there is very little benefit to using the
++    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
++    `to[to_type, type(data)]`, so storing the object elides the creation of a
++    single tuple and a dict lookup, but the cost of this is generally less than
++    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
++    efficient than the general call at all, but can be used in cases where a
++    single callable is required and is more efficient than `functools.partial`.
++    """
++
++    cdef readonly set dtypes
++    cdef readonly list dispatchers
++    cdef dict _direct_convert
++    cdef dict _convert
++    cdef readonly dict weight
++    cdef readonly dict _str2type
++
++    def __init__(self):
++        self._direct_convert = {}
++        self._convert = {}
++        self.dtypes = set()
++        self.weight = {}
++        self.dispatchers = []
++        self._str2type = {}
++
++    def add_conversions(self, converters):
++        """
++        Add conversion functions between different data types.  This is an
++        advanced function, and is only intended for the QuTiP user who wants to
++        add a new underlying data type to QuTiP.
++
++        Any new data type must have at least one converter function given to
++        produce the new data type from an existing data type, and at least one
++        which produces an existing data type from the new one.  You need not
++        specify any more than this, although for efficiency reasons, you may
++        want to specify direct conversions for all types you expect the new
++        type to interact with frequently.
++
++        Parameters
++        ----------
++        converters : iterable of (to_type, from_type, converter, [weight])
++            An iterable of 3- or 4-tuples describing all the new conversions.
++            Each element can individually be a 3- or 4-tuple; they do not need
++            to be all one or the other.
++
++            Elements
++            ........
++            to_type : type
++                The data-layer type that is output by the converter.
++
++            from_type : type
++                The data-layer type to be input to the converter.
++
++            converter : callable (Data -> Data)
++                The converter function.  This should take a single argument
++                (the input data-layer function) and output a data-layer object
++                of `to_type`.  The converter may assume without error checking
++                that its input will always be of `to_type`.  It is safe to
++                specify the same conversion function for multiple inputs so
++                long as the function handles them all safely, but it must
++                always return a single output type.
++
++            weight : positive real, optional (1)
++                The weight associated with this conversion.  This must be > 0,
++                and defaults to `1` if not supplied (which is fixed to be the
++                cost of conversion to `Dense` from `CSR`).  It is generally
++                safe just to leave this blank; it is always at best an
++                approximation.  The currently defined weights are accessible in
++                the `weights` attribute of this object.
++        """
++        for arg in converters:
++            if len(arg) == 3:
++                to_type, from_type, converter = arg
++                weight = 1
++            elif len(arg) == 4:
++                to_type, from_type, converter, weight = arg
++            else:
++                raise TypeError("unknown converter specification: " + str(arg))
++            if not isinstance(to_type, type):
++                raise TypeError(repr(to_type) + " is not a type object")
++            if not isinstance(from_type, type):
++                raise TypeError(repr(from_type) + " is not a type object")
++            if not isinstance(weight, numbers.Real) or weight <= 0:
++                raise TypeError("weight " + repr(weight) + " is not valid")
++            self.dtypes.add(from_type)
++            self.dtypes.add(to_type)
++            self._direct_convert[(to_type, from_type)] = (converter, weight)
++        # Two-way mapping to convert between the type of a dtype and an integer
++        # enumeration value for it.
++        order, index = [], {}
++        for i, dtype in enumerate(self.dtypes):
++            order.append(dtype)
++            index[dtype] = i
++        # Treat the conversion problem as a shortest-path graph problem.  We
++        # build up the graph description as a matrix, then solve the
++        # all-pairs-shortest-path problem.  We forbid negative weights and
++        # there are unlikely to be many data types, so the choice of algorithm
++        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
++        graph = dok_matrix((len(order), len(order)))
++        for (to_type, from_type), (_, weight) in self._direct_convert.items():
++            graph[index[from_type], index[to_type]] = weight
++        weights, predecessors =\
++            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
++        _raise_if_unconnected(order, weights)
++        # Build the whole shortest path conversion lookup.  We directly store
++        # all complete shortest paths, even though this is not the most memory
++        # efficient, because we expect that there will generally be a small
++        # number of available data types, and we care more about minimising the
++        # number of lookups required.
++        self.weight = {}
++        self._convert = {}
++        for i, from_t in enumerate(order):
++            for j, to_t in enumerate(order):
++                convert = []
++                weight = 0
++                cur_t = to_t
++                pred_i = predecessors[i, j]
++                while pred_i >= 0:
++                    pred_t = order[pred_i]
++                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
++                    convert.append(_convert)
++                    weight += _weight
++                    cur_t = pred_t
++                    pred_i = predecessors[i, pred_i]
++                self.weight[(to_t, from_t)] = weight
++                self._convert[(to_t, from_t)] =\
++                    _converter(convert[::-1], to_t, from_t)
++        for dispatcher in self.dispatchers:
++            dispatcher.rebuild_lookup()
++
++    def register_aliases(self, aliases, layer_type):
++        """
++        Register a user frendly name for a data-layer type to be recognized by
++        the :method:`parse` method.
++
++        Parameters
++        ----------
++        aliases : str or list of str
++            Name of list of names to be understood to represent the layer_type.
++
++        layer_type : type
++            Data-layer type, must have been registered with
++            :method:`add_conversions` first.
++        """
++        if layer_type not in self.dtypes:
++            raise ValueError(
++                "Type is not a data-layer type: " + repr(layer_type))
++        if isinstance(aliases, str):
++            aliases = [aliases]
++        for alias in aliases:
++            if type(alias) is not str:
++                raise TypeError("The alias must be a str : " + repr(alias))
++            self._str2type[alias] = layer_type
++
++    def parse(self, dtype):
++        """
++        Return a data-layer type object given its name or the type itself.
++
++        Parameters
++        ----------
++        dtype : type, str
++            Either the name of a data-layer type or a type itself.
++
++        Returns
++        -------
++        type
++            A data-layer type.
++
++        Raises
++        ------
++        TypeError
++            If ``dtype`` is neither a string nor a type.
++        ValueError
++            If ``dtype`` is a name, but no data-layer type of that name is
++            registered, or if ``dtype`` is a type, but not a known data-layer
++            type.
++        """
++        if type(dtype) is type:
++            if dtype not in self.dtypes:
++                raise ValueError(
++                    "Type is not a data-layer type: " + repr(dtype))
++            return dtype
++        elif type(dtype) is str:
++            try:
++                return self._str2type[dtype]
++            except KeyError:
++                raise ValueError(
++                    "Type name is not known to the data-layer: " + repr(dtype)
++                    ) from None
++
++        raise TypeError(
++            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    def __getitem__(self, arg):
++        if type(arg) is not tuple:
++            arg = (arg,)
++        if not arg or len(arg) > 2:
++            raise KeyError(arg)
++        to_t = self.parse(arg[0])
++        if len(arg) == 1:
++            converters = {
++                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
++            }
++            return _partial_converter(converters, to_t)
++        from_t = self.parse(arg[1])
++        return self._convert[to_t, from_t]
++
++    def __call__(self, to_type, data):
++        to_type = self.parse(to_type)
++        from_type = self.parse(type(data))
++        if to_type == from_type:
++            return data
++        return self._convert[to_type, from_type](data)
++
++
++cdef class _create:
++    cdef readonly list _creators
++
++    def __init__(self):
++        self._creators = []
++
++    def add_creators(self, creators):
++        """
++        Add creation functions to make a data-layer object from an arbitrary
++        Python object.
++
++        Parameters
++        ----------
++        creators : iterable of (condition, creator, [priority])
++            An iterable of 2- or 3-tuples describing the new data layer
++            creation functions.
++            Each element can individually be a 2- or 3-tuple; they do not need
++            to be all one or the other.
++
++            Elements
++            ........
++            condition : callable (object) -> bool
++                Function determining if the given object can be converted to a
++                data-layer type using this creator.
++
++            creator function: callable (object, shape, copy=True) -> Data
++                The creator function. It should take an object and a shape and
++                return a data-layer type instance. The object may be any object
++                for which the condition function returned ``True`` when tested.
++                The ``object`` and ``shape`` parameters are passed positionally,
++                and the ``copy`` parameter is passed by keyword.
++
++            priority : real, optional (0)
++                The priority associated with this creator. Higher priority
++                conditions will be tested first and the first valid creator
++                (i.e. for which ``condition(object) == True``) will handle
++                the creation.
++
++        Notes
++        -----
++        Default creators are added with the following priorities:
++
++        * Objects that are instances of data-layer types are
++          converted using ``.copy`` with priority 100.
++        * Objects that have a direct equivalent such as ``numpy.ndarray``
++          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
++        * Objects for which ``scipy.sparse.issparse`` is ``True``
++          are converted using an internal CSR converter with
++          priority 20.
++        * If no condition are meet, ``numpy.array`` is used to try convert
++          the input to an array (priority -inf).
++        """
++        for condition, creator, *priority in creators:
++            if not callable(condition):
++                raise TypeError(repr(condition) + " is not a callable")
++            if not callable(create):
++                raise TypeError(repr(create) + " is not a callable")
++            if len(priority) >= 2:
++                raise ValueError("Too many values to unpack for a creator, " +
++                                 "expected 2 or 3, got "+ str(2+len(priority)))
++            priority = float(priority[0] if priority else 0)
++            self._creators.append((condition, creator, priority))
++        self._creators.sort(key=lambda creator: creator[2], reverse=True)
++
++    def __call__(self, arg, shape=None, copy=True):
++        """
++        Build a :class:`qutip.data.Data` object from arg.
++
++        Parameters
++        ----------
++        arg : object
++            Object to be converted to `qutip.data.Data`. Anything that can be
++            converted to a numpy array are valid input.
++
++        shape : tuple, optional
++            The shape of the output as (``rows``, ``columns``).
++        """
++        for condition, create, _ in self._creators:
++            if condition(arg):
++                return create(arg, shape, copy=copy)
++        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
++                        "qutip data format")
++
++
++to = _to()
++create = _create()
+diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
+index 65dcd319..a05e9b9c 100644
+--- a/qutip/core/data/csr.pxd
++++ b/qutip/core/data/csr.pxd
+@@ -1,166 +1,166 @@
+-#cython: language_level=3
+-
+-from cpython cimport mem
+-from libcpp.algorithm cimport sort
+-from libc.math cimport fabs
+-
+-cdef extern from *:
+-    void *PyMem_Calloc(size_t n, size_t elsize)
+-
+-import numpy as np
+-cimport numpy as cnp
+-
+-from qutip.core.data cimport base
+-from qutip.core.data.dense cimport Dense
+-
+-cdef class CSR(base.Data):
+-    cdef double complex *data
+-    cdef base.idxint *col_index
+-    cdef base.idxint *row_index
+-    cdef size_t size
+-    cdef object _scipy
+-    cdef bint _deallocate
+-    cpdef CSR copy(CSR self)
+-    cpdef object as_scipy(CSR self, bint full=*)
+-    cpdef CSR sort_indices(CSR self)
+-    cpdef double complex trace(CSR self)
+-    cpdef CSR adjoint(CSR self)
+-    cpdef CSR conj(CSR self)
+-    cpdef CSR transpose(CSR self)
+-
+-
+-cdef struct Accumulator:
+-    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
+-    # matrices row-by-row (or column-by-column for CSC) where entries may need
+-    # to be accumulated (summed) from several locations which may not be
+-    # sorted.
+-    #
+-    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
+-    # to the accumulator for this row by calling `scatter`, then fill the row
+-    # in the output by calling `gather`.  Prepare the accumulator to receive
+-    # the next row by calling `reset`.
+-    double complex *values
+-    size_t *modified
+-    base.idxint *nonzero
+-    size_t _cur_row, nnz, size
+-    bint _sorted
+-
+-cdef inline Accumulator acc_alloc(size_t size):
+-    """
+-    Initialise this accumulator.  `size` should be the number of columns in the
+-    matrix (for CSR) or the number of rows (for CSC).
+-    """
+-    cdef Accumulator acc
+-    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
+-    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
+-    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
+-    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
+-        raise MemoryError
+-    acc.size = size
+-    acc.nnz = 0
+-    # The value of _cur_row doesn't actually need to match the true row in
+-    # the output, it just needs to be a unique number so that we can use it
+-    # as a sentinel in `modified` to tell if there's a value in the current
+-    # column.
+-    acc._cur_row = 1
+-    acc._sorted = True
+-    return acc
+-
+-cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
+-    """
+-    Add a value to the accumulator for this row, in column `position`.  The
+-    value is added on to any value already scattered into this position.
+-    """
+-    # We have to branch on modified[position] anyway (to know whether to add an
+-    # entry in nonzero), so we _actually_ reset `values` here.  This has the
+-    # potential to save operations too, if the same column is never touched
+-    # again.
+-    if acc.modified[position] == acc._cur_row:
+-        acc.values[position] += value
+-    else:
+-        acc.values[position] = value
+-        acc.modified[position] = acc._cur_row
+-        acc.nonzero[acc.nnz] = position
+-        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
+-        acc.nnz += 1
+-
+-cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
+-    """
+-    Copy all the accumulated values into this row into the output pointers.
+-    This will always output its values in sorted order.  The pointers should
+-    point to the first free space for data to be copied into.  This method will
+-    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
+-    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
+-    updated after each `self.scatter()` operation, and is reset by
+-    `self.reset()`.
+-
+-    Return the actual number of elements copied in.
+-    """
+-    cdef size_t i, nnz=0, position
+-    cdef double complex value
+-    if not acc._sorted:
+-        sort(acc.nonzero, acc.nonzero + acc.nnz)
+-        acc._sorted = True
+-    for i in range(acc.nnz):
+-        position = acc.nonzero[i]
+-        value = acc.values[position]
+-        if fabs(value.real) < tol:
+-            value.real = 0
+-        if fabs(value.imag) < tol:
+-            value.imag = 0
+-        if value != 0:
+-            values[nnz] = value
+-            indices[nnz] = position
+-            nnz += 1
+-    return nnz
+-
+-cdef inline void acc_reset(Accumulator *acc) nogil:
+-    """Prepare the accumulator to accept the next row of input."""
+-    # We actually don't need to do anything to reset other than to change
+-    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
+-    # whether a value was set in this current row (and if not, `scatter`
+-    # resets it when it's used), while `nnz`
+-    acc.nnz = 0
+-    acc._sorted = True
+-    acc._cur_row += 1
+-
+-cdef inline void acc_free(Accumulator *acc):
+-    mem.PyMem_Free(acc.values)
+-    mem.PyMem_Free(acc.modified)
+-    mem.PyMem_Free(acc.nonzero)
+-
+-
+-# Internal structure for sorting pairs of elements.  Not actually meant to be
+-# used in external code.
+-cdef struct _data_col:
+-    double complex data
+-    base.idxint col
+-
+-cdef class Sorter:
+-    cdef size_t size
+-    cdef base.idxint **argsort
+-    cdef _data_col *sort
+-
+-    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
+-    cdef void copy(Sorter self,
+-                   double complex *dest_data, base.idxint *dest_cols,
+-                   double complex *src_data, base.idxint *src_cols,
+-                   size_t size) nogil
+-
+-
+-cpdef CSR fast_from_scipy(object sci)
+-cpdef CSR copy_structure(CSR matrix)
+-cpdef CSR sorted(CSR matrix)
+-cpdef base.idxint nnz(CSR matrix) nogil
+-cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
+-cpdef CSR empty_like(CSR other)
+-cpdef CSR zeros(base.idxint rows, base.idxint cols)
+-cpdef CSR identity(base.idxint dimension, double complex scale=*)
+-
+-cpdef CSR from_dense(Dense matrix)
+-cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
+-                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
+-                           double tol=*)
+-
+-cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+-                          base.idxint n_blocks, base.idxint block_size)
++#cython: language_level=3
++
++from cpython cimport mem
++from libcpp.algorithm cimport sort
++from libc.math cimport fabs
++
++cdef extern from *:
++    void *PyMem_Calloc(size_t n, size_t elsize)
++
++import numpy as np
++cimport numpy as cnp
++
++from qutip.core.data cimport base
++from qutip.core.data.dense cimport Dense
++
++cdef class CSR(base.Data):
++    cdef double complex *data
++    cdef base.idxint *col_index
++    cdef base.idxint *row_index
++    cdef size_t size
++    cdef object _scipy
++    cdef bint _deallocate
++    cpdef CSR copy(CSR self)
++    cpdef object as_scipy(CSR self, bint full=*)
++    cpdef CSR sort_indices(CSR self)
++    cpdef double complex trace(CSR self)
++    cpdef CSR adjoint(CSR self)
++    cpdef CSR conj(CSR self)
++    cpdef CSR transpose(CSR self)
++
++
++cdef struct Accumulator:
++    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
++    # matrices row-by-row (or column-by-column for CSC) where entries may need
++    # to be accumulated (summed) from several locations which may not be
++    # sorted.
++    #
++    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
++    # to the accumulator for this row by calling `scatter`, then fill the row
++    # in the output by calling `gather`.  Prepare the accumulator to receive
++    # the next row by calling `reset`.
++    double complex *values
++    size_t *modified
++    base.idxint *nonzero
++    size_t _cur_row, nnz, size
++    bint _sorted
++
++cdef inline Accumulator acc_alloc(size_t size):
++    """
++    Initialise this accumulator.  `size` should be the number of columns in the
++    matrix (for CSR) or the number of rows (for CSC).
++    """
++    cdef Accumulator acc
++    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
++    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
++    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
++    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
++        raise MemoryError
++    acc.size = size
++    acc.nnz = 0
++    # The value of _cur_row doesn't actually need to match the true row in
++    # the output, it just needs to be a unique number so that we can use it
++    # as a sentinel in `modified` to tell if there's a value in the current
++    # column.
++    acc._cur_row = 1
++    acc._sorted = True
++    return acc
++
++cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
++    """
++    Add a value to the accumulator for this row, in column `position`.  The
++    value is added on to any value already scattered into this position.
++    """
++    # We have to branch on modified[position] anyway (to know whether to add an
++    # entry in nonzero), so we _actually_ reset `values` here.  This has the
++    # potential to save operations too, if the same column is never touched
++    # again.
++    if acc.modified[position] == acc._cur_row:
++        acc.values[position] += value
++    else:
++        acc.values[position] = value
++        acc.modified[position] = acc._cur_row
++        acc.nonzero[acc.nnz] = position
++        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
++        acc.nnz += 1
++
++cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
++    """
++    Copy all the accumulated values into this row into the output pointers.
++    This will always output its values in sorted order.  The pointers should
++    point to the first free space for data to be copied into.  This method will
++    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
++    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
++    updated after each `self.scatter()` operation, and is reset by
++    `self.reset()`.
++
++    Return the actual number of elements copied in.
++    """
++    cdef size_t i, nnz=0, position
++    cdef double complex value
++    if not acc._sorted:
++        sort(acc.nonzero, acc.nonzero + acc.nnz)
++        acc._sorted = True
++    for i in range(acc.nnz):
++        position = acc.nonzero[i]
++        value = acc.values[position]
++        if fabs(value.real) < tol:
++            value.real = 0
++        if fabs(value.imag) < tol:
++            value.imag = 0
++        if value != 0:
++            values[nnz] = value
++            indices[nnz] = position
++            nnz += 1
++    return nnz
++
++cdef inline void acc_reset(Accumulator *acc) nogil:
++    """Prepare the accumulator to accept the next row of input."""
++    # We actually don't need to do anything to reset other than to change
++    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
++    # whether a value was set in this current row (and if not, `scatter`
++    # resets it when it's used), while `nnz`
++    acc.nnz = 0
++    acc._sorted = True
++    acc._cur_row += 1
++
++cdef inline void acc_free(Accumulator *acc):
++    mem.PyMem_Free(acc.values)
++    mem.PyMem_Free(acc.modified)
++    mem.PyMem_Free(acc.nonzero)
++
++
++# Internal structure for sorting pairs of elements.  Not actually meant to be
++# used in external code.
++cdef struct _data_col:
++    double complex data
++    base.idxint col
++
++cdef class Sorter:
++    cdef size_t size
++    cdef base.idxint **argsort
++    cdef _data_col *sort
++
++    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
++    cdef void copy(Sorter self,
++                   double complex *dest_data, base.idxint *dest_cols,
++                   double complex *src_data, base.idxint *src_cols,
++                   size_t size) nogil
++
++
++cpdef CSR fast_from_scipy(object sci)
++cpdef CSR copy_structure(CSR matrix)
++cpdef CSR sorted(CSR matrix)
++cpdef base.idxint nnz(CSR matrix) nogil
++cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
++cpdef CSR empty_like(CSR other)
++cpdef CSR zeros(base.idxint rows, base.idxint cols)
++cpdef CSR identity(base.idxint dimension, double complex scale=*)
++
++cpdef CSR from_dense(Dense matrix)
++cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
++                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
++                           double tol=*)
++
++cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
++                          base.idxint n_blocks, base.idxint block_size)
+diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
+index 6cf30b06..fb9fa244 100644
+--- a/qutip/core/data/csr.pyx
++++ b/qutip/core/data/csr.pyx
+@@ -1,965 +1,965 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.string cimport memset, memcpy
+-
+-from libcpp cimport bool
+-from libcpp.algorithm cimport sort
+-
+-cimport cython
+-
+-from cpython cimport mem
+-
+-import numbers
+-import warnings
+-
+-import numpy as np
+-cimport numpy as cnp
+-import scipy.sparse
+-from scipy.sparse import csr_matrix as scipy_csr_matrix
+-try:
+-    from scipy.sparse.data import _data_matrix as scipy_data_matrix
+-except ImportError:
+-    # The file data was renamed to _data from scipy 1.8.0
+-    from scipy.sparse._data import _data_matrix as scipy_data_matrix
+-from scipy.linalg cimport cython_blas as blas
+-
+-from qutip.core.data cimport base, Dense
+-from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
+-from qutip.core.data.trace cimport trace_csr
+-from qutip.core.data.tidyup cimport tidyup_csr
+-from .base import idxint_dtype
+-from qutip.settings import settings
+-
+-cnp.import_array()
+-
+-cdef extern from *:
+-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+-    void *PyDataMem_NEW(size_t size)
+-    void PyDataMem_FREE(void *ptr)
+-
+-# Very little should be exported on star-import, because most stuff will have
+-# naming collisions with other type modules.
+-__all__ = ['CSR']
+-
+-cdef int _ONE = 1
+-
+-cdef object _csr_matrix(data, indices, indptr, shape):
+-    """
+-    Factory method of scipy csr_matrix: we skip all the index type-checking
+-    because this takes tens of microseconds, and we already know we're in
+-    a sensible format.
+-    """
+-    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
+-    # `_data_matrix` is the first object in the inheritance chain which
+-    # doesn't have a really slow __init__.
+-    scipy_data_matrix.__init__(out)
+-    out.data = data
+-    out.indices = indices
+-    out.indptr = indptr
+-    out._shape = shape
+-    return out
+-
+-
+-cdef class CSR(base.Data):
+-    """
+-    Data type for quantum objects storing its data in compressed sparse row
+-    (CSR) format.  This is similar to the `scipy` type
+-    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
+-    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
+-    using the `as_scipy()` method.
+-    """
+-    def __cinit__(self, *args, **kwargs):
+-        # By default, we want CSR to deallocate its memory (we depend on Cython
+-        # to ensure we don't deallocate a NULL pointer), and we only flip this
+-        # when we create a scipy backing.  Since creating the scipy backing
+-        # depends on knowing the shape, which happens _after_ data
+-        # initialisation and may throw an exception, it is better to have a
+-        # single flag that is set as soon as the pointers are assigned.
+-        self._deallocate = True
+-
+-    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
+-        # This is the Python __init__ method, so we do not care that it is not
+-        # super-fast C access.  Typically Cython code will not call this, but
+-        # will use a factory method in this module or at worst, call
+-        # CSR.__new__ and manually set everything.  We must be very careful in
+-        # this function that the deallocation is set up correctly if any
+-        # exceptions occur.
+-        cdef size_t ptr
+-        cdef base.idxint col
+-        cdef object data, col_index, row_index
+-        if isinstance(arg, scipy.sparse.spmatrix):
+-            arg = arg.tocsr()
+-            if shape is not None and shape != arg.shape:
+-                raise ValueError("".join([
+-                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
+-                ]))
+-            shape = arg.shape
+-            arg = (arg.data, arg.indices, arg.indptr)
+-        if not isinstance(arg, tuple):
+-            raise TypeError("arg must be a scipy matrix or tuple")
+-        if len(arg) != 3:
+-            raise ValueError("arg must be a (data, col_index, row_index) tuple")
+-        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
+-        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
+-        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
+-        # This flag must be set at the same time as data, col_index and
+-        # row_index are assigned.  These assignments cannot raise an exception
+-        # in user code due to the above three lines, but further code may.
+-        self._deallocate = False
+-        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
+-        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
+-        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
+-        self.size = (cnp.PyArray_SIZE(data)
+-                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
+-                     else cnp.PyArray_SIZE(col_index))
+-        if shape is None:
+-            warnings.warn("instantiating CSR matrix of unknown shape")
+-            # row_index contains an extra element which is nnz.  We assume the
+-            # smallest matrix which can hold all these values by iterating
+-            # through the columns.  This is slow and probably inaccurate, since
+-            # there could be columns containing zero (hence the warning).
+-            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
+-            col = 1
+-            for ptr in range(self.size):
+-                col = self.col_index[ptr] if self.col_index[ptr] > col else col
+-            self.shape[1] = col
+-        else:
+-            if not isinstance(shape, tuple):
+-                raise TypeError("shape must be a 2-tuple of positive ints")
+-            if not (len(shape) == 2
+-                    and isinstance(shape[0], int)
+-                    and isinstance(shape[1], int)
+-                    and shape[0] > 0
+-                    and shape[1] > 0):
+-                raise ValueError("shape must be a 2-tuple of positive ints")
+-            self.shape = shape
+-        # Store a reference to the backing scipy matrix so it doesn't get
+-        # deallocated before us.
+-        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
+-        if tidyup:
+-            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
+-
+-    def __reduce__(self):
+-        return (fast_from_scipy, (self.as_scipy(),))
+-
+-    cpdef CSR copy(self):
+-        """
+-        Return a complete (deep) copy of this object.
+-
+-        If the type currently has a scipy backing, such as that produced by
+-        `as_scipy`, this will not be copied.  The backing is a view onto our
+-        data, and a straight copy of this view would be incorrect.  We do not
+-        create a new view at copy time, since the user may only access this
+-        through a creation method, and creating it ahead of time would incur an
+-        unnecessary speed penalty for users who do not need it (including
+-        low-level C code).
+-        """
+-        cdef base.idxint nnz_ = nnz(self)
+-        cdef CSR out = empty_like(self)
+-        memcpy(out.data, self.data, nnz_*sizeof(double complex))
+-        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
+-        memcpy(out.row_index, self.row_index,
+-               (self.shape[0] + 1)*sizeof(base.idxint))
+-        return out
+-
+-    cpdef object to_array(self):
+-        """
+-        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
+-        is not a view onto the data, and changes to new array will not affect
+-        the original data structure.
+-        """
+-        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
+-        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
+-        cdef double complex [:, ::1] buffer = out
+-        cdef size_t row, ptr
+-        for row in range(self.shape[0]):
+-            for ptr in range(self.row_index[row], self.row_index[row + 1]):
+-                buffer[row, self.col_index[ptr]] = self.data[ptr]
+-        return out
+-
+-    cpdef object as_scipy(self, bint full=False):
+-        """
+-        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
+-        underlying data structures are exposed, such that modifications to the
+-        `data`, `indices` and `indptr` buffers in the resulting object will
+-        modify this object too.
+-
+-        If `full` is False (the default), the output array is squeezed so that
+-        the SciPy array sees only the filled elements.  If `full` is True,
+-        SciPy will see the full underlying buffers, which may include
+-        uninitialised elements.  Setting `full=True` is intended for
+-        Python-space factory methods.  In all other use cases, `full=False` is
+-        much less error prone.
+-        """
+-        # We store a reference to the scipy matrix not only for caching this
+-        # relatively expensive method, but also because we transferred
+-        # ownership of our data to the numpy arrays, and we can't allow them to
+-        # be collected while we're alive.
+-        if self._scipy is not None:
+-            return self._scipy
+-        cdef cnp.npy_intp length = self.size if full else nnz(self)
+-        data = cnp.PyArray_SimpleNewFromData(1, [length],
+-                                             cnp.NPY_COMPLEX128,
+-                                             self.data)
+-        indices = cnp.PyArray_SimpleNewFromData(1, [length],
+-                                                base.idxint_DTYPE,
+-                                                self.col_index)
+-        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
+-                                               base.idxint_DTYPE,
+-                                               self.row_index)
+-        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
+-        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
+-        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
+-        self._deallocate = False
+-        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
+-        return self._scipy
+-
+-    cpdef CSR sort_indices(self):
+-        cdef Sorter sort
+-        cdef base.idxint ptr
+-        cdef size_t row, diff, size=0
+-        for row in range(self.shape[0]):
+-            diff = self.row_index[row + 1] - self.row_index[row]
+-            size = diff if diff > size else size
+-        sort = Sorter(size)
+-        for row in range(self.shape[0]):
+-            ptr = self.row_index[row]
+-            diff = self.row_index[row + 1] - ptr
+-            sort.inplace(self, ptr, diff)
+-        return self
+-
+-    cpdef double complex trace(self):
+-        return trace_csr(self)
+-
+-    cpdef CSR adjoint(self):
+-        return adjoint_csr(self)
+-
+-    cpdef CSR conj(self):
+-        return conj_csr(self)
+-
+-    cpdef CSR transpose(self):
+-        return transpose_csr(self)
+-
+-    def __repr__(self):
+-        return "".join([
+-            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
+-        ])
+-
+-    def __str__(self):
+-        return self.__repr__()
+-
+-    def __dealloc__(self):
+-        # If we have a reference to a scipy type, then we've passed ownership
+-        # of the data to numpy, so we let it handle refcounting and we don't
+-        # need to deallocate anything ourselves.
+-        if not self._deallocate:
+-            return
+-        if self.data != NULL:
+-            PyDataMem_FREE(self.data)
+-        if self.col_index != NULL:
+-            PyDataMem_FREE(self.col_index)
+-        if self.row_index != NULL:
+-            PyDataMem_FREE(self.row_index)
+-
+-
+-cpdef CSR fast_from_scipy(object sci):
+-    """
+-    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
+-    checking on any of the inputs, and should consequently be considered very
+-    unsafe.  This is primarily for use in the unpickling operation.
+-    """
+-    cdef CSR out = CSR.__new__(CSR)
+-    out.shape = sci.shape
+-    out._deallocate = False
+-    out._scipy = sci
+-    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
+-    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
+-    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
+-    out.size = cnp.PyArray_SIZE(sci.data)
+-    return out
+-
+-
+-cpdef CSR copy_structure(CSR matrix):
+-    """
+-    Return a copy of the input matrix with identical `col_index` and
+-    `row_index` matrices, and an allocated, but empty, `data`.  The returned
+-    pointers are all separately allocated, but contain the same information.
+-
+-    This is intended for unary functions on CSR types that maintain the exact
+-    structure, but modify each non-zero data element without change their
+-    location.
+-    """
+-    cdef CSR out = empty_like(matrix)
+-    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
+-    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
+-    return out
+-
+-
+-cpdef inline base.idxint nnz(CSR matrix) nogil:
+-    """Get the number of non-zero elements of a CSR matrix."""
+-    return matrix.row_index[matrix.shape[0]]
+-
+-
+-cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
+-    return i[0] < j[0]
+-
+-cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
+-    return x.col < y.col
+-
+-ctypedef fused _swap_data:
+-    double complex
+-    base.idxint
+-
+-cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
+-    a[0], b[0] = b[0], a[0]
+-
+-cdef class Sorter:
+-    # Look on my works, ye mighty, and despair!
+-    #
+-    # This class has hard-coded sorts for up to three elements, for both
+-    # copying and in-place varieties.  Everything above that we delegate to a
+-    # proper sorting algorithm.
+-    def __init__(self, size_t size):
+-        self.size = size
+-
+-    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
+-        cdef size_t n
+-        cdef base.idxint col0, col1, col2
+-        # Fast paths for tridiagonal matrices.  These fast paths minimise the
+-        # number of comparisons and swaps made.
+-        if size < 2:
+-            return
+-        if size == 2:
+-            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
+-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+-            return
+-        if size == 3:
+-            # Faster to store rather than re-dereference, and if someone
+-            # changes the data underneath us, we've got larger problems anyway.
+-            col0 = matrix.col_index[ptr]
+-            col1 = matrix.col_index[ptr + 1]
+-            col2 = matrix.col_index[ptr + 2]
+-            if col0 < col1:
+-                if col1 > col2:
+-                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
+-                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
+-                    if col0 > col2:
+-                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+-                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+-            elif col1 < col2:
+-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+-                if col0 > col2:
+-                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
+-                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
+-            else:
+-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
+-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
+-            return
+-        # Now we actually have to do the sort properly.  It's easiest just to
+-        # copy the data into a temporary structure.
+-        if size > self.size or self.sort == NULL:
+-            # realloc(NULL, size) is equivalent to malloc(size), so there's no
+-            # problem if cols and argsort weren't allocated before.
+-            self.size = size if size > self.size else self.size
+-            with gil:
+-                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
+-                                                            self.size * sizeof(_data_col))
+-        for n in range(size):
+-            self.sort[n].data = matrix.data[ptr + n]
+-            self.sort[n].col = matrix.col_index[ptr + n]
+-        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
+-        for n in range(size):
+-            matrix.data[ptr + n] = self.sort[n].data
+-            matrix.col_index[ptr + n] = self.sort[n].col
+-
+-    cdef void copy(self,
+-                   double complex *dest_data, base.idxint *dest_cols,
+-                   double complex *src_data, base.idxint *src_cols,
+-                   size_t size) nogil:
+-        cdef size_t n, ptr
+-        # Fast paths for small sizes.  Not pretty, but it speeds things up a
+-        # lot for up to triadiaongal systems (which are pretty common).
+-        if size == 0:
+-            return
+-        if size == 1:
+-            dest_cols[0] = src_cols[0]
+-            dest_data[0] = src_data[0]
+-            return
+-        if size == 2:
+-            if src_cols[0] < src_cols[1]:
+-                dest_cols[0] = src_cols[0]
+-                dest_data[0] = src_data[0]
+-                dest_cols[1] = src_cols[1]
+-                dest_data[1] = src_data[1]
+-            else:
+-                dest_cols[1] = src_cols[0]
+-                dest_data[1] = src_data[0]
+-                dest_cols[0] = src_cols[1]
+-                dest_data[0] = src_data[1]
+-            return
+-        if size == 3:
+-            if src_cols[0] < src_cols[1]:
+-                if src_cols[0] < src_cols[2]:
+-                    dest_cols[0] = src_cols[0]
+-                    dest_data[0] = src_data[0]
+-                    if src_cols[1] < src_cols[2]:
+-                        dest_cols[1] = src_cols[1]
+-                        dest_data[1] = src_data[1]
+-                        dest_cols[2] = src_cols[2]
+-                        dest_data[2] = src_data[2]
+-                    else:
+-                        dest_cols[2] = src_cols[1]
+-                        dest_data[2] = src_data[1]
+-                        dest_cols[1] = src_cols[2]
+-                        dest_data[1] = src_data[2]
+-                else:
+-                    dest_cols[1] = src_cols[0]
+-                    dest_data[1] = src_data[0]
+-                    dest_cols[2] = src_cols[1]
+-                    dest_data[2] = src_data[1]
+-                    dest_cols[0] = src_cols[2]
+-                    dest_data[0] = src_data[2]
+-            elif src_cols[0] < src_cols[2]:
+-                dest_cols[1] = src_cols[0]
+-                dest_data[1] = src_data[0]
+-                dest_cols[0] = src_cols[1]
+-                dest_data[0] = src_data[1]
+-                dest_cols[2] = src_cols[2]
+-                dest_data[2] = src_data[2]
+-            else:
+-                dest_cols[2] = src_cols[0]
+-                dest_data[2] = src_data[0]
+-                if src_cols[1] < src_cols[2]:
+-                    dest_cols[0] = src_cols[1]
+-                    dest_data[0] = src_data[1]
+-                    dest_cols[1] = src_cols[2]
+-                    dest_data[1] = src_data[2]
+-                else:
+-                    dest_cols[1] = src_cols[1]
+-                    dest_data[1] = src_data[1]
+-                    dest_cols[0] = src_cols[2]
+-                    dest_data[0] = src_data[2]
+-            return
+-        # Now we're left with the full case, and we have to sort properly.
+-        if size > self.size or self.argsort == NULL:
+-            # realloc(NULL, size) is equivalent to malloc(size), so there's no
+-            # problem if cols and argsort weren't allocated before.
+-            self.size = size if size > self.size else self.size
+-            with gil:
+-                self.argsort = (
+-                    <base.idxint **>
+-                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
+-                )
+-        # We do the argsort with two levels of indirection to minimise memory
+-        # allocation and copying requirements when this function is being used
+-        # to assemble a CSR matrix under an operation which may change the
+-        # order of the columns (e.g. permute).  First the user makes the
+-        # columns accessible in some contiguous memory (or if they're not
+-        # changing them, they can just use the CSR buffers).  We put pointers
+-        # to each of those columns in the array which actually gets sorted
+-        # using a comparison function which dereferences the pointers and
+-        # compares the result.  After the sort, `argsort` will be the pointers
+-        # sorted according to the new column, and we know that the "lowest"
+-        # pointer in there has the value `src_cols`, so we can do pointer
+-        # arithmetic to know which element we should take.
+-        #
+-        # This is about 30-40% faster than allocating space for structs of
+-        # (double complex, idxint), copying in the data and column, sorting and
+-        # copying into the new arrays.  Allocating the structs actually
+-        # allocates more space than the pointer method (double complex is
+-        # very likely to be 2x the size of a pointer, _and_ the struct may need
+-        # extra padding to be aligned), so it's probably actually worse for
+-        # cache locality.  Despite the sort relying on pointer dereference in
+-        # this case, it's actually got very good cache locality.
+-        for n in range(size):
+-            self.argsort[n] = src_cols + n
+-        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
+-        for n in range(size):
+-            ptr = self.argsort[n] - src_cols
+-            dest_cols[n] = src_cols[ptr]
+-            dest_data[n] = src_data[ptr]
+-
+-    def __dealloc__(self):
+-        if self.argsort != NULL:
+-            mem.PyMem_Free(self.argsort)
+-        if self.sort != NULL:
+-            mem.PyMem_Free(self.sort)
+-
+-cpdef CSR sorted(CSR matrix):
+-    cdef CSR out = empty_like(matrix)
+-    cdef Sorter sort
+-    cdef base.idxint ptr
+-    cdef size_t row, diff, size=0
+-    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
+-    for row in range(matrix.shape[0]):
+-        diff = matrix.row_index[row + 1] - matrix.row_index[row]
+-        size = diff if diff > size else size
+-    sort = Sorter(size)
+-    for row in range(matrix.shape[0]):
+-        ptr = matrix.row_index[row]
+-        diff = matrix.row_index[row + 1] - ptr
+-        sort.copy(out.data + ptr, out.col_index + ptr,
+-                  matrix.data + ptr, matrix.col_index + ptr,
+-                  diff)
+-    return out
+-
+-
+-cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
+-    """
+-    Allocate an empty CSR matrix of the given shape, with space for `size`
+-    elements in the `data` and `col_index` arrays.
+-
+-    This does not initialise any of the memory returned, but sets the last
+-    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
+-    """
+-    if size < 0:
+-        raise ValueError("size must be a positive integer.")
+-    # Python doesn't like allocating nothing.
+-    if size == 0:
+-        size += 1
+-    cdef CSR out = CSR.__new__(CSR)
+-    cdef base.idxint row_size = rows + 1
+-    out.shape = (rows, cols)
+-    out.size = size
+-    out.data =\
+-        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
+-    out.col_index =\
+-        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
+-    out.row_index =\
+-        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
+-    # Set the number of non-zero elements to 0.
+-    out.row_index[rows] = 0
+-    return out
+-
+-
+-cpdef CSR empty_like(CSR other):
+-    return empty(other.shape[0], other.shape[1], nnz(other))
+-
+-
+-cpdef CSR zeros(base.idxint rows, base.idxint cols):
+-    """
+-    Allocate the zero matrix with a given shape.  There will not be any room in
+-    the `data` and `col_index` buffers to add new elements.
+-    """
+-    # We always allocate matrices with at least one element to ensure that we
+-    # actually _are_ asking for memory (Python doesn't like allocating nothing)
+-    cdef CSR out = empty(rows, cols, 1)
+-    out.data[0] = out.col_index[0] = 0
+-    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
+-    return out
+-
+-
+-cpdef CSR identity(base.idxint dimension, double complex scale=1):
+-    """
+-    Return a square matrix of the specified dimension, with a constant along
+-    the diagonal.  By default this will be the identity matrix, but if `scale`
+-    is passed, then the result will be `scale` times the identity.
+-    """
+-    cdef CSR out = empty(dimension, dimension, dimension)
+-    cdef base.idxint i
+-    for i in range(dimension):
+-        out.data[i] = scale
+-        out.col_index[i] = i
+-        out.row_index[i] = i
+-    out.row_index[dimension] = dimension
+-    return out
+-
+-cpdef CSR from_dense(Dense matrix):
+-    # Assume worst-case scenario for non-zero.
+-    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
+-                         matrix.shape[0]*matrix.shape[1])
+-    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
+-    row_stride = 1 if matrix.fortran else matrix.shape[1]
+-    col_stride = matrix.shape[0] if matrix.fortran else 1
+-    out.row_index[0] = 0
+-    for row in range(matrix.shape[0]):
+-        ptr_in = row_stride * row
+-        for col in range(matrix.shape[1]):
+-            if matrix.data[ptr_in] != 0:
+-                out.data[ptr_out] = matrix.data[ptr_in]
+-                out.col_index[ptr_out] = col
+-                ptr_out += 1
+-            ptr_in += col_stride
+-        out.row_index[row + 1] = ptr_out
+-    return out
+-
+-cdef CSR from_coo_pointers(
+-    base.idxint *rows, base.idxint *cols, double complex *data,
+-    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
+-):
+-    # Note that COO pointers may not be sorted in row-major order, and that
+-    # they may contain duplicate entries which should be implicitly summed.
+-    cdef Accumulator acc = acc_alloc(n_cols)
+-    cdef CSR out = empty(n_rows, n_cols, nnz)
+-    cdef double complex *data_tmp
+-    cdef base.idxint *cols_tmp
+-    cdef base.idxint row
+-    cdef size_t ptr_in, ptr_out, ptr_prev
+-    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
+-    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
+-    if data_tmp == NULL or cols_tmp == NULL:
+-        raise MemoryError
+-    with nogil:
+-        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
+-        for ptr_in in range(nnz):
+-            out.row_index[rows[ptr_in] + 1] += 1
+-        for ptr_out in range(n_rows):
+-            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
+-        # out.row_index is currently in the normal output form, but we're
+-        # temporarily going to modify it to keep track of how many values we've
+-        # placed in each row as we iterate through.  At every state,
+-        # out.row_index[row] will contain a pointer to the next location that
+-        # an element should be placed in this row.
+-        for ptr_in in range(nnz):
+-            row = rows[ptr_in]
+-            ptr_out = out.row_index[row]
+-            cols_tmp[ptr_out] = cols[ptr_in]
+-            data_tmp[ptr_out] = data[ptr_in]
+-            out.row_index[row] += 1
+-        # Apply the scatter/gather pattern to find the actual number of
+-        # non-zero elements we're writing into each row (since there's a sum,
+-        # there may be some zeros of duplicates).  Remember we also need to
+-        # shift the row_index array back to what it was before as well.
+-        ptr_out = 0
+-        ptr_prev = 0
+-        for row in range(n_rows):
+-            for ptr_in in range(ptr_prev, out.row_index[row]):
+-                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
+-            ptr_prev = out.row_index[row]
+-            out.row_index[row] = ptr_out
+-            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
+-            acc_reset(&acc)
+-        out.row_index[n_rows] = ptr_out
+-    mem.PyMem_Free(data_tmp)
+-    mem.PyMem_Free(cols_tmp)
+-    acc_free(&acc)
+-    return out
+-
+-
+-cdef inline base.idxint _diagonal_length(
+-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+-) nogil:
+-    if offset > 0:
+-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+-    return n_cols if offset > n_cols - n_rows else n_rows + offset
+-
+-cdef CSR diag(
+-    double complex[:] diagonal, base.idxint offset,
+-    base.idxint n_rows, base.idxint n_cols,
+-):
+-    """
+-    Construct a CSR matrix with a single non-zero diagonal.
+-
+-    Parameters
+-    ----------
+-    diagonal : indexable of double complex
+-        The entries (including zeros) that should be placed on the diagonal in
+-        the output matrix.  Each entry must have enough entries in it to fill
+-        the relevant diagonal.
+-
+-    offsets : idxint
+-        The index of the diagonals.  An offset of 0 is the main diagonal,
+-        positive values are above the main diagonal and negative ones are below
+-        the main diagonal.
+-
+-    n_rows, n_cols : idxint
+-        The shape of the output.  The result does not need to be square, but
+-        the diagonal must be of the correct length to fit in.
+-    """
+-    if n_rows < 0 or n_cols < 0:
+-        raise ValueError("shape must be positive")
+-    cdef base.idxint nnz = len(diagonal)
+-    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
+-    if nnz != n_diag:
+-        raise ValueError("incorrect number of diagonal elements")
+-    cdef CSR out = empty(n_rows, n_cols, nnz)
+-    cdef base.idxint start_row = 0 if offset >= 0 else -offset
+-    cdef base.idxint col = 0 if offset <= 0 else offset
+-    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
+-    nnz = 0
+-    for row in range(start_row + 1, start_row + n_diag + 1):
+-        out.col_index[nnz] = col
+-        out.data[nnz] = diagonal[nnz]
+-        col += 1
+-        nnz += 1
+-        out.row_index[row] = nnz
+-    for row in range(start_row + n_diag + 1, n_rows + 1):
+-        out.row_index[row] = nnz
+-    return out
+-
+-cdef CSR diags_(
+-    list diagonals, base.idxint[:] offsets,
+-    base.idxint n_rows, base.idxint n_cols,
+-):
+-    """
+-    Construct a CSR matrix from a list of diagonals and their offsets.  The
+-    offsets are assumed to be in sorted order.  This is the C-only interface to
+-    csr.diags, and inputs are not sanity checked (use the Python interface for
+-    that).
+-
+-    Parameters
+-    ----------
+-    diagonals : list of indexable of double complex
+-        The entries (including zeros) that should be placed on the diagonals in
+-        the output matrix.  Each entry must have enough entries in it to fill
+-        the relevant diagonal (not checked).
+-
+-    offsets : idxint[:]
+-        The indices of the diagonals.  These should be sorted and without
+-        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
+-        An offset of 0 is the main diagonal, positive values are above the main
+-        diagonal and negative ones are below the main diagonal.
+-
+-    n_rows, n_cols : idxint
+-        The shape of the output.  The result does not need to be square, but
+-        the diagonals must be of the correct length to fit in.
+-    """
+-    cdef size_t n_diagonals = len(diagonals)
+-    if n_diagonals == 0:
+-        return zeros(n_rows, n_cols)
+-    cdef base.idxint k, row, start_row, offset, nnz=0,
+-    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
+-    cdef double complex value
+-    for k in range(n_diagonals):
+-        offset = offsets[k]
+-        if offset >= 0 and min_k > k:
+-            min_k = k
+-        nnz += _diagonal_length(offset, n_rows, n_cols)
+-    cdef CSR out = empty(n_rows, n_cols, nnz)
+-    nnz = 0
+-    out.row_index[0] = 0
+-    for row in range(n_rows):
+-        if min_k > 0:
+-            offset = offsets[min_k - 1]
+-            start_row = 0 if offset >= 0 else -offset
+-            if start_row == row:
+-                min_k -= 1
+-        if max_k > 0:
+-            offset = offsets[max_k - 1]
+-            start_row = 0 if offset >= 0 else -offset
+-            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
+-                max_k -= 1
+-        for k in range(min_k, max_k):
+-            offset = offsets[k]
+-            value = diagonals[k][row if offset >= 0 else row + offset]
+-            if value == 0:
+-                continue
+-            out.data[nnz] = value
+-            out.col_index[nnz] = row + offset
+-            nnz += 1
+-        out.row_index[row + 1] = nnz
+-    return out
+-
+-@cython.wraparound(True)
+-def diags(diagonals, offsets=None, shape=None):
+-    """
+-    Construct a CSR matrix from diagonals and their offsets.  Using this
+-    function in single-argument form produces a square matrix with the given
+-    values on the main diagonal.
+-
+-    With lists of diagonals and offsets, the matrix will be the smallest
+-    possible square matrix if shape is not given, but in all cases the
+-    diagonals must fit exactly with no extra or missing elements.  Duplicated
+-    diagonals will be summed together in the output.
+-
+-    Parameters
+-    ----------
+-    diagonals : sequence of array_like of complex or array_like of complex
+-        The entries (including zeros) that should be placed on the diagonals in
+-        the output matrix.  Each entry must have enough entries in it to fill
+-        the relevant diagonal and no more.
+-
+-    offsets : sequence of integer or integer, optional
+-        The indices of the diagonals.  `offsets[i]` is the location of the
+-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+-        values are above the main diagonal and negative ones are below the main
+-        diagonal.
+-
+-    shape : tuple, optional
+-        The shape of the output as (``rows``, ``columns``).  The result does
+-        not need to be square, but the diagonals must be of the correct length
+-        to fit in exactly.
+-    """
+-    cdef base.idxint n_rows, n_cols, offset
+-    try:
+-        diagonals = list(diagonals)
+-        if diagonals and np.isscalar(diagonals[0]):
+-            # Catch the case where we're being called as (for example)
+-            #   diags([1, 2, 3], 0)
+-            # with a single diagonal and offset.
+-            diagonals = [diagonals]
+-    except TypeError:
+-        raise TypeError("diagonals must be a list of arrays of complex") from None
+-    if offsets is None:
+-        if len(diagonals) == 0:
+-            offsets = []
+-        elif len(diagonals) == 1:
+-            offsets = [0]
+-        else:
+-            raise TypeError("offsets must be supplied if passing more than one diagonal")
+-    offsets = np.atleast_1d(offsets)
+-    if offsets.ndim > 1:
+-        raise ValueError("offsets must be a 1D array of integers")
+-    if len(diagonals) != len(offsets):
+-        raise ValueError("number of diagonals does not match number of offsets")
+-    if len(diagonals) == 0:
+-        if shape is None:
+-            raise ValueError("cannot construct matrix with no diagonals without a shape")
+-        else:
+-            n_rows, n_cols = shape
+-        return zeros(n_rows, n_cols)
+-    order = np.argsort(offsets)
+-    diagonals_ = []
+-    offsets_ = []
+-    prev, cur = None, None
+-    for i in order:
+-        cur = offsets[i]
+-        if cur == prev:
+-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+-        else:
+-            offsets_.append(cur)
+-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+-        prev = cur
+-    if shape is None:
+-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+-    else:
+-        try:
+-            n_rows, n_cols = shape
+-        except (TypeError, ValueError):
+-            raise TypeError("shape must be a 2-tuple of positive integers")
+-        if n_rows < 0 or n_cols < 0:
+-            raise ValueError("shape must be a 2-tuple of positive integers")
+-    for i in range(len(diagonals_)):
+-        offset = offsets_[i]
+-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+-            raise ValueError("given diagonals do not have the correct lengths")
+-    if n_rows == 0 and n_cols == 0:
+-        raise ValueError("can't produce a 0x0 matrix")
+-    if len(offsets) == 1:
+-        # Fast path for a single diagonal.
+-        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
+-    return diags_(
+-        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
+-    )
+-
+-
+-cpdef CSR _from_csr_blocks(
+-    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+-    base.idxint n_blocks, base.idxint block_size
+-):
+-    """
+-    Construct a CSR from non-overlapping blocks.
+-
+-    Each operator in ``block_ops`` should be a square CSR operator with
+-    shape ``(block_size, block_size)``. The output operator consists of
+-    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
+-    ``(n_blocks * block_size, n_blocks * block_size)``.
+-
+-    None of the operators should overlap (i.e. the list of block row and
+-    column pairs should be unique).
+-
+-    Parameters
+-    ----------
+-    block_rows : sequence of base.idxint integers
+-        The block row for each operator. The block row should be in
+-        ``range(0, n_blocks)``.
+-
+-    block_cols : sequence of base.idxint integers
+-        The block column for each operator. The block column should be in
+-        ``range(0, n_blocks)``.
+-
+-    block_ops : sequence of CSR matrixes
+-        The operators corresponding to the rows and columns in ``block_rows``
+-        and ``block_cols``.
+-
+-    n_blocks : base.idxint
+-        Number of blocks. The shape of the final matrix is
+-        (n_blocks * block, n_blocks * block).
+-
+-    block_size : base.idxint
+-        Size of each block. The shape of matrices in ``block_ops`` is
+-        ``(block_size, block_size)``.
+-    """
+-    cdef CSR op
+-    cdef base.idxint shape = n_blocks * block_size
+-    cdef base.idxint nnz_ = 0
+-    cdef base.idxint n_ops = len(block_ops)
+-    cdef base.idxint i, j
+-    cdef base.idxint row_idx, col_idx
+-
+-    # check arrays are the same length
+-    if len(block_rows) != n_ops or len(block_cols) != n_ops:
+-        raise ValueError(
+-            "The arrays block_rows, block_cols and block_ops should have"
+-            " the same length."
+-        )
+-
+-    if n_ops == 0:
+-        return zeros(shape, shape)
+-
+-    # check op shapes and calculate nnz
+-    for op in block_ops:
+-        nnz_ += nnz(op)
+-        if op.shape[0] != block_size or op.shape[1] != block_size:
+-            raise ValueError(
+-                "Block operators (block_ops) do not have the correct shape."
+-            )
+-
+-    # check ops are ordered by (row, column)
+-    row_idx = block_rows[0]
+-    col_idx = block_cols[0]
+-    for i in range(1, n_ops):
+-        if (
+-            block_rows[i] < row_idx or
+-            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
+-        ):
+-            raise ValueError(
+-                "The arrays block_rows and block_cols must be sorted"
+-                " by (row, column)."
+-            )
+-        row_idx = block_rows[i]
+-        col_idx = block_cols[i]
+-
+-    if nnz_ == 0:
+-        return zeros(shape, shape)
+-
+-    cdef CSR out = empty(shape, shape, nnz_)
+-    cdef base.idxint op_idx = 0
+-    cdef base.idxint prev_op_idx = 0
+-    cdef base.idxint end = 0
+-    cdef base.idxint row_pos, col_pos
+-    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
+-
+-    out.row_index[0] = 0
+-
+-    for row_idx in range(n_blocks):
+-        prev_op_idx = op_idx
+-        while op_idx < n_ops:
+-            if block_rows[op_idx] != row_idx:
+-                break
+-            op_idx += 1
+-
+-        row_pos = row_idx * block_size
+-        for op_row in range(block_size):
+-            for i in range(prev_op_idx, op_idx):
+-                op = block_ops[i]
+-                if nnz(op) == 0:
+-                    # empty CSR matrices have uninitialized row_index entries.
+-                    # it's unclear whether users should ever see such matrixes
+-                    # but we support them here anyway.
+-                    continue
+-                col_idx = block_cols[i]
+-                col_pos = col_idx * block_size
+-                op_row_start = op.row_index[op_row]
+-                op_row_end = op.row_index[op_row + 1]
+-                op_row_len = op_row_end - op_row_start
+-                for j in range(op_row_len):
+-                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
+-                    out.data[end + j] = op.data[op_row_start + j]
+-                end += op_row_len
+-            out.row_index[row_pos + op_row + 1] = end
+-
+-    return out
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.string cimport memset, memcpy
++
++from libcpp cimport bool
++from libcpp.algorithm cimport sort
++
++cimport cython
++
++from cpython cimport mem
++
++import numbers
++import warnings
++
++import numpy as np
++cimport numpy as cnp
++import scipy.sparse
++from scipy.sparse import csr_matrix as scipy_csr_matrix
++try:
++    from scipy.sparse.data import _data_matrix as scipy_data_matrix
++except ImportError:
++    # The file data was renamed to _data from scipy 1.8.0
++    from scipy.sparse._data import _data_matrix as scipy_data_matrix
++from scipy.linalg cimport cython_blas as blas
++
++from qutip.core.data cimport base, Dense
++from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
++from qutip.core.data.trace cimport trace_csr
++from qutip.core.data.tidyup cimport tidyup_csr
++from .base import idxint_dtype
++from qutip.settings import settings
++
++cnp.import_array()
++
++cdef extern from *:
++    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
++    void *PyDataMem_NEW(size_t size)
++    void PyDataMem_FREE(void *ptr)
++
++# Very little should be exported on star-import, because most stuff will have
++# naming collisions with other type modules.
++__all__ = ['CSR']
++
++cdef int _ONE = 1
++
++cdef object _csr_matrix(data, indices, indptr, shape):
++    """
++    Factory method of scipy csr_matrix: we skip all the index type-checking
++    because this takes tens of microseconds, and we already know we're in
++    a sensible format.
++    """
++    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
++    # `_data_matrix` is the first object in the inheritance chain which
++    # doesn't have a really slow __init__.
++    scipy_data_matrix.__init__(out)
++    out.data = data
++    out.indices = indices
++    out.indptr = indptr
++    out._shape = shape
++    return out
++
++
++cdef class CSR(base.Data):
++    """
++    Data type for quantum objects storing its data in compressed sparse row
++    (CSR) format.  This is similar to the `scipy` type
++    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
++    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
++    using the `as_scipy()` method.
++    """
++    def __cinit__(self, *args, **kwargs):
++        # By default, we want CSR to deallocate its memory (we depend on Cython
++        # to ensure we don't deallocate a NULL pointer), and we only flip this
++        # when we create a scipy backing.  Since creating the scipy backing
++        # depends on knowing the shape, which happens _after_ data
++        # initialisation and may throw an exception, it is better to have a
++        # single flag that is set as soon as the pointers are assigned.
++        self._deallocate = True
++
++    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
++        # This is the Python __init__ method, so we do not care that it is not
++        # super-fast C access.  Typically Cython code will not call this, but
++        # will use a factory method in this module or at worst, call
++        # CSR.__new__ and manually set everything.  We must be very careful in
++        # this function that the deallocation is set up correctly if any
++        # exceptions occur.
++        cdef size_t ptr
++        cdef base.idxint col
++        cdef object data, col_index, row_index
++        if isinstance(arg, scipy.sparse.spmatrix):
++            arg = arg.tocsr()
++            if shape is not None and shape != arg.shape:
++                raise ValueError("".join([
++                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
++                ]))
++            shape = arg.shape
++            arg = (arg.data, arg.indices, arg.indptr)
++        if not isinstance(arg, tuple):
++            raise TypeError("arg must be a scipy matrix or tuple")
++        if len(arg) != 3:
++            raise ValueError("arg must be a (data, col_index, row_index) tuple")
++        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
++        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
++        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
++        # This flag must be set at the same time as data, col_index and
++        # row_index are assigned.  These assignments cannot raise an exception
++        # in user code due to the above three lines, but further code may.
++        self._deallocate = False
++        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
++        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
++        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
++        self.size = (cnp.PyArray_SIZE(data)
++                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
++                     else cnp.PyArray_SIZE(col_index))
++        if shape is None:
++            warnings.warn("instantiating CSR matrix of unknown shape")
++            # row_index contains an extra element which is nnz.  We assume the
++            # smallest matrix which can hold all these values by iterating
++            # through the columns.  This is slow and probably inaccurate, since
++            # there could be columns containing zero (hence the warning).
++            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
++            col = 1
++            for ptr in range(self.size):
++                col = self.col_index[ptr] if self.col_index[ptr] > col else col
++            self.shape[1] = col
++        else:
++            if not isinstance(shape, tuple):
++                raise TypeError("shape must be a 2-tuple of positive ints")
++            if not (len(shape) == 2
++                    and isinstance(shape[0], int)
++                    and isinstance(shape[1], int)
++                    and shape[0] > 0
++                    and shape[1] > 0):
++                raise ValueError("shape must be a 2-tuple of positive ints")
++            self.shape = shape
++        # Store a reference to the backing scipy matrix so it doesn't get
++        # deallocated before us.
++        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
++        if tidyup:
++            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
++
++    def __reduce__(self):
++        return (fast_from_scipy, (self.as_scipy(),))
++
++    cpdef CSR copy(self):
++        """
++        Return a complete (deep) copy of this object.
++
++        If the type currently has a scipy backing, such as that produced by
++        `as_scipy`, this will not be copied.  The backing is a view onto our
++        data, and a straight copy of this view would be incorrect.  We do not
++        create a new view at copy time, since the user may only access this
++        through a creation method, and creating it ahead of time would incur an
++        unnecessary speed penalty for users who do not need it (including
++        low-level C code).
++        """
++        cdef base.idxint nnz_ = nnz(self)
++        cdef CSR out = empty_like(self)
++        memcpy(out.data, self.data, nnz_*sizeof(double complex))
++        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
++        memcpy(out.row_index, self.row_index,
++               (self.shape[0] + 1)*sizeof(base.idxint))
++        return out
++
++    cpdef object to_array(self):
++        """
++        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
++        is not a view onto the data, and changes to new array will not affect
++        the original data structure.
++        """
++        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
++        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
++        cdef double complex [:, ::1] buffer = out
++        cdef size_t row, ptr
++        for row in range(self.shape[0]):
++            for ptr in range(self.row_index[row], self.row_index[row + 1]):
++                buffer[row, self.col_index[ptr]] = self.data[ptr]
++        return out
++
++    cpdef object as_scipy(self, bint full=False):
++        """
++        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
++        underlying data structures are exposed, such that modifications to the
++        `data`, `indices` and `indptr` buffers in the resulting object will
++        modify this object too.
++
++        If `full` is False (the default), the output array is squeezed so that
++        the SciPy array sees only the filled elements.  If `full` is True,
++        SciPy will see the full underlying buffers, which may include
++        uninitialised elements.  Setting `full=True` is intended for
++        Python-space factory methods.  In all other use cases, `full=False` is
++        much less error prone.
++        """
++        # We store a reference to the scipy matrix not only for caching this
++        # relatively expensive method, but also because we transferred
++        # ownership of our data to the numpy arrays, and we can't allow them to
++        # be collected while we're alive.
++        if self._scipy is not None:
++            return self._scipy
++        cdef cnp.npy_intp length = self.size if full else nnz(self)
++        data = cnp.PyArray_SimpleNewFromData(1, [length],
++                                             cnp.NPY_COMPLEX128,
++                                             self.data)
++        indices = cnp.PyArray_SimpleNewFromData(1, [length],
++                                                base.idxint_DTYPE,
++                                                self.col_index)
++        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
++                                               base.idxint_DTYPE,
++                                               self.row_index)
++        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
++        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
++        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
++        self._deallocate = False
++        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
++        return self._scipy
++
++    cpdef CSR sort_indices(self):
++        cdef Sorter sort
++        cdef base.idxint ptr
++        cdef size_t row, diff, size=0
++        for row in range(self.shape[0]):
++            diff = self.row_index[row + 1] - self.row_index[row]
++            size = diff if diff > size else size
++        sort = Sorter(size)
++        for row in range(self.shape[0]):
++            ptr = self.row_index[row]
++            diff = self.row_index[row + 1] - ptr
++            sort.inplace(self, ptr, diff)
++        return self
++
++    cpdef double complex trace(self):
++        return trace_csr(self)
++
++    cpdef CSR adjoint(self):
++        return adjoint_csr(self)
++
++    cpdef CSR conj(self):
++        return conj_csr(self)
++
++    cpdef CSR transpose(self):
++        return transpose_csr(self)
++
++    def __repr__(self):
++        return "".join([
++            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
++        ])
++
++    def __str__(self):
++        return self.__repr__()
++
++    def __dealloc__(self):
++        # If we have a reference to a scipy type, then we've passed ownership
++        # of the data to numpy, so we let it handle refcounting and we don't
++        # need to deallocate anything ourselves.
++        if not self._deallocate:
++            return
++        if self.data != NULL:
++            PyDataMem_FREE(self.data)
++        if self.col_index != NULL:
++            PyDataMem_FREE(self.col_index)
++        if self.row_index != NULL:
++            PyDataMem_FREE(self.row_index)
++
++
++cpdef CSR fast_from_scipy(object sci):
++    """
++    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
++    checking on any of the inputs, and should consequently be considered very
++    unsafe.  This is primarily for use in the unpickling operation.
++    """
++    cdef CSR out = CSR.__new__(CSR)
++    out.shape = sci.shape
++    out._deallocate = False
++    out._scipy = sci
++    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
++    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
++    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
++    out.size = cnp.PyArray_SIZE(sci.data)
++    return out
++
++
++cpdef CSR copy_structure(CSR matrix):
++    """
++    Return a copy of the input matrix with identical `col_index` and
++    `row_index` matrices, and an allocated, but empty, `data`.  The returned
++    pointers are all separately allocated, but contain the same information.
++
++    This is intended for unary functions on CSR types that maintain the exact
++    structure, but modify each non-zero data element without change their
++    location.
++    """
++    cdef CSR out = empty_like(matrix)
++    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
++    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
++    return out
++
++
++cpdef inline base.idxint nnz(CSR matrix) nogil:
++    """Get the number of non-zero elements of a CSR matrix."""
++    return matrix.row_index[matrix.shape[0]]
++
++
++cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
++    return i[0] < j[0]
++
++cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
++    return x.col < y.col
++
++ctypedef fused _swap_data:
++    double complex
++    base.idxint
++
++cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
++    a[0], b[0] = b[0], a[0]
++
++cdef class Sorter:
++    # Look on my works, ye mighty, and despair!
++    #
++    # This class has hard-coded sorts for up to three elements, for both
++    # copying and in-place varieties.  Everything above that we delegate to a
++    # proper sorting algorithm.
++    def __init__(self, size_t size):
++        self.size = size
++
++    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
++        cdef size_t n
++        cdef base.idxint col0, col1, col2
++        # Fast paths for tridiagonal matrices.  These fast paths minimise the
++        # number of comparisons and swaps made.
++        if size < 2:
++            return
++        if size == 2:
++            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
++                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
++                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
++            return
++        if size == 3:
++            # Faster to store rather than re-dereference, and if someone
++            # changes the data underneath us, we've got larger problems anyway.
++            col0 = matrix.col_index[ptr]
++            col1 = matrix.col_index[ptr + 1]
++            col2 = matrix.col_index[ptr + 2]
++            if col0 < col1:
++                if col1 > col2:
++                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
++                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
++                    if col0 > col2:
++                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
++                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
++            elif col1 < col2:
++                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
++                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
++                if col0 > col2:
++                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
++                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
++            else:
++                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
++                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
++            return
++        # Now we actually have to do the sort properly.  It's easiest just to
++        # copy the data into a temporary structure.
++        if size > self.size or self.sort == NULL:
++            # realloc(NULL, size) is equivalent to malloc(size), so there's no
++            # problem if cols and argsort weren't allocated before.
++            self.size = size if size > self.size else self.size
++            with gil:
++                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
++                                                            self.size * sizeof(_data_col))
++        for n in range(size):
++            self.sort[n].data = matrix.data[ptr + n]
++            self.sort[n].col = matrix.col_index[ptr + n]
++        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
++        for n in range(size):
++            matrix.data[ptr + n] = self.sort[n].data
++            matrix.col_index[ptr + n] = self.sort[n].col
++
++    cdef void copy(self,
++                   double complex *dest_data, base.idxint *dest_cols,
++                   double complex *src_data, base.idxint *src_cols,
++                   size_t size) nogil:
++        cdef size_t n, ptr
++        # Fast paths for small sizes.  Not pretty, but it speeds things up a
++        # lot for up to triadiaongal systems (which are pretty common).
++        if size == 0:
++            return
++        if size == 1:
++            dest_cols[0] = src_cols[0]
++            dest_data[0] = src_data[0]
++            return
++        if size == 2:
++            if src_cols[0] < src_cols[1]:
++                dest_cols[0] = src_cols[0]
++                dest_data[0] = src_data[0]
++                dest_cols[1] = src_cols[1]
++                dest_data[1] = src_data[1]
++            else:
++                dest_cols[1] = src_cols[0]
++                dest_data[1] = src_data[0]
++                dest_cols[0] = src_cols[1]
++                dest_data[0] = src_data[1]
++            return
++        if size == 3:
++            if src_cols[0] < src_cols[1]:
++                if src_cols[0] < src_cols[2]:
++                    dest_cols[0] = src_cols[0]
++                    dest_data[0] = src_data[0]
++                    if src_cols[1] < src_cols[2]:
++                        dest_cols[1] = src_cols[1]
++                        dest_data[1] = src_data[1]
++                        dest_cols[2] = src_cols[2]
++                        dest_data[2] = src_data[2]
++                    else:
++                        dest_cols[2] = src_cols[1]
++                        dest_data[2] = src_data[1]
++                        dest_cols[1] = src_cols[2]
++                        dest_data[1] = src_data[2]
++                else:
++                    dest_cols[1] = src_cols[0]
++                    dest_data[1] = src_data[0]
++                    dest_cols[2] = src_cols[1]
++                    dest_data[2] = src_data[1]
++                    dest_cols[0] = src_cols[2]
++                    dest_data[0] = src_data[2]
++            elif src_cols[0] < src_cols[2]:
++                dest_cols[1] = src_cols[0]
++                dest_data[1] = src_data[0]
++                dest_cols[0] = src_cols[1]
++                dest_data[0] = src_data[1]
++                dest_cols[2] = src_cols[2]
++                dest_data[2] = src_data[2]
++            else:
++                dest_cols[2] = src_cols[0]
++                dest_data[2] = src_data[0]
++                if src_cols[1] < src_cols[2]:
++                    dest_cols[0] = src_cols[1]
++                    dest_data[0] = src_data[1]
++                    dest_cols[1] = src_cols[2]
++                    dest_data[1] = src_data[2]
++                else:
++                    dest_cols[1] = src_cols[1]
++                    dest_data[1] = src_data[1]
++                    dest_cols[0] = src_cols[2]
++                    dest_data[0] = src_data[2]
++            return
++        # Now we're left with the full case, and we have to sort properly.
++        if size > self.size or self.argsort == NULL:
++            # realloc(NULL, size) is equivalent to malloc(size), so there's no
++            # problem if cols and argsort weren't allocated before.
++            self.size = size if size > self.size else self.size
++            with gil:
++                self.argsort = (
++                    <base.idxint **>
++                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
++                )
++        # We do the argsort with two levels of indirection to minimise memory
++        # allocation and copying requirements when this function is being used
++        # to assemble a CSR matrix under an operation which may change the
++        # order of the columns (e.g. permute).  First the user makes the
++        # columns accessible in some contiguous memory (or if they're not
++        # changing them, they can just use the CSR buffers).  We put pointers
++        # to each of those columns in the array which actually gets sorted
++        # using a comparison function which dereferences the pointers and
++        # compares the result.  After the sort, `argsort` will be the pointers
++        # sorted according to the new column, and we know that the "lowest"
++        # pointer in there has the value `src_cols`, so we can do pointer
++        # arithmetic to know which element we should take.
++        #
++        # This is about 30-40% faster than allocating space for structs of
++        # (double complex, idxint), copying in the data and column, sorting and
++        # copying into the new arrays.  Allocating the structs actually
++        # allocates more space than the pointer method (double complex is
++        # very likely to be 2x the size of a pointer, _and_ the struct may need
++        # extra padding to be aligned), so it's probably actually worse for
++        # cache locality.  Despite the sort relying on pointer dereference in
++        # this case, it's actually got very good cache locality.
++        for n in range(size):
++            self.argsort[n] = src_cols + n
++        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
++        for n in range(size):
++            ptr = self.argsort[n] - src_cols
++            dest_cols[n] = src_cols[ptr]
++            dest_data[n] = src_data[ptr]
++
++    def __dealloc__(self):
++        if self.argsort != NULL:
++            mem.PyMem_Free(self.argsort)
++        if self.sort != NULL:
++            mem.PyMem_Free(self.sort)
++
++cpdef CSR sorted(CSR matrix):
++    cdef CSR out = empty_like(matrix)
++    cdef Sorter sort
++    cdef base.idxint ptr
++    cdef size_t row, diff, size=0
++    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
++    for row in range(matrix.shape[0]):
++        diff = matrix.row_index[row + 1] - matrix.row_index[row]
++        size = diff if diff > size else size
++    sort = Sorter(size)
++    for row in range(matrix.shape[0]):
++        ptr = matrix.row_index[row]
++        diff = matrix.row_index[row + 1] - ptr
++        sort.copy(out.data + ptr, out.col_index + ptr,
++                  matrix.data + ptr, matrix.col_index + ptr,
++                  diff)
++    return out
++
++
++cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
++    """
++    Allocate an empty CSR matrix of the given shape, with space for `size`
++    elements in the `data` and `col_index` arrays.
++
++    This does not initialise any of the memory returned, but sets the last
++    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
++    """
++    if size < 0:
++        raise ValueError("size must be a positive integer.")
++    # Python doesn't like allocating nothing.
++    if size == 0:
++        size += 1
++    cdef CSR out = CSR.__new__(CSR)
++    cdef base.idxint row_size = rows + 1
++    out.shape = (rows, cols)
++    out.size = size
++    out.data =\
++        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
++    out.col_index =\
++        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
++    out.row_index =\
++        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
++    # Set the number of non-zero elements to 0.
++    out.row_index[rows] = 0
++    return out
++
++
++cpdef CSR empty_like(CSR other):
++    return empty(other.shape[0], other.shape[1], nnz(other))
++
++
++cpdef CSR zeros(base.idxint rows, base.idxint cols):
++    """
++    Allocate the zero matrix with a given shape.  There will not be any room in
++    the `data` and `col_index` buffers to add new elements.
++    """
++    # We always allocate matrices with at least one element to ensure that we
++    # actually _are_ asking for memory (Python doesn't like allocating nothing)
++    cdef CSR out = empty(rows, cols, 1)
++    out.data[0] = out.col_index[0] = 0
++    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
++    return out
++
++
++cpdef CSR identity(base.idxint dimension, double complex scale=1):
++    """
++    Return a square matrix of the specified dimension, with a constant along
++    the diagonal.  By default this will be the identity matrix, but if `scale`
++    is passed, then the result will be `scale` times the identity.
++    """
++    cdef CSR out = empty(dimension, dimension, dimension)
++    cdef base.idxint i
++    for i in range(dimension):
++        out.data[i] = scale
++        out.col_index[i] = i
++        out.row_index[i] = i
++    out.row_index[dimension] = dimension
++    return out
++
++cpdef CSR from_dense(Dense matrix):
++    # Assume worst-case scenario for non-zero.
++    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
++                         matrix.shape[0]*matrix.shape[1])
++    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
++    row_stride = 1 if matrix.fortran else matrix.shape[1]
++    col_stride = matrix.shape[0] if matrix.fortran else 1
++    out.row_index[0] = 0
++    for row in range(matrix.shape[0]):
++        ptr_in = row_stride * row
++        for col in range(matrix.shape[1]):
++            if matrix.data[ptr_in] != 0:
++                out.data[ptr_out] = matrix.data[ptr_in]
++                out.col_index[ptr_out] = col
++                ptr_out += 1
++            ptr_in += col_stride
++        out.row_index[row + 1] = ptr_out
++    return out
++
++cdef CSR from_coo_pointers(
++    base.idxint *rows, base.idxint *cols, double complex *data,
++    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
++):
++    # Note that COO pointers may not be sorted in row-major order, and that
++    # they may contain duplicate entries which should be implicitly summed.
++    cdef Accumulator acc = acc_alloc(n_cols)
++    cdef CSR out = empty(n_rows, n_cols, nnz)
++    cdef double complex *data_tmp
++    cdef base.idxint *cols_tmp
++    cdef base.idxint row
++    cdef size_t ptr_in, ptr_out, ptr_prev
++    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
++    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
++    if data_tmp == NULL or cols_tmp == NULL:
++        raise MemoryError
++    with nogil:
++        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
++        for ptr_in in range(nnz):
++            out.row_index[rows[ptr_in] + 1] += 1
++        for ptr_out in range(n_rows):
++            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
++        # out.row_index is currently in the normal output form, but we're
++        # temporarily going to modify it to keep track of how many values we've
++        # placed in each row as we iterate through.  At every state,
++        # out.row_index[row] will contain a pointer to the next location that
++        # an element should be placed in this row.
++        for ptr_in in range(nnz):
++            row = rows[ptr_in]
++            ptr_out = out.row_index[row]
++            cols_tmp[ptr_out] = cols[ptr_in]
++            data_tmp[ptr_out] = data[ptr_in]
++            out.row_index[row] += 1
++        # Apply the scatter/gather pattern to find the actual number of
++        # non-zero elements we're writing into each row (since there's a sum,
++        # there may be some zeros of duplicates).  Remember we also need to
++        # shift the row_index array back to what it was before as well.
++        ptr_out = 0
++        ptr_prev = 0
++        for row in range(n_rows):
++            for ptr_in in range(ptr_prev, out.row_index[row]):
++                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
++            ptr_prev = out.row_index[row]
++            out.row_index[row] = ptr_out
++            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
++            acc_reset(&acc)
++        out.row_index[n_rows] = ptr_out
++    mem.PyMem_Free(data_tmp)
++    mem.PyMem_Free(cols_tmp)
++    acc_free(&acc)
++    return out
++
++
++cdef inline base.idxint _diagonal_length(
++    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
++) nogil:
++    if offset > 0:
++        return n_rows if offset <= n_cols - n_rows else n_cols - offset
++    return n_cols if offset > n_cols - n_rows else n_rows + offset
++
++cdef CSR diag(
++    double complex[:] diagonal, base.idxint offset,
++    base.idxint n_rows, base.idxint n_cols,
++):
++    """
++    Construct a CSR matrix with a single non-zero diagonal.
++
++    Parameters
++    ----------
++    diagonal : indexable of double complex
++        The entries (including zeros) that should be placed on the diagonal in
++        the output matrix.  Each entry must have enough entries in it to fill
++        the relevant diagonal.
++
++    offsets : idxint
++        The index of the diagonals.  An offset of 0 is the main diagonal,
++        positive values are above the main diagonal and negative ones are below
++        the main diagonal.
++
++    n_rows, n_cols : idxint
++        The shape of the output.  The result does not need to be square, but
++        the diagonal must be of the correct length to fit in.
++    """
++    if n_rows < 0 or n_cols < 0:
++        raise ValueError("shape must be positive")
++    cdef base.idxint nnz = len(diagonal)
++    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
++    if nnz != n_diag:
++        raise ValueError("incorrect number of diagonal elements")
++    cdef CSR out = empty(n_rows, n_cols, nnz)
++    cdef base.idxint start_row = 0 if offset >= 0 else -offset
++    cdef base.idxint col = 0 if offset <= 0 else offset
++    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
++    nnz = 0
++    for row in range(start_row + 1, start_row + n_diag + 1):
++        out.col_index[nnz] = col
++        out.data[nnz] = diagonal[nnz]
++        col += 1
++        nnz += 1
++        out.row_index[row] = nnz
++    for row in range(start_row + n_diag + 1, n_rows + 1):
++        out.row_index[row] = nnz
++    return out
++
++cdef CSR diags_(
++    list diagonals, base.idxint[:] offsets,
++    base.idxint n_rows, base.idxint n_cols,
++):
++    """
++    Construct a CSR matrix from a list of diagonals and their offsets.  The
++    offsets are assumed to be in sorted order.  This is the C-only interface to
++    csr.diags, and inputs are not sanity checked (use the Python interface for
++    that).
++
++    Parameters
++    ----------
++    diagonals : list of indexable of double complex
++        The entries (including zeros) that should be placed on the diagonals in
++        the output matrix.  Each entry must have enough entries in it to fill
++        the relevant diagonal (not checked).
++
++    offsets : idxint[:]
++        The indices of the diagonals.  These should be sorted and without
++        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
++        An offset of 0 is the main diagonal, positive values are above the main
++        diagonal and negative ones are below the main diagonal.
++
++    n_rows, n_cols : idxint
++        The shape of the output.  The result does not need to be square, but
++        the diagonals must be of the correct length to fit in.
++    """
++    cdef size_t n_diagonals = len(diagonals)
++    if n_diagonals == 0:
++        return zeros(n_rows, n_cols)
++    cdef base.idxint k, row, start_row, offset, nnz=0,
++    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
++    cdef double complex value
++    for k in range(n_diagonals):
++        offset = offsets[k]
++        if offset >= 0 and min_k > k:
++            min_k = k
++        nnz += _diagonal_length(offset, n_rows, n_cols)
++    cdef CSR out = empty(n_rows, n_cols, nnz)
++    nnz = 0
++    out.row_index[0] = 0
++    for row in range(n_rows):
++        if min_k > 0:
++            offset = offsets[min_k - 1]
++            start_row = 0 if offset >= 0 else -offset
++            if start_row == row:
++                min_k -= 1
++        if max_k > 0:
++            offset = offsets[max_k - 1]
++            start_row = 0 if offset >= 0 else -offset
++            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
++                max_k -= 1
++        for k in range(min_k, max_k):
++            offset = offsets[k]
++            value = diagonals[k][row if offset >= 0 else row + offset]
++            if value == 0:
++                continue
++            out.data[nnz] = value
++            out.col_index[nnz] = row + offset
++            nnz += 1
++        out.row_index[row + 1] = nnz
++    return out
++
++@cython.wraparound(True)
++def diags(diagonals, offsets=None, shape=None):
++    """
++    Construct a CSR matrix from diagonals and their offsets.  Using this
++    function in single-argument form produces a square matrix with the given
++    values on the main diagonal.
++
++    With lists of diagonals and offsets, the matrix will be the smallest
++    possible square matrix if shape is not given, but in all cases the
++    diagonals must fit exactly with no extra or missing elements.  Duplicated
++    diagonals will be summed together in the output.
++
++    Parameters
++    ----------
++    diagonals : sequence of array_like of complex or array_like of complex
++        The entries (including zeros) that should be placed on the diagonals in
++        the output matrix.  Each entry must have enough entries in it to fill
++        the relevant diagonal and no more.
++
++    offsets : sequence of integer or integer, optional
++        The indices of the diagonals.  `offsets[i]` is the location of the
++        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
++        values are above the main diagonal and negative ones are below the main
++        diagonal.
++
++    shape : tuple, optional
++        The shape of the output as (``rows``, ``columns``).  The result does
++        not need to be square, but the diagonals must be of the correct length
++        to fit in exactly.
++    """
++    cdef base.idxint n_rows, n_cols, offset
++    try:
++        diagonals = list(diagonals)
++        if diagonals and np.isscalar(diagonals[0]):
++            # Catch the case where we're being called as (for example)
++            #   diags([1, 2, 3], 0)
++            # with a single diagonal and offset.
++            diagonals = [diagonals]
++    except TypeError:
++        raise TypeError("diagonals must be a list of arrays of complex") from None
++    if offsets is None:
++        if len(diagonals) == 0:
++            offsets = []
++        elif len(diagonals) == 1:
++            offsets = [0]
++        else:
++            raise TypeError("offsets must be supplied if passing more than one diagonal")
++    offsets = np.atleast_1d(offsets)
++    if offsets.ndim > 1:
++        raise ValueError("offsets must be a 1D array of integers")
++    if len(diagonals) != len(offsets):
++        raise ValueError("number of diagonals does not match number of offsets")
++    if len(diagonals) == 0:
++        if shape is None:
++            raise ValueError("cannot construct matrix with no diagonals without a shape")
++        else:
++            n_rows, n_cols = shape
++        return zeros(n_rows, n_cols)
++    order = np.argsort(offsets)
++    diagonals_ = []
++    offsets_ = []
++    prev, cur = None, None
++    for i in order:
++        cur = offsets[i]
++        if cur == prev:
++            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
++        else:
++            offsets_.append(cur)
++            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
++        prev = cur
++    if shape is None:
++        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
++    else:
++        try:
++            n_rows, n_cols = shape
++        except (TypeError, ValueError):
++            raise TypeError("shape must be a 2-tuple of positive integers")
++        if n_rows < 0 or n_cols < 0:
++            raise ValueError("shape must be a 2-tuple of positive integers")
++    for i in range(len(diagonals_)):
++        offset = offsets_[i]
++        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
++            raise ValueError("given diagonals do not have the correct lengths")
++    if n_rows == 0 and n_cols == 0:
++        raise ValueError("can't produce a 0x0 matrix")
++    if len(offsets) == 1:
++        # Fast path for a single diagonal.
++        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
++    return diags_(
++        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
++    )
++
++
++cpdef CSR _from_csr_blocks(
++    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
++    base.idxint n_blocks, base.idxint block_size
++):
++    """
++    Construct a CSR from non-overlapping blocks.
++
++    Each operator in ``block_ops`` should be a square CSR operator with
++    shape ``(block_size, block_size)``. The output operator consists of
++    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
++    ``(n_blocks * block_size, n_blocks * block_size)``.
++
++    None of the operators should overlap (i.e. the list of block row and
++    column pairs should be unique).
++
++    Parameters
++    ----------
++    block_rows : sequence of base.idxint integers
++        The block row for each operator. The block row should be in
++        ``range(0, n_blocks)``.
++
++    block_cols : sequence of base.idxint integers
++        The block column for each operator. The block column should be in
++        ``range(0, n_blocks)``.
++
++    block_ops : sequence of CSR matrixes
++        The operators corresponding to the rows and columns in ``block_rows``
++        and ``block_cols``.
++
++    n_blocks : base.idxint
++        Number of blocks. The shape of the final matrix is
++        (n_blocks * block, n_blocks * block).
++
++    block_size : base.idxint
++        Size of each block. The shape of matrices in ``block_ops`` is
++        ``(block_size, block_size)``.
++    """
++    cdef CSR op
++    cdef base.idxint shape = n_blocks * block_size
++    cdef base.idxint nnz_ = 0
++    cdef base.idxint n_ops = len(block_ops)
++    cdef base.idxint i, j
++    cdef base.idxint row_idx, col_idx
++
++    # check arrays are the same length
++    if len(block_rows) != n_ops or len(block_cols) != n_ops:
++        raise ValueError(
++            "The arrays block_rows, block_cols and block_ops should have"
++            " the same length."
++        )
++
++    if n_ops == 0:
++        return zeros(shape, shape)
++
++    # check op shapes and calculate nnz
++    for op in block_ops:
++        nnz_ += nnz(op)
++        if op.shape[0] != block_size or op.shape[1] != block_size:
++            raise ValueError(
++                "Block operators (block_ops) do not have the correct shape."
++            )
++
++    # check ops are ordered by (row, column)
++    row_idx = block_rows[0]
++    col_idx = block_cols[0]
++    for i in range(1, n_ops):
++        if (
++            block_rows[i] < row_idx or
++            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
++        ):
++            raise ValueError(
++                "The arrays block_rows and block_cols must be sorted"
++                " by (row, column)."
++            )
++        row_idx = block_rows[i]
++        col_idx = block_cols[i]
++
++    if nnz_ == 0:
++        return zeros(shape, shape)
++
++    cdef CSR out = empty(shape, shape, nnz_)
++    cdef base.idxint op_idx = 0
++    cdef base.idxint prev_op_idx = 0
++    cdef base.idxint end = 0
++    cdef base.idxint row_pos, col_pos
++    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
++
++    out.row_index[0] = 0
++
++    for row_idx in range(n_blocks):
++        prev_op_idx = op_idx
++        while op_idx < n_ops:
++            if block_rows[op_idx] != row_idx:
++                break
++            op_idx += 1
++
++        row_pos = row_idx * block_size
++        for op_row in range(block_size):
++            for i in range(prev_op_idx, op_idx):
++                op = block_ops[i]
++                if nnz(op) == 0:
++                    # empty CSR matrices have uninitialized row_index entries.
++                    # it's unclear whether users should ever see such matrixes
++                    # but we support them here anyway.
++                    continue
++                col_idx = block_cols[i]
++                col_pos = col_idx * block_size
++                op_row_start = op.row_index[op_row]
++                op_row_end = op.row_index[op_row + 1]
++                op_row_len = op_row_end - op_row_start
++                for j in range(op_row_len):
++                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
++                    out.data[end + j] = op.data[op_row_start + j]
++                end += op_row_len
++            out.row_index[row_pos + op_row + 1] = end
++
++    return out
+diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
+index 3c3dad93..354bf510 100644
+--- a/qutip/core/data/dense.pxd
++++ b/qutip/core/data/dense.pxd
+@@ -1,30 +1,30 @@
+-#cython: language_level=3
+-
+-cimport numpy as cnp
+-
+-from . cimport base
+-from .csr cimport CSR
+-
+-cdef class Dense(base.Data):
+-    cdef double complex *data
+-    cdef bint fortran
+-    cdef object _np
+-    cdef bint _deallocate
+-    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
+-    cpdef Dense reorder(Dense self, int fortran=*)
+-    cpdef Dense copy(Dense self)
+-    cpdef object as_ndarray(Dense self)
+-    cpdef object to_array(Dense self)
+-    cpdef double complex trace(Dense self)
+-    cpdef Dense adjoint(Dense self)
+-    cpdef Dense conj(Dense self)
+-    cpdef Dense transpose(Dense self)
+-
+-cpdef Dense fast_from_numpy(object array)
+-cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
+-cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
+-cpdef Dense empty_like(Dense other, int fortran=*)
+-cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
+-cpdef Dense identity(base.idxint dimension, double complex scale=*,
+-                     bint fortran=*)
+-cpdef Dense from_csr(CSR matrix, bint fortran=*)
++#cython: language_level=3
++
++cimport numpy as cnp
++
++from . cimport base
++from .csr cimport CSR
++
++cdef class Dense(base.Data):
++    cdef double complex *data
++    cdef bint fortran
++    cdef object _np
++    cdef bint _deallocate
++    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
++    cpdef Dense reorder(Dense self, int fortran=*)
++    cpdef Dense copy(Dense self)
++    cpdef object as_ndarray(Dense self)
++    cpdef object to_array(Dense self)
++    cpdef double complex trace(Dense self)
++    cpdef Dense adjoint(Dense self)
++    cpdef Dense conj(Dense self)
++    cpdef Dense transpose(Dense self)
++
++cpdef Dense fast_from_numpy(object array)
++cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
++cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
++cpdef Dense empty_like(Dense other, int fortran=*)
++cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
++cpdef Dense identity(base.idxint dimension, double complex scale=*,
++                     bint fortran=*)
++cpdef Dense from_csr(CSR matrix, bint fortran=*)
+diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
+index 38c32f5b..f16578b4 100644
+--- a/qutip/core/data/dense.pyx
++++ b/qutip/core/data/dense.pyx
+@@ -1,409 +1,409 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.string cimport memcpy
+-cimport cython
+-
+-import numbers
+-
+-import numpy as np
+-cimport numpy as cnp
+-from scipy.linalg cimport cython_blas as blas
+-
+-from .base import EfficiencyWarning
+-from qutip.core.data cimport base, CSR
+-from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
+-from qutip.core.data.trace cimport trace_dense
+-
+-cnp.import_array()
+-
+-cdef int _ONE = 1
+-
+-cdef extern from *:
+-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+-    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
+-    void *PyDataMem_NEW(size_t size)
+-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
+-    void PyDataMem_FREE(void *ptr)
+-
+-
+-# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
+-# to avoid naming clashes with other type modules.
+-__all__ = [
+-    'Dense', 'OrderEfficiencyWarning',
+-]
+-
+-
+-class OrderEfficiencyWarning(EfficiencyWarning):
+-    pass
+-
+-
+-cdef class Dense(base.Data):
+-    def __init__(self, data, shape=None, copy=True):
+-        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
+-        # Ensure that the array is contiguous.
+-        # Non contiguous array with copy=False would otherwise slip through
+-        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
+-                cnp.PyArray_IS_F_CONTIGUOUS(base)):
+-            base = base.copy()
+-        if shape is None:
+-            shape = base.shape
+-            if len(shape) == 0:
+-                shape = (1, 1)
+-            # Promote to a ket by default if passed 1D data.
+-            if len(shape) == 1:
+-                shape = (shape[0], 1)
+-        if not (
+-            len(shape) == 2
+-            and isinstance(shape[0], numbers.Integral)
+-            and isinstance(shape[1], numbers.Integral)
+-            and shape[0] > 0
+-            and shape[1] > 0
+-        ):
+-            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
+-        if shape[0] * shape[1] != base.size:
+-            raise ValueError("".join([
+-                "invalid shape ",
+-                str(shape),
+-                " for input data with size ",
+-                str(base.size)
+-            ]))
+-        self._np = base.reshape(shape, order='A')
+-        self._deallocate = False
+-        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
+-        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
+-        self.shape = (shape[0], shape[1])
+-
+-    def __reduce__(self):
+-        return (fast_from_numpy, (self.as_ndarray(),))
+-
+-    def __repr__(self):
+-        return "".join([
+-            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
+-        ])
+-
+-    def __str__(self):
+-        return self.__repr__()
+-
+-    cpdef Dense reorder(self, int fortran=-1):
+-        cdef bint fortran_
+-        if fortran < 0:
+-            fortran_ = not self.fortran
+-        else:
+-            fortran_ = fortran
+-        if bool(fortran_) == bool(self.fortran):
+-            return self.copy()
+-        cdef Dense out = empty_like(self, fortran_)
+-        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
+-        stride = self.shape[1] if self.fortran else self.shape[0]
+-        splits = self.shape[0] if self.fortran else self.shape[1]
+-        for idx_out_start in range(stride):
+-            idx_out = idx_out_start
+-            for _ in range(splits):
+-                out.data[idx_out] = self.data[idx_self]
+-                idx_self += 1
+-                idx_out += stride
+-        return out
+-
+-    cpdef Dense copy(self):
+-        """
+-        Return a complete (deep) copy of this object.
+-
+-        If the type currently has a numpy backing, such as that produced by
+-        `as_ndarray`, this will not be copied.  The backing is a view onto our
+-        data, and a straight copy of this view would be incorrect.  We do not
+-        create a new view at copy time, since the user may only access this
+-        through a creation method, and creating it ahead of time would incur an
+-        unnecessary speed penalty for users who do not need it (including
+-        low-level C code).
+-        """
+-        cdef Dense out = Dense.__new__(Dense)
+-        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
+-        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+-        memcpy(ptr, self.data, size)
+-        out.shape = self.shape
+-        out.data = ptr
+-        out.fortran = self.fortran
+-        out._deallocate = True
+-        return out
+-
+-    cdef void _fix_flags(self, object array, bint make_owner=False):
+-        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
+-        cdef int disable = 0
+-        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
+-        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
+-        # Not necessary when creating a new array because this will already
+-        # have been done, but needed for as_ndarray() if we have been mutated.
+-        dims[0] = self.shape[0]
+-        dims[1] = self.shape[1]
+-        if self.shape[0] == 1 or self.shape[1] == 1:
+-            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
+-            strides[0] = self.shape[1] * sizeof(double complex)
+-            strides[1] = sizeof(double complex)
+-        elif self.fortran:
+-            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
+-            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
+-            strides[0] = sizeof(double complex)
+-            strides[1] = self.shape[0] * sizeof(double complex)
+-        else:
+-            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
+-            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
+-            strides[0] = self.shape[1] * sizeof(double complex)
+-            strides[1] = sizeof(double complex)
+-        PyArray_ENABLEFLAGS(array, enable)
+-        PyArray_CLEARFLAGS(array, disable)
+-
+-    cpdef object to_array(self):
+-        """
+-        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
+-        be Fortran or C-ordered, but will be contiguous in one of the
+-        dimensions.  This is not a view onto the data, and changes to new array
+-        will not affect the original data structure.
+-        """
+-        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
+-        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+-        memcpy(ptr, self.data, size)
+-        cdef object out =\
+-            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
+-                                          cnp.NPY_COMPLEX128, ptr)
+-        self._fix_flags(out, make_owner=True)
+-        return out
+-
+-    cpdef object as_ndarray(self):
+-        """
+-        Get a view onto this object as a `numpy.ndarray`.  The underlying data
+-        structure is exposed, such that modifications to the array will modify
+-        this object too.
+-
+-        The array may be uninitialised, depending on how the Dense type was
+-        created.  The output will be contiguous and of dtype 'complex128', but
+-        may be C- or Fortran-ordered.
+-        """
+-        if self._np is not None:
+-            # We have to do this every time in case someone has changed our
+-            # ordering or shape inplace.
+-            self._fix_flags(self._np, make_owner=False)
+-            return self._np
+-        self._np =\
+-            cnp.PyArray_SimpleNewFromData(
+-                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
+-            )
+-        self._fix_flags(self._np, make_owner=self._deallocate)
+-        self._deallocate = False
+-        return self._np
+-
+-    cpdef double complex trace(self):
+-        return trace_dense(self)
+-
+-    cpdef Dense adjoint(self):
+-        return adjoint_dense(self)
+-
+-    cpdef Dense conj(self):
+-        return conj_dense(self)
+-
+-    cpdef Dense transpose(self):
+-        return transpose_dense(self)
+-
+-    def __dealloc__(self):
+-        if self._deallocate and self.data != NULL:
+-            PyDataMem_FREE(self.data)
+-
+-
+-cpdef Dense fast_from_numpy(object array):
+-    """
+-    Fast path construction from numpy ndarray.  This does _no_ type checking on
+-    the input, and should consequently be considered very unsafe.  This is
+-    primarily for use in the unpickling operation.
+-    """
+-    cdef Dense out = Dense.__new__(Dense)
+-    if array.ndim == 1:
+-        out.shape = (array.shape[0], 1)
+-        array = array[:, None]
+-    else:
+-        out.shape = (array.shape[0], array.shape[1])
+-    out._deallocate = False
+-    out._np = array
+-    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
+-    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
+-    return out
+-
+-cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
+-    cdef Dense out = Dense.__new__(Dense)
+-    out.data = data
+-    out._deallocate = False
+-    out.fortran = fortran or cols == 1 or rows == 1
+-    out.shape = (rows, cols)
+-    return out
+-
+-
+-cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
+-    """
+-    Return a new Dense type of the given shape, with the data allocated but
+-    uninitialised.
+-    """
+-    cdef Dense out = Dense.__new__(Dense)
+-    out.shape = (rows, cols)
+-    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
+-    out._deallocate = True
+-    out.fortran = fortran
+-    return out
+-
+-
+-cpdef Dense empty_like(Dense other, int fortran=-1):
+-    cdef bint fortran_
+-    if fortran < 0:
+-        fortran_ = other.fortran
+-    else:
+-        fortran_ = fortran
+-    return empty(other.shape[0], other.shape[1], fortran=fortran_)
+-
+-
+-cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
+-    """Return the zero matrix with the given shape."""
+-    cdef Dense out = Dense.__new__(Dense)
+-    out.shape = (rows, cols)
+-    out.data =\
+-        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
+-    out.fortran = fortran
+-    out._deallocate = True
+-    return out
+-
+-
+-cpdef Dense identity(base.idxint dimension, double complex scale=1,
+-                     bint fortran=True):
+-    """
+-    Return a square matrix of the specified dimension, with a constant along
+-    the diagonal.  By default this will be the identity matrix, but if `scale`
+-    is passed, then the result will be `scale` times the identity.
+-    """
+-    cdef size_t row
+-    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
+-    for row in range(dimension):
+-        out.data[row*dimension + row] = scale
+-    return out
+-
+-
+-cpdef Dense from_csr(CSR matrix, bint fortran=False):
+-    cdef Dense out = Dense.__new__(Dense)
+-    out.shape = matrix.shape
+-    out.data = (
+-        <double complex *>
+-        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
+-    )
+-    out.fortran = fortran
+-    out._deallocate = True
+-    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
+-    row_stride = 1 if fortran else out.shape[1]
+-    col_stride = out.shape[0] if fortran else 1
+-    ptr_out = 0
+-    for row in range(out.shape[0]):
+-        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
+-        ptr_out += row_stride
+-    return out
+-
+-
+-cdef inline base.idxint _diagonal_length(
+-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+-) nogil:
+-    if offset > 0:
+-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+-    return n_cols if offset > n_cols - n_rows else n_rows + offset
+-
+-
+-@cython.wraparound(True)
+-def diags(diagonals, offsets=None, shape=None):
+-    """
+-    Construct a matrix from diagonals and their offsets.  Using this
+-    function in single-argument form produces a square matrix with the given
+-    values on the main diagonal.
+-    With lists of diagonals and offsets, the matrix will be the smallest
+-    possible square matrix if shape is not given, but in all cases the
+-    diagonals must fit exactly with no extra or missing elements. Duplicated
+-    diagonals will be summed together in the output.
+-
+-    Parameters
+-    ----------
+-    diagonals : sequence of array_like of complex or array_like of complex
+-        The entries (including zeros) that should be placed on the diagonals in
+-        the output matrix.  Each entry must have enough entries in it to fill
+-        the relevant diagonal and no more.
+-    offsets : sequence of integer or integer, optional
+-        The indices of the diagonals.  `offsets[i]` is the location of the
+-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+-        values are above the main diagonal and negative ones are below the main
+-        diagonal.
+-    shape : tuple, optional
+-        The shape of the output as (``rows``, ``columns``).  The result does
+-        not need to be square, but the diagonals must be of the correct length
+-        to fit in exactly.
+-    """
+-    cdef base.idxint n_rows, n_cols, offset
+-    try:
+-        diagonals = list(diagonals)
+-        if diagonals and np.isscalar(diagonals[0]):
+-            # Catch the case where we're being called as (for example)
+-            #   diags([1, 2, 3], 0)
+-            # with a single diagonal and offset.
+-            diagonals = [diagonals]
+-    except TypeError:
+-        raise TypeError("diagonals must be a list of arrays of complex") from None
+-    if offsets is None:
+-        if len(diagonals) == 0:
+-            offsets = []
+-        elif len(diagonals) == 1:
+-            offsets = [0]
+-        else:
+-            raise TypeError("offsets must be supplied if passing more than one diagonal")
+-    offsets = np.atleast_1d(offsets)
+-    if offsets.ndim > 1:
+-        raise ValueError("offsets must be a 1D array of integers")
+-    if len(diagonals) != len(offsets):
+-        raise ValueError("number of diagonals does not match number of offsets")
+-    if len(diagonals) == 0:
+-        if shape is None:
+-            raise ValueError("cannot construct matrix with no diagonals without a shape")
+-        else:
+-            n_rows, n_cols = shape
+-        return zeros(n_rows, n_cols)
+-    order = np.argsort(offsets)
+-    diagonals_ = []
+-    offsets_ = []
+-    prev, cur = None, None
+-    for i in order:
+-        cur = offsets[i]
+-        if cur == prev:
+-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+-        else:
+-            offsets_.append(cur)
+-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+-        prev = cur
+-    if shape is None:
+-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+-    else:
+-        try:
+-            n_rows, n_cols = shape
+-        except (TypeError, ValueError):
+-            raise TypeError("shape must be a 2-tuple of positive integers")
+-        if n_rows < 0 or n_cols < 0:
+-            raise ValueError("shape must be a 2-tuple of positive integers")
+-    for i in range(len(diagonals_)):
+-        offset = offsets_[i]
+-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+-            raise ValueError("given diagonals do not have the correct lengths")
+-    if n_rows == 0 and n_cols == 0:
+-        raise ValueError("can't produce a 0x0 matrix")
+-
+-    out = zeros(n_rows, n_cols, fortran=True)
+-
+-    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
+-
+-    for diag_idx in range(n_diagonals):
+-        offset = offsets_[diag_idx]
+-        if offset <= 0:
+-            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
+-                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
+-        else:
+-            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
+-                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
+-    return out
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.string cimport memcpy
++cimport cython
++
++import numbers
++
++import numpy as np
++cimport numpy as cnp
++from scipy.linalg cimport cython_blas as blas
++
++from .base import EfficiencyWarning
++from qutip.core.data cimport base, CSR
++from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
++from qutip.core.data.trace cimport trace_dense
++
++cnp.import_array()
++
++cdef int _ONE = 1
++
++cdef extern from *:
++    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
++    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
++    void *PyDataMem_NEW(size_t size)
++    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
++    void PyDataMem_FREE(void *ptr)
++
++
++# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
++# to avoid naming clashes with other type modules.
++__all__ = [
++    'Dense', 'OrderEfficiencyWarning',
++]
++
++
++class OrderEfficiencyWarning(EfficiencyWarning):
++    pass
++
++
++cdef class Dense(base.Data):
++    def __init__(self, data, shape=None, copy=True):
++        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
++        # Ensure that the array is contiguous.
++        # Non contiguous array with copy=False would otherwise slip through
++        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
++                cnp.PyArray_IS_F_CONTIGUOUS(base)):
++            base = base.copy()
++        if shape is None:
++            shape = base.shape
++            if len(shape) == 0:
++                shape = (1, 1)
++            # Promote to a ket by default if passed 1D data.
++            if len(shape) == 1:
++                shape = (shape[0], 1)
++        if not (
++            len(shape) == 2
++            and isinstance(shape[0], numbers.Integral)
++            and isinstance(shape[1], numbers.Integral)
++            and shape[0] > 0
++            and shape[1] > 0
++        ):
++            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
++        if shape[0] * shape[1] != base.size:
++            raise ValueError("".join([
++                "invalid shape ",
++                str(shape),
++                " for input data with size ",
++                str(base.size)
++            ]))
++        self._np = base.reshape(shape, order='A')
++        self._deallocate = False
++        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
++        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
++        self.shape = (shape[0], shape[1])
++
++    def __reduce__(self):
++        return (fast_from_numpy, (self.as_ndarray(),))
++
++    def __repr__(self):
++        return "".join([
++            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
++        ])
++
++    def __str__(self):
++        return self.__repr__()
++
++    cpdef Dense reorder(self, int fortran=-1):
++        cdef bint fortran_
++        if fortran < 0:
++            fortran_ = not self.fortran
++        else:
++            fortran_ = fortran
++        if bool(fortran_) == bool(self.fortran):
++            return self.copy()
++        cdef Dense out = empty_like(self, fortran_)
++        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
++        stride = self.shape[1] if self.fortran else self.shape[0]
++        splits = self.shape[0] if self.fortran else self.shape[1]
++        for idx_out_start in range(stride):
++            idx_out = idx_out_start
++            for _ in range(splits):
++                out.data[idx_out] = self.data[idx_self]
++                idx_self += 1
++                idx_out += stride
++        return out
++
++    cpdef Dense copy(self):
++        """
++        Return a complete (deep) copy of this object.
++
++        If the type currently has a numpy backing, such as that produced by
++        `as_ndarray`, this will not be copied.  The backing is a view onto our
++        data, and a straight copy of this view would be incorrect.  We do not
++        create a new view at copy time, since the user may only access this
++        through a creation method, and creating it ahead of time would incur an
++        unnecessary speed penalty for users who do not need it (including
++        low-level C code).
++        """
++        cdef Dense out = Dense.__new__(Dense)
++        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
++        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
++        memcpy(ptr, self.data, size)
++        out.shape = self.shape
++        out.data = ptr
++        out.fortran = self.fortran
++        out._deallocate = True
++        return out
++
++    cdef void _fix_flags(self, object array, bint make_owner=False):
++        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
++        cdef int disable = 0
++        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
++        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
++        # Not necessary when creating a new array because this will already
++        # have been done, but needed for as_ndarray() if we have been mutated.
++        dims[0] = self.shape[0]
++        dims[1] = self.shape[1]
++        if self.shape[0] == 1 or self.shape[1] == 1:
++            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
++            strides[0] = self.shape[1] * sizeof(double complex)
++            strides[1] = sizeof(double complex)
++        elif self.fortran:
++            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
++            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
++            strides[0] = sizeof(double complex)
++            strides[1] = self.shape[0] * sizeof(double complex)
++        else:
++            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
++            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
++            strides[0] = self.shape[1] * sizeof(double complex)
++            strides[1] = sizeof(double complex)
++        PyArray_ENABLEFLAGS(array, enable)
++        PyArray_CLEARFLAGS(array, disable)
++
++    cpdef object to_array(self):
++        """
++        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
++        be Fortran or C-ordered, but will be contiguous in one of the
++        dimensions.  This is not a view onto the data, and changes to new array
++        will not affect the original data structure.
++        """
++        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
++        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
++        memcpy(ptr, self.data, size)
++        cdef object out =\
++            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
++                                          cnp.NPY_COMPLEX128, ptr)
++        self._fix_flags(out, make_owner=True)
++        return out
++
++    cpdef object as_ndarray(self):
++        """
++        Get a view onto this object as a `numpy.ndarray`.  The underlying data
++        structure is exposed, such that modifications to the array will modify
++        this object too.
++
++        The array may be uninitialised, depending on how the Dense type was
++        created.  The output will be contiguous and of dtype 'complex128', but
++        may be C- or Fortran-ordered.
++        """
++        if self._np is not None:
++            # We have to do this every time in case someone has changed our
++            # ordering or shape inplace.
++            self._fix_flags(self._np, make_owner=False)
++            return self._np
++        self._np =\
++            cnp.PyArray_SimpleNewFromData(
++                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
++            )
++        self._fix_flags(self._np, make_owner=self._deallocate)
++        self._deallocate = False
++        return self._np
++
++    cpdef double complex trace(self):
++        return trace_dense(self)
++
++    cpdef Dense adjoint(self):
++        return adjoint_dense(self)
++
++    cpdef Dense conj(self):
++        return conj_dense(self)
++
++    cpdef Dense transpose(self):
++        return transpose_dense(self)
++
++    def __dealloc__(self):
++        if self._deallocate and self.data != NULL:
++            PyDataMem_FREE(self.data)
++
++
++cpdef Dense fast_from_numpy(object array):
++    """
++    Fast path construction from numpy ndarray.  This does _no_ type checking on
++    the input, and should consequently be considered very unsafe.  This is
++    primarily for use in the unpickling operation.
++    """
++    cdef Dense out = Dense.__new__(Dense)
++    if array.ndim == 1:
++        out.shape = (array.shape[0], 1)
++        array = array[:, None]
++    else:
++        out.shape = (array.shape[0], array.shape[1])
++    out._deallocate = False
++    out._np = array
++    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
++    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
++    return out
++
++cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
++    cdef Dense out = Dense.__new__(Dense)
++    out.data = data
++    out._deallocate = False
++    out.fortran = fortran or cols == 1 or rows == 1
++    out.shape = (rows, cols)
++    return out
++
++
++cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
++    """
++    Return a new Dense type of the given shape, with the data allocated but
++    uninitialised.
++    """
++    cdef Dense out = Dense.__new__(Dense)
++    out.shape = (rows, cols)
++    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
++    out._deallocate = True
++    out.fortran = fortran
++    return out
++
++
++cpdef Dense empty_like(Dense other, int fortran=-1):
++    cdef bint fortran_
++    if fortran < 0:
++        fortran_ = other.fortran
++    else:
++        fortran_ = fortran
++    return empty(other.shape[0], other.shape[1], fortran=fortran_)
++
++
++cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
++    """Return the zero matrix with the given shape."""
++    cdef Dense out = Dense.__new__(Dense)
++    out.shape = (rows, cols)
++    out.data =\
++        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
++    out.fortran = fortran
++    out._deallocate = True
++    return out
++
++
++cpdef Dense identity(base.idxint dimension, double complex scale=1,
++                     bint fortran=True):
++    """
++    Return a square matrix of the specified dimension, with a constant along
++    the diagonal.  By default this will be the identity matrix, but if `scale`
++    is passed, then the result will be `scale` times the identity.
++    """
++    cdef size_t row
++    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
++    for row in range(dimension):
++        out.data[row*dimension + row] = scale
++    return out
++
++
++cpdef Dense from_csr(CSR matrix, bint fortran=False):
++    cdef Dense out = Dense.__new__(Dense)
++    out.shape = matrix.shape
++    out.data = (
++        <double complex *>
++        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
++    )
++    out.fortran = fortran
++    out._deallocate = True
++    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
++    row_stride = 1 if fortran else out.shape[1]
++    col_stride = out.shape[0] if fortran else 1
++    ptr_out = 0
++    for row in range(out.shape[0]):
++        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
++            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
++        ptr_out += row_stride
++    return out
++
++
++cdef inline base.idxint _diagonal_length(
++    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
++) nogil:
++    if offset > 0:
++        return n_rows if offset <= n_cols - n_rows else n_cols - offset
++    return n_cols if offset > n_cols - n_rows else n_rows + offset
++
++
++@cython.wraparound(True)
++def diags(diagonals, offsets=None, shape=None):
++    """
++    Construct a matrix from diagonals and their offsets.  Using this
++    function in single-argument form produces a square matrix with the given
++    values on the main diagonal.
++    With lists of diagonals and offsets, the matrix will be the smallest
++    possible square matrix if shape is not given, but in all cases the
++    diagonals must fit exactly with no extra or missing elements. Duplicated
++    diagonals will be summed together in the output.
++
++    Parameters
++    ----------
++    diagonals : sequence of array_like of complex or array_like of complex
++        The entries (including zeros) that should be placed on the diagonals in
++        the output matrix.  Each entry must have enough entries in it to fill
++        the relevant diagonal and no more.
++    offsets : sequence of integer or integer, optional
++        The indices of the diagonals.  `offsets[i]` is the location of the
++        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
++        values are above the main diagonal and negative ones are below the main
++        diagonal.
++    shape : tuple, optional
++        The shape of the output as (``rows``, ``columns``).  The result does
++        not need to be square, but the diagonals must be of the correct length
++        to fit in exactly.
++    """
++    cdef base.idxint n_rows, n_cols, offset
++    try:
++        diagonals = list(diagonals)
++        if diagonals and np.isscalar(diagonals[0]):
++            # Catch the case where we're being called as (for example)
++            #   diags([1, 2, 3], 0)
++            # with a single diagonal and offset.
++            diagonals = [diagonals]
++    except TypeError:
++        raise TypeError("diagonals must be a list of arrays of complex") from None
++    if offsets is None:
++        if len(diagonals) == 0:
++            offsets = []
++        elif len(diagonals) == 1:
++            offsets = [0]
++        else:
++            raise TypeError("offsets must be supplied if passing more than one diagonal")
++    offsets = np.atleast_1d(offsets)
++    if offsets.ndim > 1:
++        raise ValueError("offsets must be a 1D array of integers")
++    if len(diagonals) != len(offsets):
++        raise ValueError("number of diagonals does not match number of offsets")
++    if len(diagonals) == 0:
++        if shape is None:
++            raise ValueError("cannot construct matrix with no diagonals without a shape")
++        else:
++            n_rows, n_cols = shape
++        return zeros(n_rows, n_cols)
++    order = np.argsort(offsets)
++    diagonals_ = []
++    offsets_ = []
++    prev, cur = None, None
++    for i in order:
++        cur = offsets[i]
++        if cur == prev:
++            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
++        else:
++            offsets_.append(cur)
++            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
++        prev = cur
++    if shape is None:
++        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
++    else:
++        try:
++            n_rows, n_cols = shape
++        except (TypeError, ValueError):
++            raise TypeError("shape must be a 2-tuple of positive integers")
++        if n_rows < 0 or n_cols < 0:
++            raise ValueError("shape must be a 2-tuple of positive integers")
++    for i in range(len(diagonals_)):
++        offset = offsets_[i]
++        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
++            raise ValueError("given diagonals do not have the correct lengths")
++    if n_rows == 0 and n_cols == 0:
++        raise ValueError("can't produce a 0x0 matrix")
++
++    out = zeros(n_rows, n_cols, fortran=True)
++
++    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
++
++    for diag_idx in range(n_diagonals):
++        offset = offsets_[diag_idx]
++        if offset <= 0:
++            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
++                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
++        else:
++            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
++                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
++    return out
+diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
+index e8abebd7..276477b4 100644
+--- a/qutip/core/data/dispatch.pyx
++++ b/qutip/core/data/dispatch.pyx
+@@ -1,583 +1,583 @@
+-#cython: language_level=3
+-
+-import functools
+-import inspect
+-import itertools
+-import warnings
+-
+-from .convert import to as _to
+-
+-cimport cython
+-from libc cimport math
+-from libcpp cimport bool
+-
+-__all__ = ['Dispatcher']
+-
+-cdef class _bind:
+-    """
+-    Cythonised implementation of inspect.Signature.bind, supporting faster
+-    binding and handling of default arguments.  On construction, the signature
+-    of the base function is extracted, and all parameters are parsed into
+-    positional or keyword slots, using positional wherever possible, and their
+-    defaults are stored.
+-    """
+-    # Instance of inpsect.Signature representing the function.
+-    cdef object signature
+-    cdef object inputs
+-    # Mapping of (str: int), where str is the name of any argument which may be
+-    # specified by a keyword, and int is its location in `self._pos` if
+-    # available, or -1 if it is keyword-only.
+-    cdef dict _locations
+-    # Default values (or inspect.Parameter.empty) for every parameter which
+-    # may be passed as a positional argument.
+-    cdef list _pos
+-    # For each dispatcher input which can be given as a positional argument,
+-    # these two lists hold the index of the input in the given tuple of input
+-    # names and the corresponding index into the positional arguments after
+-    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
+-    # effectively the same mapping as _kw_inputs (but for positional
+-    # arguments), but we use two lists rather than a dictionary for speed.
+-    cdef list _pos_inputs_input, _pos_inputs_pos
+-    # Default values (or inspect.Parameter.empty) for every parameter which
+-    # _must_ be passed as a keyword argument.
+-    cdef dict _kw
+-    # Mapping of (name, index into the input tuple) for each input which must
+-    # be specified as a keyword argument
+-    cdef list _kw_inputs
+-    # Names of the keyword arguments which have default values.
+-    cdef set _default_kw_names
+-    # Respectively, numbers of positional parameters, keyword-only parameters
+-    # and dispatcher inputs.
+-    cdef Py_ssize_t n_args, n_kwargs, n_inputs
+-    # Respectively, numbers of inputs which are positional and keyword-only.
+-    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
+-    # Respectively, numbers of positional arguments without a default, and
+-    # number of keyword-only arguments which _have_ a default.
+-    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
+-
+-
+-    def __init__(self, signature, tuple inputs):
+-        for arg in inputs:
+-            if arg not in signature.parameters:
+-                raise AttributeError("No argument matches '{}'.".format(arg))
+-        self.signature = signature
+-        self.inputs = inputs
+-        self._locations = {}
+-        self._pos = []
+-        self._pos_inputs_input = []
+-        self._pos_inputs_pos = []
+-        self._kw = {}
+-        self._kw_inputs = []
+-        self._default_kw_names = set()
+-        self._n_pos_no_default = 0
+-        # signature.parameters is ordered for all Python versions.
+-        for i, (name, parameter) in enumerate(signature.parameters.items()):
+-            kind = parameter.kind
+-            if (kind == parameter.VAR_POSITIONAL
+-                    or kind == parameter.VAR_KEYWORD):
+-                raise TypeError("Cannot dispatch with *args or **kwargs.")
+-            if kind == parameter.KEYWORD_ONLY:
+-                self._kw[name] = parameter.default
+-                self._locations[name] = -1
+-                if parameter.default is not parameter.empty:
+-                    self._default_kw_names.add(name)
+-                if name in inputs:
+-                    self._kw_inputs.append((name, inputs.index(name)))
+-            else:
+-                self._pos.append(parameter.default)
+-                if kind != parameter.POSITIONAL_ONLY:
+-                    self._locations[name] = i
+-                if parameter.default is parameter.empty:
+-                    self._n_pos_no_default += 1
+-                if name in inputs:
+-                    # Effectively a mapping.
+-                    self._pos_inputs_input.append(inputs.index(name))
+-                    self._pos_inputs_pos.append(len(self._pos) - 1)
+-        self.n_args = len(self._pos)
+-        self.n_kwargs = len(self._kw)
+-        self.n_inputs = len(inputs)
+-        self._n_pos_inputs = len(self._pos_inputs_input)
+-        self._n_kw_inputs = len(self._kw_inputs)
+-        self._n_kw_default = len(self._default_kw_names)
+-
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef tuple bind(self, tuple args, dict kwargs):
+-        """
+-        Cython reimplementation of inspect.Signature.bind for binding the
+-        collected `*args` and `**kwargs` of a generic call to a specific
+-        signature, checking that everything matches.
+-
+-        The output is a parsed tuple (args, kwargs), where `args` is a list and
+-        `kwargs` is a dict, however all arguments which _can_ be passed
+-        positionally will be moved from `kwargs` into `args` for the output.
+-        The resultant `args` and `kwargs` can be unpacked into the underlying
+-        function call safely.  Default values are not filled in by this method.
+-
+-        This is necessary to allow a generic `Dispatcher` class to work with
+-        all type signatures.  The result of this function can be fed to
+-        `_bind.convert_types` and `_bind.dispatch_types`.
+-        """
+-        cdef Py_ssize_t location, got_pos=0, got_kw=0
+-        cdef Py_ssize_t n_passed_args = len(args)
+-        if n_passed_args > self.n_args:
+-            raise TypeError(
+-                "Too many arguments: expected at most {} but received {}."
+-                .format(n_passed_args, self.n_args)
+-            )
+-        # _pos and _kw are filled with their defaults at initialisation, and
+-        # _pos is already the correct length (no-default parameters have
+-        # sentinel values).
+-        cdef list out_pos = self._pos.copy()
+-        cdef dict out_kw = self._kw.copy()
+-        got_pos = self.n_args - self._n_pos_no_default
+-        got_kw = self._n_kw_default
+-        # Positional arguments unambiguously fill the first positional slots.
+-        for location in range(n_passed_args):
+-            out_pos[location] = args[location]
+-        # How many arguments that we didn't have defaults for did we just get?
+-        # Positionals with a default are always after those without one.
+-        if n_passed_args > self._n_pos_no_default:
+-            got_pos += self._n_pos_no_default
+-        else:
+-            got_pos += n_passed_args
+-        # Everything else has been passed by keyword, but it may be allowed to
+-        # be passed positionally, which is the case we prefer.  dict.items() is
+-        # (relatively) expensive, so we use a boolean test for the fast path.
+-        cdef str kw
+-        cdef object arg
+-        if kwargs:
+-            for kw, arg in kwargs.items():
+-                try:
+-                    location = self._locations[kw]
+-                except KeyError:
+-                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
+-                # _locations[kw] = -1 if kw is keyword-only, otherwise the
+-                # corresponding positional location.
+-                if location >= 0:
+-                    if location < n_passed_args:
+-                        raise TypeError("Multiple values for '{}'".format(kw))
+-                    out_pos[location] = arg
+-                    if location < self._n_pos_no_default:
+-                        got_pos += 1
+-                else:
+-                    out_kw[kw] = arg
+-                    if kw not in self._default_kw_names:
+-                        got_kw += 1
+-        if got_pos < self.n_args:
+-            raise TypeError("Too few positional arguments passed.")
+-        if got_kw < self.n_kwargs:
+-            raise TypeError("Not all keyword arguments were filled.")
+-        return out_pos, out_kw
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef list dispatch_types(self, list args, dict kwargs):
+-        """
+-        Get a list of the types which the dispatch should operate over, given
+-        the output of `_bind.bind`.  The return value is a list of the _input_
+-        types to be dispatched on, in order that they were specified at
+-        `Dispatcher` creation.  The output type is not returned as part of this
+-        list, because there is no way for `_bind` to know it.
+-        """
+-        cdef list dispatch = [None] * self.n_inputs
+-        cdef str kw
+-        cdef Py_ssize_t location, i
+-        for location in range(self._n_pos_inputs):
+-            dispatch[self._pos_inputs_input[location]]\
+-                = type(args[self._pos_inputs_pos[location]])
+-        for i in range(self._n_kw_inputs):
+-            kw, location = self._kw_inputs[i]
+-            dispatch[location] = type(kwargs[kw])
+-        return dispatch
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
+-        """
+-        Apply the type converters `converters` to the parsed arguments `args`
+-        and `kwargs`.
+-
+-        If there are `n` inputs which are dispatched on, `converters` should be
+-        a tuple whose first `n` elements are converters (such as those obtained
+-        from `data.to[to_type, from_type]`) to the desired types.
+-
+-        `args` and `kwargs` should be the output of `_bind.bind`; the function
+-        will likely fail if called on unparsed arguments.
+-        """
+-        cdef str kw
+-        cdef Py_ssize_t location, i
+-        for location in range(self._n_pos_inputs):
+-            args[location] = converters[location](args[location])
+-        for i in range(self._n_kw_inputs):
+-            kw, location = self._kw_inputs[i]
+-            kwargs[kw] = converters[location](kwargs[kw])
+-        return args, kwargs
+-
+-
+-cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
+-    """
+-    Find the total weight of conversion if the types in `froms` are converted
+-    element-wise to the types in `tos`.  `weight_map` is a mapping of
+-    `(to_type, from_type): real`; it should almost certainly be
+-    `data.to.weight`.
+-    """
+-    cdef double weight = 0.0
+-    cdef Py_ssize_t i, n=len(froms)
+-    if len(tos) != n:
+-        raise ValueError(
+-            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
+-        )
+-    if out:
+-        n = n - 1
+-        weight += weight_map[froms[n], tos[n]]
+-    for i in range(n):
+-        weight += weight_map[tos[i], froms[i]]
+-    return weight
+-
+-
+-cdef class _constructed_specialisation:
+-    """
+-    Callable object providing the specialisation of a data-layer operation for
+-    a particular set of types (`self.types`).  This may or may not involve
+-    conversion of the input types and the output to match a known
+-    specialisation; if it has no conversions, `self.direct` will be `True`,
+-    otherwise it will be `False`.
+-
+-    See `self.__signature__` or `self.__text_signature__` for the call
+-    signature of this object.
+-    """
+-    cdef _bind _parameters
+-    cdef bint _output
+-    cdef object _call
+-    cdef Py_ssize_t _n_dispatch
+-    cdef readonly tuple types
+-    cdef tuple _converters
+-    cdef str _short_name
+-    cdef public str __doc__
+-    cdef public str __name__
+-    cdef public str __module__
+-    cdef public object __signature__
+-    cdef readonly str __text_signature__
+-    cdef readonly bint direct
+-
+-    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
+-                 direct):
+-        self.__doc__ = inspect.getdoc(dispatcher)
+-        self._short_name = dispatcher.__name__
+-        self.__name__ = (
+-            self._short_name
+-            + "_"
+-            + "_".join([x.__name__ for x in types])
+-        )
+-        self.__module__ = dispatcher.__module__
+-        self.__signature__ = dispatcher.__signature__
+-        self.__text_signature__ = dispatcher.__text_signature__
+-        self._parameters = dispatcher._parameters
+-        self._output = out
+-        self._call = base
+-        self._n_dispatch = len(types)
+-        self.types = types
+-        self.direct = direct
+-        self._converters = converters
+-
+-    cdef object prebound(self, list args, dict kwargs):
+-        """
+-        Call this specialisation with pre-parsed arguments and keyword
+-        arguments.  `args` and `kwargs` must be the output of the relevant
+-        `_bind.bind` method for this function.
+-        """
+-        self._parameters.convert_types(args, kwargs, self._converters)
+-        out = self._call(*args, **kwargs)
+-        if self._output:
+-            out = self._converters[self._n_dispatch - 1](out)
+-        return out
+-
+-    def __call__(self, *args, **kwargs):
+-        cdef list args_
+-        cdef dict kwargs_
+-        args_, kwargs_ = self._parameters.bind(args, kwargs)
+-        return self.prebound(args_, kwargs_)
+-
+-    def __repr__(self):
+-        if len(self.types) == 1:
+-            spec = self.types[0].__name__
+-        else:
+-            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
+-        direct = ("" if self.direct else "in") + "direct"
+-        return "".join([
+-            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
+-        ])
+-
+-
+-cdef class Dispatcher:
+-    """
+-    Dispatcher for a data-layer operation.  This object can be called with the
+-    signature shown in `self.__signature__` or `self.__text_signature__`, where
+-    the arguments listed in `self.inputs` can be any data-layer types (i.e.
+-    ones that have valid conversions in `data.to`).
+-
+-    You can define additional specialisations for this dispatcher by calling
+-    its `add_specialisations` method.  New data types must be added to
+-    `data.to` before they can be added as specialisations to a dispatcher.
+-
+-    You can get a callable object representing a single set of dispatcher types
+-    by using the key-lookup syntax
+-        Dispatcher[type1, type2, ...]
+-    where `type1`, `type2`, etc are the dispatched arguments (with the output
+-    type on the end, if this is a dispatcher over the output type.
+-    """
+-    cdef _bind _parameters
+-    cdef readonly dict _specialisations
+-    cdef Py_ssize_t _n_dispatch
+-    cdef readonly dict _lookup
+-    cdef set _dtypes
+-    cdef bint _pass_on_dtype
+-    cdef readonly tuple inputs
+-    cdef readonly bint output
+-    cdef public str __doc__
+-    cdef public str __name__
+-    cdef public str __module__
+-    cdef public object __signature__
+-    cdef readonly str __text_signature__
+-
+-    def __init__(self, signature_source, inputs, bint out=False,
+-                 str name=None, str module=None):
+-        """
+-        Create a new data layer dispatching operator.
+-
+-        Parameters
+-        ----------
+-        signature_source : callable or inspect.Signature
+-            An object from which the call signature of operation can be
+-            determined.  You can pass any callable defined in Python space, and
+-            the signature will be extracted.  Note that the callable will not
+-            be added as a specialisation by this; you will still have to call
+-            `add_specialisations`.
+-
+-            If you cannot provide a callable with an extractable signature
+-            (e.g. Cython extension methods), you can instead directly provide
+-            an instance of `inspect.Signature`, which will be used instead.
+-
+-        inputs : iterable of str
+-            The parameters which should be dispatched over.  These can be
+-            positional or keyword arguments, but must feature in the signature
+-            provided.
+-
+-        out : bool, optional (False)
+-            Whether to dispatch on the output of the function.  Defaults to
+-            `False`.
+-
+-        name : str, optional
+-            If given, the `__name__` parameter of the dispatcher is set to
+-            this.  If not given and `signature_source` is _not_ an instance of
+-            `inspect.Signature`, then we will attempt to read `__name__` from
+-            there instead.
+-
+-        module : str, optional
+-            If given, the `__module__` parameter of the dispatcher is set to
+-            this.  If not given and `signature_source` is _not_ an instance of
+-            `inspect.Signature`, then we will attempt to read `__module__` from
+-            there instead.
+-        """
+-        if isinstance(inputs, str):
+-            inputs = (inputs,)
+-        inputs = tuple(inputs)
+-        if inputs == () and out is False:
+-            warnings.warn(
+-                "No parameters to dispatch on."
+-                " Maybe you meant to specify 'inputs' or 'out'?"
+-            )
+-        self.inputs = inputs
+-        if isinstance(signature_source, inspect.Signature):
+-            self.__signature__ = signature_source
+-        else:
+-            self.__signature__ = inspect.signature(signature_source)
+-        self._parameters = _bind(self.__signature__, inputs)
+-        if name is not None:
+-            self.__name__ = name
+-        elif not isinstance(signature_source, inspect.Signature):
+-            self.__name__ = signature_source.__name__
+-        else:
+-            self.__name__ = 'dispatcher'
+-        if module is not None:
+-            self.__module__ = module
+-        elif not isinstance(signature_source, inspect.Signature):
+-            self.__module__ = signature_source.__module__
+-        self.__text_signature__ = self.__name__ + str(self.__signature__)
+-        if not isinstance(signature_source, inspect.Signature):
+-            self.__doc__ = inspect.getdoc(signature_source)
+-        self.output = out
+-        self._specialisations = {}
+-        self._lookup = {}
+-        self._n_dispatch = self._parameters.n_inputs + self.output
+-        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
+-        # Add ourselves to the list of dispatchers to be updated.
+-        _to.dispatchers.append(self)
+-
+-    def add_specialisations(self, specialisations, _defer=False):
+-        """
+-        Add specialisations for particular combinations of data types to this
+-        operation.  The data types must already be known in `data.to` before
+-        you try to provide them here.  All data types defined in `data.to` will
+-        automatically work with this dispatcher, but will involve inefficient
+-        conversions to and from other types unless you define a closer
+-        specialisation using this method.
+-
+-        The lookup table will automatically be rebuilt after this method is
+-        called.  Specialisations defined more than once will use the most
+-        recent version; you can use this to override currently known
+-        specialisations if desired.
+-
+-        Parameters
+-        ----------
+-        specialisations : iterable of tuples
+-            An iterable where each element specifies a new specialisation for
+-            this operation.  Each element of the iterable should be a tuple,
+-            whose items are the types (instances of `type`) which this
+-            specialisation takes in each of the slots defined by
+-            `Dispatcher.inputs`, and the output type if this is a dispatcher
+-            over output types.  The last element should be the callable itself.
+-
+-            The callable must have exactly the same signature as
+-            `Dispatcher.__signature__`; it is not enough that it takes all the
+-            same keyword arguments, but they must come in the same order as
+-            well (this is a speed optimisation for the dispatching operation).
+-
+-            For example, if this is a dispatcher with the signature
+-                add(left, right, scale=1)
+-            which also dispatches over its output, and we have specialisations
+-                add_1(left: CSR, right: Dense, scale=1) -> Dense
+-                add_2(left: Dense, right: CSC, scale=1) -> CSR
+-            then to add this, `specialisations` should look like
+-                [
+-                    (CSR, Dense, Dense, add_1),
+-                    (Dense, CSC, CSR, add_2),
+-                ]
+-            Type annotations present in the specialisation objects are ignored.
+-
+-        _defer : bool, optional (False)
+-            Only intended for internal library use during initialisation. If
+-            `True`, then the input types are not checked, and the full lookup
+-            table is not built until a manual call to
+-            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
+-            remember that you should add the data type conversions to `data.to`
+-            before you try to add specialisations.
+-        """
+-        for arg in specialisations:
+-            arg = tuple(arg)
+-            if len(arg) != self._n_dispatch + 1:
+-                raise ValueError(
+-                    "specialisation " + str(arg)
+-                    + " has wrong number of parameters: needed types for "
+-                    + str(self._parameters.inputs)
+-                    + (", an output type" if self.output else "")
+-                    + " and a callable"
+-                )
+-            for i in range(self._n_dispatch):
+-                if (not _defer) and arg[i] not in _to.dtypes:
+-                    raise ValueError(str(arg[i]) + " is not a known data type")
+-            if not callable(arg[self._n_dispatch]):
+-                raise TypeError(str(arg[-1]) + " is not callable")
+-            self._specialisations[arg[:-1]] = arg[-1]
+-        if not _defer:
+-            self.rebuild_lookup()
+-
+-    def rebuild_lookup(self):
+-        """
+-        Manually trigger a rebuild of the lookup table for this dispatcher.
+-        This is called automatically when new data types are added to
+-        `data.to`, or when specialisations are added to this object with
+-        `Dispatcher.add_specialisations`.
+-
+-        You most likely do not need to call this function yourself.
+-        """
+-        cdef double weight, cur
+-        cdef tuple types, out_types
+-        cdef object function
+-        if not self._specialisations:
+-            return
+-        self._dtypes = _to.dtypes.copy()
+-        # The complexity of building the table here is very poor, but it's a
+-        # cost we pay very infrequently, and until it's proved to be a
+-        # bottle-neck in real code, we stick with the simple algorithm.
+-        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
+-            weight = math.INFINITY
+-            types = None
+-            function = None
+-            for out_types, out_function in self._specialisations.items():
+-                cur = _conversion_weight(in_types, out_types, _to.weight,
+-                                         out=self.output)
+-                if cur < weight:
+-                    weight = cur
+-                    types = out_types
+-                    function = out_function
+-            if self.output:
+-                converters = tuple(
+-                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
+-                    + [_to[in_types[-1], types[-1]]]
+-                )
+-            else:
+-                converters = tuple(_to[pair] for pair in zip(types, in_types))
+-            self._lookup[in_types] =\
+-                _constructed_specialisation(function, self, in_types,
+-                                            converters, self.output,
+-                                            weight == 0)
+-        # Now build the lookup table in the case that we dispatch on the output
+-        # type as well, but the user has called us without specifying it.
+-        # TODO: option to control default output type choice if unspecified?
+-        if self.output:
+-            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
+-                weight = math.INFINITY
+-                types = None
+-                function = None
+-                for out_types, out_function in self._specialisations.items():
+-                    cur = _conversion_weight(in_types, out_types[:-1],
+-                                             _to.weight, out=False)
+-                    if cur < weight:
+-                        weight = cur
+-                        types = out_types
+-                        function = out_function
+-                converters = tuple(_to[pair] for pair in zip(types, in_types))
+-                self._lookup[in_types] =\
+-                    _constructed_specialisation(function, self,
+-                                                in_types + (types[-1],),
+-                                                converters, False,
+-                                                weight == 0)
+-
+-    def __getitem__(self, types):
+-        """
+-        Get the particular specialisation for the given types.  The output is a
+-        callable object which requires that the dispatched arguments match
+-        those specified in `types`.
+-        """
+-        if type(types) is not tuple:
+-            types = (types,)
+-        types = tuple(_to.parse(arg) for arg in types)
+-        try:
+-            return self._lookup[types]
+-        except KeyError:
+-            raise TypeError("specialisation not known for types: " + str(types)) from None
+-
+-    def __repr__(self):
+-        return "<dispatcher: " + self.__text_signature__ + ">"
+-
+-    def __call__(self, *args, dtype=None, **kwargs):
+-        cdef list args_, dispatch
+-        cdef dict kwargs_
+-        if self._pass_on_dtype:
+-            kwargs['dtype'] = dtype
+-        if not (self._pass_on_dtype or self.output) and dtype is not None:
+-            raise TypeError("unknown argument 'dtype'")
+-        args_, kwargs_ = self._parameters.bind(args, kwargs)
+-        dispatch = self._parameters.dispatch_types(args_, kwargs_)
+-        if self.output and dtype is not None:
+-            dtype = _to.parse(dtype)
+-            dispatch.append(dtype)
+-        cdef _constructed_specialisation function
+-        try:
+-            function = self._lookup[tuple(dispatch)]
+-        except KeyError:
+-            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
+-        return function.prebound(args_, kwargs_)
++#cython: language_level=3
++
++import functools
++import inspect
++import itertools
++import warnings
++
++from .convert import to as _to
++
++cimport cython
++from libc cimport math
++from libcpp cimport bool
++
++__all__ = ['Dispatcher']
++
++cdef class _bind:
++    """
++    Cythonised implementation of inspect.Signature.bind, supporting faster
++    binding and handling of default arguments.  On construction, the signature
++    of the base function is extracted, and all parameters are parsed into
++    positional or keyword slots, using positional wherever possible, and their
++    defaults are stored.
++    """
++    # Instance of inpsect.Signature representing the function.
++    cdef object signature
++    cdef object inputs
++    # Mapping of (str: int), where str is the name of any argument which may be
++    # specified by a keyword, and int is its location in `self._pos` if
++    # available, or -1 if it is keyword-only.
++    cdef dict _locations
++    # Default values (or inspect.Parameter.empty) for every parameter which
++    # may be passed as a positional argument.
++    cdef list _pos
++    # For each dispatcher input which can be given as a positional argument,
++    # these two lists hold the index of the input in the given tuple of input
++    # names and the corresponding index into the positional arguments after
++    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
++    # effectively the same mapping as _kw_inputs (but for positional
++    # arguments), but we use two lists rather than a dictionary for speed.
++    cdef list _pos_inputs_input, _pos_inputs_pos
++    # Default values (or inspect.Parameter.empty) for every parameter which
++    # _must_ be passed as a keyword argument.
++    cdef dict _kw
++    # Mapping of (name, index into the input tuple) for each input which must
++    # be specified as a keyword argument
++    cdef list _kw_inputs
++    # Names of the keyword arguments which have default values.
++    cdef set _default_kw_names
++    # Respectively, numbers of positional parameters, keyword-only parameters
++    # and dispatcher inputs.
++    cdef Py_ssize_t n_args, n_kwargs, n_inputs
++    # Respectively, numbers of inputs which are positional and keyword-only.
++    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
++    # Respectively, numbers of positional arguments without a default, and
++    # number of keyword-only arguments which _have_ a default.
++    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
++
++
++    def __init__(self, signature, tuple inputs):
++        for arg in inputs:
++            if arg not in signature.parameters:
++                raise AttributeError("No argument matches '{}'.".format(arg))
++        self.signature = signature
++        self.inputs = inputs
++        self._locations = {}
++        self._pos = []
++        self._pos_inputs_input = []
++        self._pos_inputs_pos = []
++        self._kw = {}
++        self._kw_inputs = []
++        self._default_kw_names = set()
++        self._n_pos_no_default = 0
++        # signature.parameters is ordered for all Python versions.
++        for i, (name, parameter) in enumerate(signature.parameters.items()):
++            kind = parameter.kind
++            if (kind == parameter.VAR_POSITIONAL
++                    or kind == parameter.VAR_KEYWORD):
++                raise TypeError("Cannot dispatch with *args or **kwargs.")
++            if kind == parameter.KEYWORD_ONLY:
++                self._kw[name] = parameter.default
++                self._locations[name] = -1
++                if parameter.default is not parameter.empty:
++                    self._default_kw_names.add(name)
++                if name in inputs:
++                    self._kw_inputs.append((name, inputs.index(name)))
++            else:
++                self._pos.append(parameter.default)
++                if kind != parameter.POSITIONAL_ONLY:
++                    self._locations[name] = i
++                if parameter.default is parameter.empty:
++                    self._n_pos_no_default += 1
++                if name in inputs:
++                    # Effectively a mapping.
++                    self._pos_inputs_input.append(inputs.index(name))
++                    self._pos_inputs_pos.append(len(self._pos) - 1)
++        self.n_args = len(self._pos)
++        self.n_kwargs = len(self._kw)
++        self.n_inputs = len(inputs)
++        self._n_pos_inputs = len(self._pos_inputs_input)
++        self._n_kw_inputs = len(self._kw_inputs)
++        self._n_kw_default = len(self._default_kw_names)
++
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef tuple bind(self, tuple args, dict kwargs):
++        """
++        Cython reimplementation of inspect.Signature.bind for binding the
++        collected `*args` and `**kwargs` of a generic call to a specific
++        signature, checking that everything matches.
++
++        The output is a parsed tuple (args, kwargs), where `args` is a list and
++        `kwargs` is a dict, however all arguments which _can_ be passed
++        positionally will be moved from `kwargs` into `args` for the output.
++        The resultant `args` and `kwargs` can be unpacked into the underlying
++        function call safely.  Default values are not filled in by this method.
++
++        This is necessary to allow a generic `Dispatcher` class to work with
++        all type signatures.  The result of this function can be fed to
++        `_bind.convert_types` and `_bind.dispatch_types`.
++        """
++        cdef Py_ssize_t location, got_pos=0, got_kw=0
++        cdef Py_ssize_t n_passed_args = len(args)
++        if n_passed_args > self.n_args:
++            raise TypeError(
++                "Too many arguments: expected at most {} but received {}."
++                .format(n_passed_args, self.n_args)
++            )
++        # _pos and _kw are filled with their defaults at initialisation, and
++        # _pos is already the correct length (no-default parameters have
++        # sentinel values).
++        cdef list out_pos = self._pos.copy()
++        cdef dict out_kw = self._kw.copy()
++        got_pos = self.n_args - self._n_pos_no_default
++        got_kw = self._n_kw_default
++        # Positional arguments unambiguously fill the first positional slots.
++        for location in range(n_passed_args):
++            out_pos[location] = args[location]
++        # How many arguments that we didn't have defaults for did we just get?
++        # Positionals with a default are always after those without one.
++        if n_passed_args > self._n_pos_no_default:
++            got_pos += self._n_pos_no_default
++        else:
++            got_pos += n_passed_args
++        # Everything else has been passed by keyword, but it may be allowed to
++        # be passed positionally, which is the case we prefer.  dict.items() is
++        # (relatively) expensive, so we use a boolean test for the fast path.
++        cdef str kw
++        cdef object arg
++        if kwargs:
++            for kw, arg in kwargs.items():
++                try:
++                    location = self._locations[kw]
++                except KeyError:
++                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
++                # _locations[kw] = -1 if kw is keyword-only, otherwise the
++                # corresponding positional location.
++                if location >= 0:
++                    if location < n_passed_args:
++                        raise TypeError("Multiple values for '{}'".format(kw))
++                    out_pos[location] = arg
++                    if location < self._n_pos_no_default:
++                        got_pos += 1
++                else:
++                    out_kw[kw] = arg
++                    if kw not in self._default_kw_names:
++                        got_kw += 1
++        if got_pos < self.n_args:
++            raise TypeError("Too few positional arguments passed.")
++        if got_kw < self.n_kwargs:
++            raise TypeError("Not all keyword arguments were filled.")
++        return out_pos, out_kw
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef list dispatch_types(self, list args, dict kwargs):
++        """
++        Get a list of the types which the dispatch should operate over, given
++        the output of `_bind.bind`.  The return value is a list of the _input_
++        types to be dispatched on, in order that they were specified at
++        `Dispatcher` creation.  The output type is not returned as part of this
++        list, because there is no way for `_bind` to know it.
++        """
++        cdef list dispatch = [None] * self.n_inputs
++        cdef str kw
++        cdef Py_ssize_t location, i
++        for location in range(self._n_pos_inputs):
++            dispatch[self._pos_inputs_input[location]]\
++                = type(args[self._pos_inputs_pos[location]])
++        for i in range(self._n_kw_inputs):
++            kw, location = self._kw_inputs[i]
++            dispatch[location] = type(kwargs[kw])
++        return dispatch
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
++        """
++        Apply the type converters `converters` to the parsed arguments `args`
++        and `kwargs`.
++
++        If there are `n` inputs which are dispatched on, `converters` should be
++        a tuple whose first `n` elements are converters (such as those obtained
++        from `data.to[to_type, from_type]`) to the desired types.
++
++        `args` and `kwargs` should be the output of `_bind.bind`; the function
++        will likely fail if called on unparsed arguments.
++        """
++        cdef str kw
++        cdef Py_ssize_t location, i
++        for location in range(self._n_pos_inputs):
++            args[location] = converters[location](args[location])
++        for i in range(self._n_kw_inputs):
++            kw, location = self._kw_inputs[i]
++            kwargs[kw] = converters[location](kwargs[kw])
++        return args, kwargs
++
++
++cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
++    """
++    Find the total weight of conversion if the types in `froms` are converted
++    element-wise to the types in `tos`.  `weight_map` is a mapping of
++    `(to_type, from_type): real`; it should almost certainly be
++    `data.to.weight`.
++    """
++    cdef double weight = 0.0
++    cdef Py_ssize_t i, n=len(froms)
++    if len(tos) != n:
++        raise ValueError(
++            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
++        )
++    if out:
++        n = n - 1
++        weight += weight_map[froms[n], tos[n]]
++    for i in range(n):
++        weight += weight_map[tos[i], froms[i]]
++    return weight
++
++
++cdef class _constructed_specialisation:
++    """
++    Callable object providing the specialisation of a data-layer operation for
++    a particular set of types (`self.types`).  This may or may not involve
++    conversion of the input types and the output to match a known
++    specialisation; if it has no conversions, `self.direct` will be `True`,
++    otherwise it will be `False`.
++
++    See `self.__signature__` or `self.__text_signature__` for the call
++    signature of this object.
++    """
++    cdef _bind _parameters
++    cdef bint _output
++    cdef object _call
++    cdef Py_ssize_t _n_dispatch
++    cdef readonly tuple types
++    cdef tuple _converters
++    cdef str _short_name
++    cdef public str __doc__
++    cdef public str __name__
++    cdef public str __module__
++    cdef public object __signature__
++    cdef readonly str __text_signature__
++    cdef readonly bint direct
++
++    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
++                 direct):
++        self.__doc__ = inspect.getdoc(dispatcher)
++        self._short_name = dispatcher.__name__
++        self.__name__ = (
++            self._short_name
++            + "_"
++            + "_".join([x.__name__ for x in types])
++        )
++        self.__module__ = dispatcher.__module__
++        self.__signature__ = dispatcher.__signature__
++        self.__text_signature__ = dispatcher.__text_signature__
++        self._parameters = dispatcher._parameters
++        self._output = out
++        self._call = base
++        self._n_dispatch = len(types)
++        self.types = types
++        self.direct = direct
++        self._converters = converters
++
++    cdef object prebound(self, list args, dict kwargs):
++        """
++        Call this specialisation with pre-parsed arguments and keyword
++        arguments.  `args` and `kwargs` must be the output of the relevant
++        `_bind.bind` method for this function.
++        """
++        self._parameters.convert_types(args, kwargs, self._converters)
++        out = self._call(*args, **kwargs)
++        if self._output:
++            out = self._converters[self._n_dispatch - 1](out)
++        return out
++
++    def __call__(self, *args, **kwargs):
++        cdef list args_
++        cdef dict kwargs_
++        args_, kwargs_ = self._parameters.bind(args, kwargs)
++        return self.prebound(args_, kwargs_)
++
++    def __repr__(self):
++        if len(self.types) == 1:
++            spec = self.types[0].__name__
++        else:
++            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
++        direct = ("" if self.direct else "in") + "direct"
++        return "".join([
++            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
++        ])
++
++
++cdef class Dispatcher:
++    """
++    Dispatcher for a data-layer operation.  This object can be called with the
++    signature shown in `self.__signature__` or `self.__text_signature__`, where
++    the arguments listed in `self.inputs` can be any data-layer types (i.e.
++    ones that have valid conversions in `data.to`).
++
++    You can define additional specialisations for this dispatcher by calling
++    its `add_specialisations` method.  New data types must be added to
++    `data.to` before they can be added as specialisations to a dispatcher.
++
++    You can get a callable object representing a single set of dispatcher types
++    by using the key-lookup syntax
++        Dispatcher[type1, type2, ...]
++    where `type1`, `type2`, etc are the dispatched arguments (with the output
++    type on the end, if this is a dispatcher over the output type.
++    """
++    cdef _bind _parameters
++    cdef readonly dict _specialisations
++    cdef Py_ssize_t _n_dispatch
++    cdef readonly dict _lookup
++    cdef set _dtypes
++    cdef bint _pass_on_dtype
++    cdef readonly tuple inputs
++    cdef readonly bint output
++    cdef public str __doc__
++    cdef public str __name__
++    cdef public str __module__
++    cdef public object __signature__
++    cdef readonly str __text_signature__
++
++    def __init__(self, signature_source, inputs, bint out=False,
++                 str name=None, str module=None):
++        """
++        Create a new data layer dispatching operator.
++
++        Parameters
++        ----------
++        signature_source : callable or inspect.Signature
++            An object from which the call signature of operation can be
++            determined.  You can pass any callable defined in Python space, and
++            the signature will be extracted.  Note that the callable will not
++            be added as a specialisation by this; you will still have to call
++            `add_specialisations`.
++
++            If you cannot provide a callable with an extractable signature
++            (e.g. Cython extension methods), you can instead directly provide
++            an instance of `inspect.Signature`, which will be used instead.
++
++        inputs : iterable of str
++            The parameters which should be dispatched over.  These can be
++            positional or keyword arguments, but must feature in the signature
++            provided.
++
++        out : bool, optional (False)
++            Whether to dispatch on the output of the function.  Defaults to
++            `False`.
++
++        name : str, optional
++            If given, the `__name__` parameter of the dispatcher is set to
++            this.  If not given and `signature_source` is _not_ an instance of
++            `inspect.Signature`, then we will attempt to read `__name__` from
++            there instead.
++
++        module : str, optional
++            If given, the `__module__` parameter of the dispatcher is set to
++            this.  If not given and `signature_source` is _not_ an instance of
++            `inspect.Signature`, then we will attempt to read `__module__` from
++            there instead.
++        """
++        if isinstance(inputs, str):
++            inputs = (inputs,)
++        inputs = tuple(inputs)
++        if inputs == () and out is False:
++            warnings.warn(
++                "No parameters to dispatch on."
++                " Maybe you meant to specify 'inputs' or 'out'?"
++            )
++        self.inputs = inputs
++        if isinstance(signature_source, inspect.Signature):
++            self.__signature__ = signature_source
++        else:
++            self.__signature__ = inspect.signature(signature_source)
++        self._parameters = _bind(self.__signature__, inputs)
++        if name is not None:
++            self.__name__ = name
++        elif not isinstance(signature_source, inspect.Signature):
++            self.__name__ = signature_source.__name__
++        else:
++            self.__name__ = 'dispatcher'
++        if module is not None:
++            self.__module__ = module
++        elif not isinstance(signature_source, inspect.Signature):
++            self.__module__ = signature_source.__module__
++        self.__text_signature__ = self.__name__ + str(self.__signature__)
++        if not isinstance(signature_source, inspect.Signature):
++            self.__doc__ = inspect.getdoc(signature_source)
++        self.output = out
++        self._specialisations = {}
++        self._lookup = {}
++        self._n_dispatch = self._parameters.n_inputs + self.output
++        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
++        # Add ourselves to the list of dispatchers to be updated.
++        _to.dispatchers.append(self)
++
++    def add_specialisations(self, specialisations, _defer=False):
++        """
++        Add specialisations for particular combinations of data types to this
++        operation.  The data types must already be known in `data.to` before
++        you try to provide them here.  All data types defined in `data.to` will
++        automatically work with this dispatcher, but will involve inefficient
++        conversions to and from other types unless you define a closer
++        specialisation using this method.
++
++        The lookup table will automatically be rebuilt after this method is
++        called.  Specialisations defined more than once will use the most
++        recent version; you can use this to override currently known
++        specialisations if desired.
++
++        Parameters
++        ----------
++        specialisations : iterable of tuples
++            An iterable where each element specifies a new specialisation for
++            this operation.  Each element of the iterable should be a tuple,
++            whose items are the types (instances of `type`) which this
++            specialisation takes in each of the slots defined by
++            `Dispatcher.inputs`, and the output type if this is a dispatcher
++            over output types.  The last element should be the callable itself.
++
++            The callable must have exactly the same signature as
++            `Dispatcher.__signature__`; it is not enough that it takes all the
++            same keyword arguments, but they must come in the same order as
++            well (this is a speed optimisation for the dispatching operation).
++
++            For example, if this is a dispatcher with the signature
++                add(left, right, scale=1)
++            which also dispatches over its output, and we have specialisations
++                add_1(left: CSR, right: Dense, scale=1) -> Dense
++                add_2(left: Dense, right: CSC, scale=1) -> CSR
++            then to add this, `specialisations` should look like
++                [
++                    (CSR, Dense, Dense, add_1),
++                    (Dense, CSC, CSR, add_2),
++                ]
++            Type annotations present in the specialisation objects are ignored.
++
++        _defer : bool, optional (False)
++            Only intended for internal library use during initialisation. If
++            `True`, then the input types are not checked, and the full lookup
++            table is not built until a manual call to
++            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
++            remember that you should add the data type conversions to `data.to`
++            before you try to add specialisations.
++        """
++        for arg in specialisations:
++            arg = tuple(arg)
++            if len(arg) != self._n_dispatch + 1:
++                raise ValueError(
++                    "specialisation " + str(arg)
++                    + " has wrong number of parameters: needed types for "
++                    + str(self._parameters.inputs)
++                    + (", an output type" if self.output else "")
++                    + " and a callable"
++                )
++            for i in range(self._n_dispatch):
++                if (not _defer) and arg[i] not in _to.dtypes:
++                    raise ValueError(str(arg[i]) + " is not a known data type")
++            if not callable(arg[self._n_dispatch]):
++                raise TypeError(str(arg[-1]) + " is not callable")
++            self._specialisations[arg[:-1]] = arg[-1]
++        if not _defer:
++            self.rebuild_lookup()
++
++    def rebuild_lookup(self):
++        """
++        Manually trigger a rebuild of the lookup table for this dispatcher.
++        This is called automatically when new data types are added to
++        `data.to`, or when specialisations are added to this object with
++        `Dispatcher.add_specialisations`.
++
++        You most likely do not need to call this function yourself.
++        """
++        cdef double weight, cur
++        cdef tuple types, out_types
++        cdef object function
++        if not self._specialisations:
++            return
++        self._dtypes = _to.dtypes.copy()
++        # The complexity of building the table here is very poor, but it's a
++        # cost we pay very infrequently, and until it's proved to be a
++        # bottle-neck in real code, we stick with the simple algorithm.
++        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
++            weight = math.INFINITY
++            types = None
++            function = None
++            for out_types, out_function in self._specialisations.items():
++                cur = _conversion_weight(in_types, out_types, _to.weight,
++                                         out=self.output)
++                if cur < weight:
++                    weight = cur
++                    types = out_types
++                    function = out_function
++            if self.output:
++                converters = tuple(
++                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
++                    + [_to[in_types[-1], types[-1]]]
++                )
++            else:
++                converters = tuple(_to[pair] for pair in zip(types, in_types))
++            self._lookup[in_types] =\
++                _constructed_specialisation(function, self, in_types,
++                                            converters, self.output,
++                                            weight == 0)
++        # Now build the lookup table in the case that we dispatch on the output
++        # type as well, but the user has called us without specifying it.
++        # TODO: option to control default output type choice if unspecified?
++        if self.output:
++            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
++                weight = math.INFINITY
++                types = None
++                function = None
++                for out_types, out_function in self._specialisations.items():
++                    cur = _conversion_weight(in_types, out_types[:-1],
++                                             _to.weight, out=False)
++                    if cur < weight:
++                        weight = cur
++                        types = out_types
++                        function = out_function
++                converters = tuple(_to[pair] for pair in zip(types, in_types))
++                self._lookup[in_types] =\
++                    _constructed_specialisation(function, self,
++                                                in_types + (types[-1],),
++                                                converters, False,
++                                                weight == 0)
++
++    def __getitem__(self, types):
++        """
++        Get the particular specialisation for the given types.  The output is a
++        callable object which requires that the dispatched arguments match
++        those specified in `types`.
++        """
++        if type(types) is not tuple:
++            types = (types,)
++        types = tuple(_to.parse(arg) for arg in types)
++        try:
++            return self._lookup[types]
++        except KeyError:
++            raise TypeError("specialisation not known for types: " + str(types)) from None
++
++    def __repr__(self):
++        return "<dispatcher: " + self.__text_signature__ + ">"
++
++    def __call__(self, *args, dtype=None, **kwargs):
++        cdef list args_, dispatch
++        cdef dict kwargs_
++        if self._pass_on_dtype:
++            kwargs['dtype'] = dtype
++        if not (self._pass_on_dtype or self.output) and dtype is not None:
++            raise TypeError("unknown argument 'dtype'")
++        args_, kwargs_ = self._parameters.bind(args, kwargs)
++        dispatch = self._parameters.dispatch_types(args_, kwargs_)
++        if self.output and dtype is not None:
++            dtype = _to.parse(dtype)
++            dispatch.append(dtype)
++        cdef _constructed_specialisation function
++        try:
++            function = self._lookup[tuple(dispatch)]
++        except KeyError:
++            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
++        return function.prebound(args_, kwargs_)
+diff --git a/qutip/core/data/eigen.py b/qutip/core/data/eigen.py
+index c860fc20..f5aa6e0f 100644
+--- a/qutip/core/data/eigen.py
++++ b/qutip/core/data/eigen.py
+@@ -1,454 +1,454 @@
+-import numpy as np
+-import scipy.linalg
+-import scipy.sparse as sp
+-import scipy.sparse.linalg
+-from itertools import combinations
+-
+-from .dense import Dense, from_csr
+-from .csr import CSR
+-from .properties import isherm as _isherm
+-from qutip.settings import settings
+-
+-__all__ = [
+-    'eigs', 'eigs_csr', 'eigs_dense',
+-    'svd', 'svd_csr', 'svd_dense',
+-]
+-
+-
+-def _orthogonalize(vec, other):
+-    cross = np.sum(np.conj(other) * vec)
+-    vec -= cross * other
+-    norm = np.sum(np.conj(vec) * vec)**0.5
+-    vec /= norm
+-
+-
+-if settings.eigh_unsafe:
+-    def eigh(mat, eigvals=None):
+-        val, vec = scipy.linalg.eig(mat)
+-        val = np.real(val)
+-        idx = np.argsort(val)
+-        val = val[idx]
+-        vec = vec[:, idx]
+-        if eigvals:
+-            val = val[eigvals[0]:eigvals[1]+1]
+-            vec = vec[:, eigvals[0]:eigvals[1]+1]
+-        same_eigv = 0
+-        for i in range(1, len(val)):
+-            if abs(val[i] - val[i-1]) < 1e-12:
+-                same_eigv += 1
+-                for j in range(same_eigv):
+-                    _orthogonalize(vec[:, i], vec[:, i-j-1])
+-            else:
+-                same_eigv = 0
+-        return val, vec
+-
+-    def eigvalsh(a, eigvals=None):
+-        val = scipy.linalg.eigvals(a)
+-        val = np.sort(np.real(val))
+-        if eigvals:
+-            return val[eigvals[0]:eigvals[1]+1]
+-        return val
+-else:
+-    eigh = scipy.linalg.eigh
+-    eigvalsh = scipy.linalg.eigvalsh
+-
+-
+-def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
+-    """
+-    Internal functions for computing eigenvalues and eigenstates for a dense
+-    matrix.
+-    """
+-    N = data.shape[0]
+-    kwargs = {}
+-    if eigvals != 0 and isherm:
+-        kwargs['subset_by_index'] = (
+-            [0, num_small-1] if num_small else [N-num_large, N-1]
+-        )
+-    if vecs:
+-        driver = eigh if isherm else scipy.linalg.eig
+-        evals, evecs = driver(data, **kwargs)
+-    else:
+-        driver = eigvalsh if isherm else scipy.linalg.eigvals
+-        evals = driver(data, **kwargs)
+-        evecs = None
+-
+-    _zipped = list(zip(evals, range(len(evals))))
+-    _zipped.sort()
+-    evals, perm = list(zip(*_zipped))
+-
+-    if vecs:
+-        evecs = np.array([evecs[:, k] for k in perm]).T
+-
+-    if not isherm and eigvals > 0:
+-        if vecs:
+-            if num_small > 0:
+-                evals, evecs = evals[:num_small], evecs[:, :num_small]
+-            elif num_large > 0:
+-                evals = evals[(N - num_large):]
+-                evecs = evecs[:, (N - num_large):]
+-        else:
+-            if num_small > 0:
+-                evals = evals[:num_small]
+-            elif num_large > 0:
+-                evals = evals[(N - num_large):]
+-    return np.array(evals), evecs
+-
+-
+-def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
+-    """
+-    Internal functions for computing eigenvalues and eigenstates for a sparse
+-    matrix.
+-    """
+-    N = data.shape[0]
+-    big_vals = np.array([])
+-    small_vals = np.array([])
+-    evecs = None
+-
+-    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
+-    if eigvals == (N - 1):
+-        # calculate all eigenvalues and remove one at output if using sparse
+-        # 1: remove the smallest, -1, remove the largest
+-        remove_one = 1 if (num_small > 0) else -1
+-        eigvals = 0
+-        num_small = num_large = N // 2
+-        num_small += N % 2
+-
+-    if vecs:
+-        if isherm:
+-            if num_large > 0:
+-                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
+-                                                     which='LA', tol=tol,
+-                                                     maxiter=maxiter)
+-            if num_small > 0:
+-                small_vals, small_vecs = sp.linalg.eigsh(
+-                    data, k=num_small, which='SA',
+-                    tol=tol, maxiter=maxiter)
+-
+-        else:
+-            if num_large > 0:
+-                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
+-                                                    which='LR', tol=tol,
+-                                                    maxiter=maxiter)
+-            if num_small > 0:
+-                small_vals, small_vecs = sp.linalg.eigs(
+-                    data, k=num_small, which='SR',
+-                    tol=tol, maxiter=maxiter)
+-
+-        if num_large != 0 and num_small != 0:
+-            evecs = np.hstack([small_vecs, big_vecs])
+-        elif num_large != 0 and num_small == 0:
+-            evecs = big_vecs
+-        elif num_large == 0 and num_small != 0:
+-            evecs = small_vecs
+-    else:
+-        if isherm:
+-            if num_large > 0:
+-                big_vals = sp.linalg.eigsh(
+-                    data, k=num_large, which='LA',
+-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+-            if num_small > 0:
+-                small_vals = sp.linalg.eigsh(
+-                    data, k=num_small, which='SA',
+-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+-        else:
+-            if num_large > 0:
+-                big_vals = sp.linalg.eigs(
+-                    data, k=num_large, which='LR',
+-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+-            if num_small > 0:
+-                small_vals = sp.linalg.eigs(
+-                    data, k=num_small, which='SR',
+-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+-
+-    evals = np.hstack((small_vals, big_vals))
+-    if isherm:
+-        evals = np.real(evals)
+-
+-    _zipped = list(zip(evals, range(len(evals))))
+-    _zipped.sort()
+-    evals, perm = list(zip(*_zipped))
+-
+-    if vecs:
+-        evecs = np.array([evecs[:, k] for k in perm]).T
+-
+-    # remove last element if requesting N-1 eigs and using sparse
+-    if remove_one == 1:
+-        evals = evals[:-1]
+-        if vecs:
+-            evecs = evecs[:, :-1]
+-    elif remove_one == -1:
+-        evals = evals[1:]
+-        if vecs:
+-            evecs = evecs[:, 1:]
+-
+-    return np.array(evals), evecs
+-
+-
+-def _eigs_check_shape(data):
+-    if data.shape[0] != data.shape[1]:
+-        raise TypeError("Can only diagonalize square matrices")
+-
+-
+-def _eigs_fix_eigvals(data, eigvals, sort):
+-    N = data.shape[0]
+-    if eigvals == N:
+-        eigvals = 0
+-    if eigvals > N:
+-        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
+-    if sort not in ('low', 'high'):
+-        raise ValueError("'sort' must be 'low' or 'high'")
+-
+-    # set number of large and small eigenvals/vecs
+-    if eigvals == 0:  # user wants all eigs (default)
+-        num_small = num_large = N // 2
+-        num_small += N % 2
+-    else:  # if user wants only a few eigen vals/vecs
+-        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
+-    return eigvals, num_large, num_small
+-
+-
+-def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
+-             tol=0, maxiter=100000):
+-    """
+-    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
+-    may take some extra keyword arguments in addition to the full documentation
+-    specified in :func:`.eigs`.
+-
+-    This method is typically slower and less accurate than the dense eigenvalue
+-    solver; you probably want that, unless memory concerns deem it impossible.
+-
+-    Extra keyword arguments
+-    -----------------------
+-    tol : float (0)
+-        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
+-        as 0) cause the solver to use machine precision.
+-    maxiter : int (100_000)
+-        Max number of iterations used by sparse eigensolver.
+-    """
+-    if not isinstance(data, CSR):
+-        raise TypeError("expected data in CSR format but got "
+-                        + str(type(data)))
+-    if data.shape[0] < 4:
+-        # For small matrix, the sparse solver can't compute all eigenvalues.
+-        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
+-    _eigs_check_shape(data)
+-    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
+-    isherm = isherm if isherm is not None else _isherm(data)
+-    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
+-                             num_large, num_small, tol, maxiter)
+-
+-    if vecs and isherm:
+-        i = 0
+-        while i < len(evals):
+-            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
+-            # orthogonalize vectors 1 .. k with respect to the first, then
+-            # 2 .. k with respect to the second, and so on. Relies on both the
+-            # order of each pair and the ordering of pairs returned by
+-            # combinations.
+-            for k, l in combinations(range(num_degen), 2):
+-                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
+-            i += num_degen
+-
+-    if sort == 'high':
+-        # Flip arrays around.
+-        if vecs:
+-            evecs = np.fliplr(evecs)
+-        evals = evals[::-1]
+-    return (evals, Dense(evecs, copy=False)) if vecs else evals
+-
+-
+-def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
+-    """
+-    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
+-    keyword arguments; see the primary documentation in :func:`.eigs`.
+-    """
+-    if not isinstance(data, Dense):
+-        raise TypeError("expected data in Dense format but got "
+-                        + str(type(data)))
+-    _eigs_check_shape(data)
+-    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
+-    isherm = isherm if isherm is not None else _isherm(data)
+-    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
+-                               num_large, num_small)
+-    if sort == 'high':
+-        # Flip arrays around.
+-        if vecs:
+-            evecs = np.fliplr(evecs)
+-        evals = evals[::-1]
+-    return (evals, Dense(evecs, copy=False)) if vecs else evals
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-
+-# We use eigs_dense as the signature source, since in this case it has the
+-# complete signature that we allow, so we don't need to manually set it.
+-eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
+-eigs.__doc__ =\
+-    """
+-    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
+-
+-    Some particular specialisations of this function may take additional
+-    keyword arguments (such as the CSR solver).  See their particular
+-    docstrings for details on those.
+-
+-    Parameters
+-    ----------
+-    data : Data
+-        Input matrix
+-    isherm : bool, optional
+-        Indicate whether the matrix is Hermitian or not.  There are special
+-        Hermitian eigenvalue and -vector solvers for this case, which will take
+-        care of orthonormalisation and ensuring better accuracy.  If this is
+-        not specified either way, it will be calculated from the data.
+-    vecs : bool, optional (True)
+-        Whether the eigenvectors should be returned as well.
+-    sort : {'low', 'high'}, optional
+-        Sort the output of the eigenvalues and -vectors ordered by the relevant
+-        size of the real part of the eigenvalue from 'low' to high or from
+-        'high' to low.  If not all of the eigenvalues are requested, this
+-        influences which eigenvalues will be found.
+-    eigvals : int, optional
+-        Number of eigenvalues and -vectors to return.  If `0`, then returns
+-        all.
+-
+-    Returns
+-    -------
+-    eigenvalues : np.ndarray
+-        The requested eigenvalues, sorted in the expected order.  The dtype is
+-        `np.complex128`, unless `isherm=True`, in which case it will be
+-        `np.float64`.
+-    eigenvectors : Data
+-        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
+-        order of the eigenvalues.
+-    """
+-eigs.add_specialisations([
+-    (CSR, eigs_csr),
+-    (Dense, eigs_dense),
+-], _defer=True)
+-
+-
+-def svd_csr(data, vecs=True, k=6, **kw):
+-    """
+-    Singular Value Decomposition:
+-
+-    ``data = U @ S @ Vh``
+-
+-    Where ``S`` is diagonal.
+-
+-    Parameters
+-    ----------
+-    data : Data
+-        Input matrix
+-    vecs : bool, optional (True)
+-        Whether the singular vectors (``U``, ``Vh``) should be returned.
+-    k : int, optional (6)
+-        Number of state to compute, default is ``6`` to match scipy's default.
+-    **kw : dict
+-        Options to pass to ``scipy.sparse.linalg.svds``.
+-
+-    Returns
+-    -------
+-    U : Dense
+-        Left singular vectors as columns. Only returned if ``vecs == True``.
+-        shape = (data.shape[0], k)
+-    S : np.ndarray
+-        The ``k``'s largest singular values.
+-    Vh : Dense
+-        Right singular vectors as rows. Only returned if ``vecs == True``.
+-        shape = (k, data.shape[1])
+-
+-    .. note::
+-        svds cannot compute all states at once. While it could find the
+-        largest and smallest in 2 calls, it has issues converging with when
+-        solving for the smallest (finding the 5 smallest in a 50x50 matrix
+-        can fail with default options). It should be used when not all states
+-        are needed.
+-    """
+-    out = scipy.sparse.linalg.svds(
+-        data.as_scipy(), k, return_singular_vectors=vecs, **kw
+-    )
+-    if vecs:
+-        u, s, vh = out
+-        return Dense(u, copy=False), s, Dense(vh, copy=False)
+-    return out
+-
+-
+-def svd_dense(data, vecs=True, **kw):
+-    """
+-    Singular Value Decomposition:
+-
+-    ``data = U @ S @ Vh``
+-
+-    Where ``S`` is diagonal.
+-
+-    Parameters
+-    ----------
+-    data : Data
+-        Input matrix
+-    vecs : bool, optional (True)
+-        Whether the singular vectors (``U``, ``Vh``) should be returned.
+-    **kw : dict
+-        Options to pass to ``scipy.linalg.svd``.
+-
+-    Returns
+-    -------
+-    U : Dense
+-        Left singular vectors as columns. Only returned if ``vecs == True``.
+-    S : np.ndarray
+-        Singular values.
+-    Vh : Dense
+-        Right singular vectors as rows. Only returned if ``vecs == True``.
+-    """
+-    out = scipy.linalg.svd(
+-        data.to_array(), compute_uv=vecs, **kw
+-    )
+-    if vecs:
+-        u, s, vh = out
+-        return Dense(u, copy=False), s, Dense(vh, copy=False)
+-    return out
+-
+-
+-svd = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='svd',
+-    module=__name__,
+-    inputs=('data',),
+-    out=False)
+-svd.__doc__ =\
+-    """
+-    Singular Value Decomposition:
+-
+-    ``data = U @ S @ Vh``
+-
+-    Where ``S`` is diagonal.
+-
+-    Parameters
+-    ----------
+-    data : Data
+-        Input matrix
+-    vecs : bool, optional (True)
+-        Whether the singular vectors (``U``, ``Vh``) should be returned.
+-
+-    Returns
+-    -------
+-    U : Dense
+-        Left singular vectors as columns. Only returned if ``vecs == True``.
+-    S : np.ndarray
+-        Singular values.
+-    Vh : Dense
+-        Right singular vectors as rows. Only returned if ``vecs == True``.
+-    """
+-# Dense implementation return all states, but sparse implementation compute
+-# only a few states. So only the dense version is registered.
+-svd.add_specialisations([
+-    (Dense, svd_dense),
+-], _defer=True)
+-
+-
+-del _Dispatcher
+-del _inspect
++import numpy as np
++import scipy.linalg
++import scipy.sparse as sp
++import scipy.sparse.linalg
++from itertools import combinations
++
++from .dense import Dense, from_csr
++from .csr import CSR
++from .properties import isherm as _isherm
++from qutip.settings import settings
++
++__all__ = [
++    'eigs', 'eigs_csr', 'eigs_dense',
++    'svd', 'svd_csr', 'svd_dense',
++]
++
++
++def _orthogonalize(vec, other):
++    cross = np.sum(np.conj(other) * vec)
++    vec -= cross * other
++    norm = np.sum(np.conj(vec) * vec)**0.5
++    vec /= norm
++
++
++if settings.eigh_unsafe:
++    def eigh(mat, eigvals=None):
++        val, vec = scipy.linalg.eig(mat)
++        val = np.real(val)
++        idx = np.argsort(val)
++        val = val[idx]
++        vec = vec[:, idx]
++        if eigvals:
++            val = val[eigvals[0]:eigvals[1]+1]
++            vec = vec[:, eigvals[0]:eigvals[1]+1]
++        same_eigv = 0
++        for i in range(1, len(val)):
++            if abs(val[i] - val[i-1]) < 1e-12:
++                same_eigv += 1
++                for j in range(same_eigv):
++                    _orthogonalize(vec[:, i], vec[:, i-j-1])
++            else:
++                same_eigv = 0
++        return val, vec
++
++    def eigvalsh(a, eigvals=None):
++        val = scipy.linalg.eigvals(a)
++        val = np.sort(np.real(val))
++        if eigvals:
++            return val[eigvals[0]:eigvals[1]+1]
++        return val
++else:
++    eigh = scipy.linalg.eigh
++    eigvalsh = scipy.linalg.eigvalsh
++
++
++def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
++    """
++    Internal functions for computing eigenvalues and eigenstates for a dense
++    matrix.
++    """
++    N = data.shape[0]
++    kwargs = {}
++    if eigvals != 0 and isherm:
++        kwargs['subset_by_index'] = (
++            [0, num_small-1] if num_small else [N-num_large, N-1]
++        )
++    if vecs:
++        driver = eigh if isherm else scipy.linalg.eig
++        evals, evecs = driver(data, **kwargs)
++    else:
++        driver = eigvalsh if isherm else scipy.linalg.eigvals
++        evals = driver(data, **kwargs)
++        evecs = None
++
++    _zipped = list(zip(evals, range(len(evals))))
++    _zipped.sort()
++    evals, perm = list(zip(*_zipped))
++
++    if vecs:
++        evecs = np.array([evecs[:, k] for k in perm]).T
++
++    if not isherm and eigvals > 0:
++        if vecs:
++            if num_small > 0:
++                evals, evecs = evals[:num_small], evecs[:, :num_small]
++            elif num_large > 0:
++                evals = evals[(N - num_large):]
++                evecs = evecs[:, (N - num_large):]
++        else:
++            if num_small > 0:
++                evals = evals[:num_small]
++            elif num_large > 0:
++                evals = evals[(N - num_large):]
++    return np.array(evals), evecs
++
++
++def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
++    """
++    Internal functions for computing eigenvalues and eigenstates for a sparse
++    matrix.
++    """
++    N = data.shape[0]
++    big_vals = np.array([])
++    small_vals = np.array([])
++    evecs = None
++
++    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
++    if eigvals == (N - 1):
++        # calculate all eigenvalues and remove one at output if using sparse
++        # 1: remove the smallest, -1, remove the largest
++        remove_one = 1 if (num_small > 0) else -1
++        eigvals = 0
++        num_small = num_large = N // 2
++        num_small += N % 2
++
++    if vecs:
++        if isherm:
++            if num_large > 0:
++                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
++                                                     which='LA', tol=tol,
++                                                     maxiter=maxiter)
++            if num_small > 0:
++                small_vals, small_vecs = sp.linalg.eigsh(
++                    data, k=num_small, which='SA',
++                    tol=tol, maxiter=maxiter)
++
++        else:
++            if num_large > 0:
++                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
++                                                    which='LR', tol=tol,
++                                                    maxiter=maxiter)
++            if num_small > 0:
++                small_vals, small_vecs = sp.linalg.eigs(
++                    data, k=num_small, which='SR',
++                    tol=tol, maxiter=maxiter)
++
++        if num_large != 0 and num_small != 0:
++            evecs = np.hstack([small_vecs, big_vecs])
++        elif num_large != 0 and num_small == 0:
++            evecs = big_vecs
++        elif num_large == 0 and num_small != 0:
++            evecs = small_vecs
++    else:
++        if isherm:
++            if num_large > 0:
++                big_vals = sp.linalg.eigsh(
++                    data, k=num_large, which='LA',
++                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
++            if num_small > 0:
++                small_vals = sp.linalg.eigsh(
++                    data, k=num_small, which='SA',
++                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
++        else:
++            if num_large > 0:
++                big_vals = sp.linalg.eigs(
++                    data, k=num_large, which='LR',
++                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
++            if num_small > 0:
++                small_vals = sp.linalg.eigs(
++                    data, k=num_small, which='SR',
++                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
++
++    evals = np.hstack((small_vals, big_vals))
++    if isherm:
++        evals = np.real(evals)
++
++    _zipped = list(zip(evals, range(len(evals))))
++    _zipped.sort()
++    evals, perm = list(zip(*_zipped))
++
++    if vecs:
++        evecs = np.array([evecs[:, k] for k in perm]).T
++
++    # remove last element if requesting N-1 eigs and using sparse
++    if remove_one == 1:
++        evals = evals[:-1]
++        if vecs:
++            evecs = evecs[:, :-1]
++    elif remove_one == -1:
++        evals = evals[1:]
++        if vecs:
++            evecs = evecs[:, 1:]
++
++    return np.array(evals), evecs
++
++
++def _eigs_check_shape(data):
++    if data.shape[0] != data.shape[1]:
++        raise TypeError("Can only diagonalize square matrices")
++
++
++def _eigs_fix_eigvals(data, eigvals, sort):
++    N = data.shape[0]
++    if eigvals == N:
++        eigvals = 0
++    if eigvals > N:
++        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
++    if sort not in ('low', 'high'):
++        raise ValueError("'sort' must be 'low' or 'high'")
++
++    # set number of large and small eigenvals/vecs
++    if eigvals == 0:  # user wants all eigs (default)
++        num_small = num_large = N // 2
++        num_small += N % 2
++    else:  # if user wants only a few eigen vals/vecs
++        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
++    return eigvals, num_large, num_small
++
++
++def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
++             tol=0, maxiter=100000):
++    """
++    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
++    may take some extra keyword arguments in addition to the full documentation
++    specified in :func:`.eigs`.
++
++    This method is typically slower and less accurate than the dense eigenvalue
++    solver; you probably want that, unless memory concerns deem it impossible.
++
++    Extra keyword arguments
++    -----------------------
++    tol : float (0)
++        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
++        as 0) cause the solver to use machine precision.
++    maxiter : int (100_000)
++        Max number of iterations used by sparse eigensolver.
++    """
++    if not isinstance(data, CSR):
++        raise TypeError("expected data in CSR format but got "
++                        + str(type(data)))
++    if data.shape[0] < 4:
++        # For small matrix, the sparse solver can't compute all eigenvalues.
++        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
++    _eigs_check_shape(data)
++    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
++    isherm = isherm if isherm is not None else _isherm(data)
++    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
++                             num_large, num_small, tol, maxiter)
++
++    if vecs and isherm:
++        i = 0
++        while i < len(evals):
++            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
++            # orthogonalize vectors 1 .. k with respect to the first, then
++            # 2 .. k with respect to the second, and so on. Relies on both the
++            # order of each pair and the ordering of pairs returned by
++            # combinations.
++            for k, l in combinations(range(num_degen), 2):
++                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
++            i += num_degen
++
++    if sort == 'high':
++        # Flip arrays around.
++        if vecs:
++            evecs = np.fliplr(evecs)
++        evals = evals[::-1]
++    return (evals, Dense(evecs, copy=False)) if vecs else evals
++
++
++def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
++    """
++    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
++    keyword arguments; see the primary documentation in :func:`.eigs`.
++    """
++    if not isinstance(data, Dense):
++        raise TypeError("expected data in Dense format but got "
++                        + str(type(data)))
++    _eigs_check_shape(data)
++    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
++    isherm = isherm if isherm is not None else _isherm(data)
++    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
++                               num_large, num_small)
++    if sort == 'high':
++        # Flip arrays around.
++        if vecs:
++            evecs = np.fliplr(evecs)
++        evals = evals[::-1]
++    return (evals, Dense(evecs, copy=False)) if vecs else evals
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++
++# We use eigs_dense as the signature source, since in this case it has the
++# complete signature that we allow, so we don't need to manually set it.
++eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
++eigs.__doc__ =\
++    """
++    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
++
++    Some particular specialisations of this function may take additional
++    keyword arguments (such as the CSR solver).  See their particular
++    docstrings for details on those.
++
++    Parameters
++    ----------
++    data : Data
++        Input matrix
++    isherm : bool, optional
++        Indicate whether the matrix is Hermitian or not.  There are special
++        Hermitian eigenvalue and -vector solvers for this case, which will take
++        care of orthonormalisation and ensuring better accuracy.  If this is
++        not specified either way, it will be calculated from the data.
++    vecs : bool, optional (True)
++        Whether the eigenvectors should be returned as well.
++    sort : {'low', 'high'}, optional
++        Sort the output of the eigenvalues and -vectors ordered by the relevant
++        size of the real part of the eigenvalue from 'low' to high or from
++        'high' to low.  If not all of the eigenvalues are requested, this
++        influences which eigenvalues will be found.
++    eigvals : int, optional
++        Number of eigenvalues and -vectors to return.  If `0`, then returns
++        all.
++
++    Returns
++    -------
++    eigenvalues : np.ndarray
++        The requested eigenvalues, sorted in the expected order.  The dtype is
++        `np.complex128`, unless `isherm=True`, in which case it will be
++        `np.float64`.
++    eigenvectors : Data
++        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
++        order of the eigenvalues.
++    """
++eigs.add_specialisations([
++    (CSR, eigs_csr),
++    (Dense, eigs_dense),
++], _defer=True)
++
++
++def svd_csr(data, vecs=True, k=6, **kw):
++    """
++    Singular Value Decomposition:
++
++    ``data = U @ S @ Vh``
++
++    Where ``S`` is diagonal.
++
++    Parameters
++    ----------
++    data : Data
++        Input matrix
++    vecs : bool, optional (True)
++        Whether the singular vectors (``U``, ``Vh``) should be returned.
++    k : int, optional (6)
++        Number of state to compute, default is ``6`` to match scipy's default.
++    **kw : dict
++        Options to pass to ``scipy.sparse.linalg.svds``.
++
++    Returns
++    -------
++    U : Dense
++        Left singular vectors as columns. Only returned if ``vecs == True``.
++        shape = (data.shape[0], k)
++    S : np.ndarray
++        The ``k``'s largest singular values.
++    Vh : Dense
++        Right singular vectors as rows. Only returned if ``vecs == True``.
++        shape = (k, data.shape[1])
++
++    .. note::
++        svds cannot compute all states at once. While it could find the
++        largest and smallest in 2 calls, it has issues converging with when
++        solving for the smallest (finding the 5 smallest in a 50x50 matrix
++        can fail with default options). It should be used when not all states
++        are needed.
++    """
++    out = scipy.sparse.linalg.svds(
++        data.as_scipy(), k, return_singular_vectors=vecs, **kw
++    )
++    if vecs:
++        u, s, vh = out
++        return Dense(u, copy=False), s, Dense(vh, copy=False)
++    return out
++
++
++def svd_dense(data, vecs=True, **kw):
++    """
++    Singular Value Decomposition:
++
++    ``data = U @ S @ Vh``
++
++    Where ``S`` is diagonal.
++
++    Parameters
++    ----------
++    data : Data
++        Input matrix
++    vecs : bool, optional (True)
++        Whether the singular vectors (``U``, ``Vh``) should be returned.
++    **kw : dict
++        Options to pass to ``scipy.linalg.svd``.
++
++    Returns
++    -------
++    U : Dense
++        Left singular vectors as columns. Only returned if ``vecs == True``.
++    S : np.ndarray
++        Singular values.
++    Vh : Dense
++        Right singular vectors as rows. Only returned if ``vecs == True``.
++    """
++    out = scipy.linalg.svd(
++        data.to_array(), compute_uv=vecs, **kw
++    )
++    if vecs:
++        u, s, vh = out
++        return Dense(u, copy=False), s, Dense(vh, copy=False)
++    return out
++
++
++svd = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='svd',
++    module=__name__,
++    inputs=('data',),
++    out=False)
++svd.__doc__ =\
++    """
++    Singular Value Decomposition:
++
++    ``data = U @ S @ Vh``
++
++    Where ``S`` is diagonal.
++
++    Parameters
++    ----------
++    data : Data
++        Input matrix
++    vecs : bool, optional (True)
++        Whether the singular vectors (``U``, ``Vh``) should be returned.
++
++    Returns
++    -------
++    U : Dense
++        Left singular vectors as columns. Only returned if ``vecs == True``.
++    S : np.ndarray
++        Singular values.
++    Vh : Dense
++        Right singular vectors as rows. Only returned if ``vecs == True``.
++    """
++# Dense implementation return all states, but sparse implementation compute
++# only a few states. So only the dense version is registered.
++svd.add_specialisations([
++    (Dense, svd_dense),
++], _defer=True)
++
++
++del _Dispatcher
++del _inspect
+diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
+index 4e7d2af1..da6ab987 100644
+--- a/qutip/core/data/expect.pxd
++++ b/qutip/core/data/expect.pxd
+@@ -1,16 +1,16 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from qutip.core.data cimport CSR, Dense, Data
+-
+-cpdef double complex expect_csr(CSR op, CSR state) nogil except *
+-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
+-
+-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
+-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
+-
+-cpdef double complex expect_dense(Dense op, Dense state) nogil except *
+-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
+-
+-cdef double complex expect_data_dense(Data op, Dense state) except *
+-cdef double complex expect_super_data_dense(Data op, Dense state) except *
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from qutip.core.data cimport CSR, Dense, Data
++
++cpdef double complex expect_csr(CSR op, CSR state) nogil except *
++cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
++
++cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
++cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
++
++cpdef double complex expect_dense(Dense op, Dense state) nogil except *
++cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
++
++cdef double complex expect_data_dense(Data op, Dense state) except *
++cdef double complex expect_super_data_dense(Data op, Dense state) except *
+diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
+index 9b208994..72903acb 100644
+--- a/qutip/core/data/expect.pyx
++++ b/qutip/core/data/expect.pyx
+@@ -1,325 +1,325 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-# The exported function `expect(op, state)` is equivalent to
+-# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
+-# `trace(op @ state)` if state is a density matrix, but it's optimised to not
+-# make unnecessary extra allocations, or calculate extra factors.
+-
+-from libc.math cimport sqrt
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex conj(double complex x)
+-
+-from qutip.core.data.base cimport idxint, Data
+-from qutip.core.data cimport csr, CSR, Dense
+-
+-__all__ = [
+-    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
+-    'expect_super', 'expect_super_csr',
+-    'expect_super_csr_dense', 'expect_super_dense',
+-]
+-
+-cdef void _check_shape_ket(Data op, Data state) nogil except *:
+-    if (
+-        op.shape[1] != state.shape[0]  # Matrix multiplication
+-        or state.shape[1] != 1  # State is ket
+-        or op.shape[0] != op.shape[1]  # op must be square matrix
+-    ):
+-        raise ValueError("incorrect input shapes "
+-                         + str(op.shape) + " and " + str(state.shape))
+-
+-cdef void _check_shape_dm(Data op, Data state) nogil except *:
+-    if (
+-        op.shape[1] != state.shape[0]  # Matrix multiplication
+-        or state.shape[0] != state.shape[1]  # State is square 
+-        or op.shape[0] != op.shape[1]  # Op is square
+-    ):
+-        raise ValueError("incorrect input shapes "
+-                         + str(op.shape) + " and " + str(state.shape))
+-
+-cdef void _check_shape_super(Data op, Data state) nogil except *:
+-    if state.shape[1] != 1:
+-        raise ValueError("expected a column-stacked matrix")
+-    if (
+-        op.shape[1] != state.shape[0]  # Matrix multiplication
+-        or op.shape[0] != op.shape[1]  # Square matrix
+-    ):
+-        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
+-
+-
+-cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
+-    """
+-    Perform the operation
+-        state.adjoint() @ op @ state
+-    for a ket `state` and a square operator `op`.
+-    """
+-    _check_shape_ket(op, state)
+-    cdef double complex out=0, sum=0, mul
+-    cdef size_t row, col, ptr_op, ptr_ket
+-    for row in range(state.shape[0]):
+-        ptr_ket = state.row_index[row]
+-        if ptr_ket == state.row_index[row + 1]:
+-            continue
+-        sum = 0
+-        mul = conj(state.data[ptr_ket])
+-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+-            col = op.col_index[ptr_op]
+-            ptr_ket = state.row_index[col]
+-            if ptr_ket != state.row_index[col + 1]:
+-                sum += op.data[ptr_op] * state.data[ptr_ket]
+-        out += mul * sum
+-    return out
+-
+-cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
+-    """
+-    Perform the operation
+-        tr(op @ state)
+-    for an operator `op` and a density matrix `state`.
+-    """
+-    _check_shape_dm(op, state)
+-    cdef double complex out=0
+-    cdef size_t row, col, ptr_op, ptr_state
+-    for row in range(op.shape[0]):
+-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+-            col = op.col_index[ptr_op]
+-            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
+-                if state.col_index[ptr_state] == row:
+-                    out += op.data[ptr_op] * state.data[ptr_state]
+-                    break
+-    return out
+-
+-
+-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
+-    """
+-    Perform the operation `tr(op @ state)` where `op` is supplied as a
+-    superoperator, and `state` is a column-stacked operator.
+-    """
+-    _check_shape_super(op, state)
+-    cdef double complex out = 0.0
+-    cdef size_t row=0, ptr, col
+-    cdef size_t n = <size_t> sqrt(state.shape[0])
+-    for _ in range(n):
+-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+-            col = op.col_index[ptr]
+-            if state.row_index[col] != state.row_index[col + 1]:
+-                out += op.data[ptr] * state.data[state.row_index[col]]
+-        row += n + 1
+-    return out
+-
+-
+-cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
+-    """
+-    Get the expectation value of the operator `op` over the state `state`.  The
+-    state can be either a ket or a density matrix.
+-
+-    The expectation of a state is defined as the operation:
+-        state.adjoint() @ op @ state
+-    and of a density matrix:
+-        tr(op @ state)
+-    """
+-    if state.shape[1] == 1:
+-        return _expect_csr_ket(op, state)
+-    return _expect_csr_dm(op, state)
+-
+-cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
+-    _check_shape_ket(op, state)
+-    cdef double complex out=0, sum
+-    cdef size_t row, ptr
+-    for row in range(op.shape[0]):
+-        if op.row_index[row] == op.row_index[row + 1]:
+-            continue
+-        sum = 0
+-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+-            sum += op.data[ptr] * state.data[op.col_index[ptr]]
+-        out += sum * conj(state.data[row])
+-    return out
+-
+-cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
+-    _check_shape_dm(op, state)
+-    cdef double complex out=0
+-    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
+-    row_stride = 1 if state.fortran else state.shape[1]
+-    col_stride = state.shape[0] if state.fortran else 1
+-    for row in range(op.shape[0]):
+-        if op.row_index[row] == op.row_index[row + 1]:
+-            continue
+-        ptr_state = row * col_stride
+-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+-            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
+-    return out
+-
+-
+-cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
+-    _check_shape_ket(op, state)
+-    cdef double complex out=0, sum
+-    cdef size_t row, col, op_row_stride, op_col_stride
+-    op_row_stride = 1 if op.fortran else op.shape[1]
+-    op_col_stride = op.shape[0] if op.fortran else 1
+-
+-    for row in range(op.shape[0]):
+-        sum = 0
+-        for col in range(op.shape[0]):
+-            sum += (op.data[row * op_row_stride + col * op_col_stride] *
+-                    state.data[col])
+-        out += sum * conj(state.data[row])
+-    return out
+-
+-cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
+-    _check_shape_dm(op, state)
+-    cdef double complex out=0
+-    cdef size_t row, col, op_row_stride, op_col_stride
+-    cdef size_t state_row_stride, state_col_stride
+-    state_row_stride = 1 if state.fortran else state.shape[1]
+-    state_col_stride = state.shape[0] if state.fortran else 1
+-    op_row_stride = 1 if op.fortran else op.shape[1]
+-    op_col_stride = op.shape[0] if op.fortran else 1
+-
+-    for row in range(op.shape[0]):
+-        for col in range(op.shape[1]):
+-            out += op.data[row * op_row_stride + col * op_col_stride] * \
+-                   state.data[col * state_row_stride + row * state_col_stride]
+-    return out
+-
+-
+-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
+-    """
+-    Get the expectation value of the operator `op` over the state `state`.  The
+-    state can be either a ket or a density matrix.
+-
+-    The expectation of a state is defined as the operation:
+-        state.adjoint() @ op @ state
+-    and of a density matrix:
+-        tr(op @ state)
+-    """
+-    if state.shape[1] == 1:
+-        return _expect_csr_dense_ket(op, state)
+-    return _expect_csr_dense_dm(op, state)
+-
+-
+-cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
+-    """
+-    Get the expectation value of the operator `op` over the state `state`.  The
+-    state can be either a ket or a density matrix.
+-
+-    The expectation of a state is defined as the operation:
+-        state.adjoint() @ op @ state
+-    and of a density matrix:
+-        tr(op @ state)
+-    """
+-    if state.shape[1] == 1:
+-        return _expect_dense_ket(op, state)
+-    return _expect_dense_dense_dm(op, state)
+-
+-
+-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
+-    """
+-    Perform the operation `tr(op @ state)` where `op` is supplied as a
+-    superoperator, and `state` is a column-stacked operator.
+-    """
+-    _check_shape_super(op, state)
+-    cdef double complex out=0
+-    cdef size_t row=0, ptr
+-    cdef size_t n = <size_t> sqrt(state.shape[0])
+-    for _ in range(n):
+-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+-            out += op.data[ptr] * state.data[op.col_index[ptr]]
+-        row += n + 1
+-    return out
+-
+-
+-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
+-    """
+-    Perform the operation `tr(op @ state)` where `op` is supplied as a
+-    superoperator, and `state` is a column-stacked operator.
+-    """
+-    _check_shape_super(op, state)
+-    cdef double complex out=0
+-    cdef size_t row=0, col, N = state.shape[0]
+-    cdef size_t n = <size_t> sqrt(state.shape[0])
+-    cdef size_t op_row_stride, op_col_stride
+-    op_row_stride = 1 if op.fortran else op.shape[1]
+-    op_col_stride = op.shape[0] if op.fortran else 1
+-
+-    for _ in range(n):
+-        for col in range(N):
+-            out += op.data[row * op_row_stride + col * op_col_stride] * \
+-                   state.data[col]
+-        row += n + 1
+-    return out
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-expect = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='expect',
+-    module=__name__,
+-    inputs=('op', 'state'),
+-    out=False,
+-)
+-expect.__doc__ =\
+-    """
+-    Get the expectation value of the operator `op` over the state `state`.  The
+-    state can be either a ket or a density matrix.  Returns a complex number.
+-
+-    The expectation of a state is defined as the operation:
+-        state.adjoint() @ op @ state
+-    and of a density matrix:
+-        tr(op @ state)
+-    """
+-expect.add_specialisations([
+-    (CSR, CSR, expect_csr),
+-    (CSR, Dense, expect_csr_dense),
+-    (Dense, Dense, expect_dense),
+-], _defer=True)
+-
+-expect_super = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='expect_super',
+-    module=__name__,
+-    inputs=('op', 'state'),
+-    out=False,
+-)
+-expect_super.__doc__ =\
+-    """
+-    Perform the operation `tr(op @ state)` where `op` is supplied as a
+-    superoperator, and `state` is a column-stacked operator.  Returns a complex
+-    number.
+-    """
+-expect_super.add_specialisations([
+-    (CSR, CSR, expect_super_csr),
+-    (CSR, Dense, expect_super_csr_dense),
+-    (Dense, Dense, expect_super_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
+-
+-
+-cdef double complex expect_data_dense(Data op, Dense state) except *:
+-    cdef double complex out
+-    if type(op) is CSR:
+-        out = expect_csr_dense(op, state)
+-    elif type(op) is Dense:
+-        out = expect_dense(op, state)
+-    else:
+-        out = expect(op, state)
+-    return out
+-
+-
+-cdef double complex expect_super_data_dense(Data op, Dense state) except *:
+-    cdef double complex out
+-    if type(op) is CSR:
+-        out = expect_super_csr_dense(op, state)
+-    elif type(op) is Dense:
+-        out = expect_super_dense(op, state)
+-    else:
+-        out = expect_super(op, state)
+-    return out
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++# The exported function `expect(op, state)` is equivalent to
++# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
++# `trace(op @ state)` if state is a density matrix, but it's optimised to not
++# make unnecessary extra allocations, or calculate extra factors.
++
++from libc.math cimport sqrt
++
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex conj(double complex x)
++
++from qutip.core.data.base cimport idxint, Data
++from qutip.core.data cimport csr, CSR, Dense
++
++__all__ = [
++    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
++    'expect_super', 'expect_super_csr',
++    'expect_super_csr_dense', 'expect_super_dense',
++]
++
++cdef void _check_shape_ket(Data op, Data state) nogil except *:
++    if (
++        op.shape[1] != state.shape[0]  # Matrix multiplication
++        or state.shape[1] != 1  # State is ket
++        or op.shape[0] != op.shape[1]  # op must be square matrix
++    ):
++        raise ValueError("incorrect input shapes "
++                         + str(op.shape) + " and " + str(state.shape))
++
++cdef void _check_shape_dm(Data op, Data state) nogil except *:
++    if (
++        op.shape[1] != state.shape[0]  # Matrix multiplication
++        or state.shape[0] != state.shape[1]  # State is square 
++        or op.shape[0] != op.shape[1]  # Op is square
++    ):
++        raise ValueError("incorrect input shapes "
++                         + str(op.shape) + " and " + str(state.shape))
++
++cdef void _check_shape_super(Data op, Data state) nogil except *:
++    if state.shape[1] != 1:
++        raise ValueError("expected a column-stacked matrix")
++    if (
++        op.shape[1] != state.shape[0]  # Matrix multiplication
++        or op.shape[0] != op.shape[1]  # Square matrix
++    ):
++        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
++
++
++cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
++    """
++    Perform the operation
++        state.adjoint() @ op @ state
++    for a ket `state` and a square operator `op`.
++    """
++    _check_shape_ket(op, state)
++    cdef double complex out=0, sum=0, mul
++    cdef size_t row, col, ptr_op, ptr_ket
++    for row in range(state.shape[0]):
++        ptr_ket = state.row_index[row]
++        if ptr_ket == state.row_index[row + 1]:
++            continue
++        sum = 0
++        mul = conj(state.data[ptr_ket])
++        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
++            col = op.col_index[ptr_op]
++            ptr_ket = state.row_index[col]
++            if ptr_ket != state.row_index[col + 1]:
++                sum += op.data[ptr_op] * state.data[ptr_ket]
++        out += mul * sum
++    return out
++
++cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
++    """
++    Perform the operation
++        tr(op @ state)
++    for an operator `op` and a density matrix `state`.
++    """
++    _check_shape_dm(op, state)
++    cdef double complex out=0
++    cdef size_t row, col, ptr_op, ptr_state
++    for row in range(op.shape[0]):
++        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
++            col = op.col_index[ptr_op]
++            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
++                if state.col_index[ptr_state] == row:
++                    out += op.data[ptr_op] * state.data[ptr_state]
++                    break
++    return out
++
++
++cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
++    """
++    Perform the operation `tr(op @ state)` where `op` is supplied as a
++    superoperator, and `state` is a column-stacked operator.
++    """
++    _check_shape_super(op, state)
++    cdef double complex out = 0.0
++    cdef size_t row=0, ptr, col
++    cdef size_t n = <size_t> sqrt(state.shape[0])
++    for _ in range(n):
++        for ptr in range(op.row_index[row], op.row_index[row + 1]):
++            col = op.col_index[ptr]
++            if state.row_index[col] != state.row_index[col + 1]:
++                out += op.data[ptr] * state.data[state.row_index[col]]
++        row += n + 1
++    return out
++
++
++cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
++    """
++    Get the expectation value of the operator `op` over the state `state`.  The
++    state can be either a ket or a density matrix.
++
++    The expectation of a state is defined as the operation:
++        state.adjoint() @ op @ state
++    and of a density matrix:
++        tr(op @ state)
++    """
++    if state.shape[1] == 1:
++        return _expect_csr_ket(op, state)
++    return _expect_csr_dm(op, state)
++
++cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
++    _check_shape_ket(op, state)
++    cdef double complex out=0, sum
++    cdef size_t row, ptr
++    for row in range(op.shape[0]):
++        if op.row_index[row] == op.row_index[row + 1]:
++            continue
++        sum = 0
++        for ptr in range(op.row_index[row], op.row_index[row + 1]):
++            sum += op.data[ptr] * state.data[op.col_index[ptr]]
++        out += sum * conj(state.data[row])
++    return out
++
++cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
++    _check_shape_dm(op, state)
++    cdef double complex out=0
++    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
++    row_stride = 1 if state.fortran else state.shape[1]
++    col_stride = state.shape[0] if state.fortran else 1
++    for row in range(op.shape[0]):
++        if op.row_index[row] == op.row_index[row + 1]:
++            continue
++        ptr_state = row * col_stride
++        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
++            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
++    return out
++
++
++cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
++    _check_shape_ket(op, state)
++    cdef double complex out=0, sum
++    cdef size_t row, col, op_row_stride, op_col_stride
++    op_row_stride = 1 if op.fortran else op.shape[1]
++    op_col_stride = op.shape[0] if op.fortran else 1
++
++    for row in range(op.shape[0]):
++        sum = 0
++        for col in range(op.shape[0]):
++            sum += (op.data[row * op_row_stride + col * op_col_stride] *
++                    state.data[col])
++        out += sum * conj(state.data[row])
++    return out
++
++cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
++    _check_shape_dm(op, state)
++    cdef double complex out=0
++    cdef size_t row, col, op_row_stride, op_col_stride
++    cdef size_t state_row_stride, state_col_stride
++    state_row_stride = 1 if state.fortran else state.shape[1]
++    state_col_stride = state.shape[0] if state.fortran else 1
++    op_row_stride = 1 if op.fortran else op.shape[1]
++    op_col_stride = op.shape[0] if op.fortran else 1
++
++    for row in range(op.shape[0]):
++        for col in range(op.shape[1]):
++            out += op.data[row * op_row_stride + col * op_col_stride] * \
++                   state.data[col * state_row_stride + row * state_col_stride]
++    return out
++
++
++cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
++    """
++    Get the expectation value of the operator `op` over the state `state`.  The
++    state can be either a ket or a density matrix.
++
++    The expectation of a state is defined as the operation:
++        state.adjoint() @ op @ state
++    and of a density matrix:
++        tr(op @ state)
++    """
++    if state.shape[1] == 1:
++        return _expect_csr_dense_ket(op, state)
++    return _expect_csr_dense_dm(op, state)
++
++
++cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
++    """
++    Get the expectation value of the operator `op` over the state `state`.  The
++    state can be either a ket or a density matrix.
++
++    The expectation of a state is defined as the operation:
++        state.adjoint() @ op @ state
++    and of a density matrix:
++        tr(op @ state)
++    """
++    if state.shape[1] == 1:
++        return _expect_dense_ket(op, state)
++    return _expect_dense_dense_dm(op, state)
++
++
++cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
++    """
++    Perform the operation `tr(op @ state)` where `op` is supplied as a
++    superoperator, and `state` is a column-stacked operator.
++    """
++    _check_shape_super(op, state)
++    cdef double complex out=0
++    cdef size_t row=0, ptr
++    cdef size_t n = <size_t> sqrt(state.shape[0])
++    for _ in range(n):
++        for ptr in range(op.row_index[row], op.row_index[row + 1]):
++            out += op.data[ptr] * state.data[op.col_index[ptr]]
++        row += n + 1
++    return out
++
++
++cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
++    """
++    Perform the operation `tr(op @ state)` where `op` is supplied as a
++    superoperator, and `state` is a column-stacked operator.
++    """
++    _check_shape_super(op, state)
++    cdef double complex out=0
++    cdef size_t row=0, col, N = state.shape[0]
++    cdef size_t n = <size_t> sqrt(state.shape[0])
++    cdef size_t op_row_stride, op_col_stride
++    op_row_stride = 1 if op.fortran else op.shape[1]
++    op_col_stride = op.shape[0] if op.fortran else 1
++
++    for _ in range(n):
++        for col in range(N):
++            out += op.data[row * op_row_stride + col * op_col_stride] * \
++                   state.data[col]
++        row += n + 1
++    return out
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++expect = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='expect',
++    module=__name__,
++    inputs=('op', 'state'),
++    out=False,
++)
++expect.__doc__ =\
++    """
++    Get the expectation value of the operator `op` over the state `state`.  The
++    state can be either a ket or a density matrix.  Returns a complex number.
++
++    The expectation of a state is defined as the operation:
++        state.adjoint() @ op @ state
++    and of a density matrix:
++        tr(op @ state)
++    """
++expect.add_specialisations([
++    (CSR, CSR, expect_csr),
++    (CSR, Dense, expect_csr_dense),
++    (Dense, Dense, expect_dense),
++], _defer=True)
++
++expect_super = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='expect_super',
++    module=__name__,
++    inputs=('op', 'state'),
++    out=False,
++)
++expect_super.__doc__ =\
++    """
++    Perform the operation `tr(op @ state)` where `op` is supplied as a
++    superoperator, and `state` is a column-stacked operator.  Returns a complex
++    number.
++    """
++expect_super.add_specialisations([
++    (CSR, CSR, expect_super_csr),
++    (CSR, Dense, expect_super_csr_dense),
++    (Dense, Dense, expect_super_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
++
++
++cdef double complex expect_data_dense(Data op, Dense state) except *:
++    cdef double complex out
++    if type(op) is CSR:
++        out = expect_csr_dense(op, state)
++    elif type(op) is Dense:
++        out = expect_dense(op, state)
++    else:
++        out = expect(op, state)
++    return out
++
++
++cdef double complex expect_super_data_dense(Data op, Dense state) except *:
++    cdef double complex out
++    if type(op) is CSR:
++        out = expect_super_csr_dense(op, state)
++    elif type(op) is Dense:
++        out = expect_super_dense(op, state)
++    else:
++        out = expect_super(op, state)
++    return out
+diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
+index 27586d16..5d3bfc61 100644
+--- a/qutip/core/data/expm.py
++++ b/qutip/core/data/expm.py
+@@ -1,93 +1,93 @@
+-import numpy as np
+-import scipy.sparse.linalg
+-import scipy.linalg
+-
+-from .dense import Dense
+-from .csr import CSR
+-from .properties import isdiag_csr
+-from qutip.settings import settings
+-from .base import idxint_dtype
+-
+-__all__ = [
+-    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
+-    'logm', 'logm_dense',
+-]
+-
+-
+-def expm_csr(matrix: CSR) -> CSR:
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("can only exponentiate square matrix")
+-    if isdiag_csr(matrix):
+-        matrix_sci = matrix.as_scipy()
+-        data = np.ones(matrix.shape[0], dtype=np.complex128)
+-        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
+-        return CSR(
+-            (
+-                data,
+-                np.arange(matrix.shape[0], dtype=idxint_dtype),
+-                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
+-            ),
+-            shape=matrix.shape,
+-            copy=False,
+-        )
+-    # The scipy solvers for the Pade approximant are more efficient with the
+-    # CSC format than the CSR one.
+-    csc = matrix.as_scipy().tocsc()
+-    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
+-               tidyup=settings.core['auto_tidyup'])
+-
+-
+-def expm_csr_dense(matrix: CSR) -> Dense:
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("can only exponentiate square matrix")
+-    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
+-
+-
+-def expm_dense(matrix: Dense) -> Dense:
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("can only exponentiate square matrix")
+-    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-
+-expm = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='expm',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
+-expm.add_specialisations([
+-    (CSR, CSR, expm_csr),
+-    (CSR, Dense, expm_csr_dense),
+-    (Dense, Dense, expm_dense),
+-], _defer=True)
+-
+-
+-def logm_dense(matrix: Dense) -> Dense:
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("can only compute logarithm square matrix")
+-    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
+-
+-
+-logm = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='logm',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
+-logm.add_specialisations([
+-    (Dense, Dense, logm_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++import numpy as np
++import scipy.sparse.linalg
++import scipy.linalg
++
++from .dense import Dense
++from .csr import CSR
++from .properties import isdiag_csr
++from qutip.settings import settings
++from .base import idxint_dtype
++
++__all__ = [
++    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
++    'logm', 'logm_dense',
++]
++
++
++def expm_csr(matrix: CSR) -> CSR:
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("can only exponentiate square matrix")
++    if isdiag_csr(matrix):
++        matrix_sci = matrix.as_scipy()
++        data = np.ones(matrix.shape[0], dtype=np.complex128)
++        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
++        return CSR(
++            (
++                data,
++                np.arange(matrix.shape[0], dtype=idxint_dtype),
++                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
++            ),
++            shape=matrix.shape,
++            copy=False,
++        )
++    # The scipy solvers for the Pade approximant are more efficient with the
++    # CSC format than the CSR one.
++    csc = matrix.as_scipy().tocsc()
++    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
++               tidyup=settings.core['auto_tidyup'])
++
++
++def expm_csr_dense(matrix: CSR) -> Dense:
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("can only exponentiate square matrix")
++    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
++
++
++def expm_dense(matrix: Dense) -> Dense:
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("can only exponentiate square matrix")
++    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++
++expm = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='expm',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
++expm.add_specialisations([
++    (CSR, CSR, expm_csr),
++    (CSR, Dense, expm_csr_dense),
++    (Dense, Dense, expm_dense),
++], _defer=True)
++
++
++def logm_dense(matrix: Dense) -> Dense:
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("can only compute logarithm square matrix")
++    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
++
++
++logm = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='logm',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
++logm.add_specialisations([
++    (Dense, Dense, logm_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/inner.pxd b/qutip/core/data/inner.pxd
+index 1d5000dd..2560e435 100644
+--- a/qutip/core/data/inner.pxd
++++ b/qutip/core/data/inner.pxd
+@@ -1,6 +1,6 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-
+-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
+-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++
++cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
++cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
+diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
+index 94919700..47331c71 100644
+--- a/qutip/core/data/inner.pyx
++++ b/qutip/core/data/inner.pyx
+@@ -1,286 +1,286 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex conj(double complex x)
+-
+-from qutip.core.data.base cimport idxint, Data
+-from qutip.core.data cimport csr, dense
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data.matmul cimport matmul_dense
+-
+-__all__ = [
+-    'inner', 'inner_csr', 'inner_dense',
+-    'inner_op', 'inner_op_csr', 'inner_op_dense',
+-]
+-
+-
+-cdef void _check_shape_inner(Data left, Data right) nogil except *:
+-    if (
+-        (left.shape[0] != 1 and left.shape[1] != 1)
+-        or right.shape[1] != 1
+-    ):
+-        raise ValueError(
+-            "incompatible matrix shapes "
+-            + str(left.shape)
+-            + " and "
+-            + str(right.shape)
+-        )
+-
+-cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
+-    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
+-    cdef bint left_op = (
+-        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
+-        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
+-    )
+-    cdef bint op_right = op.shape[1] == right.shape[0]
+-    cdef bint right_shape = right.shape[1] == 1
+-    if not (left_shape and left_op and op_right and right_shape):
+-        raise ValueError("".join([
+-            "incompatible matrix shapes ",
+-            str(left.shape),
+-            ", ",
+-            str(op.shape),
+-            " and ",
+-            str(right.shape),
+-        ]))
+-
+-cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
+-    cdef size_t col, ptr_bra, ptr_ket
+-    cdef double complex out = 0
+-    # We actually don't care if left is sorted or not.
+-    for ptr_bra in range(csr.nnz(left)):
+-        col = left.col_index[ptr_bra]
+-        ptr_ket = right.row_index[col]
+-        if right.row_index[col + 1] != ptr_ket:
+-            out += left.data[ptr_bra] * right.data[ptr_ket]
+-    return out
+-
+-cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
+-    cdef size_t row, ptr_l, ptr_r
+-    cdef double complex out = 0
+-    for row in range(left.shape[0]):
+-        ptr_l = left.row_index[row]
+-        ptr_r = right.row_index[row]
+-        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
+-            out += conj(left.data[ptr_l]) * right.data[ptr_r]
+-    return out
+-
+-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
+-    """
+-    Compute the complex inner product <left|right>.  The shape of `left` is
+-    used to determine if it has been supplied as a ket or a bra.  The result of
+-    this function will be identical if passed `left` or `adjoint(left)`.
+-
+-    The parameter `scalar_is_ket` is only intended for the case where `left`
+-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+-    all other times.
+-    """
+-    _check_shape_inner(left, right)
+-    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+-        if csr.nnz(left) and csr.nnz(right):
+-            return (
+-                conj(left.data[0]) * right.data[0] if scalar_is_ket
+-                else left.data[0] * right.data[0]
+-            )
+-        return 0
+-    if left.shape[0] == 1:
+-        return _inner_csr_bra_ket(left, right)
+-    return _inner_csr_ket_ket(left, right)
+-
+-cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
+-    """
+-    Compute the complex inner product <left|right>.  The shape of `left` is
+-    used to determine if it has been supplied as a ket or a bra.  The result of
+-    this function will be identical if passed `left` or `adjoint(left)`.
+-
+-    The parameter `scalar_is_ket` is only intended for the case where `left`
+-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+-    all other times.
+-    """
+-    _check_shape_inner(left, right)
+-    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+-        return (
+-                conj(left.data[0]) * right.data[0] if scalar_is_ket
+-                else left.data[0] * right.data[0]
+-        )
+-    cdef double complex out = 0
+-    cdef size_t i
+-    if left.shape[0] == 1:
+-        for i in range(right.shape[0]):
+-            out += left.data[i] * right.data[i]
+-    else:
+-        for i in range(right.shape[0]):
+-            out += conj(left.data[i]) * right.data[i]
+-    return out
+-
+-
+-cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
+-    cdef size_t ptr_l, ptr_op, ptr_r, row, col
+-    cdef double complex sum, out=0
+-    # left does not need to be sorted.
+-    for ptr_l in range(csr.nnz(left)):
+-        row = left.col_index[ptr_l]
+-        sum = 0
+-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+-            col = op.col_index[ptr_op]
+-            ptr_r = right.row_index[col]
+-            if ptr_r != right.row_index[col + 1]:
+-                sum += op.data[ptr_op] * right.data[ptr_r]
+-        out += left.data[ptr_l] * sum
+-    return out
+-
+-cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
+-    cdef size_t ptr_l, ptr_op, ptr_r, row, col
+-    cdef double complex sum, out=0
+-    for row in range(op.shape[0]):
+-        ptr_l = left.row_index[row]
+-        if left.row_index[row + 1] == ptr_l:
+-            continue
+-        sum = 0
+-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+-            col = op.col_index[ptr_op]
+-            ptr_r = right.row_index[col]
+-            if ptr_r != right.row_index[col + 1]:
+-                sum += op.data[ptr_op] * right.data[ptr_r]
+-        out += conj(left.data[ptr_l]) * sum
+-    return out
+-
+-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
+-                                  bint scalar_is_ket=False) nogil except *:
+-    """
+-    Compute the complex inner product <left|op|right>.  The shape of `left` is
+-    used to determine if it has been supplied as a ket or a bra.  The result of
+-    this function will be identical if passed `left` or `adjoint(left)`.
+-
+-    The parameter `scalar_is_ket` is only intended for the case where `left`
+-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+-    all other times.
+-    """
+-    _check_shape_inner_op(left, op, right)
+-    cdef double complex l
+-    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
+-        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
+-            return 0
+-        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
+-        return l * op.data[0] * right.data[0]
+-    if left.shape[0] == 1:
+-        return _inner_op_csr_bra_ket(left, op, right)
+-    return _inner_op_csr_ket_ket(left, op, right)
+-
+-cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
+-                                  bint scalar_is_ket=False) except *:
+-    """
+-    Compute the complex inner product <left|op|right>.  The shape of `left` is
+-    used to determine if it has been supplied as a ket or a bra.  The result of
+-    this function will be identical if passed `left` or `adjoint(left)`.
+-
+-    The parameter `scalar_is_ket` is only intended for the case where `left`
+-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+-    all other times.
+-    """
+-    _check_shape_inner_op(left, op, right)
+-    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-inner = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=False),
+-    ]),
+-    name='inner',
+-    module=__name__,
+-    inputs=('left', 'right'),
+-    out=False,
+-)
+-inner.__doc__ =\
+-    """
+-    Compute the complex inner product <left|right>.  Return the complex value.
+-
+-    The shape of `left` is used to determine if it has been supplied as a ket
+-    or a bra.  The result of this function will be identical if passed `left`
+-    or `adjoint(left)`.
+-
+-    The parameter `scalar_is_ket` is only intended for the case where `left`
+-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+-    all other times.
+-
+-    Parameters
+-    ----------
+-    left : Data
+-        The left operand as either a bra or a ket matrix.
+-
+-    right : Data
+-        The right operand as a ket matrix.
+-
+-    scalar_is_ket : bool, optional (False)
+-        If `False`, then `left` is assumed to be a bra if it is
+-        one-dimensional.  If `True`, then it is assumed to be a ket.  This
+-        parameter is ignored if `left` and `right` are not one-dimensional.
+-    """
+-inner.add_specialisations([
+-    (CSR, CSR, inner_csr),
+-    (Dense, Dense, inner_dense),
+-], _defer=True)
+-
+-inner_op = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=False),
+-    ]),
+-    name='inner_op',
+-    module=__name__,
+-    inputs=('left', 'op', 'right'),
+-    out=False,
+-)
+-inner_op.__doc__ =\
+-    """
+-    Compute the complex inner product <left|op|right>.  Return the complex
+-    value.  This operation is also known as taking a matrix element.
+-
+-    The shape of `left` is used to determine if it has been supplied as a ket
+-    or a bra.  The result of this function will be identical if passed `left`
+-    or `adjoint(left)`.
+-
+-    The parameter `scalar_is_ket` is only intended for the case where `left`
+-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+-    all other times.
+-
+-    Parameters
+-    ----------
+-    left : Data
+-        The left operand as either a bra or a ket matrix.
+-
+-    op : Data
+-        The operator of which to take the matrix element.  Must have dimensions
+-        which match `left` and `right`.
+-
+-    right : Data
+-        The right operand as a ket matrix.
+-
+-    scalar_is_ket : bool, optional (False)
+-        If `False`, then `left` is assumed to be a bra if it is
+-        one-dimensional.  If `True`, then it is assumed to be a ket.  This
+-        parameter is ignored if `left` and `right` are not one-dimensional.
+-    """
+-inner_op.add_specialisations([
+-    (CSR, CSR, CSR, inner_op_csr),
+-    (Dense, Dense, Dense, inner_op_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex conj(double complex x)
++
++from qutip.core.data.base cimport idxint, Data
++from qutip.core.data cimport csr, dense
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++from qutip.core.data.matmul cimport matmul_dense
++
++__all__ = [
++    'inner', 'inner_csr', 'inner_dense',
++    'inner_op', 'inner_op_csr', 'inner_op_dense',
++]
++
++
++cdef void _check_shape_inner(Data left, Data right) nogil except *:
++    if (
++        (left.shape[0] != 1 and left.shape[1] != 1)
++        or right.shape[1] != 1
++    ):
++        raise ValueError(
++            "incompatible matrix shapes "
++            + str(left.shape)
++            + " and "
++            + str(right.shape)
++        )
++
++cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
++    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
++    cdef bint left_op = (
++        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
++        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
++    )
++    cdef bint op_right = op.shape[1] == right.shape[0]
++    cdef bint right_shape = right.shape[1] == 1
++    if not (left_shape and left_op and op_right and right_shape):
++        raise ValueError("".join([
++            "incompatible matrix shapes ",
++            str(left.shape),
++            ", ",
++            str(op.shape),
++            " and ",
++            str(right.shape),
++        ]))
++
++cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
++    cdef size_t col, ptr_bra, ptr_ket
++    cdef double complex out = 0
++    # We actually don't care if left is sorted or not.
++    for ptr_bra in range(csr.nnz(left)):
++        col = left.col_index[ptr_bra]
++        ptr_ket = right.row_index[col]
++        if right.row_index[col + 1] != ptr_ket:
++            out += left.data[ptr_bra] * right.data[ptr_ket]
++    return out
++
++cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
++    cdef size_t row, ptr_l, ptr_r
++    cdef double complex out = 0
++    for row in range(left.shape[0]):
++        ptr_l = left.row_index[row]
++        ptr_r = right.row_index[row]
++        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
++            out += conj(left.data[ptr_l]) * right.data[ptr_r]
++    return out
++
++cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
++    """
++    Compute the complex inner product <left|right>.  The shape of `left` is
++    used to determine if it has been supplied as a ket or a bra.  The result of
++    this function will be identical if passed `left` or `adjoint(left)`.
++
++    The parameter `scalar_is_ket` is only intended for the case where `left`
++    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
++    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
++    all other times.
++    """
++    _check_shape_inner(left, right)
++    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
++        if csr.nnz(left) and csr.nnz(right):
++            return (
++                conj(left.data[0]) * right.data[0] if scalar_is_ket
++                else left.data[0] * right.data[0]
++            )
++        return 0
++    if left.shape[0] == 1:
++        return _inner_csr_bra_ket(left, right)
++    return _inner_csr_ket_ket(left, right)
++
++cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
++    """
++    Compute the complex inner product <left|right>.  The shape of `left` is
++    used to determine if it has been supplied as a ket or a bra.  The result of
++    this function will be identical if passed `left` or `adjoint(left)`.
++
++    The parameter `scalar_is_ket` is only intended for the case where `left`
++    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
++    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
++    all other times.
++    """
++    _check_shape_inner(left, right)
++    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
++        return (
++                conj(left.data[0]) * right.data[0] if scalar_is_ket
++                else left.data[0] * right.data[0]
++        )
++    cdef double complex out = 0
++    cdef size_t i
++    if left.shape[0] == 1:
++        for i in range(right.shape[0]):
++            out += left.data[i] * right.data[i]
++    else:
++        for i in range(right.shape[0]):
++            out += conj(left.data[i]) * right.data[i]
++    return out
++
++
++cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
++    cdef size_t ptr_l, ptr_op, ptr_r, row, col
++    cdef double complex sum, out=0
++    # left does not need to be sorted.
++    for ptr_l in range(csr.nnz(left)):
++        row = left.col_index[ptr_l]
++        sum = 0
++        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
++            col = op.col_index[ptr_op]
++            ptr_r = right.row_index[col]
++            if ptr_r != right.row_index[col + 1]:
++                sum += op.data[ptr_op] * right.data[ptr_r]
++        out += left.data[ptr_l] * sum
++    return out
++
++cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
++    cdef size_t ptr_l, ptr_op, ptr_r, row, col
++    cdef double complex sum, out=0
++    for row in range(op.shape[0]):
++        ptr_l = left.row_index[row]
++        if left.row_index[row + 1] == ptr_l:
++            continue
++        sum = 0
++        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
++            col = op.col_index[ptr_op]
++            ptr_r = right.row_index[col]
++            if ptr_r != right.row_index[col + 1]:
++                sum += op.data[ptr_op] * right.data[ptr_r]
++        out += conj(left.data[ptr_l]) * sum
++    return out
++
++cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
++                                  bint scalar_is_ket=False) nogil except *:
++    """
++    Compute the complex inner product <left|op|right>.  The shape of `left` is
++    used to determine if it has been supplied as a ket or a bra.  The result of
++    this function will be identical if passed `left` or `adjoint(left)`.
++
++    The parameter `scalar_is_ket` is only intended for the case where `left`
++    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
++    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
++    all other times.
++    """
++    _check_shape_inner_op(left, op, right)
++    cdef double complex l
++    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
++        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
++            return 0
++        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
++        return l * op.data[0] * right.data[0]
++    if left.shape[0] == 1:
++        return _inner_op_csr_bra_ket(left, op, right)
++    return _inner_op_csr_ket_ket(left, op, right)
++
++cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
++                                  bint scalar_is_ket=False) except *:
++    """
++    Compute the complex inner product <left|op|right>.  The shape of `left` is
++    used to determine if it has been supplied as a ket or a bra.  The result of
++    this function will be identical if passed `left` or `adjoint(left)`.
++
++    The parameter `scalar_is_ket` is only intended for the case where `left`
++    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
++    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
++    all other times.
++    """
++    _check_shape_inner_op(left, op, right)
++    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++inner = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=False),
++    ]),
++    name='inner',
++    module=__name__,
++    inputs=('left', 'right'),
++    out=False,
++)
++inner.__doc__ =\
++    """
++    Compute the complex inner product <left|right>.  Return the complex value.
++
++    The shape of `left` is used to determine if it has been supplied as a ket
++    or a bra.  The result of this function will be identical if passed `left`
++    or `adjoint(left)`.
++
++    The parameter `scalar_is_ket` is only intended for the case where `left`
++    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
++    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
++    all other times.
++
++    Parameters
++    ----------
++    left : Data
++        The left operand as either a bra or a ket matrix.
++
++    right : Data
++        The right operand as a ket matrix.
++
++    scalar_is_ket : bool, optional (False)
++        If `False`, then `left` is assumed to be a bra if it is
++        one-dimensional.  If `True`, then it is assumed to be a ket.  This
++        parameter is ignored if `left` and `right` are not one-dimensional.
++    """
++inner.add_specialisations([
++    (CSR, CSR, inner_csr),
++    (Dense, Dense, inner_dense),
++], _defer=True)
++
++inner_op = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=False),
++    ]),
++    name='inner_op',
++    module=__name__,
++    inputs=('left', 'op', 'right'),
++    out=False,
++)
++inner_op.__doc__ =\
++    """
++    Compute the complex inner product <left|op|right>.  Return the complex
++    value.  This operation is also known as taking a matrix element.
++
++    The shape of `left` is used to determine if it has been supplied as a ket
++    or a bra.  The result of this function will be identical if passed `left`
++    or `adjoint(left)`.
++
++    The parameter `scalar_is_ket` is only intended for the case where `left`
++    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
++    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
++    all other times.
++
++    Parameters
++    ----------
++    left : Data
++        The left operand as either a bra or a ket matrix.
++
++    op : Data
++        The operator of which to take the matrix element.  Must have dimensions
++        which match `left` and `right`.
++
++    right : Data
++        The right operand as a ket matrix.
++
++    scalar_is_ket : bool, optional (False)
++        If `False`, then `left` is assumed to be a bra if it is
++        one-dimensional.  If `True`, then it is assumed to be a ket.  This
++        parameter is ignored if `left` and `right` are not one-dimensional.
++    """
++inner_op.add_specialisations([
++    (CSR, CSR, CSR, inner_op_csr),
++    (Dense, Dense, Dense, inner_op_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/kron.pxd b/qutip/core/data/kron.pxd
+index 6caa2619..89f717f8 100644
+--- a/qutip/core/data/kron.pxd
++++ b/qutip/core/data/kron.pxd
+@@ -1,5 +1,5 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-
+-cpdef CSR kron_csr(CSR left, CSR right)
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++
++cpdef CSR kron_csr(CSR left, CSR right)
+diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
+index fd94adc3..5cd9d569 100644
+--- a/qutip/core/data/kron.pyx
++++ b/qutip/core/data/kron.pyx
+@@ -1,91 +1,91 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-cimport cython
+-
+-from qutip.core.data.base cimport idxint
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data cimport csr
+-import numpy
+-
+-__all__ = [
+-    'kron', 'kron_csr', 'kron_dense'
+-]
+-
+-
+-@cython.overflowcheck(True)
+-cdef idxint _mul_checked(idxint a, idxint b):
+-    return a * b
+-
+-
+-cpdef Dense kron_dense(Dense left, Dense right):
+-    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
+-
+-
+-cpdef CSR kron_csr(CSR left, CSR right):
+-    """Kronecker product of two CSR matrices."""
+-    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
+-    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
+-    cdef idxint row_l, row_r, row_out
+-    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
+-    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
+-    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
+-                             _mul_checked(ncols_l, ncols_r),
+-                             _mul_checked(csr.nnz(left), csr.nnz(right)))
+-    with nogil:
+-        row_out = 0
+-        out.row_index[row_out] = 0
+-        for row_l in range(nrows_l):
+-            ptr_start_l = left.row_index[row_l]
+-            ptr_end_l = left.row_index[row_l + 1]
+-            dist_l = ptr_end_l - ptr_start_l
+-
+-            for row_r in range(nrows_r):
+-                ptr_start_r = right.row_index[row_r]
+-                ptr_end_r = right.row_index[row_r + 1]
+-                dist_r = ptr_end_r - ptr_start_r
+-
+-                ptr_start_out = out.row_index[row_out]
+-                ptr_end_out = ptr_start_out + dist_r
+-
+-                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
+-                row_out += 1
+-
+-                for ptr_l in range(ptr_start_l, ptr_end_l):
+-                    ptr_r = ptr_start_r
+-                    for ptr_out in range(ptr_start_out, ptr_end_out):
+-                        out.col_index[ptr_out] =\
+-                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
+-                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
+-                        ptr_r += 1
+-
+-                    ptr_start_out += dist_r
+-                    ptr_end_out += dist_r
+-    return out
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-kron = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='kron',
+-    module=__name__,
+-    inputs=('left', 'right'),
+-    out=True,
+-)
+-kron.__doc__ =\
+-    """
+-    Compute the Kronecker product of two matrices.  This is used to represent
+-    quantum tensor products of vector spaces.
+-    """
+-kron.add_specialisations([
+-    (CSR, CSR, CSR, kron_csr),
+-    (Dense, Dense, Dense, kron_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++cimport cython
++
++from qutip.core.data.base cimport idxint
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++from qutip.core.data cimport csr
++import numpy
++
++__all__ = [
++    'kron', 'kron_csr', 'kron_dense'
++]
++
++
++@cython.overflowcheck(True)
++cdef idxint _mul_checked(idxint a, idxint b):
++    return a * b
++
++
++cpdef Dense kron_dense(Dense left, Dense right):
++    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
++
++
++cpdef CSR kron_csr(CSR left, CSR right):
++    """Kronecker product of two CSR matrices."""
++    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
++    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
++    cdef idxint row_l, row_r, row_out
++    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
++    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
++    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
++                             _mul_checked(ncols_l, ncols_r),
++                             _mul_checked(csr.nnz(left), csr.nnz(right)))
++    with nogil:
++        row_out = 0
++        out.row_index[row_out] = 0
++        for row_l in range(nrows_l):
++            ptr_start_l = left.row_index[row_l]
++            ptr_end_l = left.row_index[row_l + 1]
++            dist_l = ptr_end_l - ptr_start_l
++
++            for row_r in range(nrows_r):
++                ptr_start_r = right.row_index[row_r]
++                ptr_end_r = right.row_index[row_r + 1]
++                dist_r = ptr_end_r - ptr_start_r
++
++                ptr_start_out = out.row_index[row_out]
++                ptr_end_out = ptr_start_out + dist_r
++
++                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
++                row_out += 1
++
++                for ptr_l in range(ptr_start_l, ptr_end_l):
++                    ptr_r = ptr_start_r
++                    for ptr_out in range(ptr_start_out, ptr_end_out):
++                        out.col_index[ptr_out] =\
++                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
++                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
++                        ptr_r += 1
++
++                    ptr_start_out += dist_r
++                    ptr_end_out += dist_r
++    return out
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++kron = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='kron',
++    module=__name__,
++    inputs=('left', 'right'),
++    out=True,
++)
++kron.__doc__ =\
++    """
++    Compute the Kronecker product of two matrices.  This is used to represent
++    quantum tensor products of vector spaces.
++    """
++kron.add_specialisations([
++    (CSR, CSR, CSR, kron_csr),
++    (Dense, Dense, Dense, kron_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/linalg.py b/qutip/core/data/linalg.py
+index f5507738..e3847257 100644
+--- a/qutip/core/data/linalg.py
++++ b/qutip/core/data/linalg.py
+@@ -1,55 +1,55 @@
+-import scipy.linalg
+-import scipy.sparse
+-from .dense import Dense
+-from .csr import CSR
+-
+-__all__ = ['inv', 'inv_csr', 'inv_dense']
+-
+-
+-def inv_dense(data):
+-    """Compute the inverse of a matrix"""
+-    if not isinstance(data, Dense):
+-        raise TypeError("expected data in Dense format but got "
+-                        + str(type(data)))
+-    if data.shape[0] != data.shape[1]:
+-        raise ValueError('Cannot compute the matrix inverse'
+-                         ' of a nonsquare matrix')
+-    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
+-
+-
+-def inv_csr(data):
+-    """Compute the inverse of a sparse matrix"""
+-    if not isinstance(data, CSR):
+-        raise TypeError("expected data in CSR format but got "
+-                        + str(type(data)))
+-    if data.shape[0] != data.shape[1]:
+-        raise ValueError('Cannot compute the matrix inverse '
+-                         'of a nonsquare matrix')
+-    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
+-    # scipy.sparse.linalg.inv can return dense or sparse arrays.
+-    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-
+-inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
+-inv.__doc__ =\
+-    """
+-    Return matrix inverse for a data-layer object.
+-
+-    Parameters
+-    ----------
+-    data : Data
+-        Input matrix
+-
+-    Returns
+-    -------
+-    inverse : Data
+-        Inverse of data
+-    """
+-inv.add_specialisations([
+-    (CSR, CSR, inv_csr),
+-    (Dense, Dense, inv_dense),
+-], _defer=True)
+-
+-del _Dispatcher
++import scipy.linalg
++import scipy.sparse
++from .dense import Dense
++from .csr import CSR
++
++__all__ = ['inv', 'inv_csr', 'inv_dense']
++
++
++def inv_dense(data):
++    """Compute the inverse of a matrix"""
++    if not isinstance(data, Dense):
++        raise TypeError("expected data in Dense format but got "
++                        + str(type(data)))
++    if data.shape[0] != data.shape[1]:
++        raise ValueError('Cannot compute the matrix inverse'
++                         ' of a nonsquare matrix')
++    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
++
++
++def inv_csr(data):
++    """Compute the inverse of a sparse matrix"""
++    if not isinstance(data, CSR):
++        raise TypeError("expected data in CSR format but got "
++                        + str(type(data)))
++    if data.shape[0] != data.shape[1]:
++        raise ValueError('Cannot compute the matrix inverse '
++                         'of a nonsquare matrix')
++    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
++    # scipy.sparse.linalg.inv can return dense or sparse arrays.
++    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++
++inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
++inv.__doc__ =\
++    """
++    Return matrix inverse for a data-layer object.
++
++    Parameters
++    ----------
++    data : Data
++        Input matrix
++
++    Returns
++    -------
++    inverse : Data
++        Inverse of data
++    """
++inv.add_specialisations([
++    (CSR, CSR, inv_csr),
++    (Dense, Dense, inv_dense),
++], _defer=True)
++
++del _Dispatcher
+diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
+index 8b34d656..69f1ddcb 100644
+--- a/qutip/core/data/make.py
++++ b/qutip/core/data/make.py
+@@ -1,101 +1,101 @@
+-from .dispatch import Dispatcher as _Dispatcher
+-from . import csr, dense, CSR, Dense
+-
+-__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
+-
+-
+-def _diag_signature(diagonals, offsets=0, shape=None):
+-    """
+-    Construct a matrix from diagonals and their offsets.  Using this
+-    function in single-argument form produces a square matrix with the given
+-    values on the main diagonal.
+-    With lists of diagonals and offsets, the matrix will be the smallest
+-    possible square matrix if shape is not given, but in all cases the
+-    diagonals must fit exactly with no extra or missing elements. Duplicated
+-    diagonals will be summed together in the output.
+-
+-    Parameters
+-    ----------
+-    diagonals : sequence of array_like of complex or array_like of complex
+-        The entries (including zeros) that should be placed on the diagonals in
+-        the output matrix.  Each entry must have enough entries in it to fill
+-        the relevant diagonal and no more.
+-    offsets : sequence of integer or integer, optional
+-        The indices of the diagonals.  `offsets[i]` is the location of the
+-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+-        values are above the main diagonal and negative ones are below the main
+-        diagonal.
+-    shape : tuple, optional
+-        The shape of the output as (``rows``, ``columns``).  The result does
+-        not need to be square, but the diagonals must be of the correct length
+-        to fit in exactly.
+-    """
+-    pass
+-
+-
+-diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
+-diag.add_specialisations([
+-    (CSR, csr.diags),
+-    (Dense, dense.diags),
+-], _defer=True)
+-
+-del _diag_signature
+-
+-
+-def one_element_csr(shape, position, value=1.0):
+-    """
+-    Create a matrix with only one nonzero element.
+-
+-    Parameters
+-    ----------
+-    shape : tuple
+-        The shape of the output as (``rows``, ``columns``).
+-
+-    position : tuple
+-        The position of the non zero in the matrix as (``rows``, ``columns``).
+-
+-    value : complex, optional
+-        The value of the non-null element.
+-    """
+-    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+-        raise ValueError("Position of the elements out of bound: " +
+-                         str(position) + " in " + str(shape))
+-    data = csr.empty(*shape, 1)
+-    sci = data.as_scipy(full=True)
+-    sci.data[0] = value
+-    sci.indices[0] = position[1]
+-    sci.indptr[:position[0]+1] = 0
+-    sci.indptr[position[0]+1:] = 1
+-    return data
+-
+-
+-def one_element_dense(shape, position, value=1.0):
+-    """
+-    Create a matrix with only one nonzero element.
+-
+-    Parameters
+-    ----------
+-    shape : tuple
+-        The shape of the output as (``rows``, ``columns``).
+-
+-    position : tuple
+-        The position of the non zero in the matrix as (``rows``, ``columns``).
+-
+-    value : complex, optional
+-        The value of the non-null element.
+-    """
+-    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+-        raise ValueError("Position of the elements out of bound: " +
+-                         str(position) + " in " + str(shape))
+-    data = dense.zeros(*shape, 1)
+-    nda = data.as_ndarray()
+-    nda[position] = value
+-    return data
+-
+-
+-one_element = _Dispatcher(one_element_dense, name='one_element',
+-                          inputs=(), out=True)
+-one_element.add_specialisations([
+-    (CSR, one_element_csr),
+-    (Dense, one_element_dense),
+-], _defer=True)
++from .dispatch import Dispatcher as _Dispatcher
++from . import csr, dense, CSR, Dense
++
++__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
++
++
++def _diag_signature(diagonals, offsets=0, shape=None):
++    """
++    Construct a matrix from diagonals and their offsets.  Using this
++    function in single-argument form produces a square matrix with the given
++    values on the main diagonal.
++    With lists of diagonals and offsets, the matrix will be the smallest
++    possible square matrix if shape is not given, but in all cases the
++    diagonals must fit exactly with no extra or missing elements. Duplicated
++    diagonals will be summed together in the output.
++
++    Parameters
++    ----------
++    diagonals : sequence of array_like of complex or array_like of complex
++        The entries (including zeros) that should be placed on the diagonals in
++        the output matrix.  Each entry must have enough entries in it to fill
++        the relevant diagonal and no more.
++    offsets : sequence of integer or integer, optional
++        The indices of the diagonals.  `offsets[i]` is the location of the
++        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
++        values are above the main diagonal and negative ones are below the main
++        diagonal.
++    shape : tuple, optional
++        The shape of the output as (``rows``, ``columns``).  The result does
++        not need to be square, but the diagonals must be of the correct length
++        to fit in exactly.
++    """
++    pass
++
++
++diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
++diag.add_specialisations([
++    (CSR, csr.diags),
++    (Dense, dense.diags),
++], _defer=True)
++
++del _diag_signature
++
++
++def one_element_csr(shape, position, value=1.0):
++    """
++    Create a matrix with only one nonzero element.
++
++    Parameters
++    ----------
++    shape : tuple
++        The shape of the output as (``rows``, ``columns``).
++
++    position : tuple
++        The position of the non zero in the matrix as (``rows``, ``columns``).
++
++    value : complex, optional
++        The value of the non-null element.
++    """
++    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
++        raise ValueError("Position of the elements out of bound: " +
++                         str(position) + " in " + str(shape))
++    data = csr.empty(*shape, 1)
++    sci = data.as_scipy(full=True)
++    sci.data[0] = value
++    sci.indices[0] = position[1]
++    sci.indptr[:position[0]+1] = 0
++    sci.indptr[position[0]+1:] = 1
++    return data
++
++
++def one_element_dense(shape, position, value=1.0):
++    """
++    Create a matrix with only one nonzero element.
++
++    Parameters
++    ----------
++    shape : tuple
++        The shape of the output as (``rows``, ``columns``).
++
++    position : tuple
++        The position of the non zero in the matrix as (``rows``, ``columns``).
++
++    value : complex, optional
++        The value of the non-null element.
++    """
++    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
++        raise ValueError("Position of the elements out of bound: " +
++                         str(position) + " in " + str(shape))
++    data = dense.zeros(*shape, 1)
++    nda = data.as_ndarray()
++    nda[position] = value
++    return data
++
++
++one_element = _Dispatcher(one_element_dense, name='one_element',
++                          inputs=(), out=True)
++one_element.add_specialisations([
++    (CSR, one_element_csr),
++    (Dense, one_element_dense),
++], _defer=True)
+diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
+index 54d21798..b9d85556 100644
+--- a/qutip/core/data/matmul.pxd
++++ b/qutip/core/data/matmul.pxd
+@@ -1,14 +1,14 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data.base cimport Data
+-
+-cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
+-cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
+-cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
+-cdef Dense matmul_data_dense(Data left, Dense right)
+-cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
+-
+-cpdef Dense multiply_dense(Dense left, Dense right)
+-cpdef CSR multiply_csr(CSR left, CSR right)
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++from qutip.core.data.base cimport Data
++
++cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
++cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
++cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
++cdef Dense matmul_data_dense(Data left, Dense right)
++cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
++
++cpdef Dense multiply_dense(Dense left, Dense right)
++cpdef CSR multiply_csr(CSR left, CSR right)
+diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
+index 1d053879..d2d67e97 100644
+--- a/qutip/core/data/matmul.pyx
++++ b/qutip/core/data/matmul.pyx
+@@ -1,474 +1,474 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.string cimport memset, memcpy
+-from libc.math cimport fabs
+-
+-import warnings
+-from qutip.settings import settings
+-
+-cimport cython
+-
+-from cpython cimport mem
+-
+-import numpy as np
+-cimport numpy as cnp
+-from scipy.linalg cimport cython_blas as blas
+-
+-from qutip.core.data.base import idxint_dtype
+-from qutip.core.data.base cimport idxint, Data
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data cimport csr, dense
+-from qutip.core.data.add cimport iadd_dense, add_csr
+-from qutip.core.data.dense import OrderEfficiencyWarning
+-
+-cnp.import_array()
+-
+-cdef extern from *:
+-    void *PyMem_Calloc(size_t n, size_t elsize)
+-
+-# This function is templated over integral types on import to allow `idxint` to
+-# be any signed integer (though likely things will only work for >=32-bit).  To
+-# change integral types, you only need to change the `idxint` definitions in
+-# `core.data.base` at compile-time.
+-cdef extern from "src/matmul_csr_vector.hpp" nogil:
+-    void _matmul_csr_vector[T](
+-        double complex *data, T *col_index, T *row_index,
+-        double complex *vec, double complex scale, double complex *out,
+-        T nrows)
+-
+-__all__ = [
+-    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
+-    'multiply', 'multiply_csr', 'multiply_dense',
+-]
+-
+-
+-cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
+-    if left.shape[1] != right.shape[0]:
+-        raise ValueError(
+-            "incompatible matrix shapes "
+-            + str(left.shape)
+-            + " and "
+-            + str(right.shape)
+-        )
+-    if (
+-        out is not None
+-        and out.shape[0] != left.shape[0]
+-        and out.shape[1] != right.shape[1]
+-    ):
+-        raise ValueError(
+-            "incompatible output shape, got "
+-            + str(out.shape)
+-            + " but needed "
+-            + str((left.shape[0], right.shape[1]))
+-        )
+-
+-
+-cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
+-    """
+-    Produce a sensible upper-bound for the number of non-zero elements that
+-    will be present in a matrix multiplication between the two matrices.
+-    """
+-    cdef idxint j, k, nnz=0
+-    cdef idxint ii, jj, kk
+-    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
+-    # Setup mask array
+-    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
+-    with nogil:
+-        for ii in range(ncols):
+-            mask[ii] = -1
+-        for ii in range(nrows):
+-            for jj in range(left.row_index[ii], left.row_index[ii+1]):
+-                j = left.col_index[jj]
+-                for kk in range(right.row_index[j], right.row_index[j+1]):
+-                    k = right.col_index[kk]
+-                    if mask[k] != ii:
+-                        mask[k] = ii
+-                        nnz += 1
+-    mem.PyMem_Free(mask)
+-    return nnz
+-
+-
+-cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
+-    """
+-    Multiply two CSR matrices together to produce another CSR.  If `out` is
+-    specified, it must be pre-allocated with enough space to hold the output
+-    result.
+-
+-    This is the operation
+-        ``out := left @ right``
+-    where `out` will be allocated if not supplied.
+-
+-    Parameters
+-    ----------
+-    left : CSR
+-        CSR matrix on the left of the multiplication.
+-    right : CSR
+-        CSR matrix on the right of the multiplication.
+-    out : optional CSR
+-        Allocated space to store the result.  This must have enough space in
+-        the `data`, `col_index` and `row_index` pointers already allocated.
+-
+-    Returns
+-    -------
+-    out : CSR
+-        The result of the matrix multiplication.  This will be the same object
+-        as the input parameter `out` if that was supplied.
+-    """
+-    _check_shape(left, right)
+-    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
+-    if out is not None:
+-        raise TypeError("passing an `out` entry for CSR operations makes no sense")
+-    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
+-    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
+-        # Ensure the out array row_index is zeroed.  The others need not be,
+-        # because they don't represent valid entries since row_index is zeroed.
+-        with nogil:
+-            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
+-        return out
+-
+-    # Initialise actual matrix multiplication.
+-    nnz = 0
+-    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
+-    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
+-    cdef double complex val
+-    cdef double complex *sums
+-    cdef idxint *nxt
+-    cdef double tol = 0
+-    if settings.core['auto_tidyup']:
+-        tol = settings.core['auto_tidyup_atol']
+-    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
+-    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
+-    with nogil:
+-        for col_r in range(ncols):
+-            nxt[col_r] = -1
+-
+-        # Perform operation.
+-        out.row_index[0] = 0
+-        for row_l in range(nrows):
+-            head = -2
+-            length = 0
+-            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
+-                row_r = left.col_index[ptr_l]
+-                val = left.data[ptr_l]
+-                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
+-                    col_r = right.col_index[ptr_r]
+-                    sums[col_r] += val * right.data[ptr_r]
+-                    if nxt[col_r] == -1:
+-                        nxt[col_r] = head
+-                        head = col_r
+-                        length += 1
+-            for col_r in range(length):
+-                if fabs(sums[head].real) < tol:
+-                    sums[head].real = 0
+-                if fabs(sums[head].imag) < tol:
+-                    sums[head].imag = 0
+-                if sums[head] != 0:
+-                    out.col_index[nnz] = head
+-                    out.data[nnz] = scale * sums[head]
+-                    nnz += 1
+-                tmp = head
+-                head = nxt[head]
+-                nxt[tmp] = -1
+-                sums[tmp] = 0
+-            out.row_index[row_l + 1] = nnz
+-    mem.PyMem_Free(sums)
+-    mem.PyMem_Free(nxt)
+-    return out
+-
+-
+-cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
+-                                   double complex scale=1, Dense out=None):
+-    """
+-    Perform the operation
+-        ``out := scale * (left @ right) + out``
+-    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
+-    defaulting to 1.
+-
+-    If `out` is not given, it will be allocated as if it were a zero matrix.
+-    """
+-    _check_shape(left, right, out)
+-    cdef Dense tmp = None
+-    if out is None:
+-        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
+-    if bool(right.fortran) != bool(out.fortran):
+-        msg = (
+-            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
+-            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
+-        )
+-        warnings.warn(msg, OrderEfficiencyWarning)
+-        # Rather than making loads of copies of the same code, we just moan at
+-        # the user and then transpose one of the arrays.  We prefer to have
+-        # `right` in Fortran-order for cache efficiency.
+-        if right.fortran:
+-            tmp = out
+-            out = out.reorder()
+-        else:
+-            right = right.reorder()
+-    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
+-    cdef double complex val
+-    if right.fortran:
+-        idx_r = idx_out = 0
+-        for _ in range(ncols):
+-            _matmul_csr_vector(left.data, left.col_index, left.row_index,
+-                               right.data + idx_r,
+-                               scale,
+-                               out.data + idx_out,
+-                               nrows)
+-            idx_out += nrows
+-            idx_r += right.shape[0]
+-    else:
+-        for row in range(nrows):
+-            for ptr in range(left.row_index[row], left.row_index[row + 1]):
+-                val = scale * left.data[ptr]
+-                idx_out = row * ncols
+-                idx_r = left.col_index[ptr] * ncols
+-                for _ in range(ncols):
+-                    out.data[idx_out] += val * right.data[idx_r]
+-                    idx_out += 1
+-                    idx_r += 1
+-    if tmp is None:
+-        return out
+-    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
+-    return tmp
+-
+-
+-cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
+-    """
+-    Perform the operation
+-        ``out := scale * (left @ right) + out``
+-    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
+-    defaulting to 1.
+-
+-    If `out` is not given, it will be allocated as if it were a zero matrix.
+-    """
+-    _check_shape(left, right, out)
+-    cdef double complex out_scale
+-    # If not supplied, it's more efficient from a memory allocation perspective
+-    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
+-    if out is None:
+-        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
+-        out_scale = 0
+-    else:
+-        out_scale = 1
+-    cdef double complex *a
+-    cdef double complex *b
+-    cdef char transa, transb
+-    cdef int m, n, k=left.shape[1], lda, ldb
+-    if right.shape[1] == 1:
+-        # Matrix Vector product
+-        a, b = left.data, right.data
+-        if left.fortran:
+-            lda = left.shape[0]
+-            transa = b'n'
+-            m = left.shape[0]
+-            n = left.shape[1]
+-        else:
+-            lda = left.shape[1]
+-            transa = b't'
+-            m = left.shape[1]
+-            n = left.shape[0]
+-        ldb = 1
+-        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
+-                   &out_scale, out.data, &ldb)
+-        return out
+-    # We use the BLAS routine zgemm for every single call and pretend that
+-    # we're always supplying it with Fortran-ordered matrices, but to achieve
+-    # what we want, we use the property of matrix multiplication that
+-    #   A.B = (B'.A')'
+-    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
+-    # matrix as a C-ordered one is equivalent to taking the transpose.  If
+-    # `right` is supplied in C-order, then from Fortran's perspective we
+-    # actually have `B'`, so to retrieve `B` should we want to use it, we set
+-    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
+-    # need to switch the input order, _not_ whether we actually need B'.
+-    #
+-    # In order to make the output correct, we ensure that we put A.B in if the
+-    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
+-    # This is actually more flexible than `np.dot` which requires that the
+-    # output is C-ordered.
+-    if out.fortran:
+-        # Need to make A.B
+-        a, b = left.data, right.data
+-        m, n = left.shape[0], right.shape[1]
+-        lda = left.shape[0] if left.fortran else left.shape[1]
+-        transa = b'n' if left.fortran else b't'
+-        ldb = right.shape[0] if right.fortran else right.shape[1]
+-        transb = b'n' if right.fortran else b't'
+-    else:
+-        # Need to make B'.A'
+-        a, b = right.data, left.data
+-        m, n = right.shape[1], left.shape[0]
+-        lda = right.shape[0] if right.fortran else right.shape[1]
+-        transa = b't' if right.fortran else b'n'
+-        ldb = left.shape[0] if left.fortran else left.shape[1]
+-        transb = b't' if left.fortran else b'n'
+-    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
+-               &out_scale, out.data, &m)
+-    return out
+-
+-
+-cpdef CSR multiply_csr(CSR left, CSR right):
+-    """Element-wise multiplication of CSR matrices."""
+-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+-        raise ValueError(
+-            "incompatible matrix shapes "
+-            + str(left.shape)
+-            + " and "
+-            + str(right.shape)
+-        )
+-    cdef idxint col_left, left_nnz = csr.nnz(left)
+-    cdef idxint col_right, right_nnz = csr.nnz(right)
+-    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
+-    cdef idxint row, nnz=0, ncols=left.shape[1]
+-    cdef CSR out
+-    cdef list nans=[]
+-    # Fast paths for zero matrices.
+-    if right_nnz == 0 or left_nnz == 0:
+-        return csr.zeros(left.shape[0], left.shape[1])
+-    # Main path.
+-    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
+-    out.row_index[0] = nnz
+-    ptr_left_max = ptr_right_max = 0
+-
+-    for row in range(left.shape[0]):
+-        ptr_left = ptr_left_max
+-        ptr_left_max = left.row_index[row + 1]
+-        ptr_right = ptr_right_max
+-        ptr_right_max = right.row_index[row + 1]
+-        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
+-            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
+-            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
+-            if col_left == col_right:
+-                out.col_index[nnz] = col_left
+-                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
+-                ptr_left += 1
+-                ptr_right += 1
+-                nnz += 1
+-            elif col_left <= col_right:
+-                if left.data[ptr_left] is np.nan:
+-                    # Test for NaN since `NaN * 0 = NaN`
+-                    nans.append((row, col_left))
+-                ptr_left += 1
+-            else:
+-                if right.data[ptr_right] != right.data[ptr_right]:
+-                    nans.append((row, col_right))
+-                ptr_right += 1
+-        out.row_index[row + 1] = nnz
+-    if nans:
+-        # We expect Nan to be rare enough that we don't allocate memory for
+-        # them, but add them here after the loop.
+-        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
+-        nnz = nans_pos.shape[0]
+-        nans_csr = csr.from_coo_pointers(
+-            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
+-            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
+-            <double complex *> cnp.PyArray_GETPTR1(
+-                np.array([np.nan]*nnz, dtype=np.complex128), 0),
+-            left.shape[0], left.shape[1], nnz
+-        )
+-        out = add_csr(out, nans_csr)
+-    return out
+-
+-
+-cpdef Dense multiply_dense(Dense left, Dense right):
+-    """Element-wise multiplication of Dense matrices."""
+-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+-        raise ValueError(
+-            "incompatible matrix shapes "
+-            + str(left.shape)
+-            + " and "
+-            + str(right.shape)
+-        )
+-    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-# At the time of putting in the dispatchers, the idea of an "out" parameter
+-# isn't really supported in the model; since `out` would be potentially
+-# modified in-place, it couldn't safely go through a conversion process.  For
+-# the dispatched operation, then, we omit the `scale` and `out` parameters, and
+-# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
+-# are needed, the library will have to manually do any relevant conversions,
+-# and then call a direct specialisation (which are exported to the `data`
+-# namespace).
+-
+-matmul = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=1),
+-    ]),
+-    name='matmul',
+-    module=__name__,
+-    inputs=('left', 'right'),
+-    out=True,
+-)
+-matmul.__doc__ =\
+-    """
+-    Compute the matrix multiplication of two matrices, with the operation
+-        scale * (left @ right)
+-    where `scale` is (optionally) a scalar, and `left` and `right` are
+-    matrices.
+-
+-    Parameters
+-    ----------
+-    left : Data
+-        The left operand as either a bra or a ket matrix.
+-
+-    right : Data
+-        The right operand as a ket matrix.
+-
+-    scale : complex, optional
+-        The scalar to multiply the output by.
+-    """
+-matmul.add_specialisations([
+-    (CSR, CSR, CSR, matmul_csr),
+-    (CSR, Dense, Dense, matmul_csr_dense_dense),
+-    (Dense, Dense, Dense, matmul_dense),
+-], _defer=True)
+-
+-
+-multiply = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='multiply',
+-    module=__name__,
+-    inputs=('left', 'right'),
+-    out=True,
+-)
+-multiply.__doc__ =\
+-    """Element-wise multiplication of matrices."""
+-multiply.add_specialisations([
+-    (CSR, CSR, CSR, multiply_csr),
+-    (Dense, Dense, Dense, multiply_dense),
+-], _defer=True)
+-
+-
+-del _inspect, _Dispatcher
+-
+-
+-cdef Dense matmul_data_dense(Data left, Dense right):
+-    cdef Dense out
+-    if type(left) is CSR:
+-        out = matmul_csr_dense_dense(left, right)
+-    elif type(left) is Dense:
+-        out = matmul_dense(left, right)
+-    else:
+-        out = matmul(left, right)
+-    return out
+-
+-
+-cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
+-    if type(left) is CSR:
+-        matmul_csr_dense_dense(left, right, scale, out)
+-    elif type(left) is Dense:
+-        matmul_dense(left, right, scale, out)
+-    else:
+-        iadd_dense(out, matmul(left, right), scale)
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.string cimport memset, memcpy
++from libc.math cimport fabs
++
++import warnings
++from qutip.settings import settings
++
++cimport cython
++
++from cpython cimport mem
++
++import numpy as np
++cimport numpy as cnp
++from scipy.linalg cimport cython_blas as blas
++
++from qutip.core.data.base import idxint_dtype
++from qutip.core.data.base cimport idxint, Data
++from qutip.core.data.dense cimport Dense
++from qutip.core.data.csr cimport CSR
++from qutip.core.data cimport csr, dense
++from qutip.core.data.add cimport iadd_dense, add_csr
++from qutip.core.data.dense import OrderEfficiencyWarning
++
++cnp.import_array()
++
++cdef extern from *:
++    void *PyMem_Calloc(size_t n, size_t elsize)
++
++# This function is templated over integral types on import to allow `idxint` to
++# be any signed integer (though likely things will only work for >=32-bit).  To
++# change integral types, you only need to change the `idxint` definitions in
++# `core.data.base` at compile-time.
++cdef extern from "src/matmul_csr_vector.hpp" nogil:
++    void _matmul_csr_vector[T](
++        double complex *data, T *col_index, T *row_index,
++        double complex *vec, double complex scale, double complex *out,
++        T nrows)
++
++__all__ = [
++    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
++    'multiply', 'multiply_csr', 'multiply_dense',
++]
++
++
++cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
++    if left.shape[1] != right.shape[0]:
++        raise ValueError(
++            "incompatible matrix shapes "
++            + str(left.shape)
++            + " and "
++            + str(right.shape)
++        )
++    if (
++        out is not None
++        and out.shape[0] != left.shape[0]
++        and out.shape[1] != right.shape[1]
++    ):
++        raise ValueError(
++            "incompatible output shape, got "
++            + str(out.shape)
++            + " but needed "
++            + str((left.shape[0], right.shape[1]))
++        )
++
++
++cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
++    """
++    Produce a sensible upper-bound for the number of non-zero elements that
++    will be present in a matrix multiplication between the two matrices.
++    """
++    cdef idxint j, k, nnz=0
++    cdef idxint ii, jj, kk
++    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
++    # Setup mask array
++    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
++    with nogil:
++        for ii in range(ncols):
++            mask[ii] = -1
++        for ii in range(nrows):
++            for jj in range(left.row_index[ii], left.row_index[ii+1]):
++                j = left.col_index[jj]
++                for kk in range(right.row_index[j], right.row_index[j+1]):
++                    k = right.col_index[kk]
++                    if mask[k] != ii:
++                        mask[k] = ii
++                        nnz += 1
++    mem.PyMem_Free(mask)
++    return nnz
++
++
++cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
++    """
++    Multiply two CSR matrices together to produce another CSR.  If `out` is
++    specified, it must be pre-allocated with enough space to hold the output
++    result.
++
++    This is the operation
++        ``out := left @ right``
++    where `out` will be allocated if not supplied.
++
++    Parameters
++    ----------
++    left : CSR
++        CSR matrix on the left of the multiplication.
++    right : CSR
++        CSR matrix on the right of the multiplication.
++    out : optional CSR
++        Allocated space to store the result.  This must have enough space in
++        the `data`, `col_index` and `row_index` pointers already allocated.
++
++    Returns
++    -------
++    out : CSR
++        The result of the matrix multiplication.  This will be the same object
++        as the input parameter `out` if that was supplied.
++    """
++    _check_shape(left, right)
++    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
++    if out is not None:
++        raise TypeError("passing an `out` entry for CSR operations makes no sense")
++    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
++    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
++        # Ensure the out array row_index is zeroed.  The others need not be,
++        # because they don't represent valid entries since row_index is zeroed.
++        with nogil:
++            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
++        return out
++
++    # Initialise actual matrix multiplication.
++    nnz = 0
++    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
++    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
++    cdef double complex val
++    cdef double complex *sums
++    cdef idxint *nxt
++    cdef double tol = 0
++    if settings.core['auto_tidyup']:
++        tol = settings.core['auto_tidyup_atol']
++    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
++    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
++    with nogil:
++        for col_r in range(ncols):
++            nxt[col_r] = -1
++
++        # Perform operation.
++        out.row_index[0] = 0
++        for row_l in range(nrows):
++            head = -2
++            length = 0
++            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
++                row_r = left.col_index[ptr_l]
++                val = left.data[ptr_l]
++                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
++                    col_r = right.col_index[ptr_r]
++                    sums[col_r] += val * right.data[ptr_r]
++                    if nxt[col_r] == -1:
++                        nxt[col_r] = head
++                        head = col_r
++                        length += 1
++            for col_r in range(length):
++                if fabs(sums[head].real) < tol:
++                    sums[head].real = 0
++                if fabs(sums[head].imag) < tol:
++                    sums[head].imag = 0
++                if sums[head] != 0:
++                    out.col_index[nnz] = head
++                    out.data[nnz] = scale * sums[head]
++                    nnz += 1
++                tmp = head
++                head = nxt[head]
++                nxt[tmp] = -1
++                sums[tmp] = 0
++            out.row_index[row_l + 1] = nnz
++    mem.PyMem_Free(sums)
++    mem.PyMem_Free(nxt)
++    return out
++
++
++cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
++                                   double complex scale=1, Dense out=None):
++    """
++    Perform the operation
++        ``out := scale * (left @ right) + out``
++    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
++    defaulting to 1.
++
++    If `out` is not given, it will be allocated as if it were a zero matrix.
++    """
++    _check_shape(left, right, out)
++    cdef Dense tmp = None
++    if out is None:
++        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
++    if bool(right.fortran) != bool(out.fortran):
++        msg = (
++            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
++            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
++        )
++        warnings.warn(msg, OrderEfficiencyWarning)
++        # Rather than making loads of copies of the same code, we just moan at
++        # the user and then transpose one of the arrays.  We prefer to have
++        # `right` in Fortran-order for cache efficiency.
++        if right.fortran:
++            tmp = out
++            out = out.reorder()
++        else:
++            right = right.reorder()
++    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
++    cdef double complex val
++    if right.fortran:
++        idx_r = idx_out = 0
++        for _ in range(ncols):
++            _matmul_csr_vector(left.data, left.col_index, left.row_index,
++                               right.data + idx_r,
++                               scale,
++                               out.data + idx_out,
++                               nrows)
++            idx_out += nrows
++            idx_r += right.shape[0]
++    else:
++        for row in range(nrows):
++            for ptr in range(left.row_index[row], left.row_index[row + 1]):
++                val = scale * left.data[ptr]
++                idx_out = row * ncols
++                idx_r = left.col_index[ptr] * ncols
++                for _ in range(ncols):
++                    out.data[idx_out] += val * right.data[idx_r]
++                    idx_out += 1
++                    idx_r += 1
++    if tmp is None:
++        return out
++    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
++    return tmp
++
++
++cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
++    """
++    Perform the operation
++        ``out := scale * (left @ right) + out``
++    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
++    defaulting to 1.
++
++    If `out` is not given, it will be allocated as if it were a zero matrix.
++    """
++    _check_shape(left, right, out)
++    cdef double complex out_scale
++    # If not supplied, it's more efficient from a memory allocation perspective
++    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
++    if out is None:
++        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
++        out_scale = 0
++    else:
++        out_scale = 1
++    cdef double complex *a
++    cdef double complex *b
++    cdef char transa, transb
++    cdef int m, n, k=left.shape[1], lda, ldb
++    if right.shape[1] == 1:
++        # Matrix Vector product
++        a, b = left.data, right.data
++        if left.fortran:
++            lda = left.shape[0]
++            transa = b'n'
++            m = left.shape[0]
++            n = left.shape[1]
++        else:
++            lda = left.shape[1]
++            transa = b't'
++            m = left.shape[1]
++            n = left.shape[0]
++        ldb = 1
++        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
++                   &out_scale, out.data, &ldb)
++        return out
++    # We use the BLAS routine zgemm for every single call and pretend that
++    # we're always supplying it with Fortran-ordered matrices, but to achieve
++    # what we want, we use the property of matrix multiplication that
++    #   A.B = (B'.A')'
++    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
++    # matrix as a C-ordered one is equivalent to taking the transpose.  If
++    # `right` is supplied in C-order, then from Fortran's perspective we
++    # actually have `B'`, so to retrieve `B` should we want to use it, we set
++    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
++    # need to switch the input order, _not_ whether we actually need B'.
++    #
++    # In order to make the output correct, we ensure that we put A.B in if the
++    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
++    # This is actually more flexible than `np.dot` which requires that the
++    # output is C-ordered.
++    if out.fortran:
++        # Need to make A.B
++        a, b = left.data, right.data
++        m, n = left.shape[0], right.shape[1]
++        lda = left.shape[0] if left.fortran else left.shape[1]
++        transa = b'n' if left.fortran else b't'
++        ldb = right.shape[0] if right.fortran else right.shape[1]
++        transb = b'n' if right.fortran else b't'
++    else:
++        # Need to make B'.A'
++        a, b = right.data, left.data
++        m, n = right.shape[1], left.shape[0]
++        lda = right.shape[0] if right.fortran else right.shape[1]
++        transa = b't' if right.fortran else b'n'
++        ldb = left.shape[0] if left.fortran else left.shape[1]
++        transb = b't' if left.fortran else b'n'
++    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
++               &out_scale, out.data, &m)
++    return out
++
++
++cpdef CSR multiply_csr(CSR left, CSR right):
++    """Element-wise multiplication of CSR matrices."""
++    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
++        raise ValueError(
++            "incompatible matrix shapes "
++            + str(left.shape)
++            + " and "
++            + str(right.shape)
++        )
++    cdef idxint col_left, left_nnz = csr.nnz(left)
++    cdef idxint col_right, right_nnz = csr.nnz(right)
++    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
++    cdef idxint row, nnz=0, ncols=left.shape[1]
++    cdef CSR out
++    cdef list nans=[]
++    # Fast paths for zero matrices.
++    if right_nnz == 0 or left_nnz == 0:
++        return csr.zeros(left.shape[0], left.shape[1])
++    # Main path.
++    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
++    out.row_index[0] = nnz
++    ptr_left_max = ptr_right_max = 0
++
++    for row in range(left.shape[0]):
++        ptr_left = ptr_left_max
++        ptr_left_max = left.row_index[row + 1]
++        ptr_right = ptr_right_max
++        ptr_right_max = right.row_index[row + 1]
++        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
++            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
++            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
++            if col_left == col_right:
++                out.col_index[nnz] = col_left
++                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
++                ptr_left += 1
++                ptr_right += 1
++                nnz += 1
++            elif col_left <= col_right:
++                if left.data[ptr_left] is np.nan:
++                    # Test for NaN since `NaN * 0 = NaN`
++                    nans.append((row, col_left))
++                ptr_left += 1
++            else:
++                if right.data[ptr_right] != right.data[ptr_right]:
++                    nans.append((row, col_right))
++                ptr_right += 1
++        out.row_index[row + 1] = nnz
++    if nans:
++        # We expect Nan to be rare enough that we don't allocate memory for
++        # them, but add them here after the loop.
++        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
++        nnz = nans_pos.shape[0]
++        nans_csr = csr.from_coo_pointers(
++            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
++            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
++            <double complex *> cnp.PyArray_GETPTR1(
++                np.array([np.nan]*nnz, dtype=np.complex128), 0),
++            left.shape[0], left.shape[1], nnz
++        )
++        out = add_csr(out, nans_csr)
++    return out
++
++
++cpdef Dense multiply_dense(Dense left, Dense right):
++    """Element-wise multiplication of Dense matrices."""
++    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
++        raise ValueError(
++            "incompatible matrix shapes "
++            + str(left.shape)
++            + " and "
++            + str(right.shape)
++        )
++    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++# At the time of putting in the dispatchers, the idea of an "out" parameter
++# isn't really supported in the model; since `out` would be potentially
++# modified in-place, it couldn't safely go through a conversion process.  For
++# the dispatched operation, then, we omit the `scale` and `out` parameters, and
++# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
++# are needed, the library will have to manually do any relevant conversions,
++# and then call a direct specialisation (which are exported to the `data`
++# namespace).
++
++matmul = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=1),
++    ]),
++    name='matmul',
++    module=__name__,
++    inputs=('left', 'right'),
++    out=True,
++)
++matmul.__doc__ =\
++    """
++    Compute the matrix multiplication of two matrices, with the operation
++        scale * (left @ right)
++    where `scale` is (optionally) a scalar, and `left` and `right` are
++    matrices.
++
++    Parameters
++    ----------
++    left : Data
++        The left operand as either a bra or a ket matrix.
++
++    right : Data
++        The right operand as a ket matrix.
++
++    scale : complex, optional
++        The scalar to multiply the output by.
++    """
++matmul.add_specialisations([
++    (CSR, CSR, CSR, matmul_csr),
++    (CSR, Dense, Dense, matmul_csr_dense_dense),
++    (Dense, Dense, Dense, matmul_dense),
++], _defer=True)
++
++
++multiply = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='multiply',
++    module=__name__,
++    inputs=('left', 'right'),
++    out=True,
++)
++multiply.__doc__ =\
++    """Element-wise multiplication of matrices."""
++multiply.add_specialisations([
++    (CSR, CSR, CSR, multiply_csr),
++    (Dense, Dense, Dense, multiply_dense),
++], _defer=True)
++
++
++del _inspect, _Dispatcher
++
++
++cdef Dense matmul_data_dense(Data left, Dense right):
++    cdef Dense out
++    if type(left) is CSR:
++        out = matmul_csr_dense_dense(left, right)
++    elif type(left) is Dense:
++        out = matmul_dense(left, right)
++    else:
++        out = matmul(left, right)
++    return out
++
++
++cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
++    if type(left) is CSR:
++        matmul_csr_dense_dense(left, right, scale, out)
++    elif type(left) is Dense:
++        matmul_dense(left, right, scale, out)
++    else:
++        iadd_dense(out, matmul(left, right), scale)
+diff --git a/qutip/core/data/mul.pxd b/qutip/core/data/mul.pxd
+index 2c292596..f935e1ee 100644
+--- a/qutip/core/data/mul.pxd
++++ b/qutip/core/data/mul.pxd
+@@ -1,13 +1,13 @@
+-#cython: language_level=3
+-
+-from qutip.core.data cimport CSR, Dense, Data
+-
+-cpdef CSR imul_csr(CSR matrix, double complex value)
+-cpdef CSR mul_csr(CSR matrix, double complex value)
+-cpdef CSR neg_csr(CSR matrix)
+-
+-cpdef Dense imul_dense(Dense matrix, double complex value)
+-cpdef Dense mul_dense(Dense matrix, double complex value)
+-cpdef Dense neg_dense(Dense matrix)
+-
+-cpdef Data imul_data(Data matrix, double complex value)
++#cython: language_level=3
++
++from qutip.core.data cimport CSR, Dense, Data
++
++cpdef CSR imul_csr(CSR matrix, double complex value)
++cpdef CSR mul_csr(CSR matrix, double complex value)
++cpdef CSR neg_csr(CSR matrix)
++
++cpdef Dense imul_dense(Dense matrix, double complex value)
++cpdef Dense mul_dense(Dense matrix, double complex value)
++cpdef Dense neg_dense(Dense matrix)
++
++cpdef Data imul_data(Data matrix, double complex value)
+diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
+index 439c6cf6..80928ede 100644
+--- a/qutip/core/data/mul.pyx
++++ b/qutip/core/data/mul.pyx
+@@ -1,134 +1,134 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wrapround=False, initializedcheck=False
+-
+-from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
+-from scipy.linalg.cython_blas cimport zscal
+-
+-__all__ = [
+-    'mul', 'mul_csr', 'mul_dense',
+-    'imul', 'imul_csr', 'imul_dense', 'imul_data',
+-    'neg', 'neg_csr', 'neg_dense',
+-]
+-
+-
+-cpdef CSR imul_csr(CSR matrix, double complex value):
+-    """Multiply this CSR `matrix` by a complex scalar `value`."""
+-    cdef idxint l = csr.nnz(matrix)
+-    cdef int ONE=1
+-    zscal(&l, &value, matrix.data, &ONE)
+-    return matrix
+-
+-cpdef CSR mul_csr(CSR matrix, double complex value):
+-    """Multiply this CSR `matrix` by a complex scalar `value`."""
+-    if value == 0:
+-        return csr.zeros(matrix.shape[0], matrix.shape[1])
+-    cdef CSR out = csr.copy_structure(matrix)
+-    cdef idxint ptr
+-    with nogil:
+-        for ptr in range(csr.nnz(matrix)):
+-            out.data[ptr] = value * matrix.data[ptr]
+-    return out
+-
+-cpdef CSR neg_csr(CSR matrix):
+-    """Unary negation of this CSR `matrix`.  Return a new object."""
+-    cdef CSR out = csr.copy_structure(matrix)
+-    cdef idxint ptr
+-    with nogil:
+-        for ptr in range(csr.nnz(matrix)):
+-            out.data[ptr] = -matrix.data[ptr]
+-    return out
+-
+-
+-cpdef Dense imul_dense(Dense matrix, double complex value):
+-    """Multiply this Dense `matrix` by a complex scalar `value`."""
+-    cdef size_t ptr
+-    cdef int ONE=1
+-    cdef idxint l = matrix.shape[0]*matrix.shape[1]
+-    zscal(&l, &value, matrix.data, &ONE)
+-    return matrix
+-
+-cpdef Dense mul_dense(Dense matrix, double complex value):
+-    """Multiply this Dense `matrix` by a complex scalar `value`."""
+-    cdef Dense out = dense.empty_like(matrix)
+-    cdef size_t ptr
+-    with nogil:
+-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
+-            out.data[ptr] = value * matrix.data[ptr]
+-    return out
+-
+-cpdef Dense neg_dense(Dense matrix):
+-    """Unary negation of this Dense `matrix`.  Return a new object."""
+-    cdef Dense out = dense.empty_like(matrix)
+-    cdef size_t ptr
+-    with nogil:
+-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
+-            out.data[ptr] = -matrix.data[ptr]
+-    return out
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-mul = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='mul',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-mul.__doc__ =\
+-    """Multiply a matrix element-wise by a scalar."""
+-mul.add_specialisations([
+-    (CSR, CSR, mul_csr),
+-    (Dense, Dense, mul_dense),
+-], _defer=True)
+-
+-imul = _Dispatcher(
+-    # Will not be inplce if specialisation does not exist but should still
+-    # give expected results if used as:
+-    # mat = imul(mat, x)
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='imul',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-imul.__doc__ =\
+-    """Multiply inplace a matrix element-wise by a scalar."""
+-imul.add_specialisations([
+-    (CSR, CSR, imul_csr),
+-    (Dense, Dense, imul_dense),
+-], _defer=True)
+-
+-neg = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='neg',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-neg.__doc__ =\
+-    """Unary element-wise negation of a matrix."""
+-neg.add_specialisations([
+-    (CSR, CSR, neg_csr),
+-    (Dense, Dense, neg_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
+-
+-
+-cpdef Data imul_data(Data matrix, double complex value):
+-    if type(matrix) is CSR:
+-        return imul_csr(matrix, value)
+-    elif type(matrix) is Dense:
+-        return imul_dense(matrix, value)
+-    else:
+-        return imul(matrix, value)
++#cython: language_level=3
++#cython: boundscheck=False, wrapround=False, initializedcheck=False
++
++from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
++from scipy.linalg.cython_blas cimport zscal
++
++__all__ = [
++    'mul', 'mul_csr', 'mul_dense',
++    'imul', 'imul_csr', 'imul_dense', 'imul_data',
++    'neg', 'neg_csr', 'neg_dense',
++]
++
++
++cpdef CSR imul_csr(CSR matrix, double complex value):
++    """Multiply this CSR `matrix` by a complex scalar `value`."""
++    cdef idxint l = csr.nnz(matrix)
++    cdef int ONE=1
++    zscal(&l, &value, matrix.data, &ONE)
++    return matrix
++
++cpdef CSR mul_csr(CSR matrix, double complex value):
++    """Multiply this CSR `matrix` by a complex scalar `value`."""
++    if value == 0:
++        return csr.zeros(matrix.shape[0], matrix.shape[1])
++    cdef CSR out = csr.copy_structure(matrix)
++    cdef idxint ptr
++    with nogil:
++        for ptr in range(csr.nnz(matrix)):
++            out.data[ptr] = value * matrix.data[ptr]
++    return out
++
++cpdef CSR neg_csr(CSR matrix):
++    """Unary negation of this CSR `matrix`.  Return a new object."""
++    cdef CSR out = csr.copy_structure(matrix)
++    cdef idxint ptr
++    with nogil:
++        for ptr in range(csr.nnz(matrix)):
++            out.data[ptr] = -matrix.data[ptr]
++    return out
++
++
++cpdef Dense imul_dense(Dense matrix, double complex value):
++    """Multiply this Dense `matrix` by a complex scalar `value`."""
++    cdef size_t ptr
++    cdef int ONE=1
++    cdef idxint l = matrix.shape[0]*matrix.shape[1]
++    zscal(&l, &value, matrix.data, &ONE)
++    return matrix
++
++cpdef Dense mul_dense(Dense matrix, double complex value):
++    """Multiply this Dense `matrix` by a complex scalar `value`."""
++    cdef Dense out = dense.empty_like(matrix)
++    cdef size_t ptr
++    with nogil:
++        for ptr in range(matrix.shape[0]*matrix.shape[1]):
++            out.data[ptr] = value * matrix.data[ptr]
++    return out
++
++cpdef Dense neg_dense(Dense matrix):
++    """Unary negation of this Dense `matrix`.  Return a new object."""
++    cdef Dense out = dense.empty_like(matrix)
++    cdef size_t ptr
++    with nogil:
++        for ptr in range(matrix.shape[0]*matrix.shape[1]):
++            out.data[ptr] = -matrix.data[ptr]
++    return out
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++mul = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='mul',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++mul.__doc__ =\
++    """Multiply a matrix element-wise by a scalar."""
++mul.add_specialisations([
++    (CSR, CSR, mul_csr),
++    (Dense, Dense, mul_dense),
++], _defer=True)
++
++imul = _Dispatcher(
++    # Will not be inplce if specialisation does not exist but should still
++    # give expected results if used as:
++    # mat = imul(mat, x)
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='imul',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++imul.__doc__ =\
++    """Multiply inplace a matrix element-wise by a scalar."""
++imul.add_specialisations([
++    (CSR, CSR, imul_csr),
++    (Dense, Dense, imul_dense),
++], _defer=True)
++
++neg = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='neg',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++neg.__doc__ =\
++    """Unary element-wise negation of a matrix."""
++neg.add_specialisations([
++    (CSR, CSR, neg_csr),
++    (Dense, Dense, neg_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
++
++
++cpdef Data imul_data(Data matrix, double complex value):
++    if type(matrix) is CSR:
++        return imul_csr(matrix, value)
++    elif type(matrix) is Dense:
++        return imul_dense(matrix, value)
++    else:
++        return imul(matrix, value)
+diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
+index 5e1b7ebe..560d163e 100644
+--- a/qutip/core/data/norm.pxd
++++ b/qutip/core/data/norm.pxd
+@@ -1,15 +1,15 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from qutip.core.data cimport CSR, Dense, Data
+-
+-cpdef double one_csr(CSR matrix) except -1
+-cpdef double trace_csr(CSR matrix) except -1
+-cpdef double max_csr(CSR matrix) nogil
+-cpdef double frobenius_csr(CSR matrix) nogil
+-cpdef double l2_csr(CSR matrix) nogil except -1
+-
+-cpdef double frobenius_dense(Dense matrix) nogil
+-cpdef double l2_dense(Dense matrix) nogil except -1
+-
+-cpdef double frobenius_data(Data state)
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from qutip.core.data cimport CSR, Dense, Data
++
++cpdef double one_csr(CSR matrix) except -1
++cpdef double trace_csr(CSR matrix) except -1
++cpdef double max_csr(CSR matrix) nogil
++cpdef double frobenius_csr(CSR matrix) nogil
++cpdef double l2_csr(CSR matrix) nogil except -1
++
++cpdef double frobenius_dense(Dense matrix) nogil
++cpdef double l2_dense(Dense matrix) nogil except -1
++
++cpdef double frobenius_data(Data state)
+diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
+index 998d49d1..40f15837 100644
+--- a/qutip/core/data/norm.pyx
++++ b/qutip/core/data/norm.pyx
+@@ -1,229 +1,229 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc cimport math
+-
+-from cpython cimport mem
+-
+-from scipy.linalg cimport cython_blas as blas
+-import scipy
+-
+-from qutip.core.data cimport CSR, Dense, csr, dense, Data
+-
+-from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
+-from qutip.core.data.matmul cimport matmul_csr
+-
+-from qutip.core.data import eigs_csr, eigs_dense
+-
+-cdef extern from *:
+-    # Not included in Cython for some reason?
+-    void *PyMem_Calloc(size_t n, size_t elsize)
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    # abs is templated such that Cython treats std::abs as complex->complex
+-    double abs(double complex x)
+-
+-cdef double abssq(double complex x) nogil:
+-    return x.real*x.real + x.imag*x.imag
+-
+-# We always use BLAS routines where possible because architecture-specific
+-# libraries will typically apply vectorised operations for us.
+-
+-# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
+-__all__ = []
+-
+-cpdef double one_csr(CSR matrix) except -1:
+-    cdef int n=matrix.shape[1], inc=1
+-    cdef size_t ptr
+-    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
+-    try:
+-        for ptr in range(csr.nnz(matrix)):
+-            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
+-        # BLAS is a Fortran library, so it's one-indexed of course...
+-        return col[blas.idamax(&n, col, &inc) - 1]
+-    finally:
+-        mem.PyMem_Free(col)
+-
+-
+-cpdef double trace_dense(Dense matrix) except -1:
+-    """Compute the trace norm relaying scipy for dense operations."""
+-    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
+-
+-
+-cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
+-    """Compute the trace norm using only sparse operations. These consist
+-    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
+-    their square roots."""
+-    # For column and row vectors we simply use the l2 norm as it is equivalent
+-    # to the trace norm.
+-    if matrix.shape[0]==1 or matrix.shape[1]==1:
+-        return l2_csr(matrix)
+-
+-    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
+-    cdef size_t i
+-    cdef double [::1] eigs
+-
+-    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
+-
+-    cdef double total = 0
+-    for i in range(matrix.shape[0]):
+-        # The abs is technically not part of the definition, but since all
+-        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
+-        # which are lower will just be ~1e-15 due to numerical approximations.
+-        total += math.sqrt(abs(eigs[i]))
+-    return total
+-
+-
+-cpdef double max_csr(CSR matrix) nogil:
+-    cdef size_t ptr
+-    cdef double total=0, cur
+-    for ptr in range(csr.nnz(matrix)):
+-        # The positive square root is monotonic over positive reals, so we can
+-        # find the maximum value by considering the abs squared (which doesn't
+-        # require a sqrt) rather than the abs(which does), and then perform
+-        # only a single sqrt at the end.
+-        cur = abssq(matrix.data[ptr])
+-        total = cur if cur > total else total
+-    return math.sqrt(total)
+-
+-cpdef double frobenius_csr(CSR matrix) nogil:
+-    # The Frobenius norm is effectively the same as the L2 norm when
+-    # considering the non-zero elements as a vector.
+-    cdef int n=csr.nnz(matrix), inc=1
+-    return blas.dznrm2(&n, &matrix.data[0], &inc)
+-
+-cpdef double l2_csr(CSR matrix) nogil except -1:
+-    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+-        raise ValueError("L2 norm is only defined on vectors")
+-    return frobenius_csr(matrix)
+-
+-cpdef double one_dense(Dense matrix) nogil:
+-    cdef size_t ptr, col, row, col_stride, row_stride
+-    cdef double out=0, cur
+-    col_stride = matrix.shape[0] if matrix.fortran else 1
+-    row_stride = 1 if matrix.fortran else matrix.shape[1]
+-    for col in range(matrix.shape[1]):
+-        ptr = col * col_stride
+-        cur = 0
+-        for row in range(matrix.shape[0]):
+-            cur += abs(matrix.data[ptr])
+-            ptr += row_stride
+-        out = cur if cur > out else out
+-    return out
+-
+-cpdef double max_dense(Dense matrix) nogil:
+-    cdef size_t ptr
+-    cdef double total=0, cur
+-    for ptr in range(matrix.shape[0] * matrix.shape[1]):
+-        # The positive square root is monotonic over positive reals, so we can
+-        # find the maximum value by considering the abs squared (which doesn't
+-        # require a sqrt) rather than the abs(which does), and then perform
+-        # only a single sqrt at the end.
+-        cur = abssq(matrix.data[ptr])
+-        total = cur if cur > total else total
+-    return math.sqrt(total)
+-
+-cpdef double frobenius_dense(Dense matrix) nogil:
+-    cdef int n = matrix.shape[0] * matrix.shape[1]
+-    cdef int inc = 1
+-    return blas.dznrm2(&n, matrix.data, &inc)
+-
+-cpdef double l2_dense(Dense matrix) nogil except -1:
+-    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+-        raise ValueError("L2 norm is only defined on vectors")
+-    return frobenius_dense(matrix)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-l2 = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='l2',
+-    module=__name__,
+-    inputs=('vector',),
+-)
+-l2.__doc__ =\
+-    """
+-    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
+-        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
+-    This is only defined for vectors, but see `norm.frobenius` for the similar
+-    norm defined on all matrices.
+-    """
+-l2.add_specialisations([
+-    (Dense, l2_dense),
+-    (CSR, l2_csr),
+-], _defer=True)
+-
+-_norm_signature = _inspect.Signature([
+-    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-])
+-
+-frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
+-frobenius.__doc__ =\
+-    """
+-    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
+-    as the
+-        sqrt(sum_i sum_j |matrix[i, j]|**2)
+-    and is similar to an extension of the vector L2 norm to all matrices.
+-    """
+-frobenius.add_specialisations([
+-    (Dense, frobenius_dense),
+-    (CSR, frobenius_csr),
+-], _defer=True)
+-
+-max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
+-max.__doc__ =\
+-    """
+-    Compute the max norm of a matrix.  This is the largest absolute value of an
+-    entry in the matrix, or mathematically
+-        max_{i,j} |matrix[i, j]|
+-    """
+-max.add_specialisations([
+-    (Dense, max_dense),
+-    (CSR, max_csr),
+-], _defer=True)
+-
+-one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
+-one.__doc__ =\
+-    """
+-    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
+-    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
+-    the sum of the absolute values.
+-    """
+-one.add_specialisations([
+-    (Dense, one_dense),
+-    (CSR, one_csr),
+-], _defer=True)
+-
+-
+-trace = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    inputs=('matrix',),
+-    name='trace',
+-    module=__name__,
+-    out=False,
+-)
+-trace.__doc__ =\
+-    """
+-    Compute the trace-norm of a matrix.  This is the sum of the singular values
+-    of the matrix, or equivalently
+-        Tr(sqrt(A @ A.adjoint()))
+-    """
+-trace.add_specialisations([
+-    (CSR, trace_csr),
+-    (Dense, trace_dense),
+-], _defer=True)
+-
+-
+-cpdef double frobenius_data(Data state):
+-    if type(state) is Dense:
+-        return frobenius_dense(state)
+-    elif type(state) is CSR:
+-        return frobenius_csr(state)
+-    else:
+-        return frobenius(state)
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc cimport math
++
++from cpython cimport mem
++
++from scipy.linalg cimport cython_blas as blas
++import scipy
++
++from qutip.core.data cimport CSR, Dense, csr, dense, Data
++
++from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
++from qutip.core.data.matmul cimport matmul_csr
++
++from qutip.core.data import eigs_csr, eigs_dense
++
++cdef extern from *:
++    # Not included in Cython for some reason?
++    void *PyMem_Calloc(size_t n, size_t elsize)
++
++cdef extern from "<complex>" namespace "std" nogil:
++    # abs is templated such that Cython treats std::abs as complex->complex
++    double abs(double complex x)
++
++cdef double abssq(double complex x) nogil:
++    return x.real*x.real + x.imag*x.imag
++
++# We always use BLAS routines where possible because architecture-specific
++# libraries will typically apply vectorised operations for us.
++
++# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
++__all__ = []
++
++cpdef double one_csr(CSR matrix) except -1:
++    cdef int n=matrix.shape[1], inc=1
++    cdef size_t ptr
++    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
++    try:
++        for ptr in range(csr.nnz(matrix)):
++            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
++        # BLAS is a Fortran library, so it's one-indexed of course...
++        return col[blas.idamax(&n, col, &inc) - 1]
++    finally:
++        mem.PyMem_Free(col)
++
++
++cpdef double trace_dense(Dense matrix) except -1:
++    """Compute the trace norm relaying scipy for dense operations."""
++    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
++
++
++cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
++    """Compute the trace norm using only sparse operations. These consist
++    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
++    their square roots."""
++    # For column and row vectors we simply use the l2 norm as it is equivalent
++    # to the trace norm.
++    if matrix.shape[0]==1 or matrix.shape[1]==1:
++        return l2_csr(matrix)
++
++    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
++    cdef size_t i
++    cdef double [::1] eigs
++
++    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
++
++    cdef double total = 0
++    for i in range(matrix.shape[0]):
++        # The abs is technically not part of the definition, but since all
++        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
++        # which are lower will just be ~1e-15 due to numerical approximations.
++        total += math.sqrt(abs(eigs[i]))
++    return total
++
++
++cpdef double max_csr(CSR matrix) nogil:
++    cdef size_t ptr
++    cdef double total=0, cur
++    for ptr in range(csr.nnz(matrix)):
++        # The positive square root is monotonic over positive reals, so we can
++        # find the maximum value by considering the abs squared (which doesn't
++        # require a sqrt) rather than the abs(which does), and then perform
++        # only a single sqrt at the end.
++        cur = abssq(matrix.data[ptr])
++        total = cur if cur > total else total
++    return math.sqrt(total)
++
++cpdef double frobenius_csr(CSR matrix) nogil:
++    # The Frobenius norm is effectively the same as the L2 norm when
++    # considering the non-zero elements as a vector.
++    cdef int n=csr.nnz(matrix), inc=1
++    return blas.dznrm2(&n, &matrix.data[0], &inc)
++
++cpdef double l2_csr(CSR matrix) nogil except -1:
++    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
++        raise ValueError("L2 norm is only defined on vectors")
++    return frobenius_csr(matrix)
++
++cpdef double one_dense(Dense matrix) nogil:
++    cdef size_t ptr, col, row, col_stride, row_stride
++    cdef double out=0, cur
++    col_stride = matrix.shape[0] if matrix.fortran else 1
++    row_stride = 1 if matrix.fortran else matrix.shape[1]
++    for col in range(matrix.shape[1]):
++        ptr = col * col_stride
++        cur = 0
++        for row in range(matrix.shape[0]):
++            cur += abs(matrix.data[ptr])
++            ptr += row_stride
++        out = cur if cur > out else out
++    return out
++
++cpdef double max_dense(Dense matrix) nogil:
++    cdef size_t ptr
++    cdef double total=0, cur
++    for ptr in range(matrix.shape[0] * matrix.shape[1]):
++        # The positive square root is monotonic over positive reals, so we can
++        # find the maximum value by considering the abs squared (which doesn't
++        # require a sqrt) rather than the abs(which does), and then perform
++        # only a single sqrt at the end.
++        cur = abssq(matrix.data[ptr])
++        total = cur if cur > total else total
++    return math.sqrt(total)
++
++cpdef double frobenius_dense(Dense matrix) nogil:
++    cdef int n = matrix.shape[0] * matrix.shape[1]
++    cdef int inc = 1
++    return blas.dznrm2(&n, matrix.data, &inc)
++
++cpdef double l2_dense(Dense matrix) nogil except -1:
++    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
++        raise ValueError("L2 norm is only defined on vectors")
++    return frobenius_dense(matrix)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++l2 = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='l2',
++    module=__name__,
++    inputs=('vector',),
++)
++l2.__doc__ =\
++    """
++    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
++        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
++    This is only defined for vectors, but see `norm.frobenius` for the similar
++    norm defined on all matrices.
++    """
++l2.add_specialisations([
++    (Dense, l2_dense),
++    (CSR, l2_csr),
++], _defer=True)
++
++_norm_signature = _inspect.Signature([
++    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++])
++
++frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
++frobenius.__doc__ =\
++    """
++    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
++    as the
++        sqrt(sum_i sum_j |matrix[i, j]|**2)
++    and is similar to an extension of the vector L2 norm to all matrices.
++    """
++frobenius.add_specialisations([
++    (Dense, frobenius_dense),
++    (CSR, frobenius_csr),
++], _defer=True)
++
++max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
++max.__doc__ =\
++    """
++    Compute the max norm of a matrix.  This is the largest absolute value of an
++    entry in the matrix, or mathematically
++        max_{i,j} |matrix[i, j]|
++    """
++max.add_specialisations([
++    (Dense, max_dense),
++    (CSR, max_csr),
++], _defer=True)
++
++one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
++one.__doc__ =\
++    """
++    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
++    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
++    the sum of the absolute values.
++    """
++one.add_specialisations([
++    (Dense, one_dense),
++    (CSR, one_csr),
++], _defer=True)
++
++
++trace = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    inputs=('matrix',),
++    name='trace',
++    module=__name__,
++    out=False,
++)
++trace.__doc__ =\
++    """
++    Compute the trace-norm of a matrix.  This is the sum of the singular values
++    of the matrix, or equivalently
++        Tr(sqrt(A @ A.adjoint()))
++    """
++trace.add_specialisations([
++    (CSR, trace_csr),
++    (Dense, trace_dense),
++], _defer=True)
++
++
++cpdef double frobenius_data(Data state):
++    if type(state) is Dense:
++        return frobenius_dense(state)
++    elif type(state) is CSR:
++        return frobenius_csr(state)
++    else:
++        return frobenius(state)
+diff --git a/qutip/core/data/permute.pxd b/qutip/core/data/permute.pxd
+index 1ac9a335..422be089 100644
+--- a/qutip/core/data/permute.pxd
++++ b/qutip/core/data/permute.pxd
+@@ -1,7 +1,7 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from qutip.core.data.csr cimport CSR
+-
+-cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
+-cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from qutip.core.data.csr cimport CSR
++
++cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
++cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
+diff --git a/qutip/core/data/permute.pyx b/qutip/core/data/permute.pyx
+index 72f44af2..4e08fa74 100644
+--- a/qutip/core/data/permute.pyx
++++ b/qutip/core/data/permute.pyx
+@@ -1,405 +1,405 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.string cimport memset, memcpy
+-
+-from libcpp cimport bool
+-from libcpp.algorithm cimport sort
+-
+-cimport cython
+-
+-from cpython cimport mem
+-
+-import numpy as np
+-cimport numpy as cnp
+-
+-from qutip.core.data.base cimport idxint, idxint_DTYPE
+-from qutip.core.data cimport csr, dense, CSR, Dense
+-
+-from qutip.core.data.base import idxint_dtype
+-
+-cnp.import_array()
+-
+-cdef extern from *:
+-    void *PyMem_Calloc(size_t n, size_t elsize)
+-
+-# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
+-__all__ = []
+-
+-
+-cdef class _Indexer:
+-    cdef size_t ndims, size
+-    cdef readonly cnp.ndarray new_dimensions
+-    cdef idxint[:] dimensions
+-    cdef idxint *cumprod
+-
+-    def __init__(self, idxint[:] dimensions, idxint[:] order):
+-        cdef size_t i
+-        cdef idxint dim, ord
+-        cdef idxint prev
+-        self.ndims = dimensions.shape[0]
+-        self.dimensions = dimensions
+-        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
+-        cdef idxint[:] new_dimensions = self.new_dimensions
+-        if order.shape[0] != self.ndims:
+-            raise ValueError("invalid order: wrong number of elements")
+-        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
+-        try:
+-            for i in range(self.ndims):
+-                ord = order[i]
+-                if ord < 0 or ord >= self.ndims:
+-                    raise ValueError("invalid order element: " + str(ord))
+-                if tmp[ord]:
+-                    raise ValueError("duplicate order element: " + str(ord))
+-                tmp[ord] = True
+-                dim = self.dimensions[ord]
+-                if dim < 0:
+-                    raise ValueError("found negative dimension: " + str(dim))
+-                elif dim == 0:
+-                    raise ValueError("found zero dimension")
+-                new_dimensions[i] = dim
+-        finally:
+-            mem.PyMem_Free(tmp)
+-        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
+-        prev = self.cumprod[order[self.ndims - 1]] = 1
+-        for i in range(self.ndims - 2, -1, -1):
+-            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
+-        self.size = self.cumprod[order[0]] * new_dimensions[0]
+-
+-    @cython.cdivision(True)
+-    cdef cnp.ndarray all(self):
+-        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
+-        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
+-        cdef idxint i
+-        for i in range(self.size):
+-            _out[i] = self.single(i)
+-        return out
+-
+-    @cython.cdivision(True)
+-    cdef idxint single(self, idxint idx) nogil:
+-        cdef size_t i
+-        cdef idxint out=0, dim
+-        for i in range(self.ndims - 1, -1, -1):
+-            dim = self.dimensions[i]
+-            # Dimensions cannot be zero due to the check in __init__.
+-            out += self.cumprod[i] * (idx % dim)
+-            idx //= dim
+-            if idx == 0:
+-                break
+-        return out
+-
+-    def __dealloc__(self):
+-        if self.cumprod != NULL:
+-            mem.PyMem_Free(self.cumprod)
+-
+-cdef bint _check_indices(size_t size, idxint[:] order) except True:
+-    """
+-    Test whether the permutation `order` is a valid permutation of `size`
+-    number of elements.  This is functionally equivalent to
+-
+-    ```
+-    if np.sort(order) != np.arange(size):
+-        raise ValueError
+-    return False
+-    ```
+-
+-    In other words, we test that each integer on [0, size) is present exactly
+-    once in `order`, and raise ValueError if that is not the case (returns True
+-    if an error is detected, and False if not to help pure Cython avoiding
+-    exceptions).
+-    """
+-    if order.shape[0] != size:
+-        raise ValueError("invalid permutation: wrong number of elements")
+-    cdef size_t ptr
+-    cdef idxint value
+-    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
+-    if test == NULL:
+-        raise MemoryError
+-    try:
+-        for ptr in range(size):
+-            value = order[ptr]
+-            if not 0 <= value < size:
+-                raise ValueError("invalid entry in permutation: " + str(value))
+-            if test[value]:
+-                raise ValueError("duplicate entry in permutation: " + str(value))
+-            test[value] = True
+-        return False
+-    finally:
+-        mem.PyMem_Free(test)
+-
+-cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
+-    cdef size_t n_rows=matrix.shape[0]
+-    _check_indices(n_rows, rows)
+-    cdef CSR out = csr.empty_like(matrix)
+-    cdef size_t row, ptr_in, ptr_out, len
+-    out.row_index[0] = 0
+-    for row in range(matrix.shape[0]):
+-        out.row_index[rows[row] + 1] =\
+-            matrix.row_index[row + 1] - matrix.row_index[row]
+-    for row in range(matrix.shape[0]):
+-        out.row_index[row + 1] += out.row_index[row]
+-    for row in range(matrix.shape[0]):
+-        ptr_in = matrix.row_index[row]
+-        ptr_out = out.row_index[rows[row]]
+-        len = matrix.row_index[row + 1] - ptr_in
+-        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
+-        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
+-    return out
+-
+-cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
+-    _check_indices(matrix.shape[0], rows)
+-    _check_indices(matrix.shape[1], cols)
+-    cdef CSR out = csr.empty_like(matrix)
+-    cdef size_t row, ptr_in, ptr_out, len, n
+-    # First build up the row index structure by cumulative sum, so we know
+-    # where to place the data and column indices.  We also use this opportunity
+-    # to find the maximum number of non-zero elements in a row.
+-    with nogil:
+-        len = 0
+-        out.row_index[0] = 0
+-        for row in range(matrix.shape[0]):
+-            n = matrix.row_index[row + 1] - matrix.row_index[row]
+-            out.row_index[rows[row] + 1] = n
+-            len = n if n > len else len
+-        for row in range(matrix.shape[0]):
+-            out.row_index[row + 1] += out.row_index[row]
+-    # Now we know that `len` is the most number of non-zero elements in a row,
+-    # so we can allocate space to sort only once.
+-    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
+-    cdef csr.Sorter sort = csr.Sorter(len)
+-    for row in range(matrix.shape[0]):
+-        ptr_in = matrix.row_index[row]
+-        ptr_out = out.row_index[rows[row]]
+-        len = matrix.row_index[row + 1] - ptr_in
+-        for n in range(len):
+-            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
+-        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
+-                  &matrix.data[ptr_in], new_cols,
+-                  len)
+-    mem.PyMem_Free(new_cols)
+-    return out
+-
+-cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
+-    if row_perm is None and col_perm is None:
+-        return matrix.copy()
+-    if col_perm is None:
+-        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
+-    cdef idxint *rows = NULL
+-    cdef idxint n
+-    if row_perm is None:
+-        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
+-        for n in range(matrix.shape[0]):
+-            rows[n] = n
+-        try:
+-            return _indices_csr_full(matrix,
+-                                     <idxint [:matrix.shape[0]]>rows,
+-                                     np.asarray(col_perm, dtype=idxint_dtype))
+-        finally:
+-            mem.PyMem_Free(rows)
+-    return _indices_csr_full(matrix,
+-                             np.asarray(row_perm, dtype=idxint_dtype),
+-                             np.asarray(col_perm, dtype=idxint_dtype))
+-
+-cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
+-    if row_perm is None and col_perm is None:
+-        return matrix.copy()
+-    array = matrix.as_ndarray()
+-    if row_perm is not None:
+-        array = array[np.argsort(row_perm), :]
+-    if col_perm is not None:
+-        array = array[:, np.argsort(col_perm)]
+-    return Dense(array)
+-
+-
+-cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
+-    if matrix.shape[0] != 1:
+-        raise ValueError("expected bra-like matrix")
+-    cdef size_t nnz = csr.nnz(matrix)
+-    cdef CSR out = csr.empty_like(matrix)
+-    out.row_index[0] = 0
+-    out.row_index[1] = nnz
+-    cdef size_t n
+-    cdef csr.Sorter sort = csr.Sorter(nnz)
+-    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
+-    try:
+-        for n in range(nnz):
+-            new_cols[n] = index.single(matrix.col_index[n])
+-        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
+-        return out
+-    finally:
+-        mem.PyMem_Free(new_cols)
+-
+-cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
+-    cdef CSR out = csr.empty_like(matrix)
+-    cdef csr.Sorter sort
+-    cdef size_t row, n, len=0
+-    cdef idxint ptr_in, ptr_out, col
+-    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
+-    try:
+-        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
+-        with nogil:
+-            for row in range(matrix.shape[0]):
+-                n = matrix.row_index[row + 1] - matrix.row_index[row]
+-                if n:
+-                    idx_lookup[row] = index.single(row)
+-                    out.row_index[idx_lookup[row] + 1] = n
+-                    len = n if n > len else len
+-                else:
+-                    # Use a sentinel value so we can avoid looking up columns
+-                    # that we already know about later.  Not all values in
+-                    # idx_lookup will even be filled---this is the speed up
+-                    # this function achieves over `_indices_csr_all`.
+-                    idx_lookup[row] = -1
+-            for row in range(matrix.shape[0]):
+-                out.row_index[row + 1] += out.row_index[row]
+-        # Since this is very sparse, we expect almost all rows to have at most two
+-        # elements in them.  It will be faster to copy them across, and perform the
+-        # sort in place rather than allocating temporary space and making an
+-        # additional copy.  This will still work even if there are more in a row,
+-        # it just won't be quite as efficient in that case (which should be rare).
+-        sort = csr.Sorter(len)
+-        for row in range(matrix.shape[0]):
+-            ptr_in = matrix.row_index[row]
+-            len = matrix.row_index[row + 1] - ptr_in
+-            if len == 0:
+-                continue
+-            ptr_out = out.row_index[idx_lookup[row]]
+-            for n in range(len):
+-                col = matrix.col_index[ptr_in + n]
+-                if idx_lookup[col] == -1:
+-                    idx_lookup[col] = index.single(col)
+-                out.col_index[ptr_out + n] = idx_lookup[col]
+-            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
+-            sort.inplace(out, ptr_out, len)
+-        return out
+-    finally:
+-        mem.PyMem_Free(idx_lookup)
+-
+-@cython.cdivision(True)
+-cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
+-    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
+-                                   np.asarray(order, dtype=idxint_dtype))
+-    cdef idxint[:] permutation
+-    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
+-        return matrix.copy()
+-    if matrix.shape[0] == 1:
+-        return _dimensions_csr_columns(matrix, index)
+-    if matrix.shape[1] == 1:
+-        return _indices_csr_rowonly(matrix, index.all())
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("dimensional permute requires square operators")
+-    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
+-    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
+-    # calls to `index.single()` than the matrix dimension.  To be sure of this,
+-    # we actually require the density per row to be less than 1/2, because we
+-    # have to look up both the row _and_ column on output.  This only
+-    # corresponds to exceptionally sparse matrices.  We try to avoid these
+-    # calls because index.single has ~logarithmic complexity in the dimension
+-    # (so for qubit systems it's linear in the number of qubits), and
+-    # consequently `index.all()` is a hidden quadratic complexity.
+-    if row_density >= 0.5:
+-        permutation = index.all()
+-        return _indices_csr_full(matrix, permutation, permutation)
+-    return _dimensions_csr_sparse(matrix, index)
+-
+-@cython.cdivision(True)
+-cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
+-    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
+-                                   np.asarray(order, dtype=idxint_dtype))
+-    cdef idxint[:] permutation = index.all()
+-    row_perm, col_perm = None, None
+-    if matrix.shape[0] != 1:
+-        row_perm = permutation
+-    if matrix.shape[1] != 1:
+-        col_perm = permutation
+-    return indices_dense(matrix, row_perm, col_perm)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-dimensions = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='dimensions',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-dimensions.__doc__ =\
+-    """
+-    Reorder the tensor-product structure of a matrix, assuming that the
+-    underlying structure is defined by `dimensions`.  For a separable system,
+-    this function produces a matrix which is equivalent to having performed
+-    `kron` in a different order on the separable parts.
+-
+-    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
+-    respectively, then
+-        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
+-                                                  [2, 3, 4],
+-                                                  [1, 2, 0])
+-    In other words, the inputs to `kron` are reordered so that input `n` moves
+-    to position `order[n]`.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        Input matrix to reorder.  This can either be a square matrix
+-        representing an operator, or a bra- or ket-like vector.
+-
+-    dimensions : 1D array_like of integers
+-        The tensor-product structure of the space the matrix lives on.  This
+-        will typically be one of the two elements of `Qobj.dims` (e.g. for a
+-        ket, it will be `Qobj.dims[0]`).
+-
+-    order : 1D array_like of integers
+-        The new order of the tensor-product elements.  This should be a 1D list
+-        with the integers from `0` to `N - 1` inclusive, if there are `N`
+-        elements in the tensor product.
+-    """
+-dimensions.add_specialisations([
+-    (CSR, CSR, dimensions_csr),
+-    (Dense, Dense, dimensions_dense),
+-], _defer=True)
+-
+-indices = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=None),
+-        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=None),
+-    ]),
+-    name='indices',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-indices.__doc__ =\
+-    """
+-    Permute the rows and columns of a matrix according to a row and column
+-    permutation.  This is a "dumb" operation with regards to the representation
+-    of quantum states; if you want to "reorder" the tensor-product structure of
+-    a system, you want `permute.dimensions` instead.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The input matrix.
+-
+-    row_perm, col_perm : 1D array_like of integer, optional
+-        The new order that the rows or columns should be shuffled into.  If the
+-        input matrix is `N x M`, then `row_perm` would be an array containing
+-        all the integers from `0` to `N - 1` inclusive in some new order.  Row
+-        `n` in the input will be at row `row_perm[n]` in the output, and
+-        similar for the column permutation.
+-    """
+-indices.add_specialisations([
+-    (CSR, CSR, indices_csr),
+-    (Dense, Dense, indices_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.string cimport memset, memcpy
++
++from libcpp cimport bool
++from libcpp.algorithm cimport sort
++
++cimport cython
++
++from cpython cimport mem
++
++import numpy as np
++cimport numpy as cnp
++
++from qutip.core.data.base cimport idxint, idxint_DTYPE
++from qutip.core.data cimport csr, dense, CSR, Dense
++
++from qutip.core.data.base import idxint_dtype
++
++cnp.import_array()
++
++cdef extern from *:
++    void *PyMem_Calloc(size_t n, size_t elsize)
++
++# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
++__all__ = []
++
++
++cdef class _Indexer:
++    cdef size_t ndims, size
++    cdef readonly cnp.ndarray new_dimensions
++    cdef idxint[:] dimensions
++    cdef idxint *cumprod
++
++    def __init__(self, idxint[:] dimensions, idxint[:] order):
++        cdef size_t i
++        cdef idxint dim, ord
++        cdef idxint prev
++        self.ndims = dimensions.shape[0]
++        self.dimensions = dimensions
++        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
++        cdef idxint[:] new_dimensions = self.new_dimensions
++        if order.shape[0] != self.ndims:
++            raise ValueError("invalid order: wrong number of elements")
++        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
++        try:
++            for i in range(self.ndims):
++                ord = order[i]
++                if ord < 0 or ord >= self.ndims:
++                    raise ValueError("invalid order element: " + str(ord))
++                if tmp[ord]:
++                    raise ValueError("duplicate order element: " + str(ord))
++                tmp[ord] = True
++                dim = self.dimensions[ord]
++                if dim < 0:
++                    raise ValueError("found negative dimension: " + str(dim))
++                elif dim == 0:
++                    raise ValueError("found zero dimension")
++                new_dimensions[i] = dim
++        finally:
++            mem.PyMem_Free(tmp)
++        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
++        prev = self.cumprod[order[self.ndims - 1]] = 1
++        for i in range(self.ndims - 2, -1, -1):
++            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
++        self.size = self.cumprod[order[0]] * new_dimensions[0]
++
++    @cython.cdivision(True)
++    cdef cnp.ndarray all(self):
++        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
++        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
++        cdef idxint i
++        for i in range(self.size):
++            _out[i] = self.single(i)
++        return out
++
++    @cython.cdivision(True)
++    cdef idxint single(self, idxint idx) nogil:
++        cdef size_t i
++        cdef idxint out=0, dim
++        for i in range(self.ndims - 1, -1, -1):
++            dim = self.dimensions[i]
++            # Dimensions cannot be zero due to the check in __init__.
++            out += self.cumprod[i] * (idx % dim)
++            idx //= dim
++            if idx == 0:
++                break
++        return out
++
++    def __dealloc__(self):
++        if self.cumprod != NULL:
++            mem.PyMem_Free(self.cumprod)
++
++cdef bint _check_indices(size_t size, idxint[:] order) except True:
++    """
++    Test whether the permutation `order` is a valid permutation of `size`
++    number of elements.  This is functionally equivalent to
++
++    ```
++    if np.sort(order) != np.arange(size):
++        raise ValueError
++    return False
++    ```
++
++    In other words, we test that each integer on [0, size) is present exactly
++    once in `order`, and raise ValueError if that is not the case (returns True
++    if an error is detected, and False if not to help pure Cython avoiding
++    exceptions).
++    """
++    if order.shape[0] != size:
++        raise ValueError("invalid permutation: wrong number of elements")
++    cdef size_t ptr
++    cdef idxint value
++    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
++    if test == NULL:
++        raise MemoryError
++    try:
++        for ptr in range(size):
++            value = order[ptr]
++            if not 0 <= value < size:
++                raise ValueError("invalid entry in permutation: " + str(value))
++            if test[value]:
++                raise ValueError("duplicate entry in permutation: " + str(value))
++            test[value] = True
++        return False
++    finally:
++        mem.PyMem_Free(test)
++
++cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
++    cdef size_t n_rows=matrix.shape[0]
++    _check_indices(n_rows, rows)
++    cdef CSR out = csr.empty_like(matrix)
++    cdef size_t row, ptr_in, ptr_out, len
++    out.row_index[0] = 0
++    for row in range(matrix.shape[0]):
++        out.row_index[rows[row] + 1] =\
++            matrix.row_index[row + 1] - matrix.row_index[row]
++    for row in range(matrix.shape[0]):
++        out.row_index[row + 1] += out.row_index[row]
++    for row in range(matrix.shape[0]):
++        ptr_in = matrix.row_index[row]
++        ptr_out = out.row_index[rows[row]]
++        len = matrix.row_index[row + 1] - ptr_in
++        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
++        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
++    return out
++
++cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
++    _check_indices(matrix.shape[0], rows)
++    _check_indices(matrix.shape[1], cols)
++    cdef CSR out = csr.empty_like(matrix)
++    cdef size_t row, ptr_in, ptr_out, len, n
++    # First build up the row index structure by cumulative sum, so we know
++    # where to place the data and column indices.  We also use this opportunity
++    # to find the maximum number of non-zero elements in a row.
++    with nogil:
++        len = 0
++        out.row_index[0] = 0
++        for row in range(matrix.shape[0]):
++            n = matrix.row_index[row + 1] - matrix.row_index[row]
++            out.row_index[rows[row] + 1] = n
++            len = n if n > len else len
++        for row in range(matrix.shape[0]):
++            out.row_index[row + 1] += out.row_index[row]
++    # Now we know that `len` is the most number of non-zero elements in a row,
++    # so we can allocate space to sort only once.
++    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
++    cdef csr.Sorter sort = csr.Sorter(len)
++    for row in range(matrix.shape[0]):
++        ptr_in = matrix.row_index[row]
++        ptr_out = out.row_index[rows[row]]
++        len = matrix.row_index[row + 1] - ptr_in
++        for n in range(len):
++            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
++        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
++                  &matrix.data[ptr_in], new_cols,
++                  len)
++    mem.PyMem_Free(new_cols)
++    return out
++
++cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
++    if row_perm is None and col_perm is None:
++        return matrix.copy()
++    if col_perm is None:
++        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
++    cdef idxint *rows = NULL
++    cdef idxint n
++    if row_perm is None:
++        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
++        for n in range(matrix.shape[0]):
++            rows[n] = n
++        try:
++            return _indices_csr_full(matrix,
++                                     <idxint [:matrix.shape[0]]>rows,
++                                     np.asarray(col_perm, dtype=idxint_dtype))
++        finally:
++            mem.PyMem_Free(rows)
++    return _indices_csr_full(matrix,
++                             np.asarray(row_perm, dtype=idxint_dtype),
++                             np.asarray(col_perm, dtype=idxint_dtype))
++
++cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
++    if row_perm is None and col_perm is None:
++        return matrix.copy()
++    array = matrix.as_ndarray()
++    if row_perm is not None:
++        array = array[np.argsort(row_perm), :]
++    if col_perm is not None:
++        array = array[:, np.argsort(col_perm)]
++    return Dense(array)
++
++
++cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
++    if matrix.shape[0] != 1:
++        raise ValueError("expected bra-like matrix")
++    cdef size_t nnz = csr.nnz(matrix)
++    cdef CSR out = csr.empty_like(matrix)
++    out.row_index[0] = 0
++    out.row_index[1] = nnz
++    cdef size_t n
++    cdef csr.Sorter sort = csr.Sorter(nnz)
++    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
++    try:
++        for n in range(nnz):
++            new_cols[n] = index.single(matrix.col_index[n])
++        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
++        return out
++    finally:
++        mem.PyMem_Free(new_cols)
++
++cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
++    cdef CSR out = csr.empty_like(matrix)
++    cdef csr.Sorter sort
++    cdef size_t row, n, len=0
++    cdef idxint ptr_in, ptr_out, col
++    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
++    try:
++        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
++        with nogil:
++            for row in range(matrix.shape[0]):
++                n = matrix.row_index[row + 1] - matrix.row_index[row]
++                if n:
++                    idx_lookup[row] = index.single(row)
++                    out.row_index[idx_lookup[row] + 1] = n
++                    len = n if n > len else len
++                else:
++                    # Use a sentinel value so we can avoid looking up columns
++                    # that we already know about later.  Not all values in
++                    # idx_lookup will even be filled---this is the speed up
++                    # this function achieves over `_indices_csr_all`.
++                    idx_lookup[row] = -1
++            for row in range(matrix.shape[0]):
++                out.row_index[row + 1] += out.row_index[row]
++        # Since this is very sparse, we expect almost all rows to have at most two
++        # elements in them.  It will be faster to copy them across, and perform the
++        # sort in place rather than allocating temporary space and making an
++        # additional copy.  This will still work even if there are more in a row,
++        # it just won't be quite as efficient in that case (which should be rare).
++        sort = csr.Sorter(len)
++        for row in range(matrix.shape[0]):
++            ptr_in = matrix.row_index[row]
++            len = matrix.row_index[row + 1] - ptr_in
++            if len == 0:
++                continue
++            ptr_out = out.row_index[idx_lookup[row]]
++            for n in range(len):
++                col = matrix.col_index[ptr_in + n]
++                if idx_lookup[col] == -1:
++                    idx_lookup[col] = index.single(col)
++                out.col_index[ptr_out + n] = idx_lookup[col]
++            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
++            sort.inplace(out, ptr_out, len)
++        return out
++    finally:
++        mem.PyMem_Free(idx_lookup)
++
++@cython.cdivision(True)
++cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
++    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
++                                   np.asarray(order, dtype=idxint_dtype))
++    cdef idxint[:] permutation
++    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
++        return matrix.copy()
++    if matrix.shape[0] == 1:
++        return _dimensions_csr_columns(matrix, index)
++    if matrix.shape[1] == 1:
++        return _indices_csr_rowonly(matrix, index.all())
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("dimensional permute requires square operators")
++    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
++    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
++    # calls to `index.single()` than the matrix dimension.  To be sure of this,
++    # we actually require the density per row to be less than 1/2, because we
++    # have to look up both the row _and_ column on output.  This only
++    # corresponds to exceptionally sparse matrices.  We try to avoid these
++    # calls because index.single has ~logarithmic complexity in the dimension
++    # (so for qubit systems it's linear in the number of qubits), and
++    # consequently `index.all()` is a hidden quadratic complexity.
++    if row_density >= 0.5:
++        permutation = index.all()
++        return _indices_csr_full(matrix, permutation, permutation)
++    return _dimensions_csr_sparse(matrix, index)
++
++@cython.cdivision(True)
++cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
++    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
++                                   np.asarray(order, dtype=idxint_dtype))
++    cdef idxint[:] permutation = index.all()
++    row_perm, col_perm = None, None
++    if matrix.shape[0] != 1:
++        row_perm = permutation
++    if matrix.shape[1] != 1:
++        col_perm = permutation
++    return indices_dense(matrix, row_perm, col_perm)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++dimensions = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='dimensions',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++dimensions.__doc__ =\
++    """
++    Reorder the tensor-product structure of a matrix, assuming that the
++    underlying structure is defined by `dimensions`.  For a separable system,
++    this function produces a matrix which is equivalent to having performed
++    `kron` in a different order on the separable parts.
++
++    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
++    respectively, then
++        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
++                                                  [2, 3, 4],
++                                                  [1, 2, 0])
++    In other words, the inputs to `kron` are reordered so that input `n` moves
++    to position `order[n]`.
++
++    Parameters
++    ----------
++    matrix : Data
++        Input matrix to reorder.  This can either be a square matrix
++        representing an operator, or a bra- or ket-like vector.
++
++    dimensions : 1D array_like of integers
++        The tensor-product structure of the space the matrix lives on.  This
++        will typically be one of the two elements of `Qobj.dims` (e.g. for a
++        ket, it will be `Qobj.dims[0]`).
++
++    order : 1D array_like of integers
++        The new order of the tensor-product elements.  This should be a 1D list
++        with the integers from `0` to `N - 1` inclusive, if there are `N`
++        elements in the tensor product.
++    """
++dimensions.add_specialisations([
++    (CSR, CSR, dimensions_csr),
++    (Dense, Dense, dimensions_dense),
++], _defer=True)
++
++indices = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=None),
++        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=None),
++    ]),
++    name='indices',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++indices.__doc__ =\
++    """
++    Permute the rows and columns of a matrix according to a row and column
++    permutation.  This is a "dumb" operation with regards to the representation
++    of quantum states; if you want to "reorder" the tensor-product structure of
++    a system, you want `permute.dimensions` instead.
++
++    Parameters
++    ----------
++    matrix : Data
++        The input matrix.
++
++    row_perm, col_perm : 1D array_like of integer, optional
++        The new order that the rows or columns should be shuffled into.  If the
++        input matrix is `N x M`, then `row_perm` would be an array containing
++        all the integers from `0` to `N - 1` inclusive in some new order.  Row
++        `n` in the input will be at row `row_perm[n]` in the output, and
++        similar for the column permutation.
++    """
++indices.add_specialisations([
++    (CSR, CSR, indices_csr),
++    (Dense, Dense, indices_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/pow.pxd b/qutip/core/data/pow.pxd
+index d74b871f..04a0c79f 100644
+--- a/qutip/core/data/pow.pxd
++++ b/qutip/core/data/pow.pxd
+@@ -1,5 +1,5 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-
+-cpdef CSR pow_csr(CSR matrix, unsigned long long n)
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++
++cpdef CSR pow_csr(CSR matrix, unsigned long long n)
+diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
+index b90a1a44..7c0c6bf7 100644
+--- a/qutip/core/data/pow.pyx
++++ b/qutip/core/data/pow.pyx
+@@ -1,86 +1,86 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-cimport cython
+-
+-from qutip.core.data cimport csr, dense
+-from qutip.core.data.csr cimport CSR
+-from qutip.core.data.dense cimport Dense
+-from qutip.core.data.matmul cimport matmul_csr
+-import numpy as np
+-
+-__all__ = [
+-    'pow', 'pow_csr', 'pow_dense',
+-]
+-
+-
+-@cython.nonecheck(False)
+-@cython.cdivision(True)
+-cpdef CSR pow_csr(CSR matrix, unsigned long long n):
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("matrix power only works with square matrices")
+-    if n == 0:
+-        return csr.identity(matrix.shape[0])
+-    if n == 1:
+-        return matrix.copy()
+-    # We do the matrix power in terms of powers of two, so we can do it
+-    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
+-    # number of set bits in the input.
+-    #
+-    # We don't have to do matrix.copy() or pow.copy() here, because we've
+-    # guaranteed that we won't be returning without at least one matrix
+-    # multiplcation, which will allocate a new matrix.
+-    cdef CSR pow = matrix
+-    cdef CSR out = pow if n & 1 else None
+-    n >>= 1
+-    while n:
+-        pow = matmul_csr(pow, pow)
+-        if n & 1:
+-            out = pow if out is None else matmul_csr(out, pow)
+-        n >>= 1
+-    return out
+-
+-
+-cpdef Dense pow_dense(Dense matrix, unsigned long long n):
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("matrix power only works with square matrices")
+-    if n == 0:
+-        return dense.identity(matrix.shape[0])
+-    if n == 1:
+-        return matrix.copy()
+-    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-pow = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='pow',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-pow.__doc__ =\
+-    """
+-    Compute the integer matrix power of the square input matrix.  The power
+-    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
+-    the same shape.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        Input matrix to take the power of.
+-
+-    n : non-negative integer
+-        The power to which to raise the matrix.
+-    """
+-pow.add_specialisations([
+-    (CSR, CSR, pow_csr),
+-    (Dense, Dense, pow_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++cimport cython
++
++from qutip.core.data cimport csr, dense
++from qutip.core.data.csr cimport CSR
++from qutip.core.data.dense cimport Dense
++from qutip.core.data.matmul cimport matmul_csr
++import numpy as np
++
++__all__ = [
++    'pow', 'pow_csr', 'pow_dense',
++]
++
++
++@cython.nonecheck(False)
++@cython.cdivision(True)
++cpdef CSR pow_csr(CSR matrix, unsigned long long n):
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("matrix power only works with square matrices")
++    if n == 0:
++        return csr.identity(matrix.shape[0])
++    if n == 1:
++        return matrix.copy()
++    # We do the matrix power in terms of powers of two, so we can do it
++    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
++    # number of set bits in the input.
++    #
++    # We don't have to do matrix.copy() or pow.copy() here, because we've
++    # guaranteed that we won't be returning without at least one matrix
++    # multiplcation, which will allocate a new matrix.
++    cdef CSR pow = matrix
++    cdef CSR out = pow if n & 1 else None
++    n >>= 1
++    while n:
++        pow = matmul_csr(pow, pow)
++        if n & 1:
++            out = pow if out is None else matmul_csr(out, pow)
++        n >>= 1
++    return out
++
++
++cpdef Dense pow_dense(Dense matrix, unsigned long long n):
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("matrix power only works with square matrices")
++    if n == 0:
++        return dense.identity(matrix.shape[0])
++    if n == 1:
++        return matrix.copy()
++    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++pow = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='pow',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++pow.__doc__ =\
++    """
++    Compute the integer matrix power of the square input matrix.  The power
++    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
++    the same shape.
++
++    Parameters
++    ----------
++    matrix : Data
++        Input matrix to take the power of.
++
++    n : non-negative integer
++        The power to which to raise the matrix.
++    """
++pow.add_specialisations([
++    (CSR, CSR, pow_csr),
++    (Dense, Dense, pow_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/project.pxd b/qutip/core/data/project.pxd
+index 07dabb79..86baf762 100644
+--- a/qutip/core/data/project.pxd
++++ b/qutip/core/data/project.pxd
+@@ -1,5 +1,5 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.csr cimport CSR
+-
+-cpdef CSR project_csr(CSR state)
++#cython: language_level=3
++
++from qutip.core.data.csr cimport CSR
++
++cpdef CSR project_csr(CSR state)
+diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
+index b88771e3..03a8bf73 100644
+--- a/qutip/core/data/project.pyx
++++ b/qutip/core/data/project.pyx
+@@ -1,144 +1,144 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.string cimport memcpy
+-
+-from qutip.core.data.base cimport idxint
+-from qutip.core.data cimport csr, dense, Dense
+-from qutip.core.data.csr cimport CSR
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex conj(double complex x)
+-
+-__all__ = [
+-    'project', 'project_csr', 'project_dense',
+-]
+-
+-
+-cdef void _project_ket_csr(CSR ket, CSR out) nogil:
+-    """
+-    Calculate the projection of the given ket, and place the output in out.
+-    """
+-    cdef size_t row, ptr, offset=0
+-    cdef idxint nnz_in = csr.nnz(ket)
+-    for row in range(ket.shape[0]):
+-        out.row_index[row] = ket.row_index[row] * nnz_in
+-        if ket.row_index[row + 1] != ket.row_index[row]:
+-            for ptr in range(nnz_in):
+-                out.col_index[offset + ptr*nnz_in] = row
+-            offset += 1
+-    out.row_index[ket.shape[0]] = nnz_in * nnz_in
+-    offset = 0
+-    for row in range(nnz_in):
+-        for ptr in range(nnz_in):
+-            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
+-        offset += nnz_in
+-
+-
+-cdef void _project_bra_csr(CSR bra, CSR out) nogil:
+-    """
+-    Calculate the projection of the given bra, and place the output in out.
+-    """
+-    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
+-    cdef double complex mul
+-    cdef idxint nnz_in = csr.nnz(bra)
+-    # The algorithm is much more simple conceptually if the indices are sorted,
+-    # and doesn't affect runtime much since sorting is worst-case
+-    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
+-    # sort now than later while there are fewer entries.  No need to sort when
+-    # projecting a ket because all the col_index values are 0.
+-    with gil:
+-        bra.sort_indices()
+-    out.row_index[0] = cur
+-    for ptr_bra in range(nnz_in):
+-        # Handle all zero rows between the last non-zero entry and this one.
+-        for row_out in range(row_out, bra.col_index[ptr_bra]):
+-            out.row_index[row_out + 1] = cur
+-        row_out = bra.col_index[ptr_bra]
+-        cur += nnz_in
+-        out.row_index[row_out + 1] = cur
+-        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
+-        mul = conj(bra.data[ptr_bra])
+-        for ptr in range(nnz_in):
+-            out.data[ptr_out] = mul * bra.data[ptr]
+-            ptr_out += 1
+-        row_out += 1
+-    # Handle all zero rows after the last non-zero entry.
+-    for row_out in range(row_out, out.shape[0]):
+-        out.row_index[row_out + 1] = cur
+-
+-cpdef CSR project_csr(CSR state):
+-    """
+-    Calculate the projection |state><state|.  The shape of `state` will be used
+-    to determine if it has been supplied as a ket or a bra.  The result of this
+-    function will be identical is passed `state` or `adjoint(state)`.
+-    """
+-    cdef size_t nnz_in = csr.nnz(state)
+-    cdef CSR out
+-    # We don't actually need to both handling the shape=(1, 1) case specially,
+-    # because it doesn't matter if we interpret it as a ket or a bra---the
+-    # output will be a shape=(1, 1) matrix with the only data element equal to
+-    # abs(state.data[0])**2 either way.
+-    if state.shape[1] == 1:
+-        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
+-        _project_ket_csr(state, out)
+-        return out
+-    if state.shape[0] == 1:
+-        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
+-        _project_bra_csr(state, out)
+-        return out
+-    raise ValueError("state must be a ket or a bra.")
+-
+-cpdef Dense project_dense(Dense state):
+-    """
+-    Calculate the projection |state><state|.  The shape of `state` will be used
+-    to determine if it has been supplied as a ket or a bra.  The result of this
+-    function will be identical is passed `state` or `adjoint(state)`.
+-    """
+-    cdef Dense out
+-    cdef size_t size, i
+-    cdef bint fortran
+-    if state.shape[1] == 1:
+-        size = state.shape[0]
+-        fortran = True
+-    elif state.shape[0] == 1:
+-        size = state.shape[1]
+-        fortran = False
+-    else:
+-        raise ValueError("state must be a ket or a bra.")
+-    out = dense.zeros(size, size, fortran)
+-    for i in range(size):
+-        for j in range(size):
+-            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
+-    return out
+-
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-project = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='project',
+-    module=__name__,
+-    inputs=('state',),
+-    out=True,
+-)
+-project.__doc__ =\
+-    """
+-    Get the projector of a state with itself.  Mathematically, if passed an
+-    object `|a>` or `<a|`, then return the matrix `|a><a|`.
+-
+-    Parameters
+-    ----------
+-    state : Data
+-        The input state bra- or ket-like vector.
+-    """
+-project.add_specialisations([
+-    (CSR, CSR, project_csr),
+-    (Dense, Dense, project_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.string cimport memcpy
++
++from qutip.core.data.base cimport idxint
++from qutip.core.data cimport csr, dense, Dense
++from qutip.core.data.csr cimport CSR
++
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex conj(double complex x)
++
++__all__ = [
++    'project', 'project_csr', 'project_dense',
++]
++
++
++cdef void _project_ket_csr(CSR ket, CSR out) nogil:
++    """
++    Calculate the projection of the given ket, and place the output in out.
++    """
++    cdef size_t row, ptr, offset=0
++    cdef idxint nnz_in = csr.nnz(ket)
++    for row in range(ket.shape[0]):
++        out.row_index[row] = ket.row_index[row] * nnz_in
++        if ket.row_index[row + 1] != ket.row_index[row]:
++            for ptr in range(nnz_in):
++                out.col_index[offset + ptr*nnz_in] = row
++            offset += 1
++    out.row_index[ket.shape[0]] = nnz_in * nnz_in
++    offset = 0
++    for row in range(nnz_in):
++        for ptr in range(nnz_in):
++            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
++        offset += nnz_in
++
++
++cdef void _project_bra_csr(CSR bra, CSR out) nogil:
++    """
++    Calculate the projection of the given bra, and place the output in out.
++    """
++    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
++    cdef double complex mul
++    cdef idxint nnz_in = csr.nnz(bra)
++    # The algorithm is much more simple conceptually if the indices are sorted,
++    # and doesn't affect runtime much since sorting is worst-case
++    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
++    # sort now than later while there are fewer entries.  No need to sort when
++    # projecting a ket because all the col_index values are 0.
++    with gil:
++        bra.sort_indices()
++    out.row_index[0] = cur
++    for ptr_bra in range(nnz_in):
++        # Handle all zero rows between the last non-zero entry and this one.
++        for row_out in range(row_out, bra.col_index[ptr_bra]):
++            out.row_index[row_out + 1] = cur
++        row_out = bra.col_index[ptr_bra]
++        cur += nnz_in
++        out.row_index[row_out + 1] = cur
++        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
++        mul = conj(bra.data[ptr_bra])
++        for ptr in range(nnz_in):
++            out.data[ptr_out] = mul * bra.data[ptr]
++            ptr_out += 1
++        row_out += 1
++    # Handle all zero rows after the last non-zero entry.
++    for row_out in range(row_out, out.shape[0]):
++        out.row_index[row_out + 1] = cur
++
++cpdef CSR project_csr(CSR state):
++    """
++    Calculate the projection |state><state|.  The shape of `state` will be used
++    to determine if it has been supplied as a ket or a bra.  The result of this
++    function will be identical is passed `state` or `adjoint(state)`.
++    """
++    cdef size_t nnz_in = csr.nnz(state)
++    cdef CSR out
++    # We don't actually need to both handling the shape=(1, 1) case specially,
++    # because it doesn't matter if we interpret it as a ket or a bra---the
++    # output will be a shape=(1, 1) matrix with the only data element equal to
++    # abs(state.data[0])**2 either way.
++    if state.shape[1] == 1:
++        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
++        _project_ket_csr(state, out)
++        return out
++    if state.shape[0] == 1:
++        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
++        _project_bra_csr(state, out)
++        return out
++    raise ValueError("state must be a ket or a bra.")
++
++cpdef Dense project_dense(Dense state):
++    """
++    Calculate the projection |state><state|.  The shape of `state` will be used
++    to determine if it has been supplied as a ket or a bra.  The result of this
++    function will be identical is passed `state` or `adjoint(state)`.
++    """
++    cdef Dense out
++    cdef size_t size, i
++    cdef bint fortran
++    if state.shape[1] == 1:
++        size = state.shape[0]
++        fortran = True
++    elif state.shape[0] == 1:
++        size = state.shape[1]
++        fortran = False
++    else:
++        raise ValueError("state must be a ket or a bra.")
++    out = dense.zeros(size, size, fortran)
++    for i in range(size):
++        for j in range(size):
++            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
++    return out
++
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++project = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='project',
++    module=__name__,
++    inputs=('state',),
++    out=True,
++)
++project.__doc__ =\
++    """
++    Get the projector of a state with itself.  Mathematically, if passed an
++    object `|a>` or `<a|`, then return the matrix `|a><a|`.
++
++    Parameters
++    ----------
++    state : Data
++        The input state bra- or ket-like vector.
++    """
++project.add_specialisations([
++    (CSR, CSR, project_csr),
++    (Dense, Dense, project_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/properties.pxd b/qutip/core/data/properties.pxd
+index 57424d96..9ce22e12 100644
+--- a/qutip/core/data/properties.pxd
++++ b/qutip/core/data/properties.pxd
+@@ -1,8 +1,8 @@
+-#cython: language_level=3
+-
+-from qutip.core.data cimport CSR, Dense
+-
+-cpdef bint isherm_csr(CSR matrix, double tol=*)
+-cpdef bint isdiag_csr(CSR matrix) nogil
+-cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
+-cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
++#cython: language_level=3
++
++from qutip.core.data cimport CSR, Dense
++
++cpdef bint isherm_csr(CSR matrix, double tol=*)
++cpdef bint isdiag_csr(CSR matrix) nogil
++cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
++cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
+diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
+index ded226cb..38116cab 100644
+--- a/qutip/core/data/properties.pyx
++++ b/qutip/core/data/properties.pyx
+@@ -1,319 +1,319 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-cimport cython
+-from cpython cimport mem
+-
+-from qutip.settings import settings
+-
+-from qutip.core.data.base cimport idxint
+-from qutip.core.data cimport csr, dense, CSR, Dense
+-from qutip.core.data.adjoint cimport transpose_csr
+-
+-cdef extern from *:
+-    # Not defined in cpython.mem for some reason, but is in pymem.h.
+-    void *PyMem_Calloc(size_t nelem, size_t elsize)
+-
+-__all__ = [
+-    'isherm', 'isherm_csr', 'isherm_dense',
+-    'isdiag', 'isdiag_csr', 'isdiag_dense',
+-    'iszero', 'iszero_csr', 'iszero_dense',
+-]
+-
+-cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
+-    """Check whether a == conj(b) up to an absolute tolerance."""
+-    cdef double re = a.real - b.real
+-    cdef double im = a.imag + b.imag
+-    # Comparing the squares should be fine---there is possible precision loss
+-    # in the addition, but as re*re and im*im are both positive semidefinite,
+-    # the floating point result is strictly not greater than the true value.
+-    # Save the cycles: don't sqrt.
+-    return re*re + im*im < tol*tol
+-
+-cdef inline bint _feq_zero(double complex a, double tol) nogil:
+-    return a.real*a.real + a.imag*a.imag < tol*tol
+-
+-cdef inline double _abssq(double complex x) nogil:
+-    return x.real*x.real + x.imag*x.imag
+-
+-
+-cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
+-    """
+-    Full, structural test for Hermicity of a matrix.  We assume that the input
+-    matrix has already had its shape tested (must be square).
+-
+-    This test is only necessary when there is at least one value which is less
+-    than the tolerance, and needed to be compared to an implicit zero.  In
+-    general it is less efficient than the other test, and allocates more
+-    memory.
+-    """
+-    cdef CSR transpose = transpose_csr(matrix)
+-    cdef idxint row, ptr_a, ptr_b, col_a, col_b
+-    for row in range(matrix.shape[0]):
+-        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
+-        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
+-        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
+-            # Doing this on every loop actually involves a few more
+-            # de-references than are strictly necessary, but just
+-            # simplifies the logic checking for the end of the row.
+-            col_a = matrix.col_index[ptr_a]
+-            col_b = transpose.col_index[ptr_b]
+-            if col_a == col_b:
+-                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
+-                    return False
+-                ptr_a += 1
+-                ptr_b += 1
+-            elif col_a < col_b:
+-                if not _feq_zero(matrix.data[ptr_a], tol):
+-                    return False
+-                ptr_a += 1
+-            else:
+-                if not _feq_zero(transpose.data[ptr_b], tol):
+-                    return False
+-                ptr_b += 1
+-        for ptr_a in range(ptr_a, ptr_a_end):
+-            if not _feq_zero(matrix.data[ptr_a], tol):
+-                return False
+-        for ptr_b in range(ptr_b, ptr_b_end):
+-            if not _feq_zero(transpose.data[ptr_b], tol):
+-                return False
+-    return True
+-
+-cpdef bint isherm_csr(CSR matrix, double tol=-1):
+-    """
+-    Determine whether an input CSR matrix is Hermitian up to a given
+-    floating-point tolerance.
+-
+-    Parameters
+-    ----------
+-    matrix : CSR
+-        Input matrix to test
+-    tol : double, optional
+-        Absolute tolerance value to use.  Defaults to
+-        :obj:`settings.core['atol']`.
+-
+-    Returns
+-    -------
+-    bint
+-        Boolean True if it is Hermitian, False if not.
+-
+-    Notes
+-    -----
+-    The implementation is effectively just taking the adjoint, but rather than
+-    actually allocating and creating a new matrix, we just check whether the
+-    output would match the input matrix.  If we cannot be certain of Hermicity
+-    because the sizes of some elements are within tolerance of 0, we have to
+-    resort to a complete adjoint calculation.
+-    """
+-    tol = tol if tol >= 0 else settings.core["atol"]
+-    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
+-    if matrix.shape[0] != matrix.shape[1]:
+-        return False
+-    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
+-    if out_row_index == NULL:
+-        raise MemoryError
+-    matrix.sort_indices()
+-    try:
+-        for row in range(nrows):
+-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-                col = matrix.col_index[ptr] + 1
+-                out_row_index[col] += 1
+-        for row in range(nrows):
+-            out_row_index[row+1] += out_row_index[row]
+-            if out_row_index[row + 1] != matrix.row_index[row + 1]:
+-                # Structures are not the same, but it could still be Hermitian
+-                # if any value is less than the tolerance.  That is the
+-                # worst-case scenario, so we sacrifice its speed in favour of
+-                # returning faster for the more common failure cases.
+-                for ptr in range(matrix.row_index[nrows]):
+-                    if _conj_feq(matrix.data[ptr], 0, tol):
+-                        return _isherm_csr_full(matrix, tol)
+-                return False
+-        for row in range(nrows):
+-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-                col = matrix.col_index[ptr]
+-                # Pointer into the "transposed" matrix.
+-                ptr_t = out_row_index[col]
+-                out_row_index[col] += 1
+-                if row != matrix.col_index[ptr_t]:
+-                    return _isherm_csr_full(matrix, tol)
+-                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
+-                    return False
+-        return True
+-    finally:
+-        mem.PyMem_Free(out_row_index)
+-
+-
+-cpdef bint isherm_dense(Dense matrix, double tol=-1):
+-    """
+-    Determine whether an input Dense matrix is Hermitian up to a given
+-    floating-point tolerance.
+-
+-    Parameters
+-    ----------
+-    matrix : Dense
+-        Input matrix to test
+-    tol : double, optional
+-        Absolute tolerance value to use.  Defaults to
+-        :obj:`settings.core['atol']`.
+-
+-    Returns
+-    -------
+-    bint
+-        Boolean True if it is Hermitian, False if not.
+-    """
+-    if matrix.shape[0] != matrix.shape[1]:
+-        return False
+-    tol = tol if tol >= 0 else settings.core["atol"]
+-    cdef size_t row, col, size=matrix.shape[0]
+-    for row in range(size):
+-        for col in range(row + 1):
+-            if not _conj_feq(
+-                matrix.data[col*size+row],
+-                matrix.data[row*size+col],
+-                tol
+-            ):
+-                return False
+-    return True
+-
+-
+-cpdef bint isdiag_csr(CSR matrix) nogil:
+-    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
+-    for row in range(matrix.shape[0]):
+-        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
+-        if ptr_end - ptr_start > 1:
+-            return False
+-        if ptr_end - ptr_start == 1:
+-            if matrix.col_index[ptr_start] != row:
+-                return False
+-    return True
+-
+-
+-cpdef bint isdiag_dense(Dense matrix) nogil:
+-    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
+-    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
+-    for row in range(matrix.shape[0]):
+-        for col in range(matrix.shape[1]):
+-            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
+-                return False
+-    return True
+-
+-
+-cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
+-    cdef size_t ptr
+-    if tol < 0:
+-        with gil:
+-            tol = settings.core["atol"]
+-    tolsq = tol*tol
+-    for ptr in range(csr.nnz(matrix)):
+-        if _abssq(matrix.data[ptr]) > tolsq:
+-            return False
+-    return True
+-
+-cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
+-    cdef size_t ptr
+-    if tol < 0:
+-        with gil:
+-            tol = settings.core["atol"]
+-    tolsq = tol*tol
+-    for ptr in range(matrix.shape[0]*matrix.shape[1]):
+-        if _abssq(matrix.data[ptr]) > tolsq:
+-            return False
+-    return True
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-isherm = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=-1),
+-    ]),
+-    name='isherm',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-isherm.__doc__ =\
+-    """
+-    Check if the matrix is Hermitian up to a optional element-wise absolute
+-    tolerance.  If the tolerance given is less than zero, the global settings
+-    value `qutip.settings.atol` will be used instead.
+-
+-    Only square matrices can possibly be Hermitian.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to test for Hermicity.
+-
+-    tol : real, optional
+-        If given, the absolute tolerance used to compare two values for
+-        equality.  If not given, or given and negative, the value of
+-        `qutip.settings.atol` is used instead.
+-    """
+-isherm.add_specialisations([
+-    (Dense, isherm_dense),
+-    (CSR, isherm_csr),
+-], _defer=True)
+-
+-isdiag = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='isdiag',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-isdiag.__doc__ =\
+-    """
+-    Check if the matrix is diagonal.  The matrix need not be square to test.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to test for diagonality.
+-    """
+-isdiag.add_specialisations([
+-    (Dense, isdiag_dense),
+-    (CSR, isdiag_csr),
+-], _defer=True)
+-
+-iszero = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=-1),
+-    ]),
+-    name='iszero',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-iszero.__doc__ =\
+-    """
+-    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to test.
+-    tol : real, optional
+-        The absolute tolerance to use when comparing to zero.  If not given, or
+-        less than 0, use the core setting `atol`.
+-
+-    Returns
+-    -------
+-    bool
+-        Whether the matrix is equivalent to 0 under the given absolute
+-        tolerance.
+-    """
+-iszero.add_specialisations([
+-    (CSR, iszero_csr),
+-    (Dense, iszero_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++cimport cython
++from cpython cimport mem
++
++from qutip.settings import settings
++
++from qutip.core.data.base cimport idxint
++from qutip.core.data cimport csr, dense, CSR, Dense
++from qutip.core.data.adjoint cimport transpose_csr
++
++cdef extern from *:
++    # Not defined in cpython.mem for some reason, but is in pymem.h.
++    void *PyMem_Calloc(size_t nelem, size_t elsize)
++
++__all__ = [
++    'isherm', 'isherm_csr', 'isherm_dense',
++    'isdiag', 'isdiag_csr', 'isdiag_dense',
++    'iszero', 'iszero_csr', 'iszero_dense',
++]
++
++cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
++    """Check whether a == conj(b) up to an absolute tolerance."""
++    cdef double re = a.real - b.real
++    cdef double im = a.imag + b.imag
++    # Comparing the squares should be fine---there is possible precision loss
++    # in the addition, but as re*re and im*im are both positive semidefinite,
++    # the floating point result is strictly not greater than the true value.
++    # Save the cycles: don't sqrt.
++    return re*re + im*im < tol*tol
++
++cdef inline bint _feq_zero(double complex a, double tol) nogil:
++    return a.real*a.real + a.imag*a.imag < tol*tol
++
++cdef inline double _abssq(double complex x) nogil:
++    return x.real*x.real + x.imag*x.imag
++
++
++cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
++    """
++    Full, structural test for Hermicity of a matrix.  We assume that the input
++    matrix has already had its shape tested (must be square).
++
++    This test is only necessary when there is at least one value which is less
++    than the tolerance, and needed to be compared to an implicit zero.  In
++    general it is less efficient than the other test, and allocates more
++    memory.
++    """
++    cdef CSR transpose = transpose_csr(matrix)
++    cdef idxint row, ptr_a, ptr_b, col_a, col_b
++    for row in range(matrix.shape[0]):
++        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
++        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
++        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
++            # Doing this on every loop actually involves a few more
++            # de-references than are strictly necessary, but just
++            # simplifies the logic checking for the end of the row.
++            col_a = matrix.col_index[ptr_a]
++            col_b = transpose.col_index[ptr_b]
++            if col_a == col_b:
++                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
++                    return False
++                ptr_a += 1
++                ptr_b += 1
++            elif col_a < col_b:
++                if not _feq_zero(matrix.data[ptr_a], tol):
++                    return False
++                ptr_a += 1
++            else:
++                if not _feq_zero(transpose.data[ptr_b], tol):
++                    return False
++                ptr_b += 1
++        for ptr_a in range(ptr_a, ptr_a_end):
++            if not _feq_zero(matrix.data[ptr_a], tol):
++                return False
++        for ptr_b in range(ptr_b, ptr_b_end):
++            if not _feq_zero(transpose.data[ptr_b], tol):
++                return False
++    return True
++
++cpdef bint isherm_csr(CSR matrix, double tol=-1):
++    """
++    Determine whether an input CSR matrix is Hermitian up to a given
++    floating-point tolerance.
++
++    Parameters
++    ----------
++    matrix : CSR
++        Input matrix to test
++    tol : double, optional
++        Absolute tolerance value to use.  Defaults to
++        :obj:`settings.core['atol']`.
++
++    Returns
++    -------
++    bint
++        Boolean True if it is Hermitian, False if not.
++
++    Notes
++    -----
++    The implementation is effectively just taking the adjoint, but rather than
++    actually allocating and creating a new matrix, we just check whether the
++    output would match the input matrix.  If we cannot be certain of Hermicity
++    because the sizes of some elements are within tolerance of 0, we have to
++    resort to a complete adjoint calculation.
++    """
++    tol = tol if tol >= 0 else settings.core["atol"]
++    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
++    if matrix.shape[0] != matrix.shape[1]:
++        return False
++    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
++    if out_row_index == NULL:
++        raise MemoryError
++    matrix.sort_indices()
++    try:
++        for row in range(nrows):
++            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++                col = matrix.col_index[ptr] + 1
++                out_row_index[col] += 1
++        for row in range(nrows):
++            out_row_index[row+1] += out_row_index[row]
++            if out_row_index[row + 1] != matrix.row_index[row + 1]:
++                # Structures are not the same, but it could still be Hermitian
++                # if any value is less than the tolerance.  That is the
++                # worst-case scenario, so we sacrifice its speed in favour of
++                # returning faster for the more common failure cases.
++                for ptr in range(matrix.row_index[nrows]):
++                    if _conj_feq(matrix.data[ptr], 0, tol):
++                        return _isherm_csr_full(matrix, tol)
++                return False
++        for row in range(nrows):
++            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++                col = matrix.col_index[ptr]
++                # Pointer into the "transposed" matrix.
++                ptr_t = out_row_index[col]
++                out_row_index[col] += 1
++                if row != matrix.col_index[ptr_t]:
++                    return _isherm_csr_full(matrix, tol)
++                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
++                    return False
++        return True
++    finally:
++        mem.PyMem_Free(out_row_index)
++
++
++cpdef bint isherm_dense(Dense matrix, double tol=-1):
++    """
++    Determine whether an input Dense matrix is Hermitian up to a given
++    floating-point tolerance.
++
++    Parameters
++    ----------
++    matrix : Dense
++        Input matrix to test
++    tol : double, optional
++        Absolute tolerance value to use.  Defaults to
++        :obj:`settings.core['atol']`.
++
++    Returns
++    -------
++    bint
++        Boolean True if it is Hermitian, False if not.
++    """
++    if matrix.shape[0] != matrix.shape[1]:
++        return False
++    tol = tol if tol >= 0 else settings.core["atol"]
++    cdef size_t row, col, size=matrix.shape[0]
++    for row in range(size):
++        for col in range(row + 1):
++            if not _conj_feq(
++                matrix.data[col*size+row],
++                matrix.data[row*size+col],
++                tol
++            ):
++                return False
++    return True
++
++
++cpdef bint isdiag_csr(CSR matrix) nogil:
++    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
++    for row in range(matrix.shape[0]):
++        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
++        if ptr_end - ptr_start > 1:
++            return False
++        if ptr_end - ptr_start == 1:
++            if matrix.col_index[ptr_start] != row:
++                return False
++    return True
++
++
++cpdef bint isdiag_dense(Dense matrix) nogil:
++    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
++    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
++    for row in range(matrix.shape[0]):
++        for col in range(matrix.shape[1]):
++            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
++                return False
++    return True
++
++
++cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
++    cdef size_t ptr
++    if tol < 0:
++        with gil:
++            tol = settings.core["atol"]
++    tolsq = tol*tol
++    for ptr in range(csr.nnz(matrix)):
++        if _abssq(matrix.data[ptr]) > tolsq:
++            return False
++    return True
++
++cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
++    cdef size_t ptr
++    if tol < 0:
++        with gil:
++            tol = settings.core["atol"]
++    tolsq = tol*tol
++    for ptr in range(matrix.shape[0]*matrix.shape[1]):
++        if _abssq(matrix.data[ptr]) > tolsq:
++            return False
++    return True
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++isherm = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=-1),
++    ]),
++    name='isherm',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++isherm.__doc__ =\
++    """
++    Check if the matrix is Hermitian up to a optional element-wise absolute
++    tolerance.  If the tolerance given is less than zero, the global settings
++    value `qutip.settings.atol` will be used instead.
++
++    Only square matrices can possibly be Hermitian.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to test for Hermicity.
++
++    tol : real, optional
++        If given, the absolute tolerance used to compare two values for
++        equality.  If not given, or given and negative, the value of
++        `qutip.settings.atol` is used instead.
++    """
++isherm.add_specialisations([
++    (Dense, isherm_dense),
++    (CSR, isherm_csr),
++], _defer=True)
++
++isdiag = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='isdiag',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++isdiag.__doc__ =\
++    """
++    Check if the matrix is diagonal.  The matrix need not be square to test.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to test for diagonality.
++    """
++isdiag.add_specialisations([
++    (Dense, isdiag_dense),
++    (CSR, isdiag_csr),
++], _defer=True)
++
++iszero = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=-1),
++    ]),
++    name='iszero',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++iszero.__doc__ =\
++    """
++    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to test.
++    tol : real, optional
++        The absolute tolerance to use when comparing to zero.  If not given, or
++        less than 0, use the core setting `atol`.
++
++    Returns
++    -------
++    bool
++        Whether the matrix is equivalent to 0 under the given absolute
++        tolerance.
++    """
++iszero.add_specialisations([
++    (CSR, iszero_csr),
++    (Dense, iszero_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/ptrace.pxd b/qutip/core/data/ptrace.pxd
+index 6689bafa..a233d0c0 100644
+--- a/qutip/core/data/ptrace.pxd
++++ b/qutip/core/data/ptrace.pxd
+@@ -1,7 +1,7 @@
+-#cython: language_level=3
+-
+-from qutip.core.data cimport CSR, Dense
+-
+-cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
+-cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
+-cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
++#cython: language_level=3
++
++from qutip.core.data cimport CSR, Dense
++
++cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
++cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
++cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
+diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
+index 3e58e82d..e45522ef 100644
+--- a/qutip/core/data/ptrace.pyx
++++ b/qutip/core/data/ptrace.pyx
+@@ -1,216 +1,216 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
+-
+-import numbers
+-
+-import numpy as np
+-
+-cimport numpy as cnp
+-
+-from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
+-from qutip.core.data.base import idxint_dtype
+-from qutip.settings import settings
+-
+-cnp.import_array()
+-
+-__all__ = [
+-    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
+-]
+-
+-cdef tuple _parse_inputs(object dims, object sel, tuple shape):
+-    cdef Py_ssize_t i
+-
+-    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
+-    sel = np.atleast_1d(sel).astype(idxint_dtype)
+-    sel.sort()
+-
+-    if shape[0] != shape[1]:
+-        raise ValueError("ptrace is only defined for square density matrices")
+-
+-    if shape[0] != np.prod(dims, dtype=int):
+-        raise ValueError(f"the input matrix shape, {shape} and the"
+-                         f" dimension argument, {dims}, are not compatible.")
+-    if sel.ndim != 1:
+-        raise ValueError("Selection must be one-dimensional")
+-
+-    if any(d < 1 for d in dims):
+-        raise ValueError("dimensions must be greated than zero but where"
+-                         f" dims={dims}.")
+-
+-    for i in range(sel.shape[0]):
+-        if sel[i] < 0 or sel[i] >= dims.size:
+-            raise IndexError("Invalid selection index in ptrace.")
+-        if i > 0 and sel[i] == sel[i - 1]:
+-            raise ValueError("Duplicate selection index in ptrace.")
+-
+-    return dims, sel
+-
+-cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
+-    """
+-    Populate the helper structure `tensor_table`.  Returns the size (number of
+-    rows and number of columns) of the matrix which will be output.
+-    """
+-    cdef size_t ii
+-    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
+-    cdef size_t num_dims = _dims.shape[0]
+-    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
+-    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
+-    for ii in range(_sel.shape[0]):
+-        if _sel[ii] < 0 or _sel[ii] >= num_dims:
+-            raise TypeError("Invalid selection index in ptrace.")
+-    for ii in range(num_dims - 1,-1,-1):
+-        tensor_table[ii, 0] = factor_tensor
+-        factor_tensor *= _dims[ii]
+-        if _in(ii, _sel):
+-            tensor_table[ii, 1] = factor_keep
+-            factor_keep *= _dims[ii]
+-        else:
+-            tensor_table[ii, 2]  = factor_trace
+-            factor_trace *= _dims[ii]
+-    return factor_keep
+-
+-
+-cdef bint _in(idxint val, idxint[::1] vec):
+-    cdef int ii
+-    for ii in range(vec.shape[0]):
+-        if val == vec[ii]:
+-            return True
+-    return False
+-
+-
+-cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
+-    # indices determining function for ptrace
+-    cdef size_t ii
+-    cdef idxint t1, t2
+-    out[0] = out[1] = 0
+-    for ii in range(tensor_table.shape[0]):
+-        t1 = tensor_table[ii, 0]
+-        t2 = N / t1
+-        N = N % t1
+-        out[0] += tensor_table[ii, 1] * t2
+-        out[1] += tensor_table[ii, 2] * t2
+-
+-
+-cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
+-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+-
+-    if len(sel) == len(dims):
+-        return matrix.copy()
+-    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+-    cdef idxint size
+-    size = _populate_tensor_table(dims, sel, tensor_table)
+-    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
+-    cdef idxint pos_c[2]
+-    cdef idxint pos_r[2]
+-    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
+-    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
+-    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
+-    cdef double tol = 0
+-    if settings.core['auto_tidyup']:
+-        tol = settings.core['auto_tidyup_atol']
+-    for row in range(matrix.shape[0]):
+-        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
+-            _i2_k_t(row, tensor_table, pos_r)
+-            if pos_c[1] == pos_r[1]:
+-                new_data[p] = matrix.data[ptr]
+-                new_row[p] = pos_r[0]
+-                new_col[p] = pos_c[0]
+-                p += 1
+-    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
+-                                 size, size, p, tol)
+-
+-
+-cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
+-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+-
+-    if len(sel) == len(dims):
+-        return dense.from_csr(matrix)
+-    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+-    cdef idxint size
+-    size = _populate_tensor_table(dims, sel, tensor_table)
+-    cdef size_t ii, jj
+-    cdef idxint pos_c[2]
+-    cdef idxint pos_r[2]
+-    cdef Dense out = dense.zeros(size, size, fortran=False)
+-    for ii in range(matrix.shape[0]):
+-        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
+-            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
+-            _i2_k_t(ii, tensor_table, pos_r)
+-            if pos_c[1] == pos_r[1]:
+-                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
+-    return out
+-
+-
+-cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
+-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+-
+-    if len(sel) == len(dims):
+-        return matrix.copy()
+-    nd = dims.shape[0]
+-    dkeep = [dims[x] for x in sel]
+-    qtrace = list(set(np.arange(nd)) - set(sel))
+-    dtrace = [dims[x] for x in qtrace]
+-    dims = list(dims)
+-    sel = list(sel)
+-    rhomat = np.trace(matrix.as_ndarray()
+-                      .reshape(dims + dims)
+-                      .transpose(qtrace + [nd + q for q in qtrace] +
+-                                 sel + [nd + q for q in sel])
+-                      .reshape([np.prod(dtrace, dtype=int),
+-                                np.prod(dtrace, dtype=int),
+-                                np.prod(dkeep, dtype=int),
+-                                np.prod(dkeep, dtype=int)]))
+-    return dense.fast_from_numpy(rhomat)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-ptrace = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='ptrace',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-ptrace.__doc__ =\
+-    """
+-    Compute the partial trace of this matrix, leaving the subspaces whose
+-    indices are in `sel`.  This is only defined for square density matrices,
+-    and always returns a density matrix.
+-
+-    The order of the indices in `sel` do not matter; the output matrix will
+-    always have the selected subspaces in the same order that they are in the
+-    input matrix.
+-
+-    For example, if the input is the matrix backing a `Qobj` with
+-    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
+-        ptrace(data, [2, 3, 4], [0, 2])
+-    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The density matrix to be partially traced.
+-
+-    dims : array_like of integer
+-        The dimensions of the subspaces.  This is most likely a 1D list, and
+-        since this is only defined on square matrices, there is no need to pass
+-        before the left and right sides.  Typically the input matrix will be
+-        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
+-
+-    sel : integer or array_like of integer
+-        The indices of the subspaces which should be _kept_.
+-    """
+-ptrace.add_specialisations([
+-    (CSR, CSR, ptrace_csr),
+-    (CSR, Dense, ptrace_csr_dense),
+-    (Dense, Dense, ptrace_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
++
++import numbers
++
++import numpy as np
++
++cimport numpy as cnp
++
++from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
++from qutip.core.data.base import idxint_dtype
++from qutip.settings import settings
++
++cnp.import_array()
++
++__all__ = [
++    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
++]
++
++cdef tuple _parse_inputs(object dims, object sel, tuple shape):
++    cdef Py_ssize_t i
++
++    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
++    sel = np.atleast_1d(sel).astype(idxint_dtype)
++    sel.sort()
++
++    if shape[0] != shape[1]:
++        raise ValueError("ptrace is only defined for square density matrices")
++
++    if shape[0] != np.prod(dims, dtype=int):
++        raise ValueError(f"the input matrix shape, {shape} and the"
++                         f" dimension argument, {dims}, are not compatible.")
++    if sel.ndim != 1:
++        raise ValueError("Selection must be one-dimensional")
++
++    if any(d < 1 for d in dims):
++        raise ValueError("dimensions must be greated than zero but where"
++                         f" dims={dims}.")
++
++    for i in range(sel.shape[0]):
++        if sel[i] < 0 or sel[i] >= dims.size:
++            raise IndexError("Invalid selection index in ptrace.")
++        if i > 0 and sel[i] == sel[i - 1]:
++            raise ValueError("Duplicate selection index in ptrace.")
++
++    return dims, sel
++
++cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
++    """
++    Populate the helper structure `tensor_table`.  Returns the size (number of
++    rows and number of columns) of the matrix which will be output.
++    """
++    cdef size_t ii
++    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
++    cdef size_t num_dims = _dims.shape[0]
++    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
++    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
++    for ii in range(_sel.shape[0]):
++        if _sel[ii] < 0 or _sel[ii] >= num_dims:
++            raise TypeError("Invalid selection index in ptrace.")
++    for ii in range(num_dims - 1,-1,-1):
++        tensor_table[ii, 0] = factor_tensor
++        factor_tensor *= _dims[ii]
++        if _in(ii, _sel):
++            tensor_table[ii, 1] = factor_keep
++            factor_keep *= _dims[ii]
++        else:
++            tensor_table[ii, 2]  = factor_trace
++            factor_trace *= _dims[ii]
++    return factor_keep
++
++
++cdef bint _in(idxint val, idxint[::1] vec):
++    cdef int ii
++    for ii in range(vec.shape[0]):
++        if val == vec[ii]:
++            return True
++    return False
++
++
++cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
++    # indices determining function for ptrace
++    cdef size_t ii
++    cdef idxint t1, t2
++    out[0] = out[1] = 0
++    for ii in range(tensor_table.shape[0]):
++        t1 = tensor_table[ii, 0]
++        t2 = N / t1
++        N = N % t1
++        out[0] += tensor_table[ii, 1] * t2
++        out[1] += tensor_table[ii, 2] * t2
++
++
++cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
++    dims, sel = _parse_inputs(dims, sel, matrix.shape)
++
++    if len(sel) == len(dims):
++        return matrix.copy()
++    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
++    cdef idxint size
++    size = _populate_tensor_table(dims, sel, tensor_table)
++    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
++    cdef idxint pos_c[2]
++    cdef idxint pos_r[2]
++    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
++    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
++    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
++    cdef double tol = 0
++    if settings.core['auto_tidyup']:
++        tol = settings.core['auto_tidyup_atol']
++    for row in range(matrix.shape[0]):
++        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
++            _i2_k_t(row, tensor_table, pos_r)
++            if pos_c[1] == pos_r[1]:
++                new_data[p] = matrix.data[ptr]
++                new_row[p] = pos_r[0]
++                new_col[p] = pos_c[0]
++                p += 1
++    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
++                                 size, size, p, tol)
++
++
++cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
++    dims, sel = _parse_inputs(dims, sel, matrix.shape)
++
++    if len(sel) == len(dims):
++        return dense.from_csr(matrix)
++    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
++    cdef idxint size
++    size = _populate_tensor_table(dims, sel, tensor_table)
++    cdef size_t ii, jj
++    cdef idxint pos_c[2]
++    cdef idxint pos_r[2]
++    cdef Dense out = dense.zeros(size, size, fortran=False)
++    for ii in range(matrix.shape[0]):
++        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
++            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
++            _i2_k_t(ii, tensor_table, pos_r)
++            if pos_c[1] == pos_r[1]:
++                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
++    return out
++
++
++cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
++    dims, sel = _parse_inputs(dims, sel, matrix.shape)
++
++    if len(sel) == len(dims):
++        return matrix.copy()
++    nd = dims.shape[0]
++    dkeep = [dims[x] for x in sel]
++    qtrace = list(set(np.arange(nd)) - set(sel))
++    dtrace = [dims[x] for x in qtrace]
++    dims = list(dims)
++    sel = list(sel)
++    rhomat = np.trace(matrix.as_ndarray()
++                      .reshape(dims + dims)
++                      .transpose(qtrace + [nd + q for q in qtrace] +
++                                 sel + [nd + q for q in sel])
++                      .reshape([np.prod(dtrace, dtype=int),
++                                np.prod(dtrace, dtype=int),
++                                np.prod(dkeep, dtype=int),
++                                np.prod(dkeep, dtype=int)]))
++    return dense.fast_from_numpy(rhomat)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++ptrace = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='ptrace',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++ptrace.__doc__ =\
++    """
++    Compute the partial trace of this matrix, leaving the subspaces whose
++    indices are in `sel`.  This is only defined for square density matrices,
++    and always returns a density matrix.
++
++    The order of the indices in `sel` do not matter; the output matrix will
++    always have the selected subspaces in the same order that they are in the
++    input matrix.
++
++    For example, if the input is the matrix backing a `Qobj` with
++    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
++        ptrace(data, [2, 3, 4], [0, 2])
++    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
++
++    Parameters
++    ----------
++    matrix : Data
++        The density matrix to be partially traced.
++
++    dims : array_like of integer
++        The dimensions of the subspaces.  This is most likely a 1D list, and
++        since this is only defined on square matrices, there is no need to pass
++        before the left and right sides.  Typically the input matrix will be
++        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
++
++    sel : integer or array_like of integer
++        The indices of the subspaces which should be _kept_.
++    """
++ptrace.add_specialisations([
++    (CSR, CSR, ptrace_csr),
++    (CSR, Dense, ptrace_csr_dense),
++    (Dense, Dense, ptrace_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/reshape.pxd b/qutip/core/data/reshape.pxd
+index 4efae3a0..1b04512f 100644
+--- a/qutip/core/data/reshape.pxd
++++ b/qutip/core/data/reshape.pxd
+@@ -1,12 +1,12 @@
+-#cython: language_level=3
+-
+-from qutip.core.data.base cimport idxint
+-from qutip.core.data cimport CSR, Dense
+-
+-cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
+-cpdef CSR column_stack_csr(CSR matrix)
+-cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
+-
+-cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
+-cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
+-cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
++#cython: language_level=3
++
++from qutip.core.data.base cimport idxint
++from qutip.core.data cimport CSR, Dense
++
++cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
++cpdef CSR column_stack_csr(CSR matrix)
++cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
++
++cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
++cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
++cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
+diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
+index 6871e12c..aeb83a22 100644
+--- a/qutip/core/data/reshape.pyx
++++ b/qutip/core/data/reshape.pyx
+@@ -1,285 +1,285 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
+-
+-from libc.string cimport memcpy, memset
+-
+-cimport cython
+-
+-import warnings
+-
+-from qutip.core.data.base cimport idxint
+-from qutip.core.data cimport csr, dense, CSR, Dense, Data
+-
+-__all__ = [
+-    'reshape', 'reshape_csr', 'reshape_dense',
+-    'column_stack', 'column_stack_csr', 'column_stack_dense',
+-    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
+-    'split_columns', 'split_columns_dense', 'split_columns_csr',
+-]
+-
+-
+-cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
+-    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
+-        message = "".join([
+-            "cannot reshape ", str(matrix.shape), " to ",
+-            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
+-        ])
+-        raise ValueError(message)
+-    if n_rows_out <= 0 or n_cols_out <= 0:
+-        raise ValueError("must have > 0 rows and columns")
+-
+-
+-cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
+-    cdef size_t ptr, row_in, row_out=0, loc, cur=0
+-    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
+-    cdef idxint nnz = csr.nnz(matrix)
+-    cdef CSR out
+-    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+-    out = csr.empty(n_rows_out, n_cols_out, nnz)
+-    matrix.sort_indices()
+-    with nogil:
+-        # Since the indices are now sorted, the data arrays will be identical.
+-        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
+-        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
+-        for row_in in range(n_rows_in):
+-            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
+-                loc = cur + matrix.col_index[ptr]
+-                out.row_index[loc // n_cols_out + 1] += 1
+-                out.col_index[ptr] = loc % n_cols_out
+-            cur += n_cols_in
+-        for row_out in range(n_rows_out):
+-            out.row_index[row_out + 1] += out.row_index[row_out]
+-    return out
+-
+-
+-cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
+-    return (idx // size) + (idx % size)
+-
+-
+-cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
+-    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+-    cdef Dense out
+-    if not matrix.fortran:
+-        out = matrix.copy()
+-        out.shape = (n_rows_out, n_cols_out)
+-        return out
+-    out = dense.zeros(n_rows_out, n_cols_out)
+-    cdef size_t idx_in=0, idx_out=0
+-    cdef size_t size = n_rows_out * n_cols_out
+-    # TODO: improve the algorithm here.
+-    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
+-    for idx_in in range(size):
+-        out.data[idx_out] = matrix.data[idx_in]
+-        idx_out = _reshape_dense_reindex(idx_out + stride, size)
+-    return out
+-
+-
+-cpdef CSR column_stack_csr(CSR matrix):
+-    if matrix.shape[1] == 1:
+-        return matrix.copy()
+-    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+-
+-
+-cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
+-    cdef Dense out
+-    if inplace and matrix.fortran:
+-        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
+-        return matrix
+-    if matrix.fortran:
+-        out = matrix.copy()
+-        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
+-        return out
+-    if inplace:
+-        warnings.warn("cannot stack columns inplace for C-ordered matrix")
+-    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+-
+-
+-cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
+-    if matrix.shape[1] != 1:
+-        raise ValueError("input is not a single column")
+-    if rows < 1:
+-        raise ValueError("rows must be a positive integer")
+-    if matrix.shape[0] % rows:
+-        raise ValueError("number of rows does not divide into the shape")
+-
+-
+-cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
+-    _column_unstack_check_shape(matrix, rows)
+-    cdef idxint cols = matrix.shape[0] // rows
+-    return reshape_csr(matrix, cols, rows).transpose()
+-
+-cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
+-    _column_unstack_check_shape(matrix, rows)
+-    cdef idxint cols = matrix.shape[0] // rows
+-    if inplace and matrix.fortran:
+-        matrix.shape = (rows, cols)
+-        return matrix
+-    elif inplace:
+-        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
+-    out = dense.empty(rows, cols, fortran=True)
+-    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
+-    return out
+-
+-
+-cpdef list split_columns_dense(Dense matrix, copy=True):
+-    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
+-            for k in range(matrix.shape[1])]
+-
+-cpdef list split_columns_csr(CSR matrix, copy=True):
+-    return [CSR(matrix.as_scipy()[:, k], copy=copy)
+-            for k in range(matrix.shape[1])]
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-reshape = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='reshape',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-reshape.__doc__ =\
+-    """
+-    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
+-    match the current total number of elements of the matrix.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The input matrix to reshape.
+-
+-    n_rows_out, n_cols_out : integer
+-        The number of rows and columns in the output matrix.
+-    """
+-reshape.add_specialisations([
+-    (CSR, CSR, reshape_csr),
+-    (Dense, Dense, reshape_dense),
+-], _defer=True)
+-
+-
+-# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
+-# signature of `column_stack` because the dispatcher logic currently doesn't
+-# support the idea of an input parameter also being the output.
+-
+-column_stack = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='column_stack',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-column_stack.__doc__ =\
+-    """
+-    Stack the columns of a matrix so it becomes a ket-like vector.  For
+-    example, the matrix
+-        [[0, 1, 2],
+-         [3, 4, 5],
+-         [6, 7, 8]]
+-    would be transformed to
+-        [[0],
+-         [3],
+-         [6],
+-         [1],
+-         ...
+-         [5],
+-         [8]]
+-    This is used for transforming between operator and operator-ket
+-    representations in the super-operator formalism.
+-
+-    The inverse of this operation is `column_unstack`.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to stack the columns of.
+-    """
+-column_stack.add_specialisations([
+-    (CSR, CSR, column_stack_csr),
+-    (Dense, Dense, column_stack_dense),
+-], _defer=True)
+-
+-column_unstack = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='column_unstack',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=True,
+-)
+-column_unstack.__doc__ =\
+-    """
+-    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
+-    number of rows.  For example, the matrix
+-        [[0],
+-         [1],
+-         [2],
+-         [3]]
+-    would be unstacked with `rows = 2` to
+-        [[0, 2],
+-         [1, 3]]
+-    This is used for transforming between the operator-ket and operator
+-    representations in the super-operator formalism.
+-
+-    The inverse of this operation is `column_stack`.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to unstack the columns of.
+-
+-    rows : integer
+-        The number of rows there should be in the output matrix.  This must
+-        divide into the total number of elements in the input.
+-    """
+-column_unstack.add_specialisations([
+-    (CSR, CSR, column_unstack_csr),
+-    (Dense, Dense, column_unstack_dense),
+-], _defer=True)
+-
+-
+-split_columns = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=1),
+-    ]),
+-    name='split_columns',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-split_columns.__doc__ =\
+-    """
+-    Make a ket-shaped data out of each columns of the matrix.
+-    This is used for to split the eigenvectors from :obj:`eigs`.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to unstack the columns of.
+-
+-    copy : bool, optional
+-        The number of rows there should be in the output matrix.  This must
+-        divide into the total number of elements in the input.
+-
+-    Returns
+-    -------
+-    kets : list
+-        list of Data of each columns of the matrix.
+-    """
+-split_columns.add_specialisations([
+-    (CSR, split_columns_csr),
+-    (Dense, split_columns_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
++
++from libc.string cimport memcpy, memset
++
++cimport cython
++
++import warnings
++
++from qutip.core.data.base cimport idxint
++from qutip.core.data cimport csr, dense, CSR, Dense, Data
++
++__all__ = [
++    'reshape', 'reshape_csr', 'reshape_dense',
++    'column_stack', 'column_stack_csr', 'column_stack_dense',
++    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
++    'split_columns', 'split_columns_dense', 'split_columns_csr',
++]
++
++
++cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
++    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
++        message = "".join([
++            "cannot reshape ", str(matrix.shape), " to ",
++            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
++        ])
++        raise ValueError(message)
++    if n_rows_out <= 0 or n_cols_out <= 0:
++        raise ValueError("must have > 0 rows and columns")
++
++
++cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
++    cdef size_t ptr, row_in, row_out=0, loc, cur=0
++    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
++    cdef idxint nnz = csr.nnz(matrix)
++    cdef CSR out
++    _reshape_check_input(matrix, n_rows_out, n_cols_out)
++    out = csr.empty(n_rows_out, n_cols_out, nnz)
++    matrix.sort_indices()
++    with nogil:
++        # Since the indices are now sorted, the data arrays will be identical.
++        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
++        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
++        for row_in in range(n_rows_in):
++            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
++                loc = cur + matrix.col_index[ptr]
++                out.row_index[loc // n_cols_out + 1] += 1
++                out.col_index[ptr] = loc % n_cols_out
++            cur += n_cols_in
++        for row_out in range(n_rows_out):
++            out.row_index[row_out + 1] += out.row_index[row_out]
++    return out
++
++
++cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
++    return (idx // size) + (idx % size)
++
++
++cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
++    _reshape_check_input(matrix, n_rows_out, n_cols_out)
++    cdef Dense out
++    if not matrix.fortran:
++        out = matrix.copy()
++        out.shape = (n_rows_out, n_cols_out)
++        return out
++    out = dense.zeros(n_rows_out, n_cols_out)
++    cdef size_t idx_in=0, idx_out=0
++    cdef size_t size = n_rows_out * n_cols_out
++    # TODO: improve the algorithm here.
++    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
++    for idx_in in range(size):
++        out.data[idx_out] = matrix.data[idx_in]
++        idx_out = _reshape_dense_reindex(idx_out + stride, size)
++    return out
++
++
++cpdef CSR column_stack_csr(CSR matrix):
++    if matrix.shape[1] == 1:
++        return matrix.copy()
++    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
++
++
++cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
++    cdef Dense out
++    if inplace and matrix.fortran:
++        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
++        return matrix
++    if matrix.fortran:
++        out = matrix.copy()
++        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
++        return out
++    if inplace:
++        warnings.warn("cannot stack columns inplace for C-ordered matrix")
++    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
++
++
++cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
++    if matrix.shape[1] != 1:
++        raise ValueError("input is not a single column")
++    if rows < 1:
++        raise ValueError("rows must be a positive integer")
++    if matrix.shape[0] % rows:
++        raise ValueError("number of rows does not divide into the shape")
++
++
++cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
++    _column_unstack_check_shape(matrix, rows)
++    cdef idxint cols = matrix.shape[0] // rows
++    return reshape_csr(matrix, cols, rows).transpose()
++
++cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
++    _column_unstack_check_shape(matrix, rows)
++    cdef idxint cols = matrix.shape[0] // rows
++    if inplace and matrix.fortran:
++        matrix.shape = (rows, cols)
++        return matrix
++    elif inplace:
++        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
++    out = dense.empty(rows, cols, fortran=True)
++    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
++    return out
++
++
++cpdef list split_columns_dense(Dense matrix, copy=True):
++    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
++            for k in range(matrix.shape[1])]
++
++cpdef list split_columns_csr(CSR matrix, copy=True):
++    return [CSR(matrix.as_scipy()[:, k], copy=copy)
++            for k in range(matrix.shape[1])]
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++reshape = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='reshape',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++reshape.__doc__ =\
++    """
++    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
++    match the current total number of elements of the matrix.
++
++    Parameters
++    ----------
++    matrix : Data
++        The input matrix to reshape.
++
++    n_rows_out, n_cols_out : integer
++        The number of rows and columns in the output matrix.
++    """
++reshape.add_specialisations([
++    (CSR, CSR, reshape_csr),
++    (Dense, Dense, reshape_dense),
++], _defer=True)
++
++
++# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
++# signature of `column_stack` because the dispatcher logic currently doesn't
++# support the idea of an input parameter also being the output.
++
++column_stack = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='column_stack',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++column_stack.__doc__ =\
++    """
++    Stack the columns of a matrix so it becomes a ket-like vector.  For
++    example, the matrix
++        [[0, 1, 2],
++         [3, 4, 5],
++         [6, 7, 8]]
++    would be transformed to
++        [[0],
++         [3],
++         [6],
++         [1],
++         ...
++         [5],
++         [8]]
++    This is used for transforming between operator and operator-ket
++    representations in the super-operator formalism.
++
++    The inverse of this operation is `column_unstack`.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to stack the columns of.
++    """
++column_stack.add_specialisations([
++    (CSR, CSR, column_stack_csr),
++    (Dense, Dense, column_stack_dense),
++], _defer=True)
++
++column_unstack = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='column_unstack',
++    module=__name__,
++    inputs=('matrix',),
++    out=True,
++)
++column_unstack.__doc__ =\
++    """
++    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
++    number of rows.  For example, the matrix
++        [[0],
++         [1],
++         [2],
++         [3]]
++    would be unstacked with `rows = 2` to
++        [[0, 2],
++         [1, 3]]
++    This is used for transforming between the operator-ket and operator
++    representations in the super-operator formalism.
++
++    The inverse of this operation is `column_stack`.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to unstack the columns of.
++
++    rows : integer
++        The number of rows there should be in the output matrix.  This must
++        divide into the total number of elements in the input.
++    """
++column_unstack.add_specialisations([
++    (CSR, CSR, column_unstack_csr),
++    (Dense, Dense, column_unstack_dense),
++], _defer=True)
++
++
++split_columns = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=1),
++    ]),
++    name='split_columns',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++split_columns.__doc__ =\
++    """
++    Make a ket-shaped data out of each columns of the matrix.
++    This is used for to split the eigenvectors from :obj:`eigs`.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to unstack the columns of.
++
++    copy : bool, optional
++        The number of rows there should be in the output matrix.  This must
++        divide into the total number of elements in the input.
++
++    Returns
++    -------
++    kets : list
++        list of Data of each columns of the matrix.
++    """
++split_columns.add_specialisations([
++    (CSR, split_columns_csr),
++    (Dense, split_columns_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
+index a164d4f7..30cb4dd6 100644
+--- a/qutip/core/data/solve.py
++++ b/qutip/core/data/solve.py
+@@ -1,208 +1,208 @@
+-from qutip.core.data import CSR, Data, csr, Dense
+-import qutip.core.data as _data
+-import scipy.sparse.linalg as splinalg
+-import numpy as np
+-from qutip.settings import settings
+-if settings.has_mkl:
+-    from qutip._mkl.spsolve import mkl_spsolve
+-else:
+-    mkl_spsolve = None
+-
+-
+-def _splu(A, B, **kwargs):
+-    lu = splinalg.splu(A, **kwargs)
+-    return lu.solve(B)
+-
+-
+-def solve_csr_dense(matrix: CSR, target: Dense, method=None,
+-                    options: dict={}) -> Dense:
+-    """
+-    Solve ``Ax=b`` for ``x``.
+-
+-    Parameters:
+-    -----------
+-
+-    matrix : CSR
+-        The matrix ``A``.
+-
+-    target : Data
+-        The matrix or vector ``b``.
+-
+-    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
+-        The function to use to solve the system. Any function from
+-        scipy.sparse.linalg which solve the equation Ax=b can be used.
+-        `splu` from the same and `mkl_spsolve` are also valid choice.
+-
+-    options : dict
+-        Keywork options to pass to the solver. Refer to the documenentation in
+-        scipy.sparse.linalg of the used method for a list of supported keyword.
+-        The keyword "csc" can be set to ``True`` to convert the sparse matrix
+-        before passing it to the solver.
+-
+-    .. note::
+-        Options for ``mkl_spsolve`` are presently only found in the source
+-        code.
+-
+-    Returns:
+-    --------
+-    x : Dense
+-        Solution to the system Ax = b.
+-    """
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("can only solve using square matrix")
+-    if matrix.shape[1] != target.shape[0]:
+-        raise ValueError("target does not match the system")
+-
+-    b = target.as_ndarray()
+-
+-    method = method or "spsolve"
+-
+-    if method == "splu":
+-        solver = _splu
+-    elif hasattr(splinalg, method):
+-        solver = getattr(splinalg, method)
+-    elif method == "mkl_spsolve" and mkl_spsolve is None:
+-        raise ValueError("mkl is not available")
+-    elif method == "mkl_spsolve":
+-        solver = mkl_spsolve
+-    else:
+-        raise ValueError(f"Unknown sparse solver {method}.")
+-
+-    options = options.copy()
+-    M = matrix.as_scipy()
+-    if options.pop("csc", False):
+-        M = M.tocsc()
+-
+-    out = solver(M, b, **options)
+-
+-    if isinstance(out, tuple) and len(out) == 2:
+-        # iterative method return a success flag
+-        out, check = out
+-        if check == 0:
+-            # Successful
+-            pass
+-        elif check > 0:
+-            raise RuntimeError(
+-                f"scipy.sparse.linalg.{method} error: Tolerance was not"
+-                f" reached. Error code: {check}"
+-            )
+-
+-        elif check < 0:
+-            raise RuntimeError(
+-                f"scipy.sparse.linalg.{method} error: Bad input. "
+-                f"Error code: {check}"
+-            )
+-    elif isinstance(out, tuple) and len(out) > 2:
+-        # least sqare method return residual, flag, etc.
+-        out, *_ = out
+-    return Dense(out, copy=False)
+-
+-
+-def solve_dense(matrix: Dense, target: Data, method=None,
+-                options: dict={}) -> Dense:
+-    """
+-    Solve ``Ax=b`` for ``x``.
+-
+-    Parameters:
+-    -----------
+-
+-    matrix : Dense
+-        The matrix ``A``.
+-
+-    target : Data
+-        The matrix or vector ``b``.
+-
+-    method : str {"solve", "lstsq"}, default="solve"
+-        The function from numpy.linalg to use to solve the system.
+-
+-    options : dict
+-        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
+-        not use any.
+-
+-    Returns:
+-    --------
+-    x : Dense
+-        Solution to the system Ax = b.
+-    """
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("can only solve using square matrix")
+-    if matrix.shape[1] != target.shape[0]:
+-        raise ValueError("target does not match the system")
+-
+-    if isinstance(target, Dense):
+-        b = target.as_ndarray()
+-    else:
+-        b = target.to_array()
+-
+-    if method in ["solve", None]:
+-        out = np.linalg.solve(matrix.as_ndarray(), b)
+-    elif method == "lstsq":
+-        out, *_ = np.linalg.lstsq(
+-            matrix.as_ndarray(),
+-            b,
+-            rcond=options.get("rcond", None)
+-        )
+-    else:
+-        raise ValueError(f"Unknown solver {method},"
+-                         " 'solve' and 'lstsq' are supported.")
+-    return Dense(out, copy=False)
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-
+-solve = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=None),
+-        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default={}),
+-    ]),
+-    name='solve',
+-    module=__name__,
+-    inputs=('matrix', 'target'),
+-    out=True,
+-)
+-solve.__doc__ = """
+-    Solve ``Ax=b`` for ``x``.
+-
+-    Parameters:
+-    -----------
+-    matrix : Data
+-    The matrix ``A``.
+-
+-    target : Data
+-    The matrix or vector ``b``.
+-
+-    method : str
+-        The function to use to solve the system. Function which solve the
+-        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
+-        numpy.linalg (Dense ``matrix``) can be used.
+-        Sparse cases also accept `splu` and `mkl_spsolve`.
+-
+-    options : dict
+-        Keywork options to pass to the solver. Refer to the documenentation
+-        for the chosen method in scipy.sparse.linalg or numpy.linalg.
+-        The keyword "csc" can be set to ``True`` to convert the sparse matrix
+-        in sparse cases.
+-
+-    .. note::
+-        Options for ``mkl_spsolve`` are presently only found in the source
+-        code.
+-
+-    Returns:
+-    --------
+-    x : Data
+-        Solution to the system Ax = b.
+-"""
+-solve.add_specialisations([
+-    (CSR, Dense, Dense, solve_csr_dense),
+-    (Dense, Dense, Dense, solve_dense),
+-], _defer=True)
+-
+-
+-del _Dispatcher
+-del _inspect
++from qutip.core.data import CSR, Data, csr, Dense
++import qutip.core.data as _data
++import scipy.sparse.linalg as splinalg
++import numpy as np
++from qutip.settings import settings
++if settings.has_mkl:
++    from qutip._mkl.spsolve import mkl_spsolve
++else:
++    mkl_spsolve = None
++
++
++def _splu(A, B, **kwargs):
++    lu = splinalg.splu(A, **kwargs)
++    return lu.solve(B)
++
++
++def solve_csr_dense(matrix: CSR, target: Dense, method=None,
++                    options: dict={}) -> Dense:
++    """
++    Solve ``Ax=b`` for ``x``.
++
++    Parameters:
++    -----------
++
++    matrix : CSR
++        The matrix ``A``.
++
++    target : Data
++        The matrix or vector ``b``.
++
++    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
++        The function to use to solve the system. Any function from
++        scipy.sparse.linalg which solve the equation Ax=b can be used.
++        `splu` from the same and `mkl_spsolve` are also valid choice.
++
++    options : dict
++        Keywork options to pass to the solver. Refer to the documenentation in
++        scipy.sparse.linalg of the used method for a list of supported keyword.
++        The keyword "csc" can be set to ``True`` to convert the sparse matrix
++        before passing it to the solver.
++
++    .. note::
++        Options for ``mkl_spsolve`` are presently only found in the source
++        code.
++
++    Returns:
++    --------
++    x : Dense
++        Solution to the system Ax = b.
++    """
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("can only solve using square matrix")
++    if matrix.shape[1] != target.shape[0]:
++        raise ValueError("target does not match the system")
++
++    b = target.as_ndarray()
++
++    method = method or "spsolve"
++
++    if method == "splu":
++        solver = _splu
++    elif hasattr(splinalg, method):
++        solver = getattr(splinalg, method)
++    elif method == "mkl_spsolve" and mkl_spsolve is None:
++        raise ValueError("mkl is not available")
++    elif method == "mkl_spsolve":
++        solver = mkl_spsolve
++    else:
++        raise ValueError(f"Unknown sparse solver {method}.")
++
++    options = options.copy()
++    M = matrix.as_scipy()
++    if options.pop("csc", False):
++        M = M.tocsc()
++
++    out = solver(M, b, **options)
++
++    if isinstance(out, tuple) and len(out) == 2:
++        # iterative method return a success flag
++        out, check = out
++        if check == 0:
++            # Successful
++            pass
++        elif check > 0:
++            raise RuntimeError(
++                f"scipy.sparse.linalg.{method} error: Tolerance was not"
++                f" reached. Error code: {check}"
++            )
++
++        elif check < 0:
++            raise RuntimeError(
++                f"scipy.sparse.linalg.{method} error: Bad input. "
++                f"Error code: {check}"
++            )
++    elif isinstance(out, tuple) and len(out) > 2:
++        # least sqare method return residual, flag, etc.
++        out, *_ = out
++    return Dense(out, copy=False)
++
++
++def solve_dense(matrix: Dense, target: Data, method=None,
++                options: dict={}) -> Dense:
++    """
++    Solve ``Ax=b`` for ``x``.
++
++    Parameters:
++    -----------
++
++    matrix : Dense
++        The matrix ``A``.
++
++    target : Data
++        The matrix or vector ``b``.
++
++    method : str {"solve", "lstsq"}, default="solve"
++        The function from numpy.linalg to use to solve the system.
++
++    options : dict
++        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
++        not use any.
++
++    Returns:
++    --------
++    x : Dense
++        Solution to the system Ax = b.
++    """
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("can only solve using square matrix")
++    if matrix.shape[1] != target.shape[0]:
++        raise ValueError("target does not match the system")
++
++    if isinstance(target, Dense):
++        b = target.as_ndarray()
++    else:
++        b = target.to_array()
++
++    if method in ["solve", None]:
++        out = np.linalg.solve(matrix.as_ndarray(), b)
++    elif method == "lstsq":
++        out, *_ = np.linalg.lstsq(
++            matrix.as_ndarray(),
++            b,
++            rcond=options.get("rcond", None)
++        )
++    else:
++        raise ValueError(f"Unknown solver {method},"
++                         " 'solve' and 'lstsq' are supported.")
++    return Dense(out, copy=False)
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++
++solve = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=None),
++        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default={}),
++    ]),
++    name='solve',
++    module=__name__,
++    inputs=('matrix', 'target'),
++    out=True,
++)
++solve.__doc__ = """
++    Solve ``Ax=b`` for ``x``.
++
++    Parameters:
++    -----------
++    matrix : Data
++    The matrix ``A``.
++
++    target : Data
++    The matrix or vector ``b``.
++
++    method : str
++        The function to use to solve the system. Function which solve the
++        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
++        numpy.linalg (Dense ``matrix``) can be used.
++        Sparse cases also accept `splu` and `mkl_spsolve`.
++
++    options : dict
++        Keywork options to pass to the solver. Refer to the documenentation
++        for the chosen method in scipy.sparse.linalg or numpy.linalg.
++        The keyword "csc" can be set to ``True`` to convert the sparse matrix
++        in sparse cases.
++
++    .. note::
++        Options for ``mkl_spsolve`` are presently only found in the source
++        code.
++
++    Returns:
++    --------
++    x : Data
++        Solution to the system Ax = b.
++"""
++solve.add_specialisations([
++    (CSR, Dense, Dense, solve_csr_dense),
++    (Dense, Dense, Dense, solve_dense),
++], _defer=True)
++
++
++del _Dispatcher
++del _inspect
+diff --git a/qutip/core/data/src/intdtype.h b/qutip/core/data/src/intdtype.h
+index f88c65f9..40920a71 100644
+--- a/qutip/core/data/src/intdtype.h
++++ b/qutip/core/data/src/intdtype.h
+@@ -1,2 +1,2 @@
+-typedef int32_t idxint;
+-int _idxint_size=32;
++typedef int32_t idxint;
++int _idxint_size=32;
+diff --git a/qutip/core/data/src/matmul_csr_vector.cpp b/qutip/core/data/src/matmul_csr_vector.cpp
+index 2294f3b7..08424c02 100644
+--- a/qutip/core/data/src/matmul_csr_vector.cpp
++++ b/qutip/core/data/src/matmul_csr_vector.cpp
+@@ -1,116 +1,116 @@
+-#include <complex>
+-#if \
+-    (defined(__GNUC__) && defined(__SSE3__))\
+-    || (defined(_MSC_VER) && defined(__AVX__))
+-/* If we're going to manually do the vectorisation, we need to make sure we've
+- * included the preprocessor directives.
+- */
+-# include <pmmintrin.h>
+-#endif
+-
+-#include "matmul_csr_vector.hpp"
+-
+-template <typename IntT>
+-#if \
+-    (defined(__GNUC__) && defined(__SSE3__))\
+-    || (defined(_MSC_VER) && defined(__AVX__))
+-/* Manually apply the vectorisation. */
+-void _matmul_csr_vector(
+-        const std::complex<double> * _RESTRICT data,
+-        const IntT * _RESTRICT col_index,
+-        const IntT * _RESTRICT row_index,
+-        const std::complex<double> * _RESTRICT vec,
+-        const std::complex<double> scale,
+-        std::complex<double> * _RESTRICT out,
+-        const IntT nrows)
+-{
+-    IntT row_start, row_end;
+-    __m128d num1, num2, num3, num4;
+-    for (IntT row=0; row < nrows; row++) {
+-        num4 = _mm_setzero_pd();
+-        row_start = row_index[row];
+-        row_end = row_index[row+1];
+-        for (IntT ptr=row_start; ptr < row_end; ptr++) {
+-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
+-            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
+-                              std::real(vec[col_index[ptr]]));
+-            num3 = _mm_mul_pd(num2, num1);
+-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
+-            num2 = _mm_shuffle_pd(num2, num2, 1);
+-            num2 = _mm_mul_pd(num2, num1);
+-            num3 = _mm_addsub_pd(num3, num2);
+-            num4 = _mm_add_pd(num3, num4);
+-        }
+-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
+-        num3 = _mm_mul_pd(num4, num1);
+-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
+-        num4 = _mm_shuffle_pd(num4, num4, 1);
+-        num4 = _mm_mul_pd(num4, num1);
+-        num3 = _mm_addsub_pd(num3, num4);
+-        num2 = _mm_loadu_pd((double *)&out[row]);
+-        num3 = _mm_add_pd(num2, num3);
+-        _mm_storeu_pd((double *)&out[row], num3);
+-    }
+-}
+-#else
+-/* No manual vectorisation. */
+-void _matmul_csr_vector(
+-        const std::complex<double> * _RESTRICT data,
+-        const IntT * _RESTRICT col_index,
+-        const IntT * _RESTRICT row_index,
+-        const std::complex<double> * _RESTRICT vec,
+-        const std::complex<double> scale,
+-        std::complex<double> * _RESTRICT out,
+-        const IntT nrows)
+-{
+-    IntT row_start, row_end;
+-    std::complex<double> dot;
+-    for (size_t row=0; row < nrows; row++)
+-    {
+-        dot = 0;
+-        row_start = row_index[row];
+-        row_end = row_index[row+1];
+-        for (size_t ptr=row_start; ptr < row_end; ptr++)
+-        {
+-            dot += data[ptr]*vec[col_index[ptr]];
+-        }
+-        out[row] += scale * dot;
+-    }
+-}
+-#endif
+-
+-/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
+- * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
+- * latter causes compatibility issues with defining the sized types with the
+- * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
+- * three of `int`, `long` and `long long` when doing things this way (despite
+- * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
+- * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
+- * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
+- * and `long long`.
+- * - Jake Lishman 2020-08-10.
+- */
+-template void _matmul_csr_vector<>(
+-        const std::complex<double> * _RESTRICT,
+-        const int * _RESTRICT,
+-        const int * _RESTRICT,
+-        const std::complex<double> * _RESTRICT,
+-        const std::complex<double>,
+-        std::complex<double> * _RESTRICT,
+-        const int);
+-template void _matmul_csr_vector<>(
+-        const std::complex<double> * _RESTRICT,
+-        const long * _RESTRICT,
+-        const long * _RESTRICT,
+-        const std::complex<double> * _RESTRICT,
+-        const std::complex<double>,
+-        std::complex<double> * _RESTRICT,
+-        const long);
+-template void _matmul_csr_vector<>(
+-        const std::complex<double> * _RESTRICT,
+-        const long long * _RESTRICT,
+-        const long long * _RESTRICT,
+-        const std::complex<double> * _RESTRICT,
+-        const std::complex<double>,
+-        std::complex<double> * _RESTRICT,
+-        const long long);
++#include <complex>
++#if \
++    (defined(__GNUC__) && defined(__SSE3__))\
++    || (defined(_MSC_VER) && defined(__AVX__))
++/* If we're going to manually do the vectorisation, we need to make sure we've
++ * included the preprocessor directives.
++ */
++# include <pmmintrin.h>
++#endif
++
++#include "matmul_csr_vector.hpp"
++
++template <typename IntT>
++#if \
++    (defined(__GNUC__) && defined(__SSE3__))\
++    || (defined(_MSC_VER) && defined(__AVX__))
++/* Manually apply the vectorisation. */
++void _matmul_csr_vector(
++        const std::complex<double> * _RESTRICT data,
++        const IntT * _RESTRICT col_index,
++        const IntT * _RESTRICT row_index,
++        const std::complex<double> * _RESTRICT vec,
++        const std::complex<double> scale,
++        std::complex<double> * _RESTRICT out,
++        const IntT nrows)
++{
++    IntT row_start, row_end;
++    __m128d num1, num2, num3, num4;
++    for (IntT row=0; row < nrows; row++) {
++        num4 = _mm_setzero_pd();
++        row_start = row_index[row];
++        row_end = row_index[row+1];
++        for (IntT ptr=row_start; ptr < row_end; ptr++) {
++            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
++            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
++                              std::real(vec[col_index[ptr]]));
++            num3 = _mm_mul_pd(num2, num1);
++            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
++            num2 = _mm_shuffle_pd(num2, num2, 1);
++            num2 = _mm_mul_pd(num2, num1);
++            num3 = _mm_addsub_pd(num3, num2);
++            num4 = _mm_add_pd(num3, num4);
++        }
++        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
++        num3 = _mm_mul_pd(num4, num1);
++        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
++        num4 = _mm_shuffle_pd(num4, num4, 1);
++        num4 = _mm_mul_pd(num4, num1);
++        num3 = _mm_addsub_pd(num3, num4);
++        num2 = _mm_loadu_pd((double *)&out[row]);
++        num3 = _mm_add_pd(num2, num3);
++        _mm_storeu_pd((double *)&out[row], num3);
++    }
++}
++#else
++/* No manual vectorisation. */
++void _matmul_csr_vector(
++        const std::complex<double> * _RESTRICT data,
++        const IntT * _RESTRICT col_index,
++        const IntT * _RESTRICT row_index,
++        const std::complex<double> * _RESTRICT vec,
++        const std::complex<double> scale,
++        std::complex<double> * _RESTRICT out,
++        const IntT nrows)
++{
++    IntT row_start, row_end;
++    std::complex<double> dot;
++    for (size_t row=0; row < nrows; row++)
++    {
++        dot = 0;
++        row_start = row_index[row];
++        row_end = row_index[row+1];
++        for (size_t ptr=row_start; ptr < row_end; ptr++)
++        {
++            dot += data[ptr]*vec[col_index[ptr]];
++        }
++        out[row] += scale * dot;
++    }
++}
++#endif
++
++/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
++ * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
++ * latter causes compatibility issues with defining the sized types with the
++ * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
++ * three of `int`, `long` and `long long` when doing things this way (despite
++ * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
++ * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
++ * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
++ * and `long long`.
++ * - Jake Lishman 2020-08-10.
++ */
++template void _matmul_csr_vector<>(
++        const std::complex<double> * _RESTRICT,
++        const int * _RESTRICT,
++        const int * _RESTRICT,
++        const std::complex<double> * _RESTRICT,
++        const std::complex<double>,
++        std::complex<double> * _RESTRICT,
++        const int);
++template void _matmul_csr_vector<>(
++        const std::complex<double> * _RESTRICT,
++        const long * _RESTRICT,
++        const long * _RESTRICT,
++        const std::complex<double> * _RESTRICT,
++        const std::complex<double>,
++        std::complex<double> * _RESTRICT,
++        const long);
++template void _matmul_csr_vector<>(
++        const std::complex<double> * _RESTRICT,
++        const long long * _RESTRICT,
++        const long long * _RESTRICT,
++        const std::complex<double> * _RESTRICT,
++        const std::complex<double>,
++        std::complex<double> * _RESTRICT,
++        const long long);
+diff --git a/qutip/core/data/src/matmul_csr_vector.hpp b/qutip/core/data/src/matmul_csr_vector.hpp
+index 694329ac..4dd3e72e 100755
+--- a/qutip/core/data/src/matmul_csr_vector.hpp
++++ b/qutip/core/data/src/matmul_csr_vector.hpp
+@@ -1,17 +1,17 @@
+-#include <complex>
+-
+-#if defined(__GNUC__) || defined(_MSC_VER)
+-# define _RESTRICT __restrict
+-#else
+-# define _RESTRICT
+-#endif
+-
+-template <typename IntT>
+-void _matmul_csr_vector(
+-        const std::complex<double> * _RESTRICT data,
+-        const IntT * _RESTRICT col_index,
+-        const IntT * _RESTRICT row_index,
+-        const std::complex<double> * _RESTRICT vec,
+-        const std::complex<double> scale,
+-        std::complex<double> * _RESTRICT out,
+-        const IntT nrows);
++#include <complex>
++
++#if defined(__GNUC__) || defined(_MSC_VER)
++# define _RESTRICT __restrict
++#else
++# define _RESTRICT
++#endif
++
++template <typename IntT>
++void _matmul_csr_vector(
++        const std::complex<double> * _RESTRICT data,
++        const IntT * _RESTRICT col_index,
++        const IntT * _RESTRICT row_index,
++        const std::complex<double> * _RESTRICT vec,
++        const std::complex<double> scale,
++        std::complex<double> * _RESTRICT out,
++        const IntT nrows);
+diff --git a/qutip/core/data/tidyup.pxd b/qutip/core/data/tidyup.pxd
+index 44447145..cd88c290 100644
+--- a/qutip/core/data/tidyup.pxd
++++ b/qutip/core/data/tidyup.pxd
+@@ -1,7 +1,7 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from qutip.core.data cimport CSR, Dense
+-
+-cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
+-cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from qutip.core.data cimport CSR, Dense
++
++cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
++cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
+diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
+index a9b80798..b7338718 100644
+--- a/qutip/core/data/tidyup.pyx
++++ b/qutip/core/data/tidyup.pyx
+@@ -1,106 +1,106 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-from libc.math cimport fabs
+-
+-cimport numpy as cnp
+-
+-from qutip.core.data cimport csr, dense, CSR, Dense
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    # abs is templated such that Cython treats std::abs as complex->complex
+-    double abs(double complex x)
+-
+-__all__ = [
+-    'tidyup', 'tidyup_csr', 'tidyup_dense',
+-]
+-
+-
+-cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
+-    cdef bint re, im
+-    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
+-    cdef double complex value
+-    cdef CSR out = matrix if inplace else matrix.copy()
+-    nnz = 0
+-    out.row_index[0] = 0
+-    for row in range(matrix.shape[0]):
+-        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
+-        for ptr in range(ptr_start, ptr_end):
+-            re = im = False
+-            value = matrix.data[ptr]
+-            if fabs(value.real) < tol:
+-                re = True
+-                value.real = 0
+-            if fabs(value.imag) < tol:
+-                im = True
+-                value.imag = 0
+-            if not (re & im):
+-                out.data[nnz] = value
+-                out.col_index[nnz] = matrix.col_index[ptr]
+-                nnz += 1
+-        out.row_index[row + 1] = nnz
+-    return out
+-
+-
+-cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
+-    cdef Dense out = matrix if inplace else matrix.copy()
+-    cdef double complex value
+-    cdef size_t ptr
+-    for ptr in range(matrix.shape[0] * matrix.shape[1]):
+-        value = matrix.data[ptr]
+-        if fabs(value.real) < tol:
+-            matrix.data[ptr].real = 0
+-        if fabs(value.imag) < tol:
+-            matrix.data[ptr].imag = 0
+-    return out
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-# In this case, to support the `inplace` argument, we do not support
+-# dispatching on the output.
+-
+-tidyup = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+-                           default=True),
+-    ]),
+-    name='tidyup',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-tidyup.__doc__ =\
+-    """
+-    Tidy up the input matrix by truncating small values to zero.  The real and
+-    imaginary parts are treated individually, so (for example) the number
+-        1e-18 + 2j
+-    would be truncated with a tolerance of `1e-15` to just
+-        2j
+-
+-    By default, this operation is in-place.  The output type will always match
+-    the input type; no dispatching takes place on the output.
+-
+-    Parameters
+-    ----------
+-    matrix : Data
+-        The matrix to tidy up.
+-
+-    tol : real
+-        The absolute tolerance to use to determine whether a real or imaginary
+-        part should be truncated to zero.
+-
+-    inplace : bool, optional (True)
+-        Whether to do the operation in-place.  The output matrix will always be
+-        returned, even if this argument is `True`; it will just be the same
+-        Python object as was input.
+-    """
+-tidyup.add_specialisations([
+-    (CSR, tidyup_csr),
+-    (Dense, tidyup_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++from libc.math cimport fabs
++
++cimport numpy as cnp
++
++from qutip.core.data cimport csr, dense, CSR, Dense
++
++cdef extern from "<complex>" namespace "std" nogil:
++    # abs is templated such that Cython treats std::abs as complex->complex
++    double abs(double complex x)
++
++__all__ = [
++    'tidyup', 'tidyup_csr', 'tidyup_dense',
++]
++
++
++cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
++    cdef bint re, im
++    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
++    cdef double complex value
++    cdef CSR out = matrix if inplace else matrix.copy()
++    nnz = 0
++    out.row_index[0] = 0
++    for row in range(matrix.shape[0]):
++        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
++        for ptr in range(ptr_start, ptr_end):
++            re = im = False
++            value = matrix.data[ptr]
++            if fabs(value.real) < tol:
++                re = True
++                value.real = 0
++            if fabs(value.imag) < tol:
++                im = True
++                value.imag = 0
++            if not (re & im):
++                out.data[nnz] = value
++                out.col_index[nnz] = matrix.col_index[ptr]
++                nnz += 1
++        out.row_index[row + 1] = nnz
++    return out
++
++
++cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
++    cdef Dense out = matrix if inplace else matrix.copy()
++    cdef double complex value
++    cdef size_t ptr
++    for ptr in range(matrix.shape[0] * matrix.shape[1]):
++        value = matrix.data[ptr]
++        if fabs(value.real) < tol:
++            matrix.data[ptr].real = 0
++        if fabs(value.imag) < tol:
++            matrix.data[ptr].imag = 0
++    return out
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++# In this case, to support the `inplace` argument, we do not support
++# dispatching on the output.
++
++tidyup = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
++                           default=True),
++    ]),
++    name='tidyup',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++tidyup.__doc__ =\
++    """
++    Tidy up the input matrix by truncating small values to zero.  The real and
++    imaginary parts are treated individually, so (for example) the number
++        1e-18 + 2j
++    would be truncated with a tolerance of `1e-15` to just
++        2j
++
++    By default, this operation is in-place.  The output type will always match
++    the input type; no dispatching takes place on the output.
++
++    Parameters
++    ----------
++    matrix : Data
++        The matrix to tidy up.
++
++    tol : real
++        The absolute tolerance to use to determine whether a real or imaginary
++        part should be truncated to zero.
++
++    inplace : bool, optional (True)
++        Whether to do the operation in-place.  The output matrix will always be
++        returned, even if this argument is `True`; it will just be the same
++        Python object as was input.
++    """
++tidyup.add_specialisations([
++    (CSR, tidyup_csr),
++    (Dense, tidyup_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
+index e231896f..0c9a9d4d 100644
+--- a/qutip/core/data/trace.pxd
++++ b/qutip/core/data/trace.pxd
+@@ -1,9 +1,9 @@
+-#cython: language_level=3
+-
+-from qutip.core.data cimport CSR, Dense
+-
+-cpdef double complex trace_csr(CSR matrix) nogil except *
+-cpdef double complex trace_dense(Dense matrix) nogil except *
+-
+-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
+-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
++#cython: language_level=3
++
++from qutip.core.data cimport CSR, Dense
++
++cpdef double complex trace_csr(CSR matrix) nogil except *
++cpdef double complex trace_dense(Dense matrix) nogil except *
++
++cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
++cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
+diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
+index c256f537..5dec3f6d 100644
+--- a/qutip/core/data/trace.pyx
++++ b/qutip/core/data/trace.pyx
+@@ -1,109 +1,109 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False
+-
+-cimport cython
+-from libc.math cimport sqrt
+-
+-from qutip.core.data cimport Data, CSR, Dense
+-from qutip.core.data cimport base
+-
+-__all__ = [
+-    'trace', 'trace_csr', 'trace_dense',
+-    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
+-]
+-
+-
+-cdef void _check_shape(Data matrix) nogil except *:
+-    if matrix.shape[0] != matrix.shape[1]:
+-        raise ValueError("".join([
+-            "matrix shape ", str(matrix.shape), " is not square.",
+-        ]))
+-
+-
+-cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
+-    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
+-        raise ValueError("".join([
+-            "matrix ", str(matrix.shape), " is not a stacked square matrix."
+-        ]))
+-
+-
+-cpdef double complex trace_csr(CSR matrix) nogil except *:
+-    _check_shape(matrix)
+-    cdef size_t row, ptr
+-    cdef double complex trace = 0
+-    for row in range(matrix.shape[0]):
+-        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+-            if matrix.col_index[ptr] == row:
+-                trace += matrix.data[ptr]
+-                break
+-    return trace
+-
+-cpdef double complex trace_dense(Dense matrix) nogil except *:
+-    _check_shape(matrix)
+-    cdef double complex trace = 0
+-    cdef size_t ptr = 0
+-    cdef size_t stride = matrix.shape[0] + 1
+-    for _ in range(matrix.shape[0]):
+-        trace += matrix.data[ptr]
+-        ptr += stride
+-    return trace
+-
+-
+-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
+-    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+-    _check_shape_oper_ket(N, matrix)
+-    cdef size_t row
+-    cdef double complex trace = 0
+-    cdef size_t stride = N + 1
+-    for row in range(N):
+-        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
+-            trace += matrix.data[matrix.row_index[row * stride]]
+-    return trace
+-
+-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
+-    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+-    _check_shape_oper_ket(N, matrix)
+-    cdef double complex trace = 0
+-    cdef size_t ptr = 0
+-    cdef size_t stride = N + 1
+-    for ptr in range(N):
+-        trace += matrix.data[ptr * stride]
+-    return trace
+-
+-
+-from .dispatch import Dispatcher as _Dispatcher
+-import inspect as _inspect
+-
+-trace = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='trace',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-trace.__doc__ =\
+-    """Compute the trace (sum of digaonal elements) of a square matrix."""
+-trace.add_specialisations([
+-    (CSR, trace_csr),
+-    (Dense, trace_dense),
+-], _defer=True)
+-
+-trace_oper_ket = _Dispatcher(
+-    _inspect.Signature([
+-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+-    ]),
+-    name='trace_oper_ket',
+-    module=__name__,
+-    inputs=('matrix',),
+-    out=False,
+-)
+-trace_oper_ket.__doc__ =\
+-    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
+-trace_oper_ket.add_specialisations([
+-    (CSR, trace_oper_ket_csr),
+-    (Dense, trace_oper_ket_dense),
+-], _defer=True)
+-
+-del _inspect, _Dispatcher
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False
++
++cimport cython
++from libc.math cimport sqrt
++
++from qutip.core.data cimport Data, CSR, Dense
++from qutip.core.data cimport base
++
++__all__ = [
++    'trace', 'trace_csr', 'trace_dense',
++    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
++]
++
++
++cdef void _check_shape(Data matrix) nogil except *:
++    if matrix.shape[0] != matrix.shape[1]:
++        raise ValueError("".join([
++            "matrix shape ", str(matrix.shape), " is not square.",
++        ]))
++
++
++cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
++    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
++        raise ValueError("".join([
++            "matrix ", str(matrix.shape), " is not a stacked square matrix."
++        ]))
++
++
++cpdef double complex trace_csr(CSR matrix) nogil except *:
++    _check_shape(matrix)
++    cdef size_t row, ptr
++    cdef double complex trace = 0
++    for row in range(matrix.shape[0]):
++        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
++            if matrix.col_index[ptr] == row:
++                trace += matrix.data[ptr]
++                break
++    return trace
++
++cpdef double complex trace_dense(Dense matrix) nogil except *:
++    _check_shape(matrix)
++    cdef double complex trace = 0
++    cdef size_t ptr = 0
++    cdef size_t stride = matrix.shape[0] + 1
++    for _ in range(matrix.shape[0]):
++        trace += matrix.data[ptr]
++        ptr += stride
++    return trace
++
++
++cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
++    cdef size_t N = <size_t>sqrt(matrix.shape[0])
++    _check_shape_oper_ket(N, matrix)
++    cdef size_t row
++    cdef double complex trace = 0
++    cdef size_t stride = N + 1
++    for row in range(N):
++        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
++            trace += matrix.data[matrix.row_index[row * stride]]
++    return trace
++
++cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
++    cdef size_t N = <size_t>sqrt(matrix.shape[0])
++    _check_shape_oper_ket(N, matrix)
++    cdef double complex trace = 0
++    cdef size_t ptr = 0
++    cdef size_t stride = N + 1
++    for ptr in range(N):
++        trace += matrix.data[ptr * stride]
++    return trace
++
++
++from .dispatch import Dispatcher as _Dispatcher
++import inspect as _inspect
++
++trace = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='trace',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++trace.__doc__ =\
++    """Compute the trace (sum of digaonal elements) of a square matrix."""
++trace.add_specialisations([
++    (CSR, trace_csr),
++    (Dense, trace_dense),
++], _defer=True)
++
++trace_oper_ket = _Dispatcher(
++    _inspect.Signature([
++        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
++    ]),
++    name='trace_oper_ket',
++    module=__name__,
++    inputs=('matrix',),
++    out=False,
++)
++trace_oper_ket.__doc__ =\
++    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
++trace_oper_ket.add_specialisations([
++    (CSR, trace_oper_ket_csr),
++    (Dense, trace_oper_ket_dense),
++], _defer=True)
++
++del _inspect, _Dispatcher
+diff --git a/qutip/core/dimensions.py b/qutip/core/dimensions.py
+index a2a4003a..612e97c8 100644
+--- a/qutip/core/dimensions.py
++++ b/qutip/core/dimensions.py
+@@ -1,345 +1,345 @@
+-"""
+-Internal use module for manipulating dims specifications.
+-"""
+-
+-# Everything should be explicitly imported, not made available by default.
+-
+-import numpy as np
+-from operator import getitem
+-from functools import partial
+-
+-
+-def is_scalar(dims):
+-    """
+-    Returns True if a dims specification is effectively
+-    a scalar (has dimension 1).
+-    """
+-    return np.prod(flatten(dims)) == 1
+-
+-
+-def is_vector(dims):
+-    return (
+-        isinstance(dims, list) and
+-        isinstance(dims[0], (int, np.integer))
+-    )
+-
+-
+-def is_vectorized_oper(dims):
+-    return (
+-        isinstance(dims, list) and
+-        isinstance(dims[0], list)
+-    )
+-
+-
+-def type_from_dims(dims, enforce_square=False):
+-    bra_like, ket_like = map(is_scalar, dims)
+-
+-    if bra_like:
+-        if is_vector(dims[1]):
+-            return 'bra'
+-        elif is_vectorized_oper(dims[1]):
+-            return 'operator-bra'
+-
+-    if ket_like:
+-        if is_vector(dims[0]):
+-            return 'ket'
+-        elif is_vectorized_oper(dims[0]):
+-            return 'operator-ket'
+-
+-    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
+-        return 'oper'
+-
+-    elif (
+-        is_vectorized_oper(dims[0])
+-        and (
+-            not enforce_square
+-            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
+-        )
+-    ):
+-        return 'super'
+-    return 'other'
+-
+-
+-def flatten(l):
+-    """Flattens a list of lists to the first level.
+-
+-    Given a list containing a mix of scalars and lists,
+-    flattens down to a list of the scalars within the original
+-    list.
+-
+-    Examples
+-    --------
+-
+-    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
+-    [0, 1, 2]
+-
+-    """
+-    if not isinstance(l, list):
+-        return [l]
+-    else:
+-        return sum(map(flatten, l), [])
+-
+-
+-def deep_remove(l, *what):
+-    """Removes scalars from all levels of a nested list.
+-
+-    Given a list containing a mix of scalars and lists,
+-    returns a list of the same structure, but where one or
+-    more scalars have been removed.
+-
+-    Examples
+-    --------
+-
+-    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
+-    [[[[1, 2]], [3, 4], [], [6, 7]]]
+-
+-    """
+-    if isinstance(l, list):
+-        # Make a shallow copy at this level.
+-        l = l[:]
+-        for to_remove in what:
+-            if to_remove in l:
+-                l.remove(to_remove)
+-            else:
+-                l = [deep_remove(elem, to_remove) for elem in l]
+-    return l
+-
+-
+-def unflatten(l, idxs):
+-    """Unflattens a list by a given structure.
+-
+-    Given a list of scalars and a deep list of indices
+-    as produced by `flatten`, returns an "unflattened"
+-    form of the list. This perfectly inverts `flatten`.
+-
+-    Examples
+-    --------
+-
+-    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
+-    >>> idxs = enumerate_flat(l) # doctest: +SKIP
+-    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
+-    True
+-
+-    """
+-    acc = []
+-    for idx in idxs:
+-        if isinstance(idx, list):
+-            acc.append(unflatten(l, idx))
+-        else:
+-            acc.append(l[idx])
+-    return acc
+-
+-
+-def _enumerate_flat(l, idx=0):
+-    if not isinstance(l, list):
+-        # Found a scalar, so return and increment.
+-        return idx, idx + 1
+-    else:
+-        # Found a list, so append all the scalars
+-        # from it and recurse to keep the increment
+-        # correct.
+-        acc = []
+-        for elem in l:
+-            labels, idx = _enumerate_flat(elem, idx)
+-            acc.append(labels)
+-        return acc, idx
+-
+-
+-def _collapse_composite_index(dims):
+-    """
+-    Given the dimensions specification for a composite index
+-    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
+-    returns a dimensions specification for an index of the same shape,
+-    but collapsed to a single "leg." In the previous example, [2, 3]
+-    would collapse to [6].
+-    """
+-    return [np.prod(dims)]
+-
+-
+-def _collapse_dims_to_level(dims, level=1):
+-    """
+-    Recursively collapses all indices in a dimensions specification
+-    appearing at a given level, such that the returned dimensions
+-    specification does not represent any composite systems.
+-    """
+-    if level == 0:
+-        return _collapse_composite_index(dims)
+-    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
+-
+-
+-def collapse_dims_oper(dims):
+-    """
+-    Given the dimensions specifications for a ket-, bra- or oper-type
+-    Qobj, returns a dimensions specification describing the same shape
+-    by collapsing all composite systems. For instance, the bra-type
+-    dimensions specification ``[[2, 3], [1]]`` collapses to
+-    ``[[6], [1]]``.
+-
+-    Parameters
+-    ----------
+-
+-    dims : list of lists of ints
+-        Dimensions specifications to be collapsed.
+-
+-    Returns
+-    -------
+-
+-    collapsed_dims : list of lists of ints
+-        Collapsed dimensions specification describing the same shape
+-        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
+-    """
+-    return _collapse_dims_to_level(dims, 1)
+-
+-
+-def collapse_dims_super(dims):
+-    """
+-    Given the dimensions specifications for an operator-ket-, operator-bra- or
+-    super-type Qobj, returns a dimensions specification describing the same shape
+-    by collapsing all composite systems. For instance, the super-type
+-    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
+-    ``[[[6], [6]], [[6], [6]]]``.
+-
+-    Parameters
+-    ----------
+-
+-    dims : list of lists of ints
+-        Dimensions specifications to be collapsed.
+-
+-    Returns
+-    -------
+-
+-    collapsed_dims : list of lists of ints
+-        Collapsed dimensions specification describing the same shape
+-        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
+-        in ``range(2)``.
+-    """
+-    return _collapse_dims_to_level(dims, 2)
+-
+-
+-def enumerate_flat(l):
+-    """Labels the indices at which scalars occur in a flattened list.
+-
+-    Given a list containing a mix of scalars and lists,
+-    returns a list of the same structure, where each scalar
+-    has been replaced by an index into the flattened list.
+-
+-    Examples
+-    --------
+-
+-    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
+-    [[[0], [1, 2]], 3]
+-
+-    """
+-    return _enumerate_flat(l)[0]
+-
+-
+-def deep_map(fn, collection, over=(tuple, list)):
+-    if isinstance(collection, over):
+-        return type(collection)(deep_map(fn, el, over) for el in collection)
+-    else:
+-        return fn(collection)
+-
+-
+-def dims_to_tensor_perm(dims):
+-    """
+-    Given the dims of a Qobj instance, returns a list representing
+-    a permutation from the flattening of that dims specification to
+-    the corresponding tensor indices.
+-
+-    Parameters
+-    ----------
+-
+-    dims : list
+-        Dimensions specification for a Qobj.
+-
+-    Returns
+-    -------
+-
+-    perm : list
+-        A list such that ``data[flatten(dims)[idx]]`` gives the
+-        index of the tensor ``data`` corresponding to the ``idx``th
+-        dimension of ``dims``.
+-    """
+-    # We figure out the type of the dims specification,
+-    # relaxing the requirement that operators be square.
+-    # This means that dims_type need not coincide with
+-    # Qobj.type, but that works fine for our purposes here.
+-    dims_type = type_from_dims(dims, enforce_square=False)
+-    perm = enumerate_flat(dims)
+-    if dims_type in ('oper', 'ket', 'bra'):
+-        return flatten(perm)
+-
+-    # If the type is other, we need to figure out if the
+-    # dims is superlike on its outputs and inputs
+-    # This is the case if the dims type for left or right
+-    # are, respectively, oper-like.
+-    if dims_type == 'other':
+-        raise NotImplementedError("Not yet implemented for type='other'.")
+-
+-    # If we're still here, the story is more complicated. We'll
+-    # follow the strategy of creating a permutation by using
+-    # enumerate_flat then transforming the result to swap
+-    # input and output indices of vectorized matrices, then flattening
+-    # the result. We'll then rebuild indices using this permutation.
+-    if dims_type in ('operator-ket', 'super'):
+-        # Swap the input and output spaces of the right part of
+-        # perm.
+-        perm[1] = list(reversed(perm[1]))
+-    if dims_type in ('operator-bra', 'super'):
+-        # Ditto, but for the left indices.
+-        perm[0] = list(reversed(perm[0]))
+-    return flatten(perm)
+-
+-
+-def dims_to_tensor_shape(dims):
+-    """
+-    Given the dims of a Qobj instance, returns the shape of the
+-    corresponding tensor. This helps, for instance, resolve the
+-    column-stacking convention for superoperators.
+-
+-    Parameters
+-    ----------
+-
+-    dims : list
+-        Dimensions specification for a Qobj.
+-
+-    Returns
+-    -------
+-
+-    tensor_shape : tuple
+-        NumPy shape of the corresponding tensor.
+-    """
+-    perm = dims_to_tensor_perm(dims)
+-    dims = flatten(dims)
+-    return tuple(map(partial(getitem, dims), perm))
+-
+-
+-def dims_idxs_to_tensor_idxs(dims, indices):
+-    """
+-    Given the dims of a Qobj instance, and some indices into
+-    dims, returns the corresponding tensor indices. This helps
+-    resolve, for instance, that column-stacking for superoperators,
+-    oper-ket and oper-bra implies that the input and output tensor
+-    indices are reversed from their order in dims.
+-
+-    Parameters
+-    ----------
+-
+-    dims : list
+-        Dimensions specification for a Qobj.
+-
+-    indices : int, list or tuple
+-        Indices to convert to tensor indices. Can be specified
+-        as a single index, or as a collection of indices.
+-        In the latter case, this can be nested arbitrarily
+-        deep. For instance, [0, [0, (2, 3)]].
+-
+-    Returns
+-    -------
+-
+-    tens_indices : int, list or tuple
+-        Container of the same structure as indices containing
+-        the tensor indices for each element of indices.
+-    """
+-    perm = dims_to_tensor_perm(dims)
+-    return deep_map(partial(getitem, perm), indices)
++"""
++Internal use module for manipulating dims specifications.
++"""
++
++# Everything should be explicitly imported, not made available by default.
++
++import numpy as np
++from operator import getitem
++from functools import partial
++
++
++def is_scalar(dims):
++    """
++    Returns True if a dims specification is effectively
++    a scalar (has dimension 1).
++    """
++    return np.prod(flatten(dims)) == 1
++
++
++def is_vector(dims):
++    return (
++        isinstance(dims, list) and
++        isinstance(dims[0], (int, np.integer))
++    )
++
++
++def is_vectorized_oper(dims):
++    return (
++        isinstance(dims, list) and
++        isinstance(dims[0], list)
++    )
++
++
++def type_from_dims(dims, enforce_square=False):
++    bra_like, ket_like = map(is_scalar, dims)
++
++    if bra_like:
++        if is_vector(dims[1]):
++            return 'bra'
++        elif is_vectorized_oper(dims[1]):
++            return 'operator-bra'
++
++    if ket_like:
++        if is_vector(dims[0]):
++            return 'ket'
++        elif is_vectorized_oper(dims[0]):
++            return 'operator-ket'
++
++    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
++        return 'oper'
++
++    elif (
++        is_vectorized_oper(dims[0])
++        and (
++            not enforce_square
++            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
++        )
++    ):
++        return 'super'
++    return 'other'
++
++
++def flatten(l):
++    """Flattens a list of lists to the first level.
++
++    Given a list containing a mix of scalars and lists,
++    flattens down to a list of the scalars within the original
++    list.
++
++    Examples
++    --------
++
++    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
++    [0, 1, 2]
++
++    """
++    if not isinstance(l, list):
++        return [l]
++    else:
++        return sum(map(flatten, l), [])
++
++
++def deep_remove(l, *what):
++    """Removes scalars from all levels of a nested list.
++
++    Given a list containing a mix of scalars and lists,
++    returns a list of the same structure, but where one or
++    more scalars have been removed.
++
++    Examples
++    --------
++
++    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
++    [[[[1, 2]], [3, 4], [], [6, 7]]]
++
++    """
++    if isinstance(l, list):
++        # Make a shallow copy at this level.
++        l = l[:]
++        for to_remove in what:
++            if to_remove in l:
++                l.remove(to_remove)
++            else:
++                l = [deep_remove(elem, to_remove) for elem in l]
++    return l
++
++
++def unflatten(l, idxs):
++    """Unflattens a list by a given structure.
++
++    Given a list of scalars and a deep list of indices
++    as produced by `flatten`, returns an "unflattened"
++    form of the list. This perfectly inverts `flatten`.
++
++    Examples
++    --------
++
++    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
++    >>> idxs = enumerate_flat(l) # doctest: +SKIP
++    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
++    True
++
++    """
++    acc = []
++    for idx in idxs:
++        if isinstance(idx, list):
++            acc.append(unflatten(l, idx))
++        else:
++            acc.append(l[idx])
++    return acc
++
++
++def _enumerate_flat(l, idx=0):
++    if not isinstance(l, list):
++        # Found a scalar, so return and increment.
++        return idx, idx + 1
++    else:
++        # Found a list, so append all the scalars
++        # from it and recurse to keep the increment
++        # correct.
++        acc = []
++        for elem in l:
++            labels, idx = _enumerate_flat(elem, idx)
++            acc.append(labels)
++        return acc, idx
++
++
++def _collapse_composite_index(dims):
++    """
++    Given the dimensions specification for a composite index
++    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
++    returns a dimensions specification for an index of the same shape,
++    but collapsed to a single "leg." In the previous example, [2, 3]
++    would collapse to [6].
++    """
++    return [np.prod(dims)]
++
++
++def _collapse_dims_to_level(dims, level=1):
++    """
++    Recursively collapses all indices in a dimensions specification
++    appearing at a given level, such that the returned dimensions
++    specification does not represent any composite systems.
++    """
++    if level == 0:
++        return _collapse_composite_index(dims)
++    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
++
++
++def collapse_dims_oper(dims):
++    """
++    Given the dimensions specifications for a ket-, bra- or oper-type
++    Qobj, returns a dimensions specification describing the same shape
++    by collapsing all composite systems. For instance, the bra-type
++    dimensions specification ``[[2, 3], [1]]`` collapses to
++    ``[[6], [1]]``.
++
++    Parameters
++    ----------
++
++    dims : list of lists of ints
++        Dimensions specifications to be collapsed.
++
++    Returns
++    -------
++
++    collapsed_dims : list of lists of ints
++        Collapsed dimensions specification describing the same shape
++        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
++    """
++    return _collapse_dims_to_level(dims, 1)
++
++
++def collapse_dims_super(dims):
++    """
++    Given the dimensions specifications for an operator-ket-, operator-bra- or
++    super-type Qobj, returns a dimensions specification describing the same shape
++    by collapsing all composite systems. For instance, the super-type
++    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
++    ``[[[6], [6]], [[6], [6]]]``.
++
++    Parameters
++    ----------
++
++    dims : list of lists of ints
++        Dimensions specifications to be collapsed.
++
++    Returns
++    -------
++
++    collapsed_dims : list of lists of ints
++        Collapsed dimensions specification describing the same shape
++        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
++        in ``range(2)``.
++    """
++    return _collapse_dims_to_level(dims, 2)
++
++
++def enumerate_flat(l):
++    """Labels the indices at which scalars occur in a flattened list.
++
++    Given a list containing a mix of scalars and lists,
++    returns a list of the same structure, where each scalar
++    has been replaced by an index into the flattened list.
++
++    Examples
++    --------
++
++    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
++    [[[0], [1, 2]], 3]
++
++    """
++    return _enumerate_flat(l)[0]
++
++
++def deep_map(fn, collection, over=(tuple, list)):
++    if isinstance(collection, over):
++        return type(collection)(deep_map(fn, el, over) for el in collection)
++    else:
++        return fn(collection)
++
++
++def dims_to_tensor_perm(dims):
++    """
++    Given the dims of a Qobj instance, returns a list representing
++    a permutation from the flattening of that dims specification to
++    the corresponding tensor indices.
++
++    Parameters
++    ----------
++
++    dims : list
++        Dimensions specification for a Qobj.
++
++    Returns
++    -------
++
++    perm : list
++        A list such that ``data[flatten(dims)[idx]]`` gives the
++        index of the tensor ``data`` corresponding to the ``idx``th
++        dimension of ``dims``.
++    """
++    # We figure out the type of the dims specification,
++    # relaxing the requirement that operators be square.
++    # This means that dims_type need not coincide with
++    # Qobj.type, but that works fine for our purposes here.
++    dims_type = type_from_dims(dims, enforce_square=False)
++    perm = enumerate_flat(dims)
++    if dims_type in ('oper', 'ket', 'bra'):
++        return flatten(perm)
++
++    # If the type is other, we need to figure out if the
++    # dims is superlike on its outputs and inputs
++    # This is the case if the dims type for left or right
++    # are, respectively, oper-like.
++    if dims_type == 'other':
++        raise NotImplementedError("Not yet implemented for type='other'.")
++
++    # If we're still here, the story is more complicated. We'll
++    # follow the strategy of creating a permutation by using
++    # enumerate_flat then transforming the result to swap
++    # input and output indices of vectorized matrices, then flattening
++    # the result. We'll then rebuild indices using this permutation.
++    if dims_type in ('operator-ket', 'super'):
++        # Swap the input and output spaces of the right part of
++        # perm.
++        perm[1] = list(reversed(perm[1]))
++    if dims_type in ('operator-bra', 'super'):
++        # Ditto, but for the left indices.
++        perm[0] = list(reversed(perm[0]))
++    return flatten(perm)
++
++
++def dims_to_tensor_shape(dims):
++    """
++    Given the dims of a Qobj instance, returns the shape of the
++    corresponding tensor. This helps, for instance, resolve the
++    column-stacking convention for superoperators.
++
++    Parameters
++    ----------
++
++    dims : list
++        Dimensions specification for a Qobj.
++
++    Returns
++    -------
++
++    tensor_shape : tuple
++        NumPy shape of the corresponding tensor.
++    """
++    perm = dims_to_tensor_perm(dims)
++    dims = flatten(dims)
++    return tuple(map(partial(getitem, dims), perm))
++
++
++def dims_idxs_to_tensor_idxs(dims, indices):
++    """
++    Given the dims of a Qobj instance, and some indices into
++    dims, returns the corresponding tensor indices. This helps
++    resolve, for instance, that column-stacking for superoperators,
++    oper-ket and oper-bra implies that the input and output tensor
++    indices are reversed from their order in dims.
++
++    Parameters
++    ----------
++
++    dims : list
++        Dimensions specification for a Qobj.
++
++    indices : int, list or tuple
++        Indices to convert to tensor indices. Can be specified
++        as a single index, or as a collection of indices.
++        In the latter case, this can be nested arbitrarily
++        deep. For instance, [0, [0, (2, 3)]].
++
++    Returns
++    -------
++
++    tens_indices : int, list or tuple
++        Container of the same structure as indices containing
++        the tensor indices for each element of indices.
++    """
++    perm = dims_to_tensor_perm(dims)
++    return deep_map(partial(getitem, perm), indices)
+diff --git a/qutip/core/expect.py b/qutip/core/expect.py
+index 65888f8c..f290a25b 100644
+--- a/qutip/core/expect.py
++++ b/qutip/core/expect.py
+@@ -1,97 +1,97 @@
+-__all__ = ['expect', 'variance']
+-
+-import numpy as np
+-
+-from .qobj import Qobj
+-from . import data as _data
+-
+-
+-def expect(oper, state):
+-    """
+-    Calculate the expectation value for operator(s) and state(s).  The
+-    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
+-    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
+-
+-    Parameters
+-    ----------
+-    oper : qobj/array-like
+-        A single or a `list` or operators for expectation value.
+-
+-    state : qobj/array-like
+-        A single or a `list` of quantum states or density matrices.
+-
+-    Returns
+-    -------
+-    expt : float/complex/array-like
+-        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
+-        otherwise. A (nested) array of expectaction values of state or operator
+-        are arrays.
+-
+-    Examples
+-    --------
+-    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
+-        True
+-
+-    """
+-    if isinstance(state, Qobj) and isinstance(oper, Qobj):
+-        return _single_qobj_expect(oper, state)
+-
+-    elif isinstance(oper, (list, np.ndarray)):
+-        if isinstance(state, Qobj):
+-            dtype = np.complex128
+-            if all(op.isherm for op in oper) and (state.isket or state.isherm):
+-                dtype = np.float64
+-            return np.array([_single_qobj_expect(op, state) for op in oper],
+-                            dtype=dtype)
+-        return [expect(op, state) for op in oper]
+-
+-    elif isinstance(state, (list, np.ndarray)):
+-        dtype = np.complex128
+-        if oper.isherm and all(op.isherm or op.isket for op in state):
+-            dtype = np.float64
+-        return np.array([_single_qobj_expect(oper, x) for x in state],
+-                        dtype=dtype)
+-    raise TypeError('Arguments must be quantum objects')
+-
+-
+-def _single_qobj_expect(oper, state):
+-    """
+-    Private function used by expect to calculate expectation values of Qobjs.
+-    """
+-    if not oper.isoper or not (state.isket or state.isoper):
+-        raise TypeError('invalid operand types')
+-    if oper.dims[1] != state.dims[0]:
+-        msg = (
+-            "incompatible dimensions "
+-            + str(oper.dims[1]) + " and " + str(state.dims[0])
+-        )
+-        raise ValueError(msg)
+-    out = _data.expect(oper.data, state.data)
+-
+-    # This ensures that expect can return something that is not a number such
+-    # as a `tensorflow.Tensor` in qutip-tensorflow.
+-    return out.real if (oper.isherm
+-                        and (state.isket or state.isherm)
+-                        and hasattr(out, "real")
+-                        ) else out
+-
+-
+-def variance(oper, state):
+-    """
+-    Variance of an operator for the given state vector or density matrix.
+-
+-    Parameters
+-    ----------
+-    oper : qobj
+-        Operator for expectation value.
+-
+-    state : qobj/list
+-        A single or `list` of quantum states or density matrices..
+-
+-    Returns
+-    -------
+-    var : float
+-        Variance of operator 'oper' for given state.
+-
+-    """
+-    return expect(oper**2, state) - expect(oper, state)**2
++__all__ = ['expect', 'variance']
++
++import numpy as np
++
++from .qobj import Qobj
++from . import data as _data
++
++
++def expect(oper, state):
++    """
++    Calculate the expectation value for operator(s) and state(s).  The
++    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
++    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
++
++    Parameters
++    ----------
++    oper : qobj/array-like
++        A single or a `list` or operators for expectation value.
++
++    state : qobj/array-like
++        A single or a `list` of quantum states or density matrices.
++
++    Returns
++    -------
++    expt : float/complex/array-like
++        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
++        otherwise. A (nested) array of expectaction values of state or operator
++        are arrays.
++
++    Examples
++    --------
++    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
++        True
++
++    """
++    if isinstance(state, Qobj) and isinstance(oper, Qobj):
++        return _single_qobj_expect(oper, state)
++
++    elif isinstance(oper, (list, np.ndarray)):
++        if isinstance(state, Qobj):
++            dtype = np.complex128
++            if all(op.isherm for op in oper) and (state.isket or state.isherm):
++                dtype = np.float64
++            return np.array([_single_qobj_expect(op, state) for op in oper],
++                            dtype=dtype)
++        return [expect(op, state) for op in oper]
++
++    elif isinstance(state, (list, np.ndarray)):
++        dtype = np.complex128
++        if oper.isherm and all(op.isherm or op.isket for op in state):
++            dtype = np.float64
++        return np.array([_single_qobj_expect(oper, x) for x in state],
++                        dtype=dtype)
++    raise TypeError('Arguments must be quantum objects')
++
++
++def _single_qobj_expect(oper, state):
++    """
++    Private function used by expect to calculate expectation values of Qobjs.
++    """
++    if not oper.isoper or not (state.isket or state.isoper):
++        raise TypeError('invalid operand types')
++    if oper.dims[1] != state.dims[0]:
++        msg = (
++            "incompatible dimensions "
++            + str(oper.dims[1]) + " and " + str(state.dims[0])
++        )
++        raise ValueError(msg)
++    out = _data.expect(oper.data, state.data)
++
++    # This ensures that expect can return something that is not a number such
++    # as a `tensorflow.Tensor` in qutip-tensorflow.
++    return out.real if (oper.isherm
++                        and (state.isket or state.isherm)
++                        and hasattr(out, "real")
++                        ) else out
++
++
++def variance(oper, state):
++    """
++    Variance of an operator for the given state vector or density matrix.
++
++    Parameters
++    ----------
++    oper : qobj
++        Operator for expectation value.
++
++    state : qobj/list
++        A single or `list` of quantum states or density matrices..
++
++    Returns
++    -------
++    var : float
++        Variance of operator 'oper' for given state.
++
++    """
++    return expect(oper**2, state) - expect(oper, state)**2
+diff --git a/qutip/core/gates.py b/qutip/core/gates.py
+index 28726e29..ae99fc44 100644
+--- a/qutip/core/gates.py
++++ b/qutip/core/gates.py
+@@ -1,747 +1,747 @@
+-from itertools import product
+-from functools import partial, reduce
+-from operator import mul
+-
+-import numpy as np
+-import scipy.sparse as sp
+-from . import Qobj, qeye, sigmax, fock_dm, qdiags
+-
+-
+-__all__ = [
+-    "rx",
+-    "ry",
+-    "rz",
+-    "sqrtnot",
+-    "snot",
+-    "phasegate",
+-    "qrot",
+-    "cy_gate",
+-    "cz_gate",
+-    "s_gate",
+-    "t_gate",
+-    "cs_gate",
+-    "ct_gate",
+-    "cphase",
+-    "cnot",
+-    "csign",
+-    "berkeley",
+-    "swapalpha",
+-    "swap",
+-    "iswap",
+-    "sqrtswap",
+-    "sqrtiswap",
+-    "fredkin",
+-    "molmer_sorensen",
+-    "toffoli",
+-    "hadamard_transform",
+-    "qubit_clifford_group",
+-]
+-
+-
+-def cy_gate(*, dtype="csr"):
+-    """Controlled Y gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : :class:`qutip.Qobj`
+-        Quantum object for operator describing the rotation.
+-    """
+-    return Qobj(
+-        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def cz_gate(*, dtype="csr"):
+-    """Controlled Z gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : :class:`qutip.Qobj`
+-        Quantum object for operator describing the rotation.
+-    """
+-    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
+-
+-
+-def s_gate(*, dtype="csr"):
+-    """Single-qubit rotation also called Phase gate or the Z90 gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : :class:`qutip.Qobj`
+-        Quantum object for operator describing
+-        a 90 degree rotation around the z-axis.
+-
+-    """
+-    return qdiags([1, 1j], dtype=dtype)
+-
+-
+-def cs_gate(*, dtype="csr"):
+-    """Controlled S gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : :class:`qutip.Qobj`
+-        Quantum object for operator describing the rotation.
+-
+-    """
+-    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
+-
+-
+-def t_gate(*, dtype="csr"):
+-    """Single-qubit rotation related to the S gate by the relationship S=T*T.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : :class:`qutip.Qobj`
+-        Quantum object for operator describing a phase shift of pi/4.
+-
+-    """
+-    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
+-
+-
+-def ct_gate(*, dtype="csr"):
+-    """Controlled T gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : :class:`qutip.Qobj`
+-        Quantum object for operator describing the rotation.
+-
+-    """
+-    return qdiags(
+-        [1, 1, 1, np.exp(1j * np.pi / 4)],
+-        dims=[[2, 2], [2, 2]],
+-        dtype=dtype,
+-    )
+-
+-
+-def rx(phi, *, dtype="dense"):
+-    """Single-qubit rotation for operator sigmax with angle phi.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : qobj
+-        Quantum object for operator describing the rotation.
+-
+-    """
+-    return Qobj(
+-        [
+-            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
+-            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
+-        ]
+-    ).to(dtype)
+-
+-
+-def ry(phi, *, dtype="dense"):
+-    """Single-qubit rotation for operator sigmay with angle phi.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : qobj
+-        Quantum object for operator describing the rotation.
+-
+-    """
+-    return Qobj(
+-        [
+-            [np.cos(phi / 2), -np.sin(phi / 2)],
+-            [np.sin(phi / 2), np.cos(phi / 2)],
+-        ]
+-    ).to(dtype)
+-
+-
+-def rz(phi, *, dtype="csr"):
+-    """Single-qubit rotation for operator sigmaz with angle phi.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : qobj
+-        Quantum object for operator describing the rotation.
+-
+-    """
+-    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
+-
+-
+-def sqrtnot(*, dtype="dense"):
+-    """Single-qubit square root NOT gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    result : qobj
+-        Quantum object for operator describing the square root NOT gate.
+-
+-    """
+-    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
+-
+-
+-def snot(*, dtype="dense"):
+-    """Quantum object representing the SNOT (Hadamard) gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    snot_gate : qobj
+-        Quantum object representation of SNOT gate.
+-
+-    """
+-    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
+-
+-
+-def phasegate(theta, *, dtype="csr"):
+-    """
+-    Returns quantum object representing the phase shift gate.
+-
+-    Parameters
+-    ----------
+-    theta : float
+-        Phase rotation angle.
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    phase_gate : qobj
+-        Quantum object representation of phase shift gate.
+-
+-    """
+-    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
+-
+-
+-def qrot(theta, phi, *, dtype="dense"):
+-    """
+-    Single qubit rotation driving by Rabi oscillation with 0 detune.
+-
+-    Parameters
+-    ----------
+-    phi : float
+-        The inital phase of the rabi pulse.
+-    theta : float
+-        The duration of the rabi pulse.
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    qrot_gate : :class:`qutip.Qobj`
+-        Quantum object representation of physical qubit rotation under
+-        a rabi pulse.
+-    """
+-    return Qobj(
+-        [
+-            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
+-            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
+-        ]
+-    ).to(dtype)
+-
+-
+-#
+-# 2 Qubit Gates
+-#
+-
+-
+-def cphase(theta, *, dtype="csr"):
+-    """
+-    Returns quantum object representing the controlled phase shift gate.
+-
+-    Parameters
+-    ----------
+-    theta : float
+-        Phase rotation angle.
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    U : qobj
+-        Quantum object representation of controlled phase gate.
+-    """
+-    return qdiags(
+-        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
+-    )
+-
+-
+-def cnot(*, dtype="csr"):
+-    """
+-    Quantum object representing the CNOT gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    cnot_gate : qobj
+-        Quantum object representation of CNOT gate
+-
+-    """
+-    return Qobj(
+-        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def csign(*, dtype="csr"):
+-    """
+-    Quantum object representing the CSIGN gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    csign_gate : qobj
+-        Quantum object representation of CSIGN gate
+-
+-    """
+-    return cz_gate(dtype=dtype)
+-
+-
+-def berkeley(*, dtype="dense"):
+-    """
+-    Quantum object representing the Berkeley gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    berkeley_gate : qobj
+-        Quantum object representation of Berkeley gate
+-
+-    """
+-    return Qobj(
+-        [
+-            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
+-            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
+-            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
+-            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
+-        ],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def swapalpha(alpha, *, dtype="csr"):
+-    """
+-    Quantum object representing the SWAPalpha gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    swapalpha_gate : qobj
+-        Quantum object representation of SWAPalpha gate
+-    """
+-    phase = np.exp(1.0j * np.pi * alpha)
+-    return Qobj(
+-        [
+-            [1, 0, 0, 0],
+-            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
+-            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
+-            [0, 0, 0, 1],
+-        ],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def swap(*, dtype="csr"):
+-    """Quantum object representing the SWAP gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    swap_gate : qobj
+-        Quantum object representation of SWAP gate
+-
+-    """
+-    return Qobj(
+-        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def iswap(*, dtype="csr"):
+-    """Quantum object representing the iSWAP gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    iswap_gate : qobj
+-        Quantum object representation of iSWAP gate
+-    """
+-    return Qobj(
+-        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def sqrtswap(*, dtype="dense"):
+-    """Quantum object representing the square root SWAP gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    sqrtswap_gate : qobj
+-        Quantum object representation of square root SWAP gate
+-
+-    """
+-    return Qobj(
+-        np.array(
+-            [
+-                [1, 0, 0, 0],
+-                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
+-                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
+-                [0, 0, 0, 1],
+-            ]
+-        ),
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def sqrtiswap(*, dtype="dense"):
+-    """Quantum object representing the square root iSWAP gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    sqrtiswap_gate : qobj
+-        Quantum object representation of square root iSWAP gate
+-    """
+-    return Qobj(
+-        np.array(
+-            [
+-                [1, 0, 0, 0],
+-                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
+-                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
+-                [0, 0, 0, 1],
+-            ]
+-        ),
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-def molmer_sorensen(theta, *, dtype="dense"):
+-    """
+-    Quantum object of a Mølmer–Sørensen gate.
+-
+-    Parameters
+-    ----------
+-    theta: float
+-        The duration of the interaction pulse.
+-    N: int
+-        Number of qubits in the system.
+-    target: int
+-        The indices of the target qubits.
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    molmer_sorensen_gate: :class:`qutip.Qobj`
+-        Quantum object representation of the Mølmer–Sørensen gate.
+-    """
+-    return Qobj(
+-        [
+-            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
+-            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
+-            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
+-            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
+-        ],
+-        dims=[[2, 2], [2, 2]],
+-    ).to(dtype)
+-
+-
+-#
+-# 3 Qubit Gates
+-#
+-
+-
+-def fredkin(*, dtype="csr"):
+-    """Quantum object representing the Fredkin gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    fredkin_gate : qobj
+-        Quantum object representation of Fredkin gate.
+-
+-    """
+-    return Qobj(
+-        [
+-            [1, 0, 0, 0, 0, 0, 0, 0],
+-            [0, 1, 0, 0, 0, 0, 0, 0],
+-            [0, 0, 1, 0, 0, 0, 0, 0],
+-            [0, 0, 0, 1, 0, 0, 0, 0],
+-            [0, 0, 0, 0, 1, 0, 0, 0],
+-            [0, 0, 0, 0, 0, 0, 1, 0],
+-            [0, 0, 0, 0, 0, 1, 0, 0],
+-            [0, 0, 0, 0, 0, 0, 0, 1],
+-        ],
+-        dims=[[2, 2, 2], [2, 2, 2]],
+-    ).to(dtype)
+-
+-
+-def toffoli(*, dtype="csr"):
+-    """Quantum object representing the Toffoli gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    toff_gate : qobj
+-        Quantum object representation of Toffoli gate.
+-
+-    """
+-    return Qobj(
+-        [
+-            [1, 0, 0, 0, 0, 0, 0, 0],
+-            [0, 1, 0, 0, 0, 0, 0, 0],
+-            [0, 0, 1, 0, 0, 0, 0, 0],
+-            [0, 0, 0, 1, 0, 0, 0, 0],
+-            [0, 0, 0, 0, 1, 0, 0, 0],
+-            [0, 0, 0, 0, 0, 1, 0, 0],
+-            [0, 0, 0, 0, 0, 0, 0, 1],
+-            [0, 0, 0, 0, 0, 0, 1, 0],
+-        ],
+-        dims=[[2, 2, 2], [2, 2, 2]],
+-    ).to(dtype)
+-
+-
+-#
+-# Miscellaneous Gates
+-#
+-
+-
+-def globalphase(theta, N=1, *, dtype="csr"):
+-    """
+-    Returns quantum object representing the global phase shift gate.
+-
+-    Parameters
+-    ----------
+-    theta : float
+-        Phase rotation angle.
+-
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    phase_gate : qobj
+-        Quantum object representation of global phase shift gate.
+-
+-    """
+-    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
+-
+-
+-#
+-# Operation on Gates
+-#
+-
+-
+-def _hamming_distance(x):
+-    """
+-    Calculate the bit-wise Hamming distance of x from 0: That is, the number
+-    1s in the integer x.
+-    """
+-    tot = 0
+-    while x:
+-        tot += 1
+-        x &= x - 1
+-    return tot
+-
+-
+-def hadamard_transform(N=1, *, dtype="dense"):
+-    """Quantum object representing the N-qubit Hadamard gate.
+-
+-    Parameters
+-    ----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    q : qobj
+-        Quantum object representation of the N-qubit Hadamard gate.
+-
+-    """
+-    data = 2 ** (-N / 2) * np.array(
+-        [
+-            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
+-            for j in range(2**N)
+-        ]
+-    )
+-
+-    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
+-
+-
+-def _powers(op, N):
+-    """
+-    Generator that yields powers of an operator `op`,
+-    through to `N`.
+-    """
+-    acc = qeye(op.dims[0])
+-    yield acc
+-
+-    for _ in range(N - 1):
+-        acc *= op
+-        yield acc
+-
+-
+-def qubit_clifford_group(*, dtype="dense"):
+-    """
+-    Generates the Clifford group on a single qubit,
+-    using the presentation of the group given by Ross and Selinger
+-    (http://www.mathstat.dal.ca/~selinger/newsynth/).
+-
+-    Parameters
+-    -----------
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Return
+-    ------
+-    op : list of Qobj
+-        Clifford operators, represented as Qobj instances.
+-
+-    """
+-
+-    # The Ross-Selinger presentation of the single-qubit Clifford
+-    # group expresses each element in the form C_{ijk} = E^i X^j S^k
+-    # for gates E, X and S, and for i in range(3), j in range(2) and
+-    # k in range(4).
+-    #
+-    # We start by defining these gates. E is defined in terms of H,
+-    # \omega and S, so we define \omega and H first.
+-    w = np.exp(1j * 2 * np.pi / 8)
+-    H = snot()
+-
+-    X = sigmax()
+-    S = phasegate(np.pi / 2)
+-    E = H * (S**3) * w**3
+-
+-    # partial(reduce, mul) returns a function that takes products
+-    # of its argument, by analogy to sum. Note that by analogy,
+-    # sum can be written as partial(reduce, add).
+-
+-    # product(...) yields the Cartesian product of its arguments.
+-    # Here, each element is a tuple (E**i, X**j, S**k) such that
+-    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
+-    return [
+-        op.to(dtype)
+-        for op in map(
+-            partial(reduce, mul),
+-            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
+-        )
+-    ]
++from itertools import product
++from functools import partial, reduce
++from operator import mul
++
++import numpy as np
++import scipy.sparse as sp
++from . import Qobj, qeye, sigmax, fock_dm, qdiags
++
++
++__all__ = [
++    "rx",
++    "ry",
++    "rz",
++    "sqrtnot",
++    "snot",
++    "phasegate",
++    "qrot",
++    "cy_gate",
++    "cz_gate",
++    "s_gate",
++    "t_gate",
++    "cs_gate",
++    "ct_gate",
++    "cphase",
++    "cnot",
++    "csign",
++    "berkeley",
++    "swapalpha",
++    "swap",
++    "iswap",
++    "sqrtswap",
++    "sqrtiswap",
++    "fredkin",
++    "molmer_sorensen",
++    "toffoli",
++    "hadamard_transform",
++    "qubit_clifford_group",
++]
++
++
++def cy_gate(*, dtype="csr"):
++    """Controlled Y gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : :class:`qutip.Qobj`
++        Quantum object for operator describing the rotation.
++    """
++    return Qobj(
++        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def cz_gate(*, dtype="csr"):
++    """Controlled Z gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : :class:`qutip.Qobj`
++        Quantum object for operator describing the rotation.
++    """
++    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
++
++
++def s_gate(*, dtype="csr"):
++    """Single-qubit rotation also called Phase gate or the Z90 gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : :class:`qutip.Qobj`
++        Quantum object for operator describing
++        a 90 degree rotation around the z-axis.
++
++    """
++    return qdiags([1, 1j], dtype=dtype)
++
++
++def cs_gate(*, dtype="csr"):
++    """Controlled S gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : :class:`qutip.Qobj`
++        Quantum object for operator describing the rotation.
++
++    """
++    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
++
++
++def t_gate(*, dtype="csr"):
++    """Single-qubit rotation related to the S gate by the relationship S=T*T.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : :class:`qutip.Qobj`
++        Quantum object for operator describing a phase shift of pi/4.
++
++    """
++    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
++
++
++def ct_gate(*, dtype="csr"):
++    """Controlled T gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : :class:`qutip.Qobj`
++        Quantum object for operator describing the rotation.
++
++    """
++    return qdiags(
++        [1, 1, 1, np.exp(1j * np.pi / 4)],
++        dims=[[2, 2], [2, 2]],
++        dtype=dtype,
++    )
++
++
++def rx(phi, *, dtype="dense"):
++    """Single-qubit rotation for operator sigmax with angle phi.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : qobj
++        Quantum object for operator describing the rotation.
++
++    """
++    return Qobj(
++        [
++            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
++            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
++        ]
++    ).to(dtype)
++
++
++def ry(phi, *, dtype="dense"):
++    """Single-qubit rotation for operator sigmay with angle phi.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : qobj
++        Quantum object for operator describing the rotation.
++
++    """
++    return Qobj(
++        [
++            [np.cos(phi / 2), -np.sin(phi / 2)],
++            [np.sin(phi / 2), np.cos(phi / 2)],
++        ]
++    ).to(dtype)
++
++
++def rz(phi, *, dtype="csr"):
++    """Single-qubit rotation for operator sigmaz with angle phi.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : qobj
++        Quantum object for operator describing the rotation.
++
++    """
++    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
++
++
++def sqrtnot(*, dtype="dense"):
++    """Single-qubit square root NOT gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    result : qobj
++        Quantum object for operator describing the square root NOT gate.
++
++    """
++    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
++
++
++def snot(*, dtype="dense"):
++    """Quantum object representing the SNOT (Hadamard) gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    snot_gate : qobj
++        Quantum object representation of SNOT gate.
++
++    """
++    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
++
++
++def phasegate(theta, *, dtype="csr"):
++    """
++    Returns quantum object representing the phase shift gate.
++
++    Parameters
++    ----------
++    theta : float
++        Phase rotation angle.
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    phase_gate : qobj
++        Quantum object representation of phase shift gate.
++
++    """
++    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
++
++
++def qrot(theta, phi, *, dtype="dense"):
++    """
++    Single qubit rotation driving by Rabi oscillation with 0 detune.
++
++    Parameters
++    ----------
++    phi : float
++        The inital phase of the rabi pulse.
++    theta : float
++        The duration of the rabi pulse.
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    qrot_gate : :class:`qutip.Qobj`
++        Quantum object representation of physical qubit rotation under
++        a rabi pulse.
++    """
++    return Qobj(
++        [
++            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
++            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
++        ]
++    ).to(dtype)
++
++
++#
++# 2 Qubit Gates
++#
++
++
++def cphase(theta, *, dtype="csr"):
++    """
++    Returns quantum object representing the controlled phase shift gate.
++
++    Parameters
++    ----------
++    theta : float
++        Phase rotation angle.
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    U : qobj
++        Quantum object representation of controlled phase gate.
++    """
++    return qdiags(
++        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
++    )
++
++
++def cnot(*, dtype="csr"):
++    """
++    Quantum object representing the CNOT gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    cnot_gate : qobj
++        Quantum object representation of CNOT gate
++
++    """
++    return Qobj(
++        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def csign(*, dtype="csr"):
++    """
++    Quantum object representing the CSIGN gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    csign_gate : qobj
++        Quantum object representation of CSIGN gate
++
++    """
++    return cz_gate(dtype=dtype)
++
++
++def berkeley(*, dtype="dense"):
++    """
++    Quantum object representing the Berkeley gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    berkeley_gate : qobj
++        Quantum object representation of Berkeley gate
++
++    """
++    return Qobj(
++        [
++            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
++            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
++            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
++            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
++        ],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def swapalpha(alpha, *, dtype="csr"):
++    """
++    Quantum object representing the SWAPalpha gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    swapalpha_gate : qobj
++        Quantum object representation of SWAPalpha gate
++    """
++    phase = np.exp(1.0j * np.pi * alpha)
++    return Qobj(
++        [
++            [1, 0, 0, 0],
++            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
++            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
++            [0, 0, 0, 1],
++        ],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def swap(*, dtype="csr"):
++    """Quantum object representing the SWAP gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    swap_gate : qobj
++        Quantum object representation of SWAP gate
++
++    """
++    return Qobj(
++        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def iswap(*, dtype="csr"):
++    """Quantum object representing the iSWAP gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    iswap_gate : qobj
++        Quantum object representation of iSWAP gate
++    """
++    return Qobj(
++        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def sqrtswap(*, dtype="dense"):
++    """Quantum object representing the square root SWAP gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    sqrtswap_gate : qobj
++        Quantum object representation of square root SWAP gate
++
++    """
++    return Qobj(
++        np.array(
++            [
++                [1, 0, 0, 0],
++                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
++                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
++                [0, 0, 0, 1],
++            ]
++        ),
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def sqrtiswap(*, dtype="dense"):
++    """Quantum object representing the square root iSWAP gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    sqrtiswap_gate : qobj
++        Quantum object representation of square root iSWAP gate
++    """
++    return Qobj(
++        np.array(
++            [
++                [1, 0, 0, 0],
++                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
++                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
++                [0, 0, 0, 1],
++            ]
++        ),
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++def molmer_sorensen(theta, *, dtype="dense"):
++    """
++    Quantum object of a Mølmer–Sørensen gate.
++
++    Parameters
++    ----------
++    theta: float
++        The duration of the interaction pulse.
++    N: int
++        Number of qubits in the system.
++    target: int
++        The indices of the target qubits.
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    molmer_sorensen_gate: :class:`qutip.Qobj`
++        Quantum object representation of the Mølmer–Sørensen gate.
++    """
++    return Qobj(
++        [
++            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
++            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
++            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
++            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
++        ],
++        dims=[[2, 2], [2, 2]],
++    ).to(dtype)
++
++
++#
++# 3 Qubit Gates
++#
++
++
++def fredkin(*, dtype="csr"):
++    """Quantum object representing the Fredkin gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    fredkin_gate : qobj
++        Quantum object representation of Fredkin gate.
++
++    """
++    return Qobj(
++        [
++            [1, 0, 0, 0, 0, 0, 0, 0],
++            [0, 1, 0, 0, 0, 0, 0, 0],
++            [0, 0, 1, 0, 0, 0, 0, 0],
++            [0, 0, 0, 1, 0, 0, 0, 0],
++            [0, 0, 0, 0, 1, 0, 0, 0],
++            [0, 0, 0, 0, 0, 0, 1, 0],
++            [0, 0, 0, 0, 0, 1, 0, 0],
++            [0, 0, 0, 0, 0, 0, 0, 1],
++        ],
++        dims=[[2, 2, 2], [2, 2, 2]],
++    ).to(dtype)
++
++
++def toffoli(*, dtype="csr"):
++    """Quantum object representing the Toffoli gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    toff_gate : qobj
++        Quantum object representation of Toffoli gate.
++
++    """
++    return Qobj(
++        [
++            [1, 0, 0, 0, 0, 0, 0, 0],
++            [0, 1, 0, 0, 0, 0, 0, 0],
++            [0, 0, 1, 0, 0, 0, 0, 0],
++            [0, 0, 0, 1, 0, 0, 0, 0],
++            [0, 0, 0, 0, 1, 0, 0, 0],
++            [0, 0, 0, 0, 0, 1, 0, 0],
++            [0, 0, 0, 0, 0, 0, 0, 1],
++            [0, 0, 0, 0, 0, 0, 1, 0],
++        ],
++        dims=[[2, 2, 2], [2, 2, 2]],
++    ).to(dtype)
++
++
++#
++# Miscellaneous Gates
++#
++
++
++def globalphase(theta, N=1, *, dtype="csr"):
++    """
++    Returns quantum object representing the global phase shift gate.
++
++    Parameters
++    ----------
++    theta : float
++        Phase rotation angle.
++
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    phase_gate : qobj
++        Quantum object representation of global phase shift gate.
++
++    """
++    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
++
++
++#
++# Operation on Gates
++#
++
++
++def _hamming_distance(x):
++    """
++    Calculate the bit-wise Hamming distance of x from 0: That is, the number
++    1s in the integer x.
++    """
++    tot = 0
++    while x:
++        tot += 1
++        x &= x - 1
++    return tot
++
++
++def hadamard_transform(N=1, *, dtype="dense"):
++    """Quantum object representing the N-qubit Hadamard gate.
++
++    Parameters
++    ----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    q : qobj
++        Quantum object representation of the N-qubit Hadamard gate.
++
++    """
++    data = 2 ** (-N / 2) * np.array(
++        [
++            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
++            for j in range(2**N)
++        ]
++    )
++
++    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
++
++
++def _powers(op, N):
++    """
++    Generator that yields powers of an operator `op`,
++    through to `N`.
++    """
++    acc = qeye(op.dims[0])
++    yield acc
++
++    for _ in range(N - 1):
++        acc *= op
++        yield acc
++
++
++def qubit_clifford_group(*, dtype="dense"):
++    """
++    Generates the Clifford group on a single qubit,
++    using the presentation of the group given by Ross and Selinger
++    (http://www.mathstat.dal.ca/~selinger/newsynth/).
++
++    Parameters
++    -----------
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Return
++    ------
++    op : list of Qobj
++        Clifford operators, represented as Qobj instances.
++
++    """
++
++    # The Ross-Selinger presentation of the single-qubit Clifford
++    # group expresses each element in the form C_{ijk} = E^i X^j S^k
++    # for gates E, X and S, and for i in range(3), j in range(2) and
++    # k in range(4).
++    #
++    # We start by defining these gates. E is defined in terms of H,
++    # \omega and S, so we define \omega and H first.
++    w = np.exp(1j * 2 * np.pi / 8)
++    H = snot()
++
++    X = sigmax()
++    S = phasegate(np.pi / 2)
++    E = H * (S**3) * w**3
++
++    # partial(reduce, mul) returns a function that takes products
++    # of its argument, by analogy to sum. Note that by analogy,
++    # sum can be written as partial(reduce, add).
++
++    # product(...) yields the Cartesian product of its arguments.
++    # Here, each element is a tuple (E**i, X**j, S**k) such that
++    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
++    return [
++        op.to(dtype)
++        for op in map(
++            partial(reduce, mul),
++            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
++        )
++    ]
+diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
+index 08c63532..c87c1375 100644
+--- a/qutip/core/metrics.py
++++ b/qutip/core/metrics.py
+@@ -1,590 +1,590 @@
+-# -*- coding: utf-8 -*-
+-
+-"""
+-This module contains a collection of functions for calculating metrics
+-(distance measures) between states and operators.
+-"""
+-
+-__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
+-           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
+-           'process_fidelity', 'unitarity', 'dnorm']
+-
+-import warnings
+-
+-import numpy as np
+-from scipy import linalg as la
+-import scipy.sparse as sp
+-from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
+-                           kraus_to_choi)
+-from .superoperator import operator_to_vector, vector_to_operator
+-from .operators import qeye
+-from .states import ket2dm
+-from .semidefinite import dnorm_problem, dnorm_sparse_problem
+-from . import data as _data
+-
+-try:
+-    import cvxpy
+-except ImportError:
+-    cvxpy = None
+-
+-
+-def fidelity(A, B):
+-    """
+-    Calculates the fidelity (pseudo-metric) between two density matrices.
+-    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
+-
+-    Parameters
+-    ----------
+-    A : qobj
+-        Density matrix or state vector.
+-    B : qobj
+-        Density matrix or state vector with same dimensions as A.
+-
+-    Returns
+-    -------
+-    fid : float
+-        Fidelity pseudo-metric between A and B.
+-
+-    Examples
+-    --------
+-    >>> x = fock_dm(5,3)
+-    >>> y = coherent_dm(5,1)
+-    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
+-    """
+-    if A.isket or A.isbra:
+-        if B.isket or B.isbra:
+-            # The fidelity for pure states reduces to the modulus of their
+-            # inner product.
+-            return np.abs(A.overlap(B))
+-        # Take advantage of the fact that the density operator for A
+-        # is a projector to avoid a sqrtm call.
+-        sqrtmA = ket2dm(A)
+-    else:
+-        if B.isket or B.isbra:
+-            # Swap the order so that we can take a more numerically
+-            # stable square root of B.
+-            return fidelity(B, A)
+-        # If we made it here, both A and B are operators, so
+-        # we have to take the sqrtm of one of them.
+-        sqrtmA = A.sqrtm()
+-
+-    if sqrtmA.dims != B.dims:
+-        raise TypeError('Density matrices do not have same dimensions.')
+-
+-    # We don't actually need the whole matrix here, just the trace
+-    # of its square root, so let's just get its eigenenergies instead.
+-    # We also truncate negative eigenvalues to avoid nan propagation;
+-    # even for positive semidefinite matrices, small negative eigenvalues
+-    # can be reported.
+-    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
+-    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
+-
+-
+-def _hilbert_space_dims(oper):
+-    """
+-    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
+-    of the output Hilbert space and the input Hilbert space.
+-    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
+-    - If oper is a list of Kraus operators, then
+-     `oper[0].dims == [dims_out, dims_in]`.
+-    - If oper is a superoperator with `oper.superrep == 'super'`:
+-     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
+-    - If oper is a superoperator with `oper.superrep == 'choi'`:
+-     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
+-    - If oper is a superoperator with `oper.superrep == 'chi', then
+-      `dims_out == dims_in` and
+-      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
+-    :param oper: A quantum channel, represented by a unitary, a list of Kraus
+-    operators, or a superoperator
+-    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
+-     of integers
+-    """
+-    if isinstance(oper, list):
+-        return oper[0].dims
+-    elif oper.type == 'oper':  # interpret as unitary quantum channel
+-        return oper.dims
+-    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
+-        return [oper.dims[0][1], oper.dims[1][0]]
+-    else:
+-        raise TypeError('oper is not a valid quantum channel!')
+-
+-
+-def _process_fidelity_to_id(oper):
+-    """
+-    Internal function returning the process fidelity of a quantum channel
+-    to the identity quantum channel.
+-    Parameters
+-    ----------
+-    oper : :class:`qutip.Qobj`/list
+-        A unitary operator, or a superoperator in supermatrix, Choi or
+-        chi-matrix form, or a list of Kraus operators
+-    Returns
+-    -------
+-    fid : float
+-    """
+-    dims_out, dims_in = _hilbert_space_dims(oper)
+-    if dims_out != dims_in:
+-        raise TypeError('The process fidelity to identity is only defined '
+-                        'for dimension preserving channels.')
+-    d = np.prod(dims_in)
+-    if isinstance(oper, list):  # oper is a list of Kraus operators
+-        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
+-    elif oper.type == 'oper':  # interpret as unitary
+-        return np.abs(oper.tr()) ** 2 / d ** 2
+-    elif oper.type == 'super':
+-        if oper.superrep == 'chi':
+-            return oper[0, 0].real / d ** 2
+-        else:  # oper.superrep is either 'super' or 'choi':
+-            return to_super(oper).tr().real / d ** 2
+-
+-
+-def _kraus_or_qobj_to_choi(oper):
+-    if isinstance(oper, list):
+-        return kraus_to_choi(oper)
+-    else:
+-        return to_choi(oper)
+-
+-
+-def process_fidelity(oper, target=None):
+-    """
+-    Returns the process fidelity of a quantum channel to the target
+-    channel, or to the identity channel if no target is given.
+-    The process fidelity between two channels is defined as the state
+-    fidelity between their normalized Choi matrices.
+-
+-    Parameters
+-    ----------
+-    oper : :class:`qutip.Qobj`/list
+-        A unitary operator, or a superoperator in supermatrix, Choi or
+-        chi-matrix form, or a list of Kraus operators
+-    target : :class:`qutip.Qobj`/list
+-        A unitary operator, or a superoperator in supermatrix, Choi or
+-        chi-matrix form, or a list of Kraus operators
+-
+-    Returns
+-    -------
+-    fid : float
+-        Process fidelity between oper and target, or between oper and identity.
+-
+-    Notes
+-    -----
+-    Since Qutip 5.0, this function computes the process fidelity as defined
+-    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
+-    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
+-    that is now implemented in
+-    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
+-    The definition of state fidelity that the process fidelity is based on
+-    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
+-    It is the square of the one implemented in
+-    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
+-    "Quantum Computation and Quantum Information"
+-
+-    """
+-    if target is None:
+-        return _process_fidelity_to_id(oper)
+-
+-    dims_out, dims_in = _hilbert_space_dims(oper)
+-    if dims_out != dims_in:
+-        raise NotImplementedError('Process fidelity only implemented for '
+-                                  'dimension-preserving operators.')
+-    dims_out_target, dims_in_target = _hilbert_space_dims(target)
+-    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
+-        raise TypeError('Dimensions of oper and target do not match')
+-
+-    if not isinstance(target, list) and target.type == 'oper':
+-        # interpret target as unitary.
+-        if isinstance(oper, list):  # oper is a list of Kraus operators
+-            return _process_fidelity_to_id([k * target.dag() for k in oper])
+-        elif oper.type == 'oper':
+-            return _process_fidelity_to_id(oper*target.dag())
+-        elif oper.type == 'super':
+-            oper_super = to_super(oper)
+-            target_dag_super = to_super(target.dag())
+-            return _process_fidelity_to_id(oper_super * target_dag_super)
+-    else:  # target is a list of Kraus operators or a superoperator
+-        if not isinstance(oper, list) and oper.type == 'oper':
+-            return process_fidelity(target, oper)  # reverse order
+-        oper_choi = _kraus_or_qobj_to_choi(oper)
+-        target_choi = _kraus_or_qobj_to_choi(target)
+-        d = np.prod(dims_in)
+-        return (fidelity(oper_choi, target_choi)/d)**2
+-
+-
+-def average_gate_fidelity(oper, target=None):
+-    """
+-    Returns the average gate fidelity of a quantum channel to the target
+-    channel, or to the identity channel if no target is given.
+-
+-    Parameters
+-    ----------
+-    oper : :class:`qutip.Qobj`/list
+-        A unitary operator, or a superoperator in supermatrix, Choi or
+-        chi-matrix form, or a list of Kraus operators
+-    target : :class:`qutip.Qobj`
+-        A unitary operator
+-
+-    Returns
+-    -------
+-    fid : float
+-        Average gate fidelity between oper and target,
+-        or between oper and identity.
+-
+-    Notes
+-    -----
+-    The average gate fidelity is defined for example in:
+-    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
+-    The definition of state fidelity that the average gate fidelity is based on
+-    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
+-    It is the square of the fidelity implemented in
+-    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
+-    "Quantum Computation and Quantum Information"
+-
+-    """
+-    dims_out, dims_in = _hilbert_space_dims(oper)
+-    if not (target is None or target.type == 'oper'):
+-        raise TypeError(
+-            'target must be None or a Qobj representing a unitary.')
+-
+-    d = np.prod(dims_in)
+-    return (d * process_fidelity(oper, target) + 1) / (d + 1)
+-
+-
+-def tracedist(A, B, sparse=False, tol=0):
+-    """
+-    Calculates the trace distance between two density matrices..
+-    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
+-
+-    Parameters
+-    ----------!=
+-    A : qobj
+-        Density matrix or state vector.
+-    B : qobj
+-        Density matrix or state vector with same dimensions as A.
+-    tol : float
+-        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
+-    sparse : {False, True}
+-        Use sparse eigensolver.
+-
+-    Returns
+-    -------
+-    tracedist : float
+-        Trace distance between A and B.
+-
+-    Examples
+-    --------
+-    >>> x=fock_dm(5,3)
+-    >>> y=coherent_dm(5,1)
+-    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
+-    """
+-    if A.isket or A.isbra:
+-        A = A.proj()
+-    if B.isket or B.isbra:
+-        B = B.proj()
+-    if A.dims != B.dims:
+-        raise TypeError("A and B do not have same dimensions.")
+-    diff = A - B
+-    diff = diff.dag() * diff
+-    vals = diff.eigenenergies(sparse=sparse, tol=tol)
+-    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
+-
+-
+-def hilbert_dist(A, B):
+-    """
+-    Returns the Hilbert-Schmidt distance between two density matrices A & B.
+-
+-    Parameters
+-    ----------
+-    A : qobj
+-        Density matrix or state vector.
+-    B : qobj
+-        Density matrix or state vector with same dimensions as A.
+-
+-    Returns
+-    -------
+-    dist : float
+-        Hilbert-Schmidt distance between density matrices.
+-
+-    Notes
+-    -----
+-    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
+-
+-    """
+-    if A.isket or A.isbra:
+-        A = A.proj()
+-    if B.isket or B.isbra:
+-        B = B.proj()
+-    if A.dims != B.dims:
+-        raise TypeError('A and B do not have same dimensions.')
+-    return ((A - B)**2).tr()
+-
+-
+-def bures_dist(A, B):
+-    """
+-    Returns the Bures distance between two density matrices A & B.
+-
+-    The Bures distance ranges from 0, for states with unit fidelity,
+-    to sqrt(2).
+-
+-    Parameters
+-    ----------
+-    A : qobj
+-        Density matrix or state vector.
+-    B : qobj
+-        Density matrix or state vector with same dimensions as A.
+-
+-    Returns
+-    -------
+-    dist : float
+-        Bures distance between density matrices.
+-    """
+-    if A.isket or A.isbra:
+-        A = A.proj()
+-    if B.isket or B.isbra:
+-        B = B.proj()
+-    if A.dims != B.dims:
+-        raise TypeError('A and B do not have same dimensions.')
+-    dist = np.sqrt(2 * (1 - fidelity(A, B)))
+-    return dist
+-
+-
+-def bures_angle(A, B):
+-    """
+-    Returns the Bures Angle between two density matrices A & B.
+-
+-    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
+-
+-    Parameters
+-    ----------
+-    A : qobj
+-        Density matrix or state vector.
+-    B : qobj
+-        Density matrix or state vector with same dimensions as A.
+-
+-    Returns
+-    -------
+-    angle : float
+-        Bures angle between density matrices.
+-    """
+-    if A.isket or A.isbra:
+-        A = A.proj()
+-    if B.isket or B.isbra:
+-        B = B.proj()
+-    if A.dims != B.dims:
+-        raise TypeError('A and B do not have same dimensions.')
+-    return np.arccos(fidelity(A, B))
+-
+-
+-def hellinger_dist(A, B, sparse=False, tol=0):
+-    """
+-    Calculates the quantum Hellinger distance between two density matrices.
+-
+-    Formula:
+-    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
+-
+-    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
+-    measures of quantum correlations with Bures and Hellinger distances"
+-    arXiv:1611.03449
+-
+-    Parameters
+-    ----------
+-    A : :class:`qutip.Qobj`
+-        Density matrix or state vector.
+-    B : :class:`qutip.Qobj`
+-        Density matrix or state vector with same dimensions as A.
+-    tol : float
+-        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
+-    sparse : {False, True}
+-        Use sparse eigensolver.
+-
+-    Returns
+-    -------
+-    hellinger_dist : float
+-        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
+-
+-    Examples
+-    --------
+-    >>> x=fock_dm(5,3)
+-    >>> y=coherent_dm(5,1)
+-    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
+-    """
+-    if A.isket or A.isbra:
+-        sqrtmA = ket2dm(A)
+-    else:
+-        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
+-    if B.isket or B.isbra:
+-        sqrtmB = ket2dm(B)
+-    else:
+-        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
+-
+-    if sqrtmA.dims != sqrtmB.dims:
+-        raise TypeError("A and B do not have compatible dimensions.")
+-
+-    product = sqrtmA*sqrtmB
+-    eigs = product.eigenenergies(sparse=sparse, tol=tol)
+-    # np.maximum() is to avoid nan appearing sometimes due to numerical
+-    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
+-    # hellinger_dist(A, B) is called for A=B
+-    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
+-
+-
+-def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
+-          sparse=True):
+-    """
+-    Calculates the diamond norm of the quantum map q_oper, using
+-    the simplified semidefinite program of [Wat13]_.
+-
+-    The diamond norm SDP is solved by using CVXPY_.
+-
+-    Parameters
+-    ----------
+-    A : Qobj
+-        Quantum map to take the diamond norm of.
+-    B : Qobj or None
+-        If provided, the diamond norm of :math:`A - B` is taken instead.
+-    solver : str
+-        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
+-        latter tends to be significantly faster, but somewhat less accurate.
+-    verbose : bool
+-        If True, prints additional information about the solution.
+-    force_solve : bool
+-        If True, forces dnorm to solve the associated SDP, even if a special
+-        case is known for the argument.
+-    sparse : bool
+-        Whether to use sparse matrices in the convex optimisation problem.
+-        Default True.
+-
+-    Returns
+-    -------
+-    dn : float
+-        Diamond norm of q_oper.
+-
+-    Raises
+-    ------
+-    ImportError
+-        If CVXPY cannot be imported.
+-
+-    .. _cvxpy: https://www.cvxpy.org/en/latest/
+-    """
+-    if cvxpy is None:  # pragma: no cover
+-        raise ImportError("dnorm() requires CVXPY to be installed.")
+-
+-    # We follow the strategy of using Watrous' simpler semidefinite
+-    # program in its primal form. This is the same strategy used,
+-    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
+-    # QETLAB uses the dual problem.)
+-
+-    # Check if A and B are both unitaries. If so, then we can without
+-    # loss of generality choose B to be the identity by using the
+-    # unitary invariance of the diamond norm,
+-    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
+-    # Then, using the technique mentioned by each of Johnston and
+-    # da Silva,
+-    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
+-    # where \lambda_i(U) is the ith eigenvalue of U.
+-
+-    # There's a lot of conditions to check for this path.  Only check if they
+-    # aren't superoperators.  The difference of unitaries optimization is
+-    # currently only implemented for d == 2. Much of the code below is more
+-    # general, though, in anticipation of generalizing the optimization.
+-    if (
+-        not force_solve
+-        and B is not None
+-        and A.isoper and B.isoper
+-        and A.shape[0] == 2
+-    ):
+-        # Make an identity the same size as A and B to
+-        # compare against.
+-        I = qeye(A.dims[0])
+-        # Compare to B first, so that an error is raised
+-        # as soon as possible.
+-        Bd = B.dag()
+-        if (
+-            (B * Bd - I).norm() < 1e-6 and
+-            (A * A.dag() - I).norm() < 1e-6
+-        ):
+-            # Now we are on the fast path, so let's compute the
+-            # eigenvalues, then find the diameter of the smallest circle
+-            # containing all of them.
+-            #
+-            # For now, this is only implemented for dim = 2, such that
+-            # generalizing here will allow for generalizing the optimization.
+-            # A reasonable approach would probably be to use Welzl's algorithm
+-            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
+-            U = A * B.dag()
+-            eigs = U.eigenenergies()
+-            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
+-            return np.max(eig_distances)
+-
+-    # Force the input superoperator to be a Choi matrix.
+-    J = to_choi(A)
+-
+-    if B is not None:
+-        J -= to_choi(B)
+-
+-    # Watrous 2012 also points out that the diamond norm of Lambda
+-    # is the same as the completely-bounded operator-norm (∞-norm)
+-    # of the dual map of Lambda. We can evaluate that norm much more
+-    # easily if Lambda is completely positive, since then the largest
+-    # eigenvalue is the same as the largest singular value.
+-
+-    if not force_solve and J.iscp:
+-        S_dual = to_super(J.dual_chan())
+-        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
+-        op = vector_to_operator(S_dual * vec_eye)
+-        # The 2-norm was not implemented for sparse matrices as of the time
+-        # of this writing. Thus, we must yet again go dense.
+-        return la.norm(op.full(), 2)
+-
+-    # If we're still here, we need to actually solve the problem.
+-
+-    # Assume square...
+-    dim = np.prod(J.dims[0][0])
+-
+-    # The constraints only depend on the dimension, so
+-    # we can cache them efficiently.
+-    problem, Jr, Ji, *_ = dnorm_problem(dim)
+-
+-    # Load the parameters with the Choi matrix passed in.
+-    J_dat = _data.to('csr', J.data).as_scipy()
+-
+-    if not sparse:
+-        # The parameters and constraints only depend on the dimension, so
+-        # we can cache them efficiently.
+-        problem, Jr, Ji = dnorm_problem(dim)
+-
+-        # Load the parameters with the Choi matrix passed in.
+-        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
+-                                  J_dat.indptr),
+-                                 shape=J_dat.shape).toarray()
+-
+-        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
+-                                  J_dat.indptr),
+-                                 shape=J_dat.shape).toarray()
+-    else:
+-
+-        # The parameters do not depend solely on the dimension,
+-        # so we can not cache them efficiently.
+-        problem = dnorm_sparse_problem(dim, J_dat)
+-
+-    problem.solve(solver=solver, verbose=verbose)
+-
+-    return problem.value
+-
+-
+-def unitarity(oper):
+-    """
+-    Returns the unitarity of a quantum map, defined as the Frobenius norm
+-    of the unital block of that map's superoperator representation.
+-
+-    Parameters
+-    ----------
+-    oper : Qobj
+-        Quantum map under consideration.
+-
+-    Returns
+-    -------
+-    u : float
+-        Unitarity of ``oper``.
+-    """
+-    Eu = _to_superpauli(oper).full()[1:, 1:]
+-    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
++# -*- coding: utf-8 -*-
++
++"""
++This module contains a collection of functions for calculating metrics
++(distance measures) between states and operators.
++"""
++
++__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
++           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
++           'process_fidelity', 'unitarity', 'dnorm']
++
++import warnings
++
++import numpy as np
++from scipy import linalg as la
++import scipy.sparse as sp
++from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
++                           kraus_to_choi)
++from .superoperator import operator_to_vector, vector_to_operator
++from .operators import qeye
++from .states import ket2dm
++from .semidefinite import dnorm_problem, dnorm_sparse_problem
++from . import data as _data
++
++try:
++    import cvxpy
++except ImportError:
++    cvxpy = None
++
++
++def fidelity(A, B):
++    """
++    Calculates the fidelity (pseudo-metric) between two density matrices.
++    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
++
++    Parameters
++    ----------
++    A : qobj
++        Density matrix or state vector.
++    B : qobj
++        Density matrix or state vector with same dimensions as A.
++
++    Returns
++    -------
++    fid : float
++        Fidelity pseudo-metric between A and B.
++
++    Examples
++    --------
++    >>> x = fock_dm(5,3)
++    >>> y = coherent_dm(5,1)
++    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
++    """
++    if A.isket or A.isbra:
++        if B.isket or B.isbra:
++            # The fidelity for pure states reduces to the modulus of their
++            # inner product.
++            return np.abs(A.overlap(B))
++        # Take advantage of the fact that the density operator for A
++        # is a projector to avoid a sqrtm call.
++        sqrtmA = ket2dm(A)
++    else:
++        if B.isket or B.isbra:
++            # Swap the order so that we can take a more numerically
++            # stable square root of B.
++            return fidelity(B, A)
++        # If we made it here, both A and B are operators, so
++        # we have to take the sqrtm of one of them.
++        sqrtmA = A.sqrtm()
++
++    if sqrtmA.dims != B.dims:
++        raise TypeError('Density matrices do not have same dimensions.')
++
++    # We don't actually need the whole matrix here, just the trace
++    # of its square root, so let's just get its eigenenergies instead.
++    # We also truncate negative eigenvalues to avoid nan propagation;
++    # even for positive semidefinite matrices, small negative eigenvalues
++    # can be reported.
++    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
++    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
++
++
++def _hilbert_space_dims(oper):
++    """
++    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
++    of the output Hilbert space and the input Hilbert space.
++    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
++    - If oper is a list of Kraus operators, then
++     `oper[0].dims == [dims_out, dims_in]`.
++    - If oper is a superoperator with `oper.superrep == 'super'`:
++     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
++    - If oper is a superoperator with `oper.superrep == 'choi'`:
++     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
++    - If oper is a superoperator with `oper.superrep == 'chi', then
++      `dims_out == dims_in` and
++      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
++    :param oper: A quantum channel, represented by a unitary, a list of Kraus
++    operators, or a superoperator
++    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
++     of integers
++    """
++    if isinstance(oper, list):
++        return oper[0].dims
++    elif oper.type == 'oper':  # interpret as unitary quantum channel
++        return oper.dims
++    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
++        return [oper.dims[0][1], oper.dims[1][0]]
++    else:
++        raise TypeError('oper is not a valid quantum channel!')
++
++
++def _process_fidelity_to_id(oper):
++    """
++    Internal function returning the process fidelity of a quantum channel
++    to the identity quantum channel.
++    Parameters
++    ----------
++    oper : :class:`qutip.Qobj`/list
++        A unitary operator, or a superoperator in supermatrix, Choi or
++        chi-matrix form, or a list of Kraus operators
++    Returns
++    -------
++    fid : float
++    """
++    dims_out, dims_in = _hilbert_space_dims(oper)
++    if dims_out != dims_in:
++        raise TypeError('The process fidelity to identity is only defined '
++                        'for dimension preserving channels.')
++    d = np.prod(dims_in)
++    if isinstance(oper, list):  # oper is a list of Kraus operators
++        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
++    elif oper.type == 'oper':  # interpret as unitary
++        return np.abs(oper.tr()) ** 2 / d ** 2
++    elif oper.type == 'super':
++        if oper.superrep == 'chi':
++            return oper[0, 0].real / d ** 2
++        else:  # oper.superrep is either 'super' or 'choi':
++            return to_super(oper).tr().real / d ** 2
++
++
++def _kraus_or_qobj_to_choi(oper):
++    if isinstance(oper, list):
++        return kraus_to_choi(oper)
++    else:
++        return to_choi(oper)
++
++
++def process_fidelity(oper, target=None):
++    """
++    Returns the process fidelity of a quantum channel to the target
++    channel, or to the identity channel if no target is given.
++    The process fidelity between two channels is defined as the state
++    fidelity between their normalized Choi matrices.
++
++    Parameters
++    ----------
++    oper : :class:`qutip.Qobj`/list
++        A unitary operator, or a superoperator in supermatrix, Choi or
++        chi-matrix form, or a list of Kraus operators
++    target : :class:`qutip.Qobj`/list
++        A unitary operator, or a superoperator in supermatrix, Choi or
++        chi-matrix form, or a list of Kraus operators
++
++    Returns
++    -------
++    fid : float
++        Process fidelity between oper and target, or between oper and identity.
++
++    Notes
++    -----
++    Since Qutip 5.0, this function computes the process fidelity as defined
++    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
++    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
++    that is now implemented in
++    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
++    The definition of state fidelity that the process fidelity is based on
++    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
++    It is the square of the one implemented in
++    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
++    "Quantum Computation and Quantum Information"
++
++    """
++    if target is None:
++        return _process_fidelity_to_id(oper)
++
++    dims_out, dims_in = _hilbert_space_dims(oper)
++    if dims_out != dims_in:
++        raise NotImplementedError('Process fidelity only implemented for '
++                                  'dimension-preserving operators.')
++    dims_out_target, dims_in_target = _hilbert_space_dims(target)
++    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
++        raise TypeError('Dimensions of oper and target do not match')
++
++    if not isinstance(target, list) and target.type == 'oper':
++        # interpret target as unitary.
++        if isinstance(oper, list):  # oper is a list of Kraus operators
++            return _process_fidelity_to_id([k * target.dag() for k in oper])
++        elif oper.type == 'oper':
++            return _process_fidelity_to_id(oper*target.dag())
++        elif oper.type == 'super':
++            oper_super = to_super(oper)
++            target_dag_super = to_super(target.dag())
++            return _process_fidelity_to_id(oper_super * target_dag_super)
++    else:  # target is a list of Kraus operators or a superoperator
++        if not isinstance(oper, list) and oper.type == 'oper':
++            return process_fidelity(target, oper)  # reverse order
++        oper_choi = _kraus_or_qobj_to_choi(oper)
++        target_choi = _kraus_or_qobj_to_choi(target)
++        d = np.prod(dims_in)
++        return (fidelity(oper_choi, target_choi)/d)**2
++
++
++def average_gate_fidelity(oper, target=None):
++    """
++    Returns the average gate fidelity of a quantum channel to the target
++    channel, or to the identity channel if no target is given.
++
++    Parameters
++    ----------
++    oper : :class:`qutip.Qobj`/list
++        A unitary operator, or a superoperator in supermatrix, Choi or
++        chi-matrix form, or a list of Kraus operators
++    target : :class:`qutip.Qobj`
++        A unitary operator
++
++    Returns
++    -------
++    fid : float
++        Average gate fidelity between oper and target,
++        or between oper and identity.
++
++    Notes
++    -----
++    The average gate fidelity is defined for example in:
++    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
++    The definition of state fidelity that the average gate fidelity is based on
++    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
++    It is the square of the fidelity implemented in
++    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
++    "Quantum Computation and Quantum Information"
++
++    """
++    dims_out, dims_in = _hilbert_space_dims(oper)
++    if not (target is None or target.type == 'oper'):
++        raise TypeError(
++            'target must be None or a Qobj representing a unitary.')
++
++    d = np.prod(dims_in)
++    return (d * process_fidelity(oper, target) + 1) / (d + 1)
++
++
++def tracedist(A, B, sparse=False, tol=0):
++    """
++    Calculates the trace distance between two density matrices..
++    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
++
++    Parameters
++    ----------!=
++    A : qobj
++        Density matrix or state vector.
++    B : qobj
++        Density matrix or state vector with same dimensions as A.
++    tol : float
++        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
++    sparse : {False, True}
++        Use sparse eigensolver.
++
++    Returns
++    -------
++    tracedist : float
++        Trace distance between A and B.
++
++    Examples
++    --------
++    >>> x=fock_dm(5,3)
++    >>> y=coherent_dm(5,1)
++    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
++    """
++    if A.isket or A.isbra:
++        A = A.proj()
++    if B.isket or B.isbra:
++        B = B.proj()
++    if A.dims != B.dims:
++        raise TypeError("A and B do not have same dimensions.")
++    diff = A - B
++    diff = diff.dag() * diff
++    vals = diff.eigenenergies(sparse=sparse, tol=tol)
++    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
++
++
++def hilbert_dist(A, B):
++    """
++    Returns the Hilbert-Schmidt distance between two density matrices A & B.
++
++    Parameters
++    ----------
++    A : qobj
++        Density matrix or state vector.
++    B : qobj
++        Density matrix or state vector with same dimensions as A.
++
++    Returns
++    -------
++    dist : float
++        Hilbert-Schmidt distance between density matrices.
++
++    Notes
++    -----
++    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
++
++    """
++    if A.isket or A.isbra:
++        A = A.proj()
++    if B.isket or B.isbra:
++        B = B.proj()
++    if A.dims != B.dims:
++        raise TypeError('A and B do not have same dimensions.')
++    return ((A - B)**2).tr()
++
++
++def bures_dist(A, B):
++    """
++    Returns the Bures distance between two density matrices A & B.
++
++    The Bures distance ranges from 0, for states with unit fidelity,
++    to sqrt(2).
++
++    Parameters
++    ----------
++    A : qobj
++        Density matrix or state vector.
++    B : qobj
++        Density matrix or state vector with same dimensions as A.
++
++    Returns
++    -------
++    dist : float
++        Bures distance between density matrices.
++    """
++    if A.isket or A.isbra:
++        A = A.proj()
++    if B.isket or B.isbra:
++        B = B.proj()
++    if A.dims != B.dims:
++        raise TypeError('A and B do not have same dimensions.')
++    dist = np.sqrt(2 * (1 - fidelity(A, B)))
++    return dist
++
++
++def bures_angle(A, B):
++    """
++    Returns the Bures Angle between two density matrices A & B.
++
++    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
++
++    Parameters
++    ----------
++    A : qobj
++        Density matrix or state vector.
++    B : qobj
++        Density matrix or state vector with same dimensions as A.
++
++    Returns
++    -------
++    angle : float
++        Bures angle between density matrices.
++    """
++    if A.isket or A.isbra:
++        A = A.proj()
++    if B.isket or B.isbra:
++        B = B.proj()
++    if A.dims != B.dims:
++        raise TypeError('A and B do not have same dimensions.')
++    return np.arccos(fidelity(A, B))
++
++
++def hellinger_dist(A, B, sparse=False, tol=0):
++    """
++    Calculates the quantum Hellinger distance between two density matrices.
++
++    Formula:
++    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
++
++    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
++    measures of quantum correlations with Bures and Hellinger distances"
++    arXiv:1611.03449
++
++    Parameters
++    ----------
++    A : :class:`qutip.Qobj`
++        Density matrix or state vector.
++    B : :class:`qutip.Qobj`
++        Density matrix or state vector with same dimensions as A.
++    tol : float
++        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
++    sparse : {False, True}
++        Use sparse eigensolver.
++
++    Returns
++    -------
++    hellinger_dist : float
++        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
++
++    Examples
++    --------
++    >>> x=fock_dm(5,3)
++    >>> y=coherent_dm(5,1)
++    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
++    """
++    if A.isket or A.isbra:
++        sqrtmA = ket2dm(A)
++    else:
++        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
++    if B.isket or B.isbra:
++        sqrtmB = ket2dm(B)
++    else:
++        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
++
++    if sqrtmA.dims != sqrtmB.dims:
++        raise TypeError("A and B do not have compatible dimensions.")
++
++    product = sqrtmA*sqrtmB
++    eigs = product.eigenenergies(sparse=sparse, tol=tol)
++    # np.maximum() is to avoid nan appearing sometimes due to numerical
++    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
++    # hellinger_dist(A, B) is called for A=B
++    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
++
++
++def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
++          sparse=True):
++    """
++    Calculates the diamond norm of the quantum map q_oper, using
++    the simplified semidefinite program of [Wat13]_.
++
++    The diamond norm SDP is solved by using CVXPY_.
++
++    Parameters
++    ----------
++    A : Qobj
++        Quantum map to take the diamond norm of.
++    B : Qobj or None
++        If provided, the diamond norm of :math:`A - B` is taken instead.
++    solver : str
++        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
++        latter tends to be significantly faster, but somewhat less accurate.
++    verbose : bool
++        If True, prints additional information about the solution.
++    force_solve : bool
++        If True, forces dnorm to solve the associated SDP, even if a special
++        case is known for the argument.
++    sparse : bool
++        Whether to use sparse matrices in the convex optimisation problem.
++        Default True.
++
++    Returns
++    -------
++    dn : float
++        Diamond norm of q_oper.
++
++    Raises
++    ------
++    ImportError
++        If CVXPY cannot be imported.
++
++    .. _cvxpy: https://www.cvxpy.org/en/latest/
++    """
++    if cvxpy is None:  # pragma: no cover
++        raise ImportError("dnorm() requires CVXPY to be installed.")
++
++    # We follow the strategy of using Watrous' simpler semidefinite
++    # program in its primal form. This is the same strategy used,
++    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
++    # QETLAB uses the dual problem.)
++
++    # Check if A and B are both unitaries. If so, then we can without
++    # loss of generality choose B to be the identity by using the
++    # unitary invariance of the diamond norm,
++    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
++    # Then, using the technique mentioned by each of Johnston and
++    # da Silva,
++    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
++    # where \lambda_i(U) is the ith eigenvalue of U.
++
++    # There's a lot of conditions to check for this path.  Only check if they
++    # aren't superoperators.  The difference of unitaries optimization is
++    # currently only implemented for d == 2. Much of the code below is more
++    # general, though, in anticipation of generalizing the optimization.
++    if (
++        not force_solve
++        and B is not None
++        and A.isoper and B.isoper
++        and A.shape[0] == 2
++    ):
++        # Make an identity the same size as A and B to
++        # compare against.
++        I = qeye(A.dims[0])
++        # Compare to B first, so that an error is raised
++        # as soon as possible.
++        Bd = B.dag()
++        if (
++            (B * Bd - I).norm() < 1e-6 and
++            (A * A.dag() - I).norm() < 1e-6
++        ):
++            # Now we are on the fast path, so let's compute the
++            # eigenvalues, then find the diameter of the smallest circle
++            # containing all of them.
++            #
++            # For now, this is only implemented for dim = 2, such that
++            # generalizing here will allow for generalizing the optimization.
++            # A reasonable approach would probably be to use Welzl's algorithm
++            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
++            U = A * B.dag()
++            eigs = U.eigenenergies()
++            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
++            return np.max(eig_distances)
++
++    # Force the input superoperator to be a Choi matrix.
++    J = to_choi(A)
++
++    if B is not None:
++        J -= to_choi(B)
++
++    # Watrous 2012 also points out that the diamond norm of Lambda
++    # is the same as the completely-bounded operator-norm (∞-norm)
++    # of the dual map of Lambda. We can evaluate that norm much more
++    # easily if Lambda is completely positive, since then the largest
++    # eigenvalue is the same as the largest singular value.
++
++    if not force_solve and J.iscp:
++        S_dual = to_super(J.dual_chan())
++        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
++        op = vector_to_operator(S_dual * vec_eye)
++        # The 2-norm was not implemented for sparse matrices as of the time
++        # of this writing. Thus, we must yet again go dense.
++        return la.norm(op.full(), 2)
++
++    # If we're still here, we need to actually solve the problem.
++
++    # Assume square...
++    dim = np.prod(J.dims[0][0])
++
++    # The constraints only depend on the dimension, so
++    # we can cache them efficiently.
++    problem, Jr, Ji, *_ = dnorm_problem(dim)
++
++    # Load the parameters with the Choi matrix passed in.
++    J_dat = _data.to('csr', J.data).as_scipy()
++
++    if not sparse:
++        # The parameters and constraints only depend on the dimension, so
++        # we can cache them efficiently.
++        problem, Jr, Ji = dnorm_problem(dim)
++
++        # Load the parameters with the Choi matrix passed in.
++        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
++                                  J_dat.indptr),
++                                 shape=J_dat.shape).toarray()
++
++        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
++                                  J_dat.indptr),
++                                 shape=J_dat.shape).toarray()
++    else:
++
++        # The parameters do not depend solely on the dimension,
++        # so we can not cache them efficiently.
++        problem = dnorm_sparse_problem(dim, J_dat)
++
++    problem.solve(solver=solver, verbose=verbose)
++
++    return problem.value
++
++
++def unitarity(oper):
++    """
++    Returns the unitarity of a quantum map, defined as the Frobenius norm
++    of the unital block of that map's superoperator representation.
++
++    Parameters
++    ----------
++    oper : Qobj
++        Quantum map under consideration.
++
++    Returns
++    -------
++    u : float
++        Unitarity of ``oper``.
++    """
++    Eu = _to_superpauli(oper).full()[1:, 1:]
++    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
+diff --git a/qutip/core/operators.py b/qutip/core/operators.py
+index f2921882..f3de7e22 100644
+--- a/qutip/core/operators.py
++++ b/qutip/core/operators.py
+@@ -1,1073 +1,1073 @@
+-"""
+-This module contains functions for generating Qobj representation of a variety
+-of commonly occuring quantum operators.
+-"""
+-
+-__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
+-           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
+-           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
+-           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
+-           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
+-           'enr_identity', 'charge', 'tunneling', 'qft']
+-
+-import numbers
+-
+-import numpy as np
+-import scipy.sparse
+-
+-from . import data as _data
+-from .qobj import Qobj
+-from .dimensions import flatten
+-from .. import settings
+-
+-
+-def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
+-           dtype=None):
+-    """
+-    Constructs an operator from an array of diagonals.
+-
+-    Parameters
+-    ----------
+-    diagonals : sequence of array_like
+-        Array of elements to place along the selected diagonals.
+-
+-    offsets : sequence of ints, optional
+-        Sequence for diagonals to be set:
+-            - k=0 main diagonal
+-            - k>0 kth upper diagonal
+-            - k<0 kth lower diagonal
+-
+-    dims : list, optional
+-        Dimensions for operator
+-
+-    shape : list, tuple, optional
+-        Shape of operator.  If omitted, a square operator large enough
+-        to contain the diagonals is generated.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Examples
+-    --------
+-    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
+-    Quantum object: dims = [[4], [4]], \
+-shape = [4, 4], type = oper, isherm = False
+-    Qobj data =
+-    [[ 0.          1.          0.          0.        ]
+-     [ 0.          0.          1.41421356  0.        ]
+-     [ 0.          0.          0.          1.73205081]
+-     [ 0.          0.          0.          0.        ]]
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    offsets = [0] if offsets is None else offsets
+-    data = _data.diag[dtype](diagonals, offsets, shape)
+-    return Qobj(data, dims=dims, type='oper', copy=False)
+-
+-
+-def jmat(j, which=None, *, dtype=None):
+-    """Higher-order spin operators:
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operator
+-
+-    which : str
+-        Which operator to return 'x','y','z','+','-'.
+-        If no args given, then output is ['x','y','z']
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    jmat : Qobj or tuple of Qobj
+-        ``qobj`` for requested spin operator(s).
+-
+-
+-    Examples
+-    --------
+-    >>> jmat(1) # doctest: +SKIP
+-    [ Quantum object: dims = [[3], [3]], \
+-shape = [3, 3], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.          0.70710678  0.        ]
+-     [ 0.70710678  0.          0.70710678]
+-     [ 0.          0.70710678  0.        ]]
+-     Quantum object: dims = [[3], [3]], \
+-shape = [3, 3], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
+-     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
+-     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
+-     Quantum object: dims = [[3], [3]], \
+-shape = [3, 3], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 1.  0.  0.]
+-     [ 0.  0.  0.]
+-     [ 0.  0. -1.]]]
+-
+-    Notes
+-    -----
+-    If no 'args' input, then returns array of ['x','y','z'] operators.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    if int(2 * j) != 2 * j or j < 0:
+-        raise ValueError('j must be a non-negative integer or half-integer')
+-
+-    if not which:
+-        return (
+-            jmat(j, 'x', dtype=dtype),
+-            jmat(j, 'y', dtype=dtype),
+-            jmat(j, 'z', dtype=dtype)
+-        )
+-
+-    dims = [[int(2*j + 1)]]*2
+-    if which == '+':
+-        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
+-                    isherm=False, isunitary=False, copy=False)
+-    if which == '-':
+-        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
+-                    isherm=False, isunitary=False, copy=False)
+-    if which == 'x':
+-        A =  _jplus(j, dtype=dtype)
+-        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
+-                    isherm=True, isunitary=False, copy=False) * 0.5
+-    if which == 'y':
+-        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
+-        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
+-                    isherm=True, isunitary=False, copy=False)
+-    if which == 'z':
+-        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
+-                    isherm=True, isunitary=False, copy=False)
+-    raise ValueError('Invalid spin operator: ' + which)
+-
+-
+-def _jplus(j, *, dtype=None):
+-    """
+-    Internal functions for generating the data representing the J-plus
+-    operator.
+-    """
+-    m = np.arange(j, -j - 1, -1, dtype=complex)
+-    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
+-    return _data.diag[dtype](data, 1)
+-
+-
+-def _jz(j, *, dtype=None):
+-    """
+-    Internal functions for generating the data representing the J-z operator.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    N = int(2*j + 1)
+-    data = np.array([j-k for k in range(N)], dtype=complex)
+-    return _data.diag[dtype](data, 0)
+-
+-
+-#
+-# Spin j operators:
+-#
+-def spin_Jx(j, *, dtype=None):
+-    """Spin-j x operator
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operator
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    op : Qobj
+-        ``qobj`` representation of the operator.
+-
+-    """
+-    return jmat(j, 'x', dtype=dtype)
+-
+-
+-def spin_Jy(j, *, dtype=None):
+-    """Spin-j y operator
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operator
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    op : Qobj
+-        ``qobj`` representation of the operator.
+-
+-    """
+-    return jmat(j, 'y', dtype=dtype)
+-
+-
+-def spin_Jz(j, *, dtype=None):
+-    """Spin-j z operator
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operator
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    op : Qobj
+-        ``qobj`` representation of the operator.
+-
+-    """
+-    return jmat(j, 'z', dtype=dtype)
+-
+-
+-def spin_Jm(j, *, dtype=None):
+-    """Spin-j annihilation operator
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operator
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    op : Qobj
+-        ``qobj`` representation of the operator.
+-
+-    """
+-    return jmat(j, '-', dtype=dtype)
+-
+-
+-def spin_Jp(j, *, dtype=None):
+-    """Spin-j creation operator
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operator
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    op : Qobj
+-        ``qobj`` representation of the operator.
+-
+-    """
+-    return jmat(j, '+', dtype=dtype)
+-
+-
+-def spin_J_set(j, *, dtype=None):
+-    """Set of spin-j operators (x, y, z)
+-
+-    Parameters
+-    ----------
+-    j : float
+-        Spin of operators
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    list : list of Qobj
+-        list of ``qobj`` representating of the spin operator.
+-
+-    """
+-    return jmat(j, dtype=dtype)
+-
+-
+-# Pauli spin-1/2 operators.
+-#
+-# These are so common in quantum information that we want them to be
+-# near-instantaneous to initialise, so we cache them at package import, and
+-# just return copies when someone requests one.
+-_SIGMAP = jmat(0.5, '+')
+-_SIGMAM = jmat(0.5, '-')
+-_SIGMAX = 2 * jmat(0.5, 'x')
+-_SIGMAY = 2 * jmat(0.5, 'y')
+-_SIGMAZ = 2 * jmat(0.5, 'z')
+-
+-
+-def sigmap():
+-    """Creation operator for Pauli spins.
+-
+-    Examples
+-    --------
+-    >>> sigmap() # doctest: +SKIP
+-    Quantum object: dims = [[2], [2]], \
+-shape = [2, 2], type = oper, isHerm = False
+-    Qobj data =
+-    [[ 0.  1.]
+-     [ 0.  0.]]
+-
+-    """
+-    return _SIGMAP.copy()
+-
+-
+-def sigmam():
+-    """Annihilation operator for Pauli spins.
+-
+-    Examples
+-    --------
+-    >>> sigmam() # doctest: +SKIP
+-    Quantum object: dims = [[2], [2]], \
+-shape = [2, 2], type = oper, isHerm = False
+-    Qobj data =
+-    [[ 0.  0.]
+-     [ 1.  0.]]
+-
+-    """
+-    return _SIGMAM.copy()
+-
+-
+-def sigmax():
+-    """Pauli spin 1/2 sigma-x operator
+-
+-    Examples
+-    --------
+-    >>> sigmax() # doctest: +SKIP
+-    Quantum object: dims = [[2], [2]], \
+-shape = [2, 2], type = oper, isHerm = False
+-    Qobj data =
+-    [[ 0.  1.]
+-     [ 1.  0.]]
+-
+-    """
+-    return _SIGMAX.copy()
+-
+-
+-def sigmay():
+-    """Pauli spin 1/2 sigma-y operator.
+-
+-    Examples
+-    --------
+-    >>> sigmay() # doctest: +SKIP
+-    Quantum object: dims = [[2], [2]], \
+-shape = [2, 2], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.+0.j  0.-1.j]
+-     [ 0.+1.j  0.+0.j]]
+-
+-    """
+-    return _SIGMAY.copy()
+-
+-
+-def sigmaz():
+-    """Pauli spin 1/2 sigma-z operator.
+-
+-    Examples
+-    --------
+-    >>> sigmaz() # doctest: +SKIP
+-    Quantum object: dims = [[2], [2]], \
+-shape = [2, 2], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 1.  0.]
+-     [ 0. -1.]]
+-
+-    """
+-    return _SIGMAZ.copy()
+-
+-
+-def destroy(N, offset=0, *, dtype=None):
+-    """
+-    Destruction (lowering) operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Dimension of Hilbert space.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Qobj for lowering operator.
+-
+-    Examples
+-    --------
+-    >>> destroy(4) # doctest: +SKIP
+-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
+-    Qobj data =
+-    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+-     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
+-     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
+-     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
+-        raise ValueError("Hilbert space dimension must be integer value")
+-    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
+-    return qdiags(data, 1, dtype=dtype)
+-
+-
+-def create(N, offset=0, *, dtype=None):
+-    """
+-    Creation (raising) operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Dimension of Hilbert space.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Qobj for raising operator.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    Examples
+-    --------
+-    >>> create(4) # doctest: +SKIP
+-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
+-    Qobj data =
+-    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+-     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+-     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
+-     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
+-        raise ValueError("Hilbert space dimension must be integer value")
+-    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
+-    return qdiags(data, -1, dtype=dtype)
+-
+-
+-def _implicit_tensor_dimensions(dimensions):
+-    """
+-    Total flattened size and operator dimensions for operator creation routines
+-    that automatically perform tensor products.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        First dimension of an operator which can create an implicit tensor
+-        product.  If the type is `int`, it is promoted first to `[dimensions]`.
+-        From there, it should be one of the two-elements `dims` parameter of a
+-        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
+-        products.
+-
+-    Returns
+-    -------
+-    size : int
+-        Dimension of backing matrix required to represent operator.
+-    dimensions : list
+-        Dimension list in the form required by ``Qobj`` creation.
+-    """
+-    if not isinstance(dimensions, list):
+-        dimensions = [dimensions]
+-    flat = flatten(dimensions)
+-    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
+-        raise ValueError("All dimensions must be integers >= 0")
+-    return np.prod(flat), [dimensions, dimensions]
+-
+-
+-def qzero(dimensions, *, dtype=None):
+-    """
+-    Zero operator.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    qzero : qobj
+-        Zero operator Qobj.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    size, dimensions = _implicit_tensor_dimensions(dimensions)
+-    # A sparse matrix with no data is equal to a zero matrix.
+-    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
+-    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
+-                isherm=True, isunitary=False, copy=False)
+-
+-
+-def qeye(dimensions, *, dtype=None):
+-    """
+-    Identity operator.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Identity operator Qobj.
+-
+-    Examples
+-    --------
+-    >>> qeye(3) # doctest: +SKIP
+-    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
+-isherm = True
+-    Qobj data =
+-    [[ 1.  0.  0.]
+-     [ 0.  1.  0.]
+-     [ 0.  0.  1.]]
+-    >>> qeye([2,2]) # doctest: +SKIP
+-    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
+-isherm = True
+-    Qobj data =
+-    [[1. 0. 0. 0.]
+-     [0. 1. 0. 0.]
+-     [0. 0. 1. 0.]
+-     [0. 0. 0. 1.]]
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    size, dimensions = _implicit_tensor_dimensions(dimensions)
+-    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
+-    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
+-                isherm=True, isunitary=True, copy=False)
+-
+-
+-# Name alias.
+-identity = qeye
+-
+-
+-def position(N, offset=0, *, dtype=None):
+-    """
+-    Position operator x=1/sqrt(2)*(a+a.dag())
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of Fock states in Hilbert space.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Position operator as Qobj.
+-    """
+-    a = destroy(N, offset=offset, dtype=dtype)
+-    position = np.sqrt(0.5) * (a + a.dag())
+-    position.isherm = True
+-    return position
+-
+-
+-def momentum(N, offset=0, *, dtype=None):
+-    """
+-    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of Fock states in Hilbert space.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Momentum operator as Qobj.
+-    """
+-    a = destroy(N, offset=offset, dtype=dtype)
+-    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
+-    momentum.isherm = True
+-    return momentum
+-
+-
+-def num(N, offset=0, *, dtype=None):
+-    """
+-    Quantum object for number operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        The dimension of the Hilbert space.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper: qobj
+-        Qobj for number operator.
+-
+-    Examples
+-    --------
+-    >>> num(4) # doctest: +SKIP
+-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
+-    Qobj data =
+-    [[0 0 0 0]
+-     [0 1 0 0]
+-     [0 0 2 0]
+-     [0 0 0 3]]
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    data = np.arange(offset, offset + N, dtype=complex)
+-    return qdiags(data, 0, dtype=dtype)
+-
+-
+-def squeeze(N, z, offset=0, *, dtype=None):
+-    """Single-mode squeezing operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Dimension of hilbert space.
+-
+-    z : float/complex
+-        Squeezing parameter.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : :class:`qutip.Qobj`
+-        Squeezing operator.
+-
+-
+-    Examples
+-    --------
+-    >>> squeeze(4, 0.25) # doctest: +SKIP
+-    Quantum object: dims = [[4], [4]], \
+-shape = [4, 4], type = oper, isHerm = False
+-    Qobj data =
+-    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
+-     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
+-     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
+-     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
+-
+-    """
+-    asq = destroy(N, offset=offset, dtype=dtype) ** 2
+-    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
+-    return op.expm(dtype=dtype)
+-
+-
+-def squeezing(a1, a2, z):
+-    """Generalized squeezing operator.
+-
+-    .. math::
+-
+-        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
+-        - za_1^\\dagger a_2^\\dagger\\right)\\right)
+-
+-    Parameters
+-    ----------
+-    a1 : :class:`qutip.Qobj`
+-        Operator 1.
+-
+-    a2 : :class:`qutip.Qobj`
+-        Operator 2.
+-
+-    z : float/complex
+-        Squeezing parameter.
+-
+-    Returns
+-    -------
+-    oper : :class:`qutip.Qobj`
+-        Squeezing operator.
+-
+-    """
+-    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
+-    return b.expm()
+-
+-
+-def displace(N, alpha, offset=0, *, dtype=None):
+-    """Single-mode displacement operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Dimension of Hilbert space.
+-
+-    alpha : float/complex
+-        Displacement amplitude.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the operator.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Displacement operator.
+-
+-    Examples
+-    --------
+-    >>> displace(4,0.25) # doctest: +SKIP
+-    Quantum object: dims = [[4], [4]], \
+-shape = [4, 4], type = oper, isHerm = False
+-    Qobj data =
+-    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
+-     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
+-     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
+-     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    a = destroy(N, offset=offset)
+-    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
+-
+-
+-def commutator(A, B, kind="normal"):
+-    """
+-    Return the commutator of kind `kind` (normal, anti) of the
+-    two operators A and B.
+-    """
+-    if kind == 'normal':
+-        return A @ B - B @ A
+-
+-    elif kind == 'anti':
+-        return A @ B + B @ A
+-
+-    else:
+-        raise TypeError("Unknown commutator kind '%s'" % kind)
+-
+-
+-def qutrit_ops(*, dtype=None):
+-    """
+-    Operators for a three level system (qutrit).
+-
+-    Parameters
+-    ----------
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    opers: array
+-        `array` of qutrit operators.
+-
+-    """
+-    from .states import qutrit_basis
+-
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    out = np.empty((6,), dtype=object)
+-    one, two, three = qutrit_basis(dtype=dtype)
+-    out[0] = one * one.dag()
+-    out[1] = two * two.dag()
+-    out[2] = three * three.dag()
+-    out[3] = one * two.dag()
+-    out[4] = two * three.dag()
+-    out[5] = three * one.dag()
+-    return out
+-
+-
+-def phase(N, phi0=0, *, dtype=None):
+-    """
+-    Single-mode Pegg-Barnett phase operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of basis states in Hilbert space.
+-
+-    phi0 : float
+-        Reference phase.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Phase operator with respect to reference phase.
+-
+-    Notes
+-    -----
+-    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
+-    n = np.arange(N)[:, np.newaxis]
+-    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
+-                       for kk in phim])
+-    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
+-    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
+-
+-
+-def enr_destroy(dims, excitations, *, dtype=None):
+-    """
+-    Generate annilation operators for modes in a excitation-number-restricted
+-    state space. For example, consider a system consisting of 4 modes, each
+-    with 5 states. The total hilbert space size is 5**4 = 625. If we are
+-    only interested in states that contain up to 2 excitations, we only need
+-    to include states such as
+-
+-        (0, 0, 0, 0)
+-        (0, 0, 0, 1)
+-        (0, 0, 0, 2)
+-        (0, 0, 1, 0)
+-        (0, 0, 1, 1)
+-        (0, 0, 2, 0)
+-        ...
+-
+-    This function creates annihilation operators for the 4 modes that act
+-    within this state space:
+-
+-        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
+-
+-    From this point onwards, the annihiltion operators a1, ..., a4 can be
+-    used to setup a Hamiltonian, collapse operators and expectation-value
+-    operators, etc., following the usual pattern.
+-
+-    Parameters
+-    ----------
+-    dims : list
+-        A list of the dimensions of each subsystem of a composite quantum
+-        system.
+-
+-    excitations : integer
+-        The maximum number of excitations that are to be included in the
+-        state space.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    a_ops : list of qobj
+-        A list of annihilation operators for each mode in the composite
+-        quantum system described by dims.
+-    """
+-    from .states import enr_state_dictionaries
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-
+-    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
+-
+-    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
+-             for _ in dims]
+-
+-    for n1, state1 in enumerate(idx2state):
+-        for idx, s in enumerate(state1):
+-            # if s > 0, the annihilation operator of mode idx has a non-zero
+-            # entry with one less excitation in mode idx in the final state
+-            if s > 0:
+-                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
+-                n2 = state2idx[state2]
+-                a_ops[idx][n2, n1] = np.sqrt(s)
+-
+-    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
+-
+-
+-def enr_identity(dims, excitations, *, dtype=None):
+-    """
+-    Generate the identity operator for the excitation-number restricted
+-    state space defined by the `dims` and `exciations` arguments. See the
+-    docstring for enr_fock for a more detailed description of these arguments.
+-
+-    Parameters
+-    ----------
+-    dims : list
+-        A list of the dimensions of each subsystem of a composite quantum
+-        system.
+-
+-    excitations : integer
+-        The maximum number of excitations that are to be included in the
+-        state space.
+-
+-    state : list of integers
+-        The state in the number basis representation.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    op : Qobj
+-        A Qobj instance that represent the identity operator in the
+-        exication-number-restricted state space defined by `dims` and
+-        `exciations`.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    from .states import enr_state_dictionaries
+-    nstates, _, _ = enr_state_dictionaries(dims, excitations)
+-    return Qobj(_data.identity[dtype](nstates),
+-                dims=[dims, dims],
+-                type='oper',
+-                isherm=True,
+-                isunitary=True,
+-                copy=False)
+-
+-
+-def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
+-    """
+-    Generate the diagonal charge operator over charge states
+-    from Nmin to Nmax.
+-
+-    Parameters
+-    ----------
+-    Nmax : int
+-        Maximum charge state to consider.
+-
+-    Nmin : int (default = -Nmax)
+-        Lowest charge state to consider.
+-
+-    frac : float (default = 1)
+-        Specify fractional charge if needed.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    C : Qobj
+-        Charge operator over [Nmin, Nmax].
+-
+-    Notes
+-    -----
+-    .. versionadded:: 3.2
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    if Nmin is None:
+-        Nmin = -Nmax
+-    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
+-    out = qdiags(diag, 0, dtype=dtype)
+-    out.isherm = True
+-    return out
+-
+-
+-def tunneling(N, m=1, *, dtype=None):
+-    r"""
+-    Tunneling operator with elements of the form
+-    :math:`\\sum |N><N+m| + |N+m><N|`.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of basis states in Hilbert space.
+-
+-    m : int (default = 1)
+-        Number of excitations in tunneling event.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    T : Qobj
+-        Tunneling operator.
+-
+-    Notes
+-    -----
+-    .. versionadded:: 3.2
+-
+-    """
+-    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
+-    T = qdiags(diags, [m, -m], dtype=dtype)
+-    T.isherm = True
+-    return T
+-
+-
+-def qft(dimensions, *, dtype="dense"):
+-    """
+-    Quantum Fourier Transform operator.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.
+-
+-    dtype : str or type, [keyword only] [optional]
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    QFT: qobj
+-        Quantum Fourier transform operator.
+-
+-    """
+-    N2, dimensions = _implicit_tensor_dimensions(dimensions)
+-
+-    phase = 2.0j * np.pi / N2
+-    arr = np.arange(N2)
+-    L, M = np.meshgrid(arr, arr)
+-    data = np.exp(phase * (L * M)) / np.sqrt(N2)
+-    return Qobj(data, dims=dimensions).to(dtype)
++"""
++This module contains functions for generating Qobj representation of a variety
++of commonly occuring quantum operators.
++"""
++
++__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
++           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
++           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
++           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
++           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
++           'enr_identity', 'charge', 'tunneling', 'qft']
++
++import numbers
++
++import numpy as np
++import scipy.sparse
++
++from . import data as _data
++from .qobj import Qobj
++from .dimensions import flatten
++from .. import settings
++
++
++def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
++           dtype=None):
++    """
++    Constructs an operator from an array of diagonals.
++
++    Parameters
++    ----------
++    diagonals : sequence of array_like
++        Array of elements to place along the selected diagonals.
++
++    offsets : sequence of ints, optional
++        Sequence for diagonals to be set:
++            - k=0 main diagonal
++            - k>0 kth upper diagonal
++            - k<0 kth lower diagonal
++
++    dims : list, optional
++        Dimensions for operator
++
++    shape : list, tuple, optional
++        Shape of operator.  If omitted, a square operator large enough
++        to contain the diagonals is generated.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Examples
++    --------
++    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
++    Quantum object: dims = [[4], [4]], \
++shape = [4, 4], type = oper, isherm = False
++    Qobj data =
++    [[ 0.          1.          0.          0.        ]
++     [ 0.          0.          1.41421356  0.        ]
++     [ 0.          0.          0.          1.73205081]
++     [ 0.          0.          0.          0.        ]]
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    offsets = [0] if offsets is None else offsets
++    data = _data.diag[dtype](diagonals, offsets, shape)
++    return Qobj(data, dims=dims, type='oper', copy=False)
++
++
++def jmat(j, which=None, *, dtype=None):
++    """Higher-order spin operators:
++
++    Parameters
++    ----------
++    j : float
++        Spin of operator
++
++    which : str
++        Which operator to return 'x','y','z','+','-'.
++        If no args given, then output is ['x','y','z']
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    jmat : Qobj or tuple of Qobj
++        ``qobj`` for requested spin operator(s).
++
++
++    Examples
++    --------
++    >>> jmat(1) # doctest: +SKIP
++    [ Quantum object: dims = [[3], [3]], \
++shape = [3, 3], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.          0.70710678  0.        ]
++     [ 0.70710678  0.          0.70710678]
++     [ 0.          0.70710678  0.        ]]
++     Quantum object: dims = [[3], [3]], \
++shape = [3, 3], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
++     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
++     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
++     Quantum object: dims = [[3], [3]], \
++shape = [3, 3], type = oper, isHerm = True
++    Qobj data =
++    [[ 1.  0.  0.]
++     [ 0.  0.  0.]
++     [ 0.  0. -1.]]]
++
++    Notes
++    -----
++    If no 'args' input, then returns array of ['x','y','z'] operators.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    if int(2 * j) != 2 * j or j < 0:
++        raise ValueError('j must be a non-negative integer or half-integer')
++
++    if not which:
++        return (
++            jmat(j, 'x', dtype=dtype),
++            jmat(j, 'y', dtype=dtype),
++            jmat(j, 'z', dtype=dtype)
++        )
++
++    dims = [[int(2*j + 1)]]*2
++    if which == '+':
++        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
++                    isherm=False, isunitary=False, copy=False)
++    if which == '-':
++        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
++                    isherm=False, isunitary=False, copy=False)
++    if which == 'x':
++        A =  _jplus(j, dtype=dtype)
++        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
++                    isherm=True, isunitary=False, copy=False) * 0.5
++    if which == 'y':
++        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
++        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
++                    isherm=True, isunitary=False, copy=False)
++    if which == 'z':
++        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
++                    isherm=True, isunitary=False, copy=False)
++    raise ValueError('Invalid spin operator: ' + which)
++
++
++def _jplus(j, *, dtype=None):
++    """
++    Internal functions for generating the data representing the J-plus
++    operator.
++    """
++    m = np.arange(j, -j - 1, -1, dtype=complex)
++    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
++    return _data.diag[dtype](data, 1)
++
++
++def _jz(j, *, dtype=None):
++    """
++    Internal functions for generating the data representing the J-z operator.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    N = int(2*j + 1)
++    data = np.array([j-k for k in range(N)], dtype=complex)
++    return _data.diag[dtype](data, 0)
++
++
++#
++# Spin j operators:
++#
++def spin_Jx(j, *, dtype=None):
++    """Spin-j x operator
++
++    Parameters
++    ----------
++    j : float
++        Spin of operator
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    op : Qobj
++        ``qobj`` representation of the operator.
++
++    """
++    return jmat(j, 'x', dtype=dtype)
++
++
++def spin_Jy(j, *, dtype=None):
++    """Spin-j y operator
++
++    Parameters
++    ----------
++    j : float
++        Spin of operator
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    op : Qobj
++        ``qobj`` representation of the operator.
++
++    """
++    return jmat(j, 'y', dtype=dtype)
++
++
++def spin_Jz(j, *, dtype=None):
++    """Spin-j z operator
++
++    Parameters
++    ----------
++    j : float
++        Spin of operator
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    op : Qobj
++        ``qobj`` representation of the operator.
++
++    """
++    return jmat(j, 'z', dtype=dtype)
++
++
++def spin_Jm(j, *, dtype=None):
++    """Spin-j annihilation operator
++
++    Parameters
++    ----------
++    j : float
++        Spin of operator
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    op : Qobj
++        ``qobj`` representation of the operator.
++
++    """
++    return jmat(j, '-', dtype=dtype)
++
++
++def spin_Jp(j, *, dtype=None):
++    """Spin-j creation operator
++
++    Parameters
++    ----------
++    j : float
++        Spin of operator
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    op : Qobj
++        ``qobj`` representation of the operator.
++
++    """
++    return jmat(j, '+', dtype=dtype)
++
++
++def spin_J_set(j, *, dtype=None):
++    """Set of spin-j operators (x, y, z)
++
++    Parameters
++    ----------
++    j : float
++        Spin of operators
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    list : list of Qobj
++        list of ``qobj`` representating of the spin operator.
++
++    """
++    return jmat(j, dtype=dtype)
++
++
++# Pauli spin-1/2 operators.
++#
++# These are so common in quantum information that we want them to be
++# near-instantaneous to initialise, so we cache them at package import, and
++# just return copies when someone requests one.
++_SIGMAP = jmat(0.5, '+')
++_SIGMAM = jmat(0.5, '-')
++_SIGMAX = 2 * jmat(0.5, 'x')
++_SIGMAY = 2 * jmat(0.5, 'y')
++_SIGMAZ = 2 * jmat(0.5, 'z')
++
++
++def sigmap():
++    """Creation operator for Pauli spins.
++
++    Examples
++    --------
++    >>> sigmap() # doctest: +SKIP
++    Quantum object: dims = [[2], [2]], \
++shape = [2, 2], type = oper, isHerm = False
++    Qobj data =
++    [[ 0.  1.]
++     [ 0.  0.]]
++
++    """
++    return _SIGMAP.copy()
++
++
++def sigmam():
++    """Annihilation operator for Pauli spins.
++
++    Examples
++    --------
++    >>> sigmam() # doctest: +SKIP
++    Quantum object: dims = [[2], [2]], \
++shape = [2, 2], type = oper, isHerm = False
++    Qobj data =
++    [[ 0.  0.]
++     [ 1.  0.]]
++
++    """
++    return _SIGMAM.copy()
++
++
++def sigmax():
++    """Pauli spin 1/2 sigma-x operator
++
++    Examples
++    --------
++    >>> sigmax() # doctest: +SKIP
++    Quantum object: dims = [[2], [2]], \
++shape = [2, 2], type = oper, isHerm = False
++    Qobj data =
++    [[ 0.  1.]
++     [ 1.  0.]]
++
++    """
++    return _SIGMAX.copy()
++
++
++def sigmay():
++    """Pauli spin 1/2 sigma-y operator.
++
++    Examples
++    --------
++    >>> sigmay() # doctest: +SKIP
++    Quantum object: dims = [[2], [2]], \
++shape = [2, 2], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.+0.j  0.-1.j]
++     [ 0.+1.j  0.+0.j]]
++
++    """
++    return _SIGMAY.copy()
++
++
++def sigmaz():
++    """Pauli spin 1/2 sigma-z operator.
++
++    Examples
++    --------
++    >>> sigmaz() # doctest: +SKIP
++    Quantum object: dims = [[2], [2]], \
++shape = [2, 2], type = oper, isHerm = True
++    Qobj data =
++    [[ 1.  0.]
++     [ 0. -1.]]
++
++    """
++    return _SIGMAZ.copy()
++
++
++def destroy(N, offset=0, *, dtype=None):
++    """
++    Destruction (lowering) operator.
++
++    Parameters
++    ----------
++    N : int
++        Dimension of Hilbert space.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Qobj for lowering operator.
++
++    Examples
++    --------
++    >>> destroy(4) # doctest: +SKIP
++    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
++    Qobj data =
++    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
++     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
++     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
++     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
++        raise ValueError("Hilbert space dimension must be integer value")
++    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
++    return qdiags(data, 1, dtype=dtype)
++
++
++def create(N, offset=0, *, dtype=None):
++    """
++    Creation (raising) operator.
++
++    Parameters
++    ----------
++    N : int
++        Dimension of Hilbert space.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Qobj for raising operator.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    Examples
++    --------
++    >>> create(4) # doctest: +SKIP
++    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
++    Qobj data =
++    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
++     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
++     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
++     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
++        raise ValueError("Hilbert space dimension must be integer value")
++    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
++    return qdiags(data, -1, dtype=dtype)
++
++
++def _implicit_tensor_dimensions(dimensions):
++    """
++    Total flattened size and operator dimensions for operator creation routines
++    that automatically perform tensor products.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        First dimension of an operator which can create an implicit tensor
++        product.  If the type is `int`, it is promoted first to `[dimensions]`.
++        From there, it should be one of the two-elements `dims` parameter of a
++        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
++        products.
++
++    Returns
++    -------
++    size : int
++        Dimension of backing matrix required to represent operator.
++    dimensions : list
++        Dimension list in the form required by ``Qobj`` creation.
++    """
++    if not isinstance(dimensions, list):
++        dimensions = [dimensions]
++    flat = flatten(dimensions)
++    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
++        raise ValueError("All dimensions must be integers >= 0")
++    return np.prod(flat), [dimensions, dimensions]
++
++
++def qzero(dimensions, *, dtype=None):
++    """
++    Zero operator.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    qzero : qobj
++        Zero operator Qobj.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    size, dimensions = _implicit_tensor_dimensions(dimensions)
++    # A sparse matrix with no data is equal to a zero matrix.
++    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
++    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
++                isherm=True, isunitary=False, copy=False)
++
++
++def qeye(dimensions, *, dtype=None):
++    """
++    Identity operator.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Identity operator Qobj.
++
++    Examples
++    --------
++    >>> qeye(3) # doctest: +SKIP
++    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
++isherm = True
++    Qobj data =
++    [[ 1.  0.  0.]
++     [ 0.  1.  0.]
++     [ 0.  0.  1.]]
++    >>> qeye([2,2]) # doctest: +SKIP
++    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
++isherm = True
++    Qobj data =
++    [[1. 0. 0. 0.]
++     [0. 1. 0. 0.]
++     [0. 0. 1. 0.]
++     [0. 0. 0. 1.]]
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    size, dimensions = _implicit_tensor_dimensions(dimensions)
++    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
++    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
++                isherm=True, isunitary=True, copy=False)
++
++
++# Name alias.
++identity = qeye
++
++
++def position(N, offset=0, *, dtype=None):
++    """
++    Position operator x=1/sqrt(2)*(a+a.dag())
++
++    Parameters
++    ----------
++    N : int
++        Number of Fock states in Hilbert space.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Position operator as Qobj.
++    """
++    a = destroy(N, offset=offset, dtype=dtype)
++    position = np.sqrt(0.5) * (a + a.dag())
++    position.isherm = True
++    return position
++
++
++def momentum(N, offset=0, *, dtype=None):
++    """
++    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
++
++    Parameters
++    ----------
++    N : int
++        Number of Fock states in Hilbert space.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Momentum operator as Qobj.
++    """
++    a = destroy(N, offset=offset, dtype=dtype)
++    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
++    momentum.isherm = True
++    return momentum
++
++
++def num(N, offset=0, *, dtype=None):
++    """
++    Quantum object for number operator.
++
++    Parameters
++    ----------
++    N : int
++        The dimension of the Hilbert space.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper: qobj
++        Qobj for number operator.
++
++    Examples
++    --------
++    >>> num(4) # doctest: +SKIP
++    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
++    Qobj data =
++    [[0 0 0 0]
++     [0 1 0 0]
++     [0 0 2 0]
++     [0 0 0 3]]
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    data = np.arange(offset, offset + N, dtype=complex)
++    return qdiags(data, 0, dtype=dtype)
++
++
++def squeeze(N, z, offset=0, *, dtype=None):
++    """Single-mode squeezing operator.
++
++    Parameters
++    ----------
++    N : int
++        Dimension of hilbert space.
++
++    z : float/complex
++        Squeezing parameter.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : :class:`qutip.Qobj`
++        Squeezing operator.
++
++
++    Examples
++    --------
++    >>> squeeze(4, 0.25) # doctest: +SKIP
++    Quantum object: dims = [[4], [4]], \
++shape = [4, 4], type = oper, isHerm = False
++    Qobj data =
++    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
++     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
++     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
++     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
++
++    """
++    asq = destroy(N, offset=offset, dtype=dtype) ** 2
++    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
++    return op.expm(dtype=dtype)
++
++
++def squeezing(a1, a2, z):
++    """Generalized squeezing operator.
++
++    .. math::
++
++        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
++        - za_1^\\dagger a_2^\\dagger\\right)\\right)
++
++    Parameters
++    ----------
++    a1 : :class:`qutip.Qobj`
++        Operator 1.
++
++    a2 : :class:`qutip.Qobj`
++        Operator 2.
++
++    z : float/complex
++        Squeezing parameter.
++
++    Returns
++    -------
++    oper : :class:`qutip.Qobj`
++        Squeezing operator.
++
++    """
++    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
++    return b.expm()
++
++
++def displace(N, alpha, offset=0, *, dtype=None):
++    """Single-mode displacement operator.
++
++    Parameters
++    ----------
++    N : int
++        Dimension of Hilbert space.
++
++    alpha : float/complex
++        Displacement amplitude.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the operator.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Displacement operator.
++
++    Examples
++    --------
++    >>> displace(4,0.25) # doctest: +SKIP
++    Quantum object: dims = [[4], [4]], \
++shape = [4, 4], type = oper, isHerm = False
++    Qobj data =
++    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
++     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
++     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
++     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    a = destroy(N, offset=offset)
++    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
++
++
++def commutator(A, B, kind="normal"):
++    """
++    Return the commutator of kind `kind` (normal, anti) of the
++    two operators A and B.
++    """
++    if kind == 'normal':
++        return A @ B - B @ A
++
++    elif kind == 'anti':
++        return A @ B + B @ A
++
++    else:
++        raise TypeError("Unknown commutator kind '%s'" % kind)
++
++
++def qutrit_ops(*, dtype=None):
++    """
++    Operators for a three level system (qutrit).
++
++    Parameters
++    ----------
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    opers: array
++        `array` of qutrit operators.
++
++    """
++    from .states import qutrit_basis
++
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    out = np.empty((6,), dtype=object)
++    one, two, three = qutrit_basis(dtype=dtype)
++    out[0] = one * one.dag()
++    out[1] = two * two.dag()
++    out[2] = three * three.dag()
++    out[3] = one * two.dag()
++    out[4] = two * three.dag()
++    out[5] = three * one.dag()
++    return out
++
++
++def phase(N, phi0=0, *, dtype=None):
++    """
++    Single-mode Pegg-Barnett phase operator.
++
++    Parameters
++    ----------
++    N : int
++        Number of basis states in Hilbert space.
++
++    phi0 : float
++        Reference phase.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Phase operator with respect to reference phase.
++
++    Notes
++    -----
++    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
++    n = np.arange(N)[:, np.newaxis]
++    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
++                       for kk in phim])
++    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
++    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
++
++
++def enr_destroy(dims, excitations, *, dtype=None):
++    """
++    Generate annilation operators for modes in a excitation-number-restricted
++    state space. For example, consider a system consisting of 4 modes, each
++    with 5 states. The total hilbert space size is 5**4 = 625. If we are
++    only interested in states that contain up to 2 excitations, we only need
++    to include states such as
++
++        (0, 0, 0, 0)
++        (0, 0, 0, 1)
++        (0, 0, 0, 2)
++        (0, 0, 1, 0)
++        (0, 0, 1, 1)
++        (0, 0, 2, 0)
++        ...
++
++    This function creates annihilation operators for the 4 modes that act
++    within this state space:
++
++        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
++
++    From this point onwards, the annihiltion operators a1, ..., a4 can be
++    used to setup a Hamiltonian, collapse operators and expectation-value
++    operators, etc., following the usual pattern.
++
++    Parameters
++    ----------
++    dims : list
++        A list of the dimensions of each subsystem of a composite quantum
++        system.
++
++    excitations : integer
++        The maximum number of excitations that are to be included in the
++        state space.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    a_ops : list of qobj
++        A list of annihilation operators for each mode in the composite
++        quantum system described by dims.
++    """
++    from .states import enr_state_dictionaries
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++
++    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
++
++    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
++             for _ in dims]
++
++    for n1, state1 in enumerate(idx2state):
++        for idx, s in enumerate(state1):
++            # if s > 0, the annihilation operator of mode idx has a non-zero
++            # entry with one less excitation in mode idx in the final state
++            if s > 0:
++                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
++                n2 = state2idx[state2]
++                a_ops[idx][n2, n1] = np.sqrt(s)
++
++    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
++
++
++def enr_identity(dims, excitations, *, dtype=None):
++    """
++    Generate the identity operator for the excitation-number restricted
++    state space defined by the `dims` and `exciations` arguments. See the
++    docstring for enr_fock for a more detailed description of these arguments.
++
++    Parameters
++    ----------
++    dims : list
++        A list of the dimensions of each subsystem of a composite quantum
++        system.
++
++    excitations : integer
++        The maximum number of excitations that are to be included in the
++        state space.
++
++    state : list of integers
++        The state in the number basis representation.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    op : Qobj
++        A Qobj instance that represent the identity operator in the
++        exication-number-restricted state space defined by `dims` and
++        `exciations`.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    from .states import enr_state_dictionaries
++    nstates, _, _ = enr_state_dictionaries(dims, excitations)
++    return Qobj(_data.identity[dtype](nstates),
++                dims=[dims, dims],
++                type='oper',
++                isherm=True,
++                isunitary=True,
++                copy=False)
++
++
++def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
++    """
++    Generate the diagonal charge operator over charge states
++    from Nmin to Nmax.
++
++    Parameters
++    ----------
++    Nmax : int
++        Maximum charge state to consider.
++
++    Nmin : int (default = -Nmax)
++        Lowest charge state to consider.
++
++    frac : float (default = 1)
++        Specify fractional charge if needed.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    C : Qobj
++        Charge operator over [Nmin, Nmax].
++
++    Notes
++    -----
++    .. versionadded:: 3.2
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    if Nmin is None:
++        Nmin = -Nmax
++    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
++    out = qdiags(diag, 0, dtype=dtype)
++    out.isherm = True
++    return out
++
++
++def tunneling(N, m=1, *, dtype=None):
++    r"""
++    Tunneling operator with elements of the form
++    :math:`\\sum |N><N+m| + |N+m><N|`.
++
++    Parameters
++    ----------
++    N : int
++        Number of basis states in Hilbert space.
++
++    m : int (default = 1)
++        Number of excitations in tunneling event.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    T : Qobj
++        Tunneling operator.
++
++    Notes
++    -----
++    .. versionadded:: 3.2
++
++    """
++    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
++    T = qdiags(diags, [m, -m], dtype=dtype)
++    T.isherm = True
++    return T
++
++
++def qft(dimensions, *, dtype="dense"):
++    """
++    Quantum Fourier Transform operator.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.
++
++    dtype : str or type, [keyword only] [optional]
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    QFT: qobj
++        Quantum Fourier transform operator.
++
++    """
++    N2, dimensions = _implicit_tensor_dimensions(dimensions)
++
++    phase = 2.0j * np.pi / N2
++    arr = np.arange(N2)
++    L, M = np.meshgrid(arr, arr)
++    data = np.exp(phase * (L * M)) / np.sqrt(N2)
++    return Qobj(data, dims=dimensions).to(dtype)
+diff --git a/qutip/core/options.py b/qutip/core/options.py
+index 1724c818..daa3db0b 100644
+--- a/qutip/core/options.py
++++ b/qutip/core/options.py
+@@ -1,123 +1,123 @@
+-from ..settings import settings
+-
+-__all__ = ["CoreOptions"]
+-
+-
+-class QutipOptions:
+-    """
+-    Class for basic functionality for qutip's options.
+-
+-    Define basic method to wrap an ``options`` dict.
+-    Default options are in a class _options dict.
+-    """
+-    _options = {}
+-    _settings_name = None  # Where the default is in settings
+-
+-    def __init__(self, **options):
+-        self.options = self._options.copy()
+-        for key in set(options) & set(self.options):
+-            self[key] = options.pop(key)
+-        if options:
+-            raise KeyError(f"Options {set(options)} are not supported.")
+-
+-    def __contains__(self, key):
+-        return key in self.options
+-
+-    def __getitem__(self, key):
+-        # Let the dict catch the KeyError
+-        return self.options[key]
+-
+-    def __setitem__(self, key, value):
+-        # Let the dict catch the KeyError
+-        self.options[key] = value
+-
+-    def __repr__(self, full=True):
+-        out = [f"<{self.__class__.__name__}("]
+-        for key, value in self.options.items():
+-            if full or value != self._options[key]:
+-                out += [f"    '{key}': {repr(value)},"]
+-        out += [")>"]
+-        if len(out)-2:
+-            return "\n".join(out)
+-        else:
+-            return "".join(out)
+-
+-    def __enter__(self):
+-        self._backup = getattr(settings, self._settings_name)
+-        setattr(settings, self._settings_name, self)
+-
+-    def __exit__(self, exc_type, exc_value, exc_traceback):
+-        setattr(settings, self._settings_name, self._backup)
+-
+-
+-class CoreOptions(QutipOptions):
+-    """
+-    Options used by the core of qutip such as the tolerance of :class:`Qobj`
+-    comparison or coefficient's format.
+-
+-    Values can be changed in ``qutip.settings.core`` or by using context:
+-    ``with CoreOptions(atol=1e-6): ...``.
+-
+-    Options
+-    -------
+-    auto_tidyup : bool
+-        Whether to tidyup during sparse operations.
+-
+-    auto_tidyup_dims : bool [True]
+-        Use auto tidyup dims on multiplication. (Not used yet)
+-
+-    atol : float {1e-12}
+-        General absolute tolerance
+-
+-    rtol : float {1e-12}
+-        General relative tolerance
+-        Used to choose QobjEvo.expect output type
+-
+-    auto_tidyup_atol : float {1e-14}
+-        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
+-        parameter above) and the default value of ``atol`` used in
+-        :method:`Qobj.tidyup`.
+-
+-    function_coefficient_style : str {"auto"}
+-        The signature expected by function coefficients. The options are:
+-
+-        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
+-          is the time and the ``...`` are the remaining arguments passed
+-          directly into the function. E.g. ``f(t, w, b=5)``.
+-
+-        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
+-          the time and ``args`` is a dict containing the remaining arguments.
+-          E.g. ``f(t, {"w": w, "b": 5})``.
+-
+-        - "auto": select automatically between the two options above based
+-          on the signature of the supplied function. If the function signature
+-          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
+-          ``pythonic`` is used.
+-
+-    default_dtype : Nonetype, str, type {None}
+-        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
+-        :func:"rand_herm", will use the specified data type. Any data-layer
+-        known to ``qutip.data.to`` is accepted. When ``None``, these functions
+-        will default to a sensible data type.
+-    """
+-    _options = {
+-        # use auto tidyup
+-        "auto_tidyup": True,
+-        # use auto tidyup dims on multiplication
+-        "auto_tidyup_dims": True,
+-        # general absolute tolerance
+-        "atol": 1e-12,
+-        # general relative tolerance
+-        "rtol": 1e-12,
+-        # use auto tidyup absolute tolerance
+-        "auto_tidyup_atol": 1e-14,
+-        # signature style expected by function coefficients
+-        "function_coefficient_style": "auto",
+-        # Default Qobj dtype for Qobj create function
+-        "default_dtype": None,
+-    }
+-    _settings_name = "core"
+-
+-
+-# Creating the instance of core options to use everywhere.
+-settings.core = CoreOptions()
++from ..settings import settings
++
++__all__ = ["CoreOptions"]
++
++
++class QutipOptions:
++    """
++    Class for basic functionality for qutip's options.
++
++    Define basic method to wrap an ``options`` dict.
++    Default options are in a class _options dict.
++    """
++    _options = {}
++    _settings_name = None  # Where the default is in settings
++
++    def __init__(self, **options):
++        self.options = self._options.copy()
++        for key in set(options) & set(self.options):
++            self[key] = options.pop(key)
++        if options:
++            raise KeyError(f"Options {set(options)} are not supported.")
++
++    def __contains__(self, key):
++        return key in self.options
++
++    def __getitem__(self, key):
++        # Let the dict catch the KeyError
++        return self.options[key]
++
++    def __setitem__(self, key, value):
++        # Let the dict catch the KeyError
++        self.options[key] = value
++
++    def __repr__(self, full=True):
++        out = [f"<{self.__class__.__name__}("]
++        for key, value in self.options.items():
++            if full or value != self._options[key]:
++                out += [f"    '{key}': {repr(value)},"]
++        out += [")>"]
++        if len(out)-2:
++            return "\n".join(out)
++        else:
++            return "".join(out)
++
++    def __enter__(self):
++        self._backup = getattr(settings, self._settings_name)
++        setattr(settings, self._settings_name, self)
++
++    def __exit__(self, exc_type, exc_value, exc_traceback):
++        setattr(settings, self._settings_name, self._backup)
++
++
++class CoreOptions(QutipOptions):
++    """
++    Options used by the core of qutip such as the tolerance of :class:`Qobj`
++    comparison or coefficient's format.
++
++    Values can be changed in ``qutip.settings.core`` or by using context:
++    ``with CoreOptions(atol=1e-6): ...``.
++
++    Options
++    -------
++    auto_tidyup : bool
++        Whether to tidyup during sparse operations.
++
++    auto_tidyup_dims : bool [True]
++        Use auto tidyup dims on multiplication. (Not used yet)
++
++    atol : float {1e-12}
++        General absolute tolerance
++
++    rtol : float {1e-12}
++        General relative tolerance
++        Used to choose QobjEvo.expect output type
++
++    auto_tidyup_atol : float {1e-14}
++        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
++        parameter above) and the default value of ``atol`` used in
++        :method:`Qobj.tidyup`.
++
++    function_coefficient_style : str {"auto"}
++        The signature expected by function coefficients. The options are:
++
++        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
++          is the time and the ``...`` are the remaining arguments passed
++          directly into the function. E.g. ``f(t, w, b=5)``.
++
++        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
++          the time and ``args`` is a dict containing the remaining arguments.
++          E.g. ``f(t, {"w": w, "b": 5})``.
++
++        - "auto": select automatically between the two options above based
++          on the signature of the supplied function. If the function signature
++          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
++          ``pythonic`` is used.
++
++    default_dtype : Nonetype, str, type {None}
++        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
++        :func:"rand_herm", will use the specified data type. Any data-layer
++        known to ``qutip.data.to`` is accepted. When ``None``, these functions
++        will default to a sensible data type.
++    """
++    _options = {
++        # use auto tidyup
++        "auto_tidyup": True,
++        # use auto tidyup dims on multiplication
++        "auto_tidyup_dims": True,
++        # general absolute tolerance
++        "atol": 1e-12,
++        # general relative tolerance
++        "rtol": 1e-12,
++        # use auto tidyup absolute tolerance
++        "auto_tidyup_atol": 1e-14,
++        # signature style expected by function coefficients
++        "function_coefficient_style": "auto",
++        # Default Qobj dtype for Qobj create function
++        "default_dtype": None,
++    }
++    _settings_name = "core"
++
++
++# Creating the instance of core options to use everywhere.
++settings.core = CoreOptions()
+diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
+index 83a778b0..b6128d55 100644
+--- a/qutip/core/qobj.py
++++ b/qutip/core/qobj.py
+@@ -1,1811 +1,1811 @@
+-"""The Quantum Object (Qobj) class, for representing quantum states and
+-operators, and related functions.
+-"""
+-
+-__all__ = [
+-    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
+-    'isherm', 'ptrace',
+-]
+-
+-import functools
+-import numbers
+-import warnings
+-
+-import numpy as np
+-import scipy.sparse
+-
+-from .. import __version__
+-from ..settings import settings
+-from . import data as _data
+-from .dimensions import (
+-    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
+-)
+-
+-
+-_ADJOINT_TYPE_LOOKUP = {
+-    'oper': 'oper',
+-    'super': 'super',
+-    'ket': 'bra',
+-    'bra': 'ket',
+-    'operator-ket': 'operator-bra',
+-    'operator-bra': 'operator-ket',
+-}
+-
+-_MATMUL_TYPE_LOOKUP = {
+-    ('oper', 'ket'): 'ket',
+-    ('oper', 'oper'): 'oper',
+-    ('ket', 'bra'): 'oper',
+-    ('bra', 'oper'): 'bra',
+-    ('super', 'super'): 'super',
+-    ('super', 'operator-ket'): 'operator-ket',
+-    ('operator-bra', 'super'): 'operator-bra',
+-    ('operator-ket', 'operator-bra'): 'super',
+-}
+-
+-_NORM_FUNCTION_LOOKUP = {
+-    'tr': _data.norm.trace,
+-    'one': _data.norm.one,
+-    'max': _data.norm.max,
+-    'fro': _data.norm.frobenius,
+-    'l2': _data.norm.l2,
+-}
+-_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
+-_NORM_ALLOWED_VECTOR = {'l2', 'max'}
+-
+-_CALL_ALLOWED = {
+-    ('super', 'oper'),
+-    ('super', 'ket'),
+-    ('oper', 'ket'),
+-}
+-
+-
+-def isbra(x):
+-    return isinstance(x, Qobj) and x.type == 'bra'
+-
+-
+-def isket(x):
+-    return isinstance(x, Qobj) and x.type == 'ket'
+-
+-
+-def isoper(x):
+-    return isinstance(x, Qobj) and x.type == 'oper'
+-
+-
+-def isoperbra(x):
+-    return isinstance(x, Qobj) and x.type == 'operator-bra'
+-
+-
+-def isoperket(x):
+-    return isinstance(x, Qobj) and x.type == 'operator-ket'
+-
+-
+-def issuper(x):
+-    return isinstance(x, Qobj) and x.type == 'super'
+-
+-
+-def isherm(x):
+-    return isinstance(x, Qobj) and x.isherm
+-
+-
+-def _require_equal_type(method):
+-    """
+-    Decorate a binary Qobj method to ensure both operands are Qobj and of the
+-    same type and dimensions.  Promote numeric scalar to identity matrices of
+-    the same type and shape.
+-    """
+-    @functools.wraps(method)
+-    def out(self, other):
+-        if other == 0:
+-            return method(self, other)
+-        if (
+-            self.type in ('oper', 'super')
+-            and self.dims[0] == self.dims[1]
+-            and isinstance(other, numbers.Number)
+-        ):
+-            scale = complex(other)
+-            other = Qobj(_data.identity(self.shape[0], scale,
+-                                        dtype=type(self.data)),
+-                         dims=self.dims,
+-                         type=self.type,
+-                         superrep=self.superrep,
+-                         isherm=(scale.imag == 0),
+-                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
+-                         copy=False)
+-        if not isinstance(other, Qobj):
+-            try:
+-                other = Qobj(other, type=self.type)
+-            except TypeError:
+-                return NotImplemented
+-        if self.dims != other.dims:
+-            msg = (
+-                "incompatible dimensions "
+-                + repr(self.dims) + " and " + repr(other.dims)
+-            )
+-            raise ValueError(msg)
+-        if self.type != other.type:
+-            msg = "incompatible types " + self.type + " and " + other.type
+-            raise ValueError(msg)
+-        if self.superrep != other.superrep:
+-            msg = (
+-                "incompatible superoperator representations"
+-                + self.superrep + " and " + other.superrep
+-            )
+-            raise ValueError(msg)
+-        return method(self, other)
+-    return out
+-
+-
+-def _latex_real(x):
+-    if not x:
+-        return "0"
+-    if not 0.001 <= abs(x) < 1000:
+-        base, exp = "{:.3e}".format(x).split('e')
+-        return base + r"\times10^{{ {:d} }}".format(int(exp))
+-    if abs(x - int(x)) < 0.001:
+-        return "{:d}".format(round(x))
+-    return "{:.3f}".format(x)
+-
+-
+-def _latex_complex(x):
+-    if abs(x.imag) < 0.001:
+-        return _latex_real(x.real)
+-    if abs(x.real) < 0.001:
+-        return _latex_real(x.imag) + "j"
+-    sign = "+" if x.imag > 0 else "-"
+-    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
+-
+-
+-def _latex_row(row, cols, data):
+-    if row is None:
+-        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
+-    else:
+-        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
+-                for col in cols)
+-    return " & ".join(bits)
+-
+-
+-class Qobj:
+-    """
+-    A class for representing quantum objects, such as quantum operators and
+-    states.
+-
+-    The Qobj class is the QuTiP representation of quantum operators and state
+-    vectors. This class also implements math operations +,-,* between Qobj
+-    instances (and / by a C-number), as well as a collection of common
+-    operator/state operations.  The Qobj constructor optionally takes a
+-    dimension ``list`` and/or shape ``list`` as arguments.
+-
+-    Parameters
+-    ----------
+-    inpt: array_like
+-        Data for vector/matrix representation of the quantum object.
+-    dims: list
+-        Dimensions of object used for tensor products.
+-    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
+-        The type of quantum object to be represented.
+-    shape: list
+-        Shape of underlying data structure (matrix shape).
+-    copy: bool
+-        Flag specifying whether Qobj should get a copy of the
+-        input data, or use the original.
+-
+-
+-    Attributes
+-    ----------
+-    data : array_like
+-        Sparse matrix characterizing the quantum object.
+-    dims : list
+-        List of dimensions keeping track of the tensor structure.
+-    shape : list
+-        Shape of the underlying `data` array.
+-    type : str
+-        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
+-        'operator-bra', or 'super'.
+-    superrep : str
+-        Representation used if `type` is 'super'. One of 'super'
+-        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
+-    isherm : bool
+-        Indicates if quantum object represents Hermitian operator.
+-    isunitary : bool
+-        Indictaes if quantum object represents unitary operator.
+-    iscp : bool
+-        Indicates if the quantum object represents a map, and if that map is
+-        completely positive (CP).
+-    ishp : bool
+-        Indicates if the quantum object represents a map, and if that map is
+-        hermicity preserving (HP).
+-    istp : bool
+-        Indicates if the quantum object represents a map, and if that map is
+-        trace preserving (TP).
+-    iscptp : bool
+-        Indicates if the quantum object represents a map that is completely
+-        positive and trace preserving (CPTP).
+-    isket : bool
+-        Indicates if the quantum object represents a ket.
+-    isbra : bool
+-        Indicates if the quantum object represents a bra.
+-    isoper : bool
+-        Indicates if the quantum object represents an operator.
+-    issuper : bool
+-        Indicates if the quantum object represents a superoperator.
+-    isoperket : bool
+-        Indicates if the quantum object represents an operator in column vector
+-        form.
+-    isoperbra : bool
+-        Indicates if the quantum object represents an operator in row vector
+-        form.
+-
+-    Methods
+-    -------
+-    copy()
+-        Create copy of Qobj
+-    conj()
+-        Conjugate of quantum object.
+-    cosm()
+-        Cosine of quantum object.
+-    dag()
+-        Adjoint (dagger) of quantum object.
+-    dnorm()
+-        Diamond norm of quantum operator.
+-    dual_chan()
+-        Dual channel of quantum object representing a CP map.
+-    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
+-        Returns eigenenergies (eigenvalues) of a quantum object.
+-    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
+-        Returns eigenenergies and eigenstates of quantum object.
+-    expm()
+-        Matrix exponential of quantum object.
+-    full(order='C')
+-        Returns dense array of quantum object `data` attribute.
+-    groundstate(sparse=False, tol=0, maxiter=100000)
+-        Returns eigenvalue and eigenket for the groundstate of a quantum
+-        object.
+-    inv()
+-        Return a Qobj corresponding to the matrix inverse of the operator.
+-    matrix_element(bra, ket)
+-        Returns the matrix element of operator between `bra` and `ket` vectors.
+-    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
+-        Returns norm of a ket or an operator.
+-    permute(order)
+-        Returns composite qobj with indices reordered.
+-    proj()
+-        Computes the projector for a ket or bra vector.
+-    ptrace(sel)
+-        Returns quantum object for selected dimensions after performing
+-        partial trace.
+-    sinm()
+-        Sine of quantum object.
+-    sqrtm()
+-        Matrix square root of quantum object.
+-    tidyup(atol=1e-12)
+-        Removes small elements from quantum object.
+-    tr()
+-        Trace of quantum object.
+-    trans()
+-        Transpose of quantum object.
+-    transform(inpt, inverse=False)
+-        Performs a basis transformation defined by `inpt` matrix.
+-    trunc_neg(method='clip')
+-        Removes negative eigenvalues and returns a new Qobj that is
+-        a valid density operator.
+-    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
+-        Returns normalized quantum object.
+-
+-    """
+-    # Disable ufuncs from acting directly on Qobj.
+-    __array_ufunc__ = None
+-
+-    def _initialize_data(self, arg, dims, copy):
+-        if isinstance(arg, _data.Data):
+-            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
+-            self._data = arg.copy() if copy else arg
+-        elif isinstance(arg, Qobj):
+-            self.dims = dims or arg.dims.copy()
+-            self._data = arg.data.copy() if copy else arg.data
+-        elif arg is None or isinstance(arg, numbers.Number):
+-            self.dims = dims or [[1], [1]]
+-            size = np.prod(self.dims[0])
+-            if arg is None:
+-                self._data = _data.zeros(size, size)
+-            else:
+-                self._data = _data.identity(size, scale=complex(arg))
+-        else:
+-            self._data = _data.create(arg, copy=copy)
+-            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
+-
+-    def __init__(self, arg=None, dims=None, type=None,
+-                 copy=True, superrep=None, isherm=None, isunitary=None):
+-        self._initialize_data(arg, dims, copy)
+-        self.type = type or type_from_dims(self.dims)
+-        self._isherm = isherm
+-        self._isunitary = isunitary
+-
+-        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
+-            if self._data.shape[0] != self._data.shape[1]:
+-                raise ValueError("".join([
+-                    "cannot build superoperator from nonsquare data of shape ",
+-                    repr(self._data.shape),
+-                ]))
+-            root = int(np.sqrt(self._data.shape[0]))
+-            if root * root != self._data.shape[0]:
+-                raise ValueError("".join([
+-                    "cannot build superoperator from nonsquare subspaces ",
+-                    "of size ",
+-                    repr(self._data.shape[0]),
+-                ]))
+-            self.dims = [[[root]]*2]*2
+-        if self.type in ['super', 'operator-ket', 'operator-bra']:
+-            superrep = superrep or 'super'
+-        self.superrep = superrep
+-
+-    def copy(self):
+-        """Create identical copy"""
+-        return Qobj(arg=self._data,
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=True)
+-
+-    @property
+-    def data(self):
+-        return self._data
+-
+-    @data.setter
+-    def data(self, data):
+-        if not isinstance(data, _data.Data):
+-            raise TypeError('Qobj data must be a data-layer format.')
+-        self._data = data
+-
+-    def to(self, data_type):
+-        """
+-        Convert the underlying data store of this `Qobj` into a different
+-        storage representation.
+-
+-        The different storage representations available are the "data-layer
+-        types" which are known to `qutip.data.to`.  By default, these are
+-        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
+-        dense matrix store and a compressed sparse row one.  Certain algorithms
+-        and operations may be faster or more accurate when using a more
+-        appropriate data store.
+-
+-        If the data store is already in the format requested, the function
+-        returns `self`.  Otherwise, it returns a copy of itself with the data
+-        store in the new type.
+-
+-        Parameters
+-        ----------
+-        data_type : type
+-            The data-layer type that the data of this `Qobj` should be
+-            converted to.
+-
+-        Returns
+-        -------
+-        Qobj
+-            A new `Qobj` if a type conversion took place with the data stored
+-            in the requested format, or `self` if not.
+-        """
+-        try:
+-            converter = _data.to[data_type]
+-        except (KeyError, TypeError):
+-            raise ValueError("Unknown conversion type: " + str(data_type))
+-        if type(self.data) is data_type:
+-            return self
+-        return Qobj(converter(self._data),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=False)
+-
+-    @_require_equal_type
+-    def __add__(self, other):
+-        if other == 0:
+-            return self.copy()
+-        isherm = (self._isherm and other._isherm) or None
+-        return Qobj(_data.add(self._data, other._data),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=isherm,
+-                    copy=False)
+-
+-    def __radd__(self, other):
+-        return self.__add__(other)
+-
+-    @_require_equal_type
+-    def __sub__(self, other):
+-        if other == 0:
+-            return self.copy()
+-        isherm = (self._isherm and other._isherm) or None
+-        return Qobj(_data.sub(self._data, other._data),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=isherm,
+-                    copy=False)
+-
+-    def __rsub__(self, other):
+-        return self.__neg__().__add__(other)
+-
+-    def __mul__(self, other):
+-        """
+-        If other is a Qobj, we dispatch to __matmul__. If not, we
+-        check that other is a valid complex scalar, i.e., we can do
+-        complex(other). Otherwise, we return NotImplemented.
+-        """
+-
+-        if isinstance(other, Qobj):
+-            return self.__matmul__(other)
+-
+-        # We send other to mul instead of complex(other) to be more flexible.
+-        # The dispatcher can then decide how to handle other and return
+-        # TypeError if it does not know what to do with the type of other.
+-        try:
+-            out = _data.mul(self._data, other)
+-        except TypeError:
+-            return NotImplemented
+-
+-        # Infer isherm and isunitary if possible
+-        try:
+-            multiplier = complex(other)
+-            isherm = (self._isherm and multiplier.imag == 0) or None
+-            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
+-                         if self._isunitary else None)
+-        except TypeError:
+-            isherm = None
+-            isunitary = None
+-
+-        return Qobj(out,
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=isherm,
+-                    isunitary=isunitary,
+-                    copy=False)
+-
+-    def __rmul__(self, other):
+-        # Shouldn't be here unless `other.__mul__` has already been tried, so
+-        # we _shouldn't_ check that `other` is `Qobj`.
+-        return self.__mul__(other)
+-
+-    def __matmul__(self, other):
+-        if not isinstance(other, Qobj):
+-            try:
+-                other = Qobj(other)
+-            except TypeError:
+-                return NotImplemented
+-        if self.dims[1] != other.dims[0]:
+-            raise TypeError("".join([
+-                "incompatible dimensions ",
+-                repr(self.dims),
+-                " and ",
+-                repr(other.dims),
+-            ]))
+-        if self.superrep != other.superrep:
+-            raise TypeError("".join([
+-                "incompatible superoperator representations ",
+-                repr(self.superrep),
+-                " and ",
+-                repr(other.superrep),
+-            ]))
+-        if (
+-            (self.isbra and other.isket)
+-            or (self.isoperbra and other.isoperket)
+-        ):
+-            return _data.inner(self.data, other.data)
+-
+-        try:
+-            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
+-        except KeyError:
+-            raise TypeError(
+-                "incompatible matmul types "
+-                + repr(self.type) + " and " + repr(other.type)
+-            ) from None
+-        return Qobj(_data.matmul(self.data, other.data),
+-                    dims=[self.dims[0], other.dims[1]],
+-                    type=type_,
+-                    isunitary=self._isunitary and other._isunitary,
+-                    superrep=self.superrep,
+-                    copy=False)
+-
+-    def __truediv__(self, other):
+-        return self.__mul__(1 / other)
+-
+-    def __neg__(self):
+-        return Qobj(_data.neg(self._data),
+-                    dims=self.dims.copy(),
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=False)
+-
+-    def __getitem__(self, ind):
+-        # TODO: should we require that data-layer types implement this?  This
+-        # isn't the right way of handling it, for sure.
+-        if isinstance(self._data, _data.CSR):
+-            data = self._data.as_scipy()
+-        elif isinstance(self._data, _data.Dense):
+-            data = self._data.as_ndarray()
+-        else:
+-            data = self._data
+-        try:
+-            out = data[ind]
+-            return out.toarray() if scipy.sparse.issparse(out) else out
+-        except TypeError:
+-            pass
+-        return data.to_array()[ind]
+-
+-    def __eq__(self, other):
+-        if self is other:
+-            return True
+-        if not isinstance(other, Qobj) or self.dims != other.dims:
+-            return False
+-        return _data.iszero(_data.sub(self._data, other._data),
+-                            tol=settings.core['atol'])
+-
+-    def __pow__(self, n, m=None):  # calculates powers of Qobj
+-        if (
+-            self.type not in ('oper', 'super')
+-            or self.dims[0] != self.dims[1]
+-            or m is not None
+-            or not isinstance(n, numbers.Integral)
+-            or n < 0
+-        ):
+-            return NotImplemented
+-        return Qobj(_data.pow(self._data, n),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=False)
+-
+-    def _str_header(self):
+-        out = ", ".join([
+-            "Quantum object: dims=" + str(self.dims),
+-            "shape=" + str(self.data.shape),
+-            "type=" + repr(self.type),
+-        ])
+-        if self.type in ('oper', 'super'):
+-            out += ", isherm=" + str(self.isherm)
+-        if self.issuper and self.superrep != 'super':
+-            out += ", superrep=" + repr(self.superrep)
+-        return out
+-
+-    def __str__(self):
+-        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
+-            # If the system is huge, don't attempt to convert to a dense matrix
+-            # and then to string, because it is pointless and is likely going
+-            # to produce memory errors. Instead print the sparse data string
+-            # representation.
+-            data = _data.to(_data.CSR, self.data).as_scipy()
+-        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
+-            data = np.real(self.full())
+-        else:
+-            data = self.full()
+-        return self._str_header() + "\nQobj data =\n" + str(data)
+-
+-    def __repr__(self):
+-        # give complete information on Qobj without print statement in
+-        # command-line we cant realistically serialize a Qobj into a string,
+-        # so we simply return the informal __str__ representation instead.)
+-        return self.__str__()
+-
+-    def __call__(self, other):
+-        """
+-        Acts this Qobj on another Qobj either by left-multiplication,
+-        or by vectorization and devectorization, as
+-        appropriate.
+-        """
+-        if not isinstance(other, Qobj):
+-            raise TypeError("Only defined for quantum objects.")
+-        if (self.type, other.type) not in _CALL_ALLOWED:
+-            raise TypeError(self.type + " cannot act on " + other.type)
+-        if self.issuper:
+-            if other.isket:
+-                other = other.proj()
+-            return vector_to_operator(self @ operator_to_vector(other))
+-        return self.__matmul__(other)
+-
+-    def __getstate__(self):
+-        # defines what happens when Qobj object gets pickled
+-        self.__dict__.update({'qutip_version': __version__[:5]})
+-        return self.__dict__
+-
+-    def __setstate__(self, state):
+-        # defines what happens when loading a pickled Qobj
+-        if 'qutip_version' in state.keys():
+-            del state['qutip_version']
+-        (self.__dict__).update(state)
+-
+-    def _repr_latex_(self):
+-        """
+-        Generate a LaTeX representation of the Qobj instance. Can be used for
+-        formatted output in ipython notebook.
+-        """
+-        half_length = 5
+-        n_rows, n_cols = self.data.shape
+-        # Choose which rows and columns we're going to output, or None if that
+-        # element should be truncated.
+-        rows = list(range(min((half_length, n_rows))))
+-        if n_rows <= half_length * 2:
+-            rows += list(range(half_length, min((2*half_length, n_rows))))
+-        else:
+-            rows.append(None)
+-            rows += list(range(n_rows - half_length, n_rows))
+-        cols = list(range(min((half_length, n_cols))))
+-        if n_cols <= half_length * 2:
+-            cols += list(range(half_length, min((2*half_length, n_cols))))
+-        else:
+-            cols.append(None)
+-            cols += list(range(n_cols - half_length, n_cols))
+-        # Make the data array.
+-        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
+-        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
+-                           for row in rows)
+-        data += r'\end{array}\right)\end{equation*}'
+-        return self._str_header() + data
+-
+-    def __and__(self, other):
+-        """
+-        Syntax shortcut for tensor:
+-        A & B ==> tensor(A, B)
+-        """
+-        return tensor(self, other)
+-
+-    def dag(self):
+-        """Get the Hermitian adjoint of the quantum object."""
+-        if self._isherm:
+-            return self.copy()
+-        return Qobj(_data.adjoint(self._data),
+-                    dims=[self.dims[1], self.dims[0]],
+-                    type=_ADJOINT_TYPE_LOOKUP[self.type],
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=False)
+-
+-    def conj(self):
+-        """Get the element-wise conjugation of the quantum object."""
+-        return Qobj(_data.conj(self._data),
+-                    dims=self.dims.copy(),
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=False)
+-
+-    def trans(self):
+-        """Get the matrix transpose of the quantum operator.
+-
+-        Returns
+-        -------
+-        oper : :class:`.Qobj`
+-            Transpose of input operator.
+-        """
+-        return Qobj(_data.transpose(self._data),
+-                    dims=[self.dims[1], self.dims[0]],
+-                    type=_ADJOINT_TYPE_LOOKUP[self.type],
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    isunitary=self._isunitary,
+-                    copy=False)
+-
+-    def dual_chan(self):
+-        """Dual channel of quantum object representing a completely positive
+-        map.
+-        """
+-        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
+-        # is only valid for completely positive maps.
+-        if not self.iscp:
+-            raise ValueError("Dual channels are only implemented for CP maps.")
+-        J = to_choi(self)
+-        tensor_idxs = enumerate_flat(J.dims)
+-        J_dual = tensor_swap(J, *(
+-                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
+-                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
+-        )).trans()
+-        J_dual.superrep = 'choi'
+-        return J_dual
+-
+-    def norm(self, norm=None, kwargs=None):
+-        """
+-        Norm of a quantum object.
+-
+-        Default norm is L2-norm for kets and trace-norm for operators.  Other
+-        ket and operator norms may be specified using the `norm` parameter.
+-
+-        Parameters
+-        ----------
+-        norm : str
+-            Which type of norm to use.  Allowed values for vectors are 'l2' and
+-            'max'.  Allowed values for matrices are 'tr' for the trace norm,
+-            'fro' for the Frobenius norm, 'one' and 'max'.
+-
+-        kwargs : dict
+-            Additional keyword arguments to pass on to the relevant norm
+-            solver.  See details for each norm function in :mod:`.data.norm`.
+-
+-        Returns
+-        -------
+-        norm : float
+-            The requested norm of the operator or state quantum object.
+-        """
+-        if self.type in ('oper', 'super'):
+-            norm = norm or 'tr'
+-            if norm not in _NORM_ALLOWED_MATRIX:
+-                raise ValueError(
+-                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
+-                )
+-        else:
+-            norm = norm or 'l2'
+-            if norm not in _NORM_ALLOWED_VECTOR:
+-                raise ValueError(
+-                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
+-                )
+-        kwargs = kwargs or {}
+-        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
+-
+-    def proj(self):
+-        """Form the projector from a given ket or bra vector.
+-
+-        Parameters
+-        ----------
+-        Q : :class:`qutip.Qobj`
+-            Input bra or ket vector
+-
+-        Returns
+-        -------
+-        P : :class:`qutip.Qobj`
+-            Projection operator.
+-        """
+-        if not (self.isket or self.isbra):
+-            raise TypeError("projection is only defined for bras and kets")
+-        dims = ([self.dims[0], self.dims[0]] if self.isket
+-                else [self.dims[1], self.dims[1]])
+-        return Qobj(_data.project(self._data),
+-                    dims=dims,
+-                    type='oper',
+-                    isherm=True,
+-                    copy=False)
+-
+-    def tr(self):
+-        """Trace of a quantum object.
+-
+-        Returns
+-        -------
+-        trace : float
+-            Returns the trace of the quantum object.
+-
+-        """
+-        out = _data.trace(self._data)
+-        # This ensures that trace can return something that is not a number such
+-        # as a `tensorflow.Tensor` in qutip-tensorflow.
+-        return out.real if (self.isherm
+-                        and hasattr(out, "real")
+-                        ) else out
+-
+-    def purity(self):
+-        """Calculate purity of a quantum object.
+-
+-        Returns
+-        -------
+-        state_purity : float
+-            Returns the purity of a quantum object.
+-            For a pure state, the purity is 1.
+-            For a mixed state of dimension `d`, 1/d<=purity<1.
+-
+-        """
+-        if self.type in ("super", "operator-ket", "operator-bra"):
+-            raise TypeError('purity is only defined for states.')
+-        if self.isket or self.isbra:
+-            return _data.norm.l2(self.data)**2
+-        return _data.trace(_data.matmul(self.data, self.data)).real
+-
+-    def full(self, order='C', squeeze=False):
+-        """Dense array from quantum object.
+-
+-        Parameters
+-        ----------
+-        order : str {'C', 'F'}
+-            Return array in C (default) or Fortran ordering.
+-        squeeze : bool {False, True}
+-            Squeeze output array.
+-
+-        Returns
+-        -------
+-        data : array
+-            Array of complex data from quantum objects `data` attribute.
+-        """
+-        out = np.asarray(self.data.to_array(), order=order)
+-        return out.squeeze() if squeeze else out
+-
+-    def diag(self):
+-        """Diagonal elements of quantum object.
+-
+-        Returns
+-        -------
+-        diags : array
+-            Returns array of ``real`` values if operators is Hermitian,
+-            otherwise ``complex`` values are returned.
+-        """
+-        # TODO: add a `diagonal` method to the data layer?
+-        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
+-        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
+-            return out
+-        else:
+-            return np.real(out)
+-
+-    def expm(self, dtype=_data.Dense):
+-        """Matrix exponential of quantum operator.
+-
+-        Input operator must be square.
+-
+-        Parameters
+-        ----------
+-        dtype : type
+-            The data-layer type that should be output.  As the matrix
+-            exponential is almost dense, this defaults to outputting dense
+-            matrices.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Exponentiated quantum operator.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Quantum operator is not square.
+-        """
+-        if self.dims[0] != self.dims[1]:
+-            raise TypeError("expm is only valid for square operators")
+-        return Qobj(_data.expm(self._data, dtype=dtype),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    copy=False)
+-
+-    def logm(self):
+-        """Matrix logarithm of quantum operator.
+-
+-        Input operator must be square.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Logarithm of the quantum operator.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Quantum operator is not square.
+-        """
+-        if self.dims[0] != self.dims[1]:
+-            raise TypeError("expm is only valid for square operators")
+-        return Qobj(_data.logm(self._data),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    isherm=self._isherm,
+-                    copy=False)
+-
+-    def check_herm(self):
+-        """Check if the quantum object is hermitian.
+-
+-        Returns
+-        -------
+-        isherm : bool
+-            Returns the new value of isherm property.
+-        """
+-        self._isherm = None
+-        return self.isherm
+-
+-    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
+-        """
+-        Sqrt of a quantum operator.  Operator must be square.
+-
+-        Parameters
+-        ----------
+-        sparse : bool
+-            Use sparse eigenvalue/vector solver.
+-        tol : float
+-            Tolerance used by sparse solver (0 = machine precision).
+-        maxiter : int
+-            Maximum number of iterations used by sparse solver.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Matrix square root of operator.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Quantum object is not square.
+-
+-        Notes
+-        -----
+-        The sparse eigensolver is much slower than the dense version.
+-        Use sparse only if memory requirements demand it.
+-        """
+-        if self.dims[0] != self.dims[1]:
+-            raise TypeError('sqrt only valid on square matrices')
+-        if isinstance(self.data, _data.CSR) and sparse:
+-            evals, evecs = _data.eigs_csr(self.data,
+-                                          isherm=self._isherm,
+-                                          tol=tol, maxiter=maxiter)
+-        elif isinstance(self.data, _data.CSR):
+-            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
+-                                      isherm=self._isherm)
+-        else:
+-            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
+-
+-        numevals = len(evals)
+-        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
+-        if self.isherm:
+-            spDv = _data.matmul(dV, evecs.conj().transpose())
+-        else:
+-            spDv = _data.matmul(dV, _data.inv(evecs))
+-        return Qobj(_data.matmul(evecs, spDv),
+-                    dims=self.dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    copy=False)
+-
+-    def cosm(self):
+-        """Cosine of a quantum operator.
+-
+-        Operator must be square.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Matrix cosine of operator.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Quantum object is not square.
+-
+-        Notes
+-        -----
+-        Uses the Q.expm() method.
+-
+-        """
+-        if self.dims[0] != self.dims[1]:
+-            raise TypeError('invalid operand for matrix cosine')
+-        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
+-
+-    def sinm(self):
+-        """Sine of a quantum operator.
+-
+-        Operator must be square.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Matrix sine of operator.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Quantum object is not square.
+-
+-        Notes
+-        -----
+-        Uses the Q.expm() method.
+-        """
+-        if self.dims[0] != self.dims[1]:
+-            raise TypeError('invalid operand for matrix sine')
+-        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
+-
+-    def inv(self, sparse=False):
+-        """Matrix inverse of a quantum operator
+-
+-        Operator must be square.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Matrix inverse of operator.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Quantum object is not square.
+-        """
+-        if self.data.shape[0] != self.data.shape[1]:
+-            raise TypeError('Invalid operand for matrix inverse')
+-        if isinstance(self.data, _data.CSR) and not sparse:
+-            data = _data.to(_data.Dense, self.data)
+-        else:
+-            data = self.data
+-
+-        return Qobj(_data.inv(data),
+-                    dims=[self.dims[1], self.dims[0]],
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    copy=False)
+-
+-    def unit(self, inplace=False, norm=None, kwargs=None):
+-        """
+-        Operator or state normalized to unity.  Uses norm from Qobj.norm().
+-
+-        Parameters
+-        ----------
+-        inplace : bool
+-            Do an in-place normalization
+-        norm : str
+-            Requested norm for states / operators.
+-        kwargs : dict
+-            Additional key-word arguments to be passed on to the relevant norm
+-            function (see :meth:`.norm` for more details).
+-
+-        Returns
+-        -------
+-        obj : :class:`qutip.Qobj`
+-            Normalized quantum object.  Will be the `self` object if in place.
+-        """
+-        norm = self.norm(norm=norm, kwargs=kwargs)
+-        if inplace:
+-            self.data = _data.mul(self.data, 1 / norm)
+-            self._isherm = self._isherm if norm.imag == 0 else None
+-            self._isunitary = (self._isunitary
+-                               if abs(norm) - 1 < settings.core['atol']
+-                               else None)
+-            out = self
+-        else:
+-            out = self / norm
+-        return out
+-
+-    def ptrace(self, sel, dtype=None):
+-        """
+-        Take the partial trace of the quantum object leaving the selected
+-        subspaces.  In other words, trace out all subspaces which are _not_
+-        passed.
+-
+-        This is typically a function which acts on operators; bras and kets
+-        will be promoted to density matrices before the operation takes place
+-        since the partial trace is inherently undefined on pure states.
+-
+-        For operators which are currently being represented as states in the
+-        superoperator formalism (i.e. the object has type `operator-ket` or
+-        `operator-bra`), the partial trace is applied as if the operator were
+-        in the conventional form.  This means that for any operator `x`,
+-        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
+-        and similar for `operator-bra`.
+-
+-        The story is different for full superoperators.  In the formalism that
+-        QuTiP uses, if an operator has dimensions (`dims`) of
+-        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
+-        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
+-        operator which acts on this joint space.  This function performs the
+-        partial trace on superoperators by letting the selected components
+-        refer to elements of the _joint_ _space_, and then returns a regular
+-        operator (of type `oper`).
+-
+-        Parameters
+-        ----------
+-        sel : int or iterable of int
+-            An ``int`` or ``list`` of components to keep after partial trace.
+-            The selected subspaces will _not_ be reordered, no matter order
+-            they are supplied to `ptrace`.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Quantum object representing partial trace with selected components
+-            remaining.
+-        """
+-        try:
+-            sel = sorted(sel)
+-        except TypeError:
+-            if not isinstance(sel, numbers.Integral):
+-                raise TypeError(
+-                    "selection must be an integer or list of integers"
+-                ) from None
+-            sel = [sel]
+-        if self.isoperket:
+-            dims = self.dims[0]
+-            data = vector_to_operator(self).data
+-        elif self.isoperbra:
+-            dims = self.dims[1]
+-            data = vector_to_operator(self.dag()).data
+-        elif self.issuper or self.isoper:
+-            dims = self.dims
+-            data = self.data
+-        else:
+-            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
+-            data = _data.project(self.data)
+-        if dims[0] != dims[1]:
+-            raise ValueError("partial trace is not defined on non-square maps")
+-        dims = flatten(dims[0])
+-        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
+-        new_dims = [[dims[x] for x in sel]] * 2
+-        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
+-        if self.isoperket:
+-            return operator_to_vector(out)
+-        if self.isoperbra:
+-            return operator_to_vector(out).dag()
+-        return out
+-
+-    def contract(self, inplace=False):
+-        """
+-        Contract subspaces of the tensor structure which are 1D.  Not defined
+-        on superoperators.  If all dimensions are scalar, a Qobj of dimension
+-        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
+-        contracted, but one is left.
+-
+-        Parameters
+-        ----------
+-        inplace: bool, optional
+-            If ``True``, modify the dimensions in place.  If ``False``, return
+-            a copied object.
+-
+-        Returns
+-        -------
+-        out: :class:`.Qobj`
+-            Quantum object with dimensions contracted.  Will be ``self`` if
+-            ``inplace`` is ``True``.
+-        """
+-        if self.isket:
+-            sub = [x for x in self.dims[0] if x > 1] or [1]
+-            dims = [sub, [1]*len(sub)]
+-        elif self.isbra:
+-            sub = [x for x in self.dims[1] if x > 1] or [1]
+-            dims = [[1]*len(sub), sub]
+-        elif self.isoper or self.isoperket or self.isoperbra:
+-            if self.isoper:
+-                oper_dims = self.dims
+-            elif self.isoperket:
+-                oper_dims = self.dims[0]
+-            else:
+-                oper_dims = self.dims[1]
+-            if len(oper_dims[0]) != len(oper_dims[1]):
+-                raise ValueError("cannot parse Qobj dimensions: "
+-                                 + repr(self.dims))
+-            dims_ = [
+-                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
+-                if x > 1 or y > 1
+-            ] or [(1, 1)]
+-            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
+-            if self.isoperket:
+-                dims = [dims, [1]]
+-            elif self.isoperbra:
+-                dims = [[1], dims]
+-        else:
+-            raise TypeError("not defined for superoperators")
+-        if inplace:
+-            self.dims = dims
+-            return self
+-        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
+-
+-    def permute(self, order):
+-        """
+-        Permute the tensor structure of a quantum object.  For example,
+-        ``qutip.tensor(x, y).permute([1, 0])``
+-        will give the same result as
+-        ``qutip.tensor(y, x)``
+-        and
+-        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
+-        will be the same as
+-        ``qutip.tensor(b, c, a)``
+-
+-        For regular objects (bras, kets and operators) we expect ``order`` to
+-        be a flat list of integers, which specifies the new order of the tensor
+-        product.
+-
+-        For superoperators, we expect ``order`` to be something like
+-        ``[[0, 2], [1, 3]]``
+-        which tells us to permute according to [0, 2, 1, 3], and then group
+-        indices according to the length of each sublist.  As another example,
+-        permuting a superoperator with dimensions of
+-        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
+-        by an ``order``
+-        ``[[0, 3], [1, 4], [2, 5]]``
+-        should give a new object with dimensions
+-        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
+-
+-        Parameters
+-        ----------
+-        order : list
+-            List of indices specifying the new tensor order.
+-
+-        Returns
+-        -------
+-        P : :class:`qutip.Qobj`
+-            Permuted quantum object.
+-        """
+-        if self.type in ('bra', 'ket', 'oper'):
+-            structure = self.dims[1] if self.isbra else self.dims[0]
+-            new_structure = [structure[x] for x in order]
+-            if self.isbra:
+-                dims = [self.dims[0], new_structure]
+-            elif self.isket:
+-                dims = [new_structure, self.dims[1]]
+-            else:
+-                if self.dims[0] != self.dims[1]:
+-                    raise TypeError("undefined for non-square operators")
+-                dims = [new_structure, new_structure]
+-            data = _data.permute.dimensions(self.data, structure, order)
+-            return Qobj(data,
+-                        dims=dims,
+-                        type=self.type,
+-                        isherm=self._isherm,
+-                        isunitary=self._isunitary,
+-                        copy=False)
+-        # If we've got here, we're some form of superoperator, so we work with
+-        # the flattened structure.
+-        flat_order = flatten(order)
+-        flat_structure = flatten(self.dims[1] if self.isoperbra
+-                                 else self.dims[0])
+-        new_structure = unflatten([flat_structure[x] for x in flat_order],
+-                                  enumerate_flat(order))
+-        if self.isoperbra:
+-            dims = [self.dims[0], new_structure]
+-        elif self.isoperket:
+-            dims = [new_structure, self.dims[1]]
+-        else:
+-            if self.dims[0] != self.dims[1]:
+-                raise TypeError("undefined for non-square operators")
+-            dims = [new_structure, new_structure]
+-        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
+-        return Qobj(data,
+-                    dims=dims,
+-                    type=self.type,
+-                    superrep=self.superrep,
+-                    copy=False)
+-
+-    def tidyup(self, atol=None):
+-        """
+-        Removes small elements from the quantum object.
+-
+-        Parameters
+-        ----------
+-        atol : float
+-            Absolute tolerance used by tidyup. Default is set
+-            via qutip global settings parameters.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Quantum object with small elements removed.
+-        """
+-        atol = atol or settings.core['auto_tidyup_atol']
+-        self.data = _data.tidyup(self.data, atol)
+-        return self
+-
+-    def transform(self, inpt, inverse=False):
+-        """Basis transform defined by input array.
+-
+-        Input array can be a ``matrix`` defining the transformation,
+-        or a ``list`` of kets that defines the new basis.
+-
+-        Parameters
+-        ----------
+-        inpt : array_like
+-            A ``matrix`` or ``list`` of kets defining the transformation.
+-        inverse : bool
+-            Whether to return inverse transformation.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            Operator in new basis.
+-
+-        Notes
+-        -----
+-        This function is still in development.
+-        """
+-        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
+-                                      inpt.ndim == 1):
+-            if len(inpt) != max(self.shape):
+-                raise TypeError(
+-                    'Invalid size of ket list for basis transformation')
+-            base = np.hstack([psi.full() for psi in inpt])
+-            S = _data.adjoint(_data.create(base))
+-        elif isinstance(inpt, Qobj) and inpt.isoper:
+-            S = inpt.data
+-        elif isinstance(inpt, np.ndarray):
+-            S = _data.create(inpt).conj()
+-        else:
+-            raise TypeError('Invalid operand for basis transformation')
+-
+-        # transform data
+-        if inverse:
+-            if self.isket:
+-                data = _data.matmul(S.adjoint(), self.data)
+-            elif self.isbra:
+-                data = _data.matmul(self.data, S)
+-            else:
+-                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
+-        else:
+-            if self.isket:
+-                data = _data.matmul(S, self.data)
+-            elif self.isbra:
+-                data = _data.matmul(self.data, S.adjoint())
+-            else:
+-                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
+-        return Qobj(data,
+-                    dims=self.dims,
+-                    type=self.type,
+-                    isherm=self._isherm,
+-                    superrep=self.superrep,
+-                    copy=False)
+-
+-    def trunc_neg(self, method="clip"):
+-        """Truncates negative eigenvalues and renormalizes.
+-
+-        Returns a new Qobj by removing the negative eigenvalues
+-        of this instance, then renormalizing to obtain a valid density
+-        operator.
+-
+-
+-        Parameters
+-        ----------
+-        method : str
+-            Algorithm to use to remove negative eigenvalues. "clip"
+-            simply discards negative eigenvalues, then renormalizes.
+-            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
+-            positive operator that is nearest in the Shatten 2-norm.
+-
+-        Returns
+-        -------
+-        oper : :class:`qutip.Qobj`
+-            A valid density operator.
+-        """
+-        if not self.isherm:
+-            raise ValueError("Must be a Hermitian operator to remove negative "
+-                             "eigenvalues.")
+-        if method not in ('clip', 'sgs'):
+-            raise ValueError("Method {} not recognized.".format(method))
+-
+-        eigvals, eigstates = self.eigenstates()
+-        if all(eigval >= 0 for eigval in eigvals):
+-            # All positive, so just renormalize.
+-            return self.unit()
+-        idx_nonzero = eigvals != 0
+-        eigvals = eigvals[idx_nonzero]
+-        eigstates = eigstates[idx_nonzero]
+-
+-        if method == 'clip':
+-            eigvals[eigvals < 0] = 0
+-        elif method == 'sgs':
+-            eigvals = eigvals[::-1]
+-            eigstates = eigstates[::-1]
+-            acc = 0.0
+-            n_eigs = len(eigvals)
+-            for idx in reversed(range(n_eigs)):
+-                if eigvals[idx] + acc / (idx + 1) >= 0:
+-                    break
+-                acc += eigvals[idx]
+-                eigvals[idx] = 0.0
+-            eigvals[:idx+1] += acc / (idx + 1)
+-        out_data = _data.zeros(*self.shape)
+-        for value, state in zip(eigvals, eigstates):
+-            if value:
+-                # add in 3-argument form is fused-add-multiply
+-                out_data = _data.add(out_data,
+-                                     _data.project(state.data),
+-                                     value)
+-        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
+-        return Qobj(out_data,
+-                    dims=self.dims.copy(),
+-                    type=self.type,
+-                    isherm=True,
+-                    copy=False)
+-
+-    def matrix_element(self, bra, ket):
+-        """Calculates a matrix element.
+-
+-        Gives the matrix element for the quantum object sandwiched between a
+-        `bra` and `ket` vector.
+-
+-        Parameters
+-        ----------
+-        bra : :class:`qutip.Qobj`
+-            Quantum object of type 'bra' or 'ket'
+-
+-        ket : :class:`qutip.Qobj`
+-            Quantum object of type 'ket'.
+-
+-        Returns
+-        -------
+-        elem : complex
+-            Complex valued matrix element.
+-
+-        Notes
+-        -----
+-        It is slightly more computationally efficient to use a ket
+-        vector for the 'bra' input.
+-
+-        """
+-        if not self.isoper:
+-            raise TypeError("Can only get matrix elements for an operator.")
+-        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
+-            msg = "Can only calculate matrix elements between a bra and a ket."
+-            raise TypeError(msg)
+-        left, op, right = bra.data, self.data, ket.data
+-        if ket.isbra:
+-            right = right.adjoint()
+-        return _data.inner_op(left, op, right, bra.isket)
+-
+-    def overlap(self, other):
+-        """
+-        Overlap between two state vectors or two operators.
+-
+-        Gives the overlap (inner product) between the current bra or ket Qobj
+-        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
+-        when one of the Qobj is an operator/density matrix.
+-
+-        Parameters
+-        ----------
+-        other : :class:`qutip.Qobj`
+-            Quantum object for a state vector of type 'ket', 'bra' or density
+-            matrix.
+-
+-        Returns
+-        -------
+-        overlap : complex
+-            Complex valued overlap.
+-
+-        Raises
+-        ------
+-        TypeError
+-            Can only calculate overlap between a bra, ket and density matrix
+-            quantum objects.
+-        """
+-        if not isinstance(other, Qobj):
+-            raise TypeError("".join([
+-                "cannot calculate overlap with non-quantum object ",
+-                repr(other),
+-            ]))
+-        if (
+-            self.type not in ('ket', 'bra', 'oper')
+-            or other.type not in ('ket', 'bra', 'oper')
+-        ):
+-            msg = "only bras, kets and density matrices have defined overlaps"
+-            raise TypeError(msg)
+-        left, right = self._data.adjoint(), other.data
+-        if self.isoper or other.isoper:
+-            if not self.isoper:
+-                left = _data.project(left)
+-            if not other.isoper:
+-                right = _data.project(right)
+-            return _data.trace(_data.matmul(left, right))
+-        if other.isbra:
+-            right = right.adjoint()
+-        out = _data.inner(left, right, self.isket)
+-        if self.isket and other.isbra:
+-            # In this particular case, we've basically doing
+-            #   conj(other.overlap(self))
+-            # so we take care to conjugate the output.
+-            out = np.conj(out)
+-        return out
+-
+-    def eigenstates(self, sparse=False, sort='low', eigvals=0,
+-                    tol=0, maxiter=100000, phase_fix=None):
+-        """Eigenstates and eigenenergies.
+-
+-        Eigenstates and eigenenergies are defined for operators and
+-        superoperators only.
+-
+-        Parameters
+-        ----------
+-        sparse : bool
+-            Use sparse Eigensolver
+-
+-        sort : str
+-            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
+-
+-        eigvals : int
+-            Number of requested eigenvalues. Default is all eigenvalues.
+-
+-        tol : float
+-            Tolerance used by sparse Eigensolver (0 = machine precision).
+-            The sparse solver may not converge if the tolerance is set too low.
+-
+-        maxiter : int
+-            Maximum number of iterations performed by sparse solver (if used).
+-
+-        phase_fix : int, None
+-            If not None, set the phase of each kets so that ket[phase_fix,0]
+-            is real positive.
+-
+-        Returns
+-        -------
+-        eigvals : array
+-            Array of eigenvalues for operator.
+-
+-        eigvecs : array
+-            Array of quantum operators representing the oprator eigenkets.
+-            Order of eigenkets is determined by order of eigenvalues.
+-
+-        Notes
+-        -----
+-        The sparse eigensolver is much slower than the dense version.
+-        Use sparse only if memory requirements demand it.
+-
+-        """
+-        if isinstance(self.data, _data.CSR) and sparse:
+-            evals, evecs = _data.eigs_csr(self.data,
+-                                          isherm=self._isherm,
+-                                          sort=sort, eigvals=eigvals, tol=tol,
+-                                          maxiter=maxiter)
+-        elif isinstance(self.data, _data.CSR):
+-            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
+-                                      isherm=self._isherm,
+-                                      sort=sort, eigvals=eigvals)
+-        else:
+-            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
+-                                      sort=sort, eigvals=eigvals)
+-
+-        if self.type == 'super':
+-            new_dims = [self.dims[0], [1]]
+-            new_type = 'operator-ket'
+-        else:
+-            new_dims = [self.dims[0], [1]*len(self.dims[0])]
+-            new_type = 'ket'
+-        ekets = np.empty((evecs.shape[1],), dtype=object)
+-        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
+-                    for vec in _data.split_columns(evecs, False)]
+-        norms = np.array([ket.norm() for ket in ekets])
+-        if phase_fix is None:
+-            phase = np.array([1] * len(ekets))
+-        else:
+-            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
+-                              if ket[phase_fix, 0] else 1
+-                              for ket in ekets])
+-        return evals, ekets / norms * phase
+-
+-    def eigenenergies(self, sparse=False, sort='low',
+-                      eigvals=0, tol=0, maxiter=100000):
+-        """Eigenenergies of a quantum object.
+-
+-        Eigenenergies (eigenvalues) are defined for operators or superoperators
+-        only.
+-
+-        Parameters
+-        ----------
+-        sparse : bool
+-            Use sparse Eigensolver
+-        sort : str
+-            Sort eigenvalues 'low' to high, or 'high' to low.
+-        eigvals : int
+-            Number of requested eigenvalues. Default is all eigenvalues.
+-        tol : float
+-            Tolerance used by sparse Eigensolver (0=machine precision).
+-            The sparse solver may not converge if the tolerance is set too low.
+-        maxiter : int
+-            Maximum number of iterations performed by sparse solver (if used).
+-
+-        Returns
+-        -------
+-        eigvals : array
+-            Array of eigenvalues for operator.
+-
+-        Notes
+-        -----
+-        The sparse eigensolver is much slower than the dense version.
+-        Use sparse only if memory requirements demand it.
+-
+-        """
+-        # TODO: consider another way of handling the dispatch here.
+-        if isinstance(self.data, _data.CSR) and sparse:
+-            return _data.eigs_csr(self.data,
+-                                  vecs=False,
+-                                  isherm=self._isherm,
+-                                  sort=sort, eigvals=eigvals,
+-                                  tol=tol, maxiter=maxiter)
+-        elif isinstance(self.data, _data.CSR):
+-            return _data.eigs(_data.to(_data.Dense, self.data),
+-                              vecs=False, isherm=self._isherm,
+-                              sort=sort, eigvals=eigvals)
+-
+-        return _data.eigs(self.data,
+-                          vecs=False,
+-                          isherm=self._isherm, sort=sort, eigvals=eigvals)
+-
+-    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
+-        """Ground state Eigenvalue and Eigenvector.
+-
+-        Defined for quantum operators or superoperators only.
+-
+-        Parameters
+-        ----------
+-        sparse : bool
+-            Use sparse Eigensolver
+-        tol : float
+-            Tolerance used by sparse Eigensolver (0 = machine precision).
+-            The sparse solver may not converge if the tolerance is set too low.
+-        maxiter : int
+-            Maximum number of iterations performed by sparse solver (if used).
+-        safe : bool (default=True)
+-            Check for degenerate ground state
+-
+-        Returns
+-        -------
+-        eigval : float
+-            Eigenvalue for the ground state of quantum operator.
+-        eigvec : :class:`qutip.Qobj`
+-            Eigenket for the ground state of quantum operator.
+-
+-        Notes
+-        -----
+-        The sparse eigensolver is much slower than the dense version.
+-        Use sparse only if memory requirements demand it.
+-        """
+-        eigvals = 2 if safe else 1
+-        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
+-                                        tol=tol, maxiter=maxiter)
+-
+-        if safe:
+-            tol = tol or settings.core['atol']
+-            # This tol should be less strick than the tol for the eigensolver
+-            # so it's numerical errors are not seens as degenerate states.
+-            if (evals[1]-evals[0]) <= 10 * tol:
+-                warnings.warn("Ground state may be degenerate.", UserWarning)
+-        return evals[0], evecs[0]
+-
+-    def dnorm(self, B=None):
+-        """Calculates the diamond norm, or the diamond distance to another
+-        operator.
+-
+-        Parameters
+-        ----------
+-        B : :class:`qutip.Qobj` or None
+-            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
+-            between this operator and B is returned instead of the diamond norm.
+-
+-        Returns
+-        -------
+-        d : float
+-            Either the diamond norm of this operator, or the diamond distance
+-            from this operator to B.
+-
+-        """
+-        return mts.dnorm(self, B)
+-
+-    @property
+-    def ishp(self):
+-        # FIXME: this needs to be cached in the same ways as isherm.
+-        if self.type in ["super", "oper"]:
+-            try:
+-                J = to_choi(self)
+-                return J.isherm
+-            except:
+-                return False
+-        else:
+-            return False
+-
+-    @property
+-    def iscp(self):
+-        # FIXME: this needs to be cached in the same ways as isherm.
+-        if self.type not in ["super", "oper"]:
+-            return False
+-        # We can test with either Choi or chi, since the basis
+-        # transformation between them is unitary and hence preserves
+-        # the CP and TP conditions.
+-        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
+-        # If J isn't hermitian, then that could indicate either that J is not
+-        # normal, or is normal, but has complex eigenvalues.  In either case,
+-        # it makes no sense to then demand that the eigenvalues be
+-        # non-negative.
+-        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
+-
+-    @property
+-    def istp(self):
+-        if self.type not in ['super', 'oper']:
+-            return False
+-        # Normalize to a super of type choi or chi.
+-        # We can test with either Choi or chi, since the basis
+-        # transformation between them is unitary and hence
+-        # preserves the CP and TP conditions.
+-        if self.issuper and self.superrep in ('choi', 'chi'):
+-            qobj = self
+-        else:
+-            qobj = to_choi(self)
+-        # Possibly collapse dims.
+-        if any([len(index) > 1
+-                for super_index in qobj.dims
+-                for index in super_index]):
+-            qobj = Qobj(qobj.data,
+-                        dims=collapse_dims_super(qobj.dims),
+-                        type=qobj.type,
+-                        superrep=qobj.superrep,
+-                        copy=False)
+-        # We use the condition from John Watrous' lecture notes,
+-        # Tr_1(J(Phi)) = identity_2.
+-        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
+-        # Theory of Quantum Information (Fall 2011), theorem 5.4.
+-        tr_oper = qobj.ptrace([0])
+-        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
+-                           atol=settings.core['atol'])
+-
+-    @property
+-    def iscptp(self):
+-        if not (self.issuper or self.isoper):
+-            return False
+-        reps = ('choi', 'chi')
+-        q_oper = to_choi(self) if self.superrep not in reps else self
+-        return q_oper.iscp and q_oper.istp
+-
+-    @property
+-    def isherm(self):
+-        if self._isherm is not None:
+-            return self._isherm
+-        self._isherm = _data.isherm(self._data)
+-        return self._isherm
+-
+-    @isherm.setter
+-    def isherm(self, isherm):
+-        self._isherm = isherm
+-
+-    def _calculate_isunitary(self):
+-        """
+-        Checks whether qobj is a unitary matrix
+-        """
+-        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
+-            return False
+-        cmp = _data.matmul(self._data, self._data.adjoint())
+-        iden = _data.identity(self.shape[0], dtype=type(cmp))
+-        return _data.iszero(_data.sub(cmp, iden),
+-                            tol=settings.core['atol'])
+-
+-    @property
+-    def isunitary(self):
+-        if self._isunitary is not None:
+-            return self._isunitary
+-        self._isunitary = self._calculate_isunitary()
+-        return self._isunitary
+-
+-    @property
+-    def shape(self): return self.data.shape
+-
+-    isbra = property(isbra)
+-    isket = property(isket)
+-    isoper = property(isoper)
+-    issuper = property(issuper)
+-    isoperbra = property(isoperbra)
+-    isoperket = property(isoperket)
+-
+-
+-def ptrace(Q, sel):
+-    """
+-    Partial trace of the Qobj with selected components remaining.
+-
+-    Parameters
+-    ----------
+-    Q : :class:`qutip.Qobj`
+-        Composite quantum object.
+-    sel : int/list
+-        An ``int`` or ``list`` of components to keep after partial trace.
+-
+-    Returns
+-    -------
+-    oper : :class:`qutip.Qobj`
+-        Quantum object representing partial trace with selected components
+-        remaining.
+-
+-    Notes
+-    -----
+-    This function is for legacy compatibility only. It is recommended to use
+-    the ``ptrace()`` Qobj method.
+-    """
+-    if not isinstance(Q, Qobj):
+-        raise TypeError("Input is not a quantum object")
+-    return Q.ptrace(sel)
+-
+-
+-# TRAILING IMPORTS
+-# We do a few imports here to avoid circular dependencies.
+-from qutip.core.superop_reps import to_choi
+-from qutip.core.superoperator import vector_to_operator, operator_to_vector
+-from qutip.core.tensor import tensor_swap, tensor
+-from qutip.core import metrics as mts
++"""The Quantum Object (Qobj) class, for representing quantum states and
++operators, and related functions.
++"""
++
++__all__ = [
++    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
++    'isherm', 'ptrace',
++]
++
++import functools
++import numbers
++import warnings
++
++import numpy as np
++import scipy.sparse
++
++from .. import __version__
++from ..settings import settings
++from . import data as _data
++from .dimensions import (
++    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
++)
++
++
++_ADJOINT_TYPE_LOOKUP = {
++    'oper': 'oper',
++    'super': 'super',
++    'ket': 'bra',
++    'bra': 'ket',
++    'operator-ket': 'operator-bra',
++    'operator-bra': 'operator-ket',
++}
++
++_MATMUL_TYPE_LOOKUP = {
++    ('oper', 'ket'): 'ket',
++    ('oper', 'oper'): 'oper',
++    ('ket', 'bra'): 'oper',
++    ('bra', 'oper'): 'bra',
++    ('super', 'super'): 'super',
++    ('super', 'operator-ket'): 'operator-ket',
++    ('operator-bra', 'super'): 'operator-bra',
++    ('operator-ket', 'operator-bra'): 'super',
++}
++
++_NORM_FUNCTION_LOOKUP = {
++    'tr': _data.norm.trace,
++    'one': _data.norm.one,
++    'max': _data.norm.max,
++    'fro': _data.norm.frobenius,
++    'l2': _data.norm.l2,
++}
++_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
++_NORM_ALLOWED_VECTOR = {'l2', 'max'}
++
++_CALL_ALLOWED = {
++    ('super', 'oper'),
++    ('super', 'ket'),
++    ('oper', 'ket'),
++}
++
++
++def isbra(x):
++    return isinstance(x, Qobj) and x.type == 'bra'
++
++
++def isket(x):
++    return isinstance(x, Qobj) and x.type == 'ket'
++
++
++def isoper(x):
++    return isinstance(x, Qobj) and x.type == 'oper'
++
++
++def isoperbra(x):
++    return isinstance(x, Qobj) and x.type == 'operator-bra'
++
++
++def isoperket(x):
++    return isinstance(x, Qobj) and x.type == 'operator-ket'
++
++
++def issuper(x):
++    return isinstance(x, Qobj) and x.type == 'super'
++
++
++def isherm(x):
++    return isinstance(x, Qobj) and x.isherm
++
++
++def _require_equal_type(method):
++    """
++    Decorate a binary Qobj method to ensure both operands are Qobj and of the
++    same type and dimensions.  Promote numeric scalar to identity matrices of
++    the same type and shape.
++    """
++    @functools.wraps(method)
++    def out(self, other):
++        if other == 0:
++            return method(self, other)
++        if (
++            self.type in ('oper', 'super')
++            and self.dims[0] == self.dims[1]
++            and isinstance(other, numbers.Number)
++        ):
++            scale = complex(other)
++            other = Qobj(_data.identity(self.shape[0], scale,
++                                        dtype=type(self.data)),
++                         dims=self.dims,
++                         type=self.type,
++                         superrep=self.superrep,
++                         isherm=(scale.imag == 0),
++                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
++                         copy=False)
++        if not isinstance(other, Qobj):
++            try:
++                other = Qobj(other, type=self.type)
++            except TypeError:
++                return NotImplemented
++        if self.dims != other.dims:
++            msg = (
++                "incompatible dimensions "
++                + repr(self.dims) + " and " + repr(other.dims)
++            )
++            raise ValueError(msg)
++        if self.type != other.type:
++            msg = "incompatible types " + self.type + " and " + other.type
++            raise ValueError(msg)
++        if self.superrep != other.superrep:
++            msg = (
++                "incompatible superoperator representations"
++                + self.superrep + " and " + other.superrep
++            )
++            raise ValueError(msg)
++        return method(self, other)
++    return out
++
++
++def _latex_real(x):
++    if not x:
++        return "0"
++    if not 0.001 <= abs(x) < 1000:
++        base, exp = "{:.3e}".format(x).split('e')
++        return base + r"\times10^{{ {:d} }}".format(int(exp))
++    if abs(x - int(x)) < 0.001:
++        return "{:d}".format(round(x))
++    return "{:.3f}".format(x)
++
++
++def _latex_complex(x):
++    if abs(x.imag) < 0.001:
++        return _latex_real(x.real)
++    if abs(x.real) < 0.001:
++        return _latex_real(x.imag) + "j"
++    sign = "+" if x.imag > 0 else "-"
++    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
++
++
++def _latex_row(row, cols, data):
++    if row is None:
++        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
++    else:
++        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
++                for col in cols)
++    return " & ".join(bits)
++
++
++class Qobj:
++    """
++    A class for representing quantum objects, such as quantum operators and
++    states.
++
++    The Qobj class is the QuTiP representation of quantum operators and state
++    vectors. This class also implements math operations +,-,* between Qobj
++    instances (and / by a C-number), as well as a collection of common
++    operator/state operations.  The Qobj constructor optionally takes a
++    dimension ``list`` and/or shape ``list`` as arguments.
++
++    Parameters
++    ----------
++    inpt: array_like
++        Data for vector/matrix representation of the quantum object.
++    dims: list
++        Dimensions of object used for tensor products.
++    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
++        The type of quantum object to be represented.
++    shape: list
++        Shape of underlying data structure (matrix shape).
++    copy: bool
++        Flag specifying whether Qobj should get a copy of the
++        input data, or use the original.
++
++
++    Attributes
++    ----------
++    data : array_like
++        Sparse matrix characterizing the quantum object.
++    dims : list
++        List of dimensions keeping track of the tensor structure.
++    shape : list
++        Shape of the underlying `data` array.
++    type : str
++        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
++        'operator-bra', or 'super'.
++    superrep : str
++        Representation used if `type` is 'super'. One of 'super'
++        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
++    isherm : bool
++        Indicates if quantum object represents Hermitian operator.
++    isunitary : bool
++        Indictaes if quantum object represents unitary operator.
++    iscp : bool
++        Indicates if the quantum object represents a map, and if that map is
++        completely positive (CP).
++    ishp : bool
++        Indicates if the quantum object represents a map, and if that map is
++        hermicity preserving (HP).
++    istp : bool
++        Indicates if the quantum object represents a map, and if that map is
++        trace preserving (TP).
++    iscptp : bool
++        Indicates if the quantum object represents a map that is completely
++        positive and trace preserving (CPTP).
++    isket : bool
++        Indicates if the quantum object represents a ket.
++    isbra : bool
++        Indicates if the quantum object represents a bra.
++    isoper : bool
++        Indicates if the quantum object represents an operator.
++    issuper : bool
++        Indicates if the quantum object represents a superoperator.
++    isoperket : bool
++        Indicates if the quantum object represents an operator in column vector
++        form.
++    isoperbra : bool
++        Indicates if the quantum object represents an operator in row vector
++        form.
++
++    Methods
++    -------
++    copy()
++        Create copy of Qobj
++    conj()
++        Conjugate of quantum object.
++    cosm()
++        Cosine of quantum object.
++    dag()
++        Adjoint (dagger) of quantum object.
++    dnorm()
++        Diamond norm of quantum operator.
++    dual_chan()
++        Dual channel of quantum object representing a CP map.
++    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
++        Returns eigenenergies (eigenvalues) of a quantum object.
++    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
++        Returns eigenenergies and eigenstates of quantum object.
++    expm()
++        Matrix exponential of quantum object.
++    full(order='C')
++        Returns dense array of quantum object `data` attribute.
++    groundstate(sparse=False, tol=0, maxiter=100000)
++        Returns eigenvalue and eigenket for the groundstate of a quantum
++        object.
++    inv()
++        Return a Qobj corresponding to the matrix inverse of the operator.
++    matrix_element(bra, ket)
++        Returns the matrix element of operator between `bra` and `ket` vectors.
++    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
++        Returns norm of a ket or an operator.
++    permute(order)
++        Returns composite qobj with indices reordered.
++    proj()
++        Computes the projector for a ket or bra vector.
++    ptrace(sel)
++        Returns quantum object for selected dimensions after performing
++        partial trace.
++    sinm()
++        Sine of quantum object.
++    sqrtm()
++        Matrix square root of quantum object.
++    tidyup(atol=1e-12)
++        Removes small elements from quantum object.
++    tr()
++        Trace of quantum object.
++    trans()
++        Transpose of quantum object.
++    transform(inpt, inverse=False)
++        Performs a basis transformation defined by `inpt` matrix.
++    trunc_neg(method='clip')
++        Removes negative eigenvalues and returns a new Qobj that is
++        a valid density operator.
++    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
++        Returns normalized quantum object.
++
++    """
++    # Disable ufuncs from acting directly on Qobj.
++    __array_ufunc__ = None
++
++    def _initialize_data(self, arg, dims, copy):
++        if isinstance(arg, _data.Data):
++            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
++            self._data = arg.copy() if copy else arg
++        elif isinstance(arg, Qobj):
++            self.dims = dims or arg.dims.copy()
++            self._data = arg.data.copy() if copy else arg.data
++        elif arg is None or isinstance(arg, numbers.Number):
++            self.dims = dims or [[1], [1]]
++            size = np.prod(self.dims[0])
++            if arg is None:
++                self._data = _data.zeros(size, size)
++            else:
++                self._data = _data.identity(size, scale=complex(arg))
++        else:
++            self._data = _data.create(arg, copy=copy)
++            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
++
++    def __init__(self, arg=None, dims=None, type=None,
++                 copy=True, superrep=None, isherm=None, isunitary=None):
++        self._initialize_data(arg, dims, copy)
++        self.type = type or type_from_dims(self.dims)
++        self._isherm = isherm
++        self._isunitary = isunitary
++
++        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
++            if self._data.shape[0] != self._data.shape[1]:
++                raise ValueError("".join([
++                    "cannot build superoperator from nonsquare data of shape ",
++                    repr(self._data.shape),
++                ]))
++            root = int(np.sqrt(self._data.shape[0]))
++            if root * root != self._data.shape[0]:
++                raise ValueError("".join([
++                    "cannot build superoperator from nonsquare subspaces ",
++                    "of size ",
++                    repr(self._data.shape[0]),
++                ]))
++            self.dims = [[[root]]*2]*2
++        if self.type in ['super', 'operator-ket', 'operator-bra']:
++            superrep = superrep or 'super'
++        self.superrep = superrep
++
++    def copy(self):
++        """Create identical copy"""
++        return Qobj(arg=self._data,
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=True)
++
++    @property
++    def data(self):
++        return self._data
++
++    @data.setter
++    def data(self, data):
++        if not isinstance(data, _data.Data):
++            raise TypeError('Qobj data must be a data-layer format.')
++        self._data = data
++
++    def to(self, data_type):
++        """
++        Convert the underlying data store of this `Qobj` into a different
++        storage representation.
++
++        The different storage representations available are the "data-layer
++        types" which are known to `qutip.data.to`.  By default, these are
++        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
++        dense matrix store and a compressed sparse row one.  Certain algorithms
++        and operations may be faster or more accurate when using a more
++        appropriate data store.
++
++        If the data store is already in the format requested, the function
++        returns `self`.  Otherwise, it returns a copy of itself with the data
++        store in the new type.
++
++        Parameters
++        ----------
++        data_type : type
++            The data-layer type that the data of this `Qobj` should be
++            converted to.
++
++        Returns
++        -------
++        Qobj
++            A new `Qobj` if a type conversion took place with the data stored
++            in the requested format, or `self` if not.
++        """
++        try:
++            converter = _data.to[data_type]
++        except (KeyError, TypeError):
++            raise ValueError("Unknown conversion type: " + str(data_type))
++        if type(self.data) is data_type:
++            return self
++        return Qobj(converter(self._data),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=False)
++
++    @_require_equal_type
++    def __add__(self, other):
++        if other == 0:
++            return self.copy()
++        isherm = (self._isherm and other._isherm) or None
++        return Qobj(_data.add(self._data, other._data),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=isherm,
++                    copy=False)
++
++    def __radd__(self, other):
++        return self.__add__(other)
++
++    @_require_equal_type
++    def __sub__(self, other):
++        if other == 0:
++            return self.copy()
++        isherm = (self._isherm and other._isherm) or None
++        return Qobj(_data.sub(self._data, other._data),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=isherm,
++                    copy=False)
++
++    def __rsub__(self, other):
++        return self.__neg__().__add__(other)
++
++    def __mul__(self, other):
++        """
++        If other is a Qobj, we dispatch to __matmul__. If not, we
++        check that other is a valid complex scalar, i.e., we can do
++        complex(other). Otherwise, we return NotImplemented.
++        """
++
++        if isinstance(other, Qobj):
++            return self.__matmul__(other)
++
++        # We send other to mul instead of complex(other) to be more flexible.
++        # The dispatcher can then decide how to handle other and return
++        # TypeError if it does not know what to do with the type of other.
++        try:
++            out = _data.mul(self._data, other)
++        except TypeError:
++            return NotImplemented
++
++        # Infer isherm and isunitary if possible
++        try:
++            multiplier = complex(other)
++            isherm = (self._isherm and multiplier.imag == 0) or None
++            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
++                         if self._isunitary else None)
++        except TypeError:
++            isherm = None
++            isunitary = None
++
++        return Qobj(out,
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=isherm,
++                    isunitary=isunitary,
++                    copy=False)
++
++    def __rmul__(self, other):
++        # Shouldn't be here unless `other.__mul__` has already been tried, so
++        # we _shouldn't_ check that `other` is `Qobj`.
++        return self.__mul__(other)
++
++    def __matmul__(self, other):
++        if not isinstance(other, Qobj):
++            try:
++                other = Qobj(other)
++            except TypeError:
++                return NotImplemented
++        if self.dims[1] != other.dims[0]:
++            raise TypeError("".join([
++                "incompatible dimensions ",
++                repr(self.dims),
++                " and ",
++                repr(other.dims),
++            ]))
++        if self.superrep != other.superrep:
++            raise TypeError("".join([
++                "incompatible superoperator representations ",
++                repr(self.superrep),
++                " and ",
++                repr(other.superrep),
++            ]))
++        if (
++            (self.isbra and other.isket)
++            or (self.isoperbra and other.isoperket)
++        ):
++            return _data.inner(self.data, other.data)
++
++        try:
++            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
++        except KeyError:
++            raise TypeError(
++                "incompatible matmul types "
++                + repr(self.type) + " and " + repr(other.type)
++            ) from None
++        return Qobj(_data.matmul(self.data, other.data),
++                    dims=[self.dims[0], other.dims[1]],
++                    type=type_,
++                    isunitary=self._isunitary and other._isunitary,
++                    superrep=self.superrep,
++                    copy=False)
++
++    def __truediv__(self, other):
++        return self.__mul__(1 / other)
++
++    def __neg__(self):
++        return Qobj(_data.neg(self._data),
++                    dims=self.dims.copy(),
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=False)
++
++    def __getitem__(self, ind):
++        # TODO: should we require that data-layer types implement this?  This
++        # isn't the right way of handling it, for sure.
++        if isinstance(self._data, _data.CSR):
++            data = self._data.as_scipy()
++        elif isinstance(self._data, _data.Dense):
++            data = self._data.as_ndarray()
++        else:
++            data = self._data
++        try:
++            out = data[ind]
++            return out.toarray() if scipy.sparse.issparse(out) else out
++        except TypeError:
++            pass
++        return data.to_array()[ind]
++
++    def __eq__(self, other):
++        if self is other:
++            return True
++        if not isinstance(other, Qobj) or self.dims != other.dims:
++            return False
++        return _data.iszero(_data.sub(self._data, other._data),
++                            tol=settings.core['atol'])
++
++    def __pow__(self, n, m=None):  # calculates powers of Qobj
++        if (
++            self.type not in ('oper', 'super')
++            or self.dims[0] != self.dims[1]
++            or m is not None
++            or not isinstance(n, numbers.Integral)
++            or n < 0
++        ):
++            return NotImplemented
++        return Qobj(_data.pow(self._data, n),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=False)
++
++    def _str_header(self):
++        out = ", ".join([
++            "Quantum object: dims=" + str(self.dims),
++            "shape=" + str(self.data.shape),
++            "type=" + repr(self.type),
++        ])
++        if self.type in ('oper', 'super'):
++            out += ", isherm=" + str(self.isherm)
++        if self.issuper and self.superrep != 'super':
++            out += ", superrep=" + repr(self.superrep)
++        return out
++
++    def __str__(self):
++        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
++            # If the system is huge, don't attempt to convert to a dense matrix
++            # and then to string, because it is pointless and is likely going
++            # to produce memory errors. Instead print the sparse data string
++            # representation.
++            data = _data.to(_data.CSR, self.data).as_scipy()
++        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
++            data = np.real(self.full())
++        else:
++            data = self.full()
++        return self._str_header() + "\nQobj data =\n" + str(data)
++
++    def __repr__(self):
++        # give complete information on Qobj without print statement in
++        # command-line we cant realistically serialize a Qobj into a string,
++        # so we simply return the informal __str__ representation instead.)
++        return self.__str__()
++
++    def __call__(self, other):
++        """
++        Acts this Qobj on another Qobj either by left-multiplication,
++        or by vectorization and devectorization, as
++        appropriate.
++        """
++        if not isinstance(other, Qobj):
++            raise TypeError("Only defined for quantum objects.")
++        if (self.type, other.type) not in _CALL_ALLOWED:
++            raise TypeError(self.type + " cannot act on " + other.type)
++        if self.issuper:
++            if other.isket:
++                other = other.proj()
++            return vector_to_operator(self @ operator_to_vector(other))
++        return self.__matmul__(other)
++
++    def __getstate__(self):
++        # defines what happens when Qobj object gets pickled
++        self.__dict__.update({'qutip_version': __version__[:5]})
++        return self.__dict__
++
++    def __setstate__(self, state):
++        # defines what happens when loading a pickled Qobj
++        if 'qutip_version' in state.keys():
++            del state['qutip_version']
++        (self.__dict__).update(state)
++
++    def _repr_latex_(self):
++        """
++        Generate a LaTeX representation of the Qobj instance. Can be used for
++        formatted output in ipython notebook.
++        """
++        half_length = 5
++        n_rows, n_cols = self.data.shape
++        # Choose which rows and columns we're going to output, or None if that
++        # element should be truncated.
++        rows = list(range(min((half_length, n_rows))))
++        if n_rows <= half_length * 2:
++            rows += list(range(half_length, min((2*half_length, n_rows))))
++        else:
++            rows.append(None)
++            rows += list(range(n_rows - half_length, n_rows))
++        cols = list(range(min((half_length, n_cols))))
++        if n_cols <= half_length * 2:
++            cols += list(range(half_length, min((2*half_length, n_cols))))
++        else:
++            cols.append(None)
++            cols += list(range(n_cols - half_length, n_cols))
++        # Make the data array.
++        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
++        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
++                           for row in rows)
++        data += r'\end{array}\right)\end{equation*}'
++        return self._str_header() + data
++
++    def __and__(self, other):
++        """
++        Syntax shortcut for tensor:
++        A & B ==> tensor(A, B)
++        """
++        return tensor(self, other)
++
++    def dag(self):
++        """Get the Hermitian adjoint of the quantum object."""
++        if self._isherm:
++            return self.copy()
++        return Qobj(_data.adjoint(self._data),
++                    dims=[self.dims[1], self.dims[0]],
++                    type=_ADJOINT_TYPE_LOOKUP[self.type],
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=False)
++
++    def conj(self):
++        """Get the element-wise conjugation of the quantum object."""
++        return Qobj(_data.conj(self._data),
++                    dims=self.dims.copy(),
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=False)
++
++    def trans(self):
++        """Get the matrix transpose of the quantum operator.
++
++        Returns
++        -------
++        oper : :class:`.Qobj`
++            Transpose of input operator.
++        """
++        return Qobj(_data.transpose(self._data),
++                    dims=[self.dims[1], self.dims[0]],
++                    type=_ADJOINT_TYPE_LOOKUP[self.type],
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    isunitary=self._isunitary,
++                    copy=False)
++
++    def dual_chan(self):
++        """Dual channel of quantum object representing a completely positive
++        map.
++        """
++        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
++        # is only valid for completely positive maps.
++        if not self.iscp:
++            raise ValueError("Dual channels are only implemented for CP maps.")
++        J = to_choi(self)
++        tensor_idxs = enumerate_flat(J.dims)
++        J_dual = tensor_swap(J, *(
++                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
++                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
++        )).trans()
++        J_dual.superrep = 'choi'
++        return J_dual
++
++    def norm(self, norm=None, kwargs=None):
++        """
++        Norm of a quantum object.
++
++        Default norm is L2-norm for kets and trace-norm for operators.  Other
++        ket and operator norms may be specified using the `norm` parameter.
++
++        Parameters
++        ----------
++        norm : str
++            Which type of norm to use.  Allowed values for vectors are 'l2' and
++            'max'.  Allowed values for matrices are 'tr' for the trace norm,
++            'fro' for the Frobenius norm, 'one' and 'max'.
++
++        kwargs : dict
++            Additional keyword arguments to pass on to the relevant norm
++            solver.  See details for each norm function in :mod:`.data.norm`.
++
++        Returns
++        -------
++        norm : float
++            The requested norm of the operator or state quantum object.
++        """
++        if self.type in ('oper', 'super'):
++            norm = norm or 'tr'
++            if norm not in _NORM_ALLOWED_MATRIX:
++                raise ValueError(
++                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
++                )
++        else:
++            norm = norm or 'l2'
++            if norm not in _NORM_ALLOWED_VECTOR:
++                raise ValueError(
++                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
++                )
++        kwargs = kwargs or {}
++        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
++
++    def proj(self):
++        """Form the projector from a given ket or bra vector.
++
++        Parameters
++        ----------
++        Q : :class:`qutip.Qobj`
++            Input bra or ket vector
++
++        Returns
++        -------
++        P : :class:`qutip.Qobj`
++            Projection operator.
++        """
++        if not (self.isket or self.isbra):
++            raise TypeError("projection is only defined for bras and kets")
++        dims = ([self.dims[0], self.dims[0]] if self.isket
++                else [self.dims[1], self.dims[1]])
++        return Qobj(_data.project(self._data),
++                    dims=dims,
++                    type='oper',
++                    isherm=True,
++                    copy=False)
++
++    def tr(self):
++        """Trace of a quantum object.
++
++        Returns
++        -------
++        trace : float
++            Returns the trace of the quantum object.
++
++        """
++        out = _data.trace(self._data)
++        # This ensures that trace can return something that is not a number such
++        # as a `tensorflow.Tensor` in qutip-tensorflow.
++        return out.real if (self.isherm
++                        and hasattr(out, "real")
++                        ) else out
++
++    def purity(self):
++        """Calculate purity of a quantum object.
++
++        Returns
++        -------
++        state_purity : float
++            Returns the purity of a quantum object.
++            For a pure state, the purity is 1.
++            For a mixed state of dimension `d`, 1/d<=purity<1.
++
++        """
++        if self.type in ("super", "operator-ket", "operator-bra"):
++            raise TypeError('purity is only defined for states.')
++        if self.isket or self.isbra:
++            return _data.norm.l2(self.data)**2
++        return _data.trace(_data.matmul(self.data, self.data)).real
++
++    def full(self, order='C', squeeze=False):
++        """Dense array from quantum object.
++
++        Parameters
++        ----------
++        order : str {'C', 'F'}
++            Return array in C (default) or Fortran ordering.
++        squeeze : bool {False, True}
++            Squeeze output array.
++
++        Returns
++        -------
++        data : array
++            Array of complex data from quantum objects `data` attribute.
++        """
++        out = np.asarray(self.data.to_array(), order=order)
++        return out.squeeze() if squeeze else out
++
++    def diag(self):
++        """Diagonal elements of quantum object.
++
++        Returns
++        -------
++        diags : array
++            Returns array of ``real`` values if operators is Hermitian,
++            otherwise ``complex`` values are returned.
++        """
++        # TODO: add a `diagonal` method to the data layer?
++        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
++        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
++            return out
++        else:
++            return np.real(out)
++
++    def expm(self, dtype=_data.Dense):
++        """Matrix exponential of quantum operator.
++
++        Input operator must be square.
++
++        Parameters
++        ----------
++        dtype : type
++            The data-layer type that should be output.  As the matrix
++            exponential is almost dense, this defaults to outputting dense
++            matrices.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Exponentiated quantum operator.
++
++        Raises
++        ------
++        TypeError
++            Quantum operator is not square.
++        """
++        if self.dims[0] != self.dims[1]:
++            raise TypeError("expm is only valid for square operators")
++        return Qobj(_data.expm(self._data, dtype=dtype),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    copy=False)
++
++    def logm(self):
++        """Matrix logarithm of quantum operator.
++
++        Input operator must be square.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Logarithm of the quantum operator.
++
++        Raises
++        ------
++        TypeError
++            Quantum operator is not square.
++        """
++        if self.dims[0] != self.dims[1]:
++            raise TypeError("expm is only valid for square operators")
++        return Qobj(_data.logm(self._data),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    isherm=self._isherm,
++                    copy=False)
++
++    def check_herm(self):
++        """Check if the quantum object is hermitian.
++
++        Returns
++        -------
++        isherm : bool
++            Returns the new value of isherm property.
++        """
++        self._isherm = None
++        return self.isherm
++
++    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
++        """
++        Sqrt of a quantum operator.  Operator must be square.
++
++        Parameters
++        ----------
++        sparse : bool
++            Use sparse eigenvalue/vector solver.
++        tol : float
++            Tolerance used by sparse solver (0 = machine precision).
++        maxiter : int
++            Maximum number of iterations used by sparse solver.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Matrix square root of operator.
++
++        Raises
++        ------
++        TypeError
++            Quantum object is not square.
++
++        Notes
++        -----
++        The sparse eigensolver is much slower than the dense version.
++        Use sparse only if memory requirements demand it.
++        """
++        if self.dims[0] != self.dims[1]:
++            raise TypeError('sqrt only valid on square matrices')
++        if isinstance(self.data, _data.CSR) and sparse:
++            evals, evecs = _data.eigs_csr(self.data,
++                                          isherm=self._isherm,
++                                          tol=tol, maxiter=maxiter)
++        elif isinstance(self.data, _data.CSR):
++            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
++                                      isherm=self._isherm)
++        else:
++            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
++
++        numevals = len(evals)
++        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
++        if self.isherm:
++            spDv = _data.matmul(dV, evecs.conj().transpose())
++        else:
++            spDv = _data.matmul(dV, _data.inv(evecs))
++        return Qobj(_data.matmul(evecs, spDv),
++                    dims=self.dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    copy=False)
++
++    def cosm(self):
++        """Cosine of a quantum operator.
++
++        Operator must be square.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Matrix cosine of operator.
++
++        Raises
++        ------
++        TypeError
++            Quantum object is not square.
++
++        Notes
++        -----
++        Uses the Q.expm() method.
++
++        """
++        if self.dims[0] != self.dims[1]:
++            raise TypeError('invalid operand for matrix cosine')
++        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
++
++    def sinm(self):
++        """Sine of a quantum operator.
++
++        Operator must be square.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Matrix sine of operator.
++
++        Raises
++        ------
++        TypeError
++            Quantum object is not square.
++
++        Notes
++        -----
++        Uses the Q.expm() method.
++        """
++        if self.dims[0] != self.dims[1]:
++            raise TypeError('invalid operand for matrix sine')
++        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
++
++    def inv(self, sparse=False):
++        """Matrix inverse of a quantum operator
++
++        Operator must be square.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Matrix inverse of operator.
++
++        Raises
++        ------
++        TypeError
++            Quantum object is not square.
++        """
++        if self.data.shape[0] != self.data.shape[1]:
++            raise TypeError('Invalid operand for matrix inverse')
++        if isinstance(self.data, _data.CSR) and not sparse:
++            data = _data.to(_data.Dense, self.data)
++        else:
++            data = self.data
++
++        return Qobj(_data.inv(data),
++                    dims=[self.dims[1], self.dims[0]],
++                    type=self.type,
++                    superrep=self.superrep,
++                    copy=False)
++
++    def unit(self, inplace=False, norm=None, kwargs=None):
++        """
++        Operator or state normalized to unity.  Uses norm from Qobj.norm().
++
++        Parameters
++        ----------
++        inplace : bool
++            Do an in-place normalization
++        norm : str
++            Requested norm for states / operators.
++        kwargs : dict
++            Additional key-word arguments to be passed on to the relevant norm
++            function (see :meth:`.norm` for more details).
++
++        Returns
++        -------
++        obj : :class:`qutip.Qobj`
++            Normalized quantum object.  Will be the `self` object if in place.
++        """
++        norm = self.norm(norm=norm, kwargs=kwargs)
++        if inplace:
++            self.data = _data.mul(self.data, 1 / norm)
++            self._isherm = self._isherm if norm.imag == 0 else None
++            self._isunitary = (self._isunitary
++                               if abs(norm) - 1 < settings.core['atol']
++                               else None)
++            out = self
++        else:
++            out = self / norm
++        return out
++
++    def ptrace(self, sel, dtype=None):
++        """
++        Take the partial trace of the quantum object leaving the selected
++        subspaces.  In other words, trace out all subspaces which are _not_
++        passed.
++
++        This is typically a function which acts on operators; bras and kets
++        will be promoted to density matrices before the operation takes place
++        since the partial trace is inherently undefined on pure states.
++
++        For operators which are currently being represented as states in the
++        superoperator formalism (i.e. the object has type `operator-ket` or
++        `operator-bra`), the partial trace is applied as if the operator were
++        in the conventional form.  This means that for any operator `x`,
++        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
++        and similar for `operator-bra`.
++
++        The story is different for full superoperators.  In the formalism that
++        QuTiP uses, if an operator has dimensions (`dims`) of
++        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
++        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
++        operator which acts on this joint space.  This function performs the
++        partial trace on superoperators by letting the selected components
++        refer to elements of the _joint_ _space_, and then returns a regular
++        operator (of type `oper`).
++
++        Parameters
++        ----------
++        sel : int or iterable of int
++            An ``int`` or ``list`` of components to keep after partial trace.
++            The selected subspaces will _not_ be reordered, no matter order
++            they are supplied to `ptrace`.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Quantum object representing partial trace with selected components
++            remaining.
++        """
++        try:
++            sel = sorted(sel)
++        except TypeError:
++            if not isinstance(sel, numbers.Integral):
++                raise TypeError(
++                    "selection must be an integer or list of integers"
++                ) from None
++            sel = [sel]
++        if self.isoperket:
++            dims = self.dims[0]
++            data = vector_to_operator(self).data
++        elif self.isoperbra:
++            dims = self.dims[1]
++            data = vector_to_operator(self.dag()).data
++        elif self.issuper or self.isoper:
++            dims = self.dims
++            data = self.data
++        else:
++            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
++            data = _data.project(self.data)
++        if dims[0] != dims[1]:
++            raise ValueError("partial trace is not defined on non-square maps")
++        dims = flatten(dims[0])
++        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
++        new_dims = [[dims[x] for x in sel]] * 2
++        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
++        if self.isoperket:
++            return operator_to_vector(out)
++        if self.isoperbra:
++            return operator_to_vector(out).dag()
++        return out
++
++    def contract(self, inplace=False):
++        """
++        Contract subspaces of the tensor structure which are 1D.  Not defined
++        on superoperators.  If all dimensions are scalar, a Qobj of dimension
++        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
++        contracted, but one is left.
++
++        Parameters
++        ----------
++        inplace: bool, optional
++            If ``True``, modify the dimensions in place.  If ``False``, return
++            a copied object.
++
++        Returns
++        -------
++        out: :class:`.Qobj`
++            Quantum object with dimensions contracted.  Will be ``self`` if
++            ``inplace`` is ``True``.
++        """
++        if self.isket:
++            sub = [x for x in self.dims[0] if x > 1] or [1]
++            dims = [sub, [1]*len(sub)]
++        elif self.isbra:
++            sub = [x for x in self.dims[1] if x > 1] or [1]
++            dims = [[1]*len(sub), sub]
++        elif self.isoper or self.isoperket or self.isoperbra:
++            if self.isoper:
++                oper_dims = self.dims
++            elif self.isoperket:
++                oper_dims = self.dims[0]
++            else:
++                oper_dims = self.dims[1]
++            if len(oper_dims[0]) != len(oper_dims[1]):
++                raise ValueError("cannot parse Qobj dimensions: "
++                                 + repr(self.dims))
++            dims_ = [
++                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
++                if x > 1 or y > 1
++            ] or [(1, 1)]
++            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
++            if self.isoperket:
++                dims = [dims, [1]]
++            elif self.isoperbra:
++                dims = [[1], dims]
++        else:
++            raise TypeError("not defined for superoperators")
++        if inplace:
++            self.dims = dims
++            return self
++        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
++
++    def permute(self, order):
++        """
++        Permute the tensor structure of a quantum object.  For example,
++        ``qutip.tensor(x, y).permute([1, 0])``
++        will give the same result as
++        ``qutip.tensor(y, x)``
++        and
++        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
++        will be the same as
++        ``qutip.tensor(b, c, a)``
++
++        For regular objects (bras, kets and operators) we expect ``order`` to
++        be a flat list of integers, which specifies the new order of the tensor
++        product.
++
++        For superoperators, we expect ``order`` to be something like
++        ``[[0, 2], [1, 3]]``
++        which tells us to permute according to [0, 2, 1, 3], and then group
++        indices according to the length of each sublist.  As another example,
++        permuting a superoperator with dimensions of
++        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
++        by an ``order``
++        ``[[0, 3], [1, 4], [2, 5]]``
++        should give a new object with dimensions
++        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
++
++        Parameters
++        ----------
++        order : list
++            List of indices specifying the new tensor order.
++
++        Returns
++        -------
++        P : :class:`qutip.Qobj`
++            Permuted quantum object.
++        """
++        if self.type in ('bra', 'ket', 'oper'):
++            structure = self.dims[1] if self.isbra else self.dims[0]
++            new_structure = [structure[x] for x in order]
++            if self.isbra:
++                dims = [self.dims[0], new_structure]
++            elif self.isket:
++                dims = [new_structure, self.dims[1]]
++            else:
++                if self.dims[0] != self.dims[1]:
++                    raise TypeError("undefined for non-square operators")
++                dims = [new_structure, new_structure]
++            data = _data.permute.dimensions(self.data, structure, order)
++            return Qobj(data,
++                        dims=dims,
++                        type=self.type,
++                        isherm=self._isherm,
++                        isunitary=self._isunitary,
++                        copy=False)
++        # If we've got here, we're some form of superoperator, so we work with
++        # the flattened structure.
++        flat_order = flatten(order)
++        flat_structure = flatten(self.dims[1] if self.isoperbra
++                                 else self.dims[0])
++        new_structure = unflatten([flat_structure[x] for x in flat_order],
++                                  enumerate_flat(order))
++        if self.isoperbra:
++            dims = [self.dims[0], new_structure]
++        elif self.isoperket:
++            dims = [new_structure, self.dims[1]]
++        else:
++            if self.dims[0] != self.dims[1]:
++                raise TypeError("undefined for non-square operators")
++            dims = [new_structure, new_structure]
++        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
++        return Qobj(data,
++                    dims=dims,
++                    type=self.type,
++                    superrep=self.superrep,
++                    copy=False)
++
++    def tidyup(self, atol=None):
++        """
++        Removes small elements from the quantum object.
++
++        Parameters
++        ----------
++        atol : float
++            Absolute tolerance used by tidyup. Default is set
++            via qutip global settings parameters.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Quantum object with small elements removed.
++        """
++        atol = atol or settings.core['auto_tidyup_atol']
++        self.data = _data.tidyup(self.data, atol)
++        return self
++
++    def transform(self, inpt, inverse=False):
++        """Basis transform defined by input array.
++
++        Input array can be a ``matrix`` defining the transformation,
++        or a ``list`` of kets that defines the new basis.
++
++        Parameters
++        ----------
++        inpt : array_like
++            A ``matrix`` or ``list`` of kets defining the transformation.
++        inverse : bool
++            Whether to return inverse transformation.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            Operator in new basis.
++
++        Notes
++        -----
++        This function is still in development.
++        """
++        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
++                                      inpt.ndim == 1):
++            if len(inpt) != max(self.shape):
++                raise TypeError(
++                    'Invalid size of ket list for basis transformation')
++            base = np.hstack([psi.full() for psi in inpt])
++            S = _data.adjoint(_data.create(base))
++        elif isinstance(inpt, Qobj) and inpt.isoper:
++            S = inpt.data
++        elif isinstance(inpt, np.ndarray):
++            S = _data.create(inpt).conj()
++        else:
++            raise TypeError('Invalid operand for basis transformation')
++
++        # transform data
++        if inverse:
++            if self.isket:
++                data = _data.matmul(S.adjoint(), self.data)
++            elif self.isbra:
++                data = _data.matmul(self.data, S)
++            else:
++                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
++        else:
++            if self.isket:
++                data = _data.matmul(S, self.data)
++            elif self.isbra:
++                data = _data.matmul(self.data, S.adjoint())
++            else:
++                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
++        return Qobj(data,
++                    dims=self.dims,
++                    type=self.type,
++                    isherm=self._isherm,
++                    superrep=self.superrep,
++                    copy=False)
++
++    def trunc_neg(self, method="clip"):
++        """Truncates negative eigenvalues and renormalizes.
++
++        Returns a new Qobj by removing the negative eigenvalues
++        of this instance, then renormalizing to obtain a valid density
++        operator.
++
++
++        Parameters
++        ----------
++        method : str
++            Algorithm to use to remove negative eigenvalues. "clip"
++            simply discards negative eigenvalues, then renormalizes.
++            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
++            positive operator that is nearest in the Shatten 2-norm.
++
++        Returns
++        -------
++        oper : :class:`qutip.Qobj`
++            A valid density operator.
++        """
++        if not self.isherm:
++            raise ValueError("Must be a Hermitian operator to remove negative "
++                             "eigenvalues.")
++        if method not in ('clip', 'sgs'):
++            raise ValueError("Method {} not recognized.".format(method))
++
++        eigvals, eigstates = self.eigenstates()
++        if all(eigval >= 0 for eigval in eigvals):
++            # All positive, so just renormalize.
++            return self.unit()
++        idx_nonzero = eigvals != 0
++        eigvals = eigvals[idx_nonzero]
++        eigstates = eigstates[idx_nonzero]
++
++        if method == 'clip':
++            eigvals[eigvals < 0] = 0
++        elif method == 'sgs':
++            eigvals = eigvals[::-1]
++            eigstates = eigstates[::-1]
++            acc = 0.0
++            n_eigs = len(eigvals)
++            for idx in reversed(range(n_eigs)):
++                if eigvals[idx] + acc / (idx + 1) >= 0:
++                    break
++                acc += eigvals[idx]
++                eigvals[idx] = 0.0
++            eigvals[:idx+1] += acc / (idx + 1)
++        out_data = _data.zeros(*self.shape)
++        for value, state in zip(eigvals, eigstates):
++            if value:
++                # add in 3-argument form is fused-add-multiply
++                out_data = _data.add(out_data,
++                                     _data.project(state.data),
++                                     value)
++        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
++        return Qobj(out_data,
++                    dims=self.dims.copy(),
++                    type=self.type,
++                    isherm=True,
++                    copy=False)
++
++    def matrix_element(self, bra, ket):
++        """Calculates a matrix element.
++
++        Gives the matrix element for the quantum object sandwiched between a
++        `bra` and `ket` vector.
++
++        Parameters
++        ----------
++        bra : :class:`qutip.Qobj`
++            Quantum object of type 'bra' or 'ket'
++
++        ket : :class:`qutip.Qobj`
++            Quantum object of type 'ket'.
++
++        Returns
++        -------
++        elem : complex
++            Complex valued matrix element.
++
++        Notes
++        -----
++        It is slightly more computationally efficient to use a ket
++        vector for the 'bra' input.
++
++        """
++        if not self.isoper:
++            raise TypeError("Can only get matrix elements for an operator.")
++        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
++            msg = "Can only calculate matrix elements between a bra and a ket."
++            raise TypeError(msg)
++        left, op, right = bra.data, self.data, ket.data
++        if ket.isbra:
++            right = right.adjoint()
++        return _data.inner_op(left, op, right, bra.isket)
++
++    def overlap(self, other):
++        """
++        Overlap between two state vectors or two operators.
++
++        Gives the overlap (inner product) between the current bra or ket Qobj
++        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
++        when one of the Qobj is an operator/density matrix.
++
++        Parameters
++        ----------
++        other : :class:`qutip.Qobj`
++            Quantum object for a state vector of type 'ket', 'bra' or density
++            matrix.
++
++        Returns
++        -------
++        overlap : complex
++            Complex valued overlap.
++
++        Raises
++        ------
++        TypeError
++            Can only calculate overlap between a bra, ket and density matrix
++            quantum objects.
++        """
++        if not isinstance(other, Qobj):
++            raise TypeError("".join([
++                "cannot calculate overlap with non-quantum object ",
++                repr(other),
++            ]))
++        if (
++            self.type not in ('ket', 'bra', 'oper')
++            or other.type not in ('ket', 'bra', 'oper')
++        ):
++            msg = "only bras, kets and density matrices have defined overlaps"
++            raise TypeError(msg)
++        left, right = self._data.adjoint(), other.data
++        if self.isoper or other.isoper:
++            if not self.isoper:
++                left = _data.project(left)
++            if not other.isoper:
++                right = _data.project(right)
++            return _data.trace(_data.matmul(left, right))
++        if other.isbra:
++            right = right.adjoint()
++        out = _data.inner(left, right, self.isket)
++        if self.isket and other.isbra:
++            # In this particular case, we've basically doing
++            #   conj(other.overlap(self))
++            # so we take care to conjugate the output.
++            out = np.conj(out)
++        return out
++
++    def eigenstates(self, sparse=False, sort='low', eigvals=0,
++                    tol=0, maxiter=100000, phase_fix=None):
++        """Eigenstates and eigenenergies.
++
++        Eigenstates and eigenenergies are defined for operators and
++        superoperators only.
++
++        Parameters
++        ----------
++        sparse : bool
++            Use sparse Eigensolver
++
++        sort : str
++            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
++
++        eigvals : int
++            Number of requested eigenvalues. Default is all eigenvalues.
++
++        tol : float
++            Tolerance used by sparse Eigensolver (0 = machine precision).
++            The sparse solver may not converge if the tolerance is set too low.
++
++        maxiter : int
++            Maximum number of iterations performed by sparse solver (if used).
++
++        phase_fix : int, None
++            If not None, set the phase of each kets so that ket[phase_fix,0]
++            is real positive.
++
++        Returns
++        -------
++        eigvals : array
++            Array of eigenvalues for operator.
++
++        eigvecs : array
++            Array of quantum operators representing the oprator eigenkets.
++            Order of eigenkets is determined by order of eigenvalues.
++
++        Notes
++        -----
++        The sparse eigensolver is much slower than the dense version.
++        Use sparse only if memory requirements demand it.
++
++        """
++        if isinstance(self.data, _data.CSR) and sparse:
++            evals, evecs = _data.eigs_csr(self.data,
++                                          isherm=self._isherm,
++                                          sort=sort, eigvals=eigvals, tol=tol,
++                                          maxiter=maxiter)
++        elif isinstance(self.data, _data.CSR):
++            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
++                                      isherm=self._isherm,
++                                      sort=sort, eigvals=eigvals)
++        else:
++            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
++                                      sort=sort, eigvals=eigvals)
++
++        if self.type == 'super':
++            new_dims = [self.dims[0], [1]]
++            new_type = 'operator-ket'
++        else:
++            new_dims = [self.dims[0], [1]*len(self.dims[0])]
++            new_type = 'ket'
++        ekets = np.empty((evecs.shape[1],), dtype=object)
++        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
++                    for vec in _data.split_columns(evecs, False)]
++        norms = np.array([ket.norm() for ket in ekets])
++        if phase_fix is None:
++            phase = np.array([1] * len(ekets))
++        else:
++            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
++                              if ket[phase_fix, 0] else 1
++                              for ket in ekets])
++        return evals, ekets / norms * phase
++
++    def eigenenergies(self, sparse=False, sort='low',
++                      eigvals=0, tol=0, maxiter=100000):
++        """Eigenenergies of a quantum object.
++
++        Eigenenergies (eigenvalues) are defined for operators or superoperators
++        only.
++
++        Parameters
++        ----------
++        sparse : bool
++            Use sparse Eigensolver
++        sort : str
++            Sort eigenvalues 'low' to high, or 'high' to low.
++        eigvals : int
++            Number of requested eigenvalues. Default is all eigenvalues.
++        tol : float
++            Tolerance used by sparse Eigensolver (0=machine precision).
++            The sparse solver may not converge if the tolerance is set too low.
++        maxiter : int
++            Maximum number of iterations performed by sparse solver (if used).
++
++        Returns
++        -------
++        eigvals : array
++            Array of eigenvalues for operator.
++
++        Notes
++        -----
++        The sparse eigensolver is much slower than the dense version.
++        Use sparse only if memory requirements demand it.
++
++        """
++        # TODO: consider another way of handling the dispatch here.
++        if isinstance(self.data, _data.CSR) and sparse:
++            return _data.eigs_csr(self.data,
++                                  vecs=False,
++                                  isherm=self._isherm,
++                                  sort=sort, eigvals=eigvals,
++                                  tol=tol, maxiter=maxiter)
++        elif isinstance(self.data, _data.CSR):
++            return _data.eigs(_data.to(_data.Dense, self.data),
++                              vecs=False, isherm=self._isherm,
++                              sort=sort, eigvals=eigvals)
++
++        return _data.eigs(self.data,
++                          vecs=False,
++                          isherm=self._isherm, sort=sort, eigvals=eigvals)
++
++    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
++        """Ground state Eigenvalue and Eigenvector.
++
++        Defined for quantum operators or superoperators only.
++
++        Parameters
++        ----------
++        sparse : bool
++            Use sparse Eigensolver
++        tol : float
++            Tolerance used by sparse Eigensolver (0 = machine precision).
++            The sparse solver may not converge if the tolerance is set too low.
++        maxiter : int
++            Maximum number of iterations performed by sparse solver (if used).
++        safe : bool (default=True)
++            Check for degenerate ground state
++
++        Returns
++        -------
++        eigval : float
++            Eigenvalue for the ground state of quantum operator.
++        eigvec : :class:`qutip.Qobj`
++            Eigenket for the ground state of quantum operator.
++
++        Notes
++        -----
++        The sparse eigensolver is much slower than the dense version.
++        Use sparse only if memory requirements demand it.
++        """
++        eigvals = 2 if safe else 1
++        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
++                                        tol=tol, maxiter=maxiter)
++
++        if safe:
++            tol = tol or settings.core['atol']
++            # This tol should be less strick than the tol for the eigensolver
++            # so it's numerical errors are not seens as degenerate states.
++            if (evals[1]-evals[0]) <= 10 * tol:
++                warnings.warn("Ground state may be degenerate.", UserWarning)
++        return evals[0], evecs[0]
++
++    def dnorm(self, B=None):
++        """Calculates the diamond norm, or the diamond distance to another
++        operator.
++
++        Parameters
++        ----------
++        B : :class:`qutip.Qobj` or None
++            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
++            between this operator and B is returned instead of the diamond norm.
++
++        Returns
++        -------
++        d : float
++            Either the diamond norm of this operator, or the diamond distance
++            from this operator to B.
++
++        """
++        return mts.dnorm(self, B)
++
++    @property
++    def ishp(self):
++        # FIXME: this needs to be cached in the same ways as isherm.
++        if self.type in ["super", "oper"]:
++            try:
++                J = to_choi(self)
++                return J.isherm
++            except:
++                return False
++        else:
++            return False
++
++    @property
++    def iscp(self):
++        # FIXME: this needs to be cached in the same ways as isherm.
++        if self.type not in ["super", "oper"]:
++            return False
++        # We can test with either Choi or chi, since the basis
++        # transformation between them is unitary and hence preserves
++        # the CP and TP conditions.
++        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
++        # If J isn't hermitian, then that could indicate either that J is not
++        # normal, or is normal, but has complex eigenvalues.  In either case,
++        # it makes no sense to then demand that the eigenvalues be
++        # non-negative.
++        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
++
++    @property
++    def istp(self):
++        if self.type not in ['super', 'oper']:
++            return False
++        # Normalize to a super of type choi or chi.
++        # We can test with either Choi or chi, since the basis
++        # transformation between them is unitary and hence
++        # preserves the CP and TP conditions.
++        if self.issuper and self.superrep in ('choi', 'chi'):
++            qobj = self
++        else:
++            qobj = to_choi(self)
++        # Possibly collapse dims.
++        if any([len(index) > 1
++                for super_index in qobj.dims
++                for index in super_index]):
++            qobj = Qobj(qobj.data,
++                        dims=collapse_dims_super(qobj.dims),
++                        type=qobj.type,
++                        superrep=qobj.superrep,
++                        copy=False)
++        # We use the condition from John Watrous' lecture notes,
++        # Tr_1(J(Phi)) = identity_2.
++        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
++        # Theory of Quantum Information (Fall 2011), theorem 5.4.
++        tr_oper = qobj.ptrace([0])
++        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
++                           atol=settings.core['atol'])
++
++    @property
++    def iscptp(self):
++        if not (self.issuper or self.isoper):
++            return False
++        reps = ('choi', 'chi')
++        q_oper = to_choi(self) if self.superrep not in reps else self
++        return q_oper.iscp and q_oper.istp
++
++    @property
++    def isherm(self):
++        if self._isherm is not None:
++            return self._isherm
++        self._isherm = _data.isherm(self._data)
++        return self._isherm
++
++    @isherm.setter
++    def isherm(self, isherm):
++        self._isherm = isherm
++
++    def _calculate_isunitary(self):
++        """
++        Checks whether qobj is a unitary matrix
++        """
++        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
++            return False
++        cmp = _data.matmul(self._data, self._data.adjoint())
++        iden = _data.identity(self.shape[0], dtype=type(cmp))
++        return _data.iszero(_data.sub(cmp, iden),
++                            tol=settings.core['atol'])
++
++    @property
++    def isunitary(self):
++        if self._isunitary is not None:
++            return self._isunitary
++        self._isunitary = self._calculate_isunitary()
++        return self._isunitary
++
++    @property
++    def shape(self): return self.data.shape
++
++    isbra = property(isbra)
++    isket = property(isket)
++    isoper = property(isoper)
++    issuper = property(issuper)
++    isoperbra = property(isoperbra)
++    isoperket = property(isoperket)
++
++
++def ptrace(Q, sel):
++    """
++    Partial trace of the Qobj with selected components remaining.
++
++    Parameters
++    ----------
++    Q : :class:`qutip.Qobj`
++        Composite quantum object.
++    sel : int/list
++        An ``int`` or ``list`` of components to keep after partial trace.
++
++    Returns
++    -------
++    oper : :class:`qutip.Qobj`
++        Quantum object representing partial trace with selected components
++        remaining.
++
++    Notes
++    -----
++    This function is for legacy compatibility only. It is recommended to use
++    the ``ptrace()`` Qobj method.
++    """
++    if not isinstance(Q, Qobj):
++        raise TypeError("Input is not a quantum object")
++    return Q.ptrace(sel)
++
++
++# TRAILING IMPORTS
++# We do a few imports here to avoid circular dependencies.
++from qutip.core.superop_reps import to_choi
++from qutip.core.superoperator import vector_to_operator, operator_to_vector
++from qutip.core.tensor import tensor_swap, tensor
++from qutip.core import metrics as mts
+diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
+index c6d3762f..6d4be82b 100644
+--- a/qutip/core/semidefinite.py
++++ b/qutip/core/semidefinite.py
+@@ -1,208 +1,208 @@
+-# -*- coding: utf-8 -*-
+-
+-"""
+-This module implements internal-use functions for semidefinite programming.
+-"""
+-
+-__all__ = [
+-    'dnorm_problem',
+-    'dnorm_sparse_problem',
+-]
+-
+-import collections
+-import functools
+-
+-import numpy as np
+-import scipy.sparse as sp
+-# Conditionally import CVXPY
+-try:
+-    import cvxpy
+-except ImportError:
+-    cvxpy = None
+-
+-from .tensor import tensor_swap
+-from .operators import qeye
+-from ..logging_utils import get_logger
+-logger = get_logger('qutip.core.semidefinite')
+-
+-Complex = collections.namedtuple('Complex', ['re', 'im'])
+-
+-
+-def complex_var(rows=1, cols=1, name=None):
+-    return Complex(
+-        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
+-        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
+-    )
+-
+-
+-def herm(*Xs):
+-    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
+-
+-
+-def pos_noherm(*Xs):
+-    return [
+-        cvxpy.bmat([
+-            [X.re, -X.im],
+-            [X.im, X.re]
+-        ]) >> 0
+-        for X in Xs
+-    ]
+-
+-
+-def pos(*Xs):
+-    return pos_noherm(*Xs) + herm(*Xs)
+-
+-
+-def dens(*rhos):
+-    return pos(*rhos) + [
+-        cvxpy.trace(rho.re) == 1
+-        for rho in rhos
+-    ]
+-
+-
+-def _arr_to_complex(A):
+-    if np.iscomplex(A).any():
+-        return Complex(re=A.real, im=A.imag)
+-    return Complex(re=A, im=np.zeros_like(A))
+-
+-
+-def kron(A, B):
+-    if isinstance(A, np.ndarray):
+-        A = _arr_to_complex(A)
+-    if isinstance(B, np.ndarray):
+-        B = _arr_to_complex(B)
+-
+-    return Complex(
+-        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
+-        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
+-    )
+-
+-
+-def conj(W, A):
+-    U, V = W.re, W.im
+-    A, B = A.re, A.im
+-    return Complex(
+-        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
+-        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
+-    )
+-
+-
+-def bmat(B):
+-    return Complex(
+-        re=cvxpy.bmat([[element.re for element in row] for row in B]),
+-        im=cvxpy.bmat([[element.re for element in row] for row in B]),
+-    )
+-
+-
+-def dag(X):
+-    return Complex(re=X.re.T, im=-X.im.T)
+-
+-
+-def memoize(fn):
+-    cache = {}
+-
+-    @functools.wraps(fn)
+-    def memoized(*args):
+-        if args in cache:
+-            return cache[args]
+-        else:
+-            ret = fn(*args)
+-            cache[args] = ret
+-            return ret
+-
+-    memoized.reset_cache = cache.clear
+-    return memoized
+-
+-
+-def qudit_swap(dim):
+-    # We should likely generalize this and include it in qip.gates.
+-    W = qeye([dim, dim])
+-    return tensor_swap(W, (0, 1))
+-
+-
+-@memoize
+-def initialize_constraints_on_dnorm_problem(dim):
+-    # Start assembling constraints and variables.
+-    constraints = []
+-
+-    # Make a complex variable for X.
+-    X = complex_var(dim ** 2, dim ** 2, "X")
+-
+-    # Make complex variables for rho0 and rho1.
+-    rho0 = complex_var(dim, dim, "rho0")
+-    rho1 = complex_var(dim, dim, "rho1")
+-    constraints += dens(rho0, rho1)
+-
+-    # Finally, add the tricky positive semidefinite constraint.
+-    # Since we're using column-stacking, but Watrous used row-stacking,
+-    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
+-    # as CVXPY requires that the constant be the first argument. To solve this,
+-    # We conjugate by SWAP.
+-    W = qudit_swap(dim).full()
+-    W = Complex(re=W.real, im=W.imag)
+-    Rho0 = conj(W, kron(np.eye(dim), rho0))
+-    Rho1 = conj(W, kron(np.eye(dim), rho1))
+-
+-    Y = cvxpy.bmat([
+-        [Rho0.re, X.re,      -Rho0.im, -X.im],
+-        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
+-
+-        [Rho0.im, X.im,      Rho0.re, X.re],
+-        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
+-    ])
+-    constraints += [Y >> 0]
+-
+-    logger.debug("Using %d constraints.", len(constraints))
+-
+-    return X, constraints
+-
+-
+-def dnorm_problem(dim):
+-    X, constraints = initialize_constraints_on_dnorm_problem(dim)
+-    Jr = cvxpy.Parameter((dim**2, dim**2))
+-    Ji = cvxpy.Parameter((dim**2, dim**2))
+-    # The objective, however, depends on J.
+-    objective = cvxpy.Maximize(cvxpy.trace(
+-        Jr.T @ X.re + Ji.T @ X.im
+-    ))
+-    problem = cvxpy.Problem(objective, constraints)
+-    return problem, Jr, Ji
+-
+-
+-def dnorm_sparse_problem(dim, J_dat):
+-    X, constraints = initialize_constraints_on_dnorm_problem(dim)
+-    J_val = J_dat.tocoo()
+-
+-    def adapt_sparse_params(A_val, dim):
+-        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
+-        # can not solve with parameters that aresparse matrices directly.
+-        # Solutions have to be made through calling cvxpy.reshape on
+-        # the original sparse matrix.
+-        side_size = dim**2
+-        A_nnz = cvxpy.Parameter(A_val.nnz)
+-
+-        A_data = np.ones(A_nnz.size)
+-        A_rows = A_val.row * side_size + A_val.col
+-        A_cols = np.arange(A_nnz.size)
+-        # We are pushing the data on the location of the nonzero elements
+-        # to the nonzero rows of A_indexer
+-        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
+-                                  shape=(side_size**2, A_nnz.size))
+-        # We get finaly the sparse matrix A which we wanted
+-        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
+-        A_nnz.value = A_val.data
+-        return A
+-
+-    Jr_val = J_val.real
+-    Jr = adapt_sparse_params(Jr_val, dim)
+-
+-    Ji_val = J_val.imag
+-    Ji = adapt_sparse_params(Ji_val, dim)
+-
+-    # The objective, however, depends on J.
+-    objective = cvxpy.Maximize(cvxpy.trace(
+-        Jr.T @ X.re + Ji.T @ X.im
+-    ))
+-
+-    problem = cvxpy.Problem(objective, constraints)
+-    return problem
++# -*- coding: utf-8 -*-
++
++"""
++This module implements internal-use functions for semidefinite programming.
++"""
++
++__all__ = [
++    'dnorm_problem',
++    'dnorm_sparse_problem',
++]
++
++import collections
++import functools
++
++import numpy as np
++import scipy.sparse as sp
++# Conditionally import CVXPY
++try:
++    import cvxpy
++except ImportError:
++    cvxpy = None
++
++from .tensor import tensor_swap
++from .operators import qeye
++from ..logging_utils import get_logger
++logger = get_logger('qutip.core.semidefinite')
++
++Complex = collections.namedtuple('Complex', ['re', 'im'])
++
++
++def complex_var(rows=1, cols=1, name=None):
++    return Complex(
++        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
++        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
++    )
++
++
++def herm(*Xs):
++    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
++
++
++def pos_noherm(*Xs):
++    return [
++        cvxpy.bmat([
++            [X.re, -X.im],
++            [X.im, X.re]
++        ]) >> 0
++        for X in Xs
++    ]
++
++
++def pos(*Xs):
++    return pos_noherm(*Xs) + herm(*Xs)
++
++
++def dens(*rhos):
++    return pos(*rhos) + [
++        cvxpy.trace(rho.re) == 1
++        for rho in rhos
++    ]
++
++
++def _arr_to_complex(A):
++    if np.iscomplex(A).any():
++        return Complex(re=A.real, im=A.imag)
++    return Complex(re=A, im=np.zeros_like(A))
++
++
++def kron(A, B):
++    if isinstance(A, np.ndarray):
++        A = _arr_to_complex(A)
++    if isinstance(B, np.ndarray):
++        B = _arr_to_complex(B)
++
++    return Complex(
++        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
++        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
++    )
++
++
++def conj(W, A):
++    U, V = W.re, W.im
++    A, B = A.re, A.im
++    return Complex(
++        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
++        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
++    )
++
++
++def bmat(B):
++    return Complex(
++        re=cvxpy.bmat([[element.re for element in row] for row in B]),
++        im=cvxpy.bmat([[element.re for element in row] for row in B]),
++    )
++
++
++def dag(X):
++    return Complex(re=X.re.T, im=-X.im.T)
++
++
++def memoize(fn):
++    cache = {}
++
++    @functools.wraps(fn)
++    def memoized(*args):
++        if args in cache:
++            return cache[args]
++        else:
++            ret = fn(*args)
++            cache[args] = ret
++            return ret
++
++    memoized.reset_cache = cache.clear
++    return memoized
++
++
++def qudit_swap(dim):
++    # We should likely generalize this and include it in qip.gates.
++    W = qeye([dim, dim])
++    return tensor_swap(W, (0, 1))
++
++
++@memoize
++def initialize_constraints_on_dnorm_problem(dim):
++    # Start assembling constraints and variables.
++    constraints = []
++
++    # Make a complex variable for X.
++    X = complex_var(dim ** 2, dim ** 2, "X")
++
++    # Make complex variables for rho0 and rho1.
++    rho0 = complex_var(dim, dim, "rho0")
++    rho1 = complex_var(dim, dim, "rho1")
++    constraints += dens(rho0, rho1)
++
++    # Finally, add the tricky positive semidefinite constraint.
++    # Since we're using column-stacking, but Watrous used row-stacking,
++    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
++    # as CVXPY requires that the constant be the first argument. To solve this,
++    # We conjugate by SWAP.
++    W = qudit_swap(dim).full()
++    W = Complex(re=W.real, im=W.imag)
++    Rho0 = conj(W, kron(np.eye(dim), rho0))
++    Rho1 = conj(W, kron(np.eye(dim), rho1))
++
++    Y = cvxpy.bmat([
++        [Rho0.re, X.re,      -Rho0.im, -X.im],
++        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
++
++        [Rho0.im, X.im,      Rho0.re, X.re],
++        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
++    ])
++    constraints += [Y >> 0]
++
++    logger.debug("Using %d constraints.", len(constraints))
++
++    return X, constraints
++
++
++def dnorm_problem(dim):
++    X, constraints = initialize_constraints_on_dnorm_problem(dim)
++    Jr = cvxpy.Parameter((dim**2, dim**2))
++    Ji = cvxpy.Parameter((dim**2, dim**2))
++    # The objective, however, depends on J.
++    objective = cvxpy.Maximize(cvxpy.trace(
++        Jr.T @ X.re + Ji.T @ X.im
++    ))
++    problem = cvxpy.Problem(objective, constraints)
++    return problem, Jr, Ji
++
++
++def dnorm_sparse_problem(dim, J_dat):
++    X, constraints = initialize_constraints_on_dnorm_problem(dim)
++    J_val = J_dat.tocoo()
++
++    def adapt_sparse_params(A_val, dim):
++        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
++        # can not solve with parameters that aresparse matrices directly.
++        # Solutions have to be made through calling cvxpy.reshape on
++        # the original sparse matrix.
++        side_size = dim**2
++        A_nnz = cvxpy.Parameter(A_val.nnz)
++
++        A_data = np.ones(A_nnz.size)
++        A_rows = A_val.row * side_size + A_val.col
++        A_cols = np.arange(A_nnz.size)
++        # We are pushing the data on the location of the nonzero elements
++        # to the nonzero rows of A_indexer
++        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
++                                  shape=(side_size**2, A_nnz.size))
++        # We get finaly the sparse matrix A which we wanted
++        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
++        A_nnz.value = A_val.data
++        return A
++
++    Jr_val = J_val.real
++    Jr = adapt_sparse_params(Jr_val, dim)
++
++    Ji_val = J_val.imag
++    Ji = adapt_sparse_params(Ji_val, dim)
++
++    # The objective, however, depends on J.
++    objective = cvxpy.Maximize(cvxpy.trace(
++        Jr.T @ X.re + Ji.T @ X.im
++    ))
++
++    problem = cvxpy.Problem(objective, constraints)
++    return problem
+diff --git a/qutip/core/states.py b/qutip/core/states.py
+index c030e33d..10d5788c 100644
+--- a/qutip/core/states.py
++++ b/qutip/core/states.py
+@@ -1,1342 +1,1342 @@
+-__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
+-           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
+-           'qstate', 'ket', 'bra', 'state_number_enumerate',
+-           'state_number_index', 'state_index_number', 'state_number_qobj',
+-           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
+-           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
+-           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
+-           'enr_thermal_dm']
+-
+-import itertools
+-import numbers
+-import warnings
+-
+-import numpy as np
+-import scipy.sparse as sp
+-import itertools
+-
+-from . import data as _data
+-from .qobj import Qobj
+-from .operators import jmat, displace, qdiags
+-from .tensor import tensor
+-from .. import settings
+-
+-def _promote_to_zero_list(arg, length):
+-    """
+-    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
+-    to `[0]*length`.  All other inputs are checked that they match the correct
+-    form.
+-
+-    Returns
+-    -------
+-    list_ : list
+-        A list of integers of length `length`.
+-    """
+-    if arg is None:
+-        arg = [0]*length
+-    elif not isinstance(arg, list):
+-        arg = [arg]
+-    if not len(arg) == length:
+-        raise ValueError("All list inputs must be the same length.")
+-    if all(isinstance(x, numbers.Integral) for x in arg):
+-        return arg
+-    raise TypeError("Dimensions must be an integer or list of integers.")
+-
+-
+-def basis(dimensions, n=None, offset=None, *, dtype=None):
+-    """Generates the vector representation of a Fock state.
+-
+-    Parameters
+-    ----------
+-    dimensions : int or list of ints
+-        Number of Fock states in Hilbert space.  If a list, then the resultant
+-        object will be a tensor product over spaces with those dimensions.
+-
+-    n : int or list of ints, optional (default 0 for all dimensions)
+-        Integer corresponding to desired number state, defaults to 0 for all
+-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+-        of equal length.
+-
+-    offset : int or list of ints, optional (default 0 for all dimensions)
+-        The lowest number state that is included in the finite number state
+-        representation of the state in the relevant dimension.
+-
+-    dtype : type or str
+-        storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    state : :class:`qutip.Qobj`
+-      Qobj representing the requested number state ``|n>``.
+-
+-    Examples
+-    --------
+-    >>> basis(5,2) # doctest: +SKIP
+-    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
+-    Qobj data =
+-    [[ 0.+0.j]
+-     [ 0.+0.j]
+-     [ 1.+0.j]
+-     [ 0.+0.j]
+-     [ 0.+0.j]]
+-    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
+-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
+-    Qobj data =
+-    [[0.]
+-     [0.]
+-     [1.]
+-     [0.]
+-     [0.]
+-     [0.]
+-     [0.]
+-     [0.]]
+-
+-
+-    Notes
+-    -----
+-    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
+-
+-        basis(N, 0) = ground state
+-
+-    but in the qotoolbox::
+-
+-        basis(N, 1) = ground state
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    # Promote all parameters to lists to simplify later logic.
+-    if not isinstance(dimensions, list):
+-        dimensions = [dimensions]
+-    n_dimensions = len(dimensions)
+-    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
+-                                  _promote_to_zero_list(offset, n_dimensions))]
+-    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
+-        raise ValueError("All dimensions must be >= 0.")
+-    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
+-        raise ValueError("All basis indices must be "
+-                         "`offset <= n < dimension+offset`.")
+-    location, size = 0, 1
+-    for m, dimension in zip(reversed(ns), reversed(dimensions)):
+-        location += m*size
+-        size *= dimension
+-
+-    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
+-    return Qobj(data,
+-                dims=[dimensions, [1]*n_dimensions],
+-                type='ket',
+-                isherm=False,
+-                isunitary=False,
+-                copy=False)
+-
+-
+-def qutrit_basis(*, dtype=None):
+-    """Basis states for a three level system (qutrit)
+-
+-    dtype : type or str
+-        storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    qstates : array
+-        Array of qutrit basis vectors
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    out = np.empty((3,), dtype=object)
+-    out[:] = [
+-        basis(3, 0, dtype=dtype),
+-        basis(3, 1, dtype=dtype),
+-        basis(3, 2, dtype=dtype),
+-    ]
+-    return out
+-
+-_COHERENT_METHODS = ('operator', 'analytic')
+-
+-
+-def coherent(N, alpha, offset=0, method=None, *, dtype=None):
+-    """Generates a coherent state with eigenvalue alpha.
+-
+-    Constructed using displacement operator on vacuum state.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of Fock states in Hilbert space.
+-
+-    alpha : float/complex
+-        Eigenvalue of coherent state.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the state. Using a non-zero offset will make the
+-        default method 'analytic'.
+-
+-    method : string {'operator', 'analytic'}
+-        Method for generating coherent state.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    state : qobj
+-        Qobj quantum object for coherent state
+-
+-    Examples
+-    --------
+-    >>> coherent(5,0.25j) # doctest: +SKIP
+-    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
+-    Qobj data =
+-    [[  9.69233235e-01+0.j        ]
+-     [  0.00000000e+00+0.24230831j]
+-     [ -4.28344935e-02+0.j        ]
+-     [  0.00000000e+00-0.00618204j]
+-     [  7.80904967e-04+0.j        ]]
+-
+-    Notes
+-    -----
+-    Select method 'operator' (default) or 'analytic'. With the
+-    'operator' method, the coherent state is generated by displacing
+-    the vacuum state using the displacement operator defined in the
+-    truncated Hilbert space of size 'N'. This method guarantees that the
+-    resulting state is normalized. With 'analytic' method the coherent state
+-    is generated using the analytical formula for the coherent state
+-    coefficients in the Fock basis. This method does not guarantee that the
+-    state is normalized if truncated to a small number of Fock states,
+-    but would in that case give more accurate coefficients.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    if offset < 0:
+-        raise ValueError('Offset must be non-negative')
+-
+-    if method is None:
+-        method = "operator" if offset == 0 else "analytic"
+-
+-    if method == "operator":
+-        if offset != 0:
+-            raise ValueError(
+-                "The method 'operator' does not support offset != 0. Please"
+-                " select another method or set the offset to zero."
+-            )
+-        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
+-
+-    elif method == "analytic":
+-        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
+-        sqrtn[0] = 1  # Get rid of divide by zero warning
+-        data = alpha / sqrtn
+-        if offset == 0:
+-            data[0] = np.exp(-abs(alpha)**2 / 2.0)
+-        else:
+-            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
+-            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
+-        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
+-        return Qobj(sqrtn,
+-                    dims=[[N], [1]],
+-                    type='ket',
+-                    copy=False).to(dtype)
+-    raise TypeError(
+-        "The method option can only take values in " + repr(_COHERENT_METHODS)
+-    )
+-
+-
+-def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
+-    """Density matrix representation of a coherent state.
+-
+-    Constructed via outer product of :func:`qutip.states.coherent`
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of Fock states in Hilbert space.
+-
+-    alpha : float/complex
+-        Eigenvalue for coherent state.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the state.
+-
+-    method : string {'operator', 'analytic'}
+-        Method for generating coherent density matrix.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Density matrix representation of coherent state.
+-
+-    Examples
+-    --------
+-    >>> coherent_dm(3,0.25j) # doctest: +SKIP
+-    Quantum object: dims = [[3], [3]], \
+-shape = [3, 3], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
+-     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
+-     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
+-        ]]
+-
+-    Notes
+-    -----
+-    Select method 'operator' (default) or 'analytic'. With the
+-    'operator' method, the coherent density matrix is generated by displacing
+-    the vacuum state using the displacement operator defined in the
+-    truncated Hilbert space of size 'N'. This method guarantees that the
+-    resulting density matrix is normalized. With 'analytic' method the coherent
+-    density matrix is generated using the analytical formula for the coherent
+-    state coefficients in the Fock basis. This method does not guarantee that
+-    the state is normalized if truncated to a small number of Fock states,
+-    but would in that case give more accurate coefficients.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
+-
+-
+-def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
+-    """Density matrix representation of a Fock state
+-
+-    Constructed via outer product of :func:`qutip.states.fock`.
+-
+-    Parameters
+-    ----------
+-    dimensions : int or list of ints
+-        Number of Fock states in Hilbert space.  If a list, then the resultant
+-        object will be a tensor product over spaces with those dimensions.
+-
+-    n : int or list of ints, optional (default 0 for all dimensions)
+-        Integer corresponding to desired number state, defaults to 0 for all
+-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+-        of equal length.
+-
+-    offset : int or list of ints, optional (default 0 for all dimensions)
+-        The lowest number state that is included in the finite number state
+-        representation of the state in the relevant dimension.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Density matrix representation of Fock state.
+-
+-    Examples
+-    --------
+-     >>> fock_dm(3,1) # doctest: +SKIP
+-     Quantum object: dims = [[3], [3]], \
+-shape = [3, 3], type = oper, isHerm = True
+-     Qobj data =
+-     [[ 0.+0.j  0.+0.j  0.+0.j]
+-      [ 0.+0.j  1.+0.j  0.+0.j]
+-      [ 0.+0.j  0.+0.j  0.+0.j]]
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
+-
+-
+-def fock(dimensions, n=None, offset=None, *, dtype=None):
+-    """Bosonic Fock (number) state.
+-
+-    Same as :func:`qutip.states.basis`.
+-
+-    Parameters
+-    ----------
+-    dimensions : int or list of ints
+-        Number of Fock states in Hilbert space.  If a list, then the resultant
+-        object will be a tensor product over spaces with those dimensions.
+-
+-    n : int or list of ints, optional (default 0 for all dimensions)
+-        Integer corresponding to desired number state, defaults to 0 for all
+-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+-        of equal length.
+-
+-    offset : int or list of ints, optional (default 0 for all dimensions)
+-        The lowest number state that is included in the finite number state
+-        representation of the state in the relevant dimension.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-        Requested number state :math:`\\left|n\\right>`.
+-
+-    Examples
+-    --------
+-    >>> fock(4,3) # doctest: +SKIP
+-    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
+-    Qobj data =
+-    [[ 0.+0.j]
+-     [ 0.+0.j]
+-     [ 0.+0.j]
+-     [ 1.+0.j]]
+-
+-    """
+-    return basis(dimensions, n, offset=offset, dtype=dtype)
+-
+-
+-def thermal_dm(N, n, method='operator', *, dtype=None):
+-    """Density matrix for a thermal state of n particles
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of basis states in Hilbert space.
+-
+-    n : float
+-        Expectation value for number of particles in thermal state.
+-
+-    method : string {'operator', 'analytic'}
+-        ``string`` that sets the method used to generate the
+-        thermal state probabilities
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Thermal state density matrix.
+-
+-    Examples
+-    --------
+-    >>> thermal_dm(5, 1) # doctest: +SKIP
+-    Quantum object: dims = [[5], [5]], \
+-shape = [5, 5], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.51612903  0.          0.          0.          0.        ]
+-     [ 0.          0.25806452  0.          0.          0.        ]
+-     [ 0.          0.          0.12903226  0.          0.        ]
+-     [ 0.          0.          0.          0.06451613  0.        ]
+-     [ 0.          0.          0.          0.          0.03225806]]
+-
+-
+-    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
+-    Quantum object: dims = [[5], [5]], \
+-shape = [5, 5], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.5      0.       0.       0.       0.     ]
+-     [ 0.       0.25     0.       0.       0.     ]
+-     [ 0.       0.       0.125    0.       0.     ]
+-     [ 0.       0.       0.       0.0625   0.     ]
+-     [ 0.       0.       0.       0.       0.03125]]
+-
+-    Notes
+-    -----
+-    The 'operator' method (default) generates
+-    the thermal state using the truncated number operator ``num(N)``. This
+-    is the method that should be used in computations. The
+-    'analytic' method uses the analytic coefficients derived in
+-    an infinite Hilbert space. The analytic form is not necessarily normalized,
+-    if truncated too aggressively.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    if n == 0:
+-        return fock_dm(N, 0, dtype=dtype)
+-    else:
+-        i = np.arange(N)
+-        if method == 'operator':
+-            beta = np.log(1.0 / n + 1.0)
+-            diags = np.exp(-beta * i)
+-            diags = diags / np.sum(diags)
+-            # populates diagonal terms using truncated operator expression
+-
+-        elif method == 'analytic':
+-            # populates diagonal terms using analytic values
+-            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
+-        else:
+-            raise ValueError("The method option can only take "
+-                             "values 'operator' or 'analytic'")
+-        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
+-        out._isherm = True
+-        return out
+-
+-
+-def maximally_mixed_dm(N, *, dtype=None):
+-    """
+-    Returns the maximally mixed density matrix for a Hilbert space of
+-    dimension N.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of basis states in Hilbert space.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Thermal state density matrix.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    if not isinstance(N, numbers.Integral) or N <= 0:
+-        raise ValueError("N must be integer N > 0")
+-    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
+-                type='oper', isherm=True, isunitary=(N == 1), copy=False)
+-
+-
+-def ket2dm(Q):
+-    """
+-    Takes input ket or bra vector and returns density matrix formed by outer
+-    product.  This is completely identical to calling `Q.proj()`.
+-
+-    Parameters
+-    ----------
+-    Q : qobj
+-        Ket or bra type quantum object.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Density matrix formed by outer product of `Q`.
+-
+-    Examples
+-    --------
+-    >>> x=basis(3,2)
+-    >>> ket2dm(x) # doctest: +SKIP
+-    Quantum object: dims = [[3], [3]], \
+-shape = [3, 3], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.+0.j  0.+0.j  0.+0.j]
+-     [ 0.+0.j  0.+0.j  0.+0.j]
+-     [ 0.+0.j  0.+0.j  1.+0.j]]
+-
+-    """
+-    if Q.isket or Q.isbra:
+-        return Q.proj()
+-    raise TypeError("Input is not a ket or bra vector.")
+-
+-
+-def projection(N, n, m, offset=None, *, dtype=None):
+-    r"""
+-    The projection operator that projects state :math:`\lvert m\rangle` on
+-    state :math:`\lvert n\rangle`.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of basis states in Hilbert space.
+-
+-    n, m : float
+-        The number states in the projection.
+-
+-    offset : int (default 0)
+-        The lowest number state that is included in the finite number state
+-        representation of the projector.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-         Requested projection operator.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    return basis(N, n, offset=offset, dtype=dtype) @ \
+-           basis(N, m, offset=offset, dtype=dtype).dag()
+-
+-
+-def qstate(string, *, dtype=None):
+-    r"""Creates a tensor product for a set of qubits in either
+-    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
+-
+-    Parameters
+-    ----------
+-    string : str
+-        String containing 'u' or 'd' for each qubit (ex. 'ududd')
+-
+-    Returns
+-    -------
+-    qstate : qobj
+-        Qobj for tensor product corresponding to input string.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Notes
+-    -----
+-    Look at ket and bra for more general functions
+-    creating multiparticle states.
+-
+-    Examples
+-    --------
+-    >>> qstate('udu') # doctest: +SKIP
+-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
+-    Qobj data =
+-    [[ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 1.]
+-     [ 0.]
+-     [ 0.]]
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    n = len(string)
+-    if n != (string.count('u') + string.count('d')):
+-        raise TypeError('String input to QSTATE must consist ' +
+-                        'of "u" and "d" elements only')
+-    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
+-
+-
+-#
+-# different qubit notation dictionary
+-#
+-_qubit_dict = {
+-    'g': 0,  # ground state
+-    'e': 1,  # excited state
+-    'u': 0,  # spin up
+-    'd': 1,  # spin down
+-    'H': 0,  # horizontal polarization
+-    'V': 1,  # vertical polarization
+-}
+-
+-
+-def _character_to_qudit(x):
+-    """
+-    Converts a character representing a one-particle state into int.
+-    """
+-    return _qubit_dict[x] if x in _qubit_dict else int(x)
+-
+-
+-def ket(seq, dim=2, *, dtype=None):
+-    """
+-    Produces a multiparticle ket state for a list or string,
+-    where each element stands for state of the respective particle.
+-
+-    Parameters
+-    ----------
+-    seq : str / list of ints or characters
+-        Each element defines state of the respective particle.
+-        (e.g. [1,1,0,1] or a string "1101").
+-        For qubits it is also possible to use the following conventions:
+-        - 'g'/'e' (ground and excited state)
+-        - 'u'/'d' (spin up and down)
+-        - 'H'/'V' (horizontal and vertical polarization)
+-        Note: for dimension > 9 you need to use a list.
+-
+-
+-    dim : int (default: 2) / list of ints
+-        Space dimension for each particle:
+-        int if there are the same, list if they are different.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    ket : qobj
+-
+-    Examples
+-    --------
+-    >>> ket("10") # doctest: +SKIP
+-    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
+-    Qobj data =
+-    [[ 0.]
+-     [ 0.]
+-     [ 1.]
+-     [ 0.]]
+-
+-    >>> ket("Hue") # doctest: +SKIP
+-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
+-    Qobj data =
+-    [[ 0.]
+-     [ 1.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]]
+-
+-    >>> ket("12", 3) # doctest: +SKIP
+-    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
+-    Qobj data =
+-    [[ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 1.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]]
+-
+-    >>> ket("31", [5, 2]) # doctest: +SKIP
+-    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
+-    Qobj data =
+-    [[ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 0.]
+-     [ 1.]
+-     [ 0.]
+-     [ 0.]]
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    ns = [_character_to_qudit(x) for x in seq]
+-    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
+-    return basis(dim, ns, dtype=dtype)
+-
+-
+-def bra(seq, dim=2, *, dtype=None):
+-    """
+-    Produces a multiparticle bra state for a list or string,
+-    where each element stands for state of the respective particle.
+-
+-    Parameters
+-    ----------
+-    seq : str / list of ints or characters
+-        Each element defines state of the respective particle.
+-        (e.g. [1,1,0,1] or a string "1101").
+-        For qubits it is also possible to use the following conventions:
+-
+-        - 'g'/'e' (ground and excited state)
+-        - 'u'/'d' (spin up and down)
+-        - 'H'/'V' (horizontal and vertical polarization)
+-
+-        Note: for dimension > 9 you need to use a list.
+-
+-
+-    dim : int (default: 2) / list of ints
+-        Space dimension for each particle:
+-        int if there are the same, list if they are different.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    bra : qobj
+-
+-    Examples
+-    --------
+-    >>> bra("10") # doctest: +SKIP
+-    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
+-    Qobj data =
+-    [[ 0.  0.  1.  0.]]
+-
+-    >>> bra("Hue") # doctest: +SKIP
+-    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
+-    Qobj data =
+-    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
+-
+-    >>> bra("12", 3) # doctest: +SKIP
+-    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
+-    Qobj data =
+-    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
+-
+-
+-    >>> bra("31", [5, 2]) # doctest: +SKIP
+-    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
+-    Qobj data =
+-    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    return ket(seq, dim=dim, dtype=dtype).dag()
+-
+-
+-def state_number_enumerate(dims, excitations=None):
+-    """
+-    An iterator that enumerates all the state number tuples (quantum numbers of
+-    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
+-
+-    Example:
+-
+-        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
+-        >>>     print(state) # doctest: +SKIP
+-        ( 0  0 )
+-        ( 0  1 )
+-        ( 1  0 )
+-        ( 1  1 )
+-
+-    Parameters
+-    ----------
+-    dims : list or array
+-        The quantum state dimensions array, as it would appear in a Qobj.
+-
+-    excitations : integer (None)
+-        Restrict state space to states with excitation numbers below or
+-        equal to this value.
+-
+-    Returns
+-    -------
+-    state_number : tuple
+-        Successive state number tuples that can be used in loops and other
+-        iterations, using standard state enumeration *by definition*.
+-
+-    """
+-
+-    if excitations is None:
+-        # in this case, state numbers are a direct product
+-        yield from itertools.product(*(range(d) for d in dims))
+-        return
+-
+-    # From here on, excitations is not None
+-
+-    # General idea of algorithm: add excitations one by one in last mode (idx =
+-    # len(dims)-1), and carry over to the next index when the limit is reached.
+-    # Keep track of the number of excitations while doing so to avoid having to
+-    # do explicit sums over the states.
+-    state = (0,)*len(dims)
+-    nexc = 0
+-    while True:
+-        yield state
+-        idx = len(dims) - 1
+-        state = state[:idx] + (state[idx]+1,)
+-        nexc += 1
+-        while nexc > excitations or state[idx] >= dims[idx]:
+-            # remove all excitations in mode idx, add one in idx-1
+-            idx -= 1
+-            if idx < 0:
+-                return
+-            nexc -= state[idx+1] - 1
+-            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
+-
+-
+-def state_number_index(dims, state):
+-    """
+-    Return the index of a quantum state corresponding to state,
+-    given a system with dimensions given by dims.
+-
+-    Example:
+-
+-        >>> state_number_index([2, 2, 2], [1, 1, 0])
+-        6
+-
+-    Parameters
+-    ----------
+-    dims : list or array
+-        The quantum state dimensions array, as it would appear in a Qobj.
+-
+-    state : list
+-        State number array.
+-
+-    Returns
+-    -------
+-    idx : int
+-        The index of the state given by `state` in standard enumeration
+-        ordering.
+-
+-    """
+-    return np.ravel_multi_index(state, dims)
+-
+-
+-def state_index_number(dims, index):
+-    """
+-    Return a quantum number representation given a state index, for a system
+-    of composite structure defined by dims.
+-
+-    Example:
+-
+-        >>> state_index_number([2, 2, 2], 6)
+-        [1, 1, 0]
+-
+-    Parameters
+-    ----------
+-    dims : list or array
+-        The quantum state dimensions array, as it would appear in a Qobj.
+-
+-    index : integer
+-        The index of the state in standard enumeration ordering.
+-
+-    Returns
+-    -------
+-    state : tuple
+-        The state number tuple corresponding to index `index` in standard
+-        enumeration ordering.
+-
+-    """
+-    return np.unravel_index(index, dims)
+-
+-
+-def state_number_qobj(dims, state, *, dtype=None):
+-    """
+-    Return a Qobj representation of a quantum state specified by the state
+-    array `state`.
+-
+-    Example:
+-
+-        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
+-        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
+-shape = [8, 1], type = ket
+-        Qobj data =
+-        [[ 0.]
+-         [ 0.]
+-         [ 0.]
+-         [ 0.]
+-         [ 0.]
+-         [ 1.]
+-         [ 0.]
+-         [ 0.]]
+-
+-    Parameters
+-    ----------
+-    dims : list or array
+-        The quantum state dimensions array, as it would appear in a Qobj.
+-
+-    state : list
+-        State number array.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    state : :class:`qutip.Qobj`
+-        The state as a :class:`qutip.Qobj` instance.
+-
+-    .. note::
+-        Deprecated in QuTiP 5.0, use :func:`basis` instead.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    warnings.warn("basis() is a drop-in replacement for this",
+-                  DeprecationWarning)
+-    return basis(dims, state, dtype=dtype)
+-
+-
+-# Excitation-number restricted (enr) states
+-
+-def enr_state_dictionaries(dims, excitations):
+-    """
+-    Return the number of states, and lookup-dictionaries for translating
+-    a state tuple to a state index, and vice versa, for a system with a given
+-    number of components and maximum number of excitations.
+-
+-    Parameters
+-    ----------
+-    dims: list
+-        A list with the number of states in each sub-system.
+-
+-    excitations : integer
+-        The maximum numbers of dimension
+-
+-    Returns
+-    -------
+-    nstates, state2idx, idx2state: integer, dict, list
+-        The number of states `nstates`, a dictionary for looking up state
+-        indices from a state tuple, and a list containing the state tuples
+-        ordered by state indices. state2idx and idx2state are reverses of
+-        each other, i.e., state2idx[idx2state[idx]] = idx and
+-        idx2state[state2idx[state]] = state.
+-    """
+-    idx2state = list(state_number_enumerate(dims, excitations))
+-    state2idx = {state: idx for idx, state in enumerate(idx2state)}
+-    nstates = len(idx2state)
+-
+-    return nstates, state2idx, idx2state
+-
+-
+-def enr_fock(dims, excitations, state, *, dtype=None):
+-    """
+-    Generate the Fock state representation in a excitation-number restricted
+-    state space. The `dims` argument is a list of integers that define the
+-    number of quantums states of each component of a composite quantum system,
+-    and the `excitations` specifies the maximum number of excitations for
+-    the basis states that are to be included in the state space. The `state`
+-    argument is a tuple of integers that specifies the state (in the number
+-    basis representation) for which to generate the Fock state representation.
+-
+-    Parameters
+-    ----------
+-    dims : list
+-        A list of the dimensions of each subsystem of a composite quantum
+-        system.
+-
+-    excitations : integer
+-        The maximum number of excitations that are to be included in the
+-        state space.
+-
+-    state : list of integers
+-        The state in the number basis representation.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    ket : Qobj
+-        A Qobj instance that represent a Fock state in the exication-number-
+-        restricted state space defined by `dims` and `exciations`.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
+-    try:
+-        data =_data.one_element[dtype]((nstates, 1),
+-                                       (state2idx[tuple(state)], 0), 1)
+-    except KeyError:
+-        msg = (
+-            "The state tuple " + str(tuple(state))
+-            + " is not in the restricted state space."
+-        )
+-        raise ValueError(msg) from None
+-    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
+-
+-
+-def enr_thermal_dm(dims, excitations, n, *, dtype=None):
+-    """
+-    Generate the density operator for a thermal state in the excitation-number-
+-    restricted state space defined by the `dims` and `exciations` arguments.
+-    See the documentation for enr_fock for a more detailed description of
+-    these arguments. The temperature of each mode in dims is specified by
+-    the average number of excitatons `n`.
+-
+-    Parameters
+-    ----------
+-    dims : list
+-        A list of the dimensions of each subsystem of a composite quantum
+-        system.
+-
+-    excitations : integer
+-        The maximum number of excitations that are to be included in the
+-        state space.
+-
+-    n : integer
+-        The average number of exciations in the thermal state. `n` can be
+-        a float (which then applies to each mode), or a list/array of the same
+-        length as dims, in which each element corresponds specifies the
+-        temperature of the corresponding mode.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    dm : Qobj
+-        Thermal state density matrix.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
+-    if not isinstance(n, (list, np.ndarray)):
+-        n = np.ones(len(dims)) * n
+-    else:
+-        n = np.asarray(n)
+-
+-    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
+-    diags /= np.sum(diags)
+-    out = qdiags(diags, 0, dims=[dims, dims],
+-                 shape=(nstates, nstates), dtype=dtype)
+-    out._isherm = True
+-    return out
+-
+-
+-def phase_basis(N, m, phi0=0, *, dtype=None):
+-    """
+-    Basis vector for the mth phase of the Pegg-Barnett phase operator.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of basis vectors in Hilbert space.
+-
+-    m : int
+-        Integer corresponding to the mth discrete phase
+-        phi_m = phi0 + 2 * pi * m / N
+-
+-    phi0 : float (default=0)
+-        Reference phase angle.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    state : qobj
+-        Ket vector for mth Pegg-Barnett phase operator basis state.
+-
+-    Notes
+-    -----
+-    The Pegg-Barnett basis states form a complete set over the truncated
+-    Hilbert space.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    phim = phi0 + (2.0 * np.pi * m) / N
+-    n = np.arange(N)[:, np.newaxis]
+-    data = np.exp(1.0j * n * phim) / np.sqrt(N)
+-    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
+-
+-
+-def zero_ket(N, dims=None, *, dtype=None):
+-    """
+-    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Hilbert space dimensionality
+-    dims : list
+-        Optional dimensions if ket corresponds to
+-        a composite Hilbert space.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    zero_ket : qobj
+-        Zero ket on given Hilbert space.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
+-
+-
+-def spin_state(j, m, type='ket', *, dtype=None):
+-    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
+-    eigenstate of the spin-j Sz operator with eigenvalue m.
+-
+-    Parameters
+-    ----------
+-    j : float
+-        The spin of the state ().
+-
+-    m : int
+-        Eigenvalue of the spin-j Sz operator.
+-
+-    type : string {'ket', 'bra', 'dm'}
+-        Type of state to generate.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    state : qobj
+-        Qobj quantum object for spin state
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    J = 2*j + 1
+-
+-    if type == 'ket':
+-        return basis(int(J), int(j - m), dtype=dtype)
+-    elif type == 'bra':
+-        return basis(int(J), int(j - m), dtype=dtype).dag()
+-    elif type == 'dm':
+-        return fock_dm(int(J), int(j - m), dtype=dtype)
+-    else:
+-        raise ValueError(f"Invalid value keyword argument type='{type}'")
+-
+-
+-def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
+-    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
+-
+-    Parameters
+-    ----------
+-    j : float
+-        The spin of the state.
+-
+-    theta : float
+-        Angle from z axis.
+-
+-    phi : float
+-        Angle from x axis.
+-
+-    type : string {'ket', 'bra', 'dm'}
+-        Type of state to generate.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    state : qobj
+-        Qobj quantum object for spin coherent state
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    if type not in ['ket', 'bra', 'dm']:
+-        raise ValueError("Invalid value keyword argument 'type'")
+-    Sp = jmat(j, '+')
+-    Sm = jmat(j, '-')
+-    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
+-           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
+-           spin_state(j, j)
+-
+-    if type == 'bra':
+-        psi = psi.dag()
+-    elif type == 'dm':
+-        psi = ket2dm(psi)
+-    return psi.to(dtype)
+-
+-
+-_BELL_STATES = {
+-    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
+-    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
+-    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
+-    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
+-}
+-
+-def bell_state(state='00', *, dtype=None):
+-    r"""
+-    Returns the selected Bell state:
+-
+-    .. math::
+-
+-        \begin{aligned}
+-        \lvert B_{00}\rangle &=
+-            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
+-        \lvert B_{01}\rangle &=
+-            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
+-        \lvert B_{10}\rangle &=
+-            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
+-        \lvert B_{11}\rangle &=
+-            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
+-        \end{aligned}
+-
+-
+-    Parameters
+-    ----------
+-    state : str ['00', '01', `10`, `11`]
+-        Which bell state to return
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    Bell_state : qobj
+-        Bell state
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    return _BELL_STATES[state].copy().to(dtype)
+-
+-
+-def singlet_state(*, dtype=None):
+-    r"""
+-    Returns the two particle singlet-state:
+-
+-    .. math::
+-
+-        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
+-
+-    that is identical to the fourth bell state.
+-
+-    Parameters
+-    ----------
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    Bell_state : qobj
+-        :math:`\lvert B_{11}\rangle` Bell state
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    return bell_state('11').to(dtype)
+-
+-
+-def triplet_states(*, dtype=None):
+-    r"""
+-    Returns a list of the two particle triplet-states:
+-
+-    .. math::
+-
+-        \lvert T_1\rangle = \lvert11\rangle
+-        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
+-        \lvert T_3\rangle = \lvert00\rangle
+-
+-    Parameters
+-    ----------
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    trip_states : list
+-        2 particle triplet states
+-    """
+-    return [
+-        basis([2, 2], [1, 1], dtype=dtype),
+-        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
+-                        basis([2, 2], [1, 0], dtype=dtype)),
+-        basis([2, 2], [0, 0], dtype=dtype),
+-    ]
+-
+-
+-def w_state(N=3, *, dtype=None):
+-    """
+-    Returns the N-qubit W-state:
+-        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
+-
+-    Parameters
+-    ----------
+-    N : int (default=3)
+-        Number of qubits in state
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    W : :obj:`~Qobj`
+-        N-qubit W-state
+-    """
+-    inds = np.zeros(N, dtype=int)
+-    inds[0] = 1
+-    state = basis([2]*N, list(inds), dtype=dtype)
+-    for kk in range(1, N):
+-        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
+-    return np.sqrt(1 / N) * state
+-
+-
+-def ghz_state(N=3, *, dtype=None):
+-    """
+-    Returns the N-qubit GHZ-state:
+-        ``[ |00...00> + |11...11> ] / sqrt(2)``
+-
+-    Parameters
+-    ----------
+-    N : int (default=3)
+-        Number of qubits in state
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    G : qobj
+-        N-qubit GHZ-state
+-    """
+-    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
+-                           basis([2]*N, [1]*N, dtype=dtype))
++__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
++           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
++           'qstate', 'ket', 'bra', 'state_number_enumerate',
++           'state_number_index', 'state_index_number', 'state_number_qobj',
++           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
++           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
++           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
++           'enr_thermal_dm']
++
++import itertools
++import numbers
++import warnings
++
++import numpy as np
++import scipy.sparse as sp
++import itertools
++
++from . import data as _data
++from .qobj import Qobj
++from .operators import jmat, displace, qdiags
++from .tensor import tensor
++from .. import settings
++
++def _promote_to_zero_list(arg, length):
++    """
++    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
++    to `[0]*length`.  All other inputs are checked that they match the correct
++    form.
++
++    Returns
++    -------
++    list_ : list
++        A list of integers of length `length`.
++    """
++    if arg is None:
++        arg = [0]*length
++    elif not isinstance(arg, list):
++        arg = [arg]
++    if not len(arg) == length:
++        raise ValueError("All list inputs must be the same length.")
++    if all(isinstance(x, numbers.Integral) for x in arg):
++        return arg
++    raise TypeError("Dimensions must be an integer or list of integers.")
++
++
++def basis(dimensions, n=None, offset=None, *, dtype=None):
++    """Generates the vector representation of a Fock state.
++
++    Parameters
++    ----------
++    dimensions : int or list of ints
++        Number of Fock states in Hilbert space.  If a list, then the resultant
++        object will be a tensor product over spaces with those dimensions.
++
++    n : int or list of ints, optional (default 0 for all dimensions)
++        Integer corresponding to desired number state, defaults to 0 for all
++        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
++        ``dimensions`` is a list, then ``n`` must either be omitted or a list
++        of equal length.
++
++    offset : int or list of ints, optional (default 0 for all dimensions)
++        The lowest number state that is included in the finite number state
++        representation of the state in the relevant dimension.
++
++    dtype : type or str
++        storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    state : :class:`qutip.Qobj`
++      Qobj representing the requested number state ``|n>``.
++
++    Examples
++    --------
++    >>> basis(5,2) # doctest: +SKIP
++    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
++    Qobj data =
++    [[ 0.+0.j]
++     [ 0.+0.j]
++     [ 1.+0.j]
++     [ 0.+0.j]
++     [ 0.+0.j]]
++    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
++    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
++    Qobj data =
++    [[0.]
++     [0.]
++     [1.]
++     [0.]
++     [0.]
++     [0.]
++     [0.]
++     [0.]]
++
++
++    Notes
++    -----
++    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
++
++        basis(N, 0) = ground state
++
++    but in the qotoolbox::
++
++        basis(N, 1) = ground state
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    # Promote all parameters to lists to simplify later logic.
++    if not isinstance(dimensions, list):
++        dimensions = [dimensions]
++    n_dimensions = len(dimensions)
++    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
++                                  _promote_to_zero_list(offset, n_dimensions))]
++    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
++        raise ValueError("All dimensions must be >= 0.")
++    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
++        raise ValueError("All basis indices must be "
++                         "`offset <= n < dimension+offset`.")
++    location, size = 0, 1
++    for m, dimension in zip(reversed(ns), reversed(dimensions)):
++        location += m*size
++        size *= dimension
++
++    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
++    return Qobj(data,
++                dims=[dimensions, [1]*n_dimensions],
++                type='ket',
++                isherm=False,
++                isunitary=False,
++                copy=False)
++
++
++def qutrit_basis(*, dtype=None):
++    """Basis states for a three level system (qutrit)
++
++    dtype : type or str
++        storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    qstates : array
++        Array of qutrit basis vectors
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    out = np.empty((3,), dtype=object)
++    out[:] = [
++        basis(3, 0, dtype=dtype),
++        basis(3, 1, dtype=dtype),
++        basis(3, 2, dtype=dtype),
++    ]
++    return out
++
++_COHERENT_METHODS = ('operator', 'analytic')
++
++
++def coherent(N, alpha, offset=0, method=None, *, dtype=None):
++    """Generates a coherent state with eigenvalue alpha.
++
++    Constructed using displacement operator on vacuum state.
++
++    Parameters
++    ----------
++    N : int
++        Number of Fock states in Hilbert space.
++
++    alpha : float/complex
++        Eigenvalue of coherent state.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the state. Using a non-zero offset will make the
++        default method 'analytic'.
++
++    method : string {'operator', 'analytic'}
++        Method for generating coherent state.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    state : qobj
++        Qobj quantum object for coherent state
++
++    Examples
++    --------
++    >>> coherent(5,0.25j) # doctest: +SKIP
++    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
++    Qobj data =
++    [[  9.69233235e-01+0.j        ]
++     [  0.00000000e+00+0.24230831j]
++     [ -4.28344935e-02+0.j        ]
++     [  0.00000000e+00-0.00618204j]
++     [  7.80904967e-04+0.j        ]]
++
++    Notes
++    -----
++    Select method 'operator' (default) or 'analytic'. With the
++    'operator' method, the coherent state is generated by displacing
++    the vacuum state using the displacement operator defined in the
++    truncated Hilbert space of size 'N'. This method guarantees that the
++    resulting state is normalized. With 'analytic' method the coherent state
++    is generated using the analytical formula for the coherent state
++    coefficients in the Fock basis. This method does not guarantee that the
++    state is normalized if truncated to a small number of Fock states,
++    but would in that case give more accurate coefficients.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    if offset < 0:
++        raise ValueError('Offset must be non-negative')
++
++    if method is None:
++        method = "operator" if offset == 0 else "analytic"
++
++    if method == "operator":
++        if offset != 0:
++            raise ValueError(
++                "The method 'operator' does not support offset != 0. Please"
++                " select another method or set the offset to zero."
++            )
++        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
++
++    elif method == "analytic":
++        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
++        sqrtn[0] = 1  # Get rid of divide by zero warning
++        data = alpha / sqrtn
++        if offset == 0:
++            data[0] = np.exp(-abs(alpha)**2 / 2.0)
++        else:
++            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
++            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
++        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
++        return Qobj(sqrtn,
++                    dims=[[N], [1]],
++                    type='ket',
++                    copy=False).to(dtype)
++    raise TypeError(
++        "The method option can only take values in " + repr(_COHERENT_METHODS)
++    )
++
++
++def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
++    """Density matrix representation of a coherent state.
++
++    Constructed via outer product of :func:`qutip.states.coherent`
++
++    Parameters
++    ----------
++    N : int
++        Number of Fock states in Hilbert space.
++
++    alpha : float/complex
++        Eigenvalue for coherent state.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the state.
++
++    method : string {'operator', 'analytic'}
++        Method for generating coherent density matrix.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    dm : qobj
++        Density matrix representation of coherent state.
++
++    Examples
++    --------
++    >>> coherent_dm(3,0.25j) # doctest: +SKIP
++    Quantum object: dims = [[3], [3]], \
++shape = [3, 3], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
++     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
++     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
++        ]]
++
++    Notes
++    -----
++    Select method 'operator' (default) or 'analytic'. With the
++    'operator' method, the coherent density matrix is generated by displacing
++    the vacuum state using the displacement operator defined in the
++    truncated Hilbert space of size 'N'. This method guarantees that the
++    resulting density matrix is normalized. With 'analytic' method the coherent
++    density matrix is generated using the analytical formula for the coherent
++    state coefficients in the Fock basis. This method does not guarantee that
++    the state is normalized if truncated to a small number of Fock states,
++    but would in that case give more accurate coefficients.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
++
++
++def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
++    """Density matrix representation of a Fock state
++
++    Constructed via outer product of :func:`qutip.states.fock`.
++
++    Parameters
++    ----------
++    dimensions : int or list of ints
++        Number of Fock states in Hilbert space.  If a list, then the resultant
++        object will be a tensor product over spaces with those dimensions.
++
++    n : int or list of ints, optional (default 0 for all dimensions)
++        Integer corresponding to desired number state, defaults to 0 for all
++        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
++        ``dimensions`` is a list, then ``n`` must either be omitted or a list
++        of equal length.
++
++    offset : int or list of ints, optional (default 0 for all dimensions)
++        The lowest number state that is included in the finite number state
++        representation of the state in the relevant dimension.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    dm : qobj
++        Density matrix representation of Fock state.
++
++    Examples
++    --------
++     >>> fock_dm(3,1) # doctest: +SKIP
++     Quantum object: dims = [[3], [3]], \
++shape = [3, 3], type = oper, isHerm = True
++     Qobj data =
++     [[ 0.+0.j  0.+0.j  0.+0.j]
++      [ 0.+0.j  1.+0.j  0.+0.j]
++      [ 0.+0.j  0.+0.j  0.+0.j]]
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
++
++
++def fock(dimensions, n=None, offset=None, *, dtype=None):
++    """Bosonic Fock (number) state.
++
++    Same as :func:`qutip.states.basis`.
++
++    Parameters
++    ----------
++    dimensions : int or list of ints
++        Number of Fock states in Hilbert space.  If a list, then the resultant
++        object will be a tensor product over spaces with those dimensions.
++
++    n : int or list of ints, optional (default 0 for all dimensions)
++        Integer corresponding to desired number state, defaults to 0 for all
++        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
++        ``dimensions`` is a list, then ``n`` must either be omitted or a list
++        of equal length.
++
++    offset : int or list of ints, optional (default 0 for all dimensions)
++        The lowest number state that is included in the finite number state
++        representation of the state in the relevant dimension.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++        Requested number state :math:`\\left|n\\right>`.
++
++    Examples
++    --------
++    >>> fock(4,3) # doctest: +SKIP
++    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
++    Qobj data =
++    [[ 0.+0.j]
++     [ 0.+0.j]
++     [ 0.+0.j]
++     [ 1.+0.j]]
++
++    """
++    return basis(dimensions, n, offset=offset, dtype=dtype)
++
++
++def thermal_dm(N, n, method='operator', *, dtype=None):
++    """Density matrix for a thermal state of n particles
++
++    Parameters
++    ----------
++    N : int
++        Number of basis states in Hilbert space.
++
++    n : float
++        Expectation value for number of particles in thermal state.
++
++    method : string {'operator', 'analytic'}
++        ``string`` that sets the method used to generate the
++        thermal state probabilities
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    dm : qobj
++        Thermal state density matrix.
++
++    Examples
++    --------
++    >>> thermal_dm(5, 1) # doctest: +SKIP
++    Quantum object: dims = [[5], [5]], \
++shape = [5, 5], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.51612903  0.          0.          0.          0.        ]
++     [ 0.          0.25806452  0.          0.          0.        ]
++     [ 0.          0.          0.12903226  0.          0.        ]
++     [ 0.          0.          0.          0.06451613  0.        ]
++     [ 0.          0.          0.          0.          0.03225806]]
++
++
++    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
++    Quantum object: dims = [[5], [5]], \
++shape = [5, 5], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.5      0.       0.       0.       0.     ]
++     [ 0.       0.25     0.       0.       0.     ]
++     [ 0.       0.       0.125    0.       0.     ]
++     [ 0.       0.       0.       0.0625   0.     ]
++     [ 0.       0.       0.       0.       0.03125]]
++
++    Notes
++    -----
++    The 'operator' method (default) generates
++    the thermal state using the truncated number operator ``num(N)``. This
++    is the method that should be used in computations. The
++    'analytic' method uses the analytic coefficients derived in
++    an infinite Hilbert space. The analytic form is not necessarily normalized,
++    if truncated too aggressively.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    if n == 0:
++        return fock_dm(N, 0, dtype=dtype)
++    else:
++        i = np.arange(N)
++        if method == 'operator':
++            beta = np.log(1.0 / n + 1.0)
++            diags = np.exp(-beta * i)
++            diags = diags / np.sum(diags)
++            # populates diagonal terms using truncated operator expression
++
++        elif method == 'analytic':
++            # populates diagonal terms using analytic values
++            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
++        else:
++            raise ValueError("The method option can only take "
++                             "values 'operator' or 'analytic'")
++        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
++        out._isherm = True
++        return out
++
++
++def maximally_mixed_dm(N, *, dtype=None):
++    """
++    Returns the maximally mixed density matrix for a Hilbert space of
++    dimension N.
++
++    Parameters
++    ----------
++    N : int
++        Number of basis states in Hilbert space.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    dm : qobj
++        Thermal state density matrix.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    if not isinstance(N, numbers.Integral) or N <= 0:
++        raise ValueError("N must be integer N > 0")
++    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
++                type='oper', isherm=True, isunitary=(N == 1), copy=False)
++
++
++def ket2dm(Q):
++    """
++    Takes input ket or bra vector and returns density matrix formed by outer
++    product.  This is completely identical to calling `Q.proj()`.
++
++    Parameters
++    ----------
++    Q : qobj
++        Ket or bra type quantum object.
++
++    Returns
++    -------
++    dm : qobj
++        Density matrix formed by outer product of `Q`.
++
++    Examples
++    --------
++    >>> x=basis(3,2)
++    >>> ket2dm(x) # doctest: +SKIP
++    Quantum object: dims = [[3], [3]], \
++shape = [3, 3], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.+0.j  0.+0.j  0.+0.j]
++     [ 0.+0.j  0.+0.j  0.+0.j]
++     [ 0.+0.j  0.+0.j  1.+0.j]]
++
++    """
++    if Q.isket or Q.isbra:
++        return Q.proj()
++    raise TypeError("Input is not a ket or bra vector.")
++
++
++def projection(N, n, m, offset=None, *, dtype=None):
++    r"""
++    The projection operator that projects state :math:`\lvert m\rangle` on
++    state :math:`\lvert n\rangle`.
++
++    Parameters
++    ----------
++    N : int
++        Number of basis states in Hilbert space.
++
++    n, m : float
++        The number states in the projection.
++
++    offset : int (default 0)
++        The lowest number state that is included in the finite number state
++        representation of the projector.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++         Requested projection operator.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    return basis(N, n, offset=offset, dtype=dtype) @ \
++           basis(N, m, offset=offset, dtype=dtype).dag()
++
++
++def qstate(string, *, dtype=None):
++    r"""Creates a tensor product for a set of qubits in either
++    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
++
++    Parameters
++    ----------
++    string : str
++        String containing 'u' or 'd' for each qubit (ex. 'ududd')
++
++    Returns
++    -------
++    qstate : qobj
++        Qobj for tensor product corresponding to input string.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Notes
++    -----
++    Look at ket and bra for more general functions
++    creating multiparticle states.
++
++    Examples
++    --------
++    >>> qstate('udu') # doctest: +SKIP
++    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
++    Qobj data =
++    [[ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 1.]
++     [ 0.]
++     [ 0.]]
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    n = len(string)
++    if n != (string.count('u') + string.count('d')):
++        raise TypeError('String input to QSTATE must consist ' +
++                        'of "u" and "d" elements only')
++    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
++
++
++#
++# different qubit notation dictionary
++#
++_qubit_dict = {
++    'g': 0,  # ground state
++    'e': 1,  # excited state
++    'u': 0,  # spin up
++    'd': 1,  # spin down
++    'H': 0,  # horizontal polarization
++    'V': 1,  # vertical polarization
++}
++
++
++def _character_to_qudit(x):
++    """
++    Converts a character representing a one-particle state into int.
++    """
++    return _qubit_dict[x] if x in _qubit_dict else int(x)
++
++
++def ket(seq, dim=2, *, dtype=None):
++    """
++    Produces a multiparticle ket state for a list or string,
++    where each element stands for state of the respective particle.
++
++    Parameters
++    ----------
++    seq : str / list of ints or characters
++        Each element defines state of the respective particle.
++        (e.g. [1,1,0,1] or a string "1101").
++        For qubits it is also possible to use the following conventions:
++        - 'g'/'e' (ground and excited state)
++        - 'u'/'d' (spin up and down)
++        - 'H'/'V' (horizontal and vertical polarization)
++        Note: for dimension > 9 you need to use a list.
++
++
++    dim : int (default: 2) / list of ints
++        Space dimension for each particle:
++        int if there are the same, list if they are different.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    ket : qobj
++
++    Examples
++    --------
++    >>> ket("10") # doctest: +SKIP
++    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
++    Qobj data =
++    [[ 0.]
++     [ 0.]
++     [ 1.]
++     [ 0.]]
++
++    >>> ket("Hue") # doctest: +SKIP
++    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
++    Qobj data =
++    [[ 0.]
++     [ 1.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]]
++
++    >>> ket("12", 3) # doctest: +SKIP
++    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
++    Qobj data =
++    [[ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 1.]
++     [ 0.]
++     [ 0.]
++     [ 0.]]
++
++    >>> ket("31", [5, 2]) # doctest: +SKIP
++    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
++    Qobj data =
++    [[ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 0.]
++     [ 1.]
++     [ 0.]
++     [ 0.]]
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    ns = [_character_to_qudit(x) for x in seq]
++    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
++    return basis(dim, ns, dtype=dtype)
++
++
++def bra(seq, dim=2, *, dtype=None):
++    """
++    Produces a multiparticle bra state for a list or string,
++    where each element stands for state of the respective particle.
++
++    Parameters
++    ----------
++    seq : str / list of ints or characters
++        Each element defines state of the respective particle.
++        (e.g. [1,1,0,1] or a string "1101").
++        For qubits it is also possible to use the following conventions:
++
++        - 'g'/'e' (ground and excited state)
++        - 'u'/'d' (spin up and down)
++        - 'H'/'V' (horizontal and vertical polarization)
++
++        Note: for dimension > 9 you need to use a list.
++
++
++    dim : int (default: 2) / list of ints
++        Space dimension for each particle:
++        int if there are the same, list if they are different.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    bra : qobj
++
++    Examples
++    --------
++    >>> bra("10") # doctest: +SKIP
++    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
++    Qobj data =
++    [[ 0.  0.  1.  0.]]
++
++    >>> bra("Hue") # doctest: +SKIP
++    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
++    Qobj data =
++    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
++
++    >>> bra("12", 3) # doctest: +SKIP
++    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
++    Qobj data =
++    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
++
++
++    >>> bra("31", [5, 2]) # doctest: +SKIP
++    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
++    Qobj data =
++    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    return ket(seq, dim=dim, dtype=dtype).dag()
++
++
++def state_number_enumerate(dims, excitations=None):
++    """
++    An iterator that enumerates all the state number tuples (quantum numbers of
++    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
++
++    Example:
++
++        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
++        >>>     print(state) # doctest: +SKIP
++        ( 0  0 )
++        ( 0  1 )
++        ( 1  0 )
++        ( 1  1 )
++
++    Parameters
++    ----------
++    dims : list or array
++        The quantum state dimensions array, as it would appear in a Qobj.
++
++    excitations : integer (None)
++        Restrict state space to states with excitation numbers below or
++        equal to this value.
++
++    Returns
++    -------
++    state_number : tuple
++        Successive state number tuples that can be used in loops and other
++        iterations, using standard state enumeration *by definition*.
++
++    """
++
++    if excitations is None:
++        # in this case, state numbers are a direct product
++        yield from itertools.product(*(range(d) for d in dims))
++        return
++
++    # From here on, excitations is not None
++
++    # General idea of algorithm: add excitations one by one in last mode (idx =
++    # len(dims)-1), and carry over to the next index when the limit is reached.
++    # Keep track of the number of excitations while doing so to avoid having to
++    # do explicit sums over the states.
++    state = (0,)*len(dims)
++    nexc = 0
++    while True:
++        yield state
++        idx = len(dims) - 1
++        state = state[:idx] + (state[idx]+1,)
++        nexc += 1
++        while nexc > excitations or state[idx] >= dims[idx]:
++            # remove all excitations in mode idx, add one in idx-1
++            idx -= 1
++            if idx < 0:
++                return
++            nexc -= state[idx+1] - 1
++            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
++
++
++def state_number_index(dims, state):
++    """
++    Return the index of a quantum state corresponding to state,
++    given a system with dimensions given by dims.
++
++    Example:
++
++        >>> state_number_index([2, 2, 2], [1, 1, 0])
++        6
++
++    Parameters
++    ----------
++    dims : list or array
++        The quantum state dimensions array, as it would appear in a Qobj.
++
++    state : list
++        State number array.
++
++    Returns
++    -------
++    idx : int
++        The index of the state given by `state` in standard enumeration
++        ordering.
++
++    """
++    return np.ravel_multi_index(state, dims)
++
++
++def state_index_number(dims, index):
++    """
++    Return a quantum number representation given a state index, for a system
++    of composite structure defined by dims.
++
++    Example:
++
++        >>> state_index_number([2, 2, 2], 6)
++        [1, 1, 0]
++
++    Parameters
++    ----------
++    dims : list or array
++        The quantum state dimensions array, as it would appear in a Qobj.
++
++    index : integer
++        The index of the state in standard enumeration ordering.
++
++    Returns
++    -------
++    state : tuple
++        The state number tuple corresponding to index `index` in standard
++        enumeration ordering.
++
++    """
++    return np.unravel_index(index, dims)
++
++
++def state_number_qobj(dims, state, *, dtype=None):
++    """
++    Return a Qobj representation of a quantum state specified by the state
++    array `state`.
++
++    Example:
++
++        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
++        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
++shape = [8, 1], type = ket
++        Qobj data =
++        [[ 0.]
++         [ 0.]
++         [ 0.]
++         [ 0.]
++         [ 0.]
++         [ 1.]
++         [ 0.]
++         [ 0.]]
++
++    Parameters
++    ----------
++    dims : list or array
++        The quantum state dimensions array, as it would appear in a Qobj.
++
++    state : list
++        State number array.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    state : :class:`qutip.Qobj`
++        The state as a :class:`qutip.Qobj` instance.
++
++    .. note::
++        Deprecated in QuTiP 5.0, use :func:`basis` instead.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    warnings.warn("basis() is a drop-in replacement for this",
++                  DeprecationWarning)
++    return basis(dims, state, dtype=dtype)
++
++
++# Excitation-number restricted (enr) states
++
++def enr_state_dictionaries(dims, excitations):
++    """
++    Return the number of states, and lookup-dictionaries for translating
++    a state tuple to a state index, and vice versa, for a system with a given
++    number of components and maximum number of excitations.
++
++    Parameters
++    ----------
++    dims: list
++        A list with the number of states in each sub-system.
++
++    excitations : integer
++        The maximum numbers of dimension
++
++    Returns
++    -------
++    nstates, state2idx, idx2state: integer, dict, list
++        The number of states `nstates`, a dictionary for looking up state
++        indices from a state tuple, and a list containing the state tuples
++        ordered by state indices. state2idx and idx2state are reverses of
++        each other, i.e., state2idx[idx2state[idx]] = idx and
++        idx2state[state2idx[state]] = state.
++    """
++    idx2state = list(state_number_enumerate(dims, excitations))
++    state2idx = {state: idx for idx, state in enumerate(idx2state)}
++    nstates = len(idx2state)
++
++    return nstates, state2idx, idx2state
++
++
++def enr_fock(dims, excitations, state, *, dtype=None):
++    """
++    Generate the Fock state representation in a excitation-number restricted
++    state space. The `dims` argument is a list of integers that define the
++    number of quantums states of each component of a composite quantum system,
++    and the `excitations` specifies the maximum number of excitations for
++    the basis states that are to be included in the state space. The `state`
++    argument is a tuple of integers that specifies the state (in the number
++    basis representation) for which to generate the Fock state representation.
++
++    Parameters
++    ----------
++    dims : list
++        A list of the dimensions of each subsystem of a composite quantum
++        system.
++
++    excitations : integer
++        The maximum number of excitations that are to be included in the
++        state space.
++
++    state : list of integers
++        The state in the number basis representation.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    ket : Qobj
++        A Qobj instance that represent a Fock state in the exication-number-
++        restricted state space defined by `dims` and `exciations`.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
++    try:
++        data =_data.one_element[dtype]((nstates, 1),
++                                       (state2idx[tuple(state)], 0), 1)
++    except KeyError:
++        msg = (
++            "The state tuple " + str(tuple(state))
++            + " is not in the restricted state space."
++        )
++        raise ValueError(msg) from None
++    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
++
++
++def enr_thermal_dm(dims, excitations, n, *, dtype=None):
++    """
++    Generate the density operator for a thermal state in the excitation-number-
++    restricted state space defined by the `dims` and `exciations` arguments.
++    See the documentation for enr_fock for a more detailed description of
++    these arguments. The temperature of each mode in dims is specified by
++    the average number of excitatons `n`.
++
++    Parameters
++    ----------
++    dims : list
++        A list of the dimensions of each subsystem of a composite quantum
++        system.
++
++    excitations : integer
++        The maximum number of excitations that are to be included in the
++        state space.
++
++    n : integer
++        The average number of exciations in the thermal state. `n` can be
++        a float (which then applies to each mode), or a list/array of the same
++        length as dims, in which each element corresponds specifies the
++        temperature of the corresponding mode.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    dm : Qobj
++        Thermal state density matrix.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
++    if not isinstance(n, (list, np.ndarray)):
++        n = np.ones(len(dims)) * n
++    else:
++        n = np.asarray(n)
++
++    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
++    diags /= np.sum(diags)
++    out = qdiags(diags, 0, dims=[dims, dims],
++                 shape=(nstates, nstates), dtype=dtype)
++    out._isherm = True
++    return out
++
++
++def phase_basis(N, m, phi0=0, *, dtype=None):
++    """
++    Basis vector for the mth phase of the Pegg-Barnett phase operator.
++
++    Parameters
++    ----------
++    N : int
++        Number of basis vectors in Hilbert space.
++
++    m : int
++        Integer corresponding to the mth discrete phase
++        phi_m = phi0 + 2 * pi * m / N
++
++    phi0 : float (default=0)
++        Reference phase angle.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    state : qobj
++        Ket vector for mth Pegg-Barnett phase operator basis state.
++
++    Notes
++    -----
++    The Pegg-Barnett basis states form a complete set over the truncated
++    Hilbert space.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    phim = phi0 + (2.0 * np.pi * m) / N
++    n = np.arange(N)[:, np.newaxis]
++    data = np.exp(1.0j * n * phim) / np.sqrt(N)
++    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
++
++
++def zero_ket(N, dims=None, *, dtype=None):
++    """
++    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
++
++    Parameters
++    ----------
++    N : int
++        Hilbert space dimensionality
++    dims : list
++        Optional dimensions if ket corresponds to
++        a composite Hilbert space.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    zero_ket : qobj
++        Zero ket on given Hilbert space.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
++
++
++def spin_state(j, m, type='ket', *, dtype=None):
++    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
++    eigenstate of the spin-j Sz operator with eigenvalue m.
++
++    Parameters
++    ----------
++    j : float
++        The spin of the state ().
++
++    m : int
++        Eigenvalue of the spin-j Sz operator.
++
++    type : string {'ket', 'bra', 'dm'}
++        Type of state to generate.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    state : qobj
++        Qobj quantum object for spin state
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    J = 2*j + 1
++
++    if type == 'ket':
++        return basis(int(J), int(j - m), dtype=dtype)
++    elif type == 'bra':
++        return basis(int(J), int(j - m), dtype=dtype).dag()
++    elif type == 'dm':
++        return fock_dm(int(J), int(j - m), dtype=dtype)
++    else:
++        raise ValueError(f"Invalid value keyword argument type='{type}'")
++
++
++def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
++    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
++
++    Parameters
++    ----------
++    j : float
++        The spin of the state.
++
++    theta : float
++        Angle from z axis.
++
++    phi : float
++        Angle from x axis.
++
++    type : string {'ket', 'bra', 'dm'}
++        Type of state to generate.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    state : qobj
++        Qobj quantum object for spin coherent state
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    if type not in ['ket', 'bra', 'dm']:
++        raise ValueError("Invalid value keyword argument 'type'")
++    Sp = jmat(j, '+')
++    Sm = jmat(j, '-')
++    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
++           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
++           spin_state(j, j)
++
++    if type == 'bra':
++        psi = psi.dag()
++    elif type == 'dm':
++        psi = ket2dm(psi)
++    return psi.to(dtype)
++
++
++_BELL_STATES = {
++    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
++    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
++    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
++    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
++}
++
++def bell_state(state='00', *, dtype=None):
++    r"""
++    Returns the selected Bell state:
++
++    .. math::
++
++        \begin{aligned}
++        \lvert B_{00}\rangle &=
++            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
++        \lvert B_{01}\rangle &=
++            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
++        \lvert B_{10}\rangle &=
++            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
++        \lvert B_{11}\rangle &=
++            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
++        \end{aligned}
++
++
++    Parameters
++    ----------
++    state : str ['00', '01', `10`, `11`]
++        Which bell state to return
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    Bell_state : qobj
++        Bell state
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    return _BELL_STATES[state].copy().to(dtype)
++
++
++def singlet_state(*, dtype=None):
++    r"""
++    Returns the two particle singlet-state:
++
++    .. math::
++
++        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
++
++    that is identical to the fourth bell state.
++
++    Parameters
++    ----------
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    Bell_state : qobj
++        :math:`\lvert B_{11}\rangle` Bell state
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    return bell_state('11').to(dtype)
++
++
++def triplet_states(*, dtype=None):
++    r"""
++    Returns a list of the two particle triplet-states:
++
++    .. math::
++
++        \lvert T_1\rangle = \lvert11\rangle
++        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
++        \lvert T_3\rangle = \lvert00\rangle
++
++    Parameters
++    ----------
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    trip_states : list
++        2 particle triplet states
++    """
++    return [
++        basis([2, 2], [1, 1], dtype=dtype),
++        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
++                        basis([2, 2], [1, 0], dtype=dtype)),
++        basis([2, 2], [0, 0], dtype=dtype),
++    ]
++
++
++def w_state(N=3, *, dtype=None):
++    """
++    Returns the N-qubit W-state:
++        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
++
++    Parameters
++    ----------
++    N : int (default=3)
++        Number of qubits in state
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    W : :obj:`~Qobj`
++        N-qubit W-state
++    """
++    inds = np.zeros(N, dtype=int)
++    inds[0] = 1
++    state = basis([2]*N, list(inds), dtype=dtype)
++    for kk in range(1, N):
++        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
++    return np.sqrt(1 / N) * state
++
++
++def ghz_state(N=3, *, dtype=None):
++    """
++    Returns the N-qubit GHZ-state:
++        ``[ |00...00> + |11...11> ] / sqrt(2)``
++
++    Parameters
++    ----------
++    N : int (default=3)
++        Number of qubits in state
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    G : qobj
++        N-qubit GHZ-state
++    """
++    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
++                           basis([2]*N, [1]*N, dtype=dtype))
+diff --git a/qutip/core/subsystem_apply.py b/qutip/core/subsystem_apply.py
+index 013bcbc7..ecc237dd 100644
+--- a/qutip/core/subsystem_apply.py
++++ b/qutip/core/subsystem_apply.py
+@@ -1,210 +1,210 @@
+-#
+-# This code was contributed by Ben Criger. Resemblance to
+-# partial_transpose is intentional, and meant to enhance legibility.
+-#
+-
+-__all__ = ['subsystem_apply']
+-
+-import itertools
+-
+-import numpy as np
+-
+-from . import Qobj, qeye, to_kraus, tensor
+-from . import data as _data
+-
+-
+-def subsystem_apply(state, channel, mask, reference=False):
+-    """
+-    Returns the result of applying the propagator `channel` to the
+-    subsystems indicated in `mask`, which comprise the density operator
+-    `state`.
+-
+-    Parameters
+-    ----------
+-    state : :class:`qutip.qobj`
+-        A density matrix or ket.
+-
+-    channel : :class:`qutip.qobj`
+-        A propagator, either an `oper` or `super`.
+-
+-    mask : *list* / *array*
+-        A mask that selects which subsystems should be subjected to the
+-        channel.
+-
+-    reference : bool
+-        Decides whether explicit Kraus map should be used to evaluate action
+-        of channel.
+-
+-    Returns
+-    -------
+-    rho_out: :class:`qutip.qobj`
+-        A density matrix with the selected subsystems transformed
+-        according to the specified channel.
+-    """
+-    # TODO: Include sparse/dense methods a la partial_transpose.
+-    if not (state.isket or state.isoper):
+-        raise ValueError("input state must be a ket or oper")
+-    if not (channel.issuper or channel.isoper):
+-        raise ValueError("input channel must be a super or oper")
+-    # Since there's only one channel, all affected subsystems must have
+-    # the same dimensions:
+-    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
+-    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
+-           for j in range(len(aff_subs_dim_ar))):
+-        raise ValueError("affected subsystems must have the same dimension")
+-    # If the map is on the Hilbert space, it must have the same dimension
+-    # as the affected subsystem. If it is on the Liouville space, it must
+-    # exist on a space as large as the square of the Hilbert dimension.
+-    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
+-                      else aff_subs_dim_ar[0])
+-    if tuple(required_shape) != channel.shape:
+-        raise ValueError(
+-            "superoperator dimension must be the subsystem dimension squared"
+-        )
+-    mask = np.asarray(mask)
+-    if reference:
+-        return _subsystem_apply_reference(state, channel, mask)
+-    if state.isoper:
+-        return _subsystem_apply_dm(state, channel, mask)
+-    return _subsystem_apply_ket(state, channel, mask)
+-
+-
+-def _subsystem_apply_ket(state, channel, mask):
+-    # TODO Write more efficient code for single-matrix map on pure states
+-    # TODO Write more efficient code for single-subsystem map . . .
+-    return _subsystem_apply_dm(state.proj(), channel, mask)
+-
+-
+-def _subsystem_apply_dm(state, channel, mask):
+-    """
+-    Applies a channel to every subsystem indicated by a mask, by
+-    repeatedly applying the channel to each affected subsystem.
+-    """
+-    # Initialize Output Matrix
+-    rho_out = state
+-    # checked affected subsystems print arange(len(state.dims[0]))[mask]
+-    for subsystem in np.arange(len(state.dims[0]))[mask]:
+-        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
+-    return rho_out
+-
+-
+-def _one_subsystem_apply(state, channel, idx):
+-    """
+-    Applies a channel to a state on one subsystem, by breaking it into
+-    blocks and applying a reduced channel to each block.
+-    """
+-    subs_dim_ar = np.array(state.dims).T
+-
+-    # Calculate number of blocks
+-    n_blks = 1
+-    for mul_idx in range(idx):
+-        n_blks = n_blks * subs_dim_ar[mul_idx][0]
+-    blk_sz = state.shape[0] // n_blks
+-
+-    # Apply channel to top subsystem of each block in matrix
+-    full_data_matrix = state.full()
+-    for blk_r in range(n_blks):
+-        for blk_c in range(n_blks):
+-            # Apply channel to high-level blocks of matrix:
+-            blk_rx = blk_r * blk_sz
+-            blk_cx = blk_c * blk_sz
+-
+-            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
+-                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
+-                                              blk_cx : blk_cx+blk_sz],
+-                             channel)
+-    return Qobj(full_data_matrix, dims=state.dims)
+-
+-
+-def _block_apply(block, channel):
+-    return (_top_apply_U(block, channel) if channel.isoper
+-            else _top_apply_S(block, channel))
+-
+-
+-def _top_apply_U(block, channel):
+-    """
+-    Uses scalar-matrix multiplication to efficiently apply a channel to
+-    the leftmost register in the tensor product, given a unitary matrix
+-    for a channel.
+-    """
+-    split_mat = _block_split(block, *channel.shape)
+-    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
+-    for dm_row_idx in range(channel.shape[0]):
+-        for dm_col_idx in range(channel.shape[1]):
+-            for op_row_idx in range(channel.shape[0]):
+-                for op_col_idx in range(channel.shape[1]):
+-                    temp_split_mat[dm_row_idx][dm_col_idx] += (
+-                        channel[dm_row_idx, op_col_idx]
+-                        * channel[dm_col_idx, op_row_idx].conjugate()
+-                        * split_mat[op_col_idx][op_row_idx]
+-                    )
+-    return _block_join(temp_split_mat)
+-
+-
+-def _top_apply_S(block, channel):
+-    # If the channel is a super-operator, perform second block decomposition;
+-    # block-size matches Hilbert space of affected subsystem:
+-    # FIXME use state shape?
+-    n_v = int(np.sqrt(channel.shape[0]))
+-    n_h = int(np.sqrt(channel.shape[1]))
+-    column = _block_col(block, n_v, n_h)
+-    chan_mat = channel.full()
+-    temp_col = np.zeros(np.shape(column)).astype(complex)
+-    for i, row in enumerate(chan_mat):
+-        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
+-    return _block_stack(temp_col, n_v, n_h)
+-
+-
+-def _block_split(mat_in, n_v, n_h):
+-    """
+-    Returns a 4D array of matrices, splitting mat_in into
+-    n_v * n_h square sub-arrays.
+-    """
+-    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
+-
+-
+-def _block_join(mat_in):
+-    return np.hstack(np.hstack(mat_in))
+-
+-
+-def _block_col(mat_in, n_v, n_h):
+-    """
+-    Returns a 3D array of matrices, splitting mat_in into
+-    n_v * n_h square sub-arrays.
+-    """
+-    rows, cols = np.shape(mat_in)
+-    return np.reshape(
+-        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
+-        (n_v * n_h, rows // n_v, cols // n_h)
+-    )
+-
+-
+-def _block_stack(arr_in, n_v, n_h):
+-    """
+-    Inverse of _block_split
+-    """
+-    rs, cs = np.shape(arr_in)[-2:]
+-    temp = list(map(np.transpose, arr_in))
+-    # print shape(arr_in)
+-    temp = np.reshape(temp, (n_v, n_h, rs, cs))
+-    return np.hstack(np.hstack(temp)).T
+-
+-
+-def _subsystem_apply_reference(state, channel, mask):
+-    state = state.proj() if state.isket else state
+-    if channel.isoper:
+-        full_oper = tensor([channel if mask_ else qeye(size)
+-                            for size, mask_ in zip(state.dims[0], mask)])
+-        return full_oper @ state @ full_oper.dag()
+-    kraus_list = to_kraus(channel)
+-    # Kraus operators to be padded with identities:
+-    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
+-    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
+-    for operator_iter in k_qubit_kraus_list:
+-        operator_iter = iter(operator_iter)
+-        op_iter_list = [next(operator_iter) if mask[j]
+-                        else qeye(state.dims[0][j])
+-                        for j in range(len(state.dims[0]))]
+-        full_oper = tensor(list(map(Qobj, op_iter_list)))
+-        rho_out = rho_out + full_oper * state * full_oper.dag()
+-    return rho_out
++#
++# This code was contributed by Ben Criger. Resemblance to
++# partial_transpose is intentional, and meant to enhance legibility.
++#
++
++__all__ = ['subsystem_apply']
++
++import itertools
++
++import numpy as np
++
++from . import Qobj, qeye, to_kraus, tensor
++from . import data as _data
++
++
++def subsystem_apply(state, channel, mask, reference=False):
++    """
++    Returns the result of applying the propagator `channel` to the
++    subsystems indicated in `mask`, which comprise the density operator
++    `state`.
++
++    Parameters
++    ----------
++    state : :class:`qutip.qobj`
++        A density matrix or ket.
++
++    channel : :class:`qutip.qobj`
++        A propagator, either an `oper` or `super`.
++
++    mask : *list* / *array*
++        A mask that selects which subsystems should be subjected to the
++        channel.
++
++    reference : bool
++        Decides whether explicit Kraus map should be used to evaluate action
++        of channel.
++
++    Returns
++    -------
++    rho_out: :class:`qutip.qobj`
++        A density matrix with the selected subsystems transformed
++        according to the specified channel.
++    """
++    # TODO: Include sparse/dense methods a la partial_transpose.
++    if not (state.isket or state.isoper):
++        raise ValueError("input state must be a ket or oper")
++    if not (channel.issuper or channel.isoper):
++        raise ValueError("input channel must be a super or oper")
++    # Since there's only one channel, all affected subsystems must have
++    # the same dimensions:
++    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
++    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
++           for j in range(len(aff_subs_dim_ar))):
++        raise ValueError("affected subsystems must have the same dimension")
++    # If the map is on the Hilbert space, it must have the same dimension
++    # as the affected subsystem. If it is on the Liouville space, it must
++    # exist on a space as large as the square of the Hilbert dimension.
++    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
++                      else aff_subs_dim_ar[0])
++    if tuple(required_shape) != channel.shape:
++        raise ValueError(
++            "superoperator dimension must be the subsystem dimension squared"
++        )
++    mask = np.asarray(mask)
++    if reference:
++        return _subsystem_apply_reference(state, channel, mask)
++    if state.isoper:
++        return _subsystem_apply_dm(state, channel, mask)
++    return _subsystem_apply_ket(state, channel, mask)
++
++
++def _subsystem_apply_ket(state, channel, mask):
++    # TODO Write more efficient code for single-matrix map on pure states
++    # TODO Write more efficient code for single-subsystem map . . .
++    return _subsystem_apply_dm(state.proj(), channel, mask)
++
++
++def _subsystem_apply_dm(state, channel, mask):
++    """
++    Applies a channel to every subsystem indicated by a mask, by
++    repeatedly applying the channel to each affected subsystem.
++    """
++    # Initialize Output Matrix
++    rho_out = state
++    # checked affected subsystems print arange(len(state.dims[0]))[mask]
++    for subsystem in np.arange(len(state.dims[0]))[mask]:
++        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
++    return rho_out
++
++
++def _one_subsystem_apply(state, channel, idx):
++    """
++    Applies a channel to a state on one subsystem, by breaking it into
++    blocks and applying a reduced channel to each block.
++    """
++    subs_dim_ar = np.array(state.dims).T
++
++    # Calculate number of blocks
++    n_blks = 1
++    for mul_idx in range(idx):
++        n_blks = n_blks * subs_dim_ar[mul_idx][0]
++    blk_sz = state.shape[0] // n_blks
++
++    # Apply channel to top subsystem of each block in matrix
++    full_data_matrix = state.full()
++    for blk_r in range(n_blks):
++        for blk_c in range(n_blks):
++            # Apply channel to high-level blocks of matrix:
++            blk_rx = blk_r * blk_sz
++            blk_cx = blk_c * blk_sz
++
++            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
++                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
++                                              blk_cx : blk_cx+blk_sz],
++                             channel)
++    return Qobj(full_data_matrix, dims=state.dims)
++
++
++def _block_apply(block, channel):
++    return (_top_apply_U(block, channel) if channel.isoper
++            else _top_apply_S(block, channel))
++
++
++def _top_apply_U(block, channel):
++    """
++    Uses scalar-matrix multiplication to efficiently apply a channel to
++    the leftmost register in the tensor product, given a unitary matrix
++    for a channel.
++    """
++    split_mat = _block_split(block, *channel.shape)
++    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
++    for dm_row_idx in range(channel.shape[0]):
++        for dm_col_idx in range(channel.shape[1]):
++            for op_row_idx in range(channel.shape[0]):
++                for op_col_idx in range(channel.shape[1]):
++                    temp_split_mat[dm_row_idx][dm_col_idx] += (
++                        channel[dm_row_idx, op_col_idx]
++                        * channel[dm_col_idx, op_row_idx].conjugate()
++                        * split_mat[op_col_idx][op_row_idx]
++                    )
++    return _block_join(temp_split_mat)
++
++
++def _top_apply_S(block, channel):
++    # If the channel is a super-operator, perform second block decomposition;
++    # block-size matches Hilbert space of affected subsystem:
++    # FIXME use state shape?
++    n_v = int(np.sqrt(channel.shape[0]))
++    n_h = int(np.sqrt(channel.shape[1]))
++    column = _block_col(block, n_v, n_h)
++    chan_mat = channel.full()
++    temp_col = np.zeros(np.shape(column)).astype(complex)
++    for i, row in enumerate(chan_mat):
++        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
++    return _block_stack(temp_col, n_v, n_h)
++
++
++def _block_split(mat_in, n_v, n_h):
++    """
++    Returns a 4D array of matrices, splitting mat_in into
++    n_v * n_h square sub-arrays.
++    """
++    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
++
++
++def _block_join(mat_in):
++    return np.hstack(np.hstack(mat_in))
++
++
++def _block_col(mat_in, n_v, n_h):
++    """
++    Returns a 3D array of matrices, splitting mat_in into
++    n_v * n_h square sub-arrays.
++    """
++    rows, cols = np.shape(mat_in)
++    return np.reshape(
++        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
++        (n_v * n_h, rows // n_v, cols // n_h)
++    )
++
++
++def _block_stack(arr_in, n_v, n_h):
++    """
++    Inverse of _block_split
++    """
++    rs, cs = np.shape(arr_in)[-2:]
++    temp = list(map(np.transpose, arr_in))
++    # print shape(arr_in)
++    temp = np.reshape(temp, (n_v, n_h, rs, cs))
++    return np.hstack(np.hstack(temp)).T
++
++
++def _subsystem_apply_reference(state, channel, mask):
++    state = state.proj() if state.isket else state
++    if channel.isoper:
++        full_oper = tensor([channel if mask_ else qeye(size)
++                            for size, mask_ in zip(state.dims[0], mask)])
++        return full_oper @ state @ full_oper.dag()
++    kraus_list = to_kraus(channel)
++    # Kraus operators to be padded with identities:
++    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
++    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
++    for operator_iter in k_qubit_kraus_list:
++        operator_iter = iter(operator_iter)
++        op_iter_list = [next(operator_iter) if mask[j]
++                        else qeye(state.dims[0][j])
++                        for j in range(len(state.dims[0]))]
++        full_oper = tensor(list(map(Qobj, op_iter_list)))
++        rho_out = rho_out + full_oper * state * full_oper.dag()
++    return rho_out
+diff --git a/qutip/core/superop_reps.py b/qutip/core/superop_reps.py
+index c48f05fd..10fdda0f 100644
+--- a/qutip/core/superop_reps.py
++++ b/qutip/core/superop_reps.py
+@@ -1,522 +1,522 @@
+-# -*- coding: utf-8 -*-
+-#
+-# This module was initially contributed by Ben Criger.
+-#
+-"""
+-This module implements transformations between superoperator representations,
+-including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
+-"""
+-
+-__all__ = [
+-    'kraus_to_choi', 'kraus_to_super',
+-    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
+-]
+-
+-import itertools
+-import numbers
+-
+-import numpy as np
+-import scipy.linalg
+-
+-from . import data as _data
+-from .superoperator import stack_columns, unstack_columns, sprepost
+-from .tensor import tensor
+-from .dimensions import flatten
+-from .qobj import Qobj
+-from .operators import identity, sigmax, sigmay, sigmaz
+-from .states import basis
+-
+-
+-# TODO: revisit when creation routines have dispatching.
+-_SINGLE_QUBIT_PAULI_BASIS = (
+-    identity(2).to(_data.CSR),
+-    sigmax().to(_data.CSR),
+-    sigmay().to(_data.CSR),
+-    sigmaz().to(_data.CSR),
+-)
+-
+-
+-def _superpauli_basis(nq=1):
+-    dims = [[[2] * nq] * 2] * 2
+-    nnz = 8**nq
+-    data = _data.csr.empty(4**nq, 4**nq, nnz)
+-    sci = data.as_scipy(full=True)
+-    ptr, ptr_inc = 0, 2**nq
+-    # Construct the Pauli basis by vertically stacking rows in sparse format.
+-    # The CSR format is much more efficient at handling row-stacking, so we
+-    # actually have to do a little dance through adjoint/transpose to get it
+-    # into the right format.
+-    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
+-                                                 repeat=nq)):
+-        basis = paulis[0].data
+-        for pauli in paulis[1:]:
+-            basis = _data.kron_csr(basis, pauli.data)
+-        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
+-        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
+-        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
+-        sci.indptr[i] = ptr
+-        ptr += ptr_inc
+-    sci.indptr[-1] = nnz
+-    return Qobj(data.adjoint(),
+-                dims=dims,
+-                type='super',
+-                superrep='super',
+-                isherm=False,
+-                isunitary=False,
+-                copy=False)
+-
+-
+-def _int_log_two(x):
+-    return int(x).bit_length() - 1
+-
+-
+-def _is_power_of_two(x):
+-    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
+-
+-
+-def _nq(dims):
+-    dim = np.prod(dims[0][0])
+-    nq = _int_log_two(dim)
+-    if 2 ** nq != dim:
+-        raise ValueError("{} is not an integer power of 2.".format(dim))
+-    return nq
+-
+-
+-def isqubitdims(dims):
+-    """
+-    Checks whether all entries in a dims list are integer powers of 2.
+-
+-    Parameters
+-    ----------
+-    dims : nested list of ints
+-        Dimensions to be checked.
+-
+-    Returns
+-    -------
+-    isqubitdims : bool
+-        True if and only if every member of the flattened dims
+-        list is an integer power of 2.
+-    """
+-    return all(_is_power_of_two(dim) for dim in flatten(dims))
+-
+-
+-def _to_superpauli(q_oper):
+-    """
+-    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
+-
+-    This is an internal function, as QuTiP does not currently have
+-    a way to mark that superoperators are represented in the Pauli
+-    basis as opposed to the column-stacking basis; a Pauli-basis
+-    ``type='super'`` would thus break other conversion functions.
+-    """
+-    # Ensure we start with a column-stacking-basis superoperator.
+-    sqobj = to_super(q_oper)
+-    if not isqubitdims(sqobj.dims):
+-        raise ValueError("Pauli basis is only defined for qubits.")
+-    nq = _int_log_two(sqobj.shape[0]) // 2
+-    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
+-    # To do this, we have to hack a bit and force the dims to match,
+-    # since the superpauli_basis function makes different assumptions
+-    # about indices than we need here.
+-    B.dims = sqobj.dims
+-    return B.dag() @ sqobj @ B
+-
+-
+-def _choi_to_kraus(q_oper, tol=1e-9):
+-    """
+-    Takes a Choi matrix and returns a list of Kraus operators.
+-    TODO: Create a new class structure for quantum channels, perhaps as a
+-    strict sub-class of Qobj.
+-    """
+-    vals, vecs = q_oper.eigenstates()
+-    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
+-    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
+-    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
+-                 dims=dims, type='oper', copy='False')
+-            for val, vec in zip(vals, vecs) if abs(val) >= tol]
+-
+-
+-# Individual conversions from Kraus operators are public because the output
+-# list of Kraus operators is not itself a quantum object.
+-
+-def kraus_to_choi(kraus_list):
+-    """
+-    Take a list of Kraus operators and returns the Choi matrix for the channel
+-    represented by the Kraus operators in `kraus_list`
+-    """
+-    kraus_mat_list = [k.full() for k in kraus_list]
+-    op_rng = list(range(kraus_mat_list[0].shape[1]))
+-    choi_blocks = np.array(
+-        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
+-              for op in kraus_mat_list)
+-          for r_ix in op_rng]
+-         for c_ix in op_rng]
+-    )
+-    return Qobj(np.hstack(np.hstack(choi_blocks)),
+-                dims=[kraus_list[0].dims[::-1]]*2,
+-                type='super',
+-                superrep='choi',
+-                copy=False)
+-
+-
+-def kraus_to_super(kraus_list):
+-    """
+-    Convert a list of Kraus operators to a superoperator.
+-    """
+-    return to_super(kraus_to_choi(kraus_list))
+-
+-
+-def _super_tofrom_choi(q_oper):
+-    """
+-    We exploit that the basis transformation between Choi and supermatrix
+-    representations squares to the identity, so that if we munge Qobj.type,
+-    we can use the same function.
+-    """
+-    if not q_oper.issuper:
+-        raise ValueError("needs to be a superoperator")
+-    if q_oper.superrep not in ('super', 'choi'):
+-        raise ValueError("operator is not in super or choi format")
+-    data = q_oper.data.to_array()
+-    dims = q_oper.dims
+-    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
+-    d0 = np.prod(flatten(new_dims[0]))
+-    d1 = np.prod(flatten(new_dims[1]))
+-    s0 = np.prod(dims[0][0])
+-    s1 = np.prod(dims[1][1])
+-    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
+-    return Qobj(data,
+-                dims=new_dims,
+-                type='super',
+-                superrep='super' if q_oper.superrep == 'choi' else 'choi',
+-                copy=False)
+-
+-
+-def _choi_to_chi(q_oper):
+-    """
+-    Converts a Choi matrix to a Chi matrix in the Pauli basis.
+-
+-    NOTE: this is only supported for qubits right now. Need to extend to
+-    Heisenberg-Weyl for other subsystem dimensions.
+-    """
+-    nq = _nq(q_oper.dims)
+-    B = _superpauli_basis(nq).data
+-    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
+-                dims=q_oper.dims,
+-                type='super',
+-                superrep='chi',
+-                copy=False)
+-
+-
+-def _chi_to_choi(q_oper):
+-    """
+-    Converts a Chi matrix to a Choi matrix.
+-
+-    NOTE: this is only supported for qubits right now. Need to extend to
+-    Heisenberg-Weyl for other subsystem dimensions.
+-    """
+-    nq = _nq(q_oper.dims)
+-    B = _superpauli_basis(nq).data
+-    # The Chi matrix has tr(chi) == d², so we need to divide out
+-    # by that to get back to the Choi form.
+-    return Qobj(_data.mul(
+-                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
+-                    1 / q_oper.shape[0]
+-                ),
+-                dims=q_oper.dims,
+-                type='super',
+-                superrep='choi',
+-                copy=False)
+-
+-
+-def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
+-    """
+-    Given a partial isometry U and a vector of square-roots of singular values
+-    S obtained from a SVD, produces the Kraus operators represented by U.
+-
+-    Returns
+-    -------
+-    Ks : list of Qobj
+-        Quantum objects represnting each of the Kraus operators.
+-    """
+-    # We use U * S since S is 1-index, such that this is equivalent to
+-    # U . diag(S), but easier to write down.
+-    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
+-    return [
+-        Qobj(x,
+-             dims=[outdims, indims],
+-             type='oper',
+-             copy=False)
+-        for x in data
+-    ]
+-
+-
+-def _generalized_kraus(q_oper, threshold=1e-10):
+-    # TODO: document!
+-    # TODO: use this to generalize to_kraus to the case where U != V.
+-    #       This is critical for non-CP maps, as appear in (for example)
+-    #       diamond norm differences between two CP maps.
+-    if not q_oper.issuper or q_oper.superrep != "choi":
+-        raise ValueError("".join([
+-            "Expected a Choi matrix, got a ", repr(q_oper.type),
+-            " (superrep ", repr(q_oper.superrep), ")."
+-        ]))
+-
+-    # Remember the shape of the underlying space,
+-    # as we'll need this to make Kraus operators later.
+-    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
+-    # Also remember the dims breakout.
+-    out_dims, in_dims = q_oper.dims
+-    out_left, out_right = out_dims
+-    in_left, in_right = in_dims
+-
+-    # Find the SVD.
+-    U, S, V = scipy.linalg.svd(q_oper.full())
+-
+-    # Truncate away the zero singular values, up to a threshold.
+-    nonzero_idxs = S > threshold
+-    dK = nonzero_idxs.sum()
+-    U = np.array(U)[:, nonzero_idxs]
+-    # We also want S to be a single index array, which np.matrix
+-    # doesn't allow for. This is stripped by calling array() on it.
+-    S = np.sqrt(np.array(S)[nonzero_idxs])
+-    # Since NumPy returns V and not V+, we need to take the dagger
+-    # to get back to quantum info notation for Stinespring pairs.
+-    V = np.array(V.conj().T)[:, nonzero_idxs]
+-
+-    # Next, we convert each of U and V into Kraus operators.
+-    # Finally, we want the Kraus index to be left-most so that we
+-    # can map over it when making Qobjs.
+-    # FIXME: does not preserve dims!
+-    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
+-    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
+-
+-    return kU, kV
+-
+-
+-def _choi_to_stinespring(q_oper, threshold=1e-10):
+-    # TODO: document!
+-    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
+-
+-    assert len(kU) == len(kV)
+-    dK = len(kU)
+-    dL = kU[0].shape[0]
+-    dR = kV[0].shape[1]
+-    # Also remember the dims breakout.
+-    out_dims, in_dims = q_oper.dims
+-    out_left, out_right = out_dims
+-    in_left, in_right = in_dims
+-
+-    A = Qobj(_data.zeros(dK * dL, dL),
+-             dims=[out_left + [dK], out_right + [1]],
+-             type='oper',
+-             isherm=True,
+-             isunitary=False,
+-             copy=False)
+-    B = Qobj(_data.zeros(dK * dR, dR),
+-             dims=[in_left + [dK], in_right + [1]],
+-             type='oper',
+-             isherm=True,
+-             isunitary=False,
+-             copy=False)
+-
+-    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
+-        A += tensor(KL, basis(dK, idx_kraus))
+-        B += tensor(KR, basis(dK, idx_kraus))
+-
+-    # There is no input (right) Kraus index, so strip that off.
+-    del A.dims[1][-1]
+-    del B.dims[1][-1]
+-
+-    return A, B
+-
+-
+-def to_choi(q_oper):
+-    """
+-    Converts a Qobj representing a quantum map to the Choi representation,
+-    such that the trace of the returned operator is equal to the dimension
+-    of the system.
+-
+-    Parameters
+-    ----------
+-    q_oper : Qobj
+-        Superoperator to be converted to Choi representation. If
+-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+-        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
+-
+-    Returns
+-    -------
+-    choi : Qobj
+-        A quantum object representing the same map as ``q_oper``, such that
+-        ``choi.superrep == "choi"``.
+-
+-    Raises
+-    ------
+-    TypeError: if the given quantum object is not a map, or cannot be converted
+-        to Choi representation.
+-    """
+-    if q_oper.type == 'super':
+-        if q_oper.superrep == 'choi':
+-            return q_oper
+-        if q_oper.superrep == 'super':
+-            return _super_tofrom_choi(q_oper)
+-        if q_oper.superrep == 'chi':
+-            return _chi_to_choi(q_oper)
+-        else:
+-            raise TypeError(q_oper.superrep)
+-    elif q_oper.type == 'oper':
+-        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
+-    else:
+-        raise TypeError(
+-            "Conversion of Qobj with type = {0.type} "
+-            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
+-        )
+-
+-
+-def to_chi(q_oper):
+-    """
+-    Converts a Qobj representing a quantum map to a representation as a chi
+-    (process) matrix in the Pauli basis, such that the trace of the returned
+-    operator is equal to the dimension of the system.
+-
+-    Parameters
+-    ----------
+-    q_oper : Qobj
+-        Superoperator to be converted to Chi representation. If
+-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+-        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
+-
+-    Returns
+-    -------
+-    chi : Qobj
+-        A quantum object representing the same map as ``q_oper``, such that
+-        ``chi.superrep == "chi"``.
+-
+-    Raises
+-    ------
+-    TypeError: if the given quantum object is not a map, or cannot be converted
+-        to Chi representation.
+-    """
+-    if q_oper.type == 'super':
+-        if q_oper.superrep == 'chi':
+-            return q_oper
+-        elif q_oper.superrep == 'choi':
+-            return _choi_to_chi(q_oper)
+-        elif q_oper.superrep == 'super':
+-            return _choi_to_chi(to_choi(q_oper))
+-        else:
+-            raise TypeError(q_oper.superrep)
+-    elif q_oper.type == 'oper':
+-        return to_chi(sprepost(q_oper, q_oper.dag()))
+-    else:
+-        raise TypeError(
+-            "Conversion of Qobj with type = {0.type} "
+-            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
+-        )
+-
+-
+-def to_super(q_oper):
+-    """
+-    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
+-    representation.
+-
+-    Parameters
+-    ----------
+-    q_oper : Qobj
+-        Superoperator to be converted to supermatrix representation. If
+-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+-        such that ``to_super(A) == sprepost(A, A.dag())``.
+-
+-    Returns
+-    -------
+-    superop : Qobj
+-        A quantum object representing the same map as ``q_oper``, such that
+-        ``superop.superrep == "super"``.
+-
+-    Raises
+-    ------
+-    TypeError
+-        If the given quantum object is not a map, or cannot be converted
+-        to supermatrix representation.
+-    """
+-    if q_oper.type == 'super':
+-        if q_oper.superrep == "super":
+-            return q_oper
+-        elif q_oper.superrep == 'choi':
+-            return _super_tofrom_choi(q_oper)
+-        elif q_oper.superrep == 'chi':
+-            return to_super(to_choi(q_oper))
+-        else:
+-            raise ValueError(
+-                "Unrecognized superrep '{}'.".format(q_oper.superrep))
+-    elif q_oper.type == 'oper':  # Assume unitary
+-        return sprepost(q_oper, q_oper.dag())
+-    else:
+-        raise TypeError(
+-            "Conversion of Qobj with type = {0.type} "
+-            "and superrep = {0.superrep} to supermatrix not "
+-            "supported.".format(q_oper)
+-        )
+-
+-
+-def to_kraus(q_oper, tol=1e-9):
+-    """
+-    Converts a Qobj representing a quantum map to a list of quantum objects,
+-    each representing an operator in the Kraus decomposition of the given map.
+-
+-    Parameters
+-    ----------
+-    q_oper : Qobj
+-        Superoperator to be converted to Kraus representation. If
+-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+-        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
+-
+-    tol : Float
+-        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
+-        The default is to=1e-9.
+-
+-    Returns
+-    -------
+-    kraus_ops : list of Qobj
+-        A list of quantum objects, each representing a Kraus operator in the
+-        decomposition of ``q_oper``.
+-
+-    Raises
+-    ------
+-    TypeError: if the given quantum object is not a map, or cannot be
+-        decomposed into Kraus operators.
+-    """
+-    if q_oper.issuper:
+-        if q_oper.superrep != 'choi':
+-            q_oper = to_choi(q_oper)
+-        return _choi_to_kraus(q_oper, tol)
+-    elif q_oper.isoper:  # Assume unitary
+-        return [q_oper]
+-    raise TypeError(
+-        "Conversion of Qobj with type={0.type} "
+-        "and superrep={0.superrep} to Kraus decomposition not "
+-        "supported.".format(q_oper)
+-    )
+-
+-
+-def to_stinespring(q_oper, threshold=1e-10):
+-    r"""
+-    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
+-    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
+-    all inputs $X$, where the partial trace is taken over a a new index on the
+-    output dimensions of $A$ and $B$.
+-
+-    For completely positive inputs, $A$ will always equal $B$ up to precision
+-    errors.
+-
+-    Parameters
+-    ----------
+-    q_oper : Qobj
+-        Superoperator to be converted to a Stinespring pair.
+-
+-    Returns
+-    -------
+-    A, B : Qobj
+-        Quantum objects representing each of the Stinespring matrices for the
+-        input Qobj.
+-    """
+-    return _choi_to_stinespring(to_choi(q_oper), threshold)
++# -*- coding: utf-8 -*-
++#
++# This module was initially contributed by Ben Criger.
++#
++"""
++This module implements transformations between superoperator representations,
++including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
++"""
++
++__all__ = [
++    'kraus_to_choi', 'kraus_to_super',
++    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
++]
++
++import itertools
++import numbers
++
++import numpy as np
++import scipy.linalg
++
++from . import data as _data
++from .superoperator import stack_columns, unstack_columns, sprepost
++from .tensor import tensor
++from .dimensions import flatten
++from .qobj import Qobj
++from .operators import identity, sigmax, sigmay, sigmaz
++from .states import basis
++
++
++# TODO: revisit when creation routines have dispatching.
++_SINGLE_QUBIT_PAULI_BASIS = (
++    identity(2).to(_data.CSR),
++    sigmax().to(_data.CSR),
++    sigmay().to(_data.CSR),
++    sigmaz().to(_data.CSR),
++)
++
++
++def _superpauli_basis(nq=1):
++    dims = [[[2] * nq] * 2] * 2
++    nnz = 8**nq
++    data = _data.csr.empty(4**nq, 4**nq, nnz)
++    sci = data.as_scipy(full=True)
++    ptr, ptr_inc = 0, 2**nq
++    # Construct the Pauli basis by vertically stacking rows in sparse format.
++    # The CSR format is much more efficient at handling row-stacking, so we
++    # actually have to do a little dance through adjoint/transpose to get it
++    # into the right format.
++    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
++                                                 repeat=nq)):
++        basis = paulis[0].data
++        for pauli in paulis[1:]:
++            basis = _data.kron_csr(basis, pauli.data)
++        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
++        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
++        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
++        sci.indptr[i] = ptr
++        ptr += ptr_inc
++    sci.indptr[-1] = nnz
++    return Qobj(data.adjoint(),
++                dims=dims,
++                type='super',
++                superrep='super',
++                isherm=False,
++                isunitary=False,
++                copy=False)
++
++
++def _int_log_two(x):
++    return int(x).bit_length() - 1
++
++
++def _is_power_of_two(x):
++    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
++
++
++def _nq(dims):
++    dim = np.prod(dims[0][0])
++    nq = _int_log_two(dim)
++    if 2 ** nq != dim:
++        raise ValueError("{} is not an integer power of 2.".format(dim))
++    return nq
++
++
++def isqubitdims(dims):
++    """
++    Checks whether all entries in a dims list are integer powers of 2.
++
++    Parameters
++    ----------
++    dims : nested list of ints
++        Dimensions to be checked.
++
++    Returns
++    -------
++    isqubitdims : bool
++        True if and only if every member of the flattened dims
++        list is an integer power of 2.
++    """
++    return all(_is_power_of_two(dim) for dim in flatten(dims))
++
++
++def _to_superpauli(q_oper):
++    """
++    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
++
++    This is an internal function, as QuTiP does not currently have
++    a way to mark that superoperators are represented in the Pauli
++    basis as opposed to the column-stacking basis; a Pauli-basis
++    ``type='super'`` would thus break other conversion functions.
++    """
++    # Ensure we start with a column-stacking-basis superoperator.
++    sqobj = to_super(q_oper)
++    if not isqubitdims(sqobj.dims):
++        raise ValueError("Pauli basis is only defined for qubits.")
++    nq = _int_log_two(sqobj.shape[0]) // 2
++    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
++    # To do this, we have to hack a bit and force the dims to match,
++    # since the superpauli_basis function makes different assumptions
++    # about indices than we need here.
++    B.dims = sqobj.dims
++    return B.dag() @ sqobj @ B
++
++
++def _choi_to_kraus(q_oper, tol=1e-9):
++    """
++    Takes a Choi matrix and returns a list of Kraus operators.
++    TODO: Create a new class structure for quantum channels, perhaps as a
++    strict sub-class of Qobj.
++    """
++    vals, vecs = q_oper.eigenstates()
++    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
++    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
++    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
++                 dims=dims, type='oper', copy='False')
++            for val, vec in zip(vals, vecs) if abs(val) >= tol]
++
++
++# Individual conversions from Kraus operators are public because the output
++# list of Kraus operators is not itself a quantum object.
++
++def kraus_to_choi(kraus_list):
++    """
++    Take a list of Kraus operators and returns the Choi matrix for the channel
++    represented by the Kraus operators in `kraus_list`
++    """
++    kraus_mat_list = [k.full() for k in kraus_list]
++    op_rng = list(range(kraus_mat_list[0].shape[1]))
++    choi_blocks = np.array(
++        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
++              for op in kraus_mat_list)
++          for r_ix in op_rng]
++         for c_ix in op_rng]
++    )
++    return Qobj(np.hstack(np.hstack(choi_blocks)),
++                dims=[kraus_list[0].dims[::-1]]*2,
++                type='super',
++                superrep='choi',
++                copy=False)
++
++
++def kraus_to_super(kraus_list):
++    """
++    Convert a list of Kraus operators to a superoperator.
++    """
++    return to_super(kraus_to_choi(kraus_list))
++
++
++def _super_tofrom_choi(q_oper):
++    """
++    We exploit that the basis transformation between Choi and supermatrix
++    representations squares to the identity, so that if we munge Qobj.type,
++    we can use the same function.
++    """
++    if not q_oper.issuper:
++        raise ValueError("needs to be a superoperator")
++    if q_oper.superrep not in ('super', 'choi'):
++        raise ValueError("operator is not in super or choi format")
++    data = q_oper.data.to_array()
++    dims = q_oper.dims
++    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
++    d0 = np.prod(flatten(new_dims[0]))
++    d1 = np.prod(flatten(new_dims[1]))
++    s0 = np.prod(dims[0][0])
++    s1 = np.prod(dims[1][1])
++    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
++    return Qobj(data,
++                dims=new_dims,
++                type='super',
++                superrep='super' if q_oper.superrep == 'choi' else 'choi',
++                copy=False)
++
++
++def _choi_to_chi(q_oper):
++    """
++    Converts a Choi matrix to a Chi matrix in the Pauli basis.
++
++    NOTE: this is only supported for qubits right now. Need to extend to
++    Heisenberg-Weyl for other subsystem dimensions.
++    """
++    nq = _nq(q_oper.dims)
++    B = _superpauli_basis(nq).data
++    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
++                dims=q_oper.dims,
++                type='super',
++                superrep='chi',
++                copy=False)
++
++
++def _chi_to_choi(q_oper):
++    """
++    Converts a Chi matrix to a Choi matrix.
++
++    NOTE: this is only supported for qubits right now. Need to extend to
++    Heisenberg-Weyl for other subsystem dimensions.
++    """
++    nq = _nq(q_oper.dims)
++    B = _superpauli_basis(nq).data
++    # The Chi matrix has tr(chi) == d², so we need to divide out
++    # by that to get back to the Choi form.
++    return Qobj(_data.mul(
++                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
++                    1 / q_oper.shape[0]
++                ),
++                dims=q_oper.dims,
++                type='super',
++                superrep='choi',
++                copy=False)
++
++
++def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
++    """
++    Given a partial isometry U and a vector of square-roots of singular values
++    S obtained from a SVD, produces the Kraus operators represented by U.
++
++    Returns
++    -------
++    Ks : list of Qobj
++        Quantum objects represnting each of the Kraus operators.
++    """
++    # We use U * S since S is 1-index, such that this is equivalent to
++    # U . diag(S), but easier to write down.
++    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
++    return [
++        Qobj(x,
++             dims=[outdims, indims],
++             type='oper',
++             copy=False)
++        for x in data
++    ]
++
++
++def _generalized_kraus(q_oper, threshold=1e-10):
++    # TODO: document!
++    # TODO: use this to generalize to_kraus to the case where U != V.
++    #       This is critical for non-CP maps, as appear in (for example)
++    #       diamond norm differences between two CP maps.
++    if not q_oper.issuper or q_oper.superrep != "choi":
++        raise ValueError("".join([
++            "Expected a Choi matrix, got a ", repr(q_oper.type),
++            " (superrep ", repr(q_oper.superrep), ")."
++        ]))
++
++    # Remember the shape of the underlying space,
++    # as we'll need this to make Kraus operators later.
++    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
++    # Also remember the dims breakout.
++    out_dims, in_dims = q_oper.dims
++    out_left, out_right = out_dims
++    in_left, in_right = in_dims
++
++    # Find the SVD.
++    U, S, V = scipy.linalg.svd(q_oper.full())
++
++    # Truncate away the zero singular values, up to a threshold.
++    nonzero_idxs = S > threshold
++    dK = nonzero_idxs.sum()
++    U = np.array(U)[:, nonzero_idxs]
++    # We also want S to be a single index array, which np.matrix
++    # doesn't allow for. This is stripped by calling array() on it.
++    S = np.sqrt(np.array(S)[nonzero_idxs])
++    # Since NumPy returns V and not V+, we need to take the dagger
++    # to get back to quantum info notation for Stinespring pairs.
++    V = np.array(V.conj().T)[:, nonzero_idxs]
++
++    # Next, we convert each of U and V into Kraus operators.
++    # Finally, we want the Kraus index to be left-most so that we
++    # can map over it when making Qobjs.
++    # FIXME: does not preserve dims!
++    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
++    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
++
++    return kU, kV
++
++
++def _choi_to_stinespring(q_oper, threshold=1e-10):
++    # TODO: document!
++    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
++
++    assert len(kU) == len(kV)
++    dK = len(kU)
++    dL = kU[0].shape[0]
++    dR = kV[0].shape[1]
++    # Also remember the dims breakout.
++    out_dims, in_dims = q_oper.dims
++    out_left, out_right = out_dims
++    in_left, in_right = in_dims
++
++    A = Qobj(_data.zeros(dK * dL, dL),
++             dims=[out_left + [dK], out_right + [1]],
++             type='oper',
++             isherm=True,
++             isunitary=False,
++             copy=False)
++    B = Qobj(_data.zeros(dK * dR, dR),
++             dims=[in_left + [dK], in_right + [1]],
++             type='oper',
++             isherm=True,
++             isunitary=False,
++             copy=False)
++
++    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
++        A += tensor(KL, basis(dK, idx_kraus))
++        B += tensor(KR, basis(dK, idx_kraus))
++
++    # There is no input (right) Kraus index, so strip that off.
++    del A.dims[1][-1]
++    del B.dims[1][-1]
++
++    return A, B
++
++
++def to_choi(q_oper):
++    """
++    Converts a Qobj representing a quantum map to the Choi representation,
++    such that the trace of the returned operator is equal to the dimension
++    of the system.
++
++    Parameters
++    ----------
++    q_oper : Qobj
++        Superoperator to be converted to Choi representation. If
++        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
++        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
++
++    Returns
++    -------
++    choi : Qobj
++        A quantum object representing the same map as ``q_oper``, such that
++        ``choi.superrep == "choi"``.
++
++    Raises
++    ------
++    TypeError: if the given quantum object is not a map, or cannot be converted
++        to Choi representation.
++    """
++    if q_oper.type == 'super':
++        if q_oper.superrep == 'choi':
++            return q_oper
++        if q_oper.superrep == 'super':
++            return _super_tofrom_choi(q_oper)
++        if q_oper.superrep == 'chi':
++            return _chi_to_choi(q_oper)
++        else:
++            raise TypeError(q_oper.superrep)
++    elif q_oper.type == 'oper':
++        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
++    else:
++        raise TypeError(
++            "Conversion of Qobj with type = {0.type} "
++            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
++        )
++
++
++def to_chi(q_oper):
++    """
++    Converts a Qobj representing a quantum map to a representation as a chi
++    (process) matrix in the Pauli basis, such that the trace of the returned
++    operator is equal to the dimension of the system.
++
++    Parameters
++    ----------
++    q_oper : Qobj
++        Superoperator to be converted to Chi representation. If
++        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
++        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
++
++    Returns
++    -------
++    chi : Qobj
++        A quantum object representing the same map as ``q_oper``, such that
++        ``chi.superrep == "chi"``.
++
++    Raises
++    ------
++    TypeError: if the given quantum object is not a map, or cannot be converted
++        to Chi representation.
++    """
++    if q_oper.type == 'super':
++        if q_oper.superrep == 'chi':
++            return q_oper
++        elif q_oper.superrep == 'choi':
++            return _choi_to_chi(q_oper)
++        elif q_oper.superrep == 'super':
++            return _choi_to_chi(to_choi(q_oper))
++        else:
++            raise TypeError(q_oper.superrep)
++    elif q_oper.type == 'oper':
++        return to_chi(sprepost(q_oper, q_oper.dag()))
++    else:
++        raise TypeError(
++            "Conversion of Qobj with type = {0.type} "
++            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
++        )
++
++
++def to_super(q_oper):
++    """
++    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
++    representation.
++
++    Parameters
++    ----------
++    q_oper : Qobj
++        Superoperator to be converted to supermatrix representation. If
++        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
++        such that ``to_super(A) == sprepost(A, A.dag())``.
++
++    Returns
++    -------
++    superop : Qobj
++        A quantum object representing the same map as ``q_oper``, such that
++        ``superop.superrep == "super"``.
++
++    Raises
++    ------
++    TypeError
++        If the given quantum object is not a map, or cannot be converted
++        to supermatrix representation.
++    """
++    if q_oper.type == 'super':
++        if q_oper.superrep == "super":
++            return q_oper
++        elif q_oper.superrep == 'choi':
++            return _super_tofrom_choi(q_oper)
++        elif q_oper.superrep == 'chi':
++            return to_super(to_choi(q_oper))
++        else:
++            raise ValueError(
++                "Unrecognized superrep '{}'.".format(q_oper.superrep))
++    elif q_oper.type == 'oper':  # Assume unitary
++        return sprepost(q_oper, q_oper.dag())
++    else:
++        raise TypeError(
++            "Conversion of Qobj with type = {0.type} "
++            "and superrep = {0.superrep} to supermatrix not "
++            "supported.".format(q_oper)
++        )
++
++
++def to_kraus(q_oper, tol=1e-9):
++    """
++    Converts a Qobj representing a quantum map to a list of quantum objects,
++    each representing an operator in the Kraus decomposition of the given map.
++
++    Parameters
++    ----------
++    q_oper : Qobj
++        Superoperator to be converted to Kraus representation. If
++        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
++        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
++
++    tol : Float
++        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
++        The default is to=1e-9.
++
++    Returns
++    -------
++    kraus_ops : list of Qobj
++        A list of quantum objects, each representing a Kraus operator in the
++        decomposition of ``q_oper``.
++
++    Raises
++    ------
++    TypeError: if the given quantum object is not a map, or cannot be
++        decomposed into Kraus operators.
++    """
++    if q_oper.issuper:
++        if q_oper.superrep != 'choi':
++            q_oper = to_choi(q_oper)
++        return _choi_to_kraus(q_oper, tol)
++    elif q_oper.isoper:  # Assume unitary
++        return [q_oper]
++    raise TypeError(
++        "Conversion of Qobj with type={0.type} "
++        "and superrep={0.superrep} to Kraus decomposition not "
++        "supported.".format(q_oper)
++    )
++
++
++def to_stinespring(q_oper, threshold=1e-10):
++    r"""
++    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
++    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
++    all inputs $X$, where the partial trace is taken over a a new index on the
++    output dimensions of $A$ and $B$.
++
++    For completely positive inputs, $A$ will always equal $B$ up to precision
++    errors.
++
++    Parameters
++    ----------
++    q_oper : Qobj
++        Superoperator to be converted to a Stinespring pair.
++
++    Returns
++    -------
++    A, B : Qobj
++        Quantum objects representing each of the Stinespring matrices for the
++        input Qobj.
++    """
++    return _choi_to_stinespring(to_choi(q_oper), threshold)
+diff --git a/qutip/core/superoperator.py b/qutip/core/superoperator.py
+index 328862b8..2a990868 100644
+--- a/qutip/core/superoperator.py
++++ b/qutip/core/superoperator.py
+@@ -1,412 +1,412 @@
+-__all__ = [
+-    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
+-    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
+-    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
+-]
+-
+-import functools
+-
+-import numpy as np
+-
+-from .qobj import Qobj
+-from . import data as _data
+-
+-def _map_over_compound_operators(f):
+-    """
+-    Convert a function which takes Qobj into one that can also take compound
+-    operators like QobjEvo, and applies itself over all the components.
+-    """
+-    @functools.wraps(f)
+-    def out(qobj):
+-        # To avoid circular dependencies
+-        from .cy.qobjevo import QobjEvo
+-        if isinstance(qobj, QobjEvo):
+-            return qobj.linear_map(f, _skip_check=True)
+-        if not isinstance(qobj, Qobj):
+-            raise TypeError("expected a quantum object")
+-        return f(qobj)
+-    return out
+-
+-
+-def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
+-    """Assembles the Liouvillian superoperator from a Hamiltonian
+-    and a ``list`` of collapse operators.
+-
+-    Parameters
+-    ----------
+-    H : Qobj or QobjEvo (optional)
+-        System Hamiltonian or Hamiltonian component of a Liouvillian.
+-        Considered `0` if not given.
+-
+-    c_ops : array_like of Qobj or QobjEvo
+-        A ``list`` or ``array`` of collapse operators.
+-
+-    data_only :  bool [False]
+-        Return the data object instead of a Qobj
+-
+-    chi : array_like of float [None]
+-        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
+-        probability distributions of occupation of various states by numerically evaluating the derivatives
+-        of the steady state occupation probability as a function of artificial phase parameters ``chi``
+-        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
+-        the documentation of :func:`lindblad_dissipator` for references and further details.
+-        This parameter is deprecated and may be removed in QuTiP 5.
+-
+-    Returns
+-    -------
+-    L : Qobj or QobjEvo
+-        Liouvillian superoperator.
+-
+-    """
+-    # To avoid circular dependencies
+-    from .cy.qobjevo import QobjEvo
+-    if (
+-        data_only
+-        and (isinstance(H, QobjEvo)
+-             or any(isinstance(op, QobjEvo) for op in c_ops))
+-    ):
+-        raise ValueError("Cannot return the data object when computing the"
+-                         " liouvillian with QobjEvo")
+-
+-    c_ops = c_ops or []
+-    if isinstance(c_ops, (Qobj, QobjEvo)):
+-        c_ops = [c_ops]
+-    if chi and len(chi) != len(c_ops):
+-        raise ValueError('chi must be a list with same length as c_ops')
+-    chi = chi or [0] * len(c_ops)
+-
+-    if H is None:
+-        # No Hamiltonian, add the lindblad_dissipator of c_ops:
+-        if not c_ops:
+-            raise ValueError("The liouvillian need an Hamiltonian"
+-                             " and/or c_ops")
+-        out = sum(lindblad_dissipator(c_op, chi=chi_)
+-                  for c_op, chi_ in zip(c_ops, chi))
+-        return out.data if data_only else out
+-    elif not H.isoper:
+-        raise TypeError("Invalid type for Hamiltonian.")
+-
+-    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
+-        # With QobjEvo, faster computation using Data is not used
+-        L = -1.0j * (spre(H) - spost(H))
+-        L += sum(lindblad_dissipator(c_op, chi=chi_)
+-                 for c_op, chi_ in zip(c_ops, chi))
+-        return L
+-
+-    op_dims = H.dims
+-    op_shape = H.shape
+-    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
+-    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
+-    spI = _data.identity(op_shape[0], dtype=type(H.data))
+-
+-    data = _data.mul(_data.kron(spI, H.data), -1j)
+-    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
+-
+-    for c_op, chi_ in zip(c_ops, chi):
+-        c = c_op.data
+-        cd = c.adjoint()
+-        cdc = _data.matmul(cd, c)
+-        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
+-        data = _data.add(data, _data.kron(spI, cdc), -0.5)
+-        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
+-
+-    if data_only:
+-        return data
+-    else:
+-        return Qobj(data,
+-                    dims=sop_dims,
+-                    type='super',
+-                    superrep='super',
+-                    copy=False)
+-
+-
+-def lindblad_dissipator(a, b=None, data_only=False, chi=None):
+-    """
+-    Lindblad dissipator (generalized) for a single pair of collapse operators
+-    (a, b), or for a single collapse operator (a) when b is not specified:
+-
+-    .. math::
+-
+-        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
+-        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
+-
+-    Parameters
+-    ----------
+-    a : Qobj or QobjEvo
+-        Left part of collapse operator.
+-
+-    b : Qobj or QobjEvo (optional)
+-        Right part of collapse operator. If not specified, b defaults to a.
+-
+-    chi : float [None]
+-        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
+-        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
+-        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
+-        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
+-        is introduced via the generating function of the statistical moments. For examples of the technique,
+-        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
+-        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
+-        This parameter is deprecated and may be removed in QuTiP 5.
+-
+-    data_only :  bool [False]
+-        Return the data object instead of a Qobj
+-
+-    Returns
+-    -------
+-    D : qobj, QobjEvo
+-        Lindblad dissipator superoperator.
+-    """
+-    # To avoid circular dependencies
+-    from .cy.qobjevo import QobjEvo
+-    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
+-        raise ValueError("Cannot return the data object when computing the"
+-                         " collapse of a QobjEvo")
+-    if b is None:
+-        b = a
+-    ad_b = a.dag() * b
+-    if chi:
+-        D = (
+-            spre(a) * spost(b.dag()) * np.exp(1j * chi)
+-            - 0.5 * spre(ad_b)
+-            - 0.5 * spost(ad_b)
+-        )
+-    else:
+-        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
+-
+-    return D.data if data_only else D
+-
+-
+-@_map_over_compound_operators
+-def operator_to_vector(op):
+-    """
+-    Create a vector representation given a quantum operator in matrix form.
+-    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
+-    function is not designed for general-purpose matrix reshaping.
+-
+-    Parameters
+-    ----------
+-    op : Qobj or QobjEvo
+-        Quantum operator in matrix form.  This must have a type of 'oper' or
+-        'super'.
+-
+-    Returns
+-    -------
+-    Qobj or QobjEvo
+-        The same object, but re-cast into a column-stacked-vector form of type
+-        'operator-ket'.  The output is the same type as the passed object.
+-    """
+-    if op.type in ['super', 'operator-ket', 'operator-bra']:
+-        raise TypeError("Cannot convert object already "
+-                        "in super representation")
+-    return Qobj(stack_columns(op.data),
+-                dims=[op.dims, [1]],
+-                type='operator-ket',
+-                superrep="super",
+-                copy=False)
+-
+-
+-@_map_over_compound_operators
+-def vector_to_operator(op):
+-    """
+-    Create a matrix representation given a quantum operator in vector form.
+-    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
+-    function is not designed for general-purpose matrix reshaping.
+-
+-    Parameters
+-    ----------
+-    op : Qobj or QobjEvo
+-        Quantum operator in column-stacked-vector form.  This must have a type
+-        of 'operator-ket'.
+-
+-    Returns
+-    -------
+-    Qobj or QobjEvo
+-        The same object, but re-cast into "standard" operator form.  The output
+-        is the same type as the passed object.
+-    """
+-    if not op.isoperket:
+-        raise TypeError("only defined for operator-kets")
+-    if op.superrep != "super":
+-        raise TypeError("only defined for operator-kets in super format")
+-    dims = op.dims[0]
+-    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
+-                dims=dims,
+-                copy=False)
+-
+-
+-def stack_columns(matrix):
+-    """
+-    Stack the columns in a data-layer type, useful for converting an operator
+-    into a superoperator representation.
+-    """
+-    if not isinstance(matrix, (_data.Data, np.ndarray)):
+-        raise TypeError(
+-            "input " + repr(type(matrix)) + " is not data-layer type"
+-        )
+-    if isinstance(matrix, np.ndarray):
+-        return matrix.ravel('F')[:, None]
+-    return _data.column_stack(matrix)
+-
+-
+-def unstack_columns(vector, shape=None):
+-    """
+-    Unstack the columns in a data-layer type back into a 2D shape, useful for
+-    converting an operator in vector form back into a regular operator.  If
+-    `shape` is not passed, the output operator will be assumed to be square.
+-    """
+-    if not isinstance(vector, (_data.Data, np.ndarray)):
+-        raise TypeError(
+-            "input " + repr(type(vector)) + " is not data-layer type"
+-        )
+-    if (
+-        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
+-        or (isinstance(vector, np.ndarray)
+-            and ((vector.ndim == 2 and vector.shape[1] != 1)
+-                 or vector.ndim > 2))
+-    ):
+-        raise TypeError("input is not a single column")
+-    if shape is None:
+-        n = int(np.sqrt(vector.shape[0]))
+-        if n * n != vector.shape[0]:
+-            raise ValueError(
+-                "input cannot be made square, but no specific shape given"
+-            )
+-        shape = (n, n)
+-    if isinstance(vector, np.ndarray):
+-        return vector.reshape(shape, order='F')
+-    return _data.column_unstack(vector, shape[0])
+-
+-
+-def unstacked_index(size, index):
+-    """
+-    Convert an index into a column-stacked square operator with `size` rows and
+-    columns, into a pair of indices into the unstacked operator.
+-    """
+-    return index % size, index // size
+-
+-
+-def stacked_index(size, row, col):
+-    """
+-    Convert a pair of indices into a square operator of `size` into a single
+-    index into the column-stacked version of the operator.
+-    """
+-    return row + size*col
+-
+-
+-@_map_over_compound_operators
+-def spost(A):
+-    """
+-    Superoperator formed from post-multiplication by operator A
+-
+-    Parameters
+-    ----------
+-    A : Qobj or QobjEvo
+-        Quantum operator for post multiplication.
+-
+-    Returns
+-    -------
+-    super : Qobj or QobjEvo
+-        Superoperator formed from input qauntum object.
+-    """
+-    if not A.isoper:
+-        raise TypeError('Input is not a quantum operator')
+-    data = _data.kron(A.data.transpose(),
+-                      _data.identity(A.shape[0], dtype=type(A.data)))
+-    return Qobj(data,
+-                dims=[A.dims, A.dims],
+-                type='super',
+-                superrep='super',
+-                isherm=A._isherm,
+-                copy=False)
+-
+-
+-@_map_over_compound_operators
+-def spre(A):
+-    """Superoperator formed from pre-multiplication by operator A.
+-
+-    Parameters
+-    ----------
+-    A : Qobj or QobjEvo
+-        Quantum operator for pre-multiplication.
+-
+-    Returns
+-    -------
+-    super :Qobj or QobjEvo
+-        Superoperator formed from input quantum object.
+-    """
+-    if not A.isoper:
+-        raise TypeError('Input is not a quantum operator')
+-    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
+-    return Qobj(data,
+-                dims=[A.dims, A.dims],
+-                type='super',
+-                superrep='super',
+-                isherm=A._isherm,
+-                copy=False)
+-
+-
+-def _drop_projected_dims(dims):
+-    """
+-    Eliminate subsystems that has been collapsed to only one state due to
+-    a projection.
+-    """
+-    return [d for d in dims if d != 1]
+-
+-
+-def sprepost(A, B):
+-    """
+-    Superoperator formed from pre-multiplication by A and post-multiplication
+-    by B.
+-
+-    Parameters
+-    ----------
+-    A : Qobj or QobjEvo
+-        Quantum operator for pre-multiplication.
+-
+-    B : Qobj or QobjEvo
+-        Quantum operator for post-multiplication.
+-
+-    Returns
+-    -------
+-    super : Qobj or QobjEvo
+-        Superoperator formed from input quantum objects.
+-    """
+-    # To avoid circular dependencies
+-    from .cy.qobjevo import QobjEvo
+-    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
+-        return spre(A) * spost(B)
+-    dims = [[_drop_projected_dims(A.dims[0]),
+-             _drop_projected_dims(B.dims[1])],
+-            [_drop_projected_dims(A.dims[1]),
+-             _drop_projected_dims(B.dims[0])]]
+-    return Qobj(_data.kron(B.data.transpose(), A.data),
+-                dims=dims,
+-                type='super',
+-                superrep='super',
+-                isherm=A._isherm and B._isherm,
+-                copy=False)
+-
+-
+-def reshuffle(q_oper):
+-    """
+-    Column-reshuffles a ``type="super"`` Qobj.
+-    """
+-    if q_oper.type not in ('super', 'operator-ket'):
+-        raise TypeError("Reshuffling is only supported on type='super' "
+-                        "or type='operator-ket'.")
+-    # How many indices are there, and how many subsystems can we decompose
+-    # each index into?
+-    n_indices = len(q_oper.dims[0])
+-    n_subsystems = len(q_oper.dims[0][0])
+-    # Generate a list of lists (lol) that represents the permutation order we
+-    # need. It's easiest to do so if we make an array, then turn it into a lol
+-    # by using map(list, ...). That array is generated by using reshape and
+-    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
+-    # [a, a, ..., a, b, b, ..., b].
+-    perm_idxs = map(list,
+-                    np.arange(n_subsystems * n_indices)[
+-                        np.arange(n_subsystems * n_indices).reshape(
+-                            (n_indices, n_subsystems)).T.flatten()
+-                    ].reshape((n_subsystems, n_indices))
+-                    )
+-    return q_oper.permute(list(perm_idxs))
++__all__ = [
++    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
++    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
++    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
++]
++
++import functools
++
++import numpy as np
++
++from .qobj import Qobj
++from . import data as _data
++
++def _map_over_compound_operators(f):
++    """
++    Convert a function which takes Qobj into one that can also take compound
++    operators like QobjEvo, and applies itself over all the components.
++    """
++    @functools.wraps(f)
++    def out(qobj):
++        # To avoid circular dependencies
++        from .cy.qobjevo import QobjEvo
++        if isinstance(qobj, QobjEvo):
++            return qobj.linear_map(f, _skip_check=True)
++        if not isinstance(qobj, Qobj):
++            raise TypeError("expected a quantum object")
++        return f(qobj)
++    return out
++
++
++def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
++    """Assembles the Liouvillian superoperator from a Hamiltonian
++    and a ``list`` of collapse operators.
++
++    Parameters
++    ----------
++    H : Qobj or QobjEvo (optional)
++        System Hamiltonian or Hamiltonian component of a Liouvillian.
++        Considered `0` if not given.
++
++    c_ops : array_like of Qobj or QobjEvo
++        A ``list`` or ``array`` of collapse operators.
++
++    data_only :  bool [False]
++        Return the data object instead of a Qobj
++
++    chi : array_like of float [None]
++        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
++        probability distributions of occupation of various states by numerically evaluating the derivatives
++        of the steady state occupation probability as a function of artificial phase parameters ``chi``
++        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
++        the documentation of :func:`lindblad_dissipator` for references and further details.
++        This parameter is deprecated and may be removed in QuTiP 5.
++
++    Returns
++    -------
++    L : Qobj or QobjEvo
++        Liouvillian superoperator.
++
++    """
++    # To avoid circular dependencies
++    from .cy.qobjevo import QobjEvo
++    if (
++        data_only
++        and (isinstance(H, QobjEvo)
++             or any(isinstance(op, QobjEvo) for op in c_ops))
++    ):
++        raise ValueError("Cannot return the data object when computing the"
++                         " liouvillian with QobjEvo")
++
++    c_ops = c_ops or []
++    if isinstance(c_ops, (Qobj, QobjEvo)):
++        c_ops = [c_ops]
++    if chi and len(chi) != len(c_ops):
++        raise ValueError('chi must be a list with same length as c_ops')
++    chi = chi or [0] * len(c_ops)
++
++    if H is None:
++        # No Hamiltonian, add the lindblad_dissipator of c_ops:
++        if not c_ops:
++            raise ValueError("The liouvillian need an Hamiltonian"
++                             " and/or c_ops")
++        out = sum(lindblad_dissipator(c_op, chi=chi_)
++                  for c_op, chi_ in zip(c_ops, chi))
++        return out.data if data_only else out
++    elif not H.isoper:
++        raise TypeError("Invalid type for Hamiltonian.")
++
++    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
++        # With QobjEvo, faster computation using Data is not used
++        L = -1.0j * (spre(H) - spost(H))
++        L += sum(lindblad_dissipator(c_op, chi=chi_)
++                 for c_op, chi_ in zip(c_ops, chi))
++        return L
++
++    op_dims = H.dims
++    op_shape = H.shape
++    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
++    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
++    spI = _data.identity(op_shape[0], dtype=type(H.data))
++
++    data = _data.mul(_data.kron(spI, H.data), -1j)
++    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
++
++    for c_op, chi_ in zip(c_ops, chi):
++        c = c_op.data
++        cd = c.adjoint()
++        cdc = _data.matmul(cd, c)
++        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
++        data = _data.add(data, _data.kron(spI, cdc), -0.5)
++        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
++
++    if data_only:
++        return data
++    else:
++        return Qobj(data,
++                    dims=sop_dims,
++                    type='super',
++                    superrep='super',
++                    copy=False)
++
++
++def lindblad_dissipator(a, b=None, data_only=False, chi=None):
++    """
++    Lindblad dissipator (generalized) for a single pair of collapse operators
++    (a, b), or for a single collapse operator (a) when b is not specified:
++
++    .. math::
++
++        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
++        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
++
++    Parameters
++    ----------
++    a : Qobj or QobjEvo
++        Left part of collapse operator.
++
++    b : Qobj or QobjEvo (optional)
++        Right part of collapse operator. If not specified, b defaults to a.
++
++    chi : float [None]
++        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
++        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
++        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
++        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
++        is introduced via the generating function of the statistical moments. For examples of the technique,
++        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
++        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
++        This parameter is deprecated and may be removed in QuTiP 5.
++
++    data_only :  bool [False]
++        Return the data object instead of a Qobj
++
++    Returns
++    -------
++    D : qobj, QobjEvo
++        Lindblad dissipator superoperator.
++    """
++    # To avoid circular dependencies
++    from .cy.qobjevo import QobjEvo
++    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
++        raise ValueError("Cannot return the data object when computing the"
++                         " collapse of a QobjEvo")
++    if b is None:
++        b = a
++    ad_b = a.dag() * b
++    if chi:
++        D = (
++            spre(a) * spost(b.dag()) * np.exp(1j * chi)
++            - 0.5 * spre(ad_b)
++            - 0.5 * spost(ad_b)
++        )
++    else:
++        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
++
++    return D.data if data_only else D
++
++
++@_map_over_compound_operators
++def operator_to_vector(op):
++    """
++    Create a vector representation given a quantum operator in matrix form.
++    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
++    function is not designed for general-purpose matrix reshaping.
++
++    Parameters
++    ----------
++    op : Qobj or QobjEvo
++        Quantum operator in matrix form.  This must have a type of 'oper' or
++        'super'.
++
++    Returns
++    -------
++    Qobj or QobjEvo
++        The same object, but re-cast into a column-stacked-vector form of type
++        'operator-ket'.  The output is the same type as the passed object.
++    """
++    if op.type in ['super', 'operator-ket', 'operator-bra']:
++        raise TypeError("Cannot convert object already "
++                        "in super representation")
++    return Qobj(stack_columns(op.data),
++                dims=[op.dims, [1]],
++                type='operator-ket',
++                superrep="super",
++                copy=False)
++
++
++@_map_over_compound_operators
++def vector_to_operator(op):
++    """
++    Create a matrix representation given a quantum operator in vector form.
++    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
++    function is not designed for general-purpose matrix reshaping.
++
++    Parameters
++    ----------
++    op : Qobj or QobjEvo
++        Quantum operator in column-stacked-vector form.  This must have a type
++        of 'operator-ket'.
++
++    Returns
++    -------
++    Qobj or QobjEvo
++        The same object, but re-cast into "standard" operator form.  The output
++        is the same type as the passed object.
++    """
++    if not op.isoperket:
++        raise TypeError("only defined for operator-kets")
++    if op.superrep != "super":
++        raise TypeError("only defined for operator-kets in super format")
++    dims = op.dims[0]
++    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
++                dims=dims,
++                copy=False)
++
++
++def stack_columns(matrix):
++    """
++    Stack the columns in a data-layer type, useful for converting an operator
++    into a superoperator representation.
++    """
++    if not isinstance(matrix, (_data.Data, np.ndarray)):
++        raise TypeError(
++            "input " + repr(type(matrix)) + " is not data-layer type"
++        )
++    if isinstance(matrix, np.ndarray):
++        return matrix.ravel('F')[:, None]
++    return _data.column_stack(matrix)
++
++
++def unstack_columns(vector, shape=None):
++    """
++    Unstack the columns in a data-layer type back into a 2D shape, useful for
++    converting an operator in vector form back into a regular operator.  If
++    `shape` is not passed, the output operator will be assumed to be square.
++    """
++    if not isinstance(vector, (_data.Data, np.ndarray)):
++        raise TypeError(
++            "input " + repr(type(vector)) + " is not data-layer type"
++        )
++    if (
++        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
++        or (isinstance(vector, np.ndarray)
++            and ((vector.ndim == 2 and vector.shape[1] != 1)
++                 or vector.ndim > 2))
++    ):
++        raise TypeError("input is not a single column")
++    if shape is None:
++        n = int(np.sqrt(vector.shape[0]))
++        if n * n != vector.shape[0]:
++            raise ValueError(
++                "input cannot be made square, but no specific shape given"
++            )
++        shape = (n, n)
++    if isinstance(vector, np.ndarray):
++        return vector.reshape(shape, order='F')
++    return _data.column_unstack(vector, shape[0])
++
++
++def unstacked_index(size, index):
++    """
++    Convert an index into a column-stacked square operator with `size` rows and
++    columns, into a pair of indices into the unstacked operator.
++    """
++    return index % size, index // size
++
++
++def stacked_index(size, row, col):
++    """
++    Convert a pair of indices into a square operator of `size` into a single
++    index into the column-stacked version of the operator.
++    """
++    return row + size*col
++
++
++@_map_over_compound_operators
++def spost(A):
++    """
++    Superoperator formed from post-multiplication by operator A
++
++    Parameters
++    ----------
++    A : Qobj or QobjEvo
++        Quantum operator for post multiplication.
++
++    Returns
++    -------
++    super : Qobj or QobjEvo
++        Superoperator formed from input qauntum object.
++    """
++    if not A.isoper:
++        raise TypeError('Input is not a quantum operator')
++    data = _data.kron(A.data.transpose(),
++                      _data.identity(A.shape[0], dtype=type(A.data)))
++    return Qobj(data,
++                dims=[A.dims, A.dims],
++                type='super',
++                superrep='super',
++                isherm=A._isherm,
++                copy=False)
++
++
++@_map_over_compound_operators
++def spre(A):
++    """Superoperator formed from pre-multiplication by operator A.
++
++    Parameters
++    ----------
++    A : Qobj or QobjEvo
++        Quantum operator for pre-multiplication.
++
++    Returns
++    -------
++    super :Qobj or QobjEvo
++        Superoperator formed from input quantum object.
++    """
++    if not A.isoper:
++        raise TypeError('Input is not a quantum operator')
++    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
++    return Qobj(data,
++                dims=[A.dims, A.dims],
++                type='super',
++                superrep='super',
++                isherm=A._isherm,
++                copy=False)
++
++
++def _drop_projected_dims(dims):
++    """
++    Eliminate subsystems that has been collapsed to only one state due to
++    a projection.
++    """
++    return [d for d in dims if d != 1]
++
++
++def sprepost(A, B):
++    """
++    Superoperator formed from pre-multiplication by A and post-multiplication
++    by B.
++
++    Parameters
++    ----------
++    A : Qobj or QobjEvo
++        Quantum operator for pre-multiplication.
++
++    B : Qobj or QobjEvo
++        Quantum operator for post-multiplication.
++
++    Returns
++    -------
++    super : Qobj or QobjEvo
++        Superoperator formed from input quantum objects.
++    """
++    # To avoid circular dependencies
++    from .cy.qobjevo import QobjEvo
++    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
++        return spre(A) * spost(B)
++    dims = [[_drop_projected_dims(A.dims[0]),
++             _drop_projected_dims(B.dims[1])],
++            [_drop_projected_dims(A.dims[1]),
++             _drop_projected_dims(B.dims[0])]]
++    return Qobj(_data.kron(B.data.transpose(), A.data),
++                dims=dims,
++                type='super',
++                superrep='super',
++                isherm=A._isherm and B._isherm,
++                copy=False)
++
++
++def reshuffle(q_oper):
++    """
++    Column-reshuffles a ``type="super"`` Qobj.
++    """
++    if q_oper.type not in ('super', 'operator-ket'):
++        raise TypeError("Reshuffling is only supported on type='super' "
++                        "or type='operator-ket'.")
++    # How many indices are there, and how many subsystems can we decompose
++    # each index into?
++    n_indices = len(q_oper.dims[0])
++    n_subsystems = len(q_oper.dims[0][0])
++    # Generate a list of lists (lol) that represents the permutation order we
++    # need. It's easiest to do so if we make an array, then turn it into a lol
++    # by using map(list, ...). That array is generated by using reshape and
++    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
++    # [a, a, ..., a, b, b, ..., b].
++    perm_idxs = map(list,
++                    np.arange(n_subsystems * n_indices)[
++                        np.arange(n_subsystems * n_indices).reshape(
++                            (n_indices, n_subsystems)).T.flatten()
++                    ].reshape((n_subsystems, n_indices))
++                    )
++    return q_oper.permute(list(perm_idxs))
+diff --git a/qutip/core/tensor.py b/qutip/core/tensor.py
+index 969d2ad8..7947b3ab 100644
+--- a/qutip/core/tensor.py
++++ b/qutip/core/tensor.py
+@@ -1,462 +1,462 @@
+-"""
+-Module for the creation of composite quantum objects via the tensor product.
+-"""
+-
+-__all__ = [
+-    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
+-    'expand_operator'
+-]
+-
+-import numpy as np
+-from functools import partial
+-from .operators import qeye
+-from .qobj import Qobj
+-from .superoperator import operator_to_vector, reshuffle
+-from .dimensions import (
+-    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
+-    dims_idxs_to_tensor_idxs
+-)
+-from . import data as _data
+-
+-
+-class _reverse_partial_tensor:
+-    """ Picklable lambda op: tensor(op, right) """
+-    def __init__(self, right):
+-        self.right = right
+-
+-    def __call__(self, op):
+-        return tensor(op, self.right)
+-
+-
+-def tensor(*args):
+-    """Calculates the tensor product of input operators.
+-
+-    Parameters
+-    ----------
+-    args : array_like
+-        ``list`` or ``array`` of quantum objects for tensor product.
+-
+-    Returns
+-    -------
+-    obj : qobj
+-        A composite quantum object.
+-
+-    Examples
+-    --------
+-    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
+-    Quantum object: dims = [[2, 2], [2, 2]], \
+-shape = [4, 4], type = oper, isHerm = True
+-    Qobj data =
+-    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
+-     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
+-     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
+-     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
+-    """
+-    from .cy.qobjevo import QobjEvo
+-    if not args:
+-        raise TypeError("Requires at least one input argument")
+-    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
+-        return args[0].copy()
+-    if len(args) == 1:
+-        try:
+-            args = tuple(args[0])
+-        except TypeError:
+-            raise TypeError("requires Qobj or QobjEvo operands") from None
+-    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
+-        raise TypeError("requires Qobj or QobjEvo operands")
+-    if any(isinstance(q, QobjEvo) for q in args):
+-        # First make tensor from pairs only
+-        if len(args) >= 3:
+-            return tensor(args[0], tensor(args[1:]))
+-
+-        left, right = args
+-        if isinstance(left, Qobj):
+-            return right.linear_map(partial(tensor, left))
+-        if isinstance(right, Qobj):
+-            return left.linear_map(_reverse_partial_tensor(right))
+-        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
+-        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
+-        return left_t @ right_t
+-
+-    if not all(q.superrep == args[0].superrep for q in args[1:]):
+-        raise TypeError("".join([
+-            "In tensor products of superroperators,",
+-            " all must have the same representation"
+-        ]))
+-    type = args[0].type
+-    isherm = args[0]._isherm
+-    isunitary = args[0]._isunitary
+-    out_data = args[0].data
+-    dims_l = [d for arg in args for d in arg.dims[0]]
+-    dims_r = [d for arg in args for d in arg.dims[1]]
+-    for arg in args[1:]:
+-        out_data = _data.kron(out_data, arg.data)
+-        # If both _are_ Hermitian and/or unitary, then so is the output, but if
+-        # both _aren't_, then output still can be.
+-        isherm = (isherm and arg._isherm) or None
+-        isunitary = (isunitary and arg._isunitary) or None
+-        if arg.type != type:
+-            type = None
+-    return Qobj(out_data,
+-                dims=[dims_l, dims_r],
+-                type=type,
+-                isherm=isherm,
+-                isunitary=isunitary,
+-                superrep=args[0].superrep,
+-                copy=False)
+-
+-
+-def super_tensor(*args):
+-    """
+-    Calculate the tensor product of input superoperators, by tensoring together
+-    the underlying Hilbert spaces on which each vectorized operator acts.
+-
+-    Parameters
+-    ----------
+-    args : array_like
+-        ``list`` or ``array`` of quantum objects with ``type="super"``.
+-
+-    Returns
+-    -------
+-    obj : qobj
+-        A composite quantum object.
+-    """
+-    if isinstance(args[0], list):
+-        args = args[0]
+-
+-    # Check if we're tensoring vectors or superoperators.
+-    if all(arg.issuper for arg in args):
+-        if not all(arg.superrep == "super" for arg in args):
+-            raise TypeError(
+-                "super_tensor on type='super' is only implemented for "
+-                "superrep='super'."
+-            )
+-
+-        # Reshuffle the superoperators.
+-        shuffled_ops = list(map(reshuffle, args))
+-
+-        # Tensor the result.
+-        shuffled_tensor = tensor(shuffled_ops)
+-
+-        # Unshuffle and return.
+-        out = reshuffle(shuffled_tensor)
+-        out.superrep = args[0].superrep
+-        return out
+-    if all(arg.isoperket for arg in args):
+-
+-        # Reshuffle the superoperators.
+-        shuffled_ops = list(map(reshuffle, args))
+-
+-        # Tensor the result.
+-        shuffled_tensor = tensor(shuffled_ops)
+-
+-        # Unshuffle and return.
+-        out = reshuffle(shuffled_tensor)
+-        return out
+-
+-    if all(arg.isoperbra for arg in args):
+-        return super_tensor(*(arg.dag() for arg in args)).dag()
+-    raise TypeError(
+-        "All arguments must be the same type, "
+-        "either super, operator-ket or operator-bra."
+-    )
+-
+-
+-def _isoperlike(q):
+-    return q.isoper or q.issuper
+-
+-
+-def _isketlike(q):
+-    return q.isket or q.isoperket
+-
+-
+-def _isbralike(q):
+-    return q.isbra or q.isoperbra
+-
+-
+-def composite(*args):
+-    """
+-    Given two or more operators, kets or bras, returns the Qobj
+-    corresponding to a composite system over each argument.
+-    For ordinary operators and vectors, this is the tensor product,
+-    while for superoperators and vectorized operators, this is
+-    the column-reshuffled tensor product.
+-
+-    If a mix of Qobjs supported on Hilbert and Liouville spaces
+-    are passed in, the former are promoted. Ordinary operators
+-    are assumed to be unitaries, and are promoted using ``to_super``,
+-    while kets and bras are promoted by taking their projectors and
+-    using ``operator_to_vector(ket2dm(arg))``.
+-    """
+-    import qutip.core.superop_reps
+-    # First step will be to ensure everything is a Qobj at all.
+-    if not all(isinstance(arg, Qobj) for arg in args):
+-        raise TypeError("All arguments must be Qobjs.")
+-
+-    # Next, figure out if we have something oper-like (isoper or issuper),
+-    # or something ket-like (isket or isoperket). Bra-like we'll deal with
+-    # by turning things into ket-likes and back.
+-    if all(map(_isoperlike, args)):
+-        if any(arg.issuper for arg in args):
+-            # to_super will promote 'oper' and leave 'super' untouched
+-            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
+-        return tensor(*args)
+-    if all(map(_isketlike, args)):
+-        if any(arg.isoperket for arg in args):
+-            return super_tensor(*(
+-                arg if arg.isoperket else operator_to_vector(arg.proj())
+-                for arg in args
+-            ))
+-        return tensor(*args)
+-    if all(map(_isbralike, args)):
+-        # Turn into ket-likes and recurse.
+-        return composite(*(arg.dag() for arg in args)).dag()
+-    raise TypeError("Unsupported Qobj types [{}].".format(
+-        ", ".join(arg.type for arg in args)
+-    ))
+-
+-
+-def _tensor_contract_single(arr, i, j):
+-    """
+-    Contracts a dense tensor along a single index pair.
+-    """
+-    if arr.shape[i] != arr.shape[j]:
+-        raise ValueError("Cannot contract over indices of different length.")
+-    idxs = np.arange(arr.shape[i])
+-    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
+-               for idx in range(arr.ndim))
+-    contract_at = i if j == i + 1 else 0
+-    return np.sum(arr[sl], axis=contract_at)
+-
+-
+-def _tensor_contract_dense(arr, *pairs):
+-    """
+-    Contracts a dense tensor along one or more index pairs,
+-    keeping track of how the indices are relabeled by the removal
+-    of other indices.
+-    """
+-    axis_idxs = list(range(arr.ndim))
+-    for pair in pairs:
+-        # axis_idxs.index effectively evaluates the mapping from original index
+-        # labels to the labels after contraction.
+-        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
+-        axis_idxs.remove(pair[0])
+-        axis_idxs.remove(pair[1])
+-    return arr
+-
+-
+-def tensor_swap(q_oper, *pairs):
+-    """Transposes one or more pairs of indices of a Qobj.
+-    Note that this uses dense representations and thus
+-    should *not* be used for very large Qobjs.
+-
+-    Parameters
+-    ----------
+-
+-    pairs : tuple
+-        One or more tuples ``(i, j)`` indicating that the
+-        ``i`` and ``j`` dimensions of the original qobj
+-        should be swapped.
+-
+-    Returns
+-    -------
+-
+-    sqobj : Qobj
+-        The original Qobj with all named index pairs swapped with each other
+-    """
+-    dims = q_oper.dims
+-    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
+-    data = q_oper.full()
+-    # Reshape into tensor indices
+-    data = data.reshape(dims_to_tensor_shape(dims))
+-    # Now permute the dims list so we know how to get back.
+-    flat_dims = flatten(dims)
+-    perm = list(range(len(flat_dims)))
+-    for i, j in pairs:
+-        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
+-    for i, j in tensor_pairs:
+-        perm[i], perm[j] = perm[j], perm[i]
+-    dims = unflatten(flat_dims, enumerate_flat(dims))
+-    # Next, permute the actual indices of the dense tensor.
+-    data = data.transpose(perm)
+-    # Reshape back, using the left and right of dims.
+-    data = data.reshape(list(map(np.prod, dims)))
+-    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
+-
+-
+-def tensor_contract(qobj, *pairs):
+-    """Contracts a qobj along one or more index pairs.
+-    Note that this uses dense representations and thus
+-    should *not* be used for very large Qobjs.
+-
+-    Parameters
+-    ----------
+-
+-    pairs : tuple
+-        One or more tuples ``(i, j)`` indicating that the
+-        ``i`` and ``j`` dimensions of the original qobj
+-        should be contracted.
+-
+-    Returns
+-    -------
+-
+-    cqobj : Qobj
+-        The original Qobj with all named index pairs contracted
+-        away.
+-
+-    """
+-    # Record and label the original dims.
+-    dims = qobj.dims
+-    dims_idxs = enumerate_flat(dims)
+-    tensor_dims = dims_to_tensor_shape(dims)
+-
+-    # Convert to dense first, since sparse won't support the reshaping we need.
+-    qtens = qobj.data.to_array()
+-
+-    # Reshape by the flattened dims.
+-    qtens = qtens.reshape(tensor_dims)
+-
+-    # Contract out the indices from the flattened object.
+-    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
+-    # to ensure that we are contracting the right indices.
+-    qtens = _tensor_contract_dense(qtens,
+-                                   *dims_idxs_to_tensor_idxs(dims, pairs))
+-
+-    # Remove the contracted indexes from dims so we know how to
+-    # reshape back.
+-    # This concerns dims, and not the tensor indices, so we need
+-    # to make sure to use the original dims indices and not the ones
+-    # generated by dims_to_* functions.
+-    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
+-    contracted_dims = unflatten(flatten(dims), contracted_idxs)
+-
+-    # We don't need to check for tensor idxs versus dims idxs here,
+-    # as column- versus row-stacking will never move an index for the
+-    # vectorized operator spaces all the way from the left to the right.
+-    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
+-
+-    # Reshape back into a 2D matrix.
+-    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
+-
+-    # Return back as a qobj.
+-    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
+-
+-
+-def _check_oper_dims(oper, dims=None, targets=None):
+-    """
+-    Check if the given operator is valid.
+-
+-    Parameters
+-    ----------
+-    oper : :class:`qutip.Qobj`
+-        The quantum object to be checked.
+-    dims : list, optional
+-        A list of integer for the dimension of each composite system.
+-        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
+-    targets : int or list of int, optional
+-        The indices of subspace that are acted on.
+-    """
+-    # if operator matches N
+-    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
+-        raise ValueError(
+-            "The operator is not an "
+-            "Qobj with the same input and output dimensions.")
+-    # if operator dims matches the target dims
+-    if dims is not None and targets is not None:
+-        targ_dims = [dims[t] for t in targets]
+-        if oper.dims[0] != targ_dims:
+-            raise ValueError(
+-                "The operator dims {} do not match "
+-                "the target dims {}.".format(
+-                    oper.dims[0], targ_dims))
+-
+-
+-def _targets_to_list(targets, oper=None, N=None):
+-    """
+-    transform targets to a list and check validity.
+-
+-    Parameters
+-    ----------
+-    targets : int or list of int
+-        The indices of subspace that are acted on.
+-    oper : :class:`qutip.Qobj`, optional
+-        An operator, the type of the :class:`qutip.Qobj`
+-        has to be an operator
+-        and the dimension matches the tensored qubit Hilbert space
+-        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
+-    N : int, optional
+-        The number of subspace in the system.
+-    """
+-    # if targets is a list of integer
+-    if targets is None:
+-        targets = list(range(len(oper.dims[0])))
+-    if not hasattr(targets, '__iter__'):
+-        targets = [targets]
+-    if not all([isinstance(t, int) for t in targets]):
+-        raise TypeError(
+-            "targets should be "
+-            "an integer or a list of integer")
+-    # if targets has correct length
+-    if oper is not None:
+-        req_num = len(oper.dims[0])
+-        if len(targets) != req_num:
+-            raise ValueError(
+-                "The given operator needs {} "
+-                "target qutbis, "
+-                "but {} given.".format(
+-                    req_num, len(targets)))
+-    # if targets is smaller than N
+-    if N is not None:
+-        if not all([t < N for t in targets]):
+-            raise ValueError("Targets must be smaller than N={}.".format(N))
+-    return targets
+-
+-
+-def expand_operator(oper, dims, targets):
+-    """
+-    Expand an operator to one that acts on a system with desired dimensions.
+-    e.g.
+-    ```
+-    expand_operator(oper, [2, 3, 4, 5], 2) ==
+-        tensor(qeye(2), qeye(3), oper, qeye(5))
+-    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
+-        tensor(oper2, qeye(3), oper1, qeye(5))
+-    ```
+-
+-    Parameters
+-    ----------
+-    oper : :class:`qutip.Qobj`
+-        An operator that act on the subsystem, has to be an operator and the
+-        dimension matches the tensored dims Hilbert space
+-        e.g. oper.dims = ``[[2, 3], [2, 3]]``
+-    dims : list
+-        A list of integer for the dimension of each composite system.
+-        E.g ``[2, 3, 2, 3, 4]``.
+-    targets : int or list of int
+-        The indices of subspace that are acted on.
+-
+-    Returns
+-    -------
+-    expanded_oper : :class:`qutip.Qobj`
+-        The expanded operator acting on a system with desired dimension.
+-    """
+-    from .operators import identity
+-    N = len(dims)
+-    targets = _targets_to_list(targets, oper=oper, N=N)
+-    _check_oper_dims(oper, dims=dims, targets=targets)
+-
+-    # Generate the correct order for permutation,
+-    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
+-    # If the operator is cnot,
+-    # this order means that the 3rd qubit controls the 0th qubit.
+-    new_order = [0] * N
+-    for i, t in enumerate(targets):
+-        new_order[t] = i
+-    # allocate the rest qutbits (not targets) to the empty
+-    # position in new_order
+-    rest_pos = [q for q in list(range(N)) if q not in targets]
+-    rest_qubits = list(range(len(targets), N))
+-    for i, ind in enumerate(rest_pos):
+-        new_order[ind] = rest_qubits[i]
+-    id_list = [identity(dims[i]) for i in rest_pos]
+-    return tensor([oper] + id_list).permute(new_order)
++"""
++Module for the creation of composite quantum objects via the tensor product.
++"""
++
++__all__ = [
++    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
++    'expand_operator'
++]
++
++import numpy as np
++from functools import partial
++from .operators import qeye
++from .qobj import Qobj
++from .superoperator import operator_to_vector, reshuffle
++from .dimensions import (
++    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
++    dims_idxs_to_tensor_idxs
++)
++from . import data as _data
++
++
++class _reverse_partial_tensor:
++    """ Picklable lambda op: tensor(op, right) """
++    def __init__(self, right):
++        self.right = right
++
++    def __call__(self, op):
++        return tensor(op, self.right)
++
++
++def tensor(*args):
++    """Calculates the tensor product of input operators.
++
++    Parameters
++    ----------
++    args : array_like
++        ``list`` or ``array`` of quantum objects for tensor product.
++
++    Returns
++    -------
++    obj : qobj
++        A composite quantum object.
++
++    Examples
++    --------
++    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
++    Quantum object: dims = [[2, 2], [2, 2]], \
++shape = [4, 4], type = oper, isHerm = True
++    Qobj data =
++    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
++     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
++     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
++     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
++    """
++    from .cy.qobjevo import QobjEvo
++    if not args:
++        raise TypeError("Requires at least one input argument")
++    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
++        return args[0].copy()
++    if len(args) == 1:
++        try:
++            args = tuple(args[0])
++        except TypeError:
++            raise TypeError("requires Qobj or QobjEvo operands") from None
++    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
++        raise TypeError("requires Qobj or QobjEvo operands")
++    if any(isinstance(q, QobjEvo) for q in args):
++        # First make tensor from pairs only
++        if len(args) >= 3:
++            return tensor(args[0], tensor(args[1:]))
++
++        left, right = args
++        if isinstance(left, Qobj):
++            return right.linear_map(partial(tensor, left))
++        if isinstance(right, Qobj):
++            return left.linear_map(_reverse_partial_tensor(right))
++        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
++        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
++        return left_t @ right_t
++
++    if not all(q.superrep == args[0].superrep for q in args[1:]):
++        raise TypeError("".join([
++            "In tensor products of superroperators,",
++            " all must have the same representation"
++        ]))
++    type = args[0].type
++    isherm = args[0]._isherm
++    isunitary = args[0]._isunitary
++    out_data = args[0].data
++    dims_l = [d for arg in args for d in arg.dims[0]]
++    dims_r = [d for arg in args for d in arg.dims[1]]
++    for arg in args[1:]:
++        out_data = _data.kron(out_data, arg.data)
++        # If both _are_ Hermitian and/or unitary, then so is the output, but if
++        # both _aren't_, then output still can be.
++        isherm = (isherm and arg._isherm) or None
++        isunitary = (isunitary and arg._isunitary) or None
++        if arg.type != type:
++            type = None
++    return Qobj(out_data,
++                dims=[dims_l, dims_r],
++                type=type,
++                isherm=isherm,
++                isunitary=isunitary,
++                superrep=args[0].superrep,
++                copy=False)
++
++
++def super_tensor(*args):
++    """
++    Calculate the tensor product of input superoperators, by tensoring together
++    the underlying Hilbert spaces on which each vectorized operator acts.
++
++    Parameters
++    ----------
++    args : array_like
++        ``list`` or ``array`` of quantum objects with ``type="super"``.
++
++    Returns
++    -------
++    obj : qobj
++        A composite quantum object.
++    """
++    if isinstance(args[0], list):
++        args = args[0]
++
++    # Check if we're tensoring vectors or superoperators.
++    if all(arg.issuper for arg in args):
++        if not all(arg.superrep == "super" for arg in args):
++            raise TypeError(
++                "super_tensor on type='super' is only implemented for "
++                "superrep='super'."
++            )
++
++        # Reshuffle the superoperators.
++        shuffled_ops = list(map(reshuffle, args))
++
++        # Tensor the result.
++        shuffled_tensor = tensor(shuffled_ops)
++
++        # Unshuffle and return.
++        out = reshuffle(shuffled_tensor)
++        out.superrep = args[0].superrep
++        return out
++    if all(arg.isoperket for arg in args):
++
++        # Reshuffle the superoperators.
++        shuffled_ops = list(map(reshuffle, args))
++
++        # Tensor the result.
++        shuffled_tensor = tensor(shuffled_ops)
++
++        # Unshuffle and return.
++        out = reshuffle(shuffled_tensor)
++        return out
++
++    if all(arg.isoperbra for arg in args):
++        return super_tensor(*(arg.dag() for arg in args)).dag()
++    raise TypeError(
++        "All arguments must be the same type, "
++        "either super, operator-ket or operator-bra."
++    )
++
++
++def _isoperlike(q):
++    return q.isoper or q.issuper
++
++
++def _isketlike(q):
++    return q.isket or q.isoperket
++
++
++def _isbralike(q):
++    return q.isbra or q.isoperbra
++
++
++def composite(*args):
++    """
++    Given two or more operators, kets or bras, returns the Qobj
++    corresponding to a composite system over each argument.
++    For ordinary operators and vectors, this is the tensor product,
++    while for superoperators and vectorized operators, this is
++    the column-reshuffled tensor product.
++
++    If a mix of Qobjs supported on Hilbert and Liouville spaces
++    are passed in, the former are promoted. Ordinary operators
++    are assumed to be unitaries, and are promoted using ``to_super``,
++    while kets and bras are promoted by taking their projectors and
++    using ``operator_to_vector(ket2dm(arg))``.
++    """
++    import qutip.core.superop_reps
++    # First step will be to ensure everything is a Qobj at all.
++    if not all(isinstance(arg, Qobj) for arg in args):
++        raise TypeError("All arguments must be Qobjs.")
++
++    # Next, figure out if we have something oper-like (isoper or issuper),
++    # or something ket-like (isket or isoperket). Bra-like we'll deal with
++    # by turning things into ket-likes and back.
++    if all(map(_isoperlike, args)):
++        if any(arg.issuper for arg in args):
++            # to_super will promote 'oper' and leave 'super' untouched
++            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
++        return tensor(*args)
++    if all(map(_isketlike, args)):
++        if any(arg.isoperket for arg in args):
++            return super_tensor(*(
++                arg if arg.isoperket else operator_to_vector(arg.proj())
++                for arg in args
++            ))
++        return tensor(*args)
++    if all(map(_isbralike, args)):
++        # Turn into ket-likes and recurse.
++        return composite(*(arg.dag() for arg in args)).dag()
++    raise TypeError("Unsupported Qobj types [{}].".format(
++        ", ".join(arg.type for arg in args)
++    ))
++
++
++def _tensor_contract_single(arr, i, j):
++    """
++    Contracts a dense tensor along a single index pair.
++    """
++    if arr.shape[i] != arr.shape[j]:
++        raise ValueError("Cannot contract over indices of different length.")
++    idxs = np.arange(arr.shape[i])
++    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
++               for idx in range(arr.ndim))
++    contract_at = i if j == i + 1 else 0
++    return np.sum(arr[sl], axis=contract_at)
++
++
++def _tensor_contract_dense(arr, *pairs):
++    """
++    Contracts a dense tensor along one or more index pairs,
++    keeping track of how the indices are relabeled by the removal
++    of other indices.
++    """
++    axis_idxs = list(range(arr.ndim))
++    for pair in pairs:
++        # axis_idxs.index effectively evaluates the mapping from original index
++        # labels to the labels after contraction.
++        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
++        axis_idxs.remove(pair[0])
++        axis_idxs.remove(pair[1])
++    return arr
++
++
++def tensor_swap(q_oper, *pairs):
++    """Transposes one or more pairs of indices of a Qobj.
++    Note that this uses dense representations and thus
++    should *not* be used for very large Qobjs.
++
++    Parameters
++    ----------
++
++    pairs : tuple
++        One or more tuples ``(i, j)`` indicating that the
++        ``i`` and ``j`` dimensions of the original qobj
++        should be swapped.
++
++    Returns
++    -------
++
++    sqobj : Qobj
++        The original Qobj with all named index pairs swapped with each other
++    """
++    dims = q_oper.dims
++    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
++    data = q_oper.full()
++    # Reshape into tensor indices
++    data = data.reshape(dims_to_tensor_shape(dims))
++    # Now permute the dims list so we know how to get back.
++    flat_dims = flatten(dims)
++    perm = list(range(len(flat_dims)))
++    for i, j in pairs:
++        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
++    for i, j in tensor_pairs:
++        perm[i], perm[j] = perm[j], perm[i]
++    dims = unflatten(flat_dims, enumerate_flat(dims))
++    # Next, permute the actual indices of the dense tensor.
++    data = data.transpose(perm)
++    # Reshape back, using the left and right of dims.
++    data = data.reshape(list(map(np.prod, dims)))
++    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
++
++
++def tensor_contract(qobj, *pairs):
++    """Contracts a qobj along one or more index pairs.
++    Note that this uses dense representations and thus
++    should *not* be used for very large Qobjs.
++
++    Parameters
++    ----------
++
++    pairs : tuple
++        One or more tuples ``(i, j)`` indicating that the
++        ``i`` and ``j`` dimensions of the original qobj
++        should be contracted.
++
++    Returns
++    -------
++
++    cqobj : Qobj
++        The original Qobj with all named index pairs contracted
++        away.
++
++    """
++    # Record and label the original dims.
++    dims = qobj.dims
++    dims_idxs = enumerate_flat(dims)
++    tensor_dims = dims_to_tensor_shape(dims)
++
++    # Convert to dense first, since sparse won't support the reshaping we need.
++    qtens = qobj.data.to_array()
++
++    # Reshape by the flattened dims.
++    qtens = qtens.reshape(tensor_dims)
++
++    # Contract out the indices from the flattened object.
++    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
++    # to ensure that we are contracting the right indices.
++    qtens = _tensor_contract_dense(qtens,
++                                   *dims_idxs_to_tensor_idxs(dims, pairs))
++
++    # Remove the contracted indexes from dims so we know how to
++    # reshape back.
++    # This concerns dims, and not the tensor indices, so we need
++    # to make sure to use the original dims indices and not the ones
++    # generated by dims_to_* functions.
++    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
++    contracted_dims = unflatten(flatten(dims), contracted_idxs)
++
++    # We don't need to check for tensor idxs versus dims idxs here,
++    # as column- versus row-stacking will never move an index for the
++    # vectorized operator spaces all the way from the left to the right.
++    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
++
++    # Reshape back into a 2D matrix.
++    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
++
++    # Return back as a qobj.
++    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
++
++
++def _check_oper_dims(oper, dims=None, targets=None):
++    """
++    Check if the given operator is valid.
++
++    Parameters
++    ----------
++    oper : :class:`qutip.Qobj`
++        The quantum object to be checked.
++    dims : list, optional
++        A list of integer for the dimension of each composite system.
++        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
++    targets : int or list of int, optional
++        The indices of subspace that are acted on.
++    """
++    # if operator matches N
++    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
++        raise ValueError(
++            "The operator is not an "
++            "Qobj with the same input and output dimensions.")
++    # if operator dims matches the target dims
++    if dims is not None and targets is not None:
++        targ_dims = [dims[t] for t in targets]
++        if oper.dims[0] != targ_dims:
++            raise ValueError(
++                "The operator dims {} do not match "
++                "the target dims {}.".format(
++                    oper.dims[0], targ_dims))
++
++
++def _targets_to_list(targets, oper=None, N=None):
++    """
++    transform targets to a list and check validity.
++
++    Parameters
++    ----------
++    targets : int or list of int
++        The indices of subspace that are acted on.
++    oper : :class:`qutip.Qobj`, optional
++        An operator, the type of the :class:`qutip.Qobj`
++        has to be an operator
++        and the dimension matches the tensored qubit Hilbert space
++        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
++    N : int, optional
++        The number of subspace in the system.
++    """
++    # if targets is a list of integer
++    if targets is None:
++        targets = list(range(len(oper.dims[0])))
++    if not hasattr(targets, '__iter__'):
++        targets = [targets]
++    if not all([isinstance(t, int) for t in targets]):
++        raise TypeError(
++            "targets should be "
++            "an integer or a list of integer")
++    # if targets has correct length
++    if oper is not None:
++        req_num = len(oper.dims[0])
++        if len(targets) != req_num:
++            raise ValueError(
++                "The given operator needs {} "
++                "target qutbis, "
++                "but {} given.".format(
++                    req_num, len(targets)))
++    # if targets is smaller than N
++    if N is not None:
++        if not all([t < N for t in targets]):
++            raise ValueError("Targets must be smaller than N={}.".format(N))
++    return targets
++
++
++def expand_operator(oper, dims, targets):
++    """
++    Expand an operator to one that acts on a system with desired dimensions.
++    e.g.
++    ```
++    expand_operator(oper, [2, 3, 4, 5], 2) ==
++        tensor(qeye(2), qeye(3), oper, qeye(5))
++    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
++        tensor(oper2, qeye(3), oper1, qeye(5))
++    ```
++
++    Parameters
++    ----------
++    oper : :class:`qutip.Qobj`
++        An operator that act on the subsystem, has to be an operator and the
++        dimension matches the tensored dims Hilbert space
++        e.g. oper.dims = ``[[2, 3], [2, 3]]``
++    dims : list
++        A list of integer for the dimension of each composite system.
++        E.g ``[2, 3, 2, 3, 4]``.
++    targets : int or list of int
++        The indices of subspace that are acted on.
++
++    Returns
++    -------
++    expanded_oper : :class:`qutip.Qobj`
++        The expanded operator acting on a system with desired dimension.
++    """
++    from .operators import identity
++    N = len(dims)
++    targets = _targets_to_list(targets, oper=oper, N=N)
++    _check_oper_dims(oper, dims=dims, targets=targets)
++
++    # Generate the correct order for permutation,
++    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
++    # If the operator is cnot,
++    # this order means that the 3rd qubit controls the 0th qubit.
++    new_order = [0] * N
++    for i, t in enumerate(targets):
++        new_order[t] = i
++    # allocate the rest qutbits (not targets) to the empty
++    # position in new_order
++    rest_pos = [q for q in list(range(N)) if q not in targets]
++    rest_qubits = list(range(len(targets), N))
++    for i, ind in enumerate(rest_pos):
++        new_order[ind] = rest_qubits[i]
++    id_list = [identity(dims[i]) for i in rest_pos]
++    return tensor([oper] + id_list).permute(new_order)
+diff --git a/qutip/distributions.py b/qutip/distributions.py
+index b291d51c..e85b0b00 100644
+--- a/qutip/distributions.py
++++ b/qutip/distributions.py
+@@ -1,422 +1,422 @@
+-"""
+-This module provides classes and functions for working with spatial
+-distributions, such as Wigner distributions, etc.
+-
+-.. note::
+-
+-    Experimental.
+-
+-"""
+-
+-__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
+-           'TwoModeQuadratureCorrelation',
+-           'HarmonicOscillatorWaveFunction',
+-           'HarmonicOscillatorProbabilityFunction']
+-
+-import numpy as np
+-from numpy import pi, exp, sqrt
+-
+-from scipy.special import hermite, factorial
+-
+-from . import isket, ket2dm, state_number_index
+-from .wigner import wigner, qfunc
+-
+-try:
+-    import matplotlib as mpl
+-    import matplotlib.pyplot as plt
+-    from mpl_toolkits.mplot3d import Axes3D
+-except:
+-    pass
+-
+-
+-class Distribution:
+-    """A class for representation spatial distribution functions.
+-
+-    The Distribution class can be used to prepresent spatial distribution
+-    functions of arbitray dimension (although only 1D and 2D distributions
+-    are used so far).
+-
+-    It is indented as a base class for specific distribution function, and
+-    provide implementation of basic functions that are shared among all
+-    Distribution functions, such as visualization, calculating marginal
+-    distributions, etc.
+-
+-    Parameters
+-    ----------
+-    data : array_like
+-        Data for the distribution. The dimensions must match the lengths of
+-        the coordinate arrays in xvecs.
+-    xvecs : list
+-        List of arrays that spans the space for each coordinate.
+-    xlabels : list
+-        List of labels for each coordinate.
+-
+-    """
+-
+-    def __init__(self, data=None, xvecs=[], xlabels=[]):
+-        self.data = data
+-        self.xvecs = xvecs
+-        self.xlabels = xlabels
+-
+-    def visualize(self, fig=None, ax=None, figsize=(8, 6),
+-                  colorbar=True, cmap=None, style="colormap",
+-                  show_xlabel=True, show_ylabel=True):
+-        """
+-        Visualize the data of the distribution in 1D or 2D, depending
+-        on the dimensionality of the underlaying distribution.
+-
+-        Parameters:
+-
+-        fig : matplotlib Figure instance
+-            If given, use this figure instance for the visualization,
+-
+-        ax : matplotlib Axes instance
+-            If given, render the visualization using this axis instance.
+-
+-        figsize : tuple
+-            Size of the new Figure instance, if one needs to be created.
+-
+-        colorbar: Bool
+-            Whether or not the colorbar (in 2D visualization) should be used.
+-
+-        cmap: matplotlib colormap instance
+-            If given, use this colormap for 2D visualizations.
+-
+-        style : string
+-            Type of visualization: 'colormap' (default) or 'surface'.
+-
+-        Returns
+-        -------
+-
+-        fig, ax : tuple
+-            A tuple of matplotlib figure and axes instances.
+-
+-        """
+-        n = len(self.xvecs)
+-        if n == 2:
+-            if style == "colormap":
+-                return self.visualize_2d_colormap(fig=fig, ax=ax,
+-                                                  figsize=figsize,
+-                                                  colorbar=colorbar,
+-                                                  cmap=cmap,
+-                                                  show_xlabel=show_xlabel,
+-                                                  show_ylabel=show_ylabel)
+-            else:
+-                return self.visualize_2d_surface(fig=fig, ax=ax,
+-                                                 figsize=figsize,
+-                                                 colorbar=colorbar,
+-                                                 cmap=cmap,
+-                                                 show_xlabel=show_xlabel,
+-                                                 show_ylabel=show_ylabel)
+-
+-        elif n == 1:
+-            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
+-                                     show_xlabel=show_xlabel,
+-                                     show_ylabel=show_ylabel)
+-        else:
+-            raise NotImplementedError("Distribution visualization in " +
+-                                      "%d dimensions is not implemented." % n)
+-
+-    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
+-                              colorbar=True, cmap=None,
+-                              show_xlabel=True, show_ylabel=True):
+-
+-        if not fig and not ax:
+-            fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-        if cmap is None:
+-            cmap = mpl.cm.get_cmap('RdBu')
+-
+-        lim = abs(self.data).max()
+-
+-        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
+-                         norm=mpl.colors.Normalize(-lim, lim),
+-                         cmap=cmap)
+-
+-        if show_xlabel:
+-            ax.set_xlabel(self.xlabels[0], fontsize=12)
+-        if show_ylabel:
+-            ax.set_ylabel(self.xlabels[1], fontsize=12)
+-
+-        if colorbar:
+-            cb = fig.colorbar(cf, ax=ax)
+-
+-        return fig, ax
+-
+-    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
+-                             colorbar=True, cmap=None,
+-                             show_xlabel=True, show_ylabel=True):
+-
+-        if not fig and not ax:
+-            fig = plt.figure(figsize=figsize)
+-            ax = Axes3D(fig, azim=-62, elev=25)
+-
+-        if cmap is None:
+-            cmap = mpl.cm.get_cmap('RdBu')
+-
+-        lim = abs(self.data).max()
+-
+-        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
+-        s = ax.plot_surface(X, Y, self.data,
+-                            norm=mpl.colors.Normalize(-lim, lim),
+-                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
+-
+-        if show_xlabel:
+-            ax.set_xlabel(self.xlabels[0], fontsize=12)
+-        if show_ylabel:
+-            ax.set_ylabel(self.xlabels[1], fontsize=12)
+-
+-        if colorbar:
+-            cb = fig.colorbar(s, ax=ax, shrink=0.5)
+-
+-        return fig, ax
+-
+-    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
+-                     show_xlabel=True, show_ylabel=True):
+-
+-        if not fig and not ax:
+-            fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-        p = ax.plot(self.xvecs[0], self.data)
+-
+-        if show_xlabel:
+-            ax.set_xlabel(self.xlabels[0], fontsize=12)
+-        if show_ylabel:
+-            ax.set_ylabel("Marginal distribution", fontsize=12)
+-
+-        return fig, ax
+-
+-    def marginal(self, dim=0):
+-        """
+-        Calculate the marginal distribution function along the dimension
+-        `dim`. Return a new Distribution instance describing this reduced-
+-        dimensionality distribution.
+-
+-        Parameters
+-        ----------
+-        dim : int
+-            The dimension (coordinate index) along which to obtain the
+-            marginal distribution.
+-
+-        Returns
+-        -------
+-
+-        d : Distributions
+-            A new instances of Distribution that describes the marginal
+-            distribution.
+-
+-        """
+-        return Distribution(data=self.data.mean(axis=dim),
+-                            xvecs=[self.xvecs[dim]],
+-                            xlabels=[self.xlabels[dim]])
+-
+-    def project(self, dim=0):
+-        """
+-        Calculate the projection (max value) distribution function along the
+-        dimension `dim`. Return a new Distribution instance describing this
+-        reduced-dimensionality distribution.
+-
+-        Parameters
+-        ----------
+-        dim : int
+-            The dimension (coordinate index) along which to obtain the
+-            projected distribution.
+-
+-        Returns
+-        -------
+-        d : Distributions
+-            A new instances of Distribution that describes the projection.
+-
+-        """
+-        return Distribution(data=self.data.max(axis=dim),
+-                            xvecs=[self.xvecs[dim]],
+-                            xlabels=[self.xlabels[dim]])
+-
+-
+-class WignerDistribution(Distribution):
+-
+-    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
+-
+-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+-                      np.linspace(extent[1][0], extent[1][1], steps)]
+-
+-        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
+-
+-        if rho:
+-            self.update(rho)
+-
+-    def update(self, rho):
+-
+-        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
+-
+-
+-class QDistribution(Distribution):
+-
+-    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
+-
+-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+-                      np.linspace(extent[1][0], extent[1][1], steps)]
+-
+-        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
+-
+-        if rho:
+-            self.update(rho)
+-
+-    def update(self, rho):
+-
+-        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
+-
+-
+-class TwoModeQuadratureCorrelation(Distribution):
+-
+-    def __init__(self, state=None, theta1=0.0, theta2=0.0,
+-                 extent=[[-5, 5], [-5, 5]], steps=250):
+-
+-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+-                      np.linspace(extent[1][0], extent[1][1], steps)]
+-
+-        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
+-
+-        self.theta1 = theta1
+-        self.theta2 = theta2
+-
+-        self.update(state)
+-
+-    def update(self, state):
+-        """
+-        calculate probability distribution for quadrature measurement
+-        outcomes given a two-mode wavefunction or density matrix
+-        """
+-        if isket(state):
+-            self.update_psi(state)
+-        else:
+-            self.update_rho(state)
+-
+-    def update_psi(self, psi):
+-        """
+-        calculate probability distribution for quadrature measurement
+-        outcomes given a two-mode wavefunction
+-        """
+-
+-        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
+-
+-        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+-        N = psi.dims[0][0]
+-
+-        for n1 in range(N):
+-            kn1 = exp(-1j * self.theta1 * n1) / \
+-                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
+-                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
+-
+-            for n2 in range(N):
+-                kn2 = exp(-1j * self.theta2 * n2) / \
+-                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
+-                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
+-                i = state_number_index([N, N], [n1, n2])
+-                p += kn1 * kn2 * psi.data[i, 0]
+-
+-        self.data = abs(p) ** 2
+-
+-    def update_rho(self, rho):
+-        """
+-        calculate probability distribution for quadrature measurement
+-        outcomes given a two-mode density matrix
+-        """
+-
+-        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
+-
+-        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+-        N = rho.dims[0][0]
+-
+-        M1 = np.zeros(
+-            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+-        M2 = np.zeros(
+-            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+-
+-        for m in range(N):
+-            for n in range(N):
+-                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
+-                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
+-                    exp(-X1 ** 2) * np.polyval(
+-                        hermite(m), X1) * np.polyval(hermite(n), X1)
+-                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
+-                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
+-                    exp(-X2 ** 2) * np.polyval(
+-                        hermite(m), X2) * np.polyval(hermite(n), X2)
+-
+-        for n1 in range(N):
+-            for n2 in range(N):
+-                i = state_number_index([N, N], [n1, n2])
+-                for p1 in range(N):
+-                    for p2 in range(N):
+-                        j = state_number_index([N, N], [p1, p2])
+-                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
+-
+-        self.data = p
+-
+-
+-class HarmonicOscillatorWaveFunction(Distribution):
+-
+-    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
+-
+-        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
+-        self.xlabels = [r'$x$']
+-        self.omega = omega
+-
+-        if psi:
+-            self.update(psi)
+-
+-    def update(self, psi):
+-        """
+-        Calculate the wavefunction for the given state of an harmonic
+-        oscillator
+-        """
+-
+-        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
+-        N = psi.shape[0]
+-
+-        for n in range(N):
+-            k = pow(self.omega / pi, 0.25) / \
+-                sqrt(2 ** n * factorial(n)) * \
+-                exp(-self.xvecs[0] ** 2 / 2.0) * \
+-                np.polyval(hermite(n), self.xvecs[0])
+-
+-            self.data += k * psi.data[n, 0]
+-
+-
+-class HarmonicOscillatorProbabilityFunction(Distribution):
+-
+-    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
+-
+-        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
+-        self.xlabels = [r'$x$']
+-        self.omega = omega
+-
+-        if rho:
+-            self.update(rho)
+-
+-    def update(self, rho):
+-        """
+-        Calculate the probability function for the given state of an harmonic
+-        oscillator (as density matrix)
+-        """
+-
+-        if isket(rho):
+-            rho = ket2dm(rho)
+-
+-        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
+-        M, N = rho.shape
+-
+-        for m in range(M):
+-            k_m = pow(self.omega / pi, 0.25) / \
+-                sqrt(2 ** m * factorial(m)) * \
+-                exp(-self.xvecs[0] ** 2 / 2.0) * \
+-                np.polyval(hermite(m), self.xvecs[0])
+-
+-            for n in range(N):
+-                k_n = pow(self.omega / pi, 0.25) / \
+-                    sqrt(2 ** n * factorial(n)) * \
+-                    exp(-self.xvecs[0] ** 2 / 2.0) * \
+-                    np.polyval(hermite(n), self.xvecs[0])
+-
+-                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
++"""
++This module provides classes and functions for working with spatial
++distributions, such as Wigner distributions, etc.
++
++.. note::
++
++    Experimental.
++
++"""
++
++__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
++           'TwoModeQuadratureCorrelation',
++           'HarmonicOscillatorWaveFunction',
++           'HarmonicOscillatorProbabilityFunction']
++
++import numpy as np
++from numpy import pi, exp, sqrt
++
++from scipy.special import hermite, factorial
++
++from . import isket, ket2dm, state_number_index
++from .wigner import wigner, qfunc
++
++try:
++    import matplotlib as mpl
++    import matplotlib.pyplot as plt
++    from mpl_toolkits.mplot3d import Axes3D
++except:
++    pass
++
++
++class Distribution:
++    """A class for representation spatial distribution functions.
++
++    The Distribution class can be used to prepresent spatial distribution
++    functions of arbitray dimension (although only 1D and 2D distributions
++    are used so far).
++
++    It is indented as a base class for specific distribution function, and
++    provide implementation of basic functions that are shared among all
++    Distribution functions, such as visualization, calculating marginal
++    distributions, etc.
++
++    Parameters
++    ----------
++    data : array_like
++        Data for the distribution. The dimensions must match the lengths of
++        the coordinate arrays in xvecs.
++    xvecs : list
++        List of arrays that spans the space for each coordinate.
++    xlabels : list
++        List of labels for each coordinate.
++
++    """
++
++    def __init__(self, data=None, xvecs=[], xlabels=[]):
++        self.data = data
++        self.xvecs = xvecs
++        self.xlabels = xlabels
++
++    def visualize(self, fig=None, ax=None, figsize=(8, 6),
++                  colorbar=True, cmap=None, style="colormap",
++                  show_xlabel=True, show_ylabel=True):
++        """
++        Visualize the data of the distribution in 1D or 2D, depending
++        on the dimensionality of the underlaying distribution.
++
++        Parameters:
++
++        fig : matplotlib Figure instance
++            If given, use this figure instance for the visualization,
++
++        ax : matplotlib Axes instance
++            If given, render the visualization using this axis instance.
++
++        figsize : tuple
++            Size of the new Figure instance, if one needs to be created.
++
++        colorbar: Bool
++            Whether or not the colorbar (in 2D visualization) should be used.
++
++        cmap: matplotlib colormap instance
++            If given, use this colormap for 2D visualizations.
++
++        style : string
++            Type of visualization: 'colormap' (default) or 'surface'.
++
++        Returns
++        -------
++
++        fig, ax : tuple
++            A tuple of matplotlib figure and axes instances.
++
++        """
++        n = len(self.xvecs)
++        if n == 2:
++            if style == "colormap":
++                return self.visualize_2d_colormap(fig=fig, ax=ax,
++                                                  figsize=figsize,
++                                                  colorbar=colorbar,
++                                                  cmap=cmap,
++                                                  show_xlabel=show_xlabel,
++                                                  show_ylabel=show_ylabel)
++            else:
++                return self.visualize_2d_surface(fig=fig, ax=ax,
++                                                 figsize=figsize,
++                                                 colorbar=colorbar,
++                                                 cmap=cmap,
++                                                 show_xlabel=show_xlabel,
++                                                 show_ylabel=show_ylabel)
++
++        elif n == 1:
++            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
++                                     show_xlabel=show_xlabel,
++                                     show_ylabel=show_ylabel)
++        else:
++            raise NotImplementedError("Distribution visualization in " +
++                                      "%d dimensions is not implemented." % n)
++
++    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
++                              colorbar=True, cmap=None,
++                              show_xlabel=True, show_ylabel=True):
++
++        if not fig and not ax:
++            fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++        if cmap is None:
++            cmap = mpl.cm.get_cmap('RdBu')
++
++        lim = abs(self.data).max()
++
++        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
++                         norm=mpl.colors.Normalize(-lim, lim),
++                         cmap=cmap)
++
++        if show_xlabel:
++            ax.set_xlabel(self.xlabels[0], fontsize=12)
++        if show_ylabel:
++            ax.set_ylabel(self.xlabels[1], fontsize=12)
++
++        if colorbar:
++            cb = fig.colorbar(cf, ax=ax)
++
++        return fig, ax
++
++    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
++                             colorbar=True, cmap=None,
++                             show_xlabel=True, show_ylabel=True):
++
++        if not fig and not ax:
++            fig = plt.figure(figsize=figsize)
++            ax = Axes3D(fig, azim=-62, elev=25)
++
++        if cmap is None:
++            cmap = mpl.cm.get_cmap('RdBu')
++
++        lim = abs(self.data).max()
++
++        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
++        s = ax.plot_surface(X, Y, self.data,
++                            norm=mpl.colors.Normalize(-lim, lim),
++                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
++
++        if show_xlabel:
++            ax.set_xlabel(self.xlabels[0], fontsize=12)
++        if show_ylabel:
++            ax.set_ylabel(self.xlabels[1], fontsize=12)
++
++        if colorbar:
++            cb = fig.colorbar(s, ax=ax, shrink=0.5)
++
++        return fig, ax
++
++    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
++                     show_xlabel=True, show_ylabel=True):
++
++        if not fig and not ax:
++            fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++        p = ax.plot(self.xvecs[0], self.data)
++
++        if show_xlabel:
++            ax.set_xlabel(self.xlabels[0], fontsize=12)
++        if show_ylabel:
++            ax.set_ylabel("Marginal distribution", fontsize=12)
++
++        return fig, ax
++
++    def marginal(self, dim=0):
++        """
++        Calculate the marginal distribution function along the dimension
++        `dim`. Return a new Distribution instance describing this reduced-
++        dimensionality distribution.
++
++        Parameters
++        ----------
++        dim : int
++            The dimension (coordinate index) along which to obtain the
++            marginal distribution.
++
++        Returns
++        -------
++
++        d : Distributions
++            A new instances of Distribution that describes the marginal
++            distribution.
++
++        """
++        return Distribution(data=self.data.mean(axis=dim),
++                            xvecs=[self.xvecs[dim]],
++                            xlabels=[self.xlabels[dim]])
++
++    def project(self, dim=0):
++        """
++        Calculate the projection (max value) distribution function along the
++        dimension `dim`. Return a new Distribution instance describing this
++        reduced-dimensionality distribution.
++
++        Parameters
++        ----------
++        dim : int
++            The dimension (coordinate index) along which to obtain the
++            projected distribution.
++
++        Returns
++        -------
++        d : Distributions
++            A new instances of Distribution that describes the projection.
++
++        """
++        return Distribution(data=self.data.max(axis=dim),
++                            xvecs=[self.xvecs[dim]],
++                            xlabels=[self.xlabels[dim]])
++
++
++class WignerDistribution(Distribution):
++
++    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
++
++        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
++                      np.linspace(extent[1][0], extent[1][1], steps)]
++
++        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
++
++        if rho:
++            self.update(rho)
++
++    def update(self, rho):
++
++        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
++
++
++class QDistribution(Distribution):
++
++    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
++
++        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
++                      np.linspace(extent[1][0], extent[1][1], steps)]
++
++        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
++
++        if rho:
++            self.update(rho)
++
++    def update(self, rho):
++
++        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
++
++
++class TwoModeQuadratureCorrelation(Distribution):
++
++    def __init__(self, state=None, theta1=0.0, theta2=0.0,
++                 extent=[[-5, 5], [-5, 5]], steps=250):
++
++        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
++                      np.linspace(extent[1][0], extent[1][1], steps)]
++
++        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
++
++        self.theta1 = theta1
++        self.theta2 = theta2
++
++        self.update(state)
++
++    def update(self, state):
++        """
++        calculate probability distribution for quadrature measurement
++        outcomes given a two-mode wavefunction or density matrix
++        """
++        if isket(state):
++            self.update_psi(state)
++        else:
++            self.update_rho(state)
++
++    def update_psi(self, psi):
++        """
++        calculate probability distribution for quadrature measurement
++        outcomes given a two-mode wavefunction
++        """
++
++        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
++
++        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
++        N = psi.dims[0][0]
++
++        for n1 in range(N):
++            kn1 = exp(-1j * self.theta1 * n1) / \
++                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
++                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
++
++            for n2 in range(N):
++                kn2 = exp(-1j * self.theta2 * n2) / \
++                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
++                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
++                i = state_number_index([N, N], [n1, n2])
++                p += kn1 * kn2 * psi.data[i, 0]
++
++        self.data = abs(p) ** 2
++
++    def update_rho(self, rho):
++        """
++        calculate probability distribution for quadrature measurement
++        outcomes given a two-mode density matrix
++        """
++
++        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
++
++        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
++        N = rho.dims[0][0]
++
++        M1 = np.zeros(
++            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
++        M2 = np.zeros(
++            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
++
++        for m in range(N):
++            for n in range(N):
++                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
++                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
++                    exp(-X1 ** 2) * np.polyval(
++                        hermite(m), X1) * np.polyval(hermite(n), X1)
++                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
++                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
++                    exp(-X2 ** 2) * np.polyval(
++                        hermite(m), X2) * np.polyval(hermite(n), X2)
++
++        for n1 in range(N):
++            for n2 in range(N):
++                i = state_number_index([N, N], [n1, n2])
++                for p1 in range(N):
++                    for p2 in range(N):
++                        j = state_number_index([N, N], [p1, p2])
++                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
++
++        self.data = p
++
++
++class HarmonicOscillatorWaveFunction(Distribution):
++
++    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
++
++        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
++        self.xlabels = [r'$x$']
++        self.omega = omega
++
++        if psi:
++            self.update(psi)
++
++    def update(self, psi):
++        """
++        Calculate the wavefunction for the given state of an harmonic
++        oscillator
++        """
++
++        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
++        N = psi.shape[0]
++
++        for n in range(N):
++            k = pow(self.omega / pi, 0.25) / \
++                sqrt(2 ** n * factorial(n)) * \
++                exp(-self.xvecs[0] ** 2 / 2.0) * \
++                np.polyval(hermite(n), self.xvecs[0])
++
++            self.data += k * psi.data[n, 0]
++
++
++class HarmonicOscillatorProbabilityFunction(Distribution):
++
++    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
++
++        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
++        self.xlabels = [r'$x$']
++        self.omega = omega
++
++        if rho:
++            self.update(rho)
++
++    def update(self, rho):
++        """
++        Calculate the probability function for the given state of an harmonic
++        oscillator (as density matrix)
++        """
++
++        if isket(rho):
++            rho = ket2dm(rho)
++
++        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
++        M, N = rho.shape
++
++        for m in range(M):
++            k_m = pow(self.omega / pi, 0.25) / \
++                sqrt(2 ** m * factorial(m)) * \
++                exp(-self.xvecs[0] ** 2 / 2.0) * \
++                np.polyval(hermite(m), self.xvecs[0])
++
++            for n in range(N):
++                k_n = pow(self.omega / pi, 0.25) / \
++                    sqrt(2 ** n * factorial(n)) * \
++                    exp(-self.xvecs[0] ** 2 / 2.0) * \
++                    np.polyval(hermite(n), self.xvecs[0])
++
++                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
+diff --git a/qutip/entropy.py b/qutip/entropy.py
+index cd62a69b..28ff606a 100644
+--- a/qutip/entropy.py
++++ b/qutip/entropy.py
+@@ -1,376 +1,376 @@
+-__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
+-           'concurrence', 'entropy_conditional', 'entangling_power',
+-           'entropy_relative']
+-
+-from numpy import conj, e, inf, imag, inner, real, sort, sqrt
+-from numpy.lib.scimath import log, log2
+-from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
+-               expand_operator)
+-from .core import data as _data
+-
+-
+-def entropy_vn(rho, base=e, sparse=False):
+-    """
+-    Von-Neumann entropy of density matrix
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        Density matrix.
+-    base : {e,2}
+-        Base of logarithm.
+-    sparse : {False,True}
+-        Use sparse eigensolver.
+-
+-    Returns
+-    -------
+-    entropy : float
+-        Von-Neumann entropy of `rho`.
+-
+-    Examples
+-    --------
+-    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
+-    >>> entropy_vn(rho,2)
+-    1.0
+-
+-    """
+-    if rho.type == 'ket' or rho.type == 'bra':
+-        rho = ket2dm(rho)
+-    vals = rho.eigenenergies(sparse=sparse)
+-    nzvals = vals[vals != 0]
+-    if base == 2:
+-        logvals = log2(nzvals)
+-    elif base == e:
+-        logvals = log(nzvals)
+-    else:
+-        raise ValueError("Base must be 2 or e.")
+-    return float(real(-sum(nzvals * logvals)))
+-
+-
+-def entropy_linear(rho):
+-    """
+-    Linear entropy of a density matrix.
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        sensity matrix or ket/bra vector.
+-
+-    Returns
+-    -------
+-    entropy : float
+-        Linear entropy of rho.
+-
+-    Examples
+-    --------
+-    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
+-    >>> entropy_linear(rho)
+-    0.5
+-
+-    """
+-    if rho.type == 'ket' or rho.type == 'bra':
+-        rho = ket2dm(rho)
+-    return float(real(1.0 - (rho ** 2).tr()))
+-
+-
+-def concurrence(rho):
+-    """
+-    Calculate the concurrence entanglement measure for a two-qubit state.
+-
+-    Parameters
+-    ----------
+-    state : qobj
+-        Ket, bra, or density matrix for a two-qubit state.
+-
+-    Returns
+-    -------
+-    concur : float
+-        Concurrence
+-
+-    References
+-    ----------
+-
+-    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
+-
+-    """
+-    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
+-        raise Exception("Ket must be tensor product of two qubits.")
+-
+-    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
+-        raise Exception("Bra must be tensor product of two qubits.")
+-
+-    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
+-        raise Exception("Density matrix must be tensor product of two qubits.")
+-
+-    if rho.isket or rho.isbra:
+-        rho = ket2dm(rho)
+-
+-    sysy = tensor(sigmay(), sigmay())
+-
+-    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
+-
+-    evals = rho_tilde.eigenenergies()
+-
+-    # abs to avoid problems with sqrt for very small negative numbers
+-    evals = abs(sort(real(evals)))
+-
+-    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
+-
+-    return max(0, lsum)
+-
+-
+-def negativity(rho, subsys, method='tracenorm', logarithmic=False):
+-    """
+-    Compute the negativity for a multipartite quantum system described
+-    by the density matrix rho. The subsys argument is an index that
+-    indicates which system to compute the negativity for.
+-
+-    .. note::
+-
+-        Experimental.
+-    """
+-    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
+-    rho_pt = partial_transpose(rho, mask)
+-
+-    if method == 'tracenorm':
+-        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
+-    elif method == 'eigenvalues':
+-        l = rho_pt.eigenenergies()
+-        N = ((abs(l)-l)/2).sum()
+-    else:
+-        raise ValueError("Unknown method %s" % method)
+-
+-    if logarithmic:
+-        return log2(2 * N + 1)
+-    else:
+-        return N
+-
+-
+-def entropy_mutual(rho, selA, selB, base=e, sparse=False):
+-    """
+-    Calculates the mutual information S(A:B) between selection
+-    components of a system density matrix.
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        Density matrix for composite quantum systems
+-    selA : int/list
+-        `int` or `list` of first selected density matrix components.
+-    selB : int/list
+-        `int` or `list` of second selected density matrix components.
+-    base : {e,2}
+-        Base of logarithm.
+-    sparse : {False,True}
+-        Use sparse eigensolver.
+-
+-    Returns
+-    -------
+-    ent_mut : float
+-       Mutual information between selected components.
+-
+-    """
+-    if isinstance(selA, int):
+-        selA = [selA]
+-    if isinstance(selB, int):
+-        selB = [selB]
+-    if rho.type != 'oper':
+-        raise TypeError("Input must be a density matrix.")
+-    if (len(selA) + len(selB)) != len(rho.dims[0]):
+-        raise TypeError("Number of selected components must match " +
+-                        "total number.")
+-
+-    rhoA = ptrace(rho, selA)
+-    rhoB = ptrace(rho, selB)
+-    out = (entropy_vn(rhoA, base, sparse=sparse) +
+-           entropy_vn(rhoB, base, sparse=sparse) -
+-           entropy_vn(rho, base, sparse=sparse))
+-    return out
+-
+-
+-def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
+-    """
+-    Calculates the relative entropy S(rho||sigma) between two density
+-    matrices.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        First density matrix (or ket which will be converted to a density
+-        matrix).
+-    sigma : :class:`qutip.Qobj`
+-        Second density matrix (or ket which will be converted to a density
+-        matrix).
+-    base : {e,2}
+-        Base of logarithm. Defaults to e.
+-    sparse : bool
+-        Flag to use sparse solver when determining the eigenvectors
+-        of the density matrices. Defaults to False.
+-    tol : float
+-        Tolerance to use to detect 0 eigenvalues or dot producted between
+-        eigenvectors. Defaults to 1e-12.
+-
+-    Returns
+-    -------
+-    rel_ent : float
+-        Value of relative entropy. Guaranteed to be greater than zero
+-        and should equal zero only when rho and sigma are identical.
+-
+-    Examples
+-    --------
+-
+-    First we define two density matrices:
+-
+-    >>> rho = qutip.ket2dm(qutip.ket("00"))
+-    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
+-    >>> sigma = sigma.unit()
+-
+-    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
+-    and base e (i.e. ``log``).
+-
+-    >>> qutip.entropy_relative(rho, sigma, base=2)
+-    1.0
+-    >>> qutip.entropy_relative(rho, sigma)
+-    0.6931471805599453
+-
+-    References
+-    ----------
+-
+-    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
+-    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
+-    entropy.
+-    """
+-    if rho.isket:
+-        rho = ket2dm(rho)
+-    if sigma.isket:
+-        sigma = ket2dm(sigma)
+-    if not rho.isoper or not sigma.isoper:
+-        raise TypeError("Inputs must be density matrices.")
+-    if rho.dims != sigma.dims:
+-        raise ValueError("Inputs must have the same shape and dims.")
+-    if base == 2:
+-        log_base = log2
+-    elif base == e:
+-        log_base = log
+-    else:
+-        raise ValueError("Base must be 2 or e.")
+-    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
+-    #
+-    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
+-    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
+-    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
+-    rvecs = rvecs.to_array().T
+-    if any(abs(imag(rvals)) >= tol):
+-        raise ValueError("Input rho has non-real eigenvalues.")
+-    rvals = real(rvals)
+-    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
+-    svecs = svecs.to_array().T
+-    if any(abs(imag(svals)) >= tol):
+-        raise ValueError("Input sigma has non-real eigenvalues.")
+-    svals = real(svals)
+-    # Calculate inner products of eigenvectors and return +inf if kernel
+-    # of sigma overlaps with support of rho.
+-    P = abs(inner(rvecs, conj(svecs))) ** 2
+-    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
+-        return inf
+-    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
+-    # anyway
+-    svals[abs(svals) < tol] = 1
+-    nzrvals = rvals[abs(rvals) >= tol]
+-    # Calculate S
+-    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
+-    # the relative entropy is guaranteed to be >= 0, so we clamp the
+-    # calculated value to 0 to avoid small violations of the lower bound.
+-    return max(0, S)
+-
+-
+-def entropy_conditional(rho, selB, base=e, sparse=False):
+-    """
+-    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
+-    of a selected density matrix component.
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        Density matrix of composite object
+-    selB : int/list
+-        Selected components for density matrix B
+-    base : {e,2}
+-        Base of logarithm.
+-    sparse : {False,True}
+-        Use sparse eigensolver.
+-
+-    Returns
+-    -------
+-    ent_cond : float
+-        Value of conditional entropy
+-
+-    """
+-    if rho.type != 'oper':
+-        raise TypeError("Input must be density matrix.")
+-    if isinstance(selB, int):
+-        selB = [selB]
+-    B = ptrace(rho, selB)
+-    out = (entropy_vn(rho, base, sparse=sparse) -
+-           entropy_vn(B, base, sparse=sparse))
+-    return out
+-
+-
+-def participation_ratio(rho):
+-    """
+-    Returns the effective number of states for a density matrix.
+-
+-    The participation is unity for pure states, and maximally N,
+-    where N is the Hilbert space dimensionality, for completely
+-    mixed states.
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        Density matrix
+-
+-    Returns
+-    -------
+-    pr : float
+-        Effective number of states in the density matrix
+-
+-    """
+-    if rho.type == 'ket' or rho.type == 'bra':
+-        return 1.0
+-    else:
+-        return 1.0 / (rho ** 2).tr()
+-
+-
+-def entangling_power(U):
+-    """
+-    Calculate the entangling power of a two-qubit gate U, which
+-    is zero of nonentangling gates and 2/9 for maximally entangling gates.
+-
+-    Parameters
+-    ----------
+-    U : qobj
+-        Qobj instance representing a two-qubit gate.
+-
+-    Returns
+-    -------
+-    ep : float
+-        The entanglement power of U (real number between 0 and 2/9)
+-
+-    References:
+-
+-        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
+-    """
+-
+-    if not U.isoper:
+-        raise Exception("U must be an operator.")
+-
+-    if U.dims != [[2, 2], [2, 2]]:
+-        raise Exception("U must be a two-qubit gate.")
+-
+-    from qutip.core.gates import swap
+-    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
+-    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
+-    Uswap = swap() * U
+-    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
+-
+-    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
++__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
++           'concurrence', 'entropy_conditional', 'entangling_power',
++           'entropy_relative']
++
++from numpy import conj, e, inf, imag, inner, real, sort, sqrt
++from numpy.lib.scimath import log, log2
++from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
++               expand_operator)
++from .core import data as _data
++
++
++def entropy_vn(rho, base=e, sparse=False):
++    """
++    Von-Neumann entropy of density matrix
++
++    Parameters
++    ----------
++    rho : qobj
++        Density matrix.
++    base : {e,2}
++        Base of logarithm.
++    sparse : {False,True}
++        Use sparse eigensolver.
++
++    Returns
++    -------
++    entropy : float
++        Von-Neumann entropy of `rho`.
++
++    Examples
++    --------
++    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
++    >>> entropy_vn(rho,2)
++    1.0
++
++    """
++    if rho.type == 'ket' or rho.type == 'bra':
++        rho = ket2dm(rho)
++    vals = rho.eigenenergies(sparse=sparse)
++    nzvals = vals[vals != 0]
++    if base == 2:
++        logvals = log2(nzvals)
++    elif base == e:
++        logvals = log(nzvals)
++    else:
++        raise ValueError("Base must be 2 or e.")
++    return float(real(-sum(nzvals * logvals)))
++
++
++def entropy_linear(rho):
++    """
++    Linear entropy of a density matrix.
++
++    Parameters
++    ----------
++    rho : qobj
++        sensity matrix or ket/bra vector.
++
++    Returns
++    -------
++    entropy : float
++        Linear entropy of rho.
++
++    Examples
++    --------
++    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
++    >>> entropy_linear(rho)
++    0.5
++
++    """
++    if rho.type == 'ket' or rho.type == 'bra':
++        rho = ket2dm(rho)
++    return float(real(1.0 - (rho ** 2).tr()))
++
++
++def concurrence(rho):
++    """
++    Calculate the concurrence entanglement measure for a two-qubit state.
++
++    Parameters
++    ----------
++    state : qobj
++        Ket, bra, or density matrix for a two-qubit state.
++
++    Returns
++    -------
++    concur : float
++        Concurrence
++
++    References
++    ----------
++
++    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
++
++    """
++    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
++        raise Exception("Ket must be tensor product of two qubits.")
++
++    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
++        raise Exception("Bra must be tensor product of two qubits.")
++
++    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
++        raise Exception("Density matrix must be tensor product of two qubits.")
++
++    if rho.isket or rho.isbra:
++        rho = ket2dm(rho)
++
++    sysy = tensor(sigmay(), sigmay())
++
++    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
++
++    evals = rho_tilde.eigenenergies()
++
++    # abs to avoid problems with sqrt for very small negative numbers
++    evals = abs(sort(real(evals)))
++
++    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
++
++    return max(0, lsum)
++
++
++def negativity(rho, subsys, method='tracenorm', logarithmic=False):
++    """
++    Compute the negativity for a multipartite quantum system described
++    by the density matrix rho. The subsys argument is an index that
++    indicates which system to compute the negativity for.
++
++    .. note::
++
++        Experimental.
++    """
++    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
++    rho_pt = partial_transpose(rho, mask)
++
++    if method == 'tracenorm':
++        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
++    elif method == 'eigenvalues':
++        l = rho_pt.eigenenergies()
++        N = ((abs(l)-l)/2).sum()
++    else:
++        raise ValueError("Unknown method %s" % method)
++
++    if logarithmic:
++        return log2(2 * N + 1)
++    else:
++        return N
++
++
++def entropy_mutual(rho, selA, selB, base=e, sparse=False):
++    """
++    Calculates the mutual information S(A:B) between selection
++    components of a system density matrix.
++
++    Parameters
++    ----------
++    rho : qobj
++        Density matrix for composite quantum systems
++    selA : int/list
++        `int` or `list` of first selected density matrix components.
++    selB : int/list
++        `int` or `list` of second selected density matrix components.
++    base : {e,2}
++        Base of logarithm.
++    sparse : {False,True}
++        Use sparse eigensolver.
++
++    Returns
++    -------
++    ent_mut : float
++       Mutual information between selected components.
++
++    """
++    if isinstance(selA, int):
++        selA = [selA]
++    if isinstance(selB, int):
++        selB = [selB]
++    if rho.type != 'oper':
++        raise TypeError("Input must be a density matrix.")
++    if (len(selA) + len(selB)) != len(rho.dims[0]):
++        raise TypeError("Number of selected components must match " +
++                        "total number.")
++
++    rhoA = ptrace(rho, selA)
++    rhoB = ptrace(rho, selB)
++    out = (entropy_vn(rhoA, base, sparse=sparse) +
++           entropy_vn(rhoB, base, sparse=sparse) -
++           entropy_vn(rho, base, sparse=sparse))
++    return out
++
++
++def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
++    """
++    Calculates the relative entropy S(rho||sigma) between two density
++    matrices.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        First density matrix (or ket which will be converted to a density
++        matrix).
++    sigma : :class:`qutip.Qobj`
++        Second density matrix (or ket which will be converted to a density
++        matrix).
++    base : {e,2}
++        Base of logarithm. Defaults to e.
++    sparse : bool
++        Flag to use sparse solver when determining the eigenvectors
++        of the density matrices. Defaults to False.
++    tol : float
++        Tolerance to use to detect 0 eigenvalues or dot producted between
++        eigenvectors. Defaults to 1e-12.
++
++    Returns
++    -------
++    rel_ent : float
++        Value of relative entropy. Guaranteed to be greater than zero
++        and should equal zero only when rho and sigma are identical.
++
++    Examples
++    --------
++
++    First we define two density matrices:
++
++    >>> rho = qutip.ket2dm(qutip.ket("00"))
++    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
++    >>> sigma = sigma.unit()
++
++    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
++    and base e (i.e. ``log``).
++
++    >>> qutip.entropy_relative(rho, sigma, base=2)
++    1.0
++    >>> qutip.entropy_relative(rho, sigma)
++    0.6931471805599453
++
++    References
++    ----------
++
++    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
++    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
++    entropy.
++    """
++    if rho.isket:
++        rho = ket2dm(rho)
++    if sigma.isket:
++        sigma = ket2dm(sigma)
++    if not rho.isoper or not sigma.isoper:
++        raise TypeError("Inputs must be density matrices.")
++    if rho.dims != sigma.dims:
++        raise ValueError("Inputs must have the same shape and dims.")
++    if base == 2:
++        log_base = log2
++    elif base == e:
++        log_base = log
++    else:
++        raise ValueError("Base must be 2 or e.")
++    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
++    #
++    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
++    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
++    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
++    rvecs = rvecs.to_array().T
++    if any(abs(imag(rvals)) >= tol):
++        raise ValueError("Input rho has non-real eigenvalues.")
++    rvals = real(rvals)
++    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
++    svecs = svecs.to_array().T
++    if any(abs(imag(svals)) >= tol):
++        raise ValueError("Input sigma has non-real eigenvalues.")
++    svals = real(svals)
++    # Calculate inner products of eigenvectors and return +inf if kernel
++    # of sigma overlaps with support of rho.
++    P = abs(inner(rvecs, conj(svecs))) ** 2
++    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
++        return inf
++    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
++    # anyway
++    svals[abs(svals) < tol] = 1
++    nzrvals = rvals[abs(rvals) >= tol]
++    # Calculate S
++    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
++    # the relative entropy is guaranteed to be >= 0, so we clamp the
++    # calculated value to 0 to avoid small violations of the lower bound.
++    return max(0, S)
++
++
++def entropy_conditional(rho, selB, base=e, sparse=False):
++    """
++    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
++    of a selected density matrix component.
++
++    Parameters
++    ----------
++    rho : qobj
++        Density matrix of composite object
++    selB : int/list
++        Selected components for density matrix B
++    base : {e,2}
++        Base of logarithm.
++    sparse : {False,True}
++        Use sparse eigensolver.
++
++    Returns
++    -------
++    ent_cond : float
++        Value of conditional entropy
++
++    """
++    if rho.type != 'oper':
++        raise TypeError("Input must be density matrix.")
++    if isinstance(selB, int):
++        selB = [selB]
++    B = ptrace(rho, selB)
++    out = (entropy_vn(rho, base, sparse=sparse) -
++           entropy_vn(B, base, sparse=sparse))
++    return out
++
++
++def participation_ratio(rho):
++    """
++    Returns the effective number of states for a density matrix.
++
++    The participation is unity for pure states, and maximally N,
++    where N is the Hilbert space dimensionality, for completely
++    mixed states.
++
++    Parameters
++    ----------
++    rho : qobj
++        Density matrix
++
++    Returns
++    -------
++    pr : float
++        Effective number of states in the density matrix
++
++    """
++    if rho.type == 'ket' or rho.type == 'bra':
++        return 1.0
++    else:
++        return 1.0 / (rho ** 2).tr()
++
++
++def entangling_power(U):
++    """
++    Calculate the entangling power of a two-qubit gate U, which
++    is zero of nonentangling gates and 2/9 for maximally entangling gates.
++
++    Parameters
++    ----------
++    U : qobj
++        Qobj instance representing a two-qubit gate.
++
++    Returns
++    -------
++    ep : float
++        The entanglement power of U (real number between 0 and 2/9)
++
++    References:
++
++        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
++    """
++
++    if not U.isoper:
++        raise Exception("U must be an operator.")
++
++    if U.dims != [[2, 2], [2, 2]]:
++        raise Exception("U must be a two-qubit gate.")
++
++    from qutip.core.gates import swap
++    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
++    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
++    Uswap = swap() * U
++    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
++
++    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
+diff --git a/qutip/fileio.py b/qutip/fileio.py
+index ac94dd41..36bb1a5c 100644
+--- a/qutip/fileio.py
++++ b/qutip/fileio.py
+@@ -1,257 +1,257 @@
+-__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
+-
+-import pickle
+-import numpy as np
+-import sys
+-from .core import Qobj
+-from pathlib import Path
+-
+-
+-# -----------------------------------------------------------------------------
+-# Write matrix data to a file
+-#
+-def file_data_store(filename, data, numtype="complex", numformat="decimal",
+-                    sep=","):
+-    """Stores a matrix of data to a file to be read by an external program.
+-
+-    Parameters
+-    ----------
+-    filename : str or pathlib.Path
+-        Name of data file to be stored, including extension.
+-    data: array_like
+-        Data to be written to file.
+-    numtype : str {'complex, 'real'}
+-        Type of numerical data.
+-    numformat : str {'decimal','exp'}
+-        Format for written data.
+-    sep : str
+-        Single-character field seperator.  Usually a tab, space, comma,
+-        or semicolon.
+-
+-    """
+-    if filename is None or data is None:
+-        raise ValueError("filename or data is unspecified")
+-
+-    M, N = np.shape(data)
+-
+-    f = open(filename, "w")
+-
+-    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
+-            "in %s format ['%s' separated values].\n" % (numformat, sep))
+-
+-    if numtype == "complex":
+-
+-        if numformat == "exp":
+-
+-            for m in range(M):
+-                for n in range(N):
+-                    if np.imag(data[m, n]) >= 0.0:
+-                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
+-                                                  np.imag(data[m, n])))
+-                    else:
+-                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
+-                                                 np.imag(data[m, n])))
+-                    if n != N - 1:
+-                        f.write(sep)
+-                f.write("\n")
+-
+-        elif numformat == "decimal":
+-
+-            for m in range(M):
+-                for n in range(N):
+-                    if np.imag(data[m, n]) >= 0.0:
+-                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
+-                                                  np.imag(data[m, n])))
+-                    else:
+-                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
+-                                                 np.imag(data[m, n])))
+-                    if n != N - 1:
+-                        f.write(sep)
+-                f.write("\n")
+-
+-        else:
+-            raise ValueError("Illegal numformat value (should be " +
+-                             "'exp' or 'decimal')")
+-
+-    elif numtype == "real":
+-
+-        if numformat == "exp":
+-
+-            for m in range(M):
+-                for n in range(N):
+-                    f.write("%.10e" % (np.real(data[m, n])))
+-                    if n != N - 1:
+-                        f.write(sep)
+-                f.write("\n")
+-
+-        elif numformat == "decimal":
+-
+-            for m in range(M):
+-                for n in range(N):
+-                    f.write("%.10f" % (np.real(data[m, n])))
+-                    if n != N - 1:
+-                        f.write(sep)
+-                f.write("\n")
+-
+-        else:
+-            raise ValueError("Illegal numformat value (should be " +
+-                             "'exp' or 'decimal')")
+-
+-    else:
+-        raise ValueError("Illegal numtype value (should be " +
+-                         "'complex' or 'real')")
+-
+-    f.close()
+-
+-
+-# -----------------------------------------------------------------------------
+-# Read matrix data from a file
+-#
+-def file_data_read(filename, sep=None):
+-    """Retrieves an array of data from the requested file.
+-
+-    Parameters
+-    ----------
+-    filename : str or pathlib.Path
+-        Name of file containing reqested data.
+-    sep : str
+-        Seperator used to store data.
+-
+-    Returns
+-    -------
+-    data : array_like
+-        Data from selected file.
+-
+-    """
+-    if filename is None:
+-        raise ValueError("filename is unspecified")
+-
+-    f = open(filename, "r")
+-
+-    #
+-    # first count lines and numbers of
+-    #
+-    M = N = 0
+-    for line in f:
+-        # skip comment lines
+-        if line[0] == '#' or line[0] == '%':
+-            continue
+-        # find delim
+-        if N == 0 and sep is None:
+-            if len(line.rstrip().split(",")) > 1:
+-                sep = ","
+-            elif len(line.rstrip().split(";")) > 1:
+-                sep = ";"
+-            elif len(line.rstrip().split(":")) > 1:
+-                sep = ":"
+-            elif len(line.rstrip().split("|")) > 1:
+-                sep = "|"
+-            elif len(line.rstrip().split()) > 1:
+-                # sepical case for a mix of white space deliminators
+-                sep = None
+-            else:
+-                raise ValueError("Unrecognized column deliminator")
+-        # split the line
+-        line_vec = line.split(sep)
+-        n = len(line_vec)
+-        if N == 0 and n > 0:
+-            N = n
+-            # check type
+-            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
+-                numtype = "complex"
+-            else:
+-                numtype = "np.real"
+-
+-            # check format
+-            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
+-                numformat = "exp"
+-            else:
+-                numformat = "decimal"
+-
+-        elif N != n:
+-            raise ValueError("Badly formatted data file: " +
+-                             "unequal number of columns")
+-        M += 1
+-
+-    #
+-    # read data and store in a matrix
+-    #
+-    f.seek(0)
+-
+-    if numtype == "complex":
+-        data = np.zeros((M, N), dtype="complex")
+-        m = n = 0
+-        for line in f:
+-            # skip comment lines
+-            if line[0] == '#' or line[0] == '%':
+-                continue
+-            n = 0
+-            for item in line.rstrip().split(sep):
+-                data[m, n] = complex(item)
+-                n += 1
+-            m += 1
+-
+-    else:
+-        data = np.zeros((M, N), dtype="float")
+-        m = n = 0
+-        for line in f:
+-            # skip comment lines
+-            if line[0] == '#' or line[0] == '%':
+-                continue
+-            n = 0
+-            for item in line.rstrip().split(sep):
+-                data[m, n] = float(item)
+-                n += 1
+-            m += 1
+-
+-    f.close()
+-
+-    return data
+-
+-
+-def qsave(data, name='qutip_data'):
+-    """
+-    Saves given data to file named 'filename.qu' in current directory.
+-
+-    Parameters
+-    ----------
+-    data : instance/array_like
+-        Input Python object to be stored.
+-    filename : str or pathlib.Path
+-        Name of output data file.
+-
+-    """
+-    # open the file for writing
+-    path = Path(name)
+-    path = path.with_suffix(path.suffix + ".qu")
+-
+-    with open(path, "wb") as fileObject:
+-        # this writes the object a to the file named 'filename.qu'
+-        pickle.dump(data, fileObject)
+-
+-
+-def qload(name):
+-    """
+-    Loads data file from file named 'filename.qu' in current directory.
+-
+-    Parameters
+-    ----------
+-    name : str or pathlib.Path
+-        Name of data file to be loaded.
+-
+-    Returns
+-    -------
+-    qobject : instance / array_like
+-        Object retrieved from requested file.
+-
+-    """
+-    path = Path(name)
+-    path = path.with_suffix(path.suffix + ".qu")
+-
+-    with open(path, "rb") as fileObject:
+-        if sys.version_info >= (3, 0):
+-            out = pickle.load(fileObject, encoding='latin1')
+-        else:
+-            out = pickle.load(fileObject)
+-
+-    return out
++__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
++
++import pickle
++import numpy as np
++import sys
++from .core import Qobj
++from pathlib import Path
++
++
++# -----------------------------------------------------------------------------
++# Write matrix data to a file
++#
++def file_data_store(filename, data, numtype="complex", numformat="decimal",
++                    sep=","):
++    """Stores a matrix of data to a file to be read by an external program.
++
++    Parameters
++    ----------
++    filename : str or pathlib.Path
++        Name of data file to be stored, including extension.
++    data: array_like
++        Data to be written to file.
++    numtype : str {'complex, 'real'}
++        Type of numerical data.
++    numformat : str {'decimal','exp'}
++        Format for written data.
++    sep : str
++        Single-character field seperator.  Usually a tab, space, comma,
++        or semicolon.
++
++    """
++    if filename is None or data is None:
++        raise ValueError("filename or data is unspecified")
++
++    M, N = np.shape(data)
++
++    f = open(filename, "w")
++
++    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
++            "in %s format ['%s' separated values].\n" % (numformat, sep))
++
++    if numtype == "complex":
++
++        if numformat == "exp":
++
++            for m in range(M):
++                for n in range(N):
++                    if np.imag(data[m, n]) >= 0.0:
++                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
++                                                  np.imag(data[m, n])))
++                    else:
++                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
++                                                 np.imag(data[m, n])))
++                    if n != N - 1:
++                        f.write(sep)
++                f.write("\n")
++
++        elif numformat == "decimal":
++
++            for m in range(M):
++                for n in range(N):
++                    if np.imag(data[m, n]) >= 0.0:
++                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
++                                                  np.imag(data[m, n])))
++                    else:
++                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
++                                                 np.imag(data[m, n])))
++                    if n != N - 1:
++                        f.write(sep)
++                f.write("\n")
++
++        else:
++            raise ValueError("Illegal numformat value (should be " +
++                             "'exp' or 'decimal')")
++
++    elif numtype == "real":
++
++        if numformat == "exp":
++
++            for m in range(M):
++                for n in range(N):
++                    f.write("%.10e" % (np.real(data[m, n])))
++                    if n != N - 1:
++                        f.write(sep)
++                f.write("\n")
++
++        elif numformat == "decimal":
++
++            for m in range(M):
++                for n in range(N):
++                    f.write("%.10f" % (np.real(data[m, n])))
++                    if n != N - 1:
++                        f.write(sep)
++                f.write("\n")
++
++        else:
++            raise ValueError("Illegal numformat value (should be " +
++                             "'exp' or 'decimal')")
++
++    else:
++        raise ValueError("Illegal numtype value (should be " +
++                         "'complex' or 'real')")
++
++    f.close()
++
++
++# -----------------------------------------------------------------------------
++# Read matrix data from a file
++#
++def file_data_read(filename, sep=None):
++    """Retrieves an array of data from the requested file.
++
++    Parameters
++    ----------
++    filename : str or pathlib.Path
++        Name of file containing reqested data.
++    sep : str
++        Seperator used to store data.
++
++    Returns
++    -------
++    data : array_like
++        Data from selected file.
++
++    """
++    if filename is None:
++        raise ValueError("filename is unspecified")
++
++    f = open(filename, "r")
++
++    #
++    # first count lines and numbers of
++    #
++    M = N = 0
++    for line in f:
++        # skip comment lines
++        if line[0] == '#' or line[0] == '%':
++            continue
++        # find delim
++        if N == 0 and sep is None:
++            if len(line.rstrip().split(",")) > 1:
++                sep = ","
++            elif len(line.rstrip().split(";")) > 1:
++                sep = ";"
++            elif len(line.rstrip().split(":")) > 1:
++                sep = ":"
++            elif len(line.rstrip().split("|")) > 1:
++                sep = "|"
++            elif len(line.rstrip().split()) > 1:
++                # sepical case for a mix of white space deliminators
++                sep = None
++            else:
++                raise ValueError("Unrecognized column deliminator")
++        # split the line
++        line_vec = line.split(sep)
++        n = len(line_vec)
++        if N == 0 and n > 0:
++            N = n
++            # check type
++            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
++                numtype = "complex"
++            else:
++                numtype = "np.real"
++
++            # check format
++            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
++                numformat = "exp"
++            else:
++                numformat = "decimal"
++
++        elif N != n:
++            raise ValueError("Badly formatted data file: " +
++                             "unequal number of columns")
++        M += 1
++
++    #
++    # read data and store in a matrix
++    #
++    f.seek(0)
++
++    if numtype == "complex":
++        data = np.zeros((M, N), dtype="complex")
++        m = n = 0
++        for line in f:
++            # skip comment lines
++            if line[0] == '#' or line[0] == '%':
++                continue
++            n = 0
++            for item in line.rstrip().split(sep):
++                data[m, n] = complex(item)
++                n += 1
++            m += 1
++
++    else:
++        data = np.zeros((M, N), dtype="float")
++        m = n = 0
++        for line in f:
++            # skip comment lines
++            if line[0] == '#' or line[0] == '%':
++                continue
++            n = 0
++            for item in line.rstrip().split(sep):
++                data[m, n] = float(item)
++                n += 1
++            m += 1
++
++    f.close()
++
++    return data
++
++
++def qsave(data, name='qutip_data'):
++    """
++    Saves given data to file named 'filename.qu' in current directory.
++
++    Parameters
++    ----------
++    data : instance/array_like
++        Input Python object to be stored.
++    filename : str or pathlib.Path
++        Name of output data file.
++
++    """
++    # open the file for writing
++    path = Path(name)
++    path = path.with_suffix(path.suffix + ".qu")
++
++    with open(path, "wb") as fileObject:
++        # this writes the object a to the file named 'filename.qu'
++        pickle.dump(data, fileObject)
++
++
++def qload(name):
++    """
++    Loads data file from file named 'filename.qu' in current directory.
++
++    Parameters
++    ----------
++    name : str or pathlib.Path
++        Name of data file to be loaded.
++
++    Returns
++    -------
++    qobject : instance / array_like
++        Object retrieved from requested file.
++
++    """
++    path = Path(name)
++    path = path.with_suffix(path.suffix + ".qu")
++
++    with open(path, "rb") as fileObject:
++        if sys.version_info >= (3, 0):
++            out = pickle.load(fileObject, encoding='latin1')
++        else:
++            out = pickle.load(fileObject)
++
++    return out
+diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
+index 143a3b1c..0cf9d3b4 100644
+--- a/qutip/ipynbtools.py
++++ b/qutip/ipynbtools.py
+@@ -1,326 +1,326 @@
+-"""
+-This module contains utility functions for using QuTiP with IPython notebooks.
+-"""
+-from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
+-from .settings import _blas_info, available_cpu_count
+-import IPython
+-
+-#IPython parallel routines moved to ipyparallel in V4
+-#IPython parallel routines not in Anaconda by default
+-if IPython.version_info[0] >= 4:
+-    try:
+-        from ipyparallel import Client
+-        __all__ = ['version_table', 'plot_animation',
+-                    'parallel_map']
+-    except:
+-         __all__ = ['version_table', 'plot_animation']
+-else:
+-    try:
+-        from IPython.parallel import Client
+-        __all__ = ['version_table', 'plot_animation',
+-                    'parallel_map']
+-    except:
+-         __all__ = ['version_table', 'plot_animation']
+-
+-
+-from IPython.display import HTML, Javascript, display
+-
+-import matplotlib.pyplot as plt
+-from matplotlib import animation
+-from base64 import b64encode
+-
+-import datetime
+-import uuid
+-import sys
+-import os
+-import time
+-import inspect
+-
+-import qutip
+-import numpy
+-import scipy
+-import matplotlib
+-import IPython
+-
+-try:
+-    import Cython
+-    _cython_available = True
+-except ImportError:
+-    _cython_available = False
+-
+-
+-def version_table(verbose=False):
+-    """
+-    Print an HTML-formatted table with version numbers for QuTiP and its
+-    dependencies. Use it in a IPython notebook to show which versions of
+-    different packages that were used to run the notebook. This should make it
+-    possible to reproduce the environment and the calculation later on.
+-
+-
+-    Returns
+-    -------
+-    version_table: string
+-        Return an HTML-formatted string containing version information for
+-        QuTiP dependencies.
+-
+-    """
+-
+-    html = "<table>"
+-    html += "<tr><th>Software</th><th>Version</th></tr>"
+-
+-    packages = [("QuTiP", qutip.__version__),
+-                ("Numpy", numpy.__version__),
+-                ("SciPy", scipy.__version__),
+-                ("matplotlib", matplotlib.__version__),
+-                ("Number of CPUs", available_cpu_count()),
+-                ("BLAS Info", _blas_info()),
+-                ("IPython", IPython.__version__),
+-                ("Python", sys.version),
+-                ("OS", "%s [%s]" % (os.name, sys.platform))
+-                ]
+-    if _cython_available:
+-        packages.append(("Cython", Cython.__version__))
+-
+-    for name, version in packages:
+-        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
+-
+-    if verbose:
+-        html += "<tr><th colspan='2'>Additional information</th></tr>"
+-        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
+-        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
+-                 qutip_install_path)
+-        try:
+-            import getpass
+-            html += ("<tr><td>User</td><td>%s</td></tr>" %
+-                     getpass.getuser())
+-        except:
+-            pass
+-
+-    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
+-        '%a %b %d %H:%M:%S %Y %Z')
+-    html += "</table>"
+-
+-    return HTML(html)
+-
+-
+-def _visualize_parfor_data(metadata):
+-    """
+-    Visualizing the task scheduling meta data collected from AsyncResults.
+-    """
+-    res = numpy.array(metadata)
+-    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
+-
+-    yticks = []
+-    yticklabels = []
+-    tmin = min(res[:, 1])
+-    for n, pid in enumerate(numpy.unique(res[:, 0])):
+-        yticks.append(n)
+-        yticklabels.append("%d" % pid)
+-        for m in numpy.where(res[:, 0] == pid)[0]:
+-            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
+-                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
+-
+-    ax.set_ylim(-.5, n + .5)
+-    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
+-    ax.set_yticks(yticks)
+-    ax.set_yticklabels(yticklabels)
+-    ax.set_ylabel("Engine")
+-    ax.set_xlabel("seconds")
+-    ax.set_title("Task schedule")
+-
+-
+-def parfor(task, task_vec, args=None, client=None, view=None,
+-           show_scheduling=False, show_progressbar=False):
+-    """
+-    Call the function ``tast`` for each value in ``task_vec`` using a cluster
+-    of IPython engines. The function ``task`` should have the signature
+-    ``task(value, args)`` or ``task(value)`` if ``args=None``.
+-
+-    The ``client`` and ``view`` are the IPython.parallel client and
+-    load-balanced view that will be used in the parfor execution. If these
+-    are ``None``, new instances will be created.
+-
+-    Parameters
+-    ----------
+-
+-    task: a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-
+-    task_vec: array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-
+-    args: list / dictionary
+-        The optional additional argument to the ``task`` function. For example
+-        a dictionary with parameter values.
+-
+-    client: IPython.parallel.Client
+-        The IPython.parallel Client instance that will be used in the
+-        parfor execution.
+-
+-    view: a IPython.parallel.Client view
+-        The view that is to be used in scheduling the tasks on the IPython
+-        cluster. Preferably a load-balanced view, which is obtained from the
+-        IPython.parallel.Client instance client by calling,
+-        view = client.load_balanced_view().
+-
+-    show_scheduling: bool {False, True}, default False
+-        Display a graph showing how the tasks (the evaluation of ``task`` for
+-        for the value in ``task_vec1``) was scheduled on the IPython engine
+-        cluster.
+-
+-    show_progressbar: bool {False, True}, default False
+-        Display a HTML-based progress bar duing the execution of the parfor
+-        loop.
+-
+-    Returns
+-    -------
+-    result : list
+-        The result list contains the value of ``task(value, args)`` for each
+-        value in ``task_vec``, that is, it should be equivalent to
+-        ``[task(v, args) for v in task_vec]``.
+-    """
+-
+-    if show_progressbar:
+-        progress_bar = HTMLProgressBar()
+-    else:
+-        progress_bar = None
+-
+-    return parallel_map(task, task_vec, task_args=args,
+-                        client=client, view=view, progress_bar=progress_bar,
+-                        show_scheduling=show_scheduling)
+-
+-
+-def parallel_map(task, values, task_args=None, task_kwargs=None,
+-                 client=None, view=None, progress_bar=None,
+-                 show_scheduling=False, **kwargs):
+-    """
+-    Call the function ``task`` for each value in ``values`` using a cluster
+-    of IPython engines. The function ``task`` should have the signature
+-    ``task(value, *args, **kwargs)``.
+-
+-    The ``client`` and ``view`` are the IPython.parallel client and
+-    load-balanced view that will be used in the parfor execution. If these
+-    are ``None``, new instances will be created.
+-
+-    Parameters
+-    ----------
+-
+-    task: a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-
+-    values: array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-
+-    task_args: list / dictionary
+-        The optional additional argument to the ``task`` function.
+-
+-    task_kwargs: list / dictionary
+-        The optional additional keyword argument to the ``task`` function.
+-
+-    client: IPython.parallel.Client
+-        The IPython.parallel Client instance that will be used in the
+-        parfor execution.
+-
+-    view: a IPython.parallel.Client view
+-        The view that is to be used in scheduling the tasks on the IPython
+-        cluster. Preferably a load-balanced view, which is obtained from the
+-        IPython.parallel.Client instance client by calling,
+-        view = client.load_balanced_view().
+-
+-    show_scheduling: bool {False, True}, default False
+-        Display a graph showing how the tasks (the evaluation of ``task`` for
+-        for the value in ``task_vec1``) was scheduled on the IPython engine
+-        cluster.
+-
+-    show_progressbar: bool {False, True}, default False
+-        Display a HTML-based progress bar during the execution of the parfor
+-        loop.
+-
+-    Returns
+-    -------
+-    result : list
+-        The result list contains the value of
+-        ``task(value, task_args, task_kwargs)`` for each
+-        value in ``values``.
+-
+-    """
+-    submitted = datetime.datetime.now()
+-
+-    if task_args is None:
+-        task_args = tuple()
+-
+-    if task_kwargs is None:
+-        task_kwargs = {}
+-
+-    if client is None:
+-        client = Client()
+-
+-        # make sure qutip is available at engines
+-        dview = client[:]
+-        dview.block = True
+-        dview.execute("from qutip import *")
+-
+-    if view is None:
+-        view = client.load_balanced_view()
+-
+-    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
+-               for value in values]
+-
+-    if progress_bar is None:
+-        view.wait(ar_list)
+-    else:
+-        if progress_bar is True:
+-            progress_bar = HTMLProgressBar()
+-
+-        n = len(ar_list)
+-        progress_bar.start(n)
+-        while True:
+-            n_finished = sum([ar.progress for ar in ar_list])
+-            progress_bar.update(n_finished)
+-
+-            if view.wait(ar_list, timeout=0.5):
+-                progress_bar.update(n)
+-                break
+-        progress_bar.finished()
+-
+-    if show_scheduling:
+-        metadata = [[ar.engine_id,
+-                     (ar.started - submitted).total_seconds(),
+-                     (ar.completed - submitted).total_seconds()]
+-                    for ar in ar_list]
+-        _visualize_parfor_data(metadata)
+-
+-    return [ar.get() for ar in ar_list]
+-
+-
+-def plot_animation(plot_setup_func, plot_func, result, name="movie",
+-                   writer="avconv", codec="libx264", verbose=False):
+-    """
+-    Create an animated plot of a Result object, as returned by one of
+-    the qutip evolution solvers.
+-
+-    .. note :: experimental
+-    """
+-
+-    fig, axes = plot_setup_func(result)
+-
+-    def update(n):
+-        return plot_func(result, n, fig=fig, axes=axes)
+-
+-    anim = animation.FuncAnimation(
+-        fig, update, frames=len(result.times), blit=True)
+-
+-    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
+-
+-    plt.close(fig)
+-
+-    if verbose:
+-        print("Created %s.m4v" % name)
+-
+-    video = open(name + '.mp4', "rb").read()
+-    video_encoded = b64encode(video).decode("ascii")
+-    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
+-        video_encoded)
+-    return HTML(video_tag)
++"""
++This module contains utility functions for using QuTiP with IPython notebooks.
++"""
++from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
++from .settings import _blas_info, available_cpu_count
++import IPython
++
++#IPython parallel routines moved to ipyparallel in V4
++#IPython parallel routines not in Anaconda by default
++if IPython.version_info[0] >= 4:
++    try:
++        from ipyparallel import Client
++        __all__ = ['version_table', 'plot_animation',
++                    'parallel_map']
++    except:
++         __all__ = ['version_table', 'plot_animation']
++else:
++    try:
++        from IPython.parallel import Client
++        __all__ = ['version_table', 'plot_animation',
++                    'parallel_map']
++    except:
++         __all__ = ['version_table', 'plot_animation']
++
++
++from IPython.display import HTML, Javascript, display
++
++import matplotlib.pyplot as plt
++from matplotlib import animation
++from base64 import b64encode
++
++import datetime
++import uuid
++import sys
++import os
++import time
++import inspect
++
++import qutip
++import numpy
++import scipy
++import matplotlib
++import IPython
++
++try:
++    import Cython
++    _cython_available = True
++except ImportError:
++    _cython_available = False
++
++
++def version_table(verbose=False):
++    """
++    Print an HTML-formatted table with version numbers for QuTiP and its
++    dependencies. Use it in a IPython notebook to show which versions of
++    different packages that were used to run the notebook. This should make it
++    possible to reproduce the environment and the calculation later on.
++
++
++    Returns
++    -------
++    version_table: string
++        Return an HTML-formatted string containing version information for
++        QuTiP dependencies.
++
++    """
++
++    html = "<table>"
++    html += "<tr><th>Software</th><th>Version</th></tr>"
++
++    packages = [("QuTiP", qutip.__version__),
++                ("Numpy", numpy.__version__),
++                ("SciPy", scipy.__version__),
++                ("matplotlib", matplotlib.__version__),
++                ("Number of CPUs", available_cpu_count()),
++                ("BLAS Info", _blas_info()),
++                ("IPython", IPython.__version__),
++                ("Python", sys.version),
++                ("OS", "%s [%s]" % (os.name, sys.platform))
++                ]
++    if _cython_available:
++        packages.append(("Cython", Cython.__version__))
++
++    for name, version in packages:
++        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
++
++    if verbose:
++        html += "<tr><th colspan='2'>Additional information</th></tr>"
++        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
++        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
++                 qutip_install_path)
++        try:
++            import getpass
++            html += ("<tr><td>User</td><td>%s</td></tr>" %
++                     getpass.getuser())
++        except:
++            pass
++
++    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
++        '%a %b %d %H:%M:%S %Y %Z')
++    html += "</table>"
++
++    return HTML(html)
++
++
++def _visualize_parfor_data(metadata):
++    """
++    Visualizing the task scheduling meta data collected from AsyncResults.
++    """
++    res = numpy.array(metadata)
++    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
++
++    yticks = []
++    yticklabels = []
++    tmin = min(res[:, 1])
++    for n, pid in enumerate(numpy.unique(res[:, 0])):
++        yticks.append(n)
++        yticklabels.append("%d" % pid)
++        for m in numpy.where(res[:, 0] == pid)[0]:
++            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
++                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
++
++    ax.set_ylim(-.5, n + .5)
++    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
++    ax.set_yticks(yticks)
++    ax.set_yticklabels(yticklabels)
++    ax.set_ylabel("Engine")
++    ax.set_xlabel("seconds")
++    ax.set_title("Task schedule")
++
++
++def parfor(task, task_vec, args=None, client=None, view=None,
++           show_scheduling=False, show_progressbar=False):
++    """
++    Call the function ``tast`` for each value in ``task_vec`` using a cluster
++    of IPython engines. The function ``task`` should have the signature
++    ``task(value, args)`` or ``task(value)`` if ``args=None``.
++
++    The ``client`` and ``view`` are the IPython.parallel client and
++    load-balanced view that will be used in the parfor execution. If these
++    are ``None``, new instances will be created.
++
++    Parameters
++    ----------
++
++    task: a Python function
++        The function that is to be called for each value in ``task_vec``.
++
++    task_vec: array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++
++    args: list / dictionary
++        The optional additional argument to the ``task`` function. For example
++        a dictionary with parameter values.
++
++    client: IPython.parallel.Client
++        The IPython.parallel Client instance that will be used in the
++        parfor execution.
++
++    view: a IPython.parallel.Client view
++        The view that is to be used in scheduling the tasks on the IPython
++        cluster. Preferably a load-balanced view, which is obtained from the
++        IPython.parallel.Client instance client by calling,
++        view = client.load_balanced_view().
++
++    show_scheduling: bool {False, True}, default False
++        Display a graph showing how the tasks (the evaluation of ``task`` for
++        for the value in ``task_vec1``) was scheduled on the IPython engine
++        cluster.
++
++    show_progressbar: bool {False, True}, default False
++        Display a HTML-based progress bar duing the execution of the parfor
++        loop.
++
++    Returns
++    -------
++    result : list
++        The result list contains the value of ``task(value, args)`` for each
++        value in ``task_vec``, that is, it should be equivalent to
++        ``[task(v, args) for v in task_vec]``.
++    """
++
++    if show_progressbar:
++        progress_bar = HTMLProgressBar()
++    else:
++        progress_bar = None
++
++    return parallel_map(task, task_vec, task_args=args,
++                        client=client, view=view, progress_bar=progress_bar,
++                        show_scheduling=show_scheduling)
++
++
++def parallel_map(task, values, task_args=None, task_kwargs=None,
++                 client=None, view=None, progress_bar=None,
++                 show_scheduling=False, **kwargs):
++    """
++    Call the function ``task`` for each value in ``values`` using a cluster
++    of IPython engines. The function ``task`` should have the signature
++    ``task(value, *args, **kwargs)``.
++
++    The ``client`` and ``view`` are the IPython.parallel client and
++    load-balanced view that will be used in the parfor execution. If these
++    are ``None``, new instances will be created.
++
++    Parameters
++    ----------
++
++    task: a Python function
++        The function that is to be called for each value in ``task_vec``.
++
++    values: array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++
++    task_args: list / dictionary
++        The optional additional argument to the ``task`` function.
++
++    task_kwargs: list / dictionary
++        The optional additional keyword argument to the ``task`` function.
++
++    client: IPython.parallel.Client
++        The IPython.parallel Client instance that will be used in the
++        parfor execution.
++
++    view: a IPython.parallel.Client view
++        The view that is to be used in scheduling the tasks on the IPython
++        cluster. Preferably a load-balanced view, which is obtained from the
++        IPython.parallel.Client instance client by calling,
++        view = client.load_balanced_view().
++
++    show_scheduling: bool {False, True}, default False
++        Display a graph showing how the tasks (the evaluation of ``task`` for
++        for the value in ``task_vec1``) was scheduled on the IPython engine
++        cluster.
++
++    show_progressbar: bool {False, True}, default False
++        Display a HTML-based progress bar during the execution of the parfor
++        loop.
++
++    Returns
++    -------
++    result : list
++        The result list contains the value of
++        ``task(value, task_args, task_kwargs)`` for each
++        value in ``values``.
++
++    """
++    submitted = datetime.datetime.now()
++
++    if task_args is None:
++        task_args = tuple()
++
++    if task_kwargs is None:
++        task_kwargs = {}
++
++    if client is None:
++        client = Client()
++
++        # make sure qutip is available at engines
++        dview = client[:]
++        dview.block = True
++        dview.execute("from qutip import *")
++
++    if view is None:
++        view = client.load_balanced_view()
++
++    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
++               for value in values]
++
++    if progress_bar is None:
++        view.wait(ar_list)
++    else:
++        if progress_bar is True:
++            progress_bar = HTMLProgressBar()
++
++        n = len(ar_list)
++        progress_bar.start(n)
++        while True:
++            n_finished = sum([ar.progress for ar in ar_list])
++            progress_bar.update(n_finished)
++
++            if view.wait(ar_list, timeout=0.5):
++                progress_bar.update(n)
++                break
++        progress_bar.finished()
++
++    if show_scheduling:
++        metadata = [[ar.engine_id,
++                     (ar.started - submitted).total_seconds(),
++                     (ar.completed - submitted).total_seconds()]
++                    for ar in ar_list]
++        _visualize_parfor_data(metadata)
++
++    return [ar.get() for ar in ar_list]
++
++
++def plot_animation(plot_setup_func, plot_func, result, name="movie",
++                   writer="avconv", codec="libx264", verbose=False):
++    """
++    Create an animated plot of a Result object, as returned by one of
++    the qutip evolution solvers.
++
++    .. note :: experimental
++    """
++
++    fig, axes = plot_setup_func(result)
++
++    def update(n):
++        return plot_func(result, n, fig=fig, axes=axes)
++
++    anim = animation.FuncAnimation(
++        fig, update, frames=len(result.times), blit=True)
++
++    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
++
++    plt.close(fig)
++
++    if verbose:
++        print("Created %s.m4v" % name)
++
++    video = open(name + '.mp4', "rb").read()
++    video_encoded = b64encode(video).decode("ascii")
++    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
++        video_encoded)
++    return HTML(video_tag)
+diff --git a/qutip/logging_utils.py b/qutip/logging_utils.py
+index c91b380b..915049d9 100644
+--- a/qutip/logging_utils.py
++++ b/qutip/logging_utils.py
+@@ -1,109 +1,109 @@
+-"""
+-This module contains internal-use functions for configuring and writing to
+-debug logs, using Python's internal logging functionality by default.
+-"""
+-
+-# IMPORTS
+-from __future__ import absolute_import
+-import inspect
+-import logging
+-
+-from qutip.settings import settings
+-
+-# EXPORTS
+-NOTSET = logging.NOTSET
+-DEBUG_INTENSE = logging.DEBUG - 4
+-DEBUG_VERBOSE = logging.DEBUG - 2
+-DEBUG = logging.DEBUG
+-INFO = logging.INFO
+-WARN = logging.WARN
+-ERROR = logging.ERROR
+-CRITICAL = logging.CRITICAL
+-
+-__all__ = ['get_logger']
+-
+-# META-LOGGING
+-
+-metalogger = logging.getLogger(__name__)
+-metalogger.addHandler(logging.NullHandler())
+-
+-
+-# FUNCTIONS
+-
+-def get_logger(name=None):
+-    """
+-    Returns a Python logging object with handlers configured
+-    in accordance with ~/.qutiprc. By default, this will do
+-    something sensible to integrate with IPython when running
+-    in that environment, and will print to stdout otherwise.
+-
+-    Note that this function uses a bit of magic, and thus should
+-    not be considered part of the QuTiP API. Rather, this function
+-    is for internal use only.
+-
+-    Parameters
+-    ----------
+-
+-    name : str
+-        Name of the logger to be created. If not passed,
+-        the name will automatically be set to the name of the
+-        calling module.
+-    """
+-    if name is None:
+-        try:
+-            calling_frame = inspect.stack()[1][0]
+-            calling_module = inspect.getmodule(calling_frame)
+-            name = (calling_module.__name__
+-                    if calling_module is not None else '<none>')
+-
+-        except Exception:
+-            metalogger.warn('Error creating logger.', exc_info=1)
+-            name = '<unknown>'
+-
+-    logger = logging.getLogger(name)
+-
+-    policy = settings.log_handler
+-
+-    if policy == 'default':
+-        # Let's try to see if we're in IPython mode.
+-        policy = 'basic' if settings.ipython else 'stream'
+-
+-    metalogger.debug("Creating logger for {} with policy {}.".format(
+-        name, policy
+-    ))
+-
+-    if policy == 'basic':
+-        # Add no handlers, just let basicConfig do it all.
+-        # This is nice for working with IPython, since
+-        # it will use its own handlers instead of our StreamHandler
+-        # below.
+-        if settings.debug:
+-            logging.basicConfig(level=logging.DEBUG)
+-        else:
+-            logging.basicConfig()
+-
+-    elif policy == 'stream':
+-        formatter = logging.Formatter(
+-            '[%(asctime)s] %(name)s[%(process)s]: '
+-            '%(funcName)s: %(levelname)s: %(message)s',
+-            '%Y-%m-%d %H:%M:%S')
+-        handler = logging.StreamHandler()
+-        handler.setFormatter(formatter)
+-        logger.addHandler(handler)
+-
+-        # We're handling things here, so no propagation out.
+-        logger.propagate = False
+-
+-    elif policy == 'null':
+-        # We need to add a NullHandler so that debugging works
+-        # at all, but this policy leaves it to the user to
+-        # make their own handlers. This is particularly useful
+-        # for capturing to logfiles.
+-        logger.addHandler(logging.NullHandler())
+-
+-    if settings.debug:
+-        logger.setLevel(logging.DEBUG)
+-    else:
+-        logger.setLevel(logging.WARN)
+-
+-    return logger
++"""
++This module contains internal-use functions for configuring and writing to
++debug logs, using Python's internal logging functionality by default.
++"""
++
++# IMPORTS
++from __future__ import absolute_import
++import inspect
++import logging
++
++from qutip.settings import settings
++
++# EXPORTS
++NOTSET = logging.NOTSET
++DEBUG_INTENSE = logging.DEBUG - 4
++DEBUG_VERBOSE = logging.DEBUG - 2
++DEBUG = logging.DEBUG
++INFO = logging.INFO
++WARN = logging.WARN
++ERROR = logging.ERROR
++CRITICAL = logging.CRITICAL
++
++__all__ = ['get_logger']
++
++# META-LOGGING
++
++metalogger = logging.getLogger(__name__)
++metalogger.addHandler(logging.NullHandler())
++
++
++# FUNCTIONS
++
++def get_logger(name=None):
++    """
++    Returns a Python logging object with handlers configured
++    in accordance with ~/.qutiprc. By default, this will do
++    something sensible to integrate with IPython when running
++    in that environment, and will print to stdout otherwise.
++
++    Note that this function uses a bit of magic, and thus should
++    not be considered part of the QuTiP API. Rather, this function
++    is for internal use only.
++
++    Parameters
++    ----------
++
++    name : str
++        Name of the logger to be created. If not passed,
++        the name will automatically be set to the name of the
++        calling module.
++    """
++    if name is None:
++        try:
++            calling_frame = inspect.stack()[1][0]
++            calling_module = inspect.getmodule(calling_frame)
++            name = (calling_module.__name__
++                    if calling_module is not None else '<none>')
++
++        except Exception:
++            metalogger.warn('Error creating logger.', exc_info=1)
++            name = '<unknown>'
++
++    logger = logging.getLogger(name)
++
++    policy = settings.log_handler
++
++    if policy == 'default':
++        # Let's try to see if we're in IPython mode.
++        policy = 'basic' if settings.ipython else 'stream'
++
++    metalogger.debug("Creating logger for {} with policy {}.".format(
++        name, policy
++    ))
++
++    if policy == 'basic':
++        # Add no handlers, just let basicConfig do it all.
++        # This is nice for working with IPython, since
++        # it will use its own handlers instead of our StreamHandler
++        # below.
++        if settings.debug:
++            logging.basicConfig(level=logging.DEBUG)
++        else:
++            logging.basicConfig()
++
++    elif policy == 'stream':
++        formatter = logging.Formatter(
++            '[%(asctime)s] %(name)s[%(process)s]: '
++            '%(funcName)s: %(levelname)s: %(message)s',
++            '%Y-%m-%d %H:%M:%S')
++        handler = logging.StreamHandler()
++        handler.setFormatter(formatter)
++        logger.addHandler(handler)
++
++        # We're handling things here, so no propagation out.
++        logger.propagate = False
++
++    elif policy == 'null':
++        # We need to add a NullHandler so that debugging works
++        # at all, but this policy leaves it to the user to
++        # make their own handlers. This is particularly useful
++        # for capturing to logfiles.
++        logger.addHandler(logging.NullHandler())
++
++    if settings.debug:
++        logger.setLevel(logging.DEBUG)
++    else:
++        logger.setLevel(logging.WARN)
++
++    return logger
+diff --git a/qutip/matplotlib_utilities.py b/qutip/matplotlib_utilities.py
+index 3181b291..816a4eb1 100644
+--- a/qutip/matplotlib_utilities.py
++++ b/qutip/matplotlib_utilities.py
+@@ -1,154 +1,154 @@
+-"""
+-This module contains utility functions that enhance Matplotlib
+-in one way or another.
+-"""
+-
+-__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
+-
+-import numpy as np
+-
+-try:
+-    import matplotlib as mpl
+-    from matplotlib import cm
+-    from matplotlib.colors import (Normalize, ColorConverter)
+-except:
+-    class Normalize(object):
+-        def __init__(self, vmin=None, vmax=None, clip=False):
+-            pass
+-
+-
+-def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
+-                mid_color='#FFFFFF', min_color='#530017',
+-                neg_color='#FF97D4', invert=False):
+-    """A custom colormap that emphasizes negative values by creating a
+-    nonlinear colormap.
+-
+-    Parameters
+-    ----------
+-    W : array
+-        Wigner function array, or any array.
+-    levels : int
+-        Number of color levels to create.
+-    shift : float
+-        Shifts the value at which Wigner elements are emphasized.
+-        This parameter should typically be negative and small (i.e -1e-5).
+-    max_color : str
+-        String for color corresponding to maximum value of data.  Accepts
+-        any string format compatible with the Matplotlib.colors.ColorConverter.
+-    mid_color : str
+-        Color corresponding to zero values.  Accepts any string format
+-        compatible with the Matplotlib.colors.ColorConverter.
+-    min_color : str
+-        Color corresponding to minimum data values.  Accepts any string format
+-        compatible with the Matplotlib.colors.ColorConverter.
+-    neg_color : str
+-        Color that starts highlighting negative values.  Accepts any string
+-        format compatible with the Matplotlib.colors.ColorConverter.
+-    invert : bool
+-        Invert the color scheme for negative values so that smaller negative
+-        values have darker color.
+-
+-    Returns
+-    -------
+-    Returns a Matplotlib colormap instance for use in plotting.
+-
+-    Notes
+-    -----
+-    The 'shift' parameter allows you to vary where the colormap begins
+-    to highlight negative colors. This is beneficial in cases where there
+-    are small negative Wigner elements due to numerical round-off and/or
+-    truncation.
+-
+-    """
+-    cc = ColorConverter()
+-    max_color = np.array(cc.to_rgba(max_color), dtype=float)
+-    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
+-    if invert:
+-        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
+-        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
+-    else:
+-        min_color = np.array(cc.to_rgba(min_color), dtype=float)
+-        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
+-    # get min and max values from Wigner function
+-    bounds = [W.min(), W.max()]
+-    # create empty array for RGBA colors
+-    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
+-    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
+-                        / (bounds[1] - bounds[0])))
+-    num_pos = levels - zero_pos
+-    num_neg = zero_pos - 1
+-    # set zero values to mid_color
+-    adjust_RGBA[zero_pos] = mid_color
+-    # interpolate colors
+-    for k in range(0, levels):
+-        if k < zero_pos:
+-            interp = k / (num_neg + 1.0)
+-            adjust_RGBA[k][0:3] = (1.0 - interp) * \
+-                min_color[0:3] + interp * neg_color[0:3]
+-        elif k > zero_pos:
+-            interp = (k - zero_pos) / (num_pos + 1.0)
+-            adjust_RGBA[k][0:3] = (1.0 - interp) * \
+-                mid_color[0:3] + interp * max_color[0:3]
+-    # create colormap
+-    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
+-                                                            adjust_RGBA,
+-                                                            N=levels)
+-    return wig_cmap
+-
+-
+-def complex_phase_cmap():
+-    """
+-    Create a cyclic colormap for representing the phase of complex variables
+-
+-    Returns
+-    -------
+-    cmap :
+-        A matplotlib linear segmented colormap.
+-    """
+-    cdict = {'blue': ((0.00, 0.0, 0.0),
+-                      (0.25, 0.0, 0.0),
+-                      (0.50, 1.0, 1.0),
+-                      (0.75, 1.0, 1.0),
+-                      (1.00, 0.0, 0.0)),
+-             'green': ((0.00, 0.0, 0.0),
+-                       (0.25, 1.0, 1.0),
+-                       (0.50, 0.0, 0.0),
+-                       (0.75, 1.0, 1.0),
+-                       (1.00, 0.0, 0.0)),
+-             'red': ((0.00, 1.0, 1.0),
+-                     (0.25, 0.5, 0.5),
+-                     (0.50, 0.0, 0.0),
+-                     (0.75, 0.0, 0.0),
+-                     (1.00, 1.0, 1.0))}
+-
+-    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
+-
+-    return cmap
+-
+-
+-class MidpointNorm(Normalize):
+-    """Normalization for a colormap centered about a given midpoint.
+-
+-    Parameters
+-    ----------
+-    midpoint : float (optional, default=0)
+-        Midpoint about which colormap is centered.
+-    vmin: float (optional)
+-        Minimal value for colormap. Calculated from data by default.
+-    vmax: float (optional)
+-        Maximal value for colormap. Calculated from data by default.
+-
+-    Returns
+-    -------
+-    Returns a Matplotlib colormap normalization that can be used
+-    with any colormap.
+-
+-    """
+-
+-    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
+-        self.midpoint = midpoint
+-        Normalize.__init__(self, vmin, vmax, clip)
+-
+-    def __call__(self, value, clip=None):
+-        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+-        return np.ma.masked_array(np.interp(value, x, y))
++"""
++This module contains utility functions that enhance Matplotlib
++in one way or another.
++"""
++
++__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
++
++import numpy as np
++
++try:
++    import matplotlib as mpl
++    from matplotlib import cm
++    from matplotlib.colors import (Normalize, ColorConverter)
++except:
++    class Normalize(object):
++        def __init__(self, vmin=None, vmax=None, clip=False):
++            pass
++
++
++def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
++                mid_color='#FFFFFF', min_color='#530017',
++                neg_color='#FF97D4', invert=False):
++    """A custom colormap that emphasizes negative values by creating a
++    nonlinear colormap.
++
++    Parameters
++    ----------
++    W : array
++        Wigner function array, or any array.
++    levels : int
++        Number of color levels to create.
++    shift : float
++        Shifts the value at which Wigner elements are emphasized.
++        This parameter should typically be negative and small (i.e -1e-5).
++    max_color : str
++        String for color corresponding to maximum value of data.  Accepts
++        any string format compatible with the Matplotlib.colors.ColorConverter.
++    mid_color : str
++        Color corresponding to zero values.  Accepts any string format
++        compatible with the Matplotlib.colors.ColorConverter.
++    min_color : str
++        Color corresponding to minimum data values.  Accepts any string format
++        compatible with the Matplotlib.colors.ColorConverter.
++    neg_color : str
++        Color that starts highlighting negative values.  Accepts any string
++        format compatible with the Matplotlib.colors.ColorConverter.
++    invert : bool
++        Invert the color scheme for negative values so that smaller negative
++        values have darker color.
++
++    Returns
++    -------
++    Returns a Matplotlib colormap instance for use in plotting.
++
++    Notes
++    -----
++    The 'shift' parameter allows you to vary where the colormap begins
++    to highlight negative colors. This is beneficial in cases where there
++    are small negative Wigner elements due to numerical round-off and/or
++    truncation.
++
++    """
++    cc = ColorConverter()
++    max_color = np.array(cc.to_rgba(max_color), dtype=float)
++    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
++    if invert:
++        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
++        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
++    else:
++        min_color = np.array(cc.to_rgba(min_color), dtype=float)
++        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
++    # get min and max values from Wigner function
++    bounds = [W.min(), W.max()]
++    # create empty array for RGBA colors
++    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
++    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
++                        / (bounds[1] - bounds[0])))
++    num_pos = levels - zero_pos
++    num_neg = zero_pos - 1
++    # set zero values to mid_color
++    adjust_RGBA[zero_pos] = mid_color
++    # interpolate colors
++    for k in range(0, levels):
++        if k < zero_pos:
++            interp = k / (num_neg + 1.0)
++            adjust_RGBA[k][0:3] = (1.0 - interp) * \
++                min_color[0:3] + interp * neg_color[0:3]
++        elif k > zero_pos:
++            interp = (k - zero_pos) / (num_pos + 1.0)
++            adjust_RGBA[k][0:3] = (1.0 - interp) * \
++                mid_color[0:3] + interp * max_color[0:3]
++    # create colormap
++    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
++                                                            adjust_RGBA,
++                                                            N=levels)
++    return wig_cmap
++
++
++def complex_phase_cmap():
++    """
++    Create a cyclic colormap for representing the phase of complex variables
++
++    Returns
++    -------
++    cmap :
++        A matplotlib linear segmented colormap.
++    """
++    cdict = {'blue': ((0.00, 0.0, 0.0),
++                      (0.25, 0.0, 0.0),
++                      (0.50, 1.0, 1.0),
++                      (0.75, 1.0, 1.0),
++                      (1.00, 0.0, 0.0)),
++             'green': ((0.00, 0.0, 0.0),
++                       (0.25, 1.0, 1.0),
++                       (0.50, 0.0, 0.0),
++                       (0.75, 1.0, 1.0),
++                       (1.00, 0.0, 0.0)),
++             'red': ((0.00, 1.0, 1.0),
++                     (0.25, 0.5, 0.5),
++                     (0.50, 0.0, 0.0),
++                     (0.75, 0.0, 0.0),
++                     (1.00, 1.0, 1.0))}
++
++    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
++
++    return cmap
++
++
++class MidpointNorm(Normalize):
++    """Normalization for a colormap centered about a given midpoint.
++
++    Parameters
++    ----------
++    midpoint : float (optional, default=0)
++        Midpoint about which colormap is centered.
++    vmin: float (optional)
++        Minimal value for colormap. Calculated from data by default.
++    vmax: float (optional)
++        Maximal value for colormap. Calculated from data by default.
++
++    Returns
++    -------
++    Returns a Matplotlib colormap normalization that can be used
++    with any colormap.
++
++    """
++
++    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
++        self.midpoint = midpoint
++        Normalize.__init__(self, vmin, vmax, clip)
++
++    def __call__(self, value, clip=None):
++        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
++        return np.ma.masked_array(np.interp(value, x, y))
+diff --git a/qutip/measurement.py b/qutip/measurement.py
+index da90387d..65e2f1ca 100644
+--- a/qutip/measurement.py
++++ b/qutip/measurement.py
+@@ -1,381 +1,381 @@
+-"""
+-Module for measuring quantum objects.
+-"""
+-
+-__all__ = [
+-    'measurement_statistics_povm',
+-    'measurement_statistics_observable',
+-    'measure_observable',
+-    'measure_povm',
+-    'measurement_statistics',
+-    'measure'
+-]
+-
+-import numpy as np
+-
+-from . import Qobj, expect, identity, tensor
+-
+-
+-def _verify_input(op, state):
+-    if not isinstance(op, Qobj):
+-        raise TypeError("op must be a Qobj")
+-    if not op.isoper:
+-        raise ValueError("op must be all operators or all kets")
+-    if not isinstance(state, Qobj):
+-        raise TypeError("state must be a Qobj")
+-    if state.isket:
+-        if op.dims[-1] != state.dims[0]:
+-            raise ValueError(
+-                "op and state dims should be compatible when state is a ket")
+-    elif state.isoper:
+-        if op.dims != state.dims:
+-            raise ValueError(
+-                "op and state dims should match"
+-                " when state is a density matrix")
+-    else:
+-        raise ValueError("state must be a ket or a density matrix")
+-
+-
+-def _measurement_statistics_povm_ket(state, ops):
+-    r"""
+-    Returns measurement statistics (resultant states and probabilities)
+-    for a measurements specified by a set of positive operator valued
+-    measurements on a specified ket.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj` (ket)
+-            The ket specifying the state to measure.
+-
+-    ops : list of :class:`.Qobj`
+-      List of measurement operators :math:`M_i` (specifying a POVM such that
+-      :math:`E_i = M_i^\dagger M_i`).
+-
+-
+-    Returns
+-    -------
+-    collapsed_states : list of :class:`.Qobj` (kets)
+-        The collapsed states (kets) obtained after measuring the qubits and
+-        obtaining the qubit specified by the target in the state specified by
+-        the index.
+-
+-    probabilities : list of floats
+-        The probability of measuring a state in a the state specified by the
+-        index.
+-    """
+-    probabilities = []
+-    collapsed_states = []
+-
+-    for i, op in enumerate(ops):
+-        p = np.absolute((state.dag() * op.dag() * op * state))
+-        probabilities.append(p)
+-        if p != 0:
+-            collapsed_states.append((op * state) / np.sqrt(p))
+-        else:
+-            collapsed_states.append(None)
+-
+-    return collapsed_states, probabilities
+-
+-
+-def _measurement_statistics_povm_dm(density_mat, ops):
+-    r"""
+-    Returns measurement statistics (resultant states and probabilities)
+-    for a measurements specified by a set of positive operator valued
+-    measurements on a specified ket or density matrix.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj` (density matrix)
+-        The ket or density matrix specifying the state to measure.
+-
+-    ops : list of :class:`.Qobj`
+-        List of measurement operators :math:`M_i` (specifying a POVM s.t.
+-        :mathm:`E_i = M_i^\dagger M_i`)
+-
+-    Returns
+-    -------
+-    collapsed_states : list of :class:`.Qobj`
+-        The collapsed states (density matrices) obtained after measuring the
+-        qubits and obtaining the qubit specified by the target in the state
+-        specified by the index.
+-
+-    probabilities : list of float
+-        The probability of measuring a state in a the state specified by the
+-        index.
+-    """
+-    probabilities = []
+-    collapsed_states = []
+-
+-    for i, op in enumerate(ops):
+-        st = op * density_mat * op.dag()
+-        p = st.tr()
+-        probabilities.append(p)
+-        if p != 0:
+-            collapsed_states.append(st/p)
+-        else:
+-            collapsed_states.append(None)
+-
+-    return collapsed_states, probabilities
+-
+-
+-def measurement_statistics_povm(state, ops):
+-    r"""
+-    Returns measurement statistics (resultant states and probabilities) for a
+-    measurement specified by a set of positive operator valued measurements on
+-    a specified ket or density matrix.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj`
+-        The ket or density matrix specifying the state to measure.
+-
+-    ops : list of :class:`.Qobj`
+-        List of measurement operators :math:`M_i` or kets.  Either:
+-
+-        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+-        2. projection operators if ops correspond to
+-           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
+-        3. kets (transformed to projectors)
+-
+-    Returns
+-    -------
+-    collapsed_states : list of :class:`.Qobj`
+-        The collapsed states obtained after measuring the qubits and obtaining
+-        the qubit specified by the target in the state specified by the index.
+-
+-    probabilities : list of floats
+-        The probability of measuring a state in a the state specified by the
+-        index.
+-    """
+-    if all(map(lambda x: x.isket, ops)):
+-        ops = [op * op.dag() for op in ops]
+-
+-    for op in ops:
+-        _verify_input(op, state)
+-
+-    E = [op.dag() * op for op in ops]
+-
+-    is_ID = sum(E)
+-    if not is_ID == identity(is_ID.dims[0]):
+-        raise ValueError("measurement operators must sum to identity")
+-
+-    if state.isket:
+-        return _measurement_statistics_povm_ket(state, ops)
+-    else:
+-        return _measurement_statistics_povm_dm(state, ops)
+-
+-
+-def measurement_statistics_observable(state, op):
+-    """
+-    Return the measurement eigenvalues, eigenstates (or projectors) and
+-    measurement probabilities for the given state and measurement operator.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj`
+-        The ket or density matrix specifying the state to measure.
+-
+-    op : :class:`.Qobj`
+-        The measurement operator.
+-
+-    Returns
+-    -------
+-    eigenvalues: list of float
+-        The list of eigenvalues of the measurement operator.
+-
+-    eigenstates_or_projectors: list of :class:`.Qobj`
+-        If the state was a ket, return the eigenstates of the measurement
+-        operator. Otherwise return the projectors onto the eigenstates.
+-
+-    probabilities: list of float
+-        The probability of measuring the state as being in the corresponding
+-        eigenstate (and the measurement result being the corresponding
+-        eigenvalue).
+-    """
+-    _verify_input(op, state)
+-
+-    eigenvalues, eigenstates = op.eigenstates()
+-    if state.isket:
+-        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
+-        return eigenvalues, eigenstates, probabilities
+-    else:
+-        projectors = [e.proj() for e in eigenstates]
+-        probabilities = [expect(v, state) for v in projectors]
+-        return eigenvalues, projectors, probabilities
+-
+-
+-def measure_observable(state, op):
+-    """
+-    Perform a measurement specified by an operator on the given state.
+-
+-    This function simulates the classic quantum measurement described in many
+-    introductory texts on quantum mechanics. The measurement collapses the
+-    state to one of the eigenstates of the given operator and the result of the
+-    measurement is the corresponding eigenvalue.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj`
+-        The ket or density matrix specifying the state to measure.
+-
+-    op : :class:`.Qobj`
+-        The measurement operator.
+-
+-    Returns
+-    -------
+-    measured_value : float
+-        The result of the measurement (one of the eigenvalues of op).
+-
+-    state : :class:`.Qobj`
+-        The new state (a ket if a ket was given, otherwise a density matrix).
+-
+-    Examples
+-    --------
+-
+-    Measure the z-component of the spin of the spin-up basis state:
+-
+-    >>> measure_observable(basis(2, 0), sigmaz())
+-    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
+-    Qobj data =
+-    [[-1.]
+-     [ 0.]])
+-
+-    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
+-    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
+-    and the original state (up to a global phase).
+-
+-    Measure the x-component of the spin of the spin-down basis state:
+-
+-    >>> measure_observable(basis(2, 1), sigmax())
+-    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
+-    Qobj data =
+-    [[-0.70710678]
+-     [ 0.70710678]])
+-
+-    This measurement returns 1 fifty percent of the time and -1 the other fifty
+-    percent of the time. The new state returned is the corresponding eigenstate
+-    of sigmax.
+-
+-    One may also perform a measurement on a density matrix. Below we perform
+-    the same measurement as above, but on the density matrix representing the
+-    pure spin-down state:
+-
+-    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
+-    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
+-    Qobj data =
+-    [[ 0.5 -0.5]
+-     [-0.5  0.5]])
+-
+-    The measurement result is the same, but the new state is returned as a
+-    density matrix.
+-    """
+-    eigenvalues, eigenstates_or_projectors, probabilities = (
+-        measurement_statistics_observable(state, op))
+-    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
+-    if state.isket:
+-        eigenstates = eigenstates_or_projectors
+-        state = eigenstates[i]
+-    else:
+-        projectors = eigenstates_or_projectors
+-        state = (projectors[i] * state * projectors[i]) / probabilities[i]
+-    return eigenvalues[i], state
+-
+-
+-def measure_povm(state, ops):
+-    r"""
+-    Perform a measurement specified by list of POVMs.
+-
+-    This function simulates a POVM measurement. The measurement collapses the
+-    state to one of the resultant states of the measurement and returns the
+-    index of the operator corresponding to the collapsed state as well as the
+-    collapsed state.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj`
+-        The ket or density matrix specifying the state to measure.
+-
+-    ops : list of :class:`.Qobj`
+-        List of measurement operators :math:`M_i` or kets.  Either:
+-
+-        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+-        2. projection operators if ops correspond to projectors (s.t.
+-           :math:`E_i = M_i^\dagger = M_i`)
+-        3. kets (transformed to projectors)
+-
+-    Returns
+-    -------
+-    index : float
+-        The resultant index of the measurement.
+-
+-    state : :class:`.Qobj`
+-        The new state (a ket if a ket was given, otherwise a density matrix).
+-    """
+-    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
+-    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
+-    state = collapsed_states[index]
+-    return index, state
+-
+-
+-def measurement_statistics(state, ops):
+-    r"""
+-    A dispatch method that provides measurement statistics handling both
+-    observable style measurements and projector style measurements(POVMs and
+-    PVMs).
+-
+-    For return signatures, please check:
+-
+-    - :func:`~measurement_statistics_observable` for observable measurements.
+-    - :func:`~measurement_statistics_povm` for POVM measurements.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj`
+-        The ket or density matrix specifying the state to measure.
+-
+-    ops : :class:`.Qobj` or list of :class:`.Qobj`
+-        - measurement observable (:class:.Qobj); or
+-        - list of measurement operators :math:`M_i` or kets (list of
+-          :class:`.Qobj`) Either:
+-
+-          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
+-          2. projection operators if ops correspond to projectors (s.t.
+-             :math:`E_i = M_i^\dagger = M_i`)
+-          3. kets (transformed to projectors)
+-    """
+-    if isinstance(ops, list):
+-        return measurement_statistics_povm(state, ops)
+-    else:
+-        return measurement_statistics_observable(state, ops)
+-
+-
+-def measure(state, ops):
+-    r"""
+-    A dispatch method that provides measurement results handling both
+-    observable style measurements and projector style measurements (POVMs and
+-    PVMs).
+-
+-    For return signatures, please check:
+-
+-    - :func:`~measure_observable` for observable measurements.
+-    - :func:`~measure_povm` for POVM measurements.
+-
+-    Parameters
+-    ----------
+-    state : :class:`.Qobj`
+-        The ket or density matrix specifying the state to measure.
+-
+-    ops : :class:`.Qobj` or list of :class:`.Qobj`
+-        - measurement observable (:class:`.Qobj`); or
+-        - list of measurement operators :math:`M_i` or kets (list of
+-          :class:`.Qobj`) Either:
+-
+-          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+-          2. projection operators if ops correspond to projectors (s.t.
+-             :math:`E_i = M_i^\dagger = M_i`)
+-          3. kets (transformed to projectors)
+-    """
+-    if isinstance(ops, list):
+-        return measure_povm(state, ops)
+-    else:
+-        return measure_observable(state, ops)
++"""
++Module for measuring quantum objects.
++"""
++
++__all__ = [
++    'measurement_statistics_povm',
++    'measurement_statistics_observable',
++    'measure_observable',
++    'measure_povm',
++    'measurement_statistics',
++    'measure'
++]
++
++import numpy as np
++
++from . import Qobj, expect, identity, tensor
++
++
++def _verify_input(op, state):
++    if not isinstance(op, Qobj):
++        raise TypeError("op must be a Qobj")
++    if not op.isoper:
++        raise ValueError("op must be all operators or all kets")
++    if not isinstance(state, Qobj):
++        raise TypeError("state must be a Qobj")
++    if state.isket:
++        if op.dims[-1] != state.dims[0]:
++            raise ValueError(
++                "op and state dims should be compatible when state is a ket")
++    elif state.isoper:
++        if op.dims != state.dims:
++            raise ValueError(
++                "op and state dims should match"
++                " when state is a density matrix")
++    else:
++        raise ValueError("state must be a ket or a density matrix")
++
++
++def _measurement_statistics_povm_ket(state, ops):
++    r"""
++    Returns measurement statistics (resultant states and probabilities)
++    for a measurements specified by a set of positive operator valued
++    measurements on a specified ket.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj` (ket)
++            The ket specifying the state to measure.
++
++    ops : list of :class:`.Qobj`
++      List of measurement operators :math:`M_i` (specifying a POVM such that
++      :math:`E_i = M_i^\dagger M_i`).
++
++
++    Returns
++    -------
++    collapsed_states : list of :class:`.Qobj` (kets)
++        The collapsed states (kets) obtained after measuring the qubits and
++        obtaining the qubit specified by the target in the state specified by
++        the index.
++
++    probabilities : list of floats
++        The probability of measuring a state in a the state specified by the
++        index.
++    """
++    probabilities = []
++    collapsed_states = []
++
++    for i, op in enumerate(ops):
++        p = np.absolute((state.dag() * op.dag() * op * state))
++        probabilities.append(p)
++        if p != 0:
++            collapsed_states.append((op * state) / np.sqrt(p))
++        else:
++            collapsed_states.append(None)
++
++    return collapsed_states, probabilities
++
++
++def _measurement_statistics_povm_dm(density_mat, ops):
++    r"""
++    Returns measurement statistics (resultant states and probabilities)
++    for a measurements specified by a set of positive operator valued
++    measurements on a specified ket or density matrix.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj` (density matrix)
++        The ket or density matrix specifying the state to measure.
++
++    ops : list of :class:`.Qobj`
++        List of measurement operators :math:`M_i` (specifying a POVM s.t.
++        :mathm:`E_i = M_i^\dagger M_i`)
++
++    Returns
++    -------
++    collapsed_states : list of :class:`.Qobj`
++        The collapsed states (density matrices) obtained after measuring the
++        qubits and obtaining the qubit specified by the target in the state
++        specified by the index.
++
++    probabilities : list of float
++        The probability of measuring a state in a the state specified by the
++        index.
++    """
++    probabilities = []
++    collapsed_states = []
++
++    for i, op in enumerate(ops):
++        st = op * density_mat * op.dag()
++        p = st.tr()
++        probabilities.append(p)
++        if p != 0:
++            collapsed_states.append(st/p)
++        else:
++            collapsed_states.append(None)
++
++    return collapsed_states, probabilities
++
++
++def measurement_statistics_povm(state, ops):
++    r"""
++    Returns measurement statistics (resultant states and probabilities) for a
++    measurement specified by a set of positive operator valued measurements on
++    a specified ket or density matrix.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj`
++        The ket or density matrix specifying the state to measure.
++
++    ops : list of :class:`.Qobj`
++        List of measurement operators :math:`M_i` or kets.  Either:
++
++        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
++        2. projection operators if ops correspond to
++           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
++        3. kets (transformed to projectors)
++
++    Returns
++    -------
++    collapsed_states : list of :class:`.Qobj`
++        The collapsed states obtained after measuring the qubits and obtaining
++        the qubit specified by the target in the state specified by the index.
++
++    probabilities : list of floats
++        The probability of measuring a state in a the state specified by the
++        index.
++    """
++    if all(map(lambda x: x.isket, ops)):
++        ops = [op * op.dag() for op in ops]
++
++    for op in ops:
++        _verify_input(op, state)
++
++    E = [op.dag() * op for op in ops]
++
++    is_ID = sum(E)
++    if not is_ID == identity(is_ID.dims[0]):
++        raise ValueError("measurement operators must sum to identity")
++
++    if state.isket:
++        return _measurement_statistics_povm_ket(state, ops)
++    else:
++        return _measurement_statistics_povm_dm(state, ops)
++
++
++def measurement_statistics_observable(state, op):
++    """
++    Return the measurement eigenvalues, eigenstates (or projectors) and
++    measurement probabilities for the given state and measurement operator.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj`
++        The ket or density matrix specifying the state to measure.
++
++    op : :class:`.Qobj`
++        The measurement operator.
++
++    Returns
++    -------
++    eigenvalues: list of float
++        The list of eigenvalues of the measurement operator.
++
++    eigenstates_or_projectors: list of :class:`.Qobj`
++        If the state was a ket, return the eigenstates of the measurement
++        operator. Otherwise return the projectors onto the eigenstates.
++
++    probabilities: list of float
++        The probability of measuring the state as being in the corresponding
++        eigenstate (and the measurement result being the corresponding
++        eigenvalue).
++    """
++    _verify_input(op, state)
++
++    eigenvalues, eigenstates = op.eigenstates()
++    if state.isket:
++        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
++        return eigenvalues, eigenstates, probabilities
++    else:
++        projectors = [e.proj() for e in eigenstates]
++        probabilities = [expect(v, state) for v in projectors]
++        return eigenvalues, projectors, probabilities
++
++
++def measure_observable(state, op):
++    """
++    Perform a measurement specified by an operator on the given state.
++
++    This function simulates the classic quantum measurement described in many
++    introductory texts on quantum mechanics. The measurement collapses the
++    state to one of the eigenstates of the given operator and the result of the
++    measurement is the corresponding eigenvalue.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj`
++        The ket or density matrix specifying the state to measure.
++
++    op : :class:`.Qobj`
++        The measurement operator.
++
++    Returns
++    -------
++    measured_value : float
++        The result of the measurement (one of the eigenvalues of op).
++
++    state : :class:`.Qobj`
++        The new state (a ket if a ket was given, otherwise a density matrix).
++
++    Examples
++    --------
++
++    Measure the z-component of the spin of the spin-up basis state:
++
++    >>> measure_observable(basis(2, 0), sigmaz())
++    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
++    Qobj data =
++    [[-1.]
++     [ 0.]])
++
++    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
++    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
++    and the original state (up to a global phase).
++
++    Measure the x-component of the spin of the spin-down basis state:
++
++    >>> measure_observable(basis(2, 1), sigmax())
++    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
++    Qobj data =
++    [[-0.70710678]
++     [ 0.70710678]])
++
++    This measurement returns 1 fifty percent of the time and -1 the other fifty
++    percent of the time. The new state returned is the corresponding eigenstate
++    of sigmax.
++
++    One may also perform a measurement on a density matrix. Below we perform
++    the same measurement as above, but on the density matrix representing the
++    pure spin-down state:
++
++    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
++    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
++    Qobj data =
++    [[ 0.5 -0.5]
++     [-0.5  0.5]])
++
++    The measurement result is the same, but the new state is returned as a
++    density matrix.
++    """
++    eigenvalues, eigenstates_or_projectors, probabilities = (
++        measurement_statistics_observable(state, op))
++    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
++    if state.isket:
++        eigenstates = eigenstates_or_projectors
++        state = eigenstates[i]
++    else:
++        projectors = eigenstates_or_projectors
++        state = (projectors[i] * state * projectors[i]) / probabilities[i]
++    return eigenvalues[i], state
++
++
++def measure_povm(state, ops):
++    r"""
++    Perform a measurement specified by list of POVMs.
++
++    This function simulates a POVM measurement. The measurement collapses the
++    state to one of the resultant states of the measurement and returns the
++    index of the operator corresponding to the collapsed state as well as the
++    collapsed state.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj`
++        The ket or density matrix specifying the state to measure.
++
++    ops : list of :class:`.Qobj`
++        List of measurement operators :math:`M_i` or kets.  Either:
++
++        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
++        2. projection operators if ops correspond to projectors (s.t.
++           :math:`E_i = M_i^\dagger = M_i`)
++        3. kets (transformed to projectors)
++
++    Returns
++    -------
++    index : float
++        The resultant index of the measurement.
++
++    state : :class:`.Qobj`
++        The new state (a ket if a ket was given, otherwise a density matrix).
++    """
++    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
++    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
++    state = collapsed_states[index]
++    return index, state
++
++
++def measurement_statistics(state, ops):
++    r"""
++    A dispatch method that provides measurement statistics handling both
++    observable style measurements and projector style measurements(POVMs and
++    PVMs).
++
++    For return signatures, please check:
++
++    - :func:`~measurement_statistics_observable` for observable measurements.
++    - :func:`~measurement_statistics_povm` for POVM measurements.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj`
++        The ket or density matrix specifying the state to measure.
++
++    ops : :class:`.Qobj` or list of :class:`.Qobj`
++        - measurement observable (:class:.Qobj); or
++        - list of measurement operators :math:`M_i` or kets (list of
++          :class:`.Qobj`) Either:
++
++          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
++          2. projection operators if ops correspond to projectors (s.t.
++             :math:`E_i = M_i^\dagger = M_i`)
++          3. kets (transformed to projectors)
++    """
++    if isinstance(ops, list):
++        return measurement_statistics_povm(state, ops)
++    else:
++        return measurement_statistics_observable(state, ops)
++
++
++def measure(state, ops):
++    r"""
++    A dispatch method that provides measurement results handling both
++    observable style measurements and projector style measurements (POVMs and
++    PVMs).
++
++    For return signatures, please check:
++
++    - :func:`~measure_observable` for observable measurements.
++    - :func:`~measure_povm` for POVM measurements.
++
++    Parameters
++    ----------
++    state : :class:`.Qobj`
++        The ket or density matrix specifying the state to measure.
++
++    ops : :class:`.Qobj` or list of :class:`.Qobj`
++        - measurement observable (:class:`.Qobj`); or
++        - list of measurement operators :math:`M_i` or kets (list of
++          :class:`.Qobj`) Either:
++
++          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
++          2. projection operators if ops correspond to projectors (s.t.
++             :math:`E_i = M_i^\dagger = M_i`)
++          3. kets (transformed to projectors)
++    """
++    if isinstance(ops, list):
++        return measure_povm(state, ops)
++    else:
++        return measure_observable(state, ops)
+diff --git a/qutip/orbital.py b/qutip/orbital.py
+index 209b65b4..6d171d88 100644
+--- a/qutip/orbital.py
++++ b/qutip/orbital.py
+@@ -1,81 +1,81 @@
+-__all__ = ['orbital']
+-
+-import numpy as np
+-from scipy.special import sph_harm
+-
+-
+-def orbital(theta, phi, *args):
+-    r"""Calculates an angular wave function on a sphere.
+-    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
+-    the angular wave function on a sphere at the mesh of points
+-    defined by theta and phi which is
+-    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
+-    coefficients specified by the list of kets. Each ket has 2l+1 components
+-    for some integer l. The first entry of the ket defines the coefficient
+-    c_{l,-l}, while the last entry of the ket defines the
+-    coefficient c_{l, l}.
+-
+-    Parameters
+-    ----------
+-    theta : int/float/list/array
+-        Polar angles in [0, pi]
+-
+-    phi : int/float/list/array
+-        Azimuthal angles in [0, 2*pi]
+-
+-    args : list/array
+-        ``list`` of ket vectors.
+-
+-    Returns
+-    -------
+-    ``array`` for angular wave function evaluated at all
+-              possible combinations of theta and phi
+-
+-    """
+-    if isinstance(args[0], list):
+-        # use the list in args[0]
+-        args = args[0]
+-
+-    # convert to numpy array
+-    theta = np.atleast_1d(theta)
+-    phi = np.atleast_1d(phi)
+-    # check that arrays are only 1D
+-    if len(theta.shape) != 1:
+-        raise ValueError('Polar angles theta must be 1D list')
+-    if len(phi.shape) != 1:
+-        raise ValueError('Azimuthal angles phi must be 1D list')
+-
+-    # make meshgrid
+-    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+-    # setup empty wavefunction
+-    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
+-    # iterate through provided kets
+-    for k in range(len(args)):
+-        ket = args[k]
+-        if ket.type == 'bra':
+-            ket = ket.conj()
+-        elif not ket.type == 'ket':
+-            raise TypeError('Invalid type for input ket in orbital')
+-        # Extract l value from the state
+-        l = (ket.shape[0] - 1) / 2.0
+-        if l != np.floor(l):
+-            raise ValueError(
+-                'Kets must have odd number of components in orbital')
+-        l = int(l)
+-        # get factors from ket
+-        factors = ket.full()
+-        # iterate through the possible m
+-
+-        for i in range(len(factors)):
+-            # set correct m
+-            m = i - l
+-            # calculate spherical harmonics
+-            # note that theta and phi are interchanged in scipy implementation
+-            res = sph_harm(m, l, phi_mesh, theta_mesh)
+-            psi += factors[i] * res
+-
+-    # flatten output if only one row
+-    if psi.shape[1] == 1:
+-        psi = psi.flatten()
+-
+-    return psi
++__all__ = ['orbital']
++
++import numpy as np
++from scipy.special import sph_harm
++
++
++def orbital(theta, phi, *args):
++    r"""Calculates an angular wave function on a sphere.
++    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
++    the angular wave function on a sphere at the mesh of points
++    defined by theta and phi which is
++    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
++    coefficients specified by the list of kets. Each ket has 2l+1 components
++    for some integer l. The first entry of the ket defines the coefficient
++    c_{l,-l}, while the last entry of the ket defines the
++    coefficient c_{l, l}.
++
++    Parameters
++    ----------
++    theta : int/float/list/array
++        Polar angles in [0, pi]
++
++    phi : int/float/list/array
++        Azimuthal angles in [0, 2*pi]
++
++    args : list/array
++        ``list`` of ket vectors.
++
++    Returns
++    -------
++    ``array`` for angular wave function evaluated at all
++              possible combinations of theta and phi
++
++    """
++    if isinstance(args[0], list):
++        # use the list in args[0]
++        args = args[0]
++
++    # convert to numpy array
++    theta = np.atleast_1d(theta)
++    phi = np.atleast_1d(phi)
++    # check that arrays are only 1D
++    if len(theta.shape) != 1:
++        raise ValueError('Polar angles theta must be 1D list')
++    if len(phi.shape) != 1:
++        raise ValueError('Azimuthal angles phi must be 1D list')
++
++    # make meshgrid
++    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
++    # setup empty wavefunction
++    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
++    # iterate through provided kets
++    for k in range(len(args)):
++        ket = args[k]
++        if ket.type == 'bra':
++            ket = ket.conj()
++        elif not ket.type == 'ket':
++            raise TypeError('Invalid type for input ket in orbital')
++        # Extract l value from the state
++        l = (ket.shape[0] - 1) / 2.0
++        if l != np.floor(l):
++            raise ValueError(
++                'Kets must have odd number of components in orbital')
++        l = int(l)
++        # get factors from ket
++        factors = ket.full()
++        # iterate through the possible m
++
++        for i in range(len(factors)):
++            # set correct m
++            m = i - l
++            # calculate spherical harmonics
++            # note that theta and phi are interchanged in scipy implementation
++            res = sph_harm(m, l, phi_mesh, theta_mesh)
++            psi += factors[i] * res
++
++    # flatten output if only one row
++    if psi.shape[1] == 1:
++        psi = psi.flatten()
++
++    return psi
+diff --git a/qutip/partial_transpose.py b/qutip/partial_transpose.py
+index 61871369..4a0b2595 100644
+--- a/qutip/partial_transpose.py
++++ b/qutip/partial_transpose.py
+@@ -1,122 +1,122 @@
+-__all__ = ['partial_transpose']
+-
+-import numpy as np
+-import scipy.sparse as sp
+-
+-from . import (
+-    Qobj, state_index_number, state_number_index, state_number_enumerate,
+-)
+-from .core.dimensions import flatten
+-
+-
+-def partial_transpose(rho, mask, method='dense'):
+-    """
+-    Return the partial transpose of a Qobj instance `rho`,
+-    where `mask` is an array/list with length that equals
+-    the number of components of `rho` (that is, the length of
+-    `rho.dims[0]`), and the values in `mask` indicates whether
+-    or not the corresponding subsystem is to be transposed.
+-    The elements in `mask` can be boolean or integers `0` or `1`,
+-    where `True`/`1` indicates that the corresponding subsystem
+-    should be tranposed.
+-
+-    Parameters
+-    ----------
+-
+-    rho : :class:`qutip.qobj`
+-        A density matrix.
+-
+-    mask : *list* / *array*
+-        A mask that selects which subsystems should be transposed.
+-
+-    method : str
+-        choice of method, `dense` or `sparse`. The default method
+-        is `dense`. The `sparse` implementation can be faster for
+-        large and sparse systems (hundreds of quantum states).
+-
+-    Returns
+-    -------
+-
+-    rho_pr: :class:`qutip.qobj`
+-
+-        A density matrix with the selected subsystems transposed.
+-
+-    """
+-
+-    mask = [int(i) for i in mask]
+-
+-    if method == 'sparse':
+-        return _partial_transpose_sparse(rho, mask)
+-    else:
+-        return _partial_transpose_dense(rho, mask)
+-
+-
+-def _partial_transpose_dense(rho, mask):
+-    """
+-    Based on Jonas' implementation using numpy.
+-    Very fast for dense problems.
+-    """
+-    nsys = len(mask)
+-    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
+-    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
+-                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
+-
+-    data = (rho.full()
+-            .reshape(flatten(rho.dims))
+-            .transpose(pt_idx)
+-            .reshape(rho.shape))
+-    return Qobj(data, dims=rho.dims)
+-
+-
+-def _partial_transpose_sparse(rho, mask):
+-    """
+-    Implement the partial transpose using the CSR sparse matrix.
+-    """
+-
+-    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
+-    rho_data = rho.to("CSR").data.as_scipy()
+-
+-    for m in range(len(rho_data.indptr) - 1):
+-
+-        n1 = rho_data.indptr[m]
+-        n2 = rho_data.indptr[m + 1]
+-
+-        psi_A = state_index_number(rho.dims[0], m)
+-
+-        for idx, n in enumerate(rho_data.indices[n1:n2]):
+-
+-            psi_B = state_index_number(rho.dims[1], n)
+-
+-            m_pt = state_number_index(
+-                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
+-            n_pt = state_number_index(
+-                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
+-
+-            data[m_pt, n_pt] = rho_data.data[n1 + idx]
+-
+-    return Qobj(data.tocsr(), dims=rho.dims)
+-
+-
+-def _partial_transpose_reference(rho, mask):
+-    """
+-    This is a reference implementation that explicitly loops over
+-    all states and performs the transpose. It's slow but easy to
+-    understand and useful for testing.
+-    """
+-
+-    A_pt = np.zeros(rho.shape, dtype=complex)
+-
+-    for psi_A in state_number_enumerate(rho.dims[0]):
+-        m = state_number_index(rho.dims[0], psi_A)
+-
+-        for psi_B in state_number_enumerate(rho.dims[1]):
+-            n = state_number_index(rho.dims[1], psi_B)
+-
+-            m_pt = state_number_index(
+-                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
+-            n_pt = state_number_index(
+-                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
+-
+-            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
+-
+-    return Qobj(A_pt, dims=rho.dims)
++__all__ = ['partial_transpose']
++
++import numpy as np
++import scipy.sparse as sp
++
++from . import (
++    Qobj, state_index_number, state_number_index, state_number_enumerate,
++)
++from .core.dimensions import flatten
++
++
++def partial_transpose(rho, mask, method='dense'):
++    """
++    Return the partial transpose of a Qobj instance `rho`,
++    where `mask` is an array/list with length that equals
++    the number of components of `rho` (that is, the length of
++    `rho.dims[0]`), and the values in `mask` indicates whether
++    or not the corresponding subsystem is to be transposed.
++    The elements in `mask` can be boolean or integers `0` or `1`,
++    where `True`/`1` indicates that the corresponding subsystem
++    should be tranposed.
++
++    Parameters
++    ----------
++
++    rho : :class:`qutip.qobj`
++        A density matrix.
++
++    mask : *list* / *array*
++        A mask that selects which subsystems should be transposed.
++
++    method : str
++        choice of method, `dense` or `sparse`. The default method
++        is `dense`. The `sparse` implementation can be faster for
++        large and sparse systems (hundreds of quantum states).
++
++    Returns
++    -------
++
++    rho_pr: :class:`qutip.qobj`
++
++        A density matrix with the selected subsystems transposed.
++
++    """
++
++    mask = [int(i) for i in mask]
++
++    if method == 'sparse':
++        return _partial_transpose_sparse(rho, mask)
++    else:
++        return _partial_transpose_dense(rho, mask)
++
++
++def _partial_transpose_dense(rho, mask):
++    """
++    Based on Jonas' implementation using numpy.
++    Very fast for dense problems.
++    """
++    nsys = len(mask)
++    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
++    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
++                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
++
++    data = (rho.full()
++            .reshape(flatten(rho.dims))
++            .transpose(pt_idx)
++            .reshape(rho.shape))
++    return Qobj(data, dims=rho.dims)
++
++
++def _partial_transpose_sparse(rho, mask):
++    """
++    Implement the partial transpose using the CSR sparse matrix.
++    """
++
++    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
++    rho_data = rho.to("CSR").data.as_scipy()
++
++    for m in range(len(rho_data.indptr) - 1):
++
++        n1 = rho_data.indptr[m]
++        n2 = rho_data.indptr[m + 1]
++
++        psi_A = state_index_number(rho.dims[0], m)
++
++        for idx, n in enumerate(rho_data.indices[n1:n2]):
++
++            psi_B = state_index_number(rho.dims[1], n)
++
++            m_pt = state_number_index(
++                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
++            n_pt = state_number_index(
++                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
++
++            data[m_pt, n_pt] = rho_data.data[n1 + idx]
++
++    return Qobj(data.tocsr(), dims=rho.dims)
++
++
++def _partial_transpose_reference(rho, mask):
++    """
++    This is a reference implementation that explicitly loops over
++    all states and performs the transpose. It's slow but easy to
++    understand and useful for testing.
++    """
++
++    A_pt = np.zeros(rho.shape, dtype=complex)
++
++    for psi_A in state_number_enumerate(rho.dims[0]):
++        m = state_number_index(rho.dims[0], psi_A)
++
++        for psi_B in state_number_enumerate(rho.dims[1]):
++            n = state_number_index(rho.dims[1], psi_B)
++
++            m_pt = state_number_index(
++                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
++            n_pt = state_number_index(
++                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
++
++            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
++
++    return Qobj(A_pt, dims=rho.dims)
+diff --git a/qutip/qip.py b/qutip/qip.py
+index 392b835a..69cfc856 100644
+--- a/qutip/qip.py
++++ b/qutip/qip.py
+@@ -1,13 +1,13 @@
+-"""Module replicating the qutip_qip package from within qutip."""
+-import sys
+-
+-try:
+-    import qutip_qip
+-    del qutip_qip
+-    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
+-except ImportError:
+-    raise ImportError(
+-        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
+-        "with `pip install qutip-qip` (for more details, go to "
+-        "https://qutip-qip.readthedocs.io/)."
+-    )
++"""Module replicating the qutip_qip package from within qutip."""
++import sys
++
++try:
++    import qutip_qip
++    del qutip_qip
++    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
++except ImportError:
++    raise ImportError(
++        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
++        "with `pip install qutip-qip` (for more details, go to "
++        "https://qutip-qip.readthedocs.io/)."
++    )
+diff --git a/qutip/random_objects.py b/qutip/random_objects.py
+index be759ae9..5e8f010b 100644
+--- a/qutip/random_objects.py
++++ b/qutip/random_objects.py
+@@ -1,868 +1,868 @@
+-"""
+-This module is a collection of random state and operator generators.
+-"""
+-
+-__all__ = [
+-    'rand_herm',
+-    'rand_unitary',
+-    'rand_dm',
+-    'rand_stochastic',
+-    'rand_ket',
+-    'rand_kraus_map',
+-    'rand_super',
+-    "rand_super_bcsz",
+-]
+-
+-import numbers
+-
+-import numpy as np
+-from numpy.random import Generator, SeedSequence, default_rng
+-import scipy.linalg
+-import scipy.sparse as sp
+-
+-from . import (Qobj, create, destroy, jmat, basis,
+-               to_super, to_choi, to_chi, to_kraus, to_stinespring)
+-from .core import data as _data
+-from .core.dimensions import flatten
+-from . import settings
+-
+-
+-_RAND = default_rng()
+-_UNITS = np.array([1, 1j])
+-
+-
+-def _implicit_tensor_dimensions(dimensions, superoper=False):
+-    """
+-    Total flattened size and operator dimensions for operator creation routines
+-    that automatically perform tensor products.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        First dimension of an operator which can create an implicit tensor
+-        product.  If the type is `int`, it is promoted first to `[dimensions]`.
+-        From there, it should be one of the two-elements `dims` parameter of a
+-        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
+-        products.
+-
+-    Returns
+-    -------
+-    size : int
+-        Dimension of backing matrix required to represent operator.
+-    dimensions : list
+-        Dimension list in the form required by ``Qobj`` creation.
+-    """
+-    if not isinstance(dimensions, list):
+-        dimensions = [dimensions]
+-    flat = flatten(dimensions)
+-    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
+-        raise ValueError("All dimensions must be integers >= 0")
+-    N = np.prod(flat)
+-    if superoper:
+-        if isinstance(dimensions[0], numbers.Integral):
+-            dimensions = [dimensions, dimensions]
+-        else:
+-            N = int(N**0.5)
+-    return N, [dimensions, dimensions]
+-
+-
+-def _get_generator(seed):
+-    """
+-    Obtain a random generator from a seed or generator.
+-
+-    Parameters
+-    ----------
+-    seed: int, SeedSequence, Generator, NoneType
+-        Seed to create the generator. If it's already a generator return it.
+-        When ``None`` is suplied, a default generator is provided.
+-    """
+-    if seed is None:
+-        gen = _RAND
+-    elif isinstance(seed, Generator):
+-        gen = seed
+-    else:
+-        gen = default_rng(seed)
+-    return gen
+-
+-
+-def _randnz(shape, generator, norm=np.sqrt(0.5)):
+-    """
+-    Returns an array of standard normal complex random variates.
+-    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
+-
+-    Parameters
+-    ----------
+-    shape : tuple
+-        Shape of the returned array of random variates.
+-
+-    generator : Generator
+-        Random number generator.
+-
+-    norm : float
+-        Scale of the returned random variates, or 'ginibre' to draw
+-        from the Ginibre ensemble.
+-    """
+-    # This function is intended for internal use.
+-    if norm == 'ginibre':
+-        norm = 1
+-    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
+-
+-
+-def _rand_jacobi_rotation(A, generator):
+-    """Random Jacobi rotation of a matrix.
+-
+-    Parameters
+-    ----------
+-    A : qutip.data.Data
+-        Matrix to rotate as a data layer object.
+-
+-    generator : numpy.random.generator
+-        Random number generator.
+-
+-    Returns
+-    -------
+-    qutip.data.Data
+-        Rotated sparse matrix.
+-    """
+-    if A.shape[0] != A.shape[1]:
+-        raise ValueError('Input matrix must be square.')
+-    n = A.shape[0]
+-    angle = 2 * generator.random() * np.pi
+-    a = np.sqrt(0.5) * np.exp(-1j * angle)
+-    b = np.conj(a)
+-    i = generator.integers(n)
+-    j = i
+-    while i == j:
+-        j = generator.integers(n)
+-    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
+-                      np.ones(n - 2, dtype=complex)))
+-    diag = np.delete(np.arange(n), [i, j])
+-    rows = np.hstack(([i, i, j, j], diag))
+-    cols = np.hstack(([i, j, i, j], diag))
+-    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
+-    R = _data.create(R.tocsr())
+-    return _data.matmul(_data.matmul(R, A), R.adjoint())
+-
+-
+-def _get_block_sizes(N, density, generator):
+-    """
+-    Obtain a list of matrix block sizes in such a way that an NxN matrix
+-    composed of full matrices of these sizes along the diagonal would be of
+-    desired density.
+-    """
+-    if density <= 0:
+-        return [1] * N
+-    elif density >= 1:
+-        return [N]
+-    max_block_size = int((N**2 * density)**0.5)
+-    min_block_size = 1
+-    if density >= 0.5:
+-        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
+-
+-    if min_block_size >= max_block_size:
+-        M = min(min_block_size, max_block_size)
+-    else:
+-        M = generator.integers(min_block_size, max_block_size) + 1
+-    M += generator.integers(-1, 2)
+-    M = min(max(M, 1), N)
+-
+-    other_blocks = []
+-    if M < N:
+-        other_N = N - M
+-        other_density = (density * N**2 - M**2) / other_N**2
+-        other_blocks = _get_block_sizes(other_N, other_density, generator)
+-
+-    return [M] + other_blocks
+-
+-
+-def _merge_shuffle_blocks(blocks, generator):
+-    """
+-    For a list of block, merge them in one matrix along the diagonal and
+-    shuffle the rows and columns.
+-    """
+-    N = sum(block.shape[0] for block in blocks)
+-    D = sum(block.shape[0]**2 for block in blocks) / N**2
+-    idx = generator.permutation(N)
+-    end = 0
+-    if D < 0.1:
+-        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
+-        row = []
+-        col = []
+-        data = []
+-        for block in blocks:
+-            start = end
+-            end = end + block.shape[0]
+-            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
+-            row.append(brow.ravel())
+-            col.append(bcol.ravel())
+-            data.append(block.ravel())
+-        data = np.hstack(data)
+-        row = np.hstack(row)
+-        col = np.hstack(col)
+-        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
+-    else:
+-        matrix = np.zeros((N,N), dtype=complex)
+-        for block in blocks:
+-            start = end
+-            end = end + block.shape[0]
+-            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
+-            matrix[brow, bcol] = block
+-    return _data.create(matrix, copy=False)
+-
+-
+-def rand_herm(dimensions, density=0.30, distribution="fill", *,
+-              eigenvalues=(), seed=None, dtype=None):
+-    """Creates a random sparse Hermitian quantum object.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    density : float, [0.30]
+-        Density between [0,1] of output Hermitian operator.
+-
+-    distribution : str {"fill", "pos_def", "eigen"}
+-        Method used to obtain the density matrices.
+-
+-        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
+-          generated quantum operator with elements uniformly distributed
+-          between ``[-1, 1] + [-1j, 1j]``.
+-        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
+-          random complex Jacobi rotations to shuffle the operator.
+-        - "pos_def" : Return a positive semi-definite matrix by diagonal
+-          dominance.
+-
+-    eigenvalues : array_like, optional
+-        Eigenvalues of the output Hermitian matrix. The len must match the
+-        shape of the matrix.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : :class:`qobj`
+-        Hermitian quantum operator.
+-
+-    Notes
+-    -----
+-    If given a list of eigenvalues the object is created using complex Jacobi
+-    rotations.  While this method is fast for small matrices, it should not be
+-    repeatedly used for generating matrices larger than ~1000x1000.
+-    """
+-    N, dims = _implicit_tensor_dimensions(dimensions)
+-    generator = _get_generator(seed)
+-    if distribution not in ["eigen", "fill", "pos_def"]:
+-        raise ValueError("distribution must be one of {'eigen', 'fill', "
+-                         "'pos_def'}")
+-
+-    if distribution == "eigen":
+-        if N != len(eigenvalues):
+-            raise ValueError("The number of eigenvalues does not match the "
+-                             "desired shape.")
+-        out = _data.diag[_data.CSR](eigenvalues, 0)
+-        nvals = max([N**2 * density, 1])
+-        out = _rand_jacobi_rotation(out, generator)
+-        while _data.csr.nnz(out) < 0.95 * nvals:
+-            out = _rand_jacobi_rotation(out, generator)
+-        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
+-        dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-
+-    else:
+-        pos_def = distribution == "pos_def"
+-        if density < 0.5:
+-            M = _rand_herm_sparse(N, density, pos_def, generator)
+-            dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-        else:
+-            M = _rand_herm_dense(N, density, pos_def, generator)
+-            dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-
+-        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
+-
+-    return out.to(dtype)
+-
+-
+-def _rand_herm_sparse(N, density, pos_def, generator):
+-    target = (1 - (1 - density)**0.5)
+-    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
+-    num_elems = max([num_elems, 1])
+-    num_elems = int(num_elems)
+-    data = (2 * generator.random(num_elems) - 1) + \
+-           (2 * generator.random(num_elems) - 1) * 1j
+-    row_idx, col_idx = zip(*[
+-        divmod(index, N)
+-        for index in generator.choice(N*N, num_elems, replace=False)
+-    ])
+-    M = sp.coo_matrix((data, (row_idx, col_idx)),
+-                      dtype=complex, shape=(N, N))
+-    M = 0.5 * (M + M.conj().transpose())
+-    M.sort_indices()
+-    rand_mat = _data.create(M)
+-    if pos_def:
+-        rand_mat = _data.add(
+-            rand_mat,
+-            _data.diag(np.ones(N, dtype=complex)),
+-            np.sqrt(2) * N + 1
+-        )
+-    return rand_mat
+-
+-
+-def _rand_herm_dense(N, density, pos_def, generator):
+-    M = (
+-        (2*generator.random((N, N)) - 1)
+-        + 1j*(2*generator.random((N, N)) - 1)
+-    )
+-    M = 0.5 * (M + M.conj().transpose())
+-    target = 1 - density**0.5
+-    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
+-    num_remove = max([num_remove, 1])
+-    num_remove = int(num_remove)
+-    for index in generator.choice(N*N, num_remove, replace=False):
+-        row, col = divmod(index, N)
+-        M[col, row] = 0
+-        M[row, col] = 0
+-    if pos_def:
+-        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
+-    return _data.create(M)
+-
+-
+-def rand_unitary(dimensions, density=1, distribution="haar", *,
+-                 seed=None, dtype=None):
+-    r"""Creates a random sparse unitary quantum object.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    density : float, [1]
+-        Density between [0,1] of output unitary operator.
+-
+-    distribution : ["haar", "exp"]
+-        Method used to obtain the unitary matrices.
+-
+-        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
+-        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
+-          Hermitian operator.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Unitary quantum operator.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    N, dims = _implicit_tensor_dimensions(dimensions)
+-    if distribution not in ["haar", "exp"]:
+-        raise ValueError("distribution must be one of {'haar', 'exp'}")
+-    generator = _get_generator(seed)
+-    block_sizes = _get_block_sizes(N, density, generator)
+-
+-    blocks = []
+-    for block in block_sizes:
+-        if distribution == "haar":
+-            mat = _rand_unitary_haar(block, generator)
+-        elif distribution == "exp":
+-            mat = scipy.linalg.expm(
+-                -1.0j *
+-                _rand_herm_dense(block, 1, False, generator).as_ndarray()
+-            )
+-        blocks.append(mat)
+-
+-    merged = _merge_shuffle_blocks(blocks, generator)
+-
+-    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
+-    return mat.to(dtype)
+-
+-
+-def _rand_unitary_haar(N, generator):
+-    """
+-    Returns a Haar random unitary matrix of dimension
+-    ``dim``, using the algorithm of [Mez07]_.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Dimension of the unitary to be returned.
+-
+-    generator : numpy.random.generator
+-        Random number generator.
+-
+-    Returns
+-    -------
+-    U : qutip.core.data.Dense
+-        Unitary of shape ``(N, N)`` drawn from the Haar measure.
+-    """
+-    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
+-    #               normal random variates.
+-    Z = _randnz((N, N), generator)
+-
+-    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
+-    Q, R = scipy.linalg.qr(Z)
+-
+-    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
+-    #               the diagonal elements of R.
+-    Lambda = np.diag(R).copy()
+-    Lambda /= np.abs(Lambda)
+-
+-    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
+-    #               strictly positive elements, such that
+-    #               Q' = Q · Λ is Haar distributed.
+-    # NOTE: Λ is a diagonal matrix, represented as a vector
+-    #       of the diagonal entries. Thus, the matrix dot product
+-    #       is represented nicely by the NumPy broadcasting of
+-    #       the *scalar* multiplication. In particular,
+-    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
+-    #       As NumPy arrays, Q has shape (N, N) and
+-    #       Lambda has shape (N, ), such that the broadcasting
+-    #       represents precisely Q_ij λ_j.
+-    return Q * Lambda
+-
+-
+-def rand_ket(dimensions, density=1, distribution="haar", *,
+-             seed=None, dtype=None):
+-    """Creates a random ket vector.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    density : float, [1]
+-        Density between [0,1] of output ket state when using the ``fill``
+-        method.
+-
+-    distribution : str {"haar", "fill"}
+-        Method used to obtain the kets.
+-
+-        - haar : Haar random pure state obtained by applying a Haar random
+-          unitary to a fixed pure state.
+-        - fill : Fill the ket with uniformly distributed random complex number.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Ket quantum state vector.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    generator = _get_generator(seed)
+-    N, dims = _implicit_tensor_dimensions(dimensions)
+-    if distribution not in ["haar", "fill"]:
+-        raise ValueError("distribution must be one of {'haar', 'fill'}")
+-
+-    if distribution == "haar":
+-        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
+-    else:
+-        X = scipy.sparse.rand(N, 1, density, format='csr',
+-                              random_state=generator)
+-        while X.nnz == 0:
+-            # ensure that the ket is not all zeros.
+-            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
+-                                  random_state=generator)
+-        X.data = X.data - 0.5
+-        Y = X.copy()
+-        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
+-        X = _data.csr.CSR(X + Y)
+-        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
+-                   copy=False, type="ket", isherm=False, isunitary=False)
+-    ket.dims = [dims[0], [1]]
+-    return ket.to(dtype)
+-
+-
+-def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
+-            eigenvalues=(), rank=None, seed=None,
+-            dtype=None):
+-    r"""Creates a random density matrix of the desired dimensions.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either ``oper`` or
+-        ``super`` depending on the passed ``dimensions``.
+-
+-    density : float
+-        Density between [0,1] of output density matrix. Used by the "pure",
+-        "eigen" and "herm".
+-
+-    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
+-        Method used to obtain the density matrices.
+-
+-        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
+-          the algorithm of [BCSZ08]_.
+-        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
+-          operator.
+-        - "pure" : Density matrix created from a random ket.
+-        - "eigen" : A density matrix with the given ``eigenvalues``.
+-        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
+-
+-    eigenvalues : array_like, optional
+-        Eigenvalues of the output Hermitian matrix. The len must match the
+-        shape of the matrix.
+-
+-    rank : int, optional
+-        When using the "ginibre" distribution, rank of the density matrix.
+-        Will default to a full rank operator when not provided.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Density matrix quantum operator.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    generator = _get_generator(seed)
+-    N, dims = _implicit_tensor_dimensions(dimensions)
+-    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
+-    if distribution not in distributions:
+-        raise ValueError(f"distribution must be one of {distributions}")
+-
+-    if distribution == "eigen":
+-        if len(eigenvalues) != N:
+-            raise ValueError("Number of eigenvalues does not match the shape.")
+-        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
+-            raise ValueError('Eigenvalues of a density matrix '
+-                             f'must sum to one, not {np.sum(eigenvalues)}')
+-        H = _data.diag(eigenvalues, 0)
+-        nvals = N**2 * density
+-        H = _rand_jacobi_rotation(H, generator)
+-        while _data.csr.nnz(H) < 0.95*nvals:
+-            H = _rand_jacobi_rotation(H, generator)
+-    elif distribution == "ginibre":
+-        H = _rand_dm_ginibre(N, rank, generator)
+-    elif distribution == "hs":
+-        H = _rand_dm_ginibre(N, N, generator)
+-    elif distribution == "pure":
+-        dm_density = np.sqrt(density)
+-        psi = rand_ket(N, density=dm_density,
+-                       distribution="fill", seed=generator)
+-        H = psi.proj().data
+-    elif distribution == "herm":
+-        block_sizes = _get_block_sizes(N, density, generator)
+-        blocks = []
+-        first = True
+-        for block in block_sizes:
+-            if block != 1:
+-                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
+-            else:
+-                mat = np.ones((1,1))
+-                if not first:
+-                    mat *= max(generator.random() - 0.5, 0)
+-                first = False
+-            blocks.append(mat.T.conj() @ mat)
+-        H = _merge_shuffle_blocks(blocks, generator)
+-        H /= H.trace()
+-
+-    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
+-
+-
+-def _rand_dm_ginibre(N, rank, generator):
+-    """
+-    Returns a Ginibre random density operator of  rank ``rank`` by using the
+-    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
+-    (Hilbert-Schmidt ensemble) random density operator will be
+-    returned.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Dimension of the density operator to be returned.
+-
+-    rank : int or None
+-        Rank of the sampled density operator. If None, a full-rank
+-        density operator is generated.
+-
+-    Returns
+-    -------
+-    rho : Qobj
+-        An N × N density operator sampled from the Ginibre
+-        or Hilbert-Schmidt distribution.
+-    """
+-    if not rank:
+-        rank = N
+-    if rank > N:
+-        raise ValueError("Rank cannot exceed dimension.")
+-
+-    X = _randnz((N, rank), generator, norm='ginibre')
+-    rho = np.dot(X, X.T.conj())
+-    rho /= np.trace(rho)
+-
+-    return rho
+-
+-
+-def rand_kraus_map(dimensions, *, seed=None,
+-                   dtype=None):
+-    """
+-    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
+-    form.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper_list : list of qobj
+-        N^2 x N x N qobj operators.
+-
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    N, dims = _implicit_tensor_dimensions(dimensions)
+-
+-    # Random unitary (Stinespring Dilation)
+-    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
+-    orthog_cols = np.array(big_unitary[:, :N])
+-    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
+-    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
+-            for x in oper_list]
+-
+-
+-def rand_super(dimensions, *, superrep="super", seed=None,
+-               dtype=None):
+-    """
+-    Returns a randomly drawn superoperator acting on operators acting on
+-    N dimensions.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    superrop : str, optional, {"super"}
+-        Representation of the super operator
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    generator = _get_generator(seed)
+-    from .solver.propagator import propagator
+-    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
+-    H = rand_herm(N, seed=generator, dtype=dtype)
+-    S = propagator(H, generator.random(), [
+-        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
+-    ])
+-    S.dims = dims
+-    out = {
+-            "choi" : to_choi,
+-            "chi" : to_chi,
+-            "super": to_super,
+-        }[superrep](S).to(dtype)
+-    return out
+-
+-
+-def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
+-                    superrep="super", seed=None,
+-                    dtype=None):
+-    """
+-    Returns a random superoperator drawn from the Bruzda
+-    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
+-    finite numerical precision, for ranks less than full-rank,
+-    zero eigenvalues may become slightly negative, such that the
+-    returned operator is not actually completely positive.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If an int is provided, it is understood as
+-        the Square root of the dimension of the superoperator to be returned,
+-        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
+-        as a list of ints, then the dimensions is understood as the space of
+-        density matrices this superoperator is applied to: ``dimensions=[2,2]``
+-        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
+-
+-    enforce_tp : bool
+-        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
+-        otherwise only complete positivity is enforced.
+-
+-    rank : int or None
+-        Rank of the sampled superoperator. If None, a full-rank
+-        superoperator is generated.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    superrop : str, optional, {"super"}
+-        representation of the
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    rho : Qobj
+-        A superoperator acting on vectorized dim × dim density operators,
+-        sampled from the BCSZ distribution.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+-    generator = _get_generator(seed)
+-    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
+-
+-    if rank is None:
+-        rank = N**2
+-    if rank > N**2:
+-        raise ValueError("Rank cannot exceed superoperator dimension.")
+-
+-    # We use mainly dense matrices here for speed in low
+-    # dimensions. In the future, it would likely be better to switch off
+-    # between sparse and dense matrices as the dimension grows.
+-
+-    # We start with a Ginibre uniform matrix X of the appropriate rank,
+-    # and use it to construct a positive semidefinite matrix X X⁺.
+-    X = _randnz((N**2, rank), generator, norm='ginibre')
+-
+-    # Precompute X X⁺, as we'll need it in two different places.
+-    XXdag = np.dot(X, X.T.conj())
+-    tmp_dims = [[[N], [N]], [[N], [N]]]
+-
+-    if enforce_tp:
+-        # We do the partial trace over the first index by using dense reshape
+-        # operations, so that we can avoid bouncing to a sparse representation
+-        # and back.
+-        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
+-
+-        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
+-        # the square root and the inverse separately. As a possible
+-        # improvement, iterative methods exist to find inverse square root
+-        # matrices directly, as this is important in statistics.
+-        Z = np.kron(
+-            np.eye(N),
+-            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
+-        )
+-
+-        # Finally, we dot everything together and pack it into a Qobj,
+-        # marking the dimensions as that of a type=super (that is,
+-        # with left and right compound indices, each representing
+-        # left and right indices on the underlying Hilbert space).
+-        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
+-    else:
+-        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
+-
+-    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
+-    # expects a column-stacking Choi matrix, we must permute the indices.
+-    D = D.permute([[1], [0]])
+-
+-    # Mark that we've made a Choi matrix.
+-    D.superrep = 'choi'
+-    D.dims = dims
+-    out = {
+-            "choi" : to_choi,
+-            "chi" : to_chi,
+-            "super": to_super,
+-        }[superrep](D).to(dtype)
+-    return out
+-
+-
+-def rand_stochastic(dimensions, density=0.75, kind='left',
+-                    *, seed=None, dtype=None):
+-    """Generates a random stochastic matrix.
+-
+-    Parameters
+-    ----------
+-    dimensions : (int) or (list of int) or (list of list of int)
+-        Dimension of Hilbert space. If provided as a list of ints, then the
+-        dimension is the product over this list, but the ``dims`` property of
+-        the new Qobj are set to this list.  This can produce either `oper` or
+-        `super` depending on the passed `dimensions`.
+-
+-    density : float, [0.75]
+-        Density between [0,1] of output density matrix.
+-
+-    kind : str (Default = 'left')
+-        Generate 'left' or 'right' stochastic matrix.
+-
+-    seed : int, SeedSequence, Generator, optional
+-        Seed to create the random number generator or a pre prepared
+-        generator. When none is suplied, a default generator is used.
+-
+-    dtype : type or str
+-        Storage representation. Any data-layer known to `qutip.data.to` is
+-        accepted.
+-
+-    Returns
+-    -------
+-    oper : qobj
+-        Quantum operator form of stochastic matrix.
+-    """
+-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+-    generator = _get_generator(seed)
+-    N, dims = _implicit_tensor_dimensions(dimensions)
+-    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
+-    data = generator.random(num_elems)
+-    # Ensure an element on every row and column
+-    row_idx = np.hstack([generator.permutation(N),
+-                         generator.choice(N, num_elems-N)])
+-    col_idx = np.hstack([generator.permutation(N),
+-                         generator.choice(N, num_elems-N)])
+-    M = sp.coo_matrix((data, (row_idx, col_idx)),
+-                      dtype=np.complex128, shape=(N, N)).tocsr()
+-    M = 0.5 * (M + M.conj().transpose())
+-    num_rows = M.indptr.shape[0] - 1
+-    for row in range(num_rows):
+-        row_start = M.indptr[row]
+-        row_end = M.indptr[row+1]
+-        row_sum = np.sum(M.data[row_start:row_end])
+-        M.data[row_start:row_end] /= row_sum
+-    if kind == 'left':
+-        M = M.transpose()
+-    return Qobj(M, dims=dims).to(dtype)
++"""
++This module is a collection of random state and operator generators.
++"""
++
++__all__ = [
++    'rand_herm',
++    'rand_unitary',
++    'rand_dm',
++    'rand_stochastic',
++    'rand_ket',
++    'rand_kraus_map',
++    'rand_super',
++    "rand_super_bcsz",
++]
++
++import numbers
++
++import numpy as np
++from numpy.random import Generator, SeedSequence, default_rng
++import scipy.linalg
++import scipy.sparse as sp
++
++from . import (Qobj, create, destroy, jmat, basis,
++               to_super, to_choi, to_chi, to_kraus, to_stinespring)
++from .core import data as _data
++from .core.dimensions import flatten
++from . import settings
++
++
++_RAND = default_rng()
++_UNITS = np.array([1, 1j])
++
++
++def _implicit_tensor_dimensions(dimensions, superoper=False):
++    """
++    Total flattened size and operator dimensions for operator creation routines
++    that automatically perform tensor products.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        First dimension of an operator which can create an implicit tensor
++        product.  If the type is `int`, it is promoted first to `[dimensions]`.
++        From there, it should be one of the two-elements `dims` parameter of a
++        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
++        products.
++
++    Returns
++    -------
++    size : int
++        Dimension of backing matrix required to represent operator.
++    dimensions : list
++        Dimension list in the form required by ``Qobj`` creation.
++    """
++    if not isinstance(dimensions, list):
++        dimensions = [dimensions]
++    flat = flatten(dimensions)
++    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
++        raise ValueError("All dimensions must be integers >= 0")
++    N = np.prod(flat)
++    if superoper:
++        if isinstance(dimensions[0], numbers.Integral):
++            dimensions = [dimensions, dimensions]
++        else:
++            N = int(N**0.5)
++    return N, [dimensions, dimensions]
++
++
++def _get_generator(seed):
++    """
++    Obtain a random generator from a seed or generator.
++
++    Parameters
++    ----------
++    seed: int, SeedSequence, Generator, NoneType
++        Seed to create the generator. If it's already a generator return it.
++        When ``None`` is suplied, a default generator is provided.
++    """
++    if seed is None:
++        gen = _RAND
++    elif isinstance(seed, Generator):
++        gen = seed
++    else:
++        gen = default_rng(seed)
++    return gen
++
++
++def _randnz(shape, generator, norm=np.sqrt(0.5)):
++    """
++    Returns an array of standard normal complex random variates.
++    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
++
++    Parameters
++    ----------
++    shape : tuple
++        Shape of the returned array of random variates.
++
++    generator : Generator
++        Random number generator.
++
++    norm : float
++        Scale of the returned random variates, or 'ginibre' to draw
++        from the Ginibre ensemble.
++    """
++    # This function is intended for internal use.
++    if norm == 'ginibre':
++        norm = 1
++    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
++
++
++def _rand_jacobi_rotation(A, generator):
++    """Random Jacobi rotation of a matrix.
++
++    Parameters
++    ----------
++    A : qutip.data.Data
++        Matrix to rotate as a data layer object.
++
++    generator : numpy.random.generator
++        Random number generator.
++
++    Returns
++    -------
++    qutip.data.Data
++        Rotated sparse matrix.
++    """
++    if A.shape[0] != A.shape[1]:
++        raise ValueError('Input matrix must be square.')
++    n = A.shape[0]
++    angle = 2 * generator.random() * np.pi
++    a = np.sqrt(0.5) * np.exp(-1j * angle)
++    b = np.conj(a)
++    i = generator.integers(n)
++    j = i
++    while i == j:
++        j = generator.integers(n)
++    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
++                      np.ones(n - 2, dtype=complex)))
++    diag = np.delete(np.arange(n), [i, j])
++    rows = np.hstack(([i, i, j, j], diag))
++    cols = np.hstack(([i, j, i, j], diag))
++    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
++    R = _data.create(R.tocsr())
++    return _data.matmul(_data.matmul(R, A), R.adjoint())
++
++
++def _get_block_sizes(N, density, generator):
++    """
++    Obtain a list of matrix block sizes in such a way that an NxN matrix
++    composed of full matrices of these sizes along the diagonal would be of
++    desired density.
++    """
++    if density <= 0:
++        return [1] * N
++    elif density >= 1:
++        return [N]
++    max_block_size = int((N**2 * density)**0.5)
++    min_block_size = 1
++    if density >= 0.5:
++        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
++
++    if min_block_size >= max_block_size:
++        M = min(min_block_size, max_block_size)
++    else:
++        M = generator.integers(min_block_size, max_block_size) + 1
++    M += generator.integers(-1, 2)
++    M = min(max(M, 1), N)
++
++    other_blocks = []
++    if M < N:
++        other_N = N - M
++        other_density = (density * N**2 - M**2) / other_N**2
++        other_blocks = _get_block_sizes(other_N, other_density, generator)
++
++    return [M] + other_blocks
++
++
++def _merge_shuffle_blocks(blocks, generator):
++    """
++    For a list of block, merge them in one matrix along the diagonal and
++    shuffle the rows and columns.
++    """
++    N = sum(block.shape[0] for block in blocks)
++    D = sum(block.shape[0]**2 for block in blocks) / N**2
++    idx = generator.permutation(N)
++    end = 0
++    if D < 0.1:
++        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
++        row = []
++        col = []
++        data = []
++        for block in blocks:
++            start = end
++            end = end + block.shape[0]
++            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
++            row.append(brow.ravel())
++            col.append(bcol.ravel())
++            data.append(block.ravel())
++        data = np.hstack(data)
++        row = np.hstack(row)
++        col = np.hstack(col)
++        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
++    else:
++        matrix = np.zeros((N,N), dtype=complex)
++        for block in blocks:
++            start = end
++            end = end + block.shape[0]
++            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
++            matrix[brow, bcol] = block
++    return _data.create(matrix, copy=False)
++
++
++def rand_herm(dimensions, density=0.30, distribution="fill", *,
++              eigenvalues=(), seed=None, dtype=None):
++    """Creates a random sparse Hermitian quantum object.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    density : float, [0.30]
++        Density between [0,1] of output Hermitian operator.
++
++    distribution : str {"fill", "pos_def", "eigen"}
++        Method used to obtain the density matrices.
++
++        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
++          generated quantum operator with elements uniformly distributed
++          between ``[-1, 1] + [-1j, 1j]``.
++        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
++          random complex Jacobi rotations to shuffle the operator.
++        - "pos_def" : Return a positive semi-definite matrix by diagonal
++          dominance.
++
++    eigenvalues : array_like, optional
++        Eigenvalues of the output Hermitian matrix. The len must match the
++        shape of the matrix.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : :class:`qobj`
++        Hermitian quantum operator.
++
++    Notes
++    -----
++    If given a list of eigenvalues the object is created using complex Jacobi
++    rotations.  While this method is fast for small matrices, it should not be
++    repeatedly used for generating matrices larger than ~1000x1000.
++    """
++    N, dims = _implicit_tensor_dimensions(dimensions)
++    generator = _get_generator(seed)
++    if distribution not in ["eigen", "fill", "pos_def"]:
++        raise ValueError("distribution must be one of {'eigen', 'fill', "
++                         "'pos_def'}")
++
++    if distribution == "eigen":
++        if N != len(eigenvalues):
++            raise ValueError("The number of eigenvalues does not match the "
++                             "desired shape.")
++        out = _data.diag[_data.CSR](eigenvalues, 0)
++        nvals = max([N**2 * density, 1])
++        out = _rand_jacobi_rotation(out, generator)
++        while _data.csr.nnz(out) < 0.95 * nvals:
++            out = _rand_jacobi_rotation(out, generator)
++        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
++        dtype = dtype or settings.core["default_dtype"] or _data.CSR
++
++    else:
++        pos_def = distribution == "pos_def"
++        if density < 0.5:
++            M = _rand_herm_sparse(N, density, pos_def, generator)
++            dtype = dtype or settings.core["default_dtype"] or _data.CSR
++        else:
++            M = _rand_herm_dense(N, density, pos_def, generator)
++            dtype = dtype or settings.core["default_dtype"] or _data.Dense
++
++        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
++
++    return out.to(dtype)
++
++
++def _rand_herm_sparse(N, density, pos_def, generator):
++    target = (1 - (1 - density)**0.5)
++    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
++    num_elems = max([num_elems, 1])
++    num_elems = int(num_elems)
++    data = (2 * generator.random(num_elems) - 1) + \
++           (2 * generator.random(num_elems) - 1) * 1j
++    row_idx, col_idx = zip(*[
++        divmod(index, N)
++        for index in generator.choice(N*N, num_elems, replace=False)
++    ])
++    M = sp.coo_matrix((data, (row_idx, col_idx)),
++                      dtype=complex, shape=(N, N))
++    M = 0.5 * (M + M.conj().transpose())
++    M.sort_indices()
++    rand_mat = _data.create(M)
++    if pos_def:
++        rand_mat = _data.add(
++            rand_mat,
++            _data.diag(np.ones(N, dtype=complex)),
++            np.sqrt(2) * N + 1
++        )
++    return rand_mat
++
++
++def _rand_herm_dense(N, density, pos_def, generator):
++    M = (
++        (2*generator.random((N, N)) - 1)
++        + 1j*(2*generator.random((N, N)) - 1)
++    )
++    M = 0.5 * (M + M.conj().transpose())
++    target = 1 - density**0.5
++    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
++    num_remove = max([num_remove, 1])
++    num_remove = int(num_remove)
++    for index in generator.choice(N*N, num_remove, replace=False):
++        row, col = divmod(index, N)
++        M[col, row] = 0
++        M[row, col] = 0
++    if pos_def:
++        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
++    return _data.create(M)
++
++
++def rand_unitary(dimensions, density=1, distribution="haar", *,
++                 seed=None, dtype=None):
++    r"""Creates a random sparse unitary quantum object.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    density : float, [1]
++        Density between [0,1] of output unitary operator.
++
++    distribution : ["haar", "exp"]
++        Method used to obtain the unitary matrices.
++
++        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
++        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
++          Hermitian operator.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Unitary quantum operator.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    N, dims = _implicit_tensor_dimensions(dimensions)
++    if distribution not in ["haar", "exp"]:
++        raise ValueError("distribution must be one of {'haar', 'exp'}")
++    generator = _get_generator(seed)
++    block_sizes = _get_block_sizes(N, density, generator)
++
++    blocks = []
++    for block in block_sizes:
++        if distribution == "haar":
++            mat = _rand_unitary_haar(block, generator)
++        elif distribution == "exp":
++            mat = scipy.linalg.expm(
++                -1.0j *
++                _rand_herm_dense(block, 1, False, generator).as_ndarray()
++            )
++        blocks.append(mat)
++
++    merged = _merge_shuffle_blocks(blocks, generator)
++
++    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
++    return mat.to(dtype)
++
++
++def _rand_unitary_haar(N, generator):
++    """
++    Returns a Haar random unitary matrix of dimension
++    ``dim``, using the algorithm of [Mez07]_.
++
++    Parameters
++    ----------
++    N : int
++        Dimension of the unitary to be returned.
++
++    generator : numpy.random.generator
++        Random number generator.
++
++    Returns
++    -------
++    U : qutip.core.data.Dense
++        Unitary of shape ``(N, N)`` drawn from the Haar measure.
++    """
++    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
++    #               normal random variates.
++    Z = _randnz((N, N), generator)
++
++    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
++    Q, R = scipy.linalg.qr(Z)
++
++    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
++    #               the diagonal elements of R.
++    Lambda = np.diag(R).copy()
++    Lambda /= np.abs(Lambda)
++
++    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
++    #               strictly positive elements, such that
++    #               Q' = Q · Λ is Haar distributed.
++    # NOTE: Λ is a diagonal matrix, represented as a vector
++    #       of the diagonal entries. Thus, the matrix dot product
++    #       is represented nicely by the NumPy broadcasting of
++    #       the *scalar* multiplication. In particular,
++    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
++    #       As NumPy arrays, Q has shape (N, N) and
++    #       Lambda has shape (N, ), such that the broadcasting
++    #       represents precisely Q_ij λ_j.
++    return Q * Lambda
++
++
++def rand_ket(dimensions, density=1, distribution="haar", *,
++             seed=None, dtype=None):
++    """Creates a random ket vector.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    density : float, [1]
++        Density between [0,1] of output ket state when using the ``fill``
++        method.
++
++    distribution : str {"haar", "fill"}
++        Method used to obtain the kets.
++
++        - haar : Haar random pure state obtained by applying a Haar random
++          unitary to a fixed pure state.
++        - fill : Fill the ket with uniformly distributed random complex number.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Ket quantum state vector.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    generator = _get_generator(seed)
++    N, dims = _implicit_tensor_dimensions(dimensions)
++    if distribution not in ["haar", "fill"]:
++        raise ValueError("distribution must be one of {'haar', 'fill'}")
++
++    if distribution == "haar":
++        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
++    else:
++        X = scipy.sparse.rand(N, 1, density, format='csr',
++                              random_state=generator)
++        while X.nnz == 0:
++            # ensure that the ket is not all zeros.
++            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
++                                  random_state=generator)
++        X.data = X.data - 0.5
++        Y = X.copy()
++        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
++        X = _data.csr.CSR(X + Y)
++        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
++                   copy=False, type="ket", isherm=False, isunitary=False)
++    ket.dims = [dims[0], [1]]
++    return ket.to(dtype)
++
++
++def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
++            eigenvalues=(), rank=None, seed=None,
++            dtype=None):
++    r"""Creates a random density matrix of the desired dimensions.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either ``oper`` or
++        ``super`` depending on the passed ``dimensions``.
++
++    density : float
++        Density between [0,1] of output density matrix. Used by the "pure",
++        "eigen" and "herm".
++
++    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
++        Method used to obtain the density matrices.
++
++        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
++          the algorithm of [BCSZ08]_.
++        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
++          operator.
++        - "pure" : Density matrix created from a random ket.
++        - "eigen" : A density matrix with the given ``eigenvalues``.
++        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
++
++    eigenvalues : array_like, optional
++        Eigenvalues of the output Hermitian matrix. The len must match the
++        shape of the matrix.
++
++    rank : int, optional
++        When using the "ginibre" distribution, rank of the density matrix.
++        Will default to a full rank operator when not provided.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Density matrix quantum operator.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    generator = _get_generator(seed)
++    N, dims = _implicit_tensor_dimensions(dimensions)
++    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
++    if distribution not in distributions:
++        raise ValueError(f"distribution must be one of {distributions}")
++
++    if distribution == "eigen":
++        if len(eigenvalues) != N:
++            raise ValueError("Number of eigenvalues does not match the shape.")
++        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
++            raise ValueError('Eigenvalues of a density matrix '
++                             f'must sum to one, not {np.sum(eigenvalues)}')
++        H = _data.diag(eigenvalues, 0)
++        nvals = N**2 * density
++        H = _rand_jacobi_rotation(H, generator)
++        while _data.csr.nnz(H) < 0.95*nvals:
++            H = _rand_jacobi_rotation(H, generator)
++    elif distribution == "ginibre":
++        H = _rand_dm_ginibre(N, rank, generator)
++    elif distribution == "hs":
++        H = _rand_dm_ginibre(N, N, generator)
++    elif distribution == "pure":
++        dm_density = np.sqrt(density)
++        psi = rand_ket(N, density=dm_density,
++                       distribution="fill", seed=generator)
++        H = psi.proj().data
++    elif distribution == "herm":
++        block_sizes = _get_block_sizes(N, density, generator)
++        blocks = []
++        first = True
++        for block in block_sizes:
++            if block != 1:
++                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
++            else:
++                mat = np.ones((1,1))
++                if not first:
++                    mat *= max(generator.random() - 0.5, 0)
++                first = False
++            blocks.append(mat.T.conj() @ mat)
++        H = _merge_shuffle_blocks(blocks, generator)
++        H /= H.trace()
++
++    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
++
++
++def _rand_dm_ginibre(N, rank, generator):
++    """
++    Returns a Ginibre random density operator of  rank ``rank`` by using the
++    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
++    (Hilbert-Schmidt ensemble) random density operator will be
++    returned.
++
++    Parameters
++    ----------
++    N : int
++        Dimension of the density operator to be returned.
++
++    rank : int or None
++        Rank of the sampled density operator. If None, a full-rank
++        density operator is generated.
++
++    Returns
++    -------
++    rho : Qobj
++        An N × N density operator sampled from the Ginibre
++        or Hilbert-Schmidt distribution.
++    """
++    if not rank:
++        rank = N
++    if rank > N:
++        raise ValueError("Rank cannot exceed dimension.")
++
++    X = _randnz((N, rank), generator, norm='ginibre')
++    rho = np.dot(X, X.T.conj())
++    rho /= np.trace(rho)
++
++    return rho
++
++
++def rand_kraus_map(dimensions, *, seed=None,
++                   dtype=None):
++    """
++    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
++    form.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper_list : list of qobj
++        N^2 x N x N qobj operators.
++
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    N, dims = _implicit_tensor_dimensions(dimensions)
++
++    # Random unitary (Stinespring Dilation)
++    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
++    orthog_cols = np.array(big_unitary[:, :N])
++    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
++    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
++            for x in oper_list]
++
++
++def rand_super(dimensions, *, superrep="super", seed=None,
++               dtype=None):
++    """
++    Returns a randomly drawn superoperator acting on operators acting on
++    N dimensions.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    superrop : str, optional, {"super"}
++        Representation of the super operator
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    generator = _get_generator(seed)
++    from .solver.propagator import propagator
++    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
++    H = rand_herm(N, seed=generator, dtype=dtype)
++    S = propagator(H, generator.random(), [
++        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
++    ])
++    S.dims = dims
++    out = {
++            "choi" : to_choi,
++            "chi" : to_chi,
++            "super": to_super,
++        }[superrep](S).to(dtype)
++    return out
++
++
++def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
++                    superrep="super", seed=None,
++                    dtype=None):
++    """
++    Returns a random superoperator drawn from the Bruzda
++    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
++    finite numerical precision, for ranks less than full-rank,
++    zero eigenvalues may become slightly negative, such that the
++    returned operator is not actually completely positive.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If an int is provided, it is understood as
++        the Square root of the dimension of the superoperator to be returned,
++        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
++        as a list of ints, then the dimensions is understood as the space of
++        density matrices this superoperator is applied to: ``dimensions=[2,2]``
++        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
++
++    enforce_tp : bool
++        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
++        otherwise only complete positivity is enforced.
++
++    rank : int or None
++        Rank of the sampled superoperator. If None, a full-rank
++        superoperator is generated.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    superrop : str, optional, {"super"}
++        representation of the
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    rho : Qobj
++        A superoperator acting on vectorized dim × dim density operators,
++        sampled from the BCSZ distribution.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.CSR
++    generator = _get_generator(seed)
++    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
++
++    if rank is None:
++        rank = N**2
++    if rank > N**2:
++        raise ValueError("Rank cannot exceed superoperator dimension.")
++
++    # We use mainly dense matrices here for speed in low
++    # dimensions. In the future, it would likely be better to switch off
++    # between sparse and dense matrices as the dimension grows.
++
++    # We start with a Ginibre uniform matrix X of the appropriate rank,
++    # and use it to construct a positive semidefinite matrix X X⁺.
++    X = _randnz((N**2, rank), generator, norm='ginibre')
++
++    # Precompute X X⁺, as we'll need it in two different places.
++    XXdag = np.dot(X, X.T.conj())
++    tmp_dims = [[[N], [N]], [[N], [N]]]
++
++    if enforce_tp:
++        # We do the partial trace over the first index by using dense reshape
++        # operations, so that we can avoid bouncing to a sparse representation
++        # and back.
++        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
++
++        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
++        # the square root and the inverse separately. As a possible
++        # improvement, iterative methods exist to find inverse square root
++        # matrices directly, as this is important in statistics.
++        Z = np.kron(
++            np.eye(N),
++            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
++        )
++
++        # Finally, we dot everything together and pack it into a Qobj,
++        # marking the dimensions as that of a type=super (that is,
++        # with left and right compound indices, each representing
++        # left and right indices on the underlying Hilbert space).
++        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
++    else:
++        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
++
++    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
++    # expects a column-stacking Choi matrix, we must permute the indices.
++    D = D.permute([[1], [0]])
++
++    # Mark that we've made a Choi matrix.
++    D.superrep = 'choi'
++    D.dims = dims
++    out = {
++            "choi" : to_choi,
++            "chi" : to_chi,
++            "super": to_super,
++        }[superrep](D).to(dtype)
++    return out
++
++
++def rand_stochastic(dimensions, density=0.75, kind='left',
++                    *, seed=None, dtype=None):
++    """Generates a random stochastic matrix.
++
++    Parameters
++    ----------
++    dimensions : (int) or (list of int) or (list of list of int)
++        Dimension of Hilbert space. If provided as a list of ints, then the
++        dimension is the product over this list, but the ``dims`` property of
++        the new Qobj are set to this list.  This can produce either `oper` or
++        `super` depending on the passed `dimensions`.
++
++    density : float, [0.75]
++        Density between [0,1] of output density matrix.
++
++    kind : str (Default = 'left')
++        Generate 'left' or 'right' stochastic matrix.
++
++    seed : int, SeedSequence, Generator, optional
++        Seed to create the random number generator or a pre prepared
++        generator. When none is suplied, a default generator is used.
++
++    dtype : type or str
++        Storage representation. Any data-layer known to `qutip.data.to` is
++        accepted.
++
++    Returns
++    -------
++    oper : qobj
++        Quantum operator form of stochastic matrix.
++    """
++    dtype = dtype or settings.core["default_dtype"] or _data.Dense
++    generator = _get_generator(seed)
++    N, dims = _implicit_tensor_dimensions(dimensions)
++    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
++    data = generator.random(num_elems)
++    # Ensure an element on every row and column
++    row_idx = np.hstack([generator.permutation(N),
++                         generator.choice(N, num_elems-N)])
++    col_idx = np.hstack([generator.permutation(N),
++                         generator.choice(N, num_elems-N)])
++    M = sp.coo_matrix((data, (row_idx, col_idx)),
++                      dtype=np.complex128, shape=(N, N)).tocsr()
++    M = 0.5 * (M + M.conj().transpose())
++    num_rows = M.indptr.shape[0] - 1
++    for row in range(num_rows):
++        row_start = M.indptr[row]
++        row_end = M.indptr[row+1]
++        row_sum = np.sum(M.data[row_start:row_end])
++        M.data[row_start:row_end] /= row_sum
++    if kind == 'left':
++        M = M.transpose()
++    return Qobj(M, dims=dims).to(dtype)
+diff --git a/qutip/settings.py b/qutip/settings.py
+index 29ee053b..ccf30371 100644
+--- a/qutip/settings.py
++++ b/qutip/settings.py
+@@ -1,293 +1,293 @@
+-"""
+-This module contains settings for the QuTiP graphics, multiprocessing, and
+-tidyup functionality, etc.
+-"""
+-import os
+-import sys
+-from ctypes import cdll
+-import platform
+-import numpy as np
+-
+-__all__ = ['settings']
+-
+-
+-def _blas_info():
+-    config = np.__config__
+-    if hasattr(config, 'blas_ilp64_opt_info'):
+-        blas_info = config.blas_ilp64_opt_info
+-    elif hasattr(config, 'blas_opt_info'):
+-        blas_info = config.blas_opt_info
+-    else:
+-        blas_info = {}
+-
+-    def _in_libaries(name):
+-        return any(name in lib for lib in blas_info.get('libraries', []))
+-
+-    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
+-        blas = 'INTEL MKL'
+-    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
+-        blas = 'OPENBLAS'
+-    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
+-        blas = 'Accelerate'
+-    else:
+-        blas = 'Generic'
+-    return blas
+-
+-
+-def available_cpu_count():
+-    """
+-    Get the number of cpus.
+-    It tries to only get the number available to qutip.
+-    """
+-    import os
+-    import multiprocessing
+-    try:
+-        import psutil
+-    except ImportError:
+-        psutil = None
+-    num_cpu = 0
+-
+-    if 'QUTIP_NUM_PROCESSES' in os.environ:
+-        # We consider QUTIP_NUM_PROCESSES=0 as unset.
+-        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
+-
+-    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
+-        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
+-
+-    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
+-        num_cpu = len(os.sched_getaffinity(0))
+-
+-    if (
+-        num_cpu == 0
+-        and psutil is not None
+-        and hasattr(psutil.Process(), "cpu_affinity")
+-    ):
+-        num_cpu = len(psutil.Process().cpu_affinity())
+-
+-    if num_cpu == 0:
+-        try:
+-            num_cpu = multiprocessing.cpu_count()
+-        except NotImplementedError:
+-            pass
+-
+-    return num_cpu or 1
+-
+-
+-def _find_mkl():
+-    """
+-    Finds the MKL runtime library for the Anaconda and Intel Python
+-    distributions.
+-    """
+-    mkl_lib = None
+-    if _blas_info() == 'INTEL MKL':
+-        plat = sys.platform
+-        python_dir = os.path.dirname(sys.executable)
+-        if plat in ['darwin', 'linux2', 'linux']:
+-            python_dir = os.path.dirname(python_dir)
+-
+-        if plat == 'darwin':
+-            lib = '/libmkl_rt.dylib'
+-        elif plat == 'win32':
+-            lib = r'\mkl_rt.dll'
+-        elif plat in ['linux2', 'linux']:
+-            lib = '/libmkl_rt.so'
+-        else:
+-            raise Exception('Unknown platfrom.')
+-
+-        if plat in ['darwin', 'linux2', 'linux']:
+-            lib_dir = '/lib'
+-        else:
+-            lib_dir = r'\Library\bin'
+-        # Try in default Anaconda location first
+-        try:
+-            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
+-        except Exception:
+-            pass
+-
+-        # Look in Intel Python distro location
+-        if mkl_lib is None:
+-            if plat in ['darwin', 'linux2', 'linux']:
+-                lib_dir = '/ext/lib'
+-            else:
+-                lib_dir = r'\ext\lib'
+-            try:
+-                mkl_lib = \
+-                    cdll.LoadLibrary(python_dir + lib_dir + lib)
+-            except Exception:
+-                pass
+-    return mkl_lib
+-
+-
+-class Settings:
+-    """
+-    Qutip's settings and options.
+-    """
+-    def __init__(self):
+-        self._mkl_lib = ""
+-        try:
+-            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
+-        except OSError:
+-            self._tmproot = "."
+-        self.core = None  # set in qutip.core.options
+-        self.compile = None  # set in qutip.core.coefficient
+-        self._debug = False
+-        self._log_handler = "default"
+-        self._colorblind_safe = False
+-
+-    @property
+-    def has_mkl(self):
+-        """ Whether qutip found an mkl installation. """
+-        return self.mkl_lib is not None
+-
+-    @property
+-    def mkl_lib(self):
+-        """ Location of the mkl installation. """
+-        if self._mkl_lib == "":
+-            self._mkl_lib = _find_mkl()
+-        return _find_mkl()
+-
+-    @property
+-    def ipython(self):
+-        """ Whether qutip is running in ipython. """
+-        try:
+-            __IPYTHON__
+-            return True
+-        except NameError:
+-            return False
+-
+-    @property
+-    def eigh_unsafe(self):
+-        """
+-        Whether `eigh` call is reliable.
+-        Some implementation of blas have some issues on some OS.
+-        """
+-        from packaging import version as pac_version
+-        import scipy
+-        is_old_scipy = (
+-            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
+-        )
+-        return (
+-            # macOS OpenBLAS eigh is unstable, see #1288
+-            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
+-            # The combination of scipy<1.5 and MKL causes wrong results when
+-            # calling eigh for big matrices.  See #1495, #1491 and #1498.
+-            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
+-        )
+-
+-    @property
+-    def tmproot(self):
+-        """
+-        Location in which qutip place cython string coefficient folders.
+-        The default is "$HOME/.qutip".
+-        Can be updated.
+-        """
+-        return self._tmproot
+-
+-    @tmproot.setter
+-    def tmproot(self, root):
+-        if not os.path.exists(root):
+-            os.mkdir(root)
+-        self._tmproot = root
+-
+-    @property
+-    def coeffroot(self):
+-        """
+-        Location in which qutip save cython string coefficient files.
+-        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
+-        Can be updated.
+-        """
+-        return self._coeffroot
+-
+-    @coeffroot.setter
+-    def coeffroot(self, root):
+-        if not os.path.exists(root):
+-            os.mkdir(root)
+-        if root not in sys.path:
+-            sys.path.insert(0, root)
+-        self._coeffroot = root
+-
+-    @property
+-    def coeff_write_ok(self):
+-        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
+-        return os.access(self.coeffroot, os.W_OK)
+-
+-    @property
+-    def has_openmp(self):
+-        return False
+-        # We keep this as a reminder for when openmp is restored: see Pull #652
+-        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+-
+-    @property
+-    def idxint_size(self):
+-        """
+-        Integer type used by ``CSR`` data.
+-        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
+-        non-zeros elements.
+-        """
+-        from .core import data
+-        return data.base.idxint_size
+-
+-    @property
+-    def num_cpus(self):
+-        """
+-        Number of cpu detected.
+-        Use the solver options to control the number of cpus used.
+-        """
+-        if 'QUTIP_NUM_PROCESSES' in os.environ:
+-            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
+-        else:
+-            num_cpus = available_cpu_count()
+-            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
+-        return num_cpus
+-
+-    @property
+-    def debug(self):
+-        """
+-        Debug mode for development.
+-        """
+-        return self._debug
+-
+-    @debug.setter
+-    def debug(self, value):
+-        self._debug = value
+-
+-    @property
+-    def log_handler(self):
+-        """
+-        Define whether log handler should be:
+-        - default: switch based on IPython detection
+-        - stream: set up non-propagating StreamHandler
+-        - basic: call basicConfig
+-        - null: leave logging to the user
+-        """
+-        return self._log_handler
+-
+-    @log_handler.setter
+-    def log_handler(self, value):
+-        self._log_handler = value
+-
+-    @property
+-    def colorblind_safe(self):
+-        """
+-        Allow for a colorblind mode that uses different colormaps
+-        and plotting options by default.
+-        """
+-        return self._colorblind_safe
+-
+-    @colorblind_safe.setter
+-    def colorblind_safe(self, value):
+-        self._colorblind_safe = value
+-
+-    def __str__(self):
+-        lines = ["Qutip settings:"]
+-        for attr in self.__dir__():
+-            if not attr.startswith('_') and attr not in ["core", "compile"]:
+-                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+-        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
+-        return '\n'.join(lines)
+-
+-    def __repr__(self):
+-        return self.__str__()
+-
+-
+-settings = Settings()
++"""
++This module contains settings for the QuTiP graphics, multiprocessing, and
++tidyup functionality, etc.
++"""
++import os
++import sys
++from ctypes import cdll
++import platform
++import numpy as np
++
++__all__ = ['settings']
++
++
++def _blas_info():
++    config = np.__config__
++    if hasattr(config, 'blas_ilp64_opt_info'):
++        blas_info = config.blas_ilp64_opt_info
++    elif hasattr(config, 'blas_opt_info'):
++        blas_info = config.blas_opt_info
++    else:
++        blas_info = {}
++
++    def _in_libaries(name):
++        return any(name in lib for lib in blas_info.get('libraries', []))
++
++    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
++        blas = 'INTEL MKL'
++    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
++        blas = 'OPENBLAS'
++    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
++        blas = 'Accelerate'
++    else:
++        blas = 'Generic'
++    return blas
++
++
++def available_cpu_count():
++    """
++    Get the number of cpus.
++    It tries to only get the number available to qutip.
++    """
++    import os
++    import multiprocessing
++    try:
++        import psutil
++    except ImportError:
++        psutil = None
++    num_cpu = 0
++
++    if 'QUTIP_NUM_PROCESSES' in os.environ:
++        # We consider QUTIP_NUM_PROCESSES=0 as unset.
++        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
++
++    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
++        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
++
++    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
++        num_cpu = len(os.sched_getaffinity(0))
++
++    if (
++        num_cpu == 0
++        and psutil is not None
++        and hasattr(psutil.Process(), "cpu_affinity")
++    ):
++        num_cpu = len(psutil.Process().cpu_affinity())
++
++    if num_cpu == 0:
++        try:
++            num_cpu = multiprocessing.cpu_count()
++        except NotImplementedError:
++            pass
++
++    return num_cpu or 1
++
++
++def _find_mkl():
++    """
++    Finds the MKL runtime library for the Anaconda and Intel Python
++    distributions.
++    """
++    mkl_lib = None
++    if _blas_info() == 'INTEL MKL':
++        plat = sys.platform
++        python_dir = os.path.dirname(sys.executable)
++        if plat in ['darwin', 'linux2', 'linux']:
++            python_dir = os.path.dirname(python_dir)
++
++        if plat == 'darwin':
++            lib = '/libmkl_rt.dylib'
++        elif plat == 'win32':
++            lib = r'\mkl_rt.dll'
++        elif plat in ['linux2', 'linux']:
++            lib = '/libmkl_rt.so'
++        else:
++            raise Exception('Unknown platfrom.')
++
++        if plat in ['darwin', 'linux2', 'linux']:
++            lib_dir = '/lib'
++        else:
++            lib_dir = r'\Library\bin'
++        # Try in default Anaconda location first
++        try:
++            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
++        except Exception:
++            pass
++
++        # Look in Intel Python distro location
++        if mkl_lib is None:
++            if plat in ['darwin', 'linux2', 'linux']:
++                lib_dir = '/ext/lib'
++            else:
++                lib_dir = r'\ext\lib'
++            try:
++                mkl_lib = \
++                    cdll.LoadLibrary(python_dir + lib_dir + lib)
++            except Exception:
++                pass
++    return mkl_lib
++
++
++class Settings:
++    """
++    Qutip's settings and options.
++    """
++    def __init__(self):
++        self._mkl_lib = ""
++        try:
++            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
++        except OSError:
++            self._tmproot = "."
++        self.core = None  # set in qutip.core.options
++        self.compile = None  # set in qutip.core.coefficient
++        self._debug = False
++        self._log_handler = "default"
++        self._colorblind_safe = False
++
++    @property
++    def has_mkl(self):
++        """ Whether qutip found an mkl installation. """
++        return self.mkl_lib is not None
++
++    @property
++    def mkl_lib(self):
++        """ Location of the mkl installation. """
++        if self._mkl_lib == "":
++            self._mkl_lib = _find_mkl()
++        return _find_mkl()
++
++    @property
++    def ipython(self):
++        """ Whether qutip is running in ipython. """
++        try:
++            __IPYTHON__
++            return True
++        except NameError:
++            return False
++
++    @property
++    def eigh_unsafe(self):
++        """
++        Whether `eigh` call is reliable.
++        Some implementation of blas have some issues on some OS.
++        """
++        from packaging import version as pac_version
++        import scipy
++        is_old_scipy = (
++            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
++        )
++        return (
++            # macOS OpenBLAS eigh is unstable, see #1288
++            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
++            # The combination of scipy<1.5 and MKL causes wrong results when
++            # calling eigh for big matrices.  See #1495, #1491 and #1498.
++            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
++        )
++
++    @property
++    def tmproot(self):
++        """
++        Location in which qutip place cython string coefficient folders.
++        The default is "$HOME/.qutip".
++        Can be updated.
++        """
++        return self._tmproot
++
++    @tmproot.setter
++    def tmproot(self, root):
++        if not os.path.exists(root):
++            os.mkdir(root)
++        self._tmproot = root
++
++    @property
++    def coeffroot(self):
++        """
++        Location in which qutip save cython string coefficient files.
++        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
++        Can be updated.
++        """
++        return self._coeffroot
++
++    @coeffroot.setter
++    def coeffroot(self, root):
++        if not os.path.exists(root):
++            os.mkdir(root)
++        if root not in sys.path:
++            sys.path.insert(0, root)
++        self._coeffroot = root
++
++    @property
++    def coeff_write_ok(self):
++        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
++        return os.access(self.coeffroot, os.W_OK)
++
++    @property
++    def has_openmp(self):
++        return False
++        # We keep this as a reminder for when openmp is restored: see Pull #652
++        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
++
++    @property
++    def idxint_size(self):
++        """
++        Integer type used by ``CSR`` data.
++        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
++        non-zeros elements.
++        """
++        from .core import data
++        return data.base.idxint_size
++
++    @property
++    def num_cpus(self):
++        """
++        Number of cpu detected.
++        Use the solver options to control the number of cpus used.
++        """
++        if 'QUTIP_NUM_PROCESSES' in os.environ:
++            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
++        else:
++            num_cpus = available_cpu_count()
++            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
++        return num_cpus
++
++    @property
++    def debug(self):
++        """
++        Debug mode for development.
++        """
++        return self._debug
++
++    @debug.setter
++    def debug(self, value):
++        self._debug = value
++
++    @property
++    def log_handler(self):
++        """
++        Define whether log handler should be:
++        - default: switch based on IPython detection
++        - stream: set up non-propagating StreamHandler
++        - basic: call basicConfig
++        - null: leave logging to the user
++        """
++        return self._log_handler
++
++    @log_handler.setter
++    def log_handler(self, value):
++        self._log_handler = value
++
++    @property
++    def colorblind_safe(self):
++        """
++        Allow for a colorblind mode that uses different colormaps
++        and plotting options by default.
++        """
++        return self._colorblind_safe
++
++    @colorblind_safe.setter
++    def colorblind_safe(self, value):
++        self._colorblind_safe = value
++
++    def __str__(self):
++        lines = ["Qutip settings:"]
++        for attr in self.__dir__():
++            if not attr.startswith('_') and attr not in ["core", "compile"]:
++                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
++        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
++        return '\n'.join(lines)
++
++    def __repr__(self):
++        return self.__str__()
++
++
++settings = Settings()
+diff --git a/qutip/simdiag.py b/qutip/simdiag.py
+index 370ade65..a0105eee 100644
+--- a/qutip/simdiag.py
++++ b/qutip/simdiag.py
+@@ -1,120 +1,120 @@
+-__all__ = ['simdiag']
+-
+-import numpy as np
+-import scipy.linalg as la
+-from . import Qobj
+-from .core import data as _data
+-
+-
+-def _degen(tol, vecs, ops, i=0):
+-    """
+-    Private function that finds eigen vals and vecs for degenerate matrices..
+-    """
+-    if len(ops) == i:
+-        return vecs
+-
+-    # New eigenvectors are sometime not orthogonal.
+-    for j in range(1, vecs.shape[1]):
+-        for k in range(j):
+-            dot = vecs[:, j].dot(vecs[:, k].conj())
+-            if np.abs(dot) > tol:
+-                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
+-                              / (1 - np.abs(dot)**2)**0.5)
+-
+-    subspace = vecs.conj().T @ ops[i].full() @ vecs
+-    eigvals, eigvecs = la.eig(subspace)
+-
+-    perm = np.argsort(eigvals)
+-    eigvals = eigvals[perm]
+-
+-    vecs_new = vecs @ eigvecs[:, perm]
+-    for k in range(len(eigvals)):
+-        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
+-
+-    k = 0
+-    while k < len(eigvals):
+-        ttol = max(tol, tol * abs(eigvals[k]))
+-        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
+-        if len(inds) > 1:  # if at least 2 eigvals are degenerate
+-            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
+-        k = inds[-1] + 1
+-    return vecs_new
+-
+-
+-def simdiag(ops, evals: bool = True, *,
+-            tol: float = 1e-14, safe_mode: bool = True):
+-    """Simultaneous diagonalization of commuting Hermitian matrices.
+-
+-    Parameters
+-    ----------
+-    ops : list/array
+-        ``list`` or ``array`` of qobjs representing commuting Hermitian
+-        operators.
+-
+-    evals : bool [True]
+-        Whether to return the eigenvalues for each ops and eigenvectors or just
+-        the eigenvectors.
+-
+-    tol : float [1e-14]
+-        Tolerance for detecting degenerate eigenstates.
+-
+-    safe_mode : bool [True]
+-        Whether to check that all ops are Hermitian and commuting. If set to
+-        ``False`` and operators are not commuting, the eigenvectors returned
+-        will often be eigenvectors of only the first operator.
+-
+-    Returns
+-    --------
+-    eigs : tuple
+-        Tuple of arrays representing eigvecs and eigvals of quantum objects
+-        corresponding to simultaneous eigenvectors and eigenvalues for each
+-        operator.
+-
+-    """
+-    if not ops:
+-        raise ValueError("No input matrices.")
+-    N = ops[0].shape[0]
+-    num_ops = len(ops) if safe_mode else 0
+-    for jj in range(num_ops):
+-        A = ops[jj]
+-        shape = A.shape
+-        if shape[0] != shape[1]:
+-            raise TypeError('Matricies must be square.')
+-        if shape[0] != N:
+-            raise TypeError('All matrices. must be the same shape')
+-        if not A.isherm:
+-            raise TypeError('Matricies must be Hermitian')
+-        for kk in range(jj):
+-            B = ops[kk]
+-            if (A * B - B * A).norm() / (A * B).norm() > tol:
+-                raise TypeError('Matricies must commute.')
+-
+-    # TODO: rewrite using Data object
+-    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
+-    eigvecs = eigvecs.to_array()
+-
+-    k = 0
+-    while k < N:
+-        # find degenerate eigenvalues, get indicies of degenerate eigvals
+-        ttol = max(tol, tol * abs(eigvals[k]))
+-        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
+-        if len(inds) > 1:  # if at least 2 eigvals are degenerate
+-            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
+-        k = inds[-1] + 1
+-
+-    for k in range(N):
+-        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
+-
+-    kets_out = [
+-        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
+-        for j in range(N)
+-    ]
+-    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
+-    if not evals:
+-        return kets_out
+-    else:
+-        for kk in range(len(ops)):
+-            for j in range(N):
+-                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
+-                                                            kets_out[j]).real
+-        return eigvals_out, kets_out
++__all__ = ['simdiag']
++
++import numpy as np
++import scipy.linalg as la
++from . import Qobj
++from .core import data as _data
++
++
++def _degen(tol, vecs, ops, i=0):
++    """
++    Private function that finds eigen vals and vecs for degenerate matrices..
++    """
++    if len(ops) == i:
++        return vecs
++
++    # New eigenvectors are sometime not orthogonal.
++    for j in range(1, vecs.shape[1]):
++        for k in range(j):
++            dot = vecs[:, j].dot(vecs[:, k].conj())
++            if np.abs(dot) > tol:
++                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
++                              / (1 - np.abs(dot)**2)**0.5)
++
++    subspace = vecs.conj().T @ ops[i].full() @ vecs
++    eigvals, eigvecs = la.eig(subspace)
++
++    perm = np.argsort(eigvals)
++    eigvals = eigvals[perm]
++
++    vecs_new = vecs @ eigvecs[:, perm]
++    for k in range(len(eigvals)):
++        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
++
++    k = 0
++    while k < len(eigvals):
++        ttol = max(tol, tol * abs(eigvals[k]))
++        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
++        if len(inds) > 1:  # if at least 2 eigvals are degenerate
++            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
++        k = inds[-1] + 1
++    return vecs_new
++
++
++def simdiag(ops, evals: bool = True, *,
++            tol: float = 1e-14, safe_mode: bool = True):
++    """Simultaneous diagonalization of commuting Hermitian matrices.
++
++    Parameters
++    ----------
++    ops : list/array
++        ``list`` or ``array`` of qobjs representing commuting Hermitian
++        operators.
++
++    evals : bool [True]
++        Whether to return the eigenvalues for each ops and eigenvectors or just
++        the eigenvectors.
++
++    tol : float [1e-14]
++        Tolerance for detecting degenerate eigenstates.
++
++    safe_mode : bool [True]
++        Whether to check that all ops are Hermitian and commuting. If set to
++        ``False`` and operators are not commuting, the eigenvectors returned
++        will often be eigenvectors of only the first operator.
++
++    Returns
++    --------
++    eigs : tuple
++        Tuple of arrays representing eigvecs and eigvals of quantum objects
++        corresponding to simultaneous eigenvectors and eigenvalues for each
++        operator.
++
++    """
++    if not ops:
++        raise ValueError("No input matrices.")
++    N = ops[0].shape[0]
++    num_ops = len(ops) if safe_mode else 0
++    for jj in range(num_ops):
++        A = ops[jj]
++        shape = A.shape
++        if shape[0] != shape[1]:
++            raise TypeError('Matricies must be square.')
++        if shape[0] != N:
++            raise TypeError('All matrices. must be the same shape')
++        if not A.isherm:
++            raise TypeError('Matricies must be Hermitian')
++        for kk in range(jj):
++            B = ops[kk]
++            if (A * B - B * A).norm() / (A * B).norm() > tol:
++                raise TypeError('Matricies must commute.')
++
++    # TODO: rewrite using Data object
++    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
++    eigvecs = eigvecs.to_array()
++
++    k = 0
++    while k < N:
++        # find degenerate eigenvalues, get indicies of degenerate eigvals
++        ttol = max(tol, tol * abs(eigvals[k]))
++        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
++        if len(inds) > 1:  # if at least 2 eigvals are degenerate
++            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
++        k = inds[-1] + 1
++
++    for k in range(N):
++        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
++
++    kets_out = [
++        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
++        for j in range(N)
++    ]
++    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
++    if not evals:
++        return kets_out
++    else:
++        for kk in range(len(ops)):
++            for j in range(N):
++                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
++                                                            kets_out[j]).real
++        return eigvals_out, kets_out
+diff --git a/qutip/solve/_piqs.pyx b/qutip/solve/_piqs.pyx
+index fcb614dc..48362373 100644
+--- a/qutip/solve/_piqs.pyx
++++ b/qutip/solve/_piqs.pyx
+@@ -1,641 +1,641 @@
+-#cython: language_level=3
+-
+-"""
+-Cythonized code for permutationally invariant Lindbladian generation
+-"""
+-import numpy as np
+-
+-from scipy.sparse import csr_matrix, dok_matrix
+-from qutip.core import Qobj
+-
+-cimport numpy as cnp
+-cimport cython
+-
+-
+-def _num_dicke_states(N):
+-    """
+-    Calculate the number of Dicke states.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    nds: int
+-        The number of Dicke states.
+-    """
+-    if (not float(N).is_integer()):
+-        raise ValueError("Number of TLS should be an integer")
+-
+-    if (N < 1):
+-        raise ValueError("Number of TLS should be non-negative")
+-
+-    nds = (N/2 + 1)**2 - (N % 2)/4
+-    return int(nds)
+-
+-def _num_dicke_ladders(N):
+-    """
+-    Calculate the total number of Dicke ladders in the Dicke space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    Nj: int
+-        The number of Dicke ladders.
+-    """
+-    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
+-    return int(Nj)
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cpdef list get_blocks(int N):
+-    """
+-    Calculate the number of cumulative elements at each block boundary.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    blocks: np.ndarray
+-        An array with the number of cumulative elements at the boundary of
+-        each block.
+-    """
+-    cdef int num_blocks = _num_dicke_ladders(N)
+-    cdef list blocks
+-    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
+-    return blocks
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cpdef float j_min(N):
+-    """
+-    Calculate the minimum value of j for given N.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        Number of two-level systems.
+-
+-    Returns
+-    -------
+-    jmin: float
+-        The minimum value of j for odd or even number of two
+-        level systems.
+-    """
+-    if N % 2 == 0:
+-        return 0
+-    else:
+-        return 0.5
+-
+-def j_vals(N):
+-    """
+-    Get the valid values of j for given N.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    jvals: np.ndarray
+-        The j values for given N as a 1D array.
+-    """
+-    j = np.arange(j_min(N), N/2 + 1, 1)
+-    return j
+-
+-def m_vals(j):
+-    """
+-    Get all the possible values of m or m1 for given j.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    mvals: np.ndarray
+-        The m values for given j as a 1D array.
+-    """
+-    return np.arange(-j, j+1, 1)
+-
+-def get_index(N, j, m, m1, blocks):
+-    """
+-    Get the index in the density matrix for this j, m, m1 value.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    j, m, m1: float
+-        The j, m, m1 values.
+-
+-    blocks: np.ndarray
+-        An 1D array with the number of cumulative elements at the boundary of
+-        each block.
+-
+-    Returns
+-    -------
+-    mvals: array
+-        The m values for given j.
+-    """
+-    _k = int(j-m1)
+-    _k_prime = int(j-m)
+-    block_number = int(N/2 - j)
+-    offset = 0
+-    if block_number > 0:
+-        offset = blocks[block_number-1]
+-    i = _k_prime + offset
+-    k = _k + offset
+-    return (i, k)
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cpdef list jmm1_dictionary(int N):
+-    """
+-    Get the index in the density matrix for this j, m, m1 value.
+-
+-    The (j, m, m1) values are mapped to the (i, k) index of a block
+-    diagonal matrix which has the structure to capture the permutationally
+-    symmetric part of the density matrix. For each (j, m, m1) value, first
+-    we get the block by using the "j" value and then the addition in the
+-    row/column due to the m and m1 is determined. Four dictionaries are
+-    returned giving a map from the (j, m, m1) values to (i, k), the inverse
+-    map, a flattened map and the inverse of the flattened map.
+-    """
+-    cdef long i
+-    cdef long k
+-    cdef dict jmm1_dict = {}
+-    cdef dict jmm1_inv = {}
+-    cdef dict jmm1_flat = {}
+-    cdef dict jmm1_flat_inv = {}
+-    cdef int l
+-    cdef int nds = _num_dicke_states(N)
+-    cdef list blocks = get_blocks(N)
+-
+-    jvalues = j_vals(N)
+-    for j in jvalues:
+-        mvalues = m_vals(j)
+-        for m in mvalues:
+-            for m1 in mvalues:
+-                i, k = get_index(N, j, m, m1, blocks)
+-                jmm1_dict[(i, k)] = (j, m, m1)
+-                jmm1_inv[(j, m, m1)] = (i, k)
+-                l = nds * i+k
+-                jmm1_flat[l] = (j, m, m1)
+-                jmm1_flat_inv[(j, m, m1)] = l
+-    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
+-
+-
+-@cython.boundscheck(False)
+-@cython.wraparound(False)
+-cdef class Dicke(object):
+-    """
+-    A faster Cythonized Dicke state class to build the Lindbladian.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-
+-    Attributes
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-    """
+-    cdef int N
+-    cdef float emission, dephasing, pumping
+-    cdef float collective_emission, collective_dephasing, collective_pumping
+-
+-    def __init__(self, int N, float emission=0., float dephasing=0.,
+-                 float pumping=0., float collective_emission=0.,
+-                 collective_dephasing=0., collective_pumping=0.):
+-        self.N = N
+-        self.emission = emission
+-        self.dephasing = dephasing
+-        self.pumping = pumping
+-        self.collective_emission = collective_emission
+-        self.collective_dephasing = collective_dephasing
+-        self.collective_pumping = collective_pumping
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef object lindbladian(self):
+-        """
+-        Build the Lindbladian superoperator of the dissipative dynamics as a
+-        sparse matrix.
+-
+-        Returns
+-        ----------
+-        lindblad_qobj: :class: qutip.Qobj
+-            The matrix size is (nds**2, nds**2) where nds is the number of
+-            Dicke states.
+-        """
+-        N = self.N
+-        cdef int nds = _num_dicke_states(N)
+-        cdef int num_ladders = _num_dicke_ladders(N)
+-
+-        cdef list lindblad_row = []
+-        cdef list lindblad_col = []
+-        cdef list lindblad_data = []
+-        cdef tuple jmm1_1
+-        cdef tuple jmm1_2
+-        cdef tuple jmm1_3
+-        cdef tuple jmm1_4
+-        cdef tuple jmm1_5
+-        cdef tuple jmm1_6
+-        cdef tuple jmm1_7
+-        cdef tuple jmm1_8
+-        cdef tuple jmm1_9
+-
+-        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
+-
+-        # perform loop in each row of matrix
+-        for r in jmm1_row:
+-            j, m, m1 = jmm1_row[r]
+-            jmm1_1 = (j, m, m1)
+-            jmm1_2 = (j, m+1, m1+1)
+-            jmm1_3 = (j+1, m+1, m1+1)
+-            jmm1_4 = (j-1, m+1, m1+1)
+-            jmm1_5 = (j+1, m, m1)
+-            jmm1_6 = (j-1, m, m1)
+-            jmm1_7 = (j+1, m-1, m1-1)
+-            jmm1_8 = (j, m-1, m1-1)
+-            jmm1_9 = (j-1, m-1, m1-1)
+-
+-            g1 = self.gamma1(jmm1_1)
+-            c1 = jmm1_inv[jmm1_1]
+-
+-            lindblad_row.append(int(r))
+-            lindblad_col.append(int(c1))
+-            lindblad_data.append(g1)
+-
+-            # generate gammas in the given row
+-            # check if the gammas exist
+-            # load gammas in the lindbladian in the correct position
+-
+-            if jmm1_2 in jmm1_inv:
+-                g2 = self.gamma2(jmm1_2)
+-                c2 = jmm1_inv[jmm1_2]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c2))
+-                lindblad_data.append(g2)
+-
+-            if jmm1_3 in jmm1_inv:
+-                g3 = self.gamma3(jmm1_3)
+-                c3 = jmm1_inv[jmm1_3]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c3))
+-                lindblad_data.append(g3)
+-
+-            if jmm1_4 in jmm1_inv:
+-                g4 = self.gamma4(jmm1_4)
+-                c4 = jmm1_inv[jmm1_4]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c4))
+-                lindblad_data.append(g4)
+-
+-            if jmm1_5 in jmm1_inv:
+-                g5 = self.gamma5(jmm1_5)
+-                c5 = jmm1_inv[jmm1_5]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c5))
+-                lindblad_data.append(g5)
+-
+-            if jmm1_6 in jmm1_inv:
+-                g6 = self.gamma6(jmm1_6)
+-                c6 = jmm1_inv[jmm1_6]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c6))
+-                lindblad_data.append(g6)
+-
+-            if jmm1_7 in jmm1_inv:
+-                g7 = self.gamma7(jmm1_7)
+-                c7 = jmm1_inv[jmm1_7]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c7))
+-                lindblad_data.append(g7)
+-
+-            if jmm1_8 in jmm1_inv:
+-                g8 = self.gamma8(jmm1_8)
+-                c8 = jmm1_inv[jmm1_8]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c8))
+-                lindblad_data.append(g8)
+-
+-            if jmm1_9 in jmm1_inv:
+-                g9 = self.gamma9(jmm1_9)
+-                c9 = jmm1_inv[jmm1_9]
+-
+-                lindblad_row.append(int(r))
+-                lindblad_col.append(int(c9))
+-                lindblad_data.append(g9)
+-
+-        cdef lindblad_matrix = csr_matrix((lindblad_data,
+-                                          (lindblad_row, lindblad_col)),
+-                                          shape=(nds**2, nds**2),
+-                                          dtype=np.complex128)
+-
+-        # make matrix a Qobj superoperator with expected dims
+-        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
+-        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
+-        return lindblad_qobj
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma1(self, tuple jmm1):
+-        """
+-        Calculate gamma1 for value of j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yCE, yE, yD, yP, yCP, yCD
+-        cdef float N
+-        cdef float spontaneous, losses, pump, collective_pump
+-        cdef float dephase, collective_dephase, g1
+-
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-
+-        yE = self.emission
+-        yD = self.dephasing
+-        yP = self.pumping
+-        yCE = self.collective_emission
+-        yCP = self.collective_pumping
+-        yCD = self.collective_dephasing
+-
+-        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
+-        losses = (yE/2) * (N+m+m1)
+-        pump = yP/2 * (N-m-m1)
+-        collective_pump = yCP/2 * \
+-            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
+-        collective_dephase = yCD/2 * (m-m1)**2
+-
+-        if j <= 0:
+-            dephase = yD*N/4
+-        else:
+-            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
+-
+-        g1 = spontaneous + losses + pump + dephase + \
+-            collective_pump + collective_dephase
+-
+-        return -g1
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma2(self, tuple jmm1):
+-        """
+-        Calculate gamma2 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yCE, yE, yD, yP, yCP, yCD, g2
+-        cdef float N
+-        cdef float spontaneous, losses, pump, collective_pump
+-        cdef float dephase, collective_dephase
+-
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-        yCE = self.collective_emission
+-        yE = self.emission
+-
+-        if yCE == 0:
+-            spontaneous = 0.0
+-        else:
+-            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
+-
+-        if (yE == 0) or (j <= 0):
+-            losses = 0.0
+-        else:
+-            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
+-                                                      (N/2 + 1)/(j*(j+1))
+-        g2 = spontaneous + losses
+-        return g2
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma3(self, tuple jmm1):
+-        """
+-        Calculate gamma3 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yE
+-        cdef float N
+-        cdef float spontaneous, losses, pump, collective_pump
+-        cdef float dephase, collective_dephase
+-
+-        cdef complex g3
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-        yE = self.emission
+-
+-        if (yE == 0) or (j <= 0):
+-            g3 = 0.0
+-        else:
+-            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
+-                 (N/2 + j+1)/(j*(2*j + 1))
+-        return g3
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma4(self, tuple jmm1):
+-        """
+-        Calculate gamma4 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef complex g4
+-        cdef float yE
+-        cdef float N
+-
+-        N = float(self.N)
+-        j, m, m1 = jmm1
+-        yE = self.emission
+-        if (yE == 0) or ((j+1) <= 0):
+-            g4 = 0.0
+-        else:
+-            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
+-                                (j-m1+2)) * (N/2 - j)/((j+1) *
+-                                                       (2*j + 1))
+-        return g4
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma5(self, tuple jmm1):
+-        """
+-        Calculate gamma5 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef complex g5
+-        j, m, m1 = jmm1
+-        cdef float yD
+-        cdef float N
+-
+-        N = float(self.N)
+-        yD = self.dephasing
+-
+-        if (yD == 0) or (j <= 0):
+-            g5 = 0.0
+-        else:
+-            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
+-                (N/2 + j + 1)/(j*(2*j + 1))
+-
+-        return g5
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma6(self, tuple jmm1):
+-        """
+-        Calculate gamma6 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yD
+-        cdef float N
+-        cdef complex g6
+-
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-
+-        yD = self.dephasing
+-        if yD == 0:
+-            g6 = 0.0
+-        else:
+-            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
+-                                                   2-m1**2)) * \
+-                                                   (N/2 - j)/((j+1) * (2*j+1))
+-        return g6
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma7(self, tuple jmm1):
+-        """
+-        Calculate gamma7 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yP
+-        cdef float N
+-        cdef complex g7
+-
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-        yP = self.pumping
+-
+-        if (yP == 0) or (j <= 0):
+-            g7 = 0.0
+-        else:
+-            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
+-                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
+-        return g7
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma8(self, tuple jmm1):
+-        """
+-        Calculate gamma8 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yP, yCP
+-        cdef float N
+-        cdef complex g8
+-
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-        yP = self.pumping
+-        yCP = self.collective_pumping
+-        if (yP == 0) or (j <= 0):
+-            pump = 0.0
+-        else:
+-            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
+-                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
+-        if yCP == 0:
+-            collective_pump = 0.0
+-        else:
+-            collective_pump = yCP * \
+-                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
+-        g8 = pump + collective_pump
+-        return g8
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cpdef complex gamma9(self, tuple jmm1):
+-        """
+-        Calculate gamma9 for given j, m, m'.
+-        """
+-        cdef float j, m, m1
+-        cdef float yP
+-        cdef float N
+-        cdef complex g9
+-
+-        j, m, m1 = jmm1
+-        N = float(self.N)
+-        yP = self.pumping
+-
+-        if (yP == 0):
+-            g9 = 0.0
+-        else:
+-            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
+-                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
+-        return g9
++#cython: language_level=3
++
++"""
++Cythonized code for permutationally invariant Lindbladian generation
++"""
++import numpy as np
++
++from scipy.sparse import csr_matrix, dok_matrix
++from qutip.core import Qobj
++
++cimport numpy as cnp
++cimport cython
++
++
++def _num_dicke_states(N):
++    """
++    Calculate the number of Dicke states.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    nds: int
++        The number of Dicke states.
++    """
++    if (not float(N).is_integer()):
++        raise ValueError("Number of TLS should be an integer")
++
++    if (N < 1):
++        raise ValueError("Number of TLS should be non-negative")
++
++    nds = (N/2 + 1)**2 - (N % 2)/4
++    return int(nds)
++
++def _num_dicke_ladders(N):
++    """
++    Calculate the total number of Dicke ladders in the Dicke space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    Nj: int
++        The number of Dicke ladders.
++    """
++    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
++    return int(Nj)
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cpdef list get_blocks(int N):
++    """
++    Calculate the number of cumulative elements at each block boundary.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    blocks: np.ndarray
++        An array with the number of cumulative elements at the boundary of
++        each block.
++    """
++    cdef int num_blocks = _num_dicke_ladders(N)
++    cdef list blocks
++    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
++    return blocks
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cpdef float j_min(N):
++    """
++    Calculate the minimum value of j for given N.
++
++    Parameters
++    ----------
++    N: int
++        Number of two-level systems.
++
++    Returns
++    -------
++    jmin: float
++        The minimum value of j for odd or even number of two
++        level systems.
++    """
++    if N % 2 == 0:
++        return 0
++    else:
++        return 0.5
++
++def j_vals(N):
++    """
++    Get the valid values of j for given N.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    jvals: np.ndarray
++        The j values for given N as a 1D array.
++    """
++    j = np.arange(j_min(N), N/2 + 1, 1)
++    return j
++
++def m_vals(j):
++    """
++    Get all the possible values of m or m1 for given j.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    mvals: np.ndarray
++        The m values for given j as a 1D array.
++    """
++    return np.arange(-j, j+1, 1)
++
++def get_index(N, j, m, m1, blocks):
++    """
++    Get the index in the density matrix for this j, m, m1 value.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    j, m, m1: float
++        The j, m, m1 values.
++
++    blocks: np.ndarray
++        An 1D array with the number of cumulative elements at the boundary of
++        each block.
++
++    Returns
++    -------
++    mvals: array
++        The m values for given j.
++    """
++    _k = int(j-m1)
++    _k_prime = int(j-m)
++    block_number = int(N/2 - j)
++    offset = 0
++    if block_number > 0:
++        offset = blocks[block_number-1]
++    i = _k_prime + offset
++    k = _k + offset
++    return (i, k)
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cpdef list jmm1_dictionary(int N):
++    """
++    Get the index in the density matrix for this j, m, m1 value.
++
++    The (j, m, m1) values are mapped to the (i, k) index of a block
++    diagonal matrix which has the structure to capture the permutationally
++    symmetric part of the density matrix. For each (j, m, m1) value, first
++    we get the block by using the "j" value and then the addition in the
++    row/column due to the m and m1 is determined. Four dictionaries are
++    returned giving a map from the (j, m, m1) values to (i, k), the inverse
++    map, a flattened map and the inverse of the flattened map.
++    """
++    cdef long i
++    cdef long k
++    cdef dict jmm1_dict = {}
++    cdef dict jmm1_inv = {}
++    cdef dict jmm1_flat = {}
++    cdef dict jmm1_flat_inv = {}
++    cdef int l
++    cdef int nds = _num_dicke_states(N)
++    cdef list blocks = get_blocks(N)
++
++    jvalues = j_vals(N)
++    for j in jvalues:
++        mvalues = m_vals(j)
++        for m in mvalues:
++            for m1 in mvalues:
++                i, k = get_index(N, j, m, m1, blocks)
++                jmm1_dict[(i, k)] = (j, m, m1)
++                jmm1_inv[(j, m, m1)] = (i, k)
++                l = nds * i+k
++                jmm1_flat[l] = (j, m, m1)
++                jmm1_flat_inv[(j, m, m1)] = l
++    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
++
++
++@cython.boundscheck(False)
++@cython.wraparound(False)
++cdef class Dicke(object):
++    """
++    A faster Cythonized Dicke state class to build the Lindbladian.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++
++    Attributes
++    ----------
++    N: int
++        The number of two-level systems.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++    """
++    cdef int N
++    cdef float emission, dephasing, pumping
++    cdef float collective_emission, collective_dephasing, collective_pumping
++
++    def __init__(self, int N, float emission=0., float dephasing=0.,
++                 float pumping=0., float collective_emission=0.,
++                 collective_dephasing=0., collective_pumping=0.):
++        self.N = N
++        self.emission = emission
++        self.dephasing = dephasing
++        self.pumping = pumping
++        self.collective_emission = collective_emission
++        self.collective_dephasing = collective_dephasing
++        self.collective_pumping = collective_pumping
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef object lindbladian(self):
++        """
++        Build the Lindbladian superoperator of the dissipative dynamics as a
++        sparse matrix.
++
++        Returns
++        ----------
++        lindblad_qobj: :class: qutip.Qobj
++            The matrix size is (nds**2, nds**2) where nds is the number of
++            Dicke states.
++        """
++        N = self.N
++        cdef int nds = _num_dicke_states(N)
++        cdef int num_ladders = _num_dicke_ladders(N)
++
++        cdef list lindblad_row = []
++        cdef list lindblad_col = []
++        cdef list lindblad_data = []
++        cdef tuple jmm1_1
++        cdef tuple jmm1_2
++        cdef tuple jmm1_3
++        cdef tuple jmm1_4
++        cdef tuple jmm1_5
++        cdef tuple jmm1_6
++        cdef tuple jmm1_7
++        cdef tuple jmm1_8
++        cdef tuple jmm1_9
++
++        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
++
++        # perform loop in each row of matrix
++        for r in jmm1_row:
++            j, m, m1 = jmm1_row[r]
++            jmm1_1 = (j, m, m1)
++            jmm1_2 = (j, m+1, m1+1)
++            jmm1_3 = (j+1, m+1, m1+1)
++            jmm1_4 = (j-1, m+1, m1+1)
++            jmm1_5 = (j+1, m, m1)
++            jmm1_6 = (j-1, m, m1)
++            jmm1_7 = (j+1, m-1, m1-1)
++            jmm1_8 = (j, m-1, m1-1)
++            jmm1_9 = (j-1, m-1, m1-1)
++
++            g1 = self.gamma1(jmm1_1)
++            c1 = jmm1_inv[jmm1_1]
++
++            lindblad_row.append(int(r))
++            lindblad_col.append(int(c1))
++            lindblad_data.append(g1)
++
++            # generate gammas in the given row
++            # check if the gammas exist
++            # load gammas in the lindbladian in the correct position
++
++            if jmm1_2 in jmm1_inv:
++                g2 = self.gamma2(jmm1_2)
++                c2 = jmm1_inv[jmm1_2]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c2))
++                lindblad_data.append(g2)
++
++            if jmm1_3 in jmm1_inv:
++                g3 = self.gamma3(jmm1_3)
++                c3 = jmm1_inv[jmm1_3]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c3))
++                lindblad_data.append(g3)
++
++            if jmm1_4 in jmm1_inv:
++                g4 = self.gamma4(jmm1_4)
++                c4 = jmm1_inv[jmm1_4]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c4))
++                lindblad_data.append(g4)
++
++            if jmm1_5 in jmm1_inv:
++                g5 = self.gamma5(jmm1_5)
++                c5 = jmm1_inv[jmm1_5]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c5))
++                lindblad_data.append(g5)
++
++            if jmm1_6 in jmm1_inv:
++                g6 = self.gamma6(jmm1_6)
++                c6 = jmm1_inv[jmm1_6]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c6))
++                lindblad_data.append(g6)
++
++            if jmm1_7 in jmm1_inv:
++                g7 = self.gamma7(jmm1_7)
++                c7 = jmm1_inv[jmm1_7]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c7))
++                lindblad_data.append(g7)
++
++            if jmm1_8 in jmm1_inv:
++                g8 = self.gamma8(jmm1_8)
++                c8 = jmm1_inv[jmm1_8]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c8))
++                lindblad_data.append(g8)
++
++            if jmm1_9 in jmm1_inv:
++                g9 = self.gamma9(jmm1_9)
++                c9 = jmm1_inv[jmm1_9]
++
++                lindblad_row.append(int(r))
++                lindblad_col.append(int(c9))
++                lindblad_data.append(g9)
++
++        cdef lindblad_matrix = csr_matrix((lindblad_data,
++                                          (lindblad_row, lindblad_col)),
++                                          shape=(nds**2, nds**2),
++                                          dtype=np.complex128)
++
++        # make matrix a Qobj superoperator with expected dims
++        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
++        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
++        return lindblad_qobj
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma1(self, tuple jmm1):
++        """
++        Calculate gamma1 for value of j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yCE, yE, yD, yP, yCP, yCD
++        cdef float N
++        cdef float spontaneous, losses, pump, collective_pump
++        cdef float dephase, collective_dephase, g1
++
++        j, m, m1 = jmm1
++        N = float(self.N)
++
++        yE = self.emission
++        yD = self.dephasing
++        yP = self.pumping
++        yCE = self.collective_emission
++        yCP = self.collective_pumping
++        yCD = self.collective_dephasing
++
++        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
++        losses = (yE/2) * (N+m+m1)
++        pump = yP/2 * (N-m-m1)
++        collective_pump = yCP/2 * \
++            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
++        collective_dephase = yCD/2 * (m-m1)**2
++
++        if j <= 0:
++            dephase = yD*N/4
++        else:
++            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
++
++        g1 = spontaneous + losses + pump + dephase + \
++            collective_pump + collective_dephase
++
++        return -g1
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma2(self, tuple jmm1):
++        """
++        Calculate gamma2 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yCE, yE, yD, yP, yCP, yCD, g2
++        cdef float N
++        cdef float spontaneous, losses, pump, collective_pump
++        cdef float dephase, collective_dephase
++
++        j, m, m1 = jmm1
++        N = float(self.N)
++        yCE = self.collective_emission
++        yE = self.emission
++
++        if yCE == 0:
++            spontaneous = 0.0
++        else:
++            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
++
++        if (yE == 0) or (j <= 0):
++            losses = 0.0
++        else:
++            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
++                                                      (N/2 + 1)/(j*(j+1))
++        g2 = spontaneous + losses
++        return g2
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma3(self, tuple jmm1):
++        """
++        Calculate gamma3 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yE
++        cdef float N
++        cdef float spontaneous, losses, pump, collective_pump
++        cdef float dephase, collective_dephase
++
++        cdef complex g3
++        j, m, m1 = jmm1
++        N = float(self.N)
++        yE = self.emission
++
++        if (yE == 0) or (j <= 0):
++            g3 = 0.0
++        else:
++            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
++                 (N/2 + j+1)/(j*(2*j + 1))
++        return g3
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma4(self, tuple jmm1):
++        """
++        Calculate gamma4 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef complex g4
++        cdef float yE
++        cdef float N
++
++        N = float(self.N)
++        j, m, m1 = jmm1
++        yE = self.emission
++        if (yE == 0) or ((j+1) <= 0):
++            g4 = 0.0
++        else:
++            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
++                                (j-m1+2)) * (N/2 - j)/((j+1) *
++                                                       (2*j + 1))
++        return g4
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma5(self, tuple jmm1):
++        """
++        Calculate gamma5 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef complex g5
++        j, m, m1 = jmm1
++        cdef float yD
++        cdef float N
++
++        N = float(self.N)
++        yD = self.dephasing
++
++        if (yD == 0) or (j <= 0):
++            g5 = 0.0
++        else:
++            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
++                (N/2 + j + 1)/(j*(2*j + 1))
++
++        return g5
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma6(self, tuple jmm1):
++        """
++        Calculate gamma6 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yD
++        cdef float N
++        cdef complex g6
++
++        j, m, m1 = jmm1
++        N = float(self.N)
++
++        yD = self.dephasing
++        if yD == 0:
++            g6 = 0.0
++        else:
++            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
++                                                   2-m1**2)) * \
++                                                   (N/2 - j)/((j+1) * (2*j+1))
++        return g6
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma7(self, tuple jmm1):
++        """
++        Calculate gamma7 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yP
++        cdef float N
++        cdef complex g7
++
++        j, m, m1 = jmm1
++        N = float(self.N)
++        yP = self.pumping
++
++        if (yP == 0) or (j <= 0):
++            g7 = 0.0
++        else:
++            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
++                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
++        return g7
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma8(self, tuple jmm1):
++        """
++        Calculate gamma8 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yP, yCP
++        cdef float N
++        cdef complex g8
++
++        j, m, m1 = jmm1
++        N = float(self.N)
++        yP = self.pumping
++        yCP = self.collective_pumping
++        if (yP == 0) or (j <= 0):
++            pump = 0.0
++        else:
++            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
++                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
++        if yCP == 0:
++            collective_pump = 0.0
++        else:
++            collective_pump = yCP * \
++                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
++        g8 = pump + collective_pump
++        return g8
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cpdef complex gamma9(self, tuple jmm1):
++        """
++        Calculate gamma9 for given j, m, m'.
++        """
++        cdef float j, m, m1
++        cdef float yP
++        cdef float N
++        cdef complex g9
++
++        j, m, m1 = jmm1
++        N = float(self.N)
++        yP = self.pumping
++
++        if (yP == 0):
++            g9 = 0.0
++        else:
++            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
++                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
++        return g9
+diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
+index 91799251..4257fb2b 100644
+--- a/qutip/solve/_stochastic.pyx
++++ b/qutip/solve/_stochastic.pyx
+@@ -1,2345 +1,2345 @@
+-#cython: language_level=3
+-
+-import numpy as np
+-cimport numpy as np
+-cimport cython
+-from cpython.exc cimport PyErr_CheckSignals
+-from libc.math cimport fabs
+-from qutip.core.cy.qobjevo cimport QobjEvo
+-from .. import Qobj, unstack_columns
+-import scipy.sparse as sp
+-from scipy.sparse.linalg import LinearOperator
+-from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
+-from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
+-
+-from qutip.core.data cimport dense, Dense
+-import qutip.core.data as _data
+-
+-cdef extern from "<complex>" namespace "std" nogil:
+-    double complex conj(double complex x)
+-
+-cdef int ZERO=0
+-cdef double DZERO=0
+-cdef complex ZZERO=0j
+-cdef int ONE=1
+-
+-"""Some of blas wrapper"""
+-@cython.boundscheck(False)
+-cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
+-    """ y += a*x"""
+-    cdef int l = x.shape[0]
+-    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void copy(complex[::1] x, complex[::1] y):
+-    """ y = x """
+-    cdef int l = x.shape[0]
+-    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef complex _dot(complex[::1] x, complex[::1] y):
+-    """ = x_i * y_i """
+-    cdef int l = x.shape[0]
+-    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef complex _dotc(complex[::1] x, complex[::1] y):
+-    """ = conj(x_i) * y_i """
+-    cdef int l = x.shape[0]
+-    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef double _dznrm2(complex[::1] vec):
+-    """ = sqrt( x_i**2 ) """
+-    cdef int l = vec.shape[0]
+-    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void _scale(double a, complex[::1] x):
+-    """ x *= a """
+-    cdef int l = x.shape[0]
+-    zdscal(&l, &a, <complex*>&x[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void _zscale(complex a, complex[::1] x):
+-    """ x *= a """
+-    cdef int l = x.shape[0]
+-    zscal(&l, &a, <complex*>&x[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void _zero(complex[::1] x):
+-    """ x *= 0 """
+-    cdef int l = x.shape[0]
+-    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void _zero_2d(complex[:,::1] x):
+-    """ x *= 0 """
+-    cdef int l = x.shape[0]*x.shape[1]
+-    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void _zero_3d(complex[:,:,::1] x):
+-    """ x *= 0 """
+-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
+-    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
+-
+-@cython.boundscheck(False)
+-cdef void _zero_4d(complex[:,:,:,::1] x):
+-    """ x *= 0 """
+-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
+-    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
+-
+-@cython.boundscheck(False)
+-@cython.initializedcheck(False)
+-cdef Dense _dense_wrap(double complex [::1] x):
+-    return dense.wrap(&x[0], x.shape[0], 1)
+-
+-# %%%%%%%%%%%%%%%%%%%%%%%%%
+-# functions for ensuring that the states stay physical
+-@cython.cdivision(True)
+-@cython.boundscheck(False)
+-cdef void _normalize_inplace(complex[::1] vec):
+-    """ make norm of vec equal to 1"""
+-    cdef int l = vec.shape[0]
+-    cdef double norm = 1.0/_dznrm2(vec)
+-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
+-
+-# to move eventually, 10x faster than scipy's norm.
+-@cython.cdivision(True)
+-@cython.boundscheck(False)
+-def normalize_inplace(complex[::1] vec):
+-    """ make norm of vec equal to 1"""
+-    cdef int l = vec.shape[0]
+-    cdef double norm = 1.0/_dznrm2(vec)
+-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
+-    return fabs(norm-1)
+-
+-@cython.cdivision(True)
+-@cython.boundscheck(False)
+-cdef void _normalize_rho(complex[::1] rho):
+-    """ Ensure that the density matrix trace is one and
+-    that the composing states are normalized.
+-    """
+-    cdef int l = rho.shape[0]
+-    cdef int N = np.sqrt(l)
+-    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
+-    cdef complex[::1,:] eivec
+-    cdef double[::1] eival = np.zeros(N)
+-    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
+-
+-    _zero(rho)
+-    cdef int i, j, k
+-    cdef double sum
+-
+-    sum = 0.
+-    for i in range(N):
+-        _normalize_inplace(eivec[:,i])
+-        if eival[i] < 0:
+-            eival[i] = 0.
+-        sum += eival[i]
+-    if sum != 1.:
+-        for i in range(N):
+-            eival[i] /= sum
+-
+-    for i in range(N):
+-        for j in range(N):
+-            for k in range(N):
+-                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
+-
+-# Available solvers:
+-cpdef enum Solvers:
+-  # order 0.5
+-  EULER_SOLVER           =  50
+-  # order 0.5 strong, 1.0 weak?
+-  PC_SOLVER              = 101
+-  PC_2_SOLVER            = 104
+-  # order 1.0
+-  PLATEN_SOLVER          = 100
+-  MILSTEIN_SOLVER        = 102
+-  MILSTEIN_IMP_SOLVER    = 103
+-  # order 1.5
+-  EXPLICIT1_5_SOLVER     = 150
+-  TAYLOR1_5_SOLVER       = 152
+-  TAYLOR1_5_IMP_SOLVER   = 153
+-  # order 2.0
+-  TAYLOR2_0_SOLVER       = 202
+-
+-  # Special solvers
+-  PHOTOCURRENT_SOLVER    =  60
+-  PHOTOCURRENT_PC_SOLVER = 110
+-  ROUCHON_SOLVER         = 120
+-
+-  # For initialisation
+-  SOLVER_NOT_SET         =   0
+-
+-
+-cdef class TaylorNoise:
+-    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
+-    Complex enough that I fell it should be kept separated from the main solver.
+-    """
+-    cdef:
+-      int p
+-      double rho, alpha
+-      double aFactor, bFactor
+-      double BFactor, CFactor
+-      double dt, dt_sqrt
+-
+-    @cython.cdivision(True)
+-    def __init__(self, int p, double dt):
+-        self.p = p
+-        self.dt = dt
+-        self.dt_sqrt = dt**.5
+-        cdef double pi = np.pi
+-        cdef int i
+-
+-        cdef double rho = 0.
+-        for i in range(1,p+1):
+-            rho += (i+0.)**-2
+-        rho = 1./3.-2*rho/(pi**2)
+-        self.rho = (rho)**.5
+-        self.aFactor = -(2)**.5/pi
+-
+-        cdef double alpha = 0.
+-        for i in range(1,p+1):
+-            alpha += (i+0.)**-4
+-        alpha = pi/180-alpha/(2*pi**2)/pi
+-        self.alpha = (alpha)**.5
+-        self.bFactor = (0.5)**.5/pi**2
+-
+-        self.BFactor = 1/(4*pi**2)
+-        self.CFactor = -1/(2*pi**2)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cpdef void order2(self, double[::1] noise, double[::1] dws):
+-        cdef int p = self.p
+-        cdef int r, l
+-        cdef double s = 1/6.
+-        cdef double a = 0
+-        cdef double b = 0
+-        cdef double AA = 0
+-        cdef double BB = 0
+-        cdef double CC = 0
+-
+-        for r in range(p):
+-            a += noise[3+r]/(r+1.)
+-            b += noise[3+r+p]/(r+1.)/(r+1.)
+-            BB += (1/(r+1.)/(r+1.)) *\
+-                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
+-            for l in range(p):
+-                if r != l:
+-                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
+-                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
+-                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
+-
+-        a = self.aFactor * a + self.rho * noise[1]
+-        b = self.bFactor * b + self.alpha * noise[2]
+-        AA = 0.25*a*a
+-        BB *= self.BFactor
+-        CC *= self.CFactor
+-
+-        dws[0] = noise[0]                       # dw
+-        dws[1] = 0.5*(noise[0]+a)               # dz
+-        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
+-        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
+-        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
+-
+-
+-cdef class StochasticSolver:
+-    """ stochastic solver class base
+-    Does most of the initialisation, drive the simulation and contain the
+-    stochastic integration algorythm that do not depend on the physics.
+-
+-    This class is not to be used as is, the function computing the evolution's
+-    derivative are specified in it's child class which define the deterministic
+-    and stochastic contributions.
+-
+-    PYTHON METHODS:
+-    set_solver:
+-      Receive the data for the integration.
+-      Prepare buffers
+-
+-    cy_sesolve_single_trajectory:
+-      Run one trajectory.
+-
+-
+-    INTERNAL METHODS
+-    make_noise:
+-      create the stochastic noise
+-    run:
+-      evolution between timestep (substep)
+-    solver's method:
+-      stochastic integration algorithm
+-        euler
+-        milstein
+-        taylor
+-        ...
+-
+-    CHILD:
+-    SSESolver: stochastic schrodinger evolution
+-    SMESolver: stochastic master evolution
+-    PcSSESolver: photocurrent stochastic schrodinger evolution
+-    PcSMESolver: photocurrent stochastic master evolution
+-    PmSMESolver: positive map stochastic master evolution
+-    GenericSSolver: general (user defined) stochastic evolution
+-
+-    CHILD METHODS:
+-    set_data:
+-      Read data about the system
+-    d1:
+-      deterministic part
+-    d2:
+-      non-deterministic part
+-    derivatives:
+-      d1, d2 and their derivatives up to dt**1.5
+-      multiple sc_ops
+-    derivativesO2:
+-      d1, d2 and there derivatives up to dt**2.0
+-      one sc_ops
+-    """
+-    cdef int l_vec, num_ops
+-    cdef Solvers solver
+-    cdef int num_step, num_substeps, num_dw
+-    cdef int normalize
+-    cdef double dt
+-    cdef int noise_type
+-    cdef object custom_noise
+-    cdef double[::1] dW_factor
+-    cdef unsigned int[::1] seed
+-    cdef object sso
+-
+-    # buffer to not redo the initialisation at each substep
+-    cdef complex[:, ::1] buffer_1d
+-    cdef complex[:, :, ::1] buffer_2d
+-    cdef complex[:, :, :, ::1] buffer_3d
+-    cdef complex[:, :, :, ::1] buffer_4d
+-    cdef complex[:, ::1] expect_buffer_1d
+-    cdef complex[:, ::1] expect_buffer_2d
+-    cdef complex[:, :, ::1] expect_buffer_3d
+-    cdef complex[:, ::1] func_buffer_1d
+-    cdef complex[:, ::1] func_buffer_2d
+-    cdef complex[:, :, ::1] func_buffer_3d
+-
+-    cdef TaylorNoise order2noise
+-
+-    def __init__(self):
+-        self.l_vec = 0
+-        self.num_ops = 0
+-        self.solver = SOLVER_NOT_SET
+-
+-    def set_solver(self, sso):
+-        """ Prepare the solver from the info in StochasticSolverOptions
+-
+-        Parameters
+-        ----------
+-        sso : StochasticSolverOptions
+-            Data of the stochastic system
+-        """
+-        self.set_data(sso)
+-        self.sso = sso
+-
+-        self.solver = sso.solver_code
+-        self.dt = sso.dt
+-        self.num_substeps = sso.nsubsteps
+-        self.normalize = sso.normalize
+-        self.num_step = len(sso.times)
+-        self.num_dw = len(sso.sops)
+-        if self.solver in [EXPLICIT1_5_SOLVER,
+-                           TAYLOR1_5_SOLVER,
+-                           TAYLOR1_5_IMP_SOLVER]:
+-            self.num_dw *= 2
+-        if self.solver in [TAYLOR2_0_SOLVER]:
+-            self.num_dw *= 3 + 2*sso.p
+-            self.order2noise = TaylorNoise(sso.p, self.dt)
+-        # prepare buffers for the solvers
+-        nb_solver = [0,0,0,0]
+-        nb_func = [0,0,0]
+-        nb_expect = [0,0,0]
+-
+-        # %%%%%%%%%%%%%%%%%%%%%%%%%
+-        # Depending on the solver, determine the numbers of buffers of each
+-        # shape to prepare. (~30% slower when not preallocating buffer)
+-        # nb_solver : buffer to contain the states used by solver
+-        # nb_func : buffer for states used used by d1, d2 and derivative functions
+-        # nb_expect : buffer to store expectation values.
+-        if self.solver is EULER_SOLVER:
+-            nb_solver = [0,1,0,0]
+-        elif self.solver is PHOTOCURRENT_SOLVER:
+-            nb_solver = [1,0,0,0]
+-            nb_func = [1,0,0]
+-        elif self.solver is PLATEN_SOLVER:
+-            nb_solver = [2,5,0,0]
+-        elif self.solver is PC_SOLVER:
+-            nb_solver = [4,1,1,0]
+-        elif self.solver is MILSTEIN_SOLVER:
+-            nb_solver = [0,1,1,0]
+-        elif self.solver is MILSTEIN_IMP_SOLVER:
+-            nb_solver = [1,1,1,0]
+-        elif self.solver is PC_2_SOLVER:
+-            nb_solver = [5,1,1,0]
+-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
+-            nb_solver = [1,1,0,0]
+-            nb_func = [1,0,0]
+-        elif self.solver is ROUCHON_SOLVER:
+-            nb_solver = [2,0,0,0]
+-        elif self.solver is EXPLICIT1_5_SOLVER:
+-            nb_solver = [5,8,3,0]
+-        elif self.solver is TAYLOR1_5_SOLVER:
+-            nb_solver = [2,3,1,1]
+-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
+-            nb_solver = [2,3,1,1]
+-        elif self.solver is TAYLOR2_0_SOLVER:
+-            nb_solver = [11,0,0,0]
+-
+-        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
+-                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+-          if sso.me:
+-            nb_func = [1,0,0]
+-            nb_expect = [1,1,0]
+-          else:
+-            nb_func = [2,1,1]
+-            nb_expect = [2,1,1]
+-        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
+-            nb_expect = [1,0,0]
+-        elif self.solver is TAYLOR2_0_SOLVER:
+-          if sso.me:
+-            nb_func = [2,0,0]
+-            nb_expect = [2,0,0]
+-          else:
+-            nb_func = [14,0,0]
+-            nb_expect = [0,0,0]
+-        elif self.solver is ROUCHON_SOLVER:
+-            nb_expect = [1,0,0]
+-        else:
+-          if not sso.me:
+-            nb_func = [1,0,0]
+-
+-        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
+-        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
+-                                  dtype=complex)
+-        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
+-                                        dtype=complex)
+-        if nb_solver[3]:
+-          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
+-                                        dtype=complex)
+-
+-        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
+-        if nb_expect[1]:
+-          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
+-        if nb_expect[2]:
+-          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
+-
+-        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
+-        if nb_func[1]:
+-          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
+-        if nb_func[2]:
+-          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
+-
+-        self.noise_type = sso.noise_type
+-        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
+-        if self.noise_type == 1:
+-            self.custom_noise = sso.noise
+-        elif self.noise_type == 0:
+-            self.seed = sso.noise
+-
+-    def set_data(self, sso):
+-        """Set solver specific operator"""
+-        pass
+-
+-    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
+-        """Create the random numbers for the stochastic process"""
+-        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
+-            # photocurrent, just seed,
+-            np.random.seed(self.seed[n])
+-            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
+-        if self.noise_type == 0:
+-            np.random.seed(self.seed[n])
+-            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
+-                                   np.sqrt(self.dt)
+-        elif self.noise_type == 1:
+-            return self.custom_noise[n,:,:,:]
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    def cy_sesolve_single_trajectory(self, int n):
+-        """ Run the one of the trajectories of the stochastic system.
+-
+-        Parameters
+-        ----------
+-        n : int
+-            Number of the iterations
+-
+-        sso : StochasticSolverOptions
+-            Data of the stochastic system
+-
+-        Returns
+-        -------
+-        states_list : list of qobj
+-            State of the system at each time
+-
+-        noise : array
+-            noise at each step of the solver
+-
+-        measurements : array
+-            measurements value at each timestep for each m_ops
+-
+-        expect : array
+-            expectation value at each timestep for each e_ops
+-
+-        """
+-        sso = self.sso
+-        cdef double[::1] times = sso.times
+-        cdef complex[::1] rho_t
+-        cdef double t
+-        cdef int m_idx, t_idx, e_idx
+-        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
+-        cdef int tlast = times.shape[0]
+-
+-        rho_t = sso.rho0.copy()
+-        dims = sso.state0.dims
+-
+-        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
+-        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
+-        states_list = []
+-        for t_idx, t in enumerate(times):
+-            PyErr_CheckSignals()
+-            if sso.ce_ops:
+-                for e_idx, e in enumerate(sso.ce_ops):
+-                    s = e.expect_data(t, _dense_wrap(rho_t))
+-                    expect[e_idx, t_idx] = s
+-            if sso.store_states or not sso.ce_ops:
+-                if sso.me:
+-                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
+-                        dims=dims))
+-                else:
+-                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
+-
+-            if t_idx != tlast-1:
+-                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
+-                                 rho_t, self.num_substeps)
+-
+-            if sso.store_measurement:
+-                for m_idx, m in enumerate(sso.cm_ops):
+-                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
+-                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
+-                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
+-
+-        if sso.method == 'heterodyne':
+-            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
+-
+-        return states_list, noise, measurements, expect
+-
+-    @cython.boundscheck(False)
+-    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
+-                          complex[::1] vec, int num_substeps):
+-        """ Do one time full step"""
+-        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
+-        cdef int i
+-        if self.solver is EULER_SOLVER:
+-            for i in range(num_substeps):
+-                self.euler(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is PHOTOCURRENT_SOLVER:
+-            for i in range(num_substeps):
+-                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is PLATEN_SOLVER:
+-            for i in range(num_substeps):
+-                self.platen(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is PC_SOLVER:
+-            for i in range(num_substeps):
+-                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is MILSTEIN_SOLVER:
+-            for i in range(num_substeps):
+-                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is MILSTEIN_IMP_SOLVER:
+-            for i in range(num_substeps):
+-                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is PC_2_SOLVER:
+-            for i in range(num_substeps):
+-                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
+-            for i in range(num_substeps):
+-                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is ROUCHON_SOLVER:
+-            for i in range(num_substeps):
+-                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is EXPLICIT1_5_SOLVER:
+-            for i in range(num_substeps):
+-                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is TAYLOR1_5_SOLVER:
+-            for i in range(num_substeps):
+-                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
+-            for i in range(num_substeps):
+-                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        elif self.solver is TAYLOR2_0_SOLVER:
+-            for i in range(num_substeps):
+-                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
+-                out, vec = vec, out
+-
+-        if self.normalize:
+-            self._normalize_inplace(vec)
+-        return vec
+-
+-    cdef void _normalize_inplace(self, complex[::1] vec):
+-        _normalize_inplace(vec)
+-
+-    # Dummy functions
+-    # Needed for compilation since ssesolve is not stand-alone
+-    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
+-        """ deterministic part of the evolution
+-        depend on schrodinger vs master vs photocurrent
+-        """
+-        pass
+-
+-    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
+-        """ stochastic part of the evolution
+-        depend on schrodinger vs master vs photocurrent
+-        """
+-        pass
+-
+-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+-                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
+-        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
+-        pass
+-
+-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+-                              complex[::1] a, complex[:, ::1] b,
+-                              complex[:, :, ::1] Lb, complex[:,::1] La,
+-                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+-                              complex[::1] L0a):
+-        """ Obtain the multiple terms for stochastic taylor expension
+-        Up to order 1.5
+-        multiple sc_ops
+-        """
+-        pass
+-
+-    cdef void derivativesO2(self, double t, complex[::1] rho,
+-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+-                            complex[::1] L0a,
+-                            complex[::1] LLa, complex[::1] LL0b,
+-                            complex[::1] L0Lb, complex[::1] LLLb):
+-        """ Obtain the multiple terms for stochastic taylor expension
+-        Up to order 2.0
+-        One sc_ops
+-        """
+-        pass
+-
+-    cdef void photocurrent(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        """Special integration scheme:
+-        photocurrent collapse + euler evolution
+-        """
+-        pass
+-
+-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        """Special integration scheme:
+-        photocurrent collapse + predictor-corrector evolution
+-        """
+-        pass
+-
+-    cdef void rouchon(self, double t, double dt, double[:] noise,
+-                      complex[::1] vec, complex[::1] out):
+-        """Special integration scheme:
+-        Force valid density matrix using positive map
+-        Pierre Rouchon, Jason F. Ralph
+-        arXiv:1410.5345 [quant-ph]
+-        """
+-        pass
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void euler(self, double t, double dt, double[:] noise,
+-                    complex[::1] vec, complex[::1] out):
+-        """Integration scheme:
+-        Basic Euler order 0.5
+-        dV = d1 dt + d2_i dW_i
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        cdef int i, j
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        _zero_2d(d2)
+-        copy(vec, out)
+-        self.d1(t, vec, out)
+-        self.d2(t, vec, d2)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i], d2[i,:], out)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void platen(self, double t, double dt, double[:] noise,
+-                       complex[::1] vec, complex[::1] out):
+-        """
+-        Platen rhs function for both master eq and schrodinger eq.
+-        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
+-             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
+-             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
+-
+-        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
+-        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
+-        The Theory of Open Quantum Systems
+-        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
+-        """
+-        cdef int i, j, k
+-        cdef double sqrt_dt = np.sqrt(dt)
+-        cdef double sqrt_dt_inv = 0.25/sqrt_dt
+-        cdef double dw, dw2
+-        cdef complex[::1] d1 = self.buffer_1d[0,:]
+-        cdef complex[::1] Vt = self.buffer_1d[1,:]
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
+-        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
+-        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
+-        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
+-        _zero(d1)
+-        _zero_2d(d2)
+-
+-        self.d1(t, vec, d1)
+-        self.d2(t, vec, d2)
+-        _axpy(1.0,vec,d1)
+-        copy(d1,Vt)
+-        copy(d1,out)
+-        _scale(0.5,out)
+-        for i in range(self.num_ops):
+-            copy(d1,Vp[i,:])
+-            copy(d1,Vm[i,:])
+-            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
+-            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
+-            _axpy(noise[i],d2[i,:],Vt)
+-        _zero(d1)
+-        self.d1(t, Vt, d1)
+-        _axpy(0.5,d1,out)
+-        _axpy(0.5,vec,out)
+-        for i in range(self.num_ops):
+-            _zero_2d(d2p)
+-            _zero_2d(d2m)
+-            self.d2(t, Vp[i,:], d2p)
+-            self.d2(t, Vm[i,:], d2m)
+-            dw = noise[i] * 0.25
+-            _axpy(dw,d2m[i,:],out)
+-            _axpy(2*dw,d2[i,:],out)
+-            _axpy(dw,d2p[i,:],out)
+-            for j in range(self.num_ops):
+-                if i == j:
+-                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
+-                else:
+-                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
+-                _axpy(dw2,d2p[j,:],out)
+-                _axpy(-dw2,d2m[j,:],out)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void pred_corr(self, double t, double dt, double[:] noise,
+-                    complex[::1] vec, complex[::1] out):
+-        """
+-        Chapter 15.5 Eq. (5.4)
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        # a=0. b=0.5
+-        cdef double dt_2 = dt*0.5
+-        cdef complex[::1] euler = self.buffer_1d[0,:]
+-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
+-        cdef complex[::1] b_pred = self.buffer_1d[2,:]
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+-        _zero(a_pred)
+-        _zero(b_pred)
+-        _zero_2d(d2)
+-        _zero_3d(dd2)
+-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
+-        copy(vec, euler)
+-        copy(vec, out)
+-        _axpy(1.0, a_pred, euler)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i], d2[i,:], b_pred)
+-            _axpy(-dt_2, dd2[i,i,:], a_pred)
+-        _axpy(1.0, a_pred, out)
+-        _axpy(1.0, b_pred, euler)
+-        _axpy(0.5, b_pred, out)
+-        _zero_2d(d2)
+-        self.d2(t + dt, euler, d2)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i]*0.5, d2[i,:], out)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
+-                    complex[::1] vec, complex[::1] out):
+-        """
+-        Chapter 15.5 Eq. (5.4)
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        # a=0.5, b=0.5
+-        cdef int i, j, k
+-        cdef complex[::1] euler = self.buffer_1d[0,:]
+-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
+-        _zero(a_pred)
+-        cdef complex[::1] a_corr = self.buffer_1d[2,:]
+-        _zero(a_corr)
+-        cdef complex[::1] b_pred = self.buffer_1d[3,:]
+-        _zero(b_pred)
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        _zero_2d(d2)
+-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+-        _zero_3d(dd2)
+-
+-        cdef double dt_2 = dt*0.5
+-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
+-        copy(vec, euler)
+-        _axpy(1.0, a_pred, euler)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i], d2[i,:], b_pred)
+-            _axpy(-dt_2, dd2[i,i,:], a_pred)
+-        _axpy(1.0, b_pred, euler)
+-        copy(vec, out)
+-        _axpy(0.5, a_pred, out)
+-        _axpy(0.5, b_pred, out)
+-        _zero_2d(d2)
+-        _zero_3d(dd2)
+-        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i]*0.5, d2[i,:], out)
+-            _axpy(-dt_2, dd2[i,i,:], a_corr)
+-        _axpy(0.5, a_corr, out)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void milstein(self, double t, double dt, double[:] noise,
+-                    complex[::1] vec, complex[::1] out):
+-        """
+-        Chapter 10.3 Eq. (3.1)
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-
+-        dV = -iH*V*dt + d1*dt + d2_i*dW_i
+-             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+-        """
+-        cdef int i, j, k
+-        cdef double dw
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+-        _zero_2d(d2)
+-        _zero_3d(dd2)
+-        copy(vec,out)
+-        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i],d2[i,:],out)
+-        for i in range(self.num_ops):
+-            for j in range(i, self.num_ops):
+-                if (i == j):
+-                    dw = (noise[i] * noise[i] - dt) * 0.5
+-                else:
+-                    dw = (noise[i] * noise[j])
+-                _axpy(dw,dd2[i,j,:],out)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void milstein_imp(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out) except *:
+-        """
+-        Chapter 12.2 Eq. (2.9)
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        cdef int i, j, k
+-        cdef double dw
+-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
+-                                                          dtype=complex)
+-        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
+-                                                         dtype=complex)
+-        cdef complex[::1] a = self.buffer_1d[0,:]
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+-        _zero(a)
+-        _zero_2d(d2)
+-        _zero_3d(dd2)
+-        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
+-        copy(vec, dvec)
+-        _axpy(0.5, a, dvec)
+-        for i in range(self.num_ops):
+-            _axpy(noise[i], d2[i,:], dvec)
+-        for i in range(self.num_ops):
+-            for j in range(i, self.num_ops):
+-                if (i == j):
+-                    dw = (noise[i] * noise[i] - dt) * 0.5
+-                else:
+-                    dw = (noise[i] * noise[j])
+-                _axpy(dw, dd2[i,j,:], dvec)
+-        copy(dvec, guess)
+-        _axpy(0.5, a, guess)
+-        self.implicit(t+dt, dvec, out, guess)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void taylor15(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        """
+-        Chapter 12.2 Eq. (2.18),
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        cdef complex[::1] a = self.buffer_1d[0, :]
+-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
+-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
+-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
+-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
+-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
+-        cdef complex[::1] L0a = self.buffer_1d[1, :]
+-        _zero(a)
+-        _zero_2d(b)
+-        _zero_3d(Lb)
+-        _zero_2d(L0b)
+-        _zero_2d(La)
+-        _zero_4d(LLb)
+-        _zero(L0a)
+-        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
+-
+-        cdef int i,j,k
+-        cdef double[::1] dz, dw
+-        dw = np.empty(self.num_ops)
+-        dz = np.empty(self.num_ops)
+-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
+-        for i in range(self.num_ops):
+-            dw[i] = noise[i]
+-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+-        copy(vec,out)
+-        _axpy(1.0, a, out)
+-        _axpy(0.5, L0a, out)
+-
+-        for i in range(self.num_ops):
+-            _axpy(dw[i], b[i,:], out)
+-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
+-            _axpy(dz[i], La[i,:], out)
+-            _axpy(dw[i]-dz[i], L0b[i,:], out)
+-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
+-                        LLb[i,i,i,:], out)
+-            for j in range(i+1,self.num_ops):
+-                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
+-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
+-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
+-                for k in range(j+1,self.num_ops):
+-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out) except *:
+-        """
+-        Chapter 12.2 Eq. (2.18),
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        cdef complex[::1] a = self.buffer_1d[0, :]
+-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
+-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
+-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
+-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
+-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
+-        cdef complex[::1] L0a = self.buffer_1d[1, :]
+-        _zero(a)
+-        _zero_2d(b)
+-        _zero_3d(Lb)
+-        _zero_2d(L0b)
+-        _zero_2d(La)
+-        _zero_4d(LLb)
+-        _zero(L0a)
+-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
+-                   dtype=complex)
+-        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
+-                  dtype=complex)
+-        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
+-
+-        cdef int i,j,k
+-        cdef double[::1] dz, dw
+-        dw = np.empty(self.num_ops)
+-        dz = np.empty(self.num_ops)
+-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
+-        for i in range(self.num_ops):
+-            dw[i] = noise[i]
+-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+-        copy(vec, vec_t)
+-        _axpy(0.5, a, vec_t)
+-        for i in range(self.num_ops):
+-            _axpy(dw[i], b[i,:], vec_t)
+-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
+-            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
+-            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
+-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
+-                        LLb[i,i,i,:], vec_t)
+-            for j in range(i+1,self.num_ops):
+-                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
+-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
+-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
+-                for k in range(j+1,self.num_ops):
+-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
+-        copy(vec_t, guess)
+-        _axpy(0.5, a, guess)
+-
+-        self.implicit(t+dt, vec_t, out, guess)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void platen15(self, double t, double dt, double[:] noise,
+-                    complex[::1] vec, complex[::1] out):
+-        """
+-        Chapter 11.2 Eq. (2.13)
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        cdef int i, j, k
+-        cdef double sqrt_dt = np.sqrt(dt)
+-        cdef double sqrt_dt_inv = 1./sqrt_dt
+-        cdef double ddz, ddw, ddd
+-        cdef double[::1] dz, dw
+-        dw = np.empty(self.num_ops)
+-        dz = np.empty(self.num_ops)
+-        for i in range(self.num_ops):
+-            dw[i] = noise[i]
+-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+-
+-        cdef complex[::1] d1 = self.buffer_1d[0,:]
+-        cdef complex[::1] d1p = self.buffer_1d[1,:]
+-        cdef complex[::1] d1m = self.buffer_1d[2,:]
+-        cdef complex[::1] V = self.buffer_1d[3,:]
+-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+-        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
+-        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
+-        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
+-        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
+-        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
+-        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
+-        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
+-        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
+-        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
+-
+-        _zero(d1)
+-        _zero_2d(d2)
+-        _zero_2d(dd2)
+-        self.d1(t, vec, d1)
+-        self.d2(t, vec, d2)
+-        self.d2(t + dt, vec, dd2)
+-        # Euler part
+-        copy(vec,out)
+-        _axpy(1., d1, out)
+-        for i in range(self.num_ops):
+-            _axpy(dw[i], d2[i,:], out)
+-
+-        _zero(V)
+-        _axpy(1., vec, V)
+-        _axpy(1./self.num_ops, d1, V)
+-
+-        _zero_2d(v2p)
+-        _zero_2d(v2m)
+-        for i in range(self.num_ops):
+-            _axpy(1., V, v2p[i,:])
+-            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
+-            _axpy(1., V, v2m[i,:])
+-            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
+-
+-        _zero_3d(p2p)
+-        _zero_3d(p2m)
+-        for i in range(self.num_ops):
+-            _zero_2d(d2p)
+-            _zero_2d(d2m)
+-            self.d2(t, v2p[i,:], d2p)
+-            self.d2(t, v2m[i,:], d2m)
+-            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
+-            _axpy( ddw, d2p[i,:], out)
+-            _axpy(-ddw, d2m[i,:], out)
+-            for j in range(self.num_ops):
+-                _axpy(      1., v2p[i,:], p2p[i,j,:])
+-                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
+-                _axpy(      1., v2p[i,:], p2m[i,j,:])
+-                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
+-
+-        _axpy(-0.5*(self.num_ops), d1, out)
+-        for i in range(self.num_ops):
+-            ddz = dz[i]*0.5/sqrt_dt  # 1.5
+-            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
+-            _zero(d1p)
+-            _zero(d1m)
+-            _zero_2d(d2m)
+-            _zero_2d(d2p)
+-            _zero_2d(d2pp)
+-            _zero_2d(d2mm)
+-            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
+-            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
+-            self.d2(t, v2p[i,:], d2p)
+-            self.d2(t, v2m[i,:], d2m)
+-            self.d2(t, p2p[i,i,:], d2pp)
+-            self.d2(t, p2m[i,i,:], d2mm)
+-
+-            _axpy( ddz+0.25, d1p, out)
+-            _axpy(-ddz+0.25, d1m, out)
+-
+-            _axpy((dw[i]-dz[i]), dd2[i,:], out)
+-            _axpy((dz[i]-dw[i]), d2[i,:], out)
+-
+-            _axpy( ddd, d2pp[i,:], out)
+-            _axpy(-ddd, d2mm[i,:], out)
+-            _axpy(-ddd, d2p[i,:], out)
+-            _axpy( ddd, d2m[i,:], out)
+-
+-            for j in range(self.num_ops):
+-              ddw = 0.5*(dw[j]-dz[j]) # 1.5
+-              _axpy(ddw, d2p[j,:], out)
+-              _axpy(-2*ddw, d2[j,:], out)
+-              _axpy(ddw, d2m[j,:], out)
+-
+-              if j>i:
+-                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
+-                _axpy( ddw, d2p[j,:], out)
+-                _axpy(-ddw, d2m[j,:], out)
+-
+-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
+-                _zero_2d(d2pp)
+-                _zero_2d(d2mm)
+-                self.d2(t, p2p[j,i,:], d2pp)
+-                self.d2(t, p2m[j,i,:], d2mm)
+-                _axpy( ddw, d2pp[j,:], out)
+-                _axpy(-ddw, d2mm[j,:], out)
+-                _axpy(-ddw, d2p[j,:], out)
+-                _axpy( ddw, d2m[j,:], out)
+-
+-                for k in range(j+1,self.num_ops):
+-                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
+-                    _axpy( ddw, d2pp[k,:], out)
+-                    _axpy(-ddw, d2mm[k,:], out)
+-                    _axpy(-ddw, d2p[k,:], out)
+-                    _axpy( ddw, d2m[k,:], out)
+-
+-              if j<i:
+-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
+-                _zero_2d(d2pp)
+-                _zero_2d(d2mm)
+-                self.d2(t, p2p[j,i,:], d2pp)
+-                self.d2(t, p2m[j,i,:], d2mm)
+-                _axpy( ddw, d2pp[j,:], out)
+-                _axpy(-ddw, d2mm[j,:], out)
+-                _axpy(-ddw, d2p[j,:], out)
+-                _axpy( ddw, d2m[j,:], out)
+-
+-    @cython.wraparound(False)
+-    @cython.boundscheck(False)
+-    @cython.cdivision(True)
+-    cdef void taylor20(self, double t, double dt, double[::1] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        """
+-        Chapter 10.5 Eq. (5.1),
+-        Numerical Solution of Stochastic Differential Equations
+-        By Peter E. Kloeden, Eckhard Platen
+-        """
+-        cdef double[::1] noises = np.empty(5)
+-        cdef double dwn
+-        self.order2noise.order2(noise,noises)
+-        cdef complex[::1] a = self.buffer_1d[0, :]
+-        cdef complex[::1] b = self.buffer_1d[1, :]
+-        cdef complex[::1] Lb = self.buffer_1d[2, :]
+-        cdef complex[::1] La = self.buffer_1d[3, :]
+-        cdef complex[::1] L0b = self.buffer_1d[4, :]
+-        cdef complex[::1] LLb = self.buffer_1d[5, :]
+-        cdef complex[::1] L0a = self.buffer_1d[6, :]
+-        cdef complex[::1] LLa = self.buffer_1d[7, :]
+-        cdef complex[::1] LL0b = self.buffer_1d[8, :]
+-        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
+-        cdef complex[::1] LLLb = self.buffer_1d[10, :]
+-        _zero(a)
+-        _zero(b)
+-        _zero(Lb)
+-        _zero(La)
+-        _zero(L0b)
+-        _zero(LLb)
+-        _zero(L0a)
+-        _zero(LLa)
+-        _zero(LL0b)
+-        _zero(L0Lb)
+-        _zero(LLLb)
+-        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
+-                           L0a, LLa, LL0b, L0Lb, LLLb)
+-
+-        copy(vec,out)
+-        _axpy(1.0, a, out)
+-
+-        _axpy(noises[0], b, out)
+-        dwn = noises[0]*noises[0]*0.5
+-        _axpy(dwn, Lb, out)
+-
+-        _axpy(noises[1], La, out)
+-        _axpy(noises[0]-noises[1], L0b, out)
+-        dwn *= noises[0]*(1/3.)
+-        _axpy(dwn, LLb, out)
+-        _axpy(0.5, L0a, out)
+-
+-        _axpy(noises[2], L0Lb, out)
+-        _axpy(noises[3], LL0b, out)
+-        _axpy(noises[4], LLa, out)
+-        dwn *= noises[0]*0.25
+-        _axpy(dwn, LLLb, out)
+-
+-
+-cdef class SSESolver(StochasticSolver):
+-    """stochastic Schrodinger system"""
+-    cdef QobjEvo L
+-    cdef object c_ops
+-    cdef object cpcd_ops
+-    cdef object imp
+-    cdef double tol, imp_t
+-
+-    def set_data(self, sso):
+-        L = sso.LH
+-        c_ops = sso.sops
+-        self.l_vec = L.shape[0]
+-        self.num_ops = len(c_ops)
+-        self.L = L
+-        self.c_ops = []
+-        self.cpcd_ops = []
+-        for i, op in enumerate(c_ops):
+-            self.c_ops.append(op[0])
+-            self.cpcd_ops.append(op[1])
+-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+-            self.tol = sso.tol
+-            self.imp = LinearOperator( (self.l_vec,self.l_vec),
+-                                      matvec=self.implicit_op, dtype=complex)
+-
+-    def implicit_op(self, vec):
+-        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
+-        self.d1(self.imp_t, vec, out)
+-        cdef int i
+-        _scale(-0.5,out)
+-        _axpy(1.,vec,out)
+-        return out
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+-        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
+-        cdef int i
+-        cdef complex e
+-        cdef QobjEvo c_op
+-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+-        _zero(temp)
+-        for i in range(self.num_ops):
+-            c_op = self.cpcd_ops[i]
+-            e = c_op.expect_data(t, _dense_wrap(vec))
+-            _zero(temp)
+-            c_op = self.c_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
+-            _axpy(-0.125 * e * e * self.dt, vec, out)
+-            _axpy(0.5 * e * self.dt, temp, out)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+-        cdef int i, k
+-        cdef QobjEvo c_op
+-        cdef complex expect
+-        for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
+-            c_op = self.cpcd_ops[i]
+-            expect = c_op.expect_data(t, _dense_wrap(vec))
+-            _axpy(-0.5*expect,vec,out[i,:])
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void derivatives(self, double t, int deg, complex[::1] vec,
+-                          complex[::1] a, complex[:, ::1] b,
+-                          complex[:, :, ::1] Lb, complex[:,::1] La,
+-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+-                          complex[::1] L0a):
+-        """
+-        combinaisons of a and b derivatives for taylor order 1.5
+-        dY ~ a dt + bi dwi
+-                                         deg   use        noise
+-        b[i.:]       bi                   >=0   d2 euler   dwi
+-        a[:]         a                    >=0   d1 euler   dt
+-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
+-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
+-
+-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
+-        La[i,:]      ba'                  >=2   taylor15   dzi
+-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
+-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
+-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
+-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
+-        """
+-        cdef int i, j, k, l
+-        cdef double dt = self.dt
+-        cdef QobjEvo c_op
+-        cdef complex e, de_bb
+-
+-        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
+-        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
+-        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
+-        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
+-        _zero_3d(dde_bb)
+-        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
+-        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
+-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
+-        _zero(temp)
+-        _zero(temp2)
+-        _zero_2d(Cvec)
+-        _zero_3d(Cb)
+-
+-        # a b
+-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
+-        for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
+-            e = _dotc(vec,Cvec[i,:])
+-            e_real[i] = e.real
+-            _axpy(1., Cvec[i,:], b[i,:])
+-            _axpy(-e_real[i], vec, b[i,:])
+-            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
+-            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
+-
+-        #Lb bb'
+-        if deg >= 1:
+-          for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            for j in range(self.num_ops):
+-              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
+-              for k in range(self.l_vec):
+-                  temp[k] = conj(b[j,k])
+-                  temp2[k] = 0.
+-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+-              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
+-                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
+-              _axpy(1., Cb[i,j,:], Lb[i,j,:])
+-              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
+-              _axpy(-de_b[i,j], vec, Lb[i,j,:])
+-
+-              for k in range(self.num_ops):
+-                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
+-                                  _dot(b[k,:], Cb[i,j,:]) + \
+-                                  conj(_dotc(b[k,:], temp2)))*.5
+-                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
+-
+-        #L0b La LLb
+-        if deg >= 2:
+-          for i in range(self.num_ops):
+-              #ba'
+-              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
+-              for j in range(self.num_ops):
+-                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
+-                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
+-                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
+-                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
+-
+-              #ab' + db/dt + bbb"/2
+-              c_op = self.c_ops[i]
+-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
+-              for k in range(self.l_vec):
+-                  temp[k] = conj(a[k])
+-                  temp2[k] = 0.
+-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+-              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
+-                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
+-              _axpy(-e_real[i], a, L0b[i,:])
+-              _axpy(-de_a[i], vec, L0b[i,:])
+-
+-              temp = np.zeros(self.l_vec, dtype=complex)
+-              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
+-              e = _dotc(vec,temp)
+-              _axpy(1., temp, L0b[i,:])
+-              _axpy(-e.real, vec, L0b[i,:])
+-              _axpy(-1., b[i,:], L0b[i,:])
+-
+-              for j in range(self.num_ops):
+-                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
+-                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
+-
+-              #b(bb"+b'b')
+-              for j in range(i,self.num_ops):
+-                  for k in range(j, self.num_ops):
+-                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
+-                                  _dense_wrap(LLb[i,j,k,:]))
+-                      for l in range(self.l_vec):
+-                          temp[l] = conj(Lb[j,k,l])
+-                          temp2[l] = 0.
+-                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+-                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
+-                               _dot(Lb[j,k,:], Cvec[i,:]) + \
+-                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
+-                               _dotc(vec, temp2)))*0.5
+-                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
+-                      _axpy(-de_bb, vec, LLb[i,j,k,:])
+-                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
+-                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
+-                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
+-
+-        #da/dt + aa' + bba"
+-        if deg == 2:
+-          self.d1(t + dt, vec, L0a)
+-          _axpy(-1.0, a, L0a)
+-          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+-          for j in range(self.num_ops):
+-              c_op = self.c_ops[j]
+-              temp = np.zeros(self.l_vec, dtype=complex)
+-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
+-              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
+-              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
+-              _axpy(e_real[j] * dt, temp, L0a[:])
+-              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
+-              for i in range(self.num_ops):
+-                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
+-                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
+-                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
+-                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
+-                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
+-                         complex[::1] vec, complex[::1] out):
+-        cdef int k
+-        cdef complex[::1] temp = self.func_buffer_1d[13,:]
+-        for k in range(self.l_vec):
+-            temp[k] = conj(vec[k])
+-            out[k] = 0.
+-        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void derivativesO2(self, double t, complex[::1] psi,
+-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+-                            complex[::1] L0a,
+-                            complex[::1] LLa, complex[::1] LL0b,
+-                            complex[::1] L0Lb, complex[::1] LLLb):
+-        """
+-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
+-        Use Stratonovich-Taylor expansion.
+-        One one sc_ops
+-        dY ~ a dt + bi dwi
+-
+-        b[:]     b                        d2 euler    dw
+-        a[:]     a- Lb/2                  d1 euler    dt
+-        Lb[:]    b'b                      milstein    dw^2/2
+-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
+-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
+-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
+-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
+-
+-        LLa[:]   ...                      taylor2.0   dwdt-dz
+-        LL0b[:]  ...                      taylor2.0   dz
+-        L0Lb[:]  ...                      taylor2.0   dw^3/6
+-        LLLb[:]  ...                      taylor2.0   dt^2/2
+-        """
+-        cdef double dt = self.dt
+-        cdef QobjEvo c_op = self.c_ops[0]
+-        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
+-        cdef complex de_a, dde_ba, de_La, de_L0b
+-
+-        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
+-        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
+-        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
+-        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
+-        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
+-        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
+-        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
+-        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
+-        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
+-        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
+-        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
+-        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
+-        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
+-        _zero(Cpsi)
+-        _zero(Cb)
+-        _zero(CLb)
+-        _zero(CLLb)
+-        _zero(Ca)
+-        _zero(CLa)
+-        _zero(CL0b)
+-
+-        # b
+-        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
+-        e = _dotc(psi, Cpsi).real
+-        _axpy(1., Cpsi, b)
+-        _axpy(-e, psi, b)
+-
+-        # Lb
+-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
+-        self._c_vec_conj(t, c_op, b, Cbc)
+-        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
+-                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
+-        _axpy(1., Cb, Lb)
+-        _axpy(-e, b, Lb)
+-        _axpy(-de_b, psi, Lb)
+-
+-        # LLb = b'b'b + b"bb
+-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
+-        self._c_vec_conj(t, c_op, Lb, CLbc)
+-        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
+-                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
+-        _axpy(1, CLb, LLb)      # b'b'b
+-        _axpy(-e, Lb, LLb)      # b'b'b
+-        _axpy(-de_Lb, psi, LLb) # b'b'b
+-        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
+-        _axpy(-dde_bb, psi, LLb) # b"bb
+-        _axpy(-de_b*2, b, LLb)   # b"bb
+-
+-        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
+-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
+-        self._c_vec_conj(t, c_op, LLb, CLLbc)
+-        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
+-                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
+-        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
+-                    conj(_dotc(b, CLbc)))*.5
+-        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
+-        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
+-        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
+-        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
+-        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
+-        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
+-        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
+-
+-        # a
+-        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
+-        _axpy(-0.5 * e * e * dt, psi, a)
+-        _axpy(e * dt, Cpsi, a)
+-        _axpy(-0.5 * dt, Lb, a)
+-
+-        #La
+-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
+-        _axpy(-0.5 * e * e * dt, b, La)
+-        _axpy(-e * de_b * dt, psi, La)
+-        _axpy(e * dt, Cb, La)
+-        _axpy(de_b * dt, Cpsi, La)
+-        _axpy(-0.5 * dt, LLb, La)
+-
+-        #LLa
+-        _axpy(-2 * e * de_b * dt, b, LLa)
+-        _axpy(-de_b * de_b * dt, psi, LLa)
+-        _axpy(-e * dde_bb * dt, psi, LLa)
+-        _axpy( 2 * de_b * dt, Cb, LLa)
+-        _axpy( dde_bb * dt, Cpsi, LLa)
+-
+-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
+-        _axpy(-de_Lb * e * dt, psi, LLa)
+-        _axpy(-0.5 * e * e * dt, Lb, LLa)
+-        _axpy( de_Lb * dt, Cpsi, LLa)
+-        _axpy( e * dt, CLb, LLa)
+-
+-        _axpy(-0.5 * dt, LLLb, LLa)
+-
+-        # L0b = b'a
+-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
+-        self._c_vec_conj(t, c_op, a, Cac)
+-        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
+-                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
+-        _axpy(1.0, Ca, L0b)
+-        _axpy(-e, a, L0b)
+-        _axpy(-de_a, psi, L0b)
+-
+-        # LL0b = b"ba + b'La
+-        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
+-                    conj(_dotc(b, Cac)))*.5
+-        _axpy(-dde_ba, psi, LL0b)
+-        _axpy(-de_a, b, LL0b)
+-        _axpy(-de_b, a, LL0b)
+-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
+-        self._c_vec_conj(t, c_op, La, CLac)
+-        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
+-                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
+-        _axpy(1., CLa, LL0b)
+-        _axpy(-e, La, LL0b)
+-        _axpy(-de_La, psi, LL0b)
+-
+-        # L0Lb = b"ba + b'L0b
+-        _axpy(-dde_ba, psi, L0Lb)
+-        _axpy(-de_a, b, L0Lb)
+-        _axpy(-de_b, a, L0Lb)
+-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
+-        self._c_vec_conj(t, c_op, L0b, CL0bc)
+-        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
+-                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
+-        _axpy(1., CL0b, L0Lb)
+-        _axpy(-e, L0b, L0Lb)
+-        _axpy(-de_L0b, psi, L0Lb)
+-
+-        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
+-        self.d1(t + dt, psi, L0a) # da/dt
+-        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
+-        _axpy(-1.0, a, L0a)        # da/dt
+-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
+-        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
+-        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
+-        _axpy(e * dt, Ca, L0a)              # a'_a_
+-        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
+-        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
+-
+-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+-                                        complex[::1] out,
+-                                        np.ndarray[complex, ndim=1] guess) except *:
+-        # np.ndarray to memoryview is OK but not the reverse
+-        # scipy function only take np array, not memoryview
+-        self.imp_t = t
+-        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
+-                                          tol=self.tol, atol=1e-12)
+-        cdef int i
+-        copy(spout, out)
+-
+-
+-cdef class SMESolver(StochasticSolver):
+-    """stochastic master equation system"""
+-    cdef QobjEvo L
+-    cdef object imp
+-    cdef object c_ops
+-    cdef int N_root
+-    cdef double tol
+-
+-    def set_data(self, sso):
+-        L = sso.LH
+-        c_ops = sso.sops
+-        self.l_vec = L.shape[0]
+-        self.num_ops = len(c_ops)
+-        self.L = L
+-        self.c_ops = []
+-        self.N_root = np.sqrt(self.l_vec)
+-        for i, op in enumerate(c_ops):
+-            self.c_ops.append(op)
+-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+-            self.tol = sso.tol
+-            self.imp = sso.imp
+-
+-    cdef void _normalize_inplace(self, complex[::1] vec):
+-        _normalize_rho(vec)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef complex expect(self, complex[::1] rho):
+-        cdef complex e = 0.
+-        cdef int k
+-        for k in range(self.N_root):
+-            e += rho[k*(self.N_root+1)]
+-        return e
+-
+-    @cython.boundscheck(False)
+-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+-        cdef int i, k
+-        cdef QobjEvo c_op
+-        cdef complex expect
+-        for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
+-            expect = self.expect(out[i,:])
+-            _axpy(-expect, rho, out[i,:])
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+-                          complex[::1] a, complex[:, ::1] b,
+-                          complex[:, :, ::1] Lb, complex[:,::1] La,
+-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+-                          complex[::1] L0a):
+-        """
+-        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
+-        dY ~ a dt + bi dwi
+-                                         deg   use        noise
+-        b[i.:]       bi                   >=0   d2 euler   dwi
+-        a[:]         a                    >=0   d1 euler   dt
+-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
+-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
+-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
+-        La[i,:]      ba'                  >=2   taylor15   dzi
+-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
+-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
+-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
+-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
+-        """
+-        cdef int i, j, k
+-        cdef QobjEvo c_op
+-        cdef QobjEvo c_opj
+-        cdef complex trApp, trAbb, trAa
+-        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
+-        cdef complex[:, ::1] trAb = self.expect_buffer_2d
+-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+-        #_zero(temp)
+-
+-        # a
+-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
+-
+-        # b
+-        for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            # bi
+-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
+-            trAp[i] = self.expect(b[i,:])
+-            _axpy(-trAp[i], rho, b[i,:])
+-
+-        # Libj = bibj', i<=j
+-        # sc_ops must commute (Libj = Ljbi)
+-        if deg >= 1:
+-          for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            for j in range(i, self.num_ops):
+-                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
+-                trAb[i,j] = self.expect(Lb[i,j,:])
+-                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
+-                _axpy(-trAb[i,j], rho, Lb[i,j,:])
+-
+-        # L0b La LLb
+-        if deg >= 2:
+-          for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            # Lia = bia'
+-            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
+-
+-            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
+-            # db/dt
+-            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
+-            trApp = self.expect(L0b[i,:])
+-            _axpy(-trApp, rho, L0b[i,:])
+-            _axpy(-1, b[i,:], L0b[i,:])
+-            # ab'
+-            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
+-            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
+-            trAa = self.expect(temp)
+-            _axpy(1., temp, L0b[i,:])
+-            _axpy(-trAp[i], a[:], L0b[i,:])
+-            _axpy(-trAa, rho, L0b[i,:])
+-            # bbb" : trAb[i,j] only defined for j>=i
+-            for j in range(i):
+-                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
+-            for j in range(i,self.num_ops):
+-                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
+-
+-            # LLb
+-            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
+-            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
+-            for j in range(i,self.num_ops):
+-              for k in range(j,self.num_ops):
+-                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
+-                trAbb = self.expect(LLb[i,j,k,:])
+-                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
+-                _axpy(-trAbb, rho, LLb[i,j,k,:])
+-                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
+-                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
+-
+-        # L0a = a'a + da/dt + bba"/2  (a" = 0)
+-        if deg == 2:
+-            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+-            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
+-            _axpy(-1, a, L0a)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void derivativesO2(self, double t, complex[::1] rho,
+-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+-                            complex[::1] L0a,
+-                            complex[::1] LLa, complex[::1] LL0b,
+-                            complex[::1] L0Lb, complex[::1] LLLb):
+-        """
+-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
+-        Use Stratonovich-Taylor expansion.
+-        One one sc_ops
+-        dY ~ a dt + bi dwi
+-
+-        b[:]     b                        d2 euler    dw
+-        a[:]     a- Lb/2                  d1 euler    dt
+-        Lb[:]    b'b                      milstein    dw^2/2
+-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
+-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
+-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
+-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
+-
+-        LLa[:]   ...                      taylor2.0   dwdt-dz
+-        LL0b[:]  ...                      taylor2.0   dz
+-        L0Lb[:]  ...                      taylor2.0   dw^3/6
+-        LLLb[:]  ...                      taylor2.0   dt^2/2
+-        """
+-        cdef int i, j, k
+-        cdef QobjEvo c_op = self.c_ops[0]
+-        cdef QobjEvo c_opj
+-        cdef complex trAp, trApt
+-        cdef complex trAb, trALb, trALLb
+-        cdef complex trAa, trALa
+-        cdef complex trAL0b
+-
+-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
+-
+-        # b
+-        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
+-        trAp = self.expect(b)
+-        _axpy(-trAp, rho, b)
+-
+-        # Lb = b'b
+-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
+-        trAb = self.expect(Lb)
+-        _axpy(-trAp, b, Lb)
+-        _axpy(-trAb, rho, Lb)
+-
+-        # LLb = b'Lb+b"bb
+-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
+-        trALb = self.expect(LLb)
+-        _axpy(-trAp, Lb, LLb)
+-        _axpy(-trALb, rho, LLb)
+-        _axpy(-trAb*2, b, LLb)
+-
+-        # LLLb = b'LLb + 3 b"bLb + b"'bbb
+-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
+-        trALLb = self.expect(LLLb)
+-        _axpy(-trAp, LLb, LLLb)
+-        _axpy(-trALLb, rho, LLLb)
+-        _axpy(-trALb*3, b, LLLb)
+-        _axpy(-trAb*3, Lb, LLLb)
+-
+-        # _a_ = a - Lb/2
+-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
+-        _axpy(-0.5*self.dt, Lb, a)
+-
+-        # L_a_ = ba' - LLb/2
+-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
+-        _axpy(-0.5*self.dt, LLb, La)
+-
+-        # LL_a_ = b(La)' - LLLb/2
+-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
+-        _axpy(-0.5*self.dt, LLLb, LLa)
+-
+-        # _L0_b = b'(_a_)
+-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
+-        trAa = self.expect(L0b)
+-        _axpy(-trAp, a, L0b)
+-        _axpy(-trAa, rho, L0b)
+-
+-        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
+-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
+-        trAL0b = self.expect(L0Lb)
+-        _axpy(-trAp, L0b, L0Lb)
+-        _axpy(-trAL0b, rho, L0Lb)
+-        _axpy(-trAa, b, L0Lb)
+-        _axpy(-trAb, a, L0Lb)
+-
+-        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
+-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
+-        trAL0b = self.expect(LL0b)
+-        _axpy(-trAp, La, LL0b)
+-        _axpy(-trAL0b, rho, LL0b)
+-        _axpy(-trAa, b, LL0b)
+-        _axpy(-trAb, a, LL0b)
+-
+-        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
+-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+-        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
+-        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
+-        _axpy(-1, a, L0a)
+-        _axpy(-self.dt*0.5, L0Lb, L0a)
+-
+-
+-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+-                                        complex[::1] out,
+-                                        np.ndarray[complex, ndim=1] guess) except *:
+-        # np.ndarray to memoryview is OK but not the reverse
+-        # scipy function only take np array, not memoryview
+-        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
+-                                          dvec, x0=guess,
+-                                          tol=self.tol, atol=1e-12)
+-        cdef int i
+-        copy(spout,out)
+-
+-
+-cdef class PcSSESolver(StochasticSolver):
+-    """photocurrent for Schrodinger equation"""
+-    cdef QobjEvo L
+-    cdef object c_ops
+-    cdef object cdc_ops
+-
+-    def set_data(self, sso):
+-        L = sso.LH
+-        c_ops = sso.sops
+-        self.l_vec = L.shape[0]
+-        self.num_ops = len(c_ops)
+-        self.L = L
+-        self.c_ops = []
+-        self.cdc_ops = []
+-        for i, op in enumerate(c_ops):
+-            self.c_ops.append(op[0])
+-            self.cdc_ops.append(op[1])
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void photocurrent(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        cdef QobjEvo c_op
+-        cdef double rand
+-        cdef int i, which = -1
+-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+-        cdef complex[::1] d2 = self.buffer_1d[0,:]
+-
+-        copy(vec, out)
+-        self.d1(t, vec, out)
+-        rand = np.random.rand()
+-        for i in range(self.num_ops):
+-            c_op = self.cdc_ops[i]
+-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
+-            if expects[i].real * dt >= 1e-15:
+-                rand -= expects[i].real *dt
+-            if rand < 0:
+-                which = i
+-                noise[i] = 1.
+-                break
+-
+-        if which >= 0:
+-            self.collapse(t, which, expects[which].real, vec, d2)
+-            _axpy(1, d2, out)
+-            _axpy(-1, vec, out)
+-
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        cdef QobjEvo c_op
+-        cdef double expect
+-        cdef int i, which=0, num_coll=0, did_collapse=0
+-        cdef complex[::1] tmp = self.buffer_1d[0,:]
+-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+-        cdef np.ndarray[int, ndim=1] colls
+-
+-        # Collapses are computed first
+-        for i in range(self.num_ops):
+-            c_op = self.cdc_ops[i]
+-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
+-            if expects[i].real > 0:
+-                did_collapse = np.random.poisson(expects[i].real * dt)
+-                num_coll += did_collapse
+-                if did_collapse:
+-                    which = i
+-                noise[i] = did_collapse * 1.
+-            else:
+-                noise[i] = 0.
+-
+-        if num_coll == 0:
+-            pass
+-        elif num_coll == 1:
+-            # Do one collapse
+-            self.collapse(t, which, expects[which].real, vec, out)
+-            copy(out, vec)
+-        elif num_coll and noise[which] == num_coll:
+-            # Do many collapse of one sc_ops.
+-            # Recompute the expectation value, but only to check for zero.
+-            c_op = self.cdc_ops[which]
+-            for i in range(num_coll):
+-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+-                if expect * dt >= 1e-15:
+-                    self.collapse(t, which, expect, vec, out)
+-                    copy(out,vec)
+-        elif num_coll >= 2:
+-            # 2 or more collapses of different operators
+-            # Ineficient, should be rare
+-            coll = []
+-            for i in range(self.num_ops):
+-                coll += [i]*int(noise[i])
+-            np.random.shuffle(coll)
+-            for i in coll:
+-                c_op = self.cdc_ops[i]
+-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+-                if expect * dt >= 1e-15:
+-                    self.collapse(t, i, expect, vec, out)
+-                    copy(out,vec)
+-        copy(vec,tmp)
+-        copy(vec,out)
+-        self.d1(t, vec, tmp)
+-        self.d1(t+dt, tmp, out)
+-        _scale(0.5, out)
+-        _axpy(0.5, tmp, out)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+-        cdef int i
+-        cdef complex e
+-        cdef QobjEvo c_op
+-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+-        for i in range(self.num_ops):
+-            _zero(temp)
+-            c_op = self.c_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
+-            e = _dznrm2(temp)
+-            _axpy(0.5 * e * e * self.dt, vec, out)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+-        cdef int i
+-        cdef QobjEvo c_op
+-        cdef complex expect
+-        for i in range(self.num_ops):
+-            c_op = self.c_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
+-            expect = _dznrm2(out[i,:])
+-            if expect.real >= 1e-15:
+-                _zscale(1/expect, out[i,:])
+-            else:
+-                _zero(out[i,:])
+-            _axpy(-1, vec, out[i,:])
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void collapse(self, double t, int which, double expect,
+-                       complex[::1] vec, complex[::1] out):
+-        cdef QobjEvo c_op
+-        c_op = self.c_ops[which]
+-        _zero(out)
+-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+-        _zscale(1/expect, out)
+-
+-
+-cdef class PcSMESolver(StochasticSolver):
+-    """photocurrent for master equation"""
+-    cdef QobjEvo L
+-    cdef object cdcr_cdcl_ops
+-    cdef object cdcl_ops
+-    cdef object clcdr_ops
+-    cdef int N_root
+-
+-    def set_data(self, sso):
+-        L = sso.LH
+-        c_ops = sso.sops
+-        self.l_vec = L.shape[0]
+-        self.num_ops = len(c_ops)
+-        self.L = L
+-        self.cdcr_cdcl_ops = []
+-        self.cdcl_ops = []
+-        self.clcdr_ops = []
+-        self.N_root = np.sqrt(self.l_vec)
+-        for i, op in enumerate(c_ops):
+-            self.cdcr_cdcl_ops.append(op[0])
+-            self.cdcl_ops.append(op[1])
+-            self.clcdr_ops.append(op[2])
+-
+-    cdef void _normalize_inplace(self, complex[::1] vec):
+-        _normalize_rho(vec)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void photocurrent(self, double t, double dt,  double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        cdef QobjEvo c_op
+-        cdef double rand
+-        cdef int i, which = -1
+-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+-        cdef complex[::1] d2 = self.buffer_1d[0,:]
+-
+-        copy(vec, out)
+-        self.d1(t, vec, out)
+-        rand = np.random.rand()
+-        for i in range(self.num_ops):
+-            c_op = self.clcdr_ops[i]
+-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
+-            if expects[i].real * dt >= 1e-15:
+-                rand -= expects[i].real *dt
+-            if rand < 0:
+-                which = i
+-                noise[i] = 1.
+-                break
+-
+-        if which >= 0:
+-            self.collapse(t, which, expects[which].real, vec, d2)
+-            _axpy(1, d2, out)
+-            _axpy(-1, vec, out)
+-
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        cdef QobjEvo c_op
+-        cdef int i, which, num_coll=0, did_collapse
+-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+-        cdef complex[::1] tmp = self.buffer_1d[0,:]
+-        cdef double expect
+-        cdef np.ndarray[int, ndim=1] colls
+-
+-        # Collapses are computed first
+-        for i in range(self.num_ops):
+-            c_op = self.clcdr_ops[i]
+-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
+-            if expects[i].real > 0:
+-                did_collapse = np.random.poisson(expects[i].real* dt)
+-                num_coll += did_collapse
+-                if did_collapse:
+-                    which = i
+-                noise[i] = did_collapse * 1.
+-            else:
+-                noise[i] = 0.
+-
+-        if num_coll == 0:
+-            pass
+-        elif num_coll == 1:
+-            # Do one collapse
+-            self.collapse(t, which, expects[which].real, vec, out)
+-            copy(out,vec)
+-        elif noise[which] == num_coll:
+-            # Do many collapse of one sc_ops.
+-            # Recompute the expectation value, but only to check for zero.
+-            c_op = self.clcdr_ops[which]
+-            for i in range(num_coll):
+-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+-                if expect * dt >= 1e-15:
+-                    self.collapse(t, which, expect, vec, out)
+-                    copy(out,vec)
+-        elif num_coll >= 2:
+-            # 2 or more collapses of different operators
+-            # Ineficient, should be rare
+-            coll = []
+-            for i in range(self.num_ops):
+-                coll += [i] * int(noise[i])
+-            np.random.shuffle(coll)
+-            for i in coll:
+-                c_op = self.clcdr_ops[i]
+-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+-                if expect * dt >= 1e-15:
+-                    self.collapse(t, i, expect, vec, out)
+-                    copy(out,vec)
+-
+-        copy(vec,tmp)
+-        copy(vec,out)
+-        self.d1(t, vec, tmp)
+-        self.d1(t+dt, tmp, out)
+-        _scale(0.5, out)
+-        _axpy(0.5, tmp, out)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef complex expect(self, complex[::1] rho):
+-        cdef complex e = 0.
+-        cdef int k
+-        for k in range(self.N_root):
+-            e += rho[k*(self.N_root+1)]
+-        return e
+-
+-    @cython.boundscheck(False)
+-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+-        cdef int i
+-        cdef QobjEvo c_op
+-        cdef complex[::1] crho = self.func_buffer_1d[0,:]
+-        cdef complex expect
+-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
+-        for i in range(self.num_ops):
+-            c_op = self.cdcr_cdcl_ops[i]
+-            _zero(crho)
+-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
+-            expect = self.expect(crho)
+-            _axpy(0.5*expect* self.dt, rho, out)
+-            _axpy(-0.5* self.dt, crho, out)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+-        cdef int i
+-        cdef QobjEvo c_op
+-        cdef complex expect
+-        for i in range(self.num_ops):
+-            c_op = self.clcdr_ops[i]
+-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
+-            expect = self.expect(out[i,:])
+-            if expect.real >= 1e-15:
+-                _zscale((1.+0j)/expect, out[i,:])
+-            else:
+-                _zero(out[i,:])
+-            _axpy(-1, rho, out[i,:])
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef void collapse(self, double t, int which, double expect,
+-                       complex[::1] vec, complex[::1] out):
+-        cdef QobjEvo c_op
+-        c_op = self.clcdr_ops[which]
+-        _zero(out)
+-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+-        _zscale(1./expect, out)
+-
+-cdef class PmSMESolver(StochasticSolver):
+-    """positive map for master equation"""
+-    cdef object L
+-    cdef QobjEvo pp_ops
+-    cdef QobjEvo preLH
+-    cdef QobjEvo postLH
+-    cdef object sops
+-    cdef object preops
+-    cdef object postops
+-    cdef object preops2
+-    cdef object postops2
+-    cdef int N_root
+-
+-    def set_data(self, sso):
+-        c_ops = sso.sops
+-        self.l_vec = sso.pp.shape[0]
+-        self.num_ops = len(c_ops)
+-        self.preLH = sso.preLH
+-        self.postLH = sso.postLH
+-        self.pp_ops = sso.pp
+-        self.sops = [op for op in sso.sops]
+-        self.preops = [op for op in sso.preops]
+-        self.postops = [op for op in sso.postops]
+-        self.preops2 = [op for op in sso.preops2]
+-        self.postops2 = [op for op in sso.postops2]
+-        self.N_root = np.sqrt(self.l_vec)
+-
+-    cdef void _normalize_inplace(self, complex[::1] vec):
+-        _normalize_rho(vec)
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    cdef void rouchon(self, double t, double dt, double[:] noise,
+-                           complex[::1] vec, complex[::1] out):
+-        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
+-        cdef complex[::1] temp = self.buffer_1d[0,:]
+-        cdef complex[::1] temp2 = self.buffer_1d[1,:]
+-        cdef int i, j, k
+-        cdef QobjEvo c_op, c_opj
+-        cdef complex ddw, tr
+-        _zero(out)
+-        _zero(temp)
+-        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
+-        for i in range(self.num_ops):
+-            c_op = self.sops[i]
+-            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
+-            c_op = self.preops[i]
+-            _zero(temp2)
+-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
+-            _axpy(dy[i], temp2, temp)
+-
+-        k = 0
+-        for i in range(self.num_ops):
+-            for j in range(i, self.num_ops):
+-                c_op = self.preops2[k]
+-                if i == j:
+-                    ddw = (dy[i]*dy[j] - dt) *0.5
+-                else:
+-                    ddw = (dy[i]*dy[j])
+-
+-                _zero(temp2)
+-                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
+-                _axpy(ddw, temp2, temp)
+-                k += 1
+-
+-        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
+-        for i in range(self.num_ops):
+-            dy[i] = conj(dy[i])
+-            c_op = self.postops[i]
+-            _zero(temp2)
+-            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+-            _axpy(dy[i], temp2, out)
+-
+-        k = 0
+-        for i in range(self.num_ops):
+-            for j in range(i, self.num_ops):
+-                c_op = self.postops2[k]
+-                if i == j:
+-                    ddw = (dy[i]*dy[j] - dt) *0.5
+-                else:
+-                    ddw = (dy[i]*dy[j])
+-                _zero(temp2)
+-                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+-                _axpy(ddw, temp2, out)
+-                k += 1
+-
+-        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+-        tr = self.expect(out)
+-        _zscale(1./tr, out)
+-
+-
+-    @cython.boundscheck(False)
+-    @cython.wraparound(False)
+-    @cython.cdivision(True)
+-    cdef complex expect(self, complex[::1] rho):
+-        cdef complex e = 0.
+-        cdef int k
+-        for k in range(self.N_root):
+-            e += rho[k*(self.N_root+1)]
+-        return e
+-
+-
+-cdef class GenericSSolver(StochasticSolver):
+-    """support for user defined system"""
+-    cdef object d1_func, d2_func
+-
+-    def set_data(self, sso):
+-        self.l_vec = sso.rho0.shape[0]
+-        self.num_ops = len(sso.sops)
+-        self.d1_func = sso.d1
+-        self.d2_func = sso.d2
+-
+-
+-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+-        cdef np.ndarray[complex, ndim=1] in_np
+-        cdef np.ndarray[complex, ndim=1] out_np
+-        in_np = np.zeros((self.l_vec, ), dtype=complex)
+-        copy(rho, in_np)
+-        out_np = self.d1_func(t, in_np)
+-        _axpy(self.dt, out_np, out) # d1 is += and * dt
+-
+-    @cython.boundscheck(False)
+-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+-        cdef np.ndarray[complex, ndim=1] in_np
+-        cdef np.ndarray[complex, ndim=2] out_np
+-        cdef int i
+-        in_np = np.zeros((self.l_vec, ), dtype=complex)
+-        copy(rho, in_np)
+-        out_np = self.d2_func(t, in_np)
+-        for i in range(self.num_ops):
+-            copy(out_np[i,:], out[i,:])
++#cython: language_level=3
++
++import numpy as np
++cimport numpy as np
++cimport cython
++from cpython.exc cimport PyErr_CheckSignals
++from libc.math cimport fabs
++from qutip.core.cy.qobjevo cimport QobjEvo
++from .. import Qobj, unstack_columns
++import scipy.sparse as sp
++from scipy.sparse.linalg import LinearOperator
++from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
++from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
++
++from qutip.core.data cimport dense, Dense
++import qutip.core.data as _data
++
++cdef extern from "<complex>" namespace "std" nogil:
++    double complex conj(double complex x)
++
++cdef int ZERO=0
++cdef double DZERO=0
++cdef complex ZZERO=0j
++cdef int ONE=1
++
++"""Some of blas wrapper"""
++@cython.boundscheck(False)
++cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
++    """ y += a*x"""
++    cdef int l = x.shape[0]
++    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
++
++@cython.boundscheck(False)
++cdef void copy(complex[::1] x, complex[::1] y):
++    """ y = x """
++    cdef int l = x.shape[0]
++    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
++
++@cython.boundscheck(False)
++cdef complex _dot(complex[::1] x, complex[::1] y):
++    """ = x_i * y_i """
++    cdef int l = x.shape[0]
++    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
++
++@cython.boundscheck(False)
++cdef complex _dotc(complex[::1] x, complex[::1] y):
++    """ = conj(x_i) * y_i """
++    cdef int l = x.shape[0]
++    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
++
++@cython.boundscheck(False)
++cdef double _dznrm2(complex[::1] vec):
++    """ = sqrt( x_i**2 ) """
++    cdef int l = vec.shape[0]
++    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
++
++@cython.boundscheck(False)
++cdef void _scale(double a, complex[::1] x):
++    """ x *= a """
++    cdef int l = x.shape[0]
++    zdscal(&l, &a, <complex*>&x[0], &ONE)
++
++@cython.boundscheck(False)
++cdef void _zscale(complex a, complex[::1] x):
++    """ x *= a """
++    cdef int l = x.shape[0]
++    zscal(&l, &a, <complex*>&x[0], &ONE)
++
++@cython.boundscheck(False)
++cdef void _zero(complex[::1] x):
++    """ x *= 0 """
++    cdef int l = x.shape[0]
++    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
++
++@cython.boundscheck(False)
++cdef void _zero_2d(complex[:,::1] x):
++    """ x *= 0 """
++    cdef int l = x.shape[0]*x.shape[1]
++    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
++
++@cython.boundscheck(False)
++cdef void _zero_3d(complex[:,:,::1] x):
++    """ x *= 0 """
++    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
++    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
++
++@cython.boundscheck(False)
++cdef void _zero_4d(complex[:,:,:,::1] x):
++    """ x *= 0 """
++    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
++    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
++
++@cython.boundscheck(False)
++@cython.initializedcheck(False)
++cdef Dense _dense_wrap(double complex [::1] x):
++    return dense.wrap(&x[0], x.shape[0], 1)
++
++# %%%%%%%%%%%%%%%%%%%%%%%%%
++# functions for ensuring that the states stay physical
++@cython.cdivision(True)
++@cython.boundscheck(False)
++cdef void _normalize_inplace(complex[::1] vec):
++    """ make norm of vec equal to 1"""
++    cdef int l = vec.shape[0]
++    cdef double norm = 1.0/_dznrm2(vec)
++    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
++
++# to move eventually, 10x faster than scipy's norm.
++@cython.cdivision(True)
++@cython.boundscheck(False)
++def normalize_inplace(complex[::1] vec):
++    """ make norm of vec equal to 1"""
++    cdef int l = vec.shape[0]
++    cdef double norm = 1.0/_dznrm2(vec)
++    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
++    return fabs(norm-1)
++
++@cython.cdivision(True)
++@cython.boundscheck(False)
++cdef void _normalize_rho(complex[::1] rho):
++    """ Ensure that the density matrix trace is one and
++    that the composing states are normalized.
++    """
++    cdef int l = rho.shape[0]
++    cdef int N = np.sqrt(l)
++    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
++    cdef complex[::1,:] eivec
++    cdef double[::1] eival = np.zeros(N)
++    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
++
++    _zero(rho)
++    cdef int i, j, k
++    cdef double sum
++
++    sum = 0.
++    for i in range(N):
++        _normalize_inplace(eivec[:,i])
++        if eival[i] < 0:
++            eival[i] = 0.
++        sum += eival[i]
++    if sum != 1.:
++        for i in range(N):
++            eival[i] /= sum
++
++    for i in range(N):
++        for j in range(N):
++            for k in range(N):
++                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
++
++# Available solvers:
++cpdef enum Solvers:
++  # order 0.5
++  EULER_SOLVER           =  50
++  # order 0.5 strong, 1.0 weak?
++  PC_SOLVER              = 101
++  PC_2_SOLVER            = 104
++  # order 1.0
++  PLATEN_SOLVER          = 100
++  MILSTEIN_SOLVER        = 102
++  MILSTEIN_IMP_SOLVER    = 103
++  # order 1.5
++  EXPLICIT1_5_SOLVER     = 150
++  TAYLOR1_5_SOLVER       = 152
++  TAYLOR1_5_IMP_SOLVER   = 153
++  # order 2.0
++  TAYLOR2_0_SOLVER       = 202
++
++  # Special solvers
++  PHOTOCURRENT_SOLVER    =  60
++  PHOTOCURRENT_PC_SOLVER = 110
++  ROUCHON_SOLVER         = 120
++
++  # For initialisation
++  SOLVER_NOT_SET         =   0
++
++
++cdef class TaylorNoise:
++    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
++    Complex enough that I fell it should be kept separated from the main solver.
++    """
++    cdef:
++      int p
++      double rho, alpha
++      double aFactor, bFactor
++      double BFactor, CFactor
++      double dt, dt_sqrt
++
++    @cython.cdivision(True)
++    def __init__(self, int p, double dt):
++        self.p = p
++        self.dt = dt
++        self.dt_sqrt = dt**.5
++        cdef double pi = np.pi
++        cdef int i
++
++        cdef double rho = 0.
++        for i in range(1,p+1):
++            rho += (i+0.)**-2
++        rho = 1./3.-2*rho/(pi**2)
++        self.rho = (rho)**.5
++        self.aFactor = -(2)**.5/pi
++
++        cdef double alpha = 0.
++        for i in range(1,p+1):
++            alpha += (i+0.)**-4
++        alpha = pi/180-alpha/(2*pi**2)/pi
++        self.alpha = (alpha)**.5
++        self.bFactor = (0.5)**.5/pi**2
++
++        self.BFactor = 1/(4*pi**2)
++        self.CFactor = -1/(2*pi**2)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cpdef void order2(self, double[::1] noise, double[::1] dws):
++        cdef int p = self.p
++        cdef int r, l
++        cdef double s = 1/6.
++        cdef double a = 0
++        cdef double b = 0
++        cdef double AA = 0
++        cdef double BB = 0
++        cdef double CC = 0
++
++        for r in range(p):
++            a += noise[3+r]/(r+1.)
++            b += noise[3+r+p]/(r+1.)/(r+1.)
++            BB += (1/(r+1.)/(r+1.)) *\
++                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
++            for l in range(p):
++                if r != l:
++                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
++                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
++                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
++
++        a = self.aFactor * a + self.rho * noise[1]
++        b = self.bFactor * b + self.alpha * noise[2]
++        AA = 0.25*a*a
++        BB *= self.BFactor
++        CC *= self.CFactor
++
++        dws[0] = noise[0]                       # dw
++        dws[1] = 0.5*(noise[0]+a)               # dz
++        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
++        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
++        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
++
++
++cdef class StochasticSolver:
++    """ stochastic solver class base
++    Does most of the initialisation, drive the simulation and contain the
++    stochastic integration algorythm that do not depend on the physics.
++
++    This class is not to be used as is, the function computing the evolution's
++    derivative are specified in it's child class which define the deterministic
++    and stochastic contributions.
++
++    PYTHON METHODS:
++    set_solver:
++      Receive the data for the integration.
++      Prepare buffers
++
++    cy_sesolve_single_trajectory:
++      Run one trajectory.
++
++
++    INTERNAL METHODS
++    make_noise:
++      create the stochastic noise
++    run:
++      evolution between timestep (substep)
++    solver's method:
++      stochastic integration algorithm
++        euler
++        milstein
++        taylor
++        ...
++
++    CHILD:
++    SSESolver: stochastic schrodinger evolution
++    SMESolver: stochastic master evolution
++    PcSSESolver: photocurrent stochastic schrodinger evolution
++    PcSMESolver: photocurrent stochastic master evolution
++    PmSMESolver: positive map stochastic master evolution
++    GenericSSolver: general (user defined) stochastic evolution
++
++    CHILD METHODS:
++    set_data:
++      Read data about the system
++    d1:
++      deterministic part
++    d2:
++      non-deterministic part
++    derivatives:
++      d1, d2 and their derivatives up to dt**1.5
++      multiple sc_ops
++    derivativesO2:
++      d1, d2 and there derivatives up to dt**2.0
++      one sc_ops
++    """
++    cdef int l_vec, num_ops
++    cdef Solvers solver
++    cdef int num_step, num_substeps, num_dw
++    cdef int normalize
++    cdef double dt
++    cdef int noise_type
++    cdef object custom_noise
++    cdef double[::1] dW_factor
++    cdef unsigned int[::1] seed
++    cdef object sso
++
++    # buffer to not redo the initialisation at each substep
++    cdef complex[:, ::1] buffer_1d
++    cdef complex[:, :, ::1] buffer_2d
++    cdef complex[:, :, :, ::1] buffer_3d
++    cdef complex[:, :, :, ::1] buffer_4d
++    cdef complex[:, ::1] expect_buffer_1d
++    cdef complex[:, ::1] expect_buffer_2d
++    cdef complex[:, :, ::1] expect_buffer_3d
++    cdef complex[:, ::1] func_buffer_1d
++    cdef complex[:, ::1] func_buffer_2d
++    cdef complex[:, :, ::1] func_buffer_3d
++
++    cdef TaylorNoise order2noise
++
++    def __init__(self):
++        self.l_vec = 0
++        self.num_ops = 0
++        self.solver = SOLVER_NOT_SET
++
++    def set_solver(self, sso):
++        """ Prepare the solver from the info in StochasticSolverOptions
++
++        Parameters
++        ----------
++        sso : StochasticSolverOptions
++            Data of the stochastic system
++        """
++        self.set_data(sso)
++        self.sso = sso
++
++        self.solver = sso.solver_code
++        self.dt = sso.dt
++        self.num_substeps = sso.nsubsteps
++        self.normalize = sso.normalize
++        self.num_step = len(sso.times)
++        self.num_dw = len(sso.sops)
++        if self.solver in [EXPLICIT1_5_SOLVER,
++                           TAYLOR1_5_SOLVER,
++                           TAYLOR1_5_IMP_SOLVER]:
++            self.num_dw *= 2
++        if self.solver in [TAYLOR2_0_SOLVER]:
++            self.num_dw *= 3 + 2*sso.p
++            self.order2noise = TaylorNoise(sso.p, self.dt)
++        # prepare buffers for the solvers
++        nb_solver = [0,0,0,0]
++        nb_func = [0,0,0]
++        nb_expect = [0,0,0]
++
++        # %%%%%%%%%%%%%%%%%%%%%%%%%
++        # Depending on the solver, determine the numbers of buffers of each
++        # shape to prepare. (~30% slower when not preallocating buffer)
++        # nb_solver : buffer to contain the states used by solver
++        # nb_func : buffer for states used used by d1, d2 and derivative functions
++        # nb_expect : buffer to store expectation values.
++        if self.solver is EULER_SOLVER:
++            nb_solver = [0,1,0,0]
++        elif self.solver is PHOTOCURRENT_SOLVER:
++            nb_solver = [1,0,0,0]
++            nb_func = [1,0,0]
++        elif self.solver is PLATEN_SOLVER:
++            nb_solver = [2,5,0,0]
++        elif self.solver is PC_SOLVER:
++            nb_solver = [4,1,1,0]
++        elif self.solver is MILSTEIN_SOLVER:
++            nb_solver = [0,1,1,0]
++        elif self.solver is MILSTEIN_IMP_SOLVER:
++            nb_solver = [1,1,1,0]
++        elif self.solver is PC_2_SOLVER:
++            nb_solver = [5,1,1,0]
++        elif self.solver is PHOTOCURRENT_PC_SOLVER:
++            nb_solver = [1,1,0,0]
++            nb_func = [1,0,0]
++        elif self.solver is ROUCHON_SOLVER:
++            nb_solver = [2,0,0,0]
++        elif self.solver is EXPLICIT1_5_SOLVER:
++            nb_solver = [5,8,3,0]
++        elif self.solver is TAYLOR1_5_SOLVER:
++            nb_solver = [2,3,1,1]
++        elif self.solver is TAYLOR1_5_IMP_SOLVER:
++            nb_solver = [2,3,1,1]
++        elif self.solver is TAYLOR2_0_SOLVER:
++            nb_solver = [11,0,0,0]
++
++        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
++                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
++          if sso.me:
++            nb_func = [1,0,0]
++            nb_expect = [1,1,0]
++          else:
++            nb_func = [2,1,1]
++            nb_expect = [2,1,1]
++        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
++            nb_expect = [1,0,0]
++        elif self.solver is TAYLOR2_0_SOLVER:
++          if sso.me:
++            nb_func = [2,0,0]
++            nb_expect = [2,0,0]
++          else:
++            nb_func = [14,0,0]
++            nb_expect = [0,0,0]
++        elif self.solver is ROUCHON_SOLVER:
++            nb_expect = [1,0,0]
++        else:
++          if not sso.me:
++            nb_func = [1,0,0]
++
++        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
++        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
++                                  dtype=complex)
++        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
++                                        dtype=complex)
++        if nb_solver[3]:
++          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
++                                        dtype=complex)
++
++        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
++        if nb_expect[1]:
++          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
++        if nb_expect[2]:
++          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
++
++        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
++        if nb_func[1]:
++          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
++        if nb_func[2]:
++          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
++
++        self.noise_type = sso.noise_type
++        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
++        if self.noise_type == 1:
++            self.custom_noise = sso.noise
++        elif self.noise_type == 0:
++            self.seed = sso.noise
++
++    def set_data(self, sso):
++        """Set solver specific operator"""
++        pass
++
++    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
++        """Create the random numbers for the stochastic process"""
++        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
++            # photocurrent, just seed,
++            np.random.seed(self.seed[n])
++            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
++        if self.noise_type == 0:
++            np.random.seed(self.seed[n])
++            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
++                                   np.sqrt(self.dt)
++        elif self.noise_type == 1:
++            return self.custom_noise[n,:,:,:]
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    def cy_sesolve_single_trajectory(self, int n):
++        """ Run the one of the trajectories of the stochastic system.
++
++        Parameters
++        ----------
++        n : int
++            Number of the iterations
++
++        sso : StochasticSolverOptions
++            Data of the stochastic system
++
++        Returns
++        -------
++        states_list : list of qobj
++            State of the system at each time
++
++        noise : array
++            noise at each step of the solver
++
++        measurements : array
++            measurements value at each timestep for each m_ops
++
++        expect : array
++            expectation value at each timestep for each e_ops
++
++        """
++        sso = self.sso
++        cdef double[::1] times = sso.times
++        cdef complex[::1] rho_t
++        cdef double t
++        cdef int m_idx, t_idx, e_idx
++        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
++        cdef int tlast = times.shape[0]
++
++        rho_t = sso.rho0.copy()
++        dims = sso.state0.dims
++
++        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
++        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
++        states_list = []
++        for t_idx, t in enumerate(times):
++            PyErr_CheckSignals()
++            if sso.ce_ops:
++                for e_idx, e in enumerate(sso.ce_ops):
++                    s = e.expect_data(t, _dense_wrap(rho_t))
++                    expect[e_idx, t_idx] = s
++            if sso.store_states or not sso.ce_ops:
++                if sso.me:
++                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
++                        dims=dims))
++                else:
++                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
++
++            if t_idx != tlast-1:
++                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
++                                 rho_t, self.num_substeps)
++
++            if sso.store_measurement:
++                for m_idx, m in enumerate(sso.cm_ops):
++                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
++                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
++                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
++
++        if sso.method == 'heterodyne':
++            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
++
++        return states_list, noise, measurements, expect
++
++    @cython.boundscheck(False)
++    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
++                          complex[::1] vec, int num_substeps):
++        """ Do one time full step"""
++        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
++        cdef int i
++        if self.solver is EULER_SOLVER:
++            for i in range(num_substeps):
++                self.euler(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is PHOTOCURRENT_SOLVER:
++            for i in range(num_substeps):
++                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is PLATEN_SOLVER:
++            for i in range(num_substeps):
++                self.platen(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is PC_SOLVER:
++            for i in range(num_substeps):
++                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is MILSTEIN_SOLVER:
++            for i in range(num_substeps):
++                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is MILSTEIN_IMP_SOLVER:
++            for i in range(num_substeps):
++                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is PC_2_SOLVER:
++            for i in range(num_substeps):
++                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is PHOTOCURRENT_PC_SOLVER:
++            for i in range(num_substeps):
++                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is ROUCHON_SOLVER:
++            for i in range(num_substeps):
++                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is EXPLICIT1_5_SOLVER:
++            for i in range(num_substeps):
++                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is TAYLOR1_5_SOLVER:
++            for i in range(num_substeps):
++                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is TAYLOR1_5_IMP_SOLVER:
++            for i in range(num_substeps):
++                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        elif self.solver is TAYLOR2_0_SOLVER:
++            for i in range(num_substeps):
++                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
++                out, vec = vec, out
++
++        if self.normalize:
++            self._normalize_inplace(vec)
++        return vec
++
++    cdef void _normalize_inplace(self, complex[::1] vec):
++        _normalize_inplace(vec)
++
++    # Dummy functions
++    # Needed for compilation since ssesolve is not stand-alone
++    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
++        """ deterministic part of the evolution
++        depend on schrodinger vs master vs photocurrent
++        """
++        pass
++
++    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
++        """ stochastic part of the evolution
++        depend on schrodinger vs master vs photocurrent
++        """
++        pass
++
++    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
++                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
++        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
++        pass
++
++    cdef void derivatives(self, double t, int deg, complex[::1] rho,
++                              complex[::1] a, complex[:, ::1] b,
++                              complex[:, :, ::1] Lb, complex[:,::1] La,
++                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
++                              complex[::1] L0a):
++        """ Obtain the multiple terms for stochastic taylor expension
++        Up to order 1.5
++        multiple sc_ops
++        """
++        pass
++
++    cdef void derivativesO2(self, double t, complex[::1] rho,
++                            complex[::1] a, complex[::1] b, complex[::1] Lb,
++                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
++                            complex[::1] L0a,
++                            complex[::1] LLa, complex[::1] LL0b,
++                            complex[::1] L0Lb, complex[::1] LLLb):
++        """ Obtain the multiple terms for stochastic taylor expension
++        Up to order 2.0
++        One sc_ops
++        """
++        pass
++
++    cdef void photocurrent(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        """Special integration scheme:
++        photocurrent collapse + euler evolution
++        """
++        pass
++
++    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        """Special integration scheme:
++        photocurrent collapse + predictor-corrector evolution
++        """
++        pass
++
++    cdef void rouchon(self, double t, double dt, double[:] noise,
++                      complex[::1] vec, complex[::1] out):
++        """Special integration scheme:
++        Force valid density matrix using positive map
++        Pierre Rouchon, Jason F. Ralph
++        arXiv:1410.5345 [quant-ph]
++        """
++        pass
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void euler(self, double t, double dt, double[:] noise,
++                    complex[::1] vec, complex[::1] out):
++        """Integration scheme:
++        Basic Euler order 0.5
++        dV = d1 dt + d2_i dW_i
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        cdef int i, j
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        _zero_2d(d2)
++        copy(vec, out)
++        self.d1(t, vec, out)
++        self.d2(t, vec, d2)
++        for i in range(self.num_ops):
++            _axpy(noise[i], d2[i,:], out)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void platen(self, double t, double dt, double[:] noise,
++                       complex[::1] vec, complex[::1] out):
++        """
++        Platen rhs function for both master eq and schrodinger eq.
++        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
++             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
++             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
++
++        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
++        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
++        The Theory of Open Quantum Systems
++        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
++        """
++        cdef int i, j, k
++        cdef double sqrt_dt = np.sqrt(dt)
++        cdef double sqrt_dt_inv = 0.25/sqrt_dt
++        cdef double dw, dw2
++        cdef complex[::1] d1 = self.buffer_1d[0,:]
++        cdef complex[::1] Vt = self.buffer_1d[1,:]
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
++        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
++        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
++        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
++        _zero(d1)
++        _zero_2d(d2)
++
++        self.d1(t, vec, d1)
++        self.d2(t, vec, d2)
++        _axpy(1.0,vec,d1)
++        copy(d1,Vt)
++        copy(d1,out)
++        _scale(0.5,out)
++        for i in range(self.num_ops):
++            copy(d1,Vp[i,:])
++            copy(d1,Vm[i,:])
++            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
++            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
++            _axpy(noise[i],d2[i,:],Vt)
++        _zero(d1)
++        self.d1(t, Vt, d1)
++        _axpy(0.5,d1,out)
++        _axpy(0.5,vec,out)
++        for i in range(self.num_ops):
++            _zero_2d(d2p)
++            _zero_2d(d2m)
++            self.d2(t, Vp[i,:], d2p)
++            self.d2(t, Vm[i,:], d2m)
++            dw = noise[i] * 0.25
++            _axpy(dw,d2m[i,:],out)
++            _axpy(2*dw,d2[i,:],out)
++            _axpy(dw,d2p[i,:],out)
++            for j in range(self.num_ops):
++                if i == j:
++                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
++                else:
++                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
++                _axpy(dw2,d2p[j,:],out)
++                _axpy(-dw2,d2m[j,:],out)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void pred_corr(self, double t, double dt, double[:] noise,
++                    complex[::1] vec, complex[::1] out):
++        """
++        Chapter 15.5 Eq. (5.4)
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        # a=0. b=0.5
++        cdef double dt_2 = dt*0.5
++        cdef complex[::1] euler = self.buffer_1d[0,:]
++        cdef complex[::1] a_pred = self.buffer_1d[1,:]
++        cdef complex[::1] b_pred = self.buffer_1d[2,:]
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
++        _zero(a_pred)
++        _zero(b_pred)
++        _zero_2d(d2)
++        _zero_3d(dd2)
++        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
++        copy(vec, euler)
++        copy(vec, out)
++        _axpy(1.0, a_pred, euler)
++        for i in range(self.num_ops):
++            _axpy(noise[i], d2[i,:], b_pred)
++            _axpy(-dt_2, dd2[i,i,:], a_pred)
++        _axpy(1.0, a_pred, out)
++        _axpy(1.0, b_pred, euler)
++        _axpy(0.5, b_pred, out)
++        _zero_2d(d2)
++        self.d2(t + dt, euler, d2)
++        for i in range(self.num_ops):
++            _axpy(noise[i]*0.5, d2[i,:], out)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
++                    complex[::1] vec, complex[::1] out):
++        """
++        Chapter 15.5 Eq. (5.4)
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        # a=0.5, b=0.5
++        cdef int i, j, k
++        cdef complex[::1] euler = self.buffer_1d[0,:]
++        cdef complex[::1] a_pred = self.buffer_1d[1,:]
++        _zero(a_pred)
++        cdef complex[::1] a_corr = self.buffer_1d[2,:]
++        _zero(a_corr)
++        cdef complex[::1] b_pred = self.buffer_1d[3,:]
++        _zero(b_pred)
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        _zero_2d(d2)
++        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
++        _zero_3d(dd2)
++
++        cdef double dt_2 = dt*0.5
++        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
++        copy(vec, euler)
++        _axpy(1.0, a_pred, euler)
++        for i in range(self.num_ops):
++            _axpy(noise[i], d2[i,:], b_pred)
++            _axpy(-dt_2, dd2[i,i,:], a_pred)
++        _axpy(1.0, b_pred, euler)
++        copy(vec, out)
++        _axpy(0.5, a_pred, out)
++        _axpy(0.5, b_pred, out)
++        _zero_2d(d2)
++        _zero_3d(dd2)
++        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
++        for i in range(self.num_ops):
++            _axpy(noise[i]*0.5, d2[i,:], out)
++            _axpy(-dt_2, dd2[i,i,:], a_corr)
++        _axpy(0.5, a_corr, out)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void milstein(self, double t, double dt, double[:] noise,
++                    complex[::1] vec, complex[::1] out):
++        """
++        Chapter 10.3 Eq. (3.1)
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++
++        dV = -iH*V*dt + d1*dt + d2_i*dW_i
++             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
++        """
++        cdef int i, j, k
++        cdef double dw
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
++        _zero_2d(d2)
++        _zero_3d(dd2)
++        copy(vec,out)
++        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
++        for i in range(self.num_ops):
++            _axpy(noise[i],d2[i,:],out)
++        for i in range(self.num_ops):
++            for j in range(i, self.num_ops):
++                if (i == j):
++                    dw = (noise[i] * noise[i] - dt) * 0.5
++                else:
++                    dw = (noise[i] * noise[j])
++                _axpy(dw,dd2[i,j,:],out)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void milstein_imp(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out) except *:
++        """
++        Chapter 12.2 Eq. (2.9)
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        cdef int i, j, k
++        cdef double dw
++        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
++                                                          dtype=complex)
++        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
++                                                         dtype=complex)
++        cdef complex[::1] a = self.buffer_1d[0,:]
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
++        _zero(a)
++        _zero_2d(d2)
++        _zero_3d(dd2)
++        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
++        copy(vec, dvec)
++        _axpy(0.5, a, dvec)
++        for i in range(self.num_ops):
++            _axpy(noise[i], d2[i,:], dvec)
++        for i in range(self.num_ops):
++            for j in range(i, self.num_ops):
++                if (i == j):
++                    dw = (noise[i] * noise[i] - dt) * 0.5
++                else:
++                    dw = (noise[i] * noise[j])
++                _axpy(dw, dd2[i,j,:], dvec)
++        copy(dvec, guess)
++        _axpy(0.5, a, guess)
++        self.implicit(t+dt, dvec, out, guess)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void taylor15(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        """
++        Chapter 12.2 Eq. (2.18),
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        cdef complex[::1] a = self.buffer_1d[0, :]
++        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
++        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
++        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
++        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
++        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
++        cdef complex[::1] L0a = self.buffer_1d[1, :]
++        _zero(a)
++        _zero_2d(b)
++        _zero_3d(Lb)
++        _zero_2d(L0b)
++        _zero_2d(La)
++        _zero_4d(LLb)
++        _zero(L0a)
++        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
++
++        cdef int i,j,k
++        cdef double[::1] dz, dw
++        dw = np.empty(self.num_ops)
++        dz = np.empty(self.num_ops)
++        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
++        for i in range(self.num_ops):
++            dw[i] = noise[i]
++            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
++        copy(vec,out)
++        _axpy(1.0, a, out)
++        _axpy(0.5, L0a, out)
++
++        for i in range(self.num_ops):
++            _axpy(dw[i], b[i,:], out)
++            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
++            _axpy(dz[i], La[i,:], out)
++            _axpy(dw[i]-dz[i], L0b[i,:], out)
++            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
++                        LLb[i,i,i,:], out)
++            for j in range(i+1,self.num_ops):
++                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
++                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
++                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
++                for k in range(j+1,self.num_ops):
++                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out) except *:
++        """
++        Chapter 12.2 Eq. (2.18),
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        cdef complex[::1] a = self.buffer_1d[0, :]
++        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
++        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
++        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
++        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
++        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
++        cdef complex[::1] L0a = self.buffer_1d[1, :]
++        _zero(a)
++        _zero_2d(b)
++        _zero_3d(Lb)
++        _zero_2d(L0b)
++        _zero_2d(La)
++        _zero_4d(LLb)
++        _zero(L0a)
++        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
++                   dtype=complex)
++        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
++                  dtype=complex)
++        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
++
++        cdef int i,j,k
++        cdef double[::1] dz, dw
++        dw = np.empty(self.num_ops)
++        dz = np.empty(self.num_ops)
++        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
++        for i in range(self.num_ops):
++            dw[i] = noise[i]
++            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
++        copy(vec, vec_t)
++        _axpy(0.5, a, vec_t)
++        for i in range(self.num_ops):
++            _axpy(dw[i], b[i,:], vec_t)
++            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
++            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
++            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
++            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
++                        LLb[i,i,i,:], vec_t)
++            for j in range(i+1,self.num_ops):
++                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
++                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
++                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
++                for k in range(j+1,self.num_ops):
++                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
++        copy(vec_t, guess)
++        _axpy(0.5, a, guess)
++
++        self.implicit(t+dt, vec_t, out, guess)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void platen15(self, double t, double dt, double[:] noise,
++                    complex[::1] vec, complex[::1] out):
++        """
++        Chapter 11.2 Eq. (2.13)
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        cdef int i, j, k
++        cdef double sqrt_dt = np.sqrt(dt)
++        cdef double sqrt_dt_inv = 1./sqrt_dt
++        cdef double ddz, ddw, ddd
++        cdef double[::1] dz, dw
++        dw = np.empty(self.num_ops)
++        dz = np.empty(self.num_ops)
++        for i in range(self.num_ops):
++            dw[i] = noise[i]
++            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
++
++        cdef complex[::1] d1 = self.buffer_1d[0,:]
++        cdef complex[::1] d1p = self.buffer_1d[1,:]
++        cdef complex[::1] d1m = self.buffer_1d[2,:]
++        cdef complex[::1] V = self.buffer_1d[3,:]
++        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
++        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
++        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
++        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
++        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
++        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
++        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
++        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
++        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
++        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
++
++        _zero(d1)
++        _zero_2d(d2)
++        _zero_2d(dd2)
++        self.d1(t, vec, d1)
++        self.d2(t, vec, d2)
++        self.d2(t + dt, vec, dd2)
++        # Euler part
++        copy(vec,out)
++        _axpy(1., d1, out)
++        for i in range(self.num_ops):
++            _axpy(dw[i], d2[i,:], out)
++
++        _zero(V)
++        _axpy(1., vec, V)
++        _axpy(1./self.num_ops, d1, V)
++
++        _zero_2d(v2p)
++        _zero_2d(v2m)
++        for i in range(self.num_ops):
++            _axpy(1., V, v2p[i,:])
++            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
++            _axpy(1., V, v2m[i,:])
++            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
++
++        _zero_3d(p2p)
++        _zero_3d(p2m)
++        for i in range(self.num_ops):
++            _zero_2d(d2p)
++            _zero_2d(d2m)
++            self.d2(t, v2p[i,:], d2p)
++            self.d2(t, v2m[i,:], d2m)
++            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
++            _axpy( ddw, d2p[i,:], out)
++            _axpy(-ddw, d2m[i,:], out)
++            for j in range(self.num_ops):
++                _axpy(      1., v2p[i,:], p2p[i,j,:])
++                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
++                _axpy(      1., v2p[i,:], p2m[i,j,:])
++                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
++
++        _axpy(-0.5*(self.num_ops), d1, out)
++        for i in range(self.num_ops):
++            ddz = dz[i]*0.5/sqrt_dt  # 1.5
++            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
++            _zero(d1p)
++            _zero(d1m)
++            _zero_2d(d2m)
++            _zero_2d(d2p)
++            _zero_2d(d2pp)
++            _zero_2d(d2mm)
++            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
++            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
++            self.d2(t, v2p[i,:], d2p)
++            self.d2(t, v2m[i,:], d2m)
++            self.d2(t, p2p[i,i,:], d2pp)
++            self.d2(t, p2m[i,i,:], d2mm)
++
++            _axpy( ddz+0.25, d1p, out)
++            _axpy(-ddz+0.25, d1m, out)
++
++            _axpy((dw[i]-dz[i]), dd2[i,:], out)
++            _axpy((dz[i]-dw[i]), d2[i,:], out)
++
++            _axpy( ddd, d2pp[i,:], out)
++            _axpy(-ddd, d2mm[i,:], out)
++            _axpy(-ddd, d2p[i,:], out)
++            _axpy( ddd, d2m[i,:], out)
++
++            for j in range(self.num_ops):
++              ddw = 0.5*(dw[j]-dz[j]) # 1.5
++              _axpy(ddw, d2p[j,:], out)
++              _axpy(-2*ddw, d2[j,:], out)
++              _axpy(ddw, d2m[j,:], out)
++
++              if j>i:
++                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
++                _axpy( ddw, d2p[j,:], out)
++                _axpy(-ddw, d2m[j,:], out)
++
++                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
++                _zero_2d(d2pp)
++                _zero_2d(d2mm)
++                self.d2(t, p2p[j,i,:], d2pp)
++                self.d2(t, p2m[j,i,:], d2mm)
++                _axpy( ddw, d2pp[j,:], out)
++                _axpy(-ddw, d2mm[j,:], out)
++                _axpy(-ddw, d2p[j,:], out)
++                _axpy( ddw, d2m[j,:], out)
++
++                for k in range(j+1,self.num_ops):
++                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
++                    _axpy( ddw, d2pp[k,:], out)
++                    _axpy(-ddw, d2mm[k,:], out)
++                    _axpy(-ddw, d2p[k,:], out)
++                    _axpy( ddw, d2m[k,:], out)
++
++              if j<i:
++                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
++                _zero_2d(d2pp)
++                _zero_2d(d2mm)
++                self.d2(t, p2p[j,i,:], d2pp)
++                self.d2(t, p2m[j,i,:], d2mm)
++                _axpy( ddw, d2pp[j,:], out)
++                _axpy(-ddw, d2mm[j,:], out)
++                _axpy(-ddw, d2p[j,:], out)
++                _axpy( ddw, d2m[j,:], out)
++
++    @cython.wraparound(False)
++    @cython.boundscheck(False)
++    @cython.cdivision(True)
++    cdef void taylor20(self, double t, double dt, double[::1] noise,
++                           complex[::1] vec, complex[::1] out):
++        """
++        Chapter 10.5 Eq. (5.1),
++        Numerical Solution of Stochastic Differential Equations
++        By Peter E. Kloeden, Eckhard Platen
++        """
++        cdef double[::1] noises = np.empty(5)
++        cdef double dwn
++        self.order2noise.order2(noise,noises)
++        cdef complex[::1] a = self.buffer_1d[0, :]
++        cdef complex[::1] b = self.buffer_1d[1, :]
++        cdef complex[::1] Lb = self.buffer_1d[2, :]
++        cdef complex[::1] La = self.buffer_1d[3, :]
++        cdef complex[::1] L0b = self.buffer_1d[4, :]
++        cdef complex[::1] LLb = self.buffer_1d[5, :]
++        cdef complex[::1] L0a = self.buffer_1d[6, :]
++        cdef complex[::1] LLa = self.buffer_1d[7, :]
++        cdef complex[::1] LL0b = self.buffer_1d[8, :]
++        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
++        cdef complex[::1] LLLb = self.buffer_1d[10, :]
++        _zero(a)
++        _zero(b)
++        _zero(Lb)
++        _zero(La)
++        _zero(L0b)
++        _zero(LLb)
++        _zero(L0a)
++        _zero(LLa)
++        _zero(LL0b)
++        _zero(L0Lb)
++        _zero(LLLb)
++        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
++                           L0a, LLa, LL0b, L0Lb, LLLb)
++
++        copy(vec,out)
++        _axpy(1.0, a, out)
++
++        _axpy(noises[0], b, out)
++        dwn = noises[0]*noises[0]*0.5
++        _axpy(dwn, Lb, out)
++
++        _axpy(noises[1], La, out)
++        _axpy(noises[0]-noises[1], L0b, out)
++        dwn *= noises[0]*(1/3.)
++        _axpy(dwn, LLb, out)
++        _axpy(0.5, L0a, out)
++
++        _axpy(noises[2], L0Lb, out)
++        _axpy(noises[3], LL0b, out)
++        _axpy(noises[4], LLa, out)
++        dwn *= noises[0]*0.25
++        _axpy(dwn, LLLb, out)
++
++
++cdef class SSESolver(StochasticSolver):
++    """stochastic Schrodinger system"""
++    cdef QobjEvo L
++    cdef object c_ops
++    cdef object cpcd_ops
++    cdef object imp
++    cdef double tol, imp_t
++
++    def set_data(self, sso):
++        L = sso.LH
++        c_ops = sso.sops
++        self.l_vec = L.shape[0]
++        self.num_ops = len(c_ops)
++        self.L = L
++        self.c_ops = []
++        self.cpcd_ops = []
++        for i, op in enumerate(c_ops):
++            self.c_ops.append(op[0])
++            self.cpcd_ops.append(op[1])
++        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
++            self.tol = sso.tol
++            self.imp = LinearOperator( (self.l_vec,self.l_vec),
++                                      matvec=self.implicit_op, dtype=complex)
++
++    def implicit_op(self, vec):
++        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
++        self.d1(self.imp_t, vec, out)
++        cdef int i
++        _scale(-0.5,out)
++        _axpy(1.,vec,out)
++        return out
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
++        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
++        cdef int i
++        cdef complex e
++        cdef QobjEvo c_op
++        cdef complex[::1] temp = self.func_buffer_1d[0,:]
++        _zero(temp)
++        for i in range(self.num_ops):
++            c_op = self.cpcd_ops[i]
++            e = c_op.expect_data(t, _dense_wrap(vec))
++            _zero(temp)
++            c_op = self.c_ops[i]
++            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
++            _axpy(-0.125 * e * e * self.dt, vec, out)
++            _axpy(0.5 * e * self.dt, temp, out)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
++        cdef int i, k
++        cdef QobjEvo c_op
++        cdef complex expect
++        for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
++            c_op = self.cpcd_ops[i]
++            expect = c_op.expect_data(t, _dense_wrap(vec))
++            _axpy(-0.5*expect,vec,out[i,:])
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void derivatives(self, double t, int deg, complex[::1] vec,
++                          complex[::1] a, complex[:, ::1] b,
++                          complex[:, :, ::1] Lb, complex[:,::1] La,
++                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
++                          complex[::1] L0a):
++        """
++        combinaisons of a and b derivatives for taylor order 1.5
++        dY ~ a dt + bi dwi
++                                         deg   use        noise
++        b[i.:]       bi                   >=0   d2 euler   dwi
++        a[:]         a                    >=0   d1 euler   dt
++        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
++        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
++
++        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
++        La[i,:]      ba'                  >=2   taylor15   dzi
++        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
++        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
++        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
++        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
++        """
++        cdef int i, j, k, l
++        cdef double dt = self.dt
++        cdef QobjEvo c_op
++        cdef complex e, de_bb
++
++        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
++        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
++        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
++        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
++        _zero_3d(dde_bb)
++        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
++        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
++        cdef complex[::1] temp = self.func_buffer_1d[0,:]
++        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
++        _zero(temp)
++        _zero(temp2)
++        _zero_2d(Cvec)
++        _zero_3d(Cb)
++
++        # a b
++        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
++        for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
++            e = _dotc(vec,Cvec[i,:])
++            e_real[i] = e.real
++            _axpy(1., Cvec[i,:], b[i,:])
++            _axpy(-e_real[i], vec, b[i,:])
++            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
++            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
++
++        #Lb bb'
++        if deg >= 1:
++          for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            for j in range(self.num_ops):
++              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
++              for k in range(self.l_vec):
++                  temp[k] = conj(b[j,k])
++                  temp2[k] = 0.
++              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
++              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
++                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
++              _axpy(1., Cb[i,j,:], Lb[i,j,:])
++              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
++              _axpy(-de_b[i,j], vec, Lb[i,j,:])
++
++              for k in range(self.num_ops):
++                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
++                                  _dot(b[k,:], Cb[i,j,:]) + \
++                                  conj(_dotc(b[k,:], temp2)))*.5
++                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
++
++        #L0b La LLb
++        if deg >= 2:
++          for i in range(self.num_ops):
++              #ba'
++              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
++              for j in range(self.num_ops):
++                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
++                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
++                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
++                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
++
++              #ab' + db/dt + bbb"/2
++              c_op = self.c_ops[i]
++              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
++              for k in range(self.l_vec):
++                  temp[k] = conj(a[k])
++                  temp2[k] = 0.
++              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
++              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
++                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
++              _axpy(-e_real[i], a, L0b[i,:])
++              _axpy(-de_a[i], vec, L0b[i,:])
++
++              temp = np.zeros(self.l_vec, dtype=complex)
++              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
++              e = _dotc(vec,temp)
++              _axpy(1., temp, L0b[i,:])
++              _axpy(-e.real, vec, L0b[i,:])
++              _axpy(-1., b[i,:], L0b[i,:])
++
++              for j in range(self.num_ops):
++                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
++                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
++
++              #b(bb"+b'b')
++              for j in range(i,self.num_ops):
++                  for k in range(j, self.num_ops):
++                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
++                                  _dense_wrap(LLb[i,j,k,:]))
++                      for l in range(self.l_vec):
++                          temp[l] = conj(Lb[j,k,l])
++                          temp2[l] = 0.
++                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
++                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
++                               _dot(Lb[j,k,:], Cvec[i,:]) + \
++                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
++                               _dotc(vec, temp2)))*0.5
++                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
++                      _axpy(-de_bb, vec, LLb[i,j,k,:])
++                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
++                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
++                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
++
++        #da/dt + aa' + bba"
++        if deg == 2:
++          self.d1(t + dt, vec, L0a)
++          _axpy(-1.0, a, L0a)
++          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
++          for j in range(self.num_ops):
++              c_op = self.c_ops[j]
++              temp = np.zeros(self.l_vec, dtype=complex)
++              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
++              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
++              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
++              _axpy(e_real[j] * dt, temp, L0a[:])
++              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
++              for i in range(self.num_ops):
++                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
++                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
++                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
++                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
++                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
++                         complex[::1] vec, complex[::1] out):
++        cdef int k
++        cdef complex[::1] temp = self.func_buffer_1d[13,:]
++        for k in range(self.l_vec):
++            temp[k] = conj(vec[k])
++            out[k] = 0.
++        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void derivativesO2(self, double t, complex[::1] psi,
++                            complex[::1] a, complex[::1] b, complex[::1] Lb,
++                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
++                            complex[::1] L0a,
++                            complex[::1] LLa, complex[::1] LL0b,
++                            complex[::1] L0Lb, complex[::1] LLLb):
++        """
++        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
++        Use Stratonovich-Taylor expansion.
++        One one sc_ops
++        dY ~ a dt + bi dwi
++
++        b[:]     b                        d2 euler    dw
++        a[:]     a- Lb/2                  d1 euler    dt
++        Lb[:]    b'b                      milstein    dw^2/2
++        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
++        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
++        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
++        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
++
++        LLa[:]   ...                      taylor2.0   dwdt-dz
++        LL0b[:]  ...                      taylor2.0   dz
++        L0Lb[:]  ...                      taylor2.0   dw^3/6
++        LLLb[:]  ...                      taylor2.0   dt^2/2
++        """
++        cdef double dt = self.dt
++        cdef QobjEvo c_op = self.c_ops[0]
++        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
++        cdef complex de_a, dde_ba, de_La, de_L0b
++
++        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
++        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
++        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
++        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
++        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
++        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
++        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
++        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
++        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
++        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
++        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
++        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
++        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
++        _zero(Cpsi)
++        _zero(Cb)
++        _zero(CLb)
++        _zero(CLLb)
++        _zero(Ca)
++        _zero(CLa)
++        _zero(CL0b)
++
++        # b
++        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
++        e = _dotc(psi, Cpsi).real
++        _axpy(1., Cpsi, b)
++        _axpy(-e, psi, b)
++
++        # Lb
++        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
++        self._c_vec_conj(t, c_op, b, Cbc)
++        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
++                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
++        _axpy(1., Cb, Lb)
++        _axpy(-e, b, Lb)
++        _axpy(-de_b, psi, Lb)
++
++        # LLb = b'b'b + b"bb
++        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
++        self._c_vec_conj(t, c_op, Lb, CLbc)
++        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
++                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
++        _axpy(1, CLb, LLb)      # b'b'b
++        _axpy(-e, Lb, LLb)      # b'b'b
++        _axpy(-de_Lb, psi, LLb) # b'b'b
++        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
++        _axpy(-dde_bb, psi, LLb) # b"bb
++        _axpy(-de_b*2, b, LLb)   # b"bb
++
++        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
++        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
++        self._c_vec_conj(t, c_op, LLb, CLLbc)
++        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
++                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
++        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
++                    conj(_dotc(b, CLbc)))*.5
++        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
++        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
++        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
++        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
++        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
++        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
++        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
++
++        # a
++        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
++        _axpy(-0.5 * e * e * dt, psi, a)
++        _axpy(e * dt, Cpsi, a)
++        _axpy(-0.5 * dt, Lb, a)
++
++        #La
++        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
++        _axpy(-0.5 * e * e * dt, b, La)
++        _axpy(-e * de_b * dt, psi, La)
++        _axpy(e * dt, Cb, La)
++        _axpy(de_b * dt, Cpsi, La)
++        _axpy(-0.5 * dt, LLb, La)
++
++        #LLa
++        _axpy(-2 * e * de_b * dt, b, LLa)
++        _axpy(-de_b * de_b * dt, psi, LLa)
++        _axpy(-e * dde_bb * dt, psi, LLa)
++        _axpy( 2 * de_b * dt, Cb, LLa)
++        _axpy( dde_bb * dt, Cpsi, LLa)
++
++        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
++        _axpy(-de_Lb * e * dt, psi, LLa)
++        _axpy(-0.5 * e * e * dt, Lb, LLa)
++        _axpy( de_Lb * dt, Cpsi, LLa)
++        _axpy( e * dt, CLb, LLa)
++
++        _axpy(-0.5 * dt, LLLb, LLa)
++
++        # L0b = b'a
++        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
++        self._c_vec_conj(t, c_op, a, Cac)
++        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
++                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
++        _axpy(1.0, Ca, L0b)
++        _axpy(-e, a, L0b)
++        _axpy(-de_a, psi, L0b)
++
++        # LL0b = b"ba + b'La
++        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
++                    conj(_dotc(b, Cac)))*.5
++        _axpy(-dde_ba, psi, LL0b)
++        _axpy(-de_a, b, LL0b)
++        _axpy(-de_b, a, LL0b)
++        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
++        self._c_vec_conj(t, c_op, La, CLac)
++        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
++                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
++        _axpy(1., CLa, LL0b)
++        _axpy(-e, La, LL0b)
++        _axpy(-de_La, psi, LL0b)
++
++        # L0Lb = b"ba + b'L0b
++        _axpy(-dde_ba, psi, L0Lb)
++        _axpy(-de_a, b, L0Lb)
++        _axpy(-de_b, a, L0Lb)
++        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
++        self._c_vec_conj(t, c_op, L0b, CL0bc)
++        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
++                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
++        _axpy(1., CL0b, L0Lb)
++        _axpy(-e, L0b, L0Lb)
++        _axpy(-de_L0b, psi, L0Lb)
++
++        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
++        self.d1(t + dt, psi, L0a) # da/dt
++        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
++        _axpy(-1.0, a, L0a)        # da/dt
++        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
++        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
++        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
++        _axpy(e * dt, Ca, L0a)              # a'_a_
++        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
++        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
++
++    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
++                                        complex[::1] out,
++                                        np.ndarray[complex, ndim=1] guess) except *:
++        # np.ndarray to memoryview is OK but not the reverse
++        # scipy function only take np array, not memoryview
++        self.imp_t = t
++        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
++                                          tol=self.tol, atol=1e-12)
++        cdef int i
++        copy(spout, out)
++
++
++cdef class SMESolver(StochasticSolver):
++    """stochastic master equation system"""
++    cdef QobjEvo L
++    cdef object imp
++    cdef object c_ops
++    cdef int N_root
++    cdef double tol
++
++    def set_data(self, sso):
++        L = sso.LH
++        c_ops = sso.sops
++        self.l_vec = L.shape[0]
++        self.num_ops = len(c_ops)
++        self.L = L
++        self.c_ops = []
++        self.N_root = np.sqrt(self.l_vec)
++        for i, op in enumerate(c_ops):
++            self.c_ops.append(op)
++        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
++            self.tol = sso.tol
++            self.imp = sso.imp
++
++    cdef void _normalize_inplace(self, complex[::1] vec):
++        _normalize_rho(vec)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef complex expect(self, complex[::1] rho):
++        cdef complex e = 0.
++        cdef int k
++        for k in range(self.N_root):
++            e += rho[k*(self.N_root+1)]
++        return e
++
++    @cython.boundscheck(False)
++    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
++        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
++        cdef int i, k
++        cdef QobjEvo c_op
++        cdef complex expect
++        for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
++            expect = self.expect(out[i,:])
++            _axpy(-expect, rho, out[i,:])
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void derivatives(self, double t, int deg, complex[::1] rho,
++                          complex[::1] a, complex[:, ::1] b,
++                          complex[:, :, ::1] Lb, complex[:,::1] La,
++                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
++                          complex[::1] L0a):
++        """
++        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
++        dY ~ a dt + bi dwi
++                                         deg   use        noise
++        b[i.:]       bi                   >=0   d2 euler   dwi
++        a[:]         a                    >=0   d1 euler   dt
++        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
++        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
++        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
++        La[i,:]      ba'                  >=2   taylor15   dzi
++        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
++        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
++        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
++        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
++        """
++        cdef int i, j, k
++        cdef QobjEvo c_op
++        cdef QobjEvo c_opj
++        cdef complex trApp, trAbb, trAa
++        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
++        cdef complex[:, ::1] trAb = self.expect_buffer_2d
++        cdef complex[::1] temp = self.func_buffer_1d[0,:]
++        #_zero(temp)
++
++        # a
++        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
++
++        # b
++        for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            # bi
++            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
++            trAp[i] = self.expect(b[i,:])
++            _axpy(-trAp[i], rho, b[i,:])
++
++        # Libj = bibj', i<=j
++        # sc_ops must commute (Libj = Ljbi)
++        if deg >= 1:
++          for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            for j in range(i, self.num_ops):
++                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
++                trAb[i,j] = self.expect(Lb[i,j,:])
++                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
++                _axpy(-trAb[i,j], rho, Lb[i,j,:])
++
++        # L0b La LLb
++        if deg >= 2:
++          for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            # Lia = bia'
++            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
++
++            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
++            # db/dt
++            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
++            trApp = self.expect(L0b[i,:])
++            _axpy(-trApp, rho, L0b[i,:])
++            _axpy(-1, b[i,:], L0b[i,:])
++            # ab'
++            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
++            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
++            trAa = self.expect(temp)
++            _axpy(1., temp, L0b[i,:])
++            _axpy(-trAp[i], a[:], L0b[i,:])
++            _axpy(-trAa, rho, L0b[i,:])
++            # bbb" : trAb[i,j] only defined for j>=i
++            for j in range(i):
++                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
++            for j in range(i,self.num_ops):
++                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
++
++            # LLb
++            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
++            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
++            for j in range(i,self.num_ops):
++              for k in range(j,self.num_ops):
++                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
++                trAbb = self.expect(LLb[i,j,k,:])
++                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
++                _axpy(-trAbb, rho, LLb[i,j,k,:])
++                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
++                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
++
++        # L0a = a'a + da/dt + bba"/2  (a" = 0)
++        if deg == 2:
++            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
++            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
++            _axpy(-1, a, L0a)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void derivativesO2(self, double t, complex[::1] rho,
++                            complex[::1] a, complex[::1] b, complex[::1] Lb,
++                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
++                            complex[::1] L0a,
++                            complex[::1] LLa, complex[::1] LL0b,
++                            complex[::1] L0Lb, complex[::1] LLLb):
++        """
++        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
++        Use Stratonovich-Taylor expansion.
++        One one sc_ops
++        dY ~ a dt + bi dwi
++
++        b[:]     b                        d2 euler    dw
++        a[:]     a- Lb/2                  d1 euler    dt
++        Lb[:]    b'b                      milstein    dw^2/2
++        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
++        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
++        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
++        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
++
++        LLa[:]   ...                      taylor2.0   dwdt-dz
++        LL0b[:]  ...                      taylor2.0   dz
++        L0Lb[:]  ...                      taylor2.0   dw^3/6
++        LLLb[:]  ...                      taylor2.0   dt^2/2
++        """
++        cdef int i, j, k
++        cdef QobjEvo c_op = self.c_ops[0]
++        cdef QobjEvo c_opj
++        cdef complex trAp, trApt
++        cdef complex trAb, trALb, trALLb
++        cdef complex trAa, trALa
++        cdef complex trAL0b
++
++        cdef complex[::1] temp = self.func_buffer_1d[0,:]
++        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
++
++        # b
++        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
++        trAp = self.expect(b)
++        _axpy(-trAp, rho, b)
++
++        # Lb = b'b
++        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
++        trAb = self.expect(Lb)
++        _axpy(-trAp, b, Lb)
++        _axpy(-trAb, rho, Lb)
++
++        # LLb = b'Lb+b"bb
++        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
++        trALb = self.expect(LLb)
++        _axpy(-trAp, Lb, LLb)
++        _axpy(-trALb, rho, LLb)
++        _axpy(-trAb*2, b, LLb)
++
++        # LLLb = b'LLb + 3 b"bLb + b"'bbb
++        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
++        trALLb = self.expect(LLLb)
++        _axpy(-trAp, LLb, LLLb)
++        _axpy(-trALLb, rho, LLLb)
++        _axpy(-trALb*3, b, LLLb)
++        _axpy(-trAb*3, Lb, LLLb)
++
++        # _a_ = a - Lb/2
++        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
++        _axpy(-0.5*self.dt, Lb, a)
++
++        # L_a_ = ba' - LLb/2
++        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
++        _axpy(-0.5*self.dt, LLb, La)
++
++        # LL_a_ = b(La)' - LLLb/2
++        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
++        _axpy(-0.5*self.dt, LLLb, LLa)
++
++        # _L0_b = b'(_a_)
++        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
++        trAa = self.expect(L0b)
++        _axpy(-trAp, a, L0b)
++        _axpy(-trAa, rho, L0b)
++
++        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
++        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
++        trAL0b = self.expect(L0Lb)
++        _axpy(-trAp, L0b, L0Lb)
++        _axpy(-trAL0b, rho, L0Lb)
++        _axpy(-trAa, b, L0Lb)
++        _axpy(-trAb, a, L0Lb)
++
++        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
++        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
++        trAL0b = self.expect(LL0b)
++        _axpy(-trAp, La, LL0b)
++        _axpy(-trAL0b, rho, LL0b)
++        _axpy(-trAa, b, LL0b)
++        _axpy(-trAb, a, LL0b)
++
++        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
++        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
++        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
++        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
++        _axpy(-1, a, L0a)
++        _axpy(-self.dt*0.5, L0Lb, L0a)
++
++
++    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
++                                        complex[::1] out,
++                                        np.ndarray[complex, ndim=1] guess) except *:
++        # np.ndarray to memoryview is OK but not the reverse
++        # scipy function only take np array, not memoryview
++        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
++                                          dvec, x0=guess,
++                                          tol=self.tol, atol=1e-12)
++        cdef int i
++        copy(spout,out)
++
++
++cdef class PcSSESolver(StochasticSolver):
++    """photocurrent for Schrodinger equation"""
++    cdef QobjEvo L
++    cdef object c_ops
++    cdef object cdc_ops
++
++    def set_data(self, sso):
++        L = sso.LH
++        c_ops = sso.sops
++        self.l_vec = L.shape[0]
++        self.num_ops = len(c_ops)
++        self.L = L
++        self.c_ops = []
++        self.cdc_ops = []
++        for i, op in enumerate(c_ops):
++            self.c_ops.append(op[0])
++            self.cdc_ops.append(op[1])
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void photocurrent(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        cdef QobjEvo c_op
++        cdef double rand
++        cdef int i, which = -1
++        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
++        cdef complex[::1] d2 = self.buffer_1d[0,:]
++
++        copy(vec, out)
++        self.d1(t, vec, out)
++        rand = np.random.rand()
++        for i in range(self.num_ops):
++            c_op = self.cdc_ops[i]
++            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
++            if expects[i].real * dt >= 1e-15:
++                rand -= expects[i].real *dt
++            if rand < 0:
++                which = i
++                noise[i] = 1.
++                break
++
++        if which >= 0:
++            self.collapse(t, which, expects[which].real, vec, d2)
++            _axpy(1, d2, out)
++            _axpy(-1, vec, out)
++
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        cdef QobjEvo c_op
++        cdef double expect
++        cdef int i, which=0, num_coll=0, did_collapse=0
++        cdef complex[::1] tmp = self.buffer_1d[0,:]
++        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
++        cdef np.ndarray[int, ndim=1] colls
++
++        # Collapses are computed first
++        for i in range(self.num_ops):
++            c_op = self.cdc_ops[i]
++            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
++            if expects[i].real > 0:
++                did_collapse = np.random.poisson(expects[i].real * dt)
++                num_coll += did_collapse
++                if did_collapse:
++                    which = i
++                noise[i] = did_collapse * 1.
++            else:
++                noise[i] = 0.
++
++        if num_coll == 0:
++            pass
++        elif num_coll == 1:
++            # Do one collapse
++            self.collapse(t, which, expects[which].real, vec, out)
++            copy(out, vec)
++        elif num_coll and noise[which] == num_coll:
++            # Do many collapse of one sc_ops.
++            # Recompute the expectation value, but only to check for zero.
++            c_op = self.cdc_ops[which]
++            for i in range(num_coll):
++                expect = c_op.expect_data(t, _dense_wrap(vec)).real
++                if expect * dt >= 1e-15:
++                    self.collapse(t, which, expect, vec, out)
++                    copy(out,vec)
++        elif num_coll >= 2:
++            # 2 or more collapses of different operators
++            # Ineficient, should be rare
++            coll = []
++            for i in range(self.num_ops):
++                coll += [i]*int(noise[i])
++            np.random.shuffle(coll)
++            for i in coll:
++                c_op = self.cdc_ops[i]
++                expect = c_op.expect_data(t, _dense_wrap(vec)).real
++                if expect * dt >= 1e-15:
++                    self.collapse(t, i, expect, vec, out)
++                    copy(out,vec)
++        copy(vec,tmp)
++        copy(vec,out)
++        self.d1(t, vec, tmp)
++        self.d1(t+dt, tmp, out)
++        _scale(0.5, out)
++        _axpy(0.5, tmp, out)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
++        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
++        cdef int i
++        cdef complex e
++        cdef QobjEvo c_op
++        cdef complex[::1] temp = self.func_buffer_1d[0,:]
++        for i in range(self.num_ops):
++            _zero(temp)
++            c_op = self.c_ops[i]
++            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
++            e = _dznrm2(temp)
++            _axpy(0.5 * e * e * self.dt, vec, out)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
++        cdef int i
++        cdef QobjEvo c_op
++        cdef complex expect
++        for i in range(self.num_ops):
++            c_op = self.c_ops[i]
++            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
++            expect = _dznrm2(out[i,:])
++            if expect.real >= 1e-15:
++                _zscale(1/expect, out[i,:])
++            else:
++                _zero(out[i,:])
++            _axpy(-1, vec, out[i,:])
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void collapse(self, double t, int which, double expect,
++                       complex[::1] vec, complex[::1] out):
++        cdef QobjEvo c_op
++        c_op = self.c_ops[which]
++        _zero(out)
++        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
++        _zscale(1/expect, out)
++
++
++cdef class PcSMESolver(StochasticSolver):
++    """photocurrent for master equation"""
++    cdef QobjEvo L
++    cdef object cdcr_cdcl_ops
++    cdef object cdcl_ops
++    cdef object clcdr_ops
++    cdef int N_root
++
++    def set_data(self, sso):
++        L = sso.LH
++        c_ops = sso.sops
++        self.l_vec = L.shape[0]
++        self.num_ops = len(c_ops)
++        self.L = L
++        self.cdcr_cdcl_ops = []
++        self.cdcl_ops = []
++        self.clcdr_ops = []
++        self.N_root = np.sqrt(self.l_vec)
++        for i, op in enumerate(c_ops):
++            self.cdcr_cdcl_ops.append(op[0])
++            self.cdcl_ops.append(op[1])
++            self.clcdr_ops.append(op[2])
++
++    cdef void _normalize_inplace(self, complex[::1] vec):
++        _normalize_rho(vec)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void photocurrent(self, double t, double dt,  double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        cdef QobjEvo c_op
++        cdef double rand
++        cdef int i, which = -1
++        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
++        cdef complex[::1] d2 = self.buffer_1d[0,:]
++
++        copy(vec, out)
++        self.d1(t, vec, out)
++        rand = np.random.rand()
++        for i in range(self.num_ops):
++            c_op = self.clcdr_ops[i]
++            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
++            if expects[i].real * dt >= 1e-15:
++                rand -= expects[i].real *dt
++            if rand < 0:
++                which = i
++                noise[i] = 1.
++                break
++
++        if which >= 0:
++            self.collapse(t, which, expects[which].real, vec, d2)
++            _axpy(1, d2, out)
++            _axpy(-1, vec, out)
++
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        cdef QobjEvo c_op
++        cdef int i, which, num_coll=0, did_collapse
++        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
++        cdef complex[::1] tmp = self.buffer_1d[0,:]
++        cdef double expect
++        cdef np.ndarray[int, ndim=1] colls
++
++        # Collapses are computed first
++        for i in range(self.num_ops):
++            c_op = self.clcdr_ops[i]
++            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
++            if expects[i].real > 0:
++                did_collapse = np.random.poisson(expects[i].real* dt)
++                num_coll += did_collapse
++                if did_collapse:
++                    which = i
++                noise[i] = did_collapse * 1.
++            else:
++                noise[i] = 0.
++
++        if num_coll == 0:
++            pass
++        elif num_coll == 1:
++            # Do one collapse
++            self.collapse(t, which, expects[which].real, vec, out)
++            copy(out,vec)
++        elif noise[which] == num_coll:
++            # Do many collapse of one sc_ops.
++            # Recompute the expectation value, but only to check for zero.
++            c_op = self.clcdr_ops[which]
++            for i in range(num_coll):
++                expect = c_op.expect_data(t, _dense_wrap(vec)).real
++                if expect * dt >= 1e-15:
++                    self.collapse(t, which, expect, vec, out)
++                    copy(out,vec)
++        elif num_coll >= 2:
++            # 2 or more collapses of different operators
++            # Ineficient, should be rare
++            coll = []
++            for i in range(self.num_ops):
++                coll += [i] * int(noise[i])
++            np.random.shuffle(coll)
++            for i in coll:
++                c_op = self.clcdr_ops[i]
++                expect = c_op.expect_data(t, _dense_wrap(vec)).real
++                if expect * dt >= 1e-15:
++                    self.collapse(t, i, expect, vec, out)
++                    copy(out,vec)
++
++        copy(vec,tmp)
++        copy(vec,out)
++        self.d1(t, vec, tmp)
++        self.d1(t+dt, tmp, out)
++        _scale(0.5, out)
++        _axpy(0.5, tmp, out)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef complex expect(self, complex[::1] rho):
++        cdef complex e = 0.
++        cdef int k
++        for k in range(self.N_root):
++            e += rho[k*(self.N_root+1)]
++        return e
++
++    @cython.boundscheck(False)
++    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
++        cdef int i
++        cdef QobjEvo c_op
++        cdef complex[::1] crho = self.func_buffer_1d[0,:]
++        cdef complex expect
++        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
++        for i in range(self.num_ops):
++            c_op = self.cdcr_cdcl_ops[i]
++            _zero(crho)
++            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
++            expect = self.expect(crho)
++            _axpy(0.5*expect* self.dt, rho, out)
++            _axpy(-0.5* self.dt, crho, out)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
++        cdef int i
++        cdef QobjEvo c_op
++        cdef complex expect
++        for i in range(self.num_ops):
++            c_op = self.clcdr_ops[i]
++            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
++            expect = self.expect(out[i,:])
++            if expect.real >= 1e-15:
++                _zscale((1.+0j)/expect, out[i,:])
++            else:
++                _zero(out[i,:])
++            _axpy(-1, rho, out[i,:])
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef void collapse(self, double t, int which, double expect,
++                       complex[::1] vec, complex[::1] out):
++        cdef QobjEvo c_op
++        c_op = self.clcdr_ops[which]
++        _zero(out)
++        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
++        _zscale(1./expect, out)
++
++cdef class PmSMESolver(StochasticSolver):
++    """positive map for master equation"""
++    cdef object L
++    cdef QobjEvo pp_ops
++    cdef QobjEvo preLH
++    cdef QobjEvo postLH
++    cdef object sops
++    cdef object preops
++    cdef object postops
++    cdef object preops2
++    cdef object postops2
++    cdef int N_root
++
++    def set_data(self, sso):
++        c_ops = sso.sops
++        self.l_vec = sso.pp.shape[0]
++        self.num_ops = len(c_ops)
++        self.preLH = sso.preLH
++        self.postLH = sso.postLH
++        self.pp_ops = sso.pp
++        self.sops = [op for op in sso.sops]
++        self.preops = [op for op in sso.preops]
++        self.postops = [op for op in sso.postops]
++        self.preops2 = [op for op in sso.preops2]
++        self.postops2 = [op for op in sso.postops2]
++        self.N_root = np.sqrt(self.l_vec)
++
++    cdef void _normalize_inplace(self, complex[::1] vec):
++        _normalize_rho(vec)
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    cdef void rouchon(self, double t, double dt, double[:] noise,
++                           complex[::1] vec, complex[::1] out):
++        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
++        cdef complex[::1] temp = self.buffer_1d[0,:]
++        cdef complex[::1] temp2 = self.buffer_1d[1,:]
++        cdef int i, j, k
++        cdef QobjEvo c_op, c_opj
++        cdef complex ddw, tr
++        _zero(out)
++        _zero(temp)
++        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
++        for i in range(self.num_ops):
++            c_op = self.sops[i]
++            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
++            c_op = self.preops[i]
++            _zero(temp2)
++            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
++            _axpy(dy[i], temp2, temp)
++
++        k = 0
++        for i in range(self.num_ops):
++            for j in range(i, self.num_ops):
++                c_op = self.preops2[k]
++                if i == j:
++                    ddw = (dy[i]*dy[j] - dt) *0.5
++                else:
++                    ddw = (dy[i]*dy[j])
++
++                _zero(temp2)
++                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
++                _axpy(ddw, temp2, temp)
++                k += 1
++
++        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
++        for i in range(self.num_ops):
++            dy[i] = conj(dy[i])
++            c_op = self.postops[i]
++            _zero(temp2)
++            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
++            _axpy(dy[i], temp2, out)
++
++        k = 0
++        for i in range(self.num_ops):
++            for j in range(i, self.num_ops):
++                c_op = self.postops2[k]
++                if i == j:
++                    ddw = (dy[i]*dy[j] - dt) *0.5
++                else:
++                    ddw = (dy[i]*dy[j])
++                _zero(temp2)
++                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
++                _axpy(ddw, temp2, out)
++                k += 1
++
++        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
++        tr = self.expect(out)
++        _zscale(1./tr, out)
++
++
++    @cython.boundscheck(False)
++    @cython.wraparound(False)
++    @cython.cdivision(True)
++    cdef complex expect(self, complex[::1] rho):
++        cdef complex e = 0.
++        cdef int k
++        for k in range(self.N_root):
++            e += rho[k*(self.N_root+1)]
++        return e
++
++
++cdef class GenericSSolver(StochasticSolver):
++    """support for user defined system"""
++    cdef object d1_func, d2_func
++
++    def set_data(self, sso):
++        self.l_vec = sso.rho0.shape[0]
++        self.num_ops = len(sso.sops)
++        self.d1_func = sso.d1
++        self.d2_func = sso.d2
++
++
++    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
++        cdef np.ndarray[complex, ndim=1] in_np
++        cdef np.ndarray[complex, ndim=1] out_np
++        in_np = np.zeros((self.l_vec, ), dtype=complex)
++        copy(rho, in_np)
++        out_np = self.d1_func(t, in_np)
++        _axpy(self.dt, out_np, out) # d1 is += and * dt
++
++    @cython.boundscheck(False)
++    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
++        cdef np.ndarray[complex, ndim=1] in_np
++        cdef np.ndarray[complex, ndim=2] out_np
++        cdef int i
++        in_np = np.zeros((self.l_vec, ), dtype=complex)
++        copy(rho, in_np)
++        out_np = self.d2_func(t, in_np)
++        for i in range(self.num_ops):
++            copy(out_np[i,:], out[i,:])
+diff --git a/qutip/solve/nonmarkov/memorycascade.py b/qutip/solve/nonmarkov/memorycascade.py
+index 35996d21..488b2515 100644
+--- a/qutip/solve/nonmarkov/memorycascade.py
++++ b/qutip/solve/nonmarkov/memorycascade.py
+@@ -1,405 +1,405 @@
+-# -*- coding: utf-8 -*-
+-
+-# @author: Arne L. Grimsmo
+-# @email1: arne.grimsmo@gmail.com
+-# @organization: University of Sherbrooke
+-
+-"""
+-This module is an implementation of the method introduced in [1], for
+-solving open quantum systems subject to coherent feedback with a single
+-discrete time-delay. This method is referred to as the ``memory cascade''
+-method in qutip.
+-
+-[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
+-"""
+-
+-import numpy as np
+-import warnings
+-
+-import qutip as qt
+-
+-
+-class MemoryCascade:
+-    """Class for running memory cascade simulations of open quantum systems
+-    with time-delayed coherent feedback.
+-
+-    Attributes
+-    ----------
+-    H_S : :class:`qutip.Qobj`
+-        System Hamiltonian (can also be a Liouvillian)
+-
+-    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+-        System operators coupling into the feedback loop. Can be a single
+-        operator or a list of operators.
+-
+-    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+-        System operators coupling out of the feedback loop. Can be a single
+-        operator or a list of operators. L2 must have the same length as L1.
+-
+-    S_matrix: *array*
+-        S matrix describing which operators in L1 are coupled to which
+-        operators in L2 by the feedback channel. Defaults to an n by n identity
+-        matrix where n is the number of elements in L1/L2.
+-
+-    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+-        Decay operators describing conventional Markovian decay channels.
+-        Can be a single operator or a list of operators.
+-
+-    integrator : str {'propagator', 'mesolve'}
+-        Integrator method to use. Defaults to 'propagator' which tends to be
+-        faster for long times (i.e., large Hilbert space).
+-
+-    parallel : bool
+-        Run integrator in parallel if True. Only implemented for 'propagator'
+-        as the integrator method.
+-
+-    options : dict
+-        Generic solver options.
+-    """
+-
+-    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
+-                 integrator='propagator', parallel=False, options=None):
+-
+-        if options is None:
+-            self.options = {}
+-        else:
+-            self.options = options
+-
+-        self.H_S = H_S
+-        self.sysdims = H_S.dims
+-        if isinstance(L1, qt.Qobj):
+-            self.L1 = [L1]
+-        else:
+-            self.L1 = L1
+-        if isinstance(L2, qt.Qobj):
+-            self.L2 = [L2]
+-        else:
+-            self.L2 = L2
+-        if not len(self.L1) == len(self.L2):
+-            raise ValueError('L1 and L2 has to be of equal length.')
+-        if isinstance(c_ops_markov, qt.Qobj):
+-            self.c_ops_markov = [c_ops_markov]
+-        else:
+-            self.c_ops_markov = c_ops_markov
+-
+-        if S_matrix is None:
+-            self.S_matrix = np.identity(len(self.L1))
+-        else:
+-            self.S_matrix = S_matrix
+-        # create system identity superoperator
+-        self.Id = qt.qeye(H_S.shape[0])
+-        self.Id.dims = self.sysdims
+-        self.Id = qt.sprepost(self.Id, self.Id)
+-        self.store_states = self.options['store_states']
+-        self.integrator = integrator
+-        self.parallel = parallel
+-
+-    def propagator(self, t, tau, notrace=False):
+-        """
+-        Compute propagator for time t and time-delay tau
+-
+-        Parameters
+-        ----------
+-        t : *float*
+-            current time
+-
+-        tau : *float*
+-            time-delay
+-
+-        notrace : *bool* {False}
+-            If this optional is set to True, a propagator is returned for a
+-            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
+-            If set to False (default), a generalized partial trace is performed
+-            and a propagator for a single system is returned.
+-        Returns
+-        -------
+-        : :class:`qutip.Qobj`
+-            time-propagator for reduced system dynamics
+-        """
+-        k = int(t/tau)+1
+-        s = t-(k-1)*tau
+-        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
+-                            self.c_ops_markov)
+-        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
+-                       parallel=self.parallel, opt=self.options)
+-        if k > 1:
+-            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
+-                                  self.S_matrix, self.c_ops_markov)
+-            G2 = qt.composite(G2, self.Id)
+-            E = _integrate(G2, E, s, tau, integrator=self.integrator,
+-                    parallel=self.parallel, opt=self.options)
+-        E.dims = E0.dims
+-        if not notrace:
+-            E = _genptrace(E, k)
+-        return E
+-
+-    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
+-                           notrace=False):
+-        r"""
+-        Compute propagator for computing output field expectation values
+-        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
+-        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
+-
+-        Parameters
+-        ----------
+-        blist : array_like
+-            List of integers specifying the field operators:
+-            0: I (nothing)
+-            1: b_out
+-            2: b_out^\dagger
+-            3: b_loop
+-            4: b_loop^\dagger
+-
+-        tlist : array_like
+-            list of corresponding times t1,..,tn at which to evaluate the field
+-            operators
+-
+-        tau : float
+-            time-delay
+-
+-        c1 : :class:`qutip.Qobj`
+-            system collapse operator that couples to the in-loop field in
+-            question (only needs to be specified if self.L1 has more than one
+-            element)
+-
+-        c2 : :class:`qutip.Qobj`
+-            system collapse operator that couples to the output field in
+-            question (only needs to be specified if self.L2 has more than one
+-            element)
+-
+-        notrace : bool {False}
+-            If this optional is set to True, a propagator is returned for a
+-            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
+-            If set to False (default), a generalized partial trace is performed
+-            and a propagator for a single system is returned.
+-
+-        Returns
+-        -------
+-        : :class:`qutip.Qobj`
+-            time-propagator for computing field correlation function
+-        """
+-        if c1 is None and len(self.L1) == 1:
+-            c1 = self.L1[0]
+-        else:
+-            raise ValueError('Argument c1 has to be specified when more than' +
+-                             'one collapse operator couples to the feedback' +
+-                             'loop.')
+-        if c2 is None and len(self.L2) == 1:
+-            c2 = self.L2[0]
+-        else:
+-            raise ValueError('Argument c1 has to be specified when more than' +
+-                             'one collapse operator couples to the feedback' +
+-                             'loop.')
+-        klist = []
+-        slist = []
+-        for t in tlist:
+-            klist.append(int(t/tau)+1)
+-            slist.append(t-(klist[-1]-1)*tau)
+-        kmax = max(klist)
+-        zipped = sorted(zip(slist, klist, blist))
+-        slist = [s for (s, k, b) in zipped]
+-        klist = [k for (s, k, b) in zipped]
+-        blist = [b for (s, k, b) in zipped]
+-
+-        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
+-                            self.c_ops_markov)
+-        sprev = 0.
+-        E = E0
+-        for i, s in enumerate(slist):
+-            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
+-                    parallel=self.parallel, opt=self.options)
+-            if klist[i] == 1:
+-                l1 = 0.*qt.Qobj()
+-            else:
+-                l1 = _localop(c1, klist[i]-1, kmax)
+-            l2 = _localop(c2, klist[i], kmax)
+-            if blist[i] == 0:
+-                superop = self.Id
+-            elif blist[i] == 1:
+-                superop = qt.spre(l1+l2)
+-            elif blist[i] == 2:
+-                superop = qt.spost(l1.dag()+l2.dag())
+-            elif blist[i] == 3:
+-                superop = qt.spre(l1)
+-            elif blist[i] == 4:
+-                superop = qt.spost(l1.dag())
+-            else:
+-                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
+-                                 'and 4.')
+-            superop.dims = E.dims
+-            E = superop*E
+-            sprev = s
+-        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
+-                parallel=self.parallel, opt=self.options)
+-
+-        E.dims = E0.dims
+-        if not notrace:
+-            E = _genptrace(E, kmax)
+-        return E
+-
+-    def rhot(self, rho0, t, tau):
+-        """
+-        Compute the reduced system density matrix :math:`\\rho(t)`
+-
+-        Parameters
+-        ----------
+-        rho0 : :class:`qutip.Qobj`
+-            initial density matrix or state vector (ket)
+-
+-        t : float
+-            current time
+-
+-        tau : float
+-            time-delay
+-
+-        Returns
+-        -------
+-        : :class:`qutip.Qobj`
+-            density matrix at time :math:`t`
+-        """
+-        if qt.isket(rho0):
+-            rho0 = qt.ket2dm(rho0)
+-
+-        E = self.propagator(t, tau)
+-        rhovec = qt.operator_to_vector(rho0)
+-        return qt.vector_to_operator(E*rhovec)
+-
+-    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
+-        r"""
+-        Compute output field expectation value
+-        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
+-        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
+-
+-
+-        Parameters
+-        ----------
+-        rho0 : :class:`qutip.Qobj`
+-            initial density matrix or state vector (ket).
+-
+-        blist : array_like
+-            List of integers specifying the field operators:
+-            0: I (nothing)
+-            1: b_out
+-            2: b_out^\dagger
+-            3: b_loop
+-            4: b_loop^\dagger
+-
+-        tlist : array_like
+-            list of corresponding times t1,..,tn at which to evaluate the field
+-            operators
+-
+-        tau : float
+-            time-delay
+-
+-        c1 : :class:`qutip.Qobj`
+-            system collapse operator that couples to the in-loop field in
+-            question (only needs to be specified if self.L1 has more than one
+-            element)
+-
+-        c2 : :class:`qutip.Qobj`
+-            system collapse operator that couples to the output field in
+-            question (only needs to be specified if self.L2 has more than one
+-            element)
+-
+-        Returns
+-        -------
+-        : complex
+-            expectation value of field correlation function
+-        """
+-        E = self.outfieldpropagator(blist, tlist, tau)
+-        rhovec = qt.operator_to_vector(rho0)
+-        return (qt.vector_to_operator(E*rhovec)).tr()
+-
+-
+-def _localop(op, l, k):
+-    """
+-    Create a local operator on the l'th system by tensoring
+-    with identity operators on all the other k-1 systems
+-    """
+-    if l < 1 or l > k:
+-        raise IndexError('index l out of range')
+-    h = op
+-    I = qt.qeye(op.shape[0])
+-    I.dims = op.dims
+-    for i in range(1, l):
+-        h = qt.tensor(I, h)
+-    for i in range(l+1, k+1):
+-        h = qt.tensor(h, I)
+-    return h
+-
+-
+-def _genptrace(E, k):
+-    """
+-    Perform a gneralized partial trace on a superoperator E, tracing out all
+-    subsystems but one.
+-    """
+-    for l in range(k-1):
+-        nsys = len(E.dims[0][0])
+-        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
+-    return E
+-
+-
+-def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
+-    """
+-    Create a Liouvillian for a cascaded chain of k system copies
+-    """
+-    id = qt.qeye(H.dims[0][0])
+-    Id = qt.sprepost(id, id)
+-    if S is None:
+-        S = np.identity(len(L1))
+-    # create Lindbladian
+-    L = qt.Qobj()
+-    E0 = Id
+-    # first system
+-    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
+-    for l in range(1, k):
+-        # Identiy superoperator
+-        E0 = qt.composite(E0, Id)
+-        # Bare Hamiltonian
+-        Hl = _localop(H, l, k)
+-        L += qt.liouvillian(Hl, [])
+-        # Markovian Decay channels
+-        if c_ops_markov is not None:
+-            for c in c_ops_markov:
+-                cl = _localop(c, l, k)
+-                L += qt.liouvillian(None, [cl])
+-        # Cascade coupling
+-        c1 = np.array([_localop(c, l, k) for c in L1])
+-        c2 = np.array([_localop(c, l+1, k) for c in L2])
+-        c2dag = np.array([c.dag() for c in c2])
+-        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
+-        Hcasc += Hcasc.dag()
+-        Lvec = c2 + np.dot(S, c1)
+-        L += qt.liouvillian(Hcasc, [c for c in Lvec])
+-    # last system
+-    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
+-    if c_ops_markov is not None:
+-        for c in c_ops_markov:
+-            cl = _localop(c, k, k)
+-            L += qt.liouvillian(None, [cl])
+-    E0.dims = L.dims
+-    # return generator and identity superop E0
+-    return L, E0
+-
+-
+-def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
+-        opt=None):
+-    """
+-    Basic ode integrator
+-    """
+-    opt = opt or {}
+-    if tf > ti:
+-        if integrator == 'mesolve':
+-            if parallel:
+-                warnings.warn('parallelization not implemented for "mesolve"')
+-            opt.store_final_state = True
+-            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
+-            return sol.final_state
+-        elif integrator == 'propagator':
+-            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
+-                                 options=opt)*E0
+-        else:
+-            raise ValueError('integrator keyword must be either "propagator"' +
+-                              'or "mesolve"')
+-    else:
+-        return E0
++# -*- coding: utf-8 -*-
++
++# @author: Arne L. Grimsmo
++# @email1: arne.grimsmo@gmail.com
++# @organization: University of Sherbrooke
++
++"""
++This module is an implementation of the method introduced in [1], for
++solving open quantum systems subject to coherent feedback with a single
++discrete time-delay. This method is referred to as the ``memory cascade''
++method in qutip.
++
++[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
++"""
++
++import numpy as np
++import warnings
++
++import qutip as qt
++
++
++class MemoryCascade:
++    """Class for running memory cascade simulations of open quantum systems
++    with time-delayed coherent feedback.
++
++    Attributes
++    ----------
++    H_S : :class:`qutip.Qobj`
++        System Hamiltonian (can also be a Liouvillian)
++
++    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
++        System operators coupling into the feedback loop. Can be a single
++        operator or a list of operators.
++
++    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
++        System operators coupling out of the feedback loop. Can be a single
++        operator or a list of operators. L2 must have the same length as L1.
++
++    S_matrix: *array*
++        S matrix describing which operators in L1 are coupled to which
++        operators in L2 by the feedback channel. Defaults to an n by n identity
++        matrix where n is the number of elements in L1/L2.
++
++    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
++        Decay operators describing conventional Markovian decay channels.
++        Can be a single operator or a list of operators.
++
++    integrator : str {'propagator', 'mesolve'}
++        Integrator method to use. Defaults to 'propagator' which tends to be
++        faster for long times (i.e., large Hilbert space).
++
++    parallel : bool
++        Run integrator in parallel if True. Only implemented for 'propagator'
++        as the integrator method.
++
++    options : dict
++        Generic solver options.
++    """
++
++    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
++                 integrator='propagator', parallel=False, options=None):
++
++        if options is None:
++            self.options = {}
++        else:
++            self.options = options
++
++        self.H_S = H_S
++        self.sysdims = H_S.dims
++        if isinstance(L1, qt.Qobj):
++            self.L1 = [L1]
++        else:
++            self.L1 = L1
++        if isinstance(L2, qt.Qobj):
++            self.L2 = [L2]
++        else:
++            self.L2 = L2
++        if not len(self.L1) == len(self.L2):
++            raise ValueError('L1 and L2 has to be of equal length.')
++        if isinstance(c_ops_markov, qt.Qobj):
++            self.c_ops_markov = [c_ops_markov]
++        else:
++            self.c_ops_markov = c_ops_markov
++
++        if S_matrix is None:
++            self.S_matrix = np.identity(len(self.L1))
++        else:
++            self.S_matrix = S_matrix
++        # create system identity superoperator
++        self.Id = qt.qeye(H_S.shape[0])
++        self.Id.dims = self.sysdims
++        self.Id = qt.sprepost(self.Id, self.Id)
++        self.store_states = self.options['store_states']
++        self.integrator = integrator
++        self.parallel = parallel
++
++    def propagator(self, t, tau, notrace=False):
++        """
++        Compute propagator for time t and time-delay tau
++
++        Parameters
++        ----------
++        t : *float*
++            current time
++
++        tau : *float*
++            time-delay
++
++        notrace : *bool* {False}
++            If this optional is set to True, a propagator is returned for a
++            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
++            If set to False (default), a generalized partial trace is performed
++            and a propagator for a single system is returned.
++        Returns
++        -------
++        : :class:`qutip.Qobj`
++            time-propagator for reduced system dynamics
++        """
++        k = int(t/tau)+1
++        s = t-(k-1)*tau
++        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
++                            self.c_ops_markov)
++        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
++                       parallel=self.parallel, opt=self.options)
++        if k > 1:
++            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
++                                  self.S_matrix, self.c_ops_markov)
++            G2 = qt.composite(G2, self.Id)
++            E = _integrate(G2, E, s, tau, integrator=self.integrator,
++                    parallel=self.parallel, opt=self.options)
++        E.dims = E0.dims
++        if not notrace:
++            E = _genptrace(E, k)
++        return E
++
++    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
++                           notrace=False):
++        r"""
++        Compute propagator for computing output field expectation values
++        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
++        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
++
++        Parameters
++        ----------
++        blist : array_like
++            List of integers specifying the field operators:
++            0: I (nothing)
++            1: b_out
++            2: b_out^\dagger
++            3: b_loop
++            4: b_loop^\dagger
++
++        tlist : array_like
++            list of corresponding times t1,..,tn at which to evaluate the field
++            operators
++
++        tau : float
++            time-delay
++
++        c1 : :class:`qutip.Qobj`
++            system collapse operator that couples to the in-loop field in
++            question (only needs to be specified if self.L1 has more than one
++            element)
++
++        c2 : :class:`qutip.Qobj`
++            system collapse operator that couples to the output field in
++            question (only needs to be specified if self.L2 has more than one
++            element)
++
++        notrace : bool {False}
++            If this optional is set to True, a propagator is returned for a
++            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
++            If set to False (default), a generalized partial trace is performed
++            and a propagator for a single system is returned.
++
++        Returns
++        -------
++        : :class:`qutip.Qobj`
++            time-propagator for computing field correlation function
++        """
++        if c1 is None and len(self.L1) == 1:
++            c1 = self.L1[0]
++        else:
++            raise ValueError('Argument c1 has to be specified when more than' +
++                             'one collapse operator couples to the feedback' +
++                             'loop.')
++        if c2 is None and len(self.L2) == 1:
++            c2 = self.L2[0]
++        else:
++            raise ValueError('Argument c1 has to be specified when more than' +
++                             'one collapse operator couples to the feedback' +
++                             'loop.')
++        klist = []
++        slist = []
++        for t in tlist:
++            klist.append(int(t/tau)+1)
++            slist.append(t-(klist[-1]-1)*tau)
++        kmax = max(klist)
++        zipped = sorted(zip(slist, klist, blist))
++        slist = [s for (s, k, b) in zipped]
++        klist = [k for (s, k, b) in zipped]
++        blist = [b for (s, k, b) in zipped]
++
++        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
++                            self.c_ops_markov)
++        sprev = 0.
++        E = E0
++        for i, s in enumerate(slist):
++            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
++                    parallel=self.parallel, opt=self.options)
++            if klist[i] == 1:
++                l1 = 0.*qt.Qobj()
++            else:
++                l1 = _localop(c1, klist[i]-1, kmax)
++            l2 = _localop(c2, klist[i], kmax)
++            if blist[i] == 0:
++                superop = self.Id
++            elif blist[i] == 1:
++                superop = qt.spre(l1+l2)
++            elif blist[i] == 2:
++                superop = qt.spost(l1.dag()+l2.dag())
++            elif blist[i] == 3:
++                superop = qt.spre(l1)
++            elif blist[i] == 4:
++                superop = qt.spost(l1.dag())
++            else:
++                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
++                                 'and 4.')
++            superop.dims = E.dims
++            E = superop*E
++            sprev = s
++        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
++                parallel=self.parallel, opt=self.options)
++
++        E.dims = E0.dims
++        if not notrace:
++            E = _genptrace(E, kmax)
++        return E
++
++    def rhot(self, rho0, t, tau):
++        """
++        Compute the reduced system density matrix :math:`\\rho(t)`
++
++        Parameters
++        ----------
++        rho0 : :class:`qutip.Qobj`
++            initial density matrix or state vector (ket)
++
++        t : float
++            current time
++
++        tau : float
++            time-delay
++
++        Returns
++        -------
++        : :class:`qutip.Qobj`
++            density matrix at time :math:`t`
++        """
++        if qt.isket(rho0):
++            rho0 = qt.ket2dm(rho0)
++
++        E = self.propagator(t, tau)
++        rhovec = qt.operator_to_vector(rho0)
++        return qt.vector_to_operator(E*rhovec)
++
++    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
++        r"""
++        Compute output field expectation value
++        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
++        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
++
++
++        Parameters
++        ----------
++        rho0 : :class:`qutip.Qobj`
++            initial density matrix or state vector (ket).
++
++        blist : array_like
++            List of integers specifying the field operators:
++            0: I (nothing)
++            1: b_out
++            2: b_out^\dagger
++            3: b_loop
++            4: b_loop^\dagger
++
++        tlist : array_like
++            list of corresponding times t1,..,tn at which to evaluate the field
++            operators
++
++        tau : float
++            time-delay
++
++        c1 : :class:`qutip.Qobj`
++            system collapse operator that couples to the in-loop field in
++            question (only needs to be specified if self.L1 has more than one
++            element)
++
++        c2 : :class:`qutip.Qobj`
++            system collapse operator that couples to the output field in
++            question (only needs to be specified if self.L2 has more than one
++            element)
++
++        Returns
++        -------
++        : complex
++            expectation value of field correlation function
++        """
++        E = self.outfieldpropagator(blist, tlist, tau)
++        rhovec = qt.operator_to_vector(rho0)
++        return (qt.vector_to_operator(E*rhovec)).tr()
++
++
++def _localop(op, l, k):
++    """
++    Create a local operator on the l'th system by tensoring
++    with identity operators on all the other k-1 systems
++    """
++    if l < 1 or l > k:
++        raise IndexError('index l out of range')
++    h = op
++    I = qt.qeye(op.shape[0])
++    I.dims = op.dims
++    for i in range(1, l):
++        h = qt.tensor(I, h)
++    for i in range(l+1, k+1):
++        h = qt.tensor(h, I)
++    return h
++
++
++def _genptrace(E, k):
++    """
++    Perform a gneralized partial trace on a superoperator E, tracing out all
++    subsystems but one.
++    """
++    for l in range(k-1):
++        nsys = len(E.dims[0][0])
++        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
++    return E
++
++
++def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
++    """
++    Create a Liouvillian for a cascaded chain of k system copies
++    """
++    id = qt.qeye(H.dims[0][0])
++    Id = qt.sprepost(id, id)
++    if S is None:
++        S = np.identity(len(L1))
++    # create Lindbladian
++    L = qt.Qobj()
++    E0 = Id
++    # first system
++    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
++    for l in range(1, k):
++        # Identiy superoperator
++        E0 = qt.composite(E0, Id)
++        # Bare Hamiltonian
++        Hl = _localop(H, l, k)
++        L += qt.liouvillian(Hl, [])
++        # Markovian Decay channels
++        if c_ops_markov is not None:
++            for c in c_ops_markov:
++                cl = _localop(c, l, k)
++                L += qt.liouvillian(None, [cl])
++        # Cascade coupling
++        c1 = np.array([_localop(c, l, k) for c in L1])
++        c2 = np.array([_localop(c, l+1, k) for c in L2])
++        c2dag = np.array([c.dag() for c in c2])
++        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
++        Hcasc += Hcasc.dag()
++        Lvec = c2 + np.dot(S, c1)
++        L += qt.liouvillian(Hcasc, [c for c in Lvec])
++    # last system
++    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
++    if c_ops_markov is not None:
++        for c in c_ops_markov:
++            cl = _localop(c, k, k)
++            L += qt.liouvillian(None, [cl])
++    E0.dims = L.dims
++    # return generator and identity superop E0
++    return L, E0
++
++
++def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
++        opt=None):
++    """
++    Basic ode integrator
++    """
++    opt = opt or {}
++    if tf > ti:
++        if integrator == 'mesolve':
++            if parallel:
++                warnings.warn('parallelization not implemented for "mesolve"')
++            opt.store_final_state = True
++            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
++            return sol.final_state
++        elif integrator == 'propagator':
++            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
++                                 options=opt)*E0
++        else:
++            raise ValueError('integrator keyword must be either "propagator"' +
++                              'or "mesolve"')
++    else:
++        return E0
+diff --git a/qutip/solve/nonmarkov/transfertensor.py b/qutip/solve/nonmarkov/transfertensor.py
+index 561b7554..ccd1ada8 100644
+--- a/qutip/solve/nonmarkov/transfertensor.py
++++ b/qutip/solve/nonmarkov/transfertensor.py
+@@ -1,254 +1,254 @@
+-# -*- coding: utf-8 -*-
+-# @author: Arne L. Grimsmo
+-# @email1: arne.grimsmo@gmail.com
+-# @organization: University of Sherbrooke
+-
+-"""
+-This module contains an implementation of the non-Markovian transfer tensor
+-method (TTM), introduced in [1].
+-
+-[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
+-"""
+-
+-import numpy as np
+-
+-
+-from qutip import spre, vector_to_operator, operator_to_vector
+-from qutip.core import data as _data
+-from ..solver import Result, SolverOptions
+-
+-
+-class TTMSolverOptions:
+-    """Class of options for the Transfer Tensor Method solver.
+-
+-    Attributes
+-    ----------
+-    dynmaps : list of :class:`qutip.Qobj`
+-        List of precomputed dynamical maps (superoperators),
+-        or a callback function that returns the
+-        superoperator at a given time.
+-
+-    times : array_like
+-        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
+-
+-    learningtimes : array_like
+-        List of times :math:`t_k` to use as learning times if argument
+-        `dynmaps` is a callback function.
+-
+-    thres : float
+-        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
+-        treshold.
+-
+-    options : :class:`qutip.solver.SolverOptions`
+-        Generic solver options.
+-    """
+-
+-    def __init__(self, dynmaps=None, times=[], learningtimes=[],
+-                 thres=0.0, options=None):
+-        if options is None:
+-            options = SolverOptions()
+-
+-        self.dynmaps = dynmaps
+-        self.times = times
+-        self.learningtimes = learningtimes
+-        self.thres = thres
+-        self.store_states = options['store_states']
+-
+-
+-def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
+-             **kwargs):
+-    """
+-    Solve time-evolution using the Transfer Tensor Method, based on a set of
+-    precomputed dynamical maps.
+-
+-    Parameters
+-    ----------
+-    dynmaps : list of :class:`qutip.Qobj`
+-        List of precomputed dynamical maps (superoperators),
+-        or a callback function that returns the
+-        superoperator at a given time.
+-
+-    rho0 : :class:`qutip.Qobj`
+-        Initial density matrix or state vector (ket).
+-
+-    times : array_like
+-        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
+-        Must be uniformily spaced.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    learningtimes : array_like
+-        list of times :math:`t_k` for which we have knowledge of the dynamical
+-        maps :math:`E(t_k)`.
+-
+-    tensors : array_like
+-        optional list of precomputed tensors :math:`T_k`
+-
+-    kwargs : dictionary
+-        Optional keyword arguments. See
+-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+-
+-    Returns
+-    -------
+-    output: :class:`qutip.solver.Result`
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-
+-    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
+-                           learningtimes=learningtimes, **kwargs)
+-
+-    diff = None
+-
+-    if rho0.isket:
+-        rho0 = rho0.proj()
+-
+-    output = Result()
+-    e_sops_data = []
+-
+-    if callable(e_ops):
+-        n_expt_op = 0
+-        expt_callback = True
+-
+-    else:
+-        try:
+-            tmp = e_ops[:]
+-            del tmp
+-
+-            n_expt_op = len(e_ops)
+-            expt_callback = False
+-
+-            if n_expt_op == 0:
+-                # fall back on storing states
+-                opt.store_states = True
+-
+-            for op in e_ops:
+-                e_sops_data.append(spre(op).data)
+-                if op.isherm and rho0.isherm:
+-                    output.expect.append(np.zeros(len(times)))
+-                else:
+-                    output.expect.append(np.zeros(len(times), dtype=complex))
+-        except TypeError:
+-            raise TypeError("Argument 'e_ops' should be a callable or" +
+-                            "list-like.")
+-
+-    if tensors is None:
+-        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
+-
+-    if rho0.isoper:
+-        # vectorize density matrix
+-        rho0vec = operator_to_vector(rho0)
+-    else:
+-        # rho0 might be a super in which case we should not vectorize
+-        rho0vec = rho0
+-
+-    K = len(tensors)
+-    states = [rho0vec]
+-    for n in range(1, len(times)):
+-        # Set current state
+-        state = None
+-        for j in range(1, min(K, n + 1)):
+-            tmp = tensors[j] * states[n - j]
+-            state = tmp if state is None else tmp + state
+-        # Append state to all states
+-        states.append(state)
+-    for i, r in enumerate(states):
+-        if opt.store_states or expt_callback:
+-            if r.type == 'operator-ket':
+-                states[i] = vector_to_operator(r)
+-            else:
+-                states[i] = r
+-            if expt_callback:
+-                # use callback method
+-                e_ops(times[i], states[i])
+-        rdata = _data.column_stack(r.data)
+-        for m in range(n_expt_op):
+-            if output.expect[m].dtype == complex:
+-                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
+-            else:
+-                output.expect[m][i] =\
+-                    _data.expect_super(e_sops_data[m], rdata).real
+-
+-    output.solver = "ttmsolve"
+-    output.times = times
+-
+-    output.ttmconvergence = diff
+-
+-    if opt.store_states:
+-        output.states = states
+-
+-    return output
+-
+-
+-def _generatetensors(dynmaps, learningtimes=None, **kwargs):
+-    r"""
+-    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
+-    :math:`E(t_k)`.
+-
+-    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
+-
+-    Parameters
+-    ----------
+-    dynmaps : list of :class:`qutip.Qobj`
+-        List of precomputed dynamical maps (superoperators) at the times
+-        specified in `learningtimes`, or a callback function that returns the
+-        superoperator at a given time.
+-
+-    learningtimes : array_like
+-        list of times :math:`t_k` to use if argument `dynmaps` is a callback
+-        function.
+-
+-    kwargs : dictionary
+-        Optional keyword arguments. See
+-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+-
+-    Returns
+-    -------
+-    Tlist: list of :class:`qutip.Qobj.`
+-        A list of transfer tensors :math:`T_1,\dots,T_K`
+-    """
+-
+-    # Determine if dynmaps is callable or list-like
+-    if callable(dynmaps):
+-        if learningtimes is None:
+-            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
+-                            "is a callback function.")
+-
+-        def dynmapfunc(n):
+-            return dynmaps(learningtimes[n])
+-
+-        Kmax = len(learningtimes)
+-    else:
+-        try:
+-            tmp = dynmaps[:]
+-            del tmp
+-
+-            def dynmapfunc(n):
+-                return dynmaps[n]
+-
+-            Kmax = len(dynmaps)
+-        except TypeError:
+-            raise TypeError("Argument 'dynmaps' should be a callable or" +
+-                            "list-like.")
+-
+-    if "opt" not in kwargs:
+-        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
+-                               **kwargs)
+-    else:
+-        opt = kwargs['opt']
+-
+-    Tlist = []
+-    diff = [0.0]
+-    for n in range(Kmax):
+-        T = dynmapfunc(n)
+-        for m in range(1, n):
+-            T -= Tlist[n - m] * dynmapfunc(m)
+-        Tlist.append(T)
+-        if n > 1:
+-            diff.append((Tlist[-1] - Tlist[-2]).norm())
+-            if diff[-1] < opt.thres:
+-                # Below threshold for truncation
+-                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
+-                break
+-    return Tlist, diff
++# -*- coding: utf-8 -*-
++# @author: Arne L. Grimsmo
++# @email1: arne.grimsmo@gmail.com
++# @organization: University of Sherbrooke
++
++"""
++This module contains an implementation of the non-Markovian transfer tensor
++method (TTM), introduced in [1].
++
++[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
++"""
++
++import numpy as np
++
++
++from qutip import spre, vector_to_operator, operator_to_vector
++from qutip.core import data as _data
++from ..solver import Result, SolverOptions
++
++
++class TTMSolverOptions:
++    """Class of options for the Transfer Tensor Method solver.
++
++    Attributes
++    ----------
++    dynmaps : list of :class:`qutip.Qobj`
++        List of precomputed dynamical maps (superoperators),
++        or a callback function that returns the
++        superoperator at a given time.
++
++    times : array_like
++        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
++
++    learningtimes : array_like
++        List of times :math:`t_k` to use as learning times if argument
++        `dynmaps` is a callback function.
++
++    thres : float
++        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
++        treshold.
++
++    options : :class:`qutip.solver.SolverOptions`
++        Generic solver options.
++    """
++
++    def __init__(self, dynmaps=None, times=[], learningtimes=[],
++                 thres=0.0, options=None):
++        if options is None:
++            options = SolverOptions()
++
++        self.dynmaps = dynmaps
++        self.times = times
++        self.learningtimes = learningtimes
++        self.thres = thres
++        self.store_states = options['store_states']
++
++
++def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
++             **kwargs):
++    """
++    Solve time-evolution using the Transfer Tensor Method, based on a set of
++    precomputed dynamical maps.
++
++    Parameters
++    ----------
++    dynmaps : list of :class:`qutip.Qobj`
++        List of precomputed dynamical maps (superoperators),
++        or a callback function that returns the
++        superoperator at a given time.
++
++    rho0 : :class:`qutip.Qobj`
++        Initial density matrix or state vector (ket).
++
++    times : array_like
++        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
++        Must be uniformily spaced.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    learningtimes : array_like
++        list of times :math:`t_k` for which we have knowledge of the dynamical
++        maps :math:`E(t_k)`.
++
++    tensors : array_like
++        optional list of precomputed tensors :math:`T_k`
++
++    kwargs : dictionary
++        Optional keyword arguments. See
++        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
++
++    Returns
++    -------
++    output: :class:`qutip.solver.Result`
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++
++    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
++                           learningtimes=learningtimes, **kwargs)
++
++    diff = None
++
++    if rho0.isket:
++        rho0 = rho0.proj()
++
++    output = Result()
++    e_sops_data = []
++
++    if callable(e_ops):
++        n_expt_op = 0
++        expt_callback = True
++
++    else:
++        try:
++            tmp = e_ops[:]
++            del tmp
++
++            n_expt_op = len(e_ops)
++            expt_callback = False
++
++            if n_expt_op == 0:
++                # fall back on storing states
++                opt.store_states = True
++
++            for op in e_ops:
++                e_sops_data.append(spre(op).data)
++                if op.isherm and rho0.isherm:
++                    output.expect.append(np.zeros(len(times)))
++                else:
++                    output.expect.append(np.zeros(len(times), dtype=complex))
++        except TypeError:
++            raise TypeError("Argument 'e_ops' should be a callable or" +
++                            "list-like.")
++
++    if tensors is None:
++        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
++
++    if rho0.isoper:
++        # vectorize density matrix
++        rho0vec = operator_to_vector(rho0)
++    else:
++        # rho0 might be a super in which case we should not vectorize
++        rho0vec = rho0
++
++    K = len(tensors)
++    states = [rho0vec]
++    for n in range(1, len(times)):
++        # Set current state
++        state = None
++        for j in range(1, min(K, n + 1)):
++            tmp = tensors[j] * states[n - j]
++            state = tmp if state is None else tmp + state
++        # Append state to all states
++        states.append(state)
++    for i, r in enumerate(states):
++        if opt.store_states or expt_callback:
++            if r.type == 'operator-ket':
++                states[i] = vector_to_operator(r)
++            else:
++                states[i] = r
++            if expt_callback:
++                # use callback method
++                e_ops(times[i], states[i])
++        rdata = _data.column_stack(r.data)
++        for m in range(n_expt_op):
++            if output.expect[m].dtype == complex:
++                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
++            else:
++                output.expect[m][i] =\
++                    _data.expect_super(e_sops_data[m], rdata).real
++
++    output.solver = "ttmsolve"
++    output.times = times
++
++    output.ttmconvergence = diff
++
++    if opt.store_states:
++        output.states = states
++
++    return output
++
++
++def _generatetensors(dynmaps, learningtimes=None, **kwargs):
++    r"""
++    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
++    :math:`E(t_k)`.
++
++    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
++
++    Parameters
++    ----------
++    dynmaps : list of :class:`qutip.Qobj`
++        List of precomputed dynamical maps (superoperators) at the times
++        specified in `learningtimes`, or a callback function that returns the
++        superoperator at a given time.
++
++    learningtimes : array_like
++        list of times :math:`t_k` to use if argument `dynmaps` is a callback
++        function.
++
++    kwargs : dictionary
++        Optional keyword arguments. See
++        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
++
++    Returns
++    -------
++    Tlist: list of :class:`qutip.Qobj.`
++        A list of transfer tensors :math:`T_1,\dots,T_K`
++    """
++
++    # Determine if dynmaps is callable or list-like
++    if callable(dynmaps):
++        if learningtimes is None:
++            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
++                            "is a callback function.")
++
++        def dynmapfunc(n):
++            return dynmaps(learningtimes[n])
++
++        Kmax = len(learningtimes)
++    else:
++        try:
++            tmp = dynmaps[:]
++            del tmp
++
++            def dynmapfunc(n):
++                return dynmaps[n]
++
++            Kmax = len(dynmaps)
++        except TypeError:
++            raise TypeError("Argument 'dynmaps' should be a callable or" +
++                            "list-like.")
++
++    if "opt" not in kwargs:
++        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
++                               **kwargs)
++    else:
++        opt = kwargs['opt']
++
++    Tlist = []
++    diff = [0.0]
++    for n in range(Kmax):
++        T = dynmapfunc(n)
++        for m in range(1, n):
++            T -= Tlist[n - m] * dynmapfunc(m)
++        Tlist.append(T)
++        if n > 1:
++            diff.append((Tlist[-1] - Tlist[-2]).norm())
++            if diff[-1] < opt.thres:
++                # Below threshold for truncation
++                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
++                break
++    return Tlist, diff
+diff --git a/qutip/solve/optionsclass.py b/qutip/solve/optionsclass.py
+index b82de812..73c0e709 100644
+--- a/qutip/solve/optionsclass.py
++++ b/qutip/solve/optionsclass.py
+@@ -1,263 +1,263 @@
+-
+-
+-class AllOptions:
+-    """
+-    Class that serve as the parent of all other options class.
+-    """
+-    # Temporary patch to make changes in solver's options minimal.
+-    # TODO: Follow up PR based on #1812 should replace this.
+-    def __init__(self):
+-        self._isDefault = True
+-        self._children = []
+-        self._fullname = "qutip.settings"
+-        self._defaultInstance = self
+-
+-    def _all_children(self):
+-        optcls = []
+-        for child in self._children:
+-            optcls += child._all_children()
+-        return optcls
+-
+-
+-alloptions = AllOptions()
+-
+-
+-def optionsclass(name, parent=alloptions):
+-    """
+-    Use as a decorator to register the options class to `qutip.settings`.
+-    The default will be in added to qutip.setting.[parent].name.
+-
+-    The options class should contain an `options` dictionary containing the
+-    option and their default value. Readonly settings can be defined in
+-    `read_only_options` dict.
+-
+-    ```
+-    >>> import qutip
+-    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
+-    >>> class MyOpt():
+-    >>>     options = {"opt1": True}
+-    >>>     read_only_options = {"hidden": 1}
+-
+-    >>> qutip.settings.solver.myopt['opt1'] = False
+-    >>> qutip.settings.solver.myopt['hidden']
+-    1
+-
+-    >>> qutip.settings.solver.myopt['hidden'] = 2
+-    KeyError: "'hidden': Read-only value"
+-
+-    >>> print(qutip.settings.solver.myopt)
+-    qutip.settings.solver.myopt:
+-    opt1   : False
+-    hidden : 1
+-
+-    print(MyOpt(opt1=2))
+-    qutip.settings.solver.myopt:
+-    opt1   : 2
+-    hidden : 1
+-    ```
+-
+-    It add the methods:
+-        __init__(file=None, *, option=None... )
+-            Allow to create from data in files or from defaults with attributes
+-            overwritten by keywords.
+-        __repr__():
+-            Make a clean print for all 'options' and 'read_only_options'.
+-        __getitem__(), __setitem__():
+-            Pass through to 'self.options' and 'self.read_only_options'.
+-            Option in 'self.read_only_options' can not be set.
+-        save(file='qutiprc'):
+-            Save the object in a file. 'qutiprc' file is loaded as default when
+-            loading qutip.
+-        load(file):
+-            Overwrite with options previously saved.
+-            Loaded options will have the same type as the default from one of:
+-                (bool, int, float, complex, str, object)
+-        reset():
+-            If used on an instance, reset to the default in qutip.settings.
+-            If used from qutip.settings..., go back to qutip's defaults.
+-
+-    """
+-    # The real work is in _QtOptionsMaker
+-    if isinstance(name, str):
+-        # Called as
+-        # @QtOptionsClass(name)
+-        # class Options:
+-        return _QtOptionsMaker(name, parent)
+-    else:
+-        # Called as
+-        # @QtOptionsClass
+-        # class Options:
+-        return _QtOptionsMaker(name.__name__, parent)(name)
+-
+-
+-class _QtOptionsMaker:
+-    """
+-    Apply the `optionsclass` decorator.
+-    """
+-    def __init__(self, name, parent):
+-        self.name = name
+-        self.parent = parent
+-
+-    def __call__(self, cls):
+-        if hasattr(cls, "_isDefault"):
+-            # Already a QtOptionsClass
+-            return
+-
+-        if not hasattr(cls, "read_only_options"):
+-            cls.read_only_options = {}
+-        # type to used when loading from file.
+-        cls._types = {key: type(val) for key, val in cls.options.items()}
+-        # Name in settings and in files
+-        cls._name = self.name
+-        # Name when printing
+-        cls._fullname = ".".join([self.parent._fullname, self.name])
+-        # Is this instance the default for the other.
+-        cls._isDefault = False
+-        # Children in the settings tree
+-        cls._children = []
+-        # Build the default instance
+-        # Do it before setting __init__ since it use this default
+-        self._make_default(cls)
+-
+-        cls.__init__ = _make_init(cls.options)
+-        cls.__repr__ = _repr
+-        cls.__getitem__ = _getitem
+-        cls.__setitem__ = _setitem
+-        cls.__contains__ = _contains
+-        cls.reset = _reset
+-        cls.save = _save
+-        cls.load = _load
+-        cls._all_children = _all_children
+-
+-        return cls
+-
+-    def _make_default(self, cls):
+-        """ Create the default and add it to the parent.
+-        """
+-        default = cls()
+-        default.options = cls.options.copy()
+-        default._isDefault = True
+-        default._children = []
+-        # The parent has the child twice: attribute and in a list.
+-        self.parent._defaultInstance._children.append(default)
+-        setattr(self.parent._defaultInstance, self.name, default)
+-        cls._defaultInstance = default
+-
+-
+-def _make_init(all_set):
+-    attributes_kw = ",\n             ".join(["{}=None".format(key)
+-                    for key in all_set])
+-    attributes_set = "".join(["    if {0} is not None:\n"
+-                              "        self.options['{0}'] = {0}\n".format(key)
+-                     for key in all_set])
+-    code = f"""
+-def __init__(self, file='', *,
+-             {attributes_kw},
+-             _child_instance=False,
+-             **kwargs):
+-    self.options = self._defaultInstance.options.copy()
+-{attributes_set}
+-    if file:
+-        self.load(file)
+-    if hasattr(self, "extra_options"):
+-        other_kw = dict()
+-        for kw in kwargs:
+-            if kw in self.extra_options:
+-                self.options[kw] = kwargs[kw]
+-            else:
+-                other_kw[kw] = kwargs[kw]
+-        kwargs = other_kw
+-    self._children = []
+-    for child in self._defaultInstance._children:
+-        self._children.append(child.__class__(file, _child_instance=True,
+-                                              **kwargs))
+-        setattr(self, child._name, self._children[-1])
+-        kwargs = self._children[-1].left_over_kwargs
+-    if _child_instance:
+-        self.left_over_kwargs = kwargs
+-    elif kwargs:
+-        raise KeyError("Unknown options: " +
+-                       " ,".join(str(key) for key in kwargs))
+-"""
+-    ns = {}
+-    exec(code, globals(), ns)
+-    return ns["__init__"]
+-
+-
+-def _repr(self, _recursive=True):
+-    out = self._fullname + ":\n"
+-    longest = max(len(key) for key in self.options)
+-    if self.read_only_options:
+-        longest_readonly = max(len(key) for key in self.read_only_options)
+-        longest = max((longest, longest_readonly))
+-    for key, val in self.options.items():
+-        if isinstance(val, str):
+-            out += "{:{width}} : '{}'\n".format(key, val,
+-                                                width=longest)
+-        else:
+-            out += "{:{width}} : {}\n".format(key, val,
+-                                              width=longest)
+-    for key, val in self.read_only_options.items():
+-        out += "{:{width}} : {}\n".format(key, val,
+-                                          width=longest)
+-    out += "\n"
+-    if _recursive:
+-         out += "".join([child.__repr__(_recursive)
+-                         for child in self._children])
+-    return out
+-
+-
+-def _reset(self, _recursive=False):
+-    """Reset instance to the default value or the default to Qutip's default"""
+-    if self._isDefault:
+-        self.options = self.__class__.options.copy()
+-        if _recursive:
+-            for child in self._children:
+-                child.reset()
+-    else:
+-        self.options = self._defaultInstance.options.copy()
+-
+-
+-def _all_children(self):
+-    optcls = [self]
+-    for child in self._children:
+-         optcls += child._all_children()
+-    return optcls
+-
+-
+-def _save(self, file="qutiprc", _recursive=False):
+-    """Save to desired file. 'qutiprc' if not specified"""
+-    import qutip.configrc as qrc
+-    if _recursive:
+-        optcls = self._all_children()
+-    else:
+-        optcls = [self]
+-    qrc.write_rc_object(file, optcls)
+-
+-
+-def _load(self, file="qutiprc", _recursive=False):
+-    """Load from desired file. 'qutiprc' if not specified"""
+-    import qutip.configrc as qrc
+-    if _recursive:
+-        optcls = self._all_children()
+-    else:
+-        optcls = [self]
+-    qrc.load_rc_object(file, optcls)
+-
+-
+-def _contains(self, key):
+-    return key in self.read_only_options or key in self.options
+-
+-
+-def _getitem(self, key):
+-    # Let the dict catch the KeyError
+-    if key in self.read_only_options:
+-        return self.read_only_options[key]
+-    return self.options[key]
+-
+-
+-def _setitem(self, key, value):
+-    # Let the dict catch the KeyError
+-    if key in self.read_only_options:
+-        raise KeyError(f"'{key}': Read-only value")
+-    self.options[key] = value
++
++
++class AllOptions:
++    """
++    Class that serve as the parent of all other options class.
++    """
++    # Temporary patch to make changes in solver's options minimal.
++    # TODO: Follow up PR based on #1812 should replace this.
++    def __init__(self):
++        self._isDefault = True
++        self._children = []
++        self._fullname = "qutip.settings"
++        self._defaultInstance = self
++
++    def _all_children(self):
++        optcls = []
++        for child in self._children:
++            optcls += child._all_children()
++        return optcls
++
++
++alloptions = AllOptions()
++
++
++def optionsclass(name, parent=alloptions):
++    """
++    Use as a decorator to register the options class to `qutip.settings`.
++    The default will be in added to qutip.setting.[parent].name.
++
++    The options class should contain an `options` dictionary containing the
++    option and their default value. Readonly settings can be defined in
++    `read_only_options` dict.
++
++    ```
++    >>> import qutip
++    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
++    >>> class MyOpt():
++    >>>     options = {"opt1": True}
++    >>>     read_only_options = {"hidden": 1}
++
++    >>> qutip.settings.solver.myopt['opt1'] = False
++    >>> qutip.settings.solver.myopt['hidden']
++    1
++
++    >>> qutip.settings.solver.myopt['hidden'] = 2
++    KeyError: "'hidden': Read-only value"
++
++    >>> print(qutip.settings.solver.myopt)
++    qutip.settings.solver.myopt:
++    opt1   : False
++    hidden : 1
++
++    print(MyOpt(opt1=2))
++    qutip.settings.solver.myopt:
++    opt1   : 2
++    hidden : 1
++    ```
++
++    It add the methods:
++        __init__(file=None, *, option=None... )
++            Allow to create from data in files or from defaults with attributes
++            overwritten by keywords.
++        __repr__():
++            Make a clean print for all 'options' and 'read_only_options'.
++        __getitem__(), __setitem__():
++            Pass through to 'self.options' and 'self.read_only_options'.
++            Option in 'self.read_only_options' can not be set.
++        save(file='qutiprc'):
++            Save the object in a file. 'qutiprc' file is loaded as default when
++            loading qutip.
++        load(file):
++            Overwrite with options previously saved.
++            Loaded options will have the same type as the default from one of:
++                (bool, int, float, complex, str, object)
++        reset():
++            If used on an instance, reset to the default in qutip.settings.
++            If used from qutip.settings..., go back to qutip's defaults.
++
++    """
++    # The real work is in _QtOptionsMaker
++    if isinstance(name, str):
++        # Called as
++        # @QtOptionsClass(name)
++        # class Options:
++        return _QtOptionsMaker(name, parent)
++    else:
++        # Called as
++        # @QtOptionsClass
++        # class Options:
++        return _QtOptionsMaker(name.__name__, parent)(name)
++
++
++class _QtOptionsMaker:
++    """
++    Apply the `optionsclass` decorator.
++    """
++    def __init__(self, name, parent):
++        self.name = name
++        self.parent = parent
++
++    def __call__(self, cls):
++        if hasattr(cls, "_isDefault"):
++            # Already a QtOptionsClass
++            return
++
++        if not hasattr(cls, "read_only_options"):
++            cls.read_only_options = {}
++        # type to used when loading from file.
++        cls._types = {key: type(val) for key, val in cls.options.items()}
++        # Name in settings and in files
++        cls._name = self.name
++        # Name when printing
++        cls._fullname = ".".join([self.parent._fullname, self.name])
++        # Is this instance the default for the other.
++        cls._isDefault = False
++        # Children in the settings tree
++        cls._children = []
++        # Build the default instance
++        # Do it before setting __init__ since it use this default
++        self._make_default(cls)
++
++        cls.__init__ = _make_init(cls.options)
++        cls.__repr__ = _repr
++        cls.__getitem__ = _getitem
++        cls.__setitem__ = _setitem
++        cls.__contains__ = _contains
++        cls.reset = _reset
++        cls.save = _save
++        cls.load = _load
++        cls._all_children = _all_children
++
++        return cls
++
++    def _make_default(self, cls):
++        """ Create the default and add it to the parent.
++        """
++        default = cls()
++        default.options = cls.options.copy()
++        default._isDefault = True
++        default._children = []
++        # The parent has the child twice: attribute and in a list.
++        self.parent._defaultInstance._children.append(default)
++        setattr(self.parent._defaultInstance, self.name, default)
++        cls._defaultInstance = default
++
++
++def _make_init(all_set):
++    attributes_kw = ",\n             ".join(["{}=None".format(key)
++                    for key in all_set])
++    attributes_set = "".join(["    if {0} is not None:\n"
++                              "        self.options['{0}'] = {0}\n".format(key)
++                     for key in all_set])
++    code = f"""
++def __init__(self, file='', *,
++             {attributes_kw},
++             _child_instance=False,
++             **kwargs):
++    self.options = self._defaultInstance.options.copy()
++{attributes_set}
++    if file:
++        self.load(file)
++    if hasattr(self, "extra_options"):
++        other_kw = dict()
++        for kw in kwargs:
++            if kw in self.extra_options:
++                self.options[kw] = kwargs[kw]
++            else:
++                other_kw[kw] = kwargs[kw]
++        kwargs = other_kw
++    self._children = []
++    for child in self._defaultInstance._children:
++        self._children.append(child.__class__(file, _child_instance=True,
++                                              **kwargs))
++        setattr(self, child._name, self._children[-1])
++        kwargs = self._children[-1].left_over_kwargs
++    if _child_instance:
++        self.left_over_kwargs = kwargs
++    elif kwargs:
++        raise KeyError("Unknown options: " +
++                       " ,".join(str(key) for key in kwargs))
++"""
++    ns = {}
++    exec(code, globals(), ns)
++    return ns["__init__"]
++
++
++def _repr(self, _recursive=True):
++    out = self._fullname + ":\n"
++    longest = max(len(key) for key in self.options)
++    if self.read_only_options:
++        longest_readonly = max(len(key) for key in self.read_only_options)
++        longest = max((longest, longest_readonly))
++    for key, val in self.options.items():
++        if isinstance(val, str):
++            out += "{:{width}} : '{}'\n".format(key, val,
++                                                width=longest)
++        else:
++            out += "{:{width}} : {}\n".format(key, val,
++                                              width=longest)
++    for key, val in self.read_only_options.items():
++        out += "{:{width}} : {}\n".format(key, val,
++                                          width=longest)
++    out += "\n"
++    if _recursive:
++         out += "".join([child.__repr__(_recursive)
++                         for child in self._children])
++    return out
++
++
++def _reset(self, _recursive=False):
++    """Reset instance to the default value or the default to Qutip's default"""
++    if self._isDefault:
++        self.options = self.__class__.options.copy()
++        if _recursive:
++            for child in self._children:
++                child.reset()
++    else:
++        self.options = self._defaultInstance.options.copy()
++
++
++def _all_children(self):
++    optcls = [self]
++    for child in self._children:
++         optcls += child._all_children()
++    return optcls
++
++
++def _save(self, file="qutiprc", _recursive=False):
++    """Save to desired file. 'qutiprc' if not specified"""
++    import qutip.configrc as qrc
++    if _recursive:
++        optcls = self._all_children()
++    else:
++        optcls = [self]
++    qrc.write_rc_object(file, optcls)
++
++
++def _load(self, file="qutiprc", _recursive=False):
++    """Load from desired file. 'qutiprc' if not specified"""
++    import qutip.configrc as qrc
++    if _recursive:
++        optcls = self._all_children()
++    else:
++        optcls = [self]
++    qrc.load_rc_object(file, optcls)
++
++
++def _contains(self, key):
++    return key in self.read_only_options or key in self.options
++
++
++def _getitem(self, key):
++    # Let the dict catch the KeyError
++    if key in self.read_only_options:
++        return self.read_only_options[key]
++    return self.options[key]
++
++
++def _setitem(self, key, value):
++    # Let the dict catch the KeyError
++    if key in self.read_only_options:
++        raise KeyError(f"'{key}': Read-only value")
++    self.options[key] = value
+diff --git a/qutip/solve/parallel.py b/qutip/solve/parallel.py
+index 36e35b85..02f0d8f7 100644
+--- a/qutip/solve/parallel.py
++++ b/qutip/solve/parallel.py
+@@ -1,241 +1,241 @@
+-"""
+-This function provides functions for parallel execution of loops and function
+-mappings, using the builtin Python module multiprocessing.
+-"""
+-__all__ = ['parallel_map', 'serial_map']
+-
+-from scipy import array
+-import multiprocessing
+-from functools import partial
+-import os
+-import sys
+-import signal
+-from qutip.settings import settings as qset
+-from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
+-
+-
+-if sys.platform == 'darwin':
+-    Pool = multiprocessing.get_context('fork').Pool
+-else:
+-    Pool = multiprocessing.Pool
+-
+-
+-def _task_wrapper(args):
+-    try:
+-        return args[0](*args[1])
+-    except KeyboardInterrupt:
+-        os.kill(args[2], signal.SIGINT)
+-        sys.exit(1)
+-
+-
+-def _task_wrapper_with_args(args, user_args):
+-    try:
+-        return args[0](*args[1], **user_args)
+-    except KeyboardInterrupt:
+-        os.kill(args[2], signal.SIGINT)
+-        sys.exit(1)
+-
+-
+-def parfor(func, *args, **kwargs):
+-    """Executes a multi-variable function in parallel on the local machine.
+-
+-    Parallel execution of a for-loop over function `func` for multiple input
+-    arguments and keyword arguments.
+-
+-    .. note::
+-
+-        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
+-        instead of this function.
+-
+-    Parameters
+-    ----------
+-    func : function_type
+-        A function to run in parallel on the local machine. The function 'func'
+-        accepts a series of arguments that are passed to the function as
+-        variables. In general, the function can have multiple input variables,
+-        and these arguments must be passed in the same order as they are
+-        defined in the function definition.  In addition, the user can pass
+-        multiple keyword arguments to the function.
+-
+-    The following keyword argument is reserved:
+-
+-    num_cpus : int
+-        Number of CPU's to use.  Default uses maximum number of CPU's.
+-        Performance degrades if num_cpus is larger than the physical CPU
+-        count of your machine.
+-
+-    Returns
+-    -------
+-    result : list
+-        A ``list`` with length equal to number of input parameters
+-        containing the output from `func`.
+-
+-    """
+-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+-    kw = _default_kwargs()
+-    if 'num_cpus' in kwargs.keys():
+-        kw['num_cpus'] = kwargs['num_cpus']
+-        del kwargs['num_cpus']
+-    if len(kwargs) != 0:
+-        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
+-    else:
+-        task_func = _task_wrapper
+-
+-    # if kw['num_cpus'] > qset.num_cpus:
+-    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
+-    #          "is larger than physical number (%s)." % qset.num_cpus)
+-    #    print("Reduce 'num_cpus' for greater performance.")
+-
+-    pool = Pool(processes=kw['num_cpus'])
+-    args = [list(arg) for arg in args]
+-    var = [[args[j][i] for j in range(len(args))]
+-           for i in range(len(list(args[0])))]
+-    try:
+-        map_args = ((func, v, os.getpid()) for v in var)
+-        par_return = list(pool.map(task_func, map_args))
+-
+-        pool.terminate()
+-        pool.join()
+-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-        if isinstance(par_return[0], tuple):
+-            par_return = [elem for elem in par_return]
+-            num_elems = len(par_return[0])
+-            dt = [type(ii) for ii in par_return[0]]
+-            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
+-                    for ii in range(num_elems)]
+-        else:
+-            return par_return
+-
+-    except KeyboardInterrupt:
+-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-        pool.terminate()
+-
+-
+-def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
+-    """
+-    Serial mapping function with the same call signature as parallel_map, for
+-    easy switching between serial and parallel execution. This
+-    is functionally equivalent to::
+-
+-        result = [task(value, *task_args, **task_kwargs) for value in values]
+-
+-    This function work as a drop-in replacement of
+-    :func:`qutip.parallel.parallel_map`.
+-
+-    Parameters
+-    ----------
+-    task : a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-    values : array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-    task_args : list / dictionary
+-        The optional additional argument to the ``task`` function.
+-    task_kwargs : list / dictionary
+-        The optional additional keyword argument to the ``task`` function.
+-    progress_bar : ProgressBar
+-        Progress bar class instance for showing progress.
+-
+-    Returns
+-    --------
+-    result : list
+-        The result list contains the value of
+-        ``task(value, *task_args, **task_kwargs)`` for each
+-        value in ``values``.
+-
+-    """
+-    try:
+-        progress_bar = kwargs['progress_bar']
+-        if progress_bar is True:
+-            progress_bar = TextProgressBar()
+-    except:
+-        progress_bar = BaseProgressBar()
+-
+-    progress_bar.start(len(values))
+-    results = []
+-    for n, value in enumerate(values):
+-        progress_bar.update(n)
+-        result = task(value, *task_args, **task_kwargs)
+-        results.append(result)
+-    progress_bar.finished()
+-
+-    return results
+-
+-
+-def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
+-    """
+-    Parallel execution of a mapping of `values` to the function `task`. This
+-    is functionally equivalent to::
+-
+-        result = [task(value, *task_args, **task_kwargs) for value in values]
+-
+-    Parameters
+-    ----------
+-    task : a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-    values : array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-    task_args : list / dictionary
+-        The optional additional argument to the ``task`` function.
+-    task_kwargs : list / dictionary
+-        The optional additional keyword argument to the ``task`` function.
+-    progress_bar : ProgressBar
+-        Progress bar class instance for showing progress.
+-
+-    Returns
+-    --------
+-    result : list
+-        The result list contains the value of
+-        ``task(value, *task_args, **task_kwargs)`` for
+-        each value in ``values``.
+-
+-    """
+-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+-    kw = _default_kwargs()
+-    if 'num_cpus' in kwargs:
+-        kw['num_cpus'] = kwargs['num_cpus']
+-
+-    try:
+-        progress_bar = kwargs['progress_bar']
+-        if progress_bar is True:
+-            progress_bar = TextProgressBar()
+-    except:
+-        progress_bar = BaseProgressBar()
+-
+-    progress_bar.start(len(values))
+-    nfinished = [0]
+-
+-    def _update_progress_bar(x):
+-        nfinished[0] += 1
+-        progress_bar.update(nfinished[0])
+-
+-    try:
+-        pool = Pool(processes=kw['num_cpus'])
+-
+-        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
+-                                      _update_progress_bar)
+-                     for value in values]
+-
+-        while not all([ar.ready() for ar in async_res]):
+-            for ar in async_res:
+-                ar.wait(timeout=0.1)
+-
+-        pool.terminate()
+-        pool.join()
+-
+-    except KeyboardInterrupt as e:
+-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-        pool.terminate()
+-        pool.join()
+-        raise e
+-
+-    progress_bar.finished()
+-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-    return [ar.get() for ar in async_res]
+-
+-
+-def _default_kwargs():
+-
+-    settings = {'num_cpus': multiprocessing.cpu_count()}
+-    return settings
++"""
++This function provides functions for parallel execution of loops and function
++mappings, using the builtin Python module multiprocessing.
++"""
++__all__ = ['parallel_map', 'serial_map']
++
++from scipy import array
++import multiprocessing
++from functools import partial
++import os
++import sys
++import signal
++from qutip.settings import settings as qset
++from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
++
++
++if sys.platform == 'darwin':
++    Pool = multiprocessing.get_context('fork').Pool
++else:
++    Pool = multiprocessing.Pool
++
++
++def _task_wrapper(args):
++    try:
++        return args[0](*args[1])
++    except KeyboardInterrupt:
++        os.kill(args[2], signal.SIGINT)
++        sys.exit(1)
++
++
++def _task_wrapper_with_args(args, user_args):
++    try:
++        return args[0](*args[1], **user_args)
++    except KeyboardInterrupt:
++        os.kill(args[2], signal.SIGINT)
++        sys.exit(1)
++
++
++def parfor(func, *args, **kwargs):
++    """Executes a multi-variable function in parallel on the local machine.
++
++    Parallel execution of a for-loop over function `func` for multiple input
++    arguments and keyword arguments.
++
++    .. note::
++
++        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
++        instead of this function.
++
++    Parameters
++    ----------
++    func : function_type
++        A function to run in parallel on the local machine. The function 'func'
++        accepts a series of arguments that are passed to the function as
++        variables. In general, the function can have multiple input variables,
++        and these arguments must be passed in the same order as they are
++        defined in the function definition.  In addition, the user can pass
++        multiple keyword arguments to the function.
++
++    The following keyword argument is reserved:
++
++    num_cpus : int
++        Number of CPU's to use.  Default uses maximum number of CPU's.
++        Performance degrades if num_cpus is larger than the physical CPU
++        count of your machine.
++
++    Returns
++    -------
++    result : list
++        A ``list`` with length equal to number of input parameters
++        containing the output from `func`.
++
++    """
++    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
++    kw = _default_kwargs()
++    if 'num_cpus' in kwargs.keys():
++        kw['num_cpus'] = kwargs['num_cpus']
++        del kwargs['num_cpus']
++    if len(kwargs) != 0:
++        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
++    else:
++        task_func = _task_wrapper
++
++    # if kw['num_cpus'] > qset.num_cpus:
++    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
++    #          "is larger than physical number (%s)." % qset.num_cpus)
++    #    print("Reduce 'num_cpus' for greater performance.")
++
++    pool = Pool(processes=kw['num_cpus'])
++    args = [list(arg) for arg in args]
++    var = [[args[j][i] for j in range(len(args))]
++           for i in range(len(list(args[0])))]
++    try:
++        map_args = ((func, v, os.getpid()) for v in var)
++        par_return = list(pool.map(task_func, map_args))
++
++        pool.terminate()
++        pool.join()
++        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++        if isinstance(par_return[0], tuple):
++            par_return = [elem for elem in par_return]
++            num_elems = len(par_return[0])
++            dt = [type(ii) for ii in par_return[0]]
++            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
++                    for ii in range(num_elems)]
++        else:
++            return par_return
++
++    except KeyboardInterrupt:
++        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++        pool.terminate()
++
++
++def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
++    """
++    Serial mapping function with the same call signature as parallel_map, for
++    easy switching between serial and parallel execution. This
++    is functionally equivalent to::
++
++        result = [task(value, *task_args, **task_kwargs) for value in values]
++
++    This function work as a drop-in replacement of
++    :func:`qutip.parallel.parallel_map`.
++
++    Parameters
++    ----------
++    task : a Python function
++        The function that is to be called for each value in ``task_vec``.
++    values : array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++    task_args : list / dictionary
++        The optional additional argument to the ``task`` function.
++    task_kwargs : list / dictionary
++        The optional additional keyword argument to the ``task`` function.
++    progress_bar : ProgressBar
++        Progress bar class instance for showing progress.
++
++    Returns
++    --------
++    result : list
++        The result list contains the value of
++        ``task(value, *task_args, **task_kwargs)`` for each
++        value in ``values``.
++
++    """
++    try:
++        progress_bar = kwargs['progress_bar']
++        if progress_bar is True:
++            progress_bar = TextProgressBar()
++    except:
++        progress_bar = BaseProgressBar()
++
++    progress_bar.start(len(values))
++    results = []
++    for n, value in enumerate(values):
++        progress_bar.update(n)
++        result = task(value, *task_args, **task_kwargs)
++        results.append(result)
++    progress_bar.finished()
++
++    return results
++
++
++def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
++    """
++    Parallel execution of a mapping of `values` to the function `task`. This
++    is functionally equivalent to::
++
++        result = [task(value, *task_args, **task_kwargs) for value in values]
++
++    Parameters
++    ----------
++    task : a Python function
++        The function that is to be called for each value in ``task_vec``.
++    values : array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++    task_args : list / dictionary
++        The optional additional argument to the ``task`` function.
++    task_kwargs : list / dictionary
++        The optional additional keyword argument to the ``task`` function.
++    progress_bar : ProgressBar
++        Progress bar class instance for showing progress.
++
++    Returns
++    --------
++    result : list
++        The result list contains the value of
++        ``task(value, *task_args, **task_kwargs)`` for
++        each value in ``values``.
++
++    """
++    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
++    kw = _default_kwargs()
++    if 'num_cpus' in kwargs:
++        kw['num_cpus'] = kwargs['num_cpus']
++
++    try:
++        progress_bar = kwargs['progress_bar']
++        if progress_bar is True:
++            progress_bar = TextProgressBar()
++    except:
++        progress_bar = BaseProgressBar()
++
++    progress_bar.start(len(values))
++    nfinished = [0]
++
++    def _update_progress_bar(x):
++        nfinished[0] += 1
++        progress_bar.update(nfinished[0])
++
++    try:
++        pool = Pool(processes=kw['num_cpus'])
++
++        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
++                                      _update_progress_bar)
++                     for value in values]
++
++        while not all([ar.ready() for ar in async_res]):
++            for ar in async_res:
++                ar.wait(timeout=0.1)
++
++        pool.terminate()
++        pool.join()
++
++    except KeyboardInterrupt as e:
++        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++        pool.terminate()
++        pool.join()
++        raise e
++
++    progress_bar.finished()
++    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++    return [ar.get() for ar in async_res]
++
++
++def _default_kwargs():
++
++    settings = {'num_cpus': multiprocessing.cpu_count()}
++    return settings
+diff --git a/qutip/solve/pdpsolve.py b/qutip/solve/pdpsolve.py
+index 1a1d2964..e295b237 100644
+--- a/qutip/solve/pdpsolve.py
++++ b/qutip/solve/pdpsolve.py
+@@ -1,575 +1,575 @@
+-# -*- coding: utf-8 -*-
+-
+-import numpy as np
+-from numpy.random import RandomState
+-
+-from .. import (
+-    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
+-)
+-from ..core import data as _data
+-from .solver import Result, SolverOptions
+-from .parallel import serial_map
+-from ..ui.progressbar import TextProgressBar
+-from ..settings import settings
+-debug = settings.debug
+-
+-
+-class StochasticSolverOptions:
+-    """
+-    Class of options for stochastic (piecewse deterministic process) PDP
+-    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
+-    :func:`qutip.pdpsolve.smepdpsolve`.
+-    Options can be specified either as arguments to the constructor::
+-
+-        sso = StochasticSolverOptions(nsubsteps=100, ...)
+-
+-    or by changing the class attributes after creation::
+-
+-        sso = StochasticSolverOptions()
+-        sso.nsubsteps = 1000
+-
+-    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
+-    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
+-    the constructor of these class, and internally they use these arguments to
+-    construct an instance of this class, so it is rarely needed to explicitly
+-    create an instance of this class.
+-
+-    Attributes
+-    ----------
+-
+-    H : :class:`qutip.Qobj`
+-        System Hamiltonian.
+-
+-    state0 : :class:`qutip.Qobj`
+-        Initial state vector (ket) or density matrix.
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`
+-        List of deterministic collapse operators.
+-
+-    sc_ops : list of :class:`qutip.Qobj`
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the equation of motion according to how the d1 and d2 functions
+-        are defined.
+-
+-    e_ops : list of :class:`qutip.Qobj`
+-        Single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    m_ops : list of :class:`qutip.Qobj`
+-        List of operators representing the measurement operators. The expected
+-        format is a nested list with one measurement operator for each
+-        stochastic increament, for each stochastic collapse operator.
+-
+-    args : dict / list
+-        List of dictionary of additional problem-specific parameters.
+-        Implicit methods can adjust tolerance via args = {'tol':value}
+-
+-    ntraj : int
+-        Number of trajectors.
+-
+-    nsubsteps : int
+-        Number of sub steps between each time-spep given in `times`.
+-
+-    d1 : function
+-        Function for calculating the operator-valued coefficient to the
+-        deterministic increment dt.
+-
+-    d2 : function
+-        Function for calculating the operator-valued coefficient to the
+-        stochastic increment(s) dW_n, where n is in [0, d2_len[.
+-
+-    d2_len : int (default 1)
+-        The number of stochastic increments in the process.
+-
+-    dW_factors : array
+-        Array of length d2_len, containing scaling factors for each
+-        measurement operator in m_ops.
+-
+-    rhs : function
+-        Function for calculating the deterministic and stochastic contributions
+-        to the right-hand side of the stochastic differential equation. This
+-        only needs to be specified when implementing a custom SDE solver.
+-
+-    generate_A_ops : function
+-        Function that generates a list of pre-computed operators or super-
+-        operators. These precomputed operators are used in some d1 and d2
+-        functions.
+-
+-    generate_noise : function
+-        Function for generate an array of pre-computed noise signal.
+-
+-    homogeneous : bool (True)
+-        Wheter or not the stochastic process is homogenous. Inhomogenous
+-        processes are only supported for poisson distributions.
+-
+-    solver : string
+-        Name of the solver method to use for solving the stochastic
+-        equations. Valid values are:
+-        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
+-        'pc-euler' is a predictor-corrector method which is more
+-        stable than explicit methods,
+-        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
+-        'milstein-imp' is semi-implicit Milstein method,
+-        3/2 order algorithms: 'taylor15',
+-        'taylor15-imp' is semi-implicit Taylor 1.5 method.
+-        Implicit methods can adjust tolerance via args = {'tol':value},
+-        default is {'tol':1e-6}
+-
+-    method : string ('homodyne', 'heterodyne', 'photocurrent')
+-        The name of the type of measurement process that give rise to the
+-        stochastic equation to solve. Specifying a method with this keyword
+-        argument is a short-hand notation for using pre-defined d1 and d2
+-        functions for the corresponding stochastic processes.
+-
+-    distribution : string ('normal', 'poisson')
+-        The name of the distribution used for the stochastic increments.
+-
+-    store_measurements : bool (default False)
+-        Whether or not to store the measurement results in the
+-        :class:`qutip.solver.Result` instance returned by the solver.
+-
+-    noise : array
+-        Vector specifying the noise.
+-
+-    normalize : bool (default True)
+-        Whether or not to normalize the wave function during the evolution.
+-
+-    options : :class:`qutip.solver.SolverOptions`
+-        Generic solver options.
+-
+-    map_func: function
+-        A map function or managing the calls to single-trajactory solvers.
+-
+-    map_kwargs: dictionary
+-        Optional keyword arguments to the map_func function function.
+-
+-    progress_bar : :class:`qutip.ui.BaseProgressBar`
+-        Optional progress bar class instance.
+-    """
+-    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
+-                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
+-                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
+-                 generate_A_ops=None, generate_noise=None, homogeneous=True,
+-                 solver=None, method=None, distribution='normal',
+-                 store_measurement=False, noise=None, normalize=True,
+-                 options=None, progress_bar=None, map_func=None,
+-                 map_kwargs=None):
+-
+-        if options is None:
+-            options = SolverOptions()
+-
+-        if progress_bar is None:
+-            progress_bar = TextProgressBar()
+-
+-        self.H = H
+-        self.d1 = d1
+-        self.d2 = d2
+-        self.d2_len = d2_len
+-        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
+-        self.state0 = state0
+-        self.times = times
+-        self.c_ops = c_ops
+-        self.sc_ops = sc_ops
+-        self.e_ops = e_ops
+-        self.m_ops = m_ops
+-
+-        self.ntraj = ntraj
+-        self.nsubsteps = nsubsteps
+-        self.solver = solver
+-        self.method = method
+-        self.distribution = distribution
+-        self.homogeneous = homogeneous
+-        self.rhs = rhs
+-        self.options = options
+-        self.progress_bar = progress_bar
+-        self.store_measurement = store_measurement
+-        self.store_states = options['store_states']
+-        self.noise = noise
+-        self.args = args
+-        self.normalize = normalize
+-
+-        self.generate_noise = generate_noise
+-        self.generate_A_ops = generate_A_ops
+-
+-        if self.ntraj > 1 and map_func:
+-            self.map_func = map_func
+-        else:
+-            self.map_func = serial_map
+-
+-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
+-
+-        # Does any operator depend on time?
+-        self.td = False
+-        if not isinstance(H, Qobj):
+-            self.td = True
+-        for ops in c_ops:
+-            if not isinstance(ops, Qobj):
+-                self.td = True
+-        for ops in sc_ops:
+-            if not isinstance(ops, Qobj):
+-                self.td = True
+-
+-
+-def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
+-    """
+-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
+-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
+-    trajectory simulations.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`
+-        System Hamiltonian.
+-
+-    psi0 : :class:`qutip.Qobj`
+-        Initial state vector (ket).
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`
+-        Deterministic collapse operator which will contribute with a standard
+-        Lindblad type of dissipation.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function single
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = [e for e in e_ops.values()]
+-    else:
+-        e_ops_dict = None
+-
+-    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
+-                                  e_ops=e_ops, **kwargs)
+-
+-    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-    return res
+-
+-
+-def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
+-    """
+-    A stochastic (piecewse deterministic process) PDP solver for density matrix
+-    evolution.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`
+-        System Hamiltonian.
+-
+-    rho0 : :class:`qutip.Qobj`
+-        Initial density matrix.
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`
+-        Deterministic collapse operator which will contribute with a standard
+-        Lindblad type of dissipation.
+-
+-    sc_ops : list of :class:`qutip.Qobj`
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the equation of motion according to how the d1 and d2 functions
+-        are defined.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function single
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = [e for e in e_ops.values()]
+-    else:
+-        e_ops_dict = None
+-
+-    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
+-                                  e_ops=e_ops, **kwargs)
+-
+-    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-    return res
+-
+-
+-# -----------------------------------------------------------------------------
+-# Generic parameterized stochastic SE PDP solver
+-#
+-def _ssepdpsolve_generic(sso, options, progress_bar):
+-    """
+-    For internal use. See ssepdpsolve.
+-    """
+-    N_store = len(sso.times)
+-    N_substeps = sso.nsubsteps
+-    dt = (sso.times[1] - sso.times[0]) / N_substeps
+-    nt = sso.ntraj
+-
+-    data = Result()
+-    data.solver = "sepdpsolve"
+-    data.times = sso.tlist
+-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+-    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+-    data.jump_times = []
+-    data.jump_op_idx = []
+-
+-    # effective hamiltonian for deterministic part
+-    Heff = sso.H
+-    for c in sso.c_ops:
+-        Heff += -0.5j * c.dag() * c
+-
+-    progress_bar.start(sso.ntraj)
+-    for n in range(sso.ntraj):
+-        progress_bar.update(n)
+-        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
+-
+-        states_list, jump_times, jump_op_idx = \
+-            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
+-                                           N_store, N_substeps,
+-                                           psi_t, sso.state0.dims,
+-                                           sso.c_ops, sso.e_ops)
+-
+-        data.states.append(states_list)
+-        data.jump_times.append(jump_times)
+-        data.jump_op_idx.append(jump_op_idx)
+-
+-    progress_bar.finished()
+-
+-    # average density matrices
+-    if options['average_states'] and np.any(data.states):
+-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
+-                       for n in range(len(data.times))]
+-
+-    # average
+-    data.expect = data.expect / nt
+-
+-    # standard error
+-    if nt > 1:
+-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
+-    else:
+-        data.se = None
+-
+-    # convert complex data to real if hermitian
+-    data.expect = [np.real(data.expect[n, :])
+-                   if e.isherm else data.expect[n, :]
+-                   for n, e in enumerate(sso.e_ops)]
+-
+-    return data
+-
+-
+-def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
+-    """
+-    Internal function. See ssepdpsolve.
+-    """
+-    states_list = []
+-
+-    phi_t = psi_t.copy()
+-
+-    prng = RandomState()  # todo: seed it
+-    r_jump, r_op = prng.rand(2)
+-
+-    jump_times = []
+-    jump_op_idx = []
+-
+-    for t_idx, t in enumerate(times):
+-
+-        if e_ops:
+-            for e_idx, e in enumerate(e_ops):
+-                s = _data.expect(e, psi_t)
+-                data.expect[e_idx, t_idx] += s
+-                data.ss[e_idx, t_idx] += s ** 2
+-        else:
+-            states_list.append(Qobj(psi_t.to_array(), dims=dims))
+-
+-        for j in range(N_substeps):
+-
+-            if _data.norm.l2(phi_t) ** 2 < r_jump:
+-                # jump occurs
+-                p = np.array([
+-                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
+-                    for c in c_ops
+-                ])
+-                p = np.cumsum(p / np.sum(p))
+-                n = np.where(p >= r_op)[0][0]
+-
+-                # apply jump
+-                psi_t = _data.matmul(c_ops[n].data, psi_t)
+-                psi_t /= _data.norm.l2(psi_t)
+-                phi_t = psi_t.copy()
+-
+-                # store info about jump
+-                jump_times.append(times[t_idx] + dt * j)
+-                jump_op_idx.append(n)
+-
+-                # get new random numbers for next jump
+-                r_jump, r_op = prng.rand(2)
+-
+-            # deterministic evolution wihtout correction for norm decay
+-            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
+-
+-            # deterministic evolution with correction for norm decay
+-            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
+-            A = 0.5 * np.sum([
+-                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
+-                for c in c_ops
+-            ])
+-            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
+-
+-            # increment wavefunctions
+-            phi_t = _data.add(phi_t, dphi_t)
+-            psi_t = _data.add(psi_t, dpsi_t)
+-
+-            # ensure that normalized wavefunction remains normalized
+-            # this allows larger time step than otherwise would be possible
+-            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
+-
+-    return states_list, jump_times, jump_op_idx
+-
+-
+-# -----------------------------------------------------------------------------
+-# Generic parameterized stochastic ME PDP solver
+-#
+-def _smepdpsolve_generic(sso, options, progress_bar):
+-    """
+-    For internal use. See smepdpsolve.
+-    """
+-    N_store = len(sso.times)
+-    N_substeps = sso.nsubsteps
+-    dt = (sso.times[1] - sso.times[0]) / N_substeps
+-    nt = sso.ntraj
+-
+-    data = Result()
+-    data.solver = "smepdpsolve"
+-    data.times = sso.times
+-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+-    data.jump_times = []
+-    data.jump_op_idx = []
+-
+-    # Liouvillian for the deterministic part.
+-    # needs to be modified for TD systems
+-    L = liouvillian(sso.H, sso.c_ops)
+-
+-    progress_bar.start(sso.ntraj)
+-
+-    for n in range(sso.ntraj):
+-        progress_bar.update(n)
+-        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
+-        rho_t = _data.column_stack_dense(rho_t)
+-
+-        states_list, jump_times, jump_op_idx = \
+-            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
+-                                           N_store, N_substeps,
+-                                           rho_t, sso.rho0.dims,
+-                                           sso.c_ops, sso.e_ops)
+-
+-        data.states.append(states_list)
+-        data.jump_times.append(jump_times)
+-        data.jump_op_idx.append(jump_op_idx)
+-
+-    progress_bar.finished()
+-
+-    # average density matrices
+-    if options['average_states'] and np.any(data.states):
+-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
+-                       for n in range(len(data.times))]
+-
+-    # average
+-    data.expect = data.expect / sso.ntraj
+-
+-    # standard error
+-    if nt > 1:
+-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
+-    else:
+-        data.se = None
+-
+-    return data
+-
+-def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
+-    """
+-    Internal function. See smepdpsolve.
+-    """
+-    states_list = []
+-
+-    rho_t = np.copy(rho_t)
+-    sigma_t = np.copy(rho_t)
+-
+-    prng = RandomState()  # todo: seed it
+-    r_jump, r_op = prng.rand(2)
+-
+-    jump_times = []
+-    jump_op_idx = []
+-
+-    for t_idx, t in enumerate(times):
+-
+-        if e_ops:
+-            for e_idx, e in enumerate(e_ops):
+-                data.expect[e_idx, t_idx] +=\
+-                    _data.expect_super(e, rho_t)
+-        else:
+-            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
+-
+-        for j in range(N_substeps):
+-
+-            if sigma_t.norm() < r_jump:
+-                # jump occurs
+-                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
+-                p = np.cumsum(p / np.sum(p))
+-                n = np.where(p >= r_op)[0][0]
+-
+-                # apply jump
+-                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
+-                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
+-                sigma_t = np.copy(rho_t)
+-
+-                # store info about jump
+-                jump_times.append(times[t_idx] + dt * j)
+-                jump_op_idx.append(n)
+-
+-                # get new random numbers for next jump
+-                r_jump, r_op = prng.rand(2)
+-
+-            # deterministic evolution wihtout correction for norm decay
+-            dsigma_t = _data.matmul(L.data, sigma_t) * dt
+-
+-            # deterministic evolution with correction for norm decay
+-            drho_t = _data.matmul(L.data, rho_t) * dt
+-
+-            # increment density matrices
+-            sigma_t = _data.add(sigma_t, dsigma_t)
+-            rho_t = _data.add(rho_t, drho_t)
+-
+-    return states_list, jump_times, jump_op_idx
++# -*- coding: utf-8 -*-
++
++import numpy as np
++from numpy.random import RandomState
++
++from .. import (
++    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
++)
++from ..core import data as _data
++from .solver import Result, SolverOptions
++from .parallel import serial_map
++from ..ui.progressbar import TextProgressBar
++from ..settings import settings
++debug = settings.debug
++
++
++class StochasticSolverOptions:
++    """
++    Class of options for stochastic (piecewse deterministic process) PDP
++    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
++    :func:`qutip.pdpsolve.smepdpsolve`.
++    Options can be specified either as arguments to the constructor::
++
++        sso = StochasticSolverOptions(nsubsteps=100, ...)
++
++    or by changing the class attributes after creation::
++
++        sso = StochasticSolverOptions()
++        sso.nsubsteps = 1000
++
++    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
++    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
++    the constructor of these class, and internally they use these arguments to
++    construct an instance of this class, so it is rarely needed to explicitly
++    create an instance of this class.
++
++    Attributes
++    ----------
++
++    H : :class:`qutip.Qobj`
++        System Hamiltonian.
++
++    state0 : :class:`qutip.Qobj`
++        Initial state vector (ket) or density matrix.
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`
++        List of deterministic collapse operators.
++
++    sc_ops : list of :class:`qutip.Qobj`
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the equation of motion according to how the d1 and d2 functions
++        are defined.
++
++    e_ops : list of :class:`qutip.Qobj`
++        Single operator or list of operators for which to evaluate
++        expectation values.
++
++    m_ops : list of :class:`qutip.Qobj`
++        List of operators representing the measurement operators. The expected
++        format is a nested list with one measurement operator for each
++        stochastic increament, for each stochastic collapse operator.
++
++    args : dict / list
++        List of dictionary of additional problem-specific parameters.
++        Implicit methods can adjust tolerance via args = {'tol':value}
++
++    ntraj : int
++        Number of trajectors.
++
++    nsubsteps : int
++        Number of sub steps between each time-spep given in `times`.
++
++    d1 : function
++        Function for calculating the operator-valued coefficient to the
++        deterministic increment dt.
++
++    d2 : function
++        Function for calculating the operator-valued coefficient to the
++        stochastic increment(s) dW_n, where n is in [0, d2_len[.
++
++    d2_len : int (default 1)
++        The number of stochastic increments in the process.
++
++    dW_factors : array
++        Array of length d2_len, containing scaling factors for each
++        measurement operator in m_ops.
++
++    rhs : function
++        Function for calculating the deterministic and stochastic contributions
++        to the right-hand side of the stochastic differential equation. This
++        only needs to be specified when implementing a custom SDE solver.
++
++    generate_A_ops : function
++        Function that generates a list of pre-computed operators or super-
++        operators. These precomputed operators are used in some d1 and d2
++        functions.
++
++    generate_noise : function
++        Function for generate an array of pre-computed noise signal.
++
++    homogeneous : bool (True)
++        Wheter or not the stochastic process is homogenous. Inhomogenous
++        processes are only supported for poisson distributions.
++
++    solver : string
++        Name of the solver method to use for solving the stochastic
++        equations. Valid values are:
++        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
++        'pc-euler' is a predictor-corrector method which is more
++        stable than explicit methods,
++        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
++        'milstein-imp' is semi-implicit Milstein method,
++        3/2 order algorithms: 'taylor15',
++        'taylor15-imp' is semi-implicit Taylor 1.5 method.
++        Implicit methods can adjust tolerance via args = {'tol':value},
++        default is {'tol':1e-6}
++
++    method : string ('homodyne', 'heterodyne', 'photocurrent')
++        The name of the type of measurement process that give rise to the
++        stochastic equation to solve. Specifying a method with this keyword
++        argument is a short-hand notation for using pre-defined d1 and d2
++        functions for the corresponding stochastic processes.
++
++    distribution : string ('normal', 'poisson')
++        The name of the distribution used for the stochastic increments.
++
++    store_measurements : bool (default False)
++        Whether or not to store the measurement results in the
++        :class:`qutip.solver.Result` instance returned by the solver.
++
++    noise : array
++        Vector specifying the noise.
++
++    normalize : bool (default True)
++        Whether or not to normalize the wave function during the evolution.
++
++    options : :class:`qutip.solver.SolverOptions`
++        Generic solver options.
++
++    map_func: function
++        A map function or managing the calls to single-trajactory solvers.
++
++    map_kwargs: dictionary
++        Optional keyword arguments to the map_func function function.
++
++    progress_bar : :class:`qutip.ui.BaseProgressBar`
++        Optional progress bar class instance.
++    """
++    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
++                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
++                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
++                 generate_A_ops=None, generate_noise=None, homogeneous=True,
++                 solver=None, method=None, distribution='normal',
++                 store_measurement=False, noise=None, normalize=True,
++                 options=None, progress_bar=None, map_func=None,
++                 map_kwargs=None):
++
++        if options is None:
++            options = SolverOptions()
++
++        if progress_bar is None:
++            progress_bar = TextProgressBar()
++
++        self.H = H
++        self.d1 = d1
++        self.d2 = d2
++        self.d2_len = d2_len
++        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
++        self.state0 = state0
++        self.times = times
++        self.c_ops = c_ops
++        self.sc_ops = sc_ops
++        self.e_ops = e_ops
++        self.m_ops = m_ops
++
++        self.ntraj = ntraj
++        self.nsubsteps = nsubsteps
++        self.solver = solver
++        self.method = method
++        self.distribution = distribution
++        self.homogeneous = homogeneous
++        self.rhs = rhs
++        self.options = options
++        self.progress_bar = progress_bar
++        self.store_measurement = store_measurement
++        self.store_states = options['store_states']
++        self.noise = noise
++        self.args = args
++        self.normalize = normalize
++
++        self.generate_noise = generate_noise
++        self.generate_A_ops = generate_A_ops
++
++        if self.ntraj > 1 and map_func:
++            self.map_func = map_func
++        else:
++            self.map_func = serial_map
++
++        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
++
++        # Does any operator depend on time?
++        self.td = False
++        if not isinstance(H, Qobj):
++            self.td = True
++        for ops in c_ops:
++            if not isinstance(ops, Qobj):
++                self.td = True
++        for ops in sc_ops:
++            if not isinstance(ops, Qobj):
++                self.td = True
++
++
++def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
++    """
++    A stochastic (piecewse deterministic process) PDP solver for wavefunction
++    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
++    trajectory simulations.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`
++        System Hamiltonian.
++
++    psi0 : :class:`qutip.Qobj`
++        Initial state vector (ket).
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`
++        Deterministic collapse operator which will contribute with a standard
++        Lindblad type of dissipation.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function single
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = [e for e in e_ops.values()]
++    else:
++        e_ops_dict = None
++
++    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
++                                  e_ops=e_ops, **kwargs)
++
++    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++    return res
++
++
++def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
++    """
++    A stochastic (piecewse deterministic process) PDP solver for density matrix
++    evolution.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`
++        System Hamiltonian.
++
++    rho0 : :class:`qutip.Qobj`
++        Initial density matrix.
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`
++        Deterministic collapse operator which will contribute with a standard
++        Lindblad type of dissipation.
++
++    sc_ops : list of :class:`qutip.Qobj`
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the equation of motion according to how the d1 and d2 functions
++        are defined.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function single
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = [e for e in e_ops.values()]
++    else:
++        e_ops_dict = None
++
++    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
++                                  e_ops=e_ops, **kwargs)
++
++    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++    return res
++
++
++# -----------------------------------------------------------------------------
++# Generic parameterized stochastic SE PDP solver
++#
++def _ssepdpsolve_generic(sso, options, progress_bar):
++    """
++    For internal use. See ssepdpsolve.
++    """
++    N_store = len(sso.times)
++    N_substeps = sso.nsubsteps
++    dt = (sso.times[1] - sso.times[0]) / N_substeps
++    nt = sso.ntraj
++
++    data = Result()
++    data.solver = "sepdpsolve"
++    data.times = sso.tlist
++    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
++    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
++    data.jump_times = []
++    data.jump_op_idx = []
++
++    # effective hamiltonian for deterministic part
++    Heff = sso.H
++    for c in sso.c_ops:
++        Heff += -0.5j * c.dag() * c
++
++    progress_bar.start(sso.ntraj)
++    for n in range(sso.ntraj):
++        progress_bar.update(n)
++        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
++
++        states_list, jump_times, jump_op_idx = \
++            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
++                                           N_store, N_substeps,
++                                           psi_t, sso.state0.dims,
++                                           sso.c_ops, sso.e_ops)
++
++        data.states.append(states_list)
++        data.jump_times.append(jump_times)
++        data.jump_op_idx.append(jump_op_idx)
++
++    progress_bar.finished()
++
++    # average density matrices
++    if options['average_states'] and np.any(data.states):
++        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
++                       for n in range(len(data.times))]
++
++    # average
++    data.expect = data.expect / nt
++
++    # standard error
++    if nt > 1:
++        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
++    else:
++        data.se = None
++
++    # convert complex data to real if hermitian
++    data.expect = [np.real(data.expect[n, :])
++                   if e.isherm else data.expect[n, :]
++                   for n, e in enumerate(sso.e_ops)]
++
++    return data
++
++
++def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
++    """
++    Internal function. See ssepdpsolve.
++    """
++    states_list = []
++
++    phi_t = psi_t.copy()
++
++    prng = RandomState()  # todo: seed it
++    r_jump, r_op = prng.rand(2)
++
++    jump_times = []
++    jump_op_idx = []
++
++    for t_idx, t in enumerate(times):
++
++        if e_ops:
++            for e_idx, e in enumerate(e_ops):
++                s = _data.expect(e, psi_t)
++                data.expect[e_idx, t_idx] += s
++                data.ss[e_idx, t_idx] += s ** 2
++        else:
++            states_list.append(Qobj(psi_t.to_array(), dims=dims))
++
++        for j in range(N_substeps):
++
++            if _data.norm.l2(phi_t) ** 2 < r_jump:
++                # jump occurs
++                p = np.array([
++                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
++                    for c in c_ops
++                ])
++                p = np.cumsum(p / np.sum(p))
++                n = np.where(p >= r_op)[0][0]
++
++                # apply jump
++                psi_t = _data.matmul(c_ops[n].data, psi_t)
++                psi_t /= _data.norm.l2(psi_t)
++                phi_t = psi_t.copy()
++
++                # store info about jump
++                jump_times.append(times[t_idx] + dt * j)
++                jump_op_idx.append(n)
++
++                # get new random numbers for next jump
++                r_jump, r_op = prng.rand(2)
++
++            # deterministic evolution wihtout correction for norm decay
++            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
++
++            # deterministic evolution with correction for norm decay
++            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
++            A = 0.5 * np.sum([
++                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
++                for c in c_ops
++            ])
++            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
++
++            # increment wavefunctions
++            phi_t = _data.add(phi_t, dphi_t)
++            psi_t = _data.add(psi_t, dpsi_t)
++
++            # ensure that normalized wavefunction remains normalized
++            # this allows larger time step than otherwise would be possible
++            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
++
++    return states_list, jump_times, jump_op_idx
++
++
++# -----------------------------------------------------------------------------
++# Generic parameterized stochastic ME PDP solver
++#
++def _smepdpsolve_generic(sso, options, progress_bar):
++    """
++    For internal use. See smepdpsolve.
++    """
++    N_store = len(sso.times)
++    N_substeps = sso.nsubsteps
++    dt = (sso.times[1] - sso.times[0]) / N_substeps
++    nt = sso.ntraj
++
++    data = Result()
++    data.solver = "smepdpsolve"
++    data.times = sso.times
++    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
++    data.jump_times = []
++    data.jump_op_idx = []
++
++    # Liouvillian for the deterministic part.
++    # needs to be modified for TD systems
++    L = liouvillian(sso.H, sso.c_ops)
++
++    progress_bar.start(sso.ntraj)
++
++    for n in range(sso.ntraj):
++        progress_bar.update(n)
++        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
++        rho_t = _data.column_stack_dense(rho_t)
++
++        states_list, jump_times, jump_op_idx = \
++            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
++                                           N_store, N_substeps,
++                                           rho_t, sso.rho0.dims,
++                                           sso.c_ops, sso.e_ops)
++
++        data.states.append(states_list)
++        data.jump_times.append(jump_times)
++        data.jump_op_idx.append(jump_op_idx)
++
++    progress_bar.finished()
++
++    # average density matrices
++    if options['average_states'] and np.any(data.states):
++        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
++                       for n in range(len(data.times))]
++
++    # average
++    data.expect = data.expect / sso.ntraj
++
++    # standard error
++    if nt > 1:
++        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
++    else:
++        data.se = None
++
++    return data
++
++def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
++    """
++    Internal function. See smepdpsolve.
++    """
++    states_list = []
++
++    rho_t = np.copy(rho_t)
++    sigma_t = np.copy(rho_t)
++
++    prng = RandomState()  # todo: seed it
++    r_jump, r_op = prng.rand(2)
++
++    jump_times = []
++    jump_op_idx = []
++
++    for t_idx, t in enumerate(times):
++
++        if e_ops:
++            for e_idx, e in enumerate(e_ops):
++                data.expect[e_idx, t_idx] +=\
++                    _data.expect_super(e, rho_t)
++        else:
++            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
++
++        for j in range(N_substeps):
++
++            if sigma_t.norm() < r_jump:
++                # jump occurs
++                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
++                p = np.cumsum(p / np.sum(p))
++                n = np.where(p >= r_op)[0][0]
++
++                # apply jump
++                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
++                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
++                sigma_t = np.copy(rho_t)
++
++                # store info about jump
++                jump_times.append(times[t_idx] + dt * j)
++                jump_op_idx.append(n)
++
++                # get new random numbers for next jump
++                r_jump, r_op = prng.rand(2)
++
++            # deterministic evolution wihtout correction for norm decay
++            dsigma_t = _data.matmul(L.data, sigma_t) * dt
++
++            # deterministic evolution with correction for norm decay
++            drho_t = _data.matmul(L.data, rho_t) * dt
++
++            # increment density matrices
++            sigma_t = _data.add(sigma_t, dsigma_t)
++            rho_t = _data.add(rho_t, drho_t)
++
++    return states_list, jump_times, jump_op_idx
+diff --git a/qutip/solve/piqs.py b/qutip/solve/piqs.py
+index 2784e986..b475d7d9 100644
+--- a/qutip/solve/piqs.py
++++ b/qutip/solve/piqs.py
+@@ -1,1926 +1,1926 @@
+-"""Permutational Invariant Quantum Solver (PIQS)
+-
+-This module calculates the Liouvillian for the dynamics of ensembles of
+-identical two-level systems (TLS) in the presence of local and collective
+-processes by exploiting permutational symmetry and using the Dicke basis.
+-It also allows to characterize nonlinear functions of the density matrix.
+-"""
+-
+-# Authors: Nathan Shammah, Shahnawaz Ahmed
+-# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
+-
+-from math import factorial
+-from decimal import Decimal
+-
+-import numpy as np
+-from scipy.integrate import odeint
+-from scipy.linalg import eigvalsh
+-from scipy.special import entr
+-from scipy.sparse import dok_matrix, block_diag, lil_matrix
+-from .. import (
+-    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
+-    sigmap, sigmam,
+-)
+-from ..entropy import entropy_vn
+-from .solver import SolverOptions, Result
+-from ._piqs import Dicke as _Dicke
+-from ._piqs import (
+-    jmm1_dictionary,
+-    _num_dicke_states,
+-    _num_dicke_ladders,
+-    get_blocks,
+-    j_min,
+-    j_vals,
+-)
+-
+-__all__ = [
+-    "num_dicke_states",
+-    "num_dicke_ladders",
+-    "num_tls",
+-    "isdiagonal",
+-    "dicke_blocks",
+-    "dicke_blocks_full",
+-    "dicke_function_trace",
+-    "purity_dicke",
+-    "entropy_vn_dicke",
+-    "Dicke",
+-    "state_degeneracy",
+-    "m_degeneracy",
+-    "energy_degeneracy",
+-    "ap",
+-    "am",
+-    "spin_algebra",
+-    "jspin",
+-    "collapse_uncoupled",
+-    "dicke_basis",
+-    "dicke",
+-    "excited",
+-    "superradiant",
+-    "css",
+-    "ghz",
+-    "ground",
+-    "identity_uncoupled",
+-    "block_matrix",
+-    "tau_column",
+-    "Pim",
+-]
+-
+-
+-def _ensure_int(x):
+-    """
+-    Ensure that a floating-point value `x` is exactly an integer, and return it
+-    as an int.
+-    """
+-    out = int(x)
+-    if out != x:
+-        raise ValueError(f"{x} is not an integral value")
+-    return out
+-
+-
+-# Functions necessary to generate the Lindbladian/Liouvillian
+-def num_dicke_states(N):
+-    """Calculate the number of Dicke states.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    nds: int
+-        The number of Dicke states.
+-    """
+-    return _num_dicke_states(N)
+-
+-
+-def num_dicke_ladders(N):
+-    """Calculate the total number of ladders in the Dicke space.
+-
+-    For a collection of N two-level systems it counts how many different
+-    "j" exist or the number of blocks in the block-diagonal matrix.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    Nj: int
+-        The number of Dicke ladders.
+-    """
+-    return _num_dicke_ladders(N)
+-
+-
+-def num_tls(nds):
+-    """Calculate the number of two-level systems.
+-
+-    Parameters
+-    ----------
+-    nds: int
+-         The number of Dicke states.
+-
+-    Returns
+-    -------
+-    N: int
+-        The number of two-level systems.
+-    """
+-    if np.sqrt(nds).is_integer():
+-        # N is even
+-        N = 2 * (np.sqrt(nds) - 1)
+-    else:
+-        # N is odd
+-        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
+-    return int(N)
+-
+-
+-def isdiagonal(mat):
+-    """
+-    Check if the input matrix is diagonal.
+-
+-    Parameters
+-    ==========
+-    mat: ndarray/Qobj
+-        A 2D numpy array
+-
+-    Returns
+-    =======
+-    diag: bool
+-        True/False depending on whether the input matrix is diagonal.
+-    """
+-    if isinstance(mat, Qobj):
+-        mat = mat.full()
+-
+-    return np.all(mat == np.diag(np.diagonal(mat)))
+-
+-
+-# nonlinear functions of the density matrix
+-def dicke_blocks(rho):
+-    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+-        where nds is the number of Dicke states for N two-level
+-        systems.
+-
+-    Returns
+-    -------
+-    square_blocks: list of np.array
+-        Give back the blocks list.
+-
+-    """
+-    shape_dimension = rho.shape[0]
+-    N = num_tls(shape_dimension)
+-    ladders = num_dicke_ladders(N)
+-    # create a list with the sizes of the blocks, in order
+-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+-    blocks_list = [
+-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+-        for i in range(blocks_dimensions)
+-    ]
+-    blocks_list = np.flip(blocks_list, 0)
+-    # create a list with each block matrix as element
+-    square_blocks = []
+-    block_position = 0
+-    for block_size in blocks_list:
+-        start_m = block_position
+-        end_m = block_position + block_size
+-        square_block = rho[start_m:end_m, start_m:end_m]
+-        block_position = block_position + block_size
+-        square_blocks.append(square_block)
+-
+-    return square_blocks
+-
+-
+-def dicke_blocks_full(rho):
+-    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+-        where nds is the number of Dicke states for N two-level
+-        systems.
+-
+-    Returns
+-    -------
+-    full_blocks : list
+-        The list of blocks expanded in the 2^N space for N qubits.
+-
+-    """
+-    shape_dimension = rho.shape[0]
+-    N = num_tls(shape_dimension)
+-    ladders = num_dicke_ladders(N)
+-    # create a list with the sizes of the blocks, in order
+-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+-    blocks_list = [
+-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+-        for i in range(blocks_dimensions)
+-    ]
+-    blocks_list = np.flip(blocks_list, 0)
+-    # create a list with each block matrix as element
+-    full_blocks = []
+-    k = 0
+-    block_position = 0
+-    for block_size in blocks_list:
+-        start_m = block_position
+-        end_m = block_position + block_size
+-        square_block = rho[start_m:end_m, start_m:end_m]
+-        block_position = block_position + block_size
+-        j = N / 2 - k
+-        djn = state_degeneracy(N, j)
+-        for block_counter in range(0, djn):
+-            full_blocks.append(square_block / djn)  # preserve trace
+-        k = k + 1
+-    return full_blocks
+-
+-
+-def dicke_function_trace(f, rho):
+-    """Calculate the trace of a function on a Dicke density matrix.
+-    Parameters
+-    ----------
+-    f : function
+-        A Taylor-expandable function of `rho`.
+-
+-    rho : :class:`qutip.Qobj`
+-        A density matrix in the Dicke basis.
+-
+-    Returns
+-    -------
+-    res : float
+-        Trace of a nonlinear function on `rho`.
+-    """
+-    N = num_tls(rho.shape[0])
+-    blocks = dicke_blocks(rho)
+-    block_f = []
+-    degen_blocks = np.flip(j_vals(N))
+-    state_degeneracies = []
+-    for j in degen_blocks:
+-        dj = state_degeneracy(N, j)
+-        state_degeneracies.append(dj)
+-    eigenvals_degeneracy = []
+-    deg = []
+-    for i, block in enumerate(blocks):
+-        dj = state_degeneracies[i]
+-        normalized_block = block / dj
+-        eigenvals_block = eigvalsh(normalized_block)
+-        for val in eigenvals_block:
+-            eigenvals_degeneracy.append(val)
+-            deg.append(dj)
+-
+-    eigenvalue = np.array(eigenvals_degeneracy)
+-    function_array = f(eigenvalue) * deg
+-    return sum(function_array)
+-
+-
+-def entropy_vn_dicke(rho):
+-    """Von Neumann Entropy of a Dicke-basis density matrix.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+-        where nds is the number of Dicke states for N two-level
+-        systems.
+-
+-    Returns
+-    -------
+-    entropy_dm: float
+-        Entropy. Use degeneracy to multiply each block.
+-
+-    """
+-    return dicke_function_trace(entr, rho)
+-
+-
+-def purity_dicke(rho):
+-    """Calculate purity of a density matrix in the Dicke basis.
+-    It accounts for the degenerate blocks in the density matrix.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
+-
+-    Returns
+-    -------
+-    purity : float
+-        The purity of the quantum state.
+-        It's 1 for pure states, 0<=purity<1 for mixed states.
+-    """
+-    f = lambda x: x * x
+-    return dicke_function_trace(f, rho)
+-
+-
+-class Dicke(object):
+-    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
+-
+-    Examples
+-    --------
+-    >>> from piqs import Dicke, jspin
+-    >>> N = 2
+-    >>> jx, jy, jz = jspin(N)
+-    >>> jp = jspin(N, "+")
+-    >>> jm = jspin(N, "-")
+-    >>> ensemble = Dicke(N, emission=1.)
+-    >>> L = ensemble.liouvillian()
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    hamiltonian : :class:`qutip.Qobj`
+-        A Hamiltonian in the Dicke basis.
+-
+-        The matrix dimensions are (nds, nds),
+-        with nds being the number of Dicke states.
+-        The Hamiltonian can be built with the operators
+-        given by the `jspin` functions.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-
+-    Attributes
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    hamiltonian : :class:`qutip.Qobj`
+-        A Hamiltonian in the Dicke basis.
+-
+-        The matrix dimensions are (nds, nds),
+-        with nds being the number of Dicke states.
+-        The Hamiltonian can be built with the operators given
+-        by the `jspin` function in the "dicke" basis.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    nds: int
+-        The number of Dicke states.
+-
+-    dshape: tuple
+-        The shape of the Hilbert space in the Dicke or uncoupled basis.
+-        default: (nds, nds).
+-    """
+-
+-    def __init__(
+-        self,
+-        N,
+-        hamiltonian=None,
+-        emission=0.0,
+-        dephasing=0.0,
+-        pumping=0.0,
+-        collective_emission=0.0,
+-        collective_dephasing=0.0,
+-        collective_pumping=0.0,
+-    ):
+-        self.N = N
+-        self.hamiltonian = hamiltonian
+-        self.emission = emission
+-        self.dephasing = dephasing
+-        self.pumping = pumping
+-        self.collective_emission = collective_emission
+-        self.collective_dephasing = collective_dephasing
+-        self.collective_pumping = collective_pumping
+-        self.nds = num_dicke_states(self.N)
+-        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
+-
+-    def __repr__(self):
+-        """Print the current parameters of the system."""
+-        string = []
+-        string.append("N = {}".format(self.N))
+-        string.append("Hilbert space dim = {}".format(self.dshape))
+-        string.append("Number of Dicke states = {}".format(self.nds))
+-        string.append(
+-            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
+-        )
+-        if self.emission != 0:
+-            string.append("emission = {}".format(self.emission))
+-        if self.dephasing != 0:
+-            string.append("dephasing = {}".format(self.dephasing))
+-        if self.pumping != 0:
+-            string.append("pumping = {}".format(self.pumping))
+-        if self.collective_emission != 0:
+-            string.append(
+-                "collective_emission = {}".format(self.collective_emission)
+-            )
+-        if self.collective_dephasing != 0:
+-            string.append(
+-                "collective_dephasing = {}".format(self.collective_dephasing)
+-            )
+-        if self.collective_pumping != 0:
+-            string.append(
+-                "collective_pumping = {}".format(self.collective_pumping)
+-            )
+-        return "\n".join(string)
+-
+-    def lindbladian(self):
+-        """Build the Lindbladian superoperator of the dissipative dynamics.
+-
+-        Returns
+-        -------
+-        lindbladian : :class:`qutip.Qobj`
+-            The Lindbladian matrix as a `qutip.Qobj`.
+-        """
+-        cythonized_dicke = _Dicke(
+-            int(self.N),
+-            float(self.emission),
+-            float(self.dephasing),
+-            float(self.pumping),
+-            float(self.collective_emission),
+-            float(self.collective_dephasing),
+-            float(self.collective_pumping),
+-        )
+-        return cythonized_dicke.lindbladian()
+-
+-    def liouvillian(self):
+-        """Build the total Liouvillian using the Dicke basis.
+-
+-        Returns
+-        -------
+-        liouv : :class:`qutip.Qobj`
+-            The Liouvillian matrix for the system.
+-        """
+-        lindblad = self.lindbladian()
+-        if self.hamiltonian is None:
+-            liouv = lindblad
+-
+-        else:
+-            hamiltonian = self.hamiltonian
+-            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
+-                hamiltonian
+-            )
+-            liouv = lindblad + hamiltonian_superoperator
+-        return liouv
+-
+-    def pisolve(self, initial_state, tlist, options=None):
+-        """
+-        Solve for diagonal Hamiltonians and initial states faster.
+-
+-        Parameters
+-        ==========
+-        initial_state : :class:`qutip.Qobj`
+-            An initial state specified as a density matrix of
+-            `qutip.Qbj` type.
+-
+-        tlist: ndarray
+-            A 1D numpy array of list of timesteps to integrate
+-
+-        options : :class:`qutip.solver.SolverOptions`
+-            The options for the solver.
+-
+-        Returns
+-        =======
+-        result: list
+-            A dictionary of the type `qutip.solver.Result` which holds the
+-            results of the evolution.
+-        """
+-        if isdiagonal(initial_state) == False:
+-            msg = "`pisolve` requires a diagonal initial density matrix. "
+-            msg += "In general construct the Liouvillian using "
+-            msg += "`piqs.liouvillian` and use qutip.mesolve."
+-            raise ValueError(msg)
+-
+-        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
+-            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
+-            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
+-            msg += "  use `qutip.mesolve`."
+-            raise ValueError(msg)
+-
+-        if initial_state.full().shape != self.dshape:
+-            msg = "Initial density matrix should be diagonal."
+-            raise ValueError(msg)
+-
+-        pim = Pim(
+-            self.N,
+-            self.emission,
+-            self.dephasing,
+-            self.pumping,
+-            self.collective_emission,
+-            self.collective_pumping,
+-            self.collective_dephasing,
+-        )
+-        result = pim.solve(initial_state, tlist, options=None)
+-        return result
+-
+-    def c_ops(self):
+-        """Build collapse operators in the full Hilbert space 2^N.
+-
+-        Returns
+-        -------
+-        c_ops_list: list
+-            The list with the collapse operators in the 2^N Hilbert space.
+-        """
+-        ce = self.collective_emission
+-        cd = self.collective_dephasing
+-        cp = self.collective_pumping
+-        c_ops_list = collapse_uncoupled(
+-            N=self.N,
+-            emission=self.emission,
+-            dephasing=self.dephasing,
+-            pumping=self.pumping,
+-            collective_emission=ce,
+-            collective_dephasing=cd,
+-            collective_pumping=cp,
+-        )
+-        return c_ops_list
+-
+-    def coefficient_matrix(self):
+-        """Build coefficient matrix for ODE for a diagonal problem.
+-
+-        Returns
+-        -------
+-        M: ndarray
+-            The matrix M of the coefficients for the ODE dp/dt = Mp.
+-            p is the vector of the diagonal matrix elements
+-            of the density matrix rho in the Dicke basis.
+-        """
+-        diagonal_system = Pim(
+-            N=self.N,
+-            emission=self.emission,
+-            dephasing=self.dephasing,
+-            pumping=self.pumping,
+-            collective_emission=self.collective_emission,
+-            collective_dephasing=self.collective_dephasing,
+-            collective_pumping=self.collective_pumping,
+-        )
+-        coef_matrix = diagonal_system.coefficient_matrix()
+-        return coef_matrix
+-
+-
+-# Utility functions for properties of the Dicke space
+-def energy_degeneracy(N, m):
+-    """Calculate the number of Dicke states with same energy.
+-
+-    The use of the `Decimals` class allows to explore N > 1000,
+-    unlike the built-in function `scipy.special.binom`
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    m: float
+-        Total spin z-axis projection eigenvalue.
+-        This is proportional to the total energy.
+-
+-    Returns
+-    -------
+-    degeneracy: int
+-        The energy degeneracy
+-    """
+-    numerator = Decimal(factorial(N))
+-    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
+-    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
+-    degeneracy = numerator / (d1 * d2)
+-    return int(degeneracy)
+-
+-
+-def state_degeneracy(N, j):
+-    r"""Calculate the degeneracy of the Dicke state.
+-
+-    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
+-    representations :math:`\lvert j, m, \alpha\rangle`.
+-
+-    Uses Decimals to calculate higher numerator and denominators numbers.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    j: float
+-        Total spin eigenvalue (cooperativity).
+-
+-    Returns
+-    -------
+-    degeneracy: int
+-        The state degeneracy.
+-    """
+-    if j < 0:
+-        raise ValueError("j value should be >= 0")
+-    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
+-    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
+-    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
+-    degeneracy = numerator / (denominator_1 * denominator_2)
+-    degeneracy = int(np.round(float(degeneracy)))
+-    return degeneracy
+-
+-
+-def m_degeneracy(N, m):
+-    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
+-    same energy.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    m: float
+-        Total spin z-axis projection eigenvalue (proportional to the total
+-        energy).
+-
+-    Returns
+-    -------
+-    degeneracy: int
+-        The m-degeneracy.
+-    """
+-    jvals = j_vals(N)
+-    maxj = np.max(jvals)
+-    if m < -maxj:
+-        e = "m value is incorrect for this N."
+-        e += " Minimum m value can be {}".format(-maxj)
+-        raise ValueError(e)
+-    degeneracy = N / 2 + 1 - abs(m)
+-    return int(degeneracy)
+-
+-
+-def ap(j, m):
+-    r"""
+-    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
+-
+-    The action of ap is given by:
+-    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
+-
+-    Parameters
+-    ----------
+-    j, m: float
+-        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
+-
+-    Returns
+-    -------
+-    a_plus: float
+-        The value of :math:`a_{+}`.
+-    """
+-    a_plus = np.sqrt((j - m) * (j + m + 1))
+-    return a_plus
+-
+-
+-def am(j, m):
+-    r"""Calculate the operator ``am`` used later.
+-
+-    The action of ``ap`` is given by:
+-    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
+-
+-    Parameters
+-    ----------
+-    j: float
+-        The value for j.
+-
+-    m: float
+-        The value for m.
+-
+-    Returns
+-    -------
+-    a_minus: float
+-        The value of :math:`a_{-}`.
+-    """
+-    a_minus = np.sqrt((j + m) * (j - m + 1))
+-    return a_minus
+-
+-
+-def spin_algebra(N, op=None):
+-    """Create the list [sx, sy, sz] with the spin operators.
+-
+-    The operators are constructed for a collection of N two-level systems
+-    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
+-    objects (spin matrices), as it cointains the list of the SU(2) Pauli
+-    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
+-    is placed in a :math:`2^N`-dimensional Hilbert space.
+-
+-    Notes
+-    -----
+-    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    spin_operators: list or :class: qutip.Qobj
+-        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
+-        requested operator.
+-    """
+-    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
+-    N = int(N)
+-    sx = [0 for i in range(N)]
+-    sy = [0 for i in range(N)]
+-    sz = [0 for i in range(N)]
+-    sp = [0 for i in range(N)]
+-    sm = [0 for i in range(N)]
+-
+-    sx[0] = 0.5 * sigmax()
+-    sy[0] = 0.5 * sigmay()
+-    sz[0] = 0.5 * sigmaz()
+-    sp[0] = sigmap()
+-    sm[0] = sigmam()
+-
+-    # 2. Place operators in total Hilbert space
+-    for k in range(N - 1):
+-        sx[0] = tensor(sx[0], identity(2))
+-        sy[0] = tensor(sy[0], identity(2))
+-        sz[0] = tensor(sz[0], identity(2))
+-        sp[0] = tensor(sp[0], identity(2))
+-        sm[0] = tensor(sm[0], identity(2))
+-
+-    # 3. Cyclic sequence to create all N operators
+-    a = [i for i in range(N)]
+-    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
+-
+-    # 4. Create N operators
+-    for i in range(1, N):
+-        sx[i] = sx[0].permute(b[i])
+-        sy[i] = sy[0].permute(b[i])
+-        sz[i] = sz[0].permute(b[i])
+-        sp[i] = sp[0].permute(b[i])
+-        sm[i] = sm[0].permute(b[i])
+-
+-    spin_operators = [sx, sy, sz]
+-
+-    if not op:
+-        return spin_operators
+-    elif op == "x":
+-        return sx
+-    elif op == "y":
+-        return sy
+-    elif op == "z":
+-        return sz
+-    elif op == "+":
+-        return sp
+-    elif op == "-":
+-        return sm
+-    else:
+-        raise TypeError("Invalid type")
+-
+-
+-def _jspin_uncoupled(N, op=None):
+-    """Construct the the collective spin algebra in the uncoupled basis.
+-
+-    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
+-    two-level system (TLS). Each collective operator is placed in a
+-    Hilbert space of dimension 2^N.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    op: str
+-        The operator to return 'x','y','z','+','-'.
+-        If no operator given, then output is the list of operators
+-        for ['x','y','z',].
+-
+-    Returns
+-    -------
+-    collective_operators: list or :class: qutip.Qobj
+-        A list of `qutip.Qobj` representing all the operators in
+-        uncoupled" basis or a single operator requested.
+-    """
+-    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
+-    N = int(N)
+-
+-    sx, sy, sz = spin_algebra(N)
+-    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
+-
+-    jx = sum(sx)
+-    jy = sum(sy)
+-    jz = sum(sz)
+-    jp = sum(sp)
+-    jm = sum(sm)
+-
+-    collective_operators = [jx, jy, jz]
+-
+-    if not op:
+-        return collective_operators
+-    elif op == "x":
+-        return jx
+-    elif op == "y":
+-        return jy
+-    elif op == "z":
+-        return jz
+-    elif op == "+":
+-        return jp
+-    elif op == "-":
+-        return jm
+-    else:
+-        raise TypeError("Invalid type")
+-
+-
+-def jspin(N, op=None, basis="dicke"):
+-    r"""
+-    Calculate the list of collective operators of the total algebra.
+-
+-    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
+-    default. Otherwise with "uncoupled" the operators are in a
+-    :math:`2^N` space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        Number of two-level systems.
+-
+-    op: str
+-        The operator to return 'x','y','z','+','-'.
+-        If no operator given, then output is the list of operators
+-        for ['x','y','z'].
+-
+-    basis: str
+-        The basis of the operators - "dicke" or "uncoupled"
+-        default: "dicke".
+-
+-    Returns
+-    -------
+-    j_alg: list or :class: qutip.Qobj
+-        A list of `qutip.Qobj` representing all the operators in
+-        the "dicke" or "uncoupled" basis or a single operator requested.
+-    """
+-    if basis == "uncoupled":
+-        return _jspin_uncoupled(N, op)
+-
+-    nds = num_dicke_states(N)
+-    num_ladders = num_dicke_ladders(N)
+-    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
+-    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
+-    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
+-    s = 0
+-
+-    for k in range(0, num_ladders):
+-        j = 0.5 * N - k
+-        mmax = int(2 * j + 1)
+-        for i in range(0, mmax):
+-            m = j - i
+-            jz_operator[s, s] = m
+-            if (s + 1) in range(0, nds):
+-                jp_operator[s, s + 1] = ap(j, m - 1)
+-            if (s - 1) in range(0, nds):
+-                jm_operator[s, s - 1] = am(j, m + 1)
+-            s = s + 1
+-
+-    jx_operator = 1 / 2 * (jp_operator + jm_operator)
+-    jy_operator = 1j / 2 * (jm_operator - jp_operator)
+-    jx = Qobj(jx_operator)
+-    jy = Qobj(jy_operator)
+-    jz = Qobj(jz_operator)
+-    jp = Qobj(jp_operator)
+-    jm = Qobj(jm_operator)
+-
+-    if not op:
+-        return [jx, jy, jz]
+-    if op == "+":
+-        return jp
+-    elif op == "-":
+-        return jm
+-    elif op == "x":
+-        return jx
+-    elif op == "y":
+-        return jy
+-    elif op == "z":
+-        return jz
+-    else:
+-        raise TypeError("Invalid type")
+-
+-
+-def collapse_uncoupled(
+-    N,
+-    emission=0.0,
+-    dephasing=0.0,
+-    pumping=0.0,
+-    collective_emission=0.0,
+-    collective_dephasing=0.0,
+-    collective_pumping=0.0,
+-):
+-    """
+-    Create the collapse operators (c_ops) of the Lindbladian in the
+-    uncoupled basis
+-
+-    These operators are in the uncoupled basis of the two-level
+-    system (TLS) SU(2) Pauli matrices.
+-
+-    Notes
+-    -----
+-    The collapse operator list can be given to `qutip.mesolve`.
+-    Notice that the operators are placed in a Hilbert space of
+-    dimension :math:`2^N`. Thus the method is suitable only for
+-    small N (of the order of 10).
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-
+-    Returns
+-    -------
+-    c_ops: list
+-        The list of collapse operators as `qutip.Qobj` for the system.
+-    """
+-    N = int(N)
+-
+-    if N > 10:
+-        msg = "N > 10. dim(H) = 2^N. "
+-        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
+-        msg += "dimension and exploit permutational symmetry."
+-        raise Warning(msg)
+-
+-    [sx, sy, sz] = spin_algebra(N)
+-    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
+-    [jx, jy, jz] = jspin(N, basis="uncoupled")
+-    jp, jm = (
+-        jspin(N, "+", basis="uncoupled"),
+-        jspin(N, "-", basis="uncoupled"),
+-    )
+-
+-    c_ops = []
+-
+-    if emission != 0:
+-        for i in range(0, N):
+-            c_ops.append(np.sqrt(emission) * sm[i])
+-
+-    if dephasing != 0:
+-        for i in range(0, N):
+-            c_ops.append(np.sqrt(dephasing) * sz[i])
+-
+-    if pumping != 0:
+-        for i in range(0, N):
+-            c_ops.append(np.sqrt(pumping) * sp[i])
+-
+-    if collective_emission != 0:
+-        c_ops.append(np.sqrt(collective_emission) * jm)
+-
+-    if collective_dephasing != 0:
+-        c_ops.append(np.sqrt(collective_dephasing) * jz)
+-
+-    if collective_pumping != 0:
+-        c_ops.append(np.sqrt(collective_pumping) * jp)
+-
+-    return c_ops
+-
+-
+-# State definitions in the Dicke basis with an option for basis transformation
+-def dicke_basis(N, jmm1=None):
+-    r"""
+-    Initialize the density matrix of a Dicke state for several (j, m, m1).
+-
+-    This function can be used to build arbitrary states in the Dicke basis
+-    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
+-    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
+-    index of the density matrix to the :math:`\lvert j, m\rangle` values is
+-    given by the cythonized function `jmm1_dictionary`. A density matrix is
+-    created from the given dictionary of coefficients for each (j, m, m1).
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    jmm1: dict
+-        A dictionary of {(j, m, m1): p} that gives a density p for the
+-        (j, m, m1) matrix element.
+-
+-    Returns
+-    -------
+-    rho: :class: qutip.Qobj
+-        The density matrix in the Dicke basis.
+-    """
+-    if jmm1 is None:
+-        msg = "Please specify the jmm1 values as a dictionary"
+-        msg += "or use the `excited(N)` function to create an"
+-        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
+-        raise AttributeError(msg)
+-
+-    nds = _num_dicke_states(N)
+-    rho = np.zeros((nds, nds))
+-    jmm1_dict = jmm1_dictionary(N)[1]
+-    for key in jmm1:
+-        i, k = jmm1_dict[key]
+-        rho[i, k] = jmm1[key]
+-    return Qobj(rho)
+-
+-
+-def dicke(N, j, m):
+-    r"""
+-    Generate a Dicke state as a pure density matrix in the Dicke basis.
+-
+-    For instance, the superradiant state given by
+-    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
+-    and the state is represented as a density matrix of size (nds, nds) or
+-    (4, 4), with the (1, 1) element set to 1.
+-
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    j: float
+-        The eigenvalue j of the Dicke state (j, m).
+-
+-    m: float
+-        The eigenvalue m of the Dicke state (j, m).
+-
+-    Returns
+-    -------
+-    rho: :class: qutip.Qobj
+-        The density matrix.
+-    """
+-    nds = num_dicke_states(N)
+-    rho = np.zeros((nds, nds))
+-
+-    jmm1_dict = jmm1_dictionary(N)[1]
+-
+-    i, k = jmm1_dict[(j, m, m)]
+-    rho[i, k] = 1.0
+-    return Qobj(rho)
+-
+-
+-# Uncoupled states in the full Hilbert space. These are returned with the
+-# choice of the keyword argument `basis="uncoupled"` in the state functions.
+-def _uncoupled_excited(N):
+-    """
+-    Generate the density matrix of the excited Dicke state in the full
+-    :math:`2^N` dimensional Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    psi0: :class: qutip.Qobj
+-        The density matrix for the excited state in the uncoupled basis.
+-    """
+-    N = int(N)
+-    jz = jspin(N, "z", basis="uncoupled")
+-    en, vn = jz.eigenstates()
+-    psi0 = vn[2 ** N - 1]
+-    return ket2dm(psi0)
+-
+-
+-def _uncoupled_superradiant(N):
+-    """
+-    Generate the density matrix of a superradiant state in the full
+-    :math:`2^N`-dimensional Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    psi0: :class: qutip.Qobj
+-        The density matrix for the superradiant state in the full Hilbert
+-        space.
+-    """
+-    N = int(N)
+-    jz = jspin(N, "z", basis="uncoupled")
+-    en, vn = jz.eigenstates()
+-    psi0 = vn[2 ** N - (N + 1)]
+-    return ket2dm(psi0)
+-
+-
+-def _uncoupled_ground(N):
+-    """
+-    Generate the density matrix of the ground state in the full\
+-    :math:`2^N`-dimensional Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    psi0: :class: qutip.Qobj
+-        The density matrix for the ground state in the full Hilbert space.
+-    """
+-    N = int(N)
+-    jz = jspin(N, "z", basis="uncoupled")
+-    en, vn = jz.eigenstates()
+-    psi0 = vn[0]
+-    return ket2dm(psi0)
+-
+-
+-def _uncoupled_ghz(N):
+-    """
+-    Generate the density matrix of the GHZ state in the full 2^N
+-    dimensional Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    ghz: :class: qutip.Qobj
+-        The density matrix for the GHZ state in the full Hilbert space.
+-    """
+-    N = int(N)
+-    rho = np.zeros((2 ** N, 2 ** N))
+-    rho[0, 0] = 1 / 2
+-    rho[2 ** N - 1, 0] = 1 / 2
+-    rho[0, 2 ** N - 1] = 1 / 2
+-    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
+-    spin_dim = [2 for i in range(0, N)]
+-    spins_dims = list((spin_dim, spin_dim))
+-    rho = Qobj(rho, dims=spins_dims)
+-    return rho
+-
+-
+-def _uncoupled_css(N, a, b):
+-    r"""
+-    Generate the density matrix of the CSS state in the full 2^N
+-    dimensional Hilbert space.
+-
+-    The CSS states are non-entangled states given by
+-    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    a: complex
+-        The coefficient of the :math:`\lvert1_i\rangle` state.
+-
+-    b: complex
+-        The coefficient of the :math:`\lvert0_i\rangle` state.
+-
+-    Returns
+-    -------
+-    css: :class: qutip.Qobj
+-        The density matrix for the CSS state in the full Hilbert space.
+-    """
+-    N = int(N)
+-    # 1. Define i_th factorized density matrix in the uncoupled basis
+-    rho_i = np.zeros((2, 2), dtype=complex)
+-    rho_i[0, 0] = a * np.conj(a)
+-    rho_i[1, 1] = b * np.conj(b)
+-    rho_i[0, 1] = a * np.conj(b)
+-    rho_i[1, 0] = b * np.conj(a)
+-    rho_i = Qobj(rho_i)
+-    rho = [0 for i in range(N)]
+-    rho[0] = rho_i
+-    # 2. Place single-two-level-system density matrices in total Hilbert space
+-    for k in range(N - 1):
+-        rho[0] = tensor(rho[0], identity(2))
+-    # 3. Cyclic sequence to create all N factorized density matrices
+-    # |CSS>_i<CSS|_i
+-    a = [i for i in range(N)]
+-    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
+-    # 4. Create all other N-1 factorized density matrices
+-    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
+-    for i in range(1, N):
+-        rho[i] = rho[0].permute(b[i])
+-    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
+-    rho_tot = identity_i
+-    for i in range(0, N):
+-        rho_tot = rho_tot * rho[i]
+-    return rho_tot
+-
+-
+-def excited(N, basis="dicke"):
+-    """
+-    Generate the density matrix for the excited state.
+-
+-    This state is given by (N/2, N/2) in the default Dicke basis. If the
+-    argument `basis` is "uncoupled" then it generates the state in a
+-    2**N dim Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    basis: str
+-        The basis to use. Either "dicke" or "uncoupled".
+-
+-    Returns
+-    -------
+-    state: :class: qutip.Qobj
+-        The excited state density matrix in the requested basis.
+-    """
+-    if basis == "uncoupled":
+-        state = _uncoupled_excited(N)
+-        return state
+-
+-    jmm1 = {(N / 2, N / 2, N / 2): 1}
+-    return dicke_basis(N, jmm1)
+-
+-
+-def superradiant(N, basis="dicke"):
+-    """
+-    Generate the density matrix of the superradiant state.
+-
+-    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
+-    If the argument `basis` is "uncoupled" then it generates the state
+-    in a 2**N dim Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    basis: str
+-        The basis to use. Either "dicke" or "uncoupled".
+-
+-    Returns
+-    -------
+-    state: :class: qutip.Qobj
+-        The superradiant state density matrix in the requested basis.
+-    """
+-    if basis == "uncoupled":
+-        state = _uncoupled_superradiant(N)
+-        return state
+-
+-    if N % 2 == 0:
+-        jmm1 = {(N / 2, 0, 0): 1.0}
+-        return dicke_basis(N, jmm1)
+-    else:
+-        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
+-    return dicke_basis(N, jmm1)
+-
+-
+-def css(
+-    N,
+-    x=1 / np.sqrt(2),
+-    y=1 / np.sqrt(2),
+-    basis="dicke",
+-    coordinates="cartesian",
+-):
+-    r"""
+-    Generate the density matrix of the Coherent Spin State (CSS).
+-
+-    It can be defined as,
+-    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
+-    with :math:`a = sin(\frac{\theta}{2})`,
+-    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
+-    The default basis is that of Dicke space
+-    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
+-    The default state is the symmetric CSS,
+-    :math:`\lvert CSS\rangle = \lvert+\rangle`.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    x, y: float
+-        The coefficients of the CSS state.
+-
+-    basis: str
+-        The basis to use. Either "dicke" or "uncoupled".
+-
+-    coordinates: str
+-        Either "cartesian" or "polar". If polar then the coefficients
+-        are constructed as sin(x/2), cos(x/2)e^(iy).
+-
+-    Returns
+-    -------
+-    rho: :class: qutip.Qobj
+-        The CSS state density matrix.
+-    """
+-    if coordinates == "polar":
+-        a = np.cos(0.5 * x) * np.exp(1j * y)
+-        b = np.sin(0.5 * x)
+-    else:
+-        a = x
+-        b = y
+-    if basis == "uncoupled":
+-        return _uncoupled_css(N, a, b)
+-    nds = num_dicke_states(N)
+-    num_ladders = num_dicke_ladders(N)
+-    rho = dok_matrix((nds, nds), dtype=np.complex128)
+-
+-    # loop in the allowed matrix elements
+-    jmm1_dict = jmm1_dictionary(N)[1]
+-
+-    j = 0.5 * N
+-    mmax = int(2 * j + 1)
+-    for i in range(0, mmax):
+-        m = j - i
+-        psi_m = (
+-            np.sqrt(float(energy_degeneracy(N, m)))
+-            * a ** (N * 0.5 + m)
+-            * b ** (N * 0.5 - m)
+-        )
+-        for i1 in range(0, mmax):
+-            m1 = j - i1
+-            row_column = jmm1_dict[(j, m, m1)]
+-            psi_m1 = (
+-                np.sqrt(float(energy_degeneracy(N, m1)))
+-                * np.conj(a) ** (N * 0.5 + m1)
+-                * np.conj(b) ** (N * 0.5 - m1)
+-            )
+-            rho[row_column] = psi_m * psi_m1
+-    return Qobj(rho)
+-
+-
+-def ghz(N, basis="dicke"):
+-    """
+-    Generate the density matrix of the GHZ state.
+-
+-    If the argument `basis` is "uncoupled" then it generates the state
+-    in a :math:`2^N`-dimensional Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    basis: str
+-        The basis to use. Either "dicke" or "uncoupled".
+-
+-    Returns
+-    -------
+-    state: :class: qutip.Qobj
+-        The GHZ state density matrix in the requested basis.
+-    """
+-    if basis == "uncoupled":
+-        return _uncoupled_ghz(N)
+-    nds = _num_dicke_states(N)
+-    rho = dok_matrix((nds, nds), dtype=np.complex128)
+-    rho[0, 0] = 1 / 2
+-    rho[N, N] = 1 / 2
+-    rho[N, 0] = 1 / 2
+-    rho[0, N] = 1 / 2
+-    return Qobj(rho)
+-
+-
+-def ground(N, basis="dicke"):
+-    """
+-    Generate the density matrix of the ground state.
+-
+-    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
+-    `basis` is "uncoupled" then it generates the state in a
+-    :math:`2^N`-dimensional Hilbert space.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    basis: str
+-        The basis to use. Either "dicke" or "uncoupled"
+-
+-    Returns
+-    -------
+-    state: :class: qutip.Qobj
+-        The ground state density matrix in the requested basis.
+-    """
+-    if basis == "uncoupled":
+-        state = _uncoupled_ground(N)
+-        return state
+-    nds = _num_dicke_states(N)
+-    rho = dok_matrix((nds, nds), dtype=np.complex128)
+-    rho[N, N] = 1
+-    return Qobj(rho)
+-
+-
+-def identity_uncoupled(N):
+-    """
+-    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
+-
+-    The identity matrix is formed from the tensor product of N TLSs.
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    Returns
+-    -------
+-    identity: :class: qutip.Qobj
+-        The identity matrix.
+-    """
+-    N = int(N)
+-    rho = np.zeros((2 ** N, 2 ** N))
+-    for i in range(0, 2 ** N):
+-        rho[i, i] = 1
+-    spin_dim = [2 for i in range(0, N)]
+-    spins_dims = list((spin_dim, spin_dim))
+-    identity = Qobj(rho, dims=spins_dims)
+-    return identity
+-
+-
+-def block_matrix(N, elements="ones"):
+-    """Construct the block-diagonal matrix for the Dicke basis.
+-
+-    Parameters
+-    ----------
+-    N : int
+-        Number of two-level systems.
+-    elements : str {'ones' (default),'degeneracy'}
+-
+-    Returns
+-    -------
+-    block_matr : ndarray
+-        A 2D block-diagonal matrix with dimension (nds,nds),
+-        where nds is the number of Dicke states for N two-level
+-        systems. Filled with ones or the value of degeneracy
+-        at each matrix element.
+-    """
+-    # create a list with the sizes of the blocks, in order
+-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+-    blocks_list = [
+-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+-        for i in range(blocks_dimensions)
+-    ]
+-    blocks_list = np.flip(blocks_list, 0)
+-    # create a list with each block matrix as element
+-    square_blocks = []
+-    k = 0
+-    for i in blocks_list:
+-        if elements == "ones":
+-            square_blocks.append(np.ones((i, i)))
+-        elif elements == "degeneracy":
+-            j = N / 2 - k
+-            dj = state_degeneracy(N, j)
+-            square_blocks.append(dj * np.ones((i, i)))
+-        k = k + 1
+-    return block_diag(square_blocks)
+-
+-
+-# ============================================================================
+-# Adding a faster version to make a Permutational Invariant matrix
+-# ============================================================================
+-def tau_column(tau, k, j):
+-    """
+-    Determine the column index for the non-zero elements of the matrix for a
+-    particular row `k` and the value of `j` from the Dicke space.
+-
+-    Parameters
+-    ----------
+-    tau: str
+-        The tau function to check for this `k` and `j`.
+-
+-    k: int
+-        The row of the matrix M for which the non zero elements have
+-        to be calculated.
+-
+-    j: float
+-        The value of `j` for this row.
+-    """
+-    # In the notes, we indexed from k = 1, here we do it from k = 0
+-    k = k + 1
+-    mapping = {
+-        "tau3": k - (2 * j + 3),
+-        "tau2": k - 1,
+-        "tau4": k + (2 * j - 1),
+-        "tau5": k - (2 * j + 2),
+-        "tau1": k,
+-        "tau6": k + (2 * j),
+-        "tau7": k - (2 * j + 1),
+-        "tau8": k + 1,
+-        "tau9": k + (2 * j + 1),
+-    }
+-    # we need to decrement k again as indexing is from 0
+-    return int(mapping[tau] - 1)
+-
+-
+-class Pim(object):
+-    """
+-    The Permutation Invariant Matrix class.
+-
+-    Initialize the class with the parameters for generating a Permutation
+-    Invariant matrix which evolves a given diagonal initial state `p` as:
+-
+-                                dp/dt = Mp
+-
+-    Parameters
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-
+-    Attributes
+-    ----------
+-    N: int
+-        The number of two-level systems.
+-
+-    emission: float
+-        Incoherent emission coefficient (also nonradiative emission).
+-        default: 0.0
+-
+-    dephasing: float
+-        Local dephasing coefficient.
+-        default: 0.0
+-
+-    pumping: float
+-        Incoherent pumping coefficient.
+-        default: 0.0
+-
+-    collective_emission: float
+-        Collective (superradiant) emmission coefficient.
+-        default: 0.0
+-
+-    collective_dephasing: float
+-        Collective dephasing coefficient.
+-        default: 0.0
+-
+-    collective_pumping: float
+-        Collective pumping coefficient.
+-        default: 0.0
+-
+-    M: dict
+-        A nested dictionary of the structure {row: {col: val}} which holds
+-        non zero elements of the matrix M
+-    """
+-
+-    def __init__(
+-        self,
+-        N,
+-        emission=0.0,
+-        dephasing=0,
+-        pumping=0,
+-        collective_emission=0,
+-        collective_pumping=0,
+-        collective_dephasing=0,
+-    ):
+-        self.N = N
+-        self.emission = emission
+-        self.dephasing = dephasing
+-        self.pumping = pumping
+-        self.collective_pumping = collective_pumping
+-        self.collective_dephasing = collective_dephasing
+-        self.collective_emission = collective_emission
+-        self.M = {}
+-
+-    def isdicke(self, dicke_row, dicke_col):
+-        """
+-        Check if an element in a matrix is a valid element in the Dicke space.
+-        Dicke row: j value index. Dicke column: m value index.
+-        The function returns True if the element exists in the Dicke space and
+-        False otherwise.
+-
+-        Parameters
+-        ----------
+-        dicke_row, dicke_col : int
+-            Index of the element in Dicke space which needs to be checked
+-        """
+-        rows = self.N + 1
+-        cols = 0
+-
+-        if (self.N % 2) == 0:
+-            cols = int(self.N / 2 + 1)
+-        else:
+-            cols = int(self.N / 2 + 1 / 2)
+-        if (dicke_row > rows) or (dicke_row < 0):
+-            return False
+-        if (dicke_col > cols) or (dicke_col < 0):
+-            return False
+-        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
+-            return False
+-        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
+-            return False
+-        else:
+-            return True
+-
+-    def tau_valid(self, dicke_row, dicke_col):
+-        """
+-        Find the Tau functions which are valid for this value of (dicke_row,
+-        dicke_col) given the number of TLS. This calculates the valid tau
+-        values and reurns a dictionary specifying the tau function name and
+-        the value.
+-
+-        Parameters
+-        ----------
+-        dicke_row, dicke_col : int
+-            Index of the element in Dicke space which needs to be checked.
+-
+-        Returns
+-        -------
+-        taus: dict
+-            A dictionary of key, val as {tau: value} consisting of the valid
+-            taus for this row and column of the Dicke space element.
+-        """
+-        tau_functions = [
+-            self.tau3,
+-            self.tau2,
+-            self.tau4,
+-            self.tau5,
+-            self.tau1,
+-            self.tau6,
+-            self.tau7,
+-            self.tau8,
+-            self.tau9,
+-        ]
+-        N = self.N
+-        if self.isdicke(dicke_row, dicke_col) is False:
+-            return False
+-        # The 3x3 sub matrix surrounding the Dicke space element to
+-        # run the tau functions
+-        indices = [
+-            (dicke_row + x, dicke_col + y)
+-            for x in range(-1, 2)
+-            for y in range(-1, 2)
+-        ]
+-        taus = {}
+-        for idx, tau in zip(indices, tau_functions):
+-            if self.isdicke(idx[0], idx[1]):
+-                j, m = self.calculate_j_m(idx[0], idx[1])
+-                taus[tau.__name__] = tau(j, m)
+-        return taus
+-
+-    def calculate_j_m(self, dicke_row, dicke_col):
+-        """
+-        Get the value of j and m for the particular Dicke space element.
+-
+-        Parameters
+-        ----------
+-        dicke_row, dicke_col: int
+-            The row and column from the Dicke space matrix
+-
+-        Returns
+-        -------
+-        j, m: float
+-            The j and m values.
+-        """
+-        N = self.N
+-        j = N / 2 - dicke_col
+-        m = N / 2 - dicke_row
+-        return (j, m)
+-
+-    def calculate_k(self, dicke_row, dicke_col):
+-        """
+-        Get k value from the current row and column element in the Dicke space.
+-
+-        Parameters
+-        ----------
+-        dicke_row, dicke_col: int
+-            The row and column from the Dicke space matrix.
+-        Returns
+-        -------
+-        k: int
+-            The row index for the matrix M for given Dicke space
+-            element.
+-        """
+-        N = self.N
+-        if dicke_row == 0:
+-            k = dicke_col
+-        else:
+-            k = int(
+-                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
+-                + (dicke_row - (dicke_col))
+-            )
+-        return k
+-
+-    def coefficient_matrix(self):
+-        """
+-        Generate the matrix M governing the dynamics for diagonal cases.
+-
+-        If the initial density matrix and the Hamiltonian is diagonal, the
+-        evolution of the system is given by the simple ODE: dp/dt = Mp.
+-        """
+-        N = self.N
+-        nds = num_dicke_states(N)
+-        rows = self.N + 1
+-        cols = 0
+-
+-        sparse_M = lil_matrix((nds, nds), dtype=float)
+-        if (self.N % 2) == 0:
+-            cols = int(self.N / 2 + 1)
+-        else:
+-            cols = int(self.N / 2 + 1 / 2)
+-        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
+-            if self.isdicke(dicke_row, dicke_col):
+-                k = int(self.calculate_k(dicke_row, dicke_col))
+-                row = {}
+-                taus = self.tau_valid(dicke_row, dicke_col)
+-                for tau in taus:
+-                    j, m = self.calculate_j_m(dicke_row, dicke_col)
+-                    current_col = tau_column(tau, k, j)
+-                    sparse_M[k, int(current_col)] = taus[tau]
+-        return sparse_M.tocsr()
+-
+-    def solve(self, rho0, tlist, options=None):
+-        """
+-        Solve the ODE for the evolution of diagonal states and Hamiltonians.
+-        """
+-        if options is None:
+-            options = SolverOptions()
+-        output = Result()
+-        output.solver = "pisolve"
+-        output.times = tlist
+-        output.states = []
+-        output.states.append(Qobj(rho0))
+-        rhs_generate = lambda y, tt, M: M.dot(y)
+-        rho0_flat = np.diag(np.real(rho0.full()))
+-        L = self.coefficient_matrix()
+-        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
+-        for r in rho_t[1:]:
+-            diag = np.diag(r)
+-            output.states.append(Qobj(diag))
+-        return output
+-
+-    def tau1(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j, m, m).
+-        """
+-        yS = self.collective_emission
+-        yL = self.emission
+-        yD = self.dephasing
+-        yP = self.pumping
+-        yCP = self.collective_pumping
+-        N = float(self.N)
+-        spontaneous = yS * (1 + j - m) * (j + m)
+-        losses = yL * (N / 2 + m)
+-        pump = yP * (N / 2 - m)
+-        collective_pump = yCP * (1 + j + m) * (j - m)
+-        if j == 0:
+-            dephase = yD * N / 4
+-        else:
+-            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
+-        t1 = spontaneous + losses + pump + dephase + collective_pump
+-        return -t1
+-
+-    def tau2(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j, m+1, m+1).
+-        """
+-        yS = self.collective_emission
+-        yL = self.emission
+-        N = float(self.N)
+-        spontaneous = yS * (1 + j - m) * (j + m)
+-        losses = yL * (
+-            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
+-        )
+-        t2 = spontaneous + losses
+-        return t2
+-
+-    def tau3(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
+-        """
+-        yL = self.emission
+-        N = float(self.N)
+-        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
+-        den = 2 * j * (2 * j + 1)
+-        t3 = yL * (num / den)
+-        return t3
+-
+-    def tau4(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
+-        """
+-        yL = self.emission
+-        N = float(self.N)
+-        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
+-        den = 2 * (j + 1) * (2 * j + 1)
+-        t4 = yL * (num / den)
+-        return t4
+-
+-    def tau5(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j+1, m, m).
+-        """
+-        yD = self.dephasing
+-        N = float(self.N)
+-        num = (j - m) * (j + m) * (j + 1 + N / 2)
+-        den = 2 * j * (2 * j + 1)
+-        t5 = yD * (num / den)
+-        return t5
+-
+-    def tau6(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j-1, m, m).
+-        """
+-        yD = self.dephasing
+-        N = float(self.N)
+-        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
+-        den = 2 * (j + 1) * (2 * j + 1)
+-        t6 = yD * (num / den)
+-        return t6
+-
+-    def tau7(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
+-        """
+-        yP = self.pumping
+-        N = float(self.N)
+-        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
+-        den = 2 * j * (2 * j + 1)
+-        t7 = yP * (float(num) / den)
+-        return t7
+-
+-    def tau8(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j, m-1, m-1).
+-        """
+-        yP = self.pumping
+-        yCP = self.collective_pumping
+-        N = float(self.N)
+-
+-        num = (1 + N / 2) * (j - m) * (j + m + 1)
+-        den = 2 * j * (j + 1)
+-        pump = yP * (float(num) / den)
+-        collective_pump = yCP * (j - m) * (j + m + 1)
+-        t8 = pump + collective_pump
+-        return t8
+-
+-    def tau9(self, j, m):
+-        """
+-        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
+-        """
+-        yP = self.pumping
+-        N = float(self.N)
+-        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
+-        den = 2 * (j + 1) * (2 * j + 1)
+-        t9 = yP * (float(num) / den)
+-        return t9
++"""Permutational Invariant Quantum Solver (PIQS)
++
++This module calculates the Liouvillian for the dynamics of ensembles of
++identical two-level systems (TLS) in the presence of local and collective
++processes by exploiting permutational symmetry and using the Dicke basis.
++It also allows to characterize nonlinear functions of the density matrix.
++"""
++
++# Authors: Nathan Shammah, Shahnawaz Ahmed
++# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
++
++from math import factorial
++from decimal import Decimal
++
++import numpy as np
++from scipy.integrate import odeint
++from scipy.linalg import eigvalsh
++from scipy.special import entr
++from scipy.sparse import dok_matrix, block_diag, lil_matrix
++from .. import (
++    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
++    sigmap, sigmam,
++)
++from ..entropy import entropy_vn
++from .solver import SolverOptions, Result
++from ._piqs import Dicke as _Dicke
++from ._piqs import (
++    jmm1_dictionary,
++    _num_dicke_states,
++    _num_dicke_ladders,
++    get_blocks,
++    j_min,
++    j_vals,
++)
++
++__all__ = [
++    "num_dicke_states",
++    "num_dicke_ladders",
++    "num_tls",
++    "isdiagonal",
++    "dicke_blocks",
++    "dicke_blocks_full",
++    "dicke_function_trace",
++    "purity_dicke",
++    "entropy_vn_dicke",
++    "Dicke",
++    "state_degeneracy",
++    "m_degeneracy",
++    "energy_degeneracy",
++    "ap",
++    "am",
++    "spin_algebra",
++    "jspin",
++    "collapse_uncoupled",
++    "dicke_basis",
++    "dicke",
++    "excited",
++    "superradiant",
++    "css",
++    "ghz",
++    "ground",
++    "identity_uncoupled",
++    "block_matrix",
++    "tau_column",
++    "Pim",
++]
++
++
++def _ensure_int(x):
++    """
++    Ensure that a floating-point value `x` is exactly an integer, and return it
++    as an int.
++    """
++    out = int(x)
++    if out != x:
++        raise ValueError(f"{x} is not an integral value")
++    return out
++
++
++# Functions necessary to generate the Lindbladian/Liouvillian
++def num_dicke_states(N):
++    """Calculate the number of Dicke states.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    nds: int
++        The number of Dicke states.
++    """
++    return _num_dicke_states(N)
++
++
++def num_dicke_ladders(N):
++    """Calculate the total number of ladders in the Dicke space.
++
++    For a collection of N two-level systems it counts how many different
++    "j" exist or the number of blocks in the block-diagonal matrix.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    Nj: int
++        The number of Dicke ladders.
++    """
++    return _num_dicke_ladders(N)
++
++
++def num_tls(nds):
++    """Calculate the number of two-level systems.
++
++    Parameters
++    ----------
++    nds: int
++         The number of Dicke states.
++
++    Returns
++    -------
++    N: int
++        The number of two-level systems.
++    """
++    if np.sqrt(nds).is_integer():
++        # N is even
++        N = 2 * (np.sqrt(nds) - 1)
++    else:
++        # N is odd
++        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
++    return int(N)
++
++
++def isdiagonal(mat):
++    """
++    Check if the input matrix is diagonal.
++
++    Parameters
++    ==========
++    mat: ndarray/Qobj
++        A 2D numpy array
++
++    Returns
++    =======
++    diag: bool
++        True/False depending on whether the input matrix is diagonal.
++    """
++    if isinstance(mat, Qobj):
++        mat = mat.full()
++
++    return np.all(mat == np.diag(np.diagonal(mat)))
++
++
++# nonlinear functions of the density matrix
++def dicke_blocks(rho):
++    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        A 2D block-diagonal matrix of ones with dimension (nds,nds),
++        where nds is the number of Dicke states for N two-level
++        systems.
++
++    Returns
++    -------
++    square_blocks: list of np.array
++        Give back the blocks list.
++
++    """
++    shape_dimension = rho.shape[0]
++    N = num_tls(shape_dimension)
++    ladders = num_dicke_ladders(N)
++    # create a list with the sizes of the blocks, in order
++    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
++    blocks_list = [
++        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
++        for i in range(blocks_dimensions)
++    ]
++    blocks_list = np.flip(blocks_list, 0)
++    # create a list with each block matrix as element
++    square_blocks = []
++    block_position = 0
++    for block_size in blocks_list:
++        start_m = block_position
++        end_m = block_position + block_size
++        square_block = rho[start_m:end_m, start_m:end_m]
++        block_position = block_position + block_size
++        square_blocks.append(square_block)
++
++    return square_blocks
++
++
++def dicke_blocks_full(rho):
++    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        A 2D block-diagonal matrix of ones with dimension (nds,nds),
++        where nds is the number of Dicke states for N two-level
++        systems.
++
++    Returns
++    -------
++    full_blocks : list
++        The list of blocks expanded in the 2^N space for N qubits.
++
++    """
++    shape_dimension = rho.shape[0]
++    N = num_tls(shape_dimension)
++    ladders = num_dicke_ladders(N)
++    # create a list with the sizes of the blocks, in order
++    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
++    blocks_list = [
++        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
++        for i in range(blocks_dimensions)
++    ]
++    blocks_list = np.flip(blocks_list, 0)
++    # create a list with each block matrix as element
++    full_blocks = []
++    k = 0
++    block_position = 0
++    for block_size in blocks_list:
++        start_m = block_position
++        end_m = block_position + block_size
++        square_block = rho[start_m:end_m, start_m:end_m]
++        block_position = block_position + block_size
++        j = N / 2 - k
++        djn = state_degeneracy(N, j)
++        for block_counter in range(0, djn):
++            full_blocks.append(square_block / djn)  # preserve trace
++        k = k + 1
++    return full_blocks
++
++
++def dicke_function_trace(f, rho):
++    """Calculate the trace of a function on a Dicke density matrix.
++    Parameters
++    ----------
++    f : function
++        A Taylor-expandable function of `rho`.
++
++    rho : :class:`qutip.Qobj`
++        A density matrix in the Dicke basis.
++
++    Returns
++    -------
++    res : float
++        Trace of a nonlinear function on `rho`.
++    """
++    N = num_tls(rho.shape[0])
++    blocks = dicke_blocks(rho)
++    block_f = []
++    degen_blocks = np.flip(j_vals(N))
++    state_degeneracies = []
++    for j in degen_blocks:
++        dj = state_degeneracy(N, j)
++        state_degeneracies.append(dj)
++    eigenvals_degeneracy = []
++    deg = []
++    for i, block in enumerate(blocks):
++        dj = state_degeneracies[i]
++        normalized_block = block / dj
++        eigenvals_block = eigvalsh(normalized_block)
++        for val in eigenvals_block:
++            eigenvals_degeneracy.append(val)
++            deg.append(dj)
++
++    eigenvalue = np.array(eigenvals_degeneracy)
++    function_array = f(eigenvalue) * deg
++    return sum(function_array)
++
++
++def entropy_vn_dicke(rho):
++    """Von Neumann Entropy of a Dicke-basis density matrix.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        A 2D block-diagonal matrix of ones with dimension (nds,nds),
++        where nds is the number of Dicke states for N two-level
++        systems.
++
++    Returns
++    -------
++    entropy_dm: float
++        Entropy. Use degeneracy to multiply each block.
++
++    """
++    return dicke_function_trace(entr, rho)
++
++
++def purity_dicke(rho):
++    """Calculate purity of a density matrix in the Dicke basis.
++    It accounts for the degenerate blocks in the density matrix.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
++
++    Returns
++    -------
++    purity : float
++        The purity of the quantum state.
++        It's 1 for pure states, 0<=purity<1 for mixed states.
++    """
++    f = lambda x: x * x
++    return dicke_function_trace(f, rho)
++
++
++class Dicke(object):
++    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
++
++    Examples
++    --------
++    >>> from piqs import Dicke, jspin
++    >>> N = 2
++    >>> jx, jy, jz = jspin(N)
++    >>> jp = jspin(N, "+")
++    >>> jm = jspin(N, "-")
++    >>> ensemble = Dicke(N, emission=1.)
++    >>> L = ensemble.liouvillian()
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    hamiltonian : :class:`qutip.Qobj`
++        A Hamiltonian in the Dicke basis.
++
++        The matrix dimensions are (nds, nds),
++        with nds being the number of Dicke states.
++        The Hamiltonian can be built with the operators
++        given by the `jspin` functions.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++
++    Attributes
++    ----------
++    N: int
++        The number of two-level systems.
++
++    hamiltonian : :class:`qutip.Qobj`
++        A Hamiltonian in the Dicke basis.
++
++        The matrix dimensions are (nds, nds),
++        with nds being the number of Dicke states.
++        The Hamiltonian can be built with the operators given
++        by the `jspin` function in the "dicke" basis.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    nds: int
++        The number of Dicke states.
++
++    dshape: tuple
++        The shape of the Hilbert space in the Dicke or uncoupled basis.
++        default: (nds, nds).
++    """
++
++    def __init__(
++        self,
++        N,
++        hamiltonian=None,
++        emission=0.0,
++        dephasing=0.0,
++        pumping=0.0,
++        collective_emission=0.0,
++        collective_dephasing=0.0,
++        collective_pumping=0.0,
++    ):
++        self.N = N
++        self.hamiltonian = hamiltonian
++        self.emission = emission
++        self.dephasing = dephasing
++        self.pumping = pumping
++        self.collective_emission = collective_emission
++        self.collective_dephasing = collective_dephasing
++        self.collective_pumping = collective_pumping
++        self.nds = num_dicke_states(self.N)
++        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
++
++    def __repr__(self):
++        """Print the current parameters of the system."""
++        string = []
++        string.append("N = {}".format(self.N))
++        string.append("Hilbert space dim = {}".format(self.dshape))
++        string.append("Number of Dicke states = {}".format(self.nds))
++        string.append(
++            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
++        )
++        if self.emission != 0:
++            string.append("emission = {}".format(self.emission))
++        if self.dephasing != 0:
++            string.append("dephasing = {}".format(self.dephasing))
++        if self.pumping != 0:
++            string.append("pumping = {}".format(self.pumping))
++        if self.collective_emission != 0:
++            string.append(
++                "collective_emission = {}".format(self.collective_emission)
++            )
++        if self.collective_dephasing != 0:
++            string.append(
++                "collective_dephasing = {}".format(self.collective_dephasing)
++            )
++        if self.collective_pumping != 0:
++            string.append(
++                "collective_pumping = {}".format(self.collective_pumping)
++            )
++        return "\n".join(string)
++
++    def lindbladian(self):
++        """Build the Lindbladian superoperator of the dissipative dynamics.
++
++        Returns
++        -------
++        lindbladian : :class:`qutip.Qobj`
++            The Lindbladian matrix as a `qutip.Qobj`.
++        """
++        cythonized_dicke = _Dicke(
++            int(self.N),
++            float(self.emission),
++            float(self.dephasing),
++            float(self.pumping),
++            float(self.collective_emission),
++            float(self.collective_dephasing),
++            float(self.collective_pumping),
++        )
++        return cythonized_dicke.lindbladian()
++
++    def liouvillian(self):
++        """Build the total Liouvillian using the Dicke basis.
++
++        Returns
++        -------
++        liouv : :class:`qutip.Qobj`
++            The Liouvillian matrix for the system.
++        """
++        lindblad = self.lindbladian()
++        if self.hamiltonian is None:
++            liouv = lindblad
++
++        else:
++            hamiltonian = self.hamiltonian
++            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
++                hamiltonian
++            )
++            liouv = lindblad + hamiltonian_superoperator
++        return liouv
++
++    def pisolve(self, initial_state, tlist, options=None):
++        """
++        Solve for diagonal Hamiltonians and initial states faster.
++
++        Parameters
++        ==========
++        initial_state : :class:`qutip.Qobj`
++            An initial state specified as a density matrix of
++            `qutip.Qbj` type.
++
++        tlist: ndarray
++            A 1D numpy array of list of timesteps to integrate
++
++        options : :class:`qutip.solver.SolverOptions`
++            The options for the solver.
++
++        Returns
++        =======
++        result: list
++            A dictionary of the type `qutip.solver.Result` which holds the
++            results of the evolution.
++        """
++        if isdiagonal(initial_state) == False:
++            msg = "`pisolve` requires a diagonal initial density matrix. "
++            msg += "In general construct the Liouvillian using "
++            msg += "`piqs.liouvillian` and use qutip.mesolve."
++            raise ValueError(msg)
++
++        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
++            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
++            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
++            msg += "  use `qutip.mesolve`."
++            raise ValueError(msg)
++
++        if initial_state.full().shape != self.dshape:
++            msg = "Initial density matrix should be diagonal."
++            raise ValueError(msg)
++
++        pim = Pim(
++            self.N,
++            self.emission,
++            self.dephasing,
++            self.pumping,
++            self.collective_emission,
++            self.collective_pumping,
++            self.collective_dephasing,
++        )
++        result = pim.solve(initial_state, tlist, options=None)
++        return result
++
++    def c_ops(self):
++        """Build collapse operators in the full Hilbert space 2^N.
++
++        Returns
++        -------
++        c_ops_list: list
++            The list with the collapse operators in the 2^N Hilbert space.
++        """
++        ce = self.collective_emission
++        cd = self.collective_dephasing
++        cp = self.collective_pumping
++        c_ops_list = collapse_uncoupled(
++            N=self.N,
++            emission=self.emission,
++            dephasing=self.dephasing,
++            pumping=self.pumping,
++            collective_emission=ce,
++            collective_dephasing=cd,
++            collective_pumping=cp,
++        )
++        return c_ops_list
++
++    def coefficient_matrix(self):
++        """Build coefficient matrix for ODE for a diagonal problem.
++
++        Returns
++        -------
++        M: ndarray
++            The matrix M of the coefficients for the ODE dp/dt = Mp.
++            p is the vector of the diagonal matrix elements
++            of the density matrix rho in the Dicke basis.
++        """
++        diagonal_system = Pim(
++            N=self.N,
++            emission=self.emission,
++            dephasing=self.dephasing,
++            pumping=self.pumping,
++            collective_emission=self.collective_emission,
++            collective_dephasing=self.collective_dephasing,
++            collective_pumping=self.collective_pumping,
++        )
++        coef_matrix = diagonal_system.coefficient_matrix()
++        return coef_matrix
++
++
++# Utility functions for properties of the Dicke space
++def energy_degeneracy(N, m):
++    """Calculate the number of Dicke states with same energy.
++
++    The use of the `Decimals` class allows to explore N > 1000,
++    unlike the built-in function `scipy.special.binom`
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    m: float
++        Total spin z-axis projection eigenvalue.
++        This is proportional to the total energy.
++
++    Returns
++    -------
++    degeneracy: int
++        The energy degeneracy
++    """
++    numerator = Decimal(factorial(N))
++    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
++    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
++    degeneracy = numerator / (d1 * d2)
++    return int(degeneracy)
++
++
++def state_degeneracy(N, j):
++    r"""Calculate the degeneracy of the Dicke state.
++
++    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
++    representations :math:`\lvert j, m, \alpha\rangle`.
++
++    Uses Decimals to calculate higher numerator and denominators numbers.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    j: float
++        Total spin eigenvalue (cooperativity).
++
++    Returns
++    -------
++    degeneracy: int
++        The state degeneracy.
++    """
++    if j < 0:
++        raise ValueError("j value should be >= 0")
++    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
++    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
++    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
++    degeneracy = numerator / (denominator_1 * denominator_2)
++    degeneracy = int(np.round(float(degeneracy)))
++    return degeneracy
++
++
++def m_degeneracy(N, m):
++    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
++    same energy.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    m: float
++        Total spin z-axis projection eigenvalue (proportional to the total
++        energy).
++
++    Returns
++    -------
++    degeneracy: int
++        The m-degeneracy.
++    """
++    jvals = j_vals(N)
++    maxj = np.max(jvals)
++    if m < -maxj:
++        e = "m value is incorrect for this N."
++        e += " Minimum m value can be {}".format(-maxj)
++        raise ValueError(e)
++    degeneracy = N / 2 + 1 - abs(m)
++    return int(degeneracy)
++
++
++def ap(j, m):
++    r"""
++    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
++
++    The action of ap is given by:
++    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
++
++    Parameters
++    ----------
++    j, m: float
++        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
++
++    Returns
++    -------
++    a_plus: float
++        The value of :math:`a_{+}`.
++    """
++    a_plus = np.sqrt((j - m) * (j + m + 1))
++    return a_plus
++
++
++def am(j, m):
++    r"""Calculate the operator ``am`` used later.
++
++    The action of ``ap`` is given by:
++    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
++
++    Parameters
++    ----------
++    j: float
++        The value for j.
++
++    m: float
++        The value for m.
++
++    Returns
++    -------
++    a_minus: float
++        The value of :math:`a_{-}`.
++    """
++    a_minus = np.sqrt((j + m) * (j - m + 1))
++    return a_minus
++
++
++def spin_algebra(N, op=None):
++    """Create the list [sx, sy, sz] with the spin operators.
++
++    The operators are constructed for a collection of N two-level systems
++    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
++    objects (spin matrices), as it cointains the list of the SU(2) Pauli
++    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
++    is placed in a :math:`2^N`-dimensional Hilbert space.
++
++    Notes
++    -----
++    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    spin_operators: list or :class: qutip.Qobj
++        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
++        requested operator.
++    """
++    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
++    N = int(N)
++    sx = [0 for i in range(N)]
++    sy = [0 for i in range(N)]
++    sz = [0 for i in range(N)]
++    sp = [0 for i in range(N)]
++    sm = [0 for i in range(N)]
++
++    sx[0] = 0.5 * sigmax()
++    sy[0] = 0.5 * sigmay()
++    sz[0] = 0.5 * sigmaz()
++    sp[0] = sigmap()
++    sm[0] = sigmam()
++
++    # 2. Place operators in total Hilbert space
++    for k in range(N - 1):
++        sx[0] = tensor(sx[0], identity(2))
++        sy[0] = tensor(sy[0], identity(2))
++        sz[0] = tensor(sz[0], identity(2))
++        sp[0] = tensor(sp[0], identity(2))
++        sm[0] = tensor(sm[0], identity(2))
++
++    # 3. Cyclic sequence to create all N operators
++    a = [i for i in range(N)]
++    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
++
++    # 4. Create N operators
++    for i in range(1, N):
++        sx[i] = sx[0].permute(b[i])
++        sy[i] = sy[0].permute(b[i])
++        sz[i] = sz[0].permute(b[i])
++        sp[i] = sp[0].permute(b[i])
++        sm[i] = sm[0].permute(b[i])
++
++    spin_operators = [sx, sy, sz]
++
++    if not op:
++        return spin_operators
++    elif op == "x":
++        return sx
++    elif op == "y":
++        return sy
++    elif op == "z":
++        return sz
++    elif op == "+":
++        return sp
++    elif op == "-":
++        return sm
++    else:
++        raise TypeError("Invalid type")
++
++
++def _jspin_uncoupled(N, op=None):
++    """Construct the the collective spin algebra in the uncoupled basis.
++
++    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
++    two-level system (TLS). Each collective operator is placed in a
++    Hilbert space of dimension 2^N.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    op: str
++        The operator to return 'x','y','z','+','-'.
++        If no operator given, then output is the list of operators
++        for ['x','y','z',].
++
++    Returns
++    -------
++    collective_operators: list or :class: qutip.Qobj
++        A list of `qutip.Qobj` representing all the operators in
++        uncoupled" basis or a single operator requested.
++    """
++    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
++    N = int(N)
++
++    sx, sy, sz = spin_algebra(N)
++    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
++
++    jx = sum(sx)
++    jy = sum(sy)
++    jz = sum(sz)
++    jp = sum(sp)
++    jm = sum(sm)
++
++    collective_operators = [jx, jy, jz]
++
++    if not op:
++        return collective_operators
++    elif op == "x":
++        return jx
++    elif op == "y":
++        return jy
++    elif op == "z":
++        return jz
++    elif op == "+":
++        return jp
++    elif op == "-":
++        return jm
++    else:
++        raise TypeError("Invalid type")
++
++
++def jspin(N, op=None, basis="dicke"):
++    r"""
++    Calculate the list of collective operators of the total algebra.
++
++    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
++    default. Otherwise with "uncoupled" the operators are in a
++    :math:`2^N` space.
++
++    Parameters
++    ----------
++    N: int
++        Number of two-level systems.
++
++    op: str
++        The operator to return 'x','y','z','+','-'.
++        If no operator given, then output is the list of operators
++        for ['x','y','z'].
++
++    basis: str
++        The basis of the operators - "dicke" or "uncoupled"
++        default: "dicke".
++
++    Returns
++    -------
++    j_alg: list or :class: qutip.Qobj
++        A list of `qutip.Qobj` representing all the operators in
++        the "dicke" or "uncoupled" basis or a single operator requested.
++    """
++    if basis == "uncoupled":
++        return _jspin_uncoupled(N, op)
++
++    nds = num_dicke_states(N)
++    num_ladders = num_dicke_ladders(N)
++    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
++    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
++    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
++    s = 0
++
++    for k in range(0, num_ladders):
++        j = 0.5 * N - k
++        mmax = int(2 * j + 1)
++        for i in range(0, mmax):
++            m = j - i
++            jz_operator[s, s] = m
++            if (s + 1) in range(0, nds):
++                jp_operator[s, s + 1] = ap(j, m - 1)
++            if (s - 1) in range(0, nds):
++                jm_operator[s, s - 1] = am(j, m + 1)
++            s = s + 1
++
++    jx_operator = 1 / 2 * (jp_operator + jm_operator)
++    jy_operator = 1j / 2 * (jm_operator - jp_operator)
++    jx = Qobj(jx_operator)
++    jy = Qobj(jy_operator)
++    jz = Qobj(jz_operator)
++    jp = Qobj(jp_operator)
++    jm = Qobj(jm_operator)
++
++    if not op:
++        return [jx, jy, jz]
++    if op == "+":
++        return jp
++    elif op == "-":
++        return jm
++    elif op == "x":
++        return jx
++    elif op == "y":
++        return jy
++    elif op == "z":
++        return jz
++    else:
++        raise TypeError("Invalid type")
++
++
++def collapse_uncoupled(
++    N,
++    emission=0.0,
++    dephasing=0.0,
++    pumping=0.0,
++    collective_emission=0.0,
++    collective_dephasing=0.0,
++    collective_pumping=0.0,
++):
++    """
++    Create the collapse operators (c_ops) of the Lindbladian in the
++    uncoupled basis
++
++    These operators are in the uncoupled basis of the two-level
++    system (TLS) SU(2) Pauli matrices.
++
++    Notes
++    -----
++    The collapse operator list can be given to `qutip.mesolve`.
++    Notice that the operators are placed in a Hilbert space of
++    dimension :math:`2^N`. Thus the method is suitable only for
++    small N (of the order of 10).
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++
++    Returns
++    -------
++    c_ops: list
++        The list of collapse operators as `qutip.Qobj` for the system.
++    """
++    N = int(N)
++
++    if N > 10:
++        msg = "N > 10. dim(H) = 2^N. "
++        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
++        msg += "dimension and exploit permutational symmetry."
++        raise Warning(msg)
++
++    [sx, sy, sz] = spin_algebra(N)
++    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
++    [jx, jy, jz] = jspin(N, basis="uncoupled")
++    jp, jm = (
++        jspin(N, "+", basis="uncoupled"),
++        jspin(N, "-", basis="uncoupled"),
++    )
++
++    c_ops = []
++
++    if emission != 0:
++        for i in range(0, N):
++            c_ops.append(np.sqrt(emission) * sm[i])
++
++    if dephasing != 0:
++        for i in range(0, N):
++            c_ops.append(np.sqrt(dephasing) * sz[i])
++
++    if pumping != 0:
++        for i in range(0, N):
++            c_ops.append(np.sqrt(pumping) * sp[i])
++
++    if collective_emission != 0:
++        c_ops.append(np.sqrt(collective_emission) * jm)
++
++    if collective_dephasing != 0:
++        c_ops.append(np.sqrt(collective_dephasing) * jz)
++
++    if collective_pumping != 0:
++        c_ops.append(np.sqrt(collective_pumping) * jp)
++
++    return c_ops
++
++
++# State definitions in the Dicke basis with an option for basis transformation
++def dicke_basis(N, jmm1=None):
++    r"""
++    Initialize the density matrix of a Dicke state for several (j, m, m1).
++
++    This function can be used to build arbitrary states in the Dicke basis
++    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
++    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
++    index of the density matrix to the :math:`\lvert j, m\rangle` values is
++    given by the cythonized function `jmm1_dictionary`. A density matrix is
++    created from the given dictionary of coefficients for each (j, m, m1).
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    jmm1: dict
++        A dictionary of {(j, m, m1): p} that gives a density p for the
++        (j, m, m1) matrix element.
++
++    Returns
++    -------
++    rho: :class: qutip.Qobj
++        The density matrix in the Dicke basis.
++    """
++    if jmm1 is None:
++        msg = "Please specify the jmm1 values as a dictionary"
++        msg += "or use the `excited(N)` function to create an"
++        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
++        raise AttributeError(msg)
++
++    nds = _num_dicke_states(N)
++    rho = np.zeros((nds, nds))
++    jmm1_dict = jmm1_dictionary(N)[1]
++    for key in jmm1:
++        i, k = jmm1_dict[key]
++        rho[i, k] = jmm1[key]
++    return Qobj(rho)
++
++
++def dicke(N, j, m):
++    r"""
++    Generate a Dicke state as a pure density matrix in the Dicke basis.
++
++    For instance, the superradiant state given by
++    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
++    and the state is represented as a density matrix of size (nds, nds) or
++    (4, 4), with the (1, 1) element set to 1.
++
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    j: float
++        The eigenvalue j of the Dicke state (j, m).
++
++    m: float
++        The eigenvalue m of the Dicke state (j, m).
++
++    Returns
++    -------
++    rho: :class: qutip.Qobj
++        The density matrix.
++    """
++    nds = num_dicke_states(N)
++    rho = np.zeros((nds, nds))
++
++    jmm1_dict = jmm1_dictionary(N)[1]
++
++    i, k = jmm1_dict[(j, m, m)]
++    rho[i, k] = 1.0
++    return Qobj(rho)
++
++
++# Uncoupled states in the full Hilbert space. These are returned with the
++# choice of the keyword argument `basis="uncoupled"` in the state functions.
++def _uncoupled_excited(N):
++    """
++    Generate the density matrix of the excited Dicke state in the full
++    :math:`2^N` dimensional Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    psi0: :class: qutip.Qobj
++        The density matrix for the excited state in the uncoupled basis.
++    """
++    N = int(N)
++    jz = jspin(N, "z", basis="uncoupled")
++    en, vn = jz.eigenstates()
++    psi0 = vn[2 ** N - 1]
++    return ket2dm(psi0)
++
++
++def _uncoupled_superradiant(N):
++    """
++    Generate the density matrix of a superradiant state in the full
++    :math:`2^N`-dimensional Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    psi0: :class: qutip.Qobj
++        The density matrix for the superradiant state in the full Hilbert
++        space.
++    """
++    N = int(N)
++    jz = jspin(N, "z", basis="uncoupled")
++    en, vn = jz.eigenstates()
++    psi0 = vn[2 ** N - (N + 1)]
++    return ket2dm(psi0)
++
++
++def _uncoupled_ground(N):
++    """
++    Generate the density matrix of the ground state in the full\
++    :math:`2^N`-dimensional Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    psi0: :class: qutip.Qobj
++        The density matrix for the ground state in the full Hilbert space.
++    """
++    N = int(N)
++    jz = jspin(N, "z", basis="uncoupled")
++    en, vn = jz.eigenstates()
++    psi0 = vn[0]
++    return ket2dm(psi0)
++
++
++def _uncoupled_ghz(N):
++    """
++    Generate the density matrix of the GHZ state in the full 2^N
++    dimensional Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    ghz: :class: qutip.Qobj
++        The density matrix for the GHZ state in the full Hilbert space.
++    """
++    N = int(N)
++    rho = np.zeros((2 ** N, 2 ** N))
++    rho[0, 0] = 1 / 2
++    rho[2 ** N - 1, 0] = 1 / 2
++    rho[0, 2 ** N - 1] = 1 / 2
++    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
++    spin_dim = [2 for i in range(0, N)]
++    spins_dims = list((spin_dim, spin_dim))
++    rho = Qobj(rho, dims=spins_dims)
++    return rho
++
++
++def _uncoupled_css(N, a, b):
++    r"""
++    Generate the density matrix of the CSS state in the full 2^N
++    dimensional Hilbert space.
++
++    The CSS states are non-entangled states given by
++    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    a: complex
++        The coefficient of the :math:`\lvert1_i\rangle` state.
++
++    b: complex
++        The coefficient of the :math:`\lvert0_i\rangle` state.
++
++    Returns
++    -------
++    css: :class: qutip.Qobj
++        The density matrix for the CSS state in the full Hilbert space.
++    """
++    N = int(N)
++    # 1. Define i_th factorized density matrix in the uncoupled basis
++    rho_i = np.zeros((2, 2), dtype=complex)
++    rho_i[0, 0] = a * np.conj(a)
++    rho_i[1, 1] = b * np.conj(b)
++    rho_i[0, 1] = a * np.conj(b)
++    rho_i[1, 0] = b * np.conj(a)
++    rho_i = Qobj(rho_i)
++    rho = [0 for i in range(N)]
++    rho[0] = rho_i
++    # 2. Place single-two-level-system density matrices in total Hilbert space
++    for k in range(N - 1):
++        rho[0] = tensor(rho[0], identity(2))
++    # 3. Cyclic sequence to create all N factorized density matrices
++    # |CSS>_i<CSS|_i
++    a = [i for i in range(N)]
++    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
++    # 4. Create all other N-1 factorized density matrices
++    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
++    for i in range(1, N):
++        rho[i] = rho[0].permute(b[i])
++    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
++    rho_tot = identity_i
++    for i in range(0, N):
++        rho_tot = rho_tot * rho[i]
++    return rho_tot
++
++
++def excited(N, basis="dicke"):
++    """
++    Generate the density matrix for the excited state.
++
++    This state is given by (N/2, N/2) in the default Dicke basis. If the
++    argument `basis` is "uncoupled" then it generates the state in a
++    2**N dim Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    basis: str
++        The basis to use. Either "dicke" or "uncoupled".
++
++    Returns
++    -------
++    state: :class: qutip.Qobj
++        The excited state density matrix in the requested basis.
++    """
++    if basis == "uncoupled":
++        state = _uncoupled_excited(N)
++        return state
++
++    jmm1 = {(N / 2, N / 2, N / 2): 1}
++    return dicke_basis(N, jmm1)
++
++
++def superradiant(N, basis="dicke"):
++    """
++    Generate the density matrix of the superradiant state.
++
++    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
++    If the argument `basis` is "uncoupled" then it generates the state
++    in a 2**N dim Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    basis: str
++        The basis to use. Either "dicke" or "uncoupled".
++
++    Returns
++    -------
++    state: :class: qutip.Qobj
++        The superradiant state density matrix in the requested basis.
++    """
++    if basis == "uncoupled":
++        state = _uncoupled_superradiant(N)
++        return state
++
++    if N % 2 == 0:
++        jmm1 = {(N / 2, 0, 0): 1.0}
++        return dicke_basis(N, jmm1)
++    else:
++        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
++    return dicke_basis(N, jmm1)
++
++
++def css(
++    N,
++    x=1 / np.sqrt(2),
++    y=1 / np.sqrt(2),
++    basis="dicke",
++    coordinates="cartesian",
++):
++    r"""
++    Generate the density matrix of the Coherent Spin State (CSS).
++
++    It can be defined as,
++    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
++    with :math:`a = sin(\frac{\theta}{2})`,
++    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
++    The default basis is that of Dicke space
++    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
++    The default state is the symmetric CSS,
++    :math:`\lvert CSS\rangle = \lvert+\rangle`.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    x, y: float
++        The coefficients of the CSS state.
++
++    basis: str
++        The basis to use. Either "dicke" or "uncoupled".
++
++    coordinates: str
++        Either "cartesian" or "polar". If polar then the coefficients
++        are constructed as sin(x/2), cos(x/2)e^(iy).
++
++    Returns
++    -------
++    rho: :class: qutip.Qobj
++        The CSS state density matrix.
++    """
++    if coordinates == "polar":
++        a = np.cos(0.5 * x) * np.exp(1j * y)
++        b = np.sin(0.5 * x)
++    else:
++        a = x
++        b = y
++    if basis == "uncoupled":
++        return _uncoupled_css(N, a, b)
++    nds = num_dicke_states(N)
++    num_ladders = num_dicke_ladders(N)
++    rho = dok_matrix((nds, nds), dtype=np.complex128)
++
++    # loop in the allowed matrix elements
++    jmm1_dict = jmm1_dictionary(N)[1]
++
++    j = 0.5 * N
++    mmax = int(2 * j + 1)
++    for i in range(0, mmax):
++        m = j - i
++        psi_m = (
++            np.sqrt(float(energy_degeneracy(N, m)))
++            * a ** (N * 0.5 + m)
++            * b ** (N * 0.5 - m)
++        )
++        for i1 in range(0, mmax):
++            m1 = j - i1
++            row_column = jmm1_dict[(j, m, m1)]
++            psi_m1 = (
++                np.sqrt(float(energy_degeneracy(N, m1)))
++                * np.conj(a) ** (N * 0.5 + m1)
++                * np.conj(b) ** (N * 0.5 - m1)
++            )
++            rho[row_column] = psi_m * psi_m1
++    return Qobj(rho)
++
++
++def ghz(N, basis="dicke"):
++    """
++    Generate the density matrix of the GHZ state.
++
++    If the argument `basis` is "uncoupled" then it generates the state
++    in a :math:`2^N`-dimensional Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    basis: str
++        The basis to use. Either "dicke" or "uncoupled".
++
++    Returns
++    -------
++    state: :class: qutip.Qobj
++        The GHZ state density matrix in the requested basis.
++    """
++    if basis == "uncoupled":
++        return _uncoupled_ghz(N)
++    nds = _num_dicke_states(N)
++    rho = dok_matrix((nds, nds), dtype=np.complex128)
++    rho[0, 0] = 1 / 2
++    rho[N, N] = 1 / 2
++    rho[N, 0] = 1 / 2
++    rho[0, N] = 1 / 2
++    return Qobj(rho)
++
++
++def ground(N, basis="dicke"):
++    """
++    Generate the density matrix of the ground state.
++
++    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
++    `basis` is "uncoupled" then it generates the state in a
++    :math:`2^N`-dimensional Hilbert space.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    basis: str
++        The basis to use. Either "dicke" or "uncoupled"
++
++    Returns
++    -------
++    state: :class: qutip.Qobj
++        The ground state density matrix in the requested basis.
++    """
++    if basis == "uncoupled":
++        state = _uncoupled_ground(N)
++        return state
++    nds = _num_dicke_states(N)
++    rho = dok_matrix((nds, nds), dtype=np.complex128)
++    rho[N, N] = 1
++    return Qobj(rho)
++
++
++def identity_uncoupled(N):
++    """
++    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
++
++    The identity matrix is formed from the tensor product of N TLSs.
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    Returns
++    -------
++    identity: :class: qutip.Qobj
++        The identity matrix.
++    """
++    N = int(N)
++    rho = np.zeros((2 ** N, 2 ** N))
++    for i in range(0, 2 ** N):
++        rho[i, i] = 1
++    spin_dim = [2 for i in range(0, N)]
++    spins_dims = list((spin_dim, spin_dim))
++    identity = Qobj(rho, dims=spins_dims)
++    return identity
++
++
++def block_matrix(N, elements="ones"):
++    """Construct the block-diagonal matrix for the Dicke basis.
++
++    Parameters
++    ----------
++    N : int
++        Number of two-level systems.
++    elements : str {'ones' (default),'degeneracy'}
++
++    Returns
++    -------
++    block_matr : ndarray
++        A 2D block-diagonal matrix with dimension (nds,nds),
++        where nds is the number of Dicke states for N two-level
++        systems. Filled with ones or the value of degeneracy
++        at each matrix element.
++    """
++    # create a list with the sizes of the blocks, in order
++    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
++    blocks_list = [
++        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
++        for i in range(blocks_dimensions)
++    ]
++    blocks_list = np.flip(blocks_list, 0)
++    # create a list with each block matrix as element
++    square_blocks = []
++    k = 0
++    for i in blocks_list:
++        if elements == "ones":
++            square_blocks.append(np.ones((i, i)))
++        elif elements == "degeneracy":
++            j = N / 2 - k
++            dj = state_degeneracy(N, j)
++            square_blocks.append(dj * np.ones((i, i)))
++        k = k + 1
++    return block_diag(square_blocks)
++
++
++# ============================================================================
++# Adding a faster version to make a Permutational Invariant matrix
++# ============================================================================
++def tau_column(tau, k, j):
++    """
++    Determine the column index for the non-zero elements of the matrix for a
++    particular row `k` and the value of `j` from the Dicke space.
++
++    Parameters
++    ----------
++    tau: str
++        The tau function to check for this `k` and `j`.
++
++    k: int
++        The row of the matrix M for which the non zero elements have
++        to be calculated.
++
++    j: float
++        The value of `j` for this row.
++    """
++    # In the notes, we indexed from k = 1, here we do it from k = 0
++    k = k + 1
++    mapping = {
++        "tau3": k - (2 * j + 3),
++        "tau2": k - 1,
++        "tau4": k + (2 * j - 1),
++        "tau5": k - (2 * j + 2),
++        "tau1": k,
++        "tau6": k + (2 * j),
++        "tau7": k - (2 * j + 1),
++        "tau8": k + 1,
++        "tau9": k + (2 * j + 1),
++    }
++    # we need to decrement k again as indexing is from 0
++    return int(mapping[tau] - 1)
++
++
++class Pim(object):
++    """
++    The Permutation Invariant Matrix class.
++
++    Initialize the class with the parameters for generating a Permutation
++    Invariant matrix which evolves a given diagonal initial state `p` as:
++
++                                dp/dt = Mp
++
++    Parameters
++    ----------
++    N: int
++        The number of two-level systems.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++
++    Attributes
++    ----------
++    N: int
++        The number of two-level systems.
++
++    emission: float
++        Incoherent emission coefficient (also nonradiative emission).
++        default: 0.0
++
++    dephasing: float
++        Local dephasing coefficient.
++        default: 0.0
++
++    pumping: float
++        Incoherent pumping coefficient.
++        default: 0.0
++
++    collective_emission: float
++        Collective (superradiant) emmission coefficient.
++        default: 0.0
++
++    collective_dephasing: float
++        Collective dephasing coefficient.
++        default: 0.0
++
++    collective_pumping: float
++        Collective pumping coefficient.
++        default: 0.0
++
++    M: dict
++        A nested dictionary of the structure {row: {col: val}} which holds
++        non zero elements of the matrix M
++    """
++
++    def __init__(
++        self,
++        N,
++        emission=0.0,
++        dephasing=0,
++        pumping=0,
++        collective_emission=0,
++        collective_pumping=0,
++        collective_dephasing=0,
++    ):
++        self.N = N
++        self.emission = emission
++        self.dephasing = dephasing
++        self.pumping = pumping
++        self.collective_pumping = collective_pumping
++        self.collective_dephasing = collective_dephasing
++        self.collective_emission = collective_emission
++        self.M = {}
++
++    def isdicke(self, dicke_row, dicke_col):
++        """
++        Check if an element in a matrix is a valid element in the Dicke space.
++        Dicke row: j value index. Dicke column: m value index.
++        The function returns True if the element exists in the Dicke space and
++        False otherwise.
++
++        Parameters
++        ----------
++        dicke_row, dicke_col : int
++            Index of the element in Dicke space which needs to be checked
++        """
++        rows = self.N + 1
++        cols = 0
++
++        if (self.N % 2) == 0:
++            cols = int(self.N / 2 + 1)
++        else:
++            cols = int(self.N / 2 + 1 / 2)
++        if (dicke_row > rows) or (dicke_row < 0):
++            return False
++        if (dicke_col > cols) or (dicke_col < 0):
++            return False
++        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
++            return False
++        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
++            return False
++        else:
++            return True
++
++    def tau_valid(self, dicke_row, dicke_col):
++        """
++        Find the Tau functions which are valid for this value of (dicke_row,
++        dicke_col) given the number of TLS. This calculates the valid tau
++        values and reurns a dictionary specifying the tau function name and
++        the value.
++
++        Parameters
++        ----------
++        dicke_row, dicke_col : int
++            Index of the element in Dicke space which needs to be checked.
++
++        Returns
++        -------
++        taus: dict
++            A dictionary of key, val as {tau: value} consisting of the valid
++            taus for this row and column of the Dicke space element.
++        """
++        tau_functions = [
++            self.tau3,
++            self.tau2,
++            self.tau4,
++            self.tau5,
++            self.tau1,
++            self.tau6,
++            self.tau7,
++            self.tau8,
++            self.tau9,
++        ]
++        N = self.N
++        if self.isdicke(dicke_row, dicke_col) is False:
++            return False
++        # The 3x3 sub matrix surrounding the Dicke space element to
++        # run the tau functions
++        indices = [
++            (dicke_row + x, dicke_col + y)
++            for x in range(-1, 2)
++            for y in range(-1, 2)
++        ]
++        taus = {}
++        for idx, tau in zip(indices, tau_functions):
++            if self.isdicke(idx[0], idx[1]):
++                j, m = self.calculate_j_m(idx[0], idx[1])
++                taus[tau.__name__] = tau(j, m)
++        return taus
++
++    def calculate_j_m(self, dicke_row, dicke_col):
++        """
++        Get the value of j and m for the particular Dicke space element.
++
++        Parameters
++        ----------
++        dicke_row, dicke_col: int
++            The row and column from the Dicke space matrix
++
++        Returns
++        -------
++        j, m: float
++            The j and m values.
++        """
++        N = self.N
++        j = N / 2 - dicke_col
++        m = N / 2 - dicke_row
++        return (j, m)
++
++    def calculate_k(self, dicke_row, dicke_col):
++        """
++        Get k value from the current row and column element in the Dicke space.
++
++        Parameters
++        ----------
++        dicke_row, dicke_col: int
++            The row and column from the Dicke space matrix.
++        Returns
++        -------
++        k: int
++            The row index for the matrix M for given Dicke space
++            element.
++        """
++        N = self.N
++        if dicke_row == 0:
++            k = dicke_col
++        else:
++            k = int(
++                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
++                + (dicke_row - (dicke_col))
++            )
++        return k
++
++    def coefficient_matrix(self):
++        """
++        Generate the matrix M governing the dynamics for diagonal cases.
++
++        If the initial density matrix and the Hamiltonian is diagonal, the
++        evolution of the system is given by the simple ODE: dp/dt = Mp.
++        """
++        N = self.N
++        nds = num_dicke_states(N)
++        rows = self.N + 1
++        cols = 0
++
++        sparse_M = lil_matrix((nds, nds), dtype=float)
++        if (self.N % 2) == 0:
++            cols = int(self.N / 2 + 1)
++        else:
++            cols = int(self.N / 2 + 1 / 2)
++        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
++            if self.isdicke(dicke_row, dicke_col):
++                k = int(self.calculate_k(dicke_row, dicke_col))
++                row = {}
++                taus = self.tau_valid(dicke_row, dicke_col)
++                for tau in taus:
++                    j, m = self.calculate_j_m(dicke_row, dicke_col)
++                    current_col = tau_column(tau, k, j)
++                    sparse_M[k, int(current_col)] = taus[tau]
++        return sparse_M.tocsr()
++
++    def solve(self, rho0, tlist, options=None):
++        """
++        Solve the ODE for the evolution of diagonal states and Hamiltonians.
++        """
++        if options is None:
++            options = SolverOptions()
++        output = Result()
++        output.solver = "pisolve"
++        output.times = tlist
++        output.states = []
++        output.states.append(Qobj(rho0))
++        rhs_generate = lambda y, tt, M: M.dot(y)
++        rho0_flat = np.diag(np.real(rho0.full()))
++        L = self.coefficient_matrix()
++        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
++        for r in rho_t[1:]:
++            diag = np.diag(r)
++            output.states.append(Qobj(diag))
++        return output
++
++    def tau1(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j, m, m).
++        """
++        yS = self.collective_emission
++        yL = self.emission
++        yD = self.dephasing
++        yP = self.pumping
++        yCP = self.collective_pumping
++        N = float(self.N)
++        spontaneous = yS * (1 + j - m) * (j + m)
++        losses = yL * (N / 2 + m)
++        pump = yP * (N / 2 - m)
++        collective_pump = yCP * (1 + j + m) * (j - m)
++        if j == 0:
++            dephase = yD * N / 4
++        else:
++            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
++        t1 = spontaneous + losses + pump + dephase + collective_pump
++        return -t1
++
++    def tau2(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j, m+1, m+1).
++        """
++        yS = self.collective_emission
++        yL = self.emission
++        N = float(self.N)
++        spontaneous = yS * (1 + j - m) * (j + m)
++        losses = yL * (
++            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
++        )
++        t2 = spontaneous + losses
++        return t2
++
++    def tau3(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
++        """
++        yL = self.emission
++        N = float(self.N)
++        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
++        den = 2 * j * (2 * j + 1)
++        t3 = yL * (num / den)
++        return t3
++
++    def tau4(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
++        """
++        yL = self.emission
++        N = float(self.N)
++        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
++        den = 2 * (j + 1) * (2 * j + 1)
++        t4 = yL * (num / den)
++        return t4
++
++    def tau5(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j+1, m, m).
++        """
++        yD = self.dephasing
++        N = float(self.N)
++        num = (j - m) * (j + m) * (j + 1 + N / 2)
++        den = 2 * j * (2 * j + 1)
++        t5 = yD * (num / den)
++        return t5
++
++    def tau6(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j-1, m, m).
++        """
++        yD = self.dephasing
++        N = float(self.N)
++        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
++        den = 2 * (j + 1) * (2 * j + 1)
++        t6 = yD * (num / den)
++        return t6
++
++    def tau7(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
++        """
++        yP = self.pumping
++        N = float(self.N)
++        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
++        den = 2 * j * (2 * j + 1)
++        t7 = yP * (float(num) / den)
++        return t7
++
++    def tau8(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j, m-1, m-1).
++        """
++        yP = self.pumping
++        yCP = self.collective_pumping
++        N = float(self.N)
++
++        num = (1 + N / 2) * (j - m) * (j + m + 1)
++        den = 2 * j * (j + 1)
++        pump = yP * (float(num) / den)
++        collective_pump = yCP * (j - m) * (j + m + 1)
++        t8 = pump + collective_pump
++        return t8
++
++    def tau9(self, j, m):
++        """
++        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
++        """
++        yP = self.pumping
++        N = float(self.N)
++        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
++        den = 2 * (j + 1) * (2 * j + 1)
++        t9 = yP * (float(num) / den)
++        return t9
+diff --git a/qutip/solve/rcsolve.py b/qutip/solve/rcsolve.py
+index b357bc6e..7352b978 100644
+--- a/qutip/solve/rcsolve.py
++++ b/qutip/solve/rcsolve.py
+@@ -1,127 +1,127 @@
+-"""
+-This module provides exact solvers for a system-bath setup using the
+-reaction coordinate method.
+-"""
+-
+-# Author: Neill Lambert, Anubhav Vardhan
+-# Contact: nwlambert@gmail.com
+-
+-__all__ = ['rcsolve']
+-
+-import warnings
+-import numpy as np
+-import scipy.sparse as sp
+-from numpy import matrix
+-from numpy import linalg
+-from .. import (
+-    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
+-    sigmaz, basis, qeye, mesolve
+-)
+-
+-
+-def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
+-            options=None):
+-    """
+-    Function to solve for an open quantum system using the
+-    reaction coordinate (RC) model.
+-
+-    Parameters
+-    ----------
+-    Hsys: Qobj
+-        The system hamiltonian.
+-    psi0: Qobj
+-        Initial state of the system.
+-    tlist: List.
+-        Time over which system evolves.
+-    e_ops: list of :class:`qutip.Qobj` / callback function single
+-        Single operator or list of operators for which to evaluate
+-        expectation values.
+-    Q: Qobj
+-        The coupling between system and bath.
+-    wc: Float
+-        Cutoff frequency.
+-    alpha: Float
+-        Coupling strength.
+-    N: Integer
+-        Number of cavity fock states.
+-    w_th: Float
+-        Temperature.
+-    sparse: Boolean
+-        Optional argument to call the sparse eigenstates solver if needed.
+-    options : dict
+-        Options for the solver.
+-
+-    Returns
+-    -------
+-    output: Result
+-        System evolution.
+-    """
+-    if options is None:
+-        options = {}
+-
+-    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
+-    deltaE = dot_energy[1] - dot_energy[0]
+-    if (w_th < deltaE/2):
+-        warnings.warn("Given w_th might not provide accurate results")
+-    gamma = deltaE / (2 * np.pi * wc)
+-    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
+-    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
+-    nb = (1 / (np.exp(wa/w_th) - 1))
+-
+-    # Reaction coordinate hamiltonian/operators
+-
+-    dimensions = Q.dims
+-    a = tensor(destroy(N), qeye(dimensions[1]))
+-    unit = tensor(qeye(N), qeye(dimensions[1]))
+-    Nmax = N * dimensions[1][0]
+-    Q_exp = tensor(qeye(N), Q)
+-    Hsys_exp = tensor(qeye(N), Hsys)
+-    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
+-
+-    na = a.dag() * a
+-    xa = a.dag() + a
+-
+-    # decoupled Hamiltonian
+-    H0 = wa * a.dag() * a + Hsys_exp
+-    # interaction
+-    H1 = (g * (a.dag() + a) * Q_exp)
+-    H = H0 + H1
+-    L = 0
+-    PsipreEta = 0
+-    PsipreX = 0
+-
+-    all_energy, all_state = H.eigenstates(sparse=sparse)
+-    Apre = spre((a + a.dag()))
+-    Apost = spost(a + a.dag())
+-    for j in range(Nmax):
+-        for k in range(Nmax):
+-            A = xa.matrix_element(all_state[j].dag(), all_state[k])
+-            delE = (all_energy[j] - all_energy[k])
+-            if abs(A) > 0.0:
+-                if abs(delE) > 0.0:
+-                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
+-                         * (np.cosh((all_energy[j] - all_energy[k]) /
+-                            (2 * w_th))
+-                         / (np.sinh((all_energy[j] - all_energy[k]) /
+-                            (2 * w_th)))) * A)
+-                    eta = (0.5 * np.pi * gamma *
+-                           (all_energy[j] - all_energy[k]) * A)
+-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
+-                    PsipreEta = PsipreEta + (eta * all_state[j]
+-                                             * all_state[k].dag())
+-                else:
+-                    X = 0.5 * np.pi * gamma * A * 2 * w_th
+-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
+-
+-    A = a + a.dag()
+-    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
+-         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
+-         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
+-         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
+-
+-    # Setup the operators and the Hamiltonian and the master equation
+-    # and solve for time steps in tlist
+-    rho0 = (tensor(thermal_dm(N, nb), psi0))
+-    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
+-
+-    return output
++"""
++This module provides exact solvers for a system-bath setup using the
++reaction coordinate method.
++"""
++
++# Author: Neill Lambert, Anubhav Vardhan
++# Contact: nwlambert@gmail.com
++
++__all__ = ['rcsolve']
++
++import warnings
++import numpy as np
++import scipy.sparse as sp
++from numpy import matrix
++from numpy import linalg
++from .. import (
++    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
++    sigmaz, basis, qeye, mesolve
++)
++
++
++def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
++            options=None):
++    """
++    Function to solve for an open quantum system using the
++    reaction coordinate (RC) model.
++
++    Parameters
++    ----------
++    Hsys: Qobj
++        The system hamiltonian.
++    psi0: Qobj
++        Initial state of the system.
++    tlist: List.
++        Time over which system evolves.
++    e_ops: list of :class:`qutip.Qobj` / callback function single
++        Single operator or list of operators for which to evaluate
++        expectation values.
++    Q: Qobj
++        The coupling between system and bath.
++    wc: Float
++        Cutoff frequency.
++    alpha: Float
++        Coupling strength.
++    N: Integer
++        Number of cavity fock states.
++    w_th: Float
++        Temperature.
++    sparse: Boolean
++        Optional argument to call the sparse eigenstates solver if needed.
++    options : dict
++        Options for the solver.
++
++    Returns
++    -------
++    output: Result
++        System evolution.
++    """
++    if options is None:
++        options = {}
++
++    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
++    deltaE = dot_energy[1] - dot_energy[0]
++    if (w_th < deltaE/2):
++        warnings.warn("Given w_th might not provide accurate results")
++    gamma = deltaE / (2 * np.pi * wc)
++    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
++    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
++    nb = (1 / (np.exp(wa/w_th) - 1))
++
++    # Reaction coordinate hamiltonian/operators
++
++    dimensions = Q.dims
++    a = tensor(destroy(N), qeye(dimensions[1]))
++    unit = tensor(qeye(N), qeye(dimensions[1]))
++    Nmax = N * dimensions[1][0]
++    Q_exp = tensor(qeye(N), Q)
++    Hsys_exp = tensor(qeye(N), Hsys)
++    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
++
++    na = a.dag() * a
++    xa = a.dag() + a
++
++    # decoupled Hamiltonian
++    H0 = wa * a.dag() * a + Hsys_exp
++    # interaction
++    H1 = (g * (a.dag() + a) * Q_exp)
++    H = H0 + H1
++    L = 0
++    PsipreEta = 0
++    PsipreX = 0
++
++    all_energy, all_state = H.eigenstates(sparse=sparse)
++    Apre = spre((a + a.dag()))
++    Apost = spost(a + a.dag())
++    for j in range(Nmax):
++        for k in range(Nmax):
++            A = xa.matrix_element(all_state[j].dag(), all_state[k])
++            delE = (all_energy[j] - all_energy[k])
++            if abs(A) > 0.0:
++                if abs(delE) > 0.0:
++                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
++                         * (np.cosh((all_energy[j] - all_energy[k]) /
++                            (2 * w_th))
++                         / (np.sinh((all_energy[j] - all_energy[k]) /
++                            (2 * w_th)))) * A)
++                    eta = (0.5 * np.pi * gamma *
++                           (all_energy[j] - all_energy[k]) * A)
++                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
++                    PsipreEta = PsipreEta + (eta * all_state[j]
++                                             * all_state[k].dag())
++                else:
++                    X = 0.5 * np.pi * gamma * A * 2 * w_th
++                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
++
++    A = a + a.dag()
++    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
++         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
++         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
++         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
++
++    # Setup the operators and the Hamiltonian and the master equation
++    # and solve for time steps in tlist
++    rho0 = (tensor(thermal_dm(N, nb), psi0))
++    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
++
++    return output
+diff --git a/qutip/solve/solver.py b/qutip/solve/solver.py
+index 08a53fb6..e466beb9 100644
+--- a/qutip/solve/solver.py
++++ b/qutip/solve/solver.py
+@@ -1,922 +1,922 @@
+-from __future__ import print_function
+-
+-__all__ = ['SolverOptions', 'ExpectOps']
+-
+-import os
+-import sys
+-import warnings
+-import datetime
+-import numpy as np
+-from collections import OrderedDict
+-from types import FunctionType, BuiltinFunctionType
+-
+-from .. import __version__, Qobj, QobjEvo
+-from .optionsclass import optionsclass
+-from ..core import data as _data
+-
+-solver_safe = {}
+-
+-
+-class SolverSystem():
+-    pass
+-
+-
+-class ExpectOps:
+-    """
+-        Contain and compute expectation values
+-    """
+-    def __init__(self, e_ops=[], super_=False):
+-        # take care of expectation values, if any
+-        self.isfunc = False
+-        self.e_ops_dict = False
+-        self.raw_e_ops = e_ops
+-        self.e_ops_qoevo = []
+-        self.e_num = 0
+-        self.e_ops_isherm = []
+-
+-        if isinstance(e_ops, (Qobj, QobjEvo)):
+-            e_ops = [e_ops]
+-        elif isinstance(e_ops, dict):
+-            self.e_ops_dict = e_ops
+-            e_ops = [e for e in e_ops.values()]
+-
+-        self.e_ops = e_ops
+-        if isinstance(e_ops, list):
+-            self.e_num = len(e_ops)
+-            self.e_ops_isherm = [e.isherm for e in e_ops]
+-            if not super_:
+-                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
+-                                            dtype=object)
+-            else:
+-                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
+-                                            dtype=object)
+-        elif callable(e_ops):
+-            self.isfunc = True
+-            self.e_num = 1
+-
+-    def init(self, tlist):
+-        self.tlist = tlist
+-        if self.isfunc:
+-            self.raw_out = []
+-        else:
+-            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
+-
+-    def check_dims(self, dims):
+-        if not self.isfunc:
+-            for op in self.e_ops_qoevo:
+-                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
+-                    raise TypeError(f"e_ops dims ({op.dims}) are not "
+-                                    f"compatible with the system's ({dims})")
+-
+-    def copy(self):
+-        out = ExpectOps.__new__(ExpectOps)
+-        out.isfunc = self.isfunc
+-        out.e_ops_dict = self.e_ops_dict
+-        out.raw_e_ops = self.raw_e_ops
+-        out.e_ops = self.e_ops
+-        out.e_num = self.e_num
+-        out.e_ops_isherm = self.e_ops_isherm
+-        out.e_ops_qoevo = self.e_ops_qoevo
+-        return out
+-
+-    def step(self, iter_, state):
+-        if self.isfunc:
+-            self.raw_out.append(self.e_ops(t, state))
+-        else:
+-            state = _data.dense.fast_from_numpy(state)
+-            t = self.tlist[iter_]
+-            for ii in range(self.e_num):
+-                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
+-                    self.raw_out[ii, iter_] = \
+-                        self.e_ops_qoevo[ii].expect_data(t, state)
+-                elif callable(self.e_ops_qoevo[ii]):
+-                    self.raw_out[ii, iter_] = \
+-                        self.e_ops_qoevo[ii](t, state)
+-
+-    def finish(self):
+-        if self.isfunc:
+-            result = self.raw_out
+-        else:
+-            result = []
+-            for ii in range(self.e_num):
+-                if self.e_ops_isherm[ii]:
+-                    result.append(np.real(self.raw_out[ii, :]))
+-                else:
+-                    result.append(self.raw_out[ii, :])
+-            if self.e_ops_dict:
+-                result = {e: result[n]
+-                          for n, e in enumerate(self.e_ops_dict.keys())}
+-        return result
+-
+-    def __eq__(self, other):
+-        if isinstance(other, ExpectOps):
+-            other = other.raw_e_ops
+-        return self.raw_e_ops == other
+-
+-    def __ne__(self, other):
+-        return not (self == other)
+-
+-    def __bool__(self):
+-        return bool(self.e_num)
+-
+-
+-@optionsclass("solver")
+-class SolverOptions:
+-    """
+-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
+-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
+-    constructor::
+-
+-        opts = SolverOptions(order=10, ...)
+-
+-    or by changing the class attributes after creation::
+-
+-        opts = SolverOptions()
+-        opts.order = 10
+-
+-    Returns options class to be used as options in evolution solvers.
+-
+-    The default can be changed by::
+-
+-        qutip.settings.solver['order'] = 10
+-
+-    Supported options:
+-
+-        atol : float {1e-8}
+-            Absolute tolerance.
+-        rtol : float {1e-6}
+-            Relative tolerance.
+-        method : str {'adams','bdf'}
+-            Integration method.
+-        order : int {12}
+-            Order of integrator (<=12 'adams', <=5 'bdf')
+-        nsteps : int {2500}
+-            Max. number of internal steps/call.
+-        first_step : float {0}
+-            Size of initial step (0 = automatic).
+-        min_step : float {0}
+-            Minimum step size (0 = automatic).
+-        max_step : float {0}
+-            Maximum step size (0 = automatic)
+-        tidy : bool {True,False}
+-            Tidyup Hamiltonian and initial state by removing small terms.
+-        average_states : bool {False}
+-            Average states values over trajectories in stochastic solvers.
+-        average_expect : bool {True}
+-            Average expectation values over trajectories for stochastic solvers.
+-        ntraj : int {500}
+-            Number of trajectories in stochastic solvers.
+-        store_final_state : bool {False, True}
+-            Whether or not to store the final state of the evolution in the
+-            result class.
+-        store_states : bool {False, True}
+-            Whether or not to store the state vectors or density matrices in the
+-            result class, even if expectation values operators are given. If no
+-            expectation are provided, then states are stored by default and this
+-            option has no effect.
+-    """
+-    options = {
+-        # Absolute tolerance (default = 1e-8)
+-        "atol": 1e-8,
+-        # Relative tolerance (default = 1e-6)
+-        "rtol": 1e-6,
+-        # Integration method (default = 'adams', for stiff 'bdf')
+-        "method": 'adams',
+-        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
+-        "order": 12,
+-        # Max. number of internal steps/call
+-        "nsteps": 1000,
+-        # Size of initial step (0 = determined by solver)
+-        "first_step": 0,
+-        # Max step size (0 = determined by solver)
+-        "max_step": 0,
+-        # Minimal step size (0 = determined by solver)
+-        "min_step": 0,
+-        # Average expectation values over trajectories (default = True)
+-        "average_expect": True,
+-        # average expectation values
+-        "average_states": False,
+-        # tidyup Hamiltonian before calculation (default = True)
+-        "tidy": True,
+-        # Number of trajectories (default = 500)
+-        "ntraj": 500,
+-        "gui": False,
+-        # store final state?
+-        "store_final_state": False,
+-        # store states even if expectation operators are given?
+-        "store_states": False,
+-        # average mcsolver density matricies assuming steady state evolution
+-        "steady_state_average": False,
+-        # Normalize output of solvers
+-        # (turned off for batch unitary propagator mode)
+-        "normalize_output": True
+-    }
+-
+-
+-@optionsclass("mcsolve", SolverOptions)
+-class McOptions:
+-    """
+-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
+-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
+-    constructor::
+-
+-        opts = SolverOptions(norm_tol=1e-3, ...)
+-
+-    or by changing the class attributes after creation::
+-
+-        opts = SolverOptions()
+-        opts.['norm_tol'] = 1e-3
+-
+-    Returns options class to be used as options in evolution solvers.
+-
+-    The default can be changed by::
+-
+-        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
+-
+-    Options
+-    -------
+-
+-    norm_tol : float {1e-4}
+-        Tolerance used when finding wavefunction norm in mcsolve.
+-    norm_t_tol : float {1e-6}
+-        Tolerance used when finding wavefunction time in mcsolve.
+-    norm_steps : int {5}
+-        Max. number of steps used to find wavefunction norm to within norm_tol
+-        in mcsolve.
+-    mc_corr_eps : float {1e-10}
+-        Arbitrarily small value for eliminating any divide-by-zero errors in
+-        correlation calculations when using mcsolve.
+-    """
+-    options = {
+-        # Tolerance for wavefunction norm (mcsolve only)
+-        "norm_tol": 1e-4,
+-        # Tolerance for collapse time precision (mcsolve only)
+-        "norm_t_tol": 1e-6,
+-        # Max. number of steps taken to find wavefunction norm to within
+-        # norm_tol (mcsolve only)
+-        "norm_steps": 5,
+-        # small value in mc solver for computing correlations
+-        "mc_corr_eps": 1e-10,
+-    }
+-
+-
+-class Result():
+-    """Class for storing simulation results from any of the dynamics solvers.
+-
+-    Attributes
+-    ----------
+-
+-    solver : str
+-        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
+-    times : list/array
+-        Times at which simulation data was collected.
+-    expect : list/array
+-        Expectation values (if requested) for simulation.
+-    states : array
+-        State of the simulation (density matrix or ket) evaluated at ``times``.
+-    num_expect : int
+-        Number of expectation value operators in simulation.
+-    num_collapse : int
+-        Number of collapse operators in simualation.
+-    ntraj : int/list
+-        Number of trajectories (for stochastic solvers). A list indicates
+-        that averaging of expectation values was done over a subset of total
+-        number of trajectories.
+-    col_times : list
+-        Times at which state collpase occurred. Only for Monte Carlo solver.
+-    col_which : list
+-        Which collapse operator was responsible for each collapse in
+-        ``col_times``. Only for Monte Carlo solver.
+-
+-    """
+-    def __init__(self):
+-        self.solver = None
+-        self.times = None
+-        self.states = []
+-        self.expect = []
+-        self.num_expect = 0
+-        self.num_collapse = 0
+-        self.ntraj = None
+-        self.seeds = None
+-        self.col_times = None
+-        self.col_which = None
+-
+-    def __str__(self):
+-        s = "Result object "
+-        if self.solver:
+-            s += "with " + self.solver + " data.\n"
+-        else:
+-            s += "missing solver information.\n"
+-        s += "-" * (len(s) - 1) + "\n"
+-        if self.states is not None and len(self.states) > 0:
+-            s += "states = True\n"
+-        elif self.expect is not None and len(self.expect) > 0:
+-            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
+-        else:
+-            s += "states = True, expect = True\n" + \
+-                "num_expect = " + str(self.num_expect) + ", "
+-        s += "num_collapse = " + str(self.num_collapse)
+-        if self.solver == 'mcsolve':
+-            s += ", ntraj = " + str(self.ntraj)
+-        return s
+-
+-    def __repr__(self):
+-        return self.__str__()
+-
+-    def __getstate__(self):
+-        # defines what happens when Qobj object gets pickled
+-        self.__dict__.update({'qutip_version': __version__[:5]})
+-        return self.__dict__
+-
+-    def __setstate__(self, state):
+-        # defines what happens when loading a pickled Qobj
+-        if 'qutip_version' in state.keys():
+-            del state['qutip_version']
+-        (self.__dict__).update(state)
+-
+-
+-# %%%%%%%%%%% remove ?
+-class SolverConfiguration():
+-    def __init__(self):
+-
+-        self.cgen_num = 0
+-
+-        self.reset()
+-
+-    def reset(self):
+-        # General stuff
+-        self.tlist = None       # evaluations times
+-        self.ntraj = None       # number / list of trajectories
+-        self.options = None     # options for solvers
+-        self.norm_tol = None    # tolerance for wavefunction norm
+-        self.norm_steps = None  # max. number of steps to take in finding
+-        # Initial state stuff
+-        self.psi0 = None        # initial state
+-        self.psi0_dims = None   # initial state dims
+-        self.psi0_shape = None  # initial state shape
+-
+-        # flags for setting time-dependence, collapse ops, and number of times
+-        # codegen has been run
+-        self.cflag = 0     # Flag signaling collapse operators
+-        self.tflag = 0     # Flag signaling time-dependent problem
+-
+-        self.soft_reset()
+-
+-    def soft_reset(self):
+-        # Hamiltonian stuff
+-        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
+-        self.h_tdterms = []  # List of td strs and funcs
+-        self.h_data = None   # List of sparse matrix data
+-        self.h_ind = None    # List of sparse matrix indices
+-        self.h_ptr = None    # List of sparse matrix ptrs
+-
+-        # Expectation operator stuff
+-        self.e_num = 0        # number of expect ops
+-        self.e_ops_data = []  # expect op data
+-        self.e_ops_ind = []   # expect op indices
+-        self.e_ops_ptr = []   # expect op indptrs
+-        self.e_ops_isherm = []  # expect op isherm
+-
+-        # Collapse operator stuff
+-        self.c_num = 0          # number of collapse ops
+-        self.c_const_inds = []  # indicies of constant collapse operators
+-        self.c_td_inds = []     # indicies of time-dependent collapse operators
+-        self.c_ops_data = []    # collapse op data
+-        self.c_ops_ind = []     # collapse op indices
+-        self.c_ops_ptr = []     # collapse op indptrs
+-        self.c_args = []        # store args for time-dependent collapse func.
+-
+-        # Norm collapse operator stuff
+-        self.n_ops_data = []  # norm collapse op data
+-        self.n_ops_ind = []   # norm collapse op indices
+-        self.n_ops_ptr = []   # norm collapse op indptrs
+-
+-        # holds executable strings for time-dependent collapse evaluation
+-        self.col_expect_code = None
+-        self.col_spmv_code = None
+-
+-        # hold stuff for function list based time dependence
+-        self.h_td_inds = []
+-        self.h_td_data = []
+-        self.h_td_ind = []
+-        self.h_td_ptr = []
+-        self.h_funcs = None
+-        self.h_func_args = None
+-        self.c_funcs = None
+-        self.c_func_args = None
+-
+-        # time-dependent (TD) function stuff
+-        self.tdfunc = None     # Placeholder for TD RHS function.
+-        self.tdname = None     # Name of td .pyx file
+-        self.colspmv = None    # Placeholder for TD col-spmv function.
+-        self.colexpect = None  # Placeholder for TD col_expect function.
+-        self.string = None     # Holds string of variables passed to td solver
+-
+-
+-def _format_time(t, tt=None, ttt=None):
+-    time_str = str(datetime.timedelta(seconds=t))
+-    if tt is not None and ttt is not None:
+-        sect_percent = 100*t/tt
+-        solve_percent = 100*t/ttt
+-        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
+-                                            sect_percent, solve_percent)
+-    elif tt is not None:
+-        sect_percent = 100*t/tt
+-        time_str += " ({:03.2f}% section)".format(sect_percent)
+-
+-    elif ttt is not None:
+-        solve_percent = 100*t/ttt
+-        time_str += " ({:03.2f}% total)".format(solve_percent)
+-
+-    return time_str
+-
+-
+-class Stats:
+-    """
+-    Statistical information on the solver performance
+-    Statistics can be grouped into sections.
+-    If no section names are given in the the contructor, then all statistics
+-    will be added to one section 'main'
+-
+-    Parameters
+-    ----------
+-    section_names : list
+-        list of keys that will be used as keys for the sections
+-        These keys will also be used as names for the sections
+-        The text in the output can be overidden by setting the header property
+-        of the section
+-        If no names are given then one section called 'main' is created
+-
+-    Attributes
+-    ----------
+-    sections : OrderedDict of _StatsSection
+-        These are the sections that are created automatically on instantiation
+-        or added using add_section
+-
+-    header : string
+-        Some text that will be used as the heading in the report
+-        By default there is None
+-
+-    total_time : float
+-        Time in seconds for the solver to complete processing
+-        Can be None, meaning that total timing percentages will be reported
+-    """
+-
+-    def __init__(self, section_names=None):
+-        self._def_section_name = 'main'
+-        self.sections = OrderedDict()
+-        self.total_time = None
+-        self.header = None
+-        if isinstance(section_names, list):
+-            c = 0
+-            for name in section_names:
+-                self.sections[name] = _StatsSection(name, self)
+-                if c == 0:
+-                    self._def_section_name = name
+-                c += 1
+-
+-        else:
+-            self.sections[self._def_section_name] = \
+-                        _StatsSection(self._def_section_name)
+-
+-    def _get_section(self, section):
+-        if section is None:
+-            return self.sections[self._def_section_name]
+-        elif isinstance(section, _StatsSection):
+-            return section
+-        else:
+-            sect = self.sections.get(section, None)
+-            if sect is None:
+-                raise ValueError("Unknown section {}".format(section))
+-            else:
+-                return sect
+-
+-    def add_section(self, name):
+-        """
+-        Add another section with the given name
+-
+-        Parameters
+-        ----------
+-        name : string
+-            will be used as key for sections dict
+-            will also be the header for the section
+-
+-        Returns
+-        -------
+-        section : :class:`_StatsSection`
+-            The new section
+-        """
+-        sect = _StatsSection(name, self)
+-        self.sections[name] = sect
+-        return sect
+-
+-    def add_count(self, key, value, section=None):
+-        """
+-        Add value to count. If key does not already exist in section then
+-        it is created with this value.
+-        If key already exists it is increased by the give value
+-        value is expected to be an integer
+-
+-        Parameters
+-        ----------
+-        key : string
+-            key for the section.counts dictionary
+-            reusing a key will result in numerical addition of value
+-
+-        value : int
+-            Initial value of the count, or added to an existing count
+-
+-        section : string or :class:`_StatsSection`
+-            Section which to add the count to.
+-            If None given, the default (first) section will be used
+-        """
+-
+-        self._get_section(section).add_count(key, value)
+-
+-    def add_timing(self, key, value, section=None):
+-        """
+-        Add value to timing. If key does not already exist in section then
+-        it is created with this value.
+-        If key already exists it is increased by the give value
+-        value is expected to be a float, and given in seconds.
+-
+-        Parameters
+-        ----------
+-        key : string
+-            key for the section.timings dictionary
+-            reusing a key will result in numerical addition of value
+-
+-        value : int
+-            Initial value of the timing, or added to an existing timing
+-
+-        section: string or `class` : _StatsSection
+-            Section which to add the timing to.
+-            If None given, the default (first) section will be used
+-        """
+-        self._get_section(section).add_timing(key, value)
+-
+-    def add_message(self, key, value, section=None, sep=";"):
+-        """
+-        Add value to message. If key does not already exist in section then
+-        it is created with this value.
+-        If key already exists the value is added to the message
+-        The value will be converted to a string
+-
+-        Parameters
+-        ----------
+-        key : string
+-            key for the section.messages dictionary
+-            reusing a key will result in concatenation of value
+-
+-        value : int
+-            Initial value of the message, or added to an existing message
+-
+-        sep : string
+-            Message will be prefixed with this string when concatenating
+-
+-        section: string or `class` : _StatsSection
+-            Section which to add the message to.
+-            If None given, the default (first) section will be used
+-        """
+-        self._get_section(section).add_message(key, value, sep=sep)
+-
+-    def set_total_time(self, value, section=None):
+-        """
+-        Sets the total time for the complete solve or for a specific section
+-        value is expected to be a float, and given in seconds
+-
+-        Parameters
+-        ----------
+-        value : float
+-            Time in seconds to complete the solver section
+-
+-        section : string or `class` : _StatsSection
+-            Section which to set the total_time for
+-            If None given, the total_time for complete solve is set
+-        """
+-        if not isinstance(value, float):
+-            try:
+-                value = float(value)
+-            except:
+-                raise TypeError("value is expected to be a float")
+-
+-        if section is None:
+-            self.total_time = value
+-        else:
+-            sect = self._get_section(section)
+-            sect.total_time = value
+-
+-    def report(self, output=sys.stdout):
+-        """
+-        Report the counts, timings and messages from the sections.
+-        Sections are reported in the order that the names were supplied
+-        in the constructor.
+-        The counts, timings and messages are reported in the order that they
+-        are added to the sections
+-        The output can be written to anything that supports a write method,
+-        e.g. a file or the console (default)
+-        The output is intended to in markdown format
+-
+-        Parameters
+-        ----------
+-        output : stream
+-            file or console stream - anything that support write - where
+-            the output will be written
+-        """
+-
+-        if not hasattr(output, 'write'):
+-            raise TypeError("output must have a write method")
+-
+-        if self.header:
+-            output.write("{}\n{}\n".format(self.header,
+-                                     ("="*len(self.header))))
+-        for name, sect in self.sections.items():
+-            sect.report(output)
+-
+-        if self.total_time is not None:
+-            output.write("\nSummary\n-------\n")
+-            output.write("{}\t solver total time\n".format(
+-                                            _format_time(self.total_time)))
+-
+-    def clear(self):
+-        """
+-        Clear counts, timings and messages from all sections
+-        """
+-        for sect in self.sections.values():
+-            sect.clear()
+-        self.total_time = None
+-
+-
+-class _StatsSection(object):
+-    """
+-    Not intended to be directly instantiated
+-    This is the type for the SolverStats.sections values
+-
+-    The method parameter descriptions are the same as for those the parent
+-    with the same method name
+-
+-    Parameters
+-    ----------
+-    name : string
+-        key for the parent sections dictionary
+-        will also be used as the header
+-
+-    parent : `class` :  SolverStats
+-        The container for all the sections
+-
+-    Attributes
+-    ----------
+-    name : string
+-        key for the parent sections dictionary
+-        will also be used as the header
+-
+-    parent : `class` :  SolverStats
+-        The container for all the sections
+-
+-    header : string
+-        Used as heading for section in report
+-
+-    counts : OrderedDict
+-        The integer type statistics for the stats section
+-
+-    timings : OrderedDict
+-        The timing type statistics for the stats section
+-        Expected to contain float values representing values in seconds
+-
+-    messages : OrderedDict
+-        Text type output to be reported
+-
+-    total_time : float
+-        Total time for processing in the section
+-        Can be None, meaning that section timing percentages will be reported
+-    """
+-    def __init__(self, name, parent):
+-        self.parent = parent
+-        self.header = str(name)
+-        self.name = name
+-        self.counts = OrderedDict()
+-        self.timings = OrderedDict()
+-        self.messages = OrderedDict()
+-        self.total_time = None
+-
+-    def add_count(self, key, value):
+-        """
+-        Add value to count. If key does not already exist in section then
+-        it is created with this value.
+-        If key already exists it is increased by the given value
+-        value is expected to be an integer
+-        """
+-        if not isinstance(value, int):
+-            try:
+-                value = int(value)
+-            except:
+-                raise TypeError("value is expected to be an integer")
+-
+-        if key in self.counts:
+-            self.counts[key] += value
+-        else:
+-            self.counts[key] = value
+-
+-    def add_timing(self, key, value):
+-        """
+-        Add value to timing. If key does not already exist in section then
+-        it is created with this value.
+-        If key already exists it is increased by the give value
+-        value is expected to be a float, and given in seconds.
+-        """
+-        if not isinstance(value, float):
+-            try:
+-                value = float(value)
+-            except:
+-                raise TypeError("value is expected to be a float")
+-
+-        if key in self.timings:
+-            self.timings[key] += value
+-        else:
+-            self.timings[key] = value
+-
+-    def add_message(self, key, value, sep=";"):
+-        """
+-        Add value to message. If key does not already exist in section then
+-        it is created with this value.
+-        If key already exists the value is added to the message
+-        The value will be converted to a string
+-        """
+-        value = str(value)
+-
+-        if key in self.messages:
+-            if sep is not None:
+-                try:
+-                    value = sep + value
+-                except:
+-                    TypeError("It is not possible to concatenate the value "
+-                              "with the given seperator")
+-            self.messages[key] += value
+-        else:
+-            self.messages[key] = value
+-
+-    def report(self, output=sys.stdout):
+-        """
+-        Report the counts, timings and messages for this section.
+-        Note the percentage of the section and solver total times will be
+-        given if the parent and or section total_time is set
+-        """
+-        if self.header:
+-            output.write("\n{}\n{}\n".format(self.header,
+-                                     ("-"*len(self.header))))
+-
+-        # TODO: Make the timings and counts ouput in a table format
+-        #       Generally make more pretty
+-
+-        # Report timings
+-        try:
+-            ttt = self.parent.total_time
+-        except:
+-            ttt = None
+-
+-        tt = self.total_time
+-
+-        output.write("### Timings:\n")
+-        for key, value in self.timings.items():
+-            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
+-            output.write(l)
+-        if tt is not None:
+-            output.write(" - {}\t{} total time\n".format(_format_time(tt),
+-                                                     self.name))
+-
+-        # Report counts
+-        output.write("### Counts:\n")
+-        for key, value in self.counts.items():
+-            l = " - {}\t{}\n".format(value, key)
+-            output.write(l)
+-
+-        # Report messages
+-        output.write("### Messages:\n")
+-        for key, value in self.messages.items():
+-            l = " - {}:\t{}\n".format(key, value)
+-            output.write(l)
+-
+-
+-    def clear(self):
+-        """
+-        Clear counts, timings and messages from this section
+-        """
+-        self.counts.clear()
+-        self.timings.clear()
+-        self.messages.clear()
+-        self.total_time = None
+-
+-
+-def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
+-    # Input is std Qobj (Hamiltonian or Liouvillian)
+-    if isinstance(H, Qobj):
+-        Hdims = H.dims
+-        Htype = H.type
+-        _structure_check(Hdims, Htype, state)
+-    # Input H is function
+-    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
+-        Hdims = H(0,args).dims
+-        Htype = H(0,args).type
+-        _structure_check(Hdims, Htype, state)
+-    # Input is td-list
+-    elif isinstance(H, list):
+-        if isinstance(H[0], Qobj):
+-            Hdims = H[0].dims
+-            Htype = H[0].type
+-        elif isinstance(H[0], list):
+-            Hdims = H[0][0].dims
+-            Htype = H[0][0].type
+-        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
+-            Hdims = H[0](0,args).dims
+-            Htype = H[0](0,args).type
+-        else:
+-            raise Exception('Invalid td-list element.')
+-        # Check all operators in list
+-        for ii in range(len(H)):
+-            if isinstance(H[ii], Qobj):
+-                _temp_dims = H[ii].dims
+-                _temp_type = H[ii].type
+-            elif isinstance(H[ii], list):
+-                _temp_dims = H[ii][0].dims
+-                _temp_type = H[ii][0].type
+-            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
+-                _temp_dims = H[ii](0,args).dims
+-                _temp_type = H[ii](0,args).type
+-            else:
+-                raise Exception('Invalid td-list element.')
+-            _structure_check(_temp_dims,_temp_type,state)
+-
+-    else:
+-        raise Exception('Invalid time-dependent format.')
+-
+-
+-    for ii in range(len(c_ops)):
+-        do_tests = True
+-        if isinstance(c_ops[ii], Qobj):
+-            _temp_state = c_ops[ii]
+-        elif isinstance(c_ops[ii], list):
+-            if isinstance(c_ops[ii][0], Qobj):
+-                _temp_state = c_ops[ii][0]
+-            elif isinstance(c_ops[ii][0], tuple):
+-                do_tests = False
+-                for kk in range(len(c_ops[ii][0])):
+-                    _temp_state = c_ops[ii][0][kk]
+-                    _structure_check(Hdims, Htype, _temp_state)
+-        else:
+-            raise Exception('Invalid td-list element.')
+-        if do_tests:
+-            _structure_check(Hdims, Htype, _temp_state)
+-
+-    if isinstance(e_ops, list):
+-        for ii in range(len(e_ops)):
+-            if isinstance(e_ops[ii], Qobj):
+-                _temp_state = e_ops[ii]
+-            elif isinstance(e_ops[ii], list):
+-                _temp_state = e_ops[ii][0]
+-            else:
+-                raise Exception('Invalid td-list element.')
+-            _structure_check(Hdims,Htype,_temp_state)
+-    elif isinstance(e_ops, FunctionType):
+-        pass
+-    else:
+-        raise Exception('Invalid e_ops specification.')
+-
+-
+-def _structure_check(Hdims, Htype, state):
+-    if state is not None:
+-        # Input state is a ket vector
+-        if state.type == 'ket':
+-            # Input is Hamiltonian
+-            if Htype == 'oper':
+-                if Hdims[1] != state.dims[0]:
+-                    raise Exception('Input operator and ket do not '
+-                                    'share same structure.')
+-            # Input is super and state is ket
+-            elif Htype == 'super':
+-                if Hdims[1][1] != state.dims[0]:
+-                    raise Exception('Input operator and ket do not '
+-                                    'share same structure.')
+-            else:
+-                raise Exception('Invalid input operator.')
+-        # Input state is a density matrix
+-        elif state.type == 'oper':
+-            # Input is Hamiltonian and state is density matrix
+-            if Htype == 'oper':
+-                if Hdims[1] != state.dims[0]:
+-                    raise Exception('Input operators do not '
+-                                    'share same structure.')
+-            # Input is super op. and state is density matrix
+-            elif Htype == 'super':
+-                if Hdims[1] != state.dims:
+-                    raise Exception('Input operators do not '
+-                                    'share same structure.')
+-
+-
+-#
+-# create a global instance of the SolverConfiguration class
+-#
+-config = SolverConfiguration()
+-
+-# for backwards compatibility
+-# Odeoptions = Options
+-# Odedata = Result
++from __future__ import print_function
++
++__all__ = ['SolverOptions', 'ExpectOps']
++
++import os
++import sys
++import warnings
++import datetime
++import numpy as np
++from collections import OrderedDict
++from types import FunctionType, BuiltinFunctionType
++
++from .. import __version__, Qobj, QobjEvo
++from .optionsclass import optionsclass
++from ..core import data as _data
++
++solver_safe = {}
++
++
++class SolverSystem():
++    pass
++
++
++class ExpectOps:
++    """
++        Contain and compute expectation values
++    """
++    def __init__(self, e_ops=[], super_=False):
++        # take care of expectation values, if any
++        self.isfunc = False
++        self.e_ops_dict = False
++        self.raw_e_ops = e_ops
++        self.e_ops_qoevo = []
++        self.e_num = 0
++        self.e_ops_isherm = []
++
++        if isinstance(e_ops, (Qobj, QobjEvo)):
++            e_ops = [e_ops]
++        elif isinstance(e_ops, dict):
++            self.e_ops_dict = e_ops
++            e_ops = [e for e in e_ops.values()]
++
++        self.e_ops = e_ops
++        if isinstance(e_ops, list):
++            self.e_num = len(e_ops)
++            self.e_ops_isherm = [e.isherm for e in e_ops]
++            if not super_:
++                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
++                                            dtype=object)
++            else:
++                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
++                                            dtype=object)
++        elif callable(e_ops):
++            self.isfunc = True
++            self.e_num = 1
++
++    def init(self, tlist):
++        self.tlist = tlist
++        if self.isfunc:
++            self.raw_out = []
++        else:
++            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
++
++    def check_dims(self, dims):
++        if not self.isfunc:
++            for op in self.e_ops_qoevo:
++                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
++                    raise TypeError(f"e_ops dims ({op.dims}) are not "
++                                    f"compatible with the system's ({dims})")
++
++    def copy(self):
++        out = ExpectOps.__new__(ExpectOps)
++        out.isfunc = self.isfunc
++        out.e_ops_dict = self.e_ops_dict
++        out.raw_e_ops = self.raw_e_ops
++        out.e_ops = self.e_ops
++        out.e_num = self.e_num
++        out.e_ops_isherm = self.e_ops_isherm
++        out.e_ops_qoevo = self.e_ops_qoevo
++        return out
++
++    def step(self, iter_, state):
++        if self.isfunc:
++            self.raw_out.append(self.e_ops(t, state))
++        else:
++            state = _data.dense.fast_from_numpy(state)
++            t = self.tlist[iter_]
++            for ii in range(self.e_num):
++                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
++                    self.raw_out[ii, iter_] = \
++                        self.e_ops_qoevo[ii].expect_data(t, state)
++                elif callable(self.e_ops_qoevo[ii]):
++                    self.raw_out[ii, iter_] = \
++                        self.e_ops_qoevo[ii](t, state)
++
++    def finish(self):
++        if self.isfunc:
++            result = self.raw_out
++        else:
++            result = []
++            for ii in range(self.e_num):
++                if self.e_ops_isherm[ii]:
++                    result.append(np.real(self.raw_out[ii, :]))
++                else:
++                    result.append(self.raw_out[ii, :])
++            if self.e_ops_dict:
++                result = {e: result[n]
++                          for n, e in enumerate(self.e_ops_dict.keys())}
++        return result
++
++    def __eq__(self, other):
++        if isinstance(other, ExpectOps):
++            other = other.raw_e_ops
++        return self.raw_e_ops == other
++
++    def __ne__(self, other):
++        return not (self == other)
++
++    def __bool__(self):
++        return bool(self.e_num)
++
++
++@optionsclass("solver")
++class SolverOptions:
++    """
++    Class of options for evolution solvers such as :func:`qutip.mesolve` and
++    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
++    constructor::
++
++        opts = SolverOptions(order=10, ...)
++
++    or by changing the class attributes after creation::
++
++        opts = SolverOptions()
++        opts.order = 10
++
++    Returns options class to be used as options in evolution solvers.
++
++    The default can be changed by::
++
++        qutip.settings.solver['order'] = 10
++
++    Supported options:
++
++        atol : float {1e-8}
++            Absolute tolerance.
++        rtol : float {1e-6}
++            Relative tolerance.
++        method : str {'adams','bdf'}
++            Integration method.
++        order : int {12}
++            Order of integrator (<=12 'adams', <=5 'bdf')
++        nsteps : int {2500}
++            Max. number of internal steps/call.
++        first_step : float {0}
++            Size of initial step (0 = automatic).
++        min_step : float {0}
++            Minimum step size (0 = automatic).
++        max_step : float {0}
++            Maximum step size (0 = automatic)
++        tidy : bool {True,False}
++            Tidyup Hamiltonian and initial state by removing small terms.
++        average_states : bool {False}
++            Average states values over trajectories in stochastic solvers.
++        average_expect : bool {True}
++            Average expectation values over trajectories for stochastic solvers.
++        ntraj : int {500}
++            Number of trajectories in stochastic solvers.
++        store_final_state : bool {False, True}
++            Whether or not to store the final state of the evolution in the
++            result class.
++        store_states : bool {False, True}
++            Whether or not to store the state vectors or density matrices in the
++            result class, even if expectation values operators are given. If no
++            expectation are provided, then states are stored by default and this
++            option has no effect.
++    """
++    options = {
++        # Absolute tolerance (default = 1e-8)
++        "atol": 1e-8,
++        # Relative tolerance (default = 1e-6)
++        "rtol": 1e-6,
++        # Integration method (default = 'adams', for stiff 'bdf')
++        "method": 'adams',
++        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
++        "order": 12,
++        # Max. number of internal steps/call
++        "nsteps": 1000,
++        # Size of initial step (0 = determined by solver)
++        "first_step": 0,
++        # Max step size (0 = determined by solver)
++        "max_step": 0,
++        # Minimal step size (0 = determined by solver)
++        "min_step": 0,
++        # Average expectation values over trajectories (default = True)
++        "average_expect": True,
++        # average expectation values
++        "average_states": False,
++        # tidyup Hamiltonian before calculation (default = True)
++        "tidy": True,
++        # Number of trajectories (default = 500)
++        "ntraj": 500,
++        "gui": False,
++        # store final state?
++        "store_final_state": False,
++        # store states even if expectation operators are given?
++        "store_states": False,
++        # average mcsolver density matricies assuming steady state evolution
++        "steady_state_average": False,
++        # Normalize output of solvers
++        # (turned off for batch unitary propagator mode)
++        "normalize_output": True
++    }
++
++
++@optionsclass("mcsolve", SolverOptions)
++class McOptions:
++    """
++    Class of options for evolution solvers such as :func:`qutip.mesolve` and
++    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
++    constructor::
++
++        opts = SolverOptions(norm_tol=1e-3, ...)
++
++    or by changing the class attributes after creation::
++
++        opts = SolverOptions()
++        opts.['norm_tol'] = 1e-3
++
++    Returns options class to be used as options in evolution solvers.
++
++    The default can be changed by::
++
++        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
++
++    Options
++    -------
++
++    norm_tol : float {1e-4}
++        Tolerance used when finding wavefunction norm in mcsolve.
++    norm_t_tol : float {1e-6}
++        Tolerance used when finding wavefunction time in mcsolve.
++    norm_steps : int {5}
++        Max. number of steps used to find wavefunction norm to within norm_tol
++        in mcsolve.
++    mc_corr_eps : float {1e-10}
++        Arbitrarily small value for eliminating any divide-by-zero errors in
++        correlation calculations when using mcsolve.
++    """
++    options = {
++        # Tolerance for wavefunction norm (mcsolve only)
++        "norm_tol": 1e-4,
++        # Tolerance for collapse time precision (mcsolve only)
++        "norm_t_tol": 1e-6,
++        # Max. number of steps taken to find wavefunction norm to within
++        # norm_tol (mcsolve only)
++        "norm_steps": 5,
++        # small value in mc solver for computing correlations
++        "mc_corr_eps": 1e-10,
++    }
++
++
++class Result():
++    """Class for storing simulation results from any of the dynamics solvers.
++
++    Attributes
++    ----------
++
++    solver : str
++        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
++    times : list/array
++        Times at which simulation data was collected.
++    expect : list/array
++        Expectation values (if requested) for simulation.
++    states : array
++        State of the simulation (density matrix or ket) evaluated at ``times``.
++    num_expect : int
++        Number of expectation value operators in simulation.
++    num_collapse : int
++        Number of collapse operators in simualation.
++    ntraj : int/list
++        Number of trajectories (for stochastic solvers). A list indicates
++        that averaging of expectation values was done over a subset of total
++        number of trajectories.
++    col_times : list
++        Times at which state collpase occurred. Only for Monte Carlo solver.
++    col_which : list
++        Which collapse operator was responsible for each collapse in
++        ``col_times``. Only for Monte Carlo solver.
++
++    """
++    def __init__(self):
++        self.solver = None
++        self.times = None
++        self.states = []
++        self.expect = []
++        self.num_expect = 0
++        self.num_collapse = 0
++        self.ntraj = None
++        self.seeds = None
++        self.col_times = None
++        self.col_which = None
++
++    def __str__(self):
++        s = "Result object "
++        if self.solver:
++            s += "with " + self.solver + " data.\n"
++        else:
++            s += "missing solver information.\n"
++        s += "-" * (len(s) - 1) + "\n"
++        if self.states is not None and len(self.states) > 0:
++            s += "states = True\n"
++        elif self.expect is not None and len(self.expect) > 0:
++            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
++        else:
++            s += "states = True, expect = True\n" + \
++                "num_expect = " + str(self.num_expect) + ", "
++        s += "num_collapse = " + str(self.num_collapse)
++        if self.solver == 'mcsolve':
++            s += ", ntraj = " + str(self.ntraj)
++        return s
++
++    def __repr__(self):
++        return self.__str__()
++
++    def __getstate__(self):
++        # defines what happens when Qobj object gets pickled
++        self.__dict__.update({'qutip_version': __version__[:5]})
++        return self.__dict__
++
++    def __setstate__(self, state):
++        # defines what happens when loading a pickled Qobj
++        if 'qutip_version' in state.keys():
++            del state['qutip_version']
++        (self.__dict__).update(state)
++
++
++# %%%%%%%%%%% remove ?
++class SolverConfiguration():
++    def __init__(self):
++
++        self.cgen_num = 0
++
++        self.reset()
++
++    def reset(self):
++        # General stuff
++        self.tlist = None       # evaluations times
++        self.ntraj = None       # number / list of trajectories
++        self.options = None     # options for solvers
++        self.norm_tol = None    # tolerance for wavefunction norm
++        self.norm_steps = None  # max. number of steps to take in finding
++        # Initial state stuff
++        self.psi0 = None        # initial state
++        self.psi0_dims = None   # initial state dims
++        self.psi0_shape = None  # initial state shape
++
++        # flags for setting time-dependence, collapse ops, and number of times
++        # codegen has been run
++        self.cflag = 0     # Flag signaling collapse operators
++        self.tflag = 0     # Flag signaling time-dependent problem
++
++        self.soft_reset()
++
++    def soft_reset(self):
++        # Hamiltonian stuff
++        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
++        self.h_tdterms = []  # List of td strs and funcs
++        self.h_data = None   # List of sparse matrix data
++        self.h_ind = None    # List of sparse matrix indices
++        self.h_ptr = None    # List of sparse matrix ptrs
++
++        # Expectation operator stuff
++        self.e_num = 0        # number of expect ops
++        self.e_ops_data = []  # expect op data
++        self.e_ops_ind = []   # expect op indices
++        self.e_ops_ptr = []   # expect op indptrs
++        self.e_ops_isherm = []  # expect op isherm
++
++        # Collapse operator stuff
++        self.c_num = 0          # number of collapse ops
++        self.c_const_inds = []  # indicies of constant collapse operators
++        self.c_td_inds = []     # indicies of time-dependent collapse operators
++        self.c_ops_data = []    # collapse op data
++        self.c_ops_ind = []     # collapse op indices
++        self.c_ops_ptr = []     # collapse op indptrs
++        self.c_args = []        # store args for time-dependent collapse func.
++
++        # Norm collapse operator stuff
++        self.n_ops_data = []  # norm collapse op data
++        self.n_ops_ind = []   # norm collapse op indices
++        self.n_ops_ptr = []   # norm collapse op indptrs
++
++        # holds executable strings for time-dependent collapse evaluation
++        self.col_expect_code = None
++        self.col_spmv_code = None
++
++        # hold stuff for function list based time dependence
++        self.h_td_inds = []
++        self.h_td_data = []
++        self.h_td_ind = []
++        self.h_td_ptr = []
++        self.h_funcs = None
++        self.h_func_args = None
++        self.c_funcs = None
++        self.c_func_args = None
++
++        # time-dependent (TD) function stuff
++        self.tdfunc = None     # Placeholder for TD RHS function.
++        self.tdname = None     # Name of td .pyx file
++        self.colspmv = None    # Placeholder for TD col-spmv function.
++        self.colexpect = None  # Placeholder for TD col_expect function.
++        self.string = None     # Holds string of variables passed to td solver
++
++
++def _format_time(t, tt=None, ttt=None):
++    time_str = str(datetime.timedelta(seconds=t))
++    if tt is not None and ttt is not None:
++        sect_percent = 100*t/tt
++        solve_percent = 100*t/ttt
++        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
++                                            sect_percent, solve_percent)
++    elif tt is not None:
++        sect_percent = 100*t/tt
++        time_str += " ({:03.2f}% section)".format(sect_percent)
++
++    elif ttt is not None:
++        solve_percent = 100*t/ttt
++        time_str += " ({:03.2f}% total)".format(solve_percent)
++
++    return time_str
++
++
++class Stats:
++    """
++    Statistical information on the solver performance
++    Statistics can be grouped into sections.
++    If no section names are given in the the contructor, then all statistics
++    will be added to one section 'main'
++
++    Parameters
++    ----------
++    section_names : list
++        list of keys that will be used as keys for the sections
++        These keys will also be used as names for the sections
++        The text in the output can be overidden by setting the header property
++        of the section
++        If no names are given then one section called 'main' is created
++
++    Attributes
++    ----------
++    sections : OrderedDict of _StatsSection
++        These are the sections that are created automatically on instantiation
++        or added using add_section
++
++    header : string
++        Some text that will be used as the heading in the report
++        By default there is None
++
++    total_time : float
++        Time in seconds for the solver to complete processing
++        Can be None, meaning that total timing percentages will be reported
++    """
++
++    def __init__(self, section_names=None):
++        self._def_section_name = 'main'
++        self.sections = OrderedDict()
++        self.total_time = None
++        self.header = None
++        if isinstance(section_names, list):
++            c = 0
++            for name in section_names:
++                self.sections[name] = _StatsSection(name, self)
++                if c == 0:
++                    self._def_section_name = name
++                c += 1
++
++        else:
++            self.sections[self._def_section_name] = \
++                        _StatsSection(self._def_section_name)
++
++    def _get_section(self, section):
++        if section is None:
++            return self.sections[self._def_section_name]
++        elif isinstance(section, _StatsSection):
++            return section
++        else:
++            sect = self.sections.get(section, None)
++            if sect is None:
++                raise ValueError("Unknown section {}".format(section))
++            else:
++                return sect
++
++    def add_section(self, name):
++        """
++        Add another section with the given name
++
++        Parameters
++        ----------
++        name : string
++            will be used as key for sections dict
++            will also be the header for the section
++
++        Returns
++        -------
++        section : :class:`_StatsSection`
++            The new section
++        """
++        sect = _StatsSection(name, self)
++        self.sections[name] = sect
++        return sect
++
++    def add_count(self, key, value, section=None):
++        """
++        Add value to count. If key does not already exist in section then
++        it is created with this value.
++        If key already exists it is increased by the give value
++        value is expected to be an integer
++
++        Parameters
++        ----------
++        key : string
++            key for the section.counts dictionary
++            reusing a key will result in numerical addition of value
++
++        value : int
++            Initial value of the count, or added to an existing count
++
++        section : string or :class:`_StatsSection`
++            Section which to add the count to.
++            If None given, the default (first) section will be used
++        """
++
++        self._get_section(section).add_count(key, value)
++
++    def add_timing(self, key, value, section=None):
++        """
++        Add value to timing. If key does not already exist in section then
++        it is created with this value.
++        If key already exists it is increased by the give value
++        value is expected to be a float, and given in seconds.
++
++        Parameters
++        ----------
++        key : string
++            key for the section.timings dictionary
++            reusing a key will result in numerical addition of value
++
++        value : int
++            Initial value of the timing, or added to an existing timing
++
++        section: string or `class` : _StatsSection
++            Section which to add the timing to.
++            If None given, the default (first) section will be used
++        """
++        self._get_section(section).add_timing(key, value)
++
++    def add_message(self, key, value, section=None, sep=";"):
++        """
++        Add value to message. If key does not already exist in section then
++        it is created with this value.
++        If key already exists the value is added to the message
++        The value will be converted to a string
++
++        Parameters
++        ----------
++        key : string
++            key for the section.messages dictionary
++            reusing a key will result in concatenation of value
++
++        value : int
++            Initial value of the message, or added to an existing message
++
++        sep : string
++            Message will be prefixed with this string when concatenating
++
++        section: string or `class` : _StatsSection
++            Section which to add the message to.
++            If None given, the default (first) section will be used
++        """
++        self._get_section(section).add_message(key, value, sep=sep)
++
++    def set_total_time(self, value, section=None):
++        """
++        Sets the total time for the complete solve or for a specific section
++        value is expected to be a float, and given in seconds
++
++        Parameters
++        ----------
++        value : float
++            Time in seconds to complete the solver section
++
++        section : string or `class` : _StatsSection
++            Section which to set the total_time for
++            If None given, the total_time for complete solve is set
++        """
++        if not isinstance(value, float):
++            try:
++                value = float(value)
++            except:
++                raise TypeError("value is expected to be a float")
++
++        if section is None:
++            self.total_time = value
++        else:
++            sect = self._get_section(section)
++            sect.total_time = value
++
++    def report(self, output=sys.stdout):
++        """
++        Report the counts, timings and messages from the sections.
++        Sections are reported in the order that the names were supplied
++        in the constructor.
++        The counts, timings and messages are reported in the order that they
++        are added to the sections
++        The output can be written to anything that supports a write method,
++        e.g. a file or the console (default)
++        The output is intended to in markdown format
++
++        Parameters
++        ----------
++        output : stream
++            file or console stream - anything that support write - where
++            the output will be written
++        """
++
++        if not hasattr(output, 'write'):
++            raise TypeError("output must have a write method")
++
++        if self.header:
++            output.write("{}\n{}\n".format(self.header,
++                                     ("="*len(self.header))))
++        for name, sect in self.sections.items():
++            sect.report(output)
++
++        if self.total_time is not None:
++            output.write("\nSummary\n-------\n")
++            output.write("{}\t solver total time\n".format(
++                                            _format_time(self.total_time)))
++
++    def clear(self):
++        """
++        Clear counts, timings and messages from all sections
++        """
++        for sect in self.sections.values():
++            sect.clear()
++        self.total_time = None
++
++
++class _StatsSection(object):
++    """
++    Not intended to be directly instantiated
++    This is the type for the SolverStats.sections values
++
++    The method parameter descriptions are the same as for those the parent
++    with the same method name
++
++    Parameters
++    ----------
++    name : string
++        key for the parent sections dictionary
++        will also be used as the header
++
++    parent : `class` :  SolverStats
++        The container for all the sections
++
++    Attributes
++    ----------
++    name : string
++        key for the parent sections dictionary
++        will also be used as the header
++
++    parent : `class` :  SolverStats
++        The container for all the sections
++
++    header : string
++        Used as heading for section in report
++
++    counts : OrderedDict
++        The integer type statistics for the stats section
++
++    timings : OrderedDict
++        The timing type statistics for the stats section
++        Expected to contain float values representing values in seconds
++
++    messages : OrderedDict
++        Text type output to be reported
++
++    total_time : float
++        Total time for processing in the section
++        Can be None, meaning that section timing percentages will be reported
++    """
++    def __init__(self, name, parent):
++        self.parent = parent
++        self.header = str(name)
++        self.name = name
++        self.counts = OrderedDict()
++        self.timings = OrderedDict()
++        self.messages = OrderedDict()
++        self.total_time = None
++
++    def add_count(self, key, value):
++        """
++        Add value to count. If key does not already exist in section then
++        it is created with this value.
++        If key already exists it is increased by the given value
++        value is expected to be an integer
++        """
++        if not isinstance(value, int):
++            try:
++                value = int(value)
++            except:
++                raise TypeError("value is expected to be an integer")
++
++        if key in self.counts:
++            self.counts[key] += value
++        else:
++            self.counts[key] = value
++
++    def add_timing(self, key, value):
++        """
++        Add value to timing. If key does not already exist in section then
++        it is created with this value.
++        If key already exists it is increased by the give value
++        value is expected to be a float, and given in seconds.
++        """
++        if not isinstance(value, float):
++            try:
++                value = float(value)
++            except:
++                raise TypeError("value is expected to be a float")
++
++        if key in self.timings:
++            self.timings[key] += value
++        else:
++            self.timings[key] = value
++
++    def add_message(self, key, value, sep=";"):
++        """
++        Add value to message. If key does not already exist in section then
++        it is created with this value.
++        If key already exists the value is added to the message
++        The value will be converted to a string
++        """
++        value = str(value)
++
++        if key in self.messages:
++            if sep is not None:
++                try:
++                    value = sep + value
++                except:
++                    TypeError("It is not possible to concatenate the value "
++                              "with the given seperator")
++            self.messages[key] += value
++        else:
++            self.messages[key] = value
++
++    def report(self, output=sys.stdout):
++        """
++        Report the counts, timings and messages for this section.
++        Note the percentage of the section and solver total times will be
++        given if the parent and or section total_time is set
++        """
++        if self.header:
++            output.write("\n{}\n{}\n".format(self.header,
++                                     ("-"*len(self.header))))
++
++        # TODO: Make the timings and counts ouput in a table format
++        #       Generally make more pretty
++
++        # Report timings
++        try:
++            ttt = self.parent.total_time
++        except:
++            ttt = None
++
++        tt = self.total_time
++
++        output.write("### Timings:\n")
++        for key, value in self.timings.items():
++            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
++            output.write(l)
++        if tt is not None:
++            output.write(" - {}\t{} total time\n".format(_format_time(tt),
++                                                     self.name))
++
++        # Report counts
++        output.write("### Counts:\n")
++        for key, value in self.counts.items():
++            l = " - {}\t{}\n".format(value, key)
++            output.write(l)
++
++        # Report messages
++        output.write("### Messages:\n")
++        for key, value in self.messages.items():
++            l = " - {}:\t{}\n".format(key, value)
++            output.write(l)
++
++
++    def clear(self):
++        """
++        Clear counts, timings and messages from this section
++        """
++        self.counts.clear()
++        self.timings.clear()
++        self.messages.clear()
++        self.total_time = None
++
++
++def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
++    # Input is std Qobj (Hamiltonian or Liouvillian)
++    if isinstance(H, Qobj):
++        Hdims = H.dims
++        Htype = H.type
++        _structure_check(Hdims, Htype, state)
++    # Input H is function
++    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
++        Hdims = H(0,args).dims
++        Htype = H(0,args).type
++        _structure_check(Hdims, Htype, state)
++    # Input is td-list
++    elif isinstance(H, list):
++        if isinstance(H[0], Qobj):
++            Hdims = H[0].dims
++            Htype = H[0].type
++        elif isinstance(H[0], list):
++            Hdims = H[0][0].dims
++            Htype = H[0][0].type
++        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
++            Hdims = H[0](0,args).dims
++            Htype = H[0](0,args).type
++        else:
++            raise Exception('Invalid td-list element.')
++        # Check all operators in list
++        for ii in range(len(H)):
++            if isinstance(H[ii], Qobj):
++                _temp_dims = H[ii].dims
++                _temp_type = H[ii].type
++            elif isinstance(H[ii], list):
++                _temp_dims = H[ii][0].dims
++                _temp_type = H[ii][0].type
++            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
++                _temp_dims = H[ii](0,args).dims
++                _temp_type = H[ii](0,args).type
++            else:
++                raise Exception('Invalid td-list element.')
++            _structure_check(_temp_dims,_temp_type,state)
++
++    else:
++        raise Exception('Invalid time-dependent format.')
++
++
++    for ii in range(len(c_ops)):
++        do_tests = True
++        if isinstance(c_ops[ii], Qobj):
++            _temp_state = c_ops[ii]
++        elif isinstance(c_ops[ii], list):
++            if isinstance(c_ops[ii][0], Qobj):
++                _temp_state = c_ops[ii][0]
++            elif isinstance(c_ops[ii][0], tuple):
++                do_tests = False
++                for kk in range(len(c_ops[ii][0])):
++                    _temp_state = c_ops[ii][0][kk]
++                    _structure_check(Hdims, Htype, _temp_state)
++        else:
++            raise Exception('Invalid td-list element.')
++        if do_tests:
++            _structure_check(Hdims, Htype, _temp_state)
++
++    if isinstance(e_ops, list):
++        for ii in range(len(e_ops)):
++            if isinstance(e_ops[ii], Qobj):
++                _temp_state = e_ops[ii]
++            elif isinstance(e_ops[ii], list):
++                _temp_state = e_ops[ii][0]
++            else:
++                raise Exception('Invalid td-list element.')
++            _structure_check(Hdims,Htype,_temp_state)
++    elif isinstance(e_ops, FunctionType):
++        pass
++    else:
++        raise Exception('Invalid e_ops specification.')
++
++
++def _structure_check(Hdims, Htype, state):
++    if state is not None:
++        # Input state is a ket vector
++        if state.type == 'ket':
++            # Input is Hamiltonian
++            if Htype == 'oper':
++                if Hdims[1] != state.dims[0]:
++                    raise Exception('Input operator and ket do not '
++                                    'share same structure.')
++            # Input is super and state is ket
++            elif Htype == 'super':
++                if Hdims[1][1] != state.dims[0]:
++                    raise Exception('Input operator and ket do not '
++                                    'share same structure.')
++            else:
++                raise Exception('Invalid input operator.')
++        # Input state is a density matrix
++        elif state.type == 'oper':
++            # Input is Hamiltonian and state is density matrix
++            if Htype == 'oper':
++                if Hdims[1] != state.dims[0]:
++                    raise Exception('Input operators do not '
++                                    'share same structure.')
++            # Input is super op. and state is density matrix
++            elif Htype == 'super':
++                if Hdims[1] != state.dims:
++                    raise Exception('Input operators do not '
++                                    'share same structure.')
++
++
++#
++# create a global instance of the SolverConfiguration class
++#
++config = SolverConfiguration()
++
++# for backwards compatibility
++# Odeoptions = Options
++# Odedata = Result
+diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
+index 99829ae8..63df5c46 100644
+--- a/qutip/solve/stochastic.py
++++ b/qutip/solve/stochastic.py
+@@ -1,1405 +1,1405 @@
+-# -*- coding: utf-8 -*-
+-
+-import numpy as np
+-import scipy.sparse as sp
+-from .. import (
+-    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
+-    unstack_columns, liouvillian, lindblad_dissipator,
+-)
+-from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
+-from ._stochastic import (
+-    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
+-    GenericSSolver, Solvers
+-)
+-from .solver import Result, SolverOptions, _solver_safety_check
+-from .parallel import serial_map
+-from ..ui.progressbar import TextProgressBar
+-from qutip.core import data as _data
+-
+-__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
+-           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
+-           'stochastic_solvers', 'general_stochastic']
+-
+-
+-def stochastic_solvers():
+-    # This docstring contains several literal backslash characters inside LaTeX
+-    # blocks, but it cannot be declared as a raw string because we also need to
+-    # use a line continuation.  At one point we need a restructured text
+-    # "definition list", where the heading _must_ be entirely on one line,
+-    # however it will violate our line-length reporting if we do that.
+-    """
+-    This function is purely a reference point for documenting the available
+-    stochastic solver methods, and takes no actions.
+-
+-    Notes
+-    -----
+-    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
+-        euler-maruyama
+-            A simple generalization of the Euler method for ordinary
+-            differential equations to stochastic differential equations.  Only
+-            solver which could take non-commuting ``sc_ops``. *not tested*
+-
+-            - Order 0.5
+-            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
+-
+-        milstein
+-            An order 1.0 strong Taylor scheme.  Better approximate numerical
+-            solution to stochastic differential equations.  See eq. (2.9) of
+-            chapter 12.2 of [1]_.
+-
+-            - Order strong 1.0
+-            - Code: ``'milstein'`` or ``1.0``
+-
+-        milstein-imp
+-            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
+-            scheme for the numerical simulation of stiff stochastic
+-            differential equations.
+-
+-            - Order strong 1.0
+-            - Code: ``'milstein-imp'``
+-
+-        predictor-corrector
+-            Generalization of the trapezoidal method to stochastic differential
+-            equations. More stable than explicit methods.  See eq. (5.4) of
+-            chapter 15.5 of [1]_.
+-
+-            - Order strong 0.5, weak 1.0
+-            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
+-              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
+-              ``'pc-euler'``
+-            - Codes to correct both the stochastic and deterministic parts
+-              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
+-              ``'pc-euler-2'`` or ``'pred-corr-2'``
+-
+-        platen
+-            Explicit scheme, creates the Milstein using finite differences
+-            instead of analytic derivatives. Also contains some higher order
+-            terms, thus converges better than Milstein while staying strong
+-            order 1.0.  Does not require derivatives, therefore usable by
+-            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
+-
+-            - Order strong 1.0, weak 2.0
+-            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
+-
+-        rouchon
+-            Scheme keeping the positivity of the density matrix
+-            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
+-
+-            - Order strong 1.0?
+-            - Code: ``'rouchon'`` or ``'Rouchon'``
+-
+-        taylor1.5
+-            Order 1.5 strong Taylor scheme.  Solver with more terms of the
+-            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
+-            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
+-
+-            - Order strong 1.5
+-            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
+-
+-        taylor1.5-imp
+-            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
+-            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
+-            (2.18) of chapter 12.2 of [1]_.
+-
+-            - Order strong 1.5
+-            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
+-
+-        explicit1.5
+-            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
+-            Taylor scheme using finite difference instead of derivatives.
+-            Slower than ``taylor15`` but usable by
+-            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
+-            [1]_.
+-
+-            - Order strong 1.5
+-            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
+-
+-        taylor2.0
+-            Order 2 strong Taylor scheme.  Solver with more terms of the
+-            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
+-
+-            - Order strong 2.0
+-            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
+-
+-        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
+-        and for both heterodyne and homodyne. taylor2.0 only works for 1
+-        stochastic operator independent of time with the homodyne method.
+-        :func:`~general_stochastic` only accepts the derivative-free
+-        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
+-
+-    Available solvers for :obj:`~photocurrent_sesolve` and \
+-:obj:`~photocurrent_mesolve`
+-        Photocurrent use ordinary differential equations between
+-        stochastic "jump/collapse".
+-
+-        euler
+-            Euler method for ordinary differential equations between jumps.
+-            Only one jump per time interval.  Default solver.  See eqs. (4.19)
+-            and (4.4) of chapter 4 of [4]_.
+-
+-            - Order 1.0
+-            - Code: ``'euler'``
+-
+-        predictor–corrector
+-            predictor–corrector method (PECE) for ordinary differential
+-            equations.  Uses the Poisson distribution to obtain the number of
+-            jumps at each timestep.
+-
+-            - Order 2.0
+-            - Code: ``'pred-corr'``
+-
+-    References
+-    ----------
+-    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
+-       Stochastic Differential Equations*.
+-    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
+-       Systems*.
+-    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
+-       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
+-       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
+-       (2015).
+-    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
+-       control*.
+-    """
+-
+-
+-class StochasticSolverOptions:
+-    """Class of options for stochastic solvers such as
+-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
+-
+-    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
+-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
+-    :func:`qutip.stochastic.photocurrent_sesolve` and
+-    :func:`qutip.stochastic.photocurrent_mesolve`
+-    all take the same keyword arguments as
+-    the constructor of these class, and internally they use these arguments to
+-    construct an instance of this class, so it is rarely needed to explicitly
+-    create an instance of this class.
+-
+-    Within the attribute list, a ``time_dependent_object`` is either
+-
+-    - :class:`~qutip.Qobj`: a constant term
+-    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
+-      where the ``Qobj`` will be multiplied by the time-dependent scalar.
+-
+-    For more details on all allowed time-dependent objects, see the
+-    documentation for :class:`~qutip.QobjEvo`.
+-
+-    Attributes
+-    ----------
+-    H : time_dependent_object or list of time_dependent_object
+-        System Hamiltonian in standard time-dependent list format.  This is the
+-        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
+-        If this is a list of elements, they are summed.
+-
+-    state0 : :class:`qutip.Qobj`
+-        Initial state vector (ket) or density matrix.
+-
+-    times : array_like of float
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of time_dependent_object
+-        List of deterministic collapse operators.  Each element of the list is
+-        a separate operator; unlike the Hamiltonian, there is no implicit
+-        summation over the terms.
+-
+-    sc_ops : list of time_dependent_object
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the equation of motion according to how the d1 and d2 functions
+-        are defined.  Each element of the list is a separate operator, like
+-        ``c_ops``.
+-
+-    e_ops : list of :class:`qutip.Qobj`
+-        Single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    m_ops : list of :class:`qutip.Qobj`
+-        List of operators representing the measurement operators. The expected
+-        format is a nested list with one measurement operator for each
+-        stochastic increament, for each stochastic collapse operator.
+-
+-    args : dict
+-        Dictionary of parameters for time dependent systems.
+-
+-    tol : float
+-        Tolerance of the solver for implicit methods.
+-
+-    ntraj : int
+-        Number of trajectors.
+-
+-    nsubsteps : int
+-        Number of sub steps between each time-spep given in `times`.
+-
+-    dW_factors : array
+-        Array of length len(sc_ops), containing scaling factors for each
+-        measurement operator in m_ops.
+-
+-    solver : string
+-        Name of the solver method to use for solving the stochastic
+-        equations. Valid values are:
+-
+-        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
+-        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
+-        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
+-        - order 2 algorithms: 'taylor2.0'
+-
+-        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
+-        for a description of the solvers.  Implicit methods can adjust
+-        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
+-
+-    method : string ('homodyne', 'heterodyne')
+-        The name of the type of measurement process that give rise to the
+-        stochastic equation to solve.
+-
+-    store_all_expect : bool (default False)
+-        Whether or not to store the e_ops expect values for all paths.
+-
+-    store_measurement : bool (default False)
+-        Whether or not to store the measurement results in the
+-        :class:`qutip.solver.Result` instance returned by the solver.
+-
+-    noise : int, or 1D array of int, or 4D array of float
+-        - int : seed of the noise
+-        - 1D array : length = ntraj, seeds for each trajectories.
+-        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
+-          Vector for the noise, the len of the last dimensions is doubled for
+-          solvers of order 1.5. This corresponds to results.noise.
+-
+-    noiseDepth : int
+-        Number of terms kept of the truncated series used to create the
+-        noise used by taylor2.0 solver.
+-
+-    normalize : bool
+-        (default True for (photo)ssesolve, False for (photo)smesolve)
+-        Whether or not to normalize the wave function during the evolution.
+-        Normalizing density matrices introduce numerical errors.
+-
+-    options : :class:`qutip.solver.SolverOptions`
+-        Generic solver options. Only options['average_states'] and
+-        options['store_states'] are used.
+-
+-    map_func: function
+-        A map function or managing the calls to single-trajactory solvers.
+-
+-    map_kwargs: dictionary
+-        Optional keyword arguments to the map_func function function.
+-
+-    progress_bar : :class:`qutip.ui.BaseProgressBar`
+-        Optional progress bar class instance.
+-    """
+-    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
+-                 e_ops=[], m_ops=None, store_all_expect=False,
+-                 store_measurement=False, dW_factors=None,
+-                 solver=None, method="homodyne", normalize=None,
+-                 times=None, nsubsteps=1, ntraj=1, tol=None,
+-                 generate_noise=None, noise=None,
+-                 progress_bar=None, map_func=None, map_kwargs=None,
+-                 args={}, options=None, noiseDepth=20):
+-
+-        if options is None:
+-            options = SolverOptions()
+-
+-        if progress_bar is None:
+-            progress_bar = TextProgressBar()
+-
+-        # System
+-        # Cast to QobjEvo so the code has only one version for both the
+-        # constant and time-dependent case.
+-        self.me = me
+-
+-        if H is not None:
+-            msg = "The Hamiltonian format is not valid. "
+-            try:
+-                self.H = QobjEvo(H, args=args, tlist=times)
+-            except Exception as e:
+-                raise ValueError(msg + str(e)) from e
+-        else:
+-            self.H = H
+-
+-        if sc_ops:
+-            msg = ("The sc_ops format is not valid. Options are "
+-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
+-            try:
+-                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
+-                               for op in sc_ops]
+-            except Exception as e:
+-                raise ValueError(msg + str(e)) from e
+-        else:
+-            self.sc_ops = sc_ops
+-
+-        if c_ops:
+-            msg = ("The c_ops format is not valid. Options are "
+-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
+-            try:
+-                self.c_ops = [QobjEvo(op, args=args, tlist=times)
+-                              for op in c_ops]
+-            except Exception as e:
+-                raise ValueError(msg + str(e)) from e
+-        else:
+-            self.c_ops = c_ops
+-
+-        self.state0 = state0
+-        self.rho0 = stack_columns(state0.full()).ravel()
+-
+-        # Observation
+-
+-        for e_op in e_ops:
+-            if (
+-                isinstance(e_op, Qobj)
+-                and self.H is not None
+-                and e_op.dims[1] != self.H.dims[0]
+-            ):
+-                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
+-                                f"with the system's ({self.H.dims})")
+-        self.e_ops = e_ops
+-        self.m_ops = m_ops
+-        self.store_measurement = store_measurement
+-        self.store_all_expect = store_all_expect
+-        self.store_states = options['store_states']
+-        self.dW_factors = dW_factors
+-
+-        # Solver
+-        self.solver = solver
+-        self.method = method
+-        if normalize is None and me:
+-            self.normalize = 0
+-        elif normalize is None and not me:
+-            self.normalize = 1
+-        elif normalize:
+-            self.normalize = 1
+-        else:
+-            self.normalize = 0
+-
+-        self.times = times
+-        self.nsubsteps = nsubsteps
+-        self.dt = (times[1] - times[0]) / self.nsubsteps
+-        self.ntraj = ntraj
+-        if tol is not None:
+-            self.tol = tol
+-        elif "tol" in args:
+-            self.tol = args["tol"]
+-        else:
+-            self.tol = 1e-7
+-
+-        # Noise
+-        if noise is not None:
+-            if isinstance(noise, int):
+-                # noise contain a seed
+-                np.random.seed(noise)
+-                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
+-            noise = np.array(noise)
+-            if len(noise.shape) == 1:
+-                if noise.shape[0] < ntraj:
+-                    raise ValueError("'noise' does not have enought seeds " +
+-                                     "len(noise) >= ntraj")
+-                # numpy seed must be between 0 and 2**32-1
+-                # 'u4': unsigned 32bit int
+-                self.noise = noise.astype("u4")
+-                self.noise_type = 0
+-
+-            elif len(noise.shape) == 4:
+-                # taylor case not included
+-                dw_len = (2 if method == "heterodyne" else 1)
+-                dw_len_str = (" * 2" if method == "heterodyne" else "")
+-                msg = "Incorrect shape for 'noise': "
+-                if noise.shape[0] < ntraj:
+-                    raise ValueError(msg + "shape[0] >= ntraj")
+-                if noise.shape[1] < len(times):
+-                    raise ValueError(msg + "shape[1] >= len(times)")
+-                if noise.shape[2] < nsubsteps:
+-                    raise ValueError(msg + "shape[2] >= nsubsteps")
+-                if noise.shape[3] < len(self.sc_ops) * dw_len:
+-                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
+-                                     dw_len_str)
+-                self.noise_type = 1
+-                self.noise = noise
+-
+-        else:
+-            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
+-            self.noise_type = 0
+-
+-        # Map
+-        self.progress_bar = progress_bar
+-        if self.ntraj > 1 and map_func:
+-            self.map_func = map_func
+-        else:
+-            self.map_func = serial_map
+-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
+-
+-        # Other
+-        self.options = options
+-        self.args = args
+-        self.set_solver()
+-        self.p = noiseDepth
+-
+-    def set_solver(self):
+-        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
+-            self.solver_code = 50
+-            self.solver = 'euler-maruyama'
+-        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
+-            self.solver_code = 100
+-            self.solver = 'platen'
+-        elif self.solver in ['pred-corr', 'predictor-corrector',
+-                             'pc-euler', 101]:
+-            self.solver_code = 101
+-            self.solver = 'pred-corr'
+-        elif self.solver in ['milstein', 102, 1.0]:
+-            self.solver_code = 102
+-            self.solver = 'milstein'
+-        elif self.solver in ['milstein-imp', 103]:
+-            self.solver_code = 103
+-            self.solver = 'milstein-imp'
+-        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
+-            self.solver_code = 104
+-            self.solver = 'pred-corr-2'
+-        elif self.solver in ['Rouchon', 'rouchon', 120]:
+-            self.solver_code = 120
+-            self.solver = 'rouchon'
+-            if not all((op.isconstant for op in self.sc_ops)):
+-                raise ValueError("Rouchon only works with constant sc_ops")
+-        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
+-            self.solver_code = 150
+-            self.solver = 'explicit1.5'
+-        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
+-            self.solver_code = 152
+-            self.solver = 'taylor1.5'
+-        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
+-            self.solver_code = 153
+-            self.solver = 'taylor1.5-imp'
+-        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
+-            self.solver_code = 202
+-            self.solver = 'taylor2.0'
+-            if not len(self.sc_ops) == 1 or \
+-                    not self.sc_ops[0].isconstant or \
+-                    not self.method == "homodyne":
+-                raise ValueError(
+-                    "Taylor2.0 only works with 1 constant sc_ops and for"
+-                    " homodyne method"
+-                )
+-        else:
+-            known = [
+-                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
+-                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
+-                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
+-            ]
+-            raise ValueError("The solver should be one of {!r}".format(known))
+-
+-
+-class StochasticSolverOptionsPhoto(StochasticSolverOptions):
+-    """
+-    Attributes
+-    ----------
+-
+-    solver : string
+-        Name of the solver method to use for solving the evolution
+-        of the system.*
+-        order 1 algorithms: 'euler'
+-        order 2 algorithms: 'pred-corr'
+-        In photocurrent evolution
+-    """
+-    def set_solver(self):
+-        if self.solver in [None, 'euler', 1, 60]:
+-            self.solver_code = 60
+-            self.solver = 'euler'
+-        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
+-            self.solver_code = 110
+-            self.solver = 'pred-corr'
+-        else:
+-            raise Exception("The solver should be one of " +
+-                            "[None, 'euler', 'predictor-corrector']")
+-
+-
+-def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
+-             _safe_mode=True, args={}, **kwargs):
+-    """
+-    Solve stochastic master equation. Dispatch to specific solvers
+-    depending on the value of the `solver` keyword argument.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`, or time dependent system.
+-        System Hamiltonian.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    rho0 : :class:`qutip.Qobj`
+-        Initial density matrix or state vector (ket).
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+-        Deterministic collapse operator which will contribute with a standard
+-        Lindblad type of dissipation.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the eqaution of motion according to how the d1 and d2 functions
+-        are defined.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    e_ops : list of :class:`qutip.Qobj`
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-
+-    """
+-    if "method" in kwargs and kwargs["method"] == "photocurrent":
+-        print("stochastic solver with photocurrent method has been moved to "
+-              "it's own function: photocurrent_mesolve")
+-        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
+-                                    e_ops=e_ops, _safe_mode=_safe_mode,
+-                                    args=args, **kwargs)
+-    if isket(rho0):
+-        rho0 = ket2dm(rho0)
+-
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = [e for e in e_ops.values()]
+-    else:
+-        e_ops_dict = None
+-
+-    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
+-                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
+-                                  args=args, **kwargs)
+-
+-    if _safe_mode:
+-        _safety_checks(sso)
+-
+-    if sso.solver_code == 120:
+-        return _positive_map(sso, e_ops_dict)
+-
+-    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
+-    if sso.method == 'homodyne' or sso.method is None:
+-        if sso.m_ops is None:
+-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+-        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
+-        if not isinstance(sso.dW_factors, list):
+-            sso.dW_factors = [1] * len(sso.m_ops)
+-        elif len(sso.dW_factors) != len(sso.m_ops):
+-            raise Exception("The len of dW_factors is not the same as m_ops")
+-
+-    elif sso.method == 'heterodyne':
+-        if sso.m_ops is None:
+-            m_ops = []
+-        sso.sops = []
+-        for c in sso.sc_ops:
+-            if sso.m_ops is None:
+-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+-            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
+-                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
+-        sso.m_ops = m_ops
+-        if not isinstance(sso.dW_factors, list):
+-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
+-        elif len(sso.dW_factors) == len(sso.m_ops):
+-            pass
+-        elif len(sso.dW_factors) == len(sso.sc_ops):
+-            dW_factors = []
+-            for fact in sso.dW_factors:
+-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+-            sso.dW_factors = dW_factors
+-        elif len(sso.dW_factors) != len(sso.m_ops):
+-            raise Exception("The len of dW_factors is not the same as sc_ops")
+-
+-    elif sso.method == "photocurrent":
+-        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
+-
+-    else:
+-        raise Exception("The method must be one of None, homodyne, heterodyne")
+-
+-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+-
+-    if sso.solver_code in [103, 153]:
+-        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
+-
+-    sso.solver_obj = SMESolver
+-    sso.solver_name = "smesolve_" + sso.solver
+-
+-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-    return res
+-
+-
+-def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
+-             _safe_mode=True, args={}, **kwargs):
+-    """
+-    Solve stochastic schrodinger equation. Dispatch to specific solvers
+-    depending on the value of the `solver` keyword argument.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`, or time dependent system.
+-        System Hamiltonian.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    psi0 : :class:`qutip.Qobj`
+-        State vector (ket).
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the eqaution of motion according to how the d1 and d2 functions
+-        are defined.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    e_ops : list of :class:`qutip.Qobj`
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-    if "method" in kwargs and kwargs["method"] == "photocurrent":
+-        print("stochastic solver with photocurrent method has been moved to "
+-              "it's own function: photocurrent_sesolve")
+-        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
+-                                    e_ops=e_ops, _safe_mode=_safe_mode,
+-                                    args=args, **kwargs)
+-
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = [e for e in e_ops.values()]
+-    else:
+-        e_ops_dict = None
+-
+-    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
+-                                  sc_ops=sc_ops, e_ops=e_ops,
+-                                  args=args, **kwargs)
+-
+-    if _safe_mode:
+-        _safety_checks(sso)
+-
+-    if sso.solver_code == 120:
+-        raise Exception("rouchon only work with smesolve")
+-
+-    if sso.method == 'homodyne' or sso.method is None:
+-        if sso.m_ops is None:
+-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+-        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
+-        if not isinstance(sso.dW_factors, list):
+-            sso.dW_factors = [1] * len(sso.sops)
+-        elif len(sso.dW_factors) != len(sso.sops):
+-            raise Exception("The len of dW_factors is not the same as sc_ops")
+-
+-    elif sso.method == 'heterodyne':
+-        if sso.m_ops is None:
+-            m_ops = []
+-        sso.sops = []
+-        for c in sso.sc_ops:
+-            if sso.m_ops is None:
+-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+-            c1 = c / np.sqrt(2)
+-            c2 = c * (-1j / np.sqrt(2))
+-            sso.sops += [[c1, c1 + c1.dag()],
+-                         [c2, c2 + c2.dag()]]
+-        sso.m_ops = m_ops
+-        if not isinstance(sso.dW_factors, list):
+-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
+-        elif len(sso.dW_factors) == len(sso.sc_ops):
+-            dW_factors = []
+-            for fact in sso.dW_factors:
+-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+-            sso.dW_factors = dW_factors
+-        elif len(sso.dW_factors) != len(sso.sops):
+-            raise Exception("The len of dW_factors is not the same as sc_ops")
+-
+-    elif sso.method == "photocurrent":
+-        NotImplementedError("Moved to 'photocurrent_sesolve'")
+-
+-    else:
+-        raise Exception("The method must be one of None, homodyne, heterodyne")
+-
+-    sso.LH = sso.H * (-1j * sso.dt)
+-    for ops in sso.sops:
+-        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
+-
+-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+-
+-    sso.solver_obj = SSESolver
+-    sso.solver_name = "ssesolve_" + sso.solver
+-
+-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-
+-    return res
+-
+-
+-def _positive_map(sso, e_ops_dict):
+-    if sso.method == 'homodyne' or sso.method is None:
+-        sops = sso.sc_ops
+-        if sso.m_ops is None:
+-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+-        if not isinstance(sso.dW_factors, list):
+-            sso.dW_factors = [1] * len(sops)
+-        elif len(sso.dW_factors) != len(sops):
+-            raise Exception("The len of dW_factors is not the same as sc_ops")
+-
+-    elif sso.method == 'heterodyne':
+-        if sso.m_ops is None:
+-            m_ops = []
+-        sops = []
+-        for c in sso.sc_ops:
+-            if sso.m_ops is None:
+-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+-            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
+-        sso.m_ops = m_ops
+-        if not isinstance(sso.dW_factors, list):
+-            sso.dW_factors = [np.sqrt(2)] * len(sops)
+-        elif len(sso.dW_factors) == len(sso.sc_ops):
+-            dW_factors = []
+-            for fact in sso.dW_factors:
+-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+-            sso.dW_factors = dW_factors
+-        elif len(sso.dW_factors) != len(sops):
+-            raise Exception("The len of dW_factors is not the same as sc_ops")
+-    else:
+-        raise Exception("The method must be one of homodyne or heterodyne")
+-
+-    LH = 1 - (sso.H * 1j * sso.dt)
+-    sso.pp = spre(sso.H) * 0
+-    sso.sops = []
+-    sso.preops = []
+-    sso.postops = []
+-    sso.preops2 = []
+-    sso.postops2 = []
+-
+-    def _prespostdag(op):
+-        return spre(op) * spost(op.dag())
+-
+-    for op in sso.c_ops:
+-        LH += op.dag() @ op * (-sso.dt * 0.5)
+-        sso.pp += spre(op) * spost(op.dag()) * sso.dt
+-
+-    for i, op in enumerate(sops):
+-        LH += (-sso.dt * 0.5) * op.dag() @ op
+-        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
+-        sso.preops += [spre(op)]
+-        sso.postops += [spost(op.dag())]
+-        for op2 in sops[i:]:
+-            sso.preops2 += [spre(op * op2)]
+-            sso.postops2 += [spost(op.dag() * op2.dag())]
+-
+-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+-    sso.preLH = spre(LH)
+-    sso.postLH = spost(LH.dag())
+-
+-    sso.solver_obj = PmSMESolver
+-    sso.solver_name = "smesolve_" + sso.solver
+-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-
+-    return res
+-
+-
+-def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
+-                         _safe_mode=True, args={}, **kwargs):
+-    """
+-    Solve stochastic master equation using the photocurrent method.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`, or time dependent system.
+-        System Hamiltonian.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    rho0 : :class:`qutip.Qobj`
+-        Initial density matrix or state vector (ket).
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+-        Deterministic collapse operator which will contribute with a standard
+-        Lindblad type of dissipation.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the eqaution of motion according to how the d1 and d2 functions
+-        are defined.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function single
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-    if isket(rho0):
+-        rho0 = ket2dm(rho0)
+-
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = [e for e in e_ops.values()]
+-    else:
+-        e_ops_dict = None
+-
+-    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
+-                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
+-                                       args=args, **kwargs)
+-
+-    if _safe_mode:
+-        _safety_checks(sso)
+-
+-    if sso.m_ops is None:
+-        sso.m_ops = [op * 0 for op in sso.sc_ops]
+-    if not isinstance(sso.dW_factors, list):
+-        sso.dW_factors = [1] * len(sso.sc_ops)
+-    elif len(sso.dW_factors) != len(sso.sc_ops):
+-        raise Exception("The len of dW_factors is not the same as sc_ops")
+-
+-    sso.solver_obj = PcSMESolver
+-    sso.solver_name = "photocurrent_mesolve"
+-    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
+-
+-    def _prespostdag(op):
+-        return spre(op) * spost(op.dag())
+-
+-    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
+-                 spre(op.dag() @ op),
+-                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
+-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+-
+-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-
+-    return res
+-
+-
+-def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
+-                         _safe_mode=True, args={}, **kwargs):
+-    """
+-    Solve stochastic schrodinger equation using the photocurrent method.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`, or time dependent system.
+-        System Hamiltonian.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    psi0 : :class:`qutip.Qobj`
+-        Initial state vector (ket).
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the eqaution of motion according to how the d1 and d2 functions
+-        are defined.
+-        Can depend on time, see StochasticSolverOptions help for format.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function single
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = list(e_ops.values())
+-    else:
+-        e_ops_dict = None
+-
+-    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
+-                                       sc_ops=sc_ops, e_ops=e_ops,
+-                                       args=args, **kwargs)
+-
+-    if _safe_mode:
+-        _safety_checks(sso)
+-
+-    if sso.m_ops is None:
+-        sso.m_ops = [op * 0 for op in sso.sc_ops]
+-    if not isinstance(sso.dW_factors, list):
+-        sso.dW_factors = [1] * len(sso.sc_ops)
+-    elif len(sso.dW_factors) != len(sso.sc_ops):
+-        raise Exception("The len of dW_factors is not the same as sc_ops")
+-
+-    sso.solver_obj = PcSSESolver
+-    sso.solver_name = "photocurrent_sesolve"
+-    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
+-    sso.LH = sso.H * (-1j*sso.dt)
+-    for ops in sso.sops:
+-        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
+-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+-
+-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-
+-    return res
+-
+-
+-def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
+-                       _safe_mode=True, len_d2=1, args={}, **kwargs):
+-    """
+-    Solve stochastic general equation. Dispatch to specific solvers
+-    depending on the value of the `solver` keyword argument.
+-
+-
+-    Parameters
+-    ----------
+-
+-    state0 : :class:`qutip.Qobj`
+-        Initial state vector (ket) or density matrix as a vector.
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    d1 : function, callable class
+-        Function representing the deterministic evolution of the system.
+-
+-        def d1(time (double), state (as a np.array vector)):
+-            return 1d np.array
+-
+-    d2 : function, callable class
+-        Function representing the stochastic evolution of the system.
+-
+-        def d2(time (double), state (as a np.array vector)):
+-            return 2d np.array (N_sc_ops, len(state0))
+-
+-    len_d2 : int
+-        Number of output vector produced by d2
+-
+-    e_ops : list of :class:`qutip.Qobj`
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-        Must be a superoperator if the state vector is a density matrix.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-        An instance of the class :class:`qutip.solver.Result`.
+-    """
+-
+-    if isinstance(e_ops, dict):
+-        e_ops_dict = e_ops
+-        e_ops = [e for e in e_ops.values()]
+-    else:
+-        e_ops_dict = None
+-
+-    if "solver" not in kwargs:
+-        kwargs["solver"] = 50
+-
+-    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
+-                                  e_ops=e_ops, args=args, **kwargs)
+-    if sso.solver_code not in [50, 100, 150]:
+-        raise ValueError("Only Euler, platen, platen15 can be " +
+-                         "used for the general stochastic solver.")
+-
+-    sso.d1 = d1
+-    sso.d2 = d2
+-    if _safe_mode:
+-        # This state0_vec is computed as stack_columns(state0.full()).ravel()
+-        # in the sso init.
+-        state0_vec = sso.rho0
+-        l_vec = state0_vec.shape[0]
+-        try:
+-            out_d1 = d1(0., sso.rho0)
+-        except Exception as e:
+-            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
+-                               str(e)) from e
+-        try:
+-            out_d2 = d2(0., sso.rho0)
+-        except Exception as e:
+-            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
+-                               str(e)) from e
+-
+-        msg_d1 = ("d1 must return an 1d numpy array with the same number "
+-                  "of elements as the initial state as a vector.")
+-        if not isinstance(out_d1, np.ndarray):
+-            raise TypeError(msg_d1)
+-        if (out_d1.ndim != 1
+-                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
+-            raise ValueError(msg_d1)
+-
+-        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
+-                  "with the shape (len_d2, len(state0_vec) ).")
+-        if not isinstance(out_d2, np.ndarray):
+-            raise TypeError(msg_d2)
+-        if (out_d2.ndim != 2
+-                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
+-            raise ValueError(msg_d2)
+-        if out_d1.dtype != np.dtype('complex128') or \
+-           out_d2.dtype != np.dtype('complex128'):
+-            raise ValueError("Safety check: d1 and d2 must return " +
+-                             "complex numpy array.")
+-        msg_e_ops = ("Safety check: The shape of the e_ops "
+-                     "does not fit the intial state.")
+-        for op in sso.e_ops:
+-            shape_op = op.shape
+-            if sso.me:
+-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+-                    raise ValueError(msg_e_ops)
+-            else:
+-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                    raise ValueError(msg_e_ops +
+-                                     " Expecting e_ops as superoperators.")
+-
+-    sso.m_ops = []
+-    sso.cm_ops = []
+-    if sso.store_measurement:
+-        if not m_ops:
+-            raise ValueError("General stochastic needs explicit " +
+-                             "m_ops to store measurement.")
+-        sso.m_ops = m_ops
+-        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+-        if sso.dW_factors is None:
+-            sso.dW_factors = [1.] * len(sso.m_ops)
+-        elif len(sso.dW_factors) == 1:
+-            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
+-        elif len(sso.dW_factors) != len(sso.m_ops):
+-            raise ValueError("The number of dW_factors must fit" +
+-                             " the number of m_ops.")
+-
+-    if sso.dW_factors is None:
+-        sso.dW_factors = [1.] * len_d2
+-    sso.sops = [None] * len_d2
+-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+-
+-    sso.solver_obj = GenericSSolver
+-    sso.solver_name = "general_stochastic_solver_" + sso.solver
+-
+-    ssolver = GenericSSolver()
+-    # ssolver.set_data(sso)
+-    ssolver.set_solver(sso)
+-
+-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+-
+-    if e_ops_dict:
+-        res.expect = {e: res.expect[n]
+-                      for n, e in enumerate(e_ops_dict.keys())}
+-
+-    return res
+-
+-
+-def _safety_checks(sso):
+-    l_vec = sso.rho0.shape[0]
+-    if sso.H.issuper:
+-        if not sso.me:
+-            raise ValueError(
+-                "Given a Liouvillian for a Schrödinger equation problem."
+-            )
+-        shape_op = sso.H.shape
+-        if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-            raise Exception("The size of the hamiltonian does "
+-                            "not fit the intial state")
+-    else:
+-        shape_op = sso.H.shape
+-        if sso.me:
+-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+-                raise Exception("The size of the hamiltonian does "
+-                                "not fit the intial state")
+-        else:
+-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                raise Exception("The size of the hamiltonian does "
+-                                "not fit the intial state")
+-
+-    for op in sso.sc_ops:
+-        if op.issuper:
+-            if not sso.me:
+-                raise ValueError(
+-                    "Given a Liouvillian for a Schrödinger equation problem."
+-                )
+-            shape_op = op.shape
+-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                raise Exception("The size of the sc_ops does "
+-                                "not fit the intial state")
+-        else:
+-            shape_op = op.shape
+-            if sso.me:
+-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+-                    raise Exception("The size of the sc_ops does "
+-                                    "not fit the intial state")
+-            else:
+-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                    raise Exception("The size of the sc_ops does "
+-                                    "not fit the intial state")
+-
+-    for op in sso.c_ops:
+-        if op.issuper:
+-            if not sso.me:
+-                raise ValueError(
+-                    "Given a Liouvillian for a Schrödinger equation problem."
+-                )
+-            shape_op = op.shape
+-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                raise Exception("The size of the c_ops does "
+-                                "not fit the intial state")
+-        else:
+-            shape_op = op.shape
+-            if sso.me:
+-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+-                    raise Exception("The size of the c_ops does "
+-                                    "not fit the intial state")
+-            else:
+-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                    raise Exception("The size of the c_ops does "
+-                                    "not fit the intial state")
+-
+-    for op in sso.e_ops:
+-        shape_op = op.shape
+-        if sso.me:
+-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+-                raise Exception("The size of the e_ops does "
+-                                "not fit the intial state")
+-        else:
+-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                raise Exception("The size of the e_ops does "
+-                                "not fit the intial state")
+-
+-    if sso.m_ops is not None:
+-        for op in sso.m_ops:
+-            shape_op = op.shape
+-            if sso.me:
+-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+-                    raise Exception("The size of the m_ops does "
+-                                    "not fit the intial state")
+-            else:
+-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+-                    raise Exception("The size of the m_ops does "
+-                                    "not fit the intial state")
+-
+-
+-def _sesolve_generic(sso, options, progress_bar):
+-    """
+-    Internal function. See smesolve.
+-    """
+-    res = Result()
+-    res.times = sso.times
+-    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
+-    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
+-    res.measurement = []
+-    res.solver = sso.solver_name
+-    res.ntraj = sso.ntraj
+-    res.num_expect = len(sso.e_ops)
+-
+-    nt = sso.ntraj
+-    task = _single_trajectory
+-    map_kwargs = {'progress_bar': sso.progress_bar}
+-    map_kwargs.update(sso.map_kwargs)
+-    task_args = (sso,)
+-    task_kwargs = {}
+-
+-    results = sso.map_func(task, list(range(sso.ntraj)),
+-                           task_args, task_kwargs, **map_kwargs)
+-    noise = []
+-    for result in results:
+-        states_list, dW, m, expect = result
+-        res.states.append(states_list)
+-        noise.append(dW)
+-        res.measurement.append(m)
+-        res.expect += expect
+-        res.ss += expect * expect
+-    res.noise = np.stack(noise)
+-
+-    if sso.store_all_expect:
+-        paths_expect = []
+-        for result in results:
+-            paths_expect.append(result[3])
+-        res.runs_expect = np.stack(paths_expect)
+-
+-    # average density matrices (vectorized maybe)
+-    # ajgpitch 2019-10-25: np.any(res.states) seems to error
+-    # I guess there may be a potential exception if there are no states?
+-    # store individual trajectory states
+-    res.traj_states = res.states
+-    res.avg_states = None
+-    if options['average_states'] and options['store_states']:
+-        avg_states_list = []
+-        for n in range(len(res.times)):
+-            tslot_states = [res.states[mm][n].data for mm in range(nt)]
+-            if len(tslot_states) > 0:
+-                state = Qobj(np.sum(tslot_states),
+-                             dims=res.states[0][n].dims).unit()
+-                avg_states_list.append(state)
+-        # store average states
+-        res.states = res.avg_states = avg_states_list
+-
+-    # average
+-    res.expect = res.expect / nt
+-
+-    # standard error
+-    if nt > 1:
+-        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
+-    else:
+-        res.se = None
+-
+-    # convert complex data to real if hermitian
+-    res.expect = [np.real(res.expect[n, :])
+-                  if e.isherm else res.expect[n, :]
+-                  for n, e in enumerate(sso.e_ops)]
+-
+-    return res
+-
+-
+-def _single_trajectory(i, sso):
+-    # Only one step?
+-    ssolver = sso.solver_obj()
+-    ssolver.set_solver(sso)
+-    result = ssolver.cy_sesolve_single_trajectory(i)
+-    return result
+-
+-
+-# The code for ssepdpsolve have been moved to the file pdpsolve.
+-# The call is still in stochastic for consistance.
+-def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
+-    """
+-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
+-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
+-    trajectory simulations.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`
+-        System Hamiltonian.
+-
+-    psi0 : :class:`qutip.Qobj`
+-        Initial state vector (ket).
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`
+-        Deterministic collapse operator which will contribute with a standard
+-        Lindblad type of dissipation.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function single
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-
+-    """
+-    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
+-
+-
+-# The code for smepdpsolve have been moved to the file pdpsolve.
+-# The call is still in stochastic for consistance.
+-def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
+-    """
+-    A stochastic (piecewse deterministic process) PDP solver for density matrix
+-    evolution.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`qutip.Qobj`
+-        System Hamiltonian.
+-
+-    rho0 : :class:`qutip.Qobj`
+-        Initial density matrix.
+-
+-    times : *list* / *array*
+-        List of times for :math:`t`. Must be uniformly spaced.
+-
+-    c_ops : list of :class:`qutip.Qobj`
+-        Deterministic collapse operator which will contribute with a standard
+-        Lindblad type of dissipation.
+-
+-    sc_ops : list of :class:`qutip.Qobj`
+-        List of stochastic collapse operators. Each stochastic collapse
+-        operator will give a deterministic and stochastic contribution
+-        to the eqaution of motion according to how the d1 and d2 functions
+-        are defined.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function single
+-        single operator or list of operators for which to evaluate
+-        expectation values.
+-
+-    kwargs : *dictionary*
+-        Optional keyword arguments. See
+-        :class:`qutip.stochastic.StochasticSolverOptions`.
+-
+-    Returns
+-    -------
+-
+-    output: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`.
+-
+-    """
+-    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
++# -*- coding: utf-8 -*-
++
++import numpy as np
++import scipy.sparse as sp
++from .. import (
++    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
++    unstack_columns, liouvillian, lindblad_dissipator,
++)
++from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
++from ._stochastic import (
++    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
++    GenericSSolver, Solvers
++)
++from .solver import Result, SolverOptions, _solver_safety_check
++from .parallel import serial_map
++from ..ui.progressbar import TextProgressBar
++from qutip.core import data as _data
++
++__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
++           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
++           'stochastic_solvers', 'general_stochastic']
++
++
++def stochastic_solvers():
++    # This docstring contains several literal backslash characters inside LaTeX
++    # blocks, but it cannot be declared as a raw string because we also need to
++    # use a line continuation.  At one point we need a restructured text
++    # "definition list", where the heading _must_ be entirely on one line,
++    # however it will violate our line-length reporting if we do that.
++    """
++    This function is purely a reference point for documenting the available
++    stochastic solver methods, and takes no actions.
++
++    Notes
++    -----
++    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
++        euler-maruyama
++            A simple generalization of the Euler method for ordinary
++            differential equations to stochastic differential equations.  Only
++            solver which could take non-commuting ``sc_ops``. *not tested*
++
++            - Order 0.5
++            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
++
++        milstein
++            An order 1.0 strong Taylor scheme.  Better approximate numerical
++            solution to stochastic differential equations.  See eq. (2.9) of
++            chapter 12.2 of [1]_.
++
++            - Order strong 1.0
++            - Code: ``'milstein'`` or ``1.0``
++
++        milstein-imp
++            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
++            scheme for the numerical simulation of stiff stochastic
++            differential equations.
++
++            - Order strong 1.0
++            - Code: ``'milstein-imp'``
++
++        predictor-corrector
++            Generalization of the trapezoidal method to stochastic differential
++            equations. More stable than explicit methods.  See eq. (5.4) of
++            chapter 15.5 of [1]_.
++
++            - Order strong 0.5, weak 1.0
++            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
++              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
++              ``'pc-euler'``
++            - Codes to correct both the stochastic and deterministic parts
++              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
++              ``'pc-euler-2'`` or ``'pred-corr-2'``
++
++        platen
++            Explicit scheme, creates the Milstein using finite differences
++            instead of analytic derivatives. Also contains some higher order
++            terms, thus converges better than Milstein while staying strong
++            order 1.0.  Does not require derivatives, therefore usable by
++            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
++
++            - Order strong 1.0, weak 2.0
++            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
++
++        rouchon
++            Scheme keeping the positivity of the density matrix
++            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
++
++            - Order strong 1.0?
++            - Code: ``'rouchon'`` or ``'Rouchon'``
++
++        taylor1.5
++            Order 1.5 strong Taylor scheme.  Solver with more terms of the
++            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
++            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
++
++            - Order strong 1.5
++            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
++
++        taylor1.5-imp
++            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
++            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
++            (2.18) of chapter 12.2 of [1]_.
++
++            - Order strong 1.5
++            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
++
++        explicit1.5
++            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
++            Taylor scheme using finite difference instead of derivatives.
++            Slower than ``taylor15`` but usable by
++            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
++            [1]_.
++
++            - Order strong 1.5
++            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
++
++        taylor2.0
++            Order 2 strong Taylor scheme.  Solver with more terms of the
++            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
++
++            - Order strong 2.0
++            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
++
++        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
++        and for both heterodyne and homodyne. taylor2.0 only works for 1
++        stochastic operator independent of time with the homodyne method.
++        :func:`~general_stochastic` only accepts the derivative-free
++        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
++
++    Available solvers for :obj:`~photocurrent_sesolve` and \
++:obj:`~photocurrent_mesolve`
++        Photocurrent use ordinary differential equations between
++        stochastic "jump/collapse".
++
++        euler
++            Euler method for ordinary differential equations between jumps.
++            Only one jump per time interval.  Default solver.  See eqs. (4.19)
++            and (4.4) of chapter 4 of [4]_.
++
++            - Order 1.0
++            - Code: ``'euler'``
++
++        predictor–corrector
++            predictor–corrector method (PECE) for ordinary differential
++            equations.  Uses the Poisson distribution to obtain the number of
++            jumps at each timestep.
++
++            - Order 2.0
++            - Code: ``'pred-corr'``
++
++    References
++    ----------
++    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
++       Stochastic Differential Equations*.
++    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
++       Systems*.
++    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
++       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
++       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
++       (2015).
++    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
++       control*.
++    """
++
++
++class StochasticSolverOptions:
++    """Class of options for stochastic solvers such as
++    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
++
++    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
++    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
++    :func:`qutip.stochastic.photocurrent_sesolve` and
++    :func:`qutip.stochastic.photocurrent_mesolve`
++    all take the same keyword arguments as
++    the constructor of these class, and internally they use these arguments to
++    construct an instance of this class, so it is rarely needed to explicitly
++    create an instance of this class.
++
++    Within the attribute list, a ``time_dependent_object`` is either
++
++    - :class:`~qutip.Qobj`: a constant term
++    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
++      where the ``Qobj`` will be multiplied by the time-dependent scalar.
++
++    For more details on all allowed time-dependent objects, see the
++    documentation for :class:`~qutip.QobjEvo`.
++
++    Attributes
++    ----------
++    H : time_dependent_object or list of time_dependent_object
++        System Hamiltonian in standard time-dependent list format.  This is the
++        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
++        If this is a list of elements, they are summed.
++
++    state0 : :class:`qutip.Qobj`
++        Initial state vector (ket) or density matrix.
++
++    times : array_like of float
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of time_dependent_object
++        List of deterministic collapse operators.  Each element of the list is
++        a separate operator; unlike the Hamiltonian, there is no implicit
++        summation over the terms.
++
++    sc_ops : list of time_dependent_object
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the equation of motion according to how the d1 and d2 functions
++        are defined.  Each element of the list is a separate operator, like
++        ``c_ops``.
++
++    e_ops : list of :class:`qutip.Qobj`
++        Single operator or list of operators for which to evaluate
++        expectation values.
++
++    m_ops : list of :class:`qutip.Qobj`
++        List of operators representing the measurement operators. The expected
++        format is a nested list with one measurement operator for each
++        stochastic increament, for each stochastic collapse operator.
++
++    args : dict
++        Dictionary of parameters for time dependent systems.
++
++    tol : float
++        Tolerance of the solver for implicit methods.
++
++    ntraj : int
++        Number of trajectors.
++
++    nsubsteps : int
++        Number of sub steps between each time-spep given in `times`.
++
++    dW_factors : array
++        Array of length len(sc_ops), containing scaling factors for each
++        measurement operator in m_ops.
++
++    solver : string
++        Name of the solver method to use for solving the stochastic
++        equations. Valid values are:
++
++        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
++        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
++        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
++        - order 2 algorithms: 'taylor2.0'
++
++        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
++        for a description of the solvers.  Implicit methods can adjust
++        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
++
++    method : string ('homodyne', 'heterodyne')
++        The name of the type of measurement process that give rise to the
++        stochastic equation to solve.
++
++    store_all_expect : bool (default False)
++        Whether or not to store the e_ops expect values for all paths.
++
++    store_measurement : bool (default False)
++        Whether or not to store the measurement results in the
++        :class:`qutip.solver.Result` instance returned by the solver.
++
++    noise : int, or 1D array of int, or 4D array of float
++        - int : seed of the noise
++        - 1D array : length = ntraj, seeds for each trajectories.
++        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
++          Vector for the noise, the len of the last dimensions is doubled for
++          solvers of order 1.5. This corresponds to results.noise.
++
++    noiseDepth : int
++        Number of terms kept of the truncated series used to create the
++        noise used by taylor2.0 solver.
++
++    normalize : bool
++        (default True for (photo)ssesolve, False for (photo)smesolve)
++        Whether or not to normalize the wave function during the evolution.
++        Normalizing density matrices introduce numerical errors.
++
++    options : :class:`qutip.solver.SolverOptions`
++        Generic solver options. Only options['average_states'] and
++        options['store_states'] are used.
++
++    map_func: function
++        A map function or managing the calls to single-trajactory solvers.
++
++    map_kwargs: dictionary
++        Optional keyword arguments to the map_func function function.
++
++    progress_bar : :class:`qutip.ui.BaseProgressBar`
++        Optional progress bar class instance.
++    """
++    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
++                 e_ops=[], m_ops=None, store_all_expect=False,
++                 store_measurement=False, dW_factors=None,
++                 solver=None, method="homodyne", normalize=None,
++                 times=None, nsubsteps=1, ntraj=1, tol=None,
++                 generate_noise=None, noise=None,
++                 progress_bar=None, map_func=None, map_kwargs=None,
++                 args={}, options=None, noiseDepth=20):
++
++        if options is None:
++            options = SolverOptions()
++
++        if progress_bar is None:
++            progress_bar = TextProgressBar()
++
++        # System
++        # Cast to QobjEvo so the code has only one version for both the
++        # constant and time-dependent case.
++        self.me = me
++
++        if H is not None:
++            msg = "The Hamiltonian format is not valid. "
++            try:
++                self.H = QobjEvo(H, args=args, tlist=times)
++            except Exception as e:
++                raise ValueError(msg + str(e)) from e
++        else:
++            self.H = H
++
++        if sc_ops:
++            msg = ("The sc_ops format is not valid. Options are "
++                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
++            try:
++                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
++                               for op in sc_ops]
++            except Exception as e:
++                raise ValueError(msg + str(e)) from e
++        else:
++            self.sc_ops = sc_ops
++
++        if c_ops:
++            msg = ("The c_ops format is not valid. Options are "
++                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
++            try:
++                self.c_ops = [QobjEvo(op, args=args, tlist=times)
++                              for op in c_ops]
++            except Exception as e:
++                raise ValueError(msg + str(e)) from e
++        else:
++            self.c_ops = c_ops
++
++        self.state0 = state0
++        self.rho0 = stack_columns(state0.full()).ravel()
++
++        # Observation
++
++        for e_op in e_ops:
++            if (
++                isinstance(e_op, Qobj)
++                and self.H is not None
++                and e_op.dims[1] != self.H.dims[0]
++            ):
++                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
++                                f"with the system's ({self.H.dims})")
++        self.e_ops = e_ops
++        self.m_ops = m_ops
++        self.store_measurement = store_measurement
++        self.store_all_expect = store_all_expect
++        self.store_states = options['store_states']
++        self.dW_factors = dW_factors
++
++        # Solver
++        self.solver = solver
++        self.method = method
++        if normalize is None and me:
++            self.normalize = 0
++        elif normalize is None and not me:
++            self.normalize = 1
++        elif normalize:
++            self.normalize = 1
++        else:
++            self.normalize = 0
++
++        self.times = times
++        self.nsubsteps = nsubsteps
++        self.dt = (times[1] - times[0]) / self.nsubsteps
++        self.ntraj = ntraj
++        if tol is not None:
++            self.tol = tol
++        elif "tol" in args:
++            self.tol = args["tol"]
++        else:
++            self.tol = 1e-7
++
++        # Noise
++        if noise is not None:
++            if isinstance(noise, int):
++                # noise contain a seed
++                np.random.seed(noise)
++                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
++            noise = np.array(noise)
++            if len(noise.shape) == 1:
++                if noise.shape[0] < ntraj:
++                    raise ValueError("'noise' does not have enought seeds " +
++                                     "len(noise) >= ntraj")
++                # numpy seed must be between 0 and 2**32-1
++                # 'u4': unsigned 32bit int
++                self.noise = noise.astype("u4")
++                self.noise_type = 0
++
++            elif len(noise.shape) == 4:
++                # taylor case not included
++                dw_len = (2 if method == "heterodyne" else 1)
++                dw_len_str = (" * 2" if method == "heterodyne" else "")
++                msg = "Incorrect shape for 'noise': "
++                if noise.shape[0] < ntraj:
++                    raise ValueError(msg + "shape[0] >= ntraj")
++                if noise.shape[1] < len(times):
++                    raise ValueError(msg + "shape[1] >= len(times)")
++                if noise.shape[2] < nsubsteps:
++                    raise ValueError(msg + "shape[2] >= nsubsteps")
++                if noise.shape[3] < len(self.sc_ops) * dw_len:
++                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
++                                     dw_len_str)
++                self.noise_type = 1
++                self.noise = noise
++
++        else:
++            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
++            self.noise_type = 0
++
++        # Map
++        self.progress_bar = progress_bar
++        if self.ntraj > 1 and map_func:
++            self.map_func = map_func
++        else:
++            self.map_func = serial_map
++        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
++
++        # Other
++        self.options = options
++        self.args = args
++        self.set_solver()
++        self.p = noiseDepth
++
++    def set_solver(self):
++        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
++            self.solver_code = 50
++            self.solver = 'euler-maruyama'
++        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
++            self.solver_code = 100
++            self.solver = 'platen'
++        elif self.solver in ['pred-corr', 'predictor-corrector',
++                             'pc-euler', 101]:
++            self.solver_code = 101
++            self.solver = 'pred-corr'
++        elif self.solver in ['milstein', 102, 1.0]:
++            self.solver_code = 102
++            self.solver = 'milstein'
++        elif self.solver in ['milstein-imp', 103]:
++            self.solver_code = 103
++            self.solver = 'milstein-imp'
++        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
++            self.solver_code = 104
++            self.solver = 'pred-corr-2'
++        elif self.solver in ['Rouchon', 'rouchon', 120]:
++            self.solver_code = 120
++            self.solver = 'rouchon'
++            if not all((op.isconstant for op in self.sc_ops)):
++                raise ValueError("Rouchon only works with constant sc_ops")
++        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
++            self.solver_code = 150
++            self.solver = 'explicit1.5'
++        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
++            self.solver_code = 152
++            self.solver = 'taylor1.5'
++        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
++            self.solver_code = 153
++            self.solver = 'taylor1.5-imp'
++        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
++            self.solver_code = 202
++            self.solver = 'taylor2.0'
++            if not len(self.sc_ops) == 1 or \
++                    not self.sc_ops[0].isconstant or \
++                    not self.method == "homodyne":
++                raise ValueError(
++                    "Taylor2.0 only works with 1 constant sc_ops and for"
++                    " homodyne method"
++                )
++        else:
++            known = [
++                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
++                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
++                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
++            ]
++            raise ValueError("The solver should be one of {!r}".format(known))
++
++
++class StochasticSolverOptionsPhoto(StochasticSolverOptions):
++    """
++    Attributes
++    ----------
++
++    solver : string
++        Name of the solver method to use for solving the evolution
++        of the system.*
++        order 1 algorithms: 'euler'
++        order 2 algorithms: 'pred-corr'
++        In photocurrent evolution
++    """
++    def set_solver(self):
++        if self.solver in [None, 'euler', 1, 60]:
++            self.solver_code = 60
++            self.solver = 'euler'
++        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
++            self.solver_code = 110
++            self.solver = 'pred-corr'
++        else:
++            raise Exception("The solver should be one of " +
++                            "[None, 'euler', 'predictor-corrector']")
++
++
++def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
++             _safe_mode=True, args={}, **kwargs):
++    """
++    Solve stochastic master equation. Dispatch to specific solvers
++    depending on the value of the `solver` keyword argument.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`, or time dependent system.
++        System Hamiltonian.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    rho0 : :class:`qutip.Qobj`
++        Initial density matrix or state vector (ket).
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
++        Deterministic collapse operator which will contribute with a standard
++        Lindblad type of dissipation.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the eqaution of motion according to how the d1 and d2 functions
++        are defined.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    e_ops : list of :class:`qutip.Qobj`
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++
++    """
++    if "method" in kwargs and kwargs["method"] == "photocurrent":
++        print("stochastic solver with photocurrent method has been moved to "
++              "it's own function: photocurrent_mesolve")
++        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
++                                    e_ops=e_ops, _safe_mode=_safe_mode,
++                                    args=args, **kwargs)
++    if isket(rho0):
++        rho0 = ket2dm(rho0)
++
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = [e for e in e_ops.values()]
++    else:
++        e_ops_dict = None
++
++    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
++                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
++                                  args=args, **kwargs)
++
++    if _safe_mode:
++        _safety_checks(sso)
++
++    if sso.solver_code == 120:
++        return _positive_map(sso, e_ops_dict)
++
++    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
++    if sso.method == 'homodyne' or sso.method is None:
++        if sso.m_ops is None:
++            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
++        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
++        if not isinstance(sso.dW_factors, list):
++            sso.dW_factors = [1] * len(sso.m_ops)
++        elif len(sso.dW_factors) != len(sso.m_ops):
++            raise Exception("The len of dW_factors is not the same as m_ops")
++
++    elif sso.method == 'heterodyne':
++        if sso.m_ops is None:
++            m_ops = []
++        sso.sops = []
++        for c in sso.sc_ops:
++            if sso.m_ops is None:
++                m_ops += [c + c.dag(), -1j * (c - c.dag())]
++            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
++                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
++        sso.m_ops = m_ops
++        if not isinstance(sso.dW_factors, list):
++            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
++        elif len(sso.dW_factors) == len(sso.m_ops):
++            pass
++        elif len(sso.dW_factors) == len(sso.sc_ops):
++            dW_factors = []
++            for fact in sso.dW_factors:
++                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
++            sso.dW_factors = dW_factors
++        elif len(sso.dW_factors) != len(sso.m_ops):
++            raise Exception("The len of dW_factors is not the same as sc_ops")
++
++    elif sso.method == "photocurrent":
++        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
++
++    else:
++        raise Exception("The method must be one of None, homodyne, heterodyne")
++
++    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
++    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
++
++    if sso.solver_code in [103, 153]:
++        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
++
++    sso.solver_obj = SMESolver
++    sso.solver_name = "smesolve_" + sso.solver
++
++    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++    return res
++
++
++def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
++             _safe_mode=True, args={}, **kwargs):
++    """
++    Solve stochastic schrodinger equation. Dispatch to specific solvers
++    depending on the value of the `solver` keyword argument.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`, or time dependent system.
++        System Hamiltonian.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    psi0 : :class:`qutip.Qobj`
++        State vector (ket).
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the eqaution of motion according to how the d1 and d2 functions
++        are defined.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    e_ops : list of :class:`qutip.Qobj`
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++    if "method" in kwargs and kwargs["method"] == "photocurrent":
++        print("stochastic solver with photocurrent method has been moved to "
++              "it's own function: photocurrent_sesolve")
++        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
++                                    e_ops=e_ops, _safe_mode=_safe_mode,
++                                    args=args, **kwargs)
++
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = [e for e in e_ops.values()]
++    else:
++        e_ops_dict = None
++
++    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
++                                  sc_ops=sc_ops, e_ops=e_ops,
++                                  args=args, **kwargs)
++
++    if _safe_mode:
++        _safety_checks(sso)
++
++    if sso.solver_code == 120:
++        raise Exception("rouchon only work with smesolve")
++
++    if sso.method == 'homodyne' or sso.method is None:
++        if sso.m_ops is None:
++            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
++        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
++        if not isinstance(sso.dW_factors, list):
++            sso.dW_factors = [1] * len(sso.sops)
++        elif len(sso.dW_factors) != len(sso.sops):
++            raise Exception("The len of dW_factors is not the same as sc_ops")
++
++    elif sso.method == 'heterodyne':
++        if sso.m_ops is None:
++            m_ops = []
++        sso.sops = []
++        for c in sso.sc_ops:
++            if sso.m_ops is None:
++                m_ops += [c + c.dag(), -1j * (c - c.dag())]
++            c1 = c / np.sqrt(2)
++            c2 = c * (-1j / np.sqrt(2))
++            sso.sops += [[c1, c1 + c1.dag()],
++                         [c2, c2 + c2.dag()]]
++        sso.m_ops = m_ops
++        if not isinstance(sso.dW_factors, list):
++            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
++        elif len(sso.dW_factors) == len(sso.sc_ops):
++            dW_factors = []
++            for fact in sso.dW_factors:
++                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
++            sso.dW_factors = dW_factors
++        elif len(sso.dW_factors) != len(sso.sops):
++            raise Exception("The len of dW_factors is not the same as sc_ops")
++
++    elif sso.method == "photocurrent":
++        NotImplementedError("Moved to 'photocurrent_sesolve'")
++
++    else:
++        raise Exception("The method must be one of None, homodyne, heterodyne")
++
++    sso.LH = sso.H * (-1j * sso.dt)
++    for ops in sso.sops:
++        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
++
++    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
++    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
++
++    sso.solver_obj = SSESolver
++    sso.solver_name = "ssesolve_" + sso.solver
++
++    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++
++    return res
++
++
++def _positive_map(sso, e_ops_dict):
++    if sso.method == 'homodyne' or sso.method is None:
++        sops = sso.sc_ops
++        if sso.m_ops is None:
++            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
++        if not isinstance(sso.dW_factors, list):
++            sso.dW_factors = [1] * len(sops)
++        elif len(sso.dW_factors) != len(sops):
++            raise Exception("The len of dW_factors is not the same as sc_ops")
++
++    elif sso.method == 'heterodyne':
++        if sso.m_ops is None:
++            m_ops = []
++        sops = []
++        for c in sso.sc_ops:
++            if sso.m_ops is None:
++                m_ops += [c + c.dag(), -1j * (c - c.dag())]
++            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
++        sso.m_ops = m_ops
++        if not isinstance(sso.dW_factors, list):
++            sso.dW_factors = [np.sqrt(2)] * len(sops)
++        elif len(sso.dW_factors) == len(sso.sc_ops):
++            dW_factors = []
++            for fact in sso.dW_factors:
++                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
++            sso.dW_factors = dW_factors
++        elif len(sso.dW_factors) != len(sops):
++            raise Exception("The len of dW_factors is not the same as sc_ops")
++    else:
++        raise Exception("The method must be one of homodyne or heterodyne")
++
++    LH = 1 - (sso.H * 1j * sso.dt)
++    sso.pp = spre(sso.H) * 0
++    sso.sops = []
++    sso.preops = []
++    sso.postops = []
++    sso.preops2 = []
++    sso.postops2 = []
++
++    def _prespostdag(op):
++        return spre(op) * spost(op.dag())
++
++    for op in sso.c_ops:
++        LH += op.dag() @ op * (-sso.dt * 0.5)
++        sso.pp += spre(op) * spost(op.dag()) * sso.dt
++
++    for i, op in enumerate(sops):
++        LH += (-sso.dt * 0.5) * op.dag() @ op
++        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
++        sso.preops += [spre(op)]
++        sso.postops += [spost(op.dag())]
++        for op2 in sops[i:]:
++            sso.preops2 += [spre(op * op2)]
++            sso.postops2 += [spost(op.dag() * op2.dag())]
++
++    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
++    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
++    sso.preLH = spre(LH)
++    sso.postLH = spost(LH.dag())
++
++    sso.solver_obj = PmSMESolver
++    sso.solver_name = "smesolve_" + sso.solver
++    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++
++    return res
++
++
++def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
++                         _safe_mode=True, args={}, **kwargs):
++    """
++    Solve stochastic master equation using the photocurrent method.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`, or time dependent system.
++        System Hamiltonian.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    rho0 : :class:`qutip.Qobj`
++        Initial density matrix or state vector (ket).
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
++        Deterministic collapse operator which will contribute with a standard
++        Lindblad type of dissipation.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the eqaution of motion according to how the d1 and d2 functions
++        are defined.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function single
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++    if isket(rho0):
++        rho0 = ket2dm(rho0)
++
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = [e for e in e_ops.values()]
++    else:
++        e_ops_dict = None
++
++    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
++                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
++                                       args=args, **kwargs)
++
++    if _safe_mode:
++        _safety_checks(sso)
++
++    if sso.m_ops is None:
++        sso.m_ops = [op * 0 for op in sso.sc_ops]
++    if not isinstance(sso.dW_factors, list):
++        sso.dW_factors = [1] * len(sso.sc_ops)
++    elif len(sso.dW_factors) != len(sso.sc_ops):
++        raise Exception("The len of dW_factors is not the same as sc_ops")
++
++    sso.solver_obj = PcSMESolver
++    sso.solver_name = "photocurrent_mesolve"
++    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
++
++    def _prespostdag(op):
++        return spre(op) * spost(op.dag())
++
++    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
++                 spre(op.dag() @ op),
++                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
++    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
++    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
++
++    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
++    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++
++    return res
++
++
++def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
++                         _safe_mode=True, args={}, **kwargs):
++    """
++    Solve stochastic schrodinger equation using the photocurrent method.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`, or time dependent system.
++        System Hamiltonian.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    psi0 : :class:`qutip.Qobj`
++        Initial state vector (ket).
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the eqaution of motion according to how the d1 and d2 functions
++        are defined.
++        Can depend on time, see StochasticSolverOptions help for format.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function single
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = list(e_ops.values())
++    else:
++        e_ops_dict = None
++
++    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
++                                       sc_ops=sc_ops, e_ops=e_ops,
++                                       args=args, **kwargs)
++
++    if _safe_mode:
++        _safety_checks(sso)
++
++    if sso.m_ops is None:
++        sso.m_ops = [op * 0 for op in sso.sc_ops]
++    if not isinstance(sso.dW_factors, list):
++        sso.dW_factors = [1] * len(sso.sc_ops)
++    elif len(sso.dW_factors) != len(sso.sc_ops):
++        raise Exception("The len of dW_factors is not the same as sc_ops")
++
++    sso.solver_obj = PcSSESolver
++    sso.solver_name = "photocurrent_sesolve"
++    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
++    sso.LH = sso.H * (-1j*sso.dt)
++    for ops in sso.sops:
++        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
++    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
++    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
++
++    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
++    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++
++    return res
++
++
++def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
++                       _safe_mode=True, len_d2=1, args={}, **kwargs):
++    """
++    Solve stochastic general equation. Dispatch to specific solvers
++    depending on the value of the `solver` keyword argument.
++
++
++    Parameters
++    ----------
++
++    state0 : :class:`qutip.Qobj`
++        Initial state vector (ket) or density matrix as a vector.
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    d1 : function, callable class
++        Function representing the deterministic evolution of the system.
++
++        def d1(time (double), state (as a np.array vector)):
++            return 1d np.array
++
++    d2 : function, callable class
++        Function representing the stochastic evolution of the system.
++
++        def d2(time (double), state (as a np.array vector)):
++            return 2d np.array (N_sc_ops, len(state0))
++
++    len_d2 : int
++        Number of output vector produced by d2
++
++    e_ops : list of :class:`qutip.Qobj`
++        single operator or list of operators for which to evaluate
++        expectation values.
++        Must be a superoperator if the state vector is a density matrix.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++        An instance of the class :class:`qutip.solver.Result`.
++    """
++
++    if isinstance(e_ops, dict):
++        e_ops_dict = e_ops
++        e_ops = [e for e in e_ops.values()]
++    else:
++        e_ops_dict = None
++
++    if "solver" not in kwargs:
++        kwargs["solver"] = 50
++
++    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
++                                  e_ops=e_ops, args=args, **kwargs)
++    if sso.solver_code not in [50, 100, 150]:
++        raise ValueError("Only Euler, platen, platen15 can be " +
++                         "used for the general stochastic solver.")
++
++    sso.d1 = d1
++    sso.d2 = d2
++    if _safe_mode:
++        # This state0_vec is computed as stack_columns(state0.full()).ravel()
++        # in the sso init.
++        state0_vec = sso.rho0
++        l_vec = state0_vec.shape[0]
++        try:
++            out_d1 = d1(0., sso.rho0)
++        except Exception as e:
++            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
++                               str(e)) from e
++        try:
++            out_d2 = d2(0., sso.rho0)
++        except Exception as e:
++            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
++                               str(e)) from e
++
++        msg_d1 = ("d1 must return an 1d numpy array with the same number "
++                  "of elements as the initial state as a vector.")
++        if not isinstance(out_d1, np.ndarray):
++            raise TypeError(msg_d1)
++        if (out_d1.ndim != 1
++                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
++            raise ValueError(msg_d1)
++
++        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
++                  "with the shape (len_d2, len(state0_vec) ).")
++        if not isinstance(out_d2, np.ndarray):
++            raise TypeError(msg_d2)
++        if (out_d2.ndim != 2
++                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
++            raise ValueError(msg_d2)
++        if out_d1.dtype != np.dtype('complex128') or \
++           out_d2.dtype != np.dtype('complex128'):
++            raise ValueError("Safety check: d1 and d2 must return " +
++                             "complex numpy array.")
++        msg_e_ops = ("Safety check: The shape of the e_ops "
++                     "does not fit the intial state.")
++        for op in sso.e_ops:
++            shape_op = op.shape
++            if sso.me:
++                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
++                    raise ValueError(msg_e_ops)
++            else:
++                if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                    raise ValueError(msg_e_ops +
++                                     " Expecting e_ops as superoperators.")
++
++    sso.m_ops = []
++    sso.cm_ops = []
++    if sso.store_measurement:
++        if not m_ops:
++            raise ValueError("General stochastic needs explicit " +
++                             "m_ops to store measurement.")
++        sso.m_ops = m_ops
++        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
++        if sso.dW_factors is None:
++            sso.dW_factors = [1.] * len(sso.m_ops)
++        elif len(sso.dW_factors) == 1:
++            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
++        elif len(sso.dW_factors) != len(sso.m_ops):
++            raise ValueError("The number of dW_factors must fit" +
++                             " the number of m_ops.")
++
++    if sso.dW_factors is None:
++        sso.dW_factors = [1.] * len_d2
++    sso.sops = [None] * len_d2
++    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
++
++    sso.solver_obj = GenericSSolver
++    sso.solver_name = "general_stochastic_solver_" + sso.solver
++
++    ssolver = GenericSSolver()
++    # ssolver.set_data(sso)
++    ssolver.set_solver(sso)
++
++    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
++
++    if e_ops_dict:
++        res.expect = {e: res.expect[n]
++                      for n, e in enumerate(e_ops_dict.keys())}
++
++    return res
++
++
++def _safety_checks(sso):
++    l_vec = sso.rho0.shape[0]
++    if sso.H.issuper:
++        if not sso.me:
++            raise ValueError(
++                "Given a Liouvillian for a Schrödinger equation problem."
++            )
++        shape_op = sso.H.shape
++        if shape_op[0] != l_vec or shape_op[1] != l_vec:
++            raise Exception("The size of the hamiltonian does "
++                            "not fit the intial state")
++    else:
++        shape_op = sso.H.shape
++        if sso.me:
++            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
++                raise Exception("The size of the hamiltonian does "
++                                "not fit the intial state")
++        else:
++            if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                raise Exception("The size of the hamiltonian does "
++                                "not fit the intial state")
++
++    for op in sso.sc_ops:
++        if op.issuper:
++            if not sso.me:
++                raise ValueError(
++                    "Given a Liouvillian for a Schrödinger equation problem."
++                )
++            shape_op = op.shape
++            if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                raise Exception("The size of the sc_ops does "
++                                "not fit the intial state")
++        else:
++            shape_op = op.shape
++            if sso.me:
++                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
++                    raise Exception("The size of the sc_ops does "
++                                    "not fit the intial state")
++            else:
++                if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                    raise Exception("The size of the sc_ops does "
++                                    "not fit the intial state")
++
++    for op in sso.c_ops:
++        if op.issuper:
++            if not sso.me:
++                raise ValueError(
++                    "Given a Liouvillian for a Schrödinger equation problem."
++                )
++            shape_op = op.shape
++            if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                raise Exception("The size of the c_ops does "
++                                "not fit the intial state")
++        else:
++            shape_op = op.shape
++            if sso.me:
++                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
++                    raise Exception("The size of the c_ops does "
++                                    "not fit the intial state")
++            else:
++                if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                    raise Exception("The size of the c_ops does "
++                                    "not fit the intial state")
++
++    for op in sso.e_ops:
++        shape_op = op.shape
++        if sso.me:
++            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
++                raise Exception("The size of the e_ops does "
++                                "not fit the intial state")
++        else:
++            if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                raise Exception("The size of the e_ops does "
++                                "not fit the intial state")
++
++    if sso.m_ops is not None:
++        for op in sso.m_ops:
++            shape_op = op.shape
++            if sso.me:
++                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
++                    raise Exception("The size of the m_ops does "
++                                    "not fit the intial state")
++            else:
++                if shape_op[0] != l_vec or shape_op[1] != l_vec:
++                    raise Exception("The size of the m_ops does "
++                                    "not fit the intial state")
++
++
++def _sesolve_generic(sso, options, progress_bar):
++    """
++    Internal function. See smesolve.
++    """
++    res = Result()
++    res.times = sso.times
++    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
++    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
++    res.measurement = []
++    res.solver = sso.solver_name
++    res.ntraj = sso.ntraj
++    res.num_expect = len(sso.e_ops)
++
++    nt = sso.ntraj
++    task = _single_trajectory
++    map_kwargs = {'progress_bar': sso.progress_bar}
++    map_kwargs.update(sso.map_kwargs)
++    task_args = (sso,)
++    task_kwargs = {}
++
++    results = sso.map_func(task, list(range(sso.ntraj)),
++                           task_args, task_kwargs, **map_kwargs)
++    noise = []
++    for result in results:
++        states_list, dW, m, expect = result
++        res.states.append(states_list)
++        noise.append(dW)
++        res.measurement.append(m)
++        res.expect += expect
++        res.ss += expect * expect
++    res.noise = np.stack(noise)
++
++    if sso.store_all_expect:
++        paths_expect = []
++        for result in results:
++            paths_expect.append(result[3])
++        res.runs_expect = np.stack(paths_expect)
++
++    # average density matrices (vectorized maybe)
++    # ajgpitch 2019-10-25: np.any(res.states) seems to error
++    # I guess there may be a potential exception if there are no states?
++    # store individual trajectory states
++    res.traj_states = res.states
++    res.avg_states = None
++    if options['average_states'] and options['store_states']:
++        avg_states_list = []
++        for n in range(len(res.times)):
++            tslot_states = [res.states[mm][n].data for mm in range(nt)]
++            if len(tslot_states) > 0:
++                state = Qobj(np.sum(tslot_states),
++                             dims=res.states[0][n].dims).unit()
++                avg_states_list.append(state)
++        # store average states
++        res.states = res.avg_states = avg_states_list
++
++    # average
++    res.expect = res.expect / nt
++
++    # standard error
++    if nt > 1:
++        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
++    else:
++        res.se = None
++
++    # convert complex data to real if hermitian
++    res.expect = [np.real(res.expect[n, :])
++                  if e.isherm else res.expect[n, :]
++                  for n, e in enumerate(sso.e_ops)]
++
++    return res
++
++
++def _single_trajectory(i, sso):
++    # Only one step?
++    ssolver = sso.solver_obj()
++    ssolver.set_solver(sso)
++    result = ssolver.cy_sesolve_single_trajectory(i)
++    return result
++
++
++# The code for ssepdpsolve have been moved to the file pdpsolve.
++# The call is still in stochastic for consistance.
++def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
++    """
++    A stochastic (piecewse deterministic process) PDP solver for wavefunction
++    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
++    trajectory simulations.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`
++        System Hamiltonian.
++
++    psi0 : :class:`qutip.Qobj`
++        Initial state vector (ket).
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`
++        Deterministic collapse operator which will contribute with a standard
++        Lindblad type of dissipation.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function single
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++
++    """
++    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
++
++
++# The code for smepdpsolve have been moved to the file pdpsolve.
++# The call is still in stochastic for consistance.
++def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
++    """
++    A stochastic (piecewse deterministic process) PDP solver for density matrix
++    evolution.
++
++    Parameters
++    ----------
++
++    H : :class:`qutip.Qobj`
++        System Hamiltonian.
++
++    rho0 : :class:`qutip.Qobj`
++        Initial density matrix.
++
++    times : *list* / *array*
++        List of times for :math:`t`. Must be uniformly spaced.
++
++    c_ops : list of :class:`qutip.Qobj`
++        Deterministic collapse operator which will contribute with a standard
++        Lindblad type of dissipation.
++
++    sc_ops : list of :class:`qutip.Qobj`
++        List of stochastic collapse operators. Each stochastic collapse
++        operator will give a deterministic and stochastic contribution
++        to the eqaution of motion according to how the d1 and d2 functions
++        are defined.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function single
++        single operator or list of operators for which to evaluate
++        expectation values.
++
++    kwargs : *dictionary*
++        Optional keyword arguments. See
++        :class:`qutip.stochastic.StochasticSolverOptions`.
++
++    Returns
++    -------
++
++    output: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`.
++
++    """
++    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
+diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
+index 99d84ccd..0512198f 100644
+--- a/qutip/solver/__init__.py
++++ b/qutip/solver/__init__.py
+@@ -1,18 +1,18 @@
+-from .result import *
+-from .options import *
+-import qutip.solver.integrator
+-from .integrator import IntegratorException
+-from .sesolve import *
+-from .mesolve import *
+-from .mcsolve import *
+-from .propagator import *
+-from .scattering import *
+-from .correlation import *
+-from .spectrum import *
+-from .floquet import *
+-from .floquet_bwcomp import *
+-from .steadystate import *
+-from .countstat import *
+-from .brmesolve import *
+-from .krylovsolve import *
+-from .parallel import *
++from .result import *
++from .options import *
++import qutip.solver.integrator
++from .integrator import IntegratorException
++from .sesolve import *
++from .mesolve import *
++from .mcsolve import *
++from .propagator import *
++from .scattering import *
++from .correlation import *
++from .spectrum import *
++from .floquet import *
++from .floquet_bwcomp import *
++from .steadystate import *
++from .countstat import *
++from .brmesolve import *
++from .krylovsolve import *
++from .parallel import *
+diff --git a/qutip/solver/brmesolve.py b/qutip/solver/brmesolve.py
+index 7bfc8b27..8da77494 100644
+--- a/qutip/solver/brmesolve.py
++++ b/qutip/solver/brmesolve.py
+@@ -1,362 +1,362 @@
+-"""
+-This module provides solvers for the Lindblad master equation and von Neumann
+-equation.
+-"""
+-
+-__all__ = ['brmesolve', 'BRSolver']
+-
+-import numpy as np
+-import inspect
+-from time import time
+-from .. import Qobj, QobjEvo, coefficient, Coefficient
+-from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
+-from ..core.cy.coefficient import InterCoefficient
+-from ..core import data as _data
+-from .solver_base import Solver
+-from .options import _SolverOptions
+-
+-
+-def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
+-              args={}, sec_cutoff=0.1, options=None):
+-    """
+-    Solves for the dynamics of a system using the Bloch-Redfield master
+-    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
+-    their associated spectral functions, as well as possible Lindblad collapse
+-    operators.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    psi0: Qobj
+-        Initial density matrix or state vector (ket).
+-
+-    tlist : array_like
+-        List of times for evaluating evolution
+-
+-    a_ops : list of (a_op, spectra)
+-        Nested list of system operators that couple to the environment,
+-        and the corresponding bath spectra.
+-
+-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+-            The operator coupling to the environment. Must be hermitian.
+-
+-        spectra : :class:`Coefficient`, str, func
+-            The corresponding bath spectral responce.
+-            Can be a `Coefficient` using an 'w' args, a function of the
+-            frequence or a string. Coefficient build from a numpy array are
+-            understood as a function of ``w`` instead of ``t``. Function are
+-            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
+-
+-            The spectra function can depend on ``t`` if the corresponding
+-            ``a_op`` is a :class:`QobjEvo`.
+-
+-        Example:
+-
+-        .. code-block::
+-
+-            a_ops = [
+-                (a+a.dag(), ('w>0', args={"w": 0})),
+-                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
+-                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
+-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+-            ]
+-
+-        .. note:
+-            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
+-                ``spline = qutip.coefficient(array, tlist=times)``
+-
+-            Whether the ``a_ops`` is time dependent is decided by the type of
+-            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
+-            of the spectra.
+-
+-    e_ops : list of :class:`Qobj` / callback function
+-        Single operator or list of operators for which to evaluate
+-        expectation values or callable or list of callable.
+-        Callable signature must be, `f(t: float, state: Qobj)`.
+-        See :func:`expect` for more detail of operator expectation
+-
+-    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+-        List of collapse operators.
+-
+-    args : dict
+-        Dictionary of parameters for time-dependent Hamiltonians and
+-        collapse operators. The key ``w`` is reserved for the spectra function.
+-
+-    sec_cutoff : float {0.1}
+-        Cutoff for secular approximation. Use ``-1`` if secular approximation
+-        is not used when evaluating bath-coupling terms.
+-
+-    options : None / dict
+-        Dictionary of options for the solver.
+-
+-        - store_final_state : bool
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, None
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - normalize_output : bool
+-          Normalize output state to hide ODE numerical errors.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - tensor_type : str ['sparse', 'dense', 'data']
+-          Which data type to use when computing the brtensor.
+-          With a cutoff 'sparse' is usually the most efficient.
+-        - sparse_eigensolver : bool {False}
+-          Whether to use the sparse eigensolver
+-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+-          Which differential equation integration method to use.
+-        - atol, rtol : float
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps :
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - max_step : float, 0
+-          Maximum lenght of one internal step. When using pulses, it should be
+-          less than half the width of the thinnest pulse.
+-
+-        Other options could be supported depending on the integration method,
+-        see `Integrator <./classes.html#classes-ode>`_.
+-
+-    Returns
+-    -------
+-    result: :class:`qutip.solver.Result`
+-
+-        An instance of the class :class:`qutip.solver.Result`, which contains
+-        either an array of expectation values, for operators given in e_ops,
+-        or a list of states for the times specified by `tlist`.
+-
+-    .. note:
+-        The option ``operator_data_type`` is used to determine in which format
+-        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
+-        for dense array. With 'data', it will try to use the same data type as
+-        the ``a_ops``, but it is usually less efficient than manually choosing
+-        it.
+-    """
+-    H = QobjEvo(H, args=args, tlist=tlist)
+-
+-    c_ops = c_ops if c_ops is not None else []
+-    if not isinstance(c_ops, (list, tuple)):
+-        c_ops = [c_ops]
+-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+-
+-    new_a_ops = []
+-    for (a_op, spectra) in a_ops:
+-        aop = QobjEvo(a_op, args=args, tlist=tlist)
+-        if isinstance(spectra, str):
+-            new_a_ops.append(
+-                (aop, coefficient(spectra, args={**args, 'w':0})))
+-        elif isinstance(spectra, InterCoefficient):
+-            new_a_ops.append((aop, SpectraCoefficient(spectra)))
+-        elif isinstance(spectra, Coefficient):
+-            new_a_ops.append((aop, spectra))
+-        elif callable(spectra):
+-            sig = inspect.signature(spectra)
+-            if tuple(sig.parameters.keys()) == ("w",):
+-                spec = SpectraCoefficient(coefficient(spectra))
+-            else:
+-                spec = coefficient(spectra, args={**args, 'w':0})
+-            new_a_ops.append((aop, spec))
+-        else:
+-            raise TypeError("a_ops's spectra not known")
+-
+-    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
+-
+-    return solver.run(psi0, tlist, e_ops=e_ops)
+-
+-
+-class BRSolver(Solver):
+-    """
+-    Bloch Redfield equation evolution of a density matrix for a given
+-    Hamiltonian and set of bath coupling operators.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    a_ops : list of (a_op, spectra)
+-        Nested list of system operators that couple to the environment,
+-        and the corresponding bath spectra.
+-
+-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+-            The operator coupling to the environment. Must be hermitian.
+-
+-        spectra : :class:`Coefficient`
+-            The corresponding bath spectra. As a `Coefficient` using an 'w'
+-            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
+-            :class:`SpectraCoefficient` can be used to conver a coefficient
+-            depending on ``t`` to one depending on ``w``.
+-
+-        Example:
+-
+-        .. code-block::
+-
+-            a_ops = [
+-                (a+a.dag(), coefficient('w>0', args={'w':0})),
+-                (QobjEvo([b+b.dag(), lambda t: ...]),
+-                 coefficient(lambda t, w: ...), args={"w": 0}),
+-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+-            ]
+-
+-    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
+-        Single collapse operator, or list of collapse operators, or a list
+-        of Lindblad dissipator. None is equivalent to an empty list.
+-
+-    options : dict, optional
+-        Options for the solver, see :obj:`BRSolver.options` and
+-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+-
+-    sec_cutoff : float {0.1}
+-        Cutoff for secular approximation. Use ``-1`` if secular approximation
+-        is not used when evaluating bath-coupling terms.
+-
+-    attributes
+-    ----------
+-    stats: dict
+-        Diverse diagnostic statistics of the evolution.
+-    """
+-    name = "brmesolve"
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size":10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": False,
+-        'method': 'adams',
+-        'tensor_type': 'sparse',
+-        'sparse_eigensolver': False,
+-    }
+-    _avail_integrators = {}
+-
+-    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
+-        _time_start = time()
+-
+-        self.rhs = None
+-        self.sec_cutoff = sec_cutoff
+-        self.options = options
+-
+-        if not isinstance(H, (Qobj, QobjEvo)):
+-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+-        H = QobjEvo(H)
+-
+-        c_ops = c_ops or []
+-        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
+-        for c_op in c_ops:
+-            if not isinstance(c_op, (Qobj, QobjEvo)):
+-                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
+-
+-        a_ops = a_ops or []
+-        if not hasattr(a_ops, "__iter__"):
+-            TypeError("`a_ops` must be a list of (operator, spectra)")
+-        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
+-            a_ops = [a_ops]
+-        for oper, spectra in a_ops:
+-            if not isinstance(oper, (Qobj, QobjEvo)):
+-                raise TypeError("All `a_ops` operators "
+-                                "must be a Qobj or QobjEvo")
+-            if not isinstance(spectra, Coefficient):
+-                raise TypeError("All `a_ops` spectra "
+-                                "must be a Coefficient.")
+-
+-        self._system = H, a_ops, c_ops
+-        self._num_collapse = len(c_ops)
+-        self._num_a_ops = len(a_ops)
+-        self.rhs = self._prepare_rhs()
+-        self._integrator = self._get_integrator()
+-        self._state_metadata = {}
+-        self.stats = self._initialize_stats()
+-
+-
+-    def _initialize_stats(self):
+-        stats = super()._initialize_stats()
+-        stats.update({
+-            "solver": "Bloch Redfield Equation Evolution",
+-            "init time": stats["init time"] + self._init_rhs_time,
+-            "num_collapse": self._num_collapse,
+-            "num_a_ops": self._num_a_ops,
+-        })
+-        return stats
+-
+-    def _prepare_rhs(self):
+-        _time_start = time()
+-        rhs = bloch_redfield_tensor(
+-            *self._system,
+-            fock_basis=True,
+-            sec_cutoff=self.sec_cutoff,
+-            sparse_eigensolver=self.options['sparse_eigensolver'],
+-            br_dtype=self.options['tensor_type']
+-        )
+-        self._init_rhs_time = time() - _time_start
+-        return rhs
+-
+-    @property
+-    def options(self):
+-        """
+-        Options for bloch redfield solver:
+-
+-        store_final_state: bool, default=False
+-            Whether or not to store the final state of the evolution in the
+-            result class.
+-
+-        store_states: bool, default=None
+-            Whether or not to store the state vectors or density matrices.
+-            On `None` the states will be saved if no expectation operators are
+-            given.
+-
+-        normalize_output: bool, default=False
+-            Normalize output state to hide ODE numerical errors.
+-
+-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+-            How to present the solver progress.
+-            'tqdm' uses the python module of the same name and raise an error if
+-            not installed. Empty string or False will disable the bar.
+-
+-        progress_kwargs: dict, default={"chunk_size":10}
+-            Arguments to pass to the progress_bar. Qutip's bars use
+-            ``chunk_size``.
+-
+-        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
+-            Which data type to use when computing the brtensor.
+-            With a cutoff 'sparse' is usually the most efficient.
+-
+-        sparse_eigensolver: bool, default=False
+-            Whether to use the sparse eigensolver
+-
+-        method: str, default="adams"
+-            Which ODE integrator methods are supported.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Solver.options.fset(self, new_options)
+-
+-    def _apply_options(self, keys):
+-        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
+-        need_new_rhs &= (
+-            'sparse_eigensolver' in keys or 'tensor_type' in keys
+-        )
+-        if need_new_rhs:
+-            self.rhs = self._prepare_rhs()
+-
+-        if self._integrator is None or not keys:
+-            pass
+-        elif 'method' in keys or need_new_rhs:
+-            state = self._integrator.get_state()
+-            self._integrator = self._get_integrator()
+-            self._integrator.set_state(*state)
+-        else:
+-            self._integrator.options = self._options
+-            self._integrator.reset(hard=True)
++"""
++This module provides solvers for the Lindblad master equation and von Neumann
++equation.
++"""
++
++__all__ = ['brmesolve', 'BRSolver']
++
++import numpy as np
++import inspect
++from time import time
++from .. import Qobj, QobjEvo, coefficient, Coefficient
++from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
++from ..core.cy.coefficient import InterCoefficient
++from ..core import data as _data
++from .solver_base import Solver
++from .options import _SolverOptions
++
++
++def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
++              args={}, sec_cutoff=0.1, options=None):
++    """
++    Solves for the dynamics of a system using the Bloch-Redfield master
++    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
++    their associated spectral functions, as well as possible Lindblad collapse
++    operators.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    psi0: Qobj
++        Initial density matrix or state vector (ket).
++
++    tlist : array_like
++        List of times for evaluating evolution
++
++    a_ops : list of (a_op, spectra)
++        Nested list of system operators that couple to the environment,
++        and the corresponding bath spectra.
++
++        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
++            The operator coupling to the environment. Must be hermitian.
++
++        spectra : :class:`Coefficient`, str, func
++            The corresponding bath spectral responce.
++            Can be a `Coefficient` using an 'w' args, a function of the
++            frequence or a string. Coefficient build from a numpy array are
++            understood as a function of ``w`` instead of ``t``. Function are
++            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
++
++            The spectra function can depend on ``t`` if the corresponding
++            ``a_op`` is a :class:`QobjEvo`.
++
++        Example:
++
++        .. code-block::
++
++            a_ops = [
++                (a+a.dag(), ('w>0', args={"w": 0})),
++                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
++                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
++                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
++            ]
++
++        .. note:
++            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
++                ``spline = qutip.coefficient(array, tlist=times)``
++
++            Whether the ``a_ops`` is time dependent is decided by the type of
++            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
++            of the spectra.
++
++    e_ops : list of :class:`Qobj` / callback function
++        Single operator or list of operators for which to evaluate
++        expectation values or callable or list of callable.
++        Callable signature must be, `f(t: float, state: Qobj)`.
++        See :func:`expect` for more detail of operator expectation
++
++    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
++        List of collapse operators.
++
++    args : dict
++        Dictionary of parameters for time-dependent Hamiltonians and
++        collapse operators. The key ``w`` is reserved for the spectra function.
++
++    sec_cutoff : float {0.1}
++        Cutoff for secular approximation. Use ``-1`` if secular approximation
++        is not used when evaluating bath-coupling terms.
++
++    options : None / dict
++        Dictionary of options for the solver.
++
++        - store_final_state : bool
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, None
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - normalize_output : bool
++          Normalize output state to hide ODE numerical errors.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - tensor_type : str ['sparse', 'dense', 'data']
++          Which data type to use when computing the brtensor.
++          With a cutoff 'sparse' is usually the most efficient.
++        - sparse_eigensolver : bool {False}
++          Whether to use the sparse eigensolver
++        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
++          Which differential equation integration method to use.
++        - atol, rtol : float
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps :
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - max_step : float, 0
++          Maximum lenght of one internal step. When using pulses, it should be
++          less than half the width of the thinnest pulse.
++
++        Other options could be supported depending on the integration method,
++        see `Integrator <./classes.html#classes-ode>`_.
++
++    Returns
++    -------
++    result: :class:`qutip.solver.Result`
++
++        An instance of the class :class:`qutip.solver.Result`, which contains
++        either an array of expectation values, for operators given in e_ops,
++        or a list of states for the times specified by `tlist`.
++
++    .. note:
++        The option ``operator_data_type`` is used to determine in which format
++        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
++        for dense array. With 'data', it will try to use the same data type as
++        the ``a_ops``, but it is usually less efficient than manually choosing
++        it.
++    """
++    H = QobjEvo(H, args=args, tlist=tlist)
++
++    c_ops = c_ops if c_ops is not None else []
++    if not isinstance(c_ops, (list, tuple)):
++        c_ops = [c_ops]
++    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
++
++    new_a_ops = []
++    for (a_op, spectra) in a_ops:
++        aop = QobjEvo(a_op, args=args, tlist=tlist)
++        if isinstance(spectra, str):
++            new_a_ops.append(
++                (aop, coefficient(spectra, args={**args, 'w':0})))
++        elif isinstance(spectra, InterCoefficient):
++            new_a_ops.append((aop, SpectraCoefficient(spectra)))
++        elif isinstance(spectra, Coefficient):
++            new_a_ops.append((aop, spectra))
++        elif callable(spectra):
++            sig = inspect.signature(spectra)
++            if tuple(sig.parameters.keys()) == ("w",):
++                spec = SpectraCoefficient(coefficient(spectra))
++            else:
++                spec = coefficient(spectra, args={**args, 'w':0})
++            new_a_ops.append((aop, spec))
++        else:
++            raise TypeError("a_ops's spectra not known")
++
++    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
++
++    return solver.run(psi0, tlist, e_ops=e_ops)
++
++
++class BRSolver(Solver):
++    """
++    Bloch Redfield equation evolution of a density matrix for a given
++    Hamiltonian and set of bath coupling operators.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    a_ops : list of (a_op, spectra)
++        Nested list of system operators that couple to the environment,
++        and the corresponding bath spectra.
++
++        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
++            The operator coupling to the environment. Must be hermitian.
++
++        spectra : :class:`Coefficient`
++            The corresponding bath spectra. As a `Coefficient` using an 'w'
++            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
++            :class:`SpectraCoefficient` can be used to conver a coefficient
++            depending on ``t`` to one depending on ``w``.
++
++        Example:
++
++        .. code-block::
++
++            a_ops = [
++                (a+a.dag(), coefficient('w>0', args={'w':0})),
++                (QobjEvo([b+b.dag(), lambda t: ...]),
++                 coefficient(lambda t, w: ...), args={"w": 0}),
++                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
++            ]
++
++    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
++        Single collapse operator, or list of collapse operators, or a list
++        of Lindblad dissipator. None is equivalent to an empty list.
++
++    options : dict, optional
++        Options for the solver, see :obj:`BRSolver.options` and
++        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
++
++    sec_cutoff : float {0.1}
++        Cutoff for secular approximation. Use ``-1`` if secular approximation
++        is not used when evaluating bath-coupling terms.
++
++    attributes
++    ----------
++    stats: dict
++        Diverse diagnostic statistics of the evolution.
++    """
++    name = "brmesolve"
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size":10},
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": False,
++        'method': 'adams',
++        'tensor_type': 'sparse',
++        'sparse_eigensolver': False,
++    }
++    _avail_integrators = {}
++
++    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
++        _time_start = time()
++
++        self.rhs = None
++        self.sec_cutoff = sec_cutoff
++        self.options = options
++
++        if not isinstance(H, (Qobj, QobjEvo)):
++            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
++        H = QobjEvo(H)
++
++        c_ops = c_ops or []
++        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
++        for c_op in c_ops:
++            if not isinstance(c_op, (Qobj, QobjEvo)):
++                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
++
++        a_ops = a_ops or []
++        if not hasattr(a_ops, "__iter__"):
++            TypeError("`a_ops` must be a list of (operator, spectra)")
++        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
++            a_ops = [a_ops]
++        for oper, spectra in a_ops:
++            if not isinstance(oper, (Qobj, QobjEvo)):
++                raise TypeError("All `a_ops` operators "
++                                "must be a Qobj or QobjEvo")
++            if not isinstance(spectra, Coefficient):
++                raise TypeError("All `a_ops` spectra "
++                                "must be a Coefficient.")
++
++        self._system = H, a_ops, c_ops
++        self._num_collapse = len(c_ops)
++        self._num_a_ops = len(a_ops)
++        self.rhs = self._prepare_rhs()
++        self._integrator = self._get_integrator()
++        self._state_metadata = {}
++        self.stats = self._initialize_stats()
++
++
++    def _initialize_stats(self):
++        stats = super()._initialize_stats()
++        stats.update({
++            "solver": "Bloch Redfield Equation Evolution",
++            "init time": stats["init time"] + self._init_rhs_time,
++            "num_collapse": self._num_collapse,
++            "num_a_ops": self._num_a_ops,
++        })
++        return stats
++
++    def _prepare_rhs(self):
++        _time_start = time()
++        rhs = bloch_redfield_tensor(
++            *self._system,
++            fock_basis=True,
++            sec_cutoff=self.sec_cutoff,
++            sparse_eigensolver=self.options['sparse_eigensolver'],
++            br_dtype=self.options['tensor_type']
++        )
++        self._init_rhs_time = time() - _time_start
++        return rhs
++
++    @property
++    def options(self):
++        """
++        Options for bloch redfield solver:
++
++        store_final_state: bool, default=False
++            Whether or not to store the final state of the evolution in the
++            result class.
++
++        store_states: bool, default=None
++            Whether or not to store the state vectors or density matrices.
++            On `None` the states will be saved if no expectation operators are
++            given.
++
++        normalize_output: bool, default=False
++            Normalize output state to hide ODE numerical errors.
++
++        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
++            How to present the solver progress.
++            'tqdm' uses the python module of the same name and raise an error if
++            not installed. Empty string or False will disable the bar.
++
++        progress_kwargs: dict, default={"chunk_size":10}
++            Arguments to pass to the progress_bar. Qutip's bars use
++            ``chunk_size``.
++
++        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
++            Which data type to use when computing the brtensor.
++            With a cutoff 'sparse' is usually the most efficient.
++
++        sparse_eigensolver: bool, default=False
++            Whether to use the sparse eigensolver
++
++        method: str, default="adams"
++            Which ODE integrator methods are supported.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Solver.options.fset(self, new_options)
++
++    def _apply_options(self, keys):
++        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
++        need_new_rhs &= (
++            'sparse_eigensolver' in keys or 'tensor_type' in keys
++        )
++        if need_new_rhs:
++            self.rhs = self._prepare_rhs()
++
++        if self._integrator is None or not keys:
++            pass
++        elif 'method' in keys or need_new_rhs:
++            state = self._integrator.get_state()
++            self._integrator = self._get_integrator()
++            self._integrator.set_state(*state)
++        else:
++            self._integrator.options = self._options
++            self._integrator.reset(hard=True)
+diff --git a/qutip/solver/correlation.py b/qutip/solver/correlation.py
+index b05514c5..e3be789f 100644
+--- a/qutip/solver/correlation.py
++++ b/qutip/solver/correlation.py
+@@ -1,517 +1,517 @@
+-__all__ = [
+-    'correlation_3op',
+-    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
+-    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
+-]
+-
+-import numpy as np
+-import scipy.fftpack
+-
+-from ..core import (
+-    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
+-    tensor, qzero, expect
+-)
+-from .mesolve import MESolver
+-from .mcsolve import MCSolver
+-from .brmesolve import BRSolver
+-from .heom.bofin_solvers import HEOMSolver
+-
+-from .steadystate import steadystate
+-from ..ui.progressbar import progess_bars
+-
+-# -----------------------------------------------------------------------------
+-# PUBLIC API
+-# -----------------------------------------------------------------------------
+-
+-# low level correlation
+-
+-
+-def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
+-                       solver="me", reverse=False, args={},
+-                       options={}):
+-    r"""
+-    Calculate the two-operator one-time correlation function:
+-    :math:`\left<A(\tau)B(0)\right>`
+-    along one time axis using the quantum regression theorem and the evolution
+-    solver indicated by the `solver` parameter.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian, may be time-dependent for solver choice of `me`.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+-        be used as the initial state. The 'steady-state' is only implemented
+-        if ``c_ops`` are provided and the Hamiltonian is constant.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+-        List of collapse operators
+-    a_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator A.
+-    b_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator B.
+-    reverse : bool {False}
+-        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
+-        :math:`\left<A(t+\tau)B(t)\right>`.
+-    solver : str {'me', 'es'}
+-        Choice of solver, `me` for master-equation, and `es` for exponential
+-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+-    options : dict, optional
+-        Options for the solver. Only used with `me` solver.
+-
+-    Returns
+-    -------
+-    corr_vec : ndarray
+-        An array of correlation values for the times specified by `taulist`.
+-
+-    See Also
+-    --------
+-    :func:`correlation_3op` :
+-        Similar function supporting various solver types.
+-
+-    References
+-    ----------
+-    See, Gardiner, Quantum Noise, Section 5.2.
+-
+-    """
+-    solver = _make_solver(H, c_ops, args, options, solver)
+-
+-    if reverse:
+-        A_op, B_op, C_op = a_op, b_op, 1
+-    else:
+-        A_op, B_op, C_op = 1, a_op, b_op
+-    if state0 is None:
+-        state0 = steadystate(H, c_ops)
+-
+-    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
+-
+-
+-def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
+-                       solver="me", reverse=False, args={},
+-                       options={}):
+-    r"""
+-    Calculate the two-operator two-time correlation function:
+-    :math:`\left<A(t+\tau)B(t)\right>`
+-    along two time axes using the quantum regression theorem and the
+-    evolution solver indicated by the ``solver`` parameter.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian, may be time-dependent for solver choice of `me`.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+-        be used as the initial state. The 'steady-state' is only implemented
+-        if ``c_ops`` are provided and the Hamiltonian is constant.
+-    tlist : array_like
+-        List of times for :math:`t`. tlist must be positive and contain the
+-        element `0`. When taking steady-steady correlations only one ``tlist``
+-        value is necessary, i.e. when :math:`t \rightarrow \infty`.
+-        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+-        List of collapse operators
+-    a_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator A.
+-    b_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator B.
+-    reverse : bool {False}
+-        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
+-        :math:`\left<A(t+\tau)B(t)\right>`.
+-    solver : str {'me', 'es'}
+-        Choice of solver, `me` for master-equation, and `es` for exponential
+-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+-    options : dict, optional
+-        Options for the solver. Only used with `me` solver.
+-
+-    Returns
+-    -------
+-    corr_mat : ndarray
+-        An 2-dimensional array (matrix) of correlation values for the times
+-        specified by `tlist` (first index) and `taulist` (second index).
+-
+-    See Also
+-    --------
+-    :func:`correlation_3op` :
+-        Similar function supporting various solver types.
+-
+-    References
+-    ----------
+-    See, Gardiner, Quantum Noise, Section 5.2.
+-
+-    """
+-    solver = _make_solver(H, c_ops, args, options, solver)
+-    if tlist is None:
+-        tlist = [0]
+-    if state0 is None:
+-        state0 = steadystate(H, c_ops)
+-
+-    if reverse:
+-        A_op, B_op, C_op = a_op, b_op, 1
+-    else:
+-        A_op, B_op, C_op = 1, a_op, b_op
+-
+-    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
+-
+-
+-def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
+-                       solver="me", args={},
+-                       options={}):
+-    r"""
+-    Calculate the three-operator two-time correlation function:
+-    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
+-    quantum regression theorem and the evolution solver indicated by the
+-    `solver` parameter.
+-
+-    Note: it is not possibly to calculate a physically meaningful correlation
+-    of this form where :math:`\tau<0`.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian, may be time-dependent for solver choice of `me`.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+-        be used as the initial state. The 'steady-state' is only implemented
+-        if ``c_ops`` are provided and the Hamiltonian is constant.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+-        List of collapse operators
+-    a_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator A.
+-    b_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator B.
+-    c_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator C.
+-    solver : str {'me', 'es'}
+-        Choice of solver, `me` for master-equation, and `es` for exponential
+-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+-    options : dict, optional
+-        Options for the solver. Only used with `me` solver.
+-
+-    Returns
+-    -------
+-    corr_vec : array
+-        An array of correlation values for the times specified by `taulist`.
+-
+-    See Also
+-    --------
+-    :func:`correlation_3op` :
+-        Similar function supporting various solver types.
+-
+-    References
+-    ----------
+-    See, Gardiner, Quantum Noise, Section 5.2.
+-
+-    """
+-    solver = _make_solver(H, c_ops, args, options, solver)
+-    if state0 is None:
+-        state0 = steadystate(H, c_ops)
+-    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
+-
+-
+-def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
+-                       solver="me", args={},
+-                       options={}):
+-    r"""
+-    Calculate the three-operator two-time correlation function:
+-    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
+-    quantum regression theorem and the evolution solver indicated by the
+-    `solver` parameter.
+-
+-    Note: it is not possibly to calculate a physically meaningful correlation
+-    of this form where :math:`\tau<0`.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian, may be time-dependent for solver choice of `me`.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+-        be used as the initial state. The 'steady-state' is only implemented
+-        if ``c_ops`` are provided and the Hamiltonian is constant.
+-    tlist : array_like
+-        List of times for :math:`t`. tlist must be positive and contain the
+-        element `0`. When taking steady-steady correlations only one tlist
+-        value is necessary, i.e. when :math:`t \rightarrow \infty`.
+-        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+-        List of collapse operators
+-    a_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator A.
+-    b_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator B.
+-    c_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator C.
+-    solver : str {'me', 'es'}
+-        Choice of solver, `me` for master-equation, and `es` for exponential
+-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+-    options : dict, optional
+-        Options for the solver. Only used with `me` solver.
+-
+-    Returns
+-    -------
+-    corr_mat : array
+-        An 2-dimensional array (matrix) of correlation values for the times
+-        specified by `tlist` (first index) and `taulist` (second index).
+-
+-    See Also
+-    --------
+-    :func:`correlation_3op` :
+-        Similar function supporting various solver types.
+-
+-    References
+-    ----------
+-
+-    See, Gardiner, Quantum Noise, Section 5.2.
+-
+-    """
+-    solver = _make_solver(H, c_ops, args, options, solver)
+-
+-    if tlist is None:
+-        tlist = [0]
+-    if state0 is None:
+-        state0 = steadystate(H, c_ops)
+-
+-    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
+-
+-
+-# high level correlation
+-
+-def coherence_function_g1(
+-    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
+-):
+-    r"""
+-    Calculate the normalized first-order quantum coherence function:
+-
+-    .. math::
+-
+-        g^{(1)}(\tau) =
+-        \frac{\langle A^\dagger(\tau)A(0)\rangle}
+-        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
+-                \langle A^\dagger(0)A(0)\rangle}}
+-
+-    using the quantum regression theorem and the evolution solver indicated by
+-    the `solver` parameter.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian, may be time-dependent for solver choice of `me`.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+-        be used as the initial state. The 'steady-state' is only implemented
+-        if ``c_ops`` are provided and the Hamiltonian is constant.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+-        List of collapse operators
+-    a_op : :class:`Qobj`, :class:`QobjEvo`
+-        Operator A.
+-    solver : str {'me', 'es'}
+-        Choice of solver, `me` for master-equation, and `es` for exponential
+-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+-    options : dict, optional
+-        Options for the solver. Only used with `me` solver.
+-
+-    Returns
+-    -------
+-    g1, G1 : tuple
+-        The normalized and unnormalized second-order coherence function.
+-
+-    """
+-    solver = _make_solver(H, c_ops, args, options, solver)
+-
+-    # first calculate the photon number
+-    if state0 is None:
+-        state0 = steadystate(H, c_ops)
+-        n = np.array([expect(state0, a_op.dag() * a_op)])
+-    else:
+-        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
+-
+-    # calculate the correlation function G1 and normalize with n to obtain g1
+-    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
+-
+-    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
+-    return g1, G1
+-
+-
+-def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
+-                          args={}, options={}):
+-    r"""
+-    Calculate the normalized second-order quantum coherence function:
+-
+-    .. math::
+-
+-         g^{(2)}(\tau) =
+-        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
+-        {\langle A^\dagger(\tau)A(\tau)\rangle
+-         \langle A^\dagger(0)A(0)\rangle}
+-
+-    using the quantum regression theorem and the evolution solver indicated by
+-    the `solver` parameter.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian, may be time-dependent for solver choice of `me`.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+-        be used as the initial state. The 'steady-state' is only implemented
+-        if ``c_ops`` are provided and the Hamiltonian is constant.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    c_ops : list
+-        List of collapse operators, may be time-dependent for solver choice of
+-        `me`.
+-    a_op : :class:`Qobj`
+-        Operator A.
+-    args : dict
+-        Dictionary of arguments to be passed to solver.
+-    solver : str {'me', 'es'}
+-        Choice of solver, `me` for master-equation, and `es` for exponential
+-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+-    options : dict, optional
+-        Options for the solver. Only used with `me` solver.
+-
+-    Returns
+-    -------
+-    g2, G2 : tuple
+-        The normalized and unnormalized second-order coherence function.
+-
+-    """
+-    solver = _make_solver(H, c_ops, args, options, solver)
+-
+-    # first calculate the photon number
+-    if state0 is None:
+-        state0 = steadystate(H, c_ops)
+-        n = np.array([expect(state0, a_op.dag() * a_op)])
+-    else:
+-        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
+-
+-    # calculate the correlation function G2 and normalize with n to obtain g2
+-    G2 = correlation_3op(solver, state0, [0], taulist,
+-                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
+-
+-    g2 = G2 / (n[0] * np.array(n))
+-    return g2, G2
+-
+-
+-def _make_solver(H, c_ops, args, options, solver):
+-    H = QobjEvo(H, args=args)
+-    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
+-    if solver == "me":
+-        solver_instance = MESolver(H, c_ops, options=options)
+-    elif solver == "es":
+-        options = {"method": "diag"}
+-        solver_instance = MESolver(H, c_ops, options=options)
+-    elif solver == "mc":
+-        raise ValueError("MC solver for correlation has been removed")
+-    return solver_instance
+-
+-
+-def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
+-    r"""
+-    Calculate the three-operator two-time correlation function:
+-
+-        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
+-
+-    from a open system :class:`Solver`.
+-
+-    Note: it is not possible to calculate a physically meaningful correlation
+-    where :math:`\tau<0`.
+-
+-    Parameters
+-    ----------
+-    solver : :class:`MESolver`, :class:`BRSolver`
+-        Qutip solver for an open system.
+-    state0 : :class:`Qobj`
+-        Initial state density matrix :math:`\rho(t_0)` or state vector
+-        :math:`\psi(t_0)`.
+-    tlist : array_like
+-        List of times for :math:`t`. tlist must be positive and contain the
+-        element `0`.
+-    taulist : array_like
+-        List of times for :math:`\tau`. taulist must be positive and contain
+-        the element `0`.
+-    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
+-        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
+-        in the Schrodinger picture. They do not need to be all provided. For
+-        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
+-
+-    Returns
+-    -------
+-    corr_mat : array
+-        An 2-dimensional array (matrix) of correlation values for the times
+-        specified by `tlist` (first index) and `taulist` (second index). If
+-        `tlist` is `None`, then a 1-dimensional array of correlation values
+-        is returned instead.
+-    """
+-    taulist = np.asarray(taulist)
+-
+-    dims = state0.dims[0]
+-    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
+-    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
+-    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
+-
+-    if isinstance(solver, (MESolver, BRSolver)):
+-        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
+-    elif isinstance(solver, MCSolver):
+-        raise TypeError("Monte Carlo support for correlation was removed. "
+-                        "Please, tell us on GitHub issues if you need it!")
+-    elif isinstance(solver, HEOMSolver):
+-        raise TypeError("HEOM is not supported by correlation. "
+-                        "Please, tell us on GitHub issues if you need it!")
+-    else:
+-        raise TypeError("Only solvers able to evolve density matrices"
+-                        " are supported.")
+-
+-    return out
+-
+-
+-def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
+-    old_opt = solver.options.copy()
+-    try:
+-        # We don't want to modify the solver
+-        # TODO: Solver could have a ``with`` or ``copy``.
+-        solver.options["normalize_output"] = False
+-        solver.options["progress_bar"] = False
+-
+-        progress_bar = progess_bars[old_opt['progress_bar']]()
+-        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
+-        rho_t = solver.run(state0, tlist).states
+-        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
+-        progress_bar.update()
+-
+-        for t_idx, rho in enumerate(rho_t):
+-            t = tlist[t_idx]
+-            corr_mat[t_idx, :] = solver.run(
+-                C(t) @ rho @ A(t),
+-                taulist + t,
+-                e_ops=B
+-            ).expect[0]
+-            progress_bar.update()
+-        progress_bar.finished()
+-
+-    finally:
+-        solver.options = old_opt
+-
+-    return corr_mat
++__all__ = [
++    'correlation_3op',
++    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
++    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
++]
++
++import numpy as np
++import scipy.fftpack
++
++from ..core import (
++    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
++    tensor, qzero, expect
++)
++from .mesolve import MESolver
++from .mcsolve import MCSolver
++from .brmesolve import BRSolver
++from .heom.bofin_solvers import HEOMSolver
++
++from .steadystate import steadystate
++from ..ui.progressbar import progess_bars
++
++# -----------------------------------------------------------------------------
++# PUBLIC API
++# -----------------------------------------------------------------------------
++
++# low level correlation
++
++
++def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
++                       solver="me", reverse=False, args={},
++                       options={}):
++    r"""
++    Calculate the two-operator one-time correlation function:
++    :math:`\left<A(\tau)B(0)\right>`
++    along one time axis using the quantum regression theorem and the evolution
++    solver indicated by the `solver` parameter.
++
++    Parameters
++    ----------
++
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian, may be time-dependent for solver choice of `me`.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
++        be used as the initial state. The 'steady-state' is only implemented
++        if ``c_ops`` are provided and the Hamiltonian is constant.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
++        List of collapse operators
++    a_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator A.
++    b_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator B.
++    reverse : bool {False}
++        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
++        :math:`\left<A(t+\tau)B(t)\right>`.
++    solver : str {'me', 'es'}
++        Choice of solver, `me` for master-equation, and `es` for exponential
++        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
++    options : dict, optional
++        Options for the solver. Only used with `me` solver.
++
++    Returns
++    -------
++    corr_vec : ndarray
++        An array of correlation values for the times specified by `taulist`.
++
++    See Also
++    --------
++    :func:`correlation_3op` :
++        Similar function supporting various solver types.
++
++    References
++    ----------
++    See, Gardiner, Quantum Noise, Section 5.2.
++
++    """
++    solver = _make_solver(H, c_ops, args, options, solver)
++
++    if reverse:
++        A_op, B_op, C_op = a_op, b_op, 1
++    else:
++        A_op, B_op, C_op = 1, a_op, b_op
++    if state0 is None:
++        state0 = steadystate(H, c_ops)
++
++    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
++
++
++def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
++                       solver="me", reverse=False, args={},
++                       options={}):
++    r"""
++    Calculate the two-operator two-time correlation function:
++    :math:`\left<A(t+\tau)B(t)\right>`
++    along two time axes using the quantum regression theorem and the
++    evolution solver indicated by the ``solver`` parameter.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian, may be time-dependent for solver choice of `me`.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
++        be used as the initial state. The 'steady-state' is only implemented
++        if ``c_ops`` are provided and the Hamiltonian is constant.
++    tlist : array_like
++        List of times for :math:`t`. tlist must be positive and contain the
++        element `0`. When taking steady-steady correlations only one ``tlist``
++        value is necessary, i.e. when :math:`t \rightarrow \infty`.
++        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
++        List of collapse operators
++    a_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator A.
++    b_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator B.
++    reverse : bool {False}
++        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
++        :math:`\left<A(t+\tau)B(t)\right>`.
++    solver : str {'me', 'es'}
++        Choice of solver, `me` for master-equation, and `es` for exponential
++        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
++    options : dict, optional
++        Options for the solver. Only used with `me` solver.
++
++    Returns
++    -------
++    corr_mat : ndarray
++        An 2-dimensional array (matrix) of correlation values for the times
++        specified by `tlist` (first index) and `taulist` (second index).
++
++    See Also
++    --------
++    :func:`correlation_3op` :
++        Similar function supporting various solver types.
++
++    References
++    ----------
++    See, Gardiner, Quantum Noise, Section 5.2.
++
++    """
++    solver = _make_solver(H, c_ops, args, options, solver)
++    if tlist is None:
++        tlist = [0]
++    if state0 is None:
++        state0 = steadystate(H, c_ops)
++
++    if reverse:
++        A_op, B_op, C_op = a_op, b_op, 1
++    else:
++        A_op, B_op, C_op = 1, a_op, b_op
++
++    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
++
++
++def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
++                       solver="me", args={},
++                       options={}):
++    r"""
++    Calculate the three-operator two-time correlation function:
++    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
++    quantum regression theorem and the evolution solver indicated by the
++    `solver` parameter.
++
++    Note: it is not possibly to calculate a physically meaningful correlation
++    of this form where :math:`\tau<0`.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian, may be time-dependent for solver choice of `me`.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
++        be used as the initial state. The 'steady-state' is only implemented
++        if ``c_ops`` are provided and the Hamiltonian is constant.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
++        List of collapse operators
++    a_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator A.
++    b_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator B.
++    c_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator C.
++    solver : str {'me', 'es'}
++        Choice of solver, `me` for master-equation, and `es` for exponential
++        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
++    options : dict, optional
++        Options for the solver. Only used with `me` solver.
++
++    Returns
++    -------
++    corr_vec : array
++        An array of correlation values for the times specified by `taulist`.
++
++    See Also
++    --------
++    :func:`correlation_3op` :
++        Similar function supporting various solver types.
++
++    References
++    ----------
++    See, Gardiner, Quantum Noise, Section 5.2.
++
++    """
++    solver = _make_solver(H, c_ops, args, options, solver)
++    if state0 is None:
++        state0 = steadystate(H, c_ops)
++    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
++
++
++def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
++                       solver="me", args={},
++                       options={}):
++    r"""
++    Calculate the three-operator two-time correlation function:
++    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
++    quantum regression theorem and the evolution solver indicated by the
++    `solver` parameter.
++
++    Note: it is not possibly to calculate a physically meaningful correlation
++    of this form where :math:`\tau<0`.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian, may be time-dependent for solver choice of `me`.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
++        be used as the initial state. The 'steady-state' is only implemented
++        if ``c_ops`` are provided and the Hamiltonian is constant.
++    tlist : array_like
++        List of times for :math:`t`. tlist must be positive and contain the
++        element `0`. When taking steady-steady correlations only one tlist
++        value is necessary, i.e. when :math:`t \rightarrow \infty`.
++        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
++        List of collapse operators
++    a_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator A.
++    b_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator B.
++    c_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator C.
++    solver : str {'me', 'es'}
++        Choice of solver, `me` for master-equation, and `es` for exponential
++        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
++    options : dict, optional
++        Options for the solver. Only used with `me` solver.
++
++    Returns
++    -------
++    corr_mat : array
++        An 2-dimensional array (matrix) of correlation values for the times
++        specified by `tlist` (first index) and `taulist` (second index).
++
++    See Also
++    --------
++    :func:`correlation_3op` :
++        Similar function supporting various solver types.
++
++    References
++    ----------
++
++    See, Gardiner, Quantum Noise, Section 5.2.
++
++    """
++    solver = _make_solver(H, c_ops, args, options, solver)
++
++    if tlist is None:
++        tlist = [0]
++    if state0 is None:
++        state0 = steadystate(H, c_ops)
++
++    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
++
++
++# high level correlation
++
++def coherence_function_g1(
++    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
++):
++    r"""
++    Calculate the normalized first-order quantum coherence function:
++
++    .. math::
++
++        g^{(1)}(\tau) =
++        \frac{\langle A^\dagger(\tau)A(0)\rangle}
++        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
++                \langle A^\dagger(0)A(0)\rangle}}
++
++    using the quantum regression theorem and the evolution solver indicated by
++    the `solver` parameter.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian, may be time-dependent for solver choice of `me`.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
++        be used as the initial state. The 'steady-state' is only implemented
++        if ``c_ops`` are provided and the Hamiltonian is constant.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
++        List of collapse operators
++    a_op : :class:`Qobj`, :class:`QobjEvo`
++        Operator A.
++    solver : str {'me', 'es'}
++        Choice of solver, `me` for master-equation, and `es` for exponential
++        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
++    options : dict, optional
++        Options for the solver. Only used with `me` solver.
++
++    Returns
++    -------
++    g1, G1 : tuple
++        The normalized and unnormalized second-order coherence function.
++
++    """
++    solver = _make_solver(H, c_ops, args, options, solver)
++
++    # first calculate the photon number
++    if state0 is None:
++        state0 = steadystate(H, c_ops)
++        n = np.array([expect(state0, a_op.dag() * a_op)])
++    else:
++        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
++
++    # calculate the correlation function G1 and normalize with n to obtain g1
++    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
++
++    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
++    return g1, G1
++
++
++def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
++                          args={}, options={}):
++    r"""
++    Calculate the normalized second-order quantum coherence function:
++
++    .. math::
++
++         g^{(2)}(\tau) =
++        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
++        {\langle A^\dagger(\tau)A(\tau)\rangle
++         \langle A^\dagger(0)A(0)\rangle}
++
++    using the quantum regression theorem and the evolution solver indicated by
++    the `solver` parameter.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian, may be time-dependent for solver choice of `me`.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
++        be used as the initial state. The 'steady-state' is only implemented
++        if ``c_ops`` are provided and the Hamiltonian is constant.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    c_ops : list
++        List of collapse operators, may be time-dependent for solver choice of
++        `me`.
++    a_op : :class:`Qobj`
++        Operator A.
++    args : dict
++        Dictionary of arguments to be passed to solver.
++    solver : str {'me', 'es'}
++        Choice of solver, `me` for master-equation, and `es` for exponential
++        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
++    options : dict, optional
++        Options for the solver. Only used with `me` solver.
++
++    Returns
++    -------
++    g2, G2 : tuple
++        The normalized and unnormalized second-order coherence function.
++
++    """
++    solver = _make_solver(H, c_ops, args, options, solver)
++
++    # first calculate the photon number
++    if state0 is None:
++        state0 = steadystate(H, c_ops)
++        n = np.array([expect(state0, a_op.dag() * a_op)])
++    else:
++        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
++
++    # calculate the correlation function G2 and normalize with n to obtain g2
++    G2 = correlation_3op(solver, state0, [0], taulist,
++                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
++
++    g2 = G2 / (n[0] * np.array(n))
++    return g2, G2
++
++
++def _make_solver(H, c_ops, args, options, solver):
++    H = QobjEvo(H, args=args)
++    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
++    if solver == "me":
++        solver_instance = MESolver(H, c_ops, options=options)
++    elif solver == "es":
++        options = {"method": "diag"}
++        solver_instance = MESolver(H, c_ops, options=options)
++    elif solver == "mc":
++        raise ValueError("MC solver for correlation has been removed")
++    return solver_instance
++
++
++def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
++    r"""
++    Calculate the three-operator two-time correlation function:
++
++        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
++
++    from a open system :class:`Solver`.
++
++    Note: it is not possible to calculate a physically meaningful correlation
++    where :math:`\tau<0`.
++
++    Parameters
++    ----------
++    solver : :class:`MESolver`, :class:`BRSolver`
++        Qutip solver for an open system.
++    state0 : :class:`Qobj`
++        Initial state density matrix :math:`\rho(t_0)` or state vector
++        :math:`\psi(t_0)`.
++    tlist : array_like
++        List of times for :math:`t`. tlist must be positive and contain the
++        element `0`.
++    taulist : array_like
++        List of times for :math:`\tau`. taulist must be positive and contain
++        the element `0`.
++    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
++        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
++        in the Schrodinger picture. They do not need to be all provided. For
++        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
++
++    Returns
++    -------
++    corr_mat : array
++        An 2-dimensional array (matrix) of correlation values for the times
++        specified by `tlist` (first index) and `taulist` (second index). If
++        `tlist` is `None`, then a 1-dimensional array of correlation values
++        is returned instead.
++    """
++    taulist = np.asarray(taulist)
++
++    dims = state0.dims[0]
++    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
++    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
++    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
++
++    if isinstance(solver, (MESolver, BRSolver)):
++        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
++    elif isinstance(solver, MCSolver):
++        raise TypeError("Monte Carlo support for correlation was removed. "
++                        "Please, tell us on GitHub issues if you need it!")
++    elif isinstance(solver, HEOMSolver):
++        raise TypeError("HEOM is not supported by correlation. "
++                        "Please, tell us on GitHub issues if you need it!")
++    else:
++        raise TypeError("Only solvers able to evolve density matrices"
++                        " are supported.")
++
++    return out
++
++
++def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
++    old_opt = solver.options.copy()
++    try:
++        # We don't want to modify the solver
++        # TODO: Solver could have a ``with`` or ``copy``.
++        solver.options["normalize_output"] = False
++        solver.options["progress_bar"] = False
++
++        progress_bar = progess_bars[old_opt['progress_bar']]()
++        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
++        rho_t = solver.run(state0, tlist).states
++        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
++        progress_bar.update()
++
++        for t_idx, rho in enumerate(rho_t):
++            t = tlist[t_idx]
++            corr_mat[t_idx, :] = solver.run(
++                C(t) @ rho @ A(t),
++                taulist + t,
++                e_ops=B
++            ).expect[0]
++            progress_bar.update()
++        progress_bar.finished()
++
++    finally:
++        solver.options = old_opt
++
++    return corr_mat
+diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
+index 4d4c60af..2237957d 100644
+--- a/qutip/solver/countstat.py
++++ b/qutip/solver/countstat.py
+@@ -1,217 +1,217 @@
+-"""
+-This module contains functions for calculating current and current noise using
+-the counting statistics formalism.
+-"""
+-__all__ = ['countstat_current', 'countstat_current_noise']
+-
+-import numpy as np
+-import scipy.sparse as sp
+-
+-from itertools import product
+-from ..core import (
+-    sprepost, spre, qeye, tensor, expect, Qobj,
+-    operator_to_vector, vector_to_operator
+-)
+-from ..core import data as _data
+-from .steadystate import pseudo_inverse, steadystate
+-from ..settings import settings
+-
+-# Load MKL spsolve if avaiable
+-if settings.has_mkl:
+-    from qutip._mkl.spsolve import mkl_spsolve
+-
+-
+-def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
+-    """
+-    Calculate the current corresponding to a system Liouvillian ``L`` and a
+-    list of current collapse operators ``c_ops`` or current superoperators
+-    ``J_ops``.
+-
+-    Parameters
+-    ----------
+-
+-    L : :class:`qutip.Qobj`
+-        Qobj representing the system Liouvillian.
+-
+-    c_ops : array / list (optional)
+-        List of current collapse operators. Required if either ``rhoss`` or
+-        ``J_ops`` is not given.
+-
+-    rhoss : :class:`qutip.Qobj` (optional)
+-        The steadystate density matrix for the given system Liouvillian ``L``
+-        and collapse operators. If not given, it defaults to
+-        ``steadystate(L, c_ops)``.
+-
+-    J_ops : array / list (optional)
+-        List of current superoperators. If not given, they default to
+-        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
+-
+-    Returns
+-    --------
+-    I : array
+-        The currents ``I`` corresponding to each current collapse operator
+-        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
+-    """
+-
+-    if J_ops is None:
+-        if c_ops is None:
+-            raise ValueError("c_ops must be given if J_ops is not")
+-        J_ops = [sprepost(c, c.dag()) for c in c_ops]
+-
+-    if rhoss is None:
+-        if c_ops is None:
+-            raise ValueError("c_ops must be given if rhoss is not")
+-        rhoss = steadystate(L, c_ops)
+-
+-    rhoss_vec = _data.column_stack(rhoss.data.copy())
+-
+-    N = len(J_ops)
+-    current = np.zeros(N)
+-
+-    for i, Ji in enumerate(J_ops):
+-        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
+-
+-    return current
+-
+-
+-def _solve(A, V):
+-    try:
+-        return _data.solve(A, V)
+-    except Exception:
+-        return _data.solve(A, V, "lsqr")
+-
+-
+-def _noise_direct(L, wlist, rhoss, J_ops):
+-    J_ops = [op.data for op in J_ops]
+-    rhoss_vec = operator_to_vector(rhoss).data
+-
+-    N_j_ops = len(J_ops)
+-    current = np.zeros(N_j_ops)
+-    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
+-
+-    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
+-    tr_op_vec = operator_to_vector(tr_op)
+-
+-    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
+-    Iop = _data.identity(np.prod(L.dims[0][0])**2)
+-    Q = _data.sub(Iop, Pop)
+-    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
+-
+-    for k, w in enumerate(wlist):
+-        if w != 0.0:
+-            L_temp = 1.0j * w * spre(tr_op) + L
+-        else:
+-            # At zero frequency some solvers fail for small systems.
+-            # Adding a small finite frequency of order 1e-15
+-            # helps prevent the solvers from throwing an exception.
+-            L_temp = 1e-15j * spre(tr_op) + L
+-
+-        A = _data.to(_data.CSR, L_temp.data)
+-        X_rho = [_solve(A, op) for op in Q_ops]
+-
+-        for i, j in product(range(N_j_ops), repeat=2):
+-            if i == j:
+-                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
+-                noise[j, i, k] = current[i]
+-            noise[j, i, k] -= (
+-                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
+-                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
+-            ).real
+-
+-    return current, noise
+-
+-
+-def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
+-    N_j_ops = len(J_ops)
+-    current = np.zeros(N_j_ops)
+-    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
+-    rhoss_vec = operator_to_vector(rhoss)
+-    for k, w in enumerate(wlist):
+-        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
+-        for i, j in product(range(N_j_ops), repeat=2):
+-            if i == j:
+-                current[i] = J_ops[i](rhoss).tr().real
+-                noise[i, j, k] = current[i]
+-            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
+-            noise[i, j, k] -= op(rhoss).tr().real
+-    return current, noise
+-
+-
+-def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
+-                            sparse=True, method='direct'):
+-    """
+-    Compute the cross-current noise spectrum for a list of collapse operators
+-    `c_ops` corresponding to monitored currents, given the system
+-    Liouvillian `L`. The current collapse operators `c_ops` should be part
+-    of the dissipative processes in `L`, but the `c_ops` given here does not
+-    necessarily need to be all collapse operators contributing to dissipation
+-    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
+-    and the current operators `J_ops` correpsonding to the current collapse
+-    operators `c_ops` can also be specified. If either of
+-    `rhoss` and `J_ops` are omitted, they will be computed internally.
+-    'wlist' is an optional list of frequencies at which to evaluate the noise
+-    spectrum.
+-
+-    Parameters
+-    ----------
+-
+-    L : :class:`qutip.Qobj`
+-        Qobj representing the system Liouvillian.
+-
+-    c_ops : array / list
+-        List of current collapse operators.
+-
+-    rhoss : :class:`qutip.Qobj` (optional)
+-        The steadystate density matrix corresponding the system Liouvillian
+-        `L`.
+-
+-    wlist : array / list (optional)
+-        List of frequencies at which to evaluate (if none are given, evaluates
+-        at zero frequency)
+-
+-    J_ops : array / list (optional)
+-        List of current superoperators.
+-
+-    sparse : bool [True]
+-        Flag that indicates whether to use sparse or dense matrix methods when
+-        computing the pseudo inverse. Default is false, as sparse solvers
+-        can fail for small systems. For larger systems the sparse solvers
+-        are recommended.
+-
+-    method : str, ['direct']
+-        Method used to compute the noise. The default, 'direct' with
+-        ``sparse=True``, compute the noise directly. It is the recommended
+-        method for larger systems. Otherwise, the pseudo inverse is computed
+-        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
+-        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
+-        ``sparse=False``.
+-
+-    .. note::
+-        The algoryth is described in page 67 of "Electrons in nanostructures"
+-        C. Flindt, PhD Thesis, available online:
+-        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
+-
+-    Returns
+-    --------
+-    I, S : tuple of arrays
+-        The currents `I` corresponding to each current collapse operator
+-        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
+-        zero-frequency cross-current correlation `S`.
+-    """
+-    if rhoss is None:
+-        rhoss = steadystate(L, c_ops)
+-
+-    if J_ops is None:
+-        J_ops = [sprepost(c, c.dag()) for c in c_ops]
+-
+-    if wlist is None:
+-        wlist = [0.]
+-
+-    if sparse and method == 'direct':
+-        # rhoss_vec = operator_to_vector(rhoss).data
+-        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
+-    else:
+-        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
+-                                          sparse, method)
+-
+-    return current, noise
++"""
++This module contains functions for calculating current and current noise using
++the counting statistics formalism.
++"""
++__all__ = ['countstat_current', 'countstat_current_noise']
++
++import numpy as np
++import scipy.sparse as sp
++
++from itertools import product
++from ..core import (
++    sprepost, spre, qeye, tensor, expect, Qobj,
++    operator_to_vector, vector_to_operator
++)
++from ..core import data as _data
++from .steadystate import pseudo_inverse, steadystate
++from ..settings import settings
++
++# Load MKL spsolve if avaiable
++if settings.has_mkl:
++    from qutip._mkl.spsolve import mkl_spsolve
++
++
++def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
++    """
++    Calculate the current corresponding to a system Liouvillian ``L`` and a
++    list of current collapse operators ``c_ops`` or current superoperators
++    ``J_ops``.
++
++    Parameters
++    ----------
++
++    L : :class:`qutip.Qobj`
++        Qobj representing the system Liouvillian.
++
++    c_ops : array / list (optional)
++        List of current collapse operators. Required if either ``rhoss`` or
++        ``J_ops`` is not given.
++
++    rhoss : :class:`qutip.Qobj` (optional)
++        The steadystate density matrix for the given system Liouvillian ``L``
++        and collapse operators. If not given, it defaults to
++        ``steadystate(L, c_ops)``.
++
++    J_ops : array / list (optional)
++        List of current superoperators. If not given, they default to
++        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
++
++    Returns
++    --------
++    I : array
++        The currents ``I`` corresponding to each current collapse operator
++        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
++    """
++
++    if J_ops is None:
++        if c_ops is None:
++            raise ValueError("c_ops must be given if J_ops is not")
++        J_ops = [sprepost(c, c.dag()) for c in c_ops]
++
++    if rhoss is None:
++        if c_ops is None:
++            raise ValueError("c_ops must be given if rhoss is not")
++        rhoss = steadystate(L, c_ops)
++
++    rhoss_vec = _data.column_stack(rhoss.data.copy())
++
++    N = len(J_ops)
++    current = np.zeros(N)
++
++    for i, Ji in enumerate(J_ops):
++        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
++
++    return current
++
++
++def _solve(A, V):
++    try:
++        return _data.solve(A, V)
++    except Exception:
++        return _data.solve(A, V, "lsqr")
++
++
++def _noise_direct(L, wlist, rhoss, J_ops):
++    J_ops = [op.data for op in J_ops]
++    rhoss_vec = operator_to_vector(rhoss).data
++
++    N_j_ops = len(J_ops)
++    current = np.zeros(N_j_ops)
++    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
++
++    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
++    tr_op_vec = operator_to_vector(tr_op)
++
++    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
++    Iop = _data.identity(np.prod(L.dims[0][0])**2)
++    Q = _data.sub(Iop, Pop)
++    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
++
++    for k, w in enumerate(wlist):
++        if w != 0.0:
++            L_temp = 1.0j * w * spre(tr_op) + L
++        else:
++            # At zero frequency some solvers fail for small systems.
++            # Adding a small finite frequency of order 1e-15
++            # helps prevent the solvers from throwing an exception.
++            L_temp = 1e-15j * spre(tr_op) + L
++
++        A = _data.to(_data.CSR, L_temp.data)
++        X_rho = [_solve(A, op) for op in Q_ops]
++
++        for i, j in product(range(N_j_ops), repeat=2):
++            if i == j:
++                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
++                noise[j, i, k] = current[i]
++            noise[j, i, k] -= (
++                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
++                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
++            ).real
++
++    return current, noise
++
++
++def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
++    N_j_ops = len(J_ops)
++    current = np.zeros(N_j_ops)
++    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
++    rhoss_vec = operator_to_vector(rhoss)
++    for k, w in enumerate(wlist):
++        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
++        for i, j in product(range(N_j_ops), repeat=2):
++            if i == j:
++                current[i] = J_ops[i](rhoss).tr().real
++                noise[i, j, k] = current[i]
++            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
++            noise[i, j, k] -= op(rhoss).tr().real
++    return current, noise
++
++
++def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
++                            sparse=True, method='direct'):
++    """
++    Compute the cross-current noise spectrum for a list of collapse operators
++    `c_ops` corresponding to monitored currents, given the system
++    Liouvillian `L`. The current collapse operators `c_ops` should be part
++    of the dissipative processes in `L`, but the `c_ops` given here does not
++    necessarily need to be all collapse operators contributing to dissipation
++    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
++    and the current operators `J_ops` correpsonding to the current collapse
++    operators `c_ops` can also be specified. If either of
++    `rhoss` and `J_ops` are omitted, they will be computed internally.
++    'wlist' is an optional list of frequencies at which to evaluate the noise
++    spectrum.
++
++    Parameters
++    ----------
++
++    L : :class:`qutip.Qobj`
++        Qobj representing the system Liouvillian.
++
++    c_ops : array / list
++        List of current collapse operators.
++
++    rhoss : :class:`qutip.Qobj` (optional)
++        The steadystate density matrix corresponding the system Liouvillian
++        `L`.
++
++    wlist : array / list (optional)
++        List of frequencies at which to evaluate (if none are given, evaluates
++        at zero frequency)
++
++    J_ops : array / list (optional)
++        List of current superoperators.
++
++    sparse : bool [True]
++        Flag that indicates whether to use sparse or dense matrix methods when
++        computing the pseudo inverse. Default is false, as sparse solvers
++        can fail for small systems. For larger systems the sparse solvers
++        are recommended.
++
++    method : str, ['direct']
++        Method used to compute the noise. The default, 'direct' with
++        ``sparse=True``, compute the noise directly. It is the recommended
++        method for larger systems. Otherwise, the pseudo inverse is computed
++        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
++        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
++        ``sparse=False``.
++
++    .. note::
++        The algoryth is described in page 67 of "Electrons in nanostructures"
++        C. Flindt, PhD Thesis, available online:
++        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
++
++    Returns
++    --------
++    I, S : tuple of arrays
++        The currents `I` corresponding to each current collapse operator
++        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
++        zero-frequency cross-current correlation `S`.
++    """
++    if rhoss is None:
++        rhoss = steadystate(L, c_ops)
++
++    if J_ops is None:
++        J_ops = [sprepost(c, c.dag()) for c in c_ops]
++
++    if wlist is None:
++        wlist = [0.]
++
++    if sparse and method == 'direct':
++        # rhoss_vec = operator_to_vector(rhoss).data
++        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
++    else:
++        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
++                                          sparse, method)
++
++    return current, noise
+diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
+index 7ce6cc4f..9eea49b9 100644
+--- a/qutip/solver/floquet.py
++++ b/qutip/solver/floquet.py
+@@ -1,931 +1,931 @@
+-__all__ = [
+-    "FloquetBasis",
+-    "floquet_tensor",
+-    "fsesolve",
+-    "fmmesolve",
+-    "FMESolver",
+-]
+-
+-import numpy as np
+-from qutip.core import data as _data
+-from qutip import Qobj, QobjEvo
+-from .propagator import Propagator
+-from .mesolve import MESolver
+-from .solver_base import Solver
+-from .integrator import Integrator
+-from .result import Result
+-from time import time
+-from ..ui.progressbar import progess_bars
+-
+-
+-class FloquetBasis:
+-    """
+-    Utility to compute floquet modes and states.
+-
+-    Attributes
+-    ----------
+-    U : :class:`Propagator`
+-        The propagator of the Hamiltonian over one period.
+-
+-    evecs : :class:`qutip.data.Data`
+-        Matrix where each column is an initial Floquet mode.
+-
+-    e_quasi : np.ndarray[float]
+-        The quasi energies of the Hamiltonian.
+-    """
+-
+-    def __init__(
+-        self,
+-        H,
+-        T,
+-        args=None,
+-        options=None,
+-        sparse=False,
+-        sort=True,
+-        precompute=None,
+-    ):
+-        """
+-        Parameters
+-        ----------
+-        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
+-            System Hamiltonian, with period `T`.
+-
+-        T : float
+-            Period of the Hamiltonian.
+-
+-        args : None / *dictionary*
+-            dictionary of parameters for time-dependent Hamiltonians and
+-            collapse operators.
+-
+-        options : dict [None]
+-            Options used by sesolve to compute the floquet modes.
+-
+-        sparse : bool [False]
+-            Whether to use the sparse eigen solver when computing the
+-            quasi-energies.
+-
+-        sort : bool [True]
+-            Whether to sort the quasi-energies.
+-
+-        precompute : list [None]
+-            If provided, a list of time at which to store the propagators
+-            for later use when computing modes and states. Default is
+-            ``linspace(0, T, 101)`` corresponding to the default integration
+-            steps used for the floquet tensor computation.
+-        """
+-        if not T > 0:
+-            raise ValueError("The period need to be a positive number.")
+-        self.T = T
+-        if precompute is not None:
+-            tlist = np.unique(np.atleast_1d(precompute) % self.T)
+-            memoize = len(tlist)
+-            if tlist[0] != 0:
+-                memoize += 1
+-            if tlist[-1] != T:
+-                memoize += 1
+-        else:
+-            # Default computation
+-            tlist = np.linspace(0, T, 101)
+-            memoize = 101
+-        self.U = Propagator(H, args=args, options=options, memoize=memoize)
+-        for t in tlist:
+-            # Do the evolution by steps to save the intermediate results.
+-            self.U(t)
+-        U_T = self.U(self.T)
+-        if not sparse and isinstance(U_T.data, _data.CSR):
+-            U_T = U_T.to("Dense")
+-        evals, evecs = _data.eigs(U_T.data)
+-        e_quasi = -np.angle(evals) / T
+-        if sort:
+-            perm = np.argsort(e_quasi)
+-            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
+-            self.e_quasi = e_quasi[perm]
+-        else:
+-            self.evecs = evecs
+-            self.e_quasi = e_quasi
+-
+-    def _as_ketlist(self, kets_mat):
+-        """
+-        Split the Data array in a list of kets.
+-        """
+-        dims = [self.U(0).dims[0], [1]]
+-        return [
+-            Qobj(ket, dims=dims, type="ket")
+-            for ket in _data.split_columns(kets_mat)
+-        ]
+-
+-    def mode(self, t, data=False):
+-        """
+-        Calculate the Floquet modes at time ``t``.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            The time for which to evaluate the Floquet mode.
+-
+-        data : bool [False]
+-            Whether to return the states as a single data matrix or a list of
+-            ket states.
+-
+-        Returns
+-        -------
+-        output : list[:class:`Qobj`], :class:`qutip.data.Data`
+-            A list of Floquet states for the time ``t`` or the states as column
+-            in a single matrix.
+-        """
+-        t = t % self.T
+-        if t == 0.0:
+-            kets_mat = self.evecs
+-        else:
+-            U = self.U(t).data
+-            phases = _data.diag(np.exp(1j * t * self.e_quasi))
+-            kets_mat = U @ self.evecs @ phases
+-        if data:
+-            return kets_mat
+-        else:
+-            return self._as_ketlist(kets_mat)
+-
+-    def state(self, t, data=False):
+-        """
+-        Evaluate the floquet states at time t.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            The time for which to evaluate the Floquet states.
+-
+-        data : bool [False]
+-            Whether to return the states as a single data matrix or a list of
+-            ket states.
+-
+-        Returns
+-        -------
+-        output : list[:class:`Qobj`], :class:`qutip.data.Data`
+-            A list of Floquet states for the time ``t`` or the states as column
+-            in a single matrix.
+-        """
+-        if t:
+-            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
+-            states_mat = self.mode(t, True) @ phases
+-        else:
+-            states_mat = self.evecs
+-        if data:
+-            return states_mat
+-        else:
+-            return self._as_ketlist(states_mat)
+-
+-    def from_floquet_basis(self, floquet_basis, t=0):
+-        """
+-        Transform a ket or density matrix from the Floquet basis at time ``t``
+-        to the lab basis.
+-
+-        Parameters
+-        ----------
+-        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
+-            Initial state in the Floquet basis at time ``t``. May be either a
+-            ket or density matrix.
+-
+-        t : float [0]
+-            The time at which to evaluate the Floquet states.
+-
+-        Returns
+-        -------
+-        output : :class:`Qobj`, :class:`qutip.data.Data`
+-            The state in the lab basis. The return type is the same as the type
+-            of the input state.
+-        """
+-        is_Qobj = isinstance(floquet_basis, Qobj)
+-        if is_Qobj:
+-            dims = floquet_basis.dims
+-            floquet_basis = floquet_basis.data
+-            if dims[0] != self.U(0).dims[1]:
+-                raise ValueError(
+-                    "Dimensions of the state do not match the Hamiltonian"
+-                )
+-
+-        state_mat = self.state(t, True)
+-        lab_basis = state_mat @ floquet_basis
+-        if floquet_basis.shape[1] != 1:
+-            lab_basis = lab_basis @ state_mat.adjoint()
+-
+-        if is_Qobj:
+-            return Qobj(lab_basis, dims=dims)
+-        return lab_basis
+-
+-    def to_floquet_basis(self, lab_basis, t=0):
+-        """
+-        Transform a ket or density matrix in the lab basis
+-        to the Floquet basis at time ``t``.
+-
+-        Parameters
+-        ----------
+-        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
+-            Initial state in the lab basis.
+-
+-        t : float [0]
+-            The time at which to evaluate the Floquet states.
+-
+-        Returns
+-        -------
+-        output : :class:`Qobj`, :class:`qutip.data.Data`
+-            The state in the Floquet basis. The return type is the same as the
+-            type of the input state.
+-        """
+-        is_Qobj = isinstance(lab_basis, Qobj)
+-        if is_Qobj:
+-            dims = lab_basis.dims
+-            lab_basis = lab_basis.data
+-            if dims[0] != self.U(0).dims[1]:
+-                raise ValueError(
+-                    "Dimensions of the state do not match the Hamiltonian"
+-                )
+-
+-        state_mat = self.state(t, True)
+-        floquet_basis = state_mat.adjoint() @ lab_basis
+-        if lab_basis.shape[1] != 1:
+-            floquet_basis = floquet_basis @ state_mat
+-
+-        if is_Qobj:
+-            return Qobj(floquet_basis, dims=dims)
+-        return floquet_basis
+-
+-
+-def _floquet_delta_tensor(f_energies, kmax, T):
+-    """
+-    Floquet-Markov master equation X matrices.
+-
+-    Parameters
+-    ----------
+-    f_energies : np.ndarray
+-        The Floquet energies.
+-
+-    kmax : int
+-        The truncation of the number of sidebands (default 5).
+-
+-    T : float
+-        The period of the time-dependence of the Hamiltonian.
+-
+-    Returns
+-    -------
+-    delta : np.ndarray
+-        Floquet delta tensor.
+-    """
+-    delta = np.subtract.outer(f_energies, f_energies)
+-    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
+-
+-
+-def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
+-    """
+-    Floquet-Markov master equation X matrices.
+-
+-    Parameters
+-    ----------
+-    floquet_basis : :class:`FloquetBasis`
+-        The system Hamiltonian wrapped in a FloquetBasis object.
+-
+-    c_ops : list of :class:`Qobj`
+-        The collapse operators describing the dissipation.
+-
+-    kmax : int
+-        The truncation of the number of sidebands (default 5).
+-
+-    ntimes : int [100]
+-        The number of integration steps (for calculating X) within one period.
+-
+-    Returns
+-    -------
+-    X : list of dict of :class:`qutip.data.Data`
+-        A dict of the sidebands ``k`` for the X matrices of each c_ops
+-    """
+-    T = floquet_basis.T
+-    N = floquet_basis.U(0).shape[0]
+-    omega = (2 * np.pi) / T
+-    tlist = np.linspace(T / ntimes, T, ntimes)
+-    ks = np.arange(-kmax, kmax + 1)
+-    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
+-
+-    for t in tlist:
+-        mode = floquet_basis.mode(t, data=True)
+-        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
+-        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
+-            out[k] = [
+-                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
+-            ]
+-
+-    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
+-
+-
+-def _floquet_gamma_matrices(X, delta, J_cb):
+-    """
+-    Floquet-Markov master equation gamma matrices.
+-
+-    Parameters
+-    ----------
+-    X : list of dict of :class:`qutip.data.Data`
+-        Floquet X matrices created by :func:`_floquet_X_matrices`.
+-
+-    delta : np.ndarray
+-        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
+-
+-    J_cb : list of callables
+-        A list callback functions that compute the noise power spectrum as
+-        a function of frequency. The list should contain one callable for each
+-        collapse operator `c_op`, in the same order as the elements of `X`.
+-        Each callable should accept a numpy array of frequencies and return a
+-        numpy array of corresponding noise power.
+-
+-    Returns
+-    -------
+-    gammas : dict of :class:`qutip.data.Data`
+-        A dict mapping the sidebands ``k`` to their gamma matrices.
+-    """
+-    N = delta.shape[0]
+-    kmax = (delta.shape[2] - 1) // 2
+-    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
+-
+-    for X_c_op, sp in zip(X, J_cb):
+-        response = sp(delta) * ((2 + 0j) * np.pi)
+-        response = [
+-            _data.Dense(response[:, :, k], copy=False)
+-            for k in range(2 * kmax + 1)
+-        ]
+-        for k in range(-kmax, kmax + 1, 1):
+-            gamma[k] = _data.add(
+-                gamma[k],
+-                _data.multiply(
+-                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
+-                    response[k + kmax],
+-                ),
+-            )
+-    return gamma
+-
+-
+-def _floquet_A_matrix(delta, gamma, w_th):
+-    """
+-    Floquet-Markov master equation rate matrix.
+-
+-    Parameters
+-    ----------
+-    delta : np.ndarray
+-        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
+-
+-    gamma : dict of :class:`qutip.data.Data`
+-        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
+-
+-    w_th : float
+-        The temperature in units of frequency.
+-    """
+-    kmax = (delta.shape[2] - 1) // 2
+-
+-    if w_th > 0.0:
+-        deltap = np.copy(delta)
+-        deltap[deltap == 0.0] = np.inf
+-        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
+-        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
+-
+-        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
+-        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
+-
+-        for k in range(1, kmax + 1):
+-            g_kk = _data.add(gamma[k], gamma[-k].transpose())
+-            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
+-            A = _data.add(A, _data.add(gamma[k], thermal_kk))
+-            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
+-            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
+-    else:
+-        # w_th is 0, thermal = 0s
+-        A = gamma[0]
+-        for k in range(1, kmax + 1):
+-            A = _data.add(gamma[k], A)
+-            A = _data.add(gamma[-k], A)
+-
+-    return A
+-
+-
+-def _floquet_master_equation_tensor(A):
+-    """
+-    Construct a tensor that represents the master equation in the floquet
+-    basis (with constant Hamiltonian and collapse operators?).
+-
+-    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
+-
+-    Parameters
+-    ----------
+-    A : :class:`qutip.data.Data`
+-        Floquet-Markov master equation rate matrix.
+-
+-    Returns
+-    -------
+-    output : array
+-        The Floquet-Markov master equation tensor `R`.
+-    """
+-    N = A.shape[0]
+-
+-    # R[i+N*i, j+N*j] = A[j, i]
+-    cols = np.arange(N, dtype=np.int32)
+-    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
+-    data = np.ones(N, dtype=complex)
+-    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
+-
+-    R = expand @ A.transpose() @ expand.transpose()
+-
+-    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
+-    ket_1 = _data.Dense(np.ones(N, dtype=complex))
+-    Asum = A @ ket_1
+-    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
+-    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
+-
+-    return _data.add(R, S)
+-
+-
+-def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
+-    """
+-    Construct a tensor that represents the master equation in the floquet
+-    basis.
+-
+-    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
+-
+-    Parameters
+-    ----------
+-    H : :class:`QobjEvo`
+-        Periodic Hamiltonian
+-
+-    T : float
+-        The period of the time-dependence of the hamiltonian.
+-
+-    c_ops : list of :class:`qutip.qobj`
+-        list of collapse operators.
+-
+-    spectra_cb : list callback functions
+-        List of callback functions that compute the noise power spectrum as
+-        a function of frequency for the collapse operators in `c_ops`.
+-
+-    w_th : float
+-        The temperature in units of frequency.
+-
+-    kmax : int
+-        The truncation of the number of sidebands (default 5).
+-
+-    Returns
+-    -------
+-    output : array
+-        The Floquet-Markov master equation tensor `R`.
+-    """
+-    if isinstance(H, FloquetBasis):
+-        floquet_basis = H
+-        T = H.T
+-    else:
+-        floquet_basis = FloquetBasis(H, T)
+-    energy = floquet_basis.e_quasi
+-    delta = _floquet_delta_tensor(energy, kmax, T)
+-    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
+-    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
+-    a = _floquet_A_matrix(delta, gamma, w_th)
+-    r = _floquet_master_equation_tensor(a)
+-    dims = floquet_basis.U(0).dims
+-    return Qobj(
+-        r, dims=[dims, dims], type="super", superrep="super", copy=False
+-    )
+-
+-
+-def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
+-    """
+-    Solve the Schrodinger equation using the Floquet formalism.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+-        Periodic system Hamiltonian as :class:`QobjEvo`. List of
+-        [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    psi0 : :class:`qutip.qobj`
+-        Initial state vector (ket). If an operator is provided,
+-
+-    tlist : *list* / *array*
+-        List of times for :math:`t`.
+-
+-    e_ops : list of :class:`qutip.qobj` / callback function, optional
+-        List of operators for which to evaluate expectation values. If this
+-        list is empty, the state vectors for each time in `tlist` will be
+-        returned instead of expectation values.
+-
+-    T : float, default=tlist[-1]
+-        The period of the time-dependence of the hamiltonian.
+-
+-    args : dictionary, optional
+-        Dictionary with variables required to evaluate H.
+-
+-    options : dict, optional
+-        Options for the results.
+-
+-        - store_final_state : bool
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, None
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - normalize_output : bool
+-          Normalize output state to hide ODE numerical errors.
+-
+-    Returns
+-    -------
+-    output : :class:`qutip.solver.Result`
+-        An instance of the class :class:`qutip.solver.Result`, which
+-        contains either an *array* of expectation values or an array of
+-        state vectors, for the times specified by `tlist`.
+-    """
+-    if isinstance(H, FloquetBasis):
+-        floquet_basis = H
+-    else:
+-        T = T or tlist[-1]
+-        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
+-        # are for the open system evolution.
+-        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
+-
+-    f_coeff = floquet_basis.to_floquet_basis(psi0)
+-    result_options = {
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": True,
+-    }
+-    result_options.update(options or {})
+-    result = Result(e_ops, result_options, solver="fsesolve")
+-    for t in tlist:
+-        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
+-        result.add(t, state_t)
+-
+-    return result
+-
+-
+-def fmmesolve(
+-    H,
+-    rho0,
+-    tlist,
+-    c_ops=None,
+-    e_ops=None,
+-    spectra_cb=None,
+-    T=0,
+-    w_th=0.0,
+-    args=None,
+-    options=None,
+-):
+-    """
+-    Solve the dynamics for the system using the Floquet-Markov master equation.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+-        Periodic system Hamiltonian as :class:`QobjEvo`. List of
+-        [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    rho0 / psi0 : :class:`qutip.Qobj`
+-        Initial density matrix or state vector (ket).
+-
+-    tlist : *list* / *array*
+-        List of times for :math:`t`.
+-
+-    c_ops : list of :class:`qutip.Qobj`
+-        List of collapse operators. Time dependent collapse operators are not
+-        supported.
+-
+-    e_ops : list of :class:`qutip.Qobj` / callback function
+-        List of operators for which to evaluate expectation values.
+-        The states are reverted to the lab basis before applying the
+-
+-    spectra_cb : list callback functions
+-        List of callback functions that compute the noise power spectrum as
+-        a function of frequency for the collapse operators in `c_ops`.
+-
+-    T : float
+-        The period of the time-dependence of the hamiltonian. The default value
+-        'None' indicates that the 'tlist' spans a single period of the driving.
+-
+-    w_th : float
+-        The temperature of the environment in units of frequency.
+-        For example, if the Hamiltonian written in units of 2pi GHz, and the
+-        temperature is given in K, use the following conversion:
+-
+-            temperature = 25e-3 # unit K
+-            h = 6.626e-34
+-            kB = 1.38e-23
+-            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
+-
+-    args : *dictionary*
+-        Dictionary of parameters for time-dependent Hamiltonian
+-
+-    options : None / dict
+-        Dictionary of options for the solver.
+-
+-        - store_final_state : bool
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, None
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - store_floquet_states : bool
+-          Whether or not to store the density matrices in the floquet basis in
+-          ``result.floquet_states``.
+-        - normalize_output : bool
+-          Normalize output state to hide ODE numerical errors.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+-          Which differential equation integration method to use.
+-        - atol, rtol : float
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps :
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - max_step : float, 0
+-          Maximum lenght of one internal step. When using pulses, it should be
+-          less than half the width of the thinnest pulse.
+-
+-        Other options could be supported depending on the integration method,
+-        see `Integrator <./classes.html#classes-ode>`_.
+-
+-    Returns
+-    -------
+-    result: :class:`qutip.Result`
+-
+-        An instance of the class :class:`qutip.Result`, which contains
+-        the expectation values for the times specified by `tlist`, and/or the
+-        state density matrices corresponding to the times.
+-    """
+-    if c_ops is None:
+-        return fsesolve(
+-            H,
+-            rho0,
+-            tlist,
+-            e_ops=e_ops,
+-            T=T,
+-            w_th=w_th,
+-            args=args,
+-            options=options,
+-        )
+-
+-    if isinstance(H, FloquetBasis):
+-        floquet_basis = H
+-    else:
+-        T = T or tlist[-1]
+-        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
+-        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
+-        # are for the open system evolution.
+-        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
+-
+-    if not w_th and args:
+-        w_th = args.get("w_th", 0.0)
+-
+-    if isinstance(c_ops, Qobj):
+-        c_ops = [c_ops]
+-
+-    if spectra_cb is None:
+-        spectra_cb = [lambda w: (w > 0)]
+-    elif callable(spectra_cb):
+-        spectra_cb = [spectra_cb]
+-    if len(spectra_cb) == 1:
+-        spectra_cb = spectra_cb * len(c_ops)
+-
+-    a_ops = list(zip(c_ops, spectra_cb))
+-
+-    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
+-    return solver.run(rho0, tlist, e_ops=e_ops)
+-
+-
+-class FloquetResult(Result):
+-    def _post_init(self, floquet_basis):
+-        self.floquet_basis = floquet_basis
+-        if self.options["store_floquet_states"]:
+-            self.floquet_states = []
+-        else:
+-            self.floquet_states = None
+-        super()._post_init()
+-
+-    def add(self, t, state):
+-        if self.options["store_floquet_states"]:
+-            self.floquet_states.append(state)
+-
+-        state = self.floquet_basis.from_floquet_basis(state, t)
+-        super().add(t, state)
+-
+-
+-class FMESolver(MESolver):
+-    """
+-    Solver for the Floquet-Markov master equation.
+-
+-    .. note ::
+-        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
+-
+-    Parameters
+-    ----------
+-    floquet_basis : :class:`qutip.FloquetBasis`
+-        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
+-        different integrator for the ``floquet_basis`` than for the evolution
+-        of the floquet state can improve the performance.
+-
+-    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
+-        List of collapse operators and the corresponding function for the noise
+-        power spectrum. The collapse operator must be a :class:`Qobj` and
+-        cannot be time dependent. The spectrum function must take and return
+-        an numpy array.
+-
+-    w_th : float
+-        The temperature of the environment in units of Hamiltonian frequency.
+-
+-    kmax : int [5]
+-        The truncation of the number of sidebands..
+-
+-    nT : int [20*kmax]
+-        The number of integration steps (for calculating X) within one period.
+-
+-    options : dict, optional
+-        Options for the solver, see :obj:`FMESolver.options` and
+-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+-    """
+-
+-    name = "fmmesolve"
+-    _avail_integrators = {}
+-    resultclass = FloquetResult
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size": 10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": True,
+-        "method": "adams",
+-        "store_floquet_states": False,
+-    }
+-
+-    def __init__(
+-        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
+-    ):
+-        self.options = options
+-        if isinstance(floquet_basis, FloquetBasis):
+-            self.floquet_basis = floquet_basis
+-        else:
+-            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
+-
+-        nT = nT or max(100, 20 * kmax)
+-        self._num_collapse = len(a_ops)
+-        c_ops, spectra_cb = zip(*a_ops)
+-        if not all(
+-            isinstance(c_op, Qobj) and callable(spectrum)
+-            for c_op, spectrum in a_ops
+-        ):
+-            raise TypeError("a_ops must be tuple of (Qobj, callable)")
+-        self.rhs = QobjEvo(
+-            floquet_tensor(
+-                self.floquet_basis,
+-                c_ops,
+-                spectra_cb,
+-                w_th=w_th,
+-                kmax=kmax,
+-                nT=nT,
+-            )
+-        )
+-
+-        self._integrator = self._get_integrator()
+-        self._state_metadata = {}
+-        self.stats = self._initialize_stats()
+-
+-    def _initialize_stats(self):
+-        stats = Solver._initialize_stats(self)
+-        stats.update(
+-            {
+-                "solver": "Floquet-Markov master equation",
+-                "num_collapse": self._num_collapse,
+-            }
+-        )
+-        return stats
+-
+-    def _argument(self, args):
+-        if args:
+-            raise ValueError("FMESolver cannot update arguments")
+-
+-    def start(self, state0, t0, *, floquet=False):
+-        """
+-        Set the initial state and time for a step evolution.
+-        ``options`` for the evolutions are read at this step.
+-
+-        Parameters
+-        ----------
+-        state0 : :class:`Qobj`
+-            Initial state of the evolution.
+-
+-        t0 : double
+-            Initial time of the evolution.
+-
+-        floquet : bool, optional {False}
+-            Whether the initial state is in the floquet basis or laboratory
+-            basis.
+-        """
+-        if not floquet:
+-            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
+-        super().start(state0, t0)
+-
+-    def step(self, t, *, args=None, copy=True, floquet=False):
+-        """
+-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+-
+-        Parameters
+-        ----------
+-        t : double
+-            Time to evolve to, must be higher than the last call.
+-
+-        copy : bool, optional {True}
+-            Whether to return a copy of the data or the data in the ODE solver.
+-
+-        floquet : bool, optional {False}
+-            Whether to return the state in the floquet basis or laboratory
+-            basis.
+-
+-        args : dict, optional {None}
+-            Not supported
+-
+-        .. note::
+-            The state must be initialized first by calling ``start`` or
+-            ``run``. If ``run`` is called, ``step`` will continue from the last
+-            time and state obtained.
+-        """
+-        if args:
+-            raise ValueError("FMESolver cannot update arguments")
+-        state = super().step(t)
+-        if not floquet:
+-            state = self.floquet_basis.from_floquet_basis(state, t)
+-        elif copy:
+-            state = state.copy()
+-        return state
+-
+-    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
+-        """
+-        Calculate the evolution of the quantum system.
+-
+-        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
+-        ``rhs`` and for each time in ``tlist`` store the state and/or
+-        expectation values in a :class:`Result`. The evolution method and
+-        stored results are determined by ``options``.
+-
+-        Parameters
+-        ----------
+-        state0 : :class:`Qobj`
+-            Initial state of the evolution.
+-
+-        tlist : list of double
+-            Time for which to save the results (state and/or expect) of the
+-            evolution. The first element of the list is the initial time of the
+-            evolution. Each times of the list must be increasing, but does not
+-            need to be uniformy distributed.
+-
+-        floquet : bool, optional {False}
+-            Whether the initial state in the floquet basis or laboratory basis.
+-
+-        args : dict, optional {None}
+-            Not supported
+-
+-        e_ops : list {None}
+-            List of Qobj, QobjEvo or callable to compute the expectation
+-            values. Function[s] must have the signature
+-            f(t : float, state : Qobj) -> expect.
+-
+-        Returns
+-        -------
+-        results : :class:`qutip.solver.FloquetResult`
+-            Results of the evolution. States and/or expect will be saved. You
+-            can control the saved data in the options.
+-        """
+-        if args:
+-            raise ValueError("FMESolver cannot update arguments")
+-        if not floquet:
+-            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
+-        _time_start = time()
+-        _data0 = self._prepare_state(state0)
+-        self._integrator.set_state(tlist[0], _data0)
+-        stats = self._initialize_stats()
+-        results = self.resultclass(
+-            e_ops,
+-            self.options,
+-            solver=self.name,
+-            stats=stats,
+-            floquet_basis=self.floquet_basis,
+-        )
+-        results.add(tlist[0], self._restore_state(_data0, copy=False))
+-        stats["preparation time"] += time() - _time_start
+-
+-        progress_bar = progess_bars[self.options["progress_bar"]]()
+-        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
+-        for t, state in self._integrator.run(tlist):
+-            progress_bar.update()
+-            results.add(t, self._restore_state(state, copy=False))
+-        progress_bar.finished()
+-
+-        stats["run time"] = progress_bar.total_time()
+-        # TODO: It would be nice if integrator could give evolution statistics
+-        # stats.update(_integrator.stats)
+-        return results
++__all__ = [
++    "FloquetBasis",
++    "floquet_tensor",
++    "fsesolve",
++    "fmmesolve",
++    "FMESolver",
++]
++
++import numpy as np
++from qutip.core import data as _data
++from qutip import Qobj, QobjEvo
++from .propagator import Propagator
++from .mesolve import MESolver
++from .solver_base import Solver
++from .integrator import Integrator
++from .result import Result
++from time import time
++from ..ui.progressbar import progess_bars
++
++
++class FloquetBasis:
++    """
++    Utility to compute floquet modes and states.
++
++    Attributes
++    ----------
++    U : :class:`Propagator`
++        The propagator of the Hamiltonian over one period.
++
++    evecs : :class:`qutip.data.Data`
++        Matrix where each column is an initial Floquet mode.
++
++    e_quasi : np.ndarray[float]
++        The quasi energies of the Hamiltonian.
++    """
++
++    def __init__(
++        self,
++        H,
++        T,
++        args=None,
++        options=None,
++        sparse=False,
++        sort=True,
++        precompute=None,
++    ):
++        """
++        Parameters
++        ----------
++        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
++            System Hamiltonian, with period `T`.
++
++        T : float
++            Period of the Hamiltonian.
++
++        args : None / *dictionary*
++            dictionary of parameters for time-dependent Hamiltonians and
++            collapse operators.
++
++        options : dict [None]
++            Options used by sesolve to compute the floquet modes.
++
++        sparse : bool [False]
++            Whether to use the sparse eigen solver when computing the
++            quasi-energies.
++
++        sort : bool [True]
++            Whether to sort the quasi-energies.
++
++        precompute : list [None]
++            If provided, a list of time at which to store the propagators
++            for later use when computing modes and states. Default is
++            ``linspace(0, T, 101)`` corresponding to the default integration
++            steps used for the floquet tensor computation.
++        """
++        if not T > 0:
++            raise ValueError("The period need to be a positive number.")
++        self.T = T
++        if precompute is not None:
++            tlist = np.unique(np.atleast_1d(precompute) % self.T)
++            memoize = len(tlist)
++            if tlist[0] != 0:
++                memoize += 1
++            if tlist[-1] != T:
++                memoize += 1
++        else:
++            # Default computation
++            tlist = np.linspace(0, T, 101)
++            memoize = 101
++        self.U = Propagator(H, args=args, options=options, memoize=memoize)
++        for t in tlist:
++            # Do the evolution by steps to save the intermediate results.
++            self.U(t)
++        U_T = self.U(self.T)
++        if not sparse and isinstance(U_T.data, _data.CSR):
++            U_T = U_T.to("Dense")
++        evals, evecs = _data.eigs(U_T.data)
++        e_quasi = -np.angle(evals) / T
++        if sort:
++            perm = np.argsort(e_quasi)
++            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
++            self.e_quasi = e_quasi[perm]
++        else:
++            self.evecs = evecs
++            self.e_quasi = e_quasi
++
++    def _as_ketlist(self, kets_mat):
++        """
++        Split the Data array in a list of kets.
++        """
++        dims = [self.U(0).dims[0], [1]]
++        return [
++            Qobj(ket, dims=dims, type="ket")
++            for ket in _data.split_columns(kets_mat)
++        ]
++
++    def mode(self, t, data=False):
++        """
++        Calculate the Floquet modes at time ``t``.
++
++        Parameters
++        ----------
++        t : float
++            The time for which to evaluate the Floquet mode.
++
++        data : bool [False]
++            Whether to return the states as a single data matrix or a list of
++            ket states.
++
++        Returns
++        -------
++        output : list[:class:`Qobj`], :class:`qutip.data.Data`
++            A list of Floquet states for the time ``t`` or the states as column
++            in a single matrix.
++        """
++        t = t % self.T
++        if t == 0.0:
++            kets_mat = self.evecs
++        else:
++            U = self.U(t).data
++            phases = _data.diag(np.exp(1j * t * self.e_quasi))
++            kets_mat = U @ self.evecs @ phases
++        if data:
++            return kets_mat
++        else:
++            return self._as_ketlist(kets_mat)
++
++    def state(self, t, data=False):
++        """
++        Evaluate the floquet states at time t.
++
++        Parameters
++        ----------
++        t : float
++            The time for which to evaluate the Floquet states.
++
++        data : bool [False]
++            Whether to return the states as a single data matrix or a list of
++            ket states.
++
++        Returns
++        -------
++        output : list[:class:`Qobj`], :class:`qutip.data.Data`
++            A list of Floquet states for the time ``t`` or the states as column
++            in a single matrix.
++        """
++        if t:
++            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
++            states_mat = self.mode(t, True) @ phases
++        else:
++            states_mat = self.evecs
++        if data:
++            return states_mat
++        else:
++            return self._as_ketlist(states_mat)
++
++    def from_floquet_basis(self, floquet_basis, t=0):
++        """
++        Transform a ket or density matrix from the Floquet basis at time ``t``
++        to the lab basis.
++
++        Parameters
++        ----------
++        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
++            Initial state in the Floquet basis at time ``t``. May be either a
++            ket or density matrix.
++
++        t : float [0]
++            The time at which to evaluate the Floquet states.
++
++        Returns
++        -------
++        output : :class:`Qobj`, :class:`qutip.data.Data`
++            The state in the lab basis. The return type is the same as the type
++            of the input state.
++        """
++        is_Qobj = isinstance(floquet_basis, Qobj)
++        if is_Qobj:
++            dims = floquet_basis.dims
++            floquet_basis = floquet_basis.data
++            if dims[0] != self.U(0).dims[1]:
++                raise ValueError(
++                    "Dimensions of the state do not match the Hamiltonian"
++                )
++
++        state_mat = self.state(t, True)
++        lab_basis = state_mat @ floquet_basis
++        if floquet_basis.shape[1] != 1:
++            lab_basis = lab_basis @ state_mat.adjoint()
++
++        if is_Qobj:
++            return Qobj(lab_basis, dims=dims)
++        return lab_basis
++
++    def to_floquet_basis(self, lab_basis, t=0):
++        """
++        Transform a ket or density matrix in the lab basis
++        to the Floquet basis at time ``t``.
++
++        Parameters
++        ----------
++        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
++            Initial state in the lab basis.
++
++        t : float [0]
++            The time at which to evaluate the Floquet states.
++
++        Returns
++        -------
++        output : :class:`Qobj`, :class:`qutip.data.Data`
++            The state in the Floquet basis. The return type is the same as the
++            type of the input state.
++        """
++        is_Qobj = isinstance(lab_basis, Qobj)
++        if is_Qobj:
++            dims = lab_basis.dims
++            lab_basis = lab_basis.data
++            if dims[0] != self.U(0).dims[1]:
++                raise ValueError(
++                    "Dimensions of the state do not match the Hamiltonian"
++                )
++
++        state_mat = self.state(t, True)
++        floquet_basis = state_mat.adjoint() @ lab_basis
++        if lab_basis.shape[1] != 1:
++            floquet_basis = floquet_basis @ state_mat
++
++        if is_Qobj:
++            return Qobj(floquet_basis, dims=dims)
++        return floquet_basis
++
++
++def _floquet_delta_tensor(f_energies, kmax, T):
++    """
++    Floquet-Markov master equation X matrices.
++
++    Parameters
++    ----------
++    f_energies : np.ndarray
++        The Floquet energies.
++
++    kmax : int
++        The truncation of the number of sidebands (default 5).
++
++    T : float
++        The period of the time-dependence of the Hamiltonian.
++
++    Returns
++    -------
++    delta : np.ndarray
++        Floquet delta tensor.
++    """
++    delta = np.subtract.outer(f_energies, f_energies)
++    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
++
++
++def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
++    """
++    Floquet-Markov master equation X matrices.
++
++    Parameters
++    ----------
++    floquet_basis : :class:`FloquetBasis`
++        The system Hamiltonian wrapped in a FloquetBasis object.
++
++    c_ops : list of :class:`Qobj`
++        The collapse operators describing the dissipation.
++
++    kmax : int
++        The truncation of the number of sidebands (default 5).
++
++    ntimes : int [100]
++        The number of integration steps (for calculating X) within one period.
++
++    Returns
++    -------
++    X : list of dict of :class:`qutip.data.Data`
++        A dict of the sidebands ``k`` for the X matrices of each c_ops
++    """
++    T = floquet_basis.T
++    N = floquet_basis.U(0).shape[0]
++    omega = (2 * np.pi) / T
++    tlist = np.linspace(T / ntimes, T, ntimes)
++    ks = np.arange(-kmax, kmax + 1)
++    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
++
++    for t in tlist:
++        mode = floquet_basis.mode(t, data=True)
++        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
++        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
++            out[k] = [
++                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
++            ]
++
++    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
++
++
++def _floquet_gamma_matrices(X, delta, J_cb):
++    """
++    Floquet-Markov master equation gamma matrices.
++
++    Parameters
++    ----------
++    X : list of dict of :class:`qutip.data.Data`
++        Floquet X matrices created by :func:`_floquet_X_matrices`.
++
++    delta : np.ndarray
++        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
++
++    J_cb : list of callables
++        A list callback functions that compute the noise power spectrum as
++        a function of frequency. The list should contain one callable for each
++        collapse operator `c_op`, in the same order as the elements of `X`.
++        Each callable should accept a numpy array of frequencies and return a
++        numpy array of corresponding noise power.
++
++    Returns
++    -------
++    gammas : dict of :class:`qutip.data.Data`
++        A dict mapping the sidebands ``k`` to their gamma matrices.
++    """
++    N = delta.shape[0]
++    kmax = (delta.shape[2] - 1) // 2
++    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
++
++    for X_c_op, sp in zip(X, J_cb):
++        response = sp(delta) * ((2 + 0j) * np.pi)
++        response = [
++            _data.Dense(response[:, :, k], copy=False)
++            for k in range(2 * kmax + 1)
++        ]
++        for k in range(-kmax, kmax + 1, 1):
++            gamma[k] = _data.add(
++                gamma[k],
++                _data.multiply(
++                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
++                    response[k + kmax],
++                ),
++            )
++    return gamma
++
++
++def _floquet_A_matrix(delta, gamma, w_th):
++    """
++    Floquet-Markov master equation rate matrix.
++
++    Parameters
++    ----------
++    delta : np.ndarray
++        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
++
++    gamma : dict of :class:`qutip.data.Data`
++        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
++
++    w_th : float
++        The temperature in units of frequency.
++    """
++    kmax = (delta.shape[2] - 1) // 2
++
++    if w_th > 0.0:
++        deltap = np.copy(delta)
++        deltap[deltap == 0.0] = np.inf
++        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
++        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
++
++        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
++        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
++
++        for k in range(1, kmax + 1):
++            g_kk = _data.add(gamma[k], gamma[-k].transpose())
++            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
++            A = _data.add(A, _data.add(gamma[k], thermal_kk))
++            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
++            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
++    else:
++        # w_th is 0, thermal = 0s
++        A = gamma[0]
++        for k in range(1, kmax + 1):
++            A = _data.add(gamma[k], A)
++            A = _data.add(gamma[-k], A)
++
++    return A
++
++
++def _floquet_master_equation_tensor(A):
++    """
++    Construct a tensor that represents the master equation in the floquet
++    basis (with constant Hamiltonian and collapse operators?).
++
++    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
++
++    Parameters
++    ----------
++    A : :class:`qutip.data.Data`
++        Floquet-Markov master equation rate matrix.
++
++    Returns
++    -------
++    output : array
++        The Floquet-Markov master equation tensor `R`.
++    """
++    N = A.shape[0]
++
++    # R[i+N*i, j+N*j] = A[j, i]
++    cols = np.arange(N, dtype=np.int32)
++    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
++    data = np.ones(N, dtype=complex)
++    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
++
++    R = expand @ A.transpose() @ expand.transpose()
++
++    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
++    ket_1 = _data.Dense(np.ones(N, dtype=complex))
++    Asum = A @ ket_1
++    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
++    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
++
++    return _data.add(R, S)
++
++
++def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
++    """
++    Construct a tensor that represents the master equation in the floquet
++    basis.
++
++    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
++
++    Parameters
++    ----------
++    H : :class:`QobjEvo`
++        Periodic Hamiltonian
++
++    T : float
++        The period of the time-dependence of the hamiltonian.
++
++    c_ops : list of :class:`qutip.qobj`
++        list of collapse operators.
++
++    spectra_cb : list callback functions
++        List of callback functions that compute the noise power spectrum as
++        a function of frequency for the collapse operators in `c_ops`.
++
++    w_th : float
++        The temperature in units of frequency.
++
++    kmax : int
++        The truncation of the number of sidebands (default 5).
++
++    Returns
++    -------
++    output : array
++        The Floquet-Markov master equation tensor `R`.
++    """
++    if isinstance(H, FloquetBasis):
++        floquet_basis = H
++        T = H.T
++    else:
++        floquet_basis = FloquetBasis(H, T)
++    energy = floquet_basis.e_quasi
++    delta = _floquet_delta_tensor(energy, kmax, T)
++    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
++    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
++    a = _floquet_A_matrix(delta, gamma, w_th)
++    r = _floquet_master_equation_tensor(a)
++    dims = floquet_basis.U(0).dims
++    return Qobj(
++        r, dims=[dims, dims], type="super", superrep="super", copy=False
++    )
++
++
++def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
++    """
++    Solve the Schrodinger equation using the Floquet formalism.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
++        Periodic system Hamiltonian as :class:`QobjEvo`. List of
++        [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    psi0 : :class:`qutip.qobj`
++        Initial state vector (ket). If an operator is provided,
++
++    tlist : *list* / *array*
++        List of times for :math:`t`.
++
++    e_ops : list of :class:`qutip.qobj` / callback function, optional
++        List of operators for which to evaluate expectation values. If this
++        list is empty, the state vectors for each time in `tlist` will be
++        returned instead of expectation values.
++
++    T : float, default=tlist[-1]
++        The period of the time-dependence of the hamiltonian.
++
++    args : dictionary, optional
++        Dictionary with variables required to evaluate H.
++
++    options : dict, optional
++        Options for the results.
++
++        - store_final_state : bool
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, None
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - normalize_output : bool
++          Normalize output state to hide ODE numerical errors.
++
++    Returns
++    -------
++    output : :class:`qutip.solver.Result`
++        An instance of the class :class:`qutip.solver.Result`, which
++        contains either an *array* of expectation values or an array of
++        state vectors, for the times specified by `tlist`.
++    """
++    if isinstance(H, FloquetBasis):
++        floquet_basis = H
++    else:
++        T = T or tlist[-1]
++        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
++        # are for the open system evolution.
++        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
++
++    f_coeff = floquet_basis.to_floquet_basis(psi0)
++    result_options = {
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": True,
++    }
++    result_options.update(options or {})
++    result = Result(e_ops, result_options, solver="fsesolve")
++    for t in tlist:
++        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
++        result.add(t, state_t)
++
++    return result
++
++
++def fmmesolve(
++    H,
++    rho0,
++    tlist,
++    c_ops=None,
++    e_ops=None,
++    spectra_cb=None,
++    T=0,
++    w_th=0.0,
++    args=None,
++    options=None,
++):
++    """
++    Solve the dynamics for the system using the Floquet-Markov master equation.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
++        Periodic system Hamiltonian as :class:`QobjEvo`. List of
++        [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    rho0 / psi0 : :class:`qutip.Qobj`
++        Initial density matrix or state vector (ket).
++
++    tlist : *list* / *array*
++        List of times for :math:`t`.
++
++    c_ops : list of :class:`qutip.Qobj`
++        List of collapse operators. Time dependent collapse operators are not
++        supported.
++
++    e_ops : list of :class:`qutip.Qobj` / callback function
++        List of operators for which to evaluate expectation values.
++        The states are reverted to the lab basis before applying the
++
++    spectra_cb : list callback functions
++        List of callback functions that compute the noise power spectrum as
++        a function of frequency for the collapse operators in `c_ops`.
++
++    T : float
++        The period of the time-dependence of the hamiltonian. The default value
++        'None' indicates that the 'tlist' spans a single period of the driving.
++
++    w_th : float
++        The temperature of the environment in units of frequency.
++        For example, if the Hamiltonian written in units of 2pi GHz, and the
++        temperature is given in K, use the following conversion:
++
++            temperature = 25e-3 # unit K
++            h = 6.626e-34
++            kB = 1.38e-23
++            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
++
++    args : *dictionary*
++        Dictionary of parameters for time-dependent Hamiltonian
++
++    options : None / dict
++        Dictionary of options for the solver.
++
++        - store_final_state : bool
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, None
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - store_floquet_states : bool
++          Whether or not to store the density matrices in the floquet basis in
++          ``result.floquet_states``.
++        - normalize_output : bool
++          Normalize output state to hide ODE numerical errors.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
++          Which differential equation integration method to use.
++        - atol, rtol : float
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps :
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - max_step : float, 0
++          Maximum lenght of one internal step. When using pulses, it should be
++          less than half the width of the thinnest pulse.
++
++        Other options could be supported depending on the integration method,
++        see `Integrator <./classes.html#classes-ode>`_.
++
++    Returns
++    -------
++    result: :class:`qutip.Result`
++
++        An instance of the class :class:`qutip.Result`, which contains
++        the expectation values for the times specified by `tlist`, and/or the
++        state density matrices corresponding to the times.
++    """
++    if c_ops is None:
++        return fsesolve(
++            H,
++            rho0,
++            tlist,
++            e_ops=e_ops,
++            T=T,
++            w_th=w_th,
++            args=args,
++            options=options,
++        )
++
++    if isinstance(H, FloquetBasis):
++        floquet_basis = H
++    else:
++        T = T or tlist[-1]
++        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
++        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
++        # are for the open system evolution.
++        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
++
++    if not w_th and args:
++        w_th = args.get("w_th", 0.0)
++
++    if isinstance(c_ops, Qobj):
++        c_ops = [c_ops]
++
++    if spectra_cb is None:
++        spectra_cb = [lambda w: (w > 0)]
++    elif callable(spectra_cb):
++        spectra_cb = [spectra_cb]
++    if len(spectra_cb) == 1:
++        spectra_cb = spectra_cb * len(c_ops)
++
++    a_ops = list(zip(c_ops, spectra_cb))
++
++    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
++    return solver.run(rho0, tlist, e_ops=e_ops)
++
++
++class FloquetResult(Result):
++    def _post_init(self, floquet_basis):
++        self.floquet_basis = floquet_basis
++        if self.options["store_floquet_states"]:
++            self.floquet_states = []
++        else:
++            self.floquet_states = None
++        super()._post_init()
++
++    def add(self, t, state):
++        if self.options["store_floquet_states"]:
++            self.floquet_states.append(state)
++
++        state = self.floquet_basis.from_floquet_basis(state, t)
++        super().add(t, state)
++
++
++class FMESolver(MESolver):
++    """
++    Solver for the Floquet-Markov master equation.
++
++    .. note ::
++        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
++
++    Parameters
++    ----------
++    floquet_basis : :class:`qutip.FloquetBasis`
++        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
++        different integrator for the ``floquet_basis`` than for the evolution
++        of the floquet state can improve the performance.
++
++    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
++        List of collapse operators and the corresponding function for the noise
++        power spectrum. The collapse operator must be a :class:`Qobj` and
++        cannot be time dependent. The spectrum function must take and return
++        an numpy array.
++
++    w_th : float
++        The temperature of the environment in units of Hamiltonian frequency.
++
++    kmax : int [5]
++        The truncation of the number of sidebands..
++
++    nT : int [20*kmax]
++        The number of integration steps (for calculating X) within one period.
++
++    options : dict, optional
++        Options for the solver, see :obj:`FMESolver.options` and
++        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
++    """
++
++    name = "fmmesolve"
++    _avail_integrators = {}
++    resultclass = FloquetResult
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size": 10},
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": True,
++        "method": "adams",
++        "store_floquet_states": False,
++    }
++
++    def __init__(
++        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
++    ):
++        self.options = options
++        if isinstance(floquet_basis, FloquetBasis):
++            self.floquet_basis = floquet_basis
++        else:
++            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
++
++        nT = nT or max(100, 20 * kmax)
++        self._num_collapse = len(a_ops)
++        c_ops, spectra_cb = zip(*a_ops)
++        if not all(
++            isinstance(c_op, Qobj) and callable(spectrum)
++            for c_op, spectrum in a_ops
++        ):
++            raise TypeError("a_ops must be tuple of (Qobj, callable)")
++        self.rhs = QobjEvo(
++            floquet_tensor(
++                self.floquet_basis,
++                c_ops,
++                spectra_cb,
++                w_th=w_th,
++                kmax=kmax,
++                nT=nT,
++            )
++        )
++
++        self._integrator = self._get_integrator()
++        self._state_metadata = {}
++        self.stats = self._initialize_stats()
++
++    def _initialize_stats(self):
++        stats = Solver._initialize_stats(self)
++        stats.update(
++            {
++                "solver": "Floquet-Markov master equation",
++                "num_collapse": self._num_collapse,
++            }
++        )
++        return stats
++
++    def _argument(self, args):
++        if args:
++            raise ValueError("FMESolver cannot update arguments")
++
++    def start(self, state0, t0, *, floquet=False):
++        """
++        Set the initial state and time for a step evolution.
++        ``options`` for the evolutions are read at this step.
++
++        Parameters
++        ----------
++        state0 : :class:`Qobj`
++            Initial state of the evolution.
++
++        t0 : double
++            Initial time of the evolution.
++
++        floquet : bool, optional {False}
++            Whether the initial state is in the floquet basis or laboratory
++            basis.
++        """
++        if not floquet:
++            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
++        super().start(state0, t0)
++
++    def step(self, t, *, args=None, copy=True, floquet=False):
++        """
++        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
++
++        Parameters
++        ----------
++        t : double
++            Time to evolve to, must be higher than the last call.
++
++        copy : bool, optional {True}
++            Whether to return a copy of the data or the data in the ODE solver.
++
++        floquet : bool, optional {False}
++            Whether to return the state in the floquet basis or laboratory
++            basis.
++
++        args : dict, optional {None}
++            Not supported
++
++        .. note::
++            The state must be initialized first by calling ``start`` or
++            ``run``. If ``run`` is called, ``step`` will continue from the last
++            time and state obtained.
++        """
++        if args:
++            raise ValueError("FMESolver cannot update arguments")
++        state = super().step(t)
++        if not floquet:
++            state = self.floquet_basis.from_floquet_basis(state, t)
++        elif copy:
++            state = state.copy()
++        return state
++
++    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
++        """
++        Calculate the evolution of the quantum system.
++
++        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
++        ``rhs`` and for each time in ``tlist`` store the state and/or
++        expectation values in a :class:`Result`. The evolution method and
++        stored results are determined by ``options``.
++
++        Parameters
++        ----------
++        state0 : :class:`Qobj`
++            Initial state of the evolution.
++
++        tlist : list of double
++            Time for which to save the results (state and/or expect) of the
++            evolution. The first element of the list is the initial time of the
++            evolution. Each times of the list must be increasing, but does not
++            need to be uniformy distributed.
++
++        floquet : bool, optional {False}
++            Whether the initial state in the floquet basis or laboratory basis.
++
++        args : dict, optional {None}
++            Not supported
++
++        e_ops : list {None}
++            List of Qobj, QobjEvo or callable to compute the expectation
++            values. Function[s] must have the signature
++            f(t : float, state : Qobj) -> expect.
++
++        Returns
++        -------
++        results : :class:`qutip.solver.FloquetResult`
++            Results of the evolution. States and/or expect will be saved. You
++            can control the saved data in the options.
++        """
++        if args:
++            raise ValueError("FMESolver cannot update arguments")
++        if not floquet:
++            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
++        _time_start = time()
++        _data0 = self._prepare_state(state0)
++        self._integrator.set_state(tlist[0], _data0)
++        stats = self._initialize_stats()
++        results = self.resultclass(
++            e_ops,
++            self.options,
++            solver=self.name,
++            stats=stats,
++            floquet_basis=self.floquet_basis,
++        )
++        results.add(tlist[0], self._restore_state(_data0, copy=False))
++        stats["preparation time"] += time() - _time_start
++
++        progress_bar = progess_bars[self.options["progress_bar"]]()
++        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
++        for t, state in self._integrator.run(tlist):
++            progress_bar.update()
++            results.add(t, self._restore_state(state, copy=False))
++        progress_bar.finished()
++
++        stats["run time"] = progress_bar.total_time()
++        # TODO: It would be nice if integrator could give evolution statistics
++        # stats.update(_integrator.stats)
++        return results
+diff --git a/qutip/solver/floquet_bwcomp.py b/qutip/solver/floquet_bwcomp.py
+index 8ee683ff..6937240f 100644
+--- a/qutip/solver/floquet_bwcomp.py
++++ b/qutip/solver/floquet_bwcomp.py
+@@ -1,244 +1,244 @@
+-""" Floquet solver compatibility functions that behave like the corresponding
+-functions from QuTiP 4.7.
+-
+-These functions are indented to be used when porting code from QuTiP 4.7 to
+-QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
+-"""
+-
+-__all__ = [
+-    "floquet_modes",
+-    "floquet_modes_t",
+-    "floquet_modes_table",
+-    "floquet_modes_t_lookup",
+-    "floquet_states",
+-    "floquet_states_t",
+-    "floquet_wavefunction",
+-    "floquet_wavefunction_t",
+-    "floquet_state_decomposition",
+-    "floquet_master_equation_rates",
+-]
+-
+-from .floquet import *
+-import numpy as np
+-import warnings
+-
+-
+-def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
+-    """
+-    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
+-    period T.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
+-    f_mode_0 = fbasis.mode(0)
+-    f_energies = fbasis.e_quasi
+-    """
+-    warnings.warn(FutureWarning(
+-        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
+-    ))
+-    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
+-    f_mode_0 = fbasis.mode(0)
+-    f_energies = fbasis.e_quasi
+-    return f_mode_0, f_energies
+-
+-
+-def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
+-    """
+-    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
+-    initial Floquet modes Phi_alpha(0).
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    f_mode_t = fbasis.mode(t)
+-    """
+-    warnings.warn(FutureWarning(
+-        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
+-    ))
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    return fbasis.mode(t)
+-
+-
+-def floquet_modes_table(
+-    f_modes_0, f_energies, tlist, H, T, args=None, options=None
+-):
+-    """
+-    Pre-calculate the Floquet modes for a range of times spanning the floquet
+-    period. Can later be used as a table to look up the floquet modes for
+-    any time.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
+-    """
+-    raise NotImplementedError("`floquet_modes_table` is deprecated.")
+-
+-
+-def floquet_modes_t_lookup(f_modes_table_t, t, T):
+-    """
+-    Lookup the floquet mode at time t in the pre-calculated table of floquet
+-    modes in the first period of the time-dependence.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    f_modes_table_t = fbasis = FloquetBasis(...)
+-    f_mode_t = f_modes_table_t.mode(t)
+-    """
+-    raise NotImplementedError(
+-        "`floquet_modes_t_lookup` is no longer provided. "
+-        "Use `FloquetBasis` instead."
+-    )
+-
+-
+-def floquet_states(f_modes_t, f_energies, t):
+-    """
+-    Evaluate the floquet states at time t given the Floquet modes at that time.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    f_state_t = fbasis.state(t)
+-    """
+-    warnings.warn(FutureWarning(
+-        "`floquet_states` is deprecated. "
+-        "Use `FloquetBasis.state` instead."
+-    ))
+-    return [
+-        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
+-        for i in np.arange(len(f_energies))
+-    ]
+-
+-
+-def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
+-    """
+-    Evaluate the floquet states at time t given the initial Floquet modes.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    f_state_t = fbasis.state(t)
+-    """
+-    warnings.warn(FutureWarning(
+-        "`floquet_states_t` is deprecated. "
+-        "Use `FloquetBasis.state` instead."
+-    ))
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    return fbasis.state(t)
+-
+-
+-def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
+-    """
+-    Evaluate the wavefunction for a time t using the Floquet state
+-    decompositon, given the Floquet modes at time `t`.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    psi_t = fbasis.from_floquet_basis(f_coeff, t)
+-    """
+-    raise NotImplementedError(
+-        "`floquet_wavefunction` is not longer provided. "
+-        "Use `FloquetBasis.from_floquet_basis` instead."
+-    )
+-
+-
+-def floquet_wavefunction_t(
+-    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
+-):
+-    """
+-    Evaluate the wavefunction for a time t using the Floquet state
+-    decompositon, given the initial Floquet modes.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    psi_t = fbasis.from_floquet_basis(f_coeff, t)
+-    """
+-    warnings.warn(FutureWarning(
+-        "`floquet_wavefunction_t` is deprecated. "
+-        "Use `FloquetBasis.from_floquet_basis` instead."
+-    ))
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    return fbasis.from_floquet_basis(f_coeff, t)
+-
+-
+-def floquet_state_decomposition(f_states, f_energies, psi):
+-    r"""
+-    Decompose the wavefunction `psi` (typically an initial state) in terms of
+-    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
+-
+-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+-
+-    fbasis = FloquetBasis(H, T, args=args, options=options)
+-    f_coeff = fbasis.to_floquet_basis(psi)
+-    """
+-    raise NotImplementedError(
+-        "`floquet_state_decomposition` is deprecated. "
+-        "Use `FloquetBasis.to_floquet_basis` instead."
+-    )
+-
+-
+-def floquet_master_equation_rates(
+-    f_modes_0,
+-    f_energies,
+-    c_op,
+-    H,
+-    T,
+-    args,
+-    J_cb,
+-    w_th,
+-    kmax=5,
+-    f_modes_table_t=None,
+-):
+-    """
+-    Calculate the rates and matrix elements for the Floquet-Markov master
+-    equation.
+-
+-    .. note ::
+-
+-        Deprecated. For the Floquet-Markov master equation's tensor, use
+-        :func:`floquet_tensor`. For the rates matrices, use
+-        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
+-        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
+-
+-    Parameters
+-    ----------
+-    f_modes_0 : Any
+-        No longer used.
+-    f_energies : Any
+-        No longer used.
+-    c_op : :class:`qutip.qobj`
+-        The collapse operators describing the dissipation.
+-    H : :class:`qutip.qobj`
+-        System Hamiltonian, time-dependent with period `T`.
+-    T : float
+-        The period of the time-dependence of the hamiltonian.
+-    args : dictionary
+-        Dictionary with variables required to evaluate H.
+-    J_cb : callback functions
+-        A callback function that computes the noise power spectrum, as
+-        a function of frequency, associated with the collapse operator `c_op`.
+-    w_th : float
+-        The temperature in units of frequency.
+-    kmax : int, default=5
+-        The truncation of the number of sidebands.
+-    f_modes_table_t : Any
+-        No longer used.
+-
+-    Returns
+-    -------
+-    output : list
+-        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
+-        and A used in the construction of the Floquet-Markov master equation.
+-    """
+-    warnings.warn(
+-        FutureWarning("`floquet_master_equation_rates` is deprecated.")
+-    )
+-    floquet_basis = FloquetBasis(H, T, args=args)
+-    energy = floquet_basis.e_quasi
+-    delta = floquet_delta_tensor(energy, kmax, T)
+-    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
+-    gamma = floquet_gamma_matrices(x, delta, [J_cb])
+-    a = floquet_A_matrix(delta, gamma, w_th)
+-    return delta, x[0], gamma, a
++""" Floquet solver compatibility functions that behave like the corresponding
++functions from QuTiP 4.7.
++
++These functions are indented to be used when porting code from QuTiP 4.7 to
++QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
++"""
++
++__all__ = [
++    "floquet_modes",
++    "floquet_modes_t",
++    "floquet_modes_table",
++    "floquet_modes_t_lookup",
++    "floquet_states",
++    "floquet_states_t",
++    "floquet_wavefunction",
++    "floquet_wavefunction_t",
++    "floquet_state_decomposition",
++    "floquet_master_equation_rates",
++]
++
++from .floquet import *
++import numpy as np
++import warnings
++
++
++def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
++    """
++    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
++    period T.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
++    f_mode_0 = fbasis.mode(0)
++    f_energies = fbasis.e_quasi
++    """
++    warnings.warn(FutureWarning(
++        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
++    ))
++    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
++    f_mode_0 = fbasis.mode(0)
++    f_energies = fbasis.e_quasi
++    return f_mode_0, f_energies
++
++
++def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
++    """
++    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
++    initial Floquet modes Phi_alpha(0).
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    f_mode_t = fbasis.mode(t)
++    """
++    warnings.warn(FutureWarning(
++        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
++    ))
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    return fbasis.mode(t)
++
++
++def floquet_modes_table(
++    f_modes_0, f_energies, tlist, H, T, args=None, options=None
++):
++    """
++    Pre-calculate the Floquet modes for a range of times spanning the floquet
++    period. Can later be used as a table to look up the floquet modes for
++    any time.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
++    """
++    raise NotImplementedError("`floquet_modes_table` is deprecated.")
++
++
++def floquet_modes_t_lookup(f_modes_table_t, t, T):
++    """
++    Lookup the floquet mode at time t in the pre-calculated table of floquet
++    modes in the first period of the time-dependence.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    f_modes_table_t = fbasis = FloquetBasis(...)
++    f_mode_t = f_modes_table_t.mode(t)
++    """
++    raise NotImplementedError(
++        "`floquet_modes_t_lookup` is no longer provided. "
++        "Use `FloquetBasis` instead."
++    )
++
++
++def floquet_states(f_modes_t, f_energies, t):
++    """
++    Evaluate the floquet states at time t given the Floquet modes at that time.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    f_state_t = fbasis.state(t)
++    """
++    warnings.warn(FutureWarning(
++        "`floquet_states` is deprecated. "
++        "Use `FloquetBasis.state` instead."
++    ))
++    return [
++        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
++        for i in np.arange(len(f_energies))
++    ]
++
++
++def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
++    """
++    Evaluate the floquet states at time t given the initial Floquet modes.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    f_state_t = fbasis.state(t)
++    """
++    warnings.warn(FutureWarning(
++        "`floquet_states_t` is deprecated. "
++        "Use `FloquetBasis.state` instead."
++    ))
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    return fbasis.state(t)
++
++
++def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
++    """
++    Evaluate the wavefunction for a time t using the Floquet state
++    decompositon, given the Floquet modes at time `t`.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    psi_t = fbasis.from_floquet_basis(f_coeff, t)
++    """
++    raise NotImplementedError(
++        "`floquet_wavefunction` is not longer provided. "
++        "Use `FloquetBasis.from_floquet_basis` instead."
++    )
++
++
++def floquet_wavefunction_t(
++    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
++):
++    """
++    Evaluate the wavefunction for a time t using the Floquet state
++    decompositon, given the initial Floquet modes.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    psi_t = fbasis.from_floquet_basis(f_coeff, t)
++    """
++    warnings.warn(FutureWarning(
++        "`floquet_wavefunction_t` is deprecated. "
++        "Use `FloquetBasis.from_floquet_basis` instead."
++    ))
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    return fbasis.from_floquet_basis(f_coeff, t)
++
++
++def floquet_state_decomposition(f_states, f_energies, psi):
++    r"""
++    Decompose the wavefunction `psi` (typically an initial state) in terms of
++    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
++
++    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
++
++    fbasis = FloquetBasis(H, T, args=args, options=options)
++    f_coeff = fbasis.to_floquet_basis(psi)
++    """
++    raise NotImplementedError(
++        "`floquet_state_decomposition` is deprecated. "
++        "Use `FloquetBasis.to_floquet_basis` instead."
++    )
++
++
++def floquet_master_equation_rates(
++    f_modes_0,
++    f_energies,
++    c_op,
++    H,
++    T,
++    args,
++    J_cb,
++    w_th,
++    kmax=5,
++    f_modes_table_t=None,
++):
++    """
++    Calculate the rates and matrix elements for the Floquet-Markov master
++    equation.
++
++    .. note ::
++
++        Deprecated. For the Floquet-Markov master equation's tensor, use
++        :func:`floquet_tensor`. For the rates matrices, use
++        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
++        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
++
++    Parameters
++    ----------
++    f_modes_0 : Any
++        No longer used.
++    f_energies : Any
++        No longer used.
++    c_op : :class:`qutip.qobj`
++        The collapse operators describing the dissipation.
++    H : :class:`qutip.qobj`
++        System Hamiltonian, time-dependent with period `T`.
++    T : float
++        The period of the time-dependence of the hamiltonian.
++    args : dictionary
++        Dictionary with variables required to evaluate H.
++    J_cb : callback functions
++        A callback function that computes the noise power spectrum, as
++        a function of frequency, associated with the collapse operator `c_op`.
++    w_th : float
++        The temperature in units of frequency.
++    kmax : int, default=5
++        The truncation of the number of sidebands.
++    f_modes_table_t : Any
++        No longer used.
++
++    Returns
++    -------
++    output : list
++        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
++        and A used in the construction of the Floquet-Markov master equation.
++    """
++    warnings.warn(
++        FutureWarning("`floquet_master_equation_rates` is deprecated.")
++    )
++    floquet_basis = FloquetBasis(H, T, args=args)
++    energy = floquet_basis.e_quasi
++    delta = floquet_delta_tensor(energy, kmax, T)
++    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
++    gamma = floquet_gamma_matrices(x, delta, [J_cb])
++    a = floquet_A_matrix(delta, gamma, w_th)
++    return delta, x[0], gamma, a
+diff --git a/qutip/solver/heom/__init__.py b/qutip/solver/heom/__init__.py
+index 9a8264b0..2ae10e1b 100644
+--- a/qutip/solver/heom/__init__.py
++++ b/qutip/solver/heom/__init__.py
+@@ -1,55 +1,55 @@
+-"""
+-This module provides solvers for system-bath evoluation using the
+-HEOM (hierarchy equations of motion).
+-
+-See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
+-basic introduction to the technique.
+-
+-The implementation is derived from the BoFiN library (see
+-https://github.com/tehruhn/bofin) which was itself derived from an earlier
+-implementation in QuTiP itself.
+-
+-For backwards compatibility with QuTiP 4.6 and below, a new version of
+-HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
+-implemented on top of the new HEOMSolver but should largely be a drop-in
+-replacement for the old HSolverDL.
+-"""
+-
+-__all__ = [
+-    "BathExponent",
+-    "Bath",
+-    "BosonicBath",
+-    "DrudeLorentzBath",
+-    "DrudeLorentzPadeBath",
+-    "UnderDampedBath",
+-    "FermionicBath",
+-    "LorentzianBath",
+-    "LorentzianPadeBath",
+-    "heomsolve",
+-    "HEOMSolver",
+-    "HEOMResult",
+-    "HSolverDL",
+-    "HierarchyADOs",
+-    "HierarchyADOsState",
+-]
+-
+-from .bofin_baths import (
+-    BathExponent,
+-    Bath,
+-    BosonicBath,
+-    DrudeLorentzBath,
+-    DrudeLorentzPadeBath,
+-    UnderDampedBath,
+-    FermionicBath,
+-    LorentzianBath,
+-    LorentzianPadeBath,
+-)
+-
+-from .bofin_solvers import (
+-    heomsolve,
+-    HEOMSolver,
+-    HEOMResult,
+-    HSolverDL,
+-    HierarchyADOs,
+-    HierarchyADOsState,
+-)
++"""
++This module provides solvers for system-bath evoluation using the
++HEOM (hierarchy equations of motion).
++
++See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
++basic introduction to the technique.
++
++The implementation is derived from the BoFiN library (see
++https://github.com/tehruhn/bofin) which was itself derived from an earlier
++implementation in QuTiP itself.
++
++For backwards compatibility with QuTiP 4.6 and below, a new version of
++HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
++implemented on top of the new HEOMSolver but should largely be a drop-in
++replacement for the old HSolverDL.
++"""
++
++__all__ = [
++    "BathExponent",
++    "Bath",
++    "BosonicBath",
++    "DrudeLorentzBath",
++    "DrudeLorentzPadeBath",
++    "UnderDampedBath",
++    "FermionicBath",
++    "LorentzianBath",
++    "LorentzianPadeBath",
++    "heomsolve",
++    "HEOMSolver",
++    "HEOMResult",
++    "HSolverDL",
++    "HierarchyADOs",
++    "HierarchyADOsState",
++]
++
++from .bofin_baths import (
++    BathExponent,
++    Bath,
++    BosonicBath,
++    DrudeLorentzBath,
++    DrudeLorentzPadeBath,
++    UnderDampedBath,
++    FermionicBath,
++    LorentzianBath,
++    LorentzianPadeBath,
++)
++
++from .bofin_solvers import (
++    heomsolve,
++    HEOMSolver,
++    HEOMResult,
++    HSolverDL,
++    HierarchyADOs,
++    HierarchyADOsState,
++)
+diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
+index ff64dfc6..0b7f2c2b 100644
+--- a/qutip/solver/heom/bofin_baths.py
++++ b/qutip/solver/heom/bofin_baths.py
+@@ -1,982 +1,982 @@
+-"""
+-This module provides utilities for describing baths when using the
+-HEOM (hierarchy equations of motion) to model system-bath interactions.
+-
+-See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
+-
+-The implementation is derived from the BoFiN library (see
+-https://github.com/tehruhn/bofin) which was itself derived from an earlier
+-implementation in QuTiP itself.
+-"""
+-
+-import enum
+-
+-import numpy as np
+-from scipy.linalg import eigvalsh
+-
+-from qutip.core import data as _data
+-from qutip.core.qobj import Qobj
+-from qutip.core.superoperator import spre, spost
+-
+-__all__ = [
+-    "BathExponent",
+-    "Bath",
+-    "BosonicBath",
+-    "DrudeLorentzBath",
+-    "DrudeLorentzPadeBath",
+-    "UnderDampedBath",
+-    "FermionicBath",
+-    "LorentzianBath",
+-    "LorentzianPadeBath",
+-]
+-
+-
+-def _isequal(Q1, Q2, tol):
+-    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
+-    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
+-
+-
+-class BathExponent:
+-    """
+-    Represents a single exponent (naively, an excitation mode) within the
+-    decomposition of the correlation functions of a bath.
+-
+-    Parameters
+-    ----------
+-    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
+-        The type of bath exponent.
+-
+-        "R" and "I" are bosonic bath exponents that appear in the real and
+-        imaginary parts of the correlation expansion.
+-
+-        "RI" is combined bosonic bath exponent that appears in both the real
+-        and imaginary parts of the correlation expansion. The combined exponent
+-        has a single ``vk``. The ``ck`` is the coefficient in the real
+-        expansion and ``ck2`` is the coefficient in the imaginary expansion.
+-
+-        "+" and "-" are fermionic bath exponents. These fermionic bath
+-        exponents must specify ``sigma_bar_k_offset`` which specifies
+-        the amount to add to ``k`` (the exponent index within the bath of this
+-        exponent) to determine the ``k`` of the corresponding exponent with
+-        the opposite sign (i.e. "-" or "+").
+-
+-    dim : int or None
+-        The dimension (i.e. maximum number of excitations for this exponent).
+-        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
+-        bosonic exponents.
+-
+-    Q : Qobj
+-        The coupling operator for this excitation mode.
+-
+-    vk : complex
+-        The frequency of the exponent of the excitation term.
+-
+-    ck : complex
+-        The coefficient of the excitation term.
+-
+-    ck2 : optional, complex
+-        For exponents of type "RI" this is the coefficient of the term in the
+-        imaginary expansion (and ``ck`` is the coefficient in the real
+-        expansion).
+-
+-    sigma_bar_k_offset : optional, int
+-        For exponents of type "+" this gives the offset (within the list of
+-        exponents within the bath) of the corresponding "-" bath exponent.
+-        For exponents of type "-" it gives the offset of the corresponding
+-        "+" exponent.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the exponent (often the name of the bath). It
+-        defaults to None.
+-
+-    Attributes
+-    ----------
+-    fermionic : bool
+-        True if the type of the exponent is a Fermionic type (i.e. either
+-        "+" or "-") and False otherwise.
+-
+-    All of the parameters are also available as attributes.
+-    """
+-    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
+-
+-    def _check_ck2(self, type, ck2):
+-        if type == self.types["RI"]:
+-            if ck2 is None:
+-                raise ValueError("RI bath exponents require ck2")
+-        else:
+-            if ck2 is not None:
+-                raise ValueError(
+-                    "Second co-efficient (ck2) should only be specified for RI"
+-                    " bath exponents"
+-                )
+-
+-    def _check_sigma_bar_k_offset(self, type, offset):
+-        if type in (self.types["+"], self.types["-"]):
+-            if offset is None:
+-                raise ValueError(
+-                    "+ and - bath exponents require sigma_bar_k_offset"
+-                )
+-        else:
+-            if offset is not None:
+-                raise ValueError(
+-                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
+-                    " specified for + and - bath exponents"
+-                )
+-
+-    def _type_is_fermionic(self, type):
+-        return type in (self.types["+"], self.types["-"])
+-
+-    def __init__(
+-            self, type, dim, Q, ck, vk, ck2=None,
+-            sigma_bar_k_offset=None, tag=None,
+-    ):
+-        if not isinstance(type, self.types):
+-            type = self.types[type]
+-        self._check_ck2(type, ck2)
+-        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
+-        self.type = type
+-        self.fermionic = self._type_is_fermionic(type)
+-        self.dim = dim
+-        self.Q = Q
+-        self.ck = ck
+-        self.vk = vk
+-        self.ck2 = ck2
+-        self.sigma_bar_k_offset = sigma_bar_k_offset
+-        self.tag = tag
+-
+-    def __repr__(self):
+-        dims = getattr(self.Q, "dims", None)
+-        return (
+-            f"<{self.__class__.__name__} type={self.type.name}"
+-            f" dim={self.dim!r}"
+-            f" Q.dims={dims!r}"
+-            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
+-            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
+-            f" fermionic={self.fermionic!r}"
+-            f" tag={self.tag!r}>"
+-        )
+-
+-
+-class Bath:
+-    """
+-    Represents a list of bath expansion exponents.
+-
+-    Parameters
+-    ----------
+-    exponents : list of BathExponent
+-        The exponents of the correlation function describing the bath.
+-
+-    Attributes
+-    ----------
+-
+-    All of the parameters are available as attributes.
+-    """
+-    def __init__(self, exponents):
+-        self.exponents = exponents
+-
+-
+-class BosonicBath(Bath):
+-    """
+-    A helper class for constructing a bosonic bath from the expansion
+-    coefficients and frequencies for the real and imaginary parts of
+-    the bath correlation function.
+-
+-    If the correlation functions ``C(t)`` is split into real and imaginary
+-    parts::
+-
+-        C(t) = C_real(t) + i * C_imag(t)
+-
+-    then::
+-
+-        C_real(t) = sum(ck_real * exp(- vk_real * t))
+-        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
+-
+-    Defines the coefficients ``ck`` and the frequencies ``vk``.
+-
+-    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
+-    and ``C_imag(t)`` (i.e. the sum) is real.
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        The coupling operator for the bath.
+-
+-    ck_real : list of complex
+-        The coefficients of the expansion terms for the real part of the
+-        correlation function. The corresponding frequencies are passed as
+-        vk_real.
+-
+-    vk_real : list of complex
+-        The frequencies (exponents) of the expansion terms for the real part of
+-        the correlation function. The corresponding ceofficients are passed as
+-        ck_real.
+-
+-    ck_imag : list of complex
+-        The coefficients of the expansion terms in the imaginary part of the
+-        correlation function. The corresponding frequencies are passed as
+-        vk_imag.
+-
+-    vk_imag : list of complex
+-        The frequencies (exponents) of the expansion terms for the imaginary
+-        part of the correlation function. The corresponding ceofficients are
+-        passed as ck_imag.
+-
+-    combine : bool, default True
+-        Whether to combine exponents with the same frequency (and coupling
+-        operator). See :meth:`combine` for details.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
+-        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
+-            raise ValueError(
+-                "The bath exponent lists ck_real and vk_real, and ck_imag and"
+-                " vk_imag must be the same length."
+-            )
+-
+-    def _check_coup_op(self, Q):
+-        if not isinstance(Q, Qobj):
+-            raise ValueError("The coupling operator Q must be a Qobj.")
+-
+-    def __init__(
+-            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
+-            tag=None,
+-    ):
+-        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
+-        self._check_coup_op(Q)
+-
+-        exponents = []
+-        exponents.extend(
+-            BathExponent("R", None, Q, ck, vk, tag=tag)
+-            for ck, vk in zip(ck_real, vk_real)
+-        )
+-        exponents.extend(
+-            BathExponent("I", None, Q, ck, vk, tag=tag)
+-            for ck, vk in zip(ck_imag, vk_imag)
+-        )
+-
+-        if combine:
+-            exponents = self.combine(exponents)
+-
+-        super().__init__(exponents)
+-
+-    @classmethod
+-    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
+-        """
+-        Group bosonic exponents with the same frequency and return a
+-        single exponent for each frequency present.
+-
+-        Exponents with the same frequency are only combined if they share the
+-        same coupling operator ``.Q``.
+-
+-        Note that combined exponents take their tag from the first
+-        exponent in the group being combined (i.e. the one that occurs first
+-        in the given exponents list).
+-
+-        Parameters
+-        ----------
+-        exponents : list of BathExponent
+-            The list of exponents to combine.
+-
+-        rtol : float, default 1e-5
+-            The relative tolerance to use to when comparing frequencies and
+-            coupling operators.
+-
+-        atol : float, default 1e-7
+-            The absolute tolerance to use to when comparing frequencies and
+-            coupling operators.
+-
+-        Returns
+-        -------
+-        list of BathExponent
+-            The new reduced list of exponents.
+-        """
+-        groups = []
+-        remaining = exponents[:]
+-
+-        while remaining:
+-            e1 = remaining.pop(0)
+-            group = [e1]
+-            for e2 in remaining[:]:
+-                if (
+-                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
+-                    _isequal(e1.Q, e2.Q, tol=atol)
+-                ):
+-                    group.append(e2)
+-                    remaining.remove(e2)
+-            groups.append(group)
+-
+-        new_exponents = []
+-        for combine in groups:
+-            exp1 = combine[0]
+-            if (exp1.type != exp1.types.RI) and all(
+-                exp2.type == exp1.type for exp2 in combine
+-            ):
+-                # the group is either type I or R
+-                ck = sum(exp.ck for exp in combine)
+-                new_exponents.append(BathExponent(
+-                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
+-                ))
+-            else:
+-                # the group includes both type I and R exponents
+-                ck_R = (
+-                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
+-                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
+-                )
+-                ck_I = (
+-                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
+-                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
+-                )
+-                new_exponents.append(BathExponent(
+-                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
+-                    tag=exp1.tag,
+-                ))
+-
+-        return new_exponents
+-
+-
+-class DrudeLorentzBath(BosonicBath):
+-    """
+-    A helper class for constructing a Drude-Lorentz bosonic bath from the
+-    bath parameters (see parameters below).
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        Operator describing the coupling between system and bath.
+-
+-    lam : float
+-        Coupling strength.
+-
+-    gamma : float
+-        Bath spectral density cutoff frequency.
+-
+-    T : float
+-        Bath temperature.
+-
+-    Nk : int
+-        Number of exponential terms used to approximate the bath correlation
+-        functions.
+-
+-    combine : bool, default True
+-        Whether to combine exponents with the same frequency (and coupling
+-        operator). See :meth:`BosonicBath.combine` for details.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-    def __init__(
+-        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
+-    ):
+-        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
+-            lam=lam,
+-            gamma=gamma,
+-            T=T,
+-            Nk=Nk,
+-        )
+-
+-        super().__init__(
+-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+-        )
+-
+-        self._dl_terminator = _DrudeLorentzTerminator(
+-            Q=Q, lam=lam, gamma=gamma, T=T,
+-        )
+-
+-    def terminator(self):
+-        """
+-        Return the Matsubara terminator for the bath and the calculated
+-        approximation discrepancy.
+-
+-        Returns
+-        -------
+-        delta: float
+-
+-            The approximation discrepancy. That is, the difference between the
+-            true correlation function of the Drude-Lorentz bath and the sum of
+-            the ``Nk`` exponential terms is approximately ``2 * delta *
+-            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
+-
+-        terminator : Qobj
+-
+-            The Matsubara terminator -- i.e. a liouvillian term representing
+-            the contribution to the system-bath dynamics of all exponential
+-            expansion terms beyond ``Nk``. It should be used by adding it to
+-            the system liouvillian (i.e. ``liouvillian(H_sys)``).
+-        """
+-        delta, L = self._dl_terminator.terminator(self.exponents)
+-        return delta, L
+-
+-    def _matsubara_params(self, lam, gamma, T, Nk):
+-        """ Calculate the Matsubara coefficents and frequencies. """
+-        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
+-        ck_real.extend([
+-            (8 * lam * gamma * T * np.pi * k * T /
+-                ((2 * np.pi * k * T)**2 - gamma**2))
+-            for k in range(1, Nk + 1)
+-        ])
+-        vk_real = [gamma]
+-        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
+-
+-        ck_imag = [lam * gamma * (-1.0)]
+-        vk_imag = [gamma]
+-
+-        return ck_real, vk_real, ck_imag, vk_imag
+-
+-
+-class DrudeLorentzPadeBath(BosonicBath):
+-    """
+-    A helper class for constructing a Padé expansion for a Drude-Lorentz
+-    bosonic bath from the bath parameters (see parameters below).
+-
+-    A Padé approximant is a sum-over-poles expansion (
+-    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
+-
+-    The application of the Padé method to spectrum decompoisitions is described
+-    in "Padé spectrum decompositions of quantum distribution functions and
+-    optimal hierarchical equations of motion construction for quantum open
+-    systems" [1].
+-
+-    The implementation here follows the approach in the paper.
+-
+-    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
+-
+-    This is an alternative to the :class:`DrudeLorentzBath` which constructs
+-    a simpler exponential expansion.
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        Operator describing the coupling between system and bath.
+-
+-    lam : float
+-        Coupling strength.
+-
+-    gamma : float
+-        Bath spectral density cutoff frequency.
+-
+-    T : float
+-        Bath temperature.
+-
+-    Nk : int
+-        Number of Padé exponentials terms used to approximate the bath
+-        correlation functions.
+-
+-    combine : bool, default True
+-        Whether to combine exponents with the same frequency (and coupling
+-        operator). See :meth:`BosonicBath.combine` for details.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-    def __init__(
+-        self, Q, lam, gamma, T, Nk, combine=True, tag=None
+-    ):
+-        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
+-
+-        ck_real = [np.real(eta) for eta in eta_p]
+-        vk_real = [gam for gam in gamma_p]
+-        # There is only one term in the expansion of the imaginary part of the
+-        # Drude-Lorentz correlation function.
+-        ck_imag = [np.imag(eta_p[0])]
+-        vk_imag = [gamma_p[0]]
+-
+-        super().__init__(
+-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+-        )
+-
+-        self._dl_terminator = _DrudeLorentzTerminator(
+-            Q=Q, lam=lam, gamma=gamma, T=T,
+-        )
+-
+-    def terminator(self):
+-        """
+-        Return the Padé terminator for the bath and the calculated
+-        approximation discrepancy.
+-
+-        Returns
+-        -------
+-        delta: float
+-
+-            The approximation discrepancy. That is, the difference between the
+-            true correlation function of the Drude-Lorentz bath and the sum of
+-            the ``Nk`` exponential terms is approximately ``2 * delta *
+-            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
+-
+-        terminator : Qobj
+-
+-            The Padé terminator -- i.e. a liouvillian term representing
+-            the contribution to the system-bath dynamics of all exponential
+-            expansion terms beyond ``Nk``. It should be used by adding it to
+-            the system liouvillian (i.e. ``liouvillian(H_sys)``).
+-        """
+-        delta, L = self._dl_terminator.terminator(self.exponents)
+-        return delta, L
+-
+-    def _corr(self, lam, gamma, T, Nk):
+-        beta = 1. / T
+-        kappa, epsilon = self._kappa_epsilon(Nk)
+-
+-        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
+-        gamma_p = [gamma]
+-
+-        for ll in range(1, Nk + 1):
+-            eta_p.append(
+-                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
+-                / ((epsilon[ll]**2 / beta**2) - gamma**2)
+-            )
+-            gamma_p.append(epsilon[ll] / beta)
+-
+-        return eta_p, gamma_p
+-
+-    def _cot(self, x):
+-        return 1. / np.tan(x)
+-
+-    def _kappa_epsilon(self, Nk):
+-        eps = self._calc_eps(Nk)
+-        chi = self._calc_chi(Nk)
+-
+-        kappa = [0]
+-        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
+-        for j in range(Nk):
+-            term = prefactor
+-            for k in range(Nk - 1):
+-                term *= (
+-                    (chi[k]**2 - eps[j]**2) /
+-                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+-                )
+-            for k in [Nk - 1]:
+-                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+-            kappa.append(term)
+-
+-        epsilon = [0] + eps
+-
+-        return kappa, epsilon
+-
+-    def _delta(self, i, j):
+-        return 1.0 if i == j else 0.0
+-
+-    def _calc_eps(self, Nk):
+-        alpha = np.diag([
+-                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
+-                for k in range(2 * Nk - 1)
+-        ], k=1)
+-        alpha += alpha.transpose()
+-        evals = eigvalsh(alpha)
+-        eps = [-2. / val for val in evals[0: Nk]]
+-        return eps
+-
+-    def _calc_chi(self, Nk):
+-        alpha_p = np.diag([
+-                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
+-                for k in range(2 * Nk - 2)
+-        ], k=1)
+-        alpha_p += alpha_p.transpose()
+-        evals = eigvalsh(alpha_p)
+-        chi = [-2. / val for val in evals[0: Nk - 1]]
+-        return chi
+-
+-
+-class _DrudeLorentzTerminator:
+-    """ A class for calculating the terminator of a Drude-Lorentz bath
+-        expansion.
+-    """
+-    def __init__(self, Q, lam, gamma, T):
+-        self.Q = Q
+-        self.lam = lam
+-        self.gamma = gamma
+-        self.T = T
+-
+-    def terminator(self, exponents):
+-        """ Calculate the terminator for a Drude-Lorentz bath. """
+-        Q = self.Q
+-        lam = self.lam
+-        gamma = self.gamma
+-        beta = 1 / self.T
+-
+-        delta = 2 * lam / (beta * gamma) - 1j * lam
+-
+-        for exp in exponents:
+-            if exp.type == BathExponent.types["R"]:
+-                delta -= exp.ck / exp.vk
+-            elif exp.type == BathExponent.types["RI"]:
+-                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
+-            else:
+-                delta -= 1j * exp.ck / exp.vk
+-
+-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+-        L_bnd = -delta * op
+-
+-        return delta, L_bnd
+-
+-
+-class UnderDampedBath(BosonicBath):
+-    """
+-    A helper class for constructing an under-damped bosonic bath from the
+-    bath parameters (see parameters below).
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        Operator describing the coupling between system and bath.
+-
+-    lam : float
+-        Coupling strength.
+-
+-    gamma : float
+-        Bath spectral density cutoff frequency.
+-
+-    w0 : float
+-        Bath spectral density resonance frequency.
+-
+-    T : float
+-        Bath temperature.
+-
+-    Nk : int
+-        Number of exponential terms used to approximate the bath correlation
+-        functions.
+-
+-    combine : bool, default True
+-        Whether to combine exponents with the same frequency (and coupling
+-        operator). See :meth:`BosonicBath.combine` for details.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-    def __init__(
+-        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
+-    ):
+-        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
+-            lam=lam,
+-            gamma=gamma,
+-            w0=w0,
+-            T=T,
+-            Nk=Nk,
+-        )
+-
+-        super().__init__(
+-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+-        )
+-
+-    def _matsubara_params(self, lam, gamma, w0, T, Nk):
+-        """ Calculate the Matsubara coefficents and frequencies. """
+-        beta = 1/T
+-        Om = np.sqrt(w0**2 - (gamma/2)**2)
+-        Gamma = gamma/2.
+-
+-        ck_real = ([
+-            (lam**2 / (4 * Om))
+-            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
+-            (lam**2 / (4*Om))
+-            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
+-        ])
+-
+-        ck_real.extend([
+-            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
+-            / (
+-                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
+-                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
+-            )
+-            for k in range(1, Nk + 1)
+-        ])
+-
+-        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
+-        vk_real.extend([
+-            2 * np.pi * k * T
+-            for k in range(1, Nk + 1)
+-        ])
+-
+-        ck_imag = [
+-            1.0j * lam**2 / (4 * Om),
+-            -1.0j * lam**2 / (4 * Om),
+-        ]
+-
+-        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
+-
+-        return ck_real, vk_real, ck_imag, vk_imag
+-
+-
+-class FermionicBath(Bath):
+-    """
+-    A helper class for constructing a fermionic bath from the expansion
+-    coefficients and frequencies for the ``+`` and ``-`` modes of
+-    the bath correlation function.
+-
+-    There must be the same number of ``+`` and ``-`` modes and their
+-    coefficients must be specified in the same order so that ``ck_plus[i],
+-    vk_plus[i]`` are the plus coefficient and frequency corresponding
+-    to the minus mode ``ck_minus[i], vk_minus[i]``.
+-
+-    In the fermionic case the order in which excitations are created or
+-    destroyed is important, resulting in two different correlation functions
+-    labelled ``C_plus(t)`` and ``C_plus(t)``::
+-
+-        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
+-        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
+-
+-    where the expansions above define the coeffiients ``ck`` and the
+-    frequencies ``vk``.
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        The coupling operator for the bath.
+-
+-    ck_plus : list of complex
+-        The coefficients of the expansion terms for the ``+`` part of the
+-        correlation function. The corresponding frequencies are passed as
+-        vk_plus.
+-
+-    vk_plus : list of complex
+-        The frequencies (exponents) of the expansion terms for the ``+`` part
+-        of the correlation function. The corresponding ceofficients are passed
+-        as ck_plus.
+-
+-    ck_minus : list of complex
+-        The coefficients of the expansion terms for the ``-`` part of the
+-        correlation function. The corresponding frequencies are passed as
+-        vk_minus.
+-
+-    vk_minus : list of complex
+-        The frequencies (exponents) of the expansion terms for the ``-`` part
+-        of the correlation function. The corresponding ceofficients are passed
+-        as ck_minus.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-
+-    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
+-        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
+-            raise ValueError(
+-                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+-                " vk_minus must be the same length."
+-            )
+-        if len(ck_plus) != len(ck_minus):
+-            raise ValueError(
+-                "The must be the same number of plus and minus exponents"
+-                " in the bath, and elements of plus and minus arrays"
+-                " should be arranged so that ck_plus[i] is the plus mode"
+-                " corresponding to ck_minus[i]."
+-            )
+-
+-    def _check_coup_op(self, Q):
+-        if not isinstance(Q, Qobj):
+-            raise ValueError("The coupling operator Q must be a Qobj.")
+-
+-    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
+-        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
+-        self._check_coup_op(Q)
+-
+-        exponents = []
+-        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
+-            exponents.append(BathExponent(
+-                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
+-            ))
+-            exponents.append(BathExponent(
+-                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
+-            ))
+-        super().__init__(exponents)
+-
+-
+-class LorentzianBath(FermionicBath):
+-    """
+-    A helper class for constructing a Lorentzian fermionic bath from the
+-    bath parameters (see parameters below).
+-
+-    .. note::
+-
+-        This Matsubara expansion used in this bath converges very slowly
+-        and ``Nk > 20`` may be required to get good convergence. The
+-        Padé expansion used by :class:`LorentzianPadeBath` converges much
+-        more quickly.
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        Operator describing the coupling between system and bath.
+-
+-    gamma : float
+-        The coupling strength between the system and the bath.
+-
+-    w : float
+-        The width of the environment.
+-
+-    mu : float
+-        The chemical potential of the bath.
+-
+-    T : float
+-        Bath temperature.
+-
+-    Nk : int
+-        Number of exponential terms used to approximate the bath correlation
+-        functions.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
+-        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
+-        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
+-
+-        super().__init__(
+-            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
+-        )
+-
+-    def _corr(self, gamma, w, mu, T, Nk, sigma):
+-        beta = 1. / T
+-        kappa = [0.]
+-        kappa.extend([1. for _ in range(1, Nk + 1)])
+-        epsilon = [0]
+-        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
+-
+-        def f(x):
+-            return 1 / (np.exp(x) + 1)
+-
+-        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
+-        gamma_list = [w - sigma * 1.0j * mu]
+-
+-        for ll in range(1, Nk + 1):
+-            eta_list.append(
+-                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
+-                (-(epsilon[ll]**2 / beta**2) + w**2)
+-            )
+-            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
+-
+-        return eta_list, gamma_list
+-
+-
+-class LorentzianPadeBath(FermionicBath):
+-    """
+-    A helper class for constructing a Padé expansion for Lorentzian fermionic
+-    bath from the bath parameters (see parameters below).
+-
+-    A Padé approximant is a sum-over-poles expansion (
+-    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
+-
+-    The application of the Padé method to spectrum decompoisitions is described
+-    in "Padé spectrum decompositions of quantum distribution functions and
+-    optimal hierarchical equations of motion construction for quantum open
+-    systems" [1].
+-
+-    The implementation here follows the approach in the paper.
+-
+-    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
+-
+-    This is an alternative to the :class:`LorentzianBath` which constructs
+-    a simpler exponential expansion that converges much more slowly in
+-    this particular case.
+-
+-    Parameters
+-    ----------
+-    Q : Qobj
+-        Operator describing the coupling between system and bath.
+-
+-    gamma : float
+-        The coupling strength between the system and the bath.
+-
+-    w : float
+-        The width of the environment.
+-
+-    mu : float
+-        The chemical potential of the bath.
+-
+-    T : float
+-        Bath temperature.
+-
+-    Nk : int
+-        Number of exponential terms used to approximate the bath correlation
+-        functions.
+-
+-    tag : optional, str, tuple or any other object
+-        A label for the bath exponents (for example, the name of the
+-        bath). It defaults to None but can be set to help identify which
+-        bath an exponent is from.
+-    """
+-    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
+-        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
+-        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
+-
+-        super().__init__(
+-            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
+-        )
+-
+-    def _corr(self, gamma, w, mu, T, Nk, sigma):
+-        beta = 1. / T
+-        kappa, epsilon = self._kappa_epsilon(Nk)
+-
+-        def f_approx(x):
+-            f = 0.5
+-            for ll in range(1, Nk + 1):
+-                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
+-            return f
+-
+-        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
+-        gamma_list = [w - sigma * 1.0j * mu]
+-
+-        for ll in range(1, Nk + 1):
+-            eta_list.append(
+-                -1.0j * (kappa[ll] / beta) * gamma * w**2
+-                / (-(epsilon[ll]**2 / beta**2) + w**2)
+-            )
+-            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
+-
+-        return eta_list, gamma_list
+-
+-    def _kappa_epsilon(self, Nk):
+-        eps = self._calc_eps(Nk)
+-        chi = self._calc_chi(Nk)
+-
+-        kappa = [0]
+-        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
+-        for j in range(Nk):
+-            term = prefactor
+-            for k in range(Nk - 1):
+-                term *= (
+-                    (chi[k]**2 - eps[j]**2) /
+-                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+-                )
+-            for k in [Nk - 1]:
+-                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+-            kappa.append(term)
+-
+-        epsilon = [0] + eps
+-
+-        return kappa, epsilon
+-
+-    def _delta(self, i, j):
+-        return 1.0 if i == j else 0.0
+-
+-    def _calc_eps(self, Nk):
+-        alpha = np.diag([
+-                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
+-                for k in range(2 * Nk - 1)
+-        ], k=1)
+-        alpha += alpha.transpose()
+-
+-        evals = eigvalsh(alpha)
+-        eps = [-2. / val for val in evals[0: Nk]]
+-        return eps
+-
+-    def _calc_chi(self, Nk):
+-        alpha_p = np.diag([
+-                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
+-                for k in range(2 * Nk - 2)
+-        ], k=1)
+-        alpha_p += alpha_p.transpose()
+-        evals = eigvalsh(alpha_p)
+-        chi = [-2. / val for val in evals[0: Nk - 1]]
+-        return chi
++"""
++This module provides utilities for describing baths when using the
++HEOM (hierarchy equations of motion) to model system-bath interactions.
++
++See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
++
++The implementation is derived from the BoFiN library (see
++https://github.com/tehruhn/bofin) which was itself derived from an earlier
++implementation in QuTiP itself.
++"""
++
++import enum
++
++import numpy as np
++from scipy.linalg import eigvalsh
++
++from qutip.core import data as _data
++from qutip.core.qobj import Qobj
++from qutip.core.superoperator import spre, spost
++
++__all__ = [
++    "BathExponent",
++    "Bath",
++    "BosonicBath",
++    "DrudeLorentzBath",
++    "DrudeLorentzPadeBath",
++    "UnderDampedBath",
++    "FermionicBath",
++    "LorentzianBath",
++    "LorentzianPadeBath",
++]
++
++
++def _isequal(Q1, Q2, tol):
++    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
++    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
++
++
++class BathExponent:
++    """
++    Represents a single exponent (naively, an excitation mode) within the
++    decomposition of the correlation functions of a bath.
++
++    Parameters
++    ----------
++    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
++        The type of bath exponent.
++
++        "R" and "I" are bosonic bath exponents that appear in the real and
++        imaginary parts of the correlation expansion.
++
++        "RI" is combined bosonic bath exponent that appears in both the real
++        and imaginary parts of the correlation expansion. The combined exponent
++        has a single ``vk``. The ``ck`` is the coefficient in the real
++        expansion and ``ck2`` is the coefficient in the imaginary expansion.
++
++        "+" and "-" are fermionic bath exponents. These fermionic bath
++        exponents must specify ``sigma_bar_k_offset`` which specifies
++        the amount to add to ``k`` (the exponent index within the bath of this
++        exponent) to determine the ``k`` of the corresponding exponent with
++        the opposite sign (i.e. "-" or "+").
++
++    dim : int or None
++        The dimension (i.e. maximum number of excitations for this exponent).
++        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
++        bosonic exponents.
++
++    Q : Qobj
++        The coupling operator for this excitation mode.
++
++    vk : complex
++        The frequency of the exponent of the excitation term.
++
++    ck : complex
++        The coefficient of the excitation term.
++
++    ck2 : optional, complex
++        For exponents of type "RI" this is the coefficient of the term in the
++        imaginary expansion (and ``ck`` is the coefficient in the real
++        expansion).
++
++    sigma_bar_k_offset : optional, int
++        For exponents of type "+" this gives the offset (within the list of
++        exponents within the bath) of the corresponding "-" bath exponent.
++        For exponents of type "-" it gives the offset of the corresponding
++        "+" exponent.
++
++    tag : optional, str, tuple or any other object
++        A label for the exponent (often the name of the bath). It
++        defaults to None.
++
++    Attributes
++    ----------
++    fermionic : bool
++        True if the type of the exponent is a Fermionic type (i.e. either
++        "+" or "-") and False otherwise.
++
++    All of the parameters are also available as attributes.
++    """
++    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
++
++    def _check_ck2(self, type, ck2):
++        if type == self.types["RI"]:
++            if ck2 is None:
++                raise ValueError("RI bath exponents require ck2")
++        else:
++            if ck2 is not None:
++                raise ValueError(
++                    "Second co-efficient (ck2) should only be specified for RI"
++                    " bath exponents"
++                )
++
++    def _check_sigma_bar_k_offset(self, type, offset):
++        if type in (self.types["+"], self.types["-"]):
++            if offset is None:
++                raise ValueError(
++                    "+ and - bath exponents require sigma_bar_k_offset"
++                )
++        else:
++            if offset is not None:
++                raise ValueError(
++                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
++                    " specified for + and - bath exponents"
++                )
++
++    def _type_is_fermionic(self, type):
++        return type in (self.types["+"], self.types["-"])
++
++    def __init__(
++            self, type, dim, Q, ck, vk, ck2=None,
++            sigma_bar_k_offset=None, tag=None,
++    ):
++        if not isinstance(type, self.types):
++            type = self.types[type]
++        self._check_ck2(type, ck2)
++        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
++        self.type = type
++        self.fermionic = self._type_is_fermionic(type)
++        self.dim = dim
++        self.Q = Q
++        self.ck = ck
++        self.vk = vk
++        self.ck2 = ck2
++        self.sigma_bar_k_offset = sigma_bar_k_offset
++        self.tag = tag
++
++    def __repr__(self):
++        dims = getattr(self.Q, "dims", None)
++        return (
++            f"<{self.__class__.__name__} type={self.type.name}"
++            f" dim={self.dim!r}"
++            f" Q.dims={dims!r}"
++            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
++            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
++            f" fermionic={self.fermionic!r}"
++            f" tag={self.tag!r}>"
++        )
++
++
++class Bath:
++    """
++    Represents a list of bath expansion exponents.
++
++    Parameters
++    ----------
++    exponents : list of BathExponent
++        The exponents of the correlation function describing the bath.
++
++    Attributes
++    ----------
++
++    All of the parameters are available as attributes.
++    """
++    def __init__(self, exponents):
++        self.exponents = exponents
++
++
++class BosonicBath(Bath):
++    """
++    A helper class for constructing a bosonic bath from the expansion
++    coefficients and frequencies for the real and imaginary parts of
++    the bath correlation function.
++
++    If the correlation functions ``C(t)`` is split into real and imaginary
++    parts::
++
++        C(t) = C_real(t) + i * C_imag(t)
++
++    then::
++
++        C_real(t) = sum(ck_real * exp(- vk_real * t))
++        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
++
++    Defines the coefficients ``ck`` and the frequencies ``vk``.
++
++    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
++    and ``C_imag(t)`` (i.e. the sum) is real.
++
++    Parameters
++    ----------
++    Q : Qobj
++        The coupling operator for the bath.
++
++    ck_real : list of complex
++        The coefficients of the expansion terms for the real part of the
++        correlation function. The corresponding frequencies are passed as
++        vk_real.
++
++    vk_real : list of complex
++        The frequencies (exponents) of the expansion terms for the real part of
++        the correlation function. The corresponding ceofficients are passed as
++        ck_real.
++
++    ck_imag : list of complex
++        The coefficients of the expansion terms in the imaginary part of the
++        correlation function. The corresponding frequencies are passed as
++        vk_imag.
++
++    vk_imag : list of complex
++        The frequencies (exponents) of the expansion terms for the imaginary
++        part of the correlation function. The corresponding ceofficients are
++        passed as ck_imag.
++
++    combine : bool, default True
++        Whether to combine exponents with the same frequency (and coupling
++        operator). See :meth:`combine` for details.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
++        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
++            raise ValueError(
++                "The bath exponent lists ck_real and vk_real, and ck_imag and"
++                " vk_imag must be the same length."
++            )
++
++    def _check_coup_op(self, Q):
++        if not isinstance(Q, Qobj):
++            raise ValueError("The coupling operator Q must be a Qobj.")
++
++    def __init__(
++            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
++            tag=None,
++    ):
++        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
++        self._check_coup_op(Q)
++
++        exponents = []
++        exponents.extend(
++            BathExponent("R", None, Q, ck, vk, tag=tag)
++            for ck, vk in zip(ck_real, vk_real)
++        )
++        exponents.extend(
++            BathExponent("I", None, Q, ck, vk, tag=tag)
++            for ck, vk in zip(ck_imag, vk_imag)
++        )
++
++        if combine:
++            exponents = self.combine(exponents)
++
++        super().__init__(exponents)
++
++    @classmethod
++    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
++        """
++        Group bosonic exponents with the same frequency and return a
++        single exponent for each frequency present.
++
++        Exponents with the same frequency are only combined if they share the
++        same coupling operator ``.Q``.
++
++        Note that combined exponents take their tag from the first
++        exponent in the group being combined (i.e. the one that occurs first
++        in the given exponents list).
++
++        Parameters
++        ----------
++        exponents : list of BathExponent
++            The list of exponents to combine.
++
++        rtol : float, default 1e-5
++            The relative tolerance to use to when comparing frequencies and
++            coupling operators.
++
++        atol : float, default 1e-7
++            The absolute tolerance to use to when comparing frequencies and
++            coupling operators.
++
++        Returns
++        -------
++        list of BathExponent
++            The new reduced list of exponents.
++        """
++        groups = []
++        remaining = exponents[:]
++
++        while remaining:
++            e1 = remaining.pop(0)
++            group = [e1]
++            for e2 in remaining[:]:
++                if (
++                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
++                    _isequal(e1.Q, e2.Q, tol=atol)
++                ):
++                    group.append(e2)
++                    remaining.remove(e2)
++            groups.append(group)
++
++        new_exponents = []
++        for combine in groups:
++            exp1 = combine[0]
++            if (exp1.type != exp1.types.RI) and all(
++                exp2.type == exp1.type for exp2 in combine
++            ):
++                # the group is either type I or R
++                ck = sum(exp.ck for exp in combine)
++                new_exponents.append(BathExponent(
++                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
++                ))
++            else:
++                # the group includes both type I and R exponents
++                ck_R = (
++                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
++                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
++                )
++                ck_I = (
++                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
++                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
++                )
++                new_exponents.append(BathExponent(
++                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
++                    tag=exp1.tag,
++                ))
++
++        return new_exponents
++
++
++class DrudeLorentzBath(BosonicBath):
++    """
++    A helper class for constructing a Drude-Lorentz bosonic bath from the
++    bath parameters (see parameters below).
++
++    Parameters
++    ----------
++    Q : Qobj
++        Operator describing the coupling between system and bath.
++
++    lam : float
++        Coupling strength.
++
++    gamma : float
++        Bath spectral density cutoff frequency.
++
++    T : float
++        Bath temperature.
++
++    Nk : int
++        Number of exponential terms used to approximate the bath correlation
++        functions.
++
++    combine : bool, default True
++        Whether to combine exponents with the same frequency (and coupling
++        operator). See :meth:`BosonicBath.combine` for details.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++    def __init__(
++        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
++    ):
++        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
++            lam=lam,
++            gamma=gamma,
++            T=T,
++            Nk=Nk,
++        )
++
++        super().__init__(
++            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
++        )
++
++        self._dl_terminator = _DrudeLorentzTerminator(
++            Q=Q, lam=lam, gamma=gamma, T=T,
++        )
++
++    def terminator(self):
++        """
++        Return the Matsubara terminator for the bath and the calculated
++        approximation discrepancy.
++
++        Returns
++        -------
++        delta: float
++
++            The approximation discrepancy. That is, the difference between the
++            true correlation function of the Drude-Lorentz bath and the sum of
++            the ``Nk`` exponential terms is approximately ``2 * delta *
++            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
++
++        terminator : Qobj
++
++            The Matsubara terminator -- i.e. a liouvillian term representing
++            the contribution to the system-bath dynamics of all exponential
++            expansion terms beyond ``Nk``. It should be used by adding it to
++            the system liouvillian (i.e. ``liouvillian(H_sys)``).
++        """
++        delta, L = self._dl_terminator.terminator(self.exponents)
++        return delta, L
++
++    def _matsubara_params(self, lam, gamma, T, Nk):
++        """ Calculate the Matsubara coefficents and frequencies. """
++        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
++        ck_real.extend([
++            (8 * lam * gamma * T * np.pi * k * T /
++                ((2 * np.pi * k * T)**2 - gamma**2))
++            for k in range(1, Nk + 1)
++        ])
++        vk_real = [gamma]
++        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
++
++        ck_imag = [lam * gamma * (-1.0)]
++        vk_imag = [gamma]
++
++        return ck_real, vk_real, ck_imag, vk_imag
++
++
++class DrudeLorentzPadeBath(BosonicBath):
++    """
++    A helper class for constructing a Padé expansion for a Drude-Lorentz
++    bosonic bath from the bath parameters (see parameters below).
++
++    A Padé approximant is a sum-over-poles expansion (
++    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
++
++    The application of the Padé method to spectrum decompoisitions is described
++    in "Padé spectrum decompositions of quantum distribution functions and
++    optimal hierarchical equations of motion construction for quantum open
++    systems" [1].
++
++    The implementation here follows the approach in the paper.
++
++    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
++
++    This is an alternative to the :class:`DrudeLorentzBath` which constructs
++    a simpler exponential expansion.
++
++    Parameters
++    ----------
++    Q : Qobj
++        Operator describing the coupling between system and bath.
++
++    lam : float
++        Coupling strength.
++
++    gamma : float
++        Bath spectral density cutoff frequency.
++
++    T : float
++        Bath temperature.
++
++    Nk : int
++        Number of Padé exponentials terms used to approximate the bath
++        correlation functions.
++
++    combine : bool, default True
++        Whether to combine exponents with the same frequency (and coupling
++        operator). See :meth:`BosonicBath.combine` for details.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++    def __init__(
++        self, Q, lam, gamma, T, Nk, combine=True, tag=None
++    ):
++        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
++
++        ck_real = [np.real(eta) for eta in eta_p]
++        vk_real = [gam for gam in gamma_p]
++        # There is only one term in the expansion of the imaginary part of the
++        # Drude-Lorentz correlation function.
++        ck_imag = [np.imag(eta_p[0])]
++        vk_imag = [gamma_p[0]]
++
++        super().__init__(
++            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
++        )
++
++        self._dl_terminator = _DrudeLorentzTerminator(
++            Q=Q, lam=lam, gamma=gamma, T=T,
++        )
++
++    def terminator(self):
++        """
++        Return the Padé terminator for the bath and the calculated
++        approximation discrepancy.
++
++        Returns
++        -------
++        delta: float
++
++            The approximation discrepancy. That is, the difference between the
++            true correlation function of the Drude-Lorentz bath and the sum of
++            the ``Nk`` exponential terms is approximately ``2 * delta *
++            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
++
++        terminator : Qobj
++
++            The Padé terminator -- i.e. a liouvillian term representing
++            the contribution to the system-bath dynamics of all exponential
++            expansion terms beyond ``Nk``. It should be used by adding it to
++            the system liouvillian (i.e. ``liouvillian(H_sys)``).
++        """
++        delta, L = self._dl_terminator.terminator(self.exponents)
++        return delta, L
++
++    def _corr(self, lam, gamma, T, Nk):
++        beta = 1. / T
++        kappa, epsilon = self._kappa_epsilon(Nk)
++
++        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
++        gamma_p = [gamma]
++
++        for ll in range(1, Nk + 1):
++            eta_p.append(
++                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
++                / ((epsilon[ll]**2 / beta**2) - gamma**2)
++            )
++            gamma_p.append(epsilon[ll] / beta)
++
++        return eta_p, gamma_p
++
++    def _cot(self, x):
++        return 1. / np.tan(x)
++
++    def _kappa_epsilon(self, Nk):
++        eps = self._calc_eps(Nk)
++        chi = self._calc_chi(Nk)
++
++        kappa = [0]
++        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
++        for j in range(Nk):
++            term = prefactor
++            for k in range(Nk - 1):
++                term *= (
++                    (chi[k]**2 - eps[j]**2) /
++                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
++                )
++            for k in [Nk - 1]:
++                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
++            kappa.append(term)
++
++        epsilon = [0] + eps
++
++        return kappa, epsilon
++
++    def _delta(self, i, j):
++        return 1.0 if i == j else 0.0
++
++    def _calc_eps(self, Nk):
++        alpha = np.diag([
++                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
++                for k in range(2 * Nk - 1)
++        ], k=1)
++        alpha += alpha.transpose()
++        evals = eigvalsh(alpha)
++        eps = [-2. / val for val in evals[0: Nk]]
++        return eps
++
++    def _calc_chi(self, Nk):
++        alpha_p = np.diag([
++                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
++                for k in range(2 * Nk - 2)
++        ], k=1)
++        alpha_p += alpha_p.transpose()
++        evals = eigvalsh(alpha_p)
++        chi = [-2. / val for val in evals[0: Nk - 1]]
++        return chi
++
++
++class _DrudeLorentzTerminator:
++    """ A class for calculating the terminator of a Drude-Lorentz bath
++        expansion.
++    """
++    def __init__(self, Q, lam, gamma, T):
++        self.Q = Q
++        self.lam = lam
++        self.gamma = gamma
++        self.T = T
++
++    def terminator(self, exponents):
++        """ Calculate the terminator for a Drude-Lorentz bath. """
++        Q = self.Q
++        lam = self.lam
++        gamma = self.gamma
++        beta = 1 / self.T
++
++        delta = 2 * lam / (beta * gamma) - 1j * lam
++
++        for exp in exponents:
++            if exp.type == BathExponent.types["R"]:
++                delta -= exp.ck / exp.vk
++            elif exp.type == BathExponent.types["RI"]:
++                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
++            else:
++                delta -= 1j * exp.ck / exp.vk
++
++        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
++        L_bnd = -delta * op
++
++        return delta, L_bnd
++
++
++class UnderDampedBath(BosonicBath):
++    """
++    A helper class for constructing an under-damped bosonic bath from the
++    bath parameters (see parameters below).
++
++    Parameters
++    ----------
++    Q : Qobj
++        Operator describing the coupling between system and bath.
++
++    lam : float
++        Coupling strength.
++
++    gamma : float
++        Bath spectral density cutoff frequency.
++
++    w0 : float
++        Bath spectral density resonance frequency.
++
++    T : float
++        Bath temperature.
++
++    Nk : int
++        Number of exponential terms used to approximate the bath correlation
++        functions.
++
++    combine : bool, default True
++        Whether to combine exponents with the same frequency (and coupling
++        operator). See :meth:`BosonicBath.combine` for details.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++    def __init__(
++        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
++    ):
++        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
++            lam=lam,
++            gamma=gamma,
++            w0=w0,
++            T=T,
++            Nk=Nk,
++        )
++
++        super().__init__(
++            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
++        )
++
++    def _matsubara_params(self, lam, gamma, w0, T, Nk):
++        """ Calculate the Matsubara coefficents and frequencies. """
++        beta = 1/T
++        Om = np.sqrt(w0**2 - (gamma/2)**2)
++        Gamma = gamma/2.
++
++        ck_real = ([
++            (lam**2 / (4 * Om))
++            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
++            (lam**2 / (4*Om))
++            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
++        ])
++
++        ck_real.extend([
++            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
++            / (
++                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
++                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
++            )
++            for k in range(1, Nk + 1)
++        ])
++
++        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
++        vk_real.extend([
++            2 * np.pi * k * T
++            for k in range(1, Nk + 1)
++        ])
++
++        ck_imag = [
++            1.0j * lam**2 / (4 * Om),
++            -1.0j * lam**2 / (4 * Om),
++        ]
++
++        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
++
++        return ck_real, vk_real, ck_imag, vk_imag
++
++
++class FermionicBath(Bath):
++    """
++    A helper class for constructing a fermionic bath from the expansion
++    coefficients and frequencies for the ``+`` and ``-`` modes of
++    the bath correlation function.
++
++    There must be the same number of ``+`` and ``-`` modes and their
++    coefficients must be specified in the same order so that ``ck_plus[i],
++    vk_plus[i]`` are the plus coefficient and frequency corresponding
++    to the minus mode ``ck_minus[i], vk_minus[i]``.
++
++    In the fermionic case the order in which excitations are created or
++    destroyed is important, resulting in two different correlation functions
++    labelled ``C_plus(t)`` and ``C_plus(t)``::
++
++        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
++        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
++
++    where the expansions above define the coeffiients ``ck`` and the
++    frequencies ``vk``.
++
++    Parameters
++    ----------
++    Q : Qobj
++        The coupling operator for the bath.
++
++    ck_plus : list of complex
++        The coefficients of the expansion terms for the ``+`` part of the
++        correlation function. The corresponding frequencies are passed as
++        vk_plus.
++
++    vk_plus : list of complex
++        The frequencies (exponents) of the expansion terms for the ``+`` part
++        of the correlation function. The corresponding ceofficients are passed
++        as ck_plus.
++
++    ck_minus : list of complex
++        The coefficients of the expansion terms for the ``-`` part of the
++        correlation function. The corresponding frequencies are passed as
++        vk_minus.
++
++    vk_minus : list of complex
++        The frequencies (exponents) of the expansion terms for the ``-`` part
++        of the correlation function. The corresponding ceofficients are passed
++        as ck_minus.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++
++    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
++        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
++            raise ValueError(
++                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
++                " vk_minus must be the same length."
++            )
++        if len(ck_plus) != len(ck_minus):
++            raise ValueError(
++                "The must be the same number of plus and minus exponents"
++                " in the bath, and elements of plus and minus arrays"
++                " should be arranged so that ck_plus[i] is the plus mode"
++                " corresponding to ck_minus[i]."
++            )
++
++    def _check_coup_op(self, Q):
++        if not isinstance(Q, Qobj):
++            raise ValueError("The coupling operator Q must be a Qobj.")
++
++    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
++        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
++        self._check_coup_op(Q)
++
++        exponents = []
++        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
++            exponents.append(BathExponent(
++                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
++            ))
++            exponents.append(BathExponent(
++                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
++            ))
++        super().__init__(exponents)
++
++
++class LorentzianBath(FermionicBath):
++    """
++    A helper class for constructing a Lorentzian fermionic bath from the
++    bath parameters (see parameters below).
++
++    .. note::
++
++        This Matsubara expansion used in this bath converges very slowly
++        and ``Nk > 20`` may be required to get good convergence. The
++        Padé expansion used by :class:`LorentzianPadeBath` converges much
++        more quickly.
++
++    Parameters
++    ----------
++    Q : Qobj
++        Operator describing the coupling between system and bath.
++
++    gamma : float
++        The coupling strength between the system and the bath.
++
++    w : float
++        The width of the environment.
++
++    mu : float
++        The chemical potential of the bath.
++
++    T : float
++        Bath temperature.
++
++    Nk : int
++        Number of exponential terms used to approximate the bath correlation
++        functions.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
++        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
++        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
++
++        super().__init__(
++            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
++        )
++
++    def _corr(self, gamma, w, mu, T, Nk, sigma):
++        beta = 1. / T
++        kappa = [0.]
++        kappa.extend([1. for _ in range(1, Nk + 1)])
++        epsilon = [0]
++        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
++
++        def f(x):
++            return 1 / (np.exp(x) + 1)
++
++        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
++        gamma_list = [w - sigma * 1.0j * mu]
++
++        for ll in range(1, Nk + 1):
++            eta_list.append(
++                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
++                (-(epsilon[ll]**2 / beta**2) + w**2)
++            )
++            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
++
++        return eta_list, gamma_list
++
++
++class LorentzianPadeBath(FermionicBath):
++    """
++    A helper class for constructing a Padé expansion for Lorentzian fermionic
++    bath from the bath parameters (see parameters below).
++
++    A Padé approximant is a sum-over-poles expansion (
++    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
++
++    The application of the Padé method to spectrum decompoisitions is described
++    in "Padé spectrum decompositions of quantum distribution functions and
++    optimal hierarchical equations of motion construction for quantum open
++    systems" [1].
++
++    The implementation here follows the approach in the paper.
++
++    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
++
++    This is an alternative to the :class:`LorentzianBath` which constructs
++    a simpler exponential expansion that converges much more slowly in
++    this particular case.
++
++    Parameters
++    ----------
++    Q : Qobj
++        Operator describing the coupling between system and bath.
++
++    gamma : float
++        The coupling strength between the system and the bath.
++
++    w : float
++        The width of the environment.
++
++    mu : float
++        The chemical potential of the bath.
++
++    T : float
++        Bath temperature.
++
++    Nk : int
++        Number of exponential terms used to approximate the bath correlation
++        functions.
++
++    tag : optional, str, tuple or any other object
++        A label for the bath exponents (for example, the name of the
++        bath). It defaults to None but can be set to help identify which
++        bath an exponent is from.
++    """
++    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
++        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
++        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
++
++        super().__init__(
++            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
++        )
++
++    def _corr(self, gamma, w, mu, T, Nk, sigma):
++        beta = 1. / T
++        kappa, epsilon = self._kappa_epsilon(Nk)
++
++        def f_approx(x):
++            f = 0.5
++            for ll in range(1, Nk + 1):
++                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
++            return f
++
++        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
++        gamma_list = [w - sigma * 1.0j * mu]
++
++        for ll in range(1, Nk + 1):
++            eta_list.append(
++                -1.0j * (kappa[ll] / beta) * gamma * w**2
++                / (-(epsilon[ll]**2 / beta**2) + w**2)
++            )
++            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
++
++        return eta_list, gamma_list
++
++    def _kappa_epsilon(self, Nk):
++        eps = self._calc_eps(Nk)
++        chi = self._calc_chi(Nk)
++
++        kappa = [0]
++        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
++        for j in range(Nk):
++            term = prefactor
++            for k in range(Nk - 1):
++                term *= (
++                    (chi[k]**2 - eps[j]**2) /
++                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
++                )
++            for k in [Nk - 1]:
++                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
++            kappa.append(term)
++
++        epsilon = [0] + eps
++
++        return kappa, epsilon
++
++    def _delta(self, i, j):
++        return 1.0 if i == j else 0.0
++
++    def _calc_eps(self, Nk):
++        alpha = np.diag([
++                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
++                for k in range(2 * Nk - 1)
++        ], k=1)
++        alpha += alpha.transpose()
++
++        evals = eigvalsh(alpha)
++        eps = [-2. / val for val in evals[0: Nk]]
++        return eps
++
++    def _calc_chi(self, Nk):
++        alpha_p = np.diag([
++                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
++                for k in range(2 * Nk - 2)
++        ], k=1)
++        alpha_p += alpha_p.transpose()
++        evals = eigvalsh(alpha_p)
++        chi = [-2. / val for val in evals[0: Nk - 1]]
++        return chi
+diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
+index 740c2d5d..42cc98d1 100644
+--- a/qutip/solver/heom/bofin_solvers.py
++++ b/qutip/solver/heom/bofin_solvers.py
+@@ -1,1322 +1,1322 @@
+-"""
+-This module provides solvers for system-bath evoluation using the
+-HEOM (hierarchy equations of motion).
+-
+-See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
+-basic introduction to the technique.
+-
+-The implementation is derived from the BoFiN library (see
+-https://github.com/tehruhn/bofin) which was itself derived from an earlier
+-implementation in QuTiP itself.
+-"""
+-
+-from time import time
+-
+-import numpy as np
+-import scipy.sparse as sp
+-from scipy.sparse.linalg import spsolve
+-
+-from qutip.settings import settings
+-from qutip import state_number_enumerate
+-from qutip.core import data as _data
+-from qutip.core.data import csr as _csr
+-from qutip.core import Qobj, QobjEvo
+-from qutip.core.superoperator import liouvillian, spre, spost
+-from .bofin_baths import (
+-    BathExponent, DrudeLorentzBath,
+-)
+-from ..solver_base import Solver
+-from .. import Result
+-
+-# Load MKL spsolve if avaiable
+-if settings.has_mkl:
+-    from qutip._mkl.spsolve import mkl_spsolve
+-else:
+-    mkl_spsolve = None
+-
+-__all__ = [
+-    "heomsolve",
+-    "HierarchyADOs",
+-    "HierarchyADOsState",
+-    "HEOMResult",
+-    "HEOMSolver",
+-    "HSolverDL",
+-]
+-
+-
+-class HierarchyADOs:
+-    """
+-    A description of ADOs (auxilliary density operators) with the
+-    hierarchical equations of motion.
+-
+-    The list of ADOs is constructed from a list of bath exponents
+-    (corresponding to one or more baths). Each ADO is referred to by a label
+-    that lists the number of "excitations" of each bath exponent. The
+-    level of a label within the hierarchy is the sum of the "excitations"
+-    within the label.
+-
+-    For example the label ``(0, 0, ..., 0)`` represents the density matrix
+-    of the system being solved and is the only 0th level label.
+-
+-    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
+-    etc. are the 1st level labels.
+-
+-    The second level labels all have either two 1s or a single 2, and so on
+-    for the third and higher levels of the hierarchy.
+-
+-    Parameters
+-    ----------
+-    exponents : list of BathExponent
+-        The exponents of the correlation function describing the bath or
+-        baths.
+-
+-    max_depth : int
+-        The maximum depth of the hierarchy (i.e. the maximum sum of
+-        "excitations" in the hierarchy ADO labels or maximum ADO level).
+-
+-    Attributes
+-    ----------
+-    exponents : list of BathExponent
+-        The exponents of the correlation function describing the bath or
+-        baths.
+-
+-    max_depth : int
+-        The maximum depth of the hierarchy (i.e. the maximum sum of
+-        "excitations" in the hierarchy ADO labels).
+-
+-    dims : list of int
+-        The dimensions of each exponent within the bath(s).
+-
+-    vk : list of complex
+-        The frequency of each exponent within the bath(s).
+-
+-    ck : list of complex
+-        The coefficient of each exponent within the bath(s).
+-
+-    ck2: list of complex
+-        For exponents of type "RI", the coefficient of the exponent within
+-        the imaginary expansion. For other exponent types, the entry is None.
+-
+-    sigma_bar_k_offset: list of int
+-        For exponents of type "+" or "-" the offset within the list of modes
+-        of the corresponding "-" or "+" exponent. For other exponent types,
+-        the entry is None.
+-
+-    labels: list of tuples
+-        A list of the ADO labels within the hierarchy.
+-    """
+-    def __init__(self, exponents, max_depth):
+-        self.exponents = exponents
+-        self.max_depth = max_depth
+-
+-        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
+-        self.vk = [exp.vk for exp in self.exponents]
+-        self.ck = [exp.ck for exp in self.exponents]
+-        self.ck2 = [exp.ck2 for exp in self.exponents]
+-        self.sigma_bar_k_offset = [
+-            exp.sigma_bar_k_offset for exp in self.exponents
+-        ]
+-
+-        self.labels = list(state_number_enumerate(self.dims, max_depth))
+-        self._label_idx = {s: i for i, s in enumerate(self.labels)}
+-        self.idx = self._label_idx.__getitem__
+-
+-    def idx(self, label):
+-        """
+-        Return the index of the ADO label within the list of labels,
+-        i.e. within ``self.labels``.
+-
+-        Parameters
+-        ----------
+-        label : tuple
+-            The label to look up.
+-
+-        Returns
+-        -------
+-        int
+-            The index of the label within the list of ADO labels.
+-
+-        Note
+-        ----
+-        This implementation of the ``.idx(...)`` method is just for
+-        reference and documentation. To avoid the cost of a Python
+-        function call, it is replaced with
+-        ``self._label_idx.__getitem__`` when the instance is created.
+-        """
+-        return self._label_idx[label]
+-
+-    def next(self, label, k):
+-        """
+-        Return the ADO label with one more excitation in the k'th exponent
+-        dimension or ``None`` if adding the excitation would exceed the
+-        dimension or maximum depth of the hierarchy.
+-
+-        Parameters
+-        ----------
+-        label : tuple
+-            The ADO label to add an excitation to.
+-        k : int
+-            The exponent to add the excitation to.
+-
+-        Returns
+-        -------
+-        tuple or None
+-            The next label.
+-        """
+-        if label[k] >= self.dims[k] - 1:
+-            return None
+-        if sum(label) >= self.max_depth:
+-            return None
+-        return label[:k] + (label[k] + 1,) + label[k + 1:]
+-
+-    def prev(self, label, k):
+-        """
+-        Return the ADO label with one fewer excitation in the k'th
+-        exponent dimension or ``None`` if the label has no exciations in the
+-        k'th exponent.
+-
+-        Parameters
+-        ----------
+-        label : tuple
+-            The ADO label to remove the excitation from.
+-        k : int
+-            The exponent to remove the excitation from.
+-
+-        Returns
+-        -------
+-        tuple or None
+-            The previous label.
+-        """
+-        if label[k] <= 0:
+-            return None
+-        return label[:k] + (label[k] - 1,) + label[k + 1:]
+-
+-    def exps(self, label):
+-        """
+-        Converts an ADO label into a tuple of exponents, with one exponent
+-        for each "excitation" within the label.
+-
+-        The number of exponents returned is always equal to the level of the
+-        label within the hierarchy (i.e. the sum of the indices within the
+-        label).
+-
+-        Parameters
+-        ----------
+-        label : tuple
+-            The ADO label to convert to a list of exponents.
+-
+-        Returns
+-        -------
+-        tuple of BathExponent
+-            A tuple of BathExponents.
+-
+-        Examples
+-        --------
+-
+-        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
+-
+-        ``ados.exps((2, 0, 0))`` would return
+-        ``[ados.exponents[0], ados.exponents[0]]``.
+-
+-        ``ados.exps((1, 2, 1))`` would return
+-        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
+-           ados.exponents[2]]``.
+-        """
+-        return sum(
+-            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
+-            (),
+-        )
+-
+-    def filter(self, level=None, tags=None, dims=None, types=None):
+-        """
+-        Return a list of ADO labels for ADOs whose "excitations"
+-        match the given patterns.
+-
+-        Each of the filter parameters (tags, dims, types) may be either
+-        unspecified (None) or a list. Unspecified parameters are excluded
+-        from the filtering.
+-
+-        All specified filter parameters must be lists of the same length.
+-        Each position in the lists describes a particular excitation and
+-        any exponent that matches the filters may supply that excitation.
+-        The level of all labels returned is thus equal to the length of
+-        the filter parameter lists.
+-
+-        Within a filter parameter list, items that are None represent
+-        wildcards and match any value of that exponent attribute
+-
+-        Parameters
+-        ----------
+-        level : int
+-            The hierarchy depth to return ADOs from.
+-
+-        tags : list of object or None
+-            Filter parameter that matches the ``.tag`` attribute of
+-            exponents.
+-
+-        dims : list of int
+-            Filter parameter that matches the ``.dim`` attribute of
+-            exponents.
+-
+-        types : list of BathExponent types or list of str
+-            Filter parameter that matches the ``.type`` attribute
+-            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
+-            instead of by the actual type (e.g. ``BathExponent.types.R``).
+-
+-        Returns
+-        -------
+-        list of tuple
+-            The ADO label for each ADO whose exponent excitations
+-            (i.e. label) match the given filters or level.
+-        """
+-        if types is not None:
+-            types = [
+-                t if t is None or isinstance(t, BathExponent.types)
+-                else BathExponent.types[t]
+-                for t in types
+-            ]
+-        filters = [("tag", tags), ("type", types), ("dim", dims)]
+-        filters = [(attr, f) for attr, f in filters if f is not None]
+-        n = max((len(f) for _, f in filters), default=0)
+-        if any(len(f) != n for _, f in filters):
+-            raise ValueError(
+-                "The tags, dims and types filters must all be the same length."
+-            )
+-        if n > self.max_depth:
+-            raise ValueError(
+-                f"The maximum depth for the hierarchy is {self.max_depth} but"
+-                f" {n} levels of excitation filters were given."
+-            )
+-        if level is None:
+-            if not filters:
+-                # fast path for when there are no excitation filters
+-                return self.labels[:]
+-        else:
+-            if not filters:
+-                # fast path for when there are no excitation filters
+-                return [label for label in self.labels if sum(label) == level]
+-            if level != n:
+-                raise ValueError(
+-                    f"The level parameter is {level} but {n} levels of"
+-                    " excitation filters were given."
+-                )
+-
+-        filtered_dims = [1] * len(self.exponents)
+-        for lvl in range(n):
+-            level_filters = [
+-                (attr, f[lvl]) for attr, f in filters
+-                if f[lvl] is not None
+-            ]
+-            for j, exp in enumerate(self.exponents):
+-                if any(getattr(exp, attr) != f for attr, f in level_filters):
+-                    continue
+-                filtered_dims[j] += 1
+-                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
+-
+-        return [
+-            label for label in state_number_enumerate(filtered_dims, n)
+-            if sum(label) == n
+-        ]
+-
+-
+-class HierarchyADOsState:
+-    """
+-    Provides convenient access to the full hierarchy ADO state at a particular
+-    point in time, ``t``.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`~qutip.Qobj`
+-        The current state of the system (i.e. the 0th component of the
+-        hierarchy).
+-    ados : :class:`HierarchyADOs`
+-        The description of the hierarchy.
+-    ado_state : numpy.array
+-        The full state of the hierarchy.
+-
+-    Attributes
+-    ----------
+-    rho : Qobj
+-        The system state.
+-
+-    In addition, all of the attributes of the hierarchy description,
+-    i.e. ``HierarchyADOs``, are provided directly on this class for
+-    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
+-    call ``.idx(label)`` directly.
+-
+-    See :class:`HierarchyADOs` for a full list of the available attributes
+-    and methods.
+-    """
+-    def __init__(self, rho, ados, ado_state):
+-        self.rho = rho
+-        self._ado_state = ado_state
+-        self._ados = ados
+-
+-    def __getattr__(self, name):
+-        return getattr(self._ados, name)
+-
+-    def extract(self, idx_or_label):
+-        """
+-        Extract a Qobj representing the specified ADO from a full
+-        representation of the ADO states.
+-
+-        Parameters
+-        ----------
+-        idx : int or label
+-            The index of the ADO to extract. If an ADO label, e.g.
+-            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
+-            is extracted by label instead.
+-
+-        Returns
+-        -------
+-        Qobj
+-            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
+-        """
+-        if isinstance(idx_or_label, int):
+-            idx = idx_or_label
+-        else:
+-            idx = self._ados.idx(idx_or_label)
+-        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
+-
+-
+-class HEOMResult(Result):
+-    def _post_init(self):
+-        super()._post_init()
+-
+-        self.store_ados = self.options["store_ados"]
+-        if self.store_ados:
+-            self.final_ado_state = None
+-            self.ado_states = []
+-
+-    def _e_op_func(self, e_op):
+-        """ Convert an e_op into a function ``f(t, ado_state)``. """
+-        if isinstance(e_op, Qobj):
+-            return lambda t, ado_state: (ado_state.rho * e_op).tr()
+-        elif isinstance(e_op, QobjEvo):
+-            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
+-        elif callable(e_op):
+-            return e_op
+-        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
+-
+-    def _pre_copy(self, state):
+-        return state
+-
+-    def _store_state(self, t, ado_state):
+-        self.states.append(ado_state.rho)
+-        if self.store_ados:
+-            self.ado_states.append(ado_state)
+-
+-    def _store_final_state(self, t, ado_state):
+-        self.final_state = ado_state.rho
+-        if self.store_ados:
+-            self.final_ado_state = ado_state
+-
+-
+-def heomsolve(
+-    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
+-):
+-    """
+-    Hierarchical Equations of Motion (HEOM) solver that supports multiple
+-    baths.
+-
+-    The baths must be all either bosonic or fermionic baths.
+-
+-    If you need to run many evolutions of the same system and bath, consider
+-    using :class:`HEOMSolver` directly to avoid having to continually
+-    reconstruct the equation hierarchy for every evolution.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    bath : Bath or list of Bath
+-        A :obj:`Bath` containing the exponents of the expansion of the
+-        bath correlation funcion and their associated coefficients
+-        and coupling operators, or a list of baths.
+-
+-        If multiple baths are given, they must all be either fermionic
+-        or bosonic baths.
+-
+-    max_depth : int
+-        The maximum depth of the heirarchy (i.e. the maximum number of bath
+-        exponent "excitations" to retain).
+-
+-    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
+-        If ``rho0`` is a :class:`~Qobj` the it is the initial state
+-        of the system (i.e. a :obj:`~Qobj` density matrix).
+-
+-        If it is a :class:`~HierarchyADOsState` or array-like, then
+-        ``rho0`` gives the initial state of all ADOs.
+-
+-        Usually the state of the ADOs would be determine from a previous
+-        call to ``.run(...)`` with the solver results option ``store_ados``
+-        set to True. For example, ``result = solver.run(...)`` could be
+-        followed by ``solver.run(result.ado_states[-1], tlist)``.
+-
+-        If a numpy array-like is passed its shape must be
+-        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
+-        (i.e. shape of the system density matrix) and the ADOs must
+-        be in the same order as in ``.ados.labels``.
+-
+-    tlist : list
+-        An ordered list of times at which to return the value of the state.
+-
+-    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
+-        A list or dictionary of operators as :class:`~Qobj`,
+-        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
+-        a single operator or callable function. For an operator ``op``, the
+-        result will be computed using ``(state * op).tr()`` and the state
+-        at each time ``t``. For callable functions, ``f``, the result is
+-        computed using ``f(t, ado_state)``. The values are stored in the
+-        ``expect`` and ``e_data`` attributes of the result (see the return
+-        section below).
+-
+-    args : dict, optional {None}
+-        Change the ``args`` of the RHS for the evolution.
+-
+-    options : dict, optional {None}
+-        Generic solver options.
+-
+-        - store_final_state : bool
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, None
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - store_ados : bool {False, True}
+-          Whether or not to store the HEOM ADOs.
+-        - normalize_output : bool
+-          Normalize output state to hide ODE numerical errors.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - state_data_type: str {'dense'}
+-          Name of the data type of the state used during the ODE evolution.
+-          Use an empty string to keep the input state type. Many integrator can
+-          only work with `Dense`.
+-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+-          Which differential equation integration method to use.
+-        - atol, rtol : float
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps :
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - max_step : float, 0
+-          Maximum lenght of one internal step. When using pulses, it should be
+-          less than half the width of the thinnest pulse.
+-
+-    Returns
+-    -------
+-    :class:`~HEOMResult`
+-        The results of the simulation run, with the following important
+-        attributes:
+-
+-        * ``times``: the times ``t`` (i.e. the ``tlist``).
+-
+-        * ``states``: the system state at each time ``t`` (only available
+-          if ``e_ops`` was ``None`` or if the solver option
+-          ``store_states`` was set to ``True``).
+-
+-        * ``ado_states``: the full ADO state at each time (only available
+-          if the results option ``ado_return`` was set to ``True``).
+-          Each element is an instance of :class:`HierarchyADOsState`.
+-          The state of a particular ADO may be extracted from
+-          ``result.ado_states[i]`` by calling :meth:`.extract`.
+-
+-        * ``expect``: a list containing the values of each ``e_ops`` at
+-          time ``t``.
+-
+-        * ``e_data``: a dictionary containing the values of each ``e_ops``
+-          at tme ``t``. The keys are those given by ``e_ops`` if it was
+-          a dict, otherwise they are the indexes of the supplied ``e_ops``.
+-
+-        See :class:`~HEOMResult` and :class:`~Result` for the complete
+-        list of attributes.
+-    """
+-    H = QobjEvo(H, args=args, tlist=tlist)
+-    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
+-    return solver.run(state0, tlist, e_ops=e_ops)
+-
+-
+-class HEOMSolver(Solver):
+-    """
+-    HEOM solver that supports multiple baths.
+-
+-    The baths must be all either bosonic or fermionic baths.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    bath : Bath or list of Bath
+-        A :obj:`Bath` containing the exponents of the expansion of the
+-        bath correlation funcion and their associated coefficients
+-        and coupling operators, or a list of baths.
+-
+-        If multiple baths are given, they must all be either fermionic
+-        or bosonic baths.
+-
+-    max_depth : int
+-        The maximum depth of the heirarchy (i.e. the maximum number of bath
+-        exponent "excitations" to retain).
+-
+-    options : dict, optional
+-        Generic solver options.
+-        If set to None the default options will be used. Keyword only.
+-        Default: None.
+-
+-    Attributes
+-    ----------
+-    ados : :obj:`HierarchyADOs`
+-        The description of the hierarchy constructed from the given bath
+-        and maximum depth.
+-
+-    rhs : :obj:`QobjEvo`
+-        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
+-        the system and bath coupling operators are converted to
+-        :class:`qutip.data.CSR` instances during construction of the RHS,
+-        so the operators in the ``rhs`` will all be sparse.
+-    """
+-
+-    name = "heomsolver"
+-    resultclass = HEOMResult
+-    _avail_integrators = {}
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size": 10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": False,
+-        "method": "adams",
+-        "store_ados": False,
+-        "state_data_type": "dense",
+-    }
+-
+-    def __init__(self, H, bath, max_depth, *, options=None):
+-        _time_start = time()
+-
+-        if not isinstance(H, (Qobj, QobjEvo)):
+-            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
+-
+-        H = QobjEvo(H)
+-        self.L_sys = (
+-            liouvillian(H) if H.type == "oper"  # hamiltonian
+-            else H  # already a liouvillian
+-        )
+-
+-        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
+-        self._sup_shape = self.L_sys.shape[0]
+-        self._sys_dims = self.L_sys.dims[0]
+-
+-        self.ados = HierarchyADOs(
+-            self._combine_bath_exponents(bath), max_depth,
+-        )
+-        self._n_ados = len(self.ados.labels)
+-        self._n_exponents = len(self.ados.exponents)
+-
+-        self._init_ados_time = time() - _time_start
+-        _time_start = time()
+-
+-        # pre-calculate identity matrix required by _grad_n
+-        self._sId = _data.identity(self._sup_shape, dtype="csr")
+-
+-        # pre-calculate superoperators required by _grad_prev and _grad_next:
+-        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
+-        self._spreQ = [spre(op).data for op in Qs]
+-        self._spostQ = [spost(op).data for op in Qs]
+-        self._s_pre_minus_post_Q = [
+-            _data.sub(self._spreQ[k], self._spostQ[k])
+-            for k in range(self._n_exponents)
+-        ]
+-        self._s_pre_plus_post_Q = [
+-            _data.add(self._spreQ[k], self._spostQ[k])
+-            for k in range(self._n_exponents)
+-        ]
+-        self._spreQdag = [spre(op.dag()).data for op in Qs]
+-        self._spostQdag = [spost(op.dag()).data for op in Qs]
+-        self._s_pre_minus_post_Qdag = [
+-            _data.sub(self._spreQdag[k], self._spostQdag[k])
+-            for k in range(self._n_exponents)
+-        ]
+-        self._s_pre_plus_post_Qdag = [
+-            _data.add(self._spreQdag[k], self._spostQdag[k])
+-            for k in range(self._n_exponents)
+-        ]
+-
+-        self._init_superop_cache_time = time() - _time_start
+-        _time_start = time()
+-
+-        rhs = self._calculate_rhs()
+-
+-        self._init_rhs_time = time() - _time_start
+-
+-        super().__init__(rhs, options=options)
+-
+-    @property
+-    def sys_dims(self):
+-        """
+-        Dimensions of the space that the system use, excluding any environment:
+-
+-        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
+-        for this solver.
+-        """
+-        return self._sys_dims
+-
+-    def _initialize_stats(self):
+-        stats = super()._initialize_stats()
+-        stats.update({
+-            "init time": sum([
+-                stats["init time"], self._init_ados_time,
+-                self._init_superop_cache_time, self._init_rhs_time,
+-            ]),
+-            "init ados time": self._init_ados_time,
+-            "init superop cache time": self._init_superop_cache_time,
+-            "init rhs time": self._init_rhs_time,
+-            "solver": "Hierarchical Equations of Motion Solver",
+-            "max_depth": self.ados.max_depth,
+-        })
+-        return stats
+-
+-    def _combine_bath_exponents(self, bath):
+-        """ Combine the exponents for the specified baths. """
+-        if not isinstance(bath, (list, tuple)):
+-            exponents = bath.exponents
+-        else:
+-            exponents = []
+-            for b in bath:
+-                exponents.extend(b.exponents)
+-        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
+-            raise ValueError(
+-                "All bath exponents must have system coupling operators"
+-                " with the same dimensions but a mixture of dimensions"
+-                " was given."
+-            )
+-        return exponents
+-
+-    def _grad_n(self, he_n):
+-        """ Get the gradient for the hierarchy ADO at level n. """
+-        vk = self.ados.vk
+-        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
+-        op = _data.mul(self._sId, -vk_sum)
+-        return op
+-
+-    def _grad_prev(self, he_n, k):
+-        """ Get the previous gradient. """
+-        if self.ados.exponents[k].fermionic:
+-            return self._grad_prev_fermionic(he_n, k)
+-        else:
+-            return self._grad_prev_bosonic(he_n, k)
+-
+-    def _grad_prev_bosonic(self, he_n, k):
+-        if self.ados.exponents[k].type == BathExponent.types.R:
+-            op = _data.mul(
+-                self._s_pre_minus_post_Q[k],
+-                -1j * he_n[k] * self.ados.ck[k],
+-            )
+-        elif self.ados.exponents[k].type == BathExponent.types.I:
+-            op = _data.mul(
+-                self._s_pre_plus_post_Q[k],
+-                -1j * he_n[k] * 1j * self.ados.ck[k],
+-            )
+-        elif self.ados.exponents[k].type == BathExponent.types.RI:
+-            term1 = _data.mul(
+-                self._s_pre_minus_post_Q[k],
+-                he_n[k] * -1j * self.ados.ck[k],
+-            )
+-            term2 = _data.mul(
+-                self._s_pre_plus_post_Q[k],
+-                he_n[k] * self.ados.ck2[k],
+-            )
+-            op = _data.add(term1, term2)
+-        else:
+-            raise ValueError(
+-                f"Unsupported type {self.ados.exponents[k].type}"
+-                f" for exponent {k}"
+-            )
+-        return op
+-
+-    def _grad_prev_fermionic(self, he_n, k):
+-        ck = self.ados.ck
+-        he_fermionic_n = [
+-            i * int(exp.fermionic)
+-            for i, exp in zip(he_n, self.ados.exponents)
+-        ]
+-
+-        n_excite = sum(he_fermionic_n)
+-        sign1 = (-1) ** (n_excite + 1)
+-
+-        n_excite_before_m = sum(he_fermionic_n[:k])
+-        sign2 = (-1) ** (n_excite_before_m)
+-
+-        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
+-
+-        if self.ados.exponents[k].type == BathExponent.types["+"]:
+-            op = _data.sub(
+-                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
+-                _data.mul(
+-                    self._spostQdag[k],
+-                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
+-                ),
+-            )
+-        elif self.ados.exponents[k].type == BathExponent.types["-"]:
+-            op = _data.sub(
+-                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
+-                _data.mul(
+-                    self._spostQ[k],
+-                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
+-                ),
+-            )
+-        else:
+-            raise ValueError(
+-                f"Unsupported type {self.ados.exponents[k].type}"
+-                f" for exponent {k}"
+-            )
+-        return op
+-
+-    def _grad_next(self, he_n, k):
+-        """ Get the previous gradient. """
+-        if self.ados.exponents[k].fermionic:
+-            return self._grad_next_fermionic(he_n, k)
+-        else:
+-            return self._grad_next_bosonic(he_n, k)
+-
+-    def _grad_next_bosonic(self, he_n, k):
+-        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
+-        return op
+-
+-    def _grad_next_fermionic(self, he_n, k):
+-        he_fermionic_n = [
+-            i * int(exp.fermionic)
+-            for i, exp in zip(he_n, self.ados.exponents)
+-        ]
+-        n_excite = sum(he_fermionic_n)
+-        sign1 = (-1) ** (n_excite + 1)
+-
+-        n_excite_before_m = sum(he_fermionic_n[:k])
+-        sign2 = (-1) ** (n_excite_before_m)
+-
+-        if self.ados.exponents[k].type == BathExponent.types["+"]:
+-            if sign1 == -1:
+-                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
+-            else:
+-                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
+-        elif self.ados.exponents[k].type == BathExponent.types["-"]:
+-            if sign1 == -1:
+-                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
+-            else:
+-                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
+-        else:
+-            raise ValueError(
+-                f"Unsupported type {self.ados.exponents[k].type}"
+-                f" for exponent {k}"
+-            )
+-        return op
+-
+-    def _rhs(self):
+-        """ Make the RHS for the HEOM. """
+-        ops = _GatherHEOMRHS(
+-            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
+-        )
+-
+-        for he_n in self.ados.labels:
+-            op = self._grad_n(he_n)
+-            ops.add_op(he_n, he_n, op)
+-            for k in range(len(self.ados.dims)):
+-                next_he = self.ados.next(he_n, k)
+-                if next_he is not None:
+-                    op = self._grad_next(he_n, k)
+-                    ops.add_op(he_n, next_he, op)
+-                prev_he = self.ados.prev(he_n, k)
+-                if prev_he is not None:
+-                    op = self._grad_prev(he_n, k)
+-                    ops.add_op(he_n, prev_he, op)
+-
+-        return ops.gather()
+-
+-    def _calculate_rhs(self):
+-        """ Make the full RHS required by the solver. """
+-        rhs_mat = self._rhs()
+-        rhs_dims = [
+-            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
+-        ]
+-        h_identity = _data.identity(self._n_ados, dtype="csr")
+-
+-        if self.L_sys.isconstant:
+-            # For the constant case, we just add the Liouvillian to the
+-            # diagonal blocks of the RHS matrix.
+-            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
+-            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
+-        else:
+-            # In the time dependent case, we construct the parameters
+-            # for the ODE gradient function under the assumption that
+-            #
+-            # RHSmat(t) = RHSmat + time dependent terms that only affect the
+-            # diagonal blocks of the RHS matrix.
+-            #
+-            # This assumption holds because only _grad_n dependents on
+-            # the system Liouvillian (and not _grad_prev or _grad_next) and
+-            # the bath coupling operators are not time-dependent.
+-            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
+-
+-            def _kron(x):
+-                return Qobj(
+-                    _data.kron(h_identity, x.data),
+-                    dims=rhs_dims,
+-                ).to("csr")
+-
+-            rhs += self.L_sys.linear_map(_kron)
+-
+-        # The assertion that rhs_mat has data type CSR is just a sanity
+-        # check on the RHS creation. The base solver class will still
+-        # convert the RHS to the type required by the ODE integrator if
+-        # needed.
+-        assert isinstance(rhs_mat, _csr.CSR)
+-        assert isinstance(rhs, QobjEvo)
+-        assert rhs.dims == rhs_dims
+-
+-        return rhs
+-
+-    def steady_state(
+-        self,
+-        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
+-    ):
+-        """
+-        Compute the steady state of the system.
+-
+-        Parameters
+-        ----------
+-        use_mkl : bool, default=False
+-            Whether to use mkl or not. If mkl is not installed or if
+-            this is false, use the scipy splu solver instead.
+-
+-        mkl_max_iter_refine : int
+-            Specifies the the maximum number of iterative refinement steps that
+-            the MKL PARDISO solver performs.
+-
+-            For a complete description, see iparm(8) in
+-            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
+-
+-        mkl_weighted_matching : bool
+-            MKL PARDISO can use a maximum weighted matching algorithm to
+-            permute large elements close the diagonal. This strategy adds an
+-            additional level of reliability to the factorization methods.
+-
+-            For a complete description, see iparm(13) in
+-            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
+-
+-        Returns
+-        -------
+-        steady_state : Qobj
+-            The steady state density matrix of the system.
+-
+-        steady_ados : :class:`HierarchyADOsState`
+-            The steady state of the full ADO hierarchy. A particular ADO may be
+-            extracted from the full state by calling :meth:`.extract`.
+-        """
+-        if not self.L_sys.isconstant:
+-            raise ValueError(
+-                "A steady state cannot be determined for a time-dependent"
+-                " system"
+-            )
+-        n = self._sys_shape
+-
+-        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
+-        b_mat[0] = 1.0
+-
+-        L = self.rhs(0).data.copy().as_scipy()
+-        L = L.tolil()
+-        L[0, 0: n ** 2 * self._n_ados] = 0.0
+-        L = L.tocsr()
+-        L += sp.csr_matrix((
+-            np.ones(n),
+-            (np.zeros(n), [num * (n + 1) for num in range(n)])
+-        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
+-
+-        if mkl_spsolve is not None and use_mkl:
+-            L.sort_indices()
+-            solution = mkl_spsolve(
+-                L,
+-                b_mat,
+-                perm=None,
+-                verbose=False,
+-                max_iter_refine=mkl_max_iter_refine,
+-                scaling_vectors=True,
+-                weighted_matching=mkl_weighted_matching,
+-            )
+-        else:
+-            L = L.tocsc()
+-            solution = spsolve(L, b_mat)
+-
+-        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
+-        data = _data.mul(_data.add(data, data.conj()), 0.5)
+-        steady_state = Qobj(data, dims=self._sys_dims)
+-
+-        solution = solution.reshape((self._n_ados, n, n))
+-        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
+-
+-        return steady_state, steady_ados
+-
+-    def run(self, state0, tlist, *, args=None, e_ops=None):
+-        """
+-        Solve for the time evolution of the system.
+-
+-        Parameters
+-        ----------
+-        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
+-            If ``rho0`` is a :class:`~Qobj` the it is the initial state
+-            of the system (i.e. a :obj:`~Qobj` density matrix).
+-
+-            If it is a :class:`~HierarchyADOsState` or array-like, then
+-            ``rho0`` gives the initial state of all ADOs.
+-
+-            Usually the state of the ADOs would be determine from a previous
+-            call to ``.run(...)`` with the solver results option ``store_ados``
+-            set to True. For example, ``result = solver.run(...)`` could be
+-            followed by ``solver.run(result.ado_states[-1], tlist)``.
+-
+-            If a numpy array-like is passed its shape must be
+-            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
+-            (i.e. shape of the system density matrix) and the ADOs must
+-            be in the same order as in ``.ados.labels``.
+-
+-        tlist : list
+-            An ordered list of times at which to return the value of the state.
+-
+-        args : dict, optional {None}
+-            Change the ``args`` of the RHS for the evolution.
+-
+-        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
+-            A list or dictionary of operators as :class:`~Qobj`,
+-            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
+-            a single operator or callable function. For an operator ``op``, the
+-            result will be computed using ``(state * op).tr()`` and the state
+-            at each time ``t``. For callable functions, ``f``, the result is
+-            computed using ``f(t, ado_state)``. The values are stored in the
+-            ``expect`` and ``e_data`` attributes of the result (see the return
+-            section below).
+-
+-        Returns
+-        -------
+-        :class:`~HEOMResult`
+-            The results of the simulation run, with the following important
+-            attributes:
+-
+-            * ``times``: the times ``t`` (i.e. the ``tlist``).
+-
+-            * ``states``: the system state at each time ``t`` (only available
+-              if ``e_ops`` was ``None`` or if the solver option
+-              ``store_states`` was set to ``True``).
+-
+-            * ``ado_states``: the full ADO state at each time (only available
+-              if the results option ``ado_return`` was set to ``True``).
+-              Each element is an instance of :class:`HierarchyADOsState`.
+-              The state of a particular ADO may be extracted from
+-              ``result.ado_states[i]`` by calling :meth:`.extract`.
+-
+-            * ``expect``: a list containing the values of each ``e_ops`` at
+-              time ``t``.
+-
+-            * ``e_data``: a dictionary containing the values of each ``e_ops``
+-              at tme ``t``. The keys are those given by ``e_ops`` if it was
+-              a dict, otherwise they are the indexes of the supplied ``e_ops``.
+-
+-            See :class:`~HEOMResult` and :class:`~Result` for the complete
+-            list of attributes.
+-        """
+-        return super().run(state0, tlist, args=args, e_ops=e_ops)
+-
+-    def _prepare_state(self, state):
+-        n = self._sys_shape
+-        rho_dims = self._sys_dims
+-        hierarchy_shape = (self._n_ados, n, n)
+-
+-        rho0 = state
+-        ado_init = not isinstance(rho0, Qobj)
+-
+-        if ado_init:
+-            if isinstance(rho0, HierarchyADOsState):
+-                rho0_he = rho0._ado_state
+-            elif hasattr(rho0, "shape"):  # array-like
+-                rho0_he = rho0
+-            else:
+-                raise TypeError(
+-                    f"Initial ADOs passed have type {type(rho0)}"
+-                    " but a HierarchyADOsState or a numpy array-like instance"
+-                    " was expected"
+-                )
+-            if rho0_he.shape != hierarchy_shape:
+-                raise ValueError(
+-                    f"Initial ADOs passed have shape {rho0_he.shape}"
+-                    f" but the solver hierarchy shape is {hierarchy_shape}"
+-                )
+-            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
+-            rho0_he = _data.create(rho0_he)
+-        else:
+-            if rho0.dims != rho_dims:
+-                raise ValueError(
+-                    f"Initial state rho has dims {rho0.dims}"
+-                    f" but the system dims are {rho_dims}"
+-                )
+-            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
+-            rho0_he[:n ** 2] = rho0.full().ravel('F')
+-            rho0_he = _data.create(rho0_he)
+-
+-        if self.options["state_data_type"]:
+-            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
+-
+-        return rho0_he
+-
+-    def _restore_state(self, state, *, copy=True):
+-        n = self._sys_shape
+-        rho_shape = (n, n)
+-        rho_dims = self._sys_dims
+-        hierarchy_shape = (self._n_ados, n, n)
+-
+-        rho = Qobj(
+-            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
+-            dims=rho_dims,
+-        )
+-        ado_state = HierarchyADOsState(
+-            rho, self.ados, state.to_array().reshape(hierarchy_shape)
+-        )
+-        return ado_state
+-
+-    def start(self, state0, t0):
+-        """
+-        Set the initial state and time for a step evolution.
+-
+-        Parameters
+-        ----------
+-        state0 : :class:`Qobj`
+-            Initial state of the evolution. This may provide either just the
+-            initial density matrix of the system, or the full set of ADOs
+-            for the hierarchy. See the documentation for ``rho0`` in the
+-            ``.run(...)`` method for details.
+-
+-        t0 : double
+-            Initial time of the evolution.
+-        """
+-        super().start(state0, t0)
+-
+-    @property
+-    def options(self):
+-        """
+-        Options for HEOMSolver:
+-
+-        store_final_state: bool, default=False
+-            Whether or not to store the final state of the evolution in the
+-            result class.
+-
+-        store_states: bool, default=None
+-            Whether or not to store the state vectors or density matrices.
+-            On `None` the states will be saved if no expectation operators are
+-            given.
+-
+-        normalize_output: bool, default=False
+-            Normalize output state to hide ODE numerical errors.
+-
+-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+-            How to present the solver progress.
+-            'tqdm' uses the python module of the same name and raise an error
+-            if not installed. Empty string or False will disable the bar.
+-
+-        progress_kwargs: dict, default={"chunk_size": 10}
+-            Arguments to pass to the progress_bar. Qutip's bars use
+-            ``chunk_size``.
+-
+-        method: str, default="adams"
+-            Which ordinary differential equation integration method to use.
+-
+-        state_data_type: str, default="dense"
+-            Name of the data type of the state used during the ODE evolution.
+-            Use an empty string to keep the input state type. Many integrators
+-            support only work with `Dense`.
+-
+-        store_ados : bool, default=False
+-            Whether or not to store the HEOM ADOs. Only relevant when using
+-            the HEOM solver.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Solver.options.fset(self, new_options)
+-
+-
+-class HSolverDL(HEOMSolver):
+-    """
+-    A helper class for creating an :class:`HEOMSolver` that is backwards
+-    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
+-    in QuTiP 4.6 and below.
+-
+-    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
+-    descriptions of the underlying solver and bath construction.
+-
+-    An exact copy of the QuTiP 4.6 HSolverDL is provided in
+-    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
+-    the older solver is required. The older solver will be completely
+-    removed in QuTiP 5.
+-
+-    .. note::
+-
+-        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
+-        supports supplying a time-dependent or Liouvillian ``H_sys``.
+-
+-    .. note::
+-
+-        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
+-        parameter ``N_exp`` specifying the number of exponents to keep in
+-        the expansion of the bath correlation function is one more than
+-        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
+-        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
+-        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
+-        order to better match common usage in the literature.
+-
+-    .. note::
+-
+-        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
+-        are no longer supported.
+-
+-    Parameters
+-    ----------
+-    H_sys : Qobj or QobjEvo or list
+-        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
+-        a complete description.
+-
+-    coup_op : Qobj
+-        Operator describing the coupling between system and bath.
+-        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
+-
+-    coup_strength : float
+-        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
+-
+-    temperature : float
+-        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
+-
+-    N_cut : int
+-        The maximum depth of the hierarchy. See ``max_depth`` in
+-        :class:`HEOMSolver` for a full description.
+-
+-    N_exp : int
+-        Number of exponential terms used to approximate the bath correlation
+-        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
+-        less than ``N_exp`` (see note above).
+-
+-    cut_freq : float
+-        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
+-        :class:`DrudeLorentzBath`.
+-
+-    bnd_cut_approx : bool
+-        Use boundary cut off approximation. If true, the Matsubara
+-        terminator is added to the system Liouvillian (and H_sys is
+-        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
+-        Default: False.
+-
+-    options : dict, optional
+-        Generic solver options.
+-        If set to None the default options will be used. Keyword only.
+-        Default: None.
+-
+-    combine : bool, default True
+-        Whether to combine exponents with the same frequency (and coupling
+-        operator). See :meth:`BosonicBath.combine` for details.
+-        Keyword only. Default: True.
+-    """
+-    def __init__(
+-        self, H_sys, coup_op, coup_strength, temperature,
+-        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
+-        combine=True,
+-    ):
+-        H_sys = QobjEvo(H_sys)
+-        bath = DrudeLorentzBath(
+-            Q=coup_op,
+-            lam=coup_strength,
+-            gamma=cut_freq,
+-            Nk=N_exp - 1,
+-            T=temperature,
+-            combine=combine,
+-        )
+-
+-        if bnd_cut_approx:
+-            # upgrade H_sys to a Liouvillian if needed and add the
+-            # bath terminator
+-            if H_sys.type == "oper":  # H_sys is a Hamiltonian
+-                H_sys = liouvillian(H_sys)
+-            _, terminator = bath.terminator()
+-            H_sys = H_sys + terminator
+-
+-        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
+-
+-        # store input parameters as attributes for politeness and compatibility
+-        # with HSolverDL in QuTiP 4.6 and below.
+-        self.coup_strength = coup_strength
+-        self.cut_freq = cut_freq
+-        self.temperature = temperature
+-        self.N_exp = N_exp
+-        self.bnd_cut_approx = bnd_cut_approx
+-
+-
+-class _GatherHEOMRHS:
+-    """ A class for collecting elements of the right-hand side matrix
+-        of the HEOM.
+-
+-        Parameters
+-        ----------
+-        f_idx: function(he_state) -> he_idx
+-            A function that returns the index of a hierarchy state
+-            (i.e. an ADO label).
+-        block : int
+-            The size of a single ADO Liovillian operator in the hierarchy.
+-        nhe : int
+-            The number of ADOs in the hierarchy.
+-    """
+-    def __init__(self, f_idx, block, nhe):
+-        self._block_size = block
+-        self._n_blocks = nhe
+-        self._f_idx = f_idx
+-        self._ops = []
+-
+-    def add_op(self, row_he, col_he, op):
+-        """ Add an block operator to the list. """
+-        self._ops.append(
+-            (self._f_idx(row_he), self._f_idx(col_he), op)
+-        )
+-
+-    def gather(self):
+-        """ Create the HEOM liouvillian from a sorted list of smaller sparse
+-            matrices.
+-
+-            .. note::
+-
+-                The list of operators contains tuples of the form
+-                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
+-                *block* row and column for each op. An operator with
+-                block indices ``(N, M)`` is placed at position
+-                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
+-                in the output matrix.
+-
+-            Returns
+-            -------
+-            rhs : :obj:`Data`
+-                A combined matrix of shape ``(block * nhe, block * ne)``.
+-        """
+-        self._ops.sort()
+-        ops = np.array(self._ops, dtype=[
+-            ("row", _data.base.idxint_dtype),
+-            ("col", _data.base.idxint_dtype),
+-            ("op", _data.CSR),
+-        ])
+-        return _csr._from_csr_blocks(
+-            ops["row"], ops["col"], ops["op"],
+-            self._n_blocks, self._block_size,
+-        )
++"""
++This module provides solvers for system-bath evoluation using the
++HEOM (hierarchy equations of motion).
++
++See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
++basic introduction to the technique.
++
++The implementation is derived from the BoFiN library (see
++https://github.com/tehruhn/bofin) which was itself derived from an earlier
++implementation in QuTiP itself.
++"""
++
++from time import time
++
++import numpy as np
++import scipy.sparse as sp
++from scipy.sparse.linalg import spsolve
++
++from qutip.settings import settings
++from qutip import state_number_enumerate
++from qutip.core import data as _data
++from qutip.core.data import csr as _csr
++from qutip.core import Qobj, QobjEvo
++from qutip.core.superoperator import liouvillian, spre, spost
++from .bofin_baths import (
++    BathExponent, DrudeLorentzBath,
++)
++from ..solver_base import Solver
++from .. import Result
++
++# Load MKL spsolve if avaiable
++if settings.has_mkl:
++    from qutip._mkl.spsolve import mkl_spsolve
++else:
++    mkl_spsolve = None
++
++__all__ = [
++    "heomsolve",
++    "HierarchyADOs",
++    "HierarchyADOsState",
++    "HEOMResult",
++    "HEOMSolver",
++    "HSolverDL",
++]
++
++
++class HierarchyADOs:
++    """
++    A description of ADOs (auxilliary density operators) with the
++    hierarchical equations of motion.
++
++    The list of ADOs is constructed from a list of bath exponents
++    (corresponding to one or more baths). Each ADO is referred to by a label
++    that lists the number of "excitations" of each bath exponent. The
++    level of a label within the hierarchy is the sum of the "excitations"
++    within the label.
++
++    For example the label ``(0, 0, ..., 0)`` represents the density matrix
++    of the system being solved and is the only 0th level label.
++
++    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
++    etc. are the 1st level labels.
++
++    The second level labels all have either two 1s or a single 2, and so on
++    for the third and higher levels of the hierarchy.
++
++    Parameters
++    ----------
++    exponents : list of BathExponent
++        The exponents of the correlation function describing the bath or
++        baths.
++
++    max_depth : int
++        The maximum depth of the hierarchy (i.e. the maximum sum of
++        "excitations" in the hierarchy ADO labels or maximum ADO level).
++
++    Attributes
++    ----------
++    exponents : list of BathExponent
++        The exponents of the correlation function describing the bath or
++        baths.
++
++    max_depth : int
++        The maximum depth of the hierarchy (i.e. the maximum sum of
++        "excitations" in the hierarchy ADO labels).
++
++    dims : list of int
++        The dimensions of each exponent within the bath(s).
++
++    vk : list of complex
++        The frequency of each exponent within the bath(s).
++
++    ck : list of complex
++        The coefficient of each exponent within the bath(s).
++
++    ck2: list of complex
++        For exponents of type "RI", the coefficient of the exponent within
++        the imaginary expansion. For other exponent types, the entry is None.
++
++    sigma_bar_k_offset: list of int
++        For exponents of type "+" or "-" the offset within the list of modes
++        of the corresponding "-" or "+" exponent. For other exponent types,
++        the entry is None.
++
++    labels: list of tuples
++        A list of the ADO labels within the hierarchy.
++    """
++    def __init__(self, exponents, max_depth):
++        self.exponents = exponents
++        self.max_depth = max_depth
++
++        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
++        self.vk = [exp.vk for exp in self.exponents]
++        self.ck = [exp.ck for exp in self.exponents]
++        self.ck2 = [exp.ck2 for exp in self.exponents]
++        self.sigma_bar_k_offset = [
++            exp.sigma_bar_k_offset for exp in self.exponents
++        ]
++
++        self.labels = list(state_number_enumerate(self.dims, max_depth))
++        self._label_idx = {s: i for i, s in enumerate(self.labels)}
++        self.idx = self._label_idx.__getitem__
++
++    def idx(self, label):
++        """
++        Return the index of the ADO label within the list of labels,
++        i.e. within ``self.labels``.
++
++        Parameters
++        ----------
++        label : tuple
++            The label to look up.
++
++        Returns
++        -------
++        int
++            The index of the label within the list of ADO labels.
++
++        Note
++        ----
++        This implementation of the ``.idx(...)`` method is just for
++        reference and documentation. To avoid the cost of a Python
++        function call, it is replaced with
++        ``self._label_idx.__getitem__`` when the instance is created.
++        """
++        return self._label_idx[label]
++
++    def next(self, label, k):
++        """
++        Return the ADO label with one more excitation in the k'th exponent
++        dimension or ``None`` if adding the excitation would exceed the
++        dimension or maximum depth of the hierarchy.
++
++        Parameters
++        ----------
++        label : tuple
++            The ADO label to add an excitation to.
++        k : int
++            The exponent to add the excitation to.
++
++        Returns
++        -------
++        tuple or None
++            The next label.
++        """
++        if label[k] >= self.dims[k] - 1:
++            return None
++        if sum(label) >= self.max_depth:
++            return None
++        return label[:k] + (label[k] + 1,) + label[k + 1:]
++
++    def prev(self, label, k):
++        """
++        Return the ADO label with one fewer excitation in the k'th
++        exponent dimension or ``None`` if the label has no exciations in the
++        k'th exponent.
++
++        Parameters
++        ----------
++        label : tuple
++            The ADO label to remove the excitation from.
++        k : int
++            The exponent to remove the excitation from.
++
++        Returns
++        -------
++        tuple or None
++            The previous label.
++        """
++        if label[k] <= 0:
++            return None
++        return label[:k] + (label[k] - 1,) + label[k + 1:]
++
++    def exps(self, label):
++        """
++        Converts an ADO label into a tuple of exponents, with one exponent
++        for each "excitation" within the label.
++
++        The number of exponents returned is always equal to the level of the
++        label within the hierarchy (i.e. the sum of the indices within the
++        label).
++
++        Parameters
++        ----------
++        label : tuple
++            The ADO label to convert to a list of exponents.
++
++        Returns
++        -------
++        tuple of BathExponent
++            A tuple of BathExponents.
++
++        Examples
++        --------
++
++        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
++
++        ``ados.exps((2, 0, 0))`` would return
++        ``[ados.exponents[0], ados.exponents[0]]``.
++
++        ``ados.exps((1, 2, 1))`` would return
++        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
++           ados.exponents[2]]``.
++        """
++        return sum(
++            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
++            (),
++        )
++
++    def filter(self, level=None, tags=None, dims=None, types=None):
++        """
++        Return a list of ADO labels for ADOs whose "excitations"
++        match the given patterns.
++
++        Each of the filter parameters (tags, dims, types) may be either
++        unspecified (None) or a list. Unspecified parameters are excluded
++        from the filtering.
++
++        All specified filter parameters must be lists of the same length.
++        Each position in the lists describes a particular excitation and
++        any exponent that matches the filters may supply that excitation.
++        The level of all labels returned is thus equal to the length of
++        the filter parameter lists.
++
++        Within a filter parameter list, items that are None represent
++        wildcards and match any value of that exponent attribute
++
++        Parameters
++        ----------
++        level : int
++            The hierarchy depth to return ADOs from.
++
++        tags : list of object or None
++            Filter parameter that matches the ``.tag`` attribute of
++            exponents.
++
++        dims : list of int
++            Filter parameter that matches the ``.dim`` attribute of
++            exponents.
++
++        types : list of BathExponent types or list of str
++            Filter parameter that matches the ``.type`` attribute
++            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
++            instead of by the actual type (e.g. ``BathExponent.types.R``).
++
++        Returns
++        -------
++        list of tuple
++            The ADO label for each ADO whose exponent excitations
++            (i.e. label) match the given filters or level.
++        """
++        if types is not None:
++            types = [
++                t if t is None or isinstance(t, BathExponent.types)
++                else BathExponent.types[t]
++                for t in types
++            ]
++        filters = [("tag", tags), ("type", types), ("dim", dims)]
++        filters = [(attr, f) for attr, f in filters if f is not None]
++        n = max((len(f) for _, f in filters), default=0)
++        if any(len(f) != n for _, f in filters):
++            raise ValueError(
++                "The tags, dims and types filters must all be the same length."
++            )
++        if n > self.max_depth:
++            raise ValueError(
++                f"The maximum depth for the hierarchy is {self.max_depth} but"
++                f" {n} levels of excitation filters were given."
++            )
++        if level is None:
++            if not filters:
++                # fast path for when there are no excitation filters
++                return self.labels[:]
++        else:
++            if not filters:
++                # fast path for when there are no excitation filters
++                return [label for label in self.labels if sum(label) == level]
++            if level != n:
++                raise ValueError(
++                    f"The level parameter is {level} but {n} levels of"
++                    " excitation filters were given."
++                )
++
++        filtered_dims = [1] * len(self.exponents)
++        for lvl in range(n):
++            level_filters = [
++                (attr, f[lvl]) for attr, f in filters
++                if f[lvl] is not None
++            ]
++            for j, exp in enumerate(self.exponents):
++                if any(getattr(exp, attr) != f for attr, f in level_filters):
++                    continue
++                filtered_dims[j] += 1
++                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
++
++        return [
++            label for label in state_number_enumerate(filtered_dims, n)
++            if sum(label) == n
++        ]
++
++
++class HierarchyADOsState:
++    """
++    Provides convenient access to the full hierarchy ADO state at a particular
++    point in time, ``t``.
++
++    Parameters
++    ----------
++    rho : :class:`~qutip.Qobj`
++        The current state of the system (i.e. the 0th component of the
++        hierarchy).
++    ados : :class:`HierarchyADOs`
++        The description of the hierarchy.
++    ado_state : numpy.array
++        The full state of the hierarchy.
++
++    Attributes
++    ----------
++    rho : Qobj
++        The system state.
++
++    In addition, all of the attributes of the hierarchy description,
++    i.e. ``HierarchyADOs``, are provided directly on this class for
++    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
++    call ``.idx(label)`` directly.
++
++    See :class:`HierarchyADOs` for a full list of the available attributes
++    and methods.
++    """
++    def __init__(self, rho, ados, ado_state):
++        self.rho = rho
++        self._ado_state = ado_state
++        self._ados = ados
++
++    def __getattr__(self, name):
++        return getattr(self._ados, name)
++
++    def extract(self, idx_or_label):
++        """
++        Extract a Qobj representing the specified ADO from a full
++        representation of the ADO states.
++
++        Parameters
++        ----------
++        idx : int or label
++            The index of the ADO to extract. If an ADO label, e.g.
++            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
++            is extracted by label instead.
++
++        Returns
++        -------
++        Qobj
++            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
++        """
++        if isinstance(idx_or_label, int):
++            idx = idx_or_label
++        else:
++            idx = self._ados.idx(idx_or_label)
++        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
++
++
++class HEOMResult(Result):
++    def _post_init(self):
++        super()._post_init()
++
++        self.store_ados = self.options["store_ados"]
++        if self.store_ados:
++            self.final_ado_state = None
++            self.ado_states = []
++
++    def _e_op_func(self, e_op):
++        """ Convert an e_op into a function ``f(t, ado_state)``. """
++        if isinstance(e_op, Qobj):
++            return lambda t, ado_state: (ado_state.rho * e_op).tr()
++        elif isinstance(e_op, QobjEvo):
++            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
++        elif callable(e_op):
++            return e_op
++        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
++
++    def _pre_copy(self, state):
++        return state
++
++    def _store_state(self, t, ado_state):
++        self.states.append(ado_state.rho)
++        if self.store_ados:
++            self.ado_states.append(ado_state)
++
++    def _store_final_state(self, t, ado_state):
++        self.final_state = ado_state.rho
++        if self.store_ados:
++            self.final_ado_state = ado_state
++
++
++def heomsolve(
++    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
++):
++    """
++    Hierarchical Equations of Motion (HEOM) solver that supports multiple
++    baths.
++
++    The baths must be all either bosonic or fermionic baths.
++
++    If you need to run many evolutions of the same system and bath, consider
++    using :class:`HEOMSolver` directly to avoid having to continually
++    reconstruct the equation hierarchy for every evolution.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    bath : Bath or list of Bath
++        A :obj:`Bath` containing the exponents of the expansion of the
++        bath correlation funcion and their associated coefficients
++        and coupling operators, or a list of baths.
++
++        If multiple baths are given, they must all be either fermionic
++        or bosonic baths.
++
++    max_depth : int
++        The maximum depth of the heirarchy (i.e. the maximum number of bath
++        exponent "excitations" to retain).
++
++    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
++        If ``rho0`` is a :class:`~Qobj` the it is the initial state
++        of the system (i.e. a :obj:`~Qobj` density matrix).
++
++        If it is a :class:`~HierarchyADOsState` or array-like, then
++        ``rho0`` gives the initial state of all ADOs.
++
++        Usually the state of the ADOs would be determine from a previous
++        call to ``.run(...)`` with the solver results option ``store_ados``
++        set to True. For example, ``result = solver.run(...)`` could be
++        followed by ``solver.run(result.ado_states[-1], tlist)``.
++
++        If a numpy array-like is passed its shape must be
++        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
++        (i.e. shape of the system density matrix) and the ADOs must
++        be in the same order as in ``.ados.labels``.
++
++    tlist : list
++        An ordered list of times at which to return the value of the state.
++
++    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
++        A list or dictionary of operators as :class:`~Qobj`,
++        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
++        a single operator or callable function. For an operator ``op``, the
++        result will be computed using ``(state * op).tr()`` and the state
++        at each time ``t``. For callable functions, ``f``, the result is
++        computed using ``f(t, ado_state)``. The values are stored in the
++        ``expect`` and ``e_data`` attributes of the result (see the return
++        section below).
++
++    args : dict, optional {None}
++        Change the ``args`` of the RHS for the evolution.
++
++    options : dict, optional {None}
++        Generic solver options.
++
++        - store_final_state : bool
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, None
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - store_ados : bool {False, True}
++          Whether or not to store the HEOM ADOs.
++        - normalize_output : bool
++          Normalize output state to hide ODE numerical errors.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - state_data_type: str {'dense'}
++          Name of the data type of the state used during the ODE evolution.
++          Use an empty string to keep the input state type. Many integrator can
++          only work with `Dense`.
++        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
++          Which differential equation integration method to use.
++        - atol, rtol : float
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps :
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - max_step : float, 0
++          Maximum lenght of one internal step. When using pulses, it should be
++          less than half the width of the thinnest pulse.
++
++    Returns
++    -------
++    :class:`~HEOMResult`
++        The results of the simulation run, with the following important
++        attributes:
++
++        * ``times``: the times ``t`` (i.e. the ``tlist``).
++
++        * ``states``: the system state at each time ``t`` (only available
++          if ``e_ops`` was ``None`` or if the solver option
++          ``store_states`` was set to ``True``).
++
++        * ``ado_states``: the full ADO state at each time (only available
++          if the results option ``ado_return`` was set to ``True``).
++          Each element is an instance of :class:`HierarchyADOsState`.
++          The state of a particular ADO may be extracted from
++          ``result.ado_states[i]`` by calling :meth:`.extract`.
++
++        * ``expect``: a list containing the values of each ``e_ops`` at
++          time ``t``.
++
++        * ``e_data``: a dictionary containing the values of each ``e_ops``
++          at tme ``t``. The keys are those given by ``e_ops`` if it was
++          a dict, otherwise they are the indexes of the supplied ``e_ops``.
++
++        See :class:`~HEOMResult` and :class:`~Result` for the complete
++        list of attributes.
++    """
++    H = QobjEvo(H, args=args, tlist=tlist)
++    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
++    return solver.run(state0, tlist, e_ops=e_ops)
++
++
++class HEOMSolver(Solver):
++    """
++    HEOM solver that supports multiple baths.
++
++    The baths must be all either bosonic or fermionic baths.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    bath : Bath or list of Bath
++        A :obj:`Bath` containing the exponents of the expansion of the
++        bath correlation funcion and their associated coefficients
++        and coupling operators, or a list of baths.
++
++        If multiple baths are given, they must all be either fermionic
++        or bosonic baths.
++
++    max_depth : int
++        The maximum depth of the heirarchy (i.e. the maximum number of bath
++        exponent "excitations" to retain).
++
++    options : dict, optional
++        Generic solver options.
++        If set to None the default options will be used. Keyword only.
++        Default: None.
++
++    Attributes
++    ----------
++    ados : :obj:`HierarchyADOs`
++        The description of the hierarchy constructed from the given bath
++        and maximum depth.
++
++    rhs : :obj:`QobjEvo`
++        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
++        the system and bath coupling operators are converted to
++        :class:`qutip.data.CSR` instances during construction of the RHS,
++        so the operators in the ``rhs`` will all be sparse.
++    """
++
++    name = "heomsolver"
++    resultclass = HEOMResult
++    _avail_integrators = {}
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size": 10},
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": False,
++        "method": "adams",
++        "store_ados": False,
++        "state_data_type": "dense",
++    }
++
++    def __init__(self, H, bath, max_depth, *, options=None):
++        _time_start = time()
++
++        if not isinstance(H, (Qobj, QobjEvo)):
++            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
++
++        H = QobjEvo(H)
++        self.L_sys = (
++            liouvillian(H) if H.type == "oper"  # hamiltonian
++            else H  # already a liouvillian
++        )
++
++        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
++        self._sup_shape = self.L_sys.shape[0]
++        self._sys_dims = self.L_sys.dims[0]
++
++        self.ados = HierarchyADOs(
++            self._combine_bath_exponents(bath), max_depth,
++        )
++        self._n_ados = len(self.ados.labels)
++        self._n_exponents = len(self.ados.exponents)
++
++        self._init_ados_time = time() - _time_start
++        _time_start = time()
++
++        # pre-calculate identity matrix required by _grad_n
++        self._sId = _data.identity(self._sup_shape, dtype="csr")
++
++        # pre-calculate superoperators required by _grad_prev and _grad_next:
++        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
++        self._spreQ = [spre(op).data for op in Qs]
++        self._spostQ = [spost(op).data for op in Qs]
++        self._s_pre_minus_post_Q = [
++            _data.sub(self._spreQ[k], self._spostQ[k])
++            for k in range(self._n_exponents)
++        ]
++        self._s_pre_plus_post_Q = [
++            _data.add(self._spreQ[k], self._spostQ[k])
++            for k in range(self._n_exponents)
++        ]
++        self._spreQdag = [spre(op.dag()).data for op in Qs]
++        self._spostQdag = [spost(op.dag()).data for op in Qs]
++        self._s_pre_minus_post_Qdag = [
++            _data.sub(self._spreQdag[k], self._spostQdag[k])
++            for k in range(self._n_exponents)
++        ]
++        self._s_pre_plus_post_Qdag = [
++            _data.add(self._spreQdag[k], self._spostQdag[k])
++            for k in range(self._n_exponents)
++        ]
++
++        self._init_superop_cache_time = time() - _time_start
++        _time_start = time()
++
++        rhs = self._calculate_rhs()
++
++        self._init_rhs_time = time() - _time_start
++
++        super().__init__(rhs, options=options)
++
++    @property
++    def sys_dims(self):
++        """
++        Dimensions of the space that the system use, excluding any environment:
++
++        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
++        for this solver.
++        """
++        return self._sys_dims
++
++    def _initialize_stats(self):
++        stats = super()._initialize_stats()
++        stats.update({
++            "init time": sum([
++                stats["init time"], self._init_ados_time,
++                self._init_superop_cache_time, self._init_rhs_time,
++            ]),
++            "init ados time": self._init_ados_time,
++            "init superop cache time": self._init_superop_cache_time,
++            "init rhs time": self._init_rhs_time,
++            "solver": "Hierarchical Equations of Motion Solver",
++            "max_depth": self.ados.max_depth,
++        })
++        return stats
++
++    def _combine_bath_exponents(self, bath):
++        """ Combine the exponents for the specified baths. """
++        if not isinstance(bath, (list, tuple)):
++            exponents = bath.exponents
++        else:
++            exponents = []
++            for b in bath:
++                exponents.extend(b.exponents)
++        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
++            raise ValueError(
++                "All bath exponents must have system coupling operators"
++                " with the same dimensions but a mixture of dimensions"
++                " was given."
++            )
++        return exponents
++
++    def _grad_n(self, he_n):
++        """ Get the gradient for the hierarchy ADO at level n. """
++        vk = self.ados.vk
++        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
++        op = _data.mul(self._sId, -vk_sum)
++        return op
++
++    def _grad_prev(self, he_n, k):
++        """ Get the previous gradient. """
++        if self.ados.exponents[k].fermionic:
++            return self._grad_prev_fermionic(he_n, k)
++        else:
++            return self._grad_prev_bosonic(he_n, k)
++
++    def _grad_prev_bosonic(self, he_n, k):
++        if self.ados.exponents[k].type == BathExponent.types.R:
++            op = _data.mul(
++                self._s_pre_minus_post_Q[k],
++                -1j * he_n[k] * self.ados.ck[k],
++            )
++        elif self.ados.exponents[k].type == BathExponent.types.I:
++            op = _data.mul(
++                self._s_pre_plus_post_Q[k],
++                -1j * he_n[k] * 1j * self.ados.ck[k],
++            )
++        elif self.ados.exponents[k].type == BathExponent.types.RI:
++            term1 = _data.mul(
++                self._s_pre_minus_post_Q[k],
++                he_n[k] * -1j * self.ados.ck[k],
++            )
++            term2 = _data.mul(
++                self._s_pre_plus_post_Q[k],
++                he_n[k] * self.ados.ck2[k],
++            )
++            op = _data.add(term1, term2)
++        else:
++            raise ValueError(
++                f"Unsupported type {self.ados.exponents[k].type}"
++                f" for exponent {k}"
++            )
++        return op
++
++    def _grad_prev_fermionic(self, he_n, k):
++        ck = self.ados.ck
++        he_fermionic_n = [
++            i * int(exp.fermionic)
++            for i, exp in zip(he_n, self.ados.exponents)
++        ]
++
++        n_excite = sum(he_fermionic_n)
++        sign1 = (-1) ** (n_excite + 1)
++
++        n_excite_before_m = sum(he_fermionic_n[:k])
++        sign2 = (-1) ** (n_excite_before_m)
++
++        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
++
++        if self.ados.exponents[k].type == BathExponent.types["+"]:
++            op = _data.sub(
++                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
++                _data.mul(
++                    self._spostQdag[k],
++                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
++                ),
++            )
++        elif self.ados.exponents[k].type == BathExponent.types["-"]:
++            op = _data.sub(
++                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
++                _data.mul(
++                    self._spostQ[k],
++                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
++                ),
++            )
++        else:
++            raise ValueError(
++                f"Unsupported type {self.ados.exponents[k].type}"
++                f" for exponent {k}"
++            )
++        return op
++
++    def _grad_next(self, he_n, k):
++        """ Get the previous gradient. """
++        if self.ados.exponents[k].fermionic:
++            return self._grad_next_fermionic(he_n, k)
++        else:
++            return self._grad_next_bosonic(he_n, k)
++
++    def _grad_next_bosonic(self, he_n, k):
++        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
++        return op
++
++    def _grad_next_fermionic(self, he_n, k):
++        he_fermionic_n = [
++            i * int(exp.fermionic)
++            for i, exp in zip(he_n, self.ados.exponents)
++        ]
++        n_excite = sum(he_fermionic_n)
++        sign1 = (-1) ** (n_excite + 1)
++
++        n_excite_before_m = sum(he_fermionic_n[:k])
++        sign2 = (-1) ** (n_excite_before_m)
++
++        if self.ados.exponents[k].type == BathExponent.types["+"]:
++            if sign1 == -1:
++                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
++            else:
++                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
++        elif self.ados.exponents[k].type == BathExponent.types["-"]:
++            if sign1 == -1:
++                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
++            else:
++                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
++        else:
++            raise ValueError(
++                f"Unsupported type {self.ados.exponents[k].type}"
++                f" for exponent {k}"
++            )
++        return op
++
++    def _rhs(self):
++        """ Make the RHS for the HEOM. """
++        ops = _GatherHEOMRHS(
++            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
++        )
++
++        for he_n in self.ados.labels:
++            op = self._grad_n(he_n)
++            ops.add_op(he_n, he_n, op)
++            for k in range(len(self.ados.dims)):
++                next_he = self.ados.next(he_n, k)
++                if next_he is not None:
++                    op = self._grad_next(he_n, k)
++                    ops.add_op(he_n, next_he, op)
++                prev_he = self.ados.prev(he_n, k)
++                if prev_he is not None:
++                    op = self._grad_prev(he_n, k)
++                    ops.add_op(he_n, prev_he, op)
++
++        return ops.gather()
++
++    def _calculate_rhs(self):
++        """ Make the full RHS required by the solver. """
++        rhs_mat = self._rhs()
++        rhs_dims = [
++            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
++        ]
++        h_identity = _data.identity(self._n_ados, dtype="csr")
++
++        if self.L_sys.isconstant:
++            # For the constant case, we just add the Liouvillian to the
++            # diagonal blocks of the RHS matrix.
++            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
++            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
++        else:
++            # In the time dependent case, we construct the parameters
++            # for the ODE gradient function under the assumption that
++            #
++            # RHSmat(t) = RHSmat + time dependent terms that only affect the
++            # diagonal blocks of the RHS matrix.
++            #
++            # This assumption holds because only _grad_n dependents on
++            # the system Liouvillian (and not _grad_prev or _grad_next) and
++            # the bath coupling operators are not time-dependent.
++            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
++
++            def _kron(x):
++                return Qobj(
++                    _data.kron(h_identity, x.data),
++                    dims=rhs_dims,
++                ).to("csr")
++
++            rhs += self.L_sys.linear_map(_kron)
++
++        # The assertion that rhs_mat has data type CSR is just a sanity
++        # check on the RHS creation. The base solver class will still
++        # convert the RHS to the type required by the ODE integrator if
++        # needed.
++        assert isinstance(rhs_mat, _csr.CSR)
++        assert isinstance(rhs, QobjEvo)
++        assert rhs.dims == rhs_dims
++
++        return rhs
++
++    def steady_state(
++        self,
++        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
++    ):
++        """
++        Compute the steady state of the system.
++
++        Parameters
++        ----------
++        use_mkl : bool, default=False
++            Whether to use mkl or not. If mkl is not installed or if
++            this is false, use the scipy splu solver instead.
++
++        mkl_max_iter_refine : int
++            Specifies the the maximum number of iterative refinement steps that
++            the MKL PARDISO solver performs.
++
++            For a complete description, see iparm(8) in
++            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
++
++        mkl_weighted_matching : bool
++            MKL PARDISO can use a maximum weighted matching algorithm to
++            permute large elements close the diagonal. This strategy adds an
++            additional level of reliability to the factorization methods.
++
++            For a complete description, see iparm(13) in
++            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
++
++        Returns
++        -------
++        steady_state : Qobj
++            The steady state density matrix of the system.
++
++        steady_ados : :class:`HierarchyADOsState`
++            The steady state of the full ADO hierarchy. A particular ADO may be
++            extracted from the full state by calling :meth:`.extract`.
++        """
++        if not self.L_sys.isconstant:
++            raise ValueError(
++                "A steady state cannot be determined for a time-dependent"
++                " system"
++            )
++        n = self._sys_shape
++
++        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
++        b_mat[0] = 1.0
++
++        L = self.rhs(0).data.copy().as_scipy()
++        L = L.tolil()
++        L[0, 0: n ** 2 * self._n_ados] = 0.0
++        L = L.tocsr()
++        L += sp.csr_matrix((
++            np.ones(n),
++            (np.zeros(n), [num * (n + 1) for num in range(n)])
++        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
++
++        if mkl_spsolve is not None and use_mkl:
++            L.sort_indices()
++            solution = mkl_spsolve(
++                L,
++                b_mat,
++                perm=None,
++                verbose=False,
++                max_iter_refine=mkl_max_iter_refine,
++                scaling_vectors=True,
++                weighted_matching=mkl_weighted_matching,
++            )
++        else:
++            L = L.tocsc()
++            solution = spsolve(L, b_mat)
++
++        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
++        data = _data.mul(_data.add(data, data.conj()), 0.5)
++        steady_state = Qobj(data, dims=self._sys_dims)
++
++        solution = solution.reshape((self._n_ados, n, n))
++        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
++
++        return steady_state, steady_ados
++
++    def run(self, state0, tlist, *, args=None, e_ops=None):
++        """
++        Solve for the time evolution of the system.
++
++        Parameters
++        ----------
++        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
++            If ``rho0`` is a :class:`~Qobj` the it is the initial state
++            of the system (i.e. a :obj:`~Qobj` density matrix).
++
++            If it is a :class:`~HierarchyADOsState` or array-like, then
++            ``rho0`` gives the initial state of all ADOs.
++
++            Usually the state of the ADOs would be determine from a previous
++            call to ``.run(...)`` with the solver results option ``store_ados``
++            set to True. For example, ``result = solver.run(...)`` could be
++            followed by ``solver.run(result.ado_states[-1], tlist)``.
++
++            If a numpy array-like is passed its shape must be
++            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
++            (i.e. shape of the system density matrix) and the ADOs must
++            be in the same order as in ``.ados.labels``.
++
++        tlist : list
++            An ordered list of times at which to return the value of the state.
++
++        args : dict, optional {None}
++            Change the ``args`` of the RHS for the evolution.
++
++        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
++            A list or dictionary of operators as :class:`~Qobj`,
++            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
++            a single operator or callable function. For an operator ``op``, the
++            result will be computed using ``(state * op).tr()`` and the state
++            at each time ``t``. For callable functions, ``f``, the result is
++            computed using ``f(t, ado_state)``. The values are stored in the
++            ``expect`` and ``e_data`` attributes of the result (see the return
++            section below).
++
++        Returns
++        -------
++        :class:`~HEOMResult`
++            The results of the simulation run, with the following important
++            attributes:
++
++            * ``times``: the times ``t`` (i.e. the ``tlist``).
++
++            * ``states``: the system state at each time ``t`` (only available
++              if ``e_ops`` was ``None`` or if the solver option
++              ``store_states`` was set to ``True``).
++
++            * ``ado_states``: the full ADO state at each time (only available
++              if the results option ``ado_return`` was set to ``True``).
++              Each element is an instance of :class:`HierarchyADOsState`.
++              The state of a particular ADO may be extracted from
++              ``result.ado_states[i]`` by calling :meth:`.extract`.
++
++            * ``expect``: a list containing the values of each ``e_ops`` at
++              time ``t``.
++
++            * ``e_data``: a dictionary containing the values of each ``e_ops``
++              at tme ``t``. The keys are those given by ``e_ops`` if it was
++              a dict, otherwise they are the indexes of the supplied ``e_ops``.
++
++            See :class:`~HEOMResult` and :class:`~Result` for the complete
++            list of attributes.
++        """
++        return super().run(state0, tlist, args=args, e_ops=e_ops)
++
++    def _prepare_state(self, state):
++        n = self._sys_shape
++        rho_dims = self._sys_dims
++        hierarchy_shape = (self._n_ados, n, n)
++
++        rho0 = state
++        ado_init = not isinstance(rho0, Qobj)
++
++        if ado_init:
++            if isinstance(rho0, HierarchyADOsState):
++                rho0_he = rho0._ado_state
++            elif hasattr(rho0, "shape"):  # array-like
++                rho0_he = rho0
++            else:
++                raise TypeError(
++                    f"Initial ADOs passed have type {type(rho0)}"
++                    " but a HierarchyADOsState or a numpy array-like instance"
++                    " was expected"
++                )
++            if rho0_he.shape != hierarchy_shape:
++                raise ValueError(
++                    f"Initial ADOs passed have shape {rho0_he.shape}"
++                    f" but the solver hierarchy shape is {hierarchy_shape}"
++                )
++            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
++            rho0_he = _data.create(rho0_he)
++        else:
++            if rho0.dims != rho_dims:
++                raise ValueError(
++                    f"Initial state rho has dims {rho0.dims}"
++                    f" but the system dims are {rho_dims}"
++                )
++            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
++            rho0_he[:n ** 2] = rho0.full().ravel('F')
++            rho0_he = _data.create(rho0_he)
++
++        if self.options["state_data_type"]:
++            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
++
++        return rho0_he
++
++    def _restore_state(self, state, *, copy=True):
++        n = self._sys_shape
++        rho_shape = (n, n)
++        rho_dims = self._sys_dims
++        hierarchy_shape = (self._n_ados, n, n)
++
++        rho = Qobj(
++            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
++            dims=rho_dims,
++        )
++        ado_state = HierarchyADOsState(
++            rho, self.ados, state.to_array().reshape(hierarchy_shape)
++        )
++        return ado_state
++
++    def start(self, state0, t0):
++        """
++        Set the initial state and time for a step evolution.
++
++        Parameters
++        ----------
++        state0 : :class:`Qobj`
++            Initial state of the evolution. This may provide either just the
++            initial density matrix of the system, or the full set of ADOs
++            for the hierarchy. See the documentation for ``rho0`` in the
++            ``.run(...)`` method for details.
++
++        t0 : double
++            Initial time of the evolution.
++        """
++        super().start(state0, t0)
++
++    @property
++    def options(self):
++        """
++        Options for HEOMSolver:
++
++        store_final_state: bool, default=False
++            Whether or not to store the final state of the evolution in the
++            result class.
++
++        store_states: bool, default=None
++            Whether or not to store the state vectors or density matrices.
++            On `None` the states will be saved if no expectation operators are
++            given.
++
++        normalize_output: bool, default=False
++            Normalize output state to hide ODE numerical errors.
++
++        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
++            How to present the solver progress.
++            'tqdm' uses the python module of the same name and raise an error
++            if not installed. Empty string or False will disable the bar.
++
++        progress_kwargs: dict, default={"chunk_size": 10}
++            Arguments to pass to the progress_bar. Qutip's bars use
++            ``chunk_size``.
++
++        method: str, default="adams"
++            Which ordinary differential equation integration method to use.
++
++        state_data_type: str, default="dense"
++            Name of the data type of the state used during the ODE evolution.
++            Use an empty string to keep the input state type. Many integrators
++            support only work with `Dense`.
++
++        store_ados : bool, default=False
++            Whether or not to store the HEOM ADOs. Only relevant when using
++            the HEOM solver.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Solver.options.fset(self, new_options)
++
++
++class HSolverDL(HEOMSolver):
++    """
++    A helper class for creating an :class:`HEOMSolver` that is backwards
++    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
++    in QuTiP 4.6 and below.
++
++    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
++    descriptions of the underlying solver and bath construction.
++
++    An exact copy of the QuTiP 4.6 HSolverDL is provided in
++    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
++    the older solver is required. The older solver will be completely
++    removed in QuTiP 5.
++
++    .. note::
++
++        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
++        supports supplying a time-dependent or Liouvillian ``H_sys``.
++
++    .. note::
++
++        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
++        parameter ``N_exp`` specifying the number of exponents to keep in
++        the expansion of the bath correlation function is one more than
++        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
++        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
++        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
++        order to better match common usage in the literature.
++
++    .. note::
++
++        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
++        are no longer supported.
++
++    Parameters
++    ----------
++    H_sys : Qobj or QobjEvo or list
++        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
++        a complete description.
++
++    coup_op : Qobj
++        Operator describing the coupling between system and bath.
++        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
++
++    coup_strength : float
++        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
++
++    temperature : float
++        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
++
++    N_cut : int
++        The maximum depth of the hierarchy. See ``max_depth`` in
++        :class:`HEOMSolver` for a full description.
++
++    N_exp : int
++        Number of exponential terms used to approximate the bath correlation
++        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
++        less than ``N_exp`` (see note above).
++
++    cut_freq : float
++        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
++        :class:`DrudeLorentzBath`.
++
++    bnd_cut_approx : bool
++        Use boundary cut off approximation. If true, the Matsubara
++        terminator is added to the system Liouvillian (and H_sys is
++        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
++        Default: False.
++
++    options : dict, optional
++        Generic solver options.
++        If set to None the default options will be used. Keyword only.
++        Default: None.
++
++    combine : bool, default True
++        Whether to combine exponents with the same frequency (and coupling
++        operator). See :meth:`BosonicBath.combine` for details.
++        Keyword only. Default: True.
++    """
++    def __init__(
++        self, H_sys, coup_op, coup_strength, temperature,
++        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
++        combine=True,
++    ):
++        H_sys = QobjEvo(H_sys)
++        bath = DrudeLorentzBath(
++            Q=coup_op,
++            lam=coup_strength,
++            gamma=cut_freq,
++            Nk=N_exp - 1,
++            T=temperature,
++            combine=combine,
++        )
++
++        if bnd_cut_approx:
++            # upgrade H_sys to a Liouvillian if needed and add the
++            # bath terminator
++            if H_sys.type == "oper":  # H_sys is a Hamiltonian
++                H_sys = liouvillian(H_sys)
++            _, terminator = bath.terminator()
++            H_sys = H_sys + terminator
++
++        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
++
++        # store input parameters as attributes for politeness and compatibility
++        # with HSolverDL in QuTiP 4.6 and below.
++        self.coup_strength = coup_strength
++        self.cut_freq = cut_freq
++        self.temperature = temperature
++        self.N_exp = N_exp
++        self.bnd_cut_approx = bnd_cut_approx
++
++
++class _GatherHEOMRHS:
++    """ A class for collecting elements of the right-hand side matrix
++        of the HEOM.
++
++        Parameters
++        ----------
++        f_idx: function(he_state) -> he_idx
++            A function that returns the index of a hierarchy state
++            (i.e. an ADO label).
++        block : int
++            The size of a single ADO Liovillian operator in the hierarchy.
++        nhe : int
++            The number of ADOs in the hierarchy.
++    """
++    def __init__(self, f_idx, block, nhe):
++        self._block_size = block
++        self._n_blocks = nhe
++        self._f_idx = f_idx
++        self._ops = []
++
++    def add_op(self, row_he, col_he, op):
++        """ Add an block operator to the list. """
++        self._ops.append(
++            (self._f_idx(row_he), self._f_idx(col_he), op)
++        )
++
++    def gather(self):
++        """ Create the HEOM liouvillian from a sorted list of smaller sparse
++            matrices.
++
++            .. note::
++
++                The list of operators contains tuples of the form
++                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
++                *block* row and column for each op. An operator with
++                block indices ``(N, M)`` is placed at position
++                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
++                in the output matrix.
++
++            Returns
++            -------
++            rhs : :obj:`Data`
++                A combined matrix of shape ``(block * nhe, block * ne)``.
++        """
++        self._ops.sort()
++        ops = np.array(self._ops, dtype=[
++            ("row", _data.base.idxint_dtype),
++            ("col", _data.base.idxint_dtype),
++            ("op", _data.CSR),
++        ])
++        return _csr._from_csr_blocks(
++            ops["row"], ops["col"], ops["op"],
++            self._n_blocks, self._block_size,
++        )
+diff --git a/qutip/solver/integrator/__init__.py b/qutip/solver/integrator/__init__.py
+index 987cfcd5..8e404a99 100644
+--- a/qutip/solver/integrator/__init__.py
++++ b/qutip/solver/integrator/__init__.py
+@@ -1,4 +1,4 @@
+-from .integrator import *
+-from .scipy_integrator import *
+-from .qutip_integrator import *
+-from .krylov import *
++from .integrator import *
++from .scipy_integrator import *
++from .qutip_integrator import *
++from .krylov import *
+diff --git a/qutip/solver/integrator/explicit_rk.pxd b/qutip/solver/integrator/explicit_rk.pxd
+index 46bbcf97..c149c6c0 100644
+--- a/qutip/solver/integrator/explicit_rk.pxd
++++ b/qutip/solver/integrator/explicit_rk.pxd
+@@ -1,63 +1,63 @@
+-#cython: language_level=3
+-from qutip.core.data cimport Data
+-from qutip.core.cy.qobjevo cimport QobjEvo
+-
+-cpdef enum Status:
+-    AT_FRONT = 2
+-    INTERPOLATED = 1
+-    NORMAL = 0
+-    TOO_MUCH_WORK = -1
+-    DT_UNDERFLOW = -2
+-    OUTSIDE_RANGE = -3
+-    NOT_INITIATED = -4
+-
+-cdef class Explicit_RungeKutta:
+-    cdef QobjEvo qevo
+-
+-    # Ode state data, set in set_initial_value
+-    cdef list k
+-    cdef Data _y_temp, _y, _y_prev, _y_front
+-    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
+-    cdef double _t, _t_prev, _t_front
+-    cdef Status _status
+-    cdef dict status_messages
+-
+-    # options: set in init
+-    cdef readonly double rtol, atol, first_step, min_step, max_step
+-    cdef readonly int max_numsteps
+-    cdef readonly bint interpolate
+-    cdef readonly object method
+-
+-    # Runge Kutta tableau and info
+-    cdef int rk_step, rk_extra_step, order, denseout_order
+-    cdef bint adaptative_step, can_interpolate
+-    cdef object b_factor_np
+-    cdef double [:] b
+-    cdef double [:] b_factor
+-    cdef double [:] c
+-    cdef double [:] e
+-    cdef double [:, ::1] a
+-    cdef double [:, ::1] bi
+-
+-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
+-
+-    cpdef void set_initial_value(self, Data y0, double t)
+-
+-    cdef int _step_in_err(self, double t, int max_step)
+-
+-    cdef double _compute_step(self, double dt)
+-
+-    cdef double _error(self, Data y_new, double dt)
+-
+-    cdef void _prep_dense_out(self)
+-
+-    cdef Data _interpolate_step(self, double t, Data out)
+-
+-    cdef inline Data _accumulate(self, Data target, double[:] factors,
+-                                 double dt, int size)
+-
+-    cdef double _estimate_first_step(self, double t, Data y0)
+-
+-    cdef double _get_timestep(self, double t)
+-
+-    cdef void _recompute_safe_step(self, double err, double dt)
++#cython: language_level=3
++from qutip.core.data cimport Data
++from qutip.core.cy.qobjevo cimport QobjEvo
++
++cpdef enum Status:
++    AT_FRONT = 2
++    INTERPOLATED = 1
++    NORMAL = 0
++    TOO_MUCH_WORK = -1
++    DT_UNDERFLOW = -2
++    OUTSIDE_RANGE = -3
++    NOT_INITIATED = -4
++
++cdef class Explicit_RungeKutta:
++    cdef QobjEvo qevo
++
++    # Ode state data, set in set_initial_value
++    cdef list k
++    cdef Data _y_temp, _y, _y_prev, _y_front
++    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
++    cdef double _t, _t_prev, _t_front
++    cdef Status _status
++    cdef dict status_messages
++
++    # options: set in init
++    cdef readonly double rtol, atol, first_step, min_step, max_step
++    cdef readonly int max_numsteps
++    cdef readonly bint interpolate
++    cdef readonly object method
++
++    # Runge Kutta tableau and info
++    cdef int rk_step, rk_extra_step, order, denseout_order
++    cdef bint adaptative_step, can_interpolate
++    cdef object b_factor_np
++    cdef double [:] b
++    cdef double [:] b_factor
++    cdef double [:] c
++    cdef double [:] e
++    cdef double [:, ::1] a
++    cdef double [:, ::1] bi
++
++    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
++
++    cpdef void set_initial_value(self, Data y0, double t)
++
++    cdef int _step_in_err(self, double t, int max_step)
++
++    cdef double _compute_step(self, double dt)
++
++    cdef double _error(self, Data y_new, double dt)
++
++    cdef void _prep_dense_out(self)
++
++    cdef Data _interpolate_step(self, double t, Data out)
++
++    cdef inline Data _accumulate(self, Data target, double[:] factors,
++                                 double dt, int size)
++
++    cdef double _estimate_first_step(self, double t, Data y0)
++
++    cdef double _get_timestep(self, double t)
++
++    cdef void _recompute_safe_step(self, double err, double dt)
+diff --git a/qutip/solver/integrator/explicit_rk.pyx b/qutip/solver/integrator/explicit_rk.pyx
+index 17220ea2..37dd384d 100644
+--- a/qutip/solver/integrator/explicit_rk.pyx
++++ b/qutip/solver/integrator/explicit_rk.pyx
+@@ -1,510 +1,510 @@
+-#cython: language_level=3
+-#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
+-"""
+-Provide a cython implimentation for a general Explicit runge-Kutta method.
+-"""
+-from qutip.core.data cimport Data, Dense, CSR, dense
+-from qutip.core.data.add cimport iadd_dense
+-from qutip.core.data.add import add
+-from qutip.core.data.mul import imul_data
+-from qutip.core.data.tidyup import tidyup_csr
+-from qutip.core.data.norm import frobenius_data
+-from .verner7efficient import vern7_coeff
+-from .verner9efficient import vern9_coeff
+-cimport cython
+-import numpy as np
+-
+-euler_coeff = {
+-    'order': 1,
+-    'a': np.array([[0.]], dtype=np.float64),
+-    'b': np.array([1.], dtype=np.float64),
+-    'c': np.array([0.], dtype=np.float64)
+-}
+-
+-rk4_coeff = {
+-    'order': 4,
+-    'a': np.array([[0., 0., 0., 0.],
+-                   [.5, 0., 0., 0.],
+-                   [0., .5, 0., 0.],
+-                   [0., 0., 1., 0.]], dtype=np.float64),
+-    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
+-    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
+-}
+-
+-
+-cdef Data copy_to(Data in_, Data out):
+-    # Copy while reusing allocated buffer if possible.
+-    # Does not check the shape, etc.
+-    cdef size_t ptr
+-    if type(in_) is Dense:
+-        for ptr in range(in_.shape[0] * in_.shape[1]):
+-            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
+-        return out
+-    else:
+-        return in_.copy()
+-
+-
+-cdef Data iadd_data(Data left, Data right, double complex factor):
+-    # left += right * factor
+-    # reusing `left' allocated buffer if possible.
+-    # TODO: when/if iadd_csr is added: move to data/add.pyx.
+-    if factor == 0:
+-        return left
+-    if type(left) is Dense:
+-        iadd_dense(left, right, factor)
+-        return left
+-    else:
+-        return add(left, right, factor)
+-
+-
+-cdef class Explicit_RungeKutta:
+-    """
+-    Qutip implementation of Runge Kutta ODE.
+-    Works in :class:`Data` allowing solving using sparse and gpu data.
+-
+-    Parameters
+-    ----------
+-    qevo : QobjEvo
+-        The system to integrate: ```dX = qevo.matmul_data(t, X)``
+-
+-    rtol, atol : double
+-        Relative and absolute tolerance of the integration error respectively.
+-
+-    nsteps : int
+-        Maximum number of steps done during one call of integrate.
+-
+-    first_step : double
+-        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
+-        be determined automaticaly.
+-
+-    min_step, max_step : double
+-        Bounds of the step lenght in ``t``. ``0`` means no bounds.
+-
+-    interpolate : bool
+-        Whether to do longer step and interpolate back when the method support
+-        it.
+-        Example:
+-            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
+-            safely integrate up to ``t=3``. If ``interpolate=True``, it will
+-            integrate up to ``t=3`` and then use interpolation to get the state
+-            at ``t=2``. With ``interpolate=False``, it will integrate to
+-            ``t=2``.
+-
+-    method : ['euler', 'rk4', 'vern7', 'vern9']
+-        The integration method to use.
+-        * It also accept a tuple of runge-kutta coefficients.
+-        (See `Explicit_RungeKutta._init_coeff`)
+-    """
+-    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
+-                 int nsteps=1000, double first_step=0, double min_step=0,
+-                 double max_step=0, bint interpolate=True, method="euler"):
+-        # Function to integrate.
+-        self.qevo = qevo
+-        # tolerances
+-        self.atol = atol
+-        self.rtol = rtol
+-        self._dt_safe = atol
+-        # Number of step to do before giving up
+-        self.max_numsteps = nsteps
+-
+-        # contrain on the step times
+-        self.first_step = first_step
+-        self.min_step = min_step or 1e-15
+-        self.max_step = max_step
+-
+-        # If True, will do the steps longer that the target and use
+-        # interpolation to get the state at the wanted time.
+-        self.interpolate = interpolate
+-
+-        self.k = []
+-        if isinstance(method, dict):
+-            self._init_coeff(**method)
+-        elif "vern7" == method:
+-            self._init_coeff(**vern7_coeff)
+-        elif "vern9" == method:
+-            self._init_coeff(**vern9_coeff)
+-        elif "rk4" == method:
+-            self._init_coeff(**rk4_coeff)
+-        else:
+-            self._init_coeff(**euler_coeff)
+-        self.method = method
+-        self._y_prev = None
+-
+-    def _init_coeff(self, order, a, b, c, e=None, bi=None):
+-        """
+-        Read the Butcher tableau.
+-
+-        Parameters
+-        ----------
+-        order : int
+-            Order of the method
+-
+-        a, b, c : numpy.ndarray
+-            The Butcher tableau:
+-            c_0 | a_00 a_01
+-            c_1 | a_10 a_11
+-            ---------------
+-                  b_0  b_1
+-            The ``c`` vector should start with `0` and the first line of ``a``
+-            is also expected to be zeros.
+-            The ``a`` and ``c`` part of the tableau can be larger than the
+-            number of step if dense output is available.
+-
+-        e : numpy.ndarray (optional)
+-            The error coefficients. If given, adaptative step length will be
+-            used to stay within the given tolerance.
+-            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
+-
+-        bi : numpy.ndarray (optional)
+-            The coefficients for the dense output.
+-            The dense output is computed as:
+-                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
+-            with ``k[i]`` the derivative computed from ``a`` and ``c``.
+-        """
+-        self.order = order
+-        self.rk_step = b.shape[0]
+-        self.rk_extra_step = c.shape[0]
+-        if (
+-            self.rk_step > self.rk_extra_step or
+-            a.shape[1] != self.rk_extra_step or
+-            a.shape[0] != self.rk_extra_step
+-        ):
+-            raise ValueError("Inconsistant shape between the Butcher tableau "
+-                             "parts.")
+-
+-        self.adaptative_step = e is not None
+-        if self.adaptative_step and e.shape[0] != self.rk_step:
+-            raise ValueError("The length of the error coefficients must be the"
+-                             " same as the number of steps in the Butcher "
+-                             f"tableau. Got {e.shape[0]} but expected "
+-                             f"{self.rk_step}")
+-
+-        self.interpolate = bi is not None and self.interpolate
+-        if self.interpolate:
+-            self.denseout_order = bi.shape[1]
+-            if bi.shape[0] != self.rk_extra_step:
+-                raise ValueError("The interpolation coefficient's shape must "
+-                                 "be (a.shape[0], dense output order)")
+-
+-        self.a = a
+-        self.b = b
+-        self.c = c
+-        self.e = e
+-        self.bi = bi
+-        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
+-        self.b_factor = self.b_factor_np
+-
+-    cpdef void set_initial_value(self, Data y0, double t):
+-        """
+-        Set the initial state and time of the integration.
+-        """
+-        self._t = t
+-        self._t_prev = t
+-        self._t_front = t
+-        self._dt_int = 0
+-        self._y = y0
+-        self._norm_prev = frobenius_data(self._y)
+-        self._norm_front = self._norm_prev
+-
+-        #prepare the buffers
+-        for i in range(self.rk_extra_step):
+-            self.k.append(self._y.copy())
+-        self._y_temp = self._y.copy()
+-        self._y_front = self._y.copy()
+-        self._y_prev = self._y.copy()
+-
+-        if not self.first_step:
+-            self._dt_safe = self._estimate_first_step(t, self._y)
+-        else:
+-            self._dt_safe = self.first_step
+-
+-    cdef double _estimate_first_step(self, double t, Data y0):
+-        if not self.adaptative_step:
+-            return 0.
+-
+-        cdef double dt1, dt2, dt, factorial = 1, t1
+-        cdef double norm = frobenius_data(y0), tmp_norm
+-        cdef double tol = self.atol + norm * self.rtol
+-        cdef int i
+-        self.k[0] = imul_data(<Data> self.k[0], 0)
+-        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
+-
+-        # Ok approximation for linear system. But not in a general case.
+-        if norm <= self.atol:
+-            norm = 1
+-        tmp_norm = frobenius_data(<Data> self.k[0])
+-        for i in range(1, self.order+1):
+-            factorial *= i
+-        if tmp_norm >= (self.atol * 1e-6):
+-            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
+-                   / tmp_norm)
+-        else:
+-            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
+-
+-        t1 = t + dt1 / 100
+-        self._y_temp = copy_to(y0, self._y_temp)
+-        # below dt1 / 100 is an arbitrary small fraction of dt1:
+-        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
+-        self.k[1] = imul_data(<Data> self.k[1], 0)
+-        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
+-        tmp_norm = frobenius_data(<Data> self.k[1])
+-        if tmp_norm >= (self.atol * 1e-6):
+-            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
+-                   / tmp_norm)
+-        else:
+-            dt2 = dt1
+-
+-        dt = min(dt1, dt2)
+-        if self.max_step:
+-            dt = min(self.max_step, dt)
+-        if self.min_step:
+-            dt = max(self.min_step, dt)
+-        return dt
+-
+-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
+-        """
+-        Do the integration to t.
+-        If ``step`` is True, it will make a maximum 1 step and may not reach
+-        ``t``.
+-        """
+-        cdef int nsteps_left = self.max_numsteps
+-        cdef double err = 0
+-
+-        if self._y_prev is None:
+-            self._status = Status.NOT_INITIATED
+-            return
+-
+-        self._status = Status.NORMAL
+-
+-        if t == self._t:
+-            return
+-
+-        if t < self._t_prev:
+-            self._status = Status.OUTSIDE_RANGE
+-            return
+-
+-        if self.interpolate and t < self._t_front:
+-             self._y = self._interpolate_step(t, self._y)
+-             self._t = t
+-
+-        if step and self._t < self._t_front and t > self._t_front:
+-            # To ensure that the self._t ... t_out interval can be covered.
+-            t = self._t_front
+-
+-        while self._t_front < t:
+-            self._y_prev = copy_to(self._y_front, self._y_prev)
+-            self._t_prev = self._t_front
+-            self._norm_prev = self._norm_front
+-            nsteps_left -= self._step_in_err(t, nsteps_left)
+-            if step:
+-                break
+-
+-        if self._status < 0:
+-            return
+-
+-        if self._t_front > t:
+-            self._prep_dense_out()
+-            self._status = Status.INTERPOLATED
+-            self._t = t
+-            self._y = self._interpolate_step(t, self._y)
+-        else:
+-            self._status = Status.AT_FRONT
+-            self._t = self._t_front
+-            self._y = copy_to(self._y_front, self._y)
+-
+-    cdef int _step_in_err(self, double t, int max_step):
+-        """
+-        Do compute one step, repeating until the error is within tolerance.
+-        """
+-        cdef double error = 1
+-        cdef int nsteps = 0
+-        while error >= 1:
+-            dt = self._get_timestep(t)
+-            error = self._compute_step(dt)
+-            self._dt_int = dt
+-            self._recompute_safe_step(error, dt)
+-
+-            if dt == self.min_step and error > 1:
+-                # The tolerance was not reached but the dt is at the minimum.
+-                self._status = Status.DT_UNDERFLOW
+-                break
+-            nsteps += 1
+-            if nsteps > max_step:
+-                self._status = Status.TOO_MUCH_WORK
+-                break
+-        return nsteps
+-
+-    cdef double _compute_step(self, double dt):
+-        """
+-        Do compute one step with fixed ``dt``, return the error.
+-        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
+-        """
+-        cdef int i
+-        for i in range(self.rk_step):
+-            self.k[i] = imul_data(<Data> self.k[i], 0.)
+-
+-        # Compute the derivatives
+-        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
+-                                          <Data> self.k[0])
+-        for i in range(1, self.rk_step):
+-            self._y_temp = copy_to(self._y_prev, self._y_temp)
+-            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
+-            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
+-                                              self._y_temp, <Data> self.k[i])
+-
+-        # Compute the state
+-        self._y_front = copy_to(self._y_prev, self._y_front)
+-        self._y_front = self._accumulate(self._y_front, self.b, dt,
+-                                         self.rk_step)
+-        self._t_front = self._t_prev + dt
+-
+-        if type(self._y_front) is CSR:
+-            # issparse() test would be better.
+-            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
+-
+-        return self._error(self._y_front, dt)
+-
+-    cdef double _error(self, Data y_new, double dt):
+-        """ Compute the normalized error. (error/tol) """
+-        if not self.adaptative_step:
+-            return 0.
+-        self._y_temp = imul_data(self._y_temp, 0.)
+-        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
+-        self._norm_front = frobenius_data(y_new)
+-        return frobenius_data(self._y_temp) / (self.atol +
+-                max(self._norm_prev, self._norm_front) * self.rtol)
+-
+-    cdef void _prep_dense_out(self):
+-        """
+-        Compute derivative for the interpolation step.
+-        """
+-        cdef double dt = self._dt_int
+-
+-        for i in range(self.rk_step, self.rk_extra_step):
+-            self.k[i] = imul_data(<Data> self.k[i], 0.)
+-            self._y_temp = copy_to(self._y_prev, self._y_temp)
+-            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
+-            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
+-                                              self._y_temp, <Data> self.k[i])
+-
+-    cdef Data _interpolate_step(self, double t, Data out):
+-        """
+-        Compute the state at any points between _t_prev and _t_front
+-        with an error of ~dt**denseout_order.
+-        """
+-        cdef:
+-            int i, j
+-            double t0 = self._t_prev
+-            double dt = self._dt_int
+-            double tau = (t - t0) / dt
+-        for i in range(self.rk_extra_step):
+-            self.b_factor[i] = 0.
+-            for j in range(self.denseout_order-1, -1, -1):
+-                self.b_factor[i] += self.bi[i,j]
+-                self.b_factor[i] *= tau
+-
+-        out = copy_to(self._y_prev, out)
+-        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
+-        return out
+-
+-    cdef inline Data _accumulate(self, Data target, double[:] factors,
+-                         double dt, int size):
+-        cdef int i
+-        for i in range(size):
+-            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
+-        return target
+-
+-    @cython.cdivision(True)
+-    cdef double _get_timestep(self, double t):
+-        """ Get the dt for the step. """
+-        cdef double dt_needed = t - self._t_front
+-        if not self.adaptative_step:
+-            return dt_needed
+-        if self.interpolate:
+-            return self._dt_safe
+-        if dt_needed <= self._dt_safe:
+-            return dt_needed
+-        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
+-
+-    cdef void _recompute_safe_step(self, double err, double dt):
+-        """ Get maximum safe step in function of the error."""
+-        cdef double factor
+-        if not self.adaptative_step:
+-            return
+-        elif err == 0:
+-            factor = 10
+-        else:
+-            factor = 0.9*err**(-1/(self.order+1))
+-            factor = min(10, factor)
+-            factor = max(0.2, factor)
+-
+-        self._dt_safe = dt * factor
+-        if self.max_step:
+-            self._dt_safe = min(self.max_step, self._dt_safe)
+-        if self.min_step:
+-            self._dt_safe = max(self.min_step, self._dt_safe)
+-
+-    def successful(self):
+-        return self._status >= 0
+-
+-    @property
+-    def status(self):
+-        return self._status
+-
+-    def status_message(self):
+-        "Status of the last step in a human readable format."
+-        return {
+-            AT_FRONT: "Internal state at the desired time.",
+-            INTERPOLATED: (
+-                "Internal state past the desired time and "
+-                "interpolation to step done."),
+-            NORMAL: 'No work done.',
+-            TOO_MUCH_WORK: (
+-                'Too much work done in one call. Try to increase '
+-                'the nsteps parameter or increasing the tolerance.'
+-            ),
+-            DT_UNDERFLOW:
+-                'Step size becomes too small. Try increasing tolerance.',
+-            OUTSIDE_RANGE: 'Step outside available range.',
+-            NOT_INITIATED: 'Not initialized.'
+-        }[self._status]
+-
+-    @property
+-    def y(self):
+-        return self._y
+-
+-    @property
+-    def y_prev(self):
+-        return self._y_prev
+-
+-    @property
+-    def y_front(self):
+-        return self._y_front
+-
+-    @property
+-    def t_front(self):
+-        return self._t_front
+-
+-    @property
+-    def t_prev(self):
+-        return self._t_prev
+-
+-    @property
+-    def t(self):
+-        return self._t
+-
+-    def _debug_state(self):
+-        print("t, y: ", self._t,
+-              'None' if self._y is None else self._y.to_array())
+-        print("t_prev, y_prev, |y_prev|", self._t_prev,
+-              'None' if self._y_prev is None else self._y_prev.to_array(),
+-              self._norm_prev)
+-        print("t_front, y_front, |y_front|", self._t_front,
+-              'None' if self._y_front is None else self._y_front.to_array(),
+-              self._norm_front)
+-        print("y_temp",
+-              'None' if self._y_temp is None else self._y_temp.to_array())
+-        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
+-        for i in range(self.rk_extra_step):
+-            print(f'k[{i}]',
+-                  'None' if self.k[i] is None else self.k[i].to_array())
++#cython: language_level=3
++#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
++"""
++Provide a cython implimentation for a general Explicit runge-Kutta method.
++"""
++from qutip.core.data cimport Data, Dense, CSR, dense
++from qutip.core.data.add cimport iadd_dense
++from qutip.core.data.add import add
++from qutip.core.data.mul import imul_data
++from qutip.core.data.tidyup import tidyup_csr
++from qutip.core.data.norm import frobenius_data
++from .verner7efficient import vern7_coeff
++from .verner9efficient import vern9_coeff
++cimport cython
++import numpy as np
++
++euler_coeff = {
++    'order': 1,
++    'a': np.array([[0.]], dtype=np.float64),
++    'b': np.array([1.], dtype=np.float64),
++    'c': np.array([0.], dtype=np.float64)
++}
++
++rk4_coeff = {
++    'order': 4,
++    'a': np.array([[0., 0., 0., 0.],
++                   [.5, 0., 0., 0.],
++                   [0., .5, 0., 0.],
++                   [0., 0., 1., 0.]], dtype=np.float64),
++    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
++    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
++}
++
++
++cdef Data copy_to(Data in_, Data out):
++    # Copy while reusing allocated buffer if possible.
++    # Does not check the shape, etc.
++    cdef size_t ptr
++    if type(in_) is Dense:
++        for ptr in range(in_.shape[0] * in_.shape[1]):
++            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
++        return out
++    else:
++        return in_.copy()
++
++
++cdef Data iadd_data(Data left, Data right, double complex factor):
++    # left += right * factor
++    # reusing `left' allocated buffer if possible.
++    # TODO: when/if iadd_csr is added: move to data/add.pyx.
++    if factor == 0:
++        return left
++    if type(left) is Dense:
++        iadd_dense(left, right, factor)
++        return left
++    else:
++        return add(left, right, factor)
++
++
++cdef class Explicit_RungeKutta:
++    """
++    Qutip implementation of Runge Kutta ODE.
++    Works in :class:`Data` allowing solving using sparse and gpu data.
++
++    Parameters
++    ----------
++    qevo : QobjEvo
++        The system to integrate: ```dX = qevo.matmul_data(t, X)``
++
++    rtol, atol : double
++        Relative and absolute tolerance of the integration error respectively.
++
++    nsteps : int
++        Maximum number of steps done during one call of integrate.
++
++    first_step : double
++        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
++        be determined automaticaly.
++
++    min_step, max_step : double
++        Bounds of the step lenght in ``t``. ``0`` means no bounds.
++
++    interpolate : bool
++        Whether to do longer step and interpolate back when the method support
++        it.
++        Example:
++            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
++            safely integrate up to ``t=3``. If ``interpolate=True``, it will
++            integrate up to ``t=3`` and then use interpolation to get the state
++            at ``t=2``. With ``interpolate=False``, it will integrate to
++            ``t=2``.
++
++    method : ['euler', 'rk4', 'vern7', 'vern9']
++        The integration method to use.
++        * It also accept a tuple of runge-kutta coefficients.
++        (See `Explicit_RungeKutta._init_coeff`)
++    """
++    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
++                 int nsteps=1000, double first_step=0, double min_step=0,
++                 double max_step=0, bint interpolate=True, method="euler"):
++        # Function to integrate.
++        self.qevo = qevo
++        # tolerances
++        self.atol = atol
++        self.rtol = rtol
++        self._dt_safe = atol
++        # Number of step to do before giving up
++        self.max_numsteps = nsteps
++
++        # contrain on the step times
++        self.first_step = first_step
++        self.min_step = min_step or 1e-15
++        self.max_step = max_step
++
++        # If True, will do the steps longer that the target and use
++        # interpolation to get the state at the wanted time.
++        self.interpolate = interpolate
++
++        self.k = []
++        if isinstance(method, dict):
++            self._init_coeff(**method)
++        elif "vern7" == method:
++            self._init_coeff(**vern7_coeff)
++        elif "vern9" == method:
++            self._init_coeff(**vern9_coeff)
++        elif "rk4" == method:
++            self._init_coeff(**rk4_coeff)
++        else:
++            self._init_coeff(**euler_coeff)
++        self.method = method
++        self._y_prev = None
++
++    def _init_coeff(self, order, a, b, c, e=None, bi=None):
++        """
++        Read the Butcher tableau.
++
++        Parameters
++        ----------
++        order : int
++            Order of the method
++
++        a, b, c : numpy.ndarray
++            The Butcher tableau:
++            c_0 | a_00 a_01
++            c_1 | a_10 a_11
++            ---------------
++                  b_0  b_1
++            The ``c`` vector should start with `0` and the first line of ``a``
++            is also expected to be zeros.
++            The ``a`` and ``c`` part of the tableau can be larger than the
++            number of step if dense output is available.
++
++        e : numpy.ndarray (optional)
++            The error coefficients. If given, adaptative step length will be
++            used to stay within the given tolerance.
++            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
++
++        bi : numpy.ndarray (optional)
++            The coefficients for the dense output.
++            The dense output is computed as:
++                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
++            with ``k[i]`` the derivative computed from ``a`` and ``c``.
++        """
++        self.order = order
++        self.rk_step = b.shape[0]
++        self.rk_extra_step = c.shape[0]
++        if (
++            self.rk_step > self.rk_extra_step or
++            a.shape[1] != self.rk_extra_step or
++            a.shape[0] != self.rk_extra_step
++        ):
++            raise ValueError("Inconsistant shape between the Butcher tableau "
++                             "parts.")
++
++        self.adaptative_step = e is not None
++        if self.adaptative_step and e.shape[0] != self.rk_step:
++            raise ValueError("The length of the error coefficients must be the"
++                             " same as the number of steps in the Butcher "
++                             f"tableau. Got {e.shape[0]} but expected "
++                             f"{self.rk_step}")
++
++        self.interpolate = bi is not None and self.interpolate
++        if self.interpolate:
++            self.denseout_order = bi.shape[1]
++            if bi.shape[0] != self.rk_extra_step:
++                raise ValueError("The interpolation coefficient's shape must "
++                                 "be (a.shape[0], dense output order)")
++
++        self.a = a
++        self.b = b
++        self.c = c
++        self.e = e
++        self.bi = bi
++        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
++        self.b_factor = self.b_factor_np
++
++    cpdef void set_initial_value(self, Data y0, double t):
++        """
++        Set the initial state and time of the integration.
++        """
++        self._t = t
++        self._t_prev = t
++        self._t_front = t
++        self._dt_int = 0
++        self._y = y0
++        self._norm_prev = frobenius_data(self._y)
++        self._norm_front = self._norm_prev
++
++        #prepare the buffers
++        for i in range(self.rk_extra_step):
++            self.k.append(self._y.copy())
++        self._y_temp = self._y.copy()
++        self._y_front = self._y.copy()
++        self._y_prev = self._y.copy()
++
++        if not self.first_step:
++            self._dt_safe = self._estimate_first_step(t, self._y)
++        else:
++            self._dt_safe = self.first_step
++
++    cdef double _estimate_first_step(self, double t, Data y0):
++        if not self.adaptative_step:
++            return 0.
++
++        cdef double dt1, dt2, dt, factorial = 1, t1
++        cdef double norm = frobenius_data(y0), tmp_norm
++        cdef double tol = self.atol + norm * self.rtol
++        cdef int i
++        self.k[0] = imul_data(<Data> self.k[0], 0)
++        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
++
++        # Ok approximation for linear system. But not in a general case.
++        if norm <= self.atol:
++            norm = 1
++        tmp_norm = frobenius_data(<Data> self.k[0])
++        for i in range(1, self.order+1):
++            factorial *= i
++        if tmp_norm >= (self.atol * 1e-6):
++            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
++                   / tmp_norm)
++        else:
++            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
++
++        t1 = t + dt1 / 100
++        self._y_temp = copy_to(y0, self._y_temp)
++        # below dt1 / 100 is an arbitrary small fraction of dt1:
++        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
++        self.k[1] = imul_data(<Data> self.k[1], 0)
++        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
++        tmp_norm = frobenius_data(<Data> self.k[1])
++        if tmp_norm >= (self.atol * 1e-6):
++            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
++                   / tmp_norm)
++        else:
++            dt2 = dt1
++
++        dt = min(dt1, dt2)
++        if self.max_step:
++            dt = min(self.max_step, dt)
++        if self.min_step:
++            dt = max(self.min_step, dt)
++        return dt
++
++    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
++        """
++        Do the integration to t.
++        If ``step`` is True, it will make a maximum 1 step and may not reach
++        ``t``.
++        """
++        cdef int nsteps_left = self.max_numsteps
++        cdef double err = 0
++
++        if self._y_prev is None:
++            self._status = Status.NOT_INITIATED
++            return
++
++        self._status = Status.NORMAL
++
++        if t == self._t:
++            return
++
++        if t < self._t_prev:
++            self._status = Status.OUTSIDE_RANGE
++            return
++
++        if self.interpolate and t < self._t_front:
++             self._y = self._interpolate_step(t, self._y)
++             self._t = t
++
++        if step and self._t < self._t_front and t > self._t_front:
++            # To ensure that the self._t ... t_out interval can be covered.
++            t = self._t_front
++
++        while self._t_front < t:
++            self._y_prev = copy_to(self._y_front, self._y_prev)
++            self._t_prev = self._t_front
++            self._norm_prev = self._norm_front
++            nsteps_left -= self._step_in_err(t, nsteps_left)
++            if step:
++                break
++
++        if self._status < 0:
++            return
++
++        if self._t_front > t:
++            self._prep_dense_out()
++            self._status = Status.INTERPOLATED
++            self._t = t
++            self._y = self._interpolate_step(t, self._y)
++        else:
++            self._status = Status.AT_FRONT
++            self._t = self._t_front
++            self._y = copy_to(self._y_front, self._y)
++
++    cdef int _step_in_err(self, double t, int max_step):
++        """
++        Do compute one step, repeating until the error is within tolerance.
++        """
++        cdef double error = 1
++        cdef int nsteps = 0
++        while error >= 1:
++            dt = self._get_timestep(t)
++            error = self._compute_step(dt)
++            self._dt_int = dt
++            self._recompute_safe_step(error, dt)
++
++            if dt == self.min_step and error > 1:
++                # The tolerance was not reached but the dt is at the minimum.
++                self._status = Status.DT_UNDERFLOW
++                break
++            nsteps += 1
++            if nsteps > max_step:
++                self._status = Status.TOO_MUCH_WORK
++                break
++        return nsteps
++
++    cdef double _compute_step(self, double dt):
++        """
++        Do compute one step with fixed ``dt``, return the error.
++        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
++        """
++        cdef int i
++        for i in range(self.rk_step):
++            self.k[i] = imul_data(<Data> self.k[i], 0.)
++
++        # Compute the derivatives
++        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
++                                          <Data> self.k[0])
++        for i in range(1, self.rk_step):
++            self._y_temp = copy_to(self._y_prev, self._y_temp)
++            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
++            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
++                                              self._y_temp, <Data> self.k[i])
++
++        # Compute the state
++        self._y_front = copy_to(self._y_prev, self._y_front)
++        self._y_front = self._accumulate(self._y_front, self.b, dt,
++                                         self.rk_step)
++        self._t_front = self._t_prev + dt
++
++        if type(self._y_front) is CSR:
++            # issparse() test would be better.
++            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
++
++        return self._error(self._y_front, dt)
++
++    cdef double _error(self, Data y_new, double dt):
++        """ Compute the normalized error. (error/tol) """
++        if not self.adaptative_step:
++            return 0.
++        self._y_temp = imul_data(self._y_temp, 0.)
++        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
++        self._norm_front = frobenius_data(y_new)
++        return frobenius_data(self._y_temp) / (self.atol +
++                max(self._norm_prev, self._norm_front) * self.rtol)
++
++    cdef void _prep_dense_out(self):
++        """
++        Compute derivative for the interpolation step.
++        """
++        cdef double dt = self._dt_int
++
++        for i in range(self.rk_step, self.rk_extra_step):
++            self.k[i] = imul_data(<Data> self.k[i], 0.)
++            self._y_temp = copy_to(self._y_prev, self._y_temp)
++            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
++            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
++                                              self._y_temp, <Data> self.k[i])
++
++    cdef Data _interpolate_step(self, double t, Data out):
++        """
++        Compute the state at any points between _t_prev and _t_front
++        with an error of ~dt**denseout_order.
++        """
++        cdef:
++            int i, j
++            double t0 = self._t_prev
++            double dt = self._dt_int
++            double tau = (t - t0) / dt
++        for i in range(self.rk_extra_step):
++            self.b_factor[i] = 0.
++            for j in range(self.denseout_order-1, -1, -1):
++                self.b_factor[i] += self.bi[i,j]
++                self.b_factor[i] *= tau
++
++        out = copy_to(self._y_prev, out)
++        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
++        return out
++
++    cdef inline Data _accumulate(self, Data target, double[:] factors,
++                         double dt, int size):
++        cdef int i
++        for i in range(size):
++            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
++        return target
++
++    @cython.cdivision(True)
++    cdef double _get_timestep(self, double t):
++        """ Get the dt for the step. """
++        cdef double dt_needed = t - self._t_front
++        if not self.adaptative_step:
++            return dt_needed
++        if self.interpolate:
++            return self._dt_safe
++        if dt_needed <= self._dt_safe:
++            return dt_needed
++        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
++
++    cdef void _recompute_safe_step(self, double err, double dt):
++        """ Get maximum safe step in function of the error."""
++        cdef double factor
++        if not self.adaptative_step:
++            return
++        elif err == 0:
++            factor = 10
++        else:
++            factor = 0.9*err**(-1/(self.order+1))
++            factor = min(10, factor)
++            factor = max(0.2, factor)
++
++        self._dt_safe = dt * factor
++        if self.max_step:
++            self._dt_safe = min(self.max_step, self._dt_safe)
++        if self.min_step:
++            self._dt_safe = max(self.min_step, self._dt_safe)
++
++    def successful(self):
++        return self._status >= 0
++
++    @property
++    def status(self):
++        return self._status
++
++    def status_message(self):
++        "Status of the last step in a human readable format."
++        return {
++            AT_FRONT: "Internal state at the desired time.",
++            INTERPOLATED: (
++                "Internal state past the desired time and "
++                "interpolation to step done."),
++            NORMAL: 'No work done.',
++            TOO_MUCH_WORK: (
++                'Too much work done in one call. Try to increase '
++                'the nsteps parameter or increasing the tolerance.'
++            ),
++            DT_UNDERFLOW:
++                'Step size becomes too small. Try increasing tolerance.',
++            OUTSIDE_RANGE: 'Step outside available range.',
++            NOT_INITIATED: 'Not initialized.'
++        }[self._status]
++
++    @property
++    def y(self):
++        return self._y
++
++    @property
++    def y_prev(self):
++        return self._y_prev
++
++    @property
++    def y_front(self):
++        return self._y_front
++
++    @property
++    def t_front(self):
++        return self._t_front
++
++    @property
++    def t_prev(self):
++        return self._t_prev
++
++    @property
++    def t(self):
++        return self._t
++
++    def _debug_state(self):
++        print("t, y: ", self._t,
++              'None' if self._y is None else self._y.to_array())
++        print("t_prev, y_prev, |y_prev|", self._t_prev,
++              'None' if self._y_prev is None else self._y_prev.to_array(),
++              self._norm_prev)
++        print("t_front, y_front, |y_front|", self._t_front,
++              'None' if self._y_front is None else self._y_front.to_array(),
++              self._norm_front)
++        print("y_temp",
++              'None' if self._y_temp is None else self._y_temp.to_array())
++        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
++        for i in range(self.rk_extra_step):
++            print(f'k[{i}]',
++                  'None' if self.k[i] is None else self.k[i].to_array())
+diff --git a/qutip/solver/integrator/integrator.py b/qutip/solver/integrator/integrator.py
+index 44df5546..4268621f 100644
+--- a/qutip/solver/integrator/integrator.py
++++ b/qutip/solver/integrator/integrator.py
+@@ -1,240 +1,240 @@
+-""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
+-import numpy as np
+-
+-__all__ = ['Integrator', 'IntegratorException']
+-
+-
+-class IntegratorException(Exception):
+-    """Error from the ODE solver being unable to integrate with the given
+-    parameters.
+-
+-    Example
+-    -------
+-    - The solver cannot reach the desired tolerance within the maximum number
+-    of steps.
+-    - The step needed to be within desired tolerance is too small.
+-    """
+-
+-
+-class Integrator:
+-    """
+-    A wrapper around ODE solvers.
+-    It ensures a common interface for Solver usage.
+-    It takes and return states as :class:`qutip.core.data.Data`, it may return
+-    a different data-type than the input type.
+-
+-    Parameters
+-    ----------
+-    system: qutip.QobjEvo
+-        Quantum system in which states evolve.
+-
+-    options: dict
+-        Options for the integrator.
+-
+-    Class Attributes
+-    ----------------
+-    name : str
+-        The name of the integrator.
+-
+-    supports_blackbox : bool
+-        If True, then the integrator calls only ``system.matmul``,
+-        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
+-        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
+-        the integrator to modify the system in creative ways. In particular,
+-        the solver may modify the system depending on *both* the time ``t``
+-        *and* the current ``state`` the system is being applied to.
+-
+-        If the integrator calls any other methods, set to False.
+-
+-    supports_time_dependent : bool
+-        If True, then the integrator supports time dependent systems. If False,
+-        ``supports_blackbox`` should usually be ``False`` too.
+-
+-    integrator_options : dict
+-        A dictionary of options used by the integrator and their default
+-        values. Once initiated, ``self.options`` will be a dict with the same
+-        keys, not the full options object passed to the solver. Options' keys
+-        included here will be supported by the :cls:SolverOdeOptions.
+-    """
+-    # Dict of used options and their default values
+-    integrator_options = {}
+-    _options = None
+-    # Can evolve time dependent system
+-    support_time_dependant = None
+-    # Whether the integrator used the system QobjEvo as a blackbox
+-    supports_blackbox = None
+-    # The name of the integrator
+-    name = None
+-    method = ""
+-
+-    def __init__(self, system, options):
+-        self.system = system
+-        self._is_set = False  # get_state can be used and return a valid state.
+-        self._back = (np.inf, None)
+-        self._options = self.integrator_options.copy()
+-        self.options = options
+-        self._prepare()
+-
+-    def _prepare(self):
+-        """
+-        Initialize the solver
+-        It should also set the name of the solver to be displayed in Result.
+-        """
+-        raise NotImplementedError
+-
+-    def set_state(self, t, state0):
+-        """
+-        Set the state of the ODE solver.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Initial time
+-
+-        state0 : qutip.Data
+-            Initial state.
+-
+-        .. note:
+-            It should set the flags `_is_set` to True.
+-        """
+-        raise NotImplementedError
+-
+-    def integrate(self, t, copy=True):
+-        """
+-        Evolve to t.
+-
+-        Before calling `integrate` for the first time, the initial state should
+-        be set with `set_state`.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time to integrate to, should be larger than the previous time.
+-
+-        copy : bool [True]
+-            Whether to return a copy of the state or the state itself.
+-
+-        Returns
+-        -------
+-        (t, state) : (float, qutip.Data)
+-            The state of the solver at ``t``.
+-        """
+-        raise NotImplementedError
+-
+-    def mcstep(self, t, copy=True):
+-        """
+-        Evolve toward the time ``t``.
+-
+-        If ``t`` is larger than the present state's ``t``, advance the internal
+-        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
+-        larger than the previous one, it does an interpolation step and returns
+-        the state at that time. When advancing the state, it may return it at a
+-        time between present time and the asked ``t`` if more efficent for
+-        subsequent interpolation step.
+-
+-        Before calling `mcstep` for the first time, the initial state should
+-        be set with `set_state`.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time to integrate to, should be larger than the previous time. If
+-            the last integrate call was use with ``step=True``, the time can be
+-            between the time at the start of the last call and now.
+-
+-        copy : bool [True]
+-            Whether to return a copy of the state or the state itself.
+-
+-        Returns
+-        -------
+-        (t, state) : (float, qutip.Data)
+-            The state of the solver at ``t``. The returned time ``t`` can
+-            differ from the input time only when ``step=True``.
+-
+-        .. note:
+-            The default implementation may be overridden by integrators that
+-            can provide a more efficient one.
+-        """
+-        t_last, state = self.get_state()
+-        if t > t_last:
+-            self._back = t_last, state
+-        elif t > self._back[0]:
+-            self.set_state(*self._back)
+-        else:
+-            raise IntegratorException(
+-                "`t` is outside the integration range: "
+-                f"{self._back[0]}..{t_last}."
+-            )
+-        return self.integrate(t, copy)
+-
+-    def get_state(self, copy=True):
+-        """
+-        Obtain the state of the solver as a pair (t, state).
+-
+-        Parameters
+-        ----------
+-        copy : bool (True)
+-            Whether to return the data stored in the Integrator or a copy.
+-
+-        Returns
+-        -------
+-        (t, state) : (float, qutip.Data)
+-            The state of the solver at ``t``.
+-        """
+-        raise NotImplementedError
+-
+-    def run(self, tlist):
+-        """
+-        Integrate the system yielding the state for each times in tlist.
+-
+-        Parameters
+-        ----------
+-        tlist : *list* / *array*
+-            List of times to yield the state.
+-
+-        Yields
+-        ------
+-        (t, state) : (float, qutip.Data)
+-            The state of the solver at each ``t`` of tlist.
+-        """
+-        for t in tlist[1:]:
+-            yield self.integrate(t, False)
+-
+-    def reset(self, hard=False):
+-        """Reset internal state of the ODE solver."""
+-        if self._is_set:
+-            state = self.get_state()
+-        if hard:
+-            self._prepare()
+-        if self._is_set:
+-            self.set_state(*state)
+-
+-    def arguments(self, args):
+-        """
+-        Change the argument of the system.
+-        Reset the ODE solver to ensure numerical validity.
+-
+-        Parameters
+-        ----------
+-        args : dict
+-            New arguments
+-        """
+-        self.system.arguments(args)
+-        self.reset()
+-
+-    @property
+-    def options(self):
+-        # Options should be overwritten by each integrators.
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        # This does not apply the new options.
+-        self._options = {
+-            **self._options,
+-            **{
+-               key: new_options[key]
+-               for key in self.integrator_options.keys()
+-               if key in new_options and new_options[key] is not None
+-            }
+-        }
++""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
++import numpy as np
++
++__all__ = ['Integrator', 'IntegratorException']
++
++
++class IntegratorException(Exception):
++    """Error from the ODE solver being unable to integrate with the given
++    parameters.
++
++    Example
++    -------
++    - The solver cannot reach the desired tolerance within the maximum number
++    of steps.
++    - The step needed to be within desired tolerance is too small.
++    """
++
++
++class Integrator:
++    """
++    A wrapper around ODE solvers.
++    It ensures a common interface for Solver usage.
++    It takes and return states as :class:`qutip.core.data.Data`, it may return
++    a different data-type than the input type.
++
++    Parameters
++    ----------
++    system: qutip.QobjEvo
++        Quantum system in which states evolve.
++
++    options: dict
++        Options for the integrator.
++
++    Class Attributes
++    ----------------
++    name : str
++        The name of the integrator.
++
++    supports_blackbox : bool
++        If True, then the integrator calls only ``system.matmul``,
++        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
++        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
++        the integrator to modify the system in creative ways. In particular,
++        the solver may modify the system depending on *both* the time ``t``
++        *and* the current ``state`` the system is being applied to.
++
++        If the integrator calls any other methods, set to False.
++
++    supports_time_dependent : bool
++        If True, then the integrator supports time dependent systems. If False,
++        ``supports_blackbox`` should usually be ``False`` too.
++
++    integrator_options : dict
++        A dictionary of options used by the integrator and their default
++        values. Once initiated, ``self.options`` will be a dict with the same
++        keys, not the full options object passed to the solver. Options' keys
++        included here will be supported by the :cls:SolverOdeOptions.
++    """
++    # Dict of used options and their default values
++    integrator_options = {}
++    _options = None
++    # Can evolve time dependent system
++    support_time_dependant = None
++    # Whether the integrator used the system QobjEvo as a blackbox
++    supports_blackbox = None
++    # The name of the integrator
++    name = None
++    method = ""
++
++    def __init__(self, system, options):
++        self.system = system
++        self._is_set = False  # get_state can be used and return a valid state.
++        self._back = (np.inf, None)
++        self._options = self.integrator_options.copy()
++        self.options = options
++        self._prepare()
++
++    def _prepare(self):
++        """
++        Initialize the solver
++        It should also set the name of the solver to be displayed in Result.
++        """
++        raise NotImplementedError
++
++    def set_state(self, t, state0):
++        """
++        Set the state of the ODE solver.
++
++        Parameters
++        ----------
++        t : float
++            Initial time
++
++        state0 : qutip.Data
++            Initial state.
++
++        .. note:
++            It should set the flags `_is_set` to True.
++        """
++        raise NotImplementedError
++
++    def integrate(self, t, copy=True):
++        """
++        Evolve to t.
++
++        Before calling `integrate` for the first time, the initial state should
++        be set with `set_state`.
++
++        Parameters
++        ----------
++        t : float
++            Time to integrate to, should be larger than the previous time.
++
++        copy : bool [True]
++            Whether to return a copy of the state or the state itself.
++
++        Returns
++        -------
++        (t, state) : (float, qutip.Data)
++            The state of the solver at ``t``.
++        """
++        raise NotImplementedError
++
++    def mcstep(self, t, copy=True):
++        """
++        Evolve toward the time ``t``.
++
++        If ``t`` is larger than the present state's ``t``, advance the internal
++        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
++        larger than the previous one, it does an interpolation step and returns
++        the state at that time. When advancing the state, it may return it at a
++        time between present time and the asked ``t`` if more efficent for
++        subsequent interpolation step.
++
++        Before calling `mcstep` for the first time, the initial state should
++        be set with `set_state`.
++
++        Parameters
++        ----------
++        t : float
++            Time to integrate to, should be larger than the previous time. If
++            the last integrate call was use with ``step=True``, the time can be
++            between the time at the start of the last call and now.
++
++        copy : bool [True]
++            Whether to return a copy of the state or the state itself.
++
++        Returns
++        -------
++        (t, state) : (float, qutip.Data)
++            The state of the solver at ``t``. The returned time ``t`` can
++            differ from the input time only when ``step=True``.
++
++        .. note:
++            The default implementation may be overridden by integrators that
++            can provide a more efficient one.
++        """
++        t_last, state = self.get_state()
++        if t > t_last:
++            self._back = t_last, state
++        elif t > self._back[0]:
++            self.set_state(*self._back)
++        else:
++            raise IntegratorException(
++                "`t` is outside the integration range: "
++                f"{self._back[0]}..{t_last}."
++            )
++        return self.integrate(t, copy)
++
++    def get_state(self, copy=True):
++        """
++        Obtain the state of the solver as a pair (t, state).
++
++        Parameters
++        ----------
++        copy : bool (True)
++            Whether to return the data stored in the Integrator or a copy.
++
++        Returns
++        -------
++        (t, state) : (float, qutip.Data)
++            The state of the solver at ``t``.
++        """
++        raise NotImplementedError
++
++    def run(self, tlist):
++        """
++        Integrate the system yielding the state for each times in tlist.
++
++        Parameters
++        ----------
++        tlist : *list* / *array*
++            List of times to yield the state.
++
++        Yields
++        ------
++        (t, state) : (float, qutip.Data)
++            The state of the solver at each ``t`` of tlist.
++        """
++        for t in tlist[1:]:
++            yield self.integrate(t, False)
++
++    def reset(self, hard=False):
++        """Reset internal state of the ODE solver."""
++        if self._is_set:
++            state = self.get_state()
++        if hard:
++            self._prepare()
++        if self._is_set:
++            self.set_state(*state)
++
++    def arguments(self, args):
++        """
++        Change the argument of the system.
++        Reset the ODE solver to ensure numerical validity.
++
++        Parameters
++        ----------
++        args : dict
++            New arguments
++        """
++        self.system.arguments(args)
++        self.reset()
++
++    @property
++    def options(self):
++        # Options should be overwritten by each integrators.
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        # This does not apply the new options.
++        self._options = {
++            **self._options,
++            **{
++               key: new_options[key]
++               for key in self.integrator_options.keys()
++               if key in new_options and new_options[key] is not None
++            }
++        }
+diff --git a/qutip/solver/integrator/krylov.py b/qutip/solver/integrator/krylov.py
+index d9cf5757..a05d198b 100644
+--- a/qutip/solver/integrator/krylov.py
++++ b/qutip/solver/integrator/krylov.py
+@@ -1,238 +1,238 @@
+-from ..integrator import IntegratorException, Integrator
+-import numpy as np
+-from qutip.core import data as _data
+-from scipy.optimize import root_scalar
+-from ..sesolve import SESolver
+-
+-
+-__all__ = ["IntegratorKrylov"]
+-
+-
+-class IntegratorKrylov(Integrator):
+-    """
+-    Evolve the state vector ("psi0") finding an approximation for the time
+-    evolution operator of Hamiltonian ("H") by obtaining the projection of
+-    the time evolution operator on a set of small dimensional Krylov
+-    subspaces (m << dim(H)).
+-    """
+-    integrator_options = {
+-        'atol': 1e-7,
+-        'nsteps': 100,
+-        'min_step': 1e-5,
+-        'max_step': 1e5,
+-        'krylov_dim': 0,
+-        'sub_system_tol': 1e-7,
+-        'always_compute_step': False,
+-    }
+-    support_time_dependant = False
+-    supports_blackbox = False
+-    method = 'krylov'
+-
+-    def _prepare(self):
+-        if not self.system.isconstant:
+-            raise ValueError("krylov method only support constant system.")
+-        self._max_step = -np.inf
+-        krylov_dim = self.options["krylov_dim"]
+-        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
+-            raise ValueError("The options 'krylov_dim', must be a positive "
+-                             "integer smaller that the system size")
+-
+-        if krylov_dim == 0:
+-            # TODO: krylov_dim, max_step and error (atol) are related by
+-            # err ~= exp(-krylov_dim / dt**(1~2))
+-            # We could ask for 2 and determine the third one.
+-            N = self.system.shape[0]
+-            krylov_dim = min(int((N + 100)**0.5), N-1)
+-            self.options["krylov_dim"]  = krylov_dim
+-
+-        if not self.options["always_compute_step"]:
+-            from qutip import rand_ket
+-            N = self.system.shape[0]
+-            krylov_tridiag, krylov_basis = \
+-                self._lanczos_algorithm(rand_ket(N).data)
+-            if (
+-                krylov_tridiag.shape[0] < self.options["krylov_dim"]
+-                or krylov_tridiag.shape[0] == N
+-            ):
+-                self._max_step = np.inf
+-            else:
+-                self._max_step = self._compute_max_step(krylov_tridiag,
+-                                                        krylov_basis)
+-
+-    def _lanczos_algorithm(self, psi):
+-        """
+-        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
+-        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
+-        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
+-
+-        Parameters
+-        ------------
+-        psi: np.ndarray
+-            State used to calculate Krylov subspace.
+-        """
+-        krylov_dim = self.options['krylov_dim']
+-        H = (1j * self.system(0)).data
+-
+-        v = []
+-        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
+-        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
+-
+-        w_prime = _data.matmul(H, psi)
+-        T_diag[0] = _data.inner(w_prime, psi)
+-        v.append(psi)
+-        w = _data.add(w_prime, v[-1], -T_diag[0])
+-        T_subdiag[0] = _data.norm.l2(w)
+-        j = 0
+-
+-        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
+-            j += 1
+-            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
+-            w_prime = _data.matmul(H, v[-1])
+-            T_diag[j] = _data.inner(w_prime, v[-1])
+-            w = _data.add(w_prime, v[-1], -T_diag[j])
+-            w = _data.add(w, v[-2], -T_subdiag[j-1])
+-            T_subdiag[j] = _data.norm.l2(w)
+-
+-        krylov_tridiag = _data.diag["dense"](
+-            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
+-            [-1, 0, 1]
+-        )
+-        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
+-
+-        return krylov_tridiag, krylov_basis
+-
+-    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
+-        """
+-        Compute the eigen energies, basis transformation operator (U) and e0.
+-        """
+-        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
+-        N = eigenvalues.shape[0]
+-        U = _data.matmul(krylov_basis, eigenvectors)
+-        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
+-        return eigenvalues, U, e0
+-
+-    def _compute_psi(self, dt, eigenvalues, U, e0):
+-        """
+-        compute the state at time ``t``.
+-        """
+-        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
+-        aux = _data.multiply(phases, e0)
+-        return _data.matmul(U, aux)
+-
+-    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
+-        """
+-        Compute the maximum step length to stay under the desired tolerance.
+-        """
+-        if not krylov_state:
+-            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
+-
+-        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
+-        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
+-        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
+-
+-        def krylov_error(t):
+-            # we divide by atol and take the log so that the error returned is 0
+-            # at atol, which is convenient for calling root_scalar with.
+-            return np.log(_data.norm.l2(
+-                self._compute_psi(t, *krylov_state) -
+-                self._compute_psi(t, *reduced_state)
+-            ) / self.options["atol"])
+-
+-        dt = self.options["min_step"]
+-        err = krylov_error(dt)
+-        if err > 0:
+-            ValueError(
+-                f"With the krylov dim of {self.options['krylov_dim']}, the "
+-                f"error with the minimum step {dt} is {err}, higher than the "
+-                f"desired tolerance of {self.options['atol']}."
+-            )
+-
+-        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
+-            dt *= 10
+-
+-        if dt > self.options["max_step"]:
+-            return self.options["max_step"]
+-
+-        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
+-                          method="brentq", xtol=self.options['atol'])
+-        if sol.converged:
+-            return sol.root
+-        else:
+-            return dt
+-
+-    def set_state(self, t, state0):
+-        self._t_0 = t
+-        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
+-        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
+-
+-        if (
+-            krylov_tridiag.shape[0] <= self.options['krylov_dim']
+-            or krylov_tridiag.shape == self.system.shape
+-        ):
+-            # happy_breakdown
+-            self._max_step = np.inf
+-            return
+-
+-        if (
+-            not np.isfinite(self._max_step)
+-            or self.options["always_compute_step"]
+-        ):
+-            self._max_step = self._compute_max_step(
+-                krylov_tridiag, krylov_basis, self._krylov_state,
+-            )
+-
+-    def get_state(self, copy=True):
+-        return self._t_0, self._compute_psi(0, *self._krylov_state)
+-
+-    def integrate(self, t, copy=True):
+-        step = 0
+-        while t > self._t_0 + self._max_step:
+-            # The approximation in only valid in the range t_0, t_0 + max step
+-            # If outside, advance the range
+-            step += 1
+-            if step >= self.options["nsteps"]:
+-                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
+-            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
+-            self.set_state(self._t_0 + self._max_step, new_psi)
+-
+-        delta_t = t - self._t_0
+-        out = self._compute_psi(delta_t, *self._krylov_state)
+-        return t, out
+-
+-    @property
+-    def options(self):
+-        """
+-        Supported options by krylov method:
+-
+-        atol : float, default=1e-7
+-            Absolute tolerance.
+-
+-        nsteps : int, default=100
+-            Max. number of internal steps/call.
+-
+-        min_step, max_step : float, default=(1e-5, 1e5)
+-            Minimum and maximum step size.
+-
+-        krylov_dim: int, default=0
+-            Dimension of Krylov approximation subspaces used for the time
+-            evolution approximation. If the defaut 0 is given, the dimension is calculated
+-            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
+-
+-        sub_system_tol: float, default=1e-7
+-            Tolerance to detect a happy breakdown. A happy breakdown occurs
+-            when the initial ket is in a subspace of the Hamiltonian smaller
+-            than ``krylov_dim``.
+-
+-        always_compute_step: bool, default=False
+-            If True, the step length is computed each time a new Krylov
+-            subspace is computed. Otherwise it is computed only once when
+-            creating the integrator.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Integrator.options.fset(self, new_options)
+-
+-
+-SESolver.add_integrator(IntegratorKrylov, 'krylov')
++from ..integrator import IntegratorException, Integrator
++import numpy as np
++from qutip.core import data as _data
++from scipy.optimize import root_scalar
++from ..sesolve import SESolver
++
++
++__all__ = ["IntegratorKrylov"]
++
++
++class IntegratorKrylov(Integrator):
++    """
++    Evolve the state vector ("psi0") finding an approximation for the time
++    evolution operator of Hamiltonian ("H") by obtaining the projection of
++    the time evolution operator on a set of small dimensional Krylov
++    subspaces (m << dim(H)).
++    """
++    integrator_options = {
++        'atol': 1e-7,
++        'nsteps': 100,
++        'min_step': 1e-5,
++        'max_step': 1e5,
++        'krylov_dim': 0,
++        'sub_system_tol': 1e-7,
++        'always_compute_step': False,
++    }
++    support_time_dependant = False
++    supports_blackbox = False
++    method = 'krylov'
++
++    def _prepare(self):
++        if not self.system.isconstant:
++            raise ValueError("krylov method only support constant system.")
++        self._max_step = -np.inf
++        krylov_dim = self.options["krylov_dim"]
++        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
++            raise ValueError("The options 'krylov_dim', must be a positive "
++                             "integer smaller that the system size")
++
++        if krylov_dim == 0:
++            # TODO: krylov_dim, max_step and error (atol) are related by
++            # err ~= exp(-krylov_dim / dt**(1~2))
++            # We could ask for 2 and determine the third one.
++            N = self.system.shape[0]
++            krylov_dim = min(int((N + 100)**0.5), N-1)
++            self.options["krylov_dim"]  = krylov_dim
++
++        if not self.options["always_compute_step"]:
++            from qutip import rand_ket
++            N = self.system.shape[0]
++            krylov_tridiag, krylov_basis = \
++                self._lanczos_algorithm(rand_ket(N).data)
++            if (
++                krylov_tridiag.shape[0] < self.options["krylov_dim"]
++                or krylov_tridiag.shape[0] == N
++            ):
++                self._max_step = np.inf
++            else:
++                self._max_step = self._compute_max_step(krylov_tridiag,
++                                                        krylov_basis)
++
++    def _lanczos_algorithm(self, psi):
++        """
++        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
++        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
++        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
++
++        Parameters
++        ------------
++        psi: np.ndarray
++            State used to calculate Krylov subspace.
++        """
++        krylov_dim = self.options['krylov_dim']
++        H = (1j * self.system(0)).data
++
++        v = []
++        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
++        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
++
++        w_prime = _data.matmul(H, psi)
++        T_diag[0] = _data.inner(w_prime, psi)
++        v.append(psi)
++        w = _data.add(w_prime, v[-1], -T_diag[0])
++        T_subdiag[0] = _data.norm.l2(w)
++        j = 0
++
++        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
++            j += 1
++            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
++            w_prime = _data.matmul(H, v[-1])
++            T_diag[j] = _data.inner(w_prime, v[-1])
++            w = _data.add(w_prime, v[-1], -T_diag[j])
++            w = _data.add(w, v[-2], -T_subdiag[j-1])
++            T_subdiag[j] = _data.norm.l2(w)
++
++        krylov_tridiag = _data.diag["dense"](
++            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
++            [-1, 0, 1]
++        )
++        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
++
++        return krylov_tridiag, krylov_basis
++
++    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
++        """
++        Compute the eigen energies, basis transformation operator (U) and e0.
++        """
++        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
++        N = eigenvalues.shape[0]
++        U = _data.matmul(krylov_basis, eigenvectors)
++        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
++        return eigenvalues, U, e0
++
++    def _compute_psi(self, dt, eigenvalues, U, e0):
++        """
++        compute the state at time ``t``.
++        """
++        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
++        aux = _data.multiply(phases, e0)
++        return _data.matmul(U, aux)
++
++    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
++        """
++        Compute the maximum step length to stay under the desired tolerance.
++        """
++        if not krylov_state:
++            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
++
++        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
++        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
++        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
++
++        def krylov_error(t):
++            # we divide by atol and take the log so that the error returned is 0
++            # at atol, which is convenient for calling root_scalar with.
++            return np.log(_data.norm.l2(
++                self._compute_psi(t, *krylov_state) -
++                self._compute_psi(t, *reduced_state)
++            ) / self.options["atol"])
++
++        dt = self.options["min_step"]
++        err = krylov_error(dt)
++        if err > 0:
++            ValueError(
++                f"With the krylov dim of {self.options['krylov_dim']}, the "
++                f"error with the minimum step {dt} is {err}, higher than the "
++                f"desired tolerance of {self.options['atol']}."
++            )
++
++        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
++            dt *= 10
++
++        if dt > self.options["max_step"]:
++            return self.options["max_step"]
++
++        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
++                          method="brentq", xtol=self.options['atol'])
++        if sol.converged:
++            return sol.root
++        else:
++            return dt
++
++    def set_state(self, t, state0):
++        self._t_0 = t
++        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
++        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
++
++        if (
++            krylov_tridiag.shape[0] <= self.options['krylov_dim']
++            or krylov_tridiag.shape == self.system.shape
++        ):
++            # happy_breakdown
++            self._max_step = np.inf
++            return
++
++        if (
++            not np.isfinite(self._max_step)
++            or self.options["always_compute_step"]
++        ):
++            self._max_step = self._compute_max_step(
++                krylov_tridiag, krylov_basis, self._krylov_state,
++            )
++
++    def get_state(self, copy=True):
++        return self._t_0, self._compute_psi(0, *self._krylov_state)
++
++    def integrate(self, t, copy=True):
++        step = 0
++        while t > self._t_0 + self._max_step:
++            # The approximation in only valid in the range t_0, t_0 + max step
++            # If outside, advance the range
++            step += 1
++            if step >= self.options["nsteps"]:
++                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
++            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
++            self.set_state(self._t_0 + self._max_step, new_psi)
++
++        delta_t = t - self._t_0
++        out = self._compute_psi(delta_t, *self._krylov_state)
++        return t, out
++
++    @property
++    def options(self):
++        """
++        Supported options by krylov method:
++
++        atol : float, default=1e-7
++            Absolute tolerance.
++
++        nsteps : int, default=100
++            Max. number of internal steps/call.
++
++        min_step, max_step : float, default=(1e-5, 1e5)
++            Minimum and maximum step size.
++
++        krylov_dim: int, default=0
++            Dimension of Krylov approximation subspaces used for the time
++            evolution approximation. If the defaut 0 is given, the dimension is calculated
++            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
++
++        sub_system_tol: float, default=1e-7
++            Tolerance to detect a happy breakdown. A happy breakdown occurs
++            when the initial ket is in a subspace of the Hamiltonian smaller
++            than ``krylov_dim``.
++
++        always_compute_step: bool, default=False
++            If True, the step length is computed each time a new Krylov
++            subspace is computed. Otherwise it is computed only once when
++            creating the integrator.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Integrator.options.fset(self, new_options)
++
++
++SESolver.add_integrator(IntegratorKrylov, 'krylov')
+diff --git a/qutip/solver/integrator/qutip_integrator.py b/qutip/solver/integrator/qutip_integrator.py
+index 03749a57..eca2da63 100644
+--- a/qutip/solver/integrator/qutip_integrator.py
++++ b/qutip/solver/integrator/qutip_integrator.py
+@@ -1,200 +1,200 @@
+-from ..integrator import IntegratorException, Integrator
+-from ..solver_base import Solver
+-from .explicit_rk import Explicit_RungeKutta
+-import numpy as np
+-from qutip import data as _data
+-
+-
+-__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
+-
+-
+-class IntegratorVern7(Integrator):
+-    """
+-    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
+-    of order 7. These are Runge-Kutta methods with variable steps and dense
+-    output.
+-
+-    The implementation uses QuTiP's Data objects for the state, allowing
+-    sparse, GPU or other data layer objects to be used efficiently by the
+-    solver in their native formats.
+-
+-    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
+-    methods.
+-
+-    Usable with ``method="vern7"``
+-    """
+-    integrator_options = {
+-        'atol': 1e-8,
+-        'rtol': 1e-6,
+-        'nsteps': 1000,
+-        'first_step': 0,
+-        'max_step': 0,
+-        'min_step': 0,
+-        'interpolate': True,
+-    }
+-    support_time_dependant = True
+-    supports_blackbox = True
+-    method = 'vern7'
+-
+-    def _prepare(self):
+-        self._ode_solver = Explicit_RungeKutta(
+-            self.system, method=self.method,
+-            **self.options
+-        )
+-        self.name = self.method
+-
+-    def get_state(self, copy=True):
+-        state = self._ode_solver.y
+-        return self._ode_solver.t, state.copy() if copy else state
+-
+-    def set_state(self, t, state):
+-        self._ode_solver.set_initial_value(state.copy(), t)
+-        self._is_set = True
+-
+-    def integrate(self, t, copy=True):
+-        self._ode_solver.integrate(t, step=False)
+-        self._check_failed_integration()
+-        return self.get_state(copy)
+-
+-    def mcstep(self, t, copy=True):
+-        self._ode_solver.integrate(t, step=True)
+-        self._check_failed_integration()
+-        return self.get_state(copy)
+-
+-    def _check_failed_integration(self):
+-        if self._ode_solver.successful():
+-            return
+-        raise IntegratorException(self._ode_solver.status_message())
+-
+-    @property
+-    def options(self):
+-        """
+-        Supported options by verner method:
+-
+-        atol : float, default=1e-8
+-            Absolute tolerance.
+-
+-        rtol : float, default=1e-6
+-            Relative tolerance.
+-
+-        nsteps : int, default=1000
+-            Max. number of internal steps/call.
+-
+-        first_step : float, default=0
+-            Size of initial step (0 = automatic).
+-
+-        min_step : float, default=0
+-            Minimum step size (0 = automatic).
+-
+-        max_step : float, default=0
+-            Maximum step size (0 = automatic)
+-            When using pulses, change to half the thinest pulse otherwise it
+-            may be skipped.
+-
+-        interpolate : bool, default=True
+-            Whether to use interpolation step, faster most of the time.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Integrator.options.fset(self, new_options)
+-
+-
+-class IntegratorVern9(IntegratorVern7):
+-    """
+-    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
+-    of order 9. These are Runge-Kutta methods with variable steps and dense
+-    output.
+-
+-    The implementation uses QuTiP's Data objects for the state, allowing
+-    sparse, GPU or other data layer objects to be used efficiently by the
+-    solver in their native formats.
+-
+-    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
+-    methods.
+-
+-    Usable with ``method="vern9"``
+-    """
+-    integrator_options = {
+-        'atol': 1e-8,
+-        'rtol': 1e-6,
+-        'nsteps': 1000,
+-        'first_step': 0,
+-        'max_step': 0,
+-        'min_step': 0,
+-        'interpolate': True,
+-    }
+-    method = 'vern9'
+-
+-
+-class IntegratorDiag(Integrator):
+-    """
+-    Integrator solving the ODE by diagonalizing the system and solving
+-    analytically. It can only solve constant system and has a long preparation
+-    time, but the integration is fast.
+-
+-    Usable with ``method="diag"``
+-    """
+-    integrator_options = {"eigensolver_dtype": "dense"}
+-    support_time_dependant = False
+-    supports_blackbox = False
+-    method = 'diag'
+-
+-    def __init__(self, system, options):
+-        if not system.isconstant:
+-            raise ValueError("Hamiltonian system must be constant to use "
+-                             "diagonalized method")
+-        super().__init__(system, options)
+-
+-    def _prepare(self):
+-        self._dt = 0.
+-        self._expH = None
+-        H0 = self.system(0).to(self.options["eigensolver_dtype"])
+-        self.diag, self.U = _data.eigs(H0.data, False)
+-        self.diag = self.diag.reshape((-1, 1))
+-        self.Uinv = _data.inv(self.U)
+-        self.name = "qutip diagonalized"
+-
+-    def integrate(self, t, copy=True):
+-        dt = t - self._t
+-        if dt == 0:
+-            return self.get_state()
+-        elif self._dt != dt:
+-            self._expH = np.exp(self.diag * dt)
+-            self._dt = dt
+-        self._y *= self._expH
+-        self._t = t
+-        return self.get_state(copy)
+-
+-    def mcstep(self, t, copy=True):
+-        return self.integrate(t, copy=copy)
+-
+-    def get_state(self, copy=True):
+-        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
+-
+-    def set_state(self, t, state0):
+-        self._t = t
+-        self._y = _data.matmul(self.Uinv, state0).to_array()
+-        self._is_set = True
+-
+-    @property
+-    def options(self):
+-        """
+-        Supported options by "diag" method:
+-
+-        eigensolver_dtype : str, default="dense"
+-            Qutip data type {"dense", "csr", etc.} to use when computing the
+-            eigenstates. The dense eigen solver is usually faster and more
+-            stable.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Integrator.options.fset(self, new_options)
+-
+-
+-Solver.add_integrator(IntegratorVern7, 'vern7')
+-Solver.add_integrator(IntegratorVern9, 'vern9')
+-Solver.add_integrator(IntegratorDiag, 'diag')
++from ..integrator import IntegratorException, Integrator
++from ..solver_base import Solver
++from .explicit_rk import Explicit_RungeKutta
++import numpy as np
++from qutip import data as _data
++
++
++__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
++
++
++class IntegratorVern7(Integrator):
++    """
++    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
++    of order 7. These are Runge-Kutta methods with variable steps and dense
++    output.
++
++    The implementation uses QuTiP's Data objects for the state, allowing
++    sparse, GPU or other data layer objects to be used efficiently by the
++    solver in their native formats.
++
++    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
++    methods.
++
++    Usable with ``method="vern7"``
++    """
++    integrator_options = {
++        'atol': 1e-8,
++        'rtol': 1e-6,
++        'nsteps': 1000,
++        'first_step': 0,
++        'max_step': 0,
++        'min_step': 0,
++        'interpolate': True,
++    }
++    support_time_dependant = True
++    supports_blackbox = True
++    method = 'vern7'
++
++    def _prepare(self):
++        self._ode_solver = Explicit_RungeKutta(
++            self.system, method=self.method,
++            **self.options
++        )
++        self.name = self.method
++
++    def get_state(self, copy=True):
++        state = self._ode_solver.y
++        return self._ode_solver.t, state.copy() if copy else state
++
++    def set_state(self, t, state):
++        self._ode_solver.set_initial_value(state.copy(), t)
++        self._is_set = True
++
++    def integrate(self, t, copy=True):
++        self._ode_solver.integrate(t, step=False)
++        self._check_failed_integration()
++        return self.get_state(copy)
++
++    def mcstep(self, t, copy=True):
++        self._ode_solver.integrate(t, step=True)
++        self._check_failed_integration()
++        return self.get_state(copy)
++
++    def _check_failed_integration(self):
++        if self._ode_solver.successful():
++            return
++        raise IntegratorException(self._ode_solver.status_message())
++
++    @property
++    def options(self):
++        """
++        Supported options by verner method:
++
++        atol : float, default=1e-8
++            Absolute tolerance.
++
++        rtol : float, default=1e-6
++            Relative tolerance.
++
++        nsteps : int, default=1000
++            Max. number of internal steps/call.
++
++        first_step : float, default=0
++            Size of initial step (0 = automatic).
++
++        min_step : float, default=0
++            Minimum step size (0 = automatic).
++
++        max_step : float, default=0
++            Maximum step size (0 = automatic)
++            When using pulses, change to half the thinest pulse otherwise it
++            may be skipped.
++
++        interpolate : bool, default=True
++            Whether to use interpolation step, faster most of the time.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Integrator.options.fset(self, new_options)
++
++
++class IntegratorVern9(IntegratorVern7):
++    """
++    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
++    of order 9. These are Runge-Kutta methods with variable steps and dense
++    output.
++
++    The implementation uses QuTiP's Data objects for the state, allowing
++    sparse, GPU or other data layer objects to be used efficiently by the
++    solver in their native formats.
++
++    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
++    methods.
++
++    Usable with ``method="vern9"``
++    """
++    integrator_options = {
++        'atol': 1e-8,
++        'rtol': 1e-6,
++        'nsteps': 1000,
++        'first_step': 0,
++        'max_step': 0,
++        'min_step': 0,
++        'interpolate': True,
++    }
++    method = 'vern9'
++
++
++class IntegratorDiag(Integrator):
++    """
++    Integrator solving the ODE by diagonalizing the system and solving
++    analytically. It can only solve constant system and has a long preparation
++    time, but the integration is fast.
++
++    Usable with ``method="diag"``
++    """
++    integrator_options = {"eigensolver_dtype": "dense"}
++    support_time_dependant = False
++    supports_blackbox = False
++    method = 'diag'
++
++    def __init__(self, system, options):
++        if not system.isconstant:
++            raise ValueError("Hamiltonian system must be constant to use "
++                             "diagonalized method")
++        super().__init__(system, options)
++
++    def _prepare(self):
++        self._dt = 0.
++        self._expH = None
++        H0 = self.system(0).to(self.options["eigensolver_dtype"])
++        self.diag, self.U = _data.eigs(H0.data, False)
++        self.diag = self.diag.reshape((-1, 1))
++        self.Uinv = _data.inv(self.U)
++        self.name = "qutip diagonalized"
++
++    def integrate(self, t, copy=True):
++        dt = t - self._t
++        if dt == 0:
++            return self.get_state()
++        elif self._dt != dt:
++            self._expH = np.exp(self.diag * dt)
++            self._dt = dt
++        self._y *= self._expH
++        self._t = t
++        return self.get_state(copy)
++
++    def mcstep(self, t, copy=True):
++        return self.integrate(t, copy=copy)
++
++    def get_state(self, copy=True):
++        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
++
++    def set_state(self, t, state0):
++        self._t = t
++        self._y = _data.matmul(self.Uinv, state0).to_array()
++        self._is_set = True
++
++    @property
++    def options(self):
++        """
++        Supported options by "diag" method:
++
++        eigensolver_dtype : str, default="dense"
++            Qutip data type {"dense", "csr", etc.} to use when computing the
++            eigenstates. The dense eigen solver is usually faster and more
++            stable.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Integrator.options.fset(self, new_options)
++
++
++Solver.add_integrator(IntegratorVern7, 'vern7')
++Solver.add_integrator(IntegratorVern9, 'vern9')
++Solver.add_integrator(IntegratorDiag, 'diag')
+diff --git a/qutip/solver/integrator/scipy_integrator.py b/qutip/solver/integrator/scipy_integrator.py
+index dac1028a..7c71185f 100644
+--- a/qutip/solver/integrator/scipy_integrator.py
++++ b/qutip/solver/integrator/scipy_integrator.py
+@@ -1,527 +1,527 @@
+-"""ODE integrator from scipy."""
+-
+-__all__ = [
+-    'IntegratorScipyAdams',
+-    'IntegratorScipyBDF',
+-    'IntegratorScipyDop853',
+-    'IntegratorScipylsoda',
+-]
+-
+-import numpy as np
+-from scipy.integrate import ode
+-from scipy.integrate._ode import zvode
+-from qutip.core import data as _data
+-from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
+-from ..integrator import IntegratorException, Integrator
+-from ..solver_base import Solver
+-import warnings
+-
+-
+-class IntegratorScipyAdams(Integrator):
+-    """
+-    Integrator using Scipy `ode` with zvode integrator using adams method.
+-    Ordinary Differential Equation solver by netlib
+-    (http://www.netlib.org/odepack).
+-
+-    Usable with ``method="adams"``
+-    """
+-    integrator_options = {
+-        'atol': 1e-8,
+-        'rtol': 1e-6,
+-        'nsteps': 2500,
+-        'order': 12,
+-        'first_step': 0,
+-        'max_step': 0,
+-        'min_step': 0,
+-    }
+-    support_time_dependant = True
+-    supports_blackbox = True
+-    method = 'adams'
+-
+-    class _zvode(zvode):
+-        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
+-        def step(self, *args):
+-            itask = self.call_args[2]
+-            self.rwork[0] = args[4]
+-            self.call_args[2] = 5
+-            r = self.run(*args)
+-            self.call_args[2] = itask
+-            return r
+-
+-    def _prepare(self):
+-        """
+-        Initialize the solver
+-        """
+-        self._ode_solver = ode(self._mul_np_vec)
+-        self._ode_solver.set_integrator('zvode')
+-        self._ode_solver._integrator = self._zvode(
+-            method=self.method,
+-            **self.options,
+-        )
+-        self.name = "scipy zvode " + self.method
+-
+-    def _mul_np_vec(self, t, vec):
+-        """
+-        Interface between scipy which use numpy and the driver, which use data.
+-        """
+-        state = _data.dense.fast_from_numpy(vec)
+-        column_unstack_dense(state, self._size, inplace=True)
+-        out = self.system.matmul_data(t, state)
+-        column_stack_dense(out, inplace=True)
+-        return out.as_ndarray().ravel()
+-
+-    def set_state(self, t, state0):
+-        self._is_set = True
+-        self._back = t
+-        self._front = t
+-        self._mat_state = state0.shape[1] > 1
+-        self._size = state0.shape[0]
+-        if self._mat_state:
+-            state0 = _data.column_stack(state0)
+-        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
+-
+-    def get_state(self, copy=True):
+-        if not self._is_set:
+-            raise IntegratorException("The state is not initialted")
+-        self._check_failed_integration()
+-        t = self._ode_solver.t
+-        if self._mat_state:
+-            state = _data.column_unstack_dense(
+-                _data.dense.Dense(self._ode_solver._y, copy=copy),
+-                self._size,
+-                inplace=True)
+-        else:
+-            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
+-        return t, state
+-
+-    def _check_handle(self):
+-        """
+-        Do the check for concurrent use of the integrator and reset if used
+-        elsewhere.
+-        """
+-        integrator = self._ode_solver._integrator
+-        if integrator.initialized:
+-            if integrator.handle != integrator.__class__.active_global_handle:
+-                integrator.reset(len(self._ode_solver._y), False)
+-
+-    def integrate(self, t, copy=True):
+-        self._check_handle()
+-        if t != self._ode_solver.t:
+-            self._ode_solver.integrate(t)
+-        return self.get_state(copy)
+-
+-    def mcstep(self, t, copy=True):
+-        # When working with mcstep, we use the dense output feature:
+-        # a range in which the state at any time can be computed with
+-        # minimal work. We keep track of the range with _back and _front.
+-        self._check_handle()
+-        if self._ode_solver.t == t:
+-            # Exact same `t` as the last call, nothing to do.
+-            pass
+-        elif self._back > t:
+-            # `t` before the range: not supported.
+-            raise IntegratorException(
+-                f"`t`={t} is behind the integration limit: "
+-                f"{t} < {self._back}."
+-            )
+-        elif t <= self._front:
+-            # In the range, ask for the new state.
+-            self._ode_solver.integrate(t)
+-        elif self._ode_solver.t < self._front:
+-            # `t` after the range but last call (`t_prev`) not at the front.
+-            # Advancing the range would make the interval `t_prev`..`_front`
+-            # unreachable. Thus advance to _front.
+-            self._ode_solver.integrate(self._front)
+-        else:
+-            # Advance the range.
+-            self._back = self._front
+-            self._ode_solver.integrate(t, step=True)
+-            self._front = self._ode_solver._integrator.rwork[12]
+-
+-        return self.get_state(copy)
+-
+-    def _check_failed_integration(self):
+-        if self._ode_solver.successful():
+-            return
+-        messages = {
+-            -1: 'Excess work done on this call. Try to increasing '
+-                'the nsteps parameter in the Options class',
+-            -2: 'Excess accuracy requested. (Tolerances too small.)',
+-            -3: 'Illegal input detected.',
+-            -4: 'Repeated error test failures. (Check all input.)',
+-            -5: 'Repeated convergence failures. (Perhaps bad'
+-                ' Jacobian supplied or wrong choice of MF or tolerances.)',
+-            -6: 'Error weight became zero during problem. (Solution'
+-                ' component i vanished, and ATOL or ATOL(i) = 0.)'
+-        }
+-        raise IntegratorException(
+-            messages[self._ode_solver._integrator.istate]
+-        )
+-
+-    @property
+-    def options(self):
+-        """
+-        Supported options by zvode integrator:
+-
+-        atol : float, default=1e-8
+-            Absolute tolerance.
+-
+-        rtol : float, default=1e-6
+-            Relative tolerance.
+-
+-        order : int, default=12, 'adams' or 5, 'bdf'
+-            Order of integrator <=12 'adams', <=5 'bdf'
+-
+-        nsteps : int, default=2500
+-            Max. number of internal steps/call.
+-
+-        first_step : float, default=0
+-            Size of initial step (0 = automatic).
+-
+-        min_step : float, default=0
+-            Minimum step size (0 = automatic).
+-
+-        max_step : float, default=0
+-            Maximum step size (0 = automatic)
+-            When using pulses, change to half the thinest pulse otherwise it
+-            may be skipped.
+-    """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Integrator.options.fset(self, new_options)
+-
+-
+-class IntegratorScipyBDF(IntegratorScipyAdams):
+-    """
+-    Integrator using Scipy `ode` with zvode integrator using bdf method.
+-    Ordinary Differential Equation solver by netlib
+-    (http://www.netlib.org/odepack).
+-
+-    Usable with ``method="bdf"``
+-    """
+-    method = 'bdf'
+-    integrator_options = {
+-        'atol': 1e-8,
+-        'rtol': 1e-6,
+-        'nsteps': 2500,
+-        'order': 5,
+-        'first_step': 0,
+-        'max_step': 0,
+-        'min_step': 0,
+-    }
+-
+-
+-class IntegratorScipyDop853(Integrator):
+-    """
+-    Integrator using Scipy `ode` with dop853 integrator. Eight order
+-    runge-kutta method by Dormand & Prince. Use fortran implementation
+-    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
+-    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
+-    Computational Mathematics, Springer-Verlag (1993)].
+-
+-    Usable with ``method="dop853"``
+-    """
+-    integrator_options = {
+-        'atol': 1e-8,
+-        'rtol': 1e-6,
+-        'nsteps': 2500,
+-        'first_step': 0,
+-        'max_step': 0,
+-        'ifactor': 6.0,
+-        'dfactor': 0.3,
+-        'beta': 0.0,
+-    }
+-    support_time_dependant = True
+-    supports_blackbox = True
+-    method = 'dop853'
+-
+-    def _prepare(self):
+-        """
+-        Initialize the solver
+-        """
+-        self._ode_solver = ode(self._mul_np_vec)
+-        self._ode_solver.set_integrator('dop853', **self.options)
+-        self.name = "scipy ode dop853"
+-
+-    def _mul_np_vec(self, t, vec):
+-        """
+-        Interface between scipy which use numpy and the driver, which use data.
+-        """
+-        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
+-        column_unstack_dense(state, self._size, inplace=True)
+-        out = self.system.matmul_data(t, state)
+-        column_stack_dense(out, inplace=True)
+-        return out.as_ndarray().ravel().view(np.float64)
+-
+-    def integrate(self, t, copy=True):
+-        if t != self._ode_solver.t:
+-            self._ode_solver.integrate(t)
+-        return self.get_state(copy)
+-
+-    def mcstep(self, t, copy=True):
+-        if self._ode_solver.t <= t:
+-            # Scipy's DOP853 does not have a step function.
+-            # It has a safe step length, but can be 0 if unknown.
+-            dt = self._ode_solver._integrator.work[6]
+-            if dt:
+-                t = min(self._ode_solver.t + dt, t)
+-            self._ode_solver.integrate(t)
+-        else:
+-            # While DOP853 support changing the direction of the integration,
+-            # it does not do so efficiently. We do it manually.
+-            self._ode_solver._integrator.work[6] *= -1
+-            self._ode_solver.integrate(t)
+-            self._ode_solver._integrator.work[6] *= -1
+-        return self.get_state(copy)
+-
+-    def get_state(self, copy=True):
+-        if not self._is_set:
+-            raise IntegratorException("The state is not initialted")
+-        self._check_failed_integration()
+-        t = self._ode_solver.t
+-        if self._mat_state:
+-            state = _data.column_unstack_dense(
+-                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
+-                                  copy=copy),
+-                self._size,
+-                inplace=True)
+-        else:
+-            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
+-                                      copy=copy)
+-        return t, state
+-
+-    def set_state(self, t, state0):
+-        self._is_set = True
+-        self._mat_state = state0.shape[1] > 1
+-        self._size = state0.shape[0]
+-        if self._mat_state:
+-            state0 = _data.column_stack(state0)
+-        self._ode_solver.set_initial_value(
+-            state0.to_array().ravel().view(np.float64),
+-            t
+-        )
+-
+-    def _check_failed_integration(self):
+-        if self._ode_solver.successful():
+-            return
+-        messages = {
+-            -1: 'input is not consistent',
+-            -2: 'larger nsteps is needed, Try to increase the nsteps '
+-                'parameter in the Options class.',
+-            -3: 'step size becomes too small. Try increasing tolerance',
+-            -4: 'problem is probably stiff (interrupted), try "bdf" '
+-                'method instead',
+-        }
+-        raise IntegratorException(
+-            messages[self._ode_solver._integrator.istate]
+-        )
+-
+-    @property
+-    def options(self):
+-        """
+-        Supported options by dop853 integrator:
+-
+-        atol : float, default=1e-8
+-            Absolute tolerance.
+-
+-        rtol : float, default=1e-6
+-            Relative tolerance.
+-
+-        nsteps : int, default=2500
+-            Max. number of internal steps/call.
+-
+-        first_step : float, default=0
+-            Size of initial step (0 = automatic).
+-
+-        max_step : float, default=0
+-            Maximum step size (0 = automatic)
+-
+-        ifactor, dfactor : float, default=6., 0.3
+-            Maximum factor to increase/decrease step size by in one step
+-
+-        beta : float, default=0
+-            Beta parameter for stabilised step size control.
+-
+-        See scipy.integrate.ode ode for more detail
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Integrator.options.fset(self, new_options)
+-
+-
+-class IntegratorScipylsoda(IntegratorScipyDop853):
+-    """
+-    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
+-    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
+-    'BDF' methods to solve both stiff and non-stiff systems.
+-
+-    Usable with ``method="lsoda"``
+-    """
+-    integrator_options = {
+-        'atol': 1e-8,
+-        'rtol': 1e-6,
+-        'nsteps': 2500,
+-        'max_order_ns': 12,
+-        'max_order_s': 5,
+-        'first_step': 0.0,
+-        'max_step': 0.0,
+-        'min_step': 0.0,
+-    }
+-    support_time_dependant = True
+-    supports_blackbox = True
+-    method = 'lsoda'
+-
+-    def _prepare(self):
+-        """
+-        Initialize the solver
+-        """
+-        self._ode_solver = ode(self._mul_np_vec)
+-        self._ode_solver.set_integrator('lsoda', **self.options)
+-        self.name = "scipy lsoda"
+-
+-    def _check_handle(self):
+-        """
+-        Do the check for concurrent use of the integrator and reset if used
+-        elsewhere.
+-        """
+-        integrator = self._ode_solver._integrator
+-        if integrator.initialized:
+-            if integrator.handle != integrator.__class__.active_global_handle:
+-                integrator.reset(len(self._ode_solver._y), False)
+-
+-    def integrate(self, t, copy=True):
+-        self._check_handle()
+-        return super().integrate(t, copy)
+-
+-    def set_state(self, t, state0):
+-        self._front = t
+-        super().set_state(t, state0)
+-        self._back = self.get_state()
+-
+-    def mcstep(self, t, copy=True):
+-        # This solver support dense output:
+-        # a range in which the state at any time can be computed with
+-        # minimal work. We keep track of the range with _back[0] and _front.
+-        self._check_handle()
+-        if self._ode_solver.t == t:
+-            # Exact same `t` as the last call, nothing to do.
+-            pass
+-        elif self._back[0] <= t <= self._front:
+-            # In the range, ask for the new state.
+-            self._backstep(t)
+-        elif self._front < t:
+-            # Advance the range.
+-            self._one_step(t)
+-        else:
+-            raise IntegratorException(
+-                f"`t`={t} is behind the integration limit: "
+-                f"{t} < {self._back[0]}."
+-            )
+-        return self.get_state(copy)
+-
+-    def _one_step(self, t):
+-        """
+-        Advance up to t by one internal solver step.
+-        Should be able to retreive the state at any time between the present
+-        time and the resulting time using `backstep`.
+-        """
+-        # Here we want to advance up to t doing maximum one step.
+-        # lsoda officially support step, but sometime it does more work than
+-        # needed, so we ask it to advance a fraction of the last step, where it
+-        # will advance one internal step of length allowed by the tolerance and
+-        # interpolate back to the asked time, effictively getting the single
+-        # integration step we want. The first step and abrupt changes in the
+-        # `rhs` can cause exceptions to this, but _backstep catch those cases.
+-        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
+-        t_ode = self._ode_solver.t
+-
+-        if t > self._front and t_ode >= self._front:
+-            # The state is at self._front, do a step
+-            self._back = self.get_state()
+-            self._ode_solver.integrate(min(self._front + safe_delta, t))
+-            self._front = self._ode_solver._integrator.rwork[12]
+-            # We asked for a fraction of a step, now complete it.
+-            self._ode_solver.integrate(min(self._front, t))
+-        elif t > self._front:
+-            # The state is at a time before t_front, advance to t_front
+-            self._ode_solver.integrate(self._front)
+-
+-    def _backstep(self, t):
+-        """
+-        Retreive the state at time t, with t smaller than present ODE time.
+-        The time t will always be between the last calls of `one_step`.
+-        return the pair t, state.
+-        """
+-        delta = self._ode_solver._integrator.rwork[11]
+-        if t == self._ode_solver.t:
+-            pass
+-        elif self._front - delta <= t:
+-            self._ode_solver.integrate(t)
+-        else:
+-            self.set_state(*self._back)
+-            self._ode_solver.integrate(t)
+-
+-    def _check_failed_integration(self):
+-        if self._ode_solver.successful():
+-            return
+-        messages = {
+-            -1: "Excess work done on this call."
+-                "Try to increase the nsteps parameter in the Options class.",
+-            -2: "Excess accuracy requested (tolerances too small).",
+-            -3: "Illegal input detected (internal error).",
+-            -4: "Repeated error test failures (internal error).",
+-            -5: "Repeated convergence failures "
+-                "(perhaps bad Jacobian or tolerances).",
+-            -6: "Error weight became zero during problem.",
+-            -7: "Internal workspace insufficient to finish (internal error)."
+-        }
+-        raise IntegratorException(
+-            messages[self._ode_solver._integrator.istate]
+-        )
+-
+-    @property
+-    def options(self):
+-        """
+-        Supported options by lsoda integrator:
+-
+-        atol : float, default=1e-8
+-            Absolute tolerance.
+-
+-        rtol : float, default=1e-6
+-            Relative tolerance.
+-
+-        nsteps : int, default=2500
+-            Max. number of internal steps/call.
+-
+-        max_order_ns : int, default=12
+-            Maximum order used in the nonstiff case (<= 12).
+-
+-        max_order_s : int, default=5
+-            Maximum order used in the stiff case (<= 5).
+-
+-        first_step : float, default=0
+-            Size of initial step (0 = automatic).
+-
+-        max_step : float, default=0
+-            Maximum step size (0 = automatic)
+-            When using pulses, change to half the thinest pulse otherwise it
+-            may be skipped.
+-
+-        min_step : float, default=0
+-            Minimum step size (0 = automatic)
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Integrator.options.fset(self, new_options)
+-
+-
+-Solver.add_integrator(IntegratorScipyBDF, 'bdf')
+-Solver.add_integrator(IntegratorScipyAdams, 'adams')
+-Solver.add_integrator(IntegratorScipyDop853, 'dop853')
+-Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
++"""ODE integrator from scipy."""
++
++__all__ = [
++    'IntegratorScipyAdams',
++    'IntegratorScipyBDF',
++    'IntegratorScipyDop853',
++    'IntegratorScipylsoda',
++]
++
++import numpy as np
++from scipy.integrate import ode
++from scipy.integrate._ode import zvode
++from qutip.core import data as _data
++from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
++from ..integrator import IntegratorException, Integrator
++from ..solver_base import Solver
++import warnings
++
++
++class IntegratorScipyAdams(Integrator):
++    """
++    Integrator using Scipy `ode` with zvode integrator using adams method.
++    Ordinary Differential Equation solver by netlib
++    (http://www.netlib.org/odepack).
++
++    Usable with ``method="adams"``
++    """
++    integrator_options = {
++        'atol': 1e-8,
++        'rtol': 1e-6,
++        'nsteps': 2500,
++        'order': 12,
++        'first_step': 0,
++        'max_step': 0,
++        'min_step': 0,
++    }
++    support_time_dependant = True
++    supports_blackbox = True
++    method = 'adams'
++
++    class _zvode(zvode):
++        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
++        def step(self, *args):
++            itask = self.call_args[2]
++            self.rwork[0] = args[4]
++            self.call_args[2] = 5
++            r = self.run(*args)
++            self.call_args[2] = itask
++            return r
++
++    def _prepare(self):
++        """
++        Initialize the solver
++        """
++        self._ode_solver = ode(self._mul_np_vec)
++        self._ode_solver.set_integrator('zvode')
++        self._ode_solver._integrator = self._zvode(
++            method=self.method,
++            **self.options,
++        )
++        self.name = "scipy zvode " + self.method
++
++    def _mul_np_vec(self, t, vec):
++        """
++        Interface between scipy which use numpy and the driver, which use data.
++        """
++        state = _data.dense.fast_from_numpy(vec)
++        column_unstack_dense(state, self._size, inplace=True)
++        out = self.system.matmul_data(t, state)
++        column_stack_dense(out, inplace=True)
++        return out.as_ndarray().ravel()
++
++    def set_state(self, t, state0):
++        self._is_set = True
++        self._back = t
++        self._front = t
++        self._mat_state = state0.shape[1] > 1
++        self._size = state0.shape[0]
++        if self._mat_state:
++            state0 = _data.column_stack(state0)
++        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
++
++    def get_state(self, copy=True):
++        if not self._is_set:
++            raise IntegratorException("The state is not initialted")
++        self._check_failed_integration()
++        t = self._ode_solver.t
++        if self._mat_state:
++            state = _data.column_unstack_dense(
++                _data.dense.Dense(self._ode_solver._y, copy=copy),
++                self._size,
++                inplace=True)
++        else:
++            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
++        return t, state
++
++    def _check_handle(self):
++        """
++        Do the check for concurrent use of the integrator and reset if used
++        elsewhere.
++        """
++        integrator = self._ode_solver._integrator
++        if integrator.initialized:
++            if integrator.handle != integrator.__class__.active_global_handle:
++                integrator.reset(len(self._ode_solver._y), False)
++
++    def integrate(self, t, copy=True):
++        self._check_handle()
++        if t != self._ode_solver.t:
++            self._ode_solver.integrate(t)
++        return self.get_state(copy)
++
++    def mcstep(self, t, copy=True):
++        # When working with mcstep, we use the dense output feature:
++        # a range in which the state at any time can be computed with
++        # minimal work. We keep track of the range with _back and _front.
++        self._check_handle()
++        if self._ode_solver.t == t:
++            # Exact same `t` as the last call, nothing to do.
++            pass
++        elif self._back > t:
++            # `t` before the range: not supported.
++            raise IntegratorException(
++                f"`t`={t} is behind the integration limit: "
++                f"{t} < {self._back}."
++            )
++        elif t <= self._front:
++            # In the range, ask for the new state.
++            self._ode_solver.integrate(t)
++        elif self._ode_solver.t < self._front:
++            # `t` after the range but last call (`t_prev`) not at the front.
++            # Advancing the range would make the interval `t_prev`..`_front`
++            # unreachable. Thus advance to _front.
++            self._ode_solver.integrate(self._front)
++        else:
++            # Advance the range.
++            self._back = self._front
++            self._ode_solver.integrate(t, step=True)
++            self._front = self._ode_solver._integrator.rwork[12]
++
++        return self.get_state(copy)
++
++    def _check_failed_integration(self):
++        if self._ode_solver.successful():
++            return
++        messages = {
++            -1: 'Excess work done on this call. Try to increasing '
++                'the nsteps parameter in the Options class',
++            -2: 'Excess accuracy requested. (Tolerances too small.)',
++            -3: 'Illegal input detected.',
++            -4: 'Repeated error test failures. (Check all input.)',
++            -5: 'Repeated convergence failures. (Perhaps bad'
++                ' Jacobian supplied or wrong choice of MF or tolerances.)',
++            -6: 'Error weight became zero during problem. (Solution'
++                ' component i vanished, and ATOL or ATOL(i) = 0.)'
++        }
++        raise IntegratorException(
++            messages[self._ode_solver._integrator.istate]
++        )
++
++    @property
++    def options(self):
++        """
++        Supported options by zvode integrator:
++
++        atol : float, default=1e-8
++            Absolute tolerance.
++
++        rtol : float, default=1e-6
++            Relative tolerance.
++
++        order : int, default=12, 'adams' or 5, 'bdf'
++            Order of integrator <=12 'adams', <=5 'bdf'
++
++        nsteps : int, default=2500
++            Max. number of internal steps/call.
++
++        first_step : float, default=0
++            Size of initial step (0 = automatic).
++
++        min_step : float, default=0
++            Minimum step size (0 = automatic).
++
++        max_step : float, default=0
++            Maximum step size (0 = automatic)
++            When using pulses, change to half the thinest pulse otherwise it
++            may be skipped.
++    """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Integrator.options.fset(self, new_options)
++
++
++class IntegratorScipyBDF(IntegratorScipyAdams):
++    """
++    Integrator using Scipy `ode` with zvode integrator using bdf method.
++    Ordinary Differential Equation solver by netlib
++    (http://www.netlib.org/odepack).
++
++    Usable with ``method="bdf"``
++    """
++    method = 'bdf'
++    integrator_options = {
++        'atol': 1e-8,
++        'rtol': 1e-6,
++        'nsteps': 2500,
++        'order': 5,
++        'first_step': 0,
++        'max_step': 0,
++        'min_step': 0,
++    }
++
++
++class IntegratorScipyDop853(Integrator):
++    """
++    Integrator using Scipy `ode` with dop853 integrator. Eight order
++    runge-kutta method by Dormand & Prince. Use fortran implementation
++    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
++    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
++    Computational Mathematics, Springer-Verlag (1993)].
++
++    Usable with ``method="dop853"``
++    """
++    integrator_options = {
++        'atol': 1e-8,
++        'rtol': 1e-6,
++        'nsteps': 2500,
++        'first_step': 0,
++        'max_step': 0,
++        'ifactor': 6.0,
++        'dfactor': 0.3,
++        'beta': 0.0,
++    }
++    support_time_dependant = True
++    supports_blackbox = True
++    method = 'dop853'
++
++    def _prepare(self):
++        """
++        Initialize the solver
++        """
++        self._ode_solver = ode(self._mul_np_vec)
++        self._ode_solver.set_integrator('dop853', **self.options)
++        self.name = "scipy ode dop853"
++
++    def _mul_np_vec(self, t, vec):
++        """
++        Interface between scipy which use numpy and the driver, which use data.
++        """
++        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
++        column_unstack_dense(state, self._size, inplace=True)
++        out = self.system.matmul_data(t, state)
++        column_stack_dense(out, inplace=True)
++        return out.as_ndarray().ravel().view(np.float64)
++
++    def integrate(self, t, copy=True):
++        if t != self._ode_solver.t:
++            self._ode_solver.integrate(t)
++        return self.get_state(copy)
++
++    def mcstep(self, t, copy=True):
++        if self._ode_solver.t <= t:
++            # Scipy's DOP853 does not have a step function.
++            # It has a safe step length, but can be 0 if unknown.
++            dt = self._ode_solver._integrator.work[6]
++            if dt:
++                t = min(self._ode_solver.t + dt, t)
++            self._ode_solver.integrate(t)
++        else:
++            # While DOP853 support changing the direction of the integration,
++            # it does not do so efficiently. We do it manually.
++            self._ode_solver._integrator.work[6] *= -1
++            self._ode_solver.integrate(t)
++            self._ode_solver._integrator.work[6] *= -1
++        return self.get_state(copy)
++
++    def get_state(self, copy=True):
++        if not self._is_set:
++            raise IntegratorException("The state is not initialted")
++        self._check_failed_integration()
++        t = self._ode_solver.t
++        if self._mat_state:
++            state = _data.column_unstack_dense(
++                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
++                                  copy=copy),
++                self._size,
++                inplace=True)
++        else:
++            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
++                                      copy=copy)
++        return t, state
++
++    def set_state(self, t, state0):
++        self._is_set = True
++        self._mat_state = state0.shape[1] > 1
++        self._size = state0.shape[0]
++        if self._mat_state:
++            state0 = _data.column_stack(state0)
++        self._ode_solver.set_initial_value(
++            state0.to_array().ravel().view(np.float64),
++            t
++        )
++
++    def _check_failed_integration(self):
++        if self._ode_solver.successful():
++            return
++        messages = {
++            -1: 'input is not consistent',
++            -2: 'larger nsteps is needed, Try to increase the nsteps '
++                'parameter in the Options class.',
++            -3: 'step size becomes too small. Try increasing tolerance',
++            -4: 'problem is probably stiff (interrupted), try "bdf" '
++                'method instead',
++        }
++        raise IntegratorException(
++            messages[self._ode_solver._integrator.istate]
++        )
++
++    @property
++    def options(self):
++        """
++        Supported options by dop853 integrator:
++
++        atol : float, default=1e-8
++            Absolute tolerance.
++
++        rtol : float, default=1e-6
++            Relative tolerance.
++
++        nsteps : int, default=2500
++            Max. number of internal steps/call.
++
++        first_step : float, default=0
++            Size of initial step (0 = automatic).
++
++        max_step : float, default=0
++            Maximum step size (0 = automatic)
++
++        ifactor, dfactor : float, default=6., 0.3
++            Maximum factor to increase/decrease step size by in one step
++
++        beta : float, default=0
++            Beta parameter for stabilised step size control.
++
++        See scipy.integrate.ode ode for more detail
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Integrator.options.fset(self, new_options)
++
++
++class IntegratorScipylsoda(IntegratorScipyDop853):
++    """
++    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
++    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
++    'BDF' methods to solve both stiff and non-stiff systems.
++
++    Usable with ``method="lsoda"``
++    """
++    integrator_options = {
++        'atol': 1e-8,
++        'rtol': 1e-6,
++        'nsteps': 2500,
++        'max_order_ns': 12,
++        'max_order_s': 5,
++        'first_step': 0.0,
++        'max_step': 0.0,
++        'min_step': 0.0,
++    }
++    support_time_dependant = True
++    supports_blackbox = True
++    method = 'lsoda'
++
++    def _prepare(self):
++        """
++        Initialize the solver
++        """
++        self._ode_solver = ode(self._mul_np_vec)
++        self._ode_solver.set_integrator('lsoda', **self.options)
++        self.name = "scipy lsoda"
++
++    def _check_handle(self):
++        """
++        Do the check for concurrent use of the integrator and reset if used
++        elsewhere.
++        """
++        integrator = self._ode_solver._integrator
++        if integrator.initialized:
++            if integrator.handle != integrator.__class__.active_global_handle:
++                integrator.reset(len(self._ode_solver._y), False)
++
++    def integrate(self, t, copy=True):
++        self._check_handle()
++        return super().integrate(t, copy)
++
++    def set_state(self, t, state0):
++        self._front = t
++        super().set_state(t, state0)
++        self._back = self.get_state()
++
++    def mcstep(self, t, copy=True):
++        # This solver support dense output:
++        # a range in which the state at any time can be computed with
++        # minimal work. We keep track of the range with _back[0] and _front.
++        self._check_handle()
++        if self._ode_solver.t == t:
++            # Exact same `t` as the last call, nothing to do.
++            pass
++        elif self._back[0] <= t <= self._front:
++            # In the range, ask for the new state.
++            self._backstep(t)
++        elif self._front < t:
++            # Advance the range.
++            self._one_step(t)
++        else:
++            raise IntegratorException(
++                f"`t`={t} is behind the integration limit: "
++                f"{t} < {self._back[0]}."
++            )
++        return self.get_state(copy)
++
++    def _one_step(self, t):
++        """
++        Advance up to t by one internal solver step.
++        Should be able to retreive the state at any time between the present
++        time and the resulting time using `backstep`.
++        """
++        # Here we want to advance up to t doing maximum one step.
++        # lsoda officially support step, but sometime it does more work than
++        # needed, so we ask it to advance a fraction of the last step, where it
++        # will advance one internal step of length allowed by the tolerance and
++        # interpolate back to the asked time, effictively getting the single
++        # integration step we want. The first step and abrupt changes in the
++        # `rhs` can cause exceptions to this, but _backstep catch those cases.
++        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
++        t_ode = self._ode_solver.t
++
++        if t > self._front and t_ode >= self._front:
++            # The state is at self._front, do a step
++            self._back = self.get_state()
++            self._ode_solver.integrate(min(self._front + safe_delta, t))
++            self._front = self._ode_solver._integrator.rwork[12]
++            # We asked for a fraction of a step, now complete it.
++            self._ode_solver.integrate(min(self._front, t))
++        elif t > self._front:
++            # The state is at a time before t_front, advance to t_front
++            self._ode_solver.integrate(self._front)
++
++    def _backstep(self, t):
++        """
++        Retreive the state at time t, with t smaller than present ODE time.
++        The time t will always be between the last calls of `one_step`.
++        return the pair t, state.
++        """
++        delta = self._ode_solver._integrator.rwork[11]
++        if t == self._ode_solver.t:
++            pass
++        elif self._front - delta <= t:
++            self._ode_solver.integrate(t)
++        else:
++            self.set_state(*self._back)
++            self._ode_solver.integrate(t)
++
++    def _check_failed_integration(self):
++        if self._ode_solver.successful():
++            return
++        messages = {
++            -1: "Excess work done on this call."
++                "Try to increase the nsteps parameter in the Options class.",
++            -2: "Excess accuracy requested (tolerances too small).",
++            -3: "Illegal input detected (internal error).",
++            -4: "Repeated error test failures (internal error).",
++            -5: "Repeated convergence failures "
++                "(perhaps bad Jacobian or tolerances).",
++            -6: "Error weight became zero during problem.",
++            -7: "Internal workspace insufficient to finish (internal error)."
++        }
++        raise IntegratorException(
++            messages[self._ode_solver._integrator.istate]
++        )
++
++    @property
++    def options(self):
++        """
++        Supported options by lsoda integrator:
++
++        atol : float, default=1e-8
++            Absolute tolerance.
++
++        rtol : float, default=1e-6
++            Relative tolerance.
++
++        nsteps : int, default=2500
++            Max. number of internal steps/call.
++
++        max_order_ns : int, default=12
++            Maximum order used in the nonstiff case (<= 12).
++
++        max_order_s : int, default=5
++            Maximum order used in the stiff case (<= 5).
++
++        first_step : float, default=0
++            Size of initial step (0 = automatic).
++
++        max_step : float, default=0
++            Maximum step size (0 = automatic)
++            When using pulses, change to half the thinest pulse otherwise it
++            may be skipped.
++
++        min_step : float, default=0
++            Minimum step size (0 = automatic)
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Integrator.options.fset(self, new_options)
++
++
++Solver.add_integrator(IntegratorScipyBDF, 'bdf')
++Solver.add_integrator(IntegratorScipyAdams, 'adams')
++Solver.add_integrator(IntegratorScipyDop853, 'dop853')
++Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
+diff --git a/qutip/solver/integrator/verner7efficient.py b/qutip/solver/integrator/verner7efficient.py
+index c49882a2..3bda6a91 100644
+--- a/qutip/solver/integrator/verner7efficient.py
++++ b/qutip/solver/integrator/verner7efficient.py
+@@ -1,333 +1,333 @@
+-"""
+-Provide a cython implimentation verner 'most-efficient'
+-order 7 runge-Kutta method.
+-See http://people.math.sfu.ca/~jverner/
+-"""
+-# Verner 7 Efficient
+-# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
+-__all__ = ["vern7_coeff"]
+-import numpy as np
+-order = 7
+-rk_step = 10
+-rk_extra_step = 16
+-denseout_order = 7
+-
+-bh = np.zeros(rk_step, dtype=np.float64)
+-a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
+-b = np.zeros(rk_step, dtype=np.float64)
+-c = np.zeros(rk_extra_step, dtype=np.float64)
+-e = np.zeros(rk_step, dtype=np.float64)
+-bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
+-
+-c[0] = 0.
+-c[1] = .5000000000000000000000000000000000000000e-2
+-c[2] = .1088888888888888888888888888888888888889
+-c[3] = .1633333333333333333333333333333333333333
+-c[4] = .4555000000000000000000000000000000000000
+-c[5] = .6095094489978381317087004421486024949638
+-c[6] = .8840000000000000000000000000000000000000
+-c[7] = .9250000000000000000000000000000000000000
+-c[8] = 1.
+-c[9] = 1.
+-
+-a[1, 0] = .5000000000000000000000000000000000000000e-2
+-
+-a[2, 0] = -1.076790123456790123456790123456790123457
+-a[2, 1] = 1.185679012345679012345679012345679012346
+-
+-a[3, 0] = .4083333333333333333333333333333333333333e-1
+-a[3, 1] = 0.
+-a[3, 2] = .1225000000000000000000000000000000000000
+-
+-a[4, 0] = .6389139236255726780508121615993336109954
+-a[4, 1] = 0.
+-a[4, 2] = -2.455672638223656809662640566430653894211
+-a[4, 3] = 2.272258714598084131611828404831320283215
+-
+-a[5, 0] = -2.661577375018757131119259297861818119279
+-a[5, 1] = 0.
+-a[5, 2] = 10.80451388645613769565396655365532838482
+-a[5, 3] = -8.353914657396199411968048547819291691541
+-a[5, 4] = .8204875949566569791420417341743839209619
+-
+-a[6, 0] = 6.067741434696770992718360183877276714679
+-a[6, 1] = 0.
+-a[6, 2] = -24.71127363591108579734203485290746001803
+-a[6, 3] = 20.42751793078889394045773111748346612697
+-a[6, 4] = -1.906157978816647150624096784352757010879
+-a[6, 5] = 1.006172249242068014790040335899474187268
+-
+-a[7, 0] = 12.05467007625320299509109452892778311648
+-a[7, 1] = 0.
+-a[7, 2] = -49.75478495046898932807257615331444758322
+-a[7, 3] = 41.14288863860467663259698416710157354209
+-a[7, 4] = -4.461760149974004185641911603484815375051
+-a[7, 5] = 2.042334822239174959821717077708608543738
+-a[7, 6] = -0.9834843665406107379530801693870224403537e-1
+-
+-a[8, 0] = 10.13814652288180787641845141981689030769
+-a[8, 1] = 0.
+-a[8, 2] = -42.64113603171750214622846006736635730625
+-a[8, 3] = 35.76384003992257007135021178023160054034
+-a[8, 4] = -4.348022840392907653340370296908245943710
+-a[8, 5] = 2.009862268377035895441943593011827554771
+-a[8, 6] = .3487490460338272405953822853053145879140
+-a[8, 7] = -.2714390051048312842371587140910297407572
+-
+-a[9, 0] = -45.03007203429867712435322405073769635151
+-a[9, 1] = 0.
+-a[9, 2] = 187.3272437654588840752418206154201997384
+-a[9, 3] = -154.0288236935018690596728621034510402582
+-a[9, 4] = 18.56465306347536233859492332958439136765
+-a[9, 5] = -7.141809679295078854925420496823551192821
+-a[9, 6] = 1.308808578161378625114762706007696696508
+-a[9, 7] = 0.
+-a[9, 8] = 0.
+-
+-b[0] = .4715561848627222170431765108838175679569e-1
+-b[1] = 0.
+-b[2] = 0.
+-b[3] = .2575056429843415189596436101037687580986
+-b[4] = .2621665397741262047713863095764527711129
+-b[5] = .1521609265673855740323133199165117535523
+-b[6] = .4939969170032484246907175893227876844296
+-b[7] = -.2943031171403250441557244744092703429139
+-b[8] = .8131747232495109999734599440136761892478e-1
+-b[9] = 0.
+-
+-bh[0] = .4460860660634117628731817597479197781432e-1
+-bh[1] = 0.
+-bh[2] = 0.
+-bh[3] = .2671640378571372680509102260943837899738
+-bh[4] = .2201018300177293019979715776650753096323
+-bh[5] = .2188431703143156830983120833512893824578
+-bh[6] = .2289871705411202883378173889763552365362
+-bh[7] = 0.
+-bh[8] = 0.
+-bh[9] = .2029518466335628222767054793810430358554e-1
+-
+-for i in range(10):
+-    e[i] = b[i] - bh[i]
+-
+-c[10] = 1
+-
+-a[10, 0] = .4715561848627222170431765108838175679569e-1
+-a[10, 1] = 0.
+-a[10, 2] = 0.
+-a[10, 3] = .2575056429843415189596436101037687580986
+-a[10, 4] = .2621665397741262047713863095764527711129
+-a[10, 5] = .1521609265673855740323133199165117535523
+-a[10, 6] = .4939969170032484246907175893227876844296
+-a[10, 7] = -.2943031171403250441557244744092703429139
+-a[10, 8] = .8131747232495109999734599440136761892478e-1
+-a[10, 9] = 0.
+-
+-c[11] = 29/100
+-
+-a[11, 0] = .5232227691599689815470932256735029887614e-1
+-a[11, 1] = 0.
+-a[11, 2] = 0.
+-a[11, 3] = .2249586182670571550244187743667190903405
+-a[11, 4] = .1744370924877637539031751304611402542578e-1
+-a[11, 5] = -.7669379876829393188009028209348812321417e-2
+-a[11, 6] = .3435896044073284645684381456417912794447e-1
+-a[11, 7] = -.4102097230093949839125144540100346681769e-1
+-a[11, 8] = .2565113300520561655297104906598973655221e-1
+-a[11, 9] = 0.
+-a[11, 10] = -.1604434570000000000000000000000000000000e-1
+-
+-c[12] = 1/8
+-
+-a[12, 0] = .5305334125785908638834747243817578898946e-1
+-a[12, 1] = 0.
+-a[12, 2] = 0.
+-a[12, 3] = .1219530101140188607092225622195251463666
+-a[12, 4] = .1774684073760249704011573985936092552347e-1
+-a[12, 5] = -.5928372667681494328907467430302313286925e-3
+-a[12, 6] = .8381833970853750873624781948796072714855e-2
+-a[12, 7] = -.1293369259698611956700998079778496462996e-1
+-a[12, 8] = .9412056815253860804791356641605087829772e-2
+-a[12, 9] = 0.
+-a[12, 10] = -.5353253107275676032399320754008272222345e-2
+-a[12, 11] = -.6666729992455811078380186481263955324311e-1
+-
+-c[13] = 1/4
+-
+-a[13, 0] = .3887903257436303686399931060834951327899e-1
+-a[13, 1] = 0.
+-a[13, 2] = 0.
+-a[13, 3] = -.2440320330830131517910045090190069290791e-2
+-a[13, 4] = -.1392891721467262281273220992320214734208e-2
+-a[13, 5] = -.4744629155868013465038358934145339168472e-3
+-a[13, 6] = .3920793241315951369383517310870803393356e-3
+-a[13, 7] = -.4055473328512800136385880031750264996936e-3
+-a[13, 8] = .1989709314771672628794304728258886009267e-3
+-a[13, 9] = 0.
+-a[13, 10] = -.1027819879317916884712606136811051029682e-3
+-a[13, 11] = .3385661513870266715302548402957613704604e-1
+-a[13, 12] = .1814893063199928004309543737509423302792
+-
+-c[14] = 53/100
+-
+-a[14, 0] = .5723681204690012909606837582140921695189e-1
+-a[14, 1] = 0.
+-a[14, 2] = 0.
+-a[14, 3] = .2226594806676118099285816235023183680020
+-a[14, 4] = .1234486420018689904911221497830317287757
+-a[14, 5] = .4006332526666490875113688731927762275433e-1
+-a[14, 6] = -.5269894848581452066926326838943832327366e-1
+-a[14, 7] = .4765971214244522856887315416093212596338e-1
+-a[14, 8] = -.2138895885042213036387863538386958914368e-1
+-a[14, 9] = 0.
+-a[14, 10] = .1519389106403640165459624646184297766866e-1
+-a[14, 11] = .1206054671628965554251364472502413614358
+-a[14, 12] = -.2277942301618737288237298052574548913451e-1
+-a[14, 13] = 0.
+-
+-c[15] = 79/100
+-
+-a[15, 0] = .5137203880275681426595607279552927584506e-1
+-a[15, 1] = 0.
+-a[15, 2] = 0.
+-a[15, 3] = .5414214473439405582401399378307410450482
+-a[15, 4] = .3503998066921840081154745647747846804810
+-a[15, 5] = .1419311226969218216861835872156617148040
+-a[15, 6] = .1052737747842942254816302629823570359198
+-a[15, 7] = -.3108184780587401700842726199589213259835e-1
+-a[15, 8] = -.7401883149519145061791854716430279714483e-2
+-a[15, 9] = 0.
+-a[15, 10] = -.6377932504865363437569726480040013149706e-2
+-a[15, 11] = -.1732549590836186403386348310205265959935
+-a[15, 12] = -.1822815677762202619429607513861847306420
+-a[15, 13] = 0.
+-a[15, 14] = 0.
+-
+-bi[0, 0] = 1.
+-bi[0, 1] = -8.413387198332767469319987751201351965810
+-bi[0, 2] = 33.67550888449089654479469983556967202215
+-bi[0, 3] = -70.80159089484886164618905961010838757357
+-bi[0, 4] = 80.64695108301297872968868805293298389704
+-bi[0, 5] = -47.19413969837521580145883430419406103536
+-bi[0, 6] = 11.13381344253924186418881142808952641234
+-
+-bi[1, 0] = 0.
+-bi[1, 1] = 0.
+-bi[1, 2] = 0.
+-bi[1, 3] = 0.
+-bi[1, 4] = 0.
+-bi[1, 5] = 0.
+-bi[1, 6] = 0.
+-
+-bi[2, 0] = 0.
+-bi[2, 1] = 0.
+-bi[2, 2] = 0.
+-bi[2, 3] = 0.
+-bi[2, 4] = 0.
+-bi[2, 5] = 0.
+-bi[2, 6] = 0.
+-
+-bi[3, 0] = 0.
+-bi[3, 1] = 8.754921980674397160629587282876763437696
+-bi[3, 2] = -88.45968286997709426134300934922618655402
+-bi[3, 3] = 346.9017638429916309499891288356321692825
+-bi[3, 4] = -629.2580030059837046812187141184986252218
+-bi[3, 5] = 529.6773755604192983874116479833480529304
+-bi[3, 6] = -167.3588698651401860365089970240284051167
+-
+-bi[4, 0] = 0.
+-bi[4, 1] = 8.913387586637921662996190126913331844214
+-bi[4, 2] = -90.06081846893217794712014609702916991513
+-bi[4, 3] = 353.1807459217057824951538014683541349020
+-bi[4, 4] = -640.6476819744374433668701027882567716886
+-bi[4, 5] = 539.2646279047155261551781390920363285084
+-bi[4, 6] = -170.3880944299154827945664954924414008798
+-
+-bi[5, 0] = 0.
+-bi[5, 1] = 5.173312029847800338889849068990984974299
+-bi[5, 2] = -52.27111590005538823385270070373176751689
+-bi[5, 3] = 204.9853867374073094711024260808085419491
+-bi[5, 4] = -371.8306118563602890875634623992262437796
+-bi[5, 5] = 312.9880934374529000210073972654145891826
+-bi[5, 6] = -98.89290352172494693555119599233959305606
+-
+-bi[6, 0] = 0.
+-bi[6, 1] = 16.79537744079695986364946329034055578253
+-bi[6, 2] = -169.7004000005972744435739149730966805754
+-bi[6, 3] = 665.4937727009246303131700313781960584913
+-bi[6, 4] = -1207.163889233600728395392916633015853882
+-bi[6, 5] = 1016.129151581854603280159105697386989470
+-bi[6, 6] = -321.0600155723749421933210511704882816019
+-
+-bi[7, 0] = 0.
+-bi[7, 1] = -10.00599753609866476866352971232058330270
+-bi[7, 2] = 101.1005433052275068199636113246449312792
+-bi[7, 3] = -396.4739151237843754958939772727577263768
+-bi[7, 4] = 719.1787707014182914108130834128646525498
+-bi[7, 5] = -605.3681033918824350795711030652978269725
+-bi[7, 6] = 191.2743989279793520691961908384572824802
+-
+-bi[8, 0] = 0.
+-bi[8, 1] = 2.764708833638599139713222853969606774131
+-bi[8, 2] = -27.93460263739046178114640484830267988046
+-bi[8, 3] = 109.5477918613789217803046856340175757800
+-bi[8, 4] = -198.7128113064482116421691972646370773711
+-bi[8, 5] = 167.2663357164031670694252647113936863857
+-bi[8, 6] = -52.85010499525706346613022509203974406942
+-
+-bi[9, 0] = 0.
+-bi[9, 1] = 0.
+-bi[9, 2] = 0.
+-bi[9, 3] = 0.
+-bi[9, 4] = 0.
+-bi[9, 5] = 0.
+-bi[9, 6] = 0.
+-
+-bi[10, 0] = 0.
+-bi[10, 1] = -2.169632028016350481156919876642428429100
+-bi[10, 2] = 22.01669603756987625585768587320929912766
+-bi[10, 3] = -86.90152427798948350846176288615482496306
+-bi[10, 4] = 159.2238897386147443720253338471077193471
+-bi[10, 5] = -135.9618306534587908363115231453760181702
+-bi[10, 6] = 43.79240118328000419804718618785625308759
+-
+-bi[11, 0] = 0.
+-bi[11, 1] = -4.890070188793803933769786966428026149549
+-bi[11, 2] = 22.75407737425176120799532459991506803585
+-bi[11, 3] = -30.78034218537730965082079824005797506535
+-bi[11, 4] = -2.797194317207249021142015125037024035537
+-bi[11, 5] = 31.36945663750840183161406140272783187147
+-bi[11, 6] = -15.65592732038180043387678567111987465689
+-
+-bi[12, 0] = 0.
+-bi[12, 1] = 10.86217092955196715517224349929627754387
+-bi[12, 2] = -50.54297141782710697188187875653305700081
+-bi[12, 3] = 68.37148040407511827604242008548181691494
+-bi[12, 4] = 6.213326521632409162585500428935637861213
+-bi[12, 5] = -69.68006323194158104163196358466588618336
+-bi[12, 6] = 34.77605679450919341971367832748521086414
+-
+-bi[13, 0] = 0.
+-bi[13, 1] = -11.37286691922922915922346687401389055763
+-bi[13, 2] = 130.7905807824671644130452602841032046030
+-bi[13, 3] = -488.6511367778560207543260583489312609826
+-bi[13, 4] = 832.2148793276440873476229585070779183432
+-bi[13, 5] = -664.7743368554426242883314487337054193624
+-bi[13, 6] = 201.7928804424166224412127551654694479565
+-
+-bi[14, 0] = 0.
+-bi[14, 1] = -5.919778732715006698693070786679427540601
+-bi[14, 2] = 63.27679965889218829298274978013773800731
+-bi[14, 3] = -265.4326820887379575820873554556433306580
+-bi[14, 4] = 520.1009254140610824835871087519714692468
+-bi[14, 5] = -467.4121095339020118993777963241667608460
+-bi[14, 6] = 155.3868452824017054035883640343803117904
+-
+-bi[15, 0] = 0.
+-bi[15, 1] = -10.49214619796182281022379415510181241136
+-bi[15, 2] = 105.3553852518801101042787230303396283676
+-bi[15, 3] = -409.4397501198893846479834816688367917005
+-bi[15, 4] = 732.8314489076540326880337353277812147333
+-bi[15, 5] = -606.3044574733512377981129469949015057785
+-bi[15, 6] = 188.0495196316683024640077644607192667895
+-
+-vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
++"""
++Provide a cython implimentation verner 'most-efficient'
++order 7 runge-Kutta method.
++See http://people.math.sfu.ca/~jverner/
++"""
++# Verner 7 Efficient
++# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
++__all__ = ["vern7_coeff"]
++import numpy as np
++order = 7
++rk_step = 10
++rk_extra_step = 16
++denseout_order = 7
++
++bh = np.zeros(rk_step, dtype=np.float64)
++a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
++b = np.zeros(rk_step, dtype=np.float64)
++c = np.zeros(rk_extra_step, dtype=np.float64)
++e = np.zeros(rk_step, dtype=np.float64)
++bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
++
++c[0] = 0.
++c[1] = .5000000000000000000000000000000000000000e-2
++c[2] = .1088888888888888888888888888888888888889
++c[3] = .1633333333333333333333333333333333333333
++c[4] = .4555000000000000000000000000000000000000
++c[5] = .6095094489978381317087004421486024949638
++c[6] = .8840000000000000000000000000000000000000
++c[7] = .9250000000000000000000000000000000000000
++c[8] = 1.
++c[9] = 1.
++
++a[1, 0] = .5000000000000000000000000000000000000000e-2
++
++a[2, 0] = -1.076790123456790123456790123456790123457
++a[2, 1] = 1.185679012345679012345679012345679012346
++
++a[3, 0] = .4083333333333333333333333333333333333333e-1
++a[3, 1] = 0.
++a[3, 2] = .1225000000000000000000000000000000000000
++
++a[4, 0] = .6389139236255726780508121615993336109954
++a[4, 1] = 0.
++a[4, 2] = -2.455672638223656809662640566430653894211
++a[4, 3] = 2.272258714598084131611828404831320283215
++
++a[5, 0] = -2.661577375018757131119259297861818119279
++a[5, 1] = 0.
++a[5, 2] = 10.80451388645613769565396655365532838482
++a[5, 3] = -8.353914657396199411968048547819291691541
++a[5, 4] = .8204875949566569791420417341743839209619
++
++a[6, 0] = 6.067741434696770992718360183877276714679
++a[6, 1] = 0.
++a[6, 2] = -24.71127363591108579734203485290746001803
++a[6, 3] = 20.42751793078889394045773111748346612697
++a[6, 4] = -1.906157978816647150624096784352757010879
++a[6, 5] = 1.006172249242068014790040335899474187268
++
++a[7, 0] = 12.05467007625320299509109452892778311648
++a[7, 1] = 0.
++a[7, 2] = -49.75478495046898932807257615331444758322
++a[7, 3] = 41.14288863860467663259698416710157354209
++a[7, 4] = -4.461760149974004185641911603484815375051
++a[7, 5] = 2.042334822239174959821717077708608543738
++a[7, 6] = -0.9834843665406107379530801693870224403537e-1
++
++a[8, 0] = 10.13814652288180787641845141981689030769
++a[8, 1] = 0.
++a[8, 2] = -42.64113603171750214622846006736635730625
++a[8, 3] = 35.76384003992257007135021178023160054034
++a[8, 4] = -4.348022840392907653340370296908245943710
++a[8, 5] = 2.009862268377035895441943593011827554771
++a[8, 6] = .3487490460338272405953822853053145879140
++a[8, 7] = -.2714390051048312842371587140910297407572
++
++a[9, 0] = -45.03007203429867712435322405073769635151
++a[9, 1] = 0.
++a[9, 2] = 187.3272437654588840752418206154201997384
++a[9, 3] = -154.0288236935018690596728621034510402582
++a[9, 4] = 18.56465306347536233859492332958439136765
++a[9, 5] = -7.141809679295078854925420496823551192821
++a[9, 6] = 1.308808578161378625114762706007696696508
++a[9, 7] = 0.
++a[9, 8] = 0.
++
++b[0] = .4715561848627222170431765108838175679569e-1
++b[1] = 0.
++b[2] = 0.
++b[3] = .2575056429843415189596436101037687580986
++b[4] = .2621665397741262047713863095764527711129
++b[5] = .1521609265673855740323133199165117535523
++b[6] = .4939969170032484246907175893227876844296
++b[7] = -.2943031171403250441557244744092703429139
++b[8] = .8131747232495109999734599440136761892478e-1
++b[9] = 0.
++
++bh[0] = .4460860660634117628731817597479197781432e-1
++bh[1] = 0.
++bh[2] = 0.
++bh[3] = .2671640378571372680509102260943837899738
++bh[4] = .2201018300177293019979715776650753096323
++bh[5] = .2188431703143156830983120833512893824578
++bh[6] = .2289871705411202883378173889763552365362
++bh[7] = 0.
++bh[8] = 0.
++bh[9] = .2029518466335628222767054793810430358554e-1
++
++for i in range(10):
++    e[i] = b[i] - bh[i]
++
++c[10] = 1
++
++a[10, 0] = .4715561848627222170431765108838175679569e-1
++a[10, 1] = 0.
++a[10, 2] = 0.
++a[10, 3] = .2575056429843415189596436101037687580986
++a[10, 4] = .2621665397741262047713863095764527711129
++a[10, 5] = .1521609265673855740323133199165117535523
++a[10, 6] = .4939969170032484246907175893227876844296
++a[10, 7] = -.2943031171403250441557244744092703429139
++a[10, 8] = .8131747232495109999734599440136761892478e-1
++a[10, 9] = 0.
++
++c[11] = 29/100
++
++a[11, 0] = .5232227691599689815470932256735029887614e-1
++a[11, 1] = 0.
++a[11, 2] = 0.
++a[11, 3] = .2249586182670571550244187743667190903405
++a[11, 4] = .1744370924877637539031751304611402542578e-1
++a[11, 5] = -.7669379876829393188009028209348812321417e-2
++a[11, 6] = .3435896044073284645684381456417912794447e-1
++a[11, 7] = -.4102097230093949839125144540100346681769e-1
++a[11, 8] = .2565113300520561655297104906598973655221e-1
++a[11, 9] = 0.
++a[11, 10] = -.1604434570000000000000000000000000000000e-1
++
++c[12] = 1/8
++
++a[12, 0] = .5305334125785908638834747243817578898946e-1
++a[12, 1] = 0.
++a[12, 2] = 0.
++a[12, 3] = .1219530101140188607092225622195251463666
++a[12, 4] = .1774684073760249704011573985936092552347e-1
++a[12, 5] = -.5928372667681494328907467430302313286925e-3
++a[12, 6] = .8381833970853750873624781948796072714855e-2
++a[12, 7] = -.1293369259698611956700998079778496462996e-1
++a[12, 8] = .9412056815253860804791356641605087829772e-2
++a[12, 9] = 0.
++a[12, 10] = -.5353253107275676032399320754008272222345e-2
++a[12, 11] = -.6666729992455811078380186481263955324311e-1
++
++c[13] = 1/4
++
++a[13, 0] = .3887903257436303686399931060834951327899e-1
++a[13, 1] = 0.
++a[13, 2] = 0.
++a[13, 3] = -.2440320330830131517910045090190069290791e-2
++a[13, 4] = -.1392891721467262281273220992320214734208e-2
++a[13, 5] = -.4744629155868013465038358934145339168472e-3
++a[13, 6] = .3920793241315951369383517310870803393356e-3
++a[13, 7] = -.4055473328512800136385880031750264996936e-3
++a[13, 8] = .1989709314771672628794304728258886009267e-3
++a[13, 9] = 0.
++a[13, 10] = -.1027819879317916884712606136811051029682e-3
++a[13, 11] = .3385661513870266715302548402957613704604e-1
++a[13, 12] = .1814893063199928004309543737509423302792
++
++c[14] = 53/100
++
++a[14, 0] = .5723681204690012909606837582140921695189e-1
++a[14, 1] = 0.
++a[14, 2] = 0.
++a[14, 3] = .2226594806676118099285816235023183680020
++a[14, 4] = .1234486420018689904911221497830317287757
++a[14, 5] = .4006332526666490875113688731927762275433e-1
++a[14, 6] = -.5269894848581452066926326838943832327366e-1
++a[14, 7] = .4765971214244522856887315416093212596338e-1
++a[14, 8] = -.2138895885042213036387863538386958914368e-1
++a[14, 9] = 0.
++a[14, 10] = .1519389106403640165459624646184297766866e-1
++a[14, 11] = .1206054671628965554251364472502413614358
++a[14, 12] = -.2277942301618737288237298052574548913451e-1
++a[14, 13] = 0.
++
++c[15] = 79/100
++
++a[15, 0] = .5137203880275681426595607279552927584506e-1
++a[15, 1] = 0.
++a[15, 2] = 0.
++a[15, 3] = .5414214473439405582401399378307410450482
++a[15, 4] = .3503998066921840081154745647747846804810
++a[15, 5] = .1419311226969218216861835872156617148040
++a[15, 6] = .1052737747842942254816302629823570359198
++a[15, 7] = -.3108184780587401700842726199589213259835e-1
++a[15, 8] = -.7401883149519145061791854716430279714483e-2
++a[15, 9] = 0.
++a[15, 10] = -.6377932504865363437569726480040013149706e-2
++a[15, 11] = -.1732549590836186403386348310205265959935
++a[15, 12] = -.1822815677762202619429607513861847306420
++a[15, 13] = 0.
++a[15, 14] = 0.
++
++bi[0, 0] = 1.
++bi[0, 1] = -8.413387198332767469319987751201351965810
++bi[0, 2] = 33.67550888449089654479469983556967202215
++bi[0, 3] = -70.80159089484886164618905961010838757357
++bi[0, 4] = 80.64695108301297872968868805293298389704
++bi[0, 5] = -47.19413969837521580145883430419406103536
++bi[0, 6] = 11.13381344253924186418881142808952641234
++
++bi[1, 0] = 0.
++bi[1, 1] = 0.
++bi[1, 2] = 0.
++bi[1, 3] = 0.
++bi[1, 4] = 0.
++bi[1, 5] = 0.
++bi[1, 6] = 0.
++
++bi[2, 0] = 0.
++bi[2, 1] = 0.
++bi[2, 2] = 0.
++bi[2, 3] = 0.
++bi[2, 4] = 0.
++bi[2, 5] = 0.
++bi[2, 6] = 0.
++
++bi[3, 0] = 0.
++bi[3, 1] = 8.754921980674397160629587282876763437696
++bi[3, 2] = -88.45968286997709426134300934922618655402
++bi[3, 3] = 346.9017638429916309499891288356321692825
++bi[3, 4] = -629.2580030059837046812187141184986252218
++bi[3, 5] = 529.6773755604192983874116479833480529304
++bi[3, 6] = -167.3588698651401860365089970240284051167
++
++bi[4, 0] = 0.
++bi[4, 1] = 8.913387586637921662996190126913331844214
++bi[4, 2] = -90.06081846893217794712014609702916991513
++bi[4, 3] = 353.1807459217057824951538014683541349020
++bi[4, 4] = -640.6476819744374433668701027882567716886
++bi[4, 5] = 539.2646279047155261551781390920363285084
++bi[4, 6] = -170.3880944299154827945664954924414008798
++
++bi[5, 0] = 0.
++bi[5, 1] = 5.173312029847800338889849068990984974299
++bi[5, 2] = -52.27111590005538823385270070373176751689
++bi[5, 3] = 204.9853867374073094711024260808085419491
++bi[5, 4] = -371.8306118563602890875634623992262437796
++bi[5, 5] = 312.9880934374529000210073972654145891826
++bi[5, 6] = -98.89290352172494693555119599233959305606
++
++bi[6, 0] = 0.
++bi[6, 1] = 16.79537744079695986364946329034055578253
++bi[6, 2] = -169.7004000005972744435739149730966805754
++bi[6, 3] = 665.4937727009246303131700313781960584913
++bi[6, 4] = -1207.163889233600728395392916633015853882
++bi[6, 5] = 1016.129151581854603280159105697386989470
++bi[6, 6] = -321.0600155723749421933210511704882816019
++
++bi[7, 0] = 0.
++bi[7, 1] = -10.00599753609866476866352971232058330270
++bi[7, 2] = 101.1005433052275068199636113246449312792
++bi[7, 3] = -396.4739151237843754958939772727577263768
++bi[7, 4] = 719.1787707014182914108130834128646525498
++bi[7, 5] = -605.3681033918824350795711030652978269725
++bi[7, 6] = 191.2743989279793520691961908384572824802
++
++bi[8, 0] = 0.
++bi[8, 1] = 2.764708833638599139713222853969606774131
++bi[8, 2] = -27.93460263739046178114640484830267988046
++bi[8, 3] = 109.5477918613789217803046856340175757800
++bi[8, 4] = -198.7128113064482116421691972646370773711
++bi[8, 5] = 167.2663357164031670694252647113936863857
++bi[8, 6] = -52.85010499525706346613022509203974406942
++
++bi[9, 0] = 0.
++bi[9, 1] = 0.
++bi[9, 2] = 0.
++bi[9, 3] = 0.
++bi[9, 4] = 0.
++bi[9, 5] = 0.
++bi[9, 6] = 0.
++
++bi[10, 0] = 0.
++bi[10, 1] = -2.169632028016350481156919876642428429100
++bi[10, 2] = 22.01669603756987625585768587320929912766
++bi[10, 3] = -86.90152427798948350846176288615482496306
++bi[10, 4] = 159.2238897386147443720253338471077193471
++bi[10, 5] = -135.9618306534587908363115231453760181702
++bi[10, 6] = 43.79240118328000419804718618785625308759
++
++bi[11, 0] = 0.
++bi[11, 1] = -4.890070188793803933769786966428026149549
++bi[11, 2] = 22.75407737425176120799532459991506803585
++bi[11, 3] = -30.78034218537730965082079824005797506535
++bi[11, 4] = -2.797194317207249021142015125037024035537
++bi[11, 5] = 31.36945663750840183161406140272783187147
++bi[11, 6] = -15.65592732038180043387678567111987465689
++
++bi[12, 0] = 0.
++bi[12, 1] = 10.86217092955196715517224349929627754387
++bi[12, 2] = -50.54297141782710697188187875653305700081
++bi[12, 3] = 68.37148040407511827604242008548181691494
++bi[12, 4] = 6.213326521632409162585500428935637861213
++bi[12, 5] = -69.68006323194158104163196358466588618336
++bi[12, 6] = 34.77605679450919341971367832748521086414
++
++bi[13, 0] = 0.
++bi[13, 1] = -11.37286691922922915922346687401389055763
++bi[13, 2] = 130.7905807824671644130452602841032046030
++bi[13, 3] = -488.6511367778560207543260583489312609826
++bi[13, 4] = 832.2148793276440873476229585070779183432
++bi[13, 5] = -664.7743368554426242883314487337054193624
++bi[13, 6] = 201.7928804424166224412127551654694479565
++
++bi[14, 0] = 0.
++bi[14, 1] = -5.919778732715006698693070786679427540601
++bi[14, 2] = 63.27679965889218829298274978013773800731
++bi[14, 3] = -265.4326820887379575820873554556433306580
++bi[14, 4] = 520.1009254140610824835871087519714692468
++bi[14, 5] = -467.4121095339020118993777963241667608460
++bi[14, 6] = 155.3868452824017054035883640343803117904
++
++bi[15, 0] = 0.
++bi[15, 1] = -10.49214619796182281022379415510181241136
++bi[15, 2] = 105.3553852518801101042787230303396283676
++bi[15, 3] = -409.4397501198893846479834816688367917005
++bi[15, 4] = 732.8314489076540326880337353277812147333
++bi[15, 5] = -606.3044574733512377981129469949015057785
++bi[15, 6] = 188.0495196316683024640077644607192667895
++
++vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
+diff --git a/qutip/solver/integrator/verner9efficient.py b/qutip/solver/integrator/verner9efficient.py
+index 02b1d926..aa331a91 100644
+--- a/qutip/solver/integrator/verner9efficient.py
++++ b/qutip/solver/integrator/verner9efficient.py
+@@ -1,706 +1,706 @@
+-"""
+-Provide a cython implimentation verner 'most-efficient'
+-order 9 runge-Kutta method.
+-See http://people.math.sfu.ca/~jverner/
+-"""
+-# Verner 9 Efficient
+-# http://people.math.sfu.ca/~jverner/
+-
+-__all__ = ["vern9_coeff"]
+-import numpy as np
+-order = 9
+-rk_step = 16
+-rk_extra_step = 26
+-denseout_order = 9
+-
+-bh = np.zeros(rk_step, dtype=np.float64)
+-a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
+-b = np.zeros(rk_step, dtype=np.float64)
+-c = np.zeros(rk_extra_step, dtype=np.float64)
+-e = np.zeros(rk_step, dtype=np.float64)
+-bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
+-
+-c[0] = 0.
+-c[1] = .3462e-1
+-c[2] = .9702435063878044594828361677100617517633e-1
+-c[3] = .1455365259581706689224254251565092627645
+-c[4] = .561
+-c[5] = .2290079115904850126662751771814700052182
+-c[6] = .5449920884095149873337248228185299947818
+-c[7] = .645
+-c[8] = .4837500000000000000000000000000000000000
+-c[9] = .6757e-1
+-c[10] = .2500
+-c[11] = .6590650618730998549405331618649220295334
+-c[12] = .8206
+-c[13] = .9012
+-c[14] = 1.
+-c[15] = 1.
+-
+-a[1, 0] = .3462e-1
+-
+-a[2, 0] = -.389335438857287327017042687229284478532e-1
+-a[2, 1] = .1359578945245091786499878854939346230295
+-
+-a[3, 0] = .3638413148954266723060635628912731569111e-1
+-a[3, 1] = 0.
+-a[3, 2] = .1091523944686280016918190688673819470733
+-
+-a[4, 0] = 2.025763914393969636805657604282571047511
+-a[4, 1] = 0.
+-a[4, 2] = -7.638023836496292020387602153091964592952
+-a[4, 3] = 6.173259922102322383581944548809393545442
+-
+-a[5, 0] = .5112275589406060872792270881648288397197e-1
+-a[5, 1] = 0.
+-a[5, 2] = 0.
+-a[5, 3] = .1770823794555021537929910813839068684087
+-a[5, 4] = .80277624092225014536138698108025283759e-3
+-
+-a[6, 0] = .1316006357975216279279871693164256985334
+-a[6, 1] = 0.
+-a[6, 2] = 0.
+-a[6, 3] = -.2957276252669636417685183174672273730699
+-a[6, 4] = .878137803564295237421124704053886667082e-1
+-a[6, 5] = .6213052975225274774321435005639430026100
+-
+-a[7, 0] = .7166666666666666666666666666666666666667e-1
+-a[7, 1] = 0.
+-a[7, 2] = 0.
+-a[7, 3] = 0.
+-a[7, 4] = 0.
+-a[7, 5] = .3305533578915319409260346730051472207728
+-a[7, 6] = .2427799754418013924072986603281861125606
+-
+-a[8, 0] = .7180664062500000000000000000000000000000e-1
+-a[8, 1] = 0.
+-a[8, 2] = 0.
+-a[8, 3] = 0.
+-a[8, 4] = 0.
+-a[8, 5] = .3294380283228177160744825466257672816401
+-a[8, 6] = .1165190029271822839255174533742327183599
+-a[8, 7] = -.3401367187500000000000000000000000000000e-1
+-
+-a[9, 0] = .4836757646340646986611287718844085773549e-1
+-a[9, 1] = 0.
+-a[9, 2] = 0.
+-a[9, 3] = 0.
+-a[9, 4] = 0.
+-a[9, 5] = .3928989925676163974333190042057047002852e-1
+-a[9, 6] = .1054740945890344608263649267140088017604
+-a[9, 7] = -.2143865284648312665982642293830533996214e-1
+-a[9, 8] = -.1041229174627194437759832813847147895623
+-
+-a[10, 0] = -.2664561487201478635337289243849737340534e-1
+-a[10, 1] = 0.
+-a[10, 2] = 0.
+-a[10, 3] = 0.
+-a[10, 4] = 0.
+-a[10, 5] = .3333333333333333333333333333333333333333e-1
+-a[10, 6] = -.1631072244872467239162704487554706387141
+-a[10, 7] = .3396081684127761199487954930015522928244e-1
+-a[10, 8] = .1572319413814626097110769806810024118077
+-a[10, 9] = .2152267478031879552303534778794770376960
+-
+-a[11, 0] = .3689009248708622334786359863227633989718e-1
+-a[11, 1] = 0.
+-a[11, 2] = 0.
+-a[11, 3] = 0.
+-a[11, 4] = 0.
+-a[11, 5] = -.1465181576725542928653609891758501156785
+-a[11, 6] = .2242577768172024345345469822625833796001
+-a[11, 7] = .2294405717066072637090897902753790803034e-1
+-a[11, 8] = -.35850052905728761357394424889330334334e-2
+-a[11, 9] = .8669223316444385506869203619044453906053e-1
+-a[11, 10] = .4383840651968337846196219974168630120572
+-
+-a[12, 0] = -.4866012215113340846662212357570395295088
+-a[12, 1] = 0.
+-a[12, 2] = 0.
+-a[12, 3] = 0.
+-a[12, 4] = 0.
+-a[12, 5] = -6.304602650282852990657772792012007122988
+-a[12, 6] = -.281245618289472564778284183790118418111
+-a[12, 7] = -2.679019236219849057687906597489223155566
+-a[12, 8] = .518815663924157511565311164615012522024
+-a[12, 9] = 1.365353187603341710683633635235238678626
+-a[12, 10] = 5.885091088503946585721274891680604830712
+-a[12, 11] = 2.802808786272062889819965117517532194812
+-
+-a[13, 0] = .4185367457753471441471025246471931649633
+-a[13, 1] = 0.
+-a[13, 2] = 0.
+-a[13, 3] = 0.
+-a[13, 4] = 0.
+-a[13, 5] = 6.724547581906459363100870806514855026676
+-a[13, 6] = -.425444280164611790606983409697113064616
+-a[13, 7] = 3.343279153001265577811816947557982637749
+-a[13, 8] = .617081663117537759528421117507709784737
+-a[13, 9] = -.929966123939932833937749523988800852013
+-a[13, 10] = -6.099948804751010722472962837945508844846
+-a[13, 11] = -3.002206187889399044804158084895173690015
+-a[13, 12] = .2553202529443445472336424602988558373637
+-
+-a[14, 0] = -.779374086122884664644623040843840506343
+-a[14, 1] = 0.
+-a[14, 2] = 0.
+-a[14, 3] = 0.
+-a[14, 4] = 0.
+-a[14, 5] = -13.93734253810777678786523664804936051203
+-a[14, 6] = 1.252048853379357320949735183924200895136
+-a[14, 7] = -14.69150040801686878191527989293072091588
+-a[14, 8] = -.494705058533141685655191992136962873577
+-a[14, 9] = 2.242974909146236657906984549543692874755
+-a[14, 10] = 13.36789380382864375813864978592679139881
+-a[14, 11] = 14.39665048665068644512236935340272139005
+-a[14, 12] = -.7975813331776800379127866056663258667437
+-a[14, 13] = .4409353709534277758753793068298041158235
+-
+-a[15, 0] = 2.058051337466886442151242368989994043993
+-a[15, 1] = 0.
+-a[15, 2] = 0.
+-a[15, 3] = 0.
+-a[15, 4] = 0.
+-a[15, 5] = 22.35793772796803295519317565842520212899
+-a[15, 6] = .90949810997556332745009198137971890783
+-a[15, 7] = 35.89110098240264104710550686568482456493
+-a[15, 8] = -3.442515027624453437985000403608480262211
+-a[15, 9] = -4.865481358036368826566013387928704014496
+-a[15, 10] = -18.90980381354342625688427480879773032857
+-a[15, 11] = -34.26354448030451782929251177395134170515
+-a[15, 12] = 1.264756521695642578827783499806516664686
+-a[15, 13] = 0.
+-a[15, 14] = 0.
+-
+-b[0] = .1461197685842315252051541915018784713459e-1
+-b[1] = 0.
+-b[2] = 0.
+-b[3] = 0.
+-b[4] = 0.
+-b[5] = 0.
+-b[6] = 0.
+-b[7] = -.3915211862331339089410228267288242030810
+-b[8] = .2310932500289506415909675644868993669908
+-b[9] = .1274766769992852382560589467488989175618
+-b[10] = .2246434176204157731566981937082069688984
+-b[11] = .5684352689748512932705226972873692126743
+-b[12] = .5825871557215827200814768021863420902155e-1
+-b[13] = .1364317403482215641609022744494239843327
+-b[14] = .3057013983082797397721005067920369646664e-1
+-b[15] = 0.
+-
+-bh[0] = .1996996514886773085518508418098868756464e-1
+-bh[1] = 0.
+-bh[2] = 0.
+-bh[3] = 0.
+-bh[4] = 0.
+-bh[5] = 0.
+-bh[6] = 0.
+-bh[7] = 2.191499304949330054530747099310837524864
+-bh[8] = .8857071848208438030833722031786358862953e-1
+-bh[9] = .1140560234865965622484956605091432032674
+-bh[10] = .2533163805345107065564577734569651977347
+-bh[11] = -2.056564386240941011158999594595981300493
+-bh[12] = .3408096799013119935160094894224543812830
+-bh[13] = 0.
+-bh[14] = 0.
+-bh[15] = .4834231373823958314376726739772871714902e-1
+-
+-for i in range(16):
+-    e[i] = b[i] - bh[i]
+-
+-c[16] = 1.0
+-
+-a[16, 0] = .1461197685842315252051541915018784713459e-1
+-a[16, 1] = 0.
+-a[16, 2] = 0.
+-a[16, 3] = 0.
+-a[16, 4] = 0.
+-a[16, 5] = 0.
+-a[16, 6] = 0.
+-a[16, 7] = -.3915211862331339089410228267288242030810
+-a[16, 8] = .2310932500289506415909675644868993669908
+-a[16, 9] = .1274766769992852382560589467488989175618
+-a[16, 10] = .2246434176204157731566981937082069688984
+-a[16, 11] = .5684352689748512932705226972873692126743
+-a[16, 12] = .5825871557215827200814768021863420902155e-1
+-a[16, 13] = .1364317403482215641609022744494239843327
+-a[16, 14] = .3057013983082797397721005067920369646664e-1
+-a[16, 15] = 0.
+-
+-c[17] = .7404185470631561083004100761798676215811
+-
+-a[17, 0] = .1549973668189559302279946863304789372788e-1
+-a[17, 1] = 0.
+-a[17, 2] = 0.
+-a[17, 3] = 0.
+-a[17, 4] = 0.
+-a[17, 5] = 0.
+-a[17, 6] = 0.
+-a[17, 7] = .3355153219059635054403439303177105512242
+-a[17, 8] = .2003613944191860651552622660712101217322
+-a[17, 9] = .1252060659283549312946162355194540994211
+-a[17, 10] = .2298676393184206750544046308957155868736
+-a[17, 11] = -.2020250653476181447824906889122391003637
+-a[17, 12] = .5917103230665456601422111997583025339897e-1
+-a[17, 13] = -.2651834783047638681693835956996437528251e-1
+-a[17, 14] = -.2384094602130971415278110567256446033405e-1
+-a[17, 15] = 0.
+-a[17, 16] = .2718171570208501807097257892166705118335e-1
+-
+-c[18] = .888
+-
+-a[18, 0] = .1302453943114338366054520296881099431474e-1
+-a[18, 1] = 0.
+-a[18, 2] = 0.
+-a[18, 3] = 0.
+-a[18, 4] = 0.
+-a[18, 5] = 0.
+-a[18, 6] = 0.
+-a[18, 7] = -.7452850902413112085299330666038981625179
+-a[18, 8] = .2643867896429300961465132150322749722129
+-a[18, 9] = .1313961758372753932588328082078842388890
+-a[18, 10] = .2167253815122927263092467187957410643315
+-a[18, 11] = .8734117564076052559016338094938888451419
+-a[18, 12] = .1185905643935776688228545787724340848142e-1
+-a[18, 13] = .5876002941689550612992712203494447529933e-1
+-a[18, 14] = .3266518630202087866399279690939423159022e-2
+-a[18, 15] = 0.
+-a[18, 16] = -.8959308648417929824525368306101792182274e-2
+-a[18, 17] = .6941415157202692219907482080827253287034e-1
+-
+-c[19] = .696
+-
+-a[19, 0] = .1397089996925942721283716334050740168797e-1
+-a[19, 1] = 0.
+-a[19, 2] = 0.
+-a[19, 3] = 0.
+-a[19, 4] = 0.
+-a[19, 5] = 0.
+-a[19, 6] = 0.
+-a[19, 7] = -.4665765335957674596054673402956853940520
+-a[19, 8] = .2416372787216257077935214889875485248580
+-a[19, 9] = .1290363341345674735721677437066933999929
+-a[19, 10] = .2216700671735105311080225734522323922813
+-a[19, 11] = .6257275123364644931771253383573999863003
+-a[19, 12] = .4355312415679284117869124964829805160429e-1
+-a[19, 13] = .1011962491667290833450024852274278874501
+-a[19, 14] = .1808582254679721049279369742685497400353e-1
+-a[19, 15] = 0.
+-a[19, 16] = -.2079875587689169691156509689282083267654e-1
+-a[19, 17] = -.9022232517086218976198252891464664868640e-1
+-a[19, 18] = -.1212796735622254216011467740438097427634
+-
+-c[20] = .487
+-
+-a[20, 0] = .1604638888318112738641232352800290501904e-1
+-a[20, 1] = 0.
+-a[20, 2] = 0.
+-a[20, 3] = 0.
+-a[20, 4] = 0.
+-a[20, 5] = 0.
+-a[20, 6] = 0.
+-a[20, 7] = .9517712399458336651642257453589397190702e-1
+-a[20, 8] = .1359187264655317806136927180199100622471
+-a[20, 9] = .1237765280959854006935081364365637515893
+-a[20, 10] = .2335656264102966047058755123098072346246
+-a[20, 11] = -.9051508172625873314662090873741762206189e-1
+-a[20, 12] = -.2537574270006131028513276914038326155331e-1
+-a[20, 13] = -.1359631696887162048002744757083947500478
+-a[20, 14] = -.4679214284145113075088049469061349990847e-1
+-a[20, 15] = 0.
+-a[20, 16] = .5177958859391748239949773879090325427473e-1
+-a[20, 17] = .9672595677476773313884172931875718705561e-1
+-a[20, 18] = .1477312690340742769720989417101989769314
+-a[20, 19] = -.1150750712958503934434410263732282100773
+-c[21] = .25e-1
+-
+-a[21, 0] = .1802918623893620731908165792176564180038e-1
+-a[21, 1] = 0.
+-a[21, 2] = 0.
+-a[21, 3] = 0.
+-a[21, 4] = 0.
+-a[21, 5] = 0.
+-a[21, 6] = 0.
+-a[21, 7] = .6983601042028873702545973390560096201728e-1
+-a[21, 8] = -.2541247660791663512384395986842781657182e-1
+-a[21, 9] = .8487827035463274491721441398893680307535e-2
+-a[21, 10] = -.2427525516089801645451101966852425715128e-2
+-a[21, 11] = -.1047839752893819879012607694745789515746
+-a[21, 12] = -.1473147795248041942353840372690095884761e-1
+-a[21, 13] = -.3916338390816177165706892282751065537530e-1
+-a[21, 14] = -.1005657343293959419073236542225421561652e-1
+-a[21, 15] = 0.
+-a[21, 16] = .1102510392204834322538452331445716455061e-1
+-a[21, 17] = .5092830749095398308703438556315975226108e-2
+-a[21, 18] = .4759715599420644505591133410826632557391e-1
+-a[21, 19] = .3386307003288382751110965442296681690349e-1
+-a[21, 20] = .2764422831404797700452373965825845732168e-1
+-
+-c[22] = .15
+-
+-a[22, 0] = .1677431640522778042988664067637191163626e-1
+-a[22, 1] = 0.
+-a[22, 2] = 0.
+-a[22, 3] = 0.
+-a[22, 4] = 0.
+-a[22, 5] = 0.
+-a[22, 6] = 0.
+-a[22, 7] = .6220437408820475326702539861577894278533
+-a[22, 8] = -.2060859809768841878234097076241307428139
+-a[22, 9] = .1156394989766058889629372195583391792474
+-a[22, 10] = .2664101793378358946544219293685167025971e-1
+-a[22, 11] = -.9376810793418770527505892794460093668860
+-a[22, 12] = -.1367806466702160302637074581619101741312
+-a[22, 13] = -.3678480995268296672182605288991379118419
+-a[22, 14] = -.9547871314402478902820445838193201497337e-1
+-a[22, 15] = 0.
+-a[22, 16] = .1013492018422369748729008873270013785313
+-a[22, 17] = -.8911323084568593396468400926074881389560e-1
+-a[22, 18] = .4664140988974760478895528270623735057521
+-a[22, 19] = .4502736292354579812232681662308722738519
+-a[22, 20] = .1838522463326818655346135218242696774099
+-a[22, 21] = 0.
+-
+-c[23] = .32
+-
+-a[23, 0] = .1071149731491444187554380927165768658192e-1
+-a[23, 1] = 0.
+-a[23, 2] = 0.
+-a[23, 3] = 0.
+-a[23, 4] = 0.
+-a[23, 5] = 0.
+-a[23, 6] = 0.
+-a[23, 7] = -.7094336118221108191937165464264324417735e-1
+-a[23, 8] = .1002164900340091596740582334112699697590
+-a[23, 9] = .1383453980468025108839271214703390659581
+-a[23, 10] = .1796330633578163411338104055485109917477
+-a[23, 11] = .9048246545576180974879274948815422276563e-1
+-a[23, 12] = -.5460662294523338383345981122023862069115e-2
+-a[23, 13] = -.3000457905119619782973021046143166498567e-1
+-a[23, 14] = -.1145192026962799093665613252151017277867e-1
+-a[23, 15] = 0.
+-a[23, 16] = .1003394686109385076849515422360600302176e-1
+-a[23, 17] = -.9506485282809046129031027932806241113157e-1
+-a[23, 18] = .4853358804093591445756711642658478691640e-1
+-a[23, 19] = .8013325919783924638483373011297347396327e-1
+-a[23, 20] = -.1251643326835242045676140618774248455713
+-a[23, 21] = 0.
+-a[23, 22] = 0.
+-
+-c[24] = .78
+-
+-a[24, 0] = .1410172088869221367153586187761994182069e-1
+-a[24, 1] = 0.
+-a[24, 2] = 0.
+-a[24, 3] = 0.
+-a[24, 4] = 0.
+-a[24, 5] = 0.
+-a[24, 6] = 0.
+-a[24, 7] = -.3713379753704491105936205420001801316029
+-a[24, 8] = .2231265548117180273161442520179150684520
+-a[24, 9] = .1287005345918120122888629169443916280865
+-a[24, 10] = .2224600659675494761192249831098918110654
+-a[24, 11] = .5382853042550701952740528638168708946100
+-a[24, 12] = .5417202616988763101781128062036252796548e-1
+-a[24, 13] = .1256968791308743925752109039299467082975
+-a[24, 14] = .2784492789002054061504430663197543089132e-1
+-a[24, 15] = 0.
+-a[24, 16] = -.3077409246205059733390460511525401688205e-1
+-a[24, 17] = .8569805293689777608077303071761466118035e-2
+-a[24, 18] = -.1535174690587044615794997685221990516897
+-a[24, 19] = -.2179957030548196497189489878038029238243e-1
+-a[24, 20] = .1447128819737186799295514239727801525027e-1
+-a[24, 21] = 0.
+-a[24, 22] = 0.
+-a[24, 23] = 0.
+-
+-c[25] = .96
+-
+-a[25, 0] = .1424600411735646609296566581447532773183e-1
+-a[25, 1] = 0.
+-a[25, 2] = 0.
+-a[25, 3] = 0.
+-a[25, 4] = 0.
+-a[25, 5] = 0.
+-a[25, 6] = 0.
+-a[25, 7] = -.3767107393295407091303982522049390741260
+-a[25, 8] = .2252399780730421480874737297000189000070
+-a[25, 9] = .1283603076292529988314451246143633426068
+-a[25, 10] = .2230238705261692544876826347415151339678
+-a[25, 11] = .5463127827750747224899202176094949607118
+-a[25, 12] = .5526190791375779994553849469706124289752e-1
+-a[25, 13] = .1285613508749982456581494397108686240388
+-a[25, 14] = .2857250681296406482698934635829147899039e-1
+-a[25, 15] = 0.
+-a[25, 16] = -.2398761886357108720930416967644499057175e-1
+-a[25, 17] = .5556224458910509454379297181908734648749e-1
+-a[25, 18] = -.1740675650762838674257930398070760254668e-1
+-a[25, 19] = -.3815462365996979065575121886854199471011e-1
+-a[25, 20] = .1111878504898917877407531966545730451506e-1
+-a[25, 21] = 0.
+-a[25, 22] = 0.
+-a[25, 23] = 0.
+-a[25, 24] = 0.
+-
+-bi[0, 0] = 1.
+-bi[0, 1] = -28.33048870061739823290767301658881994700
+-bi[0, 2] = 257.6535452078577977252092979905248156497
+-bi[0, 3] = -1152.154455743457311528752964691951881858
+-bi[0, 4] = 2909.390878345408890936564599116550031880
+-bi[0, 5] = -4355.005172868188498048946108887283528629
+-bi[0, 6] = 3834.083497036262189455855371796461857871
+-bi[0, 7] = -1835.419052683407081215583427992189311730
+-bi[0, 8] = 368.7958613829998340610814211036270246107
+-
+-bi[1, 0] = 0.
+-bi[1, 1] = 0.
+-bi[1, 2] = 0.
+-bi[1, 3] = 0.
+-bi[1, 4] = 0.
+-bi[1, 5] = 0.
+-bi[1, 6] = 0.
+-bi[1, 7] = 0.
+-bi[1, 8] = 0.
+-
+-bi[2, 0] = 0.
+-bi[2, 1] = 0.
+-bi[2, 2] = 0.
+-bi[2, 3] = 0.
+-bi[2, 4] = 0.
+-bi[2, 5] = 0.
+-bi[2, 6] = 0.
+-bi[2, 7] = 0.
+-bi[2, 8] = 0.
+-
+-bi[3, 0] = 0.
+-bi[3, 1] = 0.
+-bi[3, 2] = 0.
+-bi[3, 3] = 0.
+-bi[3, 4] = 0.
+-bi[3, 5] = 0.
+-bi[3, 6] = 0.
+-bi[3, 7] = 0.
+-bi[3, 8] = 0.
+-
+-bi[4, 0] = 0.
+-bi[4, 1] = 0.
+-bi[4, 2] = 0.
+-bi[4, 3] = 0.
+-bi[4, 4] = 0.
+-bi[4, 5] = 0.
+-bi[4, 6] = 0.
+-bi[4, 7] = 0.
+-bi[4, 8] = 0.
+-
+-bi[5, 0] = 0.
+-bi[5, 1] = 0.
+-bi[5, 2] = 0.
+-bi[5, 3] = 0.
+-bi[5, 4] = 0.
+-bi[5, 5] = 0.
+-bi[5, 6] = 0.
+-bi[5, 7] = 0.
+-bi[5, 8] = 0.
+-
+-bi[6, 0] = 0.
+-bi[6, 1] = 0.
+-bi[6, 2] = 0.
+-bi[6, 3] = 0.
+-bi[6, 4] = 0.
+-bi[6, 5] = 0.
+-bi[6, 6] = 0.
+-bi[6, 7] = 0.
+-bi[6, 8] = 0.
+-
+-bi[7, 0] = 0.
+-bi[7, 1] = 2.649656243770091212685381903551424676261
+-bi[7, 2] = -96.30312807816005963630382777245983513008
+-bi[7, 3] = 869.3095462492795755338599928089438369769
+-bi[7, 4] = -3395.688567551074115525201961265641584358
+-bi[7, 5] = 6796.933987158715680563278170147156885480
+-bi[7, 6] = -7340.848417712071304684606060804637321789
+-bi[7, 7] = 4082.848896992365666259441580054990759905
+-bi[7, 8] = -919.2934944890586676320942978986329899642
+-
+-bi[8, 0] = 0.
+-bi[8, 1] = -1.563945181928732780647121505551017046606
+-bi[8, 2] = 56.84239739272860000194549791973820565214
+-bi[8, 3] = -513.1052300304284642178552372517916694426
+-bi[8, 4] = 2004.286702110323162741493515173880535381
+-bi[8, 5] = -4011.853305913929339500285683507736138334
+-bi[8, 6] = 4332.895839278586189971336003691596594090
+-bi[8, 7] = -2409.879347937144606091337260195738587773
+-bi[8, 8] = 542.6079835318221405169412532400889768401
+-
+-bi[9, 0] = 0.
+-bi[9, 1] = -.8627103334967223830653368770735555216700
+-bi[9, 2] = 31.35565375185173442495465167501846267906
+-bi[9, 3] = -283.0413682227354209126847112083546012674
+-bi[9, 4] = 1105.613463426006937052739159664962261462
+-bi[9, 5] = -2213.036200678452629288185991597653042989
+-bi[9, 6] = 2390.131097754120588994847482867886207858
+-bi[9, 7] = -1329.348266146873716496636094950745123424
+-bi[9, 8] = 299.3158071265785138462868993727082901209
+-
+-bi[10, 0] = 0.
+-bi[10, 1] = -1.520295337901214839055193576160469820911
+-bi[10, 2] = 55.25592121120227100440616045452813504748
+-bi[10, 3] = -498.7844190970740738969945498750124435385
+-bi[10, 4] = 1948.346888525776056658403461666308795237
+-bi[10, 5] = -3899.882136407551390287649940376076923682
+-bi[10, 6] = 4211.964345158858030803618536151121927765
+-bi[10, 7] = -2342.619408856117128087568672414857706561
+-bi[10, 8] = 527.4637482204278644179968961638568925209
+-
+-bi[11, 0] = 0.
+-bi[11, 1] = -3.846938844125523400516071820264700141179
+-bi[11, 2] = 139.8189840986840520353362018994734906611
+-bi[11, 3] = -1262.118687621600386514715930156791825893
+-bi[11, 4] = 4930.075848057311658057235318456802793199
+-bi[11, 5] = -9868.219486069539059368988308801366826185
+-bi[11, 6] = 10657.90892434886730229746304583865145121
+-bi[11, 7] = -5927.738759872814112912292792695856187255
+-bi[11, 8] = 1334.688551172190921099749059976639173619
+-
+-bi[12, 0] = 0.
+-bi[12, 1] = -.3942713061200141454309326713125653612517
+-bi[12, 2] = 14.32999476067649707020689155180345562459
+-bi[12, 3] = -129.3540665994558117853022852051786116929
+-bi[12, 4] = 505.2816077002517600897861155496606850457
+-bi[12, 5] = -1011.390080139433268878243655218566636574
+-bi[12, 6] = 1092.325051781891697669369143688906543465
+-bi[12, 7] = -607.5317019302810290917918493845279272648
+-bi[12, 8] = 136.7917244480423273434147193694336909663
+-
+-bi[13, 0] = 0.
+-bi[13, 1] = -.9233145622082101394378429409444333268499
+-bi[13, 2] = 33.55834582309798808260613735851232640640
+-bi[13, 3] = -302.9246397549735936661321348695774835448
+-bi[13, 4] = 1183.281306967867553342903125095128753568
+-bi[13, 5] = -2368.498986790111516106072390247333149007
+-bi[13, 6] = 2558.034559755808027369106332027405169828
+-bi[13, 7] = -1422.733175577880214903071122439856598476
+-bi[13, 8] = 320.3423358787481875842587982911148385364
+-
+-bi[14, 0] = 0.
+-bi[14, 1] = -.2068862802930053801253649628830330891017
+-bi[14, 2] = 7.519388975651662772174695012120581518594
+-bi[14, 3] = -67.87605708082904058354114755731111898667
+-bi[14, 4] = 265.1367996984150421661637988925923843021
+-bi[14, 5] = -530.7074807559025368587558119659212235622
+-bi[14, 6] = 573.1765495641490277116961329189087439579
+-bi[14, 7] = -318.7905688834868978004500126002971837241
+-bi[14, 8] = 71.77882490212657594681492031347005327988
+-
+-bi[15, 0] = 0.
+-bi[15, 1] = 0.
+-bi[15, 2] = 0.
+-bi[15, 3] = 0.
+-bi[15, 4] = 0.
+-bi[15, 5] = 0.
+-bi[15, 6] = 0.
+-bi[15, 7] = 0.
+-bi[15, 8] = 0.
+-
+-bi[16, 0] = 0.
+-bi[16, 1] = -.4472441906744099441704338175964823026105
+-bi[16, 2] = 16.44684676010503791623763886833381020592
+-bi[16, 3] = -154.4086105921295528355180056633078150675
+-bi[16, 4] = 641.8986298540248497333509289273669726482
+-bi[16, 5] = -1391.939225687982391028602609567895699003
+-bi[16, 6] = 1643.890568302952013019278202625162156841
+-bi[16, 7] = -1004.065297223317845596795060426393517046
+-bi[16, 8] = 248.6243327770222987362193390543305737239
+-
+-bi[17, 0] = 0.
+-bi[17, 1] = -.1507876007899797948720901584434839156279
+-bi[17, 2] = 5.527328824824632235316362126620825363280
+-bi[17, 3] = -51.33833743084618751433903968701557585387
+-bi[17, 4] = 209.6022002703280347991393999433060881829
+-bi[17, 5] = -442.7692650421825928714839983614217797969
+-bi[17, 6] = 505.0579312588052893780948070449787925777
+-bi[17, 7] = -295.6336410615619366143935619944592839974
+-bi[17, 8] = 69.70457078142274038253812108643441743987
+-
+-bi[18, 0] = 0.
+-bi[18, 1] = -.6413652207435296452288504944964177537185
+-bi[18, 2] = 23.51013248624684600263471193689787394701
+-bi[18, 3] = -218.3642683246972281497485359238725613162
+-bi[18, 4] = 891.5292818535365634586829868055833114383
+-bi[18, 5] = -1883.290177206007885518558760085145850658
+-bi[18, 6] = 2148.230954488399755970660772306573864434
+-bi[18, 7] = -1257.458401521712336970840850120592935471
+-bi[18, 8] = 296.4838434449778148523985255750527153802
+-
+-bi[19, 0] = 0.
+-bi[19, 1] = 1.810729313444845732964058528284532356045
+-bi[19, 2] = -66.37479657295337371220255196726289169374
+-bi[19, 3] = 616.4952025401106511929691356878863855003
+-bi[19, 4] = -2517.003030777322559684753470471663859295
+-bi[19, 5] = 5316.984175781033401491488704359579721604
+-bi[19, 6] = -6064.976140789574108556866601189158423779
+-bi[19, 7] = 3550.109538888391317555902194852386816092
+-bi[19, 8] = -837.0456783831301740195014698000522807852
+-
+-bi[20, 0] = 0.
+-bi[20, 1] = .5176008760353717918864555990277480363987e-1
+-bi[20, 2] = -1.897337862580348756406065418550014243949
+-bi[20, 3] = 17.62264820793629244181715147639285955422
+-bi[20, 4] = -71.94907400242465946110661282550878163878
+-bi[20, 5] = 151.9871383765666045085018751235590550206
+-bi[20, 6] = -173.3686498747860565970136435029707518663
+-bi[20, 7] = 101.4806461521468075879782291473158292931
+-bi[20, 8] = -23.92713108446217690295957956014097092250
+-
+-bi[21, 0] = 0.
+-bi[21, 1] = 31.32178255668799909977422939838912846070
+-bi[21, 2] = -355.6570858339106059687054319211280026146
+-bi[21, 3] = 1752.685282489515979253875884672206842255
+-bi[21, 4] = -4708.092293138363367969732154806019707156
+-bi[21, 5] = 7370.900776193488713149861391844801840850
+-bi[21, 6] = -6716.504964764565347011489385051202629762
+-bi[21, 7] = 3303.940398161185772296756776169088470785
+-bi[21, 8] = -678.5938956640391428503413103061359428182
+-
+-bi[22, 0] = 0.
+-bi[22, 1] = -2.719607334185924760747802644504744092917
+-bi[22, 2] = 86.64045615858264001154848875638486632034
+-bi[22, 3] = -454.1926030939030807863651114984001402596
+-bi[22, 4] = 1014.749221100543425314268817989377200147
+-bi[22, 5] = -1133.583456714543865890388885909333783663
+-bi[22, 6] = 610.4671827718666569168001429679645990946
+-bi[22, 7] = -109.0233499449543802317396567002119357593
+-bi[22, 8] = -12.33784294340547057337599296127606178639
+-
+-bi[23, 0] = 0.
+-bi[23, 1] = 3.177214801432923432265738869490200556403
+-bi[23, 2] = -113.8098697715142983214434051918276259885
+-bi[23, 3] = 978.0935981825675014833003847211971070224
+-bi[23, 4] = -3575.129377623670076451027372711378100786
+-bi[23, 5] = 6764.361519838450570830405988615992045681
+-bi[23, 6] = -6987.161043852012362644872233028628887679
+-bi[23, 7] = 3751.905762789571137088934326513342858381
+-bi[23, 8] = -821.4378043648253954175634277881875971878
+-
+-bi[24, 0] = 0.
+-bi[24, 1] = .8772843083465530069477626269697233842708
+-bi[24, 2] = -31.51810423988375104361582759389916060143
+-bi[24, 3] = 273.1229151353221133842213845530391043248
+-bi[24, 4] = -993.2198643101781966584366870874238565290
+-bi[24, 5] = 1787.888078312663987193988385659681964836
+-bi[24, 6] = -1677.394835799640950953367739332661886275
+-bi[24, 7] = 781.3579535062687952504707744453846824540
+-bi[24, 8] = -141.1134269128985501802080532710905715931
+-
+-bi[25, 0] = 0.
+-bi[25, 1] = 1.719427581798715782378897599231938082126
+-bi[25, 2] = -62.89867309250732184389962568482931880335
+-bi[25, 3] = 580.3335507873980391019057196688995930872
+-bi[25, 4] = -2348.110620506760958600472968113883922730
+-bi[25, 5] = 4921.119298612906015908637628774963068611
+-bi[25, 6] = -5597.912448707916639109910311016358007839
+-bi[25, 7] = 3288.597775149621789973016480733216881572
+-bi[25, 8] = -782.8483098245396412116558219612402319811
+-
+-vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
++"""
++Provide a cython implimentation verner 'most-efficient'
++order 9 runge-Kutta method.
++See http://people.math.sfu.ca/~jverner/
++"""
++# Verner 9 Efficient
++# http://people.math.sfu.ca/~jverner/
++
++__all__ = ["vern9_coeff"]
++import numpy as np
++order = 9
++rk_step = 16
++rk_extra_step = 26
++denseout_order = 9
++
++bh = np.zeros(rk_step, dtype=np.float64)
++a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
++b = np.zeros(rk_step, dtype=np.float64)
++c = np.zeros(rk_extra_step, dtype=np.float64)
++e = np.zeros(rk_step, dtype=np.float64)
++bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
++
++c[0] = 0.
++c[1] = .3462e-1
++c[2] = .9702435063878044594828361677100617517633e-1
++c[3] = .1455365259581706689224254251565092627645
++c[4] = .561
++c[5] = .2290079115904850126662751771814700052182
++c[6] = .5449920884095149873337248228185299947818
++c[7] = .645
++c[8] = .4837500000000000000000000000000000000000
++c[9] = .6757e-1
++c[10] = .2500
++c[11] = .6590650618730998549405331618649220295334
++c[12] = .8206
++c[13] = .9012
++c[14] = 1.
++c[15] = 1.
++
++a[1, 0] = .3462e-1
++
++a[2, 0] = -.389335438857287327017042687229284478532e-1
++a[2, 1] = .1359578945245091786499878854939346230295
++
++a[3, 0] = .3638413148954266723060635628912731569111e-1
++a[3, 1] = 0.
++a[3, 2] = .1091523944686280016918190688673819470733
++
++a[4, 0] = 2.025763914393969636805657604282571047511
++a[4, 1] = 0.
++a[4, 2] = -7.638023836496292020387602153091964592952
++a[4, 3] = 6.173259922102322383581944548809393545442
++
++a[5, 0] = .5112275589406060872792270881648288397197e-1
++a[5, 1] = 0.
++a[5, 2] = 0.
++a[5, 3] = .1770823794555021537929910813839068684087
++a[5, 4] = .80277624092225014536138698108025283759e-3
++
++a[6, 0] = .1316006357975216279279871693164256985334
++a[6, 1] = 0.
++a[6, 2] = 0.
++a[6, 3] = -.2957276252669636417685183174672273730699
++a[6, 4] = .878137803564295237421124704053886667082e-1
++a[6, 5] = .6213052975225274774321435005639430026100
++
++a[7, 0] = .7166666666666666666666666666666666666667e-1
++a[7, 1] = 0.
++a[7, 2] = 0.
++a[7, 3] = 0.
++a[7, 4] = 0.
++a[7, 5] = .3305533578915319409260346730051472207728
++a[7, 6] = .2427799754418013924072986603281861125606
++
++a[8, 0] = .7180664062500000000000000000000000000000e-1
++a[8, 1] = 0.
++a[8, 2] = 0.
++a[8, 3] = 0.
++a[8, 4] = 0.
++a[8, 5] = .3294380283228177160744825466257672816401
++a[8, 6] = .1165190029271822839255174533742327183599
++a[8, 7] = -.3401367187500000000000000000000000000000e-1
++
++a[9, 0] = .4836757646340646986611287718844085773549e-1
++a[9, 1] = 0.
++a[9, 2] = 0.
++a[9, 3] = 0.
++a[9, 4] = 0.
++a[9, 5] = .3928989925676163974333190042057047002852e-1
++a[9, 6] = .1054740945890344608263649267140088017604
++a[9, 7] = -.2143865284648312665982642293830533996214e-1
++a[9, 8] = -.1041229174627194437759832813847147895623
++
++a[10, 0] = -.2664561487201478635337289243849737340534e-1
++a[10, 1] = 0.
++a[10, 2] = 0.
++a[10, 3] = 0.
++a[10, 4] = 0.
++a[10, 5] = .3333333333333333333333333333333333333333e-1
++a[10, 6] = -.1631072244872467239162704487554706387141
++a[10, 7] = .3396081684127761199487954930015522928244e-1
++a[10, 8] = .1572319413814626097110769806810024118077
++a[10, 9] = .2152267478031879552303534778794770376960
++
++a[11, 0] = .3689009248708622334786359863227633989718e-1
++a[11, 1] = 0.
++a[11, 2] = 0.
++a[11, 3] = 0.
++a[11, 4] = 0.
++a[11, 5] = -.1465181576725542928653609891758501156785
++a[11, 6] = .2242577768172024345345469822625833796001
++a[11, 7] = .2294405717066072637090897902753790803034e-1
++a[11, 8] = -.35850052905728761357394424889330334334e-2
++a[11, 9] = .8669223316444385506869203619044453906053e-1
++a[11, 10] = .4383840651968337846196219974168630120572
++
++a[12, 0] = -.4866012215113340846662212357570395295088
++a[12, 1] = 0.
++a[12, 2] = 0.
++a[12, 3] = 0.
++a[12, 4] = 0.
++a[12, 5] = -6.304602650282852990657772792012007122988
++a[12, 6] = -.281245618289472564778284183790118418111
++a[12, 7] = -2.679019236219849057687906597489223155566
++a[12, 8] = .518815663924157511565311164615012522024
++a[12, 9] = 1.365353187603341710683633635235238678626
++a[12, 10] = 5.885091088503946585721274891680604830712
++a[12, 11] = 2.802808786272062889819965117517532194812
++
++a[13, 0] = .4185367457753471441471025246471931649633
++a[13, 1] = 0.
++a[13, 2] = 0.
++a[13, 3] = 0.
++a[13, 4] = 0.
++a[13, 5] = 6.724547581906459363100870806514855026676
++a[13, 6] = -.425444280164611790606983409697113064616
++a[13, 7] = 3.343279153001265577811816947557982637749
++a[13, 8] = .617081663117537759528421117507709784737
++a[13, 9] = -.929966123939932833937749523988800852013
++a[13, 10] = -6.099948804751010722472962837945508844846
++a[13, 11] = -3.002206187889399044804158084895173690015
++a[13, 12] = .2553202529443445472336424602988558373637
++
++a[14, 0] = -.779374086122884664644623040843840506343
++a[14, 1] = 0.
++a[14, 2] = 0.
++a[14, 3] = 0.
++a[14, 4] = 0.
++a[14, 5] = -13.93734253810777678786523664804936051203
++a[14, 6] = 1.252048853379357320949735183924200895136
++a[14, 7] = -14.69150040801686878191527989293072091588
++a[14, 8] = -.494705058533141685655191992136962873577
++a[14, 9] = 2.242974909146236657906984549543692874755
++a[14, 10] = 13.36789380382864375813864978592679139881
++a[14, 11] = 14.39665048665068644512236935340272139005
++a[14, 12] = -.7975813331776800379127866056663258667437
++a[14, 13] = .4409353709534277758753793068298041158235
++
++a[15, 0] = 2.058051337466886442151242368989994043993
++a[15, 1] = 0.
++a[15, 2] = 0.
++a[15, 3] = 0.
++a[15, 4] = 0.
++a[15, 5] = 22.35793772796803295519317565842520212899
++a[15, 6] = .90949810997556332745009198137971890783
++a[15, 7] = 35.89110098240264104710550686568482456493
++a[15, 8] = -3.442515027624453437985000403608480262211
++a[15, 9] = -4.865481358036368826566013387928704014496
++a[15, 10] = -18.90980381354342625688427480879773032857
++a[15, 11] = -34.26354448030451782929251177395134170515
++a[15, 12] = 1.264756521695642578827783499806516664686
++a[15, 13] = 0.
++a[15, 14] = 0.
++
++b[0] = .1461197685842315252051541915018784713459e-1
++b[1] = 0.
++b[2] = 0.
++b[3] = 0.
++b[4] = 0.
++b[5] = 0.
++b[6] = 0.
++b[7] = -.3915211862331339089410228267288242030810
++b[8] = .2310932500289506415909675644868993669908
++b[9] = .1274766769992852382560589467488989175618
++b[10] = .2246434176204157731566981937082069688984
++b[11] = .5684352689748512932705226972873692126743
++b[12] = .5825871557215827200814768021863420902155e-1
++b[13] = .1364317403482215641609022744494239843327
++b[14] = .3057013983082797397721005067920369646664e-1
++b[15] = 0.
++
++bh[0] = .1996996514886773085518508418098868756464e-1
++bh[1] = 0.
++bh[2] = 0.
++bh[3] = 0.
++bh[4] = 0.
++bh[5] = 0.
++bh[6] = 0.
++bh[7] = 2.191499304949330054530747099310837524864
++bh[8] = .8857071848208438030833722031786358862953e-1
++bh[9] = .1140560234865965622484956605091432032674
++bh[10] = .2533163805345107065564577734569651977347
++bh[11] = -2.056564386240941011158999594595981300493
++bh[12] = .3408096799013119935160094894224543812830
++bh[13] = 0.
++bh[14] = 0.
++bh[15] = .4834231373823958314376726739772871714902e-1
++
++for i in range(16):
++    e[i] = b[i] - bh[i]
++
++c[16] = 1.0
++
++a[16, 0] = .1461197685842315252051541915018784713459e-1
++a[16, 1] = 0.
++a[16, 2] = 0.
++a[16, 3] = 0.
++a[16, 4] = 0.
++a[16, 5] = 0.
++a[16, 6] = 0.
++a[16, 7] = -.3915211862331339089410228267288242030810
++a[16, 8] = .2310932500289506415909675644868993669908
++a[16, 9] = .1274766769992852382560589467488989175618
++a[16, 10] = .2246434176204157731566981937082069688984
++a[16, 11] = .5684352689748512932705226972873692126743
++a[16, 12] = .5825871557215827200814768021863420902155e-1
++a[16, 13] = .1364317403482215641609022744494239843327
++a[16, 14] = .3057013983082797397721005067920369646664e-1
++a[16, 15] = 0.
++
++c[17] = .7404185470631561083004100761798676215811
++
++a[17, 0] = .1549973668189559302279946863304789372788e-1
++a[17, 1] = 0.
++a[17, 2] = 0.
++a[17, 3] = 0.
++a[17, 4] = 0.
++a[17, 5] = 0.
++a[17, 6] = 0.
++a[17, 7] = .3355153219059635054403439303177105512242
++a[17, 8] = .2003613944191860651552622660712101217322
++a[17, 9] = .1252060659283549312946162355194540994211
++a[17, 10] = .2298676393184206750544046308957155868736
++a[17, 11] = -.2020250653476181447824906889122391003637
++a[17, 12] = .5917103230665456601422111997583025339897e-1
++a[17, 13] = -.2651834783047638681693835956996437528251e-1
++a[17, 14] = -.2384094602130971415278110567256446033405e-1
++a[17, 15] = 0.
++a[17, 16] = .2718171570208501807097257892166705118335e-1
++
++c[18] = .888
++
++a[18, 0] = .1302453943114338366054520296881099431474e-1
++a[18, 1] = 0.
++a[18, 2] = 0.
++a[18, 3] = 0.
++a[18, 4] = 0.
++a[18, 5] = 0.
++a[18, 6] = 0.
++a[18, 7] = -.7452850902413112085299330666038981625179
++a[18, 8] = .2643867896429300961465132150322749722129
++a[18, 9] = .1313961758372753932588328082078842388890
++a[18, 10] = .2167253815122927263092467187957410643315
++a[18, 11] = .8734117564076052559016338094938888451419
++a[18, 12] = .1185905643935776688228545787724340848142e-1
++a[18, 13] = .5876002941689550612992712203494447529933e-1
++a[18, 14] = .3266518630202087866399279690939423159022e-2
++a[18, 15] = 0.
++a[18, 16] = -.8959308648417929824525368306101792182274e-2
++a[18, 17] = .6941415157202692219907482080827253287034e-1
++
++c[19] = .696
++
++a[19, 0] = .1397089996925942721283716334050740168797e-1
++a[19, 1] = 0.
++a[19, 2] = 0.
++a[19, 3] = 0.
++a[19, 4] = 0.
++a[19, 5] = 0.
++a[19, 6] = 0.
++a[19, 7] = -.4665765335957674596054673402956853940520
++a[19, 8] = .2416372787216257077935214889875485248580
++a[19, 9] = .1290363341345674735721677437066933999929
++a[19, 10] = .2216700671735105311080225734522323922813
++a[19, 11] = .6257275123364644931771253383573999863003
++a[19, 12] = .4355312415679284117869124964829805160429e-1
++a[19, 13] = .1011962491667290833450024852274278874501
++a[19, 14] = .1808582254679721049279369742685497400353e-1
++a[19, 15] = 0.
++a[19, 16] = -.2079875587689169691156509689282083267654e-1
++a[19, 17] = -.9022232517086218976198252891464664868640e-1
++a[19, 18] = -.1212796735622254216011467740438097427634
++
++c[20] = .487
++
++a[20, 0] = .1604638888318112738641232352800290501904e-1
++a[20, 1] = 0.
++a[20, 2] = 0.
++a[20, 3] = 0.
++a[20, 4] = 0.
++a[20, 5] = 0.
++a[20, 6] = 0.
++a[20, 7] = .9517712399458336651642257453589397190702e-1
++a[20, 8] = .1359187264655317806136927180199100622471
++a[20, 9] = .1237765280959854006935081364365637515893
++a[20, 10] = .2335656264102966047058755123098072346246
++a[20, 11] = -.9051508172625873314662090873741762206189e-1
++a[20, 12] = -.2537574270006131028513276914038326155331e-1
++a[20, 13] = -.1359631696887162048002744757083947500478
++a[20, 14] = -.4679214284145113075088049469061349990847e-1
++a[20, 15] = 0.
++a[20, 16] = .5177958859391748239949773879090325427473e-1
++a[20, 17] = .9672595677476773313884172931875718705561e-1
++a[20, 18] = .1477312690340742769720989417101989769314
++a[20, 19] = -.1150750712958503934434410263732282100773
++c[21] = .25e-1
++
++a[21, 0] = .1802918623893620731908165792176564180038e-1
++a[21, 1] = 0.
++a[21, 2] = 0.
++a[21, 3] = 0.
++a[21, 4] = 0.
++a[21, 5] = 0.
++a[21, 6] = 0.
++a[21, 7] = .6983601042028873702545973390560096201728e-1
++a[21, 8] = -.2541247660791663512384395986842781657182e-1
++a[21, 9] = .8487827035463274491721441398893680307535e-2
++a[21, 10] = -.2427525516089801645451101966852425715128e-2
++a[21, 11] = -.1047839752893819879012607694745789515746
++a[21, 12] = -.1473147795248041942353840372690095884761e-1
++a[21, 13] = -.3916338390816177165706892282751065537530e-1
++a[21, 14] = -.1005657343293959419073236542225421561652e-1
++a[21, 15] = 0.
++a[21, 16] = .1102510392204834322538452331445716455061e-1
++a[21, 17] = .5092830749095398308703438556315975226108e-2
++a[21, 18] = .4759715599420644505591133410826632557391e-1
++a[21, 19] = .3386307003288382751110965442296681690349e-1
++a[21, 20] = .2764422831404797700452373965825845732168e-1
++
++c[22] = .15
++
++a[22, 0] = .1677431640522778042988664067637191163626e-1
++a[22, 1] = 0.
++a[22, 2] = 0.
++a[22, 3] = 0.
++a[22, 4] = 0.
++a[22, 5] = 0.
++a[22, 6] = 0.
++a[22, 7] = .6220437408820475326702539861577894278533
++a[22, 8] = -.2060859809768841878234097076241307428139
++a[22, 9] = .1156394989766058889629372195583391792474
++a[22, 10] = .2664101793378358946544219293685167025971e-1
++a[22, 11] = -.9376810793418770527505892794460093668860
++a[22, 12] = -.1367806466702160302637074581619101741312
++a[22, 13] = -.3678480995268296672182605288991379118419
++a[22, 14] = -.9547871314402478902820445838193201497337e-1
++a[22, 15] = 0.
++a[22, 16] = .1013492018422369748729008873270013785313
++a[22, 17] = -.8911323084568593396468400926074881389560e-1
++a[22, 18] = .4664140988974760478895528270623735057521
++a[22, 19] = .4502736292354579812232681662308722738519
++a[22, 20] = .1838522463326818655346135218242696774099
++a[22, 21] = 0.
++
++c[23] = .32
++
++a[23, 0] = .1071149731491444187554380927165768658192e-1
++a[23, 1] = 0.
++a[23, 2] = 0.
++a[23, 3] = 0.
++a[23, 4] = 0.
++a[23, 5] = 0.
++a[23, 6] = 0.
++a[23, 7] = -.7094336118221108191937165464264324417735e-1
++a[23, 8] = .1002164900340091596740582334112699697590
++a[23, 9] = .1383453980468025108839271214703390659581
++a[23, 10] = .1796330633578163411338104055485109917477
++a[23, 11] = .9048246545576180974879274948815422276563e-1
++a[23, 12] = -.5460662294523338383345981122023862069115e-2
++a[23, 13] = -.3000457905119619782973021046143166498567e-1
++a[23, 14] = -.1145192026962799093665613252151017277867e-1
++a[23, 15] = 0.
++a[23, 16] = .1003394686109385076849515422360600302176e-1
++a[23, 17] = -.9506485282809046129031027932806241113157e-1
++a[23, 18] = .4853358804093591445756711642658478691640e-1
++a[23, 19] = .8013325919783924638483373011297347396327e-1
++a[23, 20] = -.1251643326835242045676140618774248455713
++a[23, 21] = 0.
++a[23, 22] = 0.
++
++c[24] = .78
++
++a[24, 0] = .1410172088869221367153586187761994182069e-1
++a[24, 1] = 0.
++a[24, 2] = 0.
++a[24, 3] = 0.
++a[24, 4] = 0.
++a[24, 5] = 0.
++a[24, 6] = 0.
++a[24, 7] = -.3713379753704491105936205420001801316029
++a[24, 8] = .2231265548117180273161442520179150684520
++a[24, 9] = .1287005345918120122888629169443916280865
++a[24, 10] = .2224600659675494761192249831098918110654
++a[24, 11] = .5382853042550701952740528638168708946100
++a[24, 12] = .5417202616988763101781128062036252796548e-1
++a[24, 13] = .1256968791308743925752109039299467082975
++a[24, 14] = .2784492789002054061504430663197543089132e-1
++a[24, 15] = 0.
++a[24, 16] = -.3077409246205059733390460511525401688205e-1
++a[24, 17] = .8569805293689777608077303071761466118035e-2
++a[24, 18] = -.1535174690587044615794997685221990516897
++a[24, 19] = -.2179957030548196497189489878038029238243e-1
++a[24, 20] = .1447128819737186799295514239727801525027e-1
++a[24, 21] = 0.
++a[24, 22] = 0.
++a[24, 23] = 0.
++
++c[25] = .96
++
++a[25, 0] = .1424600411735646609296566581447532773183e-1
++a[25, 1] = 0.
++a[25, 2] = 0.
++a[25, 3] = 0.
++a[25, 4] = 0.
++a[25, 5] = 0.
++a[25, 6] = 0.
++a[25, 7] = -.3767107393295407091303982522049390741260
++a[25, 8] = .2252399780730421480874737297000189000070
++a[25, 9] = .1283603076292529988314451246143633426068
++a[25, 10] = .2230238705261692544876826347415151339678
++a[25, 11] = .5463127827750747224899202176094949607118
++a[25, 12] = .5526190791375779994553849469706124289752e-1
++a[25, 13] = .1285613508749982456581494397108686240388
++a[25, 14] = .2857250681296406482698934635829147899039e-1
++a[25, 15] = 0.
++a[25, 16] = -.2398761886357108720930416967644499057175e-1
++a[25, 17] = .5556224458910509454379297181908734648749e-1
++a[25, 18] = -.1740675650762838674257930398070760254668e-1
++a[25, 19] = -.3815462365996979065575121886854199471011e-1
++a[25, 20] = .1111878504898917877407531966545730451506e-1
++a[25, 21] = 0.
++a[25, 22] = 0.
++a[25, 23] = 0.
++a[25, 24] = 0.
++
++bi[0, 0] = 1.
++bi[0, 1] = -28.33048870061739823290767301658881994700
++bi[0, 2] = 257.6535452078577977252092979905248156497
++bi[0, 3] = -1152.154455743457311528752964691951881858
++bi[0, 4] = 2909.390878345408890936564599116550031880
++bi[0, 5] = -4355.005172868188498048946108887283528629
++bi[0, 6] = 3834.083497036262189455855371796461857871
++bi[0, 7] = -1835.419052683407081215583427992189311730
++bi[0, 8] = 368.7958613829998340610814211036270246107
++
++bi[1, 0] = 0.
++bi[1, 1] = 0.
++bi[1, 2] = 0.
++bi[1, 3] = 0.
++bi[1, 4] = 0.
++bi[1, 5] = 0.
++bi[1, 6] = 0.
++bi[1, 7] = 0.
++bi[1, 8] = 0.
++
++bi[2, 0] = 0.
++bi[2, 1] = 0.
++bi[2, 2] = 0.
++bi[2, 3] = 0.
++bi[2, 4] = 0.
++bi[2, 5] = 0.
++bi[2, 6] = 0.
++bi[2, 7] = 0.
++bi[2, 8] = 0.
++
++bi[3, 0] = 0.
++bi[3, 1] = 0.
++bi[3, 2] = 0.
++bi[3, 3] = 0.
++bi[3, 4] = 0.
++bi[3, 5] = 0.
++bi[3, 6] = 0.
++bi[3, 7] = 0.
++bi[3, 8] = 0.
++
++bi[4, 0] = 0.
++bi[4, 1] = 0.
++bi[4, 2] = 0.
++bi[4, 3] = 0.
++bi[4, 4] = 0.
++bi[4, 5] = 0.
++bi[4, 6] = 0.
++bi[4, 7] = 0.
++bi[4, 8] = 0.
++
++bi[5, 0] = 0.
++bi[5, 1] = 0.
++bi[5, 2] = 0.
++bi[5, 3] = 0.
++bi[5, 4] = 0.
++bi[5, 5] = 0.
++bi[5, 6] = 0.
++bi[5, 7] = 0.
++bi[5, 8] = 0.
++
++bi[6, 0] = 0.
++bi[6, 1] = 0.
++bi[6, 2] = 0.
++bi[6, 3] = 0.
++bi[6, 4] = 0.
++bi[6, 5] = 0.
++bi[6, 6] = 0.
++bi[6, 7] = 0.
++bi[6, 8] = 0.
++
++bi[7, 0] = 0.
++bi[7, 1] = 2.649656243770091212685381903551424676261
++bi[7, 2] = -96.30312807816005963630382777245983513008
++bi[7, 3] = 869.3095462492795755338599928089438369769
++bi[7, 4] = -3395.688567551074115525201961265641584358
++bi[7, 5] = 6796.933987158715680563278170147156885480
++bi[7, 6] = -7340.848417712071304684606060804637321789
++bi[7, 7] = 4082.848896992365666259441580054990759905
++bi[7, 8] = -919.2934944890586676320942978986329899642
++
++bi[8, 0] = 0.
++bi[8, 1] = -1.563945181928732780647121505551017046606
++bi[8, 2] = 56.84239739272860000194549791973820565214
++bi[8, 3] = -513.1052300304284642178552372517916694426
++bi[8, 4] = 2004.286702110323162741493515173880535381
++bi[8, 5] = -4011.853305913929339500285683507736138334
++bi[8, 6] = 4332.895839278586189971336003691596594090
++bi[8, 7] = -2409.879347937144606091337260195738587773
++bi[8, 8] = 542.6079835318221405169412532400889768401
++
++bi[9, 0] = 0.
++bi[9, 1] = -.8627103334967223830653368770735555216700
++bi[9, 2] = 31.35565375185173442495465167501846267906
++bi[9, 3] = -283.0413682227354209126847112083546012674
++bi[9, 4] = 1105.613463426006937052739159664962261462
++bi[9, 5] = -2213.036200678452629288185991597653042989
++bi[9, 6] = 2390.131097754120588994847482867886207858
++bi[9, 7] = -1329.348266146873716496636094950745123424
++bi[9, 8] = 299.3158071265785138462868993727082901209
++
++bi[10, 0] = 0.
++bi[10, 1] = -1.520295337901214839055193576160469820911
++bi[10, 2] = 55.25592121120227100440616045452813504748
++bi[10, 3] = -498.7844190970740738969945498750124435385
++bi[10, 4] = 1948.346888525776056658403461666308795237
++bi[10, 5] = -3899.882136407551390287649940376076923682
++bi[10, 6] = 4211.964345158858030803618536151121927765
++bi[10, 7] = -2342.619408856117128087568672414857706561
++bi[10, 8] = 527.4637482204278644179968961638568925209
++
++bi[11, 0] = 0.
++bi[11, 1] = -3.846938844125523400516071820264700141179
++bi[11, 2] = 139.8189840986840520353362018994734906611
++bi[11, 3] = -1262.118687621600386514715930156791825893
++bi[11, 4] = 4930.075848057311658057235318456802793199
++bi[11, 5] = -9868.219486069539059368988308801366826185
++bi[11, 6] = 10657.90892434886730229746304583865145121
++bi[11, 7] = -5927.738759872814112912292792695856187255
++bi[11, 8] = 1334.688551172190921099749059976639173619
++
++bi[12, 0] = 0.
++bi[12, 1] = -.3942713061200141454309326713125653612517
++bi[12, 2] = 14.32999476067649707020689155180345562459
++bi[12, 3] = -129.3540665994558117853022852051786116929
++bi[12, 4] = 505.2816077002517600897861155496606850457
++bi[12, 5] = -1011.390080139433268878243655218566636574
++bi[12, 6] = 1092.325051781891697669369143688906543465
++bi[12, 7] = -607.5317019302810290917918493845279272648
++bi[12, 8] = 136.7917244480423273434147193694336909663
++
++bi[13, 0] = 0.
++bi[13, 1] = -.9233145622082101394378429409444333268499
++bi[13, 2] = 33.55834582309798808260613735851232640640
++bi[13, 3] = -302.9246397549735936661321348695774835448
++bi[13, 4] = 1183.281306967867553342903125095128753568
++bi[13, 5] = -2368.498986790111516106072390247333149007
++bi[13, 6] = 2558.034559755808027369106332027405169828
++bi[13, 7] = -1422.733175577880214903071122439856598476
++bi[13, 8] = 320.3423358787481875842587982911148385364
++
++bi[14, 0] = 0.
++bi[14, 1] = -.2068862802930053801253649628830330891017
++bi[14, 2] = 7.519388975651662772174695012120581518594
++bi[14, 3] = -67.87605708082904058354114755731111898667
++bi[14, 4] = 265.1367996984150421661637988925923843021
++bi[14, 5] = -530.7074807559025368587558119659212235622
++bi[14, 6] = 573.1765495641490277116961329189087439579
++bi[14, 7] = -318.7905688834868978004500126002971837241
++bi[14, 8] = 71.77882490212657594681492031347005327988
++
++bi[15, 0] = 0.
++bi[15, 1] = 0.
++bi[15, 2] = 0.
++bi[15, 3] = 0.
++bi[15, 4] = 0.
++bi[15, 5] = 0.
++bi[15, 6] = 0.
++bi[15, 7] = 0.
++bi[15, 8] = 0.
++
++bi[16, 0] = 0.
++bi[16, 1] = -.4472441906744099441704338175964823026105
++bi[16, 2] = 16.44684676010503791623763886833381020592
++bi[16, 3] = -154.4086105921295528355180056633078150675
++bi[16, 4] = 641.8986298540248497333509289273669726482
++bi[16, 5] = -1391.939225687982391028602609567895699003
++bi[16, 6] = 1643.890568302952013019278202625162156841
++bi[16, 7] = -1004.065297223317845596795060426393517046
++bi[16, 8] = 248.6243327770222987362193390543305737239
++
++bi[17, 0] = 0.
++bi[17, 1] = -.1507876007899797948720901584434839156279
++bi[17, 2] = 5.527328824824632235316362126620825363280
++bi[17, 3] = -51.33833743084618751433903968701557585387
++bi[17, 4] = 209.6022002703280347991393999433060881829
++bi[17, 5] = -442.7692650421825928714839983614217797969
++bi[17, 6] = 505.0579312588052893780948070449787925777
++bi[17, 7] = -295.6336410615619366143935619944592839974
++bi[17, 8] = 69.70457078142274038253812108643441743987
++
++bi[18, 0] = 0.
++bi[18, 1] = -.6413652207435296452288504944964177537185
++bi[18, 2] = 23.51013248624684600263471193689787394701
++bi[18, 3] = -218.3642683246972281497485359238725613162
++bi[18, 4] = 891.5292818535365634586829868055833114383
++bi[18, 5] = -1883.290177206007885518558760085145850658
++bi[18, 6] = 2148.230954488399755970660772306573864434
++bi[18, 7] = -1257.458401521712336970840850120592935471
++bi[18, 8] = 296.4838434449778148523985255750527153802
++
++bi[19, 0] = 0.
++bi[19, 1] = 1.810729313444845732964058528284532356045
++bi[19, 2] = -66.37479657295337371220255196726289169374
++bi[19, 3] = 616.4952025401106511929691356878863855003
++bi[19, 4] = -2517.003030777322559684753470471663859295
++bi[19, 5] = 5316.984175781033401491488704359579721604
++bi[19, 6] = -6064.976140789574108556866601189158423779
++bi[19, 7] = 3550.109538888391317555902194852386816092
++bi[19, 8] = -837.0456783831301740195014698000522807852
++
++bi[20, 0] = 0.
++bi[20, 1] = .5176008760353717918864555990277480363987e-1
++bi[20, 2] = -1.897337862580348756406065418550014243949
++bi[20, 3] = 17.62264820793629244181715147639285955422
++bi[20, 4] = -71.94907400242465946110661282550878163878
++bi[20, 5] = 151.9871383765666045085018751235590550206
++bi[20, 6] = -173.3686498747860565970136435029707518663
++bi[20, 7] = 101.4806461521468075879782291473158292931
++bi[20, 8] = -23.92713108446217690295957956014097092250
++
++bi[21, 0] = 0.
++bi[21, 1] = 31.32178255668799909977422939838912846070
++bi[21, 2] = -355.6570858339106059687054319211280026146
++bi[21, 3] = 1752.685282489515979253875884672206842255
++bi[21, 4] = -4708.092293138363367969732154806019707156
++bi[21, 5] = 7370.900776193488713149861391844801840850
++bi[21, 6] = -6716.504964764565347011489385051202629762
++bi[21, 7] = 3303.940398161185772296756776169088470785
++bi[21, 8] = -678.5938956640391428503413103061359428182
++
++bi[22, 0] = 0.
++bi[22, 1] = -2.719607334185924760747802644504744092917
++bi[22, 2] = 86.64045615858264001154848875638486632034
++bi[22, 3] = -454.1926030939030807863651114984001402596
++bi[22, 4] = 1014.749221100543425314268817989377200147
++bi[22, 5] = -1133.583456714543865890388885909333783663
++bi[22, 6] = 610.4671827718666569168001429679645990946
++bi[22, 7] = -109.0233499449543802317396567002119357593
++bi[22, 8] = -12.33784294340547057337599296127606178639
++
++bi[23, 0] = 0.
++bi[23, 1] = 3.177214801432923432265738869490200556403
++bi[23, 2] = -113.8098697715142983214434051918276259885
++bi[23, 3] = 978.0935981825675014833003847211971070224
++bi[23, 4] = -3575.129377623670076451027372711378100786
++bi[23, 5] = 6764.361519838450570830405988615992045681
++bi[23, 6] = -6987.161043852012362644872233028628887679
++bi[23, 7] = 3751.905762789571137088934326513342858381
++bi[23, 8] = -821.4378043648253954175634277881875971878
++
++bi[24, 0] = 0.
++bi[24, 1] = .8772843083465530069477626269697233842708
++bi[24, 2] = -31.51810423988375104361582759389916060143
++bi[24, 3] = 273.1229151353221133842213845530391043248
++bi[24, 4] = -993.2198643101781966584366870874238565290
++bi[24, 5] = 1787.888078312663987193988385659681964836
++bi[24, 6] = -1677.394835799640950953367739332661886275
++bi[24, 7] = 781.3579535062687952504707744453846824540
++bi[24, 8] = -141.1134269128985501802080532710905715931
++
++bi[25, 0] = 0.
++bi[25, 1] = 1.719427581798715782378897599231938082126
++bi[25, 2] = -62.89867309250732184389962568482931880335
++bi[25, 3] = 580.3335507873980391019057196688995930872
++bi[25, 4] = -2348.110620506760958600472968113883922730
++bi[25, 5] = 4921.119298612906015908637628774963068611
++bi[25, 6] = -5597.912448707916639109910311016358007839
++bi[25, 7] = 3288.597775149621789973016480733216881572
++bi[25, 8] = -782.8483098245396412116558219612402319811
++
++vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
+diff --git a/qutip/solver/krylovsolve.py b/qutip/solver/krylovsolve.py
+index 99fa78b2..4d14262c 100644
+--- a/qutip/solver/krylovsolve.py
++++ b/qutip/solver/krylovsolve.py
+@@ -1,102 +1,102 @@
+-__all__ = ['krylovsolve']
+-
+-from .. import QobjEvo
+-from .sesolve import SESolver
+-
+-
+-def krylovsolve(
+-    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
+-):
+-    """
+-    Schrodinger equation evolution of a state vector for time independent
+-    Hamiltonians using Krylov method.
+-
+-    Evolve the state vector ("psi0") finding an approximation for the time
+-    evolution operator of Hamiltonian ("H") by obtaining the projection of
+-    the time evolution operator on a set of small dimensional Krylov
+-    subspaces (m << dim(H)).
+-
+-    The output is either the state vector or unitary matrix at arbitrary points
+-    in time (`tlist`), or the expectation values of the supplied operators
+-    (`e_ops`). If e_ops is a callback function, it is invoked for each
+-    time in `tlist` with time and the state as arguments, and the function
+-    does not use any return values. e_ops cannot be used in conjunction
+-    with solving the Schrodinger operator equation
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+-        that can be made into :class:`QobjEvo` are also accepted.
+-
+-    psi0 : :class:`qutip.qobj`
+-        initial state vector (ket)
+-        or initial unitary operator `psi0 = U`
+-
+-    tlist : *list* / *array*
+-        list of times for :math:`t`.
+-
+-    krylov_dim: int
+-        Dimension of Krylov approximation subspaces used for the time
+-        evolution approximation.
+-
+-    e_ops : :class:`qutip.qobj`, callable, or list.
+-        Single operator or list of operators for which to evaluate
+-        expectation values or callable or list of callable.
+-        Callable signature must be, `f(t: float, state: Qobj)`.
+-        See :func:`expect` for more detail of operator expectation.
+-
+-    args : None / *dictionary*
+-        dictionary of parameters for time-dependent Hamiltonians
+-
+-    options : None / dict
+-        Dictionary of options for the solver.
+-
+-        - store_final_state : bool, [False]
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, [None]
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - normalize_output : bool, [True]
+-          Normalize output state to hide ODE numerical errors.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict, [{"chunk_size": 10}]
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - atol: float [1e-7]
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps : int [100]
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - min_step, max_step : float, [1e-5, 1e5]
+-          Miniumum and maximum lenght of one internal step.
+-        - always_compute_step: bool [False]
+-          If True, the step lenght is computed each time a new Krylov
+-          subspace is computed. Otherwise it is computed only once when
+-          creating the integrator.
+-        - sub_system_tol: float, [1e-7]
+-          Tolerance to detect an happy breakdown. An happy breakdown happens
+-          when the initial ket is in a subspace of the Hamiltonian smaller
+-          than ``krylov_dim``.
+-
+-    Returns
+-    -------
+-    result: :class:`qutip.Result`
+-
+-        An instance of the class :class:`qutip.Result`, which contains
+-        a *list of array* `result.expect` of expectation values for the times
+-        specified by `tlist`, and/or a *list* `result.states` of state vectors
+-        or density matrices corresponding to the times in `tlist` [if `e_ops`
+-        is an empty list of `store_states=True` in options].
+-    """
+-    H = QobjEvo(H, args=args, tlist=tlist)
+-    options = options or {}
+-    options["method"] = "krylov"
+-    options["krylov_dim"] = krylov_dim
+-    solver = SESolver(H, options=options)
+-    return solver.run(psi0, tlist, e_ops=e_ops)
++__all__ = ['krylovsolve']
++
++from .. import QobjEvo
++from .sesolve import SESolver
++
++
++def krylovsolve(
++    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
++):
++    """
++    Schrodinger equation evolution of a state vector for time independent
++    Hamiltonians using Krylov method.
++
++    Evolve the state vector ("psi0") finding an approximation for the time
++    evolution operator of Hamiltonian ("H") by obtaining the projection of
++    the time evolution operator on a set of small dimensional Krylov
++    subspaces (m << dim(H)).
++
++    The output is either the state vector or unitary matrix at arbitrary points
++    in time (`tlist`), or the expectation values of the supplied operators
++    (`e_ops`). If e_ops is a callback function, it is invoked for each
++    time in `tlist` with time and the state as arguments, and the function
++    does not use any return values. e_ops cannot be used in conjunction
++    with solving the Schrodinger operator equation
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
++        System Hamiltonian as a Qobj or QobjEvo for time-dependent
++        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
++        that can be made into :class:`QobjEvo` are also accepted.
++
++    psi0 : :class:`qutip.qobj`
++        initial state vector (ket)
++        or initial unitary operator `psi0 = U`
++
++    tlist : *list* / *array*
++        list of times for :math:`t`.
++
++    krylov_dim: int
++        Dimension of Krylov approximation subspaces used for the time
++        evolution approximation.
++
++    e_ops : :class:`qutip.qobj`, callable, or list.
++        Single operator or list of operators for which to evaluate
++        expectation values or callable or list of callable.
++        Callable signature must be, `f(t: float, state: Qobj)`.
++        See :func:`expect` for more detail of operator expectation.
++
++    args : None / *dictionary*
++        dictionary of parameters for time-dependent Hamiltonians
++
++    options : None / dict
++        Dictionary of options for the solver.
++
++        - store_final_state : bool, [False]
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, [None]
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - normalize_output : bool, [True]
++          Normalize output state to hide ODE numerical errors.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict, [{"chunk_size": 10}]
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - atol: float [1e-7]
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps : int [100]
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - min_step, max_step : float, [1e-5, 1e5]
++          Miniumum and maximum lenght of one internal step.
++        - always_compute_step: bool [False]
++          If True, the step lenght is computed each time a new Krylov
++          subspace is computed. Otherwise it is computed only once when
++          creating the integrator.
++        - sub_system_tol: float, [1e-7]
++          Tolerance to detect an happy breakdown. An happy breakdown happens
++          when the initial ket is in a subspace of the Hamiltonian smaller
++          than ``krylov_dim``.
++
++    Returns
++    -------
++    result: :class:`qutip.Result`
++
++        An instance of the class :class:`qutip.Result`, which contains
++        a *list of array* `result.expect` of expectation values for the times
++        specified by `tlist`, and/or a *list* `result.states` of state vectors
++        or density matrices corresponding to the times in `tlist` [if `e_ops`
++        is an empty list of `store_states=True` in options].
++    """
++    H = QobjEvo(H, args=args, tlist=tlist)
++    options = options or {}
++    options["method"] = "krylov"
++    options["krylov_dim"] = krylov_dim
++    solver = SESolver(H, options=options)
++    return solver.run(psi0, tlist, e_ops=e_ops)
+diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
+index bc3369b9..f1a55bf2 100644
+--- a/qutip/solver/mcsolve.py
++++ b/qutip/solver/mcsolve.py
+@@ -1,527 +1,527 @@
+-__all__ = ['mcsolve', "MCSolver"]
+-
+-import warnings
+-
+-import numpy as np
+-from copy import copy
+-from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
+-from .multitraj import MultiTrajSolver
+-from .solver_base import Solver
+-from .result import McResult, Result
+-from .mesolve import mesolve, MESolver
+-import qutip.core.data as _data
+-from time import time
+-
+-
+-def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
+-            args=None, options=None, seeds=None, target_tol=None, timeout=None):
+-    r"""
+-    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
+-    given Hamiltonian and sets of collapse operators. Options for the
+-    underlying ODE solver are given by the Options class.
+-
+-    Parameters
+-    ----------
+-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+-        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+-        ``H`` can also be a superoperator (liouvillian) if some collapse
+-        operators are to be treated deterministically.
+-
+-    state : :class:`qutip.Qobj`
+-        Initial state vector.
+-
+-    tlist : array_like
+-        Times at which results are recorded.
+-
+-    c_ops : list
+-        A ``list`` of collapse operators in any input type that QobjEvo accepts
+-        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
+-        even if ``H`` is a superoperator. If none are given, the solver will
+-        defer to ``sesolve`` or ``mesolve``.
+-
+-    e_ops : list, [optional]
+-        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
+-        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
+-        are given, the solver will default to save the states.
+-
+-    ntraj : int
+-        Maximum number of trajectories to run. Can be cut short if a time limit
+-        is passed with the ``timeout`` keyword or if the target tolerance is
+-        reached, see ``target_tol``.
+-
+-    args : None / dict
+-        Arguments for time-dependent Hamiltonian and collapse operator terms.
+-
+-    options : None / dict
+-        Dictionary of options for the solver.
+-
+-        - store_final_state : bool [False]
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, NoneType, [None]
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict, [{"chunk_size": 10}]
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
+-          Which differential equation integration method to use.
+-        - keep_runs_results : bool, [False]
+-          Whether to store results from all trajectories or just store the
+-          averages.
+-        - map : str {"serial", "parallel", "loky"}, ["serial"]
+-          How to run the trajectories. "parallel" uses concurent module to run
+-          in parallel while "loky" use the module of the same name to do so.
+-        - job_timeout : NoneType, int, [None]
+-          Maximum time to compute one trajectory.
+-        - num_cpus : NoneType, int, [None]
+-          Number of cpus to use when running in parallel. ``None`` detect the
+-          number of available cpus.
+-        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
+-          Parameters used to find the collapse location. ``norm_t_tol`` and
+-          ``norm_tol`` are the tolerance in time and norm respectively.
+-          An error will be raised if the collapse could not be found within
+-          ``norm_steps`` tries.
+-        - mc_corr_eps : float, [1e-10]
+-          Small number used to detect non-physical collapse caused by numerical
+-          imprecision.
+-        - atol, rtol : float, [1e-8, 1e-6]
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps : int [2500]
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - max_step : float, [0]
+-          Maximum lenght of one internal step. When using pulses, it should be
+-          less than half the width of the thinnest pulse.
+-
+-    seeds : int, SeedSequence, list, [optional]
+-        Seed for the random number generator. It can be a single seed used to
+-        spawn seeds for each trajectory or a list of seeds, one for each
+-        trajectory. Seeds are saved in the result and they can be reused with::
+-
+-            seeds=prev_result.seeds
+-
+-    target_tol : {float, tuple, list}, optional
+-        Target tolerance of the evolution. The evolution will compute
+-        trajectories until the error on the expectation values is lower than
+-        this tolerance. The maximum number of trajectories employed is
+-        given by ``ntraj``. The error is computed using jackknife resampling.
+-        ``target_tol`` can be an absolute tolerance or a pair of absolute and
+-        relative tolerance, in that order. Lastly, it can be a list of pairs of
+-        (atol, rtol) for each e_ops.
+-
+-    timeout : float [optional]
+-        Maximum time for the evolution in second. When reached, no more
+-        trajectories will be computed. Overwrite the option of the same name.
+-
+-    Returns
+-    -------
+-    results : :class:`qutip.solver.Result`
+-        Object storing all results from the simulation. Which results is saved
+-        depends on the presence of ``e_ops`` and the options used. ``collapse``
+-        and ``photocurrent`` is available to Monte Carlo simulation results.
+-
+-    .. note:
+-        The simulation will end when the first end condition is reached between
+-        ``ntraj``, ``timeout`` and ``target_tol``.
+-    """
+-    H = QobjEvo(H, args=args, tlist=tlist)
+-    if not isinstance(c_ops, (list, tuple)):
+-        c_ops = [c_ops]
+-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+-
+-    if len(c_ops) == 0:
+-        if options is None:
+-            options = {}
+-        options = {
+-            key: options[key]
+-            for key in options
+-            if key in MESolver.solver_options
+-        }
+-        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
+-                       options=options)
+-
+-    if isinstance(ntraj, (list, tuple)):
+-        raise TypeError(
+-            "ntraj must be an integer. "
+-            "A list of numbers is not longer supported."
+-        )
+-
+-    mc = MCSolver(H, c_ops, options=options)
+-    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
+-                    seed=seeds, target_tol=target_tol, timeout=timeout)
+-    return result
+-
+-
+-class MCIntegrator:
+-    """
+-    Integrator like object for mcsolve trajectory.
+-    """
+-    name = "mcsolve"
+-
+-    def __init__(self, integrator, c_ops, n_ops, options=None):
+-        self._integrator = integrator
+-        self._c_ops = c_ops
+-        self._n_ops = n_ops
+-        self.options = options
+-        self._generator = None
+-        self.method = f"{self.name} {self._integrator.method}"
+-        self._is_set = False
+-        self.issuper = c_ops[0].issuper
+-
+-    def set_state(self, t, state0, generator):
+-        """
+-        Set the state of the ODE solver.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Initial time
+-
+-        state0 : qutip.Data
+-            Initial state.
+-
+-        generator : numpy.random.generator
+-            Random number generator.
+-        """
+-        self.collapses = []
+-        self._generator = generator
+-        self.target_norm = self._generator.random()
+-        self._integrator.set_state(t, state0)
+-        self._is_set = True
+-
+-    def get_state(self, copy=True):
+-        return *self._integrator.get_state(copy), self._generator
+-
+-    def integrate(self, t, copy=False):
+-        t_old, y_old = self._integrator.get_state(copy=False)
+-        norm_old = self._prob_func(y_old)
+-        while t_old < t:
+-            t_step, state = self._integrator.mcstep(t, copy=False)
+-            norm = self._prob_func(state)
+-            if norm <= self.target_norm:
+-                t_col, state = self._find_collapse_time(norm_old, norm,
+-                                                        t_old, t_step)
+-                self._do_collapse(t_col, state)
+-                t_old, y_old = self._integrator.get_state(copy=False)
+-                norm_old = 1.
+-            else:
+-                t_old, y_old = t_step, state
+-                norm_old = norm
+-
+-        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
+-
+-    def run(self, tlist):
+-        for t in tlist[1:]:
+-            yield self.integrate(t, False)
+-
+-    def reset(self, hard=False):
+-        self._integrator.reset(hard)
+-
+-    def _prob_func(self, state):
+-        if self.issuper:
+-            return _data.trace_oper_ket(state).real
+-        return _data.norm.l2(state)**2
+-
+-    def _norm_func(self, state):
+-        if self.issuper:
+-            return _data.trace_oper_ket(state).real
+-        return _data.norm.l2(state)
+-
+-    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
+-        """Find the time of the collapse and state just before it."""
+-        tries = 0
+-        while tries < self.options['norm_steps']:
+-            tries += 1
+-            if (t_final - t_prev) < self.options['norm_t_tol']:
+-                t_guess = t_final
+-                _, state = self._integrator.get_state()
+-                break
+-            t_guess = (
+-                t_prev
+-                + ((t_final - t_prev)
+-                   * np.log(norm_old / self.target_norm)
+-                   / np.log(norm_old / norm))
+-            )
+-            if (t_guess - t_prev) < self.options['norm_t_tol']:
+-                t_guess = t_prev + self.options['norm_t_tol']
+-            _, state = self._integrator.mcstep(t_guess, copy=False)
+-            norm2_guess = self._prob_func(state)
+-            if (
+-                np.abs(self.target_norm - norm2_guess) <
+-                self.options['norm_tol'] * self.target_norm
+-            ):
+-                break
+-            elif (norm2_guess < self.target_norm):
+-                # t_guess is still > t_jump
+-                t_final = t_guess
+-                norm = norm2_guess
+-            else:
+-                # t_guess < t_jump
+-                t_prev = t_guess
+-                norm_old = norm2_guess
+-
+-        if tries >= self.options['norm_steps']:
+-            raise RuntimeError(
+-                "Could not find the collapse time within desired tolerance. "
+-                "Increase accuracy of the ODE solver or lower the tolerance "
+-                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
+-
+-        return t_guess, state
+-
+-    def _do_collapse(self, collapse_time, state):
+-        """
+-        Do the collapse:
+-        - Find which operator did the collapse.
+-        - Update the state and Integrator.
+-        - Next collapse norm location
+-        - Store collapse info.
+-        """
+-        # collapse_time, state is at the collapse
+-        if len(self._n_ops) == 1:
+-            which = 0
+-        else:
+-            probs = np.zeros(len(self._n_ops))
+-            for i, n_op in enumerate(self._n_ops):
+-                probs[i] = n_op.expect_data(collapse_time, state).real
+-            probs = np.cumsum(probs)
+-            which = np.searchsorted(probs,
+-                                    probs[-1] * self._generator.random())
+-
+-        state_new = self._c_ops[which].matmul_data(collapse_time, state)
+-        new_norm = self._norm_func(state_new)
+-        if new_norm < self.options['mc_corr_eps']:
+-            # This happen when the collapse is caused by numerical error
+-            state_new = _data.mul(state, 1 / self._norm_func(state))
+-        else:
+-            state_new = _data.mul(state_new, 1 / new_norm)
+-            self.collapses.append((collapse_time, which))
+-            self.target_norm = self._generator.random()
+-        self._integrator.set_state(collapse_time, state_new)
+-
+-    def arguments(self, args):
+-        if args:
+-            self._integrator.arguments(args)
+-            for c_op in self._c_ops:
+-                c_op.arguments(args)
+-            for n_op in self._n_ops:
+-                n_op.arguments(args)
+-
+-    @property
+-    def integrator_options(self):
+-        return self._integrator.integrator_options
+-
+-
+-# -----------------------------------------------------------------------------
+-# MONTE CARLO CLASS
+-# -----------------------------------------------------------------------------
+-class MCSolver(MultiTrajSolver):
+-    r"""
+-    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
+-    given Hamiltonian and sets of collapse operators. Options for the
+-    underlying ODE solver are given by the Options class.
+-
+-    Parameters
+-    ----------
+-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+-        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+-        ``H`` can also be a superoperator (liouvillian) if some collapse
+-        operators are to be treated deterministically.
+-
+-    c_ops : list
+-        A ``list`` of collapse operators in any input type that QobjEvo accepts
+-        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
+-        even if ``H`` is a superoperator.
+-
+-    options : dict, [optional]
+-        Options for the evolution.
+-    """
+-    name = "mcsolve"
+-    resultclass = McResult
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size": 10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "keep_runs_results": False,
+-        "method": "adams",
+-        "map": "serial",
+-        "job_timeout": None,
+-        "num_cpus": None,
+-        "bitgenerator": None,
+-        "mc_corr_eps": 1e-10,
+-        "norm_steps": 5,
+-        "norm_t_tol": 1e-6,
+-        "norm_tol": 1e-4,
+-    }
+-
+-    def __init__(self, H, c_ops, *, options=None):
+-        _time_start = time()
+-
+-        if isinstance(c_ops, (Qobj, QobjEvo)):
+-            c_ops = [c_ops]
+-        c_ops = [QobjEvo(c_op) for c_op in c_ops]
+-
+-        if H.issuper:
+-            self._c_ops = [
+-                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
+-                for c_op in c_ops
+-            ]
+-            self._n_ops = self._c_ops
+-            rhs = QobjEvo(H)
+-            for c_op in c_ops:
+-                cdc = c_op.dag() @ c_op
+-                rhs -= 0.5 * (spre(cdc) + spost(cdc))
+-        else:
+-            self._c_ops = c_ops
+-            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
+-            rhs = -1j * QobjEvo(H)
+-            for n_op in self._n_ops:
+-                rhs -= 0.5 * n_op
+-
+-        self._num_collapse = len(self._c_ops)
+-
+-        super().__init__(rhs, options=options)
+-
+-    def _restore_state(self, data, *, copy=True):
+-        """
+-        Retore the Qobj state from its data.
+-        """
+-        if self._state_metadata['dims'] == self.rhs.dims[1]:
+-            state = Qobj(unstack_columns(data),
+-                         **self._state_metadata, copy=False)
+-        else:
+-            state = Qobj(data, **self._state_metadata, copy=copy)
+-
+-        return state
+-
+-    def _initialize_stats(self):
+-        stats = super()._initialize_stats()
+-        stats.update({
+-            "method": self.options["method"],
+-            "solver": "Master Equation Evolution",
+-            "num_collapse": self._num_collapse,
+-        })
+-        return stats
+-
+-    def _argument(self, args):
+-        self._integrator.arguments(args)
+-        self.rhs.arguments(args)
+-        for c_op in self._c_ops:
+-            c_op.arguments(args)
+-        for n_op in self._n_ops:
+-            n_op.arguments(args)
+-
+-    def _run_one_traj(self, seed, state, tlist, e_ops):
+-        """
+-        Run one trajectory and return the result.
+-        """
+-        # The integrators is reused, but non-reentrant. They are are fine for
+-        # multiprocessing, but will fail with multithreading.
+-        # If a thread base parallel map is created, eahc trajectory should use
+-        # a copy of the integrator.
+-        result = Result(e_ops, {**self.options, "normalize_output": False})
+-        generator = self._get_generator(seed)
+-        self._integrator.set_state(tlist[0], state, generator)
+-        result.add(tlist[0], self._restore_state(state, copy=False))
+-        for t in tlist[1:]:
+-            t, state = self._integrator.integrate(t, copy=False)
+-            result.add(t, self._restore_state(state, copy=False))
+-        result.collapse = self._integrator.collapses
+-        return seed, result
+-
+-    def _get_integrator(self):
+-        _time_start = time()
+-        method = self.options["method"]
+-        if method in self.avail_integrators():
+-            integrator = self.avail_integrators()[method]
+-        elif issubclass(method, Integrator):
+-            integrator = method
+-        else:
+-            raise ValueError("Integrator method not supported.")
+-        integrator_instance = integrator(self.rhs, self.options)
+-        mc_integrator = MCIntegrator(
+-            integrator_instance, self._c_ops, self._n_ops, self.options
+-        )
+-        self._init_integrator_time = time() - _time_start
+-        return mc_integrator
+-
+-    @property
+-    def options(self):
+-        """
+-        Options for monte carlo solver:
+-
+-        store_final_state: bool, default=False
+-            Whether or not to store the final state of the evolution in the
+-            result class.
+-
+-        store_states: bool, default=None
+-            Whether or not to store the state vectors or density matrices.
+-            On `None` the states will be saved if no expectation operators are
+-            given.
+-
+-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+-            How to present the solver progress.
+-            'tqdm' uses the python module of the same name and raise an error if
+-            not installed. Empty string or False will disable the bar.
+-
+-        progress_kwargs: dict, default={"chunk_size":10}
+-            Arguments to pass to the progress_bar. Qutip's bars use
+-            ``chunk_size``.
+-
+-        keep_runs_results: bool
+-          Whether to store results from all trajectories or just store the
+-          averages.
+-
+-        method: str, default="adams"
+-            Which ODE integrator methods are supported.
+-
+-        map: str {"serial", "parallel", "loky"}
+-            How to run the trajectories. "parallel" uses concurent module to
+-            run in parallel while "loky" use the module of the same name to do
+-            so.
+-
+-        job_timeout: None, int
+-            Maximum time to compute one trajectory.
+-
+-        num_cpus: None, int
+-            Number of cpus to use when running in parallel. ``None`` detect the
+-            number of available cpus.
+-
+-        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
+-            Which of numpy.random's bitgenerator to use. With ``None``, your
+-            numpy version's default is used.
+-
+-        mc_corr_eps: float
+-            Small number used to detect non-physical collapse caused by
+-            numerical imprecision.
+-
+-        norm_t_tol: float
+-            Tolerance in time used when finding the collapse.
+-
+-        norm_tol: float
+-            Tolerance in norm used when finding the collapse.
+-
+-        norm_steps: int
+-            Maximum number of tries to find the collapse.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        MultiTrajSolver.options.fset(self, new_options)
+-
+-    @classmethod
+-    def avail_integrators(cls):
+-        if cls is Solver:
+-            return cls._avail_integrators.copy()
+-        return {
+-            **Solver.avail_integrators(),
+-            **cls._avail_integrators,
+-        }
++__all__ = ['mcsolve', "MCSolver"]
++
++import warnings
++
++import numpy as np
++from copy import copy
++from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
++from .multitraj import MultiTrajSolver
++from .solver_base import Solver
++from .result import McResult, Result
++from .mesolve import mesolve, MESolver
++import qutip.core.data as _data
++from time import time
++
++
++def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
++            args=None, options=None, seeds=None, target_tol=None, timeout=None):
++    r"""
++    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
++    given Hamiltonian and sets of collapse operators. Options for the
++    underlying ODE solver are given by the Options class.
++
++    Parameters
++    ----------
++    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
++        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
++        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
++        ``H`` can also be a superoperator (liouvillian) if some collapse
++        operators are to be treated deterministically.
++
++    state : :class:`qutip.Qobj`
++        Initial state vector.
++
++    tlist : array_like
++        Times at which results are recorded.
++
++    c_ops : list
++        A ``list`` of collapse operators in any input type that QobjEvo accepts
++        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
++        even if ``H`` is a superoperator. If none are given, the solver will
++        defer to ``sesolve`` or ``mesolve``.
++
++    e_ops : list, [optional]
++        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
++        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
++        are given, the solver will default to save the states.
++
++    ntraj : int
++        Maximum number of trajectories to run. Can be cut short if a time limit
++        is passed with the ``timeout`` keyword or if the target tolerance is
++        reached, see ``target_tol``.
++
++    args : None / dict
++        Arguments for time-dependent Hamiltonian and collapse operator terms.
++
++    options : None / dict
++        Dictionary of options for the solver.
++
++        - store_final_state : bool [False]
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, NoneType, [None]
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict, [{"chunk_size": 10}]
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
++          Which differential equation integration method to use.
++        - keep_runs_results : bool, [False]
++          Whether to store results from all trajectories or just store the
++          averages.
++        - map : str {"serial", "parallel", "loky"}, ["serial"]
++          How to run the trajectories. "parallel" uses concurent module to run
++          in parallel while "loky" use the module of the same name to do so.
++        - job_timeout : NoneType, int, [None]
++          Maximum time to compute one trajectory.
++        - num_cpus : NoneType, int, [None]
++          Number of cpus to use when running in parallel. ``None`` detect the
++          number of available cpus.
++        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
++          Parameters used to find the collapse location. ``norm_t_tol`` and
++          ``norm_tol`` are the tolerance in time and norm respectively.
++          An error will be raised if the collapse could not be found within
++          ``norm_steps`` tries.
++        - mc_corr_eps : float, [1e-10]
++          Small number used to detect non-physical collapse caused by numerical
++          imprecision.
++        - atol, rtol : float, [1e-8, 1e-6]
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps : int [2500]
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - max_step : float, [0]
++          Maximum lenght of one internal step. When using pulses, it should be
++          less than half the width of the thinnest pulse.
++
++    seeds : int, SeedSequence, list, [optional]
++        Seed for the random number generator. It can be a single seed used to
++        spawn seeds for each trajectory or a list of seeds, one for each
++        trajectory. Seeds are saved in the result and they can be reused with::
++
++            seeds=prev_result.seeds
++
++    target_tol : {float, tuple, list}, optional
++        Target tolerance of the evolution. The evolution will compute
++        trajectories until the error on the expectation values is lower than
++        this tolerance. The maximum number of trajectories employed is
++        given by ``ntraj``. The error is computed using jackknife resampling.
++        ``target_tol`` can be an absolute tolerance or a pair of absolute and
++        relative tolerance, in that order. Lastly, it can be a list of pairs of
++        (atol, rtol) for each e_ops.
++
++    timeout : float [optional]
++        Maximum time for the evolution in second. When reached, no more
++        trajectories will be computed. Overwrite the option of the same name.
++
++    Returns
++    -------
++    results : :class:`qutip.solver.Result`
++        Object storing all results from the simulation. Which results is saved
++        depends on the presence of ``e_ops`` and the options used. ``collapse``
++        and ``photocurrent`` is available to Monte Carlo simulation results.
++
++    .. note:
++        The simulation will end when the first end condition is reached between
++        ``ntraj``, ``timeout`` and ``target_tol``.
++    """
++    H = QobjEvo(H, args=args, tlist=tlist)
++    if not isinstance(c_ops, (list, tuple)):
++        c_ops = [c_ops]
++    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
++
++    if len(c_ops) == 0:
++        if options is None:
++            options = {}
++        options = {
++            key: options[key]
++            for key in options
++            if key in MESolver.solver_options
++        }
++        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
++                       options=options)
++
++    if isinstance(ntraj, (list, tuple)):
++        raise TypeError(
++            "ntraj must be an integer. "
++            "A list of numbers is not longer supported."
++        )
++
++    mc = MCSolver(H, c_ops, options=options)
++    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
++                    seed=seeds, target_tol=target_tol, timeout=timeout)
++    return result
++
++
++class MCIntegrator:
++    """
++    Integrator like object for mcsolve trajectory.
++    """
++    name = "mcsolve"
++
++    def __init__(self, integrator, c_ops, n_ops, options=None):
++        self._integrator = integrator
++        self._c_ops = c_ops
++        self._n_ops = n_ops
++        self.options = options
++        self._generator = None
++        self.method = f"{self.name} {self._integrator.method}"
++        self._is_set = False
++        self.issuper = c_ops[0].issuper
++
++    def set_state(self, t, state0, generator):
++        """
++        Set the state of the ODE solver.
++
++        Parameters
++        ----------
++        t : float
++            Initial time
++
++        state0 : qutip.Data
++            Initial state.
++
++        generator : numpy.random.generator
++            Random number generator.
++        """
++        self.collapses = []
++        self._generator = generator
++        self.target_norm = self._generator.random()
++        self._integrator.set_state(t, state0)
++        self._is_set = True
++
++    def get_state(self, copy=True):
++        return *self._integrator.get_state(copy), self._generator
++
++    def integrate(self, t, copy=False):
++        t_old, y_old = self._integrator.get_state(copy=False)
++        norm_old = self._prob_func(y_old)
++        while t_old < t:
++            t_step, state = self._integrator.mcstep(t, copy=False)
++            norm = self._prob_func(state)
++            if norm <= self.target_norm:
++                t_col, state = self._find_collapse_time(norm_old, norm,
++                                                        t_old, t_step)
++                self._do_collapse(t_col, state)
++                t_old, y_old = self._integrator.get_state(copy=False)
++                norm_old = 1.
++            else:
++                t_old, y_old = t_step, state
++                norm_old = norm
++
++        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
++
++    def run(self, tlist):
++        for t in tlist[1:]:
++            yield self.integrate(t, False)
++
++    def reset(self, hard=False):
++        self._integrator.reset(hard)
++
++    def _prob_func(self, state):
++        if self.issuper:
++            return _data.trace_oper_ket(state).real
++        return _data.norm.l2(state)**2
++
++    def _norm_func(self, state):
++        if self.issuper:
++            return _data.trace_oper_ket(state).real
++        return _data.norm.l2(state)
++
++    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
++        """Find the time of the collapse and state just before it."""
++        tries = 0
++        while tries < self.options['norm_steps']:
++            tries += 1
++            if (t_final - t_prev) < self.options['norm_t_tol']:
++                t_guess = t_final
++                _, state = self._integrator.get_state()
++                break
++            t_guess = (
++                t_prev
++                + ((t_final - t_prev)
++                   * np.log(norm_old / self.target_norm)
++                   / np.log(norm_old / norm))
++            )
++            if (t_guess - t_prev) < self.options['norm_t_tol']:
++                t_guess = t_prev + self.options['norm_t_tol']
++            _, state = self._integrator.mcstep(t_guess, copy=False)
++            norm2_guess = self._prob_func(state)
++            if (
++                np.abs(self.target_norm - norm2_guess) <
++                self.options['norm_tol'] * self.target_norm
++            ):
++                break
++            elif (norm2_guess < self.target_norm):
++                # t_guess is still > t_jump
++                t_final = t_guess
++                norm = norm2_guess
++            else:
++                # t_guess < t_jump
++                t_prev = t_guess
++                norm_old = norm2_guess
++
++        if tries >= self.options['norm_steps']:
++            raise RuntimeError(
++                "Could not find the collapse time within desired tolerance. "
++                "Increase accuracy of the ODE solver or lower the tolerance "
++                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
++
++        return t_guess, state
++
++    def _do_collapse(self, collapse_time, state):
++        """
++        Do the collapse:
++        - Find which operator did the collapse.
++        - Update the state and Integrator.
++        - Next collapse norm location
++        - Store collapse info.
++        """
++        # collapse_time, state is at the collapse
++        if len(self._n_ops) == 1:
++            which = 0
++        else:
++            probs = np.zeros(len(self._n_ops))
++            for i, n_op in enumerate(self._n_ops):
++                probs[i] = n_op.expect_data(collapse_time, state).real
++            probs = np.cumsum(probs)
++            which = np.searchsorted(probs,
++                                    probs[-1] * self._generator.random())
++
++        state_new = self._c_ops[which].matmul_data(collapse_time, state)
++        new_norm = self._norm_func(state_new)
++        if new_norm < self.options['mc_corr_eps']:
++            # This happen when the collapse is caused by numerical error
++            state_new = _data.mul(state, 1 / self._norm_func(state))
++        else:
++            state_new = _data.mul(state_new, 1 / new_norm)
++            self.collapses.append((collapse_time, which))
++            self.target_norm = self._generator.random()
++        self._integrator.set_state(collapse_time, state_new)
++
++    def arguments(self, args):
++        if args:
++            self._integrator.arguments(args)
++            for c_op in self._c_ops:
++                c_op.arguments(args)
++            for n_op in self._n_ops:
++                n_op.arguments(args)
++
++    @property
++    def integrator_options(self):
++        return self._integrator.integrator_options
++
++
++# -----------------------------------------------------------------------------
++# MONTE CARLO CLASS
++# -----------------------------------------------------------------------------
++class MCSolver(MultiTrajSolver):
++    r"""
++    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
++    given Hamiltonian and sets of collapse operators. Options for the
++    underlying ODE solver are given by the Options class.
++
++    Parameters
++    ----------
++    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
++        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
++        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
++        ``H`` can also be a superoperator (liouvillian) if some collapse
++        operators are to be treated deterministically.
++
++    c_ops : list
++        A ``list`` of collapse operators in any input type that QobjEvo accepts
++        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
++        even if ``H`` is a superoperator.
++
++    options : dict, [optional]
++        Options for the evolution.
++    """
++    name = "mcsolve"
++    resultclass = McResult
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size": 10},
++        "store_final_state": False,
++        "store_states": None,
++        "keep_runs_results": False,
++        "method": "adams",
++        "map": "serial",
++        "job_timeout": None,
++        "num_cpus": None,
++        "bitgenerator": None,
++        "mc_corr_eps": 1e-10,
++        "norm_steps": 5,
++        "norm_t_tol": 1e-6,
++        "norm_tol": 1e-4,
++    }
++
++    def __init__(self, H, c_ops, *, options=None):
++        _time_start = time()
++
++        if isinstance(c_ops, (Qobj, QobjEvo)):
++            c_ops = [c_ops]
++        c_ops = [QobjEvo(c_op) for c_op in c_ops]
++
++        if H.issuper:
++            self._c_ops = [
++                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
++                for c_op in c_ops
++            ]
++            self._n_ops = self._c_ops
++            rhs = QobjEvo(H)
++            for c_op in c_ops:
++                cdc = c_op.dag() @ c_op
++                rhs -= 0.5 * (spre(cdc) + spost(cdc))
++        else:
++            self._c_ops = c_ops
++            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
++            rhs = -1j * QobjEvo(H)
++            for n_op in self._n_ops:
++                rhs -= 0.5 * n_op
++
++        self._num_collapse = len(self._c_ops)
++
++        super().__init__(rhs, options=options)
++
++    def _restore_state(self, data, *, copy=True):
++        """
++        Retore the Qobj state from its data.
++        """
++        if self._state_metadata['dims'] == self.rhs.dims[1]:
++            state = Qobj(unstack_columns(data),
++                         **self._state_metadata, copy=False)
++        else:
++            state = Qobj(data, **self._state_metadata, copy=copy)
++
++        return state
++
++    def _initialize_stats(self):
++        stats = super()._initialize_stats()
++        stats.update({
++            "method": self.options["method"],
++            "solver": "Master Equation Evolution",
++            "num_collapse": self._num_collapse,
++        })
++        return stats
++
++    def _argument(self, args):
++        self._integrator.arguments(args)
++        self.rhs.arguments(args)
++        for c_op in self._c_ops:
++            c_op.arguments(args)
++        for n_op in self._n_ops:
++            n_op.arguments(args)
++
++    def _run_one_traj(self, seed, state, tlist, e_ops):
++        """
++        Run one trajectory and return the result.
++        """
++        # The integrators is reused, but non-reentrant. They are are fine for
++        # multiprocessing, but will fail with multithreading.
++        # If a thread base parallel map is created, eahc trajectory should use
++        # a copy of the integrator.
++        result = Result(e_ops, {**self.options, "normalize_output": False})
++        generator = self._get_generator(seed)
++        self._integrator.set_state(tlist[0], state, generator)
++        result.add(tlist[0], self._restore_state(state, copy=False))
++        for t in tlist[1:]:
++            t, state = self._integrator.integrate(t, copy=False)
++            result.add(t, self._restore_state(state, copy=False))
++        result.collapse = self._integrator.collapses
++        return seed, result
++
++    def _get_integrator(self):
++        _time_start = time()
++        method = self.options["method"]
++        if method in self.avail_integrators():
++            integrator = self.avail_integrators()[method]
++        elif issubclass(method, Integrator):
++            integrator = method
++        else:
++            raise ValueError("Integrator method not supported.")
++        integrator_instance = integrator(self.rhs, self.options)
++        mc_integrator = MCIntegrator(
++            integrator_instance, self._c_ops, self._n_ops, self.options
++        )
++        self._init_integrator_time = time() - _time_start
++        return mc_integrator
++
++    @property
++    def options(self):
++        """
++        Options for monte carlo solver:
++
++        store_final_state: bool, default=False
++            Whether or not to store the final state of the evolution in the
++            result class.
++
++        store_states: bool, default=None
++            Whether or not to store the state vectors or density matrices.
++            On `None` the states will be saved if no expectation operators are
++            given.
++
++        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
++            How to present the solver progress.
++            'tqdm' uses the python module of the same name and raise an error if
++            not installed. Empty string or False will disable the bar.
++
++        progress_kwargs: dict, default={"chunk_size":10}
++            Arguments to pass to the progress_bar. Qutip's bars use
++            ``chunk_size``.
++
++        keep_runs_results: bool
++          Whether to store results from all trajectories or just store the
++          averages.
++
++        method: str, default="adams"
++            Which ODE integrator methods are supported.
++
++        map: str {"serial", "parallel", "loky"}
++            How to run the trajectories. "parallel" uses concurent module to
++            run in parallel while "loky" use the module of the same name to do
++            so.
++
++        job_timeout: None, int
++            Maximum time to compute one trajectory.
++
++        num_cpus: None, int
++            Number of cpus to use when running in parallel. ``None`` detect the
++            number of available cpus.
++
++        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
++            Which of numpy.random's bitgenerator to use. With ``None``, your
++            numpy version's default is used.
++
++        mc_corr_eps: float
++            Small number used to detect non-physical collapse caused by
++            numerical imprecision.
++
++        norm_t_tol: float
++            Tolerance in time used when finding the collapse.
++
++        norm_tol: float
++            Tolerance in norm used when finding the collapse.
++
++        norm_steps: int
++            Maximum number of tries to find the collapse.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        MultiTrajSolver.options.fset(self, new_options)
++
++    @classmethod
++    def avail_integrators(cls):
++        if cls is Solver:
++            return cls._avail_integrators.copy()
++        return {
++            **Solver.avail_integrators(),
++            **cls._avail_integrators,
++        }
+diff --git a/qutip/solver/mesolve.py b/qutip/solver/mesolve.py
+index 5792038a..fb7ff5c7 100644
+--- a/qutip/solver/mesolve.py
++++ b/qutip/solver/mesolve.py
+@@ -1,217 +1,217 @@
+-"""
+-This module provides solvers for the Lindblad master equation and von Neumann
+-equation.
+-"""
+-
+-__all__ = ['mesolve', 'MESolver']
+-
+-import numpy as np
+-from time import time
+-from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
+-from ..core import stack_columns, unstack_columns
+-from ..core.data import to
+-from .solver_base import Solver
+-from .sesolve import sesolve, SESolver
+-
+-
+-def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
+-    """
+-    Master equation evolution of a density matrix for a given Hamiltonian and
+-    set of collapse operators, or a Liouvillian.
+-
+-    Evolve the state vector or density matrix (`rho0`) using a given
+-    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
+-    (`c_ops`), by integrating the set of ordinary differential equations
+-    that define the system. In the absence of collapse operators the system is
+-    evolved according to the unitary evolution of the Hamiltonian.
+-
+-    The output is either the state vector at arbitrary points in time
+-    (`tlist`), or the expectation values of the supplied operators
+-    (`e_ops`). If e_ops is a callback function, it is invoked for each
+-    time in `tlist` with time and the state as arguments, and the function
+-    does not use any return values.
+-
+-    If either `H` or the Qobj elements in `c_ops` are superoperators, they
+-    will be treated as direct contributions to the total system Liouvillian.
+-    This allows the solution of master equations that are not in standard
+-    Lindblad form.
+-
+-    **Time-dependent operators**
+-
+-    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
+-    object that can be interpreted as :class:`QobjEvo` such as a list of
+-    (Qobj, Coefficient) pairs or a function.
+-
+-    **Additional options**
+-
+-    Additional options to mesolve can be set via the `options` argument. Many
+-    ODE integration options can be set this way, and the `store_states` and
+-    `store_final_state` options can be used to store states even though
+-    expectation values are requested via the `e_ops` argument.
+-
+-    .. note::
+-
+-        When no collapse operator are given and the `H` is not a superoperator,
+-        it will defer to :func:`sesolve`.
+-
+-    Parameters
+-    ----------
+-
+-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    rho0 : :class:`Qobj`
+-        initial density matrix or state vector (ket).
+-
+-    tlist : *list* / *array*
+-        list of times for :math:`t`.
+-
+-    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+-        Single collapse operator, or list of collapse operators, or a list
+-        of Liouvillian superoperators. None is equivalent to an empty list.
+-
+-    e_ops : list of :class:`Qobj` / callback function
+-        Single operator or list of operators for which to evaluate
+-        expectation values or callable or list of callable.
+-        Callable signature must be, `f(t: float, state: Qobj)`.
+-        See :func:`expect` for more detail of operator expectation.
+-
+-    args : None / *dictionary*
+-        dictionary of parameters for time-dependent Hamiltonians and
+-        collapse operators.
+-
+-    options : None / dict
+-        Dictionary of options for the solver.
+-
+-        - store_final_state : bool
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, None
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - normalize_output : bool
+-          Normalize output state to hide ODE numerical errors.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+-          Which differential equation integration method to use.
+-        - atol, rtol : float
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps :
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - max_step : float, 0
+-          Maximum lenght of one internal step. When using pulses, it should be
+-          less than half the width of the thinnest pulse.
+-
+-        Other options could be supported depending on the integration method,
+-        see `Integrator <./classes.html#classes-ode>`_.
+-
+-    Returns
+-    -------
+-    result: :class:`qutip.Result`
+-
+-        An instance of the class :class:`qutip.Result`, which contains
+-        a *list of array* `result.expect` of expectation values for the times
+-        specified by `tlist`, and/or a *list* `result.states` of state vectors
+-        or density matrices corresponding to the times in `tlist` [if `e_ops`
+-        is an empty list of `store_states=True` in options].
+-
+-    """
+-    H = QobjEvo(H, args=args, tlist=tlist)
+-
+-    c_ops = c_ops if c_ops is not None else []
+-    if not isinstance(c_ops, (list, tuple)):
+-        c_ops = [c_ops]
+-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+-
+-    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
+-
+-    if not use_mesolve:
+-        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
+-                       options=options)
+-
+-    solver = MESolver(H, c_ops, options=options)
+-
+-    return solver.run(rho0, tlist, e_ops=e_ops)
+-
+-
+-class MESolver(SESolver):
+-    """
+-    Master equation evolution of a density matrix for a given Hamiltonian and
+-    set of collapse operators, or a Liouvillian.
+-
+-    Evolve the density matrix (`rho0`) using a given
+-    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
+-    (`c_ops`), by integrating the set of ordinary differential equations
+-    that define the system.
+-
+-    If either `H` or the Qobj elements in `c_ops` are superoperators, they
+-    will be treated as direct contributions to the total system Liouvillian.
+-    This allows the solution of master equations that are not in standard
+-    Lindblad form.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
+-        can be made into :class:`QobjEvo` are also accepted.
+-
+-    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
+-        Single collapse operator, or list of collapse operators, or a list
+-        of Liouvillian superoperators. None is equivalent to an empty list.
+-
+-    options : dict, optional
+-        Options for the solver, see :obj:`MESolver.options` and
+-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+-
+-    attributes
+-    ----------
+-    stats: dict
+-        Diverse diagnostic statistics of the evolution.
+-    """
+-    name = "mesolve"
+-    _avail_integrators = {}
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size":10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": True,
+-        'method': 'adams',
+-    }
+-
+-    def __init__(self, H, c_ops=None, *, options=None):
+-        _time_start = time()
+-
+-        if not isinstance(H, (Qobj, QobjEvo)):
+-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+-        c_ops = c_ops or []
+-        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
+-        for c_op in c_ops:
+-            if not isinstance(c_op, (Qobj, QobjEvo)):
+-                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
+-
+-        self._num_collapse = len(c_ops)
+-
+-        rhs = H if H.issuper else liouvillian(H)
+-        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
+-                   for c_op in c_ops)
+-
+-        Solver.__init__(self, rhs, options=options)
+-
+-    def _initialize_stats(self):
+-        stats = super()._initialize_stats()
+-        stats.update({
+-            "solver": "Master Equation Evolution",
+-            "num_collapse": self._num_collapse,
+-        })
+-        return stats
++"""
++This module provides solvers for the Lindblad master equation and von Neumann
++equation.
++"""
++
++__all__ = ['mesolve', 'MESolver']
++
++import numpy as np
++from time import time
++from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
++from ..core import stack_columns, unstack_columns
++from ..core.data import to
++from .solver_base import Solver
++from .sesolve import sesolve, SESolver
++
++
++def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
++    """
++    Master equation evolution of a density matrix for a given Hamiltonian and
++    set of collapse operators, or a Liouvillian.
++
++    Evolve the state vector or density matrix (`rho0`) using a given
++    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
++    (`c_ops`), by integrating the set of ordinary differential equations
++    that define the system. In the absence of collapse operators the system is
++    evolved according to the unitary evolution of the Hamiltonian.
++
++    The output is either the state vector at arbitrary points in time
++    (`tlist`), or the expectation values of the supplied operators
++    (`e_ops`). If e_ops is a callback function, it is invoked for each
++    time in `tlist` with time and the state as arguments, and the function
++    does not use any return values.
++
++    If either `H` or the Qobj elements in `c_ops` are superoperators, they
++    will be treated as direct contributions to the total system Liouvillian.
++    This allows the solution of master equations that are not in standard
++    Lindblad form.
++
++    **Time-dependent operators**
++
++    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
++    object that can be interpreted as :class:`QobjEvo` such as a list of
++    (Qobj, Coefficient) pairs or a function.
++
++    **Additional options**
++
++    Additional options to mesolve can be set via the `options` argument. Many
++    ODE integration options can be set this way, and the `store_states` and
++    `store_final_state` options can be used to store states even though
++    expectation values are requested via the `e_ops` argument.
++
++    .. note::
++
++        When no collapse operator are given and the `H` is not a superoperator,
++        it will defer to :func:`sesolve`.
++
++    Parameters
++    ----------
++
++    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    rho0 : :class:`Qobj`
++        initial density matrix or state vector (ket).
++
++    tlist : *list* / *array*
++        list of times for :math:`t`.
++
++    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
++        Single collapse operator, or list of collapse operators, or a list
++        of Liouvillian superoperators. None is equivalent to an empty list.
++
++    e_ops : list of :class:`Qobj` / callback function
++        Single operator or list of operators for which to evaluate
++        expectation values or callable or list of callable.
++        Callable signature must be, `f(t: float, state: Qobj)`.
++        See :func:`expect` for more detail of operator expectation.
++
++    args : None / *dictionary*
++        dictionary of parameters for time-dependent Hamiltonians and
++        collapse operators.
++
++    options : None / dict
++        Dictionary of options for the solver.
++
++        - store_final_state : bool
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, None
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - normalize_output : bool
++          Normalize output state to hide ODE numerical errors.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
++          Which differential equation integration method to use.
++        - atol, rtol : float
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps :
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - max_step : float, 0
++          Maximum lenght of one internal step. When using pulses, it should be
++          less than half the width of the thinnest pulse.
++
++        Other options could be supported depending on the integration method,
++        see `Integrator <./classes.html#classes-ode>`_.
++
++    Returns
++    -------
++    result: :class:`qutip.Result`
++
++        An instance of the class :class:`qutip.Result`, which contains
++        a *list of array* `result.expect` of expectation values for the times
++        specified by `tlist`, and/or a *list* `result.states` of state vectors
++        or density matrices corresponding to the times in `tlist` [if `e_ops`
++        is an empty list of `store_states=True` in options].
++
++    """
++    H = QobjEvo(H, args=args, tlist=tlist)
++
++    c_ops = c_ops if c_ops is not None else []
++    if not isinstance(c_ops, (list, tuple)):
++        c_ops = [c_ops]
++    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
++
++    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
++
++    if not use_mesolve:
++        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
++                       options=options)
++
++    solver = MESolver(H, c_ops, options=options)
++
++    return solver.run(rho0, tlist, e_ops=e_ops)
++
++
++class MESolver(SESolver):
++    """
++    Master equation evolution of a density matrix for a given Hamiltonian and
++    set of collapse operators, or a Liouvillian.
++
++    Evolve the density matrix (`rho0`) using a given
++    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
++    (`c_ops`), by integrating the set of ordinary differential equations
++    that define the system.
++
++    If either `H` or the Qobj elements in `c_ops` are superoperators, they
++    will be treated as direct contributions to the total system Liouvillian.
++    This allows the solution of master equations that are not in standard
++    Lindblad form.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
++        can be made into :class:`QobjEvo` are also accepted.
++
++    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
++        Single collapse operator, or list of collapse operators, or a list
++        of Liouvillian superoperators. None is equivalent to an empty list.
++
++    options : dict, optional
++        Options for the solver, see :obj:`MESolver.options` and
++        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
++
++    attributes
++    ----------
++    stats: dict
++        Diverse diagnostic statistics of the evolution.
++    """
++    name = "mesolve"
++    _avail_integrators = {}
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size":10},
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": True,
++        'method': 'adams',
++    }
++
++    def __init__(self, H, c_ops=None, *, options=None):
++        _time_start = time()
++
++        if not isinstance(H, (Qobj, QobjEvo)):
++            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
++        c_ops = c_ops or []
++        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
++        for c_op in c_ops:
++            if not isinstance(c_op, (Qobj, QobjEvo)):
++                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
++
++        self._num_collapse = len(c_ops)
++
++        rhs = H if H.issuper else liouvillian(H)
++        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
++                   for c_op in c_ops)
++
++        Solver.__init__(self, rhs, options=options)
++
++    def _initialize_stats(self):
++        stats = super()._initialize_stats()
++        stats.update({
++            "solver": "Master Equation Evolution",
++            "num_collapse": self._num_collapse,
++        })
++        return stats
+diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
+index 204178d1..3123c72e 100644
+--- a/qutip/solver/multitraj.py
++++ b/qutip/solver/multitraj.py
+@@ -1,257 +1,257 @@
+-from .. import Qobj, QobjEvo
+-from .result import Result, MultiTrajResult
+-from .parallel import _get_map
+-from time import time
+-from .solver_base import Solver
+-import numpy as np
+-from copy import copy
+-
+-__all__ = ["MultiTrajSolver", "TrajectorySolver"]
+-
+-
+-class MultiTrajSolver(Solver):
+-    """
+-    Basic class for multi-trajectory evolutions.
+-
+-    As :class:`Solver` it can ``run`` or ``step`` evolution.
+-    It manages the random seed for each trajectory.
+-
+-    The actual evolution is done by a single trajectory solver::
+-        ``_traj_solver_class``
+-
+-    Parameters
+-    ----------
+-    rhs : Qobj, QobjEvo
+-        Right hand side of the evolution::
+-            d state / dt = rhs @ state
+-
+-    options : dict
+-        Options for the solver.
+-    """
+-    name = "generic multi trajectory"
+-    resultclass = MultiTrajResult
+-    _avail_integrators = {}
+-
+-    # Class of option used by the solver
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size": 10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "keep_runs_results": False,
+-        "normalize_output": False,
+-        "method": "",
+-        "map": "serial",
+-        "job_timeout": None,
+-        "num_cpus": None,
+-        "bitgenerator": None,
+-    }
+-
+-    def __init__(self, rhs, *, options=None):
+-        self.rhs = rhs
+-        self.options = options
+-        self.seed_sequence = np.random.SeedSequence()
+-        self._integrator = self._get_integrator()
+-        self._state_metadata = {}
+-        self.stats = self._initialize_stats()
+-
+-    def start(self, state, t0, seed=None):
+-        """
+-        Set the initial state and time for a step evolution.
+-
+-        Parameters
+-        ----------
+-        state : :class:`Qobj`
+-            Initial state of the evolution.
+-
+-        t0 : double
+-            Initial time of the evolution.
+-
+-        seed : int, SeedSequence, list, {None}
+-            Seed for the random number generator. It can be a single seed used
+-            to spawn seeds for each trajectory or a list of seed, one for each
+-            trajectory.
+-
+-        ..note ::
+-            When using step evolution, only one trajectory can be computed at
+-            once.
+-        """
+-        seeds = self._read_seed(seed, 1)
+-        generator = self._get_generator(seeds[0])
+-        self._integrator.set_state(t0, self._prepare_state(state), generator)
+-
+-    def step(self, t, *, args=None, copy=True):
+-        """
+-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+-
+-        Parameters
+-        ----------
+-        t : double
+-            Time to evolve to, must be higher than the last call.
+-
+-        args : dict, optional {None}
+-            Update the ``args`` of the system.
+-            The change is effective from the beginning of the interval.
+-            Changing ``args`` can slow the evolution.
+-
+-        copy : bool, optional {True}
+-            Whether to return a copy of the data or the data in the ODE solver.
+-        """
+-        if not self._integrator._is_set:
+-            raise RuntimeError("The `start` method must called first.")
+-        self._argument(args)
+-        _, state = self._integrator.integrate(t, copy=False)
+-        return self._restore_state(state, copy=copy)
+-
+-    def run(self, state, tlist, ntraj=1, *,
+-            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+-        """
+-        Do the evolution of the Quantum system.
+-
+-        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
+-        ``rhs`` and for each time in ``tlist`` store the state and/or
+-        expectation values in a :cls:`Result`. The evolution method and stored
+-        results are determined by ``options``.
+-
+-        Parameters
+-        ----------
+-        state : :class:`Qobj`
+-            Initial state of the evolution.
+-
+-        tlist : list of double
+-            Time for which to save the results (state and/or expect) of the
+-            evolution. The first element of the list is the initial time of the
+-            evolution. Time in the list must be in increasing order, but does
+-            not need to be uniformly distributed.
+-
+-        ntraj : int
+-            Number of trajectories to add.
+-
+-        args : dict, optional {None}
+-            Change the ``args`` of the rhs for the evolution.
+-
+-        e_ops : list
+-            list of Qobj or QobjEvo to compute the expectation values.
+-            Alternatively, function[s] with the signature f(t, state) -> expect
+-            can be used.
+-
+-        timeout : float, optional [1e8]
+-            Maximum time in seconds for the trajectories to run. Once this time
+-            is reached, the simulation will end even if the number
+-            of trajectories is less than ``ntraj``. The map function, set in
+-            options, can interupt the running trajectory or wait for it to
+-            finish. Set to an arbitrary high number to disable.
+-
+-        target_tol : {float, tuple, list}, optional [None]
+-            Target tolerance of the evolution. The evolution will compute
+-            trajectories until the error on the expectation values is lower
+-            than this tolerance. The maximum number of trajectories employed is
+-            given by ``ntraj``. The error is computed using jackknife
+-            resampling. ``target_tol`` can be an absolute tolerance or a pair
+-            of absolute and relative tolerance, in that order. Lastly, it can
+-            be a list of pairs of (atol, rtol) for each e_ops.
+-
+-        seed : {int, SeedSequence, list} optional
+-            Seed or list of seeds for each trajectories.
+-
+-        Return
+-        ------
+-        results : :class:`qutip.solver.MultiTrajResult`
+-            Results of the evolution. States and/or expect will be saved. You
+-            can control the saved data in the options.
+-
+-        .. note:
+-            The simulation will end when the first end condition is reached
+-            between ``ntraj``, ``timeout`` and ``target_tol``.
+-        """
+-        start_time = time()
+-        self._argument(args)
+-        stats = self._initialize_stats()
+-        seeds = self._read_seed(seed, ntraj)
+-
+-        result = self.resultclass(
+-            e_ops, self.options, solver=self.name, stats=stats
+-        )
+-        result.add_end_condition(ntraj, target_tol)
+-
+-        map_func = _get_map[self.options['map']]
+-        map_kw = {
+-            'timeout': timeout,
+-            'job_timeout': self.options['job_timeout'],
+-            'num_cpus': self.options['num_cpus'],
+-        }
+-        state0 = self._prepare_state(state)
+-        stats['preparation time'] += time() - start_time
+-
+-        start_time = time()
+-        map_func(
+-            self._run_one_traj, seeds,
+-            (state0, tlist, e_ops),
+-            reduce_func=result.add, map_kw=map_kw,
+-            progress_bar=self.options["progress_bar"],
+-            progress_bar_kwargs=self.options["progress_kwargs"]
+-        )
+-        result.stats['run time'] = time() - start_time
+-        return result
+-
+-    def _run_one_traj(self, seed, state, tlist, e_ops):
+-        """
+-        Run one trajectory and return the result.
+-        """
+-        result = Result(e_ops, self.options)
+-        generator = self._get_generator(seed)
+-        self._integrator.set_state(tlist[0], state, generator)
+-        result.add(tlist[0], self._restore_state(state, copy=False))
+-        for t in tlist[1:]:
+-            t, state = self._integrator.step(t, copy=False)
+-            result.add(t, self._restore_state(state, copy=False))
+-        return seed, result
+-
+-    def _read_seed(self, seed, ntraj):
+-        """
+-        Read user provided seed(s) and produce one for each trajectory.
+-        Let numpy raise error for inputs that cannot be seeds.
+-        """
+-        if seed is None:
+-            seeds = self.seed_sequence.spawn(ntraj)
+-        elif isinstance(seed, np.random.SeedSequence):
+-            seeds = seed.spawn(ntraj)
+-        elif not isinstance(seed, list):
+-            seeds = np.random.SeedSequence(seed).spawn(ntraj)
+-        elif len(seed) >= ntraj:
+-            seeds = [
+-                seed_ if (isinstance(seed_, np.random.SeedSequence)
+-                          or hasattr(seed_, 'random'))
+-                else np.random.SeedSequence(seed_)
+-                for seed_ in seed[:ntraj]
+-            ]
+-        else:
+-            raise ValueError("A seed list must be longer than ntraj")
+-        return seeds
+-
+-    def _argument(self, args):
+-        """Update the args, for the `rhs` and `c_ops` and other operators."""
+-        if args:
+-            self.rhs.arguments(args)
+-
+-    def _get_generator(self, seed):
+-        """
+-        Read the seed and create the random number generator.
+-        If the ``seed`` has a ``random`` method, it will be used as the
+-        generator.
+-        """
+-        if hasattr(seed, 'random'):
+-            # We check for the method, not the type to accept pseudo non-random
+-            # generator for debug/testing purpose.
+-            return seed
+-
+-        if self.options['bitgenerator']:
+-            bit_gen = getattr(np.random, self.options['bitgenerator'])
+-            generator = np.random.Generator(bit_gen(seed))
+-        else:
+-            generator = np.random.default_rng(seed)
+-        return generator
+-
+-    @classmethod
+-    def avail_integrators(cls):
+-        return cls._avail_integrators
++from .. import Qobj, QobjEvo
++from .result import Result, MultiTrajResult
++from .parallel import _get_map
++from time import time
++from .solver_base import Solver
++import numpy as np
++from copy import copy
++
++__all__ = ["MultiTrajSolver", "TrajectorySolver"]
++
++
++class MultiTrajSolver(Solver):
++    """
++    Basic class for multi-trajectory evolutions.
++
++    As :class:`Solver` it can ``run`` or ``step`` evolution.
++    It manages the random seed for each trajectory.
++
++    The actual evolution is done by a single trajectory solver::
++        ``_traj_solver_class``
++
++    Parameters
++    ----------
++    rhs : Qobj, QobjEvo
++        Right hand side of the evolution::
++            d state / dt = rhs @ state
++
++    options : dict
++        Options for the solver.
++    """
++    name = "generic multi trajectory"
++    resultclass = MultiTrajResult
++    _avail_integrators = {}
++
++    # Class of option used by the solver
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size": 10},
++        "store_final_state": False,
++        "store_states": None,
++        "keep_runs_results": False,
++        "normalize_output": False,
++        "method": "",
++        "map": "serial",
++        "job_timeout": None,
++        "num_cpus": None,
++        "bitgenerator": None,
++    }
++
++    def __init__(self, rhs, *, options=None):
++        self.rhs = rhs
++        self.options = options
++        self.seed_sequence = np.random.SeedSequence()
++        self._integrator = self._get_integrator()
++        self._state_metadata = {}
++        self.stats = self._initialize_stats()
++
++    def start(self, state, t0, seed=None):
++        """
++        Set the initial state and time for a step evolution.
++
++        Parameters
++        ----------
++        state : :class:`Qobj`
++            Initial state of the evolution.
++
++        t0 : double
++            Initial time of the evolution.
++
++        seed : int, SeedSequence, list, {None}
++            Seed for the random number generator. It can be a single seed used
++            to spawn seeds for each trajectory or a list of seed, one for each
++            trajectory.
++
++        ..note ::
++            When using step evolution, only one trajectory can be computed at
++            once.
++        """
++        seeds = self._read_seed(seed, 1)
++        generator = self._get_generator(seeds[0])
++        self._integrator.set_state(t0, self._prepare_state(state), generator)
++
++    def step(self, t, *, args=None, copy=True):
++        """
++        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
++
++        Parameters
++        ----------
++        t : double
++            Time to evolve to, must be higher than the last call.
++
++        args : dict, optional {None}
++            Update the ``args`` of the system.
++            The change is effective from the beginning of the interval.
++            Changing ``args`` can slow the evolution.
++
++        copy : bool, optional {True}
++            Whether to return a copy of the data or the data in the ODE solver.
++        """
++        if not self._integrator._is_set:
++            raise RuntimeError("The `start` method must called first.")
++        self._argument(args)
++        _, state = self._integrator.integrate(t, copy=False)
++        return self._restore_state(state, copy=copy)
++
++    def run(self, state, tlist, ntraj=1, *,
++            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
++        """
++        Do the evolution of the Quantum system.
++
++        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
++        ``rhs`` and for each time in ``tlist`` store the state and/or
++        expectation values in a :cls:`Result`. The evolution method and stored
++        results are determined by ``options``.
++
++        Parameters
++        ----------
++        state : :class:`Qobj`
++            Initial state of the evolution.
++
++        tlist : list of double
++            Time for which to save the results (state and/or expect) of the
++            evolution. The first element of the list is the initial time of the
++            evolution. Time in the list must be in increasing order, but does
++            not need to be uniformly distributed.
++
++        ntraj : int
++            Number of trajectories to add.
++
++        args : dict, optional {None}
++            Change the ``args`` of the rhs for the evolution.
++
++        e_ops : list
++            list of Qobj or QobjEvo to compute the expectation values.
++            Alternatively, function[s] with the signature f(t, state) -> expect
++            can be used.
++
++        timeout : float, optional [1e8]
++            Maximum time in seconds for the trajectories to run. Once this time
++            is reached, the simulation will end even if the number
++            of trajectories is less than ``ntraj``. The map function, set in
++            options, can interupt the running trajectory or wait for it to
++            finish. Set to an arbitrary high number to disable.
++
++        target_tol : {float, tuple, list}, optional [None]
++            Target tolerance of the evolution. The evolution will compute
++            trajectories until the error on the expectation values is lower
++            than this tolerance. The maximum number of trajectories employed is
++            given by ``ntraj``. The error is computed using jackknife
++            resampling. ``target_tol`` can be an absolute tolerance or a pair
++            of absolute and relative tolerance, in that order. Lastly, it can
++            be a list of pairs of (atol, rtol) for each e_ops.
++
++        seed : {int, SeedSequence, list} optional
++            Seed or list of seeds for each trajectories.
++
++        Return
++        ------
++        results : :class:`qutip.solver.MultiTrajResult`
++            Results of the evolution. States and/or expect will be saved. You
++            can control the saved data in the options.
++
++        .. note:
++            The simulation will end when the first end condition is reached
++            between ``ntraj``, ``timeout`` and ``target_tol``.
++        """
++        start_time = time()
++        self._argument(args)
++        stats = self._initialize_stats()
++        seeds = self._read_seed(seed, ntraj)
++
++        result = self.resultclass(
++            e_ops, self.options, solver=self.name, stats=stats
++        )
++        result.add_end_condition(ntraj, target_tol)
++
++        map_func = _get_map[self.options['map']]
++        map_kw = {
++            'timeout': timeout,
++            'job_timeout': self.options['job_timeout'],
++            'num_cpus': self.options['num_cpus'],
++        }
++        state0 = self._prepare_state(state)
++        stats['preparation time'] += time() - start_time
++
++        start_time = time()
++        map_func(
++            self._run_one_traj, seeds,
++            (state0, tlist, e_ops),
++            reduce_func=result.add, map_kw=map_kw,
++            progress_bar=self.options["progress_bar"],
++            progress_bar_kwargs=self.options["progress_kwargs"]
++        )
++        result.stats['run time'] = time() - start_time
++        return result
++
++    def _run_one_traj(self, seed, state, tlist, e_ops):
++        """
++        Run one trajectory and return the result.
++        """
++        result = Result(e_ops, self.options)
++        generator = self._get_generator(seed)
++        self._integrator.set_state(tlist[0], state, generator)
++        result.add(tlist[0], self._restore_state(state, copy=False))
++        for t in tlist[1:]:
++            t, state = self._integrator.step(t, copy=False)
++            result.add(t, self._restore_state(state, copy=False))
++        return seed, result
++
++    def _read_seed(self, seed, ntraj):
++        """
++        Read user provided seed(s) and produce one for each trajectory.
++        Let numpy raise error for inputs that cannot be seeds.
++        """
++        if seed is None:
++            seeds = self.seed_sequence.spawn(ntraj)
++        elif isinstance(seed, np.random.SeedSequence):
++            seeds = seed.spawn(ntraj)
++        elif not isinstance(seed, list):
++            seeds = np.random.SeedSequence(seed).spawn(ntraj)
++        elif len(seed) >= ntraj:
++            seeds = [
++                seed_ if (isinstance(seed_, np.random.SeedSequence)
++                          or hasattr(seed_, 'random'))
++                else np.random.SeedSequence(seed_)
++                for seed_ in seed[:ntraj]
++            ]
++        else:
++            raise ValueError("A seed list must be longer than ntraj")
++        return seeds
++
++    def _argument(self, args):
++        """Update the args, for the `rhs` and `c_ops` and other operators."""
++        if args:
++            self.rhs.arguments(args)
++
++    def _get_generator(self, seed):
++        """
++        Read the seed and create the random number generator.
++        If the ``seed`` has a ``random`` method, it will be used as the
++        generator.
++        """
++        if hasattr(seed, 'random'):
++            # We check for the method, not the type to accept pseudo non-random
++            # generator for debug/testing purpose.
++            return seed
++
++        if self.options['bitgenerator']:
++            bit_gen = getattr(np.random, self.options['bitgenerator'])
++            generator = np.random.Generator(bit_gen(seed))
++        else:
++            generator = np.random.default_rng(seed)
++        return generator
++
++    @classmethod
++    def avail_integrators(cls):
++        return cls._avail_integrators
+diff --git a/qutip/solver/options.py b/qutip/solver/options.py
+index 207fa897..737724b9 100644
+--- a/qutip/solver/options.py
++++ b/qutip/solver/options.py
+@@ -1,106 +1,106 @@
+-__all__ = ["Options", "SolverOptions"]
+-
+-import warnings
+-
+-
+-def SolverOptions(*args, **kwargs):
+-    warnings.warn(
+-        "Dedicated options class are no longer needed, "
+-        "options should be passed as dict to solvers.",
+-        FutureWarning
+-    )
+-    return kwargs
+-
+-
+-def Options(**kwargs):
+-    warnings.warn(
+-        "Dedicated options class are no longer needed, "
+-        "options should be passed as dict to solvers.",
+-        FutureWarning
+-    )
+-    return kwargs
+-
+-
+-class _SolverOptions(dict):
+-    """
+-    Class to hold options for solver and integrator.
+-
+-    Parameters
+-    ----------
+-    default : dict
+-        Default dict, only keys in this will be accepted.
+-    feedback : callable, ``f(keys : set) -> None``, optional
+-        Function to called when an item is updated.
+-    name : str, optional
+-        Name of the solver or integrator that use this. Used in __repr__ only.
+-    doc : str, optional
+-        Overwrite the __doc__ of the instance.
+-    """
+-    def __init__(
+-        self, default, feedback=None, name="", doc="", /, **kwargs
+-    ):
+-        self._default = default
+-        self.__doc__ = doc
+-        self._feedback = feedback
+-        self._name = name
+-        extra_keys = kwargs.keys() - default.keys()
+-        if extra_keys:
+-            raise KeyError(f"Options {extra_keys} are not supported.")
+-        super().__init__(**{**self._default, **kwargs})
+-
+-    def __setitem__(self, key, val):
+-        if key not in self._default:
+-            raise KeyError(f"Options {key} is not supported.")
+-        if val is None:
+-            val = self._default[key]
+-        if val == self[key]:
+-            return
+-        super().__setitem__(key, val)
+-        if self._feedback:
+-            self._feedback(key)
+-
+-    def __delitem__(self, key):
+-        if key not in self._default:
+-            raise KeyError(f"Options {key} is not supported.")
+-        super().__setitem__(key, self._default[key])
+-        if self._feedback:
+-            self._feedback(key)
+-
+-    def copy(self):
+-        return self.__class__(
+-            self._default,
+-            self._feedback,
+-            self._name,
+-            self.__doc__,
+-            **self
+-        )
+-
+-    def __str__(self):
+-        lines = []
+-        longest = max(len(key) for key in self.keys())
+-        lines.append(f"Options for {self._name}:")
+-        for key in self.keys():
+-            default = "(default)" if self[key] == self._default[key] else ""
+-            lines.append(f"    {key:{longest}} : "
+-                         f"{self[key].__repr__():{70-longest}}"
+-                         f"{default}")
+-        return "\n".join(lines)
+-
+-    @classmethod
+-    def _from_reduced(cls, default, feedback, name, doc, keys, args):
+-        return cls(default, feedback, name, doc, **{
+-            key: arg for key, arg in zip(keys, args)
+-        })
+-
+-    def __reduce__(self):
+-        return (
+-            self._from_reduced,
+-            (
+-                self._default,
+-                self._feedback,
+-                self._name,
+-                self.__doc__,
+-                tuple(self.keys()),
+-                tuple(self.values())
+-                )
+-            )
++__all__ = ["Options", "SolverOptions"]
++
++import warnings
++
++
++def SolverOptions(*args, **kwargs):
++    warnings.warn(
++        "Dedicated options class are no longer needed, "
++        "options should be passed as dict to solvers.",
++        FutureWarning
++    )
++    return kwargs
++
++
++def Options(**kwargs):
++    warnings.warn(
++        "Dedicated options class are no longer needed, "
++        "options should be passed as dict to solvers.",
++        FutureWarning
++    )
++    return kwargs
++
++
++class _SolverOptions(dict):
++    """
++    Class to hold options for solver and integrator.
++
++    Parameters
++    ----------
++    default : dict
++        Default dict, only keys in this will be accepted.
++    feedback : callable, ``f(keys : set) -> None``, optional
++        Function to called when an item is updated.
++    name : str, optional
++        Name of the solver or integrator that use this. Used in __repr__ only.
++    doc : str, optional
++        Overwrite the __doc__ of the instance.
++    """
++    def __init__(
++        self, default, feedback=None, name="", doc="", /, **kwargs
++    ):
++        self._default = default
++        self.__doc__ = doc
++        self._feedback = feedback
++        self._name = name
++        extra_keys = kwargs.keys() - default.keys()
++        if extra_keys:
++            raise KeyError(f"Options {extra_keys} are not supported.")
++        super().__init__(**{**self._default, **kwargs})
++
++    def __setitem__(self, key, val):
++        if key not in self._default:
++            raise KeyError(f"Options {key} is not supported.")
++        if val is None:
++            val = self._default[key]
++        if val == self[key]:
++            return
++        super().__setitem__(key, val)
++        if self._feedback:
++            self._feedback(key)
++
++    def __delitem__(self, key):
++        if key not in self._default:
++            raise KeyError(f"Options {key} is not supported.")
++        super().__setitem__(key, self._default[key])
++        if self._feedback:
++            self._feedback(key)
++
++    def copy(self):
++        return self.__class__(
++            self._default,
++            self._feedback,
++            self._name,
++            self.__doc__,
++            **self
++        )
++
++    def __str__(self):
++        lines = []
++        longest = max(len(key) for key in self.keys())
++        lines.append(f"Options for {self._name}:")
++        for key in self.keys():
++            default = "(default)" if self[key] == self._default[key] else ""
++            lines.append(f"    {key:{longest}} : "
++                         f"{self[key].__repr__():{70-longest}}"
++                         f"{default}")
++        return "\n".join(lines)
++
++    @classmethod
++    def _from_reduced(cls, default, feedback, name, doc, keys, args):
++        return cls(default, feedback, name, doc, **{
++            key: arg for key, arg in zip(keys, args)
++        })
++
++    def __reduce__(self):
++        return (
++            self._from_reduced,
++            (
++                self._default,
++                self._feedback,
++                self._name,
++                self.__doc__,
++                tuple(self.keys()),
++                tuple(self.values())
++                )
++            )
+diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
+index 4ceeb0fc..2c41fb7c 100644
+--- a/qutip/solver/parallel.py
++++ b/qutip/solver/parallel.py
+@@ -1,370 +1,370 @@
+-"""
+-This module provides functions for parallel execution of loops and function
+-mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
+-"""
+-__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
+-
+-import multiprocessing
+-import os
+-import sys
+-import time
+-import threading
+-import concurrent.futures
+-from qutip.ui.progressbar import progess_bars
+-from qutip.settings import available_cpu_count
+-
+-if sys.platform == 'darwin':
+-    mp_context = multiprocessing.get_context('fork')
+-elif sys.platform == 'linux':
+-    # forkserver would handle threads better, but is much slower at starting
+-    # the executor and spawning tasks
+-    mp_context = multiprocessing.get_context('fork')
+-else:
+-    mp_context = multiprocessing.get_context()
+-
+-
+-default_map_kw = {
+-    'job_timeout': threading.TIMEOUT_MAX,
+-    'timeout': threading.TIMEOUT_MAX,
+-    'num_cpus': available_cpu_count(),
+-    'fail_fast': True,
+-}
+-
+-
+-def _read_map_kw(options):
+-    options = options or {}
+-    map_kw = default_map_kw.copy()
+-    map_kw.update({k: v for k, v in options.items() if v is not None})
+-    return map_kw
+-
+-
+-class MapExceptions(Exception):
+-    def __init__(self, msg, errors, results):
+-        super().__init__(msg, errors, results)
+-        self.errors = errors
+-        self.results = results
+-
+-
+-def serial_map(task, values, task_args=None, task_kwargs=None,
+-               reduce_func=None, map_kw=None,
+-               progress_bar=None, progress_bar_kwargs={}):
+-    """
+-    Serial mapping function with the same call signature as parallel_map, for
+-    easy switching between serial and parallel execution. This
+-    is functionally equivalent to::
+-
+-        result = [task(value, *task_args, **task_kwargs) for value in values]
+-
+-    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
+-
+-    Parameters
+-    ----------
+-    task : a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-    values : array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-    task_args : list / dictionary
+-        The optional additional argument to the ``task`` function.
+-    task_kwargs : list / dictionary
+-        The optional additional keyword argument to the ``task`` function.
+-    reduce_func : func (optional)
+-        If provided, it will be called with the output of each tasks instead of
+-        storing a them in a list.
+-    progress_bar : string
+-        Progress bar options's string for showing progress.
+-    progress_bar_kwargs : dict
+-        Options for the progress bar.
+-    map_kw: dict (optional)
+-        Dictionary containing:
+-        - timeout: float, Maximum time (sec) for the whole map.
+-        - fail_fast: bool, Raise an error at the first.
+-
+-    Returns
+-    -------
+-    result : list
+-        The result list contains the value of
+-        ``task(value, *task_args, **task_kwargs)`` for each
+-        value in ``values``. If a ``reduce_func`` is provided, and empty list
+-        will be returned.
+-
+-    """
+-    if task_args is None:
+-        task_args = ()
+-    if task_kwargs is None:
+-        task_kwargs = {}
+-    map_kw = _read_map_kw(map_kw)
+-    progress_bar = progess_bars[progress_bar]()
+-    progress_bar.start(len(values), **progress_bar_kwargs)
+-    end_time = map_kw['timeout'] + time.time()
+-    results = None
+-    if reduce_func is None:
+-        results = [None] * len(values)
+-    errors = {}
+-    for n, value in enumerate(values):
+-        if time.time() > end_time:
+-            break
+-        progress_bar.update(n)
+-        try:
+-            result = task(value, *task_args, **task_kwargs)
+-        except Exception as err:
+-            if map_kw["fail_fast"]:
+-                raise err
+-            else:
+-                errors[n] = err
+-        else:
+-            if reduce_func is not None:
+-                reduce_func(result)
+-            else:
+-                results[n] = result
+-    progress_bar.finished()
+-
+-    if errors:
+-        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
+-                            errors, results)
+-    return results
+-
+-
+-def parallel_map(task, values, task_args=None, task_kwargs=None,
+-                 reduce_func=None, map_kw=None,
+-                 progress_bar=None, progress_bar_kwargs={}):
+-    """
+-    Parallel execution of a mapping of `values` to the function `task`. This
+-    is functionally equivalent to::
+-
+-        result = [task(value, *task_args, **task_kwargs) for value in values]
+-
+-    Parameters
+-    ----------
+-    task : a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-    values : array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-    task_args : list / dictionary
+-        The optional additional argument to the ``task`` function.
+-    task_kwargs : list / dictionary
+-        The optional additional keyword argument to the ``task`` function.
+-    reduce_func : func (optional)
+-        If provided, it will be called with the output of each tasks instead of
+-        storing a them in a list. Note that the order in which results are
+-        passed to ``reduce_func`` is not defined.
+-    progress_bar : string
+-        Progress bar options's string for showing progress.
+-    progress_bar_kwargs : dict
+-        Options for the progress bar.
+-    map_kw: dict (optional)
+-        Dictionary containing entry for:
+-        - timeout: float, Maximum time (sec) for the whole map.
+-        - job_timeout: float, Maximum time (sec) for each job in the map.
+-        - num_cpus: int, Number of job to run at once.
+-        - fail_fast: bool, Raise an error at the first.
+-
+-    Returns
+-    -------
+-    result : list
+-        The result list contains the value of
+-        ``task(value, *task_args, **task_kwargs)`` for
+-        each value in ``values``. If a ``reduce_func`` is provided, and empty
+-        list will be returned.
+-
+-    """
+-    if task_args is None:
+-        task_args = ()
+-    if task_kwargs is None:
+-        task_kwargs = {}
+-    map_kw = _read_map_kw(map_kw)
+-    end_time = map_kw['timeout'] + time.time()
+-    job_time = map_kw['job_timeout']
+-
+-    progress_bar = progess_bars[progress_bar]()
+-    progress_bar.start(len(values), **progress_bar_kwargs)
+-
+-    errors = {}
+-    if reduce_func is not None:
+-        results = None
+-        result_func = lambda i, value: reduce_func(value)
+-    else:
+-        results = [None] * len(values)
+-        result_func = lambda i, value: results.__setitem__(i, value)
+-
+-    def _done_callback(future):
+-        if not future.cancelled():
+-            try:
+-                result = future.result()
+-            except Exception as e:
+-                errors[future._i] = e
+-        result_func(future._i, result)
+-        progress_bar.update()
+-
+-    if sys.version_info >= (3, 7):
+-        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
+-        ctx_kw = {"mp_context": mp_context}
+-    else:
+-        ctx_kw = {}
+-
+-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+-    try:
+-        with concurrent.futures.ProcessPoolExecutor(
+-            max_workers=map_kw['num_cpus'], **ctx_kw,
+-        ) as executor:
+-            waiting = set()
+-            i = 0
+-            while i < len(values):
+-                # feed values to the executor, ensuring that there is at
+-                # most one task per worker at any moment in time so that
+-                # we can shutdown without waiting for greater than the time
+-                # taken by the longest task
+-                if len(waiting) >= map_kw['num_cpus']:
+-                    # no space left, wait for a task to complete or
+-                    # the time to run out
+-                    timeout = max(0, end_time - time.time())
+-                    _done, waiting = concurrent.futures.wait(
+-                        waiting,
+-                        timeout=timeout,
+-                        return_when=concurrent.futures.FIRST_COMPLETED,
+-                    )
+-                if time.time() >= end_time or (errors and map_kw['fail_fast']):
+-                    # no time left, exit the loop
+-                    break
+-                while len(waiting) < map_kw['num_cpus'] and i < len(values):
+-                    # space and time available, add tasks
+-                    value = values[i]
+-                    future = executor.submit(
+-                        task, *((value,) + task_args), **task_kwargs,
+-                    )
+-                    # small hack to avoid add_done_callback not supporting
+-                    # extra arguments and closures inside loops retaining
+-                    # a reference not a value:
+-                    future._i = i
+-                    future.add_done_callback(_done_callback)
+-                    waiting.add(future)
+-                    i += 1
+-
+-            timeout = max(0, end_time - time.time())
+-            concurrent.futures.wait(waiting, timeout=timeout)
+-    finally:
+-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-
+-    progress_bar.finished()
+-    if errors and map_kw["fail_fast"]:
+-        raise list(errors.values())[0]
+-    elif errors:
+-        raise MapExceptions(
+-            f"{len(errors)} iterations failed in parallel_map",
+-            errors, results
+-        )
+-
+-    return results
+-
+-
+-def loky_pmap(task, values, task_args=None, task_kwargs=None,
+-              reduce_func=None, map_kw=None,
+-              progress_bar=None, progress_bar_kwargs={}):
+-    """
+-    Parallel execution of a mapping of `values` to the function `task`. This
+-    is functionally equivalent to::
+-
+-        result = [task(value, *task_args, **task_kwargs) for value in values]
+-
+-    Use the loky module instead of multiprocessing.
+-
+-    Parameters
+-    ----------
+-    task : a Python function
+-        The function that is to be called for each value in ``task_vec``.
+-    values : array / list
+-        The list or array of values for which the ``task`` function is to be
+-        evaluated.
+-    task_args : list / dictionary
+-        The optional additional argument to the ``task`` function.
+-    task_kwargs : list / dictionary
+-        The optional additional keyword argument to the ``task`` function.
+-    reduce_func : func (optional)
+-        If provided, it will be called with the output of each tasks instead of
+-        storing a them in a list.
+-    progress_bar : string
+-        Progress bar options's string for showing progress.
+-    progress_bar_kwargs : dict
+-        Options for the progress bar.
+-    map_kw: dict (optional)
+-        Dictionary containing entry for:
+-        - timeout: float, Maximum time (sec) for the whole map.
+-        - job_timeout: float, Maximum time (sec) for each job in the map.
+-        - num_cpus: int, Number of job to run at once.
+-        - fail_fast: bool, Raise an error at the first.
+-
+-    Returns
+-    --------
+-    result : list
+-        The result list contains the value of
+-        ``task(value, *task_args, **task_kwargs)`` for
+-        each value in ``values``. If a ``reduce_func`` is provided, and empty
+-        list will be returned.
+-
+-    """
+-    if task_args is None:
+-        task_args = ()
+-    if task_kwargs is None:
+-        task_kwargs = {}
+-    map_kw = _read_map_kw(map_kw)
+-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+-    from loky import get_reusable_executor, TimeoutError
+-
+-    progress_bar = progess_bars[progress_bar]()
+-    progress_bar.start(len(values), **progress_bar_kwargs)
+-
+-    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
+-    end_time = map_kw['timeout'] + time.time()
+-    job_time = map_kw['job_timeout']
+-    results = None
+-    errors = {}
+-    if reduce_func is None:
+-        results = [None] * len(values)
+-
+-    try:
+-        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
+-               for value in values]
+-
+-        for n, job in enumerate(jobs):
+-            remaining_time = min(end_time - time.time(), job_time)
+-            try:
+-                result = job.result(remaining_time)
+-            except Exception as err:
+-                if map_kw["fail_fast"]:
+-                    raise err
+-                else:
+-                    errors[n] = err
+-            else:
+-                if reduce_func is not None:
+-                    reduce_func(result)
+-                else:
+-                    results[n] = result
+-            progress_bar.update()
+-
+-    except KeyboardInterrupt as e:
+-        [job.cancel() for job in jobs]
+-        raise e
+-
+-    except TimeoutError:
+-        [job.cancel() for job in jobs]
+-
+-    finally:
+-        executor.shutdown()
+-    progress_bar.finished()
+-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+-    if errors:
+-        raise MapExceptions(
+-            f"{len(errors)} iterations failed in loky_pmap",
+-            errors, results
+-        )
+-    return results
+-
+-
+-_get_map = {
+-    "parallel_map": parallel_map,
+-    "parallel": parallel_map,
+-    "serial_map": serial_map,
+-    "serial": serial_map,
+-    "loky": loky_pmap
+-}
++"""
++This module provides functions for parallel execution of loops and function
++mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
++"""
++__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
++
++import multiprocessing
++import os
++import sys
++import time
++import threading
++import concurrent.futures
++from qutip.ui.progressbar import progess_bars
++from qutip.settings import available_cpu_count
++
++if sys.platform == 'darwin':
++    mp_context = multiprocessing.get_context('fork')
++elif sys.platform == 'linux':
++    # forkserver would handle threads better, but is much slower at starting
++    # the executor and spawning tasks
++    mp_context = multiprocessing.get_context('fork')
++else:
++    mp_context = multiprocessing.get_context()
++
++
++default_map_kw = {
++    'job_timeout': threading.TIMEOUT_MAX,
++    'timeout': threading.TIMEOUT_MAX,
++    'num_cpus': available_cpu_count(),
++    'fail_fast': True,
++}
++
++
++def _read_map_kw(options):
++    options = options or {}
++    map_kw = default_map_kw.copy()
++    map_kw.update({k: v for k, v in options.items() if v is not None})
++    return map_kw
++
++
++class MapExceptions(Exception):
++    def __init__(self, msg, errors, results):
++        super().__init__(msg, errors, results)
++        self.errors = errors
++        self.results = results
++
++
++def serial_map(task, values, task_args=None, task_kwargs=None,
++               reduce_func=None, map_kw=None,
++               progress_bar=None, progress_bar_kwargs={}):
++    """
++    Serial mapping function with the same call signature as parallel_map, for
++    easy switching between serial and parallel execution. This
++    is functionally equivalent to::
++
++        result = [task(value, *task_args, **task_kwargs) for value in values]
++
++    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
++
++    Parameters
++    ----------
++    task : a Python function
++        The function that is to be called for each value in ``task_vec``.
++    values : array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++    task_args : list / dictionary
++        The optional additional argument to the ``task`` function.
++    task_kwargs : list / dictionary
++        The optional additional keyword argument to the ``task`` function.
++    reduce_func : func (optional)
++        If provided, it will be called with the output of each tasks instead of
++        storing a them in a list.
++    progress_bar : string
++        Progress bar options's string for showing progress.
++    progress_bar_kwargs : dict
++        Options for the progress bar.
++    map_kw: dict (optional)
++        Dictionary containing:
++        - timeout: float, Maximum time (sec) for the whole map.
++        - fail_fast: bool, Raise an error at the first.
++
++    Returns
++    -------
++    result : list
++        The result list contains the value of
++        ``task(value, *task_args, **task_kwargs)`` for each
++        value in ``values``. If a ``reduce_func`` is provided, and empty list
++        will be returned.
++
++    """
++    if task_args is None:
++        task_args = ()
++    if task_kwargs is None:
++        task_kwargs = {}
++    map_kw = _read_map_kw(map_kw)
++    progress_bar = progess_bars[progress_bar]()
++    progress_bar.start(len(values), **progress_bar_kwargs)
++    end_time = map_kw['timeout'] + time.time()
++    results = None
++    if reduce_func is None:
++        results = [None] * len(values)
++    errors = {}
++    for n, value in enumerate(values):
++        if time.time() > end_time:
++            break
++        progress_bar.update(n)
++        try:
++            result = task(value, *task_args, **task_kwargs)
++        except Exception as err:
++            if map_kw["fail_fast"]:
++                raise err
++            else:
++                errors[n] = err
++        else:
++            if reduce_func is not None:
++                reduce_func(result)
++            else:
++                results[n] = result
++    progress_bar.finished()
++
++    if errors:
++        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
++                            errors, results)
++    return results
++
++
++def parallel_map(task, values, task_args=None, task_kwargs=None,
++                 reduce_func=None, map_kw=None,
++                 progress_bar=None, progress_bar_kwargs={}):
++    """
++    Parallel execution of a mapping of `values` to the function `task`. This
++    is functionally equivalent to::
++
++        result = [task(value, *task_args, **task_kwargs) for value in values]
++
++    Parameters
++    ----------
++    task : a Python function
++        The function that is to be called for each value in ``task_vec``.
++    values : array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++    task_args : list / dictionary
++        The optional additional argument to the ``task`` function.
++    task_kwargs : list / dictionary
++        The optional additional keyword argument to the ``task`` function.
++    reduce_func : func (optional)
++        If provided, it will be called with the output of each tasks instead of
++        storing a them in a list. Note that the order in which results are
++        passed to ``reduce_func`` is not defined.
++    progress_bar : string
++        Progress bar options's string for showing progress.
++    progress_bar_kwargs : dict
++        Options for the progress bar.
++    map_kw: dict (optional)
++        Dictionary containing entry for:
++        - timeout: float, Maximum time (sec) for the whole map.
++        - job_timeout: float, Maximum time (sec) for each job in the map.
++        - num_cpus: int, Number of job to run at once.
++        - fail_fast: bool, Raise an error at the first.
++
++    Returns
++    -------
++    result : list
++        The result list contains the value of
++        ``task(value, *task_args, **task_kwargs)`` for
++        each value in ``values``. If a ``reduce_func`` is provided, and empty
++        list will be returned.
++
++    """
++    if task_args is None:
++        task_args = ()
++    if task_kwargs is None:
++        task_kwargs = {}
++    map_kw = _read_map_kw(map_kw)
++    end_time = map_kw['timeout'] + time.time()
++    job_time = map_kw['job_timeout']
++
++    progress_bar = progess_bars[progress_bar]()
++    progress_bar.start(len(values), **progress_bar_kwargs)
++
++    errors = {}
++    if reduce_func is not None:
++        results = None
++        result_func = lambda i, value: reduce_func(value)
++    else:
++        results = [None] * len(values)
++        result_func = lambda i, value: results.__setitem__(i, value)
++
++    def _done_callback(future):
++        if not future.cancelled():
++            try:
++                result = future.result()
++            except Exception as e:
++                errors[future._i] = e
++        result_func(future._i, result)
++        progress_bar.update()
++
++    if sys.version_info >= (3, 7):
++        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
++        ctx_kw = {"mp_context": mp_context}
++    else:
++        ctx_kw = {}
++
++    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
++    try:
++        with concurrent.futures.ProcessPoolExecutor(
++            max_workers=map_kw['num_cpus'], **ctx_kw,
++        ) as executor:
++            waiting = set()
++            i = 0
++            while i < len(values):
++                # feed values to the executor, ensuring that there is at
++                # most one task per worker at any moment in time so that
++                # we can shutdown without waiting for greater than the time
++                # taken by the longest task
++                if len(waiting) >= map_kw['num_cpus']:
++                    # no space left, wait for a task to complete or
++                    # the time to run out
++                    timeout = max(0, end_time - time.time())
++                    _done, waiting = concurrent.futures.wait(
++                        waiting,
++                        timeout=timeout,
++                        return_when=concurrent.futures.FIRST_COMPLETED,
++                    )
++                if time.time() >= end_time or (errors and map_kw['fail_fast']):
++                    # no time left, exit the loop
++                    break
++                while len(waiting) < map_kw['num_cpus'] and i < len(values):
++                    # space and time available, add tasks
++                    value = values[i]
++                    future = executor.submit(
++                        task, *((value,) + task_args), **task_kwargs,
++                    )
++                    # small hack to avoid add_done_callback not supporting
++                    # extra arguments and closures inside loops retaining
++                    # a reference not a value:
++                    future._i = i
++                    future.add_done_callback(_done_callback)
++                    waiting.add(future)
++                    i += 1
++
++            timeout = max(0, end_time - time.time())
++            concurrent.futures.wait(waiting, timeout=timeout)
++    finally:
++        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++
++    progress_bar.finished()
++    if errors and map_kw["fail_fast"]:
++        raise list(errors.values())[0]
++    elif errors:
++        raise MapExceptions(
++            f"{len(errors)} iterations failed in parallel_map",
++            errors, results
++        )
++
++    return results
++
++
++def loky_pmap(task, values, task_args=None, task_kwargs=None,
++              reduce_func=None, map_kw=None,
++              progress_bar=None, progress_bar_kwargs={}):
++    """
++    Parallel execution of a mapping of `values` to the function `task`. This
++    is functionally equivalent to::
++
++        result = [task(value, *task_args, **task_kwargs) for value in values]
++
++    Use the loky module instead of multiprocessing.
++
++    Parameters
++    ----------
++    task : a Python function
++        The function that is to be called for each value in ``task_vec``.
++    values : array / list
++        The list or array of values for which the ``task`` function is to be
++        evaluated.
++    task_args : list / dictionary
++        The optional additional argument to the ``task`` function.
++    task_kwargs : list / dictionary
++        The optional additional keyword argument to the ``task`` function.
++    reduce_func : func (optional)
++        If provided, it will be called with the output of each tasks instead of
++        storing a them in a list.
++    progress_bar : string
++        Progress bar options's string for showing progress.
++    progress_bar_kwargs : dict
++        Options for the progress bar.
++    map_kw: dict (optional)
++        Dictionary containing entry for:
++        - timeout: float, Maximum time (sec) for the whole map.
++        - job_timeout: float, Maximum time (sec) for each job in the map.
++        - num_cpus: int, Number of job to run at once.
++        - fail_fast: bool, Raise an error at the first.
++
++    Returns
++    --------
++    result : list
++        The result list contains the value of
++        ``task(value, *task_args, **task_kwargs)`` for
++        each value in ``values``. If a ``reduce_func`` is provided, and empty
++        list will be returned.
++
++    """
++    if task_args is None:
++        task_args = ()
++    if task_kwargs is None:
++        task_kwargs = {}
++    map_kw = _read_map_kw(map_kw)
++    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
++    from loky import get_reusable_executor, TimeoutError
++
++    progress_bar = progess_bars[progress_bar]()
++    progress_bar.start(len(values), **progress_bar_kwargs)
++
++    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
++    end_time = map_kw['timeout'] + time.time()
++    job_time = map_kw['job_timeout']
++    results = None
++    errors = {}
++    if reduce_func is None:
++        results = [None] * len(values)
++
++    try:
++        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
++               for value in values]
++
++        for n, job in enumerate(jobs):
++            remaining_time = min(end_time - time.time(), job_time)
++            try:
++                result = job.result(remaining_time)
++            except Exception as err:
++                if map_kw["fail_fast"]:
++                    raise err
++                else:
++                    errors[n] = err
++            else:
++                if reduce_func is not None:
++                    reduce_func(result)
++                else:
++                    results[n] = result
++            progress_bar.update()
++
++    except KeyboardInterrupt as e:
++        [job.cancel() for job in jobs]
++        raise e
++
++    except TimeoutError:
++        [job.cancel() for job in jobs]
++
++    finally:
++        executor.shutdown()
++    progress_bar.finished()
++    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
++    if errors:
++        raise MapExceptions(
++            f"{len(errors)} iterations failed in loky_pmap",
++            errors, results
++        )
++    return results
++
++
++_get_map = {
++    "parallel_map": parallel_map,
++    "parallel": parallel_map,
++    "serial_map": serial_map,
++    "serial": serial_map,
++    "loky": loky_pmap
++}
+diff --git a/qutip/solver/propagator.py b/qutip/solver/propagator.py
+index 179c0dce..5ad10b6c 100644
+--- a/qutip/solver/propagator.py
++++ b/qutip/solver/propagator.py
+@@ -1,278 +1,278 @@
+-__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
+-
+-import numbers
+-import numpy as np
+-
+-from .. import Qobj, qeye, unstack_columns, QobjEvo
+-from ..core import data as _data
+-from .mesolve import mesolve, MESolver
+-from .sesolve import sesolve, SESolver
+-from .heom.bofin_solvers import HEOMSolver
+-from .solver_base import Solver
+-from .multitraj import MultiTrajSolver
+-
+-
+-def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
+-    r"""
+-    Calculate the propagator U(t) for the density matrix or wave function such
+-    that :math:`\psi(t) = U(t)\psi(0)` or
+-    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
+-    where :math:`\rho_{\mathrm vec}` is the vector representation of the
+-    density matrix.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+-        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
+-        that can be made into :class:`QobjEvo` are also accepted.
+-
+-    t : float or array-like
+-        Time or list of times for which to evaluate the propagator.
+-
+-    c_ops : list, optional
+-        List of Qobj or QobjEvo collapse operators.
+-
+-    args : dictionary, optional
+-        Parameters to callback functions for time-dependent Hamiltonians and
+-        collapse operators.
+-
+-    options : dict, optional
+-        Options for the solver.
+-
+-    **kwargs :
+-        Extra parameters to use when creating the :class:`QobjEvo` from a list
+-        format ``H``.
+-
+-    Returns
+-    -------
+-    U : qobj, list
+-        Instance representing the propagator(s) :math:`U(t)`. Return a single
+-        Qobj when ``t`` is a number or a list when ``t`` is a list.
+-
+-    """
+-    if isinstance(t, numbers.Real):
+-        tlist = [0, t]
+-        list_output = False
+-    else:
+-        tlist = t
+-        list_output = True
+-
+-    if not isinstance(H, (Qobj, QobjEvo)):
+-        H = QobjEvo(H, args=args, **kwargs)
+-
+-    if H.issuper or c_ops:
+-        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
+-                      args=args, options=options).states
+-    else:
+-        out = sesolve(H, qeye(H.dims[0]), tlist,
+-                      args=args, options=options).states
+-
+-    if list_output:
+-        return out
+-    else:
+-        return out[-1]
+-
+-
+-def propagator_steadystate(U):
+-    r"""Find the steady state for successive applications of the propagator
+-    :math:`U`.
+-
+-    Parameters
+-    ----------
+-    U : qobj
+-        Operator representing the propagator.
+-
+-    Returns
+-    -------
+-    a : qobj
+-        Instance representing the steady-state density matrix.
+-    """
+-    evals, estates = U.eigenstates()
+-    shifted_vals = np.abs(evals - 1.0)
+-    ev_idx = np.argmin(shifted_vals)
+-    rho_data = unstack_columns(estates[ev_idx].data)
+-    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
+-    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
+-                dims=U.dims[0],
+-                type='oper',
+-                isherm=True,
+-                copy=False)
+-
+-
+-class Propagator:
+-    """
+-    A generator of propagator for a system.
+-
+-    Usage:
+-        U = Propagator(H, c_ops)
+-        psi_t = U(t) @ psi_0
+-
+-    Save some previously computed propagator are stored to speed up subsequent
+-    computation. Changing ``args`` will erase these stored probagator.
+-
+-    Parameters
+-    ----------
+-    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
+-        Possibly time-dependent system driving the evolution, either already
+-        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
+-        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
+-        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
+-        be made into :class:`QobjEvo` are also accepted.
+-
+-        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
+-        not supported.
+-
+-    c_ops : list, optional
+-        List of Qobj or QobjEvo collapse operators.
+-
+-    args : dictionary
+-        Parameters to callback functions for time-dependent Hamiltonians and
+-        collapse operators.
+-
+-    options : dict
+-        Options for the solver.
+-
+-    memoize : int [10]
+-        Max number of propagator to save.
+-
+-    tol : float [1e-14]
+-        Absolute tolerance for the time. If a previous propagator was computed
+-        at a time within tolerance, that propagator will be returned.
+-
+-    .. note::
+-        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
+-        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
+-        into a :class:`QobjEvo` with ::
+-            U = QobjEvo(Propagator(H))
+-    """
+-    def __init__(self, system, *, c_ops=(), args=None, options=None,
+-                 memoize=10, tol=1e-14):
+-        if isinstance(system, MultiTrajSolver):
+-            raise TypeError("Non-deterministic solvers cannot be used "
+-                            "as a propagator system")
+-        elif isinstance(system, HEOMSolver):
+-            raise NotImplementedError(
+-                "HEOM is not supported by Propagator. "
+-                "Please, tell us on GitHub issues if you need it!"
+-            )
+-        elif isinstance(system, Solver):
+-            self.solver = system
+-        else:
+-            Hevo = QobjEvo(system, args=args)
+-            c_ops = [QobjEvo(op, args=args) for op in c_ops]
+-            if Hevo.issuper or c_ops:
+-                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
+-            else:
+-                self.solver = SESolver(Hevo, options=options)
+-
+-        self.times = [0]
+-        self.invs = [None]
+-        self.props = [qeye(self.solver.sys_dims)]
+-        self.solver.start(self.props[0], self.times[0])
+-        self.cte = self.solver.rhs.isconstant
+-        H_0 = self.solver.rhs(0)
+-        self.unitary = not H_0.issuper and H_0.isherm
+-        self.args = args
+-        self.memoize = max(3, int(memoize))
+-        self.tol = tol
+-
+-    def _lookup_or_compute(self, t):
+-        """
+-        Get U(t) from cache or compute it.
+-        """
+-        idx = np.searchsorted(self.times, t)
+-        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
+-            U = self.props[idx]
+-        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
+-            U = self.props[idx-1]
+-        else:
+-            U = self._compute(t, idx)
+-            self._insert(t, U, idx)
+-        return U
+-
+-    def __call__(self, t, t_start=0, **args):
+-        """
+-        Get the propagator from ``t_start`` to ``t``.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time at which to compute the propagator.
+-        t_start: float [0]
+-            Time at which the propagator start such that:
+-                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
+-        args : dict
+-            Argument to pass to a time dependent Hamiltonian.
+-            Updating ``args`` take effect since ``t=0`` and the new ``args``
+-            will be used in future call.
+-        """
+-        # We could improve it when the system is constant using U(2t) = U(t)**2
+-        if not self.cte and args and args != self.args:
+-            self.args = args
+-            self.solver._argument(args)
+-            self.times = [0]
+-            self.props = [qeye(self.props[0].dims[0])]
+-            self.solver.start(self.props[0], self.times[0])
+-
+-        if t_start:
+-            if t == t_start:
+-                U = self._lookup_or_compute(0)
+-            if self.cte:
+-                U = self._lookup_or_compute(t - t_start)
+-            else:
+-                Uinv = self._inv(self._lookup_or_compute(t_start))
+-                U = self._lookup_or_compute(t) @ Uinv
+-        else:
+-            U = self._lookup_or_compute(t)
+-        return U
+-
+-    def inv(self, t, **args):
+-        """
+-        Get the inverse of the propagator at ``t``, such that
+-            ``psi_0 = U.inv(t) @ psi_t``
+-
+-        Parameters
+-        ----------
+-        t : float
+-            Time at which to compute the propagator.
+-        args : dict
+-            Argument to pass to a time dependent Hamiltonian.
+-            Updating ``args`` take effect since ``t=0`` and the new ``args``
+-            will be used in future call.
+-        """
+-        return self._inv(self(t, **args))
+-
+-    def _compute(self, t, idx):
+-        """
+-        Compute the propagator at ``t``, ``idx`` point to a pair of
+-        (time, propagator) close to the desired time.
+-        """
+-        t_last = self.solver._integrator.get_state(copy=False)[0]
+-        if self.times[idx-1] <= t_last <= t:
+-            U = self.solver.step(t)
+-        elif idx > 0:
+-            self.solver.start(self.props[idx-1], self.times[idx-1])
+-            U = self.solver.step(t)
+-        else:
+-            # Evolving backward in time is not supported by all integrator.
+-            self.solver.start(qeye(self.props[0].dims[0]), t)
+-            Uinv = self.solver.step(self.times[idx])
+-            U = self._inv(Uinv)
+-        return U
+-
+-    def _inv(self, U):
+-        return U.dag() if self.unitary else U.inv()
+-
+-    def _insert(self, t, U, idx):
+-        """
+-        Insert a new pair of (time, propagator) to the memorized states.
+-        """
+-        while len(self.times) >= self.memoize:
+-            rm_idx = self.memoize // 2
+-            if self.times[rm_idx] < t:
+-                idx -= 1
+-            del self.times[rm_idx]
+-            del self.props[rm_idx]
+-        self.times.insert(idx, t)
+-        self.props.insert(idx, U)
++__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
++
++import numbers
++import numpy as np
++
++from .. import Qobj, qeye, unstack_columns, QobjEvo
++from ..core import data as _data
++from .mesolve import mesolve, MESolver
++from .sesolve import sesolve, SESolver
++from .heom.bofin_solvers import HEOMSolver
++from .solver_base import Solver
++from .multitraj import MultiTrajSolver
++
++
++def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
++    r"""
++    Calculate the propagator U(t) for the density matrix or wave function such
++    that :math:`\psi(t) = U(t)\psi(0)` or
++    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
++    where :math:`\rho_{\mathrm vec}` is the vector representation of the
++    density matrix.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
++        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
++        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
++        that can be made into :class:`QobjEvo` are also accepted.
++
++    t : float or array-like
++        Time or list of times for which to evaluate the propagator.
++
++    c_ops : list, optional
++        List of Qobj or QobjEvo collapse operators.
++
++    args : dictionary, optional
++        Parameters to callback functions for time-dependent Hamiltonians and
++        collapse operators.
++
++    options : dict, optional
++        Options for the solver.
++
++    **kwargs :
++        Extra parameters to use when creating the :class:`QobjEvo` from a list
++        format ``H``.
++
++    Returns
++    -------
++    U : qobj, list
++        Instance representing the propagator(s) :math:`U(t)`. Return a single
++        Qobj when ``t`` is a number or a list when ``t`` is a list.
++
++    """
++    if isinstance(t, numbers.Real):
++        tlist = [0, t]
++        list_output = False
++    else:
++        tlist = t
++        list_output = True
++
++    if not isinstance(H, (Qobj, QobjEvo)):
++        H = QobjEvo(H, args=args, **kwargs)
++
++    if H.issuper or c_ops:
++        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
++                      args=args, options=options).states
++    else:
++        out = sesolve(H, qeye(H.dims[0]), tlist,
++                      args=args, options=options).states
++
++    if list_output:
++        return out
++    else:
++        return out[-1]
++
++
++def propagator_steadystate(U):
++    r"""Find the steady state for successive applications of the propagator
++    :math:`U`.
++
++    Parameters
++    ----------
++    U : qobj
++        Operator representing the propagator.
++
++    Returns
++    -------
++    a : qobj
++        Instance representing the steady-state density matrix.
++    """
++    evals, estates = U.eigenstates()
++    shifted_vals = np.abs(evals - 1.0)
++    ev_idx = np.argmin(shifted_vals)
++    rho_data = unstack_columns(estates[ev_idx].data)
++    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
++    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
++                dims=U.dims[0],
++                type='oper',
++                isherm=True,
++                copy=False)
++
++
++class Propagator:
++    """
++    A generator of propagator for a system.
++
++    Usage:
++        U = Propagator(H, c_ops)
++        psi_t = U(t) @ psi_0
++
++    Save some previously computed propagator are stored to speed up subsequent
++    computation. Changing ``args`` will erase these stored probagator.
++
++    Parameters
++    ----------
++    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
++        Possibly time-dependent system driving the evolution, either already
++        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
++        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
++        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
++        be made into :class:`QobjEvo` are also accepted.
++
++        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
++        not supported.
++
++    c_ops : list, optional
++        List of Qobj or QobjEvo collapse operators.
++
++    args : dictionary
++        Parameters to callback functions for time-dependent Hamiltonians and
++        collapse operators.
++
++    options : dict
++        Options for the solver.
++
++    memoize : int [10]
++        Max number of propagator to save.
++
++    tol : float [1e-14]
++        Absolute tolerance for the time. If a previous propagator was computed
++        at a time within tolerance, that propagator will be returned.
++
++    .. note::
++        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
++        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
++        into a :class:`QobjEvo` with ::
++            U = QobjEvo(Propagator(H))
++    """
++    def __init__(self, system, *, c_ops=(), args=None, options=None,
++                 memoize=10, tol=1e-14):
++        if isinstance(system, MultiTrajSolver):
++            raise TypeError("Non-deterministic solvers cannot be used "
++                            "as a propagator system")
++        elif isinstance(system, HEOMSolver):
++            raise NotImplementedError(
++                "HEOM is not supported by Propagator. "
++                "Please, tell us on GitHub issues if you need it!"
++            )
++        elif isinstance(system, Solver):
++            self.solver = system
++        else:
++            Hevo = QobjEvo(system, args=args)
++            c_ops = [QobjEvo(op, args=args) for op in c_ops]
++            if Hevo.issuper or c_ops:
++                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
++            else:
++                self.solver = SESolver(Hevo, options=options)
++
++        self.times = [0]
++        self.invs = [None]
++        self.props = [qeye(self.solver.sys_dims)]
++        self.solver.start(self.props[0], self.times[0])
++        self.cte = self.solver.rhs.isconstant
++        H_0 = self.solver.rhs(0)
++        self.unitary = not H_0.issuper and H_0.isherm
++        self.args = args
++        self.memoize = max(3, int(memoize))
++        self.tol = tol
++
++    def _lookup_or_compute(self, t):
++        """
++        Get U(t) from cache or compute it.
++        """
++        idx = np.searchsorted(self.times, t)
++        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
++            U = self.props[idx]
++        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
++            U = self.props[idx-1]
++        else:
++            U = self._compute(t, idx)
++            self._insert(t, U, idx)
++        return U
++
++    def __call__(self, t, t_start=0, **args):
++        """
++        Get the propagator from ``t_start`` to ``t``.
++
++        Parameters
++        ----------
++        t : float
++            Time at which to compute the propagator.
++        t_start: float [0]
++            Time at which the propagator start such that:
++                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
++        args : dict
++            Argument to pass to a time dependent Hamiltonian.
++            Updating ``args`` take effect since ``t=0`` and the new ``args``
++            will be used in future call.
++        """
++        # We could improve it when the system is constant using U(2t) = U(t)**2
++        if not self.cte and args and args != self.args:
++            self.args = args
++            self.solver._argument(args)
++            self.times = [0]
++            self.props = [qeye(self.props[0].dims[0])]
++            self.solver.start(self.props[0], self.times[0])
++
++        if t_start:
++            if t == t_start:
++                U = self._lookup_or_compute(0)
++            if self.cte:
++                U = self._lookup_or_compute(t - t_start)
++            else:
++                Uinv = self._inv(self._lookup_or_compute(t_start))
++                U = self._lookup_or_compute(t) @ Uinv
++        else:
++            U = self._lookup_or_compute(t)
++        return U
++
++    def inv(self, t, **args):
++        """
++        Get the inverse of the propagator at ``t``, such that
++            ``psi_0 = U.inv(t) @ psi_t``
++
++        Parameters
++        ----------
++        t : float
++            Time at which to compute the propagator.
++        args : dict
++            Argument to pass to a time dependent Hamiltonian.
++            Updating ``args`` take effect since ``t=0`` and the new ``args``
++            will be used in future call.
++        """
++        return self._inv(self(t, **args))
++
++    def _compute(self, t, idx):
++        """
++        Compute the propagator at ``t``, ``idx`` point to a pair of
++        (time, propagator) close to the desired time.
++        """
++        t_last = self.solver._integrator.get_state(copy=False)[0]
++        if self.times[idx-1] <= t_last <= t:
++            U = self.solver.step(t)
++        elif idx > 0:
++            self.solver.start(self.props[idx-1], self.times[idx-1])
++            U = self.solver.step(t)
++        else:
++            # Evolving backward in time is not supported by all integrator.
++            self.solver.start(qeye(self.props[0].dims[0]), t)
++            Uinv = self.solver.step(self.times[idx])
++            U = self._inv(Uinv)
++        return U
++
++    def _inv(self, U):
++        return U.dag() if self.unitary else U.inv()
++
++    def _insert(self, t, U, idx):
++        """
++        Insert a new pair of (time, propagator) to the memorized states.
++        """
++        while len(self.times) >= self.memoize:
++            rm_idx = self.memoize // 2
++            if self.times[rm_idx] < t:
++                idx -= 1
++            del self.times[rm_idx]
++            del self.props[rm_idx]
++        self.times.insert(idx, t)
++        self.props.insert(idx, U)
+diff --git a/qutip/solver/result.py b/qutip/solver/result.py
+index a87ad920..c6360d4e 100644
+--- a/qutip/solver/result.py
++++ b/qutip/solver/result.py
+@@ -1,972 +1,972 @@
+-""" Class for solve function results"""
+-import numpy as np
+-from ..core import Qobj, QobjEvo, expect, qzero
+-
+-__all__ = ["Result", "MultiTrajResult", "McResult"]
+-
+-
+-class _QobjExpectEop:
+-    """
+-    Pickable e_ops callable that calculates the expectation value for a given
+-    operator.
+-
+-    Parameters
+-    ----------
+-    op : :obj:`~Qobj`
+-        The expectation value operator.
+-    """
+-    def __init__(self, op):
+-        self.op = op
+-
+-    def __call__(self, t, state):
+-        return expect(self.op, state)
+-
+-
+-class ExpectOp:
+-    """
+-    A result e_op (expectation operation).
+-
+-    Parameters
+-    ----------
+-    op : object
+-        The original object used to define the e_op operation, e.g. a
+-        :~obj:`Qobj` or a function ``f(t, state)``.
+-
+-    f : function
+-        A callable ``f(t, state)`` that will return the value of the e_op
+-        for the specified state and time.
+-
+-    append : function
+-        A callable ``append(value)``, e.g. ``expect[k].append``, that will
+-        store the result of the e_ops function ``f(t, state)``.
+-
+-    Attributes
+-    ----------
+-    op : object
+-        The original object used to define the e_op operation.
+-    """
+-    def __init__(self, op, f, append):
+-        self.op = op
+-        self._f = f
+-        self._append = append
+-
+-    def __call__(self, t, state):
+-        """
+-        Return the expectation value for the given time, ``t`` and
+-        state, ``state``.
+-        """
+-        return self._f(t, state)
+-
+-    def _store(self, t, state):
+-        """
+-        Store the result of the e_op function. Should only be called by
+-        :class:`~Result`.
+-        """
+-        self._append(self._f(t, state))
+-
+-
+-class _BaseResult:
+-    """
+-    Common method for all ``Result``.
+-    """
+-    def __init__(self, options, *, solver=None, stats=None):
+-        self.solver = solver
+-        if stats is None:
+-            stats = {}
+-        self.stats = stats
+-
+-        self._state_processors = []
+-        self._state_processors_require_copy = False
+-
+-        self.options = options
+-
+-    def _e_ops_to_dict(self, e_ops):
+-        """ Convert the supplied e_ops to a dictionary of Eop instances. """
+-        if e_ops is None:
+-            e_ops = {}
+-        elif isinstance(e_ops, (list, tuple)):
+-            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
+-        elif isinstance(e_ops, dict):
+-            pass
+-        else:
+-            e_ops = {0: e_ops}
+-        return e_ops
+-
+-    def add_processor(self, f, requires_copy=False):
+-        """
+-        Append a processor ``f`` to the list of state processors.
+-
+-        Parameters
+-        ----------
+-        f : function, ``f(t, state)``
+-            A function to be called each time a state is added to this
+-            result object. The state is the state passed to ``.add``, after
+-            applying the pre-processors, if any.
+-
+-        requires_copy : bool, default False
+-            Whether this processor requires a copy of the state rather than
+-            a reference. A processor must never modify the supplied state, but
+-            if a processor stores the state it should set ``require_copy`` to
+-            true.
+-        """
+-        self._state_processors.append(f)
+-        self._state_processors_require_copy |= requires_copy
+-
+-
+-class Result(_BaseResult):
+-    """
+-    Base class for storing solver results.
+-
+-    Parameters
+-    ----------
+-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+-        The ``e_ops`` parameter defines the set of values to record at
+-        each time step ``t``. If an element is a :obj:`~Qobj` or
+-        :obj:`~QobjEvo` the value recorded is the expectation value of that
+-        operator given the state at ``t``. If the element is a function, ``f``,
+-        the value recorded is ``f(t, state)``.
+-
+-        The values are recorded in the ``e_data`` and ``expect`` attributes of
+-        this result object. ``e_data`` is a dictionary and ``expect`` is a
+-        list, where each item contains the values of the corresponding
+-        ``e_op``.
+-
+-    options : dict
+-        The options for this result class.
+-
+-    solver : str or None
+-        The name of the solver generating these results.
+-
+-    stats : dict or None
+-        The stats generated by the solver while producing these results. Note
+-        that the solver may update the stats directly while producing results.
+-
+-    kw : dict
+-        Additional parameters specific to a result sub-class.
+-
+-    Attributes
+-    ----------
+-    times : list
+-        A list of the times at which the expectation values and states were
+-        recorded.
+-
+-    states : list of :obj:`~Qobj`
+-        The state at each time ``t`` (if the recording of the state was
+-        requested).
+-
+-    final_state : :obj:`~Qobj`:
+-        The final state (if the recording of the final state was requested).
+-
+-    expect : list of arrays of expectation values
+-        A list containing the values of each ``e_op``. The list is in
+-        the same order in which the ``e_ops`` were supplied and empty if
+-        no ``e_ops`` were given.
+-
+-        Each element is itself a list and contains the values of the
+-        corresponding ``e_op``, with one value for each time in ``.times``.
+-
+-        The same lists of values may be accessed via the ``.e_data`` dictionary
+-        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
+-
+-    e_data : dict
+-        A dictionary containing the values of each ``e_op``. If the ``e_ops``
+-        were supplied as a dictionary, the keys are the same as in
+-        that dictionary. Otherwise the keys are the index of the ``e_op``
+-        in the ``.expect`` list.
+-
+-        The lists of expectation values returned are the *same* lists as
+-        those returned by ``.expect``.
+-
+-    e_ops : dict
+-        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
+-        The keys of the dictionary are the same as for ``.e_data``.
+-        Each value is object where ``.e_ops[k](t, state)`` calculates the
+-        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
+-        ``.e_ops[k].op`` is the original object supplied to create the
+-        ``e_op``.
+-
+-    solver : str or None
+-        The name of the solver generating these results.
+-
+-    stats : dict or None
+-        The stats generated by the solver while producing these results.
+-
+-    options : dict
+-        The options for this result class.
+-    """
+-    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
+-        super().__init__(options, solver=solver, stats=stats)
+-        raw_ops = self._e_ops_to_dict(e_ops)
+-        self.e_data = {k: [] for k in raw_ops}
+-        self.e_ops = {}
+-        for k, op in raw_ops.items():
+-            f = self._e_op_func(op)
+-            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
+-            self.add_processor(self.e_ops[k]._store)
+-
+-        self.times = []
+-        self.states = []
+-        self.final_state = None
+-
+-        self._post_init(**kw)
+-
+-    def _e_op_func(self, e_op):
+-        """
+-        Convert an e_op entry into a function, ``f(t, state)`` that returns
+-        the appropriate value (usually an expectation value).
+-
+-        Sub-classes may override this function to calculate expectation values
+-        in different ways.
+-        """
+-        if isinstance(e_op, Qobj):
+-            return _QobjExpectEop(e_op)
+-        elif isinstance(e_op, QobjEvo):
+-            return e_op.expect
+-        elif callable(e_op):
+-            return e_op
+-        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
+-
+-    def _post_init(self):
+-        """
+-        Perform post __init__ initialisation. In particular, add state
+-        processors or pre-processors.
+-
+-        Sub-class may override this. If the sub-class wishes to register the
+-        default processors for storing states, it should call this parent
+-        ``.post_init()`` method.
+-
+-        Sub-class ``.post_init()`` implementation may take additional keyword
+-        arguments if required.
+-        """
+-        store_states = self.options['store_states']
+-        store_final_state = self.options['store_final_state']
+-
+-        if store_states is None:
+-            store_states = len(self.e_ops) == 0
+-        if store_states:
+-            self.add_processor(self._store_state, requires_copy=True)
+-
+-        if store_states or store_final_state:
+-            self.add_processor(self._store_final_state, requires_copy=True)
+-
+-    def _store_state(self, t, state):
+-        """ Processor that stores a state in ``.states``. """
+-        self.states.append(state)
+-
+-    def _store_final_state(self, t, state):
+-        """ Processor that writes the state to ``.final_state``. """
+-        self.final_state = state
+-
+-    def _pre_copy(self, state):
+-        """ Return a copy of the state. Sub-classes may override this to
+-            copy a state in different manner or to skip making a copy
+-            altogether if a copy is not necessary.
+-        """
+-        return state.copy()
+-
+-    def add(self, t, state):
+-        """
+-        Add a state to the results for the time ``t`` of the evolution.
+-
+-        Adding a state calculates the expectation value of the state for
+-        each of the supplied ``e_ops`` and stores the result in ``.expect``.
+-
+-        The state is recorded in ``.states`` and ``.final_state`` if specified
+-        by the supplied result options.
+-
+-        Parameters
+-        ----------
+-        t : float
+-            The time of the added state.
+-
+-        state : typically a :obj:`~Qobj`
+-            The state a time ``t``. Usually this is a :obj:`~Qobj` with
+-            suitable dimensions, but it sub-classes of result might support
+-            other forms of the state.
+-
+-        .. note::
+-
+-           The expectation values, i.e. ``e_ops``, and states are recorded by
+-           the state processors (see ``.add_processor``).
+-
+-           Additional processors may be added by sub-classes.
+-        """
+-        self.times.append(t)
+-
+-        if self._state_processors_require_copy:
+-            state = self._pre_copy(state)
+-
+-        for op in self._state_processors:
+-            op(t, state)
+-
+-    def __repr__(self):
+-        lines = [
+-            f"<{self.__class__.__name__}",
+-            f"  Solver: {self.solver}",
+-        ]
+-        if self.stats:
+-            lines.append("  Solver stats:")
+-            lines.extend(
+-                f"    {k}: {v!r}"
+-                for k, v in self.stats.items()
+-            )
+-        if self.times:
+-            lines.append(
+-                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
+-                f" ({len(self.times)} steps)"
+-            )
+-        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
+-        if self.states:
+-            lines.append("  States saved.")
+-        elif self.final_state is not None:
+-            lines.append("  Final state saved.")
+-        else:
+-            lines.append("  State not saved.")
+-        lines.append(">")
+-        return "\n".join(lines)
+-
+-    @property
+-    def expect(self):
+-        return [np.array(e_op) for e_op in self.e_data.values()]
+-
+-
+-class MultiTrajResult(_BaseResult):
+-    """
+-    Base class for storing results for solver using multiple trajectories.
+-
+-    Parameters
+-    ----------
+-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+-        The ``e_ops`` parameter defines the set of values to record at
+-        each time step ``t``. If an element is a :obj:`~Qobj` or
+-        :obj:`~QobjEvo` the value recorded is the expectation value of that
+-        operator given the state at ``t``. If the element is a function, ``f``,
+-        the value recorded is ``f(t, state)``.
+-
+-        The values are recorded in the ``.expect`` attribute of this result
+-        object. ``.expect`` is a list, where each item contains the values
+-        of the corresponding ``e_op``.
+-
+-        Function ``e_ops`` must return a number so the average can be computed.
+-
+-    options : dict
+-        The options for this result class.
+-
+-    solver : str or None
+-        The name of the solver generating these results.
+-
+-    stats : dict or None
+-        The stats generated by the solver while producing these results. Note
+-        that the solver may update the stats directly while producing results.
+-
+-    kw : dict
+-        Additional parameters specific to a result sub-class.
+-
+-    Properties
+-    ----------
+-    times : list
+-        A list of the times at which the expectation values and states were
+-        recorded.
+-
+-    average_states : list of :obj:`~Qobj`
+-        The state at each time ``t`` (if the recording of the state was
+-        requested) averaged over all trajectories as a density matrix.
+-
+-    runs_states : list of list of :obj:`~Qobj`
+-        The state for each trajectory and each time ``t`` (if the recording of
+-        the states and trajectories was requested)
+-
+-    final_state : :obj:`~Qobj:
+-        The final state (if the recording of the final state was requested)
+-        averaged over all trajectories as a density matrix.
+-
+-    runs_final_state : list of :obj:`~Qobj`
+-        The final state for each trajectory (if the recording of the final
+-        state and trajectories was requested).
+-
+-    average_expect : list of array of expectation values
+-        A list containing the values of each ``e_op`` averaged over each
+-        trajectories. The list is in the same order in which the ``e_ops`` were
+-        supplied and empty if no ``e_ops`` were given.
+-
+-        Each element is itself an array and contains the values of the
+-        corresponding ``e_op``, with one value for each time in ``.times``.
+-
+-    std_expect : list of array of expectation values
+-        A list containing the standard derivation of each ``e_op`` over each
+-        trajectories. The list is in the same order in which the ``e_ops`` were
+-        supplied and empty if no ``e_ops`` were given.
+-
+-        Each element is itself an array and contains the values of the
+-        corresponding ``e_op``, with one value for each time in ``.times``.
+-
+-    runs_expect : list of array of expectation values
+-        A list containing the values of each ``e_op`` for each trajectories.
+-        The list is in the same order in which the ``e_ops`` were
+-        supplied and empty if no ``e_ops`` were given. Only available if the
+-        storing of trajectories was requested.
+-
+-        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
+-
+-        Each element is itself an array and contains the values of the
+-        corresponding ``e_op``, with one value for each time in ``.times``.
+-
+-    average_e_data : dict
+-        A dictionary containing the values of each ``e_op`` averaged over each
+-        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
+-        are the same as in that dictionary. Otherwise the keys are the index of
+-        the ``e_op`` in the ``.expect`` list.
+-
+-        The lists of expectation values returned are the *same* lists as
+-        those returned by ``.expect``.
+-
+-    average_e_data : dict
+-        A dictionary containing the standard derivation of each ``e_op`` over
+-        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
+-        keys are the same as in that dictionary. Otherwise the keys are the
+-        index of the ``e_op`` in the ``.expect`` list.
+-
+-        The lists of expectation values returned are the *same* lists as
+-        those returned by ``.expect``.
+-
+-    runs_e_data : dict
+-        A dictionary containing the values of each ``e_op`` for each
+-        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
+-        are the same as in that dictionary. Otherwise the keys are the index of
+-        the ``e_op`` in the ``.expect`` list. Only available if the storing
+-        of trajectories was requested.
+-
+-        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
+-
+-        The lists of expectation values returned are the *same* lists as
+-        those returned by ``.expect``.
+-
+-    solver : str or None
+-        The name of the solver generating these results.
+-
+-    stats : dict or None
+-        The stats generated by the solver while producing these results.
+-
+-    options : :obj:`~SolverResultsOptions`
+-        The options for this result class.
+-    """
+-    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
+-        super().__init__(options, solver=solver, stats=stats)
+-        self._raw_ops = self._e_ops_to_dict(e_ops)
+-
+-        self.times = []
+-        self.trajectories = []
+-        self.num_trajectories = 0
+-        self.seeds = []
+-
+-        self._sum_states = None
+-        self._sum_final_states = None
+-        self._sum_expect = None
+-        self._sum2_expect = None
+-        self._target_tols = None
+-
+-        self.average_e_data = {}
+-        self.e_data = {}
+-        self.std_e_data = {}
+-        self.runs_e_data = {}
+-
+-        self._post_init(**kw)
+-
+-    @staticmethod
+-    def _to_dm(state):
+-        if state.type == 'ket':
+-            state = state.proj()
+-        return state
+-
+-    def _add_first_traj(self, trajectory):
+-        """
+-        Read the first trajectory, intitializing needed data.
+-        """
+-        self.times = trajectory.times
+-
+-        if trajectory.states:
+-            state = trajectory.states[0]
+-            self._sum_states = [qzero(state.dims[0])
+-                                for state in trajectory.states]
+-        if trajectory.final_state:
+-            state = trajectory.final_state
+-            self._sum_final_states = qzero(state.dims[0])
+-
+-        self._sum_expect = [
+-            np.zeros_like(expect) for expect in trajectory.expect
+-        ]
+-        self._sum2_expect = [
+-            np.zeros_like(expect) for expect in trajectory.expect
+-        ]
+-
+-        self.e_ops = trajectory.e_ops
+-
+-        self.average_e_data = {
+-            k: list(avg_expect)
+-            for k, avg_expect
+-            in zip(self._raw_ops, self._sum_expect)
+-        }
+-        self.e_data = self.average_e_data
+-        if self.options['keep_runs_results']:
+-            self.runs_e_data = {k: [] for k in self._raw_ops}
+-            self.e_data = self.runs_e_data
+-
+-    def _store_trajectory(self, trajectory):
+-        self.trajectories.append(trajectory)
+-
+-    def _reduce_states(self, trajectory):
+-        self._sum_states = [
+-            accu + self._to_dm(state)
+-            for accu, state
+-            in zip(self._sum_states, trajectory.states)
+-        ]
+-
+-    def _reduce_final_state(self, trajectory):
+-        self._sum_final_states += self._to_dm(trajectory.final_state)
+-
+-    def _reduce_expect(self, trajectory):
+-        """
+-        Compute the average of the expectation values and store it in it's
+-        multiple formats.
+-        """
+-        for i, k in enumerate(self._raw_ops):
+-            expect_traj = trajectory.expect[i]
+-
+-            self._sum_expect[i] += expect_traj
+-            self._sum2_expect[i] += expect_traj**2
+-
+-            avg = self._sum_expect[i] / self.num_trajectories
+-            avg2 = self._sum2_expect[i] / self.num_trajectories
+-
+-            self.average_e_data[k] = list(avg)
+-
+-            # mean(expect**2) - mean(expect)**2 can something be very small
+-            # negative (-1e-15) which raise an error for float sqrt.
+-            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
+-
+-            if self.runs_e_data:
+-                self.runs_e_data[k].append(trajectory.e_data[k])
+-
+-    def _increment_traj(self, trajectory):
+-        if self.num_trajectories == 0:
+-            self._add_first_traj(trajectory)
+-        self.num_trajectories += 1
+-
+-    def _no_end(self):
+-        """
+-        Remaining number of trajectories needed to finish cannot be determined
+-        by this object.
+-        """
+-        return np.inf
+-
+-    def _fixed_end(self):
+-        """
+-        Finish at a known number of trajectories.
+-        """
+-        ntraj_left = self._target_ntraj - self.num_trajectories
+-        if ntraj_left == 0:
+-            self.stats['end_condition'] = 'ntraj reached'
+-        return ntraj_left
+-
+-    def _target_tolerance_end(self):
+-        """
+-        Compute the error on the expectation values using jackknife resampling.
+-        Return the approximate number of trajectories needed to have this
+-        error within the tolerance fot all e_ops and times.
+-        """
+-        if self.num_trajectories <= 1:
+-            return np.inf
+-        avg = np.array(self._sum_expect) / self.num_trajectories
+-        avg2 = np.array(self._sum2_expect) / self.num_trajectories
+-        target = np.array([
+-            atol + rtol * mean
+-            for mean, (atol, rtol)
+-            in zip(avg, self._target_tols)
+-        ])
+-        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
+-
+-        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
+-        if (self._estimated_ntraj - self.num_trajectories) <= 0:
+-            self.stats['end_condition'] = 'target tolerance reached'
+-        return self._estimated_ntraj - self.num_trajectories
+-
+-    def _post_init(self):
+-        self.num_trajectories = 0
+-        self._target_ntraj = None
+-
+-        store_states = self.options['store_states']
+-        store_final_state = self.options['store_final_state']
+-        store_traj = self.options['keep_runs_results']
+-
+-        self.add_processor(self._increment_traj)
+-        if store_traj:
+-            self.add_processor(self._store_trajectory)
+-        if store_states is None:
+-            store_states = len(self._raw_ops) == 0
+-        if store_states:
+-            self.add_processor(self._reduce_states)
+-        if store_states or store_final_state:
+-            self.add_processor(self._reduce_final_state)
+-        if self._raw_ops:
+-            self.add_processor(self._reduce_expect)
+-
+-        self._early_finish_check = self._no_end
+-        self.stats['end_condition'] = 'unknown'
+-
+-    def add(self, trajectory_info):
+-        """
+-        Add a trajectory to the evolution.
+-
+-        Trajectories can be saved or average canbe extracted depending on the
+-        options ``keep_runs_results``.
+-
+-        Parameters
+-        ----------
+-        trajectory_info : tuple of seed and trajectory
+-            - seed: int, SeedSequence
+-              Seed used to generate the trajectory.
+-            - trajectory : :class:`Result`
+-              Run result for one evolution over the times.
+-
+-        Return
+-        ------
+-        remaing_traj : number
+-            Return the number of trajectories still needed to reach the target
+-            tolerance. If no tolerance is provided, return infinity.
+-        """
+-        seed, trajectory = trajectory_info
+-        self.seeds.append(seed)
+-
+-        for op in self._state_processors:
+-            op(trajectory)
+-
+-        return self._early_finish_check()
+-
+-    def add_end_condition(self, ntraj, target_tol=None):
+-        """
+-        Set the condition to stop the computing trajectories when the certain
+-        condition are fullfilled.
+-        Supported end condition for multi trajectories computation are:
+-        - Reaching a number of trajectories.
+-        - Error bar on the expectation values reach smaller than a given
+-          tolerance.
+-
+-        Parameters
+-        ----------
+-        ntraj : int
+-            Number of trajectories expected.
+-
+-        target_tol : float, array_like, [optional]
+-            Target tolerance of the evolution. The evolution will compute
+-            trajectories until the error on the expectation values is lower
+-            than this tolerance. The error is computed using jackknife
+-            resampling. ``target_tol`` can be an absolute tolerance, a pair of
+-            absolute and relative tolerance, in that order. Lastly, it can be a
+-            list of pairs of (atol, rtol) for each e_ops.
+-
+-            Error estimation is done with jackknife resampling.
+-        """
+-        self._target_ntraj = ntraj
+-        self.stats['end_condition'] = 'timeout'
+-
+-        if target_tol is None:
+-            self._early_finish_check = self._fixed_end
+-            return
+-
+-        num_e_ops = len(self._raw_ops)
+-
+-        if not num_e_ops:
+-            raise ValueError("Cannot target a tolerance without e_ops")
+-
+-        self._estimated_ntraj = ntraj
+-
+-        targets = np.array(target_tol)
+-        if targets.ndim == 0:
+-            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
+-        elif targets.shape == (2,):
+-            self._target_tols = np.ones((num_e_ops, 2)) * targets
+-        elif targets.shape == (num_e_ops, 2):
+-            self._target_tols = targets
+-        else:
+-            raise ValueError("target_tol must be a number, a pair of (atol, "
+-                             "rtol) or a list of (atol, rtol) for each e_ops")
+-
+-        self._early_finish_check = self._target_tolerance_end
+-
+-    @property
+-    def runs_states(self):
+-        """
+-        States of every runs as ``states[run][t]``.
+-        """
+-        if self.trajectories and self.trajectories[0].states:
+-            return [traj.states for traj in self.trajectories]
+-        else:
+-            return None
+-
+-    @property
+-    def average_states(self):
+-        """
+-        States averages as density matrices.
+-        """
+-        if self._sum_states is None:
+-            return None
+-        return [final / self.num_trajectories for final in self._sum_states]
+-
+-    @property
+-    def states(self):
+-        """
+-        Runs final states if available, average otherwise.
+-        """
+-        return self.runs_states or self.average_states
+-
+-    @property
+-    def runs_final_states(self):
+-        """
+-        Last states of each trajectories.
+-        """
+-        if self.trajectories and self.trajectories[0].final_state:
+-            return [traj.final_state for traj in self.trajectories]
+-        else:
+-            return None
+-
+-    @property
+-    def average_final_state(self):
+-        """
+-        Last states of each trajectories averaged into a density matrix.
+-        """
+-        if self._sum_final_states is None:
+-            return None
+-        return self._sum_final_states / self.num_trajectories
+-
+-    @property
+-    def final_state(self):
+-        """
+-        Runs final states if available, average otherwise.
+-        """
+-        return self.runs_final_states or self.average_final_state
+-
+-    @property
+-    def average_expect(self):
+-        return [np.array(val) for val in self.average_e_data.values()]
+-
+-    @property
+-    def std_expect(self):
+-        return [np.array(val) for val in self.std_e_data.values()]
+-
+-    @property
+-    def runs_expect(self):
+-        return [np.array(val) for val in self.runs_e_data.values()]
+-
+-    @property
+-    def expect(self):
+-        return [np.array(val) for val in self.e_data.values()]
+-
+-    def steady_state(self, N=0):
+-        """
+-        Average the states of the last ``N`` times of every runs as a density
+-        matrix. Should converge to the steady state in the right circumstances.
+-
+-        Parameters
+-        ----------
+-        N : int [optional]
+-            Number of states from the end of ``tlist`` to average. Per default
+-            all states will be averaged.
+-        """
+-        N = int(N) or len(self.times)
+-        N = len(self.times) if N > len(self.times) else N
+-        states = self.average_states
+-        if states is not None:
+-            return sum(states[-N:]) / N
+-        else:
+-            return None
+-
+-    def __repr__(self):
+-        lines = [
+-            f"<{self.__class__.__name__}",
+-            f"  Solver: {self.solver}",
+-        ]
+-        if self.stats:
+-            lines.append("  Solver stats:")
+-            lines.extend(
+-                f"    {k}: {v!r}"
+-                for k, v in self.stats.items()
+-            )
+-        if self.times:
+-            lines.append(
+-                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
+-                f" ({len(self.times)} steps)"
+-            )
+-        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
+-        if self.states:
+-            lines.append("  States saved.")
+-        elif self.final_state is not None:
+-            lines.append("  Final state saved.")
+-        else:
+-            lines.append("  State not saved.")
+-        lines.append(f"  Number of trajectories: {self.num_trajectories}")
+-        if self.trajectories:
+-            lines.append("  Trajectories saved.")
+-        else:
+-            lines.append("  Trajectories not saved.")
+-        lines.append(">")
+-        return "\n".join(lines)
+-
+-    def __add__(self, other):
+-        if not isinstance(other, MultiTrajResult):
+-            return NotImplemented
+-        if self._raw_ops != other._raw_ops:
+-            raise ValueError("Shared `e_ops` is required to merge results")
+-        if self.times != other.times:
+-            raise ValueError("Shared `times` are is required to merge results")
+-        new = self.__class__(self._raw_ops, self.options,
+-                             solver=self.solver, stats=self.stats)
+-        if self.trajectories and other.trajectories:
+-            new.trajectories = self.trajectories + other.trajectories
+-        new.num_trajectories = self.num_trajectories + other.num_trajectories
+-        new.times = self.times
+-        new.seeds = self.seeds + other.seeds
+-
+-        if self._sum_states is not None and other._sum_states is not None:
+-            new._sum_states = self._sum_states + other._sum_states
+-
+-        if (
+-            self._sum_final_states is not None
+-            and other._sum_final_states is not None
+-        ):
+-            new._sum_final_states = (
+-                self._sum_final_states + other._sum_final_states
+-            )
+-        new._target_tols = None
+-
+-        new._sum_expect = []
+-        new._sum2_expect = []
+-        new.average_e_data = {}
+-        new.std_e_data = {}
+-
+-        for i, k in enumerate(self._raw_ops):
+-            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
+-            new._sum2_expect.append(self._sum2_expect[i]
+-                                    + other._sum2_expect[i])
+-
+-            avg = new._sum_expect[i] / new.num_trajectories
+-            avg2 = new._sum2_expect[i] / new.num_trajectories
+-
+-            new.average_e_data[k] = list(avg)
+-            new.e_data = new.average_e_data
+-
+-            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
+-
+-            if new.trajectories:
+-                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
+-                new.e_data = new.runs_e_data
+-
+-        new.stats["run time"] += other.stats["run time"]
+-        new.stats['end_condition'] = "Merged results"
+-
+-        return new
+-
+-
+-class McResult(MultiTrajResult):
+-    """
+-    Base class for storing solver results.
+-
+-    Parameters
+-    ----------
+-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+-        The ``e_ops`` parameter defines the set of values to record at
+-        each time step ``t``. If an element is a :obj:`~Qobj` or
+-        :obj:`~QobjEvo` the value recorded is the expectation value of that
+-        operator given the state at ``t``. If the element is a function, ``f``,
+-        the value recorded is ``f(t, state)``.
+-
+-        The values are recorded in the ``.expect`` attribute of this result
+-        object. ``.expect`` is a list, where each item contains the values
+-        of the corresponding ``e_op``.
+-
+-    options : :obj:`~SolverResultsOptions`
+-        The options for this result class.
+-
+-    solver : str or None
+-        The name of the solver generating these results.
+-
+-    stats : dict
+-        The stats generated by the solver while producing these results. Note
+-        that the solver may update the stats directly while producing results.
+-        Must include a value for "num_collapse".
+-
+-    kw : dict
+-        Additional parameters specific to a result sub-class.
+-
+-    Properties
+-    ----------
+-    collapse : list
+-        For each runs, a list of every collapse as a tuple of the time it
+-        happened and the corresponding ``c_ops`` index.
+-    """
+-    # Collapse are only produced by mcsolve.
+-
+-    def _add_collapse(self, trajectory):
+-        self.collapse.append(trajectory.collapse)
+-
+-    def _post_init(self):
+-        super()._post_init()
+-        self.num_c_ops = self.stats["num_collapse"]
+-        self.collapse = []
+-        self.add_processor(self._add_collapse)
+-
+-    @property
+-    def col_times(self):
+-        """
+-        List of the times of the collapses for each runs.
+-        """
+-        out = []
+-        for col_ in self.collapse:
+-            col = list(zip(*col_))
+-            col = ([] if len(col) == 0 else col[0])
+-            out.append(col)
+-        return out
+-
+-    @property
+-    def col_which(self):
+-        """
+-        List of the indexes of the collapses for each runs.
+-        """
+-        out = []
+-        for col_ in self.collapse:
+-            col = list(zip(*col_))
+-            col = ([] if len(col) == 0 else col[1])
+-            out.append(col)
+-        return out
+-
+-    @property
+-    def photocurrent(self):
+-        """
+-        Average photocurrent or measurement of the evolution.
+-        """
+-        cols = [[] for _ in range(self.num_c_ops)]
+-        tlist = self.times
+-        for collapses in self.collapse:
+-            for t, which in collapses:
+-                cols[which].append(t)
+-        mesurement = [
+-            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
+-            for i in range(self.num_c_ops)
+-        ]
+-        return mesurement
+-
+-    @property
+-    def runs_photocurrent(self):
+-        """
+-        Photocurrent or measurement of each runs.
+-        """
+-        tlist = self.times
+-        measurements = []
+-        for collapses in self.collapse:
+-            cols = [[] for _ in range(self.num_c_ops)]
+-            for t, which in collapses:
+-                cols[which].append(t)
+-            measurements.append([
+-                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
+-                for i in range(self.num_c_ops)
+-            ])
+-        return measurements
++""" Class for solve function results"""
++import numpy as np
++from ..core import Qobj, QobjEvo, expect, qzero
++
++__all__ = ["Result", "MultiTrajResult", "McResult"]
++
++
++class _QobjExpectEop:
++    """
++    Pickable e_ops callable that calculates the expectation value for a given
++    operator.
++
++    Parameters
++    ----------
++    op : :obj:`~Qobj`
++        The expectation value operator.
++    """
++    def __init__(self, op):
++        self.op = op
++
++    def __call__(self, t, state):
++        return expect(self.op, state)
++
++
++class ExpectOp:
++    """
++    A result e_op (expectation operation).
++
++    Parameters
++    ----------
++    op : object
++        The original object used to define the e_op operation, e.g. a
++        :~obj:`Qobj` or a function ``f(t, state)``.
++
++    f : function
++        A callable ``f(t, state)`` that will return the value of the e_op
++        for the specified state and time.
++
++    append : function
++        A callable ``append(value)``, e.g. ``expect[k].append``, that will
++        store the result of the e_ops function ``f(t, state)``.
++
++    Attributes
++    ----------
++    op : object
++        The original object used to define the e_op operation.
++    """
++    def __init__(self, op, f, append):
++        self.op = op
++        self._f = f
++        self._append = append
++
++    def __call__(self, t, state):
++        """
++        Return the expectation value for the given time, ``t`` and
++        state, ``state``.
++        """
++        return self._f(t, state)
++
++    def _store(self, t, state):
++        """
++        Store the result of the e_op function. Should only be called by
++        :class:`~Result`.
++        """
++        self._append(self._f(t, state))
++
++
++class _BaseResult:
++    """
++    Common method for all ``Result``.
++    """
++    def __init__(self, options, *, solver=None, stats=None):
++        self.solver = solver
++        if stats is None:
++            stats = {}
++        self.stats = stats
++
++        self._state_processors = []
++        self._state_processors_require_copy = False
++
++        self.options = options
++
++    def _e_ops_to_dict(self, e_ops):
++        """ Convert the supplied e_ops to a dictionary of Eop instances. """
++        if e_ops is None:
++            e_ops = {}
++        elif isinstance(e_ops, (list, tuple)):
++            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
++        elif isinstance(e_ops, dict):
++            pass
++        else:
++            e_ops = {0: e_ops}
++        return e_ops
++
++    def add_processor(self, f, requires_copy=False):
++        """
++        Append a processor ``f`` to the list of state processors.
++
++        Parameters
++        ----------
++        f : function, ``f(t, state)``
++            A function to be called each time a state is added to this
++            result object. The state is the state passed to ``.add``, after
++            applying the pre-processors, if any.
++
++        requires_copy : bool, default False
++            Whether this processor requires a copy of the state rather than
++            a reference. A processor must never modify the supplied state, but
++            if a processor stores the state it should set ``require_copy`` to
++            true.
++        """
++        self._state_processors.append(f)
++        self._state_processors_require_copy |= requires_copy
++
++
++class Result(_BaseResult):
++    """
++    Base class for storing solver results.
++
++    Parameters
++    ----------
++    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
++        The ``e_ops`` parameter defines the set of values to record at
++        each time step ``t``. If an element is a :obj:`~Qobj` or
++        :obj:`~QobjEvo` the value recorded is the expectation value of that
++        operator given the state at ``t``. If the element is a function, ``f``,
++        the value recorded is ``f(t, state)``.
++
++        The values are recorded in the ``e_data`` and ``expect`` attributes of
++        this result object. ``e_data`` is a dictionary and ``expect`` is a
++        list, where each item contains the values of the corresponding
++        ``e_op``.
++
++    options : dict
++        The options for this result class.
++
++    solver : str or None
++        The name of the solver generating these results.
++
++    stats : dict or None
++        The stats generated by the solver while producing these results. Note
++        that the solver may update the stats directly while producing results.
++
++    kw : dict
++        Additional parameters specific to a result sub-class.
++
++    Attributes
++    ----------
++    times : list
++        A list of the times at which the expectation values and states were
++        recorded.
++
++    states : list of :obj:`~Qobj`
++        The state at each time ``t`` (if the recording of the state was
++        requested).
++
++    final_state : :obj:`~Qobj`:
++        The final state (if the recording of the final state was requested).
++
++    expect : list of arrays of expectation values
++        A list containing the values of each ``e_op``. The list is in
++        the same order in which the ``e_ops`` were supplied and empty if
++        no ``e_ops`` were given.
++
++        Each element is itself a list and contains the values of the
++        corresponding ``e_op``, with one value for each time in ``.times``.
++
++        The same lists of values may be accessed via the ``.e_data`` dictionary
++        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
++
++    e_data : dict
++        A dictionary containing the values of each ``e_op``. If the ``e_ops``
++        were supplied as a dictionary, the keys are the same as in
++        that dictionary. Otherwise the keys are the index of the ``e_op``
++        in the ``.expect`` list.
++
++        The lists of expectation values returned are the *same* lists as
++        those returned by ``.expect``.
++
++    e_ops : dict
++        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
++        The keys of the dictionary are the same as for ``.e_data``.
++        Each value is object where ``.e_ops[k](t, state)`` calculates the
++        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
++        ``.e_ops[k].op`` is the original object supplied to create the
++        ``e_op``.
++
++    solver : str or None
++        The name of the solver generating these results.
++
++    stats : dict or None
++        The stats generated by the solver while producing these results.
++
++    options : dict
++        The options for this result class.
++    """
++    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
++        super().__init__(options, solver=solver, stats=stats)
++        raw_ops = self._e_ops_to_dict(e_ops)
++        self.e_data = {k: [] for k in raw_ops}
++        self.e_ops = {}
++        for k, op in raw_ops.items():
++            f = self._e_op_func(op)
++            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
++            self.add_processor(self.e_ops[k]._store)
++
++        self.times = []
++        self.states = []
++        self.final_state = None
++
++        self._post_init(**kw)
++
++    def _e_op_func(self, e_op):
++        """
++        Convert an e_op entry into a function, ``f(t, state)`` that returns
++        the appropriate value (usually an expectation value).
++
++        Sub-classes may override this function to calculate expectation values
++        in different ways.
++        """
++        if isinstance(e_op, Qobj):
++            return _QobjExpectEop(e_op)
++        elif isinstance(e_op, QobjEvo):
++            return e_op.expect
++        elif callable(e_op):
++            return e_op
++        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
++
++    def _post_init(self):
++        """
++        Perform post __init__ initialisation. In particular, add state
++        processors or pre-processors.
++
++        Sub-class may override this. If the sub-class wishes to register the
++        default processors for storing states, it should call this parent
++        ``.post_init()`` method.
++
++        Sub-class ``.post_init()`` implementation may take additional keyword
++        arguments if required.
++        """
++        store_states = self.options['store_states']
++        store_final_state = self.options['store_final_state']
++
++        if store_states is None:
++            store_states = len(self.e_ops) == 0
++        if store_states:
++            self.add_processor(self._store_state, requires_copy=True)
++
++        if store_states or store_final_state:
++            self.add_processor(self._store_final_state, requires_copy=True)
++
++    def _store_state(self, t, state):
++        """ Processor that stores a state in ``.states``. """
++        self.states.append(state)
++
++    def _store_final_state(self, t, state):
++        """ Processor that writes the state to ``.final_state``. """
++        self.final_state = state
++
++    def _pre_copy(self, state):
++        """ Return a copy of the state. Sub-classes may override this to
++            copy a state in different manner or to skip making a copy
++            altogether if a copy is not necessary.
++        """
++        return state.copy()
++
++    def add(self, t, state):
++        """
++        Add a state to the results for the time ``t`` of the evolution.
++
++        Adding a state calculates the expectation value of the state for
++        each of the supplied ``e_ops`` and stores the result in ``.expect``.
++
++        The state is recorded in ``.states`` and ``.final_state`` if specified
++        by the supplied result options.
++
++        Parameters
++        ----------
++        t : float
++            The time of the added state.
++
++        state : typically a :obj:`~Qobj`
++            The state a time ``t``. Usually this is a :obj:`~Qobj` with
++            suitable dimensions, but it sub-classes of result might support
++            other forms of the state.
++
++        .. note::
++
++           The expectation values, i.e. ``e_ops``, and states are recorded by
++           the state processors (see ``.add_processor``).
++
++           Additional processors may be added by sub-classes.
++        """
++        self.times.append(t)
++
++        if self._state_processors_require_copy:
++            state = self._pre_copy(state)
++
++        for op in self._state_processors:
++            op(t, state)
++
++    def __repr__(self):
++        lines = [
++            f"<{self.__class__.__name__}",
++            f"  Solver: {self.solver}",
++        ]
++        if self.stats:
++            lines.append("  Solver stats:")
++            lines.extend(
++                f"    {k}: {v!r}"
++                for k, v in self.stats.items()
++            )
++        if self.times:
++            lines.append(
++                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
++                f" ({len(self.times)} steps)"
++            )
++        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
++        if self.states:
++            lines.append("  States saved.")
++        elif self.final_state is not None:
++            lines.append("  Final state saved.")
++        else:
++            lines.append("  State not saved.")
++        lines.append(">")
++        return "\n".join(lines)
++
++    @property
++    def expect(self):
++        return [np.array(e_op) for e_op in self.e_data.values()]
++
++
++class MultiTrajResult(_BaseResult):
++    """
++    Base class for storing results for solver using multiple trajectories.
++
++    Parameters
++    ----------
++    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
++        The ``e_ops`` parameter defines the set of values to record at
++        each time step ``t``. If an element is a :obj:`~Qobj` or
++        :obj:`~QobjEvo` the value recorded is the expectation value of that
++        operator given the state at ``t``. If the element is a function, ``f``,
++        the value recorded is ``f(t, state)``.
++
++        The values are recorded in the ``.expect`` attribute of this result
++        object. ``.expect`` is a list, where each item contains the values
++        of the corresponding ``e_op``.
++
++        Function ``e_ops`` must return a number so the average can be computed.
++
++    options : dict
++        The options for this result class.
++
++    solver : str or None
++        The name of the solver generating these results.
++
++    stats : dict or None
++        The stats generated by the solver while producing these results. Note
++        that the solver may update the stats directly while producing results.
++
++    kw : dict
++        Additional parameters specific to a result sub-class.
++
++    Properties
++    ----------
++    times : list
++        A list of the times at which the expectation values and states were
++        recorded.
++
++    average_states : list of :obj:`~Qobj`
++        The state at each time ``t`` (if the recording of the state was
++        requested) averaged over all trajectories as a density matrix.
++
++    runs_states : list of list of :obj:`~Qobj`
++        The state for each trajectory and each time ``t`` (if the recording of
++        the states and trajectories was requested)
++
++    final_state : :obj:`~Qobj:
++        The final state (if the recording of the final state was requested)
++        averaged over all trajectories as a density matrix.
++
++    runs_final_state : list of :obj:`~Qobj`
++        The final state for each trajectory (if the recording of the final
++        state and trajectories was requested).
++
++    average_expect : list of array of expectation values
++        A list containing the values of each ``e_op`` averaged over each
++        trajectories. The list is in the same order in which the ``e_ops`` were
++        supplied and empty if no ``e_ops`` were given.
++
++        Each element is itself an array and contains the values of the
++        corresponding ``e_op``, with one value for each time in ``.times``.
++
++    std_expect : list of array of expectation values
++        A list containing the standard derivation of each ``e_op`` over each
++        trajectories. The list is in the same order in which the ``e_ops`` were
++        supplied and empty if no ``e_ops`` were given.
++
++        Each element is itself an array and contains the values of the
++        corresponding ``e_op``, with one value for each time in ``.times``.
++
++    runs_expect : list of array of expectation values
++        A list containing the values of each ``e_op`` for each trajectories.
++        The list is in the same order in which the ``e_ops`` were
++        supplied and empty if no ``e_ops`` were given. Only available if the
++        storing of trajectories was requested.
++
++        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
++
++        Each element is itself an array and contains the values of the
++        corresponding ``e_op``, with one value for each time in ``.times``.
++
++    average_e_data : dict
++        A dictionary containing the values of each ``e_op`` averaged over each
++        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
++        are the same as in that dictionary. Otherwise the keys are the index of
++        the ``e_op`` in the ``.expect`` list.
++
++        The lists of expectation values returned are the *same* lists as
++        those returned by ``.expect``.
++
++    average_e_data : dict
++        A dictionary containing the standard derivation of each ``e_op`` over
++        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
++        keys are the same as in that dictionary. Otherwise the keys are the
++        index of the ``e_op`` in the ``.expect`` list.
++
++        The lists of expectation values returned are the *same* lists as
++        those returned by ``.expect``.
++
++    runs_e_data : dict
++        A dictionary containing the values of each ``e_op`` for each
++        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
++        are the same as in that dictionary. Otherwise the keys are the index of
++        the ``e_op`` in the ``.expect`` list. Only available if the storing
++        of trajectories was requested.
++
++        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
++
++        The lists of expectation values returned are the *same* lists as
++        those returned by ``.expect``.
++
++    solver : str or None
++        The name of the solver generating these results.
++
++    stats : dict or None
++        The stats generated by the solver while producing these results.
++
++    options : :obj:`~SolverResultsOptions`
++        The options for this result class.
++    """
++    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
++        super().__init__(options, solver=solver, stats=stats)
++        self._raw_ops = self._e_ops_to_dict(e_ops)
++
++        self.times = []
++        self.trajectories = []
++        self.num_trajectories = 0
++        self.seeds = []
++
++        self._sum_states = None
++        self._sum_final_states = None
++        self._sum_expect = None
++        self._sum2_expect = None
++        self._target_tols = None
++
++        self.average_e_data = {}
++        self.e_data = {}
++        self.std_e_data = {}
++        self.runs_e_data = {}
++
++        self._post_init(**kw)
++
++    @staticmethod
++    def _to_dm(state):
++        if state.type == 'ket':
++            state = state.proj()
++        return state
++
++    def _add_first_traj(self, trajectory):
++        """
++        Read the first trajectory, intitializing needed data.
++        """
++        self.times = trajectory.times
++
++        if trajectory.states:
++            state = trajectory.states[0]
++            self._sum_states = [qzero(state.dims[0])
++                                for state in trajectory.states]
++        if trajectory.final_state:
++            state = trajectory.final_state
++            self._sum_final_states = qzero(state.dims[0])
++
++        self._sum_expect = [
++            np.zeros_like(expect) for expect in trajectory.expect
++        ]
++        self._sum2_expect = [
++            np.zeros_like(expect) for expect in trajectory.expect
++        ]
++
++        self.e_ops = trajectory.e_ops
++
++        self.average_e_data = {
++            k: list(avg_expect)
++            for k, avg_expect
++            in zip(self._raw_ops, self._sum_expect)
++        }
++        self.e_data = self.average_e_data
++        if self.options['keep_runs_results']:
++            self.runs_e_data = {k: [] for k in self._raw_ops}
++            self.e_data = self.runs_e_data
++
++    def _store_trajectory(self, trajectory):
++        self.trajectories.append(trajectory)
++
++    def _reduce_states(self, trajectory):
++        self._sum_states = [
++            accu + self._to_dm(state)
++            for accu, state
++            in zip(self._sum_states, trajectory.states)
++        ]
++
++    def _reduce_final_state(self, trajectory):
++        self._sum_final_states += self._to_dm(trajectory.final_state)
++
++    def _reduce_expect(self, trajectory):
++        """
++        Compute the average of the expectation values and store it in it's
++        multiple formats.
++        """
++        for i, k in enumerate(self._raw_ops):
++            expect_traj = trajectory.expect[i]
++
++            self._sum_expect[i] += expect_traj
++            self._sum2_expect[i] += expect_traj**2
++
++            avg = self._sum_expect[i] / self.num_trajectories
++            avg2 = self._sum2_expect[i] / self.num_trajectories
++
++            self.average_e_data[k] = list(avg)
++
++            # mean(expect**2) - mean(expect)**2 can something be very small
++            # negative (-1e-15) which raise an error for float sqrt.
++            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
++
++            if self.runs_e_data:
++                self.runs_e_data[k].append(trajectory.e_data[k])
++
++    def _increment_traj(self, trajectory):
++        if self.num_trajectories == 0:
++            self._add_first_traj(trajectory)
++        self.num_trajectories += 1
++
++    def _no_end(self):
++        """
++        Remaining number of trajectories needed to finish cannot be determined
++        by this object.
++        """
++        return np.inf
++
++    def _fixed_end(self):
++        """
++        Finish at a known number of trajectories.
++        """
++        ntraj_left = self._target_ntraj - self.num_trajectories
++        if ntraj_left == 0:
++            self.stats['end_condition'] = 'ntraj reached'
++        return ntraj_left
++
++    def _target_tolerance_end(self):
++        """
++        Compute the error on the expectation values using jackknife resampling.
++        Return the approximate number of trajectories needed to have this
++        error within the tolerance fot all e_ops and times.
++        """
++        if self.num_trajectories <= 1:
++            return np.inf
++        avg = np.array(self._sum_expect) / self.num_trajectories
++        avg2 = np.array(self._sum2_expect) / self.num_trajectories
++        target = np.array([
++            atol + rtol * mean
++            for mean, (atol, rtol)
++            in zip(avg, self._target_tols)
++        ])
++        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
++
++        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
++        if (self._estimated_ntraj - self.num_trajectories) <= 0:
++            self.stats['end_condition'] = 'target tolerance reached'
++        return self._estimated_ntraj - self.num_trajectories
++
++    def _post_init(self):
++        self.num_trajectories = 0
++        self._target_ntraj = None
++
++        store_states = self.options['store_states']
++        store_final_state = self.options['store_final_state']
++        store_traj = self.options['keep_runs_results']
++
++        self.add_processor(self._increment_traj)
++        if store_traj:
++            self.add_processor(self._store_trajectory)
++        if store_states is None:
++            store_states = len(self._raw_ops) == 0
++        if store_states:
++            self.add_processor(self._reduce_states)
++        if store_states or store_final_state:
++            self.add_processor(self._reduce_final_state)
++        if self._raw_ops:
++            self.add_processor(self._reduce_expect)
++
++        self._early_finish_check = self._no_end
++        self.stats['end_condition'] = 'unknown'
++
++    def add(self, trajectory_info):
++        """
++        Add a trajectory to the evolution.
++
++        Trajectories can be saved or average canbe extracted depending on the
++        options ``keep_runs_results``.
++
++        Parameters
++        ----------
++        trajectory_info : tuple of seed and trajectory
++            - seed: int, SeedSequence
++              Seed used to generate the trajectory.
++            - trajectory : :class:`Result`
++              Run result for one evolution over the times.
++
++        Return
++        ------
++        remaing_traj : number
++            Return the number of trajectories still needed to reach the target
++            tolerance. If no tolerance is provided, return infinity.
++        """
++        seed, trajectory = trajectory_info
++        self.seeds.append(seed)
++
++        for op in self._state_processors:
++            op(trajectory)
++
++        return self._early_finish_check()
++
++    def add_end_condition(self, ntraj, target_tol=None):
++        """
++        Set the condition to stop the computing trajectories when the certain
++        condition are fullfilled.
++        Supported end condition for multi trajectories computation are:
++        - Reaching a number of trajectories.
++        - Error bar on the expectation values reach smaller than a given
++          tolerance.
++
++        Parameters
++        ----------
++        ntraj : int
++            Number of trajectories expected.
++
++        target_tol : float, array_like, [optional]
++            Target tolerance of the evolution. The evolution will compute
++            trajectories until the error on the expectation values is lower
++            than this tolerance. The error is computed using jackknife
++            resampling. ``target_tol`` can be an absolute tolerance, a pair of
++            absolute and relative tolerance, in that order. Lastly, it can be a
++            list of pairs of (atol, rtol) for each e_ops.
++
++            Error estimation is done with jackknife resampling.
++        """
++        self._target_ntraj = ntraj
++        self.stats['end_condition'] = 'timeout'
++
++        if target_tol is None:
++            self._early_finish_check = self._fixed_end
++            return
++
++        num_e_ops = len(self._raw_ops)
++
++        if not num_e_ops:
++            raise ValueError("Cannot target a tolerance without e_ops")
++
++        self._estimated_ntraj = ntraj
++
++        targets = np.array(target_tol)
++        if targets.ndim == 0:
++            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
++        elif targets.shape == (2,):
++            self._target_tols = np.ones((num_e_ops, 2)) * targets
++        elif targets.shape == (num_e_ops, 2):
++            self._target_tols = targets
++        else:
++            raise ValueError("target_tol must be a number, a pair of (atol, "
++                             "rtol) or a list of (atol, rtol) for each e_ops")
++
++        self._early_finish_check = self._target_tolerance_end
++
++    @property
++    def runs_states(self):
++        """
++        States of every runs as ``states[run][t]``.
++        """
++        if self.trajectories and self.trajectories[0].states:
++            return [traj.states for traj in self.trajectories]
++        else:
++            return None
++
++    @property
++    def average_states(self):
++        """
++        States averages as density matrices.
++        """
++        if self._sum_states is None:
++            return None
++        return [final / self.num_trajectories for final in self._sum_states]
++
++    @property
++    def states(self):
++        """
++        Runs final states if available, average otherwise.
++        """
++        return self.runs_states or self.average_states
++
++    @property
++    def runs_final_states(self):
++        """
++        Last states of each trajectories.
++        """
++        if self.trajectories and self.trajectories[0].final_state:
++            return [traj.final_state for traj in self.trajectories]
++        else:
++            return None
++
++    @property
++    def average_final_state(self):
++        """
++        Last states of each trajectories averaged into a density matrix.
++        """
++        if self._sum_final_states is None:
++            return None
++        return self._sum_final_states / self.num_trajectories
++
++    @property
++    def final_state(self):
++        """
++        Runs final states if available, average otherwise.
++        """
++        return self.runs_final_states or self.average_final_state
++
++    @property
++    def average_expect(self):
++        return [np.array(val) for val in self.average_e_data.values()]
++
++    @property
++    def std_expect(self):
++        return [np.array(val) for val in self.std_e_data.values()]
++
++    @property
++    def runs_expect(self):
++        return [np.array(val) for val in self.runs_e_data.values()]
++
++    @property
++    def expect(self):
++        return [np.array(val) for val in self.e_data.values()]
++
++    def steady_state(self, N=0):
++        """
++        Average the states of the last ``N`` times of every runs as a density
++        matrix. Should converge to the steady state in the right circumstances.
++
++        Parameters
++        ----------
++        N : int [optional]
++            Number of states from the end of ``tlist`` to average. Per default
++            all states will be averaged.
++        """
++        N = int(N) or len(self.times)
++        N = len(self.times) if N > len(self.times) else N
++        states = self.average_states
++        if states is not None:
++            return sum(states[-N:]) / N
++        else:
++            return None
++
++    def __repr__(self):
++        lines = [
++            f"<{self.__class__.__name__}",
++            f"  Solver: {self.solver}",
++        ]
++        if self.stats:
++            lines.append("  Solver stats:")
++            lines.extend(
++                f"    {k}: {v!r}"
++                for k, v in self.stats.items()
++            )
++        if self.times:
++            lines.append(
++                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
++                f" ({len(self.times)} steps)"
++            )
++        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
++        if self.states:
++            lines.append("  States saved.")
++        elif self.final_state is not None:
++            lines.append("  Final state saved.")
++        else:
++            lines.append("  State not saved.")
++        lines.append(f"  Number of trajectories: {self.num_trajectories}")
++        if self.trajectories:
++            lines.append("  Trajectories saved.")
++        else:
++            lines.append("  Trajectories not saved.")
++        lines.append(">")
++        return "\n".join(lines)
++
++    def __add__(self, other):
++        if not isinstance(other, MultiTrajResult):
++            return NotImplemented
++        if self._raw_ops != other._raw_ops:
++            raise ValueError("Shared `e_ops` is required to merge results")
++        if self.times != other.times:
++            raise ValueError("Shared `times` are is required to merge results")
++        new = self.__class__(self._raw_ops, self.options,
++                             solver=self.solver, stats=self.stats)
++        if self.trajectories and other.trajectories:
++            new.trajectories = self.trajectories + other.trajectories
++        new.num_trajectories = self.num_trajectories + other.num_trajectories
++        new.times = self.times
++        new.seeds = self.seeds + other.seeds
++
++        if self._sum_states is not None and other._sum_states is not None:
++            new._sum_states = self._sum_states + other._sum_states
++
++        if (
++            self._sum_final_states is not None
++            and other._sum_final_states is not None
++        ):
++            new._sum_final_states = (
++                self._sum_final_states + other._sum_final_states
++            )
++        new._target_tols = None
++
++        new._sum_expect = []
++        new._sum2_expect = []
++        new.average_e_data = {}
++        new.std_e_data = {}
++
++        for i, k in enumerate(self._raw_ops):
++            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
++            new._sum2_expect.append(self._sum2_expect[i]
++                                    + other._sum2_expect[i])
++
++            avg = new._sum_expect[i] / new.num_trajectories
++            avg2 = new._sum2_expect[i] / new.num_trajectories
++
++            new.average_e_data[k] = list(avg)
++            new.e_data = new.average_e_data
++
++            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
++
++            if new.trajectories:
++                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
++                new.e_data = new.runs_e_data
++
++        new.stats["run time"] += other.stats["run time"]
++        new.stats['end_condition'] = "Merged results"
++
++        return new
++
++
++class McResult(MultiTrajResult):
++    """
++    Base class for storing solver results.
++
++    Parameters
++    ----------
++    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
++        The ``e_ops`` parameter defines the set of values to record at
++        each time step ``t``. If an element is a :obj:`~Qobj` or
++        :obj:`~QobjEvo` the value recorded is the expectation value of that
++        operator given the state at ``t``. If the element is a function, ``f``,
++        the value recorded is ``f(t, state)``.
++
++        The values are recorded in the ``.expect`` attribute of this result
++        object. ``.expect`` is a list, where each item contains the values
++        of the corresponding ``e_op``.
++
++    options : :obj:`~SolverResultsOptions`
++        The options for this result class.
++
++    solver : str or None
++        The name of the solver generating these results.
++
++    stats : dict
++        The stats generated by the solver while producing these results. Note
++        that the solver may update the stats directly while producing results.
++        Must include a value for "num_collapse".
++
++    kw : dict
++        Additional parameters specific to a result sub-class.
++
++    Properties
++    ----------
++    collapse : list
++        For each runs, a list of every collapse as a tuple of the time it
++        happened and the corresponding ``c_ops`` index.
++    """
++    # Collapse are only produced by mcsolve.
++
++    def _add_collapse(self, trajectory):
++        self.collapse.append(trajectory.collapse)
++
++    def _post_init(self):
++        super()._post_init()
++        self.num_c_ops = self.stats["num_collapse"]
++        self.collapse = []
++        self.add_processor(self._add_collapse)
++
++    @property
++    def col_times(self):
++        """
++        List of the times of the collapses for each runs.
++        """
++        out = []
++        for col_ in self.collapse:
++            col = list(zip(*col_))
++            col = ([] if len(col) == 0 else col[0])
++            out.append(col)
++        return out
++
++    @property
++    def col_which(self):
++        """
++        List of the indexes of the collapses for each runs.
++        """
++        out = []
++        for col_ in self.collapse:
++            col = list(zip(*col_))
++            col = ([] if len(col) == 0 else col[1])
++            out.append(col)
++        return out
++
++    @property
++    def photocurrent(self):
++        """
++        Average photocurrent or measurement of the evolution.
++        """
++        cols = [[] for _ in range(self.num_c_ops)]
++        tlist = self.times
++        for collapses in self.collapse:
++            for t, which in collapses:
++                cols[which].append(t)
++        mesurement = [
++            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
++            for i in range(self.num_c_ops)
++        ]
++        return mesurement
++
++    @property
++    def runs_photocurrent(self):
++        """
++        Photocurrent or measurement of each runs.
++        """
++        tlist = self.times
++        measurements = []
++        for collapses in self.collapse:
++            cols = [[] for _ in range(self.num_c_ops)]
++            for t, which in collapses:
++                cols[which].append(t)
++            measurements.append([
++                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
++                for i in range(self.num_c_ops)
++            ])
++        return measurements
+diff --git a/qutip/solver/scattering.py b/qutip/solver/scattering.py
+index 5855832d..b7bdd251 100644
+--- a/qutip/solver/scattering.py
++++ b/qutip/solver/scattering.py
+@@ -1,301 +1,301 @@
+-"""
+-Photon scattering in quantum optical systems
+-
+-This module includes a collection of functions for numerically computing photon
+-scattering in driven arbitrary systems coupled to some configuration of output
+-waveguides. The implementation of these functions closely follows the
+-mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
+-Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
+-"""
+-# Author:  Ben Bartlett
+-# Contact: benbartlett@stanford.edu
+-
+-import numpy as np
+-from itertools import product, combinations_with_replacement
+-from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
+-from .propagator import propagator, Propagator
+-
+-__all__ = ['temporal_basis_vector',
+-           'temporal_scattered_state',
+-           'scattering_probability']
+-
+-
+-def set_partition(collection, num_sets):
+-    """
+-    Enumerate all ways of partitioning collection into num_sets different
+-    lists, e.g. :
+-    list(set_partition([1,2], 2))
+-    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
+-
+-    Parameters
+-    ----------
+-    collection : iterable
+-        Collection to generate a set partition of.
+-    num_sets : int
+-        Number of sets to partition collection into.
+-
+-    Returns
+-    -------
+-    partition : iterable
+-        The partitioning of collection into num_sets sets.
+-    """
+-    for partitioning in product(range(num_sets), repeat=len(collection)):
+-        partition = [[] for _ in range(num_sets)]
+-        for i, set_index in enumerate(partitioning):
+-            partition[set_index].append(collection[i])
+-        yield tuple(tuple(indices) for indices in partition)
+-
+-
+-def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
+-    """
+-    Compute the scattering amplitude for a system emitting into multiple
+-    waveguides.
+-
+-    Parameters
+-    ----------
+-    propagator : :class:Propagator
+-        Propagator
+-    c_ops : list
+-        list of collapse operators for each waveguide; these are assumed to
+-        include spontaneous decay rates, e.g.
+-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
+-    tlist : array_like
+-        List of times starting at the beginning and ending at the end of the
+-        evolution.
+-    taus : list-like
+-        List of (list of emission times) for each waveguide.
+-    psi : Qobj
+-        State at the start of the evolution
+-    psit : Qobj
+-        State at the end of the evolution.
+-    """
+-    # Extract the full list of taus
+-    tau_collapse = []
+-    for i, tau_wg in enumerate(taus):
+-        for t in tau_wg:
+-            tau_collapse.append((t, i))
+-    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
+-
+-    tq = tlist[0]
+-    # Compute Prod Ueff(tq, tq-1)
+-    for tau in tau_collapse:
+-        tprev = tq
+-        tq, q = tau
+-        psi = c_ops[q] * propagator(tq, tprev) * psi
+-
+-    psi = propagator(tlist[-1], tq) * psi
+-    return psit.overlap(psi)
+-
+-
+-def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
+-    """
+-    Generate a the global index for the excitation.
+-    """
+-    idx = []
+-    for i, wg_indices in enumerate(waveguide_emission_indices):
+-        for index in wg_indices:
+-            idx += [i * n_time_bins + index]
+-    idx = idx or [0]
+-    return tuple(idx)
+-
+-
+-def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
+-                         n_emissions=None):
+-    """
+-    Return the dims of the ``temporal_basis_vector``.
+-    """
+-    num_col = len(waveguide_emission_indices)
+-    if n_emissions is None:
+-        n_emissions = sum(
+-            [len(waveguide_indices)
+-             for waveguide_indices in waveguide_emission_indices])
+-    n_emissions = n_emissions or 1
+-    return [num_col * n_time_bins] * n_emissions
+-
+-
+-def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
+-                          n_emissions=None):
+-    """
+-    Generate a temporal basis vector for emissions at specified time bins into
+-    specified waveguides.
+-
+-    Parameters
+-    ----------
+-    waveguide_emission_indices : list or tuple
+-        List of indices where photon emission occurs for each waveguide,
+-        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
+-    n_time_bins : int
+-        Number of time bins; the range over which each index can vary.
+-
+-    Returns
+-    -------
+-    temporal_basis_vector : :class: qutip.Qobj
+-        A basis vector representing photon scattering at the specified indices.
+-        If there are W waveguides, T times, and N photon emissions, then the
+-        basis vector has dimensionality (W*T)^N.
+-    """
+-    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
+-    dims = _temporal_basis_dims(waveguide_emission_indices,
+-                                n_time_bins, n_emissions)
+-    return basis(dims, list(idx))
+-
+-
+-def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
+-                               system_zero_state=None,
+-                               construct_effective_hamiltonian=True):
+-    """
+-    Compute the scattered n-photon state as an ndarray.
+-    """
+-    T = len(tlist)
+-    W = len(c_ops)
+-    em_dims = max(n_emissions, 1)
+-    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
+-
+-    if construct_effective_hamiltonian:
+-        # Construct an effective Hamiltonian from system hamiltonian and c_ops
+-        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
+-    else:
+-        Heff = H
+-
+-    evolver = Propagator(Heff, memoize=len(tlist))
+-
+-    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
+-
+-    if system_zero_state is None:
+-        system_zero_state = psi0
+-
+-    # Compute <omega_tau> for all combinations of tau
+-    for emission_indices in all_emission_indices:
+-        # Consider unique partitionings of emission times into waveguides
+-        partition = tuple(set(set_partition(emission_indices, W)))
+-        # Consider all possible partitionings of time bins by waveguide
+-        for indices in partition:
+-            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
+-            phi_n_amp = photon_scattering_amplitude(
+-                evolver, c_ops, tlist,
+-                taus, psi0, system_zero_state
+-            )
+-            # Add scatter amplitude times temporal basis to overall state
+-            idx = _temporal_basis_idx(indices, T)
+-            phi_n[idx] = phi_n_amp
+-    return phi_n
+-
+-
+-def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
+-                             system_zero_state=None,
+-                             construct_effective_hamiltonian=True):
+-    """
+-    Compute the scattered n-photon state projected onto the temporal basis.
+-
+-    Parameters
+-    ----------
+-    H : :class: qutip.Qobj or list
+-        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
+-        list-callback format. If construct_effective_hamiltonian is not
+-        specified, an effective Hamiltonian is constructed from `H` and
+-        `c_ops`.
+-    psi0 : :class: qutip.Qobj
+-        Initial state density matrix :math:`\\rho(t_0)` or state vector
+-        :math:`\\psi(t_0)`.
+-    n_emissions : int
+-        Number of photon emissions to calculate.
+-    c_ops : list
+-        List of collapse operators for each waveguide; these are assumed to
+-        include spontaneous decay rates, e.g.
+-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
+-    tlist : array_like
+-        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
+-        the pulse duration / temporal region of interest.
+-    system_zero_state : :class: qutip.Qobj
+-        State representing zero excitations in the system. Defaults to
+-        :math:`\\psi(t_0)`
+-    construct_effective_hamiltonian : bool
+-        Whether an effective Hamiltonian should be constructed from H and
+-        c_ops:
+-        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
+-        Default: True.
+-
+-    Returns
+-    -------
+-    phi_n : :class: qutip.Qobj
+-        The scattered bath state projected onto the temporal basis given by
+-        tlist. If there are W waveguides, T times, and N photon emissions, then
+-        the state is a tensor product state with dimensionality T^(W*N).
+-    """
+-    T = len(tlist)
+-    W = len(c_ops)
+-    em_dims = max(n_emissions, 1)
+-    phi_n = _temporal_scattered_matrix(
+-        H, psi0, n_emissions, c_ops, tlist,
+-        system_zero_state, construct_effective_hamiltonian
+-    )
+-    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
+-
+-
+-def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
+-                           system_zero_state=None,
+-                           construct_effective_hamiltonian=True):
+-    """
+-    Compute the integrated probability of scattering n photons in an arbitrary
+-    system. This function accepts a nonlinearly spaced array of times.
+-
+-    Parameters
+-    ----------
+-    H : :class: qutip.Qobj or list
+-        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
+-        list-callback format. If construct_effective_hamiltonian is not
+-        specified, an effective Hamiltonian is constructed from H and
+-        `c_ops`.
+-    psi0 : :class: qutip.Qobj
+-        Initial state density matrix :math:`\\rho(t_0)` or state vector
+-        :math:`\\psi(t_0)`.
+-    n_emissions : int
+-        Number of photons emitted by the system (into any combination of
+-        waveguides).
+-    c_ops : list
+-        List of collapse operators for each waveguide; these are assumed to
+-        include spontaneous decay rates, e.g.
+-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
+-    tlist : array_like
+-        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
+-        the pulse duration / temporal region of interest; tlist need not be
+-        linearly spaced.
+-    system_zero_state : :class: qutip.Qobj
+-        State representing zero excitations in the system. Defaults to
+-        `basis(systemDims, 0)`.
+-    construct_effective_hamiltonian : bool
+-        Whether an effective Hamiltonian should be constructed from H and
+-        c_ops:
+-        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
+-        Default: True.
+-
+-    Returns
+-    -------
+-    scattering_prob : float
+-        The probability of scattering n photons from the system over the time
+-        range specified.
+-    """
+-    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
+-                                       system_zero_state,
+-                                       construct_effective_hamiltonian)
+-    T = len(tlist)
+-    W = len(c_ops)
+-
+-    # Compute <omega_tau> for all combinations of tau
+-    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
+-    probs = np.zeros([T] * n_emissions)
+-
+-    # Project scattered state onto temporal basis
+-    for emit_indices in all_emission_indices:
+-        # Consider unique emission time partitionings
+-        partition = tuple(set(set_partition(emit_indices, W)))
+-        # wg_indices_list = list(set_partition(indices, W))
+-        for wg_indices in partition:
+-            idx = _temporal_basis_idx(wg_indices, T)
+-            amplitude = phi_n[idx]
+-            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
+-
+-    # Iteratively integrate to obtain single value
+-    while probs.shape != ():
+-        probs = np.trapz(probs, x=tlist)
+-    return np.abs(probs)
++"""
++Photon scattering in quantum optical systems
++
++This module includes a collection of functions for numerically computing photon
++scattering in driven arbitrary systems coupled to some configuration of output
++waveguides. The implementation of these functions closely follows the
++mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
++Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
++"""
++# Author:  Ben Bartlett
++# Contact: benbartlett@stanford.edu
++
++import numpy as np
++from itertools import product, combinations_with_replacement
++from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
++from .propagator import propagator, Propagator
++
++__all__ = ['temporal_basis_vector',
++           'temporal_scattered_state',
++           'scattering_probability']
++
++
++def set_partition(collection, num_sets):
++    """
++    Enumerate all ways of partitioning collection into num_sets different
++    lists, e.g. :
++    list(set_partition([1,2], 2))
++    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
++
++    Parameters
++    ----------
++    collection : iterable
++        Collection to generate a set partition of.
++    num_sets : int
++        Number of sets to partition collection into.
++
++    Returns
++    -------
++    partition : iterable
++        The partitioning of collection into num_sets sets.
++    """
++    for partitioning in product(range(num_sets), repeat=len(collection)):
++        partition = [[] for _ in range(num_sets)]
++        for i, set_index in enumerate(partitioning):
++            partition[set_index].append(collection[i])
++        yield tuple(tuple(indices) for indices in partition)
++
++
++def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
++    """
++    Compute the scattering amplitude for a system emitting into multiple
++    waveguides.
++
++    Parameters
++    ----------
++    propagator : :class:Propagator
++        Propagator
++    c_ops : list
++        list of collapse operators for each waveguide; these are assumed to
++        include spontaneous decay rates, e.g.
++        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
++    tlist : array_like
++        List of times starting at the beginning and ending at the end of the
++        evolution.
++    taus : list-like
++        List of (list of emission times) for each waveguide.
++    psi : Qobj
++        State at the start of the evolution
++    psit : Qobj
++        State at the end of the evolution.
++    """
++    # Extract the full list of taus
++    tau_collapse = []
++    for i, tau_wg in enumerate(taus):
++        for t in tau_wg:
++            tau_collapse.append((t, i))
++    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
++
++    tq = tlist[0]
++    # Compute Prod Ueff(tq, tq-1)
++    for tau in tau_collapse:
++        tprev = tq
++        tq, q = tau
++        psi = c_ops[q] * propagator(tq, tprev) * psi
++
++    psi = propagator(tlist[-1], tq) * psi
++    return psit.overlap(psi)
++
++
++def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
++    """
++    Generate a the global index for the excitation.
++    """
++    idx = []
++    for i, wg_indices in enumerate(waveguide_emission_indices):
++        for index in wg_indices:
++            idx += [i * n_time_bins + index]
++    idx = idx or [0]
++    return tuple(idx)
++
++
++def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
++                         n_emissions=None):
++    """
++    Return the dims of the ``temporal_basis_vector``.
++    """
++    num_col = len(waveguide_emission_indices)
++    if n_emissions is None:
++        n_emissions = sum(
++            [len(waveguide_indices)
++             for waveguide_indices in waveguide_emission_indices])
++    n_emissions = n_emissions or 1
++    return [num_col * n_time_bins] * n_emissions
++
++
++def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
++                          n_emissions=None):
++    """
++    Generate a temporal basis vector for emissions at specified time bins into
++    specified waveguides.
++
++    Parameters
++    ----------
++    waveguide_emission_indices : list or tuple
++        List of indices where photon emission occurs for each waveguide,
++        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
++    n_time_bins : int
++        Number of time bins; the range over which each index can vary.
++
++    Returns
++    -------
++    temporal_basis_vector : :class: qutip.Qobj
++        A basis vector representing photon scattering at the specified indices.
++        If there are W waveguides, T times, and N photon emissions, then the
++        basis vector has dimensionality (W*T)^N.
++    """
++    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
++    dims = _temporal_basis_dims(waveguide_emission_indices,
++                                n_time_bins, n_emissions)
++    return basis(dims, list(idx))
++
++
++def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
++                               system_zero_state=None,
++                               construct_effective_hamiltonian=True):
++    """
++    Compute the scattered n-photon state as an ndarray.
++    """
++    T = len(tlist)
++    W = len(c_ops)
++    em_dims = max(n_emissions, 1)
++    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
++
++    if construct_effective_hamiltonian:
++        # Construct an effective Hamiltonian from system hamiltonian and c_ops
++        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
++    else:
++        Heff = H
++
++    evolver = Propagator(Heff, memoize=len(tlist))
++
++    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
++
++    if system_zero_state is None:
++        system_zero_state = psi0
++
++    # Compute <omega_tau> for all combinations of tau
++    for emission_indices in all_emission_indices:
++        # Consider unique partitionings of emission times into waveguides
++        partition = tuple(set(set_partition(emission_indices, W)))
++        # Consider all possible partitionings of time bins by waveguide
++        for indices in partition:
++            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
++            phi_n_amp = photon_scattering_amplitude(
++                evolver, c_ops, tlist,
++                taus, psi0, system_zero_state
++            )
++            # Add scatter amplitude times temporal basis to overall state
++            idx = _temporal_basis_idx(indices, T)
++            phi_n[idx] = phi_n_amp
++    return phi_n
++
++
++def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
++                             system_zero_state=None,
++                             construct_effective_hamiltonian=True):
++    """
++    Compute the scattered n-photon state projected onto the temporal basis.
++
++    Parameters
++    ----------
++    H : :class: qutip.Qobj or list
++        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
++        list-callback format. If construct_effective_hamiltonian is not
++        specified, an effective Hamiltonian is constructed from `H` and
++        `c_ops`.
++    psi0 : :class: qutip.Qobj
++        Initial state density matrix :math:`\\rho(t_0)` or state vector
++        :math:`\\psi(t_0)`.
++    n_emissions : int
++        Number of photon emissions to calculate.
++    c_ops : list
++        List of collapse operators for each waveguide; these are assumed to
++        include spontaneous decay rates, e.g.
++        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
++    tlist : array_like
++        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
++        the pulse duration / temporal region of interest.
++    system_zero_state : :class: qutip.Qobj
++        State representing zero excitations in the system. Defaults to
++        :math:`\\psi(t_0)`
++    construct_effective_hamiltonian : bool
++        Whether an effective Hamiltonian should be constructed from H and
++        c_ops:
++        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
++        Default: True.
++
++    Returns
++    -------
++    phi_n : :class: qutip.Qobj
++        The scattered bath state projected onto the temporal basis given by
++        tlist. If there are W waveguides, T times, and N photon emissions, then
++        the state is a tensor product state with dimensionality T^(W*N).
++    """
++    T = len(tlist)
++    W = len(c_ops)
++    em_dims = max(n_emissions, 1)
++    phi_n = _temporal_scattered_matrix(
++        H, psi0, n_emissions, c_ops, tlist,
++        system_zero_state, construct_effective_hamiltonian
++    )
++    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
++
++
++def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
++                           system_zero_state=None,
++                           construct_effective_hamiltonian=True):
++    """
++    Compute the integrated probability of scattering n photons in an arbitrary
++    system. This function accepts a nonlinearly spaced array of times.
++
++    Parameters
++    ----------
++    H : :class: qutip.Qobj or list
++        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
++        list-callback format. If construct_effective_hamiltonian is not
++        specified, an effective Hamiltonian is constructed from H and
++        `c_ops`.
++    psi0 : :class: qutip.Qobj
++        Initial state density matrix :math:`\\rho(t_0)` or state vector
++        :math:`\\psi(t_0)`.
++    n_emissions : int
++        Number of photons emitted by the system (into any combination of
++        waveguides).
++    c_ops : list
++        List of collapse operators for each waveguide; these are assumed to
++        include spontaneous decay rates, e.g.
++        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
++    tlist : array_like
++        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
++        the pulse duration / temporal region of interest; tlist need not be
++        linearly spaced.
++    system_zero_state : :class: qutip.Qobj
++        State representing zero excitations in the system. Defaults to
++        `basis(systemDims, 0)`.
++    construct_effective_hamiltonian : bool
++        Whether an effective Hamiltonian should be constructed from H and
++        c_ops:
++        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
++        Default: True.
++
++    Returns
++    -------
++    scattering_prob : float
++        The probability of scattering n photons from the system over the time
++        range specified.
++    """
++    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
++                                       system_zero_state,
++                                       construct_effective_hamiltonian)
++    T = len(tlist)
++    W = len(c_ops)
++
++    # Compute <omega_tau> for all combinations of tau
++    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
++    probs = np.zeros([T] * n_emissions)
++
++    # Project scattered state onto temporal basis
++    for emit_indices in all_emission_indices:
++        # Consider unique emission time partitionings
++        partition = tuple(set(set_partition(emit_indices, W)))
++        # wg_indices_list = list(set_partition(indices, W))
++        for wg_indices in partition:
++            idx = _temporal_basis_idx(wg_indices, T)
++            amplitude = phi_n[idx]
++            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
++
++    # Iteratively integrate to obtain single value
++    while probs.shape != ():
++        probs = np.trapz(probs, x=tlist)
++    return np.abs(probs)
+diff --git a/qutip/solver/sesolve.py b/qutip/solver/sesolve.py
+index 09146242..8ed998ba 100644
+--- a/qutip/solver/sesolve.py
++++ b/qutip/solver/sesolve.py
+@@ -1,189 +1,189 @@
+-"""
+-This module provides solvers for the unitary Schrodinger equation.
+-"""
+-
+-__all__ = ['sesolve', 'SESolver']
+-
+-import numpy as np
+-from time import time
+-from .. import Qobj, QobjEvo
+-from .solver_base import Solver
+-
+-
+-def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
+-    """
+-    Schrodinger equation evolution of a state vector or unitary matrix
+-    for a given Hamiltonian.
+-
+-    Evolve the state vector (`psi0`) using a given
+-    Hamiltonian (`H`), by integrating the set of ordinary differential
+-    equations that define the system. Alternatively evolve a unitary matrix in
+-    solving the Schrodinger operator equation.
+-
+-    The output is either the state vector or unitary matrix at arbitrary points
+-    in time (`tlist`), or the expectation values of the supplied operators
+-    (`e_ops`). If e_ops is a callback function, it is invoked for each
+-    time in `tlist` with time and the state as arguments, and the function
+-    does not use any return values. e_ops cannot be used in conjunction
+-    with solving the Schrodinger operator equation
+-
+-    **Time-dependent operators**
+-
+-    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
+-    object that can be interpreted as :class:`QobjEvo` such as a list of
+-    (Qobj, Coefficient) pairs or a function.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+-        that can be made into :class:`QobjEvo` are also accepted.
+-
+-    psi0 : :class:`qutip.qobj`
+-        initial state vector (ket)
+-        or initial unitary operator `psi0 = U`
+-
+-    tlist : *list* / *array*
+-        list of times for :math:`t`.
+-
+-    e_ops : :class:`qutip.qobj`, callable, or list.
+-        Single operator or list of operators for which to evaluate
+-        expectation values or callable or list of callable.
+-        Callable signature must be, `f(t: float, state: Qobj)`.
+-        See :func:`expect` for more detail of operator expectation.
+-
+-    args : None / *dictionary*
+-        dictionary of parameters for time-dependent Hamiltonians
+-
+-    options : None / dict
+-        Dictionary of options for the solver.
+-
+-        - store_final_state : bool
+-          Whether or not to store the final state of the evolution in the
+-          result class.
+-        - store_states : bool, None
+-          Whether or not to store the state vectors or density matrices.
+-          On `None` the states will be saved if no expectation operators are
+-          given.
+-        - normalize_output : bool
+-          Normalize output state to hide ODE numerical errors.
+-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+-          How to present the solver progress.
+-          'tqdm' uses the python module of the same name and raise an error
+-          if not installed. Empty string or False will disable the bar.
+-        - progress_kwargs : dict
+-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+-          Which differential equation integration method to use.
+-        - atol, rtol : float
+-          Absolute and relative tolerance of the ODE integrator.
+-        - nsteps :
+-          Maximum number of (internally defined) steps allowed in one ``tlist``
+-          step.
+-        - max_step : float, 0
+-          Maximum lenght of one internal step. When using pulses, it should be
+-          less than half the width of the thinnest pulse.
+-
+-        Other options could be supported depending on the integration method,
+-        see `Integrator <./classes.html#classes-ode>`_.
+-
+-    Returns
+-    -------
+-    result: :class:`qutip.Result`
+-
+-        An instance of the class :class:`qutip.Result`, which contains
+-        a *list of array* `result.expect` of expectation values for the times
+-        specified by `tlist`, and/or a *list* `result.states` of state vectors
+-        or density matrices corresponding to the times in `tlist` [if `e_ops`
+-        is an empty list of `store_states=True` in options].
+-    """
+-    H = QobjEvo(H, args=args, tlist=tlist)
+-    solver = SESolver(H, options=options)
+-    return solver.run(psi0, tlist, e_ops=e_ops)
+-
+-
+-class SESolver(Solver):
+-    """
+-    Schrodinger equation evolution of a state vector or unitary matrix
+-    for a given Hamiltonian.
+-
+-    Parameters
+-    ----------
+-    H : :class:`Qobj`, :class:`QobjEvo`
+-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+-        that can be made into :class:`QobjEvo` are also accepted.
+-
+-    options : dict, optional
+-        Options for the solver, see :obj:`SESolver.options` and
+-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+-
+-    attributes
+-    ----------
+-    stats: dict
+-        Diverse diagnostic statistics of the evolution.
+-    """
+-    name = "sesolve"
+-    _avail_integrators = {}
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size":10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": True,
+-        'method': 'adams',
+-    }
+-
+-    def __init__(self, H, *, options=None):
+-        _time_start = time()
+-
+-        if not isinstance(H, (Qobj, QobjEvo)):
+-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+-
+-        rhs = -1j * H
+-        if not rhs.isoper:
+-            raise ValueError("The hamiltonian must be an operator")
+-        super().__init__(rhs, options=options)
+-
+-    def _initialize_stats(self):
+-        stats = super()._initialize_stats()
+-        stats.update({
+-            "solver": "Schrodinger Evolution",
+-        })
+-        return stats
+-
+-    @property
+-    def options(self):
+-        """
+-        Solver's options:
+-
+-        store_final_state: bool, default=False
+-            Whether or not to store the final state of the evolution in the
+-            result class.
+-
+-        store_states: bool, default=None
+-            Whether or not to store the state vectors or density matrices.
+-            On `None` the states will be saved if no expectation operators are
+-            given.
+-
+-        normalize_output: bool, default=True
+-            Normalize output state to hide ODE numerical errors.
+-
+-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
+-            How to present the solver progress.
+-            'tqdm' uses the python module of the same name and raise an error
+-            if not installed. Empty string or False will disable the bar.
+-
+-        progress_kwargs: dict, default={"chunk_size": 10}
+-            Arguments to pass to the progress_bar. Qutip's bars use
+-            ``chunk_size``.
+-
+-        method: str, default="adams"
+-            Which ordinary differential equation integration method to use.
+-        """
+-        return self._options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        Solver.options.fset(self, new_options)
++"""
++This module provides solvers for the unitary Schrodinger equation.
++"""
++
++__all__ = ['sesolve', 'SESolver']
++
++import numpy as np
++from time import time
++from .. import Qobj, QobjEvo
++from .solver_base import Solver
++
++
++def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
++    """
++    Schrodinger equation evolution of a state vector or unitary matrix
++    for a given Hamiltonian.
++
++    Evolve the state vector (`psi0`) using a given
++    Hamiltonian (`H`), by integrating the set of ordinary differential
++    equations that define the system. Alternatively evolve a unitary matrix in
++    solving the Schrodinger operator equation.
++
++    The output is either the state vector or unitary matrix at arbitrary points
++    in time (`tlist`), or the expectation values of the supplied operators
++    (`e_ops`). If e_ops is a callback function, it is invoked for each
++    time in `tlist` with time and the state as arguments, and the function
++    does not use any return values. e_ops cannot be used in conjunction
++    with solving the Schrodinger operator equation
++
++    **Time-dependent operators**
++
++    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
++    object that can be interpreted as :class:`QobjEvo` such as a list of
++    (Qobj, Coefficient) pairs or a function.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
++        System Hamiltonian as a Qobj or QobjEvo for time-dependent
++        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
++        that can be made into :class:`QobjEvo` are also accepted.
++
++    psi0 : :class:`qutip.qobj`
++        initial state vector (ket)
++        or initial unitary operator `psi0 = U`
++
++    tlist : *list* / *array*
++        list of times for :math:`t`.
++
++    e_ops : :class:`qutip.qobj`, callable, or list.
++        Single operator or list of operators for which to evaluate
++        expectation values or callable or list of callable.
++        Callable signature must be, `f(t: float, state: Qobj)`.
++        See :func:`expect` for more detail of operator expectation.
++
++    args : None / *dictionary*
++        dictionary of parameters for time-dependent Hamiltonians
++
++    options : None / dict
++        Dictionary of options for the solver.
++
++        - store_final_state : bool
++          Whether or not to store the final state of the evolution in the
++          result class.
++        - store_states : bool, None
++          Whether or not to store the state vectors or density matrices.
++          On `None` the states will be saved if no expectation operators are
++          given.
++        - normalize_output : bool
++          Normalize output state to hide ODE numerical errors.
++        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
++          How to present the solver progress.
++          'tqdm' uses the python module of the same name and raise an error
++          if not installed. Empty string or False will disable the bar.
++        - progress_kwargs : dict
++          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
++        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
++          Which differential equation integration method to use.
++        - atol, rtol : float
++          Absolute and relative tolerance of the ODE integrator.
++        - nsteps :
++          Maximum number of (internally defined) steps allowed in one ``tlist``
++          step.
++        - max_step : float, 0
++          Maximum lenght of one internal step. When using pulses, it should be
++          less than half the width of the thinnest pulse.
++
++        Other options could be supported depending on the integration method,
++        see `Integrator <./classes.html#classes-ode>`_.
++
++    Returns
++    -------
++    result: :class:`qutip.Result`
++
++        An instance of the class :class:`qutip.Result`, which contains
++        a *list of array* `result.expect` of expectation values for the times
++        specified by `tlist`, and/or a *list* `result.states` of state vectors
++        or density matrices corresponding to the times in `tlist` [if `e_ops`
++        is an empty list of `store_states=True` in options].
++    """
++    H = QobjEvo(H, args=args, tlist=tlist)
++    solver = SESolver(H, options=options)
++    return solver.run(psi0, tlist, e_ops=e_ops)
++
++
++class SESolver(Solver):
++    """
++    Schrodinger equation evolution of a state vector or unitary matrix
++    for a given Hamiltonian.
++
++    Parameters
++    ----------
++    H : :class:`Qobj`, :class:`QobjEvo`
++        System Hamiltonian as a Qobj or QobjEvo for time-dependent
++        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
++        that can be made into :class:`QobjEvo` are also accepted.
++
++    options : dict, optional
++        Options for the solver, see :obj:`SESolver.options` and
++        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
++
++    attributes
++    ----------
++    stats: dict
++        Diverse diagnostic statistics of the evolution.
++    """
++    name = "sesolve"
++    _avail_integrators = {}
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size":10},
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": True,
++        'method': 'adams',
++    }
++
++    def __init__(self, H, *, options=None):
++        _time_start = time()
++
++        if not isinstance(H, (Qobj, QobjEvo)):
++            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
++
++        rhs = -1j * H
++        if not rhs.isoper:
++            raise ValueError("The hamiltonian must be an operator")
++        super().__init__(rhs, options=options)
++
++    def _initialize_stats(self):
++        stats = super()._initialize_stats()
++        stats.update({
++            "solver": "Schrodinger Evolution",
++        })
++        return stats
++
++    @property
++    def options(self):
++        """
++        Solver's options:
++
++        store_final_state: bool, default=False
++            Whether or not to store the final state of the evolution in the
++            result class.
++
++        store_states: bool, default=None
++            Whether or not to store the state vectors or density matrices.
++            On `None` the states will be saved if no expectation operators are
++            given.
++
++        normalize_output: bool, default=True
++            Normalize output state to hide ODE numerical errors.
++
++        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
++            How to present the solver progress.
++            'tqdm' uses the python module of the same name and raise an error
++            if not installed. Empty string or False will disable the bar.
++
++        progress_kwargs: dict, default={"chunk_size": 10}
++            Arguments to pass to the progress_bar. Qutip's bars use
++            ``chunk_size``.
++
++        method: str, default="adams"
++            Which ordinary differential equation integration method to use.
++        """
++        return self._options
++
++    @options.setter
++    def options(self, new_options):
++        Solver.options.fset(self, new_options)
+diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
+index 953bfab4..ae0db232 100644
+--- a/qutip/solver/solver_base.py
++++ b/qutip/solver/solver_base.py
+@@ -1,395 +1,395 @@
+-__all__ = ['Solver']
+-
+-from .. import Qobj, QobjEvo, ket2dm
+-from .options import _SolverOptions
+-from ..core import stack_columns, unstack_columns
+-from .result import Result
+-from .integrator import Integrator
+-from ..ui.progressbar import progess_bars
+-from time import time
+-
+-
+-class Solver:
+-    """
+-    Runner for an evolution.
+-    Can run the evolution at once using :method:`run` or step by step using
+-    :method:`start` and :method:`step`.
+-
+-    Parameters
+-    ----------
+-    rhs : Qobj, QobjEvo
+-        Right hand side of the evolution::
+-            d state / dt = rhs @ state
+-
+-    options : dict
+-        Options for the solver
+-    """
+-    name = ""
+-
+-    # State, time and Integrator of the stepper functionnality
+-    _integrator = None
+-    _avail_integrators = {}
+-
+-    # Class of option used by the solver
+-    solver_options = {
+-        "progress_bar": "text",
+-        "progress_kwargs": {"chunk_size": 10},
+-        "store_final_state": False,
+-        "store_states": None,
+-        "normalize_output": "ket",
+-        "method": "adams",
+-    }
+-    resultclass = Result
+-
+-    def __init__(self, rhs, *, options=None):
+-        if isinstance(rhs, (QobjEvo, Qobj)):
+-            self.rhs = QobjEvo(rhs)
+-        else:
+-            TypeError("The rhs must be a QobjEvo")
+-        self.options = options
+-        self._integrator = self._get_integrator()
+-        self._state_metadata = {}
+-        self.stats = self._initialize_stats()
+-
+-    def _initialize_stats(self):
+-        """ Return the initial values for the solver stats.
+-        """
+-        return {
+-            "method": self._integrator.name,
+-            "init time": self._init_integrator_time,
+-            "preparation time": 0.0,
+-            "run time": 0.0,
+-        }
+-
+-    def _prepare_state(self, state):
+-        """
+-        Extract the data of the Qobj state.
+-
+-        Is responsible for dims checks, preparing the data (stack columns, ...)
+-        determining the dims of the output for :method:`_restore_state`.
+-
+-        Should return the state's data such that it can be used by Integrators.
+-        """
+-        if self.rhs.issuper and state.isket:
+-            state = ket2dm(state)
+-
+-        if (
+-            self.rhs.dims[1] != state.dims[0]
+-            and self.rhs.dims[1] != state.dims
+-        ):
+-            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
+-                            f" and {state.dims}")
+-
+-        self._state_metadata = {
+-            'dims': state.dims,
+-            'type': state.type,
+-            'isherm': state.isherm and not (self.rhs.dims == state.dims)
+-        }
+-        if self.rhs.dims[1] == state.dims:
+-            return stack_columns(state.data)
+-        return state.data
+-
+-    def _restore_state(self, data, *, copy=True):
+-        """
+-        Retore the Qobj state from its data.
+-        """
+-        if self._state_metadata['dims'] == self.rhs.dims[1]:
+-            state = Qobj(unstack_columns(data),
+-                         **self._state_metadata, copy=False)
+-        else:
+-            state = Qobj(data, **self._state_metadata, copy=copy)
+-
+-        if data.shape[1] == 1 and self._options['normalize_output']:
+-            state = state * (1 / state.norm())
+-
+-        return state
+-
+-    def run(self, state0, tlist, *, args=None, e_ops=None):
+-        """
+-        Do the evolution of the Quantum system.
+-
+-        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
+-        ``rhs`` and for each time in ``tlist`` store the state and/or
+-        expectation values in a :cls:`Result`. The evolution method and stored
+-        results are determined by ``options``.
+-
+-        Parameters
+-        ----------
+-        state0 : :class:`Qobj`
+-            Initial state of the evolution.
+-
+-        tlist : list of double
+-            Time for which to save the results (state and/or expect) of the
+-            evolution. The first element of the list is the initial time of the
+-            evolution. Each times of the list must be increasing, but does not
+-            need to be uniformy distributed.
+-
+-        args : dict, optional {None}
+-            Change the ``args`` of the rhs for the evolution.
+-
+-        e_ops : list {None}
+-            List of Qobj, QobjEvo or callable to compute the expectation
+-            values. Function[s] must have the signature
+-            f(t : float, state : Qobj) -> expect.
+-
+-        Return
+-        ------
+-        results : :class:`qutip.solver.Result`
+-            Results of the evolution. States and/or expect will be saved. You
+-            can control the saved data in the options.
+-        """
+-        _time_start = time()
+-        _data0 = self._prepare_state(state0)
+-        self._integrator.set_state(tlist[0], _data0)
+-        self._argument(args)
+-        stats = self._initialize_stats()
+-        results = self.resultclass(
+-            e_ops, self.options,
+-            solver=self.name, stats=stats,
+-        )
+-        results.add(tlist[0], self._restore_state(_data0, copy=False))
+-        stats['preparation time'] += time() - _time_start
+-
+-        progress_bar = progess_bars[self.options['progress_bar']]()
+-        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
+-        for t, state in self._integrator.run(tlist):
+-            progress_bar.update()
+-            results.add(t, self._restore_state(state, copy=False))
+-        progress_bar.finished()
+-
+-        stats['run time'] = progress_bar.total_time()
+-        # TODO: It would be nice if integrator could give evolution statistics
+-        # stats.update(_integrator.stats)
+-        return results
+-
+-    def start(self, state0, t0):
+-        """
+-        Set the initial state and time for a step evolution.
+-        ``options`` for the evolutions are read at this step.
+-
+-        Parameters
+-        ----------
+-        state0 : :class:`Qobj`
+-            Initial state of the evolution.
+-
+-        t0 : double
+-            Initial time of the evolution.
+-        """
+-        _time_start = time()
+-        self._integrator.set_state(t0, self._prepare_state(state0))
+-        self.stats["preparation time"] += time() - _time_start
+-
+-    def step(self, t, *, args=None, copy=True):
+-        """
+-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+-
+-        Parameters
+-        ----------
+-        t : double
+-            Time to evolve to, must be higher than the last call.
+-
+-        args : dict, optional {None}
+-            Update the ``args`` of the system.
+-            The change is effective from the beginning of the interval.
+-            Changing ``args`` can slow the evolution.
+-
+-        copy : bool, optional {True}
+-            Whether to return a copy of the data or the data in the ODE solver.
+-
+-        .. note::
+-            The state must be initialized first by calling ``start`` or
+-            ``run``. If ``run`` is called, ``step`` will continue from the last
+-            time and state obtained.
+-        """
+-        if not self._integrator._is_set:
+-            raise RuntimeError("The `start` method must called first")
+-        _time_start = time()
+-        self._argument(args)
+-        _, state = self._integrator.integrate(t, copy=False)
+-        self.stats["run time"] += time() - _time_start
+-        return self._restore_state(state, copy=copy)
+-
+-    def _get_integrator(self):
+-        """ Return the initialted integrator. """
+-        _time_start = time()
+-        method = self._options["method"]
+-        if method in self.avail_integrators():
+-            integrator = self.avail_integrators()[method]
+-        elif issubclass(method, Integrator):
+-            integrator = method
+-        else:
+-            raise ValueError("Integrator method not supported.")
+-        integrator_instance = integrator(self.rhs, self.options)
+-        self._init_integrator_time = time() - _time_start
+-        return integrator_instance
+-
+-    @property
+-    def sys_dims(self):
+-        """
+-        Dimensions of the space that the system use:
+-
+-        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
+-        for this solver.
+-        """
+-        return self.rhs.dims[0]
+-
+-    @property
+-    def options(self):
+-        """
+-        method: str
+-            Which ordinary differential equation integration method to use.
+-        """
+-        return self._options
+-
+-    def _parse_options(self, new_options, default, old_options):
+-        """
+-        Do a first read through of the options:
+-        - Split new options' items included in the default from those that are
+-          not.
+-        - Replace ``None`` with the default value.
+-        - Remove items that are unchanged.
+-        """
+-        included_options = {
+-            key: val
+-            for key, val in new_options.items()
+-            if key in default
+-        }
+-        extra_options = {
+-            key: val
+-            for key, val in new_options.items()
+-            if key not in default
+-        }
+-
+-        # First pass: Have ``None`` refert to the default.
+-        included_options = {
+-            key: (val if val is not None else default[key])
+-            for key, val in included_options.items()
+-        }
+-        # Second pass: Remove options that remain unchanged.
+-        included_options = {
+-            key: val
+-            for key, val in included_options.items()
+-            if not (key in old_options and val == old_options[key])
+-        }
+-        return included_options, extra_options
+-
+-    @options.setter
+-    def options(self, new_options):
+-        if not hasattr(self, "_options"):
+-            self._options = {}
+-        if new_options is None:
+-            new_options = {}
+-        if not isinstance(new_options, dict):
+-            raise TypeError("options most to be a dictionary.")
+-        new_solver_options, new_ode_options = self._parse_options(
+-            new_options, self.solver_options, self.options
+-        )
+-        method = new_solver_options.get(
+-            "method", self.options.get("method", self.solver_options["method"])
+-        )
+-        integrator = self.avail_integrators()[method]
+-
+-        if method == self.options.get("method", None):
+-            # If method changed, drop old ode options
+-            old_ode_options = self.options
+-            old_options = self._options
+-        else:
+-            old_ode_options = {}
+-            old_options, _ = self._parse_options(
+-                self._options, self.solver_options, {}
+-            )
+-
+-        new_ode_options, extra_options = self._parse_options(
+-            new_ode_options, integrator.integrator_options, self.options
+-        )
+-        if extra_options:
+-            raise KeyError(f"Options {extra_options.keys()} are not supported")
+-        if self._options and not (new_solver_options or new_ode_options):
+-            return  # Nothing to do
+-
+-        self._options = _SolverOptions(
+-            {**self.solver_options, **integrator.integrator_options},
+-            self._apply_options,
+-            self.name + " with " + integrator.method + " integrator",
+-            self.__class__.options.__doc__ + integrator.options.__doc__,
+-            **{**old_options, **new_solver_options, **new_ode_options}
+-        )
+-
+-        self._apply_options(set(new_options.keys()))
+-
+-    def _apply_options(self, keys):
+-        """
+-        Method called when options are changed, either through
+-        ``solver.options[key] = value`` or ``solver.options = options``.
+-        Allow to update the solver with the new options
+-        """
+-        from_setter = isinstance(keys, (set))
+-        if not from_setter:
+-            keys = set([keys])
+-
+-        if not from_setter and "method" in keys:
+-            # Drop the ode's options.
+-            old_solver_options, _ = self._parse_options(
+-                self.options, self.solver_options, {}
+-            )
+-            method = self.options["method"]
+-            integrator = self.avail_integrators()[method]
+-
+-            self._options = _SolverOptions(
+-                {**self.solver_options, **integrator.integrator_options},
+-                self._apply_options,
+-                self.name + " with " + integrator.method + " integrator",
+-                self.__class__.options.__doc__ + integrator.options.__doc__,
+-                **old_solver_options
+-            )
+-
+-        if self._integrator is None or not keys:
+-            pass
+-        elif 'method' in keys and self._integrator._is_set:
+-            state = self._integrator.get_state()
+-            self._integrator = self._get_integrator()
+-            self._integrator.set_state(*state)
+-        elif "method" in keys:
+-            self._integrator = self._get_integrator()
+-        elif keys & self._integrator.integrator_options.keys():
+-            # Some of the keys are used by the integrator.
+-            self._integrator.options = self._options
+-            self._integrator.reset(hard=True)
+-
+-    def _argument(self, args):
+-        """Update the args, for the `rhs` and other operators."""
+-        if args:
+-            self.rhs.arguments(args)
+-            self._integrator.arguments(args)
+-
+-    @classmethod
+-    def avail_integrators(cls):
+-        if cls is Solver:
+-            return cls._avail_integrators.copy()
+-        return {
+-            **Solver.avail_integrators(),
+-            **cls._avail_integrators,
+-        }
+-
+-    @classmethod
+-    def integrator(cls, key):
+-        return cls.avail_integrators()[key]
+-
+-    @classmethod
+-    def add_integrator(cls, integrator, key):
+-        """
+-        Register an integrator.
+-
+-        Parameters
+-        ----------
+-        integrator : Integrator
+-            The ODE solver to register.
+-
+-        keys : list of str
+-            Values of the method options that refer to this integrator.
+-        """
+-        if not issubclass(integrator, Integrator):
+-            raise TypeError(f"The integrator {integrator} must be a subclass"
+-                            " of `qutip.solver.Integrator`")
+-
+-        cls._avail_integrators[key] = integrator
++__all__ = ['Solver']
++
++from .. import Qobj, QobjEvo, ket2dm
++from .options import _SolverOptions
++from ..core import stack_columns, unstack_columns
++from .result import Result
++from .integrator import Integrator
++from ..ui.progressbar import progess_bars
++from time import time
++
++
++class Solver:
++    """
++    Runner for an evolution.
++    Can run the evolution at once using :method:`run` or step by step using
++    :method:`start` and :method:`step`.
++
++    Parameters
++    ----------
++    rhs : Qobj, QobjEvo
++        Right hand side of the evolution::
++            d state / dt = rhs @ state
++
++    options : dict
++        Options for the solver
++    """
++    name = ""
++
++    # State, time and Integrator of the stepper functionnality
++    _integrator = None
++    _avail_integrators = {}
++
++    # Class of option used by the solver
++    solver_options = {
++        "progress_bar": "text",
++        "progress_kwargs": {"chunk_size": 10},
++        "store_final_state": False,
++        "store_states": None,
++        "normalize_output": "ket",
++        "method": "adams",
++    }
++    resultclass = Result
++
++    def __init__(self, rhs, *, options=None):
++        if isinstance(rhs, (QobjEvo, Qobj)):
++            self.rhs = QobjEvo(rhs)
++        else:
++            TypeError("The rhs must be a QobjEvo")
++        self.options = options
++        self._integrator = self._get_integrator()
++        self._state_metadata = {}
++        self.stats = self._initialize_stats()
++
++    def _initialize_stats(self):
++        """ Return the initial values for the solver stats.
++        """
++        return {
++            "method": self._integrator.name,
++            "init time": self._init_integrator_time,
++            "preparation time": 0.0,
++            "run time": 0.0,
++        }
++
++    def _prepare_state(self, state):
++        """
++        Extract the data of the Qobj state.
++
++        Is responsible for dims checks, preparing the data (stack columns, ...)
++        determining the dims of the output for :method:`_restore_state`.
++
++        Should return the state's data such that it can be used by Integrators.
++        """
++        if self.rhs.issuper and state.isket:
++            state = ket2dm(state)
++
++        if (
++            self.rhs.dims[1] != state.dims[0]
++            and self.rhs.dims[1] != state.dims
++        ):
++            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
++                            f" and {state.dims}")
++
++        self._state_metadata = {
++            'dims': state.dims,
++            'type': state.type,
++            'isherm': state.isherm and not (self.rhs.dims == state.dims)
++        }
++        if self.rhs.dims[1] == state.dims:
++            return stack_columns(state.data)
++        return state.data
++
++    def _restore_state(self, data, *, copy=True):
++        """
++        Retore the Qobj state from its data.
++        """
++        if self._state_metadata['dims'] == self.rhs.dims[1]:
++            state = Qobj(unstack_columns(data),
++                         **self._state_metadata, copy=False)
++        else:
++            state = Qobj(data, **self._state_metadata, copy=copy)
++
++        if data.shape[1] == 1 and self._options['normalize_output']:
++            state = state * (1 / state.norm())
++
++        return state
++
++    def run(self, state0, tlist, *, args=None, e_ops=None):
++        """
++        Do the evolution of the Quantum system.
++
++        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
++        ``rhs`` and for each time in ``tlist`` store the state and/or
++        expectation values in a :cls:`Result`. The evolution method and stored
++        results are determined by ``options``.
++
++        Parameters
++        ----------
++        state0 : :class:`Qobj`
++            Initial state of the evolution.
++
++        tlist : list of double
++            Time for which to save the results (state and/or expect) of the
++            evolution. The first element of the list is the initial time of the
++            evolution. Each times of the list must be increasing, but does not
++            need to be uniformy distributed.
++
++        args : dict, optional {None}
++            Change the ``args`` of the rhs for the evolution.
++
++        e_ops : list {None}
++            List of Qobj, QobjEvo or callable to compute the expectation
++            values. Function[s] must have the signature
++            f(t : float, state : Qobj) -> expect.
++
++        Return
++        ------
++        results : :class:`qutip.solver.Result`
++            Results of the evolution. States and/or expect will be saved. You
++            can control the saved data in the options.
++        """
++        _time_start = time()
++        _data0 = self._prepare_state(state0)
++        self._integrator.set_state(tlist[0], _data0)
++        self._argument(args)
++        stats = self._initialize_stats()
++        results = self.resultclass(
++            e_ops, self.options,
++            solver=self.name, stats=stats,
++        )
++        results.add(tlist[0], self._restore_state(_data0, copy=False))
++        stats['preparation time'] += time() - _time_start
++
++        progress_bar = progess_bars[self.options['progress_bar']]()
++        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
++        for t, state in self._integrator.run(tlist):
++            progress_bar.update()
++            results.add(t, self._restore_state(state, copy=False))
++        progress_bar.finished()
++
++        stats['run time'] = progress_bar.total_time()
++        # TODO: It would be nice if integrator could give evolution statistics
++        # stats.update(_integrator.stats)
++        return results
++
++    def start(self, state0, t0):
++        """
++        Set the initial state and time for a step evolution.
++        ``options`` for the evolutions are read at this step.
++
++        Parameters
++        ----------
++        state0 : :class:`Qobj`
++            Initial state of the evolution.
++
++        t0 : double
++            Initial time of the evolution.
++        """
++        _time_start = time()
++        self._integrator.set_state(t0, self._prepare_state(state0))
++        self.stats["preparation time"] += time() - _time_start
++
++    def step(self, t, *, args=None, copy=True):
++        """
++        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
++
++        Parameters
++        ----------
++        t : double
++            Time to evolve to, must be higher than the last call.
++
++        args : dict, optional {None}
++            Update the ``args`` of the system.
++            The change is effective from the beginning of the interval.
++            Changing ``args`` can slow the evolution.
++
++        copy : bool, optional {True}
++            Whether to return a copy of the data or the data in the ODE solver.
++
++        .. note::
++            The state must be initialized first by calling ``start`` or
++            ``run``. If ``run`` is called, ``step`` will continue from the last
++            time and state obtained.
++        """
++        if not self._integrator._is_set:
++            raise RuntimeError("The `start` method must called first")
++        _time_start = time()
++        self._argument(args)
++        _, state = self._integrator.integrate(t, copy=False)
++        self.stats["run time"] += time() - _time_start
++        return self._restore_state(state, copy=copy)
++
++    def _get_integrator(self):
++        """ Return the initialted integrator. """
++        _time_start = time()
++        method = self._options["method"]
++        if method in self.avail_integrators():
++            integrator = self.avail_integrators()[method]
++        elif issubclass(method, Integrator):
++            integrator = method
++        else:
++            raise ValueError("Integrator method not supported.")
++        integrator_instance = integrator(self.rhs, self.options)
++        self._init_integrator_time = time() - _time_start
++        return integrator_instance
++
++    @property
++    def sys_dims(self):
++        """
++        Dimensions of the space that the system use:
++
++        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
++        for this solver.
++        """
++        return self.rhs.dims[0]
++
++    @property
++    def options(self):
++        """
++        method: str
++            Which ordinary differential equation integration method to use.
++        """
++        return self._options
++
++    def _parse_options(self, new_options, default, old_options):
++        """
++        Do a first read through of the options:
++        - Split new options' items included in the default from those that are
++          not.
++        - Replace ``None`` with the default value.
++        - Remove items that are unchanged.
++        """
++        included_options = {
++            key: val
++            for key, val in new_options.items()
++            if key in default
++        }
++        extra_options = {
++            key: val
++            for key, val in new_options.items()
++            if key not in default
++        }
++
++        # First pass: Have ``None`` refert to the default.
++        included_options = {
++            key: (val if val is not None else default[key])
++            for key, val in included_options.items()
++        }
++        # Second pass: Remove options that remain unchanged.
++        included_options = {
++            key: val
++            for key, val in included_options.items()
++            if not (key in old_options and val == old_options[key])
++        }
++        return included_options, extra_options
++
++    @options.setter
++    def options(self, new_options):
++        if not hasattr(self, "_options"):
++            self._options = {}
++        if new_options is None:
++            new_options = {}
++        if not isinstance(new_options, dict):
++            raise TypeError("options most to be a dictionary.")
++        new_solver_options, new_ode_options = self._parse_options(
++            new_options, self.solver_options, self.options
++        )
++        method = new_solver_options.get(
++            "method", self.options.get("method", self.solver_options["method"])
++        )
++        integrator = self.avail_integrators()[method]
++
++        if method == self.options.get("method", None):
++            # If method changed, drop old ode options
++            old_ode_options = self.options
++            old_options = self._options
++        else:
++            old_ode_options = {}
++            old_options, _ = self._parse_options(
++                self._options, self.solver_options, {}
++            )
++
++        new_ode_options, extra_options = self._parse_options(
++            new_ode_options, integrator.integrator_options, self.options
++        )
++        if extra_options:
++            raise KeyError(f"Options {extra_options.keys()} are not supported")
++        if self._options and not (new_solver_options or new_ode_options):
++            return  # Nothing to do
++
++        self._options = _SolverOptions(
++            {**self.solver_options, **integrator.integrator_options},
++            self._apply_options,
++            self.name + " with " + integrator.method + " integrator",
++            self.__class__.options.__doc__ + integrator.options.__doc__,
++            **{**old_options, **new_solver_options, **new_ode_options}
++        )
++
++        self._apply_options(set(new_options.keys()))
++
++    def _apply_options(self, keys):
++        """
++        Method called when options are changed, either through
++        ``solver.options[key] = value`` or ``solver.options = options``.
++        Allow to update the solver with the new options
++        """
++        from_setter = isinstance(keys, (set))
++        if not from_setter:
++            keys = set([keys])
++
++        if not from_setter and "method" in keys:
++            # Drop the ode's options.
++            old_solver_options, _ = self._parse_options(
++                self.options, self.solver_options, {}
++            )
++            method = self.options["method"]
++            integrator = self.avail_integrators()[method]
++
++            self._options = _SolverOptions(
++                {**self.solver_options, **integrator.integrator_options},
++                self._apply_options,
++                self.name + " with " + integrator.method + " integrator",
++                self.__class__.options.__doc__ + integrator.options.__doc__,
++                **old_solver_options
++            )
++
++        if self._integrator is None or not keys:
++            pass
++        elif 'method' in keys and self._integrator._is_set:
++            state = self._integrator.get_state()
++            self._integrator = self._get_integrator()
++            self._integrator.set_state(*state)
++        elif "method" in keys:
++            self._integrator = self._get_integrator()
++        elif keys & self._integrator.integrator_options.keys():
++            # Some of the keys are used by the integrator.
++            self._integrator.options = self._options
++            self._integrator.reset(hard=True)
++
++    def _argument(self, args):
++        """Update the args, for the `rhs` and other operators."""
++        if args:
++            self.rhs.arguments(args)
++            self._integrator.arguments(args)
++
++    @classmethod
++    def avail_integrators(cls):
++        if cls is Solver:
++            return cls._avail_integrators.copy()
++        return {
++            **Solver.avail_integrators(),
++            **cls._avail_integrators,
++        }
++
++    @classmethod
++    def integrator(cls, key):
++        return cls.avail_integrators()[key]
++
++    @classmethod
++    def add_integrator(cls, integrator, key):
++        """
++        Register an integrator.
++
++        Parameters
++        ----------
++        integrator : Integrator
++            The ODE solver to register.
++
++        keys : list of str
++            Values of the method options that refer to this integrator.
++        """
++        if not issubclass(integrator, Integrator):
++            raise TypeError(f"The integrator {integrator} must be a subclass"
++                            " of `qutip.solver.Integrator`")
++
++        cls._avail_integrators[key] = integrator
+diff --git a/qutip/solver/spectrum.py b/qutip/solver/spectrum.py
+index cb92e1f0..a267ee64 100644
+--- a/qutip/solver/spectrum.py
++++ b/qutip/solver/spectrum.py
+@@ -1,188 +1,188 @@
+-__all__ = ['spectrum', 'spectrum_correlation_fft']
+-
+-import numpy as np
+-import scipy.fftpack
+-
+-from .steadystate import steadystate
+-from ..core import liouvillian, spre, expect
+-from ..core import data as _data
+-from qutip.settings import settings
+-
+-def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
+-    r"""
+-    Calculate the spectrum of the correlation function
+-    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
+-    i.e., the Fourier transform of the correlation function:
+-
+-    .. math::
+-
+-        S(\omega) = \int_{-\infty}^{\infty}
+-        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
+-        e^{-i\omega\tau} d\tau.
+-
+-    using the solver indicated by the `solver` parameter. Note: this spectrum
+-    is only defined for stationary statistics (uses steady state rho0)
+-
+-    Parameters
+-    ----------
+-    H : :class:`qutip.qobj`
+-        system Hamiltonian.
+-    wlist : array_like
+-        List of frequencies for :math:`\omega`.
+-    c_ops : list
+-        List of collapse operators.
+-    a_op : Qobj
+-        Operator A.
+-    b_op : Qobj
+-        Operator B.
+-    solver : str
+-        Choice of solver (`es` for exponential series and
+-        `pi` for psuedo-inverse, `solve` for generic solver).
+-
+-    Returns
+-    -------
+-    spectrum : array
+-        An array with spectrum :math:`S(\omega)` for the frequencies
+-        specified in `wlist`.
+-
+-    """
+-    if not H.issuper:
+-        L = liouvillian(H, c_ops)
+-    else:
+-        L = H + sum([lindblad_dissipator(c) for c in c_ops])
+-    if solver == "es":
+-        return _spectrum_es(L, wlist, a_op, b_op)
+-    elif solver in ["pi", "solve"]:
+-        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
+-    raise ValueError(
+-        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
+-    )
+-
+-
+-def spectrum_correlation_fft(tlist, y, inverse=False):
+-    """
+-    Calculate the power spectrum corresponding to a two-time correlation
+-    function using FFT.
+-
+-    Parameters
+-    ----------
+-    tlist : array_like
+-        list/array of times :math:`t` which the correlation function is given.
+-    y : array_like
+-        list/array of correlations corresponding to time delays :math:`t`.
+-    inverse: boolean
+-        boolean parameter for using a positive exponent in the Fourier
+-        Transform instead. Default is False.
+-
+-    Returns
+-    -------
+-    w, S : tuple
+-        Returns an array of angular frequencies 'w' and the corresponding
+-        two-sided power spectrum 'S(w)'.
+-
+-    """
+-    tlist = np.asarray(tlist)
+-    N = tlist.shape[0]
+-    dt = tlist[1] - tlist[0]
+-    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
+-        raise ValueError('tlist must be equally spaced for FFT.')
+-    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
+-    # calculate the frequencies for the components in F
+-    f = scipy.fftpack.fftfreq(N, dt)
+-    # re-order frequencies from most negative to most positive (centre on 0)
+-    idx = np.array([], dtype='int')
+-    idx = np.append(idx, np.where(f < 0.0))
+-    idx = np.append(idx, np.where(f >= 0.0))
+-    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
+-
+-
+-def _spectrum_es(L, wlist, a_op, b_op):
+-    r"""
+-    Internal function for calculating the spectrum of the correlation function
+-    :math:`\left<A(\tau)B(0)\right>`.
+-    """
+-    # find the steady state density matrix and a_op and b_op expecation values
+-    rho0 = steadystate(L)
+-    a_op_ss = expect(a_op, rho0)
+-    b_op_ss = expect(b_op, rho0)
+-    # eseries solution for (b * rho0)(t)
+-    states, rates = _diagonal_evolution(L, b_op * rho0)
+-    # correlation
+-    ampls = [_data.expect(a_op.data, state) for state in states]
+-    # make covariance
+-    ampls += [-a_op_ss * b_op_ss]
+-    rates += [0]
+-    # Tidy up similar rates.
+-    order = np.argsort(rates)
+-    clean_rates = []
+-    clean_ampls = []
+-    prev_rate = np.nan
+-    for idx in order:
+-        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
+-            clean_ampls[-1] += ampls[idx]
+-        else:
+-            clean_rates.append(rates[idx])
+-            clean_ampls.append(ampls[idx])
+-            prev_rate = rates[idx]
+-    # Remove 0 amplitude
+-    rates, ampls = zip(*[
+-        (rate, ampl)
+-        for rate, ampl in zip(clean_rates, clean_ampls)
+-        if np.abs(ampl) > settings.core["atol"]
+-    ])
+-    ampls, rates = np.array(ampls), np.array(rates)
+-    LW = np.subtract.outer(1j * np.array(wlist), rates).T
+-    return (ampls @ (2 / LW)).real
+-
+-
+-#
+-# pseudo-inverse solvers
+-def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
+-    r"""
+-    Internal function for calculating the spectrum of the correlation function
+-    :math:`\left<A(\tau)B(0)\right>`.
+-    """
+-    dtype = type(L.data)
+-    rho_ss = steadystate(L)
+-    tr_mat = _data.identity[dtype](rho_ss.shape[0])
+-    tr_vec = _data.column_stack(tr_mat).transpose()
+-    rho = _data.column_stack(rho_ss.data)
+-
+-    A = L.data
+-    ket = spre(b_op).data @ rho
+-    bra = tr_vec @ spre(a_op).data
+-
+-    I = _data.identity[dtype](L.shape[0])
+-    P = _data.kron(rho, tr_vec)
+-    Q = I - P
+-
+-    spectrum = np.zeros(len(wlist))
+-    for idx, w in enumerate(wlist):
+-        if use_pinv and np.abs(w) > settings.core["atol"]:
+-            # At w == 0., "L - iw" is singular
+-            MMR = _data.inv(-1.0j * w * I + A)
+-        else:
+-            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
+-
+-        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
+-    return spectrum
+-
+-
+-def _diagonal_evolution(L, rho0, sparse=False):
+-    if rho0.norm() < settings.core["atol"]:
+-        return [_data.zeros["CSR"](*rho0.shape)], [0]
+-    if isinstance(L.data, _data.CSR) and not sparse:
+-        L = L.to(_data.Dense)
+-    evals, evecs = _data.eigs(L.data)
+-    size = rho0.shape[0] * rho0.shape[1]
+-    r0 = _data.column_stack(rho0.data)
+-    v0 = _data.solve(evecs, r0)
+-    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
+-    states = []
+-    rates = []
+-    for ket, rate in zip(_data.split_columns(vv), evals):
+-        if _data.norm.l2(ket) < settings.core["atol"]:
+-            continue
+-        states.append(_data.column_unstack(ket, rho0.shape[0]))
+-        rates.append(rate)
+-    return states, rates
++__all__ = ['spectrum', 'spectrum_correlation_fft']
++
++import numpy as np
++import scipy.fftpack
++
++from .steadystate import steadystate
++from ..core import liouvillian, spre, expect
++from ..core import data as _data
++from qutip.settings import settings
++
++def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
++    r"""
++    Calculate the spectrum of the correlation function
++    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
++    i.e., the Fourier transform of the correlation function:
++
++    .. math::
++
++        S(\omega) = \int_{-\infty}^{\infty}
++        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
++        e^{-i\omega\tau} d\tau.
++
++    using the solver indicated by the `solver` parameter. Note: this spectrum
++    is only defined for stationary statistics (uses steady state rho0)
++
++    Parameters
++    ----------
++    H : :class:`qutip.qobj`
++        system Hamiltonian.
++    wlist : array_like
++        List of frequencies for :math:`\omega`.
++    c_ops : list
++        List of collapse operators.
++    a_op : Qobj
++        Operator A.
++    b_op : Qobj
++        Operator B.
++    solver : str
++        Choice of solver (`es` for exponential series and
++        `pi` for psuedo-inverse, `solve` for generic solver).
++
++    Returns
++    -------
++    spectrum : array
++        An array with spectrum :math:`S(\omega)` for the frequencies
++        specified in `wlist`.
++
++    """
++    if not H.issuper:
++        L = liouvillian(H, c_ops)
++    else:
++        L = H + sum([lindblad_dissipator(c) for c in c_ops])
++    if solver == "es":
++        return _spectrum_es(L, wlist, a_op, b_op)
++    elif solver in ["pi", "solve"]:
++        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
++    raise ValueError(
++        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
++    )
++
++
++def spectrum_correlation_fft(tlist, y, inverse=False):
++    """
++    Calculate the power spectrum corresponding to a two-time correlation
++    function using FFT.
++
++    Parameters
++    ----------
++    tlist : array_like
++        list/array of times :math:`t` which the correlation function is given.
++    y : array_like
++        list/array of correlations corresponding to time delays :math:`t`.
++    inverse: boolean
++        boolean parameter for using a positive exponent in the Fourier
++        Transform instead. Default is False.
++
++    Returns
++    -------
++    w, S : tuple
++        Returns an array of angular frequencies 'w' and the corresponding
++        two-sided power spectrum 'S(w)'.
++
++    """
++    tlist = np.asarray(tlist)
++    N = tlist.shape[0]
++    dt = tlist[1] - tlist[0]
++    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
++        raise ValueError('tlist must be equally spaced for FFT.')
++    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
++    # calculate the frequencies for the components in F
++    f = scipy.fftpack.fftfreq(N, dt)
++    # re-order frequencies from most negative to most positive (centre on 0)
++    idx = np.array([], dtype='int')
++    idx = np.append(idx, np.where(f < 0.0))
++    idx = np.append(idx, np.where(f >= 0.0))
++    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
++
++
++def _spectrum_es(L, wlist, a_op, b_op):
++    r"""
++    Internal function for calculating the spectrum of the correlation function
++    :math:`\left<A(\tau)B(0)\right>`.
++    """
++    # find the steady state density matrix and a_op and b_op expecation values
++    rho0 = steadystate(L)
++    a_op_ss = expect(a_op, rho0)
++    b_op_ss = expect(b_op, rho0)
++    # eseries solution for (b * rho0)(t)
++    states, rates = _diagonal_evolution(L, b_op * rho0)
++    # correlation
++    ampls = [_data.expect(a_op.data, state) for state in states]
++    # make covariance
++    ampls += [-a_op_ss * b_op_ss]
++    rates += [0]
++    # Tidy up similar rates.
++    order = np.argsort(rates)
++    clean_rates = []
++    clean_ampls = []
++    prev_rate = np.nan
++    for idx in order:
++        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
++            clean_ampls[-1] += ampls[idx]
++        else:
++            clean_rates.append(rates[idx])
++            clean_ampls.append(ampls[idx])
++            prev_rate = rates[idx]
++    # Remove 0 amplitude
++    rates, ampls = zip(*[
++        (rate, ampl)
++        for rate, ampl in zip(clean_rates, clean_ampls)
++        if np.abs(ampl) > settings.core["atol"]
++    ])
++    ampls, rates = np.array(ampls), np.array(rates)
++    LW = np.subtract.outer(1j * np.array(wlist), rates).T
++    return (ampls @ (2 / LW)).real
++
++
++#
++# pseudo-inverse solvers
++def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
++    r"""
++    Internal function for calculating the spectrum of the correlation function
++    :math:`\left<A(\tau)B(0)\right>`.
++    """
++    dtype = type(L.data)
++    rho_ss = steadystate(L)
++    tr_mat = _data.identity[dtype](rho_ss.shape[0])
++    tr_vec = _data.column_stack(tr_mat).transpose()
++    rho = _data.column_stack(rho_ss.data)
++
++    A = L.data
++    ket = spre(b_op).data @ rho
++    bra = tr_vec @ spre(a_op).data
++
++    I = _data.identity[dtype](L.shape[0])
++    P = _data.kron(rho, tr_vec)
++    Q = I - P
++
++    spectrum = np.zeros(len(wlist))
++    for idx, w in enumerate(wlist):
++        if use_pinv and np.abs(w) > settings.core["atol"]:
++            # At w == 0., "L - iw" is singular
++            MMR = _data.inv(-1.0j * w * I + A)
++        else:
++            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
++
++        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
++    return spectrum
++
++
++def _diagonal_evolution(L, rho0, sparse=False):
++    if rho0.norm() < settings.core["atol"]:
++        return [_data.zeros["CSR"](*rho0.shape)], [0]
++    if isinstance(L.data, _data.CSR) and not sparse:
++        L = L.to(_data.Dense)
++    evals, evecs = _data.eigs(L.data)
++    size = rho0.shape[0] * rho0.shape[1]
++    r0 = _data.column_stack(rho0.data)
++    v0 = _data.solve(evecs, r0)
++    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
++    states = []
++    rates = []
++    for ket, rate in zip(_data.split_columns(vv), evals):
++        if _data.norm.l2(ket) < settings.core["atol"]:
++            continue
++        states.append(_data.column_unstack(ket, rho0.shape[0]))
++        rates.append(rate)
++    return states, rates
+diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
+index f576c9f2..71efa268 100644
+--- a/qutip/solver/steadystate.py
++++ b/qutip/solver/steadystate.py
+@@ -1,537 +1,537 @@
+-from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
+-from qutip import vector_to_operator, operator_to_vector
+-from qutip import settings
+-import qutip.core.data as _data
+-import numpy as np
+-import scipy.sparse.csgraph
+-import scipy.sparse.linalg
+-from warnings import warn
+-
+-
+-__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
+-
+-
+-def _permute_wbm(L, b):
+-    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
+-    L = _data.permute.indices(L, perm, None)
+-    b = _data.permute.indices(b, perm, None)
+-    return L, b
+-
+-
+-def _permute_rcm(L, b):
+-    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
+-    L = _data.permute.indices(L, perm, perm)
+-    b = _data.permute.indices(b, perm, None)
+-    return L, b, perm
+-
+-
+-def _reverse_rcm(rho, perm):
+-    rev_perm = np.argsort(perm)
+-    rho = _data.permute.indices(rho, rev_perm, None)
+-    return rho
+-
+-
+-def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
+-    """
+-    Calculates the steady state for quantum evolution subject to the supplied
+-    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
+-    collapse operators.
+-
+-    If the user passes a Hamiltonian then it, along with the list of collapse
+-    operators, will be converted into a Liouvillian operator in Lindblad form.
+-
+-    Parameters
+-    ----------
+-    A : :obj:`~Qobj`
+-        A Hamiltonian or Liouvillian operator.
+-
+-    c_op_list : list
+-        A list of collapse operators.
+-
+-    method : str, default='direct'
+-        The allowed methods are composed of 2 parts, the steadystate method:
+-        - "direct": Solving ``L(rho_ss) = 0``
+-        - "eigen" : Eigenvalue problem
+-        - "svd" : Singular value decomposition
+-        - "power" : Inverse-power method
+-
+-    solver : str, default=None
+-        'direct' and 'power' methods only.
+-        Solver to use when solving the ``L(rho_ss) = 0`` equation.
+-        Default supported solver are:
+-
+-        - "solve", "lstsq"
+-          dense solver from numpy.linalg
+-        - "spsolve", "gmres", "lgmres", "bicgstab"
+-          sparse solver from scipy.sparse.linalg
+-        - "mkl_spsolve"
+-          sparse solver by mkl.
+-
+-        Extension to qutip, such as qutip-tensorflow, can use come with their
+-        own solver. When ``A`` and ``c_ops`` use these data backends, see the
+-        corresponding libraries ``linalg`` for available solver.
+-
+-        Extra options for these solver can be passed in ``**kw``.
+-
+-    use_rcm : bool, default False
+-        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
+-        factorization of the Liouvillian.
+-        Used with 'direct' or 'power' method.
+-
+-    use_wbm : bool, default False
+-        Use Weighted Bipartite Matching reordering to make the Liouvillian
+-        diagonally dominant.  This is useful for iterative preconditioners
+-        only. Used with 'direct' or 'power' method.
+-
+-    weight : float, optional
+-        Sets the size of the elements used for adding the unity trace condition
+-        to the linear solvers.  This is set to the average abs value of the
+-        Liouvillian elements if not specified by the user.
+-        Used with 'direct' method.
+-
+-    power_tol : float, default 1e-12
+-        Tolerance for the solution when using the 'power' method.
+-
+-    power_maxiter : int, default 10
+-        Maximum number of iteration to use when looking for a solution when
+-        using the 'power' method.
+-
+-    power_eps: double, default 1e-15
+-        Small weight used in the "power" method.
+-
+-    sparse: bool
+-        Whether to use the sparse eigen solver with the "eigen" method
+-        (default sparse).  With "direct" and "power" method, when the solver is
+-        not specified, it is used to set whether "solve" or "spsolve" is
+-        used as default solver.
+-
+-    **kwargs :
+-        Extra options to pass to the linear system solver. See the
+-        documentation of the used solver in ``numpy.linalg`` or
+-        ``scipy.sparse.linalg`` to see what extra arguments are supported.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Steady state density matrix.
+-    info : dict, optional
+-        Dictionary containing solver-specific information about the solution.
+-
+-    .. note::
+-
+-        The SVD method works only for dense operators (i.e. small systems).
+-
+-    """
+-    if not A.issuper and not c_ops:
+-        raise TypeError('Cannot calculate the steady state for a ' +
+-                        'non-dissipative system.')
+-    if not A.issuper:
+-        A = liouvillian(A)
+-    for op in c_ops:
+-        A += lindblad_dissipator(op)
+-
+-    if "-" in method:
+-        # to support v4's "power-gmres" method
+-        method, solver = method.split("-")
+-
+-    if solver == "mkl":
+-        solver = "mkl_spsolve"
+-
+-    # Keys supported in v4, but removed in v5
+-    if kwargs.pop("return_info", False):
+-        warn("Steadystate no longer supports return_info", DeprecationWarning)
+-    if "mtol" in kwargs and "power_tol" not in kwargs:
+-        kwargs["power_tol"] = kwargs["mtol"]
+-    kwargs.pop("mtol", None)
+-
+-    if method == "eigen":
+-        return _steadystate_eigen(A, **kwargs)
+-    if method == "svd":
+-        return _steadystate_svd(A, **kwargs)
+-
+-    # We want to be able to use this without having to know what data type the
+-    # liouvillian uses. For extra data types (tensorflow) we can expect
+-    # the users to know they are using them and choose an appropriate solver
+-    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
+-    if not isinstance(A.data, (_data.CSR, _data.Dense)):
+-        # Tensorflow, jax, etc. data type
+-        pass
+-    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
+-        A = A.to("dense")
+-    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
+-        A = A.to("csr")
+-    elif solver is None and kwargs.get("sparse", False):
+-        A = A.to("csr")
+-        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
+-    elif solver is None and (kwargs.get("sparse", None) is False):
+-        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
+-        A = A.to("dense")
+-        solver = "solve"
+-
+-    if method in ["direct", "iterative"]:
+-        # Remove unused kwargs, so only used and pass-through ones are included
+-        kwargs.pop("power_tol", 0)
+-        kwargs.pop("power_maxiter", 0)
+-        kwargs.pop("power_eps", 0)
+-        kwargs.pop("sparse", 0)
+-        return _steadystate_direct(A, kwargs.pop("weight", 0),
+-                                   method=solver, **kwargs)
+-
+-    elif method == "power":
+-        # Remove unused kwargs, so only used and pass-through ones are included
+-        kwargs.pop("weight", 0)
+-        kwargs.pop("sparse", 0)
+-        return _steadystate_power(A, method=solver, **kwargs)
+-    else:
+-        raise ValueError(f"method {method} not supported.")
+-
+-
+-def _steadystate_direct(A, weight, **kw):
+-    # Find the weight, no good dispatched function available...
+-    if weight:
+-        pass
+-    elif isinstance(A.data, _data.CSR):
+-        weight = np.mean(np.abs(A.data.as_scipy().data))
+-    else:
+-        A_np = np.abs(A.full())
+-        weight = np.mean(A_np[A_np > 0])
+-
+-    # Add weight to the Liouvillian
+-    # A[:, 0] = vectorized(eye * weight)
+-    # We don't have a function to overwrite part of an array, so
+-    N = A.shape[0]
+-    n = int(N**0.5)
+-    dtype = type(A.data)
+-    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
+-    weight_mat = _data.kron(
+-        weight_vec.transpose(),
+-        _data.one_element[dtype]((N, 1), (0, 0), 1)
+-    )
+-    L = _data.add(weight_mat, A.data)
+-    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
+-
+-    # Permutation are part of scipy.sparse, thus only supported for CSR.
+-    if kw.pop("use_wbm", False):
+-        if isinstance(L, _data.CSR):
+-            L, b = _permute_wbm(L, b)
+-        else:
+-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+-    use_rcm = False
+-    if kw.pop("use_rcm", False):
+-        if isinstance(L, _data.CSR):
+-            L, b, perm = _permute_rcm(L, b)
+-            use_rcm = True
+-        else:
+-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+-    if kw.pop("use_precond", False):
+-        if isinstance(L, _data.CSR):
+-            kw["M"] = _compute_precond(L, kw)
+-        else:
+-            warn("Only sparse solver use preconditioners.", RuntimeWarning)
+-
+-
+-    method = kw.pop("method", None)
+-    steadystate = _data.solve(L, b, method, options=kw)
+-
+-    if use_rcm:
+-        steadystate = _reverse_rcm(steadystate, perm)
+-
+-    rho_ss = _data.column_unstack(steadystate, n)
+-    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
+-
+-    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
+-
+-
+-def _steadystate_eigen(L, **kw):
+-    val, vec = (L.dag() @ L).eigenstates(
+-        eigvals=1,
+-        sort="low",
+-        # v4's implementation only uses sparse eigen solver
+-        sparse=kw.pop("sparse", True)
+-    )
+-    rho = vector_to_operator(vec[0])
+-    return rho / rho.tr()
+-
+-
+-def _steadystate_svd(L, **kw):
+-    u, s, vh = _data.svd(L.data, True)
+-    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
+-    rho = vector_to_operator(vec)
+-    return rho / rho.tr()
+-
+-
+-def _steadystate_power(A, **kw):
+-    A += kw.pop("power_eps", 1e-15)
+-    L = A.data
+-    N = L.shape[1]
+-    y = _data.Dense([1]*N)
+-
+-    # Permutation are part of scipy.sparse, thus only supported for CSR.
+-    if kw.pop("use_wbm", False):
+-        if isinstance(L, _data.CSR):
+-            L, y = _permute_wbm(L, y)
+-        else:
+-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+-    use_rcm = False
+-    if kw.pop("use_rcm", False):
+-        if isinstance(L, _data.CSR):
+-            L, y, perm = _permute_rcm(L, y)
+-            use_rcm = True
+-        else:
+-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+-    if kw.pop("use_precond", False):
+-        if isinstance(L, _data.CSR):
+-            kw["M"] = _compute_precond(L, kw)
+-        else:
+-            warn("Only sparse solver use preconditioners.", RuntimeWarning)
+-
+-    it = 0
+-    maxiter = kw.pop("power_maxiter", 10)
+-    tol = kw.pop("power_tol", 1e-12)
+-    method = kw.pop("method", None)
+-    while it < maxiter and _data.norm.max(L @ y) > tol:
+-        y = _data.solve(L, y, method, options=kw)
+-        y = y / _data.norm.max(y)
+-        it += 1
+-
+-    if it >= maxiter:
+-        raise Exception('Failed to find steady state after ' +
+-                        str(maxiter) + ' iterations')
+-
+-    if use_rcm:
+-        y = _reverse_rcm(y, perm)
+-
+-    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
+-    rho_ss = rho_ss + rho_ss.dag()
+-    rho_ss = rho_ss / rho_ss.tr()
+-    rho_ss.isherm = True
+-    return rho_ss
+-
+-
+-def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
+-                        solver=None, **kwargs):
+-    """
+-    Calculates the effective steady state for a driven
+-     system with a time-dependent cosinusoidal term:
+-
+-    .. math::
+-
+-        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
+-         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
+-
+-    Parameters
+-    ----------
+-    H_0 : :obj:`~Qobj`
+-        A Hamiltonian or Liouvillian operator.
+-
+-    c_ops : list
+-        A list of collapse operators.
+-
+-    Op_t : :obj:`~Qobj`
+-        The the interaction operator which is multiplied by the cosine
+-
+-    w_d : float, default 1.0
+-        The frequency of the drive
+-
+-    n_it : int, default 3
+-        The number of iterations for the solver
+-
+-    sparse : bool, default False
+-        Solve for the steady state using sparse algorithms.
+-
+-    solver : str, default=None
+-        Solver to use when solving the linear system.
+-        Default supported solver are:
+-
+-        - "solve", "lstsq"
+-          dense solver from numpy.linalg
+-        - "spsolve", "gmres", "lgmres", "bicgstab"
+-          sparse solver from scipy.sparse.linalg
+-        - "mkl_spsolve"
+-          sparse solver by mkl.
+-
+-        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
+-        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
+-        for the names and details of additional solvers they may provide.
+-
+-    **kwargs:
+-        Extra options to pass to the linear system solver. See the
+-        documentation of the used solver in ``numpy.linalg`` or
+-        ``scipy.sparse.linalg`` to see what extra arguments are supported.
+-
+-    Returns
+-    -------
+-    dm : qobj
+-        Steady state density matrix.
+-
+-    .. note::
+-
+-        See: Sze Meng Tan,
+-        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
+-        Section (10.16)
+-
+-    """
+-
+-    L_0 = liouvillian(H_0, c_ops)
+-    L_m = L_p = 0.5 * liouvillian(Op_t)
+-    # L_p and L_m correspond to the positive and negative
+-    # frequency terms respectively.
+-    # They are independent in the model, so we keep both names.
+-    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
+-    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
+-
+-    if isinstance(H_0.data, _data.CSR) and not sparse:
+-        L_0 = L_0.to("Dense")
+-        L_m = L_m.to("Dense")
+-        L_p = L_p.to("Dense")
+-        Id = Id.to("Dense")
+-
+-    for n_i in np.arange(n_it, 0, -1):
+-        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
+-        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
+-        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
+-        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
+-
+-    M_subs = L_0 + L_m @ S + L_p @ T
+-    return steadystate(M_subs, solver=solver, **kwargs)
+-
+-
+-def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
+-                   **kwargs):
+-    """
+-    Compute the pseudo inverse for a Liouvillian superoperator, optionally
+-    given its steady state density matrix (which will be computed if not
+-    given).
+-
+-    Parameters
+-    ----------
+-    L : Qobj
+-        A Liouvillian superoperator for which to compute the pseudo inverse.
+-
+-    rhoss : Qobj
+-        A steadystate density matrix as Qobj instance, for the Liouvillian
+-        superoperator L.
+-
+-    w : double
+-        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
+-        systems and large sparse systems. Small sparse systems can fail for
+-        zero frequencies.
+-
+-    sparse : bool
+-        Flag that indicate whether to use sparse or dense matrix methods when
+-        computing the pseudo inverse.
+-
+-    method : string
+-        Method used to compte matrix inverse.
+-        Choice are 'pinv' to use scipy's function of the same name, or a linear
+-        system solver.
+-        Default supported solver are:
+-
+-        - "solve", "lstsq"
+-          dense solver from numpy.linalg
+-        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
+-          sparse solver from scipy.sparse.linalg
+-        - "mkl_spsolve",
+-          sparse solver by mkl.
+-
+-        Extension to qutip, such as qutip-tensorflow, can use come with their
+-        own solver. When ``L`` use these data backends, see the corresponding
+-        libraries ``linalg`` for available solver.
+-
+-    kwargs : dictionary
+-        Additional keyword arguments for setting parameters for solver methods.
+-
+-    Returns
+-    -------
+-    R : Qobj
+-        Returns a Qobj instance representing the pseudo inverse of L.
+-
+-    .. note::
+-
+-        In general the inverse of a sparse matrix will be dense.  If you
+-        are applying the inverse to a density matrix then it is better to
+-        cast the problem as an Ax=b type problem where the explicit calculation
+-        of the inverse is not required. See page 67 of "Electrons in
+-        nanostructures" C. Flindt, PhD Thesis available online:
+-        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
+-        file_4732600/content
+-
+-        Note also that the definition of the pseudo-inverse herein is different
+-        from numpys pinv() alone, as it includes pre and post projection onto
+-        the subspace defined by the projector Q.
+-
+-    """
+-    if rhoss is None:
+-        rhoss = steadystate(L)
+-
+-    sparse = kwargs.pop("sparse", False)
+-    if method == "direct":
+-        method = "splu" if sparse else "pinv"
+-    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
+-    dense_solvers = ["solve", "lstsq", "pinv"]
+-    if isinstance(L.data, _data.CSR) and method in dense_solvers:
+-        L = L.to("dense")
+-    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
+-        L = L.to("csr")
+-
+-    N = np.prod(L.dims[0][0])
+-    dtype = type(L.data)
+-    rhoss_vec = operator_to_vector(rhoss)
+-
+-    tr_op = qeye(L.dims[0][0])
+-    tr_op_vec = operator_to_vector(tr_op)
+-
+-    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
+-    I = _data.csr.identity(N * N)
+-    Q = _data.sub(I, P)
+-
+-    if w in [None, 0.0]:
+-        L += 1e-15j
+-    else:
+-        L += 1.0j*w
+-
+-    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
+-
+-    if use_rcm:
+-        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
+-        A = _data.permute.indices(L.data, perm, perm)
+-        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
+-    else:
+-        A = L.data
+-
+-    if method in ["pinv", "numpy", "scipy", "scipy2"]:
+-        # from scipy 1.7.0, they all use the same algorithm.
+-        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
+-        LIQ = _data.matmul(LI, Q)
+-    elif method == "spilu":
+-        if not isinstance(A, _data.CSR):
+-            raise TypeError("'spilu' method can only be used with sparse data")
+-        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
+-        LIQ = _data.Dense(ILU.solve(Q.to_array()))
+-    else:
+-        LIQ = _data.solve(A, Q, method, options=kwargs)
+-
+-    R = _data.matmul(Q, LIQ)
+-
+-    if use_rcm:
+-        rev_perm = np.argsort(perm)
+-        R = _data.permute.indices(R, rev_perm, rev_perm)
+-
+-    return Qobj(R, dims=L.dims)
+-
+-
+-def _compute_precond(L, args):
+-    spilu_keys = {
+-        'permc_spec',
+-        'drop_tol',
+-        'diag_pivot_thresh',
+-        'fill_factor',
+-        'options',
+-    }
+-    ss_args = {
+-        key: args.pop(key)
+-        for key in spilu_keys
+-        if key in args
+-    }
+-    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
+-    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
++from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
++from qutip import vector_to_operator, operator_to_vector
++from qutip import settings
++import qutip.core.data as _data
++import numpy as np
++import scipy.sparse.csgraph
++import scipy.sparse.linalg
++from warnings import warn
++
++
++__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
++
++
++def _permute_wbm(L, b):
++    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
++    L = _data.permute.indices(L, perm, None)
++    b = _data.permute.indices(b, perm, None)
++    return L, b
++
++
++def _permute_rcm(L, b):
++    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
++    L = _data.permute.indices(L, perm, perm)
++    b = _data.permute.indices(b, perm, None)
++    return L, b, perm
++
++
++def _reverse_rcm(rho, perm):
++    rev_perm = np.argsort(perm)
++    rho = _data.permute.indices(rho, rev_perm, None)
++    return rho
++
++
++def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
++    """
++    Calculates the steady state for quantum evolution subject to the supplied
++    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
++    collapse operators.
++
++    If the user passes a Hamiltonian then it, along with the list of collapse
++    operators, will be converted into a Liouvillian operator in Lindblad form.
++
++    Parameters
++    ----------
++    A : :obj:`~Qobj`
++        A Hamiltonian or Liouvillian operator.
++
++    c_op_list : list
++        A list of collapse operators.
++
++    method : str, default='direct'
++        The allowed methods are composed of 2 parts, the steadystate method:
++        - "direct": Solving ``L(rho_ss) = 0``
++        - "eigen" : Eigenvalue problem
++        - "svd" : Singular value decomposition
++        - "power" : Inverse-power method
++
++    solver : str, default=None
++        'direct' and 'power' methods only.
++        Solver to use when solving the ``L(rho_ss) = 0`` equation.
++        Default supported solver are:
++
++        - "solve", "lstsq"
++          dense solver from numpy.linalg
++        - "spsolve", "gmres", "lgmres", "bicgstab"
++          sparse solver from scipy.sparse.linalg
++        - "mkl_spsolve"
++          sparse solver by mkl.
++
++        Extension to qutip, such as qutip-tensorflow, can use come with their
++        own solver. When ``A`` and ``c_ops`` use these data backends, see the
++        corresponding libraries ``linalg`` for available solver.
++
++        Extra options for these solver can be passed in ``**kw``.
++
++    use_rcm : bool, default False
++        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
++        factorization of the Liouvillian.
++        Used with 'direct' or 'power' method.
++
++    use_wbm : bool, default False
++        Use Weighted Bipartite Matching reordering to make the Liouvillian
++        diagonally dominant.  This is useful for iterative preconditioners
++        only. Used with 'direct' or 'power' method.
++
++    weight : float, optional
++        Sets the size of the elements used for adding the unity trace condition
++        to the linear solvers.  This is set to the average abs value of the
++        Liouvillian elements if not specified by the user.
++        Used with 'direct' method.
++
++    power_tol : float, default 1e-12
++        Tolerance for the solution when using the 'power' method.
++
++    power_maxiter : int, default 10
++        Maximum number of iteration to use when looking for a solution when
++        using the 'power' method.
++
++    power_eps: double, default 1e-15
++        Small weight used in the "power" method.
++
++    sparse: bool
++        Whether to use the sparse eigen solver with the "eigen" method
++        (default sparse).  With "direct" and "power" method, when the solver is
++        not specified, it is used to set whether "solve" or "spsolve" is
++        used as default solver.
++
++    **kwargs :
++        Extra options to pass to the linear system solver. See the
++        documentation of the used solver in ``numpy.linalg`` or
++        ``scipy.sparse.linalg`` to see what extra arguments are supported.
++
++    Returns
++    -------
++    dm : qobj
++        Steady state density matrix.
++    info : dict, optional
++        Dictionary containing solver-specific information about the solution.
++
++    .. note::
++
++        The SVD method works only for dense operators (i.e. small systems).
++
++    """
++    if not A.issuper and not c_ops:
++        raise TypeError('Cannot calculate the steady state for a ' +
++                        'non-dissipative system.')
++    if not A.issuper:
++        A = liouvillian(A)
++    for op in c_ops:
++        A += lindblad_dissipator(op)
++
++    if "-" in method:
++        # to support v4's "power-gmres" method
++        method, solver = method.split("-")
++
++    if solver == "mkl":
++        solver = "mkl_spsolve"
++
++    # Keys supported in v4, but removed in v5
++    if kwargs.pop("return_info", False):
++        warn("Steadystate no longer supports return_info", DeprecationWarning)
++    if "mtol" in kwargs and "power_tol" not in kwargs:
++        kwargs["power_tol"] = kwargs["mtol"]
++    kwargs.pop("mtol", None)
++
++    if method == "eigen":
++        return _steadystate_eigen(A, **kwargs)
++    if method == "svd":
++        return _steadystate_svd(A, **kwargs)
++
++    # We want to be able to use this without having to know what data type the
++    # liouvillian uses. For extra data types (tensorflow) we can expect
++    # the users to know they are using them and choose an appropriate solver
++    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
++    if not isinstance(A.data, (_data.CSR, _data.Dense)):
++        # Tensorflow, jax, etc. data type
++        pass
++    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
++        A = A.to("dense")
++    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
++        A = A.to("csr")
++    elif solver is None and kwargs.get("sparse", False):
++        A = A.to("csr")
++        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
++    elif solver is None and (kwargs.get("sparse", None) is False):
++        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
++        A = A.to("dense")
++        solver = "solve"
++
++    if method in ["direct", "iterative"]:
++        # Remove unused kwargs, so only used and pass-through ones are included
++        kwargs.pop("power_tol", 0)
++        kwargs.pop("power_maxiter", 0)
++        kwargs.pop("power_eps", 0)
++        kwargs.pop("sparse", 0)
++        return _steadystate_direct(A, kwargs.pop("weight", 0),
++                                   method=solver, **kwargs)
++
++    elif method == "power":
++        # Remove unused kwargs, so only used and pass-through ones are included
++        kwargs.pop("weight", 0)
++        kwargs.pop("sparse", 0)
++        return _steadystate_power(A, method=solver, **kwargs)
++    else:
++        raise ValueError(f"method {method} not supported.")
++
++
++def _steadystate_direct(A, weight, **kw):
++    # Find the weight, no good dispatched function available...
++    if weight:
++        pass
++    elif isinstance(A.data, _data.CSR):
++        weight = np.mean(np.abs(A.data.as_scipy().data))
++    else:
++        A_np = np.abs(A.full())
++        weight = np.mean(A_np[A_np > 0])
++
++    # Add weight to the Liouvillian
++    # A[:, 0] = vectorized(eye * weight)
++    # We don't have a function to overwrite part of an array, so
++    N = A.shape[0]
++    n = int(N**0.5)
++    dtype = type(A.data)
++    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
++    weight_mat = _data.kron(
++        weight_vec.transpose(),
++        _data.one_element[dtype]((N, 1), (0, 0), 1)
++    )
++    L = _data.add(weight_mat, A.data)
++    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
++
++    # Permutation are part of scipy.sparse, thus only supported for CSR.
++    if kw.pop("use_wbm", False):
++        if isinstance(L, _data.CSR):
++            L, b = _permute_wbm(L, b)
++        else:
++            warn("Only sparse matrice can be permuted.", RuntimeWarning)
++    use_rcm = False
++    if kw.pop("use_rcm", False):
++        if isinstance(L, _data.CSR):
++            L, b, perm = _permute_rcm(L, b)
++            use_rcm = True
++        else:
++            warn("Only sparse matrice can be permuted.", RuntimeWarning)
++    if kw.pop("use_precond", False):
++        if isinstance(L, _data.CSR):
++            kw["M"] = _compute_precond(L, kw)
++        else:
++            warn("Only sparse solver use preconditioners.", RuntimeWarning)
++
++
++    method = kw.pop("method", None)
++    steadystate = _data.solve(L, b, method, options=kw)
++
++    if use_rcm:
++        steadystate = _reverse_rcm(steadystate, perm)
++
++    rho_ss = _data.column_unstack(steadystate, n)
++    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
++
++    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
++
++
++def _steadystate_eigen(L, **kw):
++    val, vec = (L.dag() @ L).eigenstates(
++        eigvals=1,
++        sort="low",
++        # v4's implementation only uses sparse eigen solver
++        sparse=kw.pop("sparse", True)
++    )
++    rho = vector_to_operator(vec[0])
++    return rho / rho.tr()
++
++
++def _steadystate_svd(L, **kw):
++    u, s, vh = _data.svd(L.data, True)
++    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
++    rho = vector_to_operator(vec)
++    return rho / rho.tr()
++
++
++def _steadystate_power(A, **kw):
++    A += kw.pop("power_eps", 1e-15)
++    L = A.data
++    N = L.shape[1]
++    y = _data.Dense([1]*N)
++
++    # Permutation are part of scipy.sparse, thus only supported for CSR.
++    if kw.pop("use_wbm", False):
++        if isinstance(L, _data.CSR):
++            L, y = _permute_wbm(L, y)
++        else:
++            warn("Only sparse matrice can be permuted.", RuntimeWarning)
++    use_rcm = False
++    if kw.pop("use_rcm", False):
++        if isinstance(L, _data.CSR):
++            L, y, perm = _permute_rcm(L, y)
++            use_rcm = True
++        else:
++            warn("Only sparse matrice can be permuted.", RuntimeWarning)
++    if kw.pop("use_precond", False):
++        if isinstance(L, _data.CSR):
++            kw["M"] = _compute_precond(L, kw)
++        else:
++            warn("Only sparse solver use preconditioners.", RuntimeWarning)
++
++    it = 0
++    maxiter = kw.pop("power_maxiter", 10)
++    tol = kw.pop("power_tol", 1e-12)
++    method = kw.pop("method", None)
++    while it < maxiter and _data.norm.max(L @ y) > tol:
++        y = _data.solve(L, y, method, options=kw)
++        y = y / _data.norm.max(y)
++        it += 1
++
++    if it >= maxiter:
++        raise Exception('Failed to find steady state after ' +
++                        str(maxiter) + ' iterations')
++
++    if use_rcm:
++        y = _reverse_rcm(y, perm)
++
++    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
++    rho_ss = rho_ss + rho_ss.dag()
++    rho_ss = rho_ss / rho_ss.tr()
++    rho_ss.isherm = True
++    return rho_ss
++
++
++def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
++                        solver=None, **kwargs):
++    """
++    Calculates the effective steady state for a driven
++     system with a time-dependent cosinusoidal term:
++
++    .. math::
++
++        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
++         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
++
++    Parameters
++    ----------
++    H_0 : :obj:`~Qobj`
++        A Hamiltonian or Liouvillian operator.
++
++    c_ops : list
++        A list of collapse operators.
++
++    Op_t : :obj:`~Qobj`
++        The the interaction operator which is multiplied by the cosine
++
++    w_d : float, default 1.0
++        The frequency of the drive
++
++    n_it : int, default 3
++        The number of iterations for the solver
++
++    sparse : bool, default False
++        Solve for the steady state using sparse algorithms.
++
++    solver : str, default=None
++        Solver to use when solving the linear system.
++        Default supported solver are:
++
++        - "solve", "lstsq"
++          dense solver from numpy.linalg
++        - "spsolve", "gmres", "lgmres", "bicgstab"
++          sparse solver from scipy.sparse.linalg
++        - "mkl_spsolve"
++          sparse solver by mkl.
++
++        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
++        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
++        for the names and details of additional solvers they may provide.
++
++    **kwargs:
++        Extra options to pass to the linear system solver. See the
++        documentation of the used solver in ``numpy.linalg`` or
++        ``scipy.sparse.linalg`` to see what extra arguments are supported.
++
++    Returns
++    -------
++    dm : qobj
++        Steady state density matrix.
++
++    .. note::
++
++        See: Sze Meng Tan,
++        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
++        Section (10.16)
++
++    """
++
++    L_0 = liouvillian(H_0, c_ops)
++    L_m = L_p = 0.5 * liouvillian(Op_t)
++    # L_p and L_m correspond to the positive and negative
++    # frequency terms respectively.
++    # They are independent in the model, so we keep both names.
++    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
++    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
++
++    if isinstance(H_0.data, _data.CSR) and not sparse:
++        L_0 = L_0.to("Dense")
++        L_m = L_m.to("Dense")
++        L_p = L_p.to("Dense")
++        Id = Id.to("Dense")
++
++    for n_i in np.arange(n_it, 0, -1):
++        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
++        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
++        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
++        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
++
++    M_subs = L_0 + L_m @ S + L_p @ T
++    return steadystate(M_subs, solver=solver, **kwargs)
++
++
++def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
++                   **kwargs):
++    """
++    Compute the pseudo inverse for a Liouvillian superoperator, optionally
++    given its steady state density matrix (which will be computed if not
++    given).
++
++    Parameters
++    ----------
++    L : Qobj
++        A Liouvillian superoperator for which to compute the pseudo inverse.
++
++    rhoss : Qobj
++        A steadystate density matrix as Qobj instance, for the Liouvillian
++        superoperator L.
++
++    w : double
++        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
++        systems and large sparse systems. Small sparse systems can fail for
++        zero frequencies.
++
++    sparse : bool
++        Flag that indicate whether to use sparse or dense matrix methods when
++        computing the pseudo inverse.
++
++    method : string
++        Method used to compte matrix inverse.
++        Choice are 'pinv' to use scipy's function of the same name, or a linear
++        system solver.
++        Default supported solver are:
++
++        - "solve", "lstsq"
++          dense solver from numpy.linalg
++        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
++          sparse solver from scipy.sparse.linalg
++        - "mkl_spsolve",
++          sparse solver by mkl.
++
++        Extension to qutip, such as qutip-tensorflow, can use come with their
++        own solver. When ``L`` use these data backends, see the corresponding
++        libraries ``linalg`` for available solver.
++
++    kwargs : dictionary
++        Additional keyword arguments for setting parameters for solver methods.
++
++    Returns
++    -------
++    R : Qobj
++        Returns a Qobj instance representing the pseudo inverse of L.
++
++    .. note::
++
++        In general the inverse of a sparse matrix will be dense.  If you
++        are applying the inverse to a density matrix then it is better to
++        cast the problem as an Ax=b type problem where the explicit calculation
++        of the inverse is not required. See page 67 of "Electrons in
++        nanostructures" C. Flindt, PhD Thesis available online:
++        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
++        file_4732600/content
++
++        Note also that the definition of the pseudo-inverse herein is different
++        from numpys pinv() alone, as it includes pre and post projection onto
++        the subspace defined by the projector Q.
++
++    """
++    if rhoss is None:
++        rhoss = steadystate(L)
++
++    sparse = kwargs.pop("sparse", False)
++    if method == "direct":
++        method = "splu" if sparse else "pinv"
++    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
++    dense_solvers = ["solve", "lstsq", "pinv"]
++    if isinstance(L.data, _data.CSR) and method in dense_solvers:
++        L = L.to("dense")
++    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
++        L = L.to("csr")
++
++    N = np.prod(L.dims[0][0])
++    dtype = type(L.data)
++    rhoss_vec = operator_to_vector(rhoss)
++
++    tr_op = qeye(L.dims[0][0])
++    tr_op_vec = operator_to_vector(tr_op)
++
++    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
++    I = _data.csr.identity(N * N)
++    Q = _data.sub(I, P)
++
++    if w in [None, 0.0]:
++        L += 1e-15j
++    else:
++        L += 1.0j*w
++
++    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
++
++    if use_rcm:
++        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
++        A = _data.permute.indices(L.data, perm, perm)
++        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
++    else:
++        A = L.data
++
++    if method in ["pinv", "numpy", "scipy", "scipy2"]:
++        # from scipy 1.7.0, they all use the same algorithm.
++        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
++        LIQ = _data.matmul(LI, Q)
++    elif method == "spilu":
++        if not isinstance(A, _data.CSR):
++            raise TypeError("'spilu' method can only be used with sparse data")
++        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
++        LIQ = _data.Dense(ILU.solve(Q.to_array()))
++    else:
++        LIQ = _data.solve(A, Q, method, options=kwargs)
++
++    R = _data.matmul(Q, LIQ)
++
++    if use_rcm:
++        rev_perm = np.argsort(perm)
++        R = _data.permute.indices(R, rev_perm, rev_perm)
++
++    return Qobj(R, dims=L.dims)
++
++
++def _compute_precond(L, args):
++    spilu_keys = {
++        'permc_spec',
++        'drop_tol',
++        'diag_pivot_thresh',
++        'fill_factor',
++        'options',
++    }
++    ss_args = {
++        key: args.pop(key)
++        for key in spilu_keys
++        if key in args
++    }
++    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
++    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
+diff --git a/qutip/testing.py b/qutip/testing.py
+index 60eb677f..fc2d3768 100644
+--- a/qutip/testing.py
++++ b/qutip/testing.py
+@@ -1,34 +1,34 @@
+-from .about import about
+-from .settings import settings as qset
+-
+-def run(full=False):
+-    """
+-    Run the test scripts for QuTiP.
+-
+-    Parameters
+-    ----------
+-    full: bool
+-        If True run all test (30 min). Otherwise skip few variants of the
+-        slowest tests.
+-    """
+-    # Call about to get all version info printed with tests
+-    about()
+-    import pytest
+-    # real_num_cpu = qset.num_cpus
+-    # real_thresh = qset.openmp_thresh
+-    # if qset.has_openmp:
+-        # For travis which VMs have only 1 cpu.
+-        # Make sure the openmp version of the functions are tested.
+-    #     qset.num_cpus = 2
+-    #     qset.openmp_thresh = 100
+-
+-    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
+-    if not full:
+-        test_options += ['-m', 'not slow']
+-    pytest.main(test_options + ["qutip"])
+-    # runs tests in qutip.tests module only
+-
+-    # Restore previous settings
+-    # if qset.has_openmp:
+-    #     qset.num_cpus = real_num_cpu
+-    #     qset.openmp_thresh = real_thresh
++from .about import about
++from .settings import settings as qset
++
++def run(full=False):
++    """
++    Run the test scripts for QuTiP.
++
++    Parameters
++    ----------
++    full: bool
++        If True run all test (30 min). Otherwise skip few variants of the
++        slowest tests.
++    """
++    # Call about to get all version info printed with tests
++    about()
++    import pytest
++    # real_num_cpu = qset.num_cpus
++    # real_thresh = qset.openmp_thresh
++    # if qset.has_openmp:
++        # For travis which VMs have only 1 cpu.
++        # Make sure the openmp version of the functions are tested.
++    #     qset.num_cpus = 2
++    #     qset.openmp_thresh = 100
++
++    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
++    if not full:
++        test_options += ['-m', 'not slow']
++    pytest.main(test_options + ["qutip"])
++    # runs tests in qutip.tests module only
++
++    # Restore previous settings
++    # if qset.has_openmp:
++    #     qset.num_cpus = real_num_cpu
++    #     qset.openmp_thresh = real_thresh
+diff --git a/qutip/tests/Hadamard_params.ini b/qutip/tests/Hadamard_params.ini
+index 60dc840f..8d4ea5ab 100644
+--- a/qutip/tests/Hadamard_params.ini
++++ b/qutip/tests/Hadamard_params.ini
+@@ -1,19 +1,19 @@
+-[optimconfig]
+-optim_method=FMIN_L_BFGS_B
+-pulse_type = LIN
+-
+-[dynamics]
+-evo_time = 6
+-num_tslots = 6
+-
+-[termconds]
+-fid_err_targ = 1e-10
+-
+-[optimizer]
+-amp_lbound = -1.0
+-amp_ubound = 1.0
+-
+-[pulsegen]
+-scaling = 1.0
+-lbound = -1.0
+-ubound = 1.0
++[optimconfig]
++optim_method=FMIN_L_BFGS_B
++pulse_type = LIN
++
++[dynamics]
++evo_time = 6
++num_tslots = 6
++
++[termconds]
++fid_err_targ = 1e-10
++
++[optimizer]
++amp_lbound = -1.0
++amp_ubound = 1.0
++
++[pulsegen]
++scaling = 1.0
++lbound = -1.0
++ubound = 1.0
+diff --git a/qutip/tests/conftest.py b/qutip/tests/conftest.py
+index 49d4add0..71c90d86 100644
+--- a/qutip/tests/conftest.py
++++ b/qutip/tests/conftest.py
+@@ -1,158 +1,158 @@
+-import pytest
+-import functools
+-import os
+-import tempfile
+-import numpy as np
+-
+-
+-def _add_repeats_if_marked(metafunc):
+-    """
+-    If the metafunc is marked with the 'repeat' mark, then add the requisite
+-    number of repeats via parametrisation.
+-    """
+-    marker = metafunc.definition.get_closest_marker('repeat')
+-    if marker:
+-        count = marker.args[0]
+-        metafunc.fixturenames.append('_repeat_count')
+-        metafunc.parametrize('_repeat_count',
+-                             range(count),
+-                             ids=["rep({})".format(x+1) for x in range(count)])
+-
+-
+-def _skip_cython_tests_if_unavailable(item):
+-    """
+-    Skip the current test item if Cython is unavailable for import, or isn't a
+-    high enough version.
+-    """
+-    if item.get_closest_marker("requires_cython"):
+-        # importorskip rather than mark.skipif because this way we get pytest's
+-        # version-handling semantics.
+-        pytest.importorskip('Cython', minversion='0.14')
+-
+-
+-@pytest.hookimpl(trylast=True)
+-def pytest_generate_tests(metafunc):
+-    _add_repeats_if_marked(metafunc)
+-
+-
+-def pytest_runtest_setup(item):
+-    _skip_cython_tests_if_unavailable(item)
+-
+-
+-def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
+-                           verbose=True, names=('ACTUAL', 'DESIRED'),
+-                           precision=8):
+-    """
+-    Taken almost verbatim from `np.testing._private.utils`, except this version
+-    doesn't truncate output if it's longer than three lines.
+-
+-    LICENCE
+-    -------
+-    Copyright (c) 2005-2020, NumPy Developers.
+-    All rights reserved.
+-
+-    Redistribution and use in source and binary forms, with or without
+-    modification, are permitted provided that the following conditions are met:
+-
+-    - Redistributions of source code must retain the above copyright notice,
+-      this list of conditions and the following disclaimer.
+-
+-    - Redistributions in binary form must reproduce the above copyright notice,
+-      this list of conditions and the following disclaimer in the documentation
+-      and/or other materials provided with the distribution.
+-
+-    - Neither the name of the NumPy Developers nor the names of any
+-      contributors may be used to endorse or promote products derived from this
+-      software without specific prior written permission.
+-
+-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
+-    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+-    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+-    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+-    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+-    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+-    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+-    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+-    POSSIBILITY OF SUCH DAMAGE.
+-    """
+-    msg = ['\n' + header]
+-    if err_msg:
+-        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
+-            msg = [msg[0] + ' ' + err_msg]
+-        else:
+-            msg.append(err_msg)
+-    if verbose:
+-        for i, a in enumerate(arrays):
+-            if isinstance(a, np.ndarray):
+-                # precision argument is only needed if the objects are ndarrays
+-                r_func = functools.partial(np.core.array_repr,
+-                                           precision=precision)
+-            else:
+-                r_func = repr
+-
+-            try:
+-                # [diff] Remove truncation threshold from array output.
+-                with np.printoptions(threshold=np.inf):
+-                    r = r_func(a)
+-            except Exception as exc:
+-                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
+-            # [diff] The original truncates the output to 3 lines here.
+-            msg.append(' %s: %s' % (names[i], r))
+-    return '\n'.join(msg)
+-
+-
+-# Find the private module used by numpy to store its testing utility functions
+-# so that we can monkeypatch the error messages to be more verbose.  QuTiP
+-# supports numpy from 1.12 upwards, so we have to search.
+-_numpy_private_utils_paths = [
+-    ['_private', 'utils'],    # 1.15.0 <= x
+-    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
+-    ['utils'],                # 1.14.0 > x
+-]
+-for possible_path in _numpy_private_utils_paths:
+-    try:
+-        module = np.testing
+-        for submodule in possible_path:
+-            module = getattr(module, submodule)
+-        _numpy_private_utils = module
+-        break
+-    except NameError:
+-        pass
+-else:
+-    # If we can't locate it for some reason, then we don't attempt to patch.
+-    _numpy_private_utils = None
+-
+-if _numpy_private_utils is not None:
+-    @pytest.fixture(autouse=True)
+-    def do_not_truncate_numpy_output(monkeypatch):
+-        """
+-        Monkeypatch the internal numpy function used for printing arrays so
+-        that we get full output that isn't cut off after three lines.
+-        """
+-        with monkeypatch.context() as patch:
+-            patch.setattr(np.testing._private.utils, "build_err_msg",
+-                          _patched_build_err_msg)
+-            # Yield inside context manager just to minimize the amount of time
+-            # we've monkeypatched such a core library (and a private function!)
+-            yield
+-
+-
+-@pytest.fixture
+-def in_temporary_directory():
+-    """
+-    Creates a temporary directory for the lifetime of the fixture and changes
+-    into it.  All relative paths used will be in the temporary directory, and
+-    everything will automatically be cleaned up at the end of the fixture's
+-    life.
+-    """
+-    previous_dir = os.getcwd()
+-    with tempfile.TemporaryDirectory() as temporary_dir:
+-        os.chdir(temporary_dir)
+-        yield
+-        # pytest should catch exceptions occuring in functions using the
+-        # fixture, so this should always be called.  We want it here rather
+-        # than outside to prevent the case of the directory failing to be
+-        # removed because it is 'busy'.
+-        os.chdir(previous_dir)
++import pytest
++import functools
++import os
++import tempfile
++import numpy as np
++
++
++def _add_repeats_if_marked(metafunc):
++    """
++    If the metafunc is marked with the 'repeat' mark, then add the requisite
++    number of repeats via parametrisation.
++    """
++    marker = metafunc.definition.get_closest_marker('repeat')
++    if marker:
++        count = marker.args[0]
++        metafunc.fixturenames.append('_repeat_count')
++        metafunc.parametrize('_repeat_count',
++                             range(count),
++                             ids=["rep({})".format(x+1) for x in range(count)])
++
++
++def _skip_cython_tests_if_unavailable(item):
++    """
++    Skip the current test item if Cython is unavailable for import, or isn't a
++    high enough version.
++    """
++    if item.get_closest_marker("requires_cython"):
++        # importorskip rather than mark.skipif because this way we get pytest's
++        # version-handling semantics.
++        pytest.importorskip('Cython', minversion='0.14')
++
++
++@pytest.hookimpl(trylast=True)
++def pytest_generate_tests(metafunc):
++    _add_repeats_if_marked(metafunc)
++
++
++def pytest_runtest_setup(item):
++    _skip_cython_tests_if_unavailable(item)
++
++
++def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
++                           verbose=True, names=('ACTUAL', 'DESIRED'),
++                           precision=8):
++    """
++    Taken almost verbatim from `np.testing._private.utils`, except this version
++    doesn't truncate output if it's longer than three lines.
++
++    LICENCE
++    -------
++    Copyright (c) 2005-2020, NumPy Developers.
++    All rights reserved.
++
++    Redistribution and use in source and binary forms, with or without
++    modification, are permitted provided that the following conditions are met:
++
++    - Redistributions of source code must retain the above copyright notice,
++      this list of conditions and the following disclaimer.
++
++    - Redistributions in binary form must reproduce the above copyright notice,
++      this list of conditions and the following disclaimer in the documentation
++      and/or other materials provided with the distribution.
++
++    - Neither the name of the NumPy Developers nor the names of any
++      contributors may be used to endorse or promote products derived from this
++      software without specific prior written permission.
++
++    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
++    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++    POSSIBILITY OF SUCH DAMAGE.
++    """
++    msg = ['\n' + header]
++    if err_msg:
++        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
++            msg = [msg[0] + ' ' + err_msg]
++        else:
++            msg.append(err_msg)
++    if verbose:
++        for i, a in enumerate(arrays):
++            if isinstance(a, np.ndarray):
++                # precision argument is only needed if the objects are ndarrays
++                r_func = functools.partial(np.core.array_repr,
++                                           precision=precision)
++            else:
++                r_func = repr
++
++            try:
++                # [diff] Remove truncation threshold from array output.
++                with np.printoptions(threshold=np.inf):
++                    r = r_func(a)
++            except Exception as exc:
++                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
++            # [diff] The original truncates the output to 3 lines here.
++            msg.append(' %s: %s' % (names[i], r))
++    return '\n'.join(msg)
++
++
++# Find the private module used by numpy to store its testing utility functions
++# so that we can monkeypatch the error messages to be more verbose.  QuTiP
++# supports numpy from 1.12 upwards, so we have to search.
++_numpy_private_utils_paths = [
++    ['_private', 'utils'],    # 1.15.0 <= x
++    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
++    ['utils'],                # 1.14.0 > x
++]
++for possible_path in _numpy_private_utils_paths:
++    try:
++        module = np.testing
++        for submodule in possible_path:
++            module = getattr(module, submodule)
++        _numpy_private_utils = module
++        break
++    except NameError:
++        pass
++else:
++    # If we can't locate it for some reason, then we don't attempt to patch.
++    _numpy_private_utils = None
++
++if _numpy_private_utils is not None:
++    @pytest.fixture(autouse=True)
++    def do_not_truncate_numpy_output(monkeypatch):
++        """
++        Monkeypatch the internal numpy function used for printing arrays so
++        that we get full output that isn't cut off after three lines.
++        """
++        with monkeypatch.context() as patch:
++            patch.setattr(np.testing._private.utils, "build_err_msg",
++                          _patched_build_err_msg)
++            # Yield inside context manager just to minimize the amount of time
++            # we've monkeypatched such a core library (and a private function!)
++            yield
++
++
++@pytest.fixture
++def in_temporary_directory():
++    """
++    Creates a temporary directory for the lifetime of the fixture and changes
++    into it.  All relative paths used will be in the temporary directory, and
++    everything will automatically be cleaned up at the end of the fixture's
++    life.
++    """
++    previous_dir = os.getcwd()
++    with tempfile.TemporaryDirectory() as temporary_dir:
++        os.chdir(temporary_dir)
++        yield
++        # pytest should catch exceptions occuring in functions using the
++        # fixture, so this should always be called.  We want it here rather
++        # than outside to prevent the case of the directory failing to be
++        # removed because it is 'busy'.
++        os.chdir(previous_dir)
+diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
+index 01d05c01..c46297b1 100644
+--- a/qutip/tests/core/data/conftest.py
++++ b/qutip/tests/core/data/conftest.py
+@@ -1,66 +1,66 @@
+-import numpy as np
+-import scipy.sparse
+-
+-import qutip
+-
+-
+-def shuffle_indices_scipy_csr(matrix):
+-    """
+-    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
+-    return a new array.  This should represent the same matrix, but in the less
+-    efficient, "unsorted" manner.  All mathematical operations should still
+-    work the same after this, but may be slower.
+-
+-    This is not guaranteed to change the order of the indices in every case.
+-    If there is at most one value per row, there is no unsorted order.  In
+-    general, we attempt to shuffle, and if this returns the same order as
+-    before, we just reverse it to ensure it's different.
+-    """
+-    out = matrix.copy()
+-    for row in range(out.shape[0]):
+-        ptr = (out.indptr[row], out.indptr[row + 1])
+-        if ptr[1] - ptr[0] > 1:
+-            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
+-            # If sorted, reverse it.
+-            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
+-            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
+-            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
+-    return out
+-
+-
+-def random_scipy_csr(shape, density, sorted_):
+-    """
+-    Generate a random scipy CSR matrix with the given shape, nnz density, and
+-    with indices that are either sorted or unsorted.  The nnz elements will
+-    always be at least one.
+-    """
+-    nnz = int(shape[0] * shape[1] * density) or 1
+-    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+-    rows = np.random.choice(np.arange(shape[0]), nnz)
+-    cols = np.random.choice(np.arange(shape[1]), nnz)
+-    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
+-    if not sorted_:
+-        shuffle_indices_scipy_csr(sci)
+-    return sci
+-
+-
+-def random_numpy_dense(shape, fortran):
+-    """Generate a random numpy dense matrix with the given shape."""
+-    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+-    if fortran:
+-        out = np.asfortranarray(out)
+-    return out
+-
+-
+-def random_csr(shape, density, sorted_):
+-    """
+-    Generate a random qutip CSR matrix with the given shape, nnz density, and
+-    with indices that are either sorted or unsorted.  The nnz elements will
+-    always be at least one (use data.csr.zeros otherwise).
+-    """
+-    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
+-
+-
+-def random_dense(shape, fortran):
+-    """Generate a random qutip Dense matrix of the given shape."""
+-    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
++import numpy as np
++import scipy.sparse
++
++import qutip
++
++
++def shuffle_indices_scipy_csr(matrix):
++    """
++    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
++    return a new array.  This should represent the same matrix, but in the less
++    efficient, "unsorted" manner.  All mathematical operations should still
++    work the same after this, but may be slower.
++
++    This is not guaranteed to change the order of the indices in every case.
++    If there is at most one value per row, there is no unsorted order.  In
++    general, we attempt to shuffle, and if this returns the same order as
++    before, we just reverse it to ensure it's different.
++    """
++    out = matrix.copy()
++    for row in range(out.shape[0]):
++        ptr = (out.indptr[row], out.indptr[row + 1])
++        if ptr[1] - ptr[0] > 1:
++            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
++            # If sorted, reverse it.
++            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
++            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
++            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
++    return out
++
++
++def random_scipy_csr(shape, density, sorted_):
++    """
++    Generate a random scipy CSR matrix with the given shape, nnz density, and
++    with indices that are either sorted or unsorted.  The nnz elements will
++    always be at least one.
++    """
++    nnz = int(shape[0] * shape[1] * density) or 1
++    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
++    rows = np.random.choice(np.arange(shape[0]), nnz)
++    cols = np.random.choice(np.arange(shape[1]), nnz)
++    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
++    if not sorted_:
++        shuffle_indices_scipy_csr(sci)
++    return sci
++
++
++def random_numpy_dense(shape, fortran):
++    """Generate a random numpy dense matrix with the given shape."""
++    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
++    if fortran:
++        out = np.asfortranarray(out)
++    return out
++
++
++def random_csr(shape, density, sorted_):
++    """
++    Generate a random qutip CSR matrix with the given shape, nnz density, and
++    with indices that are either sorted or unsorted.  The nnz elements will
++    always be at least one (use data.csr.zeros otherwise).
++    """
++    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
++
++
++def random_dense(shape, fortran):
++    """Generate a random qutip Dense matrix of the given shape."""
++    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
+diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
+index a7be4e6d..77cf03cc 100644
+--- a/qutip/tests/core/data/test_convert.py
++++ b/qutip/tests/core/data/test_convert.py
+@@ -1,78 +1,78 @@
+-import numpy as np
+-import pytest
+-from scipy import sparse
+-from qutip import data
+-
+-
+-def test_init_empty_data():
+-    shape = (3, 3)
+-    base_data = data.Data(shape)
+-    assert base_data.shape[0] == shape[0]
+-    assert base_data.shape[1] == shape[1]
+-
+-
+-@pytest.mark.parametrize(['base', 'dtype'], [
+-    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
+-    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
+-    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
+-                 id='array'),
+-    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
+-                 id='sparse'),
+-    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
+-    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
+-                 id='sparse'),
+-])
+-def test_create(base, dtype):
+-    # The test of exactitude is done in test_csr, test_dense.
+-    created = data.create(base)
+-    assert isinstance(created, dtype)
+-
+-
+-@pytest.mark.parametrize(['from_', 'base'], [
+-    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
+-    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
+-    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
+-    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
+-    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
+-    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
+-])
+-@pytest.mark.parametrize(['to_', 'dtype'], [
+-    pytest.param('dense', data.Dense, id='to Dense str'),
+-    pytest.param('Dense', data.Dense, id='to Dense STR'),
+-    pytest.param(data.Dense, data.Dense, id='to Dense type'),
+-    pytest.param('csr', data.CSR, id='to CSR str'),
+-    pytest.param('CSR', data.CSR, id='to CSR STR'),
+-    pytest.param(data.CSR, data.CSR, id='to CSR type'),
+-])
+-def test_converters(from_, base, to_, dtype):
+-    converter = data.to[to_, from_]
+-    assert isinstance(converter(base), dtype)
+-    converter = data.to[to_]
+-    assert isinstance(converter(base), dtype)
+-    assert isinstance(data.to(to_, base), dtype)
+-
+-
+-dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
+-dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
+-@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
+-                         ids=[str(dtype) for dtype in dtype_names])
+-def test_parse_error(input, type_):
+-    assert data.to.parse(input) is type_
+-
+-
+-@pytest.mark.parametrize(['input', 'error', 'msg'], [
+-    pytest.param(5, TypeError,
+-                  "Invalid dtype is neither a type nor a type name: 5",
+-                 id="wrong type"),
+-    pytest.param("__this_is_not_a_known_type_name__", ValueError,
+-                  "Type name is not known to the data-layer: "
+-                  "'__this_is_not_a_known_type_name__'",
+-                 id="not alias"),
+-    pytest.param(object, ValueError,
+-                  "Type is not a data-layer type: <class 'object'>",
+-                 id="not Data"),
+-])
+-def test_parse_error(input, error, msg):
+-    with pytest.raises(error) as exc:
+-        data.to.parse(input)
+-    assert str(exc.value) == msg
++import numpy as np
++import pytest
++from scipy import sparse
++from qutip import data
++
++
++def test_init_empty_data():
++    shape = (3, 3)
++    base_data = data.Data(shape)
++    assert base_data.shape[0] == shape[0]
++    assert base_data.shape[1] == shape[1]
++
++
++@pytest.mark.parametrize(['base', 'dtype'], [
++    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
++    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
++    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
++                 id='array'),
++    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
++                 id='sparse'),
++    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
++    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
++                 id='sparse'),
++])
++def test_create(base, dtype):
++    # The test of exactitude is done in test_csr, test_dense.
++    created = data.create(base)
++    assert isinstance(created, dtype)
++
++
++@pytest.mark.parametrize(['from_', 'base'], [
++    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
++    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
++    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
++    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
++    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
++    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
++])
++@pytest.mark.parametrize(['to_', 'dtype'], [
++    pytest.param('dense', data.Dense, id='to Dense str'),
++    pytest.param('Dense', data.Dense, id='to Dense STR'),
++    pytest.param(data.Dense, data.Dense, id='to Dense type'),
++    pytest.param('csr', data.CSR, id='to CSR str'),
++    pytest.param('CSR', data.CSR, id='to CSR STR'),
++    pytest.param(data.CSR, data.CSR, id='to CSR type'),
++])
++def test_converters(from_, base, to_, dtype):
++    converter = data.to[to_, from_]
++    assert isinstance(converter(base), dtype)
++    converter = data.to[to_]
++    assert isinstance(converter(base), dtype)
++    assert isinstance(data.to(to_, base), dtype)
++
++
++dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
++dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
++@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
++                         ids=[str(dtype) for dtype in dtype_names])
++def test_parse_error(input, type_):
++    assert data.to.parse(input) is type_
++
++
++@pytest.mark.parametrize(['input', 'error', 'msg'], [
++    pytest.param(5, TypeError,
++                  "Invalid dtype is neither a type nor a type name: 5",
++                 id="wrong type"),
++    pytest.param("__this_is_not_a_known_type_name__", ValueError,
++                  "Type name is not known to the data-layer: "
++                  "'__this_is_not_a_known_type_name__'",
++                 id="not alias"),
++    pytest.param(object, ValueError,
++                  "Type is not a data-layer type: <class 'object'>",
++                 id="not Data"),
++])
++def test_parse_error(input, error, msg):
++    with pytest.raises(error) as exc:
++        data.to.parse(input)
++    assert str(exc.value) == msg
+diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
+index 834c9feb..853c7622 100644
+--- a/qutip/tests/core/data/test_csr.py
++++ b/qutip/tests/core/data/test_csr.py
+@@ -1,454 +1,454 @@
+-import numpy as np
+-import scipy.sparse
+-import pytest
+-
+-from qutip.core import data
+-from qutip.core.data import csr
+-from qutip import qeye, CoreOptions
+-
+-from . import conftest
+-
+-# We only choose a small subset of dtypes to test so it isn't crazy.
+-_dtype_complex = ['complex128']
+-_dtype_float = ['float64']
+-_dtype_int = ['int32', 'int64']
+-_dtype_uint = ['uint32']
+-
+-
+-# Set up some fixtures for automatic parametrisation.
+-
+-@pytest.fixture(params=[
+-    pytest.param((1, 5), id='bra'),
+-    pytest.param((5, 1), id='ket'),
+-    pytest.param((5, 5), id='square'),
+-    pytest.param((2, 4), id='wide'),
+-    pytest.param((4, 2), id='tall'),
+-])
+-def shape(request): return request.param
+-
+-
+-@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
+-def density(request): return request.param
+-
+-
+-@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
+-def sorted_(request): return request.param
+-
+-
+-def _valid_scipy():
+-    """Arbitrary valid scipy CSR"""
+-    return conftest.random_scipy_csr((10, 10), 0.5, True)
+-
+-
+-def _valid_arg():
+-    """
+-    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
+-    """
+-    sci = _valid_scipy()
+-    return (sci.data, sci.indices, sci.indptr)
+-
+-
+-@pytest.fixture(scope='function')
+-def scipy_csr(shape, density, sorted_):
+-    return conftest.random_scipy_csr(shape, density, sorted_)
+-
+-
+-@pytest.fixture(scope='function')
+-def data_csr(shape, density, sorted_):
+-    return conftest.random_csr(shape, density, sorted_)
+-
+-
+-class TestClassMethods:
+-    def test_init_from_tuple(self, scipy_csr):
+-        """
+-        Test that __init__ does not throw when passed a 3-tuple.  Also tests
+-        the as_scipy() method succeeds.
+-        """
+-        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
+-        out = data.CSR(arg, shape=scipy_csr.shape)
+-        assert out.shape == scipy_csr.shape
+-        assert (out.as_scipy() - scipy_csr).nnz == 0
+-
+-    @pytest.mark.parametrize('d_type', (
+-        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
+-    ))
+-    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
+-    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
+-    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
+-        """
+-        Test that initialisation can use a variety of dtypes and converts into
+-        the correct type.
+-        """
+-        sci = _valid_scipy()
+-        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
+-        col_index = sci.indices.astype(c_type, casting='unsafe')
+-        row_index = sci.indptr.astype(r_type, casting='unsafe')
+-        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
+-                                            shape=sci.shape)
+-        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
+-        out_scipy = out.as_scipy()
+-        assert out.shape == scipy_csr.shape
+-        assert out_scipy.data.dtype == np.complex128
+-        assert (out_scipy - scipy_csr).nnz == 0
+-
+-    def test_init_from_scipy(self, scipy_csr):
+-        """Test that __init__ can accept a scipy CSR matrix."""
+-        out = data.CSR(scipy_csr)
+-        assert out.shape == scipy_csr.shape
+-        assert (out.as_scipy() - scipy_csr).nnz == 0
+-
+-    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+-        pytest.param((), {}, ValueError, id="arg 0 tuple"),
+-        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
+-        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
+-        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
+-        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
+-        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
+-                     id="scipy-shape 0 tuple"),
+-        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
+-                     id="scipy-shape 1 tuple"),
+-        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
+-                     id="scipy-shape None tuple"),
+-        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
+-                     id="scipy-shape list"),
+-        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
+-                     id="scipy-shape 3 tuple"),
+-        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
+-                     id="arg-shape 0 tuple"),
+-        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
+-                     id="arg-shape 1 tuple"),
+-        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
+-                     id="arg-shape None tuple"),
+-        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
+-                     id="arg-shape list"),
+-        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
+-                     id="arg-shape 3 tuple"),
+-        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
+-                     id="arg-negative shape"),
+-    ])
+-    def test_init_from_wrong_input(self, arg, kwargs, error):
+-        """
+-        Test that the __init__ method raises a suitable error when passed
+-        incorrectly formatted inputs.
+-
+-        This test also serves as a *partial* check that CSR safely handles
+-        deallocation in the presence of exceptions in its __init__ method.  If
+-        the tests segfault, it's quite likely that the memory management isn't
+-        being done correctly in the hand-off us setting our data buffers up and
+-        marking the numpy actually owns the data.
+-        """
+-        with pytest.raises(error):
+-            data.CSR(arg, **kwargs)
+-
+-    def test_copy_returns_a_correct_copy(self, data_csr):
+-        """
+-        Test that the copy() method produces an actual copy, and that the
+-        result represents the same matrix.
+-        """
+-        original = data_csr
+-        copy = data_csr.copy()
+-        assert original is not copy
+-        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
+-
+-    def test_as_scipy_returns_a_view(self, data_csr):
+-        """
+-        Test that modifying the views in the result of as_scipy() also modifies
+-        the underlying data structures.  This is important for allowing minor
+-        data modifications from within Python-space.
+-        """
+-        unmodified_copy = data_csr.copy()
+-        data_csr.as_scipy().data[0] += 1
+-        modified_copy = data_csr.copy()
+-        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
+-        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
+-
+-    def test_as_scipy_caches_result(self, data_csr):
+-        """
+-        Test that the as_scipy() method always returns the same view, even if
+-        called multiple times.
+-        """
+-        assert data_csr.as_scipy() is data_csr.as_scipy()
+-
+-    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
+-        """
+-        Test that we produce a new scipy matrix, regardless of how we have
+-        initialised the type.
+-        """
+-        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
+-
+-    def test_as_scipy_of_copy_is_different(self, data_csr):
+-        """
+-        Test that as_scipy() does not return the same array, or the same views
+-        if it's not the same input matrix.  We don't want two CSR matrices to
+-        be linked.
+-        """
+-        original = data_csr.as_scipy()
+-        copy = data_csr.copy().as_scipy()
+-        assert original is not copy
+-        assert not np.may_share_memory(original.data, copy.data)
+-        assert not np.may_share_memory(original.indices, copy.indices)
+-        assert not np.may_share_memory(original.indptr, copy.indptr)
+-
+-    def test_as_scipy_is_correct_result(self, scipy_csr):
+-        """
+-        Test that as_scipy is actually giving the matrix we expect for a given
+-        input.
+-        """
+-        data_csr = data.CSR(scipy_csr)
+-        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
+-        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
+-
+-    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
+-        nnz = int(shape[0] * shape[1] * density) or 1
+-        base = csr.empty(shape[0], shape[1], nnz)
+-        sci = base.as_scipy()
+-        assert sci.nnz == 0
+-        assert len(sci.data) == 0
+-        assert len(sci.indices) == 0
+-
+-    def test_to_array_is_correct_result(self, data_csr):
+-        test_array = data_csr.to_array()
+-        assert isinstance(test_array, np.ndarray)
+-        # It's not enough to be accurate within a tolerance here - there's no
+-        # mathematics, so they should be _identical_.
+-        assert np.all(test_array == data_csr.as_scipy().toarray())
+-
+-    def test_sorted_indices(self, data_csr):
+-        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
+-        # per row), so we add in this additional assertion message just to help
+-        # out.
+-        message = (
+-            "Sort on {}sorted indices failed."
+-            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
+-        )
+-        # We test on a copy because scipy attempts to cache
+-        # `has_sorted_indices`, but since it's a view, it has no idea what
+-        # we've done to the indices behind the scenes and typically would not
+-        # notice the change.  The copy will return a difference scipy matrix,
+-        # so the cache will not be built.
+-        copy = data_csr.copy()
+-        copy.sort_indices()
+-        assert copy.as_scipy().has_sorted_indices, message
+-
+-
+-class TestFactoryMethods:
+-    def test_empty(self, shape, density):
+-        nnz = int(shape[0] * shape[1] * density) or 1
+-        base = csr.empty(shape[0], shape[1], nnz)
+-        sci = base.as_scipy(full=True)
+-        assert isinstance(base, data.CSR)
+-        assert isinstance(sci, scipy.sparse.csr_matrix)
+-        assert base.shape == shape
+-        assert sci.data.shape == (nnz,)
+-        assert sci.indices.shape == (nnz,)
+-        assert sci.indptr.shape == (shape[0] + 1,)
+-
+-    def test_zeros(self, shape):
+-        base = csr.zeros(shape[0], shape[1])
+-        sci = base.as_scipy()
+-        assert isinstance(base, data.CSR)
+-        assert base.shape == shape
+-        assert sci.nnz == 0
+-        assert sci.indptr.shape == (shape[0] + 1,)
+-
+-    @pytest.mark.parametrize('dimension', [1, 5, 100])
+-    @pytest.mark.parametrize(
+-        'scale',
+-        [None, 2, -0.1, 1.5, 1.5+1j],
+-        ids=['none', 'int', 'negative', 'float', 'complex']
+-    )
+-    def test_identity(self, dimension, scale):
+-        # scale=None is testing that the default value returns the identity.
+-        base = (csr.identity(dimension) if scale is None
+-                else csr.identity(dimension, scale))
+-        sci = base.as_scipy()
+-        scipy_test = scipy.sparse.eye(dimension,
+-                                      dtype=np.complex128, format='csr')
+-        if scale is not None:
+-            scipy_test *= scale
+-        assert isinstance(base, data.CSR)
+-        assert base.shape == (dimension, dimension)
+-        assert sci.nnz == dimension
+-        assert (sci - scipy_test).nnz == 0
+-
+-    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+-        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+-        pytest.param([1], None, None, id='1x1'),
+-        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+-        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+-        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+-        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+-                     id='two diagonals'),
+-        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+-        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+-        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+-                     id='two wide super'),
+-        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+-                     id='two tall sub'),
+-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+-                     id='out of order'),
+-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+-                     id='sum duplicates'),
+-    ])
+-    def test_diags(self, diagonals, offsets, shape):
+-        base = csr.diags(diagonals, offsets, shape)
+-        # Build numpy version test.
+-        if not isinstance(diagonals[0], list):
+-            diagonals = [diagonals]
+-        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+-        if shape is None:
+-            size = len(diagonals[0]) + abs(offsets[0])
+-            shape = (size, size)
+-        test = np.zeros(shape, dtype=np.complex128)
+-        for diagonal, offset in zip(diagonals, offsets):
+-            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+-        assert isinstance(base, data.CSR)
+-        assert base.shape == shape
+-        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+-
+-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+-        pytest.param((1, 1), (0, 0), None, id='minimal'),
+-        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+-        pytest.param((10, 10), (1, 5), 1., id='upper'),
+-        pytest.param((10, 10), (5, 1), 2., id='lower'),
+-        pytest.param((10, 1), (5, 0), None, id='column'),
+-        pytest.param((1, 10), (0, 5), -5j, id='row'),
+-        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+-        pytest.param((2, 10), (1, 5), 10, id='wide'),
+-    ])
+-    def test_one_element(self, shape, position, value):
+-        test = np.zeros(shape, dtype=np.complex128)
+-        if value is None:
+-            base = data.one_element_csr(shape, position)
+-            test[position] = 1.0+0.0j
+-        else:
+-            base = data.one_element_csr(shape, position, value)
+-            test[position] = value
+-        assert isinstance(base, data.CSR)
+-        assert base.shape == shape
+-        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
+-
+-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+-        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+-        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+-        pytest.param((10, 10), (10, 5), 1., id='outside'),
+-        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+-    ])
+-    def test_one_element_error(self, shape, position, value):
+-        with pytest.raises(ValueError) as exc:
+-            base = data.one_element_csr(shape, position, value)
+-        assert str(exc.value).startswith("Position of the elements"
+-                                         " out of bound: ")
+-
+-
+-class TestFromCSRBlocks:
+-    class _blocks:
+-        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
+-            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
+-            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
+-            if isinstance(ops, int):
+-                ops = [csr.zeros(block_size, block_size)] * ops
+-            self.ops = np.array(ops, dtype=object)
+-            self.n_blocks = n_blocks
+-            self.block_size = block_size
+-
+-        def from_csr_blocks(self):
+-            return csr._from_csr_blocks(
+-                self.rows, self.cols, self.ops,
+-                self.n_blocks, self.block_size,
+-            )
+-
+-    @pytest.mark.parametrize(['blocks'], [
+-        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
+-        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
+-    ])
+-    def test_input_length_error(self, blocks):
+-        with pytest.raises(ValueError) as exc:
+-            blocks.from_csr_blocks()
+-        assert str(exc.value) == (
+-            "The arrays block_rows, block_cols and block_ops should have"
+-            " the same length."
+-        )
+-
+-    def test_op_shape_error(self):
+-        blocks = self._blocks(
+-            (0, 1), (0, 1),
+-            (csr.zeros(2, 2), csr.zeros(3, 3)),
+-        )
+-        with pytest.raises(ValueError) as exc:
+-            blocks.from_csr_blocks()
+-        assert str(exc.value) == (
+-            "Block operators (block_ops) do not have the correct shape."
+-        )
+-
+-    @pytest.mark.parametrize(['blocks'], [
+-        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
+-        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
+-        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
+-    ])
+-    def test_op_ordering_error(self, blocks):
+-        with pytest.raises(ValueError) as exc:
+-            blocks.from_csr_blocks()
+-        assert str(exc.value) == (
+-            "The arrays block_rows and block_cols must be sorted"
+-            " by (row, column)."
+-        )
+-
+-    @pytest.mark.parametrize(['blocks'], [
+-        pytest.param(_blocks((), (), ()), id='no ops'),
+-        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
+-    ])
+-    def test_zeros_output_fast_paths(self, blocks):
+-        out = blocks.from_csr_blocks()
+-        assert out == csr.zeros(2 * 2, 2 * 2)
+-        assert csr.nnz(out) == 0
+-
+-    def test_construct_identity_with_empty(self):
+-        # users are not expected to be exposed to
+-        # csr.empty directly, but it is good to
+-        # avoid segfaults, so we test passing
+-        # csr.empty(..) blocks here explicitly
+-        blocks = self._blocks(
+-            [0, 0, 1, 1], [0, 1, 0, 1], [
+-                csr.identity(2), csr.empty(2, 2, 0),
+-                csr.empty(2, 2, 0), csr.identity(2),
+-            ],
+-        )
+-        out = blocks.from_csr_blocks()
+-        assert out == csr.identity(4)
+-        assert csr.nnz(out) == 4
+-
+-    def test_construct_identity_with_zeros(self):
+-        blocks = self._blocks(
+-            [0, 0, 1, 1], [0, 1, 0, 1], [
+-                csr.identity(2), csr.zeros(2, 2),
+-                csr.zeros(2, 2), csr.identity(2),
+-            ],
+-        )
+-        out = blocks.from_csr_blocks()
+-        assert out == csr.identity(4)
+-        assert csr.nnz(out) == 4
+-
+-    def test_construct_kron(self):
+-        A = np.array([[1, 2], [3, 4]])
+-        B = np.array([[0.3, 0.35], [0.4, 0.45]])
+-        B_op = data.to("csr", data.Dense(B))
+-        blocks = self._blocks(
+-            [0, 0, 1, 1], [0, 1, 0, 1], [
+-                A[0, 0] * B_op, A[0, 1] * B_op,
+-                A[1, 0] * B_op, A[1, 1] * B_op,
+-            ]
+-        )
+-        out = blocks.from_csr_blocks()
+-        assert out == data.kron(data.Dense(A), data.Dense(B))
+-        assert csr.nnz(out) == 16
+-
+-
+-def test_tidyup():
+-    small = qeye(1) * 1e-5
+-    with CoreOptions(auto_tidyup_atol=1e-3):
+-        assert (small + small).tr() == 0
+-    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
+-        assert (small + small).tr() == 2e-5
++import numpy as np
++import scipy.sparse
++import pytest
++
++from qutip.core import data
++from qutip.core.data import csr
++from qutip import qeye, CoreOptions
++
++from . import conftest
++
++# We only choose a small subset of dtypes to test so it isn't crazy.
++_dtype_complex = ['complex128']
++_dtype_float = ['float64']
++_dtype_int = ['int32', 'int64']
++_dtype_uint = ['uint32']
++
++
++# Set up some fixtures for automatic parametrisation.
++
++@pytest.fixture(params=[
++    pytest.param((1, 5), id='bra'),
++    pytest.param((5, 1), id='ket'),
++    pytest.param((5, 5), id='square'),
++    pytest.param((2, 4), id='wide'),
++    pytest.param((4, 2), id='tall'),
++])
++def shape(request): return request.param
++
++
++@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
++def density(request): return request.param
++
++
++@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
++def sorted_(request): return request.param
++
++
++def _valid_scipy():
++    """Arbitrary valid scipy CSR"""
++    return conftest.random_scipy_csr((10, 10), 0.5, True)
++
++
++def _valid_arg():
++    """
++    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
++    """
++    sci = _valid_scipy()
++    return (sci.data, sci.indices, sci.indptr)
++
++
++@pytest.fixture(scope='function')
++def scipy_csr(shape, density, sorted_):
++    return conftest.random_scipy_csr(shape, density, sorted_)
++
++
++@pytest.fixture(scope='function')
++def data_csr(shape, density, sorted_):
++    return conftest.random_csr(shape, density, sorted_)
++
++
++class TestClassMethods:
++    def test_init_from_tuple(self, scipy_csr):
++        """
++        Test that __init__ does not throw when passed a 3-tuple.  Also tests
++        the as_scipy() method succeeds.
++        """
++        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
++        out = data.CSR(arg, shape=scipy_csr.shape)
++        assert out.shape == scipy_csr.shape
++        assert (out.as_scipy() - scipy_csr).nnz == 0
++
++    @pytest.mark.parametrize('d_type', (
++        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
++    ))
++    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
++    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
++    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
++        """
++        Test that initialisation can use a variety of dtypes and converts into
++        the correct type.
++        """
++        sci = _valid_scipy()
++        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
++        col_index = sci.indices.astype(c_type, casting='unsafe')
++        row_index = sci.indptr.astype(r_type, casting='unsafe')
++        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
++                                            shape=sci.shape)
++        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
++        out_scipy = out.as_scipy()
++        assert out.shape == scipy_csr.shape
++        assert out_scipy.data.dtype == np.complex128
++        assert (out_scipy - scipy_csr).nnz == 0
++
++    def test_init_from_scipy(self, scipy_csr):
++        """Test that __init__ can accept a scipy CSR matrix."""
++        out = data.CSR(scipy_csr)
++        assert out.shape == scipy_csr.shape
++        assert (out.as_scipy() - scipy_csr).nnz == 0
++
++    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
++        pytest.param((), {}, ValueError, id="arg 0 tuple"),
++        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
++        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
++        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
++        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
++        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
++                     id="scipy-shape 0 tuple"),
++        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
++                     id="scipy-shape 1 tuple"),
++        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
++                     id="scipy-shape None tuple"),
++        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
++                     id="scipy-shape list"),
++        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
++                     id="scipy-shape 3 tuple"),
++        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
++                     id="arg-shape 0 tuple"),
++        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
++                     id="arg-shape 1 tuple"),
++        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
++                     id="arg-shape None tuple"),
++        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
++                     id="arg-shape list"),
++        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
++                     id="arg-shape 3 tuple"),
++        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
++                     id="arg-negative shape"),
++    ])
++    def test_init_from_wrong_input(self, arg, kwargs, error):
++        """
++        Test that the __init__ method raises a suitable error when passed
++        incorrectly formatted inputs.
++
++        This test also serves as a *partial* check that CSR safely handles
++        deallocation in the presence of exceptions in its __init__ method.  If
++        the tests segfault, it's quite likely that the memory management isn't
++        being done correctly in the hand-off us setting our data buffers up and
++        marking the numpy actually owns the data.
++        """
++        with pytest.raises(error):
++            data.CSR(arg, **kwargs)
++
++    def test_copy_returns_a_correct_copy(self, data_csr):
++        """
++        Test that the copy() method produces an actual copy, and that the
++        result represents the same matrix.
++        """
++        original = data_csr
++        copy = data_csr.copy()
++        assert original is not copy
++        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
++
++    def test_as_scipy_returns_a_view(self, data_csr):
++        """
++        Test that modifying the views in the result of as_scipy() also modifies
++        the underlying data structures.  This is important for allowing minor
++        data modifications from within Python-space.
++        """
++        unmodified_copy = data_csr.copy()
++        data_csr.as_scipy().data[0] += 1
++        modified_copy = data_csr.copy()
++        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
++        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
++
++    def test_as_scipy_caches_result(self, data_csr):
++        """
++        Test that the as_scipy() method always returns the same view, even if
++        called multiple times.
++        """
++        assert data_csr.as_scipy() is data_csr.as_scipy()
++
++    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
++        """
++        Test that we produce a new scipy matrix, regardless of how we have
++        initialised the type.
++        """
++        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
++
++    def test_as_scipy_of_copy_is_different(self, data_csr):
++        """
++        Test that as_scipy() does not return the same array, or the same views
++        if it's not the same input matrix.  We don't want two CSR matrices to
++        be linked.
++        """
++        original = data_csr.as_scipy()
++        copy = data_csr.copy().as_scipy()
++        assert original is not copy
++        assert not np.may_share_memory(original.data, copy.data)
++        assert not np.may_share_memory(original.indices, copy.indices)
++        assert not np.may_share_memory(original.indptr, copy.indptr)
++
++    def test_as_scipy_is_correct_result(self, scipy_csr):
++        """
++        Test that as_scipy is actually giving the matrix we expect for a given
++        input.
++        """
++        data_csr = data.CSR(scipy_csr)
++        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
++        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
++
++    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
++        nnz = int(shape[0] * shape[1] * density) or 1
++        base = csr.empty(shape[0], shape[1], nnz)
++        sci = base.as_scipy()
++        assert sci.nnz == 0
++        assert len(sci.data) == 0
++        assert len(sci.indices) == 0
++
++    def test_to_array_is_correct_result(self, data_csr):
++        test_array = data_csr.to_array()
++        assert isinstance(test_array, np.ndarray)
++        # It's not enough to be accurate within a tolerance here - there's no
++        # mathematics, so they should be _identical_.
++        assert np.all(test_array == data_csr.as_scipy().toarray())
++
++    def test_sorted_indices(self, data_csr):
++        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
++        # per row), so we add in this additional assertion message just to help
++        # out.
++        message = (
++            "Sort on {}sorted indices failed."
++            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
++        )
++        # We test on a copy because scipy attempts to cache
++        # `has_sorted_indices`, but since it's a view, it has no idea what
++        # we've done to the indices behind the scenes and typically would not
++        # notice the change.  The copy will return a difference scipy matrix,
++        # so the cache will not be built.
++        copy = data_csr.copy()
++        copy.sort_indices()
++        assert copy.as_scipy().has_sorted_indices, message
++
++
++class TestFactoryMethods:
++    def test_empty(self, shape, density):
++        nnz = int(shape[0] * shape[1] * density) or 1
++        base = csr.empty(shape[0], shape[1], nnz)
++        sci = base.as_scipy(full=True)
++        assert isinstance(base, data.CSR)
++        assert isinstance(sci, scipy.sparse.csr_matrix)
++        assert base.shape == shape
++        assert sci.data.shape == (nnz,)
++        assert sci.indices.shape == (nnz,)
++        assert sci.indptr.shape == (shape[0] + 1,)
++
++    def test_zeros(self, shape):
++        base = csr.zeros(shape[0], shape[1])
++        sci = base.as_scipy()
++        assert isinstance(base, data.CSR)
++        assert base.shape == shape
++        assert sci.nnz == 0
++        assert sci.indptr.shape == (shape[0] + 1,)
++
++    @pytest.mark.parametrize('dimension', [1, 5, 100])
++    @pytest.mark.parametrize(
++        'scale',
++        [None, 2, -0.1, 1.5, 1.5+1j],
++        ids=['none', 'int', 'negative', 'float', 'complex']
++    )
++    def test_identity(self, dimension, scale):
++        # scale=None is testing that the default value returns the identity.
++        base = (csr.identity(dimension) if scale is None
++                else csr.identity(dimension, scale))
++        sci = base.as_scipy()
++        scipy_test = scipy.sparse.eye(dimension,
++                                      dtype=np.complex128, format='csr')
++        if scale is not None:
++            scipy_test *= scale
++        assert isinstance(base, data.CSR)
++        assert base.shape == (dimension, dimension)
++        assert sci.nnz == dimension
++        assert (sci - scipy_test).nnz == 0
++
++    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
++        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
++        pytest.param([1], None, None, id='1x1'),
++        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
++        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
++        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
++        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
++                     id='two diagonals'),
++        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
++        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
++        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
++        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
++                     id='two wide super'),
++        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
++        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
++                     id='two tall sub'),
++        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
++                     id='out of order'),
++        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
++                     id='sum duplicates'),
++    ])
++    def test_diags(self, diagonals, offsets, shape):
++        base = csr.diags(diagonals, offsets, shape)
++        # Build numpy version test.
++        if not isinstance(diagonals[0], list):
++            diagonals = [diagonals]
++        offsets = np.atleast_1d(offsets if offsets is not None else [0])
++        if shape is None:
++            size = len(diagonals[0]) + abs(offsets[0])
++            shape = (size, size)
++        test = np.zeros(shape, dtype=np.complex128)
++        for diagonal, offset in zip(diagonals, offsets):
++            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
++        assert isinstance(base, data.CSR)
++        assert base.shape == shape
++        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
++
++    @pytest.mark.parametrize(['shape', 'position', 'value'], [
++        pytest.param((1, 1), (0, 0), None, id='minimal'),
++        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
++        pytest.param((10, 10), (1, 5), 1., id='upper'),
++        pytest.param((10, 10), (5, 1), 2., id='lower'),
++        pytest.param((10, 1), (5, 0), None, id='column'),
++        pytest.param((1, 10), (0, 5), -5j, id='row'),
++        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
++        pytest.param((2, 10), (1, 5), 10, id='wide'),
++    ])
++    def test_one_element(self, shape, position, value):
++        test = np.zeros(shape, dtype=np.complex128)
++        if value is None:
++            base = data.one_element_csr(shape, position)
++            test[position] = 1.0+0.0j
++        else:
++            base = data.one_element_csr(shape, position, value)
++            test[position] = value
++        assert isinstance(base, data.CSR)
++        assert base.shape == shape
++        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
++
++    @pytest.mark.parametrize(['shape', 'position', 'value'], [
++        pytest.param((0, 0), (0, 0), None, id='zero shape'),
++        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
++        pytest.param((10, 10), (10, 5), 1., id='outside'),
++        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
++    ])
++    def test_one_element_error(self, shape, position, value):
++        with pytest.raises(ValueError) as exc:
++            base = data.one_element_csr(shape, position, value)
++        assert str(exc.value).startswith("Position of the elements"
++                                         " out of bound: ")
++
++
++class TestFromCSRBlocks:
++    class _blocks:
++        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
++            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
++            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
++            if isinstance(ops, int):
++                ops = [csr.zeros(block_size, block_size)] * ops
++            self.ops = np.array(ops, dtype=object)
++            self.n_blocks = n_blocks
++            self.block_size = block_size
++
++        def from_csr_blocks(self):
++            return csr._from_csr_blocks(
++                self.rows, self.cols, self.ops,
++                self.n_blocks, self.block_size,
++            )
++
++    @pytest.mark.parametrize(['blocks'], [
++        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
++        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
++    ])
++    def test_input_length_error(self, blocks):
++        with pytest.raises(ValueError) as exc:
++            blocks.from_csr_blocks()
++        assert str(exc.value) == (
++            "The arrays block_rows, block_cols and block_ops should have"
++            " the same length."
++        )
++
++    def test_op_shape_error(self):
++        blocks = self._blocks(
++            (0, 1), (0, 1),
++            (csr.zeros(2, 2), csr.zeros(3, 3)),
++        )
++        with pytest.raises(ValueError) as exc:
++            blocks.from_csr_blocks()
++        assert str(exc.value) == (
++            "Block operators (block_ops) do not have the correct shape."
++        )
++
++    @pytest.mark.parametrize(['blocks'], [
++        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
++        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
++        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
++    ])
++    def test_op_ordering_error(self, blocks):
++        with pytest.raises(ValueError) as exc:
++            blocks.from_csr_blocks()
++        assert str(exc.value) == (
++            "The arrays block_rows and block_cols must be sorted"
++            " by (row, column)."
++        )
++
++    @pytest.mark.parametrize(['blocks'], [
++        pytest.param(_blocks((), (), ()), id='no ops'),
++        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
++    ])
++    def test_zeros_output_fast_paths(self, blocks):
++        out = blocks.from_csr_blocks()
++        assert out == csr.zeros(2 * 2, 2 * 2)
++        assert csr.nnz(out) == 0
++
++    def test_construct_identity_with_empty(self):
++        # users are not expected to be exposed to
++        # csr.empty directly, but it is good to
++        # avoid segfaults, so we test passing
++        # csr.empty(..) blocks here explicitly
++        blocks = self._blocks(
++            [0, 0, 1, 1], [0, 1, 0, 1], [
++                csr.identity(2), csr.empty(2, 2, 0),
++                csr.empty(2, 2, 0), csr.identity(2),
++            ],
++        )
++        out = blocks.from_csr_blocks()
++        assert out == csr.identity(4)
++        assert csr.nnz(out) == 4
++
++    def test_construct_identity_with_zeros(self):
++        blocks = self._blocks(
++            [0, 0, 1, 1], [0, 1, 0, 1], [
++                csr.identity(2), csr.zeros(2, 2),
++                csr.zeros(2, 2), csr.identity(2),
++            ],
++        )
++        out = blocks.from_csr_blocks()
++        assert out == csr.identity(4)
++        assert csr.nnz(out) == 4
++
++    def test_construct_kron(self):
++        A = np.array([[1, 2], [3, 4]])
++        B = np.array([[0.3, 0.35], [0.4, 0.45]])
++        B_op = data.to("csr", data.Dense(B))
++        blocks = self._blocks(
++            [0, 0, 1, 1], [0, 1, 0, 1], [
++                A[0, 0] * B_op, A[0, 1] * B_op,
++                A[1, 0] * B_op, A[1, 1] * B_op,
++            ]
++        )
++        out = blocks.from_csr_blocks()
++        assert out == data.kron(data.Dense(A), data.Dense(B))
++        assert csr.nnz(out) == 16
++
++
++def test_tidyup():
++    small = qeye(1) * 1e-5
++    with CoreOptions(auto_tidyup_atol=1e-3):
++        assert (small + small).tr() == 0
++    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
++        assert (small + small).tr() == 2e-5
+diff --git a/qutip/tests/core/data/test_dense.py b/qutip/tests/core/data/test_dense.py
+index 07290811..198ecf98 100644
+--- a/qutip/tests/core/data/test_dense.py
++++ b/qutip/tests/core/data/test_dense.py
+@@ -1,297 +1,297 @@
+-import numpy as np
+-import pytest
+-
+-from qutip.core import data
+-from qutip.core.data import dense, csr
+-
+-from . import conftest
+-
+-
+-# Set up some fixtures for automatic parametrisation.
+-
+-@pytest.fixture(params=[
+-    pytest.param((1, 5), id='ket'),
+-    pytest.param((5, 1), id='bra'),
+-    pytest.param((5, 5), id='square'),
+-    pytest.param((2, 4), id='wide'),
+-    pytest.param((4, 2), id='tall'),
+-])
+-def shape(request): return request.param
+-
+-
+-@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
+-def fortran(request): return request.param
+-
+-
+-def _valid_numpy():
+-    # Arbitrary valid numpy array.
+-    return conftest.random_numpy_dense((5, 5), False)
+-
+-
+-@pytest.fixture(scope='function')
+-def numpy_dense(shape, fortran):
+-    return conftest.random_numpy_dense(shape, fortran)
+-
+-
+-@pytest.fixture(scope='function')
+-def data_dense(shape, fortran):
+-    return conftest.random_dense(shape, fortran)
+-
+-
+-class TestClassMethods:
+-    def test_init_from_ndarray(self, numpy_dense):
+-        test = data.Dense(numpy_dense)
+-        assert test.shape == numpy_dense.shape
+-        assert np.all(test.as_ndarray() == numpy_dense)
+-
+-    @pytest.mark.parametrize('dtype', ['complex128',
+-                                       'float64',
+-                                       'int32', 'int64',
+-                                       'uint32'])
+-    def test_init_from_ndarray_other_dtype(self, shape, dtype):
+-        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
+-        test = data.Dense(numpy_dense)
+-        assert test.shape == shape
+-        assert test.as_ndarray().dtype == np.complex128
+-        assert np.all(test.as_ndarray() == numpy_dense)
+-
+-    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+-        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
+-                     id="numpy-shape 0 tuple"),
+-        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
+-                     id="numpy-shape 1 tuple"),
+-        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
+-                     id="numpy-shape None tuple"),
+-        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
+-                     id="numpy-shape list"),
+-        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
+-                     id="numpy-shape 3 tuple"),
+-        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
+-                     id="numpy-negative shape"),
+-        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
+-                     id="numpy-both negative shape"),
+-        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
+-                     id="numpy-different shape"),
+-    ])
+-    def test_init_from_wrong_input(self, arg, kwargs, error):
+-        """
+-        Test that the __init__ method raises a suitable error when passed
+-        incorrectly formatted inputs.
+-
+-        This test also serves as a *partial* check that Dense safely handles
+-        deallocation in the presence of exceptions in its __init__ method.  If
+-        the tests segfault, it's quite likely that the memory management isn't
+-        being done correctly in the hand-off us setting our data buffers up and
+-        marking the numpy actually owns the data.
+-        """
+-        with pytest.raises(error):
+-            data.Dense(arg, **kwargs)
+-
+-    def test_copy_returns_a_correct_copy(self, data_dense):
+-        """
+-        Test that the copy() method produces an actual copy, and that the
+-        result represents the same matrix.
+-        """
+-        original = data_dense
+-        copy = data_dense.copy()
+-        assert original is not copy
+-        assert np.all(original.as_ndarray() == copy.as_ndarray())
+-
+-    def test_as_ndarray_returns_a_view(self, data_dense):
+-        """
+-        Test that modifying the views in the result of as_ndarray() also
+-        modifies the underlying data structures.  This is important for
+-        allowing data modification from within Python-space.
+-        """
+-        unmodified_copy = data_dense.copy()
+-        data_dense.as_ndarray()[0, 0] += 1
+-        modified_copy = data_dense.copy()
+-        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
+-        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
+-
+-    def test_as_ndarray_caches_result(self, data_dense):
+-        """
+-        Test that the as_ndarray() method always returns the same view, even if
+-        called multiple times.
+-        """
+-        assert data_dense.as_ndarray() is data_dense.as_ndarray()
+-
+-    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
+-        """
+-        Test that we produce a new ndarray, regardless of how we have
+-        initialised the type.
+-        """
+-        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
+-
+-    def test_as_ndarray_of_copy_is_different(self, data_dense):
+-        """
+-        Test that as_ndarray() does not return the same array or a view to the
+-        same data, if it's not the same input matrix.  We don't want two Dense
+-        matrices to be linked.
+-        """
+-        original = data_dense.as_ndarray()
+-        copy = data_dense.copy().as_ndarray()
+-        assert original is not copy
+-        assert not np.may_share_memory(original, copy)
+-
+-    def test_as_ndarray_is_correct_result(self, numpy_dense):
+-        """
+-        Test that as_ndarray is actually giving the matrix we expect for a given
+-        input.
+-        """
+-        data_dense = data.Dense(numpy_dense)
+-        nd_view = data_dense.as_ndarray()
+-        assert isinstance(data_dense.as_ndarray(), np.ndarray)
+-        assert nd_view.ndim == 2
+-        assert nd_view.shape == numpy_dense.shape
+-        assert nd_view.strides == numpy_dense.strides
+-        assert np.all(nd_view == numpy_dense)
+-        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
+-        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
+-
+-    def test_to_array_is_correct_result(self, data_dense):
+-        test_array = data_dense.to_array()
+-        nd_view = data_dense.as_ndarray()
+-        assert isinstance(test_array, np.ndarray)
+-        assert test_array.ndim == 2
+-        assert test_array.shape == nd_view.shape
+-        assert test_array.strides == nd_view.strides
+-        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
+-        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
+-        # It's not enough to be accurate within a tolerance here - there's no
+-        # mathematics, so they should be _identical_.
+-        assert np.all(test_array == nd_view)
+-
+-    @pytest.mark.parametrize('new_fortran', [
+-        pytest.param(-1, id='swap'),
+-        pytest.param(False, id='C'),
+-        pytest.param(True, id='Fortran'),
+-    ])
+-    def test_reorder(self, data_dense, new_fortran):
+-        reordered = data_dense.reorder(new_fortran)
+-        assert isinstance(reordered, data.Dense)
+-        assert reordered.shape == data_dense.shape
+-        orig = data_dense.to_array()
+-        test = reordered.to_array()
+-        if new_fortran == -1:
+-            orig.flags.f_contiguous == test.flags.c_contiguous
+-            orig.flags.c_contiguous == test.flags.f_contiguous
+-        elif new_fortran is True:
+-            assert test.flags.f_contiguous
+-        else:
+-            assert test.flags.c_contiguous
+-        assert np.all(orig == test)
+-
+-class TestFactoryMethods:
+-    def test_empty(self, shape):
+-        base = dense.empty(shape[0], shape[1])
+-        nd = base.as_ndarray()
+-        assert isinstance(base, data.Dense)
+-        assert base.shape == shape
+-        assert nd.shape == shape
+-
+-    def test_zeros(self, shape):
+-        base = dense.zeros(shape[0], shape[1])
+-        nd = base.as_ndarray()
+-        assert isinstance(base, data.Dense)
+-        assert base.shape == shape
+-        assert nd.shape == shape
+-        assert np.count_nonzero(nd) == 0
+-
+-    @pytest.mark.parametrize('dimension', [1, 5, 100])
+-    @pytest.mark.parametrize(
+-        'scale',
+-        [None, 2, -0.1, 1.5, 1.5+1j],
+-        ids=['none', 'int', 'negative', 'float', 'complex']
+-    )
+-    def test_identity(self, dimension, scale):
+-        # scale=None is testing that the default value returns the identity.
+-        base = (dense.identity(dimension) if scale is None
+-                else dense.identity(dimension, scale))
+-        nd = base.as_ndarray()
+-        numpy_test = np.eye(dimension, dtype=np.complex128)
+-        if scale is not None:
+-            numpy_test *= scale
+-        assert isinstance(base, data.Dense)
+-        assert base.shape == (dimension, dimension)
+-        assert np.count_nonzero(nd - numpy_test) == 0
+-
+-    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+-        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+-        pytest.param([1], None, None, id='1x1'),
+-        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+-        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+-        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+-        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+-                     id='two diagonals'),
+-        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+-        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+-        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+-                     id='two wide super'),
+-        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+-                     id='two tall sub'),
+-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+-                     id='out of order'),
+-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+-                     id='sum duplicates'),
+-    ])
+-    def test_diags(self, diagonals, offsets, shape):
+-        base = dense.diags(diagonals, offsets, shape)
+-        # Build numpy version test.
+-        if not isinstance(diagonals[0], list):
+-            diagonals = [diagonals]
+-        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+-        if shape is None:
+-            size = len(diagonals[0]) + abs(offsets[0])
+-            shape = (size, size)
+-        test = np.zeros(shape, dtype=np.complex128)
+-        for diagonal, offset in zip(diagonals, offsets):
+-            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+-        assert isinstance(base, data.Dense)
+-        assert base.shape == shape
+-        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+-
+-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+-        pytest.param((1, 1), (0, 0), None, id='minimal'),
+-        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+-        pytest.param((10, 10), (1, 5), 1., id='upper'),
+-        pytest.param((10, 10), (5, 1), 2., id='lower'),
+-        pytest.param((10, 1), (5, 0), None, id='column'),
+-        pytest.param((1, 10), (0, 5), -5.j, id='row'),
+-        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+-        pytest.param((2, 10), (1, 5), 10, id='wide'),
+-    ])
+-    def test_one_element(self, shape, position, value):
+-        test = np.zeros(shape, dtype=np.complex128)
+-        if value is None:
+-            base = data.one_element_dense(shape, position)
+-            test[position] = 1.0+0.0j
+-        else:
+-            base = data.one_element_dense(shape, position, value)
+-            test[position] = value
+-        assert isinstance(base, data.Dense)
+-        assert base.shape == shape
+-        assert np.allclose(base.to_array(), test, atol=1e-10)
+-
+-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+-        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+-        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+-        pytest.param((10, 10), (10, 5), 1., id='outside'),
+-        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+-    ])
+-    def test_one_element_error(self, shape, position, value):
+-        with pytest.raises(ValueError) as exc:
+-            base = data.one_element_dense(shape, position, value)
+-        assert str(exc.value).startswith("Position of the elements"
+-                                         " out of bound: ")
+-
+-
+-def test_OrderEfficiencyWarning():
+-    N = 5
+-    M = csr.identity(N)
+-    C_ordered = dense.zeros(N, 1, fortran=False)
+-    fortran_ordered = dense.zeros(N, 1, fortran=True)
+-    with pytest.warns(dense.OrderEfficiencyWarning):
+-        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
++import numpy as np
++import pytest
++
++from qutip.core import data
++from qutip.core.data import dense, csr
++
++from . import conftest
++
++
++# Set up some fixtures for automatic parametrisation.
++
++@pytest.fixture(params=[
++    pytest.param((1, 5), id='ket'),
++    pytest.param((5, 1), id='bra'),
++    pytest.param((5, 5), id='square'),
++    pytest.param((2, 4), id='wide'),
++    pytest.param((4, 2), id='tall'),
++])
++def shape(request): return request.param
++
++
++@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
++def fortran(request): return request.param
++
++
++def _valid_numpy():
++    # Arbitrary valid numpy array.
++    return conftest.random_numpy_dense((5, 5), False)
++
++
++@pytest.fixture(scope='function')
++def numpy_dense(shape, fortran):
++    return conftest.random_numpy_dense(shape, fortran)
++
++
++@pytest.fixture(scope='function')
++def data_dense(shape, fortran):
++    return conftest.random_dense(shape, fortran)
++
++
++class TestClassMethods:
++    def test_init_from_ndarray(self, numpy_dense):
++        test = data.Dense(numpy_dense)
++        assert test.shape == numpy_dense.shape
++        assert np.all(test.as_ndarray() == numpy_dense)
++
++    @pytest.mark.parametrize('dtype', ['complex128',
++                                       'float64',
++                                       'int32', 'int64',
++                                       'uint32'])
++    def test_init_from_ndarray_other_dtype(self, shape, dtype):
++        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
++        test = data.Dense(numpy_dense)
++        assert test.shape == shape
++        assert test.as_ndarray().dtype == np.complex128
++        assert np.all(test.as_ndarray() == numpy_dense)
++
++    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
++        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
++                     id="numpy-shape 0 tuple"),
++        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
++                     id="numpy-shape 1 tuple"),
++        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
++                     id="numpy-shape None tuple"),
++        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
++                     id="numpy-shape list"),
++        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
++                     id="numpy-shape 3 tuple"),
++        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
++                     id="numpy-negative shape"),
++        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
++                     id="numpy-both negative shape"),
++        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
++                     id="numpy-different shape"),
++    ])
++    def test_init_from_wrong_input(self, arg, kwargs, error):
++        """
++        Test that the __init__ method raises a suitable error when passed
++        incorrectly formatted inputs.
++
++        This test also serves as a *partial* check that Dense safely handles
++        deallocation in the presence of exceptions in its __init__ method.  If
++        the tests segfault, it's quite likely that the memory management isn't
++        being done correctly in the hand-off us setting our data buffers up and
++        marking the numpy actually owns the data.
++        """
++        with pytest.raises(error):
++            data.Dense(arg, **kwargs)
++
++    def test_copy_returns_a_correct_copy(self, data_dense):
++        """
++        Test that the copy() method produces an actual copy, and that the
++        result represents the same matrix.
++        """
++        original = data_dense
++        copy = data_dense.copy()
++        assert original is not copy
++        assert np.all(original.as_ndarray() == copy.as_ndarray())
++
++    def test_as_ndarray_returns_a_view(self, data_dense):
++        """
++        Test that modifying the views in the result of as_ndarray() also
++        modifies the underlying data structures.  This is important for
++        allowing data modification from within Python-space.
++        """
++        unmodified_copy = data_dense.copy()
++        data_dense.as_ndarray()[0, 0] += 1
++        modified_copy = data_dense.copy()
++        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
++        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
++
++    def test_as_ndarray_caches_result(self, data_dense):
++        """
++        Test that the as_ndarray() method always returns the same view, even if
++        called multiple times.
++        """
++        assert data_dense.as_ndarray() is data_dense.as_ndarray()
++
++    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
++        """
++        Test that we produce a new ndarray, regardless of how we have
++        initialised the type.
++        """
++        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
++
++    def test_as_ndarray_of_copy_is_different(self, data_dense):
++        """
++        Test that as_ndarray() does not return the same array or a view to the
++        same data, if it's not the same input matrix.  We don't want two Dense
++        matrices to be linked.
++        """
++        original = data_dense.as_ndarray()
++        copy = data_dense.copy().as_ndarray()
++        assert original is not copy
++        assert not np.may_share_memory(original, copy)
++
++    def test_as_ndarray_is_correct_result(self, numpy_dense):
++        """
++        Test that as_ndarray is actually giving the matrix we expect for a given
++        input.
++        """
++        data_dense = data.Dense(numpy_dense)
++        nd_view = data_dense.as_ndarray()
++        assert isinstance(data_dense.as_ndarray(), np.ndarray)
++        assert nd_view.ndim == 2
++        assert nd_view.shape == numpy_dense.shape
++        assert nd_view.strides == numpy_dense.strides
++        assert np.all(nd_view == numpy_dense)
++        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
++        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
++
++    def test_to_array_is_correct_result(self, data_dense):
++        test_array = data_dense.to_array()
++        nd_view = data_dense.as_ndarray()
++        assert isinstance(test_array, np.ndarray)
++        assert test_array.ndim == 2
++        assert test_array.shape == nd_view.shape
++        assert test_array.strides == nd_view.strides
++        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
++        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
++        # It's not enough to be accurate within a tolerance here - there's no
++        # mathematics, so they should be _identical_.
++        assert np.all(test_array == nd_view)
++
++    @pytest.mark.parametrize('new_fortran', [
++        pytest.param(-1, id='swap'),
++        pytest.param(False, id='C'),
++        pytest.param(True, id='Fortran'),
++    ])
++    def test_reorder(self, data_dense, new_fortran):
++        reordered = data_dense.reorder(new_fortran)
++        assert isinstance(reordered, data.Dense)
++        assert reordered.shape == data_dense.shape
++        orig = data_dense.to_array()
++        test = reordered.to_array()
++        if new_fortran == -1:
++            orig.flags.f_contiguous == test.flags.c_contiguous
++            orig.flags.c_contiguous == test.flags.f_contiguous
++        elif new_fortran is True:
++            assert test.flags.f_contiguous
++        else:
++            assert test.flags.c_contiguous
++        assert np.all(orig == test)
++
++class TestFactoryMethods:
++    def test_empty(self, shape):
++        base = dense.empty(shape[0], shape[1])
++        nd = base.as_ndarray()
++        assert isinstance(base, data.Dense)
++        assert base.shape == shape
++        assert nd.shape == shape
++
++    def test_zeros(self, shape):
++        base = dense.zeros(shape[0], shape[1])
++        nd = base.as_ndarray()
++        assert isinstance(base, data.Dense)
++        assert base.shape == shape
++        assert nd.shape == shape
++        assert np.count_nonzero(nd) == 0
++
++    @pytest.mark.parametrize('dimension', [1, 5, 100])
++    @pytest.mark.parametrize(
++        'scale',
++        [None, 2, -0.1, 1.5, 1.5+1j],
++        ids=['none', 'int', 'negative', 'float', 'complex']
++    )
++    def test_identity(self, dimension, scale):
++        # scale=None is testing that the default value returns the identity.
++        base = (dense.identity(dimension) if scale is None
++                else dense.identity(dimension, scale))
++        nd = base.as_ndarray()
++        numpy_test = np.eye(dimension, dtype=np.complex128)
++        if scale is not None:
++            numpy_test *= scale
++        assert isinstance(base, data.Dense)
++        assert base.shape == (dimension, dimension)
++        assert np.count_nonzero(nd - numpy_test) == 0
++
++    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
++        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
++        pytest.param([1], None, None, id='1x1'),
++        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
++        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
++        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
++        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
++                     id='two diagonals'),
++        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
++        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
++        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
++        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
++                     id='two wide super'),
++        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
++        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
++                     id='two tall sub'),
++        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
++                     id='out of order'),
++        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
++                     id='sum duplicates'),
++    ])
++    def test_diags(self, diagonals, offsets, shape):
++        base = dense.diags(diagonals, offsets, shape)
++        # Build numpy version test.
++        if not isinstance(diagonals[0], list):
++            diagonals = [diagonals]
++        offsets = np.atleast_1d(offsets if offsets is not None else [0])
++        if shape is None:
++            size = len(diagonals[0]) + abs(offsets[0])
++            shape = (size, size)
++        test = np.zeros(shape, dtype=np.complex128)
++        for diagonal, offset in zip(diagonals, offsets):
++            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
++        assert isinstance(base, data.Dense)
++        assert base.shape == shape
++        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
++
++    @pytest.mark.parametrize(['shape', 'position', 'value'], [
++        pytest.param((1, 1), (0, 0), None, id='minimal'),
++        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
++        pytest.param((10, 10), (1, 5), 1., id='upper'),
++        pytest.param((10, 10), (5, 1), 2., id='lower'),
++        pytest.param((10, 1), (5, 0), None, id='column'),
++        pytest.param((1, 10), (0, 5), -5.j, id='row'),
++        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
++        pytest.param((2, 10), (1, 5), 10, id='wide'),
++    ])
++    def test_one_element(self, shape, position, value):
++        test = np.zeros(shape, dtype=np.complex128)
++        if value is None:
++            base = data.one_element_dense(shape, position)
++            test[position] = 1.0+0.0j
++        else:
++            base = data.one_element_dense(shape, position, value)
++            test[position] = value
++        assert isinstance(base, data.Dense)
++        assert base.shape == shape
++        assert np.allclose(base.to_array(), test, atol=1e-10)
++
++    @pytest.mark.parametrize(['shape', 'position', 'value'], [
++        pytest.param((0, 0), (0, 0), None, id='zero shape'),
++        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
++        pytest.param((10, 10), (10, 5), 1., id='outside'),
++        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
++    ])
++    def test_one_element_error(self, shape, position, value):
++        with pytest.raises(ValueError) as exc:
++            base = data.one_element_dense(shape, position, value)
++        assert str(exc.value).startswith("Position of the elements"
++                                         " out of bound: ")
++
++
++def test_OrderEfficiencyWarning():
++    N = 5
++    M = csr.identity(N)
++    C_ordered = dense.zeros(N, 1, fortran=False)
++    fortran_ordered = dense.zeros(N, 1, fortran=True)
++    with pytest.warns(dense.OrderEfficiencyWarning):
++        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
+diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
+index 256a703a..29eaa5c2 100644
+--- a/qutip/tests/core/data/test_expect.py
++++ b/qutip/tests/core/data/test_expect.py
+@@ -1,67 +1,67 @@
+-"""This file provides tests for expect specialisation. For tests at Qobj level
+-see `qutip/tests/core/test_expect.py`"""
+-
+-from .test_mathematics import BinaryOpMixin
+-import pytest
+-import numpy as np
+-from qutip import data
+-from qutip.core.data import CSR, Dense
+-from itertools import product
+-
+-
+-class TestExpect(BinaryOpMixin):
+-    def op_numpy(self, op, state):
+-        is_ket = state.shape[1] == 1
+-        if is_ket:
+-            return np.conj(state.T)@op@state
+-        else:
+-            return np.trace(op@state)
+-
+-    _dim = 100
+-    _ket = pytest.param((_dim, 1), id="ket")
+-    _dm = pytest.param((_dim, _dim), id="dm")
+-    _op = pytest.param((_dim, _dim), id="op")
+-    _bra = pytest.param((1, _dim), id="bra")
+-    _nonsquare = pytest.param((2, _dim), id="nonsquare")
+-    _not_op = [_bra, _ket, _nonsquare]
+-
+-    shapes = [
+-        (_op, _ket),
+-        (_op, _dm),
+-    ]
+-    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
+-    bad_shapes += [
+-        (_op, _nonsquare),
+-        (_op, _bra),
+-    ]  # Bad ket/dm
+-
+-    specialisations = [
+-        pytest.param(data.expect_csr, CSR, CSR, complex),
+-        pytest.param(data.expect_dense, Dense, Dense, complex),
+-        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
+-    ]
+-
+-
+-class TestExpectSuper(BinaryOpMixin):
+-    def op_numpy(self, op, state):
+-        n = np.sqrt(state.shape[0]).astype(int)
+-        out_shape = (n, n)
+-        return np.trace(np.reshape(op@state, newshape=out_shape))
+-
+-    _dim = 100
+-    _super_ket = pytest.param((_dim, 1), id="super_ket")
+-    _super_op = pytest.param((_dim, _dim), id="super_op")
+-    _bra = pytest.param((1, _dim), id="row_stacked")
+-    _nonsquare = pytest.param((2, _dim), id="nonsquare")
+-    _not_super_ket = [_super_op, _bra, _nonsquare]
+-    _not_super_op = [_super_ket, _bra, _nonsquare]
+-
+-    shapes = [(_super_op, _super_ket), ]
+-    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
+-    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
+-
+-    specialisations = [
+-        pytest.param(data.expect_super_dense, Dense, Dense, complex),
+-        pytest.param(data.expect_super_csr, CSR, CSR, complex),
+-        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
+-    ]
++"""This file provides tests for expect specialisation. For tests at Qobj level
++see `qutip/tests/core/test_expect.py`"""
++
++from .test_mathematics import BinaryOpMixin
++import pytest
++import numpy as np
++from qutip import data
++from qutip.core.data import CSR, Dense
++from itertools import product
++
++
++class TestExpect(BinaryOpMixin):
++    def op_numpy(self, op, state):
++        is_ket = state.shape[1] == 1
++        if is_ket:
++            return np.conj(state.T)@op@state
++        else:
++            return np.trace(op@state)
++
++    _dim = 100
++    _ket = pytest.param((_dim, 1), id="ket")
++    _dm = pytest.param((_dim, _dim), id="dm")
++    _op = pytest.param((_dim, _dim), id="op")
++    _bra = pytest.param((1, _dim), id="bra")
++    _nonsquare = pytest.param((2, _dim), id="nonsquare")
++    _not_op = [_bra, _ket, _nonsquare]
++
++    shapes = [
++        (_op, _ket),
++        (_op, _dm),
++    ]
++    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
++    bad_shapes += [
++        (_op, _nonsquare),
++        (_op, _bra),
++    ]  # Bad ket/dm
++
++    specialisations = [
++        pytest.param(data.expect_csr, CSR, CSR, complex),
++        pytest.param(data.expect_dense, Dense, Dense, complex),
++        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
++    ]
++
++
++class TestExpectSuper(BinaryOpMixin):
++    def op_numpy(self, op, state):
++        n = np.sqrt(state.shape[0]).astype(int)
++        out_shape = (n, n)
++        return np.trace(np.reshape(op@state, newshape=out_shape))
++
++    _dim = 100
++    _super_ket = pytest.param((_dim, 1), id="super_ket")
++    _super_op = pytest.param((_dim, _dim), id="super_op")
++    _bra = pytest.param((1, _dim), id="row_stacked")
++    _nonsquare = pytest.param((2, _dim), id="nonsquare")
++    _not_super_ket = [_super_op, _bra, _nonsquare]
++    _not_super_op = [_super_ket, _bra, _nonsquare]
++
++    shapes = [(_super_op, _super_ket), ]
++    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
++    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
++
++    specialisations = [
++        pytest.param(data.expect_super_dense, Dense, Dense, complex),
++        pytest.param(data.expect_super_csr, CSR, CSR, complex),
++        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
++    ]
+diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
+index 50729bba..e1025fc2 100644
+--- a/qutip/tests/core/data/test_linalg.py
++++ b/qutip/tests/core/data/test_linalg.py
+@@ -1,139 +1,139 @@
+-import qutip.settings as settings
+-import numpy as np
+-import scipy
+-import pytest
+-import qutip
+-
+-from qutip.core import data as _data
+-from qutip.core.data import Data, Dense, CSR
+-
+-
+-class TestSolve():
+-    def op_numpy(self, A, b):
+-        return np.linalg.solve(A, b)
+-
+-    def _gen_op(self, N, dtype):
+-        return qutip.rand_unitary(N, dtype=dtype).data
+-
+-    def _gen_ket(self, N, dtype):
+-        return qutip.rand_ket(N, dtype=dtype).data
+-
+-    @pytest.mark.parametrize(['method', "opt"], [
+-        ("spsolve", {}),
+-        ("splu", {"csc": True}),
+-        ("gmres", {"atol": 1e-8}),
+-        ("lsqr", {}),
+-        pytest.param(
+-            "mkl_spsolve", {},
+-            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
+-        ),
+-    ],
+-        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
+-    )
+-    def test_mathematically_correct_CSR(self, method, opt):
+-        """
+-        Test that the binary operation is mathematically correct for all the
+-        known type specialisations.
+-        """
+-        A = self._gen_op(10, CSR)
+-        b = self._gen_ket(10, Dense)
+-        expected = self.op_numpy(A.to_array(), b.to_array())
+-        test = _data.solve_csr_dense(A, b, method, opt)
+-        test1 = _data.solve(A, b, method, opt)
+-
+-        assert test.shape == expected.shape
+-        np.testing.assert_allclose(test.to_array(), expected,
+-                                   atol=1e-7, rtol=1e-7)
+-        np.testing.assert_allclose(test1.to_array(), expected,
+-                                   atol=1e-7, rtol=1e-7)
+-
+-    @pytest.mark.parametrize(['method', "opt"], [
+-        ("solve", {}),
+-        ("lstsq", {}),
+-    ])
+-    def test_mathematically_correct_Dense(self, method, opt):
+-        A = self._gen_op(10, Dense)
+-        b = self._gen_ket(10, Dense)
+-        expected = self.op_numpy(A.to_array(), b.to_array())
+-        test = _data.solve_dense(A, b, method, opt)
+-        test1 = _data.solve(A, b, method, opt)
+-
+-        assert test.shape == expected.shape
+-        np.testing.assert_allclose(test.to_array(), expected,
+-                                   atol=1e-7, rtol=1e-7)
+-        np.testing.assert_allclose(test1.to_array(), expected,
+-                                   atol=1e-7, rtol=1e-7)
+-
+-
+-    def test_incorrect_shape_non_square(self):
+-        A = qutip.Qobj(np.random.rand(5, 10)).data
+-        b = qutip.Qobj(np.random.rand(10, 1)).data
+-        with pytest.raises(ValueError):
+-            test1 = _data.solve(A, b)
+-
+-
+-    def test_incorrect_shape_mismatch(self):
+-        A = qutip.Qobj(np.random.rand(10, 10)).data
+-        b = qutip.Qobj(np.random.rand(9, 1)).data
+-        with pytest.raises(ValueError):
+-            test1 = _data.solve(A, b)
+-
+-
+-class TestSVD():
+-    def op_numpy(self, A):
+-        return np.linalg.svd(A)
+-
+-    def _gen_dm(self, N, rank, dtype):
+-        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
+-
+-    def _gen_non_square(self, N):
+-        mat = np.random.randn(N, N//2)
+-        for i in range(N//2):
+-            # Ensure no zeros singular values
+-            mat[i,i] += 5
+-        return _data.Dense(mat)
+-
+-    @pytest.mark.parametrize("shape", ["square", "non-square"])
+-    def test_mathematically_correct_svd(self, shape):
+-        if shape == "square":
+-            matrix = self._gen_dm(10, 6, Dense)
+-        else:
+-            matrix = self._gen_non_square(12)
+-        u, s, v = self.op_numpy(matrix.to_array())
+-        test_U, test_S, test_V = _data.svd(matrix, True)
+-        only_S = _data.svd(matrix, False)
+-
+-        assert sum(test_S > 1e-10) == 6
+-        # columns are definied up to a sign
+-        np.testing.assert_allclose(
+-            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
+-        )
+-        # rows are definied up to a sign
+-        np.testing.assert_allclose(
+-            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
+-        )
+-        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
+-        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
+-
+-        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
+-
+-        np.testing.assert_allclose(
+-            matrix.to_array(),
+-            (test_U @ s_as_matrix @ test_V).to_array(),
+-            atol=1e-7, rtol=1e-7
+-        )
+-
+-    def test_mathematically_correct_svd_csr(self):
+-        rank = 5
+-        matrix = self._gen_dm(100, rank, CSR)
+-        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
+-        test_S2 = _data.svd_csr(matrix, False, k=rank)
+-
+-        assert len(test_S1) == rank
+-        assert len(test_S2) == rank
+-
+-        np.testing.assert_allclose(
+-            matrix.to_array(),
+-            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
+-            atol=1e-7, rtol=1e-7
+-        )
++import qutip.settings as settings
++import numpy as np
++import scipy
++import pytest
++import qutip
++
++from qutip.core import data as _data
++from qutip.core.data import Data, Dense, CSR
++
++
++class TestSolve():
++    def op_numpy(self, A, b):
++        return np.linalg.solve(A, b)
++
++    def _gen_op(self, N, dtype):
++        return qutip.rand_unitary(N, dtype=dtype).data
++
++    def _gen_ket(self, N, dtype):
++        return qutip.rand_ket(N, dtype=dtype).data
++
++    @pytest.mark.parametrize(['method', "opt"], [
++        ("spsolve", {}),
++        ("splu", {"csc": True}),
++        ("gmres", {"atol": 1e-8}),
++        ("lsqr", {}),
++        pytest.param(
++            "mkl_spsolve", {},
++            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
++        ),
++    ],
++        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
++    )
++    def test_mathematically_correct_CSR(self, method, opt):
++        """
++        Test that the binary operation is mathematically correct for all the
++        known type specialisations.
++        """
++        A = self._gen_op(10, CSR)
++        b = self._gen_ket(10, Dense)
++        expected = self.op_numpy(A.to_array(), b.to_array())
++        test = _data.solve_csr_dense(A, b, method, opt)
++        test1 = _data.solve(A, b, method, opt)
++
++        assert test.shape == expected.shape
++        np.testing.assert_allclose(test.to_array(), expected,
++                                   atol=1e-7, rtol=1e-7)
++        np.testing.assert_allclose(test1.to_array(), expected,
++                                   atol=1e-7, rtol=1e-7)
++
++    @pytest.mark.parametrize(['method', "opt"], [
++        ("solve", {}),
++        ("lstsq", {}),
++    ])
++    def test_mathematically_correct_Dense(self, method, opt):
++        A = self._gen_op(10, Dense)
++        b = self._gen_ket(10, Dense)
++        expected = self.op_numpy(A.to_array(), b.to_array())
++        test = _data.solve_dense(A, b, method, opt)
++        test1 = _data.solve(A, b, method, opt)
++
++        assert test.shape == expected.shape
++        np.testing.assert_allclose(test.to_array(), expected,
++                                   atol=1e-7, rtol=1e-7)
++        np.testing.assert_allclose(test1.to_array(), expected,
++                                   atol=1e-7, rtol=1e-7)
++
++
++    def test_incorrect_shape_non_square(self):
++        A = qutip.Qobj(np.random.rand(5, 10)).data
++        b = qutip.Qobj(np.random.rand(10, 1)).data
++        with pytest.raises(ValueError):
++            test1 = _data.solve(A, b)
++
++
++    def test_incorrect_shape_mismatch(self):
++        A = qutip.Qobj(np.random.rand(10, 10)).data
++        b = qutip.Qobj(np.random.rand(9, 1)).data
++        with pytest.raises(ValueError):
++            test1 = _data.solve(A, b)
++
++
++class TestSVD():
++    def op_numpy(self, A):
++        return np.linalg.svd(A)
++
++    def _gen_dm(self, N, rank, dtype):
++        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
++
++    def _gen_non_square(self, N):
++        mat = np.random.randn(N, N//2)
++        for i in range(N//2):
++            # Ensure no zeros singular values
++            mat[i,i] += 5
++        return _data.Dense(mat)
++
++    @pytest.mark.parametrize("shape", ["square", "non-square"])
++    def test_mathematically_correct_svd(self, shape):
++        if shape == "square":
++            matrix = self._gen_dm(10, 6, Dense)
++        else:
++            matrix = self._gen_non_square(12)
++        u, s, v = self.op_numpy(matrix.to_array())
++        test_U, test_S, test_V = _data.svd(matrix, True)
++        only_S = _data.svd(matrix, False)
++
++        assert sum(test_S > 1e-10) == 6
++        # columns are definied up to a sign
++        np.testing.assert_allclose(
++            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
++        )
++        # rows are definied up to a sign
++        np.testing.assert_allclose(
++            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
++        )
++        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
++        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
++
++        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
++
++        np.testing.assert_allclose(
++            matrix.to_array(),
++            (test_U @ s_as_matrix @ test_V).to_array(),
++            atol=1e-7, rtol=1e-7
++        )
++
++    def test_mathematically_correct_svd_csr(self):
++        rank = 5
++        matrix = self._gen_dm(100, rank, CSR)
++        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
++        test_S2 = _data.svd_csr(matrix, False, k=rank)
++
++        assert len(test_S1) == rank
++        assert len(test_S2) == rank
++
++        np.testing.assert_allclose(
++            matrix.to_array(),
++            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
++            atol=1e-7, rtol=1e-7
++        )
+diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
+index 459ab0d4..dfe3fe8a 100644
+--- a/qutip/tests/core/data/test_mathematics.py
++++ b/qutip/tests/core/data/test_mathematics.py
+@@ -1,952 +1,952 @@
+-import itertools
+-import numpy as np
+-import scipy
+-import pytest
+-
+-from qutip.core import data
+-from qutip.core.data import Data, Dense, CSR
+-
+-from . import conftest
+-
+-# The ParameterSet is actually a pretty hidden type, so it's easiest to access
+-# it like this.
+-_ParameterSet = type(pytest.param())
+-
+-# First set up a bunch of allowable shapes, for different types of functions so
+-# we don't have to respecify a whole lot of things on repeat.
+-
+-
+-def shapes_unary(dim=100):
+-    """Base shapes to test for unary functions."""
+-    # Be sure to test a full spectrum bra-type, ket-type and square and
+-    # non-square operators.  Keep the dimension sensible, particularly for
+-    # things like kron, since these shapes are reused to build the shapes for
+-    # higher-order functions too.
+-    return [
+-        pytest.param((1, 1), id="scalar"),
+-        pytest.param((1, dim), id="bra"),
+-        pytest.param((dim, 1), id="ket"),
+-        pytest.param((dim, dim), id="square"),
+-        pytest.param((2, dim), id="nonsquare"),
+-    ]
+-
+-
+-def shapes_binary_identical(dim=100):
+-    """
+-    Allowed shapes for binary operators that need the two matrices to be the
+-    same shape, e.g. addition.
+-    """
+-    return [(x, x) for x in shapes_unary(dim)]
+-
+-
+-def shapes_binary_bad_identical(dim=100):
+-    """
+-    Disallowed shapes for binary operators that need the two matrices to be the
+-    same shape, e.g. addition.
+-    """
+-    return [
+-        (x, y)
+-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+-        if x.values[0] != y.values[0]
+-    ]
+-
+-
+-def shapes_binary_unrestricted(dim=100):
+-    """
+-    Allowed shapes for binary operators which can take any shapes, e.g. the
+-    Kronecker product.
+-    """
+-    return list(itertools.product(shapes_unary(dim), repeat=2))
+-
+-
+-def shapes_binary_bad_unrestricted(dim=100):
+-    """
+-    Disallowed shapes for binary operators which can take any shapes, e.g. the
+-    Kronecker product.  There aren't actually any of these, but we keep it just
+-    for consistency.
+-    """
+-    return []
+-
+-
+-def shapes_binary_matmul(dim=100):
+-    """
+-    Allowed shapes for "matmul"-like operators that require that the "inner"
+-    two indices are equal, i.e. the columns on the left equal the rows on the
+-    right.
+-    """
+-    return [
+-        (x, y)
+-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+-        if x.values[0][1] == y.values[0][0]
+-    ]
+-
+-
+-def shapes_binary_bad_matmul(dim=100):
+-    """
+-    Disallowed shapes for "matmul"-like operators that require that the "inner"
+-    two indices are equal, i.e. the columns on the left equal the rows on the
+-    right.
+-    """
+-    return [
+-        (x, y)
+-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+-        if x.values[0][1] != y.values[0][0]
+-    ]
+-
+-
+-def shapes_square(dim=100):
+-    """Allowed shapes for operations that require square matrices. Examples of
+-    these operations are trace, pow, expm and the trace norm."""
+-    return [
+-        (pytest.param((1, 1), id="1"),),
+-        (pytest.param((dim, dim), id=str(dim)),),
+-    ]
+-
+-
+-def shapes_not_square(dim=100):
+-    """Disallowed shapes for operations that require square matrices. Examples
+-    of these operations are trace, pow, expm and the trace norm."""
+-    return [
+-        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
+-    ]
+-
+-
+-# Set up the special cases for each type of matrix that will be tested.  These
+-# should be kept low, because mathematical operations will test a Cartesian
+-# product of all the cases of the same order as the operation, which can get
+-# very large very fast.  The operations should each complete in a small amount
+-# of time, so having 10000+ tests in this file still ought to take less than 2
+-# minutes, but it's easy to accidentally add orders of magnitude on.
+-#
+-# There is a layer of indirection---the cases are returned as 0-ary generator
+-# closures---for two reasons:
+-#   1. we don't have to store huge amounts of data at test collection time, but
+-#      the matrices are only generated, and subsequently freed, within in each
+-#      individual test.
+-#   2. each test can be repeated, and new random matrices will be generated for
+-#      each repeat, rather than re-using the same set.  This is somewhat
+-#      "defeating" pytest fixtures, but here we're not worried about re-usable
+-#      inputs, we just want the managed parametrisation.
+-
+-def cases_csr(shape):
+-    """
+-    Return a list of generators of the different special cases for CSR
+-    matrices of a given shape.
+-    """
+-    def factory(density, sort):
+-        return lambda: conftest.random_csr(shape, density, sort)
+-
+-    def zero_factory():
+-        return lambda: data.csr.zeros(shape[0], shape[1])
+-    return [
+-        pytest.param(factory(0.001, True), id="sparse"),
+-        pytest.param(factory(0.8, True), id="filled,sorted"),
+-        pytest.param(factory(0.8, False), id="filled,unsorted"),
+-        pytest.param(zero_factory(), id="zero"),
+-    ]
+-
+-
+-def cases_dense(shape):
+-    """
+-    Return a list of generators of the different special cases for Dense
+-    matrices of a given shape.
+-    """
+-    def factory(fortran):
+-        return lambda: conftest.random_dense(shape, fortran)
+-    return [
+-        pytest.param(factory(False), id="C"),
+-        pytest.param(factory(True), id="Fortran"),
+-    ]
+-
+-
+-# Factory methods for generating the cases, mapping type to the function.
+-# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
+-# getting just a single case from each.
+-_ALL_CASES = {
+-    CSR: cases_csr,
+-    Dense: cases_dense,
+-}
+-_RANDOM = {
+-    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
+-    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
+-}
+-
+-
+-def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
+-    """
+-    Return a list of `pytest.ParameterSet` which is a flat list of all the
+-    special cases that should be tested for this operator specialisation `op`,
+-    which takes in several types `types`, where the arguments have shapes taken
+-    from the iterable of iterables `shapes`.  If `out_type` is specified, it
+-    will be added into the output parameter set and its name added to the id,
+-    but is otherwise not used.
+-
+-    Parameters
+-    ----------
+-    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
+-        Mapping to get the special case generator from.  This is one of
+-        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
+-        from the case generator should all be closures of the form `() -> Data`
+-        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
+-        containing exactly one value, which is the same closure type.
+-
+-    op: Function
+-        The specialisation of a mathematical operation that is being tested.
+-        This is actually generally unused - it's just added in to the output
+-        ParameterSet at the end so that it will get correctly parametrised.
+-
+-    types: Tuple[Type]
+-        A tuple of data.Data subclass types (not instances).  This defines the
+-        inputs to this particular specialisation under test.  There should be
+-        as many types as there are Data arguments to `op`.
+-
+-    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
+-        An iterable containing several sets of shapes to parameterise over.
+-        Each element of the iterable should be s tuple of shapes, or
+-        `pytest.ParameterSet` instances each containing a single shape.  A
+-        shape is a 2-tuple of integers.  There should be as many elements of
+-        this inner tuple as there are `types`, since each individual `shape`
+-        goes with a `type`.
+-
+-    out_type: Type
+-        The output type for this specialisation.  Not used other than its name
+-        being added to the id, and it being added at the end of the
+-        specialisation (if it is given), similarly to `op`.
+-
+-    Returns
+-    -------
+-    List[ParameterSet]
+-        A list of individual test cases for parametrisation.  Each ParameterSet
+-        will be
+-            [op, *data_inputs, ?out_type]
+-        where `data_inputs` is of the same length as the input parameter
+-        `types` and represents the Data arguments to the specialisation `op`.
+-        Each element of `data_inputs` is a generator function which takes no
+-        arguments and returns a data.Data subclass of the correct type and
+-        shape.  `out_type` is present in the output only if it were given as a
+-        parameter itself.
+-    """
+-    def case(type_, shape_case, generator_case):
+-        """
+-        Build a case parameter for _one_ generator function which will return
+-        a given type and shape.
+-        """
+-        id_ = type_.__name__
+-        inner = ""
+-        for extra in [shape_case, generator_case]:
+-            if hasattr(extra, 'id') and extra.id:
+-                inner += ("," if inner else "") + extra.id
+-        if inner:
+-            id_ += "[" + inner + "]"
+-        func = (
+-            generator_case.values[0]
+-            if isinstance(generator_case, _ParameterSet)
+-            else generator_case
+-        )
+-        return pytest.param(func, id=id_)
+-
+-    cases = []
+-    for shapes_ in shapes:
+-        # Convert the list of types into a list of lists of the special cases
+-        # needed for each type.
+-        matrix_cases = [
+-            [case(type_, shape_case, type_case)
+-             for type_case in cases_lookup[type_](shape_case.values[0])]
+-            for type_, shape_case in zip(types, shapes_)
+-        ]
+-        # Now Cartesian product all the special cases together to make the full
+-        # set of parametrisations.
+-        for matrices in itertools.product(*matrix_cases):
+-            id_ = ",".join(m.id for m in matrices)
+-            args = [m for p_m in matrices for m in p_m.values]
+-            if out_type is not None:
+-                id_ += "->" + out_type.__name__
+-                args += [out_type]
+-            cases.append(pytest.param(op, *args, id=id_))
+-    return cases
+-
+-
+-# Now we start to actually build up all the test cases.  Since all the
+-# mathematical operations are really pretty similar, and most just need the
+-# basic testing functionality, we do this with a series of mix-in classes which
+-# provide various components of the testing and test-generation infrastructure.
+-#
+-# In each, we use the idiom that "test_<x>" is a test function which pytest
+-# will collect for us, and "generate_<x>" a method which will be called by
+-# `pytest_generate_tests` in order to generate all the parametrisations for the
+-# given test.
+-
+-class _GenericOpMixin:
+-    """
+-    Abstract base mix-in which sets up the test generation for the two basic
+-    test operations, and puts in the very generic test generator.  This does
+-    not actually define the tests themselves, because subclasses need to define
+-    them so the method arguments can be introspected to parametrise over the
+-    correct number of arguments.
+-
+-    The tests `mathematically_correct` and `incorrect_shape_raises` will
+-    parametrise Data types over method arguments which have names `data_*`.
+-
+-    The class arguments defined here are effectively parametrising the
+-    mathematical tests.
+-
+-    Attributes
+-    ----------
+-    op_numpy: *args -> np.ndarray
+-        Function which takes the same arguments as the mathematical operation,
+-        but with all data arguments numpy arrays, and returns the expected
+-        result.
+-
+-    atol: float
+-        The absolute tolerance to use when comparing the test value with the
+-        expected value.  If the output is a Data type, the tolerance is
+-        per-element of the output.
+-
+-    rtol: float
+-        The relative tolerance to use when comparing the test value with the
+-        expected value.  If the output is a Data type, the tolerance is
+-        per-element of the output.
+-
+-    shapes: list of (list of shapes)
+-        A list of the sets of shapes which should be used for the tests of
+-        mathematical correctness.  Each element of the list is a set of shapes,
+-        each one corresponding to one of the arguments of the operation.
+-
+-    bad_shapes: list of (list of shapes)
+-        Similar to `shapes`, but these should be shapes which are invalid for
+-        the given mathematical operation.
+-
+-    specialisations: list of (function, Type, Type, [Type, ...])
+-        The specialisations of each mathematical function, and the types that
+-        it takes in and returns.  For example, the function
+-            add(CSR, Dense) -> Other
+-        would be specified as `(add, CSR, Dense, Other)`.
+-    """
+-    def op_numpy(self, *args): raise NotImplementedError
+-    # With dimensions of around 100, we have to account for floating-point
+-    # addition not being associative; the maths on full numpy arrays will often
+-    # produce slightly different results to sparse algebra, since the order of
+-    # multiplications and additions will be different.
+-    atol = 1e-10
+-    rtol = 1e-7  # Same default as numpy
+-    shapes = []
+-    bad_shapes = []
+-    specialisations = []
+-
+-    def generate_mathematically_correct(self, metafunc):
+-        parameters = (
+-            ['op']
+-            + [x for x in metafunc.fixturenames
+-               if x.startswith("data_")]
+-            + ['out_type']
+-        )
+-        cases = []
+-        for p_op in self.specialisations:
+-            op, *types, out_type = p_op.values
+-            args = (op, types, self.shapes, out_type)
+-            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
+-        metafunc.parametrize(parameters, cases)
+-
+-    def generate_incorrect_shape_raises(self, metafunc):
+-        parameters = (
+-            ['op']
+-            + [x for x in metafunc.fixturenames
+-               if x.startswith("data_")]
+-        )
+-        if not self.bad_shapes:
+-            reason = "".join([
+-                "no shapes are 'incorrect' for ",
+-                metafunc.cls.__name__,
+-                "::",
+-                metafunc.function.__name__,
+-            ])
+-            false_case = pytest.param(*([None]*len(parameters)),
+-                                      marks=pytest.mark.skip(reason),
+-                                      id="no test")
+-            metafunc.parametrize(parameters, [false_case])
+-            return
+-        cases = []
+-        for p_op in self.specialisations:
+-            op, *types, _ = p_op.values
+-            args = (op, types, self.bad_shapes)
+-            cases.extend(cases_type_shape_product(_RANDOM, *args))
+-        metafunc.parametrize(parameters, cases)
+-
+-    def pytest_generate_tests(self, metafunc):
+-        # For every test function "test_xyz", we use the test generator
+-        # "generate_xyz" if it exists.  This allows derived classes to add
+-        # their own tests and generators without overiding this method, cutting
+-        # down on boilerplate, but also that derived classes _may_ override the
+-        # generation of tests defined in a base class, say if they have
+-        # additional special arguments that need parametrising over.
+-        generator_name = (
+-            "generate_"
+-            + metafunc.function.__name__.replace("test_", "")
+-        )
+-        try:
+-            generator = getattr(self, generator_name)
+-        except AttributeError:
+-            return
+-        generator(metafunc)
+-
+-
+-class UnaryOpMixin(_GenericOpMixin):
+-    """
+-    Mix-in for unary mathematical operations on Data instances (e.g. unary
+-    negation).
+-    """
+-    shapes = [(x,) for x in shapes_unary()]
+-    bad_shapes = []
+-
+-    def test_mathematically_correct(self, op, data_m, out_type):
+-        matrix = data_m()
+-        expected = self.op_numpy(matrix.to_array())
+-        test = op(matrix)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol, rtol=self.rtol)
+-        elif out_type is list:
+-            for test_, expected_ in zip(test, expected):
+-                assert test_.shape == expected_.shape
+-                np.testing.assert_allclose(test_.to_array(), expected_,
+-                                           atol=self.atol, rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-    def test_incorrect_shape_raises(self, op, data_m):
+-        """
+-        Test that the operation produces a suitable error if the shape of the
+-        given operand is not compatible with the operation. Useful for
+-        operations that require square matrices (trace, pow, ...).
+-        """
+-        with pytest.raises(ValueError):
+-            op(data_m())
+-
+-
+-class UnaryScalarOpMixin(_GenericOpMixin):
+-    """
+-    Mix-in for unary mathematical operations on Data instances, but that also
+-    take in a numeric scalar (e.g. scalar multiplication).  Only generates
+-    the test `mathematically_correct`, since there can't be a shape mismatch
+-    when there's only one Data argument.
+-    """
+-    shapes = [(x,) for x in shapes_unary()]
+-
+-    @pytest.mark.parametrize('scalar', [
+-        pytest.param(0, id='zero'),
+-        pytest.param(4.5, id='real'),
+-        pytest.param(3j, id='complex'),
+-    ])
+-    def test_mathematically_correct(self, op, data_m, scalar, out_type):
+-        matrix = data_m()
+-        expected = self.op_numpy(matrix.to_array(), scalar)
+-        test = op(matrix, scalar)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol,
+-                                       rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-
+-class BinaryOpMixin(_GenericOpMixin):
+-    """
+-    Mix-in for binary mathematical operations on Data instances (e.g. binary
+-    addition).
+-    """
+-    def test_mathematically_correct(self, op, data_l, data_r, out_type):
+-        """
+-        Test that the binary operation is mathematically correct for all the
+-        known type specialisations.
+-        """
+-        left, right = data_l(), data_r()
+-        expected = self.op_numpy(left.to_array(), right.to_array())
+-        test = op(left, right)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol, rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-    def test_incorrect_shape_raises(self, op, data_l, data_r):
+-        """
+-        Test that the operation produces a suitable error if the shapes of the
+-        given operands are not compatible.
+-        """
+-        with pytest.raises(ValueError):
+-            op(data_l(), data_r())
+-
+-
+-class TernaryOpMixin(_GenericOpMixin):
+-    """
+-    Mix-in for ternary mathematical operations on Data instances (e.g. inner
+-    product with an operator in the middle).  This is pretty rare.
+-    """
+-    def test_mathematically_correct(self, op,
+-                                    data_l, data_m, data_r,
+-                                    out_type):
+-        """
+-        Test that the binary operation is mathematically correct for all the
+-        known type specialisations.
+-        """
+-        left, mid, right = data_l(), data_m(), data_r()
+-        expected = self.op_numpy(left.to_array(),
+-                                 mid.to_array(),
+-                                 right.to_array())
+-        test = op(left, mid, right)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol, rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
+-        """
+-        Test that the operation produces a suitable error if the shapes of the
+-        given operands are not compatible.
+-        """
+-        with pytest.raises(ValueError):
+-            op(data_l(), data_m(), data_r())
+-
+-
+-# And now finally we get into the meat of the actual mathematical tests.
+-
+-class TestAdd(BinaryOpMixin):
+-    def op_numpy(self, left, right, scale):
+-        return np.add(left, scale * right)
+-
+-    shapes = shapes_binary_identical()
+-    bad_shapes = shapes_binary_bad_identical()
+-    specialisations = [
+-        pytest.param(data.add_csr, CSR, CSR, CSR),
+-        pytest.param(data.add_dense, Dense, Dense, Dense),
+-    ]
+-
+-    # `add` has an additional scalar parameter, because the operation is
+-    # actually more like `A + c*B`.  We just parametrise that scalar
+-    # separately.
+-    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
+-                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
+-    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
+-        """
+-        Test that the binary operation is mathematically correct for all the
+-        known type specialisations.
+-        """
+-        left, right = data_l(), data_r()
+-        if scale is not None:
+-            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
+-            test = op(left, right, scale)
+-        else:
+-            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
+-            test = op(left, right)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol, rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-
+-class TestAdjoint(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return np.conj(matrix.T)
+-
+-    specialisations = [
+-        pytest.param(data.adjoint_csr, CSR, CSR),
+-        pytest.param(data.adjoint_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestConj(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return np.conj(matrix)
+-
+-    specialisations = [
+-        pytest.param(data.conj_csr, CSR, CSR),
+-        pytest.param(data.conj_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestInner(BinaryOpMixin):
+-    # The inner product is a bit more specialist, since it has to handle inputs
+-    # in a 1D space specially.  In order to keep things simple, we just
+-    # generate those test cases completely separately from the standard
+-    # `mathematically_correct`.
+-
+-    def op_numpy(self, left, right, scalar_is_ket=False):
+-        if left.shape[1] == 1:
+-            if left.shape[0] != 1 or scalar_is_ket:
+-                left = np.conj(left.T)
+-        return (left @ right)[0, 0]
+-
+-    # These shapes are a little more non-standard.
+-    _dim = 100
+-    _scalar = pytest.param((1, 1), id="scalar")
+-    _bra = pytest.param((1, _dim), id="bra")
+-    _ket = pytest.param((_dim, 1), id="ket")
+-    _op = pytest.param((_dim, _dim), id="square")
+-    shapes = [
+-        (_bra, _ket),
+-        (_ket, _ket),
+-    ]
+-    bad_shapes = [
+-        (_bra, _bra),
+-        (_ket, _bra),
+-        (_op, _ket),
+-        (_op, _bra),
+-        (_bra, _op),
+-        (_ket, _op),
+-    ]
+-
+-    specialisations = [
+-        pytest.param(data.inner_csr, CSR, CSR, complex),
+-        pytest.param(data.inner_dense, Dense, Dense, complex),
+-    ]
+-
+-    def generate_scalar_is_ket(self, metafunc):
+-        # For 1D subspaces, the special cases don't really matter since there's
+-        # only really one type of matrix available, so this is parametrised
+-        # with only case for each input argument.
+-        parameters = (
+-            ['op']
+-            + [x for x in metafunc.fixturenames
+-               if x.startswith("data_")]
+-            + ['out_type']
+-        )
+-        cases = []
+-        for p_op in self.specialisations:
+-            op, *types, out_type = p_op.values
+-            args = (op, types, [(self._scalar, self._scalar)], out_type)
+-            cases.extend(cases_type_shape_product(_RANDOM, *args))
+-        metafunc.parametrize(parameters, cases)
+-        metafunc.parametrize('scalar_is_ket',
+-                             [True, False],
+-                             ids=["ket", "bra"])
+-
+-    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
+-        left, right = data_l(), data_r()
+-        expected = self.op_numpy(left.to_array(), right.to_array(),
+-                                 scalar_is_ket)
+-        test = op(left, right, scalar_is_ket)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol, rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-
+-class TestInnerOp(TernaryOpMixin):
+-    # This is very very similar to TestInner.
+-    def op_numpy(self, left, mid, right, scalar_is_ket=False):
+-        if left.shape[1] == 1:
+-            if left.shape[0] != 1 or scalar_is_ket:
+-                left = np.conj(left.T)
+-        return (left @ mid @ right)[0, 0]
+-
+-    _dim = 100
+-    _scalar = pytest.param((1, 1), id="scalar")
+-    _bra = pytest.param((1, _dim), id="bra")
+-    _ket = pytest.param((_dim, 1), id="ket")
+-    _op = pytest.param((_dim, _dim), id="square")
+-    shapes = [
+-        (_bra, _op, _ket),
+-        (_ket, _op, _ket),
+-    ]
+-    bad_shapes = [
+-        (_bra, _op, _bra),
+-        (_ket, _op, _bra),
+-        (_op, _op, _ket),
+-        (_op, _op, _bra),
+-        (_bra, _op, _op),
+-        (_ket, _op, _op),
+-        (_bra, _bra, _ket),
+-        (_ket, _bra, _ket),
+-        (_bra, _ket, _ket),
+-        (_ket, _ket, _ket),
+-    ]
+-
+-    specialisations = [
+-        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
+-        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
+-    ]
+-
+-    def generate_scalar_is_ket(self, metafunc):
+-        parameters = (
+-            ['op']
+-            + [x for x in metafunc.fixturenames
+-               if x.startswith("data_")]
+-            + ['out_type']
+-        )
+-        cases = []
+-        for p_op in self.specialisations:
+-            op, *types, out_type = p_op.values
+-            args = (op, types, [(self._scalar,) * 3], out_type)
+-            cases.extend(cases_type_shape_product(_RANDOM, *args))
+-        metafunc.parametrize(parameters, cases)
+-        metafunc.parametrize('scalar_is_ket',
+-                             [True, False], ids=["ket", "bra"])
+-
+-    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
+-                           scalar_is_ket):
+-        left, mid, right = data_l(), data_m(), data_r()
+-        expected = self.op_numpy(left.to_array(),
+-                                 mid.to_array(),
+-                                 right.to_array(),
+-                                 scalar_is_ket)
+-        test = op(left, mid, right, scalar_is_ket)
+-        assert isinstance(test, out_type)
+-        if issubclass(out_type, Data):
+-            assert test.shape == expected.shape
+-            np.testing.assert_allclose(test.to_array(), expected,
+-                                       atol=self.atol,
+-                                       rtol=self.rtol)
+-        else:
+-            np.testing.assert_allclose(test, expected, atol=self.atol,
+-                                       rtol=self.rtol)
+-
+-
+-class TestKron(BinaryOpMixin):
+-    def op_numpy(self, left, right):
+-        return np.kron(left, right)
+-
+-    # Keep the dimension low because kron can get very expensive.
+-    shapes = shapes_binary_unrestricted(dim=5)
+-    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
+-    specialisations = [
+-        pytest.param(data.kron_csr, CSR, CSR, CSR),
+-        pytest.param(data.kron_dense, Dense, Dense, Dense),
+-    ]
+-
+-
+-class TestMatmul(BinaryOpMixin):
+-    def op_numpy(self, left, right):
+-        return np.matmul(left, right)
+-
+-    shapes = shapes_binary_matmul()
+-    bad_shapes = shapes_binary_bad_matmul()
+-    specialisations = [
+-        pytest.param(data.matmul_csr, CSR, CSR, CSR),
+-        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
+-        pytest.param(data.matmul_dense, Dense, Dense, Dense),
+-    ]
+-
+-
+-class TestMultiply(BinaryOpMixin):
+-    def op_numpy(self, left, right):
+-        return left * right
+-
+-    shapes = shapes_binary_identical()
+-    bad_shapes = shapes_binary_bad_identical()
+-    specialisations = [
+-        pytest.param(data.multiply_csr, CSR, CSR, CSR),
+-        pytest.param(data.multiply_dense, Dense, Dense, Dense),
+-    ]
+-
+-
+-class TestMul(UnaryScalarOpMixin):
+-    def op_numpy(self, matrix, scalar):
+-        return scalar * matrix
+-
+-    specialisations = [
+-        pytest.param(data.mul_csr, CSR, CSR),
+-        pytest.param(data.mul_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestNeg(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return -matrix
+-
+-    specialisations = [
+-        pytest.param(data.neg_csr, CSR, CSR),
+-        pytest.param(data.neg_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestSub(BinaryOpMixin):
+-    def op_numpy(self, left, right):
+-        return left - right
+-
+-    shapes = shapes_binary_identical()
+-    bad_shapes = shapes_binary_bad_identical()
+-    specialisations = [
+-        pytest.param(data.sub_csr, CSR, CSR, CSR),
+-        pytest.param(data.sub_dense, Dense, Dense, Dense),
+-    ]
+-
+-
+-class TestTrace(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return np.sum(np.diag(matrix))
+-
+-    shapes = shapes_square()
+-    bad_shapes = shapes_not_square()
+-    specialisations = [
+-        pytest.param(data.trace_csr, CSR, complex),
+-        pytest.param(data.trace_dense, Dense, complex),
+-    ]
+-
+-
+-class TestTrace_oper_ket(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        N = int(matrix.shape[0] ** 0.5)
+-        return np.sum(np.diag(matrix.reshape((N, N))))
+-
+-    shapes = [
+-        (pytest.param((100, 1), id="oper-ket"),),
+-    ]
+-    bad_shapes = [
+-        (pytest.param((1, 100), id="bra"),),
+-        (pytest.param((99, 1), id="ket"),),
+-        (pytest.param((99, 99), id="ket"),),
+-        (pytest.param((2, 99), id="nonsquare"),),
+-    ]
+-    specialisations = [
+-        pytest.param(data.trace_oper_ket_csr, CSR, complex),
+-        pytest.param(data.trace_oper_ket_dense, Dense, complex),
+-    ]
+-
+-
+-class TestPow(UnaryOpMixin):
+-    def op_numpy(self, matrix, n):
+-        return np.linalg.matrix_power(matrix, n)
+-
+-    shapes = shapes_square()
+-    bad_shapes = shapes_not_square()
+-    specialisations = [
+-        pytest.param(data.pow_csr, CSR, CSR),
+-        pytest.param(data.pow_dense, Dense, Dense),
+-    ]
+-
+-    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
+-    def test_mathematically_correct(self, op, data_m, out_type, n):
+-        matrix = data_m()
+-        expected = self.op_numpy(matrix.to_array(), n)
+-        test = op(matrix, n)
+-        assert isinstance(test, out_type)
+-        assert test.shape == expected.shape
+-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+-                                   rtol=self.rtol)
+-
+-    # Pow actually does have bad shape, so we put that in too.
+-    def test_incorrect_shape_raises(self, op, data_m):
+-        """
+-        Test that the operation produces a suitable error if the shape is not a
+-        square matrix.
+-        """
+-        with pytest.raises(ValueError):
+-            op(data_m(), 10)
+-
+-
+-class TestExpm(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return scipy.linalg.expm(matrix)
+-
+-    shapes = shapes_square()
+-    bad_shapes = shapes_not_square()
+-    specialisations = [
+-        pytest.param(data.expm_csr, CSR, CSR),
+-        pytest.param(data.expm_csr_dense, CSR, Dense),
+-        pytest.param(data.expm_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestLogm(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return scipy.linalg.logm(matrix)
+-
+-    shapes = shapes_square()
+-    bad_shapes = shapes_not_square()
+-    specialisations = [
+-        pytest.param(data.logm_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestTranspose(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return matrix.T
+-
+-    specialisations = [
+-        pytest.param(data.transpose_csr, CSR, CSR),
+-        pytest.param(data.transpose_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestProject(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        if matrix.shape[0] == 1:
+-            return np.outer(np.conj(matrix), matrix)
+-        else:
+-            return np.outer(matrix, np.conj(matrix))
+-
+-    shapes = [
+-        (pytest.param((1, 1), id="scalar"),),
+-        (pytest.param((1, 100), id="bra"),),
+-        (pytest.param((100, 1), id="ket"),),
+-    ]
+-    bad_shapes = [
+-        (pytest.param((10, 10), id="square"),),
+-        (pytest.param((2, 10), id="nonsquare"),),
+-    ]
+-
+-    specialisations = [
+-        pytest.param(data.project_csr, CSR, CSR),
+-        pytest.param(data.project_dense, Dense, Dense),
+-    ]
+-
+-
+-def _inv_dense(matrix):
+-    # Add a diagonal so `matrix` is not singular
+-    return data.inv_dense(
+-        data.add(
+-            matrix,
+-            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
+-        )
+-    )
+-
+-
+-def _inv_csr(matrix):
+-    # Add a diagonal so `matrix` is not singular
+-    return data.inv_csr(
+-        data.add(
+-            matrix,
+-            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
+-        )
+-    )
+-
+-
+-class TestInv(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
+-
+-    shapes = [
+-        (pytest.param((1, 1), id="scalar"),),
+-        (pytest.param((10, 10), id="square"),),
+-    ]
+-    bad_shapes = [
+-        (pytest.param((2, 10), id="nonsquare"),),
+-        (pytest.param((1, 100), id="bra"),),
+-        (pytest.param((100, 1), id="ket"),),
+-    ]
+-
+-    specialisations = [
+-        pytest.param(_inv_csr, CSR, CSR),
+-        pytest.param(_inv_dense, Dense, Dense),
+-    ]
++import itertools
++import numpy as np
++import scipy
++import pytest
++
++from qutip.core import data
++from qutip.core.data import Data, Dense, CSR
++
++from . import conftest
++
++# The ParameterSet is actually a pretty hidden type, so it's easiest to access
++# it like this.
++_ParameterSet = type(pytest.param())
++
++# First set up a bunch of allowable shapes, for different types of functions so
++# we don't have to respecify a whole lot of things on repeat.
++
++
++def shapes_unary(dim=100):
++    """Base shapes to test for unary functions."""
++    # Be sure to test a full spectrum bra-type, ket-type and square and
++    # non-square operators.  Keep the dimension sensible, particularly for
++    # things like kron, since these shapes are reused to build the shapes for
++    # higher-order functions too.
++    return [
++        pytest.param((1, 1), id="scalar"),
++        pytest.param((1, dim), id="bra"),
++        pytest.param((dim, 1), id="ket"),
++        pytest.param((dim, dim), id="square"),
++        pytest.param((2, dim), id="nonsquare"),
++    ]
++
++
++def shapes_binary_identical(dim=100):
++    """
++    Allowed shapes for binary operators that need the two matrices to be the
++    same shape, e.g. addition.
++    """
++    return [(x, x) for x in shapes_unary(dim)]
++
++
++def shapes_binary_bad_identical(dim=100):
++    """
++    Disallowed shapes for binary operators that need the two matrices to be the
++    same shape, e.g. addition.
++    """
++    return [
++        (x, y)
++        for x, y in itertools.product(shapes_unary(dim), repeat=2)
++        if x.values[0] != y.values[0]
++    ]
++
++
++def shapes_binary_unrestricted(dim=100):
++    """
++    Allowed shapes for binary operators which can take any shapes, e.g. the
++    Kronecker product.
++    """
++    return list(itertools.product(shapes_unary(dim), repeat=2))
++
++
++def shapes_binary_bad_unrestricted(dim=100):
++    """
++    Disallowed shapes for binary operators which can take any shapes, e.g. the
++    Kronecker product.  There aren't actually any of these, but we keep it just
++    for consistency.
++    """
++    return []
++
++
++def shapes_binary_matmul(dim=100):
++    """
++    Allowed shapes for "matmul"-like operators that require that the "inner"
++    two indices are equal, i.e. the columns on the left equal the rows on the
++    right.
++    """
++    return [
++        (x, y)
++        for x, y in itertools.product(shapes_unary(dim), repeat=2)
++        if x.values[0][1] == y.values[0][0]
++    ]
++
++
++def shapes_binary_bad_matmul(dim=100):
++    """
++    Disallowed shapes for "matmul"-like operators that require that the "inner"
++    two indices are equal, i.e. the columns on the left equal the rows on the
++    right.
++    """
++    return [
++        (x, y)
++        for x, y in itertools.product(shapes_unary(dim), repeat=2)
++        if x.values[0][1] != y.values[0][0]
++    ]
++
++
++def shapes_square(dim=100):
++    """Allowed shapes for operations that require square matrices. Examples of
++    these operations are trace, pow, expm and the trace norm."""
++    return [
++        (pytest.param((1, 1), id="1"),),
++        (pytest.param((dim, dim), id=str(dim)),),
++    ]
++
++
++def shapes_not_square(dim=100):
++    """Disallowed shapes for operations that require square matrices. Examples
++    of these operations are trace, pow, expm and the trace norm."""
++    return [
++        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
++    ]
++
++
++# Set up the special cases for each type of matrix that will be tested.  These
++# should be kept low, because mathematical operations will test a Cartesian
++# product of all the cases of the same order as the operation, which can get
++# very large very fast.  The operations should each complete in a small amount
++# of time, so having 10000+ tests in this file still ought to take less than 2
++# minutes, but it's easy to accidentally add orders of magnitude on.
++#
++# There is a layer of indirection---the cases are returned as 0-ary generator
++# closures---for two reasons:
++#   1. we don't have to store huge amounts of data at test collection time, but
++#      the matrices are only generated, and subsequently freed, within in each
++#      individual test.
++#   2. each test can be repeated, and new random matrices will be generated for
++#      each repeat, rather than re-using the same set.  This is somewhat
++#      "defeating" pytest fixtures, but here we're not worried about re-usable
++#      inputs, we just want the managed parametrisation.
++
++def cases_csr(shape):
++    """
++    Return a list of generators of the different special cases for CSR
++    matrices of a given shape.
++    """
++    def factory(density, sort):
++        return lambda: conftest.random_csr(shape, density, sort)
++
++    def zero_factory():
++        return lambda: data.csr.zeros(shape[0], shape[1])
++    return [
++        pytest.param(factory(0.001, True), id="sparse"),
++        pytest.param(factory(0.8, True), id="filled,sorted"),
++        pytest.param(factory(0.8, False), id="filled,unsorted"),
++        pytest.param(zero_factory(), id="zero"),
++    ]
++
++
++def cases_dense(shape):
++    """
++    Return a list of generators of the different special cases for Dense
++    matrices of a given shape.
++    """
++    def factory(fortran):
++        return lambda: conftest.random_dense(shape, fortran)
++    return [
++        pytest.param(factory(False), id="C"),
++        pytest.param(factory(True), id="Fortran"),
++    ]
++
++
++# Factory methods for generating the cases, mapping type to the function.
++# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
++# getting just a single case from each.
++_ALL_CASES = {
++    CSR: cases_csr,
++    Dense: cases_dense,
++}
++_RANDOM = {
++    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
++    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
++}
++
++
++def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
++    """
++    Return a list of `pytest.ParameterSet` which is a flat list of all the
++    special cases that should be tested for this operator specialisation `op`,
++    which takes in several types `types`, where the arguments have shapes taken
++    from the iterable of iterables `shapes`.  If `out_type` is specified, it
++    will be added into the output parameter set and its name added to the id,
++    but is otherwise not used.
++
++    Parameters
++    ----------
++    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
++        Mapping to get the special case generator from.  This is one of
++        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
++        from the case generator should all be closures of the form `() -> Data`
++        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
++        containing exactly one value, which is the same closure type.
++
++    op: Function
++        The specialisation of a mathematical operation that is being tested.
++        This is actually generally unused - it's just added in to the output
++        ParameterSet at the end so that it will get correctly parametrised.
++
++    types: Tuple[Type]
++        A tuple of data.Data subclass types (not instances).  This defines the
++        inputs to this particular specialisation under test.  There should be
++        as many types as there are Data arguments to `op`.
++
++    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
++        An iterable containing several sets of shapes to parameterise over.
++        Each element of the iterable should be s tuple of shapes, or
++        `pytest.ParameterSet` instances each containing a single shape.  A
++        shape is a 2-tuple of integers.  There should be as many elements of
++        this inner tuple as there are `types`, since each individual `shape`
++        goes with a `type`.
++
++    out_type: Type
++        The output type for this specialisation.  Not used other than its name
++        being added to the id, and it being added at the end of the
++        specialisation (if it is given), similarly to `op`.
++
++    Returns
++    -------
++    List[ParameterSet]
++        A list of individual test cases for parametrisation.  Each ParameterSet
++        will be
++            [op, *data_inputs, ?out_type]
++        where `data_inputs` is of the same length as the input parameter
++        `types` and represents the Data arguments to the specialisation `op`.
++        Each element of `data_inputs` is a generator function which takes no
++        arguments and returns a data.Data subclass of the correct type and
++        shape.  `out_type` is present in the output only if it were given as a
++        parameter itself.
++    """
++    def case(type_, shape_case, generator_case):
++        """
++        Build a case parameter for _one_ generator function which will return
++        a given type and shape.
++        """
++        id_ = type_.__name__
++        inner = ""
++        for extra in [shape_case, generator_case]:
++            if hasattr(extra, 'id') and extra.id:
++                inner += ("," if inner else "") + extra.id
++        if inner:
++            id_ += "[" + inner + "]"
++        func = (
++            generator_case.values[0]
++            if isinstance(generator_case, _ParameterSet)
++            else generator_case
++        )
++        return pytest.param(func, id=id_)
++
++    cases = []
++    for shapes_ in shapes:
++        # Convert the list of types into a list of lists of the special cases
++        # needed for each type.
++        matrix_cases = [
++            [case(type_, shape_case, type_case)
++             for type_case in cases_lookup[type_](shape_case.values[0])]
++            for type_, shape_case in zip(types, shapes_)
++        ]
++        # Now Cartesian product all the special cases together to make the full
++        # set of parametrisations.
++        for matrices in itertools.product(*matrix_cases):
++            id_ = ",".join(m.id for m in matrices)
++            args = [m for p_m in matrices for m in p_m.values]
++            if out_type is not None:
++                id_ += "->" + out_type.__name__
++                args += [out_type]
++            cases.append(pytest.param(op, *args, id=id_))
++    return cases
++
++
++# Now we start to actually build up all the test cases.  Since all the
++# mathematical operations are really pretty similar, and most just need the
++# basic testing functionality, we do this with a series of mix-in classes which
++# provide various components of the testing and test-generation infrastructure.
++#
++# In each, we use the idiom that "test_<x>" is a test function which pytest
++# will collect for us, and "generate_<x>" a method which will be called by
++# `pytest_generate_tests` in order to generate all the parametrisations for the
++# given test.
++
++class _GenericOpMixin:
++    """
++    Abstract base mix-in which sets up the test generation for the two basic
++    test operations, and puts in the very generic test generator.  This does
++    not actually define the tests themselves, because subclasses need to define
++    them so the method arguments can be introspected to parametrise over the
++    correct number of arguments.
++
++    The tests `mathematically_correct` and `incorrect_shape_raises` will
++    parametrise Data types over method arguments which have names `data_*`.
++
++    The class arguments defined here are effectively parametrising the
++    mathematical tests.
++
++    Attributes
++    ----------
++    op_numpy: *args -> np.ndarray
++        Function which takes the same arguments as the mathematical operation,
++        but with all data arguments numpy arrays, and returns the expected
++        result.
++
++    atol: float
++        The absolute tolerance to use when comparing the test value with the
++        expected value.  If the output is a Data type, the tolerance is
++        per-element of the output.
++
++    rtol: float
++        The relative tolerance to use when comparing the test value with the
++        expected value.  If the output is a Data type, the tolerance is
++        per-element of the output.
++
++    shapes: list of (list of shapes)
++        A list of the sets of shapes which should be used for the tests of
++        mathematical correctness.  Each element of the list is a set of shapes,
++        each one corresponding to one of the arguments of the operation.
++
++    bad_shapes: list of (list of shapes)
++        Similar to `shapes`, but these should be shapes which are invalid for
++        the given mathematical operation.
++
++    specialisations: list of (function, Type, Type, [Type, ...])
++        The specialisations of each mathematical function, and the types that
++        it takes in and returns.  For example, the function
++            add(CSR, Dense) -> Other
++        would be specified as `(add, CSR, Dense, Other)`.
++    """
++    def op_numpy(self, *args): raise NotImplementedError
++    # With dimensions of around 100, we have to account for floating-point
++    # addition not being associative; the maths on full numpy arrays will often
++    # produce slightly different results to sparse algebra, since the order of
++    # multiplications and additions will be different.
++    atol = 1e-10
++    rtol = 1e-7  # Same default as numpy
++    shapes = []
++    bad_shapes = []
++    specialisations = []
++
++    def generate_mathematically_correct(self, metafunc):
++        parameters = (
++            ['op']
++            + [x for x in metafunc.fixturenames
++               if x.startswith("data_")]
++            + ['out_type']
++        )
++        cases = []
++        for p_op in self.specialisations:
++            op, *types, out_type = p_op.values
++            args = (op, types, self.shapes, out_type)
++            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
++        metafunc.parametrize(parameters, cases)
++
++    def generate_incorrect_shape_raises(self, metafunc):
++        parameters = (
++            ['op']
++            + [x for x in metafunc.fixturenames
++               if x.startswith("data_")]
++        )
++        if not self.bad_shapes:
++            reason = "".join([
++                "no shapes are 'incorrect' for ",
++                metafunc.cls.__name__,
++                "::",
++                metafunc.function.__name__,
++            ])
++            false_case = pytest.param(*([None]*len(parameters)),
++                                      marks=pytest.mark.skip(reason),
++                                      id="no test")
++            metafunc.parametrize(parameters, [false_case])
++            return
++        cases = []
++        for p_op in self.specialisations:
++            op, *types, _ = p_op.values
++            args = (op, types, self.bad_shapes)
++            cases.extend(cases_type_shape_product(_RANDOM, *args))
++        metafunc.parametrize(parameters, cases)
++
++    def pytest_generate_tests(self, metafunc):
++        # For every test function "test_xyz", we use the test generator
++        # "generate_xyz" if it exists.  This allows derived classes to add
++        # their own tests and generators without overiding this method, cutting
++        # down on boilerplate, but also that derived classes _may_ override the
++        # generation of tests defined in a base class, say if they have
++        # additional special arguments that need parametrising over.
++        generator_name = (
++            "generate_"
++            + metafunc.function.__name__.replace("test_", "")
++        )
++        try:
++            generator = getattr(self, generator_name)
++        except AttributeError:
++            return
++        generator(metafunc)
++
++
++class UnaryOpMixin(_GenericOpMixin):
++    """
++    Mix-in for unary mathematical operations on Data instances (e.g. unary
++    negation).
++    """
++    shapes = [(x,) for x in shapes_unary()]
++    bad_shapes = []
++
++    def test_mathematically_correct(self, op, data_m, out_type):
++        matrix = data_m()
++        expected = self.op_numpy(matrix.to_array())
++        test = op(matrix)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol, rtol=self.rtol)
++        elif out_type is list:
++            for test_, expected_ in zip(test, expected):
++                assert test_.shape == expected_.shape
++                np.testing.assert_allclose(test_.to_array(), expected_,
++                                           atol=self.atol, rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++    def test_incorrect_shape_raises(self, op, data_m):
++        """
++        Test that the operation produces a suitable error if the shape of the
++        given operand is not compatible with the operation. Useful for
++        operations that require square matrices (trace, pow, ...).
++        """
++        with pytest.raises(ValueError):
++            op(data_m())
++
++
++class UnaryScalarOpMixin(_GenericOpMixin):
++    """
++    Mix-in for unary mathematical operations on Data instances, but that also
++    take in a numeric scalar (e.g. scalar multiplication).  Only generates
++    the test `mathematically_correct`, since there can't be a shape mismatch
++    when there's only one Data argument.
++    """
++    shapes = [(x,) for x in shapes_unary()]
++
++    @pytest.mark.parametrize('scalar', [
++        pytest.param(0, id='zero'),
++        pytest.param(4.5, id='real'),
++        pytest.param(3j, id='complex'),
++    ])
++    def test_mathematically_correct(self, op, data_m, scalar, out_type):
++        matrix = data_m()
++        expected = self.op_numpy(matrix.to_array(), scalar)
++        test = op(matrix, scalar)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol,
++                                       rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++
++class BinaryOpMixin(_GenericOpMixin):
++    """
++    Mix-in for binary mathematical operations on Data instances (e.g. binary
++    addition).
++    """
++    def test_mathematically_correct(self, op, data_l, data_r, out_type):
++        """
++        Test that the binary operation is mathematically correct for all the
++        known type specialisations.
++        """
++        left, right = data_l(), data_r()
++        expected = self.op_numpy(left.to_array(), right.to_array())
++        test = op(left, right)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol, rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++    def test_incorrect_shape_raises(self, op, data_l, data_r):
++        """
++        Test that the operation produces a suitable error if the shapes of the
++        given operands are not compatible.
++        """
++        with pytest.raises(ValueError):
++            op(data_l(), data_r())
++
++
++class TernaryOpMixin(_GenericOpMixin):
++    """
++    Mix-in for ternary mathematical operations on Data instances (e.g. inner
++    product with an operator in the middle).  This is pretty rare.
++    """
++    def test_mathematically_correct(self, op,
++                                    data_l, data_m, data_r,
++                                    out_type):
++        """
++        Test that the binary operation is mathematically correct for all the
++        known type specialisations.
++        """
++        left, mid, right = data_l(), data_m(), data_r()
++        expected = self.op_numpy(left.to_array(),
++                                 mid.to_array(),
++                                 right.to_array())
++        test = op(left, mid, right)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol, rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
++        """
++        Test that the operation produces a suitable error if the shapes of the
++        given operands are not compatible.
++        """
++        with pytest.raises(ValueError):
++            op(data_l(), data_m(), data_r())
++
++
++# And now finally we get into the meat of the actual mathematical tests.
++
++class TestAdd(BinaryOpMixin):
++    def op_numpy(self, left, right, scale):
++        return np.add(left, scale * right)
++
++    shapes = shapes_binary_identical()
++    bad_shapes = shapes_binary_bad_identical()
++    specialisations = [
++        pytest.param(data.add_csr, CSR, CSR, CSR),
++        pytest.param(data.add_dense, Dense, Dense, Dense),
++    ]
++
++    # `add` has an additional scalar parameter, because the operation is
++    # actually more like `A + c*B`.  We just parametrise that scalar
++    # separately.
++    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
++                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
++    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
++        """
++        Test that the binary operation is mathematically correct for all the
++        known type specialisations.
++        """
++        left, right = data_l(), data_r()
++        if scale is not None:
++            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
++            test = op(left, right, scale)
++        else:
++            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
++            test = op(left, right)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol, rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++
++class TestAdjoint(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return np.conj(matrix.T)
++
++    specialisations = [
++        pytest.param(data.adjoint_csr, CSR, CSR),
++        pytest.param(data.adjoint_dense, Dense, Dense),
++    ]
++
++
++class TestConj(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return np.conj(matrix)
++
++    specialisations = [
++        pytest.param(data.conj_csr, CSR, CSR),
++        pytest.param(data.conj_dense, Dense, Dense),
++    ]
++
++
++class TestInner(BinaryOpMixin):
++    # The inner product is a bit more specialist, since it has to handle inputs
++    # in a 1D space specially.  In order to keep things simple, we just
++    # generate those test cases completely separately from the standard
++    # `mathematically_correct`.
++
++    def op_numpy(self, left, right, scalar_is_ket=False):
++        if left.shape[1] == 1:
++            if left.shape[0] != 1 or scalar_is_ket:
++                left = np.conj(left.T)
++        return (left @ right)[0, 0]
++
++    # These shapes are a little more non-standard.
++    _dim = 100
++    _scalar = pytest.param((1, 1), id="scalar")
++    _bra = pytest.param((1, _dim), id="bra")
++    _ket = pytest.param((_dim, 1), id="ket")
++    _op = pytest.param((_dim, _dim), id="square")
++    shapes = [
++        (_bra, _ket),
++        (_ket, _ket),
++    ]
++    bad_shapes = [
++        (_bra, _bra),
++        (_ket, _bra),
++        (_op, _ket),
++        (_op, _bra),
++        (_bra, _op),
++        (_ket, _op),
++    ]
++
++    specialisations = [
++        pytest.param(data.inner_csr, CSR, CSR, complex),
++        pytest.param(data.inner_dense, Dense, Dense, complex),
++    ]
++
++    def generate_scalar_is_ket(self, metafunc):
++        # For 1D subspaces, the special cases don't really matter since there's
++        # only really one type of matrix available, so this is parametrised
++        # with only case for each input argument.
++        parameters = (
++            ['op']
++            + [x for x in metafunc.fixturenames
++               if x.startswith("data_")]
++            + ['out_type']
++        )
++        cases = []
++        for p_op in self.specialisations:
++            op, *types, out_type = p_op.values
++            args = (op, types, [(self._scalar, self._scalar)], out_type)
++            cases.extend(cases_type_shape_product(_RANDOM, *args))
++        metafunc.parametrize(parameters, cases)
++        metafunc.parametrize('scalar_is_ket',
++                             [True, False],
++                             ids=["ket", "bra"])
++
++    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
++        left, right = data_l(), data_r()
++        expected = self.op_numpy(left.to_array(), right.to_array(),
++                                 scalar_is_ket)
++        test = op(left, right, scalar_is_ket)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol, rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++
++class TestInnerOp(TernaryOpMixin):
++    # This is very very similar to TestInner.
++    def op_numpy(self, left, mid, right, scalar_is_ket=False):
++        if left.shape[1] == 1:
++            if left.shape[0] != 1 or scalar_is_ket:
++                left = np.conj(left.T)
++        return (left @ mid @ right)[0, 0]
++
++    _dim = 100
++    _scalar = pytest.param((1, 1), id="scalar")
++    _bra = pytest.param((1, _dim), id="bra")
++    _ket = pytest.param((_dim, 1), id="ket")
++    _op = pytest.param((_dim, _dim), id="square")
++    shapes = [
++        (_bra, _op, _ket),
++        (_ket, _op, _ket),
++    ]
++    bad_shapes = [
++        (_bra, _op, _bra),
++        (_ket, _op, _bra),
++        (_op, _op, _ket),
++        (_op, _op, _bra),
++        (_bra, _op, _op),
++        (_ket, _op, _op),
++        (_bra, _bra, _ket),
++        (_ket, _bra, _ket),
++        (_bra, _ket, _ket),
++        (_ket, _ket, _ket),
++    ]
++
++    specialisations = [
++        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
++        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
++    ]
++
++    def generate_scalar_is_ket(self, metafunc):
++        parameters = (
++            ['op']
++            + [x for x in metafunc.fixturenames
++               if x.startswith("data_")]
++            + ['out_type']
++        )
++        cases = []
++        for p_op in self.specialisations:
++            op, *types, out_type = p_op.values
++            args = (op, types, [(self._scalar,) * 3], out_type)
++            cases.extend(cases_type_shape_product(_RANDOM, *args))
++        metafunc.parametrize(parameters, cases)
++        metafunc.parametrize('scalar_is_ket',
++                             [True, False], ids=["ket", "bra"])
++
++    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
++                           scalar_is_ket):
++        left, mid, right = data_l(), data_m(), data_r()
++        expected = self.op_numpy(left.to_array(),
++                                 mid.to_array(),
++                                 right.to_array(),
++                                 scalar_is_ket)
++        test = op(left, mid, right, scalar_is_ket)
++        assert isinstance(test, out_type)
++        if issubclass(out_type, Data):
++            assert test.shape == expected.shape
++            np.testing.assert_allclose(test.to_array(), expected,
++                                       atol=self.atol,
++                                       rtol=self.rtol)
++        else:
++            np.testing.assert_allclose(test, expected, atol=self.atol,
++                                       rtol=self.rtol)
++
++
++class TestKron(BinaryOpMixin):
++    def op_numpy(self, left, right):
++        return np.kron(left, right)
++
++    # Keep the dimension low because kron can get very expensive.
++    shapes = shapes_binary_unrestricted(dim=5)
++    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
++    specialisations = [
++        pytest.param(data.kron_csr, CSR, CSR, CSR),
++        pytest.param(data.kron_dense, Dense, Dense, Dense),
++    ]
++
++
++class TestMatmul(BinaryOpMixin):
++    def op_numpy(self, left, right):
++        return np.matmul(left, right)
++
++    shapes = shapes_binary_matmul()
++    bad_shapes = shapes_binary_bad_matmul()
++    specialisations = [
++        pytest.param(data.matmul_csr, CSR, CSR, CSR),
++        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
++        pytest.param(data.matmul_dense, Dense, Dense, Dense),
++    ]
++
++
++class TestMultiply(BinaryOpMixin):
++    def op_numpy(self, left, right):
++        return left * right
++
++    shapes = shapes_binary_identical()
++    bad_shapes = shapes_binary_bad_identical()
++    specialisations = [
++        pytest.param(data.multiply_csr, CSR, CSR, CSR),
++        pytest.param(data.multiply_dense, Dense, Dense, Dense),
++    ]
++
++
++class TestMul(UnaryScalarOpMixin):
++    def op_numpy(self, matrix, scalar):
++        return scalar * matrix
++
++    specialisations = [
++        pytest.param(data.mul_csr, CSR, CSR),
++        pytest.param(data.mul_dense, Dense, Dense),
++    ]
++
++
++class TestNeg(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return -matrix
++
++    specialisations = [
++        pytest.param(data.neg_csr, CSR, CSR),
++        pytest.param(data.neg_dense, Dense, Dense),
++    ]
++
++
++class TestSub(BinaryOpMixin):
++    def op_numpy(self, left, right):
++        return left - right
++
++    shapes = shapes_binary_identical()
++    bad_shapes = shapes_binary_bad_identical()
++    specialisations = [
++        pytest.param(data.sub_csr, CSR, CSR, CSR),
++        pytest.param(data.sub_dense, Dense, Dense, Dense),
++    ]
++
++
++class TestTrace(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return np.sum(np.diag(matrix))
++
++    shapes = shapes_square()
++    bad_shapes = shapes_not_square()
++    specialisations = [
++        pytest.param(data.trace_csr, CSR, complex),
++        pytest.param(data.trace_dense, Dense, complex),
++    ]
++
++
++class TestTrace_oper_ket(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        N = int(matrix.shape[0] ** 0.5)
++        return np.sum(np.diag(matrix.reshape((N, N))))
++
++    shapes = [
++        (pytest.param((100, 1), id="oper-ket"),),
++    ]
++    bad_shapes = [
++        (pytest.param((1, 100), id="bra"),),
++        (pytest.param((99, 1), id="ket"),),
++        (pytest.param((99, 99), id="ket"),),
++        (pytest.param((2, 99), id="nonsquare"),),
++    ]
++    specialisations = [
++        pytest.param(data.trace_oper_ket_csr, CSR, complex),
++        pytest.param(data.trace_oper_ket_dense, Dense, complex),
++    ]
++
++
++class TestPow(UnaryOpMixin):
++    def op_numpy(self, matrix, n):
++        return np.linalg.matrix_power(matrix, n)
++
++    shapes = shapes_square()
++    bad_shapes = shapes_not_square()
++    specialisations = [
++        pytest.param(data.pow_csr, CSR, CSR),
++        pytest.param(data.pow_dense, Dense, Dense),
++    ]
++
++    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
++    def test_mathematically_correct(self, op, data_m, out_type, n):
++        matrix = data_m()
++        expected = self.op_numpy(matrix.to_array(), n)
++        test = op(matrix, n)
++        assert isinstance(test, out_type)
++        assert test.shape == expected.shape
++        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
++                                   rtol=self.rtol)
++
++    # Pow actually does have bad shape, so we put that in too.
++    def test_incorrect_shape_raises(self, op, data_m):
++        """
++        Test that the operation produces a suitable error if the shape is not a
++        square matrix.
++        """
++        with pytest.raises(ValueError):
++            op(data_m(), 10)
++
++
++class TestExpm(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return scipy.linalg.expm(matrix)
++
++    shapes = shapes_square()
++    bad_shapes = shapes_not_square()
++    specialisations = [
++        pytest.param(data.expm_csr, CSR, CSR),
++        pytest.param(data.expm_csr_dense, CSR, Dense),
++        pytest.param(data.expm_dense, Dense, Dense),
++    ]
++
++
++class TestLogm(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return scipy.linalg.logm(matrix)
++
++    shapes = shapes_square()
++    bad_shapes = shapes_not_square()
++    specialisations = [
++        pytest.param(data.logm_dense, Dense, Dense),
++    ]
++
++
++class TestTranspose(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return matrix.T
++
++    specialisations = [
++        pytest.param(data.transpose_csr, CSR, CSR),
++        pytest.param(data.transpose_dense, Dense, Dense),
++    ]
++
++
++class TestProject(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        if matrix.shape[0] == 1:
++            return np.outer(np.conj(matrix), matrix)
++        else:
++            return np.outer(matrix, np.conj(matrix))
++
++    shapes = [
++        (pytest.param((1, 1), id="scalar"),),
++        (pytest.param((1, 100), id="bra"),),
++        (pytest.param((100, 1), id="ket"),),
++    ]
++    bad_shapes = [
++        (pytest.param((10, 10), id="square"),),
++        (pytest.param((2, 10), id="nonsquare"),),
++    ]
++
++    specialisations = [
++        pytest.param(data.project_csr, CSR, CSR),
++        pytest.param(data.project_dense, Dense, Dense),
++    ]
++
++
++def _inv_dense(matrix):
++    # Add a diagonal so `matrix` is not singular
++    return data.inv_dense(
++        data.add(
++            matrix,
++            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
++        )
++    )
++
++
++def _inv_csr(matrix):
++    # Add a diagonal so `matrix` is not singular
++    return data.inv_csr(
++        data.add(
++            matrix,
++            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
++        )
++    )
++
++
++class TestInv(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
++
++    shapes = [
++        (pytest.param((1, 1), id="scalar"),),
++        (pytest.param((10, 10), id="square"),),
++    ]
++    bad_shapes = [
++        (pytest.param((2, 10), id="nonsquare"),),
++        (pytest.param((1, 100), id="bra"),),
++        (pytest.param((100, 1), id="ket"),),
++    ]
++
++    specialisations = [
++        pytest.param(_inv_csr, CSR, CSR),
++        pytest.param(_inv_dense, Dense, Dense),
++    ]
+diff --git a/qutip/tests/core/data/test_norm.py b/qutip/tests/core/data/test_norm.py
+index d285bb3e..7abac872 100644
+--- a/qutip/tests/core/data/test_norm.py
++++ b/qutip/tests/core/data/test_norm.py
+@@ -1,69 +1,69 @@
+-from . import test_mathematics as testing
+-import numpy as np
+-import scipy.linalg
+-import pytest
+-from qutip import data
+-from qutip.core.data import CSR, Dense
+-import numbers
+-
+-
+-class TestOneNorm(testing.UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return scipy.linalg.norm(matrix, 1)
+-
+-    specialisations = [
+-        pytest.param(data.norm.one_csr, CSR, numbers.Number),
+-        pytest.param(data.norm.one_dense, Dense, numbers.Number),
+-    ]
+-
+-
+-class TestFrobeniusNorm(testing.UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return scipy.linalg.norm(matrix, 'fro')
+-
+-    specialisations = [
+-        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
+-        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
+-    ]
+-
+-
+-class TestMaxNorm(testing.UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
+-        # works differently for matrices.
+-        return np.max(np.abs(matrix))
+-
+-    specialisations = [
+-        pytest.param(data.norm.max_csr, CSR, numbers.Number),
+-        pytest.param(data.norm.max_dense, Dense, numbers.Number),
+-    ]
+-
+-
+-class TestL2Norm(testing.UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return scipy.linalg.norm(matrix, 'fro')
+-
+-    # These shapes correspond to kets or bras
+-    shapes = [
+-        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
+-                                                 or x.values[0][1] == 1)
+-    ]
+-    # These shapes are everything except for kets and bras
+-    bad_shapes = [
+-        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
+-                                                     or x.values[0][1] == 1)
+-    ]
+-    specialisations = [
+-        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
+-        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
+-    ]
+-
+-
+-class TestTraceNorm(testing.UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return np.linalg.svd(matrix)[1].sum()
+-
+-    specialisations = [
+-        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
+-        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
+-    ]
++from . import test_mathematics as testing
++import numpy as np
++import scipy.linalg
++import pytest
++from qutip import data
++from qutip.core.data import CSR, Dense
++import numbers
++
++
++class TestOneNorm(testing.UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return scipy.linalg.norm(matrix, 1)
++
++    specialisations = [
++        pytest.param(data.norm.one_csr, CSR, numbers.Number),
++        pytest.param(data.norm.one_dense, Dense, numbers.Number),
++    ]
++
++
++class TestFrobeniusNorm(testing.UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return scipy.linalg.norm(matrix, 'fro')
++
++    specialisations = [
++        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
++        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
++    ]
++
++
++class TestMaxNorm(testing.UnaryOpMixin):
++    def op_numpy(self, matrix):
++        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
++        # works differently for matrices.
++        return np.max(np.abs(matrix))
++
++    specialisations = [
++        pytest.param(data.norm.max_csr, CSR, numbers.Number),
++        pytest.param(data.norm.max_dense, Dense, numbers.Number),
++    ]
++
++
++class TestL2Norm(testing.UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return scipy.linalg.norm(matrix, 'fro')
++
++    # These shapes correspond to kets or bras
++    shapes = [
++        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
++                                                 or x.values[0][1] == 1)
++    ]
++    # These shapes are everything except for kets and bras
++    bad_shapes = [
++        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
++                                                     or x.values[0][1] == 1)
++    ]
++    specialisations = [
++        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
++        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
++    ]
++
++
++class TestTraceNorm(testing.UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return np.linalg.svd(matrix)[1].sum()
++
++    specialisations = [
++        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
++        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
++    ]
+diff --git a/qutip/tests/core/data/test_operators.py b/qutip/tests/core/data/test_operators.py
+index 4416629b..eb2a7507 100644
+--- a/qutip/tests/core/data/test_operators.py
++++ b/qutip/tests/core/data/test_operators.py
+@@ -1,69 +1,69 @@
+-import pytest
+-import numpy
+-import qutip
+-from qutip.core import data as _data
+-from qutip import settings
+-
+-
+-@pytest.mark.parametrize('type_left', _data.to.dtypes)
+-@pytest.mark.parametrize('type_right', _data.to.dtypes)
+-@pytest.mark.parametrize(['operator', 'dispatch'], [
+-    pytest.param(lambda left, right: left + right, _data.add, id="add"),
+-    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
+-    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
+-])
+-def test_data_binary_operator(type_left, type_right, operator, dispatch):
+-    left = qutip.rand_dm(5, dtype=type_left).data
+-    right = qutip.rand_dm(5, dtype=type_right).data
+-    numpy.testing.assert_allclose(
+-        operator(left, right).to_array(),
+-        dispatch(left, right).to_array(),
+-        rtol=1e-15
+-    )
+-
+-
+-@pytest.mark.parametrize('type_', _data.to.dtypes)
+-@pytest.mark.parametrize(['operator', 'dispatch'], [
+-    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
+-    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
+-    pytest.param(lambda data, number: data / number,
+-                 lambda data, number: _data.mul(data, 1/number), id="div"),
+-])
+-def test_data_scalar_operator(type_, operator, dispatch):
+-    data = qutip.qeye(2, dtype=type_).data
+-    number = 3
+-    numpy.testing.assert_allclose(
+-        operator(data, number).to_array(),
+-        dispatch(data, number).to_array(),
+-        rtol=1e-15
+-    )
+-
+-
+-@pytest.mark.parametrize('type_', _data.to.dtypes)
+-def test_data_neg_operator(type_):
+-    data = qutip.qeye(2, dtype=type_).data
+-    numpy.testing.assert_allclose(
+-        (-data).to_array(), -data.to_array(), rtol=1e-15
+-    )
+-
+-
+-@pytest.mark.parametrize('type_left', _data.to.dtypes)
+-@pytest.mark.parametrize('type_right', _data.to.dtypes)
+-def test_data_eq_operator(type_left, type_right):
+-    mat = qutip.rand_dm(5)
+-    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
+-
+-    left = mat.to(type_left).data
+-    right = mat.to(type_right).data
+-    assert left == right
+-    right = (mat + noise).to(type_right).data
+-    assert left == right
+-
+-    right = (mat + noise * 100).to(type_right).data
+-    assert left != right
+-
+-    right = qutip.operator_to_vector(mat).to(type_right).data
+-    assert left != right
+-
+-    assert left != mat
+-    assert numpy.all(left != mat.full())
++import pytest
++import numpy
++import qutip
++from qutip.core import data as _data
++from qutip import settings
++
++
++@pytest.mark.parametrize('type_left', _data.to.dtypes)
++@pytest.mark.parametrize('type_right', _data.to.dtypes)
++@pytest.mark.parametrize(['operator', 'dispatch'], [
++    pytest.param(lambda left, right: left + right, _data.add, id="add"),
++    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
++    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
++])
++def test_data_binary_operator(type_left, type_right, operator, dispatch):
++    left = qutip.rand_dm(5, dtype=type_left).data
++    right = qutip.rand_dm(5, dtype=type_right).data
++    numpy.testing.assert_allclose(
++        operator(left, right).to_array(),
++        dispatch(left, right).to_array(),
++        rtol=1e-15
++    )
++
++
++@pytest.mark.parametrize('type_', _data.to.dtypes)
++@pytest.mark.parametrize(['operator', 'dispatch'], [
++    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
++    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
++    pytest.param(lambda data, number: data / number,
++                 lambda data, number: _data.mul(data, 1/number), id="div"),
++])
++def test_data_scalar_operator(type_, operator, dispatch):
++    data = qutip.qeye(2, dtype=type_).data
++    number = 3
++    numpy.testing.assert_allclose(
++        operator(data, number).to_array(),
++        dispatch(data, number).to_array(),
++        rtol=1e-15
++    )
++
++
++@pytest.mark.parametrize('type_', _data.to.dtypes)
++def test_data_neg_operator(type_):
++    data = qutip.qeye(2, dtype=type_).data
++    numpy.testing.assert_allclose(
++        (-data).to_array(), -data.to_array(), rtol=1e-15
++    )
++
++
++@pytest.mark.parametrize('type_left', _data.to.dtypes)
++@pytest.mark.parametrize('type_right', _data.to.dtypes)
++def test_data_eq_operator(type_left, type_right):
++    mat = qutip.rand_dm(5)
++    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
++
++    left = mat.to(type_left).data
++    right = mat.to(type_right).data
++    assert left == right
++    right = (mat + noise).to(type_right).data
++    assert left == right
++
++    right = (mat + noise * 100).to(type_right).data
++    assert left != right
++
++    right = qutip.operator_to_vector(mat).to(type_right).data
++    assert left != right
++
++    assert left != mat
++    assert numpy.all(left != mat.full())
+diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
+index de844bae..124d7d2f 100644
+--- a/qutip/tests/core/data/test_properties.py
++++ b/qutip/tests/core/data/test_properties.py
+@@ -1,175 +1,175 @@
+-import numpy as np
+-import pytest
+-
+-from qutip import data as _data
+-
+-
+-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+-def datatype(request):
+-    return request.param
+-
+-
+-class Test_isherm:
+-    tol = 1e-12
+-
+-    @pytest.mark.repeat(20)
+-    @pytest.mark.parametrize("density", (0.1, 0.8))
+-    @pytest.mark.parametrize("size", (10, 100))
+-    def test_random_equal_structure(self, datatype, size, density):
+-        # This is only going to be approximate, as entries generated onto the
+-        # diagonal will fill only one slot, not two, after addition with the
+-        # transpose.  The densities are arbitrary, though, so this doesn't
+-        # matter much.
+-        nnz = int(0.5 * size*size * density) or 1
+-        indices = np.triu_indices(size)
+-        choice = np.random.choice(indices[0].size, nnz, replace=False)
+-        indices = (indices[0][choice], indices[1][choice])
+-
+-        # Real-symmetric matrices.
+-        base = np.zeros((size, size), dtype=np.complex128)
+-        base[indices] = np.random.rand(nnz)
+-        base += base.T.conj()
+-        base = _data.to(datatype, _data.create(base))
+-        assert _data.isherm(base)
+-
+-        # Complex Hermitian matrices
+-        base = np.zeros((size, size), dtype=np.complex128)
+-        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+-        base += base.T.conj()
+-        base = _data.to(datatype, _data.create(base))
+-        assert _data.isherm(base)
+-
+-        # Complex skew-Hermitian matrices
+-        base = np.zeros((size, size), dtype=np.complex128)
+-        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+-        base += base.T
+-        base = _data.to(datatype, _data.create(base))
+-        assert not _data.isherm(base)
+-
+-    @pytest.mark.parametrize("cols", (2, 4))
+-    @pytest.mark.parametrize("rows", (1, 5))
+-    def test_nonsquare_shapes(self, datatype, rows, cols):
+-        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
+-        assert not _data.isherm(real, self.tol)
+-        assert not _data.isherm(real.transpose(), self.tol)
+-
+-        imag = _data.to(
+-            datatype,
+-            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
+-        )
+-        assert not _data.isherm(imag, self.tol)
+-        assert not _data.isherm(imag.transpose(), self.tol)
+-
+-    def test_diagonal_elements(self, datatype):
+-        n = 10
+-        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
+-        assert _data.isherm(base, tol=self.tol)
+-        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
+-
+-    def test_compare_implicit_zero_structure(self, datatype):
+-        """
+-        Regression test for gh-1350, comparing explicitly stored values in the
+-        matrix (but below the tolerance for allowable Hermicity) to implicit
+-        zeros.
+-        """
+-
+-        base = _data.to(
+-            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
+-        )
+-        # If this first line fails, the zero has been stored explicitly and so
+-        # the test is invalid.
+-        assert np.count_nonzero(base.to_array()) == 3
+-        assert _data.isherm(base, tol=self.tol)
+-        assert _data.isherm(base.transpose(), tol=self.tol)
+-
+-        # A similar test if the structures are different, but it's not
+-        # Hermitian.
+-        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
+-        assert np.count_nonzero(base.to_array()) == 3
+-        assert not _data.isherm(base, tol=self.tol)
+-        assert not _data.isherm(base.transpose(), tol=self.tol)
+-
+-        # Catch possible edge case where it shouldn't be Hermitian, but faulty
+-        # loop logic doesn't fully compare all rows.
+-        base = _data.to(
+-            datatype,
+-            _data.create(
+-                np.array(
+-                    [
+-                        [0, 0, 0, 0],
+-                        [0, 0, 0, 0],
+-                        [0, 1, 0, 0],
+-                        [0, 0, 0, 0],
+-                    ],
+-                    dtype=np.complex128,
+-                )
+-            ),
+-        )
+-        assert np.count_nonzero(base.to_array()) == 1
+-        assert not _data.isherm(base, tol=self.tol)
+-        assert not _data.isherm(base.transpose(), tol=self.tol)
+-
+-    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
+-    def test_compare_implicit_zero_random(self, datatype, density):
+-        """
+-        Regression test of gh-1350.
+-
+-        Larger matrices where all off-diagonal elements are below the
+-        absolute tolerance, so everything should always appear Hermitian, but
+-        with random patterns of non-zero elements.  It doesn't matter that it
+-        isn't Hermitian if scaled up; everything is below absolute tolerance,
+-        so it should appear so.  We also set the diagonal to be larger to the
+-        tolerance to ensure isherm can't just compare everything to zero.
+-        """
+-        n = 10
+-        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
+-        # Mask some values out to zero.
+-        base[np.random.rand(n, n) > density] = 0
+-        np.fill_diagonal(base, self.tol * 1000)
+-        nnz = np.count_nonzero(base)
+-        base = _data.to(datatype, _data.create(base))
+-        assert np.count_nonzero(base.to_array()) == nnz
+-        assert _data.isherm(base, tol=self.tol)
+-        assert _data.isherm(base.transpose(), tol=self.tol)
+-
+-        # Similar test when it must be non-Hermitian.  We set the diagonal
+-        # to be real because we want to test off-diagonal implicit zeros,
+-        # and having an imaginary first element would automatically fail.
+-        nnz = 0
+-        while nnz <= n:
+-            # Ensure that we don't just have the real diagonal.
+-            base = self.tol * 1000j * np.random.rand(n, n)
+-            # Mask some values out to zero.
+-            base[np.random.rand(n, n) > density] = 0
+-            np.fill_diagonal(base, self.tol * 1000)
+-            nnz = np.count_nonzero(base)
+-        base = _data.to(datatype, _data.create(base))
+-        assert np.count_nonzero(base.to_array()) == nnz
+-        assert not _data.isherm(base, tol=self.tol)
+-        assert not _data.isherm(base.transpose(), tol=self.tol)
+-
+-    def test_structure_detection(self, datatype):
+-        base = np.array([[1,1,0],
+-                         [0,1,1],
+-                         [1,0,1]])
+-        base = _data.to(datatype, _data.create(base))
+-        assert not _data.isherm(base, tol=self.tol)
+-
+-
+-class Test_isdiag:
+-    @pytest.mark.parametrize("shape",
+-        [(10, 1), (2, 5), (5, 2), (5, 5)]
+-    )
+-    def test_isdiag(self, shape, datatype):
+-        mat = np.zeros(shape)
+-        data = _data.to(datatype, _data.Dense(mat))
+-        # empty matrices are diagonal
+-        assert _data.isdiag(data)
+-
+-        mat[0, 0] = 1
+-        data = _data.to(datatype, _data.Dense(mat))
+-        assert _data.isdiag(data)
+-
+-        mat[1, 0] = 1
+-        data = _data.to(datatype, _data.Dense(mat))
+-        assert not _data.isdiag(data)
++import numpy as np
++import pytest
++
++from qutip import data as _data
++
++
++@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
++def datatype(request):
++    return request.param
++
++
++class Test_isherm:
++    tol = 1e-12
++
++    @pytest.mark.repeat(20)
++    @pytest.mark.parametrize("density", (0.1, 0.8))
++    @pytest.mark.parametrize("size", (10, 100))
++    def test_random_equal_structure(self, datatype, size, density):
++        # This is only going to be approximate, as entries generated onto the
++        # diagonal will fill only one slot, not two, after addition with the
++        # transpose.  The densities are arbitrary, though, so this doesn't
++        # matter much.
++        nnz = int(0.5 * size*size * density) or 1
++        indices = np.triu_indices(size)
++        choice = np.random.choice(indices[0].size, nnz, replace=False)
++        indices = (indices[0][choice], indices[1][choice])
++
++        # Real-symmetric matrices.
++        base = np.zeros((size, size), dtype=np.complex128)
++        base[indices] = np.random.rand(nnz)
++        base += base.T.conj()
++        base = _data.to(datatype, _data.create(base))
++        assert _data.isherm(base)
++
++        # Complex Hermitian matrices
++        base = np.zeros((size, size), dtype=np.complex128)
++        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
++        base += base.T.conj()
++        base = _data.to(datatype, _data.create(base))
++        assert _data.isherm(base)
++
++        # Complex skew-Hermitian matrices
++        base = np.zeros((size, size), dtype=np.complex128)
++        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
++        base += base.T
++        base = _data.to(datatype, _data.create(base))
++        assert not _data.isherm(base)
++
++    @pytest.mark.parametrize("cols", (2, 4))
++    @pytest.mark.parametrize("rows", (1, 5))
++    def test_nonsquare_shapes(self, datatype, rows, cols):
++        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
++        assert not _data.isherm(real, self.tol)
++        assert not _data.isherm(real.transpose(), self.tol)
++
++        imag = _data.to(
++            datatype,
++            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
++        )
++        assert not _data.isherm(imag, self.tol)
++        assert not _data.isherm(imag.transpose(), self.tol)
++
++    def test_diagonal_elements(self, datatype):
++        n = 10
++        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
++        assert _data.isherm(base, tol=self.tol)
++        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
++
++    def test_compare_implicit_zero_structure(self, datatype):
++        """
++        Regression test for gh-1350, comparing explicitly stored values in the
++        matrix (but below the tolerance for allowable Hermicity) to implicit
++        zeros.
++        """
++
++        base = _data.to(
++            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
++        )
++        # If this first line fails, the zero has been stored explicitly and so
++        # the test is invalid.
++        assert np.count_nonzero(base.to_array()) == 3
++        assert _data.isherm(base, tol=self.tol)
++        assert _data.isherm(base.transpose(), tol=self.tol)
++
++        # A similar test if the structures are different, but it's not
++        # Hermitian.
++        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
++        assert np.count_nonzero(base.to_array()) == 3
++        assert not _data.isherm(base, tol=self.tol)
++        assert not _data.isherm(base.transpose(), tol=self.tol)
++
++        # Catch possible edge case where it shouldn't be Hermitian, but faulty
++        # loop logic doesn't fully compare all rows.
++        base = _data.to(
++            datatype,
++            _data.create(
++                np.array(
++                    [
++                        [0, 0, 0, 0],
++                        [0, 0, 0, 0],
++                        [0, 1, 0, 0],
++                        [0, 0, 0, 0],
++                    ],
++                    dtype=np.complex128,
++                )
++            ),
++        )
++        assert np.count_nonzero(base.to_array()) == 1
++        assert not _data.isherm(base, tol=self.tol)
++        assert not _data.isherm(base.transpose(), tol=self.tol)
++
++    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
++    def test_compare_implicit_zero_random(self, datatype, density):
++        """
++        Regression test of gh-1350.
++
++        Larger matrices where all off-diagonal elements are below the
++        absolute tolerance, so everything should always appear Hermitian, but
++        with random patterns of non-zero elements.  It doesn't matter that it
++        isn't Hermitian if scaled up; everything is below absolute tolerance,
++        so it should appear so.  We also set the diagonal to be larger to the
++        tolerance to ensure isherm can't just compare everything to zero.
++        """
++        n = 10
++        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
++        # Mask some values out to zero.
++        base[np.random.rand(n, n) > density] = 0
++        np.fill_diagonal(base, self.tol * 1000)
++        nnz = np.count_nonzero(base)
++        base = _data.to(datatype, _data.create(base))
++        assert np.count_nonzero(base.to_array()) == nnz
++        assert _data.isherm(base, tol=self.tol)
++        assert _data.isherm(base.transpose(), tol=self.tol)
++
++        # Similar test when it must be non-Hermitian.  We set the diagonal
++        # to be real because we want to test off-diagonal implicit zeros,
++        # and having an imaginary first element would automatically fail.
++        nnz = 0
++        while nnz <= n:
++            # Ensure that we don't just have the real diagonal.
++            base = self.tol * 1000j * np.random.rand(n, n)
++            # Mask some values out to zero.
++            base[np.random.rand(n, n) > density] = 0
++            np.fill_diagonal(base, self.tol * 1000)
++            nnz = np.count_nonzero(base)
++        base = _data.to(datatype, _data.create(base))
++        assert np.count_nonzero(base.to_array()) == nnz
++        assert not _data.isherm(base, tol=self.tol)
++        assert not _data.isherm(base.transpose(), tol=self.tol)
++
++    def test_structure_detection(self, datatype):
++        base = np.array([[1,1,0],
++                         [0,1,1],
++                         [1,0,1]])
++        base = _data.to(datatype, _data.create(base))
++        assert not _data.isherm(base, tol=self.tol)
++
++
++class Test_isdiag:
++    @pytest.mark.parametrize("shape",
++        [(10, 1), (2, 5), (5, 2), (5, 5)]
++    )
++    def test_isdiag(self, shape, datatype):
++        mat = np.zeros(shape)
++        data = _data.to(datatype, _data.Dense(mat))
++        # empty matrices are diagonal
++        assert _data.isdiag(data)
++
++        mat[0, 0] = 1
++        data = _data.to(datatype, _data.Dense(mat))
++        assert _data.isdiag(data)
++
++        mat[1, 0] = 1
++        data = _data.to(datatype, _data.Dense(mat))
++        assert not _data.isdiag(data)
+diff --git a/qutip/tests/core/data/test_ptrace.py b/qutip/tests/core/data/test_ptrace.py
+index 84fd4101..37b28c29 100644
+--- a/qutip/tests/core/data/test_ptrace.py
++++ b/qutip/tests/core/data/test_ptrace.py
+@@ -1,108 +1,108 @@
+-from . import test_mathematics as testing
+-import numpy as np
+-import scipy.linalg
+-import pytest
+-from qutip import data
+-from qutip.core.data import CSR, Dense
+-
+-
+-class TestPtrace(testing.UnaryOpMixin):
+-    def op_numpy(self, matrix, dims, sel):
+-        sel.sort()
+-        ndims = len(dims)
+-        dkeep = [dims[x] for x in sel]
+-        qtrace = list(set(range(ndims)) - set(sel))
+-        dtrace = [dims[x] for x in qtrace]
+-
+-        matrix = matrix.reshape(dims + dims)
+-        matrix = matrix.transpose(
+-            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
+-        )
+-        matrix = matrix.reshape(
+-            [
+-                np.prod(dtrace, dtype=int),
+-                np.prod(dtrace, dtype=int),
+-                np.prod(dkeep, dtype=int),
+-                np.prod(dkeep, dtype=int),
+-            ]
+-        )
+-        return np.trace(matrix)
+-
+-    # Custom shapes to have also custom dims and sel arguments.
+-    # These values should not be changed.
+-    dims = [2] * 7
+-    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
+-    bad_shapes = testing.shapes_not_square(np.prod(dims))
+-
+-    specialisations = [
+-        pytest.param(data.ptrace_csr, CSR, CSR),
+-        pytest.param(data.ptrace_csr_dense, CSR, Dense),
+-        pytest.param(data.ptrace_dense, Dense, Dense),
+-    ]
+-
+-    @pytest.mark.parametrize(
+-        "sel",
+-        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
+-        ids=[
+-            "keep_one",
+-            "keep_multiple_sorted",
+-            "keep_multiple_unsorted",
+-            "trace_none",
+-            "trace_all",
+-        ],
+-    )
+-    def test_mathematically_correct(self, op, data_m, out_type, sel):
+-        """
+-        Test that the unary operation is mathematically correct for all the
+-        known type specialisations.
+-        """
+-        matrix = data_m()
+-        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
+-        test = op(matrix, self.dims, sel)
+-        assert isinstance(test, out_type)
+-        assert test.shape == expected.shape
+-        np.testing.assert_allclose(
+-            test.to_array(), expected, atol=self.atol, rtol=self.rtol
+-        )
+-
+-    def test_incorrect_shape_raises(self, op, data_m):
+-        """
+-        Test that the operation produces a suitable error if the shape of the
+-        operand is not square.
+-        """
+-        with pytest.raises(ValueError):
+-            op(data_m(), self.dims, sel=[0, 1])
+-
+-    # `out_type` is included but not used so that
+-    # `generate_mathematically_correct` can be re-used.
+-    @pytest.mark.parametrize(
+-        "dims",
+-        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
+-        ids=[
+-            "dims_different_to_shape",
+-            "dims_0",
+-            "dims_prod_is_shape_but_negative",
+-            "dims_is_not_int",
+-        ],
+-    )
+-    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
+-        with pytest.raises(ValueError):
+-            op(data_m(), dims, sel=[0, 1])
+-
+-    def generate_incorrect_dims_raises(self, metafunc):
+-        self.generate_mathematically_correct(metafunc)
+-
+-    @pytest.mark.parametrize(
+-        "sel",
+-        [[2, 10], [-1, 2]],
+-        ids=[
+-            "sel_value_larger_than_dims",
+-            "sel_value_negative",
+-        ],
+-    )
+-    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
+-        with pytest.raises(IndexError):
+-            op(data_m(), dims=self.dims, sel=sel)
+-
+-    def generate_incorrect_sel_raises(self, metafunc):
+-        self.generate_mathematically_correct(metafunc)
++from . import test_mathematics as testing
++import numpy as np
++import scipy.linalg
++import pytest
++from qutip import data
++from qutip.core.data import CSR, Dense
++
++
++class TestPtrace(testing.UnaryOpMixin):
++    def op_numpy(self, matrix, dims, sel):
++        sel.sort()
++        ndims = len(dims)
++        dkeep = [dims[x] for x in sel]
++        qtrace = list(set(range(ndims)) - set(sel))
++        dtrace = [dims[x] for x in qtrace]
++
++        matrix = matrix.reshape(dims + dims)
++        matrix = matrix.transpose(
++            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
++        )
++        matrix = matrix.reshape(
++            [
++                np.prod(dtrace, dtype=int),
++                np.prod(dtrace, dtype=int),
++                np.prod(dkeep, dtype=int),
++                np.prod(dkeep, dtype=int),
++            ]
++        )
++        return np.trace(matrix)
++
++    # Custom shapes to have also custom dims and sel arguments.
++    # These values should not be changed.
++    dims = [2] * 7
++    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
++    bad_shapes = testing.shapes_not_square(np.prod(dims))
++
++    specialisations = [
++        pytest.param(data.ptrace_csr, CSR, CSR),
++        pytest.param(data.ptrace_csr_dense, CSR, Dense),
++        pytest.param(data.ptrace_dense, Dense, Dense),
++    ]
++
++    @pytest.mark.parametrize(
++        "sel",
++        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
++        ids=[
++            "keep_one",
++            "keep_multiple_sorted",
++            "keep_multiple_unsorted",
++            "trace_none",
++            "trace_all",
++        ],
++    )
++    def test_mathematically_correct(self, op, data_m, out_type, sel):
++        """
++        Test that the unary operation is mathematically correct for all the
++        known type specialisations.
++        """
++        matrix = data_m()
++        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
++        test = op(matrix, self.dims, sel)
++        assert isinstance(test, out_type)
++        assert test.shape == expected.shape
++        np.testing.assert_allclose(
++            test.to_array(), expected, atol=self.atol, rtol=self.rtol
++        )
++
++    def test_incorrect_shape_raises(self, op, data_m):
++        """
++        Test that the operation produces a suitable error if the shape of the
++        operand is not square.
++        """
++        with pytest.raises(ValueError):
++            op(data_m(), self.dims, sel=[0, 1])
++
++    # `out_type` is included but not used so that
++    # `generate_mathematically_correct` can be re-used.
++    @pytest.mark.parametrize(
++        "dims",
++        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
++        ids=[
++            "dims_different_to_shape",
++            "dims_0",
++            "dims_prod_is_shape_but_negative",
++            "dims_is_not_int",
++        ],
++    )
++    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
++        with pytest.raises(ValueError):
++            op(data_m(), dims, sel=[0, 1])
++
++    def generate_incorrect_dims_raises(self, metafunc):
++        self.generate_mathematically_correct(metafunc)
++
++    @pytest.mark.parametrize(
++        "sel",
++        [[2, 10], [-1, 2]],
++        ids=[
++            "sel_value_larger_than_dims",
++            "sel_value_negative",
++        ],
++    )
++    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
++        with pytest.raises(IndexError):
++            op(data_m(), dims=self.dims, sel=sel)
++
++    def generate_incorrect_sel_raises(self, metafunc):
++        self.generate_mathematically_correct(metafunc)
+diff --git a/qutip/tests/core/data/test_reshape.py b/qutip/tests/core/data/test_reshape.py
+index e86b327c..ad863b55 100644
+--- a/qutip/tests/core/data/test_reshape.py
++++ b/qutip/tests/core/data/test_reshape.py
+@@ -1,121 +1,121 @@
+-from .test_mathematics import UnaryOpMixin
+-import pytest
+-import numpy as np
+-from qutip import data
+-from qutip.core.data import CSR, Dense
+-
+-
+-class TestSplitColumns(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        return [column[:, np.newaxis] for column in matrix.T]
+-
+-    specialisations = [
+-        pytest.param(data.split_columns_csr, CSR, list),
+-        pytest.param(data.split_columns_dense, Dense, list),
+-    ]
+-
+-
+-class TestColumnStack(UnaryOpMixin):
+-    def op_numpy(self, matrix):
+-        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
+-        return np.reshape(matrix, newshape=out_shape, order='F')
+-
+-    specialisations = [
+-        pytest.param(data.column_stack_csr, CSR, CSR),
+-        pytest.param(data.column_stack_dense, Dense, Dense),
+-    ]
+-
+-
+-class TestColumnUnstack(UnaryOpMixin):
+-    def op_numpy(self, matrix, rows):
+-        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
+-        return np.reshape(matrix, newshape=out_shape, order='F')
+-
+-    shapes = [
+-        (pytest.param((10, 1), id="ket"), ),
+-    ]
+-
+-    bad_shapes = [
+-        (pytest.param((1, 10), id="bra"), ),
+-        (pytest.param((10, 10), id="square"), ),
+-        (pytest.param((2, 10), id="non_square"), ),
+-    ]
+-
+-    specialisations = [
+-        pytest.param(data.column_unstack_csr, CSR, CSR),
+-        pytest.param(data.column_unstack_dense, Dense, Dense),
+-    ]
+-
+-    @pytest.mark.parametrize('rows', [2, 5])
+-    def test_mathematically_correct(self, op, data_m, rows, out_type):
+-        """
+-        Test that the binary operation is correct for all the known type
+-        specialisations.
+-        """
+-        matrix = data_m()
+-        expected = self.op_numpy(matrix.to_array(), rows)
+-        test = op(matrix, rows)
+-        assert isinstance(test, out_type)
+-        assert test.shape == expected.shape
+-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+-                                   rtol=self.rtol)
+-
+-    def test_incorrect_shape_raises(self, op, data_m):
+-        with pytest.raises(ValueError):
+-            op(data_m(), 1)  # We set rows to one so that it is always valid
+-
+-    # `out_type` is included but not used so that
+-    # `generate_mathematically_correct` can be re-used.
+-    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
+-                                                      'invalid'])
+-    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
+-        with pytest.raises(ValueError):
+-            op(data_m(), rows)
+-
+-    def generate_incorrect_rows_raises(self, metafunc):
+-        self.generate_mathematically_correct(metafunc)
+-
+-
+-class TestReshape(UnaryOpMixin):
+-    def op_numpy(self, matrix, rows, columns):
+-        out_shape = (rows, columns)
+-        return np.reshape(matrix, newshape=out_shape, order='C')
+-
+-    # All matrices should have the same number of elements in total, so we can
+-    # use the same (rows, columns) parametrisation for each input.
+-    shapes = [
+-        (pytest.param((1, 100), id="bra"), ),
+-        (pytest.param((100, 1), id="ket"), ),
+-        (pytest.param((2, 50), id="non_square"), ),
+-        (pytest.param((10, 10), id="square"), ),
+-    ]
+-
+-    specialisations = [
+-        pytest.param(data.reshape_dense, Dense, Dense),
+-        pytest.param(data.reshape_csr, CSR, CSR),
+-    ]
+-
+-    # `out_type` is included but not used so that
+-    # `generate_mathematically_correct` can be re-used.
+-    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
+-    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
+-        """
+-        Test that the binary operation is correct for all the known type
+-        specialisations.
+-        """
+-        matrix = data_m()
+-        expected = self.op_numpy(matrix.to_array(), rows, columns)
+-        test = op(matrix, rows, columns)
+-        assert isinstance(test, out_type)
+-        assert test.shape == expected.shape
+-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+-                                   rtol=self.rtol)
+-
+-    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
+-                             ids=["negative1", "negative2", "invalid"])
+-    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
+-        with pytest.raises(ValueError):
+-            op(data_m(), rows, columns)
+-
+-    def generate_incorrect_rows_raises(self, metafunc):
+-        self.generate_mathematically_correct(metafunc)
++from .test_mathematics import UnaryOpMixin
++import pytest
++import numpy as np
++from qutip import data
++from qutip.core.data import CSR, Dense
++
++
++class TestSplitColumns(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        return [column[:, np.newaxis] for column in matrix.T]
++
++    specialisations = [
++        pytest.param(data.split_columns_csr, CSR, list),
++        pytest.param(data.split_columns_dense, Dense, list),
++    ]
++
++
++class TestColumnStack(UnaryOpMixin):
++    def op_numpy(self, matrix):
++        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
++        return np.reshape(matrix, newshape=out_shape, order='F')
++
++    specialisations = [
++        pytest.param(data.column_stack_csr, CSR, CSR),
++        pytest.param(data.column_stack_dense, Dense, Dense),
++    ]
++
++
++class TestColumnUnstack(UnaryOpMixin):
++    def op_numpy(self, matrix, rows):
++        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
++        return np.reshape(matrix, newshape=out_shape, order='F')
++
++    shapes = [
++        (pytest.param((10, 1), id="ket"), ),
++    ]
++
++    bad_shapes = [
++        (pytest.param((1, 10), id="bra"), ),
++        (pytest.param((10, 10), id="square"), ),
++        (pytest.param((2, 10), id="non_square"), ),
++    ]
++
++    specialisations = [
++        pytest.param(data.column_unstack_csr, CSR, CSR),
++        pytest.param(data.column_unstack_dense, Dense, Dense),
++    ]
++
++    @pytest.mark.parametrize('rows', [2, 5])
++    def test_mathematically_correct(self, op, data_m, rows, out_type):
++        """
++        Test that the binary operation is correct for all the known type
++        specialisations.
++        """
++        matrix = data_m()
++        expected = self.op_numpy(matrix.to_array(), rows)
++        test = op(matrix, rows)
++        assert isinstance(test, out_type)
++        assert test.shape == expected.shape
++        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
++                                   rtol=self.rtol)
++
++    def test_incorrect_shape_raises(self, op, data_m):
++        with pytest.raises(ValueError):
++            op(data_m(), 1)  # We set rows to one so that it is always valid
++
++    # `out_type` is included but not used so that
++    # `generate_mathematically_correct` can be re-used.
++    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
++                                                      'invalid'])
++    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
++        with pytest.raises(ValueError):
++            op(data_m(), rows)
++
++    def generate_incorrect_rows_raises(self, metafunc):
++        self.generate_mathematically_correct(metafunc)
++
++
++class TestReshape(UnaryOpMixin):
++    def op_numpy(self, matrix, rows, columns):
++        out_shape = (rows, columns)
++        return np.reshape(matrix, newshape=out_shape, order='C')
++
++    # All matrices should have the same number of elements in total, so we can
++    # use the same (rows, columns) parametrisation for each input.
++    shapes = [
++        (pytest.param((1, 100), id="bra"), ),
++        (pytest.param((100, 1), id="ket"), ),
++        (pytest.param((2, 50), id="non_square"), ),
++        (pytest.param((10, 10), id="square"), ),
++    ]
++
++    specialisations = [
++        pytest.param(data.reshape_dense, Dense, Dense),
++        pytest.param(data.reshape_csr, CSR, CSR),
++    ]
++
++    # `out_type` is included but not used so that
++    # `generate_mathematically_correct` can be re-used.
++    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
++    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
++        """
++        Test that the binary operation is correct for all the known type
++        specialisations.
++        """
++        matrix = data_m()
++        expected = self.op_numpy(matrix.to_array(), rows, columns)
++        test = op(matrix, rows, columns)
++        assert isinstance(test, out_type)
++        assert test.shape == expected.shape
++        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
++                                   rtol=self.rtol)
++
++    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
++                             ids=["negative1", "negative2", "invalid"])
++    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
++        with pytest.raises(ValueError):
++            op(data_m(), rows, columns)
++
++    def generate_incorrect_rows_raises(self, metafunc):
++        self.generate_mathematically_correct(metafunc)
+diff --git a/qutip/tests/core/test_brtools.py b/qutip/tests/core/test_brtools.py
+index 527ca897..c1b43188 100644
+--- a/qutip/tests/core/test_brtools.py
++++ b/qutip/tests/core/test_brtools.py
+@@ -1,336 +1,336 @@
+-import pytest
+-import qutip
+-import numpy as np
+-from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
+-from qutip.core.blochredfield import brterm, bloch_redfield_tensor
+-from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
+-                                  _br_term_data, _BlochRedfieldElement)
+-
+-
+-def _make_rand_data(shape):
+-    np.random.seed(11)
+-    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+-    return qutip.data.Dense(array)
+-
+-
+-transform = {
+-    0: lambda x: x,
+-    1: qutip.data.transpose,
+-    2: qutip.data.conj,
+-    3: qutip.data.adjoint
+-}
+-
+-
+-@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
+-@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
+-                         ids=['', 'transpose', 'conj', 'dag'])
+-@pytest.mark.parametrize('transright', [0, 1, 2, 3],
+-                         ids=['', 'transpose', 'conj', 'dag'])
+-def test_matmul_var(datatype, transleft, transright):
+-    shape = (5, 5)
+-    np.random.seed(11)
+-    left = qutip.data.to(datatype, _make_rand_data(shape))
+-    right = qutip.data.to(datatype, _make_rand_data(shape))
+-
+-    expected = qutip.data.matmul(
+-        transform[transleft](left),
+-        transform[transright](right),
+-        ).to_array()
+-
+-    computed = matmul_var_data(left, right, transleft, transright).to_array()
+-    np.testing.assert_allclose(computed, expected, rtol=1e-14)
+-
+-
+-@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
+-def test_eigen_transform(sparse):
+-    a = qutip.destroy(5)
+-    f = lambda t: t
+-    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
+-    eigenT = _EigenBasisTransform(op, sparse=sparse)
+-    evecs_qevo = eigenT.as_Qobj()
+-
+-    for t in [0, 1, 1.5]:
+-        eigenvals, ekets = op(t).eigenstates()
+-        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
+-                                   rtol=1e-14, atol=1e-14)
+-        np.testing.assert_allclose(
+-            np.abs(np.hstack([eket.full() for eket in ekets])),
+-            np.abs(eigenT.evecs(t).to_array()),
+-            rtol=1e-14, atol=1e-14
+-        )
+-        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
+-                                   np.abs(eigenT.evecs(t).to_array()),
+-                                   rtol=1e-14, atol=1e-14)
+-
+-
+-def test_eigen_transform_ket():
+-    N = 5
+-    a = qutip.destroy(N)
+-    op = a*a.dag() + a + a.dag()
+-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+-
+-    state = qutip.coherent(N, 1.1)
+-
+-    expected = (op @ state).full()
+-    computed = eigenT.from_eigbasis(
+-        0,
+-        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
+-    ).to_array()
+-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+-
+-
+-def test_eigen_transform_dm():
+-    N = 5
+-    a = qutip.destroy(N)
+-    op = a*a.dag() + a + a.dag()
+-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+-
+-    state = qutip.coherent_dm(N, 1.1)
+-
+-    expected = (op @ state).full()
+-    computed = eigenT.from_eigbasis(
+-        0,
+-        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
+-    ).to_array()
+-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+-
+-
+-def test_eigen_transform_oper_ket():
+-    N = 5
+-    a = qutip.destroy(N)
+-    op = a*a.dag() + a + a.dag()
+-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+-
+-    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
+-
+-    expected = (qutip.spre(op) @ state).full()
+-    computed = eigenT.from_eigbasis(
+-        0,
+-        qutip.data.matmul(qutip.spre(op_diag).data,
+-                          eigenT.to_eigbasis(0, state.data))
+-    ).to_array()
+-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+-
+-
+-def test_eigen_transform_super_ops():
+-    N = 5
+-    a = qutip.destroy(N)
+-    op = a*a.dag() + a + a.dag()
+-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+-
+-    state = qutip.sprepost(
+-        qutip.coherent_dm(N, 1.1),
+-        qutip.thermal_dm(N, 1.1)
+-    )
+-
+-    expected = (qutip.spre(op) @ state).full()
+-    computed = eigenT.from_eigbasis(
+-        0,
+-        qutip.data.matmul(qutip.spre(op_diag).data,
+-                          eigenT.to_eigbasis(0, state.data))
+-    ).to_array()
+-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('func',
+-                         [_br_term_dense, _br_term_sparse, _br_term_data],
+-                         ids=['dense', 'sparse', 'data'])
+-def test_br_term_linbblad_comp(func):
+-    N = 5
+-    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
+-    A_op = a + a.dag()
+-    H = qutip.num(N)
+-    diag = H.eigenenergies()
+-    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
+-    spectrum = (skew > 0) * 1.
+-    computation = func(A_op.data, spectrum, skew, 2).to_array()
+-    lindblad = qutip.lindblad_dissipator(a).full()
+-    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
+-@pytest.mark.parametrize('spectra', [
+-    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
+-    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
+-    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
+-])
+-def test_br_term(cutoff, spectra):
+-    N = 5
+-    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
+-    A_op = a + a.dag()
+-    H = qutip.num(N)
+-    diag = H.eigenenergies()
+-    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
+-    spectrum = spectra(skew)
+-    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
+-    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
+-    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
+-    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
+-    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+-def test_brterm(cutoff):
+-    N = 5
+-    H = qutip.num(N)
+-    a = qutip.destroy(N)
+-    A_op = a + a.dag()
+-    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
+-    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
+-    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
+-    assert isinstance(R, qutip.Qobj)
+-    assert isinstance(R_eigs, qutip.Qobj)
+-    assert isinstance(evecs, qutip.Qobj)
+-    state = qutip.operator_to_vector(qutip.rand_dm(N))
+-    fock_computed = R @ state
+-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+-    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
+-                               rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+-def test_td_brterm(cutoff):
+-    N = 5
+-    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
+-    a = qutip.destroy(N)
+-    A_op = qutip.QobjEvo([a + a.dag(), "t"])
+-    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
+-    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
+-    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
+-    assert isinstance(R, qutip.QobjEvo)
+-    assert isinstance(R_eigs, qutip.QobjEvo)
+-    assert isinstance(evecs, qutip.QobjEvo)
+-    state = qutip.operator_to_vector(qutip.rand_dm(N))
+-    fock_computed = R @ state
+-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+-    for t in [0, 0.5, 1.0]:
+-        np.testing.assert_allclose(
+-            (R(t) @ state).full(),
+-            R.matmul(t, state).full(),
+-            rtol=1e-14, atol=1e-14
+-        )
+-        np.testing.assert_allclose(fock_computed(t).full(),
+-                                   eig_computed(t).full(),
+-                                   rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+-def test_bloch_redfield_tensor_basis(cutoff):
+-    N = 5
+-    H = qutip.num(N)
+-    a = qutip.destroy(N)
+-    A_op = a + a.dag()
+-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+-    R = bloch_redfield_tensor(
+-        H=H,
+-        a_ops=[(A_op, spectra)],
+-        c_ops=[a**2],
+-        sec_cutoff=cutoff,
+-        fock_basis=True
+-    )
+-    R_eigs, evecs = bloch_redfield_tensor(
+-        H=H,
+-        a_ops=[(A_op, spectra)],
+-        c_ops=[a**2],
+-        sec_cutoff=cutoff,
+-        fock_basis=False
+-    )
+-    assert isinstance(R, qutip.Qobj)
+-    assert isinstance(R_eigs, qutip.Qobj)
+-    assert isinstance(evecs, qutip.Qobj)
+-    state = qutip.operator_to_vector(qutip.rand_dm(N))
+-    fock_computed = R @ state
+-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+-    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
+-                               rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+-def test_bloch_redfield_tensor(cutoff):
+-    N = 5
+-    H = qutip.num(N)
+-    a = qutip.destroy(N)
+-    A_op = a + a.dag()
+-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+-    R = bloch_redfield_tensor(
+-        H=H,
+-        a_ops=[(A_op, spectra)],
+-        c_ops=[a**2],
+-        sec_cutoff=cutoff,
+-        fock_basis=True
+-    )
+-    R_expected = qutip.liouvillian(H, [a**2])
+-    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
+-
+-    assert isinstance(R, qutip.Qobj)
+-    assert isinstance(R_expected, qutip.Qobj)
+-    np.testing.assert_allclose(R.full(), R_expected.full(),
+-                               rtol=1e-14, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize('fock_basis', [True, False])
+-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+-def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
+-    N = 3
+-    H = qutip.QobjEvo([qutip.num(N), "t"])
+-    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
+-    A_op = a + a.dag()
+-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+-    R = bloch_redfield_tensor(
+-        H=H,
+-        a_ops=[(A_op, spectra)],
+-        c_ops=[qutip.destroy(N)],
+-        sec_cutoff=cutoff,
+-        fock_basis=fock_basis
+-    )
+-    R = R[0] if not fock_basis else R
+-    assert isinstance(R, qutip.QobjEvo)
+-    for t in [0, 0.5, 1.0, 1.5]:
+-        R_expected = bloch_redfield_tensor(
+-            H=H(t),
+-            a_ops=[(A_op(t), spectra)],
+-            c_ops=[qutip.destroy(N)],
+-            sec_cutoff=cutoff,
+-            fock_basis=fock_basis
+-        )
+-        R_expected = R_expected[0] if not fock_basis else R_expected
+-        np.testing.assert_allclose(R(t).full(), R_expected.full(),
+-                                   rtol=1e-14, atol=1e-14)
+-
+-
+-def test_bloch_redfield_tensor_spectral_string():
+-    N = 5
+-    H = qutip.num(N)
+-    a = qutip.destroy(N)
+-    A_op = a + a.dag()
+-    spectra = "(w>0) * 0.5"
+-    R_eigs, evecs = bloch_redfield_tensor(
+-        H=H,
+-        a_ops=[(A_op, spectra)],
+-        c_ops=[a**2],
+-        fock_basis=False
+-    )
+-    assert isinstance(R_eigs, qutip.Qobj)
+-    assert isinstance(evecs, qutip.Qobj)
+-
+-def test_bloch_redfield_tensor_spectral_callable():
+-    N = 5
+-    H = qutip.num(N)
+-    a = qutip.destroy(N)
+-    A_op = a + a.dag()
+-    spectra = lambda w: (w>0) * 0.5
+-    R_eigs, evecs = bloch_redfield_tensor(
+-        H=H,
+-        a_ops=[(A_op, spectra)],
+-        c_ops=[a**2],
+-        fock_basis=False
+-    )
+-    assert isinstance(R_eigs, qutip.Qobj)
++import pytest
++import qutip
++import numpy as np
++from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
++from qutip.core.blochredfield import brterm, bloch_redfield_tensor
++from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
++                                  _br_term_data, _BlochRedfieldElement)
++
++
++def _make_rand_data(shape):
++    np.random.seed(11)
++    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
++    return qutip.data.Dense(array)
++
++
++transform = {
++    0: lambda x: x,
++    1: qutip.data.transpose,
++    2: qutip.data.conj,
++    3: qutip.data.adjoint
++}
++
++
++@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
++@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
++                         ids=['', 'transpose', 'conj', 'dag'])
++@pytest.mark.parametrize('transright', [0, 1, 2, 3],
++                         ids=['', 'transpose', 'conj', 'dag'])
++def test_matmul_var(datatype, transleft, transright):
++    shape = (5, 5)
++    np.random.seed(11)
++    left = qutip.data.to(datatype, _make_rand_data(shape))
++    right = qutip.data.to(datatype, _make_rand_data(shape))
++
++    expected = qutip.data.matmul(
++        transform[transleft](left),
++        transform[transright](right),
++        ).to_array()
++
++    computed = matmul_var_data(left, right, transleft, transright).to_array()
++    np.testing.assert_allclose(computed, expected, rtol=1e-14)
++
++
++@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
++def test_eigen_transform(sparse):
++    a = qutip.destroy(5)
++    f = lambda t: t
++    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
++    eigenT = _EigenBasisTransform(op, sparse=sparse)
++    evecs_qevo = eigenT.as_Qobj()
++
++    for t in [0, 1, 1.5]:
++        eigenvals, ekets = op(t).eigenstates()
++        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
++                                   rtol=1e-14, atol=1e-14)
++        np.testing.assert_allclose(
++            np.abs(np.hstack([eket.full() for eket in ekets])),
++            np.abs(eigenT.evecs(t).to_array()),
++            rtol=1e-14, atol=1e-14
++        )
++        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
++                                   np.abs(eigenT.evecs(t).to_array()),
++                                   rtol=1e-14, atol=1e-14)
++
++
++def test_eigen_transform_ket():
++    N = 5
++    a = qutip.destroy(N)
++    op = a*a.dag() + a + a.dag()
++    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
++    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
++
++    state = qutip.coherent(N, 1.1)
++
++    expected = (op @ state).full()
++    computed = eigenT.from_eigbasis(
++        0,
++        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
++    ).to_array()
++    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
++
++
++def test_eigen_transform_dm():
++    N = 5
++    a = qutip.destroy(N)
++    op = a*a.dag() + a + a.dag()
++    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
++    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
++
++    state = qutip.coherent_dm(N, 1.1)
++
++    expected = (op @ state).full()
++    computed = eigenT.from_eigbasis(
++        0,
++        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
++    ).to_array()
++    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
++
++
++def test_eigen_transform_oper_ket():
++    N = 5
++    a = qutip.destroy(N)
++    op = a*a.dag() + a + a.dag()
++    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
++    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
++
++    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
++
++    expected = (qutip.spre(op) @ state).full()
++    computed = eigenT.from_eigbasis(
++        0,
++        qutip.data.matmul(qutip.spre(op_diag).data,
++                          eigenT.to_eigbasis(0, state.data))
++    ).to_array()
++    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
++
++
++def test_eigen_transform_super_ops():
++    N = 5
++    a = qutip.destroy(N)
++    op = a*a.dag() + a + a.dag()
++    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
++    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
++
++    state = qutip.sprepost(
++        qutip.coherent_dm(N, 1.1),
++        qutip.thermal_dm(N, 1.1)
++    )
++
++    expected = (qutip.spre(op) @ state).full()
++    computed = eigenT.from_eigbasis(
++        0,
++        qutip.data.matmul(qutip.spre(op_diag).data,
++                          eigenT.to_eigbasis(0, state.data))
++    ).to_array()
++    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('func',
++                         [_br_term_dense, _br_term_sparse, _br_term_data],
++                         ids=['dense', 'sparse', 'data'])
++def test_br_term_linbblad_comp(func):
++    N = 5
++    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
++    A_op = a + a.dag()
++    H = qutip.num(N)
++    diag = H.eigenenergies()
++    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
++    spectrum = (skew > 0) * 1.
++    computation = func(A_op.data, spectrum, skew, 2).to_array()
++    lindblad = qutip.lindblad_dissipator(a).full()
++    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
++@pytest.mark.parametrize('spectra', [
++    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
++    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
++    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
++])
++def test_br_term(cutoff, spectra):
++    N = 5
++    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
++    A_op = a + a.dag()
++    H = qutip.num(N)
++    diag = H.eigenenergies()
++    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
++    spectrum = spectra(skew)
++    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
++    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
++    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
++    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
++    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
++def test_brterm(cutoff):
++    N = 5
++    H = qutip.num(N)
++    a = qutip.destroy(N)
++    A_op = a + a.dag()
++    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
++    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
++    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
++    assert isinstance(R, qutip.Qobj)
++    assert isinstance(R_eigs, qutip.Qobj)
++    assert isinstance(evecs, qutip.Qobj)
++    state = qutip.operator_to_vector(qutip.rand_dm(N))
++    fock_computed = R @ state
++    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
++    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
++    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
++                               rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
++def test_td_brterm(cutoff):
++    N = 5
++    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
++    a = qutip.destroy(N)
++    A_op = qutip.QobjEvo([a + a.dag(), "t"])
++    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
++    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
++    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
++    assert isinstance(R, qutip.QobjEvo)
++    assert isinstance(R_eigs, qutip.QobjEvo)
++    assert isinstance(evecs, qutip.QobjEvo)
++    state = qutip.operator_to_vector(qutip.rand_dm(N))
++    fock_computed = R @ state
++    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
++    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
++    for t in [0, 0.5, 1.0]:
++        np.testing.assert_allclose(
++            (R(t) @ state).full(),
++            R.matmul(t, state).full(),
++            rtol=1e-14, atol=1e-14
++        )
++        np.testing.assert_allclose(fock_computed(t).full(),
++                                   eig_computed(t).full(),
++                                   rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
++def test_bloch_redfield_tensor_basis(cutoff):
++    N = 5
++    H = qutip.num(N)
++    a = qutip.destroy(N)
++    A_op = a + a.dag()
++    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
++    R = bloch_redfield_tensor(
++        H=H,
++        a_ops=[(A_op, spectra)],
++        c_ops=[a**2],
++        sec_cutoff=cutoff,
++        fock_basis=True
++    )
++    R_eigs, evecs = bloch_redfield_tensor(
++        H=H,
++        a_ops=[(A_op, spectra)],
++        c_ops=[a**2],
++        sec_cutoff=cutoff,
++        fock_basis=False
++    )
++    assert isinstance(R, qutip.Qobj)
++    assert isinstance(R_eigs, qutip.Qobj)
++    assert isinstance(evecs, qutip.Qobj)
++    state = qutip.operator_to_vector(qutip.rand_dm(N))
++    fock_computed = R @ state
++    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
++    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
++    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
++                               rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
++def test_bloch_redfield_tensor(cutoff):
++    N = 5
++    H = qutip.num(N)
++    a = qutip.destroy(N)
++    A_op = a + a.dag()
++    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
++    R = bloch_redfield_tensor(
++        H=H,
++        a_ops=[(A_op, spectra)],
++        c_ops=[a**2],
++        sec_cutoff=cutoff,
++        fock_basis=True
++    )
++    R_expected = qutip.liouvillian(H, [a**2])
++    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
++
++    assert isinstance(R, qutip.Qobj)
++    assert isinstance(R_expected, qutip.Qobj)
++    np.testing.assert_allclose(R.full(), R_expected.full(),
++                               rtol=1e-14, atol=1e-14)
++
++
++@pytest.mark.parametrize('fock_basis', [True, False])
++@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
++def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
++    N = 3
++    H = qutip.QobjEvo([qutip.num(N), "t"])
++    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
++    A_op = a + a.dag()
++    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
++    R = bloch_redfield_tensor(
++        H=H,
++        a_ops=[(A_op, spectra)],
++        c_ops=[qutip.destroy(N)],
++        sec_cutoff=cutoff,
++        fock_basis=fock_basis
++    )
++    R = R[0] if not fock_basis else R
++    assert isinstance(R, qutip.QobjEvo)
++    for t in [0, 0.5, 1.0, 1.5]:
++        R_expected = bloch_redfield_tensor(
++            H=H(t),
++            a_ops=[(A_op(t), spectra)],
++            c_ops=[qutip.destroy(N)],
++            sec_cutoff=cutoff,
++            fock_basis=fock_basis
++        )
++        R_expected = R_expected[0] if not fock_basis else R_expected
++        np.testing.assert_allclose(R(t).full(), R_expected.full(),
++                                   rtol=1e-14, atol=1e-14)
++
++
++def test_bloch_redfield_tensor_spectral_string():
++    N = 5
++    H = qutip.num(N)
++    a = qutip.destroy(N)
++    A_op = a + a.dag()
++    spectra = "(w>0) * 0.5"
++    R_eigs, evecs = bloch_redfield_tensor(
++        H=H,
++        a_ops=[(A_op, spectra)],
++        c_ops=[a**2],
++        fock_basis=False
++    )
++    assert isinstance(R_eigs, qutip.Qobj)
++    assert isinstance(evecs, qutip.Qobj)
++
++def test_bloch_redfield_tensor_spectral_callable():
++    N = 5
++    H = qutip.num(N)
++    a = qutip.destroy(N)
++    A_op = a + a.dag()
++    spectra = lambda w: (w>0) * 0.5
++    R_eigs, evecs = bloch_redfield_tensor(
++        H=H,
++        a_ops=[(A_op, spectra)],
++        c_ops=[a**2],
++        fock_basis=False
++    )
++    assert isinstance(R_eigs, qutip.Qobj)
+     assert isinstance(evecs, qutip.Qobj)
+\ No newline at end of file
+diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
+index 2fe5ff0b..5c2807ac 100644
+--- a/qutip/tests/core/test_coefficient.py
++++ b/qutip/tests/core/test_coefficient.py
+@@ -1,397 +1,397 @@
+-import pytest
+-import pickle
+-import qutip
+-import numpy as np
+-import scipy.interpolate as interp
+-from functools import partial
+-from qutip.core.coefficient import (coefficient, norm, conj,
+-                                    CompilationOptions, Coefficient,
+-                                    clean_compiled_coefficient
+-                                   )
+-from qutip.core.options import CoreOptions
+-
+-# Ensure the latest version is tested
+-clean_compiled_coefficient(True)
+-
+-
+-def f(t, w):
+-    return np.exp(w * t * np.pi)
+-
+-
+-def g(t, w):
+-    return np.cos(w * t * np.pi)
+-
+-
+-def h(t, a, b):
+-    return a + b + t
+-
+-
+-def f_kw(t, w, **args):
+-    return f(t, w)
+-
+-
+-def g_kw(t, w, **args):
+-    return g(t, w)
+-
+-
+-def h_kw(t, a, b, **args):
+-    return h(t, a, b)
+-
+-
+-def f_qtv4(t, args):
+-    return f(t, args["w"])
+-
+-
+-def g_qtv4(t, args):
+-    return g(t, args["w"])
+-
+-
+-def h_qtv4(t, args):
+-    return h(t, args["a"], args["b"])
+-
+-
+-def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
+-    "assert coeff1 == coeff2"
+-    "inside refer to the range covered by tlistlog: [0.01, 1]"
+-    ts = np.linspace(0.01, 1, 20)
+-    eps = 1e-12
+-    crit_times = [0.01+eps, 0.95, 1-eps]
+-    if not inside:
+-        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
+-    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
+-    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
+-    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
+-
+-
+-args = {"w": 1j}
+-tlist = np.linspace(0, 1, 101)
+-f_asarray = f(tlist, **args)
+-g_asarray = g(tlist, **args)
+-tlistlog = np.logspace(-2, 0, 501)
+-f_asarraylog = f(tlistlog, **args)
+-
+-
+-def coeff_generator(style, func):
+-    """Make a Coefficient"""
+-    if func == "f":
+-        base = f
+-    else:
+-        base = g
+-
+-    if style == "func":
+-        return coefficient(base, args=args)
+-    if style == "array":
+-        return coefficient(base(tlist, **args), tlist=tlist)
+-    if style == "arraylog":
+-        return coefficient(base(tlistlog, **args), tlist=tlistlog)
+-    if style == "string" and func == "f":
+-        return coefficient("exp(w * t * pi)", args=args)
+-    if style == "string" and func == "g":
+-        return coefficient("cos(w * t * pi)", args=args)
+-    if style == "steparray":
+-        return coefficient(base(tlist, **args), tlist=tlist,
+-                           order=0)
+-    if style == "steparraylog":
+-        return coefficient(base(tlistlog, **args), tlist=tlistlog,
+-                           order=0)
+-
+-
+-@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
+-    pytest.param(f, {'args': args},
+-                 1e-10, id="func"),
+-    pytest.param(f_kw, {'args': args},
+-                 1e-10, id="func_keywords"),
+-    pytest.param(f_qtv4, {'args': args},
+-                 1e-10, id="func_qutip_v4"),
+-    pytest.param(f_asarray, {'tlist': tlist},
+-                 1e-6,  id="array"),
+-    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
+-                 1e-1, id="step_array"),
+-    pytest.param(f_asarraylog, {'tlist': tlistlog},
+-                 1e-6, id="nonlinear_array"),
+-    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
+-                 1e-1, id="nonlinear_step_array"),
+-    pytest.param("exp(w * t * pi)", {'args': args},
+-                 1e-10, id="string")
+-])
+-def test_CoeffCreationCall(base, kwargs, tol):
+-    opt = CompilationOptions(recompile=True)
+-    expected = lambda t: np.exp(1j * t * np.pi)
+-    coeff = coefficient(base, **kwargs, compile_opt=opt)
+-    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
+-
+-
+-@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
+-    pytest.param(f, {'args': args},
+-                 1e-10, id="func"),
+-    pytest.param(f_kw, {'args': args},
+-                 1e-10, id="func_keywords"),
+-    pytest.param(f_qtv4, {'args': args},
+-                 1e-10, id="func_qutip_v4"),
+-    pytest.param("exp(w * t * pi)", {'args': args},
+-                 1e-10, id="string")
+-])
+-def test_CoeffCallArgs(base, kwargs, tol):
+-    w = np.e + 0.5j
+-    expected = lambda t: np.exp(w * t * np.pi)
+-    coeff = coefficient(base, **kwargs)
+-    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
+-
+-
+-@pytest.mark.parametrize(['base', 'tol'], [
+-    pytest.param(h, 1e-10, id="func"),
+-    pytest.param(h_kw, 1e-10, id="func_keywords"),
+-    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
+-    pytest.param("a + b + t", 1e-10, id="string")
+-])
+-def test_CoeffCallArguments(base, tol):
+-    # Partial args update
+-    args = {"a": 1, "b": 1}
+-    a = np.e
+-    expected = lambda t: a + 1 + t
+-    coeff = coefficient(base, args=args)
+-    coeff = coeff.replace_arguments({"a": a})
+-    _assert_eq_over_interval(coeff, expected, rtol=tol)
+-    b = np.pi
+-    expected = lambda t: a + b + t
+-    coeff = coeff.replace_arguments(b=b)
+-    _assert_eq_over_interval(coeff, expected, rtol=tol)
+-
+-
+-@pytest.mark.parametrize(['style'], [
+-    pytest.param("func", id="func"),
+-    pytest.param("array", id="array"),
+-    pytest.param("arraylog", id="logarray"),
+-    pytest.param("string", id="string"),
+-    pytest.param("steparray", id="steparray"),
+-    pytest.param("steparraylog", id="steparraylog")
+-])
+-@pytest.mark.parametrize(['transform', 'expected'], [
+-    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
+-    pytest.param(conj, lambda val: np.conj(val), id="conj"),
+-])
+-def test_CoeffUnitaryTransform(style, transform, expected):
+-    coeff = coeff_generator(style, "f")
+-    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
+-
+-
+-@pytest.mark.parametrize(['style_left'], [
+-    pytest.param("func", id="func"),
+-    pytest.param("array", id="array"),
+-    pytest.param("arraylog", id="logarray"),
+-    pytest.param("string", id="string"),
+-    pytest.param("steparray", id="steparray"),
+-    pytest.param("steparraylog", id="steparraylog")
+-])
+-@pytest.mark.parametrize(['style_right'], [
+-    pytest.param("func", id="func"),
+-    pytest.param("array", id="array"),
+-    pytest.param("arraylog", id="logarray"),
+-    pytest.param("string", id="string"),
+-    pytest.param("steparray", id="steparray"),
+-    pytest.param("steparraylog", id="steparraylog")
+-])
+-@pytest.mark.parametrize(['oper'], [
+-    pytest.param(lambda a, b: a+b, id="sum"),
+-    pytest.param(lambda a, b: a*b, id="prod"),
+-])
+-def test_CoeffOperation(style_left, style_right, oper):
+-    coeff_left = coeff_generator(style_left, "f")
+-    coeff_right = coeff_generator(style_right, "g")
+-    _assert_eq_over_interval(
+-        oper(coeff_left, coeff_right),
+-        lambda t: oper(coeff_left(t), coeff_right(t))
+-    )
+-
+-
+-@pytest.mark.requires_cython
+-def test_CoeffReuse():
+-    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
+-    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
+-    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
+-    assert isinstance(coeff2, coeff1.__class__)
+-    assert isinstance(coeff3, coeff1.__class__)
+-
+-
+-@pytest.mark.requires_cython
+-def test_CoeffOptions():
+-    from itertools import combinations
+-    base = "1 + 1. + 1j"
+-    options = []
+-    options.append(CompilationOptions(accept_int=True))
+-    options.append(CompilationOptions(accept_float=False))
+-    options.append(CompilationOptions(static_types=True))
+-    options.append(CompilationOptions(try_parse=False))
+-    options.append(CompilationOptions(use_cython=False))
+-    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
+-    for coeff in coeffs:
+-        assert coeff(0) == 2+1j
+-    for coeff1, coeff2 in combinations(coeffs, 2):
+-        assert not isinstance(coeff1, coeff2.__class__)
+-
+-
+-@pytest.mark.requires_cython
+-@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
+-    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
+-                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
+-                 lambda t: 0, id="long"),
+-    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
+-                 lambda t: t + 1, id="lots_of_ctes"),
+-    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
+-                 lambda t: np.cos(t), id="real_array_subscript"),
+-    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
+-                 lambda t: 1, id="cplx_array_subscript"),
+-    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
+-                 lambda t: np.cos(t), id="dictargs"),
+-    pytest.param("cos(t*a); print(a)", {'a': 1},
+-                 lambda t: np.cos(t), id="print"),
+-    pytest.param("t + (0 if not 'something' else 1)", {},
+-                 lambda t: t + 1, id="branch")
+-])
+-@pytest.mark.filterwarnings(
+-    "ignore::qutip.core.coefficient.StringParsingWarning"
+-)
+-def test_CoeffParsingStressTest(codestring, args, reference):
+-    opt = CompilationOptions(recompile=True)
+-    coeff = coefficient(codestring, args=args, compile_opt=opt)
+-    _assert_eq_over_interval(coeff, reference)
+-
+-
+-@pytest.mark.requires_cython
+-@pytest.mark.filterwarnings("error")
+-def test_manual_typing():
+-    opt = CompilationOptions(recompile=True)
+-    coeff = coefficient("my_list[0] + my_dict[5]",
+-                        args={"my_list": [1], "my_dict": {5: 2}},
+-                        args_ctypes={"my_list": "list", "my_dict": "dict"},
+-                        compile_opt=opt)
+-    assert coeff(0) == 3
+-
+-
+-@pytest.mark.requires_cython
+-def test_advance_use():
+-    opt = CompilationOptions(recompile=True, extra_import="""
+-from qutip import basis
+-from qutip.core.data cimport CSR
+-from qutip.core.data.expect cimport expect_csr
+-""")
+-    csr = qutip.num(3).data
+-    coeff = coefficient("expect_csr(op, op)",
+-                        args={"op": csr},
+-                        args_ctypes={"op": "CSR"},
+-                        compile_opt=opt)
+-    assert coeff(0) == 5.
+-
+-
+-def _add(coeff):
+-    return coeff + coeff
+-
+-
+-def _pass(coeff):
+-    return coeff
+-
+-
+-def _mul(coeff):
+-    return coeff * coeff
+-
+-
+-@pytest.mark.parametrize(['style'], [
+-    pytest.param("func", id="func"),
+-    pytest.param("array", id="array"),
+-    pytest.param("arraylog", id="logarray"),
+-    pytest.param("string", id="string"),
+-    pytest.param("steparray", id="steparray"),
+-    pytest.param("steparraylog", id="steparraylog")
+-])
+-@pytest.mark.parametrize(['transform'], [
+-    pytest.param(_pass, id="single"),
+-    pytest.param(_add, id="sum"),
+-    pytest.param(_mul, id="prod"),
+-    pytest.param(norm, id="norm"),
+-    pytest.param(conj, id="conj"),
+-])
+-def test_Coeffpickle(style, transform):
+-    coeff = coeff_generator(style, "f")
+-    coeff = transform(coeff)
+-    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
+-    _assert_eq_over_interval(coeff, coeff_pick)
+-
+-
+-@pytest.mark.parametrize(['style'], [
+-    pytest.param("func", id="func"),
+-    pytest.param("array", id="array"),
+-    pytest.param("arraylog", id="logarray"),
+-    pytest.param("string", id="string"),
+-    pytest.param("steparray", id="steparray"),
+-    pytest.param("steparraylog", id="steparraylog")
+-])
+-@pytest.mark.parametrize(['transform'], [
+-    pytest.param(_pass, id="single"),
+-    pytest.param(_add, id="sum"),
+-    pytest.param(_mul, id="prod"),
+-    pytest.param(norm, id="norm"),
+-    pytest.param(conj, id="conj"),
+-])
+-def test_Coeffcopy(style, transform):
+-    coeff = coeff_generator(style, "f")
+-    coeff = transform(coeff)
+-    coeff_cp = coeff.copy()
+-    _assert_eq_over_interval(coeff, coeff_cp)
+-
+-
+-@pytest.mark.parametrize('order', [0, 1, 2, 3])
+-def test_CoeffArray(order):
+-    tlist = np.linspace(0, 1, 101)
+-    y = np.exp((-1 + 1j) * tlist)
+-    coeff = coefficient(y, tlist=tlist, order=order)
+-    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
+-    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
+-                             inside=True)
+-    dt = 1e-4
+-    t = 0.0225
+-    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
+-    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
+-    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
+-             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
+-    derrs = [derr, derr2, derr3]
+-    for i in range(order):
+-        assert derrs[i] != 0
+-    for i in range(order, 3):
+-        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
+-
+-
+-def test_CoeffFromScipy():
+-    tlist = np.linspace(0, 1.01, 101)
+-    y = np.exp((-1 + 1j) * tlist)
+-
+-    coeff = coefficient(y, tlist=tlist, order=3)
+-    from_scipy = coefficient(interp.CubicSpline(tlist, y))
+-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+-
+-    coeff = coefficient(y, tlist=tlist, order=3)
+-    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
+-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+-
+-    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
+-    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
+-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+-
+-
+-@pytest.mark.parametrize('map_func', [
+-    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
+-    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
+-])
+-@pytest.mark.requires_cython
+-def test_coefficient_parallel(map_func):
+-    otherwise_never_used = "np.log(np.exp(t + t + t))"
+-    expected = coefficient(lambda t: 3 * t)
+-
+-    if map_func is qutip.solver.parallel.loky_pmap:
+-        loky = pytest.importorskip("loky")
+-        otherwise_never_used += " + 0"
+-
+-    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
+-
+-    for coeff in coeffs:
+-        assert isinstance(coeff, Coefficient)
+-        _assert_eq_over_interval(coeff, expected)
++import pytest
++import pickle
++import qutip
++import numpy as np
++import scipy.interpolate as interp
++from functools import partial
++from qutip.core.coefficient import (coefficient, norm, conj,
++                                    CompilationOptions, Coefficient,
++                                    clean_compiled_coefficient
++                                   )
++from qutip.core.options import CoreOptions
++
++# Ensure the latest version is tested
++clean_compiled_coefficient(True)
++
++
++def f(t, w):
++    return np.exp(w * t * np.pi)
++
++
++def g(t, w):
++    return np.cos(w * t * np.pi)
++
++
++def h(t, a, b):
++    return a + b + t
++
++
++def f_kw(t, w, **args):
++    return f(t, w)
++
++
++def g_kw(t, w, **args):
++    return g(t, w)
++
++
++def h_kw(t, a, b, **args):
++    return h(t, a, b)
++
++
++def f_qtv4(t, args):
++    return f(t, args["w"])
++
++
++def g_qtv4(t, args):
++    return g(t, args["w"])
++
++
++def h_qtv4(t, args):
++    return h(t, args["a"], args["b"])
++
++
++def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
++    "assert coeff1 == coeff2"
++    "inside refer to the range covered by tlistlog: [0.01, 1]"
++    ts = np.linspace(0.01, 1, 20)
++    eps = 1e-12
++    crit_times = [0.01+eps, 0.95, 1-eps]
++    if not inside:
++        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
++    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
++    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
++    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
++
++
++args = {"w": 1j}
++tlist = np.linspace(0, 1, 101)
++f_asarray = f(tlist, **args)
++g_asarray = g(tlist, **args)
++tlistlog = np.logspace(-2, 0, 501)
++f_asarraylog = f(tlistlog, **args)
++
++
++def coeff_generator(style, func):
++    """Make a Coefficient"""
++    if func == "f":
++        base = f
++    else:
++        base = g
++
++    if style == "func":
++        return coefficient(base, args=args)
++    if style == "array":
++        return coefficient(base(tlist, **args), tlist=tlist)
++    if style == "arraylog":
++        return coefficient(base(tlistlog, **args), tlist=tlistlog)
++    if style == "string" and func == "f":
++        return coefficient("exp(w * t * pi)", args=args)
++    if style == "string" and func == "g":
++        return coefficient("cos(w * t * pi)", args=args)
++    if style == "steparray":
++        return coefficient(base(tlist, **args), tlist=tlist,
++                           order=0)
++    if style == "steparraylog":
++        return coefficient(base(tlistlog, **args), tlist=tlistlog,
++                           order=0)
++
++
++@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
++    pytest.param(f, {'args': args},
++                 1e-10, id="func"),
++    pytest.param(f_kw, {'args': args},
++                 1e-10, id="func_keywords"),
++    pytest.param(f_qtv4, {'args': args},
++                 1e-10, id="func_qutip_v4"),
++    pytest.param(f_asarray, {'tlist': tlist},
++                 1e-6,  id="array"),
++    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
++                 1e-1, id="step_array"),
++    pytest.param(f_asarraylog, {'tlist': tlistlog},
++                 1e-6, id="nonlinear_array"),
++    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
++                 1e-1, id="nonlinear_step_array"),
++    pytest.param("exp(w * t * pi)", {'args': args},
++                 1e-10, id="string")
++])
++def test_CoeffCreationCall(base, kwargs, tol):
++    opt = CompilationOptions(recompile=True)
++    expected = lambda t: np.exp(1j * t * np.pi)
++    coeff = coefficient(base, **kwargs, compile_opt=opt)
++    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
++
++
++@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
++    pytest.param(f, {'args': args},
++                 1e-10, id="func"),
++    pytest.param(f_kw, {'args': args},
++                 1e-10, id="func_keywords"),
++    pytest.param(f_qtv4, {'args': args},
++                 1e-10, id="func_qutip_v4"),
++    pytest.param("exp(w * t * pi)", {'args': args},
++                 1e-10, id="string")
++])
++def test_CoeffCallArgs(base, kwargs, tol):
++    w = np.e + 0.5j
++    expected = lambda t: np.exp(w * t * np.pi)
++    coeff = coefficient(base, **kwargs)
++    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
++
++
++@pytest.mark.parametrize(['base', 'tol'], [
++    pytest.param(h, 1e-10, id="func"),
++    pytest.param(h_kw, 1e-10, id="func_keywords"),
++    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
++    pytest.param("a + b + t", 1e-10, id="string")
++])
++def test_CoeffCallArguments(base, tol):
++    # Partial args update
++    args = {"a": 1, "b": 1}
++    a = np.e
++    expected = lambda t: a + 1 + t
++    coeff = coefficient(base, args=args)
++    coeff = coeff.replace_arguments({"a": a})
++    _assert_eq_over_interval(coeff, expected, rtol=tol)
++    b = np.pi
++    expected = lambda t: a + b + t
++    coeff = coeff.replace_arguments(b=b)
++    _assert_eq_over_interval(coeff, expected, rtol=tol)
++
++
++@pytest.mark.parametrize(['style'], [
++    pytest.param("func", id="func"),
++    pytest.param("array", id="array"),
++    pytest.param("arraylog", id="logarray"),
++    pytest.param("string", id="string"),
++    pytest.param("steparray", id="steparray"),
++    pytest.param("steparraylog", id="steparraylog")
++])
++@pytest.mark.parametrize(['transform', 'expected'], [
++    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
++    pytest.param(conj, lambda val: np.conj(val), id="conj"),
++])
++def test_CoeffUnitaryTransform(style, transform, expected):
++    coeff = coeff_generator(style, "f")
++    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
++
++
++@pytest.mark.parametrize(['style_left'], [
++    pytest.param("func", id="func"),
++    pytest.param("array", id="array"),
++    pytest.param("arraylog", id="logarray"),
++    pytest.param("string", id="string"),
++    pytest.param("steparray", id="steparray"),
++    pytest.param("steparraylog", id="steparraylog")
++])
++@pytest.mark.parametrize(['style_right'], [
++    pytest.param("func", id="func"),
++    pytest.param("array", id="array"),
++    pytest.param("arraylog", id="logarray"),
++    pytest.param("string", id="string"),
++    pytest.param("steparray", id="steparray"),
++    pytest.param("steparraylog", id="steparraylog")
++])
++@pytest.mark.parametrize(['oper'], [
++    pytest.param(lambda a, b: a+b, id="sum"),
++    pytest.param(lambda a, b: a*b, id="prod"),
++])
++def test_CoeffOperation(style_left, style_right, oper):
++    coeff_left = coeff_generator(style_left, "f")
++    coeff_right = coeff_generator(style_right, "g")
++    _assert_eq_over_interval(
++        oper(coeff_left, coeff_right),
++        lambda t: oper(coeff_left(t), coeff_right(t))
++    )
++
++
++@pytest.mark.requires_cython
++def test_CoeffReuse():
++    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
++    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
++    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
++    assert isinstance(coeff2, coeff1.__class__)
++    assert isinstance(coeff3, coeff1.__class__)
++
++
++@pytest.mark.requires_cython
++def test_CoeffOptions():
++    from itertools import combinations
++    base = "1 + 1. + 1j"
++    options = []
++    options.append(CompilationOptions(accept_int=True))
++    options.append(CompilationOptions(accept_float=False))
++    options.append(CompilationOptions(static_types=True))
++    options.append(CompilationOptions(try_parse=False))
++    options.append(CompilationOptions(use_cython=False))
++    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
++    for coeff in coeffs:
++        assert coeff(0) == 2+1j
++    for coeff1, coeff2 in combinations(coeffs, 2):
++        assert not isinstance(coeff1, coeff2.__class__)
++
++
++@pytest.mark.requires_cython
++@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
++    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
++                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
++                 lambda t: 0, id="long"),
++    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
++                 lambda t: t + 1, id="lots_of_ctes"),
++    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
++                 lambda t: np.cos(t), id="real_array_subscript"),
++    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
++                 lambda t: 1, id="cplx_array_subscript"),
++    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
++                 lambda t: np.cos(t), id="dictargs"),
++    pytest.param("cos(t*a); print(a)", {'a': 1},
++                 lambda t: np.cos(t), id="print"),
++    pytest.param("t + (0 if not 'something' else 1)", {},
++                 lambda t: t + 1, id="branch")
++])
++@pytest.mark.filterwarnings(
++    "ignore::qutip.core.coefficient.StringParsingWarning"
++)
++def test_CoeffParsingStressTest(codestring, args, reference):
++    opt = CompilationOptions(recompile=True)
++    coeff = coefficient(codestring, args=args, compile_opt=opt)
++    _assert_eq_over_interval(coeff, reference)
++
++
++@pytest.mark.requires_cython
++@pytest.mark.filterwarnings("error")
++def test_manual_typing():
++    opt = CompilationOptions(recompile=True)
++    coeff = coefficient("my_list[0] + my_dict[5]",
++                        args={"my_list": [1], "my_dict": {5: 2}},
++                        args_ctypes={"my_list": "list", "my_dict": "dict"},
++                        compile_opt=opt)
++    assert coeff(0) == 3
++
++
++@pytest.mark.requires_cython
++def test_advance_use():
++    opt = CompilationOptions(recompile=True, extra_import="""
++from qutip import basis
++from qutip.core.data cimport CSR
++from qutip.core.data.expect cimport expect_csr
++""")
++    csr = qutip.num(3).data
++    coeff = coefficient("expect_csr(op, op)",
++                        args={"op": csr},
++                        args_ctypes={"op": "CSR"},
++                        compile_opt=opt)
++    assert coeff(0) == 5.
++
++
++def _add(coeff):
++    return coeff + coeff
++
++
++def _pass(coeff):
++    return coeff
++
++
++def _mul(coeff):
++    return coeff * coeff
++
++
++@pytest.mark.parametrize(['style'], [
++    pytest.param("func", id="func"),
++    pytest.param("array", id="array"),
++    pytest.param("arraylog", id="logarray"),
++    pytest.param("string", id="string"),
++    pytest.param("steparray", id="steparray"),
++    pytest.param("steparraylog", id="steparraylog")
++])
++@pytest.mark.parametrize(['transform'], [
++    pytest.param(_pass, id="single"),
++    pytest.param(_add, id="sum"),
++    pytest.param(_mul, id="prod"),
++    pytest.param(norm, id="norm"),
++    pytest.param(conj, id="conj"),
++])
++def test_Coeffpickle(style, transform):
++    coeff = coeff_generator(style, "f")
++    coeff = transform(coeff)
++    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
++    _assert_eq_over_interval(coeff, coeff_pick)
++
++
++@pytest.mark.parametrize(['style'], [
++    pytest.param("func", id="func"),
++    pytest.param("array", id="array"),
++    pytest.param("arraylog", id="logarray"),
++    pytest.param("string", id="string"),
++    pytest.param("steparray", id="steparray"),
++    pytest.param("steparraylog", id="steparraylog")
++])
++@pytest.mark.parametrize(['transform'], [
++    pytest.param(_pass, id="single"),
++    pytest.param(_add, id="sum"),
++    pytest.param(_mul, id="prod"),
++    pytest.param(norm, id="norm"),
++    pytest.param(conj, id="conj"),
++])
++def test_Coeffcopy(style, transform):
++    coeff = coeff_generator(style, "f")
++    coeff = transform(coeff)
++    coeff_cp = coeff.copy()
++    _assert_eq_over_interval(coeff, coeff_cp)
++
++
++@pytest.mark.parametrize('order', [0, 1, 2, 3])
++def test_CoeffArray(order):
++    tlist = np.linspace(0, 1, 101)
++    y = np.exp((-1 + 1j) * tlist)
++    coeff = coefficient(y, tlist=tlist, order=order)
++    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
++    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
++                             inside=True)
++    dt = 1e-4
++    t = 0.0225
++    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
++    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
++    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
++             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
++    derrs = [derr, derr2, derr3]
++    for i in range(order):
++        assert derrs[i] != 0
++    for i in range(order, 3):
++        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
++
++
++def test_CoeffFromScipy():
++    tlist = np.linspace(0, 1.01, 101)
++    y = np.exp((-1 + 1j) * tlist)
++
++    coeff = coefficient(y, tlist=tlist, order=3)
++    from_scipy = coefficient(interp.CubicSpline(tlist, y))
++    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
++
++    coeff = coefficient(y, tlist=tlist, order=3)
++    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
++    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
++
++    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
++    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
++    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
++
++
++@pytest.mark.parametrize('map_func', [
++    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
++    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
++])
++@pytest.mark.requires_cython
++def test_coefficient_parallel(map_func):
++    otherwise_never_used = "np.log(np.exp(t + t + t))"
++    expected = coefficient(lambda t: 3 * t)
++
++    if map_func is qutip.solver.parallel.loky_pmap:
++        loky = pytest.importorskip("loky")
++        otherwise_never_used += " + 0"
++
++    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
++
++    for coeff in coeffs:
++        assert isinstance(coeff, Coefficient)
++        _assert_eq_over_interval(coeff, expected)
+diff --git a/qutip/tests/core/test_dimensions.py b/qutip/tests/core/test_dimensions.py
+index a32c3029..d21f2983 100644
+--- a/qutip/tests/core/test_dimensions.py
++++ b/qutip/tests/core/test_dimensions.py
+@@ -1,201 +1,201 @@
+-# -*- coding: utf-8 -*-
+-
+-import pytest
+-import collections
+-import qutip
+-from qutip.core.dimensions import (
+-    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
+-    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
+-    collapse_dims_super, collapse_dims_oper,
+-)
+-
+-_v = "vector"
+-_vo = "vectorized_oper"
+-
+-
+-@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
+-    pytest.param([1], _v, True, id="scalar"),
+-    pytest.param([1, 1], _v, True, id="tensor scalar"),
+-    pytest.param([[1]], _vo, True, id="nested scalar"),
+-    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
+-    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
+-    pytest.param([2], _v, False, id="vector"),
+-    pytest.param([2, 3], _v, False, id="tensor vector"),
+-    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
+-    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
+-    pytest.param([[2]], _vo, False, id="vectorised operator"),
+-    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
+-    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
+-])
+-@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
+-def test_rank_type_detection(rank, actual_type, scalar, test_type):
+-    """
+-    Test the rank detection tests `is_scalar`, `is_vector` and
+-    `is_vectorized_oper` for a range of different test cases.  These tests are
+-    designed to be called on individual elements of the two-element `dims`
+-    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
+-
+-    It's possible to be both a scalar and something else, but "vector" and
+-    "vectorized_oper" are mutually exclusive.
+-
+-    These functions aren't properly specified for improper dimension setups, so
+-    there are no tests for those.
+-    """
+-    expected = scalar if test_type == "scalar" else (actual_type == test_type)
+-    function = getattr(qutip.dimensions, "is_" + test_type)
+-    assert function(rank) == expected
+-
+-
+-@pytest.mark.parametrize(["base", "flat"], [
+-    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
+-    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
+-                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
+-    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
+-    pytest.param([], [], id="empty list"),
+-    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
+-])
+-class TestFlattenUnflatten:
+-    def test_flatten(self, base, flat):
+-        assert flatten(base) == flat
+-
+-    def test_unflatten(self, base, flat):
+-        labels = enumerate_flat(base)
+-        assert unflatten(flat, labels) == base
+-
+-
+-@pytest.mark.parametrize(["base", "expected"], [
+-    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
+-    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
+-    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
+-    pytest.param([], [], id="empty"),
+-    pytest.param([[], [], [[[], [], []]]],
+-                 [[], [], [[[], [], []]]], id="nested empty lists"),
+-])
+-def test_enumerate_flat(base, expected):
+-    assert enumerate_flat(base) == expected
+-
+-
+-@pytest.mark.parametrize(["base", "to_remove", "expected"], [
+-    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
+-    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
+-                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
+-    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
+-    pytest.param([], (), [], id="empty"),
+-])
+-def test_deep_remove(base, to_remove, expected):
+-    assert deep_remove(base, *to_remove) == expected
+-
+-
+-@pytest.mark.parametrize("mapping", [
+-    pytest.param(lambda x: x*2, id="(x -> 2x)"),
+-    pytest.param(lambda x: [x], id="(x -> [x])"),
+-])
+-@pytest.mark.parametrize("base", [
+-    pytest.param([[[0], 1], 2], id="standard"),
+-    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
+-    pytest.param([1, 2, 3], id="flat"),
+-    pytest.param([], id="empty list"),
+-    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
+-])
+-def test_deep_map(base, mapping):
+-    """
+-    Test the deep mapping.  To simplify generation of edge-cases, this tests
+-    against an equivalent (but slower) operation of flattening and unflattening
+-    the list.  We can get false negatives if the `flatten` or `unflatten`
+-    functions are broken, but other tests should catch those.
+-    """
+-    # This function might not need to be public, and consequently might not
+-    # need to be tested here.
+-    labels = enumerate_flat(base)
+-    expected = unflatten([mapping(x) for x in flatten(base)], labels)
+-    assert deep_map(mapping, base) == expected
+-
+-
+-_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
+-
+-
+-@pytest.mark.parametrize("indices", [
+-    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
+-    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
+-                 id="tensor-ket preserved"),
+-    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
+-    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
+-                 id="tensor-bra preserved"),
+-    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
+-    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
+-                 id="tensor-oper preserved"),
+-    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
+-                          [2, 3, 0, 1, 6, 7, 4, 5],
+-                          (6, 8, 2, 4, 5, 7, 1, 3)),
+-                 id="super-oper"),
+-    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
+-                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
+-                 id="operator-ket"),
+-    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
+-                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
+-                 id="operator-bra"),
+-])
+-class TestSuperOperatorDimsModification:
+-    def test_dims_to_tensor_perm(self, indices):
+-        # This function might not need to be public, and consequently might not
+-        # need to be tested here.
+-        assert dims_to_tensor_perm(indices.base) == indices.permutation
+-
+-    def test_dims_idxs_to_tensor_idxs(self, indices):
+-        test_indices = list(range(len(flatten(indices.base))))
+-        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
+-                == indices.permutation)
+-
+-    def test_dims_to_tensor_shape(self, indices):
+-        assert dims_to_tensor_shape(indices.base) == indices.shape
+-
+-
+-class TestTypeFromDims:
+-    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
+-        pytest.param([[2], [2]], 'oper', True),
+-        pytest.param([[2, 3], [2, 3]], 'oper', True),
+-        pytest.param([[2], [3]], 'other', True),
+-        pytest.param([[2], [3]], 'oper', False),
+-        pytest.param([[2], [1]], 'ket', True),
+-        pytest.param([[1], [2]], 'bra', True),
+-        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
+-        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
+-        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
+-        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
+-        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
+-    ])
+-    def test_type_from_dims(self, base, expected, enforce_square):
+-        assert type_from_dims(base, enforce_square=enforce_square) == expected
+-
+-    @pytest.mark.parametrize("qobj", [
+-        pytest.param(qutip.rand_ket(10), id='ket'),
+-        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
+-        pytest.param(qutip.rand_dm(10), id='oper'),
+-        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
+-    ])
+-    def test_qobj_dims_match_qobj(self, qobj):
+-        assert type_from_dims(qobj.dims) == qobj.type
+-
+-
+-class TestCollapseDims:
+-    @pytest.mark.parametrize(["base", "expected"], [
+-        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
+-        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
+-        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
+-        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
+-        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
+-        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
+-    ])
+-    def test_oper(self, base, expected):
+-        assert collapse_dims_oper(base) == expected
+-
+-    @pytest.mark.parametrize(["base", "expected"], [
+-        pytest.param([[[1]], [[2, 3], [2, 3]]],
+-                     [[[1]], [[6], [6]]], id="operator-ket"),
+-        pytest.param([[[2, 3], [2, 3]], [[1]]],
+-                     [[[6], [6]], [[1]]], id="operator-bra"),
+-        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
+-                     [[[6], [6]], [[6], [6]]], id="super"),
+-    ])
+-    def test_super(self, base, expected):
+-        assert collapse_dims_super(base) == expected
++# -*- coding: utf-8 -*-
++
++import pytest
++import collections
++import qutip
++from qutip.core.dimensions import (
++    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
++    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
++    collapse_dims_super, collapse_dims_oper,
++)
++
++_v = "vector"
++_vo = "vectorized_oper"
++
++
++@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
++    pytest.param([1], _v, True, id="scalar"),
++    pytest.param([1, 1], _v, True, id="tensor scalar"),
++    pytest.param([[1]], _vo, True, id="nested scalar"),
++    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
++    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
++    pytest.param([2], _v, False, id="vector"),
++    pytest.param([2, 3], _v, False, id="tensor vector"),
++    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
++    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
++    pytest.param([[2]], _vo, False, id="vectorised operator"),
++    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
++    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
++])
++@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
++def test_rank_type_detection(rank, actual_type, scalar, test_type):
++    """
++    Test the rank detection tests `is_scalar`, `is_vector` and
++    `is_vectorized_oper` for a range of different test cases.  These tests are
++    designed to be called on individual elements of the two-element `dims`
++    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
++
++    It's possible to be both a scalar and something else, but "vector" and
++    "vectorized_oper" are mutually exclusive.
++
++    These functions aren't properly specified for improper dimension setups, so
++    there are no tests for those.
++    """
++    expected = scalar if test_type == "scalar" else (actual_type == test_type)
++    function = getattr(qutip.dimensions, "is_" + test_type)
++    assert function(rank) == expected
++
++
++@pytest.mark.parametrize(["base", "flat"], [
++    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
++    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
++                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
++    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
++    pytest.param([], [], id="empty list"),
++    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
++])
++class TestFlattenUnflatten:
++    def test_flatten(self, base, flat):
++        assert flatten(base) == flat
++
++    def test_unflatten(self, base, flat):
++        labels = enumerate_flat(base)
++        assert unflatten(flat, labels) == base
++
++
++@pytest.mark.parametrize(["base", "expected"], [
++    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
++    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
++    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
++    pytest.param([], [], id="empty"),
++    pytest.param([[], [], [[[], [], []]]],
++                 [[], [], [[[], [], []]]], id="nested empty lists"),
++])
++def test_enumerate_flat(base, expected):
++    assert enumerate_flat(base) == expected
++
++
++@pytest.mark.parametrize(["base", "to_remove", "expected"], [
++    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
++    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
++                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
++    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
++    pytest.param([], (), [], id="empty"),
++])
++def test_deep_remove(base, to_remove, expected):
++    assert deep_remove(base, *to_remove) == expected
++
++
++@pytest.mark.parametrize("mapping", [
++    pytest.param(lambda x: x*2, id="(x -> 2x)"),
++    pytest.param(lambda x: [x], id="(x -> [x])"),
++])
++@pytest.mark.parametrize("base", [
++    pytest.param([[[0], 1], 2], id="standard"),
++    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
++    pytest.param([1, 2, 3], id="flat"),
++    pytest.param([], id="empty list"),
++    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
++])
++def test_deep_map(base, mapping):
++    """
++    Test the deep mapping.  To simplify generation of edge-cases, this tests
++    against an equivalent (but slower) operation of flattening and unflattening
++    the list.  We can get false negatives if the `flatten` or `unflatten`
++    functions are broken, but other tests should catch those.
++    """
++    # This function might not need to be public, and consequently might not
++    # need to be tested here.
++    labels = enumerate_flat(base)
++    expected = unflatten([mapping(x) for x in flatten(base)], labels)
++    assert deep_map(mapping, base) == expected
++
++
++_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
++
++
++@pytest.mark.parametrize("indices", [
++    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
++    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
++                 id="tensor-ket preserved"),
++    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
++    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
++                 id="tensor-bra preserved"),
++    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
++    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
++                 id="tensor-oper preserved"),
++    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
++                          [2, 3, 0, 1, 6, 7, 4, 5],
++                          (6, 8, 2, 4, 5, 7, 1, 3)),
++                 id="super-oper"),
++    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
++                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
++                 id="operator-ket"),
++    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
++                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
++                 id="operator-bra"),
++])
++class TestSuperOperatorDimsModification:
++    def test_dims_to_tensor_perm(self, indices):
++        # This function might not need to be public, and consequently might not
++        # need to be tested here.
++        assert dims_to_tensor_perm(indices.base) == indices.permutation
++
++    def test_dims_idxs_to_tensor_idxs(self, indices):
++        test_indices = list(range(len(flatten(indices.base))))
++        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
++                == indices.permutation)
++
++    def test_dims_to_tensor_shape(self, indices):
++        assert dims_to_tensor_shape(indices.base) == indices.shape
++
++
++class TestTypeFromDims:
++    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
++        pytest.param([[2], [2]], 'oper', True),
++        pytest.param([[2, 3], [2, 3]], 'oper', True),
++        pytest.param([[2], [3]], 'other', True),
++        pytest.param([[2], [3]], 'oper', False),
++        pytest.param([[2], [1]], 'ket', True),
++        pytest.param([[1], [2]], 'bra', True),
++        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
++        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
++        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
++        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
++        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
++    ])
++    def test_type_from_dims(self, base, expected, enforce_square):
++        assert type_from_dims(base, enforce_square=enforce_square) == expected
++
++    @pytest.mark.parametrize("qobj", [
++        pytest.param(qutip.rand_ket(10), id='ket'),
++        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
++        pytest.param(qutip.rand_dm(10), id='oper'),
++        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
++    ])
++    def test_qobj_dims_match_qobj(self, qobj):
++        assert type_from_dims(qobj.dims) == qobj.type
++
++
++class TestCollapseDims:
++    @pytest.mark.parametrize(["base", "expected"], [
++        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
++        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
++        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
++        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
++        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
++        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
++    ])
++    def test_oper(self, base, expected):
++        assert collapse_dims_oper(base) == expected
++
++    @pytest.mark.parametrize(["base", "expected"], [
++        pytest.param([[[1]], [[2, 3], [2, 3]]],
++                     [[[1]], [[6], [6]]], id="operator-ket"),
++        pytest.param([[[2, 3], [2, 3]], [[1]]],
++                     [[[6], [6]], [[1]]], id="operator-bra"),
++        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
++                     [[[6], [6]], [[6], [6]]], id="super"),
++    ])
++    def test_super(self, base, expected):
++        assert collapse_dims_super(base) == expected
+diff --git a/qutip/tests/core/test_eigen.py b/qutip/tests/core/test_eigen.py
+index ecf6f609..05e06db0 100644
+--- a/qutip/tests/core/test_eigen.py
++++ b/qutip/tests/core/test_eigen.py
+@@ -1,118 +1,118 @@
+-import scipy
+-import numpy as np
+-import pytest
+-import qutip
+-
+-
+-def is_eigen_set(oper, vals, vecs):
+-    for val, vec in zip(vals, vecs):
+-        assert abs(vec.norm() - 1) < 1e-13
+-        assert abs(qutip.expect(oper, vec) - val) < 1e-13
+-
+-
+-@pytest.mark.parametrize(["sparse", 'dtype'], [
+-    pytest.param(True, 'csr', id="sparse"),
+-    pytest.param(False, 'csr', id="sparse2dense"),
+-    pytest.param(False, 'dense', id="dense"),
+-])
+-def test_eigen_known_oper(sparse, dtype):
+-    N = qutip.num(10, dtype=dtype)
+-    spvals, spvecs = N.eigenstates(sparse=sparse)
+-    expected = np.arange(10)
+-    is_eigen_set(N, spvals, spvecs)
+-    np.testing.assert_allclose(spvals, expected, atol=1e-13)
+-
+-
+-@pytest.mark.parametrize(["sparse", 'dtype'], [
+-    pytest.param(True, 'csr', id="sparse"),
+-    pytest.param(False, 'csr', id="sparse2dense"),
+-    pytest.param(False, 'dense', id="dense"),
+-])
+-@pytest.mark.parametrize(["rand"], [
+-    pytest.param(qutip.rand_herm, id="hermitian"),
+-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+-])
+-@pytest.mark.parametrize("order", ['low', 'high'])
+-def test_eigen_rand_oper(rand, sparse, dtype, order):
+-    H = rand(10, dtype=dtype)
+-    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
+-    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
+-    if order == 'low':
+-        assert np.all(np.diff(spvals).real >= 0)
+-    else:
+-        assert np.all(np.diff(spvals).real <= 0)
+-    is_eigen_set(H, spvals, spvecs)
+-    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
+-
+-
+-@pytest.mark.parametrize(["sparse", 'dtype'], [
+-    pytest.param(True, 'csr', id="sparse"),
+-    pytest.param(False, 'csr', id="sparse2dense"),
+-    pytest.param(False, 'dense', id="dense"),
+-])
+-@pytest.mark.parametrize("rand", [
+-    pytest.param(qutip.rand_herm, id="hermitian"),
+-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+-])
+-@pytest.mark.parametrize("order", ['low', 'high'])
+-@pytest.mark.parametrize("N", [1, 5, 8, 9])
+-def test_FewState(rand, sparse, dtype, order, N):
+-    H = rand(10, dtype=dtype)
+-    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
+-    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
+-    assert np.allclose(all_spvals[:N], spvals)
+-    is_eigen_set(H, spvals, spvecs)
+-    if order == 'low':
+-        assert np.all(np.diff(spvals).real >= 0)
+-    else:
+-        assert np.all(np.diff(spvals).real <= 0)
+-
+-
+-@pytest.mark.parametrize(["sparse", 'dtype'], [
+-    pytest.param(True, 'csr', id="sparse"),
+-    pytest.param(False, 'csr', id="sparse2dense"),
+-    pytest.param(False, 'dense', id="dense"),
+-])
+-@pytest.mark.parametrize(["rand"], [
+-    pytest.param(qutip.rand_herm, id="hermitian"),
+-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+-])
+-@pytest.mark.parametrize("order", ['low', 'high'])
+-@pytest.mark.parametrize("N", [1, 5, 8, 9])
+-def test_ValsOnly(rand, sparse, dtype, order, N):
+-    H = rand(10, dtype=dtype)
+-    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
+-    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
+-    assert np.allclose(all_spvals[:N], spvals)
+-    if order == 'low':
+-        assert np.all(np.diff(spvals).real >= 0)
+-    else:
+-        assert np.all(np.diff(spvals).real <= 0)
+-
+-
+-@pytest.mark.parametrize(["sparse", 'dtype'], [
+-    pytest.param(True, 'csr', id="sparse"),
+-    pytest.param(False, 'csr', id="sparse2dense"),
+-    pytest.param(False, 'dense', id="dense"),
+-])
+-def test_eigen_small(sparse, dtype):
+-    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
+-    all_spvals = H.eigenenergies(sparse=sparse)
+-    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
+-    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
+-    is_eigen_set(H, spvals, spvecs)
+-
+-
+-def test_BigDenseValsOnly():
+-    """
+-    This checks eigenvalue calculation for large dense matrices, which
+-    historically have had instabilities with certain OS and BLAS combinations
+-    (see e.g. #1288 and #1495).
+-    """
+-    dimension = 2000
+-    # Allow an average absolute tolerance for each eigenvalue; we expect
+-    # uncertainty in the sum to add in quadrature.
+-    tol = 1e-12 * np.sqrt(dimension)
+-    H = qutip.rand_herm(dimension, density=1e-2)
+-    spvals = H.eigenenergies()
+-    assert abs(H.tr() - spvals.sum()) < tol
++import scipy
++import numpy as np
++import pytest
++import qutip
++
++
++def is_eigen_set(oper, vals, vecs):
++    for val, vec in zip(vals, vecs):
++        assert abs(vec.norm() - 1) < 1e-13
++        assert abs(qutip.expect(oper, vec) - val) < 1e-13
++
++
++@pytest.mark.parametrize(["sparse", 'dtype'], [
++    pytest.param(True, 'csr', id="sparse"),
++    pytest.param(False, 'csr', id="sparse2dense"),
++    pytest.param(False, 'dense', id="dense"),
++])
++def test_eigen_known_oper(sparse, dtype):
++    N = qutip.num(10, dtype=dtype)
++    spvals, spvecs = N.eigenstates(sparse=sparse)
++    expected = np.arange(10)
++    is_eigen_set(N, spvals, spvecs)
++    np.testing.assert_allclose(spvals, expected, atol=1e-13)
++
++
++@pytest.mark.parametrize(["sparse", 'dtype'], [
++    pytest.param(True, 'csr', id="sparse"),
++    pytest.param(False, 'csr', id="sparse2dense"),
++    pytest.param(False, 'dense', id="dense"),
++])
++@pytest.mark.parametrize(["rand"], [
++    pytest.param(qutip.rand_herm, id="hermitian"),
++    pytest.param(qutip.rand_unitary, id="non-hermitian"),
++])
++@pytest.mark.parametrize("order", ['low', 'high'])
++def test_eigen_rand_oper(rand, sparse, dtype, order):
++    H = rand(10, dtype=dtype)
++    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
++    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
++    if order == 'low':
++        assert np.all(np.diff(spvals).real >= 0)
++    else:
++        assert np.all(np.diff(spvals).real <= 0)
++    is_eigen_set(H, spvals, spvecs)
++    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
++
++
++@pytest.mark.parametrize(["sparse", 'dtype'], [
++    pytest.param(True, 'csr', id="sparse"),
++    pytest.param(False, 'csr', id="sparse2dense"),
++    pytest.param(False, 'dense', id="dense"),
++])
++@pytest.mark.parametrize("rand", [
++    pytest.param(qutip.rand_herm, id="hermitian"),
++    pytest.param(qutip.rand_unitary, id="non-hermitian"),
++])
++@pytest.mark.parametrize("order", ['low', 'high'])
++@pytest.mark.parametrize("N", [1, 5, 8, 9])
++def test_FewState(rand, sparse, dtype, order, N):
++    H = rand(10, dtype=dtype)
++    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
++    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
++    assert np.allclose(all_spvals[:N], spvals)
++    is_eigen_set(H, spvals, spvecs)
++    if order == 'low':
++        assert np.all(np.diff(spvals).real >= 0)
++    else:
++        assert np.all(np.diff(spvals).real <= 0)
++
++
++@pytest.mark.parametrize(["sparse", 'dtype'], [
++    pytest.param(True, 'csr', id="sparse"),
++    pytest.param(False, 'csr', id="sparse2dense"),
++    pytest.param(False, 'dense', id="dense"),
++])
++@pytest.mark.parametrize(["rand"], [
++    pytest.param(qutip.rand_herm, id="hermitian"),
++    pytest.param(qutip.rand_unitary, id="non-hermitian"),
++])
++@pytest.mark.parametrize("order", ['low', 'high'])
++@pytest.mark.parametrize("N", [1, 5, 8, 9])
++def test_ValsOnly(rand, sparse, dtype, order, N):
++    H = rand(10, dtype=dtype)
++    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
++    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
++    assert np.allclose(all_spvals[:N], spvals)
++    if order == 'low':
++        assert np.all(np.diff(spvals).real >= 0)
++    else:
++        assert np.all(np.diff(spvals).real <= 0)
++
++
++@pytest.mark.parametrize(["sparse", 'dtype'], [
++    pytest.param(True, 'csr', id="sparse"),
++    pytest.param(False, 'csr', id="sparse2dense"),
++    pytest.param(False, 'dense', id="dense"),
++])
++def test_eigen_small(sparse, dtype):
++    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
++    all_spvals = H.eigenenergies(sparse=sparse)
++    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
++    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
++    is_eigen_set(H, spvals, spvecs)
++
++
++def test_BigDenseValsOnly():
++    """
++    This checks eigenvalue calculation for large dense matrices, which
++    historically have had instabilities with certain OS and BLAS combinations
++    (see e.g. #1288 and #1495).
++    """
++    dimension = 2000
++    # Allow an average absolute tolerance for each eigenvalue; we expect
++    # uncertainty in the sum to add in quadrature.
++    tol = 1e-12 * np.sqrt(dimension)
++    H = qutip.rand_herm(dimension, density=1e-2)
++    spvals = H.eigenenergies()
++    assert abs(H.tr() - spvals.sum()) < tol
+diff --git a/qutip/tests/core/test_eigenstates.py b/qutip/tests/core/test_eigenstates.py
+index e03add4b..bbd00c22 100644
+--- a/qutip/tests/core/test_eigenstates.py
++++ b/qutip/tests/core/test_eigenstates.py
+@@ -1,98 +1,98 @@
+-import pytest
+-import numpy as np
+-import qutip
+-from itertools import combinations
+-
+-
+-def _canonicalise_eigenvector(vec):
+-    """
+-    Normalise an eigenvector so that the first non-zero value is equal to one,
+-    and the array is flattened.  Just normalising based on vector magnitude
+-    isn't enough to fully fix the gauge because the vectors could still be
+-    multiplied by a unit complex number.
+-    """
+-    vec = vec.flatten()
+-    nonzero = vec != 0
+-    if not np.any(nonzero):
+-        return vec
+-    return vec / vec[np.argmax(nonzero)]
+-
+-
+-# Random diagonal Hamiltonian.
+-_diagonal_dimension = 10
+-_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
+-_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
+-                                  for n in range(_diagonal_dimension)])
+-_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
+-
+-# Arbitrary known non-diagonal complex Hamiltonian.
+-_nondiagonal_hamiltonian = qutip.Qobj(np.array([
+-    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
+-    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
+-    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
+-_nondiagonal_eigenvalues = np.array([
+-    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
+-_nondiagonal_eigenstates = np.array([
+-    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
+-     0.009793118179759598+0.3029065489313791j],
+-    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
+-     -0.3741560255426259+0.6067259021655438j],
+-    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
+-     -0.5593181579625106+0.2953063897306936j]])
+-
+-
+-@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
+-    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
+-    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
+-                 _diagonal_eigenstates,
+-                 id="diagonal-"+str(_diagonal_dimension)),
+-    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
+-    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
+-                 _nondiagonal_eigenstates, id="non-diagonal"),
+-])
+-def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
+-    test_values, test_states = hamiltonian.eigenstates()
+-    eigenvalues = np.array(eigenvalues)
+-    eigenstates = np.array(eigenstates)
+-    test_order = np.argsort(test_values)
+-    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
+-                    for i in test_order]
+-    expected_order = np.argsort(eigenvalues)
+-    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
+-                        for i in expected_order]
+-    np.testing.assert_allclose(test_values[test_order],
+-                               eigenvalues[expected_order],
+-                               atol=1e-10)
+-    for test, expected in zip(test_vectors, expected_vectors):
+-        np.testing.assert_allclose(test, expected, atol=1e-10)
+-
+-
+-# Specify parametrisation over a random Hamiltonian by specifying the
+-# dimensions, rather than duplicating that logic.
+-@pytest.fixture(params=[
+-    pytest.param([10], id="simple"),
+-    pytest.param([5, 3, 4], id="tensor"),
+-    pytest.param([3, 3, 3], id="degenerate")])
+-def random_hamiltonian(request):
+-    dimensions = request.param
+-    eigen = None
+-    dist = "fill"
+-    if dimensions == [3, 3, 3]:
+-        eigen = [0, 1, 1] * 9
+-        dist = "eigen"
+-    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
+-
+-
+-@pytest.mark.parametrize('sparse', [True, False])
+-@pytest.mark.parametrize('dtype', ['csr', 'dense'])
+-def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
+-    random_hamiltonian = random_hamiltonian.to(dtype)
+-    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
+-    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
+-        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
+-                                   (eigenvalue * eigenstate).full(),
+-                                   atol=1e-10)
+-        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
+-    errors = [evec1.overlap(evec2)
+-              for evec1, evec2 in combinations(eigenstates, 2)]
+-    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
++import pytest
++import numpy as np
++import qutip
++from itertools import combinations
++
++
++def _canonicalise_eigenvector(vec):
++    """
++    Normalise an eigenvector so that the first non-zero value is equal to one,
++    and the array is flattened.  Just normalising based on vector magnitude
++    isn't enough to fully fix the gauge because the vectors could still be
++    multiplied by a unit complex number.
++    """
++    vec = vec.flatten()
++    nonzero = vec != 0
++    if not np.any(nonzero):
++        return vec
++    return vec / vec[np.argmax(nonzero)]
++
++
++# Random diagonal Hamiltonian.
++_diagonal_dimension = 10
++_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
++_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
++                                  for n in range(_diagonal_dimension)])
++_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
++
++# Arbitrary known non-diagonal complex Hamiltonian.
++_nondiagonal_hamiltonian = qutip.Qobj(np.array([
++    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
++    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
++    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
++_nondiagonal_eigenvalues = np.array([
++    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
++_nondiagonal_eigenstates = np.array([
++    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
++     0.009793118179759598+0.3029065489313791j],
++    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
++     -0.3741560255426259+0.6067259021655438j],
++    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
++     -0.5593181579625106+0.2953063897306936j]])
++
++
++@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
++    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
++    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
++                 _diagonal_eigenstates,
++                 id="diagonal-"+str(_diagonal_dimension)),
++    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
++    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
++                 _nondiagonal_eigenstates, id="non-diagonal"),
++])
++def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
++    test_values, test_states = hamiltonian.eigenstates()
++    eigenvalues = np.array(eigenvalues)
++    eigenstates = np.array(eigenstates)
++    test_order = np.argsort(test_values)
++    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
++                    for i in test_order]
++    expected_order = np.argsort(eigenvalues)
++    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
++                        for i in expected_order]
++    np.testing.assert_allclose(test_values[test_order],
++                               eigenvalues[expected_order],
++                               atol=1e-10)
++    for test, expected in zip(test_vectors, expected_vectors):
++        np.testing.assert_allclose(test, expected, atol=1e-10)
++
++
++# Specify parametrisation over a random Hamiltonian by specifying the
++# dimensions, rather than duplicating that logic.
++@pytest.fixture(params=[
++    pytest.param([10], id="simple"),
++    pytest.param([5, 3, 4], id="tensor"),
++    pytest.param([3, 3, 3], id="degenerate")])
++def random_hamiltonian(request):
++    dimensions = request.param
++    eigen = None
++    dist = "fill"
++    if dimensions == [3, 3, 3]:
++        eigen = [0, 1, 1] * 9
++        dist = "eigen"
++    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
++
++
++@pytest.mark.parametrize('sparse', [True, False])
++@pytest.mark.parametrize('dtype', ['csr', 'dense'])
++def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
++    random_hamiltonian = random_hamiltonian.to(dtype)
++    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
++    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
++        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
++                                   (eigenvalue * eigenstate).full(),
++                                   atol=1e-10)
++        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
++    errors = [evec1.overlap(evec2)
++              for evec1, evec2 in combinations(eigenstates, 2)]
++    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
+diff --git a/qutip/tests/core/test_expect.py b/qutip/tests/core/test_expect.py
+index 906880ce..96e7ff0f 100644
+--- a/qutip/tests/core/test_expect.py
++++ b/qutip/tests/core/test_expect.py
+@@ -1,179 +1,179 @@
+-import pytest
+-import collections
+-import functools
+-import numpy as np
+-import qutip
+-from qutip.core.data import CSR, Dense
+-import qutip.core.data as _data
+-
+-# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
+-# of different systems, without having to repeatedly specify the systems over
+-# and over again.  We first store a small number of test cases for known
+-# expectation value in the most bundled-up form, because it's easier to unroll
+-# these by applying the expected broadcasting rules explicitly ourselves than
+-# performing the inverse operation.
+-#
+-# We store a single test case in a record type, just to keep things neatly
+-# together while we're munging them, so it's clear at all times what
+-# constitutes a valid test case.
+-
+-_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
+-
+-
+-def _case_to_dm(case):
+-    return case._replace(state=[x.proj() for x in case.state])
+-
+-
+-def _unwrap(list_):
+-    """Unwrap lists until we reach the first non-list element."""
+-    out = list_
+-    while isinstance(out, list):
+-        out = out[0]
+-    return out
+-
+-
+-def _case_id(case):
+-    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
+-    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
+-    return op_part + "-" + state_part
+-
+-
+-# This is the minimal set of test cases, with a Fock system and a qubit system
+-# both in ket form and dm form.  The reference expectations are a 2D array
+-# which would be found by broadcasting `operator` against `state` and applying
+-# `qutip.expect` to the pairs.
+-_dim = 5
+-_num, _a = qutip.num(_dim), qutip.destroy(_dim)
+-_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
+-_known_fock = _Case([_num, _a],
+-                    [qutip.fock(_dim, n) for n in range(_dim)],
+-                    np.array([np.arange(_dim), np.zeros(_dim)]))
+-_known_qubit = _Case([_sx, _sz, _sp],
+-                     [qutip.basis(2, 0), qutip.basis(2, 1)],
+-                     np.array([[0, 0], [1, -1], [0, 0]]))
+-_known_cases = [_known_fock, _case_to_dm(_known_fock),
+-                _known_qubit, _case_to_dm(_known_qubit)]
+-
+-
+-class TestKnownExpectation:
+-    def pytest_generate_tests(self, metafunc):
+-        """
+-        Perform the parametrisation over the test cases, performing the
+-        explicit broadcasting into separate test cases when required.
+-
+-        We detect whether to perform explicit broadcasting over one of the
+-        arguments of the `_Case` by looking for a singular/plural name of the
+-        parameter in the test.  If the parameter is singular, then we manually
+-        perform the broadcasting rule for that fixture, and parametrise over
+-        the resulting list, taking care to pick out the correct parts of the
+-        reference array.
+-        """
+-        cases = _known_cases
+-        op_name, state_name = 'operator', 'state'
+-        if op_name not in metafunc.fixturenames:
+-            op_name += 's'
+-        else:
+-            cases = [_Case(op, case.state, expected)
+-                     for case in cases
+-                     for op, expected in zip(case.operator, case.expected)]
+-        if state_name not in metafunc.fixturenames:
+-            state_name += 's'
+-        else:
+-            cases = [_Case(case.operator, state, expected)
+-                     for case in cases
+-                     for state, expected in zip(case.state, case.expected.T)]
+-        metafunc.parametrize([op_name, state_name, 'expected'], cases,
+-                             ids=[_case_id(case) for case in cases])
+-
+-    def test_operator_by_basis(self, operator, state, expected):
+-        result = qutip.expect(operator, state)
+-        assert result == expected
+-        assert isinstance(result, float if operator.isherm else complex)
+-
+-    def test_broadcast_operator_list(self, operators, state, expected):
+-        result = qutip.expect(operators, state)
+-        expected_dtype = (np.float64 if all(op.isherm for op in operators)
+-                          else np.complex128)
+-        assert isinstance(result, np.ndarray)
+-        assert result.dtype == expected_dtype
+-        assert list(result) == list(expected)
+-
+-    def test_broadcast_state_list(self, operator, states, expected):
+-        result = qutip.expect(operator, states)
+-        expected_dtype = np.float64 if operator.isherm else np.complex128
+-        assert isinstance(result, np.ndarray)
+-        assert result.dtype == expected_dtype
+-        assert list(result) == list(expected)
+-
+-    def test_broadcast_both_lists(self, operators, states, expected):
+-        result = qutip.expect(operators, states)
+-        assert len(result) == len(operators)
+-        for part, operator, expected_part in zip(result, operators, expected):
+-            expected_dtype = np.float64 if operator.isherm else np.complex128
+-            assert isinstance(part, np.ndarray)
+-            assert part.dtype == expected_dtype
+-            assert list(part) == list(expected_part)
+-
+-
+-@pytest.mark.repeat(5)
+-@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
+-@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
+-@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
+-def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
+-    dimension = 20
+-    state = qutip.rand_ket(dimension, 0.3).to(op_type)
+-    op = qutip.rand_herm(dimension, 0.2).to(state_type)
+-    if not hermitian:
+-        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
+-    expected = state.dag() * op * state
+-    assert abs(qutip.expect(op, state) - expected) < 1e-14
+-
+-
+-@pytest.mark.parametrize("solve", [
+-    pytest.param(qutip.sesolve, id="sesolve"),
+-    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
+-                 id="mesolve"),
+-])
+-def test_compatibility_with_solver(solve):
+-    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
+-    e_ops += [lambda t, psi: np.sin(t)]
+-    h = qutip.sigmax()
+-    state = qutip.basis(2, 0)
+-    times = np.linspace(0, 10, 101)
+-    options = {"store_states":True}
+-    result = solve(h, state, times, e_ops=e_ops, options=options)
+-    direct, states = result.expect, result.states
+-    indirect = qutip.expect(e_ops[:-1], states)
+-    # check measurement operators based on quantum objects
+-    assert len(direct)-1 == len(indirect)
+-    for direct_, indirect_ in zip(direct, indirect):
+-        assert len(direct_) == len(indirect_)
+-        assert isinstance(direct_, np.ndarray)
+-        assert isinstance(indirect_, np.ndarray)
+-        assert direct_.dtype == indirect_.dtype
+-        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
+-        # test measurement operators based on lambda functions
+-        direct_ = direct[-1]
+-        indirect_ = np.sin(times)
+-        assert len(direct_) == len(indirect_)
+-        assert isinstance(direct_, np.ndarray)
+-        assert isinstance(indirect_, np.ndarray)
+-        assert direct_.dtype == indirect_.dtype
+-        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
+-
+-
+-def test_no_real_attribute(monkeypatch):
+-    """This tests ensures that expect still works even if the output of a
+-    specialisation does not have the ``real`` attribute. This is the case for
+-    the tensorflow and cupy data layers."""
+-
+-    def mocker_expect_return(oper, state):
+-        """
+-        We simply return None which does not have the `real` attribute.
+-        """
+-        return "object without .real"
+-
+-    monkeypatch.setattr(_data, "expect", mocker_expect_return)
+-
+-    sz = qutip.sigmaz() # the choice of the matrix does not matter
+-    assert "object without .real" == qutip.expect(sz, sz)
++import pytest
++import collections
++import functools
++import numpy as np
++import qutip
++from qutip.core.data import CSR, Dense
++import qutip.core.data as _data
++
++# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
++# of different systems, without having to repeatedly specify the systems over
++# and over again.  We first store a small number of test cases for known
++# expectation value in the most bundled-up form, because it's easier to unroll
++# these by applying the expected broadcasting rules explicitly ourselves than
++# performing the inverse operation.
++#
++# We store a single test case in a record type, just to keep things neatly
++# together while we're munging them, so it's clear at all times what
++# constitutes a valid test case.
++
++_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
++
++
++def _case_to_dm(case):
++    return case._replace(state=[x.proj() for x in case.state])
++
++
++def _unwrap(list_):
++    """Unwrap lists until we reach the first non-list element."""
++    out = list_
++    while isinstance(out, list):
++        out = out[0]
++    return out
++
++
++def _case_id(case):
++    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
++    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
++    return op_part + "-" + state_part
++
++
++# This is the minimal set of test cases, with a Fock system and a qubit system
++# both in ket form and dm form.  The reference expectations are a 2D array
++# which would be found by broadcasting `operator` against `state` and applying
++# `qutip.expect` to the pairs.
++_dim = 5
++_num, _a = qutip.num(_dim), qutip.destroy(_dim)
++_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
++_known_fock = _Case([_num, _a],
++                    [qutip.fock(_dim, n) for n in range(_dim)],
++                    np.array([np.arange(_dim), np.zeros(_dim)]))
++_known_qubit = _Case([_sx, _sz, _sp],
++                     [qutip.basis(2, 0), qutip.basis(2, 1)],
++                     np.array([[0, 0], [1, -1], [0, 0]]))
++_known_cases = [_known_fock, _case_to_dm(_known_fock),
++                _known_qubit, _case_to_dm(_known_qubit)]
++
++
++class TestKnownExpectation:
++    def pytest_generate_tests(self, metafunc):
++        """
++        Perform the parametrisation over the test cases, performing the
++        explicit broadcasting into separate test cases when required.
++
++        We detect whether to perform explicit broadcasting over one of the
++        arguments of the `_Case` by looking for a singular/plural name of the
++        parameter in the test.  If the parameter is singular, then we manually
++        perform the broadcasting rule for that fixture, and parametrise over
++        the resulting list, taking care to pick out the correct parts of the
++        reference array.
++        """
++        cases = _known_cases
++        op_name, state_name = 'operator', 'state'
++        if op_name not in metafunc.fixturenames:
++            op_name += 's'
++        else:
++            cases = [_Case(op, case.state, expected)
++                     for case in cases
++                     for op, expected in zip(case.operator, case.expected)]
++        if state_name not in metafunc.fixturenames:
++            state_name += 's'
++        else:
++            cases = [_Case(case.operator, state, expected)
++                     for case in cases
++                     for state, expected in zip(case.state, case.expected.T)]
++        metafunc.parametrize([op_name, state_name, 'expected'], cases,
++                             ids=[_case_id(case) for case in cases])
++
++    def test_operator_by_basis(self, operator, state, expected):
++        result = qutip.expect(operator, state)
++        assert result == expected
++        assert isinstance(result, float if operator.isherm else complex)
++
++    def test_broadcast_operator_list(self, operators, state, expected):
++        result = qutip.expect(operators, state)
++        expected_dtype = (np.float64 if all(op.isherm for op in operators)
++                          else np.complex128)
++        assert isinstance(result, np.ndarray)
++        assert result.dtype == expected_dtype
++        assert list(result) == list(expected)
++
++    def test_broadcast_state_list(self, operator, states, expected):
++        result = qutip.expect(operator, states)
++        expected_dtype = np.float64 if operator.isherm else np.complex128
++        assert isinstance(result, np.ndarray)
++        assert result.dtype == expected_dtype
++        assert list(result) == list(expected)
++
++    def test_broadcast_both_lists(self, operators, states, expected):
++        result = qutip.expect(operators, states)
++        assert len(result) == len(operators)
++        for part, operator, expected_part in zip(result, operators, expected):
++            expected_dtype = np.float64 if operator.isherm else np.complex128
++            assert isinstance(part, np.ndarray)
++            assert part.dtype == expected_dtype
++            assert list(part) == list(expected_part)
++
++
++@pytest.mark.repeat(5)
++@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
++@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
++@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
++def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
++    dimension = 20
++    state = qutip.rand_ket(dimension, 0.3).to(op_type)
++    op = qutip.rand_herm(dimension, 0.2).to(state_type)
++    if not hermitian:
++        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
++    expected = state.dag() * op * state
++    assert abs(qutip.expect(op, state) - expected) < 1e-14
++
++
++@pytest.mark.parametrize("solve", [
++    pytest.param(qutip.sesolve, id="sesolve"),
++    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
++                 id="mesolve"),
++])
++def test_compatibility_with_solver(solve):
++    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
++    e_ops += [lambda t, psi: np.sin(t)]
++    h = qutip.sigmax()
++    state = qutip.basis(2, 0)
++    times = np.linspace(0, 10, 101)
++    options = {"store_states":True}
++    result = solve(h, state, times, e_ops=e_ops, options=options)
++    direct, states = result.expect, result.states
++    indirect = qutip.expect(e_ops[:-1], states)
++    # check measurement operators based on quantum objects
++    assert len(direct)-1 == len(indirect)
++    for direct_, indirect_ in zip(direct, indirect):
++        assert len(direct_) == len(indirect_)
++        assert isinstance(direct_, np.ndarray)
++        assert isinstance(indirect_, np.ndarray)
++        assert direct_.dtype == indirect_.dtype
++        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
++        # test measurement operators based on lambda functions
++        direct_ = direct[-1]
++        indirect_ = np.sin(times)
++        assert len(direct_) == len(indirect_)
++        assert isinstance(direct_, np.ndarray)
++        assert isinstance(indirect_, np.ndarray)
++        assert direct_.dtype == indirect_.dtype
++        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
++
++
++def test_no_real_attribute(monkeypatch):
++    """This tests ensures that expect still works even if the output of a
++    specialisation does not have the ``real`` attribute. This is the case for
++    the tensorflow and cupy data layers."""
++
++    def mocker_expect_return(oper, state):
++        """
++        We simply return None which does not have the `real` attribute.
++        """
++        return "object without .real"
++
++    monkeypatch.setattr(_data, "expect", mocker_expect_return)
++
++    sz = qutip.sigmaz() # the choice of the matrix does not matter
++    assert "object without .real" == qutip.expect(sz, sz)
+diff --git a/qutip/tests/core/test_gates.py b/qutip/tests/core/test_gates.py
+index 7b3795b5..92f81c7f 100644
+--- a/qutip/tests/core/test_gates.py
++++ b/qutip/tests/core/test_gates.py
+@@ -1,144 +1,144 @@
+-import pytest
+-import numpy as np
+-import qutip
+-from qutip.core import gates
+-
+-
+-def _infidelity(a, b):
+-    """Infidelity between two kets."""
+-    return 1 - abs(a.overlap(b))
+-
+-
+-def _remove_global_phase(qobj):
+-    """
+-    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
+-    we set the first non-zero element to be purely real-positive.
+-    """
+-    flat = qobj.tidyup(1e-14).full().flat.copy()
+-    for phase in flat:
+-        if phase != 0:
+-            # Fix the gauge for any global phase.
+-            flat = flat * np.exp(-1j * np.angle(phase))
+-            break
+-    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
+-
+-
+-def _make_random_three_qubit_gate():
+-    """Create a random three-qubit gate."""
+-    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
+-
+-    def gate(N=None, controls=None, target=None):
+-        if N is None:
+-            return operation
+-        return gates.gate_expand_3toN(operation, N, controls, target)
+-    return gate
+-
+-
+-def _make_controled(op):
+-    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
+-    out += qutip.tensor(qutip.fock_dm(2, 1), op)
+-    return out
+-
+-
+-class TestExplicitForm:
+-    def test_swap(self):
+-        states = [qutip.rand_ket(2) for _ in [None]*2]
+-        start = qutip.tensor(states)
+-        swapped = qutip.tensor(states[::-1])
+-        swap = gates.swap()
+-        assert _infidelity(swapped, swap*start) < 1e-12
+-        assert _infidelity(start, swap*swap*start) < 1e-12
+-
+-    @pytest.mark.parametrize(["gate", "cgate", "args"], [
+-        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
+-        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
+-        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
+-        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
+-        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
+-        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
+-        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
+-        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
+-        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
+-    ])
+-    def test_controled(self, gate, cgate, args):
+-        expected = _make_controled(gate(*args))
+-        assert cgate(*args) == expected
+-
+-    @pytest.mark.parametrize(["gate", "power", "expected"], [
+-        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
+-        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
+-        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
+-        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
+-                     id="berkeley"),
+-        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
+-        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
+-        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
+-    ])
+-    def gate_power_relation(self, gate, expected, power):
+-        assert gate()**power == expected()
+-
+-    @pytest.mark.parametrize(['angle', 'expected'], [
+-        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
+-                     id="pi"),
+-        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
+-    ])
+-    def test_molmer_sorensen(self, angle, expected):
+-        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
+-                                   expected.full(), atol=1e-15)
+-
+-    @pytest.mark.parametrize(["gate", "n_angles"], [
+-        pytest.param(gates.rx, 1, id="Rx"),
+-        pytest.param(gates.ry, 1, id="Ry"),
+-        pytest.param(gates.rz, 1, id="Rz"),
+-        pytest.param(gates.phasegate, 1, id="phase"),
+-        pytest.param(gates.qrot, 2, id="Rabi rotation"),
+-    ])
+-    def test_zero_rotations_are_identity(self, gate, n_angles):
+-        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
+-                                   atol=1e-15)
+-
+-    def test_hadamard(self):
+-        N = 3
+-        expected = qutip.tensor([gates.snot()] * N)
+-        assert gates.hadamard_transform(N) == expected
+-
+-    def test_globalphase(self):
+-        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
+-
+-
+-class TestCliffordGroup:
+-    """
+-    Test a sufficient set of conditions to prove that we have a full Clifford
+-    group for a single qubit.
+-    """
+-    clifford = gates.qubit_clifford_group()
+-    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+-
+-    def test_single_qubit_group_dimension_is_24(self):
+-        assert len(self.clifford) == 24
+-
+-    def test_all_elements_different(self):
+-        clifford = [_remove_global_phase(gate) for gate in self.clifford]
+-        for i, gate in enumerate(clifford):
+-            for other in clifford[i+1:]:
+-                # Big tolerance because we actually want to test the inverse.
+-                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
+-
+-    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
+-    def test_gate_normalises_pauli_group(self, gate):
+-        """
+-        Test the fundamental definition of the Clifford group, i.e. that it
+-        normalises the Pauli group.
+-        """
+-        # Assert that each Clifford gate maps the set of Pauli gates back onto
+-        # itself (though not necessarily in order).  This condition is no
+-        # stronger than simply considering each (gate, Pauli) pair separately.
+-        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
+-        normalised = [_remove_global_phase(gate * pauli * gate.dag())
+-                      for pauli in self.pauli]
+-        for gate in normalised:
+-            for i, pauli in enumerate(pauli_gates):
+-                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
+-                    del pauli_gates[i]
+-                    break
+-        assert len(pauli_gates) == 0
++import pytest
++import numpy as np
++import qutip
++from qutip.core import gates
++
++
++def _infidelity(a, b):
++    """Infidelity between two kets."""
++    return 1 - abs(a.overlap(b))
++
++
++def _remove_global_phase(qobj):
++    """
++    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
++    we set the first non-zero element to be purely real-positive.
++    """
++    flat = qobj.tidyup(1e-14).full().flat.copy()
++    for phase in flat:
++        if phase != 0:
++            # Fix the gauge for any global phase.
++            flat = flat * np.exp(-1j * np.angle(phase))
++            break
++    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
++
++
++def _make_random_three_qubit_gate():
++    """Create a random three-qubit gate."""
++    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
++
++    def gate(N=None, controls=None, target=None):
++        if N is None:
++            return operation
++        return gates.gate_expand_3toN(operation, N, controls, target)
++    return gate
++
++
++def _make_controled(op):
++    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
++    out += qutip.tensor(qutip.fock_dm(2, 1), op)
++    return out
++
++
++class TestExplicitForm:
++    def test_swap(self):
++        states = [qutip.rand_ket(2) for _ in [None]*2]
++        start = qutip.tensor(states)
++        swapped = qutip.tensor(states[::-1])
++        swap = gates.swap()
++        assert _infidelity(swapped, swap*start) < 1e-12
++        assert _infidelity(start, swap*swap*start) < 1e-12
++
++    @pytest.mark.parametrize(["gate", "cgate", "args"], [
++        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
++        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
++        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
++        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
++        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
++        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
++        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
++        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
++        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
++    ])
++    def test_controled(self, gate, cgate, args):
++        expected = _make_controled(gate(*args))
++        assert cgate(*args) == expected
++
++    @pytest.mark.parametrize(["gate", "power", "expected"], [
++        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
++        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
++        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
++        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
++                     id="berkeley"),
++        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
++        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
++        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
++    ])
++    def gate_power_relation(self, gate, expected, power):
++        assert gate()**power == expected()
++
++    @pytest.mark.parametrize(['angle', 'expected'], [
++        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
++                     id="pi"),
++        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
++    ])
++    def test_molmer_sorensen(self, angle, expected):
++        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
++                                   expected.full(), atol=1e-15)
++
++    @pytest.mark.parametrize(["gate", "n_angles"], [
++        pytest.param(gates.rx, 1, id="Rx"),
++        pytest.param(gates.ry, 1, id="Ry"),
++        pytest.param(gates.rz, 1, id="Rz"),
++        pytest.param(gates.phasegate, 1, id="phase"),
++        pytest.param(gates.qrot, 2, id="Rabi rotation"),
++    ])
++    def test_zero_rotations_are_identity(self, gate, n_angles):
++        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
++                                   atol=1e-15)
++
++    def test_hadamard(self):
++        N = 3
++        expected = qutip.tensor([gates.snot()] * N)
++        assert gates.hadamard_transform(N) == expected
++
++    def test_globalphase(self):
++        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
++
++
++class TestCliffordGroup:
++    """
++    Test a sufficient set of conditions to prove that we have a full Clifford
++    group for a single qubit.
++    """
++    clifford = gates.qubit_clifford_group()
++    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
++
++    def test_single_qubit_group_dimension_is_24(self):
++        assert len(self.clifford) == 24
++
++    def test_all_elements_different(self):
++        clifford = [_remove_global_phase(gate) for gate in self.clifford]
++        for i, gate in enumerate(clifford):
++            for other in clifford[i+1:]:
++                # Big tolerance because we actually want to test the inverse.
++                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
++
++    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
++    def test_gate_normalises_pauli_group(self, gate):
++        """
++        Test the fundamental definition of the Clifford group, i.e. that it
++        normalises the Pauli group.
++        """
++        # Assert that each Clifford gate maps the set of Pauli gates back onto
++        # itself (though not necessarily in order).  This condition is no
++        # stronger than simply considering each (gate, Pauli) pair separately.
++        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
++        normalised = [_remove_global_phase(gate * pauli * gate.dag())
++                      for pauli in self.pauli]
++        for gate in normalised:
++            for i, pauli in enumerate(pauli_gates):
++                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
++                    del pauli_gates[i]
++                    break
++        assert len(pauli_gates) == 0
+diff --git a/qutip/tests/core/test_metrics.py b/qutip/tests/core/test_metrics.py
+index e52a074b..945c1cfb 100644
+--- a/qutip/tests/core/test_metrics.py
++++ b/qutip/tests/core/test_metrics.py
+@@ -1,551 +1,551 @@
+-# -*- coding: utf-8 -*-
+-
+-import platform
+-
+-import numpy as np
+-import pytest
+-
+-from qutip import (
+-    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
+-    qeye, rand_ket, rand_super_bcsz, rand_dm,
+-    rand_unitary, to_super, to_choi, kraus_to_choi,
+-    to_chi, to_kraus,
+-)
+-from qutip.core.gates import snot, swap
+-
+-try:
+-    import cvxpy
+-    import cvxopt
+-except ImportError:
+-    cvxpy, cvxopt = None, None
+-
+-# These ones are the metrics functions that we actually want to test.
+-from qutip import (
+-    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
+-    unitarity, hilbert_dist, bures_dist, process_fidelity,
+-)
+-from qutip.core.metrics import _hilbert_space_dims
+-
+-
+-@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
+-def dimension(request):
+-    # There are also some cases in the file where this fixture is explicitly
+-    # overridden by a more local mark.  That is deliberate; this dimension is
+-    # intended for non-superoperators, and may cause inordinantly long tests if
+-    # (for example) something uses dimension=100 then makes a superoperator out
+-    # of it.
+-    return request.param
+-
+-
+-@pytest.fixture(scope="function", params=[
+-    pytest.param(rand_ket, id="pure"),
+-    pytest.param(rand_dm, id="mixed"),
+-])
+-def state(request, dimension):
+-    return request.param(dimension)
+-
+-
+-# Also parametrise left, right as if they're the names of two states for tests
+-# that need to take two states.
+-left = right = state
+-
+-
+-# The class names have an unusual naming convention to make them more
+-# convenient to use with the `pytest -k "expr"` selection syntax.  They start
+-# with the standard `Test`, but then are the name of the function they are
+-# testing in the function naming convention, so it's easy to remember the
+-# selector to choose a particular function.
+-
+-class Test_fidelity:
+-    def test_mixed_state_inequality(self, dimension):
+-        tol = 1e-7
+-        rho1 = rand_dm(dimension, density=0.25)
+-        rho2 = rand_dm(dimension, density=0.25)
+-        F = fidelity(rho1, rho2)
+-        assert 1 - F <= np.sqrt(1 - F*F) + tol
+-
+-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+-    def test_orthogonal(self, left_dm, right_dm, dimension):
+-        left = basis(dimension, 0)
+-        right = basis(dimension, dimension//2)
+-        if left_dm:
+-            left = left.proj()
+-        if right_dm:
+-            right = right.proj()
+-        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
+-
+-    def test_invariant_under_unitary_transformation(self, dimension):
+-        rho1 = rand_dm(dimension, density=0.25)
+-        rho2 = rand_dm(dimension, density=0.25)
+-        U = rand_unitary(dimension)
+-        F = fidelity(rho1, rho2)
+-        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
+-        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
+-
+-    def test_state_with_itself(self, state):
+-        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
+-
+-    def test_bounded(self, left, right, dimension):
+-        """Test that fidelity is bounded on [0, 1]."""
+-        tol = 1e-7
+-        assert -tol <= fidelity(left, right) <= 1 + tol
+-
+-    def test_pure_state_equivalent_to_overlap(self, dimension):
+-        """Check fidelity against pure-state overlap, see gh-361."""
+-        psi = rand_ket(dimension)
+-        phi = rand_ket(dimension)
+-        overlap = np.abs(psi.overlap(phi))
+-        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
+-
+-    ket_0 = basis(2, 0)
+-    ket_1 = basis(2, 1)
+-    ket_p = (ket_0 + ket_1).unit()
+-    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
+-    max_mixed = qeye(2).unit()
+-
+-    @pytest.mark.parametrize(['left', 'right', 'expected'], [
+-        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
+-        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
+-        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
+-        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
+-                     id="|+>,|+'>"),
+-    ])
+-    def test_known_cases(self, left, right, expected):
+-        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
+-
+-
+-class Test_tracedist:
+-    def test_state_with_itself(self, state):
+-        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
+-
+-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+-    def test_orthogonal(self, left_dm, right_dm, dimension):
+-        left = basis(dimension, 0)
+-        right = basis(dimension, dimension//2)
+-        if left_dm:
+-            left = left.proj()
+-        if right_dm:
+-            right = right.proj()
+-        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
+-
+-    def test_invariant_under_unitary_transformation(self, dimension):
+-        rho1 = rand_dm(dimension, density=0.25)
+-        rho2 = rand_dm(dimension, density=0.25)
+-        U = rand_unitary(dimension)
+-        D = tracedist(rho1, rho2)
+-        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
+-        assert D == pytest.approx(DU, rel=1e-5)
+-
+-
+-class Test_hellinger_dist:
+-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+-    def test_orthogonal(self, left_dm, right_dm, dimension):
+-        left = basis(dimension, 0)
+-        right = basis(dimension, dimension//2)
+-        if left_dm:
+-            left = left.proj()
+-        if right_dm:
+-            right = right.proj()
+-        expected = np.sqrt(2)
+-        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
+-
+-    def test_state_with_itself(self, state):
+-        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
+-
+-    def test_known_cases_pure_states(self, dimension):
+-        left = rand_ket(dimension)
+-        right = rand_ket(dimension)
+-        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
+-        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
+-
+-    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
+-    def test_monotonicity(self, dimension):
+-        """
+-        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
+-        arXiv:1611.03449v2:
+-            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
+-            >= hellinger_dist(rhoA, sigmaA)
+-        with equality iff sigmaB = rhoB where '&' is the tensor product.
+-        """
+-        tol = 1e-5
+-        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
+-        rho = tensor(rhoA, rhoB)
+-        rho_sim = tensor(rhoA, sigmaB)
+-        sigma = tensor(sigmaA, sigmaB)
+-        dist = hellinger_dist(rhoA, sigmaA)
+-        assert hellinger_dist(rho, sigma) + tol > dist
+-        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
+-
+-
+-class Test_average_gate_fidelity:
+-    def test_identity(self, dimension):
+-        id = qeye(dimension)
+-        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
+-
+-    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
+-    def test_bounded(self, dimension):
+-        tol = 1e-7
+-        channel = rand_super_bcsz(dimension)
+-        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
+-
+-    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
+-    def test_unitaries_equal_1(self, dimension):
+-        """Tests that for random unitaries U, AGF(U, U) = 1."""
+-        tol = 1e-7
+-        U = rand_unitary(dimension)
+-        SU = to_super(U)
+-        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
+-
+-    def test_average_gate_fidelity_against_legacy_implementation(self):
+-        """
+-        Metrics: Test that AGF coincides with pre-5.0 implementation
+-        """
+-        def agf_pre_50(oper, target=None):
+-            kraus = to_kraus(oper)
+-            d = kraus[0].shape[0]
+-
+-            if kraus[0].shape[1] != d:
+-                return TypeError(
+-                    "Average gate fidelity only implemented for square "
+-                    "superoperators.")
+-
+-            if target is None:
+-                return (
+-                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
+-                    (d * d + d)
+-                )
+-            return (
+-                (d + np.sum([
+-                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
+-                ])) / (d * d + d)
+-            )
+-
+-        oper = rand_super_bcsz(16)
+-        target = rand_unitary(16)
+-        np.testing.assert_almost_equal(
+-            average_gate_fidelity(oper, target),
+-            agf_pre_50(oper, target)
+-        )
+-
+-
+-class Test_hilbert_dist:
+-    def test_known_cases(self):
+-        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
+-        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
+-        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
+-
+-
+-paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
+-
+-
+-class Test_unitarity:
+-    @pytest.mark.parametrize(['operator', 'expected'], [
+-        pytest.param(to_super(sigmax()), 1, id="sigmax"),
+-        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
+-        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
+-                     id="id+sigmax"),
+-    ])
+-    def test_known_cases(self, operator, expected):
+-        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
+-
+-    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
+-    def test_bounded(self, n_qubits):
+-        tol = 1e-7
+-        operator = rand_super_bcsz(2**n_qubits)
+-        assert -tol <= unitarity(operator) <= 1 + tol
+-
+-
+-class TestComparisons:
+-    """Test some known inequalities between two different metrics."""
+-
+-    def test_inequality_tracedist_to_fidelity(self, left, right):
+-        tol = 1e-7
+-        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
+-
+-    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
+-        tol = 1e-7
+-        hellinger = hellinger_dist(left, right)
+-        bures = bures_dist(left, right)
+-        assert bures <= hellinger + tol
+-
+-
+-def overrotation(x):
+-    return to_super((1j * np.pi * x * sigmax() / 2).expm())
+-
+-
+-def had_mixture(x):
+-    id_chan = to_choi(qeye(2))
+-    S_eye = to_super(id_chan)
+-    S_H = to_super(snot())
+-    return (1 - x) * S_eye + x * S_H
+-
+-
+-def swap_map(x):
+-    base = (1j * x * swap()).expm()
+-    dims = [[[2], [2]], [[2], [2]]]
+-    return Qobj(base, dims=dims, type='super', superrep='super')
+-
+-
+-def adc_choi(x):
+-    kraus = [
+-        np.sqrt(1 - x) * qeye(2),
+-        np.sqrt(x) * destroy(2),
+-        np.sqrt(x) * fock_dm(2, 0),
+-    ]
+-    return kraus_to_choi(kraus)
+-
+-
+-# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
+-# to solve the problem, and this can cause an entire test-suite failure.  As
+-# long as we are using random tests (perhaps not ideal), this will happen
+-# occasionally.  This isn't entirely a bug, it's just a reality of using a
+-# one-size-fits-all solver; we've historically assumed users who come up
+-# against this sort of thing will be accepting of the fact that dnorm
+-# calculation is nontrivial, and isn't always entirely feasible.
+-#
+-# To deal with it, we allow each test to be rerun twice, using
+-# pytest-rerunfailures.  This should forbid pathological cases where the test
+-# is failing every time, but not penalise one-off failures.  As far as we know,
+-# the failing tests always involve a random step, so triggering a re-run will
+-# have them choose new variables as well.
+-#
+-# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
+-# which is deprecated as of numpy 1.20.
+-#
+-# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
+-# depends on them.
+-@pytest.mark.skipif(cvxpy is None or cvxopt is None,
+-                    reason="Skipping dnorm tests because dnorm requires cvxpy"
+-                    " and cvxopt which are not installed.")
+-@pytest.mark.skipif("Windows" in platform.system(),
+-                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
+-                    " installed on Windows but fail to correctly solve"
+-                    " the given optimization problems.")
+-@pytest.mark.flaky(reruns=2)
+-@pytest.mark.filterwarnings(
+-    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
+-)
+-class Test_dnorm:
+-    @pytest.fixture(params=[2, 3])
+-    def dimension(self, request):
+-        return request.param
+-
+-    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
+-    def sparse(self, request):
+-        return request.param
+-
+-    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
+-    def test_sparse_against_dense_adc(self, variable):
+-        """
+-        Test sparse versus dense dnorm calculation for a sample of
+-        amplitude-damping channels.
+-        """
+-        # Choi matrix for identity channel on 1 qubit
+-        A = kraus_to_choi([qeye(2)])
+-        B = adc_choi(variable)
+-        dense = dnorm(A, B, force_solve=True, sparse=False)
+-        sparse = dnorm(A, B, force_solve=True, sparse=True)
+-        assert dense == pytest.approx(sparse, abs=1e-7)
+-
+-    @pytest.mark.repeat(3)
+-    def test_sparse_against_dense_random(self, dimension):
+-        """
+-        Test sparse versus dense dnorm calculation for random superoperators.
+-        """
+-        A = rand_super_bcsz(dimension)
+-        dense_run_result = dnorm(A, force_solve=True, sparse=False)
+-        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
+-        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
+-
+-    def test_bounded(self, dimension, sparse):
+-        """dnorm(A - B) in [0, 2] for random superops A, B."""
+-        tol = 1e-7
+-        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
+-        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
+-
+-    def test_qubit_simple_known_cases(self, sparse):
+-        """Check agreement for known qubit channels."""
+-        id_chan = to_choi(qeye(2))
+-        X_chan = to_choi(sigmax())
+-        depol = to_choi(Qobj(
+-            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
+-        ))
+-        # We need to restrict the number of iterations for things on the
+-        # boundary, such as perfectly distinguishable channels.
+-        assert (
+-            dnorm(id_chan, X_chan, sparse=sparse)
+-            == pytest.approx(2, abs=1e-7)
+-        )
+-        assert (
+-            dnorm(id_chan, depol, sparse=sparse)
+-            == pytest.approx(1.5, abs=1e-7)
+-        )
+-        # Finally, we add a known case from Johnston's QETLAB documentation,
+-        #   || Phi - I ||_♢,
+-        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
+-        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
+-        assert (
+-            dnorm(U, qeye(2), sparse=sparse)
+-            == pytest.approx(np.sqrt(2), abs=1e-7)
+-        )
+-
+-    @pytest.mark.parametrize(["variable", "expected", "generator"], [
+-        [1.0e-3, 3.141591e-03, overrotation],
+-        [3.1e-3, 9.738899e-03, overrotation],
+-        [1.0e-2, 3.141463e-02, overrotation],
+-        [3.1e-2, 9.735089e-02, overrotation],
+-        [1.0e-1, 3.128689e-01, overrotation],
+-        [3.1e-1, 9.358596e-01, overrotation],
+-        [1.0e-3, 2.000000e-03, had_mixture],
+-        [3.1e-3, 6.200000e-03, had_mixture],
+-        [1.0e-2, 2.000000e-02, had_mixture],
+-        [3.1e-2, 6.200000e-02, had_mixture],
+-        [1.0e-1, 2.000000e-01, had_mixture],
+-        [3.1e-1, 6.200000e-01, had_mixture],
+-        [1.0e-3, 2.000000e-03, swap_map],
+-        [3.1e-3, 6.199997e-03, swap_map],
+-        [1.0e-2, 1.999992e-02, swap_map],
+-        [3.1e-2, 6.199752e-02, swap_map],
+-        [1.0e-1, 1.999162e-01, swap_map],
+-        [3.1e-1, 6.173918e-01, swap_map],
+-    ])
+-    def test_qubit_known_cases(self, variable, expected, generator, sparse):
+-        """
+-        Test cases based on comparisons to pre-existing dnorm implementations.
+-        In particular, the targets for the following test cases were generated
+-        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
+-        """
+-        id_chan = to_choi(qeye(2))
+-        channel = generator(variable)
+-        assert (
+-            dnorm(channel, id_chan, sparse=sparse)
+-            == pytest.approx(expected, abs=1e-7)
+-        )
+-
+-    def test_qubit_scalar(self, dimension):
+-        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
+-        a = np.random.random()
+-        A = rand_super_bcsz(dimension)
+-        B = rand_super_bcsz(dimension)
+-        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
+-
+-    def test_qubit_triangle(self, dimension):
+-        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
+-        A = rand_super_bcsz(dimension)
+-        B = rand_super_bcsz(dimension)
+-        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
+-
+-    @pytest.mark.repeat(3)
+-    @pytest.mark.parametrize("generator", [
+-        pytest.param(rand_super_bcsz, id="super"),
+-        pytest.param(rand_unitary, id="unitary"),
+-    ])
+-    def test_force_solve(self, dimension, generator):
+-        """
+-        Metrics: checks that special cases for dnorm agree with SDP solutions.
+-        """
+-        A, B = generator(dimension), generator(dimension)
+-        assert (
+-            dnorm(A, B, force_solve=False)
+-            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
+-        )
+-
+-    @pytest.mark.repeat(3)
+-    def test_cptp(self, dimension, sparse):
+-        """Check that the diamond norm is one for CPTP maps."""
+-        A = rand_super_bcsz(dimension)
+-        assert A.iscptp
+-        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
+-
+-
+-@pytest.mark.parametrize('superrep_conversion',
+-                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
+-def test_process_fidelity_of_identity(superrep_conversion):
+-    """
+-    Metrics: process fidelity of identity map is 1
+-    """
+-    num_qubits = 3
+-    oper = qeye(num_qubits*[2])
+-    f = process_fidelity(superrep_conversion(oper))
+-    assert np.isrealobj(f)
+-    assert f == pytest.approx(1)
+-
+-
+-@pytest.mark.parametrize('superrep_conversion',
+-                         [to_super, to_choi, to_chi, to_kraus])
+-def test_process_fidelity_identical_channels(superrep_conversion):
+-    """
+-    Metrics: process fidelity of a map to itself is 1
+-    """
+-    num_qubits = 2
+-    for k in range(10):
+-        oper = rand_super_bcsz(num_qubits*[2])
+-        oper = superrep_conversion(oper)
+-        f = process_fidelity(oper, oper)
+-        assert f == pytest.approx(1)
+-
+-
+-def test_process_fidelity_identical_unitaries():
+-    """
+-    Metrics: process fidelity of a unitary to itself is 1
+-    """
+-    num_qubits = 3
+-    for k in range(10):
+-        oper = rand_unitary(num_qubits * [2])
+-        f = process_fidelity(oper, oper)
+-        assert f == pytest.approx(1)
+-
+-
+-def test_process_fidelity_consistency():
+-    """
+-    Metrics: process fidelity independent of how channels are represented
+-    """
+-    num_qubits = 2
+-    for k in range(10):
+-        fidelities_u_to_u = []
+-        fidelities_u_to_id = []
+-        u1 = rand_unitary(num_qubits * [2])
+-        u2 = rand_unitary(num_qubits * [2])
+-        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
+-            fidelities_u_to_id.append(process_fidelity(map1(u1)))
+-            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
+-                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
+-        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
+-        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
+-
+-
+-def test_process_fidelity_unitary_invariance():
+-    """
+-    Metrics: process fidelity, invariance under unitary trans.
+-    """
+-    for k in range(10):
+-        op1 = rand_super_bcsz(10)
+-        op2 = rand_super_bcsz(10)
+-        u = to_super(rand_unitary(10))
+-        assert abs(
+-            process_fidelity(op1, op2)
+-            - process_fidelity(u*op1, u*op2)
+-        ) < 1e-8
+-
+-
+-@pytest.mark.parametrize('superrep_conversion',
+-                         [lambda x: x, to_super, to_choi, to_kraus])
+-def test_hilbert_space_dims(superrep_conversion):
+-    """
+-    Metrics: check _hilbert_space_dims
+-    """
+-    dims = [[2, 3], [4, 5]]
+-    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
+-    assert _hilbert_space_dims(superrep_conversion(u)) == dims
+-
+-
+-def test_hilbert_space_dims_chi():
+-    """
+-    Metrics: check _hilbert_space_dims for a chi channel
+-    """
+-    dims = [[2, 2], [2, 2]]
+-    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
+-    assert _hilbert_space_dims(to_chi(u)) == dims
++# -*- coding: utf-8 -*-
++
++import platform
++
++import numpy as np
++import pytest
++
++from qutip import (
++    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
++    qeye, rand_ket, rand_super_bcsz, rand_dm,
++    rand_unitary, to_super, to_choi, kraus_to_choi,
++    to_chi, to_kraus,
++)
++from qutip.core.gates import snot, swap
++
++try:
++    import cvxpy
++    import cvxopt
++except ImportError:
++    cvxpy, cvxopt = None, None
++
++# These ones are the metrics functions that we actually want to test.
++from qutip import (
++    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
++    unitarity, hilbert_dist, bures_dist, process_fidelity,
++)
++from qutip.core.metrics import _hilbert_space_dims
++
++
++@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
++def dimension(request):
++    # There are also some cases in the file where this fixture is explicitly
++    # overridden by a more local mark.  That is deliberate; this dimension is
++    # intended for non-superoperators, and may cause inordinantly long tests if
++    # (for example) something uses dimension=100 then makes a superoperator out
++    # of it.
++    return request.param
++
++
++@pytest.fixture(scope="function", params=[
++    pytest.param(rand_ket, id="pure"),
++    pytest.param(rand_dm, id="mixed"),
++])
++def state(request, dimension):
++    return request.param(dimension)
++
++
++# Also parametrise left, right as if they're the names of two states for tests
++# that need to take two states.
++left = right = state
++
++
++# The class names have an unusual naming convention to make them more
++# convenient to use with the `pytest -k "expr"` selection syntax.  They start
++# with the standard `Test`, but then are the name of the function they are
++# testing in the function naming convention, so it's easy to remember the
++# selector to choose a particular function.
++
++class Test_fidelity:
++    def test_mixed_state_inequality(self, dimension):
++        tol = 1e-7
++        rho1 = rand_dm(dimension, density=0.25)
++        rho2 = rand_dm(dimension, density=0.25)
++        F = fidelity(rho1, rho2)
++        assert 1 - F <= np.sqrt(1 - F*F) + tol
++
++    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
++    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
++    def test_orthogonal(self, left_dm, right_dm, dimension):
++        left = basis(dimension, 0)
++        right = basis(dimension, dimension//2)
++        if left_dm:
++            left = left.proj()
++        if right_dm:
++            right = right.proj()
++        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
++
++    def test_invariant_under_unitary_transformation(self, dimension):
++        rho1 = rand_dm(dimension, density=0.25)
++        rho2 = rand_dm(dimension, density=0.25)
++        U = rand_unitary(dimension)
++        F = fidelity(rho1, rho2)
++        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
++        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
++
++    def test_state_with_itself(self, state):
++        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
++
++    def test_bounded(self, left, right, dimension):
++        """Test that fidelity is bounded on [0, 1]."""
++        tol = 1e-7
++        assert -tol <= fidelity(left, right) <= 1 + tol
++
++    def test_pure_state_equivalent_to_overlap(self, dimension):
++        """Check fidelity against pure-state overlap, see gh-361."""
++        psi = rand_ket(dimension)
++        phi = rand_ket(dimension)
++        overlap = np.abs(psi.overlap(phi))
++        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
++
++    ket_0 = basis(2, 0)
++    ket_1 = basis(2, 1)
++    ket_p = (ket_0 + ket_1).unit()
++    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
++    max_mixed = qeye(2).unit()
++
++    @pytest.mark.parametrize(['left', 'right', 'expected'], [
++        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
++        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
++        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
++        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
++                     id="|+>,|+'>"),
++    ])
++    def test_known_cases(self, left, right, expected):
++        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
++
++
++class Test_tracedist:
++    def test_state_with_itself(self, state):
++        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
++
++    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
++    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
++    def test_orthogonal(self, left_dm, right_dm, dimension):
++        left = basis(dimension, 0)
++        right = basis(dimension, dimension//2)
++        if left_dm:
++            left = left.proj()
++        if right_dm:
++            right = right.proj()
++        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
++
++    def test_invariant_under_unitary_transformation(self, dimension):
++        rho1 = rand_dm(dimension, density=0.25)
++        rho2 = rand_dm(dimension, density=0.25)
++        U = rand_unitary(dimension)
++        D = tracedist(rho1, rho2)
++        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
++        assert D == pytest.approx(DU, rel=1e-5)
++
++
++class Test_hellinger_dist:
++    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
++    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
++    def test_orthogonal(self, left_dm, right_dm, dimension):
++        left = basis(dimension, 0)
++        right = basis(dimension, dimension//2)
++        if left_dm:
++            left = left.proj()
++        if right_dm:
++            right = right.proj()
++        expected = np.sqrt(2)
++        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
++
++    def test_state_with_itself(self, state):
++        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
++
++    def test_known_cases_pure_states(self, dimension):
++        left = rand_ket(dimension)
++        right = rand_ket(dimension)
++        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
++        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
++
++    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
++    def test_monotonicity(self, dimension):
++        """
++        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
++        arXiv:1611.03449v2:
++            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
++            >= hellinger_dist(rhoA, sigmaA)
++        with equality iff sigmaB = rhoB where '&' is the tensor product.
++        """
++        tol = 1e-5
++        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
++        rho = tensor(rhoA, rhoB)
++        rho_sim = tensor(rhoA, sigmaB)
++        sigma = tensor(sigmaA, sigmaB)
++        dist = hellinger_dist(rhoA, sigmaA)
++        assert hellinger_dist(rho, sigma) + tol > dist
++        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
++
++
++class Test_average_gate_fidelity:
++    def test_identity(self, dimension):
++        id = qeye(dimension)
++        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
++
++    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
++    def test_bounded(self, dimension):
++        tol = 1e-7
++        channel = rand_super_bcsz(dimension)
++        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
++
++    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
++    def test_unitaries_equal_1(self, dimension):
++        """Tests that for random unitaries U, AGF(U, U) = 1."""
++        tol = 1e-7
++        U = rand_unitary(dimension)
++        SU = to_super(U)
++        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
++
++    def test_average_gate_fidelity_against_legacy_implementation(self):
++        """
++        Metrics: Test that AGF coincides with pre-5.0 implementation
++        """
++        def agf_pre_50(oper, target=None):
++            kraus = to_kraus(oper)
++            d = kraus[0].shape[0]
++
++            if kraus[0].shape[1] != d:
++                return TypeError(
++                    "Average gate fidelity only implemented for square "
++                    "superoperators.")
++
++            if target is None:
++                return (
++                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
++                    (d * d + d)
++                )
++            return (
++                (d + np.sum([
++                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
++                ])) / (d * d + d)
++            )
++
++        oper = rand_super_bcsz(16)
++        target = rand_unitary(16)
++        np.testing.assert_almost_equal(
++            average_gate_fidelity(oper, target),
++            agf_pre_50(oper, target)
++        )
++
++
++class Test_hilbert_dist:
++    def test_known_cases(self):
++        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
++        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
++        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
++
++
++paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
++
++
++class Test_unitarity:
++    @pytest.mark.parametrize(['operator', 'expected'], [
++        pytest.param(to_super(sigmax()), 1, id="sigmax"),
++        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
++        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
++                     id="id+sigmax"),
++    ])
++    def test_known_cases(self, operator, expected):
++        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
++
++    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
++    def test_bounded(self, n_qubits):
++        tol = 1e-7
++        operator = rand_super_bcsz(2**n_qubits)
++        assert -tol <= unitarity(operator) <= 1 + tol
++
++
++class TestComparisons:
++    """Test some known inequalities between two different metrics."""
++
++    def test_inequality_tracedist_to_fidelity(self, left, right):
++        tol = 1e-7
++        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
++
++    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
++        tol = 1e-7
++        hellinger = hellinger_dist(left, right)
++        bures = bures_dist(left, right)
++        assert bures <= hellinger + tol
++
++
++def overrotation(x):
++    return to_super((1j * np.pi * x * sigmax() / 2).expm())
++
++
++def had_mixture(x):
++    id_chan = to_choi(qeye(2))
++    S_eye = to_super(id_chan)
++    S_H = to_super(snot())
++    return (1 - x) * S_eye + x * S_H
++
++
++def swap_map(x):
++    base = (1j * x * swap()).expm()
++    dims = [[[2], [2]], [[2], [2]]]
++    return Qobj(base, dims=dims, type='super', superrep='super')
++
++
++def adc_choi(x):
++    kraus = [
++        np.sqrt(1 - x) * qeye(2),
++        np.sqrt(x) * destroy(2),
++        np.sqrt(x) * fock_dm(2, 0),
++    ]
++    return kraus_to_choi(kraus)
++
++
++# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
++# to solve the problem, and this can cause an entire test-suite failure.  As
++# long as we are using random tests (perhaps not ideal), this will happen
++# occasionally.  This isn't entirely a bug, it's just a reality of using a
++# one-size-fits-all solver; we've historically assumed users who come up
++# against this sort of thing will be accepting of the fact that dnorm
++# calculation is nontrivial, and isn't always entirely feasible.
++#
++# To deal with it, we allow each test to be rerun twice, using
++# pytest-rerunfailures.  This should forbid pathological cases where the test
++# is failing every time, but not penalise one-off failures.  As far as we know,
++# the failing tests always involve a random step, so triggering a re-run will
++# have them choose new variables as well.
++#
++# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
++# which is deprecated as of numpy 1.20.
++#
++# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
++# depends on them.
++@pytest.mark.skipif(cvxpy is None or cvxopt is None,
++                    reason="Skipping dnorm tests because dnorm requires cvxpy"
++                    " and cvxopt which are not installed.")
++@pytest.mark.skipif("Windows" in platform.system(),
++                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
++                    " installed on Windows but fail to correctly solve"
++                    " the given optimization problems.")
++@pytest.mark.flaky(reruns=2)
++@pytest.mark.filterwarnings(
++    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
++)
++class Test_dnorm:
++    @pytest.fixture(params=[2, 3])
++    def dimension(self, request):
++        return request.param
++
++    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
++    def sparse(self, request):
++        return request.param
++
++    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
++    def test_sparse_against_dense_adc(self, variable):
++        """
++        Test sparse versus dense dnorm calculation for a sample of
++        amplitude-damping channels.
++        """
++        # Choi matrix for identity channel on 1 qubit
++        A = kraus_to_choi([qeye(2)])
++        B = adc_choi(variable)
++        dense = dnorm(A, B, force_solve=True, sparse=False)
++        sparse = dnorm(A, B, force_solve=True, sparse=True)
++        assert dense == pytest.approx(sparse, abs=1e-7)
++
++    @pytest.mark.repeat(3)
++    def test_sparse_against_dense_random(self, dimension):
++        """
++        Test sparse versus dense dnorm calculation for random superoperators.
++        """
++        A = rand_super_bcsz(dimension)
++        dense_run_result = dnorm(A, force_solve=True, sparse=False)
++        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
++        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
++
++    def test_bounded(self, dimension, sparse):
++        """dnorm(A - B) in [0, 2] for random superops A, B."""
++        tol = 1e-7
++        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
++        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
++
++    def test_qubit_simple_known_cases(self, sparse):
++        """Check agreement for known qubit channels."""
++        id_chan = to_choi(qeye(2))
++        X_chan = to_choi(sigmax())
++        depol = to_choi(Qobj(
++            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
++        ))
++        # We need to restrict the number of iterations for things on the
++        # boundary, such as perfectly distinguishable channels.
++        assert (
++            dnorm(id_chan, X_chan, sparse=sparse)
++            == pytest.approx(2, abs=1e-7)
++        )
++        assert (
++            dnorm(id_chan, depol, sparse=sparse)
++            == pytest.approx(1.5, abs=1e-7)
++        )
++        # Finally, we add a known case from Johnston's QETLAB documentation,
++        #   || Phi - I ||_♢,
++        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
++        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
++        assert (
++            dnorm(U, qeye(2), sparse=sparse)
++            == pytest.approx(np.sqrt(2), abs=1e-7)
++        )
++
++    @pytest.mark.parametrize(["variable", "expected", "generator"], [
++        [1.0e-3, 3.141591e-03, overrotation],
++        [3.1e-3, 9.738899e-03, overrotation],
++        [1.0e-2, 3.141463e-02, overrotation],
++        [3.1e-2, 9.735089e-02, overrotation],
++        [1.0e-1, 3.128689e-01, overrotation],
++        [3.1e-1, 9.358596e-01, overrotation],
++        [1.0e-3, 2.000000e-03, had_mixture],
++        [3.1e-3, 6.200000e-03, had_mixture],
++        [1.0e-2, 2.000000e-02, had_mixture],
++        [3.1e-2, 6.200000e-02, had_mixture],
++        [1.0e-1, 2.000000e-01, had_mixture],
++        [3.1e-1, 6.200000e-01, had_mixture],
++        [1.0e-3, 2.000000e-03, swap_map],
++        [3.1e-3, 6.199997e-03, swap_map],
++        [1.0e-2, 1.999992e-02, swap_map],
++        [3.1e-2, 6.199752e-02, swap_map],
++        [1.0e-1, 1.999162e-01, swap_map],
++        [3.1e-1, 6.173918e-01, swap_map],
++    ])
++    def test_qubit_known_cases(self, variable, expected, generator, sparse):
++        """
++        Test cases based on comparisons to pre-existing dnorm implementations.
++        In particular, the targets for the following test cases were generated
++        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
++        """
++        id_chan = to_choi(qeye(2))
++        channel = generator(variable)
++        assert (
++            dnorm(channel, id_chan, sparse=sparse)
++            == pytest.approx(expected, abs=1e-7)
++        )
++
++    def test_qubit_scalar(self, dimension):
++        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
++        a = np.random.random()
++        A = rand_super_bcsz(dimension)
++        B = rand_super_bcsz(dimension)
++        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
++
++    def test_qubit_triangle(self, dimension):
++        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
++        A = rand_super_bcsz(dimension)
++        B = rand_super_bcsz(dimension)
++        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
++
++    @pytest.mark.repeat(3)
++    @pytest.mark.parametrize("generator", [
++        pytest.param(rand_super_bcsz, id="super"),
++        pytest.param(rand_unitary, id="unitary"),
++    ])
++    def test_force_solve(self, dimension, generator):
++        """
++        Metrics: checks that special cases for dnorm agree with SDP solutions.
++        """
++        A, B = generator(dimension), generator(dimension)
++        assert (
++            dnorm(A, B, force_solve=False)
++            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
++        )
++
++    @pytest.mark.repeat(3)
++    def test_cptp(self, dimension, sparse):
++        """Check that the diamond norm is one for CPTP maps."""
++        A = rand_super_bcsz(dimension)
++        assert A.iscptp
++        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
++
++
++@pytest.mark.parametrize('superrep_conversion',
++                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
++def test_process_fidelity_of_identity(superrep_conversion):
++    """
++    Metrics: process fidelity of identity map is 1
++    """
++    num_qubits = 3
++    oper = qeye(num_qubits*[2])
++    f = process_fidelity(superrep_conversion(oper))
++    assert np.isrealobj(f)
++    assert f == pytest.approx(1)
++
++
++@pytest.mark.parametrize('superrep_conversion',
++                         [to_super, to_choi, to_chi, to_kraus])
++def test_process_fidelity_identical_channels(superrep_conversion):
++    """
++    Metrics: process fidelity of a map to itself is 1
++    """
++    num_qubits = 2
++    for k in range(10):
++        oper = rand_super_bcsz(num_qubits*[2])
++        oper = superrep_conversion(oper)
++        f = process_fidelity(oper, oper)
++        assert f == pytest.approx(1)
++
++
++def test_process_fidelity_identical_unitaries():
++    """
++    Metrics: process fidelity of a unitary to itself is 1
++    """
++    num_qubits = 3
++    for k in range(10):
++        oper = rand_unitary(num_qubits * [2])
++        f = process_fidelity(oper, oper)
++        assert f == pytest.approx(1)
++
++
++def test_process_fidelity_consistency():
++    """
++    Metrics: process fidelity independent of how channels are represented
++    """
++    num_qubits = 2
++    for k in range(10):
++        fidelities_u_to_u = []
++        fidelities_u_to_id = []
++        u1 = rand_unitary(num_qubits * [2])
++        u2 = rand_unitary(num_qubits * [2])
++        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
++            fidelities_u_to_id.append(process_fidelity(map1(u1)))
++            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
++                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
++        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
++        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
++
++
++def test_process_fidelity_unitary_invariance():
++    """
++    Metrics: process fidelity, invariance under unitary trans.
++    """
++    for k in range(10):
++        op1 = rand_super_bcsz(10)
++        op2 = rand_super_bcsz(10)
++        u = to_super(rand_unitary(10))
++        assert abs(
++            process_fidelity(op1, op2)
++            - process_fidelity(u*op1, u*op2)
++        ) < 1e-8
++
++
++@pytest.mark.parametrize('superrep_conversion',
++                         [lambda x: x, to_super, to_choi, to_kraus])
++def test_hilbert_space_dims(superrep_conversion):
++    """
++    Metrics: check _hilbert_space_dims
++    """
++    dims = [[2, 3], [4, 5]]
++    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
++    assert _hilbert_space_dims(superrep_conversion(u)) == dims
++
++
++def test_hilbert_space_dims_chi():
++    """
++    Metrics: check _hilbert_space_dims for a chi channel
++    """
++    dims = [[2, 2], [2, 2]]
++    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
++    assert _hilbert_space_dims(to_chi(u)) == dims
+diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
+index c8e6d72f..f59dce8f 100644
+--- a/qutip/tests/core/test_operators.py
++++ b/qutip/tests/core/test_operators.py
+@@ -1,295 +1,295 @@
+-import numbers
+-import numpy as np
+-import pytest
+-import qutip
+-
+-
+-N = 5
+-
+-
+-def test_jmat_12():
+-    spinhalf = qutip.jmat(1 / 2.)
+-
+-    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
+-    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
+-    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
+-    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
+-    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
+-
+-    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
+-    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
+-    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
+-    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
+-    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
+-
+-    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
+-    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
+-    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
+-    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
+-    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
+-
+-    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
+-    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
+-    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
+-    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
+-    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
+-
+-    spin_set = qutip.spin_J_set(0.5)
+-    for i in range(3):
+-        assert spinhalf[i] == spin_set[i]
+-
+-
+-
+-def test_jmat_32():
+-    spin32 = qutip.jmat(3 / 2.)
+-
+-    paulix32 = np.array(
+-        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
+-         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
+-         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
+-         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
+-
+-    pauliy32 = np.array(
+-        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
+-         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
+-         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
+-         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
+-
+-    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
+-                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
+-                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
+-                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
+-
+-    np.testing.assert_allclose(spin32[0].full(), paulix32)
+-    np.testing.assert_allclose(spin32[1].full(), pauliy32)
+-    np.testing.assert_allclose(spin32[2].full(), pauliz32)
+-
+-
+-@pytest.mark.parametrize(['spin', 'N'], [
+-    pytest.param(3/2., 4, id="1.5"),
+-    pytest.param(5/2., 6, id="2.5"),
+-    pytest.param(3.0, 7, id="3.0"),
+-])
+-def test_jmat_dims(spin, N):
+-    spin_mat = qutip.jmat(spin, '+')
+-    assert spin_mat.dims == [[N], [N]]
+-    assert spin_mat.shape == (N, N)
+-
+-
+-def test_jmat_raise():
+-    with pytest.raises(ValueError) as e:
+-        qutip.jmat(0.25)
+-    assert str(e.value) == 'j must be a non-negative integer or half-integer'
+-
+-    with pytest.raises(ValueError) as e:
+-        qutip.jmat(0.5, 'zx+')
+-    assert "Invalid spin operator" in str(e.value)
+-
+-
+-@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
+-    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
+-    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
+-    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
+-    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
+-                 id="destroy_offset"),
+-    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
+-    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
+-                 id="create_offset"),
+-    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
+-    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
+-    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
+-    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
+-                 id="charge_args"),
+-])
+-def test_diagonal_operators(oper_func, diag, offset, args):
+-    oper = oper_func(N, *args)
+-    assert oper == qutip.Qobj(np.diag(diag, offset))
+-
+-
+-@pytest.mark.parametrize(['function', 'message'], [
+-    (qutip.qeye, "All dimensions must be integers >= 0"),
+-    (qutip.destroy, "Hilbert space dimension must be integer value"),
+-    (qutip.create, "Hilbert space dimension must be integer value"),
+-], ids=["qeye", "destroy", "create"])
+-def test_diagonal_raise(function, message):
+-    with pytest.raises(ValueError) as e:
+-        function(2.5)
+-    assert str(e.value) == message
+-
+-
+-@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
+-@pytest.mark.parametrize("dimensions", [
+-        2,
+-        [2],
+-        [2, 3, 4],
+-        1,
+-        [1],
+-        [1, 1],
+-    ])
+-def test_implicit_tensor_creation(to_test, dimensions):
+-    implicit = to_test(dimensions)
+-    if isinstance(dimensions, numbers.Integral):
+-        dimensions = [dimensions]
+-    assert implicit.dims == [dimensions, dimensions]
+-
+-
+-@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
+-def test_super_operator_creation(to_test):
+-    size = 2
+-    implicit = to_test([[size], [size]])
+-    explicit = qutip.to_super(to_test(size))
+-    assert implicit == explicit
+-
+-
+-def test_position():
+-    operator = qutip.position(N)
+-    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
+-                np.diag((np.arange(1, N) / 2)**0.5, k=1))
+-    np.testing.assert_allclose(operator.full(), expected)
+-    assert operator._isherm == True
+-
+-
+-def test_momentum():
+-    operator = qutip.momentum(N)
+-    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
+-                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
+-    np.testing.assert_allclose(operator.full(), expected)
+-    assert operator._isherm == True
+-
+-
+-def test_squeeze():
+-    sq = qutip.squeeze(4, 0.1 + 0.1j)
+-    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
+-                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
+-                         [0.00000000 + 0.j, 0.98503746 + 0.j,
+-                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
+-                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
+-                          0.99500417 + 0.j, 0.00000000 + 0.j],
+-                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
+-                          0.00000000 + 0.j, 0.98503746 + 0.j]])
+-    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
+-
+-
+-def test_squeezing():
+-    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
+-    a = qutip.destroy(4)
+-    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
+-    assert squeeze == squeezing
+-
+-
+-def test_displace():
+-    dp = qutip.displace(4, 0.25)
+-    dpmatrix = np.array(
+-        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
+-          0.00626025 + 0.j],
+-         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
+-          0.j, 0.07418172 + 0.j],
+-         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
+-          0.j, -0.41083747 + 0.j],
+-         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
+-          0.90866411 + 0.j]])
+-    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
+-
+-
+-@pytest.mark.parametrize("shift", [1, 2])
+-def test_tunneling(shift):
+-    N = 10
+-    tn = qutip.tunneling(N, shift)
+-    tn_matrix = np.diag(np.ones(N - shift), k=shift)
+-    tn_matrix += tn_matrix.T
+-    np.testing.assert_allclose(tn.full(), tn_matrix)
+-
+-
+-def test_commutator():
+-    A = qutip.qeye(N)
+-    B = qutip.destroy(N)
+-    assert qutip.commutator(A, B) == qutip.qzero(N)
+-
+-    sx = qutip.sigmax()
+-    sy = qutip.sigmay()
+-    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
+-
+-    A = qutip.qeye(N)
+-    B = qutip.destroy(N)
+-    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
+-
+-    sx = qutip.sigmax()
+-    sy = qutip.sigmay()
+-    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
+-
+-    with pytest.raises(TypeError) as e:
+-        qutip.commutator(sx, sy, 'something')
+-    assert str(e.value).startswith("Unknown commutator kind")
+-
+-def test_qutrit_ops():
+-    ops = qutip.qutrit_ops()
+-    assert qutip.qeye(3) == sum(ops[:3])
+-    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
+-    expected = np.zeros((3, 3))
+-    expected[2, 0] = 1
+-    np.testing.assert_allclose(expected, ops[5].full())
+-
+-
+-def _id_func(val):
+-    "ids generated from the function only"
+-    if isinstance(val, tuple):
+-        return ""
+-
+-
+-# random object accept `str` and base.Data
+-# Obtain all valid dtype from `to`
+-dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
+-dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
+-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+-                         ids=[str(dtype) for dtype in dtype_names])
+-@pytest.mark.parametrize(['func', 'args'], [
+-    (qutip.qdiags, ([0, 1, 2], 1)),
+-    (qutip.jmat, (1,)),
+-    (qutip.spin_Jx, (1,)),
+-    (qutip.spin_Jy, (1,)),
+-    (qutip.spin_Jz, (1,)),
+-    (qutip.spin_Jp, (1,)),
+-    (qutip.destroy, (5,)),
+-    (qutip.create, (5,)),
+-    (qutip.qzero, (5,)),
+-    (qutip.qeye, (5,)),
+-    (qutip.position, (5,)),
+-    (qutip.momentum, (5,)),
+-    (qutip.num, (5,)),
+-    (qutip.squeeze, (5, 0.5)),
+-    (qutip.displace, (5, 1.0)),
+-    (qutip.qutrit_ops, ()),
+-    (qutip.phase, (5,)),
+-    (qutip.charge, (5,)),
+-    (qutip.tunneling, (5,)),
+-    (qutip.enr_destroy, ([3, 3, 3], 4)),
+-    (qutip.enr_identity, ([3, 3, 3], 4)),
+-], ids=_id_func)
+-def test_operator_type(func, args, alias, dtype):
+-    object = func(*args, dtype=alias)
+-    if isinstance(object, qutip.Qobj):
+-        assert isinstance(object.data, dtype)
+-    else:
+-        for obj in object:
+-            assert isinstance(obj.data, dtype)
+-
+-    with qutip.CoreOptions(default_dtype=alias):
+-        object = func(*args)
+-        if isinstance(object, qutip.Qobj):
+-            assert isinstance(object.data, dtype)
+-        else:
+-            for obj in object:
+-                assert isinstance(obj.data, dtype)
+-
+-
+-@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
+-def test_qft(dims):
+-    N = np.prod(dims)
+-    qft = qutip.qft(N).full()
+-    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
+-    for i in range(N):
+-        target = np.zeros(N)
+-        target[i] = 1
+-        fft = np.fft.fft(qft[:,i])
+-        fft /= np.sum(fft)
+-        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
++import numbers
++import numpy as np
++import pytest
++import qutip
++
++
++N = 5
++
++
++def test_jmat_12():
++    spinhalf = qutip.jmat(1 / 2.)
++
++    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
++    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
++    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
++    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
++    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
++
++    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
++    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
++    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
++    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
++    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
++
++    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
++    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
++    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
++    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
++    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
++
++    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
++    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
++    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
++    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
++    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
++
++    spin_set = qutip.spin_J_set(0.5)
++    for i in range(3):
++        assert spinhalf[i] == spin_set[i]
++
++
++
++def test_jmat_32():
++    spin32 = qutip.jmat(3 / 2.)
++
++    paulix32 = np.array(
++        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
++         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
++         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
++         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
++
++    pauliy32 = np.array(
++        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
++         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
++         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
++         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
++
++    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
++                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
++                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
++                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
++
++    np.testing.assert_allclose(spin32[0].full(), paulix32)
++    np.testing.assert_allclose(spin32[1].full(), pauliy32)
++    np.testing.assert_allclose(spin32[2].full(), pauliz32)
++
++
++@pytest.mark.parametrize(['spin', 'N'], [
++    pytest.param(3/2., 4, id="1.5"),
++    pytest.param(5/2., 6, id="2.5"),
++    pytest.param(3.0, 7, id="3.0"),
++])
++def test_jmat_dims(spin, N):
++    spin_mat = qutip.jmat(spin, '+')
++    assert spin_mat.dims == [[N], [N]]
++    assert spin_mat.shape == (N, N)
++
++
++def test_jmat_raise():
++    with pytest.raises(ValueError) as e:
++        qutip.jmat(0.25)
++    assert str(e.value) == 'j must be a non-negative integer or half-integer'
++
++    with pytest.raises(ValueError) as e:
++        qutip.jmat(0.5, 'zx+')
++    assert "Invalid spin operator" in str(e.value)
++
++
++@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
++    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
++    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
++    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
++    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
++                 id="destroy_offset"),
++    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
++    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
++                 id="create_offset"),
++    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
++    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
++    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
++    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
++                 id="charge_args"),
++])
++def test_diagonal_operators(oper_func, diag, offset, args):
++    oper = oper_func(N, *args)
++    assert oper == qutip.Qobj(np.diag(diag, offset))
++
++
++@pytest.mark.parametrize(['function', 'message'], [
++    (qutip.qeye, "All dimensions must be integers >= 0"),
++    (qutip.destroy, "Hilbert space dimension must be integer value"),
++    (qutip.create, "Hilbert space dimension must be integer value"),
++], ids=["qeye", "destroy", "create"])
++def test_diagonal_raise(function, message):
++    with pytest.raises(ValueError) as e:
++        function(2.5)
++    assert str(e.value) == message
++
++
++@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
++@pytest.mark.parametrize("dimensions", [
++        2,
++        [2],
++        [2, 3, 4],
++        1,
++        [1],
++        [1, 1],
++    ])
++def test_implicit_tensor_creation(to_test, dimensions):
++    implicit = to_test(dimensions)
++    if isinstance(dimensions, numbers.Integral):
++        dimensions = [dimensions]
++    assert implicit.dims == [dimensions, dimensions]
++
++
++@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
++def test_super_operator_creation(to_test):
++    size = 2
++    implicit = to_test([[size], [size]])
++    explicit = qutip.to_super(to_test(size))
++    assert implicit == explicit
++
++
++def test_position():
++    operator = qutip.position(N)
++    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
++                np.diag((np.arange(1, N) / 2)**0.5, k=1))
++    np.testing.assert_allclose(operator.full(), expected)
++    assert operator._isherm == True
++
++
++def test_momentum():
++    operator = qutip.momentum(N)
++    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
++                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
++    np.testing.assert_allclose(operator.full(), expected)
++    assert operator._isherm == True
++
++
++def test_squeeze():
++    sq = qutip.squeeze(4, 0.1 + 0.1j)
++    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
++                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
++                         [0.00000000 + 0.j, 0.98503746 + 0.j,
++                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
++                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
++                          0.99500417 + 0.j, 0.00000000 + 0.j],
++                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
++                          0.00000000 + 0.j, 0.98503746 + 0.j]])
++    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
++
++
++def test_squeezing():
++    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
++    a = qutip.destroy(4)
++    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
++    assert squeeze == squeezing
++
++
++def test_displace():
++    dp = qutip.displace(4, 0.25)
++    dpmatrix = np.array(
++        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
++          0.00626025 + 0.j],
++         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
++          0.j, 0.07418172 + 0.j],
++         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
++          0.j, -0.41083747 + 0.j],
++         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
++          0.90866411 + 0.j]])
++    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
++
++
++@pytest.mark.parametrize("shift", [1, 2])
++def test_tunneling(shift):
++    N = 10
++    tn = qutip.tunneling(N, shift)
++    tn_matrix = np.diag(np.ones(N - shift), k=shift)
++    tn_matrix += tn_matrix.T
++    np.testing.assert_allclose(tn.full(), tn_matrix)
++
++
++def test_commutator():
++    A = qutip.qeye(N)
++    B = qutip.destroy(N)
++    assert qutip.commutator(A, B) == qutip.qzero(N)
++
++    sx = qutip.sigmax()
++    sy = qutip.sigmay()
++    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
++
++    A = qutip.qeye(N)
++    B = qutip.destroy(N)
++    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
++
++    sx = qutip.sigmax()
++    sy = qutip.sigmay()
++    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
++
++    with pytest.raises(TypeError) as e:
++        qutip.commutator(sx, sy, 'something')
++    assert str(e.value).startswith("Unknown commutator kind")
++
++def test_qutrit_ops():
++    ops = qutip.qutrit_ops()
++    assert qutip.qeye(3) == sum(ops[:3])
++    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
++    expected = np.zeros((3, 3))
++    expected[2, 0] = 1
++    np.testing.assert_allclose(expected, ops[5].full())
++
++
++def _id_func(val):
++    "ids generated from the function only"
++    if isinstance(val, tuple):
++        return ""
++
++
++# random object accept `str` and base.Data
++# Obtain all valid dtype from `to`
++dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
++dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
++@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
++                         ids=[str(dtype) for dtype in dtype_names])
++@pytest.mark.parametrize(['func', 'args'], [
++    (qutip.qdiags, ([0, 1, 2], 1)),
++    (qutip.jmat, (1,)),
++    (qutip.spin_Jx, (1,)),
++    (qutip.spin_Jy, (1,)),
++    (qutip.spin_Jz, (1,)),
++    (qutip.spin_Jp, (1,)),
++    (qutip.destroy, (5,)),
++    (qutip.create, (5,)),
++    (qutip.qzero, (5,)),
++    (qutip.qeye, (5,)),
++    (qutip.position, (5,)),
++    (qutip.momentum, (5,)),
++    (qutip.num, (5,)),
++    (qutip.squeeze, (5, 0.5)),
++    (qutip.displace, (5, 1.0)),
++    (qutip.qutrit_ops, ()),
++    (qutip.phase, (5,)),
++    (qutip.charge, (5,)),
++    (qutip.tunneling, (5,)),
++    (qutip.enr_destroy, ([3, 3, 3], 4)),
++    (qutip.enr_identity, ([3, 3, 3], 4)),
++], ids=_id_func)
++def test_operator_type(func, args, alias, dtype):
++    object = func(*args, dtype=alias)
++    if isinstance(object, qutip.Qobj):
++        assert isinstance(object.data, dtype)
++    else:
++        for obj in object:
++            assert isinstance(obj.data, dtype)
++
++    with qutip.CoreOptions(default_dtype=alias):
++        object = func(*args)
++        if isinstance(object, qutip.Qobj):
++            assert isinstance(object.data, dtype)
++        else:
++            for obj in object:
++                assert isinstance(obj.data, dtype)
++
++
++@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
++def test_qft(dims):
++    N = np.prod(dims)
++    qft = qutip.qft(N).full()
++    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
++    for i in range(N):
++        target = np.zeros(N)
++        target[i] = 1
++        fft = np.fft.fft(qft[:,i])
++        fft /= np.sum(fft)
++        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
+diff --git a/qutip/tests/core/test_ptrace.py b/qutip/tests/core/test_ptrace.py
+index 40efd151..8ae26d52 100644
+--- a/qutip/tests/core/test_ptrace.py
++++ b/qutip/tests/core/test_ptrace.py
+@@ -1,130 +1,130 @@
+-import itertools
+-
+-import numpy as np
+-import pytest
+-
+-import qutip
+-from qutip.core import data as _data
+-
+-
+-def expected(qobj, sel):
+-    if qobj.isbra or qobj.isket:
+-        qobj = qobj.proj()
+-    sel = sorted(sel)
+-    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
+-    new_shape = (np.prod(dims[0], dtype=int),) * 2
+-    out = qobj.full()
+-    before, after = 1, qobj.shape[0]
+-    for i, dim in enumerate(qobj.dims[0]):
+-        after //= dim
+-        if i in sel:
+-            before = before * dim
+-            continue
+-        tmp_dims = (before, dim, after) * 2
+-        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
+-    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
+-
+-
+-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
+-def dtype(request):
+-    return request.param
+-
+-
+-@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
+-def dm(request):
+-    return request.param
+-
+-
+-@pytest.fixture
+-def state(dtype, dm):
+-    dims = [2, 3, 4]
+-    state = qutip.rand_ket(dims)
+-    if dm:
+-        state = state.proj()
+-    return state.to(dtype)
+-
+-
+-def test_ptrace_noncompound_rand(dtype, dm):
+-    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
+-    for _ in range(5):
+-        state = qutip.rand_ket(5)
+-        if dm:
+-            state = state.proj()
+-        state = state.to(dtype)
+-        assert state.ptrace(0) == (state if dm else state.proj())
+-
+-
+-@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
+-def test_ptrace_unsorted_selection_subset(state, pair):
+-    """
+-    Regression test for gh-1325.  ptrace should work the same independently of
+-    the order of the input; no transposition in done in the trace operation.
+-    """
+-    # pair is always sorted.
+-    state_ordered = state.ptrace(pair)
+-    state_reversed = state.ptrace(pair[::-1])
+-    assert state_ordered.dims == state_reversed.dims
+-    assert state_ordered == state_reversed
+-
+-
+-@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
+-def test_ptrace_unsorted_selection_all(state, permutation):
+-    state_ptraced = state.ptrace(permutation)
+-    if state.isket:
+-        state = state.proj()
+-    assert state.dims == state_ptraced.dims
+-    assert state == state_ptraced
+-
+-
+-@pytest.mark.parametrize(['selection', 'exception'], [
+-    pytest.param(4, IndexError, id='too big'),
+-    pytest.param(-1, IndexError, id='too small'),
+-    pytest.param([0, 0], ValueError, id='duplicate'),
+-    # 'too many' may throw either from duplication or invalid index.
+-    pytest.param([0, 1, 2, 3], Exception, id='too many'),
+-])
+-def test_ptrace_fails_on_invalid_input(state, selection, exception):
+-    with pytest.raises(exception):
+-        state.ptrace(selection)
+-
+-
+-@pytest.mark.parametrize('dims, sel',
+-                         [
+-                             ([5, 2, 3], [2, 1]),
+-                             ([5, 2, 3], [0, 2]),
+-                             ([5, 2, 3], [0, 1]),
+-                             ([2]*6, [3, 2]),
+-                             ([2]*6, [0, 2]),
+-                             ([2]*6, [0, 1]),
+-                         ])
+-def test_ptrace_rand_ket(dtype, dims, sel):
+-    A = qutip.rand_ket(dims)
+-    assert A.ptrace(sel) == expected(A, sel)
+-
+-
+-@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
+-                         ids=['trace_all',
+-                              'trace_none',
+-                              'trace_one',
+-                              'trace_one_2',
+-                              'trace_multiple',
+-                              'trace_multiple_not_sorted',
+-                              ])
+-def test_ptrace_rand_dm(dtype, sel):
+-    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
+-    assert A.ptrace(sel) == expected(A, sel)
+-
+-
+-@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
+-                         ids=['trace_all',
+-                              'trace_none',
+-                              'trace_one',
+-                              'trace_one_2',
+-                              'trace_multiple',
+-                              'trace_multiple_not_sorted',
+-                              ])
+-def test_ptrace_operator(dtype, sel):
+-    A = qutip.tensor(
+-        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
+-    ).to(dtype)
+-    assert A.ptrace(sel) == expected(A, sel)
++import itertools
++
++import numpy as np
++import pytest
++
++import qutip
++from qutip.core import data as _data
++
++
++def expected(qobj, sel):
++    if qobj.isbra or qobj.isket:
++        qobj = qobj.proj()
++    sel = sorted(sel)
++    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
++    new_shape = (np.prod(dims[0], dtype=int),) * 2
++    out = qobj.full()
++    before, after = 1, qobj.shape[0]
++    for i, dim in enumerate(qobj.dims[0]):
++        after //= dim
++        if i in sel:
++            before = before * dim
++            continue
++        tmp_dims = (before, dim, after) * 2
++        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
++    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
++
++
++@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
++def dtype(request):
++    return request.param
++
++
++@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
++def dm(request):
++    return request.param
++
++
++@pytest.fixture
++def state(dtype, dm):
++    dims = [2, 3, 4]
++    state = qutip.rand_ket(dims)
++    if dm:
++        state = state.proj()
++    return state.to(dtype)
++
++
++def test_ptrace_noncompound_rand(dtype, dm):
++    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
++    for _ in range(5):
++        state = qutip.rand_ket(5)
++        if dm:
++            state = state.proj()
++        state = state.to(dtype)
++        assert state.ptrace(0) == (state if dm else state.proj())
++
++
++@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
++def test_ptrace_unsorted_selection_subset(state, pair):
++    """
++    Regression test for gh-1325.  ptrace should work the same independently of
++    the order of the input; no transposition in done in the trace operation.
++    """
++    # pair is always sorted.
++    state_ordered = state.ptrace(pair)
++    state_reversed = state.ptrace(pair[::-1])
++    assert state_ordered.dims == state_reversed.dims
++    assert state_ordered == state_reversed
++
++
++@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
++def test_ptrace_unsorted_selection_all(state, permutation):
++    state_ptraced = state.ptrace(permutation)
++    if state.isket:
++        state = state.proj()
++    assert state.dims == state_ptraced.dims
++    assert state == state_ptraced
++
++
++@pytest.mark.parametrize(['selection', 'exception'], [
++    pytest.param(4, IndexError, id='too big'),
++    pytest.param(-1, IndexError, id='too small'),
++    pytest.param([0, 0], ValueError, id='duplicate'),
++    # 'too many' may throw either from duplication or invalid index.
++    pytest.param([0, 1, 2, 3], Exception, id='too many'),
++])
++def test_ptrace_fails_on_invalid_input(state, selection, exception):
++    with pytest.raises(exception):
++        state.ptrace(selection)
++
++
++@pytest.mark.parametrize('dims, sel',
++                         [
++                             ([5, 2, 3], [2, 1]),
++                             ([5, 2, 3], [0, 2]),
++                             ([5, 2, 3], [0, 1]),
++                             ([2]*6, [3, 2]),
++                             ([2]*6, [0, 2]),
++                             ([2]*6, [0, 1]),
++                         ])
++def test_ptrace_rand_ket(dtype, dims, sel):
++    A = qutip.rand_ket(dims)
++    assert A.ptrace(sel) == expected(A, sel)
++
++
++@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
++                         ids=['trace_all',
++                              'trace_none',
++                              'trace_one',
++                              'trace_one_2',
++                              'trace_multiple',
++                              'trace_multiple_not_sorted',
++                              ])
++def test_ptrace_rand_dm(dtype, sel):
++    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
++    assert A.ptrace(sel) == expected(A, sel)
++
++
++@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
++                         ids=['trace_all',
++                              'trace_none',
++                              'trace_one',
++                              'trace_one_2',
++                              'trace_multiple',
++                              'trace_multiple_not_sorted',
++                              ])
++def test_ptrace_operator(dtype, sel):
++    A = qutip.tensor(
++        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
++    ).to(dtype)
++    assert A.ptrace(sel) == expected(A, sel)
+diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
+index 85e091b6..9c1aa156 100644
+--- a/qutip/tests/core/test_qobj.py
++++ b/qutip/tests/core/test_qobj.py
+@@ -1,1228 +1,1228 @@
+-import numbers
+-import operator
+-import pytest
+-
+-import numpy as np
+-import scipy.sparse
+-import scipy.linalg
+-
+-import qutip
+-from qutip.core import data as _data
+-
+-
+-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+-def datatype(request):
+-    return request.param
+-
+-
+-def _random_not_singular(N):
+-    """
+-    return a N*N complex array with determinant not 0.
+-    """
+-    data = np.zeros((1, 1))
+-    while np.linalg.det(data) == 0:
+-        data = np.random.random((N, N)) + \
+-               1j * np.random.random((N, N)) - (0.5 + 0.5j)
+-    return data
+-
+-
+-def assert_hermicity(oper, hermicity):
+-    # Check the cached isherm, if any exists.
+-    assert oper.isherm == hermicity
+-    # Force a reset of the cached value for isherm.
+-    oper._isherm = None
+-    # Force a recalculation of isherm.
+-    assert oper.isherm == hermicity
+-
+-
+-def test_QobjData():
+-    "qutip.Qobj data"
+-    N = 10
+-    data1 = _random_not_singular(N)
+-    q1 = qutip.Qobj(data1)
+-    assert isinstance(q1.data, qutip.core.data.Data)
+-    assert np.all(q1.data.to_array() == data1)
+-
+-    data2 = _random_not_singular(N)
+-    data2 = scipy.sparse.csr_matrix(data2)
+-    q2 = qutip.Qobj(data2)
+-    assert isinstance(q2.data, qutip.core.data.Data)
+-
+-
+-@pytest.mark.parametrize("original_data",
+-                         [
+-                            qutip.data.Dense(_random_not_singular(2)),
+-                            qutip.data.csr.identity(2),
+-                            qutip.Qobj(_random_not_singular(2)),
+-                            _random_not_singular(2),
+-                         ],
+-                         ids=[
+-                             "Dense",
+-                             "CSR",
+-                             "Qobj",
+-                             "ndarray",
+-                         ])
+-@pytest.mark.parametrize("copy", [True, False],
+-                         ids=["copy=True", "copy=False"])
+-def test_QobjCopyArgument(original_data, copy):
+-    """Tests that Qobj copy argument works properly when instantiating Qobj."""
+-    qobj_data = qutip.Qobj(original_data, copy=copy).data
+-
+-    if isinstance(original_data, qutip.Qobj):
+-        # Qobj copies the data of another Qobj, so we take `data` if
+-        # original_data was a Qobj
+-        original_data = original_data.data
+-
+-    if isinstance(original_data, np.ndarray):
+-        # For numpy object we compare with data's data. This should be dense so
+-        # we get its data as ndarray.
+-        qobj_data = qobj_data.as_ndarray()
+-
+-        # We look at the memory and see if it is shared or not to asses wether
+-        # copy argument worked or not.
+-        assert np.shares_memory(qobj_data, original_data) != copy
+-
+-    else:
+-        assert (original_data is qobj_data) != copy
+-
+-
+-def test_QobjType():
+-    "qutip.Qobj type"
+-    N = int(np.ceil(10.0 * np.random.random())) + 5
+-
+-    ket_data = np.random.random((N, 1))
+-    ket_qobj = qutip.Qobj(ket_data)
+-    assert ket_qobj.type == 'ket'
+-    assert ket_qobj.isket
+-
+-    bra_data = np.random.random((1, N))
+-    bra_qobj = qutip.Qobj(bra_data)
+-    assert bra_qobj.type == 'bra'
+-    assert bra_qobj.isbra
+-
+-    oper_data = np.random.random((N, N))
+-    oper_qobj = qutip.Qobj(oper_data)
+-    assert oper_qobj.type == 'oper'
+-    assert oper_qobj.isoper
+-
+-    N = 9
+-    super_data = np.random.random((N, N))
+-    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
+-    assert super_qobj.type == 'super'
+-    assert super_qobj.issuper
+-    assert super_qobj.superrep == 'super'
+-
+-    super_data = np.random.random(N)
+-    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
+-    assert super_qobj.type == 'operator-ket'
+-    assert super_qobj.isoperket
+-    assert super_qobj.superrep == 'super'
+-
+-    super_data = np.random.random(N)
+-    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
+-    assert super_qobj.type == 'operator-bra'
+-    assert super_qobj.isoperbra
+-    assert super_qobj.superrep == 'super'
+-
+-    operket_qobj = qutip.operator_to_vector(oper_qobj)
+-    assert operket_qobj.isoperket
+-    assert operket_qobj.dag().isoperbra
+-
+-
+-class TestQobjHermicity:
+-    def test_standard(self):
+-        base = _random_not_singular(10)
+-        assert_hermicity(qutip.Qobj(base), False)
+-        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
+-        assert_hermicity(qutip.destroy(5), False)
+-        assert_hermicity(qutip.create(5), False)
+-
+-    def test_addition(self):
+-        q_a, q_ad = qutip.destroy(5), qutip.create(5)
+-        # test addition of two nonhermitian operators adding up to be hermitian
+-        q_x = q_a + q_ad
+-        assert_hermicity(q_x, True)
+-        # test addition of one hermitan and one nonhermitian operator
+-        assert_hermicity(q_x + q_a, False)
+-        # test addition of two hermitan operators
+-        assert_hermicity(q_x + q_x, True)
+-
+-    def test_multiplication(self):
+-        # Test multiplication of two Hermitian operators.  This results in a
+-        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
+-        # set wrong metadata.
+-        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
+-        # Similarly, we need to check that -Z = X * iY is correctly identified
+-        # as Hermitian.
+-        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
+-
+-
+-def assert_unitarity(oper, unitarity):
+-    # Check the cached isunitary.
+-    assert oper.isunitary == unitarity
+-
+-    # Force a reset of the cached value for isunitary.
+-    oper._isunitary = None
+-    # Force a recalculation of isunitary.
+-    assert oper.isunitary == unitarity
+-
+-
+-def test_QobjUnitaryOper():
+-    "qutip.Qobj unitarity"
+-    # Check some standard operators
+-    Sx = qutip.sigmax()
+-    Sy = qutip.sigmay()
+-    assert_unitarity(qutip.qeye(4), True)
+-    assert_unitarity(Sx, True)
+-    assert_unitarity(Sy, True)
+-    assert_unitarity(qutip.sigmam(), False)
+-    assert_unitarity(qutip.destroy(10), False)
+-    # Check multiplcation of unitary is unitary
+-    assert_unitarity(Sx*Sy, True)
+-    # Check some other operations clear unitarity
+-    assert_unitarity(Sx+Sy, False)
+-    assert_unitarity(4*Sx, False)
+-    assert_unitarity(Sx*4, False)
+-    assert_unitarity(4+Sx, False)
+-    assert_unitarity(Sx+4, False)
+-    # Check that when multipliying scalar numbers with absolute value 1 we
+-    # maintain unitarity.
+-    assert_unitarity(Sx*np.exp(5j), True)
+-    assert_unitarity(Sx*1j, True)
+-    assert_unitarity(Sx*1, True)
+-    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
+-    # We do not know if it is unitary until we check the whole matrix again.
+-    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
+-    # This may be removed in the future as if scalar has abs value of 1 and
+-    # matrix is not unitary, output wont be unitary.
+-    assert (qutip.sigmam()*1)._isunitary == None
+-
+-
+-def test_QobjDimsShape():
+-    "qutip.Qobj shape"
+-    N = 10
+-    data = _random_not_singular(N)
+-
+-    q1 = qutip.Qobj(data)
+-    assert q1.dims == [[10], [10]]
+-    assert q1.shape == (10, 10)
+-
+-    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
+-
+-    q1 = qutip.Qobj(data)
+-    assert q1.dims == [[10], [1]]
+-    assert q1.shape == (10, 1)
+-
+-    data = _random_not_singular(4)
+-
+-    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
+-    assert q1.dims == [[2, 2], [2, 2]]
+-    assert q1.shape == (4, 4)
+-
+-
+-def test_QobjMulNonsquareDims():
+-    """
+-    qutip.Qobj: multiplication w/ non-square qobj.dims
+-
+-    Checks for regression of #331.
+-    """
+-    data = np.array([[0, 1], [1, 0]])
+-
+-    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
+-    q2 = qutip.Qobj(data, dims=[[2], [2]])
+-
+-    assert (q1 * q2).dims == [[2, 1], [2]]
+-    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
+-    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
+-
+-    # Because of the above, we also need to check for extra indices
+-    # that aren't of length 1.
+-    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
+-                     [0.+0.j,  1.+0.j],
+-                     [0.+0.j,  1.+0.j],
+-                     [1.+0.j,  0.+0.j],
+-                     [0.+0.j,  0.-1.j],
+-                     [0.+1.j,  0.+0.j],
+-                     [1.+0.j,  0.+0.j],
+-                     [0.+0.j, -1.+0.j]],
+-                    dims=[[4, 2], [2]])
+-    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
+-
+-
+-def test_QobjAddition():
+-    "qutip.Qobj addition"
+-    data1 = np.array([[1, 2], [3, 4]])
+-    data2 = np.array([[5, 6], [7, 8]])
+-    data3 = data1 + data2
+-
+-    q1 = qutip.Qobj(data1)
+-    q2 = qutip.Qobj(data2)
+-    q3 = qutip.Qobj(data3)
+-
+-    q4 = q1 + q2
+-    q4_type = q4.type
+-    q4_isherm = q4.isherm
+-    q4._type = None
+-    q4._isherm = None  # clear cached values
+-    assert q4_type == q4.type
+-    assert q4_isherm == q4.isherm
+-
+-    # check elementwise addition/subtraction
+-    assert q3 == q4
+-
+-    # check that addition is commutative
+-    assert q1 + q2 == q2 + q1
+-
+-    data = np.random.random((5, 5))
+-    q = qutip.Qobj(data)
+-    x1 = q + 5
+-    x2 = 5 + q
+-    data = data + np.eye(5) * 5
+-    assert np.all(x1.full() == data)
+-    assert np.all(x2.full() == data)
+-
+-
+-def test_QobjSubtraction():
+-    "qutip.Qobj subtraction"
+-    data1 = _random_not_singular(5)
+-    q1 = qutip.Qobj(data1)
+-
+-    data2 = _random_not_singular(5)
+-    q2 = qutip.Qobj(data2)
+-
+-    q3 = q1 - q2
+-    data3 = data1 - data2
+-    assert np.all(q3.full() == data3)
+-
+-    q4 = q2 - q1
+-    data4 = data2 - data1
+-    assert np.all(q4.full() == data4)
+-
+-
+-def test_QobjMultiplication():
+-    "qutip.Qobj multiplication"
+-    data1 = np.array([[1, 2], [3, 4]])
+-    data2 = np.array([[5, 6], [7, 8]])
+-
+-    data3 = np.dot(data1, data2)
+-
+-    q1 = qutip.Qobj(data1)
+-    q2 = qutip.Qobj(data2)
+-    q3 = qutip.Qobj(data3)
+-
+-    q4 = q1 * q2
+-
+-    assert q3 == q4
+-
+-
+-# Allowed mul operations (scalar)
+-@pytest.mark.parametrize("scalar",
+-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+-                         ids=[
+-                             "python_number",
+-                             "scalar_like_array_shape_0",
+-                             "scalar_like_array_shape_1",
+-                         ])
+-def test_QobjMulValidScalar(scalar):
+-    "Tests multiplication of Qobj times scalar."
+-    data = np.array([[1, 2], [3, 4]])
+-    q = qutip.Qobj(data)
+-    expect = data * (2+2j)
+-
+-    # Check __mul__
+-    result = q * scalar
+-    assert np.all(result.full() == expect)
+-
+-    # Check __rmul__
+-    result = scalar * q
+-    assert np.all(result.full() == expect)
+-
+-
+-# We do not allow yet qobj being multiplied by a numpy array that does not
+-# represent a scalar. If we include the feature of numpy broadcasting an qobj
+-# as scalar, this test should be removed.
+-@pytest.mark.parametrize("not_scalar",
+-                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
+-                         ids=[
+-                             "not_scalar_like_vector",
+-                             "not_scalar_like_matrix",
+-                         ])
+-def test_QobjMulNotValidScalar(not_scalar):
+-    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+-
+-    with pytest.raises(TypeError):
+-        not_scalar * q1
+-
+-    with pytest.raises(TypeError):
+-        q1 * not_scalar
+-
+-
+-# Allowed division operations (scalar)
+-@pytest.mark.parametrize("scalar",
+-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+-                         ids=[
+-                             "python_number",
+-                             "scalar_like_array_shape_0",
+-                             "scalar_like_array_shape_1",
+-                         ])
+-def test_QobjDivisionValidScalar(scalar):
+-    "Tests multiplication of Qobj times scalar."
+-    data = np.array([[1, 2], [3, 4]])
+-    q = qutip.Qobj(data)
+-    expect = data / (2+2j)
+-
+-    # Check __truediv__
+-    result = q / scalar
+-    assert np.all(result.full() == expect)
+-
+-
+-# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
+-# non scalar numpy values. This should also be removed in case of implementing
+-# broadcasting rules for Qobj.
+-@pytest.mark.parametrize("not_scalar",
+-                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
+-                         ids=[
+-                             "not_scalar_like_vector",
+-                             "not_scalar_like_matrix",
+-                         ])
+-def test_QobjDivisionNotValidScalar(not_scalar):
+-    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+-
+-    with pytest.raises(TypeError):
+-        q1 / not_scalar
+-
+-
+-def test_QobjNotImplemented():
+-    class MockerScalar():
+-        def __mul__(self, other):
+-            return "object not accepted by _data.mul, mul"
+-
+-        def __rmul__(self, other):
+-            return "object not accepted by _data.mul, rmul"
+-
+-        def __rtruediv__(self, other):
+-            return "object not accepted by _data.mul, rtruediv"
+-
+-    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+-    scalar = MockerScalar()
+-    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
+-    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
+-    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
+-
+-def test_QobjDivision():
+-    "qutip.Qobj division"
+-    data = _random_not_singular(5)
+-    q = qutip.Qobj(data)
+-    randN = 10 * np.random.random()
+-    q = q / randN
+-    assert np.allclose(q.full(), data/randN)
+-
+-
+-def test_QobjPower():
+-    "qutip.Qobj power"
+-    data = _random_not_singular(5)
+-    q = qutip.Qobj(data)
+-    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
+-    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
+-
+-
+-def test_QobjNeg():
+-    "qutip.Qobj negation"
+-    data = _random_not_singular(5)
+-    q = qutip.Qobj(data)
+-    x = -q
+-    assert np.all(x.full() == -data)
+-    assert q.isherm == x.isherm
+-    assert q.type == x.type
+-
+-
+-def test_QobjEquals():
+-    "qutip.Qobj equals"
+-    data = _random_not_singular(5)
+-    q1 = qutip.Qobj(data)
+-    q2 = qutip.Qobj(data)
+-    assert q1 == q2
+-
+-    q1 = qutip.Qobj(data)
+-    q2 = qutip.Qobj(-data)
+-    assert q1 != q2
+-
+-
+-def test_QobjGetItem():
+-    "qutip.Qobj getitem"
+-    data = _random_not_singular(5)
+-    q = qutip.Qobj(data)
+-    assert q[0, 0] == data[0, 0]
+-    assert q[-1, 2] == data[-1, 2]
+-
+-
+-def test_CheckMulType():
+-    "qutip.Qobj multiplication type"
+-    # ket-bra and bra-ket multiplication
+-    psi = qutip.basis(5, 0)
+-    dm = psi * psi.dag()
+-    assert dm.isoper
+-    assert dm.isherm
+-
+-    nrm = psi.dag() * psi
+-    assert isinstance(nrm, numbers.Complex)
+-    assert abs(nrm) == 1
+-
+-    # operator-operator multiplication
+-    H1 = qutip.rand_herm(3)
+-    H2 = qutip.rand_herm(3)
+-    out = H1 * H2
+-    assert out.isoper
+-    out = H1 * H1
+-    assert out.isoper
+-    assert out.isherm
+-    out = H2 * H2
+-    assert out.isoper
+-    assert out.isherm
+-
+-    U = qutip.rand_unitary(5)
+-    out = U.dag() * U
+-    assert out.isoper
+-    assert out.isherm
+-
+-    N = qutip.num(5)
+-
+-    out = N * N
+-    assert out.isoper
+-    assert out.isherm
+-
+-    # operator-ket and bra-operator multiplication
+-    op = qutip.sigmax()
+-    ket1 = qutip.basis(2, 0)
+-    ket2 = op * ket1
+-    assert ket2.isket
+-
+-    bra1 = qutip.basis(2, 0).dag()
+-    bra2 = bra1 * op
+-    assert bra2.isbra
+-
+-    assert bra2.dag() == ket2
+-
+-    # superoperator-operket and operbra-superoperator multiplication
+-    sop = qutip.to_super(qutip.sigmax())
+-    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
+-    opket2 = sop * opket1
+-    assert opket2.isoperket
+-
+-    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
+-    opbra2 = opbra1 * sop
+-    assert opbra2.isoperbra
+-
+-    assert opbra2.dag() == opket2
+-
+-
+-def test_operator_ket_superrep():
+-    sop = qutip.to_super(qutip.sigmax())
+-    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
+-    opket2 = sop * opket1
+-    assert opket1.superrep == opket2.superrep
+-
+-    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
+-    opbra2 = opbra1 * sop
+-    assert opbra1.superrep == opbra2.superrep
+-
+-
+-def test_QobjConjugate():
+-    "qutip.Qobj conjugate"
+-    data = _random_not_singular(5)
+-    A = qutip.Qobj(data)
+-    B = A.conj()
+-    assert np.all(B.full() == data.conj())
+-    assert A.isherm == B.isherm
+-    assert A.type == B.type
+-    assert A.superrep == B.superrep
+-
+-
+-def test_QobjDagger():
+-    "qutip.Qobj adjoint (dagger)"
+-    data = _random_not_singular(5)
+-    A = qutip.Qobj(data)
+-    B = A.dag()
+-    assert np.all(B.full() == data.conj().T)
+-    assert A.isherm == B.isherm
+-    assert A.type == B.type
+-    assert A.superrep == B.superrep
+-
+-
+-def test_QobjDiagonals():
+-    "qutip.Qobj diagonals"
+-    data = _random_not_singular(5)
+-    A = qutip.Qobj(data)
+-    b = A.diag()
+-    assert np.all(b == np.diag(data))
+-
+-
+-def test_QobjEigenEnergies():
+-    "qutip.Qobj eigenenergies"
+-    data = np.eye(5)
+-    A = qutip.Qobj(data)
+-    b = A.eigenenergies()
+-    assert np.all(b == np.ones(5))
+-
+-    data = np.diag(np.arange(10))
+-    A = qutip.Qobj(data)
+-    b = A.eigenenergies()
+-    assert np.all(b == np.arange(10))
+-
+-    data = np.diag(np.arange(10))
+-    A = 5 * qutip.Qobj(data)
+-    b = A.eigenenergies()
+-    assert np.all(b == 5*np.arange(10))
+-
+-
+-def test_QobjEigenStates():
+-    "qutip.Qobj eigenstates"
+-    data = np.eye(5)
+-    A = qutip.Qobj(data)
+-    b, c = A.eigenstates()
+-    assert np.all(b == np.ones(5))
+-    kets = [qutip.basis(5, k) for k in range(5)]
+-    for k in range(5):
+-        assert c[k] == kets[k]
+-
+-
+-def test_QobjExpm():
+-    "qutip.Qobj expm (dense)"
+-    data = _random_not_singular(15)
+-    A = qutip.Qobj(data)
+-    B = A.expm()
+-    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
+-
+-
+-def test_QobjExpmExplicitlySparse():
+-    "qutip.Qobj expm (sparse)"
+-    data = _random_not_singular(15)
+-    A = qutip.Qobj(data)
+-    B = A.expm(dtype=qutip.data.CSR)
+-    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
+-
+-
+-def test_QobjExpmZeroOper():
+-    "qutip.Qobj expm zero_oper (#493)"
+-    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
+-    B = A.expm()
+-    assert B == qutip.qeye(5)
+-
+-
+-def test_QobjLogm():
+-    "qutip.Qobj expm (dense)"
+-    data = _random_not_singular(15)
+-    A = qutip.Qobj(data)
+-    B = A.logm()
+-    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
+-
+-
+-def test_QobjLogmExplicitlySparse():
+-    "qutip.Qobj logm (sparse)"
+-    data = _random_not_singular(15)
+-    A = qutip.Qobj(data).to("csr")
+-    B = A.logm()
+-    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
+-
+-
+-def test_QobjLogmZeroOper():
+-    "qutip.Qobj logm zero_oper (#493)"
+-    A = qutip.qeye(5)
+-    B = A.logm()
+-    assert B == qutip.qzero(5)
+-
+-
+-def test_Qobj_sqrtm():
+-    "qutip.Qobj sqrtm"
+-    data = _random_not_singular(5)
+-    A = qutip.Qobj(data)
+-    B = A.sqrtm()
+-    assert A == B * B
+-
+-
+-def test_Qobj_inv():
+-    "qutip.Qobj inv"
+-    data = _random_not_singular(5)
+-    A = qutip.Qobj(data)
+-    B = A.inv()
+-    assert qutip.qeye(5) == A * B
+-    assert qutip.qeye(5) == B * A
+-    B = A.inv(sparse=True)
+-    assert qutip.qeye(5) == A * B
+-    assert qutip.qeye(5) == B * A
+-
+-
+-def test_QobjFull():
+-    "qutip.Qobj full"
+-    data = _random_not_singular(15)
+-    A = qutip.Qobj(data)
+-    b = A.full()
+-    assert np.all(b == data)
+-
+-
+-def test_QobjNorm():
+-    "qutip.Qobj norm"
+-    # vector L2-norm test
+-    N = 20
+-    x = np.random.random(N) + 1j*np.random.random(N)
+-    A = qutip.Qobj(x)
+-    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
+-    # vector max (inf) norm test
+-    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
+-                               atol=1e-12)
+-    # operator frobius norm
+-    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
+-    A = qutip.Qobj(x)
+-    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
+-                               atol=1e-12)
+-    # operator trace norm
+-    a = qutip.rand_herm(10, density=0.25)
+-    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
+-    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
+-    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
+-
+-
+-def test_QobjPurity():
+-    "Tests the purity method of `qutip.Qobj`"
+-    psi = qutip.basis(2, 1)
+-    # check purity of pure ket state
+-    np.testing.assert_allclose(psi.purity(), 1)
+-    # check purity of pure ket state (superposition)
+-    psi2 = qutip.basis(2, 0)
+-    psi_tot = (psi+psi2).unit()
+-    np.testing.assert_allclose(psi_tot.purity(), 1)
+-    # check purity of density matrix of pure state
+-    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
+-    # check purity of maximally mixed density matrix
+-    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
+-    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
+-
+-
+-def test_QobjPermute(datatype):
+-    "qutip.Qobj permute"
+-    A = qutip.basis(3, 0, dtype=datatype)
+-    B = qutip.basis(5, 4, dtype=datatype)
+-    C = qutip.basis(4, 2, dtype=datatype)
+-    psi = qutip.tensor(A, B, C)
+-    psi2 = psi.permute([2, 0, 1])
+-    assert psi2 == qutip.tensor(C, A, B)
+-
+-    psi_bra = psi.dag()
+-    psi2_bra = psi_bra.permute([2, 0, 1])
+-    assert psi2_bra == qutip.tensor(C, A, B).dag()
+-
+-    A = qutip.fock_dm(3, 0, dtype=datatype)
+-    B = qutip.fock_dm(5, 4, dtype=datatype)
+-    C = qutip.fock_dm(4, 2, dtype=datatype)
+-    rho = qutip.tensor(A, B, C)
+-    rho2 = rho.permute([2, 0, 1])
+-    assert rho2 == qutip.tensor(C, A, B)
+-
+-    for _ in range(3):
+-        A = qutip.rand_ket(3, dtype=datatype)
+-        B = qutip.rand_ket(4, dtype=datatype)
+-        C = qutip.rand_ket(5, dtype=datatype)
+-        psi = qutip.tensor(A, B, C)
+-        psi2 = psi.permute([1, 0, 2])
+-        assert psi2 == qutip.tensor(B, A, C)
+-
+-        psi_bra = psi.dag()
+-        psi2_bra = psi_bra.permute([1, 0, 2])
+-        assert psi2_bra == qutip.tensor(B, A, C).dag()
+-
+-    for _ in range(3):
+-        A = qutip.rand_dm(3, dtype=datatype)
+-        B = qutip.rand_dm(4, dtype=datatype)
+-        C = qutip.rand_dm(5, dtype=datatype)
+-        rho = qutip.tensor(A, B, C)
+-        rho2 = rho.permute([1, 0, 2])
+-        assert rho2 == qutip.tensor(B, A, C)
+-
+-        rho_vec = qutip.operator_to_vector(rho)
+-        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
+-        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
+-
+-        rho_vec_bra = qutip.operator_to_vector(rho).dag()
+-        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
+-        assert (rho2_vec_bra
+-                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
+-
+-    for _ in range(3):
+-        super_dims = [3, 5, 4]
+-        U = qutip.rand_unitary(super_dims, dtype=datatype)
+-        Unew = U.permute([2, 1, 0])
+-        S_tens = qutip.to_super(U)
+-        S_tens_new = qutip.to_super(Unew)
+-        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
+-
+-
+-def test_KetType():
+-    "qutip.Qobj ket type"
+-
+-    psi = qutip.basis(2, 1)
+-
+-    assert psi.isket
+-    assert not psi.isbra
+-    assert not psi.isoper
+-    assert not psi.issuper
+-
+-    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
+-
+-    assert psi.isket
+-    assert not psi.isbra
+-    assert not psi.isoper
+-    assert not psi.issuper
+-
+-
+-def test_BraType():
+-    "qutip.Qobj bra type"
+-
+-    psi = qutip.basis(2, 1).dag()
+-    assert not psi.isket
+-    assert psi.isbra
+-    assert not psi.isoper
+-    assert not psi.issuper
+-
+-    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
+-    assert not psi.isket
+-    assert psi.isbra
+-    assert not psi.isoper
+-    assert not psi.issuper
+-
+-
+-def test_OperType():
+-    "qutip.Qobj operator type"
+-
+-    psi = qutip.basis(2, 1)
+-    rho = psi * psi.dag()
+-
+-    assert not rho.isket
+-    assert not rho.isbra
+-    assert rho.isoper
+-    assert not rho.issuper
+-
+-
+-def test_SuperType():
+-    "qutip.Qobj superoperator type"
+-
+-    psi = qutip.basis(2, 1)
+-    rho = psi * psi.dag()
+-
+-    sop = qutip.spre(rho)
+-
+-    assert not sop.isket
+-    assert not sop.isbra
+-    assert not sop.isoper
+-    assert sop.issuper
+-
+-    sop = qutip.spost(rho)
+-
+-    assert not sop.isket
+-    assert not sop.isbra
+-    assert not sop.isoper
+-    assert sop.issuper
+-
+-
+-@pytest.mark.parametrize("dimension", [2, 4, 8])
+-@pytest.mark.parametrize("conversion", [
+-    pytest.param(qutip.to_super, id='to_super'),
+-    pytest.param(qutip.to_choi, id='to_choi'),
+-    pytest.param(qutip.to_chi, id='to_chi'),
+-])
+-def test_dag_preserves_superrep(dimension, conversion):
+-    """
+-    Checks that dag() preserves superrep.
+-    """
+-    qobj = conversion(qutip.rand_super_bcsz(dimension))
+-    assert qobj.superrep == qobj.dag().superrep
+-
+-
+-@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
+-@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
+-    pytest.param(operator.add, True, True, id='add'),
+-    pytest.param(operator.sub, True, True, id='sub'),
+-    pytest.param(operator.mul, True, True, id='mul'),
+-    pytest.param(operator.truediv, False, True, id='div'),
+-    pytest.param(qutip.tensor, True, False, id='tensor'),
+-])
+-def test_arithmetic_preserves_superrep(superrep,
+-                                       operation, check_op, check_scalar):
+-    """
+-    Checks that binary ops preserve 'superrep'.
+-
+-    .. note::
+-
+-        The random superoperators are not chosen in a way that reflects the
+-        structure of that superrep, but are simply random matrices.
+-    """
+-    dims = [[[2], [2]], [[2], [2]]]
+-    shape = (4, 4)
+-    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
+-    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
+-    x = np.random.random()
+-
+-    check_list = []
+-    if check_op:
+-        check_list.append(operation(S1, S2))
+-    if check_scalar:
+-        check_list.append(operation(S1, x))
+-    if check_op and check_scalar:
+-        check_list.append(operation(x, S2))
+-
+-    for S in check_list:
+-        assert S.issuper
+-        assert S.type == "super"
+-        assert S.superrep == superrep
+-
+-
+-def test_isherm_skew():
+-    """
+-    mul and tensor of skew-Hermitian operators report ``isherm = True``.
+-    """
+-    iH = 1j * qutip.rand_herm(5)
+-    assert_hermicity(iH, False)
+-    assert_hermicity(iH * iH, True)
+-    assert_hermicity(qutip.tensor(iH, iH), True)
+-
+-
+-def test_super_tensor_operket():
+-    """
+-    Tensor: Checks that super_tensor respects states.
+-    """
+-    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
+-    qutip.operator_to_vector(rho1)
+-    qutip.operator_to_vector(rho2)
+-
+-
+-def test_super_tensor_property():
+-    """
+-    Tensor: Super_tensor correctly tensors on underlying spaces.
+-    """
+-    U1 = qutip.rand_unitary(3)
+-    U2 = qutip.rand_unitary(5)
+-    U = qutip.tensor(U1, U2)
+-    S_tens = qutip.to_super(U)
+-    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
+-    assert S_tens == S_supertens
+-    assert S_supertens.superrep == 'super'
+-
+-
+-def test_composite_oper():
+-    """
+-    Composite: Tests compositing unitaries and superoperators.
+-    """
+-    U1 = qutip.rand_unitary(3)
+-    U2 = qutip.rand_unitary(5)
+-    S1 = qutip.to_super(U1)
+-    S2 = qutip.to_super(U2)
+-    S3 = qutip.rand_super(4)
+-    S4 = qutip.rand_super(7)
+-
+-    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
+-    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
+-    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
+-    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
+-
+-
+-def test_composite_vec():
+-    """
+-    Composite: Tests compositing states and density operators.
+-    """
+-    k1 = qutip.rand_ket(5)
+-    k2 = qutip.rand_ket(7)
+-    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
+-    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
+-
+-    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
+-    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
+-
+-    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
+-    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
+-    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
+-    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
+-
+-# TODO: move out to a more appropriate module.
+-
+-
+-def trunc_neg_case(qobj, method, expected=None):
+-    pos_qobj = qobj.trunc_neg(method=method)
+-    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
+-    np.testing.assert_allclose(pos_qobj.tr(), 1)
+-    if expected is not None:
+-        test_array = pos_qobj.full()
+-        exp_array = expected.full()
+-        np.testing.assert_allclose(test_array, exp_array)
+-
+-
+-class TestTruncNeg:
+-    """Test qutip.Qobj.trunc_neg for several different cases."""
+-    def test_positive_operator(self):
+-        trunc_neg_case(qutip.rand_dm(5), 'clip')
+-        trunc_neg_case(qutip.rand_dm(5), 'sgs')
+-
+-    def test_diagonal_operator(self):
+-        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
+-        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
+-        trunc_neg_case(to_test, 'clip', expected)
+-        trunc_neg_case(to_test, 'sgs', expected)
+-
+-    def test_nondiagonal_operator(self):
+-        U = qutip.rand_unitary(3)
+-        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
+-        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
+-        trunc_neg_case(to_test, 'clip', expected)
+-        trunc_neg_case(to_test, 'sgs', expected)
+-
+-    def test_sgs_known_good(self):
+-        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
+-                       'sgs',
+-                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
+-
+-
+-def test_cosm():
+-    """
+-    Test qutip.Qobj: cosm
+-    """
+-    A = qutip.rand_herm(5)
+-    B = A.cosm().full()
+-    C = scipy.linalg.cosm(A.full())
+-    np.testing.assert_allclose(B, C, atol=1e-14)
+-
+-
+-def test_sinm():
+-    """
+-    Test qutip.Qobj: sinm
+-    """
+-    A = qutip.rand_herm(5)
+-    B = A.sinm().full()
+-    C = scipy.linalg.sinm(A.full())
+-    np.testing.assert_allclose(B, C, atol=1e-14)
+-
+-
+-@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
+-def test_dual_channel(sub_dimensions, n_trials=50):
+-    """
+-    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
+-    """
+-    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
+-    S.dims = [[sub_dimensions, sub_dimensions],
+-              [sub_dimensions, sub_dimensions]]
+-    S = qutip.to_super(S)
+-    left_dims, right_dims = S.dims
+-
+-    # Assume for the purposes of the test that S maps square operators to
+-    # square operators.
+-    in_dim = np.prod(right_dims[0])
+-    out_dim = np.prod(left_dims[0])
+-
+-    S_dual = qutip.to_super(S.dual_chan())
+-
+-    primals = []
+-    duals = []
+-
+-    for _ in [None]*n_trials:
+-        X = qutip.rand_dm(out_dim)
+-        X.dims = left_dims
+-        X = qutip.operator_to_vector(X)
+-        Y = qutip.rand_dm(in_dim)
+-        Y.dims = right_dims
+-        Y = qutip.operator_to_vector(Y)
+-
+-        primals.append(X.dag() * S * Y)
+-        duals.append(X.dag() * S_dual.dag() * Y)
+-
+-    np.testing.assert_allclose(primals, duals)
+-
+-
+-def test_call():
+-    """
+-    Test qutip.Qobj: Call
+-    """
+-    # Make test objects.
+-    psi = qutip.rand_ket(3)
+-    rho = qutip.rand_dm(3)
+-    U = qutip.rand_unitary(3)
+-    S = qutip.rand_super_bcsz(3)
+-
+-    # Case 0: oper(ket).
+-    assert U(psi) == U * psi
+-    # Case 1: oper(oper). Should raise TypeError.
+-    with pytest.raises(TypeError):
+-        U(rho)
+-    # Case 2: super(ket).
+-    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
+-    assert S(psi) == expected
+-    # Case 3: super(oper).
+-    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
+-    assert S(rho) == expected
+-    # Case 4: super(super). Should raise TypeError.
+-    with pytest.raises(TypeError):
+-        S(S)
+-
+-
+-def test_mat_elem():
+-    """
+-    Test qutip.Qobj: Compute matrix elements
+-    """
+-    for _ in range(10):
+-        N = 20
+-        H = qutip.rand_herm(N, density=0.2)
+-        L = qutip.rand_ket(N, density=0.3)
+-        Ld = L.dag()
+-        R = qutip.rand_ket(N, density=0.3)
+-        ans = Ld * H * R
+-        # bra-ket
+-        out1 = H.matrix_element(Ld, R)
+-        # ket-ket
+-        out2 = H.matrix_element(Ld, R)
+-        assert abs(ans - out1) < 1e-14
+-        assert abs(ans - out2) < 1e-14
+-
+-
+-def test_projection():
+-    """
+-    Test qutip.Qobj: Projection operator
+-    """
+-    for _ in range(10):
+-        N = 5
+-        K = qutip.rand_ket([N, N], density=0.75)
+-        B = K.dag()
+-        ans = K * K.dag()
+-        out1 = K.proj()
+-        out2 = B.proj()
+-        assert out1 == ans
+-        assert out2 == ans
+-
+-
+-def test_overlap():
+-    """
+-    Test qutip.Qobj: Overlap (inner product)
+-    """
+-    for _ in range(10):
+-        N = 10
+-        A = qutip.rand_ket(N, density=0.75)
+-        Ad = A.dag()
+-        B = qutip.rand_ket(N, density=0.75)
+-        Bd = B.dag()
+-        ans = A.dag() * B
+-        np.testing.assert_allclose(A.overlap(B), ans)
+-        np.testing.assert_allclose(Ad.overlap(B), ans)
+-        np.testing.assert_allclose(Ad.overlap(Bd), ans)
+-        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
+-
+-
+-def test_unit():
+-    """
+-    Test qutip.Qobj: unit
+-    """
+-    psi = (10*np.random.randn()*qutip.basis(2, 0)
+-           - 10j*np.random.randn()*qutip.basis(2, 1))
+-    psi2 = psi.unit()
+-    psi.unit(inplace=True)
+-    assert psi == psi2
+-    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
+-
+-
+-def test_trace():
+-    sz = qutip.sigmaz()
+-    assert sz.tr() == 0
+-
+-
+-def test_no_real_attribute(monkeypatch):
+-    """This tests ensures that trace still works even if the output of a
+-    specialisation does not have the ``real`` attribute. This is the case for
+-    the tensorflow and cupy data layers."""
+-
+-    def mocker_trace_return(oper):
+-        """
+-        We simply return a string which does not have the `real` attribute.
+-        """
+-        return "object without .real"
+-
+-    monkeypatch.setattr(_data, "trace", mocker_trace_return)
+-
+-    sz = qutip.sigmaz() # the choice of the matrix does not matter
+-    assert "object without .real" == sz.tr()
+-
+-
+-@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
+-@pytest.mark.parametrize(['expanded', 'contracted'], [
+-    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
+-    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
+-    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
+-    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
+-    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
+-                 id='mixed'),
+-    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
+-                 id='mixed,unchanged'),
+-    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
+-                 id='mixed,unchanged'),
+-    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
+-    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
+-    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
+-                 id='ket,unchanged'),
+-    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
+-    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
+-    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
+-                 id='bra,unchanged'),
+-    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
+-                 id='operket'),
+-    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
+-                 id='operbra'),
+-])
+-def test_contract(expanded, contracted, inplace):
+-    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
+-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+-    qobj = qutip.Qobj(data, dims=expanded)
+-    assert qobj.dims == expanded
+-    out = qobj.contract(inplace=inplace)
+-    if inplace:
+-        assert out is qobj
+-    else:
+-        assert out is not qobj
+-    assert out.dims == contracted
+-    assert out.shape == qobj.shape
+-    assert np.all(out.full() == qobj.full())
+-
+-
+-@pytest.mark.parametrize(["shape"], [
+-    pytest.param((5, 1), id='ket'),
+-    pytest.param((5, 2), id='tall'),
+-    pytest.param((1, 5), id='bra'),
+-    pytest.param((2, 5), id='wide'),
+-    pytest.param((3, 3), id='oper'),
+-])
+-def test_sum_zero(shape):
+-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+-    qobj = qutip.Qobj(data)
+-    assert qobj + 0 == qobj
+-    assert qobj - 0 == qobj
+-    assert 0 + qobj == qobj
+-    assert 0 - qobj == -qobj
+-
+-
+-@pytest.mark.parametrize(["shape"], [
+-    pytest.param((5, 1), id='ket'),
+-    pytest.param((5, 2), id='tall'),
+-    pytest.param((1, 5), id='bra'),
+-    pytest.param((2, 5), id='wide'),
+-    pytest.param((3, 3), id='oper'),
+-])
+-def test_sum_buildin(shape):
+-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+-    qobj = qutip.Qobj(data)
+-    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
+-
+-
+-def test_groundstate():
+-    eigenvals = np.sort(np.random.rand(10))
+-    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
+-    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
+-    groundenergy, groundstate = qobj.groundstate()
+-    assert groundenergy == pytest.approx(eigenvals[0])
+-    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
+-    assert groundstate.overlap(groundstate) == pytest.approx(1)
+-
+-    with pytest.warns(UserWarning) as warning:
+-        qutip.qeye(5).groundstate()
+-    assert "degenerate" in warning[0].message.args[0]
++import numbers
++import operator
++import pytest
++
++import numpy as np
++import scipy.sparse
++import scipy.linalg
++
++import qutip
++from qutip.core import data as _data
++
++
++@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
++def datatype(request):
++    return request.param
++
++
++def _random_not_singular(N):
++    """
++    return a N*N complex array with determinant not 0.
++    """
++    data = np.zeros((1, 1))
++    while np.linalg.det(data) == 0:
++        data = np.random.random((N, N)) + \
++               1j * np.random.random((N, N)) - (0.5 + 0.5j)
++    return data
++
++
++def assert_hermicity(oper, hermicity):
++    # Check the cached isherm, if any exists.
++    assert oper.isherm == hermicity
++    # Force a reset of the cached value for isherm.
++    oper._isherm = None
++    # Force a recalculation of isherm.
++    assert oper.isherm == hermicity
++
++
++def test_QobjData():
++    "qutip.Qobj data"
++    N = 10
++    data1 = _random_not_singular(N)
++    q1 = qutip.Qobj(data1)
++    assert isinstance(q1.data, qutip.core.data.Data)
++    assert np.all(q1.data.to_array() == data1)
++
++    data2 = _random_not_singular(N)
++    data2 = scipy.sparse.csr_matrix(data2)
++    q2 = qutip.Qobj(data2)
++    assert isinstance(q2.data, qutip.core.data.Data)
++
++
++@pytest.mark.parametrize("original_data",
++                         [
++                            qutip.data.Dense(_random_not_singular(2)),
++                            qutip.data.csr.identity(2),
++                            qutip.Qobj(_random_not_singular(2)),
++                            _random_not_singular(2),
++                         ],
++                         ids=[
++                             "Dense",
++                             "CSR",
++                             "Qobj",
++                             "ndarray",
++                         ])
++@pytest.mark.parametrize("copy", [True, False],
++                         ids=["copy=True", "copy=False"])
++def test_QobjCopyArgument(original_data, copy):
++    """Tests that Qobj copy argument works properly when instantiating Qobj."""
++    qobj_data = qutip.Qobj(original_data, copy=copy).data
++
++    if isinstance(original_data, qutip.Qobj):
++        # Qobj copies the data of another Qobj, so we take `data` if
++        # original_data was a Qobj
++        original_data = original_data.data
++
++    if isinstance(original_data, np.ndarray):
++        # For numpy object we compare with data's data. This should be dense so
++        # we get its data as ndarray.
++        qobj_data = qobj_data.as_ndarray()
++
++        # We look at the memory and see if it is shared or not to asses wether
++        # copy argument worked or not.
++        assert np.shares_memory(qobj_data, original_data) != copy
++
++    else:
++        assert (original_data is qobj_data) != copy
++
++
++def test_QobjType():
++    "qutip.Qobj type"
++    N = int(np.ceil(10.0 * np.random.random())) + 5
++
++    ket_data = np.random.random((N, 1))
++    ket_qobj = qutip.Qobj(ket_data)
++    assert ket_qobj.type == 'ket'
++    assert ket_qobj.isket
++
++    bra_data = np.random.random((1, N))
++    bra_qobj = qutip.Qobj(bra_data)
++    assert bra_qobj.type == 'bra'
++    assert bra_qobj.isbra
++
++    oper_data = np.random.random((N, N))
++    oper_qobj = qutip.Qobj(oper_data)
++    assert oper_qobj.type == 'oper'
++    assert oper_qobj.isoper
++
++    N = 9
++    super_data = np.random.random((N, N))
++    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
++    assert super_qobj.type == 'super'
++    assert super_qobj.issuper
++    assert super_qobj.superrep == 'super'
++
++    super_data = np.random.random(N)
++    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
++    assert super_qobj.type == 'operator-ket'
++    assert super_qobj.isoperket
++    assert super_qobj.superrep == 'super'
++
++    super_data = np.random.random(N)
++    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
++    assert super_qobj.type == 'operator-bra'
++    assert super_qobj.isoperbra
++    assert super_qobj.superrep == 'super'
++
++    operket_qobj = qutip.operator_to_vector(oper_qobj)
++    assert operket_qobj.isoperket
++    assert operket_qobj.dag().isoperbra
++
++
++class TestQobjHermicity:
++    def test_standard(self):
++        base = _random_not_singular(10)
++        assert_hermicity(qutip.Qobj(base), False)
++        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
++        assert_hermicity(qutip.destroy(5), False)
++        assert_hermicity(qutip.create(5), False)
++
++    def test_addition(self):
++        q_a, q_ad = qutip.destroy(5), qutip.create(5)
++        # test addition of two nonhermitian operators adding up to be hermitian
++        q_x = q_a + q_ad
++        assert_hermicity(q_x, True)
++        # test addition of one hermitan and one nonhermitian operator
++        assert_hermicity(q_x + q_a, False)
++        # test addition of two hermitan operators
++        assert_hermicity(q_x + q_x, True)
++
++    def test_multiplication(self):
++        # Test multiplication of two Hermitian operators.  This results in a
++        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
++        # set wrong metadata.
++        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
++        # Similarly, we need to check that -Z = X * iY is correctly identified
++        # as Hermitian.
++        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
++
++
++def assert_unitarity(oper, unitarity):
++    # Check the cached isunitary.
++    assert oper.isunitary == unitarity
++
++    # Force a reset of the cached value for isunitary.
++    oper._isunitary = None
++    # Force a recalculation of isunitary.
++    assert oper.isunitary == unitarity
++
++
++def test_QobjUnitaryOper():
++    "qutip.Qobj unitarity"
++    # Check some standard operators
++    Sx = qutip.sigmax()
++    Sy = qutip.sigmay()
++    assert_unitarity(qutip.qeye(4), True)
++    assert_unitarity(Sx, True)
++    assert_unitarity(Sy, True)
++    assert_unitarity(qutip.sigmam(), False)
++    assert_unitarity(qutip.destroy(10), False)
++    # Check multiplcation of unitary is unitary
++    assert_unitarity(Sx*Sy, True)
++    # Check some other operations clear unitarity
++    assert_unitarity(Sx+Sy, False)
++    assert_unitarity(4*Sx, False)
++    assert_unitarity(Sx*4, False)
++    assert_unitarity(4+Sx, False)
++    assert_unitarity(Sx+4, False)
++    # Check that when multipliying scalar numbers with absolute value 1 we
++    # maintain unitarity.
++    assert_unitarity(Sx*np.exp(5j), True)
++    assert_unitarity(Sx*1j, True)
++    assert_unitarity(Sx*1, True)
++    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
++    # We do not know if it is unitary until we check the whole matrix again.
++    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
++    # This may be removed in the future as if scalar has abs value of 1 and
++    # matrix is not unitary, output wont be unitary.
++    assert (qutip.sigmam()*1)._isunitary == None
++
++
++def test_QobjDimsShape():
++    "qutip.Qobj shape"
++    N = 10
++    data = _random_not_singular(N)
++
++    q1 = qutip.Qobj(data)
++    assert q1.dims == [[10], [10]]
++    assert q1.shape == (10, 10)
++
++    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
++
++    q1 = qutip.Qobj(data)
++    assert q1.dims == [[10], [1]]
++    assert q1.shape == (10, 1)
++
++    data = _random_not_singular(4)
++
++    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
++    assert q1.dims == [[2, 2], [2, 2]]
++    assert q1.shape == (4, 4)
++
++
++def test_QobjMulNonsquareDims():
++    """
++    qutip.Qobj: multiplication w/ non-square qobj.dims
++
++    Checks for regression of #331.
++    """
++    data = np.array([[0, 1], [1, 0]])
++
++    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
++    q2 = qutip.Qobj(data, dims=[[2], [2]])
++
++    assert (q1 * q2).dims == [[2, 1], [2]]
++    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
++    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
++
++    # Because of the above, we also need to check for extra indices
++    # that aren't of length 1.
++    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
++                     [0.+0.j,  1.+0.j],
++                     [0.+0.j,  1.+0.j],
++                     [1.+0.j,  0.+0.j],
++                     [0.+0.j,  0.-1.j],
++                     [0.+1.j,  0.+0.j],
++                     [1.+0.j,  0.+0.j],
++                     [0.+0.j, -1.+0.j]],
++                    dims=[[4, 2], [2]])
++    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
++
++
++def test_QobjAddition():
++    "qutip.Qobj addition"
++    data1 = np.array([[1, 2], [3, 4]])
++    data2 = np.array([[5, 6], [7, 8]])
++    data3 = data1 + data2
++
++    q1 = qutip.Qobj(data1)
++    q2 = qutip.Qobj(data2)
++    q3 = qutip.Qobj(data3)
++
++    q4 = q1 + q2
++    q4_type = q4.type
++    q4_isherm = q4.isherm
++    q4._type = None
++    q4._isherm = None  # clear cached values
++    assert q4_type == q4.type
++    assert q4_isherm == q4.isherm
++
++    # check elementwise addition/subtraction
++    assert q3 == q4
++
++    # check that addition is commutative
++    assert q1 + q2 == q2 + q1
++
++    data = np.random.random((5, 5))
++    q = qutip.Qobj(data)
++    x1 = q + 5
++    x2 = 5 + q
++    data = data + np.eye(5) * 5
++    assert np.all(x1.full() == data)
++    assert np.all(x2.full() == data)
++
++
++def test_QobjSubtraction():
++    "qutip.Qobj subtraction"
++    data1 = _random_not_singular(5)
++    q1 = qutip.Qobj(data1)
++
++    data2 = _random_not_singular(5)
++    q2 = qutip.Qobj(data2)
++
++    q3 = q1 - q2
++    data3 = data1 - data2
++    assert np.all(q3.full() == data3)
++
++    q4 = q2 - q1
++    data4 = data2 - data1
++    assert np.all(q4.full() == data4)
++
++
++def test_QobjMultiplication():
++    "qutip.Qobj multiplication"
++    data1 = np.array([[1, 2], [3, 4]])
++    data2 = np.array([[5, 6], [7, 8]])
++
++    data3 = np.dot(data1, data2)
++
++    q1 = qutip.Qobj(data1)
++    q2 = qutip.Qobj(data2)
++    q3 = qutip.Qobj(data3)
++
++    q4 = q1 * q2
++
++    assert q3 == q4
++
++
++# Allowed mul operations (scalar)
++@pytest.mark.parametrize("scalar",
++                         [2+2j,  np.array(2+2j), np.array([2+2j])],
++                         ids=[
++                             "python_number",
++                             "scalar_like_array_shape_0",
++                             "scalar_like_array_shape_1",
++                         ])
++def test_QobjMulValidScalar(scalar):
++    "Tests multiplication of Qobj times scalar."
++    data = np.array([[1, 2], [3, 4]])
++    q = qutip.Qobj(data)
++    expect = data * (2+2j)
++
++    # Check __mul__
++    result = q * scalar
++    assert np.all(result.full() == expect)
++
++    # Check __rmul__
++    result = scalar * q
++    assert np.all(result.full() == expect)
++
++
++# We do not allow yet qobj being multiplied by a numpy array that does not
++# represent a scalar. If we include the feature of numpy broadcasting an qobj
++# as scalar, this test should be removed.
++@pytest.mark.parametrize("not_scalar",
++                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
++                         ids=[
++                             "not_scalar_like_vector",
++                             "not_scalar_like_matrix",
++                         ])
++def test_QobjMulNotValidScalar(not_scalar):
++    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
++
++    with pytest.raises(TypeError):
++        not_scalar * q1
++
++    with pytest.raises(TypeError):
++        q1 * not_scalar
++
++
++# Allowed division operations (scalar)
++@pytest.mark.parametrize("scalar",
++                         [2+2j,  np.array(2+2j), np.array([2+2j])],
++                         ids=[
++                             "python_number",
++                             "scalar_like_array_shape_0",
++                             "scalar_like_array_shape_1",
++                         ])
++def test_QobjDivisionValidScalar(scalar):
++    "Tests multiplication of Qobj times scalar."
++    data = np.array([[1, 2], [3, 4]])
++    q = qutip.Qobj(data)
++    expect = data / (2+2j)
++
++    # Check __truediv__
++    result = q / scalar
++    assert np.all(result.full() == expect)
++
++
++# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
++# non scalar numpy values. This should also be removed in case of implementing
++# broadcasting rules for Qobj.
++@pytest.mark.parametrize("not_scalar",
++                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
++                         ids=[
++                             "not_scalar_like_vector",
++                             "not_scalar_like_matrix",
++                         ])
++def test_QobjDivisionNotValidScalar(not_scalar):
++    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
++
++    with pytest.raises(TypeError):
++        q1 / not_scalar
++
++
++def test_QobjNotImplemented():
++    class MockerScalar():
++        def __mul__(self, other):
++            return "object not accepted by _data.mul, mul"
++
++        def __rmul__(self, other):
++            return "object not accepted by _data.mul, rmul"
++
++        def __rtruediv__(self, other):
++            return "object not accepted by _data.mul, rtruediv"
++
++    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
++    scalar = MockerScalar()
++    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
++    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
++    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
++
++def test_QobjDivision():
++    "qutip.Qobj division"
++    data = _random_not_singular(5)
++    q = qutip.Qobj(data)
++    randN = 10 * np.random.random()
++    q = q / randN
++    assert np.allclose(q.full(), data/randN)
++
++
++def test_QobjPower():
++    "qutip.Qobj power"
++    data = _random_not_singular(5)
++    q = qutip.Qobj(data)
++    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
++    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
++
++
++def test_QobjNeg():
++    "qutip.Qobj negation"
++    data = _random_not_singular(5)
++    q = qutip.Qobj(data)
++    x = -q
++    assert np.all(x.full() == -data)
++    assert q.isherm == x.isherm
++    assert q.type == x.type
++
++
++def test_QobjEquals():
++    "qutip.Qobj equals"
++    data = _random_not_singular(5)
++    q1 = qutip.Qobj(data)
++    q2 = qutip.Qobj(data)
++    assert q1 == q2
++
++    q1 = qutip.Qobj(data)
++    q2 = qutip.Qobj(-data)
++    assert q1 != q2
++
++
++def test_QobjGetItem():
++    "qutip.Qobj getitem"
++    data = _random_not_singular(5)
++    q = qutip.Qobj(data)
++    assert q[0, 0] == data[0, 0]
++    assert q[-1, 2] == data[-1, 2]
++
++
++def test_CheckMulType():
++    "qutip.Qobj multiplication type"
++    # ket-bra and bra-ket multiplication
++    psi = qutip.basis(5, 0)
++    dm = psi * psi.dag()
++    assert dm.isoper
++    assert dm.isherm
++
++    nrm = psi.dag() * psi
++    assert isinstance(nrm, numbers.Complex)
++    assert abs(nrm) == 1
++
++    # operator-operator multiplication
++    H1 = qutip.rand_herm(3)
++    H2 = qutip.rand_herm(3)
++    out = H1 * H2
++    assert out.isoper
++    out = H1 * H1
++    assert out.isoper
++    assert out.isherm
++    out = H2 * H2
++    assert out.isoper
++    assert out.isherm
++
++    U = qutip.rand_unitary(5)
++    out = U.dag() * U
++    assert out.isoper
++    assert out.isherm
++
++    N = qutip.num(5)
++
++    out = N * N
++    assert out.isoper
++    assert out.isherm
++
++    # operator-ket and bra-operator multiplication
++    op = qutip.sigmax()
++    ket1 = qutip.basis(2, 0)
++    ket2 = op * ket1
++    assert ket2.isket
++
++    bra1 = qutip.basis(2, 0).dag()
++    bra2 = bra1 * op
++    assert bra2.isbra
++
++    assert bra2.dag() == ket2
++
++    # superoperator-operket and operbra-superoperator multiplication
++    sop = qutip.to_super(qutip.sigmax())
++    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
++    opket2 = sop * opket1
++    assert opket2.isoperket
++
++    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
++    opbra2 = opbra1 * sop
++    assert opbra2.isoperbra
++
++    assert opbra2.dag() == opket2
++
++
++def test_operator_ket_superrep():
++    sop = qutip.to_super(qutip.sigmax())
++    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
++    opket2 = sop * opket1
++    assert opket1.superrep == opket2.superrep
++
++    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
++    opbra2 = opbra1 * sop
++    assert opbra1.superrep == opbra2.superrep
++
++
++def test_QobjConjugate():
++    "qutip.Qobj conjugate"
++    data = _random_not_singular(5)
++    A = qutip.Qobj(data)
++    B = A.conj()
++    assert np.all(B.full() == data.conj())
++    assert A.isherm == B.isherm
++    assert A.type == B.type
++    assert A.superrep == B.superrep
++
++
++def test_QobjDagger():
++    "qutip.Qobj adjoint (dagger)"
++    data = _random_not_singular(5)
++    A = qutip.Qobj(data)
++    B = A.dag()
++    assert np.all(B.full() == data.conj().T)
++    assert A.isherm == B.isherm
++    assert A.type == B.type
++    assert A.superrep == B.superrep
++
++
++def test_QobjDiagonals():
++    "qutip.Qobj diagonals"
++    data = _random_not_singular(5)
++    A = qutip.Qobj(data)
++    b = A.diag()
++    assert np.all(b == np.diag(data))
++
++
++def test_QobjEigenEnergies():
++    "qutip.Qobj eigenenergies"
++    data = np.eye(5)
++    A = qutip.Qobj(data)
++    b = A.eigenenergies()
++    assert np.all(b == np.ones(5))
++
++    data = np.diag(np.arange(10))
++    A = qutip.Qobj(data)
++    b = A.eigenenergies()
++    assert np.all(b == np.arange(10))
++
++    data = np.diag(np.arange(10))
++    A = 5 * qutip.Qobj(data)
++    b = A.eigenenergies()
++    assert np.all(b == 5*np.arange(10))
++
++
++def test_QobjEigenStates():
++    "qutip.Qobj eigenstates"
++    data = np.eye(5)
++    A = qutip.Qobj(data)
++    b, c = A.eigenstates()
++    assert np.all(b == np.ones(5))
++    kets = [qutip.basis(5, k) for k in range(5)]
++    for k in range(5):
++        assert c[k] == kets[k]
++
++
++def test_QobjExpm():
++    "qutip.Qobj expm (dense)"
++    data = _random_not_singular(15)
++    A = qutip.Qobj(data)
++    B = A.expm()
++    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
++
++
++def test_QobjExpmExplicitlySparse():
++    "qutip.Qobj expm (sparse)"
++    data = _random_not_singular(15)
++    A = qutip.Qobj(data)
++    B = A.expm(dtype=qutip.data.CSR)
++    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
++
++
++def test_QobjExpmZeroOper():
++    "qutip.Qobj expm zero_oper (#493)"
++    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
++    B = A.expm()
++    assert B == qutip.qeye(5)
++
++
++def test_QobjLogm():
++    "qutip.Qobj expm (dense)"
++    data = _random_not_singular(15)
++    A = qutip.Qobj(data)
++    B = A.logm()
++    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
++
++
++def test_QobjLogmExplicitlySparse():
++    "qutip.Qobj logm (sparse)"
++    data = _random_not_singular(15)
++    A = qutip.Qobj(data).to("csr")
++    B = A.logm()
++    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
++
++
++def test_QobjLogmZeroOper():
++    "qutip.Qobj logm zero_oper (#493)"
++    A = qutip.qeye(5)
++    B = A.logm()
++    assert B == qutip.qzero(5)
++
++
++def test_Qobj_sqrtm():
++    "qutip.Qobj sqrtm"
++    data = _random_not_singular(5)
++    A = qutip.Qobj(data)
++    B = A.sqrtm()
++    assert A == B * B
++
++
++def test_Qobj_inv():
++    "qutip.Qobj inv"
++    data = _random_not_singular(5)
++    A = qutip.Qobj(data)
++    B = A.inv()
++    assert qutip.qeye(5) == A * B
++    assert qutip.qeye(5) == B * A
++    B = A.inv(sparse=True)
++    assert qutip.qeye(5) == A * B
++    assert qutip.qeye(5) == B * A
++
++
++def test_QobjFull():
++    "qutip.Qobj full"
++    data = _random_not_singular(15)
++    A = qutip.Qobj(data)
++    b = A.full()
++    assert np.all(b == data)
++
++
++def test_QobjNorm():
++    "qutip.Qobj norm"
++    # vector L2-norm test
++    N = 20
++    x = np.random.random(N) + 1j*np.random.random(N)
++    A = qutip.Qobj(x)
++    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
++    # vector max (inf) norm test
++    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
++                               atol=1e-12)
++    # operator frobius norm
++    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
++    A = qutip.Qobj(x)
++    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
++                               atol=1e-12)
++    # operator trace norm
++    a = qutip.rand_herm(10, density=0.25)
++    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
++    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
++    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
++
++
++def test_QobjPurity():
++    "Tests the purity method of `qutip.Qobj`"
++    psi = qutip.basis(2, 1)
++    # check purity of pure ket state
++    np.testing.assert_allclose(psi.purity(), 1)
++    # check purity of pure ket state (superposition)
++    psi2 = qutip.basis(2, 0)
++    psi_tot = (psi+psi2).unit()
++    np.testing.assert_allclose(psi_tot.purity(), 1)
++    # check purity of density matrix of pure state
++    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
++    # check purity of maximally mixed density matrix
++    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
++    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
++
++
++def test_QobjPermute(datatype):
++    "qutip.Qobj permute"
++    A = qutip.basis(3, 0, dtype=datatype)
++    B = qutip.basis(5, 4, dtype=datatype)
++    C = qutip.basis(4, 2, dtype=datatype)
++    psi = qutip.tensor(A, B, C)
++    psi2 = psi.permute([2, 0, 1])
++    assert psi2 == qutip.tensor(C, A, B)
++
++    psi_bra = psi.dag()
++    psi2_bra = psi_bra.permute([2, 0, 1])
++    assert psi2_bra == qutip.tensor(C, A, B).dag()
++
++    A = qutip.fock_dm(3, 0, dtype=datatype)
++    B = qutip.fock_dm(5, 4, dtype=datatype)
++    C = qutip.fock_dm(4, 2, dtype=datatype)
++    rho = qutip.tensor(A, B, C)
++    rho2 = rho.permute([2, 0, 1])
++    assert rho2 == qutip.tensor(C, A, B)
++
++    for _ in range(3):
++        A = qutip.rand_ket(3, dtype=datatype)
++        B = qutip.rand_ket(4, dtype=datatype)
++        C = qutip.rand_ket(5, dtype=datatype)
++        psi = qutip.tensor(A, B, C)
++        psi2 = psi.permute([1, 0, 2])
++        assert psi2 == qutip.tensor(B, A, C)
++
++        psi_bra = psi.dag()
++        psi2_bra = psi_bra.permute([1, 0, 2])
++        assert psi2_bra == qutip.tensor(B, A, C).dag()
++
++    for _ in range(3):
++        A = qutip.rand_dm(3, dtype=datatype)
++        B = qutip.rand_dm(4, dtype=datatype)
++        C = qutip.rand_dm(5, dtype=datatype)
++        rho = qutip.tensor(A, B, C)
++        rho2 = rho.permute([1, 0, 2])
++        assert rho2 == qutip.tensor(B, A, C)
++
++        rho_vec = qutip.operator_to_vector(rho)
++        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
++        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
++
++        rho_vec_bra = qutip.operator_to_vector(rho).dag()
++        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
++        assert (rho2_vec_bra
++                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
++
++    for _ in range(3):
++        super_dims = [3, 5, 4]
++        U = qutip.rand_unitary(super_dims, dtype=datatype)
++        Unew = U.permute([2, 1, 0])
++        S_tens = qutip.to_super(U)
++        S_tens_new = qutip.to_super(Unew)
++        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
++
++
++def test_KetType():
++    "qutip.Qobj ket type"
++
++    psi = qutip.basis(2, 1)
++
++    assert psi.isket
++    assert not psi.isbra
++    assert not psi.isoper
++    assert not psi.issuper
++
++    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
++
++    assert psi.isket
++    assert not psi.isbra
++    assert not psi.isoper
++    assert not psi.issuper
++
++
++def test_BraType():
++    "qutip.Qobj bra type"
++
++    psi = qutip.basis(2, 1).dag()
++    assert not psi.isket
++    assert psi.isbra
++    assert not psi.isoper
++    assert not psi.issuper
++
++    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
++    assert not psi.isket
++    assert psi.isbra
++    assert not psi.isoper
++    assert not psi.issuper
++
++
++def test_OperType():
++    "qutip.Qobj operator type"
++
++    psi = qutip.basis(2, 1)
++    rho = psi * psi.dag()
++
++    assert not rho.isket
++    assert not rho.isbra
++    assert rho.isoper
++    assert not rho.issuper
++
++
++def test_SuperType():
++    "qutip.Qobj superoperator type"
++
++    psi = qutip.basis(2, 1)
++    rho = psi * psi.dag()
++
++    sop = qutip.spre(rho)
++
++    assert not sop.isket
++    assert not sop.isbra
++    assert not sop.isoper
++    assert sop.issuper
++
++    sop = qutip.spost(rho)
++
++    assert not sop.isket
++    assert not sop.isbra
++    assert not sop.isoper
++    assert sop.issuper
++
++
++@pytest.mark.parametrize("dimension", [2, 4, 8])
++@pytest.mark.parametrize("conversion", [
++    pytest.param(qutip.to_super, id='to_super'),
++    pytest.param(qutip.to_choi, id='to_choi'),
++    pytest.param(qutip.to_chi, id='to_chi'),
++])
++def test_dag_preserves_superrep(dimension, conversion):
++    """
++    Checks that dag() preserves superrep.
++    """
++    qobj = conversion(qutip.rand_super_bcsz(dimension))
++    assert qobj.superrep == qobj.dag().superrep
++
++
++@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
++@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
++    pytest.param(operator.add, True, True, id='add'),
++    pytest.param(operator.sub, True, True, id='sub'),
++    pytest.param(operator.mul, True, True, id='mul'),
++    pytest.param(operator.truediv, False, True, id='div'),
++    pytest.param(qutip.tensor, True, False, id='tensor'),
++])
++def test_arithmetic_preserves_superrep(superrep,
++                                       operation, check_op, check_scalar):
++    """
++    Checks that binary ops preserve 'superrep'.
++
++    .. note::
++
++        The random superoperators are not chosen in a way that reflects the
++        structure of that superrep, but are simply random matrices.
++    """
++    dims = [[[2], [2]], [[2], [2]]]
++    shape = (4, 4)
++    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
++    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
++    x = np.random.random()
++
++    check_list = []
++    if check_op:
++        check_list.append(operation(S1, S2))
++    if check_scalar:
++        check_list.append(operation(S1, x))
++    if check_op and check_scalar:
++        check_list.append(operation(x, S2))
++
++    for S in check_list:
++        assert S.issuper
++        assert S.type == "super"
++        assert S.superrep == superrep
++
++
++def test_isherm_skew():
++    """
++    mul and tensor of skew-Hermitian operators report ``isherm = True``.
++    """
++    iH = 1j * qutip.rand_herm(5)
++    assert_hermicity(iH, False)
++    assert_hermicity(iH * iH, True)
++    assert_hermicity(qutip.tensor(iH, iH), True)
++
++
++def test_super_tensor_operket():
++    """
++    Tensor: Checks that super_tensor respects states.
++    """
++    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
++    qutip.operator_to_vector(rho1)
++    qutip.operator_to_vector(rho2)
++
++
++def test_super_tensor_property():
++    """
++    Tensor: Super_tensor correctly tensors on underlying spaces.
++    """
++    U1 = qutip.rand_unitary(3)
++    U2 = qutip.rand_unitary(5)
++    U = qutip.tensor(U1, U2)
++    S_tens = qutip.to_super(U)
++    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
++    assert S_tens == S_supertens
++    assert S_supertens.superrep == 'super'
++
++
++def test_composite_oper():
++    """
++    Composite: Tests compositing unitaries and superoperators.
++    """
++    U1 = qutip.rand_unitary(3)
++    U2 = qutip.rand_unitary(5)
++    S1 = qutip.to_super(U1)
++    S2 = qutip.to_super(U2)
++    S3 = qutip.rand_super(4)
++    S4 = qutip.rand_super(7)
++
++    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
++    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
++    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
++    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
++
++
++def test_composite_vec():
++    """
++    Composite: Tests compositing states and density operators.
++    """
++    k1 = qutip.rand_ket(5)
++    k2 = qutip.rand_ket(7)
++    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
++    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
++
++    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
++    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
++
++    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
++    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
++    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
++    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
++
++# TODO: move out to a more appropriate module.
++
++
++def trunc_neg_case(qobj, method, expected=None):
++    pos_qobj = qobj.trunc_neg(method=method)
++    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
++    np.testing.assert_allclose(pos_qobj.tr(), 1)
++    if expected is not None:
++        test_array = pos_qobj.full()
++        exp_array = expected.full()
++        np.testing.assert_allclose(test_array, exp_array)
++
++
++class TestTruncNeg:
++    """Test qutip.Qobj.trunc_neg for several different cases."""
++    def test_positive_operator(self):
++        trunc_neg_case(qutip.rand_dm(5), 'clip')
++        trunc_neg_case(qutip.rand_dm(5), 'sgs')
++
++    def test_diagonal_operator(self):
++        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
++        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
++        trunc_neg_case(to_test, 'clip', expected)
++        trunc_neg_case(to_test, 'sgs', expected)
++
++    def test_nondiagonal_operator(self):
++        U = qutip.rand_unitary(3)
++        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
++        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
++        trunc_neg_case(to_test, 'clip', expected)
++        trunc_neg_case(to_test, 'sgs', expected)
++
++    def test_sgs_known_good(self):
++        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
++                       'sgs',
++                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
++
++
++def test_cosm():
++    """
++    Test qutip.Qobj: cosm
++    """
++    A = qutip.rand_herm(5)
++    B = A.cosm().full()
++    C = scipy.linalg.cosm(A.full())
++    np.testing.assert_allclose(B, C, atol=1e-14)
++
++
++def test_sinm():
++    """
++    Test qutip.Qobj: sinm
++    """
++    A = qutip.rand_herm(5)
++    B = A.sinm().full()
++    C = scipy.linalg.sinm(A.full())
++    np.testing.assert_allclose(B, C, atol=1e-14)
++
++
++@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
++def test_dual_channel(sub_dimensions, n_trials=50):
++    """
++    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
++    """
++    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
++    S.dims = [[sub_dimensions, sub_dimensions],
++              [sub_dimensions, sub_dimensions]]
++    S = qutip.to_super(S)
++    left_dims, right_dims = S.dims
++
++    # Assume for the purposes of the test that S maps square operators to
++    # square operators.
++    in_dim = np.prod(right_dims[0])
++    out_dim = np.prod(left_dims[0])
++
++    S_dual = qutip.to_super(S.dual_chan())
++
++    primals = []
++    duals = []
++
++    for _ in [None]*n_trials:
++        X = qutip.rand_dm(out_dim)
++        X.dims = left_dims
++        X = qutip.operator_to_vector(X)
++        Y = qutip.rand_dm(in_dim)
++        Y.dims = right_dims
++        Y = qutip.operator_to_vector(Y)
++
++        primals.append(X.dag() * S * Y)
++        duals.append(X.dag() * S_dual.dag() * Y)
++
++    np.testing.assert_allclose(primals, duals)
++
++
++def test_call():
++    """
++    Test qutip.Qobj: Call
++    """
++    # Make test objects.
++    psi = qutip.rand_ket(3)
++    rho = qutip.rand_dm(3)
++    U = qutip.rand_unitary(3)
++    S = qutip.rand_super_bcsz(3)
++
++    # Case 0: oper(ket).
++    assert U(psi) == U * psi
++    # Case 1: oper(oper). Should raise TypeError.
++    with pytest.raises(TypeError):
++        U(rho)
++    # Case 2: super(ket).
++    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
++    assert S(psi) == expected
++    # Case 3: super(oper).
++    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
++    assert S(rho) == expected
++    # Case 4: super(super). Should raise TypeError.
++    with pytest.raises(TypeError):
++        S(S)
++
++
++def test_mat_elem():
++    """
++    Test qutip.Qobj: Compute matrix elements
++    """
++    for _ in range(10):
++        N = 20
++        H = qutip.rand_herm(N, density=0.2)
++        L = qutip.rand_ket(N, density=0.3)
++        Ld = L.dag()
++        R = qutip.rand_ket(N, density=0.3)
++        ans = Ld * H * R
++        # bra-ket
++        out1 = H.matrix_element(Ld, R)
++        # ket-ket
++        out2 = H.matrix_element(Ld, R)
++        assert abs(ans - out1) < 1e-14
++        assert abs(ans - out2) < 1e-14
++
++
++def test_projection():
++    """
++    Test qutip.Qobj: Projection operator
++    """
++    for _ in range(10):
++        N = 5
++        K = qutip.rand_ket([N, N], density=0.75)
++        B = K.dag()
++        ans = K * K.dag()
++        out1 = K.proj()
++        out2 = B.proj()
++        assert out1 == ans
++        assert out2 == ans
++
++
++def test_overlap():
++    """
++    Test qutip.Qobj: Overlap (inner product)
++    """
++    for _ in range(10):
++        N = 10
++        A = qutip.rand_ket(N, density=0.75)
++        Ad = A.dag()
++        B = qutip.rand_ket(N, density=0.75)
++        Bd = B.dag()
++        ans = A.dag() * B
++        np.testing.assert_allclose(A.overlap(B), ans)
++        np.testing.assert_allclose(Ad.overlap(B), ans)
++        np.testing.assert_allclose(Ad.overlap(Bd), ans)
++        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
++
++
++def test_unit():
++    """
++    Test qutip.Qobj: unit
++    """
++    psi = (10*np.random.randn()*qutip.basis(2, 0)
++           - 10j*np.random.randn()*qutip.basis(2, 1))
++    psi2 = psi.unit()
++    psi.unit(inplace=True)
++    assert psi == psi2
++    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
++
++
++def test_trace():
++    sz = qutip.sigmaz()
++    assert sz.tr() == 0
++
++
++def test_no_real_attribute(monkeypatch):
++    """This tests ensures that trace still works even if the output of a
++    specialisation does not have the ``real`` attribute. This is the case for
++    the tensorflow and cupy data layers."""
++
++    def mocker_trace_return(oper):
++        """
++        We simply return a string which does not have the `real` attribute.
++        """
++        return "object without .real"
++
++    monkeypatch.setattr(_data, "trace", mocker_trace_return)
++
++    sz = qutip.sigmaz() # the choice of the matrix does not matter
++    assert "object without .real" == sz.tr()
++
++
++@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
++@pytest.mark.parametrize(['expanded', 'contracted'], [
++    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
++    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
++    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
++    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
++    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
++                 id='mixed'),
++    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
++                 id='mixed,unchanged'),
++    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
++                 id='mixed,unchanged'),
++    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
++    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
++    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
++                 id='ket,unchanged'),
++    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
++    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
++    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
++                 id='bra,unchanged'),
++    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
++                 id='operket'),
++    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
++                 id='operbra'),
++])
++def test_contract(expanded, contracted, inplace):
++    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
++    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
++    qobj = qutip.Qobj(data, dims=expanded)
++    assert qobj.dims == expanded
++    out = qobj.contract(inplace=inplace)
++    if inplace:
++        assert out is qobj
++    else:
++        assert out is not qobj
++    assert out.dims == contracted
++    assert out.shape == qobj.shape
++    assert np.all(out.full() == qobj.full())
++
++
++@pytest.mark.parametrize(["shape"], [
++    pytest.param((5, 1), id='ket'),
++    pytest.param((5, 2), id='tall'),
++    pytest.param((1, 5), id='bra'),
++    pytest.param((2, 5), id='wide'),
++    pytest.param((3, 3), id='oper'),
++])
++def test_sum_zero(shape):
++    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
++    qobj = qutip.Qobj(data)
++    assert qobj + 0 == qobj
++    assert qobj - 0 == qobj
++    assert 0 + qobj == qobj
++    assert 0 - qobj == -qobj
++
++
++@pytest.mark.parametrize(["shape"], [
++    pytest.param((5, 1), id='ket'),
++    pytest.param((5, 2), id='tall'),
++    pytest.param((1, 5), id='bra'),
++    pytest.param((2, 5), id='wide'),
++    pytest.param((3, 3), id='oper'),
++])
++def test_sum_buildin(shape):
++    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
++    qobj = qutip.Qobj(data)
++    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
++
++
++def test_groundstate():
++    eigenvals = np.sort(np.random.rand(10))
++    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
++    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
++    groundenergy, groundstate = qobj.groundstate()
++    assert groundenergy == pytest.approx(eigenvals[0])
++    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
++    assert groundstate.overlap(groundstate) == pytest.approx(1)
++
++    with pytest.warns(UserWarning) as warning:
++        qutip.qeye(5).groundstate()
++    assert "degenerate" in warning[0].message.args[0]
+diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
+index 77fe8fba..dbcb3979 100644
+--- a/qutip/tests/core/test_qobjevo.py
++++ b/qutip/tests/core/test_qobjevo.py
+@@ -1,515 +1,515 @@
+-import operator
+-
+-import pytest
+-from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
+-                   rand_stochastic, rand_herm, rand_ket, liouvillian,
+-                   basis, spre, spost, to_choi)
+-import numpy as np
+-from numpy.testing import assert_allclose
+-
+-from qutip.core import data as _data
+-
+-# prepare coefficient
+-class Pseudo_qevo:
+-    # Mimic QobjEvo on __call__
+-    # and can return parameter to create the equivalent QobjEvo
+-    # for each coefficient type
+-    def __init__(self, cte, qobj, func, string, args):
+-        self.cte = cte
+-        self.qobj = qobj
+-        self.func = func
+-        self.str = string
+-        self.args = args
+-
+-    def array(self):
+-        tlist = np.linspace(0, 10, 10001)
+-        coeff = self.func(tlist, self.args)
+-        return ([self.cte, [self.qobj, coeff]], {}, tlist)
+-
+-    def logarray(self):
+-        tlist = np.logspace(-3, 1, 10001)
+-        coeff = self.func(tlist, self.args)
+-        return ([self.cte, [self.qobj, coeff]], {}, tlist)
+-
+-    def func_coeff(self):
+-        return ([self.cte, [self.qobj, self.func]], self.args)
+-
+-    def string(self):
+-        return ([self.cte, [self.qobj, self.str]], self.args)
+-
+-    def func_call(self):
+-        return (self.__call__, self.args)
+-
+-    def __call__(self, t, args={}):
+-        args = args or self.args
+-        return self.cte + self.qobj * self.func(t, args)
+-
+-    def __getitem__(self, which):
+-        return getattr(self, which)()
+-
+-
+-N = 3
+-args = {'w1': 1, "w2": 2}
+-TESTTIMES = np.linspace(0.001, 1.0, 10)
+-
+-
+-def _real(t, args):
+-    return np.sin(t*args['w1'])
+-
+-
+-def _cplx(t, args):
+-    return np.exp(1j*t*args['w2'])
+-
+-
+-real_qevo = Pseudo_qevo(
+-    rand_stochastic(N).to(_data.CSR),
+-    rand_stochastic(N).to(_data.CSR),
+-    _real, "sin(t*w1)", args)
+-
+-herm_qevo = Pseudo_qevo(
+-    rand_herm(N).to(_data.Dense),
+-    rand_herm(N).to(_data.Dense),
+-    _real, "sin(t*w1)", args)
+-
+-cplx_qevo = Pseudo_qevo(
+-    rand_stochastic(N).to(_data.Dense),
+-    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
+-    _cplx, "exp(1j*t*w2)", args)
+-
+-
+-@pytest.fixture(params=['func_coeff', 'string',
+-                        'array', 'logarray', 'func_call'])
+-def coeff_type(request):
+-    # all available QobjEvo types
+-    return request.param
+-
+-
+-@pytest.fixture(params=[
+-    pytest.param(real_qevo, id="real"),
+-    pytest.param(herm_qevo, id="hermitian"),
+-    pytest.param(cplx_qevo, id="complex"),
+-])
+-def pseudo_qevo(request):
+-    return request.param
+-
+-
+-@pytest.fixture
+-def all_qevo(pseudo_qevo, coeff_type):
+-    return QobjEvo(*pseudo_qevo[coeff_type])
+-
+-
+-@pytest.fixture
+-def other_qevo(all_qevo):
+-    return all_qevo
+-
+-
+-def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
+-    for t in TESTTIMES:
+-        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
+-
+-
+-def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
+-    assert obj1.dims == obj2.dims
+-    assert obj1.shape == obj2.shape
+-    assert obj1.type == obj2.type
+-    assert _data.iszero((obj1 - obj2).data, tol)
+-
+-
+-def _assert_qobjevo_different(obj1, obj2):
+-    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
+-
+-
+-def _div(a, b):
+-    return a / b
+-
+-
+-def test_call(pseudo_qevo, coeff_type):
+-    # test creation of QobjEvo and call
+-    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+-    assert isinstance(qevo(0), Qobj)
+-    assert qevo.isoper
+-    assert not qevo.isconstant
+-    assert not qevo.issuper
+-    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
+-
+-
+-# Test the QobjEvo.__repr__()
+-def test_QobjEvo_repr():
+-    # case_n: cases with Objects of QobjEvo with unique __repr__
+-    # expected_repr_n: are the Expected result from the __repr__
+-
+-    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
+-    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
+-    expected_repr_1 += 'type = oper, superrep = None, '
+-    expected_repr_1 += 'isconstant = False, num_elements = 1'
+-    assert case_1 == expected_repr_1
+-
+-    case_2 = repr(QobjEvo(qeye(2)))
+-    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
+-    expected_repr_2 += 'type = oper, superrep = None, '
+-    expected_repr_2 += 'isconstant = True, num_elements = 1'
+-    assert case_2 == expected_repr_2
+-
+-    case_3 = repr(QobjEvo(basis(5, 2)))
+-    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
+-    expected_repr_3 += 'type = ket, superrep = None, '
+-    expected_repr_3 += 'isconstant = True, num_elements = 1'
+-    assert case_3 == expected_repr_3
+-
+-    X = sigmax()
+-    S = spre(X) * spost(X.dag())
+-    case_4 = repr(QobjEvo(to_choi(S)))
+-    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
+-    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
+-    expected_repr_4 += 'isconstant = True, num_elements = 1'
+-    assert case_4 == expected_repr_4
+-
+-    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
+-                           [qeye(4), lambda t: t]], compress=False))
+-    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
+-    expected_repr_5 += 'type = oper, superrep = None, '
+-    expected_repr_5 += 'isconstant = False, num_elements = 2'
+-    assert case_5 == expected_repr_5
+-
+-
+-@pytest.mark.parametrize('coeff_type',
+-                         ['func_coeff', 'string', 'array', 'logarray'])
+-def test_product_coeff(pseudo_qevo, coeff_type):
+-    # test creation of QobjEvo with Qobj * Coefficient
+-    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
+-    base = pseudo_qevo[coeff_type]
+-    cte, [qobj, coeff] = base[0]
+-    args = base[1] if len(base) >= 2 else {}
+-    tlist = base[2] if len(base) >= 3 else None
+-    coeff = coefficient(coeff, args=args, tlist=tlist)
+-    created = cte + qobj * coeff
+-    _assert_qobjevo_equivalent(pseudo_qevo, created)
+-
+-def test_copy(all_qevo):
+-    qevo = all_qevo
+-    copy = qevo.copy()
+-    _assert_qobjevo_equivalent(copy, qevo)
+-    assert copy is not qevo
+-
+-
+-@pytest.mark.parametrize('bin_op', [
+-    pytest.param(lambda a, b: a + b, id="add"),
+-    pytest.param(lambda a, b: a - b, id="sub"),
+-    pytest.param(lambda a, b: a * b, id="mul"),
+-    pytest.param(lambda a, b: a @ b, id="matmul"),
+-    pytest.param(lambda a, b: a & b, id="tensor"),
+-])
+-def test_binopt(all_qevo, other_qevo, bin_op):
+-    "QobjEvo arithmetic"
+-    obj1 = all_qevo
+-    obj2 = other_qevo
+-    for t in TESTTIMES:
+-        as_qevo = bin_op(obj1, obj2)(t)
+-        as_qobj = bin_op(obj1(t), obj2(t))
+-        _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-
+-@pytest.mark.parametrize('bin_op', [
+-    pytest.param(operator.iadd, id="add"),
+-    pytest.param(operator.isub, id="sub"),
+-    pytest.param(operator.imul, id="mul"),
+-    pytest.param(operator.imatmul, id="matmul"),
+-    pytest.param(operator.iand, id="tensor"),
+-])
+-def test_binopt_inplace(all_qevo, other_qevo, bin_op):
+-    obj1 = all_qevo
+-    obj2 = other_qevo
+-    for t in TESTTIMES:
+-        as_qevo = bin_op(obj1.copy(), obj2)(t)
+-        as_qobj = bin_op(obj1(t).copy(), obj2(t))
+-        _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-
+-@pytest.mark.parametrize('bin_op', [
+-    pytest.param(lambda a, b: a + b, id="add"),
+-    pytest.param(lambda a, b: a - b, id="sub"),
+-    pytest.param(lambda a, b: a * b, id="mul"),
+-    pytest.param(lambda a, b: a @ b, id="matmul"),
+-    pytest.param(lambda a, b: a & b, id="tensor"),
+-])
+-def test_binopt_qobj(all_qevo, bin_op):
+-    "QobjEvo arithmetic"
+-    obj = all_qevo
+-    qobj = rand_herm(N)
+-    for t in TESTTIMES:
+-        as_qevo = bin_op(obj, qobj)(t)
+-        as_qobj = bin_op(obj(t), qobj)
+-        _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-        as_qevo = bin_op(qobj, obj)(t)
+-        as_qobj = bin_op(qobj, obj(t))
+-        _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-
+-@pytest.mark.parametrize('bin_op', [
+-    pytest.param(lambda a, b: a + b, id="add"),
+-    pytest.param(lambda a, b: a - b, id="sub"),
+-    pytest.param(lambda a, b: a * b, id="mul"),
+-    pytest.param(_div, id="div"),
+-])
+-def test_binopt_scalar(all_qevo, bin_op):
+-    "QobjEvo arithmetic"
+-    obj = all_qevo
+-    scalar = 0.5 + 1j
+-    for t in TESTTIMES:
+-        as_qevo = bin_op(obj, scalar)(t)
+-        as_qobj = bin_op(obj(t), scalar)
+-        _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-        if bin_op is not _div:
+-            as_qevo = bin_op(scalar, obj)(t)
+-            as_qobj = bin_op(scalar, obj(t))
+-            _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-
+-def binop_coeff(all_qevo):
+-    obj = all_qevo
+-    coeff = coeffient("t")
+-    created = obj * coeff_t
+-    for t in TESTTIMES:
+-        _assert_qobj_almost_eq(created(t), obj(t) * t)
+-
+-
+-@pytest.mark.parametrize('unary_op', [
+-    pytest.param(lambda a: a.conj(), id="conj"),
+-    pytest.param(lambda a: a.dag(), id="dag"),
+-    pytest.param(lambda a: a.trans(), id="trans"),
+-    pytest.param(lambda a: -a, id="neg"),
+-])
+-def test_unary(all_qevo, unary_op):
+-    "QobjEvo arithmetic"
+-    obj = all_qevo
+-    for t in TESTTIMES:
+-        as_qevo = unary_op(obj)(t)
+-        as_qobj = unary_op(obj(t))
+-        _assert_qobj_almost_eq(as_qevo, as_qobj)
+-
+-
+-@pytest.mark.parametrize('args_coeff_type',
+-                         ['func_coeff', 'string', 'func_call'])
+-def test_args(pseudo_qevo, args_coeff_type):
+-    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
+-    args = {'w1': 3, "w2": 3}
+-
+-    for t in TESTTIMES:
+-        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
+-        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
+-
+-    # Did it modify original args
+-    _assert_qobjevo_equivalent(obj, pseudo_qevo)
+-
+-    obj.arguments(args)
+-    _assert_qobjevo_different(obj, pseudo_qevo)
+-    for t in TESTTIMES:
+-        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
+-
+-    args = {'w1': 4, "w2": 4}
+-    obj.arguments(**args)
+-    _assert_qobjevo_different(obj, pseudo_qevo)
+-    for t in TESTTIMES:
+-        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
+-
+-
+-def test_copy_side_effects(all_qevo):
+-    t = 0.2
+-    qevo = all_qevo
+-    copy = qevo.copy()
+-    before = qevo(t)
+-    # Ensure inplace modification of the copy do not affect the original
+-    copy *= 2
+-    copy += rand_herm(N)
+-    copy *= rand_herm(N)
+-    copy.arguments({'w1': 3, "w2": 3})
+-    after = qevo(t)
+-    _assert_qobj_almost_eq(before, after)
+-
+-
+-@pytest.mark.parametrize('coeff_type',
+-    ['func_coeff', 'string', 'array', 'logarray']
+-)
+-def test_tidyup(all_qevo):
+-    "QobjEvo tidyup"
+-    obj = all_qevo
+-    obj *= 1e-12
+-    obj.tidyup(atol=1e-8)
+-    t = 0.2
+-    # check that the Qobj are cleaned
+-    assert_allclose(obj(t).full(), 0)
+-
+-
+-def test_QobjEvo_pickle(all_qevo):
+-    "QobjEvo pickle"
+-    # used in parallel_map
+-    import pickle
+-    obj = all_qevo
+-    pickled = pickle.dumps(obj, -1)
+-    recreated = pickle.loads(pickled)
+-    _assert_qobjevo_equivalent(recreated, obj)
+-
+-
+-def test_QobjEvo_restore(all_qevo):
+-    "QobjEvo pickle"
+-    # used in parallel_map
+-    obj = all_qevo
+-    state = obj._getstate()
+-    recreated = QobjEvo._restore(**state)
+-    _assert_qobjevo_equivalent(recreated, obj)
+-
+-
+-def test_mul_vec(all_qevo):
+-    "QobjEvo matmul ket"
+-    vec = Qobj(np.arange(N)*.5+.5j)
+-    op = all_qevo
+-    for t in TESTTIMES:
+-        assert_allclose((op(t) @ vec).full(),
+-                        op.matmul(t, vec).full(), atol=1e-14)
+-
+-
+-def test_matmul(all_qevo):
+-    "QobjEvo matmul oper"
+-    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
+-    matDense = Qobj(mat).to(_data.Dense)
+-    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
+-    matCSR = Qobj(mat).to(_data.CSR)
+-    op = all_qevo
+-    for t in TESTTIMES:
+-        Qo1 = op(t)
+-        assert_allclose((Qo1 @ mat).full(),
+-                        op.matmul(t, matF).full(), atol=1e-14)
+-        assert_allclose((Qo1 @ mat).full(),
+-                        op.matmul(t, matDense).full(), atol=1e-14)
+-        assert_allclose((Qo1 @ mat).full(),
+-                        op.matmul(t, matCSR).full(), atol=1e-14)
+-
+-
+-def test_expect_psi(all_qevo):
+-    "QobjEvo expect psi"
+-    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
+-    qobj = Qobj(vec)
+-    op = all_qevo
+-    for t in TESTTIMES:
+-        Qo1 = op(t)
+-        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
+-                        atol=1e-14)
+-
+-
+-def test_expect_rho(all_qevo):
+-    "QobjEvo expect rho"
+-    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
+-                                      + 1j * np.random.rand(N*N))
+-    mat = _data.column_unstack_dense(vec, N)
+-    qobj = Qobj(mat)
+-    op = liouvillian(all_qevo)
+-    for t in TESTTIMES:
+-        Qo1 = op(t)
+-        assert abs(_data.expect_super(Qo1.data, vec)
+-                   - op.expect(t, qobj)) < 1e-14
+-
+-
+-@pytest.mark.parametrize('dtype',
+-[pytest.param(dtype, id=dtype.__name__)
+-     for dtype in _data.to.dtypes])
+-def test_convert(all_qevo, dtype):
+-    "QobjEvo expect rho"
+-    op = all_qevo.to(dtype)
+-    assert isinstance(op(0.5).data, dtype)
+-
+-
+-def test_compress():
+-    "QobjEvo compress"
+-    obj1 = QobjEvo(
+-        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
+-    assert obj1.num_elements == 1
+-    obj2 = QobjEvo(
+-        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
+-    assert obj2.num_elements == 3
+-    _assert_qobjevo_equivalent(obj1, obj2)
+-    obj3 = obj2.copy()
+-    assert obj3.num_elements == 3
+-    obj3.compress()
+-    assert obj3.num_elements == 1
+-    _assert_qobjevo_equivalent(obj2, obj3)
+-
+-
+-@pytest.mark.parametrize(['qobjdtype'],
+-    [pytest.param(dtype, id=dtype.__name__)
+-     for dtype in _data.to.dtypes])
+-@pytest.mark.parametrize(['statedtype'],
+-    [pytest.param(dtype, id=dtype.__name__)
+-     for dtype in _data.to.dtypes])
+-def test_layer_support(qobjdtype, statedtype):
+-    N = 10
+-    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
+-    state_dense = rand_ket(N).to(_data.Dense)
+-    state = state_dense.to(statedtype).data
+-    state_dense = state_dense.data
+-    exp_any = qevo.expect_data(0, state)
+-    exp_dense = qevo.expect_data(0, state_dense)
+-    assert_allclose(exp_any, exp_dense)
+-    mul_any = qevo.matmul_data(0, state).to_array()
+-    mul_dense = qevo.matmul_data(0, state_dense).to_array()
+-    assert_allclose(mul_any, mul_dense)
+-
+-
+-def test_QobjEvo_step_coeff():
+-    "QobjEvo step interpolation"
+-    coeff1 = np.random.rand(6)
+-    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
+-    # uniform t
+-    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
+-    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
+-                      tlist=tlist, order=0)
+-    assert qobjevo(2.0)[0,0] == coeff1[0]
+-    assert qobjevo(7.0)[0,0] == coeff1[5]
+-    assert qobjevo(5.0001)[0,0] == coeff1[3]
+-    assert qobjevo(3.9999)[0,0] == coeff1[1]
+-
+-    assert qobjevo(2.0)[0,1] == coeff2[0]
+-    assert qobjevo(7.0)[0,1] == coeff2[5]
+-    assert qobjevo(5.0001)[0,1] == coeff2[3]
+-    assert qobjevo(3.9999)[0,1] == coeff2[1]
+-
+-    # non-uniform t
+-    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
+-    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
+-        tlist=tlist, order=0)
+-    assert qobjevo(1.0)[0,0] == coeff1[0]
+-    assert qobjevo(8.0)[0,0] == coeff1[5]
+-    assert qobjevo(3.9999)[0,0] == coeff1[1]
+-    assert qobjevo(4.23)[0,0] == coeff1[2]
+-    assert qobjevo(1.23)[0,0] == coeff1[0]
+-
+-    assert qobjevo(1.0)[0,1] == coeff2[0]
+-    assert qobjevo(8.0)[0,1] == coeff2[5]
+-    assert qobjevo(6.7)[0,1] == coeff2[4]
+-    assert qobjevo(7.9999)[0,1] == coeff2[4]
+-    assert qobjevo(3.9999)[0,1] == coeff2[1]
+-
+-
+-def test_QobjEvo_isherm_flag_knowcase():
+-    assert QobjEvo(sigmax())(0)._isherm is True
+-    non_hermitian = sigmax() + 1j
+-    non_hermitian.isherm  # set flag
+-    assert QobjEvo(non_hermitian)(0)._isherm is False
+-    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
+-    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
+-    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
+-    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
+-    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
+-
+-
+-@pytest.mark.parametrize(
+-    "coeff_type",
+-    ['func_coeff', 'string', 'array', 'logarray']
+-)
+-def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
+-    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+-    as_list = qevo.to_list()
+-    assert len(as_list) == 2
+-    restored = QobjEvo(as_list)
+-    _assert_qobjevo_equivalent(qevo, restored)
++import operator
++
++import pytest
++from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
++                   rand_stochastic, rand_herm, rand_ket, liouvillian,
++                   basis, spre, spost, to_choi)
++import numpy as np
++from numpy.testing import assert_allclose
++
++from qutip.core import data as _data
++
++# prepare coefficient
++class Pseudo_qevo:
++    # Mimic QobjEvo on __call__
++    # and can return parameter to create the equivalent QobjEvo
++    # for each coefficient type
++    def __init__(self, cte, qobj, func, string, args):
++        self.cte = cte
++        self.qobj = qobj
++        self.func = func
++        self.str = string
++        self.args = args
++
++    def array(self):
++        tlist = np.linspace(0, 10, 10001)
++        coeff = self.func(tlist, self.args)
++        return ([self.cte, [self.qobj, coeff]], {}, tlist)
++
++    def logarray(self):
++        tlist = np.logspace(-3, 1, 10001)
++        coeff = self.func(tlist, self.args)
++        return ([self.cte, [self.qobj, coeff]], {}, tlist)
++
++    def func_coeff(self):
++        return ([self.cte, [self.qobj, self.func]], self.args)
++
++    def string(self):
++        return ([self.cte, [self.qobj, self.str]], self.args)
++
++    def func_call(self):
++        return (self.__call__, self.args)
++
++    def __call__(self, t, args={}):
++        args = args or self.args
++        return self.cte + self.qobj * self.func(t, args)
++
++    def __getitem__(self, which):
++        return getattr(self, which)()
++
++
++N = 3
++args = {'w1': 1, "w2": 2}
++TESTTIMES = np.linspace(0.001, 1.0, 10)
++
++
++def _real(t, args):
++    return np.sin(t*args['w1'])
++
++
++def _cplx(t, args):
++    return np.exp(1j*t*args['w2'])
++
++
++real_qevo = Pseudo_qevo(
++    rand_stochastic(N).to(_data.CSR),
++    rand_stochastic(N).to(_data.CSR),
++    _real, "sin(t*w1)", args)
++
++herm_qevo = Pseudo_qevo(
++    rand_herm(N).to(_data.Dense),
++    rand_herm(N).to(_data.Dense),
++    _real, "sin(t*w1)", args)
++
++cplx_qevo = Pseudo_qevo(
++    rand_stochastic(N).to(_data.Dense),
++    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
++    _cplx, "exp(1j*t*w2)", args)
++
++
++@pytest.fixture(params=['func_coeff', 'string',
++                        'array', 'logarray', 'func_call'])
++def coeff_type(request):
++    # all available QobjEvo types
++    return request.param
++
++
++@pytest.fixture(params=[
++    pytest.param(real_qevo, id="real"),
++    pytest.param(herm_qevo, id="hermitian"),
++    pytest.param(cplx_qevo, id="complex"),
++])
++def pseudo_qevo(request):
++    return request.param
++
++
++@pytest.fixture
++def all_qevo(pseudo_qevo, coeff_type):
++    return QobjEvo(*pseudo_qevo[coeff_type])
++
++
++@pytest.fixture
++def other_qevo(all_qevo):
++    return all_qevo
++
++
++def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
++    for t in TESTTIMES:
++        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
++
++
++def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
++    assert obj1.dims == obj2.dims
++    assert obj1.shape == obj2.shape
++    assert obj1.type == obj2.type
++    assert _data.iszero((obj1 - obj2).data, tol)
++
++
++def _assert_qobjevo_different(obj1, obj2):
++    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
++
++
++def _div(a, b):
++    return a / b
++
++
++def test_call(pseudo_qevo, coeff_type):
++    # test creation of QobjEvo and call
++    qevo = QobjEvo(*pseudo_qevo[coeff_type])
++    assert isinstance(qevo(0), Qobj)
++    assert qevo.isoper
++    assert not qevo.isconstant
++    assert not qevo.issuper
++    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
++
++
++# Test the QobjEvo.__repr__()
++def test_QobjEvo_repr():
++    # case_n: cases with Objects of QobjEvo with unique __repr__
++    # expected_repr_n: are the Expected result from the __repr__
++
++    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
++    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
++    expected_repr_1 += 'type = oper, superrep = None, '
++    expected_repr_1 += 'isconstant = False, num_elements = 1'
++    assert case_1 == expected_repr_1
++
++    case_2 = repr(QobjEvo(qeye(2)))
++    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
++    expected_repr_2 += 'type = oper, superrep = None, '
++    expected_repr_2 += 'isconstant = True, num_elements = 1'
++    assert case_2 == expected_repr_2
++
++    case_3 = repr(QobjEvo(basis(5, 2)))
++    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
++    expected_repr_3 += 'type = ket, superrep = None, '
++    expected_repr_3 += 'isconstant = True, num_elements = 1'
++    assert case_3 == expected_repr_3
++
++    X = sigmax()
++    S = spre(X) * spost(X.dag())
++    case_4 = repr(QobjEvo(to_choi(S)))
++    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
++    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
++    expected_repr_4 += 'isconstant = True, num_elements = 1'
++    assert case_4 == expected_repr_4
++
++    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
++                           [qeye(4), lambda t: t]], compress=False))
++    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
++    expected_repr_5 += 'type = oper, superrep = None, '
++    expected_repr_5 += 'isconstant = False, num_elements = 2'
++    assert case_5 == expected_repr_5
++
++
++@pytest.mark.parametrize('coeff_type',
++                         ['func_coeff', 'string', 'array', 'logarray'])
++def test_product_coeff(pseudo_qevo, coeff_type):
++    # test creation of QobjEvo with Qobj * Coefficient
++    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
++    base = pseudo_qevo[coeff_type]
++    cte, [qobj, coeff] = base[0]
++    args = base[1] if len(base) >= 2 else {}
++    tlist = base[2] if len(base) >= 3 else None
++    coeff = coefficient(coeff, args=args, tlist=tlist)
++    created = cte + qobj * coeff
++    _assert_qobjevo_equivalent(pseudo_qevo, created)
++
++def test_copy(all_qevo):
++    qevo = all_qevo
++    copy = qevo.copy()
++    _assert_qobjevo_equivalent(copy, qevo)
++    assert copy is not qevo
++
++
++@pytest.mark.parametrize('bin_op', [
++    pytest.param(lambda a, b: a + b, id="add"),
++    pytest.param(lambda a, b: a - b, id="sub"),
++    pytest.param(lambda a, b: a * b, id="mul"),
++    pytest.param(lambda a, b: a @ b, id="matmul"),
++    pytest.param(lambda a, b: a & b, id="tensor"),
++])
++def test_binopt(all_qevo, other_qevo, bin_op):
++    "QobjEvo arithmetic"
++    obj1 = all_qevo
++    obj2 = other_qevo
++    for t in TESTTIMES:
++        as_qevo = bin_op(obj1, obj2)(t)
++        as_qobj = bin_op(obj1(t), obj2(t))
++        _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++
++@pytest.mark.parametrize('bin_op', [
++    pytest.param(operator.iadd, id="add"),
++    pytest.param(operator.isub, id="sub"),
++    pytest.param(operator.imul, id="mul"),
++    pytest.param(operator.imatmul, id="matmul"),
++    pytest.param(operator.iand, id="tensor"),
++])
++def test_binopt_inplace(all_qevo, other_qevo, bin_op):
++    obj1 = all_qevo
++    obj2 = other_qevo
++    for t in TESTTIMES:
++        as_qevo = bin_op(obj1.copy(), obj2)(t)
++        as_qobj = bin_op(obj1(t).copy(), obj2(t))
++        _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++
++@pytest.mark.parametrize('bin_op', [
++    pytest.param(lambda a, b: a + b, id="add"),
++    pytest.param(lambda a, b: a - b, id="sub"),
++    pytest.param(lambda a, b: a * b, id="mul"),
++    pytest.param(lambda a, b: a @ b, id="matmul"),
++    pytest.param(lambda a, b: a & b, id="tensor"),
++])
++def test_binopt_qobj(all_qevo, bin_op):
++    "QobjEvo arithmetic"
++    obj = all_qevo
++    qobj = rand_herm(N)
++    for t in TESTTIMES:
++        as_qevo = bin_op(obj, qobj)(t)
++        as_qobj = bin_op(obj(t), qobj)
++        _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++        as_qevo = bin_op(qobj, obj)(t)
++        as_qobj = bin_op(qobj, obj(t))
++        _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++
++@pytest.mark.parametrize('bin_op', [
++    pytest.param(lambda a, b: a + b, id="add"),
++    pytest.param(lambda a, b: a - b, id="sub"),
++    pytest.param(lambda a, b: a * b, id="mul"),
++    pytest.param(_div, id="div"),
++])
++def test_binopt_scalar(all_qevo, bin_op):
++    "QobjEvo arithmetic"
++    obj = all_qevo
++    scalar = 0.5 + 1j
++    for t in TESTTIMES:
++        as_qevo = bin_op(obj, scalar)(t)
++        as_qobj = bin_op(obj(t), scalar)
++        _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++        if bin_op is not _div:
++            as_qevo = bin_op(scalar, obj)(t)
++            as_qobj = bin_op(scalar, obj(t))
++            _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++
++def binop_coeff(all_qevo):
++    obj = all_qevo
++    coeff = coeffient("t")
++    created = obj * coeff_t
++    for t in TESTTIMES:
++        _assert_qobj_almost_eq(created(t), obj(t) * t)
++
++
++@pytest.mark.parametrize('unary_op', [
++    pytest.param(lambda a: a.conj(), id="conj"),
++    pytest.param(lambda a: a.dag(), id="dag"),
++    pytest.param(lambda a: a.trans(), id="trans"),
++    pytest.param(lambda a: -a, id="neg"),
++])
++def test_unary(all_qevo, unary_op):
++    "QobjEvo arithmetic"
++    obj = all_qevo
++    for t in TESTTIMES:
++        as_qevo = unary_op(obj)(t)
++        as_qobj = unary_op(obj(t))
++        _assert_qobj_almost_eq(as_qevo, as_qobj)
++
++
++@pytest.mark.parametrize('args_coeff_type',
++                         ['func_coeff', 'string', 'func_call'])
++def test_args(pseudo_qevo, args_coeff_type):
++    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
++    args = {'w1': 3, "w2": 3}
++
++    for t in TESTTIMES:
++        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
++        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
++
++    # Did it modify original args
++    _assert_qobjevo_equivalent(obj, pseudo_qevo)
++
++    obj.arguments(args)
++    _assert_qobjevo_different(obj, pseudo_qevo)
++    for t in TESTTIMES:
++        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
++
++    args = {'w1': 4, "w2": 4}
++    obj.arguments(**args)
++    _assert_qobjevo_different(obj, pseudo_qevo)
++    for t in TESTTIMES:
++        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
++
++
++def test_copy_side_effects(all_qevo):
++    t = 0.2
++    qevo = all_qevo
++    copy = qevo.copy()
++    before = qevo(t)
++    # Ensure inplace modification of the copy do not affect the original
++    copy *= 2
++    copy += rand_herm(N)
++    copy *= rand_herm(N)
++    copy.arguments({'w1': 3, "w2": 3})
++    after = qevo(t)
++    _assert_qobj_almost_eq(before, after)
++
++
++@pytest.mark.parametrize('coeff_type',
++    ['func_coeff', 'string', 'array', 'logarray']
++)
++def test_tidyup(all_qevo):
++    "QobjEvo tidyup"
++    obj = all_qevo
++    obj *= 1e-12
++    obj.tidyup(atol=1e-8)
++    t = 0.2
++    # check that the Qobj are cleaned
++    assert_allclose(obj(t).full(), 0)
++
++
++def test_QobjEvo_pickle(all_qevo):
++    "QobjEvo pickle"
++    # used in parallel_map
++    import pickle
++    obj = all_qevo
++    pickled = pickle.dumps(obj, -1)
++    recreated = pickle.loads(pickled)
++    _assert_qobjevo_equivalent(recreated, obj)
++
++
++def test_QobjEvo_restore(all_qevo):
++    "QobjEvo pickle"
++    # used in parallel_map
++    obj = all_qevo
++    state = obj._getstate()
++    recreated = QobjEvo._restore(**state)
++    _assert_qobjevo_equivalent(recreated, obj)
++
++
++def test_mul_vec(all_qevo):
++    "QobjEvo matmul ket"
++    vec = Qobj(np.arange(N)*.5+.5j)
++    op = all_qevo
++    for t in TESTTIMES:
++        assert_allclose((op(t) @ vec).full(),
++                        op.matmul(t, vec).full(), atol=1e-14)
++
++
++def test_matmul(all_qevo):
++    "QobjEvo matmul oper"
++    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
++    matDense = Qobj(mat).to(_data.Dense)
++    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
++    matCSR = Qobj(mat).to(_data.CSR)
++    op = all_qevo
++    for t in TESTTIMES:
++        Qo1 = op(t)
++        assert_allclose((Qo1 @ mat).full(),
++                        op.matmul(t, matF).full(), atol=1e-14)
++        assert_allclose((Qo1 @ mat).full(),
++                        op.matmul(t, matDense).full(), atol=1e-14)
++        assert_allclose((Qo1 @ mat).full(),
++                        op.matmul(t, matCSR).full(), atol=1e-14)
++
++
++def test_expect_psi(all_qevo):
++    "QobjEvo expect psi"
++    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
++    qobj = Qobj(vec)
++    op = all_qevo
++    for t in TESTTIMES:
++        Qo1 = op(t)
++        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
++                        atol=1e-14)
++
++
++def test_expect_rho(all_qevo):
++    "QobjEvo expect rho"
++    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
++                                      + 1j * np.random.rand(N*N))
++    mat = _data.column_unstack_dense(vec, N)
++    qobj = Qobj(mat)
++    op = liouvillian(all_qevo)
++    for t in TESTTIMES:
++        Qo1 = op(t)
++        assert abs(_data.expect_super(Qo1.data, vec)
++                   - op.expect(t, qobj)) < 1e-14
++
++
++@pytest.mark.parametrize('dtype',
++[pytest.param(dtype, id=dtype.__name__)
++     for dtype in _data.to.dtypes])
++def test_convert(all_qevo, dtype):
++    "QobjEvo expect rho"
++    op = all_qevo.to(dtype)
++    assert isinstance(op(0.5).data, dtype)
++
++
++def test_compress():
++    "QobjEvo compress"
++    obj1 = QobjEvo(
++        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
++    assert obj1.num_elements == 1
++    obj2 = QobjEvo(
++        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
++    assert obj2.num_elements == 3
++    _assert_qobjevo_equivalent(obj1, obj2)
++    obj3 = obj2.copy()
++    assert obj3.num_elements == 3
++    obj3.compress()
++    assert obj3.num_elements == 1
++    _assert_qobjevo_equivalent(obj2, obj3)
++
++
++@pytest.mark.parametrize(['qobjdtype'],
++    [pytest.param(dtype, id=dtype.__name__)
++     for dtype in _data.to.dtypes])
++@pytest.mark.parametrize(['statedtype'],
++    [pytest.param(dtype, id=dtype.__name__)
++     for dtype in _data.to.dtypes])
++def test_layer_support(qobjdtype, statedtype):
++    N = 10
++    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
++    state_dense = rand_ket(N).to(_data.Dense)
++    state = state_dense.to(statedtype).data
++    state_dense = state_dense.data
++    exp_any = qevo.expect_data(0, state)
++    exp_dense = qevo.expect_data(0, state_dense)
++    assert_allclose(exp_any, exp_dense)
++    mul_any = qevo.matmul_data(0, state).to_array()
++    mul_dense = qevo.matmul_data(0, state_dense).to_array()
++    assert_allclose(mul_any, mul_dense)
++
++
++def test_QobjEvo_step_coeff():
++    "QobjEvo step interpolation"
++    coeff1 = np.random.rand(6)
++    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
++    # uniform t
++    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
++    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
++                      tlist=tlist, order=0)
++    assert qobjevo(2.0)[0,0] == coeff1[0]
++    assert qobjevo(7.0)[0,0] == coeff1[5]
++    assert qobjevo(5.0001)[0,0] == coeff1[3]
++    assert qobjevo(3.9999)[0,0] == coeff1[1]
++
++    assert qobjevo(2.0)[0,1] == coeff2[0]
++    assert qobjevo(7.0)[0,1] == coeff2[5]
++    assert qobjevo(5.0001)[0,1] == coeff2[3]
++    assert qobjevo(3.9999)[0,1] == coeff2[1]
++
++    # non-uniform t
++    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
++    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
++        tlist=tlist, order=0)
++    assert qobjevo(1.0)[0,0] == coeff1[0]
++    assert qobjevo(8.0)[0,0] == coeff1[5]
++    assert qobjevo(3.9999)[0,0] == coeff1[1]
++    assert qobjevo(4.23)[0,0] == coeff1[2]
++    assert qobjevo(1.23)[0,0] == coeff1[0]
++
++    assert qobjevo(1.0)[0,1] == coeff2[0]
++    assert qobjevo(8.0)[0,1] == coeff2[5]
++    assert qobjevo(6.7)[0,1] == coeff2[4]
++    assert qobjevo(7.9999)[0,1] == coeff2[4]
++    assert qobjevo(3.9999)[0,1] == coeff2[1]
++
++
++def test_QobjEvo_isherm_flag_knowcase():
++    assert QobjEvo(sigmax())(0)._isherm is True
++    non_hermitian = sigmax() + 1j
++    non_hermitian.isherm  # set flag
++    assert QobjEvo(non_hermitian)(0)._isherm is False
++    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
++    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
++    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
++    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
++    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
++
++
++@pytest.mark.parametrize(
++    "coeff_type",
++    ['func_coeff', 'string', 'array', 'logarray']
++)
++def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
++    qevo = QobjEvo(*pseudo_qevo[coeff_type])
++    as_list = qevo.to_list()
++    assert len(as_list) == 2
++    restored = QobjEvo(as_list)
++    _assert_qobjevo_equivalent(qevo, restored)
+diff --git a/qutip/tests/core/test_states.py b/qutip/tests/core/test_states.py
+index be17941d..edacd7d6 100644
+--- a/qutip/tests/core/test_states.py
++++ b/qutip/tests/core/test_states.py
+@@ -1,318 +1,318 @@
+-import pytest
+-import numpy as np
+-import qutip
+-from functools import partial
+-from itertools import combinations
+-
+-
+-@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
+-def test_basis_simple(size, n):
+-    qobj = qutip.basis(size, n)
+-    numpy = np.zeros((size, 1), dtype=complex)
+-    numpy[n, 0] = 1
+-    assert np.array_equal(qobj.full(), numpy)
+-
+-
+-@pytest.mark.parametrize("to_test", [
+-    qutip.basis, qutip.fock, qutip.fock_dm,
+-])
+-@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
+-def test_implicit_tensor_basis_like(to_test, size, n):
+-    implicit = to_test(size, n)
+-    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
+-    assert implicit == explicit
+-
+-
+-@pytest.mark.parametrize("size, n, offset, msg", [
+-    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
+-    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
+-    (-1, 0, 0, "All dimensions must be >= 0."),
+-    (1.5, 0, 0, "All dimensions must be >= 0."),
+-    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
+-    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
+-], ids=["n too long", "offset too long", "neg dims",
+-        "fraction dims", "n too large", "n too small"]
+-)
+-def test_basis_error(size, n, offset, msg):
+-    with pytest.raises(ValueError) as e:
+-        qutip.basis(size, n, offset)
+-    assert str(e.value) == msg
+-
+-
+-def test_basis_error_type():
+-    with pytest.raises(TypeError) as e:
+-        qutip.basis(5, 3.5)
+-    assert str(e.value) == ("Dimensions must be an integer "
+-                            "or list of integers.")
+-
+-
+-@pytest.mark.parametrize("size, n, m", [
+-        ([2, 2], [0, 0], [1, 1]),
+-        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
+-    ])
+-def test_implicit_tensor_projection(size, n, m):
+-    implicit = qutip.projection(size, n, m)
+-    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
+-                              for ss, nn, mm in zip(size, n, m)])
+-    assert implicit == explicit
+-
+-
+-@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
+-    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
+-                 id="basis"),
+-    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
+-                 id="basis,offset"),
+-    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
+-                 id="fock"),
+-    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
+-                 id="fock_dm"),
+-    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
+-                 id="fock_dm,offset"),
+-    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
+-                 id="coherent"),
+-    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
+-                 id="coherent,offset"),
+-    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
+-                 id="coherent_dm"),
+-    pytest.param(qutip.phase_basis, qutip.phase,
+-                 (10, 3), (10,), 3 * 2 * np.pi / 10,
+-                 id="phase_basis"),
+-    pytest.param(qutip.phase_basis, qutip.phase,
+-                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
+-                 id="phase_basis,phi0"),
+-    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
+-                 id="spin_state"),
+-    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
+-                 id="zero_ket"),
+-])
+-def test_diverse_basis(base, operator, args, opargs, eigenval):
+-    # For state which are supposed to eigenvector of an operator
+-    # Verify that correspondance
+-    state = base(*args)
+-    oper = operator(*opargs)
+-    assert qutip.expect(oper, state) == pytest.approx(eigenval)
+-
+-
+-@pytest.mark.parametrize('dm', [
+-    partial(qutip.thermal_dm, n=1.),
+-    qutip.maximally_mixed_dm,
+-    partial(qutip.coherent_dm, alpha=0.5),
+-    partial(qutip.fock_dm, n=1),
+-    partial(qutip.spin_state, m=2, type='dm'),
+-    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
+-], ids=[
+-    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
+-    'fock_dm', 'spin_state', 'spin_coherent'
+-])
+-def test_dm(dm):
+-    N = 5
+-    rho = dm(N)
+-    # make sure rho has trace close to 1.0
+-    assert rho.tr() == pytest.approx(1.0)
+-
+-
+-def test_CoherentState():
+-    N = 10
+-    alpha = 0.5
+-    c1 = qutip.coherent(N, alpha)  # displacement method
+-    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
+-    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
+-    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
+-    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
+-    with pytest.raises(TypeError) as e:
+-        qutip.coherent(N, alpha, method="other")
+-    assert all(method in str(e.value) for method in ["operator", "analytic"])
+-    with pytest.raises(ValueError) as e:
+-        qutip.coherent(N, alpha, offset=-1)
+-    assert str(e.value) == ("Offset must be non-negative")
+-    with pytest.raises(ValueError) as e:
+-        qutip.coherent(N, alpha, offset=1, method="operator")
+-    assert str(e.value) == (
+-        "The method 'operator' does not support offset != 0. Please"
+-        " select another method or set the offset to zero."
+-    )
+-
+-
+-def test_CoherentDensityMatrix():
+-    N = 10
+-    rho = qutip.coherent_dm(N, 1)
+-    assert rho.tr() == pytest.approx(1.0)
+-    with pytest.raises(TypeError) as e:
+-        qutip.coherent_dm(N, 1, method="other")
+-    assert all(method in str(e.value) for method in ["operator", "analytic"])
+-    with pytest.raises(ValueError) as e:
+-        qutip.coherent_dm(N, 1, offset=-1)
+-    assert str(e.value) == ("Offset must be non-negative")
+-    with pytest.raises(ValueError) as e:
+-        qutip.coherent_dm(N, 1, offset=1, method="operator")
+-    assert str(e.value) == (
+-        "The method 'operator' does not support offset != 0. Please"
+-        " select another method or set the offset to zero."
+-    )
+-
+-
+-def test_thermal():
+-    N = 10
+-    beta = 0.5
+-    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
+-
+-    thermal_operator = qutip.thermal_dm(N, beta)
+-    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
+-    np.testing.assert_allclose(thermal_operator.full(),
+-                               thermal_analytic.full(), atol=2e-5)
+-
+-    with pytest.raises(ValueError) as e:
+-        qutip.thermal_dm(N, beta, method="other")
+-    assert all(method in str(e.value) for method in ["operator", "analytic"])
+-
+-
+-@pytest.mark.parametrize('func', [
+-    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
+-])
+-def test_spin_output(func):
+-    assert qutip.isket(func(1.0, 0, type='ket'))
+-    assert qutip.isbra(func(1.0, 0, type='bra'))
+-    assert qutip.isoper(func(1.0, 0, type='dm'))
+-
+-    with pytest.raises(ValueError) as e:
+-        func(1.0, 0, type='something')
+-    assert str(e.value).startswith("Invalid value keyword argument")
+-
+-
+-@pytest.mark.parametrize('N', [2.5, -1])
+-def test_maximally_mixed_dm_error(N):
+-    with pytest.raises(ValueError) as e:
+-        qutip.maximally_mixed_dm(N)
+-    assert str(e.value) == "N must be integer N > 0"
+-
+-
+-def test_TripletStateNorm():
+-    for triplet in qutip.triplet_states():
+-        assert triplet.norm() == pytest.approx(1.)
+-    for t1, t2 in combinations(qutip.triplet_states(), 2):
+-        assert t1.overlap(t2) == pytest.approx(0.)
+-
+-
+-def test_ket2dm():
+-    N = 5
+-    ket = qutip.coherent(N, 2)
+-    bra = ket.dag()
+-    oper = qutip.ket2dm(ket)
+-    oper_from_bra = qutip.ket2dm(bra)
+-    assert qutip.expect(oper, ket) == pytest.approx(1.)
+-    assert qutip.isoper(oper)
+-    assert oper == ket * bra
+-    assert oper == oper_from_bra
+-    with pytest.raises(TypeError) as e:
+-        qutip.ket2dm(oper)
+-    assert str(e.value) == "Input is not a ket or bra vector."
+-
+-
+-@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
+-def test_qstate(state):
+-    from_basis = qutip.basis([2] * len(state), state)
+-    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
+-    assert from_basis == from_qstate
+-
+-
+-def test_qstate_error():
+-    with pytest.raises(TypeError) as e:
+-        qutip.qstate("eeggg")
+-    assert str(e.value) == ('String input to QSTATE must consist ' +
+-                            'of "u" and "d" elements only')
+-
+-
+-@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
+-def test_bra_ket(state):
+-    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
+-    from_ket = qutip.ket(state)
+-    from_bra = qutip.bra(state).dag()
+-    assert from_basis == from_ket
+-    assert from_basis == from_bra
+-
+-
+-def test_w_states():
+-    state = (
+-        qutip.qstate("uddd") +
+-        qutip.qstate("dudd") +
+-        qutip.qstate("ddud") +
+-        qutip.qstate("dddu")
+-    ) / 2
+-    assert state == qutip.w_state(4)
+-
+-
+-def test_ghz_states():
+-    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
+-    assert state == qutip.ghz_state(3)
+-
+-
+-def test_bell_state():
+-    states = [
+-        qutip.bell_state('00'),
+-        qutip.bell_state('01'),
+-        qutip.bell_state('10'),
+-        qutip.bell_state('11')
+-    ]
+-    exited = qutip.basis([2, 2], [1, 1])
+-    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
+-        assert state.norm() == pytest.approx(1.0)
+-        assert state.overlap(exited) == pytest.approx(overlap)
+-
+-    for state1, state2 in combinations(states, 2):
+-        assert state1.overlap(state2) == pytest.approx(0.0)
+-
+-    assert qutip.singlet_state() == qutip.bell_state('11')
+-
+-
+-def _id_func(val):
+-    "ids generated from the function only"
+-    if isinstance(val, tuple):
+-        return ""
+-
+-
+-# random object accept `str` and base.Data
+-# Obtain all valid dtype from `to`
+-dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
+-dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
+-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+-                         ids=[str(dtype) for dtype in dtype_names])
+-@pytest.mark.parametrize(['func', 'args'], [
+-    (qutip.basis, (5, 1)),
+-    (qutip.fock, (5, 1)),
+-    (qutip.fock_dm, (5, 1)),
+-    (qutip.coherent, (5, 1)),
+-    (qutip.coherent_dm, (5, 1)),
+-    (qutip.thermal_dm, (5, 1)),
+-    (qutip.maximally_mixed_dm, (5,)),
+-    (qutip.phase_basis, (5, 1)),
+-    (qutip.zero_ket, (5,)),
+-    (qutip.spin_state, (5, 1)),
+-    (qutip.spin_coherent, (5, 1, 0.5)),
+-    (qutip.projection, (5, 1, 2)),
+-    (qutip.ket, ("001",)),
+-    (qutip.bra, ('010',)),
+-    (qutip.qstate, ("uud",)),
+-    (qutip.w_state, (5,)),
+-    (qutip.ghz_state, (5,)),
+-    (qutip.qutrit_basis, ()),
+-    (qutip.triplet_states, ()),
+-    (qutip.singlet_state, ()),
+-    (qutip.bell_state, ('10',)),
+-    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
+-    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
+-], ids=_id_func)
+-def test_state_type(func, args, alias, dtype):
+-    object = func(*args, dtype=alias)
+-    if isinstance(object, qutip.Qobj):
+-        assert isinstance(object.data, dtype)
+-    else:
+-        for obj in object:
+-            assert isinstance(obj.data, dtype)
+-
+-    with qutip.CoreOptions(default_dtype=alias):
+-        object = func(*args)
+-        if isinstance(object, qutip.Qobj):
+-            assert isinstance(object.data, dtype)
+-        else:
+-            for obj in object:
+-                assert isinstance(obj.data, dtype)
++import pytest
++import numpy as np
++import qutip
++from functools import partial
++from itertools import combinations
++
++
++@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
++def test_basis_simple(size, n):
++    qobj = qutip.basis(size, n)
++    numpy = np.zeros((size, 1), dtype=complex)
++    numpy[n, 0] = 1
++    assert np.array_equal(qobj.full(), numpy)
++
++
++@pytest.mark.parametrize("to_test", [
++    qutip.basis, qutip.fock, qutip.fock_dm,
++])
++@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
++def test_implicit_tensor_basis_like(to_test, size, n):
++    implicit = to_test(size, n)
++    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
++    assert implicit == explicit
++
++
++@pytest.mark.parametrize("size, n, offset, msg", [
++    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
++    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
++    (-1, 0, 0, "All dimensions must be >= 0."),
++    (1.5, 0, 0, "All dimensions must be >= 0."),
++    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
++    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
++], ids=["n too long", "offset too long", "neg dims",
++        "fraction dims", "n too large", "n too small"]
++)
++def test_basis_error(size, n, offset, msg):
++    with pytest.raises(ValueError) as e:
++        qutip.basis(size, n, offset)
++    assert str(e.value) == msg
++
++
++def test_basis_error_type():
++    with pytest.raises(TypeError) as e:
++        qutip.basis(5, 3.5)
++    assert str(e.value) == ("Dimensions must be an integer "
++                            "or list of integers.")
++
++
++@pytest.mark.parametrize("size, n, m", [
++        ([2, 2], [0, 0], [1, 1]),
++        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
++    ])
++def test_implicit_tensor_projection(size, n, m):
++    implicit = qutip.projection(size, n, m)
++    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
++                              for ss, nn, mm in zip(size, n, m)])
++    assert implicit == explicit
++
++
++@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
++    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
++                 id="basis"),
++    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
++                 id="basis,offset"),
++    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
++                 id="fock"),
++    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
++                 id="fock_dm"),
++    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
++                 id="fock_dm,offset"),
++    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
++                 id="coherent"),
++    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
++                 id="coherent,offset"),
++    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
++                 id="coherent_dm"),
++    pytest.param(qutip.phase_basis, qutip.phase,
++                 (10, 3), (10,), 3 * 2 * np.pi / 10,
++                 id="phase_basis"),
++    pytest.param(qutip.phase_basis, qutip.phase,
++                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
++                 id="phase_basis,phi0"),
++    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
++                 id="spin_state"),
++    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
++                 id="zero_ket"),
++])
++def test_diverse_basis(base, operator, args, opargs, eigenval):
++    # For state which are supposed to eigenvector of an operator
++    # Verify that correspondance
++    state = base(*args)
++    oper = operator(*opargs)
++    assert qutip.expect(oper, state) == pytest.approx(eigenval)
++
++
++@pytest.mark.parametrize('dm', [
++    partial(qutip.thermal_dm, n=1.),
++    qutip.maximally_mixed_dm,
++    partial(qutip.coherent_dm, alpha=0.5),
++    partial(qutip.fock_dm, n=1),
++    partial(qutip.spin_state, m=2, type='dm'),
++    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
++], ids=[
++    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
++    'fock_dm', 'spin_state', 'spin_coherent'
++])
++def test_dm(dm):
++    N = 5
++    rho = dm(N)
++    # make sure rho has trace close to 1.0
++    assert rho.tr() == pytest.approx(1.0)
++
++
++def test_CoherentState():
++    N = 10
++    alpha = 0.5
++    c1 = qutip.coherent(N, alpha)  # displacement method
++    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
++    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
++    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
++    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
++    with pytest.raises(TypeError) as e:
++        qutip.coherent(N, alpha, method="other")
++    assert all(method in str(e.value) for method in ["operator", "analytic"])
++    with pytest.raises(ValueError) as e:
++        qutip.coherent(N, alpha, offset=-1)
++    assert str(e.value) == ("Offset must be non-negative")
++    with pytest.raises(ValueError) as e:
++        qutip.coherent(N, alpha, offset=1, method="operator")
++    assert str(e.value) == (
++        "The method 'operator' does not support offset != 0. Please"
++        " select another method or set the offset to zero."
++    )
++
++
++def test_CoherentDensityMatrix():
++    N = 10
++    rho = qutip.coherent_dm(N, 1)
++    assert rho.tr() == pytest.approx(1.0)
++    with pytest.raises(TypeError) as e:
++        qutip.coherent_dm(N, 1, method="other")
++    assert all(method in str(e.value) for method in ["operator", "analytic"])
++    with pytest.raises(ValueError) as e:
++        qutip.coherent_dm(N, 1, offset=-1)
++    assert str(e.value) == ("Offset must be non-negative")
++    with pytest.raises(ValueError) as e:
++        qutip.coherent_dm(N, 1, offset=1, method="operator")
++    assert str(e.value) == (
++        "The method 'operator' does not support offset != 0. Please"
++        " select another method or set the offset to zero."
++    )
++
++
++def test_thermal():
++    N = 10
++    beta = 0.5
++    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
++
++    thermal_operator = qutip.thermal_dm(N, beta)
++    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
++    np.testing.assert_allclose(thermal_operator.full(),
++                               thermal_analytic.full(), atol=2e-5)
++
++    with pytest.raises(ValueError) as e:
++        qutip.thermal_dm(N, beta, method="other")
++    assert all(method in str(e.value) for method in ["operator", "analytic"])
++
++
++@pytest.mark.parametrize('func', [
++    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
++])
++def test_spin_output(func):
++    assert qutip.isket(func(1.0, 0, type='ket'))
++    assert qutip.isbra(func(1.0, 0, type='bra'))
++    assert qutip.isoper(func(1.0, 0, type='dm'))
++
++    with pytest.raises(ValueError) as e:
++        func(1.0, 0, type='something')
++    assert str(e.value).startswith("Invalid value keyword argument")
++
++
++@pytest.mark.parametrize('N', [2.5, -1])
++def test_maximally_mixed_dm_error(N):
++    with pytest.raises(ValueError) as e:
++        qutip.maximally_mixed_dm(N)
++    assert str(e.value) == "N must be integer N > 0"
++
++
++def test_TripletStateNorm():
++    for triplet in qutip.triplet_states():
++        assert triplet.norm() == pytest.approx(1.)
++    for t1, t2 in combinations(qutip.triplet_states(), 2):
++        assert t1.overlap(t2) == pytest.approx(0.)
++
++
++def test_ket2dm():
++    N = 5
++    ket = qutip.coherent(N, 2)
++    bra = ket.dag()
++    oper = qutip.ket2dm(ket)
++    oper_from_bra = qutip.ket2dm(bra)
++    assert qutip.expect(oper, ket) == pytest.approx(1.)
++    assert qutip.isoper(oper)
++    assert oper == ket * bra
++    assert oper == oper_from_bra
++    with pytest.raises(TypeError) as e:
++        qutip.ket2dm(oper)
++    assert str(e.value) == "Input is not a ket or bra vector."
++
++
++@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
++def test_qstate(state):
++    from_basis = qutip.basis([2] * len(state), state)
++    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
++    assert from_basis == from_qstate
++
++
++def test_qstate_error():
++    with pytest.raises(TypeError) as e:
++        qutip.qstate("eeggg")
++    assert str(e.value) == ('String input to QSTATE must consist ' +
++                            'of "u" and "d" elements only')
++
++
++@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
++def test_bra_ket(state):
++    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
++    from_ket = qutip.ket(state)
++    from_bra = qutip.bra(state).dag()
++    assert from_basis == from_ket
++    assert from_basis == from_bra
++
++
++def test_w_states():
++    state = (
++        qutip.qstate("uddd") +
++        qutip.qstate("dudd") +
++        qutip.qstate("ddud") +
++        qutip.qstate("dddu")
++    ) / 2
++    assert state == qutip.w_state(4)
++
++
++def test_ghz_states():
++    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
++    assert state == qutip.ghz_state(3)
++
++
++def test_bell_state():
++    states = [
++        qutip.bell_state('00'),
++        qutip.bell_state('01'),
++        qutip.bell_state('10'),
++        qutip.bell_state('11')
++    ]
++    exited = qutip.basis([2, 2], [1, 1])
++    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
++        assert state.norm() == pytest.approx(1.0)
++        assert state.overlap(exited) == pytest.approx(overlap)
++
++    for state1, state2 in combinations(states, 2):
++        assert state1.overlap(state2) == pytest.approx(0.0)
++
++    assert qutip.singlet_state() == qutip.bell_state('11')
++
++
++def _id_func(val):
++    "ids generated from the function only"
++    if isinstance(val, tuple):
++        return ""
++
++
++# random object accept `str` and base.Data
++# Obtain all valid dtype from `to`
++dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
++dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
++@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
++                         ids=[str(dtype) for dtype in dtype_names])
++@pytest.mark.parametrize(['func', 'args'], [
++    (qutip.basis, (5, 1)),
++    (qutip.fock, (5, 1)),
++    (qutip.fock_dm, (5, 1)),
++    (qutip.coherent, (5, 1)),
++    (qutip.coherent_dm, (5, 1)),
++    (qutip.thermal_dm, (5, 1)),
++    (qutip.maximally_mixed_dm, (5,)),
++    (qutip.phase_basis, (5, 1)),
++    (qutip.zero_ket, (5,)),
++    (qutip.spin_state, (5, 1)),
++    (qutip.spin_coherent, (5, 1, 0.5)),
++    (qutip.projection, (5, 1, 2)),
++    (qutip.ket, ("001",)),
++    (qutip.bra, ('010',)),
++    (qutip.qstate, ("uud",)),
++    (qutip.w_state, (5,)),
++    (qutip.ghz_state, (5,)),
++    (qutip.qutrit_basis, ()),
++    (qutip.triplet_states, ()),
++    (qutip.singlet_state, ()),
++    (qutip.bell_state, ('10',)),
++    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
++    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
++], ids=_id_func)
++def test_state_type(func, args, alias, dtype):
++    object = func(*args, dtype=alias)
++    if isinstance(object, qutip.Qobj):
++        assert isinstance(object.data, dtype)
++    else:
++        for obj in object:
++            assert isinstance(obj.data, dtype)
++
++    with qutip.CoreOptions(default_dtype=alias):
++        object = func(*args)
++        if isinstance(object, qutip.Qobj):
++            assert isinstance(object.data, dtype)
++        else:
++            for obj in object:
++                assert isinstance(obj.data, dtype)
+diff --git a/qutip/tests/core/test_superop_reps.py b/qutip/tests/core/test_superop_reps.py
+index 31c538d1..7e04579c 100644
+--- a/qutip/tests/core/test_superop_reps.py
++++ b/qutip/tests/core/test_superop_reps.py
+@@ -1,347 +1,347 @@
+-# -*- coding: utf-8 -*-
+-"""
+-Created on Wed May 29 11:23:46 2013
+-
+-@author: dcriger
+-"""
+-
+-from __future__ import division
+-
+-import numpy as np
+-import pytest
+-
+-from qutip import (
+-    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
+-    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
+-    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
+-    vector_to_operator, sprepost, destroy
+-)
+-from qutip.core.gates import swap
+-
+-
+-tol = 1e-8
+-
+-
+-def assert_kraus_equivalence(a, b, tol=tol):
+-    assert a.shape == b.shape
+-    assert a.dims == b.dims
+-    assert a.type == b.type
+-    # Kraus operators may vary by a global phase.  Let's find the first
+-    # non-zero element, set the phase such that that element has the same phase
+-    # in both, and then compare.  We have to take care to find the first
+-    # element.
+-    a, b = a.full(), b.full()
+-    a_nz = np.nonzero(np.abs(a) > tol)
+-    if len(a_nz[0]) == 0:
+-        np.testing.assert_allclose(b, 0, atol=tol)
+-    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
+-    assert b_el != 0
+-    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
+-    np.testing.assert_allclose(a, b)
+-
+-
+-@pytest.fixture(scope="function", params=[2, 3, 7])
+-def dimension(request):
+-    # There are also some cases in the file where this fixture is explicitly
+-    # overridden by a more local mark.  That is deliberate.
+-    return request.param
+-
+-
+-@pytest.fixture(scope="function", params=[
+-    pytest.param(rand_super, id="super"),
+-    pytest.param(rand_super_bcsz, id="super_bcz")
+-])
+-def superoperator(request, dimension):
+-    return request.param(dimension)
+-
+-
+-class TestSuperopReps:
+-    """
+-    A test class for the QuTiP function for applying superoperators to
+-    subsystems.
+-    """
+-
+-    def test_SuperChoiSuper(self, superoperator):
+-        """
+-        Superoperator: Converting superoperator to Choi matrix and back.
+-        """
+-        choi_matrix = to_choi(superoperator)
+-        test_supe = to_super(choi_matrix)
+-
+-        # Assert both that the result is close to expected, and has the right
+-        # type.
+-        assert (test_supe - superoperator).norm() < tol
+-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+-        assert test_supe.type == "super" and test_supe.superrep == "super"
+-
+-    @pytest.mark.parametrize('dimension', [2, 4])
+-    def test_SuperChoiChiSuper(self, dimension):
+-        """
+-        Superoperator: Converting two-qubit superoperator through
+-        Choi and chi representations goes back to right superoperator.
+-        """
+-        superoperator = super_tensor(
+-            rand_super(dimension), rand_super(dimension),
+-        )
+-
+-        choi_matrix = to_choi(superoperator)
+-        chi_matrix = to_chi(choi_matrix)
+-        test_supe = to_super(chi_matrix)
+-
+-        # Assert both that the result is close to expected, and has the right
+-        # type.
+-        assert (test_supe - superoperator).norm() < tol
+-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+-        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
+-        assert test_supe.type == "super" and test_supe.superrep == "super"
+-
+-    def test_ChoiKrausChoi(self, superoperator):
+-        """
+-        Superoperator: Convert superoperator to Choi matrix and back.
+-        """
+-        choi_matrix = to_choi(superoperator)
+-        kraus_ops = to_kraus(choi_matrix)
+-        test_choi = kraus_to_choi(kraus_ops)
+-
+-        # Assert both that the result is close to expected, and has the right
+-        # type.
+-        assert (test_choi - choi_matrix).norm() < tol
+-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+-        assert test_choi.type == "super" and test_choi.superrep == "choi"
+-
+-    def test_NonSquareKrausSuperChoi(self):
+-        """
+-        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
+-        and back.
+-        """
+-        zero = np.array([[1], [0]], dtype=complex)
+-        one = np.array([[0], [1]], dtype=complex)
+-        zero_log = np.kron(np.kron(zero, zero), zero)
+-        one_log = np.kron(np.kron(one, one), one)
+-        # non-square Kraus operator (isometry)
+-        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
+-        super = sprepost(kraus, kraus.dag())
+-        choi = to_choi(super)
+-        op1 = to_kraus(super)
+-        op2 = to_kraus(choi)
+-        op3 = to_super(choi)
+-        assert choi.type == "super" and choi.superrep == "choi"
+-        assert super.type == "super" and super.superrep == "super"
+-        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
+-        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
+-        assert abs((op3 - super).norm()) < 1e-8
+-
+-    def test_NeglectSmallKraus(self):
+-        """
+-        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
+-        Kraus operators.
+-        """
+-        zero = np.array([[1], [0]], dtype=complex)
+-        one = np.array([[0], [1]], dtype=complex)
+-        zero_log = np.kron(np.kron(zero, zero), zero)
+-        one_log = np.kron(np.kron(one, one), one)
+-        # non-square Kraus operator (isometry)
+-        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
+-        super = sprepost(kraus, kraus.dag())
+-        # 1 non-zero Kraus operator the rest are zero
+-        sixteen_kraus_ops = to_kraus(super, tol=0.0)
+-        # default is tol=1e-9
+-        one_kraus_op = to_kraus(super)
+-        assert len(sixteen_kraus_ops) == 16
+-        assert len(one_kraus_op) == 1
+-        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
+-
+-    def test_SuperPreservesSelf(self, superoperator):
+-        """
+-        Superoperator: to_super(q) returns q if q is already a
+-        supermatrix.
+-        """
+-
+-        assert superoperator is to_super(superoperator)
+-
+-    def test_ChoiPreservesSelf(self, superoperator):
+-        """
+-        Superoperator: to_choi(q) returns q if q is already Choi.
+-        """
+-        choi = to_choi(superoperator)
+-        assert choi is to_choi(choi)
+-
+-    def test_random_iscptp(self, superoperator):
+-        """
+-        Superoperator: Randomly generated superoperators are
+-        correctly reported as CPTP and HP.
+-        """
+-        assert superoperator.iscptp
+-        assert superoperator.ishp
+-
+-    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
+-        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
+-        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
+-        pytest.param(qeye(2), True, True, True),
+-        pytest.param(sigmax(), True, True, True),
+-        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
+-        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
+-                            + to_super(tensor(qeye(2), sigmay()))),
+-                     True, True, True,
+-                     id="linear combination of bipartite unitaries"),
+-        pytest.param(Qobj(swap(), type='super', superrep='choi'),
+-                     True, False, True,
+-                     id="partial transpose map"),
+-        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
+-                     id="subnormalized map"),
+-        pytest.param(basis(2, 0), False, False, False, id="ket"),
+-    ])
+-    def test_known_iscptp(self, qobj, hp, cp, tp):
+-        """
+-        Superoperator: ishp, iscp, istp and iscptp known cases.
+-        """
+-        assert qobj.ishp == hp
+-        assert qobj.iscp == cp
+-        assert qobj.istp == tp
+-        assert qobj.iscptp == (cp and tp)
+-
+-    def test_choi_tr(self):
+-        """
+-        Superoperator: Trace returned by to_choi matches docstring.
+-        """
+-        for dims in range(2, 5):
+-            assert abs(to_choi(identity(dims)).tr() - dims) < tol
+-
+-
+-    # Conjugation by a creation operator
+-    a = create(2).dag()
+-    S = sprepost(a, a.dag())
+-
+-    # A single off-diagonal element
+-    S_ = sprepost(a, a)
+-
+-    # Check that a linear combination of bipartite unitaries is CPTP and HP.
+-    S_U = (
+-        to_super(tensor(sigmax(), identity(2))) +
+-        to_super(tensor(identity(2), sigmay()))
+-    ) / 2
+-
+-    # The partial transpose map, whose Choi matrix is SWAP
+-    ptr_swap = Qobj(swap(), type='super', superrep='choi')
+-
+-    # Subnormalized maps (representing erasure channels, for instance)
+-    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
+-
+-    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
+-        pytest.param(S, True, True, False, id="conjugatio by create op"),
+-        pytest.param(S_, False, False, False, id="single off-diag"),
+-        pytest.param(identity(2), True, True, True, id="Identity"),
+-        pytest.param(sigmax(), True, True, True, id="Pauli X"),
+-        pytest.param(
+-            tensor(sigmax(), identity(2)), True, True, True,
+-            id="bipartite system",
+-        ),
+-        pytest.param(
+-            S_U, True, True, True, id="linear combination of bip. unitaries",
+-        ),
+-        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
+-        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
+-        pytest.param(basis(2), False, False, False, id="not an operator"),
+-
+-    ])
+-    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
+-        """
+-        Superoperator: ishp, iscp, istp and iscptp known cases.
+-        """
+-        assert qobj.ishp == shouldhp
+-        assert qobj.iscp == shouldcp
+-        assert qobj.istp == shouldtp
+-        assert qobj.iscptp == (shouldcp and shouldtp)
+-
+-    def test_choi_tr(self, dimension):
+-        """
+-        Superoperator: Trace returned by to_choi matches docstring.
+-        """
+-        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
+-
+-    def test_stinespring_cp(self, dimension):
+-        """
+-        Stinespring: A and B match for CP maps.
+-        """
+-        superop = rand_super_bcsz(dimension)
+-        A, B = to_stinespring(superop)
+-
+-        assert (A - B).norm() < tol
+-
+-    @pytest.mark.repeat(3)
+-    def test_stinespring_agrees(self, dimension):
+-        """
+-        Stinespring: Partial Tr over pair agrees w/ supermatrix.
+-        """
+-
+-        map = rand_super_bcsz(dimension)
+-        state = rand_dm(dimension)
+-
+-        S = to_super(map)
+-        A, B = to_stinespring(map)
+-
+-        q1 = vector_to_operator(
+-            S * operator_to_vector(state)
+-        )
+-        # FIXME: problem if Kraus index is implicitly
+-        #        ptraced!
+-        q2 = (A * state * B.dag()).ptrace((0,))
+-
+-        assert (q1 - q2).norm('tr') <= tol
+-
+-    def test_stinespring_dims(self, dimension):
+-        """
+-        Stinespring: Check that dims of channels are preserved.
+-        """
+-        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
+-        A, B = to_stinespring(chan)
+-        assert A.dims == [[2, dimension, 1], [2, dimension]]
+-        assert B.dims == [[2, dimension, 1], [2, dimension]]
+-
+-    @pytest.mark.parametrize('dimension', [2, 4, 8])
+-    def test_chi_choi_roundtrip(self, dimension):
+-
+-        superop = rand_super_bcsz(dimension)
+-        superop = to_chi(superop)
+-        rt_superop = to_chi(to_choi(superop))
+-        dif = (rt_superop - superop).norm()
+-
+-        assert dif == pytest.approx(0, abs=1e-7)
+-        assert rt_superop.type == superop.type
+-        assert rt_superop.dims == superop.dims
+-
+-    chi_sigmax = [
+-        [0, 0, 0, 0],
+-        [0, 4, 0, 0],
+-        [0, 0, 0, 0],
+-        [0, 0, 0, 0]
+-    ]
+-    chi_diag2 = [
+-        [4, 0, 0, 0],
+-        [0, 0, 0, 0],
+-        [0, 0, 0, 0],
+-        [0, 0, 0, 0]
+-    ]
+-    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
+-    chi_rotX_pi_4 = [
+-        [2, 2j, 0, 0],
+-        [-2j, 2, 0, 0],
+-        [0, 0, 0, 0],
+-        [0, 0, 0, 0]
+-    ]
+-
+-    @pytest.mark.parametrize(['superop', 'chi_expected'], [
+-        pytest.param(sigmax(), chi_sigmax),
+-        pytest.param(to_super(sigmax()), chi_sigmax),
+-        pytest.param(qeye(2), chi_diag2),
+-        pytest.param(rotX_pi_4, chi_rotX_pi_4)
+-    ])
+-    def test_chi_known(self, superop, chi_expected):
+-        """
+-        Superoperator: Chi-matrix for known cases is correct.
+-        """
+-        chi_actual = to_chi(superop)
+-        chiq = Qobj(
+-            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
+-        )
+-        assert (chi_actual - chiq).norm() < tol
++# -*- coding: utf-8 -*-
++"""
++Created on Wed May 29 11:23:46 2013
++
++@author: dcriger
++"""
++
++from __future__ import division
++
++import numpy as np
++import pytest
++
++from qutip import (
++    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
++    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
++    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
++    vector_to_operator, sprepost, destroy
++)
++from qutip.core.gates import swap
++
++
++tol = 1e-8
++
++
++def assert_kraus_equivalence(a, b, tol=tol):
++    assert a.shape == b.shape
++    assert a.dims == b.dims
++    assert a.type == b.type
++    # Kraus operators may vary by a global phase.  Let's find the first
++    # non-zero element, set the phase such that that element has the same phase
++    # in both, and then compare.  We have to take care to find the first
++    # element.
++    a, b = a.full(), b.full()
++    a_nz = np.nonzero(np.abs(a) > tol)
++    if len(a_nz[0]) == 0:
++        np.testing.assert_allclose(b, 0, atol=tol)
++    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
++    assert b_el != 0
++    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
++    np.testing.assert_allclose(a, b)
++
++
++@pytest.fixture(scope="function", params=[2, 3, 7])
++def dimension(request):
++    # There are also some cases in the file where this fixture is explicitly
++    # overridden by a more local mark.  That is deliberate.
++    return request.param
++
++
++@pytest.fixture(scope="function", params=[
++    pytest.param(rand_super, id="super"),
++    pytest.param(rand_super_bcsz, id="super_bcz")
++])
++def superoperator(request, dimension):
++    return request.param(dimension)
++
++
++class TestSuperopReps:
++    """
++    A test class for the QuTiP function for applying superoperators to
++    subsystems.
++    """
++
++    def test_SuperChoiSuper(self, superoperator):
++        """
++        Superoperator: Converting superoperator to Choi matrix and back.
++        """
++        choi_matrix = to_choi(superoperator)
++        test_supe = to_super(choi_matrix)
++
++        # Assert both that the result is close to expected, and has the right
++        # type.
++        assert (test_supe - superoperator).norm() < tol
++        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
++        assert test_supe.type == "super" and test_supe.superrep == "super"
++
++    @pytest.mark.parametrize('dimension', [2, 4])
++    def test_SuperChoiChiSuper(self, dimension):
++        """
++        Superoperator: Converting two-qubit superoperator through
++        Choi and chi representations goes back to right superoperator.
++        """
++        superoperator = super_tensor(
++            rand_super(dimension), rand_super(dimension),
++        )
++
++        choi_matrix = to_choi(superoperator)
++        chi_matrix = to_chi(choi_matrix)
++        test_supe = to_super(chi_matrix)
++
++        # Assert both that the result is close to expected, and has the right
++        # type.
++        assert (test_supe - superoperator).norm() < tol
++        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
++        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
++        assert test_supe.type == "super" and test_supe.superrep == "super"
++
++    def test_ChoiKrausChoi(self, superoperator):
++        """
++        Superoperator: Convert superoperator to Choi matrix and back.
++        """
++        choi_matrix = to_choi(superoperator)
++        kraus_ops = to_kraus(choi_matrix)
++        test_choi = kraus_to_choi(kraus_ops)
++
++        # Assert both that the result is close to expected, and has the right
++        # type.
++        assert (test_choi - choi_matrix).norm() < tol
++        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
++        assert test_choi.type == "super" and test_choi.superrep == "choi"
++
++    def test_NonSquareKrausSuperChoi(self):
++        """
++        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
++        and back.
++        """
++        zero = np.array([[1], [0]], dtype=complex)
++        one = np.array([[0], [1]], dtype=complex)
++        zero_log = np.kron(np.kron(zero, zero), zero)
++        one_log = np.kron(np.kron(one, one), one)
++        # non-square Kraus operator (isometry)
++        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
++        super = sprepost(kraus, kraus.dag())
++        choi = to_choi(super)
++        op1 = to_kraus(super)
++        op2 = to_kraus(choi)
++        op3 = to_super(choi)
++        assert choi.type == "super" and choi.superrep == "choi"
++        assert super.type == "super" and super.superrep == "super"
++        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
++        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
++        assert abs((op3 - super).norm()) < 1e-8
++
++    def test_NeglectSmallKraus(self):
++        """
++        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
++        Kraus operators.
++        """
++        zero = np.array([[1], [0]], dtype=complex)
++        one = np.array([[0], [1]], dtype=complex)
++        zero_log = np.kron(np.kron(zero, zero), zero)
++        one_log = np.kron(np.kron(one, one), one)
++        # non-square Kraus operator (isometry)
++        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
++        super = sprepost(kraus, kraus.dag())
++        # 1 non-zero Kraus operator the rest are zero
++        sixteen_kraus_ops = to_kraus(super, tol=0.0)
++        # default is tol=1e-9
++        one_kraus_op = to_kraus(super)
++        assert len(sixteen_kraus_ops) == 16
++        assert len(one_kraus_op) == 1
++        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
++
++    def test_SuperPreservesSelf(self, superoperator):
++        """
++        Superoperator: to_super(q) returns q if q is already a
++        supermatrix.
++        """
++
++        assert superoperator is to_super(superoperator)
++
++    def test_ChoiPreservesSelf(self, superoperator):
++        """
++        Superoperator: to_choi(q) returns q if q is already Choi.
++        """
++        choi = to_choi(superoperator)
++        assert choi is to_choi(choi)
++
++    def test_random_iscptp(self, superoperator):
++        """
++        Superoperator: Randomly generated superoperators are
++        correctly reported as CPTP and HP.
++        """
++        assert superoperator.iscptp
++        assert superoperator.ishp
++
++    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
++        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
++        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
++        pytest.param(qeye(2), True, True, True),
++        pytest.param(sigmax(), True, True, True),
++        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
++        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
++                            + to_super(tensor(qeye(2), sigmay()))),
++                     True, True, True,
++                     id="linear combination of bipartite unitaries"),
++        pytest.param(Qobj(swap(), type='super', superrep='choi'),
++                     True, False, True,
++                     id="partial transpose map"),
++        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
++                     id="subnormalized map"),
++        pytest.param(basis(2, 0), False, False, False, id="ket"),
++    ])
++    def test_known_iscptp(self, qobj, hp, cp, tp):
++        """
++        Superoperator: ishp, iscp, istp and iscptp known cases.
++        """
++        assert qobj.ishp == hp
++        assert qobj.iscp == cp
++        assert qobj.istp == tp
++        assert qobj.iscptp == (cp and tp)
++
++    def test_choi_tr(self):
++        """
++        Superoperator: Trace returned by to_choi matches docstring.
++        """
++        for dims in range(2, 5):
++            assert abs(to_choi(identity(dims)).tr() - dims) < tol
++
++
++    # Conjugation by a creation operator
++    a = create(2).dag()
++    S = sprepost(a, a.dag())
++
++    # A single off-diagonal element
++    S_ = sprepost(a, a)
++
++    # Check that a linear combination of bipartite unitaries is CPTP and HP.
++    S_U = (
++        to_super(tensor(sigmax(), identity(2))) +
++        to_super(tensor(identity(2), sigmay()))
++    ) / 2
++
++    # The partial transpose map, whose Choi matrix is SWAP
++    ptr_swap = Qobj(swap(), type='super', superrep='choi')
++
++    # Subnormalized maps (representing erasure channels, for instance)
++    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
++
++    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
++        pytest.param(S, True, True, False, id="conjugatio by create op"),
++        pytest.param(S_, False, False, False, id="single off-diag"),
++        pytest.param(identity(2), True, True, True, id="Identity"),
++        pytest.param(sigmax(), True, True, True, id="Pauli X"),
++        pytest.param(
++            tensor(sigmax(), identity(2)), True, True, True,
++            id="bipartite system",
++        ),
++        pytest.param(
++            S_U, True, True, True, id="linear combination of bip. unitaries",
++        ),
++        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
++        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
++        pytest.param(basis(2), False, False, False, id="not an operator"),
++
++    ])
++    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
++        """
++        Superoperator: ishp, iscp, istp and iscptp known cases.
++        """
++        assert qobj.ishp == shouldhp
++        assert qobj.iscp == shouldcp
++        assert qobj.istp == shouldtp
++        assert qobj.iscptp == (shouldcp and shouldtp)
++
++    def test_choi_tr(self, dimension):
++        """
++        Superoperator: Trace returned by to_choi matches docstring.
++        """
++        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
++
++    def test_stinespring_cp(self, dimension):
++        """
++        Stinespring: A and B match for CP maps.
++        """
++        superop = rand_super_bcsz(dimension)
++        A, B = to_stinespring(superop)
++
++        assert (A - B).norm() < tol
++
++    @pytest.mark.repeat(3)
++    def test_stinespring_agrees(self, dimension):
++        """
++        Stinespring: Partial Tr over pair agrees w/ supermatrix.
++        """
++
++        map = rand_super_bcsz(dimension)
++        state = rand_dm(dimension)
++
++        S = to_super(map)
++        A, B = to_stinespring(map)
++
++        q1 = vector_to_operator(
++            S * operator_to_vector(state)
++        )
++        # FIXME: problem if Kraus index is implicitly
++        #        ptraced!
++        q2 = (A * state * B.dag()).ptrace((0,))
++
++        assert (q1 - q2).norm('tr') <= tol
++
++    def test_stinespring_dims(self, dimension):
++        """
++        Stinespring: Check that dims of channels are preserved.
++        """
++        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
++        A, B = to_stinespring(chan)
++        assert A.dims == [[2, dimension, 1], [2, dimension]]
++        assert B.dims == [[2, dimension, 1], [2, dimension]]
++
++    @pytest.mark.parametrize('dimension', [2, 4, 8])
++    def test_chi_choi_roundtrip(self, dimension):
++
++        superop = rand_super_bcsz(dimension)
++        superop = to_chi(superop)
++        rt_superop = to_chi(to_choi(superop))
++        dif = (rt_superop - superop).norm()
++
++        assert dif == pytest.approx(0, abs=1e-7)
++        assert rt_superop.type == superop.type
++        assert rt_superop.dims == superop.dims
++
++    chi_sigmax = [
++        [0, 0, 0, 0],
++        [0, 4, 0, 0],
++        [0, 0, 0, 0],
++        [0, 0, 0, 0]
++    ]
++    chi_diag2 = [
++        [4, 0, 0, 0],
++        [0, 0, 0, 0],
++        [0, 0, 0, 0],
++        [0, 0, 0, 0]
++    ]
++    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
++    chi_rotX_pi_4 = [
++        [2, 2j, 0, 0],
++        [-2j, 2, 0, 0],
++        [0, 0, 0, 0],
++        [0, 0, 0, 0]
++    ]
++
++    @pytest.mark.parametrize(['superop', 'chi_expected'], [
++        pytest.param(sigmax(), chi_sigmax),
++        pytest.param(to_super(sigmax()), chi_sigmax),
++        pytest.param(qeye(2), chi_diag2),
++        pytest.param(rotX_pi_4, chi_rotX_pi_4)
++    ])
++    def test_chi_known(self, superop, chi_expected):
++        """
++        Superoperator: Chi-matrix for known cases is correct.
++        """
++        chi_actual = to_chi(superop)
++        chiq = Qobj(
++            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
++        )
++        assert (chi_actual - chiq).norm() < tol
+diff --git a/qutip/tests/core/test_superoper.py b/qutip/tests/core/test_superoper.py
+index b5ba6fd1..bbeeb682 100644
+--- a/qutip/tests/core/test_superoper.py
++++ b/qutip/tests/core/test_superoper.py
+@@ -1,269 +1,269 @@
+-import numpy as np
+-import scipy.linalg
+-
+-import qutip
+-from qutip.core import data as _data
+-import pytest
+-
+-
+-def f(t, args):
+-    return t * (1 - 0.5j)
+-
+-
+-def liouvillian_ref(H, c_ops=()):
+-    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
+-    for c in c_ops:
+-        if c.issuper:
+-            L += c
+-        else:
+-            cdc = c.dag() * c
+-            L += qutip.sprepost(c, c.dag())
+-            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
+-    return L
+-
+-
+-class TestMatVec:
+-    """
+-    A test class for the QuTiP function for matrix/vector conversion.
+-    """
+-    def testOperatorVector(self):
+-        """
+-        Superoperator: Operator - vector - operator conversion.
+-        """
+-        N = 3
+-        rho1 = qutip.rand_dm(N)
+-        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
+-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+-
+-    def testsuperrep(self):
+-        N = 3
+-        rho1 = qutip.rand_dm(N)
+-        as_vec = qutip.operator_to_vector(rho1)
+-        assert as_vec.superrep == 'super'
+-
+-        with pytest.raises(TypeError) as err:
+-            bad_vec = as_vec.copy()
+-            bad_vec.superrep = ""
+-            qutip.vector_to_operator(bad_vec)
+-        assert err.value.args[0] == ("only defined for operator-kets "
+-                                     "in super format")
+-
+-        with pytest.raises(TypeError) as err:
+-            qutip.operator_to_vector(as_vec)
+-        assert err.value.args[0] == ("Cannot convert object already "
+-                                     "in super representation")
+-
+-    def testOperatorVectorTensor(self):
+-        """
+-        Superoperator: Operator - vector - operator conversion with a tensor
+-        product state.
+-        """
+-        Na = 3
+-        Nb = 2
+-        rhoa = qutip.rand_dm(Na)
+-        rhob = qutip.rand_dm(Nb)
+-        rho1 = qutip.tensor(rhoa, rhob)
+-        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
+-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+-
+-    def testOperatorVectorNotSquare(self):
+-        """
+-        Superoperator: Operator - vector - operator conversion for non-square
+-        matrix.
+-        """
+-        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
+-        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
+-        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
+-
+-    def testOperatorSpreAppl(self):
+-        """
+-        Superoperator: apply operator and superoperator from left (spre)
+-        """
+-        N = 3
+-        rho = qutip.rand_dm(N)
+-        U = qutip.rand_unitary(N)
+-        rho1 = U * rho
+-        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
+-        rho2 = qutip.vector_to_operator(rho2_vec)
+-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+-
+-    def testOperatorSpostAppl(self):
+-        """
+-        Superoperator: apply operator and superoperator from right (spost)
+-        """
+-        N = 3
+-        rho = qutip.rand_dm(N)
+-        U = qutip.rand_unitary(N)
+-        rho1 = rho * U
+-        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
+-        rho2 = qutip.vector_to_operator(rho2_vec)
+-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+-
+-    def testOperatorUnitaryTransform(self):
+-        """
+-        Superoperator: Unitary transformation with operators and superoperators
+-        """
+-        N = 3
+-        rho = qutip.rand_dm(N)
+-        U = qutip.rand_unitary(N)
+-        rho1 = U * rho * U.dag()
+-        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
+-        rho2 = qutip.vector_to_operator(rho2_vec)
+-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+-
+-    def testMatrixVecMat(self):
+-        """
+-        Superoperator: Conversion matrix to vector to matrix
+-        """
+-        M = _data.create(np.random.rand(10, 10))
+-        V = qutip.stack_columns(M)
+-        M2 = qutip.unstack_columns(V)
+-        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
+-
+-    def testVecMatVec(self):
+-        """
+-        Superoperator: Conversion vector to matrix to vector
+-        """
+-        V = _data.create(np.random.rand(100, 1))
+-        M = qutip.unstack_columns(V)
+-        V2 = qutip.stack_columns(M)
+-        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
+-
+-    def testVecMatIndexConversion(self):
+-        """
+-        Superoperator: Conversion between matrix and vector indices
+-        """
+-        N = 10
+-        for i in range(N * N):
+-            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
+-
+-    def testVecMatIndexCompability(self):
+-        """
+-        Superoperator: Compatibility between matrix/vector and
+-        corresponding index conversions.
+-        """
+-        N = 10
+-        M = _data.create(np.random.rand(N, N))
+-        V = qutip.stack_columns(M)
+-        for idx in range(N * N):
+-            i, j = qutip.unstacked_index(N, idx)
+-            assert V.to_array()[idx, 0] == M.to_array()[i, j]
+-
+-    def test_reshuffle(self):
+-        U1 = qutip.rand_unitary(2)
+-        U2 = qutip.rand_unitary(3)
+-        U3 = qutip.rand_unitary(4)
+-        U = qutip.tensor(U1, U2, U3)
+-        S = qutip.to_super(U)
+-        S_col = qutip.reshuffle(S)
+-        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
+-        assert qutip.reshuffle(S_col) == S
+-
+-    def test_sprepost(self):
+-        U1 = qutip.rand_unitary(3)
+-        U2 = qutip.rand_unitary(3)
+-        S1 = qutip.spre(U1) * qutip.spost(U2)
+-        S2 = qutip.sprepost(U1, U2)
+-        assert S1 == S2
+-
+-    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
+-    @pytest.mark.parametrize("operation", [qutip.spre,
+-                                           qutip.spost,
+-                                           qutip.liouvillian,
+-                                           qutip.lindblad_dissipator])
+-    def test_operation_dtype(self, dtype, operation):
+-        """This test checks that the dtype is properly kept with the
+-        `operation` function."""
+-        U1 = qutip.rand_unitary(3).to(dtype)
+-        result = operation(U1)
+-        assert type(result.data) == dtype
+-
+-    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
+-    def test_sprepost_dtype(self, dtype):
+-        """This test checks that the dtype is properly kept with `sprepost`
+-        function."""
+-        U1 = qutip.rand_unitary(3).to(dtype)
+-        result = qutip.sprepost(U1, U1)
+-        assert type(result.data) == dtype
+-
+-    def testLiouvillianImplem(self):
+-        """
+-        Superoperator: Randomized comparison of standard and reference
+-        Liouvillian functions.
+-        """
+-        N1, N2, N3 = 3, 4, 5
+-        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
+-                          qutip.qeye([N2, N3]))
+-        a2 = qutip.tensor(qutip.qeye(N1),
+-                          qutip.rand_dm(N2, density=0.75),
+-                          qutip.qeye(N3))
+-        a3 = qutip.tensor(qutip.qeye([N1, N2]),
+-                          qutip.rand_dm(N3, density=0.75))
+-        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
+-        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
+-        L1 = qutip.liouvillian(H, c_ops)
+-        L2 = liouvillian_ref(H, c_ops)
+-        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
+-
+-
+-class TestSuper_td:
+-    """
+-    A test class for the QuTiP superoperator functions.
+-    """
+-    N = 3
+-    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
+-                        [qutip.create(N) * (1 - 0.1j), f]])
+-    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
+-    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
+-    q1 = qutip.qeye(N) * (1 + 0.3j)
+-    q2 = qutip.destroy(N) * (1 - 0.3j)
+-    q3 = qutip.num(N) * (1 + 0.4j)
+-
+-    def test_spre_td(self):
+-        "Superoperator: spre, time-dependent"
+-        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
+-
+-    def test_spost_td(self):
+-        "Superoperator: spre, time-dependent"
+-        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
+-
+-    def test_sprepost_td(self):
+-        "Superoperator: sprepost, time-dependent"
+-        # left QobjEvo
+-        assert (qutip.sprepost(self.t1, self.q2)(0.5)
+-                == qutip.sprepost(self.t1(0.5), self.q2))
+-        # left QobjEvo
+-        assert (qutip.sprepost(self.q2, self.t1)(0.5)
+-                == qutip.sprepost(self.q2, self.t1(0.5)))
+-        # left 2 QobjEvo, one cte
+-        assert (qutip.sprepost(self.t1, self.t2)(0.5)
+-                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
+-
+-    def test_operator_vector_td(self):
+-        "Superoperator: operator_to_vector, time-dependent"
+-        assert (qutip.operator_to_vector(self.t1)(0.5)
+-                == qutip.operator_to_vector(self.t1(0.5)))
+-        vec = qutip.operator_to_vector(self.t1)
+-        assert (qutip.vector_to_operator(vec)(0.5)
+-                == qutip.vector_to_operator(vec(0.5)))
+-
+-    def test_liouvillian_td(self):
+-        "Superoperator: liouvillian, time-dependent"
+-        assert (qutip.liouvillian(self.t1)(0.5)
+-                == qutip.liouvillian(self.t1(0.5)))
+-        assert (qutip.liouvillian(None, [self.t2])(0.5)
+-                == qutip.liouvillian(None, [self.t2(0.5)]))
+-        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
+-                                  chi=[1, 2, 3])(0.5)
+-                == qutip.liouvillian(self.t1(0.5),
+-                                     [self.t2(0.5), self.q1, self.t3(0.5)],
+-                                     chi=[1, 2, 3]))
+-
+-    def test_lindblad_dissipator_td(self):
+-        "Superoperator: lindblad_dissipator, time-dependent"
+-        assert (qutip.lindblad_dissipator(self.t2)(0.5)
+-                == qutip.lindblad_dissipator(self.t2(0.5)))
+-        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
+-                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
+-        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
+-                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
++import numpy as np
++import scipy.linalg
++
++import qutip
++from qutip.core import data as _data
++import pytest
++
++
++def f(t, args):
++    return t * (1 - 0.5j)
++
++
++def liouvillian_ref(H, c_ops=()):
++    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
++    for c in c_ops:
++        if c.issuper:
++            L += c
++        else:
++            cdc = c.dag() * c
++            L += qutip.sprepost(c, c.dag())
++            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
++    return L
++
++
++class TestMatVec:
++    """
++    A test class for the QuTiP function for matrix/vector conversion.
++    """
++    def testOperatorVector(self):
++        """
++        Superoperator: Operator - vector - operator conversion.
++        """
++        N = 3
++        rho1 = qutip.rand_dm(N)
++        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
++        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
++
++    def testsuperrep(self):
++        N = 3
++        rho1 = qutip.rand_dm(N)
++        as_vec = qutip.operator_to_vector(rho1)
++        assert as_vec.superrep == 'super'
++
++        with pytest.raises(TypeError) as err:
++            bad_vec = as_vec.copy()
++            bad_vec.superrep = ""
++            qutip.vector_to_operator(bad_vec)
++        assert err.value.args[0] == ("only defined for operator-kets "
++                                     "in super format")
++
++        with pytest.raises(TypeError) as err:
++            qutip.operator_to_vector(as_vec)
++        assert err.value.args[0] == ("Cannot convert object already "
++                                     "in super representation")
++
++    def testOperatorVectorTensor(self):
++        """
++        Superoperator: Operator - vector - operator conversion with a tensor
++        product state.
++        """
++        Na = 3
++        Nb = 2
++        rhoa = qutip.rand_dm(Na)
++        rhob = qutip.rand_dm(Nb)
++        rho1 = qutip.tensor(rhoa, rhob)
++        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
++        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
++
++    def testOperatorVectorNotSquare(self):
++        """
++        Superoperator: Operator - vector - operator conversion for non-square
++        matrix.
++        """
++        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
++        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
++        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
++
++    def testOperatorSpreAppl(self):
++        """
++        Superoperator: apply operator and superoperator from left (spre)
++        """
++        N = 3
++        rho = qutip.rand_dm(N)
++        U = qutip.rand_unitary(N)
++        rho1 = U * rho
++        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
++        rho2 = qutip.vector_to_operator(rho2_vec)
++        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
++
++    def testOperatorSpostAppl(self):
++        """
++        Superoperator: apply operator and superoperator from right (spost)
++        """
++        N = 3
++        rho = qutip.rand_dm(N)
++        U = qutip.rand_unitary(N)
++        rho1 = rho * U
++        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
++        rho2 = qutip.vector_to_operator(rho2_vec)
++        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
++
++    def testOperatorUnitaryTransform(self):
++        """
++        Superoperator: Unitary transformation with operators and superoperators
++        """
++        N = 3
++        rho = qutip.rand_dm(N)
++        U = qutip.rand_unitary(N)
++        rho1 = U * rho * U.dag()
++        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
++        rho2 = qutip.vector_to_operator(rho2_vec)
++        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
++
++    def testMatrixVecMat(self):
++        """
++        Superoperator: Conversion matrix to vector to matrix
++        """
++        M = _data.create(np.random.rand(10, 10))
++        V = qutip.stack_columns(M)
++        M2 = qutip.unstack_columns(V)
++        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
++
++    def testVecMatVec(self):
++        """
++        Superoperator: Conversion vector to matrix to vector
++        """
++        V = _data.create(np.random.rand(100, 1))
++        M = qutip.unstack_columns(V)
++        V2 = qutip.stack_columns(M)
++        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
++
++    def testVecMatIndexConversion(self):
++        """
++        Superoperator: Conversion between matrix and vector indices
++        """
++        N = 10
++        for i in range(N * N):
++            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
++
++    def testVecMatIndexCompability(self):
++        """
++        Superoperator: Compatibility between matrix/vector and
++        corresponding index conversions.
++        """
++        N = 10
++        M = _data.create(np.random.rand(N, N))
++        V = qutip.stack_columns(M)
++        for idx in range(N * N):
++            i, j = qutip.unstacked_index(N, idx)
++            assert V.to_array()[idx, 0] == M.to_array()[i, j]
++
++    def test_reshuffle(self):
++        U1 = qutip.rand_unitary(2)
++        U2 = qutip.rand_unitary(3)
++        U3 = qutip.rand_unitary(4)
++        U = qutip.tensor(U1, U2, U3)
++        S = qutip.to_super(U)
++        S_col = qutip.reshuffle(S)
++        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
++        assert qutip.reshuffle(S_col) == S
++
++    def test_sprepost(self):
++        U1 = qutip.rand_unitary(3)
++        U2 = qutip.rand_unitary(3)
++        S1 = qutip.spre(U1) * qutip.spost(U2)
++        S2 = qutip.sprepost(U1, U2)
++        assert S1 == S2
++
++    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
++    @pytest.mark.parametrize("operation", [qutip.spre,
++                                           qutip.spost,
++                                           qutip.liouvillian,
++                                           qutip.lindblad_dissipator])
++    def test_operation_dtype(self, dtype, operation):
++        """This test checks that the dtype is properly kept with the
++        `operation` function."""
++        U1 = qutip.rand_unitary(3).to(dtype)
++        result = operation(U1)
++        assert type(result.data) == dtype
++
++    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
++    def test_sprepost_dtype(self, dtype):
++        """This test checks that the dtype is properly kept with `sprepost`
++        function."""
++        U1 = qutip.rand_unitary(3).to(dtype)
++        result = qutip.sprepost(U1, U1)
++        assert type(result.data) == dtype
++
++    def testLiouvillianImplem(self):
++        """
++        Superoperator: Randomized comparison of standard and reference
++        Liouvillian functions.
++        """
++        N1, N2, N3 = 3, 4, 5
++        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
++                          qutip.qeye([N2, N3]))
++        a2 = qutip.tensor(qutip.qeye(N1),
++                          qutip.rand_dm(N2, density=0.75),
++                          qutip.qeye(N3))
++        a3 = qutip.tensor(qutip.qeye([N1, N2]),
++                          qutip.rand_dm(N3, density=0.75))
++        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
++        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
++        L1 = qutip.liouvillian(H, c_ops)
++        L2 = liouvillian_ref(H, c_ops)
++        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
++
++
++class TestSuper_td:
++    """
++    A test class for the QuTiP superoperator functions.
++    """
++    N = 3
++    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
++                        [qutip.create(N) * (1 - 0.1j), f]])
++    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
++    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
++    q1 = qutip.qeye(N) * (1 + 0.3j)
++    q2 = qutip.destroy(N) * (1 - 0.3j)
++    q3 = qutip.num(N) * (1 + 0.4j)
++
++    def test_spre_td(self):
++        "Superoperator: spre, time-dependent"
++        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
++
++    def test_spost_td(self):
++        "Superoperator: spre, time-dependent"
++        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
++
++    def test_sprepost_td(self):
++        "Superoperator: sprepost, time-dependent"
++        # left QobjEvo
++        assert (qutip.sprepost(self.t1, self.q2)(0.5)
++                == qutip.sprepost(self.t1(0.5), self.q2))
++        # left QobjEvo
++        assert (qutip.sprepost(self.q2, self.t1)(0.5)
++                == qutip.sprepost(self.q2, self.t1(0.5)))
++        # left 2 QobjEvo, one cte
++        assert (qutip.sprepost(self.t1, self.t2)(0.5)
++                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
++
++    def test_operator_vector_td(self):
++        "Superoperator: operator_to_vector, time-dependent"
++        assert (qutip.operator_to_vector(self.t1)(0.5)
++                == qutip.operator_to_vector(self.t1(0.5)))
++        vec = qutip.operator_to_vector(self.t1)
++        assert (qutip.vector_to_operator(vec)(0.5)
++                == qutip.vector_to_operator(vec(0.5)))
++
++    def test_liouvillian_td(self):
++        "Superoperator: liouvillian, time-dependent"
++        assert (qutip.liouvillian(self.t1)(0.5)
++                == qutip.liouvillian(self.t1(0.5)))
++        assert (qutip.liouvillian(None, [self.t2])(0.5)
++                == qutip.liouvillian(None, [self.t2(0.5)]))
++        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
++                                  chi=[1, 2, 3])(0.5)
++                == qutip.liouvillian(self.t1(0.5),
++                                     [self.t2(0.5), self.q1, self.t3(0.5)],
++                                     chi=[1, 2, 3]))
++
++    def test_lindblad_dissipator_td(self):
++        "Superoperator: lindblad_dissipator, time-dependent"
++        assert (qutip.lindblad_dissipator(self.t2)(0.5)
++                == qutip.lindblad_dissipator(self.t2(0.5)))
++        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
++                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
++        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
++                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
+diff --git a/qutip/tests/core/test_tensor.py b/qutip/tests/core/test_tensor.py
+index 10e493e4..41ba5672 100644
+--- a/qutip/tests/core/test_tensor.py
++++ b/qutip/tests/core/test_tensor.py
+@@ -1,257 +1,257 @@
+-import numpy as np
+-
+-from numpy.testing import assert_equal, assert_
+-import pytest
+-import functools
+-import itertools
+-import qutip
+-from qutip import (
+-    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
+-    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
+-    expand_operator
+-)
+-
+-
+-def test_tensor_contract_ident():
+-    qobj = identity([2, 3, 4])
+-    ans = 3 * identity([2, 4])
+-
+-    assert_(ans == tensor_contract(qobj, (1, 4)))
+-
+-    # Now try for superoperators.
+-    # For now, we just ensure the dims are correct.
+-    sqobj = to_super(qobj)
+-    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
+-    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
+-
+-
+-def case_tensor_contract_other(left, right, pairs,
+-                               expected_dims, expected_data):
+-    dat = np.arange(np.prod(left) * np.prod(right))
+-    dat = dat.reshape((np.prod(left), np.prod(right)))
+-
+-    qobj = Qobj(dat, dims=[left, right])
+-    cqobj = tensor_contract(qobj, *pairs)
+-    assert_equal(cqobj.dims, expected_dims)
+-    assert_equal(cqobj.full(), expected_data)
+-
+-
+-def test_tensor_contract_other():
+-    case_tensor_contract_other(
+-        [2, 3], [3, 4], [(1, 2)],
+-        [[2], [4]],
+-        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
+-    )
+-
+-    case_tensor_contract_other(
+-        [2, 3], [4, 3], [(1, 3)],
+-        [[2], [4]],
+-        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
+-    )
+-
+-    case_tensor_contract_other(
+-        [2, 3], [4, 3], [(1, 3)],
+-        [[2], [4]],
+-        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
+-    )
+-
+-    # Make non-rectangular outputs in a column-/row-symmetric fashion.
+-    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
+-
+-    case_tensor_contract_other(
+-        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
+-        [[[3], [3]], [[2, 3], [2, 3]]],
+-        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
+-
+-    case_tensor_contract_other(
+-        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
+-        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
+-        # We separate einsum into two calls due to a bug internal to
+-        # einsum.
+-        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
+-
+-    # Now we try collapsing in a way that's sensitive to column- and row-
+-    # stacking conventions.
+-    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
+-    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
+-    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
+-    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
+-
+-    # Let's try a weird tensor contraction; this will likely never come up in
+-    # practice, but it should serve as a good canary for more reasonable
+-    # contractions.
+-    case_tensor_contract_other(
+-        big_dims[0], big_dims[1], [(0, 4)],
+-        [[[2], [3, 3]], [[3], [2, 3]]],
+-        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
+-
+-
+-def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
+-    sqobj = tensor_swap(qobj, *pairs)
+-
+-    assert_equal(sqobj.dims, expected_dims)
+-    assert_equal(sqobj.full(), expected_data.full())
+-
+-
+-def test_tensor_swap_other():
+-    dims = (2, 3, 4, 5, 7)
+-    for dim in dims:
+-        S = to_super(rand_super_bcsz(dim))
+-        # Swapping the inner indices on a superoperator should give a Choi
+-        # matrix.
+-        J = to_choi(S)
+-        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
+-
+-
+-def test_tensor_qobjevo():
+-    N = 5
+-    t = 1.5
+-    left = QobjEvo([num(N),[destroy(N),"t"]])
+-    right = QobjEvo([identity(2),[sigmax(),"t"]])
+-    assert tensor(left, right)(t) == tensor(left(t), right(t))
+-    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
+-    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
+-
+-
+-def test_tensor_qobjevo_non_square():
+-    N = 5
+-    t = 1.5
+-    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
+-    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
+-    assert tensor(left, right)(t) == tensor(left(t), right(t))
+-
+-
+-def test_tensor_qobjevo_multiple():
+-    N = 5
+-    t = 1.5
+-    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
+-    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
+-    right = QobjEvo([sigmax()])
+-    as_QobjEvo = tensor(left, center, right)(t)
+-    as_Qobj = tensor(left(t), center(t), right(t))
+-    assert as_QobjEvo == as_Qobj
+-
+-
+-def test_tensor_and():
+-    N = 5
+-    t = 1.5
+-    sx = sigmax()
+-    evo = QobjEvo([num(N),[destroy(N),"t"]])
+-    assert tensor([sx, sx, sx]) == sx & sx & sx
+-    assert tensor(evo, sx)(t) == (evo & sx)(t)
+-    assert tensor(sx, evo)(t) == (sx & evo)(t)
+-    assert tensor(evo, evo)(t) == (evo & evo)(t)
+-
+-
+-def _permutation_id(permutation):
+-    return str(len(permutation)) + "-" + "".join(map(str, permutation))
+-
+-
+-def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
+-    """
+-    Create a full tensor product when a subspace component is already in an
+-    entangled state.  The locations in `all_qubits` which are the entangled
+-    points in the output are ignored and can take any value.
+-
+-    For example,
+-        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
+-    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
+-    in the final output are entangled, but the others are still separable.
+-
+-    Parameters:
+-        all_qubits: list of kets --
+-            A list of separable parts to tensor together.  States that are in
+-            the locations referred to by `entangled_locations` are completely
+-            ignored.
+-        entangled: tensor-product ket -- the full entangled subspace
+-        entangled_locations: list of int --
+-            The locations that the qubits in the entangled subspace should be
+-            in in the final tensor-product space.
+-    """
+-    n_entangled = len(entangled.dims[0])
+-    n_separable = len(all_qubits) - n_entangled
+-    separable = all_qubits.copy()
+-    # Remove in reverse order so subsequent deletion locations don't change.
+-    for location in sorted(entangled_locations, reverse=True):
+-        del separable[location]
+-    # Can't separate out entangled states to pass to tensor in the right places
+-    # immediately, so tensor in at one end and then permute into place.
+-    out = qutip.tensor(*separable, entangled)
+-    permutation = list(range(n_separable))
+-    current_locations = range(n_separable, n_separable + n_entangled)
+-    # Sort to prevert later insertions changing previous locations.
+-    insertions = sorted(zip(entangled_locations, current_locations),
+-                        key=lambda x: x[0])
+-    for out_location, current_location in insertions:
+-        permutation.insert(out_location, current_location)
+-    return out.permute(permutation)
+-
+-
+-def _apply_permutation(permutation):
+-    """
+-    Permute the given permutation into the order denoted by its elements, i.e.
+-        out[0] = permutation[permutation[0]]
+-        out[1] = permutation[permutation[1]]
+-        ...
+-
+-    This function is its own inverse.
+-    """
+-    out = [None] * len(permutation)
+-    for value, location in enumerate(permutation):
+-        out[location] = value
+-    return out
+-
+-
+-class Test_expand_operator:
+-    @pytest.mark.parametrize(
+-        'permutation',
+-        tuple(itertools.chain(*[
+-            itertools.permutations(range(k)) for k in [2, 3, 4]
+-        ])),
+-        ids=_permutation_id)
+-    def test_permutation_without_expansion(self, permutation):
+-        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
+-        test = expand_operator(base, [2] * len(permutation), permutation)
+-        expected = base.permute(_apply_permutation(permutation))
+-        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
+-
+-    @pytest.mark.parametrize('n_targets', range(1, 5))
+-    def test_general_qubit_expansion(self, n_targets):
+-        # Test all permutations with the given number of targets.
+-        n_qubits = 5
+-        operation = qutip.rand_unitary([2]*n_targets)
+-        for targets in itertools.permutations(range(n_qubits), n_targets):
+-            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
+-                                                 operation, targets)
+-            test = expand_operator(operation, [2] * 5, targets)
+-            np.testing.assert_allclose(test.full(), expected.full(),
+-                                       atol=1e-15)
+-
+-    def test_cnot_explicit(self):
+-        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
+-        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
+-                             [0, 0, 0, 0, 0, 1, 0, 0],
+-                             [0, 0, 1, 0, 0, 0, 0, 0],
+-                             [0, 0, 0, 0, 0, 0, 0, 1],
+-                             [0, 0, 0, 0, 1, 0, 0, 0],
+-                             [0, 1, 0, 0, 0, 0, 0, 0],
+-                             [0, 0, 0, 0, 0, 0, 1, 0],
+-                             [0, 0, 0, 1, 0, 0, 0, 0]])
+-        np.testing.assert_allclose(test, expected, atol=1e-15)
+-
+-    @pytest.mark.parametrize('dimensions', [
+-        pytest.param([3, 4, 5], id="standard"),
+-        pytest.param([3, 3, 4, 4, 2], id="standard"),
+-        pytest.param([1, 2, 3], id="1D space"),
+-    ])
+-    def test_non_qubit_systems(self, dimensions):
+-        n_qubits = len(dimensions)
+-        for targets in itertools.permutations(range(n_qubits), 2):
+-            operators = [qutip.rand_unitary(dimension) if n in targets
+-                         else qutip.qeye(dimension)
+-                         for n, dimension in enumerate(dimensions)]
+-            expected = qutip.tensor(*operators)
+-            base_test = qutip.tensor(*[operators[x] for x in targets])
+-            test = expand_operator(base_test, dims=dimensions, targets=targets)
+-            assert test.dims == expected.dims
+-            np.testing.assert_allclose(test.full(), expected.full())
++import numpy as np
++
++from numpy.testing import assert_equal, assert_
++import pytest
++import functools
++import itertools
++import qutip
++from qutip import (
++    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
++    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
++    expand_operator
++)
++
++
++def test_tensor_contract_ident():
++    qobj = identity([2, 3, 4])
++    ans = 3 * identity([2, 4])
++
++    assert_(ans == tensor_contract(qobj, (1, 4)))
++
++    # Now try for superoperators.
++    # For now, we just ensure the dims are correct.
++    sqobj = to_super(qobj)
++    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
++    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
++
++
++def case_tensor_contract_other(left, right, pairs,
++                               expected_dims, expected_data):
++    dat = np.arange(np.prod(left) * np.prod(right))
++    dat = dat.reshape((np.prod(left), np.prod(right)))
++
++    qobj = Qobj(dat, dims=[left, right])
++    cqobj = tensor_contract(qobj, *pairs)
++    assert_equal(cqobj.dims, expected_dims)
++    assert_equal(cqobj.full(), expected_data)
++
++
++def test_tensor_contract_other():
++    case_tensor_contract_other(
++        [2, 3], [3, 4], [(1, 2)],
++        [[2], [4]],
++        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
++    )
++
++    case_tensor_contract_other(
++        [2, 3], [4, 3], [(1, 3)],
++        [[2], [4]],
++        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
++    )
++
++    case_tensor_contract_other(
++        [2, 3], [4, 3], [(1, 3)],
++        [[2], [4]],
++        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
++    )
++
++    # Make non-rectangular outputs in a column-/row-symmetric fashion.
++    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
++
++    case_tensor_contract_other(
++        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
++        [[[3], [3]], [[2, 3], [2, 3]]],
++        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
++
++    case_tensor_contract_other(
++        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
++        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
++        # We separate einsum into two calls due to a bug internal to
++        # einsum.
++        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
++
++    # Now we try collapsing in a way that's sensitive to column- and row-
++    # stacking conventions.
++    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
++    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
++    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
++    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
++
++    # Let's try a weird tensor contraction; this will likely never come up in
++    # practice, but it should serve as a good canary for more reasonable
++    # contractions.
++    case_tensor_contract_other(
++        big_dims[0], big_dims[1], [(0, 4)],
++        [[[2], [3, 3]], [[3], [2, 3]]],
++        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
++
++
++def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
++    sqobj = tensor_swap(qobj, *pairs)
++
++    assert_equal(sqobj.dims, expected_dims)
++    assert_equal(sqobj.full(), expected_data.full())
++
++
++def test_tensor_swap_other():
++    dims = (2, 3, 4, 5, 7)
++    for dim in dims:
++        S = to_super(rand_super_bcsz(dim))
++        # Swapping the inner indices on a superoperator should give a Choi
++        # matrix.
++        J = to_choi(S)
++        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
++
++
++def test_tensor_qobjevo():
++    N = 5
++    t = 1.5
++    left = QobjEvo([num(N),[destroy(N),"t"]])
++    right = QobjEvo([identity(2),[sigmax(),"t"]])
++    assert tensor(left, right)(t) == tensor(left(t), right(t))
++    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
++    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
++
++
++def test_tensor_qobjevo_non_square():
++    N = 5
++    t = 1.5
++    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
++    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
++    assert tensor(left, right)(t) == tensor(left(t), right(t))
++
++
++def test_tensor_qobjevo_multiple():
++    N = 5
++    t = 1.5
++    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
++    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
++    right = QobjEvo([sigmax()])
++    as_QobjEvo = tensor(left, center, right)(t)
++    as_Qobj = tensor(left(t), center(t), right(t))
++    assert as_QobjEvo == as_Qobj
++
++
++def test_tensor_and():
++    N = 5
++    t = 1.5
++    sx = sigmax()
++    evo = QobjEvo([num(N),[destroy(N),"t"]])
++    assert tensor([sx, sx, sx]) == sx & sx & sx
++    assert tensor(evo, sx)(t) == (evo & sx)(t)
++    assert tensor(sx, evo)(t) == (sx & evo)(t)
++    assert tensor(evo, evo)(t) == (evo & evo)(t)
++
++
++def _permutation_id(permutation):
++    return str(len(permutation)) + "-" + "".join(map(str, permutation))
++
++
++def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
++    """
++    Create a full tensor product when a subspace component is already in an
++    entangled state.  The locations in `all_qubits` which are the entangled
++    points in the output are ignored and can take any value.
++
++    For example,
++        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
++    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
++    in the final output are entangled, but the others are still separable.
++
++    Parameters:
++        all_qubits: list of kets --
++            A list of separable parts to tensor together.  States that are in
++            the locations referred to by `entangled_locations` are completely
++            ignored.
++        entangled: tensor-product ket -- the full entangled subspace
++        entangled_locations: list of int --
++            The locations that the qubits in the entangled subspace should be
++            in in the final tensor-product space.
++    """
++    n_entangled = len(entangled.dims[0])
++    n_separable = len(all_qubits) - n_entangled
++    separable = all_qubits.copy()
++    # Remove in reverse order so subsequent deletion locations don't change.
++    for location in sorted(entangled_locations, reverse=True):
++        del separable[location]
++    # Can't separate out entangled states to pass to tensor in the right places
++    # immediately, so tensor in at one end and then permute into place.
++    out = qutip.tensor(*separable, entangled)
++    permutation = list(range(n_separable))
++    current_locations = range(n_separable, n_separable + n_entangled)
++    # Sort to prevert later insertions changing previous locations.
++    insertions = sorted(zip(entangled_locations, current_locations),
++                        key=lambda x: x[0])
++    for out_location, current_location in insertions:
++        permutation.insert(out_location, current_location)
++    return out.permute(permutation)
++
++
++def _apply_permutation(permutation):
++    """
++    Permute the given permutation into the order denoted by its elements, i.e.
++        out[0] = permutation[permutation[0]]
++        out[1] = permutation[permutation[1]]
++        ...
++
++    This function is its own inverse.
++    """
++    out = [None] * len(permutation)
++    for value, location in enumerate(permutation):
++        out[location] = value
++    return out
++
++
++class Test_expand_operator:
++    @pytest.mark.parametrize(
++        'permutation',
++        tuple(itertools.chain(*[
++            itertools.permutations(range(k)) for k in [2, 3, 4]
++        ])),
++        ids=_permutation_id)
++    def test_permutation_without_expansion(self, permutation):
++        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
++        test = expand_operator(base, [2] * len(permutation), permutation)
++        expected = base.permute(_apply_permutation(permutation))
++        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
++
++    @pytest.mark.parametrize('n_targets', range(1, 5))
++    def test_general_qubit_expansion(self, n_targets):
++        # Test all permutations with the given number of targets.
++        n_qubits = 5
++        operation = qutip.rand_unitary([2]*n_targets)
++        for targets in itertools.permutations(range(n_qubits), n_targets):
++            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
++                                                 operation, targets)
++            test = expand_operator(operation, [2] * 5, targets)
++            np.testing.assert_allclose(test.full(), expected.full(),
++                                       atol=1e-15)
++
++    def test_cnot_explicit(self):
++        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
++        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
++                             [0, 0, 0, 0, 0, 1, 0, 0],
++                             [0, 0, 1, 0, 0, 0, 0, 0],
++                             [0, 0, 0, 0, 0, 0, 0, 1],
++                             [0, 0, 0, 0, 1, 0, 0, 0],
++                             [0, 1, 0, 0, 0, 0, 0, 0],
++                             [0, 0, 0, 0, 0, 0, 1, 0],
++                             [0, 0, 0, 1, 0, 0, 0, 0]])
++        np.testing.assert_allclose(test, expected, atol=1e-15)
++
++    @pytest.mark.parametrize('dimensions', [
++        pytest.param([3, 4, 5], id="standard"),
++        pytest.param([3, 3, 4, 4, 2], id="standard"),
++        pytest.param([1, 2, 3], id="1D space"),
++    ])
++    def test_non_qubit_systems(self, dimensions):
++        n_qubits = len(dimensions)
++        for targets in itertools.permutations(range(n_qubits), 2):
++            operators = [qutip.rand_unitary(dimension) if n in targets
++                         else qutip.qeye(dimension)
++                         for n, dimension in enumerate(dimensions)]
++            expected = qutip.tensor(*operators)
++            base_test = qutip.tensor(*[operators[x] for x in targets])
++            test = expand_operator(base_test, dims=dimensions, targets=targets)
++            assert test.dims == expected.dims
++            np.testing.assert_allclose(test.full(), expected.full())
+diff --git a/qutip/tests/pytest.ini b/qutip/tests/pytest.ini
+index 02ffbe59..97561c15 100644
+--- a/qutip/tests/pytest.ini
++++ b/qutip/tests/pytest.ini
+@@ -1,5 +1,5 @@
+-[pytest]
+-markers =
+-    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
+-    repeat(n): Repeat the given test 'n' times.
+-    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
++[pytest]
++markers =
++    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
++    repeat(n): Repeat the given test 'n' times.
++    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
+diff --git a/qutip/tests/solve/test_piqs.py b/qutip/tests/solve/test_piqs.py
+index a069a290..293cd586 100644
+--- a/qutip/tests/solve/test_piqs.py
++++ b/qutip/tests/solve/test_piqs.py
+@@ -1,1536 +1,1536 @@
+-"""
+-Tests for Permutational Invariant Quantum solver (PIQS).
+-"""
+-import numpy as np
+-from numpy.testing import (
+-    assert_,
+-    run_module_suite,
+-    assert_raises,
+-    assert_array_equal,
+-    assert_array_almost_equal,
+-    assert_almost_equal,
+-    assert_equal,
+-)
+-from scipy.sparse import block_diag
+-from qutip import Qobj, entropy_vn, sigmax, sigmaz
+-from qutip.solve._piqs import (
+-    get_blocks,
+-    j_min,
+-    j_vals,
+-    m_vals,
+-    _num_dicke_states,
+-    _num_dicke_ladders,
+-    get_index,
+-    jmm1_dictionary,
+-)
+-from qutip.solve._piqs import Dicke as _Dicke
+-from qutip.solve.piqs import *
+-
+-import sys
+-import unittest
+-
+-
+-# Disable tests for python2 as qutip.piqs does not support python2.
+-if sys.version_info[0] < 3:
+-    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
+-
+-
+-class TestDicke:
+-    """
+-    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
+-    """
+-
+-    def test_num_dicke_states(self):
+-        """
+-        PIQS: Test the `num_dicke_state` function.
+-        """
+-        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
+-        dicke_states = [num_dicke_states(i) for i in N_list]
+-        assert_array_equal(
+-            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
+-        )
+-        N = -1
+-        assert_raises(ValueError, num_dicke_states, N)
+-        N = 0.2
+-        assert_raises(ValueError, num_dicke_states, N)
+-
+-    def test_num_tls(self):
+-        """
+-        PIQS: Test the `num_two_level` function.
+-        """
+-        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
+-        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
+-        calculated_N = [num_tls(i) for i in N_dicke]
+-        assert_array_equal(calculated_N, N)
+-
+-    def test_num_dicke_ladders(self):
+-        """
+-        PIQS: Test the `_num_dicke_ladders` function.
+-        """
+-        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
+-        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
+-        assert_array_equal(ndl, ndl_true)
+-
+-    def test_get_blocks(self):
+-        """
+-        PIQS: Test the function to get blocks.
+-        """
+-        N_list = [1, 2, 5, 7]
+-        blocks = [
+-            np.array([2]),
+-            np.array([3, 4]),
+-            np.array([6, 10, 12]),
+-            np.array([8, 14, 18, 20]),
+-        ]
+-        calculated_blocks = [get_blocks(i) for i in N_list]
+-        for (i, j) in zip(calculated_blocks, blocks):
+-            assert_array_equal(i, j)
+-
+-    def test_j_vals(self):
+-        """
+-        PIQS: Test calculation of j values for given N.
+-        """
+-        N_list = [1, 2, 3, 4, 7]
+-        j_vals_real = [
+-            np.array([0.5]),
+-            np.array([0.0, 1.0]),
+-            np.array([0.5, 1.5]),
+-            np.array([0.0, 1.0, 2.0]),
+-            np.array([0.5, 1.5, 2.5, 3.5]),
+-        ]
+-        j_vals_calc = [j_vals(i) for i in N_list]
+-
+-        for (i, j) in zip(j_vals_calc, j_vals_real):
+-            assert_array_equal(i, j)
+-
+-    def test_m_vals(self):
+-        """
+-        PIQS: Test calculation of m values for a particular j.
+-        """
+-        j_list = [0.5, 1, 1.5, 2, 2.5]
+-        m_real = [
+-            np.array([-0.5, 0.5]),
+-            np.array([-1, 0, 1]),
+-            np.array([-1.5, -0.5, 0.5, 1.5]),
+-            np.array([-2, -1, 0, 1, 2]),
+-            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
+-        ]
+-
+-        m_calc = [m_vals(i) for i in j_list]
+-        for (i, j) in zip(m_real, m_calc):
+-            assert_array_equal(i, j)
+-
+-    def test_dicke_blocks(self):
+-        """
+-        PIQS: Test the `dicke_blocks` function.
+-        """
+-        # test 1
+-        # mixed state with non-symmetrical block matrix elements
+-        N = 3
+-        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+-        test_blocks = dicke_blocks(true_matrix)
+-        test_matrix = Qobj(block_diag(test_blocks))
+-        assert_(test_matrix == true_matrix)
+-        # test 2
+-        # all elements in block-diagonal matrix
+-        N = 4
+-        true_matrix = Qobj(block_matrix(N)).unit()
+-        test_blocks = dicke_blocks(true_matrix)
+-        test_matrix = Qobj(block_diag(test_blocks))
+-        assert_(test_matrix == true_matrix)
+-
+-    def test_dicke_blocks_full(self):
+-        """
+-        PIQS: Test the `dicke_blocks_full` function.
+-        """
+-        N = 3
+-        test_blocks = dicke_blocks_full(excited(3))
+-        test_matrix = Qobj(block_diag(test_blocks))
+-        true_expanded = np.zeros((8, 8))
+-        true_expanded[0, 0] = 1.0
+-        assert_(test_matrix == Qobj(true_expanded))
+-
+-    def test_dicke_function_trace(self):
+-        """
+-        PIQS: Test the `dicke_function_trace` function.
+-        """
+-        ## test for N odd
+-        N = 3
+-        # test trace
+-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+-        f = lambda x: x
+-        test_val = dicke_function_trace(f, rho_mixed)
+-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
+-        true_val2 = (rho_mixed).tr()
+-        # test with linear function (trace)
+-        assert_almost_equal(test_val, true_val)
+-        assert_almost_equal(test_val, true_val2)
+-        # test with nonlinear function
+-        f = lambda rho: rho ** 3
+-        test_val3 = dicke_function_trace(f, rho_mixed)
+-        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
+-        assert_almost_equal(test_val3, true_val3)
+-        ## test for N even
+-        N = 4
+-        # test trace
+-        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
+-        f = lambda x: x
+-        test_val = dicke_function_trace(f, rho_mixed)
+-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
+-        true_val2 = (rho_mixed).tr()
+-        # test with linear function (trace)
+-        assert_almost_equal(test_val, true_val)
+-        assert_almost_equal(test_val, true_val2)
+-        # test with nonlinear function
+-        f = lambda rho: rho ** 3
+-        test_val3 = dicke_function_trace(f, rho_mixed)
+-        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
+-        assert np.allclose(test_val3, true_val3)
+-
+-    def test_entropy_vn_dicke(self):
+-        """
+-        PIQS: Test the `entropy_vn_dicke` function.
+-        """
+-        N = 3
+-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+-        test_val = entropy_vn_dicke(rho_mixed)
+-        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
+-        assert np.allclose(test_val, true_val)
+-
+-    def test_purity_dicke(self):
+-        """
+-        PIQS: Test the `purity_dicke` function.
+-        """
+-        N = 3
+-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+-        test_val = purity_dicke(rho_mixed)
+-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
+-        assert np.allclose(test_val, true_val)
+-
+-    def test_get_index(self):
+-        """
+-        PIQS: Test the index fetching function for given j, m, m1 value.
+-        """
+-        N = 1
+-        jmm1_list = [
+-            (0.5, 0.5, 0.5),
+-            (0.5, 0.5, -0.5),
+-            (0.5, -0.5, 0.5),
+-            (0.5, -0.5, -0.5),
+-        ]
+-        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
+-
+-        blocks = get_blocks(N)
+-        calculated_indices = [
+-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+-            for jmm1 in jmm1_list
+-        ]
+-        assert_array_almost_equal(calculated_indices, indices)
+-        N = 2
+-        blocks = get_blocks(N)
+-        jmm1_list = [
+-            (1, 1, 1),
+-            (1, 1, 0),
+-            (1, 1, -1),
+-            (1, 0, 1),
+-            (1, 0, 0),
+-            (1, 0, -1),
+-            (1, -1, 1),
+-            (1, -1, 0),
+-            (1, -1, -1),
+-            (0, 0, 0),
+-        ]
+-        indices = [
+-            (0, 0),
+-            (0, 1),
+-            (0, 2),
+-            (1, 0),
+-            (1, 1),
+-            (1, 2),
+-            (2, 0),
+-            (2, 1),
+-            (2, 2),
+-            (3, 3),
+-        ]
+-        calculated_indices = [
+-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+-            for jmm1 in jmm1_list
+-        ]
+-        assert_array_almost_equal(calculated_indices, indices)
+-        N = 3
+-        blocks = get_blocks(N)
+-        jmm1_list = [
+-            (1.5, 1.5, 1.5),
+-            (1.5, 1.5, 0.5),
+-            (1.5, 1.5, -0.5),
+-            (1.5, 1.5, -1.5),
+-            (1.5, 0.5, 0.5),
+-            (1.5, -0.5, -0.5),
+-            (1.5, -1.5, -1.5),
+-            (1.5, -1.5, 1.5),
+-            (0.5, 0.5, 0.5),
+-            (0.5, 0.5, -0.5),
+-            (0.5, -0.5, 0.5),
+-            (0.5, -0.5, -0.5),
+-        ]
+-
+-        indices = [
+-            (0, 0),
+-            (0, 1),
+-            (0, 2),
+-            (0, 3),
+-            (1, 1),
+-            (2, 2),
+-            (3, 3),
+-            (3, 0),
+-            (4, 4),
+-            (4, 5),
+-            (5, 4),
+-            (5, 5),
+-        ]
+-
+-        calculated_indices = [
+-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+-            for jmm1 in jmm1_list
+-        ]
+-        assert_array_almost_equal(calculated_indices, indices)
+-
+-    def test_jmm1_dictionary(self):
+-        """
+-        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
+-        """
+-        d1, d2, d3, d4 = jmm1_dictionary(1)
+-
+-        d1_correct = {
+-            (0, 0): (0.5, 0.5, 0.5),
+-            (0, 1): (0.5, 0.5, -0.5),
+-            (1, 0): (0.5, -0.5, 0.5),
+-            (1, 1): (0.5, -0.5, -0.5),
+-        }
+-
+-        d2_correct = {
+-            (0.5, -0.5, -0.5): (1, 1),
+-            (0.5, -0.5, 0.5): (1, 0),
+-            (0.5, 0.5, -0.5): (0, 1),
+-            (0.5, 0.5, 0.5): (0, 0),
+-        }
+-
+-        d3_correct = {
+-            0: (0.5, 0.5, 0.5),
+-            1: (0.5, 0.5, -0.5),
+-            2: (0.5, -0.5, 0.5),
+-            3: (0.5, -0.5, -0.5),
+-        }
+-
+-        d4_correct = {
+-            (0.5, -0.5, -0.5): 3,
+-            (0.5, -0.5, 0.5): 2,
+-            (0.5, 0.5, -0.5): 1,
+-            (0.5, 0.5, 0.5): 0,
+-        }
+-
+-        assert_equal(d1, d1_correct)
+-        assert_equal(d2, d2_correct)
+-        assert_equal(d3, d3_correct)
+-        assert_equal(d4, d4_correct)
+-
+-        d1, d2, d3, d4 = jmm1_dictionary(2)
+-
+-        d1_correct = {
+-            (3, 3): (0.0, -0.0, -0.0),
+-            (2, 2): (1.0, -1.0, -1.0),
+-            (2, 1): (1.0, -1.0, 0.0),
+-            (2, 0): (1.0, -1.0, 1.0),
+-            (1, 2): (1.0, 0.0, -1.0),
+-            (1, 1): (1.0, 0.0, 0.0),
+-            (1, 0): (1.0, 0.0, 1.0),
+-            (0, 2): (1.0, 1.0, -1.0),
+-            (0, 1): (1.0, 1.0, 0.0),
+-            (0, 0): (1.0, 1.0, 1.0),
+-        }
+-
+-        d2_correct = {
+-            (0.0, -0.0, -0.0): (3, 3),
+-            (1.0, -1.0, -1.0): (2, 2),
+-            (1.0, -1.0, 0.0): (2, 1),
+-            (1.0, -1.0, 1.0): (2, 0),
+-            (1.0, 0.0, -1.0): (1, 2),
+-            (1.0, 0.0, 0.0): (1, 1),
+-            (1.0, 0.0, 1.0): (1, 0),
+-            (1.0, 1.0, -1.0): (0, 2),
+-            (1.0, 1.0, 0.0): (0, 1),
+-            (1.0, 1.0, 1.0): (0, 0),
+-        }
+-
+-        d3_correct = {
+-            15: (0.0, -0.0, -0.0),
+-            10: (1.0, -1.0, -1.0),
+-            9: (1.0, -1.0, 0.0),
+-            8: (1.0, -1.0, 1.0),
+-            6: (1.0, 0.0, -1.0),
+-            5: (1.0, 0.0, 0.0),
+-            4: (1.0, 0.0, 1.0),
+-            2: (1.0, 1.0, -1.0),
+-            1: (1.0, 1.0, 0.0),
+-            0: (1.0, 1.0, 1.0),
+-        }
+-
+-        d4_correct = {
+-            (0.0, -0.0, -0.0): 15,
+-            (1.0, -1.0, -1.0): 10,
+-            (1.0, -1.0, 0.0): 9,
+-            (1.0, -1.0, 1.0): 8,
+-            (1.0, 0.0, -1.0): 6,
+-            (1.0, 0.0, 0.0): 5,
+-            (1.0, 0.0, 1.0): 4,
+-            (1.0, 1.0, -1.0): 2,
+-            (1.0, 1.0, 0.0): 1,
+-            (1.0, 1.0, 1.0): 0,
+-        }
+-
+-        assert_equal(d1, d1_correct)
+-        assert_equal(d2, d2_correct)
+-        assert_equal(d3, d3_correct)
+-        assert_equal(d4, d4_correct)
+-
+-    def test_lindbladian(self):
+-        """
+-        PIQS: Test the generation of the Lindbladian matrix.
+-        """
+-        N = 1
+-        gCE = 0.5
+-        gCD = 0.5
+-        gCP = 0.5
+-        gE = 0.1
+-        gD = 0.1
+-        gP = 0.1
+-
+-        system = Dicke(
+-            N=N,
+-            emission=gE,
+-            pumping=gP,
+-            dephasing=gD,
+-            collective_emission=gCE,
+-            collective_pumping=gCP,
+-            collective_dephasing=gCD,
+-        )
+-
+-        lindbladian = system.lindbladian()
+-        Ldata = np.zeros((4, 4), dtype="complex")
+-        Ldata[0] = [-0.6, 0, 0, 0.6]
+-        Ldata[1] = [0, -0.9, 0, 0]
+-        Ldata[2] = [0, 0, -0.9, 0]
+-        Ldata[3] = [0.6, 0, 0, -0.6]
+-
+-        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
+-        assert_array_almost_equal(lindbladian.full(), Ldata)
+-        N = 2
+-        gCE = 0.5
+-        gCD = 0.5
+-        gCP = 0.5
+-        gE = 0.1
+-        gD = 0.1
+-        gP = 0.1
+-        system = Dicke(
+-            N=N,
+-            emission=gE,
+-            pumping=gP,
+-            dephasing=gD,
+-            collective_emission=gCE,
+-            collective_pumping=gCP,
+-            collective_dephasing=gCD,
+-        )
+-
+-        lindbladian = system.lindbladian()
+-
+-        Ldata = np.zeros((16, 16), dtype="complex")
+-        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
+-        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
+-        Ldata[2, 2] = -2.2999999999999998
+-        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
+-        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
+-            1.1,
+-            -2.25,
+-            1.1,
+-            0.05,
+-        )
+-        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
+-        Ldata[8, 8] = -2.2999999999999998
+-        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
+-        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
+-        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
+-            0.1,
+-            0.05,
+-            0.1,
+-            -0.25,
+-        )
+-        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
+-        assert_array_almost_equal(lindbladian.full(), Ldata)
+-
+-    def test_gamma(self):
+-        """
+-        PIQS: Test the calculation of various gamma values for diagonal system.
+-
+-        For N = 6 |j, m> would be :
+-
+-        | 3, 3>
+-        | 3, 2> | 2, 2>
+-        | 3, 1> | 2, 1> | 1, 1>
+-        | 3, 0> | 2, 0> | 1, 0> |0, 0>
+-        | 3,-1> | 2,-1> | 1,-1>
+-        | 3,-2> | 2,-2>
+-        | 3,-3>
+-        """
+-        N = 6
+-        collective_emission = 1.0
+-        emission = 1.0
+-        dephasing = 1.0
+-        pumping = 1.0
+-        collective_pumping = 1.0
+-        model = _Dicke(
+-            N,
+-            collective_emission=collective_emission,
+-            emission=emission,
+-            dephasing=dephasing,
+-            pumping=pumping,
+-            collective_pumping=collective_pumping,
+-        )
+-        tau_calculated = [
+-            model.gamma3((3, 1, 1)),
+-            model.gamma2((2, 1, 1)),
+-            model.gamma4((1, 1, 1)),
+-            model.gamma5((3, 0, 0)),
+-            model.gamma1((2, 0, 0)),
+-            model.gamma6((1, 0, 0)),
+-            model.gamma7((3, -1, -1)),
+-            model.gamma8((2, -1, -1)),
+-            model.gamma9((1, -1, -1)),
+-        ]
+-        tau_real = [
+-            2.0,
+-            8.0,
+-            0.333333,
+-            1.5,
+-            -19.5,
+-            0.666667,
+-            2.0,
+-            8.0,
+-            0.333333,
+-        ]
+-        assert_array_almost_equal(tau_calculated, tau_real)
+-
+-    def test_jspin(self):
+-        """
+-        PIQS: Test calculation of the j algebra relation for the total operators.
+-
+-        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
+-        basis should follow the following algebra
+-        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
+-        """
+-        N_list = [1, 2, 3, 4, 7]
+-
+-        for nn in N_list:
+-            # tests 1
+-            [jx, jy, jz] = jspin(nn)
+-            jp, jm = jspin(nn, "+"), jspin(nn, "-")
+-            test_jxjy = jx * jy - jy * jx
+-            true_jxjy = 1j * jz
+-            test_jpjm = jp * jm - jm * jp
+-            true_jpjm = 2 * jz
+-
+-            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
+-            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
+-
+-            # tests 2
+-            [jx, jy, jz] = jspin(nn)
+-            jp, jm = jspin(nn, "+"), jspin(nn, "-")
+-            test_jxjy = jx * jy - jy * jx
+-            true_jxjy = 1j * jz
+-            test_jpjm = jp * jm - jm * jp
+-            true_jpjm = 2 * jz
+-
+-            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
+-            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
+-
+-            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
+-            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
+-            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
+-            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
+-            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
+-            assert_raises(TypeError, jspin, nn, "q")
+-
+-    def test_j_min_(self):
+-        """
+-        PIQS: Test the `j_min` function.
+-        """
+-        even = [2, 4, 6, 8]
+-        odd = [1, 3, 5, 7]
+-
+-        for i in even:
+-            assert_(j_min(i) == 0)
+-
+-        for i in odd:
+-            assert_(j_min(i) == 0.5)
+-
+-    def test_energy_degeneracy(self):
+-        """
+-        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
+-        """
+-        true_en_deg = [1, 1, 1, 1, 1]
+-        true_en_deg_even = [2, 6, 20]
+-        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
+-        test_en_deg = []
+-        test_en_deg_even = []
+-        test_en_deg_odd = []
+-
+-        for nn in [1, 2, 3, 4, 7]:
+-            test_en_deg.append(energy_degeneracy(nn, nn / 2))
+-
+-        for nn in [2, 4, 6]:
+-            test_en_deg_even.append(energy_degeneracy(nn, 0))
+-
+-        for nn in [1, 3, 7]:
+-            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
+-            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
+-
+-        assert_array_equal(test_en_deg, true_en_deg)
+-        assert_array_equal(test_en_deg_even, true_en_deg_even)
+-        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
+-
+-    def test_state_degeneracy(self):
+-        """
+-        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
+-        state_degeneracy(N, j).
+-        """
+-        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
+-        state_deg = []
+-        state_deg = []
+-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+-            state_deg.append(state_degeneracy(nn, nn / 2))
+-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+-            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
+-        assert_array_equal(state_deg, true_state_deg)
+-
+-        # check error
+-        assert_raises(ValueError, state_degeneracy, 2, -1)
+-
+-    def test_m_degeneracy(self):
+-        """
+-        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
+-        """
+-        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
+-        m_deg = []
+-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+-            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
+-        assert_array_equal(m_deg, true_m_deg)
+-
+-        # check error
+-        assert_raises(ValueError, m_degeneracy, 6, -6)
+-
+-    def test_ap(self):
+-        """
+-        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
+-
+-        For given values of j, m. For a Dicke state,
+-        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
+-        """
+-        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
+-        ap_list = []
+-        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
+-            ap_list.append(ap(10, m) ** 2)
+-
+-        assert_almost_equal(ap_list, true_ap_list)
+-
+-    def test_am(self):
+-        """
+-        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
+-
+-        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
+-        """
+-        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
+-        am_list = []
+-        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
+-            am_list.append(am(10, m) ** 2)
+-
+-        assert_almost_equal(am_list, true_am_list)
+-
+-    def test_spin_algebra(self):
+-        """
+-        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
+-        The list [sx, sy, sz, sp, sm] is checked for N = 2.
+-        """
+-        sx1 = [
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        sx2 = [
+-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        sy1 = [
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        sy2 = [
+-            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
+-        ]
+-
+-        sz1 = [
+-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
+-        ]
+-
+-        sz2 = [
+-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
+-        ]
+-
+-        sp1 = [
+-            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        sp2 = [
+-            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        sm1 = [
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        sm2 = [
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
+-        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
+-        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
+-        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
+-        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
+-        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
+-        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
+-        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
+-        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
+-        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
+-
+-        # test error
+-        assert_raises(TypeError, spin_algebra, 2, "q")
+-
+-    def test_collective_algebra(self):
+-        """
+-        PIQS: Test the generation of the collective algebra in uncoupled basis.
+-
+-        The list [jx, jy, jz] created in the 2^N Hilbert space is
+-        checked for N = 2.
+-        """
+-
+-        jx_n2 = [
+-            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+-            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        jy_n2 = [
+-            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
+-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+-            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
+-        ]
+-
+-        jz_n2 = [
+-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
+-        ]
+-
+-        jp_n2 = [
+-            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        jm_n2 = [
+-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+-            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+-        ]
+-
+-        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
+-        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
+-        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
+-        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
+-        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
+-
+-        # error
+-        assert_raises(TypeError, spin_algebra, 2, "q")
+-
+-    def test_block_matrix(self):
+-        """
+-        PIQS: Test the calculation of the block-diagonal matrix for given N.
+-
+-        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
+-        """
+-        # N = 1 TLSs
+-        block_1 = [[1.0, 1.0], [1.0, 1.0]]
+-
+-        # N = 2 TLSs
+-        block_2 = [
+-            [1.0, 1.0, 1.0, 0.0],
+-            [1.0, 1.0, 1.0, 0.0],
+-            [1.0, 1.0, 1.0, 0.0],
+-            [0.0, 0.0, 0.0, 1.0],
+-        ]
+-
+-        # N = 3 TLSs
+-        block_3 = [
+-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+-            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+-            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+-        ]
+-
+-        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
+-        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
+-        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
+-
+-    def test_dicke_basis(self):
+-        """
+-        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
+-
+-        We test the state with for N = 2,
+-
+-        0   0   0.3 0
+-        0   0.5 0   0
+-        0.3 0   0   0
+-        0   0   0   0.5
+-        """
+-        N = 2
+-        true_dicke_basis = np.zeros((4, 4))
+-        true_dicke_basis[1, 1] = 0.5
+-        true_dicke_basis[-1, -1] = 0.5
+-        true_dicke_basis[0, 2] = 0.3
+-        true_dicke_basis[2, 0] = 0.3
+-        true_dicke_basis = Qobj(true_dicke_basis)
+-        jmm1_1 = {(N / 2, 0, 0): 0.5}
+-        jmm1_2 = {(0, 0, 0): 0.5}
+-        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
+-        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
+-        db1 = dicke_basis(2, jmm1_1)
+-        db2 = dicke_basis(2, jmm1_2)
+-        db3 = dicke_basis(2, jmm1_3)
+-        db4 = dicke_basis(2, jmm1_4)
+-        test_dicke_basis = db1 + db2 + db3 + db4
+-        assert_equal(test_dicke_basis, true_dicke_basis)
+-
+-        # error
+-        assert_raises(AttributeError, dicke_basis, N)
+-
+-    def test_dicke(self):
+-        """
+-        PIQS: Test the calculation of the Dicke state as a pure state.
+-        """
+-        true_excited = np.zeros((4, 4))
+-        true_excited[0, 0] = 1
+-
+-        true_superradiant = np.zeros((4, 4))
+-        true_superradiant[1, 1] = 1
+-
+-        true_subradiant = np.zeros((4, 4))
+-        true_subradiant[-1, -1] = 1
+-
+-        test_excited = dicke(2, 1, 1)
+-        test_superradiant = dicke(2, 1, 0)
+-        test_subradiant = dicke(2, 0, 0)
+-
+-        assert_equal(test_excited, Qobj(true_excited))
+-        assert_equal(test_superradiant, Qobj(true_superradiant))
+-        assert_equal(test_subradiant, Qobj(true_subradiant))
+-
+-    def test_excited(self):
+-        """
+-        PIQS: Test the calculation of the totally excited state density matrix.
+-
+-        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
+-        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
+-        """
+-        N = 3
+-        true_state = np.zeros((6, 6))
+-        true_state[0, 0] = 1
+-        true_state = Qobj(true_state)
+-
+-        test_state = excited(N)
+-        assert_equal(test_state, true_state)
+-
+-        N = 4
+-        true_state = np.zeros((9, 9))
+-        true_state[0, 0] = 1
+-        true_state = Qobj(true_state)
+-
+-        test_state = excited(N)
+-        assert_equal(test_state, true_state)
+-
+-        # uncoupled
+-        test_state_uncoupled = excited(2, basis="uncoupled")
+-        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
+-        assert_array_equal(test_state_uncoupled.shape, (4, 4))
+-        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
+-
+-    def test_superradiant(self):
+-        """
+-        PIQS: Test the calculation of the superradiant state density matrix.
+-
+-        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
+-        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
+-        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
+-        """
+-        N = 3
+-        true_state = np.zeros((6, 6))
+-        true_state[1, 1] = 1
+-        true_state = Qobj(true_state)
+-        test_state = superradiant(N)
+-        assert_equal(test_state, true_state)
+-        N = 4
+-        true_state = np.zeros((9, 9))
+-        true_state[2, 2] = 1
+-        true_state = Qobj(true_state)
+-        test_state = superradiant(N)
+-        assert_equal(test_state, true_state)
+-
+-        # uncoupled
+-        test_state_uncoupled = superradiant(2, basis="uncoupled")
+-        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
+-        assert_array_equal(test_state_uncoupled.shape, (4, 4))
+-        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
+-
+-    def test_ghz(self):
+-        """
+-        PIQS: Test the calculation of the density matrix of the GHZ state.
+-
+-        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
+-        """
+-        ghz_dicke = Qobj(
+-            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
+-        )
+-        ghz_uncoupled = Qobj(
+-            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
+-        )
+-        ghz_uncoupled.dims = [[2, 2], [2, 2]]
+-        assert_equal(ghz(2), ghz_dicke)
+-        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
+-
+-    def test_ground(self):
+-        """
+-        PIQS: Test the calculation of the density matrix of the ground state.
+-
+-        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
+-        """
+-        zeros = np.zeros((4, 4), dtype=np.complex128)
+-        gdicke = zeros.copy()
+-        guncoupled = zeros.copy()
+-        gdicke[2, 2] = 1
+-        guncoupled[3, 3] = 1
+-
+-        dim_dicke = [[4], [4]]
+-        dim_uncoupled = [[2, 2], [2, 2]]
+-
+-        test_ground_dicke = ground(2)
+-        test_ground_uncoupled = ground(2, "uncoupled")
+-
+-        assert_array_equal(test_ground_dicke.full(), gdicke)
+-        assert_array_equal(test_ground_dicke.dims, dim_dicke)
+-        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
+-        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
+-
+-    def test_identity_uncoupled(self):
+-        """
+-        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
+-        """
+-        test_identity = identity_uncoupled(4)
+-        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
+-        assert_array_equal(
+-            np.diag(test_identity.full()), np.ones(16, np.complex128)
+-        )
+-
+-    def test_css(self):
+-        """
+-        PIQS: Test the calculation of the CSS state.
+-        """
+-        test_css_uncoupled = css(2, basis="uncoupled")
+-        test_css_dicke = css(2)
+-        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
+-        css_dicke = np.array(
+-            [
+-                [
+-                    0.25000000 + 0.0j,
+-                    0.35355339 + 0.0j,
+-                    0.25000000 + 0.0j,
+-                    0.00000000 + 0.0j,
+-                ],
+-                [
+-                    0.35355339 + 0.0j,
+-                    0.50000000 + 0.0j,
+-                    0.35355339 + 0.0j,
+-                    0.00000000 + 0.0j,
+-                ],
+-                [
+-                    0.25000000 + 0.0j,
+-                    0.35355339 + 0.0j,
+-                    0.25000000 + 0.0j,
+-                    0.00000000 + 0.0j,
+-                ],
+-                [
+-                    0.00000000 + 0.0j,
+-                    0.00000000 + 0.0j,
+-                    0.00000000 + 0.0j,
+-                    0.00000000 + 0.0j,
+-                ],
+-            ]
+-        )
+-        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
+-        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
+-
+-    def test_collapse_uncoupled(self):
+-        """
+-        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
+-
+-        In the "uncoupled" basis of N two-level system (TLS).
+-        The test is performed for N = 2 and emission = 1.
+-        """
+-        c1 = Qobj(
+-            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
+-            dims=[[2, 2], [2, 2]],
+-        )
+-        c2 = Qobj(
+-            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
+-            dims=[[2, 2], [2, 2]],
+-        )
+-        true_c_ops = [c1, c2]
+-        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
+-        system = Dicke(N=2, emission=1)
+-        assert_equal(true_c_ops, system.c_ops())
+-
+-    def test_get_blocks(self):
+-        """
+-        PIQS: Test the calculation of list of cumulative elements at each block.
+-
+-        For N = 4
+-
+-        1 1 1 1 1
+-        1 1 1 1 1
+-        1 1 1 1 1
+-        1 1 1 1 1
+-        1 1 1 1 1
+-                1 1 1
+-                1 1 1
+-                1 1 1
+-                     1
+-        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
+-        elements have been accounted for and so on.
+-        """
+-        trueb1 = [2]
+-        trueb2 = [3, 4]
+-        trueb3 = [4, 6]
+-        trueb4 = [5, 8, 9]
+-
+-        test_b1 = get_blocks(1)
+-        test_b2 = get_blocks(2)
+-        test_b3 = get_blocks(3)
+-        test_b4 = get_blocks(4)
+-
+-        assert_equal(test_b1, trueb1)
+-        assert_equal(test_b2, trueb2)
+-        assert_equal(test_b3, trueb3)
+-
+-    def test_lindbladian_dims(self):
+-        """
+-        PIQS: Test the calculation of the lindbladian matrix.
+-        """
+-        true_L = [
+-            [-4, 0, 0, 3],
+-            [0, -3.54999995, 0, 0],
+-            [0, 0, -3.54999995, 0],
+-            [4, 0, 0, -3],
+-        ]
+-        true_L = Qobj(true_L)
+-        true_L.dims = [[[2], [2]], [[2], [2]]]
+-        N = 1
+-        test_dicke = _Dicke(
+-            N=N,
+-            pumping=1,
+-            collective_pumping=2,
+-            emission=1,
+-            collective_emission=3,
+-            dephasing=0.1,
+-        )
+-        test_L = test_dicke.lindbladian()
+-        assert_array_almost_equal(test_L.full(), true_L.full())
+-        assert_array_equal(test_L.dims, true_L.dims)
+-
+-    def test_liouvillian(self):
+-        """
+-        PIQS: Test the calculation of the liouvillian matrix.
+-        """
+-        true_L = [
+-            [-4, 0, 0, 3],
+-            [0, -3.54999995, 0, 0],
+-            [0, 0, -3.54999995, 0],
+-            [4, 0, 0, -3],
+-        ]
+-        true_L = Qobj(true_L)
+-        true_L.dims = [[[2], [2]], [[2], [2]]]
+-        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
+-        true_H = Qobj(true_H)
+-        true_H.dims = [[[2], [2]]]
+-        true_liouvillian = [
+-            [-4, -1.0j, 1.0j, 3],
+-            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
+-            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
+-            [4, +1.0j, -1.0j, -3],
+-        ]
+-        true_liouvillian = Qobj(true_liouvillian)
+-        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
+-        N = 1
+-        test_piqs = Dicke(
+-            hamiltonian=sigmaz() + sigmax(),
+-            N=N,
+-            pumping=1,
+-            collective_pumping=2,
+-            emission=1,
+-            collective_emission=3,
+-            dephasing=0.1,
+-        )
+-        test_liouvillian = test_piqs.liouvillian()
+-        test_hamiltonian = test_piqs.hamiltonian
+-        assert_array_almost_equal(
+-            test_liouvillian.full(), true_liouvillian.full()
+-        )
+-        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
+-        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
+-
+-        # no Hamiltonian
+-        test_piqs = Dicke(
+-            N=N,
+-            pumping=1,
+-            collective_pumping=2,
+-            emission=1,
+-            collective_emission=3,
+-            dephasing=0.1,
+-        )
+-        liouv = test_piqs.liouvillian()
+-        lindblad = test_piqs.lindbladian()
+-        assert_equal(liouv, lindblad)
+-
+-    def test_gamma1(self):
+-        """
+-        PIQS: Test the calculation of gamma1.
+-        """
+-        true_gamma_1 = -2
+-        true_gamma_2 = -3
+-        true_gamma_3 = -7
+-        true_gamma_4 = -1
+-        true_gamma_5 = 0
+-        true_gamma_6 = 0
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, collective_emission=1)
+-        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
+-        test_dicke = _Dicke(N=N, emission=1)
+-        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
+-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+-        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
+-        test_dicke = _Dicke(N=N, dephasing=4)
+-        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
+-        test_dicke = _Dicke(N=N, collective_pumping=2)
+-        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
+-        test_dicke = _Dicke(N=N, collective_dephasing=2)
+-        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-        assert_almost_equal(true_gamma_5, test_gamma_5)
+-        assert_almost_equal(true_gamma_6, test_gamma_6)
+-
+-    def test_gamma2(self):
+-        """
+-        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 2
+-        true_gamma_2 = 1.5
+-        true_gamma_3 = 5.5
+-        true_gamma_4 = 0
+-        true_gamma_5 = 0
+-        true_gamma_6 = 0
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, collective_emission=1)
+-        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
+-        test_dicke = _Dicke(N=N, emission=1)
+-        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
+-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+-        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
+-        test_dicke = _Dicke(N=N, dephasing=4)
+-        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
+-        test_dicke = _Dicke(N=N, collective_pumping=2)
+-        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
+-        test_dicke = _Dicke(N=N, collective_dephasing=2)
+-        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-        assert_almost_equal(true_gamma_5, test_gamma_5)
+-        assert_almost_equal(true_gamma_6, test_gamma_6)
+-
+-    def test_gamma3(self):
+-        """
+-        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 0
+-        true_gamma_2 = 1.3333333730697632
+-        true_gamma_3 = 1.3333333730697632
+-        true_gamma_4 = 0
+-        true_gamma_5 = 0
+-        true_gamma_6 = 0
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, collective_emission=1)
+-        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
+-        test_dicke = _Dicke(N=N, emission=1)
+-        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
+-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+-        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
+-        test_dicke = _Dicke(N=N, dephasing=4)
+-        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
+-        test_dicke = _Dicke(N=N, collective_pumping=2)
+-        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
+-        test_dicke = _Dicke(N=N, collective_dephasing=2)
+-        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
+-        #
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-        assert_almost_equal(true_gamma_5, test_gamma_5)
+-        assert_almost_equal(true_gamma_6, test_gamma_6)
+-
+-    def test_gamma4(self):
+-        """
+-        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 0.1666666716337204
+-        true_gamma_2 = 2
+-        true_gamma_3 = 0
+-        true_gamma_4 = 0.40824830532073975
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+-        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
+-        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
+-        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
+-        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-
+-    def test_gamma5(self):
+-        """
+-        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 0
+-        true_gamma_2 = 0
+-        true_gamma_3 = 0.75
+-        true_gamma_4 = 0
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, dephasing=1)
+-        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
+-        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
+-        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
+-        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-
+-    def test_gamma6(self):
+-        """
+-        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 0.25
+-        true_gamma_2 = 1
+-        true_gamma_3 = 0
+-        true_gamma_4 = 0.25
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, dephasing=1)
+-        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
+-        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
+-        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
+-        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-
+-    def test_gamma7(self):
+-        """
+-        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 0
+-        true_gamma_2 = 0.5
+-        true_gamma_3 = 0
+-        true_gamma_4 = 1.5
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, pumping=1)
+-        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
+-        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
+-        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
+-        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-
+-    def test_gamma8(self):
+-        """
+-        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 0
+-        true_gamma_2 = 13.5
+-        true_gamma_3 = 5.5
+-        true_gamma_4 = 13.5
+-
+-        N = 4
+-        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
+-        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
+-        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
+-        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
+-        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
+-
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-
+-    def test_gamma9(self):
+-        """
+-        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
+-        """
+-        true_gamma_1 = 1
+-        true_gamma_2 = 0
+-        true_gamma_3 = 0.5
+-        true_gamma_4 = 0
+-        N = 4
+-        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
+-        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
+-        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
+-        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
+-        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
+-        assert_almost_equal(true_gamma_1, test_gamma_1)
+-        assert_almost_equal(true_gamma_2, test_gamma_2)
+-        assert_almost_equal(true_gamma_3, test_gamma_3)
+-        assert_almost_equal(true_gamma_4, test_gamma_4)
+-
+-
+-class TestPim:
+-    """
+-    Tests for the `qutip.piqs.Pim` class.
+-    """
+-
+-    def test_gamma(self):
+-        """
+-        PIQS: Test the calculation of various gamma values for diagonal system.
+-
+-        For N = 6 |j, m> would be :
+-
+-        | 3, 3>
+-        | 3, 2> | 2, 2>
+-        | 3, 1> | 2, 1> | 1, 1>
+-        | 3, 0> | 2, 0> | 1, 0> |0, 0>
+-        | 3,-1> | 2,-1> | 1,-1>
+-        | 3,-2> | 2,-2>
+-        | 3,-3>
+-        """
+-        N = 6
+-        collective_emission = 1.0
+-        emission = 1.0
+-        dephasing = 1.0
+-        pumping = 1.0
+-        collective_pumping = 1.0
+-        model = Pim(
+-            N,
+-            collective_emission=collective_emission,
+-            emission=emission,
+-            dephasing=dephasing,
+-            pumping=pumping,
+-            collective_pumping=collective_pumping,
+-        )
+-        tau_calculated = [
+-            model.tau3(3, 1),
+-            model.tau2(2, 1),
+-            model.tau4(1, 1),
+-            model.tau5(3, 0),
+-            model.tau1(2, 0),
+-            model.tau6(1, 0),
+-            model.tau7(3, -1),
+-            model.tau8(2, -1),
+-            model.tau9(1, -1),
+-        ]
+-        tau_real = [
+-            2.0,
+-            8.0,
+-            0.333333,
+-            1.5,
+-            -19.5,
+-            0.666667,
+-            2.0,
+-            8.0,
+-            0.333333,
+-        ]
+-        assert_array_almost_equal(tau_calculated, tau_real)
+-
+-    def test_isdicke(self):
+-        """
+-        PIQS: Test the `isdicke` function
+-        """
+-        N1 = 1
+-        g0 = 0.01
+-        nth = 0.01
+-        gP = g0 * nth
+-        gL = g0 * (0.1 + nth)
+-        gS = 0.1
+-        gD = 0.1
+-
+-        pim1 = Pim(N1, gS, gL, gD, gP)
+-
+-        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
+-        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
+-
+-        N2 = 4
+-
+-        pim2 = Pim(N2, gS, gL, gD, gP)
+-        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
+-        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
+-
+-        assert_array_equal(dicke_labels, [True, False, True, False, True])
+-
+-    def test_isdiagonal(self):
+-        """
+-        PIQS: Test the isdiagonal function.
+-        """
+-        mat1 = np.array([[1, 2], [3, 4]])
+-        mat2 = np.array([[1, 0.0], [0.0, 2]])
+-        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
+-        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
+-        assert_equal(isdiagonal(mat1), False)
+-        assert_equal(isdiagonal(mat2), True)
+-        assert_equal(isdiagonal(mat3), False)
+-        assert_equal(isdiagonal(mat4), True)
+-
+-    def test_pisolve(self):
+-        """
+-        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
+-        """
+-        jx, jy, jz = jspin(4)
+-        jp, jm = jspin(4, "+"), jspin(4, "-")
+-
+-    def test_coefficient_matrix(self):
+-        """
+-        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
+-        """
+-        N = 2
+-        ensemble = Pim(N, emission=1)
+-        test_matrix = ensemble.coefficient_matrix().toarray()
+-        ensemble2 = Dicke(N, emission=1)
+-        test_matrix2 = ensemble.coefficient_matrix().toarray()
+-        true_matrix = [
+-            [-2, 0, 0, 0],
+-            [1, -1, 0, 0],
+-            [0, 1, 0, 1.0],
+-            [1, 0, 0, -1.0],
+-        ]
+-
+-        assert_array_almost_equal(test_matrix, true_matrix)
+-        assert_array_almost_equal(test_matrix2, true_matrix)
+-
+-    def test_pisolve(self):
+-        """
+-        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
+-        """
+-        jx, jy, jz = jspin(4)
+-        jp, jm = jspin(4, "+"), jspin(4, "-")
+-        non_diag_hamiltonian = jx
+-        diag_hamiltonian = jz
+-
+-        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
+-        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
+-
+-        diag_initial_state = dicke(4, 1, 0)
+-        non_diag_initial_state = ghz(4)
+-        tlist = np.linspace(0, 10, 100)
+-
+-        assert_raises(
+-            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
+-        )
+-        assert_raises(
+-            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
+-        )
+-        assert_raises(
+-            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
+-        )
+-
+-        non_dicke_initial_state = excited(4, basis="uncoupled")
+-        assert_raises(
+-            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
+-        )
+-
+-        # no Hamiltonian
+-        no_hamiltonian_system = Dicke(4, emission=0.1)
+-        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
+-        assert_equal(True, len(result.states) > 0)
+-
+-
+-if __name__ == "__main__":
+-    run_module_suite()
++"""
++Tests for Permutational Invariant Quantum solver (PIQS).
++"""
++import numpy as np
++from numpy.testing import (
++    assert_,
++    run_module_suite,
++    assert_raises,
++    assert_array_equal,
++    assert_array_almost_equal,
++    assert_almost_equal,
++    assert_equal,
++)
++from scipy.sparse import block_diag
++from qutip import Qobj, entropy_vn, sigmax, sigmaz
++from qutip.solve._piqs import (
++    get_blocks,
++    j_min,
++    j_vals,
++    m_vals,
++    _num_dicke_states,
++    _num_dicke_ladders,
++    get_index,
++    jmm1_dictionary,
++)
++from qutip.solve._piqs import Dicke as _Dicke
++from qutip.solve.piqs import *
++
++import sys
++import unittest
++
++
++# Disable tests for python2 as qutip.piqs does not support python2.
++if sys.version_info[0] < 3:
++    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
++
++
++class TestDicke:
++    """
++    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
++    """
++
++    def test_num_dicke_states(self):
++        """
++        PIQS: Test the `num_dicke_state` function.
++        """
++        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
++        dicke_states = [num_dicke_states(i) for i in N_list]
++        assert_array_equal(
++            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
++        )
++        N = -1
++        assert_raises(ValueError, num_dicke_states, N)
++        N = 0.2
++        assert_raises(ValueError, num_dicke_states, N)
++
++    def test_num_tls(self):
++        """
++        PIQS: Test the `num_two_level` function.
++        """
++        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
++        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
++        calculated_N = [num_tls(i) for i in N_dicke]
++        assert_array_equal(calculated_N, N)
++
++    def test_num_dicke_ladders(self):
++        """
++        PIQS: Test the `_num_dicke_ladders` function.
++        """
++        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
++        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
++        assert_array_equal(ndl, ndl_true)
++
++    def test_get_blocks(self):
++        """
++        PIQS: Test the function to get blocks.
++        """
++        N_list = [1, 2, 5, 7]
++        blocks = [
++            np.array([2]),
++            np.array([3, 4]),
++            np.array([6, 10, 12]),
++            np.array([8, 14, 18, 20]),
++        ]
++        calculated_blocks = [get_blocks(i) for i in N_list]
++        for (i, j) in zip(calculated_blocks, blocks):
++            assert_array_equal(i, j)
++
++    def test_j_vals(self):
++        """
++        PIQS: Test calculation of j values for given N.
++        """
++        N_list = [1, 2, 3, 4, 7]
++        j_vals_real = [
++            np.array([0.5]),
++            np.array([0.0, 1.0]),
++            np.array([0.5, 1.5]),
++            np.array([0.0, 1.0, 2.0]),
++            np.array([0.5, 1.5, 2.5, 3.5]),
++        ]
++        j_vals_calc = [j_vals(i) for i in N_list]
++
++        for (i, j) in zip(j_vals_calc, j_vals_real):
++            assert_array_equal(i, j)
++
++    def test_m_vals(self):
++        """
++        PIQS: Test calculation of m values for a particular j.
++        """
++        j_list = [0.5, 1, 1.5, 2, 2.5]
++        m_real = [
++            np.array([-0.5, 0.5]),
++            np.array([-1, 0, 1]),
++            np.array([-1.5, -0.5, 0.5, 1.5]),
++            np.array([-2, -1, 0, 1, 2]),
++            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
++        ]
++
++        m_calc = [m_vals(i) for i in j_list]
++        for (i, j) in zip(m_real, m_calc):
++            assert_array_equal(i, j)
++
++    def test_dicke_blocks(self):
++        """
++        PIQS: Test the `dicke_blocks` function.
++        """
++        # test 1
++        # mixed state with non-symmetrical block matrix elements
++        N = 3
++        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
++        test_blocks = dicke_blocks(true_matrix)
++        test_matrix = Qobj(block_diag(test_blocks))
++        assert_(test_matrix == true_matrix)
++        # test 2
++        # all elements in block-diagonal matrix
++        N = 4
++        true_matrix = Qobj(block_matrix(N)).unit()
++        test_blocks = dicke_blocks(true_matrix)
++        test_matrix = Qobj(block_diag(test_blocks))
++        assert_(test_matrix == true_matrix)
++
++    def test_dicke_blocks_full(self):
++        """
++        PIQS: Test the `dicke_blocks_full` function.
++        """
++        N = 3
++        test_blocks = dicke_blocks_full(excited(3))
++        test_matrix = Qobj(block_diag(test_blocks))
++        true_expanded = np.zeros((8, 8))
++        true_expanded[0, 0] = 1.0
++        assert_(test_matrix == Qobj(true_expanded))
++
++    def test_dicke_function_trace(self):
++        """
++        PIQS: Test the `dicke_function_trace` function.
++        """
++        ## test for N odd
++        N = 3
++        # test trace
++        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
++        f = lambda x: x
++        test_val = dicke_function_trace(f, rho_mixed)
++        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
++        true_val2 = (rho_mixed).tr()
++        # test with linear function (trace)
++        assert_almost_equal(test_val, true_val)
++        assert_almost_equal(test_val, true_val2)
++        # test with nonlinear function
++        f = lambda rho: rho ** 3
++        test_val3 = dicke_function_trace(f, rho_mixed)
++        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
++        assert_almost_equal(test_val3, true_val3)
++        ## test for N even
++        N = 4
++        # test trace
++        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
++        f = lambda x: x
++        test_val = dicke_function_trace(f, rho_mixed)
++        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
++        true_val2 = (rho_mixed).tr()
++        # test with linear function (trace)
++        assert_almost_equal(test_val, true_val)
++        assert_almost_equal(test_val, true_val2)
++        # test with nonlinear function
++        f = lambda rho: rho ** 3
++        test_val3 = dicke_function_trace(f, rho_mixed)
++        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
++        assert np.allclose(test_val3, true_val3)
++
++    def test_entropy_vn_dicke(self):
++        """
++        PIQS: Test the `entropy_vn_dicke` function.
++        """
++        N = 3
++        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
++        test_val = entropy_vn_dicke(rho_mixed)
++        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
++        assert np.allclose(test_val, true_val)
++
++    def test_purity_dicke(self):
++        """
++        PIQS: Test the `purity_dicke` function.
++        """
++        N = 3
++        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
++        test_val = purity_dicke(rho_mixed)
++        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
++        assert np.allclose(test_val, true_val)
++
++    def test_get_index(self):
++        """
++        PIQS: Test the index fetching function for given j, m, m1 value.
++        """
++        N = 1
++        jmm1_list = [
++            (0.5, 0.5, 0.5),
++            (0.5, 0.5, -0.5),
++            (0.5, -0.5, 0.5),
++            (0.5, -0.5, -0.5),
++        ]
++        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
++
++        blocks = get_blocks(N)
++        calculated_indices = [
++            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
++            for jmm1 in jmm1_list
++        ]
++        assert_array_almost_equal(calculated_indices, indices)
++        N = 2
++        blocks = get_blocks(N)
++        jmm1_list = [
++            (1, 1, 1),
++            (1, 1, 0),
++            (1, 1, -1),
++            (1, 0, 1),
++            (1, 0, 0),
++            (1, 0, -1),
++            (1, -1, 1),
++            (1, -1, 0),
++            (1, -1, -1),
++            (0, 0, 0),
++        ]
++        indices = [
++            (0, 0),
++            (0, 1),
++            (0, 2),
++            (1, 0),
++            (1, 1),
++            (1, 2),
++            (2, 0),
++            (2, 1),
++            (2, 2),
++            (3, 3),
++        ]
++        calculated_indices = [
++            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
++            for jmm1 in jmm1_list
++        ]
++        assert_array_almost_equal(calculated_indices, indices)
++        N = 3
++        blocks = get_blocks(N)
++        jmm1_list = [
++            (1.5, 1.5, 1.5),
++            (1.5, 1.5, 0.5),
++            (1.5, 1.5, -0.5),
++            (1.5, 1.5, -1.5),
++            (1.5, 0.5, 0.5),
++            (1.5, -0.5, -0.5),
++            (1.5, -1.5, -1.5),
++            (1.5, -1.5, 1.5),
++            (0.5, 0.5, 0.5),
++            (0.5, 0.5, -0.5),
++            (0.5, -0.5, 0.5),
++            (0.5, -0.5, -0.5),
++        ]
++
++        indices = [
++            (0, 0),
++            (0, 1),
++            (0, 2),
++            (0, 3),
++            (1, 1),
++            (2, 2),
++            (3, 3),
++            (3, 0),
++            (4, 4),
++            (4, 5),
++            (5, 4),
++            (5, 5),
++        ]
++
++        calculated_indices = [
++            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
++            for jmm1 in jmm1_list
++        ]
++        assert_array_almost_equal(calculated_indices, indices)
++
++    def test_jmm1_dictionary(self):
++        """
++        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
++        """
++        d1, d2, d3, d4 = jmm1_dictionary(1)
++
++        d1_correct = {
++            (0, 0): (0.5, 0.5, 0.5),
++            (0, 1): (0.5, 0.5, -0.5),
++            (1, 0): (0.5, -0.5, 0.5),
++            (1, 1): (0.5, -0.5, -0.5),
++        }
++
++        d2_correct = {
++            (0.5, -0.5, -0.5): (1, 1),
++            (0.5, -0.5, 0.5): (1, 0),
++            (0.5, 0.5, -0.5): (0, 1),
++            (0.5, 0.5, 0.5): (0, 0),
++        }
++
++        d3_correct = {
++            0: (0.5, 0.5, 0.5),
++            1: (0.5, 0.5, -0.5),
++            2: (0.5, -0.5, 0.5),
++            3: (0.5, -0.5, -0.5),
++        }
++
++        d4_correct = {
++            (0.5, -0.5, -0.5): 3,
++            (0.5, -0.5, 0.5): 2,
++            (0.5, 0.5, -0.5): 1,
++            (0.5, 0.5, 0.5): 0,
++        }
++
++        assert_equal(d1, d1_correct)
++        assert_equal(d2, d2_correct)
++        assert_equal(d3, d3_correct)
++        assert_equal(d4, d4_correct)
++
++        d1, d2, d3, d4 = jmm1_dictionary(2)
++
++        d1_correct = {
++            (3, 3): (0.0, -0.0, -0.0),
++            (2, 2): (1.0, -1.0, -1.0),
++            (2, 1): (1.0, -1.0, 0.0),
++            (2, 0): (1.0, -1.0, 1.0),
++            (1, 2): (1.0, 0.0, -1.0),
++            (1, 1): (1.0, 0.0, 0.0),
++            (1, 0): (1.0, 0.0, 1.0),
++            (0, 2): (1.0, 1.0, -1.0),
++            (0, 1): (1.0, 1.0, 0.0),
++            (0, 0): (1.0, 1.0, 1.0),
++        }
++
++        d2_correct = {
++            (0.0, -0.0, -0.0): (3, 3),
++            (1.0, -1.0, -1.0): (2, 2),
++            (1.0, -1.0, 0.0): (2, 1),
++            (1.0, -1.0, 1.0): (2, 0),
++            (1.0, 0.0, -1.0): (1, 2),
++            (1.0, 0.0, 0.0): (1, 1),
++            (1.0, 0.0, 1.0): (1, 0),
++            (1.0, 1.0, -1.0): (0, 2),
++            (1.0, 1.0, 0.0): (0, 1),
++            (1.0, 1.0, 1.0): (0, 0),
++        }
++
++        d3_correct = {
++            15: (0.0, -0.0, -0.0),
++            10: (1.0, -1.0, -1.0),
++            9: (1.0, -1.0, 0.0),
++            8: (1.0, -1.0, 1.0),
++            6: (1.0, 0.0, -1.0),
++            5: (1.0, 0.0, 0.0),
++            4: (1.0, 0.0, 1.0),
++            2: (1.0, 1.0, -1.0),
++            1: (1.0, 1.0, 0.0),
++            0: (1.0, 1.0, 1.0),
++        }
++
++        d4_correct = {
++            (0.0, -0.0, -0.0): 15,
++            (1.0, -1.0, -1.0): 10,
++            (1.0, -1.0, 0.0): 9,
++            (1.0, -1.0, 1.0): 8,
++            (1.0, 0.0, -1.0): 6,
++            (1.0, 0.0, 0.0): 5,
++            (1.0, 0.0, 1.0): 4,
++            (1.0, 1.0, -1.0): 2,
++            (1.0, 1.0, 0.0): 1,
++            (1.0, 1.0, 1.0): 0,
++        }
++
++        assert_equal(d1, d1_correct)
++        assert_equal(d2, d2_correct)
++        assert_equal(d3, d3_correct)
++        assert_equal(d4, d4_correct)
++
++    def test_lindbladian(self):
++        """
++        PIQS: Test the generation of the Lindbladian matrix.
++        """
++        N = 1
++        gCE = 0.5
++        gCD = 0.5
++        gCP = 0.5
++        gE = 0.1
++        gD = 0.1
++        gP = 0.1
++
++        system = Dicke(
++            N=N,
++            emission=gE,
++            pumping=gP,
++            dephasing=gD,
++            collective_emission=gCE,
++            collective_pumping=gCP,
++            collective_dephasing=gCD,
++        )
++
++        lindbladian = system.lindbladian()
++        Ldata = np.zeros((4, 4), dtype="complex")
++        Ldata[0] = [-0.6, 0, 0, 0.6]
++        Ldata[1] = [0, -0.9, 0, 0]
++        Ldata[2] = [0, 0, -0.9, 0]
++        Ldata[3] = [0.6, 0, 0, -0.6]
++
++        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
++        assert_array_almost_equal(lindbladian.full(), Ldata)
++        N = 2
++        gCE = 0.5
++        gCD = 0.5
++        gCP = 0.5
++        gE = 0.1
++        gD = 0.1
++        gP = 0.1
++        system = Dicke(
++            N=N,
++            emission=gE,
++            pumping=gP,
++            dephasing=gD,
++            collective_emission=gCE,
++            collective_pumping=gCP,
++            collective_dephasing=gCD,
++        )
++
++        lindbladian = system.lindbladian()
++
++        Ldata = np.zeros((16, 16), dtype="complex")
++        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
++        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
++        Ldata[2, 2] = -2.2999999999999998
++        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
++        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
++            1.1,
++            -2.25,
++            1.1,
++            0.05,
++        )
++        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
++        Ldata[8, 8] = -2.2999999999999998
++        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
++        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
++        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
++            0.1,
++            0.05,
++            0.1,
++            -0.25,
++        )
++        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
++        assert_array_almost_equal(lindbladian.full(), Ldata)
++
++    def test_gamma(self):
++        """
++        PIQS: Test the calculation of various gamma values for diagonal system.
++
++        For N = 6 |j, m> would be :
++
++        | 3, 3>
++        | 3, 2> | 2, 2>
++        | 3, 1> | 2, 1> | 1, 1>
++        | 3, 0> | 2, 0> | 1, 0> |0, 0>
++        | 3,-1> | 2,-1> | 1,-1>
++        | 3,-2> | 2,-2>
++        | 3,-3>
++        """
++        N = 6
++        collective_emission = 1.0
++        emission = 1.0
++        dephasing = 1.0
++        pumping = 1.0
++        collective_pumping = 1.0
++        model = _Dicke(
++            N,
++            collective_emission=collective_emission,
++            emission=emission,
++            dephasing=dephasing,
++            pumping=pumping,
++            collective_pumping=collective_pumping,
++        )
++        tau_calculated = [
++            model.gamma3((3, 1, 1)),
++            model.gamma2((2, 1, 1)),
++            model.gamma4((1, 1, 1)),
++            model.gamma5((3, 0, 0)),
++            model.gamma1((2, 0, 0)),
++            model.gamma6((1, 0, 0)),
++            model.gamma7((3, -1, -1)),
++            model.gamma8((2, -1, -1)),
++            model.gamma9((1, -1, -1)),
++        ]
++        tau_real = [
++            2.0,
++            8.0,
++            0.333333,
++            1.5,
++            -19.5,
++            0.666667,
++            2.0,
++            8.0,
++            0.333333,
++        ]
++        assert_array_almost_equal(tau_calculated, tau_real)
++
++    def test_jspin(self):
++        """
++        PIQS: Test calculation of the j algebra relation for the total operators.
++
++        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
++        basis should follow the following algebra
++        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
++        """
++        N_list = [1, 2, 3, 4, 7]
++
++        for nn in N_list:
++            # tests 1
++            [jx, jy, jz] = jspin(nn)
++            jp, jm = jspin(nn, "+"), jspin(nn, "-")
++            test_jxjy = jx * jy - jy * jx
++            true_jxjy = 1j * jz
++            test_jpjm = jp * jm - jm * jp
++            true_jpjm = 2 * jz
++
++            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
++            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
++
++            # tests 2
++            [jx, jy, jz] = jspin(nn)
++            jp, jm = jspin(nn, "+"), jspin(nn, "-")
++            test_jxjy = jx * jy - jy * jx
++            true_jxjy = 1j * jz
++            test_jpjm = jp * jm - jm * jp
++            true_jpjm = 2 * jz
++
++            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
++            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
++
++            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
++            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
++            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
++            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
++            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
++            assert_raises(TypeError, jspin, nn, "q")
++
++    def test_j_min_(self):
++        """
++        PIQS: Test the `j_min` function.
++        """
++        even = [2, 4, 6, 8]
++        odd = [1, 3, 5, 7]
++
++        for i in even:
++            assert_(j_min(i) == 0)
++
++        for i in odd:
++            assert_(j_min(i) == 0.5)
++
++    def test_energy_degeneracy(self):
++        """
++        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
++        """
++        true_en_deg = [1, 1, 1, 1, 1]
++        true_en_deg_even = [2, 6, 20]
++        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
++        test_en_deg = []
++        test_en_deg_even = []
++        test_en_deg_odd = []
++
++        for nn in [1, 2, 3, 4, 7]:
++            test_en_deg.append(energy_degeneracy(nn, nn / 2))
++
++        for nn in [2, 4, 6]:
++            test_en_deg_even.append(energy_degeneracy(nn, 0))
++
++        for nn in [1, 3, 7]:
++            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
++            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
++
++        assert_array_equal(test_en_deg, true_en_deg)
++        assert_array_equal(test_en_deg_even, true_en_deg_even)
++        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
++
++    def test_state_degeneracy(self):
++        """
++        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
++        state_degeneracy(N, j).
++        """
++        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
++        state_deg = []
++        state_deg = []
++        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
++            state_deg.append(state_degeneracy(nn, nn / 2))
++        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
++            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
++        assert_array_equal(state_deg, true_state_deg)
++
++        # check error
++        assert_raises(ValueError, state_degeneracy, 2, -1)
++
++    def test_m_degeneracy(self):
++        """
++        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
++        """
++        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
++        m_deg = []
++        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
++            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
++        assert_array_equal(m_deg, true_m_deg)
++
++        # check error
++        assert_raises(ValueError, m_degeneracy, 6, -6)
++
++    def test_ap(self):
++        """
++        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
++
++        For given values of j, m. For a Dicke state,
++        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
++        """
++        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
++        ap_list = []
++        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
++            ap_list.append(ap(10, m) ** 2)
++
++        assert_almost_equal(ap_list, true_ap_list)
++
++    def test_am(self):
++        """
++        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
++
++        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
++        """
++        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
++        am_list = []
++        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
++            am_list.append(am(10, m) ** 2)
++
++        assert_almost_equal(am_list, true_am_list)
++
++    def test_spin_algebra(self):
++        """
++        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
++        The list [sx, sy, sz, sp, sm] is checked for N = 2.
++        """
++        sx1 = [
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
++            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        sx2 = [
++            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        sy1 = [
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
++            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        sy2 = [
++            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
++        ]
++
++        sz1 = [
++            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
++        ]
++
++        sz2 = [
++            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
++        ]
++
++        sp1 = [
++            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        sp2 = [
++            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        sm1 = [
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        sm2 = [
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
++        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
++        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
++        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
++        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
++        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
++        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
++        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
++        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
++        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
++
++        # test error
++        assert_raises(TypeError, spin_algebra, 2, "q")
++
++    def test_collective_algebra(self):
++        """
++        PIQS: Test the generation of the collective algebra in uncoupled basis.
++
++        The list [jx, jy, jz] created in the 2^N Hilbert space is
++        checked for N = 2.
++        """
++
++        jx_n2 = [
++            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
++            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
++            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
++            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        jy_n2 = [
++            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
++            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
++            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
++            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
++        ]
++
++        jz_n2 = [
++            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
++        ]
++
++        jp_n2 = [
++            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        jm_n2 = [
++            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
++            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
++        ]
++
++        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
++        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
++        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
++        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
++        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
++
++        # error
++        assert_raises(TypeError, spin_algebra, 2, "q")
++
++    def test_block_matrix(self):
++        """
++        PIQS: Test the calculation of the block-diagonal matrix for given N.
++
++        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
++        """
++        # N = 1 TLSs
++        block_1 = [[1.0, 1.0], [1.0, 1.0]]
++
++        # N = 2 TLSs
++        block_2 = [
++            [1.0, 1.0, 1.0, 0.0],
++            [1.0, 1.0, 1.0, 0.0],
++            [1.0, 1.0, 1.0, 0.0],
++            [0.0, 0.0, 0.0, 1.0],
++        ]
++
++        # N = 3 TLSs
++        block_3 = [
++            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
++            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
++            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
++            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
++            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
++            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
++        ]
++
++        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
++        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
++        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
++
++    def test_dicke_basis(self):
++        """
++        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
++
++        We test the state with for N = 2,
++
++        0   0   0.3 0
++        0   0.5 0   0
++        0.3 0   0   0
++        0   0   0   0.5
++        """
++        N = 2
++        true_dicke_basis = np.zeros((4, 4))
++        true_dicke_basis[1, 1] = 0.5
++        true_dicke_basis[-1, -1] = 0.5
++        true_dicke_basis[0, 2] = 0.3
++        true_dicke_basis[2, 0] = 0.3
++        true_dicke_basis = Qobj(true_dicke_basis)
++        jmm1_1 = {(N / 2, 0, 0): 0.5}
++        jmm1_2 = {(0, 0, 0): 0.5}
++        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
++        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
++        db1 = dicke_basis(2, jmm1_1)
++        db2 = dicke_basis(2, jmm1_2)
++        db3 = dicke_basis(2, jmm1_3)
++        db4 = dicke_basis(2, jmm1_4)
++        test_dicke_basis = db1 + db2 + db3 + db4
++        assert_equal(test_dicke_basis, true_dicke_basis)
++
++        # error
++        assert_raises(AttributeError, dicke_basis, N)
++
++    def test_dicke(self):
++        """
++        PIQS: Test the calculation of the Dicke state as a pure state.
++        """
++        true_excited = np.zeros((4, 4))
++        true_excited[0, 0] = 1
++
++        true_superradiant = np.zeros((4, 4))
++        true_superradiant[1, 1] = 1
++
++        true_subradiant = np.zeros((4, 4))
++        true_subradiant[-1, -1] = 1
++
++        test_excited = dicke(2, 1, 1)
++        test_superradiant = dicke(2, 1, 0)
++        test_subradiant = dicke(2, 0, 0)
++
++        assert_equal(test_excited, Qobj(true_excited))
++        assert_equal(test_superradiant, Qobj(true_superradiant))
++        assert_equal(test_subradiant, Qobj(true_subradiant))
++
++    def test_excited(self):
++        """
++        PIQS: Test the calculation of the totally excited state density matrix.
++
++        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
++        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
++        """
++        N = 3
++        true_state = np.zeros((6, 6))
++        true_state[0, 0] = 1
++        true_state = Qobj(true_state)
++
++        test_state = excited(N)
++        assert_equal(test_state, true_state)
++
++        N = 4
++        true_state = np.zeros((9, 9))
++        true_state[0, 0] = 1
++        true_state = Qobj(true_state)
++
++        test_state = excited(N)
++        assert_equal(test_state, true_state)
++
++        # uncoupled
++        test_state_uncoupled = excited(2, basis="uncoupled")
++        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
++        assert_array_equal(test_state_uncoupled.shape, (4, 4))
++        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
++
++    def test_superradiant(self):
++        """
++        PIQS: Test the calculation of the superradiant state density matrix.
++
++        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
++        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
++        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
++        """
++        N = 3
++        true_state = np.zeros((6, 6))
++        true_state[1, 1] = 1
++        true_state = Qobj(true_state)
++        test_state = superradiant(N)
++        assert_equal(test_state, true_state)
++        N = 4
++        true_state = np.zeros((9, 9))
++        true_state[2, 2] = 1
++        true_state = Qobj(true_state)
++        test_state = superradiant(N)
++        assert_equal(test_state, true_state)
++
++        # uncoupled
++        test_state_uncoupled = superradiant(2, basis="uncoupled")
++        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
++        assert_array_equal(test_state_uncoupled.shape, (4, 4))
++        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
++
++    def test_ghz(self):
++        """
++        PIQS: Test the calculation of the density matrix of the GHZ state.
++
++        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
++        """
++        ghz_dicke = Qobj(
++            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
++        )
++        ghz_uncoupled = Qobj(
++            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
++        )
++        ghz_uncoupled.dims = [[2, 2], [2, 2]]
++        assert_equal(ghz(2), ghz_dicke)
++        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
++
++    def test_ground(self):
++        """
++        PIQS: Test the calculation of the density matrix of the ground state.
++
++        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
++        """
++        zeros = np.zeros((4, 4), dtype=np.complex128)
++        gdicke = zeros.copy()
++        guncoupled = zeros.copy()
++        gdicke[2, 2] = 1
++        guncoupled[3, 3] = 1
++
++        dim_dicke = [[4], [4]]
++        dim_uncoupled = [[2, 2], [2, 2]]
++
++        test_ground_dicke = ground(2)
++        test_ground_uncoupled = ground(2, "uncoupled")
++
++        assert_array_equal(test_ground_dicke.full(), gdicke)
++        assert_array_equal(test_ground_dicke.dims, dim_dicke)
++        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
++        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
++
++    def test_identity_uncoupled(self):
++        """
++        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
++        """
++        test_identity = identity_uncoupled(4)
++        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
++        assert_array_equal(
++            np.diag(test_identity.full()), np.ones(16, np.complex128)
++        )
++
++    def test_css(self):
++        """
++        PIQS: Test the calculation of the CSS state.
++        """
++        test_css_uncoupled = css(2, basis="uncoupled")
++        test_css_dicke = css(2)
++        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
++        css_dicke = np.array(
++            [
++                [
++                    0.25000000 + 0.0j,
++                    0.35355339 + 0.0j,
++                    0.25000000 + 0.0j,
++                    0.00000000 + 0.0j,
++                ],
++                [
++                    0.35355339 + 0.0j,
++                    0.50000000 + 0.0j,
++                    0.35355339 + 0.0j,
++                    0.00000000 + 0.0j,
++                ],
++                [
++                    0.25000000 + 0.0j,
++                    0.35355339 + 0.0j,
++                    0.25000000 + 0.0j,
++                    0.00000000 + 0.0j,
++                ],
++                [
++                    0.00000000 + 0.0j,
++                    0.00000000 + 0.0j,
++                    0.00000000 + 0.0j,
++                    0.00000000 + 0.0j,
++                ],
++            ]
++        )
++        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
++        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
++
++    def test_collapse_uncoupled(self):
++        """
++        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
++
++        In the "uncoupled" basis of N two-level system (TLS).
++        The test is performed for N = 2 and emission = 1.
++        """
++        c1 = Qobj(
++            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
++            dims=[[2, 2], [2, 2]],
++        )
++        c2 = Qobj(
++            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
++            dims=[[2, 2], [2, 2]],
++        )
++        true_c_ops = [c1, c2]
++        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
++        system = Dicke(N=2, emission=1)
++        assert_equal(true_c_ops, system.c_ops())
++
++    def test_get_blocks(self):
++        """
++        PIQS: Test the calculation of list of cumulative elements at each block.
++
++        For N = 4
++
++        1 1 1 1 1
++        1 1 1 1 1
++        1 1 1 1 1
++        1 1 1 1 1
++        1 1 1 1 1
++                1 1 1
++                1 1 1
++                1 1 1
++                     1
++        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
++        elements have been accounted for and so on.
++        """
++        trueb1 = [2]
++        trueb2 = [3, 4]
++        trueb3 = [4, 6]
++        trueb4 = [5, 8, 9]
++
++        test_b1 = get_blocks(1)
++        test_b2 = get_blocks(2)
++        test_b3 = get_blocks(3)
++        test_b4 = get_blocks(4)
++
++        assert_equal(test_b1, trueb1)
++        assert_equal(test_b2, trueb2)
++        assert_equal(test_b3, trueb3)
++
++    def test_lindbladian_dims(self):
++        """
++        PIQS: Test the calculation of the lindbladian matrix.
++        """
++        true_L = [
++            [-4, 0, 0, 3],
++            [0, -3.54999995, 0, 0],
++            [0, 0, -3.54999995, 0],
++            [4, 0, 0, -3],
++        ]
++        true_L = Qobj(true_L)
++        true_L.dims = [[[2], [2]], [[2], [2]]]
++        N = 1
++        test_dicke = _Dicke(
++            N=N,
++            pumping=1,
++            collective_pumping=2,
++            emission=1,
++            collective_emission=3,
++            dephasing=0.1,
++        )
++        test_L = test_dicke.lindbladian()
++        assert_array_almost_equal(test_L.full(), true_L.full())
++        assert_array_equal(test_L.dims, true_L.dims)
++
++    def test_liouvillian(self):
++        """
++        PIQS: Test the calculation of the liouvillian matrix.
++        """
++        true_L = [
++            [-4, 0, 0, 3],
++            [0, -3.54999995, 0, 0],
++            [0, 0, -3.54999995, 0],
++            [4, 0, 0, -3],
++        ]
++        true_L = Qobj(true_L)
++        true_L.dims = [[[2], [2]], [[2], [2]]]
++        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
++        true_H = Qobj(true_H)
++        true_H.dims = [[[2], [2]]]
++        true_liouvillian = [
++            [-4, -1.0j, 1.0j, 3],
++            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
++            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
++            [4, +1.0j, -1.0j, -3],
++        ]
++        true_liouvillian = Qobj(true_liouvillian)
++        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
++        N = 1
++        test_piqs = Dicke(
++            hamiltonian=sigmaz() + sigmax(),
++            N=N,
++            pumping=1,
++            collective_pumping=2,
++            emission=1,
++            collective_emission=3,
++            dephasing=0.1,
++        )
++        test_liouvillian = test_piqs.liouvillian()
++        test_hamiltonian = test_piqs.hamiltonian
++        assert_array_almost_equal(
++            test_liouvillian.full(), true_liouvillian.full()
++        )
++        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
++        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
++
++        # no Hamiltonian
++        test_piqs = Dicke(
++            N=N,
++            pumping=1,
++            collective_pumping=2,
++            emission=1,
++            collective_emission=3,
++            dephasing=0.1,
++        )
++        liouv = test_piqs.liouvillian()
++        lindblad = test_piqs.lindbladian()
++        assert_equal(liouv, lindblad)
++
++    def test_gamma1(self):
++        """
++        PIQS: Test the calculation of gamma1.
++        """
++        true_gamma_1 = -2
++        true_gamma_2 = -3
++        true_gamma_3 = -7
++        true_gamma_4 = -1
++        true_gamma_5 = 0
++        true_gamma_6 = 0
++
++        N = 4
++        test_dicke = _Dicke(N=N, collective_emission=1)
++        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
++        test_dicke = _Dicke(N=N, emission=1)
++        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
++        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
++        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
++        test_dicke = _Dicke(N=N, dephasing=4)
++        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
++        test_dicke = _Dicke(N=N, collective_pumping=2)
++        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
++        test_dicke = _Dicke(N=N, collective_dephasing=2)
++        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++        assert_almost_equal(true_gamma_5, test_gamma_5)
++        assert_almost_equal(true_gamma_6, test_gamma_6)
++
++    def test_gamma2(self):
++        """
++        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 2
++        true_gamma_2 = 1.5
++        true_gamma_3 = 5.5
++        true_gamma_4 = 0
++        true_gamma_5 = 0
++        true_gamma_6 = 0
++
++        N = 4
++        test_dicke = _Dicke(N=N, collective_emission=1)
++        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
++        test_dicke = _Dicke(N=N, emission=1)
++        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
++        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
++        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
++        test_dicke = _Dicke(N=N, dephasing=4)
++        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
++        test_dicke = _Dicke(N=N, collective_pumping=2)
++        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
++        test_dicke = _Dicke(N=N, collective_dephasing=2)
++        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++        assert_almost_equal(true_gamma_5, test_gamma_5)
++        assert_almost_equal(true_gamma_6, test_gamma_6)
++
++    def test_gamma3(self):
++        """
++        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 0
++        true_gamma_2 = 1.3333333730697632
++        true_gamma_3 = 1.3333333730697632
++        true_gamma_4 = 0
++        true_gamma_5 = 0
++        true_gamma_6 = 0
++
++        N = 4
++        test_dicke = _Dicke(N=N, collective_emission=1)
++        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
++        test_dicke = _Dicke(N=N, emission=1)
++        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
++        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
++        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
++        test_dicke = _Dicke(N=N, dephasing=4)
++        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
++        test_dicke = _Dicke(N=N, collective_pumping=2)
++        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
++        test_dicke = _Dicke(N=N, collective_dephasing=2)
++        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
++        #
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++        assert_almost_equal(true_gamma_5, test_gamma_5)
++        assert_almost_equal(true_gamma_6, test_gamma_6)
++
++    def test_gamma4(self):
++        """
++        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 0.1666666716337204
++        true_gamma_2 = 2
++        true_gamma_3 = 0
++        true_gamma_4 = 0.40824830532073975
++
++        N = 4
++        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
++        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
++        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
++        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
++        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++
++    def test_gamma5(self):
++        """
++        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 0
++        true_gamma_2 = 0
++        true_gamma_3 = 0.75
++        true_gamma_4 = 0
++
++        N = 4
++        test_dicke = _Dicke(N=N, dephasing=1)
++        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
++        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
++        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
++        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++
++    def test_gamma6(self):
++        """
++        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 0.25
++        true_gamma_2 = 1
++        true_gamma_3 = 0
++        true_gamma_4 = 0.25
++
++        N = 4
++        test_dicke = _Dicke(N=N, dephasing=1)
++        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
++        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
++        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
++        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++
++    def test_gamma7(self):
++        """
++        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 0
++        true_gamma_2 = 0.5
++        true_gamma_3 = 0
++        true_gamma_4 = 1.5
++
++        N = 4
++        test_dicke = _Dicke(N=N, pumping=1)
++        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
++        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
++        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
++        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++
++    def test_gamma8(self):
++        """
++        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 0
++        true_gamma_2 = 13.5
++        true_gamma_3 = 5.5
++        true_gamma_4 = 13.5
++
++        N = 4
++        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
++        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
++        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
++        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
++        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
++
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++
++    def test_gamma9(self):
++        """
++        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
++        """
++        true_gamma_1 = 1
++        true_gamma_2 = 0
++        true_gamma_3 = 0.5
++        true_gamma_4 = 0
++        N = 4
++        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
++        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
++        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
++        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
++        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
++        assert_almost_equal(true_gamma_1, test_gamma_1)
++        assert_almost_equal(true_gamma_2, test_gamma_2)
++        assert_almost_equal(true_gamma_3, test_gamma_3)
++        assert_almost_equal(true_gamma_4, test_gamma_4)
++
++
++class TestPim:
++    """
++    Tests for the `qutip.piqs.Pim` class.
++    """
++
++    def test_gamma(self):
++        """
++        PIQS: Test the calculation of various gamma values for diagonal system.
++
++        For N = 6 |j, m> would be :
++
++        | 3, 3>
++        | 3, 2> | 2, 2>
++        | 3, 1> | 2, 1> | 1, 1>
++        | 3, 0> | 2, 0> | 1, 0> |0, 0>
++        | 3,-1> | 2,-1> | 1,-1>
++        | 3,-2> | 2,-2>
++        | 3,-3>
++        """
++        N = 6
++        collective_emission = 1.0
++        emission = 1.0
++        dephasing = 1.0
++        pumping = 1.0
++        collective_pumping = 1.0
++        model = Pim(
++            N,
++            collective_emission=collective_emission,
++            emission=emission,
++            dephasing=dephasing,
++            pumping=pumping,
++            collective_pumping=collective_pumping,
++        )
++        tau_calculated = [
++            model.tau3(3, 1),
++            model.tau2(2, 1),
++            model.tau4(1, 1),
++            model.tau5(3, 0),
++            model.tau1(2, 0),
++            model.tau6(1, 0),
++            model.tau7(3, -1),
++            model.tau8(2, -1),
++            model.tau9(1, -1),
++        ]
++        tau_real = [
++            2.0,
++            8.0,
++            0.333333,
++            1.5,
++            -19.5,
++            0.666667,
++            2.0,
++            8.0,
++            0.333333,
++        ]
++        assert_array_almost_equal(tau_calculated, tau_real)
++
++    def test_isdicke(self):
++        """
++        PIQS: Test the `isdicke` function
++        """
++        N1 = 1
++        g0 = 0.01
++        nth = 0.01
++        gP = g0 * nth
++        gL = g0 * (0.1 + nth)
++        gS = 0.1
++        gD = 0.1
++
++        pim1 = Pim(N1, gS, gL, gD, gP)
++
++        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
++        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
++
++        N2 = 4
++
++        pim2 = Pim(N2, gS, gL, gD, gP)
++        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
++        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
++
++        assert_array_equal(dicke_labels, [True, False, True, False, True])
++
++    def test_isdiagonal(self):
++        """
++        PIQS: Test the isdiagonal function.
++        """
++        mat1 = np.array([[1, 2], [3, 4]])
++        mat2 = np.array([[1, 0.0], [0.0, 2]])
++        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
++        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
++        assert_equal(isdiagonal(mat1), False)
++        assert_equal(isdiagonal(mat2), True)
++        assert_equal(isdiagonal(mat3), False)
++        assert_equal(isdiagonal(mat4), True)
++
++    def test_pisolve(self):
++        """
++        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
++        """
++        jx, jy, jz = jspin(4)
++        jp, jm = jspin(4, "+"), jspin(4, "-")
++
++    def test_coefficient_matrix(self):
++        """
++        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
++        """
++        N = 2
++        ensemble = Pim(N, emission=1)
++        test_matrix = ensemble.coefficient_matrix().toarray()
++        ensemble2 = Dicke(N, emission=1)
++        test_matrix2 = ensemble.coefficient_matrix().toarray()
++        true_matrix = [
++            [-2, 0, 0, 0],
++            [1, -1, 0, 0],
++            [0, 1, 0, 1.0],
++            [1, 0, 0, -1.0],
++        ]
++
++        assert_array_almost_equal(test_matrix, true_matrix)
++        assert_array_almost_equal(test_matrix2, true_matrix)
++
++    def test_pisolve(self):
++        """
++        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
++        """
++        jx, jy, jz = jspin(4)
++        jp, jm = jspin(4, "+"), jspin(4, "-")
++        non_diag_hamiltonian = jx
++        diag_hamiltonian = jz
++
++        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
++        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
++
++        diag_initial_state = dicke(4, 1, 0)
++        non_diag_initial_state = ghz(4)
++        tlist = np.linspace(0, 10, 100)
++
++        assert_raises(
++            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
++        )
++        assert_raises(
++            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
++        )
++        assert_raises(
++            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
++        )
++
++        non_dicke_initial_state = excited(4, basis="uncoupled")
++        assert_raises(
++            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
++        )
++
++        # no Hamiltonian
++        no_hamiltonian_system = Dicke(4, emission=0.1)
++        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
++        assert_equal(True, len(result.states) > 0)
++
++
++if __name__ == "__main__":
++    run_module_suite()
+diff --git a/qutip/tests/solve/test_qubit_evolution.py b/qutip/tests/solve/test_qubit_evolution.py
+index d75697f9..7157e3ff 100644
+--- a/qutip/tests/solve/test_qubit_evolution.py
++++ b/qutip/tests/solve/test_qubit_evolution.py
+@@ -1,124 +1,124 @@
+-import numpy as np
+-import pytest
+-from qutip import (
+-    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
+-)
+-
+-
+-def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
+-
+-    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
+-
+-    c_op_list = []
+-
+-    rate = g1
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * sigmam())
+-
+-    rate = g2
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * sigmaz())
+-
+-    e_ops = [sigmax(), sigmay(), sigmaz()]
+-
+-    if solver == "me":
+-        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
+-    elif solver == "mc":
+-        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
+-    else:
+-        raise ValueError("unknown solver")
+-
+-    return output.expect[0], output.expect[1], output.expect[2]
+-
+-
+-def test_MESolverCase1():
+-    """
+-    Test mesolve qubit, with dissipation
+-    """
+-
+-    epsilon = 0.0 * 2 * np.pi   # cavity frequency
+-    delta = 1.0 * 2 * np.pi   # atom frequency
+-    g2 = 0.1
+-    g1 = 0.0
+-    psi0 = basis(2, 0)        # initial state
+-    tlist = np.linspace(0, 5, 200)
+-
+-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
+-
+-    sx_analytic = np.zeros(np.shape(tlist))
+-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-
+-    assert max(abs(sx - sx_analytic)) < 0.05
+-    assert max(abs(sy - sy_analytic)) < 0.05
+-    assert max(abs(sz - sz_analytic)) < 0.05
+-
+-
+-def test_MESolverCase2():
+-    """
+-    Test mesolve qubit, no dissipation
+-    """
+-
+-    epsilon = 0.0 * 2 * np.pi   # cavity frequency
+-    delta = 1.0 * 2 * np.pi   # atom frequency
+-    g2 = 0.0
+-    g1 = 0.0
+-    psi0 = basis(2, 0)        # initial state
+-    tlist = np.linspace(0, 5, 200)
+-
+-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
+-
+-    sx_analytic = np.zeros(np.shape(tlist))
+-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-
+-    assert max(abs(sx - sx_analytic)) < 0.05
+-    assert max(abs(sy - sy_analytic)) < 0.05
+-    assert max(abs(sz - sz_analytic)) < 0.05
+-
+-
+-def test_MCSolverCase1():
+-    """
+-    Test mcsolve qubit, with dissipation
+-    """
+-
+-    epsilon = 0.0 * 2 * np.pi      # cavity frequency
+-    delta = 1.0 * 2 * np.pi        # atom frequency
+-    g2 = 0.1
+-    g1 = 0.0
+-    psi0 = basis(2, 0)          # initial state
+-    tlist = np.linspace(0, 5, 200)
+-
+-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
+-
+-    sx_analytic = np.zeros(np.shape(tlist))
+-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-
+-    assert max(abs(sx - sx_analytic)) < 0.25
+-    assert max(abs(sy - sy_analytic)) < 0.25
+-    assert max(abs(sz - sz_analytic)) < 0.25
+-
+-
+-@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
+-def test_MCSolverCase2():
+-    """
+-    Test mcsolve qubit, no dissipation
+-    """
+-
+-    epsilon = 0.0 * 2 * np.pi      # cavity frequency
+-    delta = 1.0 * 2 * np.pi        # atom frequency
+-    g2 = 0.0
+-    g1 = 0.0
+-    psi0 = basis(2, 0)          # initial state
+-    tlist = np.linspace(0, 5, 200)
+-
+-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
+-
+-    sx_analytic = np.zeros(np.shape(tlist))
+-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-
+-    assert max(abs(sx - sx_analytic)) < 0.25
+-    assert max(abs(sy - sy_analytic)) < 0.25
+-    assert max(abs(sz - sz_analytic)) < 0.25
++import numpy as np
++import pytest
++from qutip import (
++    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
++)
++
++
++def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
++
++    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
++
++    c_op_list = []
++
++    rate = g1
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * sigmam())
++
++    rate = g2
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * sigmaz())
++
++    e_ops = [sigmax(), sigmay(), sigmaz()]
++
++    if solver == "me":
++        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
++    elif solver == "mc":
++        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
++    else:
++        raise ValueError("unknown solver")
++
++    return output.expect[0], output.expect[1], output.expect[2]
++
++
++def test_MESolverCase1():
++    """
++    Test mesolve qubit, with dissipation
++    """
++
++    epsilon = 0.0 * 2 * np.pi   # cavity frequency
++    delta = 1.0 * 2 * np.pi   # atom frequency
++    g2 = 0.1
++    g1 = 0.0
++    psi0 = basis(2, 0)        # initial state
++    tlist = np.linspace(0, 5, 200)
++
++    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
++
++    sx_analytic = np.zeros(np.shape(tlist))
++    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
++    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
++
++    assert max(abs(sx - sx_analytic)) < 0.05
++    assert max(abs(sy - sy_analytic)) < 0.05
++    assert max(abs(sz - sz_analytic)) < 0.05
++
++
++def test_MESolverCase2():
++    """
++    Test mesolve qubit, no dissipation
++    """
++
++    epsilon = 0.0 * 2 * np.pi   # cavity frequency
++    delta = 1.0 * 2 * np.pi   # atom frequency
++    g2 = 0.0
++    g1 = 0.0
++    psi0 = basis(2, 0)        # initial state
++    tlist = np.linspace(0, 5, 200)
++
++    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
++
++    sx_analytic = np.zeros(np.shape(tlist))
++    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
++    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
++
++    assert max(abs(sx - sx_analytic)) < 0.05
++    assert max(abs(sy - sy_analytic)) < 0.05
++    assert max(abs(sz - sz_analytic)) < 0.05
++
++
++def test_MCSolverCase1():
++    """
++    Test mcsolve qubit, with dissipation
++    """
++
++    epsilon = 0.0 * 2 * np.pi      # cavity frequency
++    delta = 1.0 * 2 * np.pi        # atom frequency
++    g2 = 0.1
++    g1 = 0.0
++    psi0 = basis(2, 0)          # initial state
++    tlist = np.linspace(0, 5, 200)
++
++    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
++
++    sx_analytic = np.zeros(np.shape(tlist))
++    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
++    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
++
++    assert max(abs(sx - sx_analytic)) < 0.25
++    assert max(abs(sy - sy_analytic)) < 0.25
++    assert max(abs(sz - sz_analytic)) < 0.25
++
++
++@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
++def test_MCSolverCase2():
++    """
++    Test mcsolve qubit, no dissipation
++    """
++
++    epsilon = 0.0 * 2 * np.pi      # cavity frequency
++    delta = 1.0 * 2 * np.pi        # atom frequency
++    g2 = 0.0
++    g1 = 0.0
++    psi0 = basis(2, 0)          # initial state
++    tlist = np.linspace(0, 5, 200)
++
++    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
++
++    sx_analytic = np.zeros(np.shape(tlist))
++    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
++    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
++
++    assert max(abs(sx - sx_analytic)) < 0.25
++    assert max(abs(sy - sy_analytic)) < 0.25
++    assert max(abs(sz - sz_analytic)) < 0.25
+diff --git a/qutip/tests/solve/test_stochastic_me.py b/qutip/tests/solve/test_stochastic_me.py
+index 27ac7c82..f282254b 100644
+--- a/qutip/tests/solve/test_stochastic_me.py
++++ b/qutip/tests/solve/test_stochastic_me.py
+@@ -1,309 +1,309 @@
+-import pytest
+-import numpy as np
+-from numpy.testing import assert_, run_module_suite
+-
+-from qutip import (
+-    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
+-    destroy, coherent, qeye, fock_dm, general_stochastic, num,
+-)
+-from qutip.solve.parallel import parallel_map
+-from qutip.core import data as _data
+-def f(t, args):
+-    return args["a"] * t
+-
+-
+-@pytest.mark.slow
+-def test_smesolve_homodyne_methods():
+-    "Stochastic: smesolve: homodyne methods with single jump operator"
+-
+-    def arccoth(x):
+-        return 0.5*np.log((1.+x)/(x-1.))
+-
+-    th = 0.1 # Interaction parameter
+-    alpha = np.cos(th)
+-    beta = np.sin(th)
+-    gamma = 1.
+-
+-    N = 30                 # number of Fock states
+-    Id = qeye(N)
+-    a = destroy(N)
+-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
+-    x = (a + a.dag()) * 2**-0.5
+-    H = Id
+-    c_op = [gamma**0.5 * a]
+-    sc_op = [s]
+-    e_op = [x, x*x]
+-    rho0 = fock_dm(N,0)      # initial vacuum state
+-
+-    T = 3.                   # final time
+-    # number of time steps for which we save the expectation values
+-    N_store = 121
+-    Nsub = 10
+-    tlist = np.linspace(0, T, N_store)
+-    ddt = (tlist[1]-tlist[0])
+-
+-    #### Analytic solution
+-    y0 = 0.5
+-    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
+-    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
+-    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
+-
+-
+-    list_methods_tol = [['euler-maruyama', 2e-2],
+-                        ['pc-euler', 2e-3],
+-                        ['pc-euler-2', 2e-3],
+-                        ['platen', 1e-3],
+-                        ['milstein', 1e-3],
+-                        ['milstein-imp', 1e-3],
+-                        ['rouchon', 1e-3],
+-                        ['taylor1.5', 1e-4],
+-                        ['taylor1.5-imp', 1e-4],
+-                        ['explicit1.5', 1e-4],
+-                        ['taylor2.0', 1e-4]]
+-    for n_method in list_methods_tol:
+-        # Comparisons of error between sol and sol3 depend on the stochastic
+-        # noise, thus the seed, fixing the seed remove random fails.
+-        np.random.seed(1)
+-        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
+-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
+-        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
+-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
+-                       noise = sol.noise)
+-        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
+-                        nsubsteps=Nsub*5, method='homodyne',
+-                        solver = n_method[0], tol=1e-8)
+-        err = 1/T * np.sum(np.abs(y_an - \
+-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
+-        err3 = 1/T * np.sum(np.abs(y_an - \
+-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
+-        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
+-        assert_(err < n_method[1])
+-        # 5* more substep should decrease the error
+-        assert_(err3 < err)
+-        # just to check that noise is not affected by smesolve
+-        assert_(np.all(sol.noise == sol2.noise))
+-        assert_(np.all(sol.expect[0] == sol2.expect[0]))
+-
+-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
+-                    nsubsteps=Nsub, method='homodyne', solver='euler',
+-                    store_measurement=1)
+-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
+-                    nsubsteps=Nsub, method='homodyne', solver='euler',
+-                    store_measurement=0)
+-    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
+-                    nsubsteps=Nsub, method='homodyne', solver='euler')
+-    # sol and sol2 have the same seed, sol3 differ.
+-    assert_(np.all(sol.noise == sol2.noise))
+-    assert_(np.all(sol.noise != sol3.noise))
+-    assert_(not np.all(sol.measurement[0] == 0.+0j))
+-    assert_(np.all(sol2.measurement[0] == 0.+0j))
+-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
+-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
+-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+-    # sol and sol2 have the seed of traj 1 and 2 reversed.
+-    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
+-    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
+-
+-
+-def test_smesolve_photocurrent():
+-    "Stochastic: photocurrent_mesolve"
+-    tol = 0.01
+-
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 20
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a,f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    times = np.linspace(0, 1.0, 21)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
+-                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
+-                   map_func=parallel_map)
+-
+-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+-                 for idx in range(len(e_ops))]))
+-    assert_(len(res.measurement) == ntraj)
+-    assert_(all([m.shape == (len(times), len(sc_ops))
+-                 for m in res.measurement]))
+-
+-
+-def test_smesolve_homodyne():
+-    "Stochastic: smesolve: homodyne, time-dependent H"
+-    tol = 0.01
+-
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 20
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a,f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    times = np.linspace(0, 1.0, 21)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    list_methods_tol = ['euler-maruyama',
+-                        'pc-euler',
+-                        'pc-euler-2',
+-                        'platen',
+-                        'milstein',
+-                        'milstein-imp',
+-                        'rouchon',
+-                        'taylor15',
+-                        'taylor15-imp',
+-                        'explicit15']
+-    for solver in list_methods_tol:
+-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
+-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
+-                       method='homodyne', store_measurement=True,
+-                       solver=solver, map_func=parallel_map)
+-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+-                     for idx in range(len(e_ops))]))
+-        assert_(len(res.measurement) == ntraj)
+-        assert_(all([m.shape == (len(times), len(sc_ops))
+-                     for m in res.measurement]))
+-
+-
+-@pytest.mark.slow
+-def test_smesolve_heterodyne():
+-    "Stochastic: smesolve: heterodyne, time-dependent H"
+-    tol = 0.01
+-
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 20
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a, f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    times = np.linspace(0, 1.0, 21)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    list_methods_tol = ['euler-maruyama',
+-                        'pc-euler',
+-                        'pc-euler-2',
+-                        'platen',
+-                        'milstein',
+-                        'milstein-imp',
+-                        'rouchon',
+-                        'taylor15',
+-                        'taylor15-imp',
+-                        'explicit15']
+-    for solver in list_methods_tol:
+-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
+-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
+-                       method='heterodyne', store_measurement=True,
+-                       solver=solver, map_func=parallel_map)
+-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+-                     for idx in range(len(e_ops))]))
+-        assert_(len(res.measurement) == ntraj)
+-        assert_(all([m.shape == (len(times), len(sc_ops), 2)
+-                     for m in res.measurement]))
+-
+-
+-@pytest.mark.slow
+-def test_general_stochastic():
+-    "Stochastic: general_stochastic"
+-    "Reproduce smesolve homodyne"
+-    tol = 0.025
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 20
+-    nsubsteps = 50
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a,f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
+-    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
+-    e_opsM = [spre(op) for op in e_ops]
+-
+-    def d1(t, vec):
+-        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
+-
+-    def d2(t, vec):
+-        out = []
+-        vec_d = _data.Dense(vec)
+-        for op in sc_opsM:
+-            scale = -op.expect_data(t,vec_d)
+-            out.append(
+-                _data.add(op.matmul_data(t,vec_d),
+-                          vec_d, scale)
+-                )
+-        return np.stack([o.to_array().ravel() for o in out])
+-
+-    times = np.linspace(0, 0.5, 13)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    list_methods_tol = ['euler-maruyama',
+-                        'platen',
+-                        'explicit15']
+-    for solver in list_methods_tol:
+-        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
+-                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
+-                                 nsubsteps=nsubsteps, solver=solver)
+-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+-                 for idx in range(len(e_ops))]))
+-    assert_(len(res.measurement) == ntraj)
+-
+-
+-def f_dargs(a, args):
+-    return args["expect_op_3"] - 1
+-
+-
+-@pytest.mark.xfail(reason="not working yet")
+-def test_ssesolve_feedback():
+-    "Stochastic: ssesolve: time-dependent H with feedback"
+-    tol = 0.01
+-    N = 4
+-    ntraj = 10
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [num(N)]
+-    psi0 = coherent(N, 2.5)
+-    sc_ops = [[a + a.dag(), f_dargs]]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
+-
+-    times = np.linspace(0, 10, 101)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
+-                      args={"expect_op_3":qeye(N)})
+-    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
+-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+-                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
+-
+-    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
+-
+-
+-def test_smesolve_bad_e_ops():
+-    "Stochastic: ssesolve: time-dependent H with feedback"
+-    tol = 0.01
+-    N = 4
+-    ntraj = 10
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [num(N)]
+-    psi0 = coherent(N, 2.5)
+-    sc_ops = [a + a.dag()]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
+-
+-    times = np.linspace(0, 10, 101)
+-    with pytest.raises(TypeError) as exc:
+-        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
+-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+-                       map_func=parallel_map)
++import pytest
++import numpy as np
++from numpy.testing import assert_, run_module_suite
++
++from qutip import (
++    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
++    destroy, coherent, qeye, fock_dm, general_stochastic, num,
++)
++from qutip.solve.parallel import parallel_map
++from qutip.core import data as _data
++def f(t, args):
++    return args["a"] * t
++
++
++@pytest.mark.slow
++def test_smesolve_homodyne_methods():
++    "Stochastic: smesolve: homodyne methods with single jump operator"
++
++    def arccoth(x):
++        return 0.5*np.log((1.+x)/(x-1.))
++
++    th = 0.1 # Interaction parameter
++    alpha = np.cos(th)
++    beta = np.sin(th)
++    gamma = 1.
++
++    N = 30                 # number of Fock states
++    Id = qeye(N)
++    a = destroy(N)
++    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
++    x = (a + a.dag()) * 2**-0.5
++    H = Id
++    c_op = [gamma**0.5 * a]
++    sc_op = [s]
++    e_op = [x, x*x]
++    rho0 = fock_dm(N,0)      # initial vacuum state
++
++    T = 3.                   # final time
++    # number of time steps for which we save the expectation values
++    N_store = 121
++    Nsub = 10
++    tlist = np.linspace(0, T, N_store)
++    ddt = (tlist[1]-tlist[0])
++
++    #### Analytic solution
++    y0 = 0.5
++    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
++    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
++    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
++
++
++    list_methods_tol = [['euler-maruyama', 2e-2],
++                        ['pc-euler', 2e-3],
++                        ['pc-euler-2', 2e-3],
++                        ['platen', 1e-3],
++                        ['milstein', 1e-3],
++                        ['milstein-imp', 1e-3],
++                        ['rouchon', 1e-3],
++                        ['taylor1.5', 1e-4],
++                        ['taylor1.5-imp', 1e-4],
++                        ['explicit1.5', 1e-4],
++                        ['taylor2.0', 1e-4]]
++    for n_method in list_methods_tol:
++        # Comparisons of error between sol and sol3 depend on the stochastic
++        # noise, thus the seed, fixing the seed remove random fails.
++        np.random.seed(1)
++        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
++                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
++        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
++                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
++                       noise = sol.noise)
++        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
++                        nsubsteps=Nsub*5, method='homodyne',
++                        solver = n_method[0], tol=1e-8)
++        err = 1/T * np.sum(np.abs(y_an - \
++                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
++        err3 = 1/T * np.sum(np.abs(y_an - \
++                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
++        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
++        assert_(err < n_method[1])
++        # 5* more substep should decrease the error
++        assert_(err3 < err)
++        # just to check that noise is not affected by smesolve
++        assert_(np.all(sol.noise == sol2.noise))
++        assert_(np.all(sol.expect[0] == sol2.expect[0]))
++
++    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
++                    nsubsteps=Nsub, method='homodyne', solver='euler',
++                    store_measurement=1)
++    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
++                    nsubsteps=Nsub, method='homodyne', solver='euler',
++                    store_measurement=0)
++    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
++                    nsubsteps=Nsub, method='homodyne', solver='euler')
++    # sol and sol2 have the same seed, sol3 differ.
++    assert_(np.all(sol.noise == sol2.noise))
++    assert_(np.all(sol.noise != sol3.noise))
++    assert_(not np.all(sol.measurement[0] == 0.+0j))
++    assert_(np.all(sol2.measurement[0] == 0.+0j))
++    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
++                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
++    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
++                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
++    # sol and sol2 have the seed of traj 1 and 2 reversed.
++    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
++    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
++
++
++def test_smesolve_photocurrent():
++    "Stochastic: photocurrent_mesolve"
++    tol = 0.01
++
++    N = 4
++    gamma = 0.25
++    ntraj = 20
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [[a.dag() * a,f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    times = np.linspace(0, 1.0, 21)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
++                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
++                   map_func=parallel_map)
++
++    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
++                 for idx in range(len(e_ops))]))
++    assert_(len(res.measurement) == ntraj)
++    assert_(all([m.shape == (len(times), len(sc_ops))
++                 for m in res.measurement]))
++
++
++def test_smesolve_homodyne():
++    "Stochastic: smesolve: homodyne, time-dependent H"
++    tol = 0.01
++
++    N = 4
++    gamma = 0.25
++    ntraj = 20
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [[a.dag() * a,f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    times = np.linspace(0, 1.0, 21)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    list_methods_tol = ['euler-maruyama',
++                        'pc-euler',
++                        'pc-euler-2',
++                        'platen',
++                        'milstein',
++                        'milstein-imp',
++                        'rouchon',
++                        'taylor15',
++                        'taylor15-imp',
++                        'explicit15']
++    for solver in list_methods_tol:
++        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
++                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
++                       method='homodyne', store_measurement=True,
++                       solver=solver, map_func=parallel_map)
++        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
++                     for idx in range(len(e_ops))]))
++        assert_(len(res.measurement) == ntraj)
++        assert_(all([m.shape == (len(times), len(sc_ops))
++                     for m in res.measurement]))
++
++
++@pytest.mark.slow
++def test_smesolve_heterodyne():
++    "Stochastic: smesolve: heterodyne, time-dependent H"
++    tol = 0.01
++
++    N = 4
++    gamma = 0.25
++    ntraj = 20
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [[a.dag() * a, f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    times = np.linspace(0, 1.0, 21)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    list_methods_tol = ['euler-maruyama',
++                        'pc-euler',
++                        'pc-euler-2',
++                        'platen',
++                        'milstein',
++                        'milstein-imp',
++                        'rouchon',
++                        'taylor15',
++                        'taylor15-imp',
++                        'explicit15']
++    for solver in list_methods_tol:
++        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
++                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
++                       method='heterodyne', store_measurement=True,
++                       solver=solver, map_func=parallel_map)
++        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
++                     for idx in range(len(e_ops))]))
++        assert_(len(res.measurement) == ntraj)
++        assert_(all([m.shape == (len(times), len(sc_ops), 2)
++                     for m in res.measurement]))
++
++
++@pytest.mark.slow
++def test_general_stochastic():
++    "Stochastic: general_stochastic"
++    "Reproduce smesolve homodyne"
++    tol = 0.025
++    N = 4
++    gamma = 0.25
++    ntraj = 20
++    nsubsteps = 50
++    a = destroy(N)
++
++    H = [[a.dag() * a,f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
++    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
++    e_opsM = [spre(op) for op in e_ops]
++
++    def d1(t, vec):
++        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
++
++    def d2(t, vec):
++        out = []
++        vec_d = _data.Dense(vec)
++        for op in sc_opsM:
++            scale = -op.expect_data(t,vec_d)
++            out.append(
++                _data.add(op.matmul_data(t,vec_d),
++                          vec_d, scale)
++                )
++        return np.stack([o.to_array().ravel() for o in out])
++
++    times = np.linspace(0, 0.5, 13)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    list_methods_tol = ['euler-maruyama',
++                        'platen',
++                        'explicit15']
++    for solver in list_methods_tol:
++        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
++                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
++                                 nsubsteps=nsubsteps, solver=solver)
++    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
++                 for idx in range(len(e_ops))]))
++    assert_(len(res.measurement) == ntraj)
++
++
++def f_dargs(a, args):
++    return args["expect_op_3"] - 1
++
++
++@pytest.mark.xfail(reason="not working yet")
++def test_ssesolve_feedback():
++    "Stochastic: ssesolve: time-dependent H with feedback"
++    tol = 0.01
++    N = 4
++    ntraj = 10
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [num(N)]
++    psi0 = coherent(N, 2.5)
++    sc_ops = [[a + a.dag(), f_dargs]]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
++
++    times = np.linspace(0, 10, 101)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
++                      args={"expect_op_3":qeye(N)})
++    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
++                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
++                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
++
++    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
++
++
++def test_smesolve_bad_e_ops():
++    "Stochastic: ssesolve: time-dependent H with feedback"
++    tol = 0.01
++    N = 4
++    ntraj = 10
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [num(N)]
++    psi0 = coherent(N, 2.5)
++    sc_ops = [a + a.dag()]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
++
++    times = np.linspace(0, 10, 101)
++    with pytest.raises(TypeError) as exc:
++        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
++                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
++                       map_func=parallel_map)
+diff --git a/qutip/tests/solve/test_stochastic_se.py b/qutip/tests/solve/test_stochastic_se.py
+index 8a40f2d7..e18ec023 100644
+--- a/qutip/tests/solve/test_stochastic_se.py
++++ b/qutip/tests/solve/test_stochastic_se.py
+@@ -1,230 +1,230 @@
+-import pytest
+-import numpy as np
+-from numpy.testing import assert_
+-
+-from qutip import (
+-    ssesolve, destroy, coherent, mesolve, fock, qeye,
+-    photocurrent_sesolve, num,
+-)
+-from qutip.solve.parallel import parallel_map
+-
+-def f(t, args):
+-    return args["a"] * t
+-
+-
+-@pytest.mark.slow
+-def test_ssesolve_homodyne_methods():
+-    "Stochastic: ssesolve: homodyne methods with single jump operator"
+-
+-    def arccoth(x):
+-        return 0.5*np.log((1.+x)/(x-1.))
+-
+-    th = 0.1 # Interaction parameter
+-    alpha = np.cos(th)
+-    beta = np.sin(th)
+-    gamma = 1.
+-
+-    N = 30                 # number of Fock states
+-    Id = qeye(N)
+-    a = destroy(N)
+-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
+-    x = (a + a.dag()) * 2**-0.5
+-    H = Id + gamma * a * a.dag()
+-    sc_op = [s]
+-    e_op = [x, x*x]
+-    rho0 = fock(N,0)      # initial vacuum state
+-
+-    T = 6.                   # final time
+-    # number of time steps for which we save the expectation values
+-    N_store = 200
+-    Nsub = 10
+-    tlist = np.linspace(0, T, N_store)
+-    ddt = (tlist[1]-tlist[0])
+-
+-    #### No analytic solution for ssesolve, taylor15 with 500 substep
+-    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
+-                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
+-    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
+-
+-
+-    list_methods_tol = [['euler-maruyama', 3e-2],
+-                        ['pc-euler', 5e-3],
+-                        ['pc-euler-2', 5e-3],
+-                        ['platen', 5e-3],
+-                        ['milstein', 5e-3],
+-                        ['milstein-imp', 5e-3],
+-                        ['taylor1.5', 5e-4],
+-                        ['taylor1.5-imp', 5e-4],
+-                        ['explicit1.5', 5e-4],
+-                        ['taylor2.0', 5e-4]]
+-    for n_method in list_methods_tol:
+-        # Comparisons of error between sol and sol3 depend on the stochastic
+-        # noise, thus the seed, fixing the seed remove random fails.
+-        np.random.seed(1)
+-        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
+-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
+-        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
+-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
+-                       noise = sol.noise)
+-        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
+-                        nsubsteps=Nsub*10, method='homodyne',
+-                        solver=n_method[0], tol=1e-8)
+-        err = 1/T * np.sum(np.abs(y_an - \
+-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
+-        err3 = 1/T * np.sum(np.abs(y_an - \
+-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
+-        assert err < n_method[1]
+-        # 5* more substep should decrease the error
+-        assert err3 < err
+-        # just to check that noise is not affected by ssesolve
+-        assert np.all(sol.noise == sol2.noise)
+-        assert np.all(sol.expect[0] == sol2.expect[0])
+-
+-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
+-                    nsubsteps=Nsub, method='homodyne', solver='euler',
+-                    store_measurement=1)
+-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
+-                    nsubsteps=Nsub, method='homodyne', solver='euler',
+-                    store_measurement=0)
+-    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
+-                    nsubsteps=Nsub, method='homodyne', solver='euler')
+-    # sol and sol2 have the same seed, sol3 differ.
+-    assert np.all(sol.noise == sol2.noise)
+-    assert np.all(sol.noise != sol3.noise)
+-    assert not np.all(sol.measurement[0] == 0.+0j)
+-    assert np.all(sol2.measurement[0] == 0.+0j)
+-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
+-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
+-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+-    # sol and sol2 have the seed of traj 1 and 2 reversed.
+-    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
+-    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
+-
+-
+-def test_ssesolve_photocurrent():
+-    "Stochastic: photocurrent_sesolve"
+-    tol = 0.01
+-
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 25
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a,f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    times = np.linspace(0, 2.5, 50)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
+-                              nsubsteps=nsubsteps, store_measurement=True,
+-                              map_func=parallel_map, args={"a":2})
+-
+-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+-    assert len(res.measurement) == ntraj
+-    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
+-
+-
+-def test_ssesolve_homodyne():
+-    "Stochastic: ssesolve: homodyne, time-dependent H"
+-    tol = 0.01
+-
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 25
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a,f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    times = np.linspace(0, 2.5, 50)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
+-                   ntraj=ntraj, nsubsteps=nsubsteps,
+-                   method='homodyne', store_measurement=True,
+-                   map_func=parallel_map, args={"a":2})
+-
+-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+-    assert len(res.measurement) == ntraj
+-    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
+-
+-
+-@pytest.mark.slow
+-def test_ssesolve_heterodyne():
+-    "Stochastic: ssesolve: heterodyne, time-dependent H"
+-    tol = 0.01
+-
+-    N = 4
+-    gamma = 0.25
+-    ntraj = 25
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [[a.dag() * a,f]]
+-    psi0 = coherent(N, 0.5)
+-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+-
+-    times = np.linspace(0, 2.5, 50)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
+-                   ntraj=ntraj, nsubsteps=nsubsteps,
+-                   method='heterodyne', store_measurement=True,
+-                   map_func=parallel_map, args={"a":2})
+-
+-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+-    assert len(res.measurement) == ntraj
+-    assert all(m.shape == (len(times), len(sc_ops), 2)
+-               for m in res.measurement)
+-
+-
+-def f_dargs(t, args):
+-    return args["expect_op_3"] - 1
+-
+-
+-@pytest.mark.xfail(reason="not yet working")
+-def test_ssesolve_feedback():
+-    "Stochastic: ssesolve: time-dependent H with feedback"
+-    tol = 0.01
+-    N = 4
+-    ntraj = 10
+-    nsubsteps = 100
+-    a = destroy(N)
+-
+-    H = [num(N)]
+-    psi0 = coherent(N, 2.5)
+-    sc_ops = [[a + a.dag(), f_dargs]]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
+-
+-    times = np.linspace(0, 10, 101)
+-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
+-                      args={"expect_op_3": qeye(N)})
+-    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
+-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+-                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
+-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+-
+-
+-def test_ssesolve_bad_e_ops():
+-    tol = 0.01
+-    N = 4
+-    ntraj = 10
+-    nsubsteps = 100
+-    a = destroy(N)
+-    b = destroy(N-1)
+-
+-    H = [num(N)]
+-    psi0 = coherent(N, 2.5)
+-    sc_ops = [a + a.dag()]
+-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
+-    times = np.linspace(0, 10, 101)
+-    with pytest.raises(TypeError) as exc:
+-        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
+-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+-                       map_func=parallel_map)
++import pytest
++import numpy as np
++from numpy.testing import assert_
++
++from qutip import (
++    ssesolve, destroy, coherent, mesolve, fock, qeye,
++    photocurrent_sesolve, num,
++)
++from qutip.solve.parallel import parallel_map
++
++def f(t, args):
++    return args["a"] * t
++
++
++@pytest.mark.slow
++def test_ssesolve_homodyne_methods():
++    "Stochastic: ssesolve: homodyne methods with single jump operator"
++
++    def arccoth(x):
++        return 0.5*np.log((1.+x)/(x-1.))
++
++    th = 0.1 # Interaction parameter
++    alpha = np.cos(th)
++    beta = np.sin(th)
++    gamma = 1.
++
++    N = 30                 # number of Fock states
++    Id = qeye(N)
++    a = destroy(N)
++    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
++    x = (a + a.dag()) * 2**-0.5
++    H = Id + gamma * a * a.dag()
++    sc_op = [s]
++    e_op = [x, x*x]
++    rho0 = fock(N,0)      # initial vacuum state
++
++    T = 6.                   # final time
++    # number of time steps for which we save the expectation values
++    N_store = 200
++    Nsub = 10
++    tlist = np.linspace(0, T, N_store)
++    ddt = (tlist[1]-tlist[0])
++
++    #### No analytic solution for ssesolve, taylor15 with 500 substep
++    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
++                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
++    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
++
++
++    list_methods_tol = [['euler-maruyama', 3e-2],
++                        ['pc-euler', 5e-3],
++                        ['pc-euler-2', 5e-3],
++                        ['platen', 5e-3],
++                        ['milstein', 5e-3],
++                        ['milstein-imp', 5e-3],
++                        ['taylor1.5', 5e-4],
++                        ['taylor1.5-imp', 5e-4],
++                        ['explicit1.5', 5e-4],
++                        ['taylor2.0', 5e-4]]
++    for n_method in list_methods_tol:
++        # Comparisons of error between sol and sol3 depend on the stochastic
++        # noise, thus the seed, fixing the seed remove random fails.
++        np.random.seed(1)
++        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
++                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
++        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
++                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
++                       noise = sol.noise)
++        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
++                        nsubsteps=Nsub*10, method='homodyne',
++                        solver=n_method[0], tol=1e-8)
++        err = 1/T * np.sum(np.abs(y_an - \
++                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
++        err3 = 1/T * np.sum(np.abs(y_an - \
++                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
++        assert err < n_method[1]
++        # 5* more substep should decrease the error
++        assert err3 < err
++        # just to check that noise is not affected by ssesolve
++        assert np.all(sol.noise == sol2.noise)
++        assert np.all(sol.expect[0] == sol2.expect[0])
++
++    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
++                    nsubsteps=Nsub, method='homodyne', solver='euler',
++                    store_measurement=1)
++    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
++                    nsubsteps=Nsub, method='homodyne', solver='euler',
++                    store_measurement=0)
++    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
++                    nsubsteps=Nsub, method='homodyne', solver='euler')
++    # sol and sol2 have the same seed, sol3 differ.
++    assert np.all(sol.noise == sol2.noise)
++    assert np.all(sol.noise != sol3.noise)
++    assert not np.all(sol.measurement[0] == 0.+0j)
++    assert np.all(sol2.measurement[0] == 0.+0j)
++    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
++                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
++    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
++                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
++    # sol and sol2 have the seed of traj 1 and 2 reversed.
++    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
++    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
++
++
++def test_ssesolve_photocurrent():
++    "Stochastic: photocurrent_sesolve"
++    tol = 0.01
++
++    N = 4
++    gamma = 0.25
++    ntraj = 25
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [[a.dag() * a,f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    times = np.linspace(0, 2.5, 50)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
++                              nsubsteps=nsubsteps, store_measurement=True,
++                              map_func=parallel_map, args={"a":2})
++
++    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
++    assert len(res.measurement) == ntraj
++    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
++
++
++def test_ssesolve_homodyne():
++    "Stochastic: ssesolve: homodyne, time-dependent H"
++    tol = 0.01
++
++    N = 4
++    gamma = 0.25
++    ntraj = 25
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [[a.dag() * a,f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    times = np.linspace(0, 2.5, 50)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    res = ssesolve(H, psi0, times, sc_ops, e_ops,
++                   ntraj=ntraj, nsubsteps=nsubsteps,
++                   method='homodyne', store_measurement=True,
++                   map_func=parallel_map, args={"a":2})
++
++    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
++    assert len(res.measurement) == ntraj
++    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
++
++
++@pytest.mark.slow
++def test_ssesolve_heterodyne():
++    "Stochastic: ssesolve: heterodyne, time-dependent H"
++    tol = 0.01
++
++    N = 4
++    gamma = 0.25
++    ntraj = 25
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [[a.dag() * a,f]]
++    psi0 = coherent(N, 0.5)
++    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
++
++    times = np.linspace(0, 2.5, 50)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
++    res = ssesolve(H, psi0, times, sc_ops, e_ops,
++                   ntraj=ntraj, nsubsteps=nsubsteps,
++                   method='heterodyne', store_measurement=True,
++                   map_func=parallel_map, args={"a":2})
++
++    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
++    assert len(res.measurement) == ntraj
++    assert all(m.shape == (len(times), len(sc_ops), 2)
++               for m in res.measurement)
++
++
++def f_dargs(t, args):
++    return args["expect_op_3"] - 1
++
++
++@pytest.mark.xfail(reason="not yet working")
++def test_ssesolve_feedback():
++    "Stochastic: ssesolve: time-dependent H with feedback"
++    tol = 0.01
++    N = 4
++    ntraj = 10
++    nsubsteps = 100
++    a = destroy(N)
++
++    H = [num(N)]
++    psi0 = coherent(N, 2.5)
++    sc_ops = [[a + a.dag(), f_dargs]]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
++
++    times = np.linspace(0, 10, 101)
++    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
++                      args={"expect_op_3": qeye(N)})
++    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
++                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
++                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
++    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
++
++
++def test_ssesolve_bad_e_ops():
++    tol = 0.01
++    N = 4
++    ntraj = 10
++    nsubsteps = 100
++    a = destroy(N)
++    b = destroy(N-1)
++
++    H = [num(N)]
++    psi0 = coherent(N, 2.5)
++    sc_ops = [a + a.dag()]
++    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
++    times = np.linspace(0, 10, 101)
++    with pytest.raises(TypeError) as exc:
++        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
++                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
++                       map_func=parallel_map)
+diff --git a/qutip/tests/solver/heom/test_bofin_baths.py b/qutip/tests/solver/heom/test_bofin_baths.py
+index c6c5c80f..32a4eca2 100644
+--- a/qutip/tests/solver/heom/test_bofin_baths.py
++++ b/qutip/tests/solver/heom/test_bofin_baths.py
+@@ -1,465 +1,465 @@
+-"""
+-Tests for qutip.nonmarkov.bofin_baths.
+-"""
+-
+-import numpy as np
+-import pytest
+-
+-from qutip import spre, spost, sigmax, sigmaz
+-from qutip.core import data as _data
+-from qutip.solver.heom.bofin_baths import (
+-    BathExponent,
+-    Bath,
+-    BosonicBath,
+-    DrudeLorentzBath,
+-    DrudeLorentzPadeBath,
+-    UnderDampedBath,
+-    FermionicBath,
+-    LorentzianBath,
+-    LorentzianPadeBath,
+-)
+-
+-
+-def isequal(Q1, Q2, tol):
+-    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
+-    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
+-
+-
+-def check_exponent(
+-    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
+-):
+-    """ Check the attributes of a BathExponent. """
+-    assert exp.type is BathExponent.types[type]
+-    assert exp.fermionic == (type in ["+", "-"])
+-    assert exp.dim == dim
+-    assert exp.Q == Q
+-    assert exp.ck == pytest.approx(ck)
+-    assert exp.vk == pytest.approx(vk)
+-    assert exp.ck2 == pytest.approx(ck2)
+-    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
+-    assert exp.tag == tag
+-
+-
+-class TestBathExponent:
+-    def test_create(self):
+-        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
+-        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
+-
+-        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
+-        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
+-
+-        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
+-        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
+-
+-        exp_p = BathExponent(
+-            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+-        )
+-        check_exponent(
+-            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+-        )
+-
+-        exp_m = BathExponent(
+-            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
+-        )
+-        check_exponent(
+-            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
+-        )
+-
+-        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
+-        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
+-
+-        for exp_type, kw in [
+-            ("R", {}),
+-            ("I", {}),
+-            ("+", {"sigma_bar_k_offset": 1}),
+-            ("-", {"sigma_bar_k_offset": -1}),
+-        ]:
+-            with pytest.raises(ValueError) as err:
+-                BathExponent(
+-                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
+-                )
+-            assert str(err.value) == (
+-                "Second co-efficient (ck2) should only be specified for RI"
+-                " bath exponents"
+-            )
+-
+-        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
+-            with pytest.raises(ValueError) as err:
+-                BathExponent(
+-                    exp_type, None, Q=None, ck=1.0, vk=2.0,
+-                    sigma_bar_k_offset=1, **kw,
+-                )
+-            assert str(err.value) == (
+-                "Offset of sigma bar (sigma_bar_k_offset) should only be"
+-                " specified for + and - bath exponents"
+-            )
+-
+-    def test_repr(self):
+-        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
+-        assert repr(exp1) == (
+-            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
+-            " ck=1.0 vk=2.0 ck2=None"
+-            " sigma_bar_k_offset=None fermionic=False tag=None>"
+-        )
+-        exp2 = BathExponent(
+-            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+-            tag="bath1",
+-        )
+-        assert repr(exp2) == (
+-            "<BathExponent type=+ dim=None Q.dims=None"
+-            " ck=1.0 vk=2.0 ck2=None"
+-            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
+-        )
+-
+-
+-class TestBath:
+-    def test_create(self):
+-        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
+-        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
+-        bath = Bath([exp_r, exp_i])
+-        assert bath.exponents == [exp_r, exp_i]
+-
+-
+-class TestBosonicBath:
+-    def test_create(self):
+-        Q = sigmaz()
+-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
+-        exp_r, exp_i = bath.exponents
+-        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
+-        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
+-
+-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
+-        [exp_ri] = bath.exponents
+-        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
+-
+-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
+-        exp_r, exp_i = bath.exponents
+-        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
+-        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
+-
+-        with pytest.raises(ValueError) as err:
+-            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
+-        assert str(err.value) == "The coupling operator Q must be a Qobj."
+-
+-        with pytest.raises(ValueError) as err:
+-            BosonicBath(Q, [1.], [], [2.], [0.6])
+-        assert str(err.value) == (
+-            "The bath exponent lists ck_real and vk_real, and ck_imag and"
+-            " vk_imag must be the same length."
+-        )
+-
+-        with pytest.raises(ValueError) as err:
+-            BosonicBath(Q, [1.], [0.5], [2.], [])
+-        assert str(err.value) == (
+-            "The bath exponent lists ck_real and vk_real, and ck_imag and"
+-            " vk_imag must be the same length."
+-        )
+-
+-    def test_combine(self):
+-        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
+-        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
+-        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
+-        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
+-
+-        [exp] = BosonicBath.combine([exp_rx, exp_rx])
+-        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
+-
+-        [exp] = BosonicBath.combine([exp_ix, exp_ix])
+-        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
+-
+-        [exp] = BosonicBath.combine([exp_rix, exp_rix])
+-        check_exponent(
+-            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
+-        )
+-
+-        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
+-        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
+-        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
+-
+-        [exp] = BosonicBath.combine([exp_rx, exp_ix])
+-        check_exponent(
+-            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
+-        )
+-
+-        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
+-        check_exponent(
+-            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
+-        )
+-
+-
+-class TestDrudeLorentzBath:
+-    def test_create(self):
+-        Q = sigmaz()
+-        ck_real = [0.05262168274189053, 0.0007958201977617107]
+-        vk_real = [0.05, 6.613879270715354]
+-        ck_imag = [-0.0012500000000000002]
+-        vk_imag = [0.05]
+-
+-        bath = DrudeLorentzBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
+-        )
+-        [exp1, exp2] = bath.exponents
+-        check_exponent(
+-            exp1, "RI", dim=None, Q=Q,
+-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+-            tag="bath1",
+-        )
+-        check_exponent(
+-            exp2, "R", dim=None, Q=Q,
+-            ck=ck_real[1], vk=vk_real[1],
+-            tag="bath1",
+-        )
+-
+-        bath = DrudeLorentzBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
+-        )
+-        [exp1, exp2, exp3] = bath.exponents
+-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+-        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+-
+-    @pytest.mark.parametrize(['combine'], [
+-        pytest.param(True, id="combine"),
+-        pytest.param(False, id="no-combine"),
+-    ])
+-    def test_terminator(self, combine):
+-        Q = sigmaz()
+-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+-
+-        bath = DrudeLorentzBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
+-        )
+-        delta, terminator = bath.terminator()
+-
+-        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
+-        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
+-
+-
+-class TestDrudeLorentzPadeBath:
+-    def test_create(self):
+-        Q = sigmaz()
+-        ck_real = [0.05262168274189053, 0.0016138037466648136]
+-        vk_real = [0.05, 8.153649149910352]
+-        ck_imag = [-0.0012500000000000002]
+-        vk_imag = [0.05]
+-
+-        bath = DrudeLorentzPadeBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
+-        )
+-        [exp1, exp2] = bath.exponents
+-        check_exponent(
+-            exp1, "RI", dim=None, Q=Q,
+-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+-            tag="bath1",
+-        )
+-        check_exponent(
+-            exp2, "R", dim=None, Q=Q,
+-            ck=ck_real[1], vk=vk_real[1],
+-            tag="bath1",
+-        )
+-
+-        bath = DrudeLorentzPadeBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
+-        )
+-        [exp1, exp2, exp3] = bath.exponents
+-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+-        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+-
+-    @pytest.mark.parametrize(['combine'], [
+-        pytest.param(True, id="combine"),
+-        pytest.param(False, id="no-combine"),
+-    ])
+-    def test_terminator(self, combine):
+-        Q = sigmaz()
+-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+-
+-        bath = DrudeLorentzPadeBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
+-        )
+-        delta, terminator = bath.terminator()
+-
+-        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
+-        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
+-
+-
+-class TestUnderDampedBath:
+-    def test_create(self):
+-        Q = sigmaz()
+-        ck_real = [
+-            0.0003533235200322013-7.634500355085952e-06j,
+-            0.0003533235200322013+7.634500355085952e-06j,
+-            -2.173594134367819e-07+0j,
+-        ]
+-        vk_real = [
+-            0.025-0.9996874511566103j,
+-            0.025+0.9996874511566103j,
+-            6.613879270715354,
+-        ]
+-        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
+-        vk_imag = [
+-            0.025-0.9996874511566103j,
+-            0.025+0.9996874511566103j,
+-        ]
+-
+-        bath = UnderDampedBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
+-        )
+-        [exp1, exp2, exp3] = bath.exponents
+-        check_exponent(
+-            exp1, "RI", dim=None, Q=Q,
+-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+-            tag="bath1",
+-        )
+-        check_exponent(
+-            exp2, "RI", dim=None, Q=Q,
+-            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
+-            tag="bath1",
+-        )
+-        check_exponent(
+-            exp3, "R", dim=None, Q=Q,
+-            ck=ck_real[2], vk=vk_real[2],
+-            tag="bath1",
+-        )
+-
+-        bath = UnderDampedBath(
+-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
+-        )
+-        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
+-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+-        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
+-        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+-        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
+-
+-
+-class TestFermionicBath:
+-    def test_create(self):
+-        Q = 1j * sigmaz()
+-        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
+-        exp_p, exp_m = bath.exponents
+-        check_exponent(
+-            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
+-        )
+-        check_exponent(
+-            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
+-        )
+-
+-        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
+-        exp_p, exp_m = bath.exponents
+-        check_exponent(
+-            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
+-            tag="bath1",
+-        )
+-        check_exponent(
+-            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
+-            tag="bath1",
+-        )
+-
+-        with pytest.raises(ValueError) as err:
+-            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
+-        assert str(err.value) == "The coupling operator Q must be a Qobj."
+-
+-        with pytest.raises(ValueError) as err:
+-            FermionicBath(Q, [1.], [], [2.], [0.6])
+-        assert str(err.value) == (
+-            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+-            " vk_minus must be the same length."
+-        )
+-
+-        with pytest.raises(ValueError) as err:
+-            FermionicBath(Q, [1.], [0.5], [2.], [])
+-        assert str(err.value) == (
+-            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+-            " vk_minus must be the same length."
+-        )
+-
+-
+-class TestLorentzianBath:
+-    def test_create(self):
+-        Q = sigmaz()
+-        ck_plus = [
+-            0.0025-0.0013376935246402686j,
+-            -0.00026023645770006167j,
+-            -0.0002748355116913478j,
+-        ]
+-        vk_plus = [
+-            1+1j,
+-            0.08121642500626945+1j,
+-            0.24364927501880834+1j,
+-        ]
+-        ck_minus = [
+-            0.0025-0.0013376935246402686j,
+-            -0.00026023645770006167j,
+-            -0.0002748355116913478j,
+-        ]
+-        vk_minus = [
+-            1-1j,
+-            0.08121642500626945-1j,
+-            0.24364927501880834-1j,
+-        ]
+-
+-        bath = LorentzianBath(
+-            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
+-        )
+-        assert len(bath.exponents) == 6
+-        for i in range(len(ck_plus)):
+-            exp_p = bath.exponents[2 * i]
+-            exp_m = bath.exponents[2 * i + 1]
+-            check_exponent(
+-                exp_p, "+", dim=2, Q=Q,
+-                ck=ck_plus[i], vk=vk_plus[i],
+-                sigma_bar_k_offset=1,
+-                tag="bath1",
+-            )
+-            check_exponent(
+-                exp_m, "-", dim=2, Q=Q,
+-                ck=ck_minus[i], vk=vk_minus[i],
+-                sigma_bar_k_offset=-1,
+-                tag="bath1",
+-            )
+-
+-
+-class TestLorentzianPadeBath:
+-    def test_create(self):
+-        Q = sigmaz()
+-        ck_plus = [
+-            0.0025+0.0014269000277373958j,
+-            -0.0002608459250597002j,
+-            -0.0011660541026776957j,
+-        ]
+-        vk_plus = [
+-            1+1j,
+-            0.08123902308117874+1j,
+-            0.3371925267385835+1j,
+-        ]
+-        ck_minus = [
+-            0.0025+0.0014269000277373958j,
+-            -0.0002608459250597002j,
+-            -0.0011660541026776957j,
+-        ]
+-        vk_minus = [
+-            1-1j,
+-            0.08123902308117874-1j,
+-            0.3371925267385835-1j,
+-        ]
+-
+-        bath = LorentzianPadeBath(
+-            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
+-        )
+-        assert len(bath.exponents) == 6
+-        for i in range(len(ck_plus)):
+-            exp_p = bath.exponents[2 * i]
+-            exp_m = bath.exponents[2 * i + 1]
+-            check_exponent(
+-                exp_p, "+", dim=2, Q=Q,
+-                ck=ck_plus[i], vk=vk_plus[i],
+-                sigma_bar_k_offset=1,
+-                tag="bath1",
+-            )
+-            check_exponent(
+-                exp_m, "-", dim=2, Q=Q,
+-                ck=ck_minus[i], vk=vk_minus[i],
+-                sigma_bar_k_offset=-1,
+-                tag="bath1",
+-            )
++"""
++Tests for qutip.nonmarkov.bofin_baths.
++"""
++
++import numpy as np
++import pytest
++
++from qutip import spre, spost, sigmax, sigmaz
++from qutip.core import data as _data
++from qutip.solver.heom.bofin_baths import (
++    BathExponent,
++    Bath,
++    BosonicBath,
++    DrudeLorentzBath,
++    DrudeLorentzPadeBath,
++    UnderDampedBath,
++    FermionicBath,
++    LorentzianBath,
++    LorentzianPadeBath,
++)
++
++
++def isequal(Q1, Q2, tol):
++    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
++    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
++
++
++def check_exponent(
++    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
++):
++    """ Check the attributes of a BathExponent. """
++    assert exp.type is BathExponent.types[type]
++    assert exp.fermionic == (type in ["+", "-"])
++    assert exp.dim == dim
++    assert exp.Q == Q
++    assert exp.ck == pytest.approx(ck)
++    assert exp.vk == pytest.approx(vk)
++    assert exp.ck2 == pytest.approx(ck2)
++    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
++    assert exp.tag == tag
++
++
++class TestBathExponent:
++    def test_create(self):
++        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
++        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
++
++        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
++        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
++
++        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
++        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
++
++        exp_p = BathExponent(
++            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
++        )
++        check_exponent(
++            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
++        )
++
++        exp_m = BathExponent(
++            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
++        )
++        check_exponent(
++            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
++        )
++
++        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
++        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
++
++        for exp_type, kw in [
++            ("R", {}),
++            ("I", {}),
++            ("+", {"sigma_bar_k_offset": 1}),
++            ("-", {"sigma_bar_k_offset": -1}),
++        ]:
++            with pytest.raises(ValueError) as err:
++                BathExponent(
++                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
++                )
++            assert str(err.value) == (
++                "Second co-efficient (ck2) should only be specified for RI"
++                " bath exponents"
++            )
++
++        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
++            with pytest.raises(ValueError) as err:
++                BathExponent(
++                    exp_type, None, Q=None, ck=1.0, vk=2.0,
++                    sigma_bar_k_offset=1, **kw,
++                )
++            assert str(err.value) == (
++                "Offset of sigma bar (sigma_bar_k_offset) should only be"
++                " specified for + and - bath exponents"
++            )
++
++    def test_repr(self):
++        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
++        assert repr(exp1) == (
++            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
++            " ck=1.0 vk=2.0 ck2=None"
++            " sigma_bar_k_offset=None fermionic=False tag=None>"
++        )
++        exp2 = BathExponent(
++            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
++            tag="bath1",
++        )
++        assert repr(exp2) == (
++            "<BathExponent type=+ dim=None Q.dims=None"
++            " ck=1.0 vk=2.0 ck2=None"
++            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
++        )
++
++
++class TestBath:
++    def test_create(self):
++        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
++        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
++        bath = Bath([exp_r, exp_i])
++        assert bath.exponents == [exp_r, exp_i]
++
++
++class TestBosonicBath:
++    def test_create(self):
++        Q = sigmaz()
++        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
++        exp_r, exp_i = bath.exponents
++        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
++        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
++
++        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
++        [exp_ri] = bath.exponents
++        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
++
++        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
++        exp_r, exp_i = bath.exponents
++        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
++        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
++
++        with pytest.raises(ValueError) as err:
++            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
++        assert str(err.value) == "The coupling operator Q must be a Qobj."
++
++        with pytest.raises(ValueError) as err:
++            BosonicBath(Q, [1.], [], [2.], [0.6])
++        assert str(err.value) == (
++            "The bath exponent lists ck_real and vk_real, and ck_imag and"
++            " vk_imag must be the same length."
++        )
++
++        with pytest.raises(ValueError) as err:
++            BosonicBath(Q, [1.], [0.5], [2.], [])
++        assert str(err.value) == (
++            "The bath exponent lists ck_real and vk_real, and ck_imag and"
++            " vk_imag must be the same length."
++        )
++
++    def test_combine(self):
++        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
++        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
++        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
++        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
++
++        [exp] = BosonicBath.combine([exp_rx, exp_rx])
++        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
++
++        [exp] = BosonicBath.combine([exp_ix, exp_ix])
++        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
++
++        [exp] = BosonicBath.combine([exp_rix, exp_rix])
++        check_exponent(
++            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
++        )
++
++        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
++        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
++        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
++
++        [exp] = BosonicBath.combine([exp_rx, exp_ix])
++        check_exponent(
++            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
++        )
++
++        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
++        check_exponent(
++            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
++        )
++
++
++class TestDrudeLorentzBath:
++    def test_create(self):
++        Q = sigmaz()
++        ck_real = [0.05262168274189053, 0.0007958201977617107]
++        vk_real = [0.05, 6.613879270715354]
++        ck_imag = [-0.0012500000000000002]
++        vk_imag = [0.05]
++
++        bath = DrudeLorentzBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
++        )
++        [exp1, exp2] = bath.exponents
++        check_exponent(
++            exp1, "RI", dim=None, Q=Q,
++            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
++            tag="bath1",
++        )
++        check_exponent(
++            exp2, "R", dim=None, Q=Q,
++            ck=ck_real[1], vk=vk_real[1],
++            tag="bath1",
++        )
++
++        bath = DrudeLorentzBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
++        )
++        [exp1, exp2, exp3] = bath.exponents
++        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
++        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
++        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
++
++    @pytest.mark.parametrize(['combine'], [
++        pytest.param(True, id="combine"),
++        pytest.param(False, id="no-combine"),
++    ])
++    def test_terminator(self, combine):
++        Q = sigmaz()
++        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
++
++        bath = DrudeLorentzBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
++        )
++        delta, terminator = bath.terminator()
++
++        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
++        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
++
++
++class TestDrudeLorentzPadeBath:
++    def test_create(self):
++        Q = sigmaz()
++        ck_real = [0.05262168274189053, 0.0016138037466648136]
++        vk_real = [0.05, 8.153649149910352]
++        ck_imag = [-0.0012500000000000002]
++        vk_imag = [0.05]
++
++        bath = DrudeLorentzPadeBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
++        )
++        [exp1, exp2] = bath.exponents
++        check_exponent(
++            exp1, "RI", dim=None, Q=Q,
++            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
++            tag="bath1",
++        )
++        check_exponent(
++            exp2, "R", dim=None, Q=Q,
++            ck=ck_real[1], vk=vk_real[1],
++            tag="bath1",
++        )
++
++        bath = DrudeLorentzPadeBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
++        )
++        [exp1, exp2, exp3] = bath.exponents
++        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
++        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
++        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
++
++    @pytest.mark.parametrize(['combine'], [
++        pytest.param(True, id="combine"),
++        pytest.param(False, id="no-combine"),
++    ])
++    def test_terminator(self, combine):
++        Q = sigmaz()
++        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
++
++        bath = DrudeLorentzPadeBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
++        )
++        delta, terminator = bath.terminator()
++
++        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
++        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
++
++
++class TestUnderDampedBath:
++    def test_create(self):
++        Q = sigmaz()
++        ck_real = [
++            0.0003533235200322013-7.634500355085952e-06j,
++            0.0003533235200322013+7.634500355085952e-06j,
++            -2.173594134367819e-07+0j,
++        ]
++        vk_real = [
++            0.025-0.9996874511566103j,
++            0.025+0.9996874511566103j,
++            6.613879270715354,
++        ]
++        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
++        vk_imag = [
++            0.025-0.9996874511566103j,
++            0.025+0.9996874511566103j,
++        ]
++
++        bath = UnderDampedBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
++        )
++        [exp1, exp2, exp3] = bath.exponents
++        check_exponent(
++            exp1, "RI", dim=None, Q=Q,
++            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
++            tag="bath1",
++        )
++        check_exponent(
++            exp2, "RI", dim=None, Q=Q,
++            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
++            tag="bath1",
++        )
++        check_exponent(
++            exp3, "R", dim=None, Q=Q,
++            ck=ck_real[2], vk=vk_real[2],
++            tag="bath1",
++        )
++
++        bath = UnderDampedBath(
++            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
++        )
++        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
++        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
++        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
++        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
++        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
++        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
++
++
++class TestFermionicBath:
++    def test_create(self):
++        Q = 1j * sigmaz()
++        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
++        exp_p, exp_m = bath.exponents
++        check_exponent(
++            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
++        )
++        check_exponent(
++            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
++        )
++
++        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
++        exp_p, exp_m = bath.exponents
++        check_exponent(
++            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
++            tag="bath1",
++        )
++        check_exponent(
++            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
++            tag="bath1",
++        )
++
++        with pytest.raises(ValueError) as err:
++            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
++        assert str(err.value) == "The coupling operator Q must be a Qobj."
++
++        with pytest.raises(ValueError) as err:
++            FermionicBath(Q, [1.], [], [2.], [0.6])
++        assert str(err.value) == (
++            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
++            " vk_minus must be the same length."
++        )
++
++        with pytest.raises(ValueError) as err:
++            FermionicBath(Q, [1.], [0.5], [2.], [])
++        assert str(err.value) == (
++            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
++            " vk_minus must be the same length."
++        )
++
++
++class TestLorentzianBath:
++    def test_create(self):
++        Q = sigmaz()
++        ck_plus = [
++            0.0025-0.0013376935246402686j,
++            -0.00026023645770006167j,
++            -0.0002748355116913478j,
++        ]
++        vk_plus = [
++            1+1j,
++            0.08121642500626945+1j,
++            0.24364927501880834+1j,
++        ]
++        ck_minus = [
++            0.0025-0.0013376935246402686j,
++            -0.00026023645770006167j,
++            -0.0002748355116913478j,
++        ]
++        vk_minus = [
++            1-1j,
++            0.08121642500626945-1j,
++            0.24364927501880834-1j,
++        ]
++
++        bath = LorentzianBath(
++            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
++        )
++        assert len(bath.exponents) == 6
++        for i in range(len(ck_plus)):
++            exp_p = bath.exponents[2 * i]
++            exp_m = bath.exponents[2 * i + 1]
++            check_exponent(
++                exp_p, "+", dim=2, Q=Q,
++                ck=ck_plus[i], vk=vk_plus[i],
++                sigma_bar_k_offset=1,
++                tag="bath1",
++            )
++            check_exponent(
++                exp_m, "-", dim=2, Q=Q,
++                ck=ck_minus[i], vk=vk_minus[i],
++                sigma_bar_k_offset=-1,
++                tag="bath1",
++            )
++
++
++class TestLorentzianPadeBath:
++    def test_create(self):
++        Q = sigmaz()
++        ck_plus = [
++            0.0025+0.0014269000277373958j,
++            -0.0002608459250597002j,
++            -0.0011660541026776957j,
++        ]
++        vk_plus = [
++            1+1j,
++            0.08123902308117874+1j,
++            0.3371925267385835+1j,
++        ]
++        ck_minus = [
++            0.0025+0.0014269000277373958j,
++            -0.0002608459250597002j,
++            -0.0011660541026776957j,
++        ]
++        vk_minus = [
++            1-1j,
++            0.08123902308117874-1j,
++            0.3371925267385835-1j,
++        ]
++
++        bath = LorentzianPadeBath(
++            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
++        )
++        assert len(bath.exponents) == 6
++        for i in range(len(ck_plus)):
++            exp_p = bath.exponents[2 * i]
++            exp_m = bath.exponents[2 * i + 1]
++            check_exponent(
++                exp_p, "+", dim=2, Q=Q,
++                ck=ck_plus[i], vk=vk_plus[i],
++                sigma_bar_k_offset=1,
++                tag="bath1",
++            )
++            check_exponent(
++                exp_m, "-", dim=2, Q=Q,
++                ck=ck_minus[i], vk=vk_minus[i],
++                sigma_bar_k_offset=-1,
++                tag="bath1",
++            )
+diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
+index 72b737a9..69935d01 100644
+--- a/qutip/tests/solver/heom/test_bofin_solvers.py
++++ b/qutip/tests/solver/heom/test_bofin_solvers.py
+@@ -1,1396 +1,1396 @@
+-"""
+-Tests for qutip.nonmarkov.bofin_solvers.
+-"""
+-
+-import numpy as np
+-import pytest
+-from numpy.linalg import eigvalsh
+-from scipy.integrate import quad
+-
+-from qutip import (
+-    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
+-    tensor, Qobj, QobjEvo
+-)
+-from qutip.core import data as _data
+-from qutip.solver.heom.bofin_baths import (
+-    BathExponent,
+-    Bath,
+-    BosonicBath,
+-    DrudeLorentzBath,
+-    DrudeLorentzPadeBath,
+-    UnderDampedBath,
+-    FermionicBath,
+-    LorentzianBath,
+-    LorentzianPadeBath,
+-)
+-from qutip.solver.heom.bofin_solvers import (
+-    heomsolve,
+-    HierarchyADOs,
+-    HierarchyADOsState,
+-    HEOMResult,
+-    HEOMSolver,
+-    HSolverDL,
+-    _GatherHEOMRHS,
+-)
+-from qutip.solver import (
+-    IntegratorException,
+-)
+-
+-
+-def fill_options(**kwargs):
+-    """Fill the options with minimal entries needed by HEOMResult."""
+-    return {
+-        "store_final_state": False,
+-        "store_states": None,
+-        "store_ados": False,
+-        **kwargs
+-    }
+-
+-
+-def assert_raises_steady_state_time_dependent(hsolver):
+-    """ Assert that calling .steady_state() on a HEOMSolver with
+-        a time-dependent Hamiltonian raises the appropriate exception.
+-    """
+-    with pytest.raises(ValueError) as err:
+-        hsolver.steady_state()
+-    assert str(err.value) == (
+-       "A steady state cannot be determined for a time-dependent"
+-       " system"
+-    )
+-
+-
+-class TestHierarchyADOs:
+-    def mk_exponents(self, dims):
+-        return [
+-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
+-        ]
+-
+-    def test_create(self):
+-        exponents = self.mk_exponents([2, 3])
+-        ados = HierarchyADOs(exponents, max_depth=2)
+-
+-        assert ados.exponents == exponents
+-        assert ados.max_depth == 2
+-
+-        assert ados.dims == [2, 3]
+-        assert ados.vk == [2.0, 2.0]
+-        assert ados.ck == [1.0, 1.0]
+-        assert ados.ck2 == [None, None]
+-        assert ados.sigma_bar_k_offset == [None, None]
+-
+-        assert ados.labels == [
+-            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
+-        ]
+-
+-    def test_state_idx(self):
+-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+-        assert ados.idx((0, 0)) == 0
+-        assert ados.idx((0, 1)) == 1
+-        assert ados.idx((0, 2)) == 2
+-        assert ados.idx((1, 0)) == 3
+-        assert ados.idx((1, 1)) == 4
+-
+-    def test_next(self):
+-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+-        assert ados.next((0, 0), 0) == (1, 0)
+-        assert ados.next((0, 0), 1) == (0, 1)
+-        assert ados.next((1, 0), 0) is None
+-        assert ados.next((1, 0), 1) == (1, 1)
+-        assert ados.next((1, 1), 1) is None
+-
+-    def test_prev(self):
+-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+-        assert ados.prev((0, 0), 0) is None
+-        assert ados.prev((0, 0), 1) is None
+-        assert ados.prev((1, 0), 0) == (0, 0)
+-        assert ados.prev((0, 1), 1) == (0, 0)
+-        assert ados.prev((1, 1), 1) == (1, 0)
+-        assert ados.prev((0, 2), 1) == (0, 1)
+-
+-    def test_exps(self):
+-        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
+-        assert ados.exps((0, 0, 0)) == ()
+-        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
+-        assert ados.exps((2, 0, 0)) == (
+-            ados.exponents[0], ados.exponents[0],
+-        )
+-        assert ados.exps((1, 2, 1)) == (
+-            ados.exponents[0],
+-            ados.exponents[1], ados.exponents[1],
+-            ados.exponents[2],
+-        )
+-
+-    def test_filter_by_nothing(self):
+-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+-        assert ados.filter() == [
+-            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
+-        ]
+-
+-    def test_filter_by_level(self):
+-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+-        assert ados.filter(level=0) == [
+-            (0, 0),
+-        ]
+-        assert ados.filter(level=1) == [
+-            (0, 1),
+-            (1, 0),
+-        ]
+-        assert ados.filter(level=2) == [
+-            (0, 2),
+-            (1, 1),
+-        ]
+-        assert ados.filter(level=3) == []
+-
+-    def test_filter_by_exponents(self):
+-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+-        assert ados.filter(dims=[]) == [
+-            (0, 0),
+-        ]
+-        assert ados.filter(dims=[2]) == [
+-            (1, 0),
+-        ]
+-        assert ados.filter(level=1, dims=[2]) == [
+-            (1, 0),
+-        ]
+-        assert ados.filter(dims=[3]) == [
+-            (0, 1),
+-        ]
+-        assert ados.filter(dims=[2, 3]) == [
+-            (1, 1),
+-        ]
+-        assert ados.filter(level=2, dims=[2, 3]) == [
+-            (1, 1),
+-        ]
+-        assert ados.filter(dims=[3, 3]) == [
+-            (0, 2),
+-        ]
+-        assert ados.filter(types=["I"]) == [
+-            (0, 1),
+-            (1, 0),
+-        ]
+-        assert ados.filter(types=["I", "I"]) == [
+-            (0, 2),
+-            (1, 1),
+-        ]
+-
+-        with pytest.raises(ValueError) as err:
+-            ados.filter(types=[], dims=[2])
+-        assert str(err.value) == (
+-            "The tags, dims and types filters must all be the same length."
+-        )
+-
+-        with pytest.raises(ValueError) as err:
+-            ados.filter(dims=[2, 2, 2])
+-        assert str(err.value) == (
+-            "The maximum depth for the hierarchy is 2 but 3 levels of"
+-            " excitation filters were given."
+-        )
+-
+-        with pytest.raises(ValueError) as err:
+-            ados.filter(level=0, dims=[2])
+-        assert str(err.value) == (
+-            "The level parameter is 0 but 1 levels of excitation filters"
+-            " were given."
+-        )
+-
+-
+-class TestHierarchyADOsState:
+-    def mk_ados(self, bath_dims, max_depth):
+-        exponents = [
+-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
+-        ]
+-        ados = HierarchyADOs(exponents, max_depth=max_depth)
+-        return ados
+-
+-    def mk_rho_and_soln(self, ados, rho_dims):
+-        n_ados = len(ados.labels)
+-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+-        rho = Qobj(ado_soln[0, :], dims=rho_dims)
+-        return rho, ado_soln
+-
+-    def test_create(self):
+-        ados = self.mk_ados([2, 3], max_depth=2)
+-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+-        assert ado_state.rho == rho
+-        assert ado_state.labels == ados.labels
+-        assert ado_state.exponents == ados.exponents
+-        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
+-        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
+-
+-    def test_extract(self):
+-        ados = self.mk_ados([2, 3], max_depth=2)
+-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+-        ado_state.extract((0, 0)) == rho
+-        ado_state.extract(0) == rho
+-        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
+-        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
+-
+-
+-class DrudeLorentzPureDephasingModel:
+-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+-        solver.
+-    """
+-    def __init__(self, lam, gamma, T, Nk):
+-        self.lam = lam
+-        self.gamma = gamma
+-        self.T = T
+-        self.Nk = Nk
+-        # we add a very weak system hamiltonian here to avoid having
+-        # singular system that causes problems for the scipy.sparse.linalg
+-        # superLU solver used in spsolve.
+-        self.H = Qobj(1e-5 * np.ones((2, 2)))
+-        self.Q = sigmaz()
+-
+-    def rho(self):
+-        """ Initial state. """
+-        return 0.5 * Qobj(np.ones((2, 2)))
+-
+-    def state_results(self, states):
+-        projector = basis(2, 0) * basis(2, 1).dag()
+-        return expect(states, projector)
+-
+-    def analytic_results(self, tlist):
+-        lam, gamma, T = self.lam, self.gamma, self.T
+-        lam_c = lam / np.pi
+-
+-        def _integrand(omega, t):
+-            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
+-            return (-4 * J * (1 - np.cos(omega*t))
+-                    / (np.tanh(0.5*omega / T) * omega**2))
+-
+-        # Calculate the analytical results by numerical integration
+-        return [
+-            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+-            for t in tlist
+-        ]
+-
+-    def bath_coefficients(self):
+-        """ Correlation function expansion coefficients for the Drude-Lorentz
+-            bath.
+-        """
+-        lam, gamma, T = self.lam, self.gamma, self.T
+-        Nk = self.Nk
+-        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
+-        ck_real.extend([
+-            (4 * lam * gamma * T * 2 * np.pi * k * T /
+-                ((2 * np.pi * k * T)**2 - gamma**2))
+-            for k in range(1, Nk + 1)
+-        ])
+-        vk_real = [gamma]
+-        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
+-        ck_imag = [lam * gamma * (-1.0)]
+-        vk_imag = [gamma]
+-        return ck_real, vk_real, ck_imag, vk_imag
+-
+-
+-class UnderdampedPureDephasingModel:
+-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+-        solver.
+-    """
+-    def __init__(self, lam,  gamma, w0, T, Nk):
+-        self.lam = lam
+-        self.gamma = gamma
+-        self.w0 = w0
+-        self.T = T
+-        self.Nk = Nk
+-        # we add a very weak system hamiltonian here to avoid having
+-        # singular system that causes problems for the scipy.sparse.linalg
+-        # superLU solver used in spsolve.
+-        self.H = Qobj(1e-5 * np.ones((2, 2)))
+-        self.Q = sigmaz()
+-
+-    def rho(self):
+-        """ Initial state. """
+-        return 0.5 * Qobj(np.ones((2, 2)))
+-
+-    def state_results(self, states):
+-        projector = basis(2, 0) * basis(2, 1).dag()
+-        return expect(states, projector)
+-
+-    def analytic_results(self, tlist):
+-        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
+-        lam_c = lam**2 / np.pi
+-
+-        def _integrand(omega, t):
+-            Jw = (
+-                lam_c * omega * gamma /
+-                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
+-            )
+-            return (-4 * Jw * (1 - np.cos(omega*t))
+-                    / (np.tanh(0.5*omega / T) * omega**2))
+-
+-        return [
+-            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+-            for t in tlist
+-        ]
+-
+-
+-class BosonicMode:
+-    """ A description of a bosonic mode for inclusion in a
+-        DiscreteLevelCurrentModel.
+-    """
+-    def __init__(self, N, Lambda, Omega, gamma_b):
+-        self.N = N
+-        self.Lambda = Lambda
+-        self.Omega = Omega
+-        self.gamma_b = gamma_b
+-
+-    def bath_coefficients(self):
+-        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
+-        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
+-
+-        ck_imag = [
+-            -1.0j * self.Omega + self.gamma_b / 2,
+-            1.0j * self.Omega + self.gamma_b / 2,
+-        ]
+-        vk_imag = [
+-            -1.0j * self.Omega + self.gamma_b / 2,
+-            1.0j * self.Omega + self.gamma_b / 2,
+-        ]
+-        return ck_real, ck_imag, vk_real, vk_imag
+-
+-
+-class DiscreteLevelCurrentModel:
+-    """ Analytic discrete level current model for testing the HEOM solver
+-        with a fermionic bath (and optionally a bosonic mode).
+-    """
+-    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
+-        # single fermion
+-        self.e1 = e1  # energy
+-
+-        # parameters for the fermionic leads
+-        self.gamma = gamma
+-        self.W = W
+-        self.T = T
+-        self.lmax = lmax  # Pade cut-off
+-        self.beta = 1. / T
+-        self.theta = theta  # bias
+-
+-        # bosonic_mode
+-        self.bosonic_mode = bosonic_mode
+-
+-        # Construct Hamiltonian and coupling operator
+-        if self.bosonic_mode is None:
+-            d1 = destroy(2)
+-            self.H = self.e1 * d1.dag() @ d1
+-            self.Q = d1
+-            self._sys_occupation_op = d1.dag() @ d1
+-        else:
+-            d1 = destroy(2) & qeye(self.bosonic_mode.N)
+-            a = qeye(2) & destroy(self.bosonic_mode.N)
+-            self.H = (
+-                self.e1 * d1.dag() @ d1 +
+-                self.bosonic_mode.Omega * a.dag() @ a +
+-                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
+-            )
+-            if self.bosonic_mode.gamma_b != 0:
+-                # apply phenomenological damping:
+-                self.H = liouvillian(
+-                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
+-                )
+-            self.Q = d1
+-            self._sys_occupation_op = d1.dag() @ d1
+-
+-    def rho(self, rho_fermion=None):
+-        """ Return initial system density matrix given the density matrix for
+-            the single Fermionic mode.
+-        """
+-        if rho_fermion is None:
+-            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
+-        elif rho_fermion.isket:
+-            rho_fermion = rho_fermion.proj()
+-        if self.bosonic_mode is None:
+-            rho = rho_fermion
+-        else:
+-            bm0 = basis(self.bosonic_mode.N, 0)
+-            rho = rho_fermion & (bm0 @ bm0.dag())
+-        return rho
+-
+-    def sys_occupation(self, state):
+-        return expect(state, self._sys_occupation_op)
+-
+-    def state_current(self, ado_state, tags=None):
+-        level_1_aux = [
+-            (ado_state.extract(label), ado_state.exps(label)[0])
+-            for label in ado_state.filter(level=1, tags=tags)
+-        ]
+-
+-        def exp_sign(exp):
+-            return 1 if exp.type == exp.types["+"] else -1
+-
+-        def exp_op(exp):
+-            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
+-
+-        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
+-        # and thus the first 2 * k exponents
+-        k = self.lmax + 1
+-        return 1.0j * sum(
+-            exp_sign(exp) * (exp_op(exp) * aux).tr()
+-            for aux, exp in level_1_aux[:2 * k]
+-        )
+-
+-    def analytic_current(self):
+-        if self.bosonic_mode is not None:
+-            raise RuntimeError(
+-                "Analytic calculation of the current is not implemented in the"
+-                " case where a bosonic mode is present."
+-            )
+-
+-        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
+-        mu_l = self.theta / 2.
+-        mu_r = - self.theta / 2.
+-
+-        def f(x):
+-            return 1 / (np.exp(x) + 1.)
+-
+-        def Gamma_w(w, mu):
+-            return Gamma * W**2 / ((w-mu)**2 + W**2)
+-
+-        def lamshift(w, mu):
+-            return (w-mu)*Gamma_w(w, mu)/(2*W)
+-
+-        def integrand(w):
+-            return (
+-                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
+-                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
+-                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
+-                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
+-            )
+-
+-        def real_func(x):
+-            return np.real(integrand(x))
+-
+-        def imag_func(x):
+-            return np.imag(integrand(x))
+-
+-        # These integral bounds should be checked to be wide enough if the
+-        # parameters are changed
+-        a = -2
+-        b = 2
+-        real_integral = quad(real_func, a, b)
+-        imag_integral = quad(imag_func, a, b)
+-
+-        return real_integral[0] + 1.0j * imag_integral[0]
+-
+-    def bath_coefficients(self):
+-        """ Correlation function expansion coefficients for the fermionic bath.
+-        """
+-        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
+-        mu_l = self.theta / 2.
+-        mu_r = - self.theta / 2.
+-
+-        def deltafun(j, k):
+-            return 1. if j == k else 0.
+-
+-        Alpha = np.zeros((2 * lmax, 2 * lmax))
+-        for j in range(2*lmax):
+-            for k in range(2*lmax):
+-                Alpha[j][k] = (
+-                    (deltafun(j, k + 1) + deltafun(j, k - 1))
+-                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
+-                )
+-
+-        eigvalsA = eigvalsh(Alpha)
+-
+-        eps = []
+-        for val in eigvalsA[0:lmax]:
+-            eps.append(-2 / val)
+-
+-        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
+-        for j in range(2 * lmax - 1):
+-            for k in range(2 * lmax - 1):
+-                AlphaP[j][k] = (
+-                    (deltafun(j, k + 1) + deltafun(j, k - 1))
+-                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
+-                )
+-
+-        eigvalsAP = eigvalsh(AlphaP)
+-
+-        chi = []
+-        for val in eigvalsAP[0:lmax - 1]:
+-            chi.append(-2/val)
+-
+-        eta_list = [
+-            0.5 * lmax * (2 * (lmax + 1) - 1) * (
+-                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
+-                np.prod([
+-                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
+-                ])
+-            )
+-            for j in range(lmax)
+-        ]
+-
+-        kappa = [0] + eta_list
+-        epsilon = [0] + eps
+-
+-        def f_approx(x):
+-            f = 0.5
+-            for ll in range(1, lmax + 1):
+-                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
+-            return f
+-
+-        def C(sigma, mu):
+-            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
+-            gamma_0 = W - sigma*1.0j*mu
+-            eta_list = [eta_0]
+-            gamma_list = [gamma_0]
+-            if lmax > 0:
+-                for ll in range(1, lmax + 1):
+-                    eta_list.append(
+-                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
+-                        / (-(epsilon[ll]**2 / beta**2) + W**2)
+-                    )
+-                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
+-            return eta_list, gamma_list
+-
+-        etapL, gampL = C(1.0, mu_l)
+-        etamL, gammL = C(-1.0, mu_l)
+-
+-        etapR, gampR = C(1.0, mu_r)
+-        etamR, gammR = C(-1.0, mu_r)
+-
+-        ck_plus = etapR + etapL
+-        vk_plus = gampR + gampL
+-        ck_minus = etamR + etamL
+-        vk_minus = gammR + gammL
+-
+-        return ck_plus, vk_plus, ck_minus, vk_minus
+-
+-
+-_HAMILTONIAN_EVO_KINDS = {
+-    "qobj": lambda H: H,
+-    "qobjevo_const": lambda H: QobjEvo([H]),
+-    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
+-    "listevo_const": lambda H: [H],
+-}
+-
+-
+-def hamiltonian_to_sys(H, evo, liouvillianize):
+-    if liouvillianize:
+-        H = liouvillian(H)
+-    H = _HAMILTONIAN_EVO_KINDS[evo](H)
+-    return H
+-
+-
+-class TestHEOMSolver:
+-    def test_create_bosonic(self):
+-        Q = sigmaz()
+-        H = sigmax()
+-        exponents = [
+-            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
+-            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
+-            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
+-        ]
+-        bath = Bath(exponents)
+-
+-        hsolver = HEOMSolver(H, bath, 2)
+-        assert hsolver.ados.exponents == exponents
+-        assert hsolver.ados.max_depth == 2
+-
+-        hsolver = HEOMSolver(H, [bath] * 3, 2)
+-        assert hsolver.ados.exponents == exponents * 3
+-        assert hsolver.ados.max_depth == 2
+-
+-    def test_create_fermionic(self):
+-        Q = sigmaz()
+-        H = sigmax()
+-        exponents = [
+-            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
+-            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
+-        ]
+-        bath = Bath(exponents)
+-
+-        hsolver = HEOMSolver(H, bath, 2)
+-        assert hsolver.ados.exponents == exponents
+-        assert hsolver.ados.max_depth == 2
+-
+-        hsolver = HEOMSolver(H, [bath] * 3, 2)
+-        assert hsolver.ados.exponents == exponents * 3
+-        assert hsolver.ados.max_depth == 2
+-
+-    def test_create_mixed_bosonic_and_fermionic(self):
+-        Q = sigmaz()
+-        H = sigmax()
+-        exponents = [
+-            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
+-            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
+-            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
+-        ]
+-        bath = Bath(exponents)
+-
+-        hsolver = HEOMSolver(H, bath, 2)
+-        assert hsolver.ados.exponents == exponents
+-        assert hsolver.ados.max_depth == 2
+-
+-        hsolver = HEOMSolver(H, [bath] * 3, 2)
+-        assert hsolver.ados.exponents == exponents * 3
+-        assert hsolver.ados.max_depth == 2
+-
+-    def test_create_bath_errors(self):
+-        Q = sigmaz()
+-        H = sigmax()
+-        mixed_q_dims = [
+-            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
+-            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
+-        ]
+-
+-        with pytest.raises(ValueError) as err:
+-            HEOMSolver(H, Bath(mixed_q_dims), 2)
+-        assert str(err.value) == (
+-            "All bath exponents must have system coupling operators with the"
+-            " same dimensions but a mixture of dimensions was given."
+-        )
+-
+-    def test_create_h_sys_errors(self):
+-        H = object()
+-        with pytest.raises(TypeError) as err:
+-            HEOMSolver(H, Bath([]), 2)
+-        assert str(err.value) == (
+-            "The Hamiltonian (H) must be a Qobj or QobjEvo"
+-        )
+-
+-        H = [sigmax()]
+-        with pytest.raises(TypeError) as err:
+-            HEOMSolver([H], Bath([]), 2)
+-        assert str(err.value) == (
+-            "The Hamiltonian (H) must be a Qobj or QobjEvo"
+-        )
+-
+-    @pytest.mark.parametrize(['method'], [
+-        pytest.param("run", id="run"),
+-        pytest.param("start", id="start"),
+-    ])
+-    def test_invalid_rho0_errors(self, method):
+-        Q = sigmaz()
+-        H = sigmax()
+-        exponents = [
+-            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
+-            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
+-            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
+-        ]
+-        bath = Bath(exponents)
+-        hsolver = HEOMSolver(H, bath, 2)
+-
+-        if method == "run":
+-            def solve_method(rho0):
+-                return hsolver.run(rho0, [0, 1])
+-        elif method == "start":
+-            def solve_method(rho0):
+-                return hsolver.start(rho0, 0)
+-        else:
+-            assert False, f"method {method} not supported by test"
+-
+-        with pytest.raises(ValueError) as err:
+-            solve_method(basis(3, 0))
+-        assert str(err.value) == (
+-            "Initial state rho has dims [[3], [1]]"
+-            " but the system dims are [[2], [2]]"
+-        )
+-
+-        with pytest.raises(TypeError) as err:
+-            solve_method("batman")
+-        assert str(err.value) == (
+-            "Initial ADOs passed have type <class 'str'> but a "
+-            "HierarchyADOsState or a numpy array-like instance was expected"
+-        )
+-
+-        with pytest.raises(ValueError) as err:
+-            solve_method(np.array([1, 2, 3]))
+-        assert str(err.value) == (
+-            "Initial ADOs passed have shape (3,) but the solver hierarchy"
+-            " shape is (10, 2, 2)"
+-        )
+-
+-    @pytest.mark.parametrize(['evo'], [
+-        pytest.param("qobj", id="qobj"),
+-        pytest.param("qobjevo_const", id="qobjevo_const"),
+-        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
+-    ])
+-    @pytest.mark.parametrize(['liouvillianize'], [
+-        pytest.param(False, id="hamiltonian"),
+-        pytest.param(True, id="liouvillian"),
+-    ])
+-    def test_pure_dephasing_model_bosonic_bath(
+-        self, evo, liouvillianize, atol=1e-3
+-    ):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+-
+-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+-        options = {"nsteps": 15000, "store_states": True}
+-        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
+-
+-        tlist = np.linspace(0, 10, 21)
+-        result = hsolver.run(dlm.rho(), tlist)
+-
+-        test = dlm.state_results(result.states)
+-        expected = dlm.analytic_results(tlist)
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-
+-        if evo != "qobjevo_timedep":
+-            rho_final, ado_state = hsolver.steady_state()
+-            test = dlm.state_results([rho_final])
+-            expected = dlm.analytic_results([100])
+-            np.testing.assert_allclose(test, expected, atol=atol)
+-            assert rho_final == ado_state.extract(0)
+-        else:
+-            assert_raises_steady_state_time_dependent(hsolver)
+-
+-    @pytest.mark.parametrize(['terminator'], [
+-        pytest.param(True, id="terminator"),
+-        pytest.param(False, id="noterminator"),
+-    ])
+-    @pytest.mark.parametrize(['bath_cls'], [
+-        pytest.param(DrudeLorentzBath, id="matsubara"),
+-        pytest.param(DrudeLorentzPadeBath, id="pade"),
+-    ])
+-    def test_pure_dephasing_model_drude_lorentz_baths(
+-        self, terminator, bath_cls, atol=1e-3
+-    ):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        bath = bath_cls(
+-            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
+-        )
+-        if terminator:
+-            _, terminator_op = bath.terminator()
+-            H_sys = liouvillian(dlm.H) + terminator_op
+-        else:
+-            H_sys = dlm.H
+-
+-        options = {"nsteps": 15000, "store_states": True}
+-        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
+-
+-        tlist = np.linspace(0, 10, 21)
+-        result = hsolver.run(dlm.rho(), tlist)
+-
+-        test = dlm.state_results(result.states)
+-        expected = dlm.analytic_results(tlist)
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-
+-        rho_final, ado_state = hsolver.steady_state()
+-        test = dlm.state_results([rho_final])
+-        expected = dlm.analytic_results([100])
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-        assert rho_final == ado_state.extract(0)
+-
+-    def test_underdamped_pure_dephasing_model_underdamped_bath(
+-        self, atol=1e-3
+-    ):
+-        udm = UnderdampedPureDephasingModel(
+-            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
+-        )
+-        bath = UnderDampedBath(
+-            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
+-            w0=udm.w0,
+-        )
+-
+-        options = {"nsteps": 15000, "store_states": True}
+-        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
+-
+-        tlist = np.linspace(0, 10, 21)
+-        result = hsolver.run(udm.rho(), tlist)
+-
+-        test = udm.state_results(result.states)
+-        expected = udm.analytic_results(tlist)
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-
+-        rho_final, ado_state = hsolver.steady_state()
+-        test = udm.state_results([rho_final])
+-        expected = udm.analytic_results([5000])
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-        assert rho_final == ado_state.extract(0)
+-
+-    @pytest.mark.parametrize(['evo'], [
+-        pytest.param("qobj"),
+-        pytest.param("qobjevo_const"),
+-        pytest.param("qobjevo_timedep"),
+-    ])
+-    @pytest.mark.parametrize(['liouvillianize'], [
+-        pytest.param(False, id="hamiltonian"),
+-        pytest.param(True, id="liouvillian"),
+-    ])
+-    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
+-        dlm = DiscreteLevelCurrentModel(
+-            gamma=0.01, W=1, T=0.025851991, lmax=10,
+-        )
+-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+-        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+-
+-        options = {
+-            "store_states": True,
+-            "store_ados": True,
+-            "nsteps": 15_000,
+-            "rtol": 1e-7,
+-            "atol": 1e-7,
+-        }
+-        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
+-        # for a single impurity we converge with max_depth = 2
+-        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
+-
+-        tlist = [0, 600]
+-        result = hsolver.run(dlm.rho(), tlist)
+-        current = dlm.state_current(result.ado_states[-1])
+-        analytic_current = dlm.analytic_current()
+-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+-
+-        if evo != "qobjevo_timedep":
+-            rho_final, ado_state = hsolver.steady_state()
+-            current = dlm.state_current(ado_state)
+-            analytic_current = dlm.analytic_current()
+-            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+-        else:
+-            assert_raises_steady_state_time_dependent(hsolver)
+-
+-    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
+-        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
+-        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
+-    ])
+-    def test_discrete_level_model_lorentzian_baths(
+-        self, bath_cls, analytic_current, atol=1e-3
+-    ):
+-        dlm = DiscreteLevelCurrentModel(
+-            gamma=0.01, W=1, T=0.025851991, lmax=10,
+-        )
+-
+-        options = {
+-            "nsteps": 15_000, "store_states": True, "store_ados": True,
+-            "rtol": 1e-7, "atol": 1e-7,
+-        }
+-        bath_l = bath_cls(
+-            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
+-            Nk=dlm.lmax,
+-        )
+-        bath_r = bath_cls(
+-            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
+-            Nk=dlm.lmax,
+-        )
+-        # for a single impurity we converge with max_depth = 2
+-        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
+-
+-        tlist = [0, 600]
+-        result = hsolver.run(dlm.rho(), tlist)
+-        current = dlm.state_current(result.ado_states[-1])
+-        # analytic_current = dlm.analytic_current()
+-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+-
+-        rho_final, ado_state = hsolver.steady_state()
+-        current = dlm.state_current(ado_state)
+-        # analytic_current = dlm.analytic_current()
+-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+-
+-    @pytest.mark.parametrize(['evo'], [
+-        pytest.param("qobj"),
+-        pytest.param("qobjevo_const"),
+-        pytest.param("qobjevo_timedep"),
+-    ])
+-    @pytest.mark.parametrize(['liouvillianize'], [
+-        pytest.param(False, id="hamiltonian"),
+-        pytest.param(True, id="liouvillian"),
+-    ])
+-    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
+-        self, evo, liouvillianize
+-    ):
+-        dlm = DiscreteLevelCurrentModel(
+-            gamma=0.01, W=1, T=0.025851991, lmax=10,
+-        )
+-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+-        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+-
+-        options = {
+-            "store_states": True,
+-            "store_ados": True,
+-            "nsteps": 15_000,
+-            "rtol": 1e-7,
+-            "atol": 1e-7,
+-        }
+-        fermionic_bath = FermionicBath(
+-            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
+-        )
+-        # very weak bosonic coupling which should not affect the dynamics of
+-        # the interaction between the system and the fermionic bath:
+-        eps = [1e-10] * 5
+-        bosonic_Q = sigmax()
+-        bosonic_bath = BosonicBath(
+-            bosonic_Q, eps, eps, eps, eps, combine=False,
+-        )
+-        # for a single impurity we converge with max_depth = 2
+-        # we specify the bosonic bath first to ensure that the test checks
+-        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
+-        # mode is before the fermionic ones
+-        hsolver = HEOMSolver(
+-            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
+-        )
+-
+-        tlist = [0, 600]
+-        result = hsolver.run(dlm.rho(), tlist)
+-        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
+-        analytic_current = dlm.analytic_current()
+-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+-
+-        if evo != "qobjevo_timedep":
+-            rho_final, ado_state = hsolver.steady_state()
+-            current = dlm.state_current(ado_state)
+-            analytic_current = dlm.analytic_current()
+-            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+-        else:
+-            assert_raises_steady_state_time_dependent(hsolver)
+-
+-    @pytest.mark.parametrize(['evo'], [
+-        pytest.param("qobj"),
+-        pytest.param("qobjevo_const"),
+-        pytest.param("qobjevo_timedep"),
+-    ])
+-    @pytest.mark.parametrize(['liouvillianize'], [
+-        pytest.param(False, id="hamiltonian"),
+-        pytest.param(True, id="liouvillian"),
+-    ])
+-    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
+-        self, evo, liouvillianize
+-    ):
+-        dlm = DiscreteLevelCurrentModel(
+-            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+-        )
+-        bosonic_mode = BosonicMode(
+-            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
+-        )
+-
+-        dlm_ref = DiscreteLevelCurrentModel(
+-            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+-            bosonic_mode=bosonic_mode,
+-        )
+-
+-        options = {
+-            "store_states": True,
+-            "store_ados": True,
+-            "nsteps": 15_000,
+-            "rtol": 1e-7,
+-            "atol": 1e-7,
+-        }
+-
+-        # First we construct a solver with the boson modelled as part of the
+-        # system and only a single Fermionic bath. This will provide the
+-        # reference result for the test:
+-        fermionic_bath_ref = FermionicBath(
+-            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
+-        )
+-
+-        hsolver_ref = HEOMSolver(
+-            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
+-        )
+-
+-        # Then we construct a solver for the same system, but with the
+-        # bosonic mode as a bath This is the result we would like to check:
+-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+-
+-        fermionic_bath = FermionicBath(
+-            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
+-        )
+-
+-        bosonic_bath = BosonicBath(
+-            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
+-            combine=True, tag="bosonic",
+-        )
+-
+-        hsolver = HEOMSolver(
+-            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
+-        )
+-
+-        # Calculate currents and occupations:
+-        tlist = np.linspace(0, 1000, 300)
+-        psi0 = basis(2, 0)
+-
+-        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
+-        current_ref = [
+-            dlm_ref.state_current(ado_state, tags=["fermionic"])
+-            for ado_state in result_ref.ado_states
+-        ]
+-        sys_occupation_ref = dlm_ref.sys_occupation(
+-            result_ref.states
+-        )
+-
+-        result = hsolver.run(dlm.rho(psi0), tlist)
+-        current = [
+-            dlm.state_current(ado_state, tags=["fermionic"])
+-            for ado_state in result.ado_states
+-        ]
+-        sys_occupation = dlm.sys_occupation(result.states)
+-
+-        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
+-        np.testing.assert_allclose(
+-            sys_occupation_ref, sys_occupation, rtol=1e-3,
+-        )
+-
+-        if evo != "qobjevo_timedep":
+-            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
+-            current_ss_ref = dlm_ref.state_current(ado_state_ref)
+-            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
+-
+-            rho_final, ado_state = hsolver.steady_state()
+-            current_ss = dlm.state_current(ado_state)
+-            sys_occupation_ss = dlm.sys_occupation(rho_final)
+-
+-            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
+-            np.testing.assert_allclose(
+-                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
+-            )
+-        else:
+-            assert_raises_steady_state_time_dependent(hsolver)
+-
+-    @pytest.mark.parametrize(['ado_format'], [
+-        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
+-        pytest.param("numpy", id="numpy"),
+-    ])
+-    def test_ado_input_and_return(self, ado_format):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+-
+-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+-        options = {
+-            "nsteps": 15_000, "store_states": True, "store_ados": True,
+-        }
+-        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
+-
+-        tlist_1 = [0, 1, 2]
+-        result_1 = hsolver.run(dlm.rho(), tlist_1)
+-
+-        tlist_2 = [2, 3, 4]
+-        rho0 = result_1.ado_states[-1]
+-        if ado_format == "numpy":
+-            rho0 = rho0._ado_state  # extract the raw numpy array
+-        result_2 = hsolver.run(rho0, tlist_2)
+-
+-        tlist_full = tlist_1 + tlist_2[1:]
+-        result_full = hsolver.run(dlm.rho(), tlist_full)
+-
+-        times_12 = result_1.times + result_2.times[1:]
+-        times_full = result_full.times
+-        assert times_12 == tlist_full
+-        assert times_full == tlist_full
+-
+-        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
+-        ado_states_full = result_full.ado_states
+-        assert len(ado_states_12) == len(tlist_full)
+-        assert len(ado_states_full) == len(tlist_full)
+-        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
+-            for label in hsolver.ados.labels:
+-                np.testing.assert_allclose(
+-                    ado_12.extract(label).full(),
+-                    ado_full.extract(label).full(),
+-                    atol=1e-6,
+-                )
+-
+-        states_12 = result_1.states + result_2.states[1:]
+-        states_full = result_full.states
+-        assert len(states_12) == len(tlist_full)
+-        assert len(states_full) == len(tlist_full)
+-        for ado_12, state_12 in zip(ado_states_12, states_12):
+-            assert ado_12.rho == state_12
+-        for ado_full, state_full in zip(ado_states_full, states_full):
+-            assert ado_full.rho == state_full
+-
+-        expected = dlm.analytic_results(tlist_full)
+-        test_12 = dlm.state_results(states_12)
+-        np.testing.assert_allclose(test_12, expected, atol=1e-3)
+-        test_full = dlm.state_results(states_full)
+-        np.testing.assert_allclose(test_full, expected, atol=1e-3)
+-
+-    def test_solving_with_step(self):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+-
+-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+-        options = {"nsteps": 15_000, "store_ados": True}
+-        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
+-
+-        tlist = np.linspace(0, 10, 21)
+-        ado_state = None
+-        states = [dlm.rho()]
+-        hsolver.start(states[0], 0)
+-        for t in tlist[1:]:
+-            ado_state = hsolver.step(t)
+-            states.append(ado_state.rho)
+-
+-        test = dlm.state_results(states)
+-        expected = dlm.analytic_results(tlist)
+-        np.testing.assert_allclose(test, expected, atol=1e-3)
+-
+-        assert states[-1] == ado_state.extract(0)
+-
+-
+-class TestHeomsolveFunction:
+-    @pytest.mark.parametrize(['evo'], [
+-        pytest.param("qobj", id="qobj"),
+-        pytest.param("listevo_const", id="listevo_const"),
+-        pytest.param("qobjevo_const", id="qobjevo_const"),
+-        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
+-    ])
+-    @pytest.mark.parametrize(['liouvillianize'], [
+-        pytest.param(False, id="hamiltonian"),
+-        pytest.param(True, id="liouvillian"),
+-    ])
+-    def test_heomsolve_with_pure_dephasing_model(
+-        self, evo, liouvillianize, atol=1e-3
+-    ):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+-
+-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+-        options = {"nsteps": 15000, "store_states": True}
+-
+-        e_ops = {
+-            "11": basis(2, 0) * basis(2, 0).dag(),
+-            "22": basis(2, 1) * basis(2, 1).dag(),
+-        }
+-
+-        tlist = np.linspace(0, 10, 21)
+-        result = heomsolve(
+-            H_sys, bath, 14, dlm.rho(), tlist,
+-            e_ops=e_ops, args={"foo": 1}, options=options)
+-
+-        test = dlm.state_results(result.states)
+-        expected = dlm.analytic_results(tlist)
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-
+-        for label in ["11", "22"]:
+-            np.testing.assert_allclose(
+-                result.e_data[label],
+-                [expect(rho, e_ops[label]) for rho in result.states],
+-                atol=atol,
+-            )
+-
+-
+-class TestHSolverDL:
+-    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
+-        pytest.param(True, 1e-4, id="bnd_cut_approx"),
+-        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
+-    ])
+-    @pytest.mark.parametrize(['evo', 'combine'], [
+-        pytest.param("qobj", True, id="qobj-combined"),
+-        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
+-        pytest.param("listevo_const", True, id="listevo-const-combined"),
+-        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
+-        pytest.param(
+-            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
+-        ),
+-    ])
+-    @pytest.mark.parametrize(['liouvillianize'], [
+-        pytest.param(False, id="hamiltonian"),
+-        pytest.param(True, id="liouvillian"),
+-    ])
+-    def test_pure_dephasing_model(
+-        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
+-    ):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+-
+-        options = {"nsteps": 15_000, "store_states": True}
+-        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
+-                            14, 2, dlm.gamma,
+-                            bnd_cut_approx=bnd_cut_approx,
+-                            options=options, combine=combine)
+-
+-        tlist = np.linspace(0, 10, 21)
+-        result = hsolver.run(dlm.rho(), tlist)
+-
+-        test = dlm.state_results(result.states)
+-        expected = dlm.analytic_results(tlist)
+-        np.testing.assert_allclose(test, expected, atol=atol)
+-
+-        if evo != "qobjevo_timedep":
+-            rho_final, ado_state = hsolver.steady_state()
+-            test = dlm.state_results([rho_final])
+-            expected = dlm.analytic_results([100])
+-            np.testing.assert_allclose(test, expected, atol=atol)
+-            assert rho_final == ado_state.extract(0)
+-        else:
+-            assert_raises_steady_state_time_dependent(hsolver)
+-
+-    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
+-        pytest.param(True, 1e-4, id="bnd_cut_approx"),
+-        pytest.param(False, 1e-3, id="renorm"),
+-    ])
+-    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
+-        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
+-        # is repeated here to ensure the new HSolverDL remains compatibile
+-        # with the old one until it is removed.
+-        cut_frequency = 0.05
+-        coupling_strength = 0.025
+-        lam_c = coupling_strength / np.pi
+-        temperature = 1 / 0.95
+-        times = np.linspace(0, 10, 21)
+-
+-        def _integrand(omega, t):
+-            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
+-            return (-4 * J * (1 - np.cos(omega*t))
+-                    / (np.tanh(0.5*omega / temperature) * omega**2))
+-
+-        # Calculate the analytical results by numerical integration
+-        expected = [
+-            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+-            for t in times
+-        ]
+-
+-        H_sys = Qobj(np.zeros((2, 2)))
+-        Q = sigmaz()
+-        initial_state = 0.5*Qobj(np.ones((2, 2)))
+-        projector = basis(2, 0) * basis(2, 1).dag()
+-        options = {"nsteps": 15_000, "store_states": True}
+-        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
+-                            20, 2, cut_frequency,
+-                            bnd_cut_approx=bnd_cut_approx,
+-                            options=options)
+-        test = expect(hsolver.run(initial_state, times).states, projector)
+-        np.testing.assert_allclose(test, expected, atol=tol)
+-
+-    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
+-    def test_integration_error(self):
+-        dlm = DrudeLorentzPureDephasingModel(
+-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+-        )
+-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+-
+-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+-        options = {"nsteps": 10}
+-        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
+-
+-        with pytest.raises(IntegratorException) as err:
+-            hsolver.run(dlm.rho(), tlist=[0, 10])
+-
+-        assert str(err.value) == (
+-            "Excess work done on this call. Try to increasing the nsteps"
+-            " parameter in the Options class"
+-        )
+-
+-
+-class TestHEOMResult:
+-    def mk_ados(self, bath_dims, max_depth):
+-        exponents = [
+-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
+-        ]
+-        ados = HierarchyADOs(exponents, max_depth=max_depth)
+-        return ados
+-
+-    def mk_rho_and_soln(self, ados, rho_dims):
+-        n_ados = len(ados.labels)
+-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+-        rho = Qobj(ado_soln[0, :], dims=rho_dims)
+-        return rho, ado_soln
+-
+-    def test_create_ado_states_attribute(self):
+-        options = fill_options()
+-        result = HEOMResult(e_ops=[], options=options)
+-        assert not hasattr(result, "final_ado_state")
+-        assert not hasattr(result, "ado_states")
+-        assert result.store_ados is False
+-
+-        options = fill_options(store_ados=True)
+-        result = HEOMResult(e_ops=[], options=options)
+-        assert result.final_ado_state is None
+-        assert result.ado_states == []
+-        assert result.store_ados is True
+-
+-    @pytest.mark.parametrize(['e_op_type'], [
+-        pytest.param("qobj", id="qobj"),
+-        pytest.param("qobjevo", id="qobjevo"),
+-        pytest.param("callable", id="callable"),
+-    ])
+-    def test_e_ops(self, e_op_type):
+-        op = Qobj([[1, 0], [0, 0]])
+-        if e_op_type == "qobj":
+-            e_op = op
+-        elif e_op_type == "qobjevo":
+-            e_op = QobjEvo(op)
+-        elif e_op_type == "callable":
+-            def e_op(f, ado_state):
+-                return expect(op, ado_state.rho)
+-        else:
+-            assert False, f"unknown e_op_type {e_op_type!r}"
+-
+-        options = fill_options()
+-        result = HEOMResult(e_ops=e_op, options=options)
+-
+-        ados = self.mk_ados([2, 3], max_depth=2)
+-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+-        e_op_value = expect(op, rho)
+-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+-
+-        result.add(0.1, ado_state)
+-
+-        assert result.expect[0] == [e_op_value]
+-        assert result.e_data[0] == [e_op_value]
+-
+-    def test_store_state(self):
+-        options = fill_options()
+-        result = HEOMResult(e_ops=[], options=options)
+-
+-        ados = self.mk_ados([2, 3], max_depth=2)
+-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+-
+-        result.add(0.1, ado_state)
+-
+-        assert result.times == [0.1]
+-        assert result.states == [rho]
+-        assert result.final_state is rho
+-
+-    def test_store_ados(self):
+-        options = fill_options(store_ados=True)
+-        result = HEOMResult(e_ops=[], options=options)
+-
+-        ados = self.mk_ados([2, 3], max_depth=2)
+-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+-
+-        result.add(0.1, ado_state)
+-        assert result.times == [0.1]
+-        assert result.states == [rho]
+-        assert result.final_state is rho
+-        assert result.ado_states == [ado_state]
+-        assert result.final_ado_state is ado_state
+-
+-
+-class Test_GatherHEOMRHS:
+-    def test_simple_gather(self):
+-        def f(label):
+-            return int(label.lstrip("o"))
+-
+-        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
+-
+-        for i in range(3):
+-            for j in range(3):
+-                base = 10 * (j * 2) + (i * 2)
+-                block_op = _data.to(
+-                    _data.CSR,
+-                    _data.create(np.array([
+-                        [base, base + 10],
+-                        [base + 1, base + 11],
+-                    ]))
+-                )
+-                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
+-
+-        op = gather_heoms.gather()
+-
+-        expected_op = np.array([
+-            [10 * i + j for i in range(2 * 3)]
+-            for j in range(2 * 3)
+-        ], dtype=np.complex128)
+-
+-        np.testing.assert_array_equal(op.to_array(), expected_op)
+-        assert isinstance(op, _data.CSR)
++"""
++Tests for qutip.nonmarkov.bofin_solvers.
++"""
++
++import numpy as np
++import pytest
++from numpy.linalg import eigvalsh
++from scipy.integrate import quad
++
++from qutip import (
++    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
++    tensor, Qobj, QobjEvo
++)
++from qutip.core import data as _data
++from qutip.solver.heom.bofin_baths import (
++    BathExponent,
++    Bath,
++    BosonicBath,
++    DrudeLorentzBath,
++    DrudeLorentzPadeBath,
++    UnderDampedBath,
++    FermionicBath,
++    LorentzianBath,
++    LorentzianPadeBath,
++)
++from qutip.solver.heom.bofin_solvers import (
++    heomsolve,
++    HierarchyADOs,
++    HierarchyADOsState,
++    HEOMResult,
++    HEOMSolver,
++    HSolverDL,
++    _GatherHEOMRHS,
++)
++from qutip.solver import (
++    IntegratorException,
++)
++
++
++def fill_options(**kwargs):
++    """Fill the options with minimal entries needed by HEOMResult."""
++    return {
++        "store_final_state": False,
++        "store_states": None,
++        "store_ados": False,
++        **kwargs
++    }
++
++
++def assert_raises_steady_state_time_dependent(hsolver):
++    """ Assert that calling .steady_state() on a HEOMSolver with
++        a time-dependent Hamiltonian raises the appropriate exception.
++    """
++    with pytest.raises(ValueError) as err:
++        hsolver.steady_state()
++    assert str(err.value) == (
++       "A steady state cannot be determined for a time-dependent"
++       " system"
++    )
++
++
++class TestHierarchyADOs:
++    def mk_exponents(self, dims):
++        return [
++            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
++        ]
++
++    def test_create(self):
++        exponents = self.mk_exponents([2, 3])
++        ados = HierarchyADOs(exponents, max_depth=2)
++
++        assert ados.exponents == exponents
++        assert ados.max_depth == 2
++
++        assert ados.dims == [2, 3]
++        assert ados.vk == [2.0, 2.0]
++        assert ados.ck == [1.0, 1.0]
++        assert ados.ck2 == [None, None]
++        assert ados.sigma_bar_k_offset == [None, None]
++
++        assert ados.labels == [
++            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
++        ]
++
++    def test_state_idx(self):
++        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
++        assert ados.idx((0, 0)) == 0
++        assert ados.idx((0, 1)) == 1
++        assert ados.idx((0, 2)) == 2
++        assert ados.idx((1, 0)) == 3
++        assert ados.idx((1, 1)) == 4
++
++    def test_next(self):
++        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
++        assert ados.next((0, 0), 0) == (1, 0)
++        assert ados.next((0, 0), 1) == (0, 1)
++        assert ados.next((1, 0), 0) is None
++        assert ados.next((1, 0), 1) == (1, 1)
++        assert ados.next((1, 1), 1) is None
++
++    def test_prev(self):
++        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
++        assert ados.prev((0, 0), 0) is None
++        assert ados.prev((0, 0), 1) is None
++        assert ados.prev((1, 0), 0) == (0, 0)
++        assert ados.prev((0, 1), 1) == (0, 0)
++        assert ados.prev((1, 1), 1) == (1, 0)
++        assert ados.prev((0, 2), 1) == (0, 1)
++
++    def test_exps(self):
++        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
++        assert ados.exps((0, 0, 0)) == ()
++        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
++        assert ados.exps((2, 0, 0)) == (
++            ados.exponents[0], ados.exponents[0],
++        )
++        assert ados.exps((1, 2, 1)) == (
++            ados.exponents[0],
++            ados.exponents[1], ados.exponents[1],
++            ados.exponents[2],
++        )
++
++    def test_filter_by_nothing(self):
++        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
++        assert ados.filter() == [
++            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
++        ]
++
++    def test_filter_by_level(self):
++        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
++        assert ados.filter(level=0) == [
++            (0, 0),
++        ]
++        assert ados.filter(level=1) == [
++            (0, 1),
++            (1, 0),
++        ]
++        assert ados.filter(level=2) == [
++            (0, 2),
++            (1, 1),
++        ]
++        assert ados.filter(level=3) == []
++
++    def test_filter_by_exponents(self):
++        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
++        assert ados.filter(dims=[]) == [
++            (0, 0),
++        ]
++        assert ados.filter(dims=[2]) == [
++            (1, 0),
++        ]
++        assert ados.filter(level=1, dims=[2]) == [
++            (1, 0),
++        ]
++        assert ados.filter(dims=[3]) == [
++            (0, 1),
++        ]
++        assert ados.filter(dims=[2, 3]) == [
++            (1, 1),
++        ]
++        assert ados.filter(level=2, dims=[2, 3]) == [
++            (1, 1),
++        ]
++        assert ados.filter(dims=[3, 3]) == [
++            (0, 2),
++        ]
++        assert ados.filter(types=["I"]) == [
++            (0, 1),
++            (1, 0),
++        ]
++        assert ados.filter(types=["I", "I"]) == [
++            (0, 2),
++            (1, 1),
++        ]
++
++        with pytest.raises(ValueError) as err:
++            ados.filter(types=[], dims=[2])
++        assert str(err.value) == (
++            "The tags, dims and types filters must all be the same length."
++        )
++
++        with pytest.raises(ValueError) as err:
++            ados.filter(dims=[2, 2, 2])
++        assert str(err.value) == (
++            "The maximum depth for the hierarchy is 2 but 3 levels of"
++            " excitation filters were given."
++        )
++
++        with pytest.raises(ValueError) as err:
++            ados.filter(level=0, dims=[2])
++        assert str(err.value) == (
++            "The level parameter is 0 but 1 levels of excitation filters"
++            " were given."
++        )
++
++
++class TestHierarchyADOsState:
++    def mk_ados(self, bath_dims, max_depth):
++        exponents = [
++            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
++        ]
++        ados = HierarchyADOs(exponents, max_depth=max_depth)
++        return ados
++
++    def mk_rho_and_soln(self, ados, rho_dims):
++        n_ados = len(ados.labels)
++        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
++        rho = Qobj(ado_soln[0, :], dims=rho_dims)
++        return rho, ado_soln
++
++    def test_create(self):
++        ados = self.mk_ados([2, 3], max_depth=2)
++        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
++        ado_state = HierarchyADOsState(rho, ados, ado_soln)
++        assert ado_state.rho == rho
++        assert ado_state.labels == ados.labels
++        assert ado_state.exponents == ados.exponents
++        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
++        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
++
++    def test_extract(self):
++        ados = self.mk_ados([2, 3], max_depth=2)
++        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
++        ado_state = HierarchyADOsState(rho, ados, ado_soln)
++        ado_state.extract((0, 0)) == rho
++        ado_state.extract(0) == rho
++        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
++        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
++
++
++class DrudeLorentzPureDephasingModel:
++    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
++        solver.
++    """
++    def __init__(self, lam, gamma, T, Nk):
++        self.lam = lam
++        self.gamma = gamma
++        self.T = T
++        self.Nk = Nk
++        # we add a very weak system hamiltonian here to avoid having
++        # singular system that causes problems for the scipy.sparse.linalg
++        # superLU solver used in spsolve.
++        self.H = Qobj(1e-5 * np.ones((2, 2)))
++        self.Q = sigmaz()
++
++    def rho(self):
++        """ Initial state. """
++        return 0.5 * Qobj(np.ones((2, 2)))
++
++    def state_results(self, states):
++        projector = basis(2, 0) * basis(2, 1).dag()
++        return expect(states, projector)
++
++    def analytic_results(self, tlist):
++        lam, gamma, T = self.lam, self.gamma, self.T
++        lam_c = lam / np.pi
++
++        def _integrand(omega, t):
++            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
++            return (-4 * J * (1 - np.cos(omega*t))
++                    / (np.tanh(0.5*omega / T) * omega**2))
++
++        # Calculate the analytical results by numerical integration
++        return [
++            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
++            for t in tlist
++        ]
++
++    def bath_coefficients(self):
++        """ Correlation function expansion coefficients for the Drude-Lorentz
++            bath.
++        """
++        lam, gamma, T = self.lam, self.gamma, self.T
++        Nk = self.Nk
++        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
++        ck_real.extend([
++            (4 * lam * gamma * T * 2 * np.pi * k * T /
++                ((2 * np.pi * k * T)**2 - gamma**2))
++            for k in range(1, Nk + 1)
++        ])
++        vk_real = [gamma]
++        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
++        ck_imag = [lam * gamma * (-1.0)]
++        vk_imag = [gamma]
++        return ck_real, vk_real, ck_imag, vk_imag
++
++
++class UnderdampedPureDephasingModel:
++    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
++        solver.
++    """
++    def __init__(self, lam,  gamma, w0, T, Nk):
++        self.lam = lam
++        self.gamma = gamma
++        self.w0 = w0
++        self.T = T
++        self.Nk = Nk
++        # we add a very weak system hamiltonian here to avoid having
++        # singular system that causes problems for the scipy.sparse.linalg
++        # superLU solver used in spsolve.
++        self.H = Qobj(1e-5 * np.ones((2, 2)))
++        self.Q = sigmaz()
++
++    def rho(self):
++        """ Initial state. """
++        return 0.5 * Qobj(np.ones((2, 2)))
++
++    def state_results(self, states):
++        projector = basis(2, 0) * basis(2, 1).dag()
++        return expect(states, projector)
++
++    def analytic_results(self, tlist):
++        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
++        lam_c = lam**2 / np.pi
++
++        def _integrand(omega, t):
++            Jw = (
++                lam_c * omega * gamma /
++                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
++            )
++            return (-4 * Jw * (1 - np.cos(omega*t))
++                    / (np.tanh(0.5*omega / T) * omega**2))
++
++        return [
++            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
++            for t in tlist
++        ]
++
++
++class BosonicMode:
++    """ A description of a bosonic mode for inclusion in a
++        DiscreteLevelCurrentModel.
++    """
++    def __init__(self, N, Lambda, Omega, gamma_b):
++        self.N = N
++        self.Lambda = Lambda
++        self.Omega = Omega
++        self.gamma_b = gamma_b
++
++    def bath_coefficients(self):
++        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
++        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
++
++        ck_imag = [
++            -1.0j * self.Omega + self.gamma_b / 2,
++            1.0j * self.Omega + self.gamma_b / 2,
++        ]
++        vk_imag = [
++            -1.0j * self.Omega + self.gamma_b / 2,
++            1.0j * self.Omega + self.gamma_b / 2,
++        ]
++        return ck_real, ck_imag, vk_real, vk_imag
++
++
++class DiscreteLevelCurrentModel:
++    """ Analytic discrete level current model for testing the HEOM solver
++        with a fermionic bath (and optionally a bosonic mode).
++    """
++    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
++        # single fermion
++        self.e1 = e1  # energy
++
++        # parameters for the fermionic leads
++        self.gamma = gamma
++        self.W = W
++        self.T = T
++        self.lmax = lmax  # Pade cut-off
++        self.beta = 1. / T
++        self.theta = theta  # bias
++
++        # bosonic_mode
++        self.bosonic_mode = bosonic_mode
++
++        # Construct Hamiltonian and coupling operator
++        if self.bosonic_mode is None:
++            d1 = destroy(2)
++            self.H = self.e1 * d1.dag() @ d1
++            self.Q = d1
++            self._sys_occupation_op = d1.dag() @ d1
++        else:
++            d1 = destroy(2) & qeye(self.bosonic_mode.N)
++            a = qeye(2) & destroy(self.bosonic_mode.N)
++            self.H = (
++                self.e1 * d1.dag() @ d1 +
++                self.bosonic_mode.Omega * a.dag() @ a +
++                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
++            )
++            if self.bosonic_mode.gamma_b != 0:
++                # apply phenomenological damping:
++                self.H = liouvillian(
++                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
++                )
++            self.Q = d1
++            self._sys_occupation_op = d1.dag() @ d1
++
++    def rho(self, rho_fermion=None):
++        """ Return initial system density matrix given the density matrix for
++            the single Fermionic mode.
++        """
++        if rho_fermion is None:
++            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
++        elif rho_fermion.isket:
++            rho_fermion = rho_fermion.proj()
++        if self.bosonic_mode is None:
++            rho = rho_fermion
++        else:
++            bm0 = basis(self.bosonic_mode.N, 0)
++            rho = rho_fermion & (bm0 @ bm0.dag())
++        return rho
++
++    def sys_occupation(self, state):
++        return expect(state, self._sys_occupation_op)
++
++    def state_current(self, ado_state, tags=None):
++        level_1_aux = [
++            (ado_state.extract(label), ado_state.exps(label)[0])
++            for label in ado_state.filter(level=1, tags=tags)
++        ]
++
++        def exp_sign(exp):
++            return 1 if exp.type == exp.types["+"] else -1
++
++        def exp_op(exp):
++            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
++
++        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
++        # and thus the first 2 * k exponents
++        k = self.lmax + 1
++        return 1.0j * sum(
++            exp_sign(exp) * (exp_op(exp) * aux).tr()
++            for aux, exp in level_1_aux[:2 * k]
++        )
++
++    def analytic_current(self):
++        if self.bosonic_mode is not None:
++            raise RuntimeError(
++                "Analytic calculation of the current is not implemented in the"
++                " case where a bosonic mode is present."
++            )
++
++        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
++        mu_l = self.theta / 2.
++        mu_r = - self.theta / 2.
++
++        def f(x):
++            return 1 / (np.exp(x) + 1.)
++
++        def Gamma_w(w, mu):
++            return Gamma * W**2 / ((w-mu)**2 + W**2)
++
++        def lamshift(w, mu):
++            return (w-mu)*Gamma_w(w, mu)/(2*W)
++
++        def integrand(w):
++            return (
++                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
++                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
++                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
++                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
++            )
++
++        def real_func(x):
++            return np.real(integrand(x))
++
++        def imag_func(x):
++            return np.imag(integrand(x))
++
++        # These integral bounds should be checked to be wide enough if the
++        # parameters are changed
++        a = -2
++        b = 2
++        real_integral = quad(real_func, a, b)
++        imag_integral = quad(imag_func, a, b)
++
++        return real_integral[0] + 1.0j * imag_integral[0]
++
++    def bath_coefficients(self):
++        """ Correlation function expansion coefficients for the fermionic bath.
++        """
++        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
++        mu_l = self.theta / 2.
++        mu_r = - self.theta / 2.
++
++        def deltafun(j, k):
++            return 1. if j == k else 0.
++
++        Alpha = np.zeros((2 * lmax, 2 * lmax))
++        for j in range(2*lmax):
++            for k in range(2*lmax):
++                Alpha[j][k] = (
++                    (deltafun(j, k + 1) + deltafun(j, k - 1))
++                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
++                )
++
++        eigvalsA = eigvalsh(Alpha)
++
++        eps = []
++        for val in eigvalsA[0:lmax]:
++            eps.append(-2 / val)
++
++        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
++        for j in range(2 * lmax - 1):
++            for k in range(2 * lmax - 1):
++                AlphaP[j][k] = (
++                    (deltafun(j, k + 1) + deltafun(j, k - 1))
++                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
++                )
++
++        eigvalsAP = eigvalsh(AlphaP)
++
++        chi = []
++        for val in eigvalsAP[0:lmax - 1]:
++            chi.append(-2/val)
++
++        eta_list = [
++            0.5 * lmax * (2 * (lmax + 1) - 1) * (
++                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
++                np.prod([
++                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
++                ])
++            )
++            for j in range(lmax)
++        ]
++
++        kappa = [0] + eta_list
++        epsilon = [0] + eps
++
++        def f_approx(x):
++            f = 0.5
++            for ll in range(1, lmax + 1):
++                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
++            return f
++
++        def C(sigma, mu):
++            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
++            gamma_0 = W - sigma*1.0j*mu
++            eta_list = [eta_0]
++            gamma_list = [gamma_0]
++            if lmax > 0:
++                for ll in range(1, lmax + 1):
++                    eta_list.append(
++                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
++                        / (-(epsilon[ll]**2 / beta**2) + W**2)
++                    )
++                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
++            return eta_list, gamma_list
++
++        etapL, gampL = C(1.0, mu_l)
++        etamL, gammL = C(-1.0, mu_l)
++
++        etapR, gampR = C(1.0, mu_r)
++        etamR, gammR = C(-1.0, mu_r)
++
++        ck_plus = etapR + etapL
++        vk_plus = gampR + gampL
++        ck_minus = etamR + etamL
++        vk_minus = gammR + gammL
++
++        return ck_plus, vk_plus, ck_minus, vk_minus
++
++
++_HAMILTONIAN_EVO_KINDS = {
++    "qobj": lambda H: H,
++    "qobjevo_const": lambda H: QobjEvo([H]),
++    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
++    "listevo_const": lambda H: [H],
++}
++
++
++def hamiltonian_to_sys(H, evo, liouvillianize):
++    if liouvillianize:
++        H = liouvillian(H)
++    H = _HAMILTONIAN_EVO_KINDS[evo](H)
++    return H
++
++
++class TestHEOMSolver:
++    def test_create_bosonic(self):
++        Q = sigmaz()
++        H = sigmax()
++        exponents = [
++            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
++            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
++            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
++        ]
++        bath = Bath(exponents)
++
++        hsolver = HEOMSolver(H, bath, 2)
++        assert hsolver.ados.exponents == exponents
++        assert hsolver.ados.max_depth == 2
++
++        hsolver = HEOMSolver(H, [bath] * 3, 2)
++        assert hsolver.ados.exponents == exponents * 3
++        assert hsolver.ados.max_depth == 2
++
++    def test_create_fermionic(self):
++        Q = sigmaz()
++        H = sigmax()
++        exponents = [
++            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
++            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
++        ]
++        bath = Bath(exponents)
++
++        hsolver = HEOMSolver(H, bath, 2)
++        assert hsolver.ados.exponents == exponents
++        assert hsolver.ados.max_depth == 2
++
++        hsolver = HEOMSolver(H, [bath] * 3, 2)
++        assert hsolver.ados.exponents == exponents * 3
++        assert hsolver.ados.max_depth == 2
++
++    def test_create_mixed_bosonic_and_fermionic(self):
++        Q = sigmaz()
++        H = sigmax()
++        exponents = [
++            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
++            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
++            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
++        ]
++        bath = Bath(exponents)
++
++        hsolver = HEOMSolver(H, bath, 2)
++        assert hsolver.ados.exponents == exponents
++        assert hsolver.ados.max_depth == 2
++
++        hsolver = HEOMSolver(H, [bath] * 3, 2)
++        assert hsolver.ados.exponents == exponents * 3
++        assert hsolver.ados.max_depth == 2
++
++    def test_create_bath_errors(self):
++        Q = sigmaz()
++        H = sigmax()
++        mixed_q_dims = [
++            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
++            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
++        ]
++
++        with pytest.raises(ValueError) as err:
++            HEOMSolver(H, Bath(mixed_q_dims), 2)
++        assert str(err.value) == (
++            "All bath exponents must have system coupling operators with the"
++            " same dimensions but a mixture of dimensions was given."
++        )
++
++    def test_create_h_sys_errors(self):
++        H = object()
++        with pytest.raises(TypeError) as err:
++            HEOMSolver(H, Bath([]), 2)
++        assert str(err.value) == (
++            "The Hamiltonian (H) must be a Qobj or QobjEvo"
++        )
++
++        H = [sigmax()]
++        with pytest.raises(TypeError) as err:
++            HEOMSolver([H], Bath([]), 2)
++        assert str(err.value) == (
++            "The Hamiltonian (H) must be a Qobj or QobjEvo"
++        )
++
++    @pytest.mark.parametrize(['method'], [
++        pytest.param("run", id="run"),
++        pytest.param("start", id="start"),
++    ])
++    def test_invalid_rho0_errors(self, method):
++        Q = sigmaz()
++        H = sigmax()
++        exponents = [
++            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
++            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
++            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
++        ]
++        bath = Bath(exponents)
++        hsolver = HEOMSolver(H, bath, 2)
++
++        if method == "run":
++            def solve_method(rho0):
++                return hsolver.run(rho0, [0, 1])
++        elif method == "start":
++            def solve_method(rho0):
++                return hsolver.start(rho0, 0)
++        else:
++            assert False, f"method {method} not supported by test"
++
++        with pytest.raises(ValueError) as err:
++            solve_method(basis(3, 0))
++        assert str(err.value) == (
++            "Initial state rho has dims [[3], [1]]"
++            " but the system dims are [[2], [2]]"
++        )
++
++        with pytest.raises(TypeError) as err:
++            solve_method("batman")
++        assert str(err.value) == (
++            "Initial ADOs passed have type <class 'str'> but a "
++            "HierarchyADOsState or a numpy array-like instance was expected"
++        )
++
++        with pytest.raises(ValueError) as err:
++            solve_method(np.array([1, 2, 3]))
++        assert str(err.value) == (
++            "Initial ADOs passed have shape (3,) but the solver hierarchy"
++            " shape is (10, 2, 2)"
++        )
++
++    @pytest.mark.parametrize(['evo'], [
++        pytest.param("qobj", id="qobj"),
++        pytest.param("qobjevo_const", id="qobjevo_const"),
++        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
++    ])
++    @pytest.mark.parametrize(['liouvillianize'], [
++        pytest.param(False, id="hamiltonian"),
++        pytest.param(True, id="liouvillian"),
++    ])
++    def test_pure_dephasing_model_bosonic_bath(
++        self, evo, liouvillianize, atol=1e-3
++    ):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
++        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
++
++        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
++        options = {"nsteps": 15000, "store_states": True}
++        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
++
++        tlist = np.linspace(0, 10, 21)
++        result = hsolver.run(dlm.rho(), tlist)
++
++        test = dlm.state_results(result.states)
++        expected = dlm.analytic_results(tlist)
++        np.testing.assert_allclose(test, expected, atol=atol)
++
++        if evo != "qobjevo_timedep":
++            rho_final, ado_state = hsolver.steady_state()
++            test = dlm.state_results([rho_final])
++            expected = dlm.analytic_results([100])
++            np.testing.assert_allclose(test, expected, atol=atol)
++            assert rho_final == ado_state.extract(0)
++        else:
++            assert_raises_steady_state_time_dependent(hsolver)
++
++    @pytest.mark.parametrize(['terminator'], [
++        pytest.param(True, id="terminator"),
++        pytest.param(False, id="noterminator"),
++    ])
++    @pytest.mark.parametrize(['bath_cls'], [
++        pytest.param(DrudeLorentzBath, id="matsubara"),
++        pytest.param(DrudeLorentzPadeBath, id="pade"),
++    ])
++    def test_pure_dephasing_model_drude_lorentz_baths(
++        self, terminator, bath_cls, atol=1e-3
++    ):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        bath = bath_cls(
++            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
++        )
++        if terminator:
++            _, terminator_op = bath.terminator()
++            H_sys = liouvillian(dlm.H) + terminator_op
++        else:
++            H_sys = dlm.H
++
++        options = {"nsteps": 15000, "store_states": True}
++        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
++
++        tlist = np.linspace(0, 10, 21)
++        result = hsolver.run(dlm.rho(), tlist)
++
++        test = dlm.state_results(result.states)
++        expected = dlm.analytic_results(tlist)
++        np.testing.assert_allclose(test, expected, atol=atol)
++
++        rho_final, ado_state = hsolver.steady_state()
++        test = dlm.state_results([rho_final])
++        expected = dlm.analytic_results([100])
++        np.testing.assert_allclose(test, expected, atol=atol)
++        assert rho_final == ado_state.extract(0)
++
++    def test_underdamped_pure_dephasing_model_underdamped_bath(
++        self, atol=1e-3
++    ):
++        udm = UnderdampedPureDephasingModel(
++            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
++        )
++        bath = UnderDampedBath(
++            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
++            w0=udm.w0,
++        )
++
++        options = {"nsteps": 15000, "store_states": True}
++        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
++
++        tlist = np.linspace(0, 10, 21)
++        result = hsolver.run(udm.rho(), tlist)
++
++        test = udm.state_results(result.states)
++        expected = udm.analytic_results(tlist)
++        np.testing.assert_allclose(test, expected, atol=atol)
++
++        rho_final, ado_state = hsolver.steady_state()
++        test = udm.state_results([rho_final])
++        expected = udm.analytic_results([5000])
++        np.testing.assert_allclose(test, expected, atol=atol)
++        assert rho_final == ado_state.extract(0)
++
++    @pytest.mark.parametrize(['evo'], [
++        pytest.param("qobj"),
++        pytest.param("qobjevo_const"),
++        pytest.param("qobjevo_timedep"),
++    ])
++    @pytest.mark.parametrize(['liouvillianize'], [
++        pytest.param(False, id="hamiltonian"),
++        pytest.param(True, id="liouvillian"),
++    ])
++    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
++        dlm = DiscreteLevelCurrentModel(
++            gamma=0.01, W=1, T=0.025851991, lmax=10,
++        )
++        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
++        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
++
++        options = {
++            "store_states": True,
++            "store_ados": True,
++            "nsteps": 15_000,
++            "rtol": 1e-7,
++            "atol": 1e-7,
++        }
++        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
++        # for a single impurity we converge with max_depth = 2
++        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
++
++        tlist = [0, 600]
++        result = hsolver.run(dlm.rho(), tlist)
++        current = dlm.state_current(result.ado_states[-1])
++        analytic_current = dlm.analytic_current()
++        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
++
++        if evo != "qobjevo_timedep":
++            rho_final, ado_state = hsolver.steady_state()
++            current = dlm.state_current(ado_state)
++            analytic_current = dlm.analytic_current()
++            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
++        else:
++            assert_raises_steady_state_time_dependent(hsolver)
++
++    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
++        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
++        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
++    ])
++    def test_discrete_level_model_lorentzian_baths(
++        self, bath_cls, analytic_current, atol=1e-3
++    ):
++        dlm = DiscreteLevelCurrentModel(
++            gamma=0.01, W=1, T=0.025851991, lmax=10,
++        )
++
++        options = {
++            "nsteps": 15_000, "store_states": True, "store_ados": True,
++            "rtol": 1e-7, "atol": 1e-7,
++        }
++        bath_l = bath_cls(
++            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
++            Nk=dlm.lmax,
++        )
++        bath_r = bath_cls(
++            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
++            Nk=dlm.lmax,
++        )
++        # for a single impurity we converge with max_depth = 2
++        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
++
++        tlist = [0, 600]
++        result = hsolver.run(dlm.rho(), tlist)
++        current = dlm.state_current(result.ado_states[-1])
++        # analytic_current = dlm.analytic_current()
++        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
++
++        rho_final, ado_state = hsolver.steady_state()
++        current = dlm.state_current(ado_state)
++        # analytic_current = dlm.analytic_current()
++        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
++
++    @pytest.mark.parametrize(['evo'], [
++        pytest.param("qobj"),
++        pytest.param("qobjevo_const"),
++        pytest.param("qobjevo_timedep"),
++    ])
++    @pytest.mark.parametrize(['liouvillianize'], [
++        pytest.param(False, id="hamiltonian"),
++        pytest.param(True, id="liouvillian"),
++    ])
++    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
++        self, evo, liouvillianize
++    ):
++        dlm = DiscreteLevelCurrentModel(
++            gamma=0.01, W=1, T=0.025851991, lmax=10,
++        )
++        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
++        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
++
++        options = {
++            "store_states": True,
++            "store_ados": True,
++            "nsteps": 15_000,
++            "rtol": 1e-7,
++            "atol": 1e-7,
++        }
++        fermionic_bath = FermionicBath(
++            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
++        )
++        # very weak bosonic coupling which should not affect the dynamics of
++        # the interaction between the system and the fermionic bath:
++        eps = [1e-10] * 5
++        bosonic_Q = sigmax()
++        bosonic_bath = BosonicBath(
++            bosonic_Q, eps, eps, eps, eps, combine=False,
++        )
++        # for a single impurity we converge with max_depth = 2
++        # we specify the bosonic bath first to ensure that the test checks
++        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
++        # mode is before the fermionic ones
++        hsolver = HEOMSolver(
++            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
++        )
++
++        tlist = [0, 600]
++        result = hsolver.run(dlm.rho(), tlist)
++        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
++        analytic_current = dlm.analytic_current()
++        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
++
++        if evo != "qobjevo_timedep":
++            rho_final, ado_state = hsolver.steady_state()
++            current = dlm.state_current(ado_state)
++            analytic_current = dlm.analytic_current()
++            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
++        else:
++            assert_raises_steady_state_time_dependent(hsolver)
++
++    @pytest.mark.parametrize(['evo'], [
++        pytest.param("qobj"),
++        pytest.param("qobjevo_const"),
++        pytest.param("qobjevo_timedep"),
++    ])
++    @pytest.mark.parametrize(['liouvillianize'], [
++        pytest.param(False, id="hamiltonian"),
++        pytest.param(True, id="liouvillian"),
++    ])
++    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
++        self, evo, liouvillianize
++    ):
++        dlm = DiscreteLevelCurrentModel(
++            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
++        )
++        bosonic_mode = BosonicMode(
++            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
++        )
++
++        dlm_ref = DiscreteLevelCurrentModel(
++            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
++            bosonic_mode=bosonic_mode,
++        )
++
++        options = {
++            "store_states": True,
++            "store_ados": True,
++            "nsteps": 15_000,
++            "rtol": 1e-7,
++            "atol": 1e-7,
++        }
++
++        # First we construct a solver with the boson modelled as part of the
++        # system and only a single Fermionic bath. This will provide the
++        # reference result for the test:
++        fermionic_bath_ref = FermionicBath(
++            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
++        )
++
++        hsolver_ref = HEOMSolver(
++            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
++        )
++
++        # Then we construct a solver for the same system, but with the
++        # bosonic mode as a bath This is the result we would like to check:
++        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
++
++        fermionic_bath = FermionicBath(
++            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
++        )
++
++        bosonic_bath = BosonicBath(
++            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
++            combine=True, tag="bosonic",
++        )
++
++        hsolver = HEOMSolver(
++            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
++        )
++
++        # Calculate currents and occupations:
++        tlist = np.linspace(0, 1000, 300)
++        psi0 = basis(2, 0)
++
++        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
++        current_ref = [
++            dlm_ref.state_current(ado_state, tags=["fermionic"])
++            for ado_state in result_ref.ado_states
++        ]
++        sys_occupation_ref = dlm_ref.sys_occupation(
++            result_ref.states
++        )
++
++        result = hsolver.run(dlm.rho(psi0), tlist)
++        current = [
++            dlm.state_current(ado_state, tags=["fermionic"])
++            for ado_state in result.ado_states
++        ]
++        sys_occupation = dlm.sys_occupation(result.states)
++
++        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
++        np.testing.assert_allclose(
++            sys_occupation_ref, sys_occupation, rtol=1e-3,
++        )
++
++        if evo != "qobjevo_timedep":
++            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
++            current_ss_ref = dlm_ref.state_current(ado_state_ref)
++            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
++
++            rho_final, ado_state = hsolver.steady_state()
++            current_ss = dlm.state_current(ado_state)
++            sys_occupation_ss = dlm.sys_occupation(rho_final)
++
++            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
++            np.testing.assert_allclose(
++                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
++            )
++        else:
++            assert_raises_steady_state_time_dependent(hsolver)
++
++    @pytest.mark.parametrize(['ado_format'], [
++        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
++        pytest.param("numpy", id="numpy"),
++    ])
++    def test_ado_input_and_return(self, ado_format):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
++
++        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
++        options = {
++            "nsteps": 15_000, "store_states": True, "store_ados": True,
++        }
++        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
++
++        tlist_1 = [0, 1, 2]
++        result_1 = hsolver.run(dlm.rho(), tlist_1)
++
++        tlist_2 = [2, 3, 4]
++        rho0 = result_1.ado_states[-1]
++        if ado_format == "numpy":
++            rho0 = rho0._ado_state  # extract the raw numpy array
++        result_2 = hsolver.run(rho0, tlist_2)
++
++        tlist_full = tlist_1 + tlist_2[1:]
++        result_full = hsolver.run(dlm.rho(), tlist_full)
++
++        times_12 = result_1.times + result_2.times[1:]
++        times_full = result_full.times
++        assert times_12 == tlist_full
++        assert times_full == tlist_full
++
++        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
++        ado_states_full = result_full.ado_states
++        assert len(ado_states_12) == len(tlist_full)
++        assert len(ado_states_full) == len(tlist_full)
++        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
++            for label in hsolver.ados.labels:
++                np.testing.assert_allclose(
++                    ado_12.extract(label).full(),
++                    ado_full.extract(label).full(),
++                    atol=1e-6,
++                )
++
++        states_12 = result_1.states + result_2.states[1:]
++        states_full = result_full.states
++        assert len(states_12) == len(tlist_full)
++        assert len(states_full) == len(tlist_full)
++        for ado_12, state_12 in zip(ado_states_12, states_12):
++            assert ado_12.rho == state_12
++        for ado_full, state_full in zip(ado_states_full, states_full):
++            assert ado_full.rho == state_full
++
++        expected = dlm.analytic_results(tlist_full)
++        test_12 = dlm.state_results(states_12)
++        np.testing.assert_allclose(test_12, expected, atol=1e-3)
++        test_full = dlm.state_results(states_full)
++        np.testing.assert_allclose(test_full, expected, atol=1e-3)
++
++    def test_solving_with_step(self):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
++
++        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
++        options = {"nsteps": 15_000, "store_ados": True}
++        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
++
++        tlist = np.linspace(0, 10, 21)
++        ado_state = None
++        states = [dlm.rho()]
++        hsolver.start(states[0], 0)
++        for t in tlist[1:]:
++            ado_state = hsolver.step(t)
++            states.append(ado_state.rho)
++
++        test = dlm.state_results(states)
++        expected = dlm.analytic_results(tlist)
++        np.testing.assert_allclose(test, expected, atol=1e-3)
++
++        assert states[-1] == ado_state.extract(0)
++
++
++class TestHeomsolveFunction:
++    @pytest.mark.parametrize(['evo'], [
++        pytest.param("qobj", id="qobj"),
++        pytest.param("listevo_const", id="listevo_const"),
++        pytest.param("qobjevo_const", id="qobjevo_const"),
++        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
++    ])
++    @pytest.mark.parametrize(['liouvillianize'], [
++        pytest.param(False, id="hamiltonian"),
++        pytest.param(True, id="liouvillian"),
++    ])
++    def test_heomsolve_with_pure_dephasing_model(
++        self, evo, liouvillianize, atol=1e-3
++    ):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
++        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
++
++        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
++        options = {"nsteps": 15000, "store_states": True}
++
++        e_ops = {
++            "11": basis(2, 0) * basis(2, 0).dag(),
++            "22": basis(2, 1) * basis(2, 1).dag(),
++        }
++
++        tlist = np.linspace(0, 10, 21)
++        result = heomsolve(
++            H_sys, bath, 14, dlm.rho(), tlist,
++            e_ops=e_ops, args={"foo": 1}, options=options)
++
++        test = dlm.state_results(result.states)
++        expected = dlm.analytic_results(tlist)
++        np.testing.assert_allclose(test, expected, atol=atol)
++
++        for label in ["11", "22"]:
++            np.testing.assert_allclose(
++                result.e_data[label],
++                [expect(rho, e_ops[label]) for rho in result.states],
++                atol=atol,
++            )
++
++
++class TestHSolverDL:
++    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
++        pytest.param(True, 1e-4, id="bnd_cut_approx"),
++        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
++    ])
++    @pytest.mark.parametrize(['evo', 'combine'], [
++        pytest.param("qobj", True, id="qobj-combined"),
++        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
++        pytest.param("listevo_const", True, id="listevo-const-combined"),
++        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
++        pytest.param(
++            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
++        ),
++    ])
++    @pytest.mark.parametrize(['liouvillianize'], [
++        pytest.param(False, id="hamiltonian"),
++        pytest.param(True, id="liouvillian"),
++    ])
++    def test_pure_dephasing_model(
++        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
++    ):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
++        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
++
++        options = {"nsteps": 15_000, "store_states": True}
++        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
++                            14, 2, dlm.gamma,
++                            bnd_cut_approx=bnd_cut_approx,
++                            options=options, combine=combine)
++
++        tlist = np.linspace(0, 10, 21)
++        result = hsolver.run(dlm.rho(), tlist)
++
++        test = dlm.state_results(result.states)
++        expected = dlm.analytic_results(tlist)
++        np.testing.assert_allclose(test, expected, atol=atol)
++
++        if evo != "qobjevo_timedep":
++            rho_final, ado_state = hsolver.steady_state()
++            test = dlm.state_results([rho_final])
++            expected = dlm.analytic_results([100])
++            np.testing.assert_allclose(test, expected, atol=atol)
++            assert rho_final == ado_state.extract(0)
++        else:
++            assert_raises_steady_state_time_dependent(hsolver)
++
++    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
++        pytest.param(True, 1e-4, id="bnd_cut_approx"),
++        pytest.param(False, 1e-3, id="renorm"),
++    ])
++    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
++        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
++        # is repeated here to ensure the new HSolverDL remains compatibile
++        # with the old one until it is removed.
++        cut_frequency = 0.05
++        coupling_strength = 0.025
++        lam_c = coupling_strength / np.pi
++        temperature = 1 / 0.95
++        times = np.linspace(0, 10, 21)
++
++        def _integrand(omega, t):
++            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
++            return (-4 * J * (1 - np.cos(omega*t))
++                    / (np.tanh(0.5*omega / temperature) * omega**2))
++
++        # Calculate the analytical results by numerical integration
++        expected = [
++            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
++            for t in times
++        ]
++
++        H_sys = Qobj(np.zeros((2, 2)))
++        Q = sigmaz()
++        initial_state = 0.5*Qobj(np.ones((2, 2)))
++        projector = basis(2, 0) * basis(2, 1).dag()
++        options = {"nsteps": 15_000, "store_states": True}
++        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
++                            20, 2, cut_frequency,
++                            bnd_cut_approx=bnd_cut_approx,
++                            options=options)
++        test = expect(hsolver.run(initial_state, times).states, projector)
++        np.testing.assert_allclose(test, expected, atol=tol)
++
++    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
++    def test_integration_error(self):
++        dlm = DrudeLorentzPureDephasingModel(
++            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
++        )
++        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
++
++        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
++        options = {"nsteps": 10}
++        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
++
++        with pytest.raises(IntegratorException) as err:
++            hsolver.run(dlm.rho(), tlist=[0, 10])
++
++        assert str(err.value) == (
++            "Excess work done on this call. Try to increasing the nsteps"
++            " parameter in the Options class"
++        )
++
++
++class TestHEOMResult:
++    def mk_ados(self, bath_dims, max_depth):
++        exponents = [
++            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
++        ]
++        ados = HierarchyADOs(exponents, max_depth=max_depth)
++        return ados
++
++    def mk_rho_and_soln(self, ados, rho_dims):
++        n_ados = len(ados.labels)
++        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
++        rho = Qobj(ado_soln[0, :], dims=rho_dims)
++        return rho, ado_soln
++
++    def test_create_ado_states_attribute(self):
++        options = fill_options()
++        result = HEOMResult(e_ops=[], options=options)
++        assert not hasattr(result, "final_ado_state")
++        assert not hasattr(result, "ado_states")
++        assert result.store_ados is False
++
++        options = fill_options(store_ados=True)
++        result = HEOMResult(e_ops=[], options=options)
++        assert result.final_ado_state is None
++        assert result.ado_states == []
++        assert result.store_ados is True
++
++    @pytest.mark.parametrize(['e_op_type'], [
++        pytest.param("qobj", id="qobj"),
++        pytest.param("qobjevo", id="qobjevo"),
++        pytest.param("callable", id="callable"),
++    ])
++    def test_e_ops(self, e_op_type):
++        op = Qobj([[1, 0], [0, 0]])
++        if e_op_type == "qobj":
++            e_op = op
++        elif e_op_type == "qobjevo":
++            e_op = QobjEvo(op)
++        elif e_op_type == "callable":
++            def e_op(f, ado_state):
++                return expect(op, ado_state.rho)
++        else:
++            assert False, f"unknown e_op_type {e_op_type!r}"
++
++        options = fill_options()
++        result = HEOMResult(e_ops=e_op, options=options)
++
++        ados = self.mk_ados([2, 3], max_depth=2)
++        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
++        e_op_value = expect(op, rho)
++        ado_state = HierarchyADOsState(rho, ados, ado_soln)
++
++        result.add(0.1, ado_state)
++
++        assert result.expect[0] == [e_op_value]
++        assert result.e_data[0] == [e_op_value]
++
++    def test_store_state(self):
++        options = fill_options()
++        result = HEOMResult(e_ops=[], options=options)
++
++        ados = self.mk_ados([2, 3], max_depth=2)
++        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
++        ado_state = HierarchyADOsState(rho, ados, ado_soln)
++
++        result.add(0.1, ado_state)
++
++        assert result.times == [0.1]
++        assert result.states == [rho]
++        assert result.final_state is rho
++
++    def test_store_ados(self):
++        options = fill_options(store_ados=True)
++        result = HEOMResult(e_ops=[], options=options)
++
++        ados = self.mk_ados([2, 3], max_depth=2)
++        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
++        ado_state = HierarchyADOsState(rho, ados, ado_soln)
++
++        result.add(0.1, ado_state)
++        assert result.times == [0.1]
++        assert result.states == [rho]
++        assert result.final_state is rho
++        assert result.ado_states == [ado_state]
++        assert result.final_ado_state is ado_state
++
++
++class Test_GatherHEOMRHS:
++    def test_simple_gather(self):
++        def f(label):
++            return int(label.lstrip("o"))
++
++        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
++
++        for i in range(3):
++            for j in range(3):
++                base = 10 * (j * 2) + (i * 2)
++                block_op = _data.to(
++                    _data.CSR,
++                    _data.create(np.array([
++                        [base, base + 10],
++                        [base + 1, base + 11],
++                    ]))
++                )
++                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
++
++        op = gather_heoms.gather()
++
++        expected_op = np.array([
++            [10 * i + j for i in range(2 * 3)]
++            for j in range(2 * 3)
++        ], dtype=np.complex128)
++
++        np.testing.assert_array_equal(op.to_array(), expected_op)
++        assert isinstance(op, _data.CSR)
+diff --git a/qutip/tests/solver/heom/test_heom.py b/qutip/tests/solver/heom/test_heom.py
+index c8988a16..ad5680b6 100644
+--- a/qutip/tests/solver/heom/test_heom.py
++++ b/qutip/tests/solver/heom/test_heom.py
+@@ -1,46 +1,46 @@
+-"""
+-Tests for qutip.nonmarkov.heom.
+-"""
+-
+-import pytest
+-from qutip.solver.heom import (
+-    BathExponent,
+-    Bath,
+-    BosonicBath,
+-    DrudeLorentzBath,
+-    DrudeLorentzPadeBath,
+-    UnderDampedBath,
+-    FermionicBath,
+-    LorentzianBath,
+-    LorentzianPadeBath,
+-    heomsolve,
+-    HEOMSolver,
+-    HEOMResult,
+-    HSolverDL,
+-    HierarchyADOs,
+-    HierarchyADOsState,
+-)
+-
+-class TestBathAPI:
+-    def test_api(self):
+-        # just assert that the baths are importable
+-        assert BathExponent
+-        assert Bath
+-        assert BosonicBath
+-        assert DrudeLorentzBath
+-        assert DrudeLorentzPadeBath
+-        assert UnderDampedBath
+-        assert FermionicBath
+-        assert LorentzianBath
+-        assert LorentzianPadeBath
+-
+-
+-class TestSolverAPI:
+-    def test_api(self):
+-        # just assert that the solvers and associated classes are importable
+-        assert heomsolve
+-        assert HEOMSolver
+-        assert HEOMResult
+-        assert HSolverDL
+-        assert HierarchyADOs
+-        assert HierarchyADOsState
++"""
++Tests for qutip.nonmarkov.heom.
++"""
++
++import pytest
++from qutip.solver.heom import (
++    BathExponent,
++    Bath,
++    BosonicBath,
++    DrudeLorentzBath,
++    DrudeLorentzPadeBath,
++    UnderDampedBath,
++    FermionicBath,
++    LorentzianBath,
++    LorentzianPadeBath,
++    heomsolve,
++    HEOMSolver,
++    HEOMResult,
++    HSolverDL,
++    HierarchyADOs,
++    HierarchyADOsState,
++)
++
++class TestBathAPI:
++    def test_api(self):
++        # just assert that the baths are importable
++        assert BathExponent
++        assert Bath
++        assert BosonicBath
++        assert DrudeLorentzBath
++        assert DrudeLorentzPadeBath
++        assert UnderDampedBath
++        assert FermionicBath
++        assert LorentzianBath
++        assert LorentzianPadeBath
++
++
++class TestSolverAPI:
++    def test_api(self):
++        # just assert that the solvers and associated classes are importable
++        assert heomsolve
++        assert HEOMSolver
++        assert HEOMResult
++        assert HSolverDL
++        assert HierarchyADOs
++        assert HierarchyADOsState
+diff --git a/qutip/tests/solver/test_brmesolve.py b/qutip/tests/solver/test_brmesolve.py
+index 7b1aef06..bc5b4c6d 100644
+--- a/qutip/tests/solver/test_brmesolve.py
++++ b/qutip/tests/solver/test_brmesolve.py
+@@ -1,296 +1,296 @@
+-import pytest
+-import numpy as np
+-import qutip
+-from qutip.solver.brmesolve import brmesolve
+-
+-
+-def pauli_spin_operators():
+-    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+-
+-
+-_simple_qubit_gamma = 0.25
+-coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
+-                          args={'w':0})
+-_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
+-_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
+-_x_a_op = [qutip.sigmax(), coeff]
+-
+-
+-@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
+-    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
+-    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
+-    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
+-                 id="me collapse-br collapse-br coupling"),
+-])
+-def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
+-    """
+-    Test that the BR solver handles collapse and coupling operators correctly
+-    relative to the standard ME solver.
+-    """
+-    delta = 0.0
+-    epsilon = 0.5 * 2 * np.pi
+-    e_ops = pauli_spin_operators()
+-    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
+-    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+-    times = np.linspace(0, 10, 100)
+-    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
+-    opt = {"tensor_type": "dense"}
+-    brme = brmesolve(
+-        H, psi0, times,
+-        a_ops=brme_a_ops, c_ops=brme_c_ops,
+-        e_ops=e_ops, options=opt
+-    )
+-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
+-
+-
+-def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
+-    if n_th == 0:
+-        return lambda w: kappa * (w >= 0)
+-
+-    w_th = w0 / np.log(1 + 1/n_th)
+-
+-    def f(t, w):
+-        scale = np.exp(w / w_th) if w < 0 else 1
+-        return (n_th + 1) * kappa * scale
+-    return f
+-
+-
+-def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
+-    a = qutip.destroy(dimension)
+-    if n_th == 0:
+-        return [np.sqrt(kappa) * a]
+-    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
+-
+-
+-@pytest.mark.parametrize("n_th", [0, 0.15])
+-def test_harmonic_oscillator(n_th):
+-    N = 10
+-    w0 = 1.0 * 2*np.pi
+-    g = 0.05 * w0
+-    kappa = 0.15
+-    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
+-
+-    a = qutip.destroy(N)
+-    H = w0*a.dag()*a + g*(a+a.dag())
+-    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
+-    psi0 = qutip.ket2dm(psi0)
+-    times = np.linspace(0, 20, 1000)
+-
+-    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
+-    a_ops = [[a + a.dag(), S_w]]
+-    e_ops = [a.dag()*a, a+a.dag()]
+-
+-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
+-
+-    num = qutip.num(N)
+-    me_num = qutip.expect(num, me.states)
+-    brme_num = qutip.expect(num, brme.states)
+-    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
+-
+-
+-def test_jaynes_cummings_zero_temperature_spectral_callable():
+-    """
+-    brmesolve: Jaynes-Cummings model, zero temperature
+-    """
+-    N = 10
+-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+-    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
+-    kappa = 0.05
+-    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
+-    e_ops = [a.dag()*a, sp.dag()*sp]
+-
+-    w0 = 1.0 * 2*np.pi
+-    g = 0.05 * 2*np.pi
+-    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
+-
+-    c_ops = [np.sqrt(kappa) * a]
+-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+-
+-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+-        # Accept 5% error.
+-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
+-
+-
+-def test_tensor_system():
+-    """
+-    brmesolve: Check for #572 bug.
+-    """
+-    w1, w2, w3 = 1, 2, 3
+-    gamma2, gamma3 = 0.1, 0.1
+-    id2 = qutip.qeye(2)
+-
+-    # Hamiltonian for three uncoupled qubits
+-    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
+-         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
+-         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
+-
+-    # White noise
+-    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
+-    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
+-
+-    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
+-    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
+-
+-    # Initial state : first qubit is excited
+-    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
+-    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
+-    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
+-
+-    # Projector on the excited state of qubit 1
+-    proj_up1 = qutip.tensor(exc2, id2, id2)
+-    times = np.linspace(0, 10./gamma3, 1000)
+-
+-    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
+-                    e_ops=[proj_up1]).expect[0]
+-
+-    np.testing.assert_allclose(sol, np.ones_like(times))
+-
+-
+-def test_solver_accepts_list_hamiltonian():
+-    """
+-    brmesolve: input list of Qobj
+-    """
+-    delta = 0.0 * 2 * np.pi
+-    epsilon = 0.5 * 2 * np.pi
+-    gamma = 0.25
+-    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
+-    e_ops = pauli_spin_operators()
+-    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
+-    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+-    times = np.linspace(0, 10, 100)
+-    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
+-    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
+-    for me_expectation, brme_expectation in zip(me, brme):
+-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
+-
+-
+-def test_jaynes_cummings_zero_temperature_spectral_str():
+-    N = 10
+-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+-    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
+-    kappa = 0.05
+-    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
+-    e_ops = [a.dag()*a, sp.dag()*sp]
+-
+-    w0 = 1.0 * 2*np.pi
+-    g = 0.05 * 2*np.pi
+-    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
+-
+-    c_ops = [np.sqrt(kappa) * a]
+-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+-
+-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+-        # Accept 5% error.
+-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
+-
+-
+-def _mixed_string(kappa, _):
+-    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
+-
+-
+-def _separate_strings(kappa, _):
+-    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
+-
+-
+-def _string_w_interpolating_t(kappa, times):
+-    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
+-    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
+-
+-
+-@pytest.mark.slow
+-@pytest.mark.parametrize("time_dependence_tuple", [
+-        _mixed_string,
+-        _separate_strings,
+-        _string_w_interpolating_t,
+-    ])
+-def test_time_dependence_tuples(time_dependence_tuple):
+-    N = 10
+-    a = qutip.destroy(N)
+-    H = a.dag()*a
+-    psi0 = qutip.basis(N, 9)
+-    times = np.linspace(0, 10, 100)
+-    kappa = 0.2
+-    spectra, coeff = time_dependence_tuple(kappa, times)
+-    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
+-    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
+-    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
+-    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
+-
+-
+-def test_time_dependent_spline_in_c_ops():
+-    N = 10
+-    a = qutip.destroy(N)
+-    H = a.dag()*a
+-    psi0 = qutip.basis(N, 9)
+-    times = np.linspace(0, 10, 100)
+-    kappa = 0.2
+-    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
+-    spectra, coeff = _string_w_interpolating_t(kappa, times)
+-    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
+-    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
+-    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
+-    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
+-    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
+-
+-
+-@pytest.mark.slow
+-def test_nonhermitian_e_ops():
+-    N = 5
+-    a = qutip.destroy(N)
+-    coefficient = np.random.random() + 1j*np.random.random()
+-    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
+-    H_brme = [[H, '1']]
+-    psi0 = qutip.basis(N, 2)
+-    times = np.linspace(0, 10, 10)
+-    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
+-    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
+-    np.testing.assert_allclose(me, brme, atol=1e-4)
+-
+-
+-@pytest.mark.slow
+-def test_result_states():
+-    N = 5
+-    a = qutip.destroy(N)
+-    coefficient = np.random.random() + 1j*np.random.random()
+-    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
+-    H_brme = [[H, '1']]
+-    psi0 = qutip.fock_dm(N, 2)
+-    times = np.linspace(0, 10, 10)
+-    me = qutip.mesolve(H, psi0, times).states
+-    brme = brmesolve(H_brme, psi0, times).states
+-    assert max(np.abs((me_state - brme_state).full()).max()
+-               for me_state, brme_state in zip(me, brme)) < 1e-5
+-
+-
+-@pytest.mark.slow
+-def test_hamiltonian_taking_arguments():
+-    N = 10
+-    w0 = 1.0 * 2*np.pi
+-    g = 0.75 * 2*np.pi
+-    kappa = 0.05
+-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+-    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
+-    psi0 = qutip.ket2dm(psi0)
+-    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
+-
+-    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
+-    e_ops = [a.dag()*a, sp.dag()*sp]
+-
+-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+-    args = {'ii': 1}
+-
+-    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
+-    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
+-    for arg, no_arg in zip(args.expect, no_args.expect):
+-        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
++import pytest
++import numpy as np
++import qutip
++from qutip.solver.brmesolve import brmesolve
++
++
++def pauli_spin_operators():
++    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
++
++
++_simple_qubit_gamma = 0.25
++coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
++                          args={'w':0})
++_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
++_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
++_x_a_op = [qutip.sigmax(), coeff]
++
++
++@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
++    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
++    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
++    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
++                 id="me collapse-br collapse-br coupling"),
++])
++def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
++    """
++    Test that the BR solver handles collapse and coupling operators correctly
++    relative to the standard ME solver.
++    """
++    delta = 0.0
++    epsilon = 0.5 * 2 * np.pi
++    e_ops = pauli_spin_operators()
++    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
++    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
++    times = np.linspace(0, 10, 100)
++    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
++    opt = {"tensor_type": "dense"}
++    brme = brmesolve(
++        H, psi0, times,
++        a_ops=brme_a_ops, c_ops=brme_c_ops,
++        e_ops=e_ops, options=opt
++    )
++    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
++        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
++
++
++def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
++    if n_th == 0:
++        return lambda w: kappa * (w >= 0)
++
++    w_th = w0 / np.log(1 + 1/n_th)
++
++    def f(t, w):
++        scale = np.exp(w / w_th) if w < 0 else 1
++        return (n_th + 1) * kappa * scale
++    return f
++
++
++def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
++    a = qutip.destroy(dimension)
++    if n_th == 0:
++        return [np.sqrt(kappa) * a]
++    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
++
++
++@pytest.mark.parametrize("n_th", [0, 0.15])
++def test_harmonic_oscillator(n_th):
++    N = 10
++    w0 = 1.0 * 2*np.pi
++    g = 0.05 * w0
++    kappa = 0.15
++    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
++
++    a = qutip.destroy(N)
++    H = w0*a.dag()*a + g*(a+a.dag())
++    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
++    psi0 = qutip.ket2dm(psi0)
++    times = np.linspace(0, 20, 1000)
++
++    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
++    a_ops = [[a + a.dag(), S_w]]
++    e_ops = [a.dag()*a, a+a.dag()]
++
++    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
++    brme = brmesolve(H, psi0, times, a_ops, e_ops)
++    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
++        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
++
++    num = qutip.num(N)
++    me_num = qutip.expect(num, me.states)
++    brme_num = qutip.expect(num, brme.states)
++    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
++
++
++def test_jaynes_cummings_zero_temperature_spectral_callable():
++    """
++    brmesolve: Jaynes-Cummings model, zero temperature
++    """
++    N = 10
++    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
++    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
++    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
++    kappa = 0.05
++    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
++    e_ops = [a.dag()*a, sp.dag()*sp]
++
++    w0 = 1.0 * 2*np.pi
++    g = 0.05 * 2*np.pi
++    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
++
++    c_ops = [np.sqrt(kappa) * a]
++    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
++
++    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
++    brme = brmesolve(H, psi0, times, a_ops, e_ops)
++    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
++        # Accept 5% error.
++        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
++
++
++def test_tensor_system():
++    """
++    brmesolve: Check for #572 bug.
++    """
++    w1, w2, w3 = 1, 2, 3
++    gamma2, gamma3 = 0.1, 0.1
++    id2 = qutip.qeye(2)
++
++    # Hamiltonian for three uncoupled qubits
++    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
++         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
++         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
++
++    # White noise
++    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
++    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
++
++    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
++    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
++
++    # Initial state : first qubit is excited
++    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
++    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
++    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
++
++    # Projector on the excited state of qubit 1
++    proj_up1 = qutip.tensor(exc2, id2, id2)
++    times = np.linspace(0, 10./gamma3, 1000)
++
++    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
++                    e_ops=[proj_up1]).expect[0]
++
++    np.testing.assert_allclose(sol, np.ones_like(times))
++
++
++def test_solver_accepts_list_hamiltonian():
++    """
++    brmesolve: input list of Qobj
++    """
++    delta = 0.0 * 2 * np.pi
++    epsilon = 0.5 * 2 * np.pi
++    gamma = 0.25
++    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
++    e_ops = pauli_spin_operators()
++    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
++    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
++    times = np.linspace(0, 10, 100)
++    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
++    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
++    for me_expectation, brme_expectation in zip(me, brme):
++        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
++
++
++def test_jaynes_cummings_zero_temperature_spectral_str():
++    N = 10
++    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
++    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
++    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
++    kappa = 0.05
++    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
++    e_ops = [a.dag()*a, sp.dag()*sp]
++
++    w0 = 1.0 * 2*np.pi
++    g = 0.05 * 2*np.pi
++    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
++
++    c_ops = [np.sqrt(kappa) * a]
++    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
++
++    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
++    brme = brmesolve(H, psi0, times, a_ops, e_ops)
++    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
++        # Accept 5% error.
++        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
++
++
++def _mixed_string(kappa, _):
++    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
++
++
++def _separate_strings(kappa, _):
++    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
++
++
++def _string_w_interpolating_t(kappa, times):
++    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
++    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
++
++
++@pytest.mark.slow
++@pytest.mark.parametrize("time_dependence_tuple", [
++        _mixed_string,
++        _separate_strings,
++        _string_w_interpolating_t,
++    ])
++def test_time_dependence_tuples(time_dependence_tuple):
++    N = 10
++    a = qutip.destroy(N)
++    H = a.dag()*a
++    psi0 = qutip.basis(N, 9)
++    times = np.linspace(0, 10, 100)
++    kappa = 0.2
++    spectra, coeff = time_dependence_tuple(kappa, times)
++    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
++    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
++    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
++    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
++
++
++def test_time_dependent_spline_in_c_ops():
++    N = 10
++    a = qutip.destroy(N)
++    H = a.dag()*a
++    psi0 = qutip.basis(N, 9)
++    times = np.linspace(0, 10, 100)
++    kappa = 0.2
++    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
++    spectra, coeff = _string_w_interpolating_t(kappa, times)
++    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
++    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
++    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
++    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
++    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
++
++
++@pytest.mark.slow
++def test_nonhermitian_e_ops():
++    N = 5
++    a = qutip.destroy(N)
++    coefficient = np.random.random() + 1j*np.random.random()
++    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
++    H_brme = [[H, '1']]
++    psi0 = qutip.basis(N, 2)
++    times = np.linspace(0, 10, 10)
++    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
++    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
++    np.testing.assert_allclose(me, brme, atol=1e-4)
++
++
++@pytest.mark.slow
++def test_result_states():
++    N = 5
++    a = qutip.destroy(N)
++    coefficient = np.random.random() + 1j*np.random.random()
++    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
++    H_brme = [[H, '1']]
++    psi0 = qutip.fock_dm(N, 2)
++    times = np.linspace(0, 10, 10)
++    me = qutip.mesolve(H, psi0, times).states
++    brme = brmesolve(H_brme, psi0, times).states
++    assert max(np.abs((me_state - brme_state).full()).max()
++               for me_state, brme_state in zip(me, brme)) < 1e-5
++
++
++@pytest.mark.slow
++def test_hamiltonian_taking_arguments():
++    N = 10
++    w0 = 1.0 * 2*np.pi
++    g = 0.75 * 2*np.pi
++    kappa = 0.05
++    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
++    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
++    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
++    psi0 = qutip.ket2dm(psi0)
++    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
++
++    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
++    e_ops = [a.dag()*a, sp.dag()*sp]
++
++    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
++    args = {'ii': 1}
++
++    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
++    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
++    for arg, no_arg in zip(args.expect, no_args.expect):
++        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
+diff --git a/qutip/tests/solver/test_correlation.py b/qutip/tests/solver/test_correlation.py
+index bf96b045..f2af197d 100644
+--- a/qutip/tests/solver/test_correlation.py
++++ b/qutip/tests/solver/test_correlation.py
+@@ -1,329 +1,329 @@
+-import pytest
+-import functools
+-from itertools import product
+-import numpy as np
+-import qutip
+-
+-pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
+-
+-_equivalence_dimension = 15
+-_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
+-_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
+-
+-
+-@pytest.mark.filterwarnings("ignore::FutureWarning")
+-@pytest.mark.parametrize(["solver", "start"], [
+-    pytest.param("es", _equivalence_coherent, id="es"),
+-    pytest.param("es", None, id="es-steady state"),
+-])
+-def test_correlation_solver_equivalence(solver, start):
+-    """
+-    Test that all of the correlation solvers give the same results for a given
+-    system.
+-    """
+-    a = qutip.destroy(_equivalence_dimension)
+-    x = ( a + a.dag() ) / np.sqrt(2)
+-    H = a.dag() * a
+-    G1 = 0.75
+-    n_th = 2
+-    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
+-             np.sqrt(G1 * n_th) * a.dag()]
+-    times = np.linspace(0, 3, 61)
+-    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
+-    # long simulation time.
+-    tol = 0.25 if solver == "mc" else 1e-4
+-    # We use the master equation version as a base, but it doesn't actually
+-    # matter - if all the tests fail, it implies that the "me" solver might be
+-    # broken, whereas if only one fails, then it implies that only that one is
+-    # broken.  We test that all solvers are equivalent by transitive equality
+-    # to the "me" solver.
+-    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
+-                                    a.dag(), a, solver="me")
+-    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
+-                                   a.dag(), a, solver=solver)
+-    np.testing.assert_allclose(base, cmp, atol=tol)
+-
+-
+-def _spectrum_wrapper(solver):
+-    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
+-    @functools.wraps(qutip.spectrum)
+-    def out(H, c_ops, a, b):
+-        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
+-                frequencies)
+-    return out
+-
+-
+-def _spectrum_fft(H, c_ops, a, b):
+-    times = np.linspace(0, 100, 2500)
+-    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
+-    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
+-    return spectrum, frequencies
+-
+-
+-@pytest.mark.parametrize("spectrum", [
+-    pytest.param(_spectrum_fft, id="fft"),
+-    pytest.param(_spectrum_wrapper("es"), id="es"),
+-    pytest.param(_spectrum_wrapper("pi"), id="pi"),
+-    pytest.param(_spectrum_wrapper("solve"), id="solve"),
+-])
+-def test_spectrum_solver_equivalence_to_es(spectrum):
+-    """Test equivalence of the spectrum solvers to the base "es" method."""
+-    # Jaynes--Cummings model.
+-    dimension = 4
+-    wc = wa = 1.0 * 2*np.pi
+-    g = 0.1 * 2*np.pi
+-    kappa = 0.75
+-    gamma = 0.25
+-    n_th = 0.01
+-
+-    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
+-    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
+-    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
+-    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
+-             np.sqrt(kappa * n_th) * a.dag(),
+-             np.sqrt(gamma) * sm.dag()]
+-
+-    test, frequencies = spectrum(H, c_ops, a.dag(), a)
+-    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
+-    np.testing.assert_allclose(base, test, atol=1e-3)
+-
+-
+-def _trapz_2d(z, xy):
+-    """2D trapezium-method integration assuming a square grid."""
+-    dx = xy[1] - xy[0]
+-    return dx*dx * np.trapz(np.trapz(z, axis=0))
+-
+-
+-def _n_correlation(times, n):
+-    """
+-    Numerical integration of the correlation function given an array of
+-    expectation values.
+-    """
+-    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
+-                     for t in range(times.shape[0])])
+-
+-
+-def _coefficient_function(t, args):
+-    t_off, tp = args['t_off'], args['tp']
+-    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
+-
+-
+-_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
+-
+-
+-def _h_qobj_function(t, args):
+-    return args['H0'] * _coefficient_function(t, args)
+-
+-
+-# 2LS and 3LS stand for two- and three-level system respectively.
+-
+-_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
+-_2ls_times = np.linspace(0, 5, 51)
+-_3ls_args = {'t_off': 2, 'tp': 1}
+-_3ls_times = np.linspace(0, 6, 20)
+-
+-
+-def _2ls_g2_0(H, c_ops):
+-    sp = qutip.sigmap()
+-    start = qutip.basis(2, 0)
+-    times = _2ls_times
+-    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
+-    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
+-                                           sp.dag(), sp.dag()*sp, sp,
+-                                           args=_2ls_args)
+-    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
+-                                  e_ops=[qutip.num(2)],
+-                                  args=_2ls_args).expect[0]
+-    integral_correlation = _trapz_2d(np.real(correlation), times)
+-    integral_n_expectation = np.trapz(n_expectation, times)
+-    # Factor of two from negative time correlations.
+-    return 2 * integral_correlation / integral_n_expectation**2
+-
+-
+-@pytest.fixture(params=[
+-    pytest.param(_coefficient_string, id="string"),
+-    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
+-    pytest.param(_coefficient_function, id="function"),
+-])
+-def dependence_2ls(request):
+-    return request.param
+-
+-
+-class TestTimeDependence:
+-    """
+-    Test correlations with time-dependent operators using a two-level system
+-    (2LS) or a three-level system (3LS).
+-    """
+-    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
+-        H = [[_2ls_args['H0'], dependence_2ls]]
+-        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
+-
+-    def test_hamiltonian_from_function_2ls(self):
+-        H = _h_qobj_function
+-        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
+-
+-    @pytest.mark.slow
+-    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
+-        H = [[_2ls_args['H0'], dependence_2ls]]
+-        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
+-        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
+-
+-    @pytest.mark.slow
+-    @pytest.mark.parametrize("dependence_3ls", [
+-        pytest.param(_coefficient_string, id="string"),
+-        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
+-        pytest.param(_coefficient_function, id="function"),
+-    ])
+-    def test_coefficient_c_ops_3ls(self, dependence_3ls):
+-        # Calculate zero-delay HOM cross-correlation for incoherently pumped
+-        # three-level system, g2_ab[0] with gamma = 1.
+-        dimension = 3
+-        H = qutip.qzero(dimension)
+-        start = qutip.basis(dimension, 2)
+-        times = _3ls_times
+-        project_0_1 = qutip.projection(dimension, 0, 1)
+-        project_1_2 = qutip.projection(dimension, 1, 2)
+-        population_1 = qutip.projection(dimension, 1, 1)
+-        # Define the pi pulse to be when 99% of the population is transferred.
+-        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
+-        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
+-                                      args=_3ls_args)
+-        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
+-        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
+-                                            project_0_1.dag(), project_0_1,
+-                                            args=_3ls_args)
+-        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
+-                                             project_0_1.dag(), project_0_1,
+-                                             args=_3ls_args, reverse=True)
+-        times2 = np.concatenate([times, times[1:] + times[-1]])
+-        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
+-                                 e_ops=[population_1]).expect[0]
+-        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
+-        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
+-        assert abs(g2_ab_0 - 0.185) < 1e-2
+-
+-
+-def _step(t):
+-    return np.arctan(t)/np.pi + 0.5
+-
+-
+-def test_hamiltonian_order_unimportant():
+-    # Testing for regression on issue 1048.
+-    sp = qutip.sigmap()
+-    H = [[qutip.sigmax(), lambda t: _step(t-2)],
+-         [qutip.qeye(2), lambda t: _step(-(t-2))]]
+-    start = qutip.basis(2, 0)
+-    times = np.linspace(0, 5, 6)
+-    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
+-                                        sp.dag(), sp)
+-    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
+-                                         sp.dag(), sp)
+-    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
+-
+-
+-@pytest.mark.parametrize(['solver', 'state'], [
+-    pytest.param('me', _equivalence_fock, id="me-ket"),
+-    pytest.param('me', _equivalence_coherent, id="me-dm"),
+-    pytest.param('me', None, id="me-steady"),
+-    pytest.param('es', _equivalence_fock, id="es-ket"),
+-    pytest.param('es', _equivalence_coherent, id="es-dm"),
+-    pytest.param('es', None, id="es-steady"),
+-])
+-@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
+-                         ids=["hermitian", "nonhermitian"])
+-@pytest.mark.parametrize("w", [1, 2])
+-@pytest.mark.parametrize("gamma", [1, 10])
+-def test_correlation_2op_1t_known_cases(solver,
+-                                        state,
+-                                        is_e_op_hermitian,
+-                                        w,
+-                                        gamma,
+-                                       ):
+-    """This test compares the output correlation_2op_1 solution to an analytical
+-    solution."""
+-
+-    a = qutip.destroy(_equivalence_dimension)
+-    x = (a + a.dag())/np.sqrt(2)
+-
+-    H = w * a.dag() * a
+-
+-    a_op = x if is_e_op_hermitian else a
+-    b_op = x if is_e_op_hermitian else a.dag()
+-    c_ops = [np.sqrt(gamma) * a]
+-
+-    times = np.linspace(0, 1, 30)
+-
+-    # Handle the case state==None when computing expt values
+-    rho0 = state if state else qutip.steadystate(H, c_ops)
+-    if is_e_op_hermitian:
+-        # Analitycal solution for x,x as operators.
+-        base = 0
+-        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
+-        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
+-        base /= np.sqrt(2)
+-    else:
+-        # Analitycal solution for a,adag as operators.
+-        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
+-
+-    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
+-
+-    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
+-
+-
+-def test_correlation_timedependant_op():
+-    num = qutip.num(2)
+-    a = qutip.destroy(2)
+-    sx = qutip.sigmax()
+-    sz = qutip.sigmaz()
+-    times = np.arange(4)
+-    # switch between sx and sz at t=1.5
+-    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
+-
+-    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
+-    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
+-    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
+-    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
+-    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
+-
+-
+-def test_alternative_solver():
+-    from qutip.solver.mesolve import MESolver
+-    from qutip.solver.brmesolve import BRSolver
+-
+-    H = qutip.num(5)
+-    a = qutip.destroy(5)
+-    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
+-
+-    br = BRSolver(H, a_ops)
+-    me = MESolver(H, [a])
+-    times = np.arange(4)
+-
+-    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
+-    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
+-
+-    np.testing.assert_allclose(br_corr, me_corr)
+-
+-
+-def test_G1():
+-    H = qutip.Qobj([[0,1], [1,0]])
+-    psi0 = qutip.basis(2)
+-    taus = np.linspace(0, 1, 11)
+-    scale = 2
+-    a_op = qutip.sigmaz() * scale
+-    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
+-    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
+-    np.testing.assert_allclose(g1, expected, rtol=2e-5)
+-    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
+-
+-
+-def test_G2():
+-    N = 10
+-    H = qutip.rand_dm(N)
+-    psi0 = qutip.rand_ket(N)
+-    taus = np.linspace(0, 1, 11)
+-    scale = 2
+-    a_op = qutip.rand_unitary(N) * scale
+-    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
+-    expected = np.ones(11)
+-    np.testing.assert_allclose(g1, expected, rtol=2e-5)
+-    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
++import pytest
++import functools
++from itertools import product
++import numpy as np
++import qutip
++
++pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
++
++_equivalence_dimension = 15
++_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
++_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
++
++
++@pytest.mark.filterwarnings("ignore::FutureWarning")
++@pytest.mark.parametrize(["solver", "start"], [
++    pytest.param("es", _equivalence_coherent, id="es"),
++    pytest.param("es", None, id="es-steady state"),
++])
++def test_correlation_solver_equivalence(solver, start):
++    """
++    Test that all of the correlation solvers give the same results for a given
++    system.
++    """
++    a = qutip.destroy(_equivalence_dimension)
++    x = ( a + a.dag() ) / np.sqrt(2)
++    H = a.dag() * a
++    G1 = 0.75
++    n_th = 2
++    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
++             np.sqrt(G1 * n_th) * a.dag()]
++    times = np.linspace(0, 3, 61)
++    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
++    # long simulation time.
++    tol = 0.25 if solver == "mc" else 1e-4
++    # We use the master equation version as a base, but it doesn't actually
++    # matter - if all the tests fail, it implies that the "me" solver might be
++    # broken, whereas if only one fails, then it implies that only that one is
++    # broken.  We test that all solvers are equivalent by transitive equality
++    # to the "me" solver.
++    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
++                                    a.dag(), a, solver="me")
++    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
++                                   a.dag(), a, solver=solver)
++    np.testing.assert_allclose(base, cmp, atol=tol)
++
++
++def _spectrum_wrapper(solver):
++    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
++    @functools.wraps(qutip.spectrum)
++    def out(H, c_ops, a, b):
++        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
++                frequencies)
++    return out
++
++
++def _spectrum_fft(H, c_ops, a, b):
++    times = np.linspace(0, 100, 2500)
++    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
++    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
++    return spectrum, frequencies
++
++
++@pytest.mark.parametrize("spectrum", [
++    pytest.param(_spectrum_fft, id="fft"),
++    pytest.param(_spectrum_wrapper("es"), id="es"),
++    pytest.param(_spectrum_wrapper("pi"), id="pi"),
++    pytest.param(_spectrum_wrapper("solve"), id="solve"),
++])
++def test_spectrum_solver_equivalence_to_es(spectrum):
++    """Test equivalence of the spectrum solvers to the base "es" method."""
++    # Jaynes--Cummings model.
++    dimension = 4
++    wc = wa = 1.0 * 2*np.pi
++    g = 0.1 * 2*np.pi
++    kappa = 0.75
++    gamma = 0.25
++    n_th = 0.01
++
++    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
++    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
++    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
++    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
++             np.sqrt(kappa * n_th) * a.dag(),
++             np.sqrt(gamma) * sm.dag()]
++
++    test, frequencies = spectrum(H, c_ops, a.dag(), a)
++    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
++    np.testing.assert_allclose(base, test, atol=1e-3)
++
++
++def _trapz_2d(z, xy):
++    """2D trapezium-method integration assuming a square grid."""
++    dx = xy[1] - xy[0]
++    return dx*dx * np.trapz(np.trapz(z, axis=0))
++
++
++def _n_correlation(times, n):
++    """
++    Numerical integration of the correlation function given an array of
++    expectation values.
++    """
++    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
++                     for t in range(times.shape[0])])
++
++
++def _coefficient_function(t, args):
++    t_off, tp = args['t_off'], args['tp']
++    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
++
++
++_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
++
++
++def _h_qobj_function(t, args):
++    return args['H0'] * _coefficient_function(t, args)
++
++
++# 2LS and 3LS stand for two- and three-level system respectively.
++
++_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
++_2ls_times = np.linspace(0, 5, 51)
++_3ls_args = {'t_off': 2, 'tp': 1}
++_3ls_times = np.linspace(0, 6, 20)
++
++
++def _2ls_g2_0(H, c_ops):
++    sp = qutip.sigmap()
++    start = qutip.basis(2, 0)
++    times = _2ls_times
++    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
++    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
++                                           sp.dag(), sp.dag()*sp, sp,
++                                           args=_2ls_args)
++    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
++                                  e_ops=[qutip.num(2)],
++                                  args=_2ls_args).expect[0]
++    integral_correlation = _trapz_2d(np.real(correlation), times)
++    integral_n_expectation = np.trapz(n_expectation, times)
++    # Factor of two from negative time correlations.
++    return 2 * integral_correlation / integral_n_expectation**2
++
++
++@pytest.fixture(params=[
++    pytest.param(_coefficient_string, id="string"),
++    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
++    pytest.param(_coefficient_function, id="function"),
++])
++def dependence_2ls(request):
++    return request.param
++
++
++class TestTimeDependence:
++    """
++    Test correlations with time-dependent operators using a two-level system
++    (2LS) or a three-level system (3LS).
++    """
++    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
++        H = [[_2ls_args['H0'], dependence_2ls]]
++        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
++
++    def test_hamiltonian_from_function_2ls(self):
++        H = _h_qobj_function
++        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
++
++    @pytest.mark.slow
++    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
++        H = [[_2ls_args['H0'], dependence_2ls]]
++        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
++        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
++
++    @pytest.mark.slow
++    @pytest.mark.parametrize("dependence_3ls", [
++        pytest.param(_coefficient_string, id="string"),
++        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
++        pytest.param(_coefficient_function, id="function"),
++    ])
++    def test_coefficient_c_ops_3ls(self, dependence_3ls):
++        # Calculate zero-delay HOM cross-correlation for incoherently pumped
++        # three-level system, g2_ab[0] with gamma = 1.
++        dimension = 3
++        H = qutip.qzero(dimension)
++        start = qutip.basis(dimension, 2)
++        times = _3ls_times
++        project_0_1 = qutip.projection(dimension, 0, 1)
++        project_1_2 = qutip.projection(dimension, 1, 2)
++        population_1 = qutip.projection(dimension, 1, 1)
++        # Define the pi pulse to be when 99% of the population is transferred.
++        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
++        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
++                                      args=_3ls_args)
++        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
++        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
++                                            project_0_1.dag(), project_0_1,
++                                            args=_3ls_args)
++        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
++                                             project_0_1.dag(), project_0_1,
++                                             args=_3ls_args, reverse=True)
++        times2 = np.concatenate([times, times[1:] + times[-1]])
++        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
++                                 e_ops=[population_1]).expect[0]
++        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
++        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
++        assert abs(g2_ab_0 - 0.185) < 1e-2
++
++
++def _step(t):
++    return np.arctan(t)/np.pi + 0.5
++
++
++def test_hamiltonian_order_unimportant():
++    # Testing for regression on issue 1048.
++    sp = qutip.sigmap()
++    H = [[qutip.sigmax(), lambda t: _step(t-2)],
++         [qutip.qeye(2), lambda t: _step(-(t-2))]]
++    start = qutip.basis(2, 0)
++    times = np.linspace(0, 5, 6)
++    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
++                                        sp.dag(), sp)
++    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
++                                         sp.dag(), sp)
++    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
++
++
++@pytest.mark.parametrize(['solver', 'state'], [
++    pytest.param('me', _equivalence_fock, id="me-ket"),
++    pytest.param('me', _equivalence_coherent, id="me-dm"),
++    pytest.param('me', None, id="me-steady"),
++    pytest.param('es', _equivalence_fock, id="es-ket"),
++    pytest.param('es', _equivalence_coherent, id="es-dm"),
++    pytest.param('es', None, id="es-steady"),
++])
++@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
++                         ids=["hermitian", "nonhermitian"])
++@pytest.mark.parametrize("w", [1, 2])
++@pytest.mark.parametrize("gamma", [1, 10])
++def test_correlation_2op_1t_known_cases(solver,
++                                        state,
++                                        is_e_op_hermitian,
++                                        w,
++                                        gamma,
++                                       ):
++    """This test compares the output correlation_2op_1 solution to an analytical
++    solution."""
++
++    a = qutip.destroy(_equivalence_dimension)
++    x = (a + a.dag())/np.sqrt(2)
++
++    H = w * a.dag() * a
++
++    a_op = x if is_e_op_hermitian else a
++    b_op = x if is_e_op_hermitian else a.dag()
++    c_ops = [np.sqrt(gamma) * a]
++
++    times = np.linspace(0, 1, 30)
++
++    # Handle the case state==None when computing expt values
++    rho0 = state if state else qutip.steadystate(H, c_ops)
++    if is_e_op_hermitian:
++        # Analitycal solution for x,x as operators.
++        base = 0
++        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
++        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
++        base /= np.sqrt(2)
++    else:
++        # Analitycal solution for a,adag as operators.
++        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
++
++    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
++
++    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
++
++
++def test_correlation_timedependant_op():
++    num = qutip.num(2)
++    a = qutip.destroy(2)
++    sx = qutip.sigmax()
++    sz = qutip.sigmaz()
++    times = np.arange(4)
++    # switch between sx and sz at t=1.5
++    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
++
++    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
++    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
++    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
++    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
++    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
++
++
++def test_alternative_solver():
++    from qutip.solver.mesolve import MESolver
++    from qutip.solver.brmesolve import BRSolver
++
++    H = qutip.num(5)
++    a = qutip.destroy(5)
++    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
++
++    br = BRSolver(H, a_ops)
++    me = MESolver(H, [a])
++    times = np.arange(4)
++
++    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
++    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
++
++    np.testing.assert_allclose(br_corr, me_corr)
++
++
++def test_G1():
++    H = qutip.Qobj([[0,1], [1,0]])
++    psi0 = qutip.basis(2)
++    taus = np.linspace(0, 1, 11)
++    scale = 2
++    a_op = qutip.sigmaz() * scale
++    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
++    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
++    np.testing.assert_allclose(g1, expected, rtol=2e-5)
++    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
++
++
++def test_G2():
++    N = 10
++    H = qutip.rand_dm(N)
++    psi0 = qutip.rand_ket(N)
++    taus = np.linspace(0, 1, 11)
++    scale = 2
++    a_op = qutip.rand_unitary(N) * scale
++    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
++    expected = np.ones(11)
++    np.testing.assert_allclose(g1, expected, rtol=2e-5)
++    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
+diff --git a/qutip/tests/solver/test_countstat.py b/qutip/tests/solver/test_countstat.py
+index 6d389b20..130afec6 100644
+--- a/qutip/tests/solver/test_countstat.py
++++ b/qutip/tests/solver/test_countstat.py
+@@ -1,90 +1,90 @@
+-import numpy as np
+-import qutip
+-import pytest
+-
+-
+-@pytest.mark.filterwarnings("ignore::FutureWarning")
+-def test_dqd_current():
+-    "Counting statistics: current and current noise in a DQD model"
+-
+-    G = 0
+-    L = 1
+-    R = 2
+-
+-    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
+-    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
+-    sR = qutip.projection(3, G, R)
+-    sL = qutip.projection(3, G, L)
+-
+-    w0 = 1
+-    tc = 0.6 * w0
+-    GammaR = 0.0075 * w0
+-    GammaL = 0.0075 * w0
+-    nth = 0.00
+-    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
+-
+-    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
+-
+-    c_ops = [
+-        np.sqrt(GammaR * (1 + nth)) * sR,
+-        np.sqrt(GammaR * (nth)) * sR.dag(),
+-        np.sqrt(GammaL * (nth)) * sL,
+-        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
+-    ]
+-
+-    current = np.zeros(len(eps_vec))
+-    noise = np.zeros(len(eps_vec))
+-
+-    for n, eps in enumerate(eps_vec):
+-        H = eps / 2 * sz + tc * sx
+-        L0 = qutip.liouvillian(H)
+-        L = qutip.liouvillian(H, c_ops)
+-        rhoss = qutip.steadystate(L)
+-        current_1, noise_1 = qutip.countstat_current_noise(
+-            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
+-        )
+-        current[n] = current_1[0]
+-        noise[n] = noise_1[0, 0, 0]
+-
+-        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
+-        assert abs(current_1[0] - current_2[0]) < 1e-8
+-
+-        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
+-        assert abs(current_1[0] - current_2[0]) < 1e-8
+-
+-        current_2 = qutip.countstat_current(H, c_ops)
+-        assert abs(current_1[0] - current_2[0]) < 1e-8
+-
+-        current_3, noise_3 = qutip.countstat_current_noise(
+-            L, c_ops, wlist=[0, 1], sparse=False
+-        )
+-        assert abs(current_1[0] - current_3[0]) < 1e-6
+-        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
+-                                   atol=1e-6)
+-
+-    current_target = (
+-        tc**2
+-        * GammaR
+-        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
+-    )
+-    noise_target = current_target * (
+-        1
+-        - (
+-            8
+-            * GammaL
+-            * tc**2
+-            * (
+-                4 * eps_vec**2 * (GammaR - GammaL)
+-                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
+-            )
+-            / (
+-                4 * tc**2 * (2 * GammaL + GammaR)
+-                + GammaL * GammaR**2
+-                + 4 * eps_vec**2 * GammaL
+-            )
+-            ** 2
+-        )
+-    )
+-
+-    np.testing.assert_allclose(current, current_target, atol=1e-4)
+-    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
++import numpy as np
++import qutip
++import pytest
++
++
++@pytest.mark.filterwarnings("ignore::FutureWarning")
++def test_dqd_current():
++    "Counting statistics: current and current noise in a DQD model"
++
++    G = 0
++    L = 1
++    R = 2
++
++    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
++    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
++    sR = qutip.projection(3, G, R)
++    sL = qutip.projection(3, G, L)
++
++    w0 = 1
++    tc = 0.6 * w0
++    GammaR = 0.0075 * w0
++    GammaL = 0.0075 * w0
++    nth = 0.00
++    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
++
++    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
++
++    c_ops = [
++        np.sqrt(GammaR * (1 + nth)) * sR,
++        np.sqrt(GammaR * (nth)) * sR.dag(),
++        np.sqrt(GammaL * (nth)) * sL,
++        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
++    ]
++
++    current = np.zeros(len(eps_vec))
++    noise = np.zeros(len(eps_vec))
++
++    for n, eps in enumerate(eps_vec):
++        H = eps / 2 * sz + tc * sx
++        L0 = qutip.liouvillian(H)
++        L = qutip.liouvillian(H, c_ops)
++        rhoss = qutip.steadystate(L)
++        current_1, noise_1 = qutip.countstat_current_noise(
++            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
++        )
++        current[n] = current_1[0]
++        noise[n] = noise_1[0, 0, 0]
++
++        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
++        assert abs(current_1[0] - current_2[0]) < 1e-8
++
++        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
++        assert abs(current_1[0] - current_2[0]) < 1e-8
++
++        current_2 = qutip.countstat_current(H, c_ops)
++        assert abs(current_1[0] - current_2[0]) < 1e-8
++
++        current_3, noise_3 = qutip.countstat_current_noise(
++            L, c_ops, wlist=[0, 1], sparse=False
++        )
++        assert abs(current_1[0] - current_3[0]) < 1e-6
++        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
++                                   atol=1e-6)
++
++    current_target = (
++        tc**2
++        * GammaR
++        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
++    )
++    noise_target = current_target * (
++        1
++        - (
++            8
++            * GammaL
++            * tc**2
++            * (
++                4 * eps_vec**2 * (GammaR - GammaL)
++                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
++            )
++            / (
++                4 * tc**2 * (2 * GammaL + GammaR)
++                + GammaL * GammaR**2
++                + 4 * eps_vec**2 * GammaL
++            )
++            ** 2
++        )
++    )
++
++    np.testing.assert_allclose(current, current_target, atol=1e-4)
++    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
+diff --git a/qutip/tests/solver/test_floquet.py b/qutip/tests/solver/test_floquet.py
+index be90e6fa..723bf684 100644
+--- a/qutip/tests/solver/test_floquet.py
++++ b/qutip/tests/solver/test_floquet.py
+@@ -1,333 +1,333 @@
+-import numpy as np
+-from qutip import (
+-    sigmax, sigmay, sigmaz,  sigmap, sigmam,
+-    rand_ket, num, destroy,
+-    mesolve, expect, sesolve,
+-    Qobj, QobjEvo, coefficient
+- )
+-
+-from qutip.solver.floquet import (
+-    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
+-    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
+-)
+-import pytest
+-
+-
+-def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
+-    """
+-    Convert e_ops for fmmesolve to mesolve
+-    """
+-    c_op_mesolve = []
+-    N = len(vp)
+-    for i in range(N):
+-        for j in range(N):
+-            if i != j:
+-                # caclculate the rate
+-                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
+-                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
+-                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
+-
+-                # add c_op for mesolve
+-                c_op_mesolve.append(
+-                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
+-                )
+-    return c_op_mesolve
+-
+-
+-class TestFloquet:
+-    """
+-    A test class for the QuTiP functions for Floquet formalism.
+-    """
+-
+-    def testFloquetBasis(self):
+-        N = 10
+-        a = destroy(N)
+-        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
+-        T = 2 * np.pi
+-        floquet_basis = FloquetBasis(H, T)
+-        psi0 = rand_ket(N)
+-        tlist = np.linspace(0, 10, 11)
+-        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
+-        states = sesolve(H, psi0, tlist).states
+-        for t, state in zip(tlist, states):
+-            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
+-            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
+-
+-    def testFloquetUnitary(self):
+-        N = 10
+-        a = destroy(N)
+-        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
+-        T = 2 * np.pi
+-        psi0 = rand_ket(N)
+-        tlist = np.linspace(0, 10, 11)
+-        states_se = sesolve(H, psi0, tlist).states
+-        states_fse = fsesolve(H, psi0, tlist, T=T).states
+-        for state_se, state_fse in zip(states_se, states_fse):
+-            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
+-
+-
+-    def testFloquetMasterEquation1(self):
+-        """
+-        Test Floquet-Markov Master Equation for a driven two-level system
+-        without dissipation.
+-        """
+-        delta = 1.0 * 2 * np.pi
+-        eps0 = 1.0 * 2 * np.pi
+-        A = 0.5 * 2 * np.pi
+-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+-        T = (2 * np.pi) / omega
+-        tlist = np.linspace(0.0, 2 * T, 101)
+-        psi0 = rand_ket(2)
+-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+-        H1 = A / 2.0 * sigmax()
+-        args = {'w': omega}
+-        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
+-        e_ops = [num(2)]
+-        gamma1 = 0
+-
+-        # Collapse operator for Floquet-Markov Master Equation
+-        c_op_fmmesolve = sigmax()
+-
+-        # Collapse operators for Lindblad Master Equation
+-        def spectrum(omega):
+-            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
+-
+-        ep, vp = H0.eigenstates()
+-        op0 = vp[0]*vp[0].dag()
+-        op1 = vp[1]*vp[1].dag()
+-
+-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+-
+-        # Solve the floquet-markov master equation
+-        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
+-                         [spectrum], T, args=args).expect[0]
+-
+-        # Compare with mesolve
+-        p_ex_ref = mesolve(
+-            H, psi0, tlist, c_op_mesolve, [num(2)], args
+-        ).expect[0]
+-
+-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+-
+-    def testFloquetMasterEquation2(self):
+-        """
+-        Test Floquet-Markov Master Equation for a two-level system
+-        subject to dissipation.
+-        """
+-        delta = 1.0 * 2 * np.pi
+-        eps0 = 1.0 * 2 * np.pi
+-        A = 0.0 * 2 * np.pi
+-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+-        T = (2 * np.pi) / omega
+-        tlist = np.linspace(0.0, 2 * T, 101)
+-        psi0 = rand_ket(2)
+-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+-        H1 = A / 2.0 * sigmax()
+-        args = {'w': omega}
+-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+-                    args=args)
+-        e_ops = [num(2)]
+-        gamma1 = 1
+-
+-        # Collapse operator for Floquet-Markov Master Equation
+-        c_op_fmmesolve = sigmax()
+-
+-        # Collapse operator for Lindblad Master Equation
+-        def spectrum(omega):
+-            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
+-
+-        ep, vp = H0.eigenstates()
+-        op0 = vp[0]*vp[0].dag()
+-        op1 = vp[1]*vp[1].dag()
+-
+-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+-
+-        # Solve the floquet-markov master equation
+-        p_ex = fmmesolve(
+-            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
+-            [spectrum], T, args=args
+-        ).expect[0]
+-
+-        # Compare with mesolve
+-        p_ex_ref = mesolve(
+-            H, psi0, tlist, c_op_mesolve, [num(2)], args
+-        ).expect[0]
+-
+-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+-
+-    @pytest.mark.parametrize("kmax", [5, 25, 100])
+-    def testFloquetMasterEquation3(self, kmax):
+-        """
+-        Test Floquet-Markov Master Equation for a two-level system
+-        subject to dissipation with internal transform of fmmesolve
+-        """
+-        delta = 1.0 * 2 * np.pi
+-        eps0 = 1.0 * 2 * np.pi
+-        A = 0.0 * 2 * np.pi
+-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+-        T = (2 * np.pi) / omega
+-        tlist = np.linspace(0.0, 2 * T, 101)
+-        psi0 = rand_ket(2)
+-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+-        H1 = A / 2.0 * sigmax()
+-        args = {'w': omega}
+-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+-                    args=args)
+-        e_ops = [num(2)]
+-        gamma1 = 1
+-
+-        # Collapse operator for Floquet-Markov Master Equation
+-        c_op_fmmesolve = sigmax()
+-
+-        # Collapse operator for Lindblad Master Equation
+-        def spectrum(omega):
+-            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
+-
+-        ep, vp = H0.eigenstates()
+-        op0 = vp[0]*vp[0].dag()
+-        op1 = vp[1]*vp[1].dag()
+-
+-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+-
+-        # Solve the floquet-markov master equation
+-        floquet_basis = FloquetBasis(H, T)
+-        solver = FMESolver(
+-            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
+-        )
+-        solver.start(psi0, tlist[0])
+-        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
+-
+-        # Compare with mesolve
+-        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
+-        p_ex_ref = output2.expect[0]
+-
+-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
+-                                   atol=5 * 1e-4)
+-
+-    def testFloquetMasterEquation_multiple_coupling(self):
+-        """
+-        Test Floquet-Markov Master Equation for a two-level system
+-        subject to dissipation with multiple coupling operators
+-        """
+-        delta = 1.0 * 2 * np.pi
+-        eps0 = 1.0 * 2 * np.pi
+-        A = 0.0 * 2 * np.pi
+-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+-        T = (2 * np.pi) / omega
+-        tlist = np.linspace(0.0, 2 * T, 101)
+-        psi0 = rand_ket(2)
+-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+-        H1 = A / 2.0 * sigmax()
+-        args = {'w': omega}
+-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+-                    args=args)
+-        e_ops = [num(2)]
+-        gamma1 = 1
+-
+-        # Collapse operator for Floquet-Markov Master Equation
+-        c_ops_fmmesolve = [sigmax(), sigmay()]
+-
+-        # Collapse operator for Lindblad Master Equation
+-        def noise_spectrum1(omega):
+-            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
+-
+-        def noise_spectrum2(omega):
+-            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
+-
+-        noise_spectra = [noise_spectrum1, noise_spectrum2]
+-
+-        ep, vp = H0.eigenstates()
+-        op0 = vp[0]*vp[0].dag()
+-        op1 = vp[1]*vp[1].dag()
+-
+-        c_op_mesolve = []
+-
+-        # Convert the c_ops for fmmesolve to c_ops for mesolve
+-        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
+-                                                   noise_spectra):
+-            c_op_mesolve += _convert_c_ops(
+-                c_op_fmmesolve, noise_spectrum, vp, ep
+-            )
+-
+-        # Solve the floquet-markov master equation
+-        output1 = fmmesolve(
+-            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
+-        )
+-        p_ex = output1.expect[0]
+-        # Compare with mesolve
+-        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
+-        p_ex_ref = output2.expect[0]
+-
+-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+-
+-    def testFloquetRates(self):
+-        """
+-        Compare rate transition and frequency transitions to analytical
+-        results for a driven two-level system, for different drive amplitudes.
+-        """
+-        # Parameters
+-        wq = 5.4 * 2 * np.pi
+-        wd = 6.7 * 2 * np.pi
+-        delta = wq - wd
+-        T = 2 * np.pi / wd
+-        tlist = np.linspace(0.0, 2 * T, 101)
+-        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
+-        H0 = Qobj(wq / 2 * sigmaz())
+-        args = {'wd': wd}
+-        c_ops = sigmax()
+-        gamma1 = 1
+-        kmax = 5
+-
+-        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
+-        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
+-        array_ana_delta = [
+-            2 * np.sqrt((delta / 2)**2 + a**2)
+-            for a in array_A
+-        ]
+-
+-        def noise_spectrum(omega):
+-            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
+-
+-        idx = 0
+-        for a in array_A:
+-            # Hamiltonian
+-            H1_p = a * sigmap()
+-            H1_m = a * sigmam()
+-            H = QobjEvo(
+-                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
+-                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
+-            )
+-
+-            floquet_basis = FloquetBasis(H, T)
+-            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
+-            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
+-
+-            # Check energies
+-            deltas = np.ndarray.flatten(DeltaMatrix)
+-
+-            # deltas and array_ana_delta have at least 1 value in common.
+-            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
+-
+-            # Check matrix elements
+-            Xs = np.concatenate(
+-                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
+-            ).flatten()
+-
+-            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
+-            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
+-
+-            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
+-            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
+-            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
+-            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
+-            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
+-            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
+-            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
+-            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
+-            Xpm_p1 = (a / (normMinus * normPlus)
+-                      * (array_ana_E0[idx]- delta / 2))
+-            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
+-            Xpm_m1 = (a / (normMinus * normPlus)
+-                      * (array_ana_E1[idx] - delta / 2))
+-            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
+-            idx += 1
++import numpy as np
++from qutip import (
++    sigmax, sigmay, sigmaz,  sigmap, sigmam,
++    rand_ket, num, destroy,
++    mesolve, expect, sesolve,
++    Qobj, QobjEvo, coefficient
++ )
++
++from qutip.solver.floquet import (
++    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
++    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
++)
++import pytest
++
++
++def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
++    """
++    Convert e_ops for fmmesolve to mesolve
++    """
++    c_op_mesolve = []
++    N = len(vp)
++    for i in range(N):
++        for j in range(N):
++            if i != j:
++                # caclculate the rate
++                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
++                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
++                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
++
++                # add c_op for mesolve
++                c_op_mesolve.append(
++                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
++                )
++    return c_op_mesolve
++
++
++class TestFloquet:
++    """
++    A test class for the QuTiP functions for Floquet formalism.
++    """
++
++    def testFloquetBasis(self):
++        N = 10
++        a = destroy(N)
++        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
++        T = 2 * np.pi
++        floquet_basis = FloquetBasis(H, T)
++        psi0 = rand_ket(N)
++        tlist = np.linspace(0, 10, 11)
++        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
++        states = sesolve(H, psi0, tlist).states
++        for t, state in zip(tlist, states):
++            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
++            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
++
++    def testFloquetUnitary(self):
++        N = 10
++        a = destroy(N)
++        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
++        T = 2 * np.pi
++        psi0 = rand_ket(N)
++        tlist = np.linspace(0, 10, 11)
++        states_se = sesolve(H, psi0, tlist).states
++        states_fse = fsesolve(H, psi0, tlist, T=T).states
++        for state_se, state_fse in zip(states_se, states_fse):
++            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
++
++
++    def testFloquetMasterEquation1(self):
++        """
++        Test Floquet-Markov Master Equation for a driven two-level system
++        without dissipation.
++        """
++        delta = 1.0 * 2 * np.pi
++        eps0 = 1.0 * 2 * np.pi
++        A = 0.5 * 2 * np.pi
++        omega = np.sqrt(delta ** 2 + eps0 ** 2)
++        T = (2 * np.pi) / omega
++        tlist = np.linspace(0.0, 2 * T, 101)
++        psi0 = rand_ket(2)
++        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
++        H1 = A / 2.0 * sigmax()
++        args = {'w': omega}
++        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
++        e_ops = [num(2)]
++        gamma1 = 0
++
++        # Collapse operator for Floquet-Markov Master Equation
++        c_op_fmmesolve = sigmax()
++
++        # Collapse operators for Lindblad Master Equation
++        def spectrum(omega):
++            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
++
++        ep, vp = H0.eigenstates()
++        op0 = vp[0]*vp[0].dag()
++        op1 = vp[1]*vp[1].dag()
++
++        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
++
++        # Solve the floquet-markov master equation
++        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
++                         [spectrum], T, args=args).expect[0]
++
++        # Compare with mesolve
++        p_ex_ref = mesolve(
++            H, psi0, tlist, c_op_mesolve, [num(2)], args
++        ).expect[0]
++
++        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
++
++    def testFloquetMasterEquation2(self):
++        """
++        Test Floquet-Markov Master Equation for a two-level system
++        subject to dissipation.
++        """
++        delta = 1.0 * 2 * np.pi
++        eps0 = 1.0 * 2 * np.pi
++        A = 0.0 * 2 * np.pi
++        omega = np.sqrt(delta ** 2 + eps0 ** 2)
++        T = (2 * np.pi) / omega
++        tlist = np.linspace(0.0, 2 * T, 101)
++        psi0 = rand_ket(2)
++        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
++        H1 = A / 2.0 * sigmax()
++        args = {'w': omega}
++        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
++                    args=args)
++        e_ops = [num(2)]
++        gamma1 = 1
++
++        # Collapse operator for Floquet-Markov Master Equation
++        c_op_fmmesolve = sigmax()
++
++        # Collapse operator for Lindblad Master Equation
++        def spectrum(omega):
++            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
++
++        ep, vp = H0.eigenstates()
++        op0 = vp[0]*vp[0].dag()
++        op1 = vp[1]*vp[1].dag()
++
++        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
++
++        # Solve the floquet-markov master equation
++        p_ex = fmmesolve(
++            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
++            [spectrum], T, args=args
++        ).expect[0]
++
++        # Compare with mesolve
++        p_ex_ref = mesolve(
++            H, psi0, tlist, c_op_mesolve, [num(2)], args
++        ).expect[0]
++
++        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
++
++    @pytest.mark.parametrize("kmax", [5, 25, 100])
++    def testFloquetMasterEquation3(self, kmax):
++        """
++        Test Floquet-Markov Master Equation for a two-level system
++        subject to dissipation with internal transform of fmmesolve
++        """
++        delta = 1.0 * 2 * np.pi
++        eps0 = 1.0 * 2 * np.pi
++        A = 0.0 * 2 * np.pi
++        omega = np.sqrt(delta ** 2 + eps0 ** 2)
++        T = (2 * np.pi) / omega
++        tlist = np.linspace(0.0, 2 * T, 101)
++        psi0 = rand_ket(2)
++        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
++        H1 = A / 2.0 * sigmax()
++        args = {'w': omega}
++        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
++                    args=args)
++        e_ops = [num(2)]
++        gamma1 = 1
++
++        # Collapse operator for Floquet-Markov Master Equation
++        c_op_fmmesolve = sigmax()
++
++        # Collapse operator for Lindblad Master Equation
++        def spectrum(omega):
++            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
++
++        ep, vp = H0.eigenstates()
++        op0 = vp[0]*vp[0].dag()
++        op1 = vp[1]*vp[1].dag()
++
++        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
++
++        # Solve the floquet-markov master equation
++        floquet_basis = FloquetBasis(H, T)
++        solver = FMESolver(
++            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
++        )
++        solver.start(psi0, tlist[0])
++        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
++
++        # Compare with mesolve
++        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
++        p_ex_ref = output2.expect[0]
++
++        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
++                                   atol=5 * 1e-4)
++
++    def testFloquetMasterEquation_multiple_coupling(self):
++        """
++        Test Floquet-Markov Master Equation for a two-level system
++        subject to dissipation with multiple coupling operators
++        """
++        delta = 1.0 * 2 * np.pi
++        eps0 = 1.0 * 2 * np.pi
++        A = 0.0 * 2 * np.pi
++        omega = np.sqrt(delta ** 2 + eps0 ** 2)
++        T = (2 * np.pi) / omega
++        tlist = np.linspace(0.0, 2 * T, 101)
++        psi0 = rand_ket(2)
++        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
++        H1 = A / 2.0 * sigmax()
++        args = {'w': omega}
++        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
++                    args=args)
++        e_ops = [num(2)]
++        gamma1 = 1
++
++        # Collapse operator for Floquet-Markov Master Equation
++        c_ops_fmmesolve = [sigmax(), sigmay()]
++
++        # Collapse operator for Lindblad Master Equation
++        def noise_spectrum1(omega):
++            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
++
++        def noise_spectrum2(omega):
++            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
++
++        noise_spectra = [noise_spectrum1, noise_spectrum2]
++
++        ep, vp = H0.eigenstates()
++        op0 = vp[0]*vp[0].dag()
++        op1 = vp[1]*vp[1].dag()
++
++        c_op_mesolve = []
++
++        # Convert the c_ops for fmmesolve to c_ops for mesolve
++        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
++                                                   noise_spectra):
++            c_op_mesolve += _convert_c_ops(
++                c_op_fmmesolve, noise_spectrum, vp, ep
++            )
++
++        # Solve the floquet-markov master equation
++        output1 = fmmesolve(
++            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
++        )
++        p_ex = output1.expect[0]
++        # Compare with mesolve
++        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
++        p_ex_ref = output2.expect[0]
++
++        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
++
++    def testFloquetRates(self):
++        """
++        Compare rate transition and frequency transitions to analytical
++        results for a driven two-level system, for different drive amplitudes.
++        """
++        # Parameters
++        wq = 5.4 * 2 * np.pi
++        wd = 6.7 * 2 * np.pi
++        delta = wq - wd
++        T = 2 * np.pi / wd
++        tlist = np.linspace(0.0, 2 * T, 101)
++        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
++        H0 = Qobj(wq / 2 * sigmaz())
++        args = {'wd': wd}
++        c_ops = sigmax()
++        gamma1 = 1
++        kmax = 5
++
++        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
++        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
++        array_ana_delta = [
++            2 * np.sqrt((delta / 2)**2 + a**2)
++            for a in array_A
++        ]
++
++        def noise_spectrum(omega):
++            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
++
++        idx = 0
++        for a in array_A:
++            # Hamiltonian
++            H1_p = a * sigmap()
++            H1_m = a * sigmam()
++            H = QobjEvo(
++                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
++                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
++            )
++
++            floquet_basis = FloquetBasis(H, T)
++            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
++            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
++
++            # Check energies
++            deltas = np.ndarray.flatten(DeltaMatrix)
++
++            # deltas and array_ana_delta have at least 1 value in common.
++            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
++
++            # Check matrix elements
++            Xs = np.concatenate(
++                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
++            ).flatten()
++
++            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
++            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
++
++            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
++            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
++            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
++            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
++            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
++            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
++            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
++            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
++            Xpm_p1 = (a / (normMinus * normPlus)
++                      * (array_ana_E0[idx]- delta / 2))
++            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
++            Xpm_m1 = (a / (normMinus * normPlus)
++                      * (array_ana_E1[idx] - delta / 2))
++            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
++            idx += 1
+diff --git a/qutip/tests/solver/test_integrator.py b/qutip/tests/solver/test_integrator.py
+index 8779ea76..5c46c8f3 100644
+--- a/qutip/tests/solver/test_integrator.py
++++ b/qutip/tests/solver/test_integrator.py
+@@ -1,164 +1,164 @@
+-from qutip.solver.sesolve import SESolver
+-from qutip.solver.mesolve import MESolver
+-from qutip.solver.mcsolve import MCSolver
+-from qutip.solver.solver_base import Solver
+-from qutip.solver.integrator import *
+-import qutip
+-import numpy as np
+-from numpy.testing import assert_allclose
+-import pytest
+-
+-
+-class TestIntegratorCte():
+-    _analytical_se = lambda _, t: np.cos(t * np.pi)
+-    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
+-    _analytical_me = lambda _, t: 1 - np.exp(-t)
+-    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
+-                                  c_ops=[qutip.destroy(2)])
+-
+-    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
+-    def se_method(self, request):
+-        return request.param
+-
+-    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
+-    def me_method(self, request):
+-        return request.param
+-
+-    # TODO: Change when the MCSolver is added
+-    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
+-    def mc_method(self, request):
+-        return request.param
+-
+-    def test_se_integration(self, se_method):
+-        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
+-        state0 = qutip.basis(2, 0).data
+-        evol.set_state(0, state0)
+-        for t, state in evol.run(np.linspace(0, 2, 21)):
+-            assert_allclose(self._analytical_se(t),
+-                            state.to_array()[0, 0], atol=2e-5)
+-            assert state.shape == (2, 1)
+-
+-    def test_me_integration(self, me_method):
+-        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
+-        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
+-        evol.set_state(0, state0)
+-        for t in np.linspace(0, 2, 21):
+-            t_, state = evol.integrate(t)
+-            assert t_ == t
+-            assert_allclose(self._analytical_me(t),
+-                            state.to_array()[0, 0], atol=2e-5)
+-
+-    def test_mc_integration(self, mc_method):
+-        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
+-        state = qutip.basis(2,0).data
+-        evol.set_state(0, state)
+-        t = 0
+-        for i in range(1, 21):
+-            t_target = i * 0.05
+-            while t < t_target:
+-                t_old, y_old = evol.get_state()
+-                t, state = evol.mcstep(t_target)
+-                assert t <= t_target
+-                assert t > t_old
+-                assert_allclose(self._analytical_se(t),
+-                                state.to_array()[0, 0], atol=2e-5)
+-                t_back = (t + t_old) / 2
+-                t_got, bstate = evol.mcstep(t_back)
+-                assert t_back == t_got
+-                assert_allclose(self._analytical_se(t),
+-                                state.to_array()[0, 0], atol=2e-5)
+-                t, state = evol.mcstep(t)
+-
+-
+-    @pytest.mark.parametrize('start', [1, -1])
+-    def test_mc_integration_mixed(self, start, mc_method):
+-        system = qutip.QobjEvo(qutip.qeye(1))
+-        evol = Solver.avail_integrators()[mc_method](system, {})
+-
+-        state = qutip.basis(1,0).data
+-        evol.set_state(start, state)
+-        t = start
+-        t_target = start + .1
+-        while t < t_target:
+-            t, _ = evol.mcstep(start + .1)
+-        _ = evol.mcstep(start + .2)
+-        t_target = (start + .1 + t) / 2
+-        t, state = evol.mcstep(t_target)
+-        assert (
+-            state.to_array()[0, 0]
+-            == pytest.approx(np.exp(t - start), abs=1e-5)
+-        )
+-
+-
+-class TestIntegrator(TestIntegratorCte):
+-    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
+-    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
+-    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
+-    me_system = qutip.liouvillian(
+-        qutip.QobjEvo(qutip.qeye(2)),
+-        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
+-    )
+-
+-    @pytest.fixture(
+-        params=[key for key, integrator in SESolver.avail_integrators().items()
+-                if integrator.support_time_dependant]
+-    )
+-    def se_method(self, request):
+-        return request.param
+-
+-    @pytest.fixture(
+-        params=[key for key, integrator in MESolver.avail_integrators().items()
+-                if integrator.support_time_dependant]
+-    )
+-    def me_method(self, request):
+-        return request.param
+-
+-    @pytest.fixture(
+-        params=[key for key, integrator in MCSolver.avail_integrators().items()
+-                if integrator.support_time_dependant]
+-    )
+-    def mc_method(self, request):
+-        return request.param
+-
+-
+-@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
+-                     ids=["large", "multiple subspaces", "diagonal"])
+-def test_krylov(sizes):
+-    # Krylov solve act differently for large systems composed tensored
+-    # sub systems.
+-    N, M = sizes
+-    H = qutip.qeye(N)
+-    if M:
+-        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
+-    H = qutip.QobjEvo(-1j * H)
+-    integrator = IntegratorKrylov(H, {})
+-    ref_integrator = IntegratorDiag(H, {})
+-    psi = qutip.basis(100, 95).data
+-    integrator.set_state(0, psi)
+-    ref_integrator.set_state(0, psi)
+-    for t in np.linspace(0.25, 1, 4):
+-        out = integrator.integrate(t)[1]
+-        ref = ref_integrator.integrate(t)[1]
+-        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
+-
+-
+-@pytest.mark.parametrize('integrator',
+-    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
+-    ids=["adams", 'bdf', "lsoda"]
+-)
+-def test_concurent_usage(integrator):
+-    opt = {'atol':1e-10, 'rtol':1e-7}
+-
+-    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
+-    inter1 = integrator(sys1, opt)
+-    inter1.set_state(0, qutip.basis(1,0).data)
+-
+-    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
+-    inter2 = integrator(sys2, opt)
+-    inter2.set_state(0, qutip.basis(1,0).data)
+-
+-    for t in np.linspace(0,1,6):
+-        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
+-        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
+-        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
+-        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
++from qutip.solver.sesolve import SESolver
++from qutip.solver.mesolve import MESolver
++from qutip.solver.mcsolve import MCSolver
++from qutip.solver.solver_base import Solver
++from qutip.solver.integrator import *
++import qutip
++import numpy as np
++from numpy.testing import assert_allclose
++import pytest
++
++
++class TestIntegratorCte():
++    _analytical_se = lambda _, t: np.cos(t * np.pi)
++    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
++    _analytical_me = lambda _, t: 1 - np.exp(-t)
++    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
++                                  c_ops=[qutip.destroy(2)])
++
++    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
++    def se_method(self, request):
++        return request.param
++
++    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
++    def me_method(self, request):
++        return request.param
++
++    # TODO: Change when the MCSolver is added
++    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
++    def mc_method(self, request):
++        return request.param
++
++    def test_se_integration(self, se_method):
++        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
++        state0 = qutip.basis(2, 0).data
++        evol.set_state(0, state0)
++        for t, state in evol.run(np.linspace(0, 2, 21)):
++            assert_allclose(self._analytical_se(t),
++                            state.to_array()[0, 0], atol=2e-5)
++            assert state.shape == (2, 1)
++
++    def test_me_integration(self, me_method):
++        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
++        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
++        evol.set_state(0, state0)
++        for t in np.linspace(0, 2, 21):
++            t_, state = evol.integrate(t)
++            assert t_ == t
++            assert_allclose(self._analytical_me(t),
++                            state.to_array()[0, 0], atol=2e-5)
++
++    def test_mc_integration(self, mc_method):
++        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
++        state = qutip.basis(2,0).data
++        evol.set_state(0, state)
++        t = 0
++        for i in range(1, 21):
++            t_target = i * 0.05
++            while t < t_target:
++                t_old, y_old = evol.get_state()
++                t, state = evol.mcstep(t_target)
++                assert t <= t_target
++                assert t > t_old
++                assert_allclose(self._analytical_se(t),
++                                state.to_array()[0, 0], atol=2e-5)
++                t_back = (t + t_old) / 2
++                t_got, bstate = evol.mcstep(t_back)
++                assert t_back == t_got
++                assert_allclose(self._analytical_se(t),
++                                state.to_array()[0, 0], atol=2e-5)
++                t, state = evol.mcstep(t)
++
++
++    @pytest.mark.parametrize('start', [1, -1])
++    def test_mc_integration_mixed(self, start, mc_method):
++        system = qutip.QobjEvo(qutip.qeye(1))
++        evol = Solver.avail_integrators()[mc_method](system, {})
++
++        state = qutip.basis(1,0).data
++        evol.set_state(start, state)
++        t = start
++        t_target = start + .1
++        while t < t_target:
++            t, _ = evol.mcstep(start + .1)
++        _ = evol.mcstep(start + .2)
++        t_target = (start + .1 + t) / 2
++        t, state = evol.mcstep(t_target)
++        assert (
++            state.to_array()[0, 0]
++            == pytest.approx(np.exp(t - start), abs=1e-5)
++        )
++
++
++class TestIntegrator(TestIntegratorCte):
++    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
++    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
++    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
++    me_system = qutip.liouvillian(
++        qutip.QobjEvo(qutip.qeye(2)),
++        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
++    )
++
++    @pytest.fixture(
++        params=[key for key, integrator in SESolver.avail_integrators().items()
++                if integrator.support_time_dependant]
++    )
++    def se_method(self, request):
++        return request.param
++
++    @pytest.fixture(
++        params=[key for key, integrator in MESolver.avail_integrators().items()
++                if integrator.support_time_dependant]
++    )
++    def me_method(self, request):
++        return request.param
++
++    @pytest.fixture(
++        params=[key for key, integrator in MCSolver.avail_integrators().items()
++                if integrator.support_time_dependant]
++    )
++    def mc_method(self, request):
++        return request.param
++
++
++@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
++                     ids=["large", "multiple subspaces", "diagonal"])
++def test_krylov(sizes):
++    # Krylov solve act differently for large systems composed tensored
++    # sub systems.
++    N, M = sizes
++    H = qutip.qeye(N)
++    if M:
++        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
++    H = qutip.QobjEvo(-1j * H)
++    integrator = IntegratorKrylov(H, {})
++    ref_integrator = IntegratorDiag(H, {})
++    psi = qutip.basis(100, 95).data
++    integrator.set_state(0, psi)
++    ref_integrator.set_state(0, psi)
++    for t in np.linspace(0.25, 1, 4):
++        out = integrator.integrate(t)[1]
++        ref = ref_integrator.integrate(t)[1]
++        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
++
++
++@pytest.mark.parametrize('integrator',
++    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
++    ids=["adams", 'bdf', "lsoda"]
++)
++def test_concurent_usage(integrator):
++    opt = {'atol':1e-10, 'rtol':1e-7}
++
++    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
++    inter1 = integrator(sys1, opt)
++    inter1.set_state(0, qutip.basis(1,0).data)
++
++    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
++    inter2 = integrator(sys2, opt)
++    inter2.set_state(0, qutip.basis(1,0).data)
++
++    for t in np.linspace(0,1,6):
++        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
++        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
++        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
++        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
+diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
+index be5b5b3b..840f7337 100644
+--- a/qutip/tests/solver/test_mcsolve.py
++++ b/qutip/tests/solver/test_mcsolve.py
+@@ -1,439 +1,439 @@
+-import pytest
+-import numpy as np
+-import qutip
+-from copy import copy
+-from qutip.solver.mcsolve import mcsolve, MCSolver
+-from qutip.solver.solver_base import Solver
+-
+-def _return_constant(t, args):
+-    return args['constant']
+-
+-
+-def _return_decay(t, args):
+-    return args['constant'] * np.exp(-args['rate'] * t)
+-
+-
+-class callable_qobj:
+-    def __init__(self, oper, coeff=None):
+-        self.oper = oper
+-        self.coeff = coeff
+-
+-    def __call__(self, t, args):
+-        if self.coeff is not None:
+-            return self.oper * self.coeff(t, args)
+-        return self.oper
+-
+-
+-@pytest.mark.usefixtures("in_temporary_directory")
+-class StatesAndExpectOutputCase:
+-    """
+-    Mixin class to test the states and expectation values from ``mcsolve``.
+-    """
+-    size = 10
+-    h = qutip.num(size)
+-    state = qutip.basis(size, size-1)
+-    times = np.linspace(0, 1, 101)
+-    e_ops = [qutip.num(size)]
+-    ntraj = 2000
+-
+-    def _assert_states(self, result, expected, tol):
+-        assert hasattr(result, 'states')
+-        assert len(result.states) == len(self.times)
+-        assert len(self.e_ops) == len(expected)
+-        for test_operator, expected_part in zip(self.e_ops, expected):
+-            test = qutip.expect(test_operator, result.states)
+-            np.testing.assert_allclose(test, expected_part, rtol=tol)
+-
+-    def _assert_expect(self, result, expected, tol):
+-        assert hasattr(result, 'expect')
+-        assert len(result.expect) == len(self.e_ops)
+-        assert len(self.e_ops) == len(expected)
+-        for test, expected_part in zip(result.expect, expected):
+-            np.testing.assert_allclose(test, expected_part, rtol=tol)
+-
+-    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
+-        options = {"store_states": True, "map": "serial"}
+-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+-                         options=options, target_tol=0.05)
+-        self._assert_expect(result, expected, tol)
+-        self._assert_states(result, expected, tol)
+-
+-
+-class TestNoCollapse(StatesAndExpectOutputCase):
+-    """
+-    Test that `mcsolve` correctly solves the system when there is a constant
+-    Hamiltonian and no collapses.
+-    """
+-    def pytest_generate_tests(self, metafunc):
+-        tol = 1e-8
+-        expect = (qutip.expect(self.e_ops[0], self.state)
+-                  * np.ones_like(self.times))
+-        hamiltonian_types = [
+-            (self.h, "Qobj"),
+-            ([self.h], "list"),
+-            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
+-                           args= {'constant': 0}), "QobjEvo"),
+-            (callable_qobj(self.h), "callable"),
+-        ]
+-        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
+-                 for hamiltonian, id in hamiltonian_types]
+-        metafunc.parametrize(
+-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+-            cases)
+-
+-    # Previously the "states_only" and "expect_only" tests were mixed in to
+-    # every other test case.  We move them out into the simplest set so that
+-    # their behaviour remains tested, but isn't repeated as often to keep test
+-    # runtimes shorter.  The known-good cases are still tested in the other
+-    # test cases, this is just testing the single-output behaviour.
+-
+-    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
+-        options = {"store_states": True, "map": "serial"}
+-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+-                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
+-                         options=options)
+-        self._assert_states(result, expected, tol)
+-
+-    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
+-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+-                         options={'map': 'serial'})
+-        self._assert_expect(result, expected, tol)
+-
+-
+-class TestConstantCollapse(StatesAndExpectOutputCase):
+-    """
+-    Test that `mcsolve` correctly solves the system when there is a constant
+-    collapse operator.
+-    """
+-    def pytest_generate_tests(self, metafunc):
+-        tol = 0.25
+-        coupling = 0.2
+-        expect = (qutip.expect(self.e_ops[0], self.state)
+-                  * np.exp(-coupling * self.times))
+-        collapse_op = qutip.destroy(self.size)
+-        c_op_types = [
+-            (np.sqrt(coupling)*collapse_op, {}, "constant"),
+-            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
+-            (callable_qobj(collapse_op, _return_constant),
+-             {'constant': np.sqrt(coupling)}, "function"),
+-        ]
+-        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
+-                 for c_op, args, id in c_op_types]
+-        metafunc.parametrize(
+-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+-            cases)
+-
+-
+-class TestTimeDependentCollapse(StatesAndExpectOutputCase):
+-    """
+-    Test that `mcsolve` correctly solves the system when the collapse operators
+-    are time-dependent.
+-    """
+-    def pytest_generate_tests(self, metafunc):
+-        tol = 0.25
+-        coupling = 0.2
+-        expect = (qutip.expect(self.e_ops[0], self.state)
+-                  * np.exp(-coupling * (1 - np.exp(-self.times))))
+-        collapse_op = qutip.destroy(self.size)
+-        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
+-        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
+-        c_op_types = [
+-            ([collapse_op, _return_decay], collapse_args, "function"),
+-            ([collapse_op, collapse_string], {}, "string"),
+-        ]
+-        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
+-                 for c_op, args, id in c_op_types]
+-        metafunc.parametrize(
+-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+-            cases)
+-
+-
+-def test_stored_collapse_operators_and_times():
+-    """
+-    Test that the output contains information on which collapses happened and
+-    at what times, and make sure that this information makes sense.
+-    """
+-    size = 10
+-    a = qutip.destroy(size)
+-    H = qutip.num(size)
+-    state = qutip.basis(size, size-1)
+-    times = np.linspace(0, 10, 100)
+-    c_ops = [a, a]
+-    result = mcsolve(H, state, times, c_ops, ntraj=3,
+-                     options={'map': 'serial'})
+-    assert len(result.col_times[0]) > 0
+-    assert len(result.col_which) == len(result.col_times)
+-    assert all(col in [0, 1] for col in result.col_which[0])
+-
+-
+-@pytest.mark.parametrize('keep_runs_results', [True, False])
+-def test_states_outputs(keep_runs_results):
+-    # We're just testing the output value, so it's important whether certain
+-    # things are complex or real, but not what the magnitudes of constants are.
+-    focks = 5
+-    ntraj = 5
+-    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+-    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+-    H = 1j*a.dag()*sm + a
+-    H = H + H.dag()
+-    state = qutip.basis([focks, 2], [0, 1])
+-    times = np.linspace(0, 10, 21)
+-    c_ops = [a, sm]
+-    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
+-                   options={"keep_runs_results": keep_runs_results,
+-                            'map': 'serial'})
+-
+-    assert len(data.average_states) == len(times)
+-    assert isinstance(data.average_states[0], qutip.Qobj)
+-    assert data.average_states[0].norm() == pytest.approx(1.)
+-    assert data.average_states[0].isoper
+-
+-    assert isinstance(data.average_final_state, qutip.Qobj)
+-    assert data.average_final_state.norm() == pytest.approx(1.)
+-    assert data.average_final_state.isoper
+-
+-    assert isinstance(data.photocurrent[0][1], float)
+-    assert isinstance(data.photocurrent[1][1], float)
+-    assert (np.array(data.runs_photocurrent).shape
+-        == (ntraj, len(c_ops), len(times)-1))
+-
+-    if keep_runs_results:
+-        assert len(data.runs_states) == ntraj
+-        assert len(data.runs_states[0]) == len(times)
+-        assert isinstance(data.runs_states[0][0], qutip.Qobj)
+-        assert data.runs_states[0][0].norm() == pytest.approx(1.)
+-        assert data.runs_states[0][0].isket
+-
+-        assert len(data.runs_final_states) == ntraj
+-        assert isinstance(data.runs_final_states[0], qutip.Qobj)
+-        assert data.runs_final_states[0].norm() == pytest.approx(1.)
+-        assert data.runs_final_states[0].isket
+-
+-    assert isinstance(data.steady_state(), qutip.Qobj)
+-    assert data.steady_state().norm() == pytest.approx(1.)
+-    assert data.steady_state().isoper
+-
+-    np.testing.assert_allclose(times, data.times)
+-    assert data.num_trajectories == ntraj
+-    assert len(data.e_ops) == 0
+-    assert data.stats["num_collapse"] == len(c_ops)
+-    assert len(data.col_times) == ntraj
+-    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
+-    assert data.stats['end_condition'] == "ntraj reached"
+-
+-
+-@pytest.mark.parametrize('keep_runs_results', [True, False])
+-def test_expectation_outputs(keep_runs_results):
+-    # We're just testing the output value, so it's important whether certain
+-    # things are complex or real, but not what the magnitudes of constants are.
+-    focks = 5
+-    ntraj = 5
+-    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+-    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+-    H = 1j*a.dag()*sm + a
+-    H = H + H.dag()
+-    state = qutip.basis([focks, 2], [0, 1])
+-    times = np.linspace(0, 10, 5)
+-    c_ops = [a, sm]
+-    e_ops = [a.dag()*a, sm.dag()*sm, a]
+-    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+-                   options={"keep_runs_results": keep_runs_results,
+-                            'map': 'serial'})
+-    assert isinstance(data.average_expect[0][1], float)
+-    assert isinstance(data.average_expect[1][1], float)
+-    assert isinstance(data.average_expect[2][1], complex)
+-    assert isinstance(data.std_expect[0][1], float)
+-    assert isinstance(data.std_expect[1][1], float)
+-    assert isinstance(data.std_expect[2][1], float)
+-    if keep_runs_results:
+-        assert len(data.runs_expect) == len(e_ops)
+-        assert len(data.runs_expect[0]) == ntraj
+-        assert isinstance(data.runs_expect[0][0][1], float)
+-        assert isinstance(data.runs_expect[1][0][1], float)
+-        assert isinstance(data.runs_expect[2][0][1], complex)
+-    assert isinstance(data.photocurrent[0][0], float)
+-    assert isinstance(data.photocurrent[1][0], float)
+-    assert (np.array(data.runs_photocurrent).shape
+-            == (ntraj, len(c_ops), len(times)-1))
+-    np.testing.assert_allclose(times, data.times)
+-    assert data.num_trajectories == ntraj
+-    assert len(data.e_ops) == len(e_ops)
+-    assert data.stats["num_collapse"] == len(c_ops)
+-    assert len(data.col_times) == ntraj
+-    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
+-    assert data.stats['end_condition'] == "ntraj reached"
+-
+-
+-class TestSeeds:
+-    sizes = [6, 6, 6]
+-    dampings = [0.1, 0.4, 0.1]
+-    ntraj = 25  # Big enough to ensure there are differences without being slow
+-    a = [qutip.destroy(size) for size in sizes]
+-    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
+-              - qutip.tensor(a[0].dag(), a[1], a[2]))
+-    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
+-                         qutip.basis(sizes[1:], [0, 0]))
+-    times = np.linspace(0, 10, 2)
+-    c_ops = [
+-        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
+-        (np.sqrt(2*dampings[1])
+-         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
+-        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
+-    ]
+-
+-    def test_seeds_can_be_reused(self):
+-        args = (self.H, self.state, self.times)
+-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+-        first = mcsolve(*args, **kwargs)
+-        second = mcsolve(*args, seeds=first.seeds, **kwargs)
+-        for first_t, second_t in zip(first.col_times, second.col_times):
+-            np.testing.assert_equal(first_t, second_t)
+-        for first_w, second_w in zip(first.col_which, second.col_which):
+-            np.testing.assert_equal(first_w, second_w)
+-
+-    def test_seeds_are_not_reused_by_default(self):
+-        args = (self.H, self.state, self.times)
+-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+-        first = mcsolve(*args, **kwargs)
+-        second = mcsolve(*args, **kwargs)
+-        assert not all(np.array_equal(first_t, second_t)
+-                       for first_t, second_t in zip(first.col_times,
+-                                                    second.col_times))
+-        assert not all(np.array_equal(first_w, second_w)
+-                       for first_w, second_w in zip(first.col_which,
+-                                                    second.col_which))
+-
+-    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
+-    def test_seed_type(self, seed):
+-        args = (self.H, self.state, self.times)
+-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+-        first = mcsolve(*args, seeds=copy(seed), **kwargs)
+-        second = mcsolve(*args, seeds=copy(seed), **kwargs)
+-        for f_seed, s_seed in zip(first.seeds, second.seeds):
+-            assert f_seed.state == s_seed.state
+-
+-    def test_bad_seed(self):
+-        args = (self.H, self.state, self.times)
+-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+-        with pytest.raises(ValueError):
+-            first = mcsolve(*args, seeds=[1], **kwargs)
+-
+-    def test_generator(self):
+-        args = (self.H, self.state, self.times)
+-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+-        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
+-                        **kwargs)
+-        second = mcsolve(*args, seeds=1, **kwargs)
+-        for f_seed, s_seed in zip(first.seeds, second.seeds):
+-            assert f_seed.state == s_seed.state
+-        assert not all(np.array_equal(first_t, second_t)
+-                       for first_t, second_t in zip(first.col_times,
+-                                                    second.col_times))
+-        assert not all(np.array_equal(first_w, second_w)
+-                       for first_w, second_w in zip(first.col_which,
+-                                                    second.col_which))
+-
+-    def test_stepping(self):
+-        size = 10
+-        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
+-        H = qutip.num(size)
+-        mcsolver = MCSolver(H, a, options={'map': 'serial'})
+-        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+-        state_1 = mcsolver.step(1, args={'alpha':1})
+-
+-        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+-        state_2 = mcsolver.step(1, args={'alpha':1})
+-        assert state_1 == state_2
+-
+-
+-def test_timeout():
+-    size = 10
+-    ntraj = 1000
+-    a = qutip.destroy(size)
+-    H = qutip.num(size)
+-    state = qutip.basis(size, size-1)
+-    times = np.linspace(0, 1.0, 100)
+-    coupling = 0.5
+-    n_th = 0.05
+-    c_ops = np.sqrt(coupling * (n_th + 1)) * a
+-    e_ops = [qutip.num(size)]
+-    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+-                  options={'map': 'serial'}, timeout=1e-6)
+-    assert res.stats['end_condition'] == 'timeout'
+-
+-
+-def test_super_H():
+-    size = 10
+-    ntraj = 1000
+-    a = qutip.destroy(size)
+-    H = qutip.num(size)
+-    state = qutip.basis(size, size-1)
+-    times = np.linspace(0, 1.0, 100)
+-    # Arbitrary coupling and bath temperature.
+-    coupling = 0.5
+-    n_th = 0.05
+-    c_ops = np.sqrt(coupling * (n_th + 1)) * a
+-    e_ops = [qutip.num(size)]
+-    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+-                          target_tol=0.1, options={'map': 'serial'})
+-    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
+-                 target_tol=0.1, options={'map': 'serial'})
+-    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
+-
+-
+-def test_MCSolver_run():
+-    size = 10
+-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+-    H = qutip.num(size)
+-    solver = MCSolver(H, a)
+-    solver.options = {'store_final_state': True}
+-    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+-                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
+-    assert res.final_state is not None
+-    assert len(res.collapse[0]) != 0
+-    assert res.num_trajectories == 1
+-    np.testing.assert_allclose(res.expect[0], np.ones(11))
+-    res += solver.run(
+-        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+-        e_ops=[qutip.qeye(size)], args={'coupling': 1},
+-        ntraj=1000, target_tol=0.1
+-    )
+-    assert res.num_trajectories == 1001
+-
+-
+-def test_MCSolver_stepping():
+-    size = 10
+-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+-    H = qutip.num(size)
+-    solver = MCSolver(H, a)
+-    solver.start(qutip.basis(size, size-1), 0, seed=0)
+-    solver.options = {'method': 'lsoda'}
+-    state = solver.step(1)
+-    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+-    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
+-    assert state.isket
+-    state = solver.step(5, args={'coupling': 5})
+-    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+-    assert qutip.expect(qutip.num(size), state) <= size - 1
+-    assert state.isket
+-
+-
+-# Defined in module-scope so it's pickleable.
+-def _dynamic(t, args):
+-    return 0 if args["collapse"] else 1
+-
+-
+-@pytest.mark.xfail(reason="current limitation of McSolve")
+-def test_dynamic_arguments():
+-    """Test dynamically updated arguments are usable."""
+-    size = 5
+-    a = qutip.destroy(size)
+-    H = qutip.num(size)
+-    times = np.linspace(0, 1, 11)
+-    state = qutip.basis(size, 2)
+-
+-    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
+-    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
+-    assert all(len(collapses) <= 1 for collapses in mc.col_which)
++import pytest
++import numpy as np
++import qutip
++from copy import copy
++from qutip.solver.mcsolve import mcsolve, MCSolver
++from qutip.solver.solver_base import Solver
++
++def _return_constant(t, args):
++    return args['constant']
++
++
++def _return_decay(t, args):
++    return args['constant'] * np.exp(-args['rate'] * t)
++
++
++class callable_qobj:
++    def __init__(self, oper, coeff=None):
++        self.oper = oper
++        self.coeff = coeff
++
++    def __call__(self, t, args):
++        if self.coeff is not None:
++            return self.oper * self.coeff(t, args)
++        return self.oper
++
++
++@pytest.mark.usefixtures("in_temporary_directory")
++class StatesAndExpectOutputCase:
++    """
++    Mixin class to test the states and expectation values from ``mcsolve``.
++    """
++    size = 10
++    h = qutip.num(size)
++    state = qutip.basis(size, size-1)
++    times = np.linspace(0, 1, 101)
++    e_ops = [qutip.num(size)]
++    ntraj = 2000
++
++    def _assert_states(self, result, expected, tol):
++        assert hasattr(result, 'states')
++        assert len(result.states) == len(self.times)
++        assert len(self.e_ops) == len(expected)
++        for test_operator, expected_part in zip(self.e_ops, expected):
++            test = qutip.expect(test_operator, result.states)
++            np.testing.assert_allclose(test, expected_part, rtol=tol)
++
++    def _assert_expect(self, result, expected, tol):
++        assert hasattr(result, 'expect')
++        assert len(result.expect) == len(self.e_ops)
++        assert len(self.e_ops) == len(expected)
++        for test, expected_part in zip(result.expect, expected):
++            np.testing.assert_allclose(test, expected_part, rtol=tol)
++
++    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
++        options = {"store_states": True, "map": "serial"}
++        result = mcsolve(hamiltonian, self.state, self.times, args=args,
++                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
++                         options=options, target_tol=0.05)
++        self._assert_expect(result, expected, tol)
++        self._assert_states(result, expected, tol)
++
++
++class TestNoCollapse(StatesAndExpectOutputCase):
++    """
++    Test that `mcsolve` correctly solves the system when there is a constant
++    Hamiltonian and no collapses.
++    """
++    def pytest_generate_tests(self, metafunc):
++        tol = 1e-8
++        expect = (qutip.expect(self.e_ops[0], self.state)
++                  * np.ones_like(self.times))
++        hamiltonian_types = [
++            (self.h, "Qobj"),
++            ([self.h], "list"),
++            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
++                           args= {'constant': 0}), "QobjEvo"),
++            (callable_qobj(self.h), "callable"),
++        ]
++        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
++                 for hamiltonian, id in hamiltonian_types]
++        metafunc.parametrize(
++            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
++            cases)
++
++    # Previously the "states_only" and "expect_only" tests were mixed in to
++    # every other test case.  We move them out into the simplest set so that
++    # their behaviour remains tested, but isn't repeated as often to keep test
++    # runtimes shorter.  The known-good cases are still tested in the other
++    # test cases, this is just testing the single-output behaviour.
++
++    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
++        options = {"store_states": True, "map": "serial"}
++        result = mcsolve(hamiltonian, self.state, self.times, args=args,
++                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
++                         options=options)
++        self._assert_states(result, expected, tol)
++
++    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
++        result = mcsolve(hamiltonian, self.state, self.times, args=args,
++                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
++                         options={'map': 'serial'})
++        self._assert_expect(result, expected, tol)
++
++
++class TestConstantCollapse(StatesAndExpectOutputCase):
++    """
++    Test that `mcsolve` correctly solves the system when there is a constant
++    collapse operator.
++    """
++    def pytest_generate_tests(self, metafunc):
++        tol = 0.25
++        coupling = 0.2
++        expect = (qutip.expect(self.e_ops[0], self.state)
++                  * np.exp(-coupling * self.times))
++        collapse_op = qutip.destroy(self.size)
++        c_op_types = [
++            (np.sqrt(coupling)*collapse_op, {}, "constant"),
++            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
++            (callable_qobj(collapse_op, _return_constant),
++             {'constant': np.sqrt(coupling)}, "function"),
++        ]
++        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
++                 for c_op, args, id in c_op_types]
++        metafunc.parametrize(
++            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
++            cases)
++
++
++class TestTimeDependentCollapse(StatesAndExpectOutputCase):
++    """
++    Test that `mcsolve` correctly solves the system when the collapse operators
++    are time-dependent.
++    """
++    def pytest_generate_tests(self, metafunc):
++        tol = 0.25
++        coupling = 0.2
++        expect = (qutip.expect(self.e_ops[0], self.state)
++                  * np.exp(-coupling * (1 - np.exp(-self.times))))
++        collapse_op = qutip.destroy(self.size)
++        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
++        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
++        c_op_types = [
++            ([collapse_op, _return_decay], collapse_args, "function"),
++            ([collapse_op, collapse_string], {}, "string"),
++        ]
++        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
++                 for c_op, args, id in c_op_types]
++        metafunc.parametrize(
++            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
++            cases)
++
++
++def test_stored_collapse_operators_and_times():
++    """
++    Test that the output contains information on which collapses happened and
++    at what times, and make sure that this information makes sense.
++    """
++    size = 10
++    a = qutip.destroy(size)
++    H = qutip.num(size)
++    state = qutip.basis(size, size-1)
++    times = np.linspace(0, 10, 100)
++    c_ops = [a, a]
++    result = mcsolve(H, state, times, c_ops, ntraj=3,
++                     options={'map': 'serial'})
++    assert len(result.col_times[0]) > 0
++    assert len(result.col_which) == len(result.col_times)
++    assert all(col in [0, 1] for col in result.col_which[0])
++
++
++@pytest.mark.parametrize('keep_runs_results', [True, False])
++def test_states_outputs(keep_runs_results):
++    # We're just testing the output value, so it's important whether certain
++    # things are complex or real, but not what the magnitudes of constants are.
++    focks = 5
++    ntraj = 5
++    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
++    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
++    H = 1j*a.dag()*sm + a
++    H = H + H.dag()
++    state = qutip.basis([focks, 2], [0, 1])
++    times = np.linspace(0, 10, 21)
++    c_ops = [a, sm]
++    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
++                   options={"keep_runs_results": keep_runs_results,
++                            'map': 'serial'})
++
++    assert len(data.average_states) == len(times)
++    assert isinstance(data.average_states[0], qutip.Qobj)
++    assert data.average_states[0].norm() == pytest.approx(1.)
++    assert data.average_states[0].isoper
++
++    assert isinstance(data.average_final_state, qutip.Qobj)
++    assert data.average_final_state.norm() == pytest.approx(1.)
++    assert data.average_final_state.isoper
++
++    assert isinstance(data.photocurrent[0][1], float)
++    assert isinstance(data.photocurrent[1][1], float)
++    assert (np.array(data.runs_photocurrent).shape
++        == (ntraj, len(c_ops), len(times)-1))
++
++    if keep_runs_results:
++        assert len(data.runs_states) == ntraj
++        assert len(data.runs_states[0]) == len(times)
++        assert isinstance(data.runs_states[0][0], qutip.Qobj)
++        assert data.runs_states[0][0].norm() == pytest.approx(1.)
++        assert data.runs_states[0][0].isket
++
++        assert len(data.runs_final_states) == ntraj
++        assert isinstance(data.runs_final_states[0], qutip.Qobj)
++        assert data.runs_final_states[0].norm() == pytest.approx(1.)
++        assert data.runs_final_states[0].isket
++
++    assert isinstance(data.steady_state(), qutip.Qobj)
++    assert data.steady_state().norm() == pytest.approx(1.)
++    assert data.steady_state().isoper
++
++    np.testing.assert_allclose(times, data.times)
++    assert data.num_trajectories == ntraj
++    assert len(data.e_ops) == 0
++    assert data.stats["num_collapse"] == len(c_ops)
++    assert len(data.col_times) == ntraj
++    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
++    assert data.stats['end_condition'] == "ntraj reached"
++
++
++@pytest.mark.parametrize('keep_runs_results', [True, False])
++def test_expectation_outputs(keep_runs_results):
++    # We're just testing the output value, so it's important whether certain
++    # things are complex or real, but not what the magnitudes of constants are.
++    focks = 5
++    ntraj = 5
++    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
++    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
++    H = 1j*a.dag()*sm + a
++    H = H + H.dag()
++    state = qutip.basis([focks, 2], [0, 1])
++    times = np.linspace(0, 10, 5)
++    c_ops = [a, sm]
++    e_ops = [a.dag()*a, sm.dag()*sm, a]
++    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
++                   options={"keep_runs_results": keep_runs_results,
++                            'map': 'serial'})
++    assert isinstance(data.average_expect[0][1], float)
++    assert isinstance(data.average_expect[1][1], float)
++    assert isinstance(data.average_expect[2][1], complex)
++    assert isinstance(data.std_expect[0][1], float)
++    assert isinstance(data.std_expect[1][1], float)
++    assert isinstance(data.std_expect[2][1], float)
++    if keep_runs_results:
++        assert len(data.runs_expect) == len(e_ops)
++        assert len(data.runs_expect[0]) == ntraj
++        assert isinstance(data.runs_expect[0][0][1], float)
++        assert isinstance(data.runs_expect[1][0][1], float)
++        assert isinstance(data.runs_expect[2][0][1], complex)
++    assert isinstance(data.photocurrent[0][0], float)
++    assert isinstance(data.photocurrent[1][0], float)
++    assert (np.array(data.runs_photocurrent).shape
++            == (ntraj, len(c_ops), len(times)-1))
++    np.testing.assert_allclose(times, data.times)
++    assert data.num_trajectories == ntraj
++    assert len(data.e_ops) == len(e_ops)
++    assert data.stats["num_collapse"] == len(c_ops)
++    assert len(data.col_times) == ntraj
++    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
++    assert data.stats['end_condition'] == "ntraj reached"
++
++
++class TestSeeds:
++    sizes = [6, 6, 6]
++    dampings = [0.1, 0.4, 0.1]
++    ntraj = 25  # Big enough to ensure there are differences without being slow
++    a = [qutip.destroy(size) for size in sizes]
++    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
++              - qutip.tensor(a[0].dag(), a[1], a[2]))
++    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
++                         qutip.basis(sizes[1:], [0, 0]))
++    times = np.linspace(0, 10, 2)
++    c_ops = [
++        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
++        (np.sqrt(2*dampings[1])
++         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
++        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
++    ]
++
++    def test_seeds_can_be_reused(self):
++        args = (self.H, self.state, self.times)
++        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
++        first = mcsolve(*args, **kwargs)
++        second = mcsolve(*args, seeds=first.seeds, **kwargs)
++        for first_t, second_t in zip(first.col_times, second.col_times):
++            np.testing.assert_equal(first_t, second_t)
++        for first_w, second_w in zip(first.col_which, second.col_which):
++            np.testing.assert_equal(first_w, second_w)
++
++    def test_seeds_are_not_reused_by_default(self):
++        args = (self.H, self.state, self.times)
++        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
++        first = mcsolve(*args, **kwargs)
++        second = mcsolve(*args, **kwargs)
++        assert not all(np.array_equal(first_t, second_t)
++                       for first_t, second_t in zip(first.col_times,
++                                                    second.col_times))
++        assert not all(np.array_equal(first_w, second_w)
++                       for first_w, second_w in zip(first.col_which,
++                                                    second.col_which))
++
++    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
++    def test_seed_type(self, seed):
++        args = (self.H, self.state, self.times)
++        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
++        first = mcsolve(*args, seeds=copy(seed), **kwargs)
++        second = mcsolve(*args, seeds=copy(seed), **kwargs)
++        for f_seed, s_seed in zip(first.seeds, second.seeds):
++            assert f_seed.state == s_seed.state
++
++    def test_bad_seed(self):
++        args = (self.H, self.state, self.times)
++        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
++        with pytest.raises(ValueError):
++            first = mcsolve(*args, seeds=[1], **kwargs)
++
++    def test_generator(self):
++        args = (self.H, self.state, self.times)
++        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
++        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
++                        **kwargs)
++        second = mcsolve(*args, seeds=1, **kwargs)
++        for f_seed, s_seed in zip(first.seeds, second.seeds):
++            assert f_seed.state == s_seed.state
++        assert not all(np.array_equal(first_t, second_t)
++                       for first_t, second_t in zip(first.col_times,
++                                                    second.col_times))
++        assert not all(np.array_equal(first_w, second_w)
++                       for first_w, second_w in zip(first.col_which,
++                                                    second.col_which))
++
++    def test_stepping(self):
++        size = 10
++        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
++        H = qutip.num(size)
++        mcsolver = MCSolver(H, a, options={'map': 'serial'})
++        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
++        state_1 = mcsolver.step(1, args={'alpha':1})
++
++        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
++        state_2 = mcsolver.step(1, args={'alpha':1})
++        assert state_1 == state_2
++
++
++def test_timeout():
++    size = 10
++    ntraj = 1000
++    a = qutip.destroy(size)
++    H = qutip.num(size)
++    state = qutip.basis(size, size-1)
++    times = np.linspace(0, 1.0, 100)
++    coupling = 0.5
++    n_th = 0.05
++    c_ops = np.sqrt(coupling * (n_th + 1)) * a
++    e_ops = [qutip.num(size)]
++    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
++                  options={'map': 'serial'}, timeout=1e-6)
++    assert res.stats['end_condition'] == 'timeout'
++
++
++def test_super_H():
++    size = 10
++    ntraj = 1000
++    a = qutip.destroy(size)
++    H = qutip.num(size)
++    state = qutip.basis(size, size-1)
++    times = np.linspace(0, 1.0, 100)
++    # Arbitrary coupling and bath temperature.
++    coupling = 0.5
++    n_th = 0.05
++    c_ops = np.sqrt(coupling * (n_th + 1)) * a
++    e_ops = [qutip.num(size)]
++    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
++                          target_tol=0.1, options={'map': 'serial'})
++    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
++                 target_tol=0.1, options={'map': 'serial'})
++    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
++
++
++def test_MCSolver_run():
++    size = 10
++    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
++    H = qutip.num(size)
++    solver = MCSolver(H, a)
++    solver.options = {'store_final_state': True}
++    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
++                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
++    assert res.final_state is not None
++    assert len(res.collapse[0]) != 0
++    assert res.num_trajectories == 1
++    np.testing.assert_allclose(res.expect[0], np.ones(11))
++    res += solver.run(
++        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
++        e_ops=[qutip.qeye(size)], args={'coupling': 1},
++        ntraj=1000, target_tol=0.1
++    )
++    assert res.num_trajectories == 1001
++
++
++def test_MCSolver_stepping():
++    size = 10
++    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
++    H = qutip.num(size)
++    solver = MCSolver(H, a)
++    solver.start(qutip.basis(size, size-1), 0, seed=0)
++    solver.options = {'method': 'lsoda'}
++    state = solver.step(1)
++    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
++    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
++    assert state.isket
++    state = solver.step(5, args={'coupling': 5})
++    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
++    assert qutip.expect(qutip.num(size), state) <= size - 1
++    assert state.isket
++
++
++# Defined in module-scope so it's pickleable.
++def _dynamic(t, args):
++    return 0 if args["collapse"] else 1
++
++
++@pytest.mark.xfail(reason="current limitation of McSolve")
++def test_dynamic_arguments():
++    """Test dynamically updated arguments are usable."""
++    size = 5
++    a = qutip.destroy(size)
++    H = qutip.num(size)
++    times = np.linspace(0, 1, 11)
++    state = qutip.basis(size, 2)
++
++    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
++    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
++    assert all(len(collapses) <= 1 for collapses in mc.col_which)
+diff --git a/qutip/tests/solver/test_mesolve.py b/qutip/tests/solver/test_mesolve.py
+index 6f6bbab6..deb12479 100644
+--- a/qutip/tests/solver/test_mesolve.py
++++ b/qutip/tests/solver/test_mesolve.py
+@@ -1,677 +1,677 @@
+-import numpy as np
+-from types import FunctionType
+-
+-import qutip
+-from qutip.solver.mesolve import mesolve, MESolver
+-from qutip.solver.solver_base import Solver
+-import pickle
+-import pytest
+-
+-all_ode_method = [
+-    method for method, integrator in MESolver.avail_integrators().items()
+-    if integrator.support_time_dependant
+-]
+-
+-def fidelitycheck(out1, out2, rho0vec):
+-    fid = np.zeros(len(out1.states))
+-    for i, E in enumerate(out2.states):
+-        rhot = qutip.vector_to_operator(E*rho0vec)
+-        fid[i] = qutip.fidelity(out1.states[i], rhot)
+-    return fid
+-
+-
+-class TestMESolveDecay:
+-    N = 10
+-    a = qutip.destroy(N)
+-    kappa = 0.2
+-    tlist = np.linspace(0, 10, 201)
+-    ada = a.dag() * a
+-
+-    @pytest.fixture(params=[
+-        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
+-        pytest.param([ada, '1'], id='Hlist_str'),
+-        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
+-        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
+-        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
+-                     id='func'),
+-    ])
+-    def H(self, request):
+-        return request.param
+-
+-    @pytest.fixture(params=[
+-        pytest.param(np.sqrt(kappa) * a,
+-                     id='const'),
+-        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
+-                                      * qutip.destroy(10)),
+-                     id='func'),
+-        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
+-                     id='list_func'),
+-        pytest.param([a, 'sqrt(kappa)'],
+-                     id='list_str'),
+-        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
+-                     id='list_array'),
+-        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
+-                     id='QobjEvo'),
+-    ])
+-    def cte_c_ops(self, request):
+-        return request.param
+-
+-    @pytest.fixture(params=[
+-        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
+-                  id='list_func'),
+-        pytest.param([a, 'sqrt(kappa * exp(-t))'],
+-                  id='list_str'),
+-        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
+-                  id='list_array'),
+-        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
+-                          args={'kappa': kappa}),
+-                  id='QobjEvo'),
+-        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
+-                                      qutip.destroy(10)),
+-                     id='func'),
+-    ])
+-    def c_ops(self, request):
+-        return request.param
+-
+-    c_ops_1 = c_ops
+-
+-    def testME_CteDecay(self, cte_c_ops):
+-        "mesolve: simple constant decay"
+-        me_error = 1e-6
+-        H = self.a.dag() * self.a
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        c_op_list = [cte_c_ops]
+-        options = {"progress_bar": None}
+-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+-                         args={"kappa": self.kappa},
+-                         options=options)
+-        expt = medata.expect[0]
+-        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
+-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+-
+-    @pytest.mark.parametrize('method',
+-                             all_ode_method, ids=all_ode_method)
+-    def testME_TDDecay(self, c_ops, method):
+-        "mesolve: time-dependence as function list"
+-        me_error = 1e-5
+-        H = self.a.dag() * self.a
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        c_op_list = [c_ops]
+-        options = {"method": method, "progress_bar": None}
+-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+-                         args={"kappa": self.kappa}, options=options)
+-        expt = medata.expect[0]
+-        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
+-        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
+-
+-    def testME_2TDDecay(self, c_ops, c_ops_1):
+-        "mesolve: time-dependence as function list"
+-        me_error = 1e-5
+-        H = self.a.dag() * self.a
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        c_op_list = [c_ops, c_ops_1]
+-        options = {"progress_bar": None}
+-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+-                         args={"kappa": self.kappa},
+-                         options=options)
+-        expt = medata.expect[0]
+-        actual_answer = 9.0 * np.exp(-2 * self.kappa *
+-                                     (1.0 - np.exp(-self.tlist)))
+-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+-
+-    def testME_TDH_TDDecay(self, H, c_ops):
+-        "mesolve: time-dependence as function list"
+-        me_error = 5e-6
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        c_op_list = [c_ops]
+-        options = {"progress_bar": None}
+-        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
+-                         args={"kappa": self.kappa},
+-                         options=options)
+-        expt = medata.expect[0]
+-        actual_answer = 9.0 * np.exp(-self.kappa *
+-                                     (1.0 - np.exp(-self.tlist)))
+-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+-
+-    def testME_TDH_longTDDecay(self, H, c_ops):
+-        "mesolve: time-dependence as function list"
+-        me_error = 2e-5
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        if isinstance(c_ops, FunctionType):
+-            return
+-        if isinstance(c_ops, qutip.QobjEvo):
+-            c_op_list = [c_ops + c_ops]
+-        else:
+-            c_op_list = [[c_ops, c_ops]]
+-        options = {"progress_bar": None}
+-        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
+-                         args={"kappa": self.kappa},
+-                         options=options)
+-        expt = medata.expect[0]
+-        actual_answer = 9.0 * np.exp(-4 * self.kappa *
+-                                     (1.0 - np.exp(-self.tlist)))
+-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+-
+-    def testME_TDDecayUnitary(self, c_ops):
+-        "mesolve: time-dependence as function list with super as init cond"
+-        me_error = 5e-6
+-
+-        H = self.ada
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
+-        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
+-        options = {"progress_bar": None}
+-        c_op_list = [c_ops]
+-        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
+-                       args={"kappa": self.kappa},
+-                       options=options)
+-        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
+-                       args={"kappa": self.kappa},
+-                       options=options)
+-
+-        fid = fidelitycheck(out1, out2, rho0vec)
+-        assert fid == pytest.approx(1., abs=me_error)
+-
+-    def testME_TDDecayliouvillian(self, c_ops):
+-        "mesolve: time-dependence as function list with super as init cond"
+-        me_error = 5e-6
+-
+-        H = self.ada
+-        L = qutip.liouvillian(H)
+-        psi0 = qutip.basis(self.N, 9)  # initial state
+-        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
+-        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
+-        options = {"progress_bar": None}
+-        c_op_list = [c_ops]
+-        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
+-                       args={"kappa": self.kappa},
+-                       options=options)
+-        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
+-                       args={"kappa": self.kappa},
+-                       options=options)
+-
+-        fid = fidelitycheck(out1, out2, rho0vec)
+-        assert fid == pytest.approx(1., abs=me_error)
+-
+-    @pytest.mark.parametrize(['state_type'], [
+-        pytest.param("ket", id="ket"),
+-        pytest.param("dm", id="dm"),
+-        pytest.param("unitary", id="unitary"),
+-    ])
+-    def test_mesolve_normalization(self, state_type):
+-        # non-hermitean H causes state to evolve non-unitarily
+-        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
+-        H = qutip.sprepost(H, H) # ensure use of MeSolve
+-        psi0 = qutip.basis(2, 0)
+-        options = {"normalize_output": True, "progress_bar": None}
+-
+-        if state_type in {"ket", "dm"}:
+-            if state_type == "dm":
+-                psi0 = qutip.ket2dm(psi0)
+-            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
+-            norms = [state.norm() for state in output.states]
+-            np.testing.assert_allclose(
+-                norms, [1.0 for _ in self.tlist], atol=1e-15,
+-            )
+-        else:
+-            # evolution of unitaries should not be normalized
+-            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
+-            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
+-            norms = [state.norm() for state in output.states]
+-            assert all(norm > 4 for norm in norms[1:])
+-
+-    def test_mesolver_pickling(self):
+-        options = {"progress_bar": None}
+-        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
+-        solver_copy = pickle.loads(pickle.dumps(solver_obj))
+-        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
+-                            e_ops=[self.ada]).expect[0]
+-        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
+-                            e_ops=[self.ada]).expect[0]
+-        np.testing.assert_allclose(e1, e2)
+-
+-    @pytest.mark.parametrize('method',
+-                             all_ode_method, ids=all_ode_method)
+-    def test_mesolver_stepping(self, method):
+-        options = {"method": method, "progress_bar": None}
+-        solver_obj = MESolver(
+-            self.ada,
+-            c_ops=qutip.QobjEvo(
+-                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
+-                args={'kappa': 1.}
+-            ),
+-            options=options
+-        )
+-        solver_obj.start(qutip.basis(self.N, 9), 0)
+-        state1 = solver_obj.step(1)
+-        assert qutip.expect(self.ada, state1) != (
+-            qutip.expect(self.ada, qutip.basis(self.N, 9))
+-        )
+-        state2 = solver_obj.step(2, args={"kappa":0.})
+-        np.testing.assert_allclose(qutip.expect(self.ada, state1),
+-                                   qutip.expect(self.ada, state2), 1e-6)
+-
+-
+-@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
+-                         ids=["ket", "dm", "liouvillian"])
+-def testME_SesolveFallback(super_):
+-    "mesolve: final_state has correct dims"
+-    N = 5
+-    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
+-    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
+-    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
+-    psi0 = qutip.tensor(qutip.basis(N+1,0),
+-                        qutip.basis(N+1,0),
+-                        qutip.basis(N+1,N))
+-    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
+-    if super_ == "dm":
+-        state0 = qutip.ket2dm(psi0)
+-    else:
+-        state0 = psi0
+-    if super_ == "liouvillian":
+-        H = qutip.liouvillian(H)
+-
+-    times = np.linspace(0.0, 0.1, 3)
+-    options = {
+-        "store_states": False,
+-        "store_final_state": True,
+-        "progress_bar": None
+-    }
+-    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
+-    if super_ == "ket":
+-        assert result.final_state.dims == psi0.dims
+-    else:
+-        assert result.final_state.dims == qutip.ket2dm(psi0).dims
+-
+-
+-class TestJCModelEvolution:
+-    """
+-    A test class for the QuTiP functions for the evolution of JC model
+-    """
+-    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
+-
+-        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
+-
+-        c_op_list = []
+-
+-        rate = g1
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
+-
+-        rate = g2
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
+-
+-        output = mesolve(H, psi0, tlist, c_op_list,
+-            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+-        )
+-
+-        return output.expect[0], output.expect[1], output.expect[2]
+-
+-    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
+-                       pump, psi0, use_rwa, tlist):
+-
+-        # Hamiltonian
+-        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
+-        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
+-
+-        if use_rwa:
+-            # use the rotating wave approxiation
+-            H = (wc * a.dag() * a + wa * sm.dag() * sm
+-                 + g * (a.dag() * sm + a * sm.dag()))
+-        else:
+-            H = (wc * a.dag() * a + wa * sm.dag() * sm
+-                 + g * (a.dag() + a) * (sm + sm.dag()))
+-
+-        # collapse operators
+-        c_op_list = []
+-
+-        n_th_a = 0.0  # zero temperature
+-
+-        rate = kappa * (1 + n_th_a)
+-        c_op_list.append(np.sqrt(rate) * a)
+-
+-        rate = kappa * n_th_a
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * a.dag())
+-
+-        rate = gamma
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * sm)
+-
+-        rate = pump
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * sm.dag())
+-
+-        # find the steady state
+-        rho_ss = qutip.steadystate(H, c_op_list)
+-
+-        return (qutip.expect(a.dag() * a, rho_ss),
+-                qutip.expect(sm.dag() * sm, rho_ss))
+-
+-    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
+-                     pump, psi0, use_rwa, tlist, oper_evo=False):
+-
+-        # Hamiltonian
+-        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
+-        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
+-
+-        # Identity super-operator
+-        E0 = qutip.sprepost(
+-            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
+-            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
+-        )
+-
+-        if use_rwa:
+-            # use the rotating wave approxiation
+-            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
+-                a.dag() * sm + a * sm.dag())
+-        else:
+-            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
+-                a.dag() + a) * (sm + sm.dag())
+-
+-        # collapse operators
+-        c_op_list = []
+-
+-        n_th_a = 0.0  # zero temperature
+-
+-        rate = kappa * (1 + n_th_a)
+-        c_op_list.append(np.sqrt(rate) * a)
+-
+-        rate = kappa * n_th_a
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * a.dag())
+-
+-        rate = gamma
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * sm)
+-
+-        rate = pump
+-        if rate > 0.0:
+-            c_op_list.append(np.sqrt(rate) * sm.dag())
+-
+-        options = {"store_states": True, "progress_bar": None}
+-
+-        # evolve and calculate expectation values
+-        output = mesolve(
+-            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
+-            options=options)
+-        if oper_evo:
+-            output2 = mesolve(H, E0, tlist, c_op_list, [])
+-            return output, output2
+-        return output.expect[0], output.expect[1]
+-
+-    def testSuperJC(self):
+-        "mesolve: super vs. density matrix as initial condition"
+-        me_error = 1e-6
+-
+-        use_rwa = True
+-        N = 4           # number of cavity fock states
+-        wc = 2 * np.pi * 1.0   # cavity frequency
+-        wa = 2 * np.pi * 1.0   # atom frequency
+-        g = 2 * np.pi * 0.1   # coupling strength
+-        kappa = 0.05    # cavity dissipation rate
+-        gamma = 0.001   # atom dissipation rate
+-        pump = 0.25    # atom pump rate
+-
+-        # start with an excited atom and maximum number of photons
+-        n = N - 2
+-        psi0 = qutip.basis([N, 2], [n, 1])
+-        rho0vec = qutip.operator_to_vector(psi0.proj())
+-        tlist = np.linspace(0, 100, 50)
+-
+-        out1, out2 = self.jc_integrate(
+-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
+-
+-        fid = fidelitycheck(out1, out2, rho0vec)
+-        assert fid == pytest.approx(1., abs=me_error)
+-
+-    def testQubitDynamics1(self):
+-        "mesolve: qubit with dissipation"
+-
+-        epsilon = 0.0 * 2 * np.pi   # cavity frequency
+-        delta = 1.0 * 2 * np.pi   # atom frequency
+-        g2 = 0.1
+-        g1 = 0.0
+-        psi0 = qutip.basis(2, 0)        # initial state
+-        tlist = np.linspace(0, 5, 200)
+-
+-        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
+-
+-        sx_analytic = np.zeros(np.shape(tlist))
+-        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-
+-        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
+-        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
+-        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
+-
+-    def testQubitDynamics2(self):
+-        "mesolve: qubit without dissipation"
+-
+-        epsilon = 0.0 * 2 * np.pi   # cavity frequency
+-        delta = 1.0 * 2 * np.pi   # atom frequency
+-        g2 = 0.0
+-        g1 = 0.0
+-        psi0 = qutip.basis(2, 0)        # initial state
+-        tlist = np.linspace(0, 5, 200)
+-
+-        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
+-
+-        sx_analytic = np.zeros(np.shape(tlist))
+-        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+-
+-        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
+-        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
+-        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
+-
+-    def testCavity1(self):
+-        "mesolve: cavity-qubit interaction, no dissipation"
+-
+-        use_rwa = True
+-        N = 4           # number of cavity fock states
+-        wc = 2 * np.pi * 1.0   # cavity frequency
+-        wa = 2 * np.pi * 1.0   # atom frequency
+-        g = 2 * np.pi * 0.01   # coupling strength
+-        kappa = 0.0     # cavity dissipation rate
+-        gamma = 0.0     # atom dissipation rate
+-        pump = 0.0      # atom pump rate
+-
+-        # start with an excited atom and maximum number of photons
+-        n = N - 2
+-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+-        tlist = np.linspace(0, 1000, 2000)
+-
+-        nc, na = self.jc_integrate(
+-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+-
+-        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
+-        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
+-
+-        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
+-        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
+-
+-    def testCavity2(self):
+-        "mesolve: cavity-qubit without interaction, decay"
+-
+-        use_rwa = True
+-        N = 4           # number of cavity fock states
+-        wc = 2 * np.pi * 1.0   # cavity frequency
+-        wa = 2 * np.pi * 1.0   # atom frequency
+-        g = 2 * np.pi * 0.0    # coupling strength
+-        kappa = 0.005   # cavity dissipation rate
+-        gamma = 0.01    # atom dissipation rate
+-        pump = 0.0      # atom pump rate
+-
+-        # start with an excited atom and maximum number of photons
+-        n = N - 2
+-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+-        tlist = np.linspace(0, 1000, 2000)
+-
+-        nc, na = self.jc_integrate(
+-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+-
+-        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
+-            np.exp(-kappa * tlist)
+-        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
+-            np.exp(-gamma * tlist)
+-
+-        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
+-        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
+-
+-    def testCavity3(self):
+-        "mesolve: cavity-qubit with interaction, decay"
+-
+-        use_rwa = True
+-        N = 4           # number of cavity fock states
+-        wc = 2 * np.pi * 1.0   # cavity frequency
+-        wa = 2 * np.pi * 1.0   # atom frequency
+-        g = 2 * np.pi * 0.1   # coupling strength
+-        kappa = 0.05    # cavity dissipation rate
+-        gamma = 0.001   # atom dissipation rate
+-        pump = 0.25    # atom pump rate
+-
+-        # start with an excited atom and maximum number of photons
+-        n = N - 2
+-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+-        tlist = np.linspace(0, 200, 500)
+-
+-        nc, na = self.jc_integrate(
+-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+-
+-        # we don't have any analytics for this parameters, so
+-        # compare with the steady state
+-        nc_ss, na_ss = self.jc_steadystate(
+-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+-
+-        nc_ss = nc_ss * np.ones(np.shape(nc))
+-        na_ss = na_ss * np.ones(np.shape(na))
+-
+-        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
+-        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
+-
+-
+-class TestMESolveStepFuncCoeff:
+-    """
+-    A Test class for using time-dependent array coefficients
+-    as step functions instead of doing interpolation
+-    """
+-    # Runge-Kutta method (dop853) behave better with step function evolution
+-    # than multi-step methods (adams, qutip 4's default)
+-    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
+-
+-    def python_coeff(self, t, args):
+-        if t < np.pi/2:
+-            return 1.
+-        else:
+-            return 0.
+-
+-    @pytest.mark.parametrize('method',
+-                             all_ode_method, ids=all_ode_method)
+-    def test_py_coeff(self, method):
+-        """
+-        Test for Python function as coefficient as step function coeff
+-        """
+-        rho0 = qutip.rand_ket(2)
+-        tlist = np.array([0, np.pi/2])
+-        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
+-        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
+-                     tlist=tlist, order=0)
+-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
+-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+-        assert fid == pytest.approx(1)
+-
+-    def test_array_cte_coeff(self):
+-        """
+-        Test for Array coefficient with uniform tlist as step function coeff
+-        """
+-        rho0 = qutip.rand_ket(2)
+-        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
+-        npcoeff = np.array([0.25, 0.75, 0.75])
+-        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
+-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+-        assert fid == pytest.approx(1)
+-
+-    def test_array_t_coeff(self):
+-        """
+-        Test for Array with non-uniform tlist as step function coeff
+-        """
+-        rho0 = qutip.rand_ket(2)
+-        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
+-        npcoeff = np.array([0.5, 0.25, 0.25])
+-        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
+-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+-        assert fid == pytest.approx(1)
+-
+-    def test_array_str_coeff(self):
+-        """
+-        Test for Array and string as step function coeff.
+-        qobjevo_codegen is used and uniform tlist
+-        """
+-        rho0 = qutip.rand_ket(2)
+-        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
+-        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
+-        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
+-        strcoeff = "1."
+-        qu = qutip.QobjEvo(
+-            [[qutip.sigmax(), npcoeff1],
+-             [qutip.sigmax(), strcoeff],
+-             [qutip.sigmax(), npcoeff2]],
+-            tlist=tlist, order=0)
+-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+-        assert fid == pytest.approx(1)
+-
+-    def test_array_str_py_coeff(self):
+-        """
+-        Test for Array, string and Python function as step function coeff.
+-        qobjevo_codegen is used and non non-uniform tlist
+-        """
+-        rho0 = qutip.rand_ket(2)
+-        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
+-        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
+-        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
+-        strcoeff = "1."
+-        qu = qutip.QobjEvo(
+-            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
+-             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
+-            tlist=tlist, order=0)
+-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+-        assert fid == pytest.approx(1)
+-
+-
+-def test_num_collapse_set():
+-    H = qutip.sigmaz()
+-    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+-    ts = [0, 1]
+-    for c_ops in (
+-        qutip.sigmax(),
+-        [qutip.sigmax()],
+-        [qutip.sigmay(), qutip.sigmax()],
+-    ):
+-        res = mesolve(H, psi, ts, c_ops=c_ops)
+-        if not isinstance(c_ops, list):
+-            c_ops = [c_ops]
+-        assert res.stats["num_collapse"] == len(c_ops)
+-
+-
+-def test_mesolve_bad_H():
+-    with pytest.raises(TypeError):
+-        MESolver([qutip.qeye(3), 't'], [])
+-    with pytest.raises(TypeError):
+-        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
+-
+-
+-def test_mesolve_bad_state():
+-    solver = MESolver(qutip.qeye(4), [])
+-    with pytest.raises(TypeError):
+-        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
+-
+-
+-def test_mesolve_bad_options():
+-    with pytest.raises(TypeError):
+-        MESolver(qutip.qeye(4), [], options=False)
++import numpy as np
++from types import FunctionType
++
++import qutip
++from qutip.solver.mesolve import mesolve, MESolver
++from qutip.solver.solver_base import Solver
++import pickle
++import pytest
++
++all_ode_method = [
++    method for method, integrator in MESolver.avail_integrators().items()
++    if integrator.support_time_dependant
++]
++
++def fidelitycheck(out1, out2, rho0vec):
++    fid = np.zeros(len(out1.states))
++    for i, E in enumerate(out2.states):
++        rhot = qutip.vector_to_operator(E*rho0vec)
++        fid[i] = qutip.fidelity(out1.states[i], rhot)
++    return fid
++
++
++class TestMESolveDecay:
++    N = 10
++    a = qutip.destroy(N)
++    kappa = 0.2
++    tlist = np.linspace(0, 10, 201)
++    ada = a.dag() * a
++
++    @pytest.fixture(params=[
++        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
++        pytest.param([ada, '1'], id='Hlist_str'),
++        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
++        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
++        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
++                     id='func'),
++    ])
++    def H(self, request):
++        return request.param
++
++    @pytest.fixture(params=[
++        pytest.param(np.sqrt(kappa) * a,
++                     id='const'),
++        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
++                                      * qutip.destroy(10)),
++                     id='func'),
++        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
++                     id='list_func'),
++        pytest.param([a, 'sqrt(kappa)'],
++                     id='list_str'),
++        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
++                     id='list_array'),
++        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
++                     id='QobjEvo'),
++    ])
++    def cte_c_ops(self, request):
++        return request.param
++
++    @pytest.fixture(params=[
++        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
++                  id='list_func'),
++        pytest.param([a, 'sqrt(kappa * exp(-t))'],
++                  id='list_str'),
++        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
++                  id='list_array'),
++        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
++                          args={'kappa': kappa}),
++                  id='QobjEvo'),
++        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
++                                      qutip.destroy(10)),
++                     id='func'),
++    ])
++    def c_ops(self, request):
++        return request.param
++
++    c_ops_1 = c_ops
++
++    def testME_CteDecay(self, cte_c_ops):
++        "mesolve: simple constant decay"
++        me_error = 1e-6
++        H = self.a.dag() * self.a
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        c_op_list = [cte_c_ops]
++        options = {"progress_bar": None}
++        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
++                         args={"kappa": self.kappa},
++                         options=options)
++        expt = medata.expect[0]
++        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
++        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
++
++    @pytest.mark.parametrize('method',
++                             all_ode_method, ids=all_ode_method)
++    def testME_TDDecay(self, c_ops, method):
++        "mesolve: time-dependence as function list"
++        me_error = 1e-5
++        H = self.a.dag() * self.a
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        c_op_list = [c_ops]
++        options = {"method": method, "progress_bar": None}
++        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
++                         args={"kappa": self.kappa}, options=options)
++        expt = medata.expect[0]
++        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
++        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
++
++    def testME_2TDDecay(self, c_ops, c_ops_1):
++        "mesolve: time-dependence as function list"
++        me_error = 1e-5
++        H = self.a.dag() * self.a
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        c_op_list = [c_ops, c_ops_1]
++        options = {"progress_bar": None}
++        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
++                         args={"kappa": self.kappa},
++                         options=options)
++        expt = medata.expect[0]
++        actual_answer = 9.0 * np.exp(-2 * self.kappa *
++                                     (1.0 - np.exp(-self.tlist)))
++        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
++
++    def testME_TDH_TDDecay(self, H, c_ops):
++        "mesolve: time-dependence as function list"
++        me_error = 5e-6
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        c_op_list = [c_ops]
++        options = {"progress_bar": None}
++        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
++                         args={"kappa": self.kappa},
++                         options=options)
++        expt = medata.expect[0]
++        actual_answer = 9.0 * np.exp(-self.kappa *
++                                     (1.0 - np.exp(-self.tlist)))
++        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
++
++    def testME_TDH_longTDDecay(self, H, c_ops):
++        "mesolve: time-dependence as function list"
++        me_error = 2e-5
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        if isinstance(c_ops, FunctionType):
++            return
++        if isinstance(c_ops, qutip.QobjEvo):
++            c_op_list = [c_ops + c_ops]
++        else:
++            c_op_list = [[c_ops, c_ops]]
++        options = {"progress_bar": None}
++        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
++                         args={"kappa": self.kappa},
++                         options=options)
++        expt = medata.expect[0]
++        actual_answer = 9.0 * np.exp(-4 * self.kappa *
++                                     (1.0 - np.exp(-self.tlist)))
++        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
++
++    def testME_TDDecayUnitary(self, c_ops):
++        "mesolve: time-dependence as function list with super as init cond"
++        me_error = 5e-6
++
++        H = self.ada
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
++        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
++        options = {"progress_bar": None}
++        c_op_list = [c_ops]
++        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
++                       args={"kappa": self.kappa},
++                       options=options)
++        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
++                       args={"kappa": self.kappa},
++                       options=options)
++
++        fid = fidelitycheck(out1, out2, rho0vec)
++        assert fid == pytest.approx(1., abs=me_error)
++
++    def testME_TDDecayliouvillian(self, c_ops):
++        "mesolve: time-dependence as function list with super as init cond"
++        me_error = 5e-6
++
++        H = self.ada
++        L = qutip.liouvillian(H)
++        psi0 = qutip.basis(self.N, 9)  # initial state
++        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
++        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
++        options = {"progress_bar": None}
++        c_op_list = [c_ops]
++        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
++                       args={"kappa": self.kappa},
++                       options=options)
++        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
++                       args={"kappa": self.kappa},
++                       options=options)
++
++        fid = fidelitycheck(out1, out2, rho0vec)
++        assert fid == pytest.approx(1., abs=me_error)
++
++    @pytest.mark.parametrize(['state_type'], [
++        pytest.param("ket", id="ket"),
++        pytest.param("dm", id="dm"),
++        pytest.param("unitary", id="unitary"),
++    ])
++    def test_mesolve_normalization(self, state_type):
++        # non-hermitean H causes state to evolve non-unitarily
++        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
++        H = qutip.sprepost(H, H) # ensure use of MeSolve
++        psi0 = qutip.basis(2, 0)
++        options = {"normalize_output": True, "progress_bar": None}
++
++        if state_type in {"ket", "dm"}:
++            if state_type == "dm":
++                psi0 = qutip.ket2dm(psi0)
++            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
++            norms = [state.norm() for state in output.states]
++            np.testing.assert_allclose(
++                norms, [1.0 for _ in self.tlist], atol=1e-15,
++            )
++        else:
++            # evolution of unitaries should not be normalized
++            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
++            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
++            norms = [state.norm() for state in output.states]
++            assert all(norm > 4 for norm in norms[1:])
++
++    def test_mesolver_pickling(self):
++        options = {"progress_bar": None}
++        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
++        solver_copy = pickle.loads(pickle.dumps(solver_obj))
++        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
++                            e_ops=[self.ada]).expect[0]
++        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
++                            e_ops=[self.ada]).expect[0]
++        np.testing.assert_allclose(e1, e2)
++
++    @pytest.mark.parametrize('method',
++                             all_ode_method, ids=all_ode_method)
++    def test_mesolver_stepping(self, method):
++        options = {"method": method, "progress_bar": None}
++        solver_obj = MESolver(
++            self.ada,
++            c_ops=qutip.QobjEvo(
++                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
++                args={'kappa': 1.}
++            ),
++            options=options
++        )
++        solver_obj.start(qutip.basis(self.N, 9), 0)
++        state1 = solver_obj.step(1)
++        assert qutip.expect(self.ada, state1) != (
++            qutip.expect(self.ada, qutip.basis(self.N, 9))
++        )
++        state2 = solver_obj.step(2, args={"kappa":0.})
++        np.testing.assert_allclose(qutip.expect(self.ada, state1),
++                                   qutip.expect(self.ada, state2), 1e-6)
++
++
++@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
++                         ids=["ket", "dm", "liouvillian"])
++def testME_SesolveFallback(super_):
++    "mesolve: final_state has correct dims"
++    N = 5
++    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
++    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
++    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
++    psi0 = qutip.tensor(qutip.basis(N+1,0),
++                        qutip.basis(N+1,0),
++                        qutip.basis(N+1,N))
++    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
++    if super_ == "dm":
++        state0 = qutip.ket2dm(psi0)
++    else:
++        state0 = psi0
++    if super_ == "liouvillian":
++        H = qutip.liouvillian(H)
++
++    times = np.linspace(0.0, 0.1, 3)
++    options = {
++        "store_states": False,
++        "store_final_state": True,
++        "progress_bar": None
++    }
++    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
++    if super_ == "ket":
++        assert result.final_state.dims == psi0.dims
++    else:
++        assert result.final_state.dims == qutip.ket2dm(psi0).dims
++
++
++class TestJCModelEvolution:
++    """
++    A test class for the QuTiP functions for the evolution of JC model
++    """
++    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
++
++        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
++
++        c_op_list = []
++
++        rate = g1
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
++
++        rate = g2
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
++
++        output = mesolve(H, psi0, tlist, c_op_list,
++            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
++        )
++
++        return output.expect[0], output.expect[1], output.expect[2]
++
++    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
++                       pump, psi0, use_rwa, tlist):
++
++        # Hamiltonian
++        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
++        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
++
++        if use_rwa:
++            # use the rotating wave approxiation
++            H = (wc * a.dag() * a + wa * sm.dag() * sm
++                 + g * (a.dag() * sm + a * sm.dag()))
++        else:
++            H = (wc * a.dag() * a + wa * sm.dag() * sm
++                 + g * (a.dag() + a) * (sm + sm.dag()))
++
++        # collapse operators
++        c_op_list = []
++
++        n_th_a = 0.0  # zero temperature
++
++        rate = kappa * (1 + n_th_a)
++        c_op_list.append(np.sqrt(rate) * a)
++
++        rate = kappa * n_th_a
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * a.dag())
++
++        rate = gamma
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * sm)
++
++        rate = pump
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * sm.dag())
++
++        # find the steady state
++        rho_ss = qutip.steadystate(H, c_op_list)
++
++        return (qutip.expect(a.dag() * a, rho_ss),
++                qutip.expect(sm.dag() * sm, rho_ss))
++
++    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
++                     pump, psi0, use_rwa, tlist, oper_evo=False):
++
++        # Hamiltonian
++        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
++        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
++
++        # Identity super-operator
++        E0 = qutip.sprepost(
++            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
++            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
++        )
++
++        if use_rwa:
++            # use the rotating wave approxiation
++            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
++                a.dag() * sm + a * sm.dag())
++        else:
++            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
++                a.dag() + a) * (sm + sm.dag())
++
++        # collapse operators
++        c_op_list = []
++
++        n_th_a = 0.0  # zero temperature
++
++        rate = kappa * (1 + n_th_a)
++        c_op_list.append(np.sqrt(rate) * a)
++
++        rate = kappa * n_th_a
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * a.dag())
++
++        rate = gamma
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * sm)
++
++        rate = pump
++        if rate > 0.0:
++            c_op_list.append(np.sqrt(rate) * sm.dag())
++
++        options = {"store_states": True, "progress_bar": None}
++
++        # evolve and calculate expectation values
++        output = mesolve(
++            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
++            options=options)
++        if oper_evo:
++            output2 = mesolve(H, E0, tlist, c_op_list, [])
++            return output, output2
++        return output.expect[0], output.expect[1]
++
++    def testSuperJC(self):
++        "mesolve: super vs. density matrix as initial condition"
++        me_error = 1e-6
++
++        use_rwa = True
++        N = 4           # number of cavity fock states
++        wc = 2 * np.pi * 1.0   # cavity frequency
++        wa = 2 * np.pi * 1.0   # atom frequency
++        g = 2 * np.pi * 0.1   # coupling strength
++        kappa = 0.05    # cavity dissipation rate
++        gamma = 0.001   # atom dissipation rate
++        pump = 0.25    # atom pump rate
++
++        # start with an excited atom and maximum number of photons
++        n = N - 2
++        psi0 = qutip.basis([N, 2], [n, 1])
++        rho0vec = qutip.operator_to_vector(psi0.proj())
++        tlist = np.linspace(0, 100, 50)
++
++        out1, out2 = self.jc_integrate(
++            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
++
++        fid = fidelitycheck(out1, out2, rho0vec)
++        assert fid == pytest.approx(1., abs=me_error)
++
++    def testQubitDynamics1(self):
++        "mesolve: qubit with dissipation"
++
++        epsilon = 0.0 * 2 * np.pi   # cavity frequency
++        delta = 1.0 * 2 * np.pi   # atom frequency
++        g2 = 0.1
++        g1 = 0.0
++        psi0 = qutip.basis(2, 0)        # initial state
++        tlist = np.linspace(0, 5, 200)
++
++        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
++
++        sx_analytic = np.zeros(np.shape(tlist))
++        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
++        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
++
++        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
++        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
++        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
++
++    def testQubitDynamics2(self):
++        "mesolve: qubit without dissipation"
++
++        epsilon = 0.0 * 2 * np.pi   # cavity frequency
++        delta = 1.0 * 2 * np.pi   # atom frequency
++        g2 = 0.0
++        g1 = 0.0
++        psi0 = qutip.basis(2, 0)        # initial state
++        tlist = np.linspace(0, 5, 200)
++
++        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
++
++        sx_analytic = np.zeros(np.shape(tlist))
++        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
++        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
++
++        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
++        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
++        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
++
++    def testCavity1(self):
++        "mesolve: cavity-qubit interaction, no dissipation"
++
++        use_rwa = True
++        N = 4           # number of cavity fock states
++        wc = 2 * np.pi * 1.0   # cavity frequency
++        wa = 2 * np.pi * 1.0   # atom frequency
++        g = 2 * np.pi * 0.01   # coupling strength
++        kappa = 0.0     # cavity dissipation rate
++        gamma = 0.0     # atom dissipation rate
++        pump = 0.0      # atom pump rate
++
++        # start with an excited atom and maximum number of photons
++        n = N - 2
++        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
++        tlist = np.linspace(0, 1000, 2000)
++
++        nc, na = self.jc_integrate(
++            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
++
++        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
++        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
++
++        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
++        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
++
++    def testCavity2(self):
++        "mesolve: cavity-qubit without interaction, decay"
++
++        use_rwa = True
++        N = 4           # number of cavity fock states
++        wc = 2 * np.pi * 1.0   # cavity frequency
++        wa = 2 * np.pi * 1.0   # atom frequency
++        g = 2 * np.pi * 0.0    # coupling strength
++        kappa = 0.005   # cavity dissipation rate
++        gamma = 0.01    # atom dissipation rate
++        pump = 0.0      # atom pump rate
++
++        # start with an excited atom and maximum number of photons
++        n = N - 2
++        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
++        tlist = np.linspace(0, 1000, 2000)
++
++        nc, na = self.jc_integrate(
++            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
++
++        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
++            np.exp(-kappa * tlist)
++        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
++            np.exp(-gamma * tlist)
++
++        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
++        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
++
++    def testCavity3(self):
++        "mesolve: cavity-qubit with interaction, decay"
++
++        use_rwa = True
++        N = 4           # number of cavity fock states
++        wc = 2 * np.pi * 1.0   # cavity frequency
++        wa = 2 * np.pi * 1.0   # atom frequency
++        g = 2 * np.pi * 0.1   # coupling strength
++        kappa = 0.05    # cavity dissipation rate
++        gamma = 0.001   # atom dissipation rate
++        pump = 0.25    # atom pump rate
++
++        # start with an excited atom and maximum number of photons
++        n = N - 2
++        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
++        tlist = np.linspace(0, 200, 500)
++
++        nc, na = self.jc_integrate(
++            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
++
++        # we don't have any analytics for this parameters, so
++        # compare with the steady state
++        nc_ss, na_ss = self.jc_steadystate(
++            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
++
++        nc_ss = nc_ss * np.ones(np.shape(nc))
++        na_ss = na_ss * np.ones(np.shape(na))
++
++        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
++        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
++
++
++class TestMESolveStepFuncCoeff:
++    """
++    A Test class for using time-dependent array coefficients
++    as step functions instead of doing interpolation
++    """
++    # Runge-Kutta method (dop853) behave better with step function evolution
++    # than multi-step methods (adams, qutip 4's default)
++    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
++
++    def python_coeff(self, t, args):
++        if t < np.pi/2:
++            return 1.
++        else:
++            return 0.
++
++    @pytest.mark.parametrize('method',
++                             all_ode_method, ids=all_ode_method)
++    def test_py_coeff(self, method):
++        """
++        Test for Python function as coefficient as step function coeff
++        """
++        rho0 = qutip.rand_ket(2)
++        tlist = np.array([0, np.pi/2])
++        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
++        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
++                     tlist=tlist, order=0)
++        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
++        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
++        assert fid == pytest.approx(1)
++
++    def test_array_cte_coeff(self):
++        """
++        Test for Array coefficient with uniform tlist as step function coeff
++        """
++        rho0 = qutip.rand_ket(2)
++        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
++        npcoeff = np.array([0.25, 0.75, 0.75])
++        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
++        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
++        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
++        assert fid == pytest.approx(1)
++
++    def test_array_t_coeff(self):
++        """
++        Test for Array with non-uniform tlist as step function coeff
++        """
++        rho0 = qutip.rand_ket(2)
++        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
++        npcoeff = np.array([0.5, 0.25, 0.25])
++        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
++        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
++        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
++        assert fid == pytest.approx(1)
++
++    def test_array_str_coeff(self):
++        """
++        Test for Array and string as step function coeff.
++        qobjevo_codegen is used and uniform tlist
++        """
++        rho0 = qutip.rand_ket(2)
++        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
++        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
++        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
++        strcoeff = "1."
++        qu = qutip.QobjEvo(
++            [[qutip.sigmax(), npcoeff1],
++             [qutip.sigmax(), strcoeff],
++             [qutip.sigmax(), npcoeff2]],
++            tlist=tlist, order=0)
++        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
++        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
++        assert fid == pytest.approx(1)
++
++    def test_array_str_py_coeff(self):
++        """
++        Test for Array, string and Python function as step function coeff.
++        qobjevo_codegen is used and non non-uniform tlist
++        """
++        rho0 = qutip.rand_ket(2)
++        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
++        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
++        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
++        strcoeff = "1."
++        qu = qutip.QobjEvo(
++            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
++             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
++            tlist=tlist, order=0)
++        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
++        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
++        assert fid == pytest.approx(1)
++
++
++def test_num_collapse_set():
++    H = qutip.sigmaz()
++    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
++    ts = [0, 1]
++    for c_ops in (
++        qutip.sigmax(),
++        [qutip.sigmax()],
++        [qutip.sigmay(), qutip.sigmax()],
++    ):
++        res = mesolve(H, psi, ts, c_ops=c_ops)
++        if not isinstance(c_ops, list):
++            c_ops = [c_ops]
++        assert res.stats["num_collapse"] == len(c_ops)
++
++
++def test_mesolve_bad_H():
++    with pytest.raises(TypeError):
++        MESolver([qutip.qeye(3), 't'], [])
++    with pytest.raises(TypeError):
++        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
++
++
++def test_mesolve_bad_state():
++    solver = MESolver(qutip.qeye(4), [])
++    with pytest.raises(TypeError):
++        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
++
++
++def test_mesolve_bad_options():
++    with pytest.raises(TypeError):
++        MESolver(qutip.qeye(4), [], options=False)
+diff --git a/qutip/tests/solver/test_options.py b/qutip/tests/solver/test_options.py
+index 5f75405b..7337db1c 100644
+--- a/qutip/tests/solver/test_options.py
++++ b/qutip/tests/solver/test_options.py
+@@ -1,142 +1,142 @@
+-import pytest
+-import qutip
+-import numpy as np
+-from qutip.solver.options import _SolverOptions
+-
+-
+-default = {
+-    "opt1": False,
+-    "opt2": True,
+-    "opt3": None,
+-}
+-
+-
+-def test_default():
+-    opt = _SolverOptions(default)
+-    assert opt
+-    assert default.keys() == opt.keys()
+-    assert opt["opt1"] is False
+-    assert opt["opt2"] is True
+-    assert opt["opt3"] is None
+-
+-
+-def test_SolverOptions_dictlike():
+-    opt_dict = {
+-        "opt1": True,
+-        "opt2": None,
+-    }
+-    opt = _SolverOptions(default, **opt_dict)
+-    assert opt
+-    assert default.keys() == opt.keys()
+-    assert opt["opt1"] is True
+-    assert opt["opt2"] is None
+-    assert opt["opt3"] is None
+-
+-    copy = opt.copy()
+-    assert opt.items() == copy.items()
+-    copy['opt3'] = 2
+-    assert opt.items() != copy.items()
+-
+-    assert len(opt.values()) == 3
+-    assert len(opt.items()) == 3
+-    assert len(opt.keys()) == 3
+-
+-
+-def test_del():
+-    opt_dict = {
+-        "opt1": True,
+-    }
+-    opt = _SolverOptions(default, opt1=True)
+-    del opt["opt1"]
+-    assert opt["opt1"] is False
+-
+-
+-def test_SolverOptions_Feedback():
+-    called = []
+-
+-    def _catch(keys):
+-        assert isinstance(keys, (set, str))
+-        called.append(keys)
+-
+-    opt = _SolverOptions(default, _catch)
+-    opt["opt1"] = 2
+-    opt["opt2"] = 1e-5
+-
+-    assert "opt1" in called
+-    assert "opt2" in called
+-    assert len(called) == 2
+-
+-
+-def test_error():
+-    with pytest.raises(KeyError) as err:
+-        _SolverOptions(default, opt4=4)
+-    assert "opt4" in str(err.value)
+-
+-    with pytest.raises(KeyError) as err:
+-        opt = _SolverOptions(default)
+-        opt["opt4"] = 4
+-    assert "opt4" in str(err.value)
+-
+-
+-def test_print():
+-    opt = _SolverOptions(default, None, "Test options", "Custom doc")
+-    assert "Test options" in opt.__str__()
+-    assert "opt1 : False" in opt.__str__()
+-    assert "opt2 : True" in opt.__str__()
+-    assert "opt3 : None" in opt.__str__()
+-    assert opt.__doc__ == "Custom doc"
+-
+-
+-def test_in_solver():
+-    opt = {"method": "adams", "store_states": True, "atol": 1}
+-    solver = qutip.SESolver(qutip.qeye(1), options=opt)
+-    adams = qutip.integrator.IntegratorScipyAdams
+-    lsoda = qutip.integrator.IntegratorScipylsoda
+-    bdf = qutip.integrator.IntegratorScipyBDF
+-    assert solver.options["store_states"] is True
+-    assert solver.options["method"] == "adams"
+-    assert solver.options["atol"] == 1
+-    assert solver.options["order"] == adams.integrator_options["order"]
+-
+-    solver.options["method"] = "bdf"
+-    assert solver.options["store_states"] is True
+-    assert solver.options["method"] == "bdf"
+-    assert solver.options["atol"] == bdf.integrator_options["atol"]
+-    assert solver.options["order"] == bdf.integrator_options["order"]
+-
+-    solver.options = {
+-        "method": "vern7",
+-        "store_final_state": True,
+-        "atol": 0.01
+-    }
+-    assert solver.options["store_states"] is True
+-    assert solver.options["store_final_state"] is True
+-    assert solver.options["method"] == "vern7"
+-    assert solver.options["atol"] == 0.01
+-    assert "order" not in solver.options
+-    assert "interpolate" in solver.options
+-
+-
+-def test_options_update_solver():
+-    opt = {"method": "adams", "normalize_output": False}
+-    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
+-
+-    solver.start(qutip.basis(1), 0)
+-    err_atol_def = (solver.step(1) - np.exp(1)).norm()
+-
+-    solver.options["atol"] = 1
+-    solver.start(qutip.basis(1), 0)
+-    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
+-
+-    del solver.options["atol"]
+-    solver.start(qutip.basis(1), 0)
+-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
+-
+-    solver.options["atol"] = 1
+-    solver.options["atol"] = None
+-    solver.start(qutip.basis(1), 0)
+-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
+-
+-    solver.options["method"] = "diag"
+-    solver.start(qutip.basis(1), 0)
+-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
++import pytest
++import qutip
++import numpy as np
++from qutip.solver.options import _SolverOptions
++
++
++default = {
++    "opt1": False,
++    "opt2": True,
++    "opt3": None,
++}
++
++
++def test_default():
++    opt = _SolverOptions(default)
++    assert opt
++    assert default.keys() == opt.keys()
++    assert opt["opt1"] is False
++    assert opt["opt2"] is True
++    assert opt["opt3"] is None
++
++
++def test_SolverOptions_dictlike():
++    opt_dict = {
++        "opt1": True,
++        "opt2": None,
++    }
++    opt = _SolverOptions(default, **opt_dict)
++    assert opt
++    assert default.keys() == opt.keys()
++    assert opt["opt1"] is True
++    assert opt["opt2"] is None
++    assert opt["opt3"] is None
++
++    copy = opt.copy()
++    assert opt.items() == copy.items()
++    copy['opt3'] = 2
++    assert opt.items() != copy.items()
++
++    assert len(opt.values()) == 3
++    assert len(opt.items()) == 3
++    assert len(opt.keys()) == 3
++
++
++def test_del():
++    opt_dict = {
++        "opt1": True,
++    }
++    opt = _SolverOptions(default, opt1=True)
++    del opt["opt1"]
++    assert opt["opt1"] is False
++
++
++def test_SolverOptions_Feedback():
++    called = []
++
++    def _catch(keys):
++        assert isinstance(keys, (set, str))
++        called.append(keys)
++
++    opt = _SolverOptions(default, _catch)
++    opt["opt1"] = 2
++    opt["opt2"] = 1e-5
++
++    assert "opt1" in called
++    assert "opt2" in called
++    assert len(called) == 2
++
++
++def test_error():
++    with pytest.raises(KeyError) as err:
++        _SolverOptions(default, opt4=4)
++    assert "opt4" in str(err.value)
++
++    with pytest.raises(KeyError) as err:
++        opt = _SolverOptions(default)
++        opt["opt4"] = 4
++    assert "opt4" in str(err.value)
++
++
++def test_print():
++    opt = _SolverOptions(default, None, "Test options", "Custom doc")
++    assert "Test options" in opt.__str__()
++    assert "opt1 : False" in opt.__str__()
++    assert "opt2 : True" in opt.__str__()
++    assert "opt3 : None" in opt.__str__()
++    assert opt.__doc__ == "Custom doc"
++
++
++def test_in_solver():
++    opt = {"method": "adams", "store_states": True, "atol": 1}
++    solver = qutip.SESolver(qutip.qeye(1), options=opt)
++    adams = qutip.integrator.IntegratorScipyAdams
++    lsoda = qutip.integrator.IntegratorScipylsoda
++    bdf = qutip.integrator.IntegratorScipyBDF
++    assert solver.options["store_states"] is True
++    assert solver.options["method"] == "adams"
++    assert solver.options["atol"] == 1
++    assert solver.options["order"] == adams.integrator_options["order"]
++
++    solver.options["method"] = "bdf"
++    assert solver.options["store_states"] is True
++    assert solver.options["method"] == "bdf"
++    assert solver.options["atol"] == bdf.integrator_options["atol"]
++    assert solver.options["order"] == bdf.integrator_options["order"]
++
++    solver.options = {
++        "method": "vern7",
++        "store_final_state": True,
++        "atol": 0.01
++    }
++    assert solver.options["store_states"] is True
++    assert solver.options["store_final_state"] is True
++    assert solver.options["method"] == "vern7"
++    assert solver.options["atol"] == 0.01
++    assert "order" not in solver.options
++    assert "interpolate" in solver.options
++
++
++def test_options_update_solver():
++    opt = {"method": "adams", "normalize_output": False}
++    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
++
++    solver.start(qutip.basis(1), 0)
++    err_atol_def = (solver.step(1) - np.exp(1)).norm()
++
++    solver.options["atol"] = 1
++    solver.start(qutip.basis(1), 0)
++    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
++
++    del solver.options["atol"]
++    solver.start(qutip.basis(1), 0)
++    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
++
++    solver.options["atol"] = 1
++    solver.options["atol"] = None
++    solver.start(qutip.basis(1), 0)
++    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
++
++    solver.options["method"] = "diag"
++    solver.start(qutip.basis(1), 0)
++    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
+diff --git a/qutip/tests/solver/test_parallel.py b/qutip/tests/solver/test_parallel.py
+index 41636917..9d18a70d 100644
+--- a/qutip/tests/solver/test_parallel.py
++++ b/qutip/tests/solver/test_parallel.py
+@@ -1,121 +1,121 @@
+-import numpy as np
+-import time
+-import pytest
+-import threading
+-
+-from qutip.solver.parallel import (
+-    parallel_map, serial_map, loky_pmap, MapExceptions
+-)
+-
+-
+-def _func1(x):
+-    return x**2
+-
+-
+-def _func2(x, a, b, c, d=0, e=0, f=0):
+-    assert d > 0
+-    assert e > 0
+-    assert f > 0
+-    time.sleep(np.random.rand() * 0.1)  # random delay
+-    return x**2
+-
+-@pytest.mark.parametrize('map', [
+-    pytest.param(parallel_map, id='parallel_map'),
+-    pytest.param(loky_pmap, id='loky_pmap'),
+-    pytest.param(serial_map, id='serial_map'),
+-])
+-@pytest.mark.parametrize('num_cpus',
+-                         [1, 2],
+-                         ids=['1', '2'])
+-def test_map(map, num_cpus):
+-    if map is loky_pmap:
+-        loky = pytest.importorskip("loky")
+-
+-    args = (1, 2, 3)
+-    kwargs = {'d': 4, 'e': 5, 'f': 6}
+-    map_kw = {
+-        'job_timeout': threading.TIMEOUT_MAX,
+-        'timeout': threading.TIMEOUT_MAX,
+-        'num_cpus': num_cpus,
+-    }
+-
+-    x = np.arange(10)
+-    y1 = [_func1(xx) for xx in x]
+-
+-    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
+-    assert ((np.array(y1) == np.array(y2)).all())
+-
+-
+-@pytest.mark.parametrize('map', [
+-    pytest.param(parallel_map, id='parallel_map'),
+-    pytest.param(loky_pmap, id='loky_pmap'),
+-    pytest.param(serial_map, id='serial_map'),
+-])
+-@pytest.mark.parametrize('num_cpus',
+-                         [1, 2],
+-                         ids=['1', '2'])
+-def test_map_accumulator(map, num_cpus):
+-    if map is loky_pmap:
+-        loky = pytest.importorskip("loky")
+-    args = (1, 2, 3)
+-    kwargs = {'d': 4, 'e': 5, 'f': 6}
+-    map_kw = {
+-        'job_timeout': threading.TIMEOUT_MAX,
+-        'timeout': threading.TIMEOUT_MAX,
+-        'num_cpus': num_cpus,
+-    }
+-    y2 = []
+-
+-    x = np.arange(10)
+-    y1 = [_func1(xx) for xx in x]
+-
+-    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
+-    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
+-
+-
+-class CustomException(Exception):
+-    pass
+-
+-
+-def func(i):
+-    if i % 2 == 1:
+-        raise CustomException(f"Error in subprocess {i}")
+-    return i
+-
+-
+-@pytest.mark.parametrize('map', [
+-    pytest.param(parallel_map, id='parallel_map'),
+-    pytest.param(loky_pmap, id='loky_pmap'),
+-    pytest.param(serial_map, id='serial_map'),
+-])
+-def test_map_pass_error(map):
+-    if map is loky_pmap:
+-        loky = pytest.importorskip("loky")
+-
+-    with pytest.raises(CustomException) as err:
+-        map(func, range(10))
+-    assert "Error in subprocess" in str(err.value)
+-
+-
+-@pytest.mark.parametrize('map', [
+-    pytest.param(parallel_map, id='parallel_map'),
+-    pytest.param(loky_pmap, id='loky_pmap'),
+-    pytest.param(serial_map, id='serial_map'),
+-])
+-def test_map_store_error(map):
+-    if map is loky_pmap:
+-        loky = pytest.importorskip("loky")
+-
+-    with pytest.raises(MapExceptions) as err:
+-        map(func, range(10), map_kw={"fail_fast": False})
+-    map_error = err.value
+-    assert "iterations failed" in str(map_error)
+-    for iter, error in map_error.errors.items():
+-        assert isinstance(error, CustomException)
+-        assert f"Error in subprocess {iter}" == str(error)
+-    for n, result in enumerate(map_error.results):
+-        if n % 2 == 0:
+-            # Passed
+-            assert result == n
+-        else:
+-            assert result is None
++import numpy as np
++import time
++import pytest
++import threading
++
++from qutip.solver.parallel import (
++    parallel_map, serial_map, loky_pmap, MapExceptions
++)
++
++
++def _func1(x):
++    return x**2
++
++
++def _func2(x, a, b, c, d=0, e=0, f=0):
++    assert d > 0
++    assert e > 0
++    assert f > 0
++    time.sleep(np.random.rand() * 0.1)  # random delay
++    return x**2
++
++@pytest.mark.parametrize('map', [
++    pytest.param(parallel_map, id='parallel_map'),
++    pytest.param(loky_pmap, id='loky_pmap'),
++    pytest.param(serial_map, id='serial_map'),
++])
++@pytest.mark.parametrize('num_cpus',
++                         [1, 2],
++                         ids=['1', '2'])
++def test_map(map, num_cpus):
++    if map is loky_pmap:
++        loky = pytest.importorskip("loky")
++
++    args = (1, 2, 3)
++    kwargs = {'d': 4, 'e': 5, 'f': 6}
++    map_kw = {
++        'job_timeout': threading.TIMEOUT_MAX,
++        'timeout': threading.TIMEOUT_MAX,
++        'num_cpus': num_cpus,
++    }
++
++    x = np.arange(10)
++    y1 = [_func1(xx) for xx in x]
++
++    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
++    assert ((np.array(y1) == np.array(y2)).all())
++
++
++@pytest.mark.parametrize('map', [
++    pytest.param(parallel_map, id='parallel_map'),
++    pytest.param(loky_pmap, id='loky_pmap'),
++    pytest.param(serial_map, id='serial_map'),
++])
++@pytest.mark.parametrize('num_cpus',
++                         [1, 2],
++                         ids=['1', '2'])
++def test_map_accumulator(map, num_cpus):
++    if map is loky_pmap:
++        loky = pytest.importorskip("loky")
++    args = (1, 2, 3)
++    kwargs = {'d': 4, 'e': 5, 'f': 6}
++    map_kw = {
++        'job_timeout': threading.TIMEOUT_MAX,
++        'timeout': threading.TIMEOUT_MAX,
++        'num_cpus': num_cpus,
++    }
++    y2 = []
++
++    x = np.arange(10)
++    y1 = [_func1(xx) for xx in x]
++
++    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
++    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
++
++
++class CustomException(Exception):
++    pass
++
++
++def func(i):
++    if i % 2 == 1:
++        raise CustomException(f"Error in subprocess {i}")
++    return i
++
++
++@pytest.mark.parametrize('map', [
++    pytest.param(parallel_map, id='parallel_map'),
++    pytest.param(loky_pmap, id='loky_pmap'),
++    pytest.param(serial_map, id='serial_map'),
++])
++def test_map_pass_error(map):
++    if map is loky_pmap:
++        loky = pytest.importorskip("loky")
++
++    with pytest.raises(CustomException) as err:
++        map(func, range(10))
++    assert "Error in subprocess" in str(err.value)
++
++
++@pytest.mark.parametrize('map', [
++    pytest.param(parallel_map, id='parallel_map'),
++    pytest.param(loky_pmap, id='loky_pmap'),
++    pytest.param(serial_map, id='serial_map'),
++])
++def test_map_store_error(map):
++    if map is loky_pmap:
++        loky = pytest.importorskip("loky")
++
++    with pytest.raises(MapExceptions) as err:
++        map(func, range(10), map_kw={"fail_fast": False})
++    map_error = err.value
++    assert "iterations failed" in str(map_error)
++    for iter, error in map_error.errors.items():
++        assert isinstance(error, CustomException)
++        assert f"Error in subprocess {iter}" == str(error)
++    for n, result in enumerate(map_error.results):
++        if n % 2 == 0:
++            # Passed
++            assert result == n
++        else:
++            assert result is None
+diff --git a/qutip/tests/solver/test_propagator.py b/qutip/tests/solver/test_propagator.py
+index 2d36d9f9..0a7393ec 100644
+--- a/qutip/tests/solver/test_propagator.py
++++ b/qutip/tests/solver/test_propagator.py
+@@ -1,140 +1,140 @@
+-import numpy as np
+-from qutip import (destroy, propagator, Propagator, propagator_steadystate,
+-                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
+-import qutip
+-import pytest
+-from qutip.solver.brmesolve import BRSolver
+-from qutip.solver.mesolve import MESolver
+-from qutip.solver.sesolve import SESolver
+-from qutip.solver.mcsolve import MCSolver
+-
+-
+-def testPropHOB():
+-    a = destroy(5)
+-    H = a.dag()*a
+-    U = propagator(H, 1)
+-    U2 = (-1j * H).expm()
+-    assert (U - U2).norm('max') < 1e-4
+-
+-
+-def testPropObj():
+-    opt = {"method": "dop853"}
+-    a = destroy(5)
+-    H = a.dag()*a
+-    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
+-    # Few call to fill the stored propagators.
+-    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
+-    assert len(U.times) == 5
+-    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
+-    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
+-    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
+-    # Within tol, should use the precomupted value at U(0.5)
+-    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
+-
+-
+-def func(t):
+-    return np.cos(t)
+-
+-
+-def testPropHOTd():
+-    "Propagator: func td format"
+-    a = destroy(5)
+-    H = a.dag()*a
+-    Htd = [H, [H, func]]
+-    U = propagator(Htd, 1)
+-    ts = np.linspace(0, 1, 101)
+-    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
+-    assert (U - U2).norm('max') < 1e-4
+-
+-
+-def testPropObjTd():
+-    a = destroy(5)
+-    H = a.dag()*a
+-    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
+-    assert (
+-        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
+-    ).norm('max') < 1e-4
+-    assert (
+-        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
+-    ).norm('max') < 1e-4
+-    assert (
+-        U(1.5, 0.5, w=1.5)
+-        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
+-    ).norm('max') < 1e-4
+-
+-
+-def testPropHOSteady():
+-    "Propagator: steady state"
+-    a = destroy(5)
+-    H = a.dag()*a
+-    c_op_list = []
+-    kappa = 0.1
+-    n_th = 2
+-    rate = kappa * (1 + n_th)
+-    c_op_list.append(np.sqrt(rate) * a)
+-    rate = kappa * n_th
+-    c_op_list.append(np.sqrt(rate) * a.dag())
+-    U = propagator(H, 2*np.pi, c_op_list)
+-    rho_prop = propagator_steadystate(U)
+-    rho_ss = steadystate(H, c_op_list)
+-    assert (rho_prop - rho_ss).norm('max') < 1e-4
+-
+-
+-def testPropHDims():
+-    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
+-    H = tensor([qeye(2), qeye(2)])
+-    U = propagator(H, 1)
+-    assert U.dims == H.dims
+-
+-
+-def testPropEvo():
+-    a = destroy(5)
+-    H = a.dag()*a
+-    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
+-    psi = QobjEvo(U) @ basis(5, 4)
+-    tlist = np.linspace(0, 1, 6)
+-    psi_expected = sesolve(
+-        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
+-    ).states
+-    for t, psi_t in zip(tlist, psi_expected):
+-        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
+-
+-
+-def _make_se(H, a):
+-    return SESolver(H)
+-
+-
+-def _make_me(H, a):
+-    return MESolver(H, [a])
+-
+-
+-def _make_br(H, a):
+-    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
+-    return BRSolver(H, [(a+a.dag(), spectra)])
+-
+-
+-@pytest.mark.parametrize('solver', [
+-    pytest.param(_make_se, id='SESolver'),
+-    pytest.param(_make_me, id='MESolver'),
+-    pytest.param(_make_br, id='BRSolver'),
+-])
+-def testPropSolver(solver):
+-    a = destroy(5)
+-    H = a.dag()*a
+-    U = Propagator(solver(H, a))
+-    c_ops = []
+-    if solver is not _make_se:
+-        c_ops = [a]
+-
+-    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
+-    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
+-    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
+-
+-
+-def testPropMCSolver():
+-    a = destroy(5)
+-    H = a.dag()*a
+-    solver = MCSolver(H, [a])
+-    with pytest.raises(TypeError) as err:
+-        Propagator(solver)
+-    assert str(err.value).startswith("Non-deterministic")
++import numpy as np
++from qutip import (destroy, propagator, Propagator, propagator_steadystate,
++                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
++import qutip
++import pytest
++from qutip.solver.brmesolve import BRSolver
++from qutip.solver.mesolve import MESolver
++from qutip.solver.sesolve import SESolver
++from qutip.solver.mcsolve import MCSolver
++
++
++def testPropHOB():
++    a = destroy(5)
++    H = a.dag()*a
++    U = propagator(H, 1)
++    U2 = (-1j * H).expm()
++    assert (U - U2).norm('max') < 1e-4
++
++
++def testPropObj():
++    opt = {"method": "dop853"}
++    a = destroy(5)
++    H = a.dag()*a
++    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
++    # Few call to fill the stored propagators.
++    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
++    assert len(U.times) == 5
++    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
++    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
++    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
++    # Within tol, should use the precomupted value at U(0.5)
++    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
++
++
++def func(t):
++    return np.cos(t)
++
++
++def testPropHOTd():
++    "Propagator: func td format"
++    a = destroy(5)
++    H = a.dag()*a
++    Htd = [H, [H, func]]
++    U = propagator(Htd, 1)
++    ts = np.linspace(0, 1, 101)
++    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
++    assert (U - U2).norm('max') < 1e-4
++
++
++def testPropObjTd():
++    a = destroy(5)
++    H = a.dag()*a
++    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
++    assert (
++        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
++    ).norm('max') < 1e-4
++    assert (
++        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
++    ).norm('max') < 1e-4
++    assert (
++        U(1.5, 0.5, w=1.5)
++        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
++    ).norm('max') < 1e-4
++
++
++def testPropHOSteady():
++    "Propagator: steady state"
++    a = destroy(5)
++    H = a.dag()*a
++    c_op_list = []
++    kappa = 0.1
++    n_th = 2
++    rate = kappa * (1 + n_th)
++    c_op_list.append(np.sqrt(rate) * a)
++    rate = kappa * n_th
++    c_op_list.append(np.sqrt(rate) * a.dag())
++    U = propagator(H, 2*np.pi, c_op_list)
++    rho_prop = propagator_steadystate(U)
++    rho_ss = steadystate(H, c_op_list)
++    assert (rho_prop - rho_ss).norm('max') < 1e-4
++
++
++def testPropHDims():
++    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
++    H = tensor([qeye(2), qeye(2)])
++    U = propagator(H, 1)
++    assert U.dims == H.dims
++
++
++def testPropEvo():
++    a = destroy(5)
++    H = a.dag()*a
++    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
++    psi = QobjEvo(U) @ basis(5, 4)
++    tlist = np.linspace(0, 1, 6)
++    psi_expected = sesolve(
++        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
++    ).states
++    for t, psi_t in zip(tlist, psi_expected):
++        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
++
++
++def _make_se(H, a):
++    return SESolver(H)
++
++
++def _make_me(H, a):
++    return MESolver(H, [a])
++
++
++def _make_br(H, a):
++    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
++    return BRSolver(H, [(a+a.dag(), spectra)])
++
++
++@pytest.mark.parametrize('solver', [
++    pytest.param(_make_se, id='SESolver'),
++    pytest.param(_make_me, id='MESolver'),
++    pytest.param(_make_br, id='BRSolver'),
++])
++def testPropSolver(solver):
++    a = destroy(5)
++    H = a.dag()*a
++    U = Propagator(solver(H, a))
++    c_ops = []
++    if solver is not _make_se:
++        c_ops = [a]
++
++    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
++    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
++    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
++
++
++def testPropMCSolver():
++    a = destroy(5)
++    H = a.dag()*a
++    solver = MCSolver(H, [a])
++    with pytest.raises(TypeError) as err:
++        Propagator(solver)
++    assert str(err.value).startswith("Non-deterministic")
+diff --git a/qutip/tests/solver/test_results.py b/qutip/tests/solver/test_results.py
+index 3aa46982..2bcfa2e9 100644
+--- a/qutip/tests/solver/test_results.py
++++ b/qutip/tests/solver/test_results.py
+@@ -1,352 +1,352 @@
+-import numpy as np
+-import pytest
+-
+-import qutip
+-from qutip.solver.result import Result, MultiTrajResult, McResult
+-
+-
+-def fill_options(**kwargs):
+-    return {
+-        "store_states": None,
+-        "store_final_state": False,
+-        "keep_runs_results": False,
+-        **kwargs
+-    }
+-
+-
+-def e_op_state_by_time(t, state):
+-    """ An e_ops function that returns the state multiplied by the time. """
+-    return t * state
+-
+-
+-class TestResult:
+-    @pytest.mark.parametrize(["N", "e_ops", "options"], [
+-        pytest.param(10, (), {}, id="no-e-ops"),
+-        pytest.param(
+-            10, qutip.create(10), {"store_states": True}, id="store-states",
+-        )
+-    ])
+-    def test_states(self, N, e_ops, options):
+-        res = Result(e_ops, fill_options(**options))
+-        for i in range(N):
+-            res.add(i, qutip.basis(N, i))
+-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+-        assert res.states == [qutip.basis(N, i) for i in range(N)]
+-        assert res.final_state == qutip.basis(N, N-1)
+-
+-    @pytest.mark.parametrize(["N", "e_ops", "options"], [
+-        pytest.param(10, (), {
+-            "store_states": False, "store_final_state": True
+-        }, id="no-e-ops"),
+-        pytest.param(10, qutip.create(10), {
+-            "store_final_state": True,
+-        }, id="with-eops"),
+-    ])
+-    def test_final_state_only(self, N, e_ops, options):
+-        res = Result(e_ops, fill_options(**options))
+-        for i in range(N):
+-            res.add(i, qutip.basis(N, i))
+-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+-        assert res.states == []
+-        assert res.final_state == qutip.basis(N, N-1)
+-
+-    @pytest.mark.parametrize(["N", "e_ops", "results"], [
+-        pytest.param(
+-            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
+-        ),
+-        pytest.param(
+-            10,
+-            [qutip.num(10), qutip.qeye(10)],
+-            {0: np.arange(10), 1: np.ones(10)},
+-            id="list-e-ops",
+-        ),
+-        pytest.param(
+-            10,
+-            {"a": qutip.num(10), "b": qutip.qeye(10)},
+-            {"a": np.arange(10), "b": np.ones(10)},
+-            id="dict-e-ops",
+-        ),
+-        pytest.param(
+-            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
+-        ),
+-        pytest.param(
+-            5, e_op_state_by_time,
+-            {0: [i * qutip.basis(5, i) for i in range(5)]},
+-            id="function",
+-        )
+-    ])
+-    def test_expect_and_e_ops(self, N, e_ops, results):
+-        res = Result(
+-            e_ops,
+-            fill_options(
+-                store_final_state=False,
+-                store_states=False),
+-        )
+-        if isinstance(e_ops, dict):
+-            raw_ops = e_ops
+-        elif isinstance(e_ops, (list, tuple)):
+-            raw_ops = dict(enumerate(e_ops))
+-        else:
+-            raw_ops = {0: e_ops}
+-        for i in range(N):
+-            res.add(i, qutip.basis(N, i))
+-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+-        assert res.final_state is None
+-        assert not res.states
+-        for i, k in enumerate(results):
+-            assert res.e_ops[k].op is raw_ops[k]
+-            e_op_call_values = [
+-                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
+-            ]
+-            if isinstance(res.expect[i][0], qutip.Qobj):
+-                assert (res.expect[i] == results[k]).all()
+-                assert res.e_data[k] == results[k]
+-                assert e_op_call_values == results[k]
+-            else:
+-                np.testing.assert_allclose(res.expect[i], results[k])
+-                np.testing.assert_allclose(res.e_data[k], results[k])
+-                np.testing.assert_allclose(e_op_call_values, results[k])
+-
+-    def test_add_processor(self):
+-        res = Result([], fill_options(store_states=False))
+-        a = []
+-        b = []
+-        states = [{"t": 0}, {"t": 1}]
+-
+-        res.add_processor(lambda t, state: a.append((t, state)))
+-        res.add(0, states[0])
+-        res.add_processor(
+-            lambda t, state: b.append((t, state)),
+-            requires_copy=True,
+-        )
+-        res.add(1, states[1])
+-
+-        assert a == [(0, {"t": 0}), (1, {"t": 1})]
+-        assert a[0][1] is states[0]  # no copy made
+-        assert a[1][1] is not states[1]  # copy made (for b)
+-        assert b == [(1, {"t": 1})]
+-        assert b[0][1] is not states[1]  # copy made
+-
+-    def test_repr_minimal(self):
+-        res = Result(
+-            [],
+-            fill_options(store_final_state=False, store_states=False),
+-        )
+-        assert repr(res) == "\n".join([
+-            "<Result",
+-            "  Solver: None",
+-            "  Number of e_ops: 0",
+-            "  State not saved.",
+-            ">",
+-        ])
+-
+-    def test_repr_full(self):
+-        res = Result(
+-            [qutip.num(5), qutip.qeye(5)],
+-            fill_options(store_states=True),
+-            solver="test-solver",
+-            stats={"stat-a": 1, "stat-b": 2},
+-        )
+-        for i in range(5):
+-            res.add(i, qutip.basis(5, i))
+-        assert repr(res) == "\n".join([
+-            "<Result",
+-            "  Solver: test-solver",
+-            "  Solver stats:",
+-            "    stat-a: 1",
+-            "    stat-b: 2",
+-            "  Time interval: [0, 4] (5 steps)",
+-            "  Number of e_ops: 2",
+-            "  States saved.",
+-            ">",
+-        ])
+-
+-
+-def e_op_num(t, state):
+-    """ An e_ops function that returns the ground state occupation. """
+-    return state.dag() @ qutip.num(5) @ state
+-
+-
+-class TestMultiTrajResult:
+-    def _fill_trajectories(self, multiresult, N, ntraj,
+-                           collapse=False, noise=0, dm=False):
+-        for _ in range(ntraj):
+-            result = Result(multiresult._raw_ops, multiresult.options)
+-            result.collapse = []
+-            for t in range(N):
+-                delta = 1 + noise * np.random.randn()
+-                state = qutip.basis(N, t) * delta
+-                if dm:
+-                    state = state.proj()
+-                result.add(t, state)
+-                if collapse:
+-                    result.collapse.append((t+0.1, 0))
+-                    result.collapse.append((t+0.2, 1))
+-                    result.collapse.append((t+0.3, 1))
+-            if multiresult.add((0, result)) <= 0:
+-                break
+-
+-    def _expect_check_types(self, multiresult):
+-        assert isinstance(multiresult.std_expect, list)
+-        assert isinstance(multiresult.average_e_data, dict)
+-        assert isinstance(multiresult.std_expect, list)
+-        assert isinstance(multiresult.average_e_data, dict)
+-
+-        if multiresult.trajectories:
+-            assert isinstance(multiresult.runs_expect, list)
+-            assert isinstance(multiresult.runs_e_data, dict)
+-        else:
+-            assert multiresult.runs_expect == []
+-            assert multiresult.runs_e_data == {}
+-
+-    @pytest.mark.parametrize('keep_runs_results', [True, False])
+-    @pytest.mark.parametrize('dm', [True, False])
+-    def test_McResult(self, dm, keep_runs_results):
+-        N = 10
+-        ntraj = 5
+-        e_ops = [qutip.num(N), qutip.qeye(N)]
+-        opt = fill_options(keep_runs_results=keep_runs_results)
+-
+-        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
+-        m_res.add_end_condition(ntraj, None)
+-        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
+-
+-        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
+-        assert m_res.stats['end_condition'] == "ntraj reached"
+-        self._expect_check_types(m_res)
+-
+-        assert np.all(np.array(m_res.col_which) < 2)
+-        assert isinstance(m_res.collapse, list)
+-        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
+-        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
+-        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
+-
+-    @pytest.mark.parametrize('keep_runs_results', [True, False])
+-    @pytest.mark.parametrize(["e_ops", "results"], [
+-        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
+-        pytest.param(
+-            {"a": qutip.num(5), "b": qutip.qeye(5)},
+-            [np.arange(5), np.ones(5)],
+-            id="dict-e-ops",
+-        ),
+-        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
+-        pytest.param(e_op_num, [np.arange(5)], id="function"),
+-        pytest.param(
+-            [qutip.num(5), e_op_num],
+-            [np.arange(5), np.arange(5)],
+-            id="list-e-ops",
+-        ),
+-    ])
+-    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
+-        N = 5
+-        ntraj = 25
+-        opt = fill_options(keep_runs_results=keep_runs_results)
+-        m_res = MultiTrajResult(e_ops, opt, stats={})
+-        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
+-
+-        for expect, expected in zip(m_res.average_expect, results):
+-            np.testing.assert_allclose(expect, expected,
+-                                       atol=1e-14, rtol=0.02)
+-
+-        for variance, expected in zip(m_res.std_expect, results):
+-            np.testing.assert_allclose(variance, 0.02 * expected,
+-                                       atol=1e-14, rtol=0.9)
+-
+-        if keep_runs_results:
+-            for runs_expect, expected in zip(m_res.runs_expect, results):
+-                for expect in runs_expect:
+-                    np.testing.assert_allclose(expect, expected,
+-                                               atol=1e-14, rtol=0.1)
+-
+-        self._expect_check_types(m_res)
+-
+-        assert m_res.stats['end_condition'] == "unknown"
+-
+-    @pytest.mark.parametrize('keep_runs_results', [True, False])
+-    @pytest.mark.parametrize('dm', [True, False])
+-    def test_multitraj_state(self, keep_runs_results, dm):
+-        N = 5
+-        ntraj = 25
+-        opt = fill_options(keep_runs_results=keep_runs_results)
+-        m_res = MultiTrajResult([], opt)
+-        self._fill_trajectories(m_res, N, ntraj, dm=dm)
+-
+-        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
+-
+-        for i in range(N):
+-            assert m_res.average_states[i] == qutip.fock_dm(N, i)
+-        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
+-
+-        if keep_runs_results:
+-            assert len(m_res.runs_states) == 25
+-            assert len(m_res.runs_states[0]) == N
+-            for i in range(ntraj):
+-                expected = qutip.basis(N, N-1)
+-                if dm:
+-                    expected = expected.proj()
+-                assert m_res.runs_final_states[i] == expected
+-
+-    @pytest.mark.parametrize('keep_runs_results', [True, False])
+-    @pytest.mark.parametrize('targettol', [
+-        pytest.param(0.1, id='atol'),
+-        pytest.param([0.001, 0.1], id='rtol'),
+-        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
+-    ])
+-    def test_multitraj_targettol(self, keep_runs_results, targettol):
+-        N = 10
+-        ntraj = 1000
+-        opt = fill_options(
+-            keep_runs_results=keep_runs_results, store_states=True
+-        )
+-        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
+-        m_res.add_end_condition(ntraj, targettol)
+-        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
+-
+-        assert m_res.stats['end_condition'] == "target tolerance reached"
+-        assert m_res.num_trajectories <= 1000
+-
+-    def test_multitraj_steadystate(self):
+-        N = 5
+-        ntraj = 100
+-        opt = fill_options()
+-        m_res = MultiTrajResult([], opt, stats={})
+-        m_res.add_end_condition(1000)
+-        self._fill_trajectories(m_res, N, ntraj)
+-        assert m_res.stats['end_condition'] == "timeout"
+-        assert m_res.steady_state() == qutip.qeye(5) / 5
+-
+-    @pytest.mark.parametrize('keep_runs_results', [True, False])
+-    def test_repr(self, keep_runs_results):
+-        N = 10
+-        ntraj = 10
+-        opt = fill_options(keep_runs_results=keep_runs_results)
+-        m_res = MultiTrajResult([], opt)
+-        self._fill_trajectories(m_res, N, ntraj)
+-        repr = m_res.__repr__()
+-        assert "Number of trajectories: 10" in repr
+-        if keep_runs_results:
+-            assert "Trajectories saved." in repr
+-
+-    @pytest.mark.parametrize('keep_runs_results', [True, False])
+-    def test_merge_result(self, keep_runs_results):
+-        N = 10
+-        opt = fill_options(
+-            keep_runs_results=keep_runs_results, store_states=True
+-        )
+-        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
+-        self._fill_trajectories(m_res1, N, 10, noise=0.1)
+-
+-        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
+-        self._fill_trajectories(m_res2, N, 30, noise=0.1)
+-
+-        merged_res = m_res1 + m_res2
+-        assert merged_res.num_trajectories == 40
+-        np.testing.assert_allclose(merged_res.average_expect[0],
+-                                   np.arange(10), rtol=0.1)
+-        np.testing.assert_allclose(
+-            np.diag(sum(merged_res.average_states).full()),
+-            np.ones(N),
+-            rtol=0.1
+-        )
+-        assert bool(merged_res.trajectories) == keep_runs_results
+-        assert merged_res.stats["run time"] == 3
++import numpy as np
++import pytest
++
++import qutip
++from qutip.solver.result import Result, MultiTrajResult, McResult
++
++
++def fill_options(**kwargs):
++    return {
++        "store_states": None,
++        "store_final_state": False,
++        "keep_runs_results": False,
++        **kwargs
++    }
++
++
++def e_op_state_by_time(t, state):
++    """ An e_ops function that returns the state multiplied by the time. """
++    return t * state
++
++
++class TestResult:
++    @pytest.mark.parametrize(["N", "e_ops", "options"], [
++        pytest.param(10, (), {}, id="no-e-ops"),
++        pytest.param(
++            10, qutip.create(10), {"store_states": True}, id="store-states",
++        )
++    ])
++    def test_states(self, N, e_ops, options):
++        res = Result(e_ops, fill_options(**options))
++        for i in range(N):
++            res.add(i, qutip.basis(N, i))
++        np.testing.assert_allclose(np.array(res.times), np.arange(N))
++        assert res.states == [qutip.basis(N, i) for i in range(N)]
++        assert res.final_state == qutip.basis(N, N-1)
++
++    @pytest.mark.parametrize(["N", "e_ops", "options"], [
++        pytest.param(10, (), {
++            "store_states": False, "store_final_state": True
++        }, id="no-e-ops"),
++        pytest.param(10, qutip.create(10), {
++            "store_final_state": True,
++        }, id="with-eops"),
++    ])
++    def test_final_state_only(self, N, e_ops, options):
++        res = Result(e_ops, fill_options(**options))
++        for i in range(N):
++            res.add(i, qutip.basis(N, i))
++        np.testing.assert_allclose(np.array(res.times), np.arange(N))
++        assert res.states == []
++        assert res.final_state == qutip.basis(N, N-1)
++
++    @pytest.mark.parametrize(["N", "e_ops", "results"], [
++        pytest.param(
++            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
++        ),
++        pytest.param(
++            10,
++            [qutip.num(10), qutip.qeye(10)],
++            {0: np.arange(10), 1: np.ones(10)},
++            id="list-e-ops",
++        ),
++        pytest.param(
++            10,
++            {"a": qutip.num(10), "b": qutip.qeye(10)},
++            {"a": np.arange(10), "b": np.ones(10)},
++            id="dict-e-ops",
++        ),
++        pytest.param(
++            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
++        ),
++        pytest.param(
++            5, e_op_state_by_time,
++            {0: [i * qutip.basis(5, i) for i in range(5)]},
++            id="function",
++        )
++    ])
++    def test_expect_and_e_ops(self, N, e_ops, results):
++        res = Result(
++            e_ops,
++            fill_options(
++                store_final_state=False,
++                store_states=False),
++        )
++        if isinstance(e_ops, dict):
++            raw_ops = e_ops
++        elif isinstance(e_ops, (list, tuple)):
++            raw_ops = dict(enumerate(e_ops))
++        else:
++            raw_ops = {0: e_ops}
++        for i in range(N):
++            res.add(i, qutip.basis(N, i))
++        np.testing.assert_allclose(np.array(res.times), np.arange(N))
++        assert res.final_state is None
++        assert not res.states
++        for i, k in enumerate(results):
++            assert res.e_ops[k].op is raw_ops[k]
++            e_op_call_values = [
++                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
++            ]
++            if isinstance(res.expect[i][0], qutip.Qobj):
++                assert (res.expect[i] == results[k]).all()
++                assert res.e_data[k] == results[k]
++                assert e_op_call_values == results[k]
++            else:
++                np.testing.assert_allclose(res.expect[i], results[k])
++                np.testing.assert_allclose(res.e_data[k], results[k])
++                np.testing.assert_allclose(e_op_call_values, results[k])
++
++    def test_add_processor(self):
++        res = Result([], fill_options(store_states=False))
++        a = []
++        b = []
++        states = [{"t": 0}, {"t": 1}]
++
++        res.add_processor(lambda t, state: a.append((t, state)))
++        res.add(0, states[0])
++        res.add_processor(
++            lambda t, state: b.append((t, state)),
++            requires_copy=True,
++        )
++        res.add(1, states[1])
++
++        assert a == [(0, {"t": 0}), (1, {"t": 1})]
++        assert a[0][1] is states[0]  # no copy made
++        assert a[1][1] is not states[1]  # copy made (for b)
++        assert b == [(1, {"t": 1})]
++        assert b[0][1] is not states[1]  # copy made
++
++    def test_repr_minimal(self):
++        res = Result(
++            [],
++            fill_options(store_final_state=False, store_states=False),
++        )
++        assert repr(res) == "\n".join([
++            "<Result",
++            "  Solver: None",
++            "  Number of e_ops: 0",
++            "  State not saved.",
++            ">",
++        ])
++
++    def test_repr_full(self):
++        res = Result(
++            [qutip.num(5), qutip.qeye(5)],
++            fill_options(store_states=True),
++            solver="test-solver",
++            stats={"stat-a": 1, "stat-b": 2},
++        )
++        for i in range(5):
++            res.add(i, qutip.basis(5, i))
++        assert repr(res) == "\n".join([
++            "<Result",
++            "  Solver: test-solver",
++            "  Solver stats:",
++            "    stat-a: 1",
++            "    stat-b: 2",
++            "  Time interval: [0, 4] (5 steps)",
++            "  Number of e_ops: 2",
++            "  States saved.",
++            ">",
++        ])
++
++
++def e_op_num(t, state):
++    """ An e_ops function that returns the ground state occupation. """
++    return state.dag() @ qutip.num(5) @ state
++
++
++class TestMultiTrajResult:
++    def _fill_trajectories(self, multiresult, N, ntraj,
++                           collapse=False, noise=0, dm=False):
++        for _ in range(ntraj):
++            result = Result(multiresult._raw_ops, multiresult.options)
++            result.collapse = []
++            for t in range(N):
++                delta = 1 + noise * np.random.randn()
++                state = qutip.basis(N, t) * delta
++                if dm:
++                    state = state.proj()
++                result.add(t, state)
++                if collapse:
++                    result.collapse.append((t+0.1, 0))
++                    result.collapse.append((t+0.2, 1))
++                    result.collapse.append((t+0.3, 1))
++            if multiresult.add((0, result)) <= 0:
++                break
++
++    def _expect_check_types(self, multiresult):
++        assert isinstance(multiresult.std_expect, list)
++        assert isinstance(multiresult.average_e_data, dict)
++        assert isinstance(multiresult.std_expect, list)
++        assert isinstance(multiresult.average_e_data, dict)
++
++        if multiresult.trajectories:
++            assert isinstance(multiresult.runs_expect, list)
++            assert isinstance(multiresult.runs_e_data, dict)
++        else:
++            assert multiresult.runs_expect == []
++            assert multiresult.runs_e_data == {}
++
++    @pytest.mark.parametrize('keep_runs_results', [True, False])
++    @pytest.mark.parametrize('dm', [True, False])
++    def test_McResult(self, dm, keep_runs_results):
++        N = 10
++        ntraj = 5
++        e_ops = [qutip.num(N), qutip.qeye(N)]
++        opt = fill_options(keep_runs_results=keep_runs_results)
++
++        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
++        m_res.add_end_condition(ntraj, None)
++        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
++
++        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
++        assert m_res.stats['end_condition'] == "ntraj reached"
++        self._expect_check_types(m_res)
++
++        assert np.all(np.array(m_res.col_which) < 2)
++        assert isinstance(m_res.collapse, list)
++        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
++        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
++        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
++
++    @pytest.mark.parametrize('keep_runs_results', [True, False])
++    @pytest.mark.parametrize(["e_ops", "results"], [
++        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
++        pytest.param(
++            {"a": qutip.num(5), "b": qutip.qeye(5)},
++            [np.arange(5), np.ones(5)],
++            id="dict-e-ops",
++        ),
++        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
++        pytest.param(e_op_num, [np.arange(5)], id="function"),
++        pytest.param(
++            [qutip.num(5), e_op_num],
++            [np.arange(5), np.arange(5)],
++            id="list-e-ops",
++        ),
++    ])
++    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
++        N = 5
++        ntraj = 25
++        opt = fill_options(keep_runs_results=keep_runs_results)
++        m_res = MultiTrajResult(e_ops, opt, stats={})
++        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
++
++        for expect, expected in zip(m_res.average_expect, results):
++            np.testing.assert_allclose(expect, expected,
++                                       atol=1e-14, rtol=0.02)
++
++        for variance, expected in zip(m_res.std_expect, results):
++            np.testing.assert_allclose(variance, 0.02 * expected,
++                                       atol=1e-14, rtol=0.9)
++
++        if keep_runs_results:
++            for runs_expect, expected in zip(m_res.runs_expect, results):
++                for expect in runs_expect:
++                    np.testing.assert_allclose(expect, expected,
++                                               atol=1e-14, rtol=0.1)
++
++        self._expect_check_types(m_res)
++
++        assert m_res.stats['end_condition'] == "unknown"
++
++    @pytest.mark.parametrize('keep_runs_results', [True, False])
++    @pytest.mark.parametrize('dm', [True, False])
++    def test_multitraj_state(self, keep_runs_results, dm):
++        N = 5
++        ntraj = 25
++        opt = fill_options(keep_runs_results=keep_runs_results)
++        m_res = MultiTrajResult([], opt)
++        self._fill_trajectories(m_res, N, ntraj, dm=dm)
++
++        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
++
++        for i in range(N):
++            assert m_res.average_states[i] == qutip.fock_dm(N, i)
++        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
++
++        if keep_runs_results:
++            assert len(m_res.runs_states) == 25
++            assert len(m_res.runs_states[0]) == N
++            for i in range(ntraj):
++                expected = qutip.basis(N, N-1)
++                if dm:
++                    expected = expected.proj()
++                assert m_res.runs_final_states[i] == expected
++
++    @pytest.mark.parametrize('keep_runs_results', [True, False])
++    @pytest.mark.parametrize('targettol', [
++        pytest.param(0.1, id='atol'),
++        pytest.param([0.001, 0.1], id='rtol'),
++        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
++    ])
++    def test_multitraj_targettol(self, keep_runs_results, targettol):
++        N = 10
++        ntraj = 1000
++        opt = fill_options(
++            keep_runs_results=keep_runs_results, store_states=True
++        )
++        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
++        m_res.add_end_condition(ntraj, targettol)
++        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
++
++        assert m_res.stats['end_condition'] == "target tolerance reached"
++        assert m_res.num_trajectories <= 1000
++
++    def test_multitraj_steadystate(self):
++        N = 5
++        ntraj = 100
++        opt = fill_options()
++        m_res = MultiTrajResult([], opt, stats={})
++        m_res.add_end_condition(1000)
++        self._fill_trajectories(m_res, N, ntraj)
++        assert m_res.stats['end_condition'] == "timeout"
++        assert m_res.steady_state() == qutip.qeye(5) / 5
++
++    @pytest.mark.parametrize('keep_runs_results', [True, False])
++    def test_repr(self, keep_runs_results):
++        N = 10
++        ntraj = 10
++        opt = fill_options(keep_runs_results=keep_runs_results)
++        m_res = MultiTrajResult([], opt)
++        self._fill_trajectories(m_res, N, ntraj)
++        repr = m_res.__repr__()
++        assert "Number of trajectories: 10" in repr
++        if keep_runs_results:
++            assert "Trajectories saved." in repr
++
++    @pytest.mark.parametrize('keep_runs_results', [True, False])
++    def test_merge_result(self, keep_runs_results):
++        N = 10
++        opt = fill_options(
++            keep_runs_results=keep_runs_results, store_states=True
++        )
++        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
++        self._fill_trajectories(m_res1, N, 10, noise=0.1)
++
++        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
++        self._fill_trajectories(m_res2, N, 30, noise=0.1)
++
++        merged_res = m_res1 + m_res2
++        assert merged_res.num_trajectories == 40
++        np.testing.assert_allclose(merged_res.average_expect[0],
++                                   np.arange(10), rtol=0.1)
++        np.testing.assert_allclose(
++            np.diag(sum(merged_res.average_states).full()),
++            np.ones(N),
++            rtol=0.1
++        )
++        assert bool(merged_res.trajectories) == keep_runs_results
++        assert merged_res.stats["run time"] == 3
+diff --git a/qutip/tests/solver/test_scattering.py b/qutip/tests/solver/test_scattering.py
+index 0ad7257e..33905067 100644
+--- a/qutip/tests/solver/test_scattering.py
++++ b/qutip/tests/solver/test_scattering.py
+@@ -1,92 +1,92 @@
+-"""
+-This module includes a collection of testing functions for the QuTiP scattering
+-module. Tests are approximate with low resolution to minimize runtime.
+-"""
+-
+-# Author:  Ben Bartlett
+-# Contact: benbartlett@stanford.edu
+-
+-import numpy as np
+-from numpy.testing import assert_, run_module_suite
+-from qutip import create, destroy, basis
+-from qutip.solver.scattering import *
+-
+-
+-class TestScattering:
+-    """
+-    A test class for the QuTiP quantum optical scattering module. These tests
+-    only use the two-level system for comparison, since larger systems can
+-    take a long time to run.
+-    """
+-
+-    def testScatteringProbability(self):
+-        """
+-        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
+-        """
+-        w0 = 1.0 * 2 * np.pi
+-        gamma = 1.0
+-        sm = np.sqrt(gamma) * destroy(2)
+-        pulseArea = np.pi
+-        pulseLength = 0.2 / gamma
+-        RabiFreq = pulseArea / (2 * pulseLength)
+-        psi0 = basis(2, 0)
+-        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
+-        # Define TLS Hamiltonian
+-        H0S = w0 * create(2) * destroy(2)
+-        H1S1 = lambda t, args: \
+-            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
+-        H1S2 = lambda t, args: \
+-            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
+-        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
+-        # Run the test
+-        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
+-        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
+-        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
+-        assert P0 < 1e-3
+-        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
+-
+-    def testScatteringAmplitude(self):
+-        """
+-        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
+-        """
+-        w0 = 1.0 * 2 * np.pi
+-        gamma = 1.0
+-        sm = np.sqrt(gamma) * destroy(2)
+-        pulseArea = 2 * np.pi
+-        pulseLength = 0.2 / gamma
+-        RabiFreq = pulseArea / (2 * pulseLength)
+-        psi0 = basis(2, 0)
+-        T = 50
+-        tlist = np.linspace(0, 1 / gamma, T)
+-        # Define TLS Hamiltonian
+-        H0S = w0 * create(2) * destroy(2)
+-        H1S1 = lambda t, args: \
+-            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
+-        H1S2 = lambda t, args: \
+-            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
+-        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
+-        # Run the test
+-        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
+-        basisVec = temporal_basis_vector([[40]], T)
+-        assert np.abs(basisVec.dag() @ state) < 1e-3
+-
+-    def testWaveguideSplit(self):
+-        """
+-        Checks that a trivial splitting of a waveguide collapse operator like
+-        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
+-        """
+-        gamma = 1.0
+-        sm = np.sqrt(gamma) * destroy(2)
+-        pulseArea = np.pi
+-        pulseLength = 0.2 / gamma
+-        RabiFreq = pulseArea / (2 * pulseLength)
+-        psi0 = basis(2, 0)
+-        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
+-        # Define TLS Hamiltonian with rotating frame transformation
+-        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
+-        # Run the test
+-        c_ops = [sm]
+-        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
+-        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
+-        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
+-        assert np.abs(P1/P1_split - 1) < 1e-7
++"""
++This module includes a collection of testing functions for the QuTiP scattering
++module. Tests are approximate with low resolution to minimize runtime.
++"""
++
++# Author:  Ben Bartlett
++# Contact: benbartlett@stanford.edu
++
++import numpy as np
++from numpy.testing import assert_, run_module_suite
++from qutip import create, destroy, basis
++from qutip.solver.scattering import *
++
++
++class TestScattering:
++    """
++    A test class for the QuTiP quantum optical scattering module. These tests
++    only use the two-level system for comparison, since larger systems can
++    take a long time to run.
++    """
++
++    def testScatteringProbability(self):
++        """
++        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
++        """
++        w0 = 1.0 * 2 * np.pi
++        gamma = 1.0
++        sm = np.sqrt(gamma) * destroy(2)
++        pulseArea = np.pi
++        pulseLength = 0.2 / gamma
++        RabiFreq = pulseArea / (2 * pulseLength)
++        psi0 = basis(2, 0)
++        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
++        # Define TLS Hamiltonian
++        H0S = w0 * create(2) * destroy(2)
++        H1S1 = lambda t, args: \
++            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
++        H1S2 = lambda t, args: \
++            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
++        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
++        # Run the test
++        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
++        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
++        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
++        assert P0 < 1e-3
++        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
++
++    def testScatteringAmplitude(self):
++        """
++        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
++        """
++        w0 = 1.0 * 2 * np.pi
++        gamma = 1.0
++        sm = np.sqrt(gamma) * destroy(2)
++        pulseArea = 2 * np.pi
++        pulseLength = 0.2 / gamma
++        RabiFreq = pulseArea / (2 * pulseLength)
++        psi0 = basis(2, 0)
++        T = 50
++        tlist = np.linspace(0, 1 / gamma, T)
++        # Define TLS Hamiltonian
++        H0S = w0 * create(2) * destroy(2)
++        H1S1 = lambda t, args: \
++            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
++        H1S2 = lambda t, args: \
++            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
++        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
++        # Run the test
++        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
++        basisVec = temporal_basis_vector([[40]], T)
++        assert np.abs(basisVec.dag() @ state) < 1e-3
++
++    def testWaveguideSplit(self):
++        """
++        Checks that a trivial splitting of a waveguide collapse operator like
++        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
++        """
++        gamma = 1.0
++        sm = np.sqrt(gamma) * destroy(2)
++        pulseArea = np.pi
++        pulseLength = 0.2 / gamma
++        RabiFreq = pulseArea / (2 * pulseLength)
++        psi0 = basis(2, 0)
++        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
++        # Define TLS Hamiltonian with rotating frame transformation
++        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
++        # Run the test
++        c_ops = [sm]
++        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
++        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
++        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
++        assert np.abs(P1/P1_split - 1) < 1e-7
+diff --git a/qutip/tests/solver/test_sesolve.py b/qutip/tests/solver/test_sesolve.py
+index 5ca744f9..1814b0ca 100644
+--- a/qutip/tests/solver/test_sesolve.py
++++ b/qutip/tests/solver/test_sesolve.py
+@@ -1,301 +1,301 @@
+-import pytest
+-import pickle
+-import qutip
+-import numpy as np
+-from qutip.solver.sesolve import sesolve, SESolver
+-from qutip.solver.krylovsolve import krylovsolve
+-from qutip.solver.solver_base import Solver
+-
+-all_ode_method = [
+-    method for method, integrator in SESolver.avail_integrators().items()
+-    if integrator.support_time_dependant
+-]
+-
+-def _analytic(t, alpha):
+-    return ((1 - np.exp(-alpha * t)) / alpha)
+-
+-
+-class TestSeSolve():
+-    H0 = 0.2 * np.pi * qutip.sigmaz()
+-    H1 = np.pi * qutip.sigmax()
+-    tlist = np.linspace(0, 20, 200)
+-    args = {'alpha': 0.5}
+-    w_a = 0.35
+-    a = 0.5
+-
+-    @pytest.mark.parametrize(['unitary_op'], [
+-        pytest.param(None, id="state"),
+-        pytest.param(qutip.qeye(2), id="unitary"),
+-    ])
+-    @pytest.mark.parametrize(['H', 'analytical'], [
+-        pytest.param(H1, lambda t, _: t, id='const_H'),
+-        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
+-                                       * np.exp(-alpha * t)),
+-                     _analytic, id='func_H'),
+-        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
+-                     _analytic, id='list_func_H'),
+-        pytest.param([[H1, 'exp(-alpha*t)']],
+-                     _analytic, id='list_str_H'),
+-        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
+-                     _analytic, id='list_array_H'),
+-        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
+-                     _analytic, id='QobjEvo_H'),
+-    ])
+-    def test_sesolve(self, H, analytical, unitary_op):
+-        """
+-        Compare integrated evolution with analytical result
+-        If U0 is not None then operator evo is checked
+-        Otherwise state evo
+-        """
+-        tol = 5e-3
+-        psi0 = qutip.basis(2, 0)
+-        options = {"progress_bar": None}
+-
+-        if unitary_op is None:
+-            output = sesolve(H, psi0, self.tlist,
+-                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
+-                             args=self.args, options=options)
+-            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
+-        else:
+-            output = sesolve(H, unitary_op, self.tlist, args=self.args,
+-                             options=options)
+-            sx = [qutip.expect(qutip.sigmax(), U * psi0)
+-                  for U in output.states]
+-            sy = [qutip.expect(qutip.sigmay(), U * psi0)
+-                  for U in output.states]
+-            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
+-                  for U in output.states]
+-
+-        sx_analytic = np.zeros(np.shape(self.tlist))
+-        sy_analytic = np.array(
+-            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
+-             for t in self.tlist]
+-        )
+-        sz_analytic = np.array(
+-            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
+-             for t in self.tlist]
+-        )
+-
+-        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
+-        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
+-        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
+-
+-    @pytest.mark.parametrize(['state_type'], [
+-        pytest.param("ket", id="ket"),
+-        pytest.param("unitary", id="unitary"),
+-    ])
+-    def test_sesolve_normalization(self, state_type):
+-        # non-hermitean H causes state to evolve non-unitarily
+-        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
+-        psi0 = qutip.basis(2, 0)
+-        options = {"normalize_output": True, "progress_bar": None}
+-
+-        if state_type == "ket":
+-            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
+-            norms = [state.norm() for state in output.states]
+-            np.testing.assert_allclose(
+-                norms, [1.0 for _ in self.tlist], atol=1e-15,
+-            )
+-        else:
+-            # evolution of unitaries should not be normalized
+-            U = qutip.qeye(2)
+-            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
+-            norms = [state.norm() for state in output.states]
+-            assert all(norm > 2 for norm in norms[1:])
+-
+-    @pytest.mark.parametrize(['unitary_op'], [
+-        pytest.param(None, id="state"),
+-        pytest.param(qutip.qeye(2), id="unitary"),
+-    ])
+-    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
+-    def test_sesolve_method(self, method, unitary_op):
+-        """
+-        Compare integrated evolution with analytical result
+-        If U0 is not None then operator evo is checked
+-        Otherwise state evo
+-        """
+-        tol = 5e-3
+-        psi0 = qutip.basis(2, 0)
+-        options = {"method": method, "progress_bar": None}
+-        H = [[self.H1, 'exp(-alpha*t)']]
+-
+-        if unitary_op is None:
+-            output = sesolve(H, psi0, self.tlist,
+-                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
+-                             args=self.args, options=options)
+-            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
+-        else:
+-            output = sesolve(H, unitary_op, self.tlist,
+-                             args=self.args, options=options)
+-            sx = [qutip.expect(qutip.sigmax(), U * psi0)
+-                  for U in output.states]
+-            sy = [qutip.expect(qutip.sigmay(), U * psi0)
+-                  for U in output.states]
+-            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
+-                  for U in output.states]
+-
+-        sx_analytic = np.zeros(np.shape(self.tlist))
+-        sy_analytic = np.array(
+-            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
+-             for t in self.tlist]
+-        )
+-        sz_analytic = np.array(
+-            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
+-             for t in self.tlist]
+-        )
+-
+-        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
+-        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
+-        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
+-
+-    @pytest.mark.parametrize('normalize', [True, False],
+-                             ids=['Normalized', ''])
+-    @pytest.mark.parametrize(['H', 'args'],
+-        [pytest.param(H0 + H1, {}, id='const_H'),
+-         pytest.param(lambda t, a, w_a: (
+-             a * t * 0.2 * np.pi * qutip.sigmaz() +
+-             np.cos(w_a * t) * np.pi * qutip.sigmax()
+-         ), {'a':a, 'w_a':w_a}, id='func_H'),
+-         pytest.param([
+-             [H0, lambda t, args: args['a']*t],
+-             [H1, lambda t, args: np.cos(args['w_a']*t)]
+-         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
+-         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
+-    ])
+-    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
+-        """
+-        Compare integrated evolution of unitary operator with state evo
+-        """
+-        psi0 = qutip.basis(2, 0)
+-        U0 = qutip.qeye(2)
+-
+-        options = {
+-            "store_states": True,
+-            "normalize_output": normalize,
+-            "progress_bar": None
+-        }
+-        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
+-                                              qutip.sigmay(),
+-                                              qutip.sigmaz()],
+-                        options=options, args=args)
+-        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
+-        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
+-        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
+-        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
+-
+-        np.testing.assert_allclose(xs, xss, atol=tol)
+-        np.testing.assert_allclose(ys, yss, atol=tol)
+-        np.testing.assert_allclose(zs, zss, atol=tol)
+-
+-        if normalize:
+-            # propagator evolution is not normalized (yet?)
+-            tol = 5e-4
+-        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
+-        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
+-        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
+-        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
+-
+-        np.testing.assert_allclose(xs, xu, atol=tol)
+-        np.testing.assert_allclose(ys, yu, atol=tol)
+-        np.testing.assert_allclose(zs, zu, atol=tol)
+-
+-    def test_sesolver_args(self):
+-        options = {"progress_bar": None}
+-        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
+-                                            args={'a': 1}),
+-                              options=options)
+-        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
+-                             e_ops=[qutip.num(2)], args={'a':0})
+-        np.testing.assert_allclose(res.expect[0], 1)
+-
+-    def test_sesolver_pickling(self):
+-        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+-        options = {"progress_bar": None}
+-        solver_obj = SESolver(self.H0 + self.H1,
+-                              options=options)
+-        solver_copy = pickle.loads(pickle.dumps(solver_obj))
+-        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
+-                                    e_ops=e_ops).expect
+-        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
+-                                       e_ops=e_ops).expect
+-        np.testing.assert_allclose(sx, csx)
+-        np.testing.assert_allclose(sy, csy)
+-        np.testing.assert_allclose(sz, csz)
+-
+-    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
+-    def test_sesolver_stepping(self, method):
+-        options = {
+-            "method": method,
+-            "atol": 1e-7,
+-            "rtol": 1e-8,
+-            "progress_bar": None
+-        }
+-        solver_obj = SESolver(
+-            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
+-            options=options
+-        )
+-        solver_obj.start(qutip.basis(2,0), 0)
+-        sr2 = -(2**.5)/2
+-        state = solver_obj.step(1)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+-                                   atol=2e-6)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
+-                                   atol=2e-6)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
+-                                   atol=2e-6)
+-
+-        state = solver_obj.step(2, args={"a":0.125})
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+-                                   atol=2e-6)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
+-                                   atol=2e-6)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
+-                                   atol=2e-6)
+-
+-        solver_obj.options = {
+-            "method": "adams",
+-            "atol": 1e-7,
+-            "rtol": 1e-8,
+-            "progress_bar": None
+-        }
+-        state = solver_obj.step(3, args={"a":0})
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+-                                   atol=2e-6)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
+-                                   atol=2e-6)
+-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
+-                                   atol=2e-6)
+-
+-
+-def test_sesolve_bad_H():
+-    with pytest.raises(TypeError):
+-        SESolver(np.eye(3))
+-    with pytest.raises(ValueError):
+-        SESolver(qutip.basis(3,1))
+-
+-
+-def test_sesolve_bad_state():
+-    solver = SESolver(qutip.qeye(4))
+-    with pytest.raises(TypeError):
+-        solver.start(qutip.basis(4,1).dag(), 0)
+-    with pytest.raises(TypeError):
+-        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
+-
+-
+-def test_sesolve_step_no_start():
+-    solver = SESolver(qutip.qeye(4))
+-    with pytest.raises(RuntimeError):
+-        solver.step(1)
+-
+-
+-@pytest.mark.parametrize("always_compute_step", [True, False])
+-def test_krylovsolve(always_compute_step):
+-    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
+-    psi0 = qutip.basis([2]*8, [1]*8)
+-    e_op = qutip.num(256)
+-    e_op.dims = H.dims
+-    tlist = np.linspace(0, 1, 11)
+-    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
+-    options = {"always_compute_step", always_compute_step}
+-    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
+-    np.testing.assert_allclose(ref, krylov_sol)
++import pytest
++import pickle
++import qutip
++import numpy as np
++from qutip.solver.sesolve import sesolve, SESolver
++from qutip.solver.krylovsolve import krylovsolve
++from qutip.solver.solver_base import Solver
++
++all_ode_method = [
++    method for method, integrator in SESolver.avail_integrators().items()
++    if integrator.support_time_dependant
++]
++
++def _analytic(t, alpha):
++    return ((1 - np.exp(-alpha * t)) / alpha)
++
++
++class TestSeSolve():
++    H0 = 0.2 * np.pi * qutip.sigmaz()
++    H1 = np.pi * qutip.sigmax()
++    tlist = np.linspace(0, 20, 200)
++    args = {'alpha': 0.5}
++    w_a = 0.35
++    a = 0.5
++
++    @pytest.mark.parametrize(['unitary_op'], [
++        pytest.param(None, id="state"),
++        pytest.param(qutip.qeye(2), id="unitary"),
++    ])
++    @pytest.mark.parametrize(['H', 'analytical'], [
++        pytest.param(H1, lambda t, _: t, id='const_H'),
++        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
++                                       * np.exp(-alpha * t)),
++                     _analytic, id='func_H'),
++        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
++                     _analytic, id='list_func_H'),
++        pytest.param([[H1, 'exp(-alpha*t)']],
++                     _analytic, id='list_str_H'),
++        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
++                     _analytic, id='list_array_H'),
++        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
++                     _analytic, id='QobjEvo_H'),
++    ])
++    def test_sesolve(self, H, analytical, unitary_op):
++        """
++        Compare integrated evolution with analytical result
++        If U0 is not None then operator evo is checked
++        Otherwise state evo
++        """
++        tol = 5e-3
++        psi0 = qutip.basis(2, 0)
++        options = {"progress_bar": None}
++
++        if unitary_op is None:
++            output = sesolve(H, psi0, self.tlist,
++                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
++                             args=self.args, options=options)
++            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
++        else:
++            output = sesolve(H, unitary_op, self.tlist, args=self.args,
++                             options=options)
++            sx = [qutip.expect(qutip.sigmax(), U * psi0)
++                  for U in output.states]
++            sy = [qutip.expect(qutip.sigmay(), U * psi0)
++                  for U in output.states]
++            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
++                  for U in output.states]
++
++        sx_analytic = np.zeros(np.shape(self.tlist))
++        sy_analytic = np.array(
++            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
++             for t in self.tlist]
++        )
++        sz_analytic = np.array(
++            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
++             for t in self.tlist]
++        )
++
++        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
++        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
++        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
++
++    @pytest.mark.parametrize(['state_type'], [
++        pytest.param("ket", id="ket"),
++        pytest.param("unitary", id="unitary"),
++    ])
++    def test_sesolve_normalization(self, state_type):
++        # non-hermitean H causes state to evolve non-unitarily
++        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
++        psi0 = qutip.basis(2, 0)
++        options = {"normalize_output": True, "progress_bar": None}
++
++        if state_type == "ket":
++            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
++            norms = [state.norm() for state in output.states]
++            np.testing.assert_allclose(
++                norms, [1.0 for _ in self.tlist], atol=1e-15,
++            )
++        else:
++            # evolution of unitaries should not be normalized
++            U = qutip.qeye(2)
++            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
++            norms = [state.norm() for state in output.states]
++            assert all(norm > 2 for norm in norms[1:])
++
++    @pytest.mark.parametrize(['unitary_op'], [
++        pytest.param(None, id="state"),
++        pytest.param(qutip.qeye(2), id="unitary"),
++    ])
++    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
++    def test_sesolve_method(self, method, unitary_op):
++        """
++        Compare integrated evolution with analytical result
++        If U0 is not None then operator evo is checked
++        Otherwise state evo
++        """
++        tol = 5e-3
++        psi0 = qutip.basis(2, 0)
++        options = {"method": method, "progress_bar": None}
++        H = [[self.H1, 'exp(-alpha*t)']]
++
++        if unitary_op is None:
++            output = sesolve(H, psi0, self.tlist,
++                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
++                             args=self.args, options=options)
++            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
++        else:
++            output = sesolve(H, unitary_op, self.tlist,
++                             args=self.args, options=options)
++            sx = [qutip.expect(qutip.sigmax(), U * psi0)
++                  for U in output.states]
++            sy = [qutip.expect(qutip.sigmay(), U * psi0)
++                  for U in output.states]
++            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
++                  for U in output.states]
++
++        sx_analytic = np.zeros(np.shape(self.tlist))
++        sy_analytic = np.array(
++            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
++             for t in self.tlist]
++        )
++        sz_analytic = np.array(
++            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
++             for t in self.tlist]
++        )
++
++        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
++        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
++        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
++
++    @pytest.mark.parametrize('normalize', [True, False],
++                             ids=['Normalized', ''])
++    @pytest.mark.parametrize(['H', 'args'],
++        [pytest.param(H0 + H1, {}, id='const_H'),
++         pytest.param(lambda t, a, w_a: (
++             a * t * 0.2 * np.pi * qutip.sigmaz() +
++             np.cos(w_a * t) * np.pi * qutip.sigmax()
++         ), {'a':a, 'w_a':w_a}, id='func_H'),
++         pytest.param([
++             [H0, lambda t, args: args['a']*t],
++             [H1, lambda t, args: np.cos(args['w_a']*t)]
++         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
++         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
++    ])
++    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
++        """
++        Compare integrated evolution of unitary operator with state evo
++        """
++        psi0 = qutip.basis(2, 0)
++        U0 = qutip.qeye(2)
++
++        options = {
++            "store_states": True,
++            "normalize_output": normalize,
++            "progress_bar": None
++        }
++        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
++                                              qutip.sigmay(),
++                                              qutip.sigmaz()],
++                        options=options, args=args)
++        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
++        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
++        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
++        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
++
++        np.testing.assert_allclose(xs, xss, atol=tol)
++        np.testing.assert_allclose(ys, yss, atol=tol)
++        np.testing.assert_allclose(zs, zss, atol=tol)
++
++        if normalize:
++            # propagator evolution is not normalized (yet?)
++            tol = 5e-4
++        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
++        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
++        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
++        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
++
++        np.testing.assert_allclose(xs, xu, atol=tol)
++        np.testing.assert_allclose(ys, yu, atol=tol)
++        np.testing.assert_allclose(zs, zu, atol=tol)
++
++    def test_sesolver_args(self):
++        options = {"progress_bar": None}
++        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
++                                            args={'a': 1}),
++                              options=options)
++        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
++                             e_ops=[qutip.num(2)], args={'a':0})
++        np.testing.assert_allclose(res.expect[0], 1)
++
++    def test_sesolver_pickling(self):
++        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
++        options = {"progress_bar": None}
++        solver_obj = SESolver(self.H0 + self.H1,
++                              options=options)
++        solver_copy = pickle.loads(pickle.dumps(solver_obj))
++        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
++                                    e_ops=e_ops).expect
++        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
++                                       e_ops=e_ops).expect
++        np.testing.assert_allclose(sx, csx)
++        np.testing.assert_allclose(sy, csy)
++        np.testing.assert_allclose(sz, csz)
++
++    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
++    def test_sesolver_stepping(self, method):
++        options = {
++            "method": method,
++            "atol": 1e-7,
++            "rtol": 1e-8,
++            "progress_bar": None
++        }
++        solver_obj = SESolver(
++            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
++            options=options
++        )
++        solver_obj.start(qutip.basis(2,0), 0)
++        sr2 = -(2**.5)/2
++        state = solver_obj.step(1)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
++                                   atol=2e-6)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
++                                   atol=2e-6)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
++                                   atol=2e-6)
++
++        state = solver_obj.step(2, args={"a":0.125})
++        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
++                                   atol=2e-6)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
++                                   atol=2e-6)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
++                                   atol=2e-6)
++
++        solver_obj.options = {
++            "method": "adams",
++            "atol": 1e-7,
++            "rtol": 1e-8,
++            "progress_bar": None
++        }
++        state = solver_obj.step(3, args={"a":0})
++        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
++                                   atol=2e-6)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
++                                   atol=2e-6)
++        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
++                                   atol=2e-6)
++
++
++def test_sesolve_bad_H():
++    with pytest.raises(TypeError):
++        SESolver(np.eye(3))
++    with pytest.raises(ValueError):
++        SESolver(qutip.basis(3,1))
++
++
++def test_sesolve_bad_state():
++    solver = SESolver(qutip.qeye(4))
++    with pytest.raises(TypeError):
++        solver.start(qutip.basis(4,1).dag(), 0)
++    with pytest.raises(TypeError):
++        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
++
++
++def test_sesolve_step_no_start():
++    solver = SESolver(qutip.qeye(4))
++    with pytest.raises(RuntimeError):
++        solver.step(1)
++
++
++@pytest.mark.parametrize("always_compute_step", [True, False])
++def test_krylovsolve(always_compute_step):
++    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
++    psi0 = qutip.basis([2]*8, [1]*8)
++    e_op = qutip.num(256)
++    e_op.dims = H.dims
++    tlist = np.linspace(0, 1, 11)
++    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
++    options = {"always_compute_step", always_compute_step}
++    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
++    np.testing.assert_allclose(ref, krylov_sol)
+diff --git a/qutip/tests/solver/test_steadystate.py b/qutip/tests/solver/test_steadystate.py
+index 6ae02a64..38c85dfa 100644
+--- a/qutip/tests/solver/test_steadystate.py
++++ b/qutip/tests/solver/test_steadystate.py
+@@ -1,241 +1,241 @@
+-import numpy as np
+-import pytest
+-import qutip
+-import warnings
+-
+-
+-@pytest.mark.parametrize(['method', 'kwargs'], [
+-    pytest.param('direct', {}, id="direct"),
+-    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
+-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+-                                          reason='MKL extensions not found.')),
+-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+-    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
+-    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
+-    pytest.param('eigen', {}, id="eigen"),
+-    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
+-    pytest.param('svd', {}, id="svd"),
+-    pytest.param('power', {'power_tol':1e-5}, id="power"),
+-    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
+-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+-                                          reason='MKL extensions not found.')),
+-    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
+-    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
+-                 id="power-gmres_perm"),
+-    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
+-    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
+-    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
+-                 id="iterative-gmres_perm"),
+-    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
+-                 id="iterative-bicgstab"),
+-])
+-def test_qubit(method, kwargs):
+-    # thermal steadystate of a qubit: compare numerics with analytical formula
+-    sz = qutip.sigmaz()
+-    sm = qutip.destroy(2)
+-
+-    H = 0.5 * 2 * np.pi * sz
+-    gamma1 = 0.05
+-
+-    wth_vec = np.linspace(0.1, 3, 20)
+-    p_ss = np.zeros(np.shape(wth_vec))
+-
+-    for idx, wth in enumerate(wth_vec):
+-        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
+-        c_op_list = []
+-        rate = gamma1 * (1 + n_th)
+-        c_op_list.append(np.sqrt(rate) * sm)
+-        rate = gamma1 * n_th
+-        c_op_list.append(np.sqrt(rate) * sm.dag())
+-        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
+-        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
+-
+-    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
+-    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
+-
+-
+-@pytest.mark.parametrize(['method', 'kwargs'], [
+-    pytest.param('direct', {}, id="direct"),
+-    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
+-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+-                                          reason='MKL extensions not found.')),
+-    pytest.param('direct', {'sparse': False}, id="direct_dense"),
+-    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
+-    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
+-    pytest.param('eigen', {}, id="eigen"),
+-    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
+-    pytest.param('svd', {}, id="svd"),
+-])
+-def test_exact_solution_for_simple_methods(method, kwargs):
+-    # this tests that simple methods correctly determine the steadystate
+-    # with high accuracy for a small Liouvillian requiring correct weighting.
+-    H = qutip.identity(2)
+-    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
+-    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
+-    expected_rho_ss = np.array([
+-        [1.e-10+0.j, 0.e+00-0.j],
+-        [0.e+00-0.j, 1.e+00+0.j],
+-    ])
+-    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
+-    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
+-
+-
+-@pytest.mark.parametrize(['method', 'kwargs'], [
+-    pytest.param('direct', {}, id="direct"),
+-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+-    pytest.param('eigen', {'sparse':False}, id="eigen"),
+-    pytest.param('power', {'power_tol':1e-5}, id="power"),
+-    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
+-    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
+-    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
+-])
+-def test_ho(method, kwargs):
+-    # thermal steadystate of an oscillator: compare numerics with analytical
+-    # formula
+-    a = qutip.destroy(30)
+-    H = 0.5 * 2 * np.pi * a.dag() * a
+-    gamma1 = 0.05
+-
+-    wth_vec = np.linspace(0.1, 3, 11)
+-    p_ss = np.zeros(np.shape(wth_vec))
+-
+-    for idx, wth in enumerate(wth_vec):
+-
+-        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
+-        c_op_list = []
+-        rate = gamma1 * (1 + n_th)
+-        c_op_list.append(np.sqrt(rate) * a)
+-        rate = gamma1 * n_th
+-        c_op_list.append(np.sqrt(rate) * a.dag())
+-        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
+-        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
+-
+-    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
+-    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
+-
+-
+-@pytest.mark.parametrize(['method', 'kwargs'], [
+-    pytest.param('direct', {}, id="direct"),
+-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+-    pytest.param('eigen', {}, id="eigen"),
+-    pytest.param('svd', {}, id="svd"),
+-    pytest.param('power', {}, id="power"),
+-    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
+-                 id="power-gmres"),
+-    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
+-                 id="power-bicgstab"),
+-    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
+-    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
+-])
+-def test_driven_cavity(method, kwargs):
+-    N = 30
+-    Omega = 0.01 * 2 * np.pi
+-    Gamma = 0.05
+-
+-    a = qutip.destroy(N)
+-    H = Omega * (a.dag() + a)
+-    c_ops = [np.sqrt(Gamma) * a]
+-    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
+-    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
+-
+-    np.testing.assert_allclose(
+-        rho_ss, rho_ss_analytic, atol=1e-4
+-    )
+-    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
+-
+-
+-@pytest.mark.parametrize(['method', 'kwargs'], [
+-    pytest.param('solve', {}, id="dense_direct"),
+-    pytest.param('numpy', {}, id="dense_numpy"),
+-    pytest.param('spilu', {},  id="spilu"),
+-])
+-def test_pseudo_inverse(method, kwargs):
+-    N = 4
+-    a = qutip.destroy(N)
+-    H = (a.dag() + a)
+-    L = qutip.liouvillian(H, [a])
+-    rho = qutip.steadystate(L)
+-    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
+-    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
+-    np.testing.assert_allclose(
+-        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
+-    )
+-    assert rho.tr() == pytest.approx(1, abs=3e-15)
+-
+-
+-@pytest.mark.parametrize('sparse', [True, False])
+-def test_steadystate_floquet(sparse):
+-    """
+-    Test the steadystate solution for a periodically
+-    driven system.
+-    """
+-    N_c = 20
+-
+-    a = qutip.destroy(N_c)
+-    a_d = a.dag()
+-    X_c = a + a_d
+-
+-    w_c = 1
+-
+-    A_l = 0.001
+-    w_l = w_c
+-    gam = 0.01
+-
+-    H = w_c * a_d * a
+-
+-    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
+-
+-    psi0 = qutip.fock(N_c, 0)
+-
+-    args = {"A_l": A_l, "w_l": w_l}
+-
+-    c_ops = []
+-    c_ops.append(np.sqrt(gam) * a)
+-
+-    t_l = np.linspace(0, 20 / gam, 2000)
+-
+-    expect_me = qutip.mesolve(H_t, psi0, t_l,
+-                        c_ops, [a_d * a], args=args).expect[0]
+-
+-    rho_ss = qutip.steadystate_floquet(H, c_ops,
+-                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
+-    expect_ss = qutip.expect(a_d * a, rho_ss)
+-
+-    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
+-    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
+-
+-
+-def test_bad_options_steadystate():
+-    N = 4
+-    a = qutip.destroy(N)
+-    H = (a.dag() + a)
+-    c_ops = [a]
+-    with pytest.raises(ValueError):
+-        qutip.steadystate(H, c_ops, method='not a method')
+-    with pytest.raises(TypeError):
+-        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
+-    with pytest.raises(ValueError):
+-        qutip.steadystate(H, c_ops, method='direct', solver='Error')
+-
+-
+-def test_bad_options_pseudo_inverse():
+-    N = 4
+-    a = qutip.destroy(N)
+-    H = (a.dag() + a)
+-    L = qutip.liouvillian(H, [a])
+-    with pytest.raises(TypeError):
+-        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
+-    with pytest.raises(ValueError):
+-        qutip.pseudo_inverse(L, method='not a method', sparse=False)
+-    with pytest.raises(ValueError):
+-        qutip.pseudo_inverse(L, method='not a method')
+-
+-
+-def test_bad_system():
+-    N = 4
+-    a = qutip.destroy(N)
+-    H = (a.dag() + a)
+-    with pytest.raises(TypeError):
+-        qutip.steadystate(H, [], method='direct')
+-    with pytest.raises(TypeError):
+-        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
++import numpy as np
++import pytest
++import qutip
++import warnings
++
++
++@pytest.mark.parametrize(['method', 'kwargs'], [
++    pytest.param('direct', {}, id="direct"),
++    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
++                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
++                                          reason='MKL extensions not found.')),
++    pytest.param('direct', {'sparse':False}, id="direct_dense"),
++    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
++    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
++    pytest.param('eigen', {}, id="eigen"),
++    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
++    pytest.param('svd', {}, id="svd"),
++    pytest.param('power', {'power_tol':1e-5}, id="power"),
++    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
++                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
++                                          reason='MKL extensions not found.')),
++    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
++    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
++                 id="power-gmres_perm"),
++    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
++    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
++    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
++                 id="iterative-gmres_perm"),
++    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
++                 id="iterative-bicgstab"),
++])
++def test_qubit(method, kwargs):
++    # thermal steadystate of a qubit: compare numerics with analytical formula
++    sz = qutip.sigmaz()
++    sm = qutip.destroy(2)
++
++    H = 0.5 * 2 * np.pi * sz
++    gamma1 = 0.05
++
++    wth_vec = np.linspace(0.1, 3, 20)
++    p_ss = np.zeros(np.shape(wth_vec))
++
++    for idx, wth in enumerate(wth_vec):
++        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
++        c_op_list = []
++        rate = gamma1 * (1 + n_th)
++        c_op_list.append(np.sqrt(rate) * sm)
++        rate = gamma1 * n_th
++        c_op_list.append(np.sqrt(rate) * sm.dag())
++        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
++        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
++
++    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
++    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
++
++
++@pytest.mark.parametrize(['method', 'kwargs'], [
++    pytest.param('direct', {}, id="direct"),
++    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
++                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
++                                          reason='MKL extensions not found.')),
++    pytest.param('direct', {'sparse': False}, id="direct_dense"),
++    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
++    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
++    pytest.param('eigen', {}, id="eigen"),
++    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
++    pytest.param('svd', {}, id="svd"),
++])
++def test_exact_solution_for_simple_methods(method, kwargs):
++    # this tests that simple methods correctly determine the steadystate
++    # with high accuracy for a small Liouvillian requiring correct weighting.
++    H = qutip.identity(2)
++    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
++    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
++    expected_rho_ss = np.array([
++        [1.e-10+0.j, 0.e+00-0.j],
++        [0.e+00-0.j, 1.e+00+0.j],
++    ])
++    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
++    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
++
++
++@pytest.mark.parametrize(['method', 'kwargs'], [
++    pytest.param('direct', {}, id="direct"),
++    pytest.param('direct', {'sparse':False}, id="direct_dense"),
++    pytest.param('eigen', {'sparse':False}, id="eigen"),
++    pytest.param('power', {'power_tol':1e-5}, id="power"),
++    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
++    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
++    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
++])
++def test_ho(method, kwargs):
++    # thermal steadystate of an oscillator: compare numerics with analytical
++    # formula
++    a = qutip.destroy(30)
++    H = 0.5 * 2 * np.pi * a.dag() * a
++    gamma1 = 0.05
++
++    wth_vec = np.linspace(0.1, 3, 11)
++    p_ss = np.zeros(np.shape(wth_vec))
++
++    for idx, wth in enumerate(wth_vec):
++
++        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
++        c_op_list = []
++        rate = gamma1 * (1 + n_th)
++        c_op_list.append(np.sqrt(rate) * a)
++        rate = gamma1 * n_th
++        c_op_list.append(np.sqrt(rate) * a.dag())
++        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
++        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
++
++    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
++    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
++
++
++@pytest.mark.parametrize(['method', 'kwargs'], [
++    pytest.param('direct', {}, id="direct"),
++    pytest.param('direct', {'sparse':False}, id="direct_dense"),
++    pytest.param('eigen', {}, id="eigen"),
++    pytest.param('svd', {}, id="svd"),
++    pytest.param('power', {}, id="power"),
++    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
++                 id="power-gmres"),
++    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
++                 id="power-bicgstab"),
++    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
++    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
++])
++def test_driven_cavity(method, kwargs):
++    N = 30
++    Omega = 0.01 * 2 * np.pi
++    Gamma = 0.05
++
++    a = qutip.destroy(N)
++    H = Omega * (a.dag() + a)
++    c_ops = [np.sqrt(Gamma) * a]
++    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
++    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
++
++    np.testing.assert_allclose(
++        rho_ss, rho_ss_analytic, atol=1e-4
++    )
++    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
++
++
++@pytest.mark.parametrize(['method', 'kwargs'], [
++    pytest.param('solve', {}, id="dense_direct"),
++    pytest.param('numpy', {}, id="dense_numpy"),
++    pytest.param('spilu', {},  id="spilu"),
++])
++def test_pseudo_inverse(method, kwargs):
++    N = 4
++    a = qutip.destroy(N)
++    H = (a.dag() + a)
++    L = qutip.liouvillian(H, [a])
++    rho = qutip.steadystate(L)
++    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
++    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
++    np.testing.assert_allclose(
++        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
++    )
++    assert rho.tr() == pytest.approx(1, abs=3e-15)
++
++
++@pytest.mark.parametrize('sparse', [True, False])
++def test_steadystate_floquet(sparse):
++    """
++    Test the steadystate solution for a periodically
++    driven system.
++    """
++    N_c = 20
++
++    a = qutip.destroy(N_c)
++    a_d = a.dag()
++    X_c = a + a_d
++
++    w_c = 1
++
++    A_l = 0.001
++    w_l = w_c
++    gam = 0.01
++
++    H = w_c * a_d * a
++
++    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
++
++    psi0 = qutip.fock(N_c, 0)
++
++    args = {"A_l": A_l, "w_l": w_l}
++
++    c_ops = []
++    c_ops.append(np.sqrt(gam) * a)
++
++    t_l = np.linspace(0, 20 / gam, 2000)
++
++    expect_me = qutip.mesolve(H_t, psi0, t_l,
++                        c_ops, [a_d * a], args=args).expect[0]
++
++    rho_ss = qutip.steadystate_floquet(H, c_ops,
++                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
++    expect_ss = qutip.expect(a_d * a, rho_ss)
++
++    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
++    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
++
++
++def test_bad_options_steadystate():
++    N = 4
++    a = qutip.destroy(N)
++    H = (a.dag() + a)
++    c_ops = [a]
++    with pytest.raises(ValueError):
++        qutip.steadystate(H, c_ops, method='not a method')
++    with pytest.raises(TypeError):
++        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
++    with pytest.raises(ValueError):
++        qutip.steadystate(H, c_ops, method='direct', solver='Error')
++
++
++def test_bad_options_pseudo_inverse():
++    N = 4
++    a = qutip.destroy(N)
++    H = (a.dag() + a)
++    L = qutip.liouvillian(H, [a])
++    with pytest.raises(TypeError):
++        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
++    with pytest.raises(ValueError):
++        qutip.pseudo_inverse(L, method='not a method', sparse=False)
++    with pytest.raises(ValueError):
++        qutip.pseudo_inverse(L, method='not a method')
++
++
++def test_bad_system():
++    N = 4
++    a = qutip.destroy(N)
++    H = (a.dag() + a)
++    with pytest.raises(TypeError):
++        qutip.steadystate(H, [], method='direct')
++    with pytest.raises(TypeError):
++        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
+diff --git a/qutip/tests/test_basis_transformation.py b/qutip/tests/test_basis_transformation.py
+index 1e406e9f..080296a3 100644
+--- a/qutip/tests/test_basis_transformation.py
++++ b/qutip/tests/test_basis_transformation.py
+@@ -1,55 +1,55 @@
+-import numpy as np
+-import pytest
+-import qutip
+-
+-
+-def real_hermitian(n_levels):
+-    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
+-    return qobj + qobj.dag()
+-
+-
+-def imaginary_hermitian(n_levels):
+-    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
+-    return qobj + qobj.dag()
+-
+-
+-def complex_hermitian(n_levels):
+-    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
+-
+-
+-def rand_bra(n_levels):
+-    return qutip.rand_ket(n_levels).dag()
+-
+-
+-@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
+-                                                   imaginary_hermitian,
+-                                                   complex_hermitian])
+-@pytest.mark.parametrize("n_levels", [2, 10])
+-def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
+-                                                    n_levels):
+-    """Transform n-level real-values to eigenbasis and back"""
+-    H1 = hermitian_constructor(n_levels)
+-    _, ekets = H1.eigenstates()
+-    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
+-    H2 = Heb.transform(ekets, True)  # Back to original basis
+-    assert (H1 - H2).norm() < 1e-6
+-
+-
+-@pytest.mark.parametrize("n_levels", [4])
+-def test_ket_and_dm_transformations_equivalent(n_levels):
+-    """Consistency between transformations of kets and density matrices."""
+-    psi0 = qutip.rand_ket(n_levels)
+-    # Generate a random basis
+-    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
+-    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
+-    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
+-    assert (rho1 - rho2).norm() < 1e-6
+-
+-
+-def test_eigenbasis_transformation_makes_diagonal_operator():
+-    """Check diagonalization via eigenbasis transformation."""
+-    cx, cy, cz = np.random.random_sample((3,))
+-    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
+-    _, ekets = H.eigenstates()
+-    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
+-    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
++import numpy as np
++import pytest
++import qutip
++
++
++def real_hermitian(n_levels):
++    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
++    return qobj + qobj.dag()
++
++
++def imaginary_hermitian(n_levels):
++    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
++    return qobj + qobj.dag()
++
++
++def complex_hermitian(n_levels):
++    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
++
++
++def rand_bra(n_levels):
++    return qutip.rand_ket(n_levels).dag()
++
++
++@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
++                                                   imaginary_hermitian,
++                                                   complex_hermitian])
++@pytest.mark.parametrize("n_levels", [2, 10])
++def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
++                                                    n_levels):
++    """Transform n-level real-values to eigenbasis and back"""
++    H1 = hermitian_constructor(n_levels)
++    _, ekets = H1.eigenstates()
++    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
++    H2 = Heb.transform(ekets, True)  # Back to original basis
++    assert (H1 - H2).norm() < 1e-6
++
++
++@pytest.mark.parametrize("n_levels", [4])
++def test_ket_and_dm_transformations_equivalent(n_levels):
++    """Consistency between transformations of kets and density matrices."""
++    psi0 = qutip.rand_ket(n_levels)
++    # Generate a random basis
++    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
++    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
++    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
++    assert (rho1 - rho2).norm() < 1e-6
++
++
++def test_eigenbasis_transformation_makes_diagonal_operator():
++    """Check diagonalization via eigenbasis transformation."""
++    cx, cy, cz = np.random.random_sample((3,))
++    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
++    _, ekets = H.eigenstates()
++    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
++    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
+diff --git a/qutip/tests/test_bloch.py b/qutip/tests/test_bloch.py
+index 33e8fb2f..e87517d3 100644
+--- a/qutip/tests/test_bloch.py
++++ b/qutip/tests/test_bloch.py
+@@ -1,479 +1,479 @@
+-import copy
+-
+-import numpy as np
+-import pytest
+-
+-from qutip.bloch import Bloch
+-from qutip import ket, ket2dm
+-
+-try:
+-    import matplotlib.pyplot as plt
+-    from matplotlib.testing.decorators import check_figures_equal
+-    import IPython
+-    check_pngs_equal = check_figures_equal(extensions=["png"])
+-except ImportError:
+-    plt = None
+-    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
+-
+-
+-class RefBloch(Bloch):
+-    """ A helper for rendering reference Bloch spheres. """
+-    def render(self):
+-        raise NotImplementedError("RefBloch disables .render()")
+-
+-    def render_back(self):
+-        old_plot_front = self.plot_front
+-        self.plot_front = lambda: None
+-        try:
+-            Bloch.render(self)
+-        finally:
+-            self.plot_front = old_plot_front
+-
+-    def render_front(self):
+-        self.plot_front()
+-
+-
+-class TestBloch:
+-    def plot_arc_test(self, fig, *args, **kw):
+-        b = Bloch(fig=fig)
+-        b.add_arc(*args, **kw)
+-        b.render()
+-
+-    def plot_arc_ref(self, fig, start, end, **kw):
+-        fmt = kw.pop("fmt", "b")
+-        steps = kw.pop("steps", None)
+-        start = np.array(start)
+-        end = np.array(end)
+-        if steps is None:
+-            steps = int(np.linalg.norm(start - end) * 100)
+-            steps = max(2, steps)
+-
+-        t = np.linspace(0, 1, steps)
+-        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
+-        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
+-
+-        b = RefBloch(fig=fig)
+-        b.render_back()
+-        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
+-        b.render_front()
+-
+-    @pytest.mark.parametrize([
+-        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
+-    ], [
+-        pytest.param(
+-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
+-        pytest.param(
+-            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
+-            id="small-radius"),
+-        pytest.param(
+-            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
+-            id="tiny-radius"),
+-        pytest.param(
+-            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
+-            id="large-radius"),
+-        pytest.param(
+-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
+-            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
+-        ),
+-        pytest.param(
+-            ket("0"), (0, 0, 1),
+-            (ket("0") + ket("1")).unit(), (1, 0, 0),
+-            {}, id="kets",
+-        ),
+-        pytest.param(
+-            ket2dm(ket("0")), (0, 0, 1),
+-            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
+-            {}, id="dms",
+-        ),
+-        pytest.param(
+-            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
+-            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
+-            {}, id="non-unit-dms",
+-        ),
+-    ])
+-    @check_pngs_equal
+-    def test_arc(
+-        self, start_test, start_ref, end_test, end_ref, kwargs,
+-        fig_test, fig_ref,
+-    ):
+-        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
+-        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
+-
+-    @pytest.mark.parametrize([
+-        "start", "end", "err_msg",
+-    ], [
+-        pytest.param(
+-            (0, 0, 0), (0, 1, 0),
+-            "Polar and azimuthal angles undefined at origin.",
+-            id="start-origin",
+-        ),
+-        pytest.param(
+-            (1, 0, 0), (0, 0, 0),
+-            "Polar and azimuthal angles undefined at origin.",
+-            id="end-origin",
+-        ),
+-        pytest.param(
+-            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
+-            id="different-spheres",
+-        ),
+-        pytest.param(
+-            (1, 0, 0), (1, 0, 0),
+-            "Start and end represent the same point. No arc can be formed.",
+-            id="same-points",
+-        ),
+-        pytest.param(
+-            (1, 0, 0), (-1, 0, 0),
+-            "Start and end are diagonally opposite, no unique arc is"
+-            " possible.",
+-            id="opposite-points",
+-        ),
+-    ])
+-    def test_arc_errors(self, start, end, err_msg):
+-        b = Bloch()
+-        with pytest.raises(ValueError) as err:
+-            b.add_arc(start, end)
+-        assert str(err.value) == err_msg
+-
+-    def plot_line_test(self, fig, *args, **kw):
+-        b = Bloch(fig=fig)
+-        b.add_line(*args, **kw)
+-        b.render()
+-
+-    def plot_line_ref(self, fig, start, end, **kw):
+-        fmt = kw.pop("fmt", "k")
+-
+-        x = [start[1], end[1]]
+-        y = [-start[0], -end[0]]
+-        z = [start[2], end[2]]
+-
+-        b = RefBloch(fig=fig)
+-        b.render_back()
+-        b.axes.plot(x, y, z, fmt, **kw)
+-        b.render_front()
+-
+-    @pytest.mark.parametrize([
+-        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
+-    ], [
+-        pytest.param(
+-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
+-        pytest.param(
+-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
+-            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
+-        ),
+-        pytest.param(
+-            ket("0"), (0, 0, 1),
+-            (ket("0") + ket("1")).unit(), (1, 0, 0),
+-            {}, id="kets",
+-        ),
+-        pytest.param(
+-            ket2dm(ket("0")), (0, 0, 1),
+-            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
+-            {}, id="dms",
+-        ),
+-        pytest.param(
+-            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
+-            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
+-            {}, id="non-unit-dms",
+-        ),
+-    ])
+-    @check_pngs_equal
+-    def test_line(
+-        self, start_test, start_ref, end_test, end_ref, kwargs,
+-        fig_test, fig_ref,
+-    ):
+-        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
+-        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
+-
+-    def plot_point_test(self, fig, point_kws):
+-        b = Bloch(fig=fig)
+-        for kw in point_kws:
+-            points = kw.pop("points")
+-            b.add_points(points, **kw)
+-        b.render()
+-
+-    def plot_point_ref(self, fig, point_kws):
+-        b = RefBloch(fig=fig)
+-        b.render_back()
+-        point_colors = ['b', 'r', 'g', '#CC6600']
+-        point_sizes = [25, 32, 35, 45]
+-        point_markers = ["o", "s", "d", "^"]
+-
+-        for idx, kw in enumerate(point_kws):
+-            points = kw.pop("points")
+-            if not isinstance(points[0], (list, tuple, np.ndarray)):
+-                points = [[points[0]], [points[1]], [points[2]]]
+-            points = np.array(points)
+-
+-            point_style = kw.pop("meth", "s")
+-            colors = kw.pop("colors", None)
+-            if colors is None and point_style in ['s', 'l']:
+-                colors = point_colors[idx % len(point_colors)]
+-            elif colors is None and point_style == 'm':
+-                colors = np.tile(point_colors,
+-                                 np.ceil(points.shape[1]/len(point_colors)
+-                                         ).astype(int))
+-                colors = colors[:points.shape[1]]
+-            point_size = point_sizes[idx % len(point_sizes)]
+-            point_marker = point_markers[idx % len(point_markers)]
+-            point_alpha = kw.get("alpha", 1.0)
+-
+-            if len(points[0]) == 1 and point_style == "s":
+-                points = np.append(points, points, axis=1)
+-
+-            if point_style == 's':
+-                b.axes.scatter(
+-                    np.real(points[1]),
+-                    -np.real(points[0]),
+-                    np.real(points[2]),
+-                    s=point_size,
+-                    alpha=point_alpha,
+-                    edgecolor=None,
+-                    zdir='z',
+-                    color=colors,
+-                    marker=point_marker)
+-            elif point_style == 'l':
+-                b.axes.plot(
+-                    np.real(points[1]),
+-                    -np.real(points[0]),
+-                    np.real(points[2]),
+-                    alpha=point_alpha,
+-                    zdir='z',
+-                    color=colors,
+-                )
+-            elif point_style == 'm':
+-                b.axes.scatter(
+-                    np.real(points[1]),
+-                    -np.real(points[0]),
+-                    np.real(points[2]),
+-                    s=point_size,
+-                    marker=point_marker,
+-                    color=colors,
+-                    alpha=point_alpha,
+-                    edgecolor=None,
+-                    zdir='z',
+-                )
+-            else:
+-                raise ValueError(
+-                    "Tests currently only support point method 's'"
+-                )
+-        b.render_front()
+-
+-    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
+-                                                               "scatter",
+-                                                               "line",
+-                                                               "multicolored"])
+-    @pytest.mark.parametrize([
+-        "point_kws"
+-    ], [
+-        pytest.param(
+-            dict(points=np.array([
+-                [
+-                    np.cos(np.pi / 4) * np.cos(t),
+-                    np.sin(np.pi / 4) * np.cos(t),
+-                    np.sin(t),
+-                ]
+-                for t in np.linspace(0, 2 * np.pi, 20)
+-            ]).T, alpha=0.5), id="circle-of-points"),
+-        pytest.param(
+-            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
+-        pytest.param(
+-            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
+-        pytest.param(
+-            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
+-        pytest.param(
+-            dict(points=(0, 0, 1)), id="alpha-default"),
+-        pytest.param(
+-            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
+-            id="color-green"),
+-        pytest.param([
+-            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
+-            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
+-        ], id="alpha-multiple-point-sets"),
+-        pytest.param([
+-            dict(points=[(0), (0), (1)], alpha=1.0),
+-            dict(points=[(0), (1), (0)], alpha=1.0),
+-            dict(points=[(1), (0), (0)], alpha=1.0),
+-            dict(points=[(1), (1), (1)], alpha=1.0),
+-        ], id="alpha-multiple-point-sets-all_sizes_markers"),
+-    ])
+-    @check_pngs_equal
+-    def test_point(self, point_kws, meth, fig_test, fig_ref):
+-        if meth and isinstance(point_kws, dict):
+-            point_kws["meth"] = meth
+-
+-        elif meth and isinstance(point_kws, list):
+-            for point_kw in point_kws:
+-                point_kw["meth"] = meth
+-
+-        if isinstance(point_kws, dict):
+-            point_kws = [point_kws]
+-
+-        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
+-        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
+-
+-    def test_point_errors_meth(self):
+-        with pytest.raises(ValueError) as err:
+-            b = Bloch()
+-            b.add_points((0, 0, 1), meth='k')
+-            b.render()
+-
+-        err_msg = ("The value for meth = k is not valid."
+-                   " Please use 's', 'l' or 'm'.")
+-        assert str(err.value) == err_msg
+-
+-    @pytest.mark.parametrize("points",
+-                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
+-                              np.arange(12).reshape((3, 2, 2))],
+-                             ids=["long_tuple", "short_tuple", "short_list",
+-                                  "short_numpy", "wrong_shape_numpy"]
+-                             )
+-    def test_point_errors_wrong_points(self, points):
+-        with pytest.raises(ValueError) as err:
+-            b = Bloch()
+-            b.add_points(points)
+-            b.render()
+-
+-        err_msg = ("The included points are not valid. Points must "
+-                   "be equivalent to a 2D array where the first "
+-                   "index represents the x,y,z values and the "
+-                   "second index iterates over the points.")
+-        assert str(err.value) == err_msg
+-
+-    def plot_vector_test(self, fig, vector_kws):
+-        b = Bloch(fig=fig)
+-        for kw in vector_kws:
+-            vectors = kw.pop("vectors")
+-            b.add_vectors(vectors, **kw)
+-        b.render()
+-
+-    def plot_vector_ref(self, fig, vector_kws):
+-        from qutip.bloch import Arrow3D
+-        b = RefBloch(fig=fig)
+-        b.render_back()
+-        vector_colors = ['g', '#CC6600', 'b', 'r']
+-        idx = 0
+-
+-        for kw in vector_kws:
+-            vectors = kw.pop("vectors")
+-
+-            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
+-                vectors = [vectors]
+-
+-            colors = kw.pop("colors", None)
+-            for k, v in enumerate(vectors):
+-                if colors is None:
+-                    color = vector_colors[idx % len(vector_colors)]
+-                else:
+-                    color = colors[k]
+-
+-                alpha = kw.get("alpha", 1.0)
+-                idx += 1
+-
+-                xs3d = v[1] * np.array([0, 1])
+-                ys3d = -v[0] * np.array([0, 1])
+-                zs3d = v[2] * np.array([0, 1])
+-                a = Arrow3D(
+-                    xs3d, ys3d, zs3d,
+-                    mutation_scale=20, lw=3, arrowstyle="-|>",
+-                    color=color, alpha=alpha)
+-                b.axes.add_artist(a)
+-        b.render_front()
+-
+-    @pytest.mark.parametrize([
+-        "vector_kws"
+-    ], [
+-        pytest.param(
+-            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
+-        pytest.param(
+-            dict(vectors=[0, 0, 1]), id="single-vector-list"),
+-        pytest.param(
+-            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
+-        pytest.param(
+-            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
+-        pytest.param(
+-            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
+-        pytest.param(
+-            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
+-        pytest.param(
+-            dict(vectors=[
+-                [
+-                    np.cos(np.pi / 4) * np.cos(t),
+-                    np.sin(np.pi / 4) * np.cos(t),
+-                    np.sin(t),
+-                ]
+-                for t in np.linspace(0, 2 * np.pi, 20)
+-            ], alpha=0.5), id="circle-of-vectors"),
+-        pytest.param(
+-            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
+-        pytest.param(
+-            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
+-        pytest.param(
+-            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
+-        pytest.param(
+-            dict(vectors=(0, 0, 1)), id="alpha-default"),
+-        pytest.param([
+-            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
+-            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
+-        ], id="alpha-multiple-vector-sets"),
+-        pytest.param(
+-            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
+-        pytest.param(
+-            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
+-            id="color-two-y"),
+-        pytest.param([
+-            dict(vectors=[(0, 0, 1)], colors=['y']),
+-            dict(vectors=[(1, 0, 1)], colors=['g']),
+-        ], id="color-yg"),
+-    ])
+-    @check_pngs_equal
+-    def test_vector(self, vector_kws, fig_test, fig_ref):
+-        if isinstance(vector_kws, dict):
+-            vector_kws = [vector_kws]
+-        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
+-        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
+-
+-    @pytest.mark.parametrize("vectors",
+-                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
+-                              np.arange(12).reshape((3, 2, 2))],
+-                             ids=["long_tuple", "short_tuple", "short_list",
+-                                  "short_numpy", "wrong_shape_numpy"]
+-                             )
+-    def test_vector_errors_wrong_vectors(self, vectors):
+-        with pytest.raises(ValueError) as err:
+-            b = Bloch()
+-            b.add_vectors(vectors)
+-            b.render()
+-
+-        err_msg = ("The included vectors are not valid. Vectors must "
+-                   "be equivalent to a 2D array where the first "
+-                   "index represents the iteration over the vectors and the "
+-                   "second index represents the position in 3D of vector "
+-                   "head.")
+-        assert str(err.value) == err_msg
+-
+-    @pytest.mark.parametrize("vectors, colors",
+-                             [([0, 0, 1], ['g', 'y']),
+-                              ([[0, 0, 1], [0, 1, 0]], ['y']),
+-                              ([0, 0, 1], [['g', 'y']])],
+-                             ids=["one-vec-two-colors", "two-vec-one-color",
+-                                  "wrong-dimension-list"]
+-                             )
+-    def test_vector_errors_color_length(self, vectors, colors):
+-        with pytest.raises(ValueError) as err:
+-            b = Bloch()
+-            b.add_vectors(vectors, colors=colors)
+-            b.render()
+-
+-        err_msg = ("The included colors are not valid. colors must "
+-                   "be equivalent to a 1D array with the same "
+-                   "size as the number of vectors. ")
+-        assert str(err.value) == err_msg
+-
+-
+-def test_repr_svg():
+-    pytest.importorskip("matplotlib")
+-    pytest.importorskip("ipython")
+-    svg = Bloch()._repr_svg_()
+-    assert isinstance(svg, str)
+-    assert svg.startswith("<?xml")
+-    assert svg.endswith("</svg>\n")
++import copy
++
++import numpy as np
++import pytest
++
++from qutip.bloch import Bloch
++from qutip import ket, ket2dm
++
++try:
++    import matplotlib.pyplot as plt
++    from matplotlib.testing.decorators import check_figures_equal
++    import IPython
++    check_pngs_equal = check_figures_equal(extensions=["png"])
++except ImportError:
++    plt = None
++    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
++
++
++class RefBloch(Bloch):
++    """ A helper for rendering reference Bloch spheres. """
++    def render(self):
++        raise NotImplementedError("RefBloch disables .render()")
++
++    def render_back(self):
++        old_plot_front = self.plot_front
++        self.plot_front = lambda: None
++        try:
++            Bloch.render(self)
++        finally:
++            self.plot_front = old_plot_front
++
++    def render_front(self):
++        self.plot_front()
++
++
++class TestBloch:
++    def plot_arc_test(self, fig, *args, **kw):
++        b = Bloch(fig=fig)
++        b.add_arc(*args, **kw)
++        b.render()
++
++    def plot_arc_ref(self, fig, start, end, **kw):
++        fmt = kw.pop("fmt", "b")
++        steps = kw.pop("steps", None)
++        start = np.array(start)
++        end = np.array(end)
++        if steps is None:
++            steps = int(np.linalg.norm(start - end) * 100)
++            steps = max(2, steps)
++
++        t = np.linspace(0, 1, steps)
++        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
++        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
++
++        b = RefBloch(fig=fig)
++        b.render_back()
++        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
++        b.render_front()
++
++    @pytest.mark.parametrize([
++        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
++    ], [
++        pytest.param(
++            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
++        pytest.param(
++            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
++            id="small-radius"),
++        pytest.param(
++            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
++            id="tiny-radius"),
++        pytest.param(
++            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
++            id="large-radius"),
++        pytest.param(
++            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
++            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
++        ),
++        pytest.param(
++            ket("0"), (0, 0, 1),
++            (ket("0") + ket("1")).unit(), (1, 0, 0),
++            {}, id="kets",
++        ),
++        pytest.param(
++            ket2dm(ket("0")), (0, 0, 1),
++            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
++            {}, id="dms",
++        ),
++        pytest.param(
++            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
++            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
++            {}, id="non-unit-dms",
++        ),
++    ])
++    @check_pngs_equal
++    def test_arc(
++        self, start_test, start_ref, end_test, end_ref, kwargs,
++        fig_test, fig_ref,
++    ):
++        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
++        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
++
++    @pytest.mark.parametrize([
++        "start", "end", "err_msg",
++    ], [
++        pytest.param(
++            (0, 0, 0), (0, 1, 0),
++            "Polar and azimuthal angles undefined at origin.",
++            id="start-origin",
++        ),
++        pytest.param(
++            (1, 0, 0), (0, 0, 0),
++            "Polar and azimuthal angles undefined at origin.",
++            id="end-origin",
++        ),
++        pytest.param(
++            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
++            id="different-spheres",
++        ),
++        pytest.param(
++            (1, 0, 0), (1, 0, 0),
++            "Start and end represent the same point. No arc can be formed.",
++            id="same-points",
++        ),
++        pytest.param(
++            (1, 0, 0), (-1, 0, 0),
++            "Start and end are diagonally opposite, no unique arc is"
++            " possible.",
++            id="opposite-points",
++        ),
++    ])
++    def test_arc_errors(self, start, end, err_msg):
++        b = Bloch()
++        with pytest.raises(ValueError) as err:
++            b.add_arc(start, end)
++        assert str(err.value) == err_msg
++
++    def plot_line_test(self, fig, *args, **kw):
++        b = Bloch(fig=fig)
++        b.add_line(*args, **kw)
++        b.render()
++
++    def plot_line_ref(self, fig, start, end, **kw):
++        fmt = kw.pop("fmt", "k")
++
++        x = [start[1], end[1]]
++        y = [-start[0], -end[0]]
++        z = [start[2], end[2]]
++
++        b = RefBloch(fig=fig)
++        b.render_back()
++        b.axes.plot(x, y, z, fmt, **kw)
++        b.render_front()
++
++    @pytest.mark.parametrize([
++        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
++    ], [
++        pytest.param(
++            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
++        pytest.param(
++            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
++            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
++        ),
++        pytest.param(
++            ket("0"), (0, 0, 1),
++            (ket("0") + ket("1")).unit(), (1, 0, 0),
++            {}, id="kets",
++        ),
++        pytest.param(
++            ket2dm(ket("0")), (0, 0, 1),
++            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
++            {}, id="dms",
++        ),
++        pytest.param(
++            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
++            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
++            {}, id="non-unit-dms",
++        ),
++    ])
++    @check_pngs_equal
++    def test_line(
++        self, start_test, start_ref, end_test, end_ref, kwargs,
++        fig_test, fig_ref,
++    ):
++        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
++        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
++
++    def plot_point_test(self, fig, point_kws):
++        b = Bloch(fig=fig)
++        for kw in point_kws:
++            points = kw.pop("points")
++            b.add_points(points, **kw)
++        b.render()
++
++    def plot_point_ref(self, fig, point_kws):
++        b = RefBloch(fig=fig)
++        b.render_back()
++        point_colors = ['b', 'r', 'g', '#CC6600']
++        point_sizes = [25, 32, 35, 45]
++        point_markers = ["o", "s", "d", "^"]
++
++        for idx, kw in enumerate(point_kws):
++            points = kw.pop("points")
++            if not isinstance(points[0], (list, tuple, np.ndarray)):
++                points = [[points[0]], [points[1]], [points[2]]]
++            points = np.array(points)
++
++            point_style = kw.pop("meth", "s")
++            colors = kw.pop("colors", None)
++            if colors is None and point_style in ['s', 'l']:
++                colors = point_colors[idx % len(point_colors)]
++            elif colors is None and point_style == 'm':
++                colors = np.tile(point_colors,
++                                 np.ceil(points.shape[1]/len(point_colors)
++                                         ).astype(int))
++                colors = colors[:points.shape[1]]
++            point_size = point_sizes[idx % len(point_sizes)]
++            point_marker = point_markers[idx % len(point_markers)]
++            point_alpha = kw.get("alpha", 1.0)
++
++            if len(points[0]) == 1 and point_style == "s":
++                points = np.append(points, points, axis=1)
++
++            if point_style == 's':
++                b.axes.scatter(
++                    np.real(points[1]),
++                    -np.real(points[0]),
++                    np.real(points[2]),
++                    s=point_size,
++                    alpha=point_alpha,
++                    edgecolor=None,
++                    zdir='z',
++                    color=colors,
++                    marker=point_marker)
++            elif point_style == 'l':
++                b.axes.plot(
++                    np.real(points[1]),
++                    -np.real(points[0]),
++                    np.real(points[2]),
++                    alpha=point_alpha,
++                    zdir='z',
++                    color=colors,
++                )
++            elif point_style == 'm':
++                b.axes.scatter(
++                    np.real(points[1]),
++                    -np.real(points[0]),
++                    np.real(points[2]),
++                    s=point_size,
++                    marker=point_marker,
++                    color=colors,
++                    alpha=point_alpha,
++                    edgecolor=None,
++                    zdir='z',
++                )
++            else:
++                raise ValueError(
++                    "Tests currently only support point method 's'"
++                )
++        b.render_front()
++
++    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
++                                                               "scatter",
++                                                               "line",
++                                                               "multicolored"])
++    @pytest.mark.parametrize([
++        "point_kws"
++    ], [
++        pytest.param(
++            dict(points=np.array([
++                [
++                    np.cos(np.pi / 4) * np.cos(t),
++                    np.sin(np.pi / 4) * np.cos(t),
++                    np.sin(t),
++                ]
++                for t in np.linspace(0, 2 * np.pi, 20)
++            ]).T, alpha=0.5), id="circle-of-points"),
++        pytest.param(
++            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
++        pytest.param(
++            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
++        pytest.param(
++            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
++        pytest.param(
++            dict(points=(0, 0, 1)), id="alpha-default"),
++        pytest.param(
++            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
++            id="color-green"),
++        pytest.param([
++            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
++            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
++        ], id="alpha-multiple-point-sets"),
++        pytest.param([
++            dict(points=[(0), (0), (1)], alpha=1.0),
++            dict(points=[(0), (1), (0)], alpha=1.0),
++            dict(points=[(1), (0), (0)], alpha=1.0),
++            dict(points=[(1), (1), (1)], alpha=1.0),
++        ], id="alpha-multiple-point-sets-all_sizes_markers"),
++    ])
++    @check_pngs_equal
++    def test_point(self, point_kws, meth, fig_test, fig_ref):
++        if meth and isinstance(point_kws, dict):
++            point_kws["meth"] = meth
++
++        elif meth and isinstance(point_kws, list):
++            for point_kw in point_kws:
++                point_kw["meth"] = meth
++
++        if isinstance(point_kws, dict):
++            point_kws = [point_kws]
++
++        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
++        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
++
++    def test_point_errors_meth(self):
++        with pytest.raises(ValueError) as err:
++            b = Bloch()
++            b.add_points((0, 0, 1), meth='k')
++            b.render()
++
++        err_msg = ("The value for meth = k is not valid."
++                   " Please use 's', 'l' or 'm'.")
++        assert str(err.value) == err_msg
++
++    @pytest.mark.parametrize("points",
++                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
++                              np.arange(12).reshape((3, 2, 2))],
++                             ids=["long_tuple", "short_tuple", "short_list",
++                                  "short_numpy", "wrong_shape_numpy"]
++                             )
++    def test_point_errors_wrong_points(self, points):
++        with pytest.raises(ValueError) as err:
++            b = Bloch()
++            b.add_points(points)
++            b.render()
++
++        err_msg = ("The included points are not valid. Points must "
++                   "be equivalent to a 2D array where the first "
++                   "index represents the x,y,z values and the "
++                   "second index iterates over the points.")
++        assert str(err.value) == err_msg
++
++    def plot_vector_test(self, fig, vector_kws):
++        b = Bloch(fig=fig)
++        for kw in vector_kws:
++            vectors = kw.pop("vectors")
++            b.add_vectors(vectors, **kw)
++        b.render()
++
++    def plot_vector_ref(self, fig, vector_kws):
++        from qutip.bloch import Arrow3D
++        b = RefBloch(fig=fig)
++        b.render_back()
++        vector_colors = ['g', '#CC6600', 'b', 'r']
++        idx = 0
++
++        for kw in vector_kws:
++            vectors = kw.pop("vectors")
++
++            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
++                vectors = [vectors]
++
++            colors = kw.pop("colors", None)
++            for k, v in enumerate(vectors):
++                if colors is None:
++                    color = vector_colors[idx % len(vector_colors)]
++                else:
++                    color = colors[k]
++
++                alpha = kw.get("alpha", 1.0)
++                idx += 1
++
++                xs3d = v[1] * np.array([0, 1])
++                ys3d = -v[0] * np.array([0, 1])
++                zs3d = v[2] * np.array([0, 1])
++                a = Arrow3D(
++                    xs3d, ys3d, zs3d,
++                    mutation_scale=20, lw=3, arrowstyle="-|>",
++                    color=color, alpha=alpha)
++                b.axes.add_artist(a)
++        b.render_front()
++
++    @pytest.mark.parametrize([
++        "vector_kws"
++    ], [
++        pytest.param(
++            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
++        pytest.param(
++            dict(vectors=[0, 0, 1]), id="single-vector-list"),
++        pytest.param(
++            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
++        pytest.param(
++            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
++        pytest.param(
++            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
++        pytest.param(
++            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
++        pytest.param(
++            dict(vectors=[
++                [
++                    np.cos(np.pi / 4) * np.cos(t),
++                    np.sin(np.pi / 4) * np.cos(t),
++                    np.sin(t),
++                ]
++                for t in np.linspace(0, 2 * np.pi, 20)
++            ], alpha=0.5), id="circle-of-vectors"),
++        pytest.param(
++            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
++        pytest.param(
++            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
++        pytest.param(
++            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
++        pytest.param(
++            dict(vectors=(0, 0, 1)), id="alpha-default"),
++        pytest.param([
++            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
++            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
++        ], id="alpha-multiple-vector-sets"),
++        pytest.param(
++            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
++        pytest.param(
++            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
++            id="color-two-y"),
++        pytest.param([
++            dict(vectors=[(0, 0, 1)], colors=['y']),
++            dict(vectors=[(1, 0, 1)], colors=['g']),
++        ], id="color-yg"),
++    ])
++    @check_pngs_equal
++    def test_vector(self, vector_kws, fig_test, fig_ref):
++        if isinstance(vector_kws, dict):
++            vector_kws = [vector_kws]
++        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
++        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
++
++    @pytest.mark.parametrize("vectors",
++                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
++                              np.arange(12).reshape((3, 2, 2))],
++                             ids=["long_tuple", "short_tuple", "short_list",
++                                  "short_numpy", "wrong_shape_numpy"]
++                             )
++    def test_vector_errors_wrong_vectors(self, vectors):
++        with pytest.raises(ValueError) as err:
++            b = Bloch()
++            b.add_vectors(vectors)
++            b.render()
++
++        err_msg = ("The included vectors are not valid. Vectors must "
++                   "be equivalent to a 2D array where the first "
++                   "index represents the iteration over the vectors and the "
++                   "second index represents the position in 3D of vector "
++                   "head.")
++        assert str(err.value) == err_msg
++
++    @pytest.mark.parametrize("vectors, colors",
++                             [([0, 0, 1], ['g', 'y']),
++                              ([[0, 0, 1], [0, 1, 0]], ['y']),
++                              ([0, 0, 1], [['g', 'y']])],
++                             ids=["one-vec-two-colors", "two-vec-one-color",
++                                  "wrong-dimension-list"]
++                             )
++    def test_vector_errors_color_length(self, vectors, colors):
++        with pytest.raises(ValueError) as err:
++            b = Bloch()
++            b.add_vectors(vectors, colors=colors)
++            b.render()
++
++        err_msg = ("The included colors are not valid. colors must "
++                   "be equivalent to a 1D array with the same "
++                   "size as the number of vectors. ")
++        assert str(err.value) == err_msg
++
++
++def test_repr_svg():
++    pytest.importorskip("matplotlib")
++    pytest.importorskip("ipython")
++    svg = Bloch()._repr_svg_()
++    assert isinstance(svg, str)
++    assert svg.startswith("<?xml")
++    assert svg.endswith("</svg>\n")
+diff --git a/qutip/tests/test_enr_state_operator.py b/qutip/tests/test_enr_state_operator.py
+index 9002c375..d07b7ebb 100644
+--- a/qutip/tests/test_enr_state_operator.py
++++ b/qutip/tests/test_enr_state_operator.py
+@@ -1,116 +1,116 @@
+-import pytest
+-import itertools
+-import random
+-import numpy as np
+-import qutip
+-
+-
+-def _n_enr_states(dimensions, n_excitations):
+-    """
+-    Calculate the total number of distinct ENR states for a given set of
+-    subspaces.  This method is not intended to be fast or efficient, it's
+-    intended to be obviously correct for testing purposes.
+-    """
+-    count = 0
+-    for excitations in itertools.product(*map(range, dimensions)):
+-        count += int(sum(excitations) <= n_excitations)
+-    return count
+-
+-
+-@pytest.fixture(params=[
+-    pytest.param([4], id="single"),
+-    pytest.param([4]*2, id="tensor-equal-2"),
+-    pytest.param([4]*3, id="tensor-equal-3"),
+-    pytest.param([4]*4, id="tensor-equal-4"),
+-    pytest.param([2, 3, 4], id="tensor-not-equal"),
+-])
+-def dimensions(request):
+-    return request.param
+-
+-
+-@pytest.fixture(params=[1, 2, 3, 1_000_000])
+-def n_excitations(request):
+-    return request.param
+-
+-
+-class TestOperator:
+-    def test_no_restrictions(self, dimensions):
+-        """
+-        Test that the restricted-excitation operators are equal to the standard
+-        operators when there aren't any restrictions.
+-        """
+-        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
+-        a = [qutip.destroy(n) for n in dimensions]
+-        iden = [qutip.qeye(n) for n in dimensions]
+-        for i, test in enumerate(test_operators):
+-            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
+-            assert test == expected
+-            assert test.dims == [dimensions, dimensions]
+-
+-    def test_space_size_reduction(self, dimensions, n_excitations):
+-        test_operators = qutip.enr_destroy(dimensions, n_excitations)
+-        expected_size = _n_enr_states(dimensions, n_excitations)
+-        expected_shape = (expected_size, expected_size)
+-        for test in test_operators:
+-            assert test.shape == expected_shape
+-            assert test.dims == [dimensions, dimensions]
+-
+-    def test_identity(self, dimensions, n_excitations):
+-        iden = qutip.enr_identity(dimensions, n_excitations)
+-        expected_size = _n_enr_states(dimensions, n_excitations)
+-        expected_shape = (expected_size, expected_size)
+-        assert np.all(iden.diag() == 1)
+-        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
+-        assert iden.shape == expected_shape
+-        assert iden.dims == [dimensions, dimensions]
+-
+-
+-def test_fock_state(dimensions, n_excitations):
+-    """
+-    Test Fock state creation agrees with the number operators implied by the
+-    existence of the ENR annihiliation operators.
+-    """
+-    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
+-    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
+-    n_samples = min((len(bases), 5))
+-    for basis in random.sample(bases, n_samples):
+-        state = qutip.enr_fock(dimensions, n_excitations, basis)
+-        for n, x in zip(number, basis):
+-            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
+-
+-
+-def test_fock_state_error():
+-    with pytest.raises(ValueError) as e:
+-        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
+-    assert str(e.value).startswith("The state tuple ")
+-
+-
+-def _reference_dm(dimensions, n_excitations, nbars):
+-    """
+-    Get the reference density matrix explicitly, to compare to the direct ENR
+-    construction.
+-    """
+-    if np.isscalar(nbars):
+-        nbars = [nbars] * len(dimensions)
+-    keep = np.array([
+-        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
+-        if sum(state) <= n_excitations
+-    ])
+-    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
+-                       for dimension, nbar in zip(dimensions, nbars)])
+-    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
+-    return out / out.tr()
+-
+-
+-@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
+-def test_thermal_dm(dimensions, n_excitations, nbar_type):
+-    # Ensure that the average number of excitations over all the states is
+-    # much less than the total number of allowed excitations.
+-    if nbar_type == "scalar":
+-        nbars = 0.1 * n_excitations / len(dimensions)
+-    else:
+-        nbars = np.random.rand(len(dimensions))
+-        nbars *= (0.1 * n_excitations) / np.sum(nbars)
+-    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
+-    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
+-    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
++import pytest
++import itertools
++import random
++import numpy as np
++import qutip
++
++
++def _n_enr_states(dimensions, n_excitations):
++    """
++    Calculate the total number of distinct ENR states for a given set of
++    subspaces.  This method is not intended to be fast or efficient, it's
++    intended to be obviously correct for testing purposes.
++    """
++    count = 0
++    for excitations in itertools.product(*map(range, dimensions)):
++        count += int(sum(excitations) <= n_excitations)
++    return count
++
++
++@pytest.fixture(params=[
++    pytest.param([4], id="single"),
++    pytest.param([4]*2, id="tensor-equal-2"),
++    pytest.param([4]*3, id="tensor-equal-3"),
++    pytest.param([4]*4, id="tensor-equal-4"),
++    pytest.param([2, 3, 4], id="tensor-not-equal"),
++])
++def dimensions(request):
++    return request.param
++
++
++@pytest.fixture(params=[1, 2, 3, 1_000_000])
++def n_excitations(request):
++    return request.param
++
++
++class TestOperator:
++    def test_no_restrictions(self, dimensions):
++        """
++        Test that the restricted-excitation operators are equal to the standard
++        operators when there aren't any restrictions.
++        """
++        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
++        a = [qutip.destroy(n) for n in dimensions]
++        iden = [qutip.qeye(n) for n in dimensions]
++        for i, test in enumerate(test_operators):
++            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
++            assert test == expected
++            assert test.dims == [dimensions, dimensions]
++
++    def test_space_size_reduction(self, dimensions, n_excitations):
++        test_operators = qutip.enr_destroy(dimensions, n_excitations)
++        expected_size = _n_enr_states(dimensions, n_excitations)
++        expected_shape = (expected_size, expected_size)
++        for test in test_operators:
++            assert test.shape == expected_shape
++            assert test.dims == [dimensions, dimensions]
++
++    def test_identity(self, dimensions, n_excitations):
++        iden = qutip.enr_identity(dimensions, n_excitations)
++        expected_size = _n_enr_states(dimensions, n_excitations)
++        expected_shape = (expected_size, expected_size)
++        assert np.all(iden.diag() == 1)
++        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
++        assert iden.shape == expected_shape
++        assert iden.dims == [dimensions, dimensions]
++
++
++def test_fock_state(dimensions, n_excitations):
++    """
++    Test Fock state creation agrees with the number operators implied by the
++    existence of the ENR annihiliation operators.
++    """
++    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
++    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
++    n_samples = min((len(bases), 5))
++    for basis in random.sample(bases, n_samples):
++        state = qutip.enr_fock(dimensions, n_excitations, basis)
++        for n, x in zip(number, basis):
++            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
++
++
++def test_fock_state_error():
++    with pytest.raises(ValueError) as e:
++        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
++    assert str(e.value).startswith("The state tuple ")
++
++
++def _reference_dm(dimensions, n_excitations, nbars):
++    """
++    Get the reference density matrix explicitly, to compare to the direct ENR
++    construction.
++    """
++    if np.isscalar(nbars):
++        nbars = [nbars] * len(dimensions)
++    keep = np.array([
++        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
++        if sum(state) <= n_excitations
++    ])
++    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
++                       for dimension, nbar in zip(dimensions, nbars)])
++    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
++    return out / out.tr()
++
++
++@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
++def test_thermal_dm(dimensions, n_excitations, nbar_type):
++    # Ensure that the average number of excitations over all the states is
++    # much less than the total number of allowed excitations.
++    if nbar_type == "scalar":
++        nbars = 0.1 * n_excitations / len(dimensions)
++    else:
++        nbars = np.random.rand(len(dimensions))
++        nbars *= (0.1 * n_excitations) / np.sum(nbars)
++    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
++    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
++    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
+diff --git a/qutip/tests/test_entropy.py b/qutip/tests/test_entropy.py
+index ecf465c9..ea0f0c35 100644
+--- a/qutip/tests/test_entropy.py
++++ b/qutip/tests/test_entropy.py
+@@ -1,212 +1,212 @@
+-import pytest
+-import numpy as np
+-import qutip
+-
+-
+-class TestVonNeumannEntropy:
+-    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
+-    def test_binary(self, p):
+-        dm = qutip.qdiags([p, 1 - p], 0)
+-        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
+-        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
+-
+-    @pytest.mark.repeat(10)
+-    def test_pure_state(self):
+-        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
+-
+-
+-class TestLinearEntropy:
+-    @pytest.mark.repeat(10)
+-    def test_less_than_von_neumann(self):
+-        dm = qutip.rand_dm(10)
+-        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
+-
+-    @pytest.mark.repeat(10)
+-    def test_pure_state(self):
+-        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
+-
+-
+-class TestConcurrence:
+-    @pytest.mark.parametrize("dm", [
+-        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
+-        for x in ['00', '01', '10', '11']
+-    ])
+-    def test_maximally_entangled(self, dm):
+-        assert abs(qutip.concurrence(dm) - 1) < 1e-12
+-
+-    @pytest.mark.repeat(10)
+-    def test_nonzero(self):
+-        dm = qutip.rand_dm([2, 2])
+-        assert qutip.concurrence(dm) >= 0
+-
+-
+-@pytest.mark.repeat(10)
+-class TestMutualInformation:
+-    def test_pure_state_additive(self):
+-        # Verify mutual information = S(A) + S(B) for pure states.
+-        dm = qutip.rand_dm([5, 5], distribution="pure")
+-        expect = (qutip.entropy_vn(dm.ptrace(0))
+-                  + qutip.entropy_vn(dm.ptrace(1)))
+-        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
+-
+-    def test_component_selection(self):
+-        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
+-        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
+-                  + qutip.entropy_vn(dm.ptrace(1)))
+-        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
+-
+-
+-class TestRelativeEntropy:
+-    def _simple_relative_entropy_implementation(
+-            self, rho, sigma, log_base=np.log, tol=1e-12):
+-        """ A simplified relative entropy implementation for use in
+-            double-checking the optimised implementation within
+-            QuTiP itself.
+-        """
+-        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
+-        rvals, rvecs = rho.eigenstates()
+-        svals, svecs = sigma.eigenstates()
+-        rvecs = np.hstack([vec.full() for vec in rvecs]).T
+-        svecs = np.hstack([vec.full() for vec in svecs]).T
+-        # Calculate S
+-        S = 0
+-        for i in range(len(rvals)):
+-            if abs(rvals[i]) >= tol:
+-                S += rvals[i] * log_base(rvals[i])
+-            for j in range(len(svals)):
+-                P_ij = (
+-                    np.dot(rvecs[i], svecs[j].conjugate()) *
+-                    np.dot(svecs[j], rvecs[i].conjugate())
+-                )
+-                if abs(svals[j]) < tol and not (
+-                        abs(rvals[i]) < tol or abs(P_ij) < tol):
+-                    # kernel of sigma intersects support of rho
+-                    return np.inf
+-                if abs(svals[j]) >= tol:
+-                    S -= rvals[i] * P_ij * log_base(svals[j])
+-        return np.real(S)
+-
+-    def test_rho_or_sigma_not_oper(self):
+-        rho = qutip.bra("00")
+-        sigma = qutip.bra("01")
+-        with pytest.raises(TypeError) as exc:
+-            qutip.entropy_relative(rho.dag(), sigma)
+-        assert str(exc.value) == "Inputs must be density matrices."
+-        with pytest.raises(TypeError) as exc:
+-            qutip.entropy_relative(rho, sigma.dag())
+-        assert str(exc.value) == "Inputs must be density matrices."
+-        with pytest.raises(TypeError) as exc:
+-            qutip.entropy_relative(rho, sigma)
+-        assert str(exc.value) == "Inputs must be density matrices."
+-
+-    def test_rho_and_sigma_have_different_shape_and_dims(self):
+-        # test different shape and dims
+-        rho = qutip.ket("00")
+-        sigma = qutip.ket("0")
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho, sigma)
+-        assert str(exc.value) == "Inputs must have the same shape and dims."
+-        # test same shape, difference dims
+-        rho = qutip.basis([2, 3], [0, 0])
+-        sigma = qutip.basis([3, 2], [0, 0])
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho, sigma)
+-        assert str(exc.value) == "Inputs must have the same shape and dims."
+-
+-    def test_base_not_2_or_e(self):
+-        rho = qutip.ket("00")
+-        sigma = qutip.ket("01")
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho, sigma, base=3)
+-        assert str(exc.value) == "Base must be 2 or e."
+-
+-    def test_infinite_relative_entropy(self):
+-        rho = qutip.ket("00")
+-        sigma = qutip.ket("01")
+-        assert qutip.entropy_relative(rho, sigma) == np.inf
+-
+-    def test_base_2_or_e(self):
+-        rho = qutip.ket2dm(qutip.ket("00"))
+-        sigma = rho + qutip.ket2dm(qutip.ket("01"))
+-        sigma = sigma.unit()
+-        assert (
+-            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
+-        )
+-        assert (
+-            qutip.entropy_relative(rho, sigma, base=np.e)
+-            == pytest.approx(0.69314718)
+-        )
+-        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
+-
+-    def test_pure_vs_maximally_mixed_state(self):
+-        rho = qutip.ket("00")
+-        sigma = sum(
+-            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
+-        ).unit()
+-        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
+-
+-    def test_density_matrices_with_non_real_eigenvalues(self):
+-        rho = qutip.ket2dm(qutip.ket("00"))
+-        sigma = qutip.ket2dm(qutip.ket("01"))
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho + 1j, sigma)
+-        assert str(exc.value) == "Input rho has non-real eigenvalues."
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho - 1j, sigma)
+-        assert str(exc.value) == "Input rho has non-real eigenvalues."
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho, sigma + 1j)
+-        assert str(exc.value) == "Input sigma has non-real eigenvalues."
+-        with pytest.raises(ValueError) as exc:
+-            qutip.entropy_relative(rho, sigma - 1j)
+-        assert str(exc.value) == "Input sigma has non-real eigenvalues."
+-
+-    @pytest.mark.repeat(20)
+-    def test_random_dm_with_self(self):
+-        rho = qutip.rand_dm(8)
+-        rel = qutip.entropy_relative(rho, rho)
+-        assert abs(rel) < 1e-13
+-
+-    @pytest.mark.repeat(20)
+-    def test_random_rho_sigma(self):
+-        rho = qutip.rand_dm(8)
+-        sigma = qutip.rand_dm(8)
+-        rel = qutip.entropy_relative(rho, sigma)
+-        assert rel >= 0
+-        assert rel == pytest.approx(
+-            self._simple_relative_entropy_implementation(rho, sigma, np.log)
+-        )
+-
+-
+-@pytest.mark.repeat(20)
+-class TestConditionalEntropy:
+-    def test_inequality_3_qubits(self):
+-        # S(A | B,C) <= S(A|B)
+-        full = qutip.rand_dm([2]*3, distribution="pure")
+-        ab = full.ptrace([0, 1])
+-        assert (qutip.entropy_conditional(full, [1, 2])
+-                <= qutip.entropy_conditional(ab, 1))
+-
+-    def test_triangle_inequality_4_qubits(self):
+-        # S(A,B | C,D) <= S(A|C) + S(B|D)
+-        full = qutip.rand_dm([2]*4, distribution="pure")
+-        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
+-        assert (qutip.entropy_conditional(full, [2, 3])
+-                <= (qutip.entropy_conditional(ac, 1)
+-                    + qutip.entropy_conditional(bd, 1)))
+-
+-
+-_alpha = 2*np.pi * np.random.rand()
+-
+-
+-@pytest.mark.parametrize(["gate", "expected"], [
+-    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
+-    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
+-    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
+-    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
+-    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
+-    pytest.param(qutip.gates.swapalpha(_alpha),
+-                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
+-])
+-def test_entangling_power(gate, expected):
+-    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
++import pytest
++import numpy as np
++import qutip
++
++
++class TestVonNeumannEntropy:
++    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
++    def test_binary(self, p):
++        dm = qutip.qdiags([p, 1 - p], 0)
++        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
++        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
++
++    @pytest.mark.repeat(10)
++    def test_pure_state(self):
++        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
++
++
++class TestLinearEntropy:
++    @pytest.mark.repeat(10)
++    def test_less_than_von_neumann(self):
++        dm = qutip.rand_dm(10)
++        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
++
++    @pytest.mark.repeat(10)
++    def test_pure_state(self):
++        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
++
++
++class TestConcurrence:
++    @pytest.mark.parametrize("dm", [
++        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
++        for x in ['00', '01', '10', '11']
++    ])
++    def test_maximally_entangled(self, dm):
++        assert abs(qutip.concurrence(dm) - 1) < 1e-12
++
++    @pytest.mark.repeat(10)
++    def test_nonzero(self):
++        dm = qutip.rand_dm([2, 2])
++        assert qutip.concurrence(dm) >= 0
++
++
++@pytest.mark.repeat(10)
++class TestMutualInformation:
++    def test_pure_state_additive(self):
++        # Verify mutual information = S(A) + S(B) for pure states.
++        dm = qutip.rand_dm([5, 5], distribution="pure")
++        expect = (qutip.entropy_vn(dm.ptrace(0))
++                  + qutip.entropy_vn(dm.ptrace(1)))
++        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
++
++    def test_component_selection(self):
++        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
++        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
++                  + qutip.entropy_vn(dm.ptrace(1)))
++        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
++
++
++class TestRelativeEntropy:
++    def _simple_relative_entropy_implementation(
++            self, rho, sigma, log_base=np.log, tol=1e-12):
++        """ A simplified relative entropy implementation for use in
++            double-checking the optimised implementation within
++            QuTiP itself.
++        """
++        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
++        rvals, rvecs = rho.eigenstates()
++        svals, svecs = sigma.eigenstates()
++        rvecs = np.hstack([vec.full() for vec in rvecs]).T
++        svecs = np.hstack([vec.full() for vec in svecs]).T
++        # Calculate S
++        S = 0
++        for i in range(len(rvals)):
++            if abs(rvals[i]) >= tol:
++                S += rvals[i] * log_base(rvals[i])
++            for j in range(len(svals)):
++                P_ij = (
++                    np.dot(rvecs[i], svecs[j].conjugate()) *
++                    np.dot(svecs[j], rvecs[i].conjugate())
++                )
++                if abs(svals[j]) < tol and not (
++                        abs(rvals[i]) < tol or abs(P_ij) < tol):
++                    # kernel of sigma intersects support of rho
++                    return np.inf
++                if abs(svals[j]) >= tol:
++                    S -= rvals[i] * P_ij * log_base(svals[j])
++        return np.real(S)
++
++    def test_rho_or_sigma_not_oper(self):
++        rho = qutip.bra("00")
++        sigma = qutip.bra("01")
++        with pytest.raises(TypeError) as exc:
++            qutip.entropy_relative(rho.dag(), sigma)
++        assert str(exc.value) == "Inputs must be density matrices."
++        with pytest.raises(TypeError) as exc:
++            qutip.entropy_relative(rho, sigma.dag())
++        assert str(exc.value) == "Inputs must be density matrices."
++        with pytest.raises(TypeError) as exc:
++            qutip.entropy_relative(rho, sigma)
++        assert str(exc.value) == "Inputs must be density matrices."
++
++    def test_rho_and_sigma_have_different_shape_and_dims(self):
++        # test different shape and dims
++        rho = qutip.ket("00")
++        sigma = qutip.ket("0")
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho, sigma)
++        assert str(exc.value) == "Inputs must have the same shape and dims."
++        # test same shape, difference dims
++        rho = qutip.basis([2, 3], [0, 0])
++        sigma = qutip.basis([3, 2], [0, 0])
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho, sigma)
++        assert str(exc.value) == "Inputs must have the same shape and dims."
++
++    def test_base_not_2_or_e(self):
++        rho = qutip.ket("00")
++        sigma = qutip.ket("01")
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho, sigma, base=3)
++        assert str(exc.value) == "Base must be 2 or e."
++
++    def test_infinite_relative_entropy(self):
++        rho = qutip.ket("00")
++        sigma = qutip.ket("01")
++        assert qutip.entropy_relative(rho, sigma) == np.inf
++
++    def test_base_2_or_e(self):
++        rho = qutip.ket2dm(qutip.ket("00"))
++        sigma = rho + qutip.ket2dm(qutip.ket("01"))
++        sigma = sigma.unit()
++        assert (
++            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
++        )
++        assert (
++            qutip.entropy_relative(rho, sigma, base=np.e)
++            == pytest.approx(0.69314718)
++        )
++        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
++
++    def test_pure_vs_maximally_mixed_state(self):
++        rho = qutip.ket("00")
++        sigma = sum(
++            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
++        ).unit()
++        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
++
++    def test_density_matrices_with_non_real_eigenvalues(self):
++        rho = qutip.ket2dm(qutip.ket("00"))
++        sigma = qutip.ket2dm(qutip.ket("01"))
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho + 1j, sigma)
++        assert str(exc.value) == "Input rho has non-real eigenvalues."
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho - 1j, sigma)
++        assert str(exc.value) == "Input rho has non-real eigenvalues."
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho, sigma + 1j)
++        assert str(exc.value) == "Input sigma has non-real eigenvalues."
++        with pytest.raises(ValueError) as exc:
++            qutip.entropy_relative(rho, sigma - 1j)
++        assert str(exc.value) == "Input sigma has non-real eigenvalues."
++
++    @pytest.mark.repeat(20)
++    def test_random_dm_with_self(self):
++        rho = qutip.rand_dm(8)
++        rel = qutip.entropy_relative(rho, rho)
++        assert abs(rel) < 1e-13
++
++    @pytest.mark.repeat(20)
++    def test_random_rho_sigma(self):
++        rho = qutip.rand_dm(8)
++        sigma = qutip.rand_dm(8)
++        rel = qutip.entropy_relative(rho, sigma)
++        assert rel >= 0
++        assert rel == pytest.approx(
++            self._simple_relative_entropy_implementation(rho, sigma, np.log)
++        )
++
++
++@pytest.mark.repeat(20)
++class TestConditionalEntropy:
++    def test_inequality_3_qubits(self):
++        # S(A | B,C) <= S(A|B)
++        full = qutip.rand_dm([2]*3, distribution="pure")
++        ab = full.ptrace([0, 1])
++        assert (qutip.entropy_conditional(full, [1, 2])
++                <= qutip.entropy_conditional(ab, 1))
++
++    def test_triangle_inequality_4_qubits(self):
++        # S(A,B | C,D) <= S(A|C) + S(B|D)
++        full = qutip.rand_dm([2]*4, distribution="pure")
++        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
++        assert (qutip.entropy_conditional(full, [2, 3])
++                <= (qutip.entropy_conditional(ac, 1)
++                    + qutip.entropy_conditional(bd, 1)))
++
++
++_alpha = 2*np.pi * np.random.rand()
++
++
++@pytest.mark.parametrize(["gate", "expected"], [
++    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
++    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
++    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
++    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
++    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
++    pytest.param(qutip.gates.swapalpha(_alpha),
++                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
++])
++def test_entangling_power(gate, expected):
++    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
+diff --git a/qutip/tests/test_fileio.py b/qutip/tests/test_fileio.py
+index 74337606..13e20458 100644
+--- a/qutip/tests/test_fileio.py
++++ b/qutip/tests/test_fileio.py
+@@ -1,62 +1,62 @@
+-import pytest
+-import numpy as np
+-import uuid
+-import qutip
+-from pathlib import Path
+-
+-# qsave _always_ appends a suffix to the file name at the time of writing, but
+-# in case this changes in the future, to ensure that we never leak a temporary
+-# file into the user's folders, we simply apply these tests in a temporary
+-# directory.  Windows also does not allow temporary files to be opened multiple
+-# times, so using a temporary directory is best.
+-pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
+-
+-_dimension = 10
+-
+-
+-def _random_file_name():
+-    return "_" + str(uuid.uuid4())
+-
+-
+-class Test_file_data_store_file_data_read:
+-    # Tests parametrised seprately to give nicer descriptions in verbose mode.
+-
+-    def case(self, filename, kwargs):
+-        data = 1 - 2*np.random.rand(_dimension, _dimension)
+-        if kwargs.get('numtype', 'complex') == 'complex':
+-            data = data * (0.5*0.5j)
+-        qutip.file_data_store(filename, data, **kwargs)
+-        out = qutip.file_data_read(filename)
+-        np.testing.assert_allclose(data, out, atol=1e-8)
+-
+-    def test_defaults(self):
+-        return self.case(_random_file_name(), {})
+-
+-    @pytest.mark.parametrize("type_", ["real", "complex"])
+-    @pytest.mark.parametrize("format_", ["decimal", "exp"])
+-    def test_type_format(self, type_, format_):
+-
+-        kwargs = {'numtype': type_, 'numformat': format_}
+-        return self.case(_random_file_name(), kwargs)
+-
+-    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
+-                             ids=lambda x: "'" + x + "'")
+-    def test_separator_detection(self, separator):
+-        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
+-        return self.case(_random_file_name(), kwargs)
+-
+-
+-@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
+-@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
+-def test_qsave_qload(use_path, suffix):
+-    ops_in = [qutip.sigmax(),
+-              qutip.num(_dimension),
+-              qutip.coherent_dm(_dimension, 1j)]
+-    filename = _random_file_name() + suffix
+-    if use_path:
+-        filename = Path.cwd() / filename
+-    qutip.qsave(ops_in, filename)
+-    ops_out = qutip.qload(filename)
+-    assert ops_in == ops_out
+-    # check that the file was saved with the correct name:
+-    assert Path(str(filename) + ".qu").exists()
++import pytest
++import numpy as np
++import uuid
++import qutip
++from pathlib import Path
++
++# qsave _always_ appends a suffix to the file name at the time of writing, but
++# in case this changes in the future, to ensure that we never leak a temporary
++# file into the user's folders, we simply apply these tests in a temporary
++# directory.  Windows also does not allow temporary files to be opened multiple
++# times, so using a temporary directory is best.
++pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
++
++_dimension = 10
++
++
++def _random_file_name():
++    return "_" + str(uuid.uuid4())
++
++
++class Test_file_data_store_file_data_read:
++    # Tests parametrised seprately to give nicer descriptions in verbose mode.
++
++    def case(self, filename, kwargs):
++        data = 1 - 2*np.random.rand(_dimension, _dimension)
++        if kwargs.get('numtype', 'complex') == 'complex':
++            data = data * (0.5*0.5j)
++        qutip.file_data_store(filename, data, **kwargs)
++        out = qutip.file_data_read(filename)
++        np.testing.assert_allclose(data, out, atol=1e-8)
++
++    def test_defaults(self):
++        return self.case(_random_file_name(), {})
++
++    @pytest.mark.parametrize("type_", ["real", "complex"])
++    @pytest.mark.parametrize("format_", ["decimal", "exp"])
++    def test_type_format(self, type_, format_):
++
++        kwargs = {'numtype': type_, 'numformat': format_}
++        return self.case(_random_file_name(), kwargs)
++
++    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
++                             ids=lambda x: "'" + x + "'")
++    def test_separator_detection(self, separator):
++        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
++        return self.case(_random_file_name(), kwargs)
++
++
++@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
++@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
++def test_qsave_qload(use_path, suffix):
++    ops_in = [qutip.sigmax(),
++              qutip.num(_dimension),
++              qutip.coherent_dm(_dimension, 1j)]
++    filename = _random_file_name() + suffix
++    if use_path:
++        filename = Path.cwd() / filename
++    qutip.qsave(ops_in, filename)
++    ops_out = qutip.qload(filename)
++    assert ops_in == ops_out
++    # check that the file was saved with the correct name:
++    assert Path(str(filename) + ".qu").exists()
+diff --git a/qutip/tests/test_ipynbtools.py b/qutip/tests/test_ipynbtools.py
+index 2b1c7655..25f3ec16 100644
+--- a/qutip/tests/test_ipynbtools.py
++++ b/qutip/tests/test_ipynbtools.py
+@@ -1,24 +1,24 @@
+-from qutip.ipynbtools import version_table
+-import pytest
+-
+-
+-@pytest.mark.parametrize('verbose', [False, True])
+-def test_version_table(verbose):
+-    html_data = version_table(verbose=verbose).data
+-    assert "<th>Software</th>" in html_data
+-    assert "<th>Version</th>" in html_data
+-    assert "<td>QuTiP</td>" in html_data
+-    assert "<td>Numpy</td>" in html_data
+-    assert "<td>SciPy</td>" in html_data
+-    assert "<td>matplotlib</td>" in html_data
+-    assert "<td>IPython</td>" in html_data
+-    if verbose:
+-        assert "<td>Installation path</td>" in html_data
+-        if pytest.importorskip("getpass") is not None:
+-            assert "<td>User</td>" in html_data
+-
+-
+-@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
+-def test_version_table_with_cython():
+-    html_data = version_table().data
+-    assert "<td>Cython</td>" in html_data
++from qutip.ipynbtools import version_table
++import pytest
++
++
++@pytest.mark.parametrize('verbose', [False, True])
++def test_version_table(verbose):
++    html_data = version_table(verbose=verbose).data
++    assert "<th>Software</th>" in html_data
++    assert "<th>Version</th>" in html_data
++    assert "<td>QuTiP</td>" in html_data
++    assert "<td>Numpy</td>" in html_data
++    assert "<td>SciPy</td>" in html_data
++    assert "<td>matplotlib</td>" in html_data
++    assert "<td>IPython</td>" in html_data
++    if verbose:
++        assert "<td>Installation path</td>" in html_data
++        if pytest.importorskip("getpass") is not None:
++            assert "<td>User</td>" in html_data
++
++
++@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
++def test_version_table_with_cython():
++    html_data = version_table().data
++    assert "<td>Cython</td>" in html_data
+diff --git a/qutip/tests/test_measurement.py b/qutip/tests/test_measurement.py
+index 6bccd1a3..b904e2c3 100644
+--- a/qutip/tests/test_measurement.py
++++ b/qutip/tests/test_measurement.py
+@@ -1,324 +1,324 @@
+-import numpy as np
+-import scipy
+-import pytest
+-from math import sqrt
+-from qutip import (
+-    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
+-    rand_ket,
+-)
+-from qutip.measurement import (
+-    measure_povm, measurement_statistics_povm, measure_observable,
+-    measurement_statistics_observable,
+-)
+-
+-
+-class EigenPairs:
+-    """ Manage pairs of eigenvalues and eigenstates for an operator. """
+-    def __init__(self, pairs):
+-        self.pairs = pairs
+-        self.eigenvalues = [p[0] for p in pairs]
+-        self.eigenstates = [p[1] for p in pairs]
+-        self.projectors = [v * v.dag() for v in self.eigenstates]
+-
+-    def __getitem__(self, i):
+-        return self.pairs[i]
+-
+-    def __contains__(self, other):
+-        for i, val in enumerate(self.eigenvalues):
+-            if abs(val - other[0]) < 1e-8:
+-                break
+-        else:
+-            return False
+-        return _equivalent(other[1], self.eigenstates[i])
+-
+-
+-def pairs2dm(pairs):
+-    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
+-    return [(v, e.proj()) for v, e in pairs]
+-
+-
+-SIGMAZ = EigenPairs([
+-    (-1.0, -basis(2, 1)),
+-    (1.0, -basis(2, 0)),
+-])
+-
+-SIGMAX = EigenPairs([
+-    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
+-    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
+-])
+-
+-SIGMAY = EigenPairs([
+-    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
+-    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
+-])
+-
+-state0 = basis(2, 0)
+-state1 = basis(2, 1)
+-stateplus = (basis(2, 0) + basis(2, 1)).unit()
+-stateminus = (basis(2, 0) - basis(2, 1)).unit()
+-stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
+-stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
+-PZ = [ket2dm(state0), ket2dm(state1)]
+-PX = [ket2dm(stateplus), ket2dm(stateminus)]
+-PY = [ket2dm(stateR), ket2dm(stateL)]
+-PZ_ket = [state0, state1]
+-
+-
+-def _equivalent(left, right, tol=1e-8):
+-    """ Equal up to a phase """
+-    return 1 - abs(left.overlap(right)) < tol
+-
+-
+-@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
+-    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
+-    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
+-    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
+-    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
+-                 id="sigmax_dm"),
+-    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
+-    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
+-                 id="sigmay_dm"),
+-])
+-def test_measurement_statistics_observable(op, state, pairs, probabilities):
+-    """ measurement_statistics_observable: observables on basis states. """
+-
+-    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
+-    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
+-    if state.isket:
+-        ess = ess_or_projs
+-        assert len(ess) == len(pairs.eigenstates)
+-        for a, b in zip(ess, pairs.eigenstates):
+-            assert _equivalent(a, b)
+-    else:
+-        projs = ess_or_projs
+-        assert len(projs) == len(pairs.projectors)
+-        for a, b in zip(projs, pairs.projectors):
+-            assert _equivalent(a, b)
+-    np.testing.assert_almost_equal(probs, probabilities)
+-
+-
+-@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
+-    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
+-    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
+-                 id="PZ_dm"),
+-    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
+-    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
+-                 id="PZket_dm"),
+-    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
+-                 id="PX_ket"),
+-    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
+-                 [0.5, 0.5], id="PX_dm"),
+-    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
+-    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
+-                 [0.5, 0.5], id="PY_dm")])
+-def test_measurement_statistics_povm(ops, state, final_states, probabilities):
+-    """ measurement_statistics_povm: projectors applied to basis states. """
+-
+-    collapsed_states, probs = measurement_statistics_povm(state, ops)
+-    for i, final_state in enumerate(final_states):
+-        collapsed_state = collapsed_states[i]
+-        if final_state:
+-            assert collapsed_state == final_state
+-        else:
+-            assert collapsed_state is None
+-    np.testing.assert_almost_equal(probs, probabilities)
+-
+-
+-def test_measurement_statistics_povm_input_errors():
+-    """ measurement_statistics_povm: check input errors """
+-
+-    np.testing.assert_raises_regex(
+-        ValueError, "op must be all operators or all kets",
+-        measurement_statistics_povm,
+-        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
+-    np.testing.assert_raises_regex(
+-        TypeError, "state must be a Qobj",
+-        measurement_statistics_povm, "notqobj", [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError, "state must be a ket or a density matrix",
+-        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should be compatible when state is a ket",
+-        measurement_statistics_povm, basis(3, 0), [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should match when state is a density matrix",
+-        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "measurement operators must sum to identity",
+-        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "measurement operators must sum to identity",
+-        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
+-
+-
+-def test_measurement_statistics_observable_input_errors():
+-    """ measurement_statistics_observable: check input errors """
+-
+-    np.testing.assert_raises_regex(
+-        TypeError, "op must be a Qobj",
+-        measurement_statistics_observable, basis(2, 0), "notqobj")
+-    np.testing.assert_raises_regex(
+-        ValueError, "op must be all operators or all kets",
+-        measurement_statistics_observable, basis(2, 0), basis(2, 1))
+-    np.testing.assert_raises_regex(
+-        TypeError, "state must be a Qobj",
+-        measurement_statistics_observable, "notqobj",  sigmaz())
+-    np.testing.assert_raises_regex(
+-        ValueError, "state must be a ket or a density matrix",
+-        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should be compatible when state is a ket",
+-        measurement_statistics_observable, basis(3, 0), sigmaz())
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should match when state is a density matrix",
+-        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
+-
+-
+-@pytest.mark.parametrize(["op", "state"], [
+-                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
+-                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
+-                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
+-                                 id="sigmaz_dm1"),
+-                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
+-                                 id="sigmaz_dm2"),
+-
+-                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
+-                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
+-                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
+-                                 id="sigmax_dm"),
+-
+-                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
+-                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
+-                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
+-                                 id="sigmay_dm")])
+-def test_measure_observable(op, state):
+-    """ measure_observable: basis states using different observables """
+-    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
+-
+-    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
+-    for _ in range(10):
+-        assert (measure_observable(state, op) in expected_measurements)
+-
+-
+-@pytest.mark.parametrize(["ops", "state"], [
+-
+-                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
+-                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
+-                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
+-                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
+-
+-                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
+-                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
+-                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
+-                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
+-
+-                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
+-                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
+-                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
+-
+-                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
+-                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
+-                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
+-def test_measure(ops, state):
+-    """measure_povm: test on basis states using different projectors """
+-
+-    collapsed_states, _ = measurement_statistics_povm(state, ops)
+-    for _ in range(10):
+-        index, final_state = measure_povm(state, ops)
+-        assert final_state == collapsed_states[index]
+-
+-
+-def test_measure_input_errors():
+-    """ measure_povm: check input errors """
+-    np.testing.assert_raises_regex(
+-        ValueError, "op must be all operators or all kets",
+-        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
+-    np.testing.assert_raises_regex(
+-        TypeError, "state must be a Qobj",
+-        measure_povm, "notqobj", [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError, "state must be a ket or a density matrix",
+-        measure_povm, basis(2, 0).dag(), [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should be compatible when state is a ket",
+-        measure_povm, basis(3, 0), [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should match when state is a density matrix",
+-        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "measurement operators must sum to identity",
+-        measure_povm, basis(2, 0), [basis(2, 0)])
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "measurement operators must sum to identity",
+-        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
+-
+-
+-def test_measure_observable_input_errors():
+-    """ measure_observable: check input errors """
+-    np.testing.assert_raises_regex(
+-        TypeError, "op must be a Qobj",
+-        measure_observable, basis(2, 0), "notqobj")
+-    np.testing.assert_raises_regex(
+-        ValueError, "op must be all operators or all kets",
+-        measure_observable, basis(2, 0),  basis(2, 1))
+-    np.testing.assert_raises_regex(
+-        TypeError, "state must be a Qobj",
+-        measure_observable, "notqobj", sigmaz())
+-    np.testing.assert_raises_regex(
+-        ValueError, "state must be a ket or a density matrix",
+-        measure_observable, basis(2, 0).dag(), sigmaz())
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should be compatible when state is a ket",
+-        measure_observable, basis(3, 0), sigmaz())
+-    np.testing.assert_raises_regex(
+-        ValueError,
+-        "op and state dims should match when state is a density matrix",
+-        measure_observable, ket2dm(basis(3, 0)), sigmaz())
+-
+-
+-def test_povm():
+-    """
+-    Test if povm formulation works correctly by checking probabilities for
+-    the quantum state discrimination example
+-    """
+-
+-    coeff = (sqrt(2)/(1+sqrt(2)))
+-
+-    E_1 = coeff * ket2dm(basis(2, 1))
+-    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
+-    E_3 = identity(2) - E_1 - E_2
+-
+-    M_1 = E_1.sqrtm()
+-    M_2 = E_2.sqrtm()
+-    M_3 = E_3.sqrtm()
+-
+-    ket1 = basis(2, 0)
+-    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
+-
+-    dm1 = ket2dm(ket1)
+-    dm2 = ket2dm(ket2)
+-
+-    M = [M_1, M_2, M_3]
+-
+-    _, probabilities = measurement_statistics_povm(ket1, M)
+-    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
+-
+-    _, probabilities = measurement_statistics_povm(ket2, M)
+-    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
+-
+-    _, probabilities = measurement_statistics_povm(dm1, M)
+-    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
+-
+-    _, probabilities = measurement_statistics_povm(dm2, M)
+-    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
++import numpy as np
++import scipy
++import pytest
++from math import sqrt
++from qutip import (
++    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
++    rand_ket,
++)
++from qutip.measurement import (
++    measure_povm, measurement_statistics_povm, measure_observable,
++    measurement_statistics_observable,
++)
++
++
++class EigenPairs:
++    """ Manage pairs of eigenvalues and eigenstates for an operator. """
++    def __init__(self, pairs):
++        self.pairs = pairs
++        self.eigenvalues = [p[0] for p in pairs]
++        self.eigenstates = [p[1] for p in pairs]
++        self.projectors = [v * v.dag() for v in self.eigenstates]
++
++    def __getitem__(self, i):
++        return self.pairs[i]
++
++    def __contains__(self, other):
++        for i, val in enumerate(self.eigenvalues):
++            if abs(val - other[0]) < 1e-8:
++                break
++        else:
++            return False
++        return _equivalent(other[1], self.eigenstates[i])
++
++
++def pairs2dm(pairs):
++    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
++    return [(v, e.proj()) for v, e in pairs]
++
++
++SIGMAZ = EigenPairs([
++    (-1.0, -basis(2, 1)),
++    (1.0, -basis(2, 0)),
++])
++
++SIGMAX = EigenPairs([
++    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
++    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
++])
++
++SIGMAY = EigenPairs([
++    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
++    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
++])
++
++state0 = basis(2, 0)
++state1 = basis(2, 1)
++stateplus = (basis(2, 0) + basis(2, 1)).unit()
++stateminus = (basis(2, 0) - basis(2, 1)).unit()
++stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
++stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
++PZ = [ket2dm(state0), ket2dm(state1)]
++PX = [ket2dm(stateplus), ket2dm(stateminus)]
++PY = [ket2dm(stateR), ket2dm(stateL)]
++PZ_ket = [state0, state1]
++
++
++def _equivalent(left, right, tol=1e-8):
++    """ Equal up to a phase """
++    return 1 - abs(left.overlap(right)) < tol
++
++
++@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
++    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
++    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
++    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
++    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
++                 id="sigmax_dm"),
++    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
++    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
++                 id="sigmay_dm"),
++])
++def test_measurement_statistics_observable(op, state, pairs, probabilities):
++    """ measurement_statistics_observable: observables on basis states. """
++
++    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
++    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
++    if state.isket:
++        ess = ess_or_projs
++        assert len(ess) == len(pairs.eigenstates)
++        for a, b in zip(ess, pairs.eigenstates):
++            assert _equivalent(a, b)
++    else:
++        projs = ess_or_projs
++        assert len(projs) == len(pairs.projectors)
++        for a, b in zip(projs, pairs.projectors):
++            assert _equivalent(a, b)
++    np.testing.assert_almost_equal(probs, probabilities)
++
++
++@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
++    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
++    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
++                 id="PZ_dm"),
++    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
++    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
++                 id="PZket_dm"),
++    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
++                 id="PX_ket"),
++    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
++                 [0.5, 0.5], id="PX_dm"),
++    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
++    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
++                 [0.5, 0.5], id="PY_dm")])
++def test_measurement_statistics_povm(ops, state, final_states, probabilities):
++    """ measurement_statistics_povm: projectors applied to basis states. """
++
++    collapsed_states, probs = measurement_statistics_povm(state, ops)
++    for i, final_state in enumerate(final_states):
++        collapsed_state = collapsed_states[i]
++        if final_state:
++            assert collapsed_state == final_state
++        else:
++            assert collapsed_state is None
++    np.testing.assert_almost_equal(probs, probabilities)
++
++
++def test_measurement_statistics_povm_input_errors():
++    """ measurement_statistics_povm: check input errors """
++
++    np.testing.assert_raises_regex(
++        ValueError, "op must be all operators or all kets",
++        measurement_statistics_povm,
++        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
++    np.testing.assert_raises_regex(
++        TypeError, "state must be a Qobj",
++        measurement_statistics_povm, "notqobj", [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError, "state must be a ket or a density matrix",
++        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should be compatible when state is a ket",
++        measurement_statistics_povm, basis(3, 0), [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should match when state is a density matrix",
++        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "measurement operators must sum to identity",
++        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "measurement operators must sum to identity",
++        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
++
++
++def test_measurement_statistics_observable_input_errors():
++    """ measurement_statistics_observable: check input errors """
++
++    np.testing.assert_raises_regex(
++        TypeError, "op must be a Qobj",
++        measurement_statistics_observable, basis(2, 0), "notqobj")
++    np.testing.assert_raises_regex(
++        ValueError, "op must be all operators or all kets",
++        measurement_statistics_observable, basis(2, 0), basis(2, 1))
++    np.testing.assert_raises_regex(
++        TypeError, "state must be a Qobj",
++        measurement_statistics_observable, "notqobj",  sigmaz())
++    np.testing.assert_raises_regex(
++        ValueError, "state must be a ket or a density matrix",
++        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should be compatible when state is a ket",
++        measurement_statistics_observable, basis(3, 0), sigmaz())
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should match when state is a density matrix",
++        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
++
++
++@pytest.mark.parametrize(["op", "state"], [
++                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
++                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
++                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
++                                 id="sigmaz_dm1"),
++                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
++                                 id="sigmaz_dm2"),
++
++                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
++                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
++                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
++                                 id="sigmax_dm"),
++
++                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
++                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
++                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
++                                 id="sigmay_dm")])
++def test_measure_observable(op, state):
++    """ measure_observable: basis states using different observables """
++    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
++
++    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
++    for _ in range(10):
++        assert (measure_observable(state, op) in expected_measurements)
++
++
++@pytest.mark.parametrize(["ops", "state"], [
++
++                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
++                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
++                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
++                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
++
++                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
++                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
++                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
++                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
++
++                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
++                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
++                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
++
++                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
++                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
++                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
++def test_measure(ops, state):
++    """measure_povm: test on basis states using different projectors """
++
++    collapsed_states, _ = measurement_statistics_povm(state, ops)
++    for _ in range(10):
++        index, final_state = measure_povm(state, ops)
++        assert final_state == collapsed_states[index]
++
++
++def test_measure_input_errors():
++    """ measure_povm: check input errors """
++    np.testing.assert_raises_regex(
++        ValueError, "op must be all operators or all kets",
++        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
++    np.testing.assert_raises_regex(
++        TypeError, "state must be a Qobj",
++        measure_povm, "notqobj", [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError, "state must be a ket or a density matrix",
++        measure_povm, basis(2, 0).dag(), [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should be compatible when state is a ket",
++        measure_povm, basis(3, 0), [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should match when state is a density matrix",
++        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "measurement operators must sum to identity",
++        measure_povm, basis(2, 0), [basis(2, 0)])
++    np.testing.assert_raises_regex(
++        ValueError,
++        "measurement operators must sum to identity",
++        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
++
++
++def test_measure_observable_input_errors():
++    """ measure_observable: check input errors """
++    np.testing.assert_raises_regex(
++        TypeError, "op must be a Qobj",
++        measure_observable, basis(2, 0), "notqobj")
++    np.testing.assert_raises_regex(
++        ValueError, "op must be all operators or all kets",
++        measure_observable, basis(2, 0),  basis(2, 1))
++    np.testing.assert_raises_regex(
++        TypeError, "state must be a Qobj",
++        measure_observable, "notqobj", sigmaz())
++    np.testing.assert_raises_regex(
++        ValueError, "state must be a ket or a density matrix",
++        measure_observable, basis(2, 0).dag(), sigmaz())
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should be compatible when state is a ket",
++        measure_observable, basis(3, 0), sigmaz())
++    np.testing.assert_raises_regex(
++        ValueError,
++        "op and state dims should match when state is a density matrix",
++        measure_observable, ket2dm(basis(3, 0)), sigmaz())
++
++
++def test_povm():
++    """
++    Test if povm formulation works correctly by checking probabilities for
++    the quantum state discrimination example
++    """
++
++    coeff = (sqrt(2)/(1+sqrt(2)))
++
++    E_1 = coeff * ket2dm(basis(2, 1))
++    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
++    E_3 = identity(2) - E_1 - E_2
++
++    M_1 = E_1.sqrtm()
++    M_2 = E_2.sqrtm()
++    M_3 = E_3.sqrtm()
++
++    ket1 = basis(2, 0)
++    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
++
++    dm1 = ket2dm(ket1)
++    dm2 = ket2dm(ket2)
++
++    M = [M_1, M_2, M_3]
++
++    _, probabilities = measurement_statistics_povm(ket1, M)
++    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
++
++    _, probabilities = measurement_statistics_povm(ket2, M)
++    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
++
++    _, probabilities = measurement_statistics_povm(dm1, M)
++    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
++
++    _, probabilities = measurement_statistics_povm(dm2, M)
++    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
+diff --git a/qutip/tests/test_mkl.py b/qutip/tests/test_mkl.py
+index 734f33e2..3eeb83f1 100644
+--- a/qutip/tests/test_mkl.py
++++ b/qutip/tests/test_mkl.py
+@@ -1,116 +1,116 @@
+-import pytest
+-import numpy as np
+-import scipy.linalg
+-import scipy.sparse
+-
+-import qutip
+-if qutip.settings.has_mkl:
+-    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
+-
+-pytestmark = [
+-    pytest.mark.skipif(not qutip.settings.has_mkl,
+-                       reason='MKL extensions not found.'),
+-]
+-
+-
+-class Test_spsolve:
+-    def test_single_rhs_vector_real(self):
+-        Adense = np.array([[0, 1, 1],
+-                           [1, 0, 1],
+-                           [0, 0, 1]])
+-        As = scipy.sparse.csr_matrix(Adense)
+-        np.random.seed(1234)
+-        x = np.random.randn(3)
+-        b = As * x
+-        x2 = mkl_spsolve(As, b, verbose=True)
+-        np.testing.assert_allclose(x, x2)
+-
+-    def test_single_rhs_vector_complex(self):
+-        A = qutip.rand_herm(10, density=0.8, dtype='csr')
+-        x = qutip.rand_ket(10).full()
+-        b = A.full() @ x
+-        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
+-        np.testing.assert_allclose(x, y)
+-
+-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+-    def test_multi_rhs_vector(self, dtype):
+-        M = np.array([
+-            [1, 0, 2],
+-            [0, 0, 3],
+-            [-4, 5, 6],
+-        ], dtype=dtype)
+-        sM = scipy.sparse.csr_matrix(M)
+-        N = np.array([
+-            [3, 0, 1],
+-            [0, 2, 0],
+-            [0, 0, 0],
+-        ], dtype=dtype)
+-        sX = mkl_spsolve(sM, N, verbose=True)
+-        X = scipy.linalg.solve(M, N)
+-        np.testing.assert_allclose(X, sX)
+-
+-    def test_rhs_shape_is_maintained(self):
+-        A = scipy.sparse.csr_matrix(np.array([
+-            [1, 0, 2],
+-            [0, 0, 3],
+-            [-4, 5, 6],
+-        ], dtype=np.complex128))
+-        b = np.array([0, 2, 0], dtype=np.complex128)
+-        out = mkl_spsolve(A, b, verbose=True)
+-        assert b.shape == out.shape
+-
+-        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
+-        out = mkl_spsolve(A, b, verbose=True)
+-        assert b.shape == out.shape
+-
+-    def test_sparse_rhs(self):
+-        A = scipy.sparse.csr_matrix([
+-            [1, 2, 0],
+-            [0, 3, 0],
+-            [0, 0, 5],
+-        ])
+-        b = scipy.sparse.csr_matrix([
+-            [0, 1],
+-            [1, 0],
+-            [0, 0],
+-        ])
+-        x = mkl_spsolve(A, b, verbose=True)
+-        ans = np.array([[-0.66666667, 1],
+-                        [0.33333333, 0],
+-                        [0, 0]])
+-        np.testing.assert_allclose(x.toarray(), ans)
+-
+-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+-    def test_symmetric_solver(self, dtype):
+-        A = qutip.rand_herm(10, distribution="eigen",
+-                            eigenvalues=np.arange(1, 11),
+-                            dtype='csr').data.as_scipy()
+-        if dtype == np.float64:
+-            A = A.real
+-        x = np.ones(10, dtype=dtype)
+-        b = A.dot(x)
+-        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
+-        np.testing.assert_allclose(x, y)
+-
+-
+-class Test_splu:
+-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+-    def test_repeated_rhs_solve(self, dtype):
+-        M = np.array([
+-            [1, 0, 2],
+-            [0, 0, 3],
+-            [-4, 5, 6],
+-        ], dtype=dtype)
+-        sM = scipy.sparse.csr_matrix(M)
+-        N = np.array([
+-            [3, 0, 1],
+-            [0, 2, 0],
+-            [0, 0, 0],
+-        ], dtype=dtype)
+-        test_X = np.zeros((3, 3), dtype=dtype)
+-        lu = mkl_splu(sM, verbose=True)
+-        for k in range(3):
+-            test_X[:, k] = lu.solve(N[:, k])
+-        lu.delete()
+-        expected_X = scipy.linalg.solve(M, N)
+-        np.testing.assert_allclose(test_X, expected_X)
++import pytest
++import numpy as np
++import scipy.linalg
++import scipy.sparse
++
++import qutip
++if qutip.settings.has_mkl:
++    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
++
++pytestmark = [
++    pytest.mark.skipif(not qutip.settings.has_mkl,
++                       reason='MKL extensions not found.'),
++]
++
++
++class Test_spsolve:
++    def test_single_rhs_vector_real(self):
++        Adense = np.array([[0, 1, 1],
++                           [1, 0, 1],
++                           [0, 0, 1]])
++        As = scipy.sparse.csr_matrix(Adense)
++        np.random.seed(1234)
++        x = np.random.randn(3)
++        b = As * x
++        x2 = mkl_spsolve(As, b, verbose=True)
++        np.testing.assert_allclose(x, x2)
++
++    def test_single_rhs_vector_complex(self):
++        A = qutip.rand_herm(10, density=0.8, dtype='csr')
++        x = qutip.rand_ket(10).full()
++        b = A.full() @ x
++        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
++        np.testing.assert_allclose(x, y)
++
++    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
++    def test_multi_rhs_vector(self, dtype):
++        M = np.array([
++            [1, 0, 2],
++            [0, 0, 3],
++            [-4, 5, 6],
++        ], dtype=dtype)
++        sM = scipy.sparse.csr_matrix(M)
++        N = np.array([
++            [3, 0, 1],
++            [0, 2, 0],
++            [0, 0, 0],
++        ], dtype=dtype)
++        sX = mkl_spsolve(sM, N, verbose=True)
++        X = scipy.linalg.solve(M, N)
++        np.testing.assert_allclose(X, sX)
++
++    def test_rhs_shape_is_maintained(self):
++        A = scipy.sparse.csr_matrix(np.array([
++            [1, 0, 2],
++            [0, 0, 3],
++            [-4, 5, 6],
++        ], dtype=np.complex128))
++        b = np.array([0, 2, 0], dtype=np.complex128)
++        out = mkl_spsolve(A, b, verbose=True)
++        assert b.shape == out.shape
++
++        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
++        out = mkl_spsolve(A, b, verbose=True)
++        assert b.shape == out.shape
++
++    def test_sparse_rhs(self):
++        A = scipy.sparse.csr_matrix([
++            [1, 2, 0],
++            [0, 3, 0],
++            [0, 0, 5],
++        ])
++        b = scipy.sparse.csr_matrix([
++            [0, 1],
++            [1, 0],
++            [0, 0],
++        ])
++        x = mkl_spsolve(A, b, verbose=True)
++        ans = np.array([[-0.66666667, 1],
++                        [0.33333333, 0],
++                        [0, 0]])
++        np.testing.assert_allclose(x.toarray(), ans)
++
++    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
++    def test_symmetric_solver(self, dtype):
++        A = qutip.rand_herm(10, distribution="eigen",
++                            eigenvalues=np.arange(1, 11),
++                            dtype='csr').data.as_scipy()
++        if dtype == np.float64:
++            A = A.real
++        x = np.ones(10, dtype=dtype)
++        b = A.dot(x)
++        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
++        np.testing.assert_allclose(x, y)
++
++
++class Test_splu:
++    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
++    def test_repeated_rhs_solve(self, dtype):
++        M = np.array([
++            [1, 0, 2],
++            [0, 0, 3],
++            [-4, 5, 6],
++        ], dtype=dtype)
++        sM = scipy.sparse.csr_matrix(M)
++        N = np.array([
++            [3, 0, 1],
++            [0, 2, 0],
++            [0, 0, 0],
++        ], dtype=dtype)
++        test_X = np.zeros((3, 3), dtype=dtype)
++        lu = mkl_splu(sM, verbose=True)
++        for k in range(3):
++            test_X[:, k] = lu.solve(N[:, k])
++        lu.delete()
++        expected_X = scipy.linalg.solve(M, N)
++        np.testing.assert_allclose(test_X, expected_X)
+diff --git a/qutip/tests/test_openmp.py b/qutip/tests/test_openmp.py
+index 05804ca5..604df3c6 100644
+--- a/qutip/tests/test_openmp.py
++++ b/qutip/tests/test_openmp.py
+@@ -1,111 +1,111 @@
+-import numpy as np
+-from numpy.testing import assert_equal, assert_, run_module_suite
+-import unittest
+-from qutip import *
+-from qutip.settings import settings as qset
+-# if qset.has_openmp:
+-#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
+-
+-
+-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+-@unittest.skipIf(True, 'OPENMP disabled.')
+-def test_openmp_spmv():
+-    "OPENMP : spmvpy_openmp == spmvpy"
+-    for k in range(100):
+-        L = rand_herm(10,0.25).data
+-        vec = rand_ket(L.shape[0],0.25).full().ravel()
+-        out = np.zeros_like(vec)
+-        out_openmp = np.zeros_like(vec)
+-        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
+-        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
+-        assert_(np.allclose(out, out_openmp, 1e-15))
+-
+-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+-@unittest.skipIf(True, 'OPENMP disabled.')
+-def test_openmp_mesolve():
+-    "OPENMP : mesolve"
+-    N = 100
+-    wc = 1.0  * 2 * np.pi  # cavity frequency
+-    wa = 1.0  * 2 * np.pi  # atom frequency
+-    g  = 0.05 * 2 * np.pi  # coupling strength
+-    kappa = 0.005          # cavity dissipation rate
+-    gamma = 0.05           # atom dissipation rate
+-    n_th_a = 1           # temperature in frequency units
+-    use_rwa = 0
+-    # operators
+-    a  = tensor(destroy(N), qeye(2))
+-    sm = tensor(qeye(N), destroy(2))
+-    # Hamiltonian
+-    if use_rwa:
+-        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
+-    else:
+-        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
+-    c_op_list = []
+-
+-    rate = kappa * (1 + n_th_a)
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * a)
+-
+-    rate = kappa * n_th_a
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * a.dag())
+-
+-    rate = gamma
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * sm)
+-
+-    n = N - 2
+-    psi0 = tensor(basis(N, n), basis(2, 1))
+-    tlist = np.linspace(0, 1, 100)
+-    opts = SolverOptions(use_openmp=False)
+-    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+-    opts = SolverOptions(use_openmp=True)
+-    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
+-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+-
+-
+-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+-@unittest.skipIf(True, 'OPENMP disabled.')
+-def test_openmp_mesolve_td():
+-    "OPENMP : mesolve (td)"
+-    N = 100
+-    wc = 1.0  * 2 * np.pi  # cavity frequency
+-    wa = 1.0  * 2 * np.pi  # atom frequency
+-    g  = 0.5 * 2 * np.pi  # coupling strength
+-    kappa = 0.005          # cavity dissipation rate
+-    gamma = 0.05           # atom dissipation rate
+-    n_th_a = 1           # temperature in frequency units
+-    use_rwa = 0
+-    # operators
+-    a  = tensor(destroy(N), qeye(2))
+-    sm = tensor(qeye(N), destroy(2))
+-    # Hamiltonian
+-    H0 = wc * a.dag() * a + wa * sm.dag() * sm
+-    H1 = g * (a.dag() + a) * (sm + sm.dag())
+-
+-    H = [H0, [H1,'sin(t)']]
+-
+-    c_op_list = []
+-
+-    rate = kappa * (1 + n_th_a)
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * a)
+-
+-    rate = kappa * n_th_a
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * a.dag())
+-
+-    rate = gamma
+-    if rate > 0.0:
+-        c_op_list.append(np.sqrt(rate) * sm)
+-
+-    n = N - 10
+-    psi0 = tensor(basis(N, n), basis(2, 1))
+-    tlist = np.linspace(0, 1, 100)
+-    opts = SolverOptions(use_openmp=True)
+-    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+-    opts = SolverOptions(use_openmp=False)
+-    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
+-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
++import numpy as np
++from numpy.testing import assert_equal, assert_, run_module_suite
++import unittest
++from qutip import *
++from qutip.settings import settings as qset
++# if qset.has_openmp:
++#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
++
++
++# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
++@unittest.skipIf(True, 'OPENMP disabled.')
++def test_openmp_spmv():
++    "OPENMP : spmvpy_openmp == spmvpy"
++    for k in range(100):
++        L = rand_herm(10,0.25).data
++        vec = rand_ket(L.shape[0],0.25).full().ravel()
++        out = np.zeros_like(vec)
++        out_openmp = np.zeros_like(vec)
++        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
++        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
++        assert_(np.allclose(out, out_openmp, 1e-15))
++
++# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
++@unittest.skipIf(True, 'OPENMP disabled.')
++def test_openmp_mesolve():
++    "OPENMP : mesolve"
++    N = 100
++    wc = 1.0  * 2 * np.pi  # cavity frequency
++    wa = 1.0  * 2 * np.pi  # atom frequency
++    g  = 0.05 * 2 * np.pi  # coupling strength
++    kappa = 0.005          # cavity dissipation rate
++    gamma = 0.05           # atom dissipation rate
++    n_th_a = 1           # temperature in frequency units
++    use_rwa = 0
++    # operators
++    a  = tensor(destroy(N), qeye(2))
++    sm = tensor(qeye(N), destroy(2))
++    # Hamiltonian
++    if use_rwa:
++        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
++    else:
++        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
++    c_op_list = []
++
++    rate = kappa * (1 + n_th_a)
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * a)
++
++    rate = kappa * n_th_a
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * a.dag())
++
++    rate = gamma
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * sm)
++
++    n = N - 2
++    psi0 = tensor(basis(N, n), basis(2, 1))
++    tlist = np.linspace(0, 1, 100)
++    opts = SolverOptions(use_openmp=False)
++    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
++    opts = SolverOptions(use_openmp=True)
++    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
++    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
++    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
++
++
++# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
++@unittest.skipIf(True, 'OPENMP disabled.')
++def test_openmp_mesolve_td():
++    "OPENMP : mesolve (td)"
++    N = 100
++    wc = 1.0  * 2 * np.pi  # cavity frequency
++    wa = 1.0  * 2 * np.pi  # atom frequency
++    g  = 0.5 * 2 * np.pi  # coupling strength
++    kappa = 0.005          # cavity dissipation rate
++    gamma = 0.05           # atom dissipation rate
++    n_th_a = 1           # temperature in frequency units
++    use_rwa = 0
++    # operators
++    a  = tensor(destroy(N), qeye(2))
++    sm = tensor(qeye(N), destroy(2))
++    # Hamiltonian
++    H0 = wc * a.dag() * a + wa * sm.dag() * sm
++    H1 = g * (a.dag() + a) * (sm + sm.dag())
++
++    H = [H0, [H1,'sin(t)']]
++
++    c_op_list = []
++
++    rate = kappa * (1 + n_th_a)
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * a)
++
++    rate = kappa * n_th_a
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * a.dag())
++
++    rate = gamma
++    if rate > 0.0:
++        c_op_list.append(np.sqrt(rate) * sm)
++
++    n = N - 10
++    psi0 = tensor(basis(N, n), basis(2, 1))
++    tlist = np.linspace(0, 1, 100)
++    opts = SolverOptions(use_openmp=True)
++    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
++    opts = SolverOptions(use_openmp=False)
++    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
++    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
++    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+diff --git a/qutip/tests/test_orbital.py b/qutip/tests/test_orbital.py
+index e5a18297..0fe0fb3f 100644
+--- a/qutip/tests/test_orbital.py
++++ b/qutip/tests/test_orbital.py
+@@ -1,55 +1,55 @@
+-import pytest
+-from scipy.special import sph_harm
+-from qutip.orbital import orbital
+-import qutip
+-import numpy as np
+-
+-
+-def test_orbital_single_ket():
+-    """ Checks output for a single ket as input"""
+-    # setup mesh for theta and phi
+-    theta_list = np.linspace(0, np.pi, num=50)
+-    phi_list = np.linspace(0, 2 * np.pi, num=100)
+-    for theta, phi in zip(theta_list, phi_list):
+-        # set l and m
+-        for l in range(0, 5):
+-            for m in range(-l, l + 1):
+-                q = qutip.basis(2 * l + 1, l + m)
+-                # check that outputs are the same,
+-                # note that theta and phi are interchanged for scipy
+-                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
+-
+-
+-def test_orbital_multiple_ket():
+-    """ Checks if the combination of multiple kets works """
+-    theta_list = np.linspace(0, np.pi, num=50)
+-    phi_list = np.linspace(0, 2 * np.pi, num=100)
+-    l, m = 5, 2
+-    q1 = qutip.basis(2 * l + 1, l + m)
+-    l, m = 3, -1
+-    q2 = qutip.basis(2 * l + 1, l + m)
+-    for theta, phi in zip(theta_list, phi_list):
+-        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
+-        assert orbital(theta, phi, q1, q2) ==  exp
+-
+-
+-def test_orbital_explicit():
+-    """ Checks explicit configurations of orbital functions"""
+-    theta_list = np.linspace(0, np.pi, num=50)
+-    phi_list = np.linspace(0, 2 * np.pi, num=100)
+-    # Constant function
+-    l, m = 0, 0
+-    q = qutip.basis(2 * l + 1, l + m)
+-    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
+-    # cosine function
+-    l, m = 1, 0
+-    q = qutip.basis(2 * l + 1, l + m)
+-    assert np.allclose(orbital(theta_list, 0, q),
+-                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
+-    # cosine with phase
+-    l, m = 1, 1
+-    q = qutip.basis(2 * l + 1, l + m)
+-    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
+-    assert np.allclose(orbital(theta_list, phi_list, q),
+-                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
+-                           theta_mesh) * np.exp(1j * phi_mesh))
++import pytest
++from scipy.special import sph_harm
++from qutip.orbital import orbital
++import qutip
++import numpy as np
++
++
++def test_orbital_single_ket():
++    """ Checks output for a single ket as input"""
++    # setup mesh for theta and phi
++    theta_list = np.linspace(0, np.pi, num=50)
++    phi_list = np.linspace(0, 2 * np.pi, num=100)
++    for theta, phi in zip(theta_list, phi_list):
++        # set l and m
++        for l in range(0, 5):
++            for m in range(-l, l + 1):
++                q = qutip.basis(2 * l + 1, l + m)
++                # check that outputs are the same,
++                # note that theta and phi are interchanged for scipy
++                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
++
++
++def test_orbital_multiple_ket():
++    """ Checks if the combination of multiple kets works """
++    theta_list = np.linspace(0, np.pi, num=50)
++    phi_list = np.linspace(0, 2 * np.pi, num=100)
++    l, m = 5, 2
++    q1 = qutip.basis(2 * l + 1, l + m)
++    l, m = 3, -1
++    q2 = qutip.basis(2 * l + 1, l + m)
++    for theta, phi in zip(theta_list, phi_list):
++        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
++        assert orbital(theta, phi, q1, q2) ==  exp
++
++
++def test_orbital_explicit():
++    """ Checks explicit configurations of orbital functions"""
++    theta_list = np.linspace(0, np.pi, num=50)
++    phi_list = np.linspace(0, 2 * np.pi, num=100)
++    # Constant function
++    l, m = 0, 0
++    q = qutip.basis(2 * l + 1, l + m)
++    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
++    # cosine function
++    l, m = 1, 0
++    q = qutip.basis(2 * l + 1, l + m)
++    assert np.allclose(orbital(theta_list, 0, q),
++                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
++    # cosine with phase
++    l, m = 1, 1
++    q = qutip.basis(2 * l + 1, l + m)
++    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
++    assert np.allclose(orbital(theta_list, phi_list, q),
++                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
++                           theta_mesh) * np.exp(1j * phi_mesh))
+diff --git a/qutip/tests/test_partial_transpose.py b/qutip/tests/test_partial_transpose.py
+index 02d3fec3..26dffb3a 100644
+--- a/qutip/tests/test_partial_transpose.py
++++ b/qutip/tests/test_partial_transpose.py
+@@ -1,78 +1,78 @@
+-"""
+-Unit tests for QuTiP partial transpose functions.
+-"""
+-
+-import numpy as np
+-from numpy.testing import assert_, run_module_suite
+-
+-from qutip import Qobj, partial_transpose, tensor, rand_dm
+-from qutip.partial_transpose import _partial_transpose_reference
+-
+-
+-def test_partial_transpose_bipartite():
+-    """partial transpose of bipartite systems"""
+-
+-    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
+-
+-    # no transpose
+-    rho_pt = partial_transpose(rho, [0, 0])
+-    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
+-
+-    # partial transpose subsystem 1
+-    rho_pt = partial_transpose(rho, [1, 0])
+-    rho_pt_expected = np.array([[0, 1,  8,  9],
+-                                [4, 5, 12, 13],
+-                                [2, 3, 10, 11],
+-                                [6, 7, 14, 15]])
+-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+-
+-    # partial transpose subsystem 2
+-    rho_pt = partial_transpose(rho, [0, 1])
+-    rho_pt_expected = np.array([[0, 4, 2, 6],
+-                                [1, 5, 3, 7],
+-                                [8, 12, 10, 14],
+-                                [9, 13, 11, 15]])
+-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+-
+-    # full transpose
+-    rho_pt = partial_transpose(rho, [1, 1])
+-    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
+-
+-
+-def test_partial_transpose_comparison():
+-    """partial transpose: comparing sparse and dense implementations"""
+-
+-    N = 10
+-    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
+-
+-    # partial transpose of system 1
+-    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
+-    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
+-    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
+-
+-    # partial transpose of system 2
+-    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
+-    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
+-    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
+-
+-
+-def test_partial_transpose_randomized():
+-    """partial transpose: randomized tests on tripartite system"""
+-
+-    rho = tensor(rand_dm(2, density=1),
+-                 rand_dm(2, density=1),
+-                 rand_dm(2, density=1))
+-
+-    mask = np.random.randint(2, size=3)
+-
+-    rho_pt_ref = _partial_transpose_reference(rho, mask)
+-
+-    rho_pt1 = partial_transpose(rho, mask, method="dense")
+-    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
+-
+-    rho_pt2 = partial_transpose(rho, mask, method="sparse")
+-    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
+-
+-
+-if __name__ == "__main__":
+-    run_module_suite()
++"""
++Unit tests for QuTiP partial transpose functions.
++"""
++
++import numpy as np
++from numpy.testing import assert_, run_module_suite
++
++from qutip import Qobj, partial_transpose, tensor, rand_dm
++from qutip.partial_transpose import _partial_transpose_reference
++
++
++def test_partial_transpose_bipartite():
++    """partial transpose of bipartite systems"""
++
++    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
++
++    # no transpose
++    rho_pt = partial_transpose(rho, [0, 0])
++    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
++
++    # partial transpose subsystem 1
++    rho_pt = partial_transpose(rho, [1, 0])
++    rho_pt_expected = np.array([[0, 1,  8,  9],
++                                [4, 5, 12, 13],
++                                [2, 3, 10, 11],
++                                [6, 7, 14, 15]])
++    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
++
++    # partial transpose subsystem 2
++    rho_pt = partial_transpose(rho, [0, 1])
++    rho_pt_expected = np.array([[0, 4, 2, 6],
++                                [1, 5, 3, 7],
++                                [8, 12, 10, 14],
++                                [9, 13, 11, 15]])
++    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
++
++    # full transpose
++    rho_pt = partial_transpose(rho, [1, 1])
++    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
++
++
++def test_partial_transpose_comparison():
++    """partial transpose: comparing sparse and dense implementations"""
++
++    N = 10
++    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
++
++    # partial transpose of system 1
++    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
++    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
++    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
++
++    # partial transpose of system 2
++    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
++    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
++    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
++
++
++def test_partial_transpose_randomized():
++    """partial transpose: randomized tests on tripartite system"""
++
++    rho = tensor(rand_dm(2, density=1),
++                 rand_dm(2, density=1),
++                 rand_dm(2, density=1))
++
++    mask = np.random.randint(2, size=3)
++
++    rho_pt_ref = _partial_transpose_reference(rho, mask)
++
++    rho_pt1 = partial_transpose(rho, mask, method="dense")
++    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
++
++    rho_pt2 = partial_transpose(rho, mask, method="sparse")
++    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
++
++
++if __name__ == "__main__":
++    run_module_suite()
+diff --git a/qutip/tests/test_qip.py b/qutip/tests/test_qip.py
+index d0168787..3f34d4f0 100644
+--- a/qutip/tests/test_qip.py
++++ b/qutip/tests/test_qip.py
+@@ -1,46 +1,46 @@
+-import sys
+-
+-import pytest
+-
+-
+-@pytest.fixture
+-def without_qutip_qip(monkeypatch):
+-    monkeypatch.setitem(sys.modules, "qutip_qip", None)
+-    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
+-
+-
+-@pytest.fixture
+-def with_qutip_qip_stub(tmp_path, monkeypatch):
+-    pkg_dir = tmp_path / "qutip_qip"
+-    pkg_dir.mkdir()
+-    init_file = pkg_dir / "__init__.py"
+-    init_file.write_text("__version__ = 'x.y.z'")
+-    circuit_file = pkg_dir / "circuit.py"
+-    circuit_file.write_text("class QubitCircuit:\n    pass")
+-
+-    monkeypatch.syspath_prepend(tmp_path)
+-    # Make sure the stub modules is the one imported
+-    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
+-    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
+-
+-
+-def test_failed_import(without_qutip_qip):
+-    # Ensure 'qutip.qip' is not imported yet
+-    assert "qutip.qip" not in sys.modules
+-    with pytest.raises(
+-        ImportError,
+-        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
+-    ):
+-        import qutip.qip
+-
+-
+-def test_with_qip(with_qutip_qip_stub):
+-    import qutip.qip
+-    import qutip.qip.circuit as circuit
+-    from qutip.qip.circuit import QubitCircuit
+-    import qutip_qip
+-
+-    assert qutip.qip.__version__ == "x.y.z"
+-    assert qutip.qip is qutip_qip
+-    assert circuit is qutip_qip.circuit
+-    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
++import sys
++
++import pytest
++
++
++@pytest.fixture
++def without_qutip_qip(monkeypatch):
++    monkeypatch.setitem(sys.modules, "qutip_qip", None)
++    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
++
++
++@pytest.fixture
++def with_qutip_qip_stub(tmp_path, monkeypatch):
++    pkg_dir = tmp_path / "qutip_qip"
++    pkg_dir.mkdir()
++    init_file = pkg_dir / "__init__.py"
++    init_file.write_text("__version__ = 'x.y.z'")
++    circuit_file = pkg_dir / "circuit.py"
++    circuit_file.write_text("class QubitCircuit:\n    pass")
++
++    monkeypatch.syspath_prepend(tmp_path)
++    # Make sure the stub modules is the one imported
++    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
++    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
++
++
++def test_failed_import(without_qutip_qip):
++    # Ensure 'qutip.qip' is not imported yet
++    assert "qutip.qip" not in sys.modules
++    with pytest.raises(
++        ImportError,
++        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
++    ):
++        import qutip.qip
++
++
++def test_with_qip(with_qutip_qip_stub):
++    import qutip.qip
++    import qutip.qip.circuit as circuit
++    from qutip.qip.circuit import QubitCircuit
++    import qutip_qip
++
++    assert qutip.qip.__version__ == "x.y.z"
++    assert qutip.qip is qutip_qip
++    assert circuit is qutip_qip.circuit
++    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
+diff --git a/qutip/tests/test_qpt.py b/qutip/tests/test_qpt.py
+index c2d092e2..896a8da9 100644
+--- a/qutip/tests/test_qpt.py
++++ b/qutip/tests/test_qpt.py
+@@ -1,50 +1,50 @@
+-import numpy as np
+-from numpy.testing import assert_, run_module_suite
+-import scipy.linalg as la
+-
+-from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
+-from qutip.core.gates import snot, cnot
+-
+-
+-def test_qpt_snot():
+-    "quantum process tomography for snot gate"
+-
+-    U_psi = snot()
+-    U_rho = spre(U_psi) * spost(U_psi.dag())
+-    N = 1
+-    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
+-    # op_label = [["i", "x", "y", "z"] for i in range(N)]
+-    chi1 = qpt(U_rho, op_basis)
+-
+-    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
+-    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
+-
+-    assert_(la.norm(chi2 - chi1) < 1e-8)
+-
+-
+-def test_qpt_cnot():
+-    "quantum process tomography for cnot gate"
+-
+-    U_psi = cnot()
+-    U_rho = spre(U_psi) * spost(U_psi.dag())
+-    N = 2
+-    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
+-    # op_label = [["i", "x", "y", "z"] for i in range(N)]
+-    chi1 = qpt(U_rho, op_basis)
+-
+-    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
+-    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
+-
+-    chi2[12, 0] = chi2[12, 1] = 0.25
+-    chi2[13, 0] = chi2[13, 1] = -0.25
+-
+-    chi2[0, 12] = chi2[1, 12] = 0.25
+-    chi2[0, 13] = chi2[1, 13] = -0.25
+-
+-    chi2[12, 12] = chi2[13, 13] = 0.25
+-    chi2[13, 12] = chi2[12, 13] = -0.25
+-
+-    assert_(la.norm(chi2 - chi1) < 1e-8)
+-
+-if __name__ == "__main__":
+-    run_module_suite()
++import numpy as np
++from numpy.testing import assert_, run_module_suite
++import scipy.linalg as la
++
++from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
++from qutip.core.gates import snot, cnot
++
++
++def test_qpt_snot():
++    "quantum process tomography for snot gate"
++
++    U_psi = snot()
++    U_rho = spre(U_psi) * spost(U_psi.dag())
++    N = 1
++    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
++    # op_label = [["i", "x", "y", "z"] for i in range(N)]
++    chi1 = qpt(U_rho, op_basis)
++
++    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
++    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
++
++    assert_(la.norm(chi2 - chi1) < 1e-8)
++
++
++def test_qpt_cnot():
++    "quantum process tomography for cnot gate"
++
++    U_psi = cnot()
++    U_rho = spre(U_psi) * spost(U_psi.dag())
++    N = 2
++    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
++    # op_label = [["i", "x", "y", "z"] for i in range(N)]
++    chi1 = qpt(U_rho, op_basis)
++
++    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
++    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
++
++    chi2[12, 0] = chi2[12, 1] = 0.25
++    chi2[13, 0] = chi2[13, 1] = -0.25
++
++    chi2[0, 12] = chi2[1, 12] = 0.25
++    chi2[0, 13] = chi2[1, 13] = -0.25
++
++    chi2[12, 12] = chi2[13, 13] = 0.25
++    chi2[13, 12] = chi2[12, 13] = -0.25
++
++    assert_(la.norm(chi2 - chi1) < 1e-8)
++
++if __name__ == "__main__":
++    run_module_suite()
+diff --git a/qutip/tests/test_random.py b/qutip/tests/test_random.py
+index 13f9554b..8b700296 100644
+--- a/qutip/tests/test_random.py
++++ b/qutip/tests/test_random.py
+@@ -1,311 +1,311 @@
+-import numpy as np
+-from numpy.random import SeedSequence, default_rng
+-import scipy.sparse as sp
+-import scipy.linalg as la
+-import pytest
+-
+-from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
+-from qutip import data as _data
+-from qutip.random_objects import (
+-    rand_herm,
+-    rand_unitary,
+-    rand_dm,
+-    rand_ket,
+-    rand_stochastic,
+-    rand_super,
+-    rand_super_bcsz,
+-    rand_kraus_map,
+-)
+-
+-
+-@pytest.fixture(params=[
+-    12,
+-    [8],
+-    [2, 2, 3],
+-    [[2], [2]]
+-], ids=["int", "list", "tensor", "super"])
+-def dimensions(request):
+-    return request.param
+-
+-
+-@pytest.fixture(
+-    params=list(_data.to.dtypes),
+-    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
+-)
+-def dtype(request):
+-    return request.param
+-
+-
+-def _assert_density(qobj, density):
+-    N = np.sum(qobj.full() != 0)
+-    density = N / np.prod(qobj.shape)
+-    assert density == pytest.approx(density, abs=0.2)
+-
+-
+-def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
+-    if isinstance(dims, int):
+-        dims = [dims]
+-    N = np.prod(dims)
+-    if super and not isinstance(dims[0], list):
+-        target_dims_0 = [dims, dims]
+-        shape0 = N**2
+-    else:
+-        target_dims_0 = dims
+-        shape0 = N
+-
+-    if ket:
+-        target_dims_1 = [1]
+-        shape1 = 1
+-    else:
+-        target_dims_1 = target_dims_0
+-        shape1 = shape0
+-
+-    assert random_qobj.dims[0] == target_dims_0
+-    assert random_qobj.dims[1] == target_dims_1
+-    assert random_qobj.shape == (shape0, shape1)
+-
+-    if dtype:
+-        assert isinstance(random_qobj.data, dtype)
+-
+-
+-@pytest.mark.repeat(3)
+-@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
+-@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
+-def test_rand_herm(dimensions, density, distribution, dtype):
+-    """
+-    Random Qobjs: Hermitian matrix
+-    """
+-    random_qobj = rand_herm(
+-        dimensions,
+-        density=density,
+-        distribution=distribution,
+-        dtype=dtype
+-    )
+-    if distribution == "pos_def":
+-        assert all(random_qobj.eigenenergies() > -1e14)
+-    assert random_qobj.isherm
+-    assert _data.isherm(random_qobj.data)
+-    _assert_metadata(random_qobj, dimensions, dtype)
+-    _assert_density(random_qobj, density)
+-
+-
+-@pytest.mark.repeat(3)
+-@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
+-def test_rand_herm_Eigs(dimensions, density):
+-    """
+-    Random Qobjs: Hermitian matrix - Eigs given
+-    """
+-    N = np.prod(dimensions)
+-    eigs = np.random.random(N)
+-    eigs /= np.sum(eigs)
+-    eigs.sort()
+-    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
+-    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
+-    # verify hermitian
+-    assert random_qobj.isherm
+-    assert _data.isherm(random_qobj.data)
+-    _assert_metadata(random_qobj, dimensions)
+-    _assert_density(random_qobj, density)
+-
+-
+-@pytest.mark.repeat(5)
+-@pytest.mark.parametrize('distribution', ["haar", "exp"])
+-@pytest.mark.parametrize('density', [0.2, 0.8])
+-def test_rand_unitary(dimensions, distribution, density, dtype):
+-    """
+-    Random Qobjs: Tests that unitaries are actually unitary.
+-    """
+-    N = np.prod(dimensions)
+-    random_qobj = rand_unitary(
+-        dimensions, distribution=distribution,
+-        density=density, dtype=dtype
+-    )
+-    I = qeye(dimensions)
+-    assert random_qobj * random_qobj.dag() == I
+-    _assert_metadata(random_qobj, dimensions, dtype)
+-    if distribution == "exp":
+-        _assert_density(random_qobj, density)
+-
+-
+-@pytest.mark.repeat(3)
+-@pytest.mark.parametrize(["distribution", "kw"], [
+-    pytest.param("ginibre", {"rank": 3}),
+-    pytest.param("ginibre", {"rank": 1}),
+-    pytest.param("hs", {"rank": 0}),
+-    pytest.param("pure", {"rank": 1, "density": 0.5}),
+-    pytest.param("eigen", {"eigenvalues": True}),
+-    pytest.param("herm", {"density": 0.7}),
+-    pytest.param("herm", {"density": 0.3}),
+-])
+-def test_rand_dm(dimensions, kw, dtype, distribution):
+-    """
+-    Random Qobjs: Density matrix
+-    """
+-    N = np.prod(dimensions)
+-    print(N, kw)
+-    if "eigenvalues" in kw:
+-        eigs = np.random.random(N)
+-        eigs /= np.sum(eigs)
+-        eigs.sort()
+-        kw["eigenvalues"] = eigs
+-
+-    random_qobj = rand_dm(
+-        dimensions,
+-        distribution=distribution,
+-        dtype=dtype,
+-        **kw
+-    )
+-    assert abs(random_qobj.tr() - 1.0) < 1e-14
+-    # verify all eigvals are >=0
+-    assert all(random_qobj.eigenenergies() >= -1e-14)
+-    # verify hermitian
+-    assert random_qobj.isherm
+-    assert _data.isherm(random_qobj.data)
+-
+-    _assert_metadata(random_qobj, dimensions, dtype)
+-
+-    eigenvalues = random_qobj.eigenenergies()
+-
+-    if "rank" in kw:
+-        print(kw["rank"], N, kw["rank"] or N)
+-        desired_rank = kw["rank"] or N  # 'hs' is full rank.
+-        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
+-        assert rank == desired_rank
+-
+-    if "eigenvalues" in kw:
+-        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
+-
+-    if "density" in kw:
+-        _assert_density(random_qobj, kw["density"])
+-
+-
+-@pytest.mark.repeat(5)
+-@pytest.mark.parametrize('kind', ["left", "right"])
+-def test_rand_stochastic(dimensions, kind, dtype):
+-    """
+-    Random Qobjs: Test random stochastic
+-    """
+-    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
+-    axis = {"left":0, "right":1}[kind]
+-    np.testing.assert_allclose(
+-        np.sum(random_qobj.full(), axis=axis),
+-        1, atol=1e-14
+-    )
+-    _assert_metadata(random_qobj, dimensions, dtype)
+-
+-
+-@pytest.mark.repeat(5)
+-@pytest.mark.parametrize('distribution', ["haar", "fill"])
+-def test_rand_ket(dimensions, distribution, dtype):
+-    """
+-    Random Qobjs: Test random ket type and norm.
+-    """
+-    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
+-
+-    assert random_qobj.type == 'ket'
+-    assert abs(random_qobj.norm() - 1) < 1e-14
+-
+-    if isinstance(dimensions, int):
+-        dims = [dimensions]
+-    N = np.prod(dimensions)
+-    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
+-
+-
+-@pytest.mark.repeat(2)
+-@pytest.mark.parametrize('superrep', ["choi", "super"])
+-def test_rand_super(dimensions, dtype, superrep):
+-    """
+-    Random Qobjs: Super operator.
+-    """
+-    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
+-    assert random_qobj.issuper
+-    with CoreOptions(atol=1e-9):
+-        assert random_qobj.iscptp
+-    assert random_qobj.superrep == superrep
+-    _assert_metadata(random_qobj, dimensions, dtype, super=True)
+-
+-
+-@pytest.mark.repeat(2)
+-@pytest.mark.parametrize('rank', [None, 4])
+-@pytest.mark.parametrize('superrep', ["choi", "super"])
+-def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
+-    """
+-    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
+-    """
+-
+-    random_qobj = rand_super_bcsz(dimensions, rank=rank,
+-                                  dtype=dtype, superrep=superrep)
+-    assert random_qobj.issuper
+-    with CoreOptions(atol=1e-9):
+-        assert random_qobj.iscptp
+-    assert random_qobj.superrep == superrep
+-    _assert_metadata(random_qobj, dimensions, dtype, super=True)
+-    if (
+-        not rank
+-        and isinstance(dimensions, list)
+-        and isinstance(dimensions[0], list)
+-    ):
+-        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
+-        rank = np.prod(dimensions)
+-    elif not rank:
+-        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
+-        rank = np.prod(dimensions)**2
+-    rank = rank or N
+-    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
+-    assert obtained_rank == rank
+-
+-
+-@pytest.mark.parametrize("function", [
+-    pytest.param(rand_herm, id="rand_herm"),
+-    pytest.param(rand_unitary, id="rand_unitary"),
+-    pytest.param(rand_dm, id="rand_dm"),
+-    pytest.param(rand_ket, id="rand_ket"),
+-    pytest.param(rand_stochastic, id="rand_stochastic"),
+-    pytest.param(rand_super, id="rand_super"),
+-    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
+-])
+-@pytest.mark.parametrize("seed", [
+-    pytest.param(lambda : 123, id="int"),
+-    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
+-    pytest.param(lambda : default_rng(123), id="Generator")
+-])
+-def test_random_seeds(function, seed):
+-    """
+-    Random Qobjs: Random number generator seed
+-    """
+-    U0 = function(5, seed=seed())
+-    U1 = function(5, seed=None)
+-    U2 = function(5, seed=seed())
+-    assert U0 != U1
+-    assert U0 == U2
+-
+-
+-def test_kraus_map(dimensions, dtype):
+-    kmap = rand_kraus_map(dimensions, dtype=dtype)
+-    _assert_metadata(kmap[0], dimensions, dtype)
+-    with CoreOptions(atol=1e-9):
+-        assert kraus_to_choi(kmap).iscptp
+-
+-
+-dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
+-dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
+-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+-                         ids=[str(dtype) for dtype in dtype_names])
+-@pytest.mark.parametrize('func', [
+-    rand_herm,
+-    rand_unitary,
+-    rand_dm,
+-    rand_ket,
+-    rand_stochastic,
+-    rand_super,
+-    rand_super_bcsz,
+-    rand_kraus_map,
+-])
+-def test_random_dtype(func, alias, dtype):
+-    with CoreOptions(default_dtype=alias):
+-        object = func(2)
+-        if isinstance(object, Qobj):
+-            assert isinstance(object.data, dtype)
+-        else:
+-            for obj in object:
+-                assert isinstance(obj.data, dtype)
++import numpy as np
++from numpy.random import SeedSequence, default_rng
++import scipy.sparse as sp
++import scipy.linalg as la
++import pytest
++
++from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
++from qutip import data as _data
++from qutip.random_objects import (
++    rand_herm,
++    rand_unitary,
++    rand_dm,
++    rand_ket,
++    rand_stochastic,
++    rand_super,
++    rand_super_bcsz,
++    rand_kraus_map,
++)
++
++
++@pytest.fixture(params=[
++    12,
++    [8],
++    [2, 2, 3],
++    [[2], [2]]
++], ids=["int", "list", "tensor", "super"])
++def dimensions(request):
++    return request.param
++
++
++@pytest.fixture(
++    params=list(_data.to.dtypes),
++    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
++)
++def dtype(request):
++    return request.param
++
++
++def _assert_density(qobj, density):
++    N = np.sum(qobj.full() != 0)
++    density = N / np.prod(qobj.shape)
++    assert density == pytest.approx(density, abs=0.2)
++
++
++def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
++    if isinstance(dims, int):
++        dims = [dims]
++    N = np.prod(dims)
++    if super and not isinstance(dims[0], list):
++        target_dims_0 = [dims, dims]
++        shape0 = N**2
++    else:
++        target_dims_0 = dims
++        shape0 = N
++
++    if ket:
++        target_dims_1 = [1]
++        shape1 = 1
++    else:
++        target_dims_1 = target_dims_0
++        shape1 = shape0
++
++    assert random_qobj.dims[0] == target_dims_0
++    assert random_qobj.dims[1] == target_dims_1
++    assert random_qobj.shape == (shape0, shape1)
++
++    if dtype:
++        assert isinstance(random_qobj.data, dtype)
++
++
++@pytest.mark.repeat(3)
++@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
++@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
++def test_rand_herm(dimensions, density, distribution, dtype):
++    """
++    Random Qobjs: Hermitian matrix
++    """
++    random_qobj = rand_herm(
++        dimensions,
++        density=density,
++        distribution=distribution,
++        dtype=dtype
++    )
++    if distribution == "pos_def":
++        assert all(random_qobj.eigenenergies() > -1e14)
++    assert random_qobj.isherm
++    assert _data.isherm(random_qobj.data)
++    _assert_metadata(random_qobj, dimensions, dtype)
++    _assert_density(random_qobj, density)
++
++
++@pytest.mark.repeat(3)
++@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
++def test_rand_herm_Eigs(dimensions, density):
++    """
++    Random Qobjs: Hermitian matrix - Eigs given
++    """
++    N = np.prod(dimensions)
++    eigs = np.random.random(N)
++    eigs /= np.sum(eigs)
++    eigs.sort()
++    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
++    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
++    # verify hermitian
++    assert random_qobj.isherm
++    assert _data.isherm(random_qobj.data)
++    _assert_metadata(random_qobj, dimensions)
++    _assert_density(random_qobj, density)
++
++
++@pytest.mark.repeat(5)
++@pytest.mark.parametrize('distribution', ["haar", "exp"])
++@pytest.mark.parametrize('density', [0.2, 0.8])
++def test_rand_unitary(dimensions, distribution, density, dtype):
++    """
++    Random Qobjs: Tests that unitaries are actually unitary.
++    """
++    N = np.prod(dimensions)
++    random_qobj = rand_unitary(
++        dimensions, distribution=distribution,
++        density=density, dtype=dtype
++    )
++    I = qeye(dimensions)
++    assert random_qobj * random_qobj.dag() == I
++    _assert_metadata(random_qobj, dimensions, dtype)
++    if distribution == "exp":
++        _assert_density(random_qobj, density)
++
++
++@pytest.mark.repeat(3)
++@pytest.mark.parametrize(["distribution", "kw"], [
++    pytest.param("ginibre", {"rank": 3}),
++    pytest.param("ginibre", {"rank": 1}),
++    pytest.param("hs", {"rank": 0}),
++    pytest.param("pure", {"rank": 1, "density": 0.5}),
++    pytest.param("eigen", {"eigenvalues": True}),
++    pytest.param("herm", {"density": 0.7}),
++    pytest.param("herm", {"density": 0.3}),
++])
++def test_rand_dm(dimensions, kw, dtype, distribution):
++    """
++    Random Qobjs: Density matrix
++    """
++    N = np.prod(dimensions)
++    print(N, kw)
++    if "eigenvalues" in kw:
++        eigs = np.random.random(N)
++        eigs /= np.sum(eigs)
++        eigs.sort()
++        kw["eigenvalues"] = eigs
++
++    random_qobj = rand_dm(
++        dimensions,
++        distribution=distribution,
++        dtype=dtype,
++        **kw
++    )
++    assert abs(random_qobj.tr() - 1.0) < 1e-14
++    # verify all eigvals are >=0
++    assert all(random_qobj.eigenenergies() >= -1e-14)
++    # verify hermitian
++    assert random_qobj.isherm
++    assert _data.isherm(random_qobj.data)
++
++    _assert_metadata(random_qobj, dimensions, dtype)
++
++    eigenvalues = random_qobj.eigenenergies()
++
++    if "rank" in kw:
++        print(kw["rank"], N, kw["rank"] or N)
++        desired_rank = kw["rank"] or N  # 'hs' is full rank.
++        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
++        assert rank == desired_rank
++
++    if "eigenvalues" in kw:
++        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
++
++    if "density" in kw:
++        _assert_density(random_qobj, kw["density"])
++
++
++@pytest.mark.repeat(5)
++@pytest.mark.parametrize('kind', ["left", "right"])
++def test_rand_stochastic(dimensions, kind, dtype):
++    """
++    Random Qobjs: Test random stochastic
++    """
++    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
++    axis = {"left":0, "right":1}[kind]
++    np.testing.assert_allclose(
++        np.sum(random_qobj.full(), axis=axis),
++        1, atol=1e-14
++    )
++    _assert_metadata(random_qobj, dimensions, dtype)
++
++
++@pytest.mark.repeat(5)
++@pytest.mark.parametrize('distribution', ["haar", "fill"])
++def test_rand_ket(dimensions, distribution, dtype):
++    """
++    Random Qobjs: Test random ket type and norm.
++    """
++    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
++
++    assert random_qobj.type == 'ket'
++    assert abs(random_qobj.norm() - 1) < 1e-14
++
++    if isinstance(dimensions, int):
++        dims = [dimensions]
++    N = np.prod(dimensions)
++    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
++
++
++@pytest.mark.repeat(2)
++@pytest.mark.parametrize('superrep', ["choi", "super"])
++def test_rand_super(dimensions, dtype, superrep):
++    """
++    Random Qobjs: Super operator.
++    """
++    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
++    assert random_qobj.issuper
++    with CoreOptions(atol=1e-9):
++        assert random_qobj.iscptp
++    assert random_qobj.superrep == superrep
++    _assert_metadata(random_qobj, dimensions, dtype, super=True)
++
++
++@pytest.mark.repeat(2)
++@pytest.mark.parametrize('rank', [None, 4])
++@pytest.mark.parametrize('superrep', ["choi", "super"])
++def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
++    """
++    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
++    """
++
++    random_qobj = rand_super_bcsz(dimensions, rank=rank,
++                                  dtype=dtype, superrep=superrep)
++    assert random_qobj.issuper
++    with CoreOptions(atol=1e-9):
++        assert random_qobj.iscptp
++    assert random_qobj.superrep == superrep
++    _assert_metadata(random_qobj, dimensions, dtype, super=True)
++    if (
++        not rank
++        and isinstance(dimensions, list)
++        and isinstance(dimensions[0], list)
++    ):
++        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
++        rank = np.prod(dimensions)
++    elif not rank:
++        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
++        rank = np.prod(dimensions)**2
++    rank = rank or N
++    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
++    assert obtained_rank == rank
++
++
++@pytest.mark.parametrize("function", [
++    pytest.param(rand_herm, id="rand_herm"),
++    pytest.param(rand_unitary, id="rand_unitary"),
++    pytest.param(rand_dm, id="rand_dm"),
++    pytest.param(rand_ket, id="rand_ket"),
++    pytest.param(rand_stochastic, id="rand_stochastic"),
++    pytest.param(rand_super, id="rand_super"),
++    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
++])
++@pytest.mark.parametrize("seed", [
++    pytest.param(lambda : 123, id="int"),
++    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
++    pytest.param(lambda : default_rng(123), id="Generator")
++])
++def test_random_seeds(function, seed):
++    """
++    Random Qobjs: Random number generator seed
++    """
++    U0 = function(5, seed=seed())
++    U1 = function(5, seed=None)
++    U2 = function(5, seed=seed())
++    assert U0 != U1
++    assert U0 == U2
++
++
++def test_kraus_map(dimensions, dtype):
++    kmap = rand_kraus_map(dimensions, dtype=dtype)
++    _assert_metadata(kmap[0], dimensions, dtype)
++    with CoreOptions(atol=1e-9):
++        assert kraus_to_choi(kmap).iscptp
++
++
++dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
++dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
++@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
++                         ids=[str(dtype) for dtype in dtype_names])
++@pytest.mark.parametrize('func', [
++    rand_herm,
++    rand_unitary,
++    rand_dm,
++    rand_ket,
++    rand_stochastic,
++    rand_super,
++    rand_super_bcsz,
++    rand_kraus_map,
++])
++def test_random_dtype(func, alias, dtype):
++    with CoreOptions(default_dtype=alias):
++        object = func(2)
++        if isinstance(object, Qobj):
++            assert isinstance(object.data, dtype)
++        else:
++            for obj in object:
++                assert isinstance(obj.data, dtype)
+diff --git a/qutip/tests/test_simdiag.py b/qutip/tests/test_simdiag.py
+index a45076fd..b388ad33 100644
+--- a/qutip/tests/test_simdiag.py
++++ b/qutip/tests/test_simdiag.py
+@@ -1,92 +1,92 @@
+-import pytest
+-import numpy as np
+-import qutip
+-
+-
+-@pytest.mark.flaky(reruns=2)
+-@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
+-def test_simdiag(num_mat):
+-    N = 10
+-
+-    U = qutip.rand_unitary(N)
+-    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
+-                          for _ in range(num_mat)]
+-    all_evals, evecs = qutip.simdiag(commuting_matrices)
+-
+-    for matrix, evals in zip(commuting_matrices, all_evals):
+-        for eval, evec in zip(evals, evecs):
+-            assert matrix * evec == evec * eval
+-
+-
+-@pytest.mark.flaky(reruns=2)
+-@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
+-def test_simdiag_no_evals(num_mat):
+-    N = 10
+-
+-    U = qutip.rand_unitary(N)
+-    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
+-                          for _ in range(num_mat)]
+-    evecs = qutip.simdiag(commuting_matrices, evals=False)
+-
+-    for matrix in commuting_matrices:
+-        for evec in evecs:
+-            Mvec = matrix * evec
+-            eval = Mvec.norm() / evec.norm()
+-            assert matrix * evec == evec * eval
+-
+-
+-@pytest.mark.flaky(reruns=2)
+-def test_simdiag_degen():
+-    N = 10
+-    U = qutip.rand_unitary(N)
+-    commuting_matrices = [
+-        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
+-        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
+-        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
+-    ]
+-    all_evals, evecs = qutip.simdiag(commuting_matrices)
+-
+-    for matrix, evals in zip(commuting_matrices, all_evals):
+-        for eval, evec in zip(evals, evecs):
+-            np.testing.assert_allclose(
+-                (matrix * evec).full(),
+-                (evec * eval).full(),
+-                atol=3e-14
+-            )
+-
+-@pytest.mark.flaky(reruns=2)
+-@pytest.mark.repeat(2)
+-def test_simdiag_degen_large():
+-    N = 20
+-    U = qutip.rand_unitary(N)
+-    commuting_matrices = [
+-        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
+-        for _ in range(5)
+-    ]
+-    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
+-
+-    for matrix, evals in zip(commuting_matrices, all_evals):
+-        for eval, evec in zip(evals, evecs):
+-            np.testing.assert_allclose(
+-                (matrix * evec).full(),
+-                (evec * eval).full(),
+-                atol=1e-13
+-            )
+-
+-
+-def test_simdiag_no_input():
+-    with pytest.raises(ValueError):
+-        qutip.simdiag([])
+-
+-
+-@pytest.mark.parametrize(['ops', 'error'], [
+-    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
+-    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
+-    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
+-    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
+-                 id="Not commuting"),
+-])
+-def test_simdiag_errors(ops, error):
+-    with pytest.raises(TypeError) as err:
+-        qutip.simdiag(ops)
+-    assert error in str(err.value)
++import pytest
++import numpy as np
++import qutip
++
++
++@pytest.mark.flaky(reruns=2)
++@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
++def test_simdiag(num_mat):
++    N = 10
++
++    U = qutip.rand_unitary(N)
++    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
++                          for _ in range(num_mat)]
++    all_evals, evecs = qutip.simdiag(commuting_matrices)
++
++    for matrix, evals in zip(commuting_matrices, all_evals):
++        for eval, evec in zip(evals, evecs):
++            assert matrix * evec == evec * eval
++
++
++@pytest.mark.flaky(reruns=2)
++@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
++def test_simdiag_no_evals(num_mat):
++    N = 10
++
++    U = qutip.rand_unitary(N)
++    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
++                          for _ in range(num_mat)]
++    evecs = qutip.simdiag(commuting_matrices, evals=False)
++
++    for matrix in commuting_matrices:
++        for evec in evecs:
++            Mvec = matrix * evec
++            eval = Mvec.norm() / evec.norm()
++            assert matrix * evec == evec * eval
++
++
++@pytest.mark.flaky(reruns=2)
++def test_simdiag_degen():
++    N = 10
++    U = qutip.rand_unitary(N)
++    commuting_matrices = [
++        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
++        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
++        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
++    ]
++    all_evals, evecs = qutip.simdiag(commuting_matrices)
++
++    for matrix, evals in zip(commuting_matrices, all_evals):
++        for eval, evec in zip(evals, evecs):
++            np.testing.assert_allclose(
++                (matrix * evec).full(),
++                (evec * eval).full(),
++                atol=3e-14
++            )
++
++@pytest.mark.flaky(reruns=2)
++@pytest.mark.repeat(2)
++def test_simdiag_degen_large():
++    N = 20
++    U = qutip.rand_unitary(N)
++    commuting_matrices = [
++        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
++        for _ in range(5)
++    ]
++    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
++
++    for matrix, evals in zip(commuting_matrices, all_evals):
++        for eval, evec in zip(evals, evecs):
++            np.testing.assert_allclose(
++                (matrix * evec).full(),
++                (evec * eval).full(),
++                atol=1e-13
++            )
++
++
++def test_simdiag_no_input():
++    with pytest.raises(ValueError):
++        qutip.simdiag([])
++
++
++@pytest.mark.parametrize(['ops', 'error'], [
++    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
++    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
++    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
++    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
++                 id="Not commuting"),
++])
++def test_simdiag_errors(ops, error):
++    with pytest.raises(TypeError) as err:
++        qutip.simdiag(ops)
++    assert error in str(err.value)
+diff --git a/qutip/tests/test_subsys_apply.py b/qutip/tests/test_subsys_apply.py
+index ed854666..0c73ff12 100644
+--- a/qutip/tests/test_subsys_apply.py
++++ b/qutip/tests/test_subsys_apply.py
+@@ -1,141 +1,141 @@
+-from numpy.linalg import norm
+-from numpy.testing import assert_, run_module_suite
+-
+-from qutip import (
+-    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
+-    subsystem_apply, rand_dm, rand_unitary,
+-)
+-from qutip.random_objects import rand_kraus_map
+-
+-
+-class TestSubsysApply(object):
+-    """
+-    A test class for the QuTiP function for applying superoperators to
+-    subsystems.
+-    The four tests below determine whether efficient numerics, naive numerics
+-    and semi-analytic results are identical.
+-    """
+-
+-    def test_SimpleSingleApply(self):
+-        """
+-        Non-composite system, operator on Hilbert space.
+-        """
+-        tol = 1e-12
+-        rho_3 = rand_dm(3)
+-        single_op = rand_unitary(3)
+-        analytic_result = single_op * rho_3 * single_op.dag()
+-        naive_result = subsystem_apply(rho_3, single_op, [True],
+-                                       reference=True)
+-        naive_diff = (analytic_result - naive_result).full()
+-        naive_diff_norm = norm(naive_diff)
+-        assert_(naive_diff_norm < tol,
+-                msg="SimpleSingle: naive_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        naive_diff_norm, tol))
+-
+-        efficient_result = subsystem_apply(rho_3, single_op, [True])
+-        efficient_diff = (efficient_result - analytic_result).full()
+-        efficient_diff_norm = norm(efficient_diff)
+-        assert_(efficient_diff_norm < tol,
+-                msg="SimpleSingle: efficient_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        efficient_diff_norm, tol))
+-
+-    def test_SimpleSuperApply(self):
+-        """
+-        Non-composite system, operator on Liouville space.
+-        """
+-        tol = 1e-12
+-        rho_3 = rand_dm(3)
+-        superop = kraus_to_super(rand_kraus_map(3))
+-        analytic_result = vector_to_operator(superop @
+-                                             operator_to_vector(rho_3))
+-        naive_result = subsystem_apply(rho_3, superop, [True],
+-                                       reference=True)
+-        naive_diff = (analytic_result - naive_result).full()
+-        naive_diff_norm = norm(naive_diff)
+-        assert_(naive_diff_norm < tol,
+-                msg="SimpleSuper: naive_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        naive_diff_norm, tol))
+-
+-        efficient_result = subsystem_apply(rho_3, superop, [True])
+-        efficient_diff = (efficient_result - analytic_result).full()
+-        efficient_diff_norm = norm(efficient_diff)
+-        assert_(efficient_diff_norm < tol,
+-                msg="SimpleSuper: efficient_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        efficient_diff_norm, tol))
+-
+-    def test_ComplexSingleApply(self):
+-        """
+-        Composite system, operator on Hilbert space.
+-        """
+-        tol = 1e-12
+-        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
+-        rho_input = tensor(rho_list)
+-        single_op = rand_unitary(3)
+-
+-        analytic_result = rho_list
+-        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
+-        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
+-        analytic_result = tensor(analytic_result)
+-
+-        naive_result = subsystem_apply(rho_input, single_op,
+-                                       [False, True, False, True, False],
+-                                       reference=True)
+-        naive_diff = (analytic_result - naive_result).full()
+-        naive_diff_norm = norm(naive_diff)
+-        assert_(naive_diff_norm < tol,
+-                msg="ComplexSingle: naive_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        naive_diff_norm, tol))
+-
+-        efficient_result = subsystem_apply(rho_input, single_op,
+-                                           [False, True, False, True, False])
+-        efficient_diff = (efficient_result - analytic_result).full()
+-        efficient_diff_norm = norm(efficient_diff)
+-        assert_(efficient_diff_norm < tol,
+-                msg="ComplexSingle: efficient_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        efficient_diff_norm, tol))
+-
+-    def test_ComplexSuperApply(self):
+-        """
+-        Superoperator: Efficient numerics and reference return same result,
+-        acting on non-composite system
+-        """
+-        tol = 1e-10
+-        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
+-        rho_input = tensor(rho_list)
+-        superop = kraus_to_super(rand_kraus_map(3))
+-
+-        analytic_result = rho_list
+-        analytic_result[1] = Qobj(
+-            vector_to_operator(
+-                superop @ operator_to_vector(analytic_result[1])
+-            ))
+-        analytic_result[3] = Qobj(
+-            vector_to_operator(
+-                superop @ operator_to_vector(analytic_result[3])
+-            ))
+-        analytic_result = tensor(analytic_result)
+-
+-        naive_result = subsystem_apply(rho_input, superop,
+-                                       [False, True, False, True, False],
+-                                       reference=True)
+-        naive_diff = (analytic_result - naive_result).full()
+-        naive_diff_norm = norm(naive_diff)
+-        assert_(naive_diff_norm < tol,
+-                msg="ComplexSuper: naive_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        naive_diff_norm, tol))
+-
+-        efficient_result = subsystem_apply(rho_input, superop,
+-                                           [False, True, False, True, False])
+-        efficient_diff = (efficient_result - analytic_result).full()
+-        efficient_diff_norm = norm(efficient_diff)
+-        assert_(efficient_diff_norm < tol,
+-                msg="ComplexSuper: efficient_diff_norm {} "
+-                    "is beyond tolerance {}".format(
+-                        efficient_diff_norm, tol))
++from numpy.linalg import norm
++from numpy.testing import assert_, run_module_suite
++
++from qutip import (
++    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
++    subsystem_apply, rand_dm, rand_unitary,
++)
++from qutip.random_objects import rand_kraus_map
++
++
++class TestSubsysApply(object):
++    """
++    A test class for the QuTiP function for applying superoperators to
++    subsystems.
++    The four tests below determine whether efficient numerics, naive numerics
++    and semi-analytic results are identical.
++    """
++
++    def test_SimpleSingleApply(self):
++        """
++        Non-composite system, operator on Hilbert space.
++        """
++        tol = 1e-12
++        rho_3 = rand_dm(3)
++        single_op = rand_unitary(3)
++        analytic_result = single_op * rho_3 * single_op.dag()
++        naive_result = subsystem_apply(rho_3, single_op, [True],
++                                       reference=True)
++        naive_diff = (analytic_result - naive_result).full()
++        naive_diff_norm = norm(naive_diff)
++        assert_(naive_diff_norm < tol,
++                msg="SimpleSingle: naive_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        naive_diff_norm, tol))
++
++        efficient_result = subsystem_apply(rho_3, single_op, [True])
++        efficient_diff = (efficient_result - analytic_result).full()
++        efficient_diff_norm = norm(efficient_diff)
++        assert_(efficient_diff_norm < tol,
++                msg="SimpleSingle: efficient_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        efficient_diff_norm, tol))
++
++    def test_SimpleSuperApply(self):
++        """
++        Non-composite system, operator on Liouville space.
++        """
++        tol = 1e-12
++        rho_3 = rand_dm(3)
++        superop = kraus_to_super(rand_kraus_map(3))
++        analytic_result = vector_to_operator(superop @
++                                             operator_to_vector(rho_3))
++        naive_result = subsystem_apply(rho_3, superop, [True],
++                                       reference=True)
++        naive_diff = (analytic_result - naive_result).full()
++        naive_diff_norm = norm(naive_diff)
++        assert_(naive_diff_norm < tol,
++                msg="SimpleSuper: naive_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        naive_diff_norm, tol))
++
++        efficient_result = subsystem_apply(rho_3, superop, [True])
++        efficient_diff = (efficient_result - analytic_result).full()
++        efficient_diff_norm = norm(efficient_diff)
++        assert_(efficient_diff_norm < tol,
++                msg="SimpleSuper: efficient_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        efficient_diff_norm, tol))
++
++    def test_ComplexSingleApply(self):
++        """
++        Composite system, operator on Hilbert space.
++        """
++        tol = 1e-12
++        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
++        rho_input = tensor(rho_list)
++        single_op = rand_unitary(3)
++
++        analytic_result = rho_list
++        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
++        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
++        analytic_result = tensor(analytic_result)
++
++        naive_result = subsystem_apply(rho_input, single_op,
++                                       [False, True, False, True, False],
++                                       reference=True)
++        naive_diff = (analytic_result - naive_result).full()
++        naive_diff_norm = norm(naive_diff)
++        assert_(naive_diff_norm < tol,
++                msg="ComplexSingle: naive_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        naive_diff_norm, tol))
++
++        efficient_result = subsystem_apply(rho_input, single_op,
++                                           [False, True, False, True, False])
++        efficient_diff = (efficient_result - analytic_result).full()
++        efficient_diff_norm = norm(efficient_diff)
++        assert_(efficient_diff_norm < tol,
++                msg="ComplexSingle: efficient_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        efficient_diff_norm, tol))
++
++    def test_ComplexSuperApply(self):
++        """
++        Superoperator: Efficient numerics and reference return same result,
++        acting on non-composite system
++        """
++        tol = 1e-10
++        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
++        rho_input = tensor(rho_list)
++        superop = kraus_to_super(rand_kraus_map(3))
++
++        analytic_result = rho_list
++        analytic_result[1] = Qobj(
++            vector_to_operator(
++                superop @ operator_to_vector(analytic_result[1])
++            ))
++        analytic_result[3] = Qobj(
++            vector_to_operator(
++                superop @ operator_to_vector(analytic_result[3])
++            ))
++        analytic_result = tensor(analytic_result)
++
++        naive_result = subsystem_apply(rho_input, superop,
++                                       [False, True, False, True, False],
++                                       reference=True)
++        naive_diff = (analytic_result - naive_result).full()
++        naive_diff_norm = norm(naive_diff)
++        assert_(naive_diff_norm < tol,
++                msg="ComplexSuper: naive_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        naive_diff_norm, tol))
++
++        efficient_result = subsystem_apply(rho_input, superop,
++                                           [False, True, False, True, False])
++        efficient_diff = (efficient_result - analytic_result).full()
++        efficient_diff_norm = norm(efficient_diff)
++        assert_(efficient_diff_norm < tol,
++                msg="ComplexSuper: efficient_diff_norm {} "
++                    "is beyond tolerance {}".format(
++                        efficient_diff_norm, tol))
+diff --git a/qutip/tests/test_three_level.py b/qutip/tests/test_three_level.py
+index 6aee63c0..372605d7 100644
+--- a/qutip/tests/test_three_level.py
++++ b/qutip/tests/test_three_level.py
+@@ -1,27 +1,27 @@
+-import numpy as np
+-from numpy.testing import assert_, assert_equal, run_module_suite
+-from qutip import basis
+-from qutip.three_level_atom import *
+-
+-
+-three_states = three_level_basis()
+-three_check = np.empty((3,), dtype=object)
+-three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
+-three_ops = three_level_ops()
+-
+-
+-def testThreeStates():
+-    "Three-level atom: States"
+-    assert_equal(np.all(three_states == three_check), True)
+-
+-
+-def testThreeOps():
+-    "Three-level atom: Operators"
+-    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
+-    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
+-    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
+-    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
+-    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
+-
+-if __name__ == "__main__":
+-    run_module_suite()
++import numpy as np
++from numpy.testing import assert_, assert_equal, run_module_suite
++from qutip import basis
++from qutip.three_level_atom import *
++
++
++three_states = three_level_basis()
++three_check = np.empty((3,), dtype=object)
++three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
++three_ops = three_level_ops()
++
++
++def testThreeStates():
++    "Three-level atom: States"
++    assert_equal(np.all(three_states == three_check), True)
++
++
++def testThreeOps():
++    "Three-level atom: Operators"
++    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
++    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
++    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
++    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
++    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
++
++if __name__ == "__main__":
++    run_module_suite()
+diff --git a/qutip/tests/test_transfertensor.py b/qutip/tests/test_transfertensor.py
+index c736ef04..34cacd2c 100644
+--- a/qutip/tests/test_transfertensor.py
++++ b/qutip/tests/test_transfertensor.py
+@@ -1,45 +1,45 @@
+-import pytest
+-import qutip as qt
+-import numpy as np
+-from qutip.solve.nonmarkov.transfertensor import ttmsolve
+-
+-
+-def test_ttmsolve_jc_model():
+-    """
+-    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
+-    which can also be found in the qutip-notebooks repository.
+-    """
+-    # Define Hamiltonian and states
+-    N, kappa, g = 3, 1.0, 10
+-    a = qt.tensor(qt.qeye(2), qt.destroy(N))
+-    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
+-    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
+-    H = g * (a.dag() * sm + a * sm.dag())
+-    c_ops = [np.sqrt(kappa) * a]
+-    # identity superoperator
+-    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
+-    E0 = qt.sprepost(Id, Id)
+-    # partial trace superoperator
+-    ptracesuper = qt.tensor_contract(E0, (1, N))
+-    # initial states
+-    rho0a = qt.ket2dm(qt.basis(2, 0))
+-    psi0c = qt.basis(N, 0)
+-    rho0c = qt.ket2dm(psi0c)
+-    rho0 = qt.tensor(rho0a, rho0c)
+-    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
+-                               qt.tensor(qt.qeye(2), psi0c.dag()))
+-
+-    # calculate exact solution using mesolve
+-    times = np.arange(0, 5.0, 0.1)
+-    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
+-    exact_z = qt.expect(sz, exactsol.states)
+-
+-    # solve using transfer method
+-    learning_times = np.arange(0, 2.0, 0.1)
+-    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
+-    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
+-    ttmsol = ttmsolve(learning_maps, rho0a, times)
+-    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
+-
+-    # check that ttm result and exact solution are close in the learning times
+-    assert np.allclose(ttm_z, exact_z, atol=1e-5)
++import pytest
++import qutip as qt
++import numpy as np
++from qutip.solve.nonmarkov.transfertensor import ttmsolve
++
++
++def test_ttmsolve_jc_model():
++    """
++    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
++    which can also be found in the qutip-notebooks repository.
++    """
++    # Define Hamiltonian and states
++    N, kappa, g = 3, 1.0, 10
++    a = qt.tensor(qt.qeye(2), qt.destroy(N))
++    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
++    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
++    H = g * (a.dag() * sm + a * sm.dag())
++    c_ops = [np.sqrt(kappa) * a]
++    # identity superoperator
++    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
++    E0 = qt.sprepost(Id, Id)
++    # partial trace superoperator
++    ptracesuper = qt.tensor_contract(E0, (1, N))
++    # initial states
++    rho0a = qt.ket2dm(qt.basis(2, 0))
++    psi0c = qt.basis(N, 0)
++    rho0c = qt.ket2dm(psi0c)
++    rho0 = qt.tensor(rho0a, rho0c)
++    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
++                               qt.tensor(qt.qeye(2), psi0c.dag()))
++
++    # calculate exact solution using mesolve
++    times = np.arange(0, 5.0, 0.1)
++    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
++    exact_z = qt.expect(sz, exactsol.states)
++
++    # solve using transfer method
++    learning_times = np.arange(0, 2.0, 0.1)
++    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
++    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
++    ttmsol = ttmsolve(learning_maps, rho0a, times)
++    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
++
++    # check that ttm result and exact solution are close in the learning times
++    assert np.allclose(ttm_z, exact_z, atol=1e-5)
+diff --git a/qutip/tests/test_utilities.py b/qutip/tests/test_utilities.py
+index f29d8224..648d6a4d 100644
+--- a/qutip/tests/test_utilities.py
++++ b/qutip/tests/test_utilities.py
+@@ -1,121 +1,121 @@
+-import numpy as np
+-from qutip import convert_unit, clebsch, n_thermal
+-import qutip.utilities as utils
+-from functools import partial
+-import pytest
+-
+-
+-@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
+-    pytest.param(np.log(2), 1, 1, id='log(2)'),
+-    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
+-    pytest.param(0, 1, 0, id="0_energy"),
+-    pytest.param(1, -1, 0, id="neg_temp"),
+-    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
+-                 np.array([1, 1/2, 1/3]), id="array"),
+-])
+-def test_n_thermal(w, w_th, expected):
+-    np.testing.assert_allclose(n_thermal(w, w_th), expected)
+-
+-
+-def _get_converter(orig, target):
+-    """get funtion 'convert_{}_to_{}' when available for coverage """
+-    try:
+-        func = getattr(utils, f'convert_{orig}_to_{target}')
+-    except AttributeError:
+-        func = partial(convert_unit, orig=orig, to=target)
+-    return func
+-
+-
+-@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
+-@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
+-def test_unit_conversions(orig, target):
+-    T = np.random.rand() * 100.0
+-    T_converted = convert_unit(T, orig=orig, to=target)
+-    T_back = convert_unit(T_converted, orig=target, to=orig)
+-
+-    assert T == pytest.approx(T_back)
+-
+-    T_converted = _get_converter(orig=orig, target=target)(T)
+-    T_back = _get_converter(orig=target, target=orig)(T_converted)
+-
+-    assert T == pytest.approx(T_back)
+-
+-
+-@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
+-@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
+-@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
+-def test_unit_conversions_loop(orig, middle, target):
+-    T = np.random.rand() * 100.0
+-    T_middle = convert_unit(T, orig=orig, to=middle)
+-    T_converted = convert_unit(T_middle, orig=middle, to=target)
+-    T_back = convert_unit(T_converted, orig=target, to=orig)
+-
+-    assert T == pytest.approx(T_back)
+-
+-
+-def test_unit_conversions_bad_unit():
+-    with pytest.raises(TypeError):
+-        convert_unit(10, orig="bad", to="J")
+-    with pytest.raises(TypeError):
+-        convert_unit(10, orig="J", to="bad")
+-
+-
+-@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+-@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+-def test_unit_clebsch_delta_j(j1, j2):
+-    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
+-    delta j3,j3' delta m3,m3'"""
+-    for _ in range(10):
+-        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
+-        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
+-        m3 = np.random.choice(np.arange(-j3, j3+1))
+-        m3p = np.random.choice(np.arange(-j3p, j3p+1))
+-
+-        sum_match = 0
+-        sum_differ = 0
+-        for m1 in np.arange(-j1, j1+1):
+-            for m2 in np.arange(-j2, j2+1):
+-                c1 = clebsch(j1, j2, j3, m1, m2, m3)
+-                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
+-                sum_match += c1**2
+-                sum_differ += c1*c2
+-        assert sum_match == pytest.approx(1)
+-        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
+-
+-
+-@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+-@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+-def test_unit_clebsch_delta_m(j1, j2):
+-    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
+-    delta m1,m1' delta m2,m2'"""
+-    for _ in range(10):
+-        m1 = np.random.choice(np.arange(-j1, j1+1))
+-        m1p = np.random.choice(np.arange(-j1, j1+1))
+-        m2 = np.random.choice(np.arange(-j2, j2+1))
+-        m2p = np.random.choice(np.arange(-j2, j2+1))
+-
+-        sum_match = 0
+-        sum_differ = 0
+-        for j3 in np.arange(abs(j1-j2), j1+j2+1):
+-            for m3 in np.arange(-j3, j3+1):
+-                c1 = clebsch(j1, j2, j3, m1, m2, m3)
+-                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
+-                sum_match += c1**2
+-                sum_differ += c1*c2
+-        assert sum_match == pytest.approx(1)
+-        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
+-
+-
+-def test_cpu_count(monkeypatch):
+-    from qutip.settings import available_cpu_count
+-    ncpus = available_cpu_count()
+-    assert isinstance(ncpus, int)
+-    assert ncpus >= 1
+-
+-    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
+-    new_ncpus = available_cpu_count()
+-    assert new_ncpus == ncpus + 2
+-
+-    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
+-    new_ncpus = available_cpu_count()
+-    assert new_ncpus >= 1
++import numpy as np
++from qutip import convert_unit, clebsch, n_thermal
++import qutip.utilities as utils
++from functools import partial
++import pytest
++
++
++@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
++    pytest.param(np.log(2), 1, 1, id='log(2)'),
++    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
++    pytest.param(0, 1, 0, id="0_energy"),
++    pytest.param(1, -1, 0, id="neg_temp"),
++    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
++                 np.array([1, 1/2, 1/3]), id="array"),
++])
++def test_n_thermal(w, w_th, expected):
++    np.testing.assert_allclose(n_thermal(w, w_th), expected)
++
++
++def _get_converter(orig, target):
++    """get funtion 'convert_{}_to_{}' when available for coverage """
++    try:
++        func = getattr(utils, f'convert_{orig}_to_{target}')
++    except AttributeError:
++        func = partial(convert_unit, orig=orig, to=target)
++    return func
++
++
++@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
++@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
++def test_unit_conversions(orig, target):
++    T = np.random.rand() * 100.0
++    T_converted = convert_unit(T, orig=orig, to=target)
++    T_back = convert_unit(T_converted, orig=target, to=orig)
++
++    assert T == pytest.approx(T_back)
++
++    T_converted = _get_converter(orig=orig, target=target)(T)
++    T_back = _get_converter(orig=target, target=orig)(T_converted)
++
++    assert T == pytest.approx(T_back)
++
++
++@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
++@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
++@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
++def test_unit_conversions_loop(orig, middle, target):
++    T = np.random.rand() * 100.0
++    T_middle = convert_unit(T, orig=orig, to=middle)
++    T_converted = convert_unit(T_middle, orig=middle, to=target)
++    T_back = convert_unit(T_converted, orig=target, to=orig)
++
++    assert T == pytest.approx(T_back)
++
++
++def test_unit_conversions_bad_unit():
++    with pytest.raises(TypeError):
++        convert_unit(10, orig="bad", to="J")
++    with pytest.raises(TypeError):
++        convert_unit(10, orig="J", to="bad")
++
++
++@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
++@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
++def test_unit_clebsch_delta_j(j1, j2):
++    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
++    delta j3,j3' delta m3,m3'"""
++    for _ in range(10):
++        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
++        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
++        m3 = np.random.choice(np.arange(-j3, j3+1))
++        m3p = np.random.choice(np.arange(-j3p, j3p+1))
++
++        sum_match = 0
++        sum_differ = 0
++        for m1 in np.arange(-j1, j1+1):
++            for m2 in np.arange(-j2, j2+1):
++                c1 = clebsch(j1, j2, j3, m1, m2, m3)
++                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
++                sum_match += c1**2
++                sum_differ += c1*c2
++        assert sum_match == pytest.approx(1)
++        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
++
++
++@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
++@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
++def test_unit_clebsch_delta_m(j1, j2):
++    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
++    delta m1,m1' delta m2,m2'"""
++    for _ in range(10):
++        m1 = np.random.choice(np.arange(-j1, j1+1))
++        m1p = np.random.choice(np.arange(-j1, j1+1))
++        m2 = np.random.choice(np.arange(-j2, j2+1))
++        m2p = np.random.choice(np.arange(-j2, j2+1))
++
++        sum_match = 0
++        sum_differ = 0
++        for j3 in np.arange(abs(j1-j2), j1+j2+1):
++            for m3 in np.arange(-j3, j3+1):
++                c1 = clebsch(j1, j2, j3, m1, m2, m3)
++                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
++                sum_match += c1**2
++                sum_differ += c1*c2
++        assert sum_match == pytest.approx(1)
++        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
++
++
++def test_cpu_count(monkeypatch):
++    from qutip.settings import available_cpu_count
++    ncpus = available_cpu_count()
++    assert isinstance(ncpus, int)
++    assert ncpus >= 1
++
++    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
++    new_ncpus = available_cpu_count()
++    assert new_ncpus == ncpus + 2
++
++    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
++    new_ncpus = available_cpu_count()
++    assert new_ncpus >= 1
+diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
+index 78c57148..5dd34556 100644
+--- a/qutip/tests/test_wigner.py
++++ b/qutip/tests/test_wigner.py
+@@ -1,693 +1,693 @@
+-import pytest
+-import numpy as np
+-import itertools
+-from scipy.special import laguerre
+-from numpy.random import rand
+-from numpy.testing import assert_, run_module_suite, assert_equal, \
+-    assert_almost_equal, assert_allclose
+-
+-import qutip
+-from qutip.core.states import coherent, fock, ket, bell_state
+-from qutip.wigner import wigner, wigner_transform, _parity
+-from qutip.random_objects import rand_dm, rand_ket
+-
+-
+-class TestHusimiQ:
+-    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
+-    def test_failure_if_non_arraylike_coordinates(self, xs):
+-        state = qutip.rand_ket(4)
+-        valid = np.linspace(-1, 1, 5)
+-        with pytest.raises(TypeError) as e:
+-            qutip.qfunc(state, xs, valid)
+-        assert "must be array-like" in e.value.args[0]
+-        with pytest.raises(TypeError) as e:
+-            qutip.qfunc(state, valid, xs)
+-        assert "must be array-like" in e.value.args[0]
+-        with pytest.raises(TypeError) as e:
+-            qutip.QFunc(xs, valid)
+-        assert "must be array-like" in e.value.args[0]
+-        with pytest.raises(TypeError) as e:
+-            qutip.QFunc(valid, xs)
+-        assert "must be array-like" in e.value.args[0]
+-
+-    @pytest.mark.parametrize('ndim', [2, 3])
+-    def test_failure_if_coordinates_not_1d(self, ndim):
+-        state = qutip.rand_ket(4)
+-        valid = np.linspace(-1, 1, 5)
+-        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
+-        with pytest.raises(ValueError) as e:
+-            qutip.qfunc(state, bad, valid)
+-        assert "must be 1D" in e.value.args[0]
+-        with pytest.raises(ValueError) as e:
+-            qutip.qfunc(state, valid, bad)
+-        assert "must be 1D" in e.value.args[0]
+-        with pytest.raises(ValueError) as e:
+-            qutip.QFunc(bad, valid)
+-        assert "must be 1D" in e.value.args[0]
+-        with pytest.raises(ValueError) as e:
+-            qutip.QFunc(valid, bad)
+-        assert "must be 1D" in e.value.args[0]
+-
+-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+-    def test_failure_if_tensor_hilbert_space(self, dm):
+-        if dm:
+-            state = qutip.rand_dm([2, 2])
+-        else:
+-            state = qutip.rand_ket([2, 2])
+-        xs = np.linspace(-1, 1, 5)
+-        with pytest.raises(ValueError) as e:
+-            qutip.qfunc(state, xs, xs)
+-        assert "must not have tensor structure" in e.value.args[0]
+-        with pytest.raises(ValueError) as e:
+-            qutip.QFunc(xs, xs)(state)
+-        assert "must not have tensor structure" in e.value.args[0]
+-
+-    def test_QFunc_raises_if_insufficient_memory(self):
+-        xs = np.linspace(-1, 1, 11)
+-        state = qutip.rand_ket(4)
+-        qfunc = qutip.QFunc(xs, xs, memory=0)
+-        with pytest.raises(MemoryError) as e:
+-            qfunc(state)
+-        assert e.value.args[0].startswith("Refusing to precompute")
+-
+-    def test_qfunc_warns_if_insufficient_memory(self):
+-        xs = np.linspace(-1, 1, 11)
+-        state = qutip.rand_dm(4)
+-        with pytest.warns(UserWarning) as e:
+-            qutip.qfunc(state, xs, xs, precompute_memory=0)
+-        assert (
+-            e[0].message.args[0]
+-            .startswith("Falling back to iterative algorithm")
+-        )
+-
+-    @pytest.mark.parametrize('obj', [
+-        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
+-        pytest.param([[1, 0], [0, 1]], id='list'),
+-        pytest.param(1, id='int'),
+-    ])
+-    def test_failure_if_not_a_Qobj(self, obj):
+-        xs = np.linspace(-1, 1, 11)
+-        with pytest.raises(TypeError) as e:
+-            qutip.qfunc(obj, xs, xs)
+-        assert e.value.args[0].startswith("state must be Qobj")
+-        qfunc = qutip.QFunc(xs, xs)
+-        with pytest.raises(TypeError) as e:
+-            qfunc(obj)
+-        assert e.value.args[0].startswith("state must be Qobj")
+-
+-    # Use indirection so that the tests can still be collected if there's a bug
+-    # in the generating QuTiP functions.
+-    @pytest.mark.parametrize('state', [
+-        pytest.param(lambda: qutip.rand_super(2), id='super'),
+-        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
+-        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
+-        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
+-                     id='nonsquare dm'),
+-        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
+-                     id='operator-ket'),
+-        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
+-                     id='operator-bra'),
+-    ])
+-    def test_failure_if_not_a_state(self, state):
+-        xs = np.linspace(-1, 1, 11)
+-        state = state()
+-        with pytest.raises(ValueError) as e:
+-            qutip.qfunc(state, xs, xs)
+-        assert (
+-            e.value.args[0].startswith("state must be a ket or density matrix")
+-        )
+-        qfunc = qutip.QFunc(xs, xs)
+-        with pytest.raises(ValueError) as e:
+-            qfunc(state)
+-        assert (
+-            e.value.args[0].startswith("state must be a ket or density matrix")
+-        )
+-
+-    @pytest.mark.parametrize('g', [
+-        pytest.param(np.sqrt(2), id='natural units'),
+-        pytest.param(1, id='arb units'),
+-    ])
+-    @pytest.mark.parametrize('n_ys', [5, 101])
+-    @pytest.mark.parametrize('n_xs', [5, 101])
+-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+-    @pytest.mark.parametrize('size', [5, 32])
+-    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
+-        xs = np.linspace(-1, 1, n_xs)
+-        ys = np.linspace(0, 2, n_ys)
+-        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
+-        function = qutip.qfunc(state, xs, ys, g)
+-        class_ = qutip.QFunc(xs, ys, g)(state)
+-        np.testing.assert_allclose(function, class_)
+-
+-    @pytest.mark.parametrize('g', [
+-        pytest.param(np.sqrt(2), id='natural units'),
+-        pytest.param(1, id='arb units'),
+-    ])
+-    @pytest.mark.parametrize('n_ys', [5, 101])
+-    @pytest.mark.parametrize('n_xs', [5, 101])
+-    @pytest.mark.parametrize('size', [5, 32])
+-    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
+-        xs = np.linspace(-1, 1, n_xs)
+-        ys = np.linspace(0, 2, n_ys)
+-        state = qutip.rand_dm(size)
+-        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
+-        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
+-        np.testing.assert_allclose(iterate, precompute)
+-
+-    @pytest.mark.parametrize('initial_size', [5, 8])
+-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+-    def test_same_class_can_take_many_sizes(self, dm, initial_size):
+-        xs = np.linspace(-1, 1, 11)
+-        ys = np.linspace(0, 2, 11)
+-        shape = np.meshgrid(xs, ys)[0].shape
+-        sizes = initial_size + np.array([0, 1, -1, 4])
+-        qfunc = qutip.QFunc(xs, ys)
+-        for size in sizes:
+-            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
+-            out = qfunc(state)
+-            assert isinstance(out, np.ndarray)
+-            assert out.shape == shape
+-
+-    @pytest.mark.parametrize('dm_first', [True, False])
+-    def test_same_class_can_mix_ket_and_dm(self, dm_first):
+-        dms = [True, False, True, False]
+-        if not dm_first:
+-            dms = dms[::-1]
+-        xs = np.linspace(-1, 1, 11)
+-        ys = np.linspace(0, 2, 11)
+-        shape = np.meshgrid(xs, ys)[0].shape
+-        qfunc = qutip.QFunc(xs, ys)
+-        for dm in dms:
+-            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
+-            out = qfunc(state)
+-            assert isinstance(out, np.ndarray)
+-            assert out.shape == shape
+-
+-    @pytest.mark.parametrize('n_ys', [5, 101])
+-    @pytest.mark.parametrize('n_xs', [5, 101])
+-    @pytest.mark.parametrize('mix', [0.1, 0.5])
+-    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
+-        xs = np.linspace(-1, 1, n_xs)
+-        ys = np.linspace(-1, 1, n_ys)
+-        qfunc = qutip.QFunc(xs, ys)
+-        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
+-        qleft, qright = qfunc(left), qfunc(right)
+-        qboth = qfunc(mix*left + (1-mix)*right)
+-        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
+-
+-    @pytest.mark.parametrize('n_ys', [5, 101])
+-    @pytest.mark.parametrize('n_xs', [5, 101])
+-    @pytest.mark.parametrize('size', [5, 32])
+-    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
+-        xs = np.linspace(-1, 1, n_xs)
+-        ys = np.linspace(-1, 1, n_ys)
+-        state = qutip.rand_ket(size)
+-        qfunc = qutip.QFunc(xs, ys)
+-        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
+-
+-    @pytest.mark.parametrize('g', [
+-        pytest.param(np.sqrt(2), id='natural units'),
+-        pytest.param(1, id='arb units'),
+-    ])
+-    @pytest.mark.parametrize('ys', [
+-        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
+-        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
+-    ])
+-    @pytest.mark.parametrize('xs', [
+-        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
+-        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
+-    ])
+-    @pytest.mark.parametrize('size', [3, 5])
+-    def test_against_naive_implementation(self, xs, ys, g, size):
+-        state = qutip.rand_dm(size)
+-        state_np = state.full()
+-        x, y = np.meshgrid(xs, ys)
+-        alphas = 0.5*g * (x + 1j*y)
+-        naive = np.empty(alphas.shape, dtype=np.float64)
+-        for i, alpha in enumerate(alphas.flat):
+-            coh = qutip.coherent(size, alpha, method='analytic').full()
+-            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
+-        naive *= (0.5*g)**2 / np.pi
+-        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
+-        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
+-
+-
+-def test_wigner_bell1_su2parity():
+-    """wigner: testing the SU2 parity of the first Bell state.
+-    """
+-    psi = bell_state('00')
+-
+-    steps = 25
+-    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
+-    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
+-    slicearray = ['l', 'l']
+-
+-    wigner_analyt = np.zeros((steps, steps))
+-    for t in range(steps):
+-        for p in range(steps):
+-            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
+-                                            * np.cos(theta[0, t]))
+-                                           * (1 + np.sqrt(3)
+-                                           * np.cos(theta[1, t]))
+-                                           + 3 * (np.sin(theta[0, t])
+-                                           * np.exp(-1j * phi[0, p])
+-                                           * np.sin(theta[1, t])
+-                                           * np.exp(-1j * phi[1, p])
+-                                           + np.sin(theta[0, t])
+-                                           * np.exp(1j * phi[0, p])
+-                                           * np.sin(theta[1, t])
+-                                           * np.exp(1j * phi[1, p]))
+-                                           + (1 - np.sqrt(3)
+-                                           * np.cos(theta[0, t]))
+-                                           * (1 - np.sqrt(3)
+-                                           * np.cos(theta[1, t]))) / 8.)
+-
+-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+-
+-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+-
+-
+-@pytest.mark.slow
+-def test_wigner_bell4_su2parity():
+-    """wigner: testing the SU2 parity of the fourth Bell state.
+-    """
+-    psi = bell_state('11')
+-
+-    steps = 25
+-    slicearray = ['l', 'l']
+-
+-    wigner_analyt = np.zeros((steps, steps))
+-    for t in range(steps):
+-        for p in range(steps):
+-            wigner_analyt[t, p] = -0.5
+-
+-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+-
+-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+-
+-
+-@pytest.mark.slow
+-def test_wigner_bell4_fullparity():
+-    """wigner: testing the parity of the fourth Bell state using the parity of
+-    the full space.
+-    """
+-    psi = bell_state('11')
+-
+-    steps = 25
+-    slicearray = ['l', 'l']
+-
+-    wigner_analyt = np.zeros((steps, steps))
+-    for t in range(steps):
+-        for p in range(steps):
+-            wigner_analyt[t, p] = -0.30901699
+-
+-    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
+-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
+-
+-
+-def test_parity():
+-    """wigner: testing the parity function.
+-    """
+-    j = 0.5
+-    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
+-    assert_(_parity(2, j)[0, 1] < 1e-11)
+-    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
+-    assert_(_parity(2, j)[1, 0] < 1e-11)
+-
+-
+-@pytest.mark.slow
+-def test_wigner_pure_su2():
+-    """wigner: testing the SU2 wigner transformation of a pure state.
+-    """
+-    psi = (ket([1]))
+-    steps = 25
+-    theta = np.linspace(0, np.pi, steps)
+-    phi = np.linspace(0, 2 * np.pi, steps)
+-    theta = theta[None, :]
+-    phi = phi[None, :]
+-    slicearray = ['l']
+-
+-    wigner_analyt = np.zeros((steps, steps))
+-    for t in range(steps):
+-        for p in range(steps):
+-            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
+-
+-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+-
+-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+-
+-
+-@pytest.mark.slow
+-def test_wigner_ghz_su2parity():
+-    """wigner: testing the SU2 wigner transformation of the GHZ state.
+-    """
+-    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
+-
+-    steps = 25
+-    N = 3
+-    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
+-    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
+-    slicearray = ['l', 'l', 'l']
+-
+-    wigner_analyt = np.zeros((steps, steps))
+-    for t in range(steps):
+-        for p in range(steps):
+-            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
+-                                           * (1 + np.sqrt(3)
+-                                           * np.cos(theta[1, t]))
+-                                           * (1 + np.sqrt(3)
+-                                           * np.cos(theta[2, t]))
+-                                           + 3**(3 / 2) * (np.sin(theta[0, t])
+-                                           * np.exp(-1j * phi[0, p])
+-                                           * np.sin(theta[1, t])
+-                                           * np.exp(-1j * phi[1, p])
+-                                           * np.sin(theta[2, t])
+-                                           * np.exp(-1j * phi[2, p])
+-                                           + np.sin(theta[0, t])
+-                                           * np.exp(1j * phi[0, p])
+-                                           * np.sin(theta[1, t])
+-                                           * np.exp(1j * phi[1, p])
+-                                           * np.sin(theta[2, t])
+-                                           * np.exp(1j * phi[2, p]))
+-                                           + (1 - np.sqrt(3)
+-                                           * np.cos(theta[0, t]))
+-                                           * (1 - np.sqrt(3)
+-                                           * np.cos(theta[1, t]))
+-                                           * (1 - np.sqrt(3)
+-                                           * np.cos(theta[2, t]))) / 16.)
+-
+-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+-
+-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+-
+-
+-@pytest.mark.slow
+-def test_angle_slicing():
+-    """wigner: tests angle slicing.
+-    """
+-    psi1 = bell_state('00')
+-    psi2 = bell_state('01')
+-    psi3 = bell_state('10')
+-    psi4 = bell_state('11')
+-
+-    steps = 25
+-    j = 0.5
+-
+-    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
+-    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
+-    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
+-    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
+-
+-    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
+-    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
+-    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
+-    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
+-
+-
+-def test_wigner_coherent():
+-    "wigner: test wigner function calculation for coherent states"
+-    xvec = np.linspace(-5.0, 5.0, 100)
+-    yvec = xvec
+-
+-    X, Y = np.meshgrid(xvec, yvec)
+-
+-    a = X + 1j * Y  # consistent with g=2 option to wigner function
+-
+-    dx = xvec[1] - xvec[0]
+-    dy = yvec[1] - yvec[0]
+-
+-    N = 20
+-    beta = rand() + rand() * 1.0j
+-    psi = coherent(N, beta)
+-
+-    # calculate the wigner function using qutip and analytic formula
+-    W_qutip = wigner(psi, xvec, yvec, g=2)
+-    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
+-    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
+-
+-    # check difference
+-    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
+-    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
+-
+-    # check normalization
+-    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+-    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+-    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+-
+-
+-def test_wigner_fock():
+-    "wigner: test wigner function calculation for Fock states"
+-
+-    xvec = np.linspace(-5.0, 5.0, 100)
+-    yvec = xvec
+-
+-    X, Y = np.meshgrid(xvec, yvec)
+-
+-    a = X + 1j * Y  # consistent with g=2 option to wigner function
+-
+-    dx = xvec[1] - xvec[0]
+-    dy = yvec[1] - yvec[0]
+-
+-    N = 15
+-
+-    for n in [2, 3, 4, 5, 6]:
+-
+-        psi = fock(N, n)
+-
+-        # calculate the wigner function using qutip and analytic formula
+-        W_qutip = wigner(psi, xvec, yvec, g=2)
+-        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
+-        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
+-        W_analytic = 2 / np.pi * (-1) ** n * \
+-            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
+-
+-        # check difference
+-        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
+-        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
+-        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
+-
+-        # check normalization
+-        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+-        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+-        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
+-        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+-
+-
+-def test_wigner_compare_methods_dm():
+-    "wigner: compare wigner methods for random density matrices"
+-
+-    xvec = np.linspace(-5.0, 5.0, 100)
+-    yvec = xvec
+-
+-    X, Y = np.meshgrid(xvec, yvec)
+-
+-    # a = X + 1j * Y  # consistent with g=2 option to wigner function
+-
+-    dx = xvec[1] - xvec[0]
+-    dy = yvec[1] - yvec[0]
+-
+-    N = 15
+-
+-    for n in range(10):
+-        # try ten different random density matrices
+-
+-        rho = rand_dm(N, density=0.5 + rand() / 2)
+-
+-        # calculate the wigner function using qutip and analytic formula
+-        W_qutip1 = wigner(rho, xvec, yvec, g=2)
+-        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
+-
+-        # check difference
+-        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
+-
+-        # check normalization
+-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+-
+-
+-def test_wigner_compare_methods_ket():
+-    "wigner: compare wigner methods for random state vectors"
+-
+-    xvec = np.linspace(-5.0, 5.0, 100)
+-    yvec = xvec
+-
+-    X, Y = np.meshgrid(xvec, yvec)
+-
+-    # a = X + 1j * Y  # consistent with g=2 option to wigner function
+-
+-    dx = xvec[1] - xvec[0]
+-    dy = yvec[1] - yvec[0]
+-
+-    N = 15
+-
+-    for n in range(10):
+-        # try ten different random density matrices
+-
+-        psi = rand_ket(N, density=0.5 + rand() / 2)
+-
+-        # calculate the wigner function using qutip and analytic formula
+-        W_qutip1 = wigner(psi, xvec, yvec, g=2)
+-        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
+-
+-        # check difference
+-        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
+-
+-        # check normalization
+-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+-
+-
+-def test_wigner_fft_comparse_ket():
+-    "Wigner: Compare Wigner fft and iterative for rand. ket"
+-    N = 20
+-    xvec = np.linspace(-10, 10, 128)
+-    for i in range(3):
+-        rho = rand_ket(N)
+-
+-        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
+-        W = wigner(rho, xvec, yvec, method='iterative')
+-
+-        Wdiff = abs(W - Wfft)
+-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+-
+-
+-def test_wigner_fft_comparse_dm():
+-    "Wigner: Compare Wigner fft and iterative for rand. dm"
+-    N = 20
+-    xvec = np.linspace(-10, 10, 128)
+-    for i in range(3):
+-        rho = rand_dm(N)
+-
+-        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
+-        W = wigner(rho, xvec, yvec, method='iterative')
+-
+-        Wdiff = abs(W - Wfft)
+-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+-
+-
+-def test_wigner_clenshaw_iter_dm():
+-    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
+-    N = 20
+-    xvec = np.linspace(-10, 10, 128)
+-    for i in range(3):
+-        rho = rand_dm(N)
+-
+-        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
+-        W = wigner(rho, xvec, xvec, method='iterative')
+-
+-        Wdiff = abs(W - Wclen)
+-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+-
+-
+-def test_wigner_clenshaw_sp_iter_dm():
+-    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
+-    N = 20
+-    xvec = np.linspace(-10, 10, 128)
+-    for i in range(3):
+-        rho = rand_dm(N)
+-
+-        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
+-        W = wigner(rho, xvec, xvec, method='iterative')
+-
+-        Wdiff = abs(W - Wclen)
+-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+-
+-@pytest.mark.parametrize(['spin'], [
+-    pytest.param(1/2, id="spin-one-half"),
+-    pytest.param(3, id="spin-three"),
+-    pytest.param(13/2, id="spin-thirteen-half"),
+-    pytest.param(7, id="spin-seven")
+-])
+-@pytest.mark.parametrize("pure", [
+-    pytest.param("pure", id="pure"),
+-    pytest.param("herm", id="mixed")
+-])
+-def test_spin_q_function(spin, pure):
+-    d = int(2*spin + 1)
+-    rho = rand_dm(d, distribution=pure)
+-
+-    # Points at which to evaluate the spin Q function
+-    theta = np.linspace(0, np.pi, 16, endpoint=True)
+-    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
+-    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
+-
+-    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
+-        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
+-        direct_Q = abs(state.dag() * rho * state)
+-        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
+-
+-@pytest.mark.parametrize(['spin'], [
+-    pytest.param(1/2, id="spin-one-half"),
+-    pytest.param(3, id="spin-three"),
+-    pytest.param(13/2, id="spin-thirteen-half"),
+-    pytest.param(7, id="spin-seven")
+-])
+-@pytest.mark.parametrize("pure", [
+-    pytest.param("pure", id="pure"),
+-    pytest.param("herm", id="mixed")
+-])
+-def test_spin_q_function_normalized(spin, pure):
+-    d = int(2 * spin + 1)
+-    rho = rand_dm(d, distribution=pure)
+-
+-    # Points at which to evaluate the spin Q function
+-    theta = np.linspace(0, np.pi, 128, endpoint=True)
+-    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
+-    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
+-
+-    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
+-    assert_almost_equal(norm, 1, decimal=4)
+-
+-
+-@pytest.mark.parametrize(["spin"], [
+-    pytest.param(1/2, id="spin-one-half"),
+-    pytest.param(1, id="spin-one"),
+-    pytest.param(3/2, id="spin-three-half"),
+-    pytest.param(2, id="spin-two")
+-])
+-@pytest.mark.parametrize("pure", [
+-    pytest.param("pure", id="pure"),
+-    pytest.param("herm", id="mixed")
+-])
+-def test_spin_wigner_normalized(spin, pure):
+-    d = int(2*spin + 1)
+-    rho = rand_dm(d, distribution=pure)
+-
+-    # Points at which to evaluate the spin Wigner function
+-    theta = np.linspace(0, np.pi, 256, endpoint=True)
+-    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
+-    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
+-
+-    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
+-    assert_almost_equal(norm, 1, decimal=4)
+-
+-@pytest.mark.parametrize(['spin'], [
+-    pytest.param(1 / 2, id="spin-one-half"),
+-    pytest.param(1, id="spin-one"),
+-    pytest.param(3 / 2, id="spin-three-half"),
+-    pytest.param(2, id="spin-two")
+-])
+-@pytest.mark.parametrize("pure", [
+-    pytest.param("pure", id="pure"),
+-    pytest.param("herm", id="mixed")
+-])
+-def test_spin_wigner_overlap(spin, pure, n=5):
+-    d = int(2*spin + 1)
+-    rho = rand_dm(d, distribution=pure)
+-
+-    # Points at which to evaluate the spin Wigner function
+-    theta = np.linspace(0, np.pi, 256, endpoint=True)
+-    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
+-    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
+-
+-    for k in range(n):
+-        test_state = rand_dm(d)
+-        state_overlap = (test_state*rho).tr().real
+-
+-        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
+-        W_overlap = np.trapz(
+-            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
+-        assert_almost_equal(W_overlap, state_overlap, decimal=4)
+-
+-if __name__ == "__main__":
+-    run_module_suite()
++import pytest
++import numpy as np
++import itertools
++from scipy.special import laguerre
++from numpy.random import rand
++from numpy.testing import assert_, run_module_suite, assert_equal, \
++    assert_almost_equal, assert_allclose
++
++import qutip
++from qutip.core.states import coherent, fock, ket, bell_state
++from qutip.wigner import wigner, wigner_transform, _parity
++from qutip.random_objects import rand_dm, rand_ket
++
++
++class TestHusimiQ:
++    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
++    def test_failure_if_non_arraylike_coordinates(self, xs):
++        state = qutip.rand_ket(4)
++        valid = np.linspace(-1, 1, 5)
++        with pytest.raises(TypeError) as e:
++            qutip.qfunc(state, xs, valid)
++        assert "must be array-like" in e.value.args[0]
++        with pytest.raises(TypeError) as e:
++            qutip.qfunc(state, valid, xs)
++        assert "must be array-like" in e.value.args[0]
++        with pytest.raises(TypeError) as e:
++            qutip.QFunc(xs, valid)
++        assert "must be array-like" in e.value.args[0]
++        with pytest.raises(TypeError) as e:
++            qutip.QFunc(valid, xs)
++        assert "must be array-like" in e.value.args[0]
++
++    @pytest.mark.parametrize('ndim', [2, 3])
++    def test_failure_if_coordinates_not_1d(self, ndim):
++        state = qutip.rand_ket(4)
++        valid = np.linspace(-1, 1, 5)
++        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
++        with pytest.raises(ValueError) as e:
++            qutip.qfunc(state, bad, valid)
++        assert "must be 1D" in e.value.args[0]
++        with pytest.raises(ValueError) as e:
++            qutip.qfunc(state, valid, bad)
++        assert "must be 1D" in e.value.args[0]
++        with pytest.raises(ValueError) as e:
++            qutip.QFunc(bad, valid)
++        assert "must be 1D" in e.value.args[0]
++        with pytest.raises(ValueError) as e:
++            qutip.QFunc(valid, bad)
++        assert "must be 1D" in e.value.args[0]
++
++    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
++    def test_failure_if_tensor_hilbert_space(self, dm):
++        if dm:
++            state = qutip.rand_dm([2, 2])
++        else:
++            state = qutip.rand_ket([2, 2])
++        xs = np.linspace(-1, 1, 5)
++        with pytest.raises(ValueError) as e:
++            qutip.qfunc(state, xs, xs)
++        assert "must not have tensor structure" in e.value.args[0]
++        with pytest.raises(ValueError) as e:
++            qutip.QFunc(xs, xs)(state)
++        assert "must not have tensor structure" in e.value.args[0]
++
++    def test_QFunc_raises_if_insufficient_memory(self):
++        xs = np.linspace(-1, 1, 11)
++        state = qutip.rand_ket(4)
++        qfunc = qutip.QFunc(xs, xs, memory=0)
++        with pytest.raises(MemoryError) as e:
++            qfunc(state)
++        assert e.value.args[0].startswith("Refusing to precompute")
++
++    def test_qfunc_warns_if_insufficient_memory(self):
++        xs = np.linspace(-1, 1, 11)
++        state = qutip.rand_dm(4)
++        with pytest.warns(UserWarning) as e:
++            qutip.qfunc(state, xs, xs, precompute_memory=0)
++        assert (
++            e[0].message.args[0]
++            .startswith("Falling back to iterative algorithm")
++        )
++
++    @pytest.mark.parametrize('obj', [
++        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
++        pytest.param([[1, 0], [0, 1]], id='list'),
++        pytest.param(1, id='int'),
++    ])
++    def test_failure_if_not_a_Qobj(self, obj):
++        xs = np.linspace(-1, 1, 11)
++        with pytest.raises(TypeError) as e:
++            qutip.qfunc(obj, xs, xs)
++        assert e.value.args[0].startswith("state must be Qobj")
++        qfunc = qutip.QFunc(xs, xs)
++        with pytest.raises(TypeError) as e:
++            qfunc(obj)
++        assert e.value.args[0].startswith("state must be Qobj")
++
++    # Use indirection so that the tests can still be collected if there's a bug
++    # in the generating QuTiP functions.
++    @pytest.mark.parametrize('state', [
++        pytest.param(lambda: qutip.rand_super(2), id='super'),
++        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
++        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
++        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
++                     id='nonsquare dm'),
++        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
++                     id='operator-ket'),
++        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
++                     id='operator-bra'),
++    ])
++    def test_failure_if_not_a_state(self, state):
++        xs = np.linspace(-1, 1, 11)
++        state = state()
++        with pytest.raises(ValueError) as e:
++            qutip.qfunc(state, xs, xs)
++        assert (
++            e.value.args[0].startswith("state must be a ket or density matrix")
++        )
++        qfunc = qutip.QFunc(xs, xs)
++        with pytest.raises(ValueError) as e:
++            qfunc(state)
++        assert (
++            e.value.args[0].startswith("state must be a ket or density matrix")
++        )
++
++    @pytest.mark.parametrize('g', [
++        pytest.param(np.sqrt(2), id='natural units'),
++        pytest.param(1, id='arb units'),
++    ])
++    @pytest.mark.parametrize('n_ys', [5, 101])
++    @pytest.mark.parametrize('n_xs', [5, 101])
++    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
++    @pytest.mark.parametrize('size', [5, 32])
++    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
++        xs = np.linspace(-1, 1, n_xs)
++        ys = np.linspace(0, 2, n_ys)
++        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
++        function = qutip.qfunc(state, xs, ys, g)
++        class_ = qutip.QFunc(xs, ys, g)(state)
++        np.testing.assert_allclose(function, class_)
++
++    @pytest.mark.parametrize('g', [
++        pytest.param(np.sqrt(2), id='natural units'),
++        pytest.param(1, id='arb units'),
++    ])
++    @pytest.mark.parametrize('n_ys', [5, 101])
++    @pytest.mark.parametrize('n_xs', [5, 101])
++    @pytest.mark.parametrize('size', [5, 32])
++    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
++        xs = np.linspace(-1, 1, n_xs)
++        ys = np.linspace(0, 2, n_ys)
++        state = qutip.rand_dm(size)
++        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
++        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
++        np.testing.assert_allclose(iterate, precompute)
++
++    @pytest.mark.parametrize('initial_size', [5, 8])
++    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
++    def test_same_class_can_take_many_sizes(self, dm, initial_size):
++        xs = np.linspace(-1, 1, 11)
++        ys = np.linspace(0, 2, 11)
++        shape = np.meshgrid(xs, ys)[0].shape
++        sizes = initial_size + np.array([0, 1, -1, 4])
++        qfunc = qutip.QFunc(xs, ys)
++        for size in sizes:
++            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
++            out = qfunc(state)
++            assert isinstance(out, np.ndarray)
++            assert out.shape == shape
++
++    @pytest.mark.parametrize('dm_first', [True, False])
++    def test_same_class_can_mix_ket_and_dm(self, dm_first):
++        dms = [True, False, True, False]
++        if not dm_first:
++            dms = dms[::-1]
++        xs = np.linspace(-1, 1, 11)
++        ys = np.linspace(0, 2, 11)
++        shape = np.meshgrid(xs, ys)[0].shape
++        qfunc = qutip.QFunc(xs, ys)
++        for dm in dms:
++            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
++            out = qfunc(state)
++            assert isinstance(out, np.ndarray)
++            assert out.shape == shape
++
++    @pytest.mark.parametrize('n_ys', [5, 101])
++    @pytest.mark.parametrize('n_xs', [5, 101])
++    @pytest.mark.parametrize('mix', [0.1, 0.5])
++    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
++        xs = np.linspace(-1, 1, n_xs)
++        ys = np.linspace(-1, 1, n_ys)
++        qfunc = qutip.QFunc(xs, ys)
++        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
++        qleft, qright = qfunc(left), qfunc(right)
++        qboth = qfunc(mix*left + (1-mix)*right)
++        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
++
++    @pytest.mark.parametrize('n_ys', [5, 101])
++    @pytest.mark.parametrize('n_xs', [5, 101])
++    @pytest.mark.parametrize('size', [5, 32])
++    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
++        xs = np.linspace(-1, 1, n_xs)
++        ys = np.linspace(-1, 1, n_ys)
++        state = qutip.rand_ket(size)
++        qfunc = qutip.QFunc(xs, ys)
++        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
++
++    @pytest.mark.parametrize('g', [
++        pytest.param(np.sqrt(2), id='natural units'),
++        pytest.param(1, id='arb units'),
++    ])
++    @pytest.mark.parametrize('ys', [
++        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
++        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
++    ])
++    @pytest.mark.parametrize('xs', [
++        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
++        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
++    ])
++    @pytest.mark.parametrize('size', [3, 5])
++    def test_against_naive_implementation(self, xs, ys, g, size):
++        state = qutip.rand_dm(size)
++        state_np = state.full()
++        x, y = np.meshgrid(xs, ys)
++        alphas = 0.5*g * (x + 1j*y)
++        naive = np.empty(alphas.shape, dtype=np.float64)
++        for i, alpha in enumerate(alphas.flat):
++            coh = qutip.coherent(size, alpha, method='analytic').full()
++            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
++        naive *= (0.5*g)**2 / np.pi
++        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
++        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
++
++
++def test_wigner_bell1_su2parity():
++    """wigner: testing the SU2 parity of the first Bell state.
++    """
++    psi = bell_state('00')
++
++    steps = 25
++    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
++    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
++    slicearray = ['l', 'l']
++
++    wigner_analyt = np.zeros((steps, steps))
++    for t in range(steps):
++        for p in range(steps):
++            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
++                                            * np.cos(theta[0, t]))
++                                           * (1 + np.sqrt(3)
++                                           * np.cos(theta[1, t]))
++                                           + 3 * (np.sin(theta[0, t])
++                                           * np.exp(-1j * phi[0, p])
++                                           * np.sin(theta[1, t])
++                                           * np.exp(-1j * phi[1, p])
++                                           + np.sin(theta[0, t])
++                                           * np.exp(1j * phi[0, p])
++                                           * np.sin(theta[1, t])
++                                           * np.exp(1j * phi[1, p]))
++                                           + (1 - np.sqrt(3)
++                                           * np.cos(theta[0, t]))
++                                           * (1 - np.sqrt(3)
++                                           * np.cos(theta[1, t]))) / 8.)
++
++    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
++
++    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
++
++
++@pytest.mark.slow
++def test_wigner_bell4_su2parity():
++    """wigner: testing the SU2 parity of the fourth Bell state.
++    """
++    psi = bell_state('11')
++
++    steps = 25
++    slicearray = ['l', 'l']
++
++    wigner_analyt = np.zeros((steps, steps))
++    for t in range(steps):
++        for p in range(steps):
++            wigner_analyt[t, p] = -0.5
++
++    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
++
++    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
++
++
++@pytest.mark.slow
++def test_wigner_bell4_fullparity():
++    """wigner: testing the parity of the fourth Bell state using the parity of
++    the full space.
++    """
++    psi = bell_state('11')
++
++    steps = 25
++    slicearray = ['l', 'l']
++
++    wigner_analyt = np.zeros((steps, steps))
++    for t in range(steps):
++        for p in range(steps):
++            wigner_analyt[t, p] = -0.30901699
++
++    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
++    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
++
++
++def test_parity():
++    """wigner: testing the parity function.
++    """
++    j = 0.5
++    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
++    assert_(_parity(2, j)[0, 1] < 1e-11)
++    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
++    assert_(_parity(2, j)[1, 0] < 1e-11)
++
++
++@pytest.mark.slow
++def test_wigner_pure_su2():
++    """wigner: testing the SU2 wigner transformation of a pure state.
++    """
++    psi = (ket([1]))
++    steps = 25
++    theta = np.linspace(0, np.pi, steps)
++    phi = np.linspace(0, 2 * np.pi, steps)
++    theta = theta[None, :]
++    phi = phi[None, :]
++    slicearray = ['l']
++
++    wigner_analyt = np.zeros((steps, steps))
++    for t in range(steps):
++        for p in range(steps):
++            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
++
++    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
++
++    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
++
++
++@pytest.mark.slow
++def test_wigner_ghz_su2parity():
++    """wigner: testing the SU2 wigner transformation of the GHZ state.
++    """
++    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
++
++    steps = 25
++    N = 3
++    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
++    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
++    slicearray = ['l', 'l', 'l']
++
++    wigner_analyt = np.zeros((steps, steps))
++    for t in range(steps):
++        for p in range(steps):
++            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
++                                           * (1 + np.sqrt(3)
++                                           * np.cos(theta[1, t]))
++                                           * (1 + np.sqrt(3)
++                                           * np.cos(theta[2, t]))
++                                           + 3**(3 / 2) * (np.sin(theta[0, t])
++                                           * np.exp(-1j * phi[0, p])
++                                           * np.sin(theta[1, t])
++                                           * np.exp(-1j * phi[1, p])
++                                           * np.sin(theta[2, t])
++                                           * np.exp(-1j * phi[2, p])
++                                           + np.sin(theta[0, t])
++                                           * np.exp(1j * phi[0, p])
++                                           * np.sin(theta[1, t])
++                                           * np.exp(1j * phi[1, p])
++                                           * np.sin(theta[2, t])
++                                           * np.exp(1j * phi[2, p]))
++                                           + (1 - np.sqrt(3)
++                                           * np.cos(theta[0, t]))
++                                           * (1 - np.sqrt(3)
++                                           * np.cos(theta[1, t]))
++                                           * (1 - np.sqrt(3)
++                                           * np.cos(theta[2, t]))) / 16.)
++
++    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
++
++    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
++
++
++@pytest.mark.slow
++def test_angle_slicing():
++    """wigner: tests angle slicing.
++    """
++    psi1 = bell_state('00')
++    psi2 = bell_state('01')
++    psi3 = bell_state('10')
++    psi4 = bell_state('11')
++
++    steps = 25
++    j = 0.5
++
++    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
++    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
++    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
++    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
++
++    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
++    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
++    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
++    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
++
++
++def test_wigner_coherent():
++    "wigner: test wigner function calculation for coherent states"
++    xvec = np.linspace(-5.0, 5.0, 100)
++    yvec = xvec
++
++    X, Y = np.meshgrid(xvec, yvec)
++
++    a = X + 1j * Y  # consistent with g=2 option to wigner function
++
++    dx = xvec[1] - xvec[0]
++    dy = yvec[1] - yvec[0]
++
++    N = 20
++    beta = rand() + rand() * 1.0j
++    psi = coherent(N, beta)
++
++    # calculate the wigner function using qutip and analytic formula
++    W_qutip = wigner(psi, xvec, yvec, g=2)
++    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
++    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
++
++    # check difference
++    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
++    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
++
++    # check normalization
++    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
++    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
++    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
++
++
++def test_wigner_fock():
++    "wigner: test wigner function calculation for Fock states"
++
++    xvec = np.linspace(-5.0, 5.0, 100)
++    yvec = xvec
++
++    X, Y = np.meshgrid(xvec, yvec)
++
++    a = X + 1j * Y  # consistent with g=2 option to wigner function
++
++    dx = xvec[1] - xvec[0]
++    dy = yvec[1] - yvec[0]
++
++    N = 15
++
++    for n in [2, 3, 4, 5, 6]:
++
++        psi = fock(N, n)
++
++        # calculate the wigner function using qutip and analytic formula
++        W_qutip = wigner(psi, xvec, yvec, g=2)
++        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
++        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
++        W_analytic = 2 / np.pi * (-1) ** n * \
++            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
++
++        # check difference
++        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
++        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
++        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
++
++        # check normalization
++        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
++        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
++        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
++        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
++
++
++def test_wigner_compare_methods_dm():
++    "wigner: compare wigner methods for random density matrices"
++
++    xvec = np.linspace(-5.0, 5.0, 100)
++    yvec = xvec
++
++    X, Y = np.meshgrid(xvec, yvec)
++
++    # a = X + 1j * Y  # consistent with g=2 option to wigner function
++
++    dx = xvec[1] - xvec[0]
++    dy = yvec[1] - yvec[0]
++
++    N = 15
++
++    for n in range(10):
++        # try ten different random density matrices
++
++        rho = rand_dm(N, density=0.5 + rand() / 2)
++
++        # calculate the wigner function using qutip and analytic formula
++        W_qutip1 = wigner(rho, xvec, yvec, g=2)
++        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
++
++        # check difference
++        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
++
++        # check normalization
++        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
++        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
++
++
++def test_wigner_compare_methods_ket():
++    "wigner: compare wigner methods for random state vectors"
++
++    xvec = np.linspace(-5.0, 5.0, 100)
++    yvec = xvec
++
++    X, Y = np.meshgrid(xvec, yvec)
++
++    # a = X + 1j * Y  # consistent with g=2 option to wigner function
++
++    dx = xvec[1] - xvec[0]
++    dy = yvec[1] - yvec[0]
++
++    N = 15
++
++    for n in range(10):
++        # try ten different random density matrices
++
++        psi = rand_ket(N, density=0.5 + rand() / 2)
++
++        # calculate the wigner function using qutip and analytic formula
++        W_qutip1 = wigner(psi, xvec, yvec, g=2)
++        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
++
++        # check difference
++        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
++
++        # check normalization
++        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
++        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
++
++
++def test_wigner_fft_comparse_ket():
++    "Wigner: Compare Wigner fft and iterative for rand. ket"
++    N = 20
++    xvec = np.linspace(-10, 10, 128)
++    for i in range(3):
++        rho = rand_ket(N)
++
++        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
++        W = wigner(rho, xvec, yvec, method='iterative')
++
++        Wdiff = abs(W - Wfft)
++        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
++
++
++def test_wigner_fft_comparse_dm():
++    "Wigner: Compare Wigner fft and iterative for rand. dm"
++    N = 20
++    xvec = np.linspace(-10, 10, 128)
++    for i in range(3):
++        rho = rand_dm(N)
++
++        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
++        W = wigner(rho, xvec, yvec, method='iterative')
++
++        Wdiff = abs(W - Wfft)
++        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
++
++
++def test_wigner_clenshaw_iter_dm():
++    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
++    N = 20
++    xvec = np.linspace(-10, 10, 128)
++    for i in range(3):
++        rho = rand_dm(N)
++
++        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
++        W = wigner(rho, xvec, xvec, method='iterative')
++
++        Wdiff = abs(W - Wclen)
++        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
++
++
++def test_wigner_clenshaw_sp_iter_dm():
++    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
++    N = 20
++    xvec = np.linspace(-10, 10, 128)
++    for i in range(3):
++        rho = rand_dm(N)
++
++        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
++        W = wigner(rho, xvec, xvec, method='iterative')
++
++        Wdiff = abs(W - Wclen)
++        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
++
++@pytest.mark.parametrize(['spin'], [
++    pytest.param(1/2, id="spin-one-half"),
++    pytest.param(3, id="spin-three"),
++    pytest.param(13/2, id="spin-thirteen-half"),
++    pytest.param(7, id="spin-seven")
++])
++@pytest.mark.parametrize("pure", [
++    pytest.param("pure", id="pure"),
++    pytest.param("herm", id="mixed")
++])
++def test_spin_q_function(spin, pure):
++    d = int(2*spin + 1)
++    rho = rand_dm(d, distribution=pure)
++
++    # Points at which to evaluate the spin Q function
++    theta = np.linspace(0, np.pi, 16, endpoint=True)
++    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
++    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
++
++    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
++        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
++        direct_Q = abs(state.dag() * rho * state)
++        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
++
++@pytest.mark.parametrize(['spin'], [
++    pytest.param(1/2, id="spin-one-half"),
++    pytest.param(3, id="spin-three"),
++    pytest.param(13/2, id="spin-thirteen-half"),
++    pytest.param(7, id="spin-seven")
++])
++@pytest.mark.parametrize("pure", [
++    pytest.param("pure", id="pure"),
++    pytest.param("herm", id="mixed")
++])
++def test_spin_q_function_normalized(spin, pure):
++    d = int(2 * spin + 1)
++    rho = rand_dm(d, distribution=pure)
++
++    # Points at which to evaluate the spin Q function
++    theta = np.linspace(0, np.pi, 128, endpoint=True)
++    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
++    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
++
++    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
++    assert_almost_equal(norm, 1, decimal=4)
++
++
++@pytest.mark.parametrize(["spin"], [
++    pytest.param(1/2, id="spin-one-half"),
++    pytest.param(1, id="spin-one"),
++    pytest.param(3/2, id="spin-three-half"),
++    pytest.param(2, id="spin-two")
++])
++@pytest.mark.parametrize("pure", [
++    pytest.param("pure", id="pure"),
++    pytest.param("herm", id="mixed")
++])
++def test_spin_wigner_normalized(spin, pure):
++    d = int(2*spin + 1)
++    rho = rand_dm(d, distribution=pure)
++
++    # Points at which to evaluate the spin Wigner function
++    theta = np.linspace(0, np.pi, 256, endpoint=True)
++    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
++    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
++
++    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
++    assert_almost_equal(norm, 1, decimal=4)
++
++@pytest.mark.parametrize(['spin'], [
++    pytest.param(1 / 2, id="spin-one-half"),
++    pytest.param(1, id="spin-one"),
++    pytest.param(3 / 2, id="spin-three-half"),
++    pytest.param(2, id="spin-two")
++])
++@pytest.mark.parametrize("pure", [
++    pytest.param("pure", id="pure"),
++    pytest.param("herm", id="mixed")
++])
++def test_spin_wigner_overlap(spin, pure, n=5):
++    d = int(2*spin + 1)
++    rho = rand_dm(d, distribution=pure)
++
++    # Points at which to evaluate the spin Wigner function
++    theta = np.linspace(0, np.pi, 256, endpoint=True)
++    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
++    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
++
++    for k in range(n):
++        test_state = rand_dm(d)
++        state_overlap = (test_state*rho).tr().real
++
++        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
++        W_overlap = np.trapz(
++            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
++        assert_almost_equal(W_overlap, state_overlap, decimal=4)
++
++if __name__ == "__main__":
++    run_module_suite()
+diff --git a/qutip/three_level_atom.py b/qutip/three_level_atom.py
+index eee506ef..8db037df 100644
+--- a/qutip/three_level_atom.py
++++ b/qutip/three_level_atom.py
+@@ -1,74 +1,74 @@
+-r'''
+-This module provides functions that are useful for simulating the
+-three level atom with QuTiP.  A three level atom (qutrit) has three states,
+-which are linked by dipole transitions so that 1 <-> 2 <-> 3.
+-Depending on there relative energies they are in the ladder, lambda or
+-vee configuration. The structure of the relevant operators is the same
+-for any of the three configurations::
+-
+-    Ladder:          Lambda:                 Vee:
+-                                |two>                       |three>
+-      -------|three>           -------                      -------
+-         |                       / \             |one>         /
+-         |                      /   \           -------       /
+-         |                     /     \             \         /
+-      -------|two>            /       \             \       /
+-         |                   /         \             \     /
+-         |                  /           \             \   /
+-         |                 /        --------           \ /
+-      -------|one>      -------      |three>         -------
+-                         |one>                       |two>
+-
+-References
+-----------
+-The naming of qutip operators follows the convention in [1]_ .
+-
+-.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
+-   Wiley, 1990.
+-
+-Notes
+------
+-Contributed by Markus Baden, Oct. 07, 2011
+-
+-'''
+-
+-__all__ = ['three_level_basis', 'three_level_ops']
+-
+-import numpy as np
+-from . import qutrit_basis
+-
+-
+-def three_level_basis():
+-    ''' Basis states for a three level atom.
+-
+-    Returns
+-    -------
+-    states : np.array
+-        :obj:`numpy.ndarray` of three level atom basis vectors.
+-    '''
+-    # A three level atom has the same representation as a qutrit, i.e.
+-    # three states
+-    return qutrit_basis()
+-
+-
+-def three_level_ops():
+-    """
+-    Operators for a three level system (qutrit)
+-
+-    Returns
+-    -------
+-    ops : np.array
+-        :obj:`numpy.ndarray` of three level operators.
+-    """
+-    out = np.empty((5,), dtype=object)
+-    one, two, three = qutrit_basis()
+-    # Note that the three level operators are different
+-    # from the qutrit operators. A three level atom only
+-    # has transitions 1 <-> 2 <-> 3, so we define the
+-    # operators seperately from the qutrit code
+-    out[0] = one * one.dag()
+-    out[1] = two * two.dag()
+-    out[2] = three * three.dag()
+-    out[3] = one * two.dag()
+-    out[4] = three * two.dag()
+-    return out
++r'''
++This module provides functions that are useful for simulating the
++three level atom with QuTiP.  A three level atom (qutrit) has three states,
++which are linked by dipole transitions so that 1 <-> 2 <-> 3.
++Depending on there relative energies they are in the ladder, lambda or
++vee configuration. The structure of the relevant operators is the same
++for any of the three configurations::
++
++    Ladder:          Lambda:                 Vee:
++                                |two>                       |three>
++      -------|three>           -------                      -------
++         |                       / \             |one>         /
++         |                      /   \           -------       /
++         |                     /     \             \         /
++      -------|two>            /       \             \       /
++         |                   /         \             \     /
++         |                  /           \             \   /
++         |                 /        --------           \ /
++      -------|one>      -------      |three>         -------
++                         |one>                       |two>
++
++References
++----------
++The naming of qutip operators follows the convention in [1]_ .
++
++.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
++   Wiley, 1990.
++
++Notes
++-----
++Contributed by Markus Baden, Oct. 07, 2011
++
++'''
++
++__all__ = ['three_level_basis', 'three_level_ops']
++
++import numpy as np
++from . import qutrit_basis
++
++
++def three_level_basis():
++    ''' Basis states for a three level atom.
++
++    Returns
++    -------
++    states : np.array
++        :obj:`numpy.ndarray` of three level atom basis vectors.
++    '''
++    # A three level atom has the same representation as a qutrit, i.e.
++    # three states
++    return qutrit_basis()
++
++
++def three_level_ops():
++    """
++    Operators for a three level system (qutrit)
++
++    Returns
++    -------
++    ops : np.array
++        :obj:`numpy.ndarray` of three level operators.
++    """
++    out = np.empty((5,), dtype=object)
++    one, two, three = qutrit_basis()
++    # Note that the three level operators are different
++    # from the qutrit operators. A three level atom only
++    # has transitions 1 <-> 2 <-> 3, so we define the
++    # operators seperately from the qutrit code
++    out[0] = one * one.dag()
++    out[1] = two * two.dag()
++    out[2] = three * three.dag()
++    out[3] = one * two.dag()
++    out[4] = three * two.dag()
++    return out
+diff --git a/qutip/tomography.py b/qutip/tomography.py
+index a663ee30..bf83020e 100644
+--- a/qutip/tomography.py
++++ b/qutip/tomography.py
+@@ -1,190 +1,190 @@
+-__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
+-
+-from numpy import hstack, real, imag
+-import scipy.linalg as la
+-from . import tensor, spre, spost, stack_columns, unstack_columns
+-from .visualization import matrix_histogram, matrix_histogram_complex
+-
+-try:
+-    import matplotlib.pyplot as plt
+-except:
+-    pass
+-
+-
+-def _index_permutations(size_list, perm=[]):
+-    """
+-    Generate a list with all index permutations.
+-
+-    Parameters
+-    ----------
+-    size_list : list
+-        A list that contains the sizes for each composite system.
+-    perm : list
+-        A list of permutations
+-
+-    Returns
+-    -------
+-    perm_idx : list
+-        List containing index permutations.
+-
+-
+-    """
+-    if len(size_list) == 0:
+-        yield perm
+-    else:
+-        for n in range(size_list[0]):
+-            for ip in _index_permutations(size_list[1:], perm + [n]):
+-                yield ip
+-
+-
+-def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
+-    """
+-    Visualize the quantum process tomography chi matrix. Plot the real and
+-    imaginary parts separately.
+-
+-    Parameters
+-    ----------
+-    chi : array
+-        Input QPT chi matrix.
+-    lbls_list : list
+-        List of labels for QPT plot axes.
+-    title : string
+-        Plot title.
+-    fig : figure instance
+-        User defined figure instance used for generating QPT plot.
+-    axes : list of figure axis instance
+-        User defined figure axis instance (list of two axes) used for
+-        generating QPT plot.
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    """
+-
+-    if axes is None or len(axes) != 2:
+-        if fig is None:
+-            fig = plt.figure(figsize=(16, 8))
+-
+-        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
+-        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
+-
+-        axes = [ax1, ax2]
+-
+-    xlabels = []
+-    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
+-        xlabels.append("".join([lbls_list[k][inds[k]]
+-                                for k in range(len(lbls_list))]))
+-
+-    matrix_histogram(real(chi), xlabels, xlabels,
+-                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
+-    matrix_histogram(imag(chi), xlabels, xlabels,
+-                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
+-
+-    if title and fig:
+-        fig.suptitle(title)
+-
+-    return fig, axes
+-
+-
+-def qpt_plot_combined(chi, lbls_list, title=None,
+-                      fig=None, ax=None, figsize=(8, 6),
+-                      threshold=None):
+-    """
+-    Visualize the quantum process tomography chi matrix. Plot bars with
+-    height and color corresponding to the absolute value and phase,
+-    respectively.
+-
+-    Parameters
+-    ----------
+-    chi : array
+-        Input QPT chi matrix.
+-
+-    lbls_list : list
+-        List of labels for QPT plot axes.
+-
+-    title : string
+-        Plot title.
+-
+-    fig : figure instance
+-        User defined figure instance used for generating QPT plot.
+-
+-    ax : figure axis instance
+-        User defined figure axis instance used for generating QPT plot
+-        (alternative to the fig argument).
+-
+-    threshold: float (None)
+-        Threshold for when bars of smaller height should be transparent. If
+-        not set, all bars are colored according to the color map.
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-
+-    if ax is None:
+-        if fig is None:
+-            fig = plt.figure(figsize=figsize)
+-        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
+-
+-    xlabels = []
+-    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
+-        xlabels.append("".join(
+-            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
+-
+-    if not title:
+-        title = r"$\chi$"
+-
+-    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
+-                             threshold=threshold)
+-
+-    return fig, ax
+-
+-
+-def qpt(U, op_basis_list):
+-    """
+-    Calculate the quantum process tomography chi matrix for a given (possibly
+-    nonunitary) transformation matrix U, which transforms a density matrix in
+-    vector form according to:
+-
+-        vec(rho) = U * vec(rho0)
+-
+-        or
+-
+-        rho = unstack_columns(U * stack_columns(rho0))
+-
+-    U can be calculated for an open quantum system using the QuTiP propagator
+-    function.
+-
+-    Parameters
+-    ----------
+-    U : Qobj
+-        Transformation operator. Can be calculated using QuTiP propagator
+-        function.
+-
+-    op_basis_list : list
+-        A list of Qobj's representing the basis states.
+-
+-    Returns
+-    -------
+-    chi : array
+-        QPT chi matrix
+-
+-    """
+-
+-    E_ops = []
+-    # loop over all index permutations
+-    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
+-        # loop over all composite systems
+-        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
+-            op_basis_list))]
+-        E_ops.append(tensor(E_op_list))
+-    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
+-    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
+-    Uvec = U.full().ravel('F')
+-    chi_vec = la.solve(M, Uvec)
+-    return chi_vec.reshape(U.shape).T
++__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
++
++from numpy import hstack, real, imag
++import scipy.linalg as la
++from . import tensor, spre, spost, stack_columns, unstack_columns
++from .visualization import matrix_histogram, matrix_histogram_complex
++
++try:
++    import matplotlib.pyplot as plt
++except:
++    pass
++
++
++def _index_permutations(size_list, perm=[]):
++    """
++    Generate a list with all index permutations.
++
++    Parameters
++    ----------
++    size_list : list
++        A list that contains the sizes for each composite system.
++    perm : list
++        A list of permutations
++
++    Returns
++    -------
++    perm_idx : list
++        List containing index permutations.
++
++
++    """
++    if len(size_list) == 0:
++        yield perm
++    else:
++        for n in range(size_list[0]):
++            for ip in _index_permutations(size_list[1:], perm + [n]):
++                yield ip
++
++
++def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
++    """
++    Visualize the quantum process tomography chi matrix. Plot the real and
++    imaginary parts separately.
++
++    Parameters
++    ----------
++    chi : array
++        Input QPT chi matrix.
++    lbls_list : list
++        List of labels for QPT plot axes.
++    title : string
++        Plot title.
++    fig : figure instance
++        User defined figure instance used for generating QPT plot.
++    axes : list of figure axis instance
++        User defined figure axis instance (list of two axes) used for
++        generating QPT plot.
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    """
++
++    if axes is None or len(axes) != 2:
++        if fig is None:
++            fig = plt.figure(figsize=(16, 8))
++
++        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
++        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
++
++        axes = [ax1, ax2]
++
++    xlabels = []
++    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
++        xlabels.append("".join([lbls_list[k][inds[k]]
++                                for k in range(len(lbls_list))]))
++
++    matrix_histogram(real(chi), xlabels, xlabels,
++                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
++    matrix_histogram(imag(chi), xlabels, xlabels,
++                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
++
++    if title and fig:
++        fig.suptitle(title)
++
++    return fig, axes
++
++
++def qpt_plot_combined(chi, lbls_list, title=None,
++                      fig=None, ax=None, figsize=(8, 6),
++                      threshold=None):
++    """
++    Visualize the quantum process tomography chi matrix. Plot bars with
++    height and color corresponding to the absolute value and phase,
++    respectively.
++
++    Parameters
++    ----------
++    chi : array
++        Input QPT chi matrix.
++
++    lbls_list : list
++        List of labels for QPT plot axes.
++
++    title : string
++        Plot title.
++
++    fig : figure instance
++        User defined figure instance used for generating QPT plot.
++
++    ax : figure axis instance
++        User defined figure axis instance used for generating QPT plot
++        (alternative to the fig argument).
++
++    threshold: float (None)
++        Threshold for when bars of smaller height should be transparent. If
++        not set, all bars are colored according to the color map.
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++
++    if ax is None:
++        if fig is None:
++            fig = plt.figure(figsize=figsize)
++        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
++
++    xlabels = []
++    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
++        xlabels.append("".join(
++            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
++
++    if not title:
++        title = r"$\chi$"
++
++    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
++                             threshold=threshold)
++
++    return fig, ax
++
++
++def qpt(U, op_basis_list):
++    """
++    Calculate the quantum process tomography chi matrix for a given (possibly
++    nonunitary) transformation matrix U, which transforms a density matrix in
++    vector form according to:
++
++        vec(rho) = U * vec(rho0)
++
++        or
++
++        rho = unstack_columns(U * stack_columns(rho0))
++
++    U can be calculated for an open quantum system using the QuTiP propagator
++    function.
++
++    Parameters
++    ----------
++    U : Qobj
++        Transformation operator. Can be calculated using QuTiP propagator
++        function.
++
++    op_basis_list : list
++        A list of Qobj's representing the basis states.
++
++    Returns
++    -------
++    chi : array
++        QPT chi matrix
++
++    """
++
++    E_ops = []
++    # loop over all index permutations
++    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
++        # loop over all composite systems
++        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
++            op_basis_list))]
++        E_ops.append(tensor(E_op_list))
++    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
++    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
++    Uvec = U.full().ravel('F')
++    chi_vec = la.solve(M, Uvec)
++    return chi_vec.reshape(U.shape).T
+diff --git a/qutip/ui/__init__.py b/qutip/ui/__init__.py
+index d9fdd468..a640ed1f 100644
+--- a/qutip/ui/__init__.py
++++ b/qutip/ui/__init__.py
+@@ -1 +1 @@
+-from qutip.ui.progressbar import *
++from qutip.ui.progressbar import *
+diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
+index 8bebca70..a862a24d 100644
+--- a/qutip/ui/progressbar.py
++++ b/qutip/ui/progressbar.py
+@@ -1,212 +1,212 @@
+-__all__ = ['BaseProgressBar', 'TextProgressBar',
+-           'EnhancedTextProgressBar', 'TqdmProgressBar',
+-           'HTMLProgressBar', 'progess_bars']
+-
+-import time
+-import datetime
+-import sys
+-
+-
+-class BaseProgressBar(object):
+-    """
+-    An abstract progress bar with some shared functionality.
+-
+-    Example usage:
+-
+-        n_vec = linspace(0, 10, 100)
+-        pbar = TextProgressBar(len(n_vec))
+-        for n in n_vec:
+-            pbar.update(n)
+-            compute_with_n(n)
+-        pbar.finished()
+-
+-    """
+-
+-    def __init__(self, iterations=0, chunk_size=10):
+-        pass
+-
+-    def start(self, iterations, chunk_size=10, **kwargs):
+-        self.N = float(iterations)
+-        self.n = 0
+-        self.p_chunk_size = chunk_size
+-        self.p_chunk = chunk_size
+-        self.t_start = time.time()
+-        self.t_done = self.t_start - 1
+-
+-    def update(self, n=None):
+-        pass
+-
+-    def total_time(self):
+-        return self.t_done - self.t_start
+-
+-    def time_elapsed(self):
+-        return "%6.2fs" % (time.time() - self.t_start)
+-
+-    def time_remaining_est(self, p):
+-        if p > 0.0:
+-            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
+-        else:
+-            t_r_est = 0
+-
+-        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
+-        time_string = "%02d:%02d:%02d:%02d" % \
+-            (dd.day - 1, dd.hour, dd.minute, dd.second)
+-
+-        return time_string
+-
+-    def finished(self):
+-        self.t_done = time.time()
+-
+-
+-class TextProgressBar(BaseProgressBar):
+-    """
+-    A simple text-based progress bar.
+-    """
+-
+-    def __init__(self, iterations=0, chunk_size=10):
+-        pass
+-        # super(TextProgressBar, self).start(iterations, chunk_size)
+-
+-    def start(self, iterations, chunk_size=10, **kwargs):
+-        super(TextProgressBar, self).start(iterations, chunk_size)
+-
+-    def update(self, n=None):
+-        self.n += 1
+-        n = self.n
+-        p = (n / self.N) * 100.0
+-        if p >= self.p_chunk:
+-            print("%4.1f%%." % p +
+-                  " Run time: %s." % self.time_elapsed() +
+-                  " Est. time left: %s" % self.time_remaining_est(p))
+-            sys.stdout.flush()
+-            self.p_chunk += self.p_chunk_size
+-
+-    def finished(self):
+-        self.t_done = time.time()
+-        print("Total run time: %s" % self.time_elapsed())
+-
+-
+-class EnhancedTextProgressBar(BaseProgressBar):
+-    """
+-    An enhanced text-based progress bar.
+-    """
+-
+-    def __init__(self, iterations=0, chunk_size=10):
+-        pass
+-        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+-
+-    def start(self, iterations, chunk_size=10, **kwargs):
+-        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+-        self.fill_char = '*'
+-        self.width = 25
+-
+-    def update(self, n=None):
+-        self.n += 1
+-        n = self.n
+-        percent_done = int(round(n / self.N * 100.0))
+-        all_full = self.width - 2
+-        num_hashes = int(round((percent_done / 100.0) * all_full))
+-        prog_bar = ('[' + self.fill_char * num_hashes +
+-                    ' ' * (all_full - num_hashes) + ']')
+-        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
+-        pct_string = '%d%%' % percent_done
+-        prog_bar = (prog_bar[0:pct_place] +
+-                    (pct_string + prog_bar[pct_place + len(pct_string):]))
+-        prog_bar += ' Elapsed %s / Remaining %s' % (
+-            self.time_elapsed().strip(),
+-            self.time_remaining_est(percent_done))
+-        print('\r', prog_bar, end='')
+-        sys.stdout.flush()
+-
+-    def finished(self):
+-        self.t_done = time.time()
+-        print("\r", "Total run time: %s" % self.time_elapsed())
+-
+-
+-class TqdmProgressBar(BaseProgressBar):
+-    """
+-    A progress bar using tqdm module
+-    """
+-
+-    def __init__(self, iterations=0, chunk_size=10):
+-        from tqdm.auto import tqdm
+-        self.tqdm = tqdm
+-
+-    def start(self, iterations, **kwargs):
+-        self.pbar = self.tqdm(total=iterations, **kwargs)
+-        self.t_start = time.time()
+-        self.t_done = self.t_start - 1
+-
+-    def update(self, n=None):
+-        self.pbar.update()
+-
+-    def finished(self):
+-        self.pbar.close()
+-        self.t_done = time.time()
+-
+-
+-class HTMLProgressBar(BaseProgressBar):
+-    """
+-    A simple HTML progress bar for using in IPython notebooks. Based on
+-    IPython ProgressBar demo notebook:
+-    https://github.com/ipython/ipython/tree/master/examples/notebooks
+-
+-    Example usage:
+-
+-        n_vec = linspace(0, 10, 100)
+-        pbar = HTMLProgressBar(len(n_vec))
+-        for n in n_vec:
+-            pbar.update(n)
+-            compute_with_n(n)
+-    """
+-
+-    def __init__(self, iterations=0, chunk_size=1.0):
+-        self.divid = str(uuid.uuid4())
+-        self.textid = str(uuid.uuid4())
+-        self.pb = HTML("""\
+-<div style="border: 2px solid grey; width: 600px">
+-  <div id="%s" \
+-style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
+-</div>
+-<p id="%s"></p>
+-""" % (self.divid, self.textid))
+-        display(self.pb)
+-        super(HTMLProgressBar, self).start(iterations, chunk_size)
+-
+-    def start(self, iterations=0, chunk_size=1.0):
+-        super(HTMLProgressBar, self).start(iterations, chunk_size)
+-
+-    def update(self, n):
+-        p = (n / self.N) * 100.0
+-        if p >= self.p_chunk:
+-            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
+-                   "Est. remaining time: %s." % self.time_remaining_est(p))
+-            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
+-                       "$('p#%s').text('%s');" % (self.textid, lbl))
+-            display(Javascript(js_code))
+-            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
+-            # p)))
+-            self.p_chunk += self.p_chunk_size
+-
+-    def finished(self):
+-        self.t_done = time.time()
+-        lbl = "Elapsed time: %s" % self.time_elapsed()
+-        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
+-                   "$('p#%s').text('%s');" % (self.textid, lbl))
+-        display(Javascript(js_code))
+-
+-
+-progess_bars = {
+-    "Enhanced": EnhancedTextProgressBar,
+-    "enhanced": EnhancedTextProgressBar,
+-    "Text": TextProgressBar,
+-    "text": TextProgressBar,
+-    True: TextProgressBar,
+-    "Tqdm": TqdmProgressBar,
+-    "tqdm": TqdmProgressBar,
+-    "Html": HTMLProgressBar,
+-    "html": HTMLProgressBar,
+-    "": BaseProgressBar,
+-    False: BaseProgressBar,
+-    None: BaseProgressBar,
+-}
++__all__ = ['BaseProgressBar', 'TextProgressBar',
++           'EnhancedTextProgressBar', 'TqdmProgressBar',
++           'HTMLProgressBar', 'progess_bars']
++
++import time
++import datetime
++import sys
++
++
++class BaseProgressBar(object):
++    """
++    An abstract progress bar with some shared functionality.
++
++    Example usage:
++
++        n_vec = linspace(0, 10, 100)
++        pbar = TextProgressBar(len(n_vec))
++        for n in n_vec:
++            pbar.update(n)
++            compute_with_n(n)
++        pbar.finished()
++
++    """
++
++    def __init__(self, iterations=0, chunk_size=10):
++        pass
++
++    def start(self, iterations, chunk_size=10, **kwargs):
++        self.N = float(iterations)
++        self.n = 0
++        self.p_chunk_size = chunk_size
++        self.p_chunk = chunk_size
++        self.t_start = time.time()
++        self.t_done = self.t_start - 1
++
++    def update(self, n=None):
++        pass
++
++    def total_time(self):
++        return self.t_done - self.t_start
++
++    def time_elapsed(self):
++        return "%6.2fs" % (time.time() - self.t_start)
++
++    def time_remaining_est(self, p):
++        if p > 0.0:
++            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
++        else:
++            t_r_est = 0
++
++        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
++        time_string = "%02d:%02d:%02d:%02d" % \
++            (dd.day - 1, dd.hour, dd.minute, dd.second)
++
++        return time_string
++
++    def finished(self):
++        self.t_done = time.time()
++
++
++class TextProgressBar(BaseProgressBar):
++    """
++    A simple text-based progress bar.
++    """
++
++    def __init__(self, iterations=0, chunk_size=10):
++        pass
++        # super(TextProgressBar, self).start(iterations, chunk_size)
++
++    def start(self, iterations, chunk_size=10, **kwargs):
++        super(TextProgressBar, self).start(iterations, chunk_size)
++
++    def update(self, n=None):
++        self.n += 1
++        n = self.n
++        p = (n / self.N) * 100.0
++        if p >= self.p_chunk:
++            print("%4.1f%%." % p +
++                  " Run time: %s." % self.time_elapsed() +
++                  " Est. time left: %s" % self.time_remaining_est(p))
++            sys.stdout.flush()
++            self.p_chunk += self.p_chunk_size
++
++    def finished(self):
++        self.t_done = time.time()
++        print("Total run time: %s" % self.time_elapsed())
++
++
++class EnhancedTextProgressBar(BaseProgressBar):
++    """
++    An enhanced text-based progress bar.
++    """
++
++    def __init__(self, iterations=0, chunk_size=10):
++        pass
++        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
++
++    def start(self, iterations, chunk_size=10, **kwargs):
++        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
++        self.fill_char = '*'
++        self.width = 25
++
++    def update(self, n=None):
++        self.n += 1
++        n = self.n
++        percent_done = int(round(n / self.N * 100.0))
++        all_full = self.width - 2
++        num_hashes = int(round((percent_done / 100.0) * all_full))
++        prog_bar = ('[' + self.fill_char * num_hashes +
++                    ' ' * (all_full - num_hashes) + ']')
++        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
++        pct_string = '%d%%' % percent_done
++        prog_bar = (prog_bar[0:pct_place] +
++                    (pct_string + prog_bar[pct_place + len(pct_string):]))
++        prog_bar += ' Elapsed %s / Remaining %s' % (
++            self.time_elapsed().strip(),
++            self.time_remaining_est(percent_done))
++        print('\r', prog_bar, end='')
++        sys.stdout.flush()
++
++    def finished(self):
++        self.t_done = time.time()
++        print("\r", "Total run time: %s" % self.time_elapsed())
++
++
++class TqdmProgressBar(BaseProgressBar):
++    """
++    A progress bar using tqdm module
++    """
++
++    def __init__(self, iterations=0, chunk_size=10):
++        from tqdm.auto import tqdm
++        self.tqdm = tqdm
++
++    def start(self, iterations, **kwargs):
++        self.pbar = self.tqdm(total=iterations, **kwargs)
++        self.t_start = time.time()
++        self.t_done = self.t_start - 1
++
++    def update(self, n=None):
++        self.pbar.update()
++
++    def finished(self):
++        self.pbar.close()
++        self.t_done = time.time()
++
++
++class HTMLProgressBar(BaseProgressBar):
++    """
++    A simple HTML progress bar for using in IPython notebooks. Based on
++    IPython ProgressBar demo notebook:
++    https://github.com/ipython/ipython/tree/master/examples/notebooks
++
++    Example usage:
++
++        n_vec = linspace(0, 10, 100)
++        pbar = HTMLProgressBar(len(n_vec))
++        for n in n_vec:
++            pbar.update(n)
++            compute_with_n(n)
++    """
++
++    def __init__(self, iterations=0, chunk_size=1.0):
++        self.divid = str(uuid.uuid4())
++        self.textid = str(uuid.uuid4())
++        self.pb = HTML("""\
++<div style="border: 2px solid grey; width: 600px">
++  <div id="%s" \
++style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
++</div>
++<p id="%s"></p>
++""" % (self.divid, self.textid))
++        display(self.pb)
++        super(HTMLProgressBar, self).start(iterations, chunk_size)
++
++    def start(self, iterations=0, chunk_size=1.0):
++        super(HTMLProgressBar, self).start(iterations, chunk_size)
++
++    def update(self, n):
++        p = (n / self.N) * 100.0
++        if p >= self.p_chunk:
++            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
++                   "Est. remaining time: %s." % self.time_remaining_est(p))
++            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
++                       "$('p#%s').text('%s');" % (self.textid, lbl))
++            display(Javascript(js_code))
++            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
++            # p)))
++            self.p_chunk += self.p_chunk_size
++
++    def finished(self):
++        self.t_done = time.time()
++        lbl = "Elapsed time: %s" % self.time_elapsed()
++        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
++                   "$('p#%s').text('%s');" % (self.textid, lbl))
++        display(Javascript(js_code))
++
++
++progess_bars = {
++    "Enhanced": EnhancedTextProgressBar,
++    "enhanced": EnhancedTextProgressBar,
++    "Text": TextProgressBar,
++    "text": TextProgressBar,
++    True: TextProgressBar,
++    "Tqdm": TqdmProgressBar,
++    "tqdm": TqdmProgressBar,
++    "Html": HTMLProgressBar,
++    "html": HTMLProgressBar,
++    "": BaseProgressBar,
++    False: BaseProgressBar,
++    None: BaseProgressBar,
++}
+diff --git a/qutip/utilities.py b/qutip/utilities.py
+index 8d638307..5413730a 100644
+--- a/qutip/utilities.py
++++ b/qutip/utilities.py
+@@ -1,332 +1,332 @@
+-"""
+-This module contains utility functions that are commonly needed in other
+-qutip modules.
+-"""
+-
+-__all__ = ['n_thermal', 'clebsch', 'convert_unit']
+-
+-import numpy as np
+-
+-def n_thermal(w, w_th):
+-    """
+-    Return the number of photons in thermal equilibrium for an harmonic
+-    oscillator mode with frequency 'w', at the temperature described by
+-    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
+-
+-    Parameters
+-    ----------
+-
+-    w : *float* or *array*
+-        Frequency of the oscillator.
+-
+-    w_th : *float*
+-        The temperature in units of frequency (or the same units as `w`).
+-
+-
+-    Returns
+-    -------
+-
+-    n_avg : *float* or *array*
+-
+-        Return the number of average photons in thermal equilibrium for a
+-        an oscillator with the given frequency and temperature.
+-
+-
+-    """
+-
+-    if isinstance(w, np.ndarray):
+-        return 1.0 / (np.exp(w / w_th) - 1.0)
+-
+-    else:
+-        if (w_th > 0) and np.exp(w / w_th) != 1.0:
+-            return 1.0 / (np.exp(w / w_th) - 1.0)
+-        else:
+-            return 0.0
+-
+-
+-def _factorial_prod(N, arr):
+-    arr[:int(N)] += 1
+-
+-
+-def _factorial_div(N, arr):
+-    arr[:int(N)] -= 1
+-
+-
+-def _to_long(arr):
+-    prod = 1
+-    for i, v in enumerate(arr):
+-        prod *= (i+1)**int(v)
+-    return prod
+-
+-
+-def clebsch(j1, j2, j3, m1, m2, m3):
+-    """Calculates the Clebsch-Gordon coefficient
+-    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
+-
+-    Parameters
+-    ----------
+-    j1 : float
+-        Total angular momentum 1.
+-
+-    j2 : float
+-        Total angular momentum 2.
+-
+-    j3 : float
+-        Total angular momentum 3.
+-
+-    m1 : float
+-        z-component of angular momentum 1.
+-
+-    m2 : float
+-        z-component of angular momentum 2.
+-
+-    m3 : float
+-        z-component of angular momentum 3.
+-
+-    Returns
+-    -------
+-    cg_coeff : float
+-        Requested Clebsch-Gordan coefficient.
+-
+-    """
+-    if m3 != m1 + m2:
+-        return 0
+-    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
+-    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
+-
+-    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
+-    _factorial_prod(j3 + j1 - j2, c_factor)
+-    _factorial_prod(j3 - j1 + j2, c_factor)
+-    _factorial_prod(j1 + j2 - j3, c_factor)
+-    _factorial_prod(j3 + m3, c_factor)
+-    _factorial_prod(j3 - m3, c_factor)
+-    _factorial_div(j1 + j2 + j3 + 1, c_factor)
+-    _factorial_div(j1 - m1, c_factor)
+-    _factorial_div(j1 + m1, c_factor)
+-    _factorial_div(j2 - m2, c_factor)
+-    _factorial_div(j2 + m2, c_factor)
+-    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
+-
+-    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
+-    sign = (-1) ** (vmin + j2 + m2)
+-    for i,v in enumerate(range(vmin, vmax + 1)):
+-        factor = s_factors[i,:]
+-        _factorial_prod(j2 + j3 + m1 - v, factor)
+-        _factorial_prod(j1 - m1 + v, factor)
+-        _factorial_div(j3 - j1 + j2 - v, factor)
+-        _factorial_div(j3 + m3 - v, factor)
+-        _factorial_div(v + j1 - j2 - m3, factor)
+-        _factorial_div(v, factor)
+-    common_denominator = -np.min(s_factors, axis=0)
+-    numerators = s_factors + common_denominator
+-    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
+-        sign / _to_long(common_denominator)
+-    return C * S
+-
+-
+-# -----------------------------------------------------------------------------
+-# Functions for unit conversions
+-#
+-_e = 1.602176565e-19  # C
+-_kB = 1.3806488e-23   # J/K
+-_h = 6.62606957e-34   # Js
+-
+-_unit_factor_tbl = {
+-    #   "unit": "factor that convert argument from unit 'unit' to Joule"
+-    "J": 1.0,
+-    "eV": _e,
+-    "meV": 1.0e-3 * _e,
+-    "GHz": 1.0e9 * _h,
+-    "mK": 1.0e-3 * _kB,
+-}
+-
+-
+-def convert_unit(value, orig="meV", to="GHz"):
+-    """
+-    Convert an energy from unit `orig` to unit `to`.
+-
+-    Parameters
+-    ----------
+-    value : float / array
+-        The energy in the old unit.
+-
+-    orig : string
+-        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
+-
+-    to : string
+-        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
+-
+-    Returns
+-    -------
+-    value_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    if orig not in _unit_factor_tbl:
+-        raise TypeError("Unsupported unit %s" % orig)
+-
+-    if to not in _unit_factor_tbl:
+-        raise TypeError("Unsupported unit %s" % to)
+-
+-    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
+-
+-
+-def convert_GHz_to_meV(w):
+-    """
+-    Convert an energy from unit GHz to unit meV.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
+-    w_meV = w * 4.1357e-3
+-    return w_meV
+-
+-
+-def convert_meV_to_GHz(w):
+-    """
+-    Convert an energy from unit meV to unit GHz.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # 1 meV = 1.0/4.1357e-3 GHz
+-    w_GHz = w / 4.1357e-3
+-    return w_GHz
+-
+-
+-def convert_J_to_meV(w):
+-    """
+-    Convert an energy from unit J to unit meV.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # 1 eV = 1.602e-19 J
+-    w_meV = 1000.0 * w / _e
+-    return w_meV
+-
+-
+-def convert_meV_to_J(w):
+-    """
+-    Convert an energy from unit meV to unit J.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # 1 eV = 1.602e-19 J
+-    w_J = 0.001 * w * _e
+-    return w_J
+-
+-
+-def convert_meV_to_mK(w):
+-    """
+-    Convert an energy from unit meV to unit mK.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # 1 mK = 0.0000861740 meV
+-    w_mK = w / 0.0000861740
+-    return w_mK
+-
+-
+-def convert_mK_to_meV(w):
+-    """
+-    Convert an energy from unit mK to unit meV.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # 1 mK = 0.0000861740 meV
+-    w_meV = w * 0.0000861740
+-    return w_meV
+-
+-
+-def convert_GHz_to_mK(w):
+-    """
+-    Convert an energy from unit GHz to unit mK.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-    """
+-    # h v [Hz] = kB T [K]
+-    # h 1e9 v [GHz] = kB 1e-3 T [mK]
+-    # T [mK] = 1e12 * (h/kB) * v [GHz]
+-    w_mK = w * 1.0e12 * (_h / _kB)
+-    return w_mK
+-
+-
+-def convert_mK_to_GHz(w):
+-    """
+-    Convert an energy from unit mK to unit GHz.
+-
+-    Parameters
+-    ----------
+-    w : float / array
+-        The energy in the old unit.
+-
+-    Returns
+-    -------
+-    w_new_unit : float / array
+-        The energy in the new unit.
+-
+-    """
+-    w_GHz = w * 1.0e-12 * (_kB / _h)
+-    return w_GHz
+-
+-
+-def _version2int(version_string):
+-    str_list = version_string.split(
+-        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
+-        "post")[0].split('.')
+-    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
+-                for n, d in enumerate(str_list[:3])])
++"""
++This module contains utility functions that are commonly needed in other
++qutip modules.
++"""
++
++__all__ = ['n_thermal', 'clebsch', 'convert_unit']
++
++import numpy as np
++
++def n_thermal(w, w_th):
++    """
++    Return the number of photons in thermal equilibrium for an harmonic
++    oscillator mode with frequency 'w', at the temperature described by
++    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
++
++    Parameters
++    ----------
++
++    w : *float* or *array*
++        Frequency of the oscillator.
++
++    w_th : *float*
++        The temperature in units of frequency (or the same units as `w`).
++
++
++    Returns
++    -------
++
++    n_avg : *float* or *array*
++
++        Return the number of average photons in thermal equilibrium for a
++        an oscillator with the given frequency and temperature.
++
++
++    """
++
++    if isinstance(w, np.ndarray):
++        return 1.0 / (np.exp(w / w_th) - 1.0)
++
++    else:
++        if (w_th > 0) and np.exp(w / w_th) != 1.0:
++            return 1.0 / (np.exp(w / w_th) - 1.0)
++        else:
++            return 0.0
++
++
++def _factorial_prod(N, arr):
++    arr[:int(N)] += 1
++
++
++def _factorial_div(N, arr):
++    arr[:int(N)] -= 1
++
++
++def _to_long(arr):
++    prod = 1
++    for i, v in enumerate(arr):
++        prod *= (i+1)**int(v)
++    return prod
++
++
++def clebsch(j1, j2, j3, m1, m2, m3):
++    """Calculates the Clebsch-Gordon coefficient
++    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
++
++    Parameters
++    ----------
++    j1 : float
++        Total angular momentum 1.
++
++    j2 : float
++        Total angular momentum 2.
++
++    j3 : float
++        Total angular momentum 3.
++
++    m1 : float
++        z-component of angular momentum 1.
++
++    m2 : float
++        z-component of angular momentum 2.
++
++    m3 : float
++        z-component of angular momentum 3.
++
++    Returns
++    -------
++    cg_coeff : float
++        Requested Clebsch-Gordan coefficient.
++
++    """
++    if m3 != m1 + m2:
++        return 0
++    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
++    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
++
++    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
++    _factorial_prod(j3 + j1 - j2, c_factor)
++    _factorial_prod(j3 - j1 + j2, c_factor)
++    _factorial_prod(j1 + j2 - j3, c_factor)
++    _factorial_prod(j3 + m3, c_factor)
++    _factorial_prod(j3 - m3, c_factor)
++    _factorial_div(j1 + j2 + j3 + 1, c_factor)
++    _factorial_div(j1 - m1, c_factor)
++    _factorial_div(j1 + m1, c_factor)
++    _factorial_div(j2 - m2, c_factor)
++    _factorial_div(j2 + m2, c_factor)
++    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
++
++    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
++    sign = (-1) ** (vmin + j2 + m2)
++    for i,v in enumerate(range(vmin, vmax + 1)):
++        factor = s_factors[i,:]
++        _factorial_prod(j2 + j3 + m1 - v, factor)
++        _factorial_prod(j1 - m1 + v, factor)
++        _factorial_div(j3 - j1 + j2 - v, factor)
++        _factorial_div(j3 + m3 - v, factor)
++        _factorial_div(v + j1 - j2 - m3, factor)
++        _factorial_div(v, factor)
++    common_denominator = -np.min(s_factors, axis=0)
++    numerators = s_factors + common_denominator
++    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
++        sign / _to_long(common_denominator)
++    return C * S
++
++
++# -----------------------------------------------------------------------------
++# Functions for unit conversions
++#
++_e = 1.602176565e-19  # C
++_kB = 1.3806488e-23   # J/K
++_h = 6.62606957e-34   # Js
++
++_unit_factor_tbl = {
++    #   "unit": "factor that convert argument from unit 'unit' to Joule"
++    "J": 1.0,
++    "eV": _e,
++    "meV": 1.0e-3 * _e,
++    "GHz": 1.0e9 * _h,
++    "mK": 1.0e-3 * _kB,
++}
++
++
++def convert_unit(value, orig="meV", to="GHz"):
++    """
++    Convert an energy from unit `orig` to unit `to`.
++
++    Parameters
++    ----------
++    value : float / array
++        The energy in the old unit.
++
++    orig : string
++        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
++
++    to : string
++        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
++
++    Returns
++    -------
++    value_new_unit : float / array
++        The energy in the new unit.
++    """
++    if orig not in _unit_factor_tbl:
++        raise TypeError("Unsupported unit %s" % orig)
++
++    if to not in _unit_factor_tbl:
++        raise TypeError("Unsupported unit %s" % to)
++
++    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
++
++
++def convert_GHz_to_meV(w):
++    """
++    Convert an energy from unit GHz to unit meV.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
++    w_meV = w * 4.1357e-3
++    return w_meV
++
++
++def convert_meV_to_GHz(w):
++    """
++    Convert an energy from unit meV to unit GHz.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # 1 meV = 1.0/4.1357e-3 GHz
++    w_GHz = w / 4.1357e-3
++    return w_GHz
++
++
++def convert_J_to_meV(w):
++    """
++    Convert an energy from unit J to unit meV.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # 1 eV = 1.602e-19 J
++    w_meV = 1000.0 * w / _e
++    return w_meV
++
++
++def convert_meV_to_J(w):
++    """
++    Convert an energy from unit meV to unit J.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # 1 eV = 1.602e-19 J
++    w_J = 0.001 * w * _e
++    return w_J
++
++
++def convert_meV_to_mK(w):
++    """
++    Convert an energy from unit meV to unit mK.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # 1 mK = 0.0000861740 meV
++    w_mK = w / 0.0000861740
++    return w_mK
++
++
++def convert_mK_to_meV(w):
++    """
++    Convert an energy from unit mK to unit meV.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # 1 mK = 0.0000861740 meV
++    w_meV = w * 0.0000861740
++    return w_meV
++
++
++def convert_GHz_to_mK(w):
++    """
++    Convert an energy from unit GHz to unit mK.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++    """
++    # h v [Hz] = kB T [K]
++    # h 1e9 v [GHz] = kB 1e-3 T [mK]
++    # T [mK] = 1e12 * (h/kB) * v [GHz]
++    w_mK = w * 1.0e12 * (_h / _kB)
++    return w_mK
++
++
++def convert_mK_to_GHz(w):
++    """
++    Convert an energy from unit mK to unit GHz.
++
++    Parameters
++    ----------
++    w : float / array
++        The energy in the old unit.
++
++    Returns
++    -------
++    w_new_unit : float / array
++        The energy in the new unit.
++
++    """
++    w_GHz = w * 1.0e-12 * (_kB / _h)
++    return w_GHz
++
++
++def _version2int(version_string):
++    str_list = version_string.split(
++        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
++        "post")[0].split('.')
++    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
++                for n, d in enumerate(str_list[:3])])
+diff --git a/qutip/visualization.py b/qutip/visualization.py
+index 27fe62c6..3262da18 100644
+--- a/qutip/visualization.py
++++ b/qutip/visualization.py
+@@ -1,1819 +1,1819 @@
+-"""
+-Functions for visualizing results of quantum dynamics simulations,
+-visualizations of quantum states and processes.
+-"""
+-
+-__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
+-           'plot_energy_levels', 'fock_distribution',
+-           'plot_fock_distribution', 'wigner_fock_distribution',
+-           'plot_wigner_fock_distribution', 'plot_wigner',
+-           'plot_expectation_values', 'plot_spin_distribution_2d',
+-           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
+-           'complex_array_to_rgb', 'matrix_histogram',
+-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
+-
+-import warnings
+-import itertools as it
+-import numpy as np
+-from numpy import pi, array, sin, cos, angle, log2
+-
+-from packaging.version import parse as parse_version
+-
+-from . import (
+-    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
+-)
+-from .core.dimensions import flatten
+-from .core.superop_reps import _to_superpauli, isqubitdims
+-from .wigner import wigner
+-from .matplotlib_utilities import complex_phase_cmap
+-
+-try:
+-    import matplotlib.pyplot as plt
+-    import matplotlib as mpl
+-    from matplotlib import cm
+-    from mpl_toolkits.mplot3d import Axes3D
+-
+-    # Define a custom _axes3D function based on the matplotlib version.
+-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+-    if parse_version(mpl.__version__) >= parse_version('3.4'):
+-        def _axes3D(fig, *args, **kwargs):
+-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+-            return fig.add_axes(ax)
+-    else:
+-        def _axes3D(*args, **kwargs):
+-            return Axes3D(*args, **kwargs)
+-except:
+-    pass
+-
+-
+-def plot_wigner_sphere(fig, ax, wigner, reflections):
+-    """Plots a coloured Bloch sphere.
+-
+-    Parameters
+-    ----------
+-    fig : :obj:`matplotlib.figure.Figure`
+-        An instance of :obj:`~matplotlib.figure.Figure`.
+-    ax : :obj:`matplotlib.axes.Axes`
+-        An axes instance in the given figure.
+-    wigner : list of float
+-        The wigner transformation at `steps` different theta and phi.
+-    reflections : bool
+-        If the reflections of the sphere should be plotted as well.
+-
+-    Notes
+-    -----
+-    Special thanks to Russell P Rundle for writing this function.
+-    """
+-    ax.set_xlabel("x")
+-    ax.set_ylabel("y")
+-    ax.set_zlabel("z")
+-
+-    steps = len(wigner)
+-
+-    theta = np.linspace(0, np.pi, steps)
+-    phi = np.linspace(0, 2 * np.pi, steps)
+-    x = np.outer(np.sin(theta), np.cos(phi))
+-    y = np.outer(np.sin(theta), np.sin(phi))
+-    z = np.outer(np.cos(theta), np.ones(steps))
+-    wigner = np.real(wigner)
+-    wigner_max = np.real(np.amax(np.abs(wigner)))
+-
+-    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
+-
+-    # Plot coloured Bloch sphere:
+-    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
+-                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
+-                    zorder=0.5, antialiased=None)
+-
+-    if reflections:
+-        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+-                                 (2*wigner_max))  # bottom
+-        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+-                                 (2*wigner_max))  # side
+-        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+-                                 (2*wigner_max))  # back
+-
+-        # Plot bottom reflection:
+-        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
+-                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
+-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+-                        ccount=steps/2, linewidth=0, zorder=0.5,
+-                        antialiased=False)
+-
+-        # Plot side reflection:
+-        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
+-                        z[0:steps, 0:steps], facecolors=wigner_c3,
+-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+-                        ccount=steps/2, linewidth=0, zorder=0.5,
+-                        antialiased=False)
+-
+-        # Plot back reflection:
+-        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
+-                        z[0:steps, 0:steps], facecolors=wigner_c4,
+-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+-                        ccount=steps/2, linewidth=0, zorder=0.5,
+-                        antialiased=False)
+-
+-    # Create colourbar:
+-    m = cm.ScalarMappable(cmap=cm.seismic_r)
+-    m.set_array([-wigner_max, wigner_max])
+-    plt.colorbar(m, shrink=0.5, aspect=10)
+-
+-    plt.show()
+-
+-
+-# Adopted from the SciPy Cookbook.
+-def _blob(x, y, w, w_max, area, color_fn, ax=None):
+-    """
+-    Draws a square-shaped blob with the given area (< 1) at
+-    the given coordinates.
+-    """
+-    hs = np.sqrt(area) / 2
+-    xcorners = array([x - hs, x + hs, x + hs, x - hs])
+-    ycorners = array([y - hs, y - hs, y + hs, y + hs])
+-
+-    if ax is not None:
+-        handle = ax
+-    else:
+-        handle = plt
+-
+-    handle.fill(xcorners, ycorners,
+-             color=color_fn(w))
+-
+-
+-def _cb_labels(left_dims):
+-    """Creates plot labels for matrix elements in the computational basis.
+-
+-    Parameters
+-    ----------
+-    left_dims : flat list of ints
+-        Dimensions of the left index of a density operator. E. g.
+-        [2, 3] for a qubit tensored with a qutrit.
+-
+-    Returns
+-    -------
+-    left_labels, right_labels : lists of strings
+-        Labels for the left and right indices of a density operator
+-        (kets and bras, respectively).
+-    """
+-    # FIXME: assumes dims, such that we only need left_dims == dims[0].
+-    basis_labels = list(map(",".join, it.product(*[
+-        map(str, range(dim))
+-        for dim in left_dims
+-    ])))
+-    return [
+-        map(fmt.format, basis_labels) for fmt in
+-        (
+-            r"$\langle{}|$",
+-            r"$|{}\rangle$",
+-        )
+-    ]
+-
+-
+-# Adopted from the SciPy Cookbook.
+-def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
+-           label_top=True, color_style="scaled"):
+-    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        Input density matrix or superoperator.
+-
+-    xlabels : list of strings or False
+-        list of x labels
+-
+-    ylabels : list of strings or False
+-        list of y labels
+-
+-    title : string
+-        title of the plot (optional)
+-
+-    ax : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    cmap : a matplotlib colormap instance
+-        Color map to use when plotting.
+-
+-    label_top : bool
+-        If True, x-axis labels will be placed on top, otherwise
+-        they will appear below the plot.
+-
+-    color_style : string
+-        Determines how colors are assigned to each square:
+-
+-        -  If set to ``"scaled"`` (default), each color is chosen by
+-           passing the absolute value of the corresponding matrix
+-           element into `cmap` with the sign of the real part.
+-        -  If set to ``"threshold"``, each square is plotted as
+-           the maximum of `cmap` for the positive real part and as
+-           the minimum for the negative part of the matrix element;
+-           note that this generalizes `"threshold"` to complex numbers.
+-        -  If set to ``"phase"``, each color is chosen according to
+-           the angle of the corresponding matrix element.
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    Raises
+-    ------
+-    ValueError
+-        Input argument is not a quantum object.
+-
+-    Examples
+-    --------
+-    >>> import qutip
+-    >>>
+-    >>> dm = qutip.rand_dm(4)
+-    >>> fig, ax = qutip.hinton(dm)
+-    >>> fig.show()
+-    >>>
+-    >>> qutip.settings.colorblind_safe = True
+-    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
+-    >>> fig.show()
+-    >>> qutip.settings.colorblind_safe = False
+-    >>>
+-    >>> fig, ax = qutip.hinton(dm, color_style="phase")
+-    >>> fig.show()
+-    """
+-
+-    # Apply default colormaps.
+-    # TODO: abstract this away into something that makes default
+-    #       colormaps.
+-    cmap = (
+-        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
+-        if cmap is None else cmap
+-    )
+-
+-    # Extract plotting data W from the input.
+-    if isinstance(rho, Qobj):
+-        if rho.isoper:
+-            W = rho.full()
+-
+-            # Create default labels if none are given.
+-            if xlabels is None or ylabels is None:
+-                labels = _cb_labels(rho.dims[0])
+-                xlabels = xlabels if xlabels is not None else list(labels[0])
+-                ylabels = ylabels if ylabels is not None else list(labels[1])
+-
+-        elif rho.isoperket:
+-            W = vector_to_operator(rho).full()
+-        elif rho.isoperbra:
+-            W = vector_to_operator(rho.dag()).full()
+-        elif rho.issuper:
+-            if not isqubitdims(rho.dims):
+-                raise ValueError("Hinton plots of superoperators are "
+-                                 "currently only supported for qubits.")
+-            # Convert to a superoperator in the Pauli basis,
+-            # so that all the elements are real.
+-            sqobj = _to_superpauli(rho)
+-            nq = int(log2(sqobj.shape[0]) / 2)
+-            W = sqobj.full().T
+-            # Create default labels, too.
+-            if (xlabels is None) or (ylabels is None):
+-                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+-                xlabels = xlabels if xlabels is not None else labels
+-                ylabels = ylabels if ylabels is not None else labels
+-
+-        else:
+-            raise ValueError(
+-                "Input quantum object must be an operator or superoperator."
+-            )
+-
+-    else:
+-        W = rho
+-
+-    if ax is None:
+-        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
+-    else:
+-        fig = None
+-
+-    if not (xlabels or ylabels):
+-        ax.axis('off')
+-    if title:
+-        ax.set_title(title)
+-
+-    ax.axis('equal')
+-    ax.set_frame_on(False)
+-
+-    height, width = W.shape
+-
+-    w_max = 1.25 * max(abs(np.array(W)).flatten())
+-    if w_max <= 0.0:
+-        w_max = 1.0
+-
+-    # Set color_fn here.
+-    if color_style == "scaled":
+-        def color_fn(w):
+-            w = np.abs(w) * np.sign(np.real(w))
+-            return cmap(int((w + w_max) * 256 / (2 * w_max)))
+-    elif color_style == "threshold":
+-        def color_fn(w):
+-            w = np.real(w)
+-            return cmap(255 if w > 0 else 0)
+-    elif color_style == "phase":
+-        def color_fn(w):
+-            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
+-    else:
+-        raise ValueError(
+-            "Unknown color style {} for Hinton diagrams.".format(color_style)
+-        )
+-
+-    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
+-            color=cmap(128))
+-    for x in range(width):
+-        for y in range(height):
+-            _x = x + 1
+-            _y = y + 1
+-            _blob(
+-                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
+-                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
+-
+-    # color axis
+-    vmax = np.pi if color_style == "phase" else abs(W).max()
+-    norm = mpl.colors.Normalize(-vmax, vmax)
+-    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+-    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+-
+-    xtics = 0.5 + np.arange(width)
+-    # x axis
+-    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
+-    if xlabels:
+-        nxlabels = len(xlabels)
+-        if nxlabels != len(xtics):
+-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+-        ax.set_xticklabels(xlabels)
+-        if label_top:
+-            ax.xaxis.tick_top()
+-    ax.tick_params(axis='x', labelsize=14)
+-
+-    # y axis
+-    ytics = 0.5 + np.arange(height)
+-    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
+-    if ylabels:
+-        nylabels = len(ylabels)
+-        if nylabels != len(ytics):
+-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+-        ax.set_yticklabels(list(reversed(ylabels)))
+-    ax.tick_params(axis='y', labelsize=14)
+-
+-    return fig, ax
+-
+-
+-def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
+-    """Plots a matrix of values on a sphere
+-
+-    Parameters
+-    ----------
+-    theta : float
+-        Angle with respect to z-axis
+-
+-    phi : float
+-        Angle in x-y plane
+-
+-    values : array
+-        Data set to be plotted
+-
+-    fig : a matplotlib Figure instance
+-        The Figure canvas in which the plot will be drawn.
+-
+-    ax : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    save : bool {False , True}
+-        Whether to save the figure or not
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-    if fig is None or ax is None:
+-        fig = plt.figure()
+-        ax = _axes3D(fig)
+-
+-    thetam, phim = np.meshgrid(theta, phi)
+-    xx = sin(thetam) * cos(phim)
+-    yy = sin(thetam) * sin(phim)
+-    zz = cos(thetam)
+-    r = array(abs(values))
+-    ph = angle(values)
+-    # normalize color range based on phase angles in list ph
+-    nrm = mpl.colors.Normalize(ph.min(), ph.max())
+-
+-    # plot with facecolors set to cm.jet colormap normalized to nrm
+-    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
+-                    facecolors=cm.jet(nrm(ph)), linewidth=0)
+-    # create new axes on plot for colorbar and shrink it a bit.
+-    # pad shifts location of bar with repsect to the main plot
+-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+-
+-    # create new colorbar in axes cax with cm jet and normalized to nrm like
+-    # our facecolors
+-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
+-    # add our colorbar label
+-    cb1.set_label('Angle')
+-
+-    if save:
+-        plt.savefig("sphereplot.png")
+-
+-    return fig, ax
+-
+-
+-def _remove_margins(axis):
+-    """
+-    removes margins about z = 0 and improves the style
+-    by monkey patching
+-    """
+-    def _get_coord_info_new(renderer):
+-        mins, maxs, centers, deltas, tc, highs = \
+-            _get_coord_info_old(renderer)
+-        mins += deltas / 4
+-        maxs -= deltas / 4
+-        return mins, maxs, centers, deltas, tc, highs
+-
+-    _get_coord_info_old = axis._get_coord_info
+-    axis._get_coord_info = _get_coord_info_new
+-
+-
+-def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
+-    """
+-    truncates portion of a colormap and returns the new one
+-    """
+-    if isinstance(cmap, str):
+-        cmap = plt.get_cmap(cmap)
+-    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
+-        'trunc({n},{a:.2f},{b:.2f})'.format(
+-            n=cmap.name, a=minval, b=maxval),
+-        cmap(np.linspace(minval, maxval, n)))
+-    return new_cmap
+-
+-
+-def _stick_to_planes(stick, azim, ax, M, spacing):
+-    """adjusts xlim and ylim in way that bars will
+-    Stick to xz and yz planes
+-    """
+-    if stick is True:
+-        azim = azim % 360
+-        if 0 <= azim <= 90:
+-            ax.set_ylim(1 - .5,)
+-            ax.set_xlim(1 - .5,)
+-        elif 90 < azim <= 180:
+-            ax.set_ylim(1 - .5,)
+-            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
+-        elif 180 < azim <= 270:
+-            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
+-            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
+-        elif 270 < azim < 360:
+-            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
+-            ax.set_xlim(1 - .5,)
+-
+-
+-def _update_yaxis(spacing, M, ax, ylabels):
+-    """
+-    updates the y-axis
+-    """
+-    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+-    if ylabels:
+-        nylabels = len(ylabels)
+-        if nylabels != len(ytics):
+-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+-        ax.set_yticklabels(ylabels)
+-    else:
+-        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
+-        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
+-    ax.tick_params(axis='y', labelsize=14)
+-    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
+-
+-
+-def _update_xaxis(spacing, M, ax, xlabels):
+-    """
+-    updates the x-axis
+-    """
+-    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+-    if xlabels:
+-        nxlabels = len(xlabels)
+-        if nxlabels != len(xtics):
+-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+-        ax.set_xticklabels(xlabels)
+-    else:
+-        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
+-        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
+-    ax.tick_params(axis='x', labelsize=14)
+-    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
+-
+-
+-def _update_zaxis(ax, z_min, z_max, zticks):
+-    """
+-    updates the z-axis
+-    """
+-    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
+-    if isinstance(zticks, list):
+-        ax.set_zticks(zticks)
+-    ax.set_zlim3d([min(z_min, 0), z_max])
+-
+-
+-def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
+-                     colorbar=True, fig=None, ax=None, options=None):
+-    """
+-    Draw a histogram for the matrix M, with the given x and y labels and title.
+-
+-    Parameters
+-    ----------
+-    M : Matrix of Qobj
+-        The matrix to visualize
+-
+-    xlabels : list of strings
+-        list of x labels
+-
+-    ylabels : list of strings
+-        list of y labels
+-
+-    title : string
+-        title of the plot (optional)
+-
+-    limits : list/array with two float numbers
+-        The z-axis limits [min, max] (optional)
+-
+-    ax : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    colorbar : bool (default: True)
+-        show colorbar
+-
+-    options : dict
+-        A dictionary containing extra options for the plot.
+-        The names (keys) and values of the options are
+-        described below:
+-
+-        'zticks' : list of numbers
+-            A list of z-axis tick locations.
+-
+-        'cmap' : string (default: 'jet')
+-            The name of the color map to use.
+-
+-        'cmap_min' : float (default: 0.0)
+-            The lower bound to truncate the color map at.
+-            A value in range 0 - 1. The default, 0, leaves the lower
+-            bound of the map unchanged.
+-
+-        'cmap_max' : float (default: 1.0)
+-            The upper bound to truncate the color map at.
+-            A value in range 0 - 1. The default, 1, leaves the upper
+-            bound of the map unchanged.
+-
+-        'bars_spacing' : float (default: 0.1)
+-            spacing between bars.
+-
+-        'bars_alpha' : float (default: 1.)
+-            transparency of bars, should be in range 0 - 1
+-
+-        'bars_lw' : float (default: 0.5)
+-            linewidth of bars' edges.
+-
+-        'bars_edgecolor' : color (default: 'k')
+-            The colors of the bars' edges.
+-            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
+-
+-        'shade' : bool (default: True)
+-            Whether to shade the dark sides of the bars (True) or not (False).
+-            The shading is relative to plot's source of light.
+-
+-        'azim' : float
+-            The azimuthal viewing angle.
+-
+-        'elev' : float
+-            The elevation viewing angle.
+-
+-        'proj_type' : string (default: 'ortho' if ax is not passed)
+-            The type of projection ('ortho' or 'persp')
+-
+-        'stick' : bool (default: False)
+-            Changes xlim and ylim in such a way that bars next to
+-            XZ and YZ planes will stick to those planes.
+-            This option has no effect if ``ax`` is passed as a parameter.
+-
+-        'cbar_pad' : float (default: 0.04)
+-            The fraction of the original axes between the colorbar
+-            and the new image axes.
+-            (i.e. the padding between the 3D figure and the colorbar).
+-
+-        'cbar_to_z' : bool (default: False)
+-            Whether to set the color of maximum and minimum z-values to the
+-            maximum and minimum colors in the colorbar (True) or not (False).
+-
+-        'figsize' : tuple of two numbers
+-            The size of the figure.
+-
+-    Returns :
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    Raises
+-    ------
+-    ValueError
+-        Input argument is not valid.
+-
+-    """
+-
+-    # default options
+-    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
+-                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
+-                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
+-                    'shade': False, 'azim': -35, 'elev': 35,
+-                    'proj_type': 'ortho', 'stick': False,
+-                    'cbar_pad': 0.04, 'cbar_to_z': False}
+-
+-    # update default_opts from input options
+-    if options is None:
+-        pass
+-    elif isinstance(options, dict):
+-        # check if keys in options dict are valid
+-        if set(options) - set(default_opts):
+-            raise ValueError("invalid key(s) found in options: "
+-                             f"{', '.join(set(options) - set(default_opts))}")
+-        else:
+-            # updating default options
+-            default_opts.update(options)
+-    else:
+-        raise ValueError("options must be a dictionary")
+-
+-    if isinstance(M, Qobj):
+-        # extract matrix data from Qobj
+-        M = M.full()
+-
+-    n = np.size(M)
+-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+-    xpos = xpos.T.flatten() + 0.5
+-    ypos = ypos.T.flatten() + 0.5
+-    zpos = np.zeros(n)
+-    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
+-    dz = np.real(M.flatten())
+-
+-    if isinstance(limits, list) and len(limits) == 2:
+-        z_min = limits[0]
+-        z_max = limits[1]
+-    else:
+-        z_min = min(dz)
+-        z_max = max(dz)
+-        if z_min == z_max:
+-            z_min -= 0.1
+-            z_max += 0.1
+-
+-    if default_opts['cbar_to_z']:
+-        norm = mpl.colors.Normalize(min(dz), max(dz))
+-    else:
+-        norm = mpl.colors.Normalize(z_min, z_max)
+-    cmap = _truncate_colormap(default_opts['cmap'],
+-                              default_opts['cmap_min'],
+-                              default_opts['cmap_max'])
+-    colors = cmap(norm(dz))
+-
+-    if ax is None:
+-        fig = plt.figure(figsize=default_opts['figsize'])
+-        ax = _axes3D(fig,
+-                     azim=default_opts['azim'] % 360,
+-                     elev=default_opts['elev'] % 360)
+-        ax.set_proj_type(default_opts['proj_type'])
+-
+-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
+-             edgecolors=default_opts['bars_edgecolor'],
+-             linewidths=default_opts['bars_lw'],
+-             alpha=default_opts['bars_alpha'],
+-             shade=default_opts['shade'])
+-    # remove vertical lines on xz and yz plane
+-    ax.yaxis._axinfo["grid"]['linewidth'] = 0
+-    ax.xaxis._axinfo["grid"]['linewidth'] = 0
+-
+-    if title:
+-        ax.set_title(title)
+-
+-    # x axis
+-    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
+-
+-    # y axis
+-    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
+-
+-    # z axis
+-    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
+-
+-    # stick to xz and yz plane
+-    _stick_to_planes(default_opts['stick'],
+-                     default_opts['azim'], ax, M,
+-                     default_opts['bars_spacing'])
+-
+-    # color axis
+-    if colorbar:
+-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
+-                                         pad=default_opts['cbar_pad'])
+-        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+-
+-    # removing margins
+-    _remove_margins(ax.xaxis)
+-    _remove_margins(ax.yaxis)
+-    _remove_margins(ax.zaxis)
+-
+-    return fig, ax
+-
+-
+-def matrix_histogram_complex(M, xlabels=None, ylabels=None,
+-                             title=None, limits=None, phase_limits=None,
+-                             colorbar=True, fig=None, ax=None,
+-                             threshold=None):
+-    """
+-    Draw a histogram for the amplitudes of matrix M, using the argument
+-    of each element for coloring the bars, with the given x and y labels
+-    and title.
+-
+-    Parameters
+-    ----------
+-    M : Matrix of Qobj
+-        The matrix to visualize
+-
+-    xlabels : list of strings
+-        list of x labels
+-
+-    ylabels : list of strings
+-        list of y labels
+-
+-    title : string
+-        title of the plot (optional)
+-
+-    limits : list/array with two float numbers
+-        The z-axis limits [min, max] (optional)
+-
+-    phase_limits : list/array with two float numbers
+-        The phase-axis (colorbar) limits [min, max] (optional)
+-
+-    ax : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    threshold: float (None)
+-        Threshold for when bars of smaller height should be transparent. If
+-        not set, all bars are colored according to the color map.
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    Raises
+-    ------
+-    ValueError
+-        Input argument is not valid.
+-
+-    """
+-
+-    if isinstance(M, Qobj):
+-        # extract matrix data from Qobj
+-        M = M.full()
+-
+-    n = np.size(M)
+-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+-    xpos = xpos.T.flatten() - 0.5
+-    ypos = ypos.T.flatten() - 0.5
+-    zpos = np.zeros(n)
+-    dx = dy = 0.8 * np.ones(n)
+-    Mvec = M.flatten()
+-    dz = abs(Mvec)
+-
+-    # make small numbers real, to avoid random colors
+-    idx, = np.where(abs(Mvec) < 0.001)
+-    Mvec[idx] = abs(Mvec[idx])
+-
+-    if phase_limits:  # check that limits is a list type
+-        phase_min = phase_limits[0]
+-        phase_max = phase_limits[1]
+-    else:
+-        phase_min = -pi
+-        phase_max = pi
+-
+-    norm = mpl.colors.Normalize(phase_min, phase_max)
+-    cmap = complex_phase_cmap()
+-
+-    colors = cmap(norm(angle(Mvec)))
+-    if threshold is not None:
+-        colors[:, 3] = 1 * (dz > threshold)
+-
+-    if ax is None:
+-        fig = plt.figure()
+-        ax = _axes3D(fig, azim=-35, elev=35)
+-
+-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
+-
+-    if title:
+-        ax.set_title(title)
+-
+-    # x axis
+-    xtics = -0.5 + np.arange(M.shape[0])
+-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+-    if xlabels:
+-        nxlabels = len(xlabels)
+-        if nxlabels != len(xtics):
+-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+-        ax.set_xticklabels(xlabels)
+-    ax.tick_params(axis='x', labelsize=12)
+-
+-    # y axis
+-    ytics = -0.5 + np.arange(M.shape[1])
+-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+-    if ylabels:
+-        nylabels = len(ylabels)
+-        if nylabels != len(ytics):
+-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+-        ax.set_yticklabels(ylabels)
+-    ax.tick_params(axis='y', labelsize=12)
+-
+-    # z axis
+-    if limits and isinstance(limits, list):
+-        ax.set_zlim3d(limits)
+-    else:
+-        ax.set_zlim3d([0, 1])  # use min/max
+-    # ax.set_zlabel('abs')
+-
+-    # color axis
+-    if colorbar:
+-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
+-        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+-        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+-        cb.set_ticklabels(
+-            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
+-        cb.set_label('arg')
+-
+-    return fig, ax
+-
+-
+-def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
+-                       figsize=(8, 12), fig=None, ax=None):
+-    """
+-    Plot the energy level diagrams for a list of Hamiltonians. Include
+-    up to N energy levels. For each element in H_list, the energy
+-    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
+-    where n is the index of an element in H_list.
+-
+-    Parameters
+-    ----------
+-
+-        H_list : List of Qobj
+-            A list of Hamiltonians.
+-
+-        labels : List of string
+-            A list of labels for each Hamiltonian
+-
+-        show_ylabels : Bool (default False)
+-            Show y labels to the left of energy levels of the initial
+-            Hamiltonian.
+-
+-        N : int
+-            The number of energy levels to plot
+-
+-        figsize : tuple (int,int)
+-            The size of the figure (width, height).
+-
+-        fig : a matplotlib Figure instance
+-            The Figure canvas in which the plot will be drawn.
+-
+-        ax : a matplotlib axes instance
+-            The axes context in which the plot will be drawn.
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    Raises
+-    ------
+-
+-        ValueError
+-            Input argument is not valid.
+-
+-    """
+-
+-    if not isinstance(H_list, list):
+-        raise ValueError("H_list must be a list of Qobj instances")
+-
+-    if not fig and not ax:
+-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-    H = H_list[0]
+-    N = H.shape[0] if N == 0 else min(H.shape[0], N)
+-
+-    xticks = []
+-    yticks = []
+-
+-    x = 0
+-    evals0 = H.eigenenergies(eigvals=N)
+-    for e_idx, e in enumerate(evals0[:N]):
+-        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+-        yticks.append(e)
+-    xticks.append(x + 1)
+-    x += 2
+-
+-    for H1 in H_list[1:]:
+-
+-        H = H + H1
+-        evals1 = H.eigenenergies()
+-
+-        for e_idx, e in enumerate(evals1[:N]):
+-            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
+-        x += 1
+-
+-        for e_idx, e in enumerate(evals1[:N]):
+-            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+-        xticks.append(x + 1)
+-        x += 2
+-
+-        evals0 = evals1
+-
+-    ax.set_frame_on(False)
+-
+-    if show_ylabels:
+-        yticks = np.unique(np.around(yticks, 1))
+-        ax.set_yticks(yticks)
+-    else:
+-        ax.axes.get_yaxis().set_visible(False)
+-
+-    if labels:
+-        ax.get_xaxis().tick_bottom()
+-        ax.set_xticks(xticks)
+-        ax.set_xticklabels(labels, fontsize=16)
+-    else:
+-        ax.axes.get_xaxis().set_visible(False)
+-
+-    return fig, ax
+-
+-
+-def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
+-                         figsize=(8, 12), fig=None, ax=None):
+-    warnings.warn("Deprecated: Use plot_energy_levels")
+-    return plot_energy_levels(H_list, N=N, labels=labels,
+-                              show_ylabels=show_ylabels,
+-                              figsize=figsize, fig=fig, ax=ax)
+-
+-
+-def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
+-                           figsize=(8, 6), title=None, unit_y_range=True):
+-    """
+-    Plot the Fock distribution for a density matrix (or ket) that describes
+-    an oscillator mode.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        The density matrix (or ket) of the state to visualize.
+-
+-    fig : a matplotlib Figure instance
+-        The Figure canvas in which the plot will be drawn.
+-
+-    ax : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    title : string
+-        An optional title for the figure.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-
+-    if not fig and not ax:
+-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-    if isket(rho):
+-        rho = ket2dm(rho)
+-
+-    N = rho.shape[0]
+-
+-    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
+-           color="green", alpha=0.6, width=0.8)
+-    if unit_y_range:
+-        ax.set_ylim(0, 1)
+-
+-    ax.set_xlim(-.5 + offset, N + offset)
+-    ax.set_xlabel('Fock number', fontsize=12)
+-    ax.set_ylabel('Occupation probability', fontsize=12)
+-
+-    if title:
+-        ax.set_title(title)
+-
+-    return fig, ax
+-
+-
+-def fock_distribution(rho, offset=0, fig=None, ax=None,
+-                      figsize=(8, 6), title=None, unit_y_range=True):
+-    warnings.warn("Deprecated: Use plot_fock_distribution")
+-    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
+-                                  figsize=figsize, title=title,
+-                                  unit_y_range=unit_y_range)
+-
+-
+-def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
+-                cmap=None, alpha_max=7.5, colorbar=False,
+-                method='clenshaw', projection='2d'):
+-    """
+-    Plot the the Wigner function for a density matrix (or ket) that describes
+-    an oscillator mode.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        The density matrix (or ket) of the state to visualize.
+-
+-    fig : a matplotlib Figure instance
+-        The Figure canvas in which the plot will be drawn.
+-
+-    ax : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    cmap : a matplotlib cmap instance
+-        The colormap.
+-
+-    alpha_max : float
+-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+-
+-    colorbar : bool
+-        Whether (True) or not (False) a colorbar should be attached to the
+-        Wigner function graph.
+-
+-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+-        The method used for calculating the wigner function. See the
+-        documentation for qutip.wigner for details.
+-
+-    projection: string {'2d', '3d'}
+-        Specify whether the Wigner function is to be plotted as a
+-        contour graph ('2d') or surface plot ('3d').
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-
+-    if not fig and not ax:
+-        if projection == '2d':
+-            fig, ax = plt.subplots(1, 1, figsize=figsize)
+-        elif projection == '3d':
+-            fig = plt.figure(figsize=figsize)
+-            ax = fig.add_subplot(1, 1, 1, projection='3d')
+-        else:
+-            raise ValueError('Unexpected value of projection keyword argument')
+-
+-    if isket(rho):
+-        rho = ket2dm(rho)
+-
+-    xvec = np.linspace(-alpha_max, alpha_max, 200)
+-    W0 = wigner(rho, xvec, xvec, method=method)
+-
+-    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
+-
+-    wlim = abs(W).max()
+-
+-    if cmap is None:
+-        cmap = cm.get_cmap('RdBu')
+-
+-    if projection == '2d':
+-        cf = ax.contourf(xvec, yvec, W, 100,
+-                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
+-    elif projection == '3d':
+-        X, Y = np.meshgrid(xvec, xvec)
+-        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
+-                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
+-    else:
+-        raise ValueError('Unexpected value of projection keyword argument.')
+-
+-    if xvec is not yvec:
+-        ax.set_ylim(xvec.min(), xvec.max())
+-
+-    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
+-    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+-
+-    if colorbar:
+-        fig.colorbar(cf, ax=ax)
+-
+-    ax.set_title("Wigner function", fontsize=12)
+-
+-    return fig, ax
+-
+-
+-def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
+-                                  cmap=None, alpha_max=7.5, colorbar=False,
+-                                  method='iterative', projection='2d'):
+-    """
+-    Plot the Fock distribution and the Wigner function for a density matrix
+-    (or ket) that describes an oscillator mode.
+-
+-    Parameters
+-    ----------
+-    rho : :class:`qutip.Qobj`
+-        The density matrix (or ket) of the state to visualize.
+-
+-    fig : a matplotlib Figure instance
+-        The Figure canvas in which the plot will be drawn.
+-
+-    axes : a list of two matplotlib axes instances
+-        The axes context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    cmap : a matplotlib cmap instance
+-        The colormap.
+-
+-    alpha_max : float
+-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+-
+-    colorbar : bool
+-        Whether (True) or not (False) a colorbar should be attached to the
+-        Wigner function graph.
+-
+-    method : string {'iterative', 'laguerre', 'fft'}
+-        The method used for calculating the wigner function. See the
+-        documentation for qutip.wigner for details.
+-
+-    projection: string {'2d', '3d'}
+-        Specify whether the Wigner function is to be plotted as a
+-        contour graph ('2d') or surface plot ('3d').
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-
+-    if not fig and not axes:
+-        if projection == '2d':
+-            fig, axes = plt.subplots(1, 2, figsize=figsize)
+-        elif projection == '3d':
+-            fig = plt.figure(figsize=figsize)
+-            axes = [fig.add_subplot(1, 2, 1),
+-                    fig.add_subplot(1, 2, 2, projection='3d')]
+-        else:
+-            raise ValueError('Unexpected value of projection keyword argument')
+-
+-    if isket(rho):
+-        rho = ket2dm(rho)
+-
+-    plot_fock_distribution(rho, fig=fig, ax=axes[0])
+-    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
+-                alpha_max=alpha_max, colorbar=colorbar, method=method,
+-                projection=projection)
+-
+-    return fig, axes
+-
+-
+-def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
+-                             cmap=None, alpha_max=7.5, colorbar=False,
+-                             method='iterative'):
+-    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
+-    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
+-                                         figsize=figsize, cmap=cmap,
+-                                         alpha_max=alpha_max,
+-                                         colorbar=colorbar,
+-                                         method=method)
+-
+-
+-def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
+-                            fig=None, axes=None, figsize=(8, 4)):
+-    """
+-    Visualize the results (expectation values) for an evolution solver.
+-    `results` is assumed to be an instance of Result, or a list of Result
+-    instances.
+-
+-    Parameters
+-    ----------
+-    results : (list of) :class:`qutip.solver.Result`
+-        List of results objects returned by any of the QuTiP evolution solvers.
+-
+-    ylabels : list of strings
+-        The y-axis labels. List should be of the same length as `results`.
+-
+-    title : string
+-        The title of the figure.
+-
+-    show_legend : bool
+-        Whether or not to show the legend.
+-
+-    fig : a matplotlib Figure instance
+-        The Figure canvas in which the plot will be drawn.
+-
+-    axes : a matplotlib axes instance
+-        The axes context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-    if not isinstance(results, list):
+-        results = [results]
+-
+-    n_e_ops = max([len(result.expect) for result in results])
+-
+-    if not fig or not axes:
+-        if not figsize:
+-            figsize = (12, 3 * n_e_ops)
+-        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
+-                                 figsize=figsize, squeeze=False)
+-
+-    for r_idx, result in enumerate(results):
+-        for e_idx, e in enumerate(result.expect):
+-            axes[e_idx, 0].plot(result.times, e,
+-                                label="%s [%d]" % (result.solver, e_idx))
+-
+-    if title:
+-        fig.suptitle(title)
+-
+-    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
+-    for n in range(n_e_ops):
+-        if show_legend:
+-            axes[n, 0].legend()
+-        if ylabels:
+-            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
+-
+-    return fig, axes
+-
+-
+-def plot_spin_distribution_2d(P, THETA, PHI,
+-                              fig=None, ax=None, figsize=(8, 8)):
+-    """
+-    Plot a spin distribution function (given as meshgrid data) with a 2D
+-    projection where the surface of the unit sphere is mapped on the unit disk.
+-
+-    Parameters
+-    ----------
+-    P : matrix
+-        Distribution values as a meshgrid matrix.
+-
+-    THETA : matrix
+-        Meshgrid matrix for the theta coordinate.
+-
+-    PHI : matrix
+-        Meshgrid matrix for the phi coordinate.
+-
+-    fig : a matplotlib figure instance
+-        The figure canvas on which the plot will be drawn.
+-
+-    ax : a matplotlib axis instance
+-        The axis context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-    """
+-
+-    if not fig or not ax:
+-        if not figsize:
+-            figsize = (8, 8)
+-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-    Y = (THETA - pi / 2) / (pi / 2)
+-    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
+-
+-    if P.min() < -1e12:
+-        cmap = cm.RdBu
+-    else:
+-        cmap = cm.RdYlBu
+-
+-    ax.pcolor(X, Y, P.real, cmap=cmap)
+-    ax.set_xlabel(r'$\varphi$', fontsize=18)
+-    ax.set_ylabel(r'$\theta$', fontsize=18)
+-
+-    ax.set_xticks([-1, 0, 1])
+-    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
+-    ax.set_yticks([-1, 0, 1])
+-    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
+-
+-    return fig, ax
+-
+-
+-def plot_spin_distribution_3d(P, THETA, PHI,
+-                              fig=None, ax=None, figsize=(8, 6)):
+-    """Plots a matrix of values on a sphere
+-
+-    Parameters
+-    ----------
+-    P : matrix
+-        Distribution values as a meshgrid matrix.
+-
+-    THETA : matrix
+-        Meshgrid matrix for the theta coordinate.
+-
+-    PHI : matrix
+-        Meshgrid matrix for the phi coordinate.
+-
+-    fig : a matplotlib figure instance
+-        The figure canvas on which the plot will be drawn.
+-
+-    ax : a matplotlib axis instance
+-        The axis context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    """
+-
+-    if fig is None or ax is None:
+-        fig = plt.figure(figsize=figsize)
+-        ax = _axes3D(fig, azim=-35, elev=35)
+-
+-    xx = sin(THETA) * cos(PHI)
+-    yy = sin(THETA) * sin(PHI)
+-    zz = cos(THETA)
+-
+-    if P.min() < -1e12:
+-        cmap = cm.RdBu
+-        norm = mpl.colors.Normalize(-P.max(), P.max())
+-    else:
+-        cmap = cm.RdYlBu
+-        norm = mpl.colors.Normalize(P.min(), P.max())
+-
+-    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+-                    facecolors=cmap(norm(P)), linewidth=0)
+-
+-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+-    cb1.set_label('magnitude')
+-
+-    return fig, ax
+-
+-
+-#
+-# Qubism and other qubistic visualizations
+-#
+-def complex_array_to_rgb(X, theme='light', rmax=None):
+-    """
+-    Makes an array of complex number and converts it to an array of [r, g, b],
+-    where phase gives hue and saturation/value are given by the absolute value.
+-    Especially for use with imshow for complex plots.
+-
+-    For more info on coloring, see:
+-        Emilia Petrisor,
+-        Visualizing complex-valued functions with Matplotlib and Mayavi
+-        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
+-
+-    Parameters
+-    ----------
+-    X : array
+-        Array (of any dimension) of complex numbers.
+-
+-    theme : 'light' (default) or 'dark'
+-        Set coloring theme for mapping complex values into colors.
+-
+-    rmax : float
+-        Maximal abs value for color normalization.
+-        If None (default), uses np.abs(X).max().
+-
+-    Returns
+-    -------
+-    Y : array
+-        Array of colors (of shape X.shape + (3,)).
+-
+-    """
+-
+-    absmax = rmax or np.abs(X).max()
+-    if absmax == 0.:
+-        absmax = 1.
+-    Y = np.zeros(X.shape + (3,), dtype='float')
+-    Y[..., 0] = np.angle(X) / (2 * pi) % 1
+-    if theme == 'light':
+-        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
+-        Y[..., 2] = 1
+-    elif theme == 'dark':
+-        Y[..., 1] = 1
+-        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
+-    Y = mpl.colors.hsv_to_rgb(Y)
+-    return Y
+-
+-
+-def _index_to_sequence(i, dim_list):
+-    """
+-    For a matrix entry with index i it returns state it corresponds to.
+-    In particular, for dim_list=[2]*n it returns i written as a binary number.
+-
+-    Parameters
+-    ----------
+-    i : int
+-        Index in a matrix.
+-
+-    dim_list : list of int
+-        List of dimensions of consecutive particles.
+-
+-    Returns
+-    -------
+-    seq : list
+-        List of coordinates for each particle.
+-
+-    """
+-    res = []
+-    j = i
+-    for d in reversed(dim_list):
+-        j, s = divmod(j, d)
+-        res.append(s)
+-    return list(reversed(res))
+-
+-
+-def _sequence_to_index(seq, dim_list):
+-    """
+-    Inverse of _index_to_sequence.
+-
+-    Parameters
+-    ----------
+-    seq : list of ints
+-        List of coordinates for each particle.
+-
+-    dim_list : list of int
+-        List of dimensions of consecutive particles.
+-
+-    Returns
+-    -------
+-    i : list
+-        Index in a matrix.
+-
+-    """
+-    i = 0
+-    for s, d in zip(seq, dim_list):
+-        i *= d
+-        i += s
+-
+-    return i
+-
+-
+-def _to_qubism_index_pair(i, dim_list, how='pairs'):
+-    """
+-    For a matrix entry with index i
+-    it returns x, y coordinates in qubism mapping.
+-
+-    Parameters
+-    ----------
+-    i : int
+-        Index in a matrix.
+-
+-    dim_list : list of int
+-        List of dimensions of consecutive particles.
+-
+-    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
+-        Type of qubistic plot.
+-
+-    Returns
+-    -------
+-    x, y : tuple of ints
+-        List of coordinates for each particle.
+-
+-    """
+-    seq = _index_to_sequence(i, dim_list)
+-
+-    if how == 'pairs':
+-        y = _sequence_to_index(seq[::2], dim_list[::2])
+-        x = _sequence_to_index(seq[1::2], dim_list[1::2])
+-    elif how == 'pairs_skewed':
+-        dim_list2 = dim_list[::2]
+-        y = _sequence_to_index(seq[::2], dim_list2)
+-        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
+-        x = _sequence_to_index(seq2, dim_list2)
+-    elif how == 'before_after':
+-        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
+-        n = len(dim_list)
+-        y = _sequence_to_index(reversed(seq[:(n // 2)]),
+-                               reversed(dim_list[:(n // 2)]))
+-        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
+-    else:
+-        raise Exception("No such 'how'.")
+-
+-    return x, y
+-
+-
+-def _sequence_to_latex(seq, style='ket'):
+-    """
+-    For a sequence of particle states generate LaTeX code.
+-
+-    Parameters
+-    ----------
+-    seq : list of ints
+-        List of coordinates for each particle.
+-
+-    style : 'ket' (default), 'bra' or 'bare'
+-        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
+-
+-    Returns
+-    -------
+-    latex : str
+-        LaTeX output.
+-
+-    """
+-    if style == 'ket':
+-        latex = "$\\left|{0}\\right\\rangle$"
+-    elif style == 'bra':
+-        latex = "$\\left\\langle{0}\\right|$"
+-    elif style == 'bare':
+-        latex = "${0}$"
+-    else:
+-        raise Exception("No such style.")
+-    return latex.format("".join(map(str, seq)))
+-
+-
+-def plot_qubism(ket, theme='light', how='pairs',
+-                grid_iteration=1, legend_iteration=0,
+-                fig=None, ax=None, figsize=(6, 6)):
+-    """
+-    Qubism plot for pure states of many qudits.  Works best for spin chains,
+-    especially with even number of particles of the same dimension.  Allows to
+-    see entanglement between first 2k particles and the rest.
+-
+-    Parameters
+-    ----------
+-    ket : Qobj
+-        Pure state for plotting.
+-
+-    theme : 'light' (default) or 'dark'
+-        Set coloring theme for mapping complex values into colors.
+-        See: complex_array_to_rgb.
+-
+-    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
+-        Type of Qubism plotting.  Options:
+-
+-        - 'pairs' - typical coordinates,
+-        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
+-        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
+-
+-    grid_iteration : int (default 1)
+-        Helper lines to be drawn on plot.
+-        Show tiles for 2*grid_iteration particles vs all others.
+-
+-    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
+-        Show labels for first ``2*legend_iteration`` particles.  Option
+-        'grid_iteration' sets the same number of particles as for
+-        grid_iteration.  Option 'all' makes label for all particles.  Typically
+-        it should be 0, 1, 2 or perhaps 3.
+-
+-    fig : a matplotlib figure instance
+-        The figure canvas on which the plot will be drawn.
+-
+-    ax : a matplotlib axis instance
+-        The axis context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    Notes
+-    -----
+-    See also [1]_.
+-
+-    References
+-    ----------
+-    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
+-       and G. Sierra, *Qubism: self-similar visualization of many-body
+-       wavefunctions*, `New J. Phys. 14 053028
+-       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
+-       (2012), open access.
+-    """
+-
+-    if not isket(ket):
+-        raise Exception("Qubism works only for pure states, i.e. kets.")
+-        # add for dm? (perhaps a separate function, plot_qubism_dm)
+-
+-    if not fig and not ax:
+-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-    dim_list = ket.dims[0]
+-    n = len(dim_list)
+-
+-    # for odd number of particles - pixels are rectangular
+-    if n % 2 == 1:
+-        ket = tensor(ket, Qobj([1] * dim_list[-1]))
+-        dim_list = ket.dims[0]
+-        n += 1
+-
+-    ketdata = ket.full()
+-
+-    if how == 'pairs':
+-        dim_list_y = dim_list[::2]
+-        dim_list_x = dim_list[1::2]
+-    elif how == 'pairs_skewed':
+-        dim_list_y = dim_list[::2]
+-        dim_list_x = dim_list[1::2]
+-        if dim_list_x != dim_list_y:
+-            raise Exception("For 'pairs_skewed' pairs " +
+-                            "of dimensions need to be the same.")
+-    elif how == 'before_after':
+-        dim_list_y = list(reversed(dim_list[:(n // 2)]))
+-        dim_list_x = dim_list[(n // 2):]
+-    else:
+-        raise Exception("No such 'how'.")
+-
+-    size_x = np.prod(dim_list_x)
+-    size_y = np.prod(dim_list_y)
+-
+-    qub = np.zeros([size_x, size_y], dtype=complex)
+-    for i in range(ketdata.size):
+-        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
+-    qub = qub.transpose()
+-
+-    quadrants_x = np.prod(dim_list_x[:grid_iteration])
+-    quadrants_y = np.prod(dim_list_y[:grid_iteration])
+-
+-    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
+-    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+-
+-    ax.set_xticks(ticks_x)
+-    ax.set_xticklabels([""] * (quadrants_x - 1))
+-    ax.set_yticks(ticks_y)
+-    ax.set_yticklabels([""] * (quadrants_y - 1))
+-    theme2color_of_lines = {'light': '#000000',
+-                            'dark': '#FFFFFF'}
+-    ax.grid(True, color=theme2color_of_lines[theme])
+-    ax.imshow(complex_array_to_rgb(qub, theme=theme),
+-              interpolation="none",
+-              extent=(0, size_x, 0, size_y))
+-
+-    if legend_iteration == 'all':
+-        label_n = n // 2
+-    elif legend_iteration == 'grid_iteration':
+-        label_n = grid_iteration
+-    else:
+-        try:
+-            label_n = int(legend_iteration)
+-        except:
+-            raise Exception("No such option for legend_iteration keyword " +
+-                            "argument. Use 'all', 'grid_iteration' or an " +
+-                            "integer.")
+-
+-    if label_n:
+-
+-        if how == 'before_after':
+-            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
+-                + dim_list_x[:label_n]
+-        else:
+-            dim_list_small = []
+-            for j in range(label_n):
+-                dim_list_small.append(dim_list_y[j])
+-                dim_list_small.append(dim_list_x[j])
+-
+-        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
+-        shift_x = 0.5 * scale_x
+-        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
+-        shift_y = 0.5 * scale_y
+-
+-        bbox = ax.get_window_extent().transformed(
+-            fig.dpi_scale_trans.inverted())
+-        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
+-        opts = {'fontsize': fontsize,
+-                'color': theme2color_of_lines[theme],
+-                'horizontalalignment': 'center',
+-                'verticalalignment': 'center'}
+-        for i in range(np.prod(dim_list_small)):
+-            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
+-            seq = _index_to_sequence(i, dim_list=dim_list_small)
+-            ax.text(scale_x * x + shift_x,
+-                    size_y - (scale_y * y + shift_y),
+-                    _sequence_to_latex(seq),
+-                    **opts)
+-    return fig, ax
+-
+-
+-def plot_schmidt(ket, splitting=None,
+-                 labels_iteration=(3, 2),
+-                 theme='light',
+-                 fig=None, ax=None, figsize=(6, 6)):
+-    """
+-    Plotting scheme related to Schmidt decomposition.
+-    Converts a state into a matrix (A_ij -> A_i^j),
+-    where rows are first particles and columns - last.
+-
+-    See also: plot_qubism with how='before_after' for a similar plot.
+-
+-    Parameters
+-    ----------
+-    ket : Qobj
+-        Pure state for plotting.
+-
+-    splitting : int
+-        Plot for a number of first particles versus the rest.
+-        If not given, it is (number of particles + 1) // 2.
+-
+-    theme : 'light' (default) or 'dark'
+-        Set coloring theme for mapping complex values into colors.
+-        See: complex_array_to_rgb.
+-
+-    labels_iteration : int or pair of ints (default (3,2))
+-        Number of particles to be shown as tick labels,
+-        for first (vertical) and last (horizontal) particles, respectively.
+-
+-    fig : a matplotlib figure instance
+-        The figure canvas on which the plot will be drawn.
+-
+-    ax : a matplotlib axis instance
+-        The axis context in which the plot will be drawn.
+-
+-    figsize : (width, height)
+-        The size of the matplotlib figure (in inches) if it is to be created
+-        (that is, if no 'fig' and 'ax' arguments are passed).
+-
+-    Returns
+-    -------
+-    fig, ax : tuple
+-        A tuple of the matplotlib figure and axes instances used to produce
+-        the figure.
+-
+-    """
+-    if not isket(ket):
+-        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
+-
+-    if not fig and not ax:
+-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+-
+-    dim_list = ket.dims[0]
+-
+-    if splitting is None:
+-        splitting = (len(dim_list) + 1) // 2
+-
+-    if isinstance(labels_iteration, int):
+-        labels_iteration = labels_iteration, labels_iteration
+-
+-    ketdata = ket.full()
+-
+-    dim_list_y = dim_list[:splitting]
+-    dim_list_x = dim_list[splitting:]
+-
+-    size_x = np.prod(dim_list_x)
+-    size_y = np.prod(dim_list_y)
+-
+-    ketdata = ketdata.reshape((size_y, size_x))
+-
+-    dim_list_small_x = dim_list_x[:labels_iteration[1]]
+-    dim_list_small_y = dim_list_y[:labels_iteration[0]]
+-
+-    quadrants_x = np.prod(dim_list_small_x)
+-    quadrants_y = np.prod(dim_list_small_y)
+-
+-    ticks_x = [size_x / quadrants_x * (i + 0.5)
+-               for i in range(quadrants_x)]
+-    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
+-               for i in range(quadrants_y)]
+-
+-    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
+-                                                      dim_list=dim_list_x))
+-                for i in range(quadrants_x)]
+-    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
+-                                                      dim_list=dim_list_y))
+-                for i in range(quadrants_y)]
+-
+-    ax.set_xticks(ticks_x)
+-    ax.set_xticklabels(labels_x)
+-    ax.set_yticks(ticks_y)
+-    ax.set_yticklabels(labels_y)
+-    ax.set_xlabel("last particles")
+-    ax.set_ylabel("first particles")
+-
+-    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
+-              interpolation="none",
+-              extent=(0, size_x, 0, size_y))
+-
+-    return fig, ax
++"""
++Functions for visualizing results of quantum dynamics simulations,
++visualizations of quantum states and processes.
++"""
++
++__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
++           'plot_energy_levels', 'fock_distribution',
++           'plot_fock_distribution', 'wigner_fock_distribution',
++           'plot_wigner_fock_distribution', 'plot_wigner',
++           'plot_expectation_values', 'plot_spin_distribution_2d',
++           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
++           'complex_array_to_rgb', 'matrix_histogram',
++           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
++
++import warnings
++import itertools as it
++import numpy as np
++from numpy import pi, array, sin, cos, angle, log2
++
++from packaging.version import parse as parse_version
++
++from . import (
++    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
++)
++from .core.dimensions import flatten
++from .core.superop_reps import _to_superpauli, isqubitdims
++from .wigner import wigner
++from .matplotlib_utilities import complex_phase_cmap
++
++try:
++    import matplotlib.pyplot as plt
++    import matplotlib as mpl
++    from matplotlib import cm
++    from mpl_toolkits.mplot3d import Axes3D
++
++    # Define a custom _axes3D function based on the matplotlib version.
++    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
++    if parse_version(mpl.__version__) >= parse_version('3.4'):
++        def _axes3D(fig, *args, **kwargs):
++            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
++            return fig.add_axes(ax)
++    else:
++        def _axes3D(*args, **kwargs):
++            return Axes3D(*args, **kwargs)
++except:
++    pass
++
++
++def plot_wigner_sphere(fig, ax, wigner, reflections):
++    """Plots a coloured Bloch sphere.
++
++    Parameters
++    ----------
++    fig : :obj:`matplotlib.figure.Figure`
++        An instance of :obj:`~matplotlib.figure.Figure`.
++    ax : :obj:`matplotlib.axes.Axes`
++        An axes instance in the given figure.
++    wigner : list of float
++        The wigner transformation at `steps` different theta and phi.
++    reflections : bool
++        If the reflections of the sphere should be plotted as well.
++
++    Notes
++    -----
++    Special thanks to Russell P Rundle for writing this function.
++    """
++    ax.set_xlabel("x")
++    ax.set_ylabel("y")
++    ax.set_zlabel("z")
++
++    steps = len(wigner)
++
++    theta = np.linspace(0, np.pi, steps)
++    phi = np.linspace(0, 2 * np.pi, steps)
++    x = np.outer(np.sin(theta), np.cos(phi))
++    y = np.outer(np.sin(theta), np.sin(phi))
++    z = np.outer(np.cos(theta), np.ones(steps))
++    wigner = np.real(wigner)
++    wigner_max = np.real(np.amax(np.abs(wigner)))
++
++    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
++
++    # Plot coloured Bloch sphere:
++    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
++                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
++                    zorder=0.5, antialiased=None)
++
++    if reflections:
++        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
++                                 (2*wigner_max))  # bottom
++        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
++                                 (2*wigner_max))  # side
++        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
++                                 (2*wigner_max))  # back
++
++        # Plot bottom reflection:
++        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
++                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
++                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
++                        ccount=steps/2, linewidth=0, zorder=0.5,
++                        antialiased=False)
++
++        # Plot side reflection:
++        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
++                        z[0:steps, 0:steps], facecolors=wigner_c3,
++                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
++                        ccount=steps/2, linewidth=0, zorder=0.5,
++                        antialiased=False)
++
++        # Plot back reflection:
++        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
++                        z[0:steps, 0:steps], facecolors=wigner_c4,
++                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
++                        ccount=steps/2, linewidth=0, zorder=0.5,
++                        antialiased=False)
++
++    # Create colourbar:
++    m = cm.ScalarMappable(cmap=cm.seismic_r)
++    m.set_array([-wigner_max, wigner_max])
++    plt.colorbar(m, shrink=0.5, aspect=10)
++
++    plt.show()
++
++
++# Adopted from the SciPy Cookbook.
++def _blob(x, y, w, w_max, area, color_fn, ax=None):
++    """
++    Draws a square-shaped blob with the given area (< 1) at
++    the given coordinates.
++    """
++    hs = np.sqrt(area) / 2
++    xcorners = array([x - hs, x + hs, x + hs, x - hs])
++    ycorners = array([y - hs, y - hs, y + hs, y + hs])
++
++    if ax is not None:
++        handle = ax
++    else:
++        handle = plt
++
++    handle.fill(xcorners, ycorners,
++             color=color_fn(w))
++
++
++def _cb_labels(left_dims):
++    """Creates plot labels for matrix elements in the computational basis.
++
++    Parameters
++    ----------
++    left_dims : flat list of ints
++        Dimensions of the left index of a density operator. E. g.
++        [2, 3] for a qubit tensored with a qutrit.
++
++    Returns
++    -------
++    left_labels, right_labels : lists of strings
++        Labels for the left and right indices of a density operator
++        (kets and bras, respectively).
++    """
++    # FIXME: assumes dims, such that we only need left_dims == dims[0].
++    basis_labels = list(map(",".join, it.product(*[
++        map(str, range(dim))
++        for dim in left_dims
++    ])))
++    return [
++        map(fmt.format, basis_labels) for fmt in
++        (
++            r"$\langle{}|$",
++            r"$|{}\rangle$",
++        )
++    ]
++
++
++# Adopted from the SciPy Cookbook.
++def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
++           label_top=True, color_style="scaled"):
++    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
++
++    Parameters
++    ----------
++    rho : qobj
++        Input density matrix or superoperator.
++
++    xlabels : list of strings or False
++        list of x labels
++
++    ylabels : list of strings or False
++        list of y labels
++
++    title : string
++        title of the plot (optional)
++
++    ax : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    cmap : a matplotlib colormap instance
++        Color map to use when plotting.
++
++    label_top : bool
++        If True, x-axis labels will be placed on top, otherwise
++        they will appear below the plot.
++
++    color_style : string
++        Determines how colors are assigned to each square:
++
++        -  If set to ``"scaled"`` (default), each color is chosen by
++           passing the absolute value of the corresponding matrix
++           element into `cmap` with the sign of the real part.
++        -  If set to ``"threshold"``, each square is plotted as
++           the maximum of `cmap` for the positive real part and as
++           the minimum for the negative part of the matrix element;
++           note that this generalizes `"threshold"` to complex numbers.
++        -  If set to ``"phase"``, each color is chosen according to
++           the angle of the corresponding matrix element.
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    Raises
++    ------
++    ValueError
++        Input argument is not a quantum object.
++
++    Examples
++    --------
++    >>> import qutip
++    >>>
++    >>> dm = qutip.rand_dm(4)
++    >>> fig, ax = qutip.hinton(dm)
++    >>> fig.show()
++    >>>
++    >>> qutip.settings.colorblind_safe = True
++    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
++    >>> fig.show()
++    >>> qutip.settings.colorblind_safe = False
++    >>>
++    >>> fig, ax = qutip.hinton(dm, color_style="phase")
++    >>> fig.show()
++    """
++
++    # Apply default colormaps.
++    # TODO: abstract this away into something that makes default
++    #       colormaps.
++    cmap = (
++        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
++        if cmap is None else cmap
++    )
++
++    # Extract plotting data W from the input.
++    if isinstance(rho, Qobj):
++        if rho.isoper:
++            W = rho.full()
++
++            # Create default labels if none are given.
++            if xlabels is None or ylabels is None:
++                labels = _cb_labels(rho.dims[0])
++                xlabels = xlabels if xlabels is not None else list(labels[0])
++                ylabels = ylabels if ylabels is not None else list(labels[1])
++
++        elif rho.isoperket:
++            W = vector_to_operator(rho).full()
++        elif rho.isoperbra:
++            W = vector_to_operator(rho.dag()).full()
++        elif rho.issuper:
++            if not isqubitdims(rho.dims):
++                raise ValueError("Hinton plots of superoperators are "
++                                 "currently only supported for qubits.")
++            # Convert to a superoperator in the Pauli basis,
++            # so that all the elements are real.
++            sqobj = _to_superpauli(rho)
++            nq = int(log2(sqobj.shape[0]) / 2)
++            W = sqobj.full().T
++            # Create default labels, too.
++            if (xlabels is None) or (ylabels is None):
++                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
++                xlabels = xlabels if xlabels is not None else labels
++                ylabels = ylabels if ylabels is not None else labels
++
++        else:
++            raise ValueError(
++                "Input quantum object must be an operator or superoperator."
++            )
++
++    else:
++        W = rho
++
++    if ax is None:
++        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
++    else:
++        fig = None
++
++    if not (xlabels or ylabels):
++        ax.axis('off')
++    if title:
++        ax.set_title(title)
++
++    ax.axis('equal')
++    ax.set_frame_on(False)
++
++    height, width = W.shape
++
++    w_max = 1.25 * max(abs(np.array(W)).flatten())
++    if w_max <= 0.0:
++        w_max = 1.0
++
++    # Set color_fn here.
++    if color_style == "scaled":
++        def color_fn(w):
++            w = np.abs(w) * np.sign(np.real(w))
++            return cmap(int((w + w_max) * 256 / (2 * w_max)))
++    elif color_style == "threshold":
++        def color_fn(w):
++            w = np.real(w)
++            return cmap(255 if w > 0 else 0)
++    elif color_style == "phase":
++        def color_fn(w):
++            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
++    else:
++        raise ValueError(
++            "Unknown color style {} for Hinton diagrams.".format(color_style)
++        )
++
++    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
++            color=cmap(128))
++    for x in range(width):
++        for y in range(height):
++            _x = x + 1
++            _y = y + 1
++            _blob(
++                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
++                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
++
++    # color axis
++    vmax = np.pi if color_style == "phase" else abs(W).max()
++    norm = mpl.colors.Normalize(-vmax, vmax)
++    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
++    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
++
++    xtics = 0.5 + np.arange(width)
++    # x axis
++    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
++    if xlabels:
++        nxlabels = len(xlabels)
++        if nxlabels != len(xtics):
++            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
++        ax.set_xticklabels(xlabels)
++        if label_top:
++            ax.xaxis.tick_top()
++    ax.tick_params(axis='x', labelsize=14)
++
++    # y axis
++    ytics = 0.5 + np.arange(height)
++    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
++    if ylabels:
++        nylabels = len(ylabels)
++        if nylabels != len(ytics):
++            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
++        ax.set_yticklabels(list(reversed(ylabels)))
++    ax.tick_params(axis='y', labelsize=14)
++
++    return fig, ax
++
++
++def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
++    """Plots a matrix of values on a sphere
++
++    Parameters
++    ----------
++    theta : float
++        Angle with respect to z-axis
++
++    phi : float
++        Angle in x-y plane
++
++    values : array
++        Data set to be plotted
++
++    fig : a matplotlib Figure instance
++        The Figure canvas in which the plot will be drawn.
++
++    ax : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    save : bool {False , True}
++        Whether to save the figure or not
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++    if fig is None or ax is None:
++        fig = plt.figure()
++        ax = _axes3D(fig)
++
++    thetam, phim = np.meshgrid(theta, phi)
++    xx = sin(thetam) * cos(phim)
++    yy = sin(thetam) * sin(phim)
++    zz = cos(thetam)
++    r = array(abs(values))
++    ph = angle(values)
++    # normalize color range based on phase angles in list ph
++    nrm = mpl.colors.Normalize(ph.min(), ph.max())
++
++    # plot with facecolors set to cm.jet colormap normalized to nrm
++    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
++                    facecolors=cm.jet(nrm(ph)), linewidth=0)
++    # create new axes on plot for colorbar and shrink it a bit.
++    # pad shifts location of bar with repsect to the main plot
++    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
++
++    # create new colorbar in axes cax with cm jet and normalized to nrm like
++    # our facecolors
++    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
++    # add our colorbar label
++    cb1.set_label('Angle')
++
++    if save:
++        plt.savefig("sphereplot.png")
++
++    return fig, ax
++
++
++def _remove_margins(axis):
++    """
++    removes margins about z = 0 and improves the style
++    by monkey patching
++    """
++    def _get_coord_info_new(renderer):
++        mins, maxs, centers, deltas, tc, highs = \
++            _get_coord_info_old(renderer)
++        mins += deltas / 4
++        maxs -= deltas / 4
++        return mins, maxs, centers, deltas, tc, highs
++
++    _get_coord_info_old = axis._get_coord_info
++    axis._get_coord_info = _get_coord_info_new
++
++
++def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
++    """
++    truncates portion of a colormap and returns the new one
++    """
++    if isinstance(cmap, str):
++        cmap = plt.get_cmap(cmap)
++    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
++        'trunc({n},{a:.2f},{b:.2f})'.format(
++            n=cmap.name, a=minval, b=maxval),
++        cmap(np.linspace(minval, maxval, n)))
++    return new_cmap
++
++
++def _stick_to_planes(stick, azim, ax, M, spacing):
++    """adjusts xlim and ylim in way that bars will
++    Stick to xz and yz planes
++    """
++    if stick is True:
++        azim = azim % 360
++        if 0 <= azim <= 90:
++            ax.set_ylim(1 - .5,)
++            ax.set_xlim(1 - .5,)
++        elif 90 < azim <= 180:
++            ax.set_ylim(1 - .5,)
++            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
++        elif 180 < azim <= 270:
++            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
++            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
++        elif 270 < azim < 360:
++            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
++            ax.set_xlim(1 - .5,)
++
++
++def _update_yaxis(spacing, M, ax, ylabels):
++    """
++    updates the y-axis
++    """
++    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
++    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
++    if ylabels:
++        nylabels = len(ylabels)
++        if nylabels != len(ytics):
++            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
++        ax.set_yticklabels(ylabels)
++    else:
++        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
++        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
++    ax.tick_params(axis='y', labelsize=14)
++    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
++
++
++def _update_xaxis(spacing, M, ax, xlabels):
++    """
++    updates the x-axis
++    """
++    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
++    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
++    if xlabels:
++        nxlabels = len(xlabels)
++        if nxlabels != len(xtics):
++            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
++        ax.set_xticklabels(xlabels)
++    else:
++        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
++        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
++    ax.tick_params(axis='x', labelsize=14)
++    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
++
++
++def _update_zaxis(ax, z_min, z_max, zticks):
++    """
++    updates the z-axis
++    """
++    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
++    if isinstance(zticks, list):
++        ax.set_zticks(zticks)
++    ax.set_zlim3d([min(z_min, 0), z_max])
++
++
++def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
++                     colorbar=True, fig=None, ax=None, options=None):
++    """
++    Draw a histogram for the matrix M, with the given x and y labels and title.
++
++    Parameters
++    ----------
++    M : Matrix of Qobj
++        The matrix to visualize
++
++    xlabels : list of strings
++        list of x labels
++
++    ylabels : list of strings
++        list of y labels
++
++    title : string
++        title of the plot (optional)
++
++    limits : list/array with two float numbers
++        The z-axis limits [min, max] (optional)
++
++    ax : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    colorbar : bool (default: True)
++        show colorbar
++
++    options : dict
++        A dictionary containing extra options for the plot.
++        The names (keys) and values of the options are
++        described below:
++
++        'zticks' : list of numbers
++            A list of z-axis tick locations.
++
++        'cmap' : string (default: 'jet')
++            The name of the color map to use.
++
++        'cmap_min' : float (default: 0.0)
++            The lower bound to truncate the color map at.
++            A value in range 0 - 1. The default, 0, leaves the lower
++            bound of the map unchanged.
++
++        'cmap_max' : float (default: 1.0)
++            The upper bound to truncate the color map at.
++            A value in range 0 - 1. The default, 1, leaves the upper
++            bound of the map unchanged.
++
++        'bars_spacing' : float (default: 0.1)
++            spacing between bars.
++
++        'bars_alpha' : float (default: 1.)
++            transparency of bars, should be in range 0 - 1
++
++        'bars_lw' : float (default: 0.5)
++            linewidth of bars' edges.
++
++        'bars_edgecolor' : color (default: 'k')
++            The colors of the bars' edges.
++            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
++
++        'shade' : bool (default: True)
++            Whether to shade the dark sides of the bars (True) or not (False).
++            The shading is relative to plot's source of light.
++
++        'azim' : float
++            The azimuthal viewing angle.
++
++        'elev' : float
++            The elevation viewing angle.
++
++        'proj_type' : string (default: 'ortho' if ax is not passed)
++            The type of projection ('ortho' or 'persp')
++
++        'stick' : bool (default: False)
++            Changes xlim and ylim in such a way that bars next to
++            XZ and YZ planes will stick to those planes.
++            This option has no effect if ``ax`` is passed as a parameter.
++
++        'cbar_pad' : float (default: 0.04)
++            The fraction of the original axes between the colorbar
++            and the new image axes.
++            (i.e. the padding between the 3D figure and the colorbar).
++
++        'cbar_to_z' : bool (default: False)
++            Whether to set the color of maximum and minimum z-values to the
++            maximum and minimum colors in the colorbar (True) or not (False).
++
++        'figsize' : tuple of two numbers
++            The size of the figure.
++
++    Returns :
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    Raises
++    ------
++    ValueError
++        Input argument is not valid.
++
++    """
++
++    # default options
++    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
++                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
++                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
++                    'shade': False, 'azim': -35, 'elev': 35,
++                    'proj_type': 'ortho', 'stick': False,
++                    'cbar_pad': 0.04, 'cbar_to_z': False}
++
++    # update default_opts from input options
++    if options is None:
++        pass
++    elif isinstance(options, dict):
++        # check if keys in options dict are valid
++        if set(options) - set(default_opts):
++            raise ValueError("invalid key(s) found in options: "
++                             f"{', '.join(set(options) - set(default_opts))}")
++        else:
++            # updating default options
++            default_opts.update(options)
++    else:
++        raise ValueError("options must be a dictionary")
++
++    if isinstance(M, Qobj):
++        # extract matrix data from Qobj
++        M = M.full()
++
++    n = np.size(M)
++    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
++    xpos = xpos.T.flatten() + 0.5
++    ypos = ypos.T.flatten() + 0.5
++    zpos = np.zeros(n)
++    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
++    dz = np.real(M.flatten())
++
++    if isinstance(limits, list) and len(limits) == 2:
++        z_min = limits[0]
++        z_max = limits[1]
++    else:
++        z_min = min(dz)
++        z_max = max(dz)
++        if z_min == z_max:
++            z_min -= 0.1
++            z_max += 0.1
++
++    if default_opts['cbar_to_z']:
++        norm = mpl.colors.Normalize(min(dz), max(dz))
++    else:
++        norm = mpl.colors.Normalize(z_min, z_max)
++    cmap = _truncate_colormap(default_opts['cmap'],
++                              default_opts['cmap_min'],
++                              default_opts['cmap_max'])
++    colors = cmap(norm(dz))
++
++    if ax is None:
++        fig = plt.figure(figsize=default_opts['figsize'])
++        ax = _axes3D(fig,
++                     azim=default_opts['azim'] % 360,
++                     elev=default_opts['elev'] % 360)
++        ax.set_proj_type(default_opts['proj_type'])
++
++    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
++             edgecolors=default_opts['bars_edgecolor'],
++             linewidths=default_opts['bars_lw'],
++             alpha=default_opts['bars_alpha'],
++             shade=default_opts['shade'])
++    # remove vertical lines on xz and yz plane
++    ax.yaxis._axinfo["grid"]['linewidth'] = 0
++    ax.xaxis._axinfo["grid"]['linewidth'] = 0
++
++    if title:
++        ax.set_title(title)
++
++    # x axis
++    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
++
++    # y axis
++    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
++
++    # z axis
++    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
++
++    # stick to xz and yz plane
++    _stick_to_planes(default_opts['stick'],
++                     default_opts['azim'], ax, M,
++                     default_opts['bars_spacing'])
++
++    # color axis
++    if colorbar:
++        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
++                                         pad=default_opts['cbar_pad'])
++        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
++
++    # removing margins
++    _remove_margins(ax.xaxis)
++    _remove_margins(ax.yaxis)
++    _remove_margins(ax.zaxis)
++
++    return fig, ax
++
++
++def matrix_histogram_complex(M, xlabels=None, ylabels=None,
++                             title=None, limits=None, phase_limits=None,
++                             colorbar=True, fig=None, ax=None,
++                             threshold=None):
++    """
++    Draw a histogram for the amplitudes of matrix M, using the argument
++    of each element for coloring the bars, with the given x and y labels
++    and title.
++
++    Parameters
++    ----------
++    M : Matrix of Qobj
++        The matrix to visualize
++
++    xlabels : list of strings
++        list of x labels
++
++    ylabels : list of strings
++        list of y labels
++
++    title : string
++        title of the plot (optional)
++
++    limits : list/array with two float numbers
++        The z-axis limits [min, max] (optional)
++
++    phase_limits : list/array with two float numbers
++        The phase-axis (colorbar) limits [min, max] (optional)
++
++    ax : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    threshold: float (None)
++        Threshold for when bars of smaller height should be transparent. If
++        not set, all bars are colored according to the color map.
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    Raises
++    ------
++    ValueError
++        Input argument is not valid.
++
++    """
++
++    if isinstance(M, Qobj):
++        # extract matrix data from Qobj
++        M = M.full()
++
++    n = np.size(M)
++    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
++    xpos = xpos.T.flatten() - 0.5
++    ypos = ypos.T.flatten() - 0.5
++    zpos = np.zeros(n)
++    dx = dy = 0.8 * np.ones(n)
++    Mvec = M.flatten()
++    dz = abs(Mvec)
++
++    # make small numbers real, to avoid random colors
++    idx, = np.where(abs(Mvec) < 0.001)
++    Mvec[idx] = abs(Mvec[idx])
++
++    if phase_limits:  # check that limits is a list type
++        phase_min = phase_limits[0]
++        phase_max = phase_limits[1]
++    else:
++        phase_min = -pi
++        phase_max = pi
++
++    norm = mpl.colors.Normalize(phase_min, phase_max)
++    cmap = complex_phase_cmap()
++
++    colors = cmap(norm(angle(Mvec)))
++    if threshold is not None:
++        colors[:, 3] = 1 * (dz > threshold)
++
++    if ax is None:
++        fig = plt.figure()
++        ax = _axes3D(fig, azim=-35, elev=35)
++
++    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
++
++    if title:
++        ax.set_title(title)
++
++    # x axis
++    xtics = -0.5 + np.arange(M.shape[0])
++    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
++    if xlabels:
++        nxlabels = len(xlabels)
++        if nxlabels != len(xtics):
++            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
++        ax.set_xticklabels(xlabels)
++    ax.tick_params(axis='x', labelsize=12)
++
++    # y axis
++    ytics = -0.5 + np.arange(M.shape[1])
++    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
++    if ylabels:
++        nylabels = len(ylabels)
++        if nylabels != len(ytics):
++            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
++        ax.set_yticklabels(ylabels)
++    ax.tick_params(axis='y', labelsize=12)
++
++    # z axis
++    if limits and isinstance(limits, list):
++        ax.set_zlim3d(limits)
++    else:
++        ax.set_zlim3d([0, 1])  # use min/max
++    # ax.set_zlabel('abs')
++
++    # color axis
++    if colorbar:
++        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
++        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
++        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
++        cb.set_ticklabels(
++            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
++        cb.set_label('arg')
++
++    return fig, ax
++
++
++def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
++                       figsize=(8, 12), fig=None, ax=None):
++    """
++    Plot the energy level diagrams for a list of Hamiltonians. Include
++    up to N energy levels. For each element in H_list, the energy
++    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
++    where n is the index of an element in H_list.
++
++    Parameters
++    ----------
++
++        H_list : List of Qobj
++            A list of Hamiltonians.
++
++        labels : List of string
++            A list of labels for each Hamiltonian
++
++        show_ylabels : Bool (default False)
++            Show y labels to the left of energy levels of the initial
++            Hamiltonian.
++
++        N : int
++            The number of energy levels to plot
++
++        figsize : tuple (int,int)
++            The size of the figure (width, height).
++
++        fig : a matplotlib Figure instance
++            The Figure canvas in which the plot will be drawn.
++
++        ax : a matplotlib axes instance
++            The axes context in which the plot will be drawn.
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    Raises
++    ------
++
++        ValueError
++            Input argument is not valid.
++
++    """
++
++    if not isinstance(H_list, list):
++        raise ValueError("H_list must be a list of Qobj instances")
++
++    if not fig and not ax:
++        fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++    H = H_list[0]
++    N = H.shape[0] if N == 0 else min(H.shape[0], N)
++
++    xticks = []
++    yticks = []
++
++    x = 0
++    evals0 = H.eigenenergies(eigvals=N)
++    for e_idx, e in enumerate(evals0[:N]):
++        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
++        yticks.append(e)
++    xticks.append(x + 1)
++    x += 2
++
++    for H1 in H_list[1:]:
++
++        H = H + H1
++        evals1 = H.eigenenergies()
++
++        for e_idx, e in enumerate(evals1[:N]):
++            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
++        x += 1
++
++        for e_idx, e in enumerate(evals1[:N]):
++            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
++        xticks.append(x + 1)
++        x += 2
++
++        evals0 = evals1
++
++    ax.set_frame_on(False)
++
++    if show_ylabels:
++        yticks = np.unique(np.around(yticks, 1))
++        ax.set_yticks(yticks)
++    else:
++        ax.axes.get_yaxis().set_visible(False)
++
++    if labels:
++        ax.get_xaxis().tick_bottom()
++        ax.set_xticks(xticks)
++        ax.set_xticklabels(labels, fontsize=16)
++    else:
++        ax.axes.get_xaxis().set_visible(False)
++
++    return fig, ax
++
++
++def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
++                         figsize=(8, 12), fig=None, ax=None):
++    warnings.warn("Deprecated: Use plot_energy_levels")
++    return plot_energy_levels(H_list, N=N, labels=labels,
++                              show_ylabels=show_ylabels,
++                              figsize=figsize, fig=fig, ax=ax)
++
++
++def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
++                           figsize=(8, 6), title=None, unit_y_range=True):
++    """
++    Plot the Fock distribution for a density matrix (or ket) that describes
++    an oscillator mode.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        The density matrix (or ket) of the state to visualize.
++
++    fig : a matplotlib Figure instance
++        The Figure canvas in which the plot will be drawn.
++
++    ax : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    title : string
++        An optional title for the figure.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++
++    if not fig and not ax:
++        fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++    if isket(rho):
++        rho = ket2dm(rho)
++
++    N = rho.shape[0]
++
++    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
++           color="green", alpha=0.6, width=0.8)
++    if unit_y_range:
++        ax.set_ylim(0, 1)
++
++    ax.set_xlim(-.5 + offset, N + offset)
++    ax.set_xlabel('Fock number', fontsize=12)
++    ax.set_ylabel('Occupation probability', fontsize=12)
++
++    if title:
++        ax.set_title(title)
++
++    return fig, ax
++
++
++def fock_distribution(rho, offset=0, fig=None, ax=None,
++                      figsize=(8, 6), title=None, unit_y_range=True):
++    warnings.warn("Deprecated: Use plot_fock_distribution")
++    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
++                                  figsize=figsize, title=title,
++                                  unit_y_range=unit_y_range)
++
++
++def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
++                cmap=None, alpha_max=7.5, colorbar=False,
++                method='clenshaw', projection='2d'):
++    """
++    Plot the the Wigner function for a density matrix (or ket) that describes
++    an oscillator mode.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        The density matrix (or ket) of the state to visualize.
++
++    fig : a matplotlib Figure instance
++        The Figure canvas in which the plot will be drawn.
++
++    ax : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    cmap : a matplotlib cmap instance
++        The colormap.
++
++    alpha_max : float
++        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
++
++    colorbar : bool
++        Whether (True) or not (False) a colorbar should be attached to the
++        Wigner function graph.
++
++    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
++        The method used for calculating the wigner function. See the
++        documentation for qutip.wigner for details.
++
++    projection: string {'2d', '3d'}
++        Specify whether the Wigner function is to be plotted as a
++        contour graph ('2d') or surface plot ('3d').
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++
++    if not fig and not ax:
++        if projection == '2d':
++            fig, ax = plt.subplots(1, 1, figsize=figsize)
++        elif projection == '3d':
++            fig = plt.figure(figsize=figsize)
++            ax = fig.add_subplot(1, 1, 1, projection='3d')
++        else:
++            raise ValueError('Unexpected value of projection keyword argument')
++
++    if isket(rho):
++        rho = ket2dm(rho)
++
++    xvec = np.linspace(-alpha_max, alpha_max, 200)
++    W0 = wigner(rho, xvec, xvec, method=method)
++
++    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
++
++    wlim = abs(W).max()
++
++    if cmap is None:
++        cmap = cm.get_cmap('RdBu')
++
++    if projection == '2d':
++        cf = ax.contourf(xvec, yvec, W, 100,
++                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
++    elif projection == '3d':
++        X, Y = np.meshgrid(xvec, xvec)
++        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
++                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
++    else:
++        raise ValueError('Unexpected value of projection keyword argument.')
++
++    if xvec is not yvec:
++        ax.set_ylim(xvec.min(), xvec.max())
++
++    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
++    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
++
++    if colorbar:
++        fig.colorbar(cf, ax=ax)
++
++    ax.set_title("Wigner function", fontsize=12)
++
++    return fig, ax
++
++
++def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
++                                  cmap=None, alpha_max=7.5, colorbar=False,
++                                  method='iterative', projection='2d'):
++    """
++    Plot the Fock distribution and the Wigner function for a density matrix
++    (or ket) that describes an oscillator mode.
++
++    Parameters
++    ----------
++    rho : :class:`qutip.Qobj`
++        The density matrix (or ket) of the state to visualize.
++
++    fig : a matplotlib Figure instance
++        The Figure canvas in which the plot will be drawn.
++
++    axes : a list of two matplotlib axes instances
++        The axes context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    cmap : a matplotlib cmap instance
++        The colormap.
++
++    alpha_max : float
++        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
++
++    colorbar : bool
++        Whether (True) or not (False) a colorbar should be attached to the
++        Wigner function graph.
++
++    method : string {'iterative', 'laguerre', 'fft'}
++        The method used for calculating the wigner function. See the
++        documentation for qutip.wigner for details.
++
++    projection: string {'2d', '3d'}
++        Specify whether the Wigner function is to be plotted as a
++        contour graph ('2d') or surface plot ('3d').
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++
++    if not fig and not axes:
++        if projection == '2d':
++            fig, axes = plt.subplots(1, 2, figsize=figsize)
++        elif projection == '3d':
++            fig = plt.figure(figsize=figsize)
++            axes = [fig.add_subplot(1, 2, 1),
++                    fig.add_subplot(1, 2, 2, projection='3d')]
++        else:
++            raise ValueError('Unexpected value of projection keyword argument')
++
++    if isket(rho):
++        rho = ket2dm(rho)
++
++    plot_fock_distribution(rho, fig=fig, ax=axes[0])
++    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
++                alpha_max=alpha_max, colorbar=colorbar, method=method,
++                projection=projection)
++
++    return fig, axes
++
++
++def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
++                             cmap=None, alpha_max=7.5, colorbar=False,
++                             method='iterative'):
++    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
++    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
++                                         figsize=figsize, cmap=cmap,
++                                         alpha_max=alpha_max,
++                                         colorbar=colorbar,
++                                         method=method)
++
++
++def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
++                            fig=None, axes=None, figsize=(8, 4)):
++    """
++    Visualize the results (expectation values) for an evolution solver.
++    `results` is assumed to be an instance of Result, or a list of Result
++    instances.
++
++    Parameters
++    ----------
++    results : (list of) :class:`qutip.solver.Result`
++        List of results objects returned by any of the QuTiP evolution solvers.
++
++    ylabels : list of strings
++        The y-axis labels. List should be of the same length as `results`.
++
++    title : string
++        The title of the figure.
++
++    show_legend : bool
++        Whether or not to show the legend.
++
++    fig : a matplotlib Figure instance
++        The Figure canvas in which the plot will be drawn.
++
++    axes : a matplotlib axes instance
++        The axes context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++    if not isinstance(results, list):
++        results = [results]
++
++    n_e_ops = max([len(result.expect) for result in results])
++
++    if not fig or not axes:
++        if not figsize:
++            figsize = (12, 3 * n_e_ops)
++        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
++                                 figsize=figsize, squeeze=False)
++
++    for r_idx, result in enumerate(results):
++        for e_idx, e in enumerate(result.expect):
++            axes[e_idx, 0].plot(result.times, e,
++                                label="%s [%d]" % (result.solver, e_idx))
++
++    if title:
++        fig.suptitle(title)
++
++    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
++    for n in range(n_e_ops):
++        if show_legend:
++            axes[n, 0].legend()
++        if ylabels:
++            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
++
++    return fig, axes
++
++
++def plot_spin_distribution_2d(P, THETA, PHI,
++                              fig=None, ax=None, figsize=(8, 8)):
++    """
++    Plot a spin distribution function (given as meshgrid data) with a 2D
++    projection where the surface of the unit sphere is mapped on the unit disk.
++
++    Parameters
++    ----------
++    P : matrix
++        Distribution values as a meshgrid matrix.
++
++    THETA : matrix
++        Meshgrid matrix for the theta coordinate.
++
++    PHI : matrix
++        Meshgrid matrix for the phi coordinate.
++
++    fig : a matplotlib figure instance
++        The figure canvas on which the plot will be drawn.
++
++    ax : a matplotlib axis instance
++        The axis context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++    """
++
++    if not fig or not ax:
++        if not figsize:
++            figsize = (8, 8)
++        fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++    Y = (THETA - pi / 2) / (pi / 2)
++    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
++
++    if P.min() < -1e12:
++        cmap = cm.RdBu
++    else:
++        cmap = cm.RdYlBu
++
++    ax.pcolor(X, Y, P.real, cmap=cmap)
++    ax.set_xlabel(r'$\varphi$', fontsize=18)
++    ax.set_ylabel(r'$\theta$', fontsize=18)
++
++    ax.set_xticks([-1, 0, 1])
++    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
++    ax.set_yticks([-1, 0, 1])
++    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
++
++    return fig, ax
++
++
++def plot_spin_distribution_3d(P, THETA, PHI,
++                              fig=None, ax=None, figsize=(8, 6)):
++    """Plots a matrix of values on a sphere
++
++    Parameters
++    ----------
++    P : matrix
++        Distribution values as a meshgrid matrix.
++
++    THETA : matrix
++        Meshgrid matrix for the theta coordinate.
++
++    PHI : matrix
++        Meshgrid matrix for the phi coordinate.
++
++    fig : a matplotlib figure instance
++        The figure canvas on which the plot will be drawn.
++
++    ax : a matplotlib axis instance
++        The axis context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    """
++
++    if fig is None or ax is None:
++        fig = plt.figure(figsize=figsize)
++        ax = _axes3D(fig, azim=-35, elev=35)
++
++    xx = sin(THETA) * cos(PHI)
++    yy = sin(THETA) * sin(PHI)
++    zz = cos(THETA)
++
++    if P.min() < -1e12:
++        cmap = cm.RdBu
++        norm = mpl.colors.Normalize(-P.max(), P.max())
++    else:
++        cmap = cm.RdYlBu
++        norm = mpl.colors.Normalize(P.min(), P.max())
++
++    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
++                    facecolors=cmap(norm(P)), linewidth=0)
++
++    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
++    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
++    cb1.set_label('magnitude')
++
++    return fig, ax
++
++
++#
++# Qubism and other qubistic visualizations
++#
++def complex_array_to_rgb(X, theme='light', rmax=None):
++    """
++    Makes an array of complex number and converts it to an array of [r, g, b],
++    where phase gives hue and saturation/value are given by the absolute value.
++    Especially for use with imshow for complex plots.
++
++    For more info on coloring, see:
++        Emilia Petrisor,
++        Visualizing complex-valued functions with Matplotlib and Mayavi
++        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
++
++    Parameters
++    ----------
++    X : array
++        Array (of any dimension) of complex numbers.
++
++    theme : 'light' (default) or 'dark'
++        Set coloring theme for mapping complex values into colors.
++
++    rmax : float
++        Maximal abs value for color normalization.
++        If None (default), uses np.abs(X).max().
++
++    Returns
++    -------
++    Y : array
++        Array of colors (of shape X.shape + (3,)).
++
++    """
++
++    absmax = rmax or np.abs(X).max()
++    if absmax == 0.:
++        absmax = 1.
++    Y = np.zeros(X.shape + (3,), dtype='float')
++    Y[..., 0] = np.angle(X) / (2 * pi) % 1
++    if theme == 'light':
++        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
++        Y[..., 2] = 1
++    elif theme == 'dark':
++        Y[..., 1] = 1
++        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
++    Y = mpl.colors.hsv_to_rgb(Y)
++    return Y
++
++
++def _index_to_sequence(i, dim_list):
++    """
++    For a matrix entry with index i it returns state it corresponds to.
++    In particular, for dim_list=[2]*n it returns i written as a binary number.
++
++    Parameters
++    ----------
++    i : int
++        Index in a matrix.
++
++    dim_list : list of int
++        List of dimensions of consecutive particles.
++
++    Returns
++    -------
++    seq : list
++        List of coordinates for each particle.
++
++    """
++    res = []
++    j = i
++    for d in reversed(dim_list):
++        j, s = divmod(j, d)
++        res.append(s)
++    return list(reversed(res))
++
++
++def _sequence_to_index(seq, dim_list):
++    """
++    Inverse of _index_to_sequence.
++
++    Parameters
++    ----------
++    seq : list of ints
++        List of coordinates for each particle.
++
++    dim_list : list of int
++        List of dimensions of consecutive particles.
++
++    Returns
++    -------
++    i : list
++        Index in a matrix.
++
++    """
++    i = 0
++    for s, d in zip(seq, dim_list):
++        i *= d
++        i += s
++
++    return i
++
++
++def _to_qubism_index_pair(i, dim_list, how='pairs'):
++    """
++    For a matrix entry with index i
++    it returns x, y coordinates in qubism mapping.
++
++    Parameters
++    ----------
++    i : int
++        Index in a matrix.
++
++    dim_list : list of int
++        List of dimensions of consecutive particles.
++
++    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
++        Type of qubistic plot.
++
++    Returns
++    -------
++    x, y : tuple of ints
++        List of coordinates for each particle.
++
++    """
++    seq = _index_to_sequence(i, dim_list)
++
++    if how == 'pairs':
++        y = _sequence_to_index(seq[::2], dim_list[::2])
++        x = _sequence_to_index(seq[1::2], dim_list[1::2])
++    elif how == 'pairs_skewed':
++        dim_list2 = dim_list[::2]
++        y = _sequence_to_index(seq[::2], dim_list2)
++        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
++        x = _sequence_to_index(seq2, dim_list2)
++    elif how == 'before_after':
++        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
++        n = len(dim_list)
++        y = _sequence_to_index(reversed(seq[:(n // 2)]),
++                               reversed(dim_list[:(n // 2)]))
++        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
++    else:
++        raise Exception("No such 'how'.")
++
++    return x, y
++
++
++def _sequence_to_latex(seq, style='ket'):
++    """
++    For a sequence of particle states generate LaTeX code.
++
++    Parameters
++    ----------
++    seq : list of ints
++        List of coordinates for each particle.
++
++    style : 'ket' (default), 'bra' or 'bare'
++        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
++
++    Returns
++    -------
++    latex : str
++        LaTeX output.
++
++    """
++    if style == 'ket':
++        latex = "$\\left|{0}\\right\\rangle$"
++    elif style == 'bra':
++        latex = "$\\left\\langle{0}\\right|$"
++    elif style == 'bare':
++        latex = "${0}$"
++    else:
++        raise Exception("No such style.")
++    return latex.format("".join(map(str, seq)))
++
++
++def plot_qubism(ket, theme='light', how='pairs',
++                grid_iteration=1, legend_iteration=0,
++                fig=None, ax=None, figsize=(6, 6)):
++    """
++    Qubism plot for pure states of many qudits.  Works best for spin chains,
++    especially with even number of particles of the same dimension.  Allows to
++    see entanglement between first 2k particles and the rest.
++
++    Parameters
++    ----------
++    ket : Qobj
++        Pure state for plotting.
++
++    theme : 'light' (default) or 'dark'
++        Set coloring theme for mapping complex values into colors.
++        See: complex_array_to_rgb.
++
++    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
++        Type of Qubism plotting.  Options:
++
++        - 'pairs' - typical coordinates,
++        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
++        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
++
++    grid_iteration : int (default 1)
++        Helper lines to be drawn on plot.
++        Show tiles for 2*grid_iteration particles vs all others.
++
++    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
++        Show labels for first ``2*legend_iteration`` particles.  Option
++        'grid_iteration' sets the same number of particles as for
++        grid_iteration.  Option 'all' makes label for all particles.  Typically
++        it should be 0, 1, 2 or perhaps 3.
++
++    fig : a matplotlib figure instance
++        The figure canvas on which the plot will be drawn.
++
++    ax : a matplotlib axis instance
++        The axis context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    Notes
++    -----
++    See also [1]_.
++
++    References
++    ----------
++    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
++       and G. Sierra, *Qubism: self-similar visualization of many-body
++       wavefunctions*, `New J. Phys. 14 053028
++       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
++       (2012), open access.
++    """
++
++    if not isket(ket):
++        raise Exception("Qubism works only for pure states, i.e. kets.")
++        # add for dm? (perhaps a separate function, plot_qubism_dm)
++
++    if not fig and not ax:
++        fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++    dim_list = ket.dims[0]
++    n = len(dim_list)
++
++    # for odd number of particles - pixels are rectangular
++    if n % 2 == 1:
++        ket = tensor(ket, Qobj([1] * dim_list[-1]))
++        dim_list = ket.dims[0]
++        n += 1
++
++    ketdata = ket.full()
++
++    if how == 'pairs':
++        dim_list_y = dim_list[::2]
++        dim_list_x = dim_list[1::2]
++    elif how == 'pairs_skewed':
++        dim_list_y = dim_list[::2]
++        dim_list_x = dim_list[1::2]
++        if dim_list_x != dim_list_y:
++            raise Exception("For 'pairs_skewed' pairs " +
++                            "of dimensions need to be the same.")
++    elif how == 'before_after':
++        dim_list_y = list(reversed(dim_list[:(n // 2)]))
++        dim_list_x = dim_list[(n // 2):]
++    else:
++        raise Exception("No such 'how'.")
++
++    size_x = np.prod(dim_list_x)
++    size_y = np.prod(dim_list_y)
++
++    qub = np.zeros([size_x, size_y], dtype=complex)
++    for i in range(ketdata.size):
++        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
++    qub = qub.transpose()
++
++    quadrants_x = np.prod(dim_list_x[:grid_iteration])
++    quadrants_y = np.prod(dim_list_y[:grid_iteration])
++
++    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
++    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
++
++    ax.set_xticks(ticks_x)
++    ax.set_xticklabels([""] * (quadrants_x - 1))
++    ax.set_yticks(ticks_y)
++    ax.set_yticklabels([""] * (quadrants_y - 1))
++    theme2color_of_lines = {'light': '#000000',
++                            'dark': '#FFFFFF'}
++    ax.grid(True, color=theme2color_of_lines[theme])
++    ax.imshow(complex_array_to_rgb(qub, theme=theme),
++              interpolation="none",
++              extent=(0, size_x, 0, size_y))
++
++    if legend_iteration == 'all':
++        label_n = n // 2
++    elif legend_iteration == 'grid_iteration':
++        label_n = grid_iteration
++    else:
++        try:
++            label_n = int(legend_iteration)
++        except:
++            raise Exception("No such option for legend_iteration keyword " +
++                            "argument. Use 'all', 'grid_iteration' or an " +
++                            "integer.")
++
++    if label_n:
++
++        if how == 'before_after':
++            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
++                + dim_list_x[:label_n]
++        else:
++            dim_list_small = []
++            for j in range(label_n):
++                dim_list_small.append(dim_list_y[j])
++                dim_list_small.append(dim_list_x[j])
++
++        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
++        shift_x = 0.5 * scale_x
++        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
++        shift_y = 0.5 * scale_y
++
++        bbox = ax.get_window_extent().transformed(
++            fig.dpi_scale_trans.inverted())
++        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
++        opts = {'fontsize': fontsize,
++                'color': theme2color_of_lines[theme],
++                'horizontalalignment': 'center',
++                'verticalalignment': 'center'}
++        for i in range(np.prod(dim_list_small)):
++            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
++            seq = _index_to_sequence(i, dim_list=dim_list_small)
++            ax.text(scale_x * x + shift_x,
++                    size_y - (scale_y * y + shift_y),
++                    _sequence_to_latex(seq),
++                    **opts)
++    return fig, ax
++
++
++def plot_schmidt(ket, splitting=None,
++                 labels_iteration=(3, 2),
++                 theme='light',
++                 fig=None, ax=None, figsize=(6, 6)):
++    """
++    Plotting scheme related to Schmidt decomposition.
++    Converts a state into a matrix (A_ij -> A_i^j),
++    where rows are first particles and columns - last.
++
++    See also: plot_qubism with how='before_after' for a similar plot.
++
++    Parameters
++    ----------
++    ket : Qobj
++        Pure state for plotting.
++
++    splitting : int
++        Plot for a number of first particles versus the rest.
++        If not given, it is (number of particles + 1) // 2.
++
++    theme : 'light' (default) or 'dark'
++        Set coloring theme for mapping complex values into colors.
++        See: complex_array_to_rgb.
++
++    labels_iteration : int or pair of ints (default (3,2))
++        Number of particles to be shown as tick labels,
++        for first (vertical) and last (horizontal) particles, respectively.
++
++    fig : a matplotlib figure instance
++        The figure canvas on which the plot will be drawn.
++
++    ax : a matplotlib axis instance
++        The axis context in which the plot will be drawn.
++
++    figsize : (width, height)
++        The size of the matplotlib figure (in inches) if it is to be created
++        (that is, if no 'fig' and 'ax' arguments are passed).
++
++    Returns
++    -------
++    fig, ax : tuple
++        A tuple of the matplotlib figure and axes instances used to produce
++        the figure.
++
++    """
++    if not isket(ket):
++        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
++
++    if not fig and not ax:
++        fig, ax = plt.subplots(1, 1, figsize=figsize)
++
++    dim_list = ket.dims[0]
++
++    if splitting is None:
++        splitting = (len(dim_list) + 1) // 2
++
++    if isinstance(labels_iteration, int):
++        labels_iteration = labels_iteration, labels_iteration
++
++    ketdata = ket.full()
++
++    dim_list_y = dim_list[:splitting]
++    dim_list_x = dim_list[splitting:]
++
++    size_x = np.prod(dim_list_x)
++    size_y = np.prod(dim_list_y)
++
++    ketdata = ketdata.reshape((size_y, size_x))
++
++    dim_list_small_x = dim_list_x[:labels_iteration[1]]
++    dim_list_small_y = dim_list_y[:labels_iteration[0]]
++
++    quadrants_x = np.prod(dim_list_small_x)
++    quadrants_y = np.prod(dim_list_small_y)
++
++    ticks_x = [size_x / quadrants_x * (i + 0.5)
++               for i in range(quadrants_x)]
++    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
++               for i in range(quadrants_y)]
++
++    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
++                                                      dim_list=dim_list_x))
++                for i in range(quadrants_x)]
++    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
++                                                      dim_list=dim_list_y))
++                for i in range(quadrants_y)]
++
++    ax.set_xticks(ticks_x)
++    ax.set_xticklabels(labels_x)
++    ax.set_yticks(ticks_y)
++    ax.set_yticklabels(labels_y)
++    ax.set_xlabel("last particles")
++    ax.set_ylabel("first particles")
++
++    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
++              interpolation="none",
++              extent=(0, size_x, 0, size_y))
++
++    return fig, ax
+diff --git a/qutip/wigner.py b/qutip/wigner.py
+index 48abd663..cc0a130f 100644
+--- a/qutip/wigner.py
++++ b/qutip/wigner.py
+@@ -1,1003 +1,1003 @@
+-__all__ = [
+-    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
+-    'wigner_transform',
+-]
+-
+-import numpy as np
+-import warnings
+-from numpy import (
+-    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
+-)
+-import scipy.sparse as sp
+-import scipy.fftpack as ft
+-import scipy.linalg as la
+-import scipy.special
+-from scipy.special import genlaguerre, binom, sph_harm, factorial
+-
+-import qutip
+-from qutip import Qobj, ket2dm, jmat
+-from .solver.parallel import parallel_map
+-from .utilities import clebsch
+-from .core import data as _data
+-from .core.data.eigen import eigh
+-
+-
+-def wigner_transform(psi, j, fullparity, steps, slicearray):
+-    """takes the density matrix or state vector of any finite state and
+-    generates the Wigner function for that state on a sphere, generating a spin
+-    Wigner function useful for displaying the quasi-probability for a qubit or
+-    any qudit. For the standard, continuous-variable Wigner function for
+-    position and momentum variables, wigner() should be used.
+-
+-    Parameters
+-    ----------
+-        psi : qobj
+-              a state vector or density matrix.
+-        j : int
+-            the total angular momentum of the quantum state.
+-        fullparity : bool
+-                     should the parity of the full SU space be used?
+-        steps : int
+-                number of points at which the Wigner transform is calculated.
+-        slicearray : list of str
+-                     the angle slice to be used for each particle in case of a
+-                     multi-particle quantum state. 'l' yields an equal angle
+-                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
+-
+-    Returns
+-    ----------
+-        wigner : list of float
+-                 the wigner transformation at `steps` different theta and phi.
+-
+-    Raises
+-    ------
+-    ComplexWarning
+-        This can be ignored as it is caused due to rounding errors.
+-
+-    Notes
+-    ------
+-    See example notebook wigner_visualisation.
+-
+-    References
+-    ------
+-    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
+-        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
+-    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
+-        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
+-    """
+-    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
+-        raise TypeError('Input state is not a valid operator.')
+-
+-    if psi.isket or psi.isbra:
+-        rho = psi.proj()
+-    else:
+-        rho = psi
+-
+-    sun = 2   # The order of the SU group
+-
+-    # calculate total number of particles in quantum state:
+-    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
+-
+-    theta = np.zeros((N, steps))
+-    phi = np.zeros((N, steps))
+-
+-    for i in range(N):
+-        theta[i, :] = np.linspace(0, np.pi, steps)
+-        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
+-
+-    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
+-
+-    wigner = np.zeros((steps, steps))
+-    if fullparity:
+-        pari = _parity(sun**N, j)
+-    else:
+-        pari = _parity(sun, j)
+-    for t in range(steps):
+-        for p in range(steps):
+-            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
+-            kernel = _data.dense.fast_from_numpy(kernel)
+-            wigner[t, p] = _data.expect(rho.data, kernel).real
+-    return wigner
+-
+-
+-def _parity(N, j):
+-    """Private function to calculate the parity of the quantum system.
+-    """
+-    if j == 0.5:
+-        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
+-        return pi / N
+-    elif j > 0.5:
+-        mult = np.int32(2 * j + 1)
+-        matrix = np.zeros((mult, mult))
+-        foo = np.ones(mult)
+-        for n in np.arange(-j, j + 1, 1):
+-            for l in np.arange(0, mult, 1):
+-                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
+-            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
+-        return matrix / mult
+-
+-
+-def _lambda_f(N):
+-    """Private function needed for the calculation of the parity.
+-    """
+-    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
+-    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
+-    return matrix
+-
+-
+-def _kernelsu2(theta, phi, N, j, parity, fullparity):
+-    """Private function that calculates the kernel for the SU2 unitary group.
+-    """
+-    U = np.ones(1)
+-    # calculate the total rotation matrix (tensor product for each particle):
+-    for i in range(0, N):
+-        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
+-    if not fullparity:
+-        op_parity = parity   # The parity for a one particle system
+-        for i in range(1, N):
+-            parity = np.kron(parity, op_parity)
+-    matrix = U @ parity @ U.conj().T
+-    return matrix
+-
+-
+-def _rotation_matrix(theta, phi, j):
+-    """Private function to calculate the rotation operator for the SU2 kernel.
+-    """
+-    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
+-           la.expm(1j * theta * jmat(j, 'y').full())
+-
+-
+-def _angle_slice(slicearray, theta, phi):
+-    """Private function to modify theta and phi for angle slicing.
+-    """
+-    xind = np.where(slicearray == 'x')
+-    theta[xind, :] = np.pi - theta[xind, :]
+-    phi[xind, :] = -phi[xind, :]
+-    yind = np.where(slicearray == 'y')
+-    theta[yind, :] = np.pi - theta[yind, :]
+-    phi[yind, :] = np.pi - phi[yind, :]
+-    zind = np.where(slicearray == 'z')
+-    phi[zind, :] = phi[zind, :] + np.pi
+-    return theta, phi
+-
+-
+-def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
+-           sparse=False, parfor=False):
+-    """Wigner function for a state vector or density matrix at points
+-    `xvec + i * yvec`.
+-
+-    Parameters
+-    ----------
+-
+-    state : qobj
+-        A state vector or density matrix.
+-
+-    xvec : array_like
+-        x-coordinates at which to calculate the Wigner function.
+-
+-    yvec : array_like
+-        y-coordinates at which to calculate the Wigner function.  Does not
+-        apply to the 'fft' method.
+-
+-    g : float
+-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+-        The value of `g` is related to the value of `hbar` in the commutation
+-        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
+-        value `hbar=1`.
+-
+-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+-        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
+-        and 'iterative' use an iterative method to evaluate the Wigner functions for density
+-        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
+-        in scipy for the same task. The 'fft' method evaluates the Fourier
+-        transform of the density matrix. The 'iterative' method is default, and
+-        in general recommended, but the 'laguerre' method is more efficient for
+-        very sparse density matrices (e.g., superpositions of Fock states in a
+-        large Hilbert space). The 'clenshaw' method is the preferred method for
+-        dealing with density matrices that have a large number of excitations
+-        (>~50). 'clenshaw' is a fast and numerically stable method.
+-
+-    sparse : bool {False, True}
+-        Tells the default solver whether or not to keep the input density
+-        matrix in sparse format.  As the dimensions of the density matrix
+-        grow, setthing this flag can result in increased performance.
+-
+-    parfor : bool {False, True}
+-        Flag for calculating the Laguerre polynomial based Wigner function
+-        method='laguerre' in parallel using the parfor function.
+-
+-
+-    Returns
+-    -------
+-
+-    W : array
+-        Values representing the Wigner function calculated over the specified
+-        range [xvec,yvec].
+-
+-    yvex : array
+-        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
+-        transform.
+-
+-    Notes
+-    -----
+-    The 'fft' method accepts only an xvec input for the x-coordinate.
+-    The y-coordinates are calculated internally.
+-
+-    References
+-    ----------
+-
+-    Ulf Leonhardt,
+-    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
+-
+-    """
+-
+-    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
+-        raise TypeError('Input state is not a valid operator.')
+-
+-    if method == 'fft':
+-        return _wigner_fourier(psi, xvec, g)
+-
+-    if psi.isket or psi.isbra:
+-        rho = psi.proj()
+-    else:
+-        rho = psi
+-
+-    if method == 'iterative':
+-        return _wigner_iterative(rho, xvec, yvec, g)
+-
+-    elif method == 'laguerre':
+-        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
+-
+-    elif method == 'clenshaw':
+-        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
+-
+-    else:
+-        raise TypeError(
+-            "method must be either 'iterative', 'laguerre', or 'fft'.")
+-
+-
+-def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
+-    r"""
+-    Using an iterative method to evaluate the wigner functions for the Fock
+-    state :math:`|m><n|`.
+-
+-    The Wigner function is calculated as
+-    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
+-    function for the density matrix :math:`|m><n|`.
+-
+-    In this implementation, for each row m, Wlist contains the Wigner functions
+-    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
+-    calculated, the corresponding contribution is added to the total Wigner
+-    function, weighted by the corresponding element in the density matrix
+-    :math:`rho_{mn}`.
+-    """
+-
+-    M = np.prod(rho.shape[0])
+-    X, Y = meshgrid(xvec, yvec)
+-    A = 0.5 * g * (X + 1.0j * Y)
+-
+-    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
+-    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
+-
+-    W = real(rho[0, 0]) * real(Wlist[0])
+-    for n in range(1, M):
+-        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
+-        W += 2 * real(rho[0, n] * Wlist[n])
+-
+-    for m in range(1, M):
+-        temp = copy(Wlist[m])
+-        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
+-
+-        # Wlist[m] = Wigner function for |m><m|
+-        W += real(rho[m, m] * Wlist[m])
+-
+-        for n in range(m + 1, M):
+-            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
+-            temp = copy(Wlist[n])
+-            Wlist[n] = temp2
+-
+-            # Wlist[n] = Wigner function for |m><n|
+-            W += 2 * real(rho[m, n] * Wlist[n])
+-
+-    return 0.5 * W * g ** 2
+-
+-
+-def _wigner_laguerre(rho, xvec, yvec, g, parallel):
+-    r"""
+-    Using Laguerre polynomials from scipy to evaluate the Wigner function for
+-    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
+-    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
+-    """
+-
+-    M = np.prod(rho.shape[0])
+-    X, Y = meshgrid(xvec, yvec)
+-    A = 0.5 * g * (X + 1.0j * Y)
+-    W = zeros(np.shape(A))
+-
+-    # compute wigner functions for density matrices |m><n| and
+-    # weight by all the elements in the density matrix
+-    B = 4 * abs(A) ** 2
+-    if sp.isspmatrix_csr(rho.data):
+-        # for compress sparse row matrices
+-        if parallel:
+-            iterator = (
+-                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
+-            W1_out = parallel_map(_par_wig_eval, iterator)
+-            W += sum(W1_out)
+-        else:
+-            for m in range(len(rho.data.indptr) - 1):
+-                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
+-                    n = rho.data.indices[jj]
+-
+-                    if m == n:
+-                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+-
+-                    elif n > m:
+-                        W += 2.0 * real(rho[m, n] * (-1) ** m *
+-                                        (2 * A) ** (n - m) *
+-                                        sqrt(factorial(m) / factorial(n)) *
+-                                        genlaguerre(m, n - m)(B))
+-    else:
+-        # for dense density matrices
+-        B = 4 * abs(A) ** 2
+-        for m in range(M):
+-            if abs(rho[m, m]) > 0.0:
+-                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+-            for n in range(m + 1, M):
+-                if abs(rho[m, n]) > 0.0:
+-                    W += 2.0 * real(rho[m, n] * (-1) ** m *
+-                                    (2 * A) ** (n - m) *
+-                                    sqrt(factorial(m) / factorial(n)) *
+-                                    genlaguerre(m, n - m)(B))
+-
+-    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
+-
+-
+-def _par_wig_eval(args):
+-    """
+-    Private function for calculating terms of Laguerre Wigner function
+-    using parfor.
+-    """
+-    m, rho, A, B = args
+-    W1 = zeros(np.shape(A))
+-    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
+-        n = rho.data.indices[jj]
+-
+-        if m == n:
+-            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+-
+-        elif n > m:
+-            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
+-                             (2 * A) ** (n - m) *
+-                             sqrt(factorial(m) / factorial(n)) *
+-                             genlaguerre(m, n - m)(B))
+-    return W1
+-
+-
+-def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
+-    """
+-    Evaluate the Wigner function via the Fourier transform.
+-    """
+-    if psi.type == 'bra':
+-        psi = psi.dag()
+-    if psi.type == 'ket':
+-        return _psi_wigner_fft(psi.full(), xvec, g)
+-    elif psi.type == 'oper':
+-        eig_vals, eig_vecs = eigh(psi.full())
+-        W = 0
+-        for ii in range(psi.shape[0]):
+-            W1, yvec = _psi_wigner_fft(
+-                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
+-            W += eig_vals[ii] * W1
+-        return W, yvec
+-
+-
+-def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
+-    """
+-    FFT method for a single state vector.  Called multiple times when the
+-    input is a density matrix.
+-    """
+-    n = len(psi)
+-    A = _osc_eigen(n, xvec * g / np.sqrt(2))
+-    xpsi = np.dot(psi.T, A)
+-    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
+-    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
+-
+-
+-def _wigner_fft(psi, xvec):
+-    """
+-    Evaluates the Fourier transformation of a given state vector.
+-    Returns the corresponding density matrix and range
+-    """
+-    n = 2*len(psi.T)
+-    r1 = np.concatenate((np.array([[0]]),
+-                        np.fliplr(psi.conj()),
+-                        np.zeros((1, n//2 - 1))), axis=1)
+-    r2 = np.concatenate((np.array([[0]]), psi,
+-                        np.zeros((1, n//2 - 1))), axis=1)
+-    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
+-        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
+-    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
+-    w = ft.fft(w)
+-    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
+-    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
+-    w = w / (p[1] - p[0]) / n
+-    return w, p
+-
+-
+-def _osc_eigen(N, pnts):
+-    """
+-    Vector of and N-dim oscillator eigenfunctions evaluated
+-    at the points in pnts.
+-    """
+-    pnts = np.asarray(pnts)
+-    lpnts = len(pnts)
+-    A = np.zeros((N, lpnts))
+-    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
+-    if N == 1:
+-        return A
+-    else:
+-        A[1, :] = np.sqrt(2) * pnts * A[0, :]
+-        for k in range(2, N):
+-            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
+-                np.sqrt((k - 1.0) / k) * A[k - 2, :]
+-        return A
+-
+-
+-def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
+-    r"""
+-    Using Clenshaw summation - numerically stable and efficient
+-    iterative algorithm to evaluate polynomial series.
+-
+-    The Wigner function is calculated as
+-    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
+-    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
+-    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
+-    """
+-
+-    M = np.prod(rho.shape[0])
+-    X,Y = np.meshgrid(xvec, yvec)
+-    #A = 0.5 * g * (X + 1.0j * Y)
+-    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
+-
+-    B = np.abs(A2)
+-    B *= B
+-    w0 = (2*rho[0, -1])*np.ones_like(A2)
+-    L = M-1
+-    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
+-    #using Horner's method
+-    if not sparse:
+-        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
+-        while L > 0:
+-            L -= 1
+-            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
+-            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
+-    else:
+-        # TODO: fix dispatch.
+-        _rho = _data.to(_data.CSR, rho.data).as_scipy()
+-        while L > 0:
+-            L -= 1
+-            diag = _rho.diagonal(L)
+-            if L != 0:
+-                diag *= 2
+-            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
+-            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
+-
+-    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
+-
+-
+-def _wig_laguerre_val(L, x, c):
+-    r"""
+-    this is evaluation of polynomial series inspired by hermval from numpy.
+-    Returns polynomial series
+-
+-    .. math:
+-        \sum_n b_n LL_n^L,
+-
+-    where
+-
+-    .. math:
+-        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
+-
+-    The evaluation uses Clenshaw recursion.
+-    """
+-
+-    if len(c) == 1:
+-        y0 = c[0]
+-        y1 = 0
+-    elif len(c) == 2:
+-        y0 = c[0]
+-        y1 = c[1]
+-    else:
+-        k = len(c)
+-        y0 = c[-2]
+-        y1 = c[-1]
+-        for i in range(3, len(c) + 1):
+-            k -= 1
+-            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
+-            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
+-
+-    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
+-
+-
+-# -----------------------------------------------------------------------------
+-# Q FUNCTION
+-#
+-def _qfunc_check_state(state: Qobj):
+-    if not isinstance(state, Qobj):
+-        raise TypeError(f"state must be Qobj, but is {state}")
+-    # This is only approximate, but it's enough for our purposes; doing more
+-    # than this would take computational effort we don't _need_ to do.
+-    isdm = (
+-        state.isoper
+-        and state.dims[0] == state.dims[1]
+-        and state.isherm
+-        and abs(state.tr() - 1) < qutip.settings.core['atol']
+-    )
+-    if not (state.isket or isdm):
+-        raise ValueError(
+-            f"state must be a ket or density matrix, but is {state}"
+-        )
+-    if len(state.dims[0]) != 1:
+-        raise ValueError(
+-            "state must not have tensor structure, but has dimensions:"
+-            f" {state.dims}"
+-        )
+-    return state
+-
+-
+-def _qfunc_check_coordinates(xvec, yvec):
+-    if np.isscalar(xvec) or xvec is None:
+-        raise TypeError("xvec must be array-like, but is " + repr(xvec))
+-    if np.isscalar(yvec) or yvec is None:
+-        raise TypeError("yvec must be array-like, but is " + repr(yvec))
+-    xvec = np.asarray(xvec, dtype=np.float64)
+-    yvec = np.asarray(yvec, dtype=np.float64)
+-    if xvec.ndim != 1 or yvec.ndim != 1:
+-        raise ValueError(
+-            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
+-        )
+-    return xvec, yvec
+-
+-
+-class _QFuncCoherentGrid:
+-    """
+-    Internal function to compute coherent state operators corresponding to a
+-    grid of complex values in phase space.  For efficiency reasons, this class
+-    produces the adjoint of the coherent states, to save allocations when
+-    calculating inner products later.
+-
+-    Examples
+-    --------
+-    Initialise the grid calculator.
+-
+-    >>> xvec = yvec = np.linspace(-1, 1, 21)
+-    >>> g = np.sqrt(0.5)
+-    >>> max_ns = 10
+-    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
+-
+-    The naive construction of the grid is
+-
+-    >>> xs, ys = np.meshgrid(xvec, yvec)
+-    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
+-    >>> naive = np.array([
+-    ...     [
+-    ...         qutip.coherent(max_ns, alpha, method='analytic')
+-    ...             .dag().full().ravel()
+-    ...         for alpha in x_alphas
+-    ...     ]
+-    ...     for y_alphas in all_alphas
+-    ... ])
+-
+-    The naive approach is typically several of orders of magnitude slower than
+-    this class, which uses much simpler vectorised operations.  The outputs are
+-    within close tolerance, however:
+-
+-    >>> np.allclose(naive, grid(max_ns))
+-    True
+-    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
+-    True
+-    """
+-    def __init__(self, xvec, yvec, g: float):
+-        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
+-        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
+-        self.grid = np.empty(x.shape, dtype=np.complex128)
+-        self.grid.real = x
+-        # We produce the adjoint of the coherent states to save an operation
+-        # later when computing dot products, hence the negative imaginary part.
+-        self.grid.imag = -y
+-        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
+-
+-    def _start(self, first: int):
+-        """
+-        Get the coherent state matrix corresponding to the first needed Fock
+-        state.
+-        """
+-        if first == 0:
+-            return self.prefactor.copy()
+-        out = np.power(self.grid, first)
+-        out *= self.prefactor
+-        return out
+-
+-    def __call__(self, first: int, last: int = None):
+-        """
+-        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
+-        coherent-state vectors for all the Fock states in the range ``first``
+-        to ``last``, excluding the end point.  The first two axes are the y-
+-        and x-coordinates of phase space (i.e. Cartesian indexing, like
+-        ``numpy.meshgrid``), and the last runs over the selected range of
+-        Fock-space dimensions.
+-        """
+-        ns = np.arange(first, last).reshape(1, 1, -1)
+-        # Technically we could avoid hitting the limits of floating-point
+-        # exponents for longer by doing all this in logarithmic space (using
+-        # scipy.special.gammaln), but that ends up involving more
+-        # floating-point operations overall, and needs special care around the
+-        # point alpha = 0 to avoid nan appearing, due to how Python handles
+-        # mixed-width arithmetic operations.
+-        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
+-        out[:, :, 0] = self._start(ns.flat[0])
+-        for i in range(ns.size - 1):
+-            out[:, :, i+1] = out[:, :, i] * self.grid
+-        out /= np.sqrt(scipy.special.factorial(ns))
+-        return out
+-
+-
+-class QFunc:
+-    r"""
+-    Class-based method of calculating the Husimi-Q function of many different
+-    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
+-    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
+-    subsequent operations will be several times faster. However, it can require
+-    quite a lot of memory. Call the created object as a function to retrieve
+-    the Husimi-Q function.
+-
+-    Parameters
+-    ----------
+-    xvec, yvec : array_like
+-        x- and y-coordinates at which to calculate the Husimi-Q function.
+-
+-    g : float, default sqrt(2)
+-        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
+-        related to the value of `hbar` in the commutation relation
+-        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
+-        corresponds to :math:`\hbar=1`.
+-
+-    memory : real, default 1024
+-        Size in MB that may be used internally as workspace.  This class will
+-        raise ``MemoryError`` if subsequently passed a state of sufficiently
+-        large dimension that this bound would be exceeded.  In those cases, use
+-        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
+-        the slower, more memory-efficient algorithm.
+-
+-    Examples
+-    --------
+-    Initialise the class for a square set of coordinates, with some states we
+-    want to investigate.
+-
+-    >>> xvec = np.linspace(-2, 2, 101)
+-    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
+-    >>> qfunc = qutip.QFunc(xvec, xvec)
+-
+-    Now we can calculate the Husimi-Q function over each of the states more
+-    efficiently with:
+-
+-    >>> husimiq = np.array([qfunc(state) for state in states])
+-
+-    See Also
+-    --------
+-    :obj:`.qfunc` :
+-        a single function version, which will involve computing several
+-        quantities multiple times in order to use less memory.
+-    """
+-
+-    def __init__(
+-        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
+-    ):
+-        self._g = g
+-        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
+-        # 16 bytes per complex, 1024**2 bytes per MB.
+-        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
+-        self._memory_mb = memory
+-        self._max_size = int(self._memory_mb // self._size_mb)
+-        self._current_size = 0
+-        self._cache = None
+-
+-    def _alphas(self, size: int):
+-        r"""
+-        Retrive the full tensor of (the conjugate of) coherent states over all
+-        values of :math:`\alpha`, for states of dimension ``size``.
+-        """
+-        if self._current_size >= size:
+-            return self._cache[:, :, :size]
+-        if size > self._max_size:
+-            requirement = self._size_mb * size
+-            raise MemoryError(
+-                f"Refusing to precompute up to {size} basis states."
+-                f" This would require {requirement:.2f} MB,"
+-                f" but only {self._memory_mb} MB is allowed."
+-            )
+-        if self._cache is None:
+-            self._cache = self._coherent_grid(self._current_size, size)
+-        else:
+-            self._cache = np.dstack(
+-                [self._cache, self._coherent_grid(self._current_size, size)]
+-            )
+-        self._current_size = size
+-        return self._cache
+-
+-    def _single(self, vector: np.ndarray, alphas: np.ndarray):
+-        r"""
+-        Get the Q function (without the :math:`\pi` scaling factor) of a single
+-        state vector.
+-        """
+-        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
+-
+-    def __call__(self, state: Qobj):
+-        """
+-        Get the Husimi-Q function for the given state vector or density matrix,
+-        over the coordinates used to initialise the class.  If called multiple
+-        times, the states do not need to have the same dimensions, but none of
+-        them can have tensor-product structure.
+-        """
+-        state = _qfunc_check_state(state)
+-        alphas = self._alphas(state.shape[0])
+-        if state.isket:
+-            return self._single(state.full().ravel(), alphas) / np.pi
+-        # We don't use Qobj.eigenstates() to avoid building many unnecessary
+-        # CSR versions of dense matrices.
+-        values, vectors = eigh(state.full())
+-        vectors = vectors.T
+-        out = values[0] * self._single(vectors[0], alphas)
+-        for value, vector in zip(values[1:], vectors[1:]):
+-            out += value * self._single(vector, alphas)
+-        return out / np.pi
+-
+-
+-def _qfunc_iterative_single(
+-    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
+-):
+-    r"""
+-    Get the Q function (without the :math:`\pi` scaling factor) of a single
+-    state vector, using the iterative algorithm which recomputes the powers of
+-    the coherent-state matrix.
+-    """
+-    ns = np.arange(vector.shape[0])
+-    out = np.polyval(
+-        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
+-        alpha_grid.grid,
+-    )
+-    out *= alpha_grid.prefactor
+-    return np.abs(out)**2
+-
+-
+-def qfunc(
+-    state: Qobj,
+-    xvec,
+-    yvec,
+-    g: float = sqrt(2),
+-    precompute_memory: float = 1024,
+-):
+-    r"""
+-    Husimi-Q function of a given state vector or density matrix at phase-space
+-    points ``0.5 * g * (xvec + i*yvec)``.
+-
+-    Parameters
+-    ----------
+-    state : :obj:`.Qobj`
+-        A state vector or density matrix.  This cannot have tensor-product
+-        structure.
+-
+-    xvec, yvec : array_like
+-        x- and y-coordinates at which to calculate the Husimi-Q function.
+-
+-    g : float, default sqrt(2)
+-        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
+-        related to the value of :math:`\hbar` in the commutation relation
+-        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
+-        corresponds to :math:`\hbar=1`.
+-
+-    precompute_memory : real, default 1024
+-        Size in MB that may be used during calculations as working space when
+-        dealing with density-matrix inputs.  This is ignored for state-vector
+-        inputs.  The bound is not quite exact due to other, order-of-magnitude
+-        smaller, intermediaries being necessary, but is a good approximation.
+-        If you want to use the same iterative algorithm for density matrices
+-        that is used for single kets, set ``precompute_memory=None``.
+-
+-    Returns
+-    -------
+-    ndarray
+-        Values representing the Husimi-Q function calculated over the specified
+-        range ``[xvec, yvec]``.
+-
+-    See Also
+-    --------
+-    :obj:`.QFunc` :
+-        a class-based version, more efficient if you want to calculate the
+-        Husimi-Q function for several states over the same coordinates.
+-    """
+-    state = _qfunc_check_state(state)
+-    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
+-    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
+-    enough_memory = (
+-        precompute_memory is not None
+-        and precompute_memory > required_memory
+-    )
+-    if state.isoper and enough_memory:
+-        return QFunc(xvec, yvec, g)(state)
+-    if precompute_memory is not None and state.isoper:
+-        warnings.warn(
+-            "Falling back to iterative algorithm due to lack of memory."
+-            f" Needed {required_memory:.2f} MB, but only allowed to use"
+-            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
+-            " raise limit, or set to `None` to suppress warning."
+-        )
+-    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
+-    if state.isket:
+-        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
+-        out /= np.pi
+-        return out
+-    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
+-    # versions of dense matrices.
+-    values, vectors = eigh(state.full())
+-    vectors = vectors.T
+-    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
+-    for value, vector in zip(values[1:], vectors[1:]):
+-        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
+-    out /= np.pi
+-    return out
+-
+-
+-# -----------------------------------------------------------------------------
+-# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
+-#
+-def spin_q_function(rho, theta, phi):
+-    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
+-    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
+-    j, theta, phi)`` where j is the spin length.
+-    The implementation here is more efficient as it doesn't
+-    generate all of the SCS at theta and phi (see references).
+-
+-    The spin Q function is normal when integrated over the surface of the
+-    sphere
+-
+-    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
+-              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
+-
+-    Parameters
+-    ----------
+-    state : qobj
+-        A state vector or density matrix for a spin-j quantum system.
+-    theta : array_like
+-        Polar (colatitude) angle at which to calculate the Husimi-Q function.
+-    phi : array_like
+-        Azimuthal angle at which to calculate the Husimi-Q function.
+-
+-    Returns
+-    -------
+-    Q, THETA, PHI : 2d-array
+-        Values representing the spin Husimi Q function at the values specified
+-        by THETA and PHI.
+-
+-    References
+-    ----------
+-    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
+-    https://doi.org/10.1119/1.4898595
+-
+-    """
+-
+-    if rho.isket or rho.isbra:
+-        rho = rho.proj()
+-
+-    J = rho.shape[0]
+-    j = (J - 1) / 2
+-
+-    THETA, PHI = meshgrid(theta, phi)
+-
+-    Q = np.zeros_like(THETA, dtype=complex)
+-    data = rho.full()
+-
+-    for m1 in arange(-j, j + 1):
+-        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
+-             sin(THETA / 2) ** (2 * (j - m1)) * \
+-             data[int(j - m1), int(j - m1)]
+-
+-        for m2 in arange(m1 + 1, j + 1):
+-            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
+-                  cos(THETA / 2) ** (2 * j + m1 + m2) *
+-                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
+-             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
+-              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
+-
+-    return Q.real, THETA, PHI
+-
+-
+-def _rho_kq(rho, j, k, q):
+-    """
+-    This calculates the trace of the multipole operator T_kq and the density
+-    matrix rho for use in the spin Wigner quasiprobability distribution.
+-
+-    Parameters
+-    ----------
+-    rho : qobj
+-        A density matrix for a spin-j quantum system.
+-    j : float
+-        The spin length of the system.
+-    k : int
+-        Spherical harmonic degree
+-    q : int
+-        Spherical harmonic order
+-
+-    Returns
+-    -------
+-    v : float
+-        Overlap of state with multipole operator T_kq
+-    """
+-
+-    v = 0j
+-    data = rho.full()
+-    for m1 in arange(-j, j+1):
+-        for m2 in arange(-j, j+1):
+-            v += (
+-                    (-1) ** (2 * j - k - m1 - m2)
+-                    * np.sqrt((2 * k + 1) / (2 * j + 1))
+-                    * clebsch(j, k, j, -m1, q, -m2)
+-                    * data[int(j - m1), int(j - m2)]
+-            )
+-    return v
+-
+-
+-def spin_wigner(rho, theta, phi):
+-    r"""Wigner function for a spin-j system.
+-
+-    The spin W function is normal when integrated over the surface of the
+-    sphere
+-
+-    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
+-              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
+-
+-
+-    Parameters
+-    ----------
+-    state : qobj
+-        A state vector or density matrix for a spin-j quantum system.
+-    theta : array_like
+-        Polar (colatitude) angle at which to calculate the W function.
+-    phi : array_like
+-        Azimuthal angle at which to calculate the W function.
+-
+-    Returns
+-    -------
+-    W, THETA, PHI : 2d-array
+-        Values representing the spin Wigner function at the values specified
+-        by THETA and PHI.
+-
+-    References
+-    ----------
+-    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
+-    https://doi.org/10.1103/PhysRevA.24.2889
+-
+-    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
+-    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
+-
+-    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
+-    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
+-
+-    """
+-    if rho.isket or rho.isbra:
+-        rho = rho.proj()
+-
+-    J = rho.shape[0]
+-    j = (J - 1) / 2
+-
+-    THETA, PHI = meshgrid(theta, phi)
+-
+-    W = np.zeros_like(THETA, dtype=complex)
+-
+-    for k in range(int(2 * j)+1):
+-        for q in arange(-k, k+1):
+-            # sph_harm takes azimuthal angle then polar angle as arguments
+-            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
+-
+-    return W.real, THETA, PHI
++__all__ = [
++    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
++    'wigner_transform',
++]
++
++import numpy as np
++import warnings
++from numpy import (
++    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
++)
++import scipy.sparse as sp
++import scipy.fftpack as ft
++import scipy.linalg as la
++import scipy.special
++from scipy.special import genlaguerre, binom, sph_harm, factorial
++
++import qutip
++from qutip import Qobj, ket2dm, jmat
++from .solver.parallel import parallel_map
++from .utilities import clebsch
++from .core import data as _data
++from .core.data.eigen import eigh
++
++
++def wigner_transform(psi, j, fullparity, steps, slicearray):
++    """takes the density matrix or state vector of any finite state and
++    generates the Wigner function for that state on a sphere, generating a spin
++    Wigner function useful for displaying the quasi-probability for a qubit or
++    any qudit. For the standard, continuous-variable Wigner function for
++    position and momentum variables, wigner() should be used.
++
++    Parameters
++    ----------
++        psi : qobj
++              a state vector or density matrix.
++        j : int
++            the total angular momentum of the quantum state.
++        fullparity : bool
++                     should the parity of the full SU space be used?
++        steps : int
++                number of points at which the Wigner transform is calculated.
++        slicearray : list of str
++                     the angle slice to be used for each particle in case of a
++                     multi-particle quantum state. 'l' yields an equal angle
++                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
++
++    Returns
++    ----------
++        wigner : list of float
++                 the wigner transformation at `steps` different theta and phi.
++
++    Raises
++    ------
++    ComplexWarning
++        This can be ignored as it is caused due to rounding errors.
++
++    Notes
++    ------
++    See example notebook wigner_visualisation.
++
++    References
++    ------
++    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
++        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
++    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
++        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
++    """
++    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
++        raise TypeError('Input state is not a valid operator.')
++
++    if psi.isket or psi.isbra:
++        rho = psi.proj()
++    else:
++        rho = psi
++
++    sun = 2   # The order of the SU group
++
++    # calculate total number of particles in quantum state:
++    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
++
++    theta = np.zeros((N, steps))
++    phi = np.zeros((N, steps))
++
++    for i in range(N):
++        theta[i, :] = np.linspace(0, np.pi, steps)
++        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
++
++    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
++
++    wigner = np.zeros((steps, steps))
++    if fullparity:
++        pari = _parity(sun**N, j)
++    else:
++        pari = _parity(sun, j)
++    for t in range(steps):
++        for p in range(steps):
++            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
++            kernel = _data.dense.fast_from_numpy(kernel)
++            wigner[t, p] = _data.expect(rho.data, kernel).real
++    return wigner
++
++
++def _parity(N, j):
++    """Private function to calculate the parity of the quantum system.
++    """
++    if j == 0.5:
++        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
++        return pi / N
++    elif j > 0.5:
++        mult = np.int32(2 * j + 1)
++        matrix = np.zeros((mult, mult))
++        foo = np.ones(mult)
++        for n in np.arange(-j, j + 1, 1):
++            for l in np.arange(0, mult, 1):
++                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
++            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
++        return matrix / mult
++
++
++def _lambda_f(N):
++    """Private function needed for the calculation of the parity.
++    """
++    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
++    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
++    return matrix
++
++
++def _kernelsu2(theta, phi, N, j, parity, fullparity):
++    """Private function that calculates the kernel for the SU2 unitary group.
++    """
++    U = np.ones(1)
++    # calculate the total rotation matrix (tensor product for each particle):
++    for i in range(0, N):
++        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
++    if not fullparity:
++        op_parity = parity   # The parity for a one particle system
++        for i in range(1, N):
++            parity = np.kron(parity, op_parity)
++    matrix = U @ parity @ U.conj().T
++    return matrix
++
++
++def _rotation_matrix(theta, phi, j):
++    """Private function to calculate the rotation operator for the SU2 kernel.
++    """
++    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
++           la.expm(1j * theta * jmat(j, 'y').full())
++
++
++def _angle_slice(slicearray, theta, phi):
++    """Private function to modify theta and phi for angle slicing.
++    """
++    xind = np.where(slicearray == 'x')
++    theta[xind, :] = np.pi - theta[xind, :]
++    phi[xind, :] = -phi[xind, :]
++    yind = np.where(slicearray == 'y')
++    theta[yind, :] = np.pi - theta[yind, :]
++    phi[yind, :] = np.pi - phi[yind, :]
++    zind = np.where(slicearray == 'z')
++    phi[zind, :] = phi[zind, :] + np.pi
++    return theta, phi
++
++
++def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
++           sparse=False, parfor=False):
++    """Wigner function for a state vector or density matrix at points
++    `xvec + i * yvec`.
++
++    Parameters
++    ----------
++
++    state : qobj
++        A state vector or density matrix.
++
++    xvec : array_like
++        x-coordinates at which to calculate the Wigner function.
++
++    yvec : array_like
++        y-coordinates at which to calculate the Wigner function.  Does not
++        apply to the 'fft' method.
++
++    g : float
++        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
++        The value of `g` is related to the value of `hbar` in the commutation
++        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
++        value `hbar=1`.
++
++    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
++        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
++        and 'iterative' use an iterative method to evaluate the Wigner functions for density
++        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
++        in scipy for the same task. The 'fft' method evaluates the Fourier
++        transform of the density matrix. The 'iterative' method is default, and
++        in general recommended, but the 'laguerre' method is more efficient for
++        very sparse density matrices (e.g., superpositions of Fock states in a
++        large Hilbert space). The 'clenshaw' method is the preferred method for
++        dealing with density matrices that have a large number of excitations
++        (>~50). 'clenshaw' is a fast and numerically stable method.
++
++    sparse : bool {False, True}
++        Tells the default solver whether or not to keep the input density
++        matrix in sparse format.  As the dimensions of the density matrix
++        grow, setthing this flag can result in increased performance.
++
++    parfor : bool {False, True}
++        Flag for calculating the Laguerre polynomial based Wigner function
++        method='laguerre' in parallel using the parfor function.
++
++
++    Returns
++    -------
++
++    W : array
++        Values representing the Wigner function calculated over the specified
++        range [xvec,yvec].
++
++    yvex : array
++        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
++        transform.
++
++    Notes
++    -----
++    The 'fft' method accepts only an xvec input for the x-coordinate.
++    The y-coordinates are calculated internally.
++
++    References
++    ----------
++
++    Ulf Leonhardt,
++    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
++
++    """
++
++    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
++        raise TypeError('Input state is not a valid operator.')
++
++    if method == 'fft':
++        return _wigner_fourier(psi, xvec, g)
++
++    if psi.isket or psi.isbra:
++        rho = psi.proj()
++    else:
++        rho = psi
++
++    if method == 'iterative':
++        return _wigner_iterative(rho, xvec, yvec, g)
++
++    elif method == 'laguerre':
++        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
++
++    elif method == 'clenshaw':
++        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
++
++    else:
++        raise TypeError(
++            "method must be either 'iterative', 'laguerre', or 'fft'.")
++
++
++def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
++    r"""
++    Using an iterative method to evaluate the wigner functions for the Fock
++    state :math:`|m><n|`.
++
++    The Wigner function is calculated as
++    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
++    function for the density matrix :math:`|m><n|`.
++
++    In this implementation, for each row m, Wlist contains the Wigner functions
++    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
++    calculated, the corresponding contribution is added to the total Wigner
++    function, weighted by the corresponding element in the density matrix
++    :math:`rho_{mn}`.
++    """
++
++    M = np.prod(rho.shape[0])
++    X, Y = meshgrid(xvec, yvec)
++    A = 0.5 * g * (X + 1.0j * Y)
++
++    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
++    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
++
++    W = real(rho[0, 0]) * real(Wlist[0])
++    for n in range(1, M):
++        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
++        W += 2 * real(rho[0, n] * Wlist[n])
++
++    for m in range(1, M):
++        temp = copy(Wlist[m])
++        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
++
++        # Wlist[m] = Wigner function for |m><m|
++        W += real(rho[m, m] * Wlist[m])
++
++        for n in range(m + 1, M):
++            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
++            temp = copy(Wlist[n])
++            Wlist[n] = temp2
++
++            # Wlist[n] = Wigner function for |m><n|
++            W += 2 * real(rho[m, n] * Wlist[n])
++
++    return 0.5 * W * g ** 2
++
++
++def _wigner_laguerre(rho, xvec, yvec, g, parallel):
++    r"""
++    Using Laguerre polynomials from scipy to evaluate the Wigner function for
++    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
++    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
++    """
++
++    M = np.prod(rho.shape[0])
++    X, Y = meshgrid(xvec, yvec)
++    A = 0.5 * g * (X + 1.0j * Y)
++    W = zeros(np.shape(A))
++
++    # compute wigner functions for density matrices |m><n| and
++    # weight by all the elements in the density matrix
++    B = 4 * abs(A) ** 2
++    if sp.isspmatrix_csr(rho.data):
++        # for compress sparse row matrices
++        if parallel:
++            iterator = (
++                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
++            W1_out = parallel_map(_par_wig_eval, iterator)
++            W += sum(W1_out)
++        else:
++            for m in range(len(rho.data.indptr) - 1):
++                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
++                    n = rho.data.indices[jj]
++
++                    if m == n:
++                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
++
++                    elif n > m:
++                        W += 2.0 * real(rho[m, n] * (-1) ** m *
++                                        (2 * A) ** (n - m) *
++                                        sqrt(factorial(m) / factorial(n)) *
++                                        genlaguerre(m, n - m)(B))
++    else:
++        # for dense density matrices
++        B = 4 * abs(A) ** 2
++        for m in range(M):
++            if abs(rho[m, m]) > 0.0:
++                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
++            for n in range(m + 1, M):
++                if abs(rho[m, n]) > 0.0:
++                    W += 2.0 * real(rho[m, n] * (-1) ** m *
++                                    (2 * A) ** (n - m) *
++                                    sqrt(factorial(m) / factorial(n)) *
++                                    genlaguerre(m, n - m)(B))
++
++    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
++
++
++def _par_wig_eval(args):
++    """
++    Private function for calculating terms of Laguerre Wigner function
++    using parfor.
++    """
++    m, rho, A, B = args
++    W1 = zeros(np.shape(A))
++    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
++        n = rho.data.indices[jj]
++
++        if m == n:
++            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
++
++        elif n > m:
++            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
++                             (2 * A) ** (n - m) *
++                             sqrt(factorial(m) / factorial(n)) *
++                             genlaguerre(m, n - m)(B))
++    return W1
++
++
++def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
++    """
++    Evaluate the Wigner function via the Fourier transform.
++    """
++    if psi.type == 'bra':
++        psi = psi.dag()
++    if psi.type == 'ket':
++        return _psi_wigner_fft(psi.full(), xvec, g)
++    elif psi.type == 'oper':
++        eig_vals, eig_vecs = eigh(psi.full())
++        W = 0
++        for ii in range(psi.shape[0]):
++            W1, yvec = _psi_wigner_fft(
++                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
++            W += eig_vals[ii] * W1
++        return W, yvec
++
++
++def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
++    """
++    FFT method for a single state vector.  Called multiple times when the
++    input is a density matrix.
++    """
++    n = len(psi)
++    A = _osc_eigen(n, xvec * g / np.sqrt(2))
++    xpsi = np.dot(psi.T, A)
++    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
++    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
++
++
++def _wigner_fft(psi, xvec):
++    """
++    Evaluates the Fourier transformation of a given state vector.
++    Returns the corresponding density matrix and range
++    """
++    n = 2*len(psi.T)
++    r1 = np.concatenate((np.array([[0]]),
++                        np.fliplr(psi.conj()),
++                        np.zeros((1, n//2 - 1))), axis=1)
++    r2 = np.concatenate((np.array([[0]]), psi,
++                        np.zeros((1, n//2 - 1))), axis=1)
++    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
++        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
++    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
++    w = ft.fft(w)
++    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
++    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
++    w = w / (p[1] - p[0]) / n
++    return w, p
++
++
++def _osc_eigen(N, pnts):
++    """
++    Vector of and N-dim oscillator eigenfunctions evaluated
++    at the points in pnts.
++    """
++    pnts = np.asarray(pnts)
++    lpnts = len(pnts)
++    A = np.zeros((N, lpnts))
++    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
++    if N == 1:
++        return A
++    else:
++        A[1, :] = np.sqrt(2) * pnts * A[0, :]
++        for k in range(2, N):
++            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
++                np.sqrt((k - 1.0) / k) * A[k - 2, :]
++        return A
++
++
++def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
++    r"""
++    Using Clenshaw summation - numerically stable and efficient
++    iterative algorithm to evaluate polynomial series.
++
++    The Wigner function is calculated as
++    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
++    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
++    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
++    """
++
++    M = np.prod(rho.shape[0])
++    X,Y = np.meshgrid(xvec, yvec)
++    #A = 0.5 * g * (X + 1.0j * Y)
++    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
++
++    B = np.abs(A2)
++    B *= B
++    w0 = (2*rho[0, -1])*np.ones_like(A2)
++    L = M-1
++    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
++    #using Horner's method
++    if not sparse:
++        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
++        while L > 0:
++            L -= 1
++            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
++            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
++    else:
++        # TODO: fix dispatch.
++        _rho = _data.to(_data.CSR, rho.data).as_scipy()
++        while L > 0:
++            L -= 1
++            diag = _rho.diagonal(L)
++            if L != 0:
++                diag *= 2
++            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
++            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
++
++    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
++
++
++def _wig_laguerre_val(L, x, c):
++    r"""
++    this is evaluation of polynomial series inspired by hermval from numpy.
++    Returns polynomial series
++
++    .. math:
++        \sum_n b_n LL_n^L,
++
++    where
++
++    .. math:
++        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
++
++    The evaluation uses Clenshaw recursion.
++    """
++
++    if len(c) == 1:
++        y0 = c[0]
++        y1 = 0
++    elif len(c) == 2:
++        y0 = c[0]
++        y1 = c[1]
++    else:
++        k = len(c)
++        y0 = c[-2]
++        y1 = c[-1]
++        for i in range(3, len(c) + 1):
++            k -= 1
++            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
++            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
++
++    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
++
++
++# -----------------------------------------------------------------------------
++# Q FUNCTION
++#
++def _qfunc_check_state(state: Qobj):
++    if not isinstance(state, Qobj):
++        raise TypeError(f"state must be Qobj, but is {state}")
++    # This is only approximate, but it's enough for our purposes; doing more
++    # than this would take computational effort we don't _need_ to do.
++    isdm = (
++        state.isoper
++        and state.dims[0] == state.dims[1]
++        and state.isherm
++        and abs(state.tr() - 1) < qutip.settings.core['atol']
++    )
++    if not (state.isket or isdm):
++        raise ValueError(
++            f"state must be a ket or density matrix, but is {state}"
++        )
++    if len(state.dims[0]) != 1:
++        raise ValueError(
++            "state must not have tensor structure, but has dimensions:"
++            f" {state.dims}"
++        )
++    return state
++
++
++def _qfunc_check_coordinates(xvec, yvec):
++    if np.isscalar(xvec) or xvec is None:
++        raise TypeError("xvec must be array-like, but is " + repr(xvec))
++    if np.isscalar(yvec) or yvec is None:
++        raise TypeError("yvec must be array-like, but is " + repr(yvec))
++    xvec = np.asarray(xvec, dtype=np.float64)
++    yvec = np.asarray(yvec, dtype=np.float64)
++    if xvec.ndim != 1 or yvec.ndim != 1:
++        raise ValueError(
++            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
++        )
++    return xvec, yvec
++
++
++class _QFuncCoherentGrid:
++    """
++    Internal function to compute coherent state operators corresponding to a
++    grid of complex values in phase space.  For efficiency reasons, this class
++    produces the adjoint of the coherent states, to save allocations when
++    calculating inner products later.
++
++    Examples
++    --------
++    Initialise the grid calculator.
++
++    >>> xvec = yvec = np.linspace(-1, 1, 21)
++    >>> g = np.sqrt(0.5)
++    >>> max_ns = 10
++    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
++
++    The naive construction of the grid is
++
++    >>> xs, ys = np.meshgrid(xvec, yvec)
++    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
++    >>> naive = np.array([
++    ...     [
++    ...         qutip.coherent(max_ns, alpha, method='analytic')
++    ...             .dag().full().ravel()
++    ...         for alpha in x_alphas
++    ...     ]
++    ...     for y_alphas in all_alphas
++    ... ])
++
++    The naive approach is typically several of orders of magnitude slower than
++    this class, which uses much simpler vectorised operations.  The outputs are
++    within close tolerance, however:
++
++    >>> np.allclose(naive, grid(max_ns))
++    True
++    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
++    True
++    """
++    def __init__(self, xvec, yvec, g: float):
++        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
++        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
++        self.grid = np.empty(x.shape, dtype=np.complex128)
++        self.grid.real = x
++        # We produce the adjoint of the coherent states to save an operation
++        # later when computing dot products, hence the negative imaginary part.
++        self.grid.imag = -y
++        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
++
++    def _start(self, first: int):
++        """
++        Get the coherent state matrix corresponding to the first needed Fock
++        state.
++        """
++        if first == 0:
++            return self.prefactor.copy()
++        out = np.power(self.grid, first)
++        out *= self.prefactor
++        return out
++
++    def __call__(self, first: int, last: int = None):
++        """
++        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
++        coherent-state vectors for all the Fock states in the range ``first``
++        to ``last``, excluding the end point.  The first two axes are the y-
++        and x-coordinates of phase space (i.e. Cartesian indexing, like
++        ``numpy.meshgrid``), and the last runs over the selected range of
++        Fock-space dimensions.
++        """
++        ns = np.arange(first, last).reshape(1, 1, -1)
++        # Technically we could avoid hitting the limits of floating-point
++        # exponents for longer by doing all this in logarithmic space (using
++        # scipy.special.gammaln), but that ends up involving more
++        # floating-point operations overall, and needs special care around the
++        # point alpha = 0 to avoid nan appearing, due to how Python handles
++        # mixed-width arithmetic operations.
++        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
++        out[:, :, 0] = self._start(ns.flat[0])
++        for i in range(ns.size - 1):
++            out[:, :, i+1] = out[:, :, i] * self.grid
++        out /= np.sqrt(scipy.special.factorial(ns))
++        return out
++
++
++class QFunc:
++    r"""
++    Class-based method of calculating the Husimi-Q function of many different
++    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
++    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
++    subsequent operations will be several times faster. However, it can require
++    quite a lot of memory. Call the created object as a function to retrieve
++    the Husimi-Q function.
++
++    Parameters
++    ----------
++    xvec, yvec : array_like
++        x- and y-coordinates at which to calculate the Husimi-Q function.
++
++    g : float, default sqrt(2)
++        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
++        related to the value of `hbar` in the commutation relation
++        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
++        corresponds to :math:`\hbar=1`.
++
++    memory : real, default 1024
++        Size in MB that may be used internally as workspace.  This class will
++        raise ``MemoryError`` if subsequently passed a state of sufficiently
++        large dimension that this bound would be exceeded.  In those cases, use
++        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
++        the slower, more memory-efficient algorithm.
++
++    Examples
++    --------
++    Initialise the class for a square set of coordinates, with some states we
++    want to investigate.
++
++    >>> xvec = np.linspace(-2, 2, 101)
++    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
++    >>> qfunc = qutip.QFunc(xvec, xvec)
++
++    Now we can calculate the Husimi-Q function over each of the states more
++    efficiently with:
++
++    >>> husimiq = np.array([qfunc(state) for state in states])
++
++    See Also
++    --------
++    :obj:`.qfunc` :
++        a single function version, which will involve computing several
++        quantities multiple times in order to use less memory.
++    """
++
++    def __init__(
++        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
++    ):
++        self._g = g
++        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
++        # 16 bytes per complex, 1024**2 bytes per MB.
++        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
++        self._memory_mb = memory
++        self._max_size = int(self._memory_mb // self._size_mb)
++        self._current_size = 0
++        self._cache = None
++
++    def _alphas(self, size: int):
++        r"""
++        Retrive the full tensor of (the conjugate of) coherent states over all
++        values of :math:`\alpha`, for states of dimension ``size``.
++        """
++        if self._current_size >= size:
++            return self._cache[:, :, :size]
++        if size > self._max_size:
++            requirement = self._size_mb * size
++            raise MemoryError(
++                f"Refusing to precompute up to {size} basis states."
++                f" This would require {requirement:.2f} MB,"
++                f" but only {self._memory_mb} MB is allowed."
++            )
++        if self._cache is None:
++            self._cache = self._coherent_grid(self._current_size, size)
++        else:
++            self._cache = np.dstack(
++                [self._cache, self._coherent_grid(self._current_size, size)]
++            )
++        self._current_size = size
++        return self._cache
++
++    def _single(self, vector: np.ndarray, alphas: np.ndarray):
++        r"""
++        Get the Q function (without the :math:`\pi` scaling factor) of a single
++        state vector.
++        """
++        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
++
++    def __call__(self, state: Qobj):
++        """
++        Get the Husimi-Q function for the given state vector or density matrix,
++        over the coordinates used to initialise the class.  If called multiple
++        times, the states do not need to have the same dimensions, but none of
++        them can have tensor-product structure.
++        """
++        state = _qfunc_check_state(state)
++        alphas = self._alphas(state.shape[0])
++        if state.isket:
++            return self._single(state.full().ravel(), alphas) / np.pi
++        # We don't use Qobj.eigenstates() to avoid building many unnecessary
++        # CSR versions of dense matrices.
++        values, vectors = eigh(state.full())
++        vectors = vectors.T
++        out = values[0] * self._single(vectors[0], alphas)
++        for value, vector in zip(values[1:], vectors[1:]):
++            out += value * self._single(vector, alphas)
++        return out / np.pi
++
++
++def _qfunc_iterative_single(
++    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
++):
++    r"""
++    Get the Q function (without the :math:`\pi` scaling factor) of a single
++    state vector, using the iterative algorithm which recomputes the powers of
++    the coherent-state matrix.
++    """
++    ns = np.arange(vector.shape[0])
++    out = np.polyval(
++        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
++        alpha_grid.grid,
++    )
++    out *= alpha_grid.prefactor
++    return np.abs(out)**2
++
++
++def qfunc(
++    state: Qobj,
++    xvec,
++    yvec,
++    g: float = sqrt(2),
++    precompute_memory: float = 1024,
++):
++    r"""
++    Husimi-Q function of a given state vector or density matrix at phase-space
++    points ``0.5 * g * (xvec + i*yvec)``.
++
++    Parameters
++    ----------
++    state : :obj:`.Qobj`
++        A state vector or density matrix.  This cannot have tensor-product
++        structure.
++
++    xvec, yvec : array_like
++        x- and y-coordinates at which to calculate the Husimi-Q function.
++
++    g : float, default sqrt(2)
++        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
++        related to the value of :math:`\hbar` in the commutation relation
++        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
++        corresponds to :math:`\hbar=1`.
++
++    precompute_memory : real, default 1024
++        Size in MB that may be used during calculations as working space when
++        dealing with density-matrix inputs.  This is ignored for state-vector
++        inputs.  The bound is not quite exact due to other, order-of-magnitude
++        smaller, intermediaries being necessary, but is a good approximation.
++        If you want to use the same iterative algorithm for density matrices
++        that is used for single kets, set ``precompute_memory=None``.
++
++    Returns
++    -------
++    ndarray
++        Values representing the Husimi-Q function calculated over the specified
++        range ``[xvec, yvec]``.
++
++    See Also
++    --------
++    :obj:`.QFunc` :
++        a class-based version, more efficient if you want to calculate the
++        Husimi-Q function for several states over the same coordinates.
++    """
++    state = _qfunc_check_state(state)
++    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
++    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
++    enough_memory = (
++        precompute_memory is not None
++        and precompute_memory > required_memory
++    )
++    if state.isoper and enough_memory:
++        return QFunc(xvec, yvec, g)(state)
++    if precompute_memory is not None and state.isoper:
++        warnings.warn(
++            "Falling back to iterative algorithm due to lack of memory."
++            f" Needed {required_memory:.2f} MB, but only allowed to use"
++            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
++            " raise limit, or set to `None` to suppress warning."
++        )
++    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
++    if state.isket:
++        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
++        out /= np.pi
++        return out
++    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
++    # versions of dense matrices.
++    values, vectors = eigh(state.full())
++    vectors = vectors.T
++    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
++    for value, vector in zip(values[1:], vectors[1:]):
++        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
++    out /= np.pi
++    return out
++
++
++# -----------------------------------------------------------------------------
++# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
++#
++def spin_q_function(rho, theta, phi):
++    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
++    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
++    j, theta, phi)`` where j is the spin length.
++    The implementation here is more efficient as it doesn't
++    generate all of the SCS at theta and phi (see references).
++
++    The spin Q function is normal when integrated over the surface of the
++    sphere
++
++    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
++              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
++
++    Parameters
++    ----------
++    state : qobj
++        A state vector or density matrix for a spin-j quantum system.
++    theta : array_like
++        Polar (colatitude) angle at which to calculate the Husimi-Q function.
++    phi : array_like
++        Azimuthal angle at which to calculate the Husimi-Q function.
++
++    Returns
++    -------
++    Q, THETA, PHI : 2d-array
++        Values representing the spin Husimi Q function at the values specified
++        by THETA and PHI.
++
++    References
++    ----------
++    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
++    https://doi.org/10.1119/1.4898595
++
++    """
++
++    if rho.isket or rho.isbra:
++        rho = rho.proj()
++
++    J = rho.shape[0]
++    j = (J - 1) / 2
++
++    THETA, PHI = meshgrid(theta, phi)
++
++    Q = np.zeros_like(THETA, dtype=complex)
++    data = rho.full()
++
++    for m1 in arange(-j, j + 1):
++        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
++             sin(THETA / 2) ** (2 * (j - m1)) * \
++             data[int(j - m1), int(j - m1)]
++
++        for m2 in arange(m1 + 1, j + 1):
++            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
++                  cos(THETA / 2) ** (2 * j + m1 + m2) *
++                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
++             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
++              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
++
++    return Q.real, THETA, PHI
++
++
++def _rho_kq(rho, j, k, q):
++    """
++    This calculates the trace of the multipole operator T_kq and the density
++    matrix rho for use in the spin Wigner quasiprobability distribution.
++
++    Parameters
++    ----------
++    rho : qobj
++        A density matrix for a spin-j quantum system.
++    j : float
++        The spin length of the system.
++    k : int
++        Spherical harmonic degree
++    q : int
++        Spherical harmonic order
++
++    Returns
++    -------
++    v : float
++        Overlap of state with multipole operator T_kq
++    """
++
++    v = 0j
++    data = rho.full()
++    for m1 in arange(-j, j+1):
++        for m2 in arange(-j, j+1):
++            v += (
++                    (-1) ** (2 * j - k - m1 - m2)
++                    * np.sqrt((2 * k + 1) / (2 * j + 1))
++                    * clebsch(j, k, j, -m1, q, -m2)
++                    * data[int(j - m1), int(j - m2)]
++            )
++    return v
++
++
++def spin_wigner(rho, theta, phi):
++    r"""Wigner function for a spin-j system.
++
++    The spin W function is normal when integrated over the surface of the
++    sphere
++
++    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
++              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
++
++
++    Parameters
++    ----------
++    state : qobj
++        A state vector or density matrix for a spin-j quantum system.
++    theta : array_like
++        Polar (colatitude) angle at which to calculate the W function.
++    phi : array_like
++        Azimuthal angle at which to calculate the W function.
++
++    Returns
++    -------
++    W, THETA, PHI : 2d-array
++        Values representing the spin Wigner function at the values specified
++        by THETA and PHI.
++
++    References
++    ----------
++    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
++    https://doi.org/10.1103/PhysRevA.24.2889
++
++    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
++    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
++
++    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
++    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
++
++    """
++    if rho.isket or rho.isbra:
++        rho = rho.proj()
++
++    J = rho.shape[0]
++    j = (J - 1) / 2
++
++    THETA, PHI = meshgrid(theta, phi)
++
++    W = np.zeros_like(THETA, dtype=complex)
++
++    for k in range(int(2 * j)+1):
++        for q in arange(-k, k+1):
++            # sph_harm takes azimuthal angle then polar angle as arguments
++            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
++
++    return W.real, THETA, PHI
+diff --git a/requirements.txt b/requirements.txt
+index 41d2c09a..ce27f298 100644
+--- a/requirements.txt
++++ b/requirements.txt
+@@ -1,4 +1,4 @@
+-cython>=0.29.20
+-numpy>=1.16.6
+-scipy>=1.5
+-packaging
++cython>=0.29.20
++numpy>=1.16.6
++scipy>=1.5
++packaging
+diff --git a/setup.cfg b/setup.cfg
+index 1eb1f11c..d5d6815f 100644
+--- a/setup.cfg
++++ b/setup.cfg
+@@ -1,70 +1,70 @@
+-[metadata]
+-name = qutip
+-url = https://qutip.org
+-description = QuTiP: The Quantum Toolbox in Python
+-long_description = file: README.md
+-long_description_content_type = text/markdown; variant=GFM
+-keywords = quantum, physics, dynamics
+-license = BSD 3-Clause License
+-license_files = LICENSE.txt
+-project_urls =
+-    Bug Tracker = https://github.com/qutip/qutip/issues
+-    Documentation = https://qutip.org/docs/latest/
+-    Source Code = https://github.com/qutip/qutip
+-classifiers =
+-    Development Status :: 2 - Pre-Alpha
+-    Intended Audience :: Science/Research
+-    License :: OSI Approved :: BSD License
+-    Programming Language :: Python
+-    Programming Language :: Python :: 3
+-    Topic :: Scientific/Engineering
+-    Operating System :: MacOS
+-    Operating System :: POSIX
+-    Operating System :: Unix
+-    Operating System :: Microsoft :: Windows
+-author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
+-author_email = qutip-admin@googlegroups.com
+-platforms = Linux, Mac OSX, Unix, Windows
+-
+-[options]
+-packages = find:
+-include_package_data = True
+-zip_safe = False
+-install_requires =
+-    numpy>=1.16.6
+-    scipy>=1.0
+-    packaging
+-setup_requires =
+-    numpy>=1.13.3
+-    scipy>=1.0
+-    cython>=0.29.20
+-    packaging
+-
+-[options.packages.find]
+-include = qutip*
+-
+-[options.extras_require]
+-graphics = matplotlib>=1.2.1
+-runtime_compilation =
+-    cython>=0.29.20
+-    filelock
+-semidefinite =
+-    cvxpy>=1.0
+-    cvxopt
+-tests =
+-    pytest>=5.2
+-    pytest-rerunfailures
+-ipython =
+-    ipython
+-extras =
+-    loky
+-    tqdm
+-; This uses ConfigParser's string interpolation to include all the above
+-; dependencies into one single target, convenient for testing full builds.
+-full =
+-    %(graphics)s
+-    %(runtime_compilation)s
+-    %(semidefinite)s
+-    %(tests)s
+-    %(ipython)s
+-    %(extras)s
++[metadata]
++name = qutip
++url = https://qutip.org
++description = QuTiP: The Quantum Toolbox in Python
++long_description = file: README.md
++long_description_content_type = text/markdown; variant=GFM
++keywords = quantum, physics, dynamics
++license = BSD 3-Clause License
++license_files = LICENSE.txt
++project_urls =
++    Bug Tracker = https://github.com/qutip/qutip/issues
++    Documentation = https://qutip.org/docs/latest/
++    Source Code = https://github.com/qutip/qutip
++classifiers =
++    Development Status :: 2 - Pre-Alpha
++    Intended Audience :: Science/Research
++    License :: OSI Approved :: BSD License
++    Programming Language :: Python
++    Programming Language :: Python :: 3
++    Topic :: Scientific/Engineering
++    Operating System :: MacOS
++    Operating System :: POSIX
++    Operating System :: Unix
++    Operating System :: Microsoft :: Windows
++author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
++author_email = qutip-admin@googlegroups.com
++platforms = Linux, Mac OSX, Unix, Windows
++
++[options]
++packages = find:
++include_package_data = True
++zip_safe = False
++install_requires =
++    numpy>=1.16.6
++    scipy>=1.0
++    packaging
++setup_requires =
++    numpy>=1.13.3
++    scipy>=1.0
++    cython>=0.29.20
++    packaging
++
++[options.packages.find]
++include = qutip*
++
++[options.extras_require]
++graphics = matplotlib>=1.2.1
++runtime_compilation =
++    cython>=0.29.20
++    filelock
++semidefinite =
++    cvxpy>=1.0
++    cvxopt
++tests =
++    pytest>=5.2
++    pytest-rerunfailures
++ipython =
++    ipython
++extras =
++    loky
++    tqdm
++; This uses ConfigParser's string interpolation to include all the above
++; dependencies into one single target, convenient for testing full builds.
++full =
++    %(graphics)s
++    %(runtime_compilation)s
++    %(semidefinite)s
++    %(tests)s
++    %(ipython)s
++    %(extras)s
+diff --git a/setup.py b/setup.py
+index 0bf5b8de..ddde7658 100755
+--- a/setup.py
++++ b/setup.py
+@@ -1,312 +1,312 @@
+-#!/usr/bin/env python
+-
+-import collections
+-import os
+-import pathlib
+-import subprocess
+-import sys
+-import sysconfig
+-import warnings
+-
+-# Required third-party imports, must be specified in pyproject.toml.
+-import packaging.version
+-from setuptools import setup, Extension
+-import distutils.sysconfig
+-import numpy as np
+-from Cython.Build import cythonize
+-from Cython.Distutils import build_ext
+-
+-
+-def process_options():
+-    """
+-    Determine all runtime options, returning a dictionary of the results.  The
+-    keys are:
+-        'rootdir': str
+-            The root directory of the setup.  Almost certainly the directory
+-            that this setup.py file is contained in.
+-        'release': bool
+-            Is this a release build (True) or a local development build (False)
+-        'openmp': bool
+-            Should we build our OpenMP extensions and attempt to link in OpenMP
+-            libraries? (Not supported in this version.)
+-        'cflags': list of str
+-            Flags to be passed to the C++ compiler.
+-        'ldflags': list of str
+-            Flags to be passed to the linker.
+-        'include': list of str
+-            Additional directories to be added to the header files include
+-            path.  These files will be detected by Cython as dependencies, so
+-            changes to them will trigger recompilation of .pyx files, whereas
+-            includes added in 'cflags' as '-I/path/to/include' may not.
+-    """
+-    options = {}
+-    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
+-    options = _determine_user_arguments(options)
+-    options = _determine_version(options)
+-    options = _determine_compilation_options(options)
+-    options = _determine_cythonize_options(options)
+-    return options
+-
+-
+-def _get_environment_bool(var, default=False):
+-    """
+-    Get a boolean value from the environment variable `var`.  This evalutes to
+-    `default` if the environment variable is not present.  The false-y values
+-    are '0', 'false', 'none' and empty string, insensitive to case.  All other
+-    values are truth-y.
+-    """
+-    from_env = os.environ.get(var)
+-    if from_env is None:
+-        return default
+-    return from_env.lower() not in {'0', 'false', 'none', ''}
+-
+-
+-def _parse_bool_user_argument(options, name):
+-    """
+-    Parse a single boolean option from the commandline or environment.
+-    """
+-    cmd_flag = "--with-" + name.lower().replace("_", "-")
+-    env_var = "CI_QUTIP_WITH_" + name.upper()
+-    options[name] = (
+-        cmd_flag in sys.argv
+-        or _get_environment_bool(env_var)
+-    )
+-    if cmd_flag in sys.argv:
+-        sys.argv.remove(cmd_flag)
+-    return options
+-
+-
+-def _determine_user_arguments(options):
+-    """
+-    Add the 'openmp' option to the collection, based on the passed command-line
+-    arguments or environment variables.
+-
+-    If using PEP517 builds, one can pass these options on the command-line
+-    using, for example:
+-
+-        python -m build \
+-            --wheel \
+-            --config-setting="--global-option=--with-openmp"
+-    """
+-    # options = _parse_bool_user_argument(options, 'openmp')
+-    options['openmp'] = False  # Not supported yet
+-    options = _parse_bool_user_argument(options, 'idxint_64')
+-    return options
+-
+-
+-def _determine_compilation_options(options):
+-    """
+-    Add additional options specific to C/C++ compilation.  These are 'cflags',
+-    'ldflags' and 'include'.
+-    """
+-    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
+-    # process uses in addition to user-specified ones; the flag is not valid
+-    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
+-    config = distutils.sysconfig.get_config_vars()
+-    if "CFLAGS" in config:
+-        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
+-    options['cflags'] = []
+-    options['ldflags'] = []
+-    options['include'] = [np.get_include()]
+-    if (
+-        sysconfig.get_platform().startswith("win")
+-        and os.environ.get('MSYSTEM') is None
+-    ):
+-        # Visual Studio
+-        options['cflags'].extend(['/w', '/Ox'])
+-        if options['openmp']:
+-            options['cflags'].append('/openmp')
+-    else:
+-        # Everything else
+-        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
+-        if options['openmp']:
+-            options['cflags'].append('-fopenmp')
+-            options['ldflags'].append('-fopenmp')
+-    if sysconfig.get_platform().startswith("macos"):
+-        # These are needed for compiling on OSX 10.14+
+-        options['cflags'].append('-mmacosx-version-min=10.9')
+-        options['ldflags'].append('-mmacosx-version-min=10.9')
+-        if options['openmp']:
+-            options['cflags'].append('-fopenmp')
+-            options['ldflags'].append('-fopenmp')
+-    return options
+-
+-
+-def _determine_cythonize_options(options):
+-    options["annotate"] = False
+-    if "--annotate" in sys.argv:
+-        options["annotate"] = True
+-        sys.argv.remove("--annotate")
+-    if "-a" in sys.argv:
+-        options["annotate"] = True
+-        sys.argv.remove("-a")
+-    return options
+-
+-
+-def _determine_version(options):
+-    """
+-    Adds the 'short_version', 'version' and 'release' options.
+-
+-    Read from the VERSION file to discover the version.  This should be a
+-    single line file containing valid Python package public identifier (see PEP
+-    440), for example
+-      4.5.2rc2
+-      5.0.0
+-      5.1.1a1
+-    We do that here rather than in setup.cfg so we can apply the local
+-    versioning number as well.
+-    """
+-    version_filename = os.path.join(options['rootdir'], 'VERSION')
+-    with open(version_filename, "r") as version_file:
+-        version_string = version_file.read().strip()
+-    version = packaging.version.Version(version_string)
+-    options['short_version'] = str(version.public)
+-    options['release'] = not version.is_devrelease
+-    if not options['release']:
+-        # Put the version string into canonical form, if it wasn't already.
+-        version_string = str(version)
+-        version_string += "+"
+-        try:
+-            git_out = subprocess.run(
+-                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
+-                check=True,
+-                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+-            )
+-            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
+-            version_string += git_hash or "nogit"
+-        # CalledProcessError is for if the git command fails for internal
+-        # reasons (e.g. we're not in a git repository), OSError is for if
+-        # something goes wrong when trying to run git (e.g. it's not installed,
+-        # or a permission error).
+-        except (subprocess.CalledProcessError, OSError):
+-            version_string += "nogit"
+-    options['version'] = version_string
+-    return options
+-
+-
+-def create_version_py_file(options):
+-    """
+-    Generate and write out the file qutip/version.py, which is used to produce
+-    the '__version__' information for the module.  This function will overwrite
+-    an existing file at that location.
+-    """
+-    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
+-    content = "\n".join([
+-        f"# This file is automatically generated by QuTiP's setup.py.",
+-        f"short_version = '{options['short_version']}'",
+-        f"version = '{options['version']}'",
+-        f"release = {options['release']}",
+-    ])
+-    with open(filename, 'w') as file:
+-        print(content, file=file)
+-
+-
+-def _extension_extra_sources():
+-    """
+-    Get a mapping of {module: extra_sources} for all modules to be built.  The
+-    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
+-    and extra_sources is a list of strings of relative paths to files.  If no
+-    extra sources are known for a given module, the mapping will return an
+-    empty list.
+-    """
+-    # For typing brevity we specify sources in Unix-style string form, then
+-    # normalise them into the OS-specific form later.
+-    extra_sources = {
+-        'qutip.core.data.matmul': [
+-            'qutip/core/data/src/matmul_csr_vector.cpp',
+-        ],
+-    }
+-    out = collections.defaultdict(list)
+-    for module, sources in extra_sources.items():
+-        # Normalise the sources into OS-specific form.
+-        out[module] = [str(pathlib.Path(source)) for source in sources]
+-    return out
+-
+-
+-def _create_int_type_file(options):
+-    """
+-    Create the `data/src/intdtype.h` file.
+-    """
+-    if options['idxint_64']:
+-        typedef = "typedef int64_t idxint;\n"
+-        typedef += "int _idxint_size=64;\n"
+-    else:
+-        typedef = "typedef int32_t idxint;\n"
+-        typedef += "int _idxint_size=32;\n"
+-    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
+-    file = os.path.join(path, 'intdtype.h')
+-    if os.path.exists(file):
+-        with open(file, 'r') as source:
+-            if source.read() == typedef:
+-                # The file is already existing and the same, nothing to do.
+-                return
+-
+-    with open(file, 'w') as source:
+-        source.write(typedef)
+-
+-
+-def create_extension_modules(options):
+-    """
+-    Discover and Cythonise all extension modules that need to be built.  These
+-    are returned so they can be passed into the setup command.
+-    """
+-    out = []
+-    root = pathlib.Path(options['rootdir'])
+-    _create_int_type_file(options)
+-    pyx_files = set(root.glob('qutip/**/*.pyx'))
+-    if not options['openmp']:
+-        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
+-    extra_sources = _extension_extra_sources()
+-    # Add Cython files from qutip
+-    for pyx_file in pyx_files:
+-        pyx_file = pyx_file.relative_to(root)
+-        pyx_file_str = str(pyx_file)
+-        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
+-            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
+-            # Cythonised time-dependent coefficients would get dropped in the
+-            # qutip directory if you weren't careful - this is just trying to
+-            # minimise the occasional developer error.
+-            warnings.warn(
+-                "skipping generated time-dependent coefficient: "
+-                + pyx_file_str
+-            )
+-            continue
+-        # The module name is the same as the folder structure, but with dots in
+-        # place of separators ('/' or '\'), and without the '.pyx' extension.
+-        pyx_module = ".".join(pyx_file.parts)[:-4]
+-        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
+-        out.append(Extension(pyx_module,
+-                             sources=pyx_sources,
+-                             include_dirs=options['include'],
+-                             extra_compile_args=options['cflags'],
+-                             extra_link_args=options['ldflags'],
+-                             language='c++'))
+-    return cythonize(out, annotate=options["annotate"])
+-
+-
+-def print_epilogue():
+-    """Display a post-setup epilogue."""
+-    longbar = "="*80
+-    message = "\n".join([
+-        longbar,
+-        "Installation complete",
+-        "Please cite QuTiP in your publication.",
+-        longbar,
+-        "For your convenience a BibTeX reference can be easily generated with",
+-        "`qutip.cite()`",
+-    ])
+-    print(message)
+-
+-
+-if __name__ == "__main__":
+-    options = process_options()
+-    create_version_py_file(options)
+-    extensions = create_extension_modules(options)
+-    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
+-    # keep here are ones that we have done some compile-time processing on.
+-    setup(
+-        version=options['version'],
+-        ext_modules=extensions,
+-        cmdclass={'build_ext': build_ext},
+-    )
+-    print_epilogue()
++#!/usr/bin/env python
++
++import collections
++import os
++import pathlib
++import subprocess
++import sys
++import sysconfig
++import warnings
++
++# Required third-party imports, must be specified in pyproject.toml.
++import packaging.version
++from setuptools import setup, Extension
++import distutils.sysconfig
++import numpy as np
++from Cython.Build import cythonize
++from Cython.Distutils import build_ext
++
++
++def process_options():
++    """
++    Determine all runtime options, returning a dictionary of the results.  The
++    keys are:
++        'rootdir': str
++            The root directory of the setup.  Almost certainly the directory
++            that this setup.py file is contained in.
++        'release': bool
++            Is this a release build (True) or a local development build (False)
++        'openmp': bool
++            Should we build our OpenMP extensions and attempt to link in OpenMP
++            libraries? (Not supported in this version.)
++        'cflags': list of str
++            Flags to be passed to the C++ compiler.
++        'ldflags': list of str
++            Flags to be passed to the linker.
++        'include': list of str
++            Additional directories to be added to the header files include
++            path.  These files will be detected by Cython as dependencies, so
++            changes to them will trigger recompilation of .pyx files, whereas
++            includes added in 'cflags' as '-I/path/to/include' may not.
++    """
++    options = {}
++    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
++    options = _determine_user_arguments(options)
++    options = _determine_version(options)
++    options = _determine_compilation_options(options)
++    options = _determine_cythonize_options(options)
++    return options
++
++
++def _get_environment_bool(var, default=False):
++    """
++    Get a boolean value from the environment variable `var`.  This evalutes to
++    `default` if the environment variable is not present.  The false-y values
++    are '0', 'false', 'none' and empty string, insensitive to case.  All other
++    values are truth-y.
++    """
++    from_env = os.environ.get(var)
++    if from_env is None:
++        return default
++    return from_env.lower() not in {'0', 'false', 'none', ''}
++
++
++def _parse_bool_user_argument(options, name):
++    """
++    Parse a single boolean option from the commandline or environment.
++    """
++    cmd_flag = "--with-" + name.lower().replace("_", "-")
++    env_var = "CI_QUTIP_WITH_" + name.upper()
++    options[name] = (
++        cmd_flag in sys.argv
++        or _get_environment_bool(env_var)
++    )
++    if cmd_flag in sys.argv:
++        sys.argv.remove(cmd_flag)
++    return options
++
++
++def _determine_user_arguments(options):
++    """
++    Add the 'openmp' option to the collection, based on the passed command-line
++    arguments or environment variables.
++
++    If using PEP517 builds, one can pass these options on the command-line
++    using, for example:
++
++        python -m build \
++            --wheel \
++            --config-setting="--global-option=--with-openmp"
++    """
++    # options = _parse_bool_user_argument(options, 'openmp')
++    options['openmp'] = False  # Not supported yet
++    options = _parse_bool_user_argument(options, 'idxint_64')
++    return options
++
++
++def _determine_compilation_options(options):
++    """
++    Add additional options specific to C/C++ compilation.  These are 'cflags',
++    'ldflags' and 'include'.
++    """
++    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
++    # process uses in addition to user-specified ones; the flag is not valid
++    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
++    config = distutils.sysconfig.get_config_vars()
++    if "CFLAGS" in config:
++        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
++    options['cflags'] = []
++    options['ldflags'] = []
++    options['include'] = [np.get_include()]
++    if (
++        sysconfig.get_platform().startswith("win")
++        and os.environ.get('MSYSTEM') is None
++    ):
++        # Visual Studio
++        options['cflags'].extend(['/w', '/Ox'])
++        if options['openmp']:
++            options['cflags'].append('/openmp')
++    else:
++        # Everything else
++        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
++        if options['openmp']:
++            options['cflags'].append('-fopenmp')
++            options['ldflags'].append('-fopenmp')
++    if sysconfig.get_platform().startswith("macos"):
++        # These are needed for compiling on OSX 10.14+
++        options['cflags'].append('-mmacosx-version-min=10.9')
++        options['ldflags'].append('-mmacosx-version-min=10.9')
++        if options['openmp']:
++            options['cflags'].append('-fopenmp')
++            options['ldflags'].append('-fopenmp')
++    return options
++
++
++def _determine_cythonize_options(options):
++    options["annotate"] = False
++    if "--annotate" in sys.argv:
++        options["annotate"] = True
++        sys.argv.remove("--annotate")
++    if "-a" in sys.argv:
++        options["annotate"] = True
++        sys.argv.remove("-a")
++    return options
++
++
++def _determine_version(options):
++    """
++    Adds the 'short_version', 'version' and 'release' options.
++
++    Read from the VERSION file to discover the version.  This should be a
++    single line file containing valid Python package public identifier (see PEP
++    440), for example
++      4.5.2rc2
++      5.0.0
++      5.1.1a1
++    We do that here rather than in setup.cfg so we can apply the local
++    versioning number as well.
++    """
++    version_filename = os.path.join(options['rootdir'], 'VERSION')
++    with open(version_filename, "r") as version_file:
++        version_string = version_file.read().strip()
++    version = packaging.version.Version(version_string)
++    options['short_version'] = str(version.public)
++    options['release'] = not version.is_devrelease
++    if not options['release']:
++        # Put the version string into canonical form, if it wasn't already.
++        version_string = str(version)
++        version_string += "+"
++        try:
++            git_out = subprocess.run(
++                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
++                check=True,
++                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
++            )
++            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
++            version_string += git_hash or "nogit"
++        # CalledProcessError is for if the git command fails for internal
++        # reasons (e.g. we're not in a git repository), OSError is for if
++        # something goes wrong when trying to run git (e.g. it's not installed,
++        # or a permission error).
++        except (subprocess.CalledProcessError, OSError):
++            version_string += "nogit"
++    options['version'] = version_string
++    return options
++
++
++def create_version_py_file(options):
++    """
++    Generate and write out the file qutip/version.py, which is used to produce
++    the '__version__' information for the module.  This function will overwrite
++    an existing file at that location.
++    """
++    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
++    content = "\n".join([
++        f"# This file is automatically generated by QuTiP's setup.py.",
++        f"short_version = '{options['short_version']}'",
++        f"version = '{options['version']}'",
++        f"release = {options['release']}",
++    ])
++    with open(filename, 'w') as file:
++        print(content, file=file)
++
++
++def _extension_extra_sources():
++    """
++    Get a mapping of {module: extra_sources} for all modules to be built.  The
++    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
++    and extra_sources is a list of strings of relative paths to files.  If no
++    extra sources are known for a given module, the mapping will return an
++    empty list.
++    """
++    # For typing brevity we specify sources in Unix-style string form, then
++    # normalise them into the OS-specific form later.
++    extra_sources = {
++        'qutip.core.data.matmul': [
++            'qutip/core/data/src/matmul_csr_vector.cpp',
++        ],
++    }
++    out = collections.defaultdict(list)
++    for module, sources in extra_sources.items():
++        # Normalise the sources into OS-specific form.
++        out[module] = [str(pathlib.Path(source)) for source in sources]
++    return out
++
++
++def _create_int_type_file(options):
++    """
++    Create the `data/src/intdtype.h` file.
++    """
++    if options['idxint_64']:
++        typedef = "typedef int64_t idxint;\n"
++        typedef += "int _idxint_size=64;\n"
++    else:
++        typedef = "typedef int32_t idxint;\n"
++        typedef += "int _idxint_size=32;\n"
++    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
++    file = os.path.join(path, 'intdtype.h')
++    if os.path.exists(file):
++        with open(file, 'r') as source:
++            if source.read() == typedef:
++                # The file is already existing and the same, nothing to do.
++                return
++
++    with open(file, 'w') as source:
++        source.write(typedef)
++
++
++def create_extension_modules(options):
++    """
++    Discover and Cythonise all extension modules that need to be built.  These
++    are returned so they can be passed into the setup command.
++    """
++    out = []
++    root = pathlib.Path(options['rootdir'])
++    _create_int_type_file(options)
++    pyx_files = set(root.glob('qutip/**/*.pyx'))
++    if not options['openmp']:
++        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
++    extra_sources = _extension_extra_sources()
++    # Add Cython files from qutip
++    for pyx_file in pyx_files:
++        pyx_file = pyx_file.relative_to(root)
++        pyx_file_str = str(pyx_file)
++        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
++            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
++            # Cythonised time-dependent coefficients would get dropped in the
++            # qutip directory if you weren't careful - this is just trying to
++            # minimise the occasional developer error.
++            warnings.warn(
++                "skipping generated time-dependent coefficient: "
++                + pyx_file_str
++            )
++            continue
++        # The module name is the same as the folder structure, but with dots in
++        # place of separators ('/' or '\'), and without the '.pyx' extension.
++        pyx_module = ".".join(pyx_file.parts)[:-4]
++        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
++        out.append(Extension(pyx_module,
++                             sources=pyx_sources,
++                             include_dirs=options['include'],
++                             extra_compile_args=options['cflags'],
++                             extra_link_args=options['ldflags'],
++                             language='c++'))
++    return cythonize(out, annotate=options["annotate"])
++
++
++def print_epilogue():
++    """Display a post-setup epilogue."""
++    longbar = "="*80
++    message = "\n".join([
++        longbar,
++        "Installation complete",
++        "Please cite QuTiP in your publication.",
++        longbar,
++        "For your convenience a BibTeX reference can be easily generated with",
++        "`qutip.cite()`",
++    ])
++    print(message)
++
++
++if __name__ == "__main__":
++    options = process_options()
++    create_version_py_file(options)
++    extensions = create_extension_modules(options)
++    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
++    # keep here are ones that we have done some compile-time processing on.
++    setup(
++        version=options['version'],
++        ext_modules=extensions,
++        cmdclass={'build_ext': build_ext},
++    )
++    print_epilogue()
diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 892c0a651a..fe7c021e26 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -283,6 +283,12 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
+.. note::
+    While the example code simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
+    allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting the sec_cutoff 
+    parameter to -1. as well as do a partial secular approximation by setting it to a  float. the default value is 0.1
+
+    Note that using the non-secular version may lead to negativity issues.
 
 .. _td-bloch-redfield:
 
diff --git a/pyproject.toml b/pyproject.toml
index f854fa46f5..c858ef1e37 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,54 +1,54 @@
-[build-system]
-requires = [
-    "setuptools",
-    "packaging",
-    "wheel",
-    "cython>=0.29.20",
-    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
-    # the recommended way to build against numpy's C API:
-    "oldest-supported-numpy",
-    "scipy>=1.0",
-]
-build-backend = "setuptools.build_meta"
-
-[tool.cibuildwheel]
-manylinux-x86_64-image = "manylinux2014"
-manylinux-i686-image = "manylinux2014"
-# Change in future version to "build"
-build-frontend = "pip"
-
-[[tool.cibuildwheel.overrides]]
-# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
-select = "cp3{6,7}-*"
-manylinux-x86_64-image = "manylinux2010"
-manylinux-i686-image = "manylinux2010"
-
-[tool.towncrier]
-directory = "doc/changes"
-filename = "doc/changelog.rst"
-name = "QuTiP"
-package = "qutip"
-[[tool.towncrier.type]]
-directory = "deprecation"
-name = "Deprecations"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "feature"
-name = "Features"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "bugfix"
-name = "Bug Fixes"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "removal"
-name = "Removals"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "doc"
-name = "Documentation"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "misc"
-name = "Miscellaneous"
-showcontent = true
+[build-system]
+requires = [
+    "setuptools",
+    "packaging",
+    "wheel",
+    "cython>=0.29.20",
+    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
+    # the recommended way to build against numpy's C API:
+    "oldest-supported-numpy",
+    "scipy>=1.0",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.cibuildwheel]
+manylinux-x86_64-image = "manylinux2014"
+manylinux-i686-image = "manylinux2014"
+# Change in future version to "build"
+build-frontend = "pip"
+
+[[tool.cibuildwheel.overrides]]
+# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
+select = "cp3{6,7}-*"
+manylinux-x86_64-image = "manylinux2010"
+manylinux-i686-image = "manylinux2010"
+
+[tool.towncrier]
+directory = "doc/changes"
+filename = "doc/changelog.rst"
+name = "QuTiP"
+package = "qutip"
+[[tool.towncrier.type]]
+directory = "deprecation"
+name = "Deprecations"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "feature"
+name = "Features"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "bugfix"
+name = "Bug Fixes"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "removal"
+name = "Removals"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "doc"
+name = "Documentation"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "misc"
+name = "Miscellaneous"
+showcontent = true
diff --git a/qutip/__init__.py b/qutip/__init__.py
index fc7f65b409..fe889959ea 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -1,68 +1,68 @@
-import os
-import warnings
-
-import qutip.settings
-from qutip.settings import settings
-import qutip.version
-from qutip.version import version as __version__
-
-# -----------------------------------------------------------------------------
-# Look to see if we are running with OPENMP
-#
-# Set environ variable to determin if running in parallel mode
-# (i.e. in parfor or parallel_map)
-os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-
-
-# -----------------------------------------------------------------------------
-# Check that import modules are compatible with requested configuration
-#
-
-# Check for Matplotlib
-try:
-    import matplotlib
-except ImportError:
-    warnings.warn("matplotlib not found: Graphics will not work.")
-else:
-    del matplotlib
-
-
-# -----------------------------------------------------------------------------
-# Load modules
-#
-
-from .core import *
-from .solver import *
-from .solve import nonmarkov
-import qutip.solve.piqs as piqs
-from .solve.stochastic import *
-
-# graphics
-from .bloch import *
-from .visualization import *
-from .orbital import *
-from .bloch3d import *
-from .matplotlib_utilities import *
-
-# library functions
-from .tomography import *
-from .wigner import *
-from .random_objects import *
-from .simdiag import *
-from .entropy import *
-from .partial_transpose import *
-from .continuous_variables import *
-from .distributions import *
-from .three_level_atom import *
-
-
-# utilities
-from .utilities import *
-from .fileio import *
-from .about import *
-from .cite import *
-
-# -----------------------------------------------------------------------------
-# Clean name space
-#
-del os, warnings
+import os
+import warnings
+
+import qutip.settings
+from qutip.settings import settings
+import qutip.version
+from qutip.version import version as __version__
+
+# -----------------------------------------------------------------------------
+# Look to see if we are running with OPENMP
+#
+# Set environ variable to determin if running in parallel mode
+# (i.e. in parfor or parallel_map)
+os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+
+
+# -----------------------------------------------------------------------------
+# Check that import modules are compatible with requested configuration
+#
+
+# Check for Matplotlib
+try:
+    import matplotlib
+except ImportError:
+    warnings.warn("matplotlib not found: Graphics will not work.")
+else:
+    del matplotlib
+
+
+# -----------------------------------------------------------------------------
+# Load modules
+#
+
+from .core import *
+from .solver import *
+from .solve import nonmarkov
+import qutip.solve.piqs as piqs
+from .solve.stochastic import *
+
+# graphics
+from .bloch import *
+from .visualization import *
+from .orbital import *
+from .bloch3d import *
+from .matplotlib_utilities import *
+
+# library functions
+from .tomography import *
+from .wigner import *
+from .random_objects import *
+from .simdiag import *
+from .entropy import *
+from .partial_transpose import *
+from .continuous_variables import *
+from .distributions import *
+from .three_level_atom import *
+
+
+# utilities
+from .utilities import *
+from .fileio import *
+from .about import *
+from .cite import *
+
+# -----------------------------------------------------------------------------
+# Clean name space
+#
+del os, warnings
diff --git a/qutip/_mkl/__init__.py b/qutip/_mkl/__init__.py
index 8b13789179..d3f5a12faa 100644
--- a/qutip/_mkl/__init__.py
+++ b/qutip/_mkl/__init__.py
@@ -1 +1 @@
-
+
diff --git a/qutip/_mkl/spmv.py b/qutip/_mkl/spmv.py
index ac2ca16c28..909e7b4b49 100644
--- a/qutip/_mkl/spmv.py
+++ b/qutip/_mkl/spmv.py
@@ -1,38 +1,38 @@
-import numpy as np
-from ctypes import POINTER, c_int, c_char, byref
-from numpy.ctypeslib import ndpointer
-import qutip.settings as qset
-zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
-
-
-def mkl_spmv(A, x):
-    """
-    sparse csr_spmv using MKL
-    """
-    m, _ = A.shape
-
-    # Pointers to data of the matrix
-    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
-    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
-    indices = A.indices.ctypes.data_as(POINTER(c_int))
-
-    # Allocate output, using same conventions as input
-    if x.ndim == 1:
-        y = np.empty(m, dtype=np.complex128, order='C')
-    elif x.ndim == 2 and x.shape[1] == 1:
-        y = np.empty((m, 1), dtype=np.complex128, order='C')
-    else:
-        raise Exception('Input vector must be 1D row or 2D column vector')
-
-    # Now call MKL. This returns the answer in the last argument, which shares
-    # memory with y.
-    zcsrgemv(
-        byref(c_char(bytes(b'N'))),
-        byref(c_int(m)),
-        data,
-        indptr,
-        indices,
-        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
-        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
-    )
-    return y
+import numpy as np
+from ctypes import POINTER, c_int, c_char, byref
+from numpy.ctypeslib import ndpointer
+import qutip.settings as qset
+zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
+
+
+def mkl_spmv(A, x):
+    """
+    sparse csr_spmv using MKL
+    """
+    m, _ = A.shape
+
+    # Pointers to data of the matrix
+    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
+    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
+    indices = A.indices.ctypes.data_as(POINTER(c_int))
+
+    # Allocate output, using same conventions as input
+    if x.ndim == 1:
+        y = np.empty(m, dtype=np.complex128, order='C')
+    elif x.ndim == 2 and x.shape[1] == 1:
+        y = np.empty((m, 1), dtype=np.complex128, order='C')
+    else:
+        raise Exception('Input vector must be 1D row or 2D column vector')
+
+    # Now call MKL. This returns the answer in the last argument, which shares
+    # memory with y.
+    zcsrgemv(
+        byref(c_char(bytes(b'N'))),
+        byref(c_int(m)),
+        data,
+        indptr,
+        indices,
+        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
+        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
+    )
+    return y
diff --git a/qutip/_mkl/spsolve.py b/qutip/_mkl/spsolve.py
index 7a38c5151f..82d2266bbd 100644
--- a/qutip/_mkl/spsolve.py
+++ b/qutip/_mkl/spsolve.py
@@ -1,405 +1,405 @@
-import sys
-import numpy as np
-import scipy.sparse as sp
-from ctypes import c_int, byref
-from numpy.ctypeslib import ndpointer
-import time
-from qutip.settings import settings as qset
-
-# Load solver functions from mkl_lib
-pardiso = qset.mkl_lib.pardiso
-pardiso_delete = qset.mkl_lib.pardiso_handle_delete
-if sys.maxsize > 2**32: #Running 64-bit
-    pardiso_64 = qset.mkl_lib.pardiso_64
-    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
-
-
-def _pardiso_parameters(hermitian, has_perm,
-                        max_iter_refine,
-                        scaling_vectors,
-                        weighted_matching):
-    iparm = np.zeros(64, dtype=np.int32)
-    iparm[0] = 1  # Do not use default values
-    iparm[1] = 3  # Use openmp nested dissection
-    if has_perm:
-        iparm[4] = 1
-    iparm[7] = max_iter_refine  # Max number of iterative refinements
-    if hermitian:
-        iparm[9] = 8
-    else:
-        iparm[9] = 13
-    if not hermitian:
-        iparm[10] = int(scaling_vectors)
-        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
-    iparm[17] = -1
-    iparm[20] = 1
-    iparm[23] = 1  # Parallel factorization
-    iparm[26] = 0  # Check matrix structure
-    iparm[34] = 1  # Use zero-based indexing
-    return iparm
-
-
-# Set error messages
-pardiso_error_msgs = {
-    '-1': 'Input inconsistant',
-    '-2': 'Out of memory',
-    '-3': 'Reordering problem',
-    '-4':
-        'Zero pivot, numerical factorization or iterative refinement problem',
-    '-5': 'Unclassified internal error',
-    '-6': 'Reordering failed',
-    '-7': 'Diagonal matrix is singular',
-    '-8': '32-bit integer overflow',
-    '-9': 'Not enough memory for OOC',
-    '-10': 'Error opening OOC files',
-    '-11': 'Read/write error with OOC files',
-    '-12': 'Pardiso-64 called from 32-bit library',
-}
-
-
-def _default_solver_args():
-    return {
-        'hermitian': False,
-        'posdef': False,
-        'max_iter_refine': 10,
-        'scaling_vectors': True,
-        'weighted_matching': True,
-        'return_info': False,
-    }
-
-
-class mkl_lu:
-    """
-    Object pointing to LU factorization of a sparse matrix
-    generated by mkl_splu.
-
-    Methods
-    -------
-    solve(b, verbose=False)
-        Solve system of equations using given RHS vector 'b'.
-        Returns solution ndarray with same shape as input.
-
-    info()
-        Returns the statistics of the factorization and
-        solution in the lu.info attribute.
-
-    delete()
-        Deletes the allocated solver memory.
-
-    """
-    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
-                 indptr=None, indices=None, iparm=None, np_iparm=None,
-                 mtype=None, perm=None, np_perm=None, factor_time=None):
-        self._np_pt = np_pt
-        self._dim = dim
-        self._is_complex = is_complex
-        self._data = data
-        self._indptr = indptr
-        self._indices = indices
-        self._iparm = iparm
-        self._np_iparm = np_iparm
-        self._mtype = mtype
-        self._perm = perm
-        self._np_perm = np_perm
-        self._factor_time = factor_time
-        self._solve_time = None
-
-    def solve(self, b, verbose=None):
-        b_shp = b.shape
-        if b.ndim == 2 and b.shape[1] == 1:
-            b = b.ravel()
-            nrhs = 1
-        elif b.ndim == 2 and b.shape[1] != 1:
-            nrhs = b.shape[1]
-            b = b.ravel(order='F')
-        else:
-            b = b.ravel()
-            nrhs = 1
-
-        data_type = np.complex128 if self._is_complex else np.float64
-        if b.dtype != data_type:
-            b = b.astype(np.complex128, copy=False)
-
-        # Create solution array (x) and pointers to x and b
-        x = np.zeros(b.shape, dtype=data_type, order='C')
-        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-
-        error = np.zeros(1, dtype=np.int32)
-        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-        # Call solver
-        _solve_start = time.time()
-        pardiso(
-            self._np_pt,
-            byref(c_int(1)),
-            byref(c_int(1)),
-            byref(c_int(self._mtype)),
-            byref(c_int(33)),
-            byref(c_int(self._dim)),
-            self._data,
-            self._indptr,
-            self._indices,
-            self._np_perm,
-            byref(c_int(nrhs)),
-            self._np_iparm,
-            byref(c_int(0)),
-            np_b,
-            np_x,
-            np_error,
-        )
-        self._solve_time = time.time() - _solve_start
-        if error[0] != 0:
-            raise Exception(pardiso_error_msgs[str(error[0])])
-
-        if verbose:
-            print('Solution Stage')
-            print('--------------')
-            print('Solution time:                  ',
-                  round(self._solve_time, 4))
-            print('Solution memory (Mb):           ',
-                  round(self._iparm[16]/1024, 4))
-            print('Number of iterative refinements:',
-                  self._iparm[6])
-            print('Total memory (Mb):              ',
-                  round(sum(self._iparm[15:17])/1024, 4))
-            print()
-        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
-
-    def info(self):
-        info = {'FactorTime': self._factor_time,
-                'SolveTime': self._solve_time,
-                'Factormem': round(self._iparm[15]/1024, 4),
-                'Solvemem': round(self._iparm[16]/1024, 4),
-                'IterRefine': self._iparm[6]}
-        return info
-
-    def delete(self):
-        # Delete all data
-        error = np.zeros(1, dtype=np.int32)
-        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-        pardiso(
-            self._np_pt,
-            byref(c_int(1)),
-            byref(c_int(1)),
-            byref(c_int(self._mtype)),
-            byref(c_int(-1)),
-            byref(c_int(self._dim)),
-            self._data,
-            self._indptr,
-            self._indices,
-            self._np_perm,
-            byref(c_int(1)),
-            self._np_iparm,
-            byref(c_int(0)),
-            byref(c_int(0)),
-            byref(c_int(0)),
-            np_error,
-        )
-        if error[0] == -10:
-            raise Exception('Error freeing solver memory')
-
-
-_MATRIX_TYPE_NAMES = {
-    4: 'Complex Hermitian positive-definite',
-    -4: 'Complex Hermitian indefinite',
-    2: 'Real symmetric positive-definite',
-    -2: 'Real symmetric indefinite',
-    11: 'Real non-symmetric',
-    13: 'Complex non-symmetric',
-}
-
-
-def _mkl_matrix_type(dtype, solver_args):
-    if not solver_args['hermitian']:
-        return 13 if dtype == np.complex128 else 11
-    out = 4 if dtype == np.complex128 else 2
-    return out if solver_args['posdef'] else -out
-
-
-def mkl_splu(A, perm=None, verbose=False, **kwargs):
-    """
-    Returns the LU factorization of the sparse matrix A.
-
-    Parameters
-    ----------
-    A : csr_matrix
-        Sparse input matrix.
-    perm : ndarray (optional)
-        User defined matrix factorization permutation.
-    verbose : bool {False, True}
-        Report factorization details.
-
-    Returns
-    -------
-    lu : mkl_lu
-        Returns object containing LU factorization with a
-        solve method for solving with a given RHS vector.
-
-    """
-    if not sp.isspmatrix_csr(A):
-        raise TypeError('Input matrix must be in sparse CSR format.')
-
-    if A.shape[0] != A.shape[1]:
-        raise Exception('Input matrix must be square')
-
-    dim = A.shape[0]
-    solver_args = _default_solver_args()
-    if set(kwargs) - set(solver_args):
-        raise ValueError(
-            "Unknown keyword arguments pass to mkl_splu: {!r}"
-            .format(set(kwargs) - set(solver_args))
-        )
-    solver_args.update(kwargs)
-
-    # If hermitian, then take upper-triangle of matrix only
-    if solver_args['hermitian']:
-        B = sp.triu(A, format='csr')
-        A = B  # This gets around making a full copy of A in triu
-    is_complex = bool(A.dtype == np.complex128)
-    if not is_complex:
-        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
-    data_type = A.dtype
-
-    # Create pointer to internal memory
-    pt = np.zeros(64, dtype=int)
-    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
-
-    # Create pointers to sparse matrix arrays
-    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # Setup perm array
-    if perm is None:
-        perm = np.zeros(dim, dtype=np.int32)
-        has_perm = 0
-    else:
-        has_perm = 1
-    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # setup iparm
-    iparm = _pardiso_parameters(
-        solver_args['hermitian'],
-        has_perm,
-        solver_args['max_iter_refine'],
-        solver_args['scaling_vectors'],
-        solver_args['weighted_matching'],
-    )
-    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # setup call parameters
-    mtype = _mkl_matrix_type(data_type, solver_args)
-
-    if verbose:
-        print('Solver Initialization')
-        print('---------------------')
-        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
-        print('Input matrix shape:', A.shape)
-        print('Input matrix NNZ:  ', A.nnz)
-        print()
-
-    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
-    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
-    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-
-    error = np.zeros(1, dtype=np.int32)
-    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # Call solver
-    _factor_start = time.time()
-    pardiso(
-        np_pt,
-        byref(c_int(1)),
-        byref(c_int(1)),
-        byref(c_int(mtype)),
-        byref(c_int(12)),
-        byref(c_int(dim)),
-        data,
-        indptr,
-        indices,
-        np_perm,
-        byref(c_int(1)),
-        np_iparm,
-        byref(c_int(0)),
-        np_b,
-        np_x,
-        np_error,
-    )
-    _factor_time = time.time() - _factor_start
-    if error[0] != 0:
-        raise Exception(pardiso_error_msgs[str(error[0])])
-
-    if verbose:
-        print('Analysis and Factorization Stage')
-        print('--------------------------------')
-        print('Factorization time:       ', round(_factor_time, 4))
-        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
-        print('NNZ in LU factors:        ', iparm[17])
-        print()
-
-    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
-                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
-
-
-def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
-    """
-    Solves a sparse linear system of equations using the
-    Intel MKL Pardiso solver.
-
-    Parameters
-    ----------
-    A : csr_matrix
-        Sparse matrix.
-    b : ndarray or sparse matrix
-        The vector or matrix representing the right hand side of the equation.
-        If a vector, b.shape must be (n,) or (n, 1).
-    perm : ndarray (optional)
-        User defined matrix factorization permutation.
-
-    Returns
-    -------
-    x : ndarray or csr_matrix
-        The solution of the sparse linear equation.
-        If b is a vector, then x is a vector of size A.shape[1]
-        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
-
-    """
-    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
-    b_is_sparse = sp.isspmatrix(b)
-    b_shp = b.shape
-    if b_is_sparse and b.shape[1] == 1:
-        b = b.toarray()
-        b_is_sparse = False
-    elif b_is_sparse and b.shape[1] != 1:
-        nrhs = b.shape[1]
-        if lu._is_complex:
-            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
-        else:
-            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
-
-    # Do dense RHS solving
-    if not b_is_sparse:
-        x = lu.solve(b, verbose=verbose)
-    # Solve each RHS vec individually and convert to sparse
-    else:
-        data_segs = []
-        row_segs = []
-        col_segs = []
-        for j in range(nrhs):
-            bj = b[:, j].A.ravel()
-            xj = lu.solve(bj)
-            w = np.flatnonzero(xj)
-            segment_length = w.shape[0]
-            row_segs.append(w)
-            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
-            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
-        sp_data = np.concatenate(data_segs)
-        sp_row = np.concatenate(row_segs)
-        sp_col = np.concatenate(col_segs)
-        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
-
-    info = lu.info()
-    lu.delete()
-    return (x, info) if kwargs.get('return_info', False) else x
+import sys
+import numpy as np
+import scipy.sparse as sp
+from ctypes import c_int, byref
+from numpy.ctypeslib import ndpointer
+import time
+from qutip.settings import settings as qset
+
+# Load solver functions from mkl_lib
+pardiso = qset.mkl_lib.pardiso
+pardiso_delete = qset.mkl_lib.pardiso_handle_delete
+if sys.maxsize > 2**32: #Running 64-bit
+    pardiso_64 = qset.mkl_lib.pardiso_64
+    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
+
+
+def _pardiso_parameters(hermitian, has_perm,
+                        max_iter_refine,
+                        scaling_vectors,
+                        weighted_matching):
+    iparm = np.zeros(64, dtype=np.int32)
+    iparm[0] = 1  # Do not use default values
+    iparm[1] = 3  # Use openmp nested dissection
+    if has_perm:
+        iparm[4] = 1
+    iparm[7] = max_iter_refine  # Max number of iterative refinements
+    if hermitian:
+        iparm[9] = 8
+    else:
+        iparm[9] = 13
+    if not hermitian:
+        iparm[10] = int(scaling_vectors)
+        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
+    iparm[17] = -1
+    iparm[20] = 1
+    iparm[23] = 1  # Parallel factorization
+    iparm[26] = 0  # Check matrix structure
+    iparm[34] = 1  # Use zero-based indexing
+    return iparm
+
+
+# Set error messages
+pardiso_error_msgs = {
+    '-1': 'Input inconsistant',
+    '-2': 'Out of memory',
+    '-3': 'Reordering problem',
+    '-4':
+        'Zero pivot, numerical factorization or iterative refinement problem',
+    '-5': 'Unclassified internal error',
+    '-6': 'Reordering failed',
+    '-7': 'Diagonal matrix is singular',
+    '-8': '32-bit integer overflow',
+    '-9': 'Not enough memory for OOC',
+    '-10': 'Error opening OOC files',
+    '-11': 'Read/write error with OOC files',
+    '-12': 'Pardiso-64 called from 32-bit library',
+}
+
+
+def _default_solver_args():
+    return {
+        'hermitian': False,
+        'posdef': False,
+        'max_iter_refine': 10,
+        'scaling_vectors': True,
+        'weighted_matching': True,
+        'return_info': False,
+    }
+
+
+class mkl_lu:
+    """
+    Object pointing to LU factorization of a sparse matrix
+    generated by mkl_splu.
+
+    Methods
+    -------
+    solve(b, verbose=False)
+        Solve system of equations using given RHS vector 'b'.
+        Returns solution ndarray with same shape as input.
+
+    info()
+        Returns the statistics of the factorization and
+        solution in the lu.info attribute.
+
+    delete()
+        Deletes the allocated solver memory.
+
+    """
+    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
+                 indptr=None, indices=None, iparm=None, np_iparm=None,
+                 mtype=None, perm=None, np_perm=None, factor_time=None):
+        self._np_pt = np_pt
+        self._dim = dim
+        self._is_complex = is_complex
+        self._data = data
+        self._indptr = indptr
+        self._indices = indices
+        self._iparm = iparm
+        self._np_iparm = np_iparm
+        self._mtype = mtype
+        self._perm = perm
+        self._np_perm = np_perm
+        self._factor_time = factor_time
+        self._solve_time = None
+
+    def solve(self, b, verbose=None):
+        b_shp = b.shape
+        if b.ndim == 2 and b.shape[1] == 1:
+            b = b.ravel()
+            nrhs = 1
+        elif b.ndim == 2 and b.shape[1] != 1:
+            nrhs = b.shape[1]
+            b = b.ravel(order='F')
+        else:
+            b = b.ravel()
+            nrhs = 1
+
+        data_type = np.complex128 if self._is_complex else np.float64
+        if b.dtype != data_type:
+            b = b.astype(np.complex128, copy=False)
+
+        # Create solution array (x) and pointers to x and b
+        x = np.zeros(b.shape, dtype=data_type, order='C')
+        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+
+        error = np.zeros(1, dtype=np.int32)
+        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+        # Call solver
+        _solve_start = time.time()
+        pardiso(
+            self._np_pt,
+            byref(c_int(1)),
+            byref(c_int(1)),
+            byref(c_int(self._mtype)),
+            byref(c_int(33)),
+            byref(c_int(self._dim)),
+            self._data,
+            self._indptr,
+            self._indices,
+            self._np_perm,
+            byref(c_int(nrhs)),
+            self._np_iparm,
+            byref(c_int(0)),
+            np_b,
+            np_x,
+            np_error,
+        )
+        self._solve_time = time.time() - _solve_start
+        if error[0] != 0:
+            raise Exception(pardiso_error_msgs[str(error[0])])
+
+        if verbose:
+            print('Solution Stage')
+            print('--------------')
+            print('Solution time:                  ',
+                  round(self._solve_time, 4))
+            print('Solution memory (Mb):           ',
+                  round(self._iparm[16]/1024, 4))
+            print('Number of iterative refinements:',
+                  self._iparm[6])
+            print('Total memory (Mb):              ',
+                  round(sum(self._iparm[15:17])/1024, 4))
+            print()
+        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
+
+    def info(self):
+        info = {'FactorTime': self._factor_time,
+                'SolveTime': self._solve_time,
+                'Factormem': round(self._iparm[15]/1024, 4),
+                'Solvemem': round(self._iparm[16]/1024, 4),
+                'IterRefine': self._iparm[6]}
+        return info
+
+    def delete(self):
+        # Delete all data
+        error = np.zeros(1, dtype=np.int32)
+        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+        pardiso(
+            self._np_pt,
+            byref(c_int(1)),
+            byref(c_int(1)),
+            byref(c_int(self._mtype)),
+            byref(c_int(-1)),
+            byref(c_int(self._dim)),
+            self._data,
+            self._indptr,
+            self._indices,
+            self._np_perm,
+            byref(c_int(1)),
+            self._np_iparm,
+            byref(c_int(0)),
+            byref(c_int(0)),
+            byref(c_int(0)),
+            np_error,
+        )
+        if error[0] == -10:
+            raise Exception('Error freeing solver memory')
+
+
+_MATRIX_TYPE_NAMES = {
+    4: 'Complex Hermitian positive-definite',
+    -4: 'Complex Hermitian indefinite',
+    2: 'Real symmetric positive-definite',
+    -2: 'Real symmetric indefinite',
+    11: 'Real non-symmetric',
+    13: 'Complex non-symmetric',
+}
+
+
+def _mkl_matrix_type(dtype, solver_args):
+    if not solver_args['hermitian']:
+        return 13 if dtype == np.complex128 else 11
+    out = 4 if dtype == np.complex128 else 2
+    return out if solver_args['posdef'] else -out
+
+
+def mkl_splu(A, perm=None, verbose=False, **kwargs):
+    """
+    Returns the LU factorization of the sparse matrix A.
+
+    Parameters
+    ----------
+    A : csr_matrix
+        Sparse input matrix.
+    perm : ndarray (optional)
+        User defined matrix factorization permutation.
+    verbose : bool {False, True}
+        Report factorization details.
+
+    Returns
+    -------
+    lu : mkl_lu
+        Returns object containing LU factorization with a
+        solve method for solving with a given RHS vector.
+
+    """
+    if not sp.isspmatrix_csr(A):
+        raise TypeError('Input matrix must be in sparse CSR format.')
+
+    if A.shape[0] != A.shape[1]:
+        raise Exception('Input matrix must be square')
+
+    dim = A.shape[0]
+    solver_args = _default_solver_args()
+    if set(kwargs) - set(solver_args):
+        raise ValueError(
+            "Unknown keyword arguments pass to mkl_splu: {!r}"
+            .format(set(kwargs) - set(solver_args))
+        )
+    solver_args.update(kwargs)
+
+    # If hermitian, then take upper-triangle of matrix only
+    if solver_args['hermitian']:
+        B = sp.triu(A, format='csr')
+        A = B  # This gets around making a full copy of A in triu
+    is_complex = bool(A.dtype == np.complex128)
+    if not is_complex:
+        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
+    data_type = A.dtype
+
+    # Create pointer to internal memory
+    pt = np.zeros(64, dtype=int)
+    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
+
+    # Create pointers to sparse matrix arrays
+    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # Setup perm array
+    if perm is None:
+        perm = np.zeros(dim, dtype=np.int32)
+        has_perm = 0
+    else:
+        has_perm = 1
+    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # setup iparm
+    iparm = _pardiso_parameters(
+        solver_args['hermitian'],
+        has_perm,
+        solver_args['max_iter_refine'],
+        solver_args['scaling_vectors'],
+        solver_args['weighted_matching'],
+    )
+    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # setup call parameters
+    mtype = _mkl_matrix_type(data_type, solver_args)
+
+    if verbose:
+        print('Solver Initialization')
+        print('---------------------')
+        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
+        print('Input matrix shape:', A.shape)
+        print('Input matrix NNZ:  ', A.nnz)
+        print()
+
+    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
+    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
+    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+
+    error = np.zeros(1, dtype=np.int32)
+    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # Call solver
+    _factor_start = time.time()
+    pardiso(
+        np_pt,
+        byref(c_int(1)),
+        byref(c_int(1)),
+        byref(c_int(mtype)),
+        byref(c_int(12)),
+        byref(c_int(dim)),
+        data,
+        indptr,
+        indices,
+        np_perm,
+        byref(c_int(1)),
+        np_iparm,
+        byref(c_int(0)),
+        np_b,
+        np_x,
+        np_error,
+    )
+    _factor_time = time.time() - _factor_start
+    if error[0] != 0:
+        raise Exception(pardiso_error_msgs[str(error[0])])
+
+    if verbose:
+        print('Analysis and Factorization Stage')
+        print('--------------------------------')
+        print('Factorization time:       ', round(_factor_time, 4))
+        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
+        print('NNZ in LU factors:        ', iparm[17])
+        print()
+
+    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
+                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
+
+
+def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
+    """
+    Solves a sparse linear system of equations using the
+    Intel MKL Pardiso solver.
+
+    Parameters
+    ----------
+    A : csr_matrix
+        Sparse matrix.
+    b : ndarray or sparse matrix
+        The vector or matrix representing the right hand side of the equation.
+        If a vector, b.shape must be (n,) or (n, 1).
+    perm : ndarray (optional)
+        User defined matrix factorization permutation.
+
+    Returns
+    -------
+    x : ndarray or csr_matrix
+        The solution of the sparse linear equation.
+        If b is a vector, then x is a vector of size A.shape[1]
+        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
+
+    """
+    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
+    b_is_sparse = sp.isspmatrix(b)
+    b_shp = b.shape
+    if b_is_sparse and b.shape[1] == 1:
+        b = b.toarray()
+        b_is_sparse = False
+    elif b_is_sparse and b.shape[1] != 1:
+        nrhs = b.shape[1]
+        if lu._is_complex:
+            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
+        else:
+            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
+
+    # Do dense RHS solving
+    if not b_is_sparse:
+        x = lu.solve(b, verbose=verbose)
+    # Solve each RHS vec individually and convert to sparse
+    else:
+        data_segs = []
+        row_segs = []
+        col_segs = []
+        for j in range(nrhs):
+            bj = b[:, j].A.ravel()
+            xj = lu.solve(bj)
+            w = np.flatnonzero(xj)
+            segment_length = w.shape[0]
+            row_segs.append(w)
+            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
+            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
+        sp_data = np.concatenate(data_segs)
+        sp_row = np.concatenate(row_segs)
+        sp_col = np.concatenate(col_segs)
+        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
+
+    info = lu.info()
+    lu.delete()
+    return (x, info) if kwargs.get('return_info', False) else x
diff --git a/qutip/about.py b/qutip/about.py
index 0e5eb1662a..57e7322cab 100644
--- a/qutip/about.py
+++ b/qutip/about.py
@@ -1,75 +1,75 @@
-"""
-Command line output of information on QuTiP and dependencies.
-"""
-__all__ = ['about']
-
-import sys
-import os
-import platform
-import numpy
-import scipy
-import inspect
-import qutip
-from qutip.settings import _blas_info, settings
-
-
-def about():
-    """
-    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
-    and MatPlotLib.
-    """
-    print("")
-    print("QuTiP: Quantum Toolbox in Python")
-    print("================================")
-    print("Copyright (c) QuTiP team 2011 and later.")
-    print(
-        "Current admin team: Alexander Pitchford, "
-        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
-        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
-    )
-    print(
-        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
-        "Franco Nori and Will Zeng."
-    )
-    print("Original developers: R. J. Johansson & P. D. Nation.")
-    print("Previous lead developers: Chris Granade & A. Grimsmo.")
-    print("Currently developed through wide collaboration. "
-          "See https://github.com/qutip for details.")
-    print("")
-    print("QuTiP Version:      %s" % qutip.__version__)
-    print("Numpy Version:      %s" % numpy.__version__)
-    print("Scipy Version:      %s" % scipy.__version__)
-    try:
-        import Cython
-        cython_ver = Cython.__version__
-    except ImportError:
-        cython_ver = 'None'
-    print("Cython Version:     %s" % cython_ver)
-    try:
-        import matplotlib
-        matplotlib_ver = matplotlib.__version__
-    except ImportError:
-        matplotlib_ver = 'None'
-    print("Matplotlib Version: %s" % matplotlib_ver)
-    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
-    print("Number of CPUs:     %s" % settings.num_cpus)
-    print("BLAS Info:          %s" % _blas_info())
-    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
-    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
-    print("Platform Info:      %s (%s)" % (platform.system(),
-                                           platform.machine()))
-    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
-    print("Installation path:  %s" % qutip_install_path)
-
-    # citation
-    longbar = "=" * 80
-    cite_msg = "For your convenience a bibtex reference can be easily"
-    cite_msg += " generated using `qutip.cite()`"
-    print(longbar)
-    print("Please cite QuTiP in your publication.")
-    print(longbar)
-    print(cite_msg)
-
-
-if __name__ == "__main__":
-    about()
+"""
+Command line output of information on QuTiP and dependencies.
+"""
+__all__ = ['about']
+
+import sys
+import os
+import platform
+import numpy
+import scipy
+import inspect
+import qutip
+from qutip.settings import _blas_info, settings
+
+
+def about():
+    """
+    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
+    and MatPlotLib.
+    """
+    print("")
+    print("QuTiP: Quantum Toolbox in Python")
+    print("================================")
+    print("Copyright (c) QuTiP team 2011 and later.")
+    print(
+        "Current admin team: Alexander Pitchford, "
+        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
+        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
+    )
+    print(
+        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
+        "Franco Nori and Will Zeng."
+    )
+    print("Original developers: R. J. Johansson & P. D. Nation.")
+    print("Previous lead developers: Chris Granade & A. Grimsmo.")
+    print("Currently developed through wide collaboration. "
+          "See https://github.com/qutip for details.")
+    print("")
+    print("QuTiP Version:      %s" % qutip.__version__)
+    print("Numpy Version:      %s" % numpy.__version__)
+    print("Scipy Version:      %s" % scipy.__version__)
+    try:
+        import Cython
+        cython_ver = Cython.__version__
+    except ImportError:
+        cython_ver = 'None'
+    print("Cython Version:     %s" % cython_ver)
+    try:
+        import matplotlib
+        matplotlib_ver = matplotlib.__version__
+    except ImportError:
+        matplotlib_ver = 'None'
+    print("Matplotlib Version: %s" % matplotlib_ver)
+    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
+    print("Number of CPUs:     %s" % settings.num_cpus)
+    print("BLAS Info:          %s" % _blas_info())
+    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
+    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
+    print("Platform Info:      %s (%s)" % (platform.system(),
+                                           platform.machine()))
+    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
+    print("Installation path:  %s" % qutip_install_path)
+
+    # citation
+    longbar = "=" * 80
+    cite_msg = "For your convenience a bibtex reference can be easily"
+    cite_msg += " generated using `qutip.cite()`"
+    print(longbar)
+    print("Please cite QuTiP in your publication.")
+    print(longbar)
+    print(cite_msg)
+
+
+if __name__ == "__main__":
+    about()
diff --git a/qutip/bloch.py b/qutip/bloch.py
index 980502dd9d..e67ed5046b 100644
--- a/qutip/bloch.py
+++ b/qutip/bloch.py
@@ -1,928 +1,928 @@
-__all__ = ['Bloch']
-
-import os
-
-import numpy as np
-from numpy import (outer, cos, sin, ones)
-
-from packaging.version import parse as parse_version
-
-from . import Qobj, expect, sigmax, sigmay, sigmaz
-
-try:
-    import matplotlib
-    import matplotlib.pyplot as plt
-    from mpl_toolkits.mplot3d import Axes3D
-    from matplotlib.patches import FancyArrowPatch
-    from mpl_toolkits.mplot3d import proj3d
-
-    # Define a custom _axes3D function based on the matplotlib version.
-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
-        def _axes3D(fig, *args, **kwargs):
-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-            return fig.add_axes(ax)
-    else:
-        def _axes3D(*args, **kwargs):
-            return Axes3D(*args, **kwargs)
-
-    class Arrow3D(FancyArrowPatch):
-        def __init__(self, xs, ys, zs, *args, **kwargs):
-            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
-
-            self._verts3d = xs, ys, zs
-
-        def draw(self, renderer):
-            xs3d, ys3d, zs3d = self._verts3d
-            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
-
-            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
-            FancyArrowPatch.draw(self, renderer)
-
-        def do_3d_projection(self, renderer=None):
-            # only called by matplotlib >= 3.5
-            xs3d, ys3d, zs3d = self._verts3d
-            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
-            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
-            return np.min(zs)
-except ImportError:
-    pass
-
-try:
-    from IPython.display import display
-except ImportError:
-    pass
-
-
-class Bloch:
-    r"""
-    Class for plotting data on the Bloch sphere.  Valid data can be either
-    points, vectors, or Qobj objects.
-
-    Attributes
-    ----------
-    axes : matplotlib.axes.Axes
-        User supplied Matplotlib axes for Bloch sphere animation.
-    fig : matplotlib.figure.Figure
-        User supplied Matplotlib Figure instance for plotting Bloch sphere.
-    font_color : str, default 'black'
-        Color of font used for Bloch sphere labels.
-    font_size : int, default 20
-        Size of font used for Bloch sphere labels.
-    frame_alpha : float, default 0.1
-        Sets transparency of Bloch sphere frame.
-    frame_color : str, default 'gray'
-        Color of sphere wireframe.
-    frame_width : int, default 1
-        Width of wireframe.
-    point_color : list, default ["b", "r", "g", "#CC6600"]
-        List of colors for Bloch sphere point markers to cycle through, i.e.
-        by default, points 0 and 4 will both be blue ('b').
-    point_marker : list, default ["o", "s", "d", "^"]
-        List of point marker shapes to cycle through.
-    point_size : list, default [25, 32, 35, 45]
-        List of point marker sizes. Note, not all point markers look the same
-        size when plotted!
-    sphere_alpha : float, default 0.2
-        Transparency of Bloch sphere itself.
-    sphere_color : str, default '#FFDDDD'
-        Color of Bloch sphere.
-    figsize : list, default [7, 7]
-        Figure size of Bloch sphere plot.  Best to have both numbers the same;
-        otherwise you will have a Bloch sphere that looks like a football.
-    vector_color : list, ["g", "#CC6600", "b", "r"]
-        List of vector colors to cycle through.
-    vector_width : int, default 5
-        Width of displayed vectors.
-    vector_style : str, default '-\|>'
-        Vector arrowhead style (from matplotlib's arrow style).
-    vector_mutation : int, default 20
-        Width of vectors arrowhead.
-    view : list, default [-60, 30]
-        Azimuthal and Elevation viewing angles.
-    xlabel : list, default ["$x$", ""]
-        List of strings corresponding to +x and -x axes labels, respectively.
-    xlpos : list, default [1.1, -1.1]
-        Positions of +x and -x labels respectively.
-    ylabel : list, default ["$y$", ""]
-        List of strings corresponding to +y and -y axes labels, respectively.
-    ylpos : list, default [1.2, -1.2]
-        Positions of +y and -y labels respectively.
-    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
-        List of strings corresponding to +z and -z axes labels, respectively.
-    zlpos : list, default [1.2, -1.2]
-        Positions of +z and -z labels respectively.
-    """
-    def __init__(self, fig=None, axes=None, view=None, figsize=None,
-                 background=False):
-        # Figure and axes
-        self.fig = fig
-        self._ext_fig = fig is not None
-        self.axes = axes
-        # Background axes, default = False
-        self.background = background
-        # The size of the figure in inches, default = [5,5].
-        self.figsize = figsize if figsize else [5, 5]
-        # Azimuthal and Elvation viewing angles, default = [-60,30].
-        self.view = view if view else [-60, 30]
-        # Color of Bloch sphere, default = #FFDDDD
-        self.sphere_color = '#FFDDDD'
-        # Transparency of Bloch sphere, default = 0.2
-        self.sphere_alpha = 0.2
-        # Color of wireframe, default = 'gray'
-        self.frame_color = 'gray'
-        # Width of wireframe, default = 1
-        self.frame_width = 1
-        # Transparency of wireframe, default = 0.2
-        self.frame_alpha = 0.2
-        # Labels for x-axis (in LaTex), default = ['$x$', '']
-        self.xlabel = ['$x$', '']
-        # Position of x-axis labels, default = [1.2, -1.2]
-        self.xlpos = [1.2, -1.2]
-        # Labels for y-axis (in LaTex), default = ['$y$', '']
-        self.ylabel = ['$y$', '']
-        # Position of y-axis labels, default = [1.1, -1.1]
-        self.ylpos = [1.2, -1.2]
-        # Labels for z-axis (in LaTex),
-        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
-        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
-        # Position of z-axis labels, default = [1.2, -1.2]
-        self.zlpos = [1.2, -1.2]
-        # ---font options---
-        # Color of fonts, default = 'black'
-        self.font_color = 'black'
-        # Size of fonts, default = 20
-        self.font_size = 20
-
-        # ---vector options---
-        # List of colors for Bloch vectors, default = ['b','g','r','y']
-        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
-        # List that stores the display colors for each vector
-        self.vector_color = []
-        #: Width of Bloch vectors, default = 5
-        self.vector_width = 3
-        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
-        self.vector_style = '-|>'
-        #: Sets the width of the vectors arrowhead
-        self.vector_mutation = 20
-
-        # ---point options---
-        # List of colors for Bloch point markers, default = ['b','g','r','y']
-        self.point_default_color = ['b', 'r', 'g', '#CC6600']
-        # List that stores the display colors for each set of points
-        self.point_color = []
-        # Size of point markers, default = 25
-        self.point_size = [25, 32, 35, 45]
-        # Shape of point markers, default = ['o','^','d','s']
-        self.point_marker = ['o', 's', 'd', '^']
-
-        # ---data lists---
-        # Data for point markers
-        self.points = []
-        # Data for Bloch vectors
-        self.vectors = []
-        # Transparency of vectors, alpha value from 0 to 1
-        self.vector_alpha = []
-        # Data for annotations
-        self.annotations = []
-        # Number of times sphere has been saved
-        self.savenum = 0
-        # Style of points, 'm' for multiple colors, 's' for single color
-        self.point_style = []
-        # Transparency of points, alpha value from 0 to 1
-        self.point_alpha = []
-        # Data for line segment
-        self._lines = []
-        # Data for arcs and arc style
-        self._arcs = []
-
-    def set_label_convention(self, convention):
-        """Set x, y and z labels according to one of conventions.
-
-        Parameters
-        ----------
-        convention : string
-            One of the following:
-
-            - "original"
-            - "xyz"
-            - "sx sy sz"
-            - "01"
-            - "polarization jones"
-            - "polarization jones letters"
-              see also: https://en.wikipedia.org/wiki/Jones_calculus
-            - "polarization stokes"
-              see also: https://en.wikipedia.org/wiki/Stokes_parameters
-        """
-        ketex = "$\\left.|%s\\right\\rangle$"
-        # \left.| is on purpose, so that every ket has the same size
-
-        if convention == "original":
-            self.xlabel = ['$x$', '']
-            self.ylabel = ['$y$', '']
-            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
-        elif convention == "xyz":
-            self.xlabel = ['$x$', '']
-            self.ylabel = ['$y$', '']
-            self.zlabel = ['$z$', '']
-        elif convention == "sx sy sz":
-            self.xlabel = ['$s_x$', '']
-            self.ylabel = ['$s_y$', '']
-            self.zlabel = ['$s_z$', '']
-        elif convention == "01":
-            self.xlabel = ['', '']
-            self.ylabel = ['', '']
-            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
-        elif convention == "polarization jones":
-            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
-                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
-            self.ylabel = [ketex % "\\circlearrowleft", ketex %
-                           "\\circlearrowright"]
-            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
-        elif convention == "polarization jones letters":
-            self.xlabel = [ketex % "D", ketex % "A"]
-            self.ylabel = [ketex % "L", ketex % "R"]
-            self.zlabel = [ketex % "H", ketex % "V"]
-        elif convention == "polarization stokes":
-            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
-                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
-            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
-            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
-        else:
-            raise Exception("No such convention.")
-
-    def __str__(self):
-        s = ""
-        s += "Bloch data:\n"
-        s += "-----------\n"
-        s += "Number of points:  " + str(len(self.points)) + "\n"
-        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
-        s += "\n"
-        s += "Bloch sphere properties:\n"
-        s += "------------------------\n"
-        s += "font_color:      " + str(self.font_color) + "\n"
-        s += "font_size:       " + str(self.font_size) + "\n"
-        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
-        s += "frame_color:     " + str(self.frame_color) + "\n"
-        s += "frame_width:     " + str(self.frame_width) + "\n"
-        s += "point_default_color:" + str(self.point_default_color) + "\n"
-        s += "point_marker:    " + str(self.point_marker) + "\n"
-        s += "point_size:      " + str(self.point_size) + "\n"
-        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
-        s += "sphere_color:    " + str(self.sphere_color) + "\n"
-        s += "figsize:         " + str(self.figsize) + "\n"
-        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
-        s += "vector_width:    " + str(self.vector_width) + "\n"
-        s += "vector_style:    " + str(self.vector_style) + "\n"
-        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
-        s += "view:            " + str(self.view) + "\n"
-        s += "xlabel:          " + str(self.xlabel) + "\n"
-        s += "xlpos:           " + str(self.xlpos) + "\n"
-        s += "ylabel:          " + str(self.ylabel) + "\n"
-        s += "ylpos:           " + str(self.ylpos) + "\n"
-        s += "zlabel:          " + str(self.zlabel) + "\n"
-        s += "zlpos:           " + str(self.zlpos) + "\n"
-        return s
-
-    def _repr_png_(self):
-        from IPython.core.pylabtools import print_figure
-        self.render()
-        fig_data = print_figure(self.fig, 'png')
-        plt.close(self.fig)
-        return fig_data
-
-    def _repr_svg_(self):
-        from IPython.core.pylabtools import print_figure
-        self.render()
-        fig_data = print_figure(self.fig, 'svg')
-        plt.close(self.fig)
-        return fig_data
-
-    def clear(self):
-        """Resets Bloch sphere data sets to empty.
-        """
-        self.points = []
-        self.vectors = []
-        self.point_style = []
-        self.point_alpha = []
-        self.vector_alpha = []
-        self.annotations = []
-        self.vector_color = []
-        self.point_color = []
-        self._lines = []
-        self._arcs = []
-
-    def add_points(self, points, meth='s', colors=None, alpha=1.0):
-        """Add a list of data points to bloch sphere.
-
-        Parameters
-        ----------
-        points : array_like
-            Collection of data points.
-
-        meth : {'s', 'm', 'l'}
-            Type of points to plot, use 'm' for multicolored, 'l' for points
-            connected with a line.
-
-        colors : array_like
-            Optional array with colors for the points.
-            A single color for meth 's', and list of colors for meth 'm'
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        .. note::
-
-           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
-           to ``0.75`` and there was no way to alter it.
-           When the ``alpha`` parameter was added in QuTiP 4.7, the default
-           became ``alpha=1.0`` for values of ``meth``.
-        """
-
-        points = np.asarray(points)
-
-        if points.ndim == 1:
-            points = points[:, np.newaxis]
-
-        if points.ndim != 2 or points.shape[0] != 3:
-            raise ValueError("The included points are not valid. Points must "
-                             "be equivalent to a 2D array where the first "
-                             "index represents the x,y,z values and the "
-                             "second index iterates over the points.")
-
-        if meth not in ['s', 'm', 'l']:
-            raise ValueError(f"The value for meth = {meth} is not valid."
-                             " Please use 's', 'l' or 'm'.")
-
-        if meth == 's' and points.shape[1] == 1:
-            points = np.append(points[:, :1], points, axis=1)
-
-        self.point_style.append(meth)
-        self.points.append(points)
-        self.point_alpha.append(alpha)
-        self.point_color.append(colors)
-
-    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
-        """Add a state vector Qobj to Bloch sphere.
-
-        Parameters
-        ----------
-        state : Qobj
-            Input state vector.
-
-        kind : {'vector', 'point'}
-            Type of object to plot.
-
-        colors : array_like
-            Optional array with colors for the states.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-        """
-        if isinstance(state, Qobj):
-            state = [state]
-        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
-            colors = [colors]
-
-        for k, st in enumerate(state):
-            vec = [expect(sigmax(), st),
-                   expect(sigmay(), st),
-                   expect(sigmaz(), st)]
-
-            if kind == 'vector':
-                if colors is not None:
-                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
-                else:
-                    self.add_vectors(vec)
-            elif kind == 'point':
-                if colors is not None:
-                    self.add_points(vec, colors=colors[k], alpha=alpha)
-                else:
-                    self.add_points(vec)
-
-    def add_vectors(self, vectors, colors=None, alpha=1.0):
-        """Add a list of vectors to Bloch sphere.
-
-        Parameters
-        ----------
-        vectors : array_like
-            Array with vectors of unit length or smaller.
-
-        colors : array_like
-            Optional array with colors for the vectors.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        """
-        vectors = np.asarray(vectors)
-
-        if vectors.ndim == 1:
-            vectors = vectors[np.newaxis, :]
-
-        if vectors.ndim != 2 or vectors.shape[1] != 3:
-            raise ValueError(
-                "The included vectors are not valid. Vectors must "
-                "be equivalent to a 2D array where the first "
-                "index represents the iteration over the vectors and the "
-                "second index represents the position in 3D of vector head.")
-
-        n_vectors = vectors.shape[0]
-        if colors is None:
-            colors = np.array([None] * n_vectors)
-        else:
-            colors = np.asarray(colors)
-
-        if colors.ndim != 1 or colors.size != n_vectors:
-            raise ValueError("The included colors are not valid. colors must "
-                             "be equivalent to a 1D array with the same "
-                             "size as the number of vectors. ")
-
-        for k, vec in enumerate(vectors):
-            self.vectors.append(vec)
-            self.vector_alpha.append(alpha)
-            self.vector_color.append(colors[k])
-
-    def add_annotation(self, state_or_vector, text, **kwargs):
-        """
-        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
-        state or a vector.
-
-        Parameters
-        ----------
-        state_or_vector : Qobj/array/list/tuple
-            Position for the annotaion.
-            Qobj of a qubit or a vector of 3 elements.
-
-        text : str
-            Annotation text.
-            You can use LaTeX, but remember to use raw string
-            e.g. r"$\\langle x \\rangle$"
-            or escape backslashes
-            e.g. "$\\\\langle x \\\\rangle$".
-
-        kwargs :
-            Options as for mplot3d.axes3d.text, including:
-            fontsize, color, horizontalalignment, verticalalignment.
-
-        """
-        if isinstance(state_or_vector, Qobj):
-            vec = [expect(sigmax(), state_or_vector),
-                   expect(sigmay(), state_or_vector),
-                   expect(sigmaz(), state_or_vector)]
-        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
-                and len(state_or_vector) == 3:
-            vec = state_or_vector
-        else:
-            raise Exception("Position needs to be specified by a qubit " +
-                            "state or a 3D vector.")
-        self.annotations.append({'position': vec,
-                                 'text': text,
-                                 'opts': kwargs})
-
-    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
-        """Adds an arc between two points on a sphere. The arc is set to be
-        blue solid curve by default.
-
-        The start and end points must be on the same sphere (i.e. have the
-        same radius) but need not be on the unit sphere.
-
-        Parameters
-        ----------
-        start : Qobj or array-like
-            Array with cartesian coordinates of the first point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        end : Qobj or array-like
-            Array with cartesian coordinates of the second point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        fmt : str, default: "b"
-            A matplotlib format string for rendering the arc.
-        steps : int, default: None
-            The number of segments to use when rendering the arc. The default
-            uses 100 steps times the distance between the start and end points,
-            with a minimum of 2 steps.
-        **kwargs : dict
-            Additional parameters to pass to the matplotlib .plot function
-            when rendering this arc.
-        """
-        if isinstance(start, Qobj):
-            pt1 = [
-                expect(sigmax(), start),
-                expect(sigmay(), start),
-                expect(sigmaz(), start),
-            ]
-        else:
-            pt1 = start
-
-        if isinstance(end, Qobj):
-            pt2 = [
-                expect(sigmax(), end),
-                expect(sigmay(), end),
-                expect(sigmaz(), end),
-            ]
-        else:
-            pt2 = end
-
-        pt1 = np.asarray(pt1)
-        pt2 = np.asarray(pt2)
-
-        len1 = np.linalg.norm(pt1)
-        len2 = np.linalg.norm(pt2)
-        if len1 < 1e-12 or len2 < 1e-12:
-            raise ValueError('Polar and azimuthal angles undefined at origin.')
-        elif abs(len1 - len2) > 1e-12:
-            raise ValueError("Points not on the same sphere.")
-        elif (pt1 == pt2).all():
-            raise ValueError(
-                "Start and end represent the same point. No arc can be formed."
-            )
-        elif (pt1 == -pt2).all():
-            raise ValueError(
-                "Start and end are diagonally opposite, no unique arc is"
-                " possible."
-            )
-
-        if steps is None:
-            steps = int(np.linalg.norm(pt1 - pt2) * 100)
-            steps = max(2, steps)
-        t = np.linspace(0, 1, steps)
-        # All the points in this line are contained in the plane defined
-        # by pt1, pt2 and the origin.
-        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
-        # Normalize all the points in the line so that are distance len1 from
-        # the origin.
-        arc = line * len1 / np.linalg.norm(line, axis=0)
-        self._arcs.append([arc, fmt, kwargs])
-
-    def add_line(self, start, end, fmt="k", **kwargs):
-        """Adds a line segment connecting two points on the bloch sphere.
-
-        The line segment is set to be a black solid line by default.
-
-        Parameters
-        ----------
-        start : Qobj or array-like
-            Array with cartesian coordinates of the first point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        end : Qobj or array-like
-            Array with cartesian coordinates of the second point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        fmt : str, default: "k"
-            A matplotlib format string for rendering the line.
-        **kwargs : dict
-            Additional parameters to pass to the matplotlib .plot function
-            when rendering this line.
-        """
-        if isinstance(start, Qobj):
-            pt1 = [
-                expect(sigmax(), start),
-                expect(sigmay(), start),
-                expect(sigmaz(), start),
-            ]
-        else:
-            pt1 = start
-
-        if isinstance(end, Qobj):
-            pt2 = [
-                expect(sigmax(), end),
-                expect(sigmay(), end),
-                expect(sigmaz(), end),
-            ]
-        else:
-            pt2 = end
-
-        pt1 = np.asarray(pt1)
-        pt2 = np.asarray(pt2)
-
-        x = [pt1[1], pt2[1]]
-        y = [-pt1[0], -pt2[0]]
-        z = [pt1[2], pt2[2]]
-        v = [x, y, z]
-        self._lines.append([v, fmt, kwargs])
-
-    def make_sphere(self):
-        """
-        Plots Bloch sphere and data sets.
-        """
-        self.render()
-
-    def run_from_ipython(self):
-        try:
-            __IPYTHON__
-            return True
-        except NameError:
-            return False
-
-    def _is_inline_backend(self):
-        backend = matplotlib.get_backend()
-        return backend == "module://matplotlib_inline.backend_inline"
-
-    def render(self):
-        """
-        Render the Bloch sphere and its data sets in on given figure and axes.
-        """
-        if not self._ext_fig and not self._is_inline_backend():
-            # If no external figure was supplied, we check to see if the
-            # figure we created in a previous call to .render() has been
-            # closed, and re-create if has been. This has the unfortunate
-            # side effect of losing any modifications made to the axes or
-            # figure, but the alternative is to crash the matplotlib backend.
-            #
-            # The inline backend used by, e.g. jupyter notebooks, is happy to
-            # use closed figures so we leave those figures intact.
-            if (
-                self.fig is not None and
-                not plt.fignum_exists(self.fig.number)
-            ):
-                self.fig = None
-                self.axes = None
-
-        if self.fig is None:
-            self.fig = plt.figure(figsize=self.figsize)
-            if self._is_inline_backend():
-                # We immediately close the inline figure do avoid displaying
-                # the figure twice when .show() calls display.
-                plt.close(self.fig)
-
-        if self.axes is None:
-            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
-
-        # Clearing the axes is horrifically slow and loses a lot of the
-        # axes state, but matplotlib doesn't seem to provide a better way
-        # to redraw Axes3D. :/
-        self.axes.clear()
-        self.axes.grid(False)
-        if self.background:
-            self.axes.set_xlim3d(-1.3, 1.3)
-            self.axes.set_ylim3d(-1.3, 1.3)
-            self.axes.set_zlim3d(-1.3, 1.3)
-        else:
-            self.axes.set_axis_off()
-            self.axes.set_xlim3d(-0.7, 0.7)
-            self.axes.set_ylim3d(-0.7, 0.7)
-            self.axes.set_zlim3d(-0.7, 0.7)
-        # Manually set aspect ratio to fit a square bounding box.
-        # Matplotlib did this stretching for < 3.3.0, but not above.
-        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
-            self.axes.set_box_aspect((1, 1, 1))
-        if not self.background:
-            self.plot_axes()
-
-        self.plot_back()
-        self.plot_points()
-        self.plot_vectors()
-        self.plot_lines()
-        self.plot_arcs()
-        self.plot_front()
-        self.plot_axes_labels()
-        self.plot_annotations()
-        # Trigger an update of the Bloch sphere if it is already shown:
-        self.fig.canvas.draw()
-
-    def plot_back(self):
-        # back half of sphere
-        u = np.linspace(0, np.pi, 25)
-        v = np.linspace(0, np.pi, 25)
-        x = outer(cos(u), sin(v))
-        y = outer(sin(u), sin(v))
-        z = outer(ones(np.size(u)), cos(v))
-        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
-                               color=self.sphere_color, linewidth=0,
-                               alpha=self.sphere_alpha)
-        # wireframe
-        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
-                                 color=self.frame_color,
-                                 alpha=self.frame_alpha)
-        # equator
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
-                       lw=self.frame_width, color=self.frame_color)
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
-                       lw=self.frame_width, color=self.frame_color)
-
-    def plot_front(self):
-        # front half of sphere
-        u = np.linspace(-np.pi, 0, 25)
-        v = np.linspace(0, np.pi, 25)
-        x = outer(cos(u), sin(v))
-        y = outer(sin(u), sin(v))
-        z = outer(ones(np.size(u)), cos(v))
-        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
-                               color=self.sphere_color, linewidth=0,
-                               alpha=self.sphere_alpha)
-        # wireframe
-        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
-                                 color=self.frame_color,
-                                 alpha=self.frame_alpha)
-        # equator
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
-                       zs=0, zdir='z', lw=self.frame_width,
-                       color=self.frame_color)
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
-                       zs=0, zdir='x', lw=self.frame_width,
-                       color=self.frame_color)
-
-    def plot_axes(self):
-        # axes
-        span = np.linspace(-1.0, 1.0, 2)
-        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
-                       lw=self.frame_width, color=self.frame_color)
-        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
-                       lw=self.frame_width, color=self.frame_color)
-        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
-                       lw=self.frame_width, color=self.frame_color)
-
-    def plot_axes_labels(self):
-        # axes labels
-        opts = {'fontsize': self.font_size,
-                'color': self.font_color,
-                'horizontalalignment': 'center',
-                'verticalalignment': 'center'}
-        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
-        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
-
-        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
-        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
-
-        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
-        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
-
-        for a in (self.axes.xaxis.get_ticklines() +
-                  self.axes.xaxis.get_ticklabels()):
-            a.set_visible(False)
-        for a in (self.axes.yaxis.get_ticklines() +
-                  self.axes.yaxis.get_ticklabels()):
-            a.set_visible(False)
-        for a in (self.axes.zaxis.get_ticklines() +
-                  self.axes.zaxis.get_ticklabels()):
-            a.set_visible(False)
-
-    def plot_vectors(self):
-        # -X and Y data are switched for plotting purposes
-        for k, vec in enumerate(self.vectors):
-
-            xs3d = vec[1] * np.array([0, 1])
-            ys3d = -vec[0] * np.array([0, 1])
-            zs3d = vec[2] * np.array([0, 1])
-
-            alpha = self.vector_alpha[k]
-            color = self.vector_color[k]
-            if color is None:
-                idx = k % len(self.vector_default_color)
-                color = self.vector_default_color[idx]
-
-            # decorated style, with arrow heads
-            a = Arrow3D(xs3d, ys3d, zs3d,
-                        mutation_scale=self.vector_mutation,
-                        lw=self.vector_width,
-                        arrowstyle=self.vector_style,
-                        color=color, alpha=alpha)
-
-            self.axes.add_artist(a)
-
-    def plot_points(self):
-        # -X and Y data are switched for plotting purposes
-        for k, points in enumerate(self.points):
-            points = np.asarray(points)
-            num_points = points.shape[1]
-
-            dist = np.linalg.norm(points, axis=0)
-            if not np.allclose(dist, dist[0], rtol=1e-12):
-                indperm = np.argsort(dist)
-                points = points[:, indperm]
-            else:
-                indperm = np.arange(num_points)
-
-            s = self.point_size[np.mod(k, len(self.point_size))]
-            marker = self.point_marker[np.mod(k, len(self.point_marker))]
-            style = self.point_style[k]
-            if self.point_color[k] is not None:
-                color = self.point_color[k]
-            elif self.point_style[k] in ['s', 'l']:
-                color = self.point_default_color[
-                    k % len(self.point_default_color)
-                ]
-            elif self.point_style[k] == 'm':
-                length = np.ceil(num_points/len(self.point_default_color))
-                color = np.tile(self.point_default_color, length.astype(int))
-                color = color[indperm]
-
-            if self.point_style[k] in ['s', 'm']:
-                self.axes.scatter(np.real(points[1]),
-                                  -np.real(points[0]),
-                                  np.real(points[2]),
-                                  s=s,
-                                  marker=marker,
-                                  color=color,
-                                  alpha=self.point_alpha[k],
-                                  edgecolor=None,
-                                  zdir='z',
-                                  )
-
-            elif self.point_style[k] == 'l':
-                self.axes.plot(np.real(points[1]),
-                               -np.real(points[0]),
-                               np.real(points[2]),
-                               color=color,
-                               alpha=self.point_alpha[k],
-                               zdir='z',
-                               )
-
-    def plot_annotations(self):
-        # -X and Y data are switched for plotting purposes
-        for annotation in self.annotations:
-            vec = annotation['position']
-            opts = {'fontsize': self.font_size,
-                    'color': self.font_color,
-                    'horizontalalignment': 'center',
-                    'verticalalignment': 'center'}
-            opts.update(annotation['opts'])
-            self.axes.text(vec[1], -vec[0], vec[2],
-                           annotation['text'], **opts)
-
-    def plot_lines(self):
-        for line, fmt, kw in self._lines:
-            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
-
-    def plot_arcs(self):
-        for arc, fmt, kw in self._arcs:
-            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
-
-    def show(self):
-        """
-        Display Bloch sphere and corresponding data sets.
-
-        Notes
-        -----
-
-        When using inline plotting in Jupyter notebooks, any figure created
-        in a notebook cell is displayed after the cell executes. Thus if you
-        create a figure yourself and use it create a Bloch sphere with
-        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
-        cell, then the figure will be displayed twice. If you do create your
-        own figure, the simplest solution to this is to not call ``.show()``
-        in the cell you create the figure in.
-        """
-        self.render()
-        if self.run_from_ipython():
-            display(self.fig)
-        else:
-            self.fig.show()
-
-    def save(self, name=None, format='png', dirc=None, dpin=None):
-        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
-
-        Parameters
-        ----------
-
-        name : str
-            Name of saved image. Must include path and format as well.
-            i.e. '/Users/Paul/Desktop/bloch.png'
-            This overrides the 'format' and 'dirc' arguments.
-        format : str
-            Format of output image.
-        dirc : str
-            Directory for output images. Defaults to current working directory.
-        dpin : int
-            Resolution in dots per inch.
-
-        Returns
-        -------
-        File containing plot of Bloch sphere.
-
-        """
-        self.render()
-        # Conditional variable for first argument to savefig
-        # that is set in subsequent if-elses
-        complete_path = ""
-        if dirc:
-            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
-                os.makedirs(os.getcwd() + "/" + str(dirc))
-        if name is None:
-            if dirc:
-                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
-                                + str(self.savenum) + '.' + format
-            else:
-                complete_path = os.getcwd() + '/bloch_' + \
-                                str(self.savenum) + '.' + format
-        else:
-            complete_path = name
-
-        if dpin:
-            self.fig.savefig(complete_path, dpi=dpin)
-        else:
-            self.fig.savefig(complete_path)
-        self.savenum += 1
-        if self.fig:
-            plt.close(self.fig)
-
-
-def _hide_tick_lines_and_labels(axis):
-    '''
-    Set visible property of ticklines and ticklabels of an axis to False
-    '''
-    for a in axis.get_ticklines() + axis.get_ticklabels():
-        a.set_visible(False)
+__all__ = ['Bloch']
+
+import os
+
+import numpy as np
+from numpy import (outer, cos, sin, ones)
+
+from packaging.version import parse as parse_version
+
+from . import Qobj, expect, sigmax, sigmay, sigmaz
+
+try:
+    import matplotlib
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d import Axes3D
+    from matplotlib.patches import FancyArrowPatch
+    from mpl_toolkits.mplot3d import proj3d
+
+    # Define a custom _axes3D function based on the matplotlib version.
+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
+        def _axes3D(fig, *args, **kwargs):
+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+            return fig.add_axes(ax)
+    else:
+        def _axes3D(*args, **kwargs):
+            return Axes3D(*args, **kwargs)
+
+    class Arrow3D(FancyArrowPatch):
+        def __init__(self, xs, ys, zs, *args, **kwargs):
+            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
+
+            self._verts3d = xs, ys, zs
+
+        def draw(self, renderer):
+            xs3d, ys3d, zs3d = self._verts3d
+            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+
+            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+            FancyArrowPatch.draw(self, renderer)
+
+        def do_3d_projection(self, renderer=None):
+            # only called by matplotlib >= 3.5
+            xs3d, ys3d, zs3d = self._verts3d
+            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+            return np.min(zs)
+except ImportError:
+    pass
+
+try:
+    from IPython.display import display
+except ImportError:
+    pass
+
+
+class Bloch:
+    r"""
+    Class for plotting data on the Bloch sphere.  Valid data can be either
+    points, vectors, or Qobj objects.
+
+    Attributes
+    ----------
+    axes : matplotlib.axes.Axes
+        User supplied Matplotlib axes for Bloch sphere animation.
+    fig : matplotlib.figure.Figure
+        User supplied Matplotlib Figure instance for plotting Bloch sphere.
+    font_color : str, default 'black'
+        Color of font used for Bloch sphere labels.
+    font_size : int, default 20
+        Size of font used for Bloch sphere labels.
+    frame_alpha : float, default 0.1
+        Sets transparency of Bloch sphere frame.
+    frame_color : str, default 'gray'
+        Color of sphere wireframe.
+    frame_width : int, default 1
+        Width of wireframe.
+    point_color : list, default ["b", "r", "g", "#CC6600"]
+        List of colors for Bloch sphere point markers to cycle through, i.e.
+        by default, points 0 and 4 will both be blue ('b').
+    point_marker : list, default ["o", "s", "d", "^"]
+        List of point marker shapes to cycle through.
+    point_size : list, default [25, 32, 35, 45]
+        List of point marker sizes. Note, not all point markers look the same
+        size when plotted!
+    sphere_alpha : float, default 0.2
+        Transparency of Bloch sphere itself.
+    sphere_color : str, default '#FFDDDD'
+        Color of Bloch sphere.
+    figsize : list, default [7, 7]
+        Figure size of Bloch sphere plot.  Best to have both numbers the same;
+        otherwise you will have a Bloch sphere that looks like a football.
+    vector_color : list, ["g", "#CC6600", "b", "r"]
+        List of vector colors to cycle through.
+    vector_width : int, default 5
+        Width of displayed vectors.
+    vector_style : str, default '-\|>'
+        Vector arrowhead style (from matplotlib's arrow style).
+    vector_mutation : int, default 20
+        Width of vectors arrowhead.
+    view : list, default [-60, 30]
+        Azimuthal and Elevation viewing angles.
+    xlabel : list, default ["$x$", ""]
+        List of strings corresponding to +x and -x axes labels, respectively.
+    xlpos : list, default [1.1, -1.1]
+        Positions of +x and -x labels respectively.
+    ylabel : list, default ["$y$", ""]
+        List of strings corresponding to +y and -y axes labels, respectively.
+    ylpos : list, default [1.2, -1.2]
+        Positions of +y and -y labels respectively.
+    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
+        List of strings corresponding to +z and -z axes labels, respectively.
+    zlpos : list, default [1.2, -1.2]
+        Positions of +z and -z labels respectively.
+    """
+    def __init__(self, fig=None, axes=None, view=None, figsize=None,
+                 background=False):
+        # Figure and axes
+        self.fig = fig
+        self._ext_fig = fig is not None
+        self.axes = axes
+        # Background axes, default = False
+        self.background = background
+        # The size of the figure in inches, default = [5,5].
+        self.figsize = figsize if figsize else [5, 5]
+        # Azimuthal and Elvation viewing angles, default = [-60,30].
+        self.view = view if view else [-60, 30]
+        # Color of Bloch sphere, default = #FFDDDD
+        self.sphere_color = '#FFDDDD'
+        # Transparency of Bloch sphere, default = 0.2
+        self.sphere_alpha = 0.2
+        # Color of wireframe, default = 'gray'
+        self.frame_color = 'gray'
+        # Width of wireframe, default = 1
+        self.frame_width = 1
+        # Transparency of wireframe, default = 0.2
+        self.frame_alpha = 0.2
+        # Labels for x-axis (in LaTex), default = ['$x$', '']
+        self.xlabel = ['$x$', '']
+        # Position of x-axis labels, default = [1.2, -1.2]
+        self.xlpos = [1.2, -1.2]
+        # Labels for y-axis (in LaTex), default = ['$y$', '']
+        self.ylabel = ['$y$', '']
+        # Position of y-axis labels, default = [1.1, -1.1]
+        self.ylpos = [1.2, -1.2]
+        # Labels for z-axis (in LaTex),
+        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
+        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
+        # Position of z-axis labels, default = [1.2, -1.2]
+        self.zlpos = [1.2, -1.2]
+        # ---font options---
+        # Color of fonts, default = 'black'
+        self.font_color = 'black'
+        # Size of fonts, default = 20
+        self.font_size = 20
+
+        # ---vector options---
+        # List of colors for Bloch vectors, default = ['b','g','r','y']
+        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
+        # List that stores the display colors for each vector
+        self.vector_color = []
+        #: Width of Bloch vectors, default = 5
+        self.vector_width = 3
+        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
+        self.vector_style = '-|>'
+        #: Sets the width of the vectors arrowhead
+        self.vector_mutation = 20
+
+        # ---point options---
+        # List of colors for Bloch point markers, default = ['b','g','r','y']
+        self.point_default_color = ['b', 'r', 'g', '#CC6600']
+        # List that stores the display colors for each set of points
+        self.point_color = []
+        # Size of point markers, default = 25
+        self.point_size = [25, 32, 35, 45]
+        # Shape of point markers, default = ['o','^','d','s']
+        self.point_marker = ['o', 's', 'd', '^']
+
+        # ---data lists---
+        # Data for point markers
+        self.points = []
+        # Data for Bloch vectors
+        self.vectors = []
+        # Transparency of vectors, alpha value from 0 to 1
+        self.vector_alpha = []
+        # Data for annotations
+        self.annotations = []
+        # Number of times sphere has been saved
+        self.savenum = 0
+        # Style of points, 'm' for multiple colors, 's' for single color
+        self.point_style = []
+        # Transparency of points, alpha value from 0 to 1
+        self.point_alpha = []
+        # Data for line segment
+        self._lines = []
+        # Data for arcs and arc style
+        self._arcs = []
+
+    def set_label_convention(self, convention):
+        """Set x, y and z labels according to one of conventions.
+
+        Parameters
+        ----------
+        convention : string
+            One of the following:
+
+            - "original"
+            - "xyz"
+            - "sx sy sz"
+            - "01"
+            - "polarization jones"
+            - "polarization jones letters"
+              see also: https://en.wikipedia.org/wiki/Jones_calculus
+            - "polarization stokes"
+              see also: https://en.wikipedia.org/wiki/Stokes_parameters
+        """
+        ketex = "$\\left.|%s\\right\\rangle$"
+        # \left.| is on purpose, so that every ket has the same size
+
+        if convention == "original":
+            self.xlabel = ['$x$', '']
+            self.ylabel = ['$y$', '']
+            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
+        elif convention == "xyz":
+            self.xlabel = ['$x$', '']
+            self.ylabel = ['$y$', '']
+            self.zlabel = ['$z$', '']
+        elif convention == "sx sy sz":
+            self.xlabel = ['$s_x$', '']
+            self.ylabel = ['$s_y$', '']
+            self.zlabel = ['$s_z$', '']
+        elif convention == "01":
+            self.xlabel = ['', '']
+            self.ylabel = ['', '']
+            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
+        elif convention == "polarization jones":
+            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
+                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
+            self.ylabel = [ketex % "\\circlearrowleft", ketex %
+                           "\\circlearrowright"]
+            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
+        elif convention == "polarization jones letters":
+            self.xlabel = [ketex % "D", ketex % "A"]
+            self.ylabel = [ketex % "L", ketex % "R"]
+            self.zlabel = [ketex % "H", ketex % "V"]
+        elif convention == "polarization stokes":
+            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
+                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
+            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
+            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
+        else:
+            raise Exception("No such convention.")
+
+    def __str__(self):
+        s = ""
+        s += "Bloch data:\n"
+        s += "-----------\n"
+        s += "Number of points:  " + str(len(self.points)) + "\n"
+        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
+        s += "\n"
+        s += "Bloch sphere properties:\n"
+        s += "------------------------\n"
+        s += "font_color:      " + str(self.font_color) + "\n"
+        s += "font_size:       " + str(self.font_size) + "\n"
+        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
+        s += "frame_color:     " + str(self.frame_color) + "\n"
+        s += "frame_width:     " + str(self.frame_width) + "\n"
+        s += "point_default_color:" + str(self.point_default_color) + "\n"
+        s += "point_marker:    " + str(self.point_marker) + "\n"
+        s += "point_size:      " + str(self.point_size) + "\n"
+        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
+        s += "sphere_color:    " + str(self.sphere_color) + "\n"
+        s += "figsize:         " + str(self.figsize) + "\n"
+        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
+        s += "vector_width:    " + str(self.vector_width) + "\n"
+        s += "vector_style:    " + str(self.vector_style) + "\n"
+        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
+        s += "view:            " + str(self.view) + "\n"
+        s += "xlabel:          " + str(self.xlabel) + "\n"
+        s += "xlpos:           " + str(self.xlpos) + "\n"
+        s += "ylabel:          " + str(self.ylabel) + "\n"
+        s += "ylpos:           " + str(self.ylpos) + "\n"
+        s += "zlabel:          " + str(self.zlabel) + "\n"
+        s += "zlpos:           " + str(self.zlpos) + "\n"
+        return s
+
+    def _repr_png_(self):
+        from IPython.core.pylabtools import print_figure
+        self.render()
+        fig_data = print_figure(self.fig, 'png')
+        plt.close(self.fig)
+        return fig_data
+
+    def _repr_svg_(self):
+        from IPython.core.pylabtools import print_figure
+        self.render()
+        fig_data = print_figure(self.fig, 'svg')
+        plt.close(self.fig)
+        return fig_data
+
+    def clear(self):
+        """Resets Bloch sphere data sets to empty.
+        """
+        self.points = []
+        self.vectors = []
+        self.point_style = []
+        self.point_alpha = []
+        self.vector_alpha = []
+        self.annotations = []
+        self.vector_color = []
+        self.point_color = []
+        self._lines = []
+        self._arcs = []
+
+    def add_points(self, points, meth='s', colors=None, alpha=1.0):
+        """Add a list of data points to bloch sphere.
+
+        Parameters
+        ----------
+        points : array_like
+            Collection of data points.
+
+        meth : {'s', 'm', 'l'}
+            Type of points to plot, use 'm' for multicolored, 'l' for points
+            connected with a line.
+
+        colors : array_like
+            Optional array with colors for the points.
+            A single color for meth 's', and list of colors for meth 'm'
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        .. note::
+
+           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
+           to ``0.75`` and there was no way to alter it.
+           When the ``alpha`` parameter was added in QuTiP 4.7, the default
+           became ``alpha=1.0`` for values of ``meth``.
+        """
+
+        points = np.asarray(points)
+
+        if points.ndim == 1:
+            points = points[:, np.newaxis]
+
+        if points.ndim != 2 or points.shape[0] != 3:
+            raise ValueError("The included points are not valid. Points must "
+                             "be equivalent to a 2D array where the first "
+                             "index represents the x,y,z values and the "
+                             "second index iterates over the points.")
+
+        if meth not in ['s', 'm', 'l']:
+            raise ValueError(f"The value for meth = {meth} is not valid."
+                             " Please use 's', 'l' or 'm'.")
+
+        if meth == 's' and points.shape[1] == 1:
+            points = np.append(points[:, :1], points, axis=1)
+
+        self.point_style.append(meth)
+        self.points.append(points)
+        self.point_alpha.append(alpha)
+        self.point_color.append(colors)
+
+    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
+        """Add a state vector Qobj to Bloch sphere.
+
+        Parameters
+        ----------
+        state : Qobj
+            Input state vector.
+
+        kind : {'vector', 'point'}
+            Type of object to plot.
+
+        colors : array_like
+            Optional array with colors for the states.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+        """
+        if isinstance(state, Qobj):
+            state = [state]
+        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
+            colors = [colors]
+
+        for k, st in enumerate(state):
+            vec = [expect(sigmax(), st),
+                   expect(sigmay(), st),
+                   expect(sigmaz(), st)]
+
+            if kind == 'vector':
+                if colors is not None:
+                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
+                else:
+                    self.add_vectors(vec)
+            elif kind == 'point':
+                if colors is not None:
+                    self.add_points(vec, colors=colors[k], alpha=alpha)
+                else:
+                    self.add_points(vec)
+
+    def add_vectors(self, vectors, colors=None, alpha=1.0):
+        """Add a list of vectors to Bloch sphere.
+
+        Parameters
+        ----------
+        vectors : array_like
+            Array with vectors of unit length or smaller.
+
+        colors : array_like
+            Optional array with colors for the vectors.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        """
+        vectors = np.asarray(vectors)
+
+        if vectors.ndim == 1:
+            vectors = vectors[np.newaxis, :]
+
+        if vectors.ndim != 2 or vectors.shape[1] != 3:
+            raise ValueError(
+                "The included vectors are not valid. Vectors must "
+                "be equivalent to a 2D array where the first "
+                "index represents the iteration over the vectors and the "
+                "second index represents the position in 3D of vector head.")
+
+        n_vectors = vectors.shape[0]
+        if colors is None:
+            colors = np.array([None] * n_vectors)
+        else:
+            colors = np.asarray(colors)
+
+        if colors.ndim != 1 or colors.size != n_vectors:
+            raise ValueError("The included colors are not valid. colors must "
+                             "be equivalent to a 1D array with the same "
+                             "size as the number of vectors. ")
+
+        for k, vec in enumerate(vectors):
+            self.vectors.append(vec)
+            self.vector_alpha.append(alpha)
+            self.vector_color.append(colors[k])
+
+    def add_annotation(self, state_or_vector, text, **kwargs):
+        """
+        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
+        state or a vector.
+
+        Parameters
+        ----------
+        state_or_vector : Qobj/array/list/tuple
+            Position for the annotaion.
+            Qobj of a qubit or a vector of 3 elements.
+
+        text : str
+            Annotation text.
+            You can use LaTeX, but remember to use raw string
+            e.g. r"$\\langle x \\rangle$"
+            or escape backslashes
+            e.g. "$\\\\langle x \\\\rangle$".
+
+        kwargs :
+            Options as for mplot3d.axes3d.text, including:
+            fontsize, color, horizontalalignment, verticalalignment.
+
+        """
+        if isinstance(state_or_vector, Qobj):
+            vec = [expect(sigmax(), state_or_vector),
+                   expect(sigmay(), state_or_vector),
+                   expect(sigmaz(), state_or_vector)]
+        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
+                and len(state_or_vector) == 3:
+            vec = state_or_vector
+        else:
+            raise Exception("Position needs to be specified by a qubit " +
+                            "state or a 3D vector.")
+        self.annotations.append({'position': vec,
+                                 'text': text,
+                                 'opts': kwargs})
+
+    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
+        """Adds an arc between two points on a sphere. The arc is set to be
+        blue solid curve by default.
+
+        The start and end points must be on the same sphere (i.e. have the
+        same radius) but need not be on the unit sphere.
+
+        Parameters
+        ----------
+        start : Qobj or array-like
+            Array with cartesian coordinates of the first point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        end : Qobj or array-like
+            Array with cartesian coordinates of the second point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        fmt : str, default: "b"
+            A matplotlib format string for rendering the arc.
+        steps : int, default: None
+            The number of segments to use when rendering the arc. The default
+            uses 100 steps times the distance between the start and end points,
+            with a minimum of 2 steps.
+        **kwargs : dict
+            Additional parameters to pass to the matplotlib .plot function
+            when rendering this arc.
+        """
+        if isinstance(start, Qobj):
+            pt1 = [
+                expect(sigmax(), start),
+                expect(sigmay(), start),
+                expect(sigmaz(), start),
+            ]
+        else:
+            pt1 = start
+
+        if isinstance(end, Qobj):
+            pt2 = [
+                expect(sigmax(), end),
+                expect(sigmay(), end),
+                expect(sigmaz(), end),
+            ]
+        else:
+            pt2 = end
+
+        pt1 = np.asarray(pt1)
+        pt2 = np.asarray(pt2)
+
+        len1 = np.linalg.norm(pt1)
+        len2 = np.linalg.norm(pt2)
+        if len1 < 1e-12 or len2 < 1e-12:
+            raise ValueError('Polar and azimuthal angles undefined at origin.')
+        elif abs(len1 - len2) > 1e-12:
+            raise ValueError("Points not on the same sphere.")
+        elif (pt1 == pt2).all():
+            raise ValueError(
+                "Start and end represent the same point. No arc can be formed."
+            )
+        elif (pt1 == -pt2).all():
+            raise ValueError(
+                "Start and end are diagonally opposite, no unique arc is"
+                " possible."
+            )
+
+        if steps is None:
+            steps = int(np.linalg.norm(pt1 - pt2) * 100)
+            steps = max(2, steps)
+        t = np.linspace(0, 1, steps)
+        # All the points in this line are contained in the plane defined
+        # by pt1, pt2 and the origin.
+        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
+        # Normalize all the points in the line so that are distance len1 from
+        # the origin.
+        arc = line * len1 / np.linalg.norm(line, axis=0)
+        self._arcs.append([arc, fmt, kwargs])
+
+    def add_line(self, start, end, fmt="k", **kwargs):
+        """Adds a line segment connecting two points on the bloch sphere.
+
+        The line segment is set to be a black solid line by default.
+
+        Parameters
+        ----------
+        start : Qobj or array-like
+            Array with cartesian coordinates of the first point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        end : Qobj or array-like
+            Array with cartesian coordinates of the second point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        fmt : str, default: "k"
+            A matplotlib format string for rendering the line.
+        **kwargs : dict
+            Additional parameters to pass to the matplotlib .plot function
+            when rendering this line.
+        """
+        if isinstance(start, Qobj):
+            pt1 = [
+                expect(sigmax(), start),
+                expect(sigmay(), start),
+                expect(sigmaz(), start),
+            ]
+        else:
+            pt1 = start
+
+        if isinstance(end, Qobj):
+            pt2 = [
+                expect(sigmax(), end),
+                expect(sigmay(), end),
+                expect(sigmaz(), end),
+            ]
+        else:
+            pt2 = end
+
+        pt1 = np.asarray(pt1)
+        pt2 = np.asarray(pt2)
+
+        x = [pt1[1], pt2[1]]
+        y = [-pt1[0], -pt2[0]]
+        z = [pt1[2], pt2[2]]
+        v = [x, y, z]
+        self._lines.append([v, fmt, kwargs])
+
+    def make_sphere(self):
+        """
+        Plots Bloch sphere and data sets.
+        """
+        self.render()
+
+    def run_from_ipython(self):
+        try:
+            __IPYTHON__
+            return True
+        except NameError:
+            return False
+
+    def _is_inline_backend(self):
+        backend = matplotlib.get_backend()
+        return backend == "module://matplotlib_inline.backend_inline"
+
+    def render(self):
+        """
+        Render the Bloch sphere and its data sets in on given figure and axes.
+        """
+        if not self._ext_fig and not self._is_inline_backend():
+            # If no external figure was supplied, we check to see if the
+            # figure we created in a previous call to .render() has been
+            # closed, and re-create if has been. This has the unfortunate
+            # side effect of losing any modifications made to the axes or
+            # figure, but the alternative is to crash the matplotlib backend.
+            #
+            # The inline backend used by, e.g. jupyter notebooks, is happy to
+            # use closed figures so we leave those figures intact.
+            if (
+                self.fig is not None and
+                not plt.fignum_exists(self.fig.number)
+            ):
+                self.fig = None
+                self.axes = None
+
+        if self.fig is None:
+            self.fig = plt.figure(figsize=self.figsize)
+            if self._is_inline_backend():
+                # We immediately close the inline figure do avoid displaying
+                # the figure twice when .show() calls display.
+                plt.close(self.fig)
+
+        if self.axes is None:
+            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
+
+        # Clearing the axes is horrifically slow and loses a lot of the
+        # axes state, but matplotlib doesn't seem to provide a better way
+        # to redraw Axes3D. :/
+        self.axes.clear()
+        self.axes.grid(False)
+        if self.background:
+            self.axes.set_xlim3d(-1.3, 1.3)
+            self.axes.set_ylim3d(-1.3, 1.3)
+            self.axes.set_zlim3d(-1.3, 1.3)
+        else:
+            self.axes.set_axis_off()
+            self.axes.set_xlim3d(-0.7, 0.7)
+            self.axes.set_ylim3d(-0.7, 0.7)
+            self.axes.set_zlim3d(-0.7, 0.7)
+        # Manually set aspect ratio to fit a square bounding box.
+        # Matplotlib did this stretching for < 3.3.0, but not above.
+        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
+            self.axes.set_box_aspect((1, 1, 1))
+        if not self.background:
+            self.plot_axes()
+
+        self.plot_back()
+        self.plot_points()
+        self.plot_vectors()
+        self.plot_lines()
+        self.plot_arcs()
+        self.plot_front()
+        self.plot_axes_labels()
+        self.plot_annotations()
+        # Trigger an update of the Bloch sphere if it is already shown:
+        self.fig.canvas.draw()
+
+    def plot_back(self):
+        # back half of sphere
+        u = np.linspace(0, np.pi, 25)
+        v = np.linspace(0, np.pi, 25)
+        x = outer(cos(u), sin(v))
+        y = outer(sin(u), sin(v))
+        z = outer(ones(np.size(u)), cos(v))
+        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
+                               color=self.sphere_color, linewidth=0,
+                               alpha=self.sphere_alpha)
+        # wireframe
+        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
+                                 color=self.frame_color,
+                                 alpha=self.frame_alpha)
+        # equator
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
+                       lw=self.frame_width, color=self.frame_color)
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
+                       lw=self.frame_width, color=self.frame_color)
+
+    def plot_front(self):
+        # front half of sphere
+        u = np.linspace(-np.pi, 0, 25)
+        v = np.linspace(0, np.pi, 25)
+        x = outer(cos(u), sin(v))
+        y = outer(sin(u), sin(v))
+        z = outer(ones(np.size(u)), cos(v))
+        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
+                               color=self.sphere_color, linewidth=0,
+                               alpha=self.sphere_alpha)
+        # wireframe
+        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
+                                 color=self.frame_color,
+                                 alpha=self.frame_alpha)
+        # equator
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
+                       zs=0, zdir='z', lw=self.frame_width,
+                       color=self.frame_color)
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
+                       zs=0, zdir='x', lw=self.frame_width,
+                       color=self.frame_color)
+
+    def plot_axes(self):
+        # axes
+        span = np.linspace(-1.0, 1.0, 2)
+        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
+                       lw=self.frame_width, color=self.frame_color)
+        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
+                       lw=self.frame_width, color=self.frame_color)
+        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
+                       lw=self.frame_width, color=self.frame_color)
+
+    def plot_axes_labels(self):
+        # axes labels
+        opts = {'fontsize': self.font_size,
+                'color': self.font_color,
+                'horizontalalignment': 'center',
+                'verticalalignment': 'center'}
+        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
+        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
+
+        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
+        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
+
+        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
+        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
+
+        for a in (self.axes.xaxis.get_ticklines() +
+                  self.axes.xaxis.get_ticklabels()):
+            a.set_visible(False)
+        for a in (self.axes.yaxis.get_ticklines() +
+                  self.axes.yaxis.get_ticklabels()):
+            a.set_visible(False)
+        for a in (self.axes.zaxis.get_ticklines() +
+                  self.axes.zaxis.get_ticklabels()):
+            a.set_visible(False)
+
+    def plot_vectors(self):
+        # -X and Y data are switched for plotting purposes
+        for k, vec in enumerate(self.vectors):
+
+            xs3d = vec[1] * np.array([0, 1])
+            ys3d = -vec[0] * np.array([0, 1])
+            zs3d = vec[2] * np.array([0, 1])
+
+            alpha = self.vector_alpha[k]
+            color = self.vector_color[k]
+            if color is None:
+                idx = k % len(self.vector_default_color)
+                color = self.vector_default_color[idx]
+
+            # decorated style, with arrow heads
+            a = Arrow3D(xs3d, ys3d, zs3d,
+                        mutation_scale=self.vector_mutation,
+                        lw=self.vector_width,
+                        arrowstyle=self.vector_style,
+                        color=color, alpha=alpha)
+
+            self.axes.add_artist(a)
+
+    def plot_points(self):
+        # -X and Y data are switched for plotting purposes
+        for k, points in enumerate(self.points):
+            points = np.asarray(points)
+            num_points = points.shape[1]
+
+            dist = np.linalg.norm(points, axis=0)
+            if not np.allclose(dist, dist[0], rtol=1e-12):
+                indperm = np.argsort(dist)
+                points = points[:, indperm]
+            else:
+                indperm = np.arange(num_points)
+
+            s = self.point_size[np.mod(k, len(self.point_size))]
+            marker = self.point_marker[np.mod(k, len(self.point_marker))]
+            style = self.point_style[k]
+            if self.point_color[k] is not None:
+                color = self.point_color[k]
+            elif self.point_style[k] in ['s', 'l']:
+                color = self.point_default_color[
+                    k % len(self.point_default_color)
+                ]
+            elif self.point_style[k] == 'm':
+                length = np.ceil(num_points/len(self.point_default_color))
+                color = np.tile(self.point_default_color, length.astype(int))
+                color = color[indperm]
+
+            if self.point_style[k] in ['s', 'm']:
+                self.axes.scatter(np.real(points[1]),
+                                  -np.real(points[0]),
+                                  np.real(points[2]),
+                                  s=s,
+                                  marker=marker,
+                                  color=color,
+                                  alpha=self.point_alpha[k],
+                                  edgecolor=None,
+                                  zdir='z',
+                                  )
+
+            elif self.point_style[k] == 'l':
+                self.axes.plot(np.real(points[1]),
+                               -np.real(points[0]),
+                               np.real(points[2]),
+                               color=color,
+                               alpha=self.point_alpha[k],
+                               zdir='z',
+                               )
+
+    def plot_annotations(self):
+        # -X and Y data are switched for plotting purposes
+        for annotation in self.annotations:
+            vec = annotation['position']
+            opts = {'fontsize': self.font_size,
+                    'color': self.font_color,
+                    'horizontalalignment': 'center',
+                    'verticalalignment': 'center'}
+            opts.update(annotation['opts'])
+            self.axes.text(vec[1], -vec[0], vec[2],
+                           annotation['text'], **opts)
+
+    def plot_lines(self):
+        for line, fmt, kw in self._lines:
+            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
+
+    def plot_arcs(self):
+        for arc, fmt, kw in self._arcs:
+            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
+
+    def show(self):
+        """
+        Display Bloch sphere and corresponding data sets.
+
+        Notes
+        -----
+
+        When using inline plotting in Jupyter notebooks, any figure created
+        in a notebook cell is displayed after the cell executes. Thus if you
+        create a figure yourself and use it create a Bloch sphere with
+        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
+        cell, then the figure will be displayed twice. If you do create your
+        own figure, the simplest solution to this is to not call ``.show()``
+        in the cell you create the figure in.
+        """
+        self.render()
+        if self.run_from_ipython():
+            display(self.fig)
+        else:
+            self.fig.show()
+
+    def save(self, name=None, format='png', dirc=None, dpin=None):
+        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
+
+        Parameters
+        ----------
+
+        name : str
+            Name of saved image. Must include path and format as well.
+            i.e. '/Users/Paul/Desktop/bloch.png'
+            This overrides the 'format' and 'dirc' arguments.
+        format : str
+            Format of output image.
+        dirc : str
+            Directory for output images. Defaults to current working directory.
+        dpin : int
+            Resolution in dots per inch.
+
+        Returns
+        -------
+        File containing plot of Bloch sphere.
+
+        """
+        self.render()
+        # Conditional variable for first argument to savefig
+        # that is set in subsequent if-elses
+        complete_path = ""
+        if dirc:
+            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
+                os.makedirs(os.getcwd() + "/" + str(dirc))
+        if name is None:
+            if dirc:
+                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
+                                + str(self.savenum) + '.' + format
+            else:
+                complete_path = os.getcwd() + '/bloch_' + \
+                                str(self.savenum) + '.' + format
+        else:
+            complete_path = name
+
+        if dpin:
+            self.fig.savefig(complete_path, dpi=dpin)
+        else:
+            self.fig.savefig(complete_path)
+        self.savenum += 1
+        if self.fig:
+            plt.close(self.fig)
+
+
+def _hide_tick_lines_and_labels(axis):
+    '''
+    Set visible property of ticklines and ticklabels of an axis to False
+    '''
+    for a in axis.get_ticklines() + axis.get_ticklabels():
+        a.set_visible(False)
diff --git a/qutip/bloch3d.py b/qutip/bloch3d.py
index d387b6c4d3..748e5cf750 100644
--- a/qutip/bloch3d.py
+++ b/qutip/bloch3d.py
@@ -1,517 +1,517 @@
-__all__ = ['Bloch3d']
-
-import numpy as np
-from . import Qobj, expect, sigmax, sigmay, sigmaz
-
-
-class Bloch3d:
-    """Class for plotting data on a 3D Bloch sphere using mayavi.
-    Valid data can be either points, vectors, or qobj objects
-    corresponding to state vectors or density matrices. for
-    a two-state system (or subsystem).
-
-    Attributes
-    ----------
-    fig : instance {None}
-        User supplied Matplotlib Figure instance for plotting Bloch sphere.
-    font_color : str {'black'}
-        Color of font used for Bloch sphere labels.
-    font_scale : float {0.08}
-        Scale for font used for Bloch sphere labels.
-    frame : bool {True}
-        Draw frame for Bloch sphere
-    frame_alpha : float {0.05}
-        Sets transparency of Bloch sphere frame.
-    frame_color : str {'gray'}
-        Color of sphere wireframe.
-    frame_num : int {8}
-        Number of frame elements to draw.
-    frame_radius : floats {0.005}
-        Width of wireframe.
-    point_color : list {['r', 'g', 'b', 'y']}
-        List of colors for Bloch sphere point markers to cycle through.
-        i.e. By default, points 0 and 4 will both be blue ('r').
-    point_mode : string {'sphere','cone','cube','cylinder','point'}
-        Point marker shapes.
-    point_size : float {0.075}
-        Size of points on Bloch sphere.
-    sphere_alpha : float {0.1}
-        Transparency of Bloch sphere itself.
-    sphere_color : str {'#808080'}
-        Color of Bloch sphere.
-    size : list {[500,500]}
-        Size of Bloch sphere plot in pixels. Best to have both numbers the same
-        otherwise you will have a Bloch sphere that looks like a football.
-    vector_color : list {['r', 'g', 'b', 'y']}
-        List of vector colors to cycle through.
-    vector_width : int {3}
-        Width of displayed vectors.
-    view : list {[45,65]}
-        Azimuthal and Elevation viewing angles.
-    xlabel : list {``['|x>', '']``}
-        List of strings corresponding to +x and -x axes labels, respectively.
-    xlpos : list {[1.07,-1.07]}
-        Positions of +x and -x labels respectively.
-    ylabel : list {``['|y>', '']``}
-        List of strings corresponding to +y and -y axes labels, respectively.
-    ylpos : list {[1.07,-1.07]}
-        Positions of +y and -y labels respectively.
-    zlabel : list {``['|0>', '|1>']``}
-        List of strings corresponding to +z and -z axes labels, respectively.
-    zlpos : list {[1.07,-1.07]}
-        Positions of +z and -z labels respectively.
-
-    Notes
-    -----
-    The use of mayavi for 3D rendering of the Bloch sphere comes with
-    a few limitations: I) You can not embed a Bloch3d figure into a
-    matplotlib window. II) The use of LaTex is not supported by the
-    mayavi rendering engine. Therefore all labels must be defined using
-    standard text. Of course you can post-process the generated figures
-    later to add LaTeX using other software if needed.
-
-
-    """
-    def __init__(self, fig=None):
-        # ----check for mayavi-----
-        try:
-            from mayavi import mlab
-        except:
-            raise Exception("This function requires the mayavi module.")
-
-        # ---Image options---
-        self.fig = None
-        self.user_fig = None
-        # check if user specified figure or axes.
-        if fig:
-            self.user_fig = fig
-        # The size of the figure in inches, default = [500,500].
-        self.size = [500, 500]
-        # Azimuthal and Elvation viewing angles, default = [45,65].
-        self.view = [45, 65]
-        # Image background color
-        self.bgcolor = 'white'
-        # Image foreground color. Other options can override.
-        self.fgcolor = 'black'
-
-        # ---Sphere options---
-        # Color of Bloch sphere, default = #808080
-        self.sphere_color = '#808080'
-        # Transparency of Bloch sphere, default = 0.1
-        self.sphere_alpha = 0.1
-
-        # ---Frame options---
-        # Draw frame?
-        self.frame = True
-        # number of lines to draw for frame
-        self.frame_num = 8
-        # Color of wireframe, default = 'gray'
-        self.frame_color = 'black'
-        # Transparency of wireframe, default = 0.2
-        self.frame_alpha = 0.05
-        # Radius of frame lines
-        self.frame_radius = 0.005
-
-        # --Axes---
-        # Axes color
-        self.axes_color = 'black'
-        # Transparency of axes
-        self.axes_alpha = 0.4
-        # Radius of axes lines
-        self.axes_radius = 0.005
-
-        # ---Labels---
-        # Labels for x-axis (in LaTex), default = ['$x$','']
-        self.xlabel = ['|x>', '']
-        # Position of x-axis labels, default = [1.2,-1.2]
-        self.xlpos = [1.07, -1.07]
-        # Labels for y-axis (in LaTex), default = ['$y$','']
-        self.ylabel = ['|y>', '']
-        # Position of y-axis labels, default = [1.1,-1.1]
-        self.ylpos = [1.07, -1.07]
-        # Labels for z-axis
-        self.zlabel = ['|0>', '|1>']
-        # Position of z-axis labels, default = [1.05,-1.05]
-        self.zlpos = [1.07, -1.07]
-
-        # ---Font options---
-        # Color of fonts, default = 'black'
-        self.font_color = 'black'
-        # Size of fonts, default = 20
-        self.font_scale = 0.08
-
-        # ---Vector options---
-        # Object used for representing vectors on Bloch sphere.
-        # List of colors for Bloch vectors, default = ['b','g','r','y']
-        self.vector_color = ['r', 'g', 'b', 'y']
-        # Width of Bloch vectors, default = 2
-        self.vector_width = 2.0
-        # Height of vector head
-        self.vector_head_height = 0.15
-        # Radius of vector head
-        self.vector_head_radius = 0.075
-
-        # ---Point options---
-        # List of colors for Bloch point markers, default = ['b','g','r','y']
-        self.point_color = ['r', 'g', 'b', 'y']
-        # Size of point markers
-        self.point_size = 0.06
-        # Shape of point markers
-        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
-        # Default = 'sphere'
-        self.point_mode = 'sphere'
-
-        # ---Data lists---
-        # Data for point markers
-        self.points = []
-        # Data for Bloch vectors
-        self.vectors = []
-        # Number of times sphere has been saved
-        self.savenum = 0
-        # Style of points, 'm' for multiple colors, 's' for single color
-        self.point_style = []
-        # Transparency of points
-        self.point_alpha = []
-        # Transparency of vectors
-        self.vector_alpha = []
-
-    def __str__(self):
-        s = ""
-        s += "Bloch3D data:\n"
-        s += "-----------\n"
-        s += "Number of points:  " + str(len(self.points)) + "\n"
-        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
-        s += "\n"
-        s += "Bloch3D sphere properties:\n"
-        s += "--------------------------\n"
-        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
-        s += "axes_color:         " + str(self.axes_color) + "\n"
-        s += "axes_radius:        " + str(self.axes_radius) + "\n"
-        s += "bgcolor:            " + str(self.bgcolor) + "\n"
-        s += "fgcolor:            " + str(self.fgcolor) + "\n"
-        s += "font_color:         " + str(self.font_color) + "\n"
-        s += "font_scale:         " + str(self.font_scale) + "\n"
-        s += "frame:              " + str(self.frame) + "\n"
-        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
-        s += "frame_color:        " + str(self.frame_color) + "\n"
-        s += "frame_num:          " + str(self.frame_num) + "\n"
-        s += "frame_radius:       " + str(self.frame_radius) + "\n"
-        s += "point_color:        " + str(self.point_color) + "\n"
-        s += "point_mode:         " + str(self.point_mode) + "\n"
-        s += "point_size:         " + str(self.point_size) + "\n"
-        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
-        s += "sphere_color:       " + str(self.sphere_color) + "\n"
-        s += "size:               " + str(self.size) + "\n"
-        s += "vector_color:       " + str(self.vector_color) + "\n"
-        s += "vector_width:       " + str(self.vector_width) + "\n"
-        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
-        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
-        s += "view:               " + str(self.view) + "\n"
-        s += "xlabel:             " + str(self.xlabel) + "\n"
-        s += "xlpos:              " + str(self.xlpos) + "\n"
-        s += "ylabel:             " + str(self.ylabel) + "\n"
-        s += "ylpos:              " + str(self.ylpos) + "\n"
-        s += "zlabel:             " + str(self.zlabel) + "\n"
-        s += "zlpos:              " + str(self.zlpos) + "\n"
-        return s
-
-    def clear(self):
-        """Resets the Bloch sphere data sets to empty.
-        """
-        self.points = []
-        self.vectors = []
-        self.point_style = []
-
-    def add_points(self, points, meth='s', alpha=1.0):
-        """Add a list of data points to bloch sphere.
-
-        Parameters
-        ----------
-        points : array/list
-            Collection of data points.
-
-        meth : str {'s','m'}
-            Type of points to plot, use 'm' for multicolored.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        """
-        if not isinstance(points[0], (list, np.ndarray)):
-            points = [[points[0]], [points[1]], [points[2]]]
-        points = np.array(points)
-        if meth == 's':
-            if len(points[0]) == 1:
-                pnts = np.array(
-                    [[points[0][0]], [points[1][0]], [points[2][0]]])
-                pnts = np.append(pnts, points, axis=1)
-            else:
-                pnts = points
-            self.points.append(pnts)
-            self.point_style.append('s')
-        else:
-            self.points.append(points)
-            self.point_style.append('m')
-        self.point_alpha.append(alpha)
-
-    def add_states(self, state, kind='vector', alpha=1.0):
-        """Add a state vector Qobj to Bloch sphere.
-
-        Parameters
-        ----------
-        state : qobj
-            Input state vector.
-
-        kind : str {'vector','point'}
-            Type of object to plot.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-        """
-        if isinstance(state, Qobj):
-            state = [state]
-        for st in state:
-            if kind == 'vector':
-                vec = [expect(sigmax(), st), expect(sigmay(), st),
-                       expect(sigmaz(), st)]
-                self.add_vectors(vec, alpha=alpha)
-            elif kind == 'point':
-                pnt = [expect(sigmax(), st), expect(sigmay(), st),
-                       expect(sigmaz(), st)]
-                self.add_points(pnt, alpha=alpha)
-
-    def add_vectors(self, vectors, alpha=1.0):
-        """Add a list of vectors to Bloch sphere.
-
-        Parameters
-        ----------
-        vectors : array/list
-            Array with vectors of unit length or smaller.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        """
-        if isinstance(vectors[0], (list, np.ndarray)):
-            for vec in vectors:
-                self.vectors.append(vec)
-                self.vector_alpha.append(alpha)
-        else:
-            self.vectors.append(vectors)
-            self.vector_alpha.append(alpha)
-
-    def plot_vectors(self):
-        """
-        Plots vectors on the Bloch sphere.
-        """
-        from mayavi import mlab
-        from tvtk.api import tvtk
-        import matplotlib.colors as colors
-        ii = 0
-        for k in range(len(self.vectors)):
-            vec = np.array(self.vectors[k])
-            norm = np.linalg.norm(vec)
-            theta = np.arccos(vec[2] / norm)
-            phi = np.arctan2(vec[1], vec[0])
-            vec -= 0.5 * self.vector_head_height * \
-                np.array([np.sin(theta) * np.cos(phi),
-                          np.sin(theta) * np.sin(phi), np.cos(theta)])
-
-            color = colors.colorConverter.to_rgb(
-                self.vector_color[np.mod(k, len(self.vector_color))])
-
-            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
-                        name='vector' + str(ii), tube_sides=100,
-                        line_width=self.vector_width,
-                        opacity=self.vector_alpha[k],
-                        color=color)
-
-            cone = tvtk.ConeSource(height=self.vector_head_height,
-                                   radius=self.vector_head_radius,
-                                   resolution=100)
-            cone_mapper = tvtk.PolyDataMapper(
-                input_connection=cone.output_port)
-            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
-            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
-            cc.rotate_z(np.degrees(phi))
-            cc.rotate_y(-90 + np.degrees(theta))
-            cc.position = vec
-            self.fig.scene.add_actor(cc)
-
-    def plot_points(self):
-        """
-        Plots points on the Bloch sphere.
-        """
-        from mayavi import mlab
-        import matplotlib.colors as colors
-        for k in range(len(self.points)):
-            num = len(self.points[k][0])
-            dist = [np.sqrt(self.points[k][0][j] ** 2 +
-                            self.points[k][1][j] ** 2 +
-                            self.points[k][2][j] ** 2) for j in range(num)]
-            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
-                # combine arrays so that they can be sorted together
-                # and sort rates from lowest to highest
-                zipped = sorted(zip(dist, range(num)))
-                dist, indperm = zip(*zipped)
-                indperm = np.array(indperm)
-            else:
-                indperm = range(num)
-            if self.point_style[k] == 's':
-                color = colors.colorConverter.to_rgb(
-                    self.point_color[np.mod(k, len(self.point_color))])
-                mlab.points3d(
-                    self.points[k][0][indperm], self.points[k][1][indperm],
-                    self.points[k][2][indperm], figure=self.fig,
-                    resolution=100, scale_factor=self.point_size,
-                    mode=self.point_mode, color=color,
-                    opacity=self.point_alpha[k])
-
-            elif self.point_style[k] == 'm':
-                pnt_colors = np.array(self.point_color * np.ceil(
-                    num / float(len(self.point_color))))
-                pnt_colors = pnt_colors[0:num]
-                pnt_colors = list(pnt_colors[indperm])
-                for kk in range(num):
-                    mlab.points3d(
-                        self.points[k][0][
-                            indperm[kk]], self.points[k][1][indperm[kk]],
-                        self.points[k][2][
-                            indperm[kk]], figure=self.fig, resolution=100,
-                        scale_factor=self.point_size, mode=self.point_mode,
-                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
-                        opacity=self.point_alpha[k])
-
-    def make_sphere(self):
-        """
-        Plots Bloch sphere and data sets.
-        """
-        # setup plot
-        # Figure instance for Bloch sphere plot
-        from mayavi import mlab
-        import matplotlib.colors as colors
-        if self.user_fig:
-            self.fig = self.user_fig
-        else:
-            self.fig = mlab.figure(
-                1, size=self.size,
-                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
-                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
-
-        sphere = mlab.points3d(
-            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
-            color=colors.colorConverter.to_rgb(self.sphere_color),
-            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
-
-        # Thse commands make the sphere look better
-        sphere.actor.property.specular = 0.45
-        sphere.actor.property.specular_power = 5
-        sphere.actor.property.backface_culling = True
-
-        # make frame for sphere surface
-        if self.frame:
-            theta = np.linspace(0, 2 * np.pi, 100)
-            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
-                xlat = np.cos(theta) * np.cos(angle)
-                ylat = np.sin(theta) * np.cos(angle)
-                zlat = np.ones_like(theta) * np.sin(angle)
-                xlon = np.sin(angle) * np.sin(theta)
-                ylon = np.cos(angle) * np.sin(theta)
-                zlon = np.cos(theta)
-                mlab.plot3d(
-                    xlat, ylat, zlat,
-                    color=colors.colorConverter.to_rgb(self.frame_color),
-                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
-                mlab.plot3d(
-                    xlon, ylon, zlon,
-                    color=colors.colorConverter.to_rgb(self.frame_color),
-                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
-
-        # add axes
-        axis = np.linspace(-1.0, 1.0, 10)
-        other = np.zeros_like(axis)
-        mlab.plot3d(
-            axis, other, other,
-            color=colors.colorConverter.to_rgb(self.axes_color),
-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-        mlab.plot3d(
-            other, axis, other,
-            color=colors.colorConverter.to_rgb(self.axes_color),
-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-        mlab.plot3d(
-            other, other, axis,
-            color=colors.colorConverter.to_rgb(self.axes_color),
-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-
-        # add data to sphere
-        self.plot_points()
-        self.plot_vectors()
-
-        # #add labels
-        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-
-    def show(self):
-        """
-        Display the Bloch sphere and corresponding data sets.
-        """
-        from mayavi import mlab
-        self.make_sphere()
-        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
-        if self.fig:
-            mlab.show()
-
-    def save(self, name=None, format='png', dirc=None):
-        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
-
-        Parameters
-        ----------
-        name : str
-            Name of saved image. Must include path and format as well.
-            i.e. '/Users/Paul/Desktop/bloch.png'
-            This overrides the 'format' and 'dirc' arguments.
-        format : str
-            Format of output image. Default is 'png'.
-        dirc : str
-            Directory for output images. Defaults to current working directory.
-
-        Returns
-        -------
-        File containing plot of Bloch sphere.
-
-        """
-        from mayavi import mlab
-        import os
-        self.make_sphere()
-        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
-        if dirc:
-            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
-                os.makedirs(os.getcwd() + "/" + str(dirc))
-        if name is None:
-            if dirc:
-                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
-                             str(self.savenum) + '.' + format)
-            else:
-                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
-                             '.' + format)
-        else:
-            mlab.savefig(name)
-        self.savenum += 1
-        if self.fig:
-            mlab.close(self.fig)
+__all__ = ['Bloch3d']
+
+import numpy as np
+from . import Qobj, expect, sigmax, sigmay, sigmaz
+
+
+class Bloch3d:
+    """Class for plotting data on a 3D Bloch sphere using mayavi.
+    Valid data can be either points, vectors, or qobj objects
+    corresponding to state vectors or density matrices. for
+    a two-state system (or subsystem).
+
+    Attributes
+    ----------
+    fig : instance {None}
+        User supplied Matplotlib Figure instance for plotting Bloch sphere.
+    font_color : str {'black'}
+        Color of font used for Bloch sphere labels.
+    font_scale : float {0.08}
+        Scale for font used for Bloch sphere labels.
+    frame : bool {True}
+        Draw frame for Bloch sphere
+    frame_alpha : float {0.05}
+        Sets transparency of Bloch sphere frame.
+    frame_color : str {'gray'}
+        Color of sphere wireframe.
+    frame_num : int {8}
+        Number of frame elements to draw.
+    frame_radius : floats {0.005}
+        Width of wireframe.
+    point_color : list {['r', 'g', 'b', 'y']}
+        List of colors for Bloch sphere point markers to cycle through.
+        i.e. By default, points 0 and 4 will both be blue ('r').
+    point_mode : string {'sphere','cone','cube','cylinder','point'}
+        Point marker shapes.
+    point_size : float {0.075}
+        Size of points on Bloch sphere.
+    sphere_alpha : float {0.1}
+        Transparency of Bloch sphere itself.
+    sphere_color : str {'#808080'}
+        Color of Bloch sphere.
+    size : list {[500,500]}
+        Size of Bloch sphere plot in pixels. Best to have both numbers the same
+        otherwise you will have a Bloch sphere that looks like a football.
+    vector_color : list {['r', 'g', 'b', 'y']}
+        List of vector colors to cycle through.
+    vector_width : int {3}
+        Width of displayed vectors.
+    view : list {[45,65]}
+        Azimuthal and Elevation viewing angles.
+    xlabel : list {``['|x>', '']``}
+        List of strings corresponding to +x and -x axes labels, respectively.
+    xlpos : list {[1.07,-1.07]}
+        Positions of +x and -x labels respectively.
+    ylabel : list {``['|y>', '']``}
+        List of strings corresponding to +y and -y axes labels, respectively.
+    ylpos : list {[1.07,-1.07]}
+        Positions of +y and -y labels respectively.
+    zlabel : list {``['|0>', '|1>']``}
+        List of strings corresponding to +z and -z axes labels, respectively.
+    zlpos : list {[1.07,-1.07]}
+        Positions of +z and -z labels respectively.
+
+    Notes
+    -----
+    The use of mayavi for 3D rendering of the Bloch sphere comes with
+    a few limitations: I) You can not embed a Bloch3d figure into a
+    matplotlib window. II) The use of LaTex is not supported by the
+    mayavi rendering engine. Therefore all labels must be defined using
+    standard text. Of course you can post-process the generated figures
+    later to add LaTeX using other software if needed.
+
+
+    """
+    def __init__(self, fig=None):
+        # ----check for mayavi-----
+        try:
+            from mayavi import mlab
+        except:
+            raise Exception("This function requires the mayavi module.")
+
+        # ---Image options---
+        self.fig = None
+        self.user_fig = None
+        # check if user specified figure or axes.
+        if fig:
+            self.user_fig = fig
+        # The size of the figure in inches, default = [500,500].
+        self.size = [500, 500]
+        # Azimuthal and Elvation viewing angles, default = [45,65].
+        self.view = [45, 65]
+        # Image background color
+        self.bgcolor = 'white'
+        # Image foreground color. Other options can override.
+        self.fgcolor = 'black'
+
+        # ---Sphere options---
+        # Color of Bloch sphere, default = #808080
+        self.sphere_color = '#808080'
+        # Transparency of Bloch sphere, default = 0.1
+        self.sphere_alpha = 0.1
+
+        # ---Frame options---
+        # Draw frame?
+        self.frame = True
+        # number of lines to draw for frame
+        self.frame_num = 8
+        # Color of wireframe, default = 'gray'
+        self.frame_color = 'black'
+        # Transparency of wireframe, default = 0.2
+        self.frame_alpha = 0.05
+        # Radius of frame lines
+        self.frame_radius = 0.005
+
+        # --Axes---
+        # Axes color
+        self.axes_color = 'black'
+        # Transparency of axes
+        self.axes_alpha = 0.4
+        # Radius of axes lines
+        self.axes_radius = 0.005
+
+        # ---Labels---
+        # Labels for x-axis (in LaTex), default = ['$x$','']
+        self.xlabel = ['|x>', '']
+        # Position of x-axis labels, default = [1.2,-1.2]
+        self.xlpos = [1.07, -1.07]
+        # Labels for y-axis (in LaTex), default = ['$y$','']
+        self.ylabel = ['|y>', '']
+        # Position of y-axis labels, default = [1.1,-1.1]
+        self.ylpos = [1.07, -1.07]
+        # Labels for z-axis
+        self.zlabel = ['|0>', '|1>']
+        # Position of z-axis labels, default = [1.05,-1.05]
+        self.zlpos = [1.07, -1.07]
+
+        # ---Font options---
+        # Color of fonts, default = 'black'
+        self.font_color = 'black'
+        # Size of fonts, default = 20
+        self.font_scale = 0.08
+
+        # ---Vector options---
+        # Object used for representing vectors on Bloch sphere.
+        # List of colors for Bloch vectors, default = ['b','g','r','y']
+        self.vector_color = ['r', 'g', 'b', 'y']
+        # Width of Bloch vectors, default = 2
+        self.vector_width = 2.0
+        # Height of vector head
+        self.vector_head_height = 0.15
+        # Radius of vector head
+        self.vector_head_radius = 0.075
+
+        # ---Point options---
+        # List of colors for Bloch point markers, default = ['b','g','r','y']
+        self.point_color = ['r', 'g', 'b', 'y']
+        # Size of point markers
+        self.point_size = 0.06
+        # Shape of point markers
+        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
+        # Default = 'sphere'
+        self.point_mode = 'sphere'
+
+        # ---Data lists---
+        # Data for point markers
+        self.points = []
+        # Data for Bloch vectors
+        self.vectors = []
+        # Number of times sphere has been saved
+        self.savenum = 0
+        # Style of points, 'm' for multiple colors, 's' for single color
+        self.point_style = []
+        # Transparency of points
+        self.point_alpha = []
+        # Transparency of vectors
+        self.vector_alpha = []
+
+    def __str__(self):
+        s = ""
+        s += "Bloch3D data:\n"
+        s += "-----------\n"
+        s += "Number of points:  " + str(len(self.points)) + "\n"
+        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
+        s += "\n"
+        s += "Bloch3D sphere properties:\n"
+        s += "--------------------------\n"
+        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
+        s += "axes_color:         " + str(self.axes_color) + "\n"
+        s += "axes_radius:        " + str(self.axes_radius) + "\n"
+        s += "bgcolor:            " + str(self.bgcolor) + "\n"
+        s += "fgcolor:            " + str(self.fgcolor) + "\n"
+        s += "font_color:         " + str(self.font_color) + "\n"
+        s += "font_scale:         " + str(self.font_scale) + "\n"
+        s += "frame:              " + str(self.frame) + "\n"
+        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
+        s += "frame_color:        " + str(self.frame_color) + "\n"
+        s += "frame_num:          " + str(self.frame_num) + "\n"
+        s += "frame_radius:       " + str(self.frame_radius) + "\n"
+        s += "point_color:        " + str(self.point_color) + "\n"
+        s += "point_mode:         " + str(self.point_mode) + "\n"
+        s += "point_size:         " + str(self.point_size) + "\n"
+        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
+        s += "sphere_color:       " + str(self.sphere_color) + "\n"
+        s += "size:               " + str(self.size) + "\n"
+        s += "vector_color:       " + str(self.vector_color) + "\n"
+        s += "vector_width:       " + str(self.vector_width) + "\n"
+        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
+        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
+        s += "view:               " + str(self.view) + "\n"
+        s += "xlabel:             " + str(self.xlabel) + "\n"
+        s += "xlpos:              " + str(self.xlpos) + "\n"
+        s += "ylabel:             " + str(self.ylabel) + "\n"
+        s += "ylpos:              " + str(self.ylpos) + "\n"
+        s += "zlabel:             " + str(self.zlabel) + "\n"
+        s += "zlpos:              " + str(self.zlpos) + "\n"
+        return s
+
+    def clear(self):
+        """Resets the Bloch sphere data sets to empty.
+        """
+        self.points = []
+        self.vectors = []
+        self.point_style = []
+
+    def add_points(self, points, meth='s', alpha=1.0):
+        """Add a list of data points to bloch sphere.
+
+        Parameters
+        ----------
+        points : array/list
+            Collection of data points.
+
+        meth : str {'s','m'}
+            Type of points to plot, use 'm' for multicolored.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        """
+        if not isinstance(points[0], (list, np.ndarray)):
+            points = [[points[0]], [points[1]], [points[2]]]
+        points = np.array(points)
+        if meth == 's':
+            if len(points[0]) == 1:
+                pnts = np.array(
+                    [[points[0][0]], [points[1][0]], [points[2][0]]])
+                pnts = np.append(pnts, points, axis=1)
+            else:
+                pnts = points
+            self.points.append(pnts)
+            self.point_style.append('s')
+        else:
+            self.points.append(points)
+            self.point_style.append('m')
+        self.point_alpha.append(alpha)
+
+    def add_states(self, state, kind='vector', alpha=1.0):
+        """Add a state vector Qobj to Bloch sphere.
+
+        Parameters
+        ----------
+        state : qobj
+            Input state vector.
+
+        kind : str {'vector','point'}
+            Type of object to plot.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+        """
+        if isinstance(state, Qobj):
+            state = [state]
+        for st in state:
+            if kind == 'vector':
+                vec = [expect(sigmax(), st), expect(sigmay(), st),
+                       expect(sigmaz(), st)]
+                self.add_vectors(vec, alpha=alpha)
+            elif kind == 'point':
+                pnt = [expect(sigmax(), st), expect(sigmay(), st),
+                       expect(sigmaz(), st)]
+                self.add_points(pnt, alpha=alpha)
+
+    def add_vectors(self, vectors, alpha=1.0):
+        """Add a list of vectors to Bloch sphere.
+
+        Parameters
+        ----------
+        vectors : array/list
+            Array with vectors of unit length or smaller.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        """
+        if isinstance(vectors[0], (list, np.ndarray)):
+            for vec in vectors:
+                self.vectors.append(vec)
+                self.vector_alpha.append(alpha)
+        else:
+            self.vectors.append(vectors)
+            self.vector_alpha.append(alpha)
+
+    def plot_vectors(self):
+        """
+        Plots vectors on the Bloch sphere.
+        """
+        from mayavi import mlab
+        from tvtk.api import tvtk
+        import matplotlib.colors as colors
+        ii = 0
+        for k in range(len(self.vectors)):
+            vec = np.array(self.vectors[k])
+            norm = np.linalg.norm(vec)
+            theta = np.arccos(vec[2] / norm)
+            phi = np.arctan2(vec[1], vec[0])
+            vec -= 0.5 * self.vector_head_height * \
+                np.array([np.sin(theta) * np.cos(phi),
+                          np.sin(theta) * np.sin(phi), np.cos(theta)])
+
+            color = colors.colorConverter.to_rgb(
+                self.vector_color[np.mod(k, len(self.vector_color))])
+
+            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
+                        name='vector' + str(ii), tube_sides=100,
+                        line_width=self.vector_width,
+                        opacity=self.vector_alpha[k],
+                        color=color)
+
+            cone = tvtk.ConeSource(height=self.vector_head_height,
+                                   radius=self.vector_head_radius,
+                                   resolution=100)
+            cone_mapper = tvtk.PolyDataMapper(
+                input_connection=cone.output_port)
+            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
+            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
+            cc.rotate_z(np.degrees(phi))
+            cc.rotate_y(-90 + np.degrees(theta))
+            cc.position = vec
+            self.fig.scene.add_actor(cc)
+
+    def plot_points(self):
+        """
+        Plots points on the Bloch sphere.
+        """
+        from mayavi import mlab
+        import matplotlib.colors as colors
+        for k in range(len(self.points)):
+            num = len(self.points[k][0])
+            dist = [np.sqrt(self.points[k][0][j] ** 2 +
+                            self.points[k][1][j] ** 2 +
+                            self.points[k][2][j] ** 2) for j in range(num)]
+            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
+                # combine arrays so that they can be sorted together
+                # and sort rates from lowest to highest
+                zipped = sorted(zip(dist, range(num)))
+                dist, indperm = zip(*zipped)
+                indperm = np.array(indperm)
+            else:
+                indperm = range(num)
+            if self.point_style[k] == 's':
+                color = colors.colorConverter.to_rgb(
+                    self.point_color[np.mod(k, len(self.point_color))])
+                mlab.points3d(
+                    self.points[k][0][indperm], self.points[k][1][indperm],
+                    self.points[k][2][indperm], figure=self.fig,
+                    resolution=100, scale_factor=self.point_size,
+                    mode=self.point_mode, color=color,
+                    opacity=self.point_alpha[k])
+
+            elif self.point_style[k] == 'm':
+                pnt_colors = np.array(self.point_color * np.ceil(
+                    num / float(len(self.point_color))))
+                pnt_colors = pnt_colors[0:num]
+                pnt_colors = list(pnt_colors[indperm])
+                for kk in range(num):
+                    mlab.points3d(
+                        self.points[k][0][
+                            indperm[kk]], self.points[k][1][indperm[kk]],
+                        self.points[k][2][
+                            indperm[kk]], figure=self.fig, resolution=100,
+                        scale_factor=self.point_size, mode=self.point_mode,
+                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
+                        opacity=self.point_alpha[k])
+
+    def make_sphere(self):
+        """
+        Plots Bloch sphere and data sets.
+        """
+        # setup plot
+        # Figure instance for Bloch sphere plot
+        from mayavi import mlab
+        import matplotlib.colors as colors
+        if self.user_fig:
+            self.fig = self.user_fig
+        else:
+            self.fig = mlab.figure(
+                1, size=self.size,
+                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
+                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
+
+        sphere = mlab.points3d(
+            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
+            color=colors.colorConverter.to_rgb(self.sphere_color),
+            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
+
+        # Thse commands make the sphere look better
+        sphere.actor.property.specular = 0.45
+        sphere.actor.property.specular_power = 5
+        sphere.actor.property.backface_culling = True
+
+        # make frame for sphere surface
+        if self.frame:
+            theta = np.linspace(0, 2 * np.pi, 100)
+            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
+                xlat = np.cos(theta) * np.cos(angle)
+                ylat = np.sin(theta) * np.cos(angle)
+                zlat = np.ones_like(theta) * np.sin(angle)
+                xlon = np.sin(angle) * np.sin(theta)
+                ylon = np.cos(angle) * np.sin(theta)
+                zlon = np.cos(theta)
+                mlab.plot3d(
+                    xlat, ylat, zlat,
+                    color=colors.colorConverter.to_rgb(self.frame_color),
+                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
+                mlab.plot3d(
+                    xlon, ylon, zlon,
+                    color=colors.colorConverter.to_rgb(self.frame_color),
+                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
+
+        # add axes
+        axis = np.linspace(-1.0, 1.0, 10)
+        other = np.zeros_like(axis)
+        mlab.plot3d(
+            axis, other, other,
+            color=colors.colorConverter.to_rgb(self.axes_color),
+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+        mlab.plot3d(
+            other, axis, other,
+            color=colors.colorConverter.to_rgb(self.axes_color),
+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+        mlab.plot3d(
+            other, other, axis,
+            color=colors.colorConverter.to_rgb(self.axes_color),
+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+
+        # add data to sphere
+        self.plot_points()
+        self.plot_vectors()
+
+        # #add labels
+        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+
+    def show(self):
+        """
+        Display the Bloch sphere and corresponding data sets.
+        """
+        from mayavi import mlab
+        self.make_sphere()
+        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
+        if self.fig:
+            mlab.show()
+
+    def save(self, name=None, format='png', dirc=None):
+        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
+
+        Parameters
+        ----------
+        name : str
+            Name of saved image. Must include path and format as well.
+            i.e. '/Users/Paul/Desktop/bloch.png'
+            This overrides the 'format' and 'dirc' arguments.
+        format : str
+            Format of output image. Default is 'png'.
+        dirc : str
+            Directory for output images. Defaults to current working directory.
+
+        Returns
+        -------
+        File containing plot of Bloch sphere.
+
+        """
+        from mayavi import mlab
+        import os
+        self.make_sphere()
+        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
+        if dirc:
+            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
+                os.makedirs(os.getcwd() + "/" + str(dirc))
+        if name is None:
+            if dirc:
+                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
+                             str(self.savenum) + '.' + format)
+            else:
+                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
+                             '.' + format)
+        else:
+            mlab.savefig(name)
+        self.savenum += 1
+        if self.fig:
+            mlab.close(self.fig)
diff --git a/qutip/cite.py b/qutip/cite.py
index e3efb3e16c..124b11978c 100644
--- a/qutip/cite.py
+++ b/qutip/cite.py
@@ -1,60 +1,60 @@
-"""
-Citation generator for QuTiP
-"""
-import os
-
-__all__ = ['cite']
-
-
-def cite(save=False, path=None):
-    """
-    Citation information and bibtex generator for QuTiP
-
-    Parameters
-    ----------
-    save: bool
-        The flag specifying whether to save the .bib file.
-
-    path: str
-        The complete directory path to generate the bibtex file.
-        If not specified then the citation will be generated in cwd
-    """
-    citation = ["@article{qutip2,",
-                "doi = {10.1016/j.cpc.2012.11.019},",
-                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
-                "year  = {2013},",
-                "month = {apr},",
-                "publisher = {Elsevier {BV}},",
-                "volume = {184},",
-                "number = {4},",
-                "pages = {1234--1240},",
-                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
-                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
-                "journal = {Computer Physics Communications}",
-                "}",
-                "@article{qutip1,",
-                "doi = {10.1016/j.cpc.2012.02.021},",
-                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
-                "year  = {2012},",
-                "month = {aug},",
-                "publisher = {Elsevier {BV}},",
-                "volume = {183},",
-                "number = {8},",
-                "pages = {1760--1772},",
-                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
-                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
-                "journal = {Computer Physics Communications}",
-                "}"]
-    print("\n".join(citation))
-
-    if not path:
-        path = os.getcwd()
-
-    if save:
-        filename = "qutip.bib"
-        with open(os.path.join(path, filename), 'w') as f:
-            f.write("\n".join(citation))
-
-
-if __name__ == "__main__":
-    cite()
+"""
+Citation generator for QuTiP
+"""
+import os
+
+__all__ = ['cite']
+
+
+def cite(save=False, path=None):
+    """
+    Citation information and bibtex generator for QuTiP
+
+    Parameters
+    ----------
+    save: bool
+        The flag specifying whether to save the .bib file.
+
+    path: str
+        The complete directory path to generate the bibtex file.
+        If not specified then the citation will be generated in cwd
+    """
+    citation = ["@article{qutip2,",
+                "doi = {10.1016/j.cpc.2012.11.019},",
+                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
+                "year  = {2013},",
+                "month = {apr},",
+                "publisher = {Elsevier {BV}},",
+                "volume = {184},",
+                "number = {4},",
+                "pages = {1234--1240},",
+                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
+                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
+                "journal = {Computer Physics Communications}",
+                "}",
+                "@article{qutip1,",
+                "doi = {10.1016/j.cpc.2012.02.021},",
+                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
+                "year  = {2012},",
+                "month = {aug},",
+                "publisher = {Elsevier {BV}},",
+                "volume = {183},",
+                "number = {8},",
+                "pages = {1760--1772},",
+                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
+                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
+                "journal = {Computer Physics Communications}",
+                "}"]
+    print("\n".join(citation))
+
+    if not path:
+        path = os.getcwd()
+
+    if save:
+        filename = "qutip.bib"
+        with open(os.path.join(path, filename), 'w') as f:
+            f.write("\n".join(citation))
+
+
+if __name__ == "__main__":
+    cite()
diff --git a/qutip/continuous_variables.py b/qutip/continuous_variables.py
index 519f070ffa..004b5b365b 100644
--- a/qutip/continuous_variables.py
+++ b/qutip/continuous_variables.py
@@ -1,259 +1,259 @@
-"""
-This module contains a collection functions for calculating continuous variable
-quantities from fock-basis representation of the state of multi-mode fields.
-"""
-
-__all__ = ['correlation_matrix', 'covariance_matrix',
-           'correlation_matrix_field', 'correlation_matrix_quadrature',
-           'wigner_covariance_matrix', 'logarithmic_negativity']
-
-from . import expect
-import numpy as np
-
-
-def correlation_matrix(basis, rho=None):
-    r"""
-    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
-    matrix:
-
-    .. math::
-
-        C_{mn} = \langle a_m a_n \rangle
-
-    Parameters
-    ----------
-    basis : list
-        List of operators that defines the basis for the correlation matrix.
-    rho : Qobj
-        Density matrix for which to calculate the correlation matrix. If
-        `rho` is `None`, then a matrix of correlation matrix operators is
-        returned instead of expectation values of those operators.
-
-    Returns
-    -------
-    corr_mat : ndarray
-        A 2-dimensional *array* of correlation values or operators.
-
-
-    """
-    if rho is None:
-        # return array of operators
-        out = np.empty((len(basis), len(basis)), dtype=object)
-        for i, op2 in enumerate(basis):
-            out[i, :] = [op1 * op2 for op1 in basis]
-        return out
-    else:
-        # return array of expectation values
-        return np.array([[expect(op1 * op2, rho)
-                          for op1 in basis] for op2 in basis])
-
-
-def covariance_matrix(basis, rho, symmetrized=True):
-    r"""
-    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
-    matrix:
-
-    .. math::
-
-        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
-        \langle a_m \rangle \langle a_n\rangle
-
-    or, if of the optional argument `symmetrized=False`,
-
-    .. math::
-
-        V_{mn} = \langle a_m a_n\rangle -
-        \langle a_m \rangle \langle a_n\rangle
-
-    Parameters
-    ----------
-    basis : list
-        List of operators that defines the basis for the covariance matrix.
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-    symmetrized : bool {True, False}
-        Flag indicating whether the symmetrized (default) or non-symmetrized
-        correlation matrix is to be calculated.
-
-    Returns
-    -------
-    corr_mat : ndarray
-        A 2-dimensional array of covariance values.
-
-    """
-    if symmetrized:
-        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
-                          expect(op1, rho) * expect(op2, rho)
-                          for op1 in basis] for op2 in basis])
-    else:
-        return np.array([[expect(op1 * op2, rho) -
-                          expect(op1, rho) * expect(op2, rho)
-                          for op1 in basis] for op2 in basis])
-
-
-def correlation_matrix_field(a1, a2, rho=None):
-    """
-    Calculates the correlation matrix for given field operators :math:`a_1` and
-    :math:`a_2`. If a density matrix is given the expectation values are
-    calculated, otherwise a matrix with operators is returned.
-
-    Parameters
-    ----------
-    a1 : Qobj
-        Field operator for mode 1.
-    a2 : Qobj
-        Field operator for mode 2.
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-
-    Returns
-    -------
-    cov_mat : ndarray 
-        Array of complex numbers or Qobj's
-        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
-        of operators.
-    """
-    basis = [a1, a1.dag(), a2, a2.dag()]
-    return correlation_matrix(basis, rho)
-
-
-def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
-    """
-    Calculate the quadrature correlation matrix with given field operators
-    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
-    values are calculated, otherwise a matrix with operators is returned.
-
-    Parameters
-    ----------
-    a1 : Qobj
-        Field operator for mode 1.
-    a2 : Qobj
-        Field operator for mode 2.
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation 
-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
-        value `hbar=1`. 
-
-    Returns
-    -------
-    corr_mat : ndarray 
-        Array of complex numbers or Qobj's
-        A 2-dimensional *array* of covariance values for the field quadratures,
-        or, if rho=0, a matrix of operators.
-
-    """
-    x1 = (a1 + a1.dag()) / g
-    p1 = -1j * (a1 - a1.dag()) / g
-    x2 = (a2 + a2.dag()) / g
-    p2 = -1j * (a2 - a2.dag()) / g
-    basis = [x1, p1, x2, p2]
-    return correlation_matrix(basis, rho)
-
-
-def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
-    r"""
-    Calculates the Wigner covariance matrix
-    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
-    the quadrature correlation matrix
-    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
-    \langle R_{i}\rangle \langle R_{j}\rangle`, where
-    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
-    for the two modes.
-
-    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
-    for the two modes are supplied instead, the quadrature correlation matrix
-    is constructed from the annihilation operators before then the covariance
-    matrix is calculated.
-
-    Parameters
-    ----------
-
-    a1 : Qobj
-        Field operator for mode 1.
-
-    a2 : Qobj
-        Field operator for mode 2.
-
-    R : ndarray
-        The quadrature correlation matrix.
-
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation 
-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
-        value `hbar=1`. 
-
-    Returns
-    -------
-    cov_mat : ndarray
-        A 2-dimensional array of covariance values.
-
-    """
-    if R is not None:
-        if rho is None:
-            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
-                              for i in range(4)]
-                             for j in range(4)], dtype=np.float64)
-        else:
-            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
-                              for i in range(4)]
-                             for j in range(4)], dtype=np.float64)
-    elif a1 is not None and a2 is not None:
-        if rho is not None:
-            x1 = (a1 + a1.dag()) / g
-            p1 = -1j * (a1 - a1.dag()) / g
-            x2 = (a2 + a2.dag()) / g
-            p2 = -1j * (a2 - a2.dag()) / g
-            return covariance_matrix([x1, p1, x2, p2], rho)
-        else:
-            raise ValueError("Must give rho if using field operators " +
-                             "(a1 and a2)")
-    else:
-        raise ValueError("Must give either field operators (a1 and a2) " +
-                         "or a precomputed correlation matrix (R)")
-
-
-def logarithmic_negativity(V, g=np.sqrt(2)):
-    """
-    Calculates the logarithmic negativity given a symmetrized covariance
-    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
-    the two-mode field state that is described by `V` must be Gaussian for this
-    function to applicable.
-
-    Parameters
-    ----------
-
-    V : *2d array*
-        The covariance matrix.
-
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation 
-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
-        value `hbar=1`. 
-
-    Returns
-    -------
-
-    N : float 
-        The logarithmic negativity for the two-mode Gaussian state
-        that is described by the the Wigner covariance matrix V.
-
-    """
-    A = 0.5 * V[0:2, 0:2] * g ** 2
-    B = 0.5 * V[2:4, 2:4] * g ** 2
-    C = 0.5 * V[0:2, 2:4] * g ** 2
-    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
-    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
-    if nu_ < 0.0:
-        return 0.0
-    nu = np.sqrt(nu_)
-    lognu = -np.log(2 * nu)
-    logneg = max(0, lognu)
-    return logneg
+"""
+This module contains a collection functions for calculating continuous variable
+quantities from fock-basis representation of the state of multi-mode fields.
+"""
+
+__all__ = ['correlation_matrix', 'covariance_matrix',
+           'correlation_matrix_field', 'correlation_matrix_quadrature',
+           'wigner_covariance_matrix', 'logarithmic_negativity']
+
+from . import expect
+import numpy as np
+
+
+def correlation_matrix(basis, rho=None):
+    r"""
+    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
+    matrix:
+
+    .. math::
+
+        C_{mn} = \langle a_m a_n \rangle
+
+    Parameters
+    ----------
+    basis : list
+        List of operators that defines the basis for the correlation matrix.
+    rho : Qobj
+        Density matrix for which to calculate the correlation matrix. If
+        `rho` is `None`, then a matrix of correlation matrix operators is
+        returned instead of expectation values of those operators.
+
+    Returns
+    -------
+    corr_mat : ndarray
+        A 2-dimensional *array* of correlation values or operators.
+
+
+    """
+    if rho is None:
+        # return array of operators
+        out = np.empty((len(basis), len(basis)), dtype=object)
+        for i, op2 in enumerate(basis):
+            out[i, :] = [op1 * op2 for op1 in basis]
+        return out
+    else:
+        # return array of expectation values
+        return np.array([[expect(op1 * op2, rho)
+                          for op1 in basis] for op2 in basis])
+
+
+def covariance_matrix(basis, rho, symmetrized=True):
+    r"""
+    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
+    matrix:
+
+    .. math::
+
+        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
+        \langle a_m \rangle \langle a_n\rangle
+
+    or, if of the optional argument `symmetrized=False`,
+
+    .. math::
+
+        V_{mn} = \langle a_m a_n\rangle -
+        \langle a_m \rangle \langle a_n\rangle
+
+    Parameters
+    ----------
+    basis : list
+        List of operators that defines the basis for the covariance matrix.
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+    symmetrized : bool {True, False}
+        Flag indicating whether the symmetrized (default) or non-symmetrized
+        correlation matrix is to be calculated.
+
+    Returns
+    -------
+    corr_mat : ndarray
+        A 2-dimensional array of covariance values.
+
+    """
+    if symmetrized:
+        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
+                          expect(op1, rho) * expect(op2, rho)
+                          for op1 in basis] for op2 in basis])
+    else:
+        return np.array([[expect(op1 * op2, rho) -
+                          expect(op1, rho) * expect(op2, rho)
+                          for op1 in basis] for op2 in basis])
+
+
+def correlation_matrix_field(a1, a2, rho=None):
+    """
+    Calculates the correlation matrix for given field operators :math:`a_1` and
+    :math:`a_2`. If a density matrix is given the expectation values are
+    calculated, otherwise a matrix with operators is returned.
+
+    Parameters
+    ----------
+    a1 : Qobj
+        Field operator for mode 1.
+    a2 : Qobj
+        Field operator for mode 2.
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+
+    Returns
+    -------
+    cov_mat : ndarray 
+        Array of complex numbers or Qobj's
+        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
+        of operators.
+    """
+    basis = [a1, a1.dag(), a2, a2.dag()]
+    return correlation_matrix(basis, rho)
+
+
+def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
+    """
+    Calculate the quadrature correlation matrix with given field operators
+    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
+    values are calculated, otherwise a matrix with operators is returned.
+
+    Parameters
+    ----------
+    a1 : Qobj
+        Field operator for mode 1.
+    a2 : Qobj
+        Field operator for mode 2.
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation 
+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
+        value `hbar=1`. 
+
+    Returns
+    -------
+    corr_mat : ndarray 
+        Array of complex numbers or Qobj's
+        A 2-dimensional *array* of covariance values for the field quadratures,
+        or, if rho=0, a matrix of operators.
+
+    """
+    x1 = (a1 + a1.dag()) / g
+    p1 = -1j * (a1 - a1.dag()) / g
+    x2 = (a2 + a2.dag()) / g
+    p2 = -1j * (a2 - a2.dag()) / g
+    basis = [x1, p1, x2, p2]
+    return correlation_matrix(basis, rho)
+
+
+def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
+    r"""
+    Calculates the Wigner covariance matrix
+    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
+    the quadrature correlation matrix
+    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
+    \langle R_{i}\rangle \langle R_{j}\rangle`, where
+    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
+    for the two modes.
+
+    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
+    for the two modes are supplied instead, the quadrature correlation matrix
+    is constructed from the annihilation operators before then the covariance
+    matrix is calculated.
+
+    Parameters
+    ----------
+
+    a1 : Qobj
+        Field operator for mode 1.
+
+    a2 : Qobj
+        Field operator for mode 2.
+
+    R : ndarray
+        The quadrature correlation matrix.
+
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation 
+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
+        value `hbar=1`. 
+
+    Returns
+    -------
+    cov_mat : ndarray
+        A 2-dimensional array of covariance values.
+
+    """
+    if R is not None:
+        if rho is None:
+            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
+                              for i in range(4)]
+                             for j in range(4)], dtype=np.float64)
+        else:
+            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
+                              for i in range(4)]
+                             for j in range(4)], dtype=np.float64)
+    elif a1 is not None and a2 is not None:
+        if rho is not None:
+            x1 = (a1 + a1.dag()) / g
+            p1 = -1j * (a1 - a1.dag()) / g
+            x2 = (a2 + a2.dag()) / g
+            p2 = -1j * (a2 - a2.dag()) / g
+            return covariance_matrix([x1, p1, x2, p2], rho)
+        else:
+            raise ValueError("Must give rho if using field operators " +
+                             "(a1 and a2)")
+    else:
+        raise ValueError("Must give either field operators (a1 and a2) " +
+                         "or a precomputed correlation matrix (R)")
+
+
+def logarithmic_negativity(V, g=np.sqrt(2)):
+    """
+    Calculates the logarithmic negativity given a symmetrized covariance
+    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
+    the two-mode field state that is described by `V` must be Gaussian for this
+    function to applicable.
+
+    Parameters
+    ----------
+
+    V : *2d array*
+        The covariance matrix.
+
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation 
+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
+        value `hbar=1`. 
+
+    Returns
+    -------
+
+    N : float 
+        The logarithmic negativity for the two-mode Gaussian state
+        that is described by the the Wigner covariance matrix V.
+
+    """
+    A = 0.5 * V[0:2, 0:2] * g ** 2
+    B = 0.5 * V[2:4, 2:4] * g ** 2
+    C = 0.5 * V[0:2, 2:4] * g ** 2
+    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
+    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
+    if nu_ < 0.0:
+        return 0.0
+    nu = np.sqrt(nu_)
+    lognu = -np.log(2 * nu)
+    logneg = max(0, lognu)
+    return logneg
diff --git a/qutip/control.py b/qutip/control.py
index 559a6a8d27..7b3fb74fb1 100644
--- a/qutip/control.py
+++ b/qutip/control.py
@@ -1,13 +1,13 @@
-"""Module replicating the qutip_qtrl package from within qutip."""
-import sys
-
-try:
-    import qutip_qtrl
-    del qutip_qtrl
-    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
-except ImportError:
-    raise ImportError(
-        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
-        "Install it with `pip install qutip-qtrl` (for more details, go to "
-        "https://qutip-qtrl.readthedocs.io/)."
-    )
+"""Module replicating the qutip_qtrl package from within qutip."""
+import sys
+
+try:
+    import qutip_qtrl
+    del qutip_qtrl
+    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
+except ImportError:
+    raise ImportError(
+        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
+        "Install it with `pip install qutip-qtrl` (for more details, go to "
+        "https://qutip-qtrl.readthedocs.io/)."
+    )
diff --git a/qutip/core/__init__.py b/qutip/core/__init__.py
index b12830ba87..dc1835185b 100644
--- a/qutip/core/__init__.py
+++ b/qutip/core/__init__.py
@@ -1,16 +1,16 @@
-from .options import *
-from .coefficient import *
-from .qobj import *
-from .cy.qobjevo import *
-from .expect import *
-from .tensor import *
-from .states import *
-from .operators import *
-from .metrics import *
-from .superoperator import *
-from .superop_reps import *
-from .subsystem_apply import *
-from .blochredfield import *
-from . import gates
-
-del cy  # File in cy are not public facing
+from .options import *
+from .coefficient import *
+from .qobj import *
+from .cy.qobjevo import *
+from .expect import *
+from .tensor import *
+from .states import *
+from .operators import *
+from .metrics import *
+from .superoperator import *
+from .superop_reps import *
+from .subsystem_apply import *
+from .blochredfield import *
+from . import gates
+
+del cy  # File in cy are not public facing
diff --git a/qutip/core/_brtensor.pyx b/qutip/core/_brtensor.pyx
index 530cf63d1b..2578823307 100644
--- a/qutip/core/_brtensor.pyx
+++ b/qutip/core/_brtensor.pyx
@@ -1,337 +1,337 @@
-#cython: language_level=3
-cimport cython
-
-import qutip.core.data as _data
-from qutip.core.data cimport Dense, CSR, Data, idxint, csr
-from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
-from qutip.core._brtools cimport _EigenBasisTransform
-from qutip.core.qobj import Qobj
-
-import numpy as np
-from libcpp.vector cimport vector
-from libc.math cimport fabs, fmin
-
-__all__ = []
-
-
-cpdef enum TensorType:
-    SPARSE = 0
-    DENSE = 1
-    DATA = 2
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
-                         double[:, ::1] skew, double cutoff):
-    """
-    Compute the contribution of A to the Bloch Redfield tensor.
-    Computation are done using dispatched function.
-    """
-    cdef object cutoff_arr
-    cdef int nrows = A.shape[0], a, b, c, d
-    cdef Data S, I, AS, AST, out, C
-    cdef type cls = type(A)
-
-    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
-    I = _data.identity[cls](nrows)
-    AS = _data.multiply(A, S)
-    AST = _data.multiply(A, _data.transpose(S))
-
-    out = _data.kron(AST, _data.transpose(A))
-    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
-    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
-    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
-
-    if cutoff == np.inf:
-        return out
-
-    # The cutoff_arr should be sparse most of the time, but it depend on the
-    # cutoff and we cannot easily guess a nnz to make it efficiently...
-    # But there is probably room from improvement.
-    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
-    for a in range(nrows):
-        for b in range(nrows):
-            for c in range(nrows):
-                for d in range(nrows):
-                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
-                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
-    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
-    return _data.multiply(out, C)
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
-                           double[:, ::1] skew, double cutoff):
-    """
-    Compute the contribution of A to the Bloch Redfield tensor.
-    Allocate a Dense array and fill it.
-    """
-    cdef size_t nrows = A.shape[0]
-    cdef size_t a, b, c, d, k # matrix indexing variables
-    cdef double complex elem
-    cdef double complex[:,:] A_mat, ac_term, bd_term
-    cdef object np2term
-    cdef Dense out
-    cdef double complex[::1, :] out_array
-
-    if type(A) is Dense:
-        A_mat = A.as_ndarray()
-    else:
-        A_mat = A.to_array()
-
-    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
-    out_array = out.as_ndarray()
-
-    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
-    ac_term = np2term[:, :, 0]
-    bd_term = np2term[:, :, 1]
-
-
-    for a in range(nrows):
-        for b in range(nrows-1, -1, -1):
-            if fabs(skew[a, b]) < cutoff:
-                for k in range(nrows):
-                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
-                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
-
-    # TODO: we could use openmp to speed up.
-    for a in range(nrows):
-        for b in range(nrows):
-            for c in range(nrows):
-                for d in range(nrows):
-                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
-                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
-                        elem *= (spectrum[c, a] + spectrum[d, b])
-                        if a == c:
-                            elem = elem - 0.5 * ac_term[d, b]
-                        if b == d:
-                            elem = elem - 0.5 * bd_term[a, c]
-                        out_array[a * nrows + b, c * nrows + d] = elem
-    return out
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
-                          double[:, ::1] skew, double cutoff):
-    """
-    Compute the contribution of A to the Bloch Redfield tensor.
-    Create it as coo pointers and return as CSR.
-    """
-    cdef size_t nrows = A.shape[0]
-    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
-    cdef double complex elem, ac_elem, bd_elem
-    cdef double complex[:,:] A_mat, ac_term, bd_term
-    cdef double dskew
-    cdef object np2term
-    cdef vector[idxint] coo_rows, coo_cols
-    cdef vector[double complex] coo_data
-
-    if type(A) is Dense:
-        A_mat = A.as_ndarray()
-    else:
-        A_mat = A.to_array()
-
-    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
-    ac_term = np2term[:, :, 0]
-    bd_term = np2term[:, :, 1]
-
-    for a in range(nrows):
-        for b in range(nrows-1, -1, -1):
-            if fabs(skew[a, b]) < cutoff:
-                for k in range(nrows):
-                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
-                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
-            elif skew[a, b] > cutoff:
-                break
-
-    # skew[a,b] = w[a] - w[b]
-    # (w[a] - w[b] - w[c] + w[d]) < cutoff
-    # w's are sorted so we can skip part of the loop.
-    for a in range(nrows):
-        for b in range(nrows):
-            d_min = 0
-            for c in range(nrows):
-                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
-                    break
-                for d in range(d_min, nrows):
-                    dskew = skew[a, b] - skew[c, d]
-                    if -dskew > cutoff:
-                        d_min = d
-                    elif fabs(dskew) < cutoff:
-                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
-                        elem *= (spectrum[c, a] + spectrum[d, b])
-                        if a == c:
-                            elem -= 0.5 * ac_term[d, b]
-                        if b == d:
-                            elem -= 0.5 * bd_term[a, c]
-                        if elem != 0:
-                            coo_rows.push_back(a * nrows + b)
-                            coo_cols.push_back(c * nrows + d)
-                            coo_data.push_back(elem)
-                    elif dskew >= cutoff:
-                        break
-
-    return csr.from_coo_pointers(
-        coo_rows.data(), coo_cols.data(), coo_data.data(),
-        nrows*nrows, nrows*nrows, coo_rows.size()
-    )
-
-
-cdef class _BlochRedfieldElement(_BaseElement):
-    """
-    Element for individual Bloch Redfield collapse term.
-
-    The tensor is computed in the ``eig_basis``, but is returned in the outside
-    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
-    on a state expected to be in that basis. It transform the state instead of
-    the tensor as it is usually faster, the state being a density matrix in
-    most cases.
-
-    Diffenrent term can share a same instance of the eigen transform tool
-    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
-    only once even when needed by multiple terms.
-    """
-    cdef readonly _EigenBasisTransform H
-    cdef readonly QobjEvo a_op
-    cdef readonly Coefficient spectra
-    cdef readonly double sec_cutoff
-    cdef readonly size_t nrows
-    cdef readonly (idxint, idxint) shape
-    cdef readonly list dims
-    cdef readonly object np_datas
-    cdef readonly double[:, ::1] skew
-    cdef readonly double[:, ::1] spectrum
-    cdef readonly bint eig_basis
-    cdef readonly TensorType tensortype
-
-    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
-                 dtype=None):
-        if isinstance(H, _EigenBasisTransform):
-            self.H = H
-        else:
-            self.H = _EigenBasisTransform(H)
-
-        self.a_op = a_op
-        self.spectra = spectra
-        self.sec_cutoff = sec_cutoff
-        self.eig_basis = eig_basis
-        self.nrows = a_op.shape[0]
-        self.dims = [a_op.dims, a_op.dims]
-
-        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
-        self.tensortype = {
-            'sparse': SPARSE,
-            'dense': DENSE,
-            'data': DATA
-        }[dtype]
-
-        # Allocate some array
-        # Let numpy manage memory
-        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
-                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
-        self.skew = self.np_datas[0]
-        self.spectrum = self.np_datas[1]
-
-    cpdef double _compute_spectrum(self, double t) except *:
-        "Compute the skew, spectrum and dw_min"
-        cdef Coefficient spec
-        cdef double dw_min = np.inf
-        eigvals = self.H.eigenvalues(t)
-
-        for col in range(0, self.nrows):
-            self.skew[col, col] = 0.
-            self.spectrum[col, col] = self.spectra(t, w=0).real
-            for row in range(col, self.nrows):
-                dw = eigvals[row] - eigvals[col]
-                self.skew[row, col] = dw
-                self.skew[col, row] = -dw
-                if dw != 0:
-                    dw_min = fmin(fabs(dw), dw_min)
-                self.spectrum[row, col] = self.spectra(t, w=dw).real
-                self.spectrum[col, row] = self.spectra(t, w=-dw).real
-        return dw_min
-
-    cdef Data _br_term(self, Data A_eig, double cutoff):
-        if self.tensortype == DENSE:
-            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
-        elif self.tensortype == SPARSE:
-            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
-        elif self.tensortype == DATA:
-            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
-        raise ValueError('Invalid tensortype')
-
-    cpdef object qobj(self, t):
-        return Qobj(self.data(t), dims=self.dims, type="super",
-                    copy=False, superrep="super")
-
-    cpdef object coeff(self, t):
-        return 1.
-
-    cpdef Data data(self, t):
-        cdef size_t i
-        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
-        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
-        BR_eig = self._br_term(A_eig, cutoff)
-        if self.eig_basis:
-            return BR_eig
-        return self.H.from_eigbasis(t, BR_eig)
-
-    cdef Data matmul_data_t(self, t, Data state, Data out=None):
-        cdef size_t i
-        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
-        cdef Data A_eig, BR_eig
-
-        if not self.eig_basis:
-            state = self.H.to_eigbasis(t, state)
-        if not self.eig_basis and out is not None:
-            out = self.H.to_eigbasis(t, out)
-        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
-        BR_eig = self._br_term(A_eig, cutoff)
-        out = _data.add(_data.matmul(BR_eig, state), out)
-        if not self.eig_basis:
-            out = self.H.from_eigbasis(t, out)
-        return out
-
-    def linear_map(self, f, anti=False):
-        return _MapElement(self, [f])
-
-    def replace_arguments(self, args, cache=None):
-        if cache is None:
-            return _BlochRedfieldElement(
-                self.H,
-                QobjEvo(self.a_op, args=args),
-                self.spectra,
-                self.sec_cutoff
-            )
-        H = None
-        for old, new in cache:
-            if old is self:
-                return new
-            if old is self.H:
-                H = new
-        if H is None:
-            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
-                                     type(self.H.oper) is CSR)
-        new = _BlochRedfieldElement(
-            H, QobjEvo(self.a_op, args=args),
-            self.spectra.replace_arguments(**args), self.sec_cutoff
-        )
-        cache.append((self, new))
-        cache.append((self.H, H))
-        return new
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    def __mul__(left, right):
-        cdef _MapElement out
-        if type(left) is _BlochRedfieldElement:
-            out = _MapElement(left, [], right)
-        if type(right) is _BlochRedfieldElement:
-            out = _MapElement(right, [], left)
-        return out
+#cython: language_level=3
+cimport cython
+
+import qutip.core.data as _data
+from qutip.core.data cimport Dense, CSR, Data, idxint, csr
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
+from qutip.core._brtools cimport _EigenBasisTransform
+from qutip.core.qobj import Qobj
+
+import numpy as np
+from libcpp.vector cimport vector
+from libc.math cimport fabs, fmin
+
+__all__ = []
+
+
+cpdef enum TensorType:
+    SPARSE = 0
+    DENSE = 1
+    DATA = 2
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
+                         double[:, ::1] skew, double cutoff):
+    """
+    Compute the contribution of A to the Bloch Redfield tensor.
+    Computation are done using dispatched function.
+    """
+    cdef object cutoff_arr
+    cdef int nrows = A.shape[0], a, b, c, d
+    cdef Data S, I, AS, AST, out, C
+    cdef type cls = type(A)
+
+    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
+    I = _data.identity[cls](nrows)
+    AS = _data.multiply(A, S)
+    AST = _data.multiply(A, _data.transpose(S))
+
+    out = _data.kron(AST, _data.transpose(A))
+    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
+    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
+    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
+
+    if cutoff == np.inf:
+        return out
+
+    # The cutoff_arr should be sparse most of the time, but it depend on the
+    # cutoff and we cannot easily guess a nnz to make it efficiently...
+    # But there is probably room from improvement.
+    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
+    for a in range(nrows):
+        for b in range(nrows):
+            for c in range(nrows):
+                for d in range(nrows):
+                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
+                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
+    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
+    return _data.multiply(out, C)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
+                           double[:, ::1] skew, double cutoff):
+    """
+    Compute the contribution of A to the Bloch Redfield tensor.
+    Allocate a Dense array and fill it.
+    """
+    cdef size_t nrows = A.shape[0]
+    cdef size_t a, b, c, d, k # matrix indexing variables
+    cdef double complex elem
+    cdef double complex[:,:] A_mat, ac_term, bd_term
+    cdef object np2term
+    cdef Dense out
+    cdef double complex[::1, :] out_array
+
+    if type(A) is Dense:
+        A_mat = A.as_ndarray()
+    else:
+        A_mat = A.to_array()
+
+    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
+    out_array = out.as_ndarray()
+
+    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
+    ac_term = np2term[:, :, 0]
+    bd_term = np2term[:, :, 1]
+
+
+    for a in range(nrows):
+        for b in range(nrows-1, -1, -1):
+            if fabs(skew[a, b]) < cutoff:
+                for k in range(nrows):
+                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
+                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
+
+    # TODO: we could use openmp to speed up.
+    for a in range(nrows):
+        for b in range(nrows):
+            for c in range(nrows):
+                for d in range(nrows):
+                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
+                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
+                        elem *= (spectrum[c, a] + spectrum[d, b])
+                        if a == c:
+                            elem = elem - 0.5 * ac_term[d, b]
+                        if b == d:
+                            elem = elem - 0.5 * bd_term[a, c]
+                        out_array[a * nrows + b, c * nrows + d] = elem
+    return out
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
+                          double[:, ::1] skew, double cutoff):
+    """
+    Compute the contribution of A to the Bloch Redfield tensor.
+    Create it as coo pointers and return as CSR.
+    """
+    cdef size_t nrows = A.shape[0]
+    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
+    cdef double complex elem, ac_elem, bd_elem
+    cdef double complex[:,:] A_mat, ac_term, bd_term
+    cdef double dskew
+    cdef object np2term
+    cdef vector[idxint] coo_rows, coo_cols
+    cdef vector[double complex] coo_data
+
+    if type(A) is Dense:
+        A_mat = A.as_ndarray()
+    else:
+        A_mat = A.to_array()
+
+    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
+    ac_term = np2term[:, :, 0]
+    bd_term = np2term[:, :, 1]
+
+    for a in range(nrows):
+        for b in range(nrows-1, -1, -1):
+            if fabs(skew[a, b]) < cutoff:
+                for k in range(nrows):
+                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
+                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
+            elif skew[a, b] > cutoff:
+                break
+
+    # skew[a,b] = w[a] - w[b]
+    # (w[a] - w[b] - w[c] + w[d]) < cutoff
+    # w's are sorted so we can skip part of the loop.
+    for a in range(nrows):
+        for b in range(nrows):
+            d_min = 0
+            for c in range(nrows):
+                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
+                    break
+                for d in range(d_min, nrows):
+                    dskew = skew[a, b] - skew[c, d]
+                    if -dskew > cutoff:
+                        d_min = d
+                    elif fabs(dskew) < cutoff:
+                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
+                        elem *= (spectrum[c, a] + spectrum[d, b])
+                        if a == c:
+                            elem -= 0.5 * ac_term[d, b]
+                        if b == d:
+                            elem -= 0.5 * bd_term[a, c]
+                        if elem != 0:
+                            coo_rows.push_back(a * nrows + b)
+                            coo_cols.push_back(c * nrows + d)
+                            coo_data.push_back(elem)
+                    elif dskew >= cutoff:
+                        break
+
+    return csr.from_coo_pointers(
+        coo_rows.data(), coo_cols.data(), coo_data.data(),
+        nrows*nrows, nrows*nrows, coo_rows.size()
+    )
+
+
+cdef class _BlochRedfieldElement(_BaseElement):
+    """
+    Element for individual Bloch Redfield collapse term.
+
+    The tensor is computed in the ``eig_basis``, but is returned in the outside
+    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
+    on a state expected to be in that basis. It transform the state instead of
+    the tensor as it is usually faster, the state being a density matrix in
+    most cases.
+
+    Diffenrent term can share a same instance of the eigen transform tool
+    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
+    only once even when needed by multiple terms.
+    """
+    cdef readonly _EigenBasisTransform H
+    cdef readonly QobjEvo a_op
+    cdef readonly Coefficient spectra
+    cdef readonly double sec_cutoff
+    cdef readonly size_t nrows
+    cdef readonly (idxint, idxint) shape
+    cdef readonly list dims
+    cdef readonly object np_datas
+    cdef readonly double[:, ::1] skew
+    cdef readonly double[:, ::1] spectrum
+    cdef readonly bint eig_basis
+    cdef readonly TensorType tensortype
+
+    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
+                 dtype=None):
+        if isinstance(H, _EigenBasisTransform):
+            self.H = H
+        else:
+            self.H = _EigenBasisTransform(H)
+
+        self.a_op = a_op
+        self.spectra = spectra
+        self.sec_cutoff = sec_cutoff
+        self.eig_basis = eig_basis
+        self.nrows = a_op.shape[0]
+        self.dims = [a_op.dims, a_op.dims]
+
+        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
+        self.tensortype = {
+            'sparse': SPARSE,
+            'dense': DENSE,
+            'data': DATA
+        }[dtype]
+
+        # Allocate some array
+        # Let numpy manage memory
+        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
+                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
+        self.skew = self.np_datas[0]
+        self.spectrum = self.np_datas[1]
+
+    cpdef double _compute_spectrum(self, double t) except *:
+        "Compute the skew, spectrum and dw_min"
+        cdef Coefficient spec
+        cdef double dw_min = np.inf
+        eigvals = self.H.eigenvalues(t)
+
+        for col in range(0, self.nrows):
+            self.skew[col, col] = 0.
+            self.spectrum[col, col] = self.spectra(t, w=0).real
+            for row in range(col, self.nrows):
+                dw = eigvals[row] - eigvals[col]
+                self.skew[row, col] = dw
+                self.skew[col, row] = -dw
+                if dw != 0:
+                    dw_min = fmin(fabs(dw), dw_min)
+                self.spectrum[row, col] = self.spectra(t, w=dw).real
+                self.spectrum[col, row] = self.spectra(t, w=-dw).real
+        return dw_min
+
+    cdef Data _br_term(self, Data A_eig, double cutoff):
+        if self.tensortype == DENSE:
+            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
+        elif self.tensortype == SPARSE:
+            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
+        elif self.tensortype == DATA:
+            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
+        raise ValueError('Invalid tensortype')
+
+    cpdef object qobj(self, t):
+        return Qobj(self.data(t), dims=self.dims, type="super",
+                    copy=False, superrep="super")
+
+    cpdef object coeff(self, t):
+        return 1.
+
+    cpdef Data data(self, t):
+        cdef size_t i
+        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
+        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
+        BR_eig = self._br_term(A_eig, cutoff)
+        if self.eig_basis:
+            return BR_eig
+        return self.H.from_eigbasis(t, BR_eig)
+
+    cdef Data matmul_data_t(self, t, Data state, Data out=None):
+        cdef size_t i
+        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
+        cdef Data A_eig, BR_eig
+
+        if not self.eig_basis:
+            state = self.H.to_eigbasis(t, state)
+        if not self.eig_basis and out is not None:
+            out = self.H.to_eigbasis(t, out)
+        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
+        BR_eig = self._br_term(A_eig, cutoff)
+        out = _data.add(_data.matmul(BR_eig, state), out)
+        if not self.eig_basis:
+            out = self.H.from_eigbasis(t, out)
+        return out
+
+    def linear_map(self, f, anti=False):
+        return _MapElement(self, [f])
+
+    def replace_arguments(self, args, cache=None):
+        if cache is None:
+            return _BlochRedfieldElement(
+                self.H,
+                QobjEvo(self.a_op, args=args),
+                self.spectra,
+                self.sec_cutoff
+            )
+        H = None
+        for old, new in cache:
+            if old is self:
+                return new
+            if old is self.H:
+                H = new
+        if H is None:
+            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
+                                     type(self.H.oper) is CSR)
+        new = _BlochRedfieldElement(
+            H, QobjEvo(self.a_op, args=args),
+            self.spectra.replace_arguments(**args), self.sec_cutoff
+        )
+        cache.append((self, new))
+        cache.append((self.H, H))
+        return new
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    def __mul__(left, right):
+        cdef _MapElement out
+        if type(left) is _BlochRedfieldElement:
+            out = _MapElement(left, [], right)
+        if type(right) is _BlochRedfieldElement:
+            out = _MapElement(right, [], left)
+        return out
diff --git a/qutip/core/_brtools.pxd b/qutip/core/_brtools.pxd
index ca9e3dd3ee..508d84603d 100644
--- a/qutip/core/_brtools.pxd
+++ b/qutip/core/_brtools.pxd
@@ -1,32 +1,32 @@
-#cython: language_level=3
-from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.data cimport Data
-
-cdef class SpectraCoefficient(Coefficient):
-    cdef Coefficient coeff_t
-    cdef Coefficient coeff_w
-    cdef double w
-
-cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
-
-cdef class _EigenBasisTransform:
-    cdef:
-        QobjEvo oper
-        int size
-        readonly bint isconstant
-        double _t
-        object _eigvals  # np.ndarray
-        Data _evecs, _evecs_inv
-
-    cpdef object eigenvalues(self, double t)
-    cpdef Data evecs(self, double t)
-
-    cpdef Data to_eigbasis(self, double t, Data fock)
-    cpdef Data from_eigbasis(self, double t, Data eig)
-
-    cdef Data _inv(self, double t)
-    cdef void _compute_eigen(self, double t) except *
-
-    cdef Data _S_converter(self, double t)
-    cdef Data _S_converter_inverse(self, double t)
+#cython: language_level=3
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.data cimport Data
+
+cdef class SpectraCoefficient(Coefficient):
+    cdef Coefficient coeff_t
+    cdef Coefficient coeff_w
+    cdef double w
+
+cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
+
+cdef class _EigenBasisTransform:
+    cdef:
+        QobjEvo oper
+        int size
+        readonly bint isconstant
+        double _t
+        object _eigvals  # np.ndarray
+        Data _evecs, _evecs_inv
+
+    cpdef object eigenvalues(self, double t)
+    cpdef Data evecs(self, double t)
+
+    cpdef Data to_eigbasis(self, double t, Data fock)
+    cpdef Data from_eigbasis(self, double t, Data eig)
+
+    cdef Data _inv(self, double t)
+    cdef void _compute_eigen(self, double t) except *
+
+    cdef Data _S_converter(self, double t)
+    cdef Data _S_converter_inverse(self, double t)
diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
index a7e379c964..98737b0fb0 100644
--- a/qutip/core/_brtools.pyx
+++ b/qutip/core/_brtools.pyx
@@ -1,327 +1,327 @@
-#cython: language_level=3
-from libc.math cimport fabs, fmin
-from libc.float cimport DBL_MAX
-
-cimport numpy as cnp
-import numpy as np
-
-cimport cython
-
-from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.data cimport Data, Dense, idxint
-import qutip.core.data as _data
-from qutip.core import Qobj
-from scipy.linalg cimport cython_blas as blas
-
-
-__all__ = ['SpectraCoefficient']
-
-
-cdef class SpectraCoefficient(Coefficient):
-    """
-    Change a Coefficient with `t` dependence to one with `w` dependence to use
-    in Bloch-Redfield tensor to allow array based coefficients to be used as
-    spectral functions.
-    If 2 coefficients are passed, the first one is the frequence response and
-    the second is the time response.
-    """
-    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
-        self.coeff_t = coeff_t
-        self.coeff_w = coeff_w
-        self.w = w
-
-    cdef complex _call(self, double t) except *:
-        if self.coeff_t is None:
-            return self.coeff_w(self.w)
-        return self.coeff_t(t) * self.coeff_w(self.w)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
-
-    def replace_arguments(self, _args=None, *, w=None, **kwargs):
-        if _args:
-            kwargs.update(_args)
-        if kwargs:
-            return SpectraCoefficient(
-                self.coeff_w.replace(**kwargs),
-                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
-                kwargs.get('w', w or self.w)
-              )
-        if w is not None:
-            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
-        return self
-
-
-@cython.overflowcheck(True)
-cdef size_t _mul_checked(size_t a, size_t b) except? -1:
-    return a * b
-
-
-cdef Data _apply_trans(Data original, int trans):
-    """helper function for matmul_var_data, apply transform."""
-    cdef Data out
-    if trans == 0:
-        out = original
-    elif trans == 1:
-        out = original.transpose()
-    elif trans == 2:
-        out = original.conj()
-    elif trans == 3:
-        out = original.adjoint()
-    return out
-
-
-cdef char _fetch_trans_code(int trans):
-    """helper function for matmul_var_Dense, fetch the blas flag byte"""
-    if trans == 0:
-        return b'N'
-    elif trans == 1:
-        return b'T'
-    elif trans == 3:
-        return b'C'
-
-
-cpdef Data matmul_var_data(Data left, Data right,
-                           int transleft, int transright):
-    """
-    matmul which input matrices can be transposed or adjoint.
-    out = transleft(left) @ transright(right)
-
-    with trans[left, right]:
-        0 : Normal
-        1 : Transpose
-        2 : Conjugate
-        3 : Adjoint
-    """
-    # Should this be supported in data.matmul?
-    # A.dag() @ A is quite common.
-    cdef int size
-    cdef double complex beta
-    cdef char left_code, right_code
-    if (
-        type(left) is Dense
-        and type(right) is Dense
-        and left.shape[0] == left.shape[1]
-        and left.shape[0] == right.shape[0]
-        and left.shape[0] == right.shape[1]
-    ):
-        return matmul_var_Dense(left, right, transleft, transright)
-    left = _apply_trans(left, transleft)
-    right = _apply_trans(right, transright)
-    return _data.matmul(left, right)
-
-
-cdef Dense matmul_var_Dense(Dense left, Dense right,
-                            int transleft, int transright):
-    """
-    matmul which input matrices can be transposed or adjoint.
-    out = transleft(left) @ transright(right)
-
-    with trans[left, right]:
-       0 : Normal
-       1 : Transpose
-       2 : Conjugate
-       3 : Adjoint
-    """
-    # blas support matmul for normal, transpose, adjoint for fortran ordered
-    # matrices.
-    if not (
-        left.shape[0] == left.shape[1]
-        and left.shape[0] == right.shape[0]
-        and left.shape[0] == right.shape[1]
-    ):
-        raise ValueError("Only implemented for square operators")
-    cdef Dense out, a, b
-    cdef double complex alpha = 1., beta = 0.
-    cdef int tleft, tright, size = left.shape[0]
-
-    # Since fortran to C equivalent to transpose, fix the codes to fortran
-    tleft = transleft ^ (not left.fortran)
-    tright = transright ^ (not right.fortran)
-
-    # blas.zgemm does not support adjoint.
-    if tleft + tright == 5:
-        # adjoint and conjugate, we can't transpose the output to use zgemm
-        out = matmul_var_data(left, right, transleft-2, transright-2)
-        return out.conj()
-    if tleft == 2 or tright == 2:
-        # Need a conjugate, we compute the transpose of the desired results.
-        # A.conj @ B^op -> (B^T^op @ A.dag)^T
-        out = _data.dense.empty(left.shape[0], right.shape[1], False)
-        a, b = right, left
-        tleft, tright = tright ^ 1, tleft ^ 1
-    else:
-        out = _data.dense.empty(left.shape[0], right.shape[1], True)
-        a, b = left, right
-
-    left_code = _fetch_trans_code(tleft)
-    right_code = _fetch_trans_code(tright)
-    blas.zgemm(&left_code, &right_code, &size, &size, &size,
-               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
-               &beta, (<Dense> out).data, &size)
-
-    return out
-
-
-class _eigen_qevo:
-    """
-    Callable function to represent the eigenvectors of a QobjEvo at a time
-    ``t``.
-    """
-    def __init__(self, qevo):
-        self.qevo = QobjEvo(qevo)  # Force a copy
-        self.args = None
-        # This is a base conversion operator, the eigen basis part of the dims
-        # are flat.
-        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
-
-    def __call__(self, t, args):
-        if args is not self.args:
-            self.args = args
-            self.qevo.arguments(self.args)
-        _, data = _data.eigs(self.qevo._call(t), True, True)
-        return Qobj(data, copy=False, dims=self.out_dims)
-
-
-cdef class _EigenBasisTransform:
-    """
-    For an hermitian operator, compute the eigenvalues and eigenstates and do
-    the base change to and from that eigenbasis.
-
-    parameter
-    ---------
-    oper : QobjEvo
-        Hermitian operator for which to compute the eigenbasis.
-
-    sparse : bool [False]
-        Whether to use sparse solver for eigen decomposition.
-    """
-    def __init__(self, QobjEvo oper, bint sparse=False):
-        if oper.dims[0] != oper.dims[1]:
-            raise ValueError
-        if type(oper(0).data) is _data.CSR and not sparse:
-            oper = oper.to(Dense)
-        self.oper = oper
-        self.isconstant = oper.isconstant
-        self.size = oper.shape[0]
-
-        if oper.isconstant:
-            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
-                                                    True, True)
-        else:
-            self._evecs = None
-            self._eigvals = None
-
-        self._t = np.nan
-        self._evecs_inv = None
-
-    def as_Qobj(self):
-        """Make an Qobj or QobjEvo of the eigenvectors."""
-        if self.isconstant:
-            return Qobj(self.evecs(0), dims=self.oper.dims)
-        else:
-            return QobjEvo(_eigen_qevo(self.oper))
-
-    cdef void _compute_eigen(self, double t) except *:
-        if self._t != t and not self.isconstant:
-            self._t = t
-            self._evecs_inv = None
-            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
-
-    cpdef object eigenvalues(self, double t):
-        """
-        Return the eigenvalues at ``t``.
-        """
-        self._compute_eigen(t)
-        return self._eigvals
-
-    cpdef Data evecs(self, double t):
-        """
-        Return the eigenstates at ``t``.
-        """
-        self._compute_eigen(t)
-        return self._evecs
-
-    cdef Data _inv(self, double t):
-        if self._evecs_inv is None:
-            self._evecs_inv = self.evecs(t).adjoint()
-        return self._evecs_inv
-
-    cdef Data _S_converter(self, double t):
-        return _data.kron(self.evecs(t).transpose(), self._inv(t))
-
-    cdef Data _S_converter_inverse(self, double t):
-        return _data.kron(self._inv(t).transpose(), self.evecs(t))
-
-    cpdef Data to_eigbasis(self, double t, Data fock):
-        """
-        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
-        ``oper(t)`` is diagonalized.
-        """
-        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
-        # Blas include A.dag @ B in one operation. We use it if we can so we
-        # don't make unneeded copy of evecs.
-        cdef Data temp
-        if fock.shape[0] == self.size and fock.shape[1] == 1:
-            return matmul_var_data(self.evecs(t), fock, 3, 0)
-
-        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
-            if type(fock) is Dense and (<Dense> fock).fortran:
-                fock = _data.column_unstack_dense(fock, self.size, True)
-                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-                                    self.evecs(t))
-                fock = _data.column_stack_dense(fock, True)
-            else:
-                fock = _data.column_unstack(fock, self.size)
-                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-                                    self.evecs(t))
-            if type(temp) is Dense:
-                return _data.column_stack_dense(temp, True)
-            return _data.column_stack(temp)
-
-        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
-            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-                                self.evecs(t))
-
-        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
-            temp = self._S_converter_inverse(t)
-            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
-
-        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
-                         "can't guess type from shape.")
-
-    cpdef Data from_eigbasis(self, double t, Data eig):
-        """
-        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
-        ``oper(t)`` is diagonalized to the outside basis.
-        """
-        cdef Data temp
-        if eig.shape[0] == self.size and eig.shape[1] == 1:
-            return _data.matmul(self.evecs(t), eig)
-
-        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
-            if type(eig) is Dense and (<Dense> eig).fortran:
-                eig = _data.column_unstack_dense(eig, self.size, True)
-                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
-                                  self.evecs(t), 0, 3)
-                eig = _data.column_stack_dense(eig, True)
-            else:
-                eig = _data.column_unstack(eig, self.size)
-                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
-                                  self.evecs(t), 0, 3)
-            if type(temp) is Dense:
-                return _data.column_stack_dense(temp, True)
-            return _data.column_stack(temp)
-
-        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
-            temp = self.evecs(t)
-            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
-
-        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
-            temp = self._S_converter_inverse(t)
-            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
-
-        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
-                         "can't guess type from shape.")
+#cython: language_level=3
+from libc.math cimport fabs, fmin
+from libc.float cimport DBL_MAX
+
+cimport numpy as cnp
+import numpy as np
+
+cimport cython
+
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.data cimport Data, Dense, idxint
+import qutip.core.data as _data
+from qutip.core import Qobj
+from scipy.linalg cimport cython_blas as blas
+
+
+__all__ = ['SpectraCoefficient']
+
+
+cdef class SpectraCoefficient(Coefficient):
+    """
+    Change a Coefficient with `t` dependence to one with `w` dependence to use
+    in Bloch-Redfield tensor to allow array based coefficients to be used as
+    spectral functions.
+    If 2 coefficients are passed, the first one is the frequence response and
+    the second is the time response.
+    """
+    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
+        self.coeff_t = coeff_t
+        self.coeff_w = coeff_w
+        self.w = w
+
+    cdef complex _call(self, double t) except *:
+        if self.coeff_t is None:
+            return self.coeff_w(self.w)
+        return self.coeff_t(t) * self.coeff_w(self.w)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
+
+    def replace_arguments(self, _args=None, *, w=None, **kwargs):
+        if _args:
+            kwargs.update(_args)
+        if kwargs:
+            return SpectraCoefficient(
+                self.coeff_w.replace(**kwargs),
+                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
+                kwargs.get('w', w or self.w)
+              )
+        if w is not None:
+            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
+        return self
+
+
+@cython.overflowcheck(True)
+cdef size_t _mul_checked(size_t a, size_t b) except? -1:
+    return a * b
+
+
+cdef Data _apply_trans(Data original, int trans):
+    """helper function for matmul_var_data, apply transform."""
+    cdef Data out
+    if trans == 0:
+        out = original
+    elif trans == 1:
+        out = original.transpose()
+    elif trans == 2:
+        out = original.conj()
+    elif trans == 3:
+        out = original.adjoint()
+    return out
+
+
+cdef char _fetch_trans_code(int trans):
+    """helper function for matmul_var_Dense, fetch the blas flag byte"""
+    if trans == 0:
+        return b'N'
+    elif trans == 1:
+        return b'T'
+    elif trans == 3:
+        return b'C'
+
+
+cpdef Data matmul_var_data(Data left, Data right,
+                           int transleft, int transright):
+    """
+    matmul which input matrices can be transposed or adjoint.
+    out = transleft(left) @ transright(right)
+
+    with trans[left, right]:
+        0 : Normal
+        1 : Transpose
+        2 : Conjugate
+        3 : Adjoint
+    """
+    # Should this be supported in data.matmul?
+    # A.dag() @ A is quite common.
+    cdef int size
+    cdef double complex beta
+    cdef char left_code, right_code
+    if (
+        type(left) is Dense
+        and type(right) is Dense
+        and left.shape[0] == left.shape[1]
+        and left.shape[0] == right.shape[0]
+        and left.shape[0] == right.shape[1]
+    ):
+        return matmul_var_Dense(left, right, transleft, transright)
+    left = _apply_trans(left, transleft)
+    right = _apply_trans(right, transright)
+    return _data.matmul(left, right)
+
+
+cdef Dense matmul_var_Dense(Dense left, Dense right,
+                            int transleft, int transright):
+    """
+    matmul which input matrices can be transposed or adjoint.
+    out = transleft(left) @ transright(right)
+
+    with trans[left, right]:
+       0 : Normal
+       1 : Transpose
+       2 : Conjugate
+       3 : Adjoint
+    """
+    # blas support matmul for normal, transpose, adjoint for fortran ordered
+    # matrices.
+    if not (
+        left.shape[0] == left.shape[1]
+        and left.shape[0] == right.shape[0]
+        and left.shape[0] == right.shape[1]
+    ):
+        raise ValueError("Only implemented for square operators")
+    cdef Dense out, a, b
+    cdef double complex alpha = 1., beta = 0.
+    cdef int tleft, tright, size = left.shape[0]
+
+    # Since fortran to C equivalent to transpose, fix the codes to fortran
+    tleft = transleft ^ (not left.fortran)
+    tright = transright ^ (not right.fortran)
+
+    # blas.zgemm does not support adjoint.
+    if tleft + tright == 5:
+        # adjoint and conjugate, we can't transpose the output to use zgemm
+        out = matmul_var_data(left, right, transleft-2, transright-2)
+        return out.conj()
+    if tleft == 2 or tright == 2:
+        # Need a conjugate, we compute the transpose of the desired results.
+        # A.conj @ B^op -> (B^T^op @ A.dag)^T
+        out = _data.dense.empty(left.shape[0], right.shape[1], False)
+        a, b = right, left
+        tleft, tright = tright ^ 1, tleft ^ 1
+    else:
+        out = _data.dense.empty(left.shape[0], right.shape[1], True)
+        a, b = left, right
+
+    left_code = _fetch_trans_code(tleft)
+    right_code = _fetch_trans_code(tright)
+    blas.zgemm(&left_code, &right_code, &size, &size, &size,
+               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
+               &beta, (<Dense> out).data, &size)
+
+    return out
+
+
+class _eigen_qevo:
+    """
+    Callable function to represent the eigenvectors of a QobjEvo at a time
+    ``t``.
+    """
+    def __init__(self, qevo):
+        self.qevo = QobjEvo(qevo)  # Force a copy
+        self.args = None
+        # This is a base conversion operator, the eigen basis part of the dims
+        # are flat.
+        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
+
+    def __call__(self, t, args):
+        if args is not self.args:
+            self.args = args
+            self.qevo.arguments(self.args)
+        _, data = _data.eigs(self.qevo._call(t), True, True)
+        return Qobj(data, copy=False, dims=self.out_dims)
+
+
+cdef class _EigenBasisTransform:
+    """
+    For an hermitian operator, compute the eigenvalues and eigenstates and do
+    the base change to and from that eigenbasis.
+
+    parameter
+    ---------
+    oper : QobjEvo
+        Hermitian operator for which to compute the eigenbasis.
+
+    sparse : bool [False]
+        Whether to use sparse solver for eigen decomposition.
+    """
+    def __init__(self, QobjEvo oper, bint sparse=False):
+        if oper.dims[0] != oper.dims[1]:
+            raise ValueError
+        if type(oper(0).data) is _data.CSR and not sparse:
+            oper = oper.to(Dense)
+        self.oper = oper
+        self.isconstant = oper.isconstant
+        self.size = oper.shape[0]
+
+        if oper.isconstant:
+            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
+                                                    True, True)
+        else:
+            self._evecs = None
+            self._eigvals = None
+
+        self._t = np.nan
+        self._evecs_inv = None
+
+    def as_Qobj(self):
+        """Make an Qobj or QobjEvo of the eigenvectors."""
+        if self.isconstant:
+            return Qobj(self.evecs(0), dims=self.oper.dims)
+        else:
+            return QobjEvo(_eigen_qevo(self.oper))
+
+    cdef void _compute_eigen(self, double t) except *:
+        if self._t != t and not self.isconstant:
+            self._t = t
+            self._evecs_inv = None
+            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
+
+    cpdef object eigenvalues(self, double t):
+        """
+        Return the eigenvalues at ``t``.
+        """
+        self._compute_eigen(t)
+        return self._eigvals
+
+    cpdef Data evecs(self, double t):
+        """
+        Return the eigenstates at ``t``.
+        """
+        self._compute_eigen(t)
+        return self._evecs
+
+    cdef Data _inv(self, double t):
+        if self._evecs_inv is None:
+            self._evecs_inv = self.evecs(t).adjoint()
+        return self._evecs_inv
+
+    cdef Data _S_converter(self, double t):
+        return _data.kron(self.evecs(t).transpose(), self._inv(t))
+
+    cdef Data _S_converter_inverse(self, double t):
+        return _data.kron(self._inv(t).transpose(), self.evecs(t))
+
+    cpdef Data to_eigbasis(self, double t, Data fock):
+        """
+        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
+        ``oper(t)`` is diagonalized.
+        """
+        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
+        # Blas include A.dag @ B in one operation. We use it if we can so we
+        # don't make unneeded copy of evecs.
+        cdef Data temp
+        if fock.shape[0] == self.size and fock.shape[1] == 1:
+            return matmul_var_data(self.evecs(t), fock, 3, 0)
+
+        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
+            if type(fock) is Dense and (<Dense> fock).fortran:
+                fock = _data.column_unstack_dense(fock, self.size, True)
+                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+                                    self.evecs(t))
+                fock = _data.column_stack_dense(fock, True)
+            else:
+                fock = _data.column_unstack(fock, self.size)
+                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+                                    self.evecs(t))
+            if type(temp) is Dense:
+                return _data.column_stack_dense(temp, True)
+            return _data.column_stack(temp)
+
+        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
+            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+                                self.evecs(t))
+
+        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
+            temp = self._S_converter_inverse(t)
+            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
+
+        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
+                         "can't guess type from shape.")
+
+    cpdef Data from_eigbasis(self, double t, Data eig):
+        """
+        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
+        ``oper(t)`` is diagonalized to the outside basis.
+        """
+        cdef Data temp
+        if eig.shape[0] == self.size and eig.shape[1] == 1:
+            return _data.matmul(self.evecs(t), eig)
+
+        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
+            if type(eig) is Dense and (<Dense> eig).fortran:
+                eig = _data.column_unstack_dense(eig, self.size, True)
+                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
+                                  self.evecs(t), 0, 3)
+                eig = _data.column_stack_dense(eig, True)
+            else:
+                eig = _data.column_unstack(eig, self.size)
+                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
+                                  self.evecs(t), 0, 3)
+            if type(temp) is Dense:
+                return _data.column_stack_dense(temp, True)
+            return _data.column_stack(temp)
+
+        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
+            temp = self.evecs(t)
+            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
+
+        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
+            temp = self._S_converter_inverse(t)
+            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
+
+        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
+                         "can't guess type from shape.")
diff --git a/qutip/core/blochredfield.py b/qutip/core/blochredfield.py
index e23f6af90a..7a3c6d25e4 100644
--- a/qutip/core/blochredfield.py
+++ b/qutip/core/blochredfield.py
@@ -1,188 +1,188 @@
-import os
-import inspect
-import numpy as np
-from qutip.settings import settings as qset
-
-from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
-from ._brtools import SpectraCoefficient, _EigenBasisTransform
-from .cy.coefficient import InterCoefficient, Coefficient
-from ._brtensor import _BlochRedfieldElement
-
-
-__all__ = ['bloch_redfield_tensor', 'brterm']
-
-
-def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
-                          fock_basis=False, sparse_eigensolver=False,
-                          br_dtype='sparse'):
-    """
-    Calculates the Bloch-Redfield tensor for a system given
-    a set of operators and corresponding spectral functions that describes the
-    system's coupling to its environment.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-        System Hamiltonian.
-
-    a_ops : list of (a_op, spectra)
-        Nested list of system operators that couple to the environment,
-        and the corresponding bath spectra.
-
-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-            The operator coupling to the environment. Must be hermitian.
-
-        spectra : :class:`Coefficient`, func, str
-            The corresponding bath spectra.
-            Can be a :class:`~Coefficient` using an 'w' args, a function of the
-            frequency or a string. The :class:`SpectraCoefficient` can be used for
-            array based coefficient.
-            The spectra can depend on ``t`` if the corresponding
-            ``a_op`` is a :class:`QobjEvo`.
-
-        Example:
-
-        .. code-block::
-
-            a_ops = [
-                (a+a.dag(), ('w>0', args={"w": 0})),
-                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
-                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-            ]
-
-
-    c_ops : list
-        List of system collapse operators.
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    fock_basis : bool {False}
-        Whether to return the tensor in the input basis or the diagonalized
-        basis.
-
-    sparse_eigensolver : bool {False}
-        Whether to use the sparse eigensolver
-
-    br_dtype : ['sparse', 'dense', 'data']
-        Which data type to use when computing the brtensor.
-        With a cutoff 'sparse' is usually the most efficient.
-
-    Returns
-    -------
-    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
-        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
-        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
-        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
-        column.
-    """
-    R = liouvillian(H, c_ops)
-    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
-
-    if fock_basis:
-        for (a_op, spectra) in a_ops:
-            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
-                        br_dtype=br_dtype)
-        return R
-    else:
-        # When the Hamiltonian is time-dependent, the transformation of `L` to
-        # eigenbasis is not optimized.
-        if isinstance(R, QobjEvo):
-            # The `sprepost` will be computed 2 times for each parts of `R`.
-            # Compressing the QobjEvo will lower the number of parts.
-            R.compress()
-        evec = H_transform.as_Qobj()
-        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
-        for (a_op, spectra) in a_ops:
-            R += brterm(H_transform, a_op, spectra, sec_cutoff,
-                        False, br_dtype=br_dtype)[0]
-        return R, H_transform.as_Qobj()
-
-
-def brterm(H, a_op, spectra, sec_cutoff=0.1,
-           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
-    """
-    Calculates the contribution of one coupling operator to the Bloch-Redfield
-    tensor.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-        System Hamiltonian.
-
-    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-        The operator coupling to the environment. Must be hermitian.
-
-    spectra : :class:`Coefficient`, func, str
-        The corresponding bath spectra.
-        Can be a :class:`~Coefficient` using an 'w' args, a function of the
-        frequency or a string. The :class:`SpectraCoefficient` can be used for
-        array based coefficient.
-        The spectra can depend on ``t`` if the corresponding
-        ``a_op`` is a :class:`QobjEvo`.
-
-        Example:
-
-            coefficient('w>0', args={"w": 0})
-            SpectraCoefficient(coefficient(array, tlist=...))
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    fock_basis : bool {False}
-        Whether to return the tensor in the input basis or the diagonalized
-        basis.
-
-    sparse_eigensolver : bool {False}
-        Whether to use the sparse eigensolver on the Hamiltonian.
-
-    br_dtype : ['sparse', 'dense', 'data']
-        Which data type to use when computing the brtensor.
-        With a cutoff 'sparse' is usually the most efficient.
-
-    Returns
-    -------
-    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
-        If ``fock_basis``, return the Bloch Redfield tensor in the outside
-        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
-        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
-        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
-        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
-    """
-    if isinstance(H, _EigenBasisTransform):
-        Hdiag = H
-    else:
-        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
-
-    # convert spectra to Coefficient
-    if isinstance(spectra, str):
-        spectra = coefficient(spectra, args={'w': 0})
-    elif isinstance(spectra, InterCoefficient):
-        spectra = SpectraCoefficient(spectra)
-    elif isinstance(spectra, Coefficient):
-        pass
-    elif callable(spectra):
-        sig = inspect.signature(spectra)
-        if tuple(sig.parameters.keys()) == ("w",):
-            spectra = SpectraCoefficient(coefficient(spectra))
-        else:
-            spectra = coefficient(spectra, args={'w': 0})
-    else:
-        raise TypeError("a_ops's spectra not known")
-
-    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
-    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
-                sec_cutoff, not fock_basis, dtype=br_dtype))
-
-    if (
-        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
-         or isinstance(H, Qobj))
-        and isinstance(a_op, Qobj)
-    ):
-        R = R(0)
-    return R if fock_basis else (R, Hdiag.as_Qobj())
+import os
+import inspect
+import numpy as np
+from qutip.settings import settings as qset
+
+from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
+from ._brtools import SpectraCoefficient, _EigenBasisTransform
+from .cy.coefficient import InterCoefficient, Coefficient
+from ._brtensor import _BlochRedfieldElement
+
+
+__all__ = ['bloch_redfield_tensor', 'brterm']
+
+
+def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
+                          fock_basis=False, sparse_eigensolver=False,
+                          br_dtype='sparse'):
+    """
+    Calculates the Bloch-Redfield tensor for a system given
+    a set of operators and corresponding spectral functions that describes the
+    system's coupling to its environment.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+        System Hamiltonian.
+
+    a_ops : list of (a_op, spectra)
+        Nested list of system operators that couple to the environment,
+        and the corresponding bath spectra.
+
+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+            The operator coupling to the environment. Must be hermitian.
+
+        spectra : :class:`Coefficient`, func, str
+            The corresponding bath spectra.
+            Can be a :class:`~Coefficient` using an 'w' args, a function of the
+            frequency or a string. The :class:`SpectraCoefficient` can be used for
+            array based coefficient.
+            The spectra can depend on ``t`` if the corresponding
+            ``a_op`` is a :class:`QobjEvo`.
+
+        Example:
+
+        .. code-block::
+
+            a_ops = [
+                (a+a.dag(), ('w>0', args={"w": 0})),
+                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
+                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+            ]
+
+
+    c_ops : list
+        List of system collapse operators.
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    fock_basis : bool {False}
+        Whether to return the tensor in the input basis or the diagonalized
+        basis.
+
+    sparse_eigensolver : bool {False}
+        Whether to use the sparse eigensolver
+
+    br_dtype : ['sparse', 'dense', 'data']
+        Which data type to use when computing the brtensor.
+        With a cutoff 'sparse' is usually the most efficient.
+
+    Returns
+    -------
+    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
+        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
+        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
+        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
+        column.
+    """
+    R = liouvillian(H, c_ops)
+    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
+
+    if fock_basis:
+        for (a_op, spectra) in a_ops:
+            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
+                        br_dtype=br_dtype)
+        return R
+    else:
+        # When the Hamiltonian is time-dependent, the transformation of `L` to
+        # eigenbasis is not optimized.
+        if isinstance(R, QobjEvo):
+            # The `sprepost` will be computed 2 times for each parts of `R`.
+            # Compressing the QobjEvo will lower the number of parts.
+            R.compress()
+        evec = H_transform.as_Qobj()
+        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
+        for (a_op, spectra) in a_ops:
+            R += brterm(H_transform, a_op, spectra, sec_cutoff,
+                        False, br_dtype=br_dtype)[0]
+        return R, H_transform.as_Qobj()
+
+
+def brterm(H, a_op, spectra, sec_cutoff=0.1,
+           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
+    """
+    Calculates the contribution of one coupling operator to the Bloch-Redfield
+    tensor.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+        System Hamiltonian.
+
+    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+        The operator coupling to the environment. Must be hermitian.
+
+    spectra : :class:`Coefficient`, func, str
+        The corresponding bath spectra.
+        Can be a :class:`~Coefficient` using an 'w' args, a function of the
+        frequency or a string. The :class:`SpectraCoefficient` can be used for
+        array based coefficient.
+        The spectra can depend on ``t`` if the corresponding
+        ``a_op`` is a :class:`QobjEvo`.
+
+        Example:
+
+            coefficient('w>0', args={"w": 0})
+            SpectraCoefficient(coefficient(array, tlist=...))
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    fock_basis : bool {False}
+        Whether to return the tensor in the input basis or the diagonalized
+        basis.
+
+    sparse_eigensolver : bool {False}
+        Whether to use the sparse eigensolver on the Hamiltonian.
+
+    br_dtype : ['sparse', 'dense', 'data']
+        Which data type to use when computing the brtensor.
+        With a cutoff 'sparse' is usually the most efficient.
+
+    Returns
+    -------
+    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
+        If ``fock_basis``, return the Bloch Redfield tensor in the outside
+        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
+        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
+        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
+        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
+    """
+    if isinstance(H, _EigenBasisTransform):
+        Hdiag = H
+    else:
+        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
+
+    # convert spectra to Coefficient
+    if isinstance(spectra, str):
+        spectra = coefficient(spectra, args={'w': 0})
+    elif isinstance(spectra, InterCoefficient):
+        spectra = SpectraCoefficient(spectra)
+    elif isinstance(spectra, Coefficient):
+        pass
+    elif callable(spectra):
+        sig = inspect.signature(spectra)
+        if tuple(sig.parameters.keys()) == ("w",):
+            spectra = SpectraCoefficient(coefficient(spectra))
+        else:
+            spectra = coefficient(spectra, args={'w': 0})
+    else:
+        raise TypeError("a_ops's spectra not known")
+
+    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
+    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
+                sec_cutoff, not fock_basis, dtype=br_dtype))
+
+    if (
+        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
+         or isinstance(H, Qobj))
+        and isinstance(a_op, Qobj)
+    ):
+        R = R(0)
+    return R if fock_basis else (R, Hdiag.as_Qobj())
diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index d029461f1a..a738e630c2 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -1,776 +1,776 @@
-import numpy as np
-import scipy
-import scipy.interpolate
-import os
-import sys
-import re
-import dis
-import hashlib
-import glob
-import importlib
-import warnings
-import numbers
-from contextlib import contextmanager
-from collections import defaultdict
-from setuptools import setup, Extension
-try:
-    from Cython.Build import cythonize
-    import filelock
-except ImportError:
-    pass
-
-from ..settings import settings as qset
-from .options import QutipOptions
-from .data import Data
-from .cy.coefficient import (
-    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
-    ConjCoefficient, NormCoefficient
-)
-
-
-__all__ = ["coefficient", "CompilationOptions", "Coefficient",
-           "clean_compiled_coefficient"]
-
-
-class StringParsingWarning(Warning):
-    pass
-
-
-def _return(base, **kwargs):
-    return base
-
-
-# The `coefficient` function is dispatcher for the type of the `base` to the
-# function that created the `Coefficient` object. `coefficient_builders` stores
-# the map `type -> function(base, **kw)`. Optional module can add their
-# `Coefficient` specializations here.
-coefficient_builders = {
-    Coefficient: _return,
-    np.ndarray: InterCoefficient,
-    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
-    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
-}
-
-
-def coefficient(base, *, tlist=None, args={}, args_ctypes={},
-                order=3, compile_opt=None, function_style=None,
-                boundary_conditions=None, **kwargs):
-    """Build ``Coefficient`` for time dependent systems:
-
-    ```
-    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
-    ```
-
-    The coefficients can be a function, a string or a numpy array. Other
-    packages may add support for other kind of coefficients.
-
-    For function based coefficients, the function signature must be either:
-
-    * ``f(t, ...)`` where the other arguments are supplied as ordinary
-      "pythonic" arguments (e.g. ``f(t, w, a=5))
-    * ``f(t, args)`` where the arguments are supplied in a "dict" named
-      ``args``
-
-    By default the signature style is controlled by the
-    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
-    may be overriden here by specifying either ``function_style="pythonic"``
-    or ``function_style="dict"``.
-
-    *Examples*
-        # pythonic style function signature
-
-        def f1_t(t, w):
-            return np.exp(-1j * t * w)
-
-        coeff1 = coefficient(f1_t, args={"w": 1.})
-
-        # dict style function signature
-
-        def f2_t(t, args):
-            return np.exp(-1j * t * args["w"])
-
-        coeff2 = coefficient(f2_t, args={"w": 1.})
-
-    For string based coeffients, the string must be a compilable python code
-    resulting in a complex. The following symbols are defined:
-        sin cos tan asin acos atan pi
-        sinh cosh tanh asinh acosh atanh
-        exp log log10 erf zerf sqrt
-        real imag conj abs norm arg proj
-        numpy as np,
-        scipy.special as spe (python interface)
-        and cython_special (scipy cython interface)
-
-    *Examples*
-        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
-    'args' is needed for string coefficient at compilation.
-    It is a dict of (name:object). The keys must be a valid variables string.
-
-    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
-
-    For numpy array format, the array must be an 1d of dtype float or complex.
-    A list of times (float64) at which the coeffients must be given (tlist).
-    The coeffients array must have the same len as the tlist.
-    The time of the tlist do not need to be equidistant, but must be sorted.
-    By default, a cubic spline interpolation will be used to compute the
-    coefficient at time t. The keyword ``order`` sets the order of the
-    interpolation. When ``order = 0``, the interpolation is step function that
-    evaluates to the most recent value.
-
-    *Examples*
-        tlist = np.logspace(-5,0,100)
-        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
-
-    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
-    also converted to interpolated coefficients (the same kind of coefficient
-    created from ``ndarray``). Other interpolation methods from
-    scipy are converted to a function-based coefficient (the same kind of
-    coefficient created from callables).
-
-    Parameters
-    ----------
-    base : object
-        Base object to make into a Coefficient.
-
-    args : dict, optional
-        Dictionary of arguments to pass to the function or string coefficient.
-
-    order : int, default=3
-        Order of the spline for array based coefficient.
-
-    tlist : iterable, optional
-        Times for each element of an array based coefficient.
-
-    function_style : str, ["dict", "pythonic", None]
-        Function signature of function based coefficients.
-
-    args_ctypes : dict, optional
-        C type for the args when compiling array based coefficients.
-
-    compile_opt : CompilationOptions, optional
-        Sets of options for the compilation of string based coefficients.
-
-    boundary_conditions: 2-tupule, str or None, optional
-        Specify boundary conditions for spline interpolation.
-
-    **kwargs
-        Extra arguments to pass the the coefficients.
-    """
-    kwargs.update({
-        "tlist": tlist,
-        'args': args,
-        'args_ctypes': args_ctypes,
-        'order': order,
-        'compile_opt': compile_opt,
-        'function_style': function_style,
-        'boundary_conditions': boundary_conditions
-    })
-
-    for type_ in coefficient_builders:
-        if isinstance(base, type_):
-            return coefficient_builders[type_](base, **kwargs)
-
-    if callable(base):
-        op = FunctionCoefficient(base, args.copy(), style=function_style)
-        if not isinstance(op(0), numbers.Number):
-            raise TypeError("The coefficient function must return a number")
-        return op
-    else:
-        raise ValueError("coefficient format not understood")
-
-
-def norm(coeff):
-    """ return a Coefficient with is the norm: |c|^2.
-    """
-    return NormCoefficient(coeff)
-
-
-def conj(coeff):
-    """ return a Coefficient with is the conjugate.
-    """
-    return ConjCoefficient(coeff)
-
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-class CompilationOptions(QutipOptions):
-    """
-    Compilation options:
-
-    use_cython: bool
-        Whether to compile strings as cython code or use python's ``exec``.
-
-    try_parse: bool [True]
-        Whether to try parsing the string for reuse and static typing.
-
-    static_types : bool [True]
-        Whether to use C types for constant and args.
-
-    accept_int : None, bool
-        Whether to use the type ``int`` for integer constants and args or
-        upgrade it to ``float`` or ``complex``.
-        If `None`, it will only use ``int`` when subscription is found in the
-        code.
-
-    accept_float : bool
-        Whether to use the type ``float`` or upgrade them to ``complex``.
-
-    recompile : bool
-        Do not use previously made files but build a new one.
-
-    compiler_flags : str
-        Flags to pass to the compiler, ex: "-Wall -O3"...
-        Flags not matching your comiler and OS may cause compilation to fail.
-        Use "recompile=True", when trying to if the string pattern was
-        previously used.
-
-    link_flags : str
-        Libraries to link to pass to the compiler. They can not be used to add
-        function to the string coefficient.
-
-    extra_import : str
-        Cython code to add at the head of the file. Can be used to add extra
-        import or cimport code, ex:
-        extra_import="from scipy.linalg import det"
-        extra_import="from qutip.core.data cimport CSR"
-
-    clean_on_error : bool [True]
-        When writing a cython file that cannot be imported, erase it.
-    """
-    _link_flags = ""
-    _compiler_flags = ""
-    if sys.platform == 'win32':
-        _compiler_flags = ''
-    elif sys.platform == 'darwin':
-        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
-        _link_flags += '-mmacosx-version-min=10.9'
-    else:
-        _compiler_flags = '-w -O3 -funroll-loops'
-
-    try:
-        import cython
-        import filelock
-        _use_cython = True
-    except ImportError:
-        _use_cython = False
-
-    _options = {
-        "use_cython": _use_cython,
-        "try_parse": True,
-        "static_types": True,
-        "accept_int": None,
-        "accept_float": True,
-        "recompile": False,
-        "compiler_flags": _compiler_flags,
-        "link_flags": _link_flags,
-        "extra_import": "",
-        "clean_on_error": True,
-    }
-    _settings_name = "compile"
-
-
-# Create the default instance in settings.
-qset.compile = CompilationOptions()
-
-
-# Version number of the Coefficient
-COEFF_VERSION = "1.1"
-
-try:
-    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
-    qset.coeffroot = root
-except OSError:
-    qset.coeffroot = "."
-
-
-def clean_compiled_coefficient(all=False):
-    """
-    Remove previouly compiled string Coefficient.
-
-    Parameter:
-    ----------
-    all: bool
-        If not `all` will remove only previous version.
-    """
-    import glob
-    import shutil
-    tmproot = qset.tmproot
-    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
-    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
-    for folder in folders:
-        if all or folder != root:
-            shutil.rmtree(folder)
-    # Recreate the empty folder.
-    qset.coeffroot = qset.coeffroot
-
-
-def proj(x):
-    if np.isfinite(x):
-        return (x)
-    else:
-        return np.inf + 0j * np.imag(x)
-
-
-str_env = {
-    "sin": np.sin,
-    "cos": np.cos,
-    "tan": np.tan,
-    "asin": np.arcsin,
-    "acos": np.arccos,
-    "atan": np.arctan,
-    "pi": np.pi,
-    "sinh": np.sinh,
-    "cosh": np.cosh,
-    "tanh": np.tanh,
-    "asinh": np.arcsinh,
-    "acosh": np.arccosh,
-    "atanh": np.arctanh,
-    "exp": np.exp,
-    "log": np.log,
-    "log10": np.log10,
-    "erf": scipy.special.erf,
-    "zerf": scipy.special.erf,
-    "sqrt": np.sqrt,
-    "real": np.real,
-    "imag": np.imag,
-    "conj": np.conj,
-    "abs": np.abs,
-    "norm": lambda x: np.abs(x)**2,
-    "arg": np.angle,
-    "proj": proj,
-    "np": np,
-    "spe": scipy.special}
-
-
-def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
-    """
-    Entry point for string based coefficients
-    - Test if the string is valid
-    - Parse: "cos(a*t)" and "cos( w1 * t )"
-        should be recognised as the same compiled object.
-    - Verify if already compiled and compile if not
-    """
-    # First, a sanity check before thinking of compiling
-    if compile_opt is None:
-        compile_opt = qset.compile
-    if not compile_opt['extra_import']:
-        try:
-            env = {"t": 0}
-            env.update(args)
-            exec(base, str_env, env)
-        except Exception as err:
-            raise Exception("Invalid string coefficient") from err
-    coeff = None
-    # Do we compile?
-    if not compile_opt['use_cython']:
-        return StrFunctionCoefficient(base, args)
-    # Parsing tries to make the code in common pattern
-    parsed, variables, constants, raw = try_parse(base, args,
-                                                  args_ctypes, compile_opt)
-    # Once parsed, the code should be unique enough to get a filename
-    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
-    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
-    # See if it already exist and import it.
-    if not compile_opt['recompile']:
-        coeff = try_import(file_name, parsed)
-
-    if not coeff and qset.coeff_write_ok:
-        # Previously compiled coefficient not available: create the cython code
-        code = make_cy_code(parsed, variables, constants,
-                            raw, compile_opt)
-        try :
-            coeff = compile_code(code, file_name, parsed, compile_opt)
-        except PermissionError:
-            pass
-    if coeff is None:
-        # We don't use cython or compilation failed
-        return StrFunctionCoefficient(base, args)
-    keys = [key for _, key, _ in variables]
-    const = [fromstr(val) for _, val, _ in constants]
-    return coeff(base, keys, const, args)
-
-
-coefficient_builders[str] = coeff_from_str
-
-
-def try_import(file_name, parsed_in):
-    """ Import the compiled coefficient if existing and check for
-    name collision.
-    """
-    try:
-        mod = importlib.import_module(file_name)
-    except ModuleNotFoundError:
-        # Coefficient does not exist, to compile as file_name
-        return None
-
-    if mod.parsed_code == parsed_in:
-        # Coefficient found!
-        return mod.StrCoefficient
-    else:
-        raise ValueError("string hash collision, change the string "
-                         "or clean files in qutip.settings.coeffroot")
-
-
-def make_cy_code(code, variables, constants, raw, compile_opt):
-    """
-    Generate the code for the string coefficients.
-    """
-    cdef_cte = ""
-    init_cte = ""
-    copy_cte = ""
-    for i, (name, val, ctype) in enumerate(constants):
-        cdef_cte += "        {} {}\n".format(ctype, name[5:])
-        copy_cte += "        out.{} = {}\n".format(name[5:], name)
-        init_cte += "        {} = cte[{}]\n".format(name, i)
-    cdef_var = ""
-    init_var = ""
-    init_arg = ""
-    replace_var = ""
-    call_var = ""
-    copy_var = ""
-    for i, (name, val, ctype) in enumerate(variables):
-        cdef_var += "        str key{}\n".format(i)
-        cdef_var += "        {} {}\n".format(ctype, name[5:])
-        copy_var += "        out.key{} = self.key{}\n".format(i, i)
-        copy_var += "        out.{} = {}\n".format(name[5:], name)
-        if not raw:
-            init_var += "        self.key{} = var[{}]\n".format(i, i)
-        else:
-            init_var += "        self.key{} = '{}'\n".format(i, val)
-        init_arg += "        {} = args[self.key{}]\n".format(name, i)
-        replace_var += "            if self.key{} in kwargs:\n".format(i)
-        replace_var += ("                out.{}"
-                        " = kwargs[self.key{}]\n".format(name[5:], i))
-        if raw:
-            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
-
-    code = f"""#cython: language_level=3
-# This file is generated automatically by QuTiP.
-
-import numpy as np
-import scipy.special as spe
-from scipy.special cimport cython_special
-cimport cython
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.cy.math cimport erf, zerf
-from qutip.core.cy.complex_math cimport *
-from qutip.core.data cimport Data
-cdef double pi = 3.14159265358979323
-{compile_opt['extra_import']}
-
-parsed_code = "{code}"
-
-@cython.auto_pickle(True)
-cdef class StrCoefficient(Coefficient):
-    \"\"\"
-    String compiled as a :obj:`Coefficient` using cython.
-    \"\"\"
-    cdef:
-        str codeString
-{cdef_cte}{cdef_var}
-
-    def __init__(self, base, var, cte, args):
-        self.codeString = base
-{init_cte}{init_var}{init_arg}
-
-    cpdef Coefficient copy(self):
-        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
-        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
-        out.codeString = self.codeString
-{copy_cte}{copy_var}
-        return out
-
-    def replace_arguments(self, _args=None, **kwargs):
-        \"\"\"
-        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
-        built from 'str' or a python function. Or a the :obj:`Coefficient`
-        itself if the :obj:`Coefficient` does not use arguments. New arguments
-        can be passed as a dict or as keywords.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        \"\"\"
-        cdef StrCoefficient out
-
-        if _args:
-            kwargs.update(_args)
-        if kwargs:
-            out = self.copy()
-{replace_var}
-            return out
-        return self
-
-    @cython.initializedcheck(False)
-    @cython.cdivision(True)
-    cdef complex _call(self, double t) except *:
-{call_var}        return {code}
-"""
-    return code
-
-
-def compile_code(code, file_name, parsed, c_opt):
-    pwd = os.getcwd()
-    os.chdir(qset.coeffroot)
-    # Files with the same name, but differents extension than the pyx file, are
-    # erased during cythonization process, breaking filelock.
-    # Adding a prefix make them safe to use.
-    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
-    try:
-        lock.acquire(timeout=0)
-        for file in glob.glob(file_name + "*"):
-            os.remove(file)
-        file_ = open(file_name + ".pyx", "w")
-        file_.writelines(code)
-        file_.close()
-        oldargs = sys.argv
-        try:
-            sys.argv = ["setup.py", "build_ext", "--inplace"]
-            coeff_file = Extension(
-                file_name,
-                sources=[file_name + ".pyx"],
-                extra_compile_args=c_opt['compiler_flags'].split(),
-                extra_link_args=c_opt['link_flags'].split(),
-                include_dirs=[np.get_include()],
-                language='c++'
-            )
-            ext_modules = cythonize(coeff_file, force=True)
-            setup(ext_modules=ext_modules)
-        except Exception as e:
-            if c_opt['clean_on_error']:
-                for file in glob.glob(file_name + "*"):
-                    os.remove(file)
-            raise Exception("Could not compile") from e
-        finally:
-            sys.argv = oldargs
-    except filelock.Timeout:
-        with lock:
-            # We wait for the lock to be released and then retry the import.
-            pass
-    finally:
-        lock.release()
-        os.chdir(pwd)
-    return try_import(file_name, parsed)
-
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-# Parsing here is extracting constants and args name to replace them with
-# attribute of the Coefficient so similar string like:
-# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
-# are all reconized as the same compiled object and only compiled once.
-# Weakness:
-#   typing: "1" and "1j" or the type of args ("w1") make different object
-#   complex: "1+1j" is seens as cte(double) + cte(complex)
-#   negative: "-1" is not seens as a constant but "- constant"
-#
-# int and double can be seens as complex with flags in CompilationOptions
-
-def fromstr(base):
-    """Read a varibles in a string"""
-    ls = {}
-    exec("out = " + base, {}, ls)
-    return ls["out"]
-
-
-typeCodes = {
-    "Data": "_datalayer",
-    "complex": "_cpl",
-    "double": "_dbl",
-    "int": "_int",
-    "str": "_str",
-    "object": "_obj"
-}
-
-
-def compileType(value):
-    """Obtain the index of typeCodes that correspond to the value
-    4.5 -> 'double'..."""
-    if isinstance(value, Data):
-        ctype = "Data"
-    elif isinstance(value, numbers.Integral):
-        ctype = "int"
-    elif isinstance(value, numbers.Real):
-        ctype = "double"
-    elif isinstance(value, numbers.Complex):
-        ctype = "complex"
-    elif isinstance(value, str):
-        ctype = "str"
-    else:
-        ctype = "object"
-    return ctype
-
-
-def find_type_from_str(chars):
-    """ '1j' -> complex """
-    try:
-        lc = {}
-        exec("out = " + chars, {}, lc)
-        return compileType(lc["out"])
-    except Exception:
-        return None
-
-
-def fix_type(ctype, accept_int, accept_float):
-    """int and double could be complex to limit the number of compiled object.
-    change the types is we choose not to support all.
-    """
-    if ctype == "int" and not accept_int:
-        ctype = "double"
-    if ctype == "double" and not accept_float:
-        ctype = "complex"
-    return ctype
-
-
-def extract_constant(code):
-    """Look for floating and complex constants and replace them with variable.
-    """
-    code = " " + code + " "
-    contants = []
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
-    return code, contants
-
-
-def extract_cte_pattern(code, constants, pattern):
-    """replace the constant following a pattern with variable"""
-    const_strs = re.findall(pattern, code)
-    for cte in const_strs:
-        name = " _cte_temp{}_ ".format(len(constants))
-        code = code.replace(cte, cte[0] + name, 1)
-        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
-    return code
-
-
-def space_parts(code, names):
-    """Force spacing: single space between element"""
-    for name in names:
-        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
-                      " " + name + " ", code)
-    code = " ".join(code.split())
-    return code
-
-
-def parse(code, args, compile_opt):
-    """
-    Read the code and rewrite it in a reutilisable form:
-    Ins:
-        '2.*cos(a*t)', {"a":5+1j}
-    Outs:
-        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
-        variables = [('self._arg_cpl0', 'a', 'complex')]
-        ordered_constants = [('self._cte_dbl0', 2, 'double')]
-    """
-    code, constants = extract_constant(code)
-    names = re.findall("[0-9a-zA-Z_]+", code)
-    code = space_parts(code, names)
-    constants_names = [const[0] for const in constants]
-    new_code = []
-    ordered_constants = []
-    variables = []
-    typeCounts = defaultdict(lambda: 0)
-    accept_int = compile_opt['accept_int']
-    accept_float = compile_opt['accept_float']
-    if accept_int is None:
-        # If there is a subscript: a[b] int are always accepted to be safe
-        # with TypeError
-        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
-    for word in code.split():
-        if word not in names:
-            # syntax
-            new_code.append(word)
-        elif word in args:
-            # find first if the variable is use more than once and reuse
-            var_name = [var_name for var_name, name, _ in variables
-                        if word == name]
-            if var_name:
-                var_name = var_name[0]
-            else:
-                ctype = compileType(args[word])
-                ctype = fix_type(ctype, accept_int, accept_float)
-                var_name = ("self._arg" + typeCodes[ctype] +
-                            str(typeCounts[ctype]))
-                typeCounts[ctype] += 1
-                variables.append((var_name, word, ctype))
-            new_code.append(var_name)
-        elif word in constants_names:
-            name, val, ctype = constants[int(word[9:-1])]
-            ctype = fix_type(ctype, accept_int, accept_float)
-            cte_name = "self._cte" + typeCodes[ctype] +\
-                       str(len(ordered_constants))
-            new_code.append(cte_name)
-            ordered_constants.append((cte_name, val, ctype))
-        else:
-            # Hopefully a buildin or known object
-            new_code.append(word)
-        code = " ".join(new_code)
-    return code, variables, ordered_constants
-
-
-def use_hinted_type(variables, code, args_ctypes):
-    variables_manually_typed = []
-    for i, (name, key, type_) in enumerate(variables):
-        if key in args_ctypes:
-            new_name = "self._custom_" + args_ctypes[key] + str(i)
-            code = code.replace(name, new_name)
-            variables_manually_typed.append((new_name, key, args_ctypes[key]))
-        else:
-            variables_manually_typed.append((name, key, type_))
-    return code, variables_manually_typed
-
-
-def try_parse(code, args, args_ctypes, compile_opt):
-    """
-    Try to parse and verify that the result is still usable.
-    """
-    if not compile_opt['try_parse']:
-        variables = [("self." + name, name, "object") for name in args
-                     if name in code]
-        code, variables = use_hinted_type(variables, code, args_ctypes)
-        return code, variables, [], True
-    ncode, variables, constants = parse(code, args, compile_opt)
-    if not compile_opt['static_types']:
-        # Fallback to object
-        variables = [(f, s, "object") for f, s, _ in variables]
-        constants = [(f, s, "object") for f, s, _ in constants]
-    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
-    if (
-        (compile_opt['extra_import']
-         and not compile_opt['extra_import'].isspace())
-        or test_parsed(ncode, variables, constants, args)
-    ):
-        return ncode, variables, constants, False
-    else:
-        warnings.warn("Could not find c types", StringParsingWarning)
-        remaped_variable = []
-        for _, name, ctype in variables:
-            remaped_variable.append(("self." + name, name, "object"))
-        return code, remaped_variable, [], True
-
-
-def test_parsed(code, variables, constants, args):
-    """
-    Test if parsed code broke anything.
-    """
-    class DummySelf:
-        pass
-    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
-    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
-    loc_env = {"t": 0, 'self': DummySelf}
-    try:
-        exec(code, str_env, loc_env)
-    except Exception as e:
-        return False
-    return True
+import numpy as np
+import scipy
+import scipy.interpolate
+import os
+import sys
+import re
+import dis
+import hashlib
+import glob
+import importlib
+import warnings
+import numbers
+from contextlib import contextmanager
+from collections import defaultdict
+from setuptools import setup, Extension
+try:
+    from Cython.Build import cythonize
+    import filelock
+except ImportError:
+    pass
+
+from ..settings import settings as qset
+from .options import QutipOptions
+from .data import Data
+from .cy.coefficient import (
+    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
+    ConjCoefficient, NormCoefficient
+)
+
+
+__all__ = ["coefficient", "CompilationOptions", "Coefficient",
+           "clean_compiled_coefficient"]
+
+
+class StringParsingWarning(Warning):
+    pass
+
+
+def _return(base, **kwargs):
+    return base
+
+
+# The `coefficient` function is dispatcher for the type of the `base` to the
+# function that created the `Coefficient` object. `coefficient_builders` stores
+# the map `type -> function(base, **kw)`. Optional module can add their
+# `Coefficient` specializations here.
+coefficient_builders = {
+    Coefficient: _return,
+    np.ndarray: InterCoefficient,
+    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
+    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
+}
+
+
+def coefficient(base, *, tlist=None, args={}, args_ctypes={},
+                order=3, compile_opt=None, function_style=None,
+                boundary_conditions=None, **kwargs):
+    """Build ``Coefficient`` for time dependent systems:
+
+    ```
+    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
+    ```
+
+    The coefficients can be a function, a string or a numpy array. Other
+    packages may add support for other kind of coefficients.
+
+    For function based coefficients, the function signature must be either:
+
+    * ``f(t, ...)`` where the other arguments are supplied as ordinary
+      "pythonic" arguments (e.g. ``f(t, w, a=5))
+    * ``f(t, args)`` where the arguments are supplied in a "dict" named
+      ``args``
+
+    By default the signature style is controlled by the
+    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
+    may be overriden here by specifying either ``function_style="pythonic"``
+    or ``function_style="dict"``.
+
+    *Examples*
+        # pythonic style function signature
+
+        def f1_t(t, w):
+            return np.exp(-1j * t * w)
+
+        coeff1 = coefficient(f1_t, args={"w": 1.})
+
+        # dict style function signature
+
+        def f2_t(t, args):
+            return np.exp(-1j * t * args["w"])
+
+        coeff2 = coefficient(f2_t, args={"w": 1.})
+
+    For string based coeffients, the string must be a compilable python code
+    resulting in a complex. The following symbols are defined:
+        sin cos tan asin acos atan pi
+        sinh cosh tanh asinh acosh atanh
+        exp log log10 erf zerf sqrt
+        real imag conj abs norm arg proj
+        numpy as np,
+        scipy.special as spe (python interface)
+        and cython_special (scipy cython interface)
+
+    *Examples*
+        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
+    'args' is needed for string coefficient at compilation.
+    It is a dict of (name:object). The keys must be a valid variables string.
+
+    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
+
+    For numpy array format, the array must be an 1d of dtype float or complex.
+    A list of times (float64) at which the coeffients must be given (tlist).
+    The coeffients array must have the same len as the tlist.
+    The time of the tlist do not need to be equidistant, but must be sorted.
+    By default, a cubic spline interpolation will be used to compute the
+    coefficient at time t. The keyword ``order`` sets the order of the
+    interpolation. When ``order = 0``, the interpolation is step function that
+    evaluates to the most recent value.
+
+    *Examples*
+        tlist = np.logspace(-5,0,100)
+        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
+
+    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
+    also converted to interpolated coefficients (the same kind of coefficient
+    created from ``ndarray``). Other interpolation methods from
+    scipy are converted to a function-based coefficient (the same kind of
+    coefficient created from callables).
+
+    Parameters
+    ----------
+    base : object
+        Base object to make into a Coefficient.
+
+    args : dict, optional
+        Dictionary of arguments to pass to the function or string coefficient.
+
+    order : int, default=3
+        Order of the spline for array based coefficient.
+
+    tlist : iterable, optional
+        Times for each element of an array based coefficient.
+
+    function_style : str, ["dict", "pythonic", None]
+        Function signature of function based coefficients.
+
+    args_ctypes : dict, optional
+        C type for the args when compiling array based coefficients.
+
+    compile_opt : CompilationOptions, optional
+        Sets of options for the compilation of string based coefficients.
+
+    boundary_conditions: 2-tupule, str or None, optional
+        Specify boundary conditions for spline interpolation.
+
+    **kwargs
+        Extra arguments to pass the the coefficients.
+    """
+    kwargs.update({
+        "tlist": tlist,
+        'args': args,
+        'args_ctypes': args_ctypes,
+        'order': order,
+        'compile_opt': compile_opt,
+        'function_style': function_style,
+        'boundary_conditions': boundary_conditions
+    })
+
+    for type_ in coefficient_builders:
+        if isinstance(base, type_):
+            return coefficient_builders[type_](base, **kwargs)
+
+    if callable(base):
+        op = FunctionCoefficient(base, args.copy(), style=function_style)
+        if not isinstance(op(0), numbers.Number):
+            raise TypeError("The coefficient function must return a number")
+        return op
+    else:
+        raise ValueError("coefficient format not understood")
+
+
+def norm(coeff):
+    """ return a Coefficient with is the norm: |c|^2.
+    """
+    return NormCoefficient(coeff)
+
+
+def conj(coeff):
+    """ return a Coefficient with is the conjugate.
+    """
+    return ConjCoefficient(coeff)
+
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+class CompilationOptions(QutipOptions):
+    """
+    Compilation options:
+
+    use_cython: bool
+        Whether to compile strings as cython code or use python's ``exec``.
+
+    try_parse: bool [True]
+        Whether to try parsing the string for reuse and static typing.
+
+    static_types : bool [True]
+        Whether to use C types for constant and args.
+
+    accept_int : None, bool
+        Whether to use the type ``int`` for integer constants and args or
+        upgrade it to ``float`` or ``complex``.
+        If `None`, it will only use ``int`` when subscription is found in the
+        code.
+
+    accept_float : bool
+        Whether to use the type ``float`` or upgrade them to ``complex``.
+
+    recompile : bool
+        Do not use previously made files but build a new one.
+
+    compiler_flags : str
+        Flags to pass to the compiler, ex: "-Wall -O3"...
+        Flags not matching your comiler and OS may cause compilation to fail.
+        Use "recompile=True", when trying to if the string pattern was
+        previously used.
+
+    link_flags : str
+        Libraries to link to pass to the compiler. They can not be used to add
+        function to the string coefficient.
+
+    extra_import : str
+        Cython code to add at the head of the file. Can be used to add extra
+        import or cimport code, ex:
+        extra_import="from scipy.linalg import det"
+        extra_import="from qutip.core.data cimport CSR"
+
+    clean_on_error : bool [True]
+        When writing a cython file that cannot be imported, erase it.
+    """
+    _link_flags = ""
+    _compiler_flags = ""
+    if sys.platform == 'win32':
+        _compiler_flags = ''
+    elif sys.platform == 'darwin':
+        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
+        _link_flags += '-mmacosx-version-min=10.9'
+    else:
+        _compiler_flags = '-w -O3 -funroll-loops'
+
+    try:
+        import cython
+        import filelock
+        _use_cython = True
+    except ImportError:
+        _use_cython = False
+
+    _options = {
+        "use_cython": _use_cython,
+        "try_parse": True,
+        "static_types": True,
+        "accept_int": None,
+        "accept_float": True,
+        "recompile": False,
+        "compiler_flags": _compiler_flags,
+        "link_flags": _link_flags,
+        "extra_import": "",
+        "clean_on_error": True,
+    }
+    _settings_name = "compile"
+
+
+# Create the default instance in settings.
+qset.compile = CompilationOptions()
+
+
+# Version number of the Coefficient
+COEFF_VERSION = "1.1"
+
+try:
+    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
+    qset.coeffroot = root
+except OSError:
+    qset.coeffroot = "."
+
+
+def clean_compiled_coefficient(all=False):
+    """
+    Remove previouly compiled string Coefficient.
+
+    Parameter:
+    ----------
+    all: bool
+        If not `all` will remove only previous version.
+    """
+    import glob
+    import shutil
+    tmproot = qset.tmproot
+    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
+    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
+    for folder in folders:
+        if all or folder != root:
+            shutil.rmtree(folder)
+    # Recreate the empty folder.
+    qset.coeffroot = qset.coeffroot
+
+
+def proj(x):
+    if np.isfinite(x):
+        return (x)
+    else:
+        return np.inf + 0j * np.imag(x)
+
+
+str_env = {
+    "sin": np.sin,
+    "cos": np.cos,
+    "tan": np.tan,
+    "asin": np.arcsin,
+    "acos": np.arccos,
+    "atan": np.arctan,
+    "pi": np.pi,
+    "sinh": np.sinh,
+    "cosh": np.cosh,
+    "tanh": np.tanh,
+    "asinh": np.arcsinh,
+    "acosh": np.arccosh,
+    "atanh": np.arctanh,
+    "exp": np.exp,
+    "log": np.log,
+    "log10": np.log10,
+    "erf": scipy.special.erf,
+    "zerf": scipy.special.erf,
+    "sqrt": np.sqrt,
+    "real": np.real,
+    "imag": np.imag,
+    "conj": np.conj,
+    "abs": np.abs,
+    "norm": lambda x: np.abs(x)**2,
+    "arg": np.angle,
+    "proj": proj,
+    "np": np,
+    "spe": scipy.special}
+
+
+def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
+    """
+    Entry point for string based coefficients
+    - Test if the string is valid
+    - Parse: "cos(a*t)" and "cos( w1 * t )"
+        should be recognised as the same compiled object.
+    - Verify if already compiled and compile if not
+    """
+    # First, a sanity check before thinking of compiling
+    if compile_opt is None:
+        compile_opt = qset.compile
+    if not compile_opt['extra_import']:
+        try:
+            env = {"t": 0}
+            env.update(args)
+            exec(base, str_env, env)
+        except Exception as err:
+            raise Exception("Invalid string coefficient") from err
+    coeff = None
+    # Do we compile?
+    if not compile_opt['use_cython']:
+        return StrFunctionCoefficient(base, args)
+    # Parsing tries to make the code in common pattern
+    parsed, variables, constants, raw = try_parse(base, args,
+                                                  args_ctypes, compile_opt)
+    # Once parsed, the code should be unique enough to get a filename
+    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
+    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
+    # See if it already exist and import it.
+    if not compile_opt['recompile']:
+        coeff = try_import(file_name, parsed)
+
+    if not coeff and qset.coeff_write_ok:
+        # Previously compiled coefficient not available: create the cython code
+        code = make_cy_code(parsed, variables, constants,
+                            raw, compile_opt)
+        try :
+            coeff = compile_code(code, file_name, parsed, compile_opt)
+        except PermissionError:
+            pass
+    if coeff is None:
+        # We don't use cython or compilation failed
+        return StrFunctionCoefficient(base, args)
+    keys = [key for _, key, _ in variables]
+    const = [fromstr(val) for _, val, _ in constants]
+    return coeff(base, keys, const, args)
+
+
+coefficient_builders[str] = coeff_from_str
+
+
+def try_import(file_name, parsed_in):
+    """ Import the compiled coefficient if existing and check for
+    name collision.
+    """
+    try:
+        mod = importlib.import_module(file_name)
+    except ModuleNotFoundError:
+        # Coefficient does not exist, to compile as file_name
+        return None
+
+    if mod.parsed_code == parsed_in:
+        # Coefficient found!
+        return mod.StrCoefficient
+    else:
+        raise ValueError("string hash collision, change the string "
+                         "or clean files in qutip.settings.coeffroot")
+
+
+def make_cy_code(code, variables, constants, raw, compile_opt):
+    """
+    Generate the code for the string coefficients.
+    """
+    cdef_cte = ""
+    init_cte = ""
+    copy_cte = ""
+    for i, (name, val, ctype) in enumerate(constants):
+        cdef_cte += "        {} {}\n".format(ctype, name[5:])
+        copy_cte += "        out.{} = {}\n".format(name[5:], name)
+        init_cte += "        {} = cte[{}]\n".format(name, i)
+    cdef_var = ""
+    init_var = ""
+    init_arg = ""
+    replace_var = ""
+    call_var = ""
+    copy_var = ""
+    for i, (name, val, ctype) in enumerate(variables):
+        cdef_var += "        str key{}\n".format(i)
+        cdef_var += "        {} {}\n".format(ctype, name[5:])
+        copy_var += "        out.key{} = self.key{}\n".format(i, i)
+        copy_var += "        out.{} = {}\n".format(name[5:], name)
+        if not raw:
+            init_var += "        self.key{} = var[{}]\n".format(i, i)
+        else:
+            init_var += "        self.key{} = '{}'\n".format(i, val)
+        init_arg += "        {} = args[self.key{}]\n".format(name, i)
+        replace_var += "            if self.key{} in kwargs:\n".format(i)
+        replace_var += ("                out.{}"
+                        " = kwargs[self.key{}]\n".format(name[5:], i))
+        if raw:
+            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
+
+    code = f"""#cython: language_level=3
+# This file is generated automatically by QuTiP.
+
+import numpy as np
+import scipy.special as spe
+from scipy.special cimport cython_special
+cimport cython
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.cy.math cimport erf, zerf
+from qutip.core.cy.complex_math cimport *
+from qutip.core.data cimport Data
+cdef double pi = 3.14159265358979323
+{compile_opt['extra_import']}
+
+parsed_code = "{code}"
+
+@cython.auto_pickle(True)
+cdef class StrCoefficient(Coefficient):
+    \"\"\"
+    String compiled as a :obj:`Coefficient` using cython.
+    \"\"\"
+    cdef:
+        str codeString
+{cdef_cte}{cdef_var}
+
+    def __init__(self, base, var, cte, args):
+        self.codeString = base
+{init_cte}{init_var}{init_arg}
+
+    cpdef Coefficient copy(self):
+        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
+        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
+        out.codeString = self.codeString
+{copy_cte}{copy_var}
+        return out
+
+    def replace_arguments(self, _args=None, **kwargs):
+        \"\"\"
+        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
+        built from 'str' or a python function. Or a the :obj:`Coefficient`
+        itself if the :obj:`Coefficient` does not use arguments. New arguments
+        can be passed as a dict or as keywords.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        \"\"\"
+        cdef StrCoefficient out
+
+        if _args:
+            kwargs.update(_args)
+        if kwargs:
+            out = self.copy()
+{replace_var}
+            return out
+        return self
+
+    @cython.initializedcheck(False)
+    @cython.cdivision(True)
+    cdef complex _call(self, double t) except *:
+{call_var}        return {code}
+"""
+    return code
+
+
+def compile_code(code, file_name, parsed, c_opt):
+    pwd = os.getcwd()
+    os.chdir(qset.coeffroot)
+    # Files with the same name, but differents extension than the pyx file, are
+    # erased during cythonization process, breaking filelock.
+    # Adding a prefix make them safe to use.
+    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
+    try:
+        lock.acquire(timeout=0)
+        for file in glob.glob(file_name + "*"):
+            os.remove(file)
+        file_ = open(file_name + ".pyx", "w")
+        file_.writelines(code)
+        file_.close()
+        oldargs = sys.argv
+        try:
+            sys.argv = ["setup.py", "build_ext", "--inplace"]
+            coeff_file = Extension(
+                file_name,
+                sources=[file_name + ".pyx"],
+                extra_compile_args=c_opt['compiler_flags'].split(),
+                extra_link_args=c_opt['link_flags'].split(),
+                include_dirs=[np.get_include()],
+                language='c++'
+            )
+            ext_modules = cythonize(coeff_file, force=True)
+            setup(ext_modules=ext_modules)
+        except Exception as e:
+            if c_opt['clean_on_error']:
+                for file in glob.glob(file_name + "*"):
+                    os.remove(file)
+            raise Exception("Could not compile") from e
+        finally:
+            sys.argv = oldargs
+    except filelock.Timeout:
+        with lock:
+            # We wait for the lock to be released and then retry the import.
+            pass
+    finally:
+        lock.release()
+        os.chdir(pwd)
+    return try_import(file_name, parsed)
+
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# Parsing here is extracting constants and args name to replace them with
+# attribute of the Coefficient so similar string like:
+# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
+# are all reconized as the same compiled object and only compiled once.
+# Weakness:
+#   typing: "1" and "1j" or the type of args ("w1") make different object
+#   complex: "1+1j" is seens as cte(double) + cte(complex)
+#   negative: "-1" is not seens as a constant but "- constant"
+#
+# int and double can be seens as complex with flags in CompilationOptions
+
+def fromstr(base):
+    """Read a varibles in a string"""
+    ls = {}
+    exec("out = " + base, {}, ls)
+    return ls["out"]
+
+
+typeCodes = {
+    "Data": "_datalayer",
+    "complex": "_cpl",
+    "double": "_dbl",
+    "int": "_int",
+    "str": "_str",
+    "object": "_obj"
+}
+
+
+def compileType(value):
+    """Obtain the index of typeCodes that correspond to the value
+    4.5 -> 'double'..."""
+    if isinstance(value, Data):
+        ctype = "Data"
+    elif isinstance(value, numbers.Integral):
+        ctype = "int"
+    elif isinstance(value, numbers.Real):
+        ctype = "double"
+    elif isinstance(value, numbers.Complex):
+        ctype = "complex"
+    elif isinstance(value, str):
+        ctype = "str"
+    else:
+        ctype = "object"
+    return ctype
+
+
+def find_type_from_str(chars):
+    """ '1j' -> complex """
+    try:
+        lc = {}
+        exec("out = " + chars, {}, lc)
+        return compileType(lc["out"])
+    except Exception:
+        return None
+
+
+def fix_type(ctype, accept_int, accept_float):
+    """int and double could be complex to limit the number of compiled object.
+    change the types is we choose not to support all.
+    """
+    if ctype == "int" and not accept_int:
+        ctype = "double"
+    if ctype == "double" and not accept_float:
+        ctype = "complex"
+    return ctype
+
+
+def extract_constant(code):
+    """Look for floating and complex constants and replace them with variable.
+    """
+    code = " " + code + " "
+    contants = []
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
+    return code, contants
+
+
+def extract_cte_pattern(code, constants, pattern):
+    """replace the constant following a pattern with variable"""
+    const_strs = re.findall(pattern, code)
+    for cte in const_strs:
+        name = " _cte_temp{}_ ".format(len(constants))
+        code = code.replace(cte, cte[0] + name, 1)
+        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
+    return code
+
+
+def space_parts(code, names):
+    """Force spacing: single space between element"""
+    for name in names:
+        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
+                      " " + name + " ", code)
+    code = " ".join(code.split())
+    return code
+
+
+def parse(code, args, compile_opt):
+    """
+    Read the code and rewrite it in a reutilisable form:
+    Ins:
+        '2.*cos(a*t)', {"a":5+1j}
+    Outs:
+        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
+        variables = [('self._arg_cpl0', 'a', 'complex')]
+        ordered_constants = [('self._cte_dbl0', 2, 'double')]
+    """
+    code, constants = extract_constant(code)
+    names = re.findall("[0-9a-zA-Z_]+", code)
+    code = space_parts(code, names)
+    constants_names = [const[0] for const in constants]
+    new_code = []
+    ordered_constants = []
+    variables = []
+    typeCounts = defaultdict(lambda: 0)
+    accept_int = compile_opt['accept_int']
+    accept_float = compile_opt['accept_float']
+    if accept_int is None:
+        # If there is a subscript: a[b] int are always accepted to be safe
+        # with TypeError
+        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
+    for word in code.split():
+        if word not in names:
+            # syntax
+            new_code.append(word)
+        elif word in args:
+            # find first if the variable is use more than once and reuse
+            var_name = [var_name for var_name, name, _ in variables
+                        if word == name]
+            if var_name:
+                var_name = var_name[0]
+            else:
+                ctype = compileType(args[word])
+                ctype = fix_type(ctype, accept_int, accept_float)
+                var_name = ("self._arg" + typeCodes[ctype] +
+                            str(typeCounts[ctype]))
+                typeCounts[ctype] += 1
+                variables.append((var_name, word, ctype))
+            new_code.append(var_name)
+        elif word in constants_names:
+            name, val, ctype = constants[int(word[9:-1])]
+            ctype = fix_type(ctype, accept_int, accept_float)
+            cte_name = "self._cte" + typeCodes[ctype] +\
+                       str(len(ordered_constants))
+            new_code.append(cte_name)
+            ordered_constants.append((cte_name, val, ctype))
+        else:
+            # Hopefully a buildin or known object
+            new_code.append(word)
+        code = " ".join(new_code)
+    return code, variables, ordered_constants
+
+
+def use_hinted_type(variables, code, args_ctypes):
+    variables_manually_typed = []
+    for i, (name, key, type_) in enumerate(variables):
+        if key in args_ctypes:
+            new_name = "self._custom_" + args_ctypes[key] + str(i)
+            code = code.replace(name, new_name)
+            variables_manually_typed.append((new_name, key, args_ctypes[key]))
+        else:
+            variables_manually_typed.append((name, key, type_))
+    return code, variables_manually_typed
+
+
+def try_parse(code, args, args_ctypes, compile_opt):
+    """
+    Try to parse and verify that the result is still usable.
+    """
+    if not compile_opt['try_parse']:
+        variables = [("self." + name, name, "object") for name in args
+                     if name in code]
+        code, variables = use_hinted_type(variables, code, args_ctypes)
+        return code, variables, [], True
+    ncode, variables, constants = parse(code, args, compile_opt)
+    if not compile_opt['static_types']:
+        # Fallback to object
+        variables = [(f, s, "object") for f, s, _ in variables]
+        constants = [(f, s, "object") for f, s, _ in constants]
+    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
+    if (
+        (compile_opt['extra_import']
+         and not compile_opt['extra_import'].isspace())
+        or test_parsed(ncode, variables, constants, args)
+    ):
+        return ncode, variables, constants, False
+    else:
+        warnings.warn("Could not find c types", StringParsingWarning)
+        remaped_variable = []
+        for _, name, ctype in variables:
+            remaped_variable.append(("self." + name, name, "object"))
+        return code, remaped_variable, [], True
+
+
+def test_parsed(code, variables, constants, args):
+    """
+    Test if parsed code broke anything.
+    """
+    class DummySelf:
+        pass
+    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
+    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
+    loc_env = {"t": 0, 'self': DummySelf}
+    try:
+        exec(code, str_env, loc_env)
+    except Exception as e:
+        return False
+    return True
diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
index 46f869b266..55c6c84714 100644
--- a/qutip/core/cy/_element.pxd
+++ b/qutip/core/cy/_element.pxd
@@ -1,42 +1,42 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense, Data
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.data.base cimport idxint
-from libcpp cimport bool
-
-cdef class _BaseElement:
-    cpdef Data data(self, t)
-    cpdef object qobj(self, t)
-    cpdef object coeff(self, t)
-    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
-
-
-cdef class _ConstantElement(_BaseElement):
-    cdef readonly object _qobj
-
-
-cdef class _EvoElement(_BaseElement):
-    cdef readonly object _qobj
-    cdef readonly Coefficient _coefficient
-
-
-cdef class _FuncElement(_BaseElement):
-    cdef readonly object _func
-    cdef readonly dict _args
-    cdef readonly tuple _previous
-    cdef readonly bint _f_pythonic
-    cdef readonly set _f_parameters
-
-
-cdef class _MapElement(_BaseElement):
-    cdef readonly _FuncElement _base
-    cdef readonly list _transform
-    cdef readonly double complex _coeff
-
-
-cdef class _ProdElement(_BaseElement):
-    cdef readonly _BaseElement _left
-    cdef readonly _BaseElement _right
-    cdef readonly list _transform
-    cdef readonly bool _conj
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense, Data
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.data.base cimport idxint
+from libcpp cimport bool
+
+cdef class _BaseElement:
+    cpdef Data data(self, t)
+    cpdef object qobj(self, t)
+    cpdef object coeff(self, t)
+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
+
+
+cdef class _ConstantElement(_BaseElement):
+    cdef readonly object _qobj
+
+
+cdef class _EvoElement(_BaseElement):
+    cdef readonly object _qobj
+    cdef readonly Coefficient _coefficient
+
+
+cdef class _FuncElement(_BaseElement):
+    cdef readonly object _func
+    cdef readonly dict _args
+    cdef readonly tuple _previous
+    cdef readonly bint _f_pythonic
+    cdef readonly set _f_parameters
+
+
+cdef class _MapElement(_BaseElement):
+    cdef readonly _FuncElement _base
+    cdef readonly list _transform
+    cdef readonly double complex _coeff
+
+
+cdef class _ProdElement(_BaseElement):
+    cdef readonly _BaseElement _left
+    cdef readonly _BaseElement _right
+    cdef readonly list _transform
+    cdef readonly bool _conj
diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
index 999d51d06d..a845b63d5f 100644
--- a/qutip/core/cy/_element.pyx
+++ b/qutip/core/cy/_element.pyx
@@ -1,625 +1,625 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
-
-from .. import data as _data
-from qutip.core.cy.coefficient import coefficient_function_parameters
-from qutip.core.data cimport Dense, Data, dense
-from qutip.core.data.matmul cimport *
-from math import nan as Nan
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-__all__ = ['_ConstantElement', '_EvoElement',
-           '_FuncElement', '_MapElement', '_ProdElement']
-
-
-cdef class _BaseElement:
-    """
-    The representation of a single time-dependent term in the list of
-    terms used by QobjEvo and solvers to describe operators.
-
-    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
-    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
-    are functions of time. :meth:`~_BaseElement.coeff` returns the
-    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
-
-    For example, a :obj:`QobjEvo` instance created by::
-
-      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
-
-    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
-    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
-
-    :obj:`~_BaseElement` defines the interface to time-dependent terms.
-    Sub-classes implement terms defined in different ways.
-    For example, :obj:`~_ConstantElement` implements a term that
-    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
-    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
-    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
-    so on.
-
-    .. note::
-
-      There are three methods to return the factors of the term.
-
-      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
-      coefficient and operator factors respectively. They are separate to
-      avoid constructing an intermediate Python object when called from
-      Cython code (which may take as long as the rest of the call).
-
-      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
-      provides a convenience method for this common operation.
-
-    .. note::
-
-      All :obj:`~_BaseElement` instances are immutable and methods that would
-      modify an object return a new instance instead.
-    """
-    cpdef Data data(self, t):
-        """
-        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
-        of the term at time ``t``.
-
-        Parameters
-        ----------
-        t : double
-          The time, ``t``.
-
-        Returns
-        -------
-        :obj:`~Data`
-          The underlying data of the :obj:`~Qobj` component of the term
-          at time ``t``.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .data(t)."
-        )
-
-    cpdef object qobj(self, t):
-        """
-        Returns the :obj:`~Qobj` component of the term at time ``t``.
-
-        Parameters
-        ----------
-        t : float
-          The time, ``t``.
-
-        Returns
-        -------
-        :obj:`~Qobj`
-          The :obj:`~Qobj` component of the term at time ``t``.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .qobj(t)."
-        )
-
-    cpdef object coeff(self, t):
-        """
-        Returns the complex coefficient of the term at time ``t``.
-
-        Parameters
-        ----------
-        t : float
-          The time, ``t``.
-
-        Returns
-        -------
-        complex
-          The complex coefficient of the term at time ``t``.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .coeff(t)."
-        )
-
-    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
-        """
-        Possibly in-place multiplication and addition. Multiplies a given state
-        by the elemen's value at time ``t`` and adds the result to ``out``.
-        Equivalent to::
-
-          out += self.coeff(t) * self.qobj(t) @ state
-
-        Sub-classes may override :meth:`~matmul_data_t` to provide an more
-        efficient implementation.
-
-        Parameters
-        ----------
-        t : double
-          The time, ``t``.
-
-        state : :obj:`~Data`
-          The state to multiply by the element term.
-
-        out : :obj:`~Data` or ``NULL``
-          The output to add the result of the multiplication to. If ``NULL``,
-          the result of the multiplication is returned directly (i.e. ``out``
-          is assumed to be the zero matrix).
-
-        Returns
-        -------
-        data
-          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
-          the addition possibly having been performed in-place on ``out``.
-
-        .. note::
-
-          Because of the possibly but not definitely in-place behaviour of
-          this function, the result should always be assigned to some variable
-          and surrounding code should assume that ``out`` maybe have been
-          modified and that the result may be a reference to ``out``. The
-          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
-
-        .. note::
-
-          This method would ideally be implemented using a special
-          function dispatched by the data layer so that it did not have to
-          special case the ``Dense`` operation itself, but the data layer
-          dispatch does not yet support in-place operations. Once it does
-          this method should be updated to use the new support.
-        """
-        if out is None:
-            return _data.matmul(self.data(t), state, self.coeff(t))
-        elif type(state) is Dense and type(out) is Dense:
-            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
-            return out
-        else:
-            return _data.add(
-                out,
-                _data.matmul(self.data(t), state, self.coeff(t))
-            )
-
-    def linear_map(self, f, anti=False):
-        """
-        Return a new element representing a linear transformation ``f``
-        of the :obj:`~Qobj` portion of this element and possibly a
-        complex conjucation of the coefficient portion (when ``f`` is an
-        antilinear map).
-
-        If this element represents ``coeff * qobj`` the returned element
-        represents ``coeff * f(obj)`` (if ``anti=False``) or
-        ``conj(coeff) * f(obj)`` (if ``anti=True``).
-
-        Parameters
-        ----------
-        f : function
-          The linear transformation to apply to the :obj:`~Qobj` of this
-          element.
-        anti : bool
-          Whether to take the complex conjugate of the coefficient. Default
-          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
-          map such as the adjoint (i.e. dagger).
-
-        Returns
-        -------
-        _BaseElement
-          A new element with the transformation applied.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .linear_map(t)."
-        )
-
-    def replace_arguments(self, args, cache=None):
-        """
-        Return a copy of the element with the (possible) additional arguments
-        to any time-dependent functions updated to the given argument values.
-        The arguments of any contained :obj:`~Coefficient` instances are also
-        replaced.
-
-        If the operation does not modify this element, the original element
-        may be returned.
-
-        Parameters
-        ----------
-        args : dict
-          A dictionary of arguments to update. Keys are the names of the
-          arguments and values are the new argument values. Arguments
-          not included retain their original values.
-
-        cache : list or ``None``
-          A cache to add updated elements to. Unmodified elements are not
-          added to the cache. If a cache is supplied and ``.replace_arguments``
-          would be called again on the same element with the same arguments,
-          the new element from the cache will be returned instead.
-
-          By default the cache is ``None`` and no caching is performed. Cache
-          users should supply either ``cache=[]`` (which activates caching)
-          or an existing cache (for example, if making calls on sub-elements
-          of some composite element).
-
-        Returns
-        -------
-        _BaseElement
-          A new element with the arguments replaced, or possibly this element
-          if it would not be modified.
-
-        Example
-        -------
-
-        If ``elem`` is a product element for ``op * op.dag()`` it will contain
-        two references to the same element for ``op``. Calling::
-
-          elem = elem.replace_arguments({"theta": 3.1416})
-
-        will return a new element that contains two *different* copies of
-        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
-        to be evaluated *twice* when ``elem.qobj(t)`` is called.
-
-        Calling instead::
-
-          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
-
-        will return a new element that contains two references to *one* copy
-        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
-        performance when calling ``elem.qobj(t)`` later.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
-        )
-
-    def __call__(self, t, args=None):
-        if args:
-            cache = []
-            self = self.replace_arguments(args, cache)
-        return self.qobj(t) * self.coeff(t)
-
-
-cdef class _ConstantElement(_BaseElement):
-    """
-    Constant part of a list format :obj:`QobjEvo`.
-    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
-
-      qevo = QobjEvo(H0)
-      qevo.elements = [_ConstantElement(H0)]
-    """
-    def __init__(self, qobj):
-        self._qobj = qobj
-
-    def __mul__(left, right):
-        if type(left) is _ConstantElement:
-            return _ConstantElement((<_ConstantElement> left)._qobj * right)
-        elif type(right) is _ConstantElement:
-            return _ConstantElement((<_ConstantElement> right)._qobj * left)
-        return NotImplemented
-
-    def __matmul__(left, right):
-        if type(left) is _ConstantElement and type(right) is _ConstantElement:
-            return _ConstantElement(
-                (<_ConstantElement> left)._qobj @
-                (<_ConstantElement> right)._qobj
-            )
-        return NotImplemented
-
-    cpdef Data data(self, t):
-        return self._qobj.data
-
-    cpdef object qobj(self, t):
-        return self._qobj
-
-    cpdef object coeff(self, t):
-        return 1.
-
-    def linear_map(self, f, anti=False):
-        return _ConstantElement(f(self._qobj))
-
-    def replace_arguments(self, args, cache=None):
-        return self
-
-    def __call__(self, t, args=None):
-        return self._qobj
-
-
-cdef class _EvoElement(_BaseElement):
-    """
-    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
-    time-dependent operator::
-
-      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
-      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
-    """
-    def __init__(self, qobj, coefficient):
-        self._qobj = qobj
-        self._coefficient = coefficient
-
-    def __mul__(left, right):
-        cdef _EvoElement base
-        cdef object factor
-        if type(left) is _EvoElement:
-            base = left
-            factor = right
-        if type(right) is _EvoElement:
-            base = right
-            factor = left
-        return _EvoElement(base._qobj * factor, base._coefficient)
-
-    def __matmul__(left, right):
-        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
-            coefficient = left._coefficient * right._coefficient
-        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
-            coefficient = left._coefficient
-        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
-            coefficient = right._coefficient
-        else:
-            return NotImplemented
-        return _EvoElement(left._qobj * right._qobj, coefficient)
-
-    cpdef Data data(self, t):
-        return self._qobj.data
-
-    cpdef object qobj(self, t):
-        return self._qobj
-
-    cpdef object coeff(self, t):
-        return self._coefficient(t)
-
-    def linear_map(self, f, anti=False):
-        return _EvoElement(
-            f(self._qobj),
-            self._coefficient.conj() if anti else self._coefficient,
-        )
-
-    def replace_arguments(self, args, cache=None):
-        return _EvoElement(
-            self._qobj.copy(),
-            self._coefficient.replace_arguments(args)
-        )
-
-
-cdef class _FuncElement(_BaseElement):
-    """
-    Used with :obj:`QobjEvo` to build an evolution term from a function with
-    either the signature: ::
-
-        func(t: float, ...) -> Qobj
-
-    or the older QuTiP 4 style signature: ::
-
-        func(t: float, args: dict) -> Qobj
-
-    In the new style, ``func`` may accept arbitrary named arguments and
-    is called as ``func(t, **args)``.
-
-    A :obj:`QobjEvo` created from such a function contains one
-    :obj:`_FuncElement`: ::
-
-        qevo = QobjEvo(func, args=args)
-        qevo.elements = [_FuncElement(func, args)]
-
-    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
-    of function and argument.
-
-    This class has a basic capacity to memoize calls to ``func`` by saving the
-    result of the last call ::
-
-        op = QobjEvo(func, args=args)
-        (op.dag() * op)(t)
-
-    calls ``func`` only once.
-
-    Parameters
-    ----------
-    func : callable(t : float, ...) -> Qobj
-        Function returning the element value at time ``t``.
-
-    args : dict
-        Values of the arguments to pass to ``func``.
-
-    style : {None, "pythonic", "dict", "auto"}
-        The style of the signature used. If style is ``None``,
-        the value of ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
-    style and parameter detection and are not intended to be part of
-    the public interface.
-    """
-
-    _UNSET = object()
-
-    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
-        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
-            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
-                raise TypeError(
-                    "_f_pythonic and _f_parameters should always be given together."
-                )
-            _f_pythonic, _f_parameters = coefficient_function_parameters(
-                func, style=style)
-            if _f_parameters is not None:
-                args = {k: args[k] for k in _f_parameters & args.keys()}
-            else:
-                args = args.copy()
-        self._func = func
-        self._args = args
-        self._f_pythonic = _f_pythonic
-        self._f_parameters = _f_parameters
-        self._previous = (Nan, None)
-
-    def __mul__(left, right):
-        cdef _MapElement out
-        if type(left) is _FuncElement:
-            out = _MapElement(left, [], right)
-        if type(right) is _FuncElement:
-            out = _MapElement(right, [], left)
-        return out
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    cpdef Data data(self, t):
-        return self.qobj(t).data
-
-    cpdef object qobj(self, t):
-        cdef double _t
-        cdef object _qobj
-        _t, _qobj = self._previous
-        if t == _t:
-            return _qobj
-        if self._f_pythonic:
-            _qobj = self._func(t, **self._args)
-        else:
-            _qobj = self._func(t, self._args)
-        self._previous = (t, _qobj)
-        return _qobj
-
-    cpdef object coeff(self, t):
-        return 1.
-
-    def linear_map(self, f, anti=False):
-        return _MapElement(self, [f])
-
-    def replace_arguments(_FuncElement self, args, cache=None):
-        if self._f_parameters is not None:
-            args = {k: args[k] for k in self._f_parameters & args.keys()}
-        if not args:
-            return self
-        if cache is not None:
-            for old, new in cache:
-                if old is self:
-                    return new
-        new = _FuncElement(
-                self._func,
-                {**self._args, **args},
-                _f_pythonic=self._f_pythonic,
-                _f_parameters=self._f_parameters,
-        )
-        if cache is not None:
-            cache.append((self, new))
-        return new
-
-
-cdef class _MapElement(_BaseElement):
-    """
-    :obj:`_FuncElement` decorated with linear tranformations.
-
-    Linear tranformations available in :obj:`QobjEvo` include transpose,
-    adjoint, conjugate, convertion and product with number::
-    ```
-        op = QobjEvo(f, args=args)
-        op2 = op.conj().dag() * 2
-    ```
-    Then ``op2.elements`` is::
-        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
-
-    """
-    def __init__(self, _FuncElement base, transform, coeff=1.):
-        self._base = base
-        self._transform = transform
-        self._coeff = coeff
-
-    def __mul__(left, right):
-        cdef _MapElement out, self
-        cdef double complex factor
-        if type(left) is _MapElement:
-            self = left
-            factor = right
-        elif type(right) is _MapElement:
-            self = right
-            factor = left
-        return _MapElement(
-            self._base,
-            self._transform.copy(),
-            self._coeff*factor
-        )
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    cpdef Data data(self, t):
-        return self.qobj(t).data
-
-    cpdef object qobj(self, t):
-        out = self._base.qobj(t)
-        for func in self._transform:
-            out = func(out)
-        return out
-
-    cpdef object coeff(self, t):
-        return self._coeff
-
-    def linear_map(self, f, anti=False):
-        return _MapElement(
-            self._base,
-            self._transform + [f],
-            conj(self._coeff) if anti else self._coeff
-        )
-
-    def replace_arguments(_MapElement self, args, cache=None):
-        return _MapElement(
-            self._base.replace_arguments(args, cache=cache),
-            self._transform.copy(),
-            self._coeff,
-        )
-
-
-cdef class _ProdElement(_BaseElement):
-    """
-    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
-    :obj:`_BaseElement`. Include a stack of linear transformation to be
-    applied after the product::
-
-        ``op = QobjEvo(f) * qobj1``
-    Then ``op.elements`` is::
-        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
-    """
-    def __init__(self, left, right, transform, conj=False):
-        self._left = left
-        self._right = right
-        self._conj = conj
-        self._transform = transform
-
-    def __mul__(left, right):
-        cdef _ProdElement self
-        cdef double complex factor
-        if type(left) is _ProdElement:
-            self = left
-            factor = right
-        if type(right) is _ProdElement:
-            self = right
-            factor = left
-        return _ProdElement(self._left, self._right * factor,
-                            self._transform.copy(), self._conj)
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    cpdef Data data(self, t):
-        return self.qobj(t).data
-
-    cpdef object qobj(self, t):
-        out = self._left.qobj(t) @ self._right.qobj(t)
-        for func in self._transform:
-            out = func(out)
-        return out
-
-    cpdef object coeff(self, t):
-        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
-        return conj(out) if self._conj else out
-
-    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
-        cdef Data temp
-        if not self._transform:
-            temp = self._right.matmul_data_t(t, state)
-            out = self._left.matmul_data_t(t, temp, out)
-            return out
-        elif type(state) is Dense and type(out) is Dense:
-            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
-            return out
-        else:
-            return _data.add(
-                out,
-                _data.matmul(self.data(t), state, self.coeff(t))
-            )
-
-    def linear_map(self, f, anti=False):
-        return _ProdElement(
-            self._left, self._right,
-            self._transform + [f],
-            self._conj ^ anti
-        )
-
-    def replace_arguments(_ProdElement self, args, cache=None):
-        return _ProdElement(
-            self._left.replace_arguments(args, cache=cache),
-            self._right.replace_arguments(args, cache=cache),
-            self._transform.copy(),
-            self._conj
-        )
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+
+from .. import data as _data
+from qutip.core.cy.coefficient import coefficient_function_parameters
+from qutip.core.data cimport Dense, Data, dense
+from qutip.core.data.matmul cimport *
+from math import nan as Nan
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+__all__ = ['_ConstantElement', '_EvoElement',
+           '_FuncElement', '_MapElement', '_ProdElement']
+
+
+cdef class _BaseElement:
+    """
+    The representation of a single time-dependent term in the list of
+    terms used by QobjEvo and solvers to describe operators.
+
+    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
+    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
+    are functions of time. :meth:`~_BaseElement.coeff` returns the
+    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
+
+    For example, a :obj:`QobjEvo` instance created by::
+
+      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
+
+    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
+    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
+
+    :obj:`~_BaseElement` defines the interface to time-dependent terms.
+    Sub-classes implement terms defined in different ways.
+    For example, :obj:`~_ConstantElement` implements a term that
+    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
+    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
+    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
+    so on.
+
+    .. note::
+
+      There are three methods to return the factors of the term.
+
+      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
+      coefficient and operator factors respectively. They are separate to
+      avoid constructing an intermediate Python object when called from
+      Cython code (which may take as long as the rest of the call).
+
+      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
+      provides a convenience method for this common operation.
+
+    .. note::
+
+      All :obj:`~_BaseElement` instances are immutable and methods that would
+      modify an object return a new instance instead.
+    """
+    cpdef Data data(self, t):
+        """
+        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
+        of the term at time ``t``.
+
+        Parameters
+        ----------
+        t : double
+          The time, ``t``.
+
+        Returns
+        -------
+        :obj:`~Data`
+          The underlying data of the :obj:`~Qobj` component of the term
+          at time ``t``.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .data(t)."
+        )
+
+    cpdef object qobj(self, t):
+        """
+        Returns the :obj:`~Qobj` component of the term at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+          The time, ``t``.
+
+        Returns
+        -------
+        :obj:`~Qobj`
+          The :obj:`~Qobj` component of the term at time ``t``.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .qobj(t)."
+        )
+
+    cpdef object coeff(self, t):
+        """
+        Returns the complex coefficient of the term at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+          The time, ``t``.
+
+        Returns
+        -------
+        complex
+          The complex coefficient of the term at time ``t``.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .coeff(t)."
+        )
+
+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
+        """
+        Possibly in-place multiplication and addition. Multiplies a given state
+        by the elemen's value at time ``t`` and adds the result to ``out``.
+        Equivalent to::
+
+          out += self.coeff(t) * self.qobj(t) @ state
+
+        Sub-classes may override :meth:`~matmul_data_t` to provide an more
+        efficient implementation.
+
+        Parameters
+        ----------
+        t : double
+          The time, ``t``.
+
+        state : :obj:`~Data`
+          The state to multiply by the element term.
+
+        out : :obj:`~Data` or ``NULL``
+          The output to add the result of the multiplication to. If ``NULL``,
+          the result of the multiplication is returned directly (i.e. ``out``
+          is assumed to be the zero matrix).
+
+        Returns
+        -------
+        data
+          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
+          the addition possibly having been performed in-place on ``out``.
+
+        .. note::
+
+          Because of the possibly but not definitely in-place behaviour of
+          this function, the result should always be assigned to some variable
+          and surrounding code should assume that ``out`` maybe have been
+          modified and that the result may be a reference to ``out``. The
+          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
+
+        .. note::
+
+          This method would ideally be implemented using a special
+          function dispatched by the data layer so that it did not have to
+          special case the ``Dense`` operation itself, but the data layer
+          dispatch does not yet support in-place operations. Once it does
+          this method should be updated to use the new support.
+        """
+        if out is None:
+            return _data.matmul(self.data(t), state, self.coeff(t))
+        elif type(state) is Dense and type(out) is Dense:
+            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
+            return out
+        else:
+            return _data.add(
+                out,
+                _data.matmul(self.data(t), state, self.coeff(t))
+            )
+
+    def linear_map(self, f, anti=False):
+        """
+        Return a new element representing a linear transformation ``f``
+        of the :obj:`~Qobj` portion of this element and possibly a
+        complex conjucation of the coefficient portion (when ``f`` is an
+        antilinear map).
+
+        If this element represents ``coeff * qobj`` the returned element
+        represents ``coeff * f(obj)`` (if ``anti=False``) or
+        ``conj(coeff) * f(obj)`` (if ``anti=True``).
+
+        Parameters
+        ----------
+        f : function
+          The linear transformation to apply to the :obj:`~Qobj` of this
+          element.
+        anti : bool
+          Whether to take the complex conjugate of the coefficient. Default
+          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
+          map such as the adjoint (i.e. dagger).
+
+        Returns
+        -------
+        _BaseElement
+          A new element with the transformation applied.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .linear_map(t)."
+        )
+
+    def replace_arguments(self, args, cache=None):
+        """
+        Return a copy of the element with the (possible) additional arguments
+        to any time-dependent functions updated to the given argument values.
+        The arguments of any contained :obj:`~Coefficient` instances are also
+        replaced.
+
+        If the operation does not modify this element, the original element
+        may be returned.
+
+        Parameters
+        ----------
+        args : dict
+          A dictionary of arguments to update. Keys are the names of the
+          arguments and values are the new argument values. Arguments
+          not included retain their original values.
+
+        cache : list or ``None``
+          A cache to add updated elements to. Unmodified elements are not
+          added to the cache. If a cache is supplied and ``.replace_arguments``
+          would be called again on the same element with the same arguments,
+          the new element from the cache will be returned instead.
+
+          By default the cache is ``None`` and no caching is performed. Cache
+          users should supply either ``cache=[]`` (which activates caching)
+          or an existing cache (for example, if making calls on sub-elements
+          of some composite element).
+
+        Returns
+        -------
+        _BaseElement
+          A new element with the arguments replaced, or possibly this element
+          if it would not be modified.
+
+        Example
+        -------
+
+        If ``elem`` is a product element for ``op * op.dag()`` it will contain
+        two references to the same element for ``op``. Calling::
+
+          elem = elem.replace_arguments({"theta": 3.1416})
+
+        will return a new element that contains two *different* copies of
+        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
+        to be evaluated *twice* when ``elem.qobj(t)`` is called.
+
+        Calling instead::
+
+          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
+
+        will return a new element that contains two references to *one* copy
+        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
+        performance when calling ``elem.qobj(t)`` later.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
+        )
+
+    def __call__(self, t, args=None):
+        if args:
+            cache = []
+            self = self.replace_arguments(args, cache)
+        return self.qobj(t) * self.coeff(t)
+
+
+cdef class _ConstantElement(_BaseElement):
+    """
+    Constant part of a list format :obj:`QobjEvo`.
+    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
+
+      qevo = QobjEvo(H0)
+      qevo.elements = [_ConstantElement(H0)]
+    """
+    def __init__(self, qobj):
+        self._qobj = qobj
+
+    def __mul__(left, right):
+        if type(left) is _ConstantElement:
+            return _ConstantElement((<_ConstantElement> left)._qobj * right)
+        elif type(right) is _ConstantElement:
+            return _ConstantElement((<_ConstantElement> right)._qobj * left)
+        return NotImplemented
+
+    def __matmul__(left, right):
+        if type(left) is _ConstantElement and type(right) is _ConstantElement:
+            return _ConstantElement(
+                (<_ConstantElement> left)._qobj @
+                (<_ConstantElement> right)._qobj
+            )
+        return NotImplemented
+
+    cpdef Data data(self, t):
+        return self._qobj.data
+
+    cpdef object qobj(self, t):
+        return self._qobj
+
+    cpdef object coeff(self, t):
+        return 1.
+
+    def linear_map(self, f, anti=False):
+        return _ConstantElement(f(self._qobj))
+
+    def replace_arguments(self, args, cache=None):
+        return self
+
+    def __call__(self, t, args=None):
+        return self._qobj
+
+
+cdef class _EvoElement(_BaseElement):
+    """
+    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
+    time-dependent operator::
+
+      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
+      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
+    """
+    def __init__(self, qobj, coefficient):
+        self._qobj = qobj
+        self._coefficient = coefficient
+
+    def __mul__(left, right):
+        cdef _EvoElement base
+        cdef object factor
+        if type(left) is _EvoElement:
+            base = left
+            factor = right
+        if type(right) is _EvoElement:
+            base = right
+            factor = left
+        return _EvoElement(base._qobj * factor, base._coefficient)
+
+    def __matmul__(left, right):
+        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
+            coefficient = left._coefficient * right._coefficient
+        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
+            coefficient = left._coefficient
+        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
+            coefficient = right._coefficient
+        else:
+            return NotImplemented
+        return _EvoElement(left._qobj * right._qobj, coefficient)
+
+    cpdef Data data(self, t):
+        return self._qobj.data
+
+    cpdef object qobj(self, t):
+        return self._qobj
+
+    cpdef object coeff(self, t):
+        return self._coefficient(t)
+
+    def linear_map(self, f, anti=False):
+        return _EvoElement(
+            f(self._qobj),
+            self._coefficient.conj() if anti else self._coefficient,
+        )
+
+    def replace_arguments(self, args, cache=None):
+        return _EvoElement(
+            self._qobj.copy(),
+            self._coefficient.replace_arguments(args)
+        )
+
+
+cdef class _FuncElement(_BaseElement):
+    """
+    Used with :obj:`QobjEvo` to build an evolution term from a function with
+    either the signature: ::
+
+        func(t: float, ...) -> Qobj
+
+    or the older QuTiP 4 style signature: ::
+
+        func(t: float, args: dict) -> Qobj
+
+    In the new style, ``func`` may accept arbitrary named arguments and
+    is called as ``func(t, **args)``.
+
+    A :obj:`QobjEvo` created from such a function contains one
+    :obj:`_FuncElement`: ::
+
+        qevo = QobjEvo(func, args=args)
+        qevo.elements = [_FuncElement(func, args)]
+
+    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
+    of function and argument.
+
+    This class has a basic capacity to memoize calls to ``func`` by saving the
+    result of the last call ::
+
+        op = QobjEvo(func, args=args)
+        (op.dag() * op)(t)
+
+    calls ``func`` only once.
+
+    Parameters
+    ----------
+    func : callable(t : float, ...) -> Qobj
+        Function returning the element value at time ``t``.
+
+    args : dict
+        Values of the arguments to pass to ``func``.
+
+    style : {None, "pythonic", "dict", "auto"}
+        The style of the signature used. If style is ``None``,
+        the value of ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
+    style and parameter detection and are not intended to be part of
+    the public interface.
+    """
+
+    _UNSET = object()
+
+    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
+        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
+            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
+                raise TypeError(
+                    "_f_pythonic and _f_parameters should always be given together."
+                )
+            _f_pythonic, _f_parameters = coefficient_function_parameters(
+                func, style=style)
+            if _f_parameters is not None:
+                args = {k: args[k] for k in _f_parameters & args.keys()}
+            else:
+                args = args.copy()
+        self._func = func
+        self._args = args
+        self._f_pythonic = _f_pythonic
+        self._f_parameters = _f_parameters
+        self._previous = (Nan, None)
+
+    def __mul__(left, right):
+        cdef _MapElement out
+        if type(left) is _FuncElement:
+            out = _MapElement(left, [], right)
+        if type(right) is _FuncElement:
+            out = _MapElement(right, [], left)
+        return out
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    cpdef Data data(self, t):
+        return self.qobj(t).data
+
+    cpdef object qobj(self, t):
+        cdef double _t
+        cdef object _qobj
+        _t, _qobj = self._previous
+        if t == _t:
+            return _qobj
+        if self._f_pythonic:
+            _qobj = self._func(t, **self._args)
+        else:
+            _qobj = self._func(t, self._args)
+        self._previous = (t, _qobj)
+        return _qobj
+
+    cpdef object coeff(self, t):
+        return 1.
+
+    def linear_map(self, f, anti=False):
+        return _MapElement(self, [f])
+
+    def replace_arguments(_FuncElement self, args, cache=None):
+        if self._f_parameters is not None:
+            args = {k: args[k] for k in self._f_parameters & args.keys()}
+        if not args:
+            return self
+        if cache is not None:
+            for old, new in cache:
+                if old is self:
+                    return new
+        new = _FuncElement(
+                self._func,
+                {**self._args, **args},
+                _f_pythonic=self._f_pythonic,
+                _f_parameters=self._f_parameters,
+        )
+        if cache is not None:
+            cache.append((self, new))
+        return new
+
+
+cdef class _MapElement(_BaseElement):
+    """
+    :obj:`_FuncElement` decorated with linear tranformations.
+
+    Linear tranformations available in :obj:`QobjEvo` include transpose,
+    adjoint, conjugate, convertion and product with number::
+    ```
+        op = QobjEvo(f, args=args)
+        op2 = op.conj().dag() * 2
+    ```
+    Then ``op2.elements`` is::
+        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
+
+    """
+    def __init__(self, _FuncElement base, transform, coeff=1.):
+        self._base = base
+        self._transform = transform
+        self._coeff = coeff
+
+    def __mul__(left, right):
+        cdef _MapElement out, self
+        cdef double complex factor
+        if type(left) is _MapElement:
+            self = left
+            factor = right
+        elif type(right) is _MapElement:
+            self = right
+            factor = left
+        return _MapElement(
+            self._base,
+            self._transform.copy(),
+            self._coeff*factor
+        )
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    cpdef Data data(self, t):
+        return self.qobj(t).data
+
+    cpdef object qobj(self, t):
+        out = self._base.qobj(t)
+        for func in self._transform:
+            out = func(out)
+        return out
+
+    cpdef object coeff(self, t):
+        return self._coeff
+
+    def linear_map(self, f, anti=False):
+        return _MapElement(
+            self._base,
+            self._transform + [f],
+            conj(self._coeff) if anti else self._coeff
+        )
+
+    def replace_arguments(_MapElement self, args, cache=None):
+        return _MapElement(
+            self._base.replace_arguments(args, cache=cache),
+            self._transform.copy(),
+            self._coeff,
+        )
+
+
+cdef class _ProdElement(_BaseElement):
+    """
+    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
+    :obj:`_BaseElement`. Include a stack of linear transformation to be
+    applied after the product::
+
+        ``op = QobjEvo(f) * qobj1``
+    Then ``op.elements`` is::
+        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
+    """
+    def __init__(self, left, right, transform, conj=False):
+        self._left = left
+        self._right = right
+        self._conj = conj
+        self._transform = transform
+
+    def __mul__(left, right):
+        cdef _ProdElement self
+        cdef double complex factor
+        if type(left) is _ProdElement:
+            self = left
+            factor = right
+        if type(right) is _ProdElement:
+            self = right
+            factor = left
+        return _ProdElement(self._left, self._right * factor,
+                            self._transform.copy(), self._conj)
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    cpdef Data data(self, t):
+        return self.qobj(t).data
+
+    cpdef object qobj(self, t):
+        out = self._left.qobj(t) @ self._right.qobj(t)
+        for func in self._transform:
+            out = func(out)
+        return out
+
+    cpdef object coeff(self, t):
+        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
+        return conj(out) if self._conj else out
+
+    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
+        cdef Data temp
+        if not self._transform:
+            temp = self._right.matmul_data_t(t, state)
+            out = self._left.matmul_data_t(t, temp, out)
+            return out
+        elif type(state) is Dense and type(out) is Dense:
+            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
+            return out
+        else:
+            return _data.add(
+                out,
+                _data.matmul(self.data(t), state, self.coeff(t))
+            )
+
+    def linear_map(self, f, anti=False):
+        return _ProdElement(
+            self._left, self._right,
+            self._transform + [f],
+            self._conj ^ anti
+        )
+
+    def replace_arguments(_ProdElement self, args, cache=None):
+        return _ProdElement(
+            self._left.replace_arguments(args, cache=cache),
+            self._right.replace_arguments(args, cache=cache),
+            self._transform.copy(),
+            self._conj
+        )
diff --git a/qutip/core/cy/coefficient.pxd b/qutip/core/cy/coefficient.pxd
index f81858c2ef..c4824b7d4a 100644
--- a/qutip/core/cy/coefficient.pxd
+++ b/qutip/core/cy/coefficient.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-cdef class Coefficient:
-    cdef readonly dict args
-    cdef double complex _call(self, double t) except *
-    cpdef Coefficient copy(self)
+#cython: language_level=3
+cdef class Coefficient:
+    cdef readonly dict args
+    cdef double complex _call(self, double t) except *
+    cpdef Coefficient copy(self)
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 79fd84e5ae..b2755c3a4a 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -1,728 +1,728 @@
-#cython: language_level=3
-import inspect
-import pickle
-import scipy
-from scipy.interpolate import make_interp_spline
-import numpy as np
-cimport numpy as cnp
-cimport cython
-import qutip
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-    double         norm(double complex x)
-
-
-def coefficient_function_parameters(func, style=None):
-    """
-    Return the function style (either "pythonic" or not) and a list of
-    additional parameters accepted.
-
-    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
-    call signature of the supplied function based on the given style (or
-    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
-    and the signature of the given function.
-
-    Parameters
-    ----------
-    func : function
-        The :obj:`FunctionCoefficient` to inspect. The first argument
-        of the function is assumed to be ``t`` (the time at which to
-        evaluate the coefficient). The remaining arguments depend on
-        the signature style (see below).
-
-    style : {None, "pythonic", "dict", "auto"}
-        The style of the signature used. If style is ``None``,
-        the value of ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-    Returns
-    -------
-    (f_pythonic, f_parameters)
-
-    f_pythonic : bool
-        True if the function should be called as ``f(t, **kw)`` and False
-        if the function should be called as ``f(t, kw_dict)``.
-
-    f_parameters : set or None
-        The set of parameters (other than ``t``) of the function or
-        ``None`` if the function accepts arbitrary parameters.
-    """
-    sig = inspect.signature(func)
-    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
-    if style is None:
-        style = qutip.settings.core["function_coefficient_style"]
-    if style == "auto":
-        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
-            # if the signature is exactly f(t, args), then assume parameters
-            # are supplied in an argument dictionary
-            style = "dict"
-        else:
-            style = "pythonic"
-    if style == "dict" or f_has_kw:
-        # f might accept any parameter
-        f_parameters = None
-    else:
-        # f accepts only t and the named parameters
-        f_parameters = set(list(sig.parameters.keys())[1:])
-    return (style == "pythonic", f_parameters)
-
-
-cdef class Coefficient:
-    """
-    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
-    composing time-dependant operator in list format for :obj:`QobjEvo`.
-
-    :obj:`Coefficient` are immutable.
-    """
-    def __init__(self, args, **_):
-        self.args = args
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return self
-
-    def __call__(self, t, dict _args=None, **kwargs):
-        """
-        Return the coefficient value at time `t`.
-        Stored arguments can overwriten with `_args` or as keywords parameters.
-
-        Parameters
-        ----------
-        t : float
-            Time at which to evaluate the :obj:`Coefficient`.
-
-        _args : dict
-            Dictionary of arguments to use instead of the stored ones.
-
-        **kwargs
-            Arguments to overwrite for this call.
-        """
-        if _args is not None or kwargs:
-            return (<Coefficient> self.replace_arguments(_args,
-                                                         **kwargs))._call(t)
-        return self._call(t)
-
-    cdef double complex _call(self, double t) except *:
-        """Core computation of the :obj:`Coefficient`."""
-        # All Coefficient sub-classes should overwrite this or __call__
-        return complex(self(t))
-
-    def __add__(left, right):
-        if (
-            isinstance(left, InterCoefficient)
-            and isinstance(right, InterCoefficient)
-        ):
-            return add_inter(left, right)
-        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
-            return SumCoefficient(left.copy(), right.copy())
-        return NotImplemented
-
-    def __mul__(left, right):
-        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
-            return MulCoefficient(left.copy(), right.copy())
-        if isinstance(left, qutip.Qobj):
-            return qutip.QobjEvo([left.copy(), right.copy()])
-        if isinstance(right, qutip.Qobj):
-            return qutip.QobjEvo([right.copy(), left.copy()])
-        return NotImplemented
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return pickle.loads(pickle.dumps(self))
-
-    def conj(self):
-        """ Return a conjugate :obj:`Coefficient` of this"""
-        return ConjCoefficient(self)
-
-    def _cdc(self):
-        """ Return a :obj:`Coefficient` being the norm of this"""
-        return NormCoefficient(self)
-
-
-@cython.auto_pickle(True)
-cdef class FunctionCoefficient(Coefficient):
-    """
-    :obj:`Coefficient` wrapping a Python function.
-
-    Parameters
-    ----------
-    func : callable(t : float, ...) -> complex
-        Function returning the coefficient value at time ``t``.
-
-    args : dict
-        Values of the arguments to pass to ``func``.
-
-    style : {None, "pythonic", "dict", "auto"}
-        The style of function signature used. If style is ``None``,
-        the value of ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
-    style and parameter detection and are not intended to be part of
-    the public interface.
-    """
-    cdef object func
-    cdef bint _f_pythonic
-    cdef set _f_parameters
-
-    _UNSET = object()
-
-    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
-                 _f_parameters=_UNSET, **_):
-        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
-            if not (_f_pythonic is self._UNSET
-                    and _f_parameters is self._UNSET):
-                raise TypeError(
-                    "_f_pythonic and _f_parameters should "
-                    "always be given together."
-                )
-            _f_pythonic, _f_parameters = coefficient_function_parameters(
-                func, style=style)
-            if _f_parameters is not None:
-                args = {k: args[k] for k in _f_parameters & args.keys()}
-            else:
-                args = args.copy()
-        self.func = func
-        self.args = args
-        self._f_pythonic = _f_pythonic
-        self._f_parameters = _f_parameters
-
-    def __call__(self, t, dict _args=None, **kwargs):
-        if _args is not None or kwargs:
-            return self.replace_arguments(_args, **kwargs)(t)
-        if self._f_pythonic:
-            return self.func(t, **self.args)
-        return self.func(t, self.args)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return FunctionCoefficient(
-            self.func,
-            self.args.copy(),
-            _f_pythonic=self._f_pythonic,
-            _f_parameters=self._f_parameters,
-        )
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        if _args:
-            kwargs.update(_args)
-        if self._f_parameters is not None:
-            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
-        if not kwargs:
-            return self
-        return FunctionCoefficient(
-            self.func,
-            {**self.args, **kwargs},
-            _f_pythonic=self._f_pythonic,
-            _f_parameters=self._f_parameters,
-        )
-
-
-def proj(x):
-    if np.isfinite(x):
-        return (x)
-    else:
-        return np.inf + 0j * np.imag(x)
-
-
-cdef class StrFunctionCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` defined by a string containing a simple Python
-    expression.
-
-    The string should contain a compilable Python expression that results in a
-    complex number. The time ``t`` is available as a local variable, as are the
-    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
-    itself is not accessible.
-
-    The following symbols are defined:
-        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
-        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
-        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
-        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
-        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
-
-    Examples
-    --------
-    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
-
-    Parameters
-    ----------
-    base : str
-        A string representing a compilable Python expression that results in a
-        complex number.
-
-    args : dict
-        A dictionary of variable used in the code string. It may include unused
-        variables.
-    """
-    cdef object func
-    cdef str base
-
-    str_env = {
-        "sin": np.sin,
-        "cos": np.cos,
-        "tan": np.tan,
-        "asin": np.arcsin,
-        "acos": np.arccos,
-        "atan": np.arctan,
-        "pi": np.pi,
-        "sinh": np.sinh,
-        "cosh": np.cosh,
-        "tanh": np.tanh,
-        "asinh": np.arcsinh,
-        "acosh": np.arccosh,
-        "atanh": np.arctanh,
-        "exp": np.exp,
-        "log": np.log,
-        "log10": np.log10,
-        "erf": scipy.special.erf,
-        "zerf": scipy.special.erf,
-        "sqrt": np.sqrt,
-        "real": np.real,
-        "imag": np.imag,
-        "conj": np.conj,
-        "abs": np.abs,
-        "norm": lambda x: np.abs(x)**2,
-        "arg": np.angle,
-        "proj": proj,
-        "np": np,
-        "spe": scipy.special}
-
-    def __init__(self, base, dict args, **_):
-        args2var = "\n".join(["    {} = args['{}']".format(key, key)
-                              for key in args])
-        code = f"""
-def coeff(t, args):
-{args2var}
-    return {base}"""
-        lc = {}
-        exec(code, self.str_env, lc)
-        self.base = base
-        self.func = lc["coeff"]
-        self.args = args
-
-    cdef complex _call(self, double t) except *:
-        return self.func(t, self.args)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return StrFunctionCoefficient(self.base, self.args.copy())
-
-    def __reduce__(self):
-        return (StrFunctionCoefficient, (self.base, self.args))
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        if _args:
-            kwargs.update(_args)
-        if kwargs:
-            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
-        return self
-
-
-cdef class InterCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` built from an interpolation of a numpy array.
-
-    Parameters
-    ----------
-    coeff_arr : np.ndarray
-        The array of coefficient values to interpolate.
-
-    tlist : np.ndarray
-        An array of times corresponding to each coefficient value. The times
-        must be increasing, but do not need to be uniformly spaced.
-
-    order : int
-        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
-        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
-
-    boundary_conditions : 2-Tuple, str or None, optional
-        Boundary conditions for spline evaluation. Default value is `None`.
-        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
-        Refer to Scipy's documentation for further details:
-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-    """
-    cdef int order
-    cdef double dt
-    cdef double[::1] tlist
-    cdef complex[:, :] poly
-    cdef object np_arrays
-
-    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
-        tlist = np.array(tlist, dtype=np.float64)
-        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
-
-        if coeff_arr.ndim != 1:
-            raise ValueError("The array to interpolate must be a 1D array")
-        if coeff_arr.shape != tlist.shape:
-            raise ValueError("tlist must be the same len "
-                             "as the array to interpolate")
-        if order < 0:
-            raise ValueError("order must be a positive integer")
-
-        order = min(order, len(tlist) - 1)
-
-        if order == 0:
-            coeff_arr = coeff_arr.reshape((1, -1))
-        elif order == 1:
-            coeff_arr = np.vstack([
-                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
-                    coeff_arr
-                ])
-        elif order >= 2:
-            # Use scipy to compute the spline and transform it to polynomes
-            # as used in scipy's PPoly which is easier for us to use.
-            spline = make_interp_spline(tlist, coeff_arr, k=order,
-                                        bc_type=boundary_conditions)
-            # Scipy can move knots, we add them to tlist
-            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
-            a = np.arange(spline.k+1)
-            a[0] = 1
-            fact = np.cumprod(a)
-            coeff_arr = np.concatenate([
-                spline(tlist, i) / fact[i]
-                for i in range(spline.k, -1, -1)
-            ]).reshape((spline.k+1, -1))
-
-        self._prepare(tlist, coeff_arr)
-
-    def _prepare(self, np_tlist, np_poly, dt=None):
-        self.np_arrays = (np_tlist, np_poly)
-        self.tlist = np_tlist
-        self.poly = np_poly
-        self.order = self.poly.shape[0] - 1
-        diff = np.diff(self.np_arrays[0])
-        if dt is not None:
-            self.dt = dt
-        elif len(diff) >= 1 and np.allclose(diff[0], diff):
-            self.dt = diff[0]
-        else:
-            self.dt = 0
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef size_t _binary_search(self, double x):
-        # Binary search for the interval
-        # return the indice of the of the biggest element where t <= x
-        cdef size_t low = 0
-        cdef size_t high = self.tlist.shape[0]
-        cdef size_t middle
-        cdef size_t count = 0
-        while low+1 != high and count < 64:
-            middle = (low + high)//2
-            if x < self.tlist[middle]:
-                high = middle
-            else:
-                low = middle
-            # We keep a count to be sure that it never get into an infinit loop
-            # even if tlist has an unexpected format.
-            count += 1
-        return low
-
-    @cython.initializedcheck(False)
-    @cython.cdivision(True)
-    cdef double complex _call(self, double t) except *:
-        cdef size_t idx, i
-        cdef double factor
-        cdef double complex out
-        cdef double complex[:] slice
-        if t <= self.tlist[0]:
-            return self.poly[-1, 0]
-        elif t >= self.tlist[-1]:
-            return self.poly[-1, -1]
-        if self.dt:
-            idx = <size_t>((t - self.tlist[0]) / self.dt)
-        else:
-            idx = self._binary_search(t)
-        if self.order == 0:
-            out = self.poly[0, idx]
-        else:
-            factor = t - self.tlist[idx]
-            slice = self.poly[:, idx]
-            out = 0.
-            for i in range(self.order+1):
-                out *= factor
-                out += slice[i]
-        return out
-
-    def __reduce__(self):
-        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
-
-    @classmethod
-    def restore(cls, np_tlist, np_poly, dt=None):
-        cdef InterCoefficient out = cls.__new__(cls)
-        out._prepare(np_tlist, np_poly, dt)
-        return out
-
-    @classmethod
-    def from_PPoly(cls, ppoly, **_):
-        return cls.restore(ppoly.x, ppoly.c)
-
-    @classmethod
-    def from_Bspline(cls, spline, **_):
-        tlist = np.unique(spline.t)
-        a = np.arange(spline.k+1)
-        a[0] = 1
-        fact = np.cumprod(a) + 0j
-        poly = np.concatenate([
-            spline(tlist, i) / fact[i]
-            for i in range(spline.k, -1, -1)
-        ]).reshape((spline.k+1, -1))
-        return cls.restore(tlist, poly)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return InterCoefficient.restore(*self.np_arrays, self.dt)
-
-
-cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
-    """ Add two array coefficient with matching tlist into one."""
-    if (
-        left.np_arrays[0].shape == right.np_arrays[0].shape
-        and np.allclose(left.np_arrays[0], right.np_arrays[0],
-                        rtol=1e-15, atol=1e-15)
-        and (left.order == right.order)
-    ):
-        return InterCoefficient.restore(
-            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
-            left.dt
-        )
-    else:
-        # It would be possible to add them by merging tlist.
-        return SumCoefficient(left, right)
-
-
-@cython.auto_pickle(True)
-cdef class SumCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` built from the sum of two other coefficients.
-
-    A :obj:`SumCoefficient` is returned as the result of the addition of two
-    coefficients, e.g. ::
-
-        coefficient("t * t") + coefficient("t")  # SumCoefficient
-    """
-    cdef Coefficient first
-    cdef Coefficient second
-
-    def __init__(self, Coefficient first, Coefficient second):
-        self.first = first
-        self.second = second
-
-    cdef complex _call(self, double t) except *:
-        return self.first._call(t) + self.second._call(t)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return SumCoefficient(self.first.copy(), self.second.copy())
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return SumCoefficient(
-            self.first.replace_arguments(_args, **kwargs),
-            self.second.replace_arguments(_args, **kwargs)
-        )
-
-
-@cython.auto_pickle(True)
-cdef class MulCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` built from the product of two other coefficients.
-
-    A :obj:`MulCoefficient` is returned as the result of the multiplication of
-    two coefficients, e.g. ::
-
-        coefficient("w * t", args={'w': 1}) * coefficient("t")
-    """
-    cdef Coefficient first
-    cdef Coefficient second
-
-    def __init__(self, Coefficient first, Coefficient second):
-        self.first = first
-        self.second = second
-
-    cdef complex _call(self, double t) except *:
-        return self.first._call(t) * self.second._call(t)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return MulCoefficient(self.first.copy(), self.second.copy())
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return MulCoefficient(
-            self.first.replace_arguments(_args, **kwargs),
-            self.second.replace_arguments(_args, **kwargs)
-        )
-
-
-@cython.auto_pickle(True)
-cdef class ConjCoefficient(Coefficient):
-    """
-    The conjugate of a :obj:`Coefficient`.
-
-    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
-    ``qutip.coefficent.conj(Coefficient)``.
-    """
-    cdef Coefficient base
-
-    def __init__(self, Coefficient base):
-        self.base = base
-
-    cdef complex _call(self, double t) except *:
-        return conj(self.base._call(t))
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return ConjCoefficient(self.base.copy())
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return ConjCoefficient(
-            self.base.replace_arguments(_args, **kwargs)
-        )
-
-
-@cython.auto_pickle(True)
-cdef class NormCoefficient(Coefficient):
-    """
-    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
-    ``conj(coeff) * coeff``.
-
-    :obj:`NormCoefficient` is returned by
-    ``qutip.coefficent.norm(Coefficient)``.
-    """
-    cdef Coefficient base
-
-    def __init__(self, Coefficient base):
-        self.base = base
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return NormCoefficient(
-            self.base.replace_arguments(_args, **kwargs)
-        )
-
-    cdef complex _call(self, double t) except *:
-        return norm(self.base._call(t))
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return NormCoefficient(self.base.copy())
+#cython: language_level=3
+import inspect
+import pickle
+import scipy
+from scipy.interpolate import make_interp_spline
+import numpy as np
+cimport numpy as cnp
+cimport cython
+import qutip
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+    double         norm(double complex x)
+
+
+def coefficient_function_parameters(func, style=None):
+    """
+    Return the function style (either "pythonic" or not) and a list of
+    additional parameters accepted.
+
+    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
+    call signature of the supplied function based on the given style (or
+    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
+    and the signature of the given function.
+
+    Parameters
+    ----------
+    func : function
+        The :obj:`FunctionCoefficient` to inspect. The first argument
+        of the function is assumed to be ``t`` (the time at which to
+        evaluate the coefficient). The remaining arguments depend on
+        the signature style (see below).
+
+    style : {None, "pythonic", "dict", "auto"}
+        The style of the signature used. If style is ``None``,
+        the value of ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+    Returns
+    -------
+    (f_pythonic, f_parameters)
+
+    f_pythonic : bool
+        True if the function should be called as ``f(t, **kw)`` and False
+        if the function should be called as ``f(t, kw_dict)``.
+
+    f_parameters : set or None
+        The set of parameters (other than ``t``) of the function or
+        ``None`` if the function accepts arbitrary parameters.
+    """
+    sig = inspect.signature(func)
+    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
+    if style is None:
+        style = qutip.settings.core["function_coefficient_style"]
+    if style == "auto":
+        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
+            # if the signature is exactly f(t, args), then assume parameters
+            # are supplied in an argument dictionary
+            style = "dict"
+        else:
+            style = "pythonic"
+    if style == "dict" or f_has_kw:
+        # f might accept any parameter
+        f_parameters = None
+    else:
+        # f accepts only t and the named parameters
+        f_parameters = set(list(sig.parameters.keys())[1:])
+    return (style == "pythonic", f_parameters)
+
+
+cdef class Coefficient:
+    """
+    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
+    composing time-dependant operator in list format for :obj:`QobjEvo`.
+
+    :obj:`Coefficient` are immutable.
+    """
+    def __init__(self, args, **_):
+        self.args = args
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return self
+
+    def __call__(self, t, dict _args=None, **kwargs):
+        """
+        Return the coefficient value at time `t`.
+        Stored arguments can overwriten with `_args` or as keywords parameters.
+
+        Parameters
+        ----------
+        t : float
+            Time at which to evaluate the :obj:`Coefficient`.
+
+        _args : dict
+            Dictionary of arguments to use instead of the stored ones.
+
+        **kwargs
+            Arguments to overwrite for this call.
+        """
+        if _args is not None or kwargs:
+            return (<Coefficient> self.replace_arguments(_args,
+                                                         **kwargs))._call(t)
+        return self._call(t)
+
+    cdef double complex _call(self, double t) except *:
+        """Core computation of the :obj:`Coefficient`."""
+        # All Coefficient sub-classes should overwrite this or __call__
+        return complex(self(t))
+
+    def __add__(left, right):
+        if (
+            isinstance(left, InterCoefficient)
+            and isinstance(right, InterCoefficient)
+        ):
+            return add_inter(left, right)
+        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
+            return SumCoefficient(left.copy(), right.copy())
+        return NotImplemented
+
+    def __mul__(left, right):
+        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
+            return MulCoefficient(left.copy(), right.copy())
+        if isinstance(left, qutip.Qobj):
+            return qutip.QobjEvo([left.copy(), right.copy()])
+        if isinstance(right, qutip.Qobj):
+            return qutip.QobjEvo([right.copy(), left.copy()])
+        return NotImplemented
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return pickle.loads(pickle.dumps(self))
+
+    def conj(self):
+        """ Return a conjugate :obj:`Coefficient` of this"""
+        return ConjCoefficient(self)
+
+    def _cdc(self):
+        """ Return a :obj:`Coefficient` being the norm of this"""
+        return NormCoefficient(self)
+
+
+@cython.auto_pickle(True)
+cdef class FunctionCoefficient(Coefficient):
+    """
+    :obj:`Coefficient` wrapping a Python function.
+
+    Parameters
+    ----------
+    func : callable(t : float, ...) -> complex
+        Function returning the coefficient value at time ``t``.
+
+    args : dict
+        Values of the arguments to pass to ``func``.
+
+    style : {None, "pythonic", "dict", "auto"}
+        The style of function signature used. If style is ``None``,
+        the value of ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
+    style and parameter detection and are not intended to be part of
+    the public interface.
+    """
+    cdef object func
+    cdef bint _f_pythonic
+    cdef set _f_parameters
+
+    _UNSET = object()
+
+    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
+                 _f_parameters=_UNSET, **_):
+        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
+            if not (_f_pythonic is self._UNSET
+                    and _f_parameters is self._UNSET):
+                raise TypeError(
+                    "_f_pythonic and _f_parameters should "
+                    "always be given together."
+                )
+            _f_pythonic, _f_parameters = coefficient_function_parameters(
+                func, style=style)
+            if _f_parameters is not None:
+                args = {k: args[k] for k in _f_parameters & args.keys()}
+            else:
+                args = args.copy()
+        self.func = func
+        self.args = args
+        self._f_pythonic = _f_pythonic
+        self._f_parameters = _f_parameters
+
+    def __call__(self, t, dict _args=None, **kwargs):
+        if _args is not None or kwargs:
+            return self.replace_arguments(_args, **kwargs)(t)
+        if self._f_pythonic:
+            return self.func(t, **self.args)
+        return self.func(t, self.args)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return FunctionCoefficient(
+            self.func,
+            self.args.copy(),
+            _f_pythonic=self._f_pythonic,
+            _f_parameters=self._f_parameters,
+        )
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        if self._f_parameters is not None:
+            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
+        if not kwargs:
+            return self
+        return FunctionCoefficient(
+            self.func,
+            {**self.args, **kwargs},
+            _f_pythonic=self._f_pythonic,
+            _f_parameters=self._f_parameters,
+        )
+
+
+def proj(x):
+    if np.isfinite(x):
+        return (x)
+    else:
+        return np.inf + 0j * np.imag(x)
+
+
+cdef class StrFunctionCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` defined by a string containing a simple Python
+    expression.
+
+    The string should contain a compilable Python expression that results in a
+    complex number. The time ``t`` is available as a local variable, as are the
+    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
+    itself is not accessible.
+
+    The following symbols are defined:
+        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
+        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
+        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
+        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
+        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
+
+    Examples
+    --------
+    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
+
+    Parameters
+    ----------
+    base : str
+        A string representing a compilable Python expression that results in a
+        complex number.
+
+    args : dict
+        A dictionary of variable used in the code string. It may include unused
+        variables.
+    """
+    cdef object func
+    cdef str base
+
+    str_env = {
+        "sin": np.sin,
+        "cos": np.cos,
+        "tan": np.tan,
+        "asin": np.arcsin,
+        "acos": np.arccos,
+        "atan": np.arctan,
+        "pi": np.pi,
+        "sinh": np.sinh,
+        "cosh": np.cosh,
+        "tanh": np.tanh,
+        "asinh": np.arcsinh,
+        "acosh": np.arccosh,
+        "atanh": np.arctanh,
+        "exp": np.exp,
+        "log": np.log,
+        "log10": np.log10,
+        "erf": scipy.special.erf,
+        "zerf": scipy.special.erf,
+        "sqrt": np.sqrt,
+        "real": np.real,
+        "imag": np.imag,
+        "conj": np.conj,
+        "abs": np.abs,
+        "norm": lambda x: np.abs(x)**2,
+        "arg": np.angle,
+        "proj": proj,
+        "np": np,
+        "spe": scipy.special}
+
+    def __init__(self, base, dict args, **_):
+        args2var = "\n".join(["    {} = args['{}']".format(key, key)
+                              for key in args])
+        code = f"""
+def coeff(t, args):
+{args2var}
+    return {base}"""
+        lc = {}
+        exec(code, self.str_env, lc)
+        self.base = base
+        self.func = lc["coeff"]
+        self.args = args
+
+    cdef complex _call(self, double t) except *:
+        return self.func(t, self.args)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return StrFunctionCoefficient(self.base, self.args.copy())
+
+    def __reduce__(self):
+        return (StrFunctionCoefficient, (self.base, self.args))
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        if kwargs:
+            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
+        return self
+
+
+cdef class InterCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` built from an interpolation of a numpy array.
+
+    Parameters
+    ----------
+    coeff_arr : np.ndarray
+        The array of coefficient values to interpolate.
+
+    tlist : np.ndarray
+        An array of times corresponding to each coefficient value. The times
+        must be increasing, but do not need to be uniformly spaced.
+
+    order : int
+        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
+        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
+
+    boundary_conditions : 2-Tuple, str or None, optional
+        Boundary conditions for spline evaluation. Default value is `None`.
+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+        Refer to Scipy's documentation for further details:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+    """
+    cdef int order
+    cdef double dt
+    cdef double[::1] tlist
+    cdef complex[:, :] poly
+    cdef object np_arrays
+
+    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
+        tlist = np.array(tlist, dtype=np.float64)
+        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
+
+        if coeff_arr.ndim != 1:
+            raise ValueError("The array to interpolate must be a 1D array")
+        if coeff_arr.shape != tlist.shape:
+            raise ValueError("tlist must be the same len "
+                             "as the array to interpolate")
+        if order < 0:
+            raise ValueError("order must be a positive integer")
+
+        order = min(order, len(tlist) - 1)
+
+        if order == 0:
+            coeff_arr = coeff_arr.reshape((1, -1))
+        elif order == 1:
+            coeff_arr = np.vstack([
+                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
+                    coeff_arr
+                ])
+        elif order >= 2:
+            # Use scipy to compute the spline and transform it to polynomes
+            # as used in scipy's PPoly which is easier for us to use.
+            spline = make_interp_spline(tlist, coeff_arr, k=order,
+                                        bc_type=boundary_conditions)
+            # Scipy can move knots, we add them to tlist
+            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
+            a = np.arange(spline.k+1)
+            a[0] = 1
+            fact = np.cumprod(a)
+            coeff_arr = np.concatenate([
+                spline(tlist, i) / fact[i]
+                for i in range(spline.k, -1, -1)
+            ]).reshape((spline.k+1, -1))
+
+        self._prepare(tlist, coeff_arr)
+
+    def _prepare(self, np_tlist, np_poly, dt=None):
+        self.np_arrays = (np_tlist, np_poly)
+        self.tlist = np_tlist
+        self.poly = np_poly
+        self.order = self.poly.shape[0] - 1
+        diff = np.diff(self.np_arrays[0])
+        if dt is not None:
+            self.dt = dt
+        elif len(diff) >= 1 and np.allclose(diff[0], diff):
+            self.dt = diff[0]
+        else:
+            self.dt = 0
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef size_t _binary_search(self, double x):
+        # Binary search for the interval
+        # return the indice of the of the biggest element where t <= x
+        cdef size_t low = 0
+        cdef size_t high = self.tlist.shape[0]
+        cdef size_t middle
+        cdef size_t count = 0
+        while low+1 != high and count < 64:
+            middle = (low + high)//2
+            if x < self.tlist[middle]:
+                high = middle
+            else:
+                low = middle
+            # We keep a count to be sure that it never get into an infinit loop
+            # even if tlist has an unexpected format.
+            count += 1
+        return low
+
+    @cython.initializedcheck(False)
+    @cython.cdivision(True)
+    cdef double complex _call(self, double t) except *:
+        cdef size_t idx, i
+        cdef double factor
+        cdef double complex out
+        cdef double complex[:] slice
+        if t <= self.tlist[0]:
+            return self.poly[-1, 0]
+        elif t >= self.tlist[-1]:
+            return self.poly[-1, -1]
+        if self.dt:
+            idx = <size_t>((t - self.tlist[0]) / self.dt)
+        else:
+            idx = self._binary_search(t)
+        if self.order == 0:
+            out = self.poly[0, idx]
+        else:
+            factor = t - self.tlist[idx]
+            slice = self.poly[:, idx]
+            out = 0.
+            for i in range(self.order+1):
+                out *= factor
+                out += slice[i]
+        return out
+
+    def __reduce__(self):
+        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
+
+    @classmethod
+    def restore(cls, np_tlist, np_poly, dt=None):
+        cdef InterCoefficient out = cls.__new__(cls)
+        out._prepare(np_tlist, np_poly, dt)
+        return out
+
+    @classmethod
+    def from_PPoly(cls, ppoly, **_):
+        return cls.restore(ppoly.x, ppoly.c)
+
+    @classmethod
+    def from_Bspline(cls, spline, **_):
+        tlist = np.unique(spline.t)
+        a = np.arange(spline.k+1)
+        a[0] = 1
+        fact = np.cumprod(a) + 0j
+        poly = np.concatenate([
+            spline(tlist, i) / fact[i]
+            for i in range(spline.k, -1, -1)
+        ]).reshape((spline.k+1, -1))
+        return cls.restore(tlist, poly)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return InterCoefficient.restore(*self.np_arrays, self.dt)
+
+
+cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
+    """ Add two array coefficient with matching tlist into one."""
+    if (
+        left.np_arrays[0].shape == right.np_arrays[0].shape
+        and np.allclose(left.np_arrays[0], right.np_arrays[0],
+                        rtol=1e-15, atol=1e-15)
+        and (left.order == right.order)
+    ):
+        return InterCoefficient.restore(
+            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
+            left.dt
+        )
+    else:
+        # It would be possible to add them by merging tlist.
+        return SumCoefficient(left, right)
+
+
+@cython.auto_pickle(True)
+cdef class SumCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` built from the sum of two other coefficients.
+
+    A :obj:`SumCoefficient` is returned as the result of the addition of two
+    coefficients, e.g. ::
+
+        coefficient("t * t") + coefficient("t")  # SumCoefficient
+    """
+    cdef Coefficient first
+    cdef Coefficient second
+
+    def __init__(self, Coefficient first, Coefficient second):
+        self.first = first
+        self.second = second
+
+    cdef complex _call(self, double t) except *:
+        return self.first._call(t) + self.second._call(t)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return SumCoefficient(self.first.copy(), self.second.copy())
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return SumCoefficient(
+            self.first.replace_arguments(_args, **kwargs),
+            self.second.replace_arguments(_args, **kwargs)
+        )
+
+
+@cython.auto_pickle(True)
+cdef class MulCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` built from the product of two other coefficients.
+
+    A :obj:`MulCoefficient` is returned as the result of the multiplication of
+    two coefficients, e.g. ::
+
+        coefficient("w * t", args={'w': 1}) * coefficient("t")
+    """
+    cdef Coefficient first
+    cdef Coefficient second
+
+    def __init__(self, Coefficient first, Coefficient second):
+        self.first = first
+        self.second = second
+
+    cdef complex _call(self, double t) except *:
+        return self.first._call(t) * self.second._call(t)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return MulCoefficient(self.first.copy(), self.second.copy())
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return MulCoefficient(
+            self.first.replace_arguments(_args, **kwargs),
+            self.second.replace_arguments(_args, **kwargs)
+        )
+
+
+@cython.auto_pickle(True)
+cdef class ConjCoefficient(Coefficient):
+    """
+    The conjugate of a :obj:`Coefficient`.
+
+    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
+    ``qutip.coefficent.conj(Coefficient)``.
+    """
+    cdef Coefficient base
+
+    def __init__(self, Coefficient base):
+        self.base = base
+
+    cdef complex _call(self, double t) except *:
+        return conj(self.base._call(t))
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return ConjCoefficient(self.base.copy())
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return ConjCoefficient(
+            self.base.replace_arguments(_args, **kwargs)
+        )
+
+
+@cython.auto_pickle(True)
+cdef class NormCoefficient(Coefficient):
+    """
+    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
+    ``conj(coeff) * coeff``.
+
+    :obj:`NormCoefficient` is returned by
+    ``qutip.coefficent.norm(Coefficient)``.
+    """
+    cdef Coefficient base
+
+    def __init__(self, Coefficient base):
+        self.base = base
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return NormCoefficient(
+            self.base.replace_arguments(_args, **kwargs)
+        )
+
+    cdef complex _call(self, double t) except *:
+        return norm(self.base._call(t))
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return NormCoefficient(self.base.copy())
diff --git a/qutip/core/cy/complex_math.pxd b/qutip/core/cy/complex_math.pxd
index 43f0fd1793..5271c33010 100644
--- a/qutip/core/cy/complex_math.pxd
+++ b/qutip/core/cy/complex_math.pxd
@@ -1,24 +1,24 @@
-cdef extern from "<complex>" namespace "std" nogil:
-    double         abs(double complex x)
-    double complex acos(double complex x)
-    double complex acosh(double complex x)
-    double         arg(double complex x)
-    double complex asin(double complex x)
-    double complex asinh(double complex x)
-    double complex atan(double complex x)
-    double complex atanh(double complex x)
-    double complex conj(double complex x)
-    double complex cos(double complex x)
-    double complex cosh(double complex x)
-    double complex exp(double complex x)
-    double         imag(double complex x)
-    double complex log(double complex x)
-    double complex log10(double complex x)
-    double         norm(double complex x)
-    double complex proj(double complex x)
-    double         real(double complex x)
-    double complex sin(double complex x)
-    double complex sinh(double complex x)
-    double complex sqrt(double complex x)
-    double complex tan(double complex x)
-    double complex tanh(double complex x)
+cdef extern from "<complex>" namespace "std" nogil:
+    double         abs(double complex x)
+    double complex acos(double complex x)
+    double complex acosh(double complex x)
+    double         arg(double complex x)
+    double complex asin(double complex x)
+    double complex asinh(double complex x)
+    double complex atan(double complex x)
+    double complex atanh(double complex x)
+    double complex conj(double complex x)
+    double complex cos(double complex x)
+    double complex cosh(double complex x)
+    double complex exp(double complex x)
+    double         imag(double complex x)
+    double complex log(double complex x)
+    double complex log10(double complex x)
+    double         norm(double complex x)
+    double complex proj(double complex x)
+    double         real(double complex x)
+    double complex sin(double complex x)
+    double complex sinh(double complex x)
+    double complex sqrt(double complex x)
+    double complex tan(double complex x)
+    double complex tanh(double complex x)
diff --git a/qutip/core/cy/math.pxd b/qutip/core/cy/math.pxd
index 6f304b4916..6002bf9cb4 100644
--- a/qutip/core/cy/math.pxd
+++ b/qutip/core/cy/math.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-cdef double erf(double x)
-
-cdef double complex zerf(double complex Z)
+#cython: language_level=3
+
+cdef double erf(double x)
+
+cdef double complex zerf(double complex Z)
diff --git a/qutip/core/cy/math.pyx b/qutip/core/cy/math.pyx
index abdda8c5ae..e9f113cf45 100644
--- a/qutip/core/cy/math.pyx
+++ b/qutip/core/cy/math.pyx
@@ -1,159 +1,159 @@
-#cython: language_level=3
-
-cimport cython
-from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double real(double complex x)
-    double imag(double complex x)
-
-@cython.boundscheck(False)
-@cython.cdivision(True)
-cdef double erf(double x):
-    """
-    A Cython version of the erf function from the cdflib in SciPy.
-    """
-    cdef double c = 0.564189583547756
-
-    cdef double a[5]
-    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
-                     0.479137145607681e-1, 0.128379167095513]
-
-    cdef double b[3]
-    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
-
-    cdef double p[8]
-    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
-                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
-                     4.51918953711873e2, 3.00459261020162e2]
-
-    cdef double q[8]
-    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
-                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
-                     3.00459260956983e2]
-
-    cdef double r[5]
-    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
-                      4.65807828718470, 2.82094791773523e-1]
-
-    cdef double s[4]
-    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
-                     1.80124575948747e1]
-
-    cdef double ax = fabs(x)
-    cdef double t, x2, top, bot, erf
-
-    if ax <= 0.5:
-        t = x*x
-        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
-        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
-        erf = x * (top/bot)
-        return erf
-    elif ax <= 4.0:
-        x2 = x*x
-        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
-        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
-        erf = 0.5 + (0.5-exp(-x2)*top/bot)
-        if x < 0.0:
-            erf = -erf
-        return erf
-    elif ax < 5.8:
-        x2 = x*x
-        t = 1.0/x2
-        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
-        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
-        erf = (c-top/(x2*bot))/ax
-        erf = 0.5 + (0.5-exp(-x2)*erf)
-        if x < 0.0:
-            erf = -erf
-        return erf
-    else:
-        erf = copysign(1.0, x)
-        return erf
-
-
-#       COMPUTATION OF SPECIAL FUNCTIONS
-#
-#          Shanjie Zhang and Jianming Jin
-#
-#       Copyrighted but permission granted to use code in programs.
-# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
-    
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cdef double complex zerf(double complex Z):
-    """
-    Parameters
-    ----------
-    Z : double complex
-        Input parameter.
-    X : double
-        Real part of Z.
-    Y : double
-        Imag part of Z.
-
-    Returns
-    -------
-    erf(z) : double complex
-    """
-    
-    cdef double EPS = 1e-12
-    cdef double X = real(Z)
-    cdef double Y = imag(Z)
-    cdef double X2 = X * X
-    
-    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
-    
-    cdef size_t K, N
-    
-    if X < 3.5:
-        ER = 1.0
-        R = 1.0
-        W = 0.0
-        for K in range(1, 100):
-            R = R*X2/(K+0.5)
-            ER = ER+R
-            if (fabs(ER-W) < EPS*fabs(ER)):
-                break
-            W = ER
-        C0 = 2.0/sqrt(pi)*X*exp(-X2)
-        ER0 = C0*ER
-    else:
-        ER = 1.0
-        R=1.0
-        for K in range(1, 12):
-            R = -R*(K-0.5)/X2
-            ER = ER+R
-        C0 = exp(-X2)/(X*sqrt(pi))
-        ER0 = 1.0-C0*ER
-    
-    if Y == 0.0:
-        ERR = ER0
-        ERI = 0.0
-    else:
-        CS = cos(2.0*X*Y)
-        SS = sin(2.0*X*Y)
-        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
-        EI1 = exp(-X2)*SS/(2.0*pi*X)
-        ER2 = 0.0
-        W1 = 0.0
-        
-        for N in range(1,100):
-            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
-            if (fabs((ER2-W1)/ER2) < EPS):
-                break
-            W1 = ER2
-        
-        C0 = 2.0*exp(-X2)/pi
-        ERR = ER0+ER1+C0*ER2
-        EI2 = 0.0
-        W2 = 0.0
-        
-        for N in range(1,100):
-            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
-            if (fabs((EI2-W2)/EI2) < EPS):
-                break
-            W2 = EI2
-        ERI = EI1+C0*EI2
-        
-    return ERR + 1j*ERI
+#cython: language_level=3
+
+cimport cython
+from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double real(double complex x)
+    double imag(double complex x)
+
+@cython.boundscheck(False)
+@cython.cdivision(True)
+cdef double erf(double x):
+    """
+    A Cython version of the erf function from the cdflib in SciPy.
+    """
+    cdef double c = 0.564189583547756
+
+    cdef double a[5]
+    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
+                     0.479137145607681e-1, 0.128379167095513]
+
+    cdef double b[3]
+    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
+
+    cdef double p[8]
+    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
+                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
+                     4.51918953711873e2, 3.00459261020162e2]
+
+    cdef double q[8]
+    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
+                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
+                     3.00459260956983e2]
+
+    cdef double r[5]
+    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
+                      4.65807828718470, 2.82094791773523e-1]
+
+    cdef double s[4]
+    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
+                     1.80124575948747e1]
+
+    cdef double ax = fabs(x)
+    cdef double t, x2, top, bot, erf
+
+    if ax <= 0.5:
+        t = x*x
+        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
+        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
+        erf = x * (top/bot)
+        return erf
+    elif ax <= 4.0:
+        x2 = x*x
+        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
+        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
+        erf = 0.5 + (0.5-exp(-x2)*top/bot)
+        if x < 0.0:
+            erf = -erf
+        return erf
+    elif ax < 5.8:
+        x2 = x*x
+        t = 1.0/x2
+        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
+        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
+        erf = (c-top/(x2*bot))/ax
+        erf = 0.5 + (0.5-exp(-x2)*erf)
+        if x < 0.0:
+            erf = -erf
+        return erf
+    else:
+        erf = copysign(1.0, x)
+        return erf
+
+
+#       COMPUTATION OF SPECIAL FUNCTIONS
+#
+#          Shanjie Zhang and Jianming Jin
+#
+#       Copyrighted but permission granted to use code in programs.
+# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
+    
+@cython.cdivision(True)
+@cython.boundscheck(False)
+cdef double complex zerf(double complex Z):
+    """
+    Parameters
+    ----------
+    Z : double complex
+        Input parameter.
+    X : double
+        Real part of Z.
+    Y : double
+        Imag part of Z.
+
+    Returns
+    -------
+    erf(z) : double complex
+    """
+    
+    cdef double EPS = 1e-12
+    cdef double X = real(Z)
+    cdef double Y = imag(Z)
+    cdef double X2 = X * X
+    
+    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
+    
+    cdef size_t K, N
+    
+    if X < 3.5:
+        ER = 1.0
+        R = 1.0
+        W = 0.0
+        for K in range(1, 100):
+            R = R*X2/(K+0.5)
+            ER = ER+R
+            if (fabs(ER-W) < EPS*fabs(ER)):
+                break
+            W = ER
+        C0 = 2.0/sqrt(pi)*X*exp(-X2)
+        ER0 = C0*ER
+    else:
+        ER = 1.0
+        R=1.0
+        for K in range(1, 12):
+            R = -R*(K-0.5)/X2
+            ER = ER+R
+        C0 = exp(-X2)/(X*sqrt(pi))
+        ER0 = 1.0-C0*ER
+    
+    if Y == 0.0:
+        ERR = ER0
+        ERI = 0.0
+    else:
+        CS = cos(2.0*X*Y)
+        SS = sin(2.0*X*Y)
+        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
+        EI1 = exp(-X2)*SS/(2.0*pi*X)
+        ER2 = 0.0
+        W1 = 0.0
+        
+        for N in range(1,100):
+            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
+            if (fabs((ER2-W1)/ER2) < EPS):
+                break
+            W1 = ER2
+        
+        C0 = 2.0*exp(-X2)/pi
+        ERR = ER0+ER1+C0*ER2
+        EI2 = 0.0
+        W2 = 0.0
+        
+        for N in range(1,100):
+            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
+            if (fabs((EI2-W2)/EI2) < EPS):
+                break
+            W2 = EI2
+        ERI = EI1+C0*EI2
+        
+    return ERR + 1j*ERI
diff --git a/qutip/core/cy/openmp/bench_openmp.py b/qutip/core/cy/openmp/bench_openmp.py
index 84db486bb5..88868a8200 100644
--- a/qutip/core/cy/openmp/bench_openmp.py
+++ b/qutip/core/cy/openmp/bench_openmp.py
@@ -1,154 +1,154 @@
-import numpy as np
-from qutip.settings import settings as qset
-from timeit import default_timer as timer
-
-
-def _min_timer(function, *args, **kwargs):
-    min_time = 1e6
-    for kk in range(10000):
-        t0 = timer()
-        function(*args, **kwargs)
-        t1 = timer()
-        min_time = min(min_time, t1-t0)
-    return min_time
-
-
-def system_bench(func, dims):
-    from qutip.random_objects import rand_ket
-    ratio = 0
-    ratio_old = 0
-    nnz_old = 0
-    for N in dims:
-        L = func(N).data
-        vec = rand_ket(L.shape[0], 0.25).full().ravel()
-        nnz = L.nnz
-        out = np.zeros_like(vec)
-        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
-        out = np.zeros_like(vec)
-        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
-        ratio = ser/par
-        if ratio > 1:
-            break
-        nnz_old = nnz
-        ratio_old = ratio
-    if ratio > 1:
-        rate = (ratio-ratio_old)/(nnz-nnz_old)
-        return int((1.0-ratio_old)/rate+nnz_old)
-    else:
-        return -1
-
-
-def calculate_openmp_thresh():
-    # if qset.num_cpus == 1:
-    #    return qset.openmp_thresh
-    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
-    jc_result = system_bench(_jc_liouvillian, jc_dims)
-
-    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
-    opto_result = system_bench(_opto_liouvillian, opto_dims)
-
-    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
-    spin_result = system_bench(_spin_hamiltonian, spin_dims)
-
-    # Double result to be conservative
-    thresh = 2*int(max([jc_result, opto_result, spin_result]))
-    if thresh < 0:
-        thresh = np.iinfo(np.int32).max
-    return thresh
-
-
-def _jc_liouvillian(N):
-    from qutip.core import tensor, destroy, qeye, liouvillian
-    wc = 2*np.pi * 1.0   # cavity frequency
-    wa = 2*np.pi * 1.0   # atom frequency
-    g = 2*np.pi * 0.05   # coupling strength
-    kappa = 0.005        # cavity dissipation rate
-    gamma = 0.05         # atom dissipation rate
-    n_th_a = 1           # temperature in frequency units
-    use_rwa = 0
-    # operators
-    a = tensor(destroy(N), qeye(2))
-    sm = tensor(qeye(N), destroy(2))
-    # Hamiltonian
-    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
-    c_op_list = []
-
-    rate = kappa * (1 + n_th_a)
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a)
-
-    rate = kappa * n_th_a
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a.dag())
-
-    rate = gamma
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sm)
-
-    return liouvillian(H, c_op_list)
-
-
-def _opto_liouvillian(N):
-    from qutip.core import tensor, destroy, qeye, liouvillian
-    Nc = 5                      # Number of cavity states
-    Nm = N                     # Number of mech states
-    kappa = 0.3                 # Cavity damping rate
-    E = 0.1                     # Driving Amplitude
-    g0 = 2.4*kappa              # Coupling strength
-    Qm = 1e4                    # Mech quality factor
-    gamma = 1/Qm                # Mech damping rate
-    n_th = 1                    # Mech bath temperature
-    delta = -0.43               # Detuning
-    a = tensor(destroy(Nc), qeye(Nm))
-    b = tensor(qeye(Nc), destroy(Nm))
-    num_b = b.dag()*b
-    num_a = a.dag()*a
-    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
-    cc = np.sqrt(kappa)*a
-    cm = np.sqrt(gamma*(1.0 + n_th))*b
-    cp = np.sqrt(gamma*n_th)*b.dag()
-    c_ops = [cc, cm, cp]
-    return liouvillian(H, c_ops)
-
-
-def _spin_hamiltonian(N):
-    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
-    # array of spin energy splittings and coupling strengths. here we use
-    # uniform parameters, but in general we don't have too
-    h = 2*np.pi * 1.0 * np.ones(N)
-    Jz = 2*np.pi * 0.1 * np.ones(N)
-    Jx = 2*np.pi * 0.1 * np.ones(N)
-    Jy = 2*np.pi * 0.1 * np.ones(N)
-    # dephasing rate
-
-    si = qeye(2)
-    sx = sigmax()
-    sy = sigmay()
-    sz = sigmaz()
-
-    sx_list = []
-    sy_list = []
-    sz_list = []
-
-    for n in range(N):
-        op_list = [si] * N
-        op_list[n] = sx
-        sx_list.append(tensor(op_list))
-        op_list[n] = sy
-        sy_list.append(tensor(op_list))
-        op_list[n] = sz
-        sz_list.append(tensor(op_list))
-
-    # construct the hamiltonian
-    H = 0
-
-    # energy splitting terms
-    for n in range(N):
-        H += - 0.5 * h[n] * sz_list[n]
-
-    # interaction terms
-    for n in range(N-1):
-        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
-        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
-        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
-    return H
+import numpy as np
+from qutip.settings import settings as qset
+from timeit import default_timer as timer
+
+
+def _min_timer(function, *args, **kwargs):
+    min_time = 1e6
+    for kk in range(10000):
+        t0 = timer()
+        function(*args, **kwargs)
+        t1 = timer()
+        min_time = min(min_time, t1-t0)
+    return min_time
+
+
+def system_bench(func, dims):
+    from qutip.random_objects import rand_ket
+    ratio = 0
+    ratio_old = 0
+    nnz_old = 0
+    for N in dims:
+        L = func(N).data
+        vec = rand_ket(L.shape[0], 0.25).full().ravel()
+        nnz = L.nnz
+        out = np.zeros_like(vec)
+        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
+        out = np.zeros_like(vec)
+        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
+        ratio = ser/par
+        if ratio > 1:
+            break
+        nnz_old = nnz
+        ratio_old = ratio
+    if ratio > 1:
+        rate = (ratio-ratio_old)/(nnz-nnz_old)
+        return int((1.0-ratio_old)/rate+nnz_old)
+    else:
+        return -1
+
+
+def calculate_openmp_thresh():
+    # if qset.num_cpus == 1:
+    #    return qset.openmp_thresh
+    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
+    jc_result = system_bench(_jc_liouvillian, jc_dims)
+
+    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
+    opto_result = system_bench(_opto_liouvillian, opto_dims)
+
+    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
+    spin_result = system_bench(_spin_hamiltonian, spin_dims)
+
+    # Double result to be conservative
+    thresh = 2*int(max([jc_result, opto_result, spin_result]))
+    if thresh < 0:
+        thresh = np.iinfo(np.int32).max
+    return thresh
+
+
+def _jc_liouvillian(N):
+    from qutip.core import tensor, destroy, qeye, liouvillian
+    wc = 2*np.pi * 1.0   # cavity frequency
+    wa = 2*np.pi * 1.0   # atom frequency
+    g = 2*np.pi * 0.05   # coupling strength
+    kappa = 0.005        # cavity dissipation rate
+    gamma = 0.05         # atom dissipation rate
+    n_th_a = 1           # temperature in frequency units
+    use_rwa = 0
+    # operators
+    a = tensor(destroy(N), qeye(2))
+    sm = tensor(qeye(N), destroy(2))
+    # Hamiltonian
+    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
+    c_op_list = []
+
+    rate = kappa * (1 + n_th_a)
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a)
+
+    rate = kappa * n_th_a
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a.dag())
+
+    rate = gamma
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sm)
+
+    return liouvillian(H, c_op_list)
+
+
+def _opto_liouvillian(N):
+    from qutip.core import tensor, destroy, qeye, liouvillian
+    Nc = 5                      # Number of cavity states
+    Nm = N                     # Number of mech states
+    kappa = 0.3                 # Cavity damping rate
+    E = 0.1                     # Driving Amplitude
+    g0 = 2.4*kappa              # Coupling strength
+    Qm = 1e4                    # Mech quality factor
+    gamma = 1/Qm                # Mech damping rate
+    n_th = 1                    # Mech bath temperature
+    delta = -0.43               # Detuning
+    a = tensor(destroy(Nc), qeye(Nm))
+    b = tensor(qeye(Nc), destroy(Nm))
+    num_b = b.dag()*b
+    num_a = a.dag()*a
+    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
+    cc = np.sqrt(kappa)*a
+    cm = np.sqrt(gamma*(1.0 + n_th))*b
+    cp = np.sqrt(gamma*n_th)*b.dag()
+    c_ops = [cc, cm, cp]
+    return liouvillian(H, c_ops)
+
+
+def _spin_hamiltonian(N):
+    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
+    # array of spin energy splittings and coupling strengths. here we use
+    # uniform parameters, but in general we don't have too
+    h = 2*np.pi * 1.0 * np.ones(N)
+    Jz = 2*np.pi * 0.1 * np.ones(N)
+    Jx = 2*np.pi * 0.1 * np.ones(N)
+    Jy = 2*np.pi * 0.1 * np.ones(N)
+    # dephasing rate
+
+    si = qeye(2)
+    sx = sigmax()
+    sy = sigmay()
+    sz = sigmaz()
+
+    sx_list = []
+    sy_list = []
+    sz_list = []
+
+    for n in range(N):
+        op_list = [si] * N
+        op_list[n] = sx
+        sx_list.append(tensor(op_list))
+        op_list[n] = sy
+        sy_list.append(tensor(op_list))
+        op_list[n] = sz
+        sz_list.append(tensor(op_list))
+
+    # construct the hamiltonian
+    H = 0
+
+    # energy splitting terms
+    for n in range(N):
+        H += - 0.5 * h[n] * sz_list[n]
+
+    # interaction terms
+    for n in range(N-1):
+        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
+        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
+        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
+    return H
diff --git a/qutip/core/cy/openmp/parfuncs.pxd b/qutip/core/cy/openmp/parfuncs.pxd
index a8a14bea5a..73a4186df9 100644
--- a/qutip/core/cy/openmp/parfuncs.pxd
+++ b/qutip/core/cy/openmp/parfuncs.pxd
@@ -1,9 +1,9 @@
-#cython: language_level=3
-
-cimport numpy as cnp
-cimport cython
-
-cdef void spmvpy_openmp(
-    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
-    unsigned int nrows, unsigned int nthr,
-)
+#cython: language_level=3
+
+cimport numpy as cnp
+cimport cython
+
+cdef void spmvpy_openmp(
+    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
+    unsigned int nrows, unsigned int nthr,
+)
diff --git a/qutip/core/cy/openmp/parfuncs.pyx b/qutip/core/cy/openmp/parfuncs.pyx
index 919a209ea1..382c75b461 100644
--- a/qutip/core/cy/openmp/parfuncs.pyx
+++ b/qutip/core/cy/openmp/parfuncs.pyx
@@ -1,13 +1,13 @@
-#cython: language_level=3
-
-cdef extern from "src/zspmv_openmp.hpp" nogil:
-    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
-                double complex a, double complex *out, int nrows, int nthr)
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
-                               complex * vec, complex a, complex * out,
-                               unsigned int nrows, unsigned int nthr):
-    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
+#cython: language_level=3
+
+cdef extern from "src/zspmv_openmp.hpp" nogil:
+    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
+                double complex a, double complex *out, int nrows, int nthr)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
+                               complex * vec, complex a, complex * out,
+                               unsigned int nrows, unsigned int nthr):
+    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
diff --git a/qutip/core/cy/openmp/src/zspmv_openmp.cpp b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
index 7e98b93412..f6b42c3ab3 100644
--- a/qutip/core/cy/openmp/src/zspmv_openmp.cpp
+++ b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
@@ -1,166 +1,166 @@
-#include <complex>
-#include <omp.h>
-
-#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
-#include <pmmintrin.h>
-void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-            const int * __restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-            std::complex<double> * __restrict__ out, const unsigned int nrows,
-            const unsigned int nthr)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    #pragma omp parallel for \
-        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        num4 = _mm_setzero_pd();
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
-    }
-}
-#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
-void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-            const int * __restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-            std::complex<double> * __restrict__ out, const unsigned int nrows,
-            const unsigned int nthr)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    #pragma omp parallel for \
-        private(row,dot,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
-    }
-}
-#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
-#include <pmmintrin.h>
-void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
-            const int * __restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a,
-            std::complex<double> * __restrict out, const int nrows,
-            const unsigned int nthr)
-{
-    int row, jj;
-    int row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    #pragma omp parallel for \
-        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        num4 = _mm_setzero_pd();
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
-    }
-}
-#elif defined(_MSC_VER) // Visual Studio no AVX
-void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
-            const int * __restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a,
-            std::complex<double> * __restrict out, const int nrows,
-            const unsigned int nthr)
-{
-    int row, jj;
-    int row_start, row_end;
-    std::complex<double> dot;
-    #pragma omp parallel for \
-        private(row,dot,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
-    }
-}
-#else // Everything else
-void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
-            const int * ptr,
-            const std::complex<double> * vec, const std::complex<double> a,
-            std::complex<double> * out, const unsigned int nrows,
-            const unsigned int nthr)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    #pragma omp parallel for \
-        private(row,dot,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
-    }
-}
-#endif
+#include <complex>
+#include <omp.h>
+
+#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
+#include <pmmintrin.h>
+void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
+            const int * __restrict__ ptr,
+            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
+            std::complex<double> * __restrict__ out, const unsigned int nrows,
+            const unsigned int nthr)
+{
+    size_t row, jj;
+    unsigned int row_start, row_end;
+    __m128d num1, num2, num3, num4;
+    #pragma omp parallel for \
+        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        num4 = _mm_setzero_pd();
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
+            num3 = _mm_mul_pd(num2, num1);
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+            num2 = _mm_shuffle_pd(num2, num2, 1);
+            num2 = _mm_mul_pd(num2, num1);
+            num3 = _mm_addsub_pd(num3, num2);
+            num4 = _mm_add_pd(num3, num4);
+        }
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+        num3 = _mm_mul_pd(num4, num1);
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+        num4 = _mm_shuffle_pd(num4, num4, 1);
+        num4 = _mm_mul_pd(num4, num1);
+        num3 = _mm_addsub_pd(num3, num4);
+        num2 = _mm_loadu_pd((double *)&out[row]);
+        num3 = _mm_add_pd(num2, num3);
+        _mm_storeu_pd((double *)&out[row], num3);
+    }
+}
+#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
+void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
+            const int * __restrict__ ptr,
+            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
+            std::complex<double> * __restrict__ out, const unsigned int nrows,
+            const unsigned int nthr)
+{
+    size_t row, jj;
+    unsigned int row_start, row_end;
+    std::complex<double> dot;
+    #pragma omp parallel for \
+        private(row,dot,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            dot += data[jj]*vec[ind[jj]];
+        }
+        out[row] += a*dot;
+    }
+}
+#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
+#include <pmmintrin.h>
+void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
+            const int * __restrict ptr,
+            const std::complex<double> * __restrict vec, const std::complex<double> a,
+            std::complex<double> * __restrict out, const int nrows,
+            const unsigned int nthr)
+{
+    int row, jj;
+    int row_start, row_end;
+    __m128d num1, num2, num3, num4;
+    #pragma omp parallel for \
+        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        num4 = _mm_setzero_pd();
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
+            num3 = _mm_mul_pd(num2, num1);
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+            num2 = _mm_shuffle_pd(num2, num2, 1);
+            num2 = _mm_mul_pd(num2, num1);
+            num3 = _mm_addsub_pd(num3, num2);
+            num4 = _mm_add_pd(num3, num4);
+        }
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+        num3 = _mm_mul_pd(num4, num1);
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+        num4 = _mm_shuffle_pd(num4, num4, 1);
+        num4 = _mm_mul_pd(num4, num1);
+        num3 = _mm_addsub_pd(num3, num4);
+        num2 = _mm_loadu_pd((double *)&out[row]);
+        num3 = _mm_add_pd(num2, num3);
+        _mm_storeu_pd((double *)&out[row], num3);
+    }
+}
+#elif defined(_MSC_VER) // Visual Studio no AVX
+void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
+            const int * __restrict ptr,
+            const std::complex<double> * __restrict vec, const std::complex<double> a,
+            std::complex<double> * __restrict out, const int nrows,
+            const unsigned int nthr)
+{
+    int row, jj;
+    int row_start, row_end;
+    std::complex<double> dot;
+    #pragma omp parallel for \
+        private(row,dot,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            dot += data[jj]*vec[ind[jj]];
+        }
+        out[row] += a*dot;
+    }
+}
+#else // Everything else
+void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
+            const int * ptr,
+            const std::complex<double> * vec, const std::complex<double> a,
+            std::complex<double> * out, const unsigned int nrows,
+            const unsigned int nthr)
+{
+    size_t row, jj;
+    unsigned int row_start, row_end;
+    std::complex<double> dot;
+    #pragma omp parallel for \
+        private(row,dot,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            dot += data[jj]*vec[ind[jj]];
+        }
+        out[row] += a*dot;
+    }
+}
+#endif
diff --git a/qutip/core/cy/openmp/utilities.py b/qutip/core/cy/openmp/utilities.py
index 9627576919..ac5bab8676 100644
--- a/qutip/core/cy/openmp/utilities.py
+++ b/qutip/core/cy/openmp/utilities.py
@@ -1,41 +1,41 @@
-import os
-from qutip.settings import settings as qset
-
-
-def check_use_openmp(options):
-    """
-    Check to see if OPENMP should be used in dynamic solvers.
-    """
-    # TODO: sort this out.
-    return False
-    """
-    force_omp = False
-    if qset.has_openmp:
-        if options.use_openmp is None:
-            options.use_openmp = True
-        else:
-            force_omp = bool(options.use_openmp)
-    elif (not qset.has_openmp) and options.use_openmp:
-        raise Exception('OPENMP not available.')
-    else:
-        options.use_openmp = False
-        force_omp = False
-    # Disable OPENMP in parallel mode unless explicitly set.
-    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
-        options.use_openmp = False"""
-
-
-def use_openmp():
-    """
-    Check for using openmp in general cases outside of dynamics
-    """
-    return False
-    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
-        return True
-    else:
-        return False
-
-
-def openmp_components(ptr_list):
-    return np.array([False for ptr in ptr_list], dtype=bool)
-    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
+import os
+from qutip.settings import settings as qset
+
+
+def check_use_openmp(options):
+    """
+    Check to see if OPENMP should be used in dynamic solvers.
+    """
+    # TODO: sort this out.
+    return False
+    """
+    force_omp = False
+    if qset.has_openmp:
+        if options.use_openmp is None:
+            options.use_openmp = True
+        else:
+            force_omp = bool(options.use_openmp)
+    elif (not qset.has_openmp) and options.use_openmp:
+        raise Exception('OPENMP not available.')
+    else:
+        options.use_openmp = False
+        force_omp = False
+    # Disable OPENMP in parallel mode unless explicitly set.
+    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
+        options.use_openmp = False"""
+
+
+def use_openmp():
+    """
+    Check for using openmp in general cases outside of dynamics
+    """
+    return False
+    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
+        return True
+    else:
+        return False
+
+
+def openmp_components(ptr_list):
+    return np.array([False for ptr in ptr_list], dtype=bool)
+    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
index 07e0d3df7c..73b7f01b91 100644
--- a/qutip/core/cy/qobjevo.pxd
+++ b/qutip/core/cy/qobjevo.pxd
@@ -1,24 +1,24 @@
-#cython: language_level=3
-
-from qutip.core.data cimport Dense, Data
-from qutip.core.data.base cimport idxint
-
-cdef class QobjEvo:
-    cdef:
-        list elements
-        readonly list dims
-        readonly (idxint, idxint) shape
-        readonly str type
-        readonly str superrep
-        int _issuper
-        int _isoper
-
-    cpdef Data _call(QobjEvo self, double t)
-
-    cdef object _prepare(QobjEvo self, object t, Data state=*)
-
-    cpdef object expect_data(QobjEvo self, object t, Data state)
-
-    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
-
-    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
+#cython: language_level=3
+
+from qutip.core.data cimport Dense, Data
+from qutip.core.data.base cimport idxint
+
+cdef class QobjEvo:
+    cdef:
+        list elements
+        readonly list dims
+        readonly (idxint, idxint) shape
+        readonly str type
+        readonly str superrep
+        int _issuper
+        int _isoper
+
+    cpdef Data _call(QobjEvo self, double t)
+
+    cdef object _prepare(QobjEvo self, object t, Data state=*)
+
+    cpdef object expect_data(QobjEvo self, object t, Data state)
+
+    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
+
+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 513d3ae519..cddeb5d09d 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -1,1019 +1,1019 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
-
-import numpy as np
-import numbers
-import itertools
-from functools import partial
-
-import qutip
-from .. import Qobj
-from .. import data as _data
-from ..coefficient import coefficient, CompilationOptions
-from ._element import *
-from ..dimensions import type_from_dims
-from qutip.settings import settings
-
-from qutip.core.cy._element cimport _BaseElement
-from qutip.core.data cimport Dense, Data, dense
-from qutip.core.data.expect cimport *
-from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
-from libc.math cimport fabs
-
-__all__ = ['QobjEvo']
-
-cdef class QobjEvo:
-    """
-    A class for representing time-dependent quantum objects, such as quantum
-    operators and states.
-
-    Importantly, :obj:`~QobjEvo` instances are used to represent such
-    time-dependent quantum objects when working with QuTiP solvers.
-
-    A :obj:`~QobjEvo` instance may be constructed from one of the following:
-
-      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
-        value of the quantum object at time ``t``.
-
-      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
-        any item that can be used to construct a coefficient (e.g. a function,
-        a numpy array of coefficient values, a string expression).
-
-      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
-
-      * a list of such callables, pairs or :obj:`~Qobj`\s.
-
-      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
-        are ignored except ``args`` which, if passed, replaces the existing
-        arguments).
-
-    Parameters
-    ----------
-    Q_object : callable, list or Qobj
-        A specification of the time-depedent quantum object. See the
-        paragraph above for a full description and the examples section below
-        for examples.
-
-    args : dict, optional
-        A dictionary that contains the arguments for the coefficients.
-        Arguments may be omitted if no function or string coefficients that
-        require arguments are present.
-
-    tlist : array-like, optional
-        A list of times corresponding to the values of the coefficients
-        supplied as numpy arrays. If no coefficients are supplied as numpy
-        arrays, ``tlist`` may be omitted, otherwise it is required.
-
-        The times in ``tlist`` do not need to be equidistant, but must
-        be sorted.
-
-        By default, a cubic spline interpolation will be used to interpolate
-        the value of the (numpy array) coefficients at time ``t``. If the
-        coefficients are to be treated as step functions, pass the argument
-        ``order=0`` (see below).
-
-    order : int, default=3
-        Order of the spline interpolation that is to be used to interpolate
-        the value of the (numpy array) coefficients at time ``t``.
-        ``0`` use previous or left value.
-
-    copy : bool, default=True
-        Whether to make a copy of the :obj:`Qobj` instances supplied in
-        the ``Q_object`` parameter.
-
-    compress : bool, default=True
-        Whether to compress the :obj:`QobjEvo` instance terms after the
-        instance has been created.
-
-        This sums the constant terms in a single term and combines
-        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
-        pair containing the sum of the coefficients.
-
-        See :meth:`compress`.
-
-    function_style : {None, "pythonic", "dict", "auto"}
-        The style of function signature used by callables in ``Q_object``.
-        If style is ``None``, the value of
-        ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-
-    boundary_conditions : 2-Tuple, str or None, optional
-        Boundary conditions for spline evaluation. Default value is `None`.
-        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
-        Refer to Scipy's documentation for further details:
-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-
-
-    Attributes
-    ----------
-    dims : list
-        List of dimensions keeping track of the tensor structure.
-
-    shape : (int, int)
-        List of dimensions keeping track of the tensor structure.
-
-    type : str
-        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
-        'operator-bra', or 'super'.
-
-    superrep : str
-        Representation used if `type` is 'super'. One of 'super'
-        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
-
-    Examples
-    --------
-
-    A :obj:`~QobjEvo` constructed from a function:
-
-    .. code-block::
-
-        def f(t, args):
-            return qutip.qeye(N) * np.exp(args['w'] * t)
-
-        QobjEvo(f, args={'w': 1j})
-
-
-    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
-    ``[Qobj, Coefficient]`` pairs:
-
-    .. code-block::
-
-        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
-
-    The coefficients may be specified either using a :obj:`~Coefficient`
-    object or by a function, string, numpy array or any object that
-    can be passed to the :func:`~coefficient` function. See the documentation
-    of :func:`coefficient` for a full description.
-
-    An example of a coefficient specified by a function:
-
-    .. code-block::
-
-        def f1_t(t, args):
-            return np.exp(-1j * t * args["w1"])
-
-        QobjEvo([[H1, f1_t]], args={"w1": 1.})
-
-    And of coefficients specified by string expressions:
-
-    .. code-block::
-
-        H = QobjEvo(
-            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
-            args={"w1": 1., "w2": 2.}
-        )
-
-    Coefficients maybe also be expressed as numpy arrays giving a list
-    of the coefficient values:
-
-    .. code-block:: python
-
-        tlist = np.logspace(-5, 0, 100)
-        H = QobjEvo(
-            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
-            tlist=tlist
-        )
-
-    The coeffients array must have the same len as the tlist.
-
-    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
-    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
-
-    .. code-block:: python
-
-        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
-        qevo = H0 + H1 * coeff
-
-    """
-    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
-                 order=3, copy=True, compress=True,
-                 function_style=None, boundary_conditions=None):
-        if isinstance(Q_object, QobjEvo):
-            self.dims = Q_object.dims.copy()
-            self.shape = Q_object.shape
-            self.type = Q_object.type
-            self._issuper = (<QobjEvo> Q_object)._issuper
-            self._isoper = (<QobjEvo> Q_object)._isoper
-            self.elements = (<QobjEvo> Q_object).elements.copy()
-            if args:
-                self.arguments(args)
-            if compress:
-                self.compress()
-            return
-
-        self.elements = []
-        self.dims = None
-        self.shape = (0, 0)
-        self._issuper = -1
-        self._isoper = -1
-        args = args or {}
-
-        if (
-            isinstance(Q_object, list)
-            and len(Q_object) == 2
-            and isinstance(Q_object[0], Qobj)
-            and not isinstance(Q_object[1], (Qobj, list))
-        ):
-            # The format is [Qobj, coefficient]
-            Q_object = [Q_object]
-
-        if isinstance(Q_object, list):
-            for op in Q_object:
-                self.elements.append(
-                    self._read_element(
-                        op, copy=copy, tlist=tlist, args=args, order=order,
-                        function_style=function_style,
-                        boundary_conditions=boundary_conditions
-                    )
-                )
-        else:
-            self.elements.append(
-                self._read_element(
-                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
-                    function_style=function_style,
-                    boundary_conditions=boundary_conditions
-                )
-            )
-
-        if compress:
-            self.compress()
-
-    def __repr__(self):
-        cls = self.__class__.__name__
-        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
-        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
-        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
-        return repr_str
-
-    def _read_element(self, op, copy, tlist, args, order, function_style, 
-                      boundary_conditions):
-        """ Read a Q_object item and return an element for that item. """
-        if isinstance(op, Qobj):
-            out = _ConstantElement(op.copy() if copy else op)
-            qobj = op
-        elif isinstance(op, list):
-            out = _EvoElement(
-                op[0].copy() if copy else op[0],
-                coefficient(op[1], tlist=tlist, args=args, order=order, 
-                            boundary_conditions=boundary_conditions)
-            )
-            qobj = op[0]
-        elif isinstance(op, _BaseElement):
-            out = op
-            qobj = op.qobj(0)
-        elif callable(op):
-            out = _FuncElement(op, args, style=function_style)
-            qobj = out.qobj(0)
-            if not isinstance(qobj, Qobj):
-                raise TypeError(
-                    "Function based time-dependent elements must have the"
-                    " signature f(t: double, args: dict) -> Qobj, but"
-                    " {!r} returned: {!r}".format(op, qobj)
-                )
-        else:
-            raise TypeError(
-                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
-                " or a function f(t: double, args: dict) -> Qobj, but"
-                " received: {!r}".format(op)
-            )
-
-        if self.dims is None:
-            self.dims = qobj.dims
-            self.shape = qobj.shape
-            self.type = qobj.type
-            self.superrep = qobj.superrep
-        elif self.dims != qobj.dims or self.shape != qobj.shape:
-            raise ValueError(
-                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
-                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
-                f" and shape {self.shape!r}."
-            )
-        elif self.type != qobj.type:
-            raise ValueError(
-                f"QobjEvo term {op!r} has type {qobj.type!r} but "
-                f"previous terms had type {self.type!r}."
-            )
-        elif self.superrep != qobj.superrep:
-            raise ValueError(
-                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
-                f"previous terms had superrep {self.superrep!r}."
-            )
-
-        return out
-
-    @classmethod
-    def _restore(cls, elements, dims, shape, type, superrep, flags):
-        """Recreate a QobjEvo without using __init__. """
-        cdef QobjEvo out = cls.__new__(cls)
-        out.elements = elements
-        out.dims = dims
-        out.shape = shape
-        out.type = type
-        out.superrep = superrep
-        out._issuper, out._isoper = flags
-        return out
-
-    def _getstate(self):
-        """ Obtain the state """
-        # For jax pytree representation
-        # auto_pickle create similar method __getstate__, but since it's
-        # automatically created, it could change depending on cython version
-        # etc., so we create our own.
-        return {
-            "elements": self.elements,
-            "dims": self.dims,
-            "shape": self.shape,
-            "type": self.type,
-            "superrep": self.superrep,
-            "flags": (self._issuper, self._isoper,)
-        }
-
-    def __call__(self, double t, dict _args=None, **kwargs):
-        """
-        Get the :class:`~Qobj` at ``t``.
-
-        Parameters
-        ----------
-        t : float
-            Time at which the ``QobjEvo`` is to be evalued.
-
-        _args : dict [optional]
-            New arguments as a dict. Update args with ``arguments(new_args)``.
-
-        **kwargs :
-            New arguments as a keywors. Update args with
-            ``arguments(**new_args)``.
-
-        .. note::
-            If both the positional ``_args`` and keywords are passed new values
-            from both will be used. If a key is present with both, the
-            ``_args`` dict value will take priority.
-        """
-        if _args is not None or kwargs:
-            if _args is not None:
-                kwargs.update(_args)
-            return QobjEvo(self, args=kwargs)(t)
-
-        t = self._prepare(t, None)
-
-        if self.isconstant:
-            # For constant QobjEvo's, we sum the contained Qobjs directly in
-            # order to retain the cached values of attributes like .isherm when
-            # possible, rather than calling _call(t) which may lose this cached
-            # information.
-            return sum(element.qobj(t) for element in self.elements)
-
-        cdef _BaseElement part = self.elements[0]
-        cdef double complex coeff = part.coeff(t)
-        obj = part.qobj(t)
-        cdef Data out = _data.mul(obj.data, coeff)
-        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
-        for element in self.elements[1:]:
-            part = <_BaseElement> element
-            coeff = part.coeff(t)
-            obj = part.qobj(t)
-            isherm &= <bint> obj._isherm and coeff.imag == 0
-            out = _data.add(out, obj.data, coeff)
-
-        return Qobj(
-            out, dims=self.dims, copy=False, isherm=isherm or None,
-            type=self.type, superrep=self.superrep
-        )
-
-    cpdef Data _call(QobjEvo self, double t):
-        t = self._prepare(t, None)
-        cdef Data out
-        cdef _BaseElement part = self.elements[0]
-        out = _data.mul(part.data(t),
-                        part.coeff(t))
-        for element in self.elements[1:]:
-            part = <_BaseElement> element
-
-            out = _data.add(
-                out,
-                part.data(t),
-                part.coeff(t)
-            )
-        return out
-
-    cdef object _prepare(QobjEvo self, object t, Data state=None):
-        """ Precomputation before computing getting the element at `t`"""
-        # We keep the function for feedback eventually
-        return t
-
-    def copy(QobjEvo self):
-        """Return a copy of this `QobjEvo`"""
-        return QobjEvo(self, compress=False)
-
-    def arguments(QobjEvo self, dict _args=None, **kwargs):
-        """
-        Update the arguments.
-
-        Parameters
-        ----------
-        _args : dict [optional]
-            New arguments as a dict. Update args with ``arguments(new_args)``.
-
-        **kwargs :
-            New arguments as a keywors. Update args with
-            ``arguments(**new_args)``.
-
-        .. note::
-            If both the positional ``_args`` and keywords are passed new values
-            from both will be used. If a key is present with both, the ``_args``
-            dict value will take priority.
-        """
-        if _args is not None:
-            kwargs.update(_args)
-        cache = []
-        self.elements = [
-            element.replace_arguments(kwargs, cache=cache)
-            for element in self.elements
-        ]
-
-
-    ###########################################################################
-    # Math function                                                           #
-    ###########################################################################
-    def __add__(left, right):
-        if isinstance(left, QobjEvo):
-            self = left
-            other = right
-        else:
-            self = right
-            other = left
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        res = self.copy()
-        res += other
-        return res
-
-    def __radd__(self, other):
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        res = self.copy()
-        res += other
-        return res
-
-    def __iadd__(QobjEvo self, other):
-        cdef _BaseElement element
-        if isinstance(other, QobjEvo):
-            if other.dims != self.dims:
-                raise TypeError("incompatible dimensions" +
-                                str(self.dims) + ", " + str(other.dims))
-            for element in (<QobjEvo> other).elements:
-                self.elements.append(element)
-        elif isinstance(other, Qobj):
-            if other.dims != self.dims:
-                raise TypeError("incompatible dimensions" +
-                                str(self.dims) + ", " + str(other.dims))
-            self.elements.append(_ConstantElement(other))
-        elif (
-            isinstance(other, numbers.Number) and
-            self.dims[0] == self.dims[1]
-        ):
-            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
-        else:
-            return NotImplemented
-        return self
-
-    def __sub__(left, right):
-        if isinstance(left, QobjEvo):
-            res = left.copy()
-            res += -right
-            return res
-        else:
-            res = -right.copy()
-            res += left
-            return res
-
-    def __rsub__(self, other):
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        res = -self
-        res += other
-        return res
-
-    def __isub__(self, other):
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        self += (-other)
-        return self
-
-    def __matmul__(left, right):
-        cdef QobjEvo res
-        if isinstance(left, QobjEvo):
-            return left.copy().__imatmul__(right)
-        elif isinstance(left, Qobj):
-            if left.dims[1] != (<QobjEvo> right).dims[0]:
-                raise TypeError("incompatible dimensions" +
-                                 str(left.dims[1]) + ", " +
-                                 str((<QobjEvo> right).dims[0]))
-
-            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
-            if type_ is None:
-                raise TypeError(
-                    "incompatible matmul types "
-                    + repr(left.type) + " and " + repr(right.type)
-                )
-
-            res = right.copy()
-            res.dims = [left.dims[0], right.dims[1]]
-            res.shape = (left.shape[0], right.shape[1])
-            res.type = type_
-            left = _ConstantElement(left)
-            res.elements = [left @ element for element in res.elements]
-            res._issuper = -1
-            res._isoper = -1
-            return res
-        else:
-            return NotImplemented
-
-    def __rmatmul__(QobjEvo self, other):
-        cdef QobjEvo res
-        if isinstance(other, Qobj):
-            if other.dims[1] != self.dims[0]:
-                raise TypeError("incompatible dimensions" +
-                                 str(other.dims[1]) + ", " +
-                                 str(self.dims[0]))
-
-            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
-            if type_ is None:
-                raise TypeError(
-                    "incompatible matmul types "
-                    + repr(other.type) + " and " + repr(self.type)
-                )
-
-            res = self.copy()
-            res.dims = [other.dims[0], res.dims[1]]
-            res.shape = (other.shape[0], res.shape[1])
-            res.type = type_
-            other = _ConstantElement(other)
-            res.elements = [other @ element for element in res.elements]
-            res._issuper = -1
-            res._isoper = -1
-            return res
-        else:
-            return NotImplemented
-
-    def __imatmul__(QobjEvo self, other):
-        if isinstance(other, (Qobj, QobjEvo)):
-            if self.dims[1] != other.dims[0]:
-                raise TypeError("incompatible dimensions" +
-                                str(self.dims[1]) + ", " +
-                                str(other.dims[0]))
-
-            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
-            if type_ is None:
-                raise TypeError(
-                    "incompatible matmul types "
-                    + repr(self.type) + " and " + repr(other.type)
-                )
-
-            self.dims = [self.dims[0], other.dims[1]]
-            self.shape = (self.shape[0], other.shape[1])
-            self.type = type_
-            self._issuper = -1
-            self._isoper = -1
-            if isinstance(other, Qobj):
-                other = _ConstantElement(other)
-                self.elements = [element @ other for element in self.elements]
-
-            elif isinstance(other, QobjEvo):
-                self.elements = [left @ right
-                    for left, right in itertools.product(
-                        self.elements, (<QobjEvo> other).elements
-                    )]
-        else:
-            return NotImplemented
-        return self
-
-    def __mul__(left, right):
-        if isinstance(left, QobjEvo):
-            return left.copy().__imul__(right)
-        elif isinstance(left, Qobj):
-            return right.__rmatmul__(left)
-        elif isinstance(left, (numbers.Number, Coefficient)):
-            return right.copy().__imul__(left)
-        else:
-            return NotImplemented
-
-    def __rmul__(self, other):
-        if isinstance(other, Qobj):
-            return self.__rmatmul__(other)
-        else:
-            res = self.copy()
-            res *= other
-            return res
-
-    def __imul__(QobjEvo self, other):
-        if isinstance(other, (Qobj, QobjEvo)):
-            self @= other
-        elif isinstance(other, numbers.Number):
-            self.elements = [element * other for element in self.elements]
-        elif isinstance(other, Coefficient):
-            other = _EvoElement(qutip.qeye(self.dims[1]), other)
-            self.elements = [element @ other for element in self.elements]
-        else:
-            return NotImplemented
-        return self
-
-    def __truediv__(left, right):
-        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
-            res = left.copy()
-            res *= 1 / right
-            return res
-        return NotImplemented
-
-    def __idiv__(self, other):
-        if not isinstance(other, numbers.Number):
-            return NotImplemented
-        self *= 1 / other
-        return self
-
-    def __neg__(self):
-        res = self.copy()
-        res *= -1
-        return res
-
-    ###########################################################################
-    # tensor                                                                  #
-    ###########################################################################
-    def __and__(left, right):
-        """
-        Syntax shortcut for tensor:
-        A & B ==> tensor(A, B)
-        """
-        return qutip.tensor(left, right)
-
-    ###########################################################################
-    # Unary transformation                                                    #
-    ###########################################################################
-    def trans(self):
-        """ Transpose of the quantum object """
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(Qobj.trans)
-                        for element in res.elements]
-        return res
-
-    def conj(self):
-        """Get the element-wise conjugation of the quantum object."""
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(Qobj.conj, True)
-                        for element in res.elements]
-        return res
-
-    def dag(self):
-        """Get the Hermitian adjoint of the quantum object."""
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(Qobj.dag, True)
-                        for element in res.elements]
-        return res
-
-    def to(self, data_type):
-        """
-        Convert the underlying data store of all component into the desired
-        storage representation.
-
-        The different storage representations available are the "data-layer
-        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
-        which respectively construct a dense matrix store and a compressed
-        sparse row one.
-
-        The `QobjEvo` is transformed inplace.
-
-        Parameters
-        ----------
-        data_type : type
-            The data-layer type that the data of this `Qobj` should be
-            converted to.
-
-        Returns
-        -------
-        None
-        """
-        return self.linear_map(partial(Qobj.to, data_type=data_type),
-                               _skip_check=True)
-
-    def tidyup(self, atol=1e-12):
-        """Removes small elements from quantum object."""
-        for element in self.elements:
-            if type(element) is _ConstantElement:
-                element = _ConstantElement(element.qobj(0).tidyup(atol))
-            elif type(element) is _EvoElement:
-                element = _EvoElement(element.qobj(0).tidyup(atol),
-                                      element._coefficient)
-        return self
-
-    def linear_map(self, op_mapping, *, _skip_check=False):
-        """
-        Apply mapping to each Qobj contribution.
-
-        Example:
-        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
-        gives the same result has
-        ``QobjEvo([spre(sigmax()), coeff])``
-
-        Returns
-        -------
-        :class:`.QobjEvo`
-            Modified object
-
-        Notes
-        -----
-        Does not modify the coefficients, thus ``linear_map(conj)`` would not
-        give the the conjugate of the QobjEvo. It's only valid for linear
-        transformations.
-        """
-        if not _skip_check:
-            out = op_mapping(self(0))
-            if not isinstance(out, Qobj):
-                raise TypeError("The op_mapping function must return a Qobj")
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(op_mapping) for element in res.elements]
-        res.dims = res.elements[0].qobj(0).dims
-        res.shape = res.elements[0].qobj(0).shape
-        res.type = res.elements[0].qobj(0).type
-        res._issuper = res.elements[0].qobj(0).issuper
-        res._isoper = res.elements[0].qobj(0).isoper
-        if not _skip_check:
-            if res(0) != out:
-                raise ValueError("The mapping is not linear")
-
-        return res
-
-    ###########################################################################
-    # Cleaning and compress                                                   #
-    ###########################################################################
-    def _compress_merge_qobj(self, coeff_elements):
-        """Merge element with matching qobj:
-        ``[A, f1], [A, f2] -> [A, f1+f2]``
-        """
-        cleaned_elements = []
-        # Mimic a dict with Qobj not hashable
-        qobjs = []
-        coeffs = []
-        for element in coeff_elements:
-            for i, qobj in enumerate(qobjs):
-                if element.qobj(0) == qobj:
-                    coeffs[i] = coeffs[i] + element._coefficient
-                    break
-            else:
-                qobjs.append(element.qobj(0))
-                coeffs.append(element._coefficient)
-        for qobj, coeff in zip(qobjs, coeffs):
-            cleaned_elements.append(_EvoElement(qobj, coeff))
-        return cleaned_elements
-
-    def compress(self):
-        """
-        Look for redundance in the :obj:`~QobjEvo` components:
-
-        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
-        summed.
-        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
-
-        Example:
-        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
-
-        The :class:`~QobjEvo` is transformed inplace.
-
-        Returns
-        -------
-        None
-        """
-        cte_elements = []
-        coeff_elements = []
-        func_elements = []
-        for element in self.elements:
-            if type(element) is _ConstantElement:
-                cte_elements.append(element)
-            elif type(element) is _EvoElement:
-                coeff_elements.append(element)
-            else:
-                func_elements.append(element)
-
-        cleaned_elements = []
-        if len(cte_elements) >= 2:
-            # Multiple constant parts
-            cleaned_elements.append(_ConstantElement(
-                sum(element.qobj(0) for element in cte_elements)))
-        else:
-            cleaned_elements += cte_elements
-
-        coeff_elements = self._compress_merge_qobj(coeff_elements)
-        cleaned_elements += coeff_elements + func_elements
-
-        self.elements = cleaned_elements
-
-    def to_list(QobjEvo self):
-        """
-        Restore the QobjEvo to a list form.
-
-        Returns
-        -------
-        list_qevo: list
-            The QobjEvo as a list, element are either :class:`Qobj` for
-            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
-            The original format of the :class:`Coefficient` is not restored.
-            Lastly if the original `QobjEvo` is constructed with a function
-            returning a Qobj, the term is returned as a pair of the original
-            function and args (``dict``).
-        """
-        out = []
-        for element in self.elements:
-            if isinstance(element, _ConstantElement):
-                out.append(element.qobj(0))
-            elif isinstance(element, _EvoElement):
-                coeff = element._coefficient
-                out.append([element.qobj(0), coeff])
-            elif isinstance(element, _FuncElement):
-                func = element._func
-                args = element._args
-                out.append([func, args])
-            else:
-                out.append([element, {}])
-        return out
-
-    ###########################################################################
-    # properties                                                              #
-    ###########################################################################
-    @property
-    def num_elements(self):
-        """Number of parts composing the system"""
-        return len(self.elements)
-
-    @property
-    def isconstant(self):
-        """Does the system change depending on ``t``"""
-        return not any(type(element) is not _ConstantElement
-                       for element in self.elements)
-
-    @property
-    def isoper(self):
-        """Indicates if the system represents an operator."""
-        # TODO: isoper should be part of dims
-        if self._isoper == -1:
-            self._isoper = type_from_dims(self.dims) == "oper"
-        return self._isoper
-
-    @property
-    def issuper(self):
-        """Indicates if the system represents a superoperator."""
-        # TODO: issuper should/will be part of dims
-        # remove self._issuper then
-        if self._issuper == -1:
-            self._issuper = type_from_dims(self.dims) == "super"
-        return self._issuper
-
-    ###########################################################################
-    # operation methods                                                       #
-    ###########################################################################
-    def expect(QobjEvo self, object t, state, check_real=True):
-        """
-        Expectation value of this operator at time ``t`` with the state.
-
-        Parameters
-        ----------
-        t : float
-            Time of the operator to apply.
-
-        state : Qobj
-            right matrix of the product
-
-        check_real : bool (True)
-            Whether to convert the result to a `real` when the imaginary part
-            is smaller than the real part by a dactor of
-            ``settings.core['rtol']``.
-
-        Returns
-        -------
-        expect : float or complex
-            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
-            ``trace(self @ matrix)`` is ``state`` is an operator or
-            operator-ket.
-        """
-        # TODO: remove reading from `settings` for a typed value when options
-        # support property.
-        cdef float herm_rtol = settings.core['rtol']
-        if not isinstance(state, Qobj):
-            raise TypeError("A Qobj state is expected")
-        if not (self.isoper or self.issuper):
-            raise ValueError("Must be an operator or super operator to compute"
-                             " an expectation value")
-        if not (
-            (self.dims[1] == state.dims[0]) or
-            (self.issuper and self.dims[1] == state.dims)
-        ):
-            raise ValueError("incompatible dimensions " + str(self.dims) +
-                             ", " + str(state.dims))
-        out = self.expect_data(t, state.data)
-        if (
-            check_real and
-            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
-        ):
-            return out.real
-        return out
-
-    cpdef object expect_data(QobjEvo self, object t, Data state):
-        """
-        Expectation is defined as ``state.adjoint() @ self @ state`` if
-        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
-        superoperator.  If ``state`` is an operator and ``self`` is an
-        operator, then expectation is ``trace(self @ matrix)``.
-        """
-        if type(state) is Dense:
-            return self._expect_dense(t, state)
-        cdef _BaseElement part
-        cdef object out = 0.
-        cdef Data part_data
-        cdef object expect_func
-        t = self._prepare(t, state)
-        if self.issuper:
-            if state.shape[1] != 1:
-                state = _data.column_stack(state)
-            expect_func = _data.expect_super
-        else:
-            expect_func = _data.expect
-
-        for element in self.elements:
-            part = (<_BaseElement> element)
-            part_data = part.data(t)
-            out += part.coeff(t) * expect_func(part_data, state)
-        return out
-
-    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
-        """For Dense state, ``column_stack_dense`` can be done inplace if in
-        fortran format."""
-        cdef size_t nrow = state.shape[0]
-        cdef _BaseElement part
-        cdef double complex out = 0., coeff
-        cdef Data part_data
-        t = self._prepare(t, state)
-        if self.issuper:
-            if state.shape[1] != 1:
-                state = column_stack_dense(state, inplace=state.fortran)
-            try:
-                for element in self.elements:
-                    part = (<_BaseElement> element)
-                    coeff = part.coeff(t)
-                    part_data = part.data(t)
-                    out += coeff * expect_super_data_dense(part_data, state)
-            finally:
-                if state.fortran:
-                    # `state` was reshaped inplace, restore it's original shape
-                    column_unstack_dense(state, nrow, inplace=state.fortran)
-        else:
-            for element in self.elements:
-                part = (<_BaseElement> element)
-                coeff = part.coeff(t)
-                part_data = part.data(t)
-                out += coeff * expect_data_dense(part_data, state)
-        return out
-
-    def matmul(self, t, state):
-        """
-        Product of this operator at time ``t`` to the state.
-        ``self(t) @ state``
-
-        Parameters
-        ----------
-        t : float
-            Time of the operator to apply.
-        state : Qobj
-            right matrix of the product
-
-        Returns
-        -------
-        product : Qobj
-            The result product as a Qobj
-        """
-        if not isinstance(state, Qobj):
-            raise TypeError("A Qobj state is expected")
-
-        if self.dims[1] != state.dims[0]:
-            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
-                             ", " + str(state.dims[0]))
-
-        return Qobj(self.matmul_data(t, state.data),
-                    dims=[self.dims[0], state.dims[1]],
-                    copy=False
-                    )
-
-    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
-        """Compute ``out += self(t) @ state``"""
-        cdef _BaseElement part
-        t = self._prepare(t, state)
-        if out is None and type(state) is Dense:
-            out = dense.zeros(self.shape[0], state.shape[1],
-                              (<Dense> state).fortran)
-        elif out is None:
-            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
-
-        for element in self.elements:
-            part = (<_BaseElement> element)
-            out = part.matmul_data_t(t, state, out)
-        return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+
+import numpy as np
+import numbers
+import itertools
+from functools import partial
+
+import qutip
+from .. import Qobj
+from .. import data as _data
+from ..coefficient import coefficient, CompilationOptions
+from ._element import *
+from ..dimensions import type_from_dims
+from qutip.settings import settings
+
+from qutip.core.cy._element cimport _BaseElement
+from qutip.core.data cimport Dense, Data, dense
+from qutip.core.data.expect cimport *
+from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
+from libc.math cimport fabs
+
+__all__ = ['QobjEvo']
+
+cdef class QobjEvo:
+    """
+    A class for representing time-dependent quantum objects, such as quantum
+    operators and states.
+
+    Importantly, :obj:`~QobjEvo` instances are used to represent such
+    time-dependent quantum objects when working with QuTiP solvers.
+
+    A :obj:`~QobjEvo` instance may be constructed from one of the following:
+
+      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
+        value of the quantum object at time ``t``.
+
+      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
+        any item that can be used to construct a coefficient (e.g. a function,
+        a numpy array of coefficient values, a string expression).
+
+      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
+
+      * a list of such callables, pairs or :obj:`~Qobj`\s.
+
+      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
+        are ignored except ``args`` which, if passed, replaces the existing
+        arguments).
+
+    Parameters
+    ----------
+    Q_object : callable, list or Qobj
+        A specification of the time-depedent quantum object. See the
+        paragraph above for a full description and the examples section below
+        for examples.
+
+    args : dict, optional
+        A dictionary that contains the arguments for the coefficients.
+        Arguments may be omitted if no function or string coefficients that
+        require arguments are present.
+
+    tlist : array-like, optional
+        A list of times corresponding to the values of the coefficients
+        supplied as numpy arrays. If no coefficients are supplied as numpy
+        arrays, ``tlist`` may be omitted, otherwise it is required.
+
+        The times in ``tlist`` do not need to be equidistant, but must
+        be sorted.
+
+        By default, a cubic spline interpolation will be used to interpolate
+        the value of the (numpy array) coefficients at time ``t``. If the
+        coefficients are to be treated as step functions, pass the argument
+        ``order=0`` (see below).
+
+    order : int, default=3
+        Order of the spline interpolation that is to be used to interpolate
+        the value of the (numpy array) coefficients at time ``t``.
+        ``0`` use previous or left value.
+
+    copy : bool, default=True
+        Whether to make a copy of the :obj:`Qobj` instances supplied in
+        the ``Q_object`` parameter.
+
+    compress : bool, default=True
+        Whether to compress the :obj:`QobjEvo` instance terms after the
+        instance has been created.
+
+        This sums the constant terms in a single term and combines
+        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
+        pair containing the sum of the coefficients.
+
+        See :meth:`compress`.
+
+    function_style : {None, "pythonic", "dict", "auto"}
+        The style of function signature used by callables in ``Q_object``.
+        If style is ``None``, the value of
+        ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+
+    boundary_conditions : 2-Tuple, str or None, optional
+        Boundary conditions for spline evaluation. Default value is `None`.
+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+        Refer to Scipy's documentation for further details:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+
+
+    Attributes
+    ----------
+    dims : list
+        List of dimensions keeping track of the tensor structure.
+
+    shape : (int, int)
+        List of dimensions keeping track of the tensor structure.
+
+    type : str
+        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
+        'operator-bra', or 'super'.
+
+    superrep : str
+        Representation used if `type` is 'super'. One of 'super'
+        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
+
+    Examples
+    --------
+
+    A :obj:`~QobjEvo` constructed from a function:
+
+    .. code-block::
+
+        def f(t, args):
+            return qutip.qeye(N) * np.exp(args['w'] * t)
+
+        QobjEvo(f, args={'w': 1j})
+
+
+    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
+    ``[Qobj, Coefficient]`` pairs:
+
+    .. code-block::
+
+        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
+
+    The coefficients may be specified either using a :obj:`~Coefficient`
+    object or by a function, string, numpy array or any object that
+    can be passed to the :func:`~coefficient` function. See the documentation
+    of :func:`coefficient` for a full description.
+
+    An example of a coefficient specified by a function:
+
+    .. code-block::
+
+        def f1_t(t, args):
+            return np.exp(-1j * t * args["w1"])
+
+        QobjEvo([[H1, f1_t]], args={"w1": 1.})
+
+    And of coefficients specified by string expressions:
+
+    .. code-block::
+
+        H = QobjEvo(
+            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
+            args={"w1": 1., "w2": 2.}
+        )
+
+    Coefficients maybe also be expressed as numpy arrays giving a list
+    of the coefficient values:
+
+    .. code-block:: python
+
+        tlist = np.logspace(-5, 0, 100)
+        H = QobjEvo(
+            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
+            tlist=tlist
+        )
+
+    The coeffients array must have the same len as the tlist.
+
+    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
+    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
+
+    .. code-block:: python
+
+        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
+        qevo = H0 + H1 * coeff
+
+    """
+    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
+                 order=3, copy=True, compress=True,
+                 function_style=None, boundary_conditions=None):
+        if isinstance(Q_object, QobjEvo):
+            self.dims = Q_object.dims.copy()
+            self.shape = Q_object.shape
+            self.type = Q_object.type
+            self._issuper = (<QobjEvo> Q_object)._issuper
+            self._isoper = (<QobjEvo> Q_object)._isoper
+            self.elements = (<QobjEvo> Q_object).elements.copy()
+            if args:
+                self.arguments(args)
+            if compress:
+                self.compress()
+            return
+
+        self.elements = []
+        self.dims = None
+        self.shape = (0, 0)
+        self._issuper = -1
+        self._isoper = -1
+        args = args or {}
+
+        if (
+            isinstance(Q_object, list)
+            and len(Q_object) == 2
+            and isinstance(Q_object[0], Qobj)
+            and not isinstance(Q_object[1], (Qobj, list))
+        ):
+            # The format is [Qobj, coefficient]
+            Q_object = [Q_object]
+
+        if isinstance(Q_object, list):
+            for op in Q_object:
+                self.elements.append(
+                    self._read_element(
+                        op, copy=copy, tlist=tlist, args=args, order=order,
+                        function_style=function_style,
+                        boundary_conditions=boundary_conditions
+                    )
+                )
+        else:
+            self.elements.append(
+                self._read_element(
+                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
+                    function_style=function_style,
+                    boundary_conditions=boundary_conditions
+                )
+            )
+
+        if compress:
+            self.compress()
+
+    def __repr__(self):
+        cls = self.__class__.__name__
+        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
+        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
+        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
+        return repr_str
+
+    def _read_element(self, op, copy, tlist, args, order, function_style, 
+                      boundary_conditions):
+        """ Read a Q_object item and return an element for that item. """
+        if isinstance(op, Qobj):
+            out = _ConstantElement(op.copy() if copy else op)
+            qobj = op
+        elif isinstance(op, list):
+            out = _EvoElement(
+                op[0].copy() if copy else op[0],
+                coefficient(op[1], tlist=tlist, args=args, order=order, 
+                            boundary_conditions=boundary_conditions)
+            )
+            qobj = op[0]
+        elif isinstance(op, _BaseElement):
+            out = op
+            qobj = op.qobj(0)
+        elif callable(op):
+            out = _FuncElement(op, args, style=function_style)
+            qobj = out.qobj(0)
+            if not isinstance(qobj, Qobj):
+                raise TypeError(
+                    "Function based time-dependent elements must have the"
+                    " signature f(t: double, args: dict) -> Qobj, but"
+                    " {!r} returned: {!r}".format(op, qobj)
+                )
+        else:
+            raise TypeError(
+                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
+                " or a function f(t: double, args: dict) -> Qobj, but"
+                " received: {!r}".format(op)
+            )
+
+        if self.dims is None:
+            self.dims = qobj.dims
+            self.shape = qobj.shape
+            self.type = qobj.type
+            self.superrep = qobj.superrep
+        elif self.dims != qobj.dims or self.shape != qobj.shape:
+            raise ValueError(
+                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
+                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
+                f" and shape {self.shape!r}."
+            )
+        elif self.type != qobj.type:
+            raise ValueError(
+                f"QobjEvo term {op!r} has type {qobj.type!r} but "
+                f"previous terms had type {self.type!r}."
+            )
+        elif self.superrep != qobj.superrep:
+            raise ValueError(
+                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
+                f"previous terms had superrep {self.superrep!r}."
+            )
+
+        return out
+
+    @classmethod
+    def _restore(cls, elements, dims, shape, type, superrep, flags):
+        """Recreate a QobjEvo without using __init__. """
+        cdef QobjEvo out = cls.__new__(cls)
+        out.elements = elements
+        out.dims = dims
+        out.shape = shape
+        out.type = type
+        out.superrep = superrep
+        out._issuper, out._isoper = flags
+        return out
+
+    def _getstate(self):
+        """ Obtain the state """
+        # For jax pytree representation
+        # auto_pickle create similar method __getstate__, but since it's
+        # automatically created, it could change depending on cython version
+        # etc., so we create our own.
+        return {
+            "elements": self.elements,
+            "dims": self.dims,
+            "shape": self.shape,
+            "type": self.type,
+            "superrep": self.superrep,
+            "flags": (self._issuper, self._isoper,)
+        }
+
+    def __call__(self, double t, dict _args=None, **kwargs):
+        """
+        Get the :class:`~Qobj` at ``t``.
+
+        Parameters
+        ----------
+        t : float
+            Time at which the ``QobjEvo`` is to be evalued.
+
+        _args : dict [optional]
+            New arguments as a dict. Update args with ``arguments(new_args)``.
+
+        **kwargs :
+            New arguments as a keywors. Update args with
+            ``arguments(**new_args)``.
+
+        .. note::
+            If both the positional ``_args`` and keywords are passed new values
+            from both will be used. If a key is present with both, the
+            ``_args`` dict value will take priority.
+        """
+        if _args is not None or kwargs:
+            if _args is not None:
+                kwargs.update(_args)
+            return QobjEvo(self, args=kwargs)(t)
+
+        t = self._prepare(t, None)
+
+        if self.isconstant:
+            # For constant QobjEvo's, we sum the contained Qobjs directly in
+            # order to retain the cached values of attributes like .isherm when
+            # possible, rather than calling _call(t) which may lose this cached
+            # information.
+            return sum(element.qobj(t) for element in self.elements)
+
+        cdef _BaseElement part = self.elements[0]
+        cdef double complex coeff = part.coeff(t)
+        obj = part.qobj(t)
+        cdef Data out = _data.mul(obj.data, coeff)
+        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
+        for element in self.elements[1:]:
+            part = <_BaseElement> element
+            coeff = part.coeff(t)
+            obj = part.qobj(t)
+            isherm &= <bint> obj._isherm and coeff.imag == 0
+            out = _data.add(out, obj.data, coeff)
+
+        return Qobj(
+            out, dims=self.dims, copy=False, isherm=isherm or None,
+            type=self.type, superrep=self.superrep
+        )
+
+    cpdef Data _call(QobjEvo self, double t):
+        t = self._prepare(t, None)
+        cdef Data out
+        cdef _BaseElement part = self.elements[0]
+        out = _data.mul(part.data(t),
+                        part.coeff(t))
+        for element in self.elements[1:]:
+            part = <_BaseElement> element
+
+            out = _data.add(
+                out,
+                part.data(t),
+                part.coeff(t)
+            )
+        return out
+
+    cdef object _prepare(QobjEvo self, object t, Data state=None):
+        """ Precomputation before computing getting the element at `t`"""
+        # We keep the function for feedback eventually
+        return t
+
+    def copy(QobjEvo self):
+        """Return a copy of this `QobjEvo`"""
+        return QobjEvo(self, compress=False)
+
+    def arguments(QobjEvo self, dict _args=None, **kwargs):
+        """
+        Update the arguments.
+
+        Parameters
+        ----------
+        _args : dict [optional]
+            New arguments as a dict. Update args with ``arguments(new_args)``.
+
+        **kwargs :
+            New arguments as a keywors. Update args with
+            ``arguments(**new_args)``.
+
+        .. note::
+            If both the positional ``_args`` and keywords are passed new values
+            from both will be used. If a key is present with both, the ``_args``
+            dict value will take priority.
+        """
+        if _args is not None:
+            kwargs.update(_args)
+        cache = []
+        self.elements = [
+            element.replace_arguments(kwargs, cache=cache)
+            for element in self.elements
+        ]
+
+
+    ###########################################################################
+    # Math function                                                           #
+    ###########################################################################
+    def __add__(left, right):
+        if isinstance(left, QobjEvo):
+            self = left
+            other = right
+        else:
+            self = right
+            other = left
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        res = self.copy()
+        res += other
+        return res
+
+    def __radd__(self, other):
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        res = self.copy()
+        res += other
+        return res
+
+    def __iadd__(QobjEvo self, other):
+        cdef _BaseElement element
+        if isinstance(other, QobjEvo):
+            if other.dims != self.dims:
+                raise TypeError("incompatible dimensions" +
+                                str(self.dims) + ", " + str(other.dims))
+            for element in (<QobjEvo> other).elements:
+                self.elements.append(element)
+        elif isinstance(other, Qobj):
+            if other.dims != self.dims:
+                raise TypeError("incompatible dimensions" +
+                                str(self.dims) + ", " + str(other.dims))
+            self.elements.append(_ConstantElement(other))
+        elif (
+            isinstance(other, numbers.Number) and
+            self.dims[0] == self.dims[1]
+        ):
+            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
+        else:
+            return NotImplemented
+        return self
+
+    def __sub__(left, right):
+        if isinstance(left, QobjEvo):
+            res = left.copy()
+            res += -right
+            return res
+        else:
+            res = -right.copy()
+            res += left
+            return res
+
+    def __rsub__(self, other):
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        res = -self
+        res += other
+        return res
+
+    def __isub__(self, other):
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        self += (-other)
+        return self
+
+    def __matmul__(left, right):
+        cdef QobjEvo res
+        if isinstance(left, QobjEvo):
+            return left.copy().__imatmul__(right)
+        elif isinstance(left, Qobj):
+            if left.dims[1] != (<QobjEvo> right).dims[0]:
+                raise TypeError("incompatible dimensions" +
+                                 str(left.dims[1]) + ", " +
+                                 str((<QobjEvo> right).dims[0]))
+
+            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
+            if type_ is None:
+                raise TypeError(
+                    "incompatible matmul types "
+                    + repr(left.type) + " and " + repr(right.type)
+                )
+
+            res = right.copy()
+            res.dims = [left.dims[0], right.dims[1]]
+            res.shape = (left.shape[0], right.shape[1])
+            res.type = type_
+            left = _ConstantElement(left)
+            res.elements = [left @ element for element in res.elements]
+            res._issuper = -1
+            res._isoper = -1
+            return res
+        else:
+            return NotImplemented
+
+    def __rmatmul__(QobjEvo self, other):
+        cdef QobjEvo res
+        if isinstance(other, Qobj):
+            if other.dims[1] != self.dims[0]:
+                raise TypeError("incompatible dimensions" +
+                                 str(other.dims[1]) + ", " +
+                                 str(self.dims[0]))
+
+            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
+            if type_ is None:
+                raise TypeError(
+                    "incompatible matmul types "
+                    + repr(other.type) + " and " + repr(self.type)
+                )
+
+            res = self.copy()
+            res.dims = [other.dims[0], res.dims[1]]
+            res.shape = (other.shape[0], res.shape[1])
+            res.type = type_
+            other = _ConstantElement(other)
+            res.elements = [other @ element for element in res.elements]
+            res._issuper = -1
+            res._isoper = -1
+            return res
+        else:
+            return NotImplemented
+
+    def __imatmul__(QobjEvo self, other):
+        if isinstance(other, (Qobj, QobjEvo)):
+            if self.dims[1] != other.dims[0]:
+                raise TypeError("incompatible dimensions" +
+                                str(self.dims[1]) + ", " +
+                                str(other.dims[0]))
+
+            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
+            if type_ is None:
+                raise TypeError(
+                    "incompatible matmul types "
+                    + repr(self.type) + " and " + repr(other.type)
+                )
+
+            self.dims = [self.dims[0], other.dims[1]]
+            self.shape = (self.shape[0], other.shape[1])
+            self.type = type_
+            self._issuper = -1
+            self._isoper = -1
+            if isinstance(other, Qobj):
+                other = _ConstantElement(other)
+                self.elements = [element @ other for element in self.elements]
+
+            elif isinstance(other, QobjEvo):
+                self.elements = [left @ right
+                    for left, right in itertools.product(
+                        self.elements, (<QobjEvo> other).elements
+                    )]
+        else:
+            return NotImplemented
+        return self
+
+    def __mul__(left, right):
+        if isinstance(left, QobjEvo):
+            return left.copy().__imul__(right)
+        elif isinstance(left, Qobj):
+            return right.__rmatmul__(left)
+        elif isinstance(left, (numbers.Number, Coefficient)):
+            return right.copy().__imul__(left)
+        else:
+            return NotImplemented
+
+    def __rmul__(self, other):
+        if isinstance(other, Qobj):
+            return self.__rmatmul__(other)
+        else:
+            res = self.copy()
+            res *= other
+            return res
+
+    def __imul__(QobjEvo self, other):
+        if isinstance(other, (Qobj, QobjEvo)):
+            self @= other
+        elif isinstance(other, numbers.Number):
+            self.elements = [element * other for element in self.elements]
+        elif isinstance(other, Coefficient):
+            other = _EvoElement(qutip.qeye(self.dims[1]), other)
+            self.elements = [element @ other for element in self.elements]
+        else:
+            return NotImplemented
+        return self
+
+    def __truediv__(left, right):
+        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
+            res = left.copy()
+            res *= 1 / right
+            return res
+        return NotImplemented
+
+    def __idiv__(self, other):
+        if not isinstance(other, numbers.Number):
+            return NotImplemented
+        self *= 1 / other
+        return self
+
+    def __neg__(self):
+        res = self.copy()
+        res *= -1
+        return res
+
+    ###########################################################################
+    # tensor                                                                  #
+    ###########################################################################
+    def __and__(left, right):
+        """
+        Syntax shortcut for tensor:
+        A & B ==> tensor(A, B)
+        """
+        return qutip.tensor(left, right)
+
+    ###########################################################################
+    # Unary transformation                                                    #
+    ###########################################################################
+    def trans(self):
+        """ Transpose of the quantum object """
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(Qobj.trans)
+                        for element in res.elements]
+        return res
+
+    def conj(self):
+        """Get the element-wise conjugation of the quantum object."""
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(Qobj.conj, True)
+                        for element in res.elements]
+        return res
+
+    def dag(self):
+        """Get the Hermitian adjoint of the quantum object."""
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(Qobj.dag, True)
+                        for element in res.elements]
+        return res
+
+    def to(self, data_type):
+        """
+        Convert the underlying data store of all component into the desired
+        storage representation.
+
+        The different storage representations available are the "data-layer
+        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
+        which respectively construct a dense matrix store and a compressed
+        sparse row one.
+
+        The `QobjEvo` is transformed inplace.
+
+        Parameters
+        ----------
+        data_type : type
+            The data-layer type that the data of this `Qobj` should be
+            converted to.
+
+        Returns
+        -------
+        None
+        """
+        return self.linear_map(partial(Qobj.to, data_type=data_type),
+                               _skip_check=True)
+
+    def tidyup(self, atol=1e-12):
+        """Removes small elements from quantum object."""
+        for element in self.elements:
+            if type(element) is _ConstantElement:
+                element = _ConstantElement(element.qobj(0).tidyup(atol))
+            elif type(element) is _EvoElement:
+                element = _EvoElement(element.qobj(0).tidyup(atol),
+                                      element._coefficient)
+        return self
+
+    def linear_map(self, op_mapping, *, _skip_check=False):
+        """
+        Apply mapping to each Qobj contribution.
+
+        Example:
+        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
+        gives the same result has
+        ``QobjEvo([spre(sigmax()), coeff])``
+
+        Returns
+        -------
+        :class:`.QobjEvo`
+            Modified object
+
+        Notes
+        -----
+        Does not modify the coefficients, thus ``linear_map(conj)`` would not
+        give the the conjugate of the QobjEvo. It's only valid for linear
+        transformations.
+        """
+        if not _skip_check:
+            out = op_mapping(self(0))
+            if not isinstance(out, Qobj):
+                raise TypeError("The op_mapping function must return a Qobj")
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(op_mapping) for element in res.elements]
+        res.dims = res.elements[0].qobj(0).dims
+        res.shape = res.elements[0].qobj(0).shape
+        res.type = res.elements[0].qobj(0).type
+        res._issuper = res.elements[0].qobj(0).issuper
+        res._isoper = res.elements[0].qobj(0).isoper
+        if not _skip_check:
+            if res(0) != out:
+                raise ValueError("The mapping is not linear")
+
+        return res
+
+    ###########################################################################
+    # Cleaning and compress                                                   #
+    ###########################################################################
+    def _compress_merge_qobj(self, coeff_elements):
+        """Merge element with matching qobj:
+        ``[A, f1], [A, f2] -> [A, f1+f2]``
+        """
+        cleaned_elements = []
+        # Mimic a dict with Qobj not hashable
+        qobjs = []
+        coeffs = []
+        for element in coeff_elements:
+            for i, qobj in enumerate(qobjs):
+                if element.qobj(0) == qobj:
+                    coeffs[i] = coeffs[i] + element._coefficient
+                    break
+            else:
+                qobjs.append(element.qobj(0))
+                coeffs.append(element._coefficient)
+        for qobj, coeff in zip(qobjs, coeffs):
+            cleaned_elements.append(_EvoElement(qobj, coeff))
+        return cleaned_elements
+
+    def compress(self):
+        """
+        Look for redundance in the :obj:`~QobjEvo` components:
+
+        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
+        summed.
+        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
+
+        Example:
+        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
+
+        The :class:`~QobjEvo` is transformed inplace.
+
+        Returns
+        -------
+        None
+        """
+        cte_elements = []
+        coeff_elements = []
+        func_elements = []
+        for element in self.elements:
+            if type(element) is _ConstantElement:
+                cte_elements.append(element)
+            elif type(element) is _EvoElement:
+                coeff_elements.append(element)
+            else:
+                func_elements.append(element)
+
+        cleaned_elements = []
+        if len(cte_elements) >= 2:
+            # Multiple constant parts
+            cleaned_elements.append(_ConstantElement(
+                sum(element.qobj(0) for element in cte_elements)))
+        else:
+            cleaned_elements += cte_elements
+
+        coeff_elements = self._compress_merge_qobj(coeff_elements)
+        cleaned_elements += coeff_elements + func_elements
+
+        self.elements = cleaned_elements
+
+    def to_list(QobjEvo self):
+        """
+        Restore the QobjEvo to a list form.
+
+        Returns
+        -------
+        list_qevo: list
+            The QobjEvo as a list, element are either :class:`Qobj` for
+            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
+            The original format of the :class:`Coefficient` is not restored.
+            Lastly if the original `QobjEvo` is constructed with a function
+            returning a Qobj, the term is returned as a pair of the original
+            function and args (``dict``).
+        """
+        out = []
+        for element in self.elements:
+            if isinstance(element, _ConstantElement):
+                out.append(element.qobj(0))
+            elif isinstance(element, _EvoElement):
+                coeff = element._coefficient
+                out.append([element.qobj(0), coeff])
+            elif isinstance(element, _FuncElement):
+                func = element._func
+                args = element._args
+                out.append([func, args])
+            else:
+                out.append([element, {}])
+        return out
+
+    ###########################################################################
+    # properties                                                              #
+    ###########################################################################
+    @property
+    def num_elements(self):
+        """Number of parts composing the system"""
+        return len(self.elements)
+
+    @property
+    def isconstant(self):
+        """Does the system change depending on ``t``"""
+        return not any(type(element) is not _ConstantElement
+                       for element in self.elements)
+
+    @property
+    def isoper(self):
+        """Indicates if the system represents an operator."""
+        # TODO: isoper should be part of dims
+        if self._isoper == -1:
+            self._isoper = type_from_dims(self.dims) == "oper"
+        return self._isoper
+
+    @property
+    def issuper(self):
+        """Indicates if the system represents a superoperator."""
+        # TODO: issuper should/will be part of dims
+        # remove self._issuper then
+        if self._issuper == -1:
+            self._issuper = type_from_dims(self.dims) == "super"
+        return self._issuper
+
+    ###########################################################################
+    # operation methods                                                       #
+    ###########################################################################
+    def expect(QobjEvo self, object t, state, check_real=True):
+        """
+        Expectation value of this operator at time ``t`` with the state.
+
+        Parameters
+        ----------
+        t : float
+            Time of the operator to apply.
+
+        state : Qobj
+            right matrix of the product
+
+        check_real : bool (True)
+            Whether to convert the result to a `real` when the imaginary part
+            is smaller than the real part by a dactor of
+            ``settings.core['rtol']``.
+
+        Returns
+        -------
+        expect : float or complex
+            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
+            ``trace(self @ matrix)`` is ``state`` is an operator or
+            operator-ket.
+        """
+        # TODO: remove reading from `settings` for a typed value when options
+        # support property.
+        cdef float herm_rtol = settings.core['rtol']
+        if not isinstance(state, Qobj):
+            raise TypeError("A Qobj state is expected")
+        if not (self.isoper or self.issuper):
+            raise ValueError("Must be an operator or super operator to compute"
+                             " an expectation value")
+        if not (
+            (self.dims[1] == state.dims[0]) or
+            (self.issuper and self.dims[1] == state.dims)
+        ):
+            raise ValueError("incompatible dimensions " + str(self.dims) +
+                             ", " + str(state.dims))
+        out = self.expect_data(t, state.data)
+        if (
+            check_real and
+            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
+        ):
+            return out.real
+        return out
+
+    cpdef object expect_data(QobjEvo self, object t, Data state):
+        """
+        Expectation is defined as ``state.adjoint() @ self @ state`` if
+        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
+        superoperator.  If ``state`` is an operator and ``self`` is an
+        operator, then expectation is ``trace(self @ matrix)``.
+        """
+        if type(state) is Dense:
+            return self._expect_dense(t, state)
+        cdef _BaseElement part
+        cdef object out = 0.
+        cdef Data part_data
+        cdef object expect_func
+        t = self._prepare(t, state)
+        if self.issuper:
+            if state.shape[1] != 1:
+                state = _data.column_stack(state)
+            expect_func = _data.expect_super
+        else:
+            expect_func = _data.expect
+
+        for element in self.elements:
+            part = (<_BaseElement> element)
+            part_data = part.data(t)
+            out += part.coeff(t) * expect_func(part_data, state)
+        return out
+
+    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
+        """For Dense state, ``column_stack_dense`` can be done inplace if in
+        fortran format."""
+        cdef size_t nrow = state.shape[0]
+        cdef _BaseElement part
+        cdef double complex out = 0., coeff
+        cdef Data part_data
+        t = self._prepare(t, state)
+        if self.issuper:
+            if state.shape[1] != 1:
+                state = column_stack_dense(state, inplace=state.fortran)
+            try:
+                for element in self.elements:
+                    part = (<_BaseElement> element)
+                    coeff = part.coeff(t)
+                    part_data = part.data(t)
+                    out += coeff * expect_super_data_dense(part_data, state)
+            finally:
+                if state.fortran:
+                    # `state` was reshaped inplace, restore it's original shape
+                    column_unstack_dense(state, nrow, inplace=state.fortran)
+        else:
+            for element in self.elements:
+                part = (<_BaseElement> element)
+                coeff = part.coeff(t)
+                part_data = part.data(t)
+                out += coeff * expect_data_dense(part_data, state)
+        return out
+
+    def matmul(self, t, state):
+        """
+        Product of this operator at time ``t`` to the state.
+        ``self(t) @ state``
+
+        Parameters
+        ----------
+        t : float
+            Time of the operator to apply.
+        state : Qobj
+            right matrix of the product
+
+        Returns
+        -------
+        product : Qobj
+            The result product as a Qobj
+        """
+        if not isinstance(state, Qobj):
+            raise TypeError("A Qobj state is expected")
+
+        if self.dims[1] != state.dims[0]:
+            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
+                             ", " + str(state.dims[0]))
+
+        return Qobj(self.matmul_data(t, state.data),
+                    dims=[self.dims[0], state.dims[1]],
+                    copy=False
+                    )
+
+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
+        """Compute ``out += self(t) @ state``"""
+        cdef _BaseElement part
+        t = self._prepare(t, state)
+        if out is None and type(state) is Dense:
+            out = dense.zeros(self.shape[0], state.shape[1],
+                              (<Dense> state).fortran)
+        elif out is None:
+            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
+
+        for element in self.elements:
+            part = (<_BaseElement> element)
+            out = part.matmul_data_t(t, state, out)
+        return out
diff --git a/qutip/core/data/__init__.pxd b/qutip/core/data/__init__.pxd
index c1b4e6809d..1f5c75d908 100644
--- a/qutip/core/data/__init__.pxd
+++ b/qutip/core/data/__init__.pxd
@@ -1,13 +1,13 @@
-#cython: language_level=3
-
-# Package-level relative imports in Cython (0.29.17) are temperamental.
-from qutip.core.data cimport dense, csr
-from qutip.core.data.base cimport Data, idxint
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.csr cimport CSR
-
-from qutip.core.data.add cimport *
-from qutip.core.data.adjoint cimport *
-from qutip.core.data.kron cimport *
-from qutip.core.data.matmul cimport *
-from qutip.core.data.mul cimport *
+#cython: language_level=3
+
+# Package-level relative imports in Cython (0.29.17) are temperamental.
+from qutip.core.data cimport dense, csr
+from qutip.core.data.base cimport Data, idxint
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport CSR
+
+from qutip.core.data.add cimport *
+from qutip.core.data.adjoint cimport *
+from qutip.core.data.kron cimport *
+from qutip.core.data.matmul cimport *
+from qutip.core.data.mul cimport *
diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index 557aff5c04..5fd15509ab 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -1,56 +1,56 @@
-# First-class type imports
-
-from . import dense, csr
-from .dense import Dense
-from .csr import CSR
-from .base import Data
-
-from .add import *
-from .adjoint import *
-from .constant import *
-from .eigen import *
-from .expect import *
-from .expm import *
-from .inner import *
-from .kron import *
-from .linalg import *
-from .matmul import *
-from .make import *
-from .mul import *
-from .pow import *
-from .project import *
-from .properties import *
-from .ptrace import *
-from .reshape import *
-from .tidyup import *
-from .trace import *
-from .solve import *
-# For operations with mulitple related versions, we just import the module.
-from . import norm, permute
-
-
-# Set up the data conversions that are known by us.  All types covered by
-# conversions will be made available for use in the dispatcher functions.
-
-from .convert import to, create
-to.add_conversions([
-    (Dense, CSR, dense.from_csr, 1),
-    (CSR, Dense, csr.from_dense, 1.4),
-])
-to.register_aliases(['csr', 'CSR'], CSR)
-to.register_aliases(['Dense', 'dense'], Dense)
-
-
-from . import _creator_utils
-import numpy as np
-create.add_creators([
-    (_creator_utils.is_data, _creator_utils.data_copy, 100),
-    (_creator_utils.isspmatrix_csr, CSR, 80),
-    (_creator_utils.is_nparray, Dense, 80),
-    (_creator_utils.issparse, CSR, 20),
-    (_creator_utils.true, Dense, -np.inf),
-])
-del _creator_utils
-del np
-
-from .dispatch import Dispatcher
+# First-class type imports
+
+from . import dense, csr
+from .dense import Dense
+from .csr import CSR
+from .base import Data
+
+from .add import *
+from .adjoint import *
+from .constant import *
+from .eigen import *
+from .expect import *
+from .expm import *
+from .inner import *
+from .kron import *
+from .linalg import *
+from .matmul import *
+from .make import *
+from .mul import *
+from .pow import *
+from .project import *
+from .properties import *
+from .ptrace import *
+from .reshape import *
+from .tidyup import *
+from .trace import *
+from .solve import *
+# For operations with mulitple related versions, we just import the module.
+from . import norm, permute
+
+
+# Set up the data conversions that are known by us.  All types covered by
+# conversions will be made available for use in the dispatcher functions.
+
+from .convert import to, create
+to.add_conversions([
+    (Dense, CSR, dense.from_csr, 1),
+    (CSR, Dense, csr.from_dense, 1.4),
+])
+to.register_aliases(['csr', 'CSR'], CSR)
+to.register_aliases(['Dense', 'dense'], Dense)
+
+
+from . import _creator_utils
+import numpy as np
+create.add_creators([
+    (_creator_utils.is_data, _creator_utils.data_copy, 100),
+    (_creator_utils.isspmatrix_csr, CSR, 80),
+    (_creator_utils.is_nparray, Dense, 80),
+    (_creator_utils.issparse, CSR, 20),
+    (_creator_utils.true, Dense, -np.inf),
+])
+del _creator_utils
+del np
+
+from .dispatch import Dispatcher
diff --git a/qutip/core/data/_creator_utils.py b/qutip/core/data/_creator_utils.py
index 3f3779e219..1432804b94 100644
--- a/qutip/core/data/_creator_utils.py
+++ b/qutip/core/data/_creator_utils.py
@@ -1,31 +1,31 @@
-"""
-Define functions to use as Data creator for `create` in `convert.py`.
-"""
-
-from scipy.sparse import isspmatrix_csr, issparse
-import numpy as np
-from .csr import CSR
-from .base import Data
-from .dense import Dense
-
-__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
-
-
-def is_data(arg):
-    return isinstance(arg, Data)
-
-
-def is_nparray(arg):
-    return isinstance(arg, np.ndarray)
-
-
-def true(arg):
-    return True
-
-
-def data_copy(arg, shape, copy=True):
-    if shape is not None and shape != arg.shape:
-        raise ValueError("".join([
-            "shapes do not match: ", str(shape), " and ", str(arg.shape),
-        ]))
-    return arg.copy() if copy else arg
+"""
+Define functions to use as Data creator for `create` in `convert.py`.
+"""
+
+from scipy.sparse import isspmatrix_csr, issparse
+import numpy as np
+from .csr import CSR
+from .base import Data
+from .dense import Dense
+
+__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
+
+
+def is_data(arg):
+    return isinstance(arg, Data)
+
+
+def is_nparray(arg):
+    return isinstance(arg, np.ndarray)
+
+
+def true(arg):
+    return True
+
+
+def data_copy(arg, shape, copy=True):
+    if shape is not None and shape != arg.shape:
+        raise ValueError("".join([
+            "shapes do not match: ", str(shape), " and ", str(arg.shape),
+        ]))
+    return arg.copy() if copy else arg
diff --git a/qutip/core/data/add.pxd b/qutip/core/data/add.pxd
index edb30f14ae..e05941870b 100644
--- a/qutip/core/data/add.pxd
+++ b/qutip/core/data/add.pxd
@@ -1,12 +1,12 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-
-cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
-cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
-cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
-cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
-
-cpdef CSR sub_csr(CSR left, CSR right)
-cpdef Dense sub_dense(Dense left, Dense right)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+
+cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
+cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
+cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
+cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
+
+cpdef CSR sub_csr(CSR left, CSR right)
+cpdef Dense sub_dense(Dense left, Dense right)
diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index 4a24a193a4..0b65d2e32a 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -1,276 +1,276 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-import numpy as np
-cimport numpy as cnp
-from scipy.linalg cimport cython_blas as blas
-from qutip.settings import settings
-
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.csr cimport (
-    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
-)
-from qutip.core.data cimport csr, dense
-
-cnp.import_array()
-
-cdef extern from *:
-    void *PyDataMem_NEW(size_t size)
-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-    void PyDataMem_FREE(void *ptr)
-
-
-__all__ = [
-    'add', 'add_csr', 'add_dense', 'iadd_dense',
-    'sub', 'sub_csr', 'sub_dense',
-]
-
-
-cdef int _ONE=1
-
-
-cdef void _check_shape(Data left, Data right) nogil except *:
-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-
-
-cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
-    """
-    Perform the operation
-        c := a + b
-    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
-    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
-
-    Return the true value of nnz(c).
-    """
-    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
-    cdef idxint ncols = a.shape[1]
-    c.row_index[0] = nnz
-    ptr_a_max = ptr_b_max = 0
-    for row in range(a.shape[0]):
-        ptr_a = ptr_a_max
-        ptr_a_max = a.row_index[row + 1]
-        ptr_b = ptr_b_max
-        ptr_b_max = b.row_index[row + 1]
-        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-        # We use this method of going through the row to give the Accumulator
-        # the best chance of receiving the scatters in a sorted order.  We
-        # could also safely iterate through a completely then b, which would be
-        # more cache efficient, but would quite often require a sort within the
-        # gather, making the algorithimic complexity worse.
-        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
-            if col_a < col_b:
-                acc_scatter(acc, a.data[ptr_a], col_a)
-                ptr_a += 1
-                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-            else:
-                acc_scatter(acc, b.data[ptr_b], col_b)
-                ptr_b += 1
-                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-            # There's no need to test col_a == col_b because the Accumulator
-            # already tests that in all scatters anyway.
-        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
-        acc_reset(acc)
-        c.row_index[row + 1] = nnz
-    return nnz
-
-
-cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
-                           double complex scale, double tol) nogil:
-    """
-    Perform the operation
-        c := a + scale*b
-    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
-    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
-
-    Return the true value of nnz(c).
-    """
-    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
-    cdef idxint ncols = a.shape[1]
-    c.row_index[0] = nnz
-    ptr_a_max = ptr_b_max = 0
-    for row in range(a.shape[0]):
-        ptr_a = ptr_a_max
-        ptr_a_max = a.row_index[row + 1]
-        ptr_b = ptr_b_max
-        ptr_b_max = b.row_index[row + 1]
-        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
-            if col_a < col_b:
-                acc_scatter(acc, a.data[ptr_a], col_a)
-                ptr_a += 1
-                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-            else:
-                acc_scatter(acc, scale * b.data[ptr_b], col_b)
-                ptr_b += 1
-                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
-        acc_reset(acc)
-        c.row_index[row + 1] = nnz
-    return nnz
-
-
-cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
-    """
-    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
-    `right` is multiplied by `scale`, so the full operation is
-        ``out := left + scale*right``
-    The two matrices must be of exactly the same shape.
-
-    Parameters
-    ----------
-    left : CSR
-        Matrix to be added.
-    right : CSR
-        Matrix to be added.  If `scale` is given, this matrix will be
-        multiplied by `scale` before addition.
-    scale : optional double complex (1)
-        The scalar value to multiply `right` by before addition.
-
-    Returns
-    -------
-    out : CSR
-        The result `left + scale*right`.
-    """
-    _check_shape(left, right)
-    cdef idxint left_nnz = csr.nnz(left)
-    cdef idxint right_nnz = csr.nnz(right)
-    cdef idxint worst_nnz = left_nnz + right_nnz
-    cdef idxint i
-    cdef CSR out
-    cdef Accumulator acc
-    cdef double tol = 0
-    if settings.core['auto_tidyup']:
-        tol = settings.core['auto_tidyup_atol']
-    # Fast paths for zero matrices.
-    if right_nnz == 0 or scale == 0:
-        return left.copy()
-    if left_nnz == 0:
-        out = right.copy()
-        # Fast path if the multiplication is a no-op.
-        if scale != 1:
-            for i in range(right_nnz):
-                out.data[i] *= scale
-        return out
-    # Main path.
-    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
-    acc = acc_alloc(left.shape[1])
-    if scale == 1:
-        _add_csr(&acc, left, right, out, tol)
-    else:
-        _add_csr_scale(&acc, left, right, out, scale, tol)
-    acc_free(&acc)
-    return out
-
-
-cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
-    cdef int size = left.shape[0] * left.shape[1]
-    with nogil:
-        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
-
-
-cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
-    cdef Dense out = left.copy()
-    cdef int size = left.shape[0] * left.shape[1]
-    with nogil:
-        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
-    return out
-
-
-cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
-    _check_shape(left, right)
-    if not (left.fortran ^ right.fortran):
-        return _add_dense_eq_order(left, right, scale)
-    cdef Dense out = left.copy()
-    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
-    # We always iterate through `left` and `out` in memory-layout order.
-    cdef int dim1, dim2
-    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
-    with nogil:
-        for idx in range(dim2):
-            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
-    return out
-
-
-cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
-    _check_shape(left, right)
-    cdef int size = left.shape[0] * left.shape[1]
-    cdef int dim1, dim2
-    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
-    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
-    with nogil:
-        if not (left.fortran ^ right.fortran):
-            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
-        else:
-            for idx in range(dim2):
-                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
-                           left.data + idx*dim1, &_ONE)
-    return left
-
-
-cpdef CSR sub_csr(CSR left, CSR right):
-    return add_csr(left, right, -1)
-
-
-cpdef Dense sub_dense(Dense left, Dense right):
-    return add_dense(left, right, -1)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-add = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='add',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-add.__doc__ =\
-    """
-    Perform the operation
-        left + scale*right
-    where `left` and `right` are matrices, and `scale` is an optional complex
-    scalar.
-    """
-add.add_specialisations([
-    (Dense, Dense, Dense, add_dense),
-    (CSR, CSR, CSR, add_csr),
-], _defer=True)
-
-sub = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='sub',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-sub.__doc__ =\
-    """
-    Perform the operation
-        left - right
-    where `left` and `right` are matrices.
-    """
-sub.add_specialisations([
-    (Dense, Dense, Dense, sub_dense),
-    (CSR, CSR, CSR, sub_csr),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+import numpy as np
+cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
+from qutip.settings import settings
+
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport (
+    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
+)
+from qutip.core.data cimport csr, dense
+
+cnp.import_array()
+
+cdef extern from *:
+    void *PyDataMem_NEW(size_t size)
+    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
+    void PyDataMem_FREE(void *ptr)
+
+
+__all__ = [
+    'add', 'add_csr', 'add_dense', 'iadd_dense',
+    'sub', 'sub_csr', 'sub_dense',
+]
+
+
+cdef int _ONE=1
+
+
+cdef void _check_shape(Data left, Data right) nogil except *:
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+
+
+cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
+    """
+    Perform the operation
+        c := a + b
+    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
+    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
+
+    Return the true value of nnz(c).
+    """
+    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
+    cdef idxint ncols = a.shape[1]
+    c.row_index[0] = nnz
+    ptr_a_max = ptr_b_max = 0
+    for row in range(a.shape[0]):
+        ptr_a = ptr_a_max
+        ptr_a_max = a.row_index[row + 1]
+        ptr_b = ptr_b_max
+        ptr_b_max = b.row_index[row + 1]
+        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+        # We use this method of going through the row to give the Accumulator
+        # the best chance of receiving the scatters in a sorted order.  We
+        # could also safely iterate through a completely then b, which would be
+        # more cache efficient, but would quite often require a sort within the
+        # gather, making the algorithimic complexity worse.
+        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
+            if col_a < col_b:
+                acc_scatter(acc, a.data[ptr_a], col_a)
+                ptr_a += 1
+                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+            else:
+                acc_scatter(acc, b.data[ptr_b], col_b)
+                ptr_b += 1
+                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+            # There's no need to test col_a == col_b because the Accumulator
+            # already tests that in all scatters anyway.
+        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
+        acc_reset(acc)
+        c.row_index[row + 1] = nnz
+    return nnz
+
+
+cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
+                           double complex scale, double tol) nogil:
+    """
+    Perform the operation
+        c := a + scale*b
+    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
+    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
+
+    Return the true value of nnz(c).
+    """
+    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
+    cdef idxint ncols = a.shape[1]
+    c.row_index[0] = nnz
+    ptr_a_max = ptr_b_max = 0
+    for row in range(a.shape[0]):
+        ptr_a = ptr_a_max
+        ptr_a_max = a.row_index[row + 1]
+        ptr_b = ptr_b_max
+        ptr_b_max = b.row_index[row + 1]
+        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
+            if col_a < col_b:
+                acc_scatter(acc, a.data[ptr_a], col_a)
+                ptr_a += 1
+                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+            else:
+                acc_scatter(acc, scale * b.data[ptr_b], col_b)
+                ptr_b += 1
+                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
+        acc_reset(acc)
+        c.row_index[row + 1] = nnz
+    return nnz
+
+
+cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
+    """
+    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
+    `right` is multiplied by `scale`, so the full operation is
+        ``out := left + scale*right``
+    The two matrices must be of exactly the same shape.
+
+    Parameters
+    ----------
+    left : CSR
+        Matrix to be added.
+    right : CSR
+        Matrix to be added.  If `scale` is given, this matrix will be
+        multiplied by `scale` before addition.
+    scale : optional double complex (1)
+        The scalar value to multiply `right` by before addition.
+
+    Returns
+    -------
+    out : CSR
+        The result `left + scale*right`.
+    """
+    _check_shape(left, right)
+    cdef idxint left_nnz = csr.nnz(left)
+    cdef idxint right_nnz = csr.nnz(right)
+    cdef idxint worst_nnz = left_nnz + right_nnz
+    cdef idxint i
+    cdef CSR out
+    cdef Accumulator acc
+    cdef double tol = 0
+    if settings.core['auto_tidyup']:
+        tol = settings.core['auto_tidyup_atol']
+    # Fast paths for zero matrices.
+    if right_nnz == 0 or scale == 0:
+        return left.copy()
+    if left_nnz == 0:
+        out = right.copy()
+        # Fast path if the multiplication is a no-op.
+        if scale != 1:
+            for i in range(right_nnz):
+                out.data[i] *= scale
+        return out
+    # Main path.
+    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
+    acc = acc_alloc(left.shape[1])
+    if scale == 1:
+        _add_csr(&acc, left, right, out, tol)
+    else:
+        _add_csr_scale(&acc, left, right, out, scale, tol)
+    acc_free(&acc)
+    return out
+
+
+cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
+    cdef int size = left.shape[0] * left.shape[1]
+    with nogil:
+        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
+
+
+cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
+    cdef Dense out = left.copy()
+    cdef int size = left.shape[0] * left.shape[1]
+    with nogil:
+        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
+    return out
+
+
+cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
+    _check_shape(left, right)
+    if not (left.fortran ^ right.fortran):
+        return _add_dense_eq_order(left, right, scale)
+    cdef Dense out = left.copy()
+    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
+    # We always iterate through `left` and `out` in memory-layout order.
+    cdef int dim1, dim2
+    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
+    with nogil:
+        for idx in range(dim2):
+            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
+    return out
+
+
+cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
+    _check_shape(left, right)
+    cdef int size = left.shape[0] * left.shape[1]
+    cdef int dim1, dim2
+    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
+    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
+    with nogil:
+        if not (left.fortran ^ right.fortran):
+            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
+        else:
+            for idx in range(dim2):
+                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
+                           left.data + idx*dim1, &_ONE)
+    return left
+
+
+cpdef CSR sub_csr(CSR left, CSR right):
+    return add_csr(left, right, -1)
+
+
+cpdef Dense sub_dense(Dense left, Dense right):
+    return add_dense(left, right, -1)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+add = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='add',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+add.__doc__ =\
+    """
+    Perform the operation
+        left + scale*right
+    where `left` and `right` are matrices, and `scale` is an optional complex
+    scalar.
+    """
+add.add_specialisations([
+    (Dense, Dense, Dense, add_dense),
+    (CSR, CSR, CSR, add_csr),
+], _defer=True)
+
+sub = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='sub',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+sub.__doc__ =\
+    """
+    Perform the operation
+        left - right
+    where `left` and `right` are matrices.
+    """
+sub.add_specialisations([
+    (Dense, Dense, Dense, sub_dense),
+    (CSR, CSR, CSR, sub_csr),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/adjoint.pxd b/qutip/core/data/adjoint.pxd
index 793aac6409..ced7be525e 100644
--- a/qutip/core/data/adjoint.pxd
+++ b/qutip/core/data/adjoint.pxd
@@ -1,12 +1,12 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-
-cpdef CSR adjoint_csr(CSR matrix)
-cpdef CSR transpose_csr(CSR matrix)
-cpdef CSR conj_csr(CSR matrix)
-
-cpdef Dense adjoint_dense(Dense matrix)
-cpdef Dense transpose_dense(Dense matrix)
-cpdef Dense conj_dense(Dense matrix)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+
+cpdef CSR adjoint_csr(CSR matrix)
+cpdef CSR transpose_csr(CSR matrix)
+cpdef CSR conj_csr(CSR matrix)
+
+cpdef Dense adjoint_dense(Dense matrix)
+cpdef Dense transpose_dense(Dense matrix)
+cpdef Dense conj_dense(Dense matrix)
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index ebff9e4d6c..4f1543cdaa 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -1,160 +1,160 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset
-
-cimport cython
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data cimport csr, dense
-
-# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex _conj "conj"(double complex x)
-
-__all__ = [
-    'adjoint', 'adjoint_csr', 'adjoint_dense',
-    'conj', 'conj_csr', 'conj_dense',
-    'transpose', 'transpose_csr', 'transpose_dense',
-]
-
-
-cpdef CSR transpose_csr(CSR matrix):
-    """Transpose the CSR matrix, and return a new object."""
-    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
-    cdef idxint row, col, ptr, ptr_out
-    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
-    with nogil:
-        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr] + 1
-                out.row_index[col] += 1
-        for row in range(rows_out):
-            out.row_index[row + 1] += out.row_index[row]
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr]
-                ptr_out = out.row_index[col]
-                out.data[ptr_out] = matrix.data[ptr]
-                out.col_index[ptr_out] = row
-                out.row_index[col] = ptr_out + 1
-        for row in range(rows_out, 0, -1):
-            out.row_index[row] = out.row_index[row - 1]
-        out.row_index[0] = 0
-    return out
-
-
-cpdef CSR adjoint_csr(CSR matrix):
-    """Conjugate-transpose the CSR matrix, and return a new object."""
-    cdef idxint nnz_ = csr.nnz(matrix)
-    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
-    cdef idxint row, col, ptr, ptr_out
-    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
-    with nogil:
-        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr] + 1
-                out.row_index[col] += 1
-        for row in range(rows_out):
-            out.row_index[row + 1] += out.row_index[row]
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr]
-                ptr_out = out.row_index[col]
-                out.data[ptr_out] = _conj(matrix.data[ptr])
-                out.col_index[ptr_out] = row
-                out.row_index[col] = ptr_out + 1
-        for row in range(rows_out, 0, -1):
-            out.row_index[row] = out.row_index[row - 1]
-        out.row_index[0] = 0
-    return out
-
-
-cpdef CSR conj_csr(CSR matrix):
-    """Conjugate the CSR matrix, and return a new object."""
-    cdef CSR out = csr.copy_structure(matrix)
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            out.data[ptr] = _conj(matrix.data[ptr])
-    return out
-
-
-cpdef Dense adjoint_dense(Dense matrix):
-    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
-    out.shape = (out.shape[1], out.shape[0])
-    with nogil:
-        for ptr in range(matrix.shape[0] * matrix.shape[1]):
-            out.data[ptr] = _conj(matrix.data[ptr])
-    return out
-
-
-cpdef Dense transpose_dense(Dense matrix):
-    cdef Dense out = matrix.copy()
-    out.shape = (out.shape[1], out.shape[0])
-    out.fortran = not out.fortran
-    return out
-
-
-cpdef Dense conj_dense(Dense matrix):
-    cdef Dense out = dense.empty_like(matrix)
-    cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0] * matrix.shape[1]):
-            out.data[ptr] = _conj(matrix.data[ptr])
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-adjoint = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='adjoint',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
-adjoint.add_specialisations([
-    (Dense, Dense, adjoint_dense),
-    (CSR, CSR, adjoint_csr),
-], _defer=True)
-
-transpose = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='transpose',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-transpose.__doc__ = """Transpose of a matrix."""
-transpose.add_specialisations([
-    (Dense, Dense, transpose_dense),
-    (CSR, CSR, transpose_csr),
-], _defer=True)
-
-conj = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='conj',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-conj.__doc__ = """Element-wise conjugation of a matrix."""
-conj.add_specialisations([
-    (Dense, Dense, conj_dense),
-    (CSR, CSR, conj_csr),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset
+
+cimport cython
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data cimport csr, dense
+
+# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex _conj "conj"(double complex x)
+
+__all__ = [
+    'adjoint', 'adjoint_csr', 'adjoint_dense',
+    'conj', 'conj_csr', 'conj_dense',
+    'transpose', 'transpose_csr', 'transpose_dense',
+]
+
+
+cpdef CSR transpose_csr(CSR matrix):
+    """Transpose the CSR matrix, and return a new object."""
+    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
+    cdef idxint row, col, ptr, ptr_out
+    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
+    with nogil:
+        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr] + 1
+                out.row_index[col] += 1
+        for row in range(rows_out):
+            out.row_index[row + 1] += out.row_index[row]
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr]
+                ptr_out = out.row_index[col]
+                out.data[ptr_out] = matrix.data[ptr]
+                out.col_index[ptr_out] = row
+                out.row_index[col] = ptr_out + 1
+        for row in range(rows_out, 0, -1):
+            out.row_index[row] = out.row_index[row - 1]
+        out.row_index[0] = 0
+    return out
+
+
+cpdef CSR adjoint_csr(CSR matrix):
+    """Conjugate-transpose the CSR matrix, and return a new object."""
+    cdef idxint nnz_ = csr.nnz(matrix)
+    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
+    cdef idxint row, col, ptr, ptr_out
+    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
+    with nogil:
+        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr] + 1
+                out.row_index[col] += 1
+        for row in range(rows_out):
+            out.row_index[row + 1] += out.row_index[row]
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr]
+                ptr_out = out.row_index[col]
+                out.data[ptr_out] = _conj(matrix.data[ptr])
+                out.col_index[ptr_out] = row
+                out.row_index[col] = ptr_out + 1
+        for row in range(rows_out, 0, -1):
+            out.row_index[row] = out.row_index[row - 1]
+        out.row_index[0] = 0
+    return out
+
+
+cpdef CSR conj_csr(CSR matrix):
+    """Conjugate the CSR matrix, and return a new object."""
+    cdef CSR out = csr.copy_structure(matrix)
+    cdef idxint ptr
+    with nogil:
+        for ptr in range(csr.nnz(matrix)):
+            out.data[ptr] = _conj(matrix.data[ptr])
+    return out
+
+
+cpdef Dense adjoint_dense(Dense matrix):
+    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
+    out.shape = (out.shape[1], out.shape[0])
+    with nogil:
+        for ptr in range(matrix.shape[0] * matrix.shape[1]):
+            out.data[ptr] = _conj(matrix.data[ptr])
+    return out
+
+
+cpdef Dense transpose_dense(Dense matrix):
+    cdef Dense out = matrix.copy()
+    out.shape = (out.shape[1], out.shape[0])
+    out.fortran = not out.fortran
+    return out
+
+
+cpdef Dense conj_dense(Dense matrix):
+    cdef Dense out = dense.empty_like(matrix)
+    cdef size_t ptr
+    with nogil:
+        for ptr in range(matrix.shape[0] * matrix.shape[1]):
+            out.data[ptr] = _conj(matrix.data[ptr])
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+adjoint = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='adjoint',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
+adjoint.add_specialisations([
+    (Dense, Dense, adjoint_dense),
+    (CSR, CSR, adjoint_csr),
+], _defer=True)
+
+transpose = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='transpose',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+transpose.__doc__ = """Transpose of a matrix."""
+transpose.add_specialisations([
+    (Dense, Dense, transpose_dense),
+    (CSR, CSR, transpose_csr),
+], _defer=True)
+
+conj = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='conj',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+conj.__doc__ = """Element-wise conjugation of a matrix."""
+conj.add_specialisations([
+    (Dense, Dense, conj_dense),
+    (CSR, CSR, conj_csr),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/base.pxd b/qutip/core/data/base.pxd
index f34a80ff24..4aa8d08372 100644
--- a/qutip/core/data/base.pxd
+++ b/qutip/core/data/base.pxd
@@ -1,17 +1,17 @@
-#cython: language_level=3
-
-cdef extern from "src/intdtype.h":
-    # cython is smart enough to understand this int can be 32 or 64 bits.
-    ctypedef int idxint
-    cdef int _idxint_size
-
-cdef int idxint_DTYPE
-
-cdef class Data:
-    cdef readonly (idxint, idxint) shape
-    cpdef object to_array(self)
-    cpdef double complex trace(self)
-    cpdef Data adjoint(self)
-    cpdef Data conj(self)
-    cpdef Data transpose(self)
-    cpdef Data copy(self)
+#cython: language_level=3
+
+cdef extern from "src/intdtype.h":
+    # cython is smart enough to understand this int can be 32 or 64 bits.
+    ctypedef int idxint
+    cdef int _idxint_size
+
+cdef int idxint_DTYPE
+
+cdef class Data:
+    cdef readonly (idxint, idxint) shape
+    cpdef object to_array(self)
+    cpdef double complex trace(self)
+    cpdef Data adjoint(self)
+    cpdef Data conj(self)
+    cpdef Data transpose(self)
+    cpdef Data copy(self)
diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
index a463bf3834..a7c599399d 100644
--- a/qutip/core/data/base.pyx
+++ b/qutip/core/data/base.pyx
@@ -1,89 +1,89 @@
-#cython: language_level=3
-
-import numpy as np
-cimport numpy as cnp
-import qutip.core.data as _data
-from qutip.settings import settings
-
-__all__ = [
-    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
-]
-
-if _idxint_size == 32:
-    idxint_dtype = np.int32
-    idxint_DTYPE = cnp.NPY_INT32
-else:
-    idxint_dtype = np.int64
-    idxint_DTYPE = cnp.NPY_INT64
-
-idxint_size = _idxint_size
-
-# As this is an abstract base class with C entry points, we have to explicitly
-# stub out methods since we can't mark them as abstract.
-cdef class Data:
-    def __init__(self, shape):
-        self.shape = shape
-
-    cpdef object to_array(self):
-        raise NotImplementedError
-
-    cpdef double complex trace(self):
-        return NotImplementedError
-
-    cpdef Data adjoint(self):
-        raise NotImplementedError
-
-    cpdef Data conj(self):
-        raise NotImplementedError
-
-    cpdef Data transpose(self):
-        raise NotImplementedError
-
-    cpdef Data copy(self):
-        raise NotImplementedError
-
-    def __add__(left, right):
-        if isinstance(left, Data) and isinstance(right, Data):
-            return _data.add(left, right)
-        return NotImplemented
-
-    def __sub__(left, right):
-        if isinstance(left, Data) and isinstance(right, Data):
-            return _data.sub(left, right)
-        return NotImplemented
-
-    def __matmul__(left, right):
-        if isinstance(left, Data) and isinstance(right, Data):
-            return _data.matmul(left, right)
-        return NotImplemented
-
-    def __mul__(left, right):
-        data, number = (left, right) if isinstance(left, Data) else (right, left)
-        try:
-            return _data.mul(data, number)
-        except TypeError:
-            return NotImplemented
-
-    def __truediv__(left, right):
-        data, number = (left, right) if isinstance(left, Data) else (right, left)
-        try:
-            return _data.mul(data, 1/number)
-        except TypeError:
-            return NotImplemented
-
-    def __neg__(self):
-        return _data.neg(self)
-
-    def __eq__(left, right):
-        if not (isinstance(left, Data) and isinstance(right, Data)):
-            return NotImplemented
-        if (
-            left.shape[0] == right.shape[0]
-            and left.shape[1] == right.shape[1]
-        ):
-            return _data.iszero(_data.sub(left, right), settings.core['atol'])
-        return False
-
-
-class EfficiencyWarning(Warning):
-    pass
+#cython: language_level=3
+
+import numpy as np
+cimport numpy as cnp
+import qutip.core.data as _data
+from qutip.settings import settings
+
+__all__ = [
+    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
+]
+
+if _idxint_size == 32:
+    idxint_dtype = np.int32
+    idxint_DTYPE = cnp.NPY_INT32
+else:
+    idxint_dtype = np.int64
+    idxint_DTYPE = cnp.NPY_INT64
+
+idxint_size = _idxint_size
+
+# As this is an abstract base class with C entry points, we have to explicitly
+# stub out methods since we can't mark them as abstract.
+cdef class Data:
+    def __init__(self, shape):
+        self.shape = shape
+
+    cpdef object to_array(self):
+        raise NotImplementedError
+
+    cpdef double complex trace(self):
+        return NotImplementedError
+
+    cpdef Data adjoint(self):
+        raise NotImplementedError
+
+    cpdef Data conj(self):
+        raise NotImplementedError
+
+    cpdef Data transpose(self):
+        raise NotImplementedError
+
+    cpdef Data copy(self):
+        raise NotImplementedError
+
+    def __add__(left, right):
+        if isinstance(left, Data) and isinstance(right, Data):
+            return _data.add(left, right)
+        return NotImplemented
+
+    def __sub__(left, right):
+        if isinstance(left, Data) and isinstance(right, Data):
+            return _data.sub(left, right)
+        return NotImplemented
+
+    def __matmul__(left, right):
+        if isinstance(left, Data) and isinstance(right, Data):
+            return _data.matmul(left, right)
+        return NotImplemented
+
+    def __mul__(left, right):
+        data, number = (left, right) if isinstance(left, Data) else (right, left)
+        try:
+            return _data.mul(data, number)
+        except TypeError:
+            return NotImplemented
+
+    def __truediv__(left, right):
+        data, number = (left, right) if isinstance(left, Data) else (right, left)
+        try:
+            return _data.mul(data, 1/number)
+        except TypeError:
+            return NotImplemented
+
+    def __neg__(self):
+        return _data.neg(self)
+
+    def __eq__(left, right):
+        if not (isinstance(left, Data) and isinstance(right, Data)):
+            return NotImplemented
+        if (
+            left.shape[0] == right.shape[0]
+            and left.shape[1] == right.shape[1]
+        ):
+            return _data.iszero(_data.sub(left, right), settings.core['atol'])
+        return False
+
+
+class EfficiencyWarning(Warning):
+    pass
diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index a60341a364..6f850d22c9 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -1,73 +1,73 @@
-# This module exists to supply a couple of very standard constant matrices
-# which are used in the data layer, and within `Qobj` itself.  Other matrices
-# (e.g. `create`) should not be here, but should be defined within the
-# higher-level components of QuTiP instead.
-
-from . import csr, dense
-from .csr import CSR
-from .dense import Dense
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-__all__ = ['zeros', 'identity']
-
-zeros = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='zeros',
-    module=__name__,
-    inputs=(),
-    out=True,
-)
-zeros.__doc__ =\
-    """
-    Create matrix representation of 0 with the given dimensions.
-
-    Depending on the selected output type, this may or may not actually
-    contained explicit values; sparse matrices will typically contain nothing
-    (which is their representation of 0), and dense matrices will still be
-    filled.
-
-    Parameters
-    ----------
-    rows, cols : int
-        The number of rows and columns in the output matrix.
-    """
-zeros.add_specialisations([
-    (CSR, csr.zeros),
-    (Dense, dense.zeros),
-], _defer=True)
-
-identity = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('dimension',
-                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='identity',
-    module=__name__,
-    inputs=(),
-    out=True,
-)
-identity.__doc__ =\
-    """
-    Create a square identity matrix of the given dimension.  Optionally, the
-    `scale` can be given, where all the diagonal elements will be that instead
-    of 1.
-
-    Parameters
-    ----------
-    dimension : int
-        The dimension of the square output identity matrix.
-    scale : complex, optional
-        The element which should be placed on the diagonal.
-    """
-identity.add_specialisations([
-    (CSR, csr.identity),
-    (Dense, dense.identity),
-], _defer=True)
-
-del _Dispatcher, _inspect
+# This module exists to supply a couple of very standard constant matrices
+# which are used in the data layer, and within `Qobj` itself.  Other matrices
+# (e.g. `create`) should not be here, but should be defined within the
+# higher-level components of QuTiP instead.
+
+from . import csr, dense
+from .csr import CSR
+from .dense import Dense
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+__all__ = ['zeros', 'identity']
+
+zeros = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='zeros',
+    module=__name__,
+    inputs=(),
+    out=True,
+)
+zeros.__doc__ =\
+    """
+    Create matrix representation of 0 with the given dimensions.
+
+    Depending on the selected output type, this may or may not actually
+    contained explicit values; sparse matrices will typically contain nothing
+    (which is their representation of 0), and dense matrices will still be
+    filled.
+
+    Parameters
+    ----------
+    rows, cols : int
+        The number of rows and columns in the output matrix.
+    """
+zeros.add_specialisations([
+    (CSR, csr.zeros),
+    (Dense, dense.zeros),
+], _defer=True)
+
+identity = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('dimension',
+                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='identity',
+    module=__name__,
+    inputs=(),
+    out=True,
+)
+identity.__doc__ =\
+    """
+    Create a square identity matrix of the given dimension.  Optionally, the
+    `scale` can be given, where all the diagonal elements will be that instead
+    of 1.
+
+    Parameters
+    ----------
+    dimension : int
+        The dimension of the square output identity matrix.
+    scale : complex, optional
+        The element which should be placed on the diagonal.
+    """
+identity.add_specialisations([
+    (CSR, csr.identity),
+    (Dense, dense.identity),
+], _defer=True)
+
+del _Dispatcher, _inspect
diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index c2feed3dd1..6826ac818a 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -1,436 +1,436 @@
-#cython: language_level=3
-
-"""
-The conversion machinery between different data-layer types, and creation
-routines from arbitrary data.  The classes `_to` and `_create` are not intended
-to be exported names, but are the backing machinery of the functions `data.to`
-and `data.create`, which are built up as the last objects in the `__init__.py`
-initialisation of the `data` module.
-"""
-
-# This module is compiled by Cython because it's the core of the entire
-# dispatch table, and having it compiled to a C extension saves about 1µs per
-# call.  This is not much at all, and there's very little which benefits from
-# Cython compiliation, but such core functionality is called millions of times
-# even in a simple interactive QuTiP session, and it all adds up.
-
-import numbers
-
-import numpy as np
-from scipy.sparse import dok_matrix, csgraph
-cimport cython
-
-__all__ = ['to', 'create']
-
-
-def _raise_if_unconnected(dtype_list, weights):
-    unconnected = {}
-    for i, type_ in enumerate(dtype_list):
-        missing = [dtype_list[j].__name__
-                   for j, weight in enumerate(weights[:, i])
-                   if weight == np.inf]
-        if missing:
-            unconnected[type_.__name__] = missing
-    if unconnected:
-        message = "Conversion graph not connected.  Cannot reach:\n * "
-        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
-                                for to, froms in unconnected.items())
-        raise NotImplementedError(message)
-
-
-cdef class _converter:
-    """Callable which converts objects of type `x.from_` to type `x.to`."""
-
-    cdef list functions
-    cdef Py_ssize_t n_functions
-    cdef readonly type to
-    cdef readonly type from_
-
-    def __init__(self, functions, to_type, from_type):
-        self.functions = list(functions)
-        self.n_functions = len(self.functions)
-        self.to = to_type
-        self.from_ = from_type
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def __call__(self, arg):
-        if not isinstance(arg, self.from_):
-            raise TypeError(str(arg) + " is not of type " + str(self.from_))
-        cdef Py_ssize_t i
-        for i in range(self.n_functions):
-            arg = self.functions[i](arg)
-        return arg
-
-    def __repr__(self):
-        return ("<converter to "
-                + self.to.__name__
-                + " from " + self.from_.__name__
-                + ">")
-
-
-cdef class _partial_converter:
-    """Convert from any known data-layer type into the type `x.to`."""
-
-    cdef dict converters
-    cdef readonly type to
-
-    def __init__(self, converters, to_type):
-        self.converters = dict(converters)
-        self.to = to_type
-
-    def __call__(self, arg):
-        try:
-            return self.converters[type(arg)](arg)
-        except KeyError:
-            raise TypeError("unknown type of input: " + str(arg)) from None
-
-    def __repr__(self):
-        return "<converter to " + self.to.__name__ + ">"
-
-
-# While `_to` and `_create` are defined as objects here, they are actually
-# exported by `data.__init__.py` as singleton function objects of their
-# respective types (without the leading underscore).
-
-cdef class _to:
-    """
-    Convert data into a different type.  This object is the knowledge source
-    for every allowable data-layer type in QuTiP, and provides the conversions
-    between all of them.
-
-    The base use is to call this object as a function with signature
-        (type, data) -> converted_data
-    where `type` is a type object (such as `data.CSR`, or that obtained by
-    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
-    want to create a data-layer type from non-data-layer data, use `create`
-    instead.
-
-    You can get individual converters by using the key-lookup syntax.  For
-    example, the item
-        to[CSR, Dense]
-    is a callable which accepts arguments of type `Dense` and returns the
-    equivalent item of type `CSR`.  You can also get a generic converter to a
-    particular data type if only one type is specified, so
-        to[Dense]
-    is a callable which accepts all known (at the time of the lookup)
-    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
-    section below for more detail.
-
-    Internally, the conversion process may go through several steps if new
-    data-layer types have been defined with few conversions specified between
-    them and the pre-existing converters.  The first-class QuTiP data types
-    `Dense` and `CSR` will typically have the best connectivity.
-
-
-    Adding new types
-    ----------------
-    You can add new data-layer types by calling the `add_conversions` method of
-    this object, and then rebuilding all of the mathematical dispatchers.  See
-    the docstring of that method for more information.
-
-
-    Efficiency notes
-    ----------------
-    From an efficiency perspective, there is very little benefit to using the
-    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
-    `to[to_type, type(data)]`, so storing the object elides the creation of a
-    single tuple and a dict lookup, but the cost of this is generally less than
-    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
-    efficient than the general call at all, but can be used in cases where a
-    single callable is required and is more efficient than `functools.partial`.
-    """
-
-    cdef readonly set dtypes
-    cdef readonly list dispatchers
-    cdef dict _direct_convert
-    cdef dict _convert
-    cdef readonly dict weight
-    cdef readonly dict _str2type
-
-    def __init__(self):
-        self._direct_convert = {}
-        self._convert = {}
-        self.dtypes = set()
-        self.weight = {}
-        self.dispatchers = []
-        self._str2type = {}
-
-    def add_conversions(self, converters):
-        """
-        Add conversion functions between different data types.  This is an
-        advanced function, and is only intended for the QuTiP user who wants to
-        add a new underlying data type to QuTiP.
-
-        Any new data type must have at least one converter function given to
-        produce the new data type from an existing data type, and at least one
-        which produces an existing data type from the new one.  You need not
-        specify any more than this, although for efficiency reasons, you may
-        want to specify direct conversions for all types you expect the new
-        type to interact with frequently.
-
-        Parameters
-        ----------
-        converters : iterable of (to_type, from_type, converter, [weight])
-            An iterable of 3- or 4-tuples describing all the new conversions.
-            Each element can individually be a 3- or 4-tuple; they do not need
-            to be all one or the other.
-
-            Elements
-            ........
-            to_type : type
-                The data-layer type that is output by the converter.
-
-            from_type : type
-                The data-layer type to be input to the converter.
-
-            converter : callable (Data -> Data)
-                The converter function.  This should take a single argument
-                (the input data-layer function) and output a data-layer object
-                of `to_type`.  The converter may assume without error checking
-                that its input will always be of `to_type`.  It is safe to
-                specify the same conversion function for multiple inputs so
-                long as the function handles them all safely, but it must
-                always return a single output type.
-
-            weight : positive real, optional (1)
-                The weight associated with this conversion.  This must be > 0,
-                and defaults to `1` if not supplied (which is fixed to be the
-                cost of conversion to `Dense` from `CSR`).  It is generally
-                safe just to leave this blank; it is always at best an
-                approximation.  The currently defined weights are accessible in
-                the `weights` attribute of this object.
-        """
-        for arg in converters:
-            if len(arg) == 3:
-                to_type, from_type, converter = arg
-                weight = 1
-            elif len(arg) == 4:
-                to_type, from_type, converter, weight = arg
-            else:
-                raise TypeError("unknown converter specification: " + str(arg))
-            if not isinstance(to_type, type):
-                raise TypeError(repr(to_type) + " is not a type object")
-            if not isinstance(from_type, type):
-                raise TypeError(repr(from_type) + " is not a type object")
-            if not isinstance(weight, numbers.Real) or weight <= 0:
-                raise TypeError("weight " + repr(weight) + " is not valid")
-            self.dtypes.add(from_type)
-            self.dtypes.add(to_type)
-            self._direct_convert[(to_type, from_type)] = (converter, weight)
-        # Two-way mapping to convert between the type of a dtype and an integer
-        # enumeration value for it.
-        order, index = [], {}
-        for i, dtype in enumerate(self.dtypes):
-            order.append(dtype)
-            index[dtype] = i
-        # Treat the conversion problem as a shortest-path graph problem.  We
-        # build up the graph description as a matrix, then solve the
-        # all-pairs-shortest-path problem.  We forbid negative weights and
-        # there are unlikely to be many data types, so the choice of algorithm
-        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
-        graph = dok_matrix((len(order), len(order)))
-        for (to_type, from_type), (_, weight) in self._direct_convert.items():
-            graph[index[from_type], index[to_type]] = weight
-        weights, predecessors =\
-            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
-        _raise_if_unconnected(order, weights)
-        # Build the whole shortest path conversion lookup.  We directly store
-        # all complete shortest paths, even though this is not the most memory
-        # efficient, because we expect that there will generally be a small
-        # number of available data types, and we care more about minimising the
-        # number of lookups required.
-        self.weight = {}
-        self._convert = {}
-        for i, from_t in enumerate(order):
-            for j, to_t in enumerate(order):
-                convert = []
-                weight = 0
-                cur_t = to_t
-                pred_i = predecessors[i, j]
-                while pred_i >= 0:
-                    pred_t = order[pred_i]
-                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
-                    convert.append(_convert)
-                    weight += _weight
-                    cur_t = pred_t
-                    pred_i = predecessors[i, pred_i]
-                self.weight[(to_t, from_t)] = weight
-                self._convert[(to_t, from_t)] =\
-                    _converter(convert[::-1], to_t, from_t)
-        for dispatcher in self.dispatchers:
-            dispatcher.rebuild_lookup()
-
-    def register_aliases(self, aliases, layer_type):
-        """
-        Register a user frendly name for a data-layer type to be recognized by
-        the :method:`parse` method.
-
-        Parameters
-        ----------
-        aliases : str or list of str
-            Name of list of names to be understood to represent the layer_type.
-
-        layer_type : type
-            Data-layer type, must have been registered with
-            :method:`add_conversions` first.
-        """
-        if layer_type not in self.dtypes:
-            raise ValueError(
-                "Type is not a data-layer type: " + repr(layer_type))
-        if isinstance(aliases, str):
-            aliases = [aliases]
-        for alias in aliases:
-            if type(alias) is not str:
-                raise TypeError("The alias must be a str : " + repr(alias))
-            self._str2type[alias] = layer_type
-
-    def parse(self, dtype):
-        """
-        Return a data-layer type object given its name or the type itself.
-
-        Parameters
-        ----------
-        dtype : type, str
-            Either the name of a data-layer type or a type itself.
-
-        Returns
-        -------
-        type
-            A data-layer type.
-
-        Raises
-        ------
-        TypeError
-            If ``dtype`` is neither a string nor a type.
-        ValueError
-            If ``dtype`` is a name, but no data-layer type of that name is
-            registered, or if ``dtype`` is a type, but not a known data-layer
-            type.
-        """
-        if type(dtype) is type:
-            if dtype not in self.dtypes:
-                raise ValueError(
-                    "Type is not a data-layer type: " + repr(dtype))
-            return dtype
-        elif type(dtype) is str:
-            try:
-                return self._str2type[dtype]
-            except KeyError:
-                raise ValueError(
-                    "Type name is not known to the data-layer: " + repr(dtype)
-                    ) from None
-
-        raise TypeError(
-            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def __getitem__(self, arg):
-        if type(arg) is not tuple:
-            arg = (arg,)
-        if not arg or len(arg) > 2:
-            raise KeyError(arg)
-        to_t = self.parse(arg[0])
-        if len(arg) == 1:
-            converters = {
-                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
-            }
-            return _partial_converter(converters, to_t)
-        from_t = self.parse(arg[1])
-        return self._convert[to_t, from_t]
-
-    def __call__(self, to_type, data):
-        to_type = self.parse(to_type)
-        from_type = self.parse(type(data))
-        if to_type == from_type:
-            return data
-        return self._convert[to_type, from_type](data)
-
-
-cdef class _create:
-    cdef readonly list _creators
-
-    def __init__(self):
-        self._creators = []
-
-    def add_creators(self, creators):
-        """
-        Add creation functions to make a data-layer object from an arbitrary
-        Python object.
-
-        Parameters
-        ----------
-        creators : iterable of (condition, creator, [priority])
-            An iterable of 2- or 3-tuples describing the new data layer
-            creation functions.
-            Each element can individually be a 2- or 3-tuple; they do not need
-            to be all one or the other.
-
-            Elements
-            ........
-            condition : callable (object) -> bool
-                Function determining if the given object can be converted to a
-                data-layer type using this creator.
-
-            creator function: callable (object, shape, copy=True) -> Data
-                The creator function. It should take an object and a shape and
-                return a data-layer type instance. The object may be any object
-                for which the condition function returned ``True`` when tested.
-                The ``object`` and ``shape`` parameters are passed positionally,
-                and the ``copy`` parameter is passed by keyword.
-
-            priority : real, optional (0)
-                The priority associated with this creator. Higher priority
-                conditions will be tested first and the first valid creator
-                (i.e. for which ``condition(object) == True``) will handle
-                the creation.
-
-        Notes
-        -----
-        Default creators are added with the following priorities:
-
-        * Objects that are instances of data-layer types are
-          converted using ``.copy`` with priority 100.
-        * Objects that have a direct equivalent such as ``numpy.ndarray``
-          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
-        * Objects for which ``scipy.sparse.issparse`` is ``True``
-          are converted using an internal CSR converter with
-          priority 20.
-        * If no condition are meet, ``numpy.array`` is used to try convert
-          the input to an array (priority -inf).
-        """
-        for condition, creator, *priority in creators:
-            if not callable(condition):
-                raise TypeError(repr(condition) + " is not a callable")
-            if not callable(create):
-                raise TypeError(repr(create) + " is not a callable")
-            if len(priority) >= 2:
-                raise ValueError("Too many values to unpack for a creator, " +
-                                 "expected 2 or 3, got "+ str(2+len(priority)))
-            priority = float(priority[0] if priority else 0)
-            self._creators.append((condition, creator, priority))
-        self._creators.sort(key=lambda creator: creator[2], reverse=True)
-
-    def __call__(self, arg, shape=None, copy=True):
-        """
-        Build a :class:`qutip.data.Data` object from arg.
-
-        Parameters
-        ----------
-        arg : object
-            Object to be converted to `qutip.data.Data`. Anything that can be
-            converted to a numpy array are valid input.
-
-        shape : tuple, optional
-            The shape of the output as (``rows``, ``columns``).
-        """
-        for condition, create, _ in self._creators:
-            if condition(arg):
-                return create(arg, shape, copy=copy)
-        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
-                        "qutip data format")
-
-
-to = _to()
-create = _create()
+#cython: language_level=3
+
+"""
+The conversion machinery between different data-layer types, and creation
+routines from arbitrary data.  The classes `_to` and `_create` are not intended
+to be exported names, but are the backing machinery of the functions `data.to`
+and `data.create`, which are built up as the last objects in the `__init__.py`
+initialisation of the `data` module.
+"""
+
+# This module is compiled by Cython because it's the core of the entire
+# dispatch table, and having it compiled to a C extension saves about 1µs per
+# call.  This is not much at all, and there's very little which benefits from
+# Cython compiliation, but such core functionality is called millions of times
+# even in a simple interactive QuTiP session, and it all adds up.
+
+import numbers
+
+import numpy as np
+from scipy.sparse import dok_matrix, csgraph
+cimport cython
+
+__all__ = ['to', 'create']
+
+
+def _raise_if_unconnected(dtype_list, weights):
+    unconnected = {}
+    for i, type_ in enumerate(dtype_list):
+        missing = [dtype_list[j].__name__
+                   for j, weight in enumerate(weights[:, i])
+                   if weight == np.inf]
+        if missing:
+            unconnected[type_.__name__] = missing
+    if unconnected:
+        message = "Conversion graph not connected.  Cannot reach:\n * "
+        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
+                                for to, froms in unconnected.items())
+        raise NotImplementedError(message)
+
+
+cdef class _converter:
+    """Callable which converts objects of type `x.from_` to type `x.to`."""
+
+    cdef list functions
+    cdef Py_ssize_t n_functions
+    cdef readonly type to
+    cdef readonly type from_
+
+    def __init__(self, functions, to_type, from_type):
+        self.functions = list(functions)
+        self.n_functions = len(self.functions)
+        self.to = to_type
+        self.from_ = from_type
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    def __call__(self, arg):
+        if not isinstance(arg, self.from_):
+            raise TypeError(str(arg) + " is not of type " + str(self.from_))
+        cdef Py_ssize_t i
+        for i in range(self.n_functions):
+            arg = self.functions[i](arg)
+        return arg
+
+    def __repr__(self):
+        return ("<converter to "
+                + self.to.__name__
+                + " from " + self.from_.__name__
+                + ">")
+
+
+cdef class _partial_converter:
+    """Convert from any known data-layer type into the type `x.to`."""
+
+    cdef dict converters
+    cdef readonly type to
+
+    def __init__(self, converters, to_type):
+        self.converters = dict(converters)
+        self.to = to_type
+
+    def __call__(self, arg):
+        try:
+            return self.converters[type(arg)](arg)
+        except KeyError:
+            raise TypeError("unknown type of input: " + str(arg)) from None
+
+    def __repr__(self):
+        return "<converter to " + self.to.__name__ + ">"
+
+
+# While `_to` and `_create` are defined as objects here, they are actually
+# exported by `data.__init__.py` as singleton function objects of their
+# respective types (without the leading underscore).
+
+cdef class _to:
+    """
+    Convert data into a different type.  This object is the knowledge source
+    for every allowable data-layer type in QuTiP, and provides the conversions
+    between all of them.
+
+    The base use is to call this object as a function with signature
+        (type, data) -> converted_data
+    where `type` is a type object (such as `data.CSR`, or that obtained by
+    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
+    want to create a data-layer type from non-data-layer data, use `create`
+    instead.
+
+    You can get individual converters by using the key-lookup syntax.  For
+    example, the item
+        to[CSR, Dense]
+    is a callable which accepts arguments of type `Dense` and returns the
+    equivalent item of type `CSR`.  You can also get a generic converter to a
+    particular data type if only one type is specified, so
+        to[Dense]
+    is a callable which accepts all known (at the time of the lookup)
+    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
+    section below for more detail.
+
+    Internally, the conversion process may go through several steps if new
+    data-layer types have been defined with few conversions specified between
+    them and the pre-existing converters.  The first-class QuTiP data types
+    `Dense` and `CSR` will typically have the best connectivity.
+
+
+    Adding new types
+    ----------------
+    You can add new data-layer types by calling the `add_conversions` method of
+    this object, and then rebuilding all of the mathematical dispatchers.  See
+    the docstring of that method for more information.
+
+
+    Efficiency notes
+    ----------------
+    From an efficiency perspective, there is very little benefit to using the
+    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
+    `to[to_type, type(data)]`, so storing the object elides the creation of a
+    single tuple and a dict lookup, but the cost of this is generally less than
+    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
+    efficient than the general call at all, but can be used in cases where a
+    single callable is required and is more efficient than `functools.partial`.
+    """
+
+    cdef readonly set dtypes
+    cdef readonly list dispatchers
+    cdef dict _direct_convert
+    cdef dict _convert
+    cdef readonly dict weight
+    cdef readonly dict _str2type
+
+    def __init__(self):
+        self._direct_convert = {}
+        self._convert = {}
+        self.dtypes = set()
+        self.weight = {}
+        self.dispatchers = []
+        self._str2type = {}
+
+    def add_conversions(self, converters):
+        """
+        Add conversion functions between different data types.  This is an
+        advanced function, and is only intended for the QuTiP user who wants to
+        add a new underlying data type to QuTiP.
+
+        Any new data type must have at least one converter function given to
+        produce the new data type from an existing data type, and at least one
+        which produces an existing data type from the new one.  You need not
+        specify any more than this, although for efficiency reasons, you may
+        want to specify direct conversions for all types you expect the new
+        type to interact with frequently.
+
+        Parameters
+        ----------
+        converters : iterable of (to_type, from_type, converter, [weight])
+            An iterable of 3- or 4-tuples describing all the new conversions.
+            Each element can individually be a 3- or 4-tuple; they do not need
+            to be all one or the other.
+
+            Elements
+            ........
+            to_type : type
+                The data-layer type that is output by the converter.
+
+            from_type : type
+                The data-layer type to be input to the converter.
+
+            converter : callable (Data -> Data)
+                The converter function.  This should take a single argument
+                (the input data-layer function) and output a data-layer object
+                of `to_type`.  The converter may assume without error checking
+                that its input will always be of `to_type`.  It is safe to
+                specify the same conversion function for multiple inputs so
+                long as the function handles them all safely, but it must
+                always return a single output type.
+
+            weight : positive real, optional (1)
+                The weight associated with this conversion.  This must be > 0,
+                and defaults to `1` if not supplied (which is fixed to be the
+                cost of conversion to `Dense` from `CSR`).  It is generally
+                safe just to leave this blank; it is always at best an
+                approximation.  The currently defined weights are accessible in
+                the `weights` attribute of this object.
+        """
+        for arg in converters:
+            if len(arg) == 3:
+                to_type, from_type, converter = arg
+                weight = 1
+            elif len(arg) == 4:
+                to_type, from_type, converter, weight = arg
+            else:
+                raise TypeError("unknown converter specification: " + str(arg))
+            if not isinstance(to_type, type):
+                raise TypeError(repr(to_type) + " is not a type object")
+            if not isinstance(from_type, type):
+                raise TypeError(repr(from_type) + " is not a type object")
+            if not isinstance(weight, numbers.Real) or weight <= 0:
+                raise TypeError("weight " + repr(weight) + " is not valid")
+            self.dtypes.add(from_type)
+            self.dtypes.add(to_type)
+            self._direct_convert[(to_type, from_type)] = (converter, weight)
+        # Two-way mapping to convert between the type of a dtype and an integer
+        # enumeration value for it.
+        order, index = [], {}
+        for i, dtype in enumerate(self.dtypes):
+            order.append(dtype)
+            index[dtype] = i
+        # Treat the conversion problem as a shortest-path graph problem.  We
+        # build up the graph description as a matrix, then solve the
+        # all-pairs-shortest-path problem.  We forbid negative weights and
+        # there are unlikely to be many data types, so the choice of algorithm
+        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
+        graph = dok_matrix((len(order), len(order)))
+        for (to_type, from_type), (_, weight) in self._direct_convert.items():
+            graph[index[from_type], index[to_type]] = weight
+        weights, predecessors =\
+            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
+        _raise_if_unconnected(order, weights)
+        # Build the whole shortest path conversion lookup.  We directly store
+        # all complete shortest paths, even though this is not the most memory
+        # efficient, because we expect that there will generally be a small
+        # number of available data types, and we care more about minimising the
+        # number of lookups required.
+        self.weight = {}
+        self._convert = {}
+        for i, from_t in enumerate(order):
+            for j, to_t in enumerate(order):
+                convert = []
+                weight = 0
+                cur_t = to_t
+                pred_i = predecessors[i, j]
+                while pred_i >= 0:
+                    pred_t = order[pred_i]
+                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
+                    convert.append(_convert)
+                    weight += _weight
+                    cur_t = pred_t
+                    pred_i = predecessors[i, pred_i]
+                self.weight[(to_t, from_t)] = weight
+                self._convert[(to_t, from_t)] =\
+                    _converter(convert[::-1], to_t, from_t)
+        for dispatcher in self.dispatchers:
+            dispatcher.rebuild_lookup()
+
+    def register_aliases(self, aliases, layer_type):
+        """
+        Register a user frendly name for a data-layer type to be recognized by
+        the :method:`parse` method.
+
+        Parameters
+        ----------
+        aliases : str or list of str
+            Name of list of names to be understood to represent the layer_type.
+
+        layer_type : type
+            Data-layer type, must have been registered with
+            :method:`add_conversions` first.
+        """
+        if layer_type not in self.dtypes:
+            raise ValueError(
+                "Type is not a data-layer type: " + repr(layer_type))
+        if isinstance(aliases, str):
+            aliases = [aliases]
+        for alias in aliases:
+            if type(alias) is not str:
+                raise TypeError("The alias must be a str : " + repr(alias))
+            self._str2type[alias] = layer_type
+
+    def parse(self, dtype):
+        """
+        Return a data-layer type object given its name or the type itself.
+
+        Parameters
+        ----------
+        dtype : type, str
+            Either the name of a data-layer type or a type itself.
+
+        Returns
+        -------
+        type
+            A data-layer type.
+
+        Raises
+        ------
+        TypeError
+            If ``dtype`` is neither a string nor a type.
+        ValueError
+            If ``dtype`` is a name, but no data-layer type of that name is
+            registered, or if ``dtype`` is a type, but not a known data-layer
+            type.
+        """
+        if type(dtype) is type:
+            if dtype not in self.dtypes:
+                raise ValueError(
+                    "Type is not a data-layer type: " + repr(dtype))
+            return dtype
+        elif type(dtype) is str:
+            try:
+                return self._str2type[dtype]
+            except KeyError:
+                raise ValueError(
+                    "Type name is not known to the data-layer: " + repr(dtype)
+                    ) from None
+
+        raise TypeError(
+            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    def __getitem__(self, arg):
+        if type(arg) is not tuple:
+            arg = (arg,)
+        if not arg or len(arg) > 2:
+            raise KeyError(arg)
+        to_t = self.parse(arg[0])
+        if len(arg) == 1:
+            converters = {
+                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
+            }
+            return _partial_converter(converters, to_t)
+        from_t = self.parse(arg[1])
+        return self._convert[to_t, from_t]
+
+    def __call__(self, to_type, data):
+        to_type = self.parse(to_type)
+        from_type = self.parse(type(data))
+        if to_type == from_type:
+            return data
+        return self._convert[to_type, from_type](data)
+
+
+cdef class _create:
+    cdef readonly list _creators
+
+    def __init__(self):
+        self._creators = []
+
+    def add_creators(self, creators):
+        """
+        Add creation functions to make a data-layer object from an arbitrary
+        Python object.
+
+        Parameters
+        ----------
+        creators : iterable of (condition, creator, [priority])
+            An iterable of 2- or 3-tuples describing the new data layer
+            creation functions.
+            Each element can individually be a 2- or 3-tuple; they do not need
+            to be all one or the other.
+
+            Elements
+            ........
+            condition : callable (object) -> bool
+                Function determining if the given object can be converted to a
+                data-layer type using this creator.
+
+            creator function: callable (object, shape, copy=True) -> Data
+                The creator function. It should take an object and a shape and
+                return a data-layer type instance. The object may be any object
+                for which the condition function returned ``True`` when tested.
+                The ``object`` and ``shape`` parameters are passed positionally,
+                and the ``copy`` parameter is passed by keyword.
+
+            priority : real, optional (0)
+                The priority associated with this creator. Higher priority
+                conditions will be tested first and the first valid creator
+                (i.e. for which ``condition(object) == True``) will handle
+                the creation.
+
+        Notes
+        -----
+        Default creators are added with the following priorities:
+
+        * Objects that are instances of data-layer types are
+          converted using ``.copy`` with priority 100.
+        * Objects that have a direct equivalent such as ``numpy.ndarray``
+          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
+        * Objects for which ``scipy.sparse.issparse`` is ``True``
+          are converted using an internal CSR converter with
+          priority 20.
+        * If no condition are meet, ``numpy.array`` is used to try convert
+          the input to an array (priority -inf).
+        """
+        for condition, creator, *priority in creators:
+            if not callable(condition):
+                raise TypeError(repr(condition) + " is not a callable")
+            if not callable(create):
+                raise TypeError(repr(create) + " is not a callable")
+            if len(priority) >= 2:
+                raise ValueError("Too many values to unpack for a creator, " +
+                                 "expected 2 or 3, got "+ str(2+len(priority)))
+            priority = float(priority[0] if priority else 0)
+            self._creators.append((condition, creator, priority))
+        self._creators.sort(key=lambda creator: creator[2], reverse=True)
+
+    def __call__(self, arg, shape=None, copy=True):
+        """
+        Build a :class:`qutip.data.Data` object from arg.
+
+        Parameters
+        ----------
+        arg : object
+            Object to be converted to `qutip.data.Data`. Anything that can be
+            converted to a numpy array are valid input.
+
+        shape : tuple, optional
+            The shape of the output as (``rows``, ``columns``).
+        """
+        for condition, create, _ in self._creators:
+            if condition(arg):
+                return create(arg, shape, copy=copy)
+        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
+                        "qutip data format")
+
+
+to = _to()
+create = _create()
diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
index 65dcd3193c..a05e9b9c45 100644
--- a/qutip/core/data/csr.pxd
+++ b/qutip/core/data/csr.pxd
@@ -1,166 +1,166 @@
-#cython: language_level=3
-
-from cpython cimport mem
-from libcpp.algorithm cimport sort
-from libc.math cimport fabs
-
-cdef extern from *:
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-import numpy as np
-cimport numpy as cnp
-
-from qutip.core.data cimport base
-from qutip.core.data.dense cimport Dense
-
-cdef class CSR(base.Data):
-    cdef double complex *data
-    cdef base.idxint *col_index
-    cdef base.idxint *row_index
-    cdef size_t size
-    cdef object _scipy
-    cdef bint _deallocate
-    cpdef CSR copy(CSR self)
-    cpdef object as_scipy(CSR self, bint full=*)
-    cpdef CSR sort_indices(CSR self)
-    cpdef double complex trace(CSR self)
-    cpdef CSR adjoint(CSR self)
-    cpdef CSR conj(CSR self)
-    cpdef CSR transpose(CSR self)
-
-
-cdef struct Accumulator:
-    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
-    # matrices row-by-row (or column-by-column for CSC) where entries may need
-    # to be accumulated (summed) from several locations which may not be
-    # sorted.
-    #
-    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
-    # to the accumulator for this row by calling `scatter`, then fill the row
-    # in the output by calling `gather`.  Prepare the accumulator to receive
-    # the next row by calling `reset`.
-    double complex *values
-    size_t *modified
-    base.idxint *nonzero
-    size_t _cur_row, nnz, size
-    bint _sorted
-
-cdef inline Accumulator acc_alloc(size_t size):
-    """
-    Initialise this accumulator.  `size` should be the number of columns in the
-    matrix (for CSR) or the number of rows (for CSC).
-    """
-    cdef Accumulator acc
-    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
-    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
-    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
-    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
-        raise MemoryError
-    acc.size = size
-    acc.nnz = 0
-    # The value of _cur_row doesn't actually need to match the true row in
-    # the output, it just needs to be a unique number so that we can use it
-    # as a sentinel in `modified` to tell if there's a value in the current
-    # column.
-    acc._cur_row = 1
-    acc._sorted = True
-    return acc
-
-cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
-    """
-    Add a value to the accumulator for this row, in column `position`.  The
-    value is added on to any value already scattered into this position.
-    """
-    # We have to branch on modified[position] anyway (to know whether to add an
-    # entry in nonzero), so we _actually_ reset `values` here.  This has the
-    # potential to save operations too, if the same column is never touched
-    # again.
-    if acc.modified[position] == acc._cur_row:
-        acc.values[position] += value
-    else:
-        acc.values[position] = value
-        acc.modified[position] = acc._cur_row
-        acc.nonzero[acc.nnz] = position
-        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
-        acc.nnz += 1
-
-cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
-    """
-    Copy all the accumulated values into this row into the output pointers.
-    This will always output its values in sorted order.  The pointers should
-    point to the first free space for data to be copied into.  This method will
-    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
-    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
-    updated after each `self.scatter()` operation, and is reset by
-    `self.reset()`.
-
-    Return the actual number of elements copied in.
-    """
-    cdef size_t i, nnz=0, position
-    cdef double complex value
-    if not acc._sorted:
-        sort(acc.nonzero, acc.nonzero + acc.nnz)
-        acc._sorted = True
-    for i in range(acc.nnz):
-        position = acc.nonzero[i]
-        value = acc.values[position]
-        if fabs(value.real) < tol:
-            value.real = 0
-        if fabs(value.imag) < tol:
-            value.imag = 0
-        if value != 0:
-            values[nnz] = value
-            indices[nnz] = position
-            nnz += 1
-    return nnz
-
-cdef inline void acc_reset(Accumulator *acc) nogil:
-    """Prepare the accumulator to accept the next row of input."""
-    # We actually don't need to do anything to reset other than to change
-    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
-    # whether a value was set in this current row (and if not, `scatter`
-    # resets it when it's used), while `nnz`
-    acc.nnz = 0
-    acc._sorted = True
-    acc._cur_row += 1
-
-cdef inline void acc_free(Accumulator *acc):
-    mem.PyMem_Free(acc.values)
-    mem.PyMem_Free(acc.modified)
-    mem.PyMem_Free(acc.nonzero)
-
-
-# Internal structure for sorting pairs of elements.  Not actually meant to be
-# used in external code.
-cdef struct _data_col:
-    double complex data
-    base.idxint col
-
-cdef class Sorter:
-    cdef size_t size
-    cdef base.idxint **argsort
-    cdef _data_col *sort
-
-    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
-    cdef void copy(Sorter self,
-                   double complex *dest_data, base.idxint *dest_cols,
-                   double complex *src_data, base.idxint *src_cols,
-                   size_t size) nogil
-
-
-cpdef CSR fast_from_scipy(object sci)
-cpdef CSR copy_structure(CSR matrix)
-cpdef CSR sorted(CSR matrix)
-cpdef base.idxint nnz(CSR matrix) nogil
-cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
-cpdef CSR empty_like(CSR other)
-cpdef CSR zeros(base.idxint rows, base.idxint cols)
-cpdef CSR identity(base.idxint dimension, double complex scale=*)
-
-cpdef CSR from_dense(Dense matrix)
-cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
-                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
-                           double tol=*)
-
-cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
-                          base.idxint n_blocks, base.idxint block_size)
+#cython: language_level=3
+
+from cpython cimport mem
+from libcpp.algorithm cimport sort
+from libc.math cimport fabs
+
+cdef extern from *:
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+import numpy as np
+cimport numpy as cnp
+
+from qutip.core.data cimport base
+from qutip.core.data.dense cimport Dense
+
+cdef class CSR(base.Data):
+    cdef double complex *data
+    cdef base.idxint *col_index
+    cdef base.idxint *row_index
+    cdef size_t size
+    cdef object _scipy
+    cdef bint _deallocate
+    cpdef CSR copy(CSR self)
+    cpdef object as_scipy(CSR self, bint full=*)
+    cpdef CSR sort_indices(CSR self)
+    cpdef double complex trace(CSR self)
+    cpdef CSR adjoint(CSR self)
+    cpdef CSR conj(CSR self)
+    cpdef CSR transpose(CSR self)
+
+
+cdef struct Accumulator:
+    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
+    # matrices row-by-row (or column-by-column for CSC) where entries may need
+    # to be accumulated (summed) from several locations which may not be
+    # sorted.
+    #
+    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
+    # to the accumulator for this row by calling `scatter`, then fill the row
+    # in the output by calling `gather`.  Prepare the accumulator to receive
+    # the next row by calling `reset`.
+    double complex *values
+    size_t *modified
+    base.idxint *nonzero
+    size_t _cur_row, nnz, size
+    bint _sorted
+
+cdef inline Accumulator acc_alloc(size_t size):
+    """
+    Initialise this accumulator.  `size` should be the number of columns in the
+    matrix (for CSR) or the number of rows (for CSC).
+    """
+    cdef Accumulator acc
+    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
+    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
+    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
+    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
+        raise MemoryError
+    acc.size = size
+    acc.nnz = 0
+    # The value of _cur_row doesn't actually need to match the true row in
+    # the output, it just needs to be a unique number so that we can use it
+    # as a sentinel in `modified` to tell if there's a value in the current
+    # column.
+    acc._cur_row = 1
+    acc._sorted = True
+    return acc
+
+cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
+    """
+    Add a value to the accumulator for this row, in column `position`.  The
+    value is added on to any value already scattered into this position.
+    """
+    # We have to branch on modified[position] anyway (to know whether to add an
+    # entry in nonzero), so we _actually_ reset `values` here.  This has the
+    # potential to save operations too, if the same column is never touched
+    # again.
+    if acc.modified[position] == acc._cur_row:
+        acc.values[position] += value
+    else:
+        acc.values[position] = value
+        acc.modified[position] = acc._cur_row
+        acc.nonzero[acc.nnz] = position
+        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
+        acc.nnz += 1
+
+cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
+    """
+    Copy all the accumulated values into this row into the output pointers.
+    This will always output its values in sorted order.  The pointers should
+    point to the first free space for data to be copied into.  This method will
+    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
+    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
+    updated after each `self.scatter()` operation, and is reset by
+    `self.reset()`.
+
+    Return the actual number of elements copied in.
+    """
+    cdef size_t i, nnz=0, position
+    cdef double complex value
+    if not acc._sorted:
+        sort(acc.nonzero, acc.nonzero + acc.nnz)
+        acc._sorted = True
+    for i in range(acc.nnz):
+        position = acc.nonzero[i]
+        value = acc.values[position]
+        if fabs(value.real) < tol:
+            value.real = 0
+        if fabs(value.imag) < tol:
+            value.imag = 0
+        if value != 0:
+            values[nnz] = value
+            indices[nnz] = position
+            nnz += 1
+    return nnz
+
+cdef inline void acc_reset(Accumulator *acc) nogil:
+    """Prepare the accumulator to accept the next row of input."""
+    # We actually don't need to do anything to reset other than to change
+    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
+    # whether a value was set in this current row (and if not, `scatter`
+    # resets it when it's used), while `nnz`
+    acc.nnz = 0
+    acc._sorted = True
+    acc._cur_row += 1
+
+cdef inline void acc_free(Accumulator *acc):
+    mem.PyMem_Free(acc.values)
+    mem.PyMem_Free(acc.modified)
+    mem.PyMem_Free(acc.nonzero)
+
+
+# Internal structure for sorting pairs of elements.  Not actually meant to be
+# used in external code.
+cdef struct _data_col:
+    double complex data
+    base.idxint col
+
+cdef class Sorter:
+    cdef size_t size
+    cdef base.idxint **argsort
+    cdef _data_col *sort
+
+    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
+    cdef void copy(Sorter self,
+                   double complex *dest_data, base.idxint *dest_cols,
+                   double complex *src_data, base.idxint *src_cols,
+                   size_t size) nogil
+
+
+cpdef CSR fast_from_scipy(object sci)
+cpdef CSR copy_structure(CSR matrix)
+cpdef CSR sorted(CSR matrix)
+cpdef base.idxint nnz(CSR matrix) nogil
+cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
+cpdef CSR empty_like(CSR other)
+cpdef CSR zeros(base.idxint rows, base.idxint cols)
+cpdef CSR identity(base.idxint dimension, double complex scale=*)
+
+cpdef CSR from_dense(Dense matrix)
+cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
+                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
+                           double tol=*)
+
+cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+                          base.idxint n_blocks, base.idxint block_size)
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 6cf30b06e6..fb9fa24494 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -1,965 +1,965 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-
-from libcpp cimport bool
-from libcpp.algorithm cimport sort
-
-cimport cython
-
-from cpython cimport mem
-
-import numbers
-import warnings
-
-import numpy as np
-cimport numpy as cnp
-import scipy.sparse
-from scipy.sparse import csr_matrix as scipy_csr_matrix
-try:
-    from scipy.sparse.data import _data_matrix as scipy_data_matrix
-except ImportError:
-    # The file data was renamed to _data from scipy 1.8.0
-    from scipy.sparse._data import _data_matrix as scipy_data_matrix
-from scipy.linalg cimport cython_blas as blas
-
-from qutip.core.data cimport base, Dense
-from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
-from qutip.core.data.trace cimport trace_csr
-from qutip.core.data.tidyup cimport tidyup_csr
-from .base import idxint_dtype
-from qutip.settings import settings
-
-cnp.import_array()
-
-cdef extern from *:
-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-    void *PyDataMem_NEW(size_t size)
-    void PyDataMem_FREE(void *ptr)
-
-# Very little should be exported on star-import, because most stuff will have
-# naming collisions with other type modules.
-__all__ = ['CSR']
-
-cdef int _ONE = 1
-
-cdef object _csr_matrix(data, indices, indptr, shape):
-    """
-    Factory method of scipy csr_matrix: we skip all the index type-checking
-    because this takes tens of microseconds, and we already know we're in
-    a sensible format.
-    """
-    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
-    # `_data_matrix` is the first object in the inheritance chain which
-    # doesn't have a really slow __init__.
-    scipy_data_matrix.__init__(out)
-    out.data = data
-    out.indices = indices
-    out.indptr = indptr
-    out._shape = shape
-    return out
-
-
-cdef class CSR(base.Data):
-    """
-    Data type for quantum objects storing its data in compressed sparse row
-    (CSR) format.  This is similar to the `scipy` type
-    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
-    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
-    using the `as_scipy()` method.
-    """
-    def __cinit__(self, *args, **kwargs):
-        # By default, we want CSR to deallocate its memory (we depend on Cython
-        # to ensure we don't deallocate a NULL pointer), and we only flip this
-        # when we create a scipy backing.  Since creating the scipy backing
-        # depends on knowing the shape, which happens _after_ data
-        # initialisation and may throw an exception, it is better to have a
-        # single flag that is set as soon as the pointers are assigned.
-        self._deallocate = True
-
-    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
-        # This is the Python __init__ method, so we do not care that it is not
-        # super-fast C access.  Typically Cython code will not call this, but
-        # will use a factory method in this module or at worst, call
-        # CSR.__new__ and manually set everything.  We must be very careful in
-        # this function that the deallocation is set up correctly if any
-        # exceptions occur.
-        cdef size_t ptr
-        cdef base.idxint col
-        cdef object data, col_index, row_index
-        if isinstance(arg, scipy.sparse.spmatrix):
-            arg = arg.tocsr()
-            if shape is not None and shape != arg.shape:
-                raise ValueError("".join([
-                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
-                ]))
-            shape = arg.shape
-            arg = (arg.data, arg.indices, arg.indptr)
-        if not isinstance(arg, tuple):
-            raise TypeError("arg must be a scipy matrix or tuple")
-        if len(arg) != 3:
-            raise ValueError("arg must be a (data, col_index, row_index) tuple")
-        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
-        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
-        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
-        # This flag must be set at the same time as data, col_index and
-        # row_index are assigned.  These assignments cannot raise an exception
-        # in user code due to the above three lines, but further code may.
-        self._deallocate = False
-        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
-        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
-        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
-        self.size = (cnp.PyArray_SIZE(data)
-                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
-                     else cnp.PyArray_SIZE(col_index))
-        if shape is None:
-            warnings.warn("instantiating CSR matrix of unknown shape")
-            # row_index contains an extra element which is nnz.  We assume the
-            # smallest matrix which can hold all these values by iterating
-            # through the columns.  This is slow and probably inaccurate, since
-            # there could be columns containing zero (hence the warning).
-            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
-            col = 1
-            for ptr in range(self.size):
-                col = self.col_index[ptr] if self.col_index[ptr] > col else col
-            self.shape[1] = col
-        else:
-            if not isinstance(shape, tuple):
-                raise TypeError("shape must be a 2-tuple of positive ints")
-            if not (len(shape) == 2
-                    and isinstance(shape[0], int)
-                    and isinstance(shape[1], int)
-                    and shape[0] > 0
-                    and shape[1] > 0):
-                raise ValueError("shape must be a 2-tuple of positive ints")
-            self.shape = shape
-        # Store a reference to the backing scipy matrix so it doesn't get
-        # deallocated before us.
-        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
-        if tidyup:
-            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
-
-    def __reduce__(self):
-        return (fast_from_scipy, (self.as_scipy(),))
-
-    cpdef CSR copy(self):
-        """
-        Return a complete (deep) copy of this object.
-
-        If the type currently has a scipy backing, such as that produced by
-        `as_scipy`, this will not be copied.  The backing is a view onto our
-        data, and a straight copy of this view would be incorrect.  We do not
-        create a new view at copy time, since the user may only access this
-        through a creation method, and creating it ahead of time would incur an
-        unnecessary speed penalty for users who do not need it (including
-        low-level C code).
-        """
-        cdef base.idxint nnz_ = nnz(self)
-        cdef CSR out = empty_like(self)
-        memcpy(out.data, self.data, nnz_*sizeof(double complex))
-        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
-        memcpy(out.row_index, self.row_index,
-               (self.shape[0] + 1)*sizeof(base.idxint))
-        return out
-
-    cpdef object to_array(self):
-        """
-        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
-        is not a view onto the data, and changes to new array will not affect
-        the original data structure.
-        """
-        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
-        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
-        cdef double complex [:, ::1] buffer = out
-        cdef size_t row, ptr
-        for row in range(self.shape[0]):
-            for ptr in range(self.row_index[row], self.row_index[row + 1]):
-                buffer[row, self.col_index[ptr]] = self.data[ptr]
-        return out
-
-    cpdef object as_scipy(self, bint full=False):
-        """
-        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
-        underlying data structures are exposed, such that modifications to the
-        `data`, `indices` and `indptr` buffers in the resulting object will
-        modify this object too.
-
-        If `full` is False (the default), the output array is squeezed so that
-        the SciPy array sees only the filled elements.  If `full` is True,
-        SciPy will see the full underlying buffers, which may include
-        uninitialised elements.  Setting `full=True` is intended for
-        Python-space factory methods.  In all other use cases, `full=False` is
-        much less error prone.
-        """
-        # We store a reference to the scipy matrix not only for caching this
-        # relatively expensive method, but also because we transferred
-        # ownership of our data to the numpy arrays, and we can't allow them to
-        # be collected while we're alive.
-        if self._scipy is not None:
-            return self._scipy
-        cdef cnp.npy_intp length = self.size if full else nnz(self)
-        data = cnp.PyArray_SimpleNewFromData(1, [length],
-                                             cnp.NPY_COMPLEX128,
-                                             self.data)
-        indices = cnp.PyArray_SimpleNewFromData(1, [length],
-                                                base.idxint_DTYPE,
-                                                self.col_index)
-        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
-                                               base.idxint_DTYPE,
-                                               self.row_index)
-        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
-        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
-        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
-        self._deallocate = False
-        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
-        return self._scipy
-
-    cpdef CSR sort_indices(self):
-        cdef Sorter sort
-        cdef base.idxint ptr
-        cdef size_t row, diff, size=0
-        for row in range(self.shape[0]):
-            diff = self.row_index[row + 1] - self.row_index[row]
-            size = diff if diff > size else size
-        sort = Sorter(size)
-        for row in range(self.shape[0]):
-            ptr = self.row_index[row]
-            diff = self.row_index[row + 1] - ptr
-            sort.inplace(self, ptr, diff)
-        return self
-
-    cpdef double complex trace(self):
-        return trace_csr(self)
-
-    cpdef CSR adjoint(self):
-        return adjoint_csr(self)
-
-    cpdef CSR conj(self):
-        return conj_csr(self)
-
-    cpdef CSR transpose(self):
-        return transpose_csr(self)
-
-    def __repr__(self):
-        return "".join([
-            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
-        ])
-
-    def __str__(self):
-        return self.__repr__()
-
-    def __dealloc__(self):
-        # If we have a reference to a scipy type, then we've passed ownership
-        # of the data to numpy, so we let it handle refcounting and we don't
-        # need to deallocate anything ourselves.
-        if not self._deallocate:
-            return
-        if self.data != NULL:
-            PyDataMem_FREE(self.data)
-        if self.col_index != NULL:
-            PyDataMem_FREE(self.col_index)
-        if self.row_index != NULL:
-            PyDataMem_FREE(self.row_index)
-
-
-cpdef CSR fast_from_scipy(object sci):
-    """
-    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
-    checking on any of the inputs, and should consequently be considered very
-    unsafe.  This is primarily for use in the unpickling operation.
-    """
-    cdef CSR out = CSR.__new__(CSR)
-    out.shape = sci.shape
-    out._deallocate = False
-    out._scipy = sci
-    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
-    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
-    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
-    out.size = cnp.PyArray_SIZE(sci.data)
-    return out
-
-
-cpdef CSR copy_structure(CSR matrix):
-    """
-    Return a copy of the input matrix with identical `col_index` and
-    `row_index` matrices, and an allocated, but empty, `data`.  The returned
-    pointers are all separately allocated, but contain the same information.
-
-    This is intended for unary functions on CSR types that maintain the exact
-    structure, but modify each non-zero data element without change their
-    location.
-    """
-    cdef CSR out = empty_like(matrix)
-    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
-    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
-    return out
-
-
-cpdef inline base.idxint nnz(CSR matrix) nogil:
-    """Get the number of non-zero elements of a CSR matrix."""
-    return matrix.row_index[matrix.shape[0]]
-
-
-cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
-    return i[0] < j[0]
-
-cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
-    return x.col < y.col
-
-ctypedef fused _swap_data:
-    double complex
-    base.idxint
-
-cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
-    a[0], b[0] = b[0], a[0]
-
-cdef class Sorter:
-    # Look on my works, ye mighty, and despair!
-    #
-    # This class has hard-coded sorts for up to three elements, for both
-    # copying and in-place varieties.  Everything above that we delegate to a
-    # proper sorting algorithm.
-    def __init__(self, size_t size):
-        self.size = size
-
-    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
-        cdef size_t n
-        cdef base.idxint col0, col1, col2
-        # Fast paths for tridiagonal matrices.  These fast paths minimise the
-        # number of comparisons and swaps made.
-        if size < 2:
-            return
-        if size == 2:
-            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-            return
-        if size == 3:
-            # Faster to store rather than re-dereference, and if someone
-            # changes the data underneath us, we've got larger problems anyway.
-            col0 = matrix.col_index[ptr]
-            col1 = matrix.col_index[ptr + 1]
-            col2 = matrix.col_index[ptr + 2]
-            if col0 < col1:
-                if col1 > col2:
-                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
-                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
-                    if col0 > col2:
-                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-            elif col1 < col2:
-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-                if col0 > col2:
-                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
-                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
-            else:
-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
-            return
-        # Now we actually have to do the sort properly.  It's easiest just to
-        # copy the data into a temporary structure.
-        if size > self.size or self.sort == NULL:
-            # realloc(NULL, size) is equivalent to malloc(size), so there's no
-            # problem if cols and argsort weren't allocated before.
-            self.size = size if size > self.size else self.size
-            with gil:
-                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
-                                                            self.size * sizeof(_data_col))
-        for n in range(size):
-            self.sort[n].data = matrix.data[ptr + n]
-            self.sort[n].col = matrix.col_index[ptr + n]
-        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
-        for n in range(size):
-            matrix.data[ptr + n] = self.sort[n].data
-            matrix.col_index[ptr + n] = self.sort[n].col
-
-    cdef void copy(self,
-                   double complex *dest_data, base.idxint *dest_cols,
-                   double complex *src_data, base.idxint *src_cols,
-                   size_t size) nogil:
-        cdef size_t n, ptr
-        # Fast paths for small sizes.  Not pretty, but it speeds things up a
-        # lot for up to triadiaongal systems (which are pretty common).
-        if size == 0:
-            return
-        if size == 1:
-            dest_cols[0] = src_cols[0]
-            dest_data[0] = src_data[0]
-            return
-        if size == 2:
-            if src_cols[0] < src_cols[1]:
-                dest_cols[0] = src_cols[0]
-                dest_data[0] = src_data[0]
-                dest_cols[1] = src_cols[1]
-                dest_data[1] = src_data[1]
-            else:
-                dest_cols[1] = src_cols[0]
-                dest_data[1] = src_data[0]
-                dest_cols[0] = src_cols[1]
-                dest_data[0] = src_data[1]
-            return
-        if size == 3:
-            if src_cols[0] < src_cols[1]:
-                if src_cols[0] < src_cols[2]:
-                    dest_cols[0] = src_cols[0]
-                    dest_data[0] = src_data[0]
-                    if src_cols[1] < src_cols[2]:
-                        dest_cols[1] = src_cols[1]
-                        dest_data[1] = src_data[1]
-                        dest_cols[2] = src_cols[2]
-                        dest_data[2] = src_data[2]
-                    else:
-                        dest_cols[2] = src_cols[1]
-                        dest_data[2] = src_data[1]
-                        dest_cols[1] = src_cols[2]
-                        dest_data[1] = src_data[2]
-                else:
-                    dest_cols[1] = src_cols[0]
-                    dest_data[1] = src_data[0]
-                    dest_cols[2] = src_cols[1]
-                    dest_data[2] = src_data[1]
-                    dest_cols[0] = src_cols[2]
-                    dest_data[0] = src_data[2]
-            elif src_cols[0] < src_cols[2]:
-                dest_cols[1] = src_cols[0]
-                dest_data[1] = src_data[0]
-                dest_cols[0] = src_cols[1]
-                dest_data[0] = src_data[1]
-                dest_cols[2] = src_cols[2]
-                dest_data[2] = src_data[2]
-            else:
-                dest_cols[2] = src_cols[0]
-                dest_data[2] = src_data[0]
-                if src_cols[1] < src_cols[2]:
-                    dest_cols[0] = src_cols[1]
-                    dest_data[0] = src_data[1]
-                    dest_cols[1] = src_cols[2]
-                    dest_data[1] = src_data[2]
-                else:
-                    dest_cols[1] = src_cols[1]
-                    dest_data[1] = src_data[1]
-                    dest_cols[0] = src_cols[2]
-                    dest_data[0] = src_data[2]
-            return
-        # Now we're left with the full case, and we have to sort properly.
-        if size > self.size or self.argsort == NULL:
-            # realloc(NULL, size) is equivalent to malloc(size), so there's no
-            # problem if cols and argsort weren't allocated before.
-            self.size = size if size > self.size else self.size
-            with gil:
-                self.argsort = (
-                    <base.idxint **>
-                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
-                )
-        # We do the argsort with two levels of indirection to minimise memory
-        # allocation and copying requirements when this function is being used
-        # to assemble a CSR matrix under an operation which may change the
-        # order of the columns (e.g. permute).  First the user makes the
-        # columns accessible in some contiguous memory (or if they're not
-        # changing them, they can just use the CSR buffers).  We put pointers
-        # to each of those columns in the array which actually gets sorted
-        # using a comparison function which dereferences the pointers and
-        # compares the result.  After the sort, `argsort` will be the pointers
-        # sorted according to the new column, and we know that the "lowest"
-        # pointer in there has the value `src_cols`, so we can do pointer
-        # arithmetic to know which element we should take.
-        #
-        # This is about 30-40% faster than allocating space for structs of
-        # (double complex, idxint), copying in the data and column, sorting and
-        # copying into the new arrays.  Allocating the structs actually
-        # allocates more space than the pointer method (double complex is
-        # very likely to be 2x the size of a pointer, _and_ the struct may need
-        # extra padding to be aligned), so it's probably actually worse for
-        # cache locality.  Despite the sort relying on pointer dereference in
-        # this case, it's actually got very good cache locality.
-        for n in range(size):
-            self.argsort[n] = src_cols + n
-        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
-        for n in range(size):
-            ptr = self.argsort[n] - src_cols
-            dest_cols[n] = src_cols[ptr]
-            dest_data[n] = src_data[ptr]
-
-    def __dealloc__(self):
-        if self.argsort != NULL:
-            mem.PyMem_Free(self.argsort)
-        if self.sort != NULL:
-            mem.PyMem_Free(self.sort)
-
-cpdef CSR sorted(CSR matrix):
-    cdef CSR out = empty_like(matrix)
-    cdef Sorter sort
-    cdef base.idxint ptr
-    cdef size_t row, diff, size=0
-    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
-    for row in range(matrix.shape[0]):
-        diff = matrix.row_index[row + 1] - matrix.row_index[row]
-        size = diff if diff > size else size
-    sort = Sorter(size)
-    for row in range(matrix.shape[0]):
-        ptr = matrix.row_index[row]
-        diff = matrix.row_index[row + 1] - ptr
-        sort.copy(out.data + ptr, out.col_index + ptr,
-                  matrix.data + ptr, matrix.col_index + ptr,
-                  diff)
-    return out
-
-
-cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
-    """
-    Allocate an empty CSR matrix of the given shape, with space for `size`
-    elements in the `data` and `col_index` arrays.
-
-    This does not initialise any of the memory returned, but sets the last
-    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
-    """
-    if size < 0:
-        raise ValueError("size must be a positive integer.")
-    # Python doesn't like allocating nothing.
-    if size == 0:
-        size += 1
-    cdef CSR out = CSR.__new__(CSR)
-    cdef base.idxint row_size = rows + 1
-    out.shape = (rows, cols)
-    out.size = size
-    out.data =\
-        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
-    out.col_index =\
-        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
-    out.row_index =\
-        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
-    # Set the number of non-zero elements to 0.
-    out.row_index[rows] = 0
-    return out
-
-
-cpdef CSR empty_like(CSR other):
-    return empty(other.shape[0], other.shape[1], nnz(other))
-
-
-cpdef CSR zeros(base.idxint rows, base.idxint cols):
-    """
-    Allocate the zero matrix with a given shape.  There will not be any room in
-    the `data` and `col_index` buffers to add new elements.
-    """
-    # We always allocate matrices with at least one element to ensure that we
-    # actually _are_ asking for memory (Python doesn't like allocating nothing)
-    cdef CSR out = empty(rows, cols, 1)
-    out.data[0] = out.col_index[0] = 0
-    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
-    return out
-
-
-cpdef CSR identity(base.idxint dimension, double complex scale=1):
-    """
-    Return a square matrix of the specified dimension, with a constant along
-    the diagonal.  By default this will be the identity matrix, but if `scale`
-    is passed, then the result will be `scale` times the identity.
-    """
-    cdef CSR out = empty(dimension, dimension, dimension)
-    cdef base.idxint i
-    for i in range(dimension):
-        out.data[i] = scale
-        out.col_index[i] = i
-        out.row_index[i] = i
-    out.row_index[dimension] = dimension
-    return out
-
-cpdef CSR from_dense(Dense matrix):
-    # Assume worst-case scenario for non-zero.
-    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
-                         matrix.shape[0]*matrix.shape[1])
-    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
-    row_stride = 1 if matrix.fortran else matrix.shape[1]
-    col_stride = matrix.shape[0] if matrix.fortran else 1
-    out.row_index[0] = 0
-    for row in range(matrix.shape[0]):
-        ptr_in = row_stride * row
-        for col in range(matrix.shape[1]):
-            if matrix.data[ptr_in] != 0:
-                out.data[ptr_out] = matrix.data[ptr_in]
-                out.col_index[ptr_out] = col
-                ptr_out += 1
-            ptr_in += col_stride
-        out.row_index[row + 1] = ptr_out
-    return out
-
-cdef CSR from_coo_pointers(
-    base.idxint *rows, base.idxint *cols, double complex *data,
-    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
-):
-    # Note that COO pointers may not be sorted in row-major order, and that
-    # they may contain duplicate entries which should be implicitly summed.
-    cdef Accumulator acc = acc_alloc(n_cols)
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    cdef double complex *data_tmp
-    cdef base.idxint *cols_tmp
-    cdef base.idxint row
-    cdef size_t ptr_in, ptr_out, ptr_prev
-    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
-    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
-    if data_tmp == NULL or cols_tmp == NULL:
-        raise MemoryError
-    with nogil:
-        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
-        for ptr_in in range(nnz):
-            out.row_index[rows[ptr_in] + 1] += 1
-        for ptr_out in range(n_rows):
-            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
-        # out.row_index is currently in the normal output form, but we're
-        # temporarily going to modify it to keep track of how many values we've
-        # placed in each row as we iterate through.  At every state,
-        # out.row_index[row] will contain a pointer to the next location that
-        # an element should be placed in this row.
-        for ptr_in in range(nnz):
-            row = rows[ptr_in]
-            ptr_out = out.row_index[row]
-            cols_tmp[ptr_out] = cols[ptr_in]
-            data_tmp[ptr_out] = data[ptr_in]
-            out.row_index[row] += 1
-        # Apply the scatter/gather pattern to find the actual number of
-        # non-zero elements we're writing into each row (since there's a sum,
-        # there may be some zeros of duplicates).  Remember we also need to
-        # shift the row_index array back to what it was before as well.
-        ptr_out = 0
-        ptr_prev = 0
-        for row in range(n_rows):
-            for ptr_in in range(ptr_prev, out.row_index[row]):
-                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
-            ptr_prev = out.row_index[row]
-            out.row_index[row] = ptr_out
-            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
-            acc_reset(&acc)
-        out.row_index[n_rows] = ptr_out
-    mem.PyMem_Free(data_tmp)
-    mem.PyMem_Free(cols_tmp)
-    acc_free(&acc)
-    return out
-
-
-cdef inline base.idxint _diagonal_length(
-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-) nogil:
-    if offset > 0:
-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-    return n_cols if offset > n_cols - n_rows else n_rows + offset
-
-cdef CSR diag(
-    double complex[:] diagonal, base.idxint offset,
-    base.idxint n_rows, base.idxint n_cols,
-):
-    """
-    Construct a CSR matrix with a single non-zero diagonal.
-
-    Parameters
-    ----------
-    diagonal : indexable of double complex
-        The entries (including zeros) that should be placed on the diagonal in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal.
-
-    offsets : idxint
-        The index of the diagonals.  An offset of 0 is the main diagonal,
-        positive values are above the main diagonal and negative ones are below
-        the main diagonal.
-
-    n_rows, n_cols : idxint
-        The shape of the output.  The result does not need to be square, but
-        the diagonal must be of the correct length to fit in.
-    """
-    if n_rows < 0 or n_cols < 0:
-        raise ValueError("shape must be positive")
-    cdef base.idxint nnz = len(diagonal)
-    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
-    if nnz != n_diag:
-        raise ValueError("incorrect number of diagonal elements")
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    cdef base.idxint start_row = 0 if offset >= 0 else -offset
-    cdef base.idxint col = 0 if offset <= 0 else offset
-    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
-    nnz = 0
-    for row in range(start_row + 1, start_row + n_diag + 1):
-        out.col_index[nnz] = col
-        out.data[nnz] = diagonal[nnz]
-        col += 1
-        nnz += 1
-        out.row_index[row] = nnz
-    for row in range(start_row + n_diag + 1, n_rows + 1):
-        out.row_index[row] = nnz
-    return out
-
-cdef CSR diags_(
-    list diagonals, base.idxint[:] offsets,
-    base.idxint n_rows, base.idxint n_cols,
-):
-    """
-    Construct a CSR matrix from a list of diagonals and their offsets.  The
-    offsets are assumed to be in sorted order.  This is the C-only interface to
-    csr.diags, and inputs are not sanity checked (use the Python interface for
-    that).
-
-    Parameters
-    ----------
-    diagonals : list of indexable of double complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal (not checked).
-
-    offsets : idxint[:]
-        The indices of the diagonals.  These should be sorted and without
-        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
-        An offset of 0 is the main diagonal, positive values are above the main
-        diagonal and negative ones are below the main diagonal.
-
-    n_rows, n_cols : idxint
-        The shape of the output.  The result does not need to be square, but
-        the diagonals must be of the correct length to fit in.
-    """
-    cdef size_t n_diagonals = len(diagonals)
-    if n_diagonals == 0:
-        return zeros(n_rows, n_cols)
-    cdef base.idxint k, row, start_row, offset, nnz=0,
-    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
-    cdef double complex value
-    for k in range(n_diagonals):
-        offset = offsets[k]
-        if offset >= 0 and min_k > k:
-            min_k = k
-        nnz += _diagonal_length(offset, n_rows, n_cols)
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    nnz = 0
-    out.row_index[0] = 0
-    for row in range(n_rows):
-        if min_k > 0:
-            offset = offsets[min_k - 1]
-            start_row = 0 if offset >= 0 else -offset
-            if start_row == row:
-                min_k -= 1
-        if max_k > 0:
-            offset = offsets[max_k - 1]
-            start_row = 0 if offset >= 0 else -offset
-            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
-                max_k -= 1
-        for k in range(min_k, max_k):
-            offset = offsets[k]
-            value = diagonals[k][row if offset >= 0 else row + offset]
-            if value == 0:
-                continue
-            out.data[nnz] = value
-            out.col_index[nnz] = row + offset
-            nnz += 1
-        out.row_index[row + 1] = nnz
-    return out
-
-@cython.wraparound(True)
-def diags(diagonals, offsets=None, shape=None):
-    """
-    Construct a CSR matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements.  Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    cdef base.idxint n_rows, n_cols, offset
-    try:
-        diagonals = list(diagonals)
-        if diagonals and np.isscalar(diagonals[0]):
-            # Catch the case where we're being called as (for example)
-            #   diags([1, 2, 3], 0)
-            # with a single diagonal and offset.
-            diagonals = [diagonals]
-    except TypeError:
-        raise TypeError("diagonals must be a list of arrays of complex") from None
-    if offsets is None:
-        if len(diagonals) == 0:
-            offsets = []
-        elif len(diagonals) == 1:
-            offsets = [0]
-        else:
-            raise TypeError("offsets must be supplied if passing more than one diagonal")
-    offsets = np.atleast_1d(offsets)
-    if offsets.ndim > 1:
-        raise ValueError("offsets must be a 1D array of integers")
-    if len(diagonals) != len(offsets):
-        raise ValueError("number of diagonals does not match number of offsets")
-    if len(diagonals) == 0:
-        if shape is None:
-            raise ValueError("cannot construct matrix with no diagonals without a shape")
-        else:
-            n_rows, n_cols = shape
-        return zeros(n_rows, n_cols)
-    order = np.argsort(offsets)
-    diagonals_ = []
-    offsets_ = []
-    prev, cur = None, None
-    for i in order:
-        cur = offsets[i]
-        if cur == prev:
-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-        else:
-            offsets_.append(cur)
-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-        prev = cur
-    if shape is None:
-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-    else:
-        try:
-            n_rows, n_cols = shape
-        except (TypeError, ValueError):
-            raise TypeError("shape must be a 2-tuple of positive integers")
-        if n_rows < 0 or n_cols < 0:
-            raise ValueError("shape must be a 2-tuple of positive integers")
-    for i in range(len(diagonals_)):
-        offset = offsets_[i]
-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-            raise ValueError("given diagonals do not have the correct lengths")
-    if n_rows == 0 and n_cols == 0:
-        raise ValueError("can't produce a 0x0 matrix")
-    if len(offsets) == 1:
-        # Fast path for a single diagonal.
-        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
-    return diags_(
-        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
-    )
-
-
-cpdef CSR _from_csr_blocks(
-    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
-    base.idxint n_blocks, base.idxint block_size
-):
-    """
-    Construct a CSR from non-overlapping blocks.
-
-    Each operator in ``block_ops`` should be a square CSR operator with
-    shape ``(block_size, block_size)``. The output operator consists of
-    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
-    ``(n_blocks * block_size, n_blocks * block_size)``.
-
-    None of the operators should overlap (i.e. the list of block row and
-    column pairs should be unique).
-
-    Parameters
-    ----------
-    block_rows : sequence of base.idxint integers
-        The block row for each operator. The block row should be in
-        ``range(0, n_blocks)``.
-
-    block_cols : sequence of base.idxint integers
-        The block column for each operator. The block column should be in
-        ``range(0, n_blocks)``.
-
-    block_ops : sequence of CSR matrixes
-        The operators corresponding to the rows and columns in ``block_rows``
-        and ``block_cols``.
-
-    n_blocks : base.idxint
-        Number of blocks. The shape of the final matrix is
-        (n_blocks * block, n_blocks * block).
-
-    block_size : base.idxint
-        Size of each block. The shape of matrices in ``block_ops`` is
-        ``(block_size, block_size)``.
-    """
-    cdef CSR op
-    cdef base.idxint shape = n_blocks * block_size
-    cdef base.idxint nnz_ = 0
-    cdef base.idxint n_ops = len(block_ops)
-    cdef base.idxint i, j
-    cdef base.idxint row_idx, col_idx
-
-    # check arrays are the same length
-    if len(block_rows) != n_ops or len(block_cols) != n_ops:
-        raise ValueError(
-            "The arrays block_rows, block_cols and block_ops should have"
-            " the same length."
-        )
-
-    if n_ops == 0:
-        return zeros(shape, shape)
-
-    # check op shapes and calculate nnz
-    for op in block_ops:
-        nnz_ += nnz(op)
-        if op.shape[0] != block_size or op.shape[1] != block_size:
-            raise ValueError(
-                "Block operators (block_ops) do not have the correct shape."
-            )
-
-    # check ops are ordered by (row, column)
-    row_idx = block_rows[0]
-    col_idx = block_cols[0]
-    for i in range(1, n_ops):
-        if (
-            block_rows[i] < row_idx or
-            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
-        ):
-            raise ValueError(
-                "The arrays block_rows and block_cols must be sorted"
-                " by (row, column)."
-            )
-        row_idx = block_rows[i]
-        col_idx = block_cols[i]
-
-    if nnz_ == 0:
-        return zeros(shape, shape)
-
-    cdef CSR out = empty(shape, shape, nnz_)
-    cdef base.idxint op_idx = 0
-    cdef base.idxint prev_op_idx = 0
-    cdef base.idxint end = 0
-    cdef base.idxint row_pos, col_pos
-    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
-
-    out.row_index[0] = 0
-
-    for row_idx in range(n_blocks):
-        prev_op_idx = op_idx
-        while op_idx < n_ops:
-            if block_rows[op_idx] != row_idx:
-                break
-            op_idx += 1
-
-        row_pos = row_idx * block_size
-        for op_row in range(block_size):
-            for i in range(prev_op_idx, op_idx):
-                op = block_ops[i]
-                if nnz(op) == 0:
-                    # empty CSR matrices have uninitialized row_index entries.
-                    # it's unclear whether users should ever see such matrixes
-                    # but we support them here anyway.
-                    continue
-                col_idx = block_cols[i]
-                col_pos = col_idx * block_size
-                op_row_start = op.row_index[op_row]
-                op_row_end = op.row_index[op_row + 1]
-                op_row_len = op_row_end - op_row_start
-                for j in range(op_row_len):
-                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
-                    out.data[end + j] = op.data[op_row_start + j]
-                end += op_row_len
-            out.row_index[row_pos + op_row + 1] = end
-
-    return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+
+from libcpp cimport bool
+from libcpp.algorithm cimport sort
+
+cimport cython
+
+from cpython cimport mem
+
+import numbers
+import warnings
+
+import numpy as np
+cimport numpy as cnp
+import scipy.sparse
+from scipy.sparse import csr_matrix as scipy_csr_matrix
+try:
+    from scipy.sparse.data import _data_matrix as scipy_data_matrix
+except ImportError:
+    # The file data was renamed to _data from scipy 1.8.0
+    from scipy.sparse._data import _data_matrix as scipy_data_matrix
+from scipy.linalg cimport cython_blas as blas
+
+from qutip.core.data cimport base, Dense
+from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
+from qutip.core.data.trace cimport trace_csr
+from qutip.core.data.tidyup cimport tidyup_csr
+from .base import idxint_dtype
+from qutip.settings import settings
+
+cnp.import_array()
+
+cdef extern from *:
+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+    void *PyDataMem_NEW(size_t size)
+    void PyDataMem_FREE(void *ptr)
+
+# Very little should be exported on star-import, because most stuff will have
+# naming collisions with other type modules.
+__all__ = ['CSR']
+
+cdef int _ONE = 1
+
+cdef object _csr_matrix(data, indices, indptr, shape):
+    """
+    Factory method of scipy csr_matrix: we skip all the index type-checking
+    because this takes tens of microseconds, and we already know we're in
+    a sensible format.
+    """
+    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
+    # `_data_matrix` is the first object in the inheritance chain which
+    # doesn't have a really slow __init__.
+    scipy_data_matrix.__init__(out)
+    out.data = data
+    out.indices = indices
+    out.indptr = indptr
+    out._shape = shape
+    return out
+
+
+cdef class CSR(base.Data):
+    """
+    Data type for quantum objects storing its data in compressed sparse row
+    (CSR) format.  This is similar to the `scipy` type
+    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
+    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
+    using the `as_scipy()` method.
+    """
+    def __cinit__(self, *args, **kwargs):
+        # By default, we want CSR to deallocate its memory (we depend on Cython
+        # to ensure we don't deallocate a NULL pointer), and we only flip this
+        # when we create a scipy backing.  Since creating the scipy backing
+        # depends on knowing the shape, which happens _after_ data
+        # initialisation and may throw an exception, it is better to have a
+        # single flag that is set as soon as the pointers are assigned.
+        self._deallocate = True
+
+    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
+        # This is the Python __init__ method, so we do not care that it is not
+        # super-fast C access.  Typically Cython code will not call this, but
+        # will use a factory method in this module or at worst, call
+        # CSR.__new__ and manually set everything.  We must be very careful in
+        # this function that the deallocation is set up correctly if any
+        # exceptions occur.
+        cdef size_t ptr
+        cdef base.idxint col
+        cdef object data, col_index, row_index
+        if isinstance(arg, scipy.sparse.spmatrix):
+            arg = arg.tocsr()
+            if shape is not None and shape != arg.shape:
+                raise ValueError("".join([
+                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
+                ]))
+            shape = arg.shape
+            arg = (arg.data, arg.indices, arg.indptr)
+        if not isinstance(arg, tuple):
+            raise TypeError("arg must be a scipy matrix or tuple")
+        if len(arg) != 3:
+            raise ValueError("arg must be a (data, col_index, row_index) tuple")
+        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
+        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
+        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
+        # This flag must be set at the same time as data, col_index and
+        # row_index are assigned.  These assignments cannot raise an exception
+        # in user code due to the above three lines, but further code may.
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
+        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
+        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
+        self.size = (cnp.PyArray_SIZE(data)
+                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
+                     else cnp.PyArray_SIZE(col_index))
+        if shape is None:
+            warnings.warn("instantiating CSR matrix of unknown shape")
+            # row_index contains an extra element which is nnz.  We assume the
+            # smallest matrix which can hold all these values by iterating
+            # through the columns.  This is slow and probably inaccurate, since
+            # there could be columns containing zero (hence the warning).
+            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
+            col = 1
+            for ptr in range(self.size):
+                col = self.col_index[ptr] if self.col_index[ptr] > col else col
+            self.shape[1] = col
+        else:
+            if not isinstance(shape, tuple):
+                raise TypeError("shape must be a 2-tuple of positive ints")
+            if not (len(shape) == 2
+                    and isinstance(shape[0], int)
+                    and isinstance(shape[1], int)
+                    and shape[0] > 0
+                    and shape[1] > 0):
+                raise ValueError("shape must be a 2-tuple of positive ints")
+            self.shape = shape
+        # Store a reference to the backing scipy matrix so it doesn't get
+        # deallocated before us.
+        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
+        if tidyup:
+            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
+
+    def __reduce__(self):
+        return (fast_from_scipy, (self.as_scipy(),))
+
+    cpdef CSR copy(self):
+        """
+        Return a complete (deep) copy of this object.
+
+        If the type currently has a scipy backing, such as that produced by
+        `as_scipy`, this will not be copied.  The backing is a view onto our
+        data, and a straight copy of this view would be incorrect.  We do not
+        create a new view at copy time, since the user may only access this
+        through a creation method, and creating it ahead of time would incur an
+        unnecessary speed penalty for users who do not need it (including
+        low-level C code).
+        """
+        cdef base.idxint nnz_ = nnz(self)
+        cdef CSR out = empty_like(self)
+        memcpy(out.data, self.data, nnz_*sizeof(double complex))
+        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
+        memcpy(out.row_index, self.row_index,
+               (self.shape[0] + 1)*sizeof(base.idxint))
+        return out
+
+    cpdef object to_array(self):
+        """
+        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
+        is not a view onto the data, and changes to new array will not affect
+        the original data structure.
+        """
+        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
+        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
+        cdef double complex [:, ::1] buffer = out
+        cdef size_t row, ptr
+        for row in range(self.shape[0]):
+            for ptr in range(self.row_index[row], self.row_index[row + 1]):
+                buffer[row, self.col_index[ptr]] = self.data[ptr]
+        return out
+
+    cpdef object as_scipy(self, bint full=False):
+        """
+        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
+        underlying data structures are exposed, such that modifications to the
+        `data`, `indices` and `indptr` buffers in the resulting object will
+        modify this object too.
+
+        If `full` is False (the default), the output array is squeezed so that
+        the SciPy array sees only the filled elements.  If `full` is True,
+        SciPy will see the full underlying buffers, which may include
+        uninitialised elements.  Setting `full=True` is intended for
+        Python-space factory methods.  In all other use cases, `full=False` is
+        much less error prone.
+        """
+        # We store a reference to the scipy matrix not only for caching this
+        # relatively expensive method, but also because we transferred
+        # ownership of our data to the numpy arrays, and we can't allow them to
+        # be collected while we're alive.
+        if self._scipy is not None:
+            return self._scipy
+        cdef cnp.npy_intp length = self.size if full else nnz(self)
+        data = cnp.PyArray_SimpleNewFromData(1, [length],
+                                             cnp.NPY_COMPLEX128,
+                                             self.data)
+        indices = cnp.PyArray_SimpleNewFromData(1, [length],
+                                                base.idxint_DTYPE,
+                                                self.col_index)
+        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
+                                               base.idxint_DTYPE,
+                                               self.row_index)
+        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
+        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
+        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
+        self._deallocate = False
+        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
+        return self._scipy
+
+    cpdef CSR sort_indices(self):
+        cdef Sorter sort
+        cdef base.idxint ptr
+        cdef size_t row, diff, size=0
+        for row in range(self.shape[0]):
+            diff = self.row_index[row + 1] - self.row_index[row]
+            size = diff if diff > size else size
+        sort = Sorter(size)
+        for row in range(self.shape[0]):
+            ptr = self.row_index[row]
+            diff = self.row_index[row + 1] - ptr
+            sort.inplace(self, ptr, diff)
+        return self
+
+    cpdef double complex trace(self):
+        return trace_csr(self)
+
+    cpdef CSR adjoint(self):
+        return adjoint_csr(self)
+
+    cpdef CSR conj(self):
+        return conj_csr(self)
+
+    cpdef CSR transpose(self):
+        return transpose_csr(self)
+
+    def __repr__(self):
+        return "".join([
+            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
+        ])
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __dealloc__(self):
+        # If we have a reference to a scipy type, then we've passed ownership
+        # of the data to numpy, so we let it handle refcounting and we don't
+        # need to deallocate anything ourselves.
+        if not self._deallocate:
+            return
+        if self.data != NULL:
+            PyDataMem_FREE(self.data)
+        if self.col_index != NULL:
+            PyDataMem_FREE(self.col_index)
+        if self.row_index != NULL:
+            PyDataMem_FREE(self.row_index)
+
+
+cpdef CSR fast_from_scipy(object sci):
+    """
+    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
+    checking on any of the inputs, and should consequently be considered very
+    unsafe.  This is primarily for use in the unpickling operation.
+    """
+    cdef CSR out = CSR.__new__(CSR)
+    out.shape = sci.shape
+    out._deallocate = False
+    out._scipy = sci
+    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
+    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
+    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
+    out.size = cnp.PyArray_SIZE(sci.data)
+    return out
+
+
+cpdef CSR copy_structure(CSR matrix):
+    """
+    Return a copy of the input matrix with identical `col_index` and
+    `row_index` matrices, and an allocated, but empty, `data`.  The returned
+    pointers are all separately allocated, but contain the same information.
+
+    This is intended for unary functions on CSR types that maintain the exact
+    structure, but modify each non-zero data element without change their
+    location.
+    """
+    cdef CSR out = empty_like(matrix)
+    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
+    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
+    return out
+
+
+cpdef inline base.idxint nnz(CSR matrix) nogil:
+    """Get the number of non-zero elements of a CSR matrix."""
+    return matrix.row_index[matrix.shape[0]]
+
+
+cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
+    return i[0] < j[0]
+
+cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
+    return x.col < y.col
+
+ctypedef fused _swap_data:
+    double complex
+    base.idxint
+
+cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
+    a[0], b[0] = b[0], a[0]
+
+cdef class Sorter:
+    # Look on my works, ye mighty, and despair!
+    #
+    # This class has hard-coded sorts for up to three elements, for both
+    # copying and in-place varieties.  Everything above that we delegate to a
+    # proper sorting algorithm.
+    def __init__(self, size_t size):
+        self.size = size
+
+    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
+        cdef size_t n
+        cdef base.idxint col0, col1, col2
+        # Fast paths for tridiagonal matrices.  These fast paths minimise the
+        # number of comparisons and swaps made.
+        if size < 2:
+            return
+        if size == 2:
+            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+            return
+        if size == 3:
+            # Faster to store rather than re-dereference, and if someone
+            # changes the data underneath us, we've got larger problems anyway.
+            col0 = matrix.col_index[ptr]
+            col1 = matrix.col_index[ptr + 1]
+            col2 = matrix.col_index[ptr + 2]
+            if col0 < col1:
+                if col1 > col2:
+                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
+                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
+                    if col0 > col2:
+                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+            elif col1 < col2:
+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+                if col0 > col2:
+                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
+                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
+            else:
+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
+            return
+        # Now we actually have to do the sort properly.  It's easiest just to
+        # copy the data into a temporary structure.
+        if size > self.size or self.sort == NULL:
+            # realloc(NULL, size) is equivalent to malloc(size), so there's no
+            # problem if cols and argsort weren't allocated before.
+            self.size = size if size > self.size else self.size
+            with gil:
+                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
+                                                            self.size * sizeof(_data_col))
+        for n in range(size):
+            self.sort[n].data = matrix.data[ptr + n]
+            self.sort[n].col = matrix.col_index[ptr + n]
+        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
+        for n in range(size):
+            matrix.data[ptr + n] = self.sort[n].data
+            matrix.col_index[ptr + n] = self.sort[n].col
+
+    cdef void copy(self,
+                   double complex *dest_data, base.idxint *dest_cols,
+                   double complex *src_data, base.idxint *src_cols,
+                   size_t size) nogil:
+        cdef size_t n, ptr
+        # Fast paths for small sizes.  Not pretty, but it speeds things up a
+        # lot for up to triadiaongal systems (which are pretty common).
+        if size == 0:
+            return
+        if size == 1:
+            dest_cols[0] = src_cols[0]
+            dest_data[0] = src_data[0]
+            return
+        if size == 2:
+            if src_cols[0] < src_cols[1]:
+                dest_cols[0] = src_cols[0]
+                dest_data[0] = src_data[0]
+                dest_cols[1] = src_cols[1]
+                dest_data[1] = src_data[1]
+            else:
+                dest_cols[1] = src_cols[0]
+                dest_data[1] = src_data[0]
+                dest_cols[0] = src_cols[1]
+                dest_data[0] = src_data[1]
+            return
+        if size == 3:
+            if src_cols[0] < src_cols[1]:
+                if src_cols[0] < src_cols[2]:
+                    dest_cols[0] = src_cols[0]
+                    dest_data[0] = src_data[0]
+                    if src_cols[1] < src_cols[2]:
+                        dest_cols[1] = src_cols[1]
+                        dest_data[1] = src_data[1]
+                        dest_cols[2] = src_cols[2]
+                        dest_data[2] = src_data[2]
+                    else:
+                        dest_cols[2] = src_cols[1]
+                        dest_data[2] = src_data[1]
+                        dest_cols[1] = src_cols[2]
+                        dest_data[1] = src_data[2]
+                else:
+                    dest_cols[1] = src_cols[0]
+                    dest_data[1] = src_data[0]
+                    dest_cols[2] = src_cols[1]
+                    dest_data[2] = src_data[1]
+                    dest_cols[0] = src_cols[2]
+                    dest_data[0] = src_data[2]
+            elif src_cols[0] < src_cols[2]:
+                dest_cols[1] = src_cols[0]
+                dest_data[1] = src_data[0]
+                dest_cols[0] = src_cols[1]
+                dest_data[0] = src_data[1]
+                dest_cols[2] = src_cols[2]
+                dest_data[2] = src_data[2]
+            else:
+                dest_cols[2] = src_cols[0]
+                dest_data[2] = src_data[0]
+                if src_cols[1] < src_cols[2]:
+                    dest_cols[0] = src_cols[1]
+                    dest_data[0] = src_data[1]
+                    dest_cols[1] = src_cols[2]
+                    dest_data[1] = src_data[2]
+                else:
+                    dest_cols[1] = src_cols[1]
+                    dest_data[1] = src_data[1]
+                    dest_cols[0] = src_cols[2]
+                    dest_data[0] = src_data[2]
+            return
+        # Now we're left with the full case, and we have to sort properly.
+        if size > self.size or self.argsort == NULL:
+            # realloc(NULL, size) is equivalent to malloc(size), so there's no
+            # problem if cols and argsort weren't allocated before.
+            self.size = size if size > self.size else self.size
+            with gil:
+                self.argsort = (
+                    <base.idxint **>
+                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
+                )
+        # We do the argsort with two levels of indirection to minimise memory
+        # allocation and copying requirements when this function is being used
+        # to assemble a CSR matrix under an operation which may change the
+        # order of the columns (e.g. permute).  First the user makes the
+        # columns accessible in some contiguous memory (or if they're not
+        # changing them, they can just use the CSR buffers).  We put pointers
+        # to each of those columns in the array which actually gets sorted
+        # using a comparison function which dereferences the pointers and
+        # compares the result.  After the sort, `argsort` will be the pointers
+        # sorted according to the new column, and we know that the "lowest"
+        # pointer in there has the value `src_cols`, so we can do pointer
+        # arithmetic to know which element we should take.
+        #
+        # This is about 30-40% faster than allocating space for structs of
+        # (double complex, idxint), copying in the data and column, sorting and
+        # copying into the new arrays.  Allocating the structs actually
+        # allocates more space than the pointer method (double complex is
+        # very likely to be 2x the size of a pointer, _and_ the struct may need
+        # extra padding to be aligned), so it's probably actually worse for
+        # cache locality.  Despite the sort relying on pointer dereference in
+        # this case, it's actually got very good cache locality.
+        for n in range(size):
+            self.argsort[n] = src_cols + n
+        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
+        for n in range(size):
+            ptr = self.argsort[n] - src_cols
+            dest_cols[n] = src_cols[ptr]
+            dest_data[n] = src_data[ptr]
+
+    def __dealloc__(self):
+        if self.argsort != NULL:
+            mem.PyMem_Free(self.argsort)
+        if self.sort != NULL:
+            mem.PyMem_Free(self.sort)
+
+cpdef CSR sorted(CSR matrix):
+    cdef CSR out = empty_like(matrix)
+    cdef Sorter sort
+    cdef base.idxint ptr
+    cdef size_t row, diff, size=0
+    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
+    for row in range(matrix.shape[0]):
+        diff = matrix.row_index[row + 1] - matrix.row_index[row]
+        size = diff if diff > size else size
+    sort = Sorter(size)
+    for row in range(matrix.shape[0]):
+        ptr = matrix.row_index[row]
+        diff = matrix.row_index[row + 1] - ptr
+        sort.copy(out.data + ptr, out.col_index + ptr,
+                  matrix.data + ptr, matrix.col_index + ptr,
+                  diff)
+    return out
+
+
+cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
+    """
+    Allocate an empty CSR matrix of the given shape, with space for `size`
+    elements in the `data` and `col_index` arrays.
+
+    This does not initialise any of the memory returned, but sets the last
+    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
+    """
+    if size < 0:
+        raise ValueError("size must be a positive integer.")
+    # Python doesn't like allocating nothing.
+    if size == 0:
+        size += 1
+    cdef CSR out = CSR.__new__(CSR)
+    cdef base.idxint row_size = rows + 1
+    out.shape = (rows, cols)
+    out.size = size
+    out.data =\
+        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
+    out.col_index =\
+        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
+    out.row_index =\
+        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
+    # Set the number of non-zero elements to 0.
+    out.row_index[rows] = 0
+    return out
+
+
+cpdef CSR empty_like(CSR other):
+    return empty(other.shape[0], other.shape[1], nnz(other))
+
+
+cpdef CSR zeros(base.idxint rows, base.idxint cols):
+    """
+    Allocate the zero matrix with a given shape.  There will not be any room in
+    the `data` and `col_index` buffers to add new elements.
+    """
+    # We always allocate matrices with at least one element to ensure that we
+    # actually _are_ asking for memory (Python doesn't like allocating nothing)
+    cdef CSR out = empty(rows, cols, 1)
+    out.data[0] = out.col_index[0] = 0
+    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
+    return out
+
+
+cpdef CSR identity(base.idxint dimension, double complex scale=1):
+    """
+    Return a square matrix of the specified dimension, with a constant along
+    the diagonal.  By default this will be the identity matrix, but if `scale`
+    is passed, then the result will be `scale` times the identity.
+    """
+    cdef CSR out = empty(dimension, dimension, dimension)
+    cdef base.idxint i
+    for i in range(dimension):
+        out.data[i] = scale
+        out.col_index[i] = i
+        out.row_index[i] = i
+    out.row_index[dimension] = dimension
+    return out
+
+cpdef CSR from_dense(Dense matrix):
+    # Assume worst-case scenario for non-zero.
+    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
+                         matrix.shape[0]*matrix.shape[1])
+    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
+    row_stride = 1 if matrix.fortran else matrix.shape[1]
+    col_stride = matrix.shape[0] if matrix.fortran else 1
+    out.row_index[0] = 0
+    for row in range(matrix.shape[0]):
+        ptr_in = row_stride * row
+        for col in range(matrix.shape[1]):
+            if matrix.data[ptr_in] != 0:
+                out.data[ptr_out] = matrix.data[ptr_in]
+                out.col_index[ptr_out] = col
+                ptr_out += 1
+            ptr_in += col_stride
+        out.row_index[row + 1] = ptr_out
+    return out
+
+cdef CSR from_coo_pointers(
+    base.idxint *rows, base.idxint *cols, double complex *data,
+    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
+):
+    # Note that COO pointers may not be sorted in row-major order, and that
+    # they may contain duplicate entries which should be implicitly summed.
+    cdef Accumulator acc = acc_alloc(n_cols)
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    cdef double complex *data_tmp
+    cdef base.idxint *cols_tmp
+    cdef base.idxint row
+    cdef size_t ptr_in, ptr_out, ptr_prev
+    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
+    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
+    if data_tmp == NULL or cols_tmp == NULL:
+        raise MemoryError
+    with nogil:
+        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
+        for ptr_in in range(nnz):
+            out.row_index[rows[ptr_in] + 1] += 1
+        for ptr_out in range(n_rows):
+            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
+        # out.row_index is currently in the normal output form, but we're
+        # temporarily going to modify it to keep track of how many values we've
+        # placed in each row as we iterate through.  At every state,
+        # out.row_index[row] will contain a pointer to the next location that
+        # an element should be placed in this row.
+        for ptr_in in range(nnz):
+            row = rows[ptr_in]
+            ptr_out = out.row_index[row]
+            cols_tmp[ptr_out] = cols[ptr_in]
+            data_tmp[ptr_out] = data[ptr_in]
+            out.row_index[row] += 1
+        # Apply the scatter/gather pattern to find the actual number of
+        # non-zero elements we're writing into each row (since there's a sum,
+        # there may be some zeros of duplicates).  Remember we also need to
+        # shift the row_index array back to what it was before as well.
+        ptr_out = 0
+        ptr_prev = 0
+        for row in range(n_rows):
+            for ptr_in in range(ptr_prev, out.row_index[row]):
+                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
+            ptr_prev = out.row_index[row]
+            out.row_index[row] = ptr_out
+            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
+            acc_reset(&acc)
+        out.row_index[n_rows] = ptr_out
+    mem.PyMem_Free(data_tmp)
+    mem.PyMem_Free(cols_tmp)
+    acc_free(&acc)
+    return out
+
+
+cdef inline base.idxint _diagonal_length(
+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+) nogil:
+    if offset > 0:
+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+    return n_cols if offset > n_cols - n_rows else n_rows + offset
+
+cdef CSR diag(
+    double complex[:] diagonal, base.idxint offset,
+    base.idxint n_rows, base.idxint n_cols,
+):
+    """
+    Construct a CSR matrix with a single non-zero diagonal.
+
+    Parameters
+    ----------
+    diagonal : indexable of double complex
+        The entries (including zeros) that should be placed on the diagonal in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal.
+
+    offsets : idxint
+        The index of the diagonals.  An offset of 0 is the main diagonal,
+        positive values are above the main diagonal and negative ones are below
+        the main diagonal.
+
+    n_rows, n_cols : idxint
+        The shape of the output.  The result does not need to be square, but
+        the diagonal must be of the correct length to fit in.
+    """
+    if n_rows < 0 or n_cols < 0:
+        raise ValueError("shape must be positive")
+    cdef base.idxint nnz = len(diagonal)
+    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
+    if nnz != n_diag:
+        raise ValueError("incorrect number of diagonal elements")
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    cdef base.idxint start_row = 0 if offset >= 0 else -offset
+    cdef base.idxint col = 0 if offset <= 0 else offset
+    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
+    nnz = 0
+    for row in range(start_row + 1, start_row + n_diag + 1):
+        out.col_index[nnz] = col
+        out.data[nnz] = diagonal[nnz]
+        col += 1
+        nnz += 1
+        out.row_index[row] = nnz
+    for row in range(start_row + n_diag + 1, n_rows + 1):
+        out.row_index[row] = nnz
+    return out
+
+cdef CSR diags_(
+    list diagonals, base.idxint[:] offsets,
+    base.idxint n_rows, base.idxint n_cols,
+):
+    """
+    Construct a CSR matrix from a list of diagonals and their offsets.  The
+    offsets are assumed to be in sorted order.  This is the C-only interface to
+    csr.diags, and inputs are not sanity checked (use the Python interface for
+    that).
+
+    Parameters
+    ----------
+    diagonals : list of indexable of double complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal (not checked).
+
+    offsets : idxint[:]
+        The indices of the diagonals.  These should be sorted and without
+        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
+        An offset of 0 is the main diagonal, positive values are above the main
+        diagonal and negative ones are below the main diagonal.
+
+    n_rows, n_cols : idxint
+        The shape of the output.  The result does not need to be square, but
+        the diagonals must be of the correct length to fit in.
+    """
+    cdef size_t n_diagonals = len(diagonals)
+    if n_diagonals == 0:
+        return zeros(n_rows, n_cols)
+    cdef base.idxint k, row, start_row, offset, nnz=0,
+    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
+    cdef double complex value
+    for k in range(n_diagonals):
+        offset = offsets[k]
+        if offset >= 0 and min_k > k:
+            min_k = k
+        nnz += _diagonal_length(offset, n_rows, n_cols)
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    nnz = 0
+    out.row_index[0] = 0
+    for row in range(n_rows):
+        if min_k > 0:
+            offset = offsets[min_k - 1]
+            start_row = 0 if offset >= 0 else -offset
+            if start_row == row:
+                min_k -= 1
+        if max_k > 0:
+            offset = offsets[max_k - 1]
+            start_row = 0 if offset >= 0 else -offset
+            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
+                max_k -= 1
+        for k in range(min_k, max_k):
+            offset = offsets[k]
+            value = diagonals[k][row if offset >= 0 else row + offset]
+            if value == 0:
+                continue
+            out.data[nnz] = value
+            out.col_index[nnz] = row + offset
+            nnz += 1
+        out.row_index[row + 1] = nnz
+    return out
+
+@cython.wraparound(True)
+def diags(diagonals, offsets=None, shape=None):
+    """
+    Construct a CSR matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements.  Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    cdef base.idxint n_rows, n_cols, offset
+    try:
+        diagonals = list(diagonals)
+        if diagonals and np.isscalar(diagonals[0]):
+            # Catch the case where we're being called as (for example)
+            #   diags([1, 2, 3], 0)
+            # with a single diagonal and offset.
+            diagonals = [diagonals]
+    except TypeError:
+        raise TypeError("diagonals must be a list of arrays of complex") from None
+    if offsets is None:
+        if len(diagonals) == 0:
+            offsets = []
+        elif len(diagonals) == 1:
+            offsets = [0]
+        else:
+            raise TypeError("offsets must be supplied if passing more than one diagonal")
+    offsets = np.atleast_1d(offsets)
+    if offsets.ndim > 1:
+        raise ValueError("offsets must be a 1D array of integers")
+    if len(diagonals) != len(offsets):
+        raise ValueError("number of diagonals does not match number of offsets")
+    if len(diagonals) == 0:
+        if shape is None:
+            raise ValueError("cannot construct matrix with no diagonals without a shape")
+        else:
+            n_rows, n_cols = shape
+        return zeros(n_rows, n_cols)
+    order = np.argsort(offsets)
+    diagonals_ = []
+    offsets_ = []
+    prev, cur = None, None
+    for i in order:
+        cur = offsets[i]
+        if cur == prev:
+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+        else:
+            offsets_.append(cur)
+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+        prev = cur
+    if shape is None:
+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+    else:
+        try:
+            n_rows, n_cols = shape
+        except (TypeError, ValueError):
+            raise TypeError("shape must be a 2-tuple of positive integers")
+        if n_rows < 0 or n_cols < 0:
+            raise ValueError("shape must be a 2-tuple of positive integers")
+    for i in range(len(diagonals_)):
+        offset = offsets_[i]
+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+            raise ValueError("given diagonals do not have the correct lengths")
+    if n_rows == 0 and n_cols == 0:
+        raise ValueError("can't produce a 0x0 matrix")
+    if len(offsets) == 1:
+        # Fast path for a single diagonal.
+        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
+    return diags_(
+        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
+    )
+
+
+cpdef CSR _from_csr_blocks(
+    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+    base.idxint n_blocks, base.idxint block_size
+):
+    """
+    Construct a CSR from non-overlapping blocks.
+
+    Each operator in ``block_ops`` should be a square CSR operator with
+    shape ``(block_size, block_size)``. The output operator consists of
+    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
+    ``(n_blocks * block_size, n_blocks * block_size)``.
+
+    None of the operators should overlap (i.e. the list of block row and
+    column pairs should be unique).
+
+    Parameters
+    ----------
+    block_rows : sequence of base.idxint integers
+        The block row for each operator. The block row should be in
+        ``range(0, n_blocks)``.
+
+    block_cols : sequence of base.idxint integers
+        The block column for each operator. The block column should be in
+        ``range(0, n_blocks)``.
+
+    block_ops : sequence of CSR matrixes
+        The operators corresponding to the rows and columns in ``block_rows``
+        and ``block_cols``.
+
+    n_blocks : base.idxint
+        Number of blocks. The shape of the final matrix is
+        (n_blocks * block, n_blocks * block).
+
+    block_size : base.idxint
+        Size of each block. The shape of matrices in ``block_ops`` is
+        ``(block_size, block_size)``.
+    """
+    cdef CSR op
+    cdef base.idxint shape = n_blocks * block_size
+    cdef base.idxint nnz_ = 0
+    cdef base.idxint n_ops = len(block_ops)
+    cdef base.idxint i, j
+    cdef base.idxint row_idx, col_idx
+
+    # check arrays are the same length
+    if len(block_rows) != n_ops or len(block_cols) != n_ops:
+        raise ValueError(
+            "The arrays block_rows, block_cols and block_ops should have"
+            " the same length."
+        )
+
+    if n_ops == 0:
+        return zeros(shape, shape)
+
+    # check op shapes and calculate nnz
+    for op in block_ops:
+        nnz_ += nnz(op)
+        if op.shape[0] != block_size or op.shape[1] != block_size:
+            raise ValueError(
+                "Block operators (block_ops) do not have the correct shape."
+            )
+
+    # check ops are ordered by (row, column)
+    row_idx = block_rows[0]
+    col_idx = block_cols[0]
+    for i in range(1, n_ops):
+        if (
+            block_rows[i] < row_idx or
+            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
+        ):
+            raise ValueError(
+                "The arrays block_rows and block_cols must be sorted"
+                " by (row, column)."
+            )
+        row_idx = block_rows[i]
+        col_idx = block_cols[i]
+
+    if nnz_ == 0:
+        return zeros(shape, shape)
+
+    cdef CSR out = empty(shape, shape, nnz_)
+    cdef base.idxint op_idx = 0
+    cdef base.idxint prev_op_idx = 0
+    cdef base.idxint end = 0
+    cdef base.idxint row_pos, col_pos
+    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
+
+    out.row_index[0] = 0
+
+    for row_idx in range(n_blocks):
+        prev_op_idx = op_idx
+        while op_idx < n_ops:
+            if block_rows[op_idx] != row_idx:
+                break
+            op_idx += 1
+
+        row_pos = row_idx * block_size
+        for op_row in range(block_size):
+            for i in range(prev_op_idx, op_idx):
+                op = block_ops[i]
+                if nnz(op) == 0:
+                    # empty CSR matrices have uninitialized row_index entries.
+                    # it's unclear whether users should ever see such matrixes
+                    # but we support them here anyway.
+                    continue
+                col_idx = block_cols[i]
+                col_pos = col_idx * block_size
+                op_row_start = op.row_index[op_row]
+                op_row_end = op.row_index[op_row + 1]
+                op_row_len = op_row_end - op_row_start
+                for j in range(op_row_len):
+                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
+                    out.data[end + j] = op.data[op_row_start + j]
+                end += op_row_len
+            out.row_index[row_pos + op_row + 1] = end
+
+    return out
diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
index 3c3dad938a..354bf51045 100644
--- a/qutip/core/data/dense.pxd
+++ b/qutip/core/data/dense.pxd
@@ -1,30 +1,30 @@
-#cython: language_level=3
-
-cimport numpy as cnp
-
-from . cimport base
-from .csr cimport CSR
-
-cdef class Dense(base.Data):
-    cdef double complex *data
-    cdef bint fortran
-    cdef object _np
-    cdef bint _deallocate
-    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
-    cpdef Dense reorder(Dense self, int fortran=*)
-    cpdef Dense copy(Dense self)
-    cpdef object as_ndarray(Dense self)
-    cpdef object to_array(Dense self)
-    cpdef double complex trace(Dense self)
-    cpdef Dense adjoint(Dense self)
-    cpdef Dense conj(Dense self)
-    cpdef Dense transpose(Dense self)
-
-cpdef Dense fast_from_numpy(object array)
-cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
-cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
-cpdef Dense empty_like(Dense other, int fortran=*)
-cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
-cpdef Dense identity(base.idxint dimension, double complex scale=*,
-                     bint fortran=*)
-cpdef Dense from_csr(CSR matrix, bint fortran=*)
+#cython: language_level=3
+
+cimport numpy as cnp
+
+from . cimport base
+from .csr cimport CSR
+
+cdef class Dense(base.Data):
+    cdef double complex *data
+    cdef bint fortran
+    cdef object _np
+    cdef bint _deallocate
+    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
+    cpdef Dense reorder(Dense self, int fortran=*)
+    cpdef Dense copy(Dense self)
+    cpdef object as_ndarray(Dense self)
+    cpdef object to_array(Dense self)
+    cpdef double complex trace(Dense self)
+    cpdef Dense adjoint(Dense self)
+    cpdef Dense conj(Dense self)
+    cpdef Dense transpose(Dense self)
+
+cpdef Dense fast_from_numpy(object array)
+cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
+cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
+cpdef Dense empty_like(Dense other, int fortran=*)
+cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
+cpdef Dense identity(base.idxint dimension, double complex scale=*,
+                     bint fortran=*)
+cpdef Dense from_csr(CSR matrix, bint fortran=*)
diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
index 38c32f5bb8..f16578b4ba 100644
--- a/qutip/core/data/dense.pyx
+++ b/qutip/core/data/dense.pyx
@@ -1,409 +1,409 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memcpy
-cimport cython
-
-import numbers
-
-import numpy as np
-cimport numpy as cnp
-from scipy.linalg cimport cython_blas as blas
-
-from .base import EfficiencyWarning
-from qutip.core.data cimport base, CSR
-from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
-from qutip.core.data.trace cimport trace_dense
-
-cnp.import_array()
-
-cdef int _ONE = 1
-
-cdef extern from *:
-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
-    void *PyDataMem_NEW(size_t size)
-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-    void PyDataMem_FREE(void *ptr)
-
-
-# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
-# to avoid naming clashes with other type modules.
-__all__ = [
-    'Dense', 'OrderEfficiencyWarning',
-]
-
-
-class OrderEfficiencyWarning(EfficiencyWarning):
-    pass
-
-
-cdef class Dense(base.Data):
-    def __init__(self, data, shape=None, copy=True):
-        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
-        # Ensure that the array is contiguous.
-        # Non contiguous array with copy=False would otherwise slip through
-        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
-                cnp.PyArray_IS_F_CONTIGUOUS(base)):
-            base = base.copy()
-        if shape is None:
-            shape = base.shape
-            if len(shape) == 0:
-                shape = (1, 1)
-            # Promote to a ket by default if passed 1D data.
-            if len(shape) == 1:
-                shape = (shape[0], 1)
-        if not (
-            len(shape) == 2
-            and isinstance(shape[0], numbers.Integral)
-            and isinstance(shape[1], numbers.Integral)
-            and shape[0] > 0
-            and shape[1] > 0
-        ):
-            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
-        if shape[0] * shape[1] != base.size:
-            raise ValueError("".join([
-                "invalid shape ",
-                str(shape),
-                " for input data with size ",
-                str(base.size)
-            ]))
-        self._np = base.reshape(shape, order='A')
-        self._deallocate = False
-        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
-        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
-        self.shape = (shape[0], shape[1])
-
-    def __reduce__(self):
-        return (fast_from_numpy, (self.as_ndarray(),))
-
-    def __repr__(self):
-        return "".join([
-            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
-        ])
-
-    def __str__(self):
-        return self.__repr__()
-
-    cpdef Dense reorder(self, int fortran=-1):
-        cdef bint fortran_
-        if fortran < 0:
-            fortran_ = not self.fortran
-        else:
-            fortran_ = fortran
-        if bool(fortran_) == bool(self.fortran):
-            return self.copy()
-        cdef Dense out = empty_like(self, fortran_)
-        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
-        stride = self.shape[1] if self.fortran else self.shape[0]
-        splits = self.shape[0] if self.fortran else self.shape[1]
-        for idx_out_start in range(stride):
-            idx_out = idx_out_start
-            for _ in range(splits):
-                out.data[idx_out] = self.data[idx_self]
-                idx_self += 1
-                idx_out += stride
-        return out
-
-    cpdef Dense copy(self):
-        """
-        Return a complete (deep) copy of this object.
-
-        If the type currently has a numpy backing, such as that produced by
-        `as_ndarray`, this will not be copied.  The backing is a view onto our
-        data, and a straight copy of this view would be incorrect.  We do not
-        create a new view at copy time, since the user may only access this
-        through a creation method, and creating it ahead of time would incur an
-        unnecessary speed penalty for users who do not need it (including
-        low-level C code).
-        """
-        cdef Dense out = Dense.__new__(Dense)
-        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
-        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
-        memcpy(ptr, self.data, size)
-        out.shape = self.shape
-        out.data = ptr
-        out.fortran = self.fortran
-        out._deallocate = True
-        return out
-
-    cdef void _fix_flags(self, object array, bint make_owner=False):
-        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
-        cdef int disable = 0
-        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
-        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
-        # Not necessary when creating a new array because this will already
-        # have been done, but needed for as_ndarray() if we have been mutated.
-        dims[0] = self.shape[0]
-        dims[1] = self.shape[1]
-        if self.shape[0] == 1 or self.shape[1] == 1:
-            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
-            strides[0] = self.shape[1] * sizeof(double complex)
-            strides[1] = sizeof(double complex)
-        elif self.fortran:
-            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
-            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
-            strides[0] = sizeof(double complex)
-            strides[1] = self.shape[0] * sizeof(double complex)
-        else:
-            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
-            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
-            strides[0] = self.shape[1] * sizeof(double complex)
-            strides[1] = sizeof(double complex)
-        PyArray_ENABLEFLAGS(array, enable)
-        PyArray_CLEARFLAGS(array, disable)
-
-    cpdef object to_array(self):
-        """
-        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
-        be Fortran or C-ordered, but will be contiguous in one of the
-        dimensions.  This is not a view onto the data, and changes to new array
-        will not affect the original data structure.
-        """
-        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
-        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
-        memcpy(ptr, self.data, size)
-        cdef object out =\
-            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
-                                          cnp.NPY_COMPLEX128, ptr)
-        self._fix_flags(out, make_owner=True)
-        return out
-
-    cpdef object as_ndarray(self):
-        """
-        Get a view onto this object as a `numpy.ndarray`.  The underlying data
-        structure is exposed, such that modifications to the array will modify
-        this object too.
-
-        The array may be uninitialised, depending on how the Dense type was
-        created.  The output will be contiguous and of dtype 'complex128', but
-        may be C- or Fortran-ordered.
-        """
-        if self._np is not None:
-            # We have to do this every time in case someone has changed our
-            # ordering or shape inplace.
-            self._fix_flags(self._np, make_owner=False)
-            return self._np
-        self._np =\
-            cnp.PyArray_SimpleNewFromData(
-                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
-            )
-        self._fix_flags(self._np, make_owner=self._deallocate)
-        self._deallocate = False
-        return self._np
-
-    cpdef double complex trace(self):
-        return trace_dense(self)
-
-    cpdef Dense adjoint(self):
-        return adjoint_dense(self)
-
-    cpdef Dense conj(self):
-        return conj_dense(self)
-
-    cpdef Dense transpose(self):
-        return transpose_dense(self)
-
-    def __dealloc__(self):
-        if self._deallocate and self.data != NULL:
-            PyDataMem_FREE(self.data)
-
-
-cpdef Dense fast_from_numpy(object array):
-    """
-    Fast path construction from numpy ndarray.  This does _no_ type checking on
-    the input, and should consequently be considered very unsafe.  This is
-    primarily for use in the unpickling operation.
-    """
-    cdef Dense out = Dense.__new__(Dense)
-    if array.ndim == 1:
-        out.shape = (array.shape[0], 1)
-        array = array[:, None]
-    else:
-        out.shape = (array.shape[0], array.shape[1])
-    out._deallocate = False
-    out._np = array
-    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
-    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
-    return out
-
-cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
-    cdef Dense out = Dense.__new__(Dense)
-    out.data = data
-    out._deallocate = False
-    out.fortran = fortran or cols == 1 or rows == 1
-    out.shape = (rows, cols)
-    return out
-
-
-cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
-    """
-    Return a new Dense type of the given shape, with the data allocated but
-    uninitialised.
-    """
-    cdef Dense out = Dense.__new__(Dense)
-    out.shape = (rows, cols)
-    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
-    out._deallocate = True
-    out.fortran = fortran
-    return out
-
-
-cpdef Dense empty_like(Dense other, int fortran=-1):
-    cdef bint fortran_
-    if fortran < 0:
-        fortran_ = other.fortran
-    else:
-        fortran_ = fortran
-    return empty(other.shape[0], other.shape[1], fortran=fortran_)
-
-
-cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
-    """Return the zero matrix with the given shape."""
-    cdef Dense out = Dense.__new__(Dense)
-    out.shape = (rows, cols)
-    out.data =\
-        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
-    out.fortran = fortran
-    out._deallocate = True
-    return out
-
-
-cpdef Dense identity(base.idxint dimension, double complex scale=1,
-                     bint fortran=True):
-    """
-    Return a square matrix of the specified dimension, with a constant along
-    the diagonal.  By default this will be the identity matrix, but if `scale`
-    is passed, then the result will be `scale` times the identity.
-    """
-    cdef size_t row
-    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
-    for row in range(dimension):
-        out.data[row*dimension + row] = scale
-    return out
-
-
-cpdef Dense from_csr(CSR matrix, bint fortran=False):
-    cdef Dense out = Dense.__new__(Dense)
-    out.shape = matrix.shape
-    out.data = (
-        <double complex *>
-        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
-    )
-    out.fortran = fortran
-    out._deallocate = True
-    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
-    row_stride = 1 if fortran else out.shape[1]
-    col_stride = out.shape[0] if fortran else 1
-    ptr_out = 0
-    for row in range(out.shape[0]):
-        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
-            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
-        ptr_out += row_stride
-    return out
-
-
-cdef inline base.idxint _diagonal_length(
-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-) nogil:
-    if offset > 0:
-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-    return n_cols if offset > n_cols - n_rows else n_rows + offset
-
-
-@cython.wraparound(True)
-def diags(diagonals, offsets=None, shape=None):
-    """
-    Construct a matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements. Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    cdef base.idxint n_rows, n_cols, offset
-    try:
-        diagonals = list(diagonals)
-        if diagonals and np.isscalar(diagonals[0]):
-            # Catch the case where we're being called as (for example)
-            #   diags([1, 2, 3], 0)
-            # with a single diagonal and offset.
-            diagonals = [diagonals]
-    except TypeError:
-        raise TypeError("diagonals must be a list of arrays of complex") from None
-    if offsets is None:
-        if len(diagonals) == 0:
-            offsets = []
-        elif len(diagonals) == 1:
-            offsets = [0]
-        else:
-            raise TypeError("offsets must be supplied if passing more than one diagonal")
-    offsets = np.atleast_1d(offsets)
-    if offsets.ndim > 1:
-        raise ValueError("offsets must be a 1D array of integers")
-    if len(diagonals) != len(offsets):
-        raise ValueError("number of diagonals does not match number of offsets")
-    if len(diagonals) == 0:
-        if shape is None:
-            raise ValueError("cannot construct matrix with no diagonals without a shape")
-        else:
-            n_rows, n_cols = shape
-        return zeros(n_rows, n_cols)
-    order = np.argsort(offsets)
-    diagonals_ = []
-    offsets_ = []
-    prev, cur = None, None
-    for i in order:
-        cur = offsets[i]
-        if cur == prev:
-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-        else:
-            offsets_.append(cur)
-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-        prev = cur
-    if shape is None:
-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-    else:
-        try:
-            n_rows, n_cols = shape
-        except (TypeError, ValueError):
-            raise TypeError("shape must be a 2-tuple of positive integers")
-        if n_rows < 0 or n_cols < 0:
-            raise ValueError("shape must be a 2-tuple of positive integers")
-    for i in range(len(diagonals_)):
-        offset = offsets_[i]
-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-            raise ValueError("given diagonals do not have the correct lengths")
-    if n_rows == 0 and n_cols == 0:
-        raise ValueError("can't produce a 0x0 matrix")
-
-    out = zeros(n_rows, n_cols, fortran=True)
-
-    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
-
-    for diag_idx in range(n_diagonals):
-        offset = offsets_[diag_idx]
-        if offset <= 0:
-            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
-                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
-        else:
-            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
-                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
-    return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memcpy
+cimport cython
+
+import numbers
+
+import numpy as np
+cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
+
+from .base import EfficiencyWarning
+from qutip.core.data cimport base, CSR
+from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
+from qutip.core.data.trace cimport trace_dense
+
+cnp.import_array()
+
+cdef int _ONE = 1
+
+cdef extern from *:
+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
+    void *PyDataMem_NEW(size_t size)
+    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
+    void PyDataMem_FREE(void *ptr)
+
+
+# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
+# to avoid naming clashes with other type modules.
+__all__ = [
+    'Dense', 'OrderEfficiencyWarning',
+]
+
+
+class OrderEfficiencyWarning(EfficiencyWarning):
+    pass
+
+
+cdef class Dense(base.Data):
+    def __init__(self, data, shape=None, copy=True):
+        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
+        # Ensure that the array is contiguous.
+        # Non contiguous array with copy=False would otherwise slip through
+        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
+                cnp.PyArray_IS_F_CONTIGUOUS(base)):
+            base = base.copy()
+        if shape is None:
+            shape = base.shape
+            if len(shape) == 0:
+                shape = (1, 1)
+            # Promote to a ket by default if passed 1D data.
+            if len(shape) == 1:
+                shape = (shape[0], 1)
+        if not (
+            len(shape) == 2
+            and isinstance(shape[0], numbers.Integral)
+            and isinstance(shape[1], numbers.Integral)
+            and shape[0] > 0
+            and shape[1] > 0
+        ):
+            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
+        if shape[0] * shape[1] != base.size:
+            raise ValueError("".join([
+                "invalid shape ",
+                str(shape),
+                " for input data with size ",
+                str(base.size)
+            ]))
+        self._np = base.reshape(shape, order='A')
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
+        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
+        self.shape = (shape[0], shape[1])
+
+    def __reduce__(self):
+        return (fast_from_numpy, (self.as_ndarray(),))
+
+    def __repr__(self):
+        return "".join([
+            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
+        ])
+
+    def __str__(self):
+        return self.__repr__()
+
+    cpdef Dense reorder(self, int fortran=-1):
+        cdef bint fortran_
+        if fortran < 0:
+            fortran_ = not self.fortran
+        else:
+            fortran_ = fortran
+        if bool(fortran_) == bool(self.fortran):
+            return self.copy()
+        cdef Dense out = empty_like(self, fortran_)
+        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
+        stride = self.shape[1] if self.fortran else self.shape[0]
+        splits = self.shape[0] if self.fortran else self.shape[1]
+        for idx_out_start in range(stride):
+            idx_out = idx_out_start
+            for _ in range(splits):
+                out.data[idx_out] = self.data[idx_self]
+                idx_self += 1
+                idx_out += stride
+        return out
+
+    cpdef Dense copy(self):
+        """
+        Return a complete (deep) copy of this object.
+
+        If the type currently has a numpy backing, such as that produced by
+        `as_ndarray`, this will not be copied.  The backing is a view onto our
+        data, and a straight copy of this view would be incorrect.  We do not
+        create a new view at copy time, since the user may only access this
+        through a creation method, and creating it ahead of time would incur an
+        unnecessary speed penalty for users who do not need it (including
+        low-level C code).
+        """
+        cdef Dense out = Dense.__new__(Dense)
+        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
+        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+        memcpy(ptr, self.data, size)
+        out.shape = self.shape
+        out.data = ptr
+        out.fortran = self.fortran
+        out._deallocate = True
+        return out
+
+    cdef void _fix_flags(self, object array, bint make_owner=False):
+        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
+        cdef int disable = 0
+        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
+        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
+        # Not necessary when creating a new array because this will already
+        # have been done, but needed for as_ndarray() if we have been mutated.
+        dims[0] = self.shape[0]
+        dims[1] = self.shape[1]
+        if self.shape[0] == 1 or self.shape[1] == 1:
+            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
+            strides[0] = self.shape[1] * sizeof(double complex)
+            strides[1] = sizeof(double complex)
+        elif self.fortran:
+            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
+            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
+            strides[0] = sizeof(double complex)
+            strides[1] = self.shape[0] * sizeof(double complex)
+        else:
+            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
+            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
+            strides[0] = self.shape[1] * sizeof(double complex)
+            strides[1] = sizeof(double complex)
+        PyArray_ENABLEFLAGS(array, enable)
+        PyArray_CLEARFLAGS(array, disable)
+
+    cpdef object to_array(self):
+        """
+        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
+        be Fortran or C-ordered, but will be contiguous in one of the
+        dimensions.  This is not a view onto the data, and changes to new array
+        will not affect the original data structure.
+        """
+        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
+        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+        memcpy(ptr, self.data, size)
+        cdef object out =\
+            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
+                                          cnp.NPY_COMPLEX128, ptr)
+        self._fix_flags(out, make_owner=True)
+        return out
+
+    cpdef object as_ndarray(self):
+        """
+        Get a view onto this object as a `numpy.ndarray`.  The underlying data
+        structure is exposed, such that modifications to the array will modify
+        this object too.
+
+        The array may be uninitialised, depending on how the Dense type was
+        created.  The output will be contiguous and of dtype 'complex128', but
+        may be C- or Fortran-ordered.
+        """
+        if self._np is not None:
+            # We have to do this every time in case someone has changed our
+            # ordering or shape inplace.
+            self._fix_flags(self._np, make_owner=False)
+            return self._np
+        self._np =\
+            cnp.PyArray_SimpleNewFromData(
+                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
+            )
+        self._fix_flags(self._np, make_owner=self._deallocate)
+        self._deallocate = False
+        return self._np
+
+    cpdef double complex trace(self):
+        return trace_dense(self)
+
+    cpdef Dense adjoint(self):
+        return adjoint_dense(self)
+
+    cpdef Dense conj(self):
+        return conj_dense(self)
+
+    cpdef Dense transpose(self):
+        return transpose_dense(self)
+
+    def __dealloc__(self):
+        if self._deallocate and self.data != NULL:
+            PyDataMem_FREE(self.data)
+
+
+cpdef Dense fast_from_numpy(object array):
+    """
+    Fast path construction from numpy ndarray.  This does _no_ type checking on
+    the input, and should consequently be considered very unsafe.  This is
+    primarily for use in the unpickling operation.
+    """
+    cdef Dense out = Dense.__new__(Dense)
+    if array.ndim == 1:
+        out.shape = (array.shape[0], 1)
+        array = array[:, None]
+    else:
+        out.shape = (array.shape[0], array.shape[1])
+    out._deallocate = False
+    out._np = array
+    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
+    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
+    return out
+
+cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
+    cdef Dense out = Dense.__new__(Dense)
+    out.data = data
+    out._deallocate = False
+    out.fortran = fortran or cols == 1 or rows == 1
+    out.shape = (rows, cols)
+    return out
+
+
+cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
+    """
+    Return a new Dense type of the given shape, with the data allocated but
+    uninitialised.
+    """
+    cdef Dense out = Dense.__new__(Dense)
+    out.shape = (rows, cols)
+    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
+    out._deallocate = True
+    out.fortran = fortran
+    return out
+
+
+cpdef Dense empty_like(Dense other, int fortran=-1):
+    cdef bint fortran_
+    if fortran < 0:
+        fortran_ = other.fortran
+    else:
+        fortran_ = fortran
+    return empty(other.shape[0], other.shape[1], fortran=fortran_)
+
+
+cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
+    """Return the zero matrix with the given shape."""
+    cdef Dense out = Dense.__new__(Dense)
+    out.shape = (rows, cols)
+    out.data =\
+        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
+    out.fortran = fortran
+    out._deallocate = True
+    return out
+
+
+cpdef Dense identity(base.idxint dimension, double complex scale=1,
+                     bint fortran=True):
+    """
+    Return a square matrix of the specified dimension, with a constant along
+    the diagonal.  By default this will be the identity matrix, but if `scale`
+    is passed, then the result will be `scale` times the identity.
+    """
+    cdef size_t row
+    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
+    for row in range(dimension):
+        out.data[row*dimension + row] = scale
+    return out
+
+
+cpdef Dense from_csr(CSR matrix, bint fortran=False):
+    cdef Dense out = Dense.__new__(Dense)
+    out.shape = matrix.shape
+    out.data = (
+        <double complex *>
+        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
+    )
+    out.fortran = fortran
+    out._deallocate = True
+    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
+    row_stride = 1 if fortran else out.shape[1]
+    col_stride = out.shape[0] if fortran else 1
+    ptr_out = 0
+    for row in range(out.shape[0]):
+        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
+            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
+        ptr_out += row_stride
+    return out
+
+
+cdef inline base.idxint _diagonal_length(
+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+) nogil:
+    if offset > 0:
+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+    return n_cols if offset > n_cols - n_rows else n_rows + offset
+
+
+@cython.wraparound(True)
+def diags(diagonals, offsets=None, shape=None):
+    """
+    Construct a matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements. Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    cdef base.idxint n_rows, n_cols, offset
+    try:
+        diagonals = list(diagonals)
+        if diagonals and np.isscalar(diagonals[0]):
+            # Catch the case where we're being called as (for example)
+            #   diags([1, 2, 3], 0)
+            # with a single diagonal and offset.
+            diagonals = [diagonals]
+    except TypeError:
+        raise TypeError("diagonals must be a list of arrays of complex") from None
+    if offsets is None:
+        if len(diagonals) == 0:
+            offsets = []
+        elif len(diagonals) == 1:
+            offsets = [0]
+        else:
+            raise TypeError("offsets must be supplied if passing more than one diagonal")
+    offsets = np.atleast_1d(offsets)
+    if offsets.ndim > 1:
+        raise ValueError("offsets must be a 1D array of integers")
+    if len(diagonals) != len(offsets):
+        raise ValueError("number of diagonals does not match number of offsets")
+    if len(diagonals) == 0:
+        if shape is None:
+            raise ValueError("cannot construct matrix with no diagonals without a shape")
+        else:
+            n_rows, n_cols = shape
+        return zeros(n_rows, n_cols)
+    order = np.argsort(offsets)
+    diagonals_ = []
+    offsets_ = []
+    prev, cur = None, None
+    for i in order:
+        cur = offsets[i]
+        if cur == prev:
+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+        else:
+            offsets_.append(cur)
+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+        prev = cur
+    if shape is None:
+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+    else:
+        try:
+            n_rows, n_cols = shape
+        except (TypeError, ValueError):
+            raise TypeError("shape must be a 2-tuple of positive integers")
+        if n_rows < 0 or n_cols < 0:
+            raise ValueError("shape must be a 2-tuple of positive integers")
+    for i in range(len(diagonals_)):
+        offset = offsets_[i]
+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+            raise ValueError("given diagonals do not have the correct lengths")
+    if n_rows == 0 and n_cols == 0:
+        raise ValueError("can't produce a 0x0 matrix")
+
+    out = zeros(n_rows, n_cols, fortran=True)
+
+    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
+
+    for diag_idx in range(n_diagonals):
+        offset = offsets_[diag_idx]
+        if offset <= 0:
+            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
+                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
+        else:
+            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
+                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
+    return out
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index e8abebd7bc..276477b4d9 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -1,583 +1,583 @@
-#cython: language_level=3
-
-import functools
-import inspect
-import itertools
-import warnings
-
-from .convert import to as _to
-
-cimport cython
-from libc cimport math
-from libcpp cimport bool
-
-__all__ = ['Dispatcher']
-
-cdef class _bind:
-    """
-    Cythonised implementation of inspect.Signature.bind, supporting faster
-    binding and handling of default arguments.  On construction, the signature
-    of the base function is extracted, and all parameters are parsed into
-    positional or keyword slots, using positional wherever possible, and their
-    defaults are stored.
-    """
-    # Instance of inpsect.Signature representing the function.
-    cdef object signature
-    cdef object inputs
-    # Mapping of (str: int), where str is the name of any argument which may be
-    # specified by a keyword, and int is its location in `self._pos` if
-    # available, or -1 if it is keyword-only.
-    cdef dict _locations
-    # Default values (or inspect.Parameter.empty) for every parameter which
-    # may be passed as a positional argument.
-    cdef list _pos
-    # For each dispatcher input which can be given as a positional argument,
-    # these two lists hold the index of the input in the given tuple of input
-    # names and the corresponding index into the positional arguments after
-    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
-    # effectively the same mapping as _kw_inputs (but for positional
-    # arguments), but we use two lists rather than a dictionary for speed.
-    cdef list _pos_inputs_input, _pos_inputs_pos
-    # Default values (or inspect.Parameter.empty) for every parameter which
-    # _must_ be passed as a keyword argument.
-    cdef dict _kw
-    # Mapping of (name, index into the input tuple) for each input which must
-    # be specified as a keyword argument
-    cdef list _kw_inputs
-    # Names of the keyword arguments which have default values.
-    cdef set _default_kw_names
-    # Respectively, numbers of positional parameters, keyword-only parameters
-    # and dispatcher inputs.
-    cdef Py_ssize_t n_args, n_kwargs, n_inputs
-    # Respectively, numbers of inputs which are positional and keyword-only.
-    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
-    # Respectively, numbers of positional arguments without a default, and
-    # number of keyword-only arguments which _have_ a default.
-    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
-
-
-    def __init__(self, signature, tuple inputs):
-        for arg in inputs:
-            if arg not in signature.parameters:
-                raise AttributeError("No argument matches '{}'.".format(arg))
-        self.signature = signature
-        self.inputs = inputs
-        self._locations = {}
-        self._pos = []
-        self._pos_inputs_input = []
-        self._pos_inputs_pos = []
-        self._kw = {}
-        self._kw_inputs = []
-        self._default_kw_names = set()
-        self._n_pos_no_default = 0
-        # signature.parameters is ordered for all Python versions.
-        for i, (name, parameter) in enumerate(signature.parameters.items()):
-            kind = parameter.kind
-            if (kind == parameter.VAR_POSITIONAL
-                    or kind == parameter.VAR_KEYWORD):
-                raise TypeError("Cannot dispatch with *args or **kwargs.")
-            if kind == parameter.KEYWORD_ONLY:
-                self._kw[name] = parameter.default
-                self._locations[name] = -1
-                if parameter.default is not parameter.empty:
-                    self._default_kw_names.add(name)
-                if name in inputs:
-                    self._kw_inputs.append((name, inputs.index(name)))
-            else:
-                self._pos.append(parameter.default)
-                if kind != parameter.POSITIONAL_ONLY:
-                    self._locations[name] = i
-                if parameter.default is parameter.empty:
-                    self._n_pos_no_default += 1
-                if name in inputs:
-                    # Effectively a mapping.
-                    self._pos_inputs_input.append(inputs.index(name))
-                    self._pos_inputs_pos.append(len(self._pos) - 1)
-        self.n_args = len(self._pos)
-        self.n_kwargs = len(self._kw)
-        self.n_inputs = len(inputs)
-        self._n_pos_inputs = len(self._pos_inputs_input)
-        self._n_kw_inputs = len(self._kw_inputs)
-        self._n_kw_default = len(self._default_kw_names)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef tuple bind(self, tuple args, dict kwargs):
-        """
-        Cython reimplementation of inspect.Signature.bind for binding the
-        collected `*args` and `**kwargs` of a generic call to a specific
-        signature, checking that everything matches.
-
-        The output is a parsed tuple (args, kwargs), where `args` is a list and
-        `kwargs` is a dict, however all arguments which _can_ be passed
-        positionally will be moved from `kwargs` into `args` for the output.
-        The resultant `args` and `kwargs` can be unpacked into the underlying
-        function call safely.  Default values are not filled in by this method.
-
-        This is necessary to allow a generic `Dispatcher` class to work with
-        all type signatures.  The result of this function can be fed to
-        `_bind.convert_types` and `_bind.dispatch_types`.
-        """
-        cdef Py_ssize_t location, got_pos=0, got_kw=0
-        cdef Py_ssize_t n_passed_args = len(args)
-        if n_passed_args > self.n_args:
-            raise TypeError(
-                "Too many arguments: expected at most {} but received {}."
-                .format(n_passed_args, self.n_args)
-            )
-        # _pos and _kw are filled with their defaults at initialisation, and
-        # _pos is already the correct length (no-default parameters have
-        # sentinel values).
-        cdef list out_pos = self._pos.copy()
-        cdef dict out_kw = self._kw.copy()
-        got_pos = self.n_args - self._n_pos_no_default
-        got_kw = self._n_kw_default
-        # Positional arguments unambiguously fill the first positional slots.
-        for location in range(n_passed_args):
-            out_pos[location] = args[location]
-        # How many arguments that we didn't have defaults for did we just get?
-        # Positionals with a default are always after those without one.
-        if n_passed_args > self._n_pos_no_default:
-            got_pos += self._n_pos_no_default
-        else:
-            got_pos += n_passed_args
-        # Everything else has been passed by keyword, but it may be allowed to
-        # be passed positionally, which is the case we prefer.  dict.items() is
-        # (relatively) expensive, so we use a boolean test for the fast path.
-        cdef str kw
-        cdef object arg
-        if kwargs:
-            for kw, arg in kwargs.items():
-                try:
-                    location = self._locations[kw]
-                except KeyError:
-                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
-                # _locations[kw] = -1 if kw is keyword-only, otherwise the
-                # corresponding positional location.
-                if location >= 0:
-                    if location < n_passed_args:
-                        raise TypeError("Multiple values for '{}'".format(kw))
-                    out_pos[location] = arg
-                    if location < self._n_pos_no_default:
-                        got_pos += 1
-                else:
-                    out_kw[kw] = arg
-                    if kw not in self._default_kw_names:
-                        got_kw += 1
-        if got_pos < self.n_args:
-            raise TypeError("Too few positional arguments passed.")
-        if got_kw < self.n_kwargs:
-            raise TypeError("Not all keyword arguments were filled.")
-        return out_pos, out_kw
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef list dispatch_types(self, list args, dict kwargs):
-        """
-        Get a list of the types which the dispatch should operate over, given
-        the output of `_bind.bind`.  The return value is a list of the _input_
-        types to be dispatched on, in order that they were specified at
-        `Dispatcher` creation.  The output type is not returned as part of this
-        list, because there is no way for `_bind` to know it.
-        """
-        cdef list dispatch = [None] * self.n_inputs
-        cdef str kw
-        cdef Py_ssize_t location, i
-        for location in range(self._n_pos_inputs):
-            dispatch[self._pos_inputs_input[location]]\
-                = type(args[self._pos_inputs_pos[location]])
-        for i in range(self._n_kw_inputs):
-            kw, location = self._kw_inputs[i]
-            dispatch[location] = type(kwargs[kw])
-        return dispatch
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
-        """
-        Apply the type converters `converters` to the parsed arguments `args`
-        and `kwargs`.
-
-        If there are `n` inputs which are dispatched on, `converters` should be
-        a tuple whose first `n` elements are converters (such as those obtained
-        from `data.to[to_type, from_type]`) to the desired types.
-
-        `args` and `kwargs` should be the output of `_bind.bind`; the function
-        will likely fail if called on unparsed arguments.
-        """
-        cdef str kw
-        cdef Py_ssize_t location, i
-        for location in range(self._n_pos_inputs):
-            args[location] = converters[location](args[location])
-        for i in range(self._n_kw_inputs):
-            kw, location = self._kw_inputs[i]
-            kwargs[kw] = converters[location](kwargs[kw])
-        return args, kwargs
-
-
-cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
-    """
-    Find the total weight of conversion if the types in `froms` are converted
-    element-wise to the types in `tos`.  `weight_map` is a mapping of
-    `(to_type, from_type): real`; it should almost certainly be
-    `data.to.weight`.
-    """
-    cdef double weight = 0.0
-    cdef Py_ssize_t i, n=len(froms)
-    if len(tos) != n:
-        raise ValueError(
-            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
-        )
-    if out:
-        n = n - 1
-        weight += weight_map[froms[n], tos[n]]
-    for i in range(n):
-        weight += weight_map[tos[i], froms[i]]
-    return weight
-
-
-cdef class _constructed_specialisation:
-    """
-    Callable object providing the specialisation of a data-layer operation for
-    a particular set of types (`self.types`).  This may or may not involve
-    conversion of the input types and the output to match a known
-    specialisation; if it has no conversions, `self.direct` will be `True`,
-    otherwise it will be `False`.
-
-    See `self.__signature__` or `self.__text_signature__` for the call
-    signature of this object.
-    """
-    cdef _bind _parameters
-    cdef bint _output
-    cdef object _call
-    cdef Py_ssize_t _n_dispatch
-    cdef readonly tuple types
-    cdef tuple _converters
-    cdef str _short_name
-    cdef public str __doc__
-    cdef public str __name__
-    cdef public str __module__
-    cdef public object __signature__
-    cdef readonly str __text_signature__
-    cdef readonly bint direct
-
-    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
-                 direct):
-        self.__doc__ = inspect.getdoc(dispatcher)
-        self._short_name = dispatcher.__name__
-        self.__name__ = (
-            self._short_name
-            + "_"
-            + "_".join([x.__name__ for x in types])
-        )
-        self.__module__ = dispatcher.__module__
-        self.__signature__ = dispatcher.__signature__
-        self.__text_signature__ = dispatcher.__text_signature__
-        self._parameters = dispatcher._parameters
-        self._output = out
-        self._call = base
-        self._n_dispatch = len(types)
-        self.types = types
-        self.direct = direct
-        self._converters = converters
-
-    cdef object prebound(self, list args, dict kwargs):
-        """
-        Call this specialisation with pre-parsed arguments and keyword
-        arguments.  `args` and `kwargs` must be the output of the relevant
-        `_bind.bind` method for this function.
-        """
-        self._parameters.convert_types(args, kwargs, self._converters)
-        out = self._call(*args, **kwargs)
-        if self._output:
-            out = self._converters[self._n_dispatch - 1](out)
-        return out
-
-    def __call__(self, *args, **kwargs):
-        cdef list args_
-        cdef dict kwargs_
-        args_, kwargs_ = self._parameters.bind(args, kwargs)
-        return self.prebound(args_, kwargs_)
-
-    def __repr__(self):
-        if len(self.types) == 1:
-            spec = self.types[0].__name__
-        else:
-            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
-        direct = ("" if self.direct else "in") + "direct"
-        return "".join([
-            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
-        ])
-
-
-cdef class Dispatcher:
-    """
-    Dispatcher for a data-layer operation.  This object can be called with the
-    signature shown in `self.__signature__` or `self.__text_signature__`, where
-    the arguments listed in `self.inputs` can be any data-layer types (i.e.
-    ones that have valid conversions in `data.to`).
-
-    You can define additional specialisations for this dispatcher by calling
-    its `add_specialisations` method.  New data types must be added to
-    `data.to` before they can be added as specialisations to a dispatcher.
-
-    You can get a callable object representing a single set of dispatcher types
-    by using the key-lookup syntax
-        Dispatcher[type1, type2, ...]
-    where `type1`, `type2`, etc are the dispatched arguments (with the output
-    type on the end, if this is a dispatcher over the output type.
-    """
-    cdef _bind _parameters
-    cdef readonly dict _specialisations
-    cdef Py_ssize_t _n_dispatch
-    cdef readonly dict _lookup
-    cdef set _dtypes
-    cdef bint _pass_on_dtype
-    cdef readonly tuple inputs
-    cdef readonly bint output
-    cdef public str __doc__
-    cdef public str __name__
-    cdef public str __module__
-    cdef public object __signature__
-    cdef readonly str __text_signature__
-
-    def __init__(self, signature_source, inputs, bint out=False,
-                 str name=None, str module=None):
-        """
-        Create a new data layer dispatching operator.
-
-        Parameters
-        ----------
-        signature_source : callable or inspect.Signature
-            An object from which the call signature of operation can be
-            determined.  You can pass any callable defined in Python space, and
-            the signature will be extracted.  Note that the callable will not
-            be added as a specialisation by this; you will still have to call
-            `add_specialisations`.
-
-            If you cannot provide a callable with an extractable signature
-            (e.g. Cython extension methods), you can instead directly provide
-            an instance of `inspect.Signature`, which will be used instead.
-
-        inputs : iterable of str
-            The parameters which should be dispatched over.  These can be
-            positional or keyword arguments, but must feature in the signature
-            provided.
-
-        out : bool, optional (False)
-            Whether to dispatch on the output of the function.  Defaults to
-            `False`.
-
-        name : str, optional
-            If given, the `__name__` parameter of the dispatcher is set to
-            this.  If not given and `signature_source` is _not_ an instance of
-            `inspect.Signature`, then we will attempt to read `__name__` from
-            there instead.
-
-        module : str, optional
-            If given, the `__module__` parameter of the dispatcher is set to
-            this.  If not given and `signature_source` is _not_ an instance of
-            `inspect.Signature`, then we will attempt to read `__module__` from
-            there instead.
-        """
-        if isinstance(inputs, str):
-            inputs = (inputs,)
-        inputs = tuple(inputs)
-        if inputs == () and out is False:
-            warnings.warn(
-                "No parameters to dispatch on."
-                " Maybe you meant to specify 'inputs' or 'out'?"
-            )
-        self.inputs = inputs
-        if isinstance(signature_source, inspect.Signature):
-            self.__signature__ = signature_source
-        else:
-            self.__signature__ = inspect.signature(signature_source)
-        self._parameters = _bind(self.__signature__, inputs)
-        if name is not None:
-            self.__name__ = name
-        elif not isinstance(signature_source, inspect.Signature):
-            self.__name__ = signature_source.__name__
-        else:
-            self.__name__ = 'dispatcher'
-        if module is not None:
-            self.__module__ = module
-        elif not isinstance(signature_source, inspect.Signature):
-            self.__module__ = signature_source.__module__
-        self.__text_signature__ = self.__name__ + str(self.__signature__)
-        if not isinstance(signature_source, inspect.Signature):
-            self.__doc__ = inspect.getdoc(signature_source)
-        self.output = out
-        self._specialisations = {}
-        self._lookup = {}
-        self._n_dispatch = self._parameters.n_inputs + self.output
-        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
-        # Add ourselves to the list of dispatchers to be updated.
-        _to.dispatchers.append(self)
-
-    def add_specialisations(self, specialisations, _defer=False):
-        """
-        Add specialisations for particular combinations of data types to this
-        operation.  The data types must already be known in `data.to` before
-        you try to provide them here.  All data types defined in `data.to` will
-        automatically work with this dispatcher, but will involve inefficient
-        conversions to and from other types unless you define a closer
-        specialisation using this method.
-
-        The lookup table will automatically be rebuilt after this method is
-        called.  Specialisations defined more than once will use the most
-        recent version; you can use this to override currently known
-        specialisations if desired.
-
-        Parameters
-        ----------
-        specialisations : iterable of tuples
-            An iterable where each element specifies a new specialisation for
-            this operation.  Each element of the iterable should be a tuple,
-            whose items are the types (instances of `type`) which this
-            specialisation takes in each of the slots defined by
-            `Dispatcher.inputs`, and the output type if this is a dispatcher
-            over output types.  The last element should be the callable itself.
-
-            The callable must have exactly the same signature as
-            `Dispatcher.__signature__`; it is not enough that it takes all the
-            same keyword arguments, but they must come in the same order as
-            well (this is a speed optimisation for the dispatching operation).
-
-            For example, if this is a dispatcher with the signature
-                add(left, right, scale=1)
-            which also dispatches over its output, and we have specialisations
-                add_1(left: CSR, right: Dense, scale=1) -> Dense
-                add_2(left: Dense, right: CSC, scale=1) -> CSR
-            then to add this, `specialisations` should look like
-                [
-                    (CSR, Dense, Dense, add_1),
-                    (Dense, CSC, CSR, add_2),
-                ]
-            Type annotations present in the specialisation objects are ignored.
-
-        _defer : bool, optional (False)
-            Only intended for internal library use during initialisation. If
-            `True`, then the input types are not checked, and the full lookup
-            table is not built until a manual call to
-            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
-            remember that you should add the data type conversions to `data.to`
-            before you try to add specialisations.
-        """
-        for arg in specialisations:
-            arg = tuple(arg)
-            if len(arg) != self._n_dispatch + 1:
-                raise ValueError(
-                    "specialisation " + str(arg)
-                    + " has wrong number of parameters: needed types for "
-                    + str(self._parameters.inputs)
-                    + (", an output type" if self.output else "")
-                    + " and a callable"
-                )
-            for i in range(self._n_dispatch):
-                if (not _defer) and arg[i] not in _to.dtypes:
-                    raise ValueError(str(arg[i]) + " is not a known data type")
-            if not callable(arg[self._n_dispatch]):
-                raise TypeError(str(arg[-1]) + " is not callable")
-            self._specialisations[arg[:-1]] = arg[-1]
-        if not _defer:
-            self.rebuild_lookup()
-
-    def rebuild_lookup(self):
-        """
-        Manually trigger a rebuild of the lookup table for this dispatcher.
-        This is called automatically when new data types are added to
-        `data.to`, or when specialisations are added to this object with
-        `Dispatcher.add_specialisations`.
-
-        You most likely do not need to call this function yourself.
-        """
-        cdef double weight, cur
-        cdef tuple types, out_types
-        cdef object function
-        if not self._specialisations:
-            return
-        self._dtypes = _to.dtypes.copy()
-        # The complexity of building the table here is very poor, but it's a
-        # cost we pay very infrequently, and until it's proved to be a
-        # bottle-neck in real code, we stick with the simple algorithm.
-        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
-            weight = math.INFINITY
-            types = None
-            function = None
-            for out_types, out_function in self._specialisations.items():
-                cur = _conversion_weight(in_types, out_types, _to.weight,
-                                         out=self.output)
-                if cur < weight:
-                    weight = cur
-                    types = out_types
-                    function = out_function
-            if self.output:
-                converters = tuple(
-                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
-                    + [_to[in_types[-1], types[-1]]]
-                )
-            else:
-                converters = tuple(_to[pair] for pair in zip(types, in_types))
-            self._lookup[in_types] =\
-                _constructed_specialisation(function, self, in_types,
-                                            converters, self.output,
-                                            weight == 0)
-        # Now build the lookup table in the case that we dispatch on the output
-        # type as well, but the user has called us without specifying it.
-        # TODO: option to control default output type choice if unspecified?
-        if self.output:
-            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
-                weight = math.INFINITY
-                types = None
-                function = None
-                for out_types, out_function in self._specialisations.items():
-                    cur = _conversion_weight(in_types, out_types[:-1],
-                                             _to.weight, out=False)
-                    if cur < weight:
-                        weight = cur
-                        types = out_types
-                        function = out_function
-                converters = tuple(_to[pair] for pair in zip(types, in_types))
-                self._lookup[in_types] =\
-                    _constructed_specialisation(function, self,
-                                                in_types + (types[-1],),
-                                                converters, False,
-                                                weight == 0)
-
-    def __getitem__(self, types):
-        """
-        Get the particular specialisation for the given types.  The output is a
-        callable object which requires that the dispatched arguments match
-        those specified in `types`.
-        """
-        if type(types) is not tuple:
-            types = (types,)
-        types = tuple(_to.parse(arg) for arg in types)
-        try:
-            return self._lookup[types]
-        except KeyError:
-            raise TypeError("specialisation not known for types: " + str(types)) from None
-
-    def __repr__(self):
-        return "<dispatcher: " + self.__text_signature__ + ">"
-
-    def __call__(self, *args, dtype=None, **kwargs):
-        cdef list args_, dispatch
-        cdef dict kwargs_
-        if self._pass_on_dtype:
-            kwargs['dtype'] = dtype
-        if not (self._pass_on_dtype or self.output) and dtype is not None:
-            raise TypeError("unknown argument 'dtype'")
-        args_, kwargs_ = self._parameters.bind(args, kwargs)
-        dispatch = self._parameters.dispatch_types(args_, kwargs_)
-        if self.output and dtype is not None:
-            dtype = _to.parse(dtype)
-            dispatch.append(dtype)
-        cdef _constructed_specialisation function
-        try:
-            function = self._lookup[tuple(dispatch)]
-        except KeyError:
-            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
-        return function.prebound(args_, kwargs_)
+#cython: language_level=3
+
+import functools
+import inspect
+import itertools
+import warnings
+
+from .convert import to as _to
+
+cimport cython
+from libc cimport math
+from libcpp cimport bool
+
+__all__ = ['Dispatcher']
+
+cdef class _bind:
+    """
+    Cythonised implementation of inspect.Signature.bind, supporting faster
+    binding and handling of default arguments.  On construction, the signature
+    of the base function is extracted, and all parameters are parsed into
+    positional or keyword slots, using positional wherever possible, and their
+    defaults are stored.
+    """
+    # Instance of inpsect.Signature representing the function.
+    cdef object signature
+    cdef object inputs
+    # Mapping of (str: int), where str is the name of any argument which may be
+    # specified by a keyword, and int is its location in `self._pos` if
+    # available, or -1 if it is keyword-only.
+    cdef dict _locations
+    # Default values (or inspect.Parameter.empty) for every parameter which
+    # may be passed as a positional argument.
+    cdef list _pos
+    # For each dispatcher input which can be given as a positional argument,
+    # these two lists hold the index of the input in the given tuple of input
+    # names and the corresponding index into the positional arguments after
+    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
+    # effectively the same mapping as _kw_inputs (but for positional
+    # arguments), but we use two lists rather than a dictionary for speed.
+    cdef list _pos_inputs_input, _pos_inputs_pos
+    # Default values (or inspect.Parameter.empty) for every parameter which
+    # _must_ be passed as a keyword argument.
+    cdef dict _kw
+    # Mapping of (name, index into the input tuple) for each input which must
+    # be specified as a keyword argument
+    cdef list _kw_inputs
+    # Names of the keyword arguments which have default values.
+    cdef set _default_kw_names
+    # Respectively, numbers of positional parameters, keyword-only parameters
+    # and dispatcher inputs.
+    cdef Py_ssize_t n_args, n_kwargs, n_inputs
+    # Respectively, numbers of inputs which are positional and keyword-only.
+    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
+    # Respectively, numbers of positional arguments without a default, and
+    # number of keyword-only arguments which _have_ a default.
+    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
+
+
+    def __init__(self, signature, tuple inputs):
+        for arg in inputs:
+            if arg not in signature.parameters:
+                raise AttributeError("No argument matches '{}'.".format(arg))
+        self.signature = signature
+        self.inputs = inputs
+        self._locations = {}
+        self._pos = []
+        self._pos_inputs_input = []
+        self._pos_inputs_pos = []
+        self._kw = {}
+        self._kw_inputs = []
+        self._default_kw_names = set()
+        self._n_pos_no_default = 0
+        # signature.parameters is ordered for all Python versions.
+        for i, (name, parameter) in enumerate(signature.parameters.items()):
+            kind = parameter.kind
+            if (kind == parameter.VAR_POSITIONAL
+                    or kind == parameter.VAR_KEYWORD):
+                raise TypeError("Cannot dispatch with *args or **kwargs.")
+            if kind == parameter.KEYWORD_ONLY:
+                self._kw[name] = parameter.default
+                self._locations[name] = -1
+                if parameter.default is not parameter.empty:
+                    self._default_kw_names.add(name)
+                if name in inputs:
+                    self._kw_inputs.append((name, inputs.index(name)))
+            else:
+                self._pos.append(parameter.default)
+                if kind != parameter.POSITIONAL_ONLY:
+                    self._locations[name] = i
+                if parameter.default is parameter.empty:
+                    self._n_pos_no_default += 1
+                if name in inputs:
+                    # Effectively a mapping.
+                    self._pos_inputs_input.append(inputs.index(name))
+                    self._pos_inputs_pos.append(len(self._pos) - 1)
+        self.n_args = len(self._pos)
+        self.n_kwargs = len(self._kw)
+        self.n_inputs = len(inputs)
+        self._n_pos_inputs = len(self._pos_inputs_input)
+        self._n_kw_inputs = len(self._kw_inputs)
+        self._n_kw_default = len(self._default_kw_names)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef tuple bind(self, tuple args, dict kwargs):
+        """
+        Cython reimplementation of inspect.Signature.bind for binding the
+        collected `*args` and `**kwargs` of a generic call to a specific
+        signature, checking that everything matches.
+
+        The output is a parsed tuple (args, kwargs), where `args` is a list and
+        `kwargs` is a dict, however all arguments which _can_ be passed
+        positionally will be moved from `kwargs` into `args` for the output.
+        The resultant `args` and `kwargs` can be unpacked into the underlying
+        function call safely.  Default values are not filled in by this method.
+
+        This is necessary to allow a generic `Dispatcher` class to work with
+        all type signatures.  The result of this function can be fed to
+        `_bind.convert_types` and `_bind.dispatch_types`.
+        """
+        cdef Py_ssize_t location, got_pos=0, got_kw=0
+        cdef Py_ssize_t n_passed_args = len(args)
+        if n_passed_args > self.n_args:
+            raise TypeError(
+                "Too many arguments: expected at most {} but received {}."
+                .format(n_passed_args, self.n_args)
+            )
+        # _pos and _kw are filled with their defaults at initialisation, and
+        # _pos is already the correct length (no-default parameters have
+        # sentinel values).
+        cdef list out_pos = self._pos.copy()
+        cdef dict out_kw = self._kw.copy()
+        got_pos = self.n_args - self._n_pos_no_default
+        got_kw = self._n_kw_default
+        # Positional arguments unambiguously fill the first positional slots.
+        for location in range(n_passed_args):
+            out_pos[location] = args[location]
+        # How many arguments that we didn't have defaults for did we just get?
+        # Positionals with a default are always after those without one.
+        if n_passed_args > self._n_pos_no_default:
+            got_pos += self._n_pos_no_default
+        else:
+            got_pos += n_passed_args
+        # Everything else has been passed by keyword, but it may be allowed to
+        # be passed positionally, which is the case we prefer.  dict.items() is
+        # (relatively) expensive, so we use a boolean test for the fast path.
+        cdef str kw
+        cdef object arg
+        if kwargs:
+            for kw, arg in kwargs.items():
+                try:
+                    location = self._locations[kw]
+                except KeyError:
+                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
+                # _locations[kw] = -1 if kw is keyword-only, otherwise the
+                # corresponding positional location.
+                if location >= 0:
+                    if location < n_passed_args:
+                        raise TypeError("Multiple values for '{}'".format(kw))
+                    out_pos[location] = arg
+                    if location < self._n_pos_no_default:
+                        got_pos += 1
+                else:
+                    out_kw[kw] = arg
+                    if kw not in self._default_kw_names:
+                        got_kw += 1
+        if got_pos < self.n_args:
+            raise TypeError("Too few positional arguments passed.")
+        if got_kw < self.n_kwargs:
+            raise TypeError("Not all keyword arguments were filled.")
+        return out_pos, out_kw
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef list dispatch_types(self, list args, dict kwargs):
+        """
+        Get a list of the types which the dispatch should operate over, given
+        the output of `_bind.bind`.  The return value is a list of the _input_
+        types to be dispatched on, in order that they were specified at
+        `Dispatcher` creation.  The output type is not returned as part of this
+        list, because there is no way for `_bind` to know it.
+        """
+        cdef list dispatch = [None] * self.n_inputs
+        cdef str kw
+        cdef Py_ssize_t location, i
+        for location in range(self._n_pos_inputs):
+            dispatch[self._pos_inputs_input[location]]\
+                = type(args[self._pos_inputs_pos[location]])
+        for i in range(self._n_kw_inputs):
+            kw, location = self._kw_inputs[i]
+            dispatch[location] = type(kwargs[kw])
+        return dispatch
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
+        """
+        Apply the type converters `converters` to the parsed arguments `args`
+        and `kwargs`.
+
+        If there are `n` inputs which are dispatched on, `converters` should be
+        a tuple whose first `n` elements are converters (such as those obtained
+        from `data.to[to_type, from_type]`) to the desired types.
+
+        `args` and `kwargs` should be the output of `_bind.bind`; the function
+        will likely fail if called on unparsed arguments.
+        """
+        cdef str kw
+        cdef Py_ssize_t location, i
+        for location in range(self._n_pos_inputs):
+            args[location] = converters[location](args[location])
+        for i in range(self._n_kw_inputs):
+            kw, location = self._kw_inputs[i]
+            kwargs[kw] = converters[location](kwargs[kw])
+        return args, kwargs
+
+
+cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
+    """
+    Find the total weight of conversion if the types in `froms` are converted
+    element-wise to the types in `tos`.  `weight_map` is a mapping of
+    `(to_type, from_type): real`; it should almost certainly be
+    `data.to.weight`.
+    """
+    cdef double weight = 0.0
+    cdef Py_ssize_t i, n=len(froms)
+    if len(tos) != n:
+        raise ValueError(
+            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
+        )
+    if out:
+        n = n - 1
+        weight += weight_map[froms[n], tos[n]]
+    for i in range(n):
+        weight += weight_map[tos[i], froms[i]]
+    return weight
+
+
+cdef class _constructed_specialisation:
+    """
+    Callable object providing the specialisation of a data-layer operation for
+    a particular set of types (`self.types`).  This may or may not involve
+    conversion of the input types and the output to match a known
+    specialisation; if it has no conversions, `self.direct` will be `True`,
+    otherwise it will be `False`.
+
+    See `self.__signature__` or `self.__text_signature__` for the call
+    signature of this object.
+    """
+    cdef _bind _parameters
+    cdef bint _output
+    cdef object _call
+    cdef Py_ssize_t _n_dispatch
+    cdef readonly tuple types
+    cdef tuple _converters
+    cdef str _short_name
+    cdef public str __doc__
+    cdef public str __name__
+    cdef public str __module__
+    cdef public object __signature__
+    cdef readonly str __text_signature__
+    cdef readonly bint direct
+
+    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
+                 direct):
+        self.__doc__ = inspect.getdoc(dispatcher)
+        self._short_name = dispatcher.__name__
+        self.__name__ = (
+            self._short_name
+            + "_"
+            + "_".join([x.__name__ for x in types])
+        )
+        self.__module__ = dispatcher.__module__
+        self.__signature__ = dispatcher.__signature__
+        self.__text_signature__ = dispatcher.__text_signature__
+        self._parameters = dispatcher._parameters
+        self._output = out
+        self._call = base
+        self._n_dispatch = len(types)
+        self.types = types
+        self.direct = direct
+        self._converters = converters
+
+    cdef object prebound(self, list args, dict kwargs):
+        """
+        Call this specialisation with pre-parsed arguments and keyword
+        arguments.  `args` and `kwargs` must be the output of the relevant
+        `_bind.bind` method for this function.
+        """
+        self._parameters.convert_types(args, kwargs, self._converters)
+        out = self._call(*args, **kwargs)
+        if self._output:
+            out = self._converters[self._n_dispatch - 1](out)
+        return out
+
+    def __call__(self, *args, **kwargs):
+        cdef list args_
+        cdef dict kwargs_
+        args_, kwargs_ = self._parameters.bind(args, kwargs)
+        return self.prebound(args_, kwargs_)
+
+    def __repr__(self):
+        if len(self.types) == 1:
+            spec = self.types[0].__name__
+        else:
+            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
+        direct = ("" if self.direct else "in") + "direct"
+        return "".join([
+            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
+        ])
+
+
+cdef class Dispatcher:
+    """
+    Dispatcher for a data-layer operation.  This object can be called with the
+    signature shown in `self.__signature__` or `self.__text_signature__`, where
+    the arguments listed in `self.inputs` can be any data-layer types (i.e.
+    ones that have valid conversions in `data.to`).
+
+    You can define additional specialisations for this dispatcher by calling
+    its `add_specialisations` method.  New data types must be added to
+    `data.to` before they can be added as specialisations to a dispatcher.
+
+    You can get a callable object representing a single set of dispatcher types
+    by using the key-lookup syntax
+        Dispatcher[type1, type2, ...]
+    where `type1`, `type2`, etc are the dispatched arguments (with the output
+    type on the end, if this is a dispatcher over the output type.
+    """
+    cdef _bind _parameters
+    cdef readonly dict _specialisations
+    cdef Py_ssize_t _n_dispatch
+    cdef readonly dict _lookup
+    cdef set _dtypes
+    cdef bint _pass_on_dtype
+    cdef readonly tuple inputs
+    cdef readonly bint output
+    cdef public str __doc__
+    cdef public str __name__
+    cdef public str __module__
+    cdef public object __signature__
+    cdef readonly str __text_signature__
+
+    def __init__(self, signature_source, inputs, bint out=False,
+                 str name=None, str module=None):
+        """
+        Create a new data layer dispatching operator.
+
+        Parameters
+        ----------
+        signature_source : callable or inspect.Signature
+            An object from which the call signature of operation can be
+            determined.  You can pass any callable defined in Python space, and
+            the signature will be extracted.  Note that the callable will not
+            be added as a specialisation by this; you will still have to call
+            `add_specialisations`.
+
+            If you cannot provide a callable with an extractable signature
+            (e.g. Cython extension methods), you can instead directly provide
+            an instance of `inspect.Signature`, which will be used instead.
+
+        inputs : iterable of str
+            The parameters which should be dispatched over.  These can be
+            positional or keyword arguments, but must feature in the signature
+            provided.
+
+        out : bool, optional (False)
+            Whether to dispatch on the output of the function.  Defaults to
+            `False`.
+
+        name : str, optional
+            If given, the `__name__` parameter of the dispatcher is set to
+            this.  If not given and `signature_source` is _not_ an instance of
+            `inspect.Signature`, then we will attempt to read `__name__` from
+            there instead.
+
+        module : str, optional
+            If given, the `__module__` parameter of the dispatcher is set to
+            this.  If not given and `signature_source` is _not_ an instance of
+            `inspect.Signature`, then we will attempt to read `__module__` from
+            there instead.
+        """
+        if isinstance(inputs, str):
+            inputs = (inputs,)
+        inputs = tuple(inputs)
+        if inputs == () and out is False:
+            warnings.warn(
+                "No parameters to dispatch on."
+                " Maybe you meant to specify 'inputs' or 'out'?"
+            )
+        self.inputs = inputs
+        if isinstance(signature_source, inspect.Signature):
+            self.__signature__ = signature_source
+        else:
+            self.__signature__ = inspect.signature(signature_source)
+        self._parameters = _bind(self.__signature__, inputs)
+        if name is not None:
+            self.__name__ = name
+        elif not isinstance(signature_source, inspect.Signature):
+            self.__name__ = signature_source.__name__
+        else:
+            self.__name__ = 'dispatcher'
+        if module is not None:
+            self.__module__ = module
+        elif not isinstance(signature_source, inspect.Signature):
+            self.__module__ = signature_source.__module__
+        self.__text_signature__ = self.__name__ + str(self.__signature__)
+        if not isinstance(signature_source, inspect.Signature):
+            self.__doc__ = inspect.getdoc(signature_source)
+        self.output = out
+        self._specialisations = {}
+        self._lookup = {}
+        self._n_dispatch = self._parameters.n_inputs + self.output
+        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
+        # Add ourselves to the list of dispatchers to be updated.
+        _to.dispatchers.append(self)
+
+    def add_specialisations(self, specialisations, _defer=False):
+        """
+        Add specialisations for particular combinations of data types to this
+        operation.  The data types must already be known in `data.to` before
+        you try to provide them here.  All data types defined in `data.to` will
+        automatically work with this dispatcher, but will involve inefficient
+        conversions to and from other types unless you define a closer
+        specialisation using this method.
+
+        The lookup table will automatically be rebuilt after this method is
+        called.  Specialisations defined more than once will use the most
+        recent version; you can use this to override currently known
+        specialisations if desired.
+
+        Parameters
+        ----------
+        specialisations : iterable of tuples
+            An iterable where each element specifies a new specialisation for
+            this operation.  Each element of the iterable should be a tuple,
+            whose items are the types (instances of `type`) which this
+            specialisation takes in each of the slots defined by
+            `Dispatcher.inputs`, and the output type if this is a dispatcher
+            over output types.  The last element should be the callable itself.
+
+            The callable must have exactly the same signature as
+            `Dispatcher.__signature__`; it is not enough that it takes all the
+            same keyword arguments, but they must come in the same order as
+            well (this is a speed optimisation for the dispatching operation).
+
+            For example, if this is a dispatcher with the signature
+                add(left, right, scale=1)
+            which also dispatches over its output, and we have specialisations
+                add_1(left: CSR, right: Dense, scale=1) -> Dense
+                add_2(left: Dense, right: CSC, scale=1) -> CSR
+            then to add this, `specialisations` should look like
+                [
+                    (CSR, Dense, Dense, add_1),
+                    (Dense, CSC, CSR, add_2),
+                ]
+            Type annotations present in the specialisation objects are ignored.
+
+        _defer : bool, optional (False)
+            Only intended for internal library use during initialisation. If
+            `True`, then the input types are not checked, and the full lookup
+            table is not built until a manual call to
+            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
+            remember that you should add the data type conversions to `data.to`
+            before you try to add specialisations.
+        """
+        for arg in specialisations:
+            arg = tuple(arg)
+            if len(arg) != self._n_dispatch + 1:
+                raise ValueError(
+                    "specialisation " + str(arg)
+                    + " has wrong number of parameters: needed types for "
+                    + str(self._parameters.inputs)
+                    + (", an output type" if self.output else "")
+                    + " and a callable"
+                )
+            for i in range(self._n_dispatch):
+                if (not _defer) and arg[i] not in _to.dtypes:
+                    raise ValueError(str(arg[i]) + " is not a known data type")
+            if not callable(arg[self._n_dispatch]):
+                raise TypeError(str(arg[-1]) + " is not callable")
+            self._specialisations[arg[:-1]] = arg[-1]
+        if not _defer:
+            self.rebuild_lookup()
+
+    def rebuild_lookup(self):
+        """
+        Manually trigger a rebuild of the lookup table for this dispatcher.
+        This is called automatically when new data types are added to
+        `data.to`, or when specialisations are added to this object with
+        `Dispatcher.add_specialisations`.
+
+        You most likely do not need to call this function yourself.
+        """
+        cdef double weight, cur
+        cdef tuple types, out_types
+        cdef object function
+        if not self._specialisations:
+            return
+        self._dtypes = _to.dtypes.copy()
+        # The complexity of building the table here is very poor, but it's a
+        # cost we pay very infrequently, and until it's proved to be a
+        # bottle-neck in real code, we stick with the simple algorithm.
+        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
+            weight = math.INFINITY
+            types = None
+            function = None
+            for out_types, out_function in self._specialisations.items():
+                cur = _conversion_weight(in_types, out_types, _to.weight,
+                                         out=self.output)
+                if cur < weight:
+                    weight = cur
+                    types = out_types
+                    function = out_function
+            if self.output:
+                converters = tuple(
+                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
+                    + [_to[in_types[-1], types[-1]]]
+                )
+            else:
+                converters = tuple(_to[pair] for pair in zip(types, in_types))
+            self._lookup[in_types] =\
+                _constructed_specialisation(function, self, in_types,
+                                            converters, self.output,
+                                            weight == 0)
+        # Now build the lookup table in the case that we dispatch on the output
+        # type as well, but the user has called us without specifying it.
+        # TODO: option to control default output type choice if unspecified?
+        if self.output:
+            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
+                weight = math.INFINITY
+                types = None
+                function = None
+                for out_types, out_function in self._specialisations.items():
+                    cur = _conversion_weight(in_types, out_types[:-1],
+                                             _to.weight, out=False)
+                    if cur < weight:
+                        weight = cur
+                        types = out_types
+                        function = out_function
+                converters = tuple(_to[pair] for pair in zip(types, in_types))
+                self._lookup[in_types] =\
+                    _constructed_specialisation(function, self,
+                                                in_types + (types[-1],),
+                                                converters, False,
+                                                weight == 0)
+
+    def __getitem__(self, types):
+        """
+        Get the particular specialisation for the given types.  The output is a
+        callable object which requires that the dispatched arguments match
+        those specified in `types`.
+        """
+        if type(types) is not tuple:
+            types = (types,)
+        types = tuple(_to.parse(arg) for arg in types)
+        try:
+            return self._lookup[types]
+        except KeyError:
+            raise TypeError("specialisation not known for types: " + str(types)) from None
+
+    def __repr__(self):
+        return "<dispatcher: " + self.__text_signature__ + ">"
+
+    def __call__(self, *args, dtype=None, **kwargs):
+        cdef list args_, dispatch
+        cdef dict kwargs_
+        if self._pass_on_dtype:
+            kwargs['dtype'] = dtype
+        if not (self._pass_on_dtype or self.output) and dtype is not None:
+            raise TypeError("unknown argument 'dtype'")
+        args_, kwargs_ = self._parameters.bind(args, kwargs)
+        dispatch = self._parameters.dispatch_types(args_, kwargs_)
+        if self.output and dtype is not None:
+            dtype = _to.parse(dtype)
+            dispatch.append(dtype)
+        cdef _constructed_specialisation function
+        try:
+            function = self._lookup[tuple(dispatch)]
+        except KeyError:
+            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
+        return function.prebound(args_, kwargs_)
diff --git a/qutip/core/data/eigen.py b/qutip/core/data/eigen.py
index c860fc2003..f5aa6e0f3e 100644
--- a/qutip/core/data/eigen.py
+++ b/qutip/core/data/eigen.py
@@ -1,454 +1,454 @@
-import numpy as np
-import scipy.linalg
-import scipy.sparse as sp
-import scipy.sparse.linalg
-from itertools import combinations
-
-from .dense import Dense, from_csr
-from .csr import CSR
-from .properties import isherm as _isherm
-from qutip.settings import settings
-
-__all__ = [
-    'eigs', 'eigs_csr', 'eigs_dense',
-    'svd', 'svd_csr', 'svd_dense',
-]
-
-
-def _orthogonalize(vec, other):
-    cross = np.sum(np.conj(other) * vec)
-    vec -= cross * other
-    norm = np.sum(np.conj(vec) * vec)**0.5
-    vec /= norm
-
-
-if settings.eigh_unsafe:
-    def eigh(mat, eigvals=None):
-        val, vec = scipy.linalg.eig(mat)
-        val = np.real(val)
-        idx = np.argsort(val)
-        val = val[idx]
-        vec = vec[:, idx]
-        if eigvals:
-            val = val[eigvals[0]:eigvals[1]+1]
-            vec = vec[:, eigvals[0]:eigvals[1]+1]
-        same_eigv = 0
-        for i in range(1, len(val)):
-            if abs(val[i] - val[i-1]) < 1e-12:
-                same_eigv += 1
-                for j in range(same_eigv):
-                    _orthogonalize(vec[:, i], vec[:, i-j-1])
-            else:
-                same_eigv = 0
-        return val, vec
-
-    def eigvalsh(a, eigvals=None):
-        val = scipy.linalg.eigvals(a)
-        val = np.sort(np.real(val))
-        if eigvals:
-            return val[eigvals[0]:eigvals[1]+1]
-        return val
-else:
-    eigh = scipy.linalg.eigh
-    eigvalsh = scipy.linalg.eigvalsh
-
-
-def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
-    """
-    Internal functions for computing eigenvalues and eigenstates for a dense
-    matrix.
-    """
-    N = data.shape[0]
-    kwargs = {}
-    if eigvals != 0 and isherm:
-        kwargs['subset_by_index'] = (
-            [0, num_small-1] if num_small else [N-num_large, N-1]
-        )
-    if vecs:
-        driver = eigh if isherm else scipy.linalg.eig
-        evals, evecs = driver(data, **kwargs)
-    else:
-        driver = eigvalsh if isherm else scipy.linalg.eigvals
-        evals = driver(data, **kwargs)
-        evecs = None
-
-    _zipped = list(zip(evals, range(len(evals))))
-    _zipped.sort()
-    evals, perm = list(zip(*_zipped))
-
-    if vecs:
-        evecs = np.array([evecs[:, k] for k in perm]).T
-
-    if not isherm and eigvals > 0:
-        if vecs:
-            if num_small > 0:
-                evals, evecs = evals[:num_small], evecs[:, :num_small]
-            elif num_large > 0:
-                evals = evals[(N - num_large):]
-                evecs = evecs[:, (N - num_large):]
-        else:
-            if num_small > 0:
-                evals = evals[:num_small]
-            elif num_large > 0:
-                evals = evals[(N - num_large):]
-    return np.array(evals), evecs
-
-
-def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
-    """
-    Internal functions for computing eigenvalues and eigenstates for a sparse
-    matrix.
-    """
-    N = data.shape[0]
-    big_vals = np.array([])
-    small_vals = np.array([])
-    evecs = None
-
-    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
-    if eigvals == (N - 1):
-        # calculate all eigenvalues and remove one at output if using sparse
-        # 1: remove the smallest, -1, remove the largest
-        remove_one = 1 if (num_small > 0) else -1
-        eigvals = 0
-        num_small = num_large = N // 2
-        num_small += N % 2
-
-    if vecs:
-        if isherm:
-            if num_large > 0:
-                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
-                                                     which='LA', tol=tol,
-                                                     maxiter=maxiter)
-            if num_small > 0:
-                small_vals, small_vecs = sp.linalg.eigsh(
-                    data, k=num_small, which='SA',
-                    tol=tol, maxiter=maxiter)
-
-        else:
-            if num_large > 0:
-                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
-                                                    which='LR', tol=tol,
-                                                    maxiter=maxiter)
-            if num_small > 0:
-                small_vals, small_vecs = sp.linalg.eigs(
-                    data, k=num_small, which='SR',
-                    tol=tol, maxiter=maxiter)
-
-        if num_large != 0 and num_small != 0:
-            evecs = np.hstack([small_vecs, big_vecs])
-        elif num_large != 0 and num_small == 0:
-            evecs = big_vecs
-        elif num_large == 0 and num_small != 0:
-            evecs = small_vecs
-    else:
-        if isherm:
-            if num_large > 0:
-                big_vals = sp.linalg.eigsh(
-                    data, k=num_large, which='LA',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-            if num_small > 0:
-                small_vals = sp.linalg.eigsh(
-                    data, k=num_small, which='SA',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-        else:
-            if num_large > 0:
-                big_vals = sp.linalg.eigs(
-                    data, k=num_large, which='LR',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-            if num_small > 0:
-                small_vals = sp.linalg.eigs(
-                    data, k=num_small, which='SR',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-
-    evals = np.hstack((small_vals, big_vals))
-    if isherm:
-        evals = np.real(evals)
-
-    _zipped = list(zip(evals, range(len(evals))))
-    _zipped.sort()
-    evals, perm = list(zip(*_zipped))
-
-    if vecs:
-        evecs = np.array([evecs[:, k] for k in perm]).T
-
-    # remove last element if requesting N-1 eigs and using sparse
-    if remove_one == 1:
-        evals = evals[:-1]
-        if vecs:
-            evecs = evecs[:, :-1]
-    elif remove_one == -1:
-        evals = evals[1:]
-        if vecs:
-            evecs = evecs[:, 1:]
-
-    return np.array(evals), evecs
-
-
-def _eigs_check_shape(data):
-    if data.shape[0] != data.shape[1]:
-        raise TypeError("Can only diagonalize square matrices")
-
-
-def _eigs_fix_eigvals(data, eigvals, sort):
-    N = data.shape[0]
-    if eigvals == N:
-        eigvals = 0
-    if eigvals > N:
-        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
-    if sort not in ('low', 'high'):
-        raise ValueError("'sort' must be 'low' or 'high'")
-
-    # set number of large and small eigenvals/vecs
-    if eigvals == 0:  # user wants all eigs (default)
-        num_small = num_large = N // 2
-        num_small += N % 2
-    else:  # if user wants only a few eigen vals/vecs
-        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
-    return eigvals, num_large, num_small
-
-
-def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
-             tol=0, maxiter=100000):
-    """
-    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
-    may take some extra keyword arguments in addition to the full documentation
-    specified in :func:`.eigs`.
-
-    This method is typically slower and less accurate than the dense eigenvalue
-    solver; you probably want that, unless memory concerns deem it impossible.
-
-    Extra keyword arguments
-    -----------------------
-    tol : float (0)
-        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
-        as 0) cause the solver to use machine precision.
-    maxiter : int (100_000)
-        Max number of iterations used by sparse eigensolver.
-    """
-    if not isinstance(data, CSR):
-        raise TypeError("expected data in CSR format but got "
-                        + str(type(data)))
-    if data.shape[0] < 4:
-        # For small matrix, the sparse solver can't compute all eigenvalues.
-        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
-    _eigs_check_shape(data)
-    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
-    isherm = isherm if isherm is not None else _isherm(data)
-    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
-                             num_large, num_small, tol, maxiter)
-
-    if vecs and isherm:
-        i = 0
-        while i < len(evals):
-            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
-            # orthogonalize vectors 1 .. k with respect to the first, then
-            # 2 .. k with respect to the second, and so on. Relies on both the
-            # order of each pair and the ordering of pairs returned by
-            # combinations.
-            for k, l in combinations(range(num_degen), 2):
-                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
-            i += num_degen
-
-    if sort == 'high':
-        # Flip arrays around.
-        if vecs:
-            evecs = np.fliplr(evecs)
-        evals = evals[::-1]
-    return (evals, Dense(evecs, copy=False)) if vecs else evals
-
-
-def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
-    """
-    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
-    keyword arguments; see the primary documentation in :func:`.eigs`.
-    """
-    if not isinstance(data, Dense):
-        raise TypeError("expected data in Dense format but got "
-                        + str(type(data)))
-    _eigs_check_shape(data)
-    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
-    isherm = isherm if isherm is not None else _isherm(data)
-    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
-                               num_large, num_small)
-    if sort == 'high':
-        # Flip arrays around.
-        if vecs:
-            evecs = np.fliplr(evecs)
-        evals = evals[::-1]
-    return (evals, Dense(evecs, copy=False)) if vecs else evals
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-
-# We use eigs_dense as the signature source, since in this case it has the
-# complete signature that we allow, so we don't need to manually set it.
-eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
-eigs.__doc__ =\
-    """
-    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
-
-    Some particular specialisations of this function may take additional
-    keyword arguments (such as the CSR solver).  See their particular
-    docstrings for details on those.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    isherm : bool, optional
-        Indicate whether the matrix is Hermitian or not.  There are special
-        Hermitian eigenvalue and -vector solvers for this case, which will take
-        care of orthonormalisation and ensuring better accuracy.  If this is
-        not specified either way, it will be calculated from the data.
-    vecs : bool, optional (True)
-        Whether the eigenvectors should be returned as well.
-    sort : {'low', 'high'}, optional
-        Sort the output of the eigenvalues and -vectors ordered by the relevant
-        size of the real part of the eigenvalue from 'low' to high or from
-        'high' to low.  If not all of the eigenvalues are requested, this
-        influences which eigenvalues will be found.
-    eigvals : int, optional
-        Number of eigenvalues and -vectors to return.  If `0`, then returns
-        all.
-
-    Returns
-    -------
-    eigenvalues : np.ndarray
-        The requested eigenvalues, sorted in the expected order.  The dtype is
-        `np.complex128`, unless `isherm=True`, in which case it will be
-        `np.float64`.
-    eigenvectors : Data
-        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
-        order of the eigenvalues.
-    """
-eigs.add_specialisations([
-    (CSR, eigs_csr),
-    (Dense, eigs_dense),
-], _defer=True)
-
-
-def svd_csr(data, vecs=True, k=6, **kw):
-    """
-    Singular Value Decomposition:
-
-    ``data = U @ S @ Vh``
-
-    Where ``S`` is diagonal.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    vecs : bool, optional (True)
-        Whether the singular vectors (``U``, ``Vh``) should be returned.
-    k : int, optional (6)
-        Number of state to compute, default is ``6`` to match scipy's default.
-    **kw : dict
-        Options to pass to ``scipy.sparse.linalg.svds``.
-
-    Returns
-    -------
-    U : Dense
-        Left singular vectors as columns. Only returned if ``vecs == True``.
-        shape = (data.shape[0], k)
-    S : np.ndarray
-        The ``k``'s largest singular values.
-    Vh : Dense
-        Right singular vectors as rows. Only returned if ``vecs == True``.
-        shape = (k, data.shape[1])
-
-    .. note::
-        svds cannot compute all states at once. While it could find the
-        largest and smallest in 2 calls, it has issues converging with when
-        solving for the smallest (finding the 5 smallest in a 50x50 matrix
-        can fail with default options). It should be used when not all states
-        are needed.
-    """
-    out = scipy.sparse.linalg.svds(
-        data.as_scipy(), k, return_singular_vectors=vecs, **kw
-    )
-    if vecs:
-        u, s, vh = out
-        return Dense(u, copy=False), s, Dense(vh, copy=False)
-    return out
-
-
-def svd_dense(data, vecs=True, **kw):
-    """
-    Singular Value Decomposition:
-
-    ``data = U @ S @ Vh``
-
-    Where ``S`` is diagonal.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    vecs : bool, optional (True)
-        Whether the singular vectors (``U``, ``Vh``) should be returned.
-    **kw : dict
-        Options to pass to ``scipy.linalg.svd``.
-
-    Returns
-    -------
-    U : Dense
-        Left singular vectors as columns. Only returned if ``vecs == True``.
-    S : np.ndarray
-        Singular values.
-    Vh : Dense
-        Right singular vectors as rows. Only returned if ``vecs == True``.
-    """
-    out = scipy.linalg.svd(
-        data.to_array(), compute_uv=vecs, **kw
-    )
-    if vecs:
-        u, s, vh = out
-        return Dense(u, copy=False), s, Dense(vh, copy=False)
-    return out
-
-
-svd = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='svd',
-    module=__name__,
-    inputs=('data',),
-    out=False)
-svd.__doc__ =\
-    """
-    Singular Value Decomposition:
-
-    ``data = U @ S @ Vh``
-
-    Where ``S`` is diagonal.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    vecs : bool, optional (True)
-        Whether the singular vectors (``U``, ``Vh``) should be returned.
-
-    Returns
-    -------
-    U : Dense
-        Left singular vectors as columns. Only returned if ``vecs == True``.
-    S : np.ndarray
-        Singular values.
-    Vh : Dense
-        Right singular vectors as rows. Only returned if ``vecs == True``.
-    """
-# Dense implementation return all states, but sparse implementation compute
-# only a few states. So only the dense version is registered.
-svd.add_specialisations([
-    (Dense, svd_dense),
-], _defer=True)
-
-
-del _Dispatcher
-del _inspect
+import numpy as np
+import scipy.linalg
+import scipy.sparse as sp
+import scipy.sparse.linalg
+from itertools import combinations
+
+from .dense import Dense, from_csr
+from .csr import CSR
+from .properties import isherm as _isherm
+from qutip.settings import settings
+
+__all__ = [
+    'eigs', 'eigs_csr', 'eigs_dense',
+    'svd', 'svd_csr', 'svd_dense',
+]
+
+
+def _orthogonalize(vec, other):
+    cross = np.sum(np.conj(other) * vec)
+    vec -= cross * other
+    norm = np.sum(np.conj(vec) * vec)**0.5
+    vec /= norm
+
+
+if settings.eigh_unsafe:
+    def eigh(mat, eigvals=None):
+        val, vec = scipy.linalg.eig(mat)
+        val = np.real(val)
+        idx = np.argsort(val)
+        val = val[idx]
+        vec = vec[:, idx]
+        if eigvals:
+            val = val[eigvals[0]:eigvals[1]+1]
+            vec = vec[:, eigvals[0]:eigvals[1]+1]
+        same_eigv = 0
+        for i in range(1, len(val)):
+            if abs(val[i] - val[i-1]) < 1e-12:
+                same_eigv += 1
+                for j in range(same_eigv):
+                    _orthogonalize(vec[:, i], vec[:, i-j-1])
+            else:
+                same_eigv = 0
+        return val, vec
+
+    def eigvalsh(a, eigvals=None):
+        val = scipy.linalg.eigvals(a)
+        val = np.sort(np.real(val))
+        if eigvals:
+            return val[eigvals[0]:eigvals[1]+1]
+        return val
+else:
+    eigh = scipy.linalg.eigh
+    eigvalsh = scipy.linalg.eigvalsh
+
+
+def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
+    """
+    Internal functions for computing eigenvalues and eigenstates for a dense
+    matrix.
+    """
+    N = data.shape[0]
+    kwargs = {}
+    if eigvals != 0 and isherm:
+        kwargs['subset_by_index'] = (
+            [0, num_small-1] if num_small else [N-num_large, N-1]
+        )
+    if vecs:
+        driver = eigh if isherm else scipy.linalg.eig
+        evals, evecs = driver(data, **kwargs)
+    else:
+        driver = eigvalsh if isherm else scipy.linalg.eigvals
+        evals = driver(data, **kwargs)
+        evecs = None
+
+    _zipped = list(zip(evals, range(len(evals))))
+    _zipped.sort()
+    evals, perm = list(zip(*_zipped))
+
+    if vecs:
+        evecs = np.array([evecs[:, k] for k in perm]).T
+
+    if not isherm and eigvals > 0:
+        if vecs:
+            if num_small > 0:
+                evals, evecs = evals[:num_small], evecs[:, :num_small]
+            elif num_large > 0:
+                evals = evals[(N - num_large):]
+                evecs = evecs[:, (N - num_large):]
+        else:
+            if num_small > 0:
+                evals = evals[:num_small]
+            elif num_large > 0:
+                evals = evals[(N - num_large):]
+    return np.array(evals), evecs
+
+
+def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
+    """
+    Internal functions for computing eigenvalues and eigenstates for a sparse
+    matrix.
+    """
+    N = data.shape[0]
+    big_vals = np.array([])
+    small_vals = np.array([])
+    evecs = None
+
+    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
+    if eigvals == (N - 1):
+        # calculate all eigenvalues and remove one at output if using sparse
+        # 1: remove the smallest, -1, remove the largest
+        remove_one = 1 if (num_small > 0) else -1
+        eigvals = 0
+        num_small = num_large = N // 2
+        num_small += N % 2
+
+    if vecs:
+        if isherm:
+            if num_large > 0:
+                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
+                                                     which='LA', tol=tol,
+                                                     maxiter=maxiter)
+            if num_small > 0:
+                small_vals, small_vecs = sp.linalg.eigsh(
+                    data, k=num_small, which='SA',
+                    tol=tol, maxiter=maxiter)
+
+        else:
+            if num_large > 0:
+                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
+                                                    which='LR', tol=tol,
+                                                    maxiter=maxiter)
+            if num_small > 0:
+                small_vals, small_vecs = sp.linalg.eigs(
+                    data, k=num_small, which='SR',
+                    tol=tol, maxiter=maxiter)
+
+        if num_large != 0 and num_small != 0:
+            evecs = np.hstack([small_vecs, big_vecs])
+        elif num_large != 0 and num_small == 0:
+            evecs = big_vecs
+        elif num_large == 0 and num_small != 0:
+            evecs = small_vecs
+    else:
+        if isherm:
+            if num_large > 0:
+                big_vals = sp.linalg.eigsh(
+                    data, k=num_large, which='LA',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+            if num_small > 0:
+                small_vals = sp.linalg.eigsh(
+                    data, k=num_small, which='SA',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+        else:
+            if num_large > 0:
+                big_vals = sp.linalg.eigs(
+                    data, k=num_large, which='LR',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+            if num_small > 0:
+                small_vals = sp.linalg.eigs(
+                    data, k=num_small, which='SR',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+
+    evals = np.hstack((small_vals, big_vals))
+    if isherm:
+        evals = np.real(evals)
+
+    _zipped = list(zip(evals, range(len(evals))))
+    _zipped.sort()
+    evals, perm = list(zip(*_zipped))
+
+    if vecs:
+        evecs = np.array([evecs[:, k] for k in perm]).T
+
+    # remove last element if requesting N-1 eigs and using sparse
+    if remove_one == 1:
+        evals = evals[:-1]
+        if vecs:
+            evecs = evecs[:, :-1]
+    elif remove_one == -1:
+        evals = evals[1:]
+        if vecs:
+            evecs = evecs[:, 1:]
+
+    return np.array(evals), evecs
+
+
+def _eigs_check_shape(data):
+    if data.shape[0] != data.shape[1]:
+        raise TypeError("Can only diagonalize square matrices")
+
+
+def _eigs_fix_eigvals(data, eigvals, sort):
+    N = data.shape[0]
+    if eigvals == N:
+        eigvals = 0
+    if eigvals > N:
+        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
+    if sort not in ('low', 'high'):
+        raise ValueError("'sort' must be 'low' or 'high'")
+
+    # set number of large and small eigenvals/vecs
+    if eigvals == 0:  # user wants all eigs (default)
+        num_small = num_large = N // 2
+        num_small += N % 2
+    else:  # if user wants only a few eigen vals/vecs
+        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
+    return eigvals, num_large, num_small
+
+
+def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
+             tol=0, maxiter=100000):
+    """
+    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
+    may take some extra keyword arguments in addition to the full documentation
+    specified in :func:`.eigs`.
+
+    This method is typically slower and less accurate than the dense eigenvalue
+    solver; you probably want that, unless memory concerns deem it impossible.
+
+    Extra keyword arguments
+    -----------------------
+    tol : float (0)
+        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
+        as 0) cause the solver to use machine precision.
+    maxiter : int (100_000)
+        Max number of iterations used by sparse eigensolver.
+    """
+    if not isinstance(data, CSR):
+        raise TypeError("expected data in CSR format but got "
+                        + str(type(data)))
+    if data.shape[0] < 4:
+        # For small matrix, the sparse solver can't compute all eigenvalues.
+        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
+    _eigs_check_shape(data)
+    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
+    isherm = isherm if isherm is not None else _isherm(data)
+    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
+                             num_large, num_small, tol, maxiter)
+
+    if vecs and isherm:
+        i = 0
+        while i < len(evals):
+            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
+            # orthogonalize vectors 1 .. k with respect to the first, then
+            # 2 .. k with respect to the second, and so on. Relies on both the
+            # order of each pair and the ordering of pairs returned by
+            # combinations.
+            for k, l in combinations(range(num_degen), 2):
+                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
+            i += num_degen
+
+    if sort == 'high':
+        # Flip arrays around.
+        if vecs:
+            evecs = np.fliplr(evecs)
+        evals = evals[::-1]
+    return (evals, Dense(evecs, copy=False)) if vecs else evals
+
+
+def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
+    """
+    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
+    keyword arguments; see the primary documentation in :func:`.eigs`.
+    """
+    if not isinstance(data, Dense):
+        raise TypeError("expected data in Dense format but got "
+                        + str(type(data)))
+    _eigs_check_shape(data)
+    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
+    isherm = isherm if isherm is not None else _isherm(data)
+    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
+                               num_large, num_small)
+    if sort == 'high':
+        # Flip arrays around.
+        if vecs:
+            evecs = np.fliplr(evecs)
+        evals = evals[::-1]
+    return (evals, Dense(evecs, copy=False)) if vecs else evals
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+# We use eigs_dense as the signature source, since in this case it has the
+# complete signature that we allow, so we don't need to manually set it.
+eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
+eigs.__doc__ =\
+    """
+    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
+
+    Some particular specialisations of this function may take additional
+    keyword arguments (such as the CSR solver).  See their particular
+    docstrings for details on those.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    isherm : bool, optional
+        Indicate whether the matrix is Hermitian or not.  There are special
+        Hermitian eigenvalue and -vector solvers for this case, which will take
+        care of orthonormalisation and ensuring better accuracy.  If this is
+        not specified either way, it will be calculated from the data.
+    vecs : bool, optional (True)
+        Whether the eigenvectors should be returned as well.
+    sort : {'low', 'high'}, optional
+        Sort the output of the eigenvalues and -vectors ordered by the relevant
+        size of the real part of the eigenvalue from 'low' to high or from
+        'high' to low.  If not all of the eigenvalues are requested, this
+        influences which eigenvalues will be found.
+    eigvals : int, optional
+        Number of eigenvalues and -vectors to return.  If `0`, then returns
+        all.
+
+    Returns
+    -------
+    eigenvalues : np.ndarray
+        The requested eigenvalues, sorted in the expected order.  The dtype is
+        `np.complex128`, unless `isherm=True`, in which case it will be
+        `np.float64`.
+    eigenvectors : Data
+        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
+        order of the eigenvalues.
+    """
+eigs.add_specialisations([
+    (CSR, eigs_csr),
+    (Dense, eigs_dense),
+], _defer=True)
+
+
+def svd_csr(data, vecs=True, k=6, **kw):
+    """
+    Singular Value Decomposition:
+
+    ``data = U @ S @ Vh``
+
+    Where ``S`` is diagonal.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    vecs : bool, optional (True)
+        Whether the singular vectors (``U``, ``Vh``) should be returned.
+    k : int, optional (6)
+        Number of state to compute, default is ``6`` to match scipy's default.
+    **kw : dict
+        Options to pass to ``scipy.sparse.linalg.svds``.
+
+    Returns
+    -------
+    U : Dense
+        Left singular vectors as columns. Only returned if ``vecs == True``.
+        shape = (data.shape[0], k)
+    S : np.ndarray
+        The ``k``'s largest singular values.
+    Vh : Dense
+        Right singular vectors as rows. Only returned if ``vecs == True``.
+        shape = (k, data.shape[1])
+
+    .. note::
+        svds cannot compute all states at once. While it could find the
+        largest and smallest in 2 calls, it has issues converging with when
+        solving for the smallest (finding the 5 smallest in a 50x50 matrix
+        can fail with default options). It should be used when not all states
+        are needed.
+    """
+    out = scipy.sparse.linalg.svds(
+        data.as_scipy(), k, return_singular_vectors=vecs, **kw
+    )
+    if vecs:
+        u, s, vh = out
+        return Dense(u, copy=False), s, Dense(vh, copy=False)
+    return out
+
+
+def svd_dense(data, vecs=True, **kw):
+    """
+    Singular Value Decomposition:
+
+    ``data = U @ S @ Vh``
+
+    Where ``S`` is diagonal.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    vecs : bool, optional (True)
+        Whether the singular vectors (``U``, ``Vh``) should be returned.
+    **kw : dict
+        Options to pass to ``scipy.linalg.svd``.
+
+    Returns
+    -------
+    U : Dense
+        Left singular vectors as columns. Only returned if ``vecs == True``.
+    S : np.ndarray
+        Singular values.
+    Vh : Dense
+        Right singular vectors as rows. Only returned if ``vecs == True``.
+    """
+    out = scipy.linalg.svd(
+        data.to_array(), compute_uv=vecs, **kw
+    )
+    if vecs:
+        u, s, vh = out
+        return Dense(u, copy=False), s, Dense(vh, copy=False)
+    return out
+
+
+svd = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='svd',
+    module=__name__,
+    inputs=('data',),
+    out=False)
+svd.__doc__ =\
+    """
+    Singular Value Decomposition:
+
+    ``data = U @ S @ Vh``
+
+    Where ``S`` is diagonal.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    vecs : bool, optional (True)
+        Whether the singular vectors (``U``, ``Vh``) should be returned.
+
+    Returns
+    -------
+    U : Dense
+        Left singular vectors as columns. Only returned if ``vecs == True``.
+    S : np.ndarray
+        Singular values.
+    Vh : Dense
+        Right singular vectors as rows. Only returned if ``vecs == True``.
+    """
+# Dense implementation return all states, but sparse implementation compute
+# only a few states. So only the dense version is registered.
+svd.add_specialisations([
+    (Dense, svd_dense),
+], _defer=True)
+
+
+del _Dispatcher
+del _inspect
diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
index 4e7d2af104..da6ab98754 100644
--- a/qutip/core/data/expect.pxd
+++ b/qutip/core/data/expect.pxd
@@ -1,16 +1,16 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data cimport CSR, Dense, Data
-
-cpdef double complex expect_csr(CSR op, CSR state) nogil except *
-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
-
-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
-
-cpdef double complex expect_dense(Dense op, Dense state) nogil except *
-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
-
-cdef double complex expect_data_dense(Data op, Dense state) except *
-cdef double complex expect_super_data_dense(Data op, Dense state) except *
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data cimport CSR, Dense, Data
+
+cpdef double complex expect_csr(CSR op, CSR state) nogil except *
+cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
+
+cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
+cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
+
+cpdef double complex expect_dense(Dense op, Dense state) nogil except *
+cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
+
+cdef double complex expect_data_dense(Data op, Dense state) except *
+cdef double complex expect_super_data_dense(Data op, Dense state) except *
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 9b2089943e..72903acb08 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -1,325 +1,325 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-# The exported function `expect(op, state)` is equivalent to
-# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
-# `trace(op @ state)` if state is a density matrix, but it's optimised to not
-# make unnecessary extra allocations, or calculate extra factors.
-
-from libc.math cimport sqrt
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data cimport csr, CSR, Dense
-
-__all__ = [
-    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
-    'expect_super', 'expect_super_csr',
-    'expect_super_csr_dense', 'expect_super_dense',
-]
-
-cdef void _check_shape_ket(Data op, Data state) nogil except *:
-    if (
-        op.shape[1] != state.shape[0]  # Matrix multiplication
-        or state.shape[1] != 1  # State is ket
-        or op.shape[0] != op.shape[1]  # op must be square matrix
-    ):
-        raise ValueError("incorrect input shapes "
-                         + str(op.shape) + " and " + str(state.shape))
-
-cdef void _check_shape_dm(Data op, Data state) nogil except *:
-    if (
-        op.shape[1] != state.shape[0]  # Matrix multiplication
-        or state.shape[0] != state.shape[1]  # State is square 
-        or op.shape[0] != op.shape[1]  # Op is square
-    ):
-        raise ValueError("incorrect input shapes "
-                         + str(op.shape) + " and " + str(state.shape))
-
-cdef void _check_shape_super(Data op, Data state) nogil except *:
-    if state.shape[1] != 1:
-        raise ValueError("expected a column-stacked matrix")
-    if (
-        op.shape[1] != state.shape[0]  # Matrix multiplication
-        or op.shape[0] != op.shape[1]  # Square matrix
-    ):
-        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
-
-
-cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
-    """
-    Perform the operation
-        state.adjoint() @ op @ state
-    for a ket `state` and a square operator `op`.
-    """
-    _check_shape_ket(op, state)
-    cdef double complex out=0, sum=0, mul
-    cdef size_t row, col, ptr_op, ptr_ket
-    for row in range(state.shape[0]):
-        ptr_ket = state.row_index[row]
-        if ptr_ket == state.row_index[row + 1]:
-            continue
-        sum = 0
-        mul = conj(state.data[ptr_ket])
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            ptr_ket = state.row_index[col]
-            if ptr_ket != state.row_index[col + 1]:
-                sum += op.data[ptr_op] * state.data[ptr_ket]
-        out += mul * sum
-    return out
-
-cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
-    """
-    Perform the operation
-        tr(op @ state)
-    for an operator `op` and a density matrix `state`.
-    """
-    _check_shape_dm(op, state)
-    cdef double complex out=0
-    cdef size_t row, col, ptr_op, ptr_state
-    for row in range(op.shape[0]):
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
-                if state.col_index[ptr_state] == row:
-                    out += op.data[ptr_op] * state.data[ptr_state]
-                    break
-    return out
-
-
-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.
-    """
-    _check_shape_super(op, state)
-    cdef double complex out = 0.0
-    cdef size_t row=0, ptr, col
-    cdef size_t n = <size_t> sqrt(state.shape[0])
-    for _ in range(n):
-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr]
-            if state.row_index[col] != state.row_index[col + 1]:
-                out += op.data[ptr] * state.data[state.row_index[col]]
-        row += n + 1
-    return out
-
-
-cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-    if state.shape[1] == 1:
-        return _expect_csr_ket(op, state)
-    return _expect_csr_dm(op, state)
-
-cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
-    _check_shape_ket(op, state)
-    cdef double complex out=0, sum
-    cdef size_t row, ptr
-    for row in range(op.shape[0]):
-        if op.row_index[row] == op.row_index[row + 1]:
-            continue
-        sum = 0
-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-            sum += op.data[ptr] * state.data[op.col_index[ptr]]
-        out += sum * conj(state.data[row])
-    return out
-
-cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
-    _check_shape_dm(op, state)
-    cdef double complex out=0
-    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
-    row_stride = 1 if state.fortran else state.shape[1]
-    col_stride = state.shape[0] if state.fortran else 1
-    for row in range(op.shape[0]):
-        if op.row_index[row] == op.row_index[row + 1]:
-            continue
-        ptr_state = row * col_stride
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
-    return out
-
-
-cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
-    _check_shape_ket(op, state)
-    cdef double complex out=0, sum
-    cdef size_t row, col, op_row_stride, op_col_stride
-    op_row_stride = 1 if op.fortran else op.shape[1]
-    op_col_stride = op.shape[0] if op.fortran else 1
-
-    for row in range(op.shape[0]):
-        sum = 0
-        for col in range(op.shape[0]):
-            sum += (op.data[row * op_row_stride + col * op_col_stride] *
-                    state.data[col])
-        out += sum * conj(state.data[row])
-    return out
-
-cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
-    _check_shape_dm(op, state)
-    cdef double complex out=0
-    cdef size_t row, col, op_row_stride, op_col_stride
-    cdef size_t state_row_stride, state_col_stride
-    state_row_stride = 1 if state.fortran else state.shape[1]
-    state_col_stride = state.shape[0] if state.fortran else 1
-    op_row_stride = 1 if op.fortran else op.shape[1]
-    op_col_stride = op.shape[0] if op.fortran else 1
-
-    for row in range(op.shape[0]):
-        for col in range(op.shape[1]):
-            out += op.data[row * op_row_stride + col * op_col_stride] * \
-                   state.data[col * state_row_stride + row * state_col_stride]
-    return out
-
-
-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-    if state.shape[1] == 1:
-        return _expect_csr_dense_ket(op, state)
-    return _expect_csr_dense_dm(op, state)
-
-
-cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-    if state.shape[1] == 1:
-        return _expect_dense_ket(op, state)
-    return _expect_dense_dense_dm(op, state)
-
-
-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.
-    """
-    _check_shape_super(op, state)
-    cdef double complex out=0
-    cdef size_t row=0, ptr
-    cdef size_t n = <size_t> sqrt(state.shape[0])
-    for _ in range(n):
-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-            out += op.data[ptr] * state.data[op.col_index[ptr]]
-        row += n + 1
-    return out
-
-
-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.
-    """
-    _check_shape_super(op, state)
-    cdef double complex out=0
-    cdef size_t row=0, col, N = state.shape[0]
-    cdef size_t n = <size_t> sqrt(state.shape[0])
-    cdef size_t op_row_stride, op_col_stride
-    op_row_stride = 1 if op.fortran else op.shape[1]
-    op_col_stride = op.shape[0] if op.fortran else 1
-
-    for _ in range(n):
-        for col in range(N):
-            out += op.data[row * op_row_stride + col * op_col_stride] * \
-                   state.data[col]
-        row += n + 1
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-expect = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='expect',
-    module=__name__,
-    inputs=('op', 'state'),
-    out=False,
-)
-expect.__doc__ =\
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.  Returns a complex number.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-expect.add_specialisations([
-    (CSR, CSR, expect_csr),
-    (CSR, Dense, expect_csr_dense),
-    (Dense, Dense, expect_dense),
-], _defer=True)
-
-expect_super = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='expect_super',
-    module=__name__,
-    inputs=('op', 'state'),
-    out=False,
-)
-expect_super.__doc__ =\
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.  Returns a complex
-    number.
-    """
-expect_super.add_specialisations([
-    (CSR, CSR, expect_super_csr),
-    (CSR, Dense, expect_super_csr_dense),
-    (Dense, Dense, expect_super_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
-
-
-cdef double complex expect_data_dense(Data op, Dense state) except *:
-    cdef double complex out
-    if type(op) is CSR:
-        out = expect_csr_dense(op, state)
-    elif type(op) is Dense:
-        out = expect_dense(op, state)
-    else:
-        out = expect(op, state)
-    return out
-
-
-cdef double complex expect_super_data_dense(Data op, Dense state) except *:
-    cdef double complex out
-    if type(op) is CSR:
-        out = expect_super_csr_dense(op, state)
-    elif type(op) is Dense:
-        out = expect_super_dense(op, state)
-    else:
-        out = expect_super(op, state)
-    return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+# The exported function `expect(op, state)` is equivalent to
+# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
+# `trace(op @ state)` if state is a density matrix, but it's optimised to not
+# make unnecessary extra allocations, or calculate extra factors.
+
+from libc.math cimport sqrt
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data cimport csr, CSR, Dense
+
+__all__ = [
+    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
+    'expect_super', 'expect_super_csr',
+    'expect_super_csr_dense', 'expect_super_dense',
+]
+
+cdef void _check_shape_ket(Data op, Data state) nogil except *:
+    if (
+        op.shape[1] != state.shape[0]  # Matrix multiplication
+        or state.shape[1] != 1  # State is ket
+        or op.shape[0] != op.shape[1]  # op must be square matrix
+    ):
+        raise ValueError("incorrect input shapes "
+                         + str(op.shape) + " and " + str(state.shape))
+
+cdef void _check_shape_dm(Data op, Data state) nogil except *:
+    if (
+        op.shape[1] != state.shape[0]  # Matrix multiplication
+        or state.shape[0] != state.shape[1]  # State is square 
+        or op.shape[0] != op.shape[1]  # Op is square
+    ):
+        raise ValueError("incorrect input shapes "
+                         + str(op.shape) + " and " + str(state.shape))
+
+cdef void _check_shape_super(Data op, Data state) nogil except *:
+    if state.shape[1] != 1:
+        raise ValueError("expected a column-stacked matrix")
+    if (
+        op.shape[1] != state.shape[0]  # Matrix multiplication
+        or op.shape[0] != op.shape[1]  # Square matrix
+    ):
+        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
+
+
+cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
+    """
+    Perform the operation
+        state.adjoint() @ op @ state
+    for a ket `state` and a square operator `op`.
+    """
+    _check_shape_ket(op, state)
+    cdef double complex out=0, sum=0, mul
+    cdef size_t row, col, ptr_op, ptr_ket
+    for row in range(state.shape[0]):
+        ptr_ket = state.row_index[row]
+        if ptr_ket == state.row_index[row + 1]:
+            continue
+        sum = 0
+        mul = conj(state.data[ptr_ket])
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            ptr_ket = state.row_index[col]
+            if ptr_ket != state.row_index[col + 1]:
+                sum += op.data[ptr_op] * state.data[ptr_ket]
+        out += mul * sum
+    return out
+
+cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
+    """
+    Perform the operation
+        tr(op @ state)
+    for an operator `op` and a density matrix `state`.
+    """
+    _check_shape_dm(op, state)
+    cdef double complex out=0
+    cdef size_t row, col, ptr_op, ptr_state
+    for row in range(op.shape[0]):
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
+                if state.col_index[ptr_state] == row:
+                    out += op.data[ptr_op] * state.data[ptr_state]
+                    break
+    return out
+
+
+cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    cdef double complex out = 0.0
+    cdef size_t row=0, ptr, col
+    cdef size_t n = <size_t> sqrt(state.shape[0])
+    for _ in range(n):
+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr]
+            if state.row_index[col] != state.row_index[col + 1]:
+                out += op.data[ptr] * state.data[state.row_index[col]]
+        row += n + 1
+    return out
+
+
+cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        return _expect_csr_ket(op, state)
+    return _expect_csr_dm(op, state)
+
+cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
+    _check_shape_ket(op, state)
+    cdef double complex out=0, sum
+    cdef size_t row, ptr
+    for row in range(op.shape[0]):
+        if op.row_index[row] == op.row_index[row + 1]:
+            continue
+        sum = 0
+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+            sum += op.data[ptr] * state.data[op.col_index[ptr]]
+        out += sum * conj(state.data[row])
+    return out
+
+cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
+    _check_shape_dm(op, state)
+    cdef double complex out=0
+    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
+    row_stride = 1 if state.fortran else state.shape[1]
+    col_stride = state.shape[0] if state.fortran else 1
+    for row in range(op.shape[0]):
+        if op.row_index[row] == op.row_index[row + 1]:
+            continue
+        ptr_state = row * col_stride
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
+    return out
+
+
+cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
+    _check_shape_ket(op, state)
+    cdef double complex out=0, sum
+    cdef size_t row, col, op_row_stride, op_col_stride
+    op_row_stride = 1 if op.fortran else op.shape[1]
+    op_col_stride = op.shape[0] if op.fortran else 1
+
+    for row in range(op.shape[0]):
+        sum = 0
+        for col in range(op.shape[0]):
+            sum += (op.data[row * op_row_stride + col * op_col_stride] *
+                    state.data[col])
+        out += sum * conj(state.data[row])
+    return out
+
+cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
+    _check_shape_dm(op, state)
+    cdef double complex out=0
+    cdef size_t row, col, op_row_stride, op_col_stride
+    cdef size_t state_row_stride, state_col_stride
+    state_row_stride = 1 if state.fortran else state.shape[1]
+    state_col_stride = state.shape[0] if state.fortran else 1
+    op_row_stride = 1 if op.fortran else op.shape[1]
+    op_col_stride = op.shape[0] if op.fortran else 1
+
+    for row in range(op.shape[0]):
+        for col in range(op.shape[1]):
+            out += op.data[row * op_row_stride + col * op_col_stride] * \
+                   state.data[col * state_row_stride + row * state_col_stride]
+    return out
+
+
+cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        return _expect_csr_dense_ket(op, state)
+    return _expect_csr_dense_dm(op, state)
+
+
+cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        return _expect_dense_ket(op, state)
+    return _expect_dense_dense_dm(op, state)
+
+
+cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    cdef double complex out=0
+    cdef size_t row=0, ptr
+    cdef size_t n = <size_t> sqrt(state.shape[0])
+    for _ in range(n):
+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+            out += op.data[ptr] * state.data[op.col_index[ptr]]
+        row += n + 1
+    return out
+
+
+cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    cdef double complex out=0
+    cdef size_t row=0, col, N = state.shape[0]
+    cdef size_t n = <size_t> sqrt(state.shape[0])
+    cdef size_t op_row_stride, op_col_stride
+    op_row_stride = 1 if op.fortran else op.shape[1]
+    op_col_stride = op.shape[0] if op.fortran else 1
+
+    for _ in range(n):
+        for col in range(N):
+            out += op.data[row * op_row_stride + col * op_col_stride] * \
+                   state.data[col]
+        row += n + 1
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+expect = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='expect',
+    module=__name__,
+    inputs=('op', 'state'),
+    out=False,
+)
+expect.__doc__ =\
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.  Returns a complex number.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+expect.add_specialisations([
+    (CSR, CSR, expect_csr),
+    (CSR, Dense, expect_csr_dense),
+    (Dense, Dense, expect_dense),
+], _defer=True)
+
+expect_super = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='expect_super',
+    module=__name__,
+    inputs=('op', 'state'),
+    out=False,
+)
+expect_super.__doc__ =\
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.  Returns a complex
+    number.
+    """
+expect_super.add_specialisations([
+    (CSR, CSR, expect_super_csr),
+    (CSR, Dense, expect_super_csr_dense),
+    (Dense, Dense, expect_super_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
+
+
+cdef double complex expect_data_dense(Data op, Dense state) except *:
+    cdef double complex out
+    if type(op) is CSR:
+        out = expect_csr_dense(op, state)
+    elif type(op) is Dense:
+        out = expect_dense(op, state)
+    else:
+        out = expect(op, state)
+    return out
+
+
+cdef double complex expect_super_data_dense(Data op, Dense state) except *:
+    cdef double complex out
+    if type(op) is CSR:
+        out = expect_super_csr_dense(op, state)
+    elif type(op) is Dense:
+        out = expect_super_dense(op, state)
+    else:
+        out = expect_super(op, state)
+    return out
diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index 27586d1678..5d3bfc615f 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -1,93 +1,93 @@
-import numpy as np
-import scipy.sparse.linalg
-import scipy.linalg
-
-from .dense import Dense
-from .csr import CSR
-from .properties import isdiag_csr
-from qutip.settings import settings
-from .base import idxint_dtype
-
-__all__ = [
-    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
-    'logm', 'logm_dense',
-]
-
-
-def expm_csr(matrix: CSR) -> CSR:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only exponentiate square matrix")
-    if isdiag_csr(matrix):
-        matrix_sci = matrix.as_scipy()
-        data = np.ones(matrix.shape[0], dtype=np.complex128)
-        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
-        return CSR(
-            (
-                data,
-                np.arange(matrix.shape[0], dtype=idxint_dtype),
-                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
-            ),
-            shape=matrix.shape,
-            copy=False,
-        )
-    # The scipy solvers for the Pade approximant are more efficient with the
-    # CSC format than the CSR one.
-    csc = matrix.as_scipy().tocsc()
-    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
-               tidyup=settings.core['auto_tidyup'])
-
-
-def expm_csr_dense(matrix: CSR) -> Dense:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only exponentiate square matrix")
-    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
-
-
-def expm_dense(matrix: Dense) -> Dense:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only exponentiate square matrix")
-    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-
-expm = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='expm',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
-expm.add_specialisations([
-    (CSR, CSR, expm_csr),
-    (CSR, Dense, expm_csr_dense),
-    (Dense, Dense, expm_dense),
-], _defer=True)
-
-
-def logm_dense(matrix: Dense) -> Dense:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only compute logarithm square matrix")
-    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
-
-
-logm = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='logm',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
-logm.add_specialisations([
-    (Dense, Dense, logm_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+import numpy as np
+import scipy.sparse.linalg
+import scipy.linalg
+
+from .dense import Dense
+from .csr import CSR
+from .properties import isdiag_csr
+from qutip.settings import settings
+from .base import idxint_dtype
+
+__all__ = [
+    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
+    'logm', 'logm_dense',
+]
+
+
+def expm_csr(matrix: CSR) -> CSR:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    if isdiag_csr(matrix):
+        matrix_sci = matrix.as_scipy()
+        data = np.ones(matrix.shape[0], dtype=np.complex128)
+        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
+        return CSR(
+            (
+                data,
+                np.arange(matrix.shape[0], dtype=idxint_dtype),
+                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
+            ),
+            shape=matrix.shape,
+            copy=False,
+        )
+    # The scipy solvers for the Pade approximant are more efficient with the
+    # CSC format than the CSR one.
+    csc = matrix.as_scipy().tocsc()
+    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
+               tidyup=settings.core['auto_tidyup'])
+
+
+def expm_csr_dense(matrix: CSR) -> Dense:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
+
+
+def expm_dense(matrix: Dense) -> Dense:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+expm = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='expm',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
+expm.add_specialisations([
+    (CSR, CSR, expm_csr),
+    (CSR, Dense, expm_csr_dense),
+    (Dense, Dense, expm_dense),
+], _defer=True)
+
+
+def logm_dense(matrix: Dense) -> Dense:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only compute logarithm square matrix")
+    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
+
+
+logm = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='logm',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
+logm.add_specialisations([
+    (Dense, Dense, logm_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/inner.pxd b/qutip/core/data/inner.pxd
index 1d5000dd7a..2560e43586 100644
--- a/qutip/core/data/inner.pxd
+++ b/qutip/core/data/inner.pxd
@@ -1,6 +1,6 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index 9491970044..47331c7173 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -1,286 +1,286 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data cimport csr, dense
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.matmul cimport matmul_dense
-
-__all__ = [
-    'inner', 'inner_csr', 'inner_dense',
-    'inner_op', 'inner_op_csr', 'inner_op_dense',
-]
-
-
-cdef void _check_shape_inner(Data left, Data right) nogil except *:
-    if (
-        (left.shape[0] != 1 and left.shape[1] != 1)
-        or right.shape[1] != 1
-    ):
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-
-cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
-    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
-    cdef bint left_op = (
-        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
-        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
-    )
-    cdef bint op_right = op.shape[1] == right.shape[0]
-    cdef bint right_shape = right.shape[1] == 1
-    if not (left_shape and left_op and op_right and right_shape):
-        raise ValueError("".join([
-            "incompatible matrix shapes ",
-            str(left.shape),
-            ", ",
-            str(op.shape),
-            " and ",
-            str(right.shape),
-        ]))
-
-cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
-    cdef size_t col, ptr_bra, ptr_ket
-    cdef double complex out = 0
-    # We actually don't care if left is sorted or not.
-    for ptr_bra in range(csr.nnz(left)):
-        col = left.col_index[ptr_bra]
-        ptr_ket = right.row_index[col]
-        if right.row_index[col + 1] != ptr_ket:
-            out += left.data[ptr_bra] * right.data[ptr_ket]
-    return out
-
-cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
-    cdef size_t row, ptr_l, ptr_r
-    cdef double complex out = 0
-    for row in range(left.shape[0]):
-        ptr_l = left.row_index[row]
-        ptr_r = right.row_index[row]
-        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
-            out += conj(left.data[ptr_l]) * right.data[ptr_r]
-    return out
-
-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
-    """
-    Compute the complex inner product <left|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner(left, right)
-    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
-        if csr.nnz(left) and csr.nnz(right):
-            return (
-                conj(left.data[0]) * right.data[0] if scalar_is_ket
-                else left.data[0] * right.data[0]
-            )
-        return 0
-    if left.shape[0] == 1:
-        return _inner_csr_bra_ket(left, right)
-    return _inner_csr_ket_ket(left, right)
-
-cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
-    """
-    Compute the complex inner product <left|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner(left, right)
-    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
-        return (
-                conj(left.data[0]) * right.data[0] if scalar_is_ket
-                else left.data[0] * right.data[0]
-        )
-    cdef double complex out = 0
-    cdef size_t i
-    if left.shape[0] == 1:
-        for i in range(right.shape[0]):
-            out += left.data[i] * right.data[i]
-    else:
-        for i in range(right.shape[0]):
-            out += conj(left.data[i]) * right.data[i]
-    return out
-
-
-cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
-    cdef size_t ptr_l, ptr_op, ptr_r, row, col
-    cdef double complex sum, out=0
-    # left does not need to be sorted.
-    for ptr_l in range(csr.nnz(left)):
-        row = left.col_index[ptr_l]
-        sum = 0
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            ptr_r = right.row_index[col]
-            if ptr_r != right.row_index[col + 1]:
-                sum += op.data[ptr_op] * right.data[ptr_r]
-        out += left.data[ptr_l] * sum
-    return out
-
-cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
-    cdef size_t ptr_l, ptr_op, ptr_r, row, col
-    cdef double complex sum, out=0
-    for row in range(op.shape[0]):
-        ptr_l = left.row_index[row]
-        if left.row_index[row + 1] == ptr_l:
-            continue
-        sum = 0
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            ptr_r = right.row_index[col]
-            if ptr_r != right.row_index[col + 1]:
-                sum += op.data[ptr_op] * right.data[ptr_r]
-        out += conj(left.data[ptr_l]) * sum
-    return out
-
-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
-                                  bint scalar_is_ket=False) nogil except *:
-    """
-    Compute the complex inner product <left|op|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner_op(left, op, right)
-    cdef double complex l
-    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
-        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
-            return 0
-        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
-        return l * op.data[0] * right.data[0]
-    if left.shape[0] == 1:
-        return _inner_op_csr_bra_ket(left, op, right)
-    return _inner_op_csr_ket_ket(left, op, right)
-
-cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
-                                  bint scalar_is_ket=False) except *:
-    """
-    Compute the complex inner product <left|op|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner_op(left, op, right)
-    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-inner = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=False),
-    ]),
-    name='inner',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=False,
-)
-inner.__doc__ =\
-    """
-    Compute the complex inner product <left|right>.  Return the complex value.
-
-    The shape of `left` is used to determine if it has been supplied as a ket
-    or a bra.  The result of this function will be identical if passed `left`
-    or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-
-    Parameters
-    ----------
-    left : Data
-        The left operand as either a bra or a ket matrix.
-
-    right : Data
-        The right operand as a ket matrix.
-
-    scalar_is_ket : bool, optional (False)
-        If `False`, then `left` is assumed to be a bra if it is
-        one-dimensional.  If `True`, then it is assumed to be a ket.  This
-        parameter is ignored if `left` and `right` are not one-dimensional.
-    """
-inner.add_specialisations([
-    (CSR, CSR, inner_csr),
-    (Dense, Dense, inner_dense),
-], _defer=True)
-
-inner_op = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=False),
-    ]),
-    name='inner_op',
-    module=__name__,
-    inputs=('left', 'op', 'right'),
-    out=False,
-)
-inner_op.__doc__ =\
-    """
-    Compute the complex inner product <left|op|right>.  Return the complex
-    value.  This operation is also known as taking a matrix element.
-
-    The shape of `left` is used to determine if it has been supplied as a ket
-    or a bra.  The result of this function will be identical if passed `left`
-    or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-
-    Parameters
-    ----------
-    left : Data
-        The left operand as either a bra or a ket matrix.
-
-    op : Data
-        The operator of which to take the matrix element.  Must have dimensions
-        which match `left` and `right`.
-
-    right : Data
-        The right operand as a ket matrix.
-
-    scalar_is_ket : bool, optional (False)
-        If `False`, then `left` is assumed to be a bra if it is
-        one-dimensional.  If `True`, then it is assumed to be a ket.  This
-        parameter is ignored if `left` and `right` are not one-dimensional.
-    """
-inner_op.add_specialisations([
-    (CSR, CSR, CSR, inner_op_csr),
-    (Dense, Dense, Dense, inner_op_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data cimport csr, dense
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.matmul cimport matmul_dense
+
+__all__ = [
+    'inner', 'inner_csr', 'inner_dense',
+    'inner_op', 'inner_op_csr', 'inner_op_dense',
+]
+
+
+cdef void _check_shape_inner(Data left, Data right) nogil except *:
+    if (
+        (left.shape[0] != 1 and left.shape[1] != 1)
+        or right.shape[1] != 1
+    ):
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+
+cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
+    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
+    cdef bint left_op = (
+        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
+        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
+    )
+    cdef bint op_right = op.shape[1] == right.shape[0]
+    cdef bint right_shape = right.shape[1] == 1
+    if not (left_shape and left_op and op_right and right_shape):
+        raise ValueError("".join([
+            "incompatible matrix shapes ",
+            str(left.shape),
+            ", ",
+            str(op.shape),
+            " and ",
+            str(right.shape),
+        ]))
+
+cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
+    cdef size_t col, ptr_bra, ptr_ket
+    cdef double complex out = 0
+    # We actually don't care if left is sorted or not.
+    for ptr_bra in range(csr.nnz(left)):
+        col = left.col_index[ptr_bra]
+        ptr_ket = right.row_index[col]
+        if right.row_index[col + 1] != ptr_ket:
+            out += left.data[ptr_bra] * right.data[ptr_ket]
+    return out
+
+cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
+    cdef size_t row, ptr_l, ptr_r
+    cdef double complex out = 0
+    for row in range(left.shape[0]):
+        ptr_l = left.row_index[row]
+        ptr_r = right.row_index[row]
+        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
+            out += conj(left.data[ptr_l]) * right.data[ptr_r]
+    return out
+
+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner(left, right)
+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+        if csr.nnz(left) and csr.nnz(right):
+            return (
+                conj(left.data[0]) * right.data[0] if scalar_is_ket
+                else left.data[0] * right.data[0]
+            )
+        return 0
+    if left.shape[0] == 1:
+        return _inner_csr_bra_ket(left, right)
+    return _inner_csr_ket_ket(left, right)
+
+cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner(left, right)
+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+        return (
+                conj(left.data[0]) * right.data[0] if scalar_is_ket
+                else left.data[0] * right.data[0]
+        )
+    cdef double complex out = 0
+    cdef size_t i
+    if left.shape[0] == 1:
+        for i in range(right.shape[0]):
+            out += left.data[i] * right.data[i]
+    else:
+        for i in range(right.shape[0]):
+            out += conj(left.data[i]) * right.data[i]
+    return out
+
+
+cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
+    cdef size_t ptr_l, ptr_op, ptr_r, row, col
+    cdef double complex sum, out=0
+    # left does not need to be sorted.
+    for ptr_l in range(csr.nnz(left)):
+        row = left.col_index[ptr_l]
+        sum = 0
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            ptr_r = right.row_index[col]
+            if ptr_r != right.row_index[col + 1]:
+                sum += op.data[ptr_op] * right.data[ptr_r]
+        out += left.data[ptr_l] * sum
+    return out
+
+cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
+    cdef size_t ptr_l, ptr_op, ptr_r, row, col
+    cdef double complex sum, out=0
+    for row in range(op.shape[0]):
+        ptr_l = left.row_index[row]
+        if left.row_index[row + 1] == ptr_l:
+            continue
+        sum = 0
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            ptr_r = right.row_index[col]
+            if ptr_r != right.row_index[col + 1]:
+                sum += op.data[ptr_op] * right.data[ptr_r]
+        out += conj(left.data[ptr_l]) * sum
+    return out
+
+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
+                                  bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|op|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner_op(left, op, right)
+    cdef double complex l
+    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
+        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
+            return 0
+        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
+        return l * op.data[0] * right.data[0]
+    if left.shape[0] == 1:
+        return _inner_op_csr_bra_ket(left, op, right)
+    return _inner_op_csr_ket_ket(left, op, right)
+
+cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
+                                  bint scalar_is_ket=False) except *:
+    """
+    Compute the complex inner product <left|op|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner_op(left, op, right)
+    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+inner = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=False),
+    ]),
+    name='inner',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=False,
+)
+inner.__doc__ =\
+    """
+    Compute the complex inner product <left|right>.  Return the complex value.
+
+    The shape of `left` is used to determine if it has been supplied as a ket
+    or a bra.  The result of this function will be identical if passed `left`
+    or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+
+    Parameters
+    ----------
+    left : Data
+        The left operand as either a bra or a ket matrix.
+
+    right : Data
+        The right operand as a ket matrix.
+
+    scalar_is_ket : bool, optional (False)
+        If `False`, then `left` is assumed to be a bra if it is
+        one-dimensional.  If `True`, then it is assumed to be a ket.  This
+        parameter is ignored if `left` and `right` are not one-dimensional.
+    """
+inner.add_specialisations([
+    (CSR, CSR, inner_csr),
+    (Dense, Dense, inner_dense),
+], _defer=True)
+
+inner_op = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=False),
+    ]),
+    name='inner_op',
+    module=__name__,
+    inputs=('left', 'op', 'right'),
+    out=False,
+)
+inner_op.__doc__ =\
+    """
+    Compute the complex inner product <left|op|right>.  Return the complex
+    value.  This operation is also known as taking a matrix element.
+
+    The shape of `left` is used to determine if it has been supplied as a ket
+    or a bra.  The result of this function will be identical if passed `left`
+    or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+
+    Parameters
+    ----------
+    left : Data
+        The left operand as either a bra or a ket matrix.
+
+    op : Data
+        The operator of which to take the matrix element.  Must have dimensions
+        which match `left` and `right`.
+
+    right : Data
+        The right operand as a ket matrix.
+
+    scalar_is_ket : bool, optional (False)
+        If `False`, then `left` is assumed to be a bra if it is
+        one-dimensional.  If `True`, then it is assumed to be a ket.  This
+        parameter is ignored if `left` and `right` are not one-dimensional.
+    """
+inner_op.add_specialisations([
+    (CSR, CSR, CSR, inner_op_csr),
+    (Dense, Dense, Dense, inner_op_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/kron.pxd b/qutip/core/data/kron.pxd
index 6caa261983..89f717f8a7 100644
--- a/qutip/core/data/kron.pxd
+++ b/qutip/core/data/kron.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR kron_csr(CSR left, CSR right)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR kron_csr(CSR left, CSR right)
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index fd94adc369..5cd9d5697b 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -1,91 +1,91 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data cimport csr
-import numpy
-
-__all__ = [
-    'kron', 'kron_csr', 'kron_dense'
-]
-
-
-@cython.overflowcheck(True)
-cdef idxint _mul_checked(idxint a, idxint b):
-    return a * b
-
-
-cpdef Dense kron_dense(Dense left, Dense right):
-    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
-
-
-cpdef CSR kron_csr(CSR left, CSR right):
-    """Kronecker product of two CSR matrices."""
-    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
-    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
-    cdef idxint row_l, row_r, row_out
-    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
-    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
-    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
-                             _mul_checked(ncols_l, ncols_r),
-                             _mul_checked(csr.nnz(left), csr.nnz(right)))
-    with nogil:
-        row_out = 0
-        out.row_index[row_out] = 0
-        for row_l in range(nrows_l):
-            ptr_start_l = left.row_index[row_l]
-            ptr_end_l = left.row_index[row_l + 1]
-            dist_l = ptr_end_l - ptr_start_l
-
-            for row_r in range(nrows_r):
-                ptr_start_r = right.row_index[row_r]
-                ptr_end_r = right.row_index[row_r + 1]
-                dist_r = ptr_end_r - ptr_start_r
-
-                ptr_start_out = out.row_index[row_out]
-                ptr_end_out = ptr_start_out + dist_r
-
-                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
-                row_out += 1
-
-                for ptr_l in range(ptr_start_l, ptr_end_l):
-                    ptr_r = ptr_start_r
-                    for ptr_out in range(ptr_start_out, ptr_end_out):
-                        out.col_index[ptr_out] =\
-                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
-                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
-                        ptr_r += 1
-
-                    ptr_start_out += dist_r
-                    ptr_end_out += dist_r
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-kron = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='kron',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-kron.__doc__ =\
-    """
-    Compute the Kronecker product of two matrices.  This is used to represent
-    quantum tensor products of vector spaces.
-    """
-kron.add_specialisations([
-    (CSR, CSR, CSR, kron_csr),
-    (Dense, Dense, Dense, kron_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data cimport csr
+import numpy
+
+__all__ = [
+    'kron', 'kron_csr', 'kron_dense'
+]
+
+
+@cython.overflowcheck(True)
+cdef idxint _mul_checked(idxint a, idxint b):
+    return a * b
+
+
+cpdef Dense kron_dense(Dense left, Dense right):
+    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
+
+
+cpdef CSR kron_csr(CSR left, CSR right):
+    """Kronecker product of two CSR matrices."""
+    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
+    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
+    cdef idxint row_l, row_r, row_out
+    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
+    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
+    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
+                             _mul_checked(ncols_l, ncols_r),
+                             _mul_checked(csr.nnz(left), csr.nnz(right)))
+    with nogil:
+        row_out = 0
+        out.row_index[row_out] = 0
+        for row_l in range(nrows_l):
+            ptr_start_l = left.row_index[row_l]
+            ptr_end_l = left.row_index[row_l + 1]
+            dist_l = ptr_end_l - ptr_start_l
+
+            for row_r in range(nrows_r):
+                ptr_start_r = right.row_index[row_r]
+                ptr_end_r = right.row_index[row_r + 1]
+                dist_r = ptr_end_r - ptr_start_r
+
+                ptr_start_out = out.row_index[row_out]
+                ptr_end_out = ptr_start_out + dist_r
+
+                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
+                row_out += 1
+
+                for ptr_l in range(ptr_start_l, ptr_end_l):
+                    ptr_r = ptr_start_r
+                    for ptr_out in range(ptr_start_out, ptr_end_out):
+                        out.col_index[ptr_out] =\
+                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
+                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
+                        ptr_r += 1
+
+                    ptr_start_out += dist_r
+                    ptr_end_out += dist_r
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+kron = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='kron',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+kron.__doc__ =\
+    """
+    Compute the Kronecker product of two matrices.  This is used to represent
+    quantum tensor products of vector spaces.
+    """
+kron.add_specialisations([
+    (CSR, CSR, CSR, kron_csr),
+    (Dense, Dense, Dense, kron_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/linalg.py b/qutip/core/data/linalg.py
index f55077381c..e3847257ad 100644
--- a/qutip/core/data/linalg.py
+++ b/qutip/core/data/linalg.py
@@ -1,55 +1,55 @@
-import scipy.linalg
-import scipy.sparse
-from .dense import Dense
-from .csr import CSR
-
-__all__ = ['inv', 'inv_csr', 'inv_dense']
-
-
-def inv_dense(data):
-    """Compute the inverse of a matrix"""
-    if not isinstance(data, Dense):
-        raise TypeError("expected data in Dense format but got "
-                        + str(type(data)))
-    if data.shape[0] != data.shape[1]:
-        raise ValueError('Cannot compute the matrix inverse'
-                         ' of a nonsquare matrix')
-    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
-
-
-def inv_csr(data):
-    """Compute the inverse of a sparse matrix"""
-    if not isinstance(data, CSR):
-        raise TypeError("expected data in CSR format but got "
-                        + str(type(data)))
-    if data.shape[0] != data.shape[1]:
-        raise ValueError('Cannot compute the matrix inverse '
-                         'of a nonsquare matrix')
-    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
-    # scipy.sparse.linalg.inv can return dense or sparse arrays.
-    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-
-inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
-inv.__doc__ =\
-    """
-    Return matrix inverse for a data-layer object.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-
-    Returns
-    -------
-    inverse : Data
-        Inverse of data
-    """
-inv.add_specialisations([
-    (CSR, CSR, inv_csr),
-    (Dense, Dense, inv_dense),
-], _defer=True)
-
-del _Dispatcher
+import scipy.linalg
+import scipy.sparse
+from .dense import Dense
+from .csr import CSR
+
+__all__ = ['inv', 'inv_csr', 'inv_dense']
+
+
+def inv_dense(data):
+    """Compute the inverse of a matrix"""
+    if not isinstance(data, Dense):
+        raise TypeError("expected data in Dense format but got "
+                        + str(type(data)))
+    if data.shape[0] != data.shape[1]:
+        raise ValueError('Cannot compute the matrix inverse'
+                         ' of a nonsquare matrix')
+    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
+
+
+def inv_csr(data):
+    """Compute the inverse of a sparse matrix"""
+    if not isinstance(data, CSR):
+        raise TypeError("expected data in CSR format but got "
+                        + str(type(data)))
+    if data.shape[0] != data.shape[1]:
+        raise ValueError('Cannot compute the matrix inverse '
+                         'of a nonsquare matrix')
+    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
+    # scipy.sparse.linalg.inv can return dense or sparse arrays.
+    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+
+inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
+inv.__doc__ =\
+    """
+    Return matrix inverse for a data-layer object.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+
+    Returns
+    -------
+    inverse : Data
+        Inverse of data
+    """
+inv.add_specialisations([
+    (CSR, CSR, inv_csr),
+    (Dense, Dense, inv_dense),
+], _defer=True)
+
+del _Dispatcher
diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
index 8b34d6565c..69f1ddcba6 100644
--- a/qutip/core/data/make.py
+++ b/qutip/core/data/make.py
@@ -1,101 +1,101 @@
-from .dispatch import Dispatcher as _Dispatcher
-from . import csr, dense, CSR, Dense
-
-__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
-
-
-def _diag_signature(diagonals, offsets=0, shape=None):
-    """
-    Construct a matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements. Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    pass
-
-
-diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
-diag.add_specialisations([
-    (CSR, csr.diags),
-    (Dense, dense.diags),
-], _defer=True)
-
-del _diag_signature
-
-
-def one_element_csr(shape, position, value=1.0):
-    """
-    Create a matrix with only one nonzero element.
-
-    Parameters
-    ----------
-    shape : tuple
-        The shape of the output as (``rows``, ``columns``).
-
-    position : tuple
-        The position of the non zero in the matrix as (``rows``, ``columns``).
-
-    value : complex, optional
-        The value of the non-null element.
-    """
-    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
-        raise ValueError("Position of the elements out of bound: " +
-                         str(position) + " in " + str(shape))
-    data = csr.empty(*shape, 1)
-    sci = data.as_scipy(full=True)
-    sci.data[0] = value
-    sci.indices[0] = position[1]
-    sci.indptr[:position[0]+1] = 0
-    sci.indptr[position[0]+1:] = 1
-    return data
-
-
-def one_element_dense(shape, position, value=1.0):
-    """
-    Create a matrix with only one nonzero element.
-
-    Parameters
-    ----------
-    shape : tuple
-        The shape of the output as (``rows``, ``columns``).
-
-    position : tuple
-        The position of the non zero in the matrix as (``rows``, ``columns``).
-
-    value : complex, optional
-        The value of the non-null element.
-    """
-    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
-        raise ValueError("Position of the elements out of bound: " +
-                         str(position) + " in " + str(shape))
-    data = dense.zeros(*shape, 1)
-    nda = data.as_ndarray()
-    nda[position] = value
-    return data
-
-
-one_element = _Dispatcher(one_element_dense, name='one_element',
-                          inputs=(), out=True)
-one_element.add_specialisations([
-    (CSR, one_element_csr),
-    (Dense, one_element_dense),
-], _defer=True)
+from .dispatch import Dispatcher as _Dispatcher
+from . import csr, dense, CSR, Dense
+
+__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
+
+
+def _diag_signature(diagonals, offsets=0, shape=None):
+    """
+    Construct a matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements. Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    pass
+
+
+diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
+diag.add_specialisations([
+    (CSR, csr.diags),
+    (Dense, dense.diags),
+], _defer=True)
+
+del _diag_signature
+
+
+def one_element_csr(shape, position, value=1.0):
+    """
+    Create a matrix with only one nonzero element.
+
+    Parameters
+    ----------
+    shape : tuple
+        The shape of the output as (``rows``, ``columns``).
+
+    position : tuple
+        The position of the non zero in the matrix as (``rows``, ``columns``).
+
+    value : complex, optional
+        The value of the non-null element.
+    """
+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+        raise ValueError("Position of the elements out of bound: " +
+                         str(position) + " in " + str(shape))
+    data = csr.empty(*shape, 1)
+    sci = data.as_scipy(full=True)
+    sci.data[0] = value
+    sci.indices[0] = position[1]
+    sci.indptr[:position[0]+1] = 0
+    sci.indptr[position[0]+1:] = 1
+    return data
+
+
+def one_element_dense(shape, position, value=1.0):
+    """
+    Create a matrix with only one nonzero element.
+
+    Parameters
+    ----------
+    shape : tuple
+        The shape of the output as (``rows``, ``columns``).
+
+    position : tuple
+        The position of the non zero in the matrix as (``rows``, ``columns``).
+
+    value : complex, optional
+        The value of the non-null element.
+    """
+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+        raise ValueError("Position of the elements out of bound: " +
+                         str(position) + " in " + str(shape))
+    data = dense.zeros(*shape, 1)
+    nda = data.as_ndarray()
+    nda[position] = value
+    return data
+
+
+one_element = _Dispatcher(one_element_dense, name='one_element',
+                          inputs=(), out=True)
+one_element.add_specialisations([
+    (CSR, one_element_csr),
+    (Dense, one_element_dense),
+], _defer=True)
diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
index 54d21798d0..b9d85556bb 100644
--- a/qutip/core/data/matmul.pxd
+++ b/qutip/core/data/matmul.pxd
@@ -1,14 +1,14 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.base cimport Data
-
-cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
-cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
-cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
-cdef Dense matmul_data_dense(Data left, Dense right)
-cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
-
-cpdef Dense multiply_dense(Dense left, Dense right)
-cpdef CSR multiply_csr(CSR left, CSR right)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.base cimport Data
+
+cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
+cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
+cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
+cdef Dense matmul_data_dense(Data left, Dense right)
+cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
+
+cpdef Dense multiply_dense(Dense left, Dense right)
+cpdef CSR multiply_csr(CSR left, CSR right)
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 1d05387961..d2d67e9723 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -1,474 +1,474 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-from libc.math cimport fabs
-
-import warnings
-from qutip.settings import settings
-
-cimport cython
-
-from cpython cimport mem
-
-import numpy as np
-cimport numpy as cnp
-from scipy.linalg cimport cython_blas as blas
-
-from qutip.core.data.base import idxint_dtype
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.csr cimport CSR
-from qutip.core.data cimport csr, dense
-from qutip.core.data.add cimport iadd_dense, add_csr
-from qutip.core.data.dense import OrderEfficiencyWarning
-
-cnp.import_array()
-
-cdef extern from *:
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-# This function is templated over integral types on import to allow `idxint` to
-# be any signed integer (though likely things will only work for >=32-bit).  To
-# change integral types, you only need to change the `idxint` definitions in
-# `core.data.base` at compile-time.
-cdef extern from "src/matmul_csr_vector.hpp" nogil:
-    void _matmul_csr_vector[T](
-        double complex *data, T *col_index, T *row_index,
-        double complex *vec, double complex scale, double complex *out,
-        T nrows)
-
-__all__ = [
-    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
-    'multiply', 'multiply_csr', 'multiply_dense',
-]
-
-
-cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
-    if left.shape[1] != right.shape[0]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-    if (
-        out is not None
-        and out.shape[0] != left.shape[0]
-        and out.shape[1] != right.shape[1]
-    ):
-        raise ValueError(
-            "incompatible output shape, got "
-            + str(out.shape)
-            + " but needed "
-            + str((left.shape[0], right.shape[1]))
-        )
-
-
-cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
-    """
-    Produce a sensible upper-bound for the number of non-zero elements that
-    will be present in a matrix multiplication between the two matrices.
-    """
-    cdef idxint j, k, nnz=0
-    cdef idxint ii, jj, kk
-    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
-    # Setup mask array
-    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
-    with nogil:
-        for ii in range(ncols):
-            mask[ii] = -1
-        for ii in range(nrows):
-            for jj in range(left.row_index[ii], left.row_index[ii+1]):
-                j = left.col_index[jj]
-                for kk in range(right.row_index[j], right.row_index[j+1]):
-                    k = right.col_index[kk]
-                    if mask[k] != ii:
-                        mask[k] = ii
-                        nnz += 1
-    mem.PyMem_Free(mask)
-    return nnz
-
-
-cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
-    """
-    Multiply two CSR matrices together to produce another CSR.  If `out` is
-    specified, it must be pre-allocated with enough space to hold the output
-    result.
-
-    This is the operation
-        ``out := left @ right``
-    where `out` will be allocated if not supplied.
-
-    Parameters
-    ----------
-    left : CSR
-        CSR matrix on the left of the multiplication.
-    right : CSR
-        CSR matrix on the right of the multiplication.
-    out : optional CSR
-        Allocated space to store the result.  This must have enough space in
-        the `data`, `col_index` and `row_index` pointers already allocated.
-
-    Returns
-    -------
-    out : CSR
-        The result of the matrix multiplication.  This will be the same object
-        as the input parameter `out` if that was supplied.
-    """
-    _check_shape(left, right)
-    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
-    if out is not None:
-        raise TypeError("passing an `out` entry for CSR operations makes no sense")
-    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
-    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
-        # Ensure the out array row_index is zeroed.  The others need not be,
-        # because they don't represent valid entries since row_index is zeroed.
-        with nogil:
-            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
-        return out
-
-    # Initialise actual matrix multiplication.
-    nnz = 0
-    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
-    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
-    cdef double complex val
-    cdef double complex *sums
-    cdef idxint *nxt
-    cdef double tol = 0
-    if settings.core['auto_tidyup']:
-        tol = settings.core['auto_tidyup_atol']
-    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
-    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
-    with nogil:
-        for col_r in range(ncols):
-            nxt[col_r] = -1
-
-        # Perform operation.
-        out.row_index[0] = 0
-        for row_l in range(nrows):
-            head = -2
-            length = 0
-            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
-                row_r = left.col_index[ptr_l]
-                val = left.data[ptr_l]
-                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
-                    col_r = right.col_index[ptr_r]
-                    sums[col_r] += val * right.data[ptr_r]
-                    if nxt[col_r] == -1:
-                        nxt[col_r] = head
-                        head = col_r
-                        length += 1
-            for col_r in range(length):
-                if fabs(sums[head].real) < tol:
-                    sums[head].real = 0
-                if fabs(sums[head].imag) < tol:
-                    sums[head].imag = 0
-                if sums[head] != 0:
-                    out.col_index[nnz] = head
-                    out.data[nnz] = scale * sums[head]
-                    nnz += 1
-                tmp = head
-                head = nxt[head]
-                nxt[tmp] = -1
-                sums[tmp] = 0
-            out.row_index[row_l + 1] = nnz
-    mem.PyMem_Free(sums)
-    mem.PyMem_Free(nxt)
-    return out
-
-
-cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
-                                   double complex scale=1, Dense out=None):
-    """
-    Perform the operation
-        ``out := scale * (left @ right) + out``
-    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
-    defaulting to 1.
-
-    If `out` is not given, it will be allocated as if it were a zero matrix.
-    """
-    _check_shape(left, right, out)
-    cdef Dense tmp = None
-    if out is None:
-        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
-    if bool(right.fortran) != bool(out.fortran):
-        msg = (
-            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
-            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
-        )
-        warnings.warn(msg, OrderEfficiencyWarning)
-        # Rather than making loads of copies of the same code, we just moan at
-        # the user and then transpose one of the arrays.  We prefer to have
-        # `right` in Fortran-order for cache efficiency.
-        if right.fortran:
-            tmp = out
-            out = out.reorder()
-        else:
-            right = right.reorder()
-    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
-    cdef double complex val
-    if right.fortran:
-        idx_r = idx_out = 0
-        for _ in range(ncols):
-            _matmul_csr_vector(left.data, left.col_index, left.row_index,
-                               right.data + idx_r,
-                               scale,
-                               out.data + idx_out,
-                               nrows)
-            idx_out += nrows
-            idx_r += right.shape[0]
-    else:
-        for row in range(nrows):
-            for ptr in range(left.row_index[row], left.row_index[row + 1]):
-                val = scale * left.data[ptr]
-                idx_out = row * ncols
-                idx_r = left.col_index[ptr] * ncols
-                for _ in range(ncols):
-                    out.data[idx_out] += val * right.data[idx_r]
-                    idx_out += 1
-                    idx_r += 1
-    if tmp is None:
-        return out
-    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
-    return tmp
-
-
-cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
-    """
-    Perform the operation
-        ``out := scale * (left @ right) + out``
-    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
-    defaulting to 1.
-
-    If `out` is not given, it will be allocated as if it were a zero matrix.
-    """
-    _check_shape(left, right, out)
-    cdef double complex out_scale
-    # If not supplied, it's more efficient from a memory allocation perspective
-    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
-    if out is None:
-        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
-        out_scale = 0
-    else:
-        out_scale = 1
-    cdef double complex *a
-    cdef double complex *b
-    cdef char transa, transb
-    cdef int m, n, k=left.shape[1], lda, ldb
-    if right.shape[1] == 1:
-        # Matrix Vector product
-        a, b = left.data, right.data
-        if left.fortran:
-            lda = left.shape[0]
-            transa = b'n'
-            m = left.shape[0]
-            n = left.shape[1]
-        else:
-            lda = left.shape[1]
-            transa = b't'
-            m = left.shape[1]
-            n = left.shape[0]
-        ldb = 1
-        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
-                   &out_scale, out.data, &ldb)
-        return out
-    # We use the BLAS routine zgemm for every single call and pretend that
-    # we're always supplying it with Fortran-ordered matrices, but to achieve
-    # what we want, we use the property of matrix multiplication that
-    #   A.B = (B'.A')'
-    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
-    # matrix as a C-ordered one is equivalent to taking the transpose.  If
-    # `right` is supplied in C-order, then from Fortran's perspective we
-    # actually have `B'`, so to retrieve `B` should we want to use it, we set
-    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
-    # need to switch the input order, _not_ whether we actually need B'.
-    #
-    # In order to make the output correct, we ensure that we put A.B in if the
-    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
-    # This is actually more flexible than `np.dot` which requires that the
-    # output is C-ordered.
-    if out.fortran:
-        # Need to make A.B
-        a, b = left.data, right.data
-        m, n = left.shape[0], right.shape[1]
-        lda = left.shape[0] if left.fortran else left.shape[1]
-        transa = b'n' if left.fortran else b't'
-        ldb = right.shape[0] if right.fortran else right.shape[1]
-        transb = b'n' if right.fortran else b't'
-    else:
-        # Need to make B'.A'
-        a, b = right.data, left.data
-        m, n = right.shape[1], left.shape[0]
-        lda = right.shape[0] if right.fortran else right.shape[1]
-        transa = b't' if right.fortran else b'n'
-        ldb = left.shape[0] if left.fortran else left.shape[1]
-        transb = b't' if left.fortran else b'n'
-    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
-               &out_scale, out.data, &m)
-    return out
-
-
-cpdef CSR multiply_csr(CSR left, CSR right):
-    """Element-wise multiplication of CSR matrices."""
-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-    cdef idxint col_left, left_nnz = csr.nnz(left)
-    cdef idxint col_right, right_nnz = csr.nnz(right)
-    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
-    cdef idxint row, nnz=0, ncols=left.shape[1]
-    cdef CSR out
-    cdef list nans=[]
-    # Fast paths for zero matrices.
-    if right_nnz == 0 or left_nnz == 0:
-        return csr.zeros(left.shape[0], left.shape[1])
-    # Main path.
-    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
-    out.row_index[0] = nnz
-    ptr_left_max = ptr_right_max = 0
-
-    for row in range(left.shape[0]):
-        ptr_left = ptr_left_max
-        ptr_left_max = left.row_index[row + 1]
-        ptr_right = ptr_right_max
-        ptr_right_max = right.row_index[row + 1]
-        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
-            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
-            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
-            if col_left == col_right:
-                out.col_index[nnz] = col_left
-                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
-                ptr_left += 1
-                ptr_right += 1
-                nnz += 1
-            elif col_left <= col_right:
-                if left.data[ptr_left] is np.nan:
-                    # Test for NaN since `NaN * 0 = NaN`
-                    nans.append((row, col_left))
-                ptr_left += 1
-            else:
-                if right.data[ptr_right] != right.data[ptr_right]:
-                    nans.append((row, col_right))
-                ptr_right += 1
-        out.row_index[row + 1] = nnz
-    if nans:
-        # We expect Nan to be rare enough that we don't allocate memory for
-        # them, but add them here after the loop.
-        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
-        nnz = nans_pos.shape[0]
-        nans_csr = csr.from_coo_pointers(
-            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
-            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
-            <double complex *> cnp.PyArray_GETPTR1(
-                np.array([np.nan]*nnz, dtype=np.complex128), 0),
-            left.shape[0], left.shape[1], nnz
-        )
-        out = add_csr(out, nans_csr)
-    return out
-
-
-cpdef Dense multiply_dense(Dense left, Dense right):
-    """Element-wise multiplication of Dense matrices."""
-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-# At the time of putting in the dispatchers, the idea of an "out" parameter
-# isn't really supported in the model; since `out` would be potentially
-# modified in-place, it couldn't safely go through a conversion process.  For
-# the dispatched operation, then, we omit the `scale` and `out` parameters, and
-# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
-# are needed, the library will have to manually do any relevant conversions,
-# and then call a direct specialisation (which are exported to the `data`
-# namespace).
-
-matmul = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='matmul',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-matmul.__doc__ =\
-    """
-    Compute the matrix multiplication of two matrices, with the operation
-        scale * (left @ right)
-    where `scale` is (optionally) a scalar, and `left` and `right` are
-    matrices.
-
-    Parameters
-    ----------
-    left : Data
-        The left operand as either a bra or a ket matrix.
-
-    right : Data
-        The right operand as a ket matrix.
-
-    scale : complex, optional
-        The scalar to multiply the output by.
-    """
-matmul.add_specialisations([
-    (CSR, CSR, CSR, matmul_csr),
-    (CSR, Dense, Dense, matmul_csr_dense_dense),
-    (Dense, Dense, Dense, matmul_dense),
-], _defer=True)
-
-
-multiply = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='multiply',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-multiply.__doc__ =\
-    """Element-wise multiplication of matrices."""
-multiply.add_specialisations([
-    (CSR, CSR, CSR, multiply_csr),
-    (Dense, Dense, Dense, multiply_dense),
-], _defer=True)
-
-
-del _inspect, _Dispatcher
-
-
-cdef Dense matmul_data_dense(Data left, Dense right):
-    cdef Dense out
-    if type(left) is CSR:
-        out = matmul_csr_dense_dense(left, right)
-    elif type(left) is Dense:
-        out = matmul_dense(left, right)
-    else:
-        out = matmul(left, right)
-    return out
-
-
-cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
-    if type(left) is CSR:
-        matmul_csr_dense_dense(left, right, scale, out)
-    elif type(left) is Dense:
-        matmul_dense(left, right, scale, out)
-    else:
-        iadd_dense(out, matmul(left, right), scale)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+from libc.math cimport fabs
+
+import warnings
+from qutip.settings import settings
+
+cimport cython
+
+from cpython cimport mem
+
+import numpy as np
+cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
+
+from qutip.core.data.base import idxint_dtype
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport CSR
+from qutip.core.data cimport csr, dense
+from qutip.core.data.add cimport iadd_dense, add_csr
+from qutip.core.data.dense import OrderEfficiencyWarning
+
+cnp.import_array()
+
+cdef extern from *:
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+# This function is templated over integral types on import to allow `idxint` to
+# be any signed integer (though likely things will only work for >=32-bit).  To
+# change integral types, you only need to change the `idxint` definitions in
+# `core.data.base` at compile-time.
+cdef extern from "src/matmul_csr_vector.hpp" nogil:
+    void _matmul_csr_vector[T](
+        double complex *data, T *col_index, T *row_index,
+        double complex *vec, double complex scale, double complex *out,
+        T nrows)
+
+__all__ = [
+    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
+    'multiply', 'multiply_csr', 'multiply_dense',
+]
+
+
+cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
+    if left.shape[1] != right.shape[0]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    if (
+        out is not None
+        and out.shape[0] != left.shape[0]
+        and out.shape[1] != right.shape[1]
+    ):
+        raise ValueError(
+            "incompatible output shape, got "
+            + str(out.shape)
+            + " but needed "
+            + str((left.shape[0], right.shape[1]))
+        )
+
+
+cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
+    """
+    Produce a sensible upper-bound for the number of non-zero elements that
+    will be present in a matrix multiplication between the two matrices.
+    """
+    cdef idxint j, k, nnz=0
+    cdef idxint ii, jj, kk
+    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
+    # Setup mask array
+    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
+    with nogil:
+        for ii in range(ncols):
+            mask[ii] = -1
+        for ii in range(nrows):
+            for jj in range(left.row_index[ii], left.row_index[ii+1]):
+                j = left.col_index[jj]
+                for kk in range(right.row_index[j], right.row_index[j+1]):
+                    k = right.col_index[kk]
+                    if mask[k] != ii:
+                        mask[k] = ii
+                        nnz += 1
+    mem.PyMem_Free(mask)
+    return nnz
+
+
+cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
+    """
+    Multiply two CSR matrices together to produce another CSR.  If `out` is
+    specified, it must be pre-allocated with enough space to hold the output
+    result.
+
+    This is the operation
+        ``out := left @ right``
+    where `out` will be allocated if not supplied.
+
+    Parameters
+    ----------
+    left : CSR
+        CSR matrix on the left of the multiplication.
+    right : CSR
+        CSR matrix on the right of the multiplication.
+    out : optional CSR
+        Allocated space to store the result.  This must have enough space in
+        the `data`, `col_index` and `row_index` pointers already allocated.
+
+    Returns
+    -------
+    out : CSR
+        The result of the matrix multiplication.  This will be the same object
+        as the input parameter `out` if that was supplied.
+    """
+    _check_shape(left, right)
+    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
+    if out is not None:
+        raise TypeError("passing an `out` entry for CSR operations makes no sense")
+    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
+    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
+        # Ensure the out array row_index is zeroed.  The others need not be,
+        # because they don't represent valid entries since row_index is zeroed.
+        with nogil:
+            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
+        return out
+
+    # Initialise actual matrix multiplication.
+    nnz = 0
+    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
+    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
+    cdef double complex val
+    cdef double complex *sums
+    cdef idxint *nxt
+    cdef double tol = 0
+    if settings.core['auto_tidyup']:
+        tol = settings.core['auto_tidyup_atol']
+    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
+    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
+    with nogil:
+        for col_r in range(ncols):
+            nxt[col_r] = -1
+
+        # Perform operation.
+        out.row_index[0] = 0
+        for row_l in range(nrows):
+            head = -2
+            length = 0
+            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
+                row_r = left.col_index[ptr_l]
+                val = left.data[ptr_l]
+                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
+                    col_r = right.col_index[ptr_r]
+                    sums[col_r] += val * right.data[ptr_r]
+                    if nxt[col_r] == -1:
+                        nxt[col_r] = head
+                        head = col_r
+                        length += 1
+            for col_r in range(length):
+                if fabs(sums[head].real) < tol:
+                    sums[head].real = 0
+                if fabs(sums[head].imag) < tol:
+                    sums[head].imag = 0
+                if sums[head] != 0:
+                    out.col_index[nnz] = head
+                    out.data[nnz] = scale * sums[head]
+                    nnz += 1
+                tmp = head
+                head = nxt[head]
+                nxt[tmp] = -1
+                sums[tmp] = 0
+            out.row_index[row_l + 1] = nnz
+    mem.PyMem_Free(sums)
+    mem.PyMem_Free(nxt)
+    return out
+
+
+cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
+                                   double complex scale=1, Dense out=None):
+    """
+    Perform the operation
+        ``out := scale * (left @ right) + out``
+    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
+    defaulting to 1.
+
+    If `out` is not given, it will be allocated as if it were a zero matrix.
+    """
+    _check_shape(left, right, out)
+    cdef Dense tmp = None
+    if out is None:
+        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
+    if bool(right.fortran) != bool(out.fortran):
+        msg = (
+            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
+            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
+        )
+        warnings.warn(msg, OrderEfficiencyWarning)
+        # Rather than making loads of copies of the same code, we just moan at
+        # the user and then transpose one of the arrays.  We prefer to have
+        # `right` in Fortran-order for cache efficiency.
+        if right.fortran:
+            tmp = out
+            out = out.reorder()
+        else:
+            right = right.reorder()
+    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
+    cdef double complex val
+    if right.fortran:
+        idx_r = idx_out = 0
+        for _ in range(ncols):
+            _matmul_csr_vector(left.data, left.col_index, left.row_index,
+                               right.data + idx_r,
+                               scale,
+                               out.data + idx_out,
+                               nrows)
+            idx_out += nrows
+            idx_r += right.shape[0]
+    else:
+        for row in range(nrows):
+            for ptr in range(left.row_index[row], left.row_index[row + 1]):
+                val = scale * left.data[ptr]
+                idx_out = row * ncols
+                idx_r = left.col_index[ptr] * ncols
+                for _ in range(ncols):
+                    out.data[idx_out] += val * right.data[idx_r]
+                    idx_out += 1
+                    idx_r += 1
+    if tmp is None:
+        return out
+    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
+    return tmp
+
+
+cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
+    """
+    Perform the operation
+        ``out := scale * (left @ right) + out``
+    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
+    defaulting to 1.
+
+    If `out` is not given, it will be allocated as if it were a zero matrix.
+    """
+    _check_shape(left, right, out)
+    cdef double complex out_scale
+    # If not supplied, it's more efficient from a memory allocation perspective
+    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
+    if out is None:
+        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
+        out_scale = 0
+    else:
+        out_scale = 1
+    cdef double complex *a
+    cdef double complex *b
+    cdef char transa, transb
+    cdef int m, n, k=left.shape[1], lda, ldb
+    if right.shape[1] == 1:
+        # Matrix Vector product
+        a, b = left.data, right.data
+        if left.fortran:
+            lda = left.shape[0]
+            transa = b'n'
+            m = left.shape[0]
+            n = left.shape[1]
+        else:
+            lda = left.shape[1]
+            transa = b't'
+            m = left.shape[1]
+            n = left.shape[0]
+        ldb = 1
+        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
+                   &out_scale, out.data, &ldb)
+        return out
+    # We use the BLAS routine zgemm for every single call and pretend that
+    # we're always supplying it with Fortran-ordered matrices, but to achieve
+    # what we want, we use the property of matrix multiplication that
+    #   A.B = (B'.A')'
+    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
+    # matrix as a C-ordered one is equivalent to taking the transpose.  If
+    # `right` is supplied in C-order, then from Fortran's perspective we
+    # actually have `B'`, so to retrieve `B` should we want to use it, we set
+    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
+    # need to switch the input order, _not_ whether we actually need B'.
+    #
+    # In order to make the output correct, we ensure that we put A.B in if the
+    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
+    # This is actually more flexible than `np.dot` which requires that the
+    # output is C-ordered.
+    if out.fortran:
+        # Need to make A.B
+        a, b = left.data, right.data
+        m, n = left.shape[0], right.shape[1]
+        lda = left.shape[0] if left.fortran else left.shape[1]
+        transa = b'n' if left.fortran else b't'
+        ldb = right.shape[0] if right.fortran else right.shape[1]
+        transb = b'n' if right.fortran else b't'
+    else:
+        # Need to make B'.A'
+        a, b = right.data, left.data
+        m, n = right.shape[1], left.shape[0]
+        lda = right.shape[0] if right.fortran else right.shape[1]
+        transa = b't' if right.fortran else b'n'
+        ldb = left.shape[0] if left.fortran else left.shape[1]
+        transb = b't' if left.fortran else b'n'
+    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
+               &out_scale, out.data, &m)
+    return out
+
+
+cpdef CSR multiply_csr(CSR left, CSR right):
+    """Element-wise multiplication of CSR matrices."""
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    cdef idxint col_left, left_nnz = csr.nnz(left)
+    cdef idxint col_right, right_nnz = csr.nnz(right)
+    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
+    cdef idxint row, nnz=0, ncols=left.shape[1]
+    cdef CSR out
+    cdef list nans=[]
+    # Fast paths for zero matrices.
+    if right_nnz == 0 or left_nnz == 0:
+        return csr.zeros(left.shape[0], left.shape[1])
+    # Main path.
+    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
+    out.row_index[0] = nnz
+    ptr_left_max = ptr_right_max = 0
+
+    for row in range(left.shape[0]):
+        ptr_left = ptr_left_max
+        ptr_left_max = left.row_index[row + 1]
+        ptr_right = ptr_right_max
+        ptr_right_max = right.row_index[row + 1]
+        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
+            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
+            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
+            if col_left == col_right:
+                out.col_index[nnz] = col_left
+                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
+                ptr_left += 1
+                ptr_right += 1
+                nnz += 1
+            elif col_left <= col_right:
+                if left.data[ptr_left] is np.nan:
+                    # Test for NaN since `NaN * 0 = NaN`
+                    nans.append((row, col_left))
+                ptr_left += 1
+            else:
+                if right.data[ptr_right] != right.data[ptr_right]:
+                    nans.append((row, col_right))
+                ptr_right += 1
+        out.row_index[row + 1] = nnz
+    if nans:
+        # We expect Nan to be rare enough that we don't allocate memory for
+        # them, but add them here after the loop.
+        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
+        nnz = nans_pos.shape[0]
+        nans_csr = csr.from_coo_pointers(
+            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
+            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
+            <double complex *> cnp.PyArray_GETPTR1(
+                np.array([np.nan]*nnz, dtype=np.complex128), 0),
+            left.shape[0], left.shape[1], nnz
+        )
+        out = add_csr(out, nans_csr)
+    return out
+
+
+cpdef Dense multiply_dense(Dense left, Dense right):
+    """Element-wise multiplication of Dense matrices."""
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+# At the time of putting in the dispatchers, the idea of an "out" parameter
+# isn't really supported in the model; since `out` would be potentially
+# modified in-place, it couldn't safely go through a conversion process.  For
+# the dispatched operation, then, we omit the `scale` and `out` parameters, and
+# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
+# are needed, the library will have to manually do any relevant conversions,
+# and then call a direct specialisation (which are exported to the `data`
+# namespace).
+
+matmul = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='matmul',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+matmul.__doc__ =\
+    """
+    Compute the matrix multiplication of two matrices, with the operation
+        scale * (left @ right)
+    where `scale` is (optionally) a scalar, and `left` and `right` are
+    matrices.
+
+    Parameters
+    ----------
+    left : Data
+        The left operand as either a bra or a ket matrix.
+
+    right : Data
+        The right operand as a ket matrix.
+
+    scale : complex, optional
+        The scalar to multiply the output by.
+    """
+matmul.add_specialisations([
+    (CSR, CSR, CSR, matmul_csr),
+    (CSR, Dense, Dense, matmul_csr_dense_dense),
+    (Dense, Dense, Dense, matmul_dense),
+], _defer=True)
+
+
+multiply = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='multiply',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+multiply.__doc__ =\
+    """Element-wise multiplication of matrices."""
+multiply.add_specialisations([
+    (CSR, CSR, CSR, multiply_csr),
+    (Dense, Dense, Dense, multiply_dense),
+], _defer=True)
+
+
+del _inspect, _Dispatcher
+
+
+cdef Dense matmul_data_dense(Data left, Dense right):
+    cdef Dense out
+    if type(left) is CSR:
+        out = matmul_csr_dense_dense(left, right)
+    elif type(left) is Dense:
+        out = matmul_dense(left, right)
+    else:
+        out = matmul(left, right)
+    return out
+
+
+cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
+    if type(left) is CSR:
+        matmul_csr_dense_dense(left, right, scale, out)
+    elif type(left) is Dense:
+        matmul_dense(left, right, scale, out)
+    else:
+        iadd_dense(out, matmul(left, right), scale)
diff --git a/qutip/core/data/mul.pxd b/qutip/core/data/mul.pxd
index 2c29259631..f935e1ee07 100644
--- a/qutip/core/data/mul.pxd
+++ b/qutip/core/data/mul.pxd
@@ -1,13 +1,13 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense, Data
-
-cpdef CSR imul_csr(CSR matrix, double complex value)
-cpdef CSR mul_csr(CSR matrix, double complex value)
-cpdef CSR neg_csr(CSR matrix)
-
-cpdef Dense imul_dense(Dense matrix, double complex value)
-cpdef Dense mul_dense(Dense matrix, double complex value)
-cpdef Dense neg_dense(Dense matrix)
-
-cpdef Data imul_data(Data matrix, double complex value)
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense, Data
+
+cpdef CSR imul_csr(CSR matrix, double complex value)
+cpdef CSR mul_csr(CSR matrix, double complex value)
+cpdef CSR neg_csr(CSR matrix)
+
+cpdef Dense imul_dense(Dense matrix, double complex value)
+cpdef Dense mul_dense(Dense matrix, double complex value)
+cpdef Dense neg_dense(Dense matrix)
+
+cpdef Data imul_data(Data matrix, double complex value)
diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 439c6cf694..80928edee1 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -1,134 +1,134 @@
-#cython: language_level=3
-#cython: boundscheck=False, wrapround=False, initializedcheck=False
-
-from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
-from scipy.linalg.cython_blas cimport zscal
-
-__all__ = [
-    'mul', 'mul_csr', 'mul_dense',
-    'imul', 'imul_csr', 'imul_dense', 'imul_data',
-    'neg', 'neg_csr', 'neg_dense',
-]
-
-
-cpdef CSR imul_csr(CSR matrix, double complex value):
-    """Multiply this CSR `matrix` by a complex scalar `value`."""
-    cdef idxint l = csr.nnz(matrix)
-    cdef int ONE=1
-    zscal(&l, &value, matrix.data, &ONE)
-    return matrix
-
-cpdef CSR mul_csr(CSR matrix, double complex value):
-    """Multiply this CSR `matrix` by a complex scalar `value`."""
-    if value == 0:
-        return csr.zeros(matrix.shape[0], matrix.shape[1])
-    cdef CSR out = csr.copy_structure(matrix)
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            out.data[ptr] = value * matrix.data[ptr]
-    return out
-
-cpdef CSR neg_csr(CSR matrix):
-    """Unary negation of this CSR `matrix`.  Return a new object."""
-    cdef CSR out = csr.copy_structure(matrix)
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            out.data[ptr] = -matrix.data[ptr]
-    return out
-
-
-cpdef Dense imul_dense(Dense matrix, double complex value):
-    """Multiply this Dense `matrix` by a complex scalar `value`."""
-    cdef size_t ptr
-    cdef int ONE=1
-    cdef idxint l = matrix.shape[0]*matrix.shape[1]
-    zscal(&l, &value, matrix.data, &ONE)
-    return matrix
-
-cpdef Dense mul_dense(Dense matrix, double complex value):
-    """Multiply this Dense `matrix` by a complex scalar `value`."""
-    cdef Dense out = dense.empty_like(matrix)
-    cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-            out.data[ptr] = value * matrix.data[ptr]
-    return out
-
-cpdef Dense neg_dense(Dense matrix):
-    """Unary negation of this Dense `matrix`.  Return a new object."""
-    cdef Dense out = dense.empty_like(matrix)
-    cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-            out.data[ptr] = -matrix.data[ptr]
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-mul = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='mul',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-mul.__doc__ =\
-    """Multiply a matrix element-wise by a scalar."""
-mul.add_specialisations([
-    (CSR, CSR, mul_csr),
-    (Dense, Dense, mul_dense),
-], _defer=True)
-
-imul = _Dispatcher(
-    # Will not be inplce if specialisation does not exist but should still
-    # give expected results if used as:
-    # mat = imul(mat, x)
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='imul',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-imul.__doc__ =\
-    """Multiply inplace a matrix element-wise by a scalar."""
-imul.add_specialisations([
-    (CSR, CSR, imul_csr),
-    (Dense, Dense, imul_dense),
-], _defer=True)
-
-neg = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='neg',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-neg.__doc__ =\
-    """Unary element-wise negation of a matrix."""
-neg.add_specialisations([
-    (CSR, CSR, neg_csr),
-    (Dense, Dense, neg_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
-
-
-cpdef Data imul_data(Data matrix, double complex value):
-    if type(matrix) is CSR:
-        return imul_csr(matrix, value)
-    elif type(matrix) is Dense:
-        return imul_dense(matrix, value)
-    else:
-        return imul(matrix, value)
+#cython: language_level=3
+#cython: boundscheck=False, wrapround=False, initializedcheck=False
+
+from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
+from scipy.linalg.cython_blas cimport zscal
+
+__all__ = [
+    'mul', 'mul_csr', 'mul_dense',
+    'imul', 'imul_csr', 'imul_dense', 'imul_data',
+    'neg', 'neg_csr', 'neg_dense',
+]
+
+
+cpdef CSR imul_csr(CSR matrix, double complex value):
+    """Multiply this CSR `matrix` by a complex scalar `value`."""
+    cdef idxint l = csr.nnz(matrix)
+    cdef int ONE=1
+    zscal(&l, &value, matrix.data, &ONE)
+    return matrix
+
+cpdef CSR mul_csr(CSR matrix, double complex value):
+    """Multiply this CSR `matrix` by a complex scalar `value`."""
+    if value == 0:
+        return csr.zeros(matrix.shape[0], matrix.shape[1])
+    cdef CSR out = csr.copy_structure(matrix)
+    cdef idxint ptr
+    with nogil:
+        for ptr in range(csr.nnz(matrix)):
+            out.data[ptr] = value * matrix.data[ptr]
+    return out
+
+cpdef CSR neg_csr(CSR matrix):
+    """Unary negation of this CSR `matrix`.  Return a new object."""
+    cdef CSR out = csr.copy_structure(matrix)
+    cdef idxint ptr
+    with nogil:
+        for ptr in range(csr.nnz(matrix)):
+            out.data[ptr] = -matrix.data[ptr]
+    return out
+
+
+cpdef Dense imul_dense(Dense matrix, double complex value):
+    """Multiply this Dense `matrix` by a complex scalar `value`."""
+    cdef size_t ptr
+    cdef int ONE=1
+    cdef idxint l = matrix.shape[0]*matrix.shape[1]
+    zscal(&l, &value, matrix.data, &ONE)
+    return matrix
+
+cpdef Dense mul_dense(Dense matrix, double complex value):
+    """Multiply this Dense `matrix` by a complex scalar `value`."""
+    cdef Dense out = dense.empty_like(matrix)
+    cdef size_t ptr
+    with nogil:
+        for ptr in range(matrix.shape[0]*matrix.shape[1]):
+            out.data[ptr] = value * matrix.data[ptr]
+    return out
+
+cpdef Dense neg_dense(Dense matrix):
+    """Unary negation of this Dense `matrix`.  Return a new object."""
+    cdef Dense out = dense.empty_like(matrix)
+    cdef size_t ptr
+    with nogil:
+        for ptr in range(matrix.shape[0]*matrix.shape[1]):
+            out.data[ptr] = -matrix.data[ptr]
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+mul = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='mul',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+mul.__doc__ =\
+    """Multiply a matrix element-wise by a scalar."""
+mul.add_specialisations([
+    (CSR, CSR, mul_csr),
+    (Dense, Dense, mul_dense),
+], _defer=True)
+
+imul = _Dispatcher(
+    # Will not be inplce if specialisation does not exist but should still
+    # give expected results if used as:
+    # mat = imul(mat, x)
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='imul',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+imul.__doc__ =\
+    """Multiply inplace a matrix element-wise by a scalar."""
+imul.add_specialisations([
+    (CSR, CSR, imul_csr),
+    (Dense, Dense, imul_dense),
+], _defer=True)
+
+neg = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='neg',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+neg.__doc__ =\
+    """Unary element-wise negation of a matrix."""
+neg.add_specialisations([
+    (CSR, CSR, neg_csr),
+    (Dense, Dense, neg_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
+
+
+cpdef Data imul_data(Data matrix, double complex value):
+    if type(matrix) is CSR:
+        return imul_csr(matrix, value)
+    elif type(matrix) is Dense:
+        return imul_dense(matrix, value)
+    else:
+        return imul(matrix, value)
diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
index 5e1b7ebe0d..560d163e28 100644
--- a/qutip/core/data/norm.pxd
+++ b/qutip/core/data/norm.pxd
@@ -1,15 +1,15 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data cimport CSR, Dense, Data
-
-cpdef double one_csr(CSR matrix) except -1
-cpdef double trace_csr(CSR matrix) except -1
-cpdef double max_csr(CSR matrix) nogil
-cpdef double frobenius_csr(CSR matrix) nogil
-cpdef double l2_csr(CSR matrix) nogil except -1
-
-cpdef double frobenius_dense(Dense matrix) nogil
-cpdef double l2_dense(Dense matrix) nogil except -1
-
-cpdef double frobenius_data(Data state)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data cimport CSR, Dense, Data
+
+cpdef double one_csr(CSR matrix) except -1
+cpdef double trace_csr(CSR matrix) except -1
+cpdef double max_csr(CSR matrix) nogil
+cpdef double frobenius_csr(CSR matrix) nogil
+cpdef double l2_csr(CSR matrix) nogil except -1
+
+cpdef double frobenius_dense(Dense matrix) nogil
+cpdef double l2_dense(Dense matrix) nogil except -1
+
+cpdef double frobenius_data(Data state)
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 998d49d1d2..40f15837c0 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -1,229 +1,229 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc cimport math
-
-from cpython cimport mem
-
-from scipy.linalg cimport cython_blas as blas
-import scipy
-
-from qutip.core.data cimport CSR, Dense, csr, dense, Data
-
-from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
-from qutip.core.data.matmul cimport matmul_csr
-
-from qutip.core.data import eigs_csr, eigs_dense
-
-cdef extern from *:
-    # Not included in Cython for some reason?
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-cdef extern from "<complex>" namespace "std" nogil:
-    # abs is templated such that Cython treats std::abs as complex->complex
-    double abs(double complex x)
-
-cdef double abssq(double complex x) nogil:
-    return x.real*x.real + x.imag*x.imag
-
-# We always use BLAS routines where possible because architecture-specific
-# libraries will typically apply vectorised operations for us.
-
-# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
-__all__ = []
-
-cpdef double one_csr(CSR matrix) except -1:
-    cdef int n=matrix.shape[1], inc=1
-    cdef size_t ptr
-    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
-    try:
-        for ptr in range(csr.nnz(matrix)):
-            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
-        # BLAS is a Fortran library, so it's one-indexed of course...
-        return col[blas.idamax(&n, col, &inc) - 1]
-    finally:
-        mem.PyMem_Free(col)
-
-
-cpdef double trace_dense(Dense matrix) except -1:
-    """Compute the trace norm relaying scipy for dense operations."""
-    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
-
-
-cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
-    """Compute the trace norm using only sparse operations. These consist
-    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
-    their square roots."""
-    # For column and row vectors we simply use the l2 norm as it is equivalent
-    # to the trace norm.
-    if matrix.shape[0]==1 or matrix.shape[1]==1:
-        return l2_csr(matrix)
-
-    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
-    cdef size_t i
-    cdef double [::1] eigs
-
-    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
-
-    cdef double total = 0
-    for i in range(matrix.shape[0]):
-        # The abs is technically not part of the definition, but since all
-        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
-        # which are lower will just be ~1e-15 due to numerical approximations.
-        total += math.sqrt(abs(eigs[i]))
-    return total
-
-
-cpdef double max_csr(CSR matrix) nogil:
-    cdef size_t ptr
-    cdef double total=0, cur
-    for ptr in range(csr.nnz(matrix)):
-        # The positive square root is monotonic over positive reals, so we can
-        # find the maximum value by considering the abs squared (which doesn't
-        # require a sqrt) rather than the abs(which does), and then perform
-        # only a single sqrt at the end.
-        cur = abssq(matrix.data[ptr])
-        total = cur if cur > total else total
-    return math.sqrt(total)
-
-cpdef double frobenius_csr(CSR matrix) nogil:
-    # The Frobenius norm is effectively the same as the L2 norm when
-    # considering the non-zero elements as a vector.
-    cdef int n=csr.nnz(matrix), inc=1
-    return blas.dznrm2(&n, &matrix.data[0], &inc)
-
-cpdef double l2_csr(CSR matrix) nogil except -1:
-    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
-        raise ValueError("L2 norm is only defined on vectors")
-    return frobenius_csr(matrix)
-
-cpdef double one_dense(Dense matrix) nogil:
-    cdef size_t ptr, col, row, col_stride, row_stride
-    cdef double out=0, cur
-    col_stride = matrix.shape[0] if matrix.fortran else 1
-    row_stride = 1 if matrix.fortran else matrix.shape[1]
-    for col in range(matrix.shape[1]):
-        ptr = col * col_stride
-        cur = 0
-        for row in range(matrix.shape[0]):
-            cur += abs(matrix.data[ptr])
-            ptr += row_stride
-        out = cur if cur > out else out
-    return out
-
-cpdef double max_dense(Dense matrix) nogil:
-    cdef size_t ptr
-    cdef double total=0, cur
-    for ptr in range(matrix.shape[0] * matrix.shape[1]):
-        # The positive square root is monotonic over positive reals, so we can
-        # find the maximum value by considering the abs squared (which doesn't
-        # require a sqrt) rather than the abs(which does), and then perform
-        # only a single sqrt at the end.
-        cur = abssq(matrix.data[ptr])
-        total = cur if cur > total else total
-    return math.sqrt(total)
-
-cpdef double frobenius_dense(Dense matrix) nogil:
-    cdef int n = matrix.shape[0] * matrix.shape[1]
-    cdef int inc = 1
-    return blas.dznrm2(&n, matrix.data, &inc)
-
-cpdef double l2_dense(Dense matrix) nogil except -1:
-    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
-        raise ValueError("L2 norm is only defined on vectors")
-    return frobenius_dense(matrix)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-l2 = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='l2',
-    module=__name__,
-    inputs=('vector',),
-)
-l2.__doc__ =\
-    """
-    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
-        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
-    This is only defined for vectors, but see `norm.frobenius` for the similar
-    norm defined on all matrices.
-    """
-l2.add_specialisations([
-    (Dense, l2_dense),
-    (CSR, l2_csr),
-], _defer=True)
-
-_norm_signature = _inspect.Signature([
-    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-])
-
-frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
-frobenius.__doc__ =\
-    """
-    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
-    as the
-        sqrt(sum_i sum_j |matrix[i, j]|**2)
-    and is similar to an extension of the vector L2 norm to all matrices.
-    """
-frobenius.add_specialisations([
-    (Dense, frobenius_dense),
-    (CSR, frobenius_csr),
-], _defer=True)
-
-max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
-max.__doc__ =\
-    """
-    Compute the max norm of a matrix.  This is the largest absolute value of an
-    entry in the matrix, or mathematically
-        max_{i,j} |matrix[i, j]|
-    """
-max.add_specialisations([
-    (Dense, max_dense),
-    (CSR, max_csr),
-], _defer=True)
-
-one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
-one.__doc__ =\
-    """
-    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
-    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
-    the sum of the absolute values.
-    """
-one.add_specialisations([
-    (Dense, one_dense),
-    (CSR, one_csr),
-], _defer=True)
-
-
-trace = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    inputs=('matrix',),
-    name='trace',
-    module=__name__,
-    out=False,
-)
-trace.__doc__ =\
-    """
-    Compute the trace-norm of a matrix.  This is the sum of the singular values
-    of the matrix, or equivalently
-        Tr(sqrt(A @ A.adjoint()))
-    """
-trace.add_specialisations([
-    (CSR, trace_csr),
-    (Dense, trace_dense),
-], _defer=True)
-
-
-cpdef double frobenius_data(Data state):
-    if type(state) is Dense:
-        return frobenius_dense(state)
-    elif type(state) is CSR:
-        return frobenius_csr(state)
-    else:
-        return frobenius(state)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc cimport math
+
+from cpython cimport mem
+
+from scipy.linalg cimport cython_blas as blas
+import scipy
+
+from qutip.core.data cimport CSR, Dense, csr, dense, Data
+
+from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
+from qutip.core.data.matmul cimport matmul_csr
+
+from qutip.core.data import eigs_csr, eigs_dense
+
+cdef extern from *:
+    # Not included in Cython for some reason?
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+cdef extern from "<complex>" namespace "std" nogil:
+    # abs is templated such that Cython treats std::abs as complex->complex
+    double abs(double complex x)
+
+cdef double abssq(double complex x) nogil:
+    return x.real*x.real + x.imag*x.imag
+
+# We always use BLAS routines where possible because architecture-specific
+# libraries will typically apply vectorised operations for us.
+
+# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
+__all__ = []
+
+cpdef double one_csr(CSR matrix) except -1:
+    cdef int n=matrix.shape[1], inc=1
+    cdef size_t ptr
+    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
+    try:
+        for ptr in range(csr.nnz(matrix)):
+            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
+        # BLAS is a Fortran library, so it's one-indexed of course...
+        return col[blas.idamax(&n, col, &inc) - 1]
+    finally:
+        mem.PyMem_Free(col)
+
+
+cpdef double trace_dense(Dense matrix) except -1:
+    """Compute the trace norm relaying scipy for dense operations."""
+    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
+
+
+cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
+    """Compute the trace norm using only sparse operations. These consist
+    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
+    their square roots."""
+    # For column and row vectors we simply use the l2 norm as it is equivalent
+    # to the trace norm.
+    if matrix.shape[0]==1 or matrix.shape[1]==1:
+        return l2_csr(matrix)
+
+    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
+    cdef size_t i
+    cdef double [::1] eigs
+
+    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
+
+    cdef double total = 0
+    for i in range(matrix.shape[0]):
+        # The abs is technically not part of the definition, but since all
+        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
+        # which are lower will just be ~1e-15 due to numerical approximations.
+        total += math.sqrt(abs(eigs[i]))
+    return total
+
+
+cpdef double max_csr(CSR matrix) nogil:
+    cdef size_t ptr
+    cdef double total=0, cur
+    for ptr in range(csr.nnz(matrix)):
+        # The positive square root is monotonic over positive reals, so we can
+        # find the maximum value by considering the abs squared (which doesn't
+        # require a sqrt) rather than the abs(which does), and then perform
+        # only a single sqrt at the end.
+        cur = abssq(matrix.data[ptr])
+        total = cur if cur > total else total
+    return math.sqrt(total)
+
+cpdef double frobenius_csr(CSR matrix) nogil:
+    # The Frobenius norm is effectively the same as the L2 norm when
+    # considering the non-zero elements as a vector.
+    cdef int n=csr.nnz(matrix), inc=1
+    return blas.dznrm2(&n, &matrix.data[0], &inc)
+
+cpdef double l2_csr(CSR matrix) nogil except -1:
+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+        raise ValueError("L2 norm is only defined on vectors")
+    return frobenius_csr(matrix)
+
+cpdef double one_dense(Dense matrix) nogil:
+    cdef size_t ptr, col, row, col_stride, row_stride
+    cdef double out=0, cur
+    col_stride = matrix.shape[0] if matrix.fortran else 1
+    row_stride = 1 if matrix.fortran else matrix.shape[1]
+    for col in range(matrix.shape[1]):
+        ptr = col * col_stride
+        cur = 0
+        for row in range(matrix.shape[0]):
+            cur += abs(matrix.data[ptr])
+            ptr += row_stride
+        out = cur if cur > out else out
+    return out
+
+cpdef double max_dense(Dense matrix) nogil:
+    cdef size_t ptr
+    cdef double total=0, cur
+    for ptr in range(matrix.shape[0] * matrix.shape[1]):
+        # The positive square root is monotonic over positive reals, so we can
+        # find the maximum value by considering the abs squared (which doesn't
+        # require a sqrt) rather than the abs(which does), and then perform
+        # only a single sqrt at the end.
+        cur = abssq(matrix.data[ptr])
+        total = cur if cur > total else total
+    return math.sqrt(total)
+
+cpdef double frobenius_dense(Dense matrix) nogil:
+    cdef int n = matrix.shape[0] * matrix.shape[1]
+    cdef int inc = 1
+    return blas.dznrm2(&n, matrix.data, &inc)
+
+cpdef double l2_dense(Dense matrix) nogil except -1:
+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+        raise ValueError("L2 norm is only defined on vectors")
+    return frobenius_dense(matrix)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+l2 = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='l2',
+    module=__name__,
+    inputs=('vector',),
+)
+l2.__doc__ =\
+    """
+    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
+        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
+    This is only defined for vectors, but see `norm.frobenius` for the similar
+    norm defined on all matrices.
+    """
+l2.add_specialisations([
+    (Dense, l2_dense),
+    (CSR, l2_csr),
+], _defer=True)
+
+_norm_signature = _inspect.Signature([
+    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+])
+
+frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
+frobenius.__doc__ =\
+    """
+    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
+    as the
+        sqrt(sum_i sum_j |matrix[i, j]|**2)
+    and is similar to an extension of the vector L2 norm to all matrices.
+    """
+frobenius.add_specialisations([
+    (Dense, frobenius_dense),
+    (CSR, frobenius_csr),
+], _defer=True)
+
+max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
+max.__doc__ =\
+    """
+    Compute the max norm of a matrix.  This is the largest absolute value of an
+    entry in the matrix, or mathematically
+        max_{i,j} |matrix[i, j]|
+    """
+max.add_specialisations([
+    (Dense, max_dense),
+    (CSR, max_csr),
+], _defer=True)
+
+one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
+one.__doc__ =\
+    """
+    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
+    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
+    the sum of the absolute values.
+    """
+one.add_specialisations([
+    (Dense, one_dense),
+    (CSR, one_csr),
+], _defer=True)
+
+
+trace = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    inputs=('matrix',),
+    name='trace',
+    module=__name__,
+    out=False,
+)
+trace.__doc__ =\
+    """
+    Compute the trace-norm of a matrix.  This is the sum of the singular values
+    of the matrix, or equivalently
+        Tr(sqrt(A @ A.adjoint()))
+    """
+trace.add_specialisations([
+    (CSR, trace_csr),
+    (Dense, trace_dense),
+], _defer=True)
+
+
+cpdef double frobenius_data(Data state):
+    if type(state) is Dense:
+        return frobenius_dense(state)
+    elif type(state) is CSR:
+        return frobenius_csr(state)
+    else:
+        return frobenius(state)
diff --git a/qutip/core/data/permute.pxd b/qutip/core/data/permute.pxd
index 1ac9a33500..422be089a7 100644
--- a/qutip/core/data/permute.pxd
+++ b/qutip/core/data/permute.pxd
@@ -1,7 +1,7 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
-cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
+cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
diff --git a/qutip/core/data/permute.pyx b/qutip/core/data/permute.pyx
index 72f44af2af..4e08fa74e9 100644
--- a/qutip/core/data/permute.pyx
+++ b/qutip/core/data/permute.pyx
@@ -1,405 +1,405 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-
-from libcpp cimport bool
-from libcpp.algorithm cimport sort
-
-cimport cython
-
-from cpython cimport mem
-
-import numpy as np
-cimport numpy as cnp
-
-from qutip.core.data.base cimport idxint, idxint_DTYPE
-from qutip.core.data cimport csr, dense, CSR, Dense
-
-from qutip.core.data.base import idxint_dtype
-
-cnp.import_array()
-
-cdef extern from *:
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
-__all__ = []
-
-
-cdef class _Indexer:
-    cdef size_t ndims, size
-    cdef readonly cnp.ndarray new_dimensions
-    cdef idxint[:] dimensions
-    cdef idxint *cumprod
-
-    def __init__(self, idxint[:] dimensions, idxint[:] order):
-        cdef size_t i
-        cdef idxint dim, ord
-        cdef idxint prev
-        self.ndims = dimensions.shape[0]
-        self.dimensions = dimensions
-        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
-        cdef idxint[:] new_dimensions = self.new_dimensions
-        if order.shape[0] != self.ndims:
-            raise ValueError("invalid order: wrong number of elements")
-        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
-        try:
-            for i in range(self.ndims):
-                ord = order[i]
-                if ord < 0 or ord >= self.ndims:
-                    raise ValueError("invalid order element: " + str(ord))
-                if tmp[ord]:
-                    raise ValueError("duplicate order element: " + str(ord))
-                tmp[ord] = True
-                dim = self.dimensions[ord]
-                if dim < 0:
-                    raise ValueError("found negative dimension: " + str(dim))
-                elif dim == 0:
-                    raise ValueError("found zero dimension")
-                new_dimensions[i] = dim
-        finally:
-            mem.PyMem_Free(tmp)
-        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
-        prev = self.cumprod[order[self.ndims - 1]] = 1
-        for i in range(self.ndims - 2, -1, -1):
-            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
-        self.size = self.cumprod[order[0]] * new_dimensions[0]
-
-    @cython.cdivision(True)
-    cdef cnp.ndarray all(self):
-        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
-        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
-        cdef idxint i
-        for i in range(self.size):
-            _out[i] = self.single(i)
-        return out
-
-    @cython.cdivision(True)
-    cdef idxint single(self, idxint idx) nogil:
-        cdef size_t i
-        cdef idxint out=0, dim
-        for i in range(self.ndims - 1, -1, -1):
-            dim = self.dimensions[i]
-            # Dimensions cannot be zero due to the check in __init__.
-            out += self.cumprod[i] * (idx % dim)
-            idx //= dim
-            if idx == 0:
-                break
-        return out
-
-    def __dealloc__(self):
-        if self.cumprod != NULL:
-            mem.PyMem_Free(self.cumprod)
-
-cdef bint _check_indices(size_t size, idxint[:] order) except True:
-    """
-    Test whether the permutation `order` is a valid permutation of `size`
-    number of elements.  This is functionally equivalent to
-
-    ```
-    if np.sort(order) != np.arange(size):
-        raise ValueError
-    return False
-    ```
-
-    In other words, we test that each integer on [0, size) is present exactly
-    once in `order`, and raise ValueError if that is not the case (returns True
-    if an error is detected, and False if not to help pure Cython avoiding
-    exceptions).
-    """
-    if order.shape[0] != size:
-        raise ValueError("invalid permutation: wrong number of elements")
-    cdef size_t ptr
-    cdef idxint value
-    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
-    if test == NULL:
-        raise MemoryError
-    try:
-        for ptr in range(size):
-            value = order[ptr]
-            if not 0 <= value < size:
-                raise ValueError("invalid entry in permutation: " + str(value))
-            if test[value]:
-                raise ValueError("duplicate entry in permutation: " + str(value))
-            test[value] = True
-        return False
-    finally:
-        mem.PyMem_Free(test)
-
-cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
-    cdef size_t n_rows=matrix.shape[0]
-    _check_indices(n_rows, rows)
-    cdef CSR out = csr.empty_like(matrix)
-    cdef size_t row, ptr_in, ptr_out, len
-    out.row_index[0] = 0
-    for row in range(matrix.shape[0]):
-        out.row_index[rows[row] + 1] =\
-            matrix.row_index[row + 1] - matrix.row_index[row]
-    for row in range(matrix.shape[0]):
-        out.row_index[row + 1] += out.row_index[row]
-    for row in range(matrix.shape[0]):
-        ptr_in = matrix.row_index[row]
-        ptr_out = out.row_index[rows[row]]
-        len = matrix.row_index[row + 1] - ptr_in
-        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
-        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
-    return out
-
-cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
-    _check_indices(matrix.shape[0], rows)
-    _check_indices(matrix.shape[1], cols)
-    cdef CSR out = csr.empty_like(matrix)
-    cdef size_t row, ptr_in, ptr_out, len, n
-    # First build up the row index structure by cumulative sum, so we know
-    # where to place the data and column indices.  We also use this opportunity
-    # to find the maximum number of non-zero elements in a row.
-    with nogil:
-        len = 0
-        out.row_index[0] = 0
-        for row in range(matrix.shape[0]):
-            n = matrix.row_index[row + 1] - matrix.row_index[row]
-            out.row_index[rows[row] + 1] = n
-            len = n if n > len else len
-        for row in range(matrix.shape[0]):
-            out.row_index[row + 1] += out.row_index[row]
-    # Now we know that `len` is the most number of non-zero elements in a row,
-    # so we can allocate space to sort only once.
-    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
-    cdef csr.Sorter sort = csr.Sorter(len)
-    for row in range(matrix.shape[0]):
-        ptr_in = matrix.row_index[row]
-        ptr_out = out.row_index[rows[row]]
-        len = matrix.row_index[row + 1] - ptr_in
-        for n in range(len):
-            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
-        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
-                  &matrix.data[ptr_in], new_cols,
-                  len)
-    mem.PyMem_Free(new_cols)
-    return out
-
-cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
-    if row_perm is None and col_perm is None:
-        return matrix.copy()
-    if col_perm is None:
-        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
-    cdef idxint *rows = NULL
-    cdef idxint n
-    if row_perm is None:
-        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
-        for n in range(matrix.shape[0]):
-            rows[n] = n
-        try:
-            return _indices_csr_full(matrix,
-                                     <idxint [:matrix.shape[0]]>rows,
-                                     np.asarray(col_perm, dtype=idxint_dtype))
-        finally:
-            mem.PyMem_Free(rows)
-    return _indices_csr_full(matrix,
-                             np.asarray(row_perm, dtype=idxint_dtype),
-                             np.asarray(col_perm, dtype=idxint_dtype))
-
-cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
-    if row_perm is None and col_perm is None:
-        return matrix.copy()
-    array = matrix.as_ndarray()
-    if row_perm is not None:
-        array = array[np.argsort(row_perm), :]
-    if col_perm is not None:
-        array = array[:, np.argsort(col_perm)]
-    return Dense(array)
-
-
-cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
-    if matrix.shape[0] != 1:
-        raise ValueError("expected bra-like matrix")
-    cdef size_t nnz = csr.nnz(matrix)
-    cdef CSR out = csr.empty_like(matrix)
-    out.row_index[0] = 0
-    out.row_index[1] = nnz
-    cdef size_t n
-    cdef csr.Sorter sort = csr.Sorter(nnz)
-    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
-    try:
-        for n in range(nnz):
-            new_cols[n] = index.single(matrix.col_index[n])
-        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
-        return out
-    finally:
-        mem.PyMem_Free(new_cols)
-
-cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
-    cdef CSR out = csr.empty_like(matrix)
-    cdef csr.Sorter sort
-    cdef size_t row, n, len=0
-    cdef idxint ptr_in, ptr_out, col
-    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
-    try:
-        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
-        with nogil:
-            for row in range(matrix.shape[0]):
-                n = matrix.row_index[row + 1] - matrix.row_index[row]
-                if n:
-                    idx_lookup[row] = index.single(row)
-                    out.row_index[idx_lookup[row] + 1] = n
-                    len = n if n > len else len
-                else:
-                    # Use a sentinel value so we can avoid looking up columns
-                    # that we already know about later.  Not all values in
-                    # idx_lookup will even be filled---this is the speed up
-                    # this function achieves over `_indices_csr_all`.
-                    idx_lookup[row] = -1
-            for row in range(matrix.shape[0]):
-                out.row_index[row + 1] += out.row_index[row]
-        # Since this is very sparse, we expect almost all rows to have at most two
-        # elements in them.  It will be faster to copy them across, and perform the
-        # sort in place rather than allocating temporary space and making an
-        # additional copy.  This will still work even if there are more in a row,
-        # it just won't be quite as efficient in that case (which should be rare).
-        sort = csr.Sorter(len)
-        for row in range(matrix.shape[0]):
-            ptr_in = matrix.row_index[row]
-            len = matrix.row_index[row + 1] - ptr_in
-            if len == 0:
-                continue
-            ptr_out = out.row_index[idx_lookup[row]]
-            for n in range(len):
-                col = matrix.col_index[ptr_in + n]
-                if idx_lookup[col] == -1:
-                    idx_lookup[col] = index.single(col)
-                out.col_index[ptr_out + n] = idx_lookup[col]
-            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
-            sort.inplace(out, ptr_out, len)
-        return out
-    finally:
-        mem.PyMem_Free(idx_lookup)
-
-@cython.cdivision(True)
-cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
-    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
-                                   np.asarray(order, dtype=idxint_dtype))
-    cdef idxint[:] permutation
-    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
-        return matrix.copy()
-    if matrix.shape[0] == 1:
-        return _dimensions_csr_columns(matrix, index)
-    if matrix.shape[1] == 1:
-        return _indices_csr_rowonly(matrix, index.all())
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("dimensional permute requires square operators")
-    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
-    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
-    # calls to `index.single()` than the matrix dimension.  To be sure of this,
-    # we actually require the density per row to be less than 1/2, because we
-    # have to look up both the row _and_ column on output.  This only
-    # corresponds to exceptionally sparse matrices.  We try to avoid these
-    # calls because index.single has ~logarithmic complexity in the dimension
-    # (so for qubit systems it's linear in the number of qubits), and
-    # consequently `index.all()` is a hidden quadratic complexity.
-    if row_density >= 0.5:
-        permutation = index.all()
-        return _indices_csr_full(matrix, permutation, permutation)
-    return _dimensions_csr_sparse(matrix, index)
-
-@cython.cdivision(True)
-cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
-    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
-                                   np.asarray(order, dtype=idxint_dtype))
-    cdef idxint[:] permutation = index.all()
-    row_perm, col_perm = None, None
-    if matrix.shape[0] != 1:
-        row_perm = permutation
-    if matrix.shape[1] != 1:
-        col_perm = permutation
-    return indices_dense(matrix, row_perm, col_perm)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-dimensions = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='dimensions',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-dimensions.__doc__ =\
-    """
-    Reorder the tensor-product structure of a matrix, assuming that the
-    underlying structure is defined by `dimensions`.  For a separable system,
-    this function produces a matrix which is equivalent to having performed
-    `kron` in a different order on the separable parts.
-
-    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
-    respectively, then
-        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
-                                                  [2, 3, 4],
-                                                  [1, 2, 0])
-    In other words, the inputs to `kron` are reordered so that input `n` moves
-    to position `order[n]`.
-
-    Parameters
-    ----------
-    matrix : Data
-        Input matrix to reorder.  This can either be a square matrix
-        representing an operator, or a bra- or ket-like vector.
-
-    dimensions : 1D array_like of integers
-        The tensor-product structure of the space the matrix lives on.  This
-        will typically be one of the two elements of `Qobj.dims` (e.g. for a
-        ket, it will be `Qobj.dims[0]`).
-
-    order : 1D array_like of integers
-        The new order of the tensor-product elements.  This should be a 1D list
-        with the integers from `0` to `N - 1` inclusive, if there are `N`
-        elements in the tensor product.
-    """
-dimensions.add_specialisations([
-    (CSR, CSR, dimensions_csr),
-    (Dense, Dense, dimensions_dense),
-], _defer=True)
-
-indices = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=None),
-        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=None),
-    ]),
-    name='indices',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-indices.__doc__ =\
-    """
-    Permute the rows and columns of a matrix according to a row and column
-    permutation.  This is a "dumb" operation with regards to the representation
-    of quantum states; if you want to "reorder" the tensor-product structure of
-    a system, you want `permute.dimensions` instead.
-
-    Parameters
-    ----------
-    matrix : Data
-        The input matrix.
-
-    row_perm, col_perm : 1D array_like of integer, optional
-        The new order that the rows or columns should be shuffled into.  If the
-        input matrix is `N x M`, then `row_perm` would be an array containing
-        all the integers from `0` to `N - 1` inclusive in some new order.  Row
-        `n` in the input will be at row `row_perm[n]` in the output, and
-        similar for the column permutation.
-    """
-indices.add_specialisations([
-    (CSR, CSR, indices_csr),
-    (Dense, Dense, indices_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+
+from libcpp cimport bool
+from libcpp.algorithm cimport sort
+
+cimport cython
+
+from cpython cimport mem
+
+import numpy as np
+cimport numpy as cnp
+
+from qutip.core.data.base cimport idxint, idxint_DTYPE
+from qutip.core.data cimport csr, dense, CSR, Dense
+
+from qutip.core.data.base import idxint_dtype
+
+cnp.import_array()
+
+cdef extern from *:
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
+__all__ = []
+
+
+cdef class _Indexer:
+    cdef size_t ndims, size
+    cdef readonly cnp.ndarray new_dimensions
+    cdef idxint[:] dimensions
+    cdef idxint *cumprod
+
+    def __init__(self, idxint[:] dimensions, idxint[:] order):
+        cdef size_t i
+        cdef idxint dim, ord
+        cdef idxint prev
+        self.ndims = dimensions.shape[0]
+        self.dimensions = dimensions
+        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
+        cdef idxint[:] new_dimensions = self.new_dimensions
+        if order.shape[0] != self.ndims:
+            raise ValueError("invalid order: wrong number of elements")
+        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
+        try:
+            for i in range(self.ndims):
+                ord = order[i]
+                if ord < 0 or ord >= self.ndims:
+                    raise ValueError("invalid order element: " + str(ord))
+                if tmp[ord]:
+                    raise ValueError("duplicate order element: " + str(ord))
+                tmp[ord] = True
+                dim = self.dimensions[ord]
+                if dim < 0:
+                    raise ValueError("found negative dimension: " + str(dim))
+                elif dim == 0:
+                    raise ValueError("found zero dimension")
+                new_dimensions[i] = dim
+        finally:
+            mem.PyMem_Free(tmp)
+        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
+        prev = self.cumprod[order[self.ndims - 1]] = 1
+        for i in range(self.ndims - 2, -1, -1):
+            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
+        self.size = self.cumprod[order[0]] * new_dimensions[0]
+
+    @cython.cdivision(True)
+    cdef cnp.ndarray all(self):
+        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
+        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
+        cdef idxint i
+        for i in range(self.size):
+            _out[i] = self.single(i)
+        return out
+
+    @cython.cdivision(True)
+    cdef idxint single(self, idxint idx) nogil:
+        cdef size_t i
+        cdef idxint out=0, dim
+        for i in range(self.ndims - 1, -1, -1):
+            dim = self.dimensions[i]
+            # Dimensions cannot be zero due to the check in __init__.
+            out += self.cumprod[i] * (idx % dim)
+            idx //= dim
+            if idx == 0:
+                break
+        return out
+
+    def __dealloc__(self):
+        if self.cumprod != NULL:
+            mem.PyMem_Free(self.cumprod)
+
+cdef bint _check_indices(size_t size, idxint[:] order) except True:
+    """
+    Test whether the permutation `order` is a valid permutation of `size`
+    number of elements.  This is functionally equivalent to
+
+    ```
+    if np.sort(order) != np.arange(size):
+        raise ValueError
+    return False
+    ```
+
+    In other words, we test that each integer on [0, size) is present exactly
+    once in `order`, and raise ValueError if that is not the case (returns True
+    if an error is detected, and False if not to help pure Cython avoiding
+    exceptions).
+    """
+    if order.shape[0] != size:
+        raise ValueError("invalid permutation: wrong number of elements")
+    cdef size_t ptr
+    cdef idxint value
+    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
+    if test == NULL:
+        raise MemoryError
+    try:
+        for ptr in range(size):
+            value = order[ptr]
+            if not 0 <= value < size:
+                raise ValueError("invalid entry in permutation: " + str(value))
+            if test[value]:
+                raise ValueError("duplicate entry in permutation: " + str(value))
+            test[value] = True
+        return False
+    finally:
+        mem.PyMem_Free(test)
+
+cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
+    cdef size_t n_rows=matrix.shape[0]
+    _check_indices(n_rows, rows)
+    cdef CSR out = csr.empty_like(matrix)
+    cdef size_t row, ptr_in, ptr_out, len
+    out.row_index[0] = 0
+    for row in range(matrix.shape[0]):
+        out.row_index[rows[row] + 1] =\
+            matrix.row_index[row + 1] - matrix.row_index[row]
+    for row in range(matrix.shape[0]):
+        out.row_index[row + 1] += out.row_index[row]
+    for row in range(matrix.shape[0]):
+        ptr_in = matrix.row_index[row]
+        ptr_out = out.row_index[rows[row]]
+        len = matrix.row_index[row + 1] - ptr_in
+        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
+        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
+    return out
+
+cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
+    _check_indices(matrix.shape[0], rows)
+    _check_indices(matrix.shape[1], cols)
+    cdef CSR out = csr.empty_like(matrix)
+    cdef size_t row, ptr_in, ptr_out, len, n
+    # First build up the row index structure by cumulative sum, so we know
+    # where to place the data and column indices.  We also use this opportunity
+    # to find the maximum number of non-zero elements in a row.
+    with nogil:
+        len = 0
+        out.row_index[0] = 0
+        for row in range(matrix.shape[0]):
+            n = matrix.row_index[row + 1] - matrix.row_index[row]
+            out.row_index[rows[row] + 1] = n
+            len = n if n > len else len
+        for row in range(matrix.shape[0]):
+            out.row_index[row + 1] += out.row_index[row]
+    # Now we know that `len` is the most number of non-zero elements in a row,
+    # so we can allocate space to sort only once.
+    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
+    cdef csr.Sorter sort = csr.Sorter(len)
+    for row in range(matrix.shape[0]):
+        ptr_in = matrix.row_index[row]
+        ptr_out = out.row_index[rows[row]]
+        len = matrix.row_index[row + 1] - ptr_in
+        for n in range(len):
+            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
+        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
+                  &matrix.data[ptr_in], new_cols,
+                  len)
+    mem.PyMem_Free(new_cols)
+    return out
+
+cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
+    if row_perm is None and col_perm is None:
+        return matrix.copy()
+    if col_perm is None:
+        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
+    cdef idxint *rows = NULL
+    cdef idxint n
+    if row_perm is None:
+        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
+        for n in range(matrix.shape[0]):
+            rows[n] = n
+        try:
+            return _indices_csr_full(matrix,
+                                     <idxint [:matrix.shape[0]]>rows,
+                                     np.asarray(col_perm, dtype=idxint_dtype))
+        finally:
+            mem.PyMem_Free(rows)
+    return _indices_csr_full(matrix,
+                             np.asarray(row_perm, dtype=idxint_dtype),
+                             np.asarray(col_perm, dtype=idxint_dtype))
+
+cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
+    if row_perm is None and col_perm is None:
+        return matrix.copy()
+    array = matrix.as_ndarray()
+    if row_perm is not None:
+        array = array[np.argsort(row_perm), :]
+    if col_perm is not None:
+        array = array[:, np.argsort(col_perm)]
+    return Dense(array)
+
+
+cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
+    if matrix.shape[0] != 1:
+        raise ValueError("expected bra-like matrix")
+    cdef size_t nnz = csr.nnz(matrix)
+    cdef CSR out = csr.empty_like(matrix)
+    out.row_index[0] = 0
+    out.row_index[1] = nnz
+    cdef size_t n
+    cdef csr.Sorter sort = csr.Sorter(nnz)
+    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
+    try:
+        for n in range(nnz):
+            new_cols[n] = index.single(matrix.col_index[n])
+        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
+        return out
+    finally:
+        mem.PyMem_Free(new_cols)
+
+cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
+    cdef CSR out = csr.empty_like(matrix)
+    cdef csr.Sorter sort
+    cdef size_t row, n, len=0
+    cdef idxint ptr_in, ptr_out, col
+    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
+    try:
+        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
+        with nogil:
+            for row in range(matrix.shape[0]):
+                n = matrix.row_index[row + 1] - matrix.row_index[row]
+                if n:
+                    idx_lookup[row] = index.single(row)
+                    out.row_index[idx_lookup[row] + 1] = n
+                    len = n if n > len else len
+                else:
+                    # Use a sentinel value so we can avoid looking up columns
+                    # that we already know about later.  Not all values in
+                    # idx_lookup will even be filled---this is the speed up
+                    # this function achieves over `_indices_csr_all`.
+                    idx_lookup[row] = -1
+            for row in range(matrix.shape[0]):
+                out.row_index[row + 1] += out.row_index[row]
+        # Since this is very sparse, we expect almost all rows to have at most two
+        # elements in them.  It will be faster to copy them across, and perform the
+        # sort in place rather than allocating temporary space and making an
+        # additional copy.  This will still work even if there are more in a row,
+        # it just won't be quite as efficient in that case (which should be rare).
+        sort = csr.Sorter(len)
+        for row in range(matrix.shape[0]):
+            ptr_in = matrix.row_index[row]
+            len = matrix.row_index[row + 1] - ptr_in
+            if len == 0:
+                continue
+            ptr_out = out.row_index[idx_lookup[row]]
+            for n in range(len):
+                col = matrix.col_index[ptr_in + n]
+                if idx_lookup[col] == -1:
+                    idx_lookup[col] = index.single(col)
+                out.col_index[ptr_out + n] = idx_lookup[col]
+            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
+            sort.inplace(out, ptr_out, len)
+        return out
+    finally:
+        mem.PyMem_Free(idx_lookup)
+
+@cython.cdivision(True)
+cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
+    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
+                                   np.asarray(order, dtype=idxint_dtype))
+    cdef idxint[:] permutation
+    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
+        return matrix.copy()
+    if matrix.shape[0] == 1:
+        return _dimensions_csr_columns(matrix, index)
+    if matrix.shape[1] == 1:
+        return _indices_csr_rowonly(matrix, index.all())
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("dimensional permute requires square operators")
+    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
+    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
+    # calls to `index.single()` than the matrix dimension.  To be sure of this,
+    # we actually require the density per row to be less than 1/2, because we
+    # have to look up both the row _and_ column on output.  This only
+    # corresponds to exceptionally sparse matrices.  We try to avoid these
+    # calls because index.single has ~logarithmic complexity in the dimension
+    # (so for qubit systems it's linear in the number of qubits), and
+    # consequently `index.all()` is a hidden quadratic complexity.
+    if row_density >= 0.5:
+        permutation = index.all()
+        return _indices_csr_full(matrix, permutation, permutation)
+    return _dimensions_csr_sparse(matrix, index)
+
+@cython.cdivision(True)
+cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
+    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
+                                   np.asarray(order, dtype=idxint_dtype))
+    cdef idxint[:] permutation = index.all()
+    row_perm, col_perm = None, None
+    if matrix.shape[0] != 1:
+        row_perm = permutation
+    if matrix.shape[1] != 1:
+        col_perm = permutation
+    return indices_dense(matrix, row_perm, col_perm)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+dimensions = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='dimensions',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+dimensions.__doc__ =\
+    """
+    Reorder the tensor-product structure of a matrix, assuming that the
+    underlying structure is defined by `dimensions`.  For a separable system,
+    this function produces a matrix which is equivalent to having performed
+    `kron` in a different order on the separable parts.
+
+    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
+    respectively, then
+        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
+                                                  [2, 3, 4],
+                                                  [1, 2, 0])
+    In other words, the inputs to `kron` are reordered so that input `n` moves
+    to position `order[n]`.
+
+    Parameters
+    ----------
+    matrix : Data
+        Input matrix to reorder.  This can either be a square matrix
+        representing an operator, or a bra- or ket-like vector.
+
+    dimensions : 1D array_like of integers
+        The tensor-product structure of the space the matrix lives on.  This
+        will typically be one of the two elements of `Qobj.dims` (e.g. for a
+        ket, it will be `Qobj.dims[0]`).
+
+    order : 1D array_like of integers
+        The new order of the tensor-product elements.  This should be a 1D list
+        with the integers from `0` to `N - 1` inclusive, if there are `N`
+        elements in the tensor product.
+    """
+dimensions.add_specialisations([
+    (CSR, CSR, dimensions_csr),
+    (Dense, Dense, dimensions_dense),
+], _defer=True)
+
+indices = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=None),
+        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=None),
+    ]),
+    name='indices',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+indices.__doc__ =\
+    """
+    Permute the rows and columns of a matrix according to a row and column
+    permutation.  This is a "dumb" operation with regards to the representation
+    of quantum states; if you want to "reorder" the tensor-product structure of
+    a system, you want `permute.dimensions` instead.
+
+    Parameters
+    ----------
+    matrix : Data
+        The input matrix.
+
+    row_perm, col_perm : 1D array_like of integer, optional
+        The new order that the rows or columns should be shuffled into.  If the
+        input matrix is `N x M`, then `row_perm` would be an array containing
+        all the integers from `0` to `N - 1` inclusive in some new order.  Row
+        `n` in the input will be at row `row_perm[n]` in the output, and
+        similar for the column permutation.
+    """
+indices.add_specialisations([
+    (CSR, CSR, indices_csr),
+    (Dense, Dense, indices_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/pow.pxd b/qutip/core/data/pow.pxd
index d74b871fd0..04a0c79fc6 100644
--- a/qutip/core/data/pow.pxd
+++ b/qutip/core/data/pow.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR pow_csr(CSR matrix, unsigned long long n)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR pow_csr(CSR matrix, unsigned long long n)
diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
index b90a1a44b7..7c0c6bf7c0 100644
--- a/qutip/core/data/pow.pyx
+++ b/qutip/core/data/pow.pyx
@@ -1,86 +1,86 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-
-from qutip.core.data cimport csr, dense
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.matmul cimport matmul_csr
-import numpy as np
-
-__all__ = [
-    'pow', 'pow_csr', 'pow_dense',
-]
-
-
-@cython.nonecheck(False)
-@cython.cdivision(True)
-cpdef CSR pow_csr(CSR matrix, unsigned long long n):
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("matrix power only works with square matrices")
-    if n == 0:
-        return csr.identity(matrix.shape[0])
-    if n == 1:
-        return matrix.copy()
-    # We do the matrix power in terms of powers of two, so we can do it
-    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
-    # number of set bits in the input.
-    #
-    # We don't have to do matrix.copy() or pow.copy() here, because we've
-    # guaranteed that we won't be returning without at least one matrix
-    # multiplcation, which will allocate a new matrix.
-    cdef CSR pow = matrix
-    cdef CSR out = pow if n & 1 else None
-    n >>= 1
-    while n:
-        pow = matmul_csr(pow, pow)
-        if n & 1:
-            out = pow if out is None else matmul_csr(out, pow)
-        n >>= 1
-    return out
-
-
-cpdef Dense pow_dense(Dense matrix, unsigned long long n):
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("matrix power only works with square matrices")
-    if n == 0:
-        return dense.identity(matrix.shape[0])
-    if n == 1:
-        return matrix.copy()
-    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-pow = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='pow',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-pow.__doc__ =\
-    """
-    Compute the integer matrix power of the square input matrix.  The power
-    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
-    the same shape.
-
-    Parameters
-    ----------
-    matrix : Data
-        Input matrix to take the power of.
-
-    n : non-negative integer
-        The power to which to raise the matrix.
-    """
-pow.add_specialisations([
-    (CSR, CSR, pow_csr),
-    (Dense, Dense, pow_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+
+from qutip.core.data cimport csr, dense
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.matmul cimport matmul_csr
+import numpy as np
+
+__all__ = [
+    'pow', 'pow_csr', 'pow_dense',
+]
+
+
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cpdef CSR pow_csr(CSR matrix, unsigned long long n):
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("matrix power only works with square matrices")
+    if n == 0:
+        return csr.identity(matrix.shape[0])
+    if n == 1:
+        return matrix.copy()
+    # We do the matrix power in terms of powers of two, so we can do it
+    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
+    # number of set bits in the input.
+    #
+    # We don't have to do matrix.copy() or pow.copy() here, because we've
+    # guaranteed that we won't be returning without at least one matrix
+    # multiplcation, which will allocate a new matrix.
+    cdef CSR pow = matrix
+    cdef CSR out = pow if n & 1 else None
+    n >>= 1
+    while n:
+        pow = matmul_csr(pow, pow)
+        if n & 1:
+            out = pow if out is None else matmul_csr(out, pow)
+        n >>= 1
+    return out
+
+
+cpdef Dense pow_dense(Dense matrix, unsigned long long n):
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("matrix power only works with square matrices")
+    if n == 0:
+        return dense.identity(matrix.shape[0])
+    if n == 1:
+        return matrix.copy()
+    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+pow = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='pow',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+pow.__doc__ =\
+    """
+    Compute the integer matrix power of the square input matrix.  The power
+    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
+    the same shape.
+
+    Parameters
+    ----------
+    matrix : Data
+        Input matrix to take the power of.
+
+    n : non-negative integer
+        The power to which to raise the matrix.
+    """
+pow.add_specialisations([
+    (CSR, CSR, pow_csr),
+    (Dense, Dense, pow_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/project.pxd b/qutip/core/data/project.pxd
index 07dabb79ca..86baf76291 100644
--- a/qutip/core/data/project.pxd
+++ b/qutip/core/data/project.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR project_csr(CSR state)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR project_csr(CSR state)
diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
index b88771e365..03a8bf7309 100644
--- a/qutip/core/data/project.pyx
+++ b/qutip/core/data/project.pyx
@@ -1,144 +1,144 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memcpy
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, Dense
-from qutip.core.data.csr cimport CSR
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-__all__ = [
-    'project', 'project_csr', 'project_dense',
-]
-
-
-cdef void _project_ket_csr(CSR ket, CSR out) nogil:
-    """
-    Calculate the projection of the given ket, and place the output in out.
-    """
-    cdef size_t row, ptr, offset=0
-    cdef idxint nnz_in = csr.nnz(ket)
-    for row in range(ket.shape[0]):
-        out.row_index[row] = ket.row_index[row] * nnz_in
-        if ket.row_index[row + 1] != ket.row_index[row]:
-            for ptr in range(nnz_in):
-                out.col_index[offset + ptr*nnz_in] = row
-            offset += 1
-    out.row_index[ket.shape[0]] = nnz_in * nnz_in
-    offset = 0
-    for row in range(nnz_in):
-        for ptr in range(nnz_in):
-            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
-        offset += nnz_in
-
-
-cdef void _project_bra_csr(CSR bra, CSR out) nogil:
-    """
-    Calculate the projection of the given bra, and place the output in out.
-    """
-    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
-    cdef double complex mul
-    cdef idxint nnz_in = csr.nnz(bra)
-    # The algorithm is much more simple conceptually if the indices are sorted,
-    # and doesn't affect runtime much since sorting is worst-case
-    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
-    # sort now than later while there are fewer entries.  No need to sort when
-    # projecting a ket because all the col_index values are 0.
-    with gil:
-        bra.sort_indices()
-    out.row_index[0] = cur
-    for ptr_bra in range(nnz_in):
-        # Handle all zero rows between the last non-zero entry and this one.
-        for row_out in range(row_out, bra.col_index[ptr_bra]):
-            out.row_index[row_out + 1] = cur
-        row_out = bra.col_index[ptr_bra]
-        cur += nnz_in
-        out.row_index[row_out + 1] = cur
-        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
-        mul = conj(bra.data[ptr_bra])
-        for ptr in range(nnz_in):
-            out.data[ptr_out] = mul * bra.data[ptr]
-            ptr_out += 1
-        row_out += 1
-    # Handle all zero rows after the last non-zero entry.
-    for row_out in range(row_out, out.shape[0]):
-        out.row_index[row_out + 1] = cur
-
-cpdef CSR project_csr(CSR state):
-    """
-    Calculate the projection |state><state|.  The shape of `state` will be used
-    to determine if it has been supplied as a ket or a bra.  The result of this
-    function will be identical is passed `state` or `adjoint(state)`.
-    """
-    cdef size_t nnz_in = csr.nnz(state)
-    cdef CSR out
-    # We don't actually need to both handling the shape=(1, 1) case specially,
-    # because it doesn't matter if we interpret it as a ket or a bra---the
-    # output will be a shape=(1, 1) matrix with the only data element equal to
-    # abs(state.data[0])**2 either way.
-    if state.shape[1] == 1:
-        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
-        _project_ket_csr(state, out)
-        return out
-    if state.shape[0] == 1:
-        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
-        _project_bra_csr(state, out)
-        return out
-    raise ValueError("state must be a ket or a bra.")
-
-cpdef Dense project_dense(Dense state):
-    """
-    Calculate the projection |state><state|.  The shape of `state` will be used
-    to determine if it has been supplied as a ket or a bra.  The result of this
-    function will be identical is passed `state` or `adjoint(state)`.
-    """
-    cdef Dense out
-    cdef size_t size, i
-    cdef bint fortran
-    if state.shape[1] == 1:
-        size = state.shape[0]
-        fortran = True
-    elif state.shape[0] == 1:
-        size = state.shape[1]
-        fortran = False
-    else:
-        raise ValueError("state must be a ket or a bra.")
-    out = dense.zeros(size, size, fortran)
-    for i in range(size):
-        for j in range(size):
-            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
-    return out
-
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-project = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='project',
-    module=__name__,
-    inputs=('state',),
-    out=True,
-)
-project.__doc__ =\
-    """
-    Get the projector of a state with itself.  Mathematically, if passed an
-    object `|a>` or `<a|`, then return the matrix `|a><a|`.
-
-    Parameters
-    ----------
-    state : Data
-        The input state bra- or ket-like vector.
-    """
-project.add_specialisations([
-    (CSR, CSR, project_csr),
-    (Dense, Dense, project_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memcpy
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport csr, dense, Dense
+from qutip.core.data.csr cimport CSR
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+__all__ = [
+    'project', 'project_csr', 'project_dense',
+]
+
+
+cdef void _project_ket_csr(CSR ket, CSR out) nogil:
+    """
+    Calculate the projection of the given ket, and place the output in out.
+    """
+    cdef size_t row, ptr, offset=0
+    cdef idxint nnz_in = csr.nnz(ket)
+    for row in range(ket.shape[0]):
+        out.row_index[row] = ket.row_index[row] * nnz_in
+        if ket.row_index[row + 1] != ket.row_index[row]:
+            for ptr in range(nnz_in):
+                out.col_index[offset + ptr*nnz_in] = row
+            offset += 1
+    out.row_index[ket.shape[0]] = nnz_in * nnz_in
+    offset = 0
+    for row in range(nnz_in):
+        for ptr in range(nnz_in):
+            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
+        offset += nnz_in
+
+
+cdef void _project_bra_csr(CSR bra, CSR out) nogil:
+    """
+    Calculate the projection of the given bra, and place the output in out.
+    """
+    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
+    cdef double complex mul
+    cdef idxint nnz_in = csr.nnz(bra)
+    # The algorithm is much more simple conceptually if the indices are sorted,
+    # and doesn't affect runtime much since sorting is worst-case
+    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
+    # sort now than later while there are fewer entries.  No need to sort when
+    # projecting a ket because all the col_index values are 0.
+    with gil:
+        bra.sort_indices()
+    out.row_index[0] = cur
+    for ptr_bra in range(nnz_in):
+        # Handle all zero rows between the last non-zero entry and this one.
+        for row_out in range(row_out, bra.col_index[ptr_bra]):
+            out.row_index[row_out + 1] = cur
+        row_out = bra.col_index[ptr_bra]
+        cur += nnz_in
+        out.row_index[row_out + 1] = cur
+        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
+        mul = conj(bra.data[ptr_bra])
+        for ptr in range(nnz_in):
+            out.data[ptr_out] = mul * bra.data[ptr]
+            ptr_out += 1
+        row_out += 1
+    # Handle all zero rows after the last non-zero entry.
+    for row_out in range(row_out, out.shape[0]):
+        out.row_index[row_out + 1] = cur
+
+cpdef CSR project_csr(CSR state):
+    """
+    Calculate the projection |state><state|.  The shape of `state` will be used
+    to determine if it has been supplied as a ket or a bra.  The result of this
+    function will be identical is passed `state` or `adjoint(state)`.
+    """
+    cdef size_t nnz_in = csr.nnz(state)
+    cdef CSR out
+    # We don't actually need to both handling the shape=(1, 1) case specially,
+    # because it doesn't matter if we interpret it as a ket or a bra---the
+    # output will be a shape=(1, 1) matrix with the only data element equal to
+    # abs(state.data[0])**2 either way.
+    if state.shape[1] == 1:
+        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
+        _project_ket_csr(state, out)
+        return out
+    if state.shape[0] == 1:
+        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
+        _project_bra_csr(state, out)
+        return out
+    raise ValueError("state must be a ket or a bra.")
+
+cpdef Dense project_dense(Dense state):
+    """
+    Calculate the projection |state><state|.  The shape of `state` will be used
+    to determine if it has been supplied as a ket or a bra.  The result of this
+    function will be identical is passed `state` or `adjoint(state)`.
+    """
+    cdef Dense out
+    cdef size_t size, i
+    cdef bint fortran
+    if state.shape[1] == 1:
+        size = state.shape[0]
+        fortran = True
+    elif state.shape[0] == 1:
+        size = state.shape[1]
+        fortran = False
+    else:
+        raise ValueError("state must be a ket or a bra.")
+    out = dense.zeros(size, size, fortran)
+    for i in range(size):
+        for j in range(size):
+            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
+    return out
+
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+project = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='project',
+    module=__name__,
+    inputs=('state',),
+    out=True,
+)
+project.__doc__ =\
+    """
+    Get the projector of a state with itself.  Mathematically, if passed an
+    object `|a>` or `<a|`, then return the matrix `|a><a|`.
+
+    Parameters
+    ----------
+    state : Data
+        The input state bra- or ket-like vector.
+    """
+project.add_specialisations([
+    (CSR, CSR, project_csr),
+    (Dense, Dense, project_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/properties.pxd b/qutip/core/data/properties.pxd
index 57424d9638..9ce22e1292 100644
--- a/qutip/core/data/properties.pxd
+++ b/qutip/core/data/properties.pxd
@@ -1,8 +1,8 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef bint isherm_csr(CSR matrix, double tol=*)
-cpdef bint isdiag_csr(CSR matrix) nogil
-cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
-cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef bint isherm_csr(CSR matrix, double tol=*)
+cpdef bint isdiag_csr(CSR matrix) nogil
+cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
+cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
index ded226cbe7..38116cabcd 100644
--- a/qutip/core/data/properties.pyx
+++ b/qutip/core/data/properties.pyx
@@ -1,319 +1,319 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-from cpython cimport mem
-
-from qutip.settings import settings
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense
-from qutip.core.data.adjoint cimport transpose_csr
-
-cdef extern from *:
-    # Not defined in cpython.mem for some reason, but is in pymem.h.
-    void *PyMem_Calloc(size_t nelem, size_t elsize)
-
-__all__ = [
-    'isherm', 'isherm_csr', 'isherm_dense',
-    'isdiag', 'isdiag_csr', 'isdiag_dense',
-    'iszero', 'iszero_csr', 'iszero_dense',
-]
-
-cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
-    """Check whether a == conj(b) up to an absolute tolerance."""
-    cdef double re = a.real - b.real
-    cdef double im = a.imag + b.imag
-    # Comparing the squares should be fine---there is possible precision loss
-    # in the addition, but as re*re and im*im are both positive semidefinite,
-    # the floating point result is strictly not greater than the true value.
-    # Save the cycles: don't sqrt.
-    return re*re + im*im < tol*tol
-
-cdef inline bint _feq_zero(double complex a, double tol) nogil:
-    return a.real*a.real + a.imag*a.imag < tol*tol
-
-cdef inline double _abssq(double complex x) nogil:
-    return x.real*x.real + x.imag*x.imag
-
-
-cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
-    """
-    Full, structural test for Hermicity of a matrix.  We assume that the input
-    matrix has already had its shape tested (must be square).
-
-    This test is only necessary when there is at least one value which is less
-    than the tolerance, and needed to be compared to an implicit zero.  In
-    general it is less efficient than the other test, and allocates more
-    memory.
-    """
-    cdef CSR transpose = transpose_csr(matrix)
-    cdef idxint row, ptr_a, ptr_b, col_a, col_b
-    for row in range(matrix.shape[0]):
-        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
-        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
-        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
-            # Doing this on every loop actually involves a few more
-            # de-references than are strictly necessary, but just
-            # simplifies the logic checking for the end of the row.
-            col_a = matrix.col_index[ptr_a]
-            col_b = transpose.col_index[ptr_b]
-            if col_a == col_b:
-                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
-                    return False
-                ptr_a += 1
-                ptr_b += 1
-            elif col_a < col_b:
-                if not _feq_zero(matrix.data[ptr_a], tol):
-                    return False
-                ptr_a += 1
-            else:
-                if not _feq_zero(transpose.data[ptr_b], tol):
-                    return False
-                ptr_b += 1
-        for ptr_a in range(ptr_a, ptr_a_end):
-            if not _feq_zero(matrix.data[ptr_a], tol):
-                return False
-        for ptr_b in range(ptr_b, ptr_b_end):
-            if not _feq_zero(transpose.data[ptr_b], tol):
-                return False
-    return True
-
-cpdef bint isherm_csr(CSR matrix, double tol=-1):
-    """
-    Determine whether an input CSR matrix is Hermitian up to a given
-    floating-point tolerance.
-
-    Parameters
-    ----------
-    matrix : CSR
-        Input matrix to test
-    tol : double, optional
-        Absolute tolerance value to use.  Defaults to
-        :obj:`settings.core['atol']`.
-
-    Returns
-    -------
-    bint
-        Boolean True if it is Hermitian, False if not.
-
-    Notes
-    -----
-    The implementation is effectively just taking the adjoint, but rather than
-    actually allocating and creating a new matrix, we just check whether the
-    output would match the input matrix.  If we cannot be certain of Hermicity
-    because the sizes of some elements are within tolerance of 0, we have to
-    resort to a complete adjoint calculation.
-    """
-    tol = tol if tol >= 0 else settings.core["atol"]
-    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
-    if matrix.shape[0] != matrix.shape[1]:
-        return False
-    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
-    if out_row_index == NULL:
-        raise MemoryError
-    matrix.sort_indices()
-    try:
-        for row in range(nrows):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr] + 1
-                out_row_index[col] += 1
-        for row in range(nrows):
-            out_row_index[row+1] += out_row_index[row]
-            if out_row_index[row + 1] != matrix.row_index[row + 1]:
-                # Structures are not the same, but it could still be Hermitian
-                # if any value is less than the tolerance.  That is the
-                # worst-case scenario, so we sacrifice its speed in favour of
-                # returning faster for the more common failure cases.
-                for ptr in range(matrix.row_index[nrows]):
-                    if _conj_feq(matrix.data[ptr], 0, tol):
-                        return _isherm_csr_full(matrix, tol)
-                return False
-        for row in range(nrows):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr]
-                # Pointer into the "transposed" matrix.
-                ptr_t = out_row_index[col]
-                out_row_index[col] += 1
-                if row != matrix.col_index[ptr_t]:
-                    return _isherm_csr_full(matrix, tol)
-                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
-                    return False
-        return True
-    finally:
-        mem.PyMem_Free(out_row_index)
-
-
-cpdef bint isherm_dense(Dense matrix, double tol=-1):
-    """
-    Determine whether an input Dense matrix is Hermitian up to a given
-    floating-point tolerance.
-
-    Parameters
-    ----------
-    matrix : Dense
-        Input matrix to test
-    tol : double, optional
-        Absolute tolerance value to use.  Defaults to
-        :obj:`settings.core['atol']`.
-
-    Returns
-    -------
-    bint
-        Boolean True if it is Hermitian, False if not.
-    """
-    if matrix.shape[0] != matrix.shape[1]:
-        return False
-    tol = tol if tol >= 0 else settings.core["atol"]
-    cdef size_t row, col, size=matrix.shape[0]
-    for row in range(size):
-        for col in range(row + 1):
-            if not _conj_feq(
-                matrix.data[col*size+row],
-                matrix.data[row*size+col],
-                tol
-            ):
-                return False
-    return True
-
-
-cpdef bint isdiag_csr(CSR matrix) nogil:
-    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
-    for row in range(matrix.shape[0]):
-        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
-        if ptr_end - ptr_start > 1:
-            return False
-        if ptr_end - ptr_start == 1:
-            if matrix.col_index[ptr_start] != row:
-                return False
-    return True
-
-
-cpdef bint isdiag_dense(Dense matrix) nogil:
-    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
-    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
-    for row in range(matrix.shape[0]):
-        for col in range(matrix.shape[1]):
-            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
-                return False
-    return True
-
-
-cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
-    cdef size_t ptr
-    if tol < 0:
-        with gil:
-            tol = settings.core["atol"]
-    tolsq = tol*tol
-    for ptr in range(csr.nnz(matrix)):
-        if _abssq(matrix.data[ptr]) > tolsq:
-            return False
-    return True
-
-cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
-    cdef size_t ptr
-    if tol < 0:
-        with gil:
-            tol = settings.core["atol"]
-    tolsq = tol*tol
-    for ptr in range(matrix.shape[0]*matrix.shape[1]):
-        if _abssq(matrix.data[ptr]) > tolsq:
-            return False
-    return True
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-isherm = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=-1),
-    ]),
-    name='isherm',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-isherm.__doc__ =\
-    """
-    Check if the matrix is Hermitian up to a optional element-wise absolute
-    tolerance.  If the tolerance given is less than zero, the global settings
-    value `qutip.settings.atol` will be used instead.
-
-    Only square matrices can possibly be Hermitian.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to test for Hermicity.
-
-    tol : real, optional
-        If given, the absolute tolerance used to compare two values for
-        equality.  If not given, or given and negative, the value of
-        `qutip.settings.atol` is used instead.
-    """
-isherm.add_specialisations([
-    (Dense, isherm_dense),
-    (CSR, isherm_csr),
-], _defer=True)
-
-isdiag = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='isdiag',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-isdiag.__doc__ =\
-    """
-    Check if the matrix is diagonal.  The matrix need not be square to test.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to test for diagonality.
-    """
-isdiag.add_specialisations([
-    (Dense, isdiag_dense),
-    (CSR, isdiag_csr),
-], _defer=True)
-
-iszero = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=-1),
-    ]),
-    name='iszero',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-iszero.__doc__ =\
-    """
-    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to test.
-    tol : real, optional
-        The absolute tolerance to use when comparing to zero.  If not given, or
-        less than 0, use the core setting `atol`.
-
-    Returns
-    -------
-    bool
-        Whether the matrix is equivalent to 0 under the given absolute
-        tolerance.
-    """
-iszero.add_specialisations([
-    (CSR, iszero_csr),
-    (Dense, iszero_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+from cpython cimport mem
+
+from qutip.settings import settings
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport csr, dense, CSR, Dense
+from qutip.core.data.adjoint cimport transpose_csr
+
+cdef extern from *:
+    # Not defined in cpython.mem for some reason, but is in pymem.h.
+    void *PyMem_Calloc(size_t nelem, size_t elsize)
+
+__all__ = [
+    'isherm', 'isherm_csr', 'isherm_dense',
+    'isdiag', 'isdiag_csr', 'isdiag_dense',
+    'iszero', 'iszero_csr', 'iszero_dense',
+]
+
+cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
+    """Check whether a == conj(b) up to an absolute tolerance."""
+    cdef double re = a.real - b.real
+    cdef double im = a.imag + b.imag
+    # Comparing the squares should be fine---there is possible precision loss
+    # in the addition, but as re*re and im*im are both positive semidefinite,
+    # the floating point result is strictly not greater than the true value.
+    # Save the cycles: don't sqrt.
+    return re*re + im*im < tol*tol
+
+cdef inline bint _feq_zero(double complex a, double tol) nogil:
+    return a.real*a.real + a.imag*a.imag < tol*tol
+
+cdef inline double _abssq(double complex x) nogil:
+    return x.real*x.real + x.imag*x.imag
+
+
+cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
+    """
+    Full, structural test for Hermicity of a matrix.  We assume that the input
+    matrix has already had its shape tested (must be square).
+
+    This test is only necessary when there is at least one value which is less
+    than the tolerance, and needed to be compared to an implicit zero.  In
+    general it is less efficient than the other test, and allocates more
+    memory.
+    """
+    cdef CSR transpose = transpose_csr(matrix)
+    cdef idxint row, ptr_a, ptr_b, col_a, col_b
+    for row in range(matrix.shape[0]):
+        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
+        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
+        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
+            # Doing this on every loop actually involves a few more
+            # de-references than are strictly necessary, but just
+            # simplifies the logic checking for the end of the row.
+            col_a = matrix.col_index[ptr_a]
+            col_b = transpose.col_index[ptr_b]
+            if col_a == col_b:
+                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
+                    return False
+                ptr_a += 1
+                ptr_b += 1
+            elif col_a < col_b:
+                if not _feq_zero(matrix.data[ptr_a], tol):
+                    return False
+                ptr_a += 1
+            else:
+                if not _feq_zero(transpose.data[ptr_b], tol):
+                    return False
+                ptr_b += 1
+        for ptr_a in range(ptr_a, ptr_a_end):
+            if not _feq_zero(matrix.data[ptr_a], tol):
+                return False
+        for ptr_b in range(ptr_b, ptr_b_end):
+            if not _feq_zero(transpose.data[ptr_b], tol):
+                return False
+    return True
+
+cpdef bint isherm_csr(CSR matrix, double tol=-1):
+    """
+    Determine whether an input CSR matrix is Hermitian up to a given
+    floating-point tolerance.
+
+    Parameters
+    ----------
+    matrix : CSR
+        Input matrix to test
+    tol : double, optional
+        Absolute tolerance value to use.  Defaults to
+        :obj:`settings.core['atol']`.
+
+    Returns
+    -------
+    bint
+        Boolean True if it is Hermitian, False if not.
+
+    Notes
+    -----
+    The implementation is effectively just taking the adjoint, but rather than
+    actually allocating and creating a new matrix, we just check whether the
+    output would match the input matrix.  If we cannot be certain of Hermicity
+    because the sizes of some elements are within tolerance of 0, we have to
+    resort to a complete adjoint calculation.
+    """
+    tol = tol if tol >= 0 else settings.core["atol"]
+    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
+    if matrix.shape[0] != matrix.shape[1]:
+        return False
+    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
+    if out_row_index == NULL:
+        raise MemoryError
+    matrix.sort_indices()
+    try:
+        for row in range(nrows):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr] + 1
+                out_row_index[col] += 1
+        for row in range(nrows):
+            out_row_index[row+1] += out_row_index[row]
+            if out_row_index[row + 1] != matrix.row_index[row + 1]:
+                # Structures are not the same, but it could still be Hermitian
+                # if any value is less than the tolerance.  That is the
+                # worst-case scenario, so we sacrifice its speed in favour of
+                # returning faster for the more common failure cases.
+                for ptr in range(matrix.row_index[nrows]):
+                    if _conj_feq(matrix.data[ptr], 0, tol):
+                        return _isherm_csr_full(matrix, tol)
+                return False
+        for row in range(nrows):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr]
+                # Pointer into the "transposed" matrix.
+                ptr_t = out_row_index[col]
+                out_row_index[col] += 1
+                if row != matrix.col_index[ptr_t]:
+                    return _isherm_csr_full(matrix, tol)
+                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
+                    return False
+        return True
+    finally:
+        mem.PyMem_Free(out_row_index)
+
+
+cpdef bint isherm_dense(Dense matrix, double tol=-1):
+    """
+    Determine whether an input Dense matrix is Hermitian up to a given
+    floating-point tolerance.
+
+    Parameters
+    ----------
+    matrix : Dense
+        Input matrix to test
+    tol : double, optional
+        Absolute tolerance value to use.  Defaults to
+        :obj:`settings.core['atol']`.
+
+    Returns
+    -------
+    bint
+        Boolean True if it is Hermitian, False if not.
+    """
+    if matrix.shape[0] != matrix.shape[1]:
+        return False
+    tol = tol if tol >= 0 else settings.core["atol"]
+    cdef size_t row, col, size=matrix.shape[0]
+    for row in range(size):
+        for col in range(row + 1):
+            if not _conj_feq(
+                matrix.data[col*size+row],
+                matrix.data[row*size+col],
+                tol
+            ):
+                return False
+    return True
+
+
+cpdef bint isdiag_csr(CSR matrix) nogil:
+    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
+    for row in range(matrix.shape[0]):
+        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
+        if ptr_end - ptr_start > 1:
+            return False
+        if ptr_end - ptr_start == 1:
+            if matrix.col_index[ptr_start] != row:
+                return False
+    return True
+
+
+cpdef bint isdiag_dense(Dense matrix) nogil:
+    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
+    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
+    for row in range(matrix.shape[0]):
+        for col in range(matrix.shape[1]):
+            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
+                return False
+    return True
+
+
+cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
+    cdef size_t ptr
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    tolsq = tol*tol
+    for ptr in range(csr.nnz(matrix)):
+        if _abssq(matrix.data[ptr]) > tolsq:
+            return False
+    return True
+
+cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
+    cdef size_t ptr
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    tolsq = tol*tol
+    for ptr in range(matrix.shape[0]*matrix.shape[1]):
+        if _abssq(matrix.data[ptr]) > tolsq:
+            return False
+    return True
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+isherm = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=-1),
+    ]),
+    name='isherm',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+isherm.__doc__ =\
+    """
+    Check if the matrix is Hermitian up to a optional element-wise absolute
+    tolerance.  If the tolerance given is less than zero, the global settings
+    value `qutip.settings.atol` will be used instead.
+
+    Only square matrices can possibly be Hermitian.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to test for Hermicity.
+
+    tol : real, optional
+        If given, the absolute tolerance used to compare two values for
+        equality.  If not given, or given and negative, the value of
+        `qutip.settings.atol` is used instead.
+    """
+isherm.add_specialisations([
+    (Dense, isherm_dense),
+    (CSR, isherm_csr),
+], _defer=True)
+
+isdiag = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='isdiag',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+isdiag.__doc__ =\
+    """
+    Check if the matrix is diagonal.  The matrix need not be square to test.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to test for diagonality.
+    """
+isdiag.add_specialisations([
+    (Dense, isdiag_dense),
+    (CSR, isdiag_csr),
+], _defer=True)
+
+iszero = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=-1),
+    ]),
+    name='iszero',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+iszero.__doc__ =\
+    """
+    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to test.
+    tol : real, optional
+        The absolute tolerance to use when comparing to zero.  If not given, or
+        less than 0, use the core setting `atol`.
+
+    Returns
+    -------
+    bool
+        Whether the matrix is equivalent to 0 under the given absolute
+        tolerance.
+    """
+iszero.add_specialisations([
+    (CSR, iszero_csr),
+    (Dense, iszero_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/ptrace.pxd b/qutip/core/data/ptrace.pxd
index 6689bafaec..a233d0c0a3 100644
--- a/qutip/core/data/ptrace.pxd
+++ b/qutip/core/data/ptrace.pxd
@@ -1,7 +1,7 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
-cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
-cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
+cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
+cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 3e58e82d94..e45522ef5d 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -1,216 +1,216 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
-
-import numbers
-
-import numpy as np
-
-cimport numpy as cnp
-
-from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
-from qutip.core.data.base import idxint_dtype
-from qutip.settings import settings
-
-cnp.import_array()
-
-__all__ = [
-    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
-]
-
-cdef tuple _parse_inputs(object dims, object sel, tuple shape):
-    cdef Py_ssize_t i
-
-    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
-    sel = np.atleast_1d(sel).astype(idxint_dtype)
-    sel.sort()
-
-    if shape[0] != shape[1]:
-        raise ValueError("ptrace is only defined for square density matrices")
-
-    if shape[0] != np.prod(dims, dtype=int):
-        raise ValueError(f"the input matrix shape, {shape} and the"
-                         f" dimension argument, {dims}, are not compatible.")
-    if sel.ndim != 1:
-        raise ValueError("Selection must be one-dimensional")
-
-    if any(d < 1 for d in dims):
-        raise ValueError("dimensions must be greated than zero but where"
-                         f" dims={dims}.")
-
-    for i in range(sel.shape[0]):
-        if sel[i] < 0 or sel[i] >= dims.size:
-            raise IndexError("Invalid selection index in ptrace.")
-        if i > 0 and sel[i] == sel[i - 1]:
-            raise ValueError("Duplicate selection index in ptrace.")
-
-    return dims, sel
-
-cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
-    """
-    Populate the helper structure `tensor_table`.  Returns the size (number of
-    rows and number of columns) of the matrix which will be output.
-    """
-    cdef size_t ii
-    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
-    cdef size_t num_dims = _dims.shape[0]
-    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
-    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
-    for ii in range(_sel.shape[0]):
-        if _sel[ii] < 0 or _sel[ii] >= num_dims:
-            raise TypeError("Invalid selection index in ptrace.")
-    for ii in range(num_dims - 1,-1,-1):
-        tensor_table[ii, 0] = factor_tensor
-        factor_tensor *= _dims[ii]
-        if _in(ii, _sel):
-            tensor_table[ii, 1] = factor_keep
-            factor_keep *= _dims[ii]
-        else:
-            tensor_table[ii, 2]  = factor_trace
-            factor_trace *= _dims[ii]
-    return factor_keep
-
-
-cdef bint _in(idxint val, idxint[::1] vec):
-    cdef int ii
-    for ii in range(vec.shape[0]):
-        if val == vec[ii]:
-            return True
-    return False
-
-
-cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
-    # indices determining function for ptrace
-    cdef size_t ii
-    cdef idxint t1, t2
-    out[0] = out[1] = 0
-    for ii in range(tensor_table.shape[0]):
-        t1 = tensor_table[ii, 0]
-        t2 = N / t1
-        N = N % t1
-        out[0] += tensor_table[ii, 1] * t2
-        out[1] += tensor_table[ii, 2] * t2
-
-
-cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
-    if len(sel) == len(dims):
-        return matrix.copy()
-    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-    cdef idxint size
-    size = _populate_tensor_table(dims, sel, tensor_table)
-    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
-    cdef idxint pos_c[2]
-    cdef idxint pos_r[2]
-    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
-    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
-    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
-    cdef double tol = 0
-    if settings.core['auto_tidyup']:
-        tol = settings.core['auto_tidyup_atol']
-    for row in range(matrix.shape[0]):
-        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
-            _i2_k_t(row, tensor_table, pos_r)
-            if pos_c[1] == pos_r[1]:
-                new_data[p] = matrix.data[ptr]
-                new_row[p] = pos_r[0]
-                new_col[p] = pos_c[0]
-                p += 1
-    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
-                                 size, size, p, tol)
-
-
-cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
-    if len(sel) == len(dims):
-        return dense.from_csr(matrix)
-    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-    cdef idxint size
-    size = _populate_tensor_table(dims, sel, tensor_table)
-    cdef size_t ii, jj
-    cdef idxint pos_c[2]
-    cdef idxint pos_r[2]
-    cdef Dense out = dense.zeros(size, size, fortran=False)
-    for ii in range(matrix.shape[0]):
-        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
-            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
-            _i2_k_t(ii, tensor_table, pos_r)
-            if pos_c[1] == pos_r[1]:
-                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
-    return out
-
-
-cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
-    if len(sel) == len(dims):
-        return matrix.copy()
-    nd = dims.shape[0]
-    dkeep = [dims[x] for x in sel]
-    qtrace = list(set(np.arange(nd)) - set(sel))
-    dtrace = [dims[x] for x in qtrace]
-    dims = list(dims)
-    sel = list(sel)
-    rhomat = np.trace(matrix.as_ndarray()
-                      .reshape(dims + dims)
-                      .transpose(qtrace + [nd + q for q in qtrace] +
-                                 sel + [nd + q for q in sel])
-                      .reshape([np.prod(dtrace, dtype=int),
-                                np.prod(dtrace, dtype=int),
-                                np.prod(dkeep, dtype=int),
-                                np.prod(dkeep, dtype=int)]))
-    return dense.fast_from_numpy(rhomat)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-ptrace = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='ptrace',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-ptrace.__doc__ =\
-    """
-    Compute the partial trace of this matrix, leaving the subspaces whose
-    indices are in `sel`.  This is only defined for square density matrices,
-    and always returns a density matrix.
-
-    The order of the indices in `sel` do not matter; the output matrix will
-    always have the selected subspaces in the same order that they are in the
-    input matrix.
-
-    For example, if the input is the matrix backing a `Qobj` with
-    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
-        ptrace(data, [2, 3, 4], [0, 2])
-    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The density matrix to be partially traced.
-
-    dims : array_like of integer
-        The dimensions of the subspaces.  This is most likely a 1D list, and
-        since this is only defined on square matrices, there is no need to pass
-        before the left and right sides.  Typically the input matrix will be
-        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
-
-    sel : integer or array_like of integer
-        The indices of the subspaces which should be _kept_.
-    """
-ptrace.add_specialisations([
-    (CSR, CSR, ptrace_csr),
-    (CSR, Dense, ptrace_csr_dense),
-    (Dense, Dense, ptrace_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
+
+import numbers
+
+import numpy as np
+
+cimport numpy as cnp
+
+from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
+from qutip.core.data.base import idxint_dtype
+from qutip.settings import settings
+
+cnp.import_array()
+
+__all__ = [
+    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
+]
+
+cdef tuple _parse_inputs(object dims, object sel, tuple shape):
+    cdef Py_ssize_t i
+
+    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
+    sel = np.atleast_1d(sel).astype(idxint_dtype)
+    sel.sort()
+
+    if shape[0] != shape[1]:
+        raise ValueError("ptrace is only defined for square density matrices")
+
+    if shape[0] != np.prod(dims, dtype=int):
+        raise ValueError(f"the input matrix shape, {shape} and the"
+                         f" dimension argument, {dims}, are not compatible.")
+    if sel.ndim != 1:
+        raise ValueError("Selection must be one-dimensional")
+
+    if any(d < 1 for d in dims):
+        raise ValueError("dimensions must be greated than zero but where"
+                         f" dims={dims}.")
+
+    for i in range(sel.shape[0]):
+        if sel[i] < 0 or sel[i] >= dims.size:
+            raise IndexError("Invalid selection index in ptrace.")
+        if i > 0 and sel[i] == sel[i - 1]:
+            raise ValueError("Duplicate selection index in ptrace.")
+
+    return dims, sel
+
+cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
+    """
+    Populate the helper structure `tensor_table`.  Returns the size (number of
+    rows and number of columns) of the matrix which will be output.
+    """
+    cdef size_t ii
+    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
+    cdef size_t num_dims = _dims.shape[0]
+    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
+    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
+    for ii in range(_sel.shape[0]):
+        if _sel[ii] < 0 or _sel[ii] >= num_dims:
+            raise TypeError("Invalid selection index in ptrace.")
+    for ii in range(num_dims - 1,-1,-1):
+        tensor_table[ii, 0] = factor_tensor
+        factor_tensor *= _dims[ii]
+        if _in(ii, _sel):
+            tensor_table[ii, 1] = factor_keep
+            factor_keep *= _dims[ii]
+        else:
+            tensor_table[ii, 2]  = factor_trace
+            factor_trace *= _dims[ii]
+    return factor_keep
+
+
+cdef bint _in(idxint val, idxint[::1] vec):
+    cdef int ii
+    for ii in range(vec.shape[0]):
+        if val == vec[ii]:
+            return True
+    return False
+
+
+cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
+    # indices determining function for ptrace
+    cdef size_t ii
+    cdef idxint t1, t2
+    out[0] = out[1] = 0
+    for ii in range(tensor_table.shape[0]):
+        t1 = tensor_table[ii, 0]
+        t2 = N / t1
+        N = N % t1
+        out[0] += tensor_table[ii, 1] * t2
+        out[1] += tensor_table[ii, 2] * t2
+
+
+cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return matrix.copy()
+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+    cdef idxint size
+    size = _populate_tensor_table(dims, sel, tensor_table)
+    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
+    cdef idxint pos_c[2]
+    cdef idxint pos_r[2]
+    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
+    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
+    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
+    cdef double tol = 0
+    if settings.core['auto_tidyup']:
+        tol = settings.core['auto_tidyup_atol']
+    for row in range(matrix.shape[0]):
+        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
+            _i2_k_t(row, tensor_table, pos_r)
+            if pos_c[1] == pos_r[1]:
+                new_data[p] = matrix.data[ptr]
+                new_row[p] = pos_r[0]
+                new_col[p] = pos_c[0]
+                p += 1
+    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
+                                 size, size, p, tol)
+
+
+cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return dense.from_csr(matrix)
+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+    cdef idxint size
+    size = _populate_tensor_table(dims, sel, tensor_table)
+    cdef size_t ii, jj
+    cdef idxint pos_c[2]
+    cdef idxint pos_r[2]
+    cdef Dense out = dense.zeros(size, size, fortran=False)
+    for ii in range(matrix.shape[0]):
+        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
+            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
+            _i2_k_t(ii, tensor_table, pos_r)
+            if pos_c[1] == pos_r[1]:
+                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
+    return out
+
+
+cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return matrix.copy()
+    nd = dims.shape[0]
+    dkeep = [dims[x] for x in sel]
+    qtrace = list(set(np.arange(nd)) - set(sel))
+    dtrace = [dims[x] for x in qtrace]
+    dims = list(dims)
+    sel = list(sel)
+    rhomat = np.trace(matrix.as_ndarray()
+                      .reshape(dims + dims)
+                      .transpose(qtrace + [nd + q for q in qtrace] +
+                                 sel + [nd + q for q in sel])
+                      .reshape([np.prod(dtrace, dtype=int),
+                                np.prod(dtrace, dtype=int),
+                                np.prod(dkeep, dtype=int),
+                                np.prod(dkeep, dtype=int)]))
+    return dense.fast_from_numpy(rhomat)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+ptrace = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='ptrace',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+ptrace.__doc__ =\
+    """
+    Compute the partial trace of this matrix, leaving the subspaces whose
+    indices are in `sel`.  This is only defined for square density matrices,
+    and always returns a density matrix.
+
+    The order of the indices in `sel` do not matter; the output matrix will
+    always have the selected subspaces in the same order that they are in the
+    input matrix.
+
+    For example, if the input is the matrix backing a `Qobj` with
+    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
+        ptrace(data, [2, 3, 4], [0, 2])
+    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The density matrix to be partially traced.
+
+    dims : array_like of integer
+        The dimensions of the subspaces.  This is most likely a 1D list, and
+        since this is only defined on square matrices, there is no need to pass
+        before the left and right sides.  Typically the input matrix will be
+        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
+
+    sel : integer or array_like of integer
+        The indices of the subspaces which should be _kept_.
+    """
+ptrace.add_specialisations([
+    (CSR, CSR, ptrace_csr),
+    (CSR, Dense, ptrace_csr_dense),
+    (Dense, Dense, ptrace_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/reshape.pxd b/qutip/core/data/reshape.pxd
index 4efae3a0e4..1b04512f60 100644
--- a/qutip/core/data/reshape.pxd
+++ b/qutip/core/data/reshape.pxd
@@ -1,12 +1,12 @@
-#cython: language_level=3
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport CSR, Dense
-
-cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
-cpdef CSR column_stack_csr(CSR matrix)
-cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
-
-cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
-cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
-cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
+#cython: language_level=3
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport CSR, Dense
+
+cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
+cpdef CSR column_stack_csr(CSR matrix)
+cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
+
+cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
+cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
+cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
index 6871e12c9b..aeb83a22ff 100644
--- a/qutip/core/data/reshape.pyx
+++ b/qutip/core/data/reshape.pyx
@@ -1,285 +1,285 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
-
-from libc.string cimport memcpy, memset
-
-cimport cython
-
-import warnings
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense, Data
-
-__all__ = [
-    'reshape', 'reshape_csr', 'reshape_dense',
-    'column_stack', 'column_stack_csr', 'column_stack_dense',
-    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
-    'split_columns', 'split_columns_dense', 'split_columns_csr',
-]
-
-
-cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
-    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
-        message = "".join([
-            "cannot reshape ", str(matrix.shape), " to ",
-            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
-        ])
-        raise ValueError(message)
-    if n_rows_out <= 0 or n_cols_out <= 0:
-        raise ValueError("must have > 0 rows and columns")
-
-
-cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
-    cdef size_t ptr, row_in, row_out=0, loc, cur=0
-    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
-    cdef idxint nnz = csr.nnz(matrix)
-    cdef CSR out
-    _reshape_check_input(matrix, n_rows_out, n_cols_out)
-    out = csr.empty(n_rows_out, n_cols_out, nnz)
-    matrix.sort_indices()
-    with nogil:
-        # Since the indices are now sorted, the data arrays will be identical.
-        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
-        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
-        for row_in in range(n_rows_in):
-            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
-                loc = cur + matrix.col_index[ptr]
-                out.row_index[loc // n_cols_out + 1] += 1
-                out.col_index[ptr] = loc % n_cols_out
-            cur += n_cols_in
-        for row_out in range(n_rows_out):
-            out.row_index[row_out + 1] += out.row_index[row_out]
-    return out
-
-
-cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
-    return (idx // size) + (idx % size)
-
-
-cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
-    _reshape_check_input(matrix, n_rows_out, n_cols_out)
-    cdef Dense out
-    if not matrix.fortran:
-        out = matrix.copy()
-        out.shape = (n_rows_out, n_cols_out)
-        return out
-    out = dense.zeros(n_rows_out, n_cols_out)
-    cdef size_t idx_in=0, idx_out=0
-    cdef size_t size = n_rows_out * n_cols_out
-    # TODO: improve the algorithm here.
-    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
-    for idx_in in range(size):
-        out.data[idx_out] = matrix.data[idx_in]
-        idx_out = _reshape_dense_reindex(idx_out + stride, size)
-    return out
-
-
-cpdef CSR column_stack_csr(CSR matrix):
-    if matrix.shape[1] == 1:
-        return matrix.copy()
-    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
-
-
-cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
-    cdef Dense out
-    if inplace and matrix.fortran:
-        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
-        return matrix
-    if matrix.fortran:
-        out = matrix.copy()
-        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
-        return out
-    if inplace:
-        warnings.warn("cannot stack columns inplace for C-ordered matrix")
-    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
-
-
-cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
-    if matrix.shape[1] != 1:
-        raise ValueError("input is not a single column")
-    if rows < 1:
-        raise ValueError("rows must be a positive integer")
-    if matrix.shape[0] % rows:
-        raise ValueError("number of rows does not divide into the shape")
-
-
-cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
-    _column_unstack_check_shape(matrix, rows)
-    cdef idxint cols = matrix.shape[0] // rows
-    return reshape_csr(matrix, cols, rows).transpose()
-
-cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
-    _column_unstack_check_shape(matrix, rows)
-    cdef idxint cols = matrix.shape[0] // rows
-    if inplace and matrix.fortran:
-        matrix.shape = (rows, cols)
-        return matrix
-    elif inplace:
-        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
-    out = dense.empty(rows, cols, fortran=True)
-    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
-    return out
-
-
-cpdef list split_columns_dense(Dense matrix, copy=True):
-    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
-            for k in range(matrix.shape[1])]
-
-cpdef list split_columns_csr(CSR matrix, copy=True):
-    return [CSR(matrix.as_scipy()[:, k], copy=copy)
-            for k in range(matrix.shape[1])]
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-reshape = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='reshape',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-reshape.__doc__ =\
-    """
-    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
-    match the current total number of elements of the matrix.
-
-    Parameters
-    ----------
-    matrix : Data
-        The input matrix to reshape.
-
-    n_rows_out, n_cols_out : integer
-        The number of rows and columns in the output matrix.
-    """
-reshape.add_specialisations([
-    (CSR, CSR, reshape_csr),
-    (Dense, Dense, reshape_dense),
-], _defer=True)
-
-
-# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
-# signature of `column_stack` because the dispatcher logic currently doesn't
-# support the idea of an input parameter also being the output.
-
-column_stack = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='column_stack',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-column_stack.__doc__ =\
-    """
-    Stack the columns of a matrix so it becomes a ket-like vector.  For
-    example, the matrix
-        [[0, 1, 2],
-         [3, 4, 5],
-         [6, 7, 8]]
-    would be transformed to
-        [[0],
-         [3],
-         [6],
-         [1],
-         ...
-         [5],
-         [8]]
-    This is used for transforming between operator and operator-ket
-    representations in the super-operator formalism.
-
-    The inverse of this operation is `column_unstack`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to stack the columns of.
-    """
-column_stack.add_specialisations([
-    (CSR, CSR, column_stack_csr),
-    (Dense, Dense, column_stack_dense),
-], _defer=True)
-
-column_unstack = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='column_unstack',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-column_unstack.__doc__ =\
-    """
-    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
-    number of rows.  For example, the matrix
-        [[0],
-         [1],
-         [2],
-         [3]]
-    would be unstacked with `rows = 2` to
-        [[0, 2],
-         [1, 3]]
-    This is used for transforming between the operator-ket and operator
-    representations in the super-operator formalism.
-
-    The inverse of this operation is `column_stack`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to unstack the columns of.
-
-    rows : integer
-        The number of rows there should be in the output matrix.  This must
-        divide into the total number of elements in the input.
-    """
-column_unstack.add_specialisations([
-    (CSR, CSR, column_unstack_csr),
-    (Dense, Dense, column_unstack_dense),
-], _defer=True)
-
-
-split_columns = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='split_columns',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-split_columns.__doc__ =\
-    """
-    Make a ket-shaped data out of each columns of the matrix.
-    This is used for to split the eigenvectors from :obj:`eigs`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to unstack the columns of.
-
-    copy : bool, optional
-        The number of rows there should be in the output matrix.  This must
-        divide into the total number of elements in the input.
-
-    Returns
-    -------
-    kets : list
-        list of Data of each columns of the matrix.
-    """
-split_columns.add_specialisations([
-    (CSR, split_columns_csr),
-    (Dense, split_columns_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
+
+from libc.string cimport memcpy, memset
+
+cimport cython
+
+import warnings
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport csr, dense, CSR, Dense, Data
+
+__all__ = [
+    'reshape', 'reshape_csr', 'reshape_dense',
+    'column_stack', 'column_stack_csr', 'column_stack_dense',
+    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
+    'split_columns', 'split_columns_dense', 'split_columns_csr',
+]
+
+
+cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
+    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
+        message = "".join([
+            "cannot reshape ", str(matrix.shape), " to ",
+            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
+        ])
+        raise ValueError(message)
+    if n_rows_out <= 0 or n_cols_out <= 0:
+        raise ValueError("must have > 0 rows and columns")
+
+
+cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
+    cdef size_t ptr, row_in, row_out=0, loc, cur=0
+    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
+    cdef idxint nnz = csr.nnz(matrix)
+    cdef CSR out
+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+    out = csr.empty(n_rows_out, n_cols_out, nnz)
+    matrix.sort_indices()
+    with nogil:
+        # Since the indices are now sorted, the data arrays will be identical.
+        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
+        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
+        for row_in in range(n_rows_in):
+            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
+                loc = cur + matrix.col_index[ptr]
+                out.row_index[loc // n_cols_out + 1] += 1
+                out.col_index[ptr] = loc % n_cols_out
+            cur += n_cols_in
+        for row_out in range(n_rows_out):
+            out.row_index[row_out + 1] += out.row_index[row_out]
+    return out
+
+
+cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
+    return (idx // size) + (idx % size)
+
+
+cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+    cdef Dense out
+    if not matrix.fortran:
+        out = matrix.copy()
+        out.shape = (n_rows_out, n_cols_out)
+        return out
+    out = dense.zeros(n_rows_out, n_cols_out)
+    cdef size_t idx_in=0, idx_out=0
+    cdef size_t size = n_rows_out * n_cols_out
+    # TODO: improve the algorithm here.
+    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
+    for idx_in in range(size):
+        out.data[idx_out] = matrix.data[idx_in]
+        idx_out = _reshape_dense_reindex(idx_out + stride, size)
+    return out
+
+
+cpdef CSR column_stack_csr(CSR matrix):
+    if matrix.shape[1] == 1:
+        return matrix.copy()
+    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+
+
+cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
+    cdef Dense out
+    if inplace and matrix.fortran:
+        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
+        return matrix
+    if matrix.fortran:
+        out = matrix.copy()
+        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
+        return out
+    if inplace:
+        warnings.warn("cannot stack columns inplace for C-ordered matrix")
+    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+
+
+cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
+    if matrix.shape[1] != 1:
+        raise ValueError("input is not a single column")
+    if rows < 1:
+        raise ValueError("rows must be a positive integer")
+    if matrix.shape[0] % rows:
+        raise ValueError("number of rows does not divide into the shape")
+
+
+cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
+    _column_unstack_check_shape(matrix, rows)
+    cdef idxint cols = matrix.shape[0] // rows
+    return reshape_csr(matrix, cols, rows).transpose()
+
+cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
+    _column_unstack_check_shape(matrix, rows)
+    cdef idxint cols = matrix.shape[0] // rows
+    if inplace and matrix.fortran:
+        matrix.shape = (rows, cols)
+        return matrix
+    elif inplace:
+        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
+    out = dense.empty(rows, cols, fortran=True)
+    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
+    return out
+
+
+cpdef list split_columns_dense(Dense matrix, copy=True):
+    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
+            for k in range(matrix.shape[1])]
+
+cpdef list split_columns_csr(CSR matrix, copy=True):
+    return [CSR(matrix.as_scipy()[:, k], copy=copy)
+            for k in range(matrix.shape[1])]
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+reshape = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='reshape',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+reshape.__doc__ =\
+    """
+    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
+    match the current total number of elements of the matrix.
+
+    Parameters
+    ----------
+    matrix : Data
+        The input matrix to reshape.
+
+    n_rows_out, n_cols_out : integer
+        The number of rows and columns in the output matrix.
+    """
+reshape.add_specialisations([
+    (CSR, CSR, reshape_csr),
+    (Dense, Dense, reshape_dense),
+], _defer=True)
+
+
+# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
+# signature of `column_stack` because the dispatcher logic currently doesn't
+# support the idea of an input parameter also being the output.
+
+column_stack = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='column_stack',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+column_stack.__doc__ =\
+    """
+    Stack the columns of a matrix so it becomes a ket-like vector.  For
+    example, the matrix
+        [[0, 1, 2],
+         [3, 4, 5],
+         [6, 7, 8]]
+    would be transformed to
+        [[0],
+         [3],
+         [6],
+         [1],
+         ...
+         [5],
+         [8]]
+    This is used for transforming between operator and operator-ket
+    representations in the super-operator formalism.
+
+    The inverse of this operation is `column_unstack`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to stack the columns of.
+    """
+column_stack.add_specialisations([
+    (CSR, CSR, column_stack_csr),
+    (Dense, Dense, column_stack_dense),
+], _defer=True)
+
+column_unstack = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='column_unstack',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+column_unstack.__doc__ =\
+    """
+    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
+    number of rows.  For example, the matrix
+        [[0],
+         [1],
+         [2],
+         [3]]
+    would be unstacked with `rows = 2` to
+        [[0, 2],
+         [1, 3]]
+    This is used for transforming between the operator-ket and operator
+    representations in the super-operator formalism.
+
+    The inverse of this operation is `column_stack`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to unstack the columns of.
+
+    rows : integer
+        The number of rows there should be in the output matrix.  This must
+        divide into the total number of elements in the input.
+    """
+column_unstack.add_specialisations([
+    (CSR, CSR, column_unstack_csr),
+    (Dense, Dense, column_unstack_dense),
+], _defer=True)
+
+
+split_columns = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='split_columns',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+split_columns.__doc__ =\
+    """
+    Make a ket-shaped data out of each columns of the matrix.
+    This is used for to split the eigenvectors from :obj:`eigs`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to unstack the columns of.
+
+    copy : bool, optional
+        The number of rows there should be in the output matrix.  This must
+        divide into the total number of elements in the input.
+
+    Returns
+    -------
+    kets : list
+        list of Data of each columns of the matrix.
+    """
+split_columns.add_specialisations([
+    (CSR, split_columns_csr),
+    (Dense, split_columns_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index a164d4f745..30cb4dd6c2 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -1,208 +1,208 @@
-from qutip.core.data import CSR, Data, csr, Dense
-import qutip.core.data as _data
-import scipy.sparse.linalg as splinalg
-import numpy as np
-from qutip.settings import settings
-if settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_spsolve
-else:
-    mkl_spsolve = None
-
-
-def _splu(A, B, **kwargs):
-    lu = splinalg.splu(A, **kwargs)
-    return lu.solve(B)
-
-
-def solve_csr_dense(matrix: CSR, target: Dense, method=None,
-                    options: dict={}) -> Dense:
-    """
-    Solve ``Ax=b`` for ``x``.
-
-    Parameters:
-    -----------
-
-    matrix : CSR
-        The matrix ``A``.
-
-    target : Data
-        The matrix or vector ``b``.
-
-    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
-        The function to use to solve the system. Any function from
-        scipy.sparse.linalg which solve the equation Ax=b can be used.
-        `splu` from the same and `mkl_spsolve` are also valid choice.
-
-    options : dict
-        Keywork options to pass to the solver. Refer to the documenentation in
-        scipy.sparse.linalg of the used method for a list of supported keyword.
-        The keyword "csc" can be set to ``True`` to convert the sparse matrix
-        before passing it to the solver.
-
-    .. note::
-        Options for ``mkl_spsolve`` are presently only found in the source
-        code.
-
-    Returns:
-    --------
-    x : Dense
-        Solution to the system Ax = b.
-    """
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only solve using square matrix")
-    if matrix.shape[1] != target.shape[0]:
-        raise ValueError("target does not match the system")
-
-    b = target.as_ndarray()
-
-    method = method or "spsolve"
-
-    if method == "splu":
-        solver = _splu
-    elif hasattr(splinalg, method):
-        solver = getattr(splinalg, method)
-    elif method == "mkl_spsolve" and mkl_spsolve is None:
-        raise ValueError("mkl is not available")
-    elif method == "mkl_spsolve":
-        solver = mkl_spsolve
-    else:
-        raise ValueError(f"Unknown sparse solver {method}.")
-
-    options = options.copy()
-    M = matrix.as_scipy()
-    if options.pop("csc", False):
-        M = M.tocsc()
-
-    out = solver(M, b, **options)
-
-    if isinstance(out, tuple) and len(out) == 2:
-        # iterative method return a success flag
-        out, check = out
-        if check == 0:
-            # Successful
-            pass
-        elif check > 0:
-            raise RuntimeError(
-                f"scipy.sparse.linalg.{method} error: Tolerance was not"
-                f" reached. Error code: {check}"
-            )
-
-        elif check < 0:
-            raise RuntimeError(
-                f"scipy.sparse.linalg.{method} error: Bad input. "
-                f"Error code: {check}"
-            )
-    elif isinstance(out, tuple) and len(out) > 2:
-        # least sqare method return residual, flag, etc.
-        out, *_ = out
-    return Dense(out, copy=False)
-
-
-def solve_dense(matrix: Dense, target: Data, method=None,
-                options: dict={}) -> Dense:
-    """
-    Solve ``Ax=b`` for ``x``.
-
-    Parameters:
-    -----------
-
-    matrix : Dense
-        The matrix ``A``.
-
-    target : Data
-        The matrix or vector ``b``.
-
-    method : str {"solve", "lstsq"}, default="solve"
-        The function from numpy.linalg to use to solve the system.
-
-    options : dict
-        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
-        not use any.
-
-    Returns:
-    --------
-    x : Dense
-        Solution to the system Ax = b.
-    """
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only solve using square matrix")
-    if matrix.shape[1] != target.shape[0]:
-        raise ValueError("target does not match the system")
-
-    if isinstance(target, Dense):
-        b = target.as_ndarray()
-    else:
-        b = target.to_array()
-
-    if method in ["solve", None]:
-        out = np.linalg.solve(matrix.as_ndarray(), b)
-    elif method == "lstsq":
-        out, *_ = np.linalg.lstsq(
-            matrix.as_ndarray(),
-            b,
-            rcond=options.get("rcond", None)
-        )
-    else:
-        raise ValueError(f"Unknown solver {method},"
-                         " 'solve' and 'lstsq' are supported.")
-    return Dense(out, copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-
-solve = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=None),
-        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default={}),
-    ]),
-    name='solve',
-    module=__name__,
-    inputs=('matrix', 'target'),
-    out=True,
-)
-solve.__doc__ = """
-    Solve ``Ax=b`` for ``x``.
-
-    Parameters:
-    -----------
-    matrix : Data
-    The matrix ``A``.
-
-    target : Data
-    The matrix or vector ``b``.
-
-    method : str
-        The function to use to solve the system. Function which solve the
-        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
-        numpy.linalg (Dense ``matrix``) can be used.
-        Sparse cases also accept `splu` and `mkl_spsolve`.
-
-    options : dict
-        Keywork options to pass to the solver. Refer to the documenentation
-        for the chosen method in scipy.sparse.linalg or numpy.linalg.
-        The keyword "csc" can be set to ``True`` to convert the sparse matrix
-        in sparse cases.
-
-    .. note::
-        Options for ``mkl_spsolve`` are presently only found in the source
-        code.
-
-    Returns:
-    --------
-    x : Data
-        Solution to the system Ax = b.
-"""
-solve.add_specialisations([
-    (CSR, Dense, Dense, solve_csr_dense),
-    (Dense, Dense, Dense, solve_dense),
-], _defer=True)
-
-
-del _Dispatcher
-del _inspect
+from qutip.core.data import CSR, Data, csr, Dense
+import qutip.core.data as _data
+import scipy.sparse.linalg as splinalg
+import numpy as np
+from qutip.settings import settings
+if settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_spsolve
+else:
+    mkl_spsolve = None
+
+
+def _splu(A, B, **kwargs):
+    lu = splinalg.splu(A, **kwargs)
+    return lu.solve(B)
+
+
+def solve_csr_dense(matrix: CSR, target: Dense, method=None,
+                    options: dict={}) -> Dense:
+    """
+    Solve ``Ax=b`` for ``x``.
+
+    Parameters:
+    -----------
+
+    matrix : CSR
+        The matrix ``A``.
+
+    target : Data
+        The matrix or vector ``b``.
+
+    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
+        The function to use to solve the system. Any function from
+        scipy.sparse.linalg which solve the equation Ax=b can be used.
+        `splu` from the same and `mkl_spsolve` are also valid choice.
+
+    options : dict
+        Keywork options to pass to the solver. Refer to the documenentation in
+        scipy.sparse.linalg of the used method for a list of supported keyword.
+        The keyword "csc" can be set to ``True`` to convert the sparse matrix
+        before passing it to the solver.
+
+    .. note::
+        Options for ``mkl_spsolve`` are presently only found in the source
+        code.
+
+    Returns:
+    --------
+    x : Dense
+        Solution to the system Ax = b.
+    """
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only solve using square matrix")
+    if matrix.shape[1] != target.shape[0]:
+        raise ValueError("target does not match the system")
+
+    b = target.as_ndarray()
+
+    method = method or "spsolve"
+
+    if method == "splu":
+        solver = _splu
+    elif hasattr(splinalg, method):
+        solver = getattr(splinalg, method)
+    elif method == "mkl_spsolve" and mkl_spsolve is None:
+        raise ValueError("mkl is not available")
+    elif method == "mkl_spsolve":
+        solver = mkl_spsolve
+    else:
+        raise ValueError(f"Unknown sparse solver {method}.")
+
+    options = options.copy()
+    M = matrix.as_scipy()
+    if options.pop("csc", False):
+        M = M.tocsc()
+
+    out = solver(M, b, **options)
+
+    if isinstance(out, tuple) and len(out) == 2:
+        # iterative method return a success flag
+        out, check = out
+        if check == 0:
+            # Successful
+            pass
+        elif check > 0:
+            raise RuntimeError(
+                f"scipy.sparse.linalg.{method} error: Tolerance was not"
+                f" reached. Error code: {check}"
+            )
+
+        elif check < 0:
+            raise RuntimeError(
+                f"scipy.sparse.linalg.{method} error: Bad input. "
+                f"Error code: {check}"
+            )
+    elif isinstance(out, tuple) and len(out) > 2:
+        # least sqare method return residual, flag, etc.
+        out, *_ = out
+    return Dense(out, copy=False)
+
+
+def solve_dense(matrix: Dense, target: Data, method=None,
+                options: dict={}) -> Dense:
+    """
+    Solve ``Ax=b`` for ``x``.
+
+    Parameters:
+    -----------
+
+    matrix : Dense
+        The matrix ``A``.
+
+    target : Data
+        The matrix or vector ``b``.
+
+    method : str {"solve", "lstsq"}, default="solve"
+        The function from numpy.linalg to use to solve the system.
+
+    options : dict
+        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
+        not use any.
+
+    Returns:
+    --------
+    x : Dense
+        Solution to the system Ax = b.
+    """
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only solve using square matrix")
+    if matrix.shape[1] != target.shape[0]:
+        raise ValueError("target does not match the system")
+
+    if isinstance(target, Dense):
+        b = target.as_ndarray()
+    else:
+        b = target.to_array()
+
+    if method in ["solve", None]:
+        out = np.linalg.solve(matrix.as_ndarray(), b)
+    elif method == "lstsq":
+        out, *_ = np.linalg.lstsq(
+            matrix.as_ndarray(),
+            b,
+            rcond=options.get("rcond", None)
+        )
+    else:
+        raise ValueError(f"Unknown solver {method},"
+                         " 'solve' and 'lstsq' are supported.")
+    return Dense(out, copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+solve = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=None),
+        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default={}),
+    ]),
+    name='solve',
+    module=__name__,
+    inputs=('matrix', 'target'),
+    out=True,
+)
+solve.__doc__ = """
+    Solve ``Ax=b`` for ``x``.
+
+    Parameters:
+    -----------
+    matrix : Data
+    The matrix ``A``.
+
+    target : Data
+    The matrix or vector ``b``.
+
+    method : str
+        The function to use to solve the system. Function which solve the
+        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
+        numpy.linalg (Dense ``matrix``) can be used.
+        Sparse cases also accept `splu` and `mkl_spsolve`.
+
+    options : dict
+        Keywork options to pass to the solver. Refer to the documenentation
+        for the chosen method in scipy.sparse.linalg or numpy.linalg.
+        The keyword "csc" can be set to ``True`` to convert the sparse matrix
+        in sparse cases.
+
+    .. note::
+        Options for ``mkl_spsolve`` are presently only found in the source
+        code.
+
+    Returns:
+    --------
+    x : Data
+        Solution to the system Ax = b.
+"""
+solve.add_specialisations([
+    (CSR, Dense, Dense, solve_csr_dense),
+    (Dense, Dense, Dense, solve_dense),
+], _defer=True)
+
+
+del _Dispatcher
+del _inspect
diff --git a/qutip/core/data/src/intdtype.h b/qutip/core/data/src/intdtype.h
index f88c65f952..40920a715c 100644
--- a/qutip/core/data/src/intdtype.h
+++ b/qutip/core/data/src/intdtype.h
@@ -1,2 +1,2 @@
-typedef int32_t idxint;
-int _idxint_size=32;
+typedef int32_t idxint;
+int _idxint_size=32;
diff --git a/qutip/core/data/src/matmul_csr_vector.cpp b/qutip/core/data/src/matmul_csr_vector.cpp
index 2294f3b754..08424c0250 100644
--- a/qutip/core/data/src/matmul_csr_vector.cpp
+++ b/qutip/core/data/src/matmul_csr_vector.cpp
@@ -1,116 +1,116 @@
-#include <complex>
-#if \
-    (defined(__GNUC__) && defined(__SSE3__))\
-    || (defined(_MSC_VER) && defined(__AVX__))
-/* If we're going to manually do the vectorisation, we need to make sure we've
- * included the preprocessor directives.
- */
-# include <pmmintrin.h>
-#endif
-
-#include "matmul_csr_vector.hpp"
-
-template <typename IntT>
-#if \
-    (defined(__GNUC__) && defined(__SSE3__))\
-    || (defined(_MSC_VER) && defined(__AVX__))
-/* Manually apply the vectorisation. */
-void _matmul_csr_vector(
-        const std::complex<double> * _RESTRICT data,
-        const IntT * _RESTRICT col_index,
-        const IntT * _RESTRICT row_index,
-        const std::complex<double> * _RESTRICT vec,
-        const std::complex<double> scale,
-        std::complex<double> * _RESTRICT out,
-        const IntT nrows)
-{
-    IntT row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    for (IntT row=0; row < nrows; row++) {
-        num4 = _mm_setzero_pd();
-        row_start = row_index[row];
-        row_end = row_index[row+1];
-        for (IntT ptr=row_start; ptr < row_end; ptr++) {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
-            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
-                              std::real(vec[col_index[ptr]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
-    }
-}
-#else
-/* No manual vectorisation. */
-void _matmul_csr_vector(
-        const std::complex<double> * _RESTRICT data,
-        const IntT * _RESTRICT col_index,
-        const IntT * _RESTRICT row_index,
-        const std::complex<double> * _RESTRICT vec,
-        const std::complex<double> scale,
-        std::complex<double> * _RESTRICT out,
-        const IntT nrows)
-{
-    IntT row_start, row_end;
-    std::complex<double> dot;
-    for (size_t row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = row_index[row];
-        row_end = row_index[row+1];
-        for (size_t ptr=row_start; ptr < row_end; ptr++)
-        {
-            dot += data[ptr]*vec[col_index[ptr]];
-        }
-        out[row] += scale * dot;
-    }
-}
-#endif
-
-/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
- * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
- * latter causes compatibility issues with defining the sized types with the
- * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
- * three of `int`, `long` and `long long` when doing things this way (despite
- * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
- * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
- * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
- * and `long long`.
- * - Jake Lishman 2020-08-10.
- */
-template void _matmul_csr_vector<>(
-        const std::complex<double> * _RESTRICT,
-        const int * _RESTRICT,
-        const int * _RESTRICT,
-        const std::complex<double> * _RESTRICT,
-        const std::complex<double>,
-        std::complex<double> * _RESTRICT,
-        const int);
-template void _matmul_csr_vector<>(
-        const std::complex<double> * _RESTRICT,
-        const long * _RESTRICT,
-        const long * _RESTRICT,
-        const std::complex<double> * _RESTRICT,
-        const std::complex<double>,
-        std::complex<double> * _RESTRICT,
-        const long);
-template void _matmul_csr_vector<>(
-        const std::complex<double> * _RESTRICT,
-        const long long * _RESTRICT,
-        const long long * _RESTRICT,
-        const std::complex<double> * _RESTRICT,
-        const std::complex<double>,
-        std::complex<double> * _RESTRICT,
-        const long long);
+#include <complex>
+#if \
+    (defined(__GNUC__) && defined(__SSE3__))\
+    || (defined(_MSC_VER) && defined(__AVX__))
+/* If we're going to manually do the vectorisation, we need to make sure we've
+ * included the preprocessor directives.
+ */
+# include <pmmintrin.h>
+#endif
+
+#include "matmul_csr_vector.hpp"
+
+template <typename IntT>
+#if \
+    (defined(__GNUC__) && defined(__SSE3__))\
+    || (defined(_MSC_VER) && defined(__AVX__))
+/* Manually apply the vectorisation. */
+void _matmul_csr_vector(
+        const std::complex<double> * _RESTRICT data,
+        const IntT * _RESTRICT col_index,
+        const IntT * _RESTRICT row_index,
+        const std::complex<double> * _RESTRICT vec,
+        const std::complex<double> scale,
+        std::complex<double> * _RESTRICT out,
+        const IntT nrows)
+{
+    IntT row_start, row_end;
+    __m128d num1, num2, num3, num4;
+    for (IntT row=0; row < nrows; row++) {
+        num4 = _mm_setzero_pd();
+        row_start = row_index[row];
+        row_end = row_index[row+1];
+        for (IntT ptr=row_start; ptr < row_end; ptr++) {
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
+            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
+                              std::real(vec[col_index[ptr]]));
+            num3 = _mm_mul_pd(num2, num1);
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
+            num2 = _mm_shuffle_pd(num2, num2, 1);
+            num2 = _mm_mul_pd(num2, num1);
+            num3 = _mm_addsub_pd(num3, num2);
+            num4 = _mm_add_pd(num3, num4);
+        }
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
+        num3 = _mm_mul_pd(num4, num1);
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
+        num4 = _mm_shuffle_pd(num4, num4, 1);
+        num4 = _mm_mul_pd(num4, num1);
+        num3 = _mm_addsub_pd(num3, num4);
+        num2 = _mm_loadu_pd((double *)&out[row]);
+        num3 = _mm_add_pd(num2, num3);
+        _mm_storeu_pd((double *)&out[row], num3);
+    }
+}
+#else
+/* No manual vectorisation. */
+void _matmul_csr_vector(
+        const std::complex<double> * _RESTRICT data,
+        const IntT * _RESTRICT col_index,
+        const IntT * _RESTRICT row_index,
+        const std::complex<double> * _RESTRICT vec,
+        const std::complex<double> scale,
+        std::complex<double> * _RESTRICT out,
+        const IntT nrows)
+{
+    IntT row_start, row_end;
+    std::complex<double> dot;
+    for (size_t row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = row_index[row];
+        row_end = row_index[row+1];
+        for (size_t ptr=row_start; ptr < row_end; ptr++)
+        {
+            dot += data[ptr]*vec[col_index[ptr]];
+        }
+        out[row] += scale * dot;
+    }
+}
+#endif
+
+/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
+ * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
+ * latter causes compatibility issues with defining the sized types with the
+ * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
+ * three of `int`, `long` and `long long` when doing things this way (despite
+ * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
+ * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
+ * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
+ * and `long long`.
+ * - Jake Lishman 2020-08-10.
+ */
+template void _matmul_csr_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const int * _RESTRICT,
+        const int * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double>,
+        std::complex<double> * _RESTRICT,
+        const int);
+template void _matmul_csr_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const long * _RESTRICT,
+        const long * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double>,
+        std::complex<double> * _RESTRICT,
+        const long);
+template void _matmul_csr_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const long long * _RESTRICT,
+        const long long * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double>,
+        std::complex<double> * _RESTRICT,
+        const long long);
diff --git a/qutip/core/data/src/matmul_csr_vector.hpp b/qutip/core/data/src/matmul_csr_vector.hpp
index 694329ac37..4dd3e72ea0 100755
--- a/qutip/core/data/src/matmul_csr_vector.hpp
+++ b/qutip/core/data/src/matmul_csr_vector.hpp
@@ -1,17 +1,17 @@
-#include <complex>
-
-#if defined(__GNUC__) || defined(_MSC_VER)
-# define _RESTRICT __restrict
-#else
-# define _RESTRICT
-#endif
-
-template <typename IntT>
-void _matmul_csr_vector(
-        const std::complex<double> * _RESTRICT data,
-        const IntT * _RESTRICT col_index,
-        const IntT * _RESTRICT row_index,
-        const std::complex<double> * _RESTRICT vec,
-        const std::complex<double> scale,
-        std::complex<double> * _RESTRICT out,
-        const IntT nrows);
+#include <complex>
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+# define _RESTRICT __restrict
+#else
+# define _RESTRICT
+#endif
+
+template <typename IntT>
+void _matmul_csr_vector(
+        const std::complex<double> * _RESTRICT data,
+        const IntT * _RESTRICT col_index,
+        const IntT * _RESTRICT row_index,
+        const std::complex<double> * _RESTRICT vec,
+        const std::complex<double> scale,
+        std::complex<double> * _RESTRICT out,
+        const IntT nrows);
diff --git a/qutip/core/data/tidyup.pxd b/qutip/core/data/tidyup.pxd
index 4444714507..cd88c2900c 100644
--- a/qutip/core/data/tidyup.pxd
+++ b/qutip/core/data/tidyup.pxd
@@ -1,7 +1,7 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
-cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
+cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
index a9b80798f1..b733871855 100644
--- a/qutip/core/data/tidyup.pyx
+++ b/qutip/core/data/tidyup.pyx
@@ -1,106 +1,106 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.math cimport fabs
-
-cimport numpy as cnp
-
-from qutip.core.data cimport csr, dense, CSR, Dense
-
-cdef extern from "<complex>" namespace "std" nogil:
-    # abs is templated such that Cython treats std::abs as complex->complex
-    double abs(double complex x)
-
-__all__ = [
-    'tidyup', 'tidyup_csr', 'tidyup_dense',
-]
-
-
-cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
-    cdef bint re, im
-    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
-    cdef double complex value
-    cdef CSR out = matrix if inplace else matrix.copy()
-    nnz = 0
-    out.row_index[0] = 0
-    for row in range(matrix.shape[0]):
-        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
-        for ptr in range(ptr_start, ptr_end):
-            re = im = False
-            value = matrix.data[ptr]
-            if fabs(value.real) < tol:
-                re = True
-                value.real = 0
-            if fabs(value.imag) < tol:
-                im = True
-                value.imag = 0
-            if not (re & im):
-                out.data[nnz] = value
-                out.col_index[nnz] = matrix.col_index[ptr]
-                nnz += 1
-        out.row_index[row + 1] = nnz
-    return out
-
-
-cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
-    cdef Dense out = matrix if inplace else matrix.copy()
-    cdef double complex value
-    cdef size_t ptr
-    for ptr in range(matrix.shape[0] * matrix.shape[1]):
-        value = matrix.data[ptr]
-        if fabs(value.real) < tol:
-            matrix.data[ptr].real = 0
-        if fabs(value.imag) < tol:
-            matrix.data[ptr].imag = 0
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-# In this case, to support the `inplace` argument, we do not support
-# dispatching on the output.
-
-tidyup = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=True),
-    ]),
-    name='tidyup',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-tidyup.__doc__ =\
-    """
-    Tidy up the input matrix by truncating small values to zero.  The real and
-    imaginary parts are treated individually, so (for example) the number
-        1e-18 + 2j
-    would be truncated with a tolerance of `1e-15` to just
-        2j
-
-    By default, this operation is in-place.  The output type will always match
-    the input type; no dispatching takes place on the output.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to tidy up.
-
-    tol : real
-        The absolute tolerance to use to determine whether a real or imaginary
-        part should be truncated to zero.
-
-    inplace : bool, optional (True)
-        Whether to do the operation in-place.  The output matrix will always be
-        returned, even if this argument is `True`; it will just be the same
-        Python object as was input.
-    """
-tidyup.add_specialisations([
-    (CSR, tidyup_csr),
-    (Dense, tidyup_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.math cimport fabs
+
+cimport numpy as cnp
+
+from qutip.core.data cimport csr, dense, CSR, Dense
+
+cdef extern from "<complex>" namespace "std" nogil:
+    # abs is templated such that Cython treats std::abs as complex->complex
+    double abs(double complex x)
+
+__all__ = [
+    'tidyup', 'tidyup_csr', 'tidyup_dense',
+]
+
+
+cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
+    cdef bint re, im
+    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
+    cdef double complex value
+    cdef CSR out = matrix if inplace else matrix.copy()
+    nnz = 0
+    out.row_index[0] = 0
+    for row in range(matrix.shape[0]):
+        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
+        for ptr in range(ptr_start, ptr_end):
+            re = im = False
+            value = matrix.data[ptr]
+            if fabs(value.real) < tol:
+                re = True
+                value.real = 0
+            if fabs(value.imag) < tol:
+                im = True
+                value.imag = 0
+            if not (re & im):
+                out.data[nnz] = value
+                out.col_index[nnz] = matrix.col_index[ptr]
+                nnz += 1
+        out.row_index[row + 1] = nnz
+    return out
+
+
+cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
+    cdef Dense out = matrix if inplace else matrix.copy()
+    cdef double complex value
+    cdef size_t ptr
+    for ptr in range(matrix.shape[0] * matrix.shape[1]):
+        value = matrix.data[ptr]
+        if fabs(value.real) < tol:
+            matrix.data[ptr].real = 0
+        if fabs(value.imag) < tol:
+            matrix.data[ptr].imag = 0
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+# In this case, to support the `inplace` argument, we do not support
+# dispatching on the output.
+
+tidyup = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=True),
+    ]),
+    name='tidyup',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+tidyup.__doc__ =\
+    """
+    Tidy up the input matrix by truncating small values to zero.  The real and
+    imaginary parts are treated individually, so (for example) the number
+        1e-18 + 2j
+    would be truncated with a tolerance of `1e-15` to just
+        2j
+
+    By default, this operation is in-place.  The output type will always match
+    the input type; no dispatching takes place on the output.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to tidy up.
+
+    tol : real
+        The absolute tolerance to use to determine whether a real or imaginary
+        part should be truncated to zero.
+
+    inplace : bool, optional (True)
+        Whether to do the operation in-place.  The output matrix will always be
+        returned, even if this argument is `True`; it will just be the same
+        Python object as was input.
+    """
+tidyup.add_specialisations([
+    (CSR, tidyup_csr),
+    (Dense, tidyup_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index e231896f8f..0c9a9d4d10 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -1,9 +1,9 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef double complex trace_csr(CSR matrix) nogil except *
-cpdef double complex trace_dense(Dense matrix) nogil except *
-
-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef double complex trace_csr(CSR matrix) nogil except *
+cpdef double complex trace_dense(Dense matrix) nogil except *
+
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index c256f537cc..5dec3f6de0 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -1,109 +1,109 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-from libc.math cimport sqrt
-
-from qutip.core.data cimport Data, CSR, Dense
-from qutip.core.data cimport base
-
-__all__ = [
-    'trace', 'trace_csr', 'trace_dense',
-    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
-]
-
-
-cdef void _check_shape(Data matrix) nogil except *:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("".join([
-            "matrix shape ", str(matrix.shape), " is not square.",
-        ]))
-
-
-cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
-    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
-        raise ValueError("".join([
-            "matrix ", str(matrix.shape), " is not a stacked square matrix."
-        ]))
-
-
-cpdef double complex trace_csr(CSR matrix) nogil except *:
-    _check_shape(matrix)
-    cdef size_t row, ptr
-    cdef double complex trace = 0
-    for row in range(matrix.shape[0]):
-        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-            if matrix.col_index[ptr] == row:
-                trace += matrix.data[ptr]
-                break
-    return trace
-
-cpdef double complex trace_dense(Dense matrix) nogil except *:
-    _check_shape(matrix)
-    cdef double complex trace = 0
-    cdef size_t ptr = 0
-    cdef size_t stride = matrix.shape[0] + 1
-    for _ in range(matrix.shape[0]):
-        trace += matrix.data[ptr]
-        ptr += stride
-    return trace
-
-
-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
-    cdef size_t N = <size_t>sqrt(matrix.shape[0])
-    _check_shape_oper_ket(N, matrix)
-    cdef size_t row
-    cdef double complex trace = 0
-    cdef size_t stride = N + 1
-    for row in range(N):
-        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
-            trace += matrix.data[matrix.row_index[row * stride]]
-    return trace
-
-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
-    cdef size_t N = <size_t>sqrt(matrix.shape[0])
-    _check_shape_oper_ket(N, matrix)
-    cdef double complex trace = 0
-    cdef size_t ptr = 0
-    cdef size_t stride = N + 1
-    for ptr in range(N):
-        trace += matrix.data[ptr * stride]
-    return trace
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-trace = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='trace',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-trace.__doc__ =\
-    """Compute the trace (sum of digaonal elements) of a square matrix."""
-trace.add_specialisations([
-    (CSR, trace_csr),
-    (Dense, trace_dense),
-], _defer=True)
-
-trace_oper_ket = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='trace_oper_ket',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-trace_oper_ket.__doc__ =\
-    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
-trace_oper_ket.add_specialisations([
-    (CSR, trace_oper_ket_csr),
-    (Dense, trace_oper_ket_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+from libc.math cimport sqrt
+
+from qutip.core.data cimport Data, CSR, Dense
+from qutip.core.data cimport base
+
+__all__ = [
+    'trace', 'trace_csr', 'trace_dense',
+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
+]
+
+
+cdef void _check_shape(Data matrix) nogil except *:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("".join([
+            "matrix shape ", str(matrix.shape), " is not square.",
+        ]))
+
+
+cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
+    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
+        raise ValueError("".join([
+            "matrix ", str(matrix.shape), " is not a stacked square matrix."
+        ]))
+
+
+cpdef double complex trace_csr(CSR matrix) nogil except *:
+    _check_shape(matrix)
+    cdef size_t row, ptr
+    cdef double complex trace = 0
+    for row in range(matrix.shape[0]):
+        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+            if matrix.col_index[ptr] == row:
+                trace += matrix.data[ptr]
+                break
+    return trace
+
+cpdef double complex trace_dense(Dense matrix) nogil except *:
+    _check_shape(matrix)
+    cdef double complex trace = 0
+    cdef size_t ptr = 0
+    cdef size_t stride = matrix.shape[0] + 1
+    for _ in range(matrix.shape[0]):
+        trace += matrix.data[ptr]
+        ptr += stride
+    return trace
+
+
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef size_t row
+    cdef double complex trace = 0
+    cdef size_t stride = N + 1
+    for row in range(N):
+        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
+            trace += matrix.data[matrix.row_index[row * stride]]
+    return trace
+
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef double complex trace = 0
+    cdef size_t ptr = 0
+    cdef size_t stride = N + 1
+    for ptr in range(N):
+        trace += matrix.data[ptr * stride]
+    return trace
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+trace = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='trace',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+trace.__doc__ =\
+    """Compute the trace (sum of digaonal elements) of a square matrix."""
+trace.add_specialisations([
+    (CSR, trace_csr),
+    (Dense, trace_dense),
+], _defer=True)
+
+trace_oper_ket = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='trace_oper_ket',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+trace_oper_ket.__doc__ =\
+    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
+trace_oper_ket.add_specialisations([
+    (CSR, trace_oper_ket_csr),
+    (Dense, trace_oper_ket_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/dimensions.py b/qutip/core/dimensions.py
index a2a4003a52..612e97c8ff 100644
--- a/qutip/core/dimensions.py
+++ b/qutip/core/dimensions.py
@@ -1,345 +1,345 @@
-"""
-Internal use module for manipulating dims specifications.
-"""
-
-# Everything should be explicitly imported, not made available by default.
-
-import numpy as np
-from operator import getitem
-from functools import partial
-
-
-def is_scalar(dims):
-    """
-    Returns True if a dims specification is effectively
-    a scalar (has dimension 1).
-    """
-    return np.prod(flatten(dims)) == 1
-
-
-def is_vector(dims):
-    return (
-        isinstance(dims, list) and
-        isinstance(dims[0], (int, np.integer))
-    )
-
-
-def is_vectorized_oper(dims):
-    return (
-        isinstance(dims, list) and
-        isinstance(dims[0], list)
-    )
-
-
-def type_from_dims(dims, enforce_square=False):
-    bra_like, ket_like = map(is_scalar, dims)
-
-    if bra_like:
-        if is_vector(dims[1]):
-            return 'bra'
-        elif is_vectorized_oper(dims[1]):
-            return 'operator-bra'
-
-    if ket_like:
-        if is_vector(dims[0]):
-            return 'ket'
-        elif is_vectorized_oper(dims[0]):
-            return 'operator-ket'
-
-    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
-        return 'oper'
-
-    elif (
-        is_vectorized_oper(dims[0])
-        and (
-            not enforce_square
-            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
-        )
-    ):
-        return 'super'
-    return 'other'
-
-
-def flatten(l):
-    """Flattens a list of lists to the first level.
-
-    Given a list containing a mix of scalars and lists,
-    flattens down to a list of the scalars within the original
-    list.
-
-    Examples
-    --------
-
-    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
-    [0, 1, 2]
-
-    """
-    if not isinstance(l, list):
-        return [l]
-    else:
-        return sum(map(flatten, l), [])
-
-
-def deep_remove(l, *what):
-    """Removes scalars from all levels of a nested list.
-
-    Given a list containing a mix of scalars and lists,
-    returns a list of the same structure, but where one or
-    more scalars have been removed.
-
-    Examples
-    --------
-
-    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
-    [[[[1, 2]], [3, 4], [], [6, 7]]]
-
-    """
-    if isinstance(l, list):
-        # Make a shallow copy at this level.
-        l = l[:]
-        for to_remove in what:
-            if to_remove in l:
-                l.remove(to_remove)
-            else:
-                l = [deep_remove(elem, to_remove) for elem in l]
-    return l
-
-
-def unflatten(l, idxs):
-    """Unflattens a list by a given structure.
-
-    Given a list of scalars and a deep list of indices
-    as produced by `flatten`, returns an "unflattened"
-    form of the list. This perfectly inverts `flatten`.
-
-    Examples
-    --------
-
-    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
-    >>> idxs = enumerate_flat(l) # doctest: +SKIP
-    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
-    True
-
-    """
-    acc = []
-    for idx in idxs:
-        if isinstance(idx, list):
-            acc.append(unflatten(l, idx))
-        else:
-            acc.append(l[idx])
-    return acc
-
-
-def _enumerate_flat(l, idx=0):
-    if not isinstance(l, list):
-        # Found a scalar, so return and increment.
-        return idx, idx + 1
-    else:
-        # Found a list, so append all the scalars
-        # from it and recurse to keep the increment
-        # correct.
-        acc = []
-        for elem in l:
-            labels, idx = _enumerate_flat(elem, idx)
-            acc.append(labels)
-        return acc, idx
-
-
-def _collapse_composite_index(dims):
-    """
-    Given the dimensions specification for a composite index
-    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
-    returns a dimensions specification for an index of the same shape,
-    but collapsed to a single "leg." In the previous example, [2, 3]
-    would collapse to [6].
-    """
-    return [np.prod(dims)]
-
-
-def _collapse_dims_to_level(dims, level=1):
-    """
-    Recursively collapses all indices in a dimensions specification
-    appearing at a given level, such that the returned dimensions
-    specification does not represent any composite systems.
-    """
-    if level == 0:
-        return _collapse_composite_index(dims)
-    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
-
-
-def collapse_dims_oper(dims):
-    """
-    Given the dimensions specifications for a ket-, bra- or oper-type
-    Qobj, returns a dimensions specification describing the same shape
-    by collapsing all composite systems. For instance, the bra-type
-    dimensions specification ``[[2, 3], [1]]`` collapses to
-    ``[[6], [1]]``.
-
-    Parameters
-    ----------
-
-    dims : list of lists of ints
-        Dimensions specifications to be collapsed.
-
-    Returns
-    -------
-
-    collapsed_dims : list of lists of ints
-        Collapsed dimensions specification describing the same shape
-        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
-    """
-    return _collapse_dims_to_level(dims, 1)
-
-
-def collapse_dims_super(dims):
-    """
-    Given the dimensions specifications for an operator-ket-, operator-bra- or
-    super-type Qobj, returns a dimensions specification describing the same shape
-    by collapsing all composite systems. For instance, the super-type
-    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
-    ``[[[6], [6]], [[6], [6]]]``.
-
-    Parameters
-    ----------
-
-    dims : list of lists of ints
-        Dimensions specifications to be collapsed.
-
-    Returns
-    -------
-
-    collapsed_dims : list of lists of ints
-        Collapsed dimensions specification describing the same shape
-        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
-        in ``range(2)``.
-    """
-    return _collapse_dims_to_level(dims, 2)
-
-
-def enumerate_flat(l):
-    """Labels the indices at which scalars occur in a flattened list.
-
-    Given a list containing a mix of scalars and lists,
-    returns a list of the same structure, where each scalar
-    has been replaced by an index into the flattened list.
-
-    Examples
-    --------
-
-    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
-    [[[0], [1, 2]], 3]
-
-    """
-    return _enumerate_flat(l)[0]
-
-
-def deep_map(fn, collection, over=(tuple, list)):
-    if isinstance(collection, over):
-        return type(collection)(deep_map(fn, el, over) for el in collection)
-    else:
-        return fn(collection)
-
-
-def dims_to_tensor_perm(dims):
-    """
-    Given the dims of a Qobj instance, returns a list representing
-    a permutation from the flattening of that dims specification to
-    the corresponding tensor indices.
-
-    Parameters
-    ----------
-
-    dims : list
-        Dimensions specification for a Qobj.
-
-    Returns
-    -------
-
-    perm : list
-        A list such that ``data[flatten(dims)[idx]]`` gives the
-        index of the tensor ``data`` corresponding to the ``idx``th
-        dimension of ``dims``.
-    """
-    # We figure out the type of the dims specification,
-    # relaxing the requirement that operators be square.
-    # This means that dims_type need not coincide with
-    # Qobj.type, but that works fine for our purposes here.
-    dims_type = type_from_dims(dims, enforce_square=False)
-    perm = enumerate_flat(dims)
-    if dims_type in ('oper', 'ket', 'bra'):
-        return flatten(perm)
-
-    # If the type is other, we need to figure out if the
-    # dims is superlike on its outputs and inputs
-    # This is the case if the dims type for left or right
-    # are, respectively, oper-like.
-    if dims_type == 'other':
-        raise NotImplementedError("Not yet implemented for type='other'.")
-
-    # If we're still here, the story is more complicated. We'll
-    # follow the strategy of creating a permutation by using
-    # enumerate_flat then transforming the result to swap
-    # input and output indices of vectorized matrices, then flattening
-    # the result. We'll then rebuild indices using this permutation.
-    if dims_type in ('operator-ket', 'super'):
-        # Swap the input and output spaces of the right part of
-        # perm.
-        perm[1] = list(reversed(perm[1]))
-    if dims_type in ('operator-bra', 'super'):
-        # Ditto, but for the left indices.
-        perm[0] = list(reversed(perm[0]))
-    return flatten(perm)
-
-
-def dims_to_tensor_shape(dims):
-    """
-    Given the dims of a Qobj instance, returns the shape of the
-    corresponding tensor. This helps, for instance, resolve the
-    column-stacking convention for superoperators.
-
-    Parameters
-    ----------
-
-    dims : list
-        Dimensions specification for a Qobj.
-
-    Returns
-    -------
-
-    tensor_shape : tuple
-        NumPy shape of the corresponding tensor.
-    """
-    perm = dims_to_tensor_perm(dims)
-    dims = flatten(dims)
-    return tuple(map(partial(getitem, dims), perm))
-
-
-def dims_idxs_to_tensor_idxs(dims, indices):
-    """
-    Given the dims of a Qobj instance, and some indices into
-    dims, returns the corresponding tensor indices. This helps
-    resolve, for instance, that column-stacking for superoperators,
-    oper-ket and oper-bra implies that the input and output tensor
-    indices are reversed from their order in dims.
-
-    Parameters
-    ----------
-
-    dims : list
-        Dimensions specification for a Qobj.
-
-    indices : int, list or tuple
-        Indices to convert to tensor indices. Can be specified
-        as a single index, or as a collection of indices.
-        In the latter case, this can be nested arbitrarily
-        deep. For instance, [0, [0, (2, 3)]].
-
-    Returns
-    -------
-
-    tens_indices : int, list or tuple
-        Container of the same structure as indices containing
-        the tensor indices for each element of indices.
-    """
-    perm = dims_to_tensor_perm(dims)
-    return deep_map(partial(getitem, perm), indices)
+"""
+Internal use module for manipulating dims specifications.
+"""
+
+# Everything should be explicitly imported, not made available by default.
+
+import numpy as np
+from operator import getitem
+from functools import partial
+
+
+def is_scalar(dims):
+    """
+    Returns True if a dims specification is effectively
+    a scalar (has dimension 1).
+    """
+    return np.prod(flatten(dims)) == 1
+
+
+def is_vector(dims):
+    return (
+        isinstance(dims, list) and
+        isinstance(dims[0], (int, np.integer))
+    )
+
+
+def is_vectorized_oper(dims):
+    return (
+        isinstance(dims, list) and
+        isinstance(dims[0], list)
+    )
+
+
+def type_from_dims(dims, enforce_square=False):
+    bra_like, ket_like = map(is_scalar, dims)
+
+    if bra_like:
+        if is_vector(dims[1]):
+            return 'bra'
+        elif is_vectorized_oper(dims[1]):
+            return 'operator-bra'
+
+    if ket_like:
+        if is_vector(dims[0]):
+            return 'ket'
+        elif is_vectorized_oper(dims[0]):
+            return 'operator-ket'
+
+    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
+        return 'oper'
+
+    elif (
+        is_vectorized_oper(dims[0])
+        and (
+            not enforce_square
+            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
+        )
+    ):
+        return 'super'
+    return 'other'
+
+
+def flatten(l):
+    """Flattens a list of lists to the first level.
+
+    Given a list containing a mix of scalars and lists,
+    flattens down to a list of the scalars within the original
+    list.
+
+    Examples
+    --------
+
+    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
+    [0, 1, 2]
+
+    """
+    if not isinstance(l, list):
+        return [l]
+    else:
+        return sum(map(flatten, l), [])
+
+
+def deep_remove(l, *what):
+    """Removes scalars from all levels of a nested list.
+
+    Given a list containing a mix of scalars and lists,
+    returns a list of the same structure, but where one or
+    more scalars have been removed.
+
+    Examples
+    --------
+
+    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
+    [[[[1, 2]], [3, 4], [], [6, 7]]]
+
+    """
+    if isinstance(l, list):
+        # Make a shallow copy at this level.
+        l = l[:]
+        for to_remove in what:
+            if to_remove in l:
+                l.remove(to_remove)
+            else:
+                l = [deep_remove(elem, to_remove) for elem in l]
+    return l
+
+
+def unflatten(l, idxs):
+    """Unflattens a list by a given structure.
+
+    Given a list of scalars and a deep list of indices
+    as produced by `flatten`, returns an "unflattened"
+    form of the list. This perfectly inverts `flatten`.
+
+    Examples
+    --------
+
+    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
+    >>> idxs = enumerate_flat(l) # doctest: +SKIP
+    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
+    True
+
+    """
+    acc = []
+    for idx in idxs:
+        if isinstance(idx, list):
+            acc.append(unflatten(l, idx))
+        else:
+            acc.append(l[idx])
+    return acc
+
+
+def _enumerate_flat(l, idx=0):
+    if not isinstance(l, list):
+        # Found a scalar, so return and increment.
+        return idx, idx + 1
+    else:
+        # Found a list, so append all the scalars
+        # from it and recurse to keep the increment
+        # correct.
+        acc = []
+        for elem in l:
+            labels, idx = _enumerate_flat(elem, idx)
+            acc.append(labels)
+        return acc, idx
+
+
+def _collapse_composite_index(dims):
+    """
+    Given the dimensions specification for a composite index
+    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
+    returns a dimensions specification for an index of the same shape,
+    but collapsed to a single "leg." In the previous example, [2, 3]
+    would collapse to [6].
+    """
+    return [np.prod(dims)]
+
+
+def _collapse_dims_to_level(dims, level=1):
+    """
+    Recursively collapses all indices in a dimensions specification
+    appearing at a given level, such that the returned dimensions
+    specification does not represent any composite systems.
+    """
+    if level == 0:
+        return _collapse_composite_index(dims)
+    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
+
+
+def collapse_dims_oper(dims):
+    """
+    Given the dimensions specifications for a ket-, bra- or oper-type
+    Qobj, returns a dimensions specification describing the same shape
+    by collapsing all composite systems. For instance, the bra-type
+    dimensions specification ``[[2, 3], [1]]`` collapses to
+    ``[[6], [1]]``.
+
+    Parameters
+    ----------
+
+    dims : list of lists of ints
+        Dimensions specifications to be collapsed.
+
+    Returns
+    -------
+
+    collapsed_dims : list of lists of ints
+        Collapsed dimensions specification describing the same shape
+        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
+    """
+    return _collapse_dims_to_level(dims, 1)
+
+
+def collapse_dims_super(dims):
+    """
+    Given the dimensions specifications for an operator-ket-, operator-bra- or
+    super-type Qobj, returns a dimensions specification describing the same shape
+    by collapsing all composite systems. For instance, the super-type
+    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
+    ``[[[6], [6]], [[6], [6]]]``.
+
+    Parameters
+    ----------
+
+    dims : list of lists of ints
+        Dimensions specifications to be collapsed.
+
+    Returns
+    -------
+
+    collapsed_dims : list of lists of ints
+        Collapsed dimensions specification describing the same shape
+        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
+        in ``range(2)``.
+    """
+    return _collapse_dims_to_level(dims, 2)
+
+
+def enumerate_flat(l):
+    """Labels the indices at which scalars occur in a flattened list.
+
+    Given a list containing a mix of scalars and lists,
+    returns a list of the same structure, where each scalar
+    has been replaced by an index into the flattened list.
+
+    Examples
+    --------
+
+    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
+    [[[0], [1, 2]], 3]
+
+    """
+    return _enumerate_flat(l)[0]
+
+
+def deep_map(fn, collection, over=(tuple, list)):
+    if isinstance(collection, over):
+        return type(collection)(deep_map(fn, el, over) for el in collection)
+    else:
+        return fn(collection)
+
+
+def dims_to_tensor_perm(dims):
+    """
+    Given the dims of a Qobj instance, returns a list representing
+    a permutation from the flattening of that dims specification to
+    the corresponding tensor indices.
+
+    Parameters
+    ----------
+
+    dims : list
+        Dimensions specification for a Qobj.
+
+    Returns
+    -------
+
+    perm : list
+        A list such that ``data[flatten(dims)[idx]]`` gives the
+        index of the tensor ``data`` corresponding to the ``idx``th
+        dimension of ``dims``.
+    """
+    # We figure out the type of the dims specification,
+    # relaxing the requirement that operators be square.
+    # This means that dims_type need not coincide with
+    # Qobj.type, but that works fine for our purposes here.
+    dims_type = type_from_dims(dims, enforce_square=False)
+    perm = enumerate_flat(dims)
+    if dims_type in ('oper', 'ket', 'bra'):
+        return flatten(perm)
+
+    # If the type is other, we need to figure out if the
+    # dims is superlike on its outputs and inputs
+    # This is the case if the dims type for left or right
+    # are, respectively, oper-like.
+    if dims_type == 'other':
+        raise NotImplementedError("Not yet implemented for type='other'.")
+
+    # If we're still here, the story is more complicated. We'll
+    # follow the strategy of creating a permutation by using
+    # enumerate_flat then transforming the result to swap
+    # input and output indices of vectorized matrices, then flattening
+    # the result. We'll then rebuild indices using this permutation.
+    if dims_type in ('operator-ket', 'super'):
+        # Swap the input and output spaces of the right part of
+        # perm.
+        perm[1] = list(reversed(perm[1]))
+    if dims_type in ('operator-bra', 'super'):
+        # Ditto, but for the left indices.
+        perm[0] = list(reversed(perm[0]))
+    return flatten(perm)
+
+
+def dims_to_tensor_shape(dims):
+    """
+    Given the dims of a Qobj instance, returns the shape of the
+    corresponding tensor. This helps, for instance, resolve the
+    column-stacking convention for superoperators.
+
+    Parameters
+    ----------
+
+    dims : list
+        Dimensions specification for a Qobj.
+
+    Returns
+    -------
+
+    tensor_shape : tuple
+        NumPy shape of the corresponding tensor.
+    """
+    perm = dims_to_tensor_perm(dims)
+    dims = flatten(dims)
+    return tuple(map(partial(getitem, dims), perm))
+
+
+def dims_idxs_to_tensor_idxs(dims, indices):
+    """
+    Given the dims of a Qobj instance, and some indices into
+    dims, returns the corresponding tensor indices. This helps
+    resolve, for instance, that column-stacking for superoperators,
+    oper-ket and oper-bra implies that the input and output tensor
+    indices are reversed from their order in dims.
+
+    Parameters
+    ----------
+
+    dims : list
+        Dimensions specification for a Qobj.
+
+    indices : int, list or tuple
+        Indices to convert to tensor indices. Can be specified
+        as a single index, or as a collection of indices.
+        In the latter case, this can be nested arbitrarily
+        deep. For instance, [0, [0, (2, 3)]].
+
+    Returns
+    -------
+
+    tens_indices : int, list or tuple
+        Container of the same structure as indices containing
+        the tensor indices for each element of indices.
+    """
+    perm = dims_to_tensor_perm(dims)
+    return deep_map(partial(getitem, perm), indices)
diff --git a/qutip/core/expect.py b/qutip/core/expect.py
index 65888f8c7e..f290a25b90 100644
--- a/qutip/core/expect.py
+++ b/qutip/core/expect.py
@@ -1,97 +1,97 @@
-__all__ = ['expect', 'variance']
-
-import numpy as np
-
-from .qobj import Qobj
-from . import data as _data
-
-
-def expect(oper, state):
-    """
-    Calculate the expectation value for operator(s) and state(s).  The
-    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
-    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
-
-    Parameters
-    ----------
-    oper : qobj/array-like
-        A single or a `list` or operators for expectation value.
-
-    state : qobj/array-like
-        A single or a `list` of quantum states or density matrices.
-
-    Returns
-    -------
-    expt : float/complex/array-like
-        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
-        otherwise. A (nested) array of expectaction values of state or operator
-        are arrays.
-
-    Examples
-    --------
-    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
-        True
-
-    """
-    if isinstance(state, Qobj) and isinstance(oper, Qobj):
-        return _single_qobj_expect(oper, state)
-
-    elif isinstance(oper, (list, np.ndarray)):
-        if isinstance(state, Qobj):
-            dtype = np.complex128
-            if all(op.isherm for op in oper) and (state.isket or state.isherm):
-                dtype = np.float64
-            return np.array([_single_qobj_expect(op, state) for op in oper],
-                            dtype=dtype)
-        return [expect(op, state) for op in oper]
-
-    elif isinstance(state, (list, np.ndarray)):
-        dtype = np.complex128
-        if oper.isherm and all(op.isherm or op.isket for op in state):
-            dtype = np.float64
-        return np.array([_single_qobj_expect(oper, x) for x in state],
-                        dtype=dtype)
-    raise TypeError('Arguments must be quantum objects')
-
-
-def _single_qobj_expect(oper, state):
-    """
-    Private function used by expect to calculate expectation values of Qobjs.
-    """
-    if not oper.isoper or not (state.isket or state.isoper):
-        raise TypeError('invalid operand types')
-    if oper.dims[1] != state.dims[0]:
-        msg = (
-            "incompatible dimensions "
-            + str(oper.dims[1]) + " and " + str(state.dims[0])
-        )
-        raise ValueError(msg)
-    out = _data.expect(oper.data, state.data)
-
-    # This ensures that expect can return something that is not a number such
-    # as a `tensorflow.Tensor` in qutip-tensorflow.
-    return out.real if (oper.isherm
-                        and (state.isket or state.isherm)
-                        and hasattr(out, "real")
-                        ) else out
-
-
-def variance(oper, state):
-    """
-    Variance of an operator for the given state vector or density matrix.
-
-    Parameters
-    ----------
-    oper : qobj
-        Operator for expectation value.
-
-    state : qobj/list
-        A single or `list` of quantum states or density matrices..
-
-    Returns
-    -------
-    var : float
-        Variance of operator 'oper' for given state.
-
-    """
-    return expect(oper**2, state) - expect(oper, state)**2
+__all__ = ['expect', 'variance']
+
+import numpy as np
+
+from .qobj import Qobj
+from . import data as _data
+
+
+def expect(oper, state):
+    """
+    Calculate the expectation value for operator(s) and state(s).  The
+    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
+    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
+
+    Parameters
+    ----------
+    oper : qobj/array-like
+        A single or a `list` or operators for expectation value.
+
+    state : qobj/array-like
+        A single or a `list` of quantum states or density matrices.
+
+    Returns
+    -------
+    expt : float/complex/array-like
+        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
+        otherwise. A (nested) array of expectaction values of state or operator
+        are arrays.
+
+    Examples
+    --------
+    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
+        True
+
+    """
+    if isinstance(state, Qobj) and isinstance(oper, Qobj):
+        return _single_qobj_expect(oper, state)
+
+    elif isinstance(oper, (list, np.ndarray)):
+        if isinstance(state, Qobj):
+            dtype = np.complex128
+            if all(op.isherm for op in oper) and (state.isket or state.isherm):
+                dtype = np.float64
+            return np.array([_single_qobj_expect(op, state) for op in oper],
+                            dtype=dtype)
+        return [expect(op, state) for op in oper]
+
+    elif isinstance(state, (list, np.ndarray)):
+        dtype = np.complex128
+        if oper.isherm and all(op.isherm or op.isket for op in state):
+            dtype = np.float64
+        return np.array([_single_qobj_expect(oper, x) for x in state],
+                        dtype=dtype)
+    raise TypeError('Arguments must be quantum objects')
+
+
+def _single_qobj_expect(oper, state):
+    """
+    Private function used by expect to calculate expectation values of Qobjs.
+    """
+    if not oper.isoper or not (state.isket or state.isoper):
+        raise TypeError('invalid operand types')
+    if oper.dims[1] != state.dims[0]:
+        msg = (
+            "incompatible dimensions "
+            + str(oper.dims[1]) + " and " + str(state.dims[0])
+        )
+        raise ValueError(msg)
+    out = _data.expect(oper.data, state.data)
+
+    # This ensures that expect can return something that is not a number such
+    # as a `tensorflow.Tensor` in qutip-tensorflow.
+    return out.real if (oper.isherm
+                        and (state.isket or state.isherm)
+                        and hasattr(out, "real")
+                        ) else out
+
+
+def variance(oper, state):
+    """
+    Variance of an operator for the given state vector or density matrix.
+
+    Parameters
+    ----------
+    oper : qobj
+        Operator for expectation value.
+
+    state : qobj/list
+        A single or `list` of quantum states or density matrices..
+
+    Returns
+    -------
+    var : float
+        Variance of operator 'oper' for given state.
+
+    """
+    return expect(oper**2, state) - expect(oper, state)**2
diff --git a/qutip/core/gates.py b/qutip/core/gates.py
index 28726e292c..ae99fc4446 100644
--- a/qutip/core/gates.py
+++ b/qutip/core/gates.py
@@ -1,747 +1,747 @@
-from itertools import product
-from functools import partial, reduce
-from operator import mul
-
-import numpy as np
-import scipy.sparse as sp
-from . import Qobj, qeye, sigmax, fock_dm, qdiags
-
-
-__all__ = [
-    "rx",
-    "ry",
-    "rz",
-    "sqrtnot",
-    "snot",
-    "phasegate",
-    "qrot",
-    "cy_gate",
-    "cz_gate",
-    "s_gate",
-    "t_gate",
-    "cs_gate",
-    "ct_gate",
-    "cphase",
-    "cnot",
-    "csign",
-    "berkeley",
-    "swapalpha",
-    "swap",
-    "iswap",
-    "sqrtswap",
-    "sqrtiswap",
-    "fredkin",
-    "molmer_sorensen",
-    "toffoli",
-    "hadamard_transform",
-    "qubit_clifford_group",
-]
-
-
-def cy_gate(*, dtype="csr"):
-    """Controlled Y gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def cz_gate(*, dtype="csr"):
-    """Controlled Z gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-    """
-    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
-
-
-def s_gate(*, dtype="csr"):
-    """Single-qubit rotation also called Phase gate or the Z90 gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing
-        a 90 degree rotation around the z-axis.
-
-    """
-    return qdiags([1, 1j], dtype=dtype)
-
-
-def cs_gate(*, dtype="csr"):
-    """Controlled S gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-
-    """
-    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
-
-
-def t_gate(*, dtype="csr"):
-    """Single-qubit rotation related to the S gate by the relationship S=T*T.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing a phase shift of pi/4.
-
-    """
-    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
-
-
-def ct_gate(*, dtype="csr"):
-    """Controlled T gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-
-    """
-    return qdiags(
-        [1, 1, 1, np.exp(1j * np.pi / 4)],
-        dims=[[2, 2], [2, 2]],
-        dtype=dtype,
-    )
-
-
-def rx(phi, *, dtype="dense"):
-    """Single-qubit rotation for operator sigmax with angle phi.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the rotation.
-
-    """
-    return Qobj(
-        [
-            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
-            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
-        ]
-    ).to(dtype)
-
-
-def ry(phi, *, dtype="dense"):
-    """Single-qubit rotation for operator sigmay with angle phi.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the rotation.
-
-    """
-    return Qobj(
-        [
-            [np.cos(phi / 2), -np.sin(phi / 2)],
-            [np.sin(phi / 2), np.cos(phi / 2)],
-        ]
-    ).to(dtype)
-
-
-def rz(phi, *, dtype="csr"):
-    """Single-qubit rotation for operator sigmaz with angle phi.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the rotation.
-
-    """
-    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
-
-
-def sqrtnot(*, dtype="dense"):
-    """Single-qubit square root NOT gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the square root NOT gate.
-
-    """
-    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
-
-
-def snot(*, dtype="dense"):
-    """Quantum object representing the SNOT (Hadamard) gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    snot_gate : qobj
-        Quantum object representation of SNOT gate.
-
-    """
-    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
-
-
-def phasegate(theta, *, dtype="csr"):
-    """
-    Returns quantum object representing the phase shift gate.
-
-    Parameters
-    ----------
-    theta : float
-        Phase rotation angle.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    phase_gate : qobj
-        Quantum object representation of phase shift gate.
-
-    """
-    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
-
-
-def qrot(theta, phi, *, dtype="dense"):
-    """
-    Single qubit rotation driving by Rabi oscillation with 0 detune.
-
-    Parameters
-    ----------
-    phi : float
-        The inital phase of the rabi pulse.
-    theta : float
-        The duration of the rabi pulse.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    qrot_gate : :class:`qutip.Qobj`
-        Quantum object representation of physical qubit rotation under
-        a rabi pulse.
-    """
-    return Qobj(
-        [
-            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
-            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
-        ]
-    ).to(dtype)
-
-
-#
-# 2 Qubit Gates
-#
-
-
-def cphase(theta, *, dtype="csr"):
-    """
-    Returns quantum object representing the controlled phase shift gate.
-
-    Parameters
-    ----------
-    theta : float
-        Phase rotation angle.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    U : qobj
-        Quantum object representation of controlled phase gate.
-    """
-    return qdiags(
-        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
-    )
-
-
-def cnot(*, dtype="csr"):
-    """
-    Quantum object representing the CNOT gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    cnot_gate : qobj
-        Quantum object representation of CNOT gate
-
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def csign(*, dtype="csr"):
-    """
-    Quantum object representing the CSIGN gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    csign_gate : qobj
-        Quantum object representation of CSIGN gate
-
-    """
-    return cz_gate(dtype=dtype)
-
-
-def berkeley(*, dtype="dense"):
-    """
-    Quantum object representing the Berkeley gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    berkeley_gate : qobj
-        Quantum object representation of Berkeley gate
-
-    """
-    return Qobj(
-        [
-            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
-            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
-            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
-            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
-        ],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def swapalpha(alpha, *, dtype="csr"):
-    """
-    Quantum object representing the SWAPalpha gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    swapalpha_gate : qobj
-        Quantum object representation of SWAPalpha gate
-    """
-    phase = np.exp(1.0j * np.pi * alpha)
-    return Qobj(
-        [
-            [1, 0, 0, 0],
-            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
-            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
-            [0, 0, 0, 1],
-        ],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def swap(*, dtype="csr"):
-    """Quantum object representing the SWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    swap_gate : qobj
-        Quantum object representation of SWAP gate
-
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def iswap(*, dtype="csr"):
-    """Quantum object representing the iSWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    iswap_gate : qobj
-        Quantum object representation of iSWAP gate
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def sqrtswap(*, dtype="dense"):
-    """Quantum object representing the square root SWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    sqrtswap_gate : qobj
-        Quantum object representation of square root SWAP gate
-
-    """
-    return Qobj(
-        np.array(
-            [
-                [1, 0, 0, 0],
-                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
-                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
-                [0, 0, 0, 1],
-            ]
-        ),
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def sqrtiswap(*, dtype="dense"):
-    """Quantum object representing the square root iSWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    sqrtiswap_gate : qobj
-        Quantum object representation of square root iSWAP gate
-    """
-    return Qobj(
-        np.array(
-            [
-                [1, 0, 0, 0],
-                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
-                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
-                [0, 0, 0, 1],
-            ]
-        ),
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def molmer_sorensen(theta, *, dtype="dense"):
-    """
-    Quantum object of a Mølmer–Sørensen gate.
-
-    Parameters
-    ----------
-    theta: float
-        The duration of the interaction pulse.
-    N: int
-        Number of qubits in the system.
-    target: int
-        The indices of the target qubits.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    molmer_sorensen_gate: :class:`qutip.Qobj`
-        Quantum object representation of the Mølmer–Sørensen gate.
-    """
-    return Qobj(
-        [
-            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
-            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
-            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
-            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
-        ],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-#
-# 3 Qubit Gates
-#
-
-
-def fredkin(*, dtype="csr"):
-    """Quantum object representing the Fredkin gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    fredkin_gate : qobj
-        Quantum object representation of Fredkin gate.
-
-    """
-    return Qobj(
-        [
-            [1, 0, 0, 0, 0, 0, 0, 0],
-            [0, 1, 0, 0, 0, 0, 0, 0],
-            [0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 1, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0],
-            [0, 0, 0, 0, 0, 0, 1, 0],
-            [0, 0, 0, 0, 0, 1, 0, 0],
-            [0, 0, 0, 0, 0, 0, 0, 1],
-        ],
-        dims=[[2, 2, 2], [2, 2, 2]],
-    ).to(dtype)
-
-
-def toffoli(*, dtype="csr"):
-    """Quantum object representing the Toffoli gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    toff_gate : qobj
-        Quantum object representation of Toffoli gate.
-
-    """
-    return Qobj(
-        [
-            [1, 0, 0, 0, 0, 0, 0, 0],
-            [0, 1, 0, 0, 0, 0, 0, 0],
-            [0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 1, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0],
-            [0, 0, 0, 0, 0, 1, 0, 0],
-            [0, 0, 0, 0, 0, 0, 0, 1],
-            [0, 0, 0, 0, 0, 0, 1, 0],
-        ],
-        dims=[[2, 2, 2], [2, 2, 2]],
-    ).to(dtype)
-
-
-#
-# Miscellaneous Gates
-#
-
-
-def globalphase(theta, N=1, *, dtype="csr"):
-    """
-    Returns quantum object representing the global phase shift gate.
-
-    Parameters
-    ----------
-    theta : float
-        Phase rotation angle.
-
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    phase_gate : qobj
-        Quantum object representation of global phase shift gate.
-
-    """
-    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
-
-
-#
-# Operation on Gates
-#
-
-
-def _hamming_distance(x):
-    """
-    Calculate the bit-wise Hamming distance of x from 0: That is, the number
-    1s in the integer x.
-    """
-    tot = 0
-    while x:
-        tot += 1
-        x &= x - 1
-    return tot
-
-
-def hadamard_transform(N=1, *, dtype="dense"):
-    """Quantum object representing the N-qubit Hadamard gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    q : qobj
-        Quantum object representation of the N-qubit Hadamard gate.
-
-    """
-    data = 2 ** (-N / 2) * np.array(
-        [
-            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
-            for j in range(2**N)
-        ]
-    )
-
-    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
-
-
-def _powers(op, N):
-    """
-    Generator that yields powers of an operator `op`,
-    through to `N`.
-    """
-    acc = qeye(op.dims[0])
-    yield acc
-
-    for _ in range(N - 1):
-        acc *= op
-        yield acc
-
-
-def qubit_clifford_group(*, dtype="dense"):
-    """
-    Generates the Clifford group on a single qubit,
-    using the presentation of the group given by Ross and Selinger
-    (http://www.mathstat.dal.ca/~selinger/newsynth/).
-
-    Parameters
-    -----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Return
-    ------
-    op : list of Qobj
-        Clifford operators, represented as Qobj instances.
-
-    """
-
-    # The Ross-Selinger presentation of the single-qubit Clifford
-    # group expresses each element in the form C_{ijk} = E^i X^j S^k
-    # for gates E, X and S, and for i in range(3), j in range(2) and
-    # k in range(4).
-    #
-    # We start by defining these gates. E is defined in terms of H,
-    # \omega and S, so we define \omega and H first.
-    w = np.exp(1j * 2 * np.pi / 8)
-    H = snot()
-
-    X = sigmax()
-    S = phasegate(np.pi / 2)
-    E = H * (S**3) * w**3
-
-    # partial(reduce, mul) returns a function that takes products
-    # of its argument, by analogy to sum. Note that by analogy,
-    # sum can be written as partial(reduce, add).
-
-    # product(...) yields the Cartesian product of its arguments.
-    # Here, each element is a tuple (E**i, X**j, S**k) such that
-    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
-    return [
-        op.to(dtype)
-        for op in map(
-            partial(reduce, mul),
-            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
-        )
-    ]
+from itertools import product
+from functools import partial, reduce
+from operator import mul
+
+import numpy as np
+import scipy.sparse as sp
+from . import Qobj, qeye, sigmax, fock_dm, qdiags
+
+
+__all__ = [
+    "rx",
+    "ry",
+    "rz",
+    "sqrtnot",
+    "snot",
+    "phasegate",
+    "qrot",
+    "cy_gate",
+    "cz_gate",
+    "s_gate",
+    "t_gate",
+    "cs_gate",
+    "ct_gate",
+    "cphase",
+    "cnot",
+    "csign",
+    "berkeley",
+    "swapalpha",
+    "swap",
+    "iswap",
+    "sqrtswap",
+    "sqrtiswap",
+    "fredkin",
+    "molmer_sorensen",
+    "toffoli",
+    "hadamard_transform",
+    "qubit_clifford_group",
+]
+
+
+def cy_gate(*, dtype="csr"):
+    """Controlled Y gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def cz_gate(*, dtype="csr"):
+    """Controlled Z gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+    """
+    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
+
+
+def s_gate(*, dtype="csr"):
+    """Single-qubit rotation also called Phase gate or the Z90 gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing
+        a 90 degree rotation around the z-axis.
+
+    """
+    return qdiags([1, 1j], dtype=dtype)
+
+
+def cs_gate(*, dtype="csr"):
+    """Controlled S gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+
+    """
+    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
+
+
+def t_gate(*, dtype="csr"):
+    """Single-qubit rotation related to the S gate by the relationship S=T*T.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing a phase shift of pi/4.
+
+    """
+    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
+
+
+def ct_gate(*, dtype="csr"):
+    """Controlled T gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+
+    """
+    return qdiags(
+        [1, 1, 1, np.exp(1j * np.pi / 4)],
+        dims=[[2, 2], [2, 2]],
+        dtype=dtype,
+    )
+
+
+def rx(phi, *, dtype="dense"):
+    """Single-qubit rotation for operator sigmax with angle phi.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the rotation.
+
+    """
+    return Qobj(
+        [
+            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
+            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
+        ]
+    ).to(dtype)
+
+
+def ry(phi, *, dtype="dense"):
+    """Single-qubit rotation for operator sigmay with angle phi.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the rotation.
+
+    """
+    return Qobj(
+        [
+            [np.cos(phi / 2), -np.sin(phi / 2)],
+            [np.sin(phi / 2), np.cos(phi / 2)],
+        ]
+    ).to(dtype)
+
+
+def rz(phi, *, dtype="csr"):
+    """Single-qubit rotation for operator sigmaz with angle phi.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the rotation.
+
+    """
+    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
+
+
+def sqrtnot(*, dtype="dense"):
+    """Single-qubit square root NOT gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the square root NOT gate.
+
+    """
+    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
+
+
+def snot(*, dtype="dense"):
+    """Quantum object representing the SNOT (Hadamard) gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    snot_gate : qobj
+        Quantum object representation of SNOT gate.
+
+    """
+    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
+
+
+def phasegate(theta, *, dtype="csr"):
+    """
+    Returns quantum object representing the phase shift gate.
+
+    Parameters
+    ----------
+    theta : float
+        Phase rotation angle.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    phase_gate : qobj
+        Quantum object representation of phase shift gate.
+
+    """
+    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
+
+
+def qrot(theta, phi, *, dtype="dense"):
+    """
+    Single qubit rotation driving by Rabi oscillation with 0 detune.
+
+    Parameters
+    ----------
+    phi : float
+        The inital phase of the rabi pulse.
+    theta : float
+        The duration of the rabi pulse.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    qrot_gate : :class:`qutip.Qobj`
+        Quantum object representation of physical qubit rotation under
+        a rabi pulse.
+    """
+    return Qobj(
+        [
+            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
+            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
+        ]
+    ).to(dtype)
+
+
+#
+# 2 Qubit Gates
+#
+
+
+def cphase(theta, *, dtype="csr"):
+    """
+    Returns quantum object representing the controlled phase shift gate.
+
+    Parameters
+    ----------
+    theta : float
+        Phase rotation angle.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    U : qobj
+        Quantum object representation of controlled phase gate.
+    """
+    return qdiags(
+        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
+    )
+
+
+def cnot(*, dtype="csr"):
+    """
+    Quantum object representing the CNOT gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    cnot_gate : qobj
+        Quantum object representation of CNOT gate
+
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def csign(*, dtype="csr"):
+    """
+    Quantum object representing the CSIGN gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    csign_gate : qobj
+        Quantum object representation of CSIGN gate
+
+    """
+    return cz_gate(dtype=dtype)
+
+
+def berkeley(*, dtype="dense"):
+    """
+    Quantum object representing the Berkeley gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    berkeley_gate : qobj
+        Quantum object representation of Berkeley gate
+
+    """
+    return Qobj(
+        [
+            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
+            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
+            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
+            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
+        ],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def swapalpha(alpha, *, dtype="csr"):
+    """
+    Quantum object representing the SWAPalpha gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    swapalpha_gate : qobj
+        Quantum object representation of SWAPalpha gate
+    """
+    phase = np.exp(1.0j * np.pi * alpha)
+    return Qobj(
+        [
+            [1, 0, 0, 0],
+            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
+            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
+            [0, 0, 0, 1],
+        ],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def swap(*, dtype="csr"):
+    """Quantum object representing the SWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    swap_gate : qobj
+        Quantum object representation of SWAP gate
+
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def iswap(*, dtype="csr"):
+    """Quantum object representing the iSWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    iswap_gate : qobj
+        Quantum object representation of iSWAP gate
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def sqrtswap(*, dtype="dense"):
+    """Quantum object representing the square root SWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    sqrtswap_gate : qobj
+        Quantum object representation of square root SWAP gate
+
+    """
+    return Qobj(
+        np.array(
+            [
+                [1, 0, 0, 0],
+                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
+                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
+                [0, 0, 0, 1],
+            ]
+        ),
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def sqrtiswap(*, dtype="dense"):
+    """Quantum object representing the square root iSWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    sqrtiswap_gate : qobj
+        Quantum object representation of square root iSWAP gate
+    """
+    return Qobj(
+        np.array(
+            [
+                [1, 0, 0, 0],
+                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
+                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
+                [0, 0, 0, 1],
+            ]
+        ),
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def molmer_sorensen(theta, *, dtype="dense"):
+    """
+    Quantum object of a Mølmer–Sørensen gate.
+
+    Parameters
+    ----------
+    theta: float
+        The duration of the interaction pulse.
+    N: int
+        Number of qubits in the system.
+    target: int
+        The indices of the target qubits.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    molmer_sorensen_gate: :class:`qutip.Qobj`
+        Quantum object representation of the Mølmer–Sørensen gate.
+    """
+    return Qobj(
+        [
+            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
+            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
+            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
+            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
+        ],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+#
+# 3 Qubit Gates
+#
+
+
+def fredkin(*, dtype="csr"):
+    """Quantum object representing the Fredkin gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    fredkin_gate : qobj
+        Quantum object representation of Fredkin gate.
+
+    """
+    return Qobj(
+        [
+            [1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1],
+        ],
+        dims=[[2, 2, 2], [2, 2, 2]],
+    ).to(dtype)
+
+
+def toffoli(*, dtype="csr"):
+    """Quantum object representing the Toffoli gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    toff_gate : qobj
+        Quantum object representation of Toffoli gate.
+
+    """
+    return Qobj(
+        [
+            [1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+        ],
+        dims=[[2, 2, 2], [2, 2, 2]],
+    ).to(dtype)
+
+
+#
+# Miscellaneous Gates
+#
+
+
+def globalphase(theta, N=1, *, dtype="csr"):
+    """
+    Returns quantum object representing the global phase shift gate.
+
+    Parameters
+    ----------
+    theta : float
+        Phase rotation angle.
+
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    phase_gate : qobj
+        Quantum object representation of global phase shift gate.
+
+    """
+    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
+
+
+#
+# Operation on Gates
+#
+
+
+def _hamming_distance(x):
+    """
+    Calculate the bit-wise Hamming distance of x from 0: That is, the number
+    1s in the integer x.
+    """
+    tot = 0
+    while x:
+        tot += 1
+        x &= x - 1
+    return tot
+
+
+def hadamard_transform(N=1, *, dtype="dense"):
+    """Quantum object representing the N-qubit Hadamard gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    q : qobj
+        Quantum object representation of the N-qubit Hadamard gate.
+
+    """
+    data = 2 ** (-N / 2) * np.array(
+        [
+            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
+            for j in range(2**N)
+        ]
+    )
+
+    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
+
+
+def _powers(op, N):
+    """
+    Generator that yields powers of an operator `op`,
+    through to `N`.
+    """
+    acc = qeye(op.dims[0])
+    yield acc
+
+    for _ in range(N - 1):
+        acc *= op
+        yield acc
+
+
+def qubit_clifford_group(*, dtype="dense"):
+    """
+    Generates the Clifford group on a single qubit,
+    using the presentation of the group given by Ross and Selinger
+    (http://www.mathstat.dal.ca/~selinger/newsynth/).
+
+    Parameters
+    -----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Return
+    ------
+    op : list of Qobj
+        Clifford operators, represented as Qobj instances.
+
+    """
+
+    # The Ross-Selinger presentation of the single-qubit Clifford
+    # group expresses each element in the form C_{ijk} = E^i X^j S^k
+    # for gates E, X and S, and for i in range(3), j in range(2) and
+    # k in range(4).
+    #
+    # We start by defining these gates. E is defined in terms of H,
+    # \omega and S, so we define \omega and H first.
+    w = np.exp(1j * 2 * np.pi / 8)
+    H = snot()
+
+    X = sigmax()
+    S = phasegate(np.pi / 2)
+    E = H * (S**3) * w**3
+
+    # partial(reduce, mul) returns a function that takes products
+    # of its argument, by analogy to sum. Note that by analogy,
+    # sum can be written as partial(reduce, add).
+
+    # product(...) yields the Cartesian product of its arguments.
+    # Here, each element is a tuple (E**i, X**j, S**k) such that
+    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
+    return [
+        op.to(dtype)
+        for op in map(
+            partial(reduce, mul),
+            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
+        )
+    ]
diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
index 08c635326c..c87c13756b 100644
--- a/qutip/core/metrics.py
+++ b/qutip/core/metrics.py
@@ -1,590 +1,590 @@
-# -*- coding: utf-8 -*-
-
-"""
-This module contains a collection of functions for calculating metrics
-(distance measures) between states and operators.
-"""
-
-__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
-           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
-           'process_fidelity', 'unitarity', 'dnorm']
-
-import warnings
-
-import numpy as np
-from scipy import linalg as la
-import scipy.sparse as sp
-from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
-                           kraus_to_choi)
-from .superoperator import operator_to_vector, vector_to_operator
-from .operators import qeye
-from .states import ket2dm
-from .semidefinite import dnorm_problem, dnorm_sparse_problem
-from . import data as _data
-
-try:
-    import cvxpy
-except ImportError:
-    cvxpy = None
-
-
-def fidelity(A, B):
-    """
-    Calculates the fidelity (pseudo-metric) between two density matrices.
-    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    fid : float
-        Fidelity pseudo-metric between A and B.
-
-    Examples
-    --------
-    >>> x = fock_dm(5,3)
-    >>> y = coherent_dm(5,1)
-    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
-    """
-    if A.isket or A.isbra:
-        if B.isket or B.isbra:
-            # The fidelity for pure states reduces to the modulus of their
-            # inner product.
-            return np.abs(A.overlap(B))
-        # Take advantage of the fact that the density operator for A
-        # is a projector to avoid a sqrtm call.
-        sqrtmA = ket2dm(A)
-    else:
-        if B.isket or B.isbra:
-            # Swap the order so that we can take a more numerically
-            # stable square root of B.
-            return fidelity(B, A)
-        # If we made it here, both A and B are operators, so
-        # we have to take the sqrtm of one of them.
-        sqrtmA = A.sqrtm()
-
-    if sqrtmA.dims != B.dims:
-        raise TypeError('Density matrices do not have same dimensions.')
-
-    # We don't actually need the whole matrix here, just the trace
-    # of its square root, so let's just get its eigenenergies instead.
-    # We also truncate negative eigenvalues to avoid nan propagation;
-    # even for positive semidefinite matrices, small negative eigenvalues
-    # can be reported.
-    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
-    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
-
-
-def _hilbert_space_dims(oper):
-    """
-    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
-    of the output Hilbert space and the input Hilbert space.
-    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
-    - If oper is a list of Kraus operators, then
-     `oper[0].dims == [dims_out, dims_in]`.
-    - If oper is a superoperator with `oper.superrep == 'super'`:
-     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
-    - If oper is a superoperator with `oper.superrep == 'choi'`:
-     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
-    - If oper is a superoperator with `oper.superrep == 'chi', then
-      `dims_out == dims_in` and
-      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
-    :param oper: A quantum channel, represented by a unitary, a list of Kraus
-    operators, or a superoperator
-    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
-     of integers
-    """
-    if isinstance(oper, list):
-        return oper[0].dims
-    elif oper.type == 'oper':  # interpret as unitary quantum channel
-        return oper.dims
-    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
-        return [oper.dims[0][1], oper.dims[1][0]]
-    else:
-        raise TypeError('oper is not a valid quantum channel!')
-
-
-def _process_fidelity_to_id(oper):
-    """
-    Internal function returning the process fidelity of a quantum channel
-    to the identity quantum channel.
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-    Returns
-    -------
-    fid : float
-    """
-    dims_out, dims_in = _hilbert_space_dims(oper)
-    if dims_out != dims_in:
-        raise TypeError('The process fidelity to identity is only defined '
-                        'for dimension preserving channels.')
-    d = np.prod(dims_in)
-    if isinstance(oper, list):  # oper is a list of Kraus operators
-        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
-    elif oper.type == 'oper':  # interpret as unitary
-        return np.abs(oper.tr()) ** 2 / d ** 2
-    elif oper.type == 'super':
-        if oper.superrep == 'chi':
-            return oper[0, 0].real / d ** 2
-        else:  # oper.superrep is either 'super' or 'choi':
-            return to_super(oper).tr().real / d ** 2
-
-
-def _kraus_or_qobj_to_choi(oper):
-    if isinstance(oper, list):
-        return kraus_to_choi(oper)
-    else:
-        return to_choi(oper)
-
-
-def process_fidelity(oper, target=None):
-    """
-    Returns the process fidelity of a quantum channel to the target
-    channel, or to the identity channel if no target is given.
-    The process fidelity between two channels is defined as the state
-    fidelity between their normalized Choi matrices.
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-    target : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-
-    Returns
-    -------
-    fid : float
-        Process fidelity between oper and target, or between oper and identity.
-
-    Notes
-    -----
-    Since Qutip 5.0, this function computes the process fidelity as defined
-    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
-    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
-    that is now implemented in
-    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
-    The definition of state fidelity that the process fidelity is based on
-    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
-    It is the square of the one implemented in
-    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
-    "Quantum Computation and Quantum Information"
-
-    """
-    if target is None:
-        return _process_fidelity_to_id(oper)
-
-    dims_out, dims_in = _hilbert_space_dims(oper)
-    if dims_out != dims_in:
-        raise NotImplementedError('Process fidelity only implemented for '
-                                  'dimension-preserving operators.')
-    dims_out_target, dims_in_target = _hilbert_space_dims(target)
-    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
-        raise TypeError('Dimensions of oper and target do not match')
-
-    if not isinstance(target, list) and target.type == 'oper':
-        # interpret target as unitary.
-        if isinstance(oper, list):  # oper is a list of Kraus operators
-            return _process_fidelity_to_id([k * target.dag() for k in oper])
-        elif oper.type == 'oper':
-            return _process_fidelity_to_id(oper*target.dag())
-        elif oper.type == 'super':
-            oper_super = to_super(oper)
-            target_dag_super = to_super(target.dag())
-            return _process_fidelity_to_id(oper_super * target_dag_super)
-    else:  # target is a list of Kraus operators or a superoperator
-        if not isinstance(oper, list) and oper.type == 'oper':
-            return process_fidelity(target, oper)  # reverse order
-        oper_choi = _kraus_or_qobj_to_choi(oper)
-        target_choi = _kraus_or_qobj_to_choi(target)
-        d = np.prod(dims_in)
-        return (fidelity(oper_choi, target_choi)/d)**2
-
-
-def average_gate_fidelity(oper, target=None):
-    """
-    Returns the average gate fidelity of a quantum channel to the target
-    channel, or to the identity channel if no target is given.
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-    target : :class:`qutip.Qobj`
-        A unitary operator
-
-    Returns
-    -------
-    fid : float
-        Average gate fidelity between oper and target,
-        or between oper and identity.
-
-    Notes
-    -----
-    The average gate fidelity is defined for example in:
-    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
-    The definition of state fidelity that the average gate fidelity is based on
-    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
-    It is the square of the fidelity implemented in
-    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
-    "Quantum Computation and Quantum Information"
-
-    """
-    dims_out, dims_in = _hilbert_space_dims(oper)
-    if not (target is None or target.type == 'oper'):
-        raise TypeError(
-            'target must be None or a Qobj representing a unitary.')
-
-    d = np.prod(dims_in)
-    return (d * process_fidelity(oper, target) + 1) / (d + 1)
-
-
-def tracedist(A, B, sparse=False, tol=0):
-    """
-    Calculates the trace distance between two density matrices..
-    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
-
-    Parameters
-    ----------!=
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-    tol : float
-        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
-    sparse : {False, True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    tracedist : float
-        Trace distance between A and B.
-
-    Examples
-    --------
-    >>> x=fock_dm(5,3)
-    >>> y=coherent_dm(5,1)
-    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError("A and B do not have same dimensions.")
-    diff = A - B
-    diff = diff.dag() * diff
-    vals = diff.eigenenergies(sparse=sparse, tol=tol)
-    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
-
-
-def hilbert_dist(A, B):
-    """
-    Returns the Hilbert-Schmidt distance between two density matrices A & B.
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    dist : float
-        Hilbert-Schmidt distance between density matrices.
-
-    Notes
-    -----
-    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
-
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError('A and B do not have same dimensions.')
-    return ((A - B)**2).tr()
-
-
-def bures_dist(A, B):
-    """
-    Returns the Bures distance between two density matrices A & B.
-
-    The Bures distance ranges from 0, for states with unit fidelity,
-    to sqrt(2).
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    dist : float
-        Bures distance between density matrices.
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError('A and B do not have same dimensions.')
-    dist = np.sqrt(2 * (1 - fidelity(A, B)))
-    return dist
-
-
-def bures_angle(A, B):
-    """
-    Returns the Bures Angle between two density matrices A & B.
-
-    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    angle : float
-        Bures angle between density matrices.
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError('A and B do not have same dimensions.')
-    return np.arccos(fidelity(A, B))
-
-
-def hellinger_dist(A, B, sparse=False, tol=0):
-    """
-    Calculates the quantum Hellinger distance between two density matrices.
-
-    Formula:
-    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
-
-    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
-    measures of quantum correlations with Bures and Hellinger distances"
-    arXiv:1611.03449
-
-    Parameters
-    ----------
-    A : :class:`qutip.Qobj`
-        Density matrix or state vector.
-    B : :class:`qutip.Qobj`
-        Density matrix or state vector with same dimensions as A.
-    tol : float
-        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
-    sparse : {False, True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    hellinger_dist : float
-        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
-
-    Examples
-    --------
-    >>> x=fock_dm(5,3)
-    >>> y=coherent_dm(5,1)
-    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
-    """
-    if A.isket or A.isbra:
-        sqrtmA = ket2dm(A)
-    else:
-        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
-    if B.isket or B.isbra:
-        sqrtmB = ket2dm(B)
-    else:
-        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
-
-    if sqrtmA.dims != sqrtmB.dims:
-        raise TypeError("A and B do not have compatible dimensions.")
-
-    product = sqrtmA*sqrtmB
-    eigs = product.eigenenergies(sparse=sparse, tol=tol)
-    # np.maximum() is to avoid nan appearing sometimes due to numerical
-    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
-    # hellinger_dist(A, B) is called for A=B
-    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
-
-
-def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
-          sparse=True):
-    """
-    Calculates the diamond norm of the quantum map q_oper, using
-    the simplified semidefinite program of [Wat13]_.
-
-    The diamond norm SDP is solved by using CVXPY_.
-
-    Parameters
-    ----------
-    A : Qobj
-        Quantum map to take the diamond norm of.
-    B : Qobj or None
-        If provided, the diamond norm of :math:`A - B` is taken instead.
-    solver : str
-        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
-        latter tends to be significantly faster, but somewhat less accurate.
-    verbose : bool
-        If True, prints additional information about the solution.
-    force_solve : bool
-        If True, forces dnorm to solve the associated SDP, even if a special
-        case is known for the argument.
-    sparse : bool
-        Whether to use sparse matrices in the convex optimisation problem.
-        Default True.
-
-    Returns
-    -------
-    dn : float
-        Diamond norm of q_oper.
-
-    Raises
-    ------
-    ImportError
-        If CVXPY cannot be imported.
-
-    .. _cvxpy: https://www.cvxpy.org/en/latest/
-    """
-    if cvxpy is None:  # pragma: no cover
-        raise ImportError("dnorm() requires CVXPY to be installed.")
-
-    # We follow the strategy of using Watrous' simpler semidefinite
-    # program in its primal form. This is the same strategy used,
-    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
-    # QETLAB uses the dual problem.)
-
-    # Check if A and B are both unitaries. If so, then we can without
-    # loss of generality choose B to be the identity by using the
-    # unitary invariance of the diamond norm,
-    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
-    # Then, using the technique mentioned by each of Johnston and
-    # da Silva,
-    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
-    # where \lambda_i(U) is the ith eigenvalue of U.
-
-    # There's a lot of conditions to check for this path.  Only check if they
-    # aren't superoperators.  The difference of unitaries optimization is
-    # currently only implemented for d == 2. Much of the code below is more
-    # general, though, in anticipation of generalizing the optimization.
-    if (
-        not force_solve
-        and B is not None
-        and A.isoper and B.isoper
-        and A.shape[0] == 2
-    ):
-        # Make an identity the same size as A and B to
-        # compare against.
-        I = qeye(A.dims[0])
-        # Compare to B first, so that an error is raised
-        # as soon as possible.
-        Bd = B.dag()
-        if (
-            (B * Bd - I).norm() < 1e-6 and
-            (A * A.dag() - I).norm() < 1e-6
-        ):
-            # Now we are on the fast path, so let's compute the
-            # eigenvalues, then find the diameter of the smallest circle
-            # containing all of them.
-            #
-            # For now, this is only implemented for dim = 2, such that
-            # generalizing here will allow for generalizing the optimization.
-            # A reasonable approach would probably be to use Welzl's algorithm
-            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
-            U = A * B.dag()
-            eigs = U.eigenenergies()
-            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
-            return np.max(eig_distances)
-
-    # Force the input superoperator to be a Choi matrix.
-    J = to_choi(A)
-
-    if B is not None:
-        J -= to_choi(B)
-
-    # Watrous 2012 also points out that the diamond norm of Lambda
-    # is the same as the completely-bounded operator-norm (∞-norm)
-    # of the dual map of Lambda. We can evaluate that norm much more
-    # easily if Lambda is completely positive, since then the largest
-    # eigenvalue is the same as the largest singular value.
-
-    if not force_solve and J.iscp:
-        S_dual = to_super(J.dual_chan())
-        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
-        op = vector_to_operator(S_dual * vec_eye)
-        # The 2-norm was not implemented for sparse matrices as of the time
-        # of this writing. Thus, we must yet again go dense.
-        return la.norm(op.full(), 2)
-
-    # If we're still here, we need to actually solve the problem.
-
-    # Assume square...
-    dim = np.prod(J.dims[0][0])
-
-    # The constraints only depend on the dimension, so
-    # we can cache them efficiently.
-    problem, Jr, Ji, *_ = dnorm_problem(dim)
-
-    # Load the parameters with the Choi matrix passed in.
-    J_dat = _data.to('csr', J.data).as_scipy()
-
-    if not sparse:
-        # The parameters and constraints only depend on the dimension, so
-        # we can cache them efficiently.
-        problem, Jr, Ji = dnorm_problem(dim)
-
-        # Load the parameters with the Choi matrix passed in.
-        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
-                                  J_dat.indptr),
-                                 shape=J_dat.shape).toarray()
-
-        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
-                                  J_dat.indptr),
-                                 shape=J_dat.shape).toarray()
-    else:
-
-        # The parameters do not depend solely on the dimension,
-        # so we can not cache them efficiently.
-        problem = dnorm_sparse_problem(dim, J_dat)
-
-    problem.solve(solver=solver, verbose=verbose)
-
-    return problem.value
-
-
-def unitarity(oper):
-    """
-    Returns the unitarity of a quantum map, defined as the Frobenius norm
-    of the unital block of that map's superoperator representation.
-
-    Parameters
-    ----------
-    oper : Qobj
-        Quantum map under consideration.
-
-    Returns
-    -------
-    u : float
-        Unitarity of ``oper``.
-    """
-    Eu = _to_superpauli(oper).full()[1:, 1:]
-    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
+# -*- coding: utf-8 -*-
+
+"""
+This module contains a collection of functions for calculating metrics
+(distance measures) between states and operators.
+"""
+
+__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
+           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
+           'process_fidelity', 'unitarity', 'dnorm']
+
+import warnings
+
+import numpy as np
+from scipy import linalg as la
+import scipy.sparse as sp
+from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
+                           kraus_to_choi)
+from .superoperator import operator_to_vector, vector_to_operator
+from .operators import qeye
+from .states import ket2dm
+from .semidefinite import dnorm_problem, dnorm_sparse_problem
+from . import data as _data
+
+try:
+    import cvxpy
+except ImportError:
+    cvxpy = None
+
+
+def fidelity(A, B):
+    """
+    Calculates the fidelity (pseudo-metric) between two density matrices.
+    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    fid : float
+        Fidelity pseudo-metric between A and B.
+
+    Examples
+    --------
+    >>> x = fock_dm(5,3)
+    >>> y = coherent_dm(5,1)
+    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
+    """
+    if A.isket or A.isbra:
+        if B.isket or B.isbra:
+            # The fidelity for pure states reduces to the modulus of their
+            # inner product.
+            return np.abs(A.overlap(B))
+        # Take advantage of the fact that the density operator for A
+        # is a projector to avoid a sqrtm call.
+        sqrtmA = ket2dm(A)
+    else:
+        if B.isket or B.isbra:
+            # Swap the order so that we can take a more numerically
+            # stable square root of B.
+            return fidelity(B, A)
+        # If we made it here, both A and B are operators, so
+        # we have to take the sqrtm of one of them.
+        sqrtmA = A.sqrtm()
+
+    if sqrtmA.dims != B.dims:
+        raise TypeError('Density matrices do not have same dimensions.')
+
+    # We don't actually need the whole matrix here, just the trace
+    # of its square root, so let's just get its eigenenergies instead.
+    # We also truncate negative eigenvalues to avoid nan propagation;
+    # even for positive semidefinite matrices, small negative eigenvalues
+    # can be reported.
+    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
+    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
+
+
+def _hilbert_space_dims(oper):
+    """
+    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
+    of the output Hilbert space and the input Hilbert space.
+    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
+    - If oper is a list of Kraus operators, then
+     `oper[0].dims == [dims_out, dims_in]`.
+    - If oper is a superoperator with `oper.superrep == 'super'`:
+     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
+    - If oper is a superoperator with `oper.superrep == 'choi'`:
+     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
+    - If oper is a superoperator with `oper.superrep == 'chi', then
+      `dims_out == dims_in` and
+      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
+    :param oper: A quantum channel, represented by a unitary, a list of Kraus
+    operators, or a superoperator
+    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
+     of integers
+    """
+    if isinstance(oper, list):
+        return oper[0].dims
+    elif oper.type == 'oper':  # interpret as unitary quantum channel
+        return oper.dims
+    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
+        return [oper.dims[0][1], oper.dims[1][0]]
+    else:
+        raise TypeError('oper is not a valid quantum channel!')
+
+
+def _process_fidelity_to_id(oper):
+    """
+    Internal function returning the process fidelity of a quantum channel
+    to the identity quantum channel.
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+    Returns
+    -------
+    fid : float
+    """
+    dims_out, dims_in = _hilbert_space_dims(oper)
+    if dims_out != dims_in:
+        raise TypeError('The process fidelity to identity is only defined '
+                        'for dimension preserving channels.')
+    d = np.prod(dims_in)
+    if isinstance(oper, list):  # oper is a list of Kraus operators
+        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
+    elif oper.type == 'oper':  # interpret as unitary
+        return np.abs(oper.tr()) ** 2 / d ** 2
+    elif oper.type == 'super':
+        if oper.superrep == 'chi':
+            return oper[0, 0].real / d ** 2
+        else:  # oper.superrep is either 'super' or 'choi':
+            return to_super(oper).tr().real / d ** 2
+
+
+def _kraus_or_qobj_to_choi(oper):
+    if isinstance(oper, list):
+        return kraus_to_choi(oper)
+    else:
+        return to_choi(oper)
+
+
+def process_fidelity(oper, target=None):
+    """
+    Returns the process fidelity of a quantum channel to the target
+    channel, or to the identity channel if no target is given.
+    The process fidelity between two channels is defined as the state
+    fidelity between their normalized Choi matrices.
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+    target : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+
+    Returns
+    -------
+    fid : float
+        Process fidelity between oper and target, or between oper and identity.
+
+    Notes
+    -----
+    Since Qutip 5.0, this function computes the process fidelity as defined
+    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
+    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
+    that is now implemented in
+    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
+    The definition of state fidelity that the process fidelity is based on
+    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
+    It is the square of the one implemented in
+    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
+    "Quantum Computation and Quantum Information"
+
+    """
+    if target is None:
+        return _process_fidelity_to_id(oper)
+
+    dims_out, dims_in = _hilbert_space_dims(oper)
+    if dims_out != dims_in:
+        raise NotImplementedError('Process fidelity only implemented for '
+                                  'dimension-preserving operators.')
+    dims_out_target, dims_in_target = _hilbert_space_dims(target)
+    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
+        raise TypeError('Dimensions of oper and target do not match')
+
+    if not isinstance(target, list) and target.type == 'oper':
+        # interpret target as unitary.
+        if isinstance(oper, list):  # oper is a list of Kraus operators
+            return _process_fidelity_to_id([k * target.dag() for k in oper])
+        elif oper.type == 'oper':
+            return _process_fidelity_to_id(oper*target.dag())
+        elif oper.type == 'super':
+            oper_super = to_super(oper)
+            target_dag_super = to_super(target.dag())
+            return _process_fidelity_to_id(oper_super * target_dag_super)
+    else:  # target is a list of Kraus operators or a superoperator
+        if not isinstance(oper, list) and oper.type == 'oper':
+            return process_fidelity(target, oper)  # reverse order
+        oper_choi = _kraus_or_qobj_to_choi(oper)
+        target_choi = _kraus_or_qobj_to_choi(target)
+        d = np.prod(dims_in)
+        return (fidelity(oper_choi, target_choi)/d)**2
+
+
+def average_gate_fidelity(oper, target=None):
+    """
+    Returns the average gate fidelity of a quantum channel to the target
+    channel, or to the identity channel if no target is given.
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+    target : :class:`qutip.Qobj`
+        A unitary operator
+
+    Returns
+    -------
+    fid : float
+        Average gate fidelity between oper and target,
+        or between oper and identity.
+
+    Notes
+    -----
+    The average gate fidelity is defined for example in:
+    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
+    The definition of state fidelity that the average gate fidelity is based on
+    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
+    It is the square of the fidelity implemented in
+    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
+    "Quantum Computation and Quantum Information"
+
+    """
+    dims_out, dims_in = _hilbert_space_dims(oper)
+    if not (target is None or target.type == 'oper'):
+        raise TypeError(
+            'target must be None or a Qobj representing a unitary.')
+
+    d = np.prod(dims_in)
+    return (d * process_fidelity(oper, target) + 1) / (d + 1)
+
+
+def tracedist(A, B, sparse=False, tol=0):
+    """
+    Calculates the trace distance between two density matrices..
+    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
+
+    Parameters
+    ----------!=
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+    tol : float
+        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
+    sparse : {False, True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    tracedist : float
+        Trace distance between A and B.
+
+    Examples
+    --------
+    >>> x=fock_dm(5,3)
+    >>> y=coherent_dm(5,1)
+    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError("A and B do not have same dimensions.")
+    diff = A - B
+    diff = diff.dag() * diff
+    vals = diff.eigenenergies(sparse=sparse, tol=tol)
+    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
+
+
+def hilbert_dist(A, B):
+    """
+    Returns the Hilbert-Schmidt distance between two density matrices A & B.
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    dist : float
+        Hilbert-Schmidt distance between density matrices.
+
+    Notes
+    -----
+    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
+
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError('A and B do not have same dimensions.')
+    return ((A - B)**2).tr()
+
+
+def bures_dist(A, B):
+    """
+    Returns the Bures distance between two density matrices A & B.
+
+    The Bures distance ranges from 0, for states with unit fidelity,
+    to sqrt(2).
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    dist : float
+        Bures distance between density matrices.
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError('A and B do not have same dimensions.')
+    dist = np.sqrt(2 * (1 - fidelity(A, B)))
+    return dist
+
+
+def bures_angle(A, B):
+    """
+    Returns the Bures Angle between two density matrices A & B.
+
+    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    angle : float
+        Bures angle between density matrices.
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError('A and B do not have same dimensions.')
+    return np.arccos(fidelity(A, B))
+
+
+def hellinger_dist(A, B, sparse=False, tol=0):
+    """
+    Calculates the quantum Hellinger distance between two density matrices.
+
+    Formula:
+    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
+
+    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
+    measures of quantum correlations with Bures and Hellinger distances"
+    arXiv:1611.03449
+
+    Parameters
+    ----------
+    A : :class:`qutip.Qobj`
+        Density matrix or state vector.
+    B : :class:`qutip.Qobj`
+        Density matrix or state vector with same dimensions as A.
+    tol : float
+        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
+    sparse : {False, True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    hellinger_dist : float
+        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
+
+    Examples
+    --------
+    >>> x=fock_dm(5,3)
+    >>> y=coherent_dm(5,1)
+    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
+    """
+    if A.isket or A.isbra:
+        sqrtmA = ket2dm(A)
+    else:
+        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
+    if B.isket or B.isbra:
+        sqrtmB = ket2dm(B)
+    else:
+        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
+
+    if sqrtmA.dims != sqrtmB.dims:
+        raise TypeError("A and B do not have compatible dimensions.")
+
+    product = sqrtmA*sqrtmB
+    eigs = product.eigenenergies(sparse=sparse, tol=tol)
+    # np.maximum() is to avoid nan appearing sometimes due to numerical
+    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
+    # hellinger_dist(A, B) is called for A=B
+    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
+
+
+def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
+          sparse=True):
+    """
+    Calculates the diamond norm of the quantum map q_oper, using
+    the simplified semidefinite program of [Wat13]_.
+
+    The diamond norm SDP is solved by using CVXPY_.
+
+    Parameters
+    ----------
+    A : Qobj
+        Quantum map to take the diamond norm of.
+    B : Qobj or None
+        If provided, the diamond norm of :math:`A - B` is taken instead.
+    solver : str
+        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
+        latter tends to be significantly faster, but somewhat less accurate.
+    verbose : bool
+        If True, prints additional information about the solution.
+    force_solve : bool
+        If True, forces dnorm to solve the associated SDP, even if a special
+        case is known for the argument.
+    sparse : bool
+        Whether to use sparse matrices in the convex optimisation problem.
+        Default True.
+
+    Returns
+    -------
+    dn : float
+        Diamond norm of q_oper.
+
+    Raises
+    ------
+    ImportError
+        If CVXPY cannot be imported.
+
+    .. _cvxpy: https://www.cvxpy.org/en/latest/
+    """
+    if cvxpy is None:  # pragma: no cover
+        raise ImportError("dnorm() requires CVXPY to be installed.")
+
+    # We follow the strategy of using Watrous' simpler semidefinite
+    # program in its primal form. This is the same strategy used,
+    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
+    # QETLAB uses the dual problem.)
+
+    # Check if A and B are both unitaries. If so, then we can without
+    # loss of generality choose B to be the identity by using the
+    # unitary invariance of the diamond norm,
+    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
+    # Then, using the technique mentioned by each of Johnston and
+    # da Silva,
+    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
+    # where \lambda_i(U) is the ith eigenvalue of U.
+
+    # There's a lot of conditions to check for this path.  Only check if they
+    # aren't superoperators.  The difference of unitaries optimization is
+    # currently only implemented for d == 2. Much of the code below is more
+    # general, though, in anticipation of generalizing the optimization.
+    if (
+        not force_solve
+        and B is not None
+        and A.isoper and B.isoper
+        and A.shape[0] == 2
+    ):
+        # Make an identity the same size as A and B to
+        # compare against.
+        I = qeye(A.dims[0])
+        # Compare to B first, so that an error is raised
+        # as soon as possible.
+        Bd = B.dag()
+        if (
+            (B * Bd - I).norm() < 1e-6 and
+            (A * A.dag() - I).norm() < 1e-6
+        ):
+            # Now we are on the fast path, so let's compute the
+            # eigenvalues, then find the diameter of the smallest circle
+            # containing all of them.
+            #
+            # For now, this is only implemented for dim = 2, such that
+            # generalizing here will allow for generalizing the optimization.
+            # A reasonable approach would probably be to use Welzl's algorithm
+            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
+            U = A * B.dag()
+            eigs = U.eigenenergies()
+            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
+            return np.max(eig_distances)
+
+    # Force the input superoperator to be a Choi matrix.
+    J = to_choi(A)
+
+    if B is not None:
+        J -= to_choi(B)
+
+    # Watrous 2012 also points out that the diamond norm of Lambda
+    # is the same as the completely-bounded operator-norm (∞-norm)
+    # of the dual map of Lambda. We can evaluate that norm much more
+    # easily if Lambda is completely positive, since then the largest
+    # eigenvalue is the same as the largest singular value.
+
+    if not force_solve and J.iscp:
+        S_dual = to_super(J.dual_chan())
+        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
+        op = vector_to_operator(S_dual * vec_eye)
+        # The 2-norm was not implemented for sparse matrices as of the time
+        # of this writing. Thus, we must yet again go dense.
+        return la.norm(op.full(), 2)
+
+    # If we're still here, we need to actually solve the problem.
+
+    # Assume square...
+    dim = np.prod(J.dims[0][0])
+
+    # The constraints only depend on the dimension, so
+    # we can cache them efficiently.
+    problem, Jr, Ji, *_ = dnorm_problem(dim)
+
+    # Load the parameters with the Choi matrix passed in.
+    J_dat = _data.to('csr', J.data).as_scipy()
+
+    if not sparse:
+        # The parameters and constraints only depend on the dimension, so
+        # we can cache them efficiently.
+        problem, Jr, Ji = dnorm_problem(dim)
+
+        # Load the parameters with the Choi matrix passed in.
+        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
+                                  J_dat.indptr),
+                                 shape=J_dat.shape).toarray()
+
+        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
+                                  J_dat.indptr),
+                                 shape=J_dat.shape).toarray()
+    else:
+
+        # The parameters do not depend solely on the dimension,
+        # so we can not cache them efficiently.
+        problem = dnorm_sparse_problem(dim, J_dat)
+
+    problem.solve(solver=solver, verbose=verbose)
+
+    return problem.value
+
+
+def unitarity(oper):
+    """
+    Returns the unitarity of a quantum map, defined as the Frobenius norm
+    of the unital block of that map's superoperator representation.
+
+    Parameters
+    ----------
+    oper : Qobj
+        Quantum map under consideration.
+
+    Returns
+    -------
+    u : float
+        Unitarity of ``oper``.
+    """
+    Eu = _to_superpauli(oper).full()[1:, 1:]
+    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index f2921882a9..f3de7e2223 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -1,1073 +1,1073 @@
-"""
-This module contains functions for generating Qobj representation of a variety
-of commonly occuring quantum operators.
-"""
-
-__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
-           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
-           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
-           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
-           'enr_identity', 'charge', 'tunneling', 'qft']
-
-import numbers
-
-import numpy as np
-import scipy.sparse
-
-from . import data as _data
-from .qobj import Qobj
-from .dimensions import flatten
-from .. import settings
-
-
-def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
-           dtype=None):
-    """
-    Constructs an operator from an array of diagonals.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like
-        Array of elements to place along the selected diagonals.
-
-    offsets : sequence of ints, optional
-        Sequence for diagonals to be set:
-            - k=0 main diagonal
-            - k>0 kth upper diagonal
-            - k<0 kth lower diagonal
-
-    dims : list, optional
-        Dimensions for operator
-
-    shape : list, tuple, optional
-        Shape of operator.  If omitted, a square operator large enough
-        to contain the diagonals is generated.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Examples
-    --------
-    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
-    Quantum object: dims = [[4], [4]], \
-shape = [4, 4], type = oper, isherm = False
-    Qobj data =
-    [[ 0.          1.          0.          0.        ]
-     [ 0.          0.          1.41421356  0.        ]
-     [ 0.          0.          0.          1.73205081]
-     [ 0.          0.          0.          0.        ]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    offsets = [0] if offsets is None else offsets
-    data = _data.diag[dtype](diagonals, offsets, shape)
-    return Qobj(data, dims=dims, type='oper', copy=False)
-
-
-def jmat(j, which=None, *, dtype=None):
-    """Higher-order spin operators:
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    which : str
-        Which operator to return 'x','y','z','+','-'.
-        If no args given, then output is ['x','y','z']
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    jmat : Qobj or tuple of Qobj
-        ``qobj`` for requested spin operator(s).
-
-
-    Examples
-    --------
-    >>> jmat(1) # doctest: +SKIP
-    [ Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.          0.70710678  0.        ]
-     [ 0.70710678  0.          0.70710678]
-     [ 0.          0.70710678  0.        ]]
-     Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
-     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
-     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
-     Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 1.  0.  0.]
-     [ 0.  0.  0.]
-     [ 0.  0. -1.]]]
-
-    Notes
-    -----
-    If no 'args' input, then returns array of ['x','y','z'] operators.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if int(2 * j) != 2 * j or j < 0:
-        raise ValueError('j must be a non-negative integer or half-integer')
-
-    if not which:
-        return (
-            jmat(j, 'x', dtype=dtype),
-            jmat(j, 'y', dtype=dtype),
-            jmat(j, 'z', dtype=dtype)
-        )
-
-    dims = [[int(2*j + 1)]]*2
-    if which == '+':
-        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
-                    isherm=False, isunitary=False, copy=False)
-    if which == '-':
-        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
-                    isherm=False, isunitary=False, copy=False)
-    if which == 'x':
-        A =  _jplus(j, dtype=dtype)
-        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
-                    isherm=True, isunitary=False, copy=False) * 0.5
-    if which == 'y':
-        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
-        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
-                    isherm=True, isunitary=False, copy=False)
-    if which == 'z':
-        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
-                    isherm=True, isunitary=False, copy=False)
-    raise ValueError('Invalid spin operator: ' + which)
-
-
-def _jplus(j, *, dtype=None):
-    """
-    Internal functions for generating the data representing the J-plus
-    operator.
-    """
-    m = np.arange(j, -j - 1, -1, dtype=complex)
-    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
-    return _data.diag[dtype](data, 1)
-
-
-def _jz(j, *, dtype=None):
-    """
-    Internal functions for generating the data representing the J-z operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    N = int(2*j + 1)
-    data = np.array([j-k for k in range(N)], dtype=complex)
-    return _data.diag[dtype](data, 0)
-
-
-#
-# Spin j operators:
-#
-def spin_Jx(j, *, dtype=None):
-    """Spin-j x operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, 'x', dtype=dtype)
-
-
-def spin_Jy(j, *, dtype=None):
-    """Spin-j y operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, 'y', dtype=dtype)
-
-
-def spin_Jz(j, *, dtype=None):
-    """Spin-j z operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, 'z', dtype=dtype)
-
-
-def spin_Jm(j, *, dtype=None):
-    """Spin-j annihilation operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, '-', dtype=dtype)
-
-
-def spin_Jp(j, *, dtype=None):
-    """Spin-j creation operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, '+', dtype=dtype)
-
-
-def spin_J_set(j, *, dtype=None):
-    """Set of spin-j operators (x, y, z)
-
-    Parameters
-    ----------
-    j : float
-        Spin of operators
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    list : list of Qobj
-        list of ``qobj`` representating of the spin operator.
-
-    """
-    return jmat(j, dtype=dtype)
-
-
-# Pauli spin-1/2 operators.
-#
-# These are so common in quantum information that we want them to be
-# near-instantaneous to initialise, so we cache them at package import, and
-# just return copies when someone requests one.
-_SIGMAP = jmat(0.5, '+')
-_SIGMAM = jmat(0.5, '-')
-_SIGMAX = 2 * jmat(0.5, 'x')
-_SIGMAY = 2 * jmat(0.5, 'y')
-_SIGMAZ = 2 * jmat(0.5, 'z')
-
-
-def sigmap():
-    """Creation operator for Pauli spins.
-
-    Examples
-    --------
-    >>> sigmap() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.  1.]
-     [ 0.  0.]]
-
-    """
-    return _SIGMAP.copy()
-
-
-def sigmam():
-    """Annihilation operator for Pauli spins.
-
-    Examples
-    --------
-    >>> sigmam() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.  0.]
-     [ 1.  0.]]
-
-    """
-    return _SIGMAM.copy()
-
-
-def sigmax():
-    """Pauli spin 1/2 sigma-x operator
-
-    Examples
-    --------
-    >>> sigmax() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.  1.]
-     [ 1.  0.]]
-
-    """
-    return _SIGMAX.copy()
-
-
-def sigmay():
-    """Pauli spin 1/2 sigma-y operator.
-
-    Examples
-    --------
-    >>> sigmay() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j  0.-1.j]
-     [ 0.+1.j  0.+0.j]]
-
-    """
-    return _SIGMAY.copy()
-
-
-def sigmaz():
-    """Pauli spin 1/2 sigma-z operator.
-
-    Examples
-    --------
-    >>> sigmaz() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = True
-    Qobj data =
-    [[ 1.  0.]
-     [ 0. -1.]]
-
-    """
-    return _SIGMAZ.copy()
-
-
-def destroy(N, offset=0, *, dtype=None):
-    """
-    Destruction (lowering) operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Qobj for lowering operator.
-
-    Examples
-    --------
-    >>> destroy(4) # doctest: +SKIP
-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
-    Qobj data =
-    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
-        raise ValueError("Hilbert space dimension must be integer value")
-    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
-    return qdiags(data, 1, dtype=dtype)
-
-
-def create(N, offset=0, *, dtype=None):
-    """
-    Creation (raising) operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Qobj for raising operator.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    Examples
-    --------
-    >>> create(4) # doctest: +SKIP
-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
-    Qobj data =
-    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
-        raise ValueError("Hilbert space dimension must be integer value")
-    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
-    return qdiags(data, -1, dtype=dtype)
-
-
-def _implicit_tensor_dimensions(dimensions):
-    """
-    Total flattened size and operator dimensions for operator creation routines
-    that automatically perform tensor products.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        First dimension of an operator which can create an implicit tensor
-        product.  If the type is `int`, it is promoted first to `[dimensions]`.
-        From there, it should be one of the two-elements `dims` parameter of a
-        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
-        products.
-
-    Returns
-    -------
-    size : int
-        Dimension of backing matrix required to represent operator.
-    dimensions : list
-        Dimension list in the form required by ``Qobj`` creation.
-    """
-    if not isinstance(dimensions, list):
-        dimensions = [dimensions]
-    flat = flatten(dimensions)
-    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
-        raise ValueError("All dimensions must be integers >= 0")
-    return np.prod(flat), [dimensions, dimensions]
-
-
-def qzero(dimensions, *, dtype=None):
-    """
-    Zero operator.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    qzero : qobj
-        Zero operator Qobj.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    size, dimensions = _implicit_tensor_dimensions(dimensions)
-    # A sparse matrix with no data is equal to a zero matrix.
-    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
-    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
-                isherm=True, isunitary=False, copy=False)
-
-
-def qeye(dimensions, *, dtype=None):
-    """
-    Identity operator.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Identity operator Qobj.
-
-    Examples
-    --------
-    >>> qeye(3) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
-isherm = True
-    Qobj data =
-    [[ 1.  0.  0.]
-     [ 0.  1.  0.]
-     [ 0.  0.  1.]]
-    >>> qeye([2,2]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
-isherm = True
-    Qobj data =
-    [[1. 0. 0. 0.]
-     [0. 1. 0. 0.]
-     [0. 0. 1. 0.]
-     [0. 0. 0. 1.]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    size, dimensions = _implicit_tensor_dimensions(dimensions)
-    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
-    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
-                isherm=True, isunitary=True, copy=False)
-
-
-# Name alias.
-identity = qeye
-
-
-def position(N, offset=0, *, dtype=None):
-    """
-    Position operator x=1/sqrt(2)*(a+a.dag())
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Position operator as Qobj.
-    """
-    a = destroy(N, offset=offset, dtype=dtype)
-    position = np.sqrt(0.5) * (a + a.dag())
-    position.isherm = True
-    return position
-
-
-def momentum(N, offset=0, *, dtype=None):
-    """
-    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Momentum operator as Qobj.
-    """
-    a = destroy(N, offset=offset, dtype=dtype)
-    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
-    momentum.isherm = True
-    return momentum
-
-
-def num(N, offset=0, *, dtype=None):
-    """
-    Quantum object for number operator.
-
-    Parameters
-    ----------
-    N : int
-        The dimension of the Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper: qobj
-        Qobj for number operator.
-
-    Examples
-    --------
-    >>> num(4) # doctest: +SKIP
-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
-    Qobj data =
-    [[0 0 0 0]
-     [0 1 0 0]
-     [0 0 2 0]
-     [0 0 0 3]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    data = np.arange(offset, offset + N, dtype=complex)
-    return qdiags(data, 0, dtype=dtype)
-
-
-def squeeze(N, z, offset=0, *, dtype=None):
-    """Single-mode squeezing operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of hilbert space.
-
-    z : float/complex
-        Squeezing parameter.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : :class:`qutip.Qobj`
-        Squeezing operator.
-
-
-    Examples
-    --------
-    >>> squeeze(4, 0.25) # doctest: +SKIP
-    Quantum object: dims = [[4], [4]], \
-shape = [4, 4], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
-     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
-
-    """
-    asq = destroy(N, offset=offset, dtype=dtype) ** 2
-    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
-    return op.expm(dtype=dtype)
-
-
-def squeezing(a1, a2, z):
-    """Generalized squeezing operator.
-
-    .. math::
-
-        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
-        - za_1^\\dagger a_2^\\dagger\\right)\\right)
-
-    Parameters
-    ----------
-    a1 : :class:`qutip.Qobj`
-        Operator 1.
-
-    a2 : :class:`qutip.Qobj`
-        Operator 2.
-
-    z : float/complex
-        Squeezing parameter.
-
-    Returns
-    -------
-    oper : :class:`qutip.Qobj`
-        Squeezing operator.
-
-    """
-    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
-    return b.expm()
-
-
-def displace(N, alpha, offset=0, *, dtype=None):
-    """Single-mode displacement operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of Hilbert space.
-
-    alpha : float/complex
-        Displacement amplitude.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Displacement operator.
-
-    Examples
-    --------
-    >>> displace(4,0.25) # doctest: +SKIP
-    Quantum object: dims = [[4], [4]], \
-shape = [4, 4], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
-     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
-     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
-     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    a = destroy(N, offset=offset)
-    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
-
-
-def commutator(A, B, kind="normal"):
-    """
-    Return the commutator of kind `kind` (normal, anti) of the
-    two operators A and B.
-    """
-    if kind == 'normal':
-        return A @ B - B @ A
-
-    elif kind == 'anti':
-        return A @ B + B @ A
-
-    else:
-        raise TypeError("Unknown commutator kind '%s'" % kind)
-
-
-def qutrit_ops(*, dtype=None):
-    """
-    Operators for a three level system (qutrit).
-
-    Parameters
-    ----------
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    opers: array
-        `array` of qutrit operators.
-
-    """
-    from .states import qutrit_basis
-
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    out = np.empty((6,), dtype=object)
-    one, two, three = qutrit_basis(dtype=dtype)
-    out[0] = one * one.dag()
-    out[1] = two * two.dag()
-    out[2] = three * three.dag()
-    out[3] = one * two.dag()
-    out[4] = two * three.dag()
-    out[5] = three * one.dag()
-    return out
-
-
-def phase(N, phi0=0, *, dtype=None):
-    """
-    Single-mode Pegg-Barnett phase operator.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    phi0 : float
-        Reference phase.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Phase operator with respect to reference phase.
-
-    Notes
-    -----
-    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
-    n = np.arange(N)[:, np.newaxis]
-    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
-                       for kk in phim])
-    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
-    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
-
-
-def enr_destroy(dims, excitations, *, dtype=None):
-    """
-    Generate annilation operators for modes in a excitation-number-restricted
-    state space. For example, consider a system consisting of 4 modes, each
-    with 5 states. The total hilbert space size is 5**4 = 625. If we are
-    only interested in states that contain up to 2 excitations, we only need
-    to include states such as
-
-        (0, 0, 0, 0)
-        (0, 0, 0, 1)
-        (0, 0, 0, 2)
-        (0, 0, 1, 0)
-        (0, 0, 1, 1)
-        (0, 0, 2, 0)
-        ...
-
-    This function creates annihilation operators for the 4 modes that act
-    within this state space:
-
-        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
-
-    From this point onwards, the annihiltion operators a1, ..., a4 can be
-    used to setup a Hamiltonian, collapse operators and expectation-value
-    operators, etc., following the usual pattern.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    a_ops : list of qobj
-        A list of annihilation operators for each mode in the composite
-        quantum system described by dims.
-    """
-    from .states import enr_state_dictionaries
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-
-    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
-
-    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
-             for _ in dims]
-
-    for n1, state1 in enumerate(idx2state):
-        for idx, s in enumerate(state1):
-            # if s > 0, the annihilation operator of mode idx has a non-zero
-            # entry with one less excitation in mode idx in the final state
-            if s > 0:
-                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
-                n2 = state2idx[state2]
-                a_ops[idx][n2, n1] = np.sqrt(s)
-
-    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
-
-
-def enr_identity(dims, excitations, *, dtype=None):
-    """
-    Generate the identity operator for the excitation-number restricted
-    state space defined by the `dims` and `exciations` arguments. See the
-    docstring for enr_fock for a more detailed description of these arguments.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    state : list of integers
-        The state in the number basis representation.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        A Qobj instance that represent the identity operator in the
-        exication-number-restricted state space defined by `dims` and
-        `exciations`.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    from .states import enr_state_dictionaries
-    nstates, _, _ = enr_state_dictionaries(dims, excitations)
-    return Qobj(_data.identity[dtype](nstates),
-                dims=[dims, dims],
-                type='oper',
-                isherm=True,
-                isunitary=True,
-                copy=False)
-
-
-def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
-    """
-    Generate the diagonal charge operator over charge states
-    from Nmin to Nmax.
-
-    Parameters
-    ----------
-    Nmax : int
-        Maximum charge state to consider.
-
-    Nmin : int (default = -Nmax)
-        Lowest charge state to consider.
-
-    frac : float (default = 1)
-        Specify fractional charge if needed.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    C : Qobj
-        Charge operator over [Nmin, Nmax].
-
-    Notes
-    -----
-    .. versionadded:: 3.2
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if Nmin is None:
-        Nmin = -Nmax
-    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
-    out = qdiags(diag, 0, dtype=dtype)
-    out.isherm = True
-    return out
-
-
-def tunneling(N, m=1, *, dtype=None):
-    r"""
-    Tunneling operator with elements of the form
-    :math:`\\sum |N><N+m| + |N+m><N|`.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    m : int (default = 1)
-        Number of excitations in tunneling event.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    T : Qobj
-        Tunneling operator.
-
-    Notes
-    -----
-    .. versionadded:: 3.2
-
-    """
-    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
-    T = qdiags(diags, [m, -m], dtype=dtype)
-    T.isherm = True
-    return T
-
-
-def qft(dimensions, *, dtype="dense"):
-    """
-    Quantum Fourier Transform operator.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.
-
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    QFT: qobj
-        Quantum Fourier transform operator.
-
-    """
-    N2, dimensions = _implicit_tensor_dimensions(dimensions)
-
-    phase = 2.0j * np.pi / N2
-    arr = np.arange(N2)
-    L, M = np.meshgrid(arr, arr)
-    data = np.exp(phase * (L * M)) / np.sqrt(N2)
-    return Qobj(data, dims=dimensions).to(dtype)
+"""
+This module contains functions for generating Qobj representation of a variety
+of commonly occuring quantum operators.
+"""
+
+__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
+           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
+           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
+           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
+           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
+           'enr_identity', 'charge', 'tunneling', 'qft']
+
+import numbers
+
+import numpy as np
+import scipy.sparse
+
+from . import data as _data
+from .qobj import Qobj
+from .dimensions import flatten
+from .. import settings
+
+
+def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
+           dtype=None):
+    """
+    Constructs an operator from an array of diagonals.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like
+        Array of elements to place along the selected diagonals.
+
+    offsets : sequence of ints, optional
+        Sequence for diagonals to be set:
+            - k=0 main diagonal
+            - k>0 kth upper diagonal
+            - k<0 kth lower diagonal
+
+    dims : list, optional
+        Dimensions for operator
+
+    shape : list, tuple, optional
+        Shape of operator.  If omitted, a square operator large enough
+        to contain the diagonals is generated.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Examples
+    --------
+    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
+    Quantum object: dims = [[4], [4]], \
+shape = [4, 4], type = oper, isherm = False
+    Qobj data =
+    [[ 0.          1.          0.          0.        ]
+     [ 0.          0.          1.41421356  0.        ]
+     [ 0.          0.          0.          1.73205081]
+     [ 0.          0.          0.          0.        ]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    offsets = [0] if offsets is None else offsets
+    data = _data.diag[dtype](diagonals, offsets, shape)
+    return Qobj(data, dims=dims, type='oper', copy=False)
+
+
+def jmat(j, which=None, *, dtype=None):
+    """Higher-order spin operators:
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    which : str
+        Which operator to return 'x','y','z','+','-'.
+        If no args given, then output is ['x','y','z']
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    jmat : Qobj or tuple of Qobj
+        ``qobj`` for requested spin operator(s).
+
+
+    Examples
+    --------
+    >>> jmat(1) # doctest: +SKIP
+    [ Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.          0.70710678  0.        ]
+     [ 0.70710678  0.          0.70710678]
+     [ 0.          0.70710678  0.        ]]
+     Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
+     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
+     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
+     Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 1.  0.  0.]
+     [ 0.  0.  0.]
+     [ 0.  0. -1.]]]
+
+    Notes
+    -----
+    If no 'args' input, then returns array of ['x','y','z'] operators.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if int(2 * j) != 2 * j or j < 0:
+        raise ValueError('j must be a non-negative integer or half-integer')
+
+    if not which:
+        return (
+            jmat(j, 'x', dtype=dtype),
+            jmat(j, 'y', dtype=dtype),
+            jmat(j, 'z', dtype=dtype)
+        )
+
+    dims = [[int(2*j + 1)]]*2
+    if which == '+':
+        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
+                    isherm=False, isunitary=False, copy=False)
+    if which == '-':
+        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
+                    isherm=False, isunitary=False, copy=False)
+    if which == 'x':
+        A =  _jplus(j, dtype=dtype)
+        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
+                    isherm=True, isunitary=False, copy=False) * 0.5
+    if which == 'y':
+        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
+        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
+                    isherm=True, isunitary=False, copy=False)
+    if which == 'z':
+        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
+                    isherm=True, isunitary=False, copy=False)
+    raise ValueError('Invalid spin operator: ' + which)
+
+
+def _jplus(j, *, dtype=None):
+    """
+    Internal functions for generating the data representing the J-plus
+    operator.
+    """
+    m = np.arange(j, -j - 1, -1, dtype=complex)
+    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
+    return _data.diag[dtype](data, 1)
+
+
+def _jz(j, *, dtype=None):
+    """
+    Internal functions for generating the data representing the J-z operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    N = int(2*j + 1)
+    data = np.array([j-k for k in range(N)], dtype=complex)
+    return _data.diag[dtype](data, 0)
+
+
+#
+# Spin j operators:
+#
+def spin_Jx(j, *, dtype=None):
+    """Spin-j x operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, 'x', dtype=dtype)
+
+
+def spin_Jy(j, *, dtype=None):
+    """Spin-j y operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, 'y', dtype=dtype)
+
+
+def spin_Jz(j, *, dtype=None):
+    """Spin-j z operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, 'z', dtype=dtype)
+
+
+def spin_Jm(j, *, dtype=None):
+    """Spin-j annihilation operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, '-', dtype=dtype)
+
+
+def spin_Jp(j, *, dtype=None):
+    """Spin-j creation operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, '+', dtype=dtype)
+
+
+def spin_J_set(j, *, dtype=None):
+    """Set of spin-j operators (x, y, z)
+
+    Parameters
+    ----------
+    j : float
+        Spin of operators
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    list : list of Qobj
+        list of ``qobj`` representating of the spin operator.
+
+    """
+    return jmat(j, dtype=dtype)
+
+
+# Pauli spin-1/2 operators.
+#
+# These are so common in quantum information that we want them to be
+# near-instantaneous to initialise, so we cache them at package import, and
+# just return copies when someone requests one.
+_SIGMAP = jmat(0.5, '+')
+_SIGMAM = jmat(0.5, '-')
+_SIGMAX = 2 * jmat(0.5, 'x')
+_SIGMAY = 2 * jmat(0.5, 'y')
+_SIGMAZ = 2 * jmat(0.5, 'z')
+
+
+def sigmap():
+    """Creation operator for Pauli spins.
+
+    Examples
+    --------
+    >>> sigmap() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.  1.]
+     [ 0.  0.]]
+
+    """
+    return _SIGMAP.copy()
+
+
+def sigmam():
+    """Annihilation operator for Pauli spins.
+
+    Examples
+    --------
+    >>> sigmam() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.  0.]
+     [ 1.  0.]]
+
+    """
+    return _SIGMAM.copy()
+
+
+def sigmax():
+    """Pauli spin 1/2 sigma-x operator
+
+    Examples
+    --------
+    >>> sigmax() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.  1.]
+     [ 1.  0.]]
+
+    """
+    return _SIGMAX.copy()
+
+
+def sigmay():
+    """Pauli spin 1/2 sigma-y operator.
+
+    Examples
+    --------
+    >>> sigmay() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j  0.-1.j]
+     [ 0.+1.j  0.+0.j]]
+
+    """
+    return _SIGMAY.copy()
+
+
+def sigmaz():
+    """Pauli spin 1/2 sigma-z operator.
+
+    Examples
+    --------
+    >>> sigmaz() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = True
+    Qobj data =
+    [[ 1.  0.]
+     [ 0. -1.]]
+
+    """
+    return _SIGMAZ.copy()
+
+
+def destroy(N, offset=0, *, dtype=None):
+    """
+    Destruction (lowering) operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for lowering operator.
+
+    Examples
+    --------
+    >>> destroy(4) # doctest: +SKIP
+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
+    Qobj data =
+    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
+        raise ValueError("Hilbert space dimension must be integer value")
+    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
+    return qdiags(data, 1, dtype=dtype)
+
+
+def create(N, offset=0, *, dtype=None):
+    """
+    Creation (raising) operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for raising operator.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    Examples
+    --------
+    >>> create(4) # doctest: +SKIP
+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
+    Qobj data =
+    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
+        raise ValueError("Hilbert space dimension must be integer value")
+    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
+    return qdiags(data, -1, dtype=dtype)
+
+
+def _implicit_tensor_dimensions(dimensions):
+    """
+    Total flattened size and operator dimensions for operator creation routines
+    that automatically perform tensor products.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        First dimension of an operator which can create an implicit tensor
+        product.  If the type is `int`, it is promoted first to `[dimensions]`.
+        From there, it should be one of the two-elements `dims` parameter of a
+        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
+        products.
+
+    Returns
+    -------
+    size : int
+        Dimension of backing matrix required to represent operator.
+    dimensions : list
+        Dimension list in the form required by ``Qobj`` creation.
+    """
+    if not isinstance(dimensions, list):
+        dimensions = [dimensions]
+    flat = flatten(dimensions)
+    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
+        raise ValueError("All dimensions must be integers >= 0")
+    return np.prod(flat), [dimensions, dimensions]
+
+
+def qzero(dimensions, *, dtype=None):
+    """
+    Zero operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    qzero : qobj
+        Zero operator Qobj.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    size, dimensions = _implicit_tensor_dimensions(dimensions)
+    # A sparse matrix with no data is equal to a zero matrix.
+    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
+    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
+                isherm=True, isunitary=False, copy=False)
+
+
+def qeye(dimensions, *, dtype=None):
+    """
+    Identity operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Identity operator Qobj.
+
+    Examples
+    --------
+    >>> qeye(3) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
+isherm = True
+    Qobj data =
+    [[ 1.  0.  0.]
+     [ 0.  1.  0.]
+     [ 0.  0.  1.]]
+    >>> qeye([2,2]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
+isherm = True
+    Qobj data =
+    [[1. 0. 0. 0.]
+     [0. 1. 0. 0.]
+     [0. 0. 1. 0.]
+     [0. 0. 0. 1.]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    size, dimensions = _implicit_tensor_dimensions(dimensions)
+    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
+    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
+                isherm=True, isunitary=True, copy=False)
+
+
+# Name alias.
+identity = qeye
+
+
+def position(N, offset=0, *, dtype=None):
+    """
+    Position operator x=1/sqrt(2)*(a+a.dag())
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Position operator as Qobj.
+    """
+    a = destroy(N, offset=offset, dtype=dtype)
+    position = np.sqrt(0.5) * (a + a.dag())
+    position.isherm = True
+    return position
+
+
+def momentum(N, offset=0, *, dtype=None):
+    """
+    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Momentum operator as Qobj.
+    """
+    a = destroy(N, offset=offset, dtype=dtype)
+    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
+    momentum.isherm = True
+    return momentum
+
+
+def num(N, offset=0, *, dtype=None):
+    """
+    Quantum object for number operator.
+
+    Parameters
+    ----------
+    N : int
+        The dimension of the Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper: qobj
+        Qobj for number operator.
+
+    Examples
+    --------
+    >>> num(4) # doctest: +SKIP
+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
+    Qobj data =
+    [[0 0 0 0]
+     [0 1 0 0]
+     [0 0 2 0]
+     [0 0 0 3]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    data = np.arange(offset, offset + N, dtype=complex)
+    return qdiags(data, 0, dtype=dtype)
+
+
+def squeeze(N, z, offset=0, *, dtype=None):
+    """Single-mode squeezing operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of hilbert space.
+
+    z : float/complex
+        Squeezing parameter.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : :class:`qutip.Qobj`
+        Squeezing operator.
+
+
+    Examples
+    --------
+    >>> squeeze(4, 0.25) # doctest: +SKIP
+    Quantum object: dims = [[4], [4]], \
+shape = [4, 4], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
+     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
+
+    """
+    asq = destroy(N, offset=offset, dtype=dtype) ** 2
+    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
+    return op.expm(dtype=dtype)
+
+
+def squeezing(a1, a2, z):
+    """Generalized squeezing operator.
+
+    .. math::
+
+        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
+        - za_1^\\dagger a_2^\\dagger\\right)\\right)
+
+    Parameters
+    ----------
+    a1 : :class:`qutip.Qobj`
+        Operator 1.
+
+    a2 : :class:`qutip.Qobj`
+        Operator 2.
+
+    z : float/complex
+        Squeezing parameter.
+
+    Returns
+    -------
+    oper : :class:`qutip.Qobj`
+        Squeezing operator.
+
+    """
+    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
+    return b.expm()
+
+
+def displace(N, alpha, offset=0, *, dtype=None):
+    """Single-mode displacement operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    alpha : float/complex
+        Displacement amplitude.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Displacement operator.
+
+    Examples
+    --------
+    >>> displace(4,0.25) # doctest: +SKIP
+    Quantum object: dims = [[4], [4]], \
+shape = [4, 4], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
+     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
+     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
+     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    a = destroy(N, offset=offset)
+    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
+
+
+def commutator(A, B, kind="normal"):
+    """
+    Return the commutator of kind `kind` (normal, anti) of the
+    two operators A and B.
+    """
+    if kind == 'normal':
+        return A @ B - B @ A
+
+    elif kind == 'anti':
+        return A @ B + B @ A
+
+    else:
+        raise TypeError("Unknown commutator kind '%s'" % kind)
+
+
+def qutrit_ops(*, dtype=None):
+    """
+    Operators for a three level system (qutrit).
+
+    Parameters
+    ----------
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    opers: array
+        `array` of qutrit operators.
+
+    """
+    from .states import qutrit_basis
+
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    out = np.empty((6,), dtype=object)
+    one, two, three = qutrit_basis(dtype=dtype)
+    out[0] = one * one.dag()
+    out[1] = two * two.dag()
+    out[2] = three * three.dag()
+    out[3] = one * two.dag()
+    out[4] = two * three.dag()
+    out[5] = three * one.dag()
+    return out
+
+
+def phase(N, phi0=0, *, dtype=None):
+    """
+    Single-mode Pegg-Barnett phase operator.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    phi0 : float
+        Reference phase.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Phase operator with respect to reference phase.
+
+    Notes
+    -----
+    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
+    n = np.arange(N)[:, np.newaxis]
+    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
+                       for kk in phim])
+    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
+    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
+
+
+def enr_destroy(dims, excitations, *, dtype=None):
+    """
+    Generate annilation operators for modes in a excitation-number-restricted
+    state space. For example, consider a system consisting of 4 modes, each
+    with 5 states. The total hilbert space size is 5**4 = 625. If we are
+    only interested in states that contain up to 2 excitations, we only need
+    to include states such as
+
+        (0, 0, 0, 0)
+        (0, 0, 0, 1)
+        (0, 0, 0, 2)
+        (0, 0, 1, 0)
+        (0, 0, 1, 1)
+        (0, 0, 2, 0)
+        ...
+
+    This function creates annihilation operators for the 4 modes that act
+    within this state space:
+
+        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
+
+    From this point onwards, the annihiltion operators a1, ..., a4 can be
+    used to setup a Hamiltonian, collapse operators and expectation-value
+    operators, etc., following the usual pattern.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    a_ops : list of qobj
+        A list of annihilation operators for each mode in the composite
+        quantum system described by dims.
+    """
+    from .states import enr_state_dictionaries
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+
+    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
+
+    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
+             for _ in dims]
+
+    for n1, state1 in enumerate(idx2state):
+        for idx, s in enumerate(state1):
+            # if s > 0, the annihilation operator of mode idx has a non-zero
+            # entry with one less excitation in mode idx in the final state
+            if s > 0:
+                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
+                n2 = state2idx[state2]
+                a_ops[idx][n2, n1] = np.sqrt(s)
+
+    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
+
+
+def enr_identity(dims, excitations, *, dtype=None):
+    """
+    Generate the identity operator for the excitation-number restricted
+    state space defined by the `dims` and `exciations` arguments. See the
+    docstring for enr_fock for a more detailed description of these arguments.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    state : list of integers
+        The state in the number basis representation.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        A Qobj instance that represent the identity operator in the
+        exication-number-restricted state space defined by `dims` and
+        `exciations`.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    from .states import enr_state_dictionaries
+    nstates, _, _ = enr_state_dictionaries(dims, excitations)
+    return Qobj(_data.identity[dtype](nstates),
+                dims=[dims, dims],
+                type='oper',
+                isherm=True,
+                isunitary=True,
+                copy=False)
+
+
+def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
+    """
+    Generate the diagonal charge operator over charge states
+    from Nmin to Nmax.
+
+    Parameters
+    ----------
+    Nmax : int
+        Maximum charge state to consider.
+
+    Nmin : int (default = -Nmax)
+        Lowest charge state to consider.
+
+    frac : float (default = 1)
+        Specify fractional charge if needed.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    C : Qobj
+        Charge operator over [Nmin, Nmax].
+
+    Notes
+    -----
+    .. versionadded:: 3.2
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if Nmin is None:
+        Nmin = -Nmax
+    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
+    out = qdiags(diag, 0, dtype=dtype)
+    out.isherm = True
+    return out
+
+
+def tunneling(N, m=1, *, dtype=None):
+    r"""
+    Tunneling operator with elements of the form
+    :math:`\\sum |N><N+m| + |N+m><N|`.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    m : int (default = 1)
+        Number of excitations in tunneling event.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    T : Qobj
+        Tunneling operator.
+
+    Notes
+    -----
+    .. versionadded:: 3.2
+
+    """
+    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
+    T = qdiags(diags, [m, -m], dtype=dtype)
+    T.isherm = True
+    return T
+
+
+def qft(dimensions, *, dtype="dense"):
+    """
+    Quantum Fourier Transform operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.
+
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    QFT: qobj
+        Quantum Fourier transform operator.
+
+    """
+    N2, dimensions = _implicit_tensor_dimensions(dimensions)
+
+    phase = 2.0j * np.pi / N2
+    arr = np.arange(N2)
+    L, M = np.meshgrid(arr, arr)
+    data = np.exp(phase * (L * M)) / np.sqrt(N2)
+    return Qobj(data, dims=dimensions).to(dtype)
diff --git a/qutip/core/options.py b/qutip/core/options.py
index 1724c81890..daa3db0b3b 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -1,123 +1,123 @@
-from ..settings import settings
-
-__all__ = ["CoreOptions"]
-
-
-class QutipOptions:
-    """
-    Class for basic functionality for qutip's options.
-
-    Define basic method to wrap an ``options`` dict.
-    Default options are in a class _options dict.
-    """
-    _options = {}
-    _settings_name = None  # Where the default is in settings
-
-    def __init__(self, **options):
-        self.options = self._options.copy()
-        for key in set(options) & set(self.options):
-            self[key] = options.pop(key)
-        if options:
-            raise KeyError(f"Options {set(options)} are not supported.")
-
-    def __contains__(self, key):
-        return key in self.options
-
-    def __getitem__(self, key):
-        # Let the dict catch the KeyError
-        return self.options[key]
-
-    def __setitem__(self, key, value):
-        # Let the dict catch the KeyError
-        self.options[key] = value
-
-    def __repr__(self, full=True):
-        out = [f"<{self.__class__.__name__}("]
-        for key, value in self.options.items():
-            if full or value != self._options[key]:
-                out += [f"    '{key}': {repr(value)},"]
-        out += [")>"]
-        if len(out)-2:
-            return "\n".join(out)
-        else:
-            return "".join(out)
-
-    def __enter__(self):
-        self._backup = getattr(settings, self._settings_name)
-        setattr(settings, self._settings_name, self)
-
-    def __exit__(self, exc_type, exc_value, exc_traceback):
-        setattr(settings, self._settings_name, self._backup)
-
-
-class CoreOptions(QutipOptions):
-    """
-    Options used by the core of qutip such as the tolerance of :class:`Qobj`
-    comparison or coefficient's format.
-
-    Values can be changed in ``qutip.settings.core`` or by using context:
-    ``with CoreOptions(atol=1e-6): ...``.
-
-    Options
-    -------
-    auto_tidyup : bool
-        Whether to tidyup during sparse operations.
-
-    auto_tidyup_dims : bool [True]
-        Use auto tidyup dims on multiplication. (Not used yet)
-
-    atol : float {1e-12}
-        General absolute tolerance
-
-    rtol : float {1e-12}
-        General relative tolerance
-        Used to choose QobjEvo.expect output type
-
-    auto_tidyup_atol : float {1e-14}
-        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
-        parameter above) and the default value of ``atol`` used in
-        :method:`Qobj.tidyup`.
-
-    function_coefficient_style : str {"auto"}
-        The signature expected by function coefficients. The options are:
-
-        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
-          is the time and the ``...`` are the remaining arguments passed
-          directly into the function. E.g. ``f(t, w, b=5)``.
-
-        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
-          the time and ``args`` is a dict containing the remaining arguments.
-          E.g. ``f(t, {"w": w, "b": 5})``.
-
-        - "auto": select automatically between the two options above based
-          on the signature of the supplied function. If the function signature
-          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
-          ``pythonic`` is used.
-
-    default_dtype : Nonetype, str, type {None}
-        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
-        :func:"rand_herm", will use the specified data type. Any data-layer
-        known to ``qutip.data.to`` is accepted. When ``None``, these functions
-        will default to a sensible data type.
-    """
-    _options = {
-        # use auto tidyup
-        "auto_tidyup": True,
-        # use auto tidyup dims on multiplication
-        "auto_tidyup_dims": True,
-        # general absolute tolerance
-        "atol": 1e-12,
-        # general relative tolerance
-        "rtol": 1e-12,
-        # use auto tidyup absolute tolerance
-        "auto_tidyup_atol": 1e-14,
-        # signature style expected by function coefficients
-        "function_coefficient_style": "auto",
-        # Default Qobj dtype for Qobj create function
-        "default_dtype": None,
-    }
-    _settings_name = "core"
-
-
-# Creating the instance of core options to use everywhere.
-settings.core = CoreOptions()
+from ..settings import settings
+
+__all__ = ["CoreOptions"]
+
+
+class QutipOptions:
+    """
+    Class for basic functionality for qutip's options.
+
+    Define basic method to wrap an ``options`` dict.
+    Default options are in a class _options dict.
+    """
+    _options = {}
+    _settings_name = None  # Where the default is in settings
+
+    def __init__(self, **options):
+        self.options = self._options.copy()
+        for key in set(options) & set(self.options):
+            self[key] = options.pop(key)
+        if options:
+            raise KeyError(f"Options {set(options)} are not supported.")
+
+    def __contains__(self, key):
+        return key in self.options
+
+    def __getitem__(self, key):
+        # Let the dict catch the KeyError
+        return self.options[key]
+
+    def __setitem__(self, key, value):
+        # Let the dict catch the KeyError
+        self.options[key] = value
+
+    def __repr__(self, full=True):
+        out = [f"<{self.__class__.__name__}("]
+        for key, value in self.options.items():
+            if full or value != self._options[key]:
+                out += [f"    '{key}': {repr(value)},"]
+        out += [")>"]
+        if len(out)-2:
+            return "\n".join(out)
+        else:
+            return "".join(out)
+
+    def __enter__(self):
+        self._backup = getattr(settings, self._settings_name)
+        setattr(settings, self._settings_name, self)
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        setattr(settings, self._settings_name, self._backup)
+
+
+class CoreOptions(QutipOptions):
+    """
+    Options used by the core of qutip such as the tolerance of :class:`Qobj`
+    comparison or coefficient's format.
+
+    Values can be changed in ``qutip.settings.core`` or by using context:
+    ``with CoreOptions(atol=1e-6): ...``.
+
+    Options
+    -------
+    auto_tidyup : bool
+        Whether to tidyup during sparse operations.
+
+    auto_tidyup_dims : bool [True]
+        Use auto tidyup dims on multiplication. (Not used yet)
+
+    atol : float {1e-12}
+        General absolute tolerance
+
+    rtol : float {1e-12}
+        General relative tolerance
+        Used to choose QobjEvo.expect output type
+
+    auto_tidyup_atol : float {1e-14}
+        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
+        parameter above) and the default value of ``atol`` used in
+        :method:`Qobj.tidyup`.
+
+    function_coefficient_style : str {"auto"}
+        The signature expected by function coefficients. The options are:
+
+        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
+          is the time and the ``...`` are the remaining arguments passed
+          directly into the function. E.g. ``f(t, w, b=5)``.
+
+        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
+          the time and ``args`` is a dict containing the remaining arguments.
+          E.g. ``f(t, {"w": w, "b": 5})``.
+
+        - "auto": select automatically between the two options above based
+          on the signature of the supplied function. If the function signature
+          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
+          ``pythonic`` is used.
+
+    default_dtype : Nonetype, str, type {None}
+        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
+        :func:"rand_herm", will use the specified data type. Any data-layer
+        known to ``qutip.data.to`` is accepted. When ``None``, these functions
+        will default to a sensible data type.
+    """
+    _options = {
+        # use auto tidyup
+        "auto_tidyup": True,
+        # use auto tidyup dims on multiplication
+        "auto_tidyup_dims": True,
+        # general absolute tolerance
+        "atol": 1e-12,
+        # general relative tolerance
+        "rtol": 1e-12,
+        # use auto tidyup absolute tolerance
+        "auto_tidyup_atol": 1e-14,
+        # signature style expected by function coefficients
+        "function_coefficient_style": "auto",
+        # Default Qobj dtype for Qobj create function
+        "default_dtype": None,
+    }
+    _settings_name = "core"
+
+
+# Creating the instance of core options to use everywhere.
+settings.core = CoreOptions()
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index 83a778b052..b6128d55cf 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -1,1811 +1,1811 @@
-"""The Quantum Object (Qobj) class, for representing quantum states and
-operators, and related functions.
-"""
-
-__all__ = [
-    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
-    'isherm', 'ptrace',
-]
-
-import functools
-import numbers
-import warnings
-
-import numpy as np
-import scipy.sparse
-
-from .. import __version__
-from ..settings import settings
-from . import data as _data
-from .dimensions import (
-    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
-)
-
-
-_ADJOINT_TYPE_LOOKUP = {
-    'oper': 'oper',
-    'super': 'super',
-    'ket': 'bra',
-    'bra': 'ket',
-    'operator-ket': 'operator-bra',
-    'operator-bra': 'operator-ket',
-}
-
-_MATMUL_TYPE_LOOKUP = {
-    ('oper', 'ket'): 'ket',
-    ('oper', 'oper'): 'oper',
-    ('ket', 'bra'): 'oper',
-    ('bra', 'oper'): 'bra',
-    ('super', 'super'): 'super',
-    ('super', 'operator-ket'): 'operator-ket',
-    ('operator-bra', 'super'): 'operator-bra',
-    ('operator-ket', 'operator-bra'): 'super',
-}
-
-_NORM_FUNCTION_LOOKUP = {
-    'tr': _data.norm.trace,
-    'one': _data.norm.one,
-    'max': _data.norm.max,
-    'fro': _data.norm.frobenius,
-    'l2': _data.norm.l2,
-}
-_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
-_NORM_ALLOWED_VECTOR = {'l2', 'max'}
-
-_CALL_ALLOWED = {
-    ('super', 'oper'),
-    ('super', 'ket'),
-    ('oper', 'ket'),
-}
-
-
-def isbra(x):
-    return isinstance(x, Qobj) and x.type == 'bra'
-
-
-def isket(x):
-    return isinstance(x, Qobj) and x.type == 'ket'
-
-
-def isoper(x):
-    return isinstance(x, Qobj) and x.type == 'oper'
-
-
-def isoperbra(x):
-    return isinstance(x, Qobj) and x.type == 'operator-bra'
-
-
-def isoperket(x):
-    return isinstance(x, Qobj) and x.type == 'operator-ket'
-
-
-def issuper(x):
-    return isinstance(x, Qobj) and x.type == 'super'
-
-
-def isherm(x):
-    return isinstance(x, Qobj) and x.isherm
-
-
-def _require_equal_type(method):
-    """
-    Decorate a binary Qobj method to ensure both operands are Qobj and of the
-    same type and dimensions.  Promote numeric scalar to identity matrices of
-    the same type and shape.
-    """
-    @functools.wraps(method)
-    def out(self, other):
-        if other == 0:
-            return method(self, other)
-        if (
-            self.type in ('oper', 'super')
-            and self.dims[0] == self.dims[1]
-            and isinstance(other, numbers.Number)
-        ):
-            scale = complex(other)
-            other = Qobj(_data.identity(self.shape[0], scale,
-                                        dtype=type(self.data)),
-                         dims=self.dims,
-                         type=self.type,
-                         superrep=self.superrep,
-                         isherm=(scale.imag == 0),
-                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
-                         copy=False)
-        if not isinstance(other, Qobj):
-            try:
-                other = Qobj(other, type=self.type)
-            except TypeError:
-                return NotImplemented
-        if self.dims != other.dims:
-            msg = (
-                "incompatible dimensions "
-                + repr(self.dims) + " and " + repr(other.dims)
-            )
-            raise ValueError(msg)
-        if self.type != other.type:
-            msg = "incompatible types " + self.type + " and " + other.type
-            raise ValueError(msg)
-        if self.superrep != other.superrep:
-            msg = (
-                "incompatible superoperator representations"
-                + self.superrep + " and " + other.superrep
-            )
-            raise ValueError(msg)
-        return method(self, other)
-    return out
-
-
-def _latex_real(x):
-    if not x:
-        return "0"
-    if not 0.001 <= abs(x) < 1000:
-        base, exp = "{:.3e}".format(x).split('e')
-        return base + r"\times10^{{ {:d} }}".format(int(exp))
-    if abs(x - int(x)) < 0.001:
-        return "{:d}".format(round(x))
-    return "{:.3f}".format(x)
-
-
-def _latex_complex(x):
-    if abs(x.imag) < 0.001:
-        return _latex_real(x.real)
-    if abs(x.real) < 0.001:
-        return _latex_real(x.imag) + "j"
-    sign = "+" if x.imag > 0 else "-"
-    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
-
-
-def _latex_row(row, cols, data):
-    if row is None:
-        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
-    else:
-        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
-                for col in cols)
-    return " & ".join(bits)
-
-
-class Qobj:
-    """
-    A class for representing quantum objects, such as quantum operators and
-    states.
-
-    The Qobj class is the QuTiP representation of quantum operators and state
-    vectors. This class also implements math operations +,-,* between Qobj
-    instances (and / by a C-number), as well as a collection of common
-    operator/state operations.  The Qobj constructor optionally takes a
-    dimension ``list`` and/or shape ``list`` as arguments.
-
-    Parameters
-    ----------
-    inpt: array_like
-        Data for vector/matrix representation of the quantum object.
-    dims: list
-        Dimensions of object used for tensor products.
-    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
-        The type of quantum object to be represented.
-    shape: list
-        Shape of underlying data structure (matrix shape).
-    copy: bool
-        Flag specifying whether Qobj should get a copy of the
-        input data, or use the original.
-
-
-    Attributes
-    ----------
-    data : array_like
-        Sparse matrix characterizing the quantum object.
-    dims : list
-        List of dimensions keeping track of the tensor structure.
-    shape : list
-        Shape of the underlying `data` array.
-    type : str
-        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
-        'operator-bra', or 'super'.
-    superrep : str
-        Representation used if `type` is 'super'. One of 'super'
-        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
-    isherm : bool
-        Indicates if quantum object represents Hermitian operator.
-    isunitary : bool
-        Indictaes if quantum object represents unitary operator.
-    iscp : bool
-        Indicates if the quantum object represents a map, and if that map is
-        completely positive (CP).
-    ishp : bool
-        Indicates if the quantum object represents a map, and if that map is
-        hermicity preserving (HP).
-    istp : bool
-        Indicates if the quantum object represents a map, and if that map is
-        trace preserving (TP).
-    iscptp : bool
-        Indicates if the quantum object represents a map that is completely
-        positive and trace preserving (CPTP).
-    isket : bool
-        Indicates if the quantum object represents a ket.
-    isbra : bool
-        Indicates if the quantum object represents a bra.
-    isoper : bool
-        Indicates if the quantum object represents an operator.
-    issuper : bool
-        Indicates if the quantum object represents a superoperator.
-    isoperket : bool
-        Indicates if the quantum object represents an operator in column vector
-        form.
-    isoperbra : bool
-        Indicates if the quantum object represents an operator in row vector
-        form.
-
-    Methods
-    -------
-    copy()
-        Create copy of Qobj
-    conj()
-        Conjugate of quantum object.
-    cosm()
-        Cosine of quantum object.
-    dag()
-        Adjoint (dagger) of quantum object.
-    dnorm()
-        Diamond norm of quantum operator.
-    dual_chan()
-        Dual channel of quantum object representing a CP map.
-    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
-        Returns eigenenergies (eigenvalues) of a quantum object.
-    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
-        Returns eigenenergies and eigenstates of quantum object.
-    expm()
-        Matrix exponential of quantum object.
-    full(order='C')
-        Returns dense array of quantum object `data` attribute.
-    groundstate(sparse=False, tol=0, maxiter=100000)
-        Returns eigenvalue and eigenket for the groundstate of a quantum
-        object.
-    inv()
-        Return a Qobj corresponding to the matrix inverse of the operator.
-    matrix_element(bra, ket)
-        Returns the matrix element of operator between `bra` and `ket` vectors.
-    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
-        Returns norm of a ket or an operator.
-    permute(order)
-        Returns composite qobj with indices reordered.
-    proj()
-        Computes the projector for a ket or bra vector.
-    ptrace(sel)
-        Returns quantum object for selected dimensions after performing
-        partial trace.
-    sinm()
-        Sine of quantum object.
-    sqrtm()
-        Matrix square root of quantum object.
-    tidyup(atol=1e-12)
-        Removes small elements from quantum object.
-    tr()
-        Trace of quantum object.
-    trans()
-        Transpose of quantum object.
-    transform(inpt, inverse=False)
-        Performs a basis transformation defined by `inpt` matrix.
-    trunc_neg(method='clip')
-        Removes negative eigenvalues and returns a new Qobj that is
-        a valid density operator.
-    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
-        Returns normalized quantum object.
-
-    """
-    # Disable ufuncs from acting directly on Qobj.
-    __array_ufunc__ = None
-
-    def _initialize_data(self, arg, dims, copy):
-        if isinstance(arg, _data.Data):
-            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
-            self._data = arg.copy() if copy else arg
-        elif isinstance(arg, Qobj):
-            self.dims = dims or arg.dims.copy()
-            self._data = arg.data.copy() if copy else arg.data
-        elif arg is None or isinstance(arg, numbers.Number):
-            self.dims = dims or [[1], [1]]
-            size = np.prod(self.dims[0])
-            if arg is None:
-                self._data = _data.zeros(size, size)
-            else:
-                self._data = _data.identity(size, scale=complex(arg))
-        else:
-            self._data = _data.create(arg, copy=copy)
-            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
-
-    def __init__(self, arg=None, dims=None, type=None,
-                 copy=True, superrep=None, isherm=None, isunitary=None):
-        self._initialize_data(arg, dims, copy)
-        self.type = type or type_from_dims(self.dims)
-        self._isherm = isherm
-        self._isunitary = isunitary
-
-        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
-            if self._data.shape[0] != self._data.shape[1]:
-                raise ValueError("".join([
-                    "cannot build superoperator from nonsquare data of shape ",
-                    repr(self._data.shape),
-                ]))
-            root = int(np.sqrt(self._data.shape[0]))
-            if root * root != self._data.shape[0]:
-                raise ValueError("".join([
-                    "cannot build superoperator from nonsquare subspaces ",
-                    "of size ",
-                    repr(self._data.shape[0]),
-                ]))
-            self.dims = [[[root]]*2]*2
-        if self.type in ['super', 'operator-ket', 'operator-bra']:
-            superrep = superrep or 'super'
-        self.superrep = superrep
-
-    def copy(self):
-        """Create identical copy"""
-        return Qobj(arg=self._data,
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=True)
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        if not isinstance(data, _data.Data):
-            raise TypeError('Qobj data must be a data-layer format.')
-        self._data = data
-
-    def to(self, data_type):
-        """
-        Convert the underlying data store of this `Qobj` into a different
-        storage representation.
-
-        The different storage representations available are the "data-layer
-        types" which are known to `qutip.data.to`.  By default, these are
-        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
-        dense matrix store and a compressed sparse row one.  Certain algorithms
-        and operations may be faster or more accurate when using a more
-        appropriate data store.
-
-        If the data store is already in the format requested, the function
-        returns `self`.  Otherwise, it returns a copy of itself with the data
-        store in the new type.
-
-        Parameters
-        ----------
-        data_type : type
-            The data-layer type that the data of this `Qobj` should be
-            converted to.
-
-        Returns
-        -------
-        Qobj
-            A new `Qobj` if a type conversion took place with the data stored
-            in the requested format, or `self` if not.
-        """
-        try:
-            converter = _data.to[data_type]
-        except (KeyError, TypeError):
-            raise ValueError("Unknown conversion type: " + str(data_type))
-        if type(self.data) is data_type:
-            return self
-        return Qobj(converter(self._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    @_require_equal_type
-    def __add__(self, other):
-        if other == 0:
-            return self.copy()
-        isherm = (self._isherm and other._isherm) or None
-        return Qobj(_data.add(self._data, other._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=isherm,
-                    copy=False)
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    @_require_equal_type
-    def __sub__(self, other):
-        if other == 0:
-            return self.copy()
-        isherm = (self._isherm and other._isherm) or None
-        return Qobj(_data.sub(self._data, other._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=isherm,
-                    copy=False)
-
-    def __rsub__(self, other):
-        return self.__neg__().__add__(other)
-
-    def __mul__(self, other):
-        """
-        If other is a Qobj, we dispatch to __matmul__. If not, we
-        check that other is a valid complex scalar, i.e., we can do
-        complex(other). Otherwise, we return NotImplemented.
-        """
-
-        if isinstance(other, Qobj):
-            return self.__matmul__(other)
-
-        # We send other to mul instead of complex(other) to be more flexible.
-        # The dispatcher can then decide how to handle other and return
-        # TypeError if it does not know what to do with the type of other.
-        try:
-            out = _data.mul(self._data, other)
-        except TypeError:
-            return NotImplemented
-
-        # Infer isherm and isunitary if possible
-        try:
-            multiplier = complex(other)
-            isherm = (self._isherm and multiplier.imag == 0) or None
-            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
-                         if self._isunitary else None)
-        except TypeError:
-            isherm = None
-            isunitary = None
-
-        return Qobj(out,
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=isherm,
-                    isunitary=isunitary,
-                    copy=False)
-
-    def __rmul__(self, other):
-        # Shouldn't be here unless `other.__mul__` has already been tried, so
-        # we _shouldn't_ check that `other` is `Qobj`.
-        return self.__mul__(other)
-
-    def __matmul__(self, other):
-        if not isinstance(other, Qobj):
-            try:
-                other = Qobj(other)
-            except TypeError:
-                return NotImplemented
-        if self.dims[1] != other.dims[0]:
-            raise TypeError("".join([
-                "incompatible dimensions ",
-                repr(self.dims),
-                " and ",
-                repr(other.dims),
-            ]))
-        if self.superrep != other.superrep:
-            raise TypeError("".join([
-                "incompatible superoperator representations ",
-                repr(self.superrep),
-                " and ",
-                repr(other.superrep),
-            ]))
-        if (
-            (self.isbra and other.isket)
-            or (self.isoperbra and other.isoperket)
-        ):
-            return _data.inner(self.data, other.data)
-
-        try:
-            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
-        except KeyError:
-            raise TypeError(
-                "incompatible matmul types "
-                + repr(self.type) + " and " + repr(other.type)
-            ) from None
-        return Qobj(_data.matmul(self.data, other.data),
-                    dims=[self.dims[0], other.dims[1]],
-                    type=type_,
-                    isunitary=self._isunitary and other._isunitary,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def __truediv__(self, other):
-        return self.__mul__(1 / other)
-
-    def __neg__(self):
-        return Qobj(_data.neg(self._data),
-                    dims=self.dims.copy(),
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def __getitem__(self, ind):
-        # TODO: should we require that data-layer types implement this?  This
-        # isn't the right way of handling it, for sure.
-        if isinstance(self._data, _data.CSR):
-            data = self._data.as_scipy()
-        elif isinstance(self._data, _data.Dense):
-            data = self._data.as_ndarray()
-        else:
-            data = self._data
-        try:
-            out = data[ind]
-            return out.toarray() if scipy.sparse.issparse(out) else out
-        except TypeError:
-            pass
-        return data.to_array()[ind]
-
-    def __eq__(self, other):
-        if self is other:
-            return True
-        if not isinstance(other, Qobj) or self.dims != other.dims:
-            return False
-        return _data.iszero(_data.sub(self._data, other._data),
-                            tol=settings.core['atol'])
-
-    def __pow__(self, n, m=None):  # calculates powers of Qobj
-        if (
-            self.type not in ('oper', 'super')
-            or self.dims[0] != self.dims[1]
-            or m is not None
-            or not isinstance(n, numbers.Integral)
-            or n < 0
-        ):
-            return NotImplemented
-        return Qobj(_data.pow(self._data, n),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def _str_header(self):
-        out = ", ".join([
-            "Quantum object: dims=" + str(self.dims),
-            "shape=" + str(self.data.shape),
-            "type=" + repr(self.type),
-        ])
-        if self.type in ('oper', 'super'):
-            out += ", isherm=" + str(self.isherm)
-        if self.issuper and self.superrep != 'super':
-            out += ", superrep=" + repr(self.superrep)
-        return out
-
-    def __str__(self):
-        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
-            # If the system is huge, don't attempt to convert to a dense matrix
-            # and then to string, because it is pointless and is likely going
-            # to produce memory errors. Instead print the sparse data string
-            # representation.
-            data = _data.to(_data.CSR, self.data).as_scipy()
-        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
-            data = np.real(self.full())
-        else:
-            data = self.full()
-        return self._str_header() + "\nQobj data =\n" + str(data)
-
-    def __repr__(self):
-        # give complete information on Qobj without print statement in
-        # command-line we cant realistically serialize a Qobj into a string,
-        # so we simply return the informal __str__ representation instead.)
-        return self.__str__()
-
-    def __call__(self, other):
-        """
-        Acts this Qobj on another Qobj either by left-multiplication,
-        or by vectorization and devectorization, as
-        appropriate.
-        """
-        if not isinstance(other, Qobj):
-            raise TypeError("Only defined for quantum objects.")
-        if (self.type, other.type) not in _CALL_ALLOWED:
-            raise TypeError(self.type + " cannot act on " + other.type)
-        if self.issuper:
-            if other.isket:
-                other = other.proj()
-            return vector_to_operator(self @ operator_to_vector(other))
-        return self.__matmul__(other)
-
-    def __getstate__(self):
-        # defines what happens when Qobj object gets pickled
-        self.__dict__.update({'qutip_version': __version__[:5]})
-        return self.__dict__
-
-    def __setstate__(self, state):
-        # defines what happens when loading a pickled Qobj
-        if 'qutip_version' in state.keys():
-            del state['qutip_version']
-        (self.__dict__).update(state)
-
-    def _repr_latex_(self):
-        """
-        Generate a LaTeX representation of the Qobj instance. Can be used for
-        formatted output in ipython notebook.
-        """
-        half_length = 5
-        n_rows, n_cols = self.data.shape
-        # Choose which rows and columns we're going to output, or None if that
-        # element should be truncated.
-        rows = list(range(min((half_length, n_rows))))
-        if n_rows <= half_length * 2:
-            rows += list(range(half_length, min((2*half_length, n_rows))))
-        else:
-            rows.append(None)
-            rows += list(range(n_rows - half_length, n_rows))
-        cols = list(range(min((half_length, n_cols))))
-        if n_cols <= half_length * 2:
-            cols += list(range(half_length, min((2*half_length, n_cols))))
-        else:
-            cols.append(None)
-            cols += list(range(n_cols - half_length, n_cols))
-        # Make the data array.
-        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
-        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
-                           for row in rows)
-        data += r'\end{array}\right)\end{equation*}'
-        return self._str_header() + data
-
-    def __and__(self, other):
-        """
-        Syntax shortcut for tensor:
-        A & B ==> tensor(A, B)
-        """
-        return tensor(self, other)
-
-    def dag(self):
-        """Get the Hermitian adjoint of the quantum object."""
-        if self._isherm:
-            return self.copy()
-        return Qobj(_data.adjoint(self._data),
-                    dims=[self.dims[1], self.dims[0]],
-                    type=_ADJOINT_TYPE_LOOKUP[self.type],
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def conj(self):
-        """Get the element-wise conjugation of the quantum object."""
-        return Qobj(_data.conj(self._data),
-                    dims=self.dims.copy(),
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def trans(self):
-        """Get the matrix transpose of the quantum operator.
-
-        Returns
-        -------
-        oper : :class:`.Qobj`
-            Transpose of input operator.
-        """
-        return Qobj(_data.transpose(self._data),
-                    dims=[self.dims[1], self.dims[0]],
-                    type=_ADJOINT_TYPE_LOOKUP[self.type],
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def dual_chan(self):
-        """Dual channel of quantum object representing a completely positive
-        map.
-        """
-        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
-        # is only valid for completely positive maps.
-        if not self.iscp:
-            raise ValueError("Dual channels are only implemented for CP maps.")
-        J = to_choi(self)
-        tensor_idxs = enumerate_flat(J.dims)
-        J_dual = tensor_swap(J, *(
-                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
-                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
-        )).trans()
-        J_dual.superrep = 'choi'
-        return J_dual
-
-    def norm(self, norm=None, kwargs=None):
-        """
-        Norm of a quantum object.
-
-        Default norm is L2-norm for kets and trace-norm for operators.  Other
-        ket and operator norms may be specified using the `norm` parameter.
-
-        Parameters
-        ----------
-        norm : str
-            Which type of norm to use.  Allowed values for vectors are 'l2' and
-            'max'.  Allowed values for matrices are 'tr' for the trace norm,
-            'fro' for the Frobenius norm, 'one' and 'max'.
-
-        kwargs : dict
-            Additional keyword arguments to pass on to the relevant norm
-            solver.  See details for each norm function in :mod:`.data.norm`.
-
-        Returns
-        -------
-        norm : float
-            The requested norm of the operator or state quantum object.
-        """
-        if self.type in ('oper', 'super'):
-            norm = norm or 'tr'
-            if norm not in _NORM_ALLOWED_MATRIX:
-                raise ValueError(
-                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
-                )
-        else:
-            norm = norm or 'l2'
-            if norm not in _NORM_ALLOWED_VECTOR:
-                raise ValueError(
-                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
-                )
-        kwargs = kwargs or {}
-        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
-
-    def proj(self):
-        """Form the projector from a given ket or bra vector.
-
-        Parameters
-        ----------
-        Q : :class:`qutip.Qobj`
-            Input bra or ket vector
-
-        Returns
-        -------
-        P : :class:`qutip.Qobj`
-            Projection operator.
-        """
-        if not (self.isket or self.isbra):
-            raise TypeError("projection is only defined for bras and kets")
-        dims = ([self.dims[0], self.dims[0]] if self.isket
-                else [self.dims[1], self.dims[1]])
-        return Qobj(_data.project(self._data),
-                    dims=dims,
-                    type='oper',
-                    isherm=True,
-                    copy=False)
-
-    def tr(self):
-        """Trace of a quantum object.
-
-        Returns
-        -------
-        trace : float
-            Returns the trace of the quantum object.
-
-        """
-        out = _data.trace(self._data)
-        # This ensures that trace can return something that is not a number such
-        # as a `tensorflow.Tensor` in qutip-tensorflow.
-        return out.real if (self.isherm
-                        and hasattr(out, "real")
-                        ) else out
-
-    def purity(self):
-        """Calculate purity of a quantum object.
-
-        Returns
-        -------
-        state_purity : float
-            Returns the purity of a quantum object.
-            For a pure state, the purity is 1.
-            For a mixed state of dimension `d`, 1/d<=purity<1.
-
-        """
-        if self.type in ("super", "operator-ket", "operator-bra"):
-            raise TypeError('purity is only defined for states.')
-        if self.isket or self.isbra:
-            return _data.norm.l2(self.data)**2
-        return _data.trace(_data.matmul(self.data, self.data)).real
-
-    def full(self, order='C', squeeze=False):
-        """Dense array from quantum object.
-
-        Parameters
-        ----------
-        order : str {'C', 'F'}
-            Return array in C (default) or Fortran ordering.
-        squeeze : bool {False, True}
-            Squeeze output array.
-
-        Returns
-        -------
-        data : array
-            Array of complex data from quantum objects `data` attribute.
-        """
-        out = np.asarray(self.data.to_array(), order=order)
-        return out.squeeze() if squeeze else out
-
-    def diag(self):
-        """Diagonal elements of quantum object.
-
-        Returns
-        -------
-        diags : array
-            Returns array of ``real`` values if operators is Hermitian,
-            otherwise ``complex`` values are returned.
-        """
-        # TODO: add a `diagonal` method to the data layer?
-        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
-        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
-            return out
-        else:
-            return np.real(out)
-
-    def expm(self, dtype=_data.Dense):
-        """Matrix exponential of quantum operator.
-
-        Input operator must be square.
-
-        Parameters
-        ----------
-        dtype : type
-            The data-layer type that should be output.  As the matrix
-            exponential is almost dense, this defaults to outputting dense
-            matrices.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Exponentiated quantum operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum operator is not square.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError("expm is only valid for square operators")
-        return Qobj(_data.expm(self._data, dtype=dtype),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    copy=False)
-
-    def logm(self):
-        """Matrix logarithm of quantum operator.
-
-        Input operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Logarithm of the quantum operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum operator is not square.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError("expm is only valid for square operators")
-        return Qobj(_data.logm(self._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    copy=False)
-
-    def check_herm(self):
-        """Check if the quantum object is hermitian.
-
-        Returns
-        -------
-        isherm : bool
-            Returns the new value of isherm property.
-        """
-        self._isherm = None
-        return self.isherm
-
-    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
-        """
-        Sqrt of a quantum operator.  Operator must be square.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse eigenvalue/vector solver.
-        tol : float
-            Tolerance used by sparse solver (0 = machine precision).
-        maxiter : int
-            Maximum number of iterations used by sparse solver.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix square root of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError('sqrt only valid on square matrices')
-        if isinstance(self.data, _data.CSR) and sparse:
-            evals, evecs = _data.eigs_csr(self.data,
-                                          isherm=self._isherm,
-                                          tol=tol, maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
-            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
-                                      isherm=self._isherm)
-        else:
-            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
-
-        numevals = len(evals)
-        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
-        if self.isherm:
-            spDv = _data.matmul(dV, evecs.conj().transpose())
-        else:
-            spDv = _data.matmul(dV, _data.inv(evecs))
-        return Qobj(_data.matmul(evecs, spDv),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def cosm(self):
-        """Cosine of a quantum operator.
-
-        Operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix cosine of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-
-        Notes
-        -----
-        Uses the Q.expm() method.
-
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError('invalid operand for matrix cosine')
-        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
-
-    def sinm(self):
-        """Sine of a quantum operator.
-
-        Operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix sine of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-
-        Notes
-        -----
-        Uses the Q.expm() method.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError('invalid operand for matrix sine')
-        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
-
-    def inv(self, sparse=False):
-        """Matrix inverse of a quantum operator
-
-        Operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix inverse of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-        """
-        if self.data.shape[0] != self.data.shape[1]:
-            raise TypeError('Invalid operand for matrix inverse')
-        if isinstance(self.data, _data.CSR) and not sparse:
-            data = _data.to(_data.Dense, self.data)
-        else:
-            data = self.data
-
-        return Qobj(_data.inv(data),
-                    dims=[self.dims[1], self.dims[0]],
-                    type=self.type,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def unit(self, inplace=False, norm=None, kwargs=None):
-        """
-        Operator or state normalized to unity.  Uses norm from Qobj.norm().
-
-        Parameters
-        ----------
-        inplace : bool
-            Do an in-place normalization
-        norm : str
-            Requested norm for states / operators.
-        kwargs : dict
-            Additional key-word arguments to be passed on to the relevant norm
-            function (see :meth:`.norm` for more details).
-
-        Returns
-        -------
-        obj : :class:`qutip.Qobj`
-            Normalized quantum object.  Will be the `self` object if in place.
-        """
-        norm = self.norm(norm=norm, kwargs=kwargs)
-        if inplace:
-            self.data = _data.mul(self.data, 1 / norm)
-            self._isherm = self._isherm if norm.imag == 0 else None
-            self._isunitary = (self._isunitary
-                               if abs(norm) - 1 < settings.core['atol']
-                               else None)
-            out = self
-        else:
-            out = self / norm
-        return out
-
-    def ptrace(self, sel, dtype=None):
-        """
-        Take the partial trace of the quantum object leaving the selected
-        subspaces.  In other words, trace out all subspaces which are _not_
-        passed.
-
-        This is typically a function which acts on operators; bras and kets
-        will be promoted to density matrices before the operation takes place
-        since the partial trace is inherently undefined on pure states.
-
-        For operators which are currently being represented as states in the
-        superoperator formalism (i.e. the object has type `operator-ket` or
-        `operator-bra`), the partial trace is applied as if the operator were
-        in the conventional form.  This means that for any operator `x`,
-        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
-        and similar for `operator-bra`.
-
-        The story is different for full superoperators.  In the formalism that
-        QuTiP uses, if an operator has dimensions (`dims`) of
-        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
-        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
-        operator which acts on this joint space.  This function performs the
-        partial trace on superoperators by letting the selected components
-        refer to elements of the _joint_ _space_, and then returns a regular
-        operator (of type `oper`).
-
-        Parameters
-        ----------
-        sel : int or iterable of int
-            An ``int`` or ``list`` of components to keep after partial trace.
-            The selected subspaces will _not_ be reordered, no matter order
-            they are supplied to `ptrace`.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Quantum object representing partial trace with selected components
-            remaining.
-        """
-        try:
-            sel = sorted(sel)
-        except TypeError:
-            if not isinstance(sel, numbers.Integral):
-                raise TypeError(
-                    "selection must be an integer or list of integers"
-                ) from None
-            sel = [sel]
-        if self.isoperket:
-            dims = self.dims[0]
-            data = vector_to_operator(self).data
-        elif self.isoperbra:
-            dims = self.dims[1]
-            data = vector_to_operator(self.dag()).data
-        elif self.issuper or self.isoper:
-            dims = self.dims
-            data = self.data
-        else:
-            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
-            data = _data.project(self.data)
-        if dims[0] != dims[1]:
-            raise ValueError("partial trace is not defined on non-square maps")
-        dims = flatten(dims[0])
-        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
-        new_dims = [[dims[x] for x in sel]] * 2
-        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
-        if self.isoperket:
-            return operator_to_vector(out)
-        if self.isoperbra:
-            return operator_to_vector(out).dag()
-        return out
-
-    def contract(self, inplace=False):
-        """
-        Contract subspaces of the tensor structure which are 1D.  Not defined
-        on superoperators.  If all dimensions are scalar, a Qobj of dimension
-        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
-        contracted, but one is left.
-
-        Parameters
-        ----------
-        inplace: bool, optional
-            If ``True``, modify the dimensions in place.  If ``False``, return
-            a copied object.
-
-        Returns
-        -------
-        out: :class:`.Qobj`
-            Quantum object with dimensions contracted.  Will be ``self`` if
-            ``inplace`` is ``True``.
-        """
-        if self.isket:
-            sub = [x for x in self.dims[0] if x > 1] or [1]
-            dims = [sub, [1]*len(sub)]
-        elif self.isbra:
-            sub = [x for x in self.dims[1] if x > 1] or [1]
-            dims = [[1]*len(sub), sub]
-        elif self.isoper or self.isoperket or self.isoperbra:
-            if self.isoper:
-                oper_dims = self.dims
-            elif self.isoperket:
-                oper_dims = self.dims[0]
-            else:
-                oper_dims = self.dims[1]
-            if len(oper_dims[0]) != len(oper_dims[1]):
-                raise ValueError("cannot parse Qobj dimensions: "
-                                 + repr(self.dims))
-            dims_ = [
-                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
-                if x > 1 or y > 1
-            ] or [(1, 1)]
-            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
-            if self.isoperket:
-                dims = [dims, [1]]
-            elif self.isoperbra:
-                dims = [[1], dims]
-        else:
-            raise TypeError("not defined for superoperators")
-        if inplace:
-            self.dims = dims
-            return self
-        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
-
-    def permute(self, order):
-        """
-        Permute the tensor structure of a quantum object.  For example,
-        ``qutip.tensor(x, y).permute([1, 0])``
-        will give the same result as
-        ``qutip.tensor(y, x)``
-        and
-        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
-        will be the same as
-        ``qutip.tensor(b, c, a)``
-
-        For regular objects (bras, kets and operators) we expect ``order`` to
-        be a flat list of integers, which specifies the new order of the tensor
-        product.
-
-        For superoperators, we expect ``order`` to be something like
-        ``[[0, 2], [1, 3]]``
-        which tells us to permute according to [0, 2, 1, 3], and then group
-        indices according to the length of each sublist.  As another example,
-        permuting a superoperator with dimensions of
-        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
-        by an ``order``
-        ``[[0, 3], [1, 4], [2, 5]]``
-        should give a new object with dimensions
-        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
-
-        Parameters
-        ----------
-        order : list
-            List of indices specifying the new tensor order.
-
-        Returns
-        -------
-        P : :class:`qutip.Qobj`
-            Permuted quantum object.
-        """
-        if self.type in ('bra', 'ket', 'oper'):
-            structure = self.dims[1] if self.isbra else self.dims[0]
-            new_structure = [structure[x] for x in order]
-            if self.isbra:
-                dims = [self.dims[0], new_structure]
-            elif self.isket:
-                dims = [new_structure, self.dims[1]]
-            else:
-                if self.dims[0] != self.dims[1]:
-                    raise TypeError("undefined for non-square operators")
-                dims = [new_structure, new_structure]
-            data = _data.permute.dimensions(self.data, structure, order)
-            return Qobj(data,
-                        dims=dims,
-                        type=self.type,
-                        isherm=self._isherm,
-                        isunitary=self._isunitary,
-                        copy=False)
-        # If we've got here, we're some form of superoperator, so we work with
-        # the flattened structure.
-        flat_order = flatten(order)
-        flat_structure = flatten(self.dims[1] if self.isoperbra
-                                 else self.dims[0])
-        new_structure = unflatten([flat_structure[x] for x in flat_order],
-                                  enumerate_flat(order))
-        if self.isoperbra:
-            dims = [self.dims[0], new_structure]
-        elif self.isoperket:
-            dims = [new_structure, self.dims[1]]
-        else:
-            if self.dims[0] != self.dims[1]:
-                raise TypeError("undefined for non-square operators")
-            dims = [new_structure, new_structure]
-        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
-        return Qobj(data,
-                    dims=dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def tidyup(self, atol=None):
-        """
-        Removes small elements from the quantum object.
-
-        Parameters
-        ----------
-        atol : float
-            Absolute tolerance used by tidyup. Default is set
-            via qutip global settings parameters.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Quantum object with small elements removed.
-        """
-        atol = atol or settings.core['auto_tidyup_atol']
-        self.data = _data.tidyup(self.data, atol)
-        return self
-
-    def transform(self, inpt, inverse=False):
-        """Basis transform defined by input array.
-
-        Input array can be a ``matrix`` defining the transformation,
-        or a ``list`` of kets that defines the new basis.
-
-        Parameters
-        ----------
-        inpt : array_like
-            A ``matrix`` or ``list`` of kets defining the transformation.
-        inverse : bool
-            Whether to return inverse transformation.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Operator in new basis.
-
-        Notes
-        -----
-        This function is still in development.
-        """
-        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
-                                      inpt.ndim == 1):
-            if len(inpt) != max(self.shape):
-                raise TypeError(
-                    'Invalid size of ket list for basis transformation')
-            base = np.hstack([psi.full() for psi in inpt])
-            S = _data.adjoint(_data.create(base))
-        elif isinstance(inpt, Qobj) and inpt.isoper:
-            S = inpt.data
-        elif isinstance(inpt, np.ndarray):
-            S = _data.create(inpt).conj()
-        else:
-            raise TypeError('Invalid operand for basis transformation')
-
-        # transform data
-        if inverse:
-            if self.isket:
-                data = _data.matmul(S.adjoint(), self.data)
-            elif self.isbra:
-                data = _data.matmul(self.data, S)
-            else:
-                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
-        else:
-            if self.isket:
-                data = _data.matmul(S, self.data)
-            elif self.isbra:
-                data = _data.matmul(self.data, S.adjoint())
-            else:
-                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
-        return Qobj(data,
-                    dims=self.dims,
-                    type=self.type,
-                    isherm=self._isherm,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def trunc_neg(self, method="clip"):
-        """Truncates negative eigenvalues and renormalizes.
-
-        Returns a new Qobj by removing the negative eigenvalues
-        of this instance, then renormalizing to obtain a valid density
-        operator.
-
-
-        Parameters
-        ----------
-        method : str
-            Algorithm to use to remove negative eigenvalues. "clip"
-            simply discards negative eigenvalues, then renormalizes.
-            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
-            positive operator that is nearest in the Shatten 2-norm.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            A valid density operator.
-        """
-        if not self.isherm:
-            raise ValueError("Must be a Hermitian operator to remove negative "
-                             "eigenvalues.")
-        if method not in ('clip', 'sgs'):
-            raise ValueError("Method {} not recognized.".format(method))
-
-        eigvals, eigstates = self.eigenstates()
-        if all(eigval >= 0 for eigval in eigvals):
-            # All positive, so just renormalize.
-            return self.unit()
-        idx_nonzero = eigvals != 0
-        eigvals = eigvals[idx_nonzero]
-        eigstates = eigstates[idx_nonzero]
-
-        if method == 'clip':
-            eigvals[eigvals < 0] = 0
-        elif method == 'sgs':
-            eigvals = eigvals[::-1]
-            eigstates = eigstates[::-1]
-            acc = 0.0
-            n_eigs = len(eigvals)
-            for idx in reversed(range(n_eigs)):
-                if eigvals[idx] + acc / (idx + 1) >= 0:
-                    break
-                acc += eigvals[idx]
-                eigvals[idx] = 0.0
-            eigvals[:idx+1] += acc / (idx + 1)
-        out_data = _data.zeros(*self.shape)
-        for value, state in zip(eigvals, eigstates):
-            if value:
-                # add in 3-argument form is fused-add-multiply
-                out_data = _data.add(out_data,
-                                     _data.project(state.data),
-                                     value)
-        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
-        return Qobj(out_data,
-                    dims=self.dims.copy(),
-                    type=self.type,
-                    isherm=True,
-                    copy=False)
-
-    def matrix_element(self, bra, ket):
-        """Calculates a matrix element.
-
-        Gives the matrix element for the quantum object sandwiched between a
-        `bra` and `ket` vector.
-
-        Parameters
-        ----------
-        bra : :class:`qutip.Qobj`
-            Quantum object of type 'bra' or 'ket'
-
-        ket : :class:`qutip.Qobj`
-            Quantum object of type 'ket'.
-
-        Returns
-        -------
-        elem : complex
-            Complex valued matrix element.
-
-        Notes
-        -----
-        It is slightly more computationally efficient to use a ket
-        vector for the 'bra' input.
-
-        """
-        if not self.isoper:
-            raise TypeError("Can only get matrix elements for an operator.")
-        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
-            msg = "Can only calculate matrix elements between a bra and a ket."
-            raise TypeError(msg)
-        left, op, right = bra.data, self.data, ket.data
-        if ket.isbra:
-            right = right.adjoint()
-        return _data.inner_op(left, op, right, bra.isket)
-
-    def overlap(self, other):
-        """
-        Overlap between two state vectors or two operators.
-
-        Gives the overlap (inner product) between the current bra or ket Qobj
-        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
-        when one of the Qobj is an operator/density matrix.
-
-        Parameters
-        ----------
-        other : :class:`qutip.Qobj`
-            Quantum object for a state vector of type 'ket', 'bra' or density
-            matrix.
-
-        Returns
-        -------
-        overlap : complex
-            Complex valued overlap.
-
-        Raises
-        ------
-        TypeError
-            Can only calculate overlap between a bra, ket and density matrix
-            quantum objects.
-        """
-        if not isinstance(other, Qobj):
-            raise TypeError("".join([
-                "cannot calculate overlap with non-quantum object ",
-                repr(other),
-            ]))
-        if (
-            self.type not in ('ket', 'bra', 'oper')
-            or other.type not in ('ket', 'bra', 'oper')
-        ):
-            msg = "only bras, kets and density matrices have defined overlaps"
-            raise TypeError(msg)
-        left, right = self._data.adjoint(), other.data
-        if self.isoper or other.isoper:
-            if not self.isoper:
-                left = _data.project(left)
-            if not other.isoper:
-                right = _data.project(right)
-            return _data.trace(_data.matmul(left, right))
-        if other.isbra:
-            right = right.adjoint()
-        out = _data.inner(left, right, self.isket)
-        if self.isket and other.isbra:
-            # In this particular case, we've basically doing
-            #   conj(other.overlap(self))
-            # so we take care to conjugate the output.
-            out = np.conj(out)
-        return out
-
-    def eigenstates(self, sparse=False, sort='low', eigvals=0,
-                    tol=0, maxiter=100000, phase_fix=None):
-        """Eigenstates and eigenenergies.
-
-        Eigenstates and eigenenergies are defined for operators and
-        superoperators only.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse Eigensolver
-
-        sort : str
-            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
-
-        eigvals : int
-            Number of requested eigenvalues. Default is all eigenvalues.
-
-        tol : float
-            Tolerance used by sparse Eigensolver (0 = machine precision).
-            The sparse solver may not converge if the tolerance is set too low.
-
-        maxiter : int
-            Maximum number of iterations performed by sparse solver (if used).
-
-        phase_fix : int, None
-            If not None, set the phase of each kets so that ket[phase_fix,0]
-            is real positive.
-
-        Returns
-        -------
-        eigvals : array
-            Array of eigenvalues for operator.
-
-        eigvecs : array
-            Array of quantum operators representing the oprator eigenkets.
-            Order of eigenkets is determined by order of eigenvalues.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-
-        """
-        if isinstance(self.data, _data.CSR) and sparse:
-            evals, evecs = _data.eigs_csr(self.data,
-                                          isherm=self._isherm,
-                                          sort=sort, eigvals=eigvals, tol=tol,
-                                          maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
-            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
-                                      isherm=self._isherm,
-                                      sort=sort, eigvals=eigvals)
-        else:
-            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
-                                      sort=sort, eigvals=eigvals)
-
-        if self.type == 'super':
-            new_dims = [self.dims[0], [1]]
-            new_type = 'operator-ket'
-        else:
-            new_dims = [self.dims[0], [1]*len(self.dims[0])]
-            new_type = 'ket'
-        ekets = np.empty((evecs.shape[1],), dtype=object)
-        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
-                    for vec in _data.split_columns(evecs, False)]
-        norms = np.array([ket.norm() for ket in ekets])
-        if phase_fix is None:
-            phase = np.array([1] * len(ekets))
-        else:
-            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
-                              if ket[phase_fix, 0] else 1
-                              for ket in ekets])
-        return evals, ekets / norms * phase
-
-    def eigenenergies(self, sparse=False, sort='low',
-                      eigvals=0, tol=0, maxiter=100000):
-        """Eigenenergies of a quantum object.
-
-        Eigenenergies (eigenvalues) are defined for operators or superoperators
-        only.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse Eigensolver
-        sort : str
-            Sort eigenvalues 'low' to high, or 'high' to low.
-        eigvals : int
-            Number of requested eigenvalues. Default is all eigenvalues.
-        tol : float
-            Tolerance used by sparse Eigensolver (0=machine precision).
-            The sparse solver may not converge if the tolerance is set too low.
-        maxiter : int
-            Maximum number of iterations performed by sparse solver (if used).
-
-        Returns
-        -------
-        eigvals : array
-            Array of eigenvalues for operator.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-
-        """
-        # TODO: consider another way of handling the dispatch here.
-        if isinstance(self.data, _data.CSR) and sparse:
-            return _data.eigs_csr(self.data,
-                                  vecs=False,
-                                  isherm=self._isherm,
-                                  sort=sort, eigvals=eigvals,
-                                  tol=tol, maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
-            return _data.eigs(_data.to(_data.Dense, self.data),
-                              vecs=False, isherm=self._isherm,
-                              sort=sort, eigvals=eigvals)
-
-        return _data.eigs(self.data,
-                          vecs=False,
-                          isherm=self._isherm, sort=sort, eigvals=eigvals)
-
-    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
-        """Ground state Eigenvalue and Eigenvector.
-
-        Defined for quantum operators or superoperators only.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse Eigensolver
-        tol : float
-            Tolerance used by sparse Eigensolver (0 = machine precision).
-            The sparse solver may not converge if the tolerance is set too low.
-        maxiter : int
-            Maximum number of iterations performed by sparse solver (if used).
-        safe : bool (default=True)
-            Check for degenerate ground state
-
-        Returns
-        -------
-        eigval : float
-            Eigenvalue for the ground state of quantum operator.
-        eigvec : :class:`qutip.Qobj`
-            Eigenket for the ground state of quantum operator.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-        """
-        eigvals = 2 if safe else 1
-        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
-                                        tol=tol, maxiter=maxiter)
-
-        if safe:
-            tol = tol or settings.core['atol']
-            # This tol should be less strick than the tol for the eigensolver
-            # so it's numerical errors are not seens as degenerate states.
-            if (evals[1]-evals[0]) <= 10 * tol:
-                warnings.warn("Ground state may be degenerate.", UserWarning)
-        return evals[0], evecs[0]
-
-    def dnorm(self, B=None):
-        """Calculates the diamond norm, or the diamond distance to another
-        operator.
-
-        Parameters
-        ----------
-        B : :class:`qutip.Qobj` or None
-            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
-            between this operator and B is returned instead of the diamond norm.
-
-        Returns
-        -------
-        d : float
-            Either the diamond norm of this operator, or the diamond distance
-            from this operator to B.
-
-        """
-        return mts.dnorm(self, B)
-
-    @property
-    def ishp(self):
-        # FIXME: this needs to be cached in the same ways as isherm.
-        if self.type in ["super", "oper"]:
-            try:
-                J = to_choi(self)
-                return J.isherm
-            except:
-                return False
-        else:
-            return False
-
-    @property
-    def iscp(self):
-        # FIXME: this needs to be cached in the same ways as isherm.
-        if self.type not in ["super", "oper"]:
-            return False
-        # We can test with either Choi or chi, since the basis
-        # transformation between them is unitary and hence preserves
-        # the CP and TP conditions.
-        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
-        # If J isn't hermitian, then that could indicate either that J is not
-        # normal, or is normal, but has complex eigenvalues.  In either case,
-        # it makes no sense to then demand that the eigenvalues be
-        # non-negative.
-        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
-
-    @property
-    def istp(self):
-        if self.type not in ['super', 'oper']:
-            return False
-        # Normalize to a super of type choi or chi.
-        # We can test with either Choi or chi, since the basis
-        # transformation between them is unitary and hence
-        # preserves the CP and TP conditions.
-        if self.issuper and self.superrep in ('choi', 'chi'):
-            qobj = self
-        else:
-            qobj = to_choi(self)
-        # Possibly collapse dims.
-        if any([len(index) > 1
-                for super_index in qobj.dims
-                for index in super_index]):
-            qobj = Qobj(qobj.data,
-                        dims=collapse_dims_super(qobj.dims),
-                        type=qobj.type,
-                        superrep=qobj.superrep,
-                        copy=False)
-        # We use the condition from John Watrous' lecture notes,
-        # Tr_1(J(Phi)) = identity_2.
-        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
-        # Theory of Quantum Information (Fall 2011), theorem 5.4.
-        tr_oper = qobj.ptrace([0])
-        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
-                           atol=settings.core['atol'])
-
-    @property
-    def iscptp(self):
-        if not (self.issuper or self.isoper):
-            return False
-        reps = ('choi', 'chi')
-        q_oper = to_choi(self) if self.superrep not in reps else self
-        return q_oper.iscp and q_oper.istp
-
-    @property
-    def isherm(self):
-        if self._isherm is not None:
-            return self._isherm
-        self._isherm = _data.isherm(self._data)
-        return self._isherm
-
-    @isherm.setter
-    def isherm(self, isherm):
-        self._isherm = isherm
-
-    def _calculate_isunitary(self):
-        """
-        Checks whether qobj is a unitary matrix
-        """
-        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
-            return False
-        cmp = _data.matmul(self._data, self._data.adjoint())
-        iden = _data.identity(self.shape[0], dtype=type(cmp))
-        return _data.iszero(_data.sub(cmp, iden),
-                            tol=settings.core['atol'])
-
-    @property
-    def isunitary(self):
-        if self._isunitary is not None:
-            return self._isunitary
-        self._isunitary = self._calculate_isunitary()
-        return self._isunitary
-
-    @property
-    def shape(self): return self.data.shape
-
-    isbra = property(isbra)
-    isket = property(isket)
-    isoper = property(isoper)
-    issuper = property(issuper)
-    isoperbra = property(isoperbra)
-    isoperket = property(isoperket)
-
-
-def ptrace(Q, sel):
-    """
-    Partial trace of the Qobj with selected components remaining.
-
-    Parameters
-    ----------
-    Q : :class:`qutip.Qobj`
-        Composite quantum object.
-    sel : int/list
-        An ``int`` or ``list`` of components to keep after partial trace.
-
-    Returns
-    -------
-    oper : :class:`qutip.Qobj`
-        Quantum object representing partial trace with selected components
-        remaining.
-
-    Notes
-    -----
-    This function is for legacy compatibility only. It is recommended to use
-    the ``ptrace()`` Qobj method.
-    """
-    if not isinstance(Q, Qobj):
-        raise TypeError("Input is not a quantum object")
-    return Q.ptrace(sel)
-
-
-# TRAILING IMPORTS
-# We do a few imports here to avoid circular dependencies.
-from qutip.core.superop_reps import to_choi
-from qutip.core.superoperator import vector_to_operator, operator_to_vector
-from qutip.core.tensor import tensor_swap, tensor
-from qutip.core import metrics as mts
+"""The Quantum Object (Qobj) class, for representing quantum states and
+operators, and related functions.
+"""
+
+__all__ = [
+    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
+    'isherm', 'ptrace',
+]
+
+import functools
+import numbers
+import warnings
+
+import numpy as np
+import scipy.sparse
+
+from .. import __version__
+from ..settings import settings
+from . import data as _data
+from .dimensions import (
+    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
+)
+
+
+_ADJOINT_TYPE_LOOKUP = {
+    'oper': 'oper',
+    'super': 'super',
+    'ket': 'bra',
+    'bra': 'ket',
+    'operator-ket': 'operator-bra',
+    'operator-bra': 'operator-ket',
+}
+
+_MATMUL_TYPE_LOOKUP = {
+    ('oper', 'ket'): 'ket',
+    ('oper', 'oper'): 'oper',
+    ('ket', 'bra'): 'oper',
+    ('bra', 'oper'): 'bra',
+    ('super', 'super'): 'super',
+    ('super', 'operator-ket'): 'operator-ket',
+    ('operator-bra', 'super'): 'operator-bra',
+    ('operator-ket', 'operator-bra'): 'super',
+}
+
+_NORM_FUNCTION_LOOKUP = {
+    'tr': _data.norm.trace,
+    'one': _data.norm.one,
+    'max': _data.norm.max,
+    'fro': _data.norm.frobenius,
+    'l2': _data.norm.l2,
+}
+_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
+_NORM_ALLOWED_VECTOR = {'l2', 'max'}
+
+_CALL_ALLOWED = {
+    ('super', 'oper'),
+    ('super', 'ket'),
+    ('oper', 'ket'),
+}
+
+
+def isbra(x):
+    return isinstance(x, Qobj) and x.type == 'bra'
+
+
+def isket(x):
+    return isinstance(x, Qobj) and x.type == 'ket'
+
+
+def isoper(x):
+    return isinstance(x, Qobj) and x.type == 'oper'
+
+
+def isoperbra(x):
+    return isinstance(x, Qobj) and x.type == 'operator-bra'
+
+
+def isoperket(x):
+    return isinstance(x, Qobj) and x.type == 'operator-ket'
+
+
+def issuper(x):
+    return isinstance(x, Qobj) and x.type == 'super'
+
+
+def isherm(x):
+    return isinstance(x, Qobj) and x.isherm
+
+
+def _require_equal_type(method):
+    """
+    Decorate a binary Qobj method to ensure both operands are Qobj and of the
+    same type and dimensions.  Promote numeric scalar to identity matrices of
+    the same type and shape.
+    """
+    @functools.wraps(method)
+    def out(self, other):
+        if other == 0:
+            return method(self, other)
+        if (
+            self.type in ('oper', 'super')
+            and self.dims[0] == self.dims[1]
+            and isinstance(other, numbers.Number)
+        ):
+            scale = complex(other)
+            other = Qobj(_data.identity(self.shape[0], scale,
+                                        dtype=type(self.data)),
+                         dims=self.dims,
+                         type=self.type,
+                         superrep=self.superrep,
+                         isherm=(scale.imag == 0),
+                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
+                         copy=False)
+        if not isinstance(other, Qobj):
+            try:
+                other = Qobj(other, type=self.type)
+            except TypeError:
+                return NotImplemented
+        if self.dims != other.dims:
+            msg = (
+                "incompatible dimensions "
+                + repr(self.dims) + " and " + repr(other.dims)
+            )
+            raise ValueError(msg)
+        if self.type != other.type:
+            msg = "incompatible types " + self.type + " and " + other.type
+            raise ValueError(msg)
+        if self.superrep != other.superrep:
+            msg = (
+                "incompatible superoperator representations"
+                + self.superrep + " and " + other.superrep
+            )
+            raise ValueError(msg)
+        return method(self, other)
+    return out
+
+
+def _latex_real(x):
+    if not x:
+        return "0"
+    if not 0.001 <= abs(x) < 1000:
+        base, exp = "{:.3e}".format(x).split('e')
+        return base + r"\times10^{{ {:d} }}".format(int(exp))
+    if abs(x - int(x)) < 0.001:
+        return "{:d}".format(round(x))
+    return "{:.3f}".format(x)
+
+
+def _latex_complex(x):
+    if abs(x.imag) < 0.001:
+        return _latex_real(x.real)
+    if abs(x.real) < 0.001:
+        return _latex_real(x.imag) + "j"
+    sign = "+" if x.imag > 0 else "-"
+    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
+
+
+def _latex_row(row, cols, data):
+    if row is None:
+        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
+    else:
+        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
+                for col in cols)
+    return " & ".join(bits)
+
+
+class Qobj:
+    """
+    A class for representing quantum objects, such as quantum operators and
+    states.
+
+    The Qobj class is the QuTiP representation of quantum operators and state
+    vectors. This class also implements math operations +,-,* between Qobj
+    instances (and / by a C-number), as well as a collection of common
+    operator/state operations.  The Qobj constructor optionally takes a
+    dimension ``list`` and/or shape ``list`` as arguments.
+
+    Parameters
+    ----------
+    inpt: array_like
+        Data for vector/matrix representation of the quantum object.
+    dims: list
+        Dimensions of object used for tensor products.
+    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
+        The type of quantum object to be represented.
+    shape: list
+        Shape of underlying data structure (matrix shape).
+    copy: bool
+        Flag specifying whether Qobj should get a copy of the
+        input data, or use the original.
+
+
+    Attributes
+    ----------
+    data : array_like
+        Sparse matrix characterizing the quantum object.
+    dims : list
+        List of dimensions keeping track of the tensor structure.
+    shape : list
+        Shape of the underlying `data` array.
+    type : str
+        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
+        'operator-bra', or 'super'.
+    superrep : str
+        Representation used if `type` is 'super'. One of 'super'
+        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
+    isherm : bool
+        Indicates if quantum object represents Hermitian operator.
+    isunitary : bool
+        Indictaes if quantum object represents unitary operator.
+    iscp : bool
+        Indicates if the quantum object represents a map, and if that map is
+        completely positive (CP).
+    ishp : bool
+        Indicates if the quantum object represents a map, and if that map is
+        hermicity preserving (HP).
+    istp : bool
+        Indicates if the quantum object represents a map, and if that map is
+        trace preserving (TP).
+    iscptp : bool
+        Indicates if the quantum object represents a map that is completely
+        positive and trace preserving (CPTP).
+    isket : bool
+        Indicates if the quantum object represents a ket.
+    isbra : bool
+        Indicates if the quantum object represents a bra.
+    isoper : bool
+        Indicates if the quantum object represents an operator.
+    issuper : bool
+        Indicates if the quantum object represents a superoperator.
+    isoperket : bool
+        Indicates if the quantum object represents an operator in column vector
+        form.
+    isoperbra : bool
+        Indicates if the quantum object represents an operator in row vector
+        form.
+
+    Methods
+    -------
+    copy()
+        Create copy of Qobj
+    conj()
+        Conjugate of quantum object.
+    cosm()
+        Cosine of quantum object.
+    dag()
+        Adjoint (dagger) of quantum object.
+    dnorm()
+        Diamond norm of quantum operator.
+    dual_chan()
+        Dual channel of quantum object representing a CP map.
+    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
+        Returns eigenenergies (eigenvalues) of a quantum object.
+    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
+        Returns eigenenergies and eigenstates of quantum object.
+    expm()
+        Matrix exponential of quantum object.
+    full(order='C')
+        Returns dense array of quantum object `data` attribute.
+    groundstate(sparse=False, tol=0, maxiter=100000)
+        Returns eigenvalue and eigenket for the groundstate of a quantum
+        object.
+    inv()
+        Return a Qobj corresponding to the matrix inverse of the operator.
+    matrix_element(bra, ket)
+        Returns the matrix element of operator between `bra` and `ket` vectors.
+    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
+        Returns norm of a ket or an operator.
+    permute(order)
+        Returns composite qobj with indices reordered.
+    proj()
+        Computes the projector for a ket or bra vector.
+    ptrace(sel)
+        Returns quantum object for selected dimensions after performing
+        partial trace.
+    sinm()
+        Sine of quantum object.
+    sqrtm()
+        Matrix square root of quantum object.
+    tidyup(atol=1e-12)
+        Removes small elements from quantum object.
+    tr()
+        Trace of quantum object.
+    trans()
+        Transpose of quantum object.
+    transform(inpt, inverse=False)
+        Performs a basis transformation defined by `inpt` matrix.
+    trunc_neg(method='clip')
+        Removes negative eigenvalues and returns a new Qobj that is
+        a valid density operator.
+    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
+        Returns normalized quantum object.
+
+    """
+    # Disable ufuncs from acting directly on Qobj.
+    __array_ufunc__ = None
+
+    def _initialize_data(self, arg, dims, copy):
+        if isinstance(arg, _data.Data):
+            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
+            self._data = arg.copy() if copy else arg
+        elif isinstance(arg, Qobj):
+            self.dims = dims or arg.dims.copy()
+            self._data = arg.data.copy() if copy else arg.data
+        elif arg is None or isinstance(arg, numbers.Number):
+            self.dims = dims or [[1], [1]]
+            size = np.prod(self.dims[0])
+            if arg is None:
+                self._data = _data.zeros(size, size)
+            else:
+                self._data = _data.identity(size, scale=complex(arg))
+        else:
+            self._data = _data.create(arg, copy=copy)
+            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
+
+    def __init__(self, arg=None, dims=None, type=None,
+                 copy=True, superrep=None, isherm=None, isunitary=None):
+        self._initialize_data(arg, dims, copy)
+        self.type = type or type_from_dims(self.dims)
+        self._isherm = isherm
+        self._isunitary = isunitary
+
+        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
+            if self._data.shape[0] != self._data.shape[1]:
+                raise ValueError("".join([
+                    "cannot build superoperator from nonsquare data of shape ",
+                    repr(self._data.shape),
+                ]))
+            root = int(np.sqrt(self._data.shape[0]))
+            if root * root != self._data.shape[0]:
+                raise ValueError("".join([
+                    "cannot build superoperator from nonsquare subspaces ",
+                    "of size ",
+                    repr(self._data.shape[0]),
+                ]))
+            self.dims = [[[root]]*2]*2
+        if self.type in ['super', 'operator-ket', 'operator-bra']:
+            superrep = superrep or 'super'
+        self.superrep = superrep
+
+    def copy(self):
+        """Create identical copy"""
+        return Qobj(arg=self._data,
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=True)
+
+    @property
+    def data(self):
+        return self._data
+
+    @data.setter
+    def data(self, data):
+        if not isinstance(data, _data.Data):
+            raise TypeError('Qobj data must be a data-layer format.')
+        self._data = data
+
+    def to(self, data_type):
+        """
+        Convert the underlying data store of this `Qobj` into a different
+        storage representation.
+
+        The different storage representations available are the "data-layer
+        types" which are known to `qutip.data.to`.  By default, these are
+        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
+        dense matrix store and a compressed sparse row one.  Certain algorithms
+        and operations may be faster or more accurate when using a more
+        appropriate data store.
+
+        If the data store is already in the format requested, the function
+        returns `self`.  Otherwise, it returns a copy of itself with the data
+        store in the new type.
+
+        Parameters
+        ----------
+        data_type : type
+            The data-layer type that the data of this `Qobj` should be
+            converted to.
+
+        Returns
+        -------
+        Qobj
+            A new `Qobj` if a type conversion took place with the data stored
+            in the requested format, or `self` if not.
+        """
+        try:
+            converter = _data.to[data_type]
+        except (KeyError, TypeError):
+            raise ValueError("Unknown conversion type: " + str(data_type))
+        if type(self.data) is data_type:
+            return self
+        return Qobj(converter(self._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    @_require_equal_type
+    def __add__(self, other):
+        if other == 0:
+            return self.copy()
+        isherm = (self._isherm and other._isherm) or None
+        return Qobj(_data.add(self._data, other._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=isherm,
+                    copy=False)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    @_require_equal_type
+    def __sub__(self, other):
+        if other == 0:
+            return self.copy()
+        isherm = (self._isherm and other._isherm) or None
+        return Qobj(_data.sub(self._data, other._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=isherm,
+                    copy=False)
+
+    def __rsub__(self, other):
+        return self.__neg__().__add__(other)
+
+    def __mul__(self, other):
+        """
+        If other is a Qobj, we dispatch to __matmul__. If not, we
+        check that other is a valid complex scalar, i.e., we can do
+        complex(other). Otherwise, we return NotImplemented.
+        """
+
+        if isinstance(other, Qobj):
+            return self.__matmul__(other)
+
+        # We send other to mul instead of complex(other) to be more flexible.
+        # The dispatcher can then decide how to handle other and return
+        # TypeError if it does not know what to do with the type of other.
+        try:
+            out = _data.mul(self._data, other)
+        except TypeError:
+            return NotImplemented
+
+        # Infer isherm and isunitary if possible
+        try:
+            multiplier = complex(other)
+            isherm = (self._isherm and multiplier.imag == 0) or None
+            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
+                         if self._isunitary else None)
+        except TypeError:
+            isherm = None
+            isunitary = None
+
+        return Qobj(out,
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=isherm,
+                    isunitary=isunitary,
+                    copy=False)
+
+    def __rmul__(self, other):
+        # Shouldn't be here unless `other.__mul__` has already been tried, so
+        # we _shouldn't_ check that `other` is `Qobj`.
+        return self.__mul__(other)
+
+    def __matmul__(self, other):
+        if not isinstance(other, Qobj):
+            try:
+                other = Qobj(other)
+            except TypeError:
+                return NotImplemented
+        if self.dims[1] != other.dims[0]:
+            raise TypeError("".join([
+                "incompatible dimensions ",
+                repr(self.dims),
+                " and ",
+                repr(other.dims),
+            ]))
+        if self.superrep != other.superrep:
+            raise TypeError("".join([
+                "incompatible superoperator representations ",
+                repr(self.superrep),
+                " and ",
+                repr(other.superrep),
+            ]))
+        if (
+            (self.isbra and other.isket)
+            or (self.isoperbra and other.isoperket)
+        ):
+            return _data.inner(self.data, other.data)
+
+        try:
+            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
+        except KeyError:
+            raise TypeError(
+                "incompatible matmul types "
+                + repr(self.type) + " and " + repr(other.type)
+            ) from None
+        return Qobj(_data.matmul(self.data, other.data),
+                    dims=[self.dims[0], other.dims[1]],
+                    type=type_,
+                    isunitary=self._isunitary and other._isunitary,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def __truediv__(self, other):
+        return self.__mul__(1 / other)
+
+    def __neg__(self):
+        return Qobj(_data.neg(self._data),
+                    dims=self.dims.copy(),
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def __getitem__(self, ind):
+        # TODO: should we require that data-layer types implement this?  This
+        # isn't the right way of handling it, for sure.
+        if isinstance(self._data, _data.CSR):
+            data = self._data.as_scipy()
+        elif isinstance(self._data, _data.Dense):
+            data = self._data.as_ndarray()
+        else:
+            data = self._data
+        try:
+            out = data[ind]
+            return out.toarray() if scipy.sparse.issparse(out) else out
+        except TypeError:
+            pass
+        return data.to_array()[ind]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        if not isinstance(other, Qobj) or self.dims != other.dims:
+            return False
+        return _data.iszero(_data.sub(self._data, other._data),
+                            tol=settings.core['atol'])
+
+    def __pow__(self, n, m=None):  # calculates powers of Qobj
+        if (
+            self.type not in ('oper', 'super')
+            or self.dims[0] != self.dims[1]
+            or m is not None
+            or not isinstance(n, numbers.Integral)
+            or n < 0
+        ):
+            return NotImplemented
+        return Qobj(_data.pow(self._data, n),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def _str_header(self):
+        out = ", ".join([
+            "Quantum object: dims=" + str(self.dims),
+            "shape=" + str(self.data.shape),
+            "type=" + repr(self.type),
+        ])
+        if self.type in ('oper', 'super'):
+            out += ", isherm=" + str(self.isherm)
+        if self.issuper and self.superrep != 'super':
+            out += ", superrep=" + repr(self.superrep)
+        return out
+
+    def __str__(self):
+        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
+            # If the system is huge, don't attempt to convert to a dense matrix
+            # and then to string, because it is pointless and is likely going
+            # to produce memory errors. Instead print the sparse data string
+            # representation.
+            data = _data.to(_data.CSR, self.data).as_scipy()
+        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
+            data = np.real(self.full())
+        else:
+            data = self.full()
+        return self._str_header() + "\nQobj data =\n" + str(data)
+
+    def __repr__(self):
+        # give complete information on Qobj without print statement in
+        # command-line we cant realistically serialize a Qobj into a string,
+        # so we simply return the informal __str__ representation instead.)
+        return self.__str__()
+
+    def __call__(self, other):
+        """
+        Acts this Qobj on another Qobj either by left-multiplication,
+        or by vectorization and devectorization, as
+        appropriate.
+        """
+        if not isinstance(other, Qobj):
+            raise TypeError("Only defined for quantum objects.")
+        if (self.type, other.type) not in _CALL_ALLOWED:
+            raise TypeError(self.type + " cannot act on " + other.type)
+        if self.issuper:
+            if other.isket:
+                other = other.proj()
+            return vector_to_operator(self @ operator_to_vector(other))
+        return self.__matmul__(other)
+
+    def __getstate__(self):
+        # defines what happens when Qobj object gets pickled
+        self.__dict__.update({'qutip_version': __version__[:5]})
+        return self.__dict__
+
+    def __setstate__(self, state):
+        # defines what happens when loading a pickled Qobj
+        if 'qutip_version' in state.keys():
+            del state['qutip_version']
+        (self.__dict__).update(state)
+
+    def _repr_latex_(self):
+        """
+        Generate a LaTeX representation of the Qobj instance. Can be used for
+        formatted output in ipython notebook.
+        """
+        half_length = 5
+        n_rows, n_cols = self.data.shape
+        # Choose which rows and columns we're going to output, or None if that
+        # element should be truncated.
+        rows = list(range(min((half_length, n_rows))))
+        if n_rows <= half_length * 2:
+            rows += list(range(half_length, min((2*half_length, n_rows))))
+        else:
+            rows.append(None)
+            rows += list(range(n_rows - half_length, n_rows))
+        cols = list(range(min((half_length, n_cols))))
+        if n_cols <= half_length * 2:
+            cols += list(range(half_length, min((2*half_length, n_cols))))
+        else:
+            cols.append(None)
+            cols += list(range(n_cols - half_length, n_cols))
+        # Make the data array.
+        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
+        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
+                           for row in rows)
+        data += r'\end{array}\right)\end{equation*}'
+        return self._str_header() + data
+
+    def __and__(self, other):
+        """
+        Syntax shortcut for tensor:
+        A & B ==> tensor(A, B)
+        """
+        return tensor(self, other)
+
+    def dag(self):
+        """Get the Hermitian adjoint of the quantum object."""
+        if self._isherm:
+            return self.copy()
+        return Qobj(_data.adjoint(self._data),
+                    dims=[self.dims[1], self.dims[0]],
+                    type=_ADJOINT_TYPE_LOOKUP[self.type],
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def conj(self):
+        """Get the element-wise conjugation of the quantum object."""
+        return Qobj(_data.conj(self._data),
+                    dims=self.dims.copy(),
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def trans(self):
+        """Get the matrix transpose of the quantum operator.
+
+        Returns
+        -------
+        oper : :class:`.Qobj`
+            Transpose of input operator.
+        """
+        return Qobj(_data.transpose(self._data),
+                    dims=[self.dims[1], self.dims[0]],
+                    type=_ADJOINT_TYPE_LOOKUP[self.type],
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def dual_chan(self):
+        """Dual channel of quantum object representing a completely positive
+        map.
+        """
+        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
+        # is only valid for completely positive maps.
+        if not self.iscp:
+            raise ValueError("Dual channels are only implemented for CP maps.")
+        J = to_choi(self)
+        tensor_idxs = enumerate_flat(J.dims)
+        J_dual = tensor_swap(J, *(
+                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
+                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
+        )).trans()
+        J_dual.superrep = 'choi'
+        return J_dual
+
+    def norm(self, norm=None, kwargs=None):
+        """
+        Norm of a quantum object.
+
+        Default norm is L2-norm for kets and trace-norm for operators.  Other
+        ket and operator norms may be specified using the `norm` parameter.
+
+        Parameters
+        ----------
+        norm : str
+            Which type of norm to use.  Allowed values for vectors are 'l2' and
+            'max'.  Allowed values for matrices are 'tr' for the trace norm,
+            'fro' for the Frobenius norm, 'one' and 'max'.
+
+        kwargs : dict
+            Additional keyword arguments to pass on to the relevant norm
+            solver.  See details for each norm function in :mod:`.data.norm`.
+
+        Returns
+        -------
+        norm : float
+            The requested norm of the operator or state quantum object.
+        """
+        if self.type in ('oper', 'super'):
+            norm = norm or 'tr'
+            if norm not in _NORM_ALLOWED_MATRIX:
+                raise ValueError(
+                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
+                )
+        else:
+            norm = norm or 'l2'
+            if norm not in _NORM_ALLOWED_VECTOR:
+                raise ValueError(
+                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
+                )
+        kwargs = kwargs or {}
+        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
+
+    def proj(self):
+        """Form the projector from a given ket or bra vector.
+
+        Parameters
+        ----------
+        Q : :class:`qutip.Qobj`
+            Input bra or ket vector
+
+        Returns
+        -------
+        P : :class:`qutip.Qobj`
+            Projection operator.
+        """
+        if not (self.isket or self.isbra):
+            raise TypeError("projection is only defined for bras and kets")
+        dims = ([self.dims[0], self.dims[0]] if self.isket
+                else [self.dims[1], self.dims[1]])
+        return Qobj(_data.project(self._data),
+                    dims=dims,
+                    type='oper',
+                    isherm=True,
+                    copy=False)
+
+    def tr(self):
+        """Trace of a quantum object.
+
+        Returns
+        -------
+        trace : float
+            Returns the trace of the quantum object.
+
+        """
+        out = _data.trace(self._data)
+        # This ensures that trace can return something that is not a number such
+        # as a `tensorflow.Tensor` in qutip-tensorflow.
+        return out.real if (self.isherm
+                        and hasattr(out, "real")
+                        ) else out
+
+    def purity(self):
+        """Calculate purity of a quantum object.
+
+        Returns
+        -------
+        state_purity : float
+            Returns the purity of a quantum object.
+            For a pure state, the purity is 1.
+            For a mixed state of dimension `d`, 1/d<=purity<1.
+
+        """
+        if self.type in ("super", "operator-ket", "operator-bra"):
+            raise TypeError('purity is only defined for states.')
+        if self.isket or self.isbra:
+            return _data.norm.l2(self.data)**2
+        return _data.trace(_data.matmul(self.data, self.data)).real
+
+    def full(self, order='C', squeeze=False):
+        """Dense array from quantum object.
+
+        Parameters
+        ----------
+        order : str {'C', 'F'}
+            Return array in C (default) or Fortran ordering.
+        squeeze : bool {False, True}
+            Squeeze output array.
+
+        Returns
+        -------
+        data : array
+            Array of complex data from quantum objects `data` attribute.
+        """
+        out = np.asarray(self.data.to_array(), order=order)
+        return out.squeeze() if squeeze else out
+
+    def diag(self):
+        """Diagonal elements of quantum object.
+
+        Returns
+        -------
+        diags : array
+            Returns array of ``real`` values if operators is Hermitian,
+            otherwise ``complex`` values are returned.
+        """
+        # TODO: add a `diagonal` method to the data layer?
+        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
+        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
+            return out
+        else:
+            return np.real(out)
+
+    def expm(self, dtype=_data.Dense):
+        """Matrix exponential of quantum operator.
+
+        Input operator must be square.
+
+        Parameters
+        ----------
+        dtype : type
+            The data-layer type that should be output.  As the matrix
+            exponential is almost dense, this defaults to outputting dense
+            matrices.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Exponentiated quantum operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum operator is not square.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError("expm is only valid for square operators")
+        return Qobj(_data.expm(self._data, dtype=dtype),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    copy=False)
+
+    def logm(self):
+        """Matrix logarithm of quantum operator.
+
+        Input operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Logarithm of the quantum operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum operator is not square.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError("expm is only valid for square operators")
+        return Qobj(_data.logm(self._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    copy=False)
+
+    def check_herm(self):
+        """Check if the quantum object is hermitian.
+
+        Returns
+        -------
+        isherm : bool
+            Returns the new value of isherm property.
+        """
+        self._isherm = None
+        return self.isherm
+
+    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
+        """
+        Sqrt of a quantum operator.  Operator must be square.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse eigenvalue/vector solver.
+        tol : float
+            Tolerance used by sparse solver (0 = machine precision).
+        maxiter : int
+            Maximum number of iterations used by sparse solver.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix square root of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError('sqrt only valid on square matrices')
+        if isinstance(self.data, _data.CSR) and sparse:
+            evals, evecs = _data.eigs_csr(self.data,
+                                          isherm=self._isherm,
+                                          tol=tol, maxiter=maxiter)
+        elif isinstance(self.data, _data.CSR):
+            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
+                                      isherm=self._isherm)
+        else:
+            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
+
+        numevals = len(evals)
+        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
+        if self.isherm:
+            spDv = _data.matmul(dV, evecs.conj().transpose())
+        else:
+            spDv = _data.matmul(dV, _data.inv(evecs))
+        return Qobj(_data.matmul(evecs, spDv),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def cosm(self):
+        """Cosine of a quantum operator.
+
+        Operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix cosine of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+
+        Notes
+        -----
+        Uses the Q.expm() method.
+
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError('invalid operand for matrix cosine')
+        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
+
+    def sinm(self):
+        """Sine of a quantum operator.
+
+        Operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix sine of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+
+        Notes
+        -----
+        Uses the Q.expm() method.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError('invalid operand for matrix sine')
+        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
+
+    def inv(self, sparse=False):
+        """Matrix inverse of a quantum operator
+
+        Operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix inverse of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+        """
+        if self.data.shape[0] != self.data.shape[1]:
+            raise TypeError('Invalid operand for matrix inverse')
+        if isinstance(self.data, _data.CSR) and not sparse:
+            data = _data.to(_data.Dense, self.data)
+        else:
+            data = self.data
+
+        return Qobj(_data.inv(data),
+                    dims=[self.dims[1], self.dims[0]],
+                    type=self.type,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def unit(self, inplace=False, norm=None, kwargs=None):
+        """
+        Operator or state normalized to unity.  Uses norm from Qobj.norm().
+
+        Parameters
+        ----------
+        inplace : bool
+            Do an in-place normalization
+        norm : str
+            Requested norm for states / operators.
+        kwargs : dict
+            Additional key-word arguments to be passed on to the relevant norm
+            function (see :meth:`.norm` for more details).
+
+        Returns
+        -------
+        obj : :class:`qutip.Qobj`
+            Normalized quantum object.  Will be the `self` object if in place.
+        """
+        norm = self.norm(norm=norm, kwargs=kwargs)
+        if inplace:
+            self.data = _data.mul(self.data, 1 / norm)
+            self._isherm = self._isherm if norm.imag == 0 else None
+            self._isunitary = (self._isunitary
+                               if abs(norm) - 1 < settings.core['atol']
+                               else None)
+            out = self
+        else:
+            out = self / norm
+        return out
+
+    def ptrace(self, sel, dtype=None):
+        """
+        Take the partial trace of the quantum object leaving the selected
+        subspaces.  In other words, trace out all subspaces which are _not_
+        passed.
+
+        This is typically a function which acts on operators; bras and kets
+        will be promoted to density matrices before the operation takes place
+        since the partial trace is inherently undefined on pure states.
+
+        For operators which are currently being represented as states in the
+        superoperator formalism (i.e. the object has type `operator-ket` or
+        `operator-bra`), the partial trace is applied as if the operator were
+        in the conventional form.  This means that for any operator `x`,
+        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
+        and similar for `operator-bra`.
+
+        The story is different for full superoperators.  In the formalism that
+        QuTiP uses, if an operator has dimensions (`dims`) of
+        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
+        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
+        operator which acts on this joint space.  This function performs the
+        partial trace on superoperators by letting the selected components
+        refer to elements of the _joint_ _space_, and then returns a regular
+        operator (of type `oper`).
+
+        Parameters
+        ----------
+        sel : int or iterable of int
+            An ``int`` or ``list`` of components to keep after partial trace.
+            The selected subspaces will _not_ be reordered, no matter order
+            they are supplied to `ptrace`.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Quantum object representing partial trace with selected components
+            remaining.
+        """
+        try:
+            sel = sorted(sel)
+        except TypeError:
+            if not isinstance(sel, numbers.Integral):
+                raise TypeError(
+                    "selection must be an integer or list of integers"
+                ) from None
+            sel = [sel]
+        if self.isoperket:
+            dims = self.dims[0]
+            data = vector_to_operator(self).data
+        elif self.isoperbra:
+            dims = self.dims[1]
+            data = vector_to_operator(self.dag()).data
+        elif self.issuper or self.isoper:
+            dims = self.dims
+            data = self.data
+        else:
+            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
+            data = _data.project(self.data)
+        if dims[0] != dims[1]:
+            raise ValueError("partial trace is not defined on non-square maps")
+        dims = flatten(dims[0])
+        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
+        new_dims = [[dims[x] for x in sel]] * 2
+        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
+        if self.isoperket:
+            return operator_to_vector(out)
+        if self.isoperbra:
+            return operator_to_vector(out).dag()
+        return out
+
+    def contract(self, inplace=False):
+        """
+        Contract subspaces of the tensor structure which are 1D.  Not defined
+        on superoperators.  If all dimensions are scalar, a Qobj of dimension
+        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
+        contracted, but one is left.
+
+        Parameters
+        ----------
+        inplace: bool, optional
+            If ``True``, modify the dimensions in place.  If ``False``, return
+            a copied object.
+
+        Returns
+        -------
+        out: :class:`.Qobj`
+            Quantum object with dimensions contracted.  Will be ``self`` if
+            ``inplace`` is ``True``.
+        """
+        if self.isket:
+            sub = [x for x in self.dims[0] if x > 1] or [1]
+            dims = [sub, [1]*len(sub)]
+        elif self.isbra:
+            sub = [x for x in self.dims[1] if x > 1] or [1]
+            dims = [[1]*len(sub), sub]
+        elif self.isoper or self.isoperket or self.isoperbra:
+            if self.isoper:
+                oper_dims = self.dims
+            elif self.isoperket:
+                oper_dims = self.dims[0]
+            else:
+                oper_dims = self.dims[1]
+            if len(oper_dims[0]) != len(oper_dims[1]):
+                raise ValueError("cannot parse Qobj dimensions: "
+                                 + repr(self.dims))
+            dims_ = [
+                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
+                if x > 1 or y > 1
+            ] or [(1, 1)]
+            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
+            if self.isoperket:
+                dims = [dims, [1]]
+            elif self.isoperbra:
+                dims = [[1], dims]
+        else:
+            raise TypeError("not defined for superoperators")
+        if inplace:
+            self.dims = dims
+            return self
+        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
+
+    def permute(self, order):
+        """
+        Permute the tensor structure of a quantum object.  For example,
+        ``qutip.tensor(x, y).permute([1, 0])``
+        will give the same result as
+        ``qutip.tensor(y, x)``
+        and
+        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
+        will be the same as
+        ``qutip.tensor(b, c, a)``
+
+        For regular objects (bras, kets and operators) we expect ``order`` to
+        be a flat list of integers, which specifies the new order of the tensor
+        product.
+
+        For superoperators, we expect ``order`` to be something like
+        ``[[0, 2], [1, 3]]``
+        which tells us to permute according to [0, 2, 1, 3], and then group
+        indices according to the length of each sublist.  As another example,
+        permuting a superoperator with dimensions of
+        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
+        by an ``order``
+        ``[[0, 3], [1, 4], [2, 5]]``
+        should give a new object with dimensions
+        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
+
+        Parameters
+        ----------
+        order : list
+            List of indices specifying the new tensor order.
+
+        Returns
+        -------
+        P : :class:`qutip.Qobj`
+            Permuted quantum object.
+        """
+        if self.type in ('bra', 'ket', 'oper'):
+            structure = self.dims[1] if self.isbra else self.dims[0]
+            new_structure = [structure[x] for x in order]
+            if self.isbra:
+                dims = [self.dims[0], new_structure]
+            elif self.isket:
+                dims = [new_structure, self.dims[1]]
+            else:
+                if self.dims[0] != self.dims[1]:
+                    raise TypeError("undefined for non-square operators")
+                dims = [new_structure, new_structure]
+            data = _data.permute.dimensions(self.data, structure, order)
+            return Qobj(data,
+                        dims=dims,
+                        type=self.type,
+                        isherm=self._isherm,
+                        isunitary=self._isunitary,
+                        copy=False)
+        # If we've got here, we're some form of superoperator, so we work with
+        # the flattened structure.
+        flat_order = flatten(order)
+        flat_structure = flatten(self.dims[1] if self.isoperbra
+                                 else self.dims[0])
+        new_structure = unflatten([flat_structure[x] for x in flat_order],
+                                  enumerate_flat(order))
+        if self.isoperbra:
+            dims = [self.dims[0], new_structure]
+        elif self.isoperket:
+            dims = [new_structure, self.dims[1]]
+        else:
+            if self.dims[0] != self.dims[1]:
+                raise TypeError("undefined for non-square operators")
+            dims = [new_structure, new_structure]
+        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
+        return Qobj(data,
+                    dims=dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def tidyup(self, atol=None):
+        """
+        Removes small elements from the quantum object.
+
+        Parameters
+        ----------
+        atol : float
+            Absolute tolerance used by tidyup. Default is set
+            via qutip global settings parameters.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Quantum object with small elements removed.
+        """
+        atol = atol or settings.core['auto_tidyup_atol']
+        self.data = _data.tidyup(self.data, atol)
+        return self
+
+    def transform(self, inpt, inverse=False):
+        """Basis transform defined by input array.
+
+        Input array can be a ``matrix`` defining the transformation,
+        or a ``list`` of kets that defines the new basis.
+
+        Parameters
+        ----------
+        inpt : array_like
+            A ``matrix`` or ``list`` of kets defining the transformation.
+        inverse : bool
+            Whether to return inverse transformation.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Operator in new basis.
+
+        Notes
+        -----
+        This function is still in development.
+        """
+        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
+                                      inpt.ndim == 1):
+            if len(inpt) != max(self.shape):
+                raise TypeError(
+                    'Invalid size of ket list for basis transformation')
+            base = np.hstack([psi.full() for psi in inpt])
+            S = _data.adjoint(_data.create(base))
+        elif isinstance(inpt, Qobj) and inpt.isoper:
+            S = inpt.data
+        elif isinstance(inpt, np.ndarray):
+            S = _data.create(inpt).conj()
+        else:
+            raise TypeError('Invalid operand for basis transformation')
+
+        # transform data
+        if inverse:
+            if self.isket:
+                data = _data.matmul(S.adjoint(), self.data)
+            elif self.isbra:
+                data = _data.matmul(self.data, S)
+            else:
+                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
+        else:
+            if self.isket:
+                data = _data.matmul(S, self.data)
+            elif self.isbra:
+                data = _data.matmul(self.data, S.adjoint())
+            else:
+                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
+        return Qobj(data,
+                    dims=self.dims,
+                    type=self.type,
+                    isherm=self._isherm,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def trunc_neg(self, method="clip"):
+        """Truncates negative eigenvalues and renormalizes.
+
+        Returns a new Qobj by removing the negative eigenvalues
+        of this instance, then renormalizing to obtain a valid density
+        operator.
+
+
+        Parameters
+        ----------
+        method : str
+            Algorithm to use to remove negative eigenvalues. "clip"
+            simply discards negative eigenvalues, then renormalizes.
+            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
+            positive operator that is nearest in the Shatten 2-norm.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            A valid density operator.
+        """
+        if not self.isherm:
+            raise ValueError("Must be a Hermitian operator to remove negative "
+                             "eigenvalues.")
+        if method not in ('clip', 'sgs'):
+            raise ValueError("Method {} not recognized.".format(method))
+
+        eigvals, eigstates = self.eigenstates()
+        if all(eigval >= 0 for eigval in eigvals):
+            # All positive, so just renormalize.
+            return self.unit()
+        idx_nonzero = eigvals != 0
+        eigvals = eigvals[idx_nonzero]
+        eigstates = eigstates[idx_nonzero]
+
+        if method == 'clip':
+            eigvals[eigvals < 0] = 0
+        elif method == 'sgs':
+            eigvals = eigvals[::-1]
+            eigstates = eigstates[::-1]
+            acc = 0.0
+            n_eigs = len(eigvals)
+            for idx in reversed(range(n_eigs)):
+                if eigvals[idx] + acc / (idx + 1) >= 0:
+                    break
+                acc += eigvals[idx]
+                eigvals[idx] = 0.0
+            eigvals[:idx+1] += acc / (idx + 1)
+        out_data = _data.zeros(*self.shape)
+        for value, state in zip(eigvals, eigstates):
+            if value:
+                # add in 3-argument form is fused-add-multiply
+                out_data = _data.add(out_data,
+                                     _data.project(state.data),
+                                     value)
+        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
+        return Qobj(out_data,
+                    dims=self.dims.copy(),
+                    type=self.type,
+                    isherm=True,
+                    copy=False)
+
+    def matrix_element(self, bra, ket):
+        """Calculates a matrix element.
+
+        Gives the matrix element for the quantum object sandwiched between a
+        `bra` and `ket` vector.
+
+        Parameters
+        ----------
+        bra : :class:`qutip.Qobj`
+            Quantum object of type 'bra' or 'ket'
+
+        ket : :class:`qutip.Qobj`
+            Quantum object of type 'ket'.
+
+        Returns
+        -------
+        elem : complex
+            Complex valued matrix element.
+
+        Notes
+        -----
+        It is slightly more computationally efficient to use a ket
+        vector for the 'bra' input.
+
+        """
+        if not self.isoper:
+            raise TypeError("Can only get matrix elements for an operator.")
+        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
+            msg = "Can only calculate matrix elements between a bra and a ket."
+            raise TypeError(msg)
+        left, op, right = bra.data, self.data, ket.data
+        if ket.isbra:
+            right = right.adjoint()
+        return _data.inner_op(left, op, right, bra.isket)
+
+    def overlap(self, other):
+        """
+        Overlap between two state vectors or two operators.
+
+        Gives the overlap (inner product) between the current bra or ket Qobj
+        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
+        when one of the Qobj is an operator/density matrix.
+
+        Parameters
+        ----------
+        other : :class:`qutip.Qobj`
+            Quantum object for a state vector of type 'ket', 'bra' or density
+            matrix.
+
+        Returns
+        -------
+        overlap : complex
+            Complex valued overlap.
+
+        Raises
+        ------
+        TypeError
+            Can only calculate overlap between a bra, ket and density matrix
+            quantum objects.
+        """
+        if not isinstance(other, Qobj):
+            raise TypeError("".join([
+                "cannot calculate overlap with non-quantum object ",
+                repr(other),
+            ]))
+        if (
+            self.type not in ('ket', 'bra', 'oper')
+            or other.type not in ('ket', 'bra', 'oper')
+        ):
+            msg = "only bras, kets and density matrices have defined overlaps"
+            raise TypeError(msg)
+        left, right = self._data.adjoint(), other.data
+        if self.isoper or other.isoper:
+            if not self.isoper:
+                left = _data.project(left)
+            if not other.isoper:
+                right = _data.project(right)
+            return _data.trace(_data.matmul(left, right))
+        if other.isbra:
+            right = right.adjoint()
+        out = _data.inner(left, right, self.isket)
+        if self.isket and other.isbra:
+            # In this particular case, we've basically doing
+            #   conj(other.overlap(self))
+            # so we take care to conjugate the output.
+            out = np.conj(out)
+        return out
+
+    def eigenstates(self, sparse=False, sort='low', eigvals=0,
+                    tol=0, maxiter=100000, phase_fix=None):
+        """Eigenstates and eigenenergies.
+
+        Eigenstates and eigenenergies are defined for operators and
+        superoperators only.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse Eigensolver
+
+        sort : str
+            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
+
+        eigvals : int
+            Number of requested eigenvalues. Default is all eigenvalues.
+
+        tol : float
+            Tolerance used by sparse Eigensolver (0 = machine precision).
+            The sparse solver may not converge if the tolerance is set too low.
+
+        maxiter : int
+            Maximum number of iterations performed by sparse solver (if used).
+
+        phase_fix : int, None
+            If not None, set the phase of each kets so that ket[phase_fix,0]
+            is real positive.
+
+        Returns
+        -------
+        eigvals : array
+            Array of eigenvalues for operator.
+
+        eigvecs : array
+            Array of quantum operators representing the oprator eigenkets.
+            Order of eigenkets is determined by order of eigenvalues.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+
+        """
+        if isinstance(self.data, _data.CSR) and sparse:
+            evals, evecs = _data.eigs_csr(self.data,
+                                          isherm=self._isherm,
+                                          sort=sort, eigvals=eigvals, tol=tol,
+                                          maxiter=maxiter)
+        elif isinstance(self.data, _data.CSR):
+            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
+                                      isherm=self._isherm,
+                                      sort=sort, eigvals=eigvals)
+        else:
+            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
+                                      sort=sort, eigvals=eigvals)
+
+        if self.type == 'super':
+            new_dims = [self.dims[0], [1]]
+            new_type = 'operator-ket'
+        else:
+            new_dims = [self.dims[0], [1]*len(self.dims[0])]
+            new_type = 'ket'
+        ekets = np.empty((evecs.shape[1],), dtype=object)
+        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
+                    for vec in _data.split_columns(evecs, False)]
+        norms = np.array([ket.norm() for ket in ekets])
+        if phase_fix is None:
+            phase = np.array([1] * len(ekets))
+        else:
+            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
+                              if ket[phase_fix, 0] else 1
+                              for ket in ekets])
+        return evals, ekets / norms * phase
+
+    def eigenenergies(self, sparse=False, sort='low',
+                      eigvals=0, tol=0, maxiter=100000):
+        """Eigenenergies of a quantum object.
+
+        Eigenenergies (eigenvalues) are defined for operators or superoperators
+        only.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse Eigensolver
+        sort : str
+            Sort eigenvalues 'low' to high, or 'high' to low.
+        eigvals : int
+            Number of requested eigenvalues. Default is all eigenvalues.
+        tol : float
+            Tolerance used by sparse Eigensolver (0=machine precision).
+            The sparse solver may not converge if the tolerance is set too low.
+        maxiter : int
+            Maximum number of iterations performed by sparse solver (if used).
+
+        Returns
+        -------
+        eigvals : array
+            Array of eigenvalues for operator.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+
+        """
+        # TODO: consider another way of handling the dispatch here.
+        if isinstance(self.data, _data.CSR) and sparse:
+            return _data.eigs_csr(self.data,
+                                  vecs=False,
+                                  isherm=self._isherm,
+                                  sort=sort, eigvals=eigvals,
+                                  tol=tol, maxiter=maxiter)
+        elif isinstance(self.data, _data.CSR):
+            return _data.eigs(_data.to(_data.Dense, self.data),
+                              vecs=False, isherm=self._isherm,
+                              sort=sort, eigvals=eigvals)
+
+        return _data.eigs(self.data,
+                          vecs=False,
+                          isherm=self._isherm, sort=sort, eigvals=eigvals)
+
+    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
+        """Ground state Eigenvalue and Eigenvector.
+
+        Defined for quantum operators or superoperators only.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse Eigensolver
+        tol : float
+            Tolerance used by sparse Eigensolver (0 = machine precision).
+            The sparse solver may not converge if the tolerance is set too low.
+        maxiter : int
+            Maximum number of iterations performed by sparse solver (if used).
+        safe : bool (default=True)
+            Check for degenerate ground state
+
+        Returns
+        -------
+        eigval : float
+            Eigenvalue for the ground state of quantum operator.
+        eigvec : :class:`qutip.Qobj`
+            Eigenket for the ground state of quantum operator.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+        """
+        eigvals = 2 if safe else 1
+        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
+                                        tol=tol, maxiter=maxiter)
+
+        if safe:
+            tol = tol or settings.core['atol']
+            # This tol should be less strick than the tol for the eigensolver
+            # so it's numerical errors are not seens as degenerate states.
+            if (evals[1]-evals[0]) <= 10 * tol:
+                warnings.warn("Ground state may be degenerate.", UserWarning)
+        return evals[0], evecs[0]
+
+    def dnorm(self, B=None):
+        """Calculates the diamond norm, or the diamond distance to another
+        operator.
+
+        Parameters
+        ----------
+        B : :class:`qutip.Qobj` or None
+            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
+            between this operator and B is returned instead of the diamond norm.
+
+        Returns
+        -------
+        d : float
+            Either the diamond norm of this operator, or the diamond distance
+            from this operator to B.
+
+        """
+        return mts.dnorm(self, B)
+
+    @property
+    def ishp(self):
+        # FIXME: this needs to be cached in the same ways as isherm.
+        if self.type in ["super", "oper"]:
+            try:
+                J = to_choi(self)
+                return J.isherm
+            except:
+                return False
+        else:
+            return False
+
+    @property
+    def iscp(self):
+        # FIXME: this needs to be cached in the same ways as isherm.
+        if self.type not in ["super", "oper"]:
+            return False
+        # We can test with either Choi or chi, since the basis
+        # transformation between them is unitary and hence preserves
+        # the CP and TP conditions.
+        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
+        # If J isn't hermitian, then that could indicate either that J is not
+        # normal, or is normal, but has complex eigenvalues.  In either case,
+        # it makes no sense to then demand that the eigenvalues be
+        # non-negative.
+        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
+
+    @property
+    def istp(self):
+        if self.type not in ['super', 'oper']:
+            return False
+        # Normalize to a super of type choi or chi.
+        # We can test with either Choi or chi, since the basis
+        # transformation between them is unitary and hence
+        # preserves the CP and TP conditions.
+        if self.issuper and self.superrep in ('choi', 'chi'):
+            qobj = self
+        else:
+            qobj = to_choi(self)
+        # Possibly collapse dims.
+        if any([len(index) > 1
+                for super_index in qobj.dims
+                for index in super_index]):
+            qobj = Qobj(qobj.data,
+                        dims=collapse_dims_super(qobj.dims),
+                        type=qobj.type,
+                        superrep=qobj.superrep,
+                        copy=False)
+        # We use the condition from John Watrous' lecture notes,
+        # Tr_1(J(Phi)) = identity_2.
+        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
+        # Theory of Quantum Information (Fall 2011), theorem 5.4.
+        tr_oper = qobj.ptrace([0])
+        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
+                           atol=settings.core['atol'])
+
+    @property
+    def iscptp(self):
+        if not (self.issuper or self.isoper):
+            return False
+        reps = ('choi', 'chi')
+        q_oper = to_choi(self) if self.superrep not in reps else self
+        return q_oper.iscp and q_oper.istp
+
+    @property
+    def isherm(self):
+        if self._isherm is not None:
+            return self._isherm
+        self._isherm = _data.isherm(self._data)
+        return self._isherm
+
+    @isherm.setter
+    def isherm(self, isherm):
+        self._isherm = isherm
+
+    def _calculate_isunitary(self):
+        """
+        Checks whether qobj is a unitary matrix
+        """
+        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
+            return False
+        cmp = _data.matmul(self._data, self._data.adjoint())
+        iden = _data.identity(self.shape[0], dtype=type(cmp))
+        return _data.iszero(_data.sub(cmp, iden),
+                            tol=settings.core['atol'])
+
+    @property
+    def isunitary(self):
+        if self._isunitary is not None:
+            return self._isunitary
+        self._isunitary = self._calculate_isunitary()
+        return self._isunitary
+
+    @property
+    def shape(self): return self.data.shape
+
+    isbra = property(isbra)
+    isket = property(isket)
+    isoper = property(isoper)
+    issuper = property(issuper)
+    isoperbra = property(isoperbra)
+    isoperket = property(isoperket)
+
+
+def ptrace(Q, sel):
+    """
+    Partial trace of the Qobj with selected components remaining.
+
+    Parameters
+    ----------
+    Q : :class:`qutip.Qobj`
+        Composite quantum object.
+    sel : int/list
+        An ``int`` or ``list`` of components to keep after partial trace.
+
+    Returns
+    -------
+    oper : :class:`qutip.Qobj`
+        Quantum object representing partial trace with selected components
+        remaining.
+
+    Notes
+    -----
+    This function is for legacy compatibility only. It is recommended to use
+    the ``ptrace()`` Qobj method.
+    """
+    if not isinstance(Q, Qobj):
+        raise TypeError("Input is not a quantum object")
+    return Q.ptrace(sel)
+
+
+# TRAILING IMPORTS
+# We do a few imports here to avoid circular dependencies.
+from qutip.core.superop_reps import to_choi
+from qutip.core.superoperator import vector_to_operator, operator_to_vector
+from qutip.core.tensor import tensor_swap, tensor
+from qutip.core import metrics as mts
diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index c6d3762f22..6d4be82b1d 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -1,208 +1,208 @@
-# -*- coding: utf-8 -*-
-
-"""
-This module implements internal-use functions for semidefinite programming.
-"""
-
-__all__ = [
-    'dnorm_problem',
-    'dnorm_sparse_problem',
-]
-
-import collections
-import functools
-
-import numpy as np
-import scipy.sparse as sp
-# Conditionally import CVXPY
-try:
-    import cvxpy
-except ImportError:
-    cvxpy = None
-
-from .tensor import tensor_swap
-from .operators import qeye
-from ..logging_utils import get_logger
-logger = get_logger('qutip.core.semidefinite')
-
-Complex = collections.namedtuple('Complex', ['re', 'im'])
-
-
-def complex_var(rows=1, cols=1, name=None):
-    return Complex(
-        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
-        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
-    )
-
-
-def herm(*Xs):
-    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
-
-
-def pos_noherm(*Xs):
-    return [
-        cvxpy.bmat([
-            [X.re, -X.im],
-            [X.im, X.re]
-        ]) >> 0
-        for X in Xs
-    ]
-
-
-def pos(*Xs):
-    return pos_noherm(*Xs) + herm(*Xs)
-
-
-def dens(*rhos):
-    return pos(*rhos) + [
-        cvxpy.trace(rho.re) == 1
-        for rho in rhos
-    ]
-
-
-def _arr_to_complex(A):
-    if np.iscomplex(A).any():
-        return Complex(re=A.real, im=A.imag)
-    return Complex(re=A, im=np.zeros_like(A))
-
-
-def kron(A, B):
-    if isinstance(A, np.ndarray):
-        A = _arr_to_complex(A)
-    if isinstance(B, np.ndarray):
-        B = _arr_to_complex(B)
-
-    return Complex(
-        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
-        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
-    )
-
-
-def conj(W, A):
-    U, V = W.re, W.im
-    A, B = A.re, A.im
-    return Complex(
-        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
-        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
-    )
-
-
-def bmat(B):
-    return Complex(
-        re=cvxpy.bmat([[element.re for element in row] for row in B]),
-        im=cvxpy.bmat([[element.re for element in row] for row in B]),
-    )
-
-
-def dag(X):
-    return Complex(re=X.re.T, im=-X.im.T)
-
-
-def memoize(fn):
-    cache = {}
-
-    @functools.wraps(fn)
-    def memoized(*args):
-        if args in cache:
-            return cache[args]
-        else:
-            ret = fn(*args)
-            cache[args] = ret
-            return ret
-
-    memoized.reset_cache = cache.clear
-    return memoized
-
-
-def qudit_swap(dim):
-    # We should likely generalize this and include it in qip.gates.
-    W = qeye([dim, dim])
-    return tensor_swap(W, (0, 1))
-
-
-@memoize
-def initialize_constraints_on_dnorm_problem(dim):
-    # Start assembling constraints and variables.
-    constraints = []
-
-    # Make a complex variable for X.
-    X = complex_var(dim ** 2, dim ** 2, "X")
-
-    # Make complex variables for rho0 and rho1.
-    rho0 = complex_var(dim, dim, "rho0")
-    rho1 = complex_var(dim, dim, "rho1")
-    constraints += dens(rho0, rho1)
-
-    # Finally, add the tricky positive semidefinite constraint.
-    # Since we're using column-stacking, but Watrous used row-stacking,
-    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
-    # as CVXPY requires that the constant be the first argument. To solve this,
-    # We conjugate by SWAP.
-    W = qudit_swap(dim).full()
-    W = Complex(re=W.real, im=W.imag)
-    Rho0 = conj(W, kron(np.eye(dim), rho0))
-    Rho1 = conj(W, kron(np.eye(dim), rho1))
-
-    Y = cvxpy.bmat([
-        [Rho0.re, X.re,      -Rho0.im, -X.im],
-        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
-
-        [Rho0.im, X.im,      Rho0.re, X.re],
-        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
-    ])
-    constraints += [Y >> 0]
-
-    logger.debug("Using %d constraints.", len(constraints))
-
-    return X, constraints
-
-
-def dnorm_problem(dim):
-    X, constraints = initialize_constraints_on_dnorm_problem(dim)
-    Jr = cvxpy.Parameter((dim**2, dim**2))
-    Ji = cvxpy.Parameter((dim**2, dim**2))
-    # The objective, however, depends on J.
-    objective = cvxpy.Maximize(cvxpy.trace(
-        Jr.T @ X.re + Ji.T @ X.im
-    ))
-    problem = cvxpy.Problem(objective, constraints)
-    return problem, Jr, Ji
-
-
-def dnorm_sparse_problem(dim, J_dat):
-    X, constraints = initialize_constraints_on_dnorm_problem(dim)
-    J_val = J_dat.tocoo()
-
-    def adapt_sparse_params(A_val, dim):
-        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
-        # can not solve with parameters that aresparse matrices directly.
-        # Solutions have to be made through calling cvxpy.reshape on
-        # the original sparse matrix.
-        side_size = dim**2
-        A_nnz = cvxpy.Parameter(A_val.nnz)
-
-        A_data = np.ones(A_nnz.size)
-        A_rows = A_val.row * side_size + A_val.col
-        A_cols = np.arange(A_nnz.size)
-        # We are pushing the data on the location of the nonzero elements
-        # to the nonzero rows of A_indexer
-        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
-                                  shape=(side_size**2, A_nnz.size))
-        # We get finaly the sparse matrix A which we wanted
-        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
-        A_nnz.value = A_val.data
-        return A
-
-    Jr_val = J_val.real
-    Jr = adapt_sparse_params(Jr_val, dim)
-
-    Ji_val = J_val.imag
-    Ji = adapt_sparse_params(Ji_val, dim)
-
-    # The objective, however, depends on J.
-    objective = cvxpy.Maximize(cvxpy.trace(
-        Jr.T @ X.re + Ji.T @ X.im
-    ))
-
-    problem = cvxpy.Problem(objective, constraints)
-    return problem
+# -*- coding: utf-8 -*-
+
+"""
+This module implements internal-use functions for semidefinite programming.
+"""
+
+__all__ = [
+    'dnorm_problem',
+    'dnorm_sparse_problem',
+]
+
+import collections
+import functools
+
+import numpy as np
+import scipy.sparse as sp
+# Conditionally import CVXPY
+try:
+    import cvxpy
+except ImportError:
+    cvxpy = None
+
+from .tensor import tensor_swap
+from .operators import qeye
+from ..logging_utils import get_logger
+logger = get_logger('qutip.core.semidefinite')
+
+Complex = collections.namedtuple('Complex', ['re', 'im'])
+
+
+def complex_var(rows=1, cols=1, name=None):
+    return Complex(
+        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
+        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
+    )
+
+
+def herm(*Xs):
+    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
+
+
+def pos_noherm(*Xs):
+    return [
+        cvxpy.bmat([
+            [X.re, -X.im],
+            [X.im, X.re]
+        ]) >> 0
+        for X in Xs
+    ]
+
+
+def pos(*Xs):
+    return pos_noherm(*Xs) + herm(*Xs)
+
+
+def dens(*rhos):
+    return pos(*rhos) + [
+        cvxpy.trace(rho.re) == 1
+        for rho in rhos
+    ]
+
+
+def _arr_to_complex(A):
+    if np.iscomplex(A).any():
+        return Complex(re=A.real, im=A.imag)
+    return Complex(re=A, im=np.zeros_like(A))
+
+
+def kron(A, B):
+    if isinstance(A, np.ndarray):
+        A = _arr_to_complex(A)
+    if isinstance(B, np.ndarray):
+        B = _arr_to_complex(B)
+
+    return Complex(
+        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
+        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
+    )
+
+
+def conj(W, A):
+    U, V = W.re, W.im
+    A, B = A.re, A.im
+    return Complex(
+        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
+        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
+    )
+
+
+def bmat(B):
+    return Complex(
+        re=cvxpy.bmat([[element.re for element in row] for row in B]),
+        im=cvxpy.bmat([[element.re for element in row] for row in B]),
+    )
+
+
+def dag(X):
+    return Complex(re=X.re.T, im=-X.im.T)
+
+
+def memoize(fn):
+    cache = {}
+
+    @functools.wraps(fn)
+    def memoized(*args):
+        if args in cache:
+            return cache[args]
+        else:
+            ret = fn(*args)
+            cache[args] = ret
+            return ret
+
+    memoized.reset_cache = cache.clear
+    return memoized
+
+
+def qudit_swap(dim):
+    # We should likely generalize this and include it in qip.gates.
+    W = qeye([dim, dim])
+    return tensor_swap(W, (0, 1))
+
+
+@memoize
+def initialize_constraints_on_dnorm_problem(dim):
+    # Start assembling constraints and variables.
+    constraints = []
+
+    # Make a complex variable for X.
+    X = complex_var(dim ** 2, dim ** 2, "X")
+
+    # Make complex variables for rho0 and rho1.
+    rho0 = complex_var(dim, dim, "rho0")
+    rho1 = complex_var(dim, dim, "rho1")
+    constraints += dens(rho0, rho1)
+
+    # Finally, add the tricky positive semidefinite constraint.
+    # Since we're using column-stacking, but Watrous used row-stacking,
+    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
+    # as CVXPY requires that the constant be the first argument. To solve this,
+    # We conjugate by SWAP.
+    W = qudit_swap(dim).full()
+    W = Complex(re=W.real, im=W.imag)
+    Rho0 = conj(W, kron(np.eye(dim), rho0))
+    Rho1 = conj(W, kron(np.eye(dim), rho1))
+
+    Y = cvxpy.bmat([
+        [Rho0.re, X.re,      -Rho0.im, -X.im],
+        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
+
+        [Rho0.im, X.im,      Rho0.re, X.re],
+        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
+    ])
+    constraints += [Y >> 0]
+
+    logger.debug("Using %d constraints.", len(constraints))
+
+    return X, constraints
+
+
+def dnorm_problem(dim):
+    X, constraints = initialize_constraints_on_dnorm_problem(dim)
+    Jr = cvxpy.Parameter((dim**2, dim**2))
+    Ji = cvxpy.Parameter((dim**2, dim**2))
+    # The objective, however, depends on J.
+    objective = cvxpy.Maximize(cvxpy.trace(
+        Jr.T @ X.re + Ji.T @ X.im
+    ))
+    problem = cvxpy.Problem(objective, constraints)
+    return problem, Jr, Ji
+
+
+def dnorm_sparse_problem(dim, J_dat):
+    X, constraints = initialize_constraints_on_dnorm_problem(dim)
+    J_val = J_dat.tocoo()
+
+    def adapt_sparse_params(A_val, dim):
+        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
+        # can not solve with parameters that aresparse matrices directly.
+        # Solutions have to be made through calling cvxpy.reshape on
+        # the original sparse matrix.
+        side_size = dim**2
+        A_nnz = cvxpy.Parameter(A_val.nnz)
+
+        A_data = np.ones(A_nnz.size)
+        A_rows = A_val.row * side_size + A_val.col
+        A_cols = np.arange(A_nnz.size)
+        # We are pushing the data on the location of the nonzero elements
+        # to the nonzero rows of A_indexer
+        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
+                                  shape=(side_size**2, A_nnz.size))
+        # We get finaly the sparse matrix A which we wanted
+        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
+        A_nnz.value = A_val.data
+        return A
+
+    Jr_val = J_val.real
+    Jr = adapt_sparse_params(Jr_val, dim)
+
+    Ji_val = J_val.imag
+    Ji = adapt_sparse_params(Ji_val, dim)
+
+    # The objective, however, depends on J.
+    objective = cvxpy.Maximize(cvxpy.trace(
+        Jr.T @ X.re + Ji.T @ X.im
+    ))
+
+    problem = cvxpy.Problem(objective, constraints)
+    return problem
diff --git a/qutip/core/states.py b/qutip/core/states.py
index c030e33d0b..10d5788ca5 100644
--- a/qutip/core/states.py
+++ b/qutip/core/states.py
@@ -1,1342 +1,1342 @@
-__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
-           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
-           'qstate', 'ket', 'bra', 'state_number_enumerate',
-           'state_number_index', 'state_index_number', 'state_number_qobj',
-           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
-           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
-           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
-           'enr_thermal_dm']
-
-import itertools
-import numbers
-import warnings
-
-import numpy as np
-import scipy.sparse as sp
-import itertools
-
-from . import data as _data
-from .qobj import Qobj
-from .operators import jmat, displace, qdiags
-from .tensor import tensor
-from .. import settings
-
-def _promote_to_zero_list(arg, length):
-    """
-    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
-    to `[0]*length`.  All other inputs are checked that they match the correct
-    form.
-
-    Returns
-    -------
-    list_ : list
-        A list of integers of length `length`.
-    """
-    if arg is None:
-        arg = [0]*length
-    elif not isinstance(arg, list):
-        arg = [arg]
-    if not len(arg) == length:
-        raise ValueError("All list inputs must be the same length.")
-    if all(isinstance(x, numbers.Integral) for x in arg):
-        return arg
-    raise TypeError("Dimensions must be an integer or list of integers.")
-
-
-def basis(dimensions, n=None, offset=None, *, dtype=None):
-    """Generates the vector representation of a Fock state.
-
-    Parameters
-    ----------
-    dimensions : int or list of ints
-        Number of Fock states in Hilbert space.  If a list, then the resultant
-        object will be a tensor product over spaces with those dimensions.
-
-    n : int or list of ints, optional (default 0 for all dimensions)
-        Integer corresponding to desired number state, defaults to 0 for all
-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-        of equal length.
-
-    offset : int or list of ints, optional (default 0 for all dimensions)
-        The lowest number state that is included in the finite number state
-        representation of the state in the relevant dimension.
-
-    dtype : type or str
-        storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : :class:`qutip.Qobj`
-      Qobj representing the requested number state ``|n>``.
-
-    Examples
-    --------
-    >>> basis(5,2) # doctest: +SKIP
-    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
-    Qobj data =
-    [[ 0.+0.j]
-     [ 0.+0.j]
-     [ 1.+0.j]
-     [ 0.+0.j]
-     [ 0.+0.j]]
-    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
-    Qobj data =
-    [[0.]
-     [0.]
-     [1.]
-     [0.]
-     [0.]
-     [0.]
-     [0.]
-     [0.]]
-
-
-    Notes
-    -----
-    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
-
-        basis(N, 0) = ground state
-
-    but in the qotoolbox::
-
-        basis(N, 1) = ground state
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    # Promote all parameters to lists to simplify later logic.
-    if not isinstance(dimensions, list):
-        dimensions = [dimensions]
-    n_dimensions = len(dimensions)
-    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
-                                  _promote_to_zero_list(offset, n_dimensions))]
-    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
-        raise ValueError("All dimensions must be >= 0.")
-    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
-        raise ValueError("All basis indices must be "
-                         "`offset <= n < dimension+offset`.")
-    location, size = 0, 1
-    for m, dimension in zip(reversed(ns), reversed(dimensions)):
-        location += m*size
-        size *= dimension
-
-    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
-    return Qobj(data,
-                dims=[dimensions, [1]*n_dimensions],
-                type='ket',
-                isherm=False,
-                isunitary=False,
-                copy=False)
-
-
-def qutrit_basis(*, dtype=None):
-    """Basis states for a three level system (qutrit)
-
-    dtype : type or str
-        storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    qstates : array
-        Array of qutrit basis vectors
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    out = np.empty((3,), dtype=object)
-    out[:] = [
-        basis(3, 0, dtype=dtype),
-        basis(3, 1, dtype=dtype),
-        basis(3, 2, dtype=dtype),
-    ]
-    return out
-
-_COHERENT_METHODS = ('operator', 'analytic')
-
-
-def coherent(N, alpha, offset=0, method=None, *, dtype=None):
-    """Generates a coherent state with eigenvalue alpha.
-
-    Constructed using displacement operator on vacuum state.
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    alpha : float/complex
-        Eigenvalue of coherent state.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the state. Using a non-zero offset will make the
-        default method 'analytic'.
-
-    method : string {'operator', 'analytic'}
-        Method for generating coherent state.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Qobj quantum object for coherent state
-
-    Examples
-    --------
-    >>> coherent(5,0.25j) # doctest: +SKIP
-    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
-    Qobj data =
-    [[  9.69233235e-01+0.j        ]
-     [  0.00000000e+00+0.24230831j]
-     [ -4.28344935e-02+0.j        ]
-     [  0.00000000e+00-0.00618204j]
-     [  7.80904967e-04+0.j        ]]
-
-    Notes
-    -----
-    Select method 'operator' (default) or 'analytic'. With the
-    'operator' method, the coherent state is generated by displacing
-    the vacuum state using the displacement operator defined in the
-    truncated Hilbert space of size 'N'. This method guarantees that the
-    resulting state is normalized. With 'analytic' method the coherent state
-    is generated using the analytical formula for the coherent state
-    coefficients in the Fock basis. This method does not guarantee that the
-    state is normalized if truncated to a small number of Fock states,
-    but would in that case give more accurate coefficients.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    if offset < 0:
-        raise ValueError('Offset must be non-negative')
-
-    if method is None:
-        method = "operator" if offset == 0 else "analytic"
-
-    if method == "operator":
-        if offset != 0:
-            raise ValueError(
-                "The method 'operator' does not support offset != 0. Please"
-                " select another method or set the offset to zero."
-            )
-        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
-
-    elif method == "analytic":
-        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
-        sqrtn[0] = 1  # Get rid of divide by zero warning
-        data = alpha / sqrtn
-        if offset == 0:
-            data[0] = np.exp(-abs(alpha)**2 / 2.0)
-        else:
-            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
-            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
-        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
-        return Qobj(sqrtn,
-                    dims=[[N], [1]],
-                    type='ket',
-                    copy=False).to(dtype)
-    raise TypeError(
-        "The method option can only take values in " + repr(_COHERENT_METHODS)
-    )
-
-
-def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
-    """Density matrix representation of a coherent state.
-
-    Constructed via outer product of :func:`qutip.states.coherent`
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    alpha : float/complex
-        Eigenvalue for coherent state.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the state.
-
-    method : string {'operator', 'analytic'}
-        Method for generating coherent density matrix.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Density matrix representation of coherent state.
-
-    Examples
-    --------
-    >>> coherent_dm(3,0.25j) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
-     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
-     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
-        ]]
-
-    Notes
-    -----
-    Select method 'operator' (default) or 'analytic'. With the
-    'operator' method, the coherent density matrix is generated by displacing
-    the vacuum state using the displacement operator defined in the
-    truncated Hilbert space of size 'N'. This method guarantees that the
-    resulting density matrix is normalized. With 'analytic' method the coherent
-    density matrix is generated using the analytical formula for the coherent
-    state coefficients in the Fock basis. This method does not guarantee that
-    the state is normalized if truncated to a small number of Fock states,
-    but would in that case give more accurate coefficients.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
-
-
-def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
-    """Density matrix representation of a Fock state
-
-    Constructed via outer product of :func:`qutip.states.fock`.
-
-    Parameters
-    ----------
-    dimensions : int or list of ints
-        Number of Fock states in Hilbert space.  If a list, then the resultant
-        object will be a tensor product over spaces with those dimensions.
-
-    n : int or list of ints, optional (default 0 for all dimensions)
-        Integer corresponding to desired number state, defaults to 0 for all
-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-        of equal length.
-
-    offset : int or list of ints, optional (default 0 for all dimensions)
-        The lowest number state that is included in the finite number state
-        representation of the state in the relevant dimension.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Density matrix representation of Fock state.
-
-    Examples
-    --------
-     >>> fock_dm(3,1) # doctest: +SKIP
-     Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-     Qobj data =
-     [[ 0.+0.j  0.+0.j  0.+0.j]
-      [ 0.+0.j  1.+0.j  0.+0.j]
-      [ 0.+0.j  0.+0.j  0.+0.j]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
-
-
-def fock(dimensions, n=None, offset=None, *, dtype=None):
-    """Bosonic Fock (number) state.
-
-    Same as :func:`qutip.states.basis`.
-
-    Parameters
-    ----------
-    dimensions : int or list of ints
-        Number of Fock states in Hilbert space.  If a list, then the resultant
-        object will be a tensor product over spaces with those dimensions.
-
-    n : int or list of ints, optional (default 0 for all dimensions)
-        Integer corresponding to desired number state, defaults to 0 for all
-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-        of equal length.
-
-    offset : int or list of ints, optional (default 0 for all dimensions)
-        The lowest number state that is included in the finite number state
-        representation of the state in the relevant dimension.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-        Requested number state :math:`\\left|n\\right>`.
-
-    Examples
-    --------
-    >>> fock(4,3) # doctest: +SKIP
-    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
-    Qobj data =
-    [[ 0.+0.j]
-     [ 0.+0.j]
-     [ 0.+0.j]
-     [ 1.+0.j]]
-
-    """
-    return basis(dimensions, n, offset=offset, dtype=dtype)
-
-
-def thermal_dm(N, n, method='operator', *, dtype=None):
-    """Density matrix for a thermal state of n particles
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    n : float
-        Expectation value for number of particles in thermal state.
-
-    method : string {'operator', 'analytic'}
-        ``string`` that sets the method used to generate the
-        thermal state probabilities
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Thermal state density matrix.
-
-    Examples
-    --------
-    >>> thermal_dm(5, 1) # doctest: +SKIP
-    Quantum object: dims = [[5], [5]], \
-shape = [5, 5], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.51612903  0.          0.          0.          0.        ]
-     [ 0.          0.25806452  0.          0.          0.        ]
-     [ 0.          0.          0.12903226  0.          0.        ]
-     [ 0.          0.          0.          0.06451613  0.        ]
-     [ 0.          0.          0.          0.          0.03225806]]
-
-
-    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
-    Quantum object: dims = [[5], [5]], \
-shape = [5, 5], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.5      0.       0.       0.       0.     ]
-     [ 0.       0.25     0.       0.       0.     ]
-     [ 0.       0.       0.125    0.       0.     ]
-     [ 0.       0.       0.       0.0625   0.     ]
-     [ 0.       0.       0.       0.       0.03125]]
-
-    Notes
-    -----
-    The 'operator' method (default) generates
-    the thermal state using the truncated number operator ``num(N)``. This
-    is the method that should be used in computations. The
-    'analytic' method uses the analytic coefficients derived in
-    an infinite Hilbert space. The analytic form is not necessarily normalized,
-    if truncated too aggressively.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if n == 0:
-        return fock_dm(N, 0, dtype=dtype)
-    else:
-        i = np.arange(N)
-        if method == 'operator':
-            beta = np.log(1.0 / n + 1.0)
-            diags = np.exp(-beta * i)
-            diags = diags / np.sum(diags)
-            # populates diagonal terms using truncated operator expression
-
-        elif method == 'analytic':
-            # populates diagonal terms using analytic values
-            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
-        else:
-            raise ValueError("The method option can only take "
-                             "values 'operator' or 'analytic'")
-        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
-        out._isherm = True
-        return out
-
-
-def maximally_mixed_dm(N, *, dtype=None):
-    """
-    Returns the maximally mixed density matrix for a Hilbert space of
-    dimension N.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Thermal state density matrix.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if not isinstance(N, numbers.Integral) or N <= 0:
-        raise ValueError("N must be integer N > 0")
-    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
-                type='oper', isherm=True, isunitary=(N == 1), copy=False)
-
-
-def ket2dm(Q):
-    """
-    Takes input ket or bra vector and returns density matrix formed by outer
-    product.  This is completely identical to calling `Q.proj()`.
-
-    Parameters
-    ----------
-    Q : qobj
-        Ket or bra type quantum object.
-
-    Returns
-    -------
-    dm : qobj
-        Density matrix formed by outer product of `Q`.
-
-    Examples
-    --------
-    >>> x=basis(3,2)
-    >>> ket2dm(x) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j  0.+0.j  0.+0.j]
-     [ 0.+0.j  0.+0.j  0.+0.j]
-     [ 0.+0.j  0.+0.j  1.+0.j]]
-
-    """
-    if Q.isket or Q.isbra:
-        return Q.proj()
-    raise TypeError("Input is not a ket or bra vector.")
-
-
-def projection(N, n, m, offset=None, *, dtype=None):
-    r"""
-    The projection operator that projects state :math:`\lvert m\rangle` on
-    state :math:`\lvert n\rangle`.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    n, m : float
-        The number states in the projection.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the projector.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-         Requested projection operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    return basis(N, n, offset=offset, dtype=dtype) @ \
-           basis(N, m, offset=offset, dtype=dtype).dag()
-
-
-def qstate(string, *, dtype=None):
-    r"""Creates a tensor product for a set of qubits in either
-    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
-
-    Parameters
-    ----------
-    string : str
-        String containing 'u' or 'd' for each qubit (ex. 'ududd')
-
-    Returns
-    -------
-    qstate : qobj
-        Qobj for tensor product corresponding to input string.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Notes
-    -----
-    Look at ket and bra for more general functions
-    creating multiparticle states.
-
-    Examples
-    --------
-    >>> qstate('udu') # doctest: +SKIP
-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    n = len(string)
-    if n != (string.count('u') + string.count('d')):
-        raise TypeError('String input to QSTATE must consist ' +
-                        'of "u" and "d" elements only')
-    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
-
-
-#
-# different qubit notation dictionary
-#
-_qubit_dict = {
-    'g': 0,  # ground state
-    'e': 1,  # excited state
-    'u': 0,  # spin up
-    'd': 1,  # spin down
-    'H': 0,  # horizontal polarization
-    'V': 1,  # vertical polarization
-}
-
-
-def _character_to_qudit(x):
-    """
-    Converts a character representing a one-particle state into int.
-    """
-    return _qubit_dict[x] if x in _qubit_dict else int(x)
-
-
-def ket(seq, dim=2, *, dtype=None):
-    """
-    Produces a multiparticle ket state for a list or string,
-    where each element stands for state of the respective particle.
-
-    Parameters
-    ----------
-    seq : str / list of ints or characters
-        Each element defines state of the respective particle.
-        (e.g. [1,1,0,1] or a string "1101").
-        For qubits it is also possible to use the following conventions:
-        - 'g'/'e' (ground and excited state)
-        - 'u'/'d' (spin up and down)
-        - 'H'/'V' (horizontal and vertical polarization)
-        Note: for dimension > 9 you need to use a list.
-
-
-    dim : int (default: 2) / list of ints
-        Space dimension for each particle:
-        int if there are the same, list if they are different.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    ket : qobj
-
-    Examples
-    --------
-    >>> ket("10") # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]]
-
-    >>> ket("Hue") # doctest: +SKIP
-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]]
-
-    >>> ket("12", 3) # doctest: +SKIP
-    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]
-     [ 0.]]
-
-    >>> ket("31", [5, 2]) # doctest: +SKIP
-    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    ns = [_character_to_qudit(x) for x in seq]
-    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
-    return basis(dim, ns, dtype=dtype)
-
-
-def bra(seq, dim=2, *, dtype=None):
-    """
-    Produces a multiparticle bra state for a list or string,
-    where each element stands for state of the respective particle.
-
-    Parameters
-    ----------
-    seq : str / list of ints or characters
-        Each element defines state of the respective particle.
-        (e.g. [1,1,0,1] or a string "1101").
-        For qubits it is also possible to use the following conventions:
-
-        - 'g'/'e' (ground and excited state)
-        - 'u'/'d' (spin up and down)
-        - 'H'/'V' (horizontal and vertical polarization)
-
-        Note: for dimension > 9 you need to use a list.
-
-
-    dim : int (default: 2) / list of ints
-        Space dimension for each particle:
-        int if there are the same, list if they are different.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    bra : qobj
-
-    Examples
-    --------
-    >>> bra("10") # doctest: +SKIP
-    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
-    Qobj data =
-    [[ 0.  0.  1.  0.]]
-
-    >>> bra("Hue") # doctest: +SKIP
-    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
-    Qobj data =
-    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
-
-    >>> bra("12", 3) # doctest: +SKIP
-    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
-    Qobj data =
-    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
-
-
-    >>> bra("31", [5, 2]) # doctest: +SKIP
-    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
-    Qobj data =
-    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return ket(seq, dim=dim, dtype=dtype).dag()
-
-
-def state_number_enumerate(dims, excitations=None):
-    """
-    An iterator that enumerates all the state number tuples (quantum numbers of
-    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
-
-    Example:
-
-        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
-        >>>     print(state) # doctest: +SKIP
-        ( 0  0 )
-        ( 0  1 )
-        ( 1  0 )
-        ( 1  1 )
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    excitations : integer (None)
-        Restrict state space to states with excitation numbers below or
-        equal to this value.
-
-    Returns
-    -------
-    state_number : tuple
-        Successive state number tuples that can be used in loops and other
-        iterations, using standard state enumeration *by definition*.
-
-    """
-
-    if excitations is None:
-        # in this case, state numbers are a direct product
-        yield from itertools.product(*(range(d) for d in dims))
-        return
-
-    # From here on, excitations is not None
-
-    # General idea of algorithm: add excitations one by one in last mode (idx =
-    # len(dims)-1), and carry over to the next index when the limit is reached.
-    # Keep track of the number of excitations while doing so to avoid having to
-    # do explicit sums over the states.
-    state = (0,)*len(dims)
-    nexc = 0
-    while True:
-        yield state
-        idx = len(dims) - 1
-        state = state[:idx] + (state[idx]+1,)
-        nexc += 1
-        while nexc > excitations or state[idx] >= dims[idx]:
-            # remove all excitations in mode idx, add one in idx-1
-            idx -= 1
-            if idx < 0:
-                return
-            nexc -= state[idx+1] - 1
-            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
-
-
-def state_number_index(dims, state):
-    """
-    Return the index of a quantum state corresponding to state,
-    given a system with dimensions given by dims.
-
-    Example:
-
-        >>> state_number_index([2, 2, 2], [1, 1, 0])
-        6
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    state : list
-        State number array.
-
-    Returns
-    -------
-    idx : int
-        The index of the state given by `state` in standard enumeration
-        ordering.
-
-    """
-    return np.ravel_multi_index(state, dims)
-
-
-def state_index_number(dims, index):
-    """
-    Return a quantum number representation given a state index, for a system
-    of composite structure defined by dims.
-
-    Example:
-
-        >>> state_index_number([2, 2, 2], 6)
-        [1, 1, 0]
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    index : integer
-        The index of the state in standard enumeration ordering.
-
-    Returns
-    -------
-    state : tuple
-        The state number tuple corresponding to index `index` in standard
-        enumeration ordering.
-
-    """
-    return np.unravel_index(index, dims)
-
-
-def state_number_qobj(dims, state, *, dtype=None):
-    """
-    Return a Qobj representation of a quantum state specified by the state
-    array `state`.
-
-    Example:
-
-        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
-        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
-shape = [8, 1], type = ket
-        Qobj data =
-        [[ 0.]
-         [ 0.]
-         [ 0.]
-         [ 0.]
-         [ 0.]
-         [ 1.]
-         [ 0.]
-         [ 0.]]
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    state : list
-        State number array.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : :class:`qutip.Qobj`
-        The state as a :class:`qutip.Qobj` instance.
-
-    .. note::
-        Deprecated in QuTiP 5.0, use :func:`basis` instead.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    warnings.warn("basis() is a drop-in replacement for this",
-                  DeprecationWarning)
-    return basis(dims, state, dtype=dtype)
-
-
-# Excitation-number restricted (enr) states
-
-def enr_state_dictionaries(dims, excitations):
-    """
-    Return the number of states, and lookup-dictionaries for translating
-    a state tuple to a state index, and vice versa, for a system with a given
-    number of components and maximum number of excitations.
-
-    Parameters
-    ----------
-    dims: list
-        A list with the number of states in each sub-system.
-
-    excitations : integer
-        The maximum numbers of dimension
-
-    Returns
-    -------
-    nstates, state2idx, idx2state: integer, dict, list
-        The number of states `nstates`, a dictionary for looking up state
-        indices from a state tuple, and a list containing the state tuples
-        ordered by state indices. state2idx and idx2state are reverses of
-        each other, i.e., state2idx[idx2state[idx]] = idx and
-        idx2state[state2idx[state]] = state.
-    """
-    idx2state = list(state_number_enumerate(dims, excitations))
-    state2idx = {state: idx for idx, state in enumerate(idx2state)}
-    nstates = len(idx2state)
-
-    return nstates, state2idx, idx2state
-
-
-def enr_fock(dims, excitations, state, *, dtype=None):
-    """
-    Generate the Fock state representation in a excitation-number restricted
-    state space. The `dims` argument is a list of integers that define the
-    number of quantums states of each component of a composite quantum system,
-    and the `excitations` specifies the maximum number of excitations for
-    the basis states that are to be included in the state space. The `state`
-    argument is a tuple of integers that specifies the state (in the number
-    basis representation) for which to generate the Fock state representation.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    state : list of integers
-        The state in the number basis representation.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    ket : Qobj
-        A Qobj instance that represent a Fock state in the exication-number-
-        restricted state space defined by `dims` and `exciations`.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
-    try:
-        data =_data.one_element[dtype]((nstates, 1),
-                                       (state2idx[tuple(state)], 0), 1)
-    except KeyError:
-        msg = (
-            "The state tuple " + str(tuple(state))
-            + " is not in the restricted state space."
-        )
-        raise ValueError(msg) from None
-    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
-
-
-def enr_thermal_dm(dims, excitations, n, *, dtype=None):
-    """
-    Generate the density operator for a thermal state in the excitation-number-
-    restricted state space defined by the `dims` and `exciations` arguments.
-    See the documentation for enr_fock for a more detailed description of
-    these arguments. The temperature of each mode in dims is specified by
-    the average number of excitatons `n`.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    n : integer
-        The average number of exciations in the thermal state. `n` can be
-        a float (which then applies to each mode), or a list/array of the same
-        length as dims, in which each element corresponds specifies the
-        temperature of the corresponding mode.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : Qobj
-        Thermal state density matrix.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
-    if not isinstance(n, (list, np.ndarray)):
-        n = np.ones(len(dims)) * n
-    else:
-        n = np.asarray(n)
-
-    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
-    diags /= np.sum(diags)
-    out = qdiags(diags, 0, dims=[dims, dims],
-                 shape=(nstates, nstates), dtype=dtype)
-    out._isherm = True
-    return out
-
-
-def phase_basis(N, m, phi0=0, *, dtype=None):
-    """
-    Basis vector for the mth phase of the Pegg-Barnett phase operator.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis vectors in Hilbert space.
-
-    m : int
-        Integer corresponding to the mth discrete phase
-        phi_m = phi0 + 2 * pi * m / N
-
-    phi0 : float (default=0)
-        Reference phase angle.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Ket vector for mth Pegg-Barnett phase operator basis state.
-
-    Notes
-    -----
-    The Pegg-Barnett basis states form a complete set over the truncated
-    Hilbert space.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    phim = phi0 + (2.0 * np.pi * m) / N
-    n = np.arange(N)[:, np.newaxis]
-    data = np.exp(1.0j * n * phim) / np.sqrt(N)
-    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
-
-
-def zero_ket(N, dims=None, *, dtype=None):
-    """
-    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
-
-    Parameters
-    ----------
-    N : int
-        Hilbert space dimensionality
-    dims : list
-        Optional dimensions if ket corresponds to
-        a composite Hilbert space.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    zero_ket : qobj
-        Zero ket on given Hilbert space.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
-
-
-def spin_state(j, m, type='ket', *, dtype=None):
-    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
-    eigenstate of the spin-j Sz operator with eigenvalue m.
-
-    Parameters
-    ----------
-    j : float
-        The spin of the state ().
-
-    m : int
-        Eigenvalue of the spin-j Sz operator.
-
-    type : string {'ket', 'bra', 'dm'}
-        Type of state to generate.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Qobj quantum object for spin state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    J = 2*j + 1
-
-    if type == 'ket':
-        return basis(int(J), int(j - m), dtype=dtype)
-    elif type == 'bra':
-        return basis(int(J), int(j - m), dtype=dtype).dag()
-    elif type == 'dm':
-        return fock_dm(int(J), int(j - m), dtype=dtype)
-    else:
-        raise ValueError(f"Invalid value keyword argument type='{type}'")
-
-
-def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
-    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
-
-    Parameters
-    ----------
-    j : float
-        The spin of the state.
-
-    theta : float
-        Angle from z axis.
-
-    phi : float
-        Angle from x axis.
-
-    type : string {'ket', 'bra', 'dm'}
-        Type of state to generate.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Qobj quantum object for spin coherent state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    if type not in ['ket', 'bra', 'dm']:
-        raise ValueError("Invalid value keyword argument 'type'")
-    Sp = jmat(j, '+')
-    Sm = jmat(j, '-')
-    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
-           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
-           spin_state(j, j)
-
-    if type == 'bra':
-        psi = psi.dag()
-    elif type == 'dm':
-        psi = ket2dm(psi)
-    return psi.to(dtype)
-
-
-_BELL_STATES = {
-    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
-    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
-    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
-    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
-}
-
-def bell_state(state='00', *, dtype=None):
-    r"""
-    Returns the selected Bell state:
-
-    .. math::
-
-        \begin{aligned}
-        \lvert B_{00}\rangle &=
-            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
-        \lvert B_{01}\rangle &=
-            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
-        \lvert B_{10}\rangle &=
-            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
-        \lvert B_{11}\rangle &=
-            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
-        \end{aligned}
-
-
-    Parameters
-    ----------
-    state : str ['00', '01', `10`, `11`]
-        Which bell state to return
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    Bell_state : qobj
-        Bell state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return _BELL_STATES[state].copy().to(dtype)
-
-
-def singlet_state(*, dtype=None):
-    r"""
-    Returns the two particle singlet-state:
-
-    .. math::
-
-        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
-
-    that is identical to the fourth bell state.
-
-    Parameters
-    ----------
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    Bell_state : qobj
-        :math:`\lvert B_{11}\rangle` Bell state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return bell_state('11').to(dtype)
-
-
-def triplet_states(*, dtype=None):
-    r"""
-    Returns a list of the two particle triplet-states:
-
-    .. math::
-
-        \lvert T_1\rangle = \lvert11\rangle
-        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
-        \lvert T_3\rangle = \lvert00\rangle
-
-    Parameters
-    ----------
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    trip_states : list
-        2 particle triplet states
-    """
-    return [
-        basis([2, 2], [1, 1], dtype=dtype),
-        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
-                        basis([2, 2], [1, 0], dtype=dtype)),
-        basis([2, 2], [0, 0], dtype=dtype),
-    ]
-
-
-def w_state(N=3, *, dtype=None):
-    """
-    Returns the N-qubit W-state:
-        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
-
-    Parameters
-    ----------
-    N : int (default=3)
-        Number of qubits in state
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    W : :obj:`~Qobj`
-        N-qubit W-state
-    """
-    inds = np.zeros(N, dtype=int)
-    inds[0] = 1
-    state = basis([2]*N, list(inds), dtype=dtype)
-    for kk in range(1, N):
-        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
-    return np.sqrt(1 / N) * state
-
-
-def ghz_state(N=3, *, dtype=None):
-    """
-    Returns the N-qubit GHZ-state:
-        ``[ |00...00> + |11...11> ] / sqrt(2)``
-
-    Parameters
-    ----------
-    N : int (default=3)
-        Number of qubits in state
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    G : qobj
-        N-qubit GHZ-state
-    """
-    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
-                           basis([2]*N, [1]*N, dtype=dtype))
+__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
+           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
+           'qstate', 'ket', 'bra', 'state_number_enumerate',
+           'state_number_index', 'state_index_number', 'state_number_qobj',
+           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
+           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
+           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
+           'enr_thermal_dm']
+
+import itertools
+import numbers
+import warnings
+
+import numpy as np
+import scipy.sparse as sp
+import itertools
+
+from . import data as _data
+from .qobj import Qobj
+from .operators import jmat, displace, qdiags
+from .tensor import tensor
+from .. import settings
+
+def _promote_to_zero_list(arg, length):
+    """
+    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
+    to `[0]*length`.  All other inputs are checked that they match the correct
+    form.
+
+    Returns
+    -------
+    list_ : list
+        A list of integers of length `length`.
+    """
+    if arg is None:
+        arg = [0]*length
+    elif not isinstance(arg, list):
+        arg = [arg]
+    if not len(arg) == length:
+        raise ValueError("All list inputs must be the same length.")
+    if all(isinstance(x, numbers.Integral) for x in arg):
+        return arg
+    raise TypeError("Dimensions must be an integer or list of integers.")
+
+
+def basis(dimensions, n=None, offset=None, *, dtype=None):
+    """Generates the vector representation of a Fock state.
+
+    Parameters
+    ----------
+    dimensions : int or list of ints
+        Number of Fock states in Hilbert space.  If a list, then the resultant
+        object will be a tensor product over spaces with those dimensions.
+
+    n : int or list of ints, optional (default 0 for all dimensions)
+        Integer corresponding to desired number state, defaults to 0 for all
+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+        of equal length.
+
+    offset : int or list of ints, optional (default 0 for all dimensions)
+        The lowest number state that is included in the finite number state
+        representation of the state in the relevant dimension.
+
+    dtype : type or str
+        storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : :class:`qutip.Qobj`
+      Qobj representing the requested number state ``|n>``.
+
+    Examples
+    --------
+    >>> basis(5,2) # doctest: +SKIP
+    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
+    Qobj data =
+    [[ 0.+0.j]
+     [ 0.+0.j]
+     [ 1.+0.j]
+     [ 0.+0.j]
+     [ 0.+0.j]]
+    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
+    Qobj data =
+    [[0.]
+     [0.]
+     [1.]
+     [0.]
+     [0.]
+     [0.]
+     [0.]
+     [0.]]
+
+
+    Notes
+    -----
+    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
+
+        basis(N, 0) = ground state
+
+    but in the qotoolbox::
+
+        basis(N, 1) = ground state
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    # Promote all parameters to lists to simplify later logic.
+    if not isinstance(dimensions, list):
+        dimensions = [dimensions]
+    n_dimensions = len(dimensions)
+    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
+                                  _promote_to_zero_list(offset, n_dimensions))]
+    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
+        raise ValueError("All dimensions must be >= 0.")
+    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
+        raise ValueError("All basis indices must be "
+                         "`offset <= n < dimension+offset`.")
+    location, size = 0, 1
+    for m, dimension in zip(reversed(ns), reversed(dimensions)):
+        location += m*size
+        size *= dimension
+
+    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
+    return Qobj(data,
+                dims=[dimensions, [1]*n_dimensions],
+                type='ket',
+                isherm=False,
+                isunitary=False,
+                copy=False)
+
+
+def qutrit_basis(*, dtype=None):
+    """Basis states for a three level system (qutrit)
+
+    dtype : type or str
+        storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    qstates : array
+        Array of qutrit basis vectors
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    out = np.empty((3,), dtype=object)
+    out[:] = [
+        basis(3, 0, dtype=dtype),
+        basis(3, 1, dtype=dtype),
+        basis(3, 2, dtype=dtype),
+    ]
+    return out
+
+_COHERENT_METHODS = ('operator', 'analytic')
+
+
+def coherent(N, alpha, offset=0, method=None, *, dtype=None):
+    """Generates a coherent state with eigenvalue alpha.
+
+    Constructed using displacement operator on vacuum state.
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    alpha : float/complex
+        Eigenvalue of coherent state.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the state. Using a non-zero offset will make the
+        default method 'analytic'.
+
+    method : string {'operator', 'analytic'}
+        Method for generating coherent state.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Qobj quantum object for coherent state
+
+    Examples
+    --------
+    >>> coherent(5,0.25j) # doctest: +SKIP
+    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
+    Qobj data =
+    [[  9.69233235e-01+0.j        ]
+     [  0.00000000e+00+0.24230831j]
+     [ -4.28344935e-02+0.j        ]
+     [  0.00000000e+00-0.00618204j]
+     [  7.80904967e-04+0.j        ]]
+
+    Notes
+    -----
+    Select method 'operator' (default) or 'analytic'. With the
+    'operator' method, the coherent state is generated by displacing
+    the vacuum state using the displacement operator defined in the
+    truncated Hilbert space of size 'N'. This method guarantees that the
+    resulting state is normalized. With 'analytic' method the coherent state
+    is generated using the analytical formula for the coherent state
+    coefficients in the Fock basis. This method does not guarantee that the
+    state is normalized if truncated to a small number of Fock states,
+    but would in that case give more accurate coefficients.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    if offset < 0:
+        raise ValueError('Offset must be non-negative')
+
+    if method is None:
+        method = "operator" if offset == 0 else "analytic"
+
+    if method == "operator":
+        if offset != 0:
+            raise ValueError(
+                "The method 'operator' does not support offset != 0. Please"
+                " select another method or set the offset to zero."
+            )
+        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
+
+    elif method == "analytic":
+        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
+        sqrtn[0] = 1  # Get rid of divide by zero warning
+        data = alpha / sqrtn
+        if offset == 0:
+            data[0] = np.exp(-abs(alpha)**2 / 2.0)
+        else:
+            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
+            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
+        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
+        return Qobj(sqrtn,
+                    dims=[[N], [1]],
+                    type='ket',
+                    copy=False).to(dtype)
+    raise TypeError(
+        "The method option can only take values in " + repr(_COHERENT_METHODS)
+    )
+
+
+def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
+    """Density matrix representation of a coherent state.
+
+    Constructed via outer product of :func:`qutip.states.coherent`
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    alpha : float/complex
+        Eigenvalue for coherent state.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the state.
+
+    method : string {'operator', 'analytic'}
+        Method for generating coherent density matrix.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Density matrix representation of coherent state.
+
+    Examples
+    --------
+    >>> coherent_dm(3,0.25j) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
+     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
+     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
+        ]]
+
+    Notes
+    -----
+    Select method 'operator' (default) or 'analytic'. With the
+    'operator' method, the coherent density matrix is generated by displacing
+    the vacuum state using the displacement operator defined in the
+    truncated Hilbert space of size 'N'. This method guarantees that the
+    resulting density matrix is normalized. With 'analytic' method the coherent
+    density matrix is generated using the analytical formula for the coherent
+    state coefficients in the Fock basis. This method does not guarantee that
+    the state is normalized if truncated to a small number of Fock states,
+    but would in that case give more accurate coefficients.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
+
+
+def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
+    """Density matrix representation of a Fock state
+
+    Constructed via outer product of :func:`qutip.states.fock`.
+
+    Parameters
+    ----------
+    dimensions : int or list of ints
+        Number of Fock states in Hilbert space.  If a list, then the resultant
+        object will be a tensor product over spaces with those dimensions.
+
+    n : int or list of ints, optional (default 0 for all dimensions)
+        Integer corresponding to desired number state, defaults to 0 for all
+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+        of equal length.
+
+    offset : int or list of ints, optional (default 0 for all dimensions)
+        The lowest number state that is included in the finite number state
+        representation of the state in the relevant dimension.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Density matrix representation of Fock state.
+
+    Examples
+    --------
+     >>> fock_dm(3,1) # doctest: +SKIP
+     Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+     Qobj data =
+     [[ 0.+0.j  0.+0.j  0.+0.j]
+      [ 0.+0.j  1.+0.j  0.+0.j]
+      [ 0.+0.j  0.+0.j  0.+0.j]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
+
+
+def fock(dimensions, n=None, offset=None, *, dtype=None):
+    """Bosonic Fock (number) state.
+
+    Same as :func:`qutip.states.basis`.
+
+    Parameters
+    ----------
+    dimensions : int or list of ints
+        Number of Fock states in Hilbert space.  If a list, then the resultant
+        object will be a tensor product over spaces with those dimensions.
+
+    n : int or list of ints, optional (default 0 for all dimensions)
+        Integer corresponding to desired number state, defaults to 0 for all
+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+        of equal length.
+
+    offset : int or list of ints, optional (default 0 for all dimensions)
+        The lowest number state that is included in the finite number state
+        representation of the state in the relevant dimension.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+        Requested number state :math:`\\left|n\\right>`.
+
+    Examples
+    --------
+    >>> fock(4,3) # doctest: +SKIP
+    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
+    Qobj data =
+    [[ 0.+0.j]
+     [ 0.+0.j]
+     [ 0.+0.j]
+     [ 1.+0.j]]
+
+    """
+    return basis(dimensions, n, offset=offset, dtype=dtype)
+
+
+def thermal_dm(N, n, method='operator', *, dtype=None):
+    """Density matrix for a thermal state of n particles
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    n : float
+        Expectation value for number of particles in thermal state.
+
+    method : string {'operator', 'analytic'}
+        ``string`` that sets the method used to generate the
+        thermal state probabilities
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Thermal state density matrix.
+
+    Examples
+    --------
+    >>> thermal_dm(5, 1) # doctest: +SKIP
+    Quantum object: dims = [[5], [5]], \
+shape = [5, 5], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.51612903  0.          0.          0.          0.        ]
+     [ 0.          0.25806452  0.          0.          0.        ]
+     [ 0.          0.          0.12903226  0.          0.        ]
+     [ 0.          0.          0.          0.06451613  0.        ]
+     [ 0.          0.          0.          0.          0.03225806]]
+
+
+    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
+    Quantum object: dims = [[5], [5]], \
+shape = [5, 5], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.5      0.       0.       0.       0.     ]
+     [ 0.       0.25     0.       0.       0.     ]
+     [ 0.       0.       0.125    0.       0.     ]
+     [ 0.       0.       0.       0.0625   0.     ]
+     [ 0.       0.       0.       0.       0.03125]]
+
+    Notes
+    -----
+    The 'operator' method (default) generates
+    the thermal state using the truncated number operator ``num(N)``. This
+    is the method that should be used in computations. The
+    'analytic' method uses the analytic coefficients derived in
+    an infinite Hilbert space. The analytic form is not necessarily normalized,
+    if truncated too aggressively.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if n == 0:
+        return fock_dm(N, 0, dtype=dtype)
+    else:
+        i = np.arange(N)
+        if method == 'operator':
+            beta = np.log(1.0 / n + 1.0)
+            diags = np.exp(-beta * i)
+            diags = diags / np.sum(diags)
+            # populates diagonal terms using truncated operator expression
+
+        elif method == 'analytic':
+            # populates diagonal terms using analytic values
+            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
+        else:
+            raise ValueError("The method option can only take "
+                             "values 'operator' or 'analytic'")
+        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
+        out._isherm = True
+        return out
+
+
+def maximally_mixed_dm(N, *, dtype=None):
+    """
+    Returns the maximally mixed density matrix for a Hilbert space of
+    dimension N.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Thermal state density matrix.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if not isinstance(N, numbers.Integral) or N <= 0:
+        raise ValueError("N must be integer N > 0")
+    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
+                type='oper', isherm=True, isunitary=(N == 1), copy=False)
+
+
+def ket2dm(Q):
+    """
+    Takes input ket or bra vector and returns density matrix formed by outer
+    product.  This is completely identical to calling `Q.proj()`.
+
+    Parameters
+    ----------
+    Q : qobj
+        Ket or bra type quantum object.
+
+    Returns
+    -------
+    dm : qobj
+        Density matrix formed by outer product of `Q`.
+
+    Examples
+    --------
+    >>> x=basis(3,2)
+    >>> ket2dm(x) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j  0.+0.j  0.+0.j]
+     [ 0.+0.j  0.+0.j  0.+0.j]
+     [ 0.+0.j  0.+0.j  1.+0.j]]
+
+    """
+    if Q.isket or Q.isbra:
+        return Q.proj()
+    raise TypeError("Input is not a ket or bra vector.")
+
+
+def projection(N, n, m, offset=None, *, dtype=None):
+    r"""
+    The projection operator that projects state :math:`\lvert m\rangle` on
+    state :math:`\lvert n\rangle`.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    n, m : float
+        The number states in the projection.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the projector.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+         Requested projection operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    return basis(N, n, offset=offset, dtype=dtype) @ \
+           basis(N, m, offset=offset, dtype=dtype).dag()
+
+
+def qstate(string, *, dtype=None):
+    r"""Creates a tensor product for a set of qubits in either
+    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
+
+    Parameters
+    ----------
+    string : str
+        String containing 'u' or 'd' for each qubit (ex. 'ududd')
+
+    Returns
+    -------
+    qstate : qobj
+        Qobj for tensor product corresponding to input string.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Notes
+    -----
+    Look at ket and bra for more general functions
+    creating multiparticle states.
+
+    Examples
+    --------
+    >>> qstate('udu') # doctest: +SKIP
+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    n = len(string)
+    if n != (string.count('u') + string.count('d')):
+        raise TypeError('String input to QSTATE must consist ' +
+                        'of "u" and "d" elements only')
+    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
+
+
+#
+# different qubit notation dictionary
+#
+_qubit_dict = {
+    'g': 0,  # ground state
+    'e': 1,  # excited state
+    'u': 0,  # spin up
+    'd': 1,  # spin down
+    'H': 0,  # horizontal polarization
+    'V': 1,  # vertical polarization
+}
+
+
+def _character_to_qudit(x):
+    """
+    Converts a character representing a one-particle state into int.
+    """
+    return _qubit_dict[x] if x in _qubit_dict else int(x)
+
+
+def ket(seq, dim=2, *, dtype=None):
+    """
+    Produces a multiparticle ket state for a list or string,
+    where each element stands for state of the respective particle.
+
+    Parameters
+    ----------
+    seq : str / list of ints or characters
+        Each element defines state of the respective particle.
+        (e.g. [1,1,0,1] or a string "1101").
+        For qubits it is also possible to use the following conventions:
+        - 'g'/'e' (ground and excited state)
+        - 'u'/'d' (spin up and down)
+        - 'H'/'V' (horizontal and vertical polarization)
+        Note: for dimension > 9 you need to use a list.
+
+
+    dim : int (default: 2) / list of ints
+        Space dimension for each particle:
+        int if there are the same, list if they are different.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    ket : qobj
+
+    Examples
+    --------
+    >>> ket("10") # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]]
+
+    >>> ket("Hue") # doctest: +SKIP
+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]]
+
+    >>> ket("12", 3) # doctest: +SKIP
+    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]
+     [ 0.]]
+
+    >>> ket("31", [5, 2]) # doctest: +SKIP
+    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    ns = [_character_to_qudit(x) for x in seq]
+    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
+    return basis(dim, ns, dtype=dtype)
+
+
+def bra(seq, dim=2, *, dtype=None):
+    """
+    Produces a multiparticle bra state for a list or string,
+    where each element stands for state of the respective particle.
+
+    Parameters
+    ----------
+    seq : str / list of ints or characters
+        Each element defines state of the respective particle.
+        (e.g. [1,1,0,1] or a string "1101").
+        For qubits it is also possible to use the following conventions:
+
+        - 'g'/'e' (ground and excited state)
+        - 'u'/'d' (spin up and down)
+        - 'H'/'V' (horizontal and vertical polarization)
+
+        Note: for dimension > 9 you need to use a list.
+
+
+    dim : int (default: 2) / list of ints
+        Space dimension for each particle:
+        int if there are the same, list if they are different.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    bra : qobj
+
+    Examples
+    --------
+    >>> bra("10") # doctest: +SKIP
+    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
+    Qobj data =
+    [[ 0.  0.  1.  0.]]
+
+    >>> bra("Hue") # doctest: +SKIP
+    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
+    Qobj data =
+    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
+
+    >>> bra("12", 3) # doctest: +SKIP
+    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
+    Qobj data =
+    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
+
+
+    >>> bra("31", [5, 2]) # doctest: +SKIP
+    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
+    Qobj data =
+    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return ket(seq, dim=dim, dtype=dtype).dag()
+
+
+def state_number_enumerate(dims, excitations=None):
+    """
+    An iterator that enumerates all the state number tuples (quantum numbers of
+    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
+
+    Example:
+
+        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
+        >>>     print(state) # doctest: +SKIP
+        ( 0  0 )
+        ( 0  1 )
+        ( 1  0 )
+        ( 1  1 )
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    excitations : integer (None)
+        Restrict state space to states with excitation numbers below or
+        equal to this value.
+
+    Returns
+    -------
+    state_number : tuple
+        Successive state number tuples that can be used in loops and other
+        iterations, using standard state enumeration *by definition*.
+
+    """
+
+    if excitations is None:
+        # in this case, state numbers are a direct product
+        yield from itertools.product(*(range(d) for d in dims))
+        return
+
+    # From here on, excitations is not None
+
+    # General idea of algorithm: add excitations one by one in last mode (idx =
+    # len(dims)-1), and carry over to the next index when the limit is reached.
+    # Keep track of the number of excitations while doing so to avoid having to
+    # do explicit sums over the states.
+    state = (0,)*len(dims)
+    nexc = 0
+    while True:
+        yield state
+        idx = len(dims) - 1
+        state = state[:idx] + (state[idx]+1,)
+        nexc += 1
+        while nexc > excitations or state[idx] >= dims[idx]:
+            # remove all excitations in mode idx, add one in idx-1
+            idx -= 1
+            if idx < 0:
+                return
+            nexc -= state[idx+1] - 1
+            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
+
+
+def state_number_index(dims, state):
+    """
+    Return the index of a quantum state corresponding to state,
+    given a system with dimensions given by dims.
+
+    Example:
+
+        >>> state_number_index([2, 2, 2], [1, 1, 0])
+        6
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    state : list
+        State number array.
+
+    Returns
+    -------
+    idx : int
+        The index of the state given by `state` in standard enumeration
+        ordering.
+
+    """
+    return np.ravel_multi_index(state, dims)
+
+
+def state_index_number(dims, index):
+    """
+    Return a quantum number representation given a state index, for a system
+    of composite structure defined by dims.
+
+    Example:
+
+        >>> state_index_number([2, 2, 2], 6)
+        [1, 1, 0]
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    index : integer
+        The index of the state in standard enumeration ordering.
+
+    Returns
+    -------
+    state : tuple
+        The state number tuple corresponding to index `index` in standard
+        enumeration ordering.
+
+    """
+    return np.unravel_index(index, dims)
+
+
+def state_number_qobj(dims, state, *, dtype=None):
+    """
+    Return a Qobj representation of a quantum state specified by the state
+    array `state`.
+
+    Example:
+
+        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
+        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
+shape = [8, 1], type = ket
+        Qobj data =
+        [[ 0.]
+         [ 0.]
+         [ 0.]
+         [ 0.]
+         [ 0.]
+         [ 1.]
+         [ 0.]
+         [ 0.]]
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    state : list
+        State number array.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : :class:`qutip.Qobj`
+        The state as a :class:`qutip.Qobj` instance.
+
+    .. note::
+        Deprecated in QuTiP 5.0, use :func:`basis` instead.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    warnings.warn("basis() is a drop-in replacement for this",
+                  DeprecationWarning)
+    return basis(dims, state, dtype=dtype)
+
+
+# Excitation-number restricted (enr) states
+
+def enr_state_dictionaries(dims, excitations):
+    """
+    Return the number of states, and lookup-dictionaries for translating
+    a state tuple to a state index, and vice versa, for a system with a given
+    number of components and maximum number of excitations.
+
+    Parameters
+    ----------
+    dims: list
+        A list with the number of states in each sub-system.
+
+    excitations : integer
+        The maximum numbers of dimension
+
+    Returns
+    -------
+    nstates, state2idx, idx2state: integer, dict, list
+        The number of states `nstates`, a dictionary for looking up state
+        indices from a state tuple, and a list containing the state tuples
+        ordered by state indices. state2idx and idx2state are reverses of
+        each other, i.e., state2idx[idx2state[idx]] = idx and
+        idx2state[state2idx[state]] = state.
+    """
+    idx2state = list(state_number_enumerate(dims, excitations))
+    state2idx = {state: idx for idx, state in enumerate(idx2state)}
+    nstates = len(idx2state)
+
+    return nstates, state2idx, idx2state
+
+
+def enr_fock(dims, excitations, state, *, dtype=None):
+    """
+    Generate the Fock state representation in a excitation-number restricted
+    state space. The `dims` argument is a list of integers that define the
+    number of quantums states of each component of a composite quantum system,
+    and the `excitations` specifies the maximum number of excitations for
+    the basis states that are to be included in the state space. The `state`
+    argument is a tuple of integers that specifies the state (in the number
+    basis representation) for which to generate the Fock state representation.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    state : list of integers
+        The state in the number basis representation.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    ket : Qobj
+        A Qobj instance that represent a Fock state in the exication-number-
+        restricted state space defined by `dims` and `exciations`.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
+    try:
+        data =_data.one_element[dtype]((nstates, 1),
+                                       (state2idx[tuple(state)], 0), 1)
+    except KeyError:
+        msg = (
+            "The state tuple " + str(tuple(state))
+            + " is not in the restricted state space."
+        )
+        raise ValueError(msg) from None
+    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
+
+
+def enr_thermal_dm(dims, excitations, n, *, dtype=None):
+    """
+    Generate the density operator for a thermal state in the excitation-number-
+    restricted state space defined by the `dims` and `exciations` arguments.
+    See the documentation for enr_fock for a more detailed description of
+    these arguments. The temperature of each mode in dims is specified by
+    the average number of excitatons `n`.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    n : integer
+        The average number of exciations in the thermal state. `n` can be
+        a float (which then applies to each mode), or a list/array of the same
+        length as dims, in which each element corresponds specifies the
+        temperature of the corresponding mode.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : Qobj
+        Thermal state density matrix.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
+    if not isinstance(n, (list, np.ndarray)):
+        n = np.ones(len(dims)) * n
+    else:
+        n = np.asarray(n)
+
+    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
+    diags /= np.sum(diags)
+    out = qdiags(diags, 0, dims=[dims, dims],
+                 shape=(nstates, nstates), dtype=dtype)
+    out._isherm = True
+    return out
+
+
+def phase_basis(N, m, phi0=0, *, dtype=None):
+    """
+    Basis vector for the mth phase of the Pegg-Barnett phase operator.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis vectors in Hilbert space.
+
+    m : int
+        Integer corresponding to the mth discrete phase
+        phi_m = phi0 + 2 * pi * m / N
+
+    phi0 : float (default=0)
+        Reference phase angle.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Ket vector for mth Pegg-Barnett phase operator basis state.
+
+    Notes
+    -----
+    The Pegg-Barnett basis states form a complete set over the truncated
+    Hilbert space.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    phim = phi0 + (2.0 * np.pi * m) / N
+    n = np.arange(N)[:, np.newaxis]
+    data = np.exp(1.0j * n * phim) / np.sqrt(N)
+    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
+
+
+def zero_ket(N, dims=None, *, dtype=None):
+    """
+    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
+
+    Parameters
+    ----------
+    N : int
+        Hilbert space dimensionality
+    dims : list
+        Optional dimensions if ket corresponds to
+        a composite Hilbert space.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    zero_ket : qobj
+        Zero ket on given Hilbert space.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
+
+
+def spin_state(j, m, type='ket', *, dtype=None):
+    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
+    eigenstate of the spin-j Sz operator with eigenvalue m.
+
+    Parameters
+    ----------
+    j : float
+        The spin of the state ().
+
+    m : int
+        Eigenvalue of the spin-j Sz operator.
+
+    type : string {'ket', 'bra', 'dm'}
+        Type of state to generate.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Qobj quantum object for spin state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    J = 2*j + 1
+
+    if type == 'ket':
+        return basis(int(J), int(j - m), dtype=dtype)
+    elif type == 'bra':
+        return basis(int(J), int(j - m), dtype=dtype).dag()
+    elif type == 'dm':
+        return fock_dm(int(J), int(j - m), dtype=dtype)
+    else:
+        raise ValueError(f"Invalid value keyword argument type='{type}'")
+
+
+def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
+    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
+
+    Parameters
+    ----------
+    j : float
+        The spin of the state.
+
+    theta : float
+        Angle from z axis.
+
+    phi : float
+        Angle from x axis.
+
+    type : string {'ket', 'bra', 'dm'}
+        Type of state to generate.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Qobj quantum object for spin coherent state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    if type not in ['ket', 'bra', 'dm']:
+        raise ValueError("Invalid value keyword argument 'type'")
+    Sp = jmat(j, '+')
+    Sm = jmat(j, '-')
+    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
+           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
+           spin_state(j, j)
+
+    if type == 'bra':
+        psi = psi.dag()
+    elif type == 'dm':
+        psi = ket2dm(psi)
+    return psi.to(dtype)
+
+
+_BELL_STATES = {
+    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
+    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
+    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
+    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
+}
+
+def bell_state(state='00', *, dtype=None):
+    r"""
+    Returns the selected Bell state:
+
+    .. math::
+
+        \begin{aligned}
+        \lvert B_{00}\rangle &=
+            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
+        \lvert B_{01}\rangle &=
+            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
+        \lvert B_{10}\rangle &=
+            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
+        \lvert B_{11}\rangle &=
+            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
+        \end{aligned}
+
+
+    Parameters
+    ----------
+    state : str ['00', '01', `10`, `11`]
+        Which bell state to return
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    Bell_state : qobj
+        Bell state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return _BELL_STATES[state].copy().to(dtype)
+
+
+def singlet_state(*, dtype=None):
+    r"""
+    Returns the two particle singlet-state:
+
+    .. math::
+
+        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
+
+    that is identical to the fourth bell state.
+
+    Parameters
+    ----------
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    Bell_state : qobj
+        :math:`\lvert B_{11}\rangle` Bell state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return bell_state('11').to(dtype)
+
+
+def triplet_states(*, dtype=None):
+    r"""
+    Returns a list of the two particle triplet-states:
+
+    .. math::
+
+        \lvert T_1\rangle = \lvert11\rangle
+        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
+        \lvert T_3\rangle = \lvert00\rangle
+
+    Parameters
+    ----------
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    trip_states : list
+        2 particle triplet states
+    """
+    return [
+        basis([2, 2], [1, 1], dtype=dtype),
+        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
+                        basis([2, 2], [1, 0], dtype=dtype)),
+        basis([2, 2], [0, 0], dtype=dtype),
+    ]
+
+
+def w_state(N=3, *, dtype=None):
+    """
+    Returns the N-qubit W-state:
+        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
+
+    Parameters
+    ----------
+    N : int (default=3)
+        Number of qubits in state
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    W : :obj:`~Qobj`
+        N-qubit W-state
+    """
+    inds = np.zeros(N, dtype=int)
+    inds[0] = 1
+    state = basis([2]*N, list(inds), dtype=dtype)
+    for kk in range(1, N):
+        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
+    return np.sqrt(1 / N) * state
+
+
+def ghz_state(N=3, *, dtype=None):
+    """
+    Returns the N-qubit GHZ-state:
+        ``[ |00...00> + |11...11> ] / sqrt(2)``
+
+    Parameters
+    ----------
+    N : int (default=3)
+        Number of qubits in state
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    G : qobj
+        N-qubit GHZ-state
+    """
+    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
+                           basis([2]*N, [1]*N, dtype=dtype))
diff --git a/qutip/core/subsystem_apply.py b/qutip/core/subsystem_apply.py
index 013bcbc7d2..ecc237dd6f 100644
--- a/qutip/core/subsystem_apply.py
+++ b/qutip/core/subsystem_apply.py
@@ -1,210 +1,210 @@
-#
-# This code was contributed by Ben Criger. Resemblance to
-# partial_transpose is intentional, and meant to enhance legibility.
-#
-
-__all__ = ['subsystem_apply']
-
-import itertools
-
-import numpy as np
-
-from . import Qobj, qeye, to_kraus, tensor
-from . import data as _data
-
-
-def subsystem_apply(state, channel, mask, reference=False):
-    """
-    Returns the result of applying the propagator `channel` to the
-    subsystems indicated in `mask`, which comprise the density operator
-    `state`.
-
-    Parameters
-    ----------
-    state : :class:`qutip.qobj`
-        A density matrix or ket.
-
-    channel : :class:`qutip.qobj`
-        A propagator, either an `oper` or `super`.
-
-    mask : *list* / *array*
-        A mask that selects which subsystems should be subjected to the
-        channel.
-
-    reference : bool
-        Decides whether explicit Kraus map should be used to evaluate action
-        of channel.
-
-    Returns
-    -------
-    rho_out: :class:`qutip.qobj`
-        A density matrix with the selected subsystems transformed
-        according to the specified channel.
-    """
-    # TODO: Include sparse/dense methods a la partial_transpose.
-    if not (state.isket or state.isoper):
-        raise ValueError("input state must be a ket or oper")
-    if not (channel.issuper or channel.isoper):
-        raise ValueError("input channel must be a super or oper")
-    # Since there's only one channel, all affected subsystems must have
-    # the same dimensions:
-    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
-    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
-           for j in range(len(aff_subs_dim_ar))):
-        raise ValueError("affected subsystems must have the same dimension")
-    # If the map is on the Hilbert space, it must have the same dimension
-    # as the affected subsystem. If it is on the Liouville space, it must
-    # exist on a space as large as the square of the Hilbert dimension.
-    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
-                      else aff_subs_dim_ar[0])
-    if tuple(required_shape) != channel.shape:
-        raise ValueError(
-            "superoperator dimension must be the subsystem dimension squared"
-        )
-    mask = np.asarray(mask)
-    if reference:
-        return _subsystem_apply_reference(state, channel, mask)
-    if state.isoper:
-        return _subsystem_apply_dm(state, channel, mask)
-    return _subsystem_apply_ket(state, channel, mask)
-
-
-def _subsystem_apply_ket(state, channel, mask):
-    # TODO Write more efficient code for single-matrix map on pure states
-    # TODO Write more efficient code for single-subsystem map . . .
-    return _subsystem_apply_dm(state.proj(), channel, mask)
-
-
-def _subsystem_apply_dm(state, channel, mask):
-    """
-    Applies a channel to every subsystem indicated by a mask, by
-    repeatedly applying the channel to each affected subsystem.
-    """
-    # Initialize Output Matrix
-    rho_out = state
-    # checked affected subsystems print arange(len(state.dims[0]))[mask]
-    for subsystem in np.arange(len(state.dims[0]))[mask]:
-        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
-    return rho_out
-
-
-def _one_subsystem_apply(state, channel, idx):
-    """
-    Applies a channel to a state on one subsystem, by breaking it into
-    blocks and applying a reduced channel to each block.
-    """
-    subs_dim_ar = np.array(state.dims).T
-
-    # Calculate number of blocks
-    n_blks = 1
-    for mul_idx in range(idx):
-        n_blks = n_blks * subs_dim_ar[mul_idx][0]
-    blk_sz = state.shape[0] // n_blks
-
-    # Apply channel to top subsystem of each block in matrix
-    full_data_matrix = state.full()
-    for blk_r in range(n_blks):
-        for blk_c in range(n_blks):
-            # Apply channel to high-level blocks of matrix:
-            blk_rx = blk_r * blk_sz
-            blk_cx = blk_c * blk_sz
-
-            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
-                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
-                                              blk_cx : blk_cx+blk_sz],
-                             channel)
-    return Qobj(full_data_matrix, dims=state.dims)
-
-
-def _block_apply(block, channel):
-    return (_top_apply_U(block, channel) if channel.isoper
-            else _top_apply_S(block, channel))
-
-
-def _top_apply_U(block, channel):
-    """
-    Uses scalar-matrix multiplication to efficiently apply a channel to
-    the leftmost register in the tensor product, given a unitary matrix
-    for a channel.
-    """
-    split_mat = _block_split(block, *channel.shape)
-    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
-    for dm_row_idx in range(channel.shape[0]):
-        for dm_col_idx in range(channel.shape[1]):
-            for op_row_idx in range(channel.shape[0]):
-                for op_col_idx in range(channel.shape[1]):
-                    temp_split_mat[dm_row_idx][dm_col_idx] += (
-                        channel[dm_row_idx, op_col_idx]
-                        * channel[dm_col_idx, op_row_idx].conjugate()
-                        * split_mat[op_col_idx][op_row_idx]
-                    )
-    return _block_join(temp_split_mat)
-
-
-def _top_apply_S(block, channel):
-    # If the channel is a super-operator, perform second block decomposition;
-    # block-size matches Hilbert space of affected subsystem:
-    # FIXME use state shape?
-    n_v = int(np.sqrt(channel.shape[0]))
-    n_h = int(np.sqrt(channel.shape[1]))
-    column = _block_col(block, n_v, n_h)
-    chan_mat = channel.full()
-    temp_col = np.zeros(np.shape(column)).astype(complex)
-    for i, row in enumerate(chan_mat):
-        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
-    return _block_stack(temp_col, n_v, n_h)
-
-
-def _block_split(mat_in, n_v, n_h):
-    """
-    Returns a 4D array of matrices, splitting mat_in into
-    n_v * n_h square sub-arrays.
-    """
-    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
-
-
-def _block_join(mat_in):
-    return np.hstack(np.hstack(mat_in))
-
-
-def _block_col(mat_in, n_v, n_h):
-    """
-    Returns a 3D array of matrices, splitting mat_in into
-    n_v * n_h square sub-arrays.
-    """
-    rows, cols = np.shape(mat_in)
-    return np.reshape(
-        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
-        (n_v * n_h, rows // n_v, cols // n_h)
-    )
-
-
-def _block_stack(arr_in, n_v, n_h):
-    """
-    Inverse of _block_split
-    """
-    rs, cs = np.shape(arr_in)[-2:]
-    temp = list(map(np.transpose, arr_in))
-    # print shape(arr_in)
-    temp = np.reshape(temp, (n_v, n_h, rs, cs))
-    return np.hstack(np.hstack(temp)).T
-
-
-def _subsystem_apply_reference(state, channel, mask):
-    state = state.proj() if state.isket else state
-    if channel.isoper:
-        full_oper = tensor([channel if mask_ else qeye(size)
-                            for size, mask_ in zip(state.dims[0], mask)])
-        return full_oper @ state @ full_oper.dag()
-    kraus_list = to_kraus(channel)
-    # Kraus operators to be padded with identities:
-    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
-    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
-    for operator_iter in k_qubit_kraus_list:
-        operator_iter = iter(operator_iter)
-        op_iter_list = [next(operator_iter) if mask[j]
-                        else qeye(state.dims[0][j])
-                        for j in range(len(state.dims[0]))]
-        full_oper = tensor(list(map(Qobj, op_iter_list)))
-        rho_out = rho_out + full_oper * state * full_oper.dag()
-    return rho_out
+#
+# This code was contributed by Ben Criger. Resemblance to
+# partial_transpose is intentional, and meant to enhance legibility.
+#
+
+__all__ = ['subsystem_apply']
+
+import itertools
+
+import numpy as np
+
+from . import Qobj, qeye, to_kraus, tensor
+from . import data as _data
+
+
+def subsystem_apply(state, channel, mask, reference=False):
+    """
+    Returns the result of applying the propagator `channel` to the
+    subsystems indicated in `mask`, which comprise the density operator
+    `state`.
+
+    Parameters
+    ----------
+    state : :class:`qutip.qobj`
+        A density matrix or ket.
+
+    channel : :class:`qutip.qobj`
+        A propagator, either an `oper` or `super`.
+
+    mask : *list* / *array*
+        A mask that selects which subsystems should be subjected to the
+        channel.
+
+    reference : bool
+        Decides whether explicit Kraus map should be used to evaluate action
+        of channel.
+
+    Returns
+    -------
+    rho_out: :class:`qutip.qobj`
+        A density matrix with the selected subsystems transformed
+        according to the specified channel.
+    """
+    # TODO: Include sparse/dense methods a la partial_transpose.
+    if not (state.isket or state.isoper):
+        raise ValueError("input state must be a ket or oper")
+    if not (channel.issuper or channel.isoper):
+        raise ValueError("input channel must be a super or oper")
+    # Since there's only one channel, all affected subsystems must have
+    # the same dimensions:
+    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
+    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
+           for j in range(len(aff_subs_dim_ar))):
+        raise ValueError("affected subsystems must have the same dimension")
+    # If the map is on the Hilbert space, it must have the same dimension
+    # as the affected subsystem. If it is on the Liouville space, it must
+    # exist on a space as large as the square of the Hilbert dimension.
+    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
+                      else aff_subs_dim_ar[0])
+    if tuple(required_shape) != channel.shape:
+        raise ValueError(
+            "superoperator dimension must be the subsystem dimension squared"
+        )
+    mask = np.asarray(mask)
+    if reference:
+        return _subsystem_apply_reference(state, channel, mask)
+    if state.isoper:
+        return _subsystem_apply_dm(state, channel, mask)
+    return _subsystem_apply_ket(state, channel, mask)
+
+
+def _subsystem_apply_ket(state, channel, mask):
+    # TODO Write more efficient code for single-matrix map on pure states
+    # TODO Write more efficient code for single-subsystem map . . .
+    return _subsystem_apply_dm(state.proj(), channel, mask)
+
+
+def _subsystem_apply_dm(state, channel, mask):
+    """
+    Applies a channel to every subsystem indicated by a mask, by
+    repeatedly applying the channel to each affected subsystem.
+    """
+    # Initialize Output Matrix
+    rho_out = state
+    # checked affected subsystems print arange(len(state.dims[0]))[mask]
+    for subsystem in np.arange(len(state.dims[0]))[mask]:
+        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
+    return rho_out
+
+
+def _one_subsystem_apply(state, channel, idx):
+    """
+    Applies a channel to a state on one subsystem, by breaking it into
+    blocks and applying a reduced channel to each block.
+    """
+    subs_dim_ar = np.array(state.dims).T
+
+    # Calculate number of blocks
+    n_blks = 1
+    for mul_idx in range(idx):
+        n_blks = n_blks * subs_dim_ar[mul_idx][0]
+    blk_sz = state.shape[0] // n_blks
+
+    # Apply channel to top subsystem of each block in matrix
+    full_data_matrix = state.full()
+    for blk_r in range(n_blks):
+        for blk_c in range(n_blks):
+            # Apply channel to high-level blocks of matrix:
+            blk_rx = blk_r * blk_sz
+            blk_cx = blk_c * blk_sz
+
+            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
+                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
+                                              blk_cx : blk_cx+blk_sz],
+                             channel)
+    return Qobj(full_data_matrix, dims=state.dims)
+
+
+def _block_apply(block, channel):
+    return (_top_apply_U(block, channel) if channel.isoper
+            else _top_apply_S(block, channel))
+
+
+def _top_apply_U(block, channel):
+    """
+    Uses scalar-matrix multiplication to efficiently apply a channel to
+    the leftmost register in the tensor product, given a unitary matrix
+    for a channel.
+    """
+    split_mat = _block_split(block, *channel.shape)
+    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
+    for dm_row_idx in range(channel.shape[0]):
+        for dm_col_idx in range(channel.shape[1]):
+            for op_row_idx in range(channel.shape[0]):
+                for op_col_idx in range(channel.shape[1]):
+                    temp_split_mat[dm_row_idx][dm_col_idx] += (
+                        channel[dm_row_idx, op_col_idx]
+                        * channel[dm_col_idx, op_row_idx].conjugate()
+                        * split_mat[op_col_idx][op_row_idx]
+                    )
+    return _block_join(temp_split_mat)
+
+
+def _top_apply_S(block, channel):
+    # If the channel is a super-operator, perform second block decomposition;
+    # block-size matches Hilbert space of affected subsystem:
+    # FIXME use state shape?
+    n_v = int(np.sqrt(channel.shape[0]))
+    n_h = int(np.sqrt(channel.shape[1]))
+    column = _block_col(block, n_v, n_h)
+    chan_mat = channel.full()
+    temp_col = np.zeros(np.shape(column)).astype(complex)
+    for i, row in enumerate(chan_mat):
+        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
+    return _block_stack(temp_col, n_v, n_h)
+
+
+def _block_split(mat_in, n_v, n_h):
+    """
+    Returns a 4D array of matrices, splitting mat_in into
+    n_v * n_h square sub-arrays.
+    """
+    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
+
+
+def _block_join(mat_in):
+    return np.hstack(np.hstack(mat_in))
+
+
+def _block_col(mat_in, n_v, n_h):
+    """
+    Returns a 3D array of matrices, splitting mat_in into
+    n_v * n_h square sub-arrays.
+    """
+    rows, cols = np.shape(mat_in)
+    return np.reshape(
+        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
+        (n_v * n_h, rows // n_v, cols // n_h)
+    )
+
+
+def _block_stack(arr_in, n_v, n_h):
+    """
+    Inverse of _block_split
+    """
+    rs, cs = np.shape(arr_in)[-2:]
+    temp = list(map(np.transpose, arr_in))
+    # print shape(arr_in)
+    temp = np.reshape(temp, (n_v, n_h, rs, cs))
+    return np.hstack(np.hstack(temp)).T
+
+
+def _subsystem_apply_reference(state, channel, mask):
+    state = state.proj() if state.isket else state
+    if channel.isoper:
+        full_oper = tensor([channel if mask_ else qeye(size)
+                            for size, mask_ in zip(state.dims[0], mask)])
+        return full_oper @ state @ full_oper.dag()
+    kraus_list = to_kraus(channel)
+    # Kraus operators to be padded with identities:
+    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
+    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
+    for operator_iter in k_qubit_kraus_list:
+        operator_iter = iter(operator_iter)
+        op_iter_list = [next(operator_iter) if mask[j]
+                        else qeye(state.dims[0][j])
+                        for j in range(len(state.dims[0]))]
+        full_oper = tensor(list(map(Qobj, op_iter_list)))
+        rho_out = rho_out + full_oper * state * full_oper.dag()
+    return rho_out
diff --git a/qutip/core/superop_reps.py b/qutip/core/superop_reps.py
index c48f05fd1a..10fdda0fdb 100644
--- a/qutip/core/superop_reps.py
+++ b/qutip/core/superop_reps.py
@@ -1,522 +1,522 @@
-# -*- coding: utf-8 -*-
-#
-# This module was initially contributed by Ben Criger.
-#
-"""
-This module implements transformations between superoperator representations,
-including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
-"""
-
-__all__ = [
-    'kraus_to_choi', 'kraus_to_super',
-    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
-]
-
-import itertools
-import numbers
-
-import numpy as np
-import scipy.linalg
-
-from . import data as _data
-from .superoperator import stack_columns, unstack_columns, sprepost
-from .tensor import tensor
-from .dimensions import flatten
-from .qobj import Qobj
-from .operators import identity, sigmax, sigmay, sigmaz
-from .states import basis
-
-
-# TODO: revisit when creation routines have dispatching.
-_SINGLE_QUBIT_PAULI_BASIS = (
-    identity(2).to(_data.CSR),
-    sigmax().to(_data.CSR),
-    sigmay().to(_data.CSR),
-    sigmaz().to(_data.CSR),
-)
-
-
-def _superpauli_basis(nq=1):
-    dims = [[[2] * nq] * 2] * 2
-    nnz = 8**nq
-    data = _data.csr.empty(4**nq, 4**nq, nnz)
-    sci = data.as_scipy(full=True)
-    ptr, ptr_inc = 0, 2**nq
-    # Construct the Pauli basis by vertically stacking rows in sparse format.
-    # The CSR format is much more efficient at handling row-stacking, so we
-    # actually have to do a little dance through adjoint/transpose to get it
-    # into the right format.
-    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
-                                                 repeat=nq)):
-        basis = paulis[0].data
-        for pauli in paulis[1:]:
-            basis = _data.kron_csr(basis, pauli.data)
-        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
-        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
-        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
-        sci.indptr[i] = ptr
-        ptr += ptr_inc
-    sci.indptr[-1] = nnz
-    return Qobj(data.adjoint(),
-                dims=dims,
-                type='super',
-                superrep='super',
-                isherm=False,
-                isunitary=False,
-                copy=False)
-
-
-def _int_log_two(x):
-    return int(x).bit_length() - 1
-
-
-def _is_power_of_two(x):
-    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
-
-
-def _nq(dims):
-    dim = np.prod(dims[0][0])
-    nq = _int_log_two(dim)
-    if 2 ** nq != dim:
-        raise ValueError("{} is not an integer power of 2.".format(dim))
-    return nq
-
-
-def isqubitdims(dims):
-    """
-    Checks whether all entries in a dims list are integer powers of 2.
-
-    Parameters
-    ----------
-    dims : nested list of ints
-        Dimensions to be checked.
-
-    Returns
-    -------
-    isqubitdims : bool
-        True if and only if every member of the flattened dims
-        list is an integer power of 2.
-    """
-    return all(_is_power_of_two(dim) for dim in flatten(dims))
-
-
-def _to_superpauli(q_oper):
-    """
-    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
-
-    This is an internal function, as QuTiP does not currently have
-    a way to mark that superoperators are represented in the Pauli
-    basis as opposed to the column-stacking basis; a Pauli-basis
-    ``type='super'`` would thus break other conversion functions.
-    """
-    # Ensure we start with a column-stacking-basis superoperator.
-    sqobj = to_super(q_oper)
-    if not isqubitdims(sqobj.dims):
-        raise ValueError("Pauli basis is only defined for qubits.")
-    nq = _int_log_two(sqobj.shape[0]) // 2
-    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
-    # To do this, we have to hack a bit and force the dims to match,
-    # since the superpauli_basis function makes different assumptions
-    # about indices than we need here.
-    B.dims = sqobj.dims
-    return B.dag() @ sqobj @ B
-
-
-def _choi_to_kraus(q_oper, tol=1e-9):
-    """
-    Takes a Choi matrix and returns a list of Kraus operators.
-    TODO: Create a new class structure for quantum channels, perhaps as a
-    strict sub-class of Qobj.
-    """
-    vals, vecs = q_oper.eigenstates()
-    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
-    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
-    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
-                 dims=dims, type='oper', copy='False')
-            for val, vec in zip(vals, vecs) if abs(val) >= tol]
-
-
-# Individual conversions from Kraus operators are public because the output
-# list of Kraus operators is not itself a quantum object.
-
-def kraus_to_choi(kraus_list):
-    """
-    Take a list of Kraus operators and returns the Choi matrix for the channel
-    represented by the Kraus operators in `kraus_list`
-    """
-    kraus_mat_list = [k.full() for k in kraus_list]
-    op_rng = list(range(kraus_mat_list[0].shape[1]))
-    choi_blocks = np.array(
-        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
-              for op in kraus_mat_list)
-          for r_ix in op_rng]
-         for c_ix in op_rng]
-    )
-    return Qobj(np.hstack(np.hstack(choi_blocks)),
-                dims=[kraus_list[0].dims[::-1]]*2,
-                type='super',
-                superrep='choi',
-                copy=False)
-
-
-def kraus_to_super(kraus_list):
-    """
-    Convert a list of Kraus operators to a superoperator.
-    """
-    return to_super(kraus_to_choi(kraus_list))
-
-
-def _super_tofrom_choi(q_oper):
-    """
-    We exploit that the basis transformation between Choi and supermatrix
-    representations squares to the identity, so that if we munge Qobj.type,
-    we can use the same function.
-    """
-    if not q_oper.issuper:
-        raise ValueError("needs to be a superoperator")
-    if q_oper.superrep not in ('super', 'choi'):
-        raise ValueError("operator is not in super or choi format")
-    data = q_oper.data.to_array()
-    dims = q_oper.dims
-    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
-    d0 = np.prod(flatten(new_dims[0]))
-    d1 = np.prod(flatten(new_dims[1]))
-    s0 = np.prod(dims[0][0])
-    s1 = np.prod(dims[1][1])
-    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
-    return Qobj(data,
-                dims=new_dims,
-                type='super',
-                superrep='super' if q_oper.superrep == 'choi' else 'choi',
-                copy=False)
-
-
-def _choi_to_chi(q_oper):
-    """
-    Converts a Choi matrix to a Chi matrix in the Pauli basis.
-
-    NOTE: this is only supported for qubits right now. Need to extend to
-    Heisenberg-Weyl for other subsystem dimensions.
-    """
-    nq = _nq(q_oper.dims)
-    B = _superpauli_basis(nq).data
-    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
-                dims=q_oper.dims,
-                type='super',
-                superrep='chi',
-                copy=False)
-
-
-def _chi_to_choi(q_oper):
-    """
-    Converts a Chi matrix to a Choi matrix.
-
-    NOTE: this is only supported for qubits right now. Need to extend to
-    Heisenberg-Weyl for other subsystem dimensions.
-    """
-    nq = _nq(q_oper.dims)
-    B = _superpauli_basis(nq).data
-    # The Chi matrix has tr(chi) == d², so we need to divide out
-    # by that to get back to the Choi form.
-    return Qobj(_data.mul(
-                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
-                    1 / q_oper.shape[0]
-                ),
-                dims=q_oper.dims,
-                type='super',
-                superrep='choi',
-                copy=False)
-
-
-def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
-    """
-    Given a partial isometry U and a vector of square-roots of singular values
-    S obtained from a SVD, produces the Kraus operators represented by U.
-
-    Returns
-    -------
-    Ks : list of Qobj
-        Quantum objects represnting each of the Kraus operators.
-    """
-    # We use U * S since S is 1-index, such that this is equivalent to
-    # U . diag(S), but easier to write down.
-    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
-    return [
-        Qobj(x,
-             dims=[outdims, indims],
-             type='oper',
-             copy=False)
-        for x in data
-    ]
-
-
-def _generalized_kraus(q_oper, threshold=1e-10):
-    # TODO: document!
-    # TODO: use this to generalize to_kraus to the case where U != V.
-    #       This is critical for non-CP maps, as appear in (for example)
-    #       diamond norm differences between two CP maps.
-    if not q_oper.issuper or q_oper.superrep != "choi":
-        raise ValueError("".join([
-            "Expected a Choi matrix, got a ", repr(q_oper.type),
-            " (superrep ", repr(q_oper.superrep), ")."
-        ]))
-
-    # Remember the shape of the underlying space,
-    # as we'll need this to make Kraus operators later.
-    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
-    # Also remember the dims breakout.
-    out_dims, in_dims = q_oper.dims
-    out_left, out_right = out_dims
-    in_left, in_right = in_dims
-
-    # Find the SVD.
-    U, S, V = scipy.linalg.svd(q_oper.full())
-
-    # Truncate away the zero singular values, up to a threshold.
-    nonzero_idxs = S > threshold
-    dK = nonzero_idxs.sum()
-    U = np.array(U)[:, nonzero_idxs]
-    # We also want S to be a single index array, which np.matrix
-    # doesn't allow for. This is stripped by calling array() on it.
-    S = np.sqrt(np.array(S)[nonzero_idxs])
-    # Since NumPy returns V and not V+, we need to take the dagger
-    # to get back to quantum info notation for Stinespring pairs.
-    V = np.array(V.conj().T)[:, nonzero_idxs]
-
-    # Next, we convert each of U and V into Kraus operators.
-    # Finally, we want the Kraus index to be left-most so that we
-    # can map over it when making Qobjs.
-    # FIXME: does not preserve dims!
-    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
-    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
-
-    return kU, kV
-
-
-def _choi_to_stinespring(q_oper, threshold=1e-10):
-    # TODO: document!
-    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
-
-    assert len(kU) == len(kV)
-    dK = len(kU)
-    dL = kU[0].shape[0]
-    dR = kV[0].shape[1]
-    # Also remember the dims breakout.
-    out_dims, in_dims = q_oper.dims
-    out_left, out_right = out_dims
-    in_left, in_right = in_dims
-
-    A = Qobj(_data.zeros(dK * dL, dL),
-             dims=[out_left + [dK], out_right + [1]],
-             type='oper',
-             isherm=True,
-             isunitary=False,
-             copy=False)
-    B = Qobj(_data.zeros(dK * dR, dR),
-             dims=[in_left + [dK], in_right + [1]],
-             type='oper',
-             isherm=True,
-             isunitary=False,
-             copy=False)
-
-    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
-        A += tensor(KL, basis(dK, idx_kraus))
-        B += tensor(KR, basis(dK, idx_kraus))
-
-    # There is no input (right) Kraus index, so strip that off.
-    del A.dims[1][-1]
-    del B.dims[1][-1]
-
-    return A, B
-
-
-def to_choi(q_oper):
-    """
-    Converts a Qobj representing a quantum map to the Choi representation,
-    such that the trace of the returned operator is equal to the dimension
-    of the system.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to Choi representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
-
-    Returns
-    -------
-    choi : Qobj
-        A quantum object representing the same map as ``q_oper``, such that
-        ``choi.superrep == "choi"``.
-
-    Raises
-    ------
-    TypeError: if the given quantum object is not a map, or cannot be converted
-        to Choi representation.
-    """
-    if q_oper.type == 'super':
-        if q_oper.superrep == 'choi':
-            return q_oper
-        if q_oper.superrep == 'super':
-            return _super_tofrom_choi(q_oper)
-        if q_oper.superrep == 'chi':
-            return _chi_to_choi(q_oper)
-        else:
-            raise TypeError(q_oper.superrep)
-    elif q_oper.type == 'oper':
-        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
-    else:
-        raise TypeError(
-            "Conversion of Qobj with type = {0.type} "
-            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
-        )
-
-
-def to_chi(q_oper):
-    """
-    Converts a Qobj representing a quantum map to a representation as a chi
-    (process) matrix in the Pauli basis, such that the trace of the returned
-    operator is equal to the dimension of the system.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to Chi representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
-
-    Returns
-    -------
-    chi : Qobj
-        A quantum object representing the same map as ``q_oper``, such that
-        ``chi.superrep == "chi"``.
-
-    Raises
-    ------
-    TypeError: if the given quantum object is not a map, or cannot be converted
-        to Chi representation.
-    """
-    if q_oper.type == 'super':
-        if q_oper.superrep == 'chi':
-            return q_oper
-        elif q_oper.superrep == 'choi':
-            return _choi_to_chi(q_oper)
-        elif q_oper.superrep == 'super':
-            return _choi_to_chi(to_choi(q_oper))
-        else:
-            raise TypeError(q_oper.superrep)
-    elif q_oper.type == 'oper':
-        return to_chi(sprepost(q_oper, q_oper.dag()))
-    else:
-        raise TypeError(
-            "Conversion of Qobj with type = {0.type} "
-            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
-        )
-
-
-def to_super(q_oper):
-    """
-    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
-    representation.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to supermatrix representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_super(A) == sprepost(A, A.dag())``.
-
-    Returns
-    -------
-    superop : Qobj
-        A quantum object representing the same map as ``q_oper``, such that
-        ``superop.superrep == "super"``.
-
-    Raises
-    ------
-    TypeError
-        If the given quantum object is not a map, or cannot be converted
-        to supermatrix representation.
-    """
-    if q_oper.type == 'super':
-        if q_oper.superrep == "super":
-            return q_oper
-        elif q_oper.superrep == 'choi':
-            return _super_tofrom_choi(q_oper)
-        elif q_oper.superrep == 'chi':
-            return to_super(to_choi(q_oper))
-        else:
-            raise ValueError(
-                "Unrecognized superrep '{}'.".format(q_oper.superrep))
-    elif q_oper.type == 'oper':  # Assume unitary
-        return sprepost(q_oper, q_oper.dag())
-    else:
-        raise TypeError(
-            "Conversion of Qobj with type = {0.type} "
-            "and superrep = {0.superrep} to supermatrix not "
-            "supported.".format(q_oper)
-        )
-
-
-def to_kraus(q_oper, tol=1e-9):
-    """
-    Converts a Qobj representing a quantum map to a list of quantum objects,
-    each representing an operator in the Kraus decomposition of the given map.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to Kraus representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
-
-    tol : Float
-        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
-        The default is to=1e-9.
-
-    Returns
-    -------
-    kraus_ops : list of Qobj
-        A list of quantum objects, each representing a Kraus operator in the
-        decomposition of ``q_oper``.
-
-    Raises
-    ------
-    TypeError: if the given quantum object is not a map, or cannot be
-        decomposed into Kraus operators.
-    """
-    if q_oper.issuper:
-        if q_oper.superrep != 'choi':
-            q_oper = to_choi(q_oper)
-        return _choi_to_kraus(q_oper, tol)
-    elif q_oper.isoper:  # Assume unitary
-        return [q_oper]
-    raise TypeError(
-        "Conversion of Qobj with type={0.type} "
-        "and superrep={0.superrep} to Kraus decomposition not "
-        "supported.".format(q_oper)
-    )
-
-
-def to_stinespring(q_oper, threshold=1e-10):
-    r"""
-    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
-    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
-    all inputs $X$, where the partial trace is taken over a a new index on the
-    output dimensions of $A$ and $B$.
-
-    For completely positive inputs, $A$ will always equal $B$ up to precision
-    errors.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to a Stinespring pair.
-
-    Returns
-    -------
-    A, B : Qobj
-        Quantum objects representing each of the Stinespring matrices for the
-        input Qobj.
-    """
-    return _choi_to_stinespring(to_choi(q_oper), threshold)
+# -*- coding: utf-8 -*-
+#
+# This module was initially contributed by Ben Criger.
+#
+"""
+This module implements transformations between superoperator representations,
+including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
+"""
+
+__all__ = [
+    'kraus_to_choi', 'kraus_to_super',
+    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
+]
+
+import itertools
+import numbers
+
+import numpy as np
+import scipy.linalg
+
+from . import data as _data
+from .superoperator import stack_columns, unstack_columns, sprepost
+from .tensor import tensor
+from .dimensions import flatten
+from .qobj import Qobj
+from .operators import identity, sigmax, sigmay, sigmaz
+from .states import basis
+
+
+# TODO: revisit when creation routines have dispatching.
+_SINGLE_QUBIT_PAULI_BASIS = (
+    identity(2).to(_data.CSR),
+    sigmax().to(_data.CSR),
+    sigmay().to(_data.CSR),
+    sigmaz().to(_data.CSR),
+)
+
+
+def _superpauli_basis(nq=1):
+    dims = [[[2] * nq] * 2] * 2
+    nnz = 8**nq
+    data = _data.csr.empty(4**nq, 4**nq, nnz)
+    sci = data.as_scipy(full=True)
+    ptr, ptr_inc = 0, 2**nq
+    # Construct the Pauli basis by vertically stacking rows in sparse format.
+    # The CSR format is much more efficient at handling row-stacking, so we
+    # actually have to do a little dance through adjoint/transpose to get it
+    # into the right format.
+    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
+                                                 repeat=nq)):
+        basis = paulis[0].data
+        for pauli in paulis[1:]:
+            basis = _data.kron_csr(basis, pauli.data)
+        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
+        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
+        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
+        sci.indptr[i] = ptr
+        ptr += ptr_inc
+    sci.indptr[-1] = nnz
+    return Qobj(data.adjoint(),
+                dims=dims,
+                type='super',
+                superrep='super',
+                isherm=False,
+                isunitary=False,
+                copy=False)
+
+
+def _int_log_two(x):
+    return int(x).bit_length() - 1
+
+
+def _is_power_of_two(x):
+    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
+
+
+def _nq(dims):
+    dim = np.prod(dims[0][0])
+    nq = _int_log_two(dim)
+    if 2 ** nq != dim:
+        raise ValueError("{} is not an integer power of 2.".format(dim))
+    return nq
+
+
+def isqubitdims(dims):
+    """
+    Checks whether all entries in a dims list are integer powers of 2.
+
+    Parameters
+    ----------
+    dims : nested list of ints
+        Dimensions to be checked.
+
+    Returns
+    -------
+    isqubitdims : bool
+        True if and only if every member of the flattened dims
+        list is an integer power of 2.
+    """
+    return all(_is_power_of_two(dim) for dim in flatten(dims))
+
+
+def _to_superpauli(q_oper):
+    """
+    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
+
+    This is an internal function, as QuTiP does not currently have
+    a way to mark that superoperators are represented in the Pauli
+    basis as opposed to the column-stacking basis; a Pauli-basis
+    ``type='super'`` would thus break other conversion functions.
+    """
+    # Ensure we start with a column-stacking-basis superoperator.
+    sqobj = to_super(q_oper)
+    if not isqubitdims(sqobj.dims):
+        raise ValueError("Pauli basis is only defined for qubits.")
+    nq = _int_log_two(sqobj.shape[0]) // 2
+    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
+    # To do this, we have to hack a bit and force the dims to match,
+    # since the superpauli_basis function makes different assumptions
+    # about indices than we need here.
+    B.dims = sqobj.dims
+    return B.dag() @ sqobj @ B
+
+
+def _choi_to_kraus(q_oper, tol=1e-9):
+    """
+    Takes a Choi matrix and returns a list of Kraus operators.
+    TODO: Create a new class structure for quantum channels, perhaps as a
+    strict sub-class of Qobj.
+    """
+    vals, vecs = q_oper.eigenstates()
+    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
+    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
+    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
+                 dims=dims, type='oper', copy='False')
+            for val, vec in zip(vals, vecs) if abs(val) >= tol]
+
+
+# Individual conversions from Kraus operators are public because the output
+# list of Kraus operators is not itself a quantum object.
+
+def kraus_to_choi(kraus_list):
+    """
+    Take a list of Kraus operators and returns the Choi matrix for the channel
+    represented by the Kraus operators in `kraus_list`
+    """
+    kraus_mat_list = [k.full() for k in kraus_list]
+    op_rng = list(range(kraus_mat_list[0].shape[1]))
+    choi_blocks = np.array(
+        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
+              for op in kraus_mat_list)
+          for r_ix in op_rng]
+         for c_ix in op_rng]
+    )
+    return Qobj(np.hstack(np.hstack(choi_blocks)),
+                dims=[kraus_list[0].dims[::-1]]*2,
+                type='super',
+                superrep='choi',
+                copy=False)
+
+
+def kraus_to_super(kraus_list):
+    """
+    Convert a list of Kraus operators to a superoperator.
+    """
+    return to_super(kraus_to_choi(kraus_list))
+
+
+def _super_tofrom_choi(q_oper):
+    """
+    We exploit that the basis transformation between Choi and supermatrix
+    representations squares to the identity, so that if we munge Qobj.type,
+    we can use the same function.
+    """
+    if not q_oper.issuper:
+        raise ValueError("needs to be a superoperator")
+    if q_oper.superrep not in ('super', 'choi'):
+        raise ValueError("operator is not in super or choi format")
+    data = q_oper.data.to_array()
+    dims = q_oper.dims
+    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
+    d0 = np.prod(flatten(new_dims[0]))
+    d1 = np.prod(flatten(new_dims[1]))
+    s0 = np.prod(dims[0][0])
+    s1 = np.prod(dims[1][1])
+    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
+    return Qobj(data,
+                dims=new_dims,
+                type='super',
+                superrep='super' if q_oper.superrep == 'choi' else 'choi',
+                copy=False)
+
+
+def _choi_to_chi(q_oper):
+    """
+    Converts a Choi matrix to a Chi matrix in the Pauli basis.
+
+    NOTE: this is only supported for qubits right now. Need to extend to
+    Heisenberg-Weyl for other subsystem dimensions.
+    """
+    nq = _nq(q_oper.dims)
+    B = _superpauli_basis(nq).data
+    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
+                dims=q_oper.dims,
+                type='super',
+                superrep='chi',
+                copy=False)
+
+
+def _chi_to_choi(q_oper):
+    """
+    Converts a Chi matrix to a Choi matrix.
+
+    NOTE: this is only supported for qubits right now. Need to extend to
+    Heisenberg-Weyl for other subsystem dimensions.
+    """
+    nq = _nq(q_oper.dims)
+    B = _superpauli_basis(nq).data
+    # The Chi matrix has tr(chi) == d², so we need to divide out
+    # by that to get back to the Choi form.
+    return Qobj(_data.mul(
+                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
+                    1 / q_oper.shape[0]
+                ),
+                dims=q_oper.dims,
+                type='super',
+                superrep='choi',
+                copy=False)
+
+
+def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
+    """
+    Given a partial isometry U and a vector of square-roots of singular values
+    S obtained from a SVD, produces the Kraus operators represented by U.
+
+    Returns
+    -------
+    Ks : list of Qobj
+        Quantum objects represnting each of the Kraus operators.
+    """
+    # We use U * S since S is 1-index, such that this is equivalent to
+    # U . diag(S), but easier to write down.
+    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
+    return [
+        Qobj(x,
+             dims=[outdims, indims],
+             type='oper',
+             copy=False)
+        for x in data
+    ]
+
+
+def _generalized_kraus(q_oper, threshold=1e-10):
+    # TODO: document!
+    # TODO: use this to generalize to_kraus to the case where U != V.
+    #       This is critical for non-CP maps, as appear in (for example)
+    #       diamond norm differences between two CP maps.
+    if not q_oper.issuper or q_oper.superrep != "choi":
+        raise ValueError("".join([
+            "Expected a Choi matrix, got a ", repr(q_oper.type),
+            " (superrep ", repr(q_oper.superrep), ")."
+        ]))
+
+    # Remember the shape of the underlying space,
+    # as we'll need this to make Kraus operators later.
+    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
+    # Also remember the dims breakout.
+    out_dims, in_dims = q_oper.dims
+    out_left, out_right = out_dims
+    in_left, in_right = in_dims
+
+    # Find the SVD.
+    U, S, V = scipy.linalg.svd(q_oper.full())
+
+    # Truncate away the zero singular values, up to a threshold.
+    nonzero_idxs = S > threshold
+    dK = nonzero_idxs.sum()
+    U = np.array(U)[:, nonzero_idxs]
+    # We also want S to be a single index array, which np.matrix
+    # doesn't allow for. This is stripped by calling array() on it.
+    S = np.sqrt(np.array(S)[nonzero_idxs])
+    # Since NumPy returns V and not V+, we need to take the dagger
+    # to get back to quantum info notation for Stinespring pairs.
+    V = np.array(V.conj().T)[:, nonzero_idxs]
+
+    # Next, we convert each of U and V into Kraus operators.
+    # Finally, we want the Kraus index to be left-most so that we
+    # can map over it when making Qobjs.
+    # FIXME: does not preserve dims!
+    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
+    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
+
+    return kU, kV
+
+
+def _choi_to_stinespring(q_oper, threshold=1e-10):
+    # TODO: document!
+    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
+
+    assert len(kU) == len(kV)
+    dK = len(kU)
+    dL = kU[0].shape[0]
+    dR = kV[0].shape[1]
+    # Also remember the dims breakout.
+    out_dims, in_dims = q_oper.dims
+    out_left, out_right = out_dims
+    in_left, in_right = in_dims
+
+    A = Qobj(_data.zeros(dK * dL, dL),
+             dims=[out_left + [dK], out_right + [1]],
+             type='oper',
+             isherm=True,
+             isunitary=False,
+             copy=False)
+    B = Qobj(_data.zeros(dK * dR, dR),
+             dims=[in_left + [dK], in_right + [1]],
+             type='oper',
+             isherm=True,
+             isunitary=False,
+             copy=False)
+
+    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
+        A += tensor(KL, basis(dK, idx_kraus))
+        B += tensor(KR, basis(dK, idx_kraus))
+
+    # There is no input (right) Kraus index, so strip that off.
+    del A.dims[1][-1]
+    del B.dims[1][-1]
+
+    return A, B
+
+
+def to_choi(q_oper):
+    """
+    Converts a Qobj representing a quantum map to the Choi representation,
+    such that the trace of the returned operator is equal to the dimension
+    of the system.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to Choi representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
+
+    Returns
+    -------
+    choi : Qobj
+        A quantum object representing the same map as ``q_oper``, such that
+        ``choi.superrep == "choi"``.
+
+    Raises
+    ------
+    TypeError: if the given quantum object is not a map, or cannot be converted
+        to Choi representation.
+    """
+    if q_oper.type == 'super':
+        if q_oper.superrep == 'choi':
+            return q_oper
+        if q_oper.superrep == 'super':
+            return _super_tofrom_choi(q_oper)
+        if q_oper.superrep == 'chi':
+            return _chi_to_choi(q_oper)
+        else:
+            raise TypeError(q_oper.superrep)
+    elif q_oper.type == 'oper':
+        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
+    else:
+        raise TypeError(
+            "Conversion of Qobj with type = {0.type} "
+            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
+        )
+
+
+def to_chi(q_oper):
+    """
+    Converts a Qobj representing a quantum map to a representation as a chi
+    (process) matrix in the Pauli basis, such that the trace of the returned
+    operator is equal to the dimension of the system.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to Chi representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
+
+    Returns
+    -------
+    chi : Qobj
+        A quantum object representing the same map as ``q_oper``, such that
+        ``chi.superrep == "chi"``.
+
+    Raises
+    ------
+    TypeError: if the given quantum object is not a map, or cannot be converted
+        to Chi representation.
+    """
+    if q_oper.type == 'super':
+        if q_oper.superrep == 'chi':
+            return q_oper
+        elif q_oper.superrep == 'choi':
+            return _choi_to_chi(q_oper)
+        elif q_oper.superrep == 'super':
+            return _choi_to_chi(to_choi(q_oper))
+        else:
+            raise TypeError(q_oper.superrep)
+    elif q_oper.type == 'oper':
+        return to_chi(sprepost(q_oper, q_oper.dag()))
+    else:
+        raise TypeError(
+            "Conversion of Qobj with type = {0.type} "
+            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
+        )
+
+
+def to_super(q_oper):
+    """
+    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
+    representation.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to supermatrix representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_super(A) == sprepost(A, A.dag())``.
+
+    Returns
+    -------
+    superop : Qobj
+        A quantum object representing the same map as ``q_oper``, such that
+        ``superop.superrep == "super"``.
+
+    Raises
+    ------
+    TypeError
+        If the given quantum object is not a map, or cannot be converted
+        to supermatrix representation.
+    """
+    if q_oper.type == 'super':
+        if q_oper.superrep == "super":
+            return q_oper
+        elif q_oper.superrep == 'choi':
+            return _super_tofrom_choi(q_oper)
+        elif q_oper.superrep == 'chi':
+            return to_super(to_choi(q_oper))
+        else:
+            raise ValueError(
+                "Unrecognized superrep '{}'.".format(q_oper.superrep))
+    elif q_oper.type == 'oper':  # Assume unitary
+        return sprepost(q_oper, q_oper.dag())
+    else:
+        raise TypeError(
+            "Conversion of Qobj with type = {0.type} "
+            "and superrep = {0.superrep} to supermatrix not "
+            "supported.".format(q_oper)
+        )
+
+
+def to_kraus(q_oper, tol=1e-9):
+    """
+    Converts a Qobj representing a quantum map to a list of quantum objects,
+    each representing an operator in the Kraus decomposition of the given map.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to Kraus representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
+
+    tol : Float
+        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
+        The default is to=1e-9.
+
+    Returns
+    -------
+    kraus_ops : list of Qobj
+        A list of quantum objects, each representing a Kraus operator in the
+        decomposition of ``q_oper``.
+
+    Raises
+    ------
+    TypeError: if the given quantum object is not a map, or cannot be
+        decomposed into Kraus operators.
+    """
+    if q_oper.issuper:
+        if q_oper.superrep != 'choi':
+            q_oper = to_choi(q_oper)
+        return _choi_to_kraus(q_oper, tol)
+    elif q_oper.isoper:  # Assume unitary
+        return [q_oper]
+    raise TypeError(
+        "Conversion of Qobj with type={0.type} "
+        "and superrep={0.superrep} to Kraus decomposition not "
+        "supported.".format(q_oper)
+    )
+
+
+def to_stinespring(q_oper, threshold=1e-10):
+    r"""
+    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
+    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
+    all inputs $X$, where the partial trace is taken over a a new index on the
+    output dimensions of $A$ and $B$.
+
+    For completely positive inputs, $A$ will always equal $B$ up to precision
+    errors.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to a Stinespring pair.
+
+    Returns
+    -------
+    A, B : Qobj
+        Quantum objects representing each of the Stinespring matrices for the
+        input Qobj.
+    """
+    return _choi_to_stinespring(to_choi(q_oper), threshold)
diff --git a/qutip/core/superoperator.py b/qutip/core/superoperator.py
index 328862b8f3..2a990868e0 100644
--- a/qutip/core/superoperator.py
+++ b/qutip/core/superoperator.py
@@ -1,412 +1,412 @@
-__all__ = [
-    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
-    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
-    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
-]
-
-import functools
-
-import numpy as np
-
-from .qobj import Qobj
-from . import data as _data
-
-def _map_over_compound_operators(f):
-    """
-    Convert a function which takes Qobj into one that can also take compound
-    operators like QobjEvo, and applies itself over all the components.
-    """
-    @functools.wraps(f)
-    def out(qobj):
-        # To avoid circular dependencies
-        from .cy.qobjevo import QobjEvo
-        if isinstance(qobj, QobjEvo):
-            return qobj.linear_map(f, _skip_check=True)
-        if not isinstance(qobj, Qobj):
-            raise TypeError("expected a quantum object")
-        return f(qobj)
-    return out
-
-
-def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
-    """Assembles the Liouvillian superoperator from a Hamiltonian
-    and a ``list`` of collapse operators.
-
-    Parameters
-    ----------
-    H : Qobj or QobjEvo (optional)
-        System Hamiltonian or Hamiltonian component of a Liouvillian.
-        Considered `0` if not given.
-
-    c_ops : array_like of Qobj or QobjEvo
-        A ``list`` or ``array`` of collapse operators.
-
-    data_only :  bool [False]
-        Return the data object instead of a Qobj
-
-    chi : array_like of float [None]
-        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
-        probability distributions of occupation of various states by numerically evaluating the derivatives
-        of the steady state occupation probability as a function of artificial phase parameters ``chi``
-        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
-        the documentation of :func:`lindblad_dissipator` for references and further details.
-        This parameter is deprecated and may be removed in QuTiP 5.
-
-    Returns
-    -------
-    L : Qobj or QobjEvo
-        Liouvillian superoperator.
-
-    """
-    # To avoid circular dependencies
-    from .cy.qobjevo import QobjEvo
-    if (
-        data_only
-        and (isinstance(H, QobjEvo)
-             or any(isinstance(op, QobjEvo) for op in c_ops))
-    ):
-        raise ValueError("Cannot return the data object when computing the"
-                         " liouvillian with QobjEvo")
-
-    c_ops = c_ops or []
-    if isinstance(c_ops, (Qobj, QobjEvo)):
-        c_ops = [c_ops]
-    if chi and len(chi) != len(c_ops):
-        raise ValueError('chi must be a list with same length as c_ops')
-    chi = chi or [0] * len(c_ops)
-
-    if H is None:
-        # No Hamiltonian, add the lindblad_dissipator of c_ops:
-        if not c_ops:
-            raise ValueError("The liouvillian need an Hamiltonian"
-                             " and/or c_ops")
-        out = sum(lindblad_dissipator(c_op, chi=chi_)
-                  for c_op, chi_ in zip(c_ops, chi))
-        return out.data if data_only else out
-    elif not H.isoper:
-        raise TypeError("Invalid type for Hamiltonian.")
-
-    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
-        # With QobjEvo, faster computation using Data is not used
-        L = -1.0j * (spre(H) - spost(H))
-        L += sum(lindblad_dissipator(c_op, chi=chi_)
-                 for c_op, chi_ in zip(c_ops, chi))
-        return L
-
-    op_dims = H.dims
-    op_shape = H.shape
-    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
-    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
-    spI = _data.identity(op_shape[0], dtype=type(H.data))
-
-    data = _data.mul(_data.kron(spI, H.data), -1j)
-    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
-
-    for c_op, chi_ in zip(c_ops, chi):
-        c = c_op.data
-        cd = c.adjoint()
-        cdc = _data.matmul(cd, c)
-        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
-        data = _data.add(data, _data.kron(spI, cdc), -0.5)
-        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
-
-    if data_only:
-        return data
-    else:
-        return Qobj(data,
-                    dims=sop_dims,
-                    type='super',
-                    superrep='super',
-                    copy=False)
-
-
-def lindblad_dissipator(a, b=None, data_only=False, chi=None):
-    """
-    Lindblad dissipator (generalized) for a single pair of collapse operators
-    (a, b), or for a single collapse operator (a) when b is not specified:
-
-    .. math::
-
-        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
-        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
-
-    Parameters
-    ----------
-    a : Qobj or QobjEvo
-        Left part of collapse operator.
-
-    b : Qobj or QobjEvo (optional)
-        Right part of collapse operator. If not specified, b defaults to a.
-
-    chi : float [None]
-        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
-        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
-        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
-        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
-        is introduced via the generating function of the statistical moments. For examples of the technique,
-        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
-        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
-        This parameter is deprecated and may be removed in QuTiP 5.
-
-    data_only :  bool [False]
-        Return the data object instead of a Qobj
-
-    Returns
-    -------
-    D : qobj, QobjEvo
-        Lindblad dissipator superoperator.
-    """
-    # To avoid circular dependencies
-    from .cy.qobjevo import QobjEvo
-    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
-        raise ValueError("Cannot return the data object when computing the"
-                         " collapse of a QobjEvo")
-    if b is None:
-        b = a
-    ad_b = a.dag() * b
-    if chi:
-        D = (
-            spre(a) * spost(b.dag()) * np.exp(1j * chi)
-            - 0.5 * spre(ad_b)
-            - 0.5 * spost(ad_b)
-        )
-    else:
-        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
-
-    return D.data if data_only else D
-
-
-@_map_over_compound_operators
-def operator_to_vector(op):
-    """
-    Create a vector representation given a quantum operator in matrix form.
-    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
-    function is not designed for general-purpose matrix reshaping.
-
-    Parameters
-    ----------
-    op : Qobj or QobjEvo
-        Quantum operator in matrix form.  This must have a type of 'oper' or
-        'super'.
-
-    Returns
-    -------
-    Qobj or QobjEvo
-        The same object, but re-cast into a column-stacked-vector form of type
-        'operator-ket'.  The output is the same type as the passed object.
-    """
-    if op.type in ['super', 'operator-ket', 'operator-bra']:
-        raise TypeError("Cannot convert object already "
-                        "in super representation")
-    return Qobj(stack_columns(op.data),
-                dims=[op.dims, [1]],
-                type='operator-ket',
-                superrep="super",
-                copy=False)
-
-
-@_map_over_compound_operators
-def vector_to_operator(op):
-    """
-    Create a matrix representation given a quantum operator in vector form.
-    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
-    function is not designed for general-purpose matrix reshaping.
-
-    Parameters
-    ----------
-    op : Qobj or QobjEvo
-        Quantum operator in column-stacked-vector form.  This must have a type
-        of 'operator-ket'.
-
-    Returns
-    -------
-    Qobj or QobjEvo
-        The same object, but re-cast into "standard" operator form.  The output
-        is the same type as the passed object.
-    """
-    if not op.isoperket:
-        raise TypeError("only defined for operator-kets")
-    if op.superrep != "super":
-        raise TypeError("only defined for operator-kets in super format")
-    dims = op.dims[0]
-    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
-                dims=dims,
-                copy=False)
-
-
-def stack_columns(matrix):
-    """
-    Stack the columns in a data-layer type, useful for converting an operator
-    into a superoperator representation.
-    """
-    if not isinstance(matrix, (_data.Data, np.ndarray)):
-        raise TypeError(
-            "input " + repr(type(matrix)) + " is not data-layer type"
-        )
-    if isinstance(matrix, np.ndarray):
-        return matrix.ravel('F')[:, None]
-    return _data.column_stack(matrix)
-
-
-def unstack_columns(vector, shape=None):
-    """
-    Unstack the columns in a data-layer type back into a 2D shape, useful for
-    converting an operator in vector form back into a regular operator.  If
-    `shape` is not passed, the output operator will be assumed to be square.
-    """
-    if not isinstance(vector, (_data.Data, np.ndarray)):
-        raise TypeError(
-            "input " + repr(type(vector)) + " is not data-layer type"
-        )
-    if (
-        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
-        or (isinstance(vector, np.ndarray)
-            and ((vector.ndim == 2 and vector.shape[1] != 1)
-                 or vector.ndim > 2))
-    ):
-        raise TypeError("input is not a single column")
-    if shape is None:
-        n = int(np.sqrt(vector.shape[0]))
-        if n * n != vector.shape[0]:
-            raise ValueError(
-                "input cannot be made square, but no specific shape given"
-            )
-        shape = (n, n)
-    if isinstance(vector, np.ndarray):
-        return vector.reshape(shape, order='F')
-    return _data.column_unstack(vector, shape[0])
-
-
-def unstacked_index(size, index):
-    """
-    Convert an index into a column-stacked square operator with `size` rows and
-    columns, into a pair of indices into the unstacked operator.
-    """
-    return index % size, index // size
-
-
-def stacked_index(size, row, col):
-    """
-    Convert a pair of indices into a square operator of `size` into a single
-    index into the column-stacked version of the operator.
-    """
-    return row + size*col
-
-
-@_map_over_compound_operators
-def spost(A):
-    """
-    Superoperator formed from post-multiplication by operator A
-
-    Parameters
-    ----------
-    A : Qobj or QobjEvo
-        Quantum operator for post multiplication.
-
-    Returns
-    -------
-    super : Qobj or QobjEvo
-        Superoperator formed from input qauntum object.
-    """
-    if not A.isoper:
-        raise TypeError('Input is not a quantum operator')
-    data = _data.kron(A.data.transpose(),
-                      _data.identity(A.shape[0], dtype=type(A.data)))
-    return Qobj(data,
-                dims=[A.dims, A.dims],
-                type='super',
-                superrep='super',
-                isherm=A._isherm,
-                copy=False)
-
-
-@_map_over_compound_operators
-def spre(A):
-    """Superoperator formed from pre-multiplication by operator A.
-
-    Parameters
-    ----------
-    A : Qobj or QobjEvo
-        Quantum operator for pre-multiplication.
-
-    Returns
-    -------
-    super :Qobj or QobjEvo
-        Superoperator formed from input quantum object.
-    """
-    if not A.isoper:
-        raise TypeError('Input is not a quantum operator')
-    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
-    return Qobj(data,
-                dims=[A.dims, A.dims],
-                type='super',
-                superrep='super',
-                isherm=A._isherm,
-                copy=False)
-
-
-def _drop_projected_dims(dims):
-    """
-    Eliminate subsystems that has been collapsed to only one state due to
-    a projection.
-    """
-    return [d for d in dims if d != 1]
-
-
-def sprepost(A, B):
-    """
-    Superoperator formed from pre-multiplication by A and post-multiplication
-    by B.
-
-    Parameters
-    ----------
-    A : Qobj or QobjEvo
-        Quantum operator for pre-multiplication.
-
-    B : Qobj or QobjEvo
-        Quantum operator for post-multiplication.
-
-    Returns
-    -------
-    super : Qobj or QobjEvo
-        Superoperator formed from input quantum objects.
-    """
-    # To avoid circular dependencies
-    from .cy.qobjevo import QobjEvo
-    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
-        return spre(A) * spost(B)
-    dims = [[_drop_projected_dims(A.dims[0]),
-             _drop_projected_dims(B.dims[1])],
-            [_drop_projected_dims(A.dims[1]),
-             _drop_projected_dims(B.dims[0])]]
-    return Qobj(_data.kron(B.data.transpose(), A.data),
-                dims=dims,
-                type='super',
-                superrep='super',
-                isherm=A._isherm and B._isherm,
-                copy=False)
-
-
-def reshuffle(q_oper):
-    """
-    Column-reshuffles a ``type="super"`` Qobj.
-    """
-    if q_oper.type not in ('super', 'operator-ket'):
-        raise TypeError("Reshuffling is only supported on type='super' "
-                        "or type='operator-ket'.")
-    # How many indices are there, and how many subsystems can we decompose
-    # each index into?
-    n_indices = len(q_oper.dims[0])
-    n_subsystems = len(q_oper.dims[0][0])
-    # Generate a list of lists (lol) that represents the permutation order we
-    # need. It's easiest to do so if we make an array, then turn it into a lol
-    # by using map(list, ...). That array is generated by using reshape and
-    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
-    # [a, a, ..., a, b, b, ..., b].
-    perm_idxs = map(list,
-                    np.arange(n_subsystems * n_indices)[
-                        np.arange(n_subsystems * n_indices).reshape(
-                            (n_indices, n_subsystems)).T.flatten()
-                    ].reshape((n_subsystems, n_indices))
-                    )
-    return q_oper.permute(list(perm_idxs))
+__all__ = [
+    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
+    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
+    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
+]
+
+import functools
+
+import numpy as np
+
+from .qobj import Qobj
+from . import data as _data
+
+def _map_over_compound_operators(f):
+    """
+    Convert a function which takes Qobj into one that can also take compound
+    operators like QobjEvo, and applies itself over all the components.
+    """
+    @functools.wraps(f)
+    def out(qobj):
+        # To avoid circular dependencies
+        from .cy.qobjevo import QobjEvo
+        if isinstance(qobj, QobjEvo):
+            return qobj.linear_map(f, _skip_check=True)
+        if not isinstance(qobj, Qobj):
+            raise TypeError("expected a quantum object")
+        return f(qobj)
+    return out
+
+
+def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
+    """Assembles the Liouvillian superoperator from a Hamiltonian
+    and a ``list`` of collapse operators.
+
+    Parameters
+    ----------
+    H : Qobj or QobjEvo (optional)
+        System Hamiltonian or Hamiltonian component of a Liouvillian.
+        Considered `0` if not given.
+
+    c_ops : array_like of Qobj or QobjEvo
+        A ``list`` or ``array`` of collapse operators.
+
+    data_only :  bool [False]
+        Return the data object instead of a Qobj
+
+    chi : array_like of float [None]
+        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
+        probability distributions of occupation of various states by numerically evaluating the derivatives
+        of the steady state occupation probability as a function of artificial phase parameters ``chi``
+        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
+        the documentation of :func:`lindblad_dissipator` for references and further details.
+        This parameter is deprecated and may be removed in QuTiP 5.
+
+    Returns
+    -------
+    L : Qobj or QobjEvo
+        Liouvillian superoperator.
+
+    """
+    # To avoid circular dependencies
+    from .cy.qobjevo import QobjEvo
+    if (
+        data_only
+        and (isinstance(H, QobjEvo)
+             or any(isinstance(op, QobjEvo) for op in c_ops))
+    ):
+        raise ValueError("Cannot return the data object when computing the"
+                         " liouvillian with QobjEvo")
+
+    c_ops = c_ops or []
+    if isinstance(c_ops, (Qobj, QobjEvo)):
+        c_ops = [c_ops]
+    if chi and len(chi) != len(c_ops):
+        raise ValueError('chi must be a list with same length as c_ops')
+    chi = chi or [0] * len(c_ops)
+
+    if H is None:
+        # No Hamiltonian, add the lindblad_dissipator of c_ops:
+        if not c_ops:
+            raise ValueError("The liouvillian need an Hamiltonian"
+                             " and/or c_ops")
+        out = sum(lindblad_dissipator(c_op, chi=chi_)
+                  for c_op, chi_ in zip(c_ops, chi))
+        return out.data if data_only else out
+    elif not H.isoper:
+        raise TypeError("Invalid type for Hamiltonian.")
+
+    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
+        # With QobjEvo, faster computation using Data is not used
+        L = -1.0j * (spre(H) - spost(H))
+        L += sum(lindblad_dissipator(c_op, chi=chi_)
+                 for c_op, chi_ in zip(c_ops, chi))
+        return L
+
+    op_dims = H.dims
+    op_shape = H.shape
+    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
+    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
+    spI = _data.identity(op_shape[0], dtype=type(H.data))
+
+    data = _data.mul(_data.kron(spI, H.data), -1j)
+    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
+
+    for c_op, chi_ in zip(c_ops, chi):
+        c = c_op.data
+        cd = c.adjoint()
+        cdc = _data.matmul(cd, c)
+        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
+        data = _data.add(data, _data.kron(spI, cdc), -0.5)
+        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
+
+    if data_only:
+        return data
+    else:
+        return Qobj(data,
+                    dims=sop_dims,
+                    type='super',
+                    superrep='super',
+                    copy=False)
+
+
+def lindblad_dissipator(a, b=None, data_only=False, chi=None):
+    """
+    Lindblad dissipator (generalized) for a single pair of collapse operators
+    (a, b), or for a single collapse operator (a) when b is not specified:
+
+    .. math::
+
+        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
+        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
+
+    Parameters
+    ----------
+    a : Qobj or QobjEvo
+        Left part of collapse operator.
+
+    b : Qobj or QobjEvo (optional)
+        Right part of collapse operator. If not specified, b defaults to a.
+
+    chi : float [None]
+        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
+        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
+        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
+        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
+        is introduced via the generating function of the statistical moments. For examples of the technique,
+        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
+        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
+        This parameter is deprecated and may be removed in QuTiP 5.
+
+    data_only :  bool [False]
+        Return the data object instead of a Qobj
+
+    Returns
+    -------
+    D : qobj, QobjEvo
+        Lindblad dissipator superoperator.
+    """
+    # To avoid circular dependencies
+    from .cy.qobjevo import QobjEvo
+    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
+        raise ValueError("Cannot return the data object when computing the"
+                         " collapse of a QobjEvo")
+    if b is None:
+        b = a
+    ad_b = a.dag() * b
+    if chi:
+        D = (
+            spre(a) * spost(b.dag()) * np.exp(1j * chi)
+            - 0.5 * spre(ad_b)
+            - 0.5 * spost(ad_b)
+        )
+    else:
+        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
+
+    return D.data if data_only else D
+
+
+@_map_over_compound_operators
+def operator_to_vector(op):
+    """
+    Create a vector representation given a quantum operator in matrix form.
+    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
+    function is not designed for general-purpose matrix reshaping.
+
+    Parameters
+    ----------
+    op : Qobj or QobjEvo
+        Quantum operator in matrix form.  This must have a type of 'oper' or
+        'super'.
+
+    Returns
+    -------
+    Qobj or QobjEvo
+        The same object, but re-cast into a column-stacked-vector form of type
+        'operator-ket'.  The output is the same type as the passed object.
+    """
+    if op.type in ['super', 'operator-ket', 'operator-bra']:
+        raise TypeError("Cannot convert object already "
+                        "in super representation")
+    return Qobj(stack_columns(op.data),
+                dims=[op.dims, [1]],
+                type='operator-ket',
+                superrep="super",
+                copy=False)
+
+
+@_map_over_compound_operators
+def vector_to_operator(op):
+    """
+    Create a matrix representation given a quantum operator in vector form.
+    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
+    function is not designed for general-purpose matrix reshaping.
+
+    Parameters
+    ----------
+    op : Qobj or QobjEvo
+        Quantum operator in column-stacked-vector form.  This must have a type
+        of 'operator-ket'.
+
+    Returns
+    -------
+    Qobj or QobjEvo
+        The same object, but re-cast into "standard" operator form.  The output
+        is the same type as the passed object.
+    """
+    if not op.isoperket:
+        raise TypeError("only defined for operator-kets")
+    if op.superrep != "super":
+        raise TypeError("only defined for operator-kets in super format")
+    dims = op.dims[0]
+    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
+                dims=dims,
+                copy=False)
+
+
+def stack_columns(matrix):
+    """
+    Stack the columns in a data-layer type, useful for converting an operator
+    into a superoperator representation.
+    """
+    if not isinstance(matrix, (_data.Data, np.ndarray)):
+        raise TypeError(
+            "input " + repr(type(matrix)) + " is not data-layer type"
+        )
+    if isinstance(matrix, np.ndarray):
+        return matrix.ravel('F')[:, None]
+    return _data.column_stack(matrix)
+
+
+def unstack_columns(vector, shape=None):
+    """
+    Unstack the columns in a data-layer type back into a 2D shape, useful for
+    converting an operator in vector form back into a regular operator.  If
+    `shape` is not passed, the output operator will be assumed to be square.
+    """
+    if not isinstance(vector, (_data.Data, np.ndarray)):
+        raise TypeError(
+            "input " + repr(type(vector)) + " is not data-layer type"
+        )
+    if (
+        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
+        or (isinstance(vector, np.ndarray)
+            and ((vector.ndim == 2 and vector.shape[1] != 1)
+                 or vector.ndim > 2))
+    ):
+        raise TypeError("input is not a single column")
+    if shape is None:
+        n = int(np.sqrt(vector.shape[0]))
+        if n * n != vector.shape[0]:
+            raise ValueError(
+                "input cannot be made square, but no specific shape given"
+            )
+        shape = (n, n)
+    if isinstance(vector, np.ndarray):
+        return vector.reshape(shape, order='F')
+    return _data.column_unstack(vector, shape[0])
+
+
+def unstacked_index(size, index):
+    """
+    Convert an index into a column-stacked square operator with `size` rows and
+    columns, into a pair of indices into the unstacked operator.
+    """
+    return index % size, index // size
+
+
+def stacked_index(size, row, col):
+    """
+    Convert a pair of indices into a square operator of `size` into a single
+    index into the column-stacked version of the operator.
+    """
+    return row + size*col
+
+
+@_map_over_compound_operators
+def spost(A):
+    """
+    Superoperator formed from post-multiplication by operator A
+
+    Parameters
+    ----------
+    A : Qobj or QobjEvo
+        Quantum operator for post multiplication.
+
+    Returns
+    -------
+    super : Qobj or QobjEvo
+        Superoperator formed from input qauntum object.
+    """
+    if not A.isoper:
+        raise TypeError('Input is not a quantum operator')
+    data = _data.kron(A.data.transpose(),
+                      _data.identity(A.shape[0], dtype=type(A.data)))
+    return Qobj(data,
+                dims=[A.dims, A.dims],
+                type='super',
+                superrep='super',
+                isherm=A._isherm,
+                copy=False)
+
+
+@_map_over_compound_operators
+def spre(A):
+    """Superoperator formed from pre-multiplication by operator A.
+
+    Parameters
+    ----------
+    A : Qobj or QobjEvo
+        Quantum operator for pre-multiplication.
+
+    Returns
+    -------
+    super :Qobj or QobjEvo
+        Superoperator formed from input quantum object.
+    """
+    if not A.isoper:
+        raise TypeError('Input is not a quantum operator')
+    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
+    return Qobj(data,
+                dims=[A.dims, A.dims],
+                type='super',
+                superrep='super',
+                isherm=A._isherm,
+                copy=False)
+
+
+def _drop_projected_dims(dims):
+    """
+    Eliminate subsystems that has been collapsed to only one state due to
+    a projection.
+    """
+    return [d for d in dims if d != 1]
+
+
+def sprepost(A, B):
+    """
+    Superoperator formed from pre-multiplication by A and post-multiplication
+    by B.
+
+    Parameters
+    ----------
+    A : Qobj or QobjEvo
+        Quantum operator for pre-multiplication.
+
+    B : Qobj or QobjEvo
+        Quantum operator for post-multiplication.
+
+    Returns
+    -------
+    super : Qobj or QobjEvo
+        Superoperator formed from input quantum objects.
+    """
+    # To avoid circular dependencies
+    from .cy.qobjevo import QobjEvo
+    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
+        return spre(A) * spost(B)
+    dims = [[_drop_projected_dims(A.dims[0]),
+             _drop_projected_dims(B.dims[1])],
+            [_drop_projected_dims(A.dims[1]),
+             _drop_projected_dims(B.dims[0])]]
+    return Qobj(_data.kron(B.data.transpose(), A.data),
+                dims=dims,
+                type='super',
+                superrep='super',
+                isherm=A._isherm and B._isherm,
+                copy=False)
+
+
+def reshuffle(q_oper):
+    """
+    Column-reshuffles a ``type="super"`` Qobj.
+    """
+    if q_oper.type not in ('super', 'operator-ket'):
+        raise TypeError("Reshuffling is only supported on type='super' "
+                        "or type='operator-ket'.")
+    # How many indices are there, and how many subsystems can we decompose
+    # each index into?
+    n_indices = len(q_oper.dims[0])
+    n_subsystems = len(q_oper.dims[0][0])
+    # Generate a list of lists (lol) that represents the permutation order we
+    # need. It's easiest to do so if we make an array, then turn it into a lol
+    # by using map(list, ...). That array is generated by using reshape and
+    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
+    # [a, a, ..., a, b, b, ..., b].
+    perm_idxs = map(list,
+                    np.arange(n_subsystems * n_indices)[
+                        np.arange(n_subsystems * n_indices).reshape(
+                            (n_indices, n_subsystems)).T.flatten()
+                    ].reshape((n_subsystems, n_indices))
+                    )
+    return q_oper.permute(list(perm_idxs))
diff --git a/qutip/core/tensor.py b/qutip/core/tensor.py
index 969d2ad842..7947b3abed 100644
--- a/qutip/core/tensor.py
+++ b/qutip/core/tensor.py
@@ -1,462 +1,462 @@
-"""
-Module for the creation of composite quantum objects via the tensor product.
-"""
-
-__all__ = [
-    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
-    'expand_operator'
-]
-
-import numpy as np
-from functools import partial
-from .operators import qeye
-from .qobj import Qobj
-from .superoperator import operator_to_vector, reshuffle
-from .dimensions import (
-    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
-    dims_idxs_to_tensor_idxs
-)
-from . import data as _data
-
-
-class _reverse_partial_tensor:
-    """ Picklable lambda op: tensor(op, right) """
-    def __init__(self, right):
-        self.right = right
-
-    def __call__(self, op):
-        return tensor(op, self.right)
-
-
-def tensor(*args):
-    """Calculates the tensor product of input operators.
-
-    Parameters
-    ----------
-    args : array_like
-        ``list`` or ``array`` of quantum objects for tensor product.
-
-    Returns
-    -------
-    obj : qobj
-        A composite quantum object.
-
-    Examples
-    --------
-    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], \
-shape = [4, 4], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
-     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
-     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
-     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
-    """
-    from .cy.qobjevo import QobjEvo
-    if not args:
-        raise TypeError("Requires at least one input argument")
-    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
-        return args[0].copy()
-    if len(args) == 1:
-        try:
-            args = tuple(args[0])
-        except TypeError:
-            raise TypeError("requires Qobj or QobjEvo operands") from None
-    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
-        raise TypeError("requires Qobj or QobjEvo operands")
-    if any(isinstance(q, QobjEvo) for q in args):
-        # First make tensor from pairs only
-        if len(args) >= 3:
-            return tensor(args[0], tensor(args[1:]))
-
-        left, right = args
-        if isinstance(left, Qobj):
-            return right.linear_map(partial(tensor, left))
-        if isinstance(right, Qobj):
-            return left.linear_map(_reverse_partial_tensor(right))
-        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
-        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
-        return left_t @ right_t
-
-    if not all(q.superrep == args[0].superrep for q in args[1:]):
-        raise TypeError("".join([
-            "In tensor products of superroperators,",
-            " all must have the same representation"
-        ]))
-    type = args[0].type
-    isherm = args[0]._isherm
-    isunitary = args[0]._isunitary
-    out_data = args[0].data
-    dims_l = [d for arg in args for d in arg.dims[0]]
-    dims_r = [d for arg in args for d in arg.dims[1]]
-    for arg in args[1:]:
-        out_data = _data.kron(out_data, arg.data)
-        # If both _are_ Hermitian and/or unitary, then so is the output, but if
-        # both _aren't_, then output still can be.
-        isherm = (isherm and arg._isherm) or None
-        isunitary = (isunitary and arg._isunitary) or None
-        if arg.type != type:
-            type = None
-    return Qobj(out_data,
-                dims=[dims_l, dims_r],
-                type=type,
-                isherm=isherm,
-                isunitary=isunitary,
-                superrep=args[0].superrep,
-                copy=False)
-
-
-def super_tensor(*args):
-    """
-    Calculate the tensor product of input superoperators, by tensoring together
-    the underlying Hilbert spaces on which each vectorized operator acts.
-
-    Parameters
-    ----------
-    args : array_like
-        ``list`` or ``array`` of quantum objects with ``type="super"``.
-
-    Returns
-    -------
-    obj : qobj
-        A composite quantum object.
-    """
-    if isinstance(args[0], list):
-        args = args[0]
-
-    # Check if we're tensoring vectors or superoperators.
-    if all(arg.issuper for arg in args):
-        if not all(arg.superrep == "super" for arg in args):
-            raise TypeError(
-                "super_tensor on type='super' is only implemented for "
-                "superrep='super'."
-            )
-
-        # Reshuffle the superoperators.
-        shuffled_ops = list(map(reshuffle, args))
-
-        # Tensor the result.
-        shuffled_tensor = tensor(shuffled_ops)
-
-        # Unshuffle and return.
-        out = reshuffle(shuffled_tensor)
-        out.superrep = args[0].superrep
-        return out
-    if all(arg.isoperket for arg in args):
-
-        # Reshuffle the superoperators.
-        shuffled_ops = list(map(reshuffle, args))
-
-        # Tensor the result.
-        shuffled_tensor = tensor(shuffled_ops)
-
-        # Unshuffle and return.
-        out = reshuffle(shuffled_tensor)
-        return out
-
-    if all(arg.isoperbra for arg in args):
-        return super_tensor(*(arg.dag() for arg in args)).dag()
-    raise TypeError(
-        "All arguments must be the same type, "
-        "either super, operator-ket or operator-bra."
-    )
-
-
-def _isoperlike(q):
-    return q.isoper or q.issuper
-
-
-def _isketlike(q):
-    return q.isket or q.isoperket
-
-
-def _isbralike(q):
-    return q.isbra or q.isoperbra
-
-
-def composite(*args):
-    """
-    Given two or more operators, kets or bras, returns the Qobj
-    corresponding to a composite system over each argument.
-    For ordinary operators and vectors, this is the tensor product,
-    while for superoperators and vectorized operators, this is
-    the column-reshuffled tensor product.
-
-    If a mix of Qobjs supported on Hilbert and Liouville spaces
-    are passed in, the former are promoted. Ordinary operators
-    are assumed to be unitaries, and are promoted using ``to_super``,
-    while kets and bras are promoted by taking their projectors and
-    using ``operator_to_vector(ket2dm(arg))``.
-    """
-    import qutip.core.superop_reps
-    # First step will be to ensure everything is a Qobj at all.
-    if not all(isinstance(arg, Qobj) for arg in args):
-        raise TypeError("All arguments must be Qobjs.")
-
-    # Next, figure out if we have something oper-like (isoper or issuper),
-    # or something ket-like (isket or isoperket). Bra-like we'll deal with
-    # by turning things into ket-likes and back.
-    if all(map(_isoperlike, args)):
-        if any(arg.issuper for arg in args):
-            # to_super will promote 'oper' and leave 'super' untouched
-            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
-        return tensor(*args)
-    if all(map(_isketlike, args)):
-        if any(arg.isoperket for arg in args):
-            return super_tensor(*(
-                arg if arg.isoperket else operator_to_vector(arg.proj())
-                for arg in args
-            ))
-        return tensor(*args)
-    if all(map(_isbralike, args)):
-        # Turn into ket-likes and recurse.
-        return composite(*(arg.dag() for arg in args)).dag()
-    raise TypeError("Unsupported Qobj types [{}].".format(
-        ", ".join(arg.type for arg in args)
-    ))
-
-
-def _tensor_contract_single(arr, i, j):
-    """
-    Contracts a dense tensor along a single index pair.
-    """
-    if arr.shape[i] != arr.shape[j]:
-        raise ValueError("Cannot contract over indices of different length.")
-    idxs = np.arange(arr.shape[i])
-    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
-               for idx in range(arr.ndim))
-    contract_at = i if j == i + 1 else 0
-    return np.sum(arr[sl], axis=contract_at)
-
-
-def _tensor_contract_dense(arr, *pairs):
-    """
-    Contracts a dense tensor along one or more index pairs,
-    keeping track of how the indices are relabeled by the removal
-    of other indices.
-    """
-    axis_idxs = list(range(arr.ndim))
-    for pair in pairs:
-        # axis_idxs.index effectively evaluates the mapping from original index
-        # labels to the labels after contraction.
-        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
-        axis_idxs.remove(pair[0])
-        axis_idxs.remove(pair[1])
-    return arr
-
-
-def tensor_swap(q_oper, *pairs):
-    """Transposes one or more pairs of indices of a Qobj.
-    Note that this uses dense representations and thus
-    should *not* be used for very large Qobjs.
-
-    Parameters
-    ----------
-
-    pairs : tuple
-        One or more tuples ``(i, j)`` indicating that the
-        ``i`` and ``j`` dimensions of the original qobj
-        should be swapped.
-
-    Returns
-    -------
-
-    sqobj : Qobj
-        The original Qobj with all named index pairs swapped with each other
-    """
-    dims = q_oper.dims
-    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
-    data = q_oper.full()
-    # Reshape into tensor indices
-    data = data.reshape(dims_to_tensor_shape(dims))
-    # Now permute the dims list so we know how to get back.
-    flat_dims = flatten(dims)
-    perm = list(range(len(flat_dims)))
-    for i, j in pairs:
-        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
-    for i, j in tensor_pairs:
-        perm[i], perm[j] = perm[j], perm[i]
-    dims = unflatten(flat_dims, enumerate_flat(dims))
-    # Next, permute the actual indices of the dense tensor.
-    data = data.transpose(perm)
-    # Reshape back, using the left and right of dims.
-    data = data.reshape(list(map(np.prod, dims)))
-    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
-
-
-def tensor_contract(qobj, *pairs):
-    """Contracts a qobj along one or more index pairs.
-    Note that this uses dense representations and thus
-    should *not* be used for very large Qobjs.
-
-    Parameters
-    ----------
-
-    pairs : tuple
-        One or more tuples ``(i, j)`` indicating that the
-        ``i`` and ``j`` dimensions of the original qobj
-        should be contracted.
-
-    Returns
-    -------
-
-    cqobj : Qobj
-        The original Qobj with all named index pairs contracted
-        away.
-
-    """
-    # Record and label the original dims.
-    dims = qobj.dims
-    dims_idxs = enumerate_flat(dims)
-    tensor_dims = dims_to_tensor_shape(dims)
-
-    # Convert to dense first, since sparse won't support the reshaping we need.
-    qtens = qobj.data.to_array()
-
-    # Reshape by the flattened dims.
-    qtens = qtens.reshape(tensor_dims)
-
-    # Contract out the indices from the flattened object.
-    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
-    # to ensure that we are contracting the right indices.
-    qtens = _tensor_contract_dense(qtens,
-                                   *dims_idxs_to_tensor_idxs(dims, pairs))
-
-    # Remove the contracted indexes from dims so we know how to
-    # reshape back.
-    # This concerns dims, and not the tensor indices, so we need
-    # to make sure to use the original dims indices and not the ones
-    # generated by dims_to_* functions.
-    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
-    contracted_dims = unflatten(flatten(dims), contracted_idxs)
-
-    # We don't need to check for tensor idxs versus dims idxs here,
-    # as column- versus row-stacking will never move an index for the
-    # vectorized operator spaces all the way from the left to the right.
-    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
-
-    # Reshape back into a 2D matrix.
-    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
-
-    # Return back as a qobj.
-    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
-
-
-def _check_oper_dims(oper, dims=None, targets=None):
-    """
-    Check if the given operator is valid.
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`
-        The quantum object to be checked.
-    dims : list, optional
-        A list of integer for the dimension of each composite system.
-        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
-    targets : int or list of int, optional
-        The indices of subspace that are acted on.
-    """
-    # if operator matches N
-    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
-        raise ValueError(
-            "The operator is not an "
-            "Qobj with the same input and output dimensions.")
-    # if operator dims matches the target dims
-    if dims is not None and targets is not None:
-        targ_dims = [dims[t] for t in targets]
-        if oper.dims[0] != targ_dims:
-            raise ValueError(
-                "The operator dims {} do not match "
-                "the target dims {}.".format(
-                    oper.dims[0], targ_dims))
-
-
-def _targets_to_list(targets, oper=None, N=None):
-    """
-    transform targets to a list and check validity.
-
-    Parameters
-    ----------
-    targets : int or list of int
-        The indices of subspace that are acted on.
-    oper : :class:`qutip.Qobj`, optional
-        An operator, the type of the :class:`qutip.Qobj`
-        has to be an operator
-        and the dimension matches the tensored qubit Hilbert space
-        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
-    N : int, optional
-        The number of subspace in the system.
-    """
-    # if targets is a list of integer
-    if targets is None:
-        targets = list(range(len(oper.dims[0])))
-    if not hasattr(targets, '__iter__'):
-        targets = [targets]
-    if not all([isinstance(t, int) for t in targets]):
-        raise TypeError(
-            "targets should be "
-            "an integer or a list of integer")
-    # if targets has correct length
-    if oper is not None:
-        req_num = len(oper.dims[0])
-        if len(targets) != req_num:
-            raise ValueError(
-                "The given operator needs {} "
-                "target qutbis, "
-                "but {} given.".format(
-                    req_num, len(targets)))
-    # if targets is smaller than N
-    if N is not None:
-        if not all([t < N for t in targets]):
-            raise ValueError("Targets must be smaller than N={}.".format(N))
-    return targets
-
-
-def expand_operator(oper, dims, targets):
-    """
-    Expand an operator to one that acts on a system with desired dimensions.
-    e.g.
-    ```
-    expand_operator(oper, [2, 3, 4, 5], 2) ==
-        tensor(qeye(2), qeye(3), oper, qeye(5))
-    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
-        tensor(oper2, qeye(3), oper1, qeye(5))
-    ```
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`
-        An operator that act on the subsystem, has to be an operator and the
-        dimension matches the tensored dims Hilbert space
-        e.g. oper.dims = ``[[2, 3], [2, 3]]``
-    dims : list
-        A list of integer for the dimension of each composite system.
-        E.g ``[2, 3, 2, 3, 4]``.
-    targets : int or list of int
-        The indices of subspace that are acted on.
-
-    Returns
-    -------
-    expanded_oper : :class:`qutip.Qobj`
-        The expanded operator acting on a system with desired dimension.
-    """
-    from .operators import identity
-    N = len(dims)
-    targets = _targets_to_list(targets, oper=oper, N=N)
-    _check_oper_dims(oper, dims=dims, targets=targets)
-
-    # Generate the correct order for permutation,
-    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
-    # If the operator is cnot,
-    # this order means that the 3rd qubit controls the 0th qubit.
-    new_order = [0] * N
-    for i, t in enumerate(targets):
-        new_order[t] = i
-    # allocate the rest qutbits (not targets) to the empty
-    # position in new_order
-    rest_pos = [q for q in list(range(N)) if q not in targets]
-    rest_qubits = list(range(len(targets), N))
-    for i, ind in enumerate(rest_pos):
-        new_order[ind] = rest_qubits[i]
-    id_list = [identity(dims[i]) for i in rest_pos]
-    return tensor([oper] + id_list).permute(new_order)
+"""
+Module for the creation of composite quantum objects via the tensor product.
+"""
+
+__all__ = [
+    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
+    'expand_operator'
+]
+
+import numpy as np
+from functools import partial
+from .operators import qeye
+from .qobj import Qobj
+from .superoperator import operator_to_vector, reshuffle
+from .dimensions import (
+    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
+    dims_idxs_to_tensor_idxs
+)
+from . import data as _data
+
+
+class _reverse_partial_tensor:
+    """ Picklable lambda op: tensor(op, right) """
+    def __init__(self, right):
+        self.right = right
+
+    def __call__(self, op):
+        return tensor(op, self.right)
+
+
+def tensor(*args):
+    """Calculates the tensor product of input operators.
+
+    Parameters
+    ----------
+    args : array_like
+        ``list`` or ``array`` of quantum objects for tensor product.
+
+    Returns
+    -------
+    obj : qobj
+        A composite quantum object.
+
+    Examples
+    --------
+    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [2, 2]], \
+shape = [4, 4], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
+     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
+     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
+     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
+    """
+    from .cy.qobjevo import QobjEvo
+    if not args:
+        raise TypeError("Requires at least one input argument")
+    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
+        return args[0].copy()
+    if len(args) == 1:
+        try:
+            args = tuple(args[0])
+        except TypeError:
+            raise TypeError("requires Qobj or QobjEvo operands") from None
+    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
+        raise TypeError("requires Qobj or QobjEvo operands")
+    if any(isinstance(q, QobjEvo) for q in args):
+        # First make tensor from pairs only
+        if len(args) >= 3:
+            return tensor(args[0], tensor(args[1:]))
+
+        left, right = args
+        if isinstance(left, Qobj):
+            return right.linear_map(partial(tensor, left))
+        if isinstance(right, Qobj):
+            return left.linear_map(_reverse_partial_tensor(right))
+        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
+        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
+        return left_t @ right_t
+
+    if not all(q.superrep == args[0].superrep for q in args[1:]):
+        raise TypeError("".join([
+            "In tensor products of superroperators,",
+            " all must have the same representation"
+        ]))
+    type = args[0].type
+    isherm = args[0]._isherm
+    isunitary = args[0]._isunitary
+    out_data = args[0].data
+    dims_l = [d for arg in args for d in arg.dims[0]]
+    dims_r = [d for arg in args for d in arg.dims[1]]
+    for arg in args[1:]:
+        out_data = _data.kron(out_data, arg.data)
+        # If both _are_ Hermitian and/or unitary, then so is the output, but if
+        # both _aren't_, then output still can be.
+        isherm = (isherm and arg._isherm) or None
+        isunitary = (isunitary and arg._isunitary) or None
+        if arg.type != type:
+            type = None
+    return Qobj(out_data,
+                dims=[dims_l, dims_r],
+                type=type,
+                isherm=isherm,
+                isunitary=isunitary,
+                superrep=args[0].superrep,
+                copy=False)
+
+
+def super_tensor(*args):
+    """
+    Calculate the tensor product of input superoperators, by tensoring together
+    the underlying Hilbert spaces on which each vectorized operator acts.
+
+    Parameters
+    ----------
+    args : array_like
+        ``list`` or ``array`` of quantum objects with ``type="super"``.
+
+    Returns
+    -------
+    obj : qobj
+        A composite quantum object.
+    """
+    if isinstance(args[0], list):
+        args = args[0]
+
+    # Check if we're tensoring vectors or superoperators.
+    if all(arg.issuper for arg in args):
+        if not all(arg.superrep == "super" for arg in args):
+            raise TypeError(
+                "super_tensor on type='super' is only implemented for "
+                "superrep='super'."
+            )
+
+        # Reshuffle the superoperators.
+        shuffled_ops = list(map(reshuffle, args))
+
+        # Tensor the result.
+        shuffled_tensor = tensor(shuffled_ops)
+
+        # Unshuffle and return.
+        out = reshuffle(shuffled_tensor)
+        out.superrep = args[0].superrep
+        return out
+    if all(arg.isoperket for arg in args):
+
+        # Reshuffle the superoperators.
+        shuffled_ops = list(map(reshuffle, args))
+
+        # Tensor the result.
+        shuffled_tensor = tensor(shuffled_ops)
+
+        # Unshuffle and return.
+        out = reshuffle(shuffled_tensor)
+        return out
+
+    if all(arg.isoperbra for arg in args):
+        return super_tensor(*(arg.dag() for arg in args)).dag()
+    raise TypeError(
+        "All arguments must be the same type, "
+        "either super, operator-ket or operator-bra."
+    )
+
+
+def _isoperlike(q):
+    return q.isoper or q.issuper
+
+
+def _isketlike(q):
+    return q.isket or q.isoperket
+
+
+def _isbralike(q):
+    return q.isbra or q.isoperbra
+
+
+def composite(*args):
+    """
+    Given two or more operators, kets or bras, returns the Qobj
+    corresponding to a composite system over each argument.
+    For ordinary operators and vectors, this is the tensor product,
+    while for superoperators and vectorized operators, this is
+    the column-reshuffled tensor product.
+
+    If a mix of Qobjs supported on Hilbert and Liouville spaces
+    are passed in, the former are promoted. Ordinary operators
+    are assumed to be unitaries, and are promoted using ``to_super``,
+    while kets and bras are promoted by taking their projectors and
+    using ``operator_to_vector(ket2dm(arg))``.
+    """
+    import qutip.core.superop_reps
+    # First step will be to ensure everything is a Qobj at all.
+    if not all(isinstance(arg, Qobj) for arg in args):
+        raise TypeError("All arguments must be Qobjs.")
+
+    # Next, figure out if we have something oper-like (isoper or issuper),
+    # or something ket-like (isket or isoperket). Bra-like we'll deal with
+    # by turning things into ket-likes and back.
+    if all(map(_isoperlike, args)):
+        if any(arg.issuper for arg in args):
+            # to_super will promote 'oper' and leave 'super' untouched
+            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
+        return tensor(*args)
+    if all(map(_isketlike, args)):
+        if any(arg.isoperket for arg in args):
+            return super_tensor(*(
+                arg if arg.isoperket else operator_to_vector(arg.proj())
+                for arg in args
+            ))
+        return tensor(*args)
+    if all(map(_isbralike, args)):
+        # Turn into ket-likes and recurse.
+        return composite(*(arg.dag() for arg in args)).dag()
+    raise TypeError("Unsupported Qobj types [{}].".format(
+        ", ".join(arg.type for arg in args)
+    ))
+
+
+def _tensor_contract_single(arr, i, j):
+    """
+    Contracts a dense tensor along a single index pair.
+    """
+    if arr.shape[i] != arr.shape[j]:
+        raise ValueError("Cannot contract over indices of different length.")
+    idxs = np.arange(arr.shape[i])
+    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
+               for idx in range(arr.ndim))
+    contract_at = i if j == i + 1 else 0
+    return np.sum(arr[sl], axis=contract_at)
+
+
+def _tensor_contract_dense(arr, *pairs):
+    """
+    Contracts a dense tensor along one or more index pairs,
+    keeping track of how the indices are relabeled by the removal
+    of other indices.
+    """
+    axis_idxs = list(range(arr.ndim))
+    for pair in pairs:
+        # axis_idxs.index effectively evaluates the mapping from original index
+        # labels to the labels after contraction.
+        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
+        axis_idxs.remove(pair[0])
+        axis_idxs.remove(pair[1])
+    return arr
+
+
+def tensor_swap(q_oper, *pairs):
+    """Transposes one or more pairs of indices of a Qobj.
+    Note that this uses dense representations and thus
+    should *not* be used for very large Qobjs.
+
+    Parameters
+    ----------
+
+    pairs : tuple
+        One or more tuples ``(i, j)`` indicating that the
+        ``i`` and ``j`` dimensions of the original qobj
+        should be swapped.
+
+    Returns
+    -------
+
+    sqobj : Qobj
+        The original Qobj with all named index pairs swapped with each other
+    """
+    dims = q_oper.dims
+    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
+    data = q_oper.full()
+    # Reshape into tensor indices
+    data = data.reshape(dims_to_tensor_shape(dims))
+    # Now permute the dims list so we know how to get back.
+    flat_dims = flatten(dims)
+    perm = list(range(len(flat_dims)))
+    for i, j in pairs:
+        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
+    for i, j in tensor_pairs:
+        perm[i], perm[j] = perm[j], perm[i]
+    dims = unflatten(flat_dims, enumerate_flat(dims))
+    # Next, permute the actual indices of the dense tensor.
+    data = data.transpose(perm)
+    # Reshape back, using the left and right of dims.
+    data = data.reshape(list(map(np.prod, dims)))
+    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
+
+
+def tensor_contract(qobj, *pairs):
+    """Contracts a qobj along one or more index pairs.
+    Note that this uses dense representations and thus
+    should *not* be used for very large Qobjs.
+
+    Parameters
+    ----------
+
+    pairs : tuple
+        One or more tuples ``(i, j)`` indicating that the
+        ``i`` and ``j`` dimensions of the original qobj
+        should be contracted.
+
+    Returns
+    -------
+
+    cqobj : Qobj
+        The original Qobj with all named index pairs contracted
+        away.
+
+    """
+    # Record and label the original dims.
+    dims = qobj.dims
+    dims_idxs = enumerate_flat(dims)
+    tensor_dims = dims_to_tensor_shape(dims)
+
+    # Convert to dense first, since sparse won't support the reshaping we need.
+    qtens = qobj.data.to_array()
+
+    # Reshape by the flattened dims.
+    qtens = qtens.reshape(tensor_dims)
+
+    # Contract out the indices from the flattened object.
+    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
+    # to ensure that we are contracting the right indices.
+    qtens = _tensor_contract_dense(qtens,
+                                   *dims_idxs_to_tensor_idxs(dims, pairs))
+
+    # Remove the contracted indexes from dims so we know how to
+    # reshape back.
+    # This concerns dims, and not the tensor indices, so we need
+    # to make sure to use the original dims indices and not the ones
+    # generated by dims_to_* functions.
+    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
+    contracted_dims = unflatten(flatten(dims), contracted_idxs)
+
+    # We don't need to check for tensor idxs versus dims idxs here,
+    # as column- versus row-stacking will never move an index for the
+    # vectorized operator spaces all the way from the left to the right.
+    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
+
+    # Reshape back into a 2D matrix.
+    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
+
+    # Return back as a qobj.
+    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
+
+
+def _check_oper_dims(oper, dims=None, targets=None):
+    """
+    Check if the given operator is valid.
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`
+        The quantum object to be checked.
+    dims : list, optional
+        A list of integer for the dimension of each composite system.
+        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
+    targets : int or list of int, optional
+        The indices of subspace that are acted on.
+    """
+    # if operator matches N
+    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
+        raise ValueError(
+            "The operator is not an "
+            "Qobj with the same input and output dimensions.")
+    # if operator dims matches the target dims
+    if dims is not None and targets is not None:
+        targ_dims = [dims[t] for t in targets]
+        if oper.dims[0] != targ_dims:
+            raise ValueError(
+                "The operator dims {} do not match "
+                "the target dims {}.".format(
+                    oper.dims[0], targ_dims))
+
+
+def _targets_to_list(targets, oper=None, N=None):
+    """
+    transform targets to a list and check validity.
+
+    Parameters
+    ----------
+    targets : int or list of int
+        The indices of subspace that are acted on.
+    oper : :class:`qutip.Qobj`, optional
+        An operator, the type of the :class:`qutip.Qobj`
+        has to be an operator
+        and the dimension matches the tensored qubit Hilbert space
+        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
+    N : int, optional
+        The number of subspace in the system.
+    """
+    # if targets is a list of integer
+    if targets is None:
+        targets = list(range(len(oper.dims[0])))
+    if not hasattr(targets, '__iter__'):
+        targets = [targets]
+    if not all([isinstance(t, int) for t in targets]):
+        raise TypeError(
+            "targets should be "
+            "an integer or a list of integer")
+    # if targets has correct length
+    if oper is not None:
+        req_num = len(oper.dims[0])
+        if len(targets) != req_num:
+            raise ValueError(
+                "The given operator needs {} "
+                "target qutbis, "
+                "but {} given.".format(
+                    req_num, len(targets)))
+    # if targets is smaller than N
+    if N is not None:
+        if not all([t < N for t in targets]):
+            raise ValueError("Targets must be smaller than N={}.".format(N))
+    return targets
+
+
+def expand_operator(oper, dims, targets):
+    """
+    Expand an operator to one that acts on a system with desired dimensions.
+    e.g.
+    ```
+    expand_operator(oper, [2, 3, 4, 5], 2) ==
+        tensor(qeye(2), qeye(3), oper, qeye(5))
+    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
+        tensor(oper2, qeye(3), oper1, qeye(5))
+    ```
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`
+        An operator that act on the subsystem, has to be an operator and the
+        dimension matches the tensored dims Hilbert space
+        e.g. oper.dims = ``[[2, 3], [2, 3]]``
+    dims : list
+        A list of integer for the dimension of each composite system.
+        E.g ``[2, 3, 2, 3, 4]``.
+    targets : int or list of int
+        The indices of subspace that are acted on.
+
+    Returns
+    -------
+    expanded_oper : :class:`qutip.Qobj`
+        The expanded operator acting on a system with desired dimension.
+    """
+    from .operators import identity
+    N = len(dims)
+    targets = _targets_to_list(targets, oper=oper, N=N)
+    _check_oper_dims(oper, dims=dims, targets=targets)
+
+    # Generate the correct order for permutation,
+    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
+    # If the operator is cnot,
+    # this order means that the 3rd qubit controls the 0th qubit.
+    new_order = [0] * N
+    for i, t in enumerate(targets):
+        new_order[t] = i
+    # allocate the rest qutbits (not targets) to the empty
+    # position in new_order
+    rest_pos = [q for q in list(range(N)) if q not in targets]
+    rest_qubits = list(range(len(targets), N))
+    for i, ind in enumerate(rest_pos):
+        new_order[ind] = rest_qubits[i]
+    id_list = [identity(dims[i]) for i in rest_pos]
+    return tensor([oper] + id_list).permute(new_order)
diff --git a/qutip/distributions.py b/qutip/distributions.py
index b291d51c1f..e85b0b00e6 100644
--- a/qutip/distributions.py
+++ b/qutip/distributions.py
@@ -1,422 +1,422 @@
-"""
-This module provides classes and functions for working with spatial
-distributions, such as Wigner distributions, etc.
-
-.. note::
-
-    Experimental.
-
-"""
-
-__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
-           'TwoModeQuadratureCorrelation',
-           'HarmonicOscillatorWaveFunction',
-           'HarmonicOscillatorProbabilityFunction']
-
-import numpy as np
-from numpy import pi, exp, sqrt
-
-from scipy.special import hermite, factorial
-
-from . import isket, ket2dm, state_number_index
-from .wigner import wigner, qfunc
-
-try:
-    import matplotlib as mpl
-    import matplotlib.pyplot as plt
-    from mpl_toolkits.mplot3d import Axes3D
-except:
-    pass
-
-
-class Distribution:
-    """A class for representation spatial distribution functions.
-
-    The Distribution class can be used to prepresent spatial distribution
-    functions of arbitray dimension (although only 1D and 2D distributions
-    are used so far).
-
-    It is indented as a base class for specific distribution function, and
-    provide implementation of basic functions that are shared among all
-    Distribution functions, such as visualization, calculating marginal
-    distributions, etc.
-
-    Parameters
-    ----------
-    data : array_like
-        Data for the distribution. The dimensions must match the lengths of
-        the coordinate arrays in xvecs.
-    xvecs : list
-        List of arrays that spans the space for each coordinate.
-    xlabels : list
-        List of labels for each coordinate.
-
-    """
-
-    def __init__(self, data=None, xvecs=[], xlabels=[]):
-        self.data = data
-        self.xvecs = xvecs
-        self.xlabels = xlabels
-
-    def visualize(self, fig=None, ax=None, figsize=(8, 6),
-                  colorbar=True, cmap=None, style="colormap",
-                  show_xlabel=True, show_ylabel=True):
-        """
-        Visualize the data of the distribution in 1D or 2D, depending
-        on the dimensionality of the underlaying distribution.
-
-        Parameters:
-
-        fig : matplotlib Figure instance
-            If given, use this figure instance for the visualization,
-
-        ax : matplotlib Axes instance
-            If given, render the visualization using this axis instance.
-
-        figsize : tuple
-            Size of the new Figure instance, if one needs to be created.
-
-        colorbar: Bool
-            Whether or not the colorbar (in 2D visualization) should be used.
-
-        cmap: matplotlib colormap instance
-            If given, use this colormap for 2D visualizations.
-
-        style : string
-            Type of visualization: 'colormap' (default) or 'surface'.
-
-        Returns
-        -------
-
-        fig, ax : tuple
-            A tuple of matplotlib figure and axes instances.
-
-        """
-        n = len(self.xvecs)
-        if n == 2:
-            if style == "colormap":
-                return self.visualize_2d_colormap(fig=fig, ax=ax,
-                                                  figsize=figsize,
-                                                  colorbar=colorbar,
-                                                  cmap=cmap,
-                                                  show_xlabel=show_xlabel,
-                                                  show_ylabel=show_ylabel)
-            else:
-                return self.visualize_2d_surface(fig=fig, ax=ax,
-                                                 figsize=figsize,
-                                                 colorbar=colorbar,
-                                                 cmap=cmap,
-                                                 show_xlabel=show_xlabel,
-                                                 show_ylabel=show_ylabel)
-
-        elif n == 1:
-            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
-                                     show_xlabel=show_xlabel,
-                                     show_ylabel=show_ylabel)
-        else:
-            raise NotImplementedError("Distribution visualization in " +
-                                      "%d dimensions is not implemented." % n)
-
-    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
-                              colorbar=True, cmap=None,
-                              show_xlabel=True, show_ylabel=True):
-
-        if not fig and not ax:
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-        if cmap is None:
-            cmap = mpl.cm.get_cmap('RdBu')
-
-        lim = abs(self.data).max()
-
-        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
-                         norm=mpl.colors.Normalize(-lim, lim),
-                         cmap=cmap)
-
-        if show_xlabel:
-            ax.set_xlabel(self.xlabels[0], fontsize=12)
-        if show_ylabel:
-            ax.set_ylabel(self.xlabels[1], fontsize=12)
-
-        if colorbar:
-            cb = fig.colorbar(cf, ax=ax)
-
-        return fig, ax
-
-    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
-                             colorbar=True, cmap=None,
-                             show_xlabel=True, show_ylabel=True):
-
-        if not fig and not ax:
-            fig = plt.figure(figsize=figsize)
-            ax = Axes3D(fig, azim=-62, elev=25)
-
-        if cmap is None:
-            cmap = mpl.cm.get_cmap('RdBu')
-
-        lim = abs(self.data).max()
-
-        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
-        s = ax.plot_surface(X, Y, self.data,
-                            norm=mpl.colors.Normalize(-lim, lim),
-                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
-
-        if show_xlabel:
-            ax.set_xlabel(self.xlabels[0], fontsize=12)
-        if show_ylabel:
-            ax.set_ylabel(self.xlabels[1], fontsize=12)
-
-        if colorbar:
-            cb = fig.colorbar(s, ax=ax, shrink=0.5)
-
-        return fig, ax
-
-    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
-                     show_xlabel=True, show_ylabel=True):
-
-        if not fig and not ax:
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-        p = ax.plot(self.xvecs[0], self.data)
-
-        if show_xlabel:
-            ax.set_xlabel(self.xlabels[0], fontsize=12)
-        if show_ylabel:
-            ax.set_ylabel("Marginal distribution", fontsize=12)
-
-        return fig, ax
-
-    def marginal(self, dim=0):
-        """
-        Calculate the marginal distribution function along the dimension
-        `dim`. Return a new Distribution instance describing this reduced-
-        dimensionality distribution.
-
-        Parameters
-        ----------
-        dim : int
-            The dimension (coordinate index) along which to obtain the
-            marginal distribution.
-
-        Returns
-        -------
-
-        d : Distributions
-            A new instances of Distribution that describes the marginal
-            distribution.
-
-        """
-        return Distribution(data=self.data.mean(axis=dim),
-                            xvecs=[self.xvecs[dim]],
-                            xlabels=[self.xlabels[dim]])
-
-    def project(self, dim=0):
-        """
-        Calculate the projection (max value) distribution function along the
-        dimension `dim`. Return a new Distribution instance describing this
-        reduced-dimensionality distribution.
-
-        Parameters
-        ----------
-        dim : int
-            The dimension (coordinate index) along which to obtain the
-            projected distribution.
-
-        Returns
-        -------
-        d : Distributions
-            A new instances of Distribution that describes the projection.
-
-        """
-        return Distribution(data=self.data.max(axis=dim),
-                            xvecs=[self.xvecs[dim]],
-                            xlabels=[self.xlabels[dim]])
-
-
-class WignerDistribution(Distribution):
-
-    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
-
-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-                      np.linspace(extent[1][0], extent[1][1], steps)]
-
-        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
-
-        if rho:
-            self.update(rho)
-
-    def update(self, rho):
-
-        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
-
-
-class QDistribution(Distribution):
-
-    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
-
-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-                      np.linspace(extent[1][0], extent[1][1], steps)]
-
-        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
-
-        if rho:
-            self.update(rho)
-
-    def update(self, rho):
-
-        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
-
-
-class TwoModeQuadratureCorrelation(Distribution):
-
-    def __init__(self, state=None, theta1=0.0, theta2=0.0,
-                 extent=[[-5, 5], [-5, 5]], steps=250):
-
-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-                      np.linspace(extent[1][0], extent[1][1], steps)]
-
-        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
-
-        self.theta1 = theta1
-        self.theta2 = theta2
-
-        self.update(state)
-
-    def update(self, state):
-        """
-        calculate probability distribution for quadrature measurement
-        outcomes given a two-mode wavefunction or density matrix
-        """
-        if isket(state):
-            self.update_psi(state)
-        else:
-            self.update_rho(state)
-
-    def update_psi(self, psi):
-        """
-        calculate probability distribution for quadrature measurement
-        outcomes given a two-mode wavefunction
-        """
-
-        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
-
-        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-        N = psi.dims[0][0]
-
-        for n1 in range(N):
-            kn1 = exp(-1j * self.theta1 * n1) / \
-                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
-                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
-
-            for n2 in range(N):
-                kn2 = exp(-1j * self.theta2 * n2) / \
-                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
-                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
-                i = state_number_index([N, N], [n1, n2])
-                p += kn1 * kn2 * psi.data[i, 0]
-
-        self.data = abs(p) ** 2
-
-    def update_rho(self, rho):
-        """
-        calculate probability distribution for quadrature measurement
-        outcomes given a two-mode density matrix
-        """
-
-        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
-
-        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-        N = rho.dims[0][0]
-
-        M1 = np.zeros(
-            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-        M2 = np.zeros(
-            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-
-        for m in range(N):
-            for n in range(N):
-                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
-                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
-                    exp(-X1 ** 2) * np.polyval(
-                        hermite(m), X1) * np.polyval(hermite(n), X1)
-                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
-                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
-                    exp(-X2 ** 2) * np.polyval(
-                        hermite(m), X2) * np.polyval(hermite(n), X2)
-
-        for n1 in range(N):
-            for n2 in range(N):
-                i = state_number_index([N, N], [n1, n2])
-                for p1 in range(N):
-                    for p2 in range(N):
-                        j = state_number_index([N, N], [p1, p2])
-                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
-
-        self.data = p
-
-
-class HarmonicOscillatorWaveFunction(Distribution):
-
-    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
-
-        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
-        self.xlabels = [r'$x$']
-        self.omega = omega
-
-        if psi:
-            self.update(psi)
-
-    def update(self, psi):
-        """
-        Calculate the wavefunction for the given state of an harmonic
-        oscillator
-        """
-
-        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
-        N = psi.shape[0]
-
-        for n in range(N):
-            k = pow(self.omega / pi, 0.25) / \
-                sqrt(2 ** n * factorial(n)) * \
-                exp(-self.xvecs[0] ** 2 / 2.0) * \
-                np.polyval(hermite(n), self.xvecs[0])
-
-            self.data += k * psi.data[n, 0]
-
-
-class HarmonicOscillatorProbabilityFunction(Distribution):
-
-    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
-
-        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
-        self.xlabels = [r'$x$']
-        self.omega = omega
-
-        if rho:
-            self.update(rho)
-
-    def update(self, rho):
-        """
-        Calculate the probability function for the given state of an harmonic
-        oscillator (as density matrix)
-        """
-
-        if isket(rho):
-            rho = ket2dm(rho)
-
-        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
-        M, N = rho.shape
-
-        for m in range(M):
-            k_m = pow(self.omega / pi, 0.25) / \
-                sqrt(2 ** m * factorial(m)) * \
-                exp(-self.xvecs[0] ** 2 / 2.0) * \
-                np.polyval(hermite(m), self.xvecs[0])
-
-            for n in range(N):
-                k_n = pow(self.omega / pi, 0.25) / \
-                    sqrt(2 ** n * factorial(n)) * \
-                    exp(-self.xvecs[0] ** 2 / 2.0) * \
-                    np.polyval(hermite(n), self.xvecs[0])
-
-                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
+"""
+This module provides classes and functions for working with spatial
+distributions, such as Wigner distributions, etc.
+
+.. note::
+
+    Experimental.
+
+"""
+
+__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
+           'TwoModeQuadratureCorrelation',
+           'HarmonicOscillatorWaveFunction',
+           'HarmonicOscillatorProbabilityFunction']
+
+import numpy as np
+from numpy import pi, exp, sqrt
+
+from scipy.special import hermite, factorial
+
+from . import isket, ket2dm, state_number_index
+from .wigner import wigner, qfunc
+
+try:
+    import matplotlib as mpl
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d import Axes3D
+except:
+    pass
+
+
+class Distribution:
+    """A class for representation spatial distribution functions.
+
+    The Distribution class can be used to prepresent spatial distribution
+    functions of arbitray dimension (although only 1D and 2D distributions
+    are used so far).
+
+    It is indented as a base class for specific distribution function, and
+    provide implementation of basic functions that are shared among all
+    Distribution functions, such as visualization, calculating marginal
+    distributions, etc.
+
+    Parameters
+    ----------
+    data : array_like
+        Data for the distribution. The dimensions must match the lengths of
+        the coordinate arrays in xvecs.
+    xvecs : list
+        List of arrays that spans the space for each coordinate.
+    xlabels : list
+        List of labels for each coordinate.
+
+    """
+
+    def __init__(self, data=None, xvecs=[], xlabels=[]):
+        self.data = data
+        self.xvecs = xvecs
+        self.xlabels = xlabels
+
+    def visualize(self, fig=None, ax=None, figsize=(8, 6),
+                  colorbar=True, cmap=None, style="colormap",
+                  show_xlabel=True, show_ylabel=True):
+        """
+        Visualize the data of the distribution in 1D or 2D, depending
+        on the dimensionality of the underlaying distribution.
+
+        Parameters:
+
+        fig : matplotlib Figure instance
+            If given, use this figure instance for the visualization,
+
+        ax : matplotlib Axes instance
+            If given, render the visualization using this axis instance.
+
+        figsize : tuple
+            Size of the new Figure instance, if one needs to be created.
+
+        colorbar: Bool
+            Whether or not the colorbar (in 2D visualization) should be used.
+
+        cmap: matplotlib colormap instance
+            If given, use this colormap for 2D visualizations.
+
+        style : string
+            Type of visualization: 'colormap' (default) or 'surface'.
+
+        Returns
+        -------
+
+        fig, ax : tuple
+            A tuple of matplotlib figure and axes instances.
+
+        """
+        n = len(self.xvecs)
+        if n == 2:
+            if style == "colormap":
+                return self.visualize_2d_colormap(fig=fig, ax=ax,
+                                                  figsize=figsize,
+                                                  colorbar=colorbar,
+                                                  cmap=cmap,
+                                                  show_xlabel=show_xlabel,
+                                                  show_ylabel=show_ylabel)
+            else:
+                return self.visualize_2d_surface(fig=fig, ax=ax,
+                                                 figsize=figsize,
+                                                 colorbar=colorbar,
+                                                 cmap=cmap,
+                                                 show_xlabel=show_xlabel,
+                                                 show_ylabel=show_ylabel)
+
+        elif n == 1:
+            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
+                                     show_xlabel=show_xlabel,
+                                     show_ylabel=show_ylabel)
+        else:
+            raise NotImplementedError("Distribution visualization in " +
+                                      "%d dimensions is not implemented." % n)
+
+    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
+                              colorbar=True, cmap=None,
+                              show_xlabel=True, show_ylabel=True):
+
+        if not fig and not ax:
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+        if cmap is None:
+            cmap = mpl.cm.get_cmap('RdBu')
+
+        lim = abs(self.data).max()
+
+        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
+                         norm=mpl.colors.Normalize(-lim, lim),
+                         cmap=cmap)
+
+        if show_xlabel:
+            ax.set_xlabel(self.xlabels[0], fontsize=12)
+        if show_ylabel:
+            ax.set_ylabel(self.xlabels[1], fontsize=12)
+
+        if colorbar:
+            cb = fig.colorbar(cf, ax=ax)
+
+        return fig, ax
+
+    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
+                             colorbar=True, cmap=None,
+                             show_xlabel=True, show_ylabel=True):
+
+        if not fig and not ax:
+            fig = plt.figure(figsize=figsize)
+            ax = Axes3D(fig, azim=-62, elev=25)
+
+        if cmap is None:
+            cmap = mpl.cm.get_cmap('RdBu')
+
+        lim = abs(self.data).max()
+
+        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
+        s = ax.plot_surface(X, Y, self.data,
+                            norm=mpl.colors.Normalize(-lim, lim),
+                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
+
+        if show_xlabel:
+            ax.set_xlabel(self.xlabels[0], fontsize=12)
+        if show_ylabel:
+            ax.set_ylabel(self.xlabels[1], fontsize=12)
+
+        if colorbar:
+            cb = fig.colorbar(s, ax=ax, shrink=0.5)
+
+        return fig, ax
+
+    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
+                     show_xlabel=True, show_ylabel=True):
+
+        if not fig and not ax:
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+        p = ax.plot(self.xvecs[0], self.data)
+
+        if show_xlabel:
+            ax.set_xlabel(self.xlabels[0], fontsize=12)
+        if show_ylabel:
+            ax.set_ylabel("Marginal distribution", fontsize=12)
+
+        return fig, ax
+
+    def marginal(self, dim=0):
+        """
+        Calculate the marginal distribution function along the dimension
+        `dim`. Return a new Distribution instance describing this reduced-
+        dimensionality distribution.
+
+        Parameters
+        ----------
+        dim : int
+            The dimension (coordinate index) along which to obtain the
+            marginal distribution.
+
+        Returns
+        -------
+
+        d : Distributions
+            A new instances of Distribution that describes the marginal
+            distribution.
+
+        """
+        return Distribution(data=self.data.mean(axis=dim),
+                            xvecs=[self.xvecs[dim]],
+                            xlabels=[self.xlabels[dim]])
+
+    def project(self, dim=0):
+        """
+        Calculate the projection (max value) distribution function along the
+        dimension `dim`. Return a new Distribution instance describing this
+        reduced-dimensionality distribution.
+
+        Parameters
+        ----------
+        dim : int
+            The dimension (coordinate index) along which to obtain the
+            projected distribution.
+
+        Returns
+        -------
+        d : Distributions
+            A new instances of Distribution that describes the projection.
+
+        """
+        return Distribution(data=self.data.max(axis=dim),
+                            xvecs=[self.xvecs[dim]],
+                            xlabels=[self.xlabels[dim]])
+
+
+class WignerDistribution(Distribution):
+
+    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
+
+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+                      np.linspace(extent[1][0], extent[1][1], steps)]
+
+        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
+
+        if rho:
+            self.update(rho)
+
+    def update(self, rho):
+
+        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
+
+
+class QDistribution(Distribution):
+
+    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
+
+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+                      np.linspace(extent[1][0], extent[1][1], steps)]
+
+        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
+
+        if rho:
+            self.update(rho)
+
+    def update(self, rho):
+
+        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
+
+
+class TwoModeQuadratureCorrelation(Distribution):
+
+    def __init__(self, state=None, theta1=0.0, theta2=0.0,
+                 extent=[[-5, 5], [-5, 5]], steps=250):
+
+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+                      np.linspace(extent[1][0], extent[1][1], steps)]
+
+        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
+
+        self.theta1 = theta1
+        self.theta2 = theta2
+
+        self.update(state)
+
+    def update(self, state):
+        """
+        calculate probability distribution for quadrature measurement
+        outcomes given a two-mode wavefunction or density matrix
+        """
+        if isket(state):
+            self.update_psi(state)
+        else:
+            self.update_rho(state)
+
+    def update_psi(self, psi):
+        """
+        calculate probability distribution for quadrature measurement
+        outcomes given a two-mode wavefunction
+        """
+
+        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
+
+        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+        N = psi.dims[0][0]
+
+        for n1 in range(N):
+            kn1 = exp(-1j * self.theta1 * n1) / \
+                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
+                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
+
+            for n2 in range(N):
+                kn2 = exp(-1j * self.theta2 * n2) / \
+                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
+                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
+                i = state_number_index([N, N], [n1, n2])
+                p += kn1 * kn2 * psi.data[i, 0]
+
+        self.data = abs(p) ** 2
+
+    def update_rho(self, rho):
+        """
+        calculate probability distribution for quadrature measurement
+        outcomes given a two-mode density matrix
+        """
+
+        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
+
+        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+        N = rho.dims[0][0]
+
+        M1 = np.zeros(
+            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+        M2 = np.zeros(
+            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+
+        for m in range(N):
+            for n in range(N):
+                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
+                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
+                    exp(-X1 ** 2) * np.polyval(
+                        hermite(m), X1) * np.polyval(hermite(n), X1)
+                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
+                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
+                    exp(-X2 ** 2) * np.polyval(
+                        hermite(m), X2) * np.polyval(hermite(n), X2)
+
+        for n1 in range(N):
+            for n2 in range(N):
+                i = state_number_index([N, N], [n1, n2])
+                for p1 in range(N):
+                    for p2 in range(N):
+                        j = state_number_index([N, N], [p1, p2])
+                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
+
+        self.data = p
+
+
+class HarmonicOscillatorWaveFunction(Distribution):
+
+    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
+
+        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
+        self.xlabels = [r'$x$']
+        self.omega = omega
+
+        if psi:
+            self.update(psi)
+
+    def update(self, psi):
+        """
+        Calculate the wavefunction for the given state of an harmonic
+        oscillator
+        """
+
+        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
+        N = psi.shape[0]
+
+        for n in range(N):
+            k = pow(self.omega / pi, 0.25) / \
+                sqrt(2 ** n * factorial(n)) * \
+                exp(-self.xvecs[0] ** 2 / 2.0) * \
+                np.polyval(hermite(n), self.xvecs[0])
+
+            self.data += k * psi.data[n, 0]
+
+
+class HarmonicOscillatorProbabilityFunction(Distribution):
+
+    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
+
+        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
+        self.xlabels = [r'$x$']
+        self.omega = omega
+
+        if rho:
+            self.update(rho)
+
+    def update(self, rho):
+        """
+        Calculate the probability function for the given state of an harmonic
+        oscillator (as density matrix)
+        """
+
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
+        M, N = rho.shape
+
+        for m in range(M):
+            k_m = pow(self.omega / pi, 0.25) / \
+                sqrt(2 ** m * factorial(m)) * \
+                exp(-self.xvecs[0] ** 2 / 2.0) * \
+                np.polyval(hermite(m), self.xvecs[0])
+
+            for n in range(N):
+                k_n = pow(self.omega / pi, 0.25) / \
+                    sqrt(2 ** n * factorial(n)) * \
+                    exp(-self.xvecs[0] ** 2 / 2.0) * \
+                    np.polyval(hermite(n), self.xvecs[0])
+
+                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
diff --git a/qutip/entropy.py b/qutip/entropy.py
index cd62a69b76..28ff606aa4 100644
--- a/qutip/entropy.py
+++ b/qutip/entropy.py
@@ -1,376 +1,376 @@
-__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
-           'concurrence', 'entropy_conditional', 'entangling_power',
-           'entropy_relative']
-
-from numpy import conj, e, inf, imag, inner, real, sort, sqrt
-from numpy.lib.scimath import log, log2
-from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
-               expand_operator)
-from .core import data as _data
-
-
-def entropy_vn(rho, base=e, sparse=False):
-    """
-    Von-Neumann entropy of density matrix
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix.
-    base : {e,2}
-        Base of logarithm.
-    sparse : {False,True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    entropy : float
-        Von-Neumann entropy of `rho`.
-
-    Examples
-    --------
-    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
-    >>> entropy_vn(rho,2)
-    1.0
-
-    """
-    if rho.type == 'ket' or rho.type == 'bra':
-        rho = ket2dm(rho)
-    vals = rho.eigenenergies(sparse=sparse)
-    nzvals = vals[vals != 0]
-    if base == 2:
-        logvals = log2(nzvals)
-    elif base == e:
-        logvals = log(nzvals)
-    else:
-        raise ValueError("Base must be 2 or e.")
-    return float(real(-sum(nzvals * logvals)))
-
-
-def entropy_linear(rho):
-    """
-    Linear entropy of a density matrix.
-
-    Parameters
-    ----------
-    rho : qobj
-        sensity matrix or ket/bra vector.
-
-    Returns
-    -------
-    entropy : float
-        Linear entropy of rho.
-
-    Examples
-    --------
-    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
-    >>> entropy_linear(rho)
-    0.5
-
-    """
-    if rho.type == 'ket' or rho.type == 'bra':
-        rho = ket2dm(rho)
-    return float(real(1.0 - (rho ** 2).tr()))
-
-
-def concurrence(rho):
-    """
-    Calculate the concurrence entanglement measure for a two-qubit state.
-
-    Parameters
-    ----------
-    state : qobj
-        Ket, bra, or density matrix for a two-qubit state.
-
-    Returns
-    -------
-    concur : float
-        Concurrence
-
-    References
-    ----------
-
-    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
-
-    """
-    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
-        raise Exception("Ket must be tensor product of two qubits.")
-
-    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
-        raise Exception("Bra must be tensor product of two qubits.")
-
-    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
-        raise Exception("Density matrix must be tensor product of two qubits.")
-
-    if rho.isket or rho.isbra:
-        rho = ket2dm(rho)
-
-    sysy = tensor(sigmay(), sigmay())
-
-    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
-
-    evals = rho_tilde.eigenenergies()
-
-    # abs to avoid problems with sqrt for very small negative numbers
-    evals = abs(sort(real(evals)))
-
-    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
-
-    return max(0, lsum)
-
-
-def negativity(rho, subsys, method='tracenorm', logarithmic=False):
-    """
-    Compute the negativity for a multipartite quantum system described
-    by the density matrix rho. The subsys argument is an index that
-    indicates which system to compute the negativity for.
-
-    .. note::
-
-        Experimental.
-    """
-    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
-    rho_pt = partial_transpose(rho, mask)
-
-    if method == 'tracenorm':
-        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
-    elif method == 'eigenvalues':
-        l = rho_pt.eigenenergies()
-        N = ((abs(l)-l)/2).sum()
-    else:
-        raise ValueError("Unknown method %s" % method)
-
-    if logarithmic:
-        return log2(2 * N + 1)
-    else:
-        return N
-
-
-def entropy_mutual(rho, selA, selB, base=e, sparse=False):
-    """
-    Calculates the mutual information S(A:B) between selection
-    components of a system density matrix.
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix for composite quantum systems
-    selA : int/list
-        `int` or `list` of first selected density matrix components.
-    selB : int/list
-        `int` or `list` of second selected density matrix components.
-    base : {e,2}
-        Base of logarithm.
-    sparse : {False,True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    ent_mut : float
-       Mutual information between selected components.
-
-    """
-    if isinstance(selA, int):
-        selA = [selA]
-    if isinstance(selB, int):
-        selB = [selB]
-    if rho.type != 'oper':
-        raise TypeError("Input must be a density matrix.")
-    if (len(selA) + len(selB)) != len(rho.dims[0]):
-        raise TypeError("Number of selected components must match " +
-                        "total number.")
-
-    rhoA = ptrace(rho, selA)
-    rhoB = ptrace(rho, selB)
-    out = (entropy_vn(rhoA, base, sparse=sparse) +
-           entropy_vn(rhoB, base, sparse=sparse) -
-           entropy_vn(rho, base, sparse=sparse))
-    return out
-
-
-def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
-    """
-    Calculates the relative entropy S(rho||sigma) between two density
-    matrices.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        First density matrix (or ket which will be converted to a density
-        matrix).
-    sigma : :class:`qutip.Qobj`
-        Second density matrix (or ket which will be converted to a density
-        matrix).
-    base : {e,2}
-        Base of logarithm. Defaults to e.
-    sparse : bool
-        Flag to use sparse solver when determining the eigenvectors
-        of the density matrices. Defaults to False.
-    tol : float
-        Tolerance to use to detect 0 eigenvalues or dot producted between
-        eigenvectors. Defaults to 1e-12.
-
-    Returns
-    -------
-    rel_ent : float
-        Value of relative entropy. Guaranteed to be greater than zero
-        and should equal zero only when rho and sigma are identical.
-
-    Examples
-    --------
-
-    First we define two density matrices:
-
-    >>> rho = qutip.ket2dm(qutip.ket("00"))
-    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
-    >>> sigma = sigma.unit()
-
-    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
-    and base e (i.e. ``log``).
-
-    >>> qutip.entropy_relative(rho, sigma, base=2)
-    1.0
-    >>> qutip.entropy_relative(rho, sigma)
-    0.6931471805599453
-
-    References
-    ----------
-
-    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
-    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
-    entropy.
-    """
-    if rho.isket:
-        rho = ket2dm(rho)
-    if sigma.isket:
-        sigma = ket2dm(sigma)
-    if not rho.isoper or not sigma.isoper:
-        raise TypeError("Inputs must be density matrices.")
-    if rho.dims != sigma.dims:
-        raise ValueError("Inputs must have the same shape and dims.")
-    if base == 2:
-        log_base = log2
-    elif base == e:
-        log_base = log
-    else:
-        raise ValueError("Base must be 2 or e.")
-    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
-    #
-    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
-    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
-    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
-    rvecs = rvecs.to_array().T
-    if any(abs(imag(rvals)) >= tol):
-        raise ValueError("Input rho has non-real eigenvalues.")
-    rvals = real(rvals)
-    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
-    svecs = svecs.to_array().T
-    if any(abs(imag(svals)) >= tol):
-        raise ValueError("Input sigma has non-real eigenvalues.")
-    svals = real(svals)
-    # Calculate inner products of eigenvectors and return +inf if kernel
-    # of sigma overlaps with support of rho.
-    P = abs(inner(rvecs, conj(svecs))) ** 2
-    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
-        return inf
-    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
-    # anyway
-    svals[abs(svals) < tol] = 1
-    nzrvals = rvals[abs(rvals) >= tol]
-    # Calculate S
-    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
-    # the relative entropy is guaranteed to be >= 0, so we clamp the
-    # calculated value to 0 to avoid small violations of the lower bound.
-    return max(0, S)
-
-
-def entropy_conditional(rho, selB, base=e, sparse=False):
-    """
-    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
-    of a selected density matrix component.
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix of composite object
-    selB : int/list
-        Selected components for density matrix B
-    base : {e,2}
-        Base of logarithm.
-    sparse : {False,True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    ent_cond : float
-        Value of conditional entropy
-
-    """
-    if rho.type != 'oper':
-        raise TypeError("Input must be density matrix.")
-    if isinstance(selB, int):
-        selB = [selB]
-    B = ptrace(rho, selB)
-    out = (entropy_vn(rho, base, sparse=sparse) -
-           entropy_vn(B, base, sparse=sparse))
-    return out
-
-
-def participation_ratio(rho):
-    """
-    Returns the effective number of states for a density matrix.
-
-    The participation is unity for pure states, and maximally N,
-    where N is the Hilbert space dimensionality, for completely
-    mixed states.
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix
-
-    Returns
-    -------
-    pr : float
-        Effective number of states in the density matrix
-
-    """
-    if rho.type == 'ket' or rho.type == 'bra':
-        return 1.0
-    else:
-        return 1.0 / (rho ** 2).tr()
-
-
-def entangling_power(U):
-    """
-    Calculate the entangling power of a two-qubit gate U, which
-    is zero of nonentangling gates and 2/9 for maximally entangling gates.
-
-    Parameters
-    ----------
-    U : qobj
-        Qobj instance representing a two-qubit gate.
-
-    Returns
-    -------
-    ep : float
-        The entanglement power of U (real number between 0 and 2/9)
-
-    References:
-
-        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
-    """
-
-    if not U.isoper:
-        raise Exception("U must be an operator.")
-
-    if U.dims != [[2, 2], [2, 2]]:
-        raise Exception("U must be a two-qubit gate.")
-
-    from qutip.core.gates import swap
-    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
-    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
-    Uswap = swap() * U
-    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
-
-    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
+__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
+           'concurrence', 'entropy_conditional', 'entangling_power',
+           'entropy_relative']
+
+from numpy import conj, e, inf, imag, inner, real, sort, sqrt
+from numpy.lib.scimath import log, log2
+from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
+               expand_operator)
+from .core import data as _data
+
+
+def entropy_vn(rho, base=e, sparse=False):
+    """
+    Von-Neumann entropy of density matrix
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix.
+    base : {e,2}
+        Base of logarithm.
+    sparse : {False,True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    entropy : float
+        Von-Neumann entropy of `rho`.
+
+    Examples
+    --------
+    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
+    >>> entropy_vn(rho,2)
+    1.0
+
+    """
+    if rho.type == 'ket' or rho.type == 'bra':
+        rho = ket2dm(rho)
+    vals = rho.eigenenergies(sparse=sparse)
+    nzvals = vals[vals != 0]
+    if base == 2:
+        logvals = log2(nzvals)
+    elif base == e:
+        logvals = log(nzvals)
+    else:
+        raise ValueError("Base must be 2 or e.")
+    return float(real(-sum(nzvals * logvals)))
+
+
+def entropy_linear(rho):
+    """
+    Linear entropy of a density matrix.
+
+    Parameters
+    ----------
+    rho : qobj
+        sensity matrix or ket/bra vector.
+
+    Returns
+    -------
+    entropy : float
+        Linear entropy of rho.
+
+    Examples
+    --------
+    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
+    >>> entropy_linear(rho)
+    0.5
+
+    """
+    if rho.type == 'ket' or rho.type == 'bra':
+        rho = ket2dm(rho)
+    return float(real(1.0 - (rho ** 2).tr()))
+
+
+def concurrence(rho):
+    """
+    Calculate the concurrence entanglement measure for a two-qubit state.
+
+    Parameters
+    ----------
+    state : qobj
+        Ket, bra, or density matrix for a two-qubit state.
+
+    Returns
+    -------
+    concur : float
+        Concurrence
+
+    References
+    ----------
+
+    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
+
+    """
+    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
+        raise Exception("Ket must be tensor product of two qubits.")
+
+    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
+        raise Exception("Bra must be tensor product of two qubits.")
+
+    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
+        raise Exception("Density matrix must be tensor product of two qubits.")
+
+    if rho.isket or rho.isbra:
+        rho = ket2dm(rho)
+
+    sysy = tensor(sigmay(), sigmay())
+
+    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
+
+    evals = rho_tilde.eigenenergies()
+
+    # abs to avoid problems with sqrt for very small negative numbers
+    evals = abs(sort(real(evals)))
+
+    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
+
+    return max(0, lsum)
+
+
+def negativity(rho, subsys, method='tracenorm', logarithmic=False):
+    """
+    Compute the negativity for a multipartite quantum system described
+    by the density matrix rho. The subsys argument is an index that
+    indicates which system to compute the negativity for.
+
+    .. note::
+
+        Experimental.
+    """
+    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
+    rho_pt = partial_transpose(rho, mask)
+
+    if method == 'tracenorm':
+        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
+    elif method == 'eigenvalues':
+        l = rho_pt.eigenenergies()
+        N = ((abs(l)-l)/2).sum()
+    else:
+        raise ValueError("Unknown method %s" % method)
+
+    if logarithmic:
+        return log2(2 * N + 1)
+    else:
+        return N
+
+
+def entropy_mutual(rho, selA, selB, base=e, sparse=False):
+    """
+    Calculates the mutual information S(A:B) between selection
+    components of a system density matrix.
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix for composite quantum systems
+    selA : int/list
+        `int` or `list` of first selected density matrix components.
+    selB : int/list
+        `int` or `list` of second selected density matrix components.
+    base : {e,2}
+        Base of logarithm.
+    sparse : {False,True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    ent_mut : float
+       Mutual information between selected components.
+
+    """
+    if isinstance(selA, int):
+        selA = [selA]
+    if isinstance(selB, int):
+        selB = [selB]
+    if rho.type != 'oper':
+        raise TypeError("Input must be a density matrix.")
+    if (len(selA) + len(selB)) != len(rho.dims[0]):
+        raise TypeError("Number of selected components must match " +
+                        "total number.")
+
+    rhoA = ptrace(rho, selA)
+    rhoB = ptrace(rho, selB)
+    out = (entropy_vn(rhoA, base, sparse=sparse) +
+           entropy_vn(rhoB, base, sparse=sparse) -
+           entropy_vn(rho, base, sparse=sparse))
+    return out
+
+
+def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
+    """
+    Calculates the relative entropy S(rho||sigma) between two density
+    matrices.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        First density matrix (or ket which will be converted to a density
+        matrix).
+    sigma : :class:`qutip.Qobj`
+        Second density matrix (or ket which will be converted to a density
+        matrix).
+    base : {e,2}
+        Base of logarithm. Defaults to e.
+    sparse : bool
+        Flag to use sparse solver when determining the eigenvectors
+        of the density matrices. Defaults to False.
+    tol : float
+        Tolerance to use to detect 0 eigenvalues or dot producted between
+        eigenvectors. Defaults to 1e-12.
+
+    Returns
+    -------
+    rel_ent : float
+        Value of relative entropy. Guaranteed to be greater than zero
+        and should equal zero only when rho and sigma are identical.
+
+    Examples
+    --------
+
+    First we define two density matrices:
+
+    >>> rho = qutip.ket2dm(qutip.ket("00"))
+    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
+    >>> sigma = sigma.unit()
+
+    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
+    and base e (i.e. ``log``).
+
+    >>> qutip.entropy_relative(rho, sigma, base=2)
+    1.0
+    >>> qutip.entropy_relative(rho, sigma)
+    0.6931471805599453
+
+    References
+    ----------
+
+    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
+    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
+    entropy.
+    """
+    if rho.isket:
+        rho = ket2dm(rho)
+    if sigma.isket:
+        sigma = ket2dm(sigma)
+    if not rho.isoper or not sigma.isoper:
+        raise TypeError("Inputs must be density matrices.")
+    if rho.dims != sigma.dims:
+        raise ValueError("Inputs must have the same shape and dims.")
+    if base == 2:
+        log_base = log2
+    elif base == e:
+        log_base = log
+    else:
+        raise ValueError("Base must be 2 or e.")
+    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
+    #
+    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
+    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
+    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
+    rvecs = rvecs.to_array().T
+    if any(abs(imag(rvals)) >= tol):
+        raise ValueError("Input rho has non-real eigenvalues.")
+    rvals = real(rvals)
+    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
+    svecs = svecs.to_array().T
+    if any(abs(imag(svals)) >= tol):
+        raise ValueError("Input sigma has non-real eigenvalues.")
+    svals = real(svals)
+    # Calculate inner products of eigenvectors and return +inf if kernel
+    # of sigma overlaps with support of rho.
+    P = abs(inner(rvecs, conj(svecs))) ** 2
+    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
+        return inf
+    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
+    # anyway
+    svals[abs(svals) < tol] = 1
+    nzrvals = rvals[abs(rvals) >= tol]
+    # Calculate S
+    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
+    # the relative entropy is guaranteed to be >= 0, so we clamp the
+    # calculated value to 0 to avoid small violations of the lower bound.
+    return max(0, S)
+
+
+def entropy_conditional(rho, selB, base=e, sparse=False):
+    """
+    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
+    of a selected density matrix component.
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix of composite object
+    selB : int/list
+        Selected components for density matrix B
+    base : {e,2}
+        Base of logarithm.
+    sparse : {False,True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    ent_cond : float
+        Value of conditional entropy
+
+    """
+    if rho.type != 'oper':
+        raise TypeError("Input must be density matrix.")
+    if isinstance(selB, int):
+        selB = [selB]
+    B = ptrace(rho, selB)
+    out = (entropy_vn(rho, base, sparse=sparse) -
+           entropy_vn(B, base, sparse=sparse))
+    return out
+
+
+def participation_ratio(rho):
+    """
+    Returns the effective number of states for a density matrix.
+
+    The participation is unity for pure states, and maximally N,
+    where N is the Hilbert space dimensionality, for completely
+    mixed states.
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix
+
+    Returns
+    -------
+    pr : float
+        Effective number of states in the density matrix
+
+    """
+    if rho.type == 'ket' or rho.type == 'bra':
+        return 1.0
+    else:
+        return 1.0 / (rho ** 2).tr()
+
+
+def entangling_power(U):
+    """
+    Calculate the entangling power of a two-qubit gate U, which
+    is zero of nonentangling gates and 2/9 for maximally entangling gates.
+
+    Parameters
+    ----------
+    U : qobj
+        Qobj instance representing a two-qubit gate.
+
+    Returns
+    -------
+    ep : float
+        The entanglement power of U (real number between 0 and 2/9)
+
+    References:
+
+        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
+    """
+
+    if not U.isoper:
+        raise Exception("U must be an operator.")
+
+    if U.dims != [[2, 2], [2, 2]]:
+        raise Exception("U must be a two-qubit gate.")
+
+    from qutip.core.gates import swap
+    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
+    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
+    Uswap = swap() * U
+    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
+
+    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
diff --git a/qutip/fileio.py b/qutip/fileio.py
index ac94dd41f5..36bb1a5c55 100644
--- a/qutip/fileio.py
+++ b/qutip/fileio.py
@@ -1,257 +1,257 @@
-__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
-
-import pickle
-import numpy as np
-import sys
-from .core import Qobj
-from pathlib import Path
-
-
-# -----------------------------------------------------------------------------
-# Write matrix data to a file
-#
-def file_data_store(filename, data, numtype="complex", numformat="decimal",
-                    sep=","):
-    """Stores a matrix of data to a file to be read by an external program.
-
-    Parameters
-    ----------
-    filename : str or pathlib.Path
-        Name of data file to be stored, including extension.
-    data: array_like
-        Data to be written to file.
-    numtype : str {'complex, 'real'}
-        Type of numerical data.
-    numformat : str {'decimal','exp'}
-        Format for written data.
-    sep : str
-        Single-character field seperator.  Usually a tab, space, comma,
-        or semicolon.
-
-    """
-    if filename is None or data is None:
-        raise ValueError("filename or data is unspecified")
-
-    M, N = np.shape(data)
-
-    f = open(filename, "w")
-
-    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
-            "in %s format ['%s' separated values].\n" % (numformat, sep))
-
-    if numtype == "complex":
-
-        if numformat == "exp":
-
-            for m in range(M):
-                for n in range(N):
-                    if np.imag(data[m, n]) >= 0.0:
-                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
-                                                  np.imag(data[m, n])))
-                    else:
-                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
-                                                 np.imag(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        elif numformat == "decimal":
-
-            for m in range(M):
-                for n in range(N):
-                    if np.imag(data[m, n]) >= 0.0:
-                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
-                                                  np.imag(data[m, n])))
-                    else:
-                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
-                                                 np.imag(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        else:
-            raise ValueError("Illegal numformat value (should be " +
-                             "'exp' or 'decimal')")
-
-    elif numtype == "real":
-
-        if numformat == "exp":
-
-            for m in range(M):
-                for n in range(N):
-                    f.write("%.10e" % (np.real(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        elif numformat == "decimal":
-
-            for m in range(M):
-                for n in range(N):
-                    f.write("%.10f" % (np.real(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        else:
-            raise ValueError("Illegal numformat value (should be " +
-                             "'exp' or 'decimal')")
-
-    else:
-        raise ValueError("Illegal numtype value (should be " +
-                         "'complex' or 'real')")
-
-    f.close()
-
-
-# -----------------------------------------------------------------------------
-# Read matrix data from a file
-#
-def file_data_read(filename, sep=None):
-    """Retrieves an array of data from the requested file.
-
-    Parameters
-    ----------
-    filename : str or pathlib.Path
-        Name of file containing reqested data.
-    sep : str
-        Seperator used to store data.
-
-    Returns
-    -------
-    data : array_like
-        Data from selected file.
-
-    """
-    if filename is None:
-        raise ValueError("filename is unspecified")
-
-    f = open(filename, "r")
-
-    #
-    # first count lines and numbers of
-    #
-    M = N = 0
-    for line in f:
-        # skip comment lines
-        if line[0] == '#' or line[0] == '%':
-            continue
-        # find delim
-        if N == 0 and sep is None:
-            if len(line.rstrip().split(",")) > 1:
-                sep = ","
-            elif len(line.rstrip().split(";")) > 1:
-                sep = ";"
-            elif len(line.rstrip().split(":")) > 1:
-                sep = ":"
-            elif len(line.rstrip().split("|")) > 1:
-                sep = "|"
-            elif len(line.rstrip().split()) > 1:
-                # sepical case for a mix of white space deliminators
-                sep = None
-            else:
-                raise ValueError("Unrecognized column deliminator")
-        # split the line
-        line_vec = line.split(sep)
-        n = len(line_vec)
-        if N == 0 and n > 0:
-            N = n
-            # check type
-            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
-                numtype = "complex"
-            else:
-                numtype = "np.real"
-
-            # check format
-            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
-                numformat = "exp"
-            else:
-                numformat = "decimal"
-
-        elif N != n:
-            raise ValueError("Badly formatted data file: " +
-                             "unequal number of columns")
-        M += 1
-
-    #
-    # read data and store in a matrix
-    #
-    f.seek(0)
-
-    if numtype == "complex":
-        data = np.zeros((M, N), dtype="complex")
-        m = n = 0
-        for line in f:
-            # skip comment lines
-            if line[0] == '#' or line[0] == '%':
-                continue
-            n = 0
-            for item in line.rstrip().split(sep):
-                data[m, n] = complex(item)
-                n += 1
-            m += 1
-
-    else:
-        data = np.zeros((M, N), dtype="float")
-        m = n = 0
-        for line in f:
-            # skip comment lines
-            if line[0] == '#' or line[0] == '%':
-                continue
-            n = 0
-            for item in line.rstrip().split(sep):
-                data[m, n] = float(item)
-                n += 1
-            m += 1
-
-    f.close()
-
-    return data
-
-
-def qsave(data, name='qutip_data'):
-    """
-    Saves given data to file named 'filename.qu' in current directory.
-
-    Parameters
-    ----------
-    data : instance/array_like
-        Input Python object to be stored.
-    filename : str or pathlib.Path
-        Name of output data file.
-
-    """
-    # open the file for writing
-    path = Path(name)
-    path = path.with_suffix(path.suffix + ".qu")
-
-    with open(path, "wb") as fileObject:
-        # this writes the object a to the file named 'filename.qu'
-        pickle.dump(data, fileObject)
-
-
-def qload(name):
-    """
-    Loads data file from file named 'filename.qu' in current directory.
-
-    Parameters
-    ----------
-    name : str or pathlib.Path
-        Name of data file to be loaded.
-
-    Returns
-    -------
-    qobject : instance / array_like
-        Object retrieved from requested file.
-
-    """
-    path = Path(name)
-    path = path.with_suffix(path.suffix + ".qu")
-
-    with open(path, "rb") as fileObject:
-        if sys.version_info >= (3, 0):
-            out = pickle.load(fileObject, encoding='latin1')
-        else:
-            out = pickle.load(fileObject)
-
-    return out
+__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
+
+import pickle
+import numpy as np
+import sys
+from .core import Qobj
+from pathlib import Path
+
+
+# -----------------------------------------------------------------------------
+# Write matrix data to a file
+#
+def file_data_store(filename, data, numtype="complex", numformat="decimal",
+                    sep=","):
+    """Stores a matrix of data to a file to be read by an external program.
+
+    Parameters
+    ----------
+    filename : str or pathlib.Path
+        Name of data file to be stored, including extension.
+    data: array_like
+        Data to be written to file.
+    numtype : str {'complex, 'real'}
+        Type of numerical data.
+    numformat : str {'decimal','exp'}
+        Format for written data.
+    sep : str
+        Single-character field seperator.  Usually a tab, space, comma,
+        or semicolon.
+
+    """
+    if filename is None or data is None:
+        raise ValueError("filename or data is unspecified")
+
+    M, N = np.shape(data)
+
+    f = open(filename, "w")
+
+    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
+            "in %s format ['%s' separated values].\n" % (numformat, sep))
+
+    if numtype == "complex":
+
+        if numformat == "exp":
+
+            for m in range(M):
+                for n in range(N):
+                    if np.imag(data[m, n]) >= 0.0:
+                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
+                                                  np.imag(data[m, n])))
+                    else:
+                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
+                                                 np.imag(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        elif numformat == "decimal":
+
+            for m in range(M):
+                for n in range(N):
+                    if np.imag(data[m, n]) >= 0.0:
+                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
+                                                  np.imag(data[m, n])))
+                    else:
+                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
+                                                 np.imag(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        else:
+            raise ValueError("Illegal numformat value (should be " +
+                             "'exp' or 'decimal')")
+
+    elif numtype == "real":
+
+        if numformat == "exp":
+
+            for m in range(M):
+                for n in range(N):
+                    f.write("%.10e" % (np.real(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        elif numformat == "decimal":
+
+            for m in range(M):
+                for n in range(N):
+                    f.write("%.10f" % (np.real(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        else:
+            raise ValueError("Illegal numformat value (should be " +
+                             "'exp' or 'decimal')")
+
+    else:
+        raise ValueError("Illegal numtype value (should be " +
+                         "'complex' or 'real')")
+
+    f.close()
+
+
+# -----------------------------------------------------------------------------
+# Read matrix data from a file
+#
+def file_data_read(filename, sep=None):
+    """Retrieves an array of data from the requested file.
+
+    Parameters
+    ----------
+    filename : str or pathlib.Path
+        Name of file containing reqested data.
+    sep : str
+        Seperator used to store data.
+
+    Returns
+    -------
+    data : array_like
+        Data from selected file.
+
+    """
+    if filename is None:
+        raise ValueError("filename is unspecified")
+
+    f = open(filename, "r")
+
+    #
+    # first count lines and numbers of
+    #
+    M = N = 0
+    for line in f:
+        # skip comment lines
+        if line[0] == '#' or line[0] == '%':
+            continue
+        # find delim
+        if N == 0 and sep is None:
+            if len(line.rstrip().split(",")) > 1:
+                sep = ","
+            elif len(line.rstrip().split(";")) > 1:
+                sep = ";"
+            elif len(line.rstrip().split(":")) > 1:
+                sep = ":"
+            elif len(line.rstrip().split("|")) > 1:
+                sep = "|"
+            elif len(line.rstrip().split()) > 1:
+                # sepical case for a mix of white space deliminators
+                sep = None
+            else:
+                raise ValueError("Unrecognized column deliminator")
+        # split the line
+        line_vec = line.split(sep)
+        n = len(line_vec)
+        if N == 0 and n > 0:
+            N = n
+            # check type
+            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
+                numtype = "complex"
+            else:
+                numtype = "np.real"
+
+            # check format
+            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
+                numformat = "exp"
+            else:
+                numformat = "decimal"
+
+        elif N != n:
+            raise ValueError("Badly formatted data file: " +
+                             "unequal number of columns")
+        M += 1
+
+    #
+    # read data and store in a matrix
+    #
+    f.seek(0)
+
+    if numtype == "complex":
+        data = np.zeros((M, N), dtype="complex")
+        m = n = 0
+        for line in f:
+            # skip comment lines
+            if line[0] == '#' or line[0] == '%':
+                continue
+            n = 0
+            for item in line.rstrip().split(sep):
+                data[m, n] = complex(item)
+                n += 1
+            m += 1
+
+    else:
+        data = np.zeros((M, N), dtype="float")
+        m = n = 0
+        for line in f:
+            # skip comment lines
+            if line[0] == '#' or line[0] == '%':
+                continue
+            n = 0
+            for item in line.rstrip().split(sep):
+                data[m, n] = float(item)
+                n += 1
+            m += 1
+
+    f.close()
+
+    return data
+
+
+def qsave(data, name='qutip_data'):
+    """
+    Saves given data to file named 'filename.qu' in current directory.
+
+    Parameters
+    ----------
+    data : instance/array_like
+        Input Python object to be stored.
+    filename : str or pathlib.Path
+        Name of output data file.
+
+    """
+    # open the file for writing
+    path = Path(name)
+    path = path.with_suffix(path.suffix + ".qu")
+
+    with open(path, "wb") as fileObject:
+        # this writes the object a to the file named 'filename.qu'
+        pickle.dump(data, fileObject)
+
+
+def qload(name):
+    """
+    Loads data file from file named 'filename.qu' in current directory.
+
+    Parameters
+    ----------
+    name : str or pathlib.Path
+        Name of data file to be loaded.
+
+    Returns
+    -------
+    qobject : instance / array_like
+        Object retrieved from requested file.
+
+    """
+    path = Path(name)
+    path = path.with_suffix(path.suffix + ".qu")
+
+    with open(path, "rb") as fileObject:
+        if sys.version_info >= (3, 0):
+            out = pickle.load(fileObject, encoding='latin1')
+        else:
+            out = pickle.load(fileObject)
+
+    return out
diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 143a3b1c9d..0cf9d3b481 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -1,326 +1,326 @@
-"""
-This module contains utility functions for using QuTiP with IPython notebooks.
-"""
-from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
-from .settings import _blas_info, available_cpu_count
-import IPython
-
-#IPython parallel routines moved to ipyparallel in V4
-#IPython parallel routines not in Anaconda by default
-if IPython.version_info[0] >= 4:
-    try:
-        from ipyparallel import Client
-        __all__ = ['version_table', 'plot_animation',
-                    'parallel_map']
-    except:
-         __all__ = ['version_table', 'plot_animation']
-else:
-    try:
-        from IPython.parallel import Client
-        __all__ = ['version_table', 'plot_animation',
-                    'parallel_map']
-    except:
-         __all__ = ['version_table', 'plot_animation']
-
-
-from IPython.display import HTML, Javascript, display
-
-import matplotlib.pyplot as plt
-from matplotlib import animation
-from base64 import b64encode
-
-import datetime
-import uuid
-import sys
-import os
-import time
-import inspect
-
-import qutip
-import numpy
-import scipy
-import matplotlib
-import IPython
-
-try:
-    import Cython
-    _cython_available = True
-except ImportError:
-    _cython_available = False
-
-
-def version_table(verbose=False):
-    """
-    Print an HTML-formatted table with version numbers for QuTiP and its
-    dependencies. Use it in a IPython notebook to show which versions of
-    different packages that were used to run the notebook. This should make it
-    possible to reproduce the environment and the calculation later on.
-
-
-    Returns
-    -------
-    version_table: string
-        Return an HTML-formatted string containing version information for
-        QuTiP dependencies.
-
-    """
-
-    html = "<table>"
-    html += "<tr><th>Software</th><th>Version</th></tr>"
-
-    packages = [("QuTiP", qutip.__version__),
-                ("Numpy", numpy.__version__),
-                ("SciPy", scipy.__version__),
-                ("matplotlib", matplotlib.__version__),
-                ("Number of CPUs", available_cpu_count()),
-                ("BLAS Info", _blas_info()),
-                ("IPython", IPython.__version__),
-                ("Python", sys.version),
-                ("OS", "%s [%s]" % (os.name, sys.platform))
-                ]
-    if _cython_available:
-        packages.append(("Cython", Cython.__version__))
-
-    for name, version in packages:
-        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
-
-    if verbose:
-        html += "<tr><th colspan='2'>Additional information</th></tr>"
-        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
-        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
-                 qutip_install_path)
-        try:
-            import getpass
-            html += ("<tr><td>User</td><td>%s</td></tr>" %
-                     getpass.getuser())
-        except:
-            pass
-
-    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
-        '%a %b %d %H:%M:%S %Y %Z')
-    html += "</table>"
-
-    return HTML(html)
-
-
-def _visualize_parfor_data(metadata):
-    """
-    Visualizing the task scheduling meta data collected from AsyncResults.
-    """
-    res = numpy.array(metadata)
-    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
-
-    yticks = []
-    yticklabels = []
-    tmin = min(res[:, 1])
-    for n, pid in enumerate(numpy.unique(res[:, 0])):
-        yticks.append(n)
-        yticklabels.append("%d" % pid)
-        for m in numpy.where(res[:, 0] == pid)[0]:
-            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
-                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
-
-    ax.set_ylim(-.5, n + .5)
-    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
-    ax.set_yticks(yticks)
-    ax.set_yticklabels(yticklabels)
-    ax.set_ylabel("Engine")
-    ax.set_xlabel("seconds")
-    ax.set_title("Task schedule")
-
-
-def parfor(task, task_vec, args=None, client=None, view=None,
-           show_scheduling=False, show_progressbar=False):
-    """
-    Call the function ``tast`` for each value in ``task_vec`` using a cluster
-    of IPython engines. The function ``task`` should have the signature
-    ``task(value, args)`` or ``task(value)`` if ``args=None``.
-
-    The ``client`` and ``view`` are the IPython.parallel client and
-    load-balanced view that will be used in the parfor execution. If these
-    are ``None``, new instances will be created.
-
-    Parameters
-    ----------
-
-    task: a Python function
-        The function that is to be called for each value in ``task_vec``.
-
-    task_vec: array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-
-    args: list / dictionary
-        The optional additional argument to the ``task`` function. For example
-        a dictionary with parameter values.
-
-    client: IPython.parallel.Client
-        The IPython.parallel Client instance that will be used in the
-        parfor execution.
-
-    view: a IPython.parallel.Client view
-        The view that is to be used in scheduling the tasks on the IPython
-        cluster. Preferably a load-balanced view, which is obtained from the
-        IPython.parallel.Client instance client by calling,
-        view = client.load_balanced_view().
-
-    show_scheduling: bool {False, True}, default False
-        Display a graph showing how the tasks (the evaluation of ``task`` for
-        for the value in ``task_vec1``) was scheduled on the IPython engine
-        cluster.
-
-    show_progressbar: bool {False, True}, default False
-        Display a HTML-based progress bar duing the execution of the parfor
-        loop.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of ``task(value, args)`` for each
-        value in ``task_vec``, that is, it should be equivalent to
-        ``[task(v, args) for v in task_vec]``.
-    """
-
-    if show_progressbar:
-        progress_bar = HTMLProgressBar()
-    else:
-        progress_bar = None
-
-    return parallel_map(task, task_vec, task_args=args,
-                        client=client, view=view, progress_bar=progress_bar,
-                        show_scheduling=show_scheduling)
-
-
-def parallel_map(task, values, task_args=None, task_kwargs=None,
-                 client=None, view=None, progress_bar=None,
-                 show_scheduling=False, **kwargs):
-    """
-    Call the function ``task`` for each value in ``values`` using a cluster
-    of IPython engines. The function ``task`` should have the signature
-    ``task(value, *args, **kwargs)``.
-
-    The ``client`` and ``view`` are the IPython.parallel client and
-    load-balanced view that will be used in the parfor execution. If these
-    are ``None``, new instances will be created.
-
-    Parameters
-    ----------
-
-    task: a Python function
-        The function that is to be called for each value in ``task_vec``.
-
-    values: array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-
-    task_args: list / dictionary
-        The optional additional argument to the ``task`` function.
-
-    task_kwargs: list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-
-    client: IPython.parallel.Client
-        The IPython.parallel Client instance that will be used in the
-        parfor execution.
-
-    view: a IPython.parallel.Client view
-        The view that is to be used in scheduling the tasks on the IPython
-        cluster. Preferably a load-balanced view, which is obtained from the
-        IPython.parallel.Client instance client by calling,
-        view = client.load_balanced_view().
-
-    show_scheduling: bool {False, True}, default False
-        Display a graph showing how the tasks (the evaluation of ``task`` for
-        for the value in ``task_vec1``) was scheduled on the IPython engine
-        cluster.
-
-    show_progressbar: bool {False, True}, default False
-        Display a HTML-based progress bar during the execution of the parfor
-        loop.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of
-        ``task(value, task_args, task_kwargs)`` for each
-        value in ``values``.
-
-    """
-    submitted = datetime.datetime.now()
-
-    if task_args is None:
-        task_args = tuple()
-
-    if task_kwargs is None:
-        task_kwargs = {}
-
-    if client is None:
-        client = Client()
-
-        # make sure qutip is available at engines
-        dview = client[:]
-        dview.block = True
-        dview.execute("from qutip import *")
-
-    if view is None:
-        view = client.load_balanced_view()
-
-    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
-               for value in values]
-
-    if progress_bar is None:
-        view.wait(ar_list)
-    else:
-        if progress_bar is True:
-            progress_bar = HTMLProgressBar()
-
-        n = len(ar_list)
-        progress_bar.start(n)
-        while True:
-            n_finished = sum([ar.progress for ar in ar_list])
-            progress_bar.update(n_finished)
-
-            if view.wait(ar_list, timeout=0.5):
-                progress_bar.update(n)
-                break
-        progress_bar.finished()
-
-    if show_scheduling:
-        metadata = [[ar.engine_id,
-                     (ar.started - submitted).total_seconds(),
-                     (ar.completed - submitted).total_seconds()]
-                    for ar in ar_list]
-        _visualize_parfor_data(metadata)
-
-    return [ar.get() for ar in ar_list]
-
-
-def plot_animation(plot_setup_func, plot_func, result, name="movie",
-                   writer="avconv", codec="libx264", verbose=False):
-    """
-    Create an animated plot of a Result object, as returned by one of
-    the qutip evolution solvers.
-
-    .. note :: experimental
-    """
-
-    fig, axes = plot_setup_func(result)
-
-    def update(n):
-        return plot_func(result, n, fig=fig, axes=axes)
-
-    anim = animation.FuncAnimation(
-        fig, update, frames=len(result.times), blit=True)
-
-    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
-
-    plt.close(fig)
-
-    if verbose:
-        print("Created %s.m4v" % name)
-
-    video = open(name + '.mp4', "rb").read()
-    video_encoded = b64encode(video).decode("ascii")
-    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
-        video_encoded)
-    return HTML(video_tag)
+"""
+This module contains utility functions for using QuTiP with IPython notebooks.
+"""
+from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
+from .settings import _blas_info, available_cpu_count
+import IPython
+
+#IPython parallel routines moved to ipyparallel in V4
+#IPython parallel routines not in Anaconda by default
+if IPython.version_info[0] >= 4:
+    try:
+        from ipyparallel import Client
+        __all__ = ['version_table', 'plot_animation',
+                    'parallel_map']
+    except:
+         __all__ = ['version_table', 'plot_animation']
+else:
+    try:
+        from IPython.parallel import Client
+        __all__ = ['version_table', 'plot_animation',
+                    'parallel_map']
+    except:
+         __all__ = ['version_table', 'plot_animation']
+
+
+from IPython.display import HTML, Javascript, display
+
+import matplotlib.pyplot as plt
+from matplotlib import animation
+from base64 import b64encode
+
+import datetime
+import uuid
+import sys
+import os
+import time
+import inspect
+
+import qutip
+import numpy
+import scipy
+import matplotlib
+import IPython
+
+try:
+    import Cython
+    _cython_available = True
+except ImportError:
+    _cython_available = False
+
+
+def version_table(verbose=False):
+    """
+    Print an HTML-formatted table with version numbers for QuTiP and its
+    dependencies. Use it in a IPython notebook to show which versions of
+    different packages that were used to run the notebook. This should make it
+    possible to reproduce the environment and the calculation later on.
+
+
+    Returns
+    -------
+    version_table: string
+        Return an HTML-formatted string containing version information for
+        QuTiP dependencies.
+
+    """
+
+    html = "<table>"
+    html += "<tr><th>Software</th><th>Version</th></tr>"
+
+    packages = [("QuTiP", qutip.__version__),
+                ("Numpy", numpy.__version__),
+                ("SciPy", scipy.__version__),
+                ("matplotlib", matplotlib.__version__),
+                ("Number of CPUs", available_cpu_count()),
+                ("BLAS Info", _blas_info()),
+                ("IPython", IPython.__version__),
+                ("Python", sys.version),
+                ("OS", "%s [%s]" % (os.name, sys.platform))
+                ]
+    if _cython_available:
+        packages.append(("Cython", Cython.__version__))
+
+    for name, version in packages:
+        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
+
+    if verbose:
+        html += "<tr><th colspan='2'>Additional information</th></tr>"
+        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
+        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
+                 qutip_install_path)
+        try:
+            import getpass
+            html += ("<tr><td>User</td><td>%s</td></tr>" %
+                     getpass.getuser())
+        except:
+            pass
+
+    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
+        '%a %b %d %H:%M:%S %Y %Z')
+    html += "</table>"
+
+    return HTML(html)
+
+
+def _visualize_parfor_data(metadata):
+    """
+    Visualizing the task scheduling meta data collected from AsyncResults.
+    """
+    res = numpy.array(metadata)
+    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
+
+    yticks = []
+    yticklabels = []
+    tmin = min(res[:, 1])
+    for n, pid in enumerate(numpy.unique(res[:, 0])):
+        yticks.append(n)
+        yticklabels.append("%d" % pid)
+        for m in numpy.where(res[:, 0] == pid)[0]:
+            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
+                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
+
+    ax.set_ylim(-.5, n + .5)
+    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
+    ax.set_yticks(yticks)
+    ax.set_yticklabels(yticklabels)
+    ax.set_ylabel("Engine")
+    ax.set_xlabel("seconds")
+    ax.set_title("Task schedule")
+
+
+def parfor(task, task_vec, args=None, client=None, view=None,
+           show_scheduling=False, show_progressbar=False):
+    """
+    Call the function ``tast`` for each value in ``task_vec`` using a cluster
+    of IPython engines. The function ``task`` should have the signature
+    ``task(value, args)`` or ``task(value)`` if ``args=None``.
+
+    The ``client`` and ``view`` are the IPython.parallel client and
+    load-balanced view that will be used in the parfor execution. If these
+    are ``None``, new instances will be created.
+
+    Parameters
+    ----------
+
+    task: a Python function
+        The function that is to be called for each value in ``task_vec``.
+
+    task_vec: array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+
+    args: list / dictionary
+        The optional additional argument to the ``task`` function. For example
+        a dictionary with parameter values.
+
+    client: IPython.parallel.Client
+        The IPython.parallel Client instance that will be used in the
+        parfor execution.
+
+    view: a IPython.parallel.Client view
+        The view that is to be used in scheduling the tasks on the IPython
+        cluster. Preferably a load-balanced view, which is obtained from the
+        IPython.parallel.Client instance client by calling,
+        view = client.load_balanced_view().
+
+    show_scheduling: bool {False, True}, default False
+        Display a graph showing how the tasks (the evaluation of ``task`` for
+        for the value in ``task_vec1``) was scheduled on the IPython engine
+        cluster.
+
+    show_progressbar: bool {False, True}, default False
+        Display a HTML-based progress bar duing the execution of the parfor
+        loop.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of ``task(value, args)`` for each
+        value in ``task_vec``, that is, it should be equivalent to
+        ``[task(v, args) for v in task_vec]``.
+    """
+
+    if show_progressbar:
+        progress_bar = HTMLProgressBar()
+    else:
+        progress_bar = None
+
+    return parallel_map(task, task_vec, task_args=args,
+                        client=client, view=view, progress_bar=progress_bar,
+                        show_scheduling=show_scheduling)
+
+
+def parallel_map(task, values, task_args=None, task_kwargs=None,
+                 client=None, view=None, progress_bar=None,
+                 show_scheduling=False, **kwargs):
+    """
+    Call the function ``task`` for each value in ``values`` using a cluster
+    of IPython engines. The function ``task`` should have the signature
+    ``task(value, *args, **kwargs)``.
+
+    The ``client`` and ``view`` are the IPython.parallel client and
+    load-balanced view that will be used in the parfor execution. If these
+    are ``None``, new instances will be created.
+
+    Parameters
+    ----------
+
+    task: a Python function
+        The function that is to be called for each value in ``task_vec``.
+
+    values: array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+
+    task_args: list / dictionary
+        The optional additional argument to the ``task`` function.
+
+    task_kwargs: list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+
+    client: IPython.parallel.Client
+        The IPython.parallel Client instance that will be used in the
+        parfor execution.
+
+    view: a IPython.parallel.Client view
+        The view that is to be used in scheduling the tasks on the IPython
+        cluster. Preferably a load-balanced view, which is obtained from the
+        IPython.parallel.Client instance client by calling,
+        view = client.load_balanced_view().
+
+    show_scheduling: bool {False, True}, default False
+        Display a graph showing how the tasks (the evaluation of ``task`` for
+        for the value in ``task_vec1``) was scheduled on the IPython engine
+        cluster.
+
+    show_progressbar: bool {False, True}, default False
+        Display a HTML-based progress bar during the execution of the parfor
+        loop.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of
+        ``task(value, task_args, task_kwargs)`` for each
+        value in ``values``.
+
+    """
+    submitted = datetime.datetime.now()
+
+    if task_args is None:
+        task_args = tuple()
+
+    if task_kwargs is None:
+        task_kwargs = {}
+
+    if client is None:
+        client = Client()
+
+        # make sure qutip is available at engines
+        dview = client[:]
+        dview.block = True
+        dview.execute("from qutip import *")
+
+    if view is None:
+        view = client.load_balanced_view()
+
+    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
+               for value in values]
+
+    if progress_bar is None:
+        view.wait(ar_list)
+    else:
+        if progress_bar is True:
+            progress_bar = HTMLProgressBar()
+
+        n = len(ar_list)
+        progress_bar.start(n)
+        while True:
+            n_finished = sum([ar.progress for ar in ar_list])
+            progress_bar.update(n_finished)
+
+            if view.wait(ar_list, timeout=0.5):
+                progress_bar.update(n)
+                break
+        progress_bar.finished()
+
+    if show_scheduling:
+        metadata = [[ar.engine_id,
+                     (ar.started - submitted).total_seconds(),
+                     (ar.completed - submitted).total_seconds()]
+                    for ar in ar_list]
+        _visualize_parfor_data(metadata)
+
+    return [ar.get() for ar in ar_list]
+
+
+def plot_animation(plot_setup_func, plot_func, result, name="movie",
+                   writer="avconv", codec="libx264", verbose=False):
+    """
+    Create an animated plot of a Result object, as returned by one of
+    the qutip evolution solvers.
+
+    .. note :: experimental
+    """
+
+    fig, axes = plot_setup_func(result)
+
+    def update(n):
+        return plot_func(result, n, fig=fig, axes=axes)
+
+    anim = animation.FuncAnimation(
+        fig, update, frames=len(result.times), blit=True)
+
+    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
+
+    plt.close(fig)
+
+    if verbose:
+        print("Created %s.m4v" % name)
+
+    video = open(name + '.mp4', "rb").read()
+    video_encoded = b64encode(video).decode("ascii")
+    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
+        video_encoded)
+    return HTML(video_tag)
diff --git a/qutip/logging_utils.py b/qutip/logging_utils.py
index c91b380b50..915049d999 100644
--- a/qutip/logging_utils.py
+++ b/qutip/logging_utils.py
@@ -1,109 +1,109 @@
-"""
-This module contains internal-use functions for configuring and writing to
-debug logs, using Python's internal logging functionality by default.
-"""
-
-# IMPORTS
-from __future__ import absolute_import
-import inspect
-import logging
-
-from qutip.settings import settings
-
-# EXPORTS
-NOTSET = logging.NOTSET
-DEBUG_INTENSE = logging.DEBUG - 4
-DEBUG_VERBOSE = logging.DEBUG - 2
-DEBUG = logging.DEBUG
-INFO = logging.INFO
-WARN = logging.WARN
-ERROR = logging.ERROR
-CRITICAL = logging.CRITICAL
-
-__all__ = ['get_logger']
-
-# META-LOGGING
-
-metalogger = logging.getLogger(__name__)
-metalogger.addHandler(logging.NullHandler())
-
-
-# FUNCTIONS
-
-def get_logger(name=None):
-    """
-    Returns a Python logging object with handlers configured
-    in accordance with ~/.qutiprc. By default, this will do
-    something sensible to integrate with IPython when running
-    in that environment, and will print to stdout otherwise.
-
-    Note that this function uses a bit of magic, and thus should
-    not be considered part of the QuTiP API. Rather, this function
-    is for internal use only.
-
-    Parameters
-    ----------
-
-    name : str
-        Name of the logger to be created. If not passed,
-        the name will automatically be set to the name of the
-        calling module.
-    """
-    if name is None:
-        try:
-            calling_frame = inspect.stack()[1][0]
-            calling_module = inspect.getmodule(calling_frame)
-            name = (calling_module.__name__
-                    if calling_module is not None else '<none>')
-
-        except Exception:
-            metalogger.warn('Error creating logger.', exc_info=1)
-            name = '<unknown>'
-
-    logger = logging.getLogger(name)
-
-    policy = settings.log_handler
-
-    if policy == 'default':
-        # Let's try to see if we're in IPython mode.
-        policy = 'basic' if settings.ipython else 'stream'
-
-    metalogger.debug("Creating logger for {} with policy {}.".format(
-        name, policy
-    ))
-
-    if policy == 'basic':
-        # Add no handlers, just let basicConfig do it all.
-        # This is nice for working with IPython, since
-        # it will use its own handlers instead of our StreamHandler
-        # below.
-        if settings.debug:
-            logging.basicConfig(level=logging.DEBUG)
-        else:
-            logging.basicConfig()
-
-    elif policy == 'stream':
-        formatter = logging.Formatter(
-            '[%(asctime)s] %(name)s[%(process)s]: '
-            '%(funcName)s: %(levelname)s: %(message)s',
-            '%Y-%m-%d %H:%M:%S')
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        # We're handling things here, so no propagation out.
-        logger.propagate = False
-
-    elif policy == 'null':
-        # We need to add a NullHandler so that debugging works
-        # at all, but this policy leaves it to the user to
-        # make their own handlers. This is particularly useful
-        # for capturing to logfiles.
-        logger.addHandler(logging.NullHandler())
-
-    if settings.debug:
-        logger.setLevel(logging.DEBUG)
-    else:
-        logger.setLevel(logging.WARN)
-
-    return logger
+"""
+This module contains internal-use functions for configuring and writing to
+debug logs, using Python's internal logging functionality by default.
+"""
+
+# IMPORTS
+from __future__ import absolute_import
+import inspect
+import logging
+
+from qutip.settings import settings
+
+# EXPORTS
+NOTSET = logging.NOTSET
+DEBUG_INTENSE = logging.DEBUG - 4
+DEBUG_VERBOSE = logging.DEBUG - 2
+DEBUG = logging.DEBUG
+INFO = logging.INFO
+WARN = logging.WARN
+ERROR = logging.ERROR
+CRITICAL = logging.CRITICAL
+
+__all__ = ['get_logger']
+
+# META-LOGGING
+
+metalogger = logging.getLogger(__name__)
+metalogger.addHandler(logging.NullHandler())
+
+
+# FUNCTIONS
+
+def get_logger(name=None):
+    """
+    Returns a Python logging object with handlers configured
+    in accordance with ~/.qutiprc. By default, this will do
+    something sensible to integrate with IPython when running
+    in that environment, and will print to stdout otherwise.
+
+    Note that this function uses a bit of magic, and thus should
+    not be considered part of the QuTiP API. Rather, this function
+    is for internal use only.
+
+    Parameters
+    ----------
+
+    name : str
+        Name of the logger to be created. If not passed,
+        the name will automatically be set to the name of the
+        calling module.
+    """
+    if name is None:
+        try:
+            calling_frame = inspect.stack()[1][0]
+            calling_module = inspect.getmodule(calling_frame)
+            name = (calling_module.__name__
+                    if calling_module is not None else '<none>')
+
+        except Exception:
+            metalogger.warn('Error creating logger.', exc_info=1)
+            name = '<unknown>'
+
+    logger = logging.getLogger(name)
+
+    policy = settings.log_handler
+
+    if policy == 'default':
+        # Let's try to see if we're in IPython mode.
+        policy = 'basic' if settings.ipython else 'stream'
+
+    metalogger.debug("Creating logger for {} with policy {}.".format(
+        name, policy
+    ))
+
+    if policy == 'basic':
+        # Add no handlers, just let basicConfig do it all.
+        # This is nice for working with IPython, since
+        # it will use its own handlers instead of our StreamHandler
+        # below.
+        if settings.debug:
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig()
+
+    elif policy == 'stream':
+        formatter = logging.Formatter(
+            '[%(asctime)s] %(name)s[%(process)s]: '
+            '%(funcName)s: %(levelname)s: %(message)s',
+            '%Y-%m-%d %H:%M:%S')
+        handler = logging.StreamHandler()
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+        # We're handling things here, so no propagation out.
+        logger.propagate = False
+
+    elif policy == 'null':
+        # We need to add a NullHandler so that debugging works
+        # at all, but this policy leaves it to the user to
+        # make their own handlers. This is particularly useful
+        # for capturing to logfiles.
+        logger.addHandler(logging.NullHandler())
+
+    if settings.debug:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.WARN)
+
+    return logger
diff --git a/qutip/matplotlib_utilities.py b/qutip/matplotlib_utilities.py
index 3181b29192..816a4eb1cb 100644
--- a/qutip/matplotlib_utilities.py
+++ b/qutip/matplotlib_utilities.py
@@ -1,154 +1,154 @@
-"""
-This module contains utility functions that enhance Matplotlib
-in one way or another.
-"""
-
-__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
-
-import numpy as np
-
-try:
-    import matplotlib as mpl
-    from matplotlib import cm
-    from matplotlib.colors import (Normalize, ColorConverter)
-except:
-    class Normalize(object):
-        def __init__(self, vmin=None, vmax=None, clip=False):
-            pass
-
-
-def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
-                mid_color='#FFFFFF', min_color='#530017',
-                neg_color='#FF97D4', invert=False):
-    """A custom colormap that emphasizes negative values by creating a
-    nonlinear colormap.
-
-    Parameters
-    ----------
-    W : array
-        Wigner function array, or any array.
-    levels : int
-        Number of color levels to create.
-    shift : float
-        Shifts the value at which Wigner elements are emphasized.
-        This parameter should typically be negative and small (i.e -1e-5).
-    max_color : str
-        String for color corresponding to maximum value of data.  Accepts
-        any string format compatible with the Matplotlib.colors.ColorConverter.
-    mid_color : str
-        Color corresponding to zero values.  Accepts any string format
-        compatible with the Matplotlib.colors.ColorConverter.
-    min_color : str
-        Color corresponding to minimum data values.  Accepts any string format
-        compatible with the Matplotlib.colors.ColorConverter.
-    neg_color : str
-        Color that starts highlighting negative values.  Accepts any string
-        format compatible with the Matplotlib.colors.ColorConverter.
-    invert : bool
-        Invert the color scheme for negative values so that smaller negative
-        values have darker color.
-
-    Returns
-    -------
-    Returns a Matplotlib colormap instance for use in plotting.
-
-    Notes
-    -----
-    The 'shift' parameter allows you to vary where the colormap begins
-    to highlight negative colors. This is beneficial in cases where there
-    are small negative Wigner elements due to numerical round-off and/or
-    truncation.
-
-    """
-    cc = ColorConverter()
-    max_color = np.array(cc.to_rgba(max_color), dtype=float)
-    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
-    if invert:
-        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
-        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
-    else:
-        min_color = np.array(cc.to_rgba(min_color), dtype=float)
-        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
-    # get min and max values from Wigner function
-    bounds = [W.min(), W.max()]
-    # create empty array for RGBA colors
-    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
-    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
-                        / (bounds[1] - bounds[0])))
-    num_pos = levels - zero_pos
-    num_neg = zero_pos - 1
-    # set zero values to mid_color
-    adjust_RGBA[zero_pos] = mid_color
-    # interpolate colors
-    for k in range(0, levels):
-        if k < zero_pos:
-            interp = k / (num_neg + 1.0)
-            adjust_RGBA[k][0:3] = (1.0 - interp) * \
-                min_color[0:3] + interp * neg_color[0:3]
-        elif k > zero_pos:
-            interp = (k - zero_pos) / (num_pos + 1.0)
-            adjust_RGBA[k][0:3] = (1.0 - interp) * \
-                mid_color[0:3] + interp * max_color[0:3]
-    # create colormap
-    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
-                                                            adjust_RGBA,
-                                                            N=levels)
-    return wig_cmap
-
-
-def complex_phase_cmap():
-    """
-    Create a cyclic colormap for representing the phase of complex variables
-
-    Returns
-    -------
-    cmap :
-        A matplotlib linear segmented colormap.
-    """
-    cdict = {'blue': ((0.00, 0.0, 0.0),
-                      (0.25, 0.0, 0.0),
-                      (0.50, 1.0, 1.0),
-                      (0.75, 1.0, 1.0),
-                      (1.00, 0.0, 0.0)),
-             'green': ((0.00, 0.0, 0.0),
-                       (0.25, 1.0, 1.0),
-                       (0.50, 0.0, 0.0),
-                       (0.75, 1.0, 1.0),
-                       (1.00, 0.0, 0.0)),
-             'red': ((0.00, 1.0, 1.0),
-                     (0.25, 0.5, 0.5),
-                     (0.50, 0.0, 0.0),
-                     (0.75, 0.0, 0.0),
-                     (1.00, 1.0, 1.0))}
-
-    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
-
-    return cmap
-
-
-class MidpointNorm(Normalize):
-    """Normalization for a colormap centered about a given midpoint.
-
-    Parameters
-    ----------
-    midpoint : float (optional, default=0)
-        Midpoint about which colormap is centered.
-    vmin: float (optional)
-        Minimal value for colormap. Calculated from data by default.
-    vmax: float (optional)
-        Maximal value for colormap. Calculated from data by default.
-
-    Returns
-    -------
-    Returns a Matplotlib colormap normalization that can be used
-    with any colormap.
-
-    """
-
-    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
-        self.midpoint = midpoint
-        Normalize.__init__(self, vmin, vmax, clip)
-
-    def __call__(self, value, clip=None):
-        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
-        return np.ma.masked_array(np.interp(value, x, y))
+"""
+This module contains utility functions that enhance Matplotlib
+in one way or another.
+"""
+
+__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
+
+import numpy as np
+
+try:
+    import matplotlib as mpl
+    from matplotlib import cm
+    from matplotlib.colors import (Normalize, ColorConverter)
+except:
+    class Normalize(object):
+        def __init__(self, vmin=None, vmax=None, clip=False):
+            pass
+
+
+def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
+                mid_color='#FFFFFF', min_color='#530017',
+                neg_color='#FF97D4', invert=False):
+    """A custom colormap that emphasizes negative values by creating a
+    nonlinear colormap.
+
+    Parameters
+    ----------
+    W : array
+        Wigner function array, or any array.
+    levels : int
+        Number of color levels to create.
+    shift : float
+        Shifts the value at which Wigner elements are emphasized.
+        This parameter should typically be negative and small (i.e -1e-5).
+    max_color : str
+        String for color corresponding to maximum value of data.  Accepts
+        any string format compatible with the Matplotlib.colors.ColorConverter.
+    mid_color : str
+        Color corresponding to zero values.  Accepts any string format
+        compatible with the Matplotlib.colors.ColorConverter.
+    min_color : str
+        Color corresponding to minimum data values.  Accepts any string format
+        compatible with the Matplotlib.colors.ColorConverter.
+    neg_color : str
+        Color that starts highlighting negative values.  Accepts any string
+        format compatible with the Matplotlib.colors.ColorConverter.
+    invert : bool
+        Invert the color scheme for negative values so that smaller negative
+        values have darker color.
+
+    Returns
+    -------
+    Returns a Matplotlib colormap instance for use in plotting.
+
+    Notes
+    -----
+    The 'shift' parameter allows you to vary where the colormap begins
+    to highlight negative colors. This is beneficial in cases where there
+    are small negative Wigner elements due to numerical round-off and/or
+    truncation.
+
+    """
+    cc = ColorConverter()
+    max_color = np.array(cc.to_rgba(max_color), dtype=float)
+    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
+    if invert:
+        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
+        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
+    else:
+        min_color = np.array(cc.to_rgba(min_color), dtype=float)
+        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
+    # get min and max values from Wigner function
+    bounds = [W.min(), W.max()]
+    # create empty array for RGBA colors
+    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
+    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
+                        / (bounds[1] - bounds[0])))
+    num_pos = levels - zero_pos
+    num_neg = zero_pos - 1
+    # set zero values to mid_color
+    adjust_RGBA[zero_pos] = mid_color
+    # interpolate colors
+    for k in range(0, levels):
+        if k < zero_pos:
+            interp = k / (num_neg + 1.0)
+            adjust_RGBA[k][0:3] = (1.0 - interp) * \
+                min_color[0:3] + interp * neg_color[0:3]
+        elif k > zero_pos:
+            interp = (k - zero_pos) / (num_pos + 1.0)
+            adjust_RGBA[k][0:3] = (1.0 - interp) * \
+                mid_color[0:3] + interp * max_color[0:3]
+    # create colormap
+    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
+                                                            adjust_RGBA,
+                                                            N=levels)
+    return wig_cmap
+
+
+def complex_phase_cmap():
+    """
+    Create a cyclic colormap for representing the phase of complex variables
+
+    Returns
+    -------
+    cmap :
+        A matplotlib linear segmented colormap.
+    """
+    cdict = {'blue': ((0.00, 0.0, 0.0),
+                      (0.25, 0.0, 0.0),
+                      (0.50, 1.0, 1.0),
+                      (0.75, 1.0, 1.0),
+                      (1.00, 0.0, 0.0)),
+             'green': ((0.00, 0.0, 0.0),
+                       (0.25, 1.0, 1.0),
+                       (0.50, 0.0, 0.0),
+                       (0.75, 1.0, 1.0),
+                       (1.00, 0.0, 0.0)),
+             'red': ((0.00, 1.0, 1.0),
+                     (0.25, 0.5, 0.5),
+                     (0.50, 0.0, 0.0),
+                     (0.75, 0.0, 0.0),
+                     (1.00, 1.0, 1.0))}
+
+    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
+
+    return cmap
+
+
+class MidpointNorm(Normalize):
+    """Normalization for a colormap centered about a given midpoint.
+
+    Parameters
+    ----------
+    midpoint : float (optional, default=0)
+        Midpoint about which colormap is centered.
+    vmin: float (optional)
+        Minimal value for colormap. Calculated from data by default.
+    vmax: float (optional)
+        Maximal value for colormap. Calculated from data by default.
+
+    Returns
+    -------
+    Returns a Matplotlib colormap normalization that can be used
+    with any colormap.
+
+    """
+
+    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
+        self.midpoint = midpoint
+        Normalize.__init__(self, vmin, vmax, clip)
+
+    def __call__(self, value, clip=None):
+        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+        return np.ma.masked_array(np.interp(value, x, y))
diff --git a/qutip/measurement.py b/qutip/measurement.py
index da90387dd0..65e2f1ca83 100644
--- a/qutip/measurement.py
+++ b/qutip/measurement.py
@@ -1,381 +1,381 @@
-"""
-Module for measuring quantum objects.
-"""
-
-__all__ = [
-    'measurement_statistics_povm',
-    'measurement_statistics_observable',
-    'measure_observable',
-    'measure_povm',
-    'measurement_statistics',
-    'measure'
-]
-
-import numpy as np
-
-from . import Qobj, expect, identity, tensor
-
-
-def _verify_input(op, state):
-    if not isinstance(op, Qobj):
-        raise TypeError("op must be a Qobj")
-    if not op.isoper:
-        raise ValueError("op must be all operators or all kets")
-    if not isinstance(state, Qobj):
-        raise TypeError("state must be a Qobj")
-    if state.isket:
-        if op.dims[-1] != state.dims[0]:
-            raise ValueError(
-                "op and state dims should be compatible when state is a ket")
-    elif state.isoper:
-        if op.dims != state.dims:
-            raise ValueError(
-                "op and state dims should match"
-                " when state is a density matrix")
-    else:
-        raise ValueError("state must be a ket or a density matrix")
-
-
-def _measurement_statistics_povm_ket(state, ops):
-    r"""
-    Returns measurement statistics (resultant states and probabilities)
-    for a measurements specified by a set of positive operator valued
-    measurements on a specified ket.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj` (ket)
-            The ket specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-      List of measurement operators :math:`M_i` (specifying a POVM such that
-      :math:`E_i = M_i^\dagger M_i`).
-
-
-    Returns
-    -------
-    collapsed_states : list of :class:`.Qobj` (kets)
-        The collapsed states (kets) obtained after measuring the qubits and
-        obtaining the qubit specified by the target in the state specified by
-        the index.
-
-    probabilities : list of floats
-        The probability of measuring a state in a the state specified by the
-        index.
-    """
-    probabilities = []
-    collapsed_states = []
-
-    for i, op in enumerate(ops):
-        p = np.absolute((state.dag() * op.dag() * op * state))
-        probabilities.append(p)
-        if p != 0:
-            collapsed_states.append((op * state) / np.sqrt(p))
-        else:
-            collapsed_states.append(None)
-
-    return collapsed_states, probabilities
-
-
-def _measurement_statistics_povm_dm(density_mat, ops):
-    r"""
-    Returns measurement statistics (resultant states and probabilities)
-    for a measurements specified by a set of positive operator valued
-    measurements on a specified ket or density matrix.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj` (density matrix)
-        The ket or density matrix specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-        List of measurement operators :math:`M_i` (specifying a POVM s.t.
-        :mathm:`E_i = M_i^\dagger M_i`)
-
-    Returns
-    -------
-    collapsed_states : list of :class:`.Qobj`
-        The collapsed states (density matrices) obtained after measuring the
-        qubits and obtaining the qubit specified by the target in the state
-        specified by the index.
-
-    probabilities : list of float
-        The probability of measuring a state in a the state specified by the
-        index.
-    """
-    probabilities = []
-    collapsed_states = []
-
-    for i, op in enumerate(ops):
-        st = op * density_mat * op.dag()
-        p = st.tr()
-        probabilities.append(p)
-        if p != 0:
-            collapsed_states.append(st/p)
-        else:
-            collapsed_states.append(None)
-
-    return collapsed_states, probabilities
-
-
-def measurement_statistics_povm(state, ops):
-    r"""
-    Returns measurement statistics (resultant states and probabilities) for a
-    measurement specified by a set of positive operator valued measurements on
-    a specified ket or density matrix.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-        List of measurement operators :math:`M_i` or kets.  Either:
-
-        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-        2. projection operators if ops correspond to
-           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
-        3. kets (transformed to projectors)
-
-    Returns
-    -------
-    collapsed_states : list of :class:`.Qobj`
-        The collapsed states obtained after measuring the qubits and obtaining
-        the qubit specified by the target in the state specified by the index.
-
-    probabilities : list of floats
-        The probability of measuring a state in a the state specified by the
-        index.
-    """
-    if all(map(lambda x: x.isket, ops)):
-        ops = [op * op.dag() for op in ops]
-
-    for op in ops:
-        _verify_input(op, state)
-
-    E = [op.dag() * op for op in ops]
-
-    is_ID = sum(E)
-    if not is_ID == identity(is_ID.dims[0]):
-        raise ValueError("measurement operators must sum to identity")
-
-    if state.isket:
-        return _measurement_statistics_povm_ket(state, ops)
-    else:
-        return _measurement_statistics_povm_dm(state, ops)
-
-
-def measurement_statistics_observable(state, op):
-    """
-    Return the measurement eigenvalues, eigenstates (or projectors) and
-    measurement probabilities for the given state and measurement operator.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    op : :class:`.Qobj`
-        The measurement operator.
-
-    Returns
-    -------
-    eigenvalues: list of float
-        The list of eigenvalues of the measurement operator.
-
-    eigenstates_or_projectors: list of :class:`.Qobj`
-        If the state was a ket, return the eigenstates of the measurement
-        operator. Otherwise return the projectors onto the eigenstates.
-
-    probabilities: list of float
-        The probability of measuring the state as being in the corresponding
-        eigenstate (and the measurement result being the corresponding
-        eigenvalue).
-    """
-    _verify_input(op, state)
-
-    eigenvalues, eigenstates = op.eigenstates()
-    if state.isket:
-        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
-        return eigenvalues, eigenstates, probabilities
-    else:
-        projectors = [e.proj() for e in eigenstates]
-        probabilities = [expect(v, state) for v in projectors]
-        return eigenvalues, projectors, probabilities
-
-
-def measure_observable(state, op):
-    """
-    Perform a measurement specified by an operator on the given state.
-
-    This function simulates the classic quantum measurement described in many
-    introductory texts on quantum mechanics. The measurement collapses the
-    state to one of the eigenstates of the given operator and the result of the
-    measurement is the corresponding eigenvalue.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    op : :class:`.Qobj`
-        The measurement operator.
-
-    Returns
-    -------
-    measured_value : float
-        The result of the measurement (one of the eigenvalues of op).
-
-    state : :class:`.Qobj`
-        The new state (a ket if a ket was given, otherwise a density matrix).
-
-    Examples
-    --------
-
-    Measure the z-component of the spin of the spin-up basis state:
-
-    >>> measure_observable(basis(2, 0), sigmaz())
-    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
-    Qobj data =
-    [[-1.]
-     [ 0.]])
-
-    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
-    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
-    and the original state (up to a global phase).
-
-    Measure the x-component of the spin of the spin-down basis state:
-
-    >>> measure_observable(basis(2, 1), sigmax())
-    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
-    Qobj data =
-    [[-0.70710678]
-     [ 0.70710678]])
-
-    This measurement returns 1 fifty percent of the time and -1 the other fifty
-    percent of the time. The new state returned is the corresponding eigenstate
-    of sigmax.
-
-    One may also perform a measurement on a density matrix. Below we perform
-    the same measurement as above, but on the density matrix representing the
-    pure spin-down state:
-
-    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
-    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
-    Qobj data =
-    [[ 0.5 -0.5]
-     [-0.5  0.5]])
-
-    The measurement result is the same, but the new state is returned as a
-    density matrix.
-    """
-    eigenvalues, eigenstates_or_projectors, probabilities = (
-        measurement_statistics_observable(state, op))
-    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
-    if state.isket:
-        eigenstates = eigenstates_or_projectors
-        state = eigenstates[i]
-    else:
-        projectors = eigenstates_or_projectors
-        state = (projectors[i] * state * projectors[i]) / probabilities[i]
-    return eigenvalues[i], state
-
-
-def measure_povm(state, ops):
-    r"""
-    Perform a measurement specified by list of POVMs.
-
-    This function simulates a POVM measurement. The measurement collapses the
-    state to one of the resultant states of the measurement and returns the
-    index of the operator corresponding to the collapsed state as well as the
-    collapsed state.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-        List of measurement operators :math:`M_i` or kets.  Either:
-
-        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-        2. projection operators if ops correspond to projectors (s.t.
-           :math:`E_i = M_i^\dagger = M_i`)
-        3. kets (transformed to projectors)
-
-    Returns
-    -------
-    index : float
-        The resultant index of the measurement.
-
-    state : :class:`.Qobj`
-        The new state (a ket if a ket was given, otherwise a density matrix).
-    """
-    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
-    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
-    state = collapsed_states[index]
-    return index, state
-
-
-def measurement_statistics(state, ops):
-    r"""
-    A dispatch method that provides measurement statistics handling both
-    observable style measurements and projector style measurements(POVMs and
-    PVMs).
-
-    For return signatures, please check:
-
-    - :func:`~measurement_statistics_observable` for observable measurements.
-    - :func:`~measurement_statistics_povm` for POVM measurements.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : :class:`.Qobj` or list of :class:`.Qobj`
-        - measurement observable (:class:.Qobj); or
-        - list of measurement operators :math:`M_i` or kets (list of
-          :class:`.Qobj`) Either:
-
-          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
-          2. projection operators if ops correspond to projectors (s.t.
-             :math:`E_i = M_i^\dagger = M_i`)
-          3. kets (transformed to projectors)
-    """
-    if isinstance(ops, list):
-        return measurement_statistics_povm(state, ops)
-    else:
-        return measurement_statistics_observable(state, ops)
-
-
-def measure(state, ops):
-    r"""
-    A dispatch method that provides measurement results handling both
-    observable style measurements and projector style measurements (POVMs and
-    PVMs).
-
-    For return signatures, please check:
-
-    - :func:`~measure_observable` for observable measurements.
-    - :func:`~measure_povm` for POVM measurements.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : :class:`.Qobj` or list of :class:`.Qobj`
-        - measurement observable (:class:`.Qobj`); or
-        - list of measurement operators :math:`M_i` or kets (list of
-          :class:`.Qobj`) Either:
-
-          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-          2. projection operators if ops correspond to projectors (s.t.
-             :math:`E_i = M_i^\dagger = M_i`)
-          3. kets (transformed to projectors)
-    """
-    if isinstance(ops, list):
-        return measure_povm(state, ops)
-    else:
-        return measure_observable(state, ops)
+"""
+Module for measuring quantum objects.
+"""
+
+__all__ = [
+    'measurement_statistics_povm',
+    'measurement_statistics_observable',
+    'measure_observable',
+    'measure_povm',
+    'measurement_statistics',
+    'measure'
+]
+
+import numpy as np
+
+from . import Qobj, expect, identity, tensor
+
+
+def _verify_input(op, state):
+    if not isinstance(op, Qobj):
+        raise TypeError("op must be a Qobj")
+    if not op.isoper:
+        raise ValueError("op must be all operators or all kets")
+    if not isinstance(state, Qobj):
+        raise TypeError("state must be a Qobj")
+    if state.isket:
+        if op.dims[-1] != state.dims[0]:
+            raise ValueError(
+                "op and state dims should be compatible when state is a ket")
+    elif state.isoper:
+        if op.dims != state.dims:
+            raise ValueError(
+                "op and state dims should match"
+                " when state is a density matrix")
+    else:
+        raise ValueError("state must be a ket or a density matrix")
+
+
+def _measurement_statistics_povm_ket(state, ops):
+    r"""
+    Returns measurement statistics (resultant states and probabilities)
+    for a measurements specified by a set of positive operator valued
+    measurements on a specified ket.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj` (ket)
+            The ket specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+      List of measurement operators :math:`M_i` (specifying a POVM such that
+      :math:`E_i = M_i^\dagger M_i`).
+
+
+    Returns
+    -------
+    collapsed_states : list of :class:`.Qobj` (kets)
+        The collapsed states (kets) obtained after measuring the qubits and
+        obtaining the qubit specified by the target in the state specified by
+        the index.
+
+    probabilities : list of floats
+        The probability of measuring a state in a the state specified by the
+        index.
+    """
+    probabilities = []
+    collapsed_states = []
+
+    for i, op in enumerate(ops):
+        p = np.absolute((state.dag() * op.dag() * op * state))
+        probabilities.append(p)
+        if p != 0:
+            collapsed_states.append((op * state) / np.sqrt(p))
+        else:
+            collapsed_states.append(None)
+
+    return collapsed_states, probabilities
+
+
+def _measurement_statistics_povm_dm(density_mat, ops):
+    r"""
+    Returns measurement statistics (resultant states and probabilities)
+    for a measurements specified by a set of positive operator valued
+    measurements on a specified ket or density matrix.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj` (density matrix)
+        The ket or density matrix specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+        List of measurement operators :math:`M_i` (specifying a POVM s.t.
+        :mathm:`E_i = M_i^\dagger M_i`)
+
+    Returns
+    -------
+    collapsed_states : list of :class:`.Qobj`
+        The collapsed states (density matrices) obtained after measuring the
+        qubits and obtaining the qubit specified by the target in the state
+        specified by the index.
+
+    probabilities : list of float
+        The probability of measuring a state in a the state specified by the
+        index.
+    """
+    probabilities = []
+    collapsed_states = []
+
+    for i, op in enumerate(ops):
+        st = op * density_mat * op.dag()
+        p = st.tr()
+        probabilities.append(p)
+        if p != 0:
+            collapsed_states.append(st/p)
+        else:
+            collapsed_states.append(None)
+
+    return collapsed_states, probabilities
+
+
+def measurement_statistics_povm(state, ops):
+    r"""
+    Returns measurement statistics (resultant states and probabilities) for a
+    measurement specified by a set of positive operator valued measurements on
+    a specified ket or density matrix.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+        List of measurement operators :math:`M_i` or kets.  Either:
+
+        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+        2. projection operators if ops correspond to
+           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
+        3. kets (transformed to projectors)
+
+    Returns
+    -------
+    collapsed_states : list of :class:`.Qobj`
+        The collapsed states obtained after measuring the qubits and obtaining
+        the qubit specified by the target in the state specified by the index.
+
+    probabilities : list of floats
+        The probability of measuring a state in a the state specified by the
+        index.
+    """
+    if all(map(lambda x: x.isket, ops)):
+        ops = [op * op.dag() for op in ops]
+
+    for op in ops:
+        _verify_input(op, state)
+
+    E = [op.dag() * op for op in ops]
+
+    is_ID = sum(E)
+    if not is_ID == identity(is_ID.dims[0]):
+        raise ValueError("measurement operators must sum to identity")
+
+    if state.isket:
+        return _measurement_statistics_povm_ket(state, ops)
+    else:
+        return _measurement_statistics_povm_dm(state, ops)
+
+
+def measurement_statistics_observable(state, op):
+    """
+    Return the measurement eigenvalues, eigenstates (or projectors) and
+    measurement probabilities for the given state and measurement operator.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    op : :class:`.Qobj`
+        The measurement operator.
+
+    Returns
+    -------
+    eigenvalues: list of float
+        The list of eigenvalues of the measurement operator.
+
+    eigenstates_or_projectors: list of :class:`.Qobj`
+        If the state was a ket, return the eigenstates of the measurement
+        operator. Otherwise return the projectors onto the eigenstates.
+
+    probabilities: list of float
+        The probability of measuring the state as being in the corresponding
+        eigenstate (and the measurement result being the corresponding
+        eigenvalue).
+    """
+    _verify_input(op, state)
+
+    eigenvalues, eigenstates = op.eigenstates()
+    if state.isket:
+        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
+        return eigenvalues, eigenstates, probabilities
+    else:
+        projectors = [e.proj() for e in eigenstates]
+        probabilities = [expect(v, state) for v in projectors]
+        return eigenvalues, projectors, probabilities
+
+
+def measure_observable(state, op):
+    """
+    Perform a measurement specified by an operator on the given state.
+
+    This function simulates the classic quantum measurement described in many
+    introductory texts on quantum mechanics. The measurement collapses the
+    state to one of the eigenstates of the given operator and the result of the
+    measurement is the corresponding eigenvalue.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    op : :class:`.Qobj`
+        The measurement operator.
+
+    Returns
+    -------
+    measured_value : float
+        The result of the measurement (one of the eigenvalues of op).
+
+    state : :class:`.Qobj`
+        The new state (a ket if a ket was given, otherwise a density matrix).
+
+    Examples
+    --------
+
+    Measure the z-component of the spin of the spin-up basis state:
+
+    >>> measure_observable(basis(2, 0), sigmaz())
+    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
+    Qobj data =
+    [[-1.]
+     [ 0.]])
+
+    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
+    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
+    and the original state (up to a global phase).
+
+    Measure the x-component of the spin of the spin-down basis state:
+
+    >>> measure_observable(basis(2, 1), sigmax())
+    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
+    Qobj data =
+    [[-0.70710678]
+     [ 0.70710678]])
+
+    This measurement returns 1 fifty percent of the time and -1 the other fifty
+    percent of the time. The new state returned is the corresponding eigenstate
+    of sigmax.
+
+    One may also perform a measurement on a density matrix. Below we perform
+    the same measurement as above, but on the density matrix representing the
+    pure spin-down state:
+
+    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
+    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
+    Qobj data =
+    [[ 0.5 -0.5]
+     [-0.5  0.5]])
+
+    The measurement result is the same, but the new state is returned as a
+    density matrix.
+    """
+    eigenvalues, eigenstates_or_projectors, probabilities = (
+        measurement_statistics_observable(state, op))
+    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
+    if state.isket:
+        eigenstates = eigenstates_or_projectors
+        state = eigenstates[i]
+    else:
+        projectors = eigenstates_or_projectors
+        state = (projectors[i] * state * projectors[i]) / probabilities[i]
+    return eigenvalues[i], state
+
+
+def measure_povm(state, ops):
+    r"""
+    Perform a measurement specified by list of POVMs.
+
+    This function simulates a POVM measurement. The measurement collapses the
+    state to one of the resultant states of the measurement and returns the
+    index of the operator corresponding to the collapsed state as well as the
+    collapsed state.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+        List of measurement operators :math:`M_i` or kets.  Either:
+
+        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+        2. projection operators if ops correspond to projectors (s.t.
+           :math:`E_i = M_i^\dagger = M_i`)
+        3. kets (transformed to projectors)
+
+    Returns
+    -------
+    index : float
+        The resultant index of the measurement.
+
+    state : :class:`.Qobj`
+        The new state (a ket if a ket was given, otherwise a density matrix).
+    """
+    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
+    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
+    state = collapsed_states[index]
+    return index, state
+
+
+def measurement_statistics(state, ops):
+    r"""
+    A dispatch method that provides measurement statistics handling both
+    observable style measurements and projector style measurements(POVMs and
+    PVMs).
+
+    For return signatures, please check:
+
+    - :func:`~measurement_statistics_observable` for observable measurements.
+    - :func:`~measurement_statistics_povm` for POVM measurements.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : :class:`.Qobj` or list of :class:`.Qobj`
+        - measurement observable (:class:.Qobj); or
+        - list of measurement operators :math:`M_i` or kets (list of
+          :class:`.Qobj`) Either:
+
+          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
+          2. projection operators if ops correspond to projectors (s.t.
+             :math:`E_i = M_i^\dagger = M_i`)
+          3. kets (transformed to projectors)
+    """
+    if isinstance(ops, list):
+        return measurement_statistics_povm(state, ops)
+    else:
+        return measurement_statistics_observable(state, ops)
+
+
+def measure(state, ops):
+    r"""
+    A dispatch method that provides measurement results handling both
+    observable style measurements and projector style measurements (POVMs and
+    PVMs).
+
+    For return signatures, please check:
+
+    - :func:`~measure_observable` for observable measurements.
+    - :func:`~measure_povm` for POVM measurements.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : :class:`.Qobj` or list of :class:`.Qobj`
+        - measurement observable (:class:`.Qobj`); or
+        - list of measurement operators :math:`M_i` or kets (list of
+          :class:`.Qobj`) Either:
+
+          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+          2. projection operators if ops correspond to projectors (s.t.
+             :math:`E_i = M_i^\dagger = M_i`)
+          3. kets (transformed to projectors)
+    """
+    if isinstance(ops, list):
+        return measure_povm(state, ops)
+    else:
+        return measure_observable(state, ops)
diff --git a/qutip/orbital.py b/qutip/orbital.py
index 209b65b406..6d171d881f 100644
--- a/qutip/orbital.py
+++ b/qutip/orbital.py
@@ -1,81 +1,81 @@
-__all__ = ['orbital']
-
-import numpy as np
-from scipy.special import sph_harm
-
-
-def orbital(theta, phi, *args):
-    r"""Calculates an angular wave function on a sphere.
-    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
-    the angular wave function on a sphere at the mesh of points
-    defined by theta and phi which is
-    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
-    coefficients specified by the list of kets. Each ket has 2l+1 components
-    for some integer l. The first entry of the ket defines the coefficient
-    c_{l,-l}, while the last entry of the ket defines the
-    coefficient c_{l, l}.
-
-    Parameters
-    ----------
-    theta : int/float/list/array
-        Polar angles in [0, pi]
-
-    phi : int/float/list/array
-        Azimuthal angles in [0, 2*pi]
-
-    args : list/array
-        ``list`` of ket vectors.
-
-    Returns
-    -------
-    ``array`` for angular wave function evaluated at all
-              possible combinations of theta and phi
-
-    """
-    if isinstance(args[0], list):
-        # use the list in args[0]
-        args = args[0]
-
-    # convert to numpy array
-    theta = np.atleast_1d(theta)
-    phi = np.atleast_1d(phi)
-    # check that arrays are only 1D
-    if len(theta.shape) != 1:
-        raise ValueError('Polar angles theta must be 1D list')
-    if len(phi.shape) != 1:
-        raise ValueError('Azimuthal angles phi must be 1D list')
-
-    # make meshgrid
-    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
-    # setup empty wavefunction
-    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
-    # iterate through provided kets
-    for k in range(len(args)):
-        ket = args[k]
-        if ket.type == 'bra':
-            ket = ket.conj()
-        elif not ket.type == 'ket':
-            raise TypeError('Invalid type for input ket in orbital')
-        # Extract l value from the state
-        l = (ket.shape[0] - 1) / 2.0
-        if l != np.floor(l):
-            raise ValueError(
-                'Kets must have odd number of components in orbital')
-        l = int(l)
-        # get factors from ket
-        factors = ket.full()
-        # iterate through the possible m
-
-        for i in range(len(factors)):
-            # set correct m
-            m = i - l
-            # calculate spherical harmonics
-            # note that theta and phi are interchanged in scipy implementation
-            res = sph_harm(m, l, phi_mesh, theta_mesh)
-            psi += factors[i] * res
-
-    # flatten output if only one row
-    if psi.shape[1] == 1:
-        psi = psi.flatten()
-
-    return psi
+__all__ = ['orbital']
+
+import numpy as np
+from scipy.special import sph_harm
+
+
+def orbital(theta, phi, *args):
+    r"""Calculates an angular wave function on a sphere.
+    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
+    the angular wave function on a sphere at the mesh of points
+    defined by theta and phi which is
+    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
+    coefficients specified by the list of kets. Each ket has 2l+1 components
+    for some integer l. The first entry of the ket defines the coefficient
+    c_{l,-l}, while the last entry of the ket defines the
+    coefficient c_{l, l}.
+
+    Parameters
+    ----------
+    theta : int/float/list/array
+        Polar angles in [0, pi]
+
+    phi : int/float/list/array
+        Azimuthal angles in [0, 2*pi]
+
+    args : list/array
+        ``list`` of ket vectors.
+
+    Returns
+    -------
+    ``array`` for angular wave function evaluated at all
+              possible combinations of theta and phi
+
+    """
+    if isinstance(args[0], list):
+        # use the list in args[0]
+        args = args[0]
+
+    # convert to numpy array
+    theta = np.atleast_1d(theta)
+    phi = np.atleast_1d(phi)
+    # check that arrays are only 1D
+    if len(theta.shape) != 1:
+        raise ValueError('Polar angles theta must be 1D list')
+    if len(phi.shape) != 1:
+        raise ValueError('Azimuthal angles phi must be 1D list')
+
+    # make meshgrid
+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+    # setup empty wavefunction
+    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
+    # iterate through provided kets
+    for k in range(len(args)):
+        ket = args[k]
+        if ket.type == 'bra':
+            ket = ket.conj()
+        elif not ket.type == 'ket':
+            raise TypeError('Invalid type for input ket in orbital')
+        # Extract l value from the state
+        l = (ket.shape[0] - 1) / 2.0
+        if l != np.floor(l):
+            raise ValueError(
+                'Kets must have odd number of components in orbital')
+        l = int(l)
+        # get factors from ket
+        factors = ket.full()
+        # iterate through the possible m
+
+        for i in range(len(factors)):
+            # set correct m
+            m = i - l
+            # calculate spherical harmonics
+            # note that theta and phi are interchanged in scipy implementation
+            res = sph_harm(m, l, phi_mesh, theta_mesh)
+            psi += factors[i] * res
+
+    # flatten output if only one row
+    if psi.shape[1] == 1:
+        psi = psi.flatten()
+
+    return psi
diff --git a/qutip/partial_transpose.py b/qutip/partial_transpose.py
index 61871369d8..4a0b259564 100644
--- a/qutip/partial_transpose.py
+++ b/qutip/partial_transpose.py
@@ -1,122 +1,122 @@
-__all__ = ['partial_transpose']
-
-import numpy as np
-import scipy.sparse as sp
-
-from . import (
-    Qobj, state_index_number, state_number_index, state_number_enumerate,
-)
-from .core.dimensions import flatten
-
-
-def partial_transpose(rho, mask, method='dense'):
-    """
-    Return the partial transpose of a Qobj instance `rho`,
-    where `mask` is an array/list with length that equals
-    the number of components of `rho` (that is, the length of
-    `rho.dims[0]`), and the values in `mask` indicates whether
-    or not the corresponding subsystem is to be transposed.
-    The elements in `mask` can be boolean or integers `0` or `1`,
-    where `True`/`1` indicates that the corresponding subsystem
-    should be tranposed.
-
-    Parameters
-    ----------
-
-    rho : :class:`qutip.qobj`
-        A density matrix.
-
-    mask : *list* / *array*
-        A mask that selects which subsystems should be transposed.
-
-    method : str
-        choice of method, `dense` or `sparse`. The default method
-        is `dense`. The `sparse` implementation can be faster for
-        large and sparse systems (hundreds of quantum states).
-
-    Returns
-    -------
-
-    rho_pr: :class:`qutip.qobj`
-
-        A density matrix with the selected subsystems transposed.
-
-    """
-
-    mask = [int(i) for i in mask]
-
-    if method == 'sparse':
-        return _partial_transpose_sparse(rho, mask)
-    else:
-        return _partial_transpose_dense(rho, mask)
-
-
-def _partial_transpose_dense(rho, mask):
-    """
-    Based on Jonas' implementation using numpy.
-    Very fast for dense problems.
-    """
-    nsys = len(mask)
-    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
-    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
-                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
-
-    data = (rho.full()
-            .reshape(flatten(rho.dims))
-            .transpose(pt_idx)
-            .reshape(rho.shape))
-    return Qobj(data, dims=rho.dims)
-
-
-def _partial_transpose_sparse(rho, mask):
-    """
-    Implement the partial transpose using the CSR sparse matrix.
-    """
-
-    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
-    rho_data = rho.to("CSR").data.as_scipy()
-
-    for m in range(len(rho_data.indptr) - 1):
-
-        n1 = rho_data.indptr[m]
-        n2 = rho_data.indptr[m + 1]
-
-        psi_A = state_index_number(rho.dims[0], m)
-
-        for idx, n in enumerate(rho_data.indices[n1:n2]):
-
-            psi_B = state_index_number(rho.dims[1], n)
-
-            m_pt = state_number_index(
-                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
-            n_pt = state_number_index(
-                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
-
-            data[m_pt, n_pt] = rho_data.data[n1 + idx]
-
-    return Qobj(data.tocsr(), dims=rho.dims)
-
-
-def _partial_transpose_reference(rho, mask):
-    """
-    This is a reference implementation that explicitly loops over
-    all states and performs the transpose. It's slow but easy to
-    understand and useful for testing.
-    """
-
-    A_pt = np.zeros(rho.shape, dtype=complex)
-
-    for psi_A in state_number_enumerate(rho.dims[0]):
-        m = state_number_index(rho.dims[0], psi_A)
-
-        for psi_B in state_number_enumerate(rho.dims[1]):
-            n = state_number_index(rho.dims[1], psi_B)
-
-            m_pt = state_number_index(
-                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
-            n_pt = state_number_index(
-                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
-
-            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
-
-    return Qobj(A_pt, dims=rho.dims)
+__all__ = ['partial_transpose']
+
+import numpy as np
+import scipy.sparse as sp
+
+from . import (
+    Qobj, state_index_number, state_number_index, state_number_enumerate,
+)
+from .core.dimensions import flatten
+
+
+def partial_transpose(rho, mask, method='dense'):
+    """
+    Return the partial transpose of a Qobj instance `rho`,
+    where `mask` is an array/list with length that equals
+    the number of components of `rho` (that is, the length of
+    `rho.dims[0]`), and the values in `mask` indicates whether
+    or not the corresponding subsystem is to be transposed.
+    The elements in `mask` can be boolean or integers `0` or `1`,
+    where `True`/`1` indicates that the corresponding subsystem
+    should be tranposed.
+
+    Parameters
+    ----------
+
+    rho : :class:`qutip.qobj`
+        A density matrix.
+
+    mask : *list* / *array*
+        A mask that selects which subsystems should be transposed.
+
+    method : str
+        choice of method, `dense` or `sparse`. The default method
+        is `dense`. The `sparse` implementation can be faster for
+        large and sparse systems (hundreds of quantum states).
+
+    Returns
+    -------
+
+    rho_pr: :class:`qutip.qobj`
+
+        A density matrix with the selected subsystems transposed.
+
+    """
+
+    mask = [int(i) for i in mask]
+
+    if method == 'sparse':
+        return _partial_transpose_sparse(rho, mask)
+    else:
+        return _partial_transpose_dense(rho, mask)
+
+
+def _partial_transpose_dense(rho, mask):
+    """
+    Based on Jonas' implementation using numpy.
+    Very fast for dense problems.
+    """
+    nsys = len(mask)
+    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
+    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
+                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
+
+    data = (rho.full()
+            .reshape(flatten(rho.dims))
+            .transpose(pt_idx)
+            .reshape(rho.shape))
+    return Qobj(data, dims=rho.dims)
+
+
+def _partial_transpose_sparse(rho, mask):
+    """
+    Implement the partial transpose using the CSR sparse matrix.
+    """
+
+    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
+    rho_data = rho.to("CSR").data.as_scipy()
+
+    for m in range(len(rho_data.indptr) - 1):
+
+        n1 = rho_data.indptr[m]
+        n2 = rho_data.indptr[m + 1]
+
+        psi_A = state_index_number(rho.dims[0], m)
+
+        for idx, n in enumerate(rho_data.indices[n1:n2]):
+
+            psi_B = state_index_number(rho.dims[1], n)
+
+            m_pt = state_number_index(
+                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
+            n_pt = state_number_index(
+                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
+
+            data[m_pt, n_pt] = rho_data.data[n1 + idx]
+
+    return Qobj(data.tocsr(), dims=rho.dims)
+
+
+def _partial_transpose_reference(rho, mask):
+    """
+    This is a reference implementation that explicitly loops over
+    all states and performs the transpose. It's slow but easy to
+    understand and useful for testing.
+    """
+
+    A_pt = np.zeros(rho.shape, dtype=complex)
+
+    for psi_A in state_number_enumerate(rho.dims[0]):
+        m = state_number_index(rho.dims[0], psi_A)
+
+        for psi_B in state_number_enumerate(rho.dims[1]):
+            n = state_number_index(rho.dims[1], psi_B)
+
+            m_pt = state_number_index(
+                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
+            n_pt = state_number_index(
+                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
+
+            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
+
+    return Qobj(A_pt, dims=rho.dims)
diff --git a/qutip/qip.py b/qutip/qip.py
index 392b835a94..69cfc8564d 100644
--- a/qutip/qip.py
+++ b/qutip/qip.py
@@ -1,13 +1,13 @@
-"""Module replicating the qutip_qip package from within qutip."""
-import sys
-
-try:
-    import qutip_qip
-    del qutip_qip
-    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
-except ImportError:
-    raise ImportError(
-        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
-        "with `pip install qutip-qip` (for more details, go to "
-        "https://qutip-qip.readthedocs.io/)."
-    )
+"""Module replicating the qutip_qip package from within qutip."""
+import sys
+
+try:
+    import qutip_qip
+    del qutip_qip
+    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
+except ImportError:
+    raise ImportError(
+        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
+        "with `pip install qutip-qip` (for more details, go to "
+        "https://qutip-qip.readthedocs.io/)."
+    )
diff --git a/qutip/random_objects.py b/qutip/random_objects.py
index be759ae9db..5e8f010bd3 100644
--- a/qutip/random_objects.py
+++ b/qutip/random_objects.py
@@ -1,868 +1,868 @@
-"""
-This module is a collection of random state and operator generators.
-"""
-
-__all__ = [
-    'rand_herm',
-    'rand_unitary',
-    'rand_dm',
-    'rand_stochastic',
-    'rand_ket',
-    'rand_kraus_map',
-    'rand_super',
-    "rand_super_bcsz",
-]
-
-import numbers
-
-import numpy as np
-from numpy.random import Generator, SeedSequence, default_rng
-import scipy.linalg
-import scipy.sparse as sp
-
-from . import (Qobj, create, destroy, jmat, basis,
-               to_super, to_choi, to_chi, to_kraus, to_stinespring)
-from .core import data as _data
-from .core.dimensions import flatten
-from . import settings
-
-
-_RAND = default_rng()
-_UNITS = np.array([1, 1j])
-
-
-def _implicit_tensor_dimensions(dimensions, superoper=False):
-    """
-    Total flattened size and operator dimensions for operator creation routines
-    that automatically perform tensor products.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        First dimension of an operator which can create an implicit tensor
-        product.  If the type is `int`, it is promoted first to `[dimensions]`.
-        From there, it should be one of the two-elements `dims` parameter of a
-        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
-        products.
-
-    Returns
-    -------
-    size : int
-        Dimension of backing matrix required to represent operator.
-    dimensions : list
-        Dimension list in the form required by ``Qobj`` creation.
-    """
-    if not isinstance(dimensions, list):
-        dimensions = [dimensions]
-    flat = flatten(dimensions)
-    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
-        raise ValueError("All dimensions must be integers >= 0")
-    N = np.prod(flat)
-    if superoper:
-        if isinstance(dimensions[0], numbers.Integral):
-            dimensions = [dimensions, dimensions]
-        else:
-            N = int(N**0.5)
-    return N, [dimensions, dimensions]
-
-
-def _get_generator(seed):
-    """
-    Obtain a random generator from a seed or generator.
-
-    Parameters
-    ----------
-    seed: int, SeedSequence, Generator, NoneType
-        Seed to create the generator. If it's already a generator return it.
-        When ``None`` is suplied, a default generator is provided.
-    """
-    if seed is None:
-        gen = _RAND
-    elif isinstance(seed, Generator):
-        gen = seed
-    else:
-        gen = default_rng(seed)
-    return gen
-
-
-def _randnz(shape, generator, norm=np.sqrt(0.5)):
-    """
-    Returns an array of standard normal complex random variates.
-    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
-
-    Parameters
-    ----------
-    shape : tuple
-        Shape of the returned array of random variates.
-
-    generator : Generator
-        Random number generator.
-
-    norm : float
-        Scale of the returned random variates, or 'ginibre' to draw
-        from the Ginibre ensemble.
-    """
-    # This function is intended for internal use.
-    if norm == 'ginibre':
-        norm = 1
-    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
-
-
-def _rand_jacobi_rotation(A, generator):
-    """Random Jacobi rotation of a matrix.
-
-    Parameters
-    ----------
-    A : qutip.data.Data
-        Matrix to rotate as a data layer object.
-
-    generator : numpy.random.generator
-        Random number generator.
-
-    Returns
-    -------
-    qutip.data.Data
-        Rotated sparse matrix.
-    """
-    if A.shape[0] != A.shape[1]:
-        raise ValueError('Input matrix must be square.')
-    n = A.shape[0]
-    angle = 2 * generator.random() * np.pi
-    a = np.sqrt(0.5) * np.exp(-1j * angle)
-    b = np.conj(a)
-    i = generator.integers(n)
-    j = i
-    while i == j:
-        j = generator.integers(n)
-    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
-                      np.ones(n - 2, dtype=complex)))
-    diag = np.delete(np.arange(n), [i, j])
-    rows = np.hstack(([i, i, j, j], diag))
-    cols = np.hstack(([i, j, i, j], diag))
-    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
-    R = _data.create(R.tocsr())
-    return _data.matmul(_data.matmul(R, A), R.adjoint())
-
-
-def _get_block_sizes(N, density, generator):
-    """
-    Obtain a list of matrix block sizes in such a way that an NxN matrix
-    composed of full matrices of these sizes along the diagonal would be of
-    desired density.
-    """
-    if density <= 0:
-        return [1] * N
-    elif density >= 1:
-        return [N]
-    max_block_size = int((N**2 * density)**0.5)
-    min_block_size = 1
-    if density >= 0.5:
-        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
-
-    if min_block_size >= max_block_size:
-        M = min(min_block_size, max_block_size)
-    else:
-        M = generator.integers(min_block_size, max_block_size) + 1
-    M += generator.integers(-1, 2)
-    M = min(max(M, 1), N)
-
-    other_blocks = []
-    if M < N:
-        other_N = N - M
-        other_density = (density * N**2 - M**2) / other_N**2
-        other_blocks = _get_block_sizes(other_N, other_density, generator)
-
-    return [M] + other_blocks
-
-
-def _merge_shuffle_blocks(blocks, generator):
-    """
-    For a list of block, merge them in one matrix along the diagonal and
-    shuffle the rows and columns.
-    """
-    N = sum(block.shape[0] for block in blocks)
-    D = sum(block.shape[0]**2 for block in blocks) / N**2
-    idx = generator.permutation(N)
-    end = 0
-    if D < 0.1:
-        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
-        row = []
-        col = []
-        data = []
-        for block in blocks:
-            start = end
-            end = end + block.shape[0]
-            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
-            row.append(brow.ravel())
-            col.append(bcol.ravel())
-            data.append(block.ravel())
-        data = np.hstack(data)
-        row = np.hstack(row)
-        col = np.hstack(col)
-        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
-    else:
-        matrix = np.zeros((N,N), dtype=complex)
-        for block in blocks:
-            start = end
-            end = end + block.shape[0]
-            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
-            matrix[brow, bcol] = block
-    return _data.create(matrix, copy=False)
-
-
-def rand_herm(dimensions, density=0.30, distribution="fill", *,
-              eigenvalues=(), seed=None, dtype=None):
-    """Creates a random sparse Hermitian quantum object.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [0.30]
-        Density between [0,1] of output Hermitian operator.
-
-    distribution : str {"fill", "pos_def", "eigen"}
-        Method used to obtain the density matrices.
-
-        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
-          generated quantum operator with elements uniformly distributed
-          between ``[-1, 1] + [-1j, 1j]``.
-        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
-          random complex Jacobi rotations to shuffle the operator.
-        - "pos_def" : Return a positive semi-definite matrix by diagonal
-          dominance.
-
-    eigenvalues : array_like, optional
-        Eigenvalues of the output Hermitian matrix. The len must match the
-        shape of the matrix.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : :class:`qobj`
-        Hermitian quantum operator.
-
-    Notes
-    -----
-    If given a list of eigenvalues the object is created using complex Jacobi
-    rotations.  While this method is fast for small matrices, it should not be
-    repeatedly used for generating matrices larger than ~1000x1000.
-    """
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    generator = _get_generator(seed)
-    if distribution not in ["eigen", "fill", "pos_def"]:
-        raise ValueError("distribution must be one of {'eigen', 'fill', "
-                         "'pos_def'}")
-
-    if distribution == "eigen":
-        if N != len(eigenvalues):
-            raise ValueError("The number of eigenvalues does not match the "
-                             "desired shape.")
-        out = _data.diag[_data.CSR](eigenvalues, 0)
-        nvals = max([N**2 * density, 1])
-        out = _rand_jacobi_rotation(out, generator)
-        while _data.csr.nnz(out) < 0.95 * nvals:
-            out = _rand_jacobi_rotation(out, generator)
-        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
-        dtype = dtype or settings.core["default_dtype"] or _data.CSR
-
-    else:
-        pos_def = distribution == "pos_def"
-        if density < 0.5:
-            M = _rand_herm_sparse(N, density, pos_def, generator)
-            dtype = dtype or settings.core["default_dtype"] or _data.CSR
-        else:
-            M = _rand_herm_dense(N, density, pos_def, generator)
-            dtype = dtype or settings.core["default_dtype"] or _data.Dense
-
-        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
-
-    return out.to(dtype)
-
-
-def _rand_herm_sparse(N, density, pos_def, generator):
-    target = (1 - (1 - density)**0.5)
-    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
-    num_elems = max([num_elems, 1])
-    num_elems = int(num_elems)
-    data = (2 * generator.random(num_elems) - 1) + \
-           (2 * generator.random(num_elems) - 1) * 1j
-    row_idx, col_idx = zip(*[
-        divmod(index, N)
-        for index in generator.choice(N*N, num_elems, replace=False)
-    ])
-    M = sp.coo_matrix((data, (row_idx, col_idx)),
-                      dtype=complex, shape=(N, N))
-    M = 0.5 * (M + M.conj().transpose())
-    M.sort_indices()
-    rand_mat = _data.create(M)
-    if pos_def:
-        rand_mat = _data.add(
-            rand_mat,
-            _data.diag(np.ones(N, dtype=complex)),
-            np.sqrt(2) * N + 1
-        )
-    return rand_mat
-
-
-def _rand_herm_dense(N, density, pos_def, generator):
-    M = (
-        (2*generator.random((N, N)) - 1)
-        + 1j*(2*generator.random((N, N)) - 1)
-    )
-    M = 0.5 * (M + M.conj().transpose())
-    target = 1 - density**0.5
-    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
-    num_remove = max([num_remove, 1])
-    num_remove = int(num_remove)
-    for index in generator.choice(N*N, num_remove, replace=False):
-        row, col = divmod(index, N)
-        M[col, row] = 0
-        M[row, col] = 0
-    if pos_def:
-        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
-    return _data.create(M)
-
-
-def rand_unitary(dimensions, density=1, distribution="haar", *,
-                 seed=None, dtype=None):
-    r"""Creates a random sparse unitary quantum object.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [1]
-        Density between [0,1] of output unitary operator.
-
-    distribution : ["haar", "exp"]
-        Method used to obtain the unitary matrices.
-
-        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
-        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
-          Hermitian operator.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Unitary quantum operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    if distribution not in ["haar", "exp"]:
-        raise ValueError("distribution must be one of {'haar', 'exp'}")
-    generator = _get_generator(seed)
-    block_sizes = _get_block_sizes(N, density, generator)
-
-    blocks = []
-    for block in block_sizes:
-        if distribution == "haar":
-            mat = _rand_unitary_haar(block, generator)
-        elif distribution == "exp":
-            mat = scipy.linalg.expm(
-                -1.0j *
-                _rand_herm_dense(block, 1, False, generator).as_ndarray()
-            )
-        blocks.append(mat)
-
-    merged = _merge_shuffle_blocks(blocks, generator)
-
-    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
-    return mat.to(dtype)
-
-
-def _rand_unitary_haar(N, generator):
-    """
-    Returns a Haar random unitary matrix of dimension
-    ``dim``, using the algorithm of [Mez07]_.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of the unitary to be returned.
-
-    generator : numpy.random.generator
-        Random number generator.
-
-    Returns
-    -------
-    U : qutip.core.data.Dense
-        Unitary of shape ``(N, N)`` drawn from the Haar measure.
-    """
-    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
-    #               normal random variates.
-    Z = _randnz((N, N), generator)
-
-    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
-    Q, R = scipy.linalg.qr(Z)
-
-    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
-    #               the diagonal elements of R.
-    Lambda = np.diag(R).copy()
-    Lambda /= np.abs(Lambda)
-
-    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
-    #               strictly positive elements, such that
-    #               Q' = Q · Λ is Haar distributed.
-    # NOTE: Λ is a diagonal matrix, represented as a vector
-    #       of the diagonal entries. Thus, the matrix dot product
-    #       is represented nicely by the NumPy broadcasting of
-    #       the *scalar* multiplication. In particular,
-    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
-    #       As NumPy arrays, Q has shape (N, N) and
-    #       Lambda has shape (N, ), such that the broadcasting
-    #       represents precisely Q_ij λ_j.
-    return Q * Lambda
-
-
-def rand_ket(dimensions, density=1, distribution="haar", *,
-             seed=None, dtype=None):
-    """Creates a random ket vector.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [1]
-        Density between [0,1] of output ket state when using the ``fill``
-        method.
-
-    distribution : str {"haar", "fill"}
-        Method used to obtain the kets.
-
-        - haar : Haar random pure state obtained by applying a Haar random
-          unitary to a fixed pure state.
-        - fill : Fill the ket with uniformly distributed random complex number.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Ket quantum state vector.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    if distribution not in ["haar", "fill"]:
-        raise ValueError("distribution must be one of {'haar', 'fill'}")
-
-    if distribution == "haar":
-        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
-    else:
-        X = scipy.sparse.rand(N, 1, density, format='csr',
-                              random_state=generator)
-        while X.nnz == 0:
-            # ensure that the ket is not all zeros.
-            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
-                                  random_state=generator)
-        X.data = X.data - 0.5
-        Y = X.copy()
-        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
-        X = _data.csr.CSR(X + Y)
-        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
-                   copy=False, type="ket", isherm=False, isunitary=False)
-    ket.dims = [dims[0], [1]]
-    return ket.to(dtype)
-
-
-def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
-            eigenvalues=(), rank=None, seed=None,
-            dtype=None):
-    r"""Creates a random density matrix of the desired dimensions.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either ``oper`` or
-        ``super`` depending on the passed ``dimensions``.
-
-    density : float
-        Density between [0,1] of output density matrix. Used by the "pure",
-        "eigen" and "herm".
-
-    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
-        Method used to obtain the density matrices.
-
-        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
-          the algorithm of [BCSZ08]_.
-        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
-          operator.
-        - "pure" : Density matrix created from a random ket.
-        - "eigen" : A density matrix with the given ``eigenvalues``.
-        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
-
-    eigenvalues : array_like, optional
-        Eigenvalues of the output Hermitian matrix. The len must match the
-        shape of the matrix.
-
-    rank : int, optional
-        When using the "ginibre" distribution, rank of the density matrix.
-        Will default to a full rank operator when not provided.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Density matrix quantum operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
-    if distribution not in distributions:
-        raise ValueError(f"distribution must be one of {distributions}")
-
-    if distribution == "eigen":
-        if len(eigenvalues) != N:
-            raise ValueError("Number of eigenvalues does not match the shape.")
-        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
-            raise ValueError('Eigenvalues of a density matrix '
-                             f'must sum to one, not {np.sum(eigenvalues)}')
-        H = _data.diag(eigenvalues, 0)
-        nvals = N**2 * density
-        H = _rand_jacobi_rotation(H, generator)
-        while _data.csr.nnz(H) < 0.95*nvals:
-            H = _rand_jacobi_rotation(H, generator)
-    elif distribution == "ginibre":
-        H = _rand_dm_ginibre(N, rank, generator)
-    elif distribution == "hs":
-        H = _rand_dm_ginibre(N, N, generator)
-    elif distribution == "pure":
-        dm_density = np.sqrt(density)
-        psi = rand_ket(N, density=dm_density,
-                       distribution="fill", seed=generator)
-        H = psi.proj().data
-    elif distribution == "herm":
-        block_sizes = _get_block_sizes(N, density, generator)
-        blocks = []
-        first = True
-        for block in block_sizes:
-            if block != 1:
-                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
-            else:
-                mat = np.ones((1,1))
-                if not first:
-                    mat *= max(generator.random() - 0.5, 0)
-                first = False
-            blocks.append(mat.T.conj() @ mat)
-        H = _merge_shuffle_blocks(blocks, generator)
-        H /= H.trace()
-
-    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
-
-
-def _rand_dm_ginibre(N, rank, generator):
-    """
-    Returns a Ginibre random density operator of  rank ``rank`` by using the
-    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
-    (Hilbert-Schmidt ensemble) random density operator will be
-    returned.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of the density operator to be returned.
-
-    rank : int or None
-        Rank of the sampled density operator. If None, a full-rank
-        density operator is generated.
-
-    Returns
-    -------
-    rho : Qobj
-        An N × N density operator sampled from the Ginibre
-        or Hilbert-Schmidt distribution.
-    """
-    if not rank:
-        rank = N
-    if rank > N:
-        raise ValueError("Rank cannot exceed dimension.")
-
-    X = _randnz((N, rank), generator, norm='ginibre')
-    rho = np.dot(X, X.T.conj())
-    rho /= np.trace(rho)
-
-    return rho
-
-
-def rand_kraus_map(dimensions, *, seed=None,
-                   dtype=None):
-    """
-    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
-    form.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper_list : list of qobj
-        N^2 x N x N qobj operators.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    N, dims = _implicit_tensor_dimensions(dimensions)
-
-    # Random unitary (Stinespring Dilation)
-    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
-    orthog_cols = np.array(big_unitary[:, :N])
-    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
-    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
-            for x in oper_list]
-
-
-def rand_super(dimensions, *, superrep="super", seed=None,
-               dtype=None):
-    """
-    Returns a randomly drawn superoperator acting on operators acting on
-    N dimensions.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    superrop : str, optional, {"super"}
-        Representation of the super operator
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    from .solver.propagator import propagator
-    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
-    H = rand_herm(N, seed=generator, dtype=dtype)
-    S = propagator(H, generator.random(), [
-        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
-    ])
-    S.dims = dims
-    out = {
-            "choi" : to_choi,
-            "chi" : to_chi,
-            "super": to_super,
-        }[superrep](S).to(dtype)
-    return out
-
-
-def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
-                    superrep="super", seed=None,
-                    dtype=None):
-    """
-    Returns a random superoperator drawn from the Bruzda
-    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
-    finite numerical precision, for ranks less than full-rank,
-    zero eigenvalues may become slightly negative, such that the
-    returned operator is not actually completely positive.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If an int is provided, it is understood as
-        the Square root of the dimension of the superoperator to be returned,
-        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
-        as a list of ints, then the dimensions is understood as the space of
-        density matrices this superoperator is applied to: ``dimensions=[2,2]``
-        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
-
-    enforce_tp : bool
-        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
-        otherwise only complete positivity is enforced.
-
-    rank : int or None
-        Rank of the sampled superoperator. If None, a full-rank
-        superoperator is generated.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    superrop : str, optional, {"super"}
-        representation of the
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    rho : Qobj
-        A superoperator acting on vectorized dim × dim density operators,
-        sampled from the BCSZ distribution.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
-
-    if rank is None:
-        rank = N**2
-    if rank > N**2:
-        raise ValueError("Rank cannot exceed superoperator dimension.")
-
-    # We use mainly dense matrices here for speed in low
-    # dimensions. In the future, it would likely be better to switch off
-    # between sparse and dense matrices as the dimension grows.
-
-    # We start with a Ginibre uniform matrix X of the appropriate rank,
-    # and use it to construct a positive semidefinite matrix X X⁺.
-    X = _randnz((N**2, rank), generator, norm='ginibre')
-
-    # Precompute X X⁺, as we'll need it in two different places.
-    XXdag = np.dot(X, X.T.conj())
-    tmp_dims = [[[N], [N]], [[N], [N]]]
-
-    if enforce_tp:
-        # We do the partial trace over the first index by using dense reshape
-        # operations, so that we can avoid bouncing to a sparse representation
-        # and back.
-        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
-
-        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
-        # the square root and the inverse separately. As a possible
-        # improvement, iterative methods exist to find inverse square root
-        # matrices directly, as this is important in statistics.
-        Z = np.kron(
-            np.eye(N),
-            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
-        )
-
-        # Finally, we dot everything together and pack it into a Qobj,
-        # marking the dimensions as that of a type=super (that is,
-        # with left and right compound indices, each representing
-        # left and right indices on the underlying Hilbert space).
-        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
-    else:
-        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
-
-    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
-    # expects a column-stacking Choi matrix, we must permute the indices.
-    D = D.permute([[1], [0]])
-
-    # Mark that we've made a Choi matrix.
-    D.superrep = 'choi'
-    D.dims = dims
-    out = {
-            "choi" : to_choi,
-            "chi" : to_chi,
-            "super": to_super,
-        }[superrep](D).to(dtype)
-    return out
-
-
-def rand_stochastic(dimensions, density=0.75, kind='left',
-                    *, seed=None, dtype=None):
-    """Generates a random stochastic matrix.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [0.75]
-        Density between [0,1] of output density matrix.
-
-    kind : str (Default = 'left')
-        Generate 'left' or 'right' stochastic matrix.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Quantum operator form of stochastic matrix.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
-    data = generator.random(num_elems)
-    # Ensure an element on every row and column
-    row_idx = np.hstack([generator.permutation(N),
-                         generator.choice(N, num_elems-N)])
-    col_idx = np.hstack([generator.permutation(N),
-                         generator.choice(N, num_elems-N)])
-    M = sp.coo_matrix((data, (row_idx, col_idx)),
-                      dtype=np.complex128, shape=(N, N)).tocsr()
-    M = 0.5 * (M + M.conj().transpose())
-    num_rows = M.indptr.shape[0] - 1
-    for row in range(num_rows):
-        row_start = M.indptr[row]
-        row_end = M.indptr[row+1]
-        row_sum = np.sum(M.data[row_start:row_end])
-        M.data[row_start:row_end] /= row_sum
-    if kind == 'left':
-        M = M.transpose()
-    return Qobj(M, dims=dims).to(dtype)
+"""
+This module is a collection of random state and operator generators.
+"""
+
+__all__ = [
+    'rand_herm',
+    'rand_unitary',
+    'rand_dm',
+    'rand_stochastic',
+    'rand_ket',
+    'rand_kraus_map',
+    'rand_super',
+    "rand_super_bcsz",
+]
+
+import numbers
+
+import numpy as np
+from numpy.random import Generator, SeedSequence, default_rng
+import scipy.linalg
+import scipy.sparse as sp
+
+from . import (Qobj, create, destroy, jmat, basis,
+               to_super, to_choi, to_chi, to_kraus, to_stinespring)
+from .core import data as _data
+from .core.dimensions import flatten
+from . import settings
+
+
+_RAND = default_rng()
+_UNITS = np.array([1, 1j])
+
+
+def _implicit_tensor_dimensions(dimensions, superoper=False):
+    """
+    Total flattened size and operator dimensions for operator creation routines
+    that automatically perform tensor products.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        First dimension of an operator which can create an implicit tensor
+        product.  If the type is `int`, it is promoted first to `[dimensions]`.
+        From there, it should be one of the two-elements `dims` parameter of a
+        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
+        products.
+
+    Returns
+    -------
+    size : int
+        Dimension of backing matrix required to represent operator.
+    dimensions : list
+        Dimension list in the form required by ``Qobj`` creation.
+    """
+    if not isinstance(dimensions, list):
+        dimensions = [dimensions]
+    flat = flatten(dimensions)
+    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
+        raise ValueError("All dimensions must be integers >= 0")
+    N = np.prod(flat)
+    if superoper:
+        if isinstance(dimensions[0], numbers.Integral):
+            dimensions = [dimensions, dimensions]
+        else:
+            N = int(N**0.5)
+    return N, [dimensions, dimensions]
+
+
+def _get_generator(seed):
+    """
+    Obtain a random generator from a seed or generator.
+
+    Parameters
+    ----------
+    seed: int, SeedSequence, Generator, NoneType
+        Seed to create the generator. If it's already a generator return it.
+        When ``None`` is suplied, a default generator is provided.
+    """
+    if seed is None:
+        gen = _RAND
+    elif isinstance(seed, Generator):
+        gen = seed
+    else:
+        gen = default_rng(seed)
+    return gen
+
+
+def _randnz(shape, generator, norm=np.sqrt(0.5)):
+    """
+    Returns an array of standard normal complex random variates.
+    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
+
+    Parameters
+    ----------
+    shape : tuple
+        Shape of the returned array of random variates.
+
+    generator : Generator
+        Random number generator.
+
+    norm : float
+        Scale of the returned random variates, or 'ginibre' to draw
+        from the Ginibre ensemble.
+    """
+    # This function is intended for internal use.
+    if norm == 'ginibre':
+        norm = 1
+    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
+
+
+def _rand_jacobi_rotation(A, generator):
+    """Random Jacobi rotation of a matrix.
+
+    Parameters
+    ----------
+    A : qutip.data.Data
+        Matrix to rotate as a data layer object.
+
+    generator : numpy.random.generator
+        Random number generator.
+
+    Returns
+    -------
+    qutip.data.Data
+        Rotated sparse matrix.
+    """
+    if A.shape[0] != A.shape[1]:
+        raise ValueError('Input matrix must be square.')
+    n = A.shape[0]
+    angle = 2 * generator.random() * np.pi
+    a = np.sqrt(0.5) * np.exp(-1j * angle)
+    b = np.conj(a)
+    i = generator.integers(n)
+    j = i
+    while i == j:
+        j = generator.integers(n)
+    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
+                      np.ones(n - 2, dtype=complex)))
+    diag = np.delete(np.arange(n), [i, j])
+    rows = np.hstack(([i, i, j, j], diag))
+    cols = np.hstack(([i, j, i, j], diag))
+    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
+    R = _data.create(R.tocsr())
+    return _data.matmul(_data.matmul(R, A), R.adjoint())
+
+
+def _get_block_sizes(N, density, generator):
+    """
+    Obtain a list of matrix block sizes in such a way that an NxN matrix
+    composed of full matrices of these sizes along the diagonal would be of
+    desired density.
+    """
+    if density <= 0:
+        return [1] * N
+    elif density >= 1:
+        return [N]
+    max_block_size = int((N**2 * density)**0.5)
+    min_block_size = 1
+    if density >= 0.5:
+        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
+
+    if min_block_size >= max_block_size:
+        M = min(min_block_size, max_block_size)
+    else:
+        M = generator.integers(min_block_size, max_block_size) + 1
+    M += generator.integers(-1, 2)
+    M = min(max(M, 1), N)
+
+    other_blocks = []
+    if M < N:
+        other_N = N - M
+        other_density = (density * N**2 - M**2) / other_N**2
+        other_blocks = _get_block_sizes(other_N, other_density, generator)
+
+    return [M] + other_blocks
+
+
+def _merge_shuffle_blocks(blocks, generator):
+    """
+    For a list of block, merge them in one matrix along the diagonal and
+    shuffle the rows and columns.
+    """
+    N = sum(block.shape[0] for block in blocks)
+    D = sum(block.shape[0]**2 for block in blocks) / N**2
+    idx = generator.permutation(N)
+    end = 0
+    if D < 0.1:
+        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
+        row = []
+        col = []
+        data = []
+        for block in blocks:
+            start = end
+            end = end + block.shape[0]
+            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
+            row.append(brow.ravel())
+            col.append(bcol.ravel())
+            data.append(block.ravel())
+        data = np.hstack(data)
+        row = np.hstack(row)
+        col = np.hstack(col)
+        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
+    else:
+        matrix = np.zeros((N,N), dtype=complex)
+        for block in blocks:
+            start = end
+            end = end + block.shape[0]
+            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
+            matrix[brow, bcol] = block
+    return _data.create(matrix, copy=False)
+
+
+def rand_herm(dimensions, density=0.30, distribution="fill", *,
+              eigenvalues=(), seed=None, dtype=None):
+    """Creates a random sparse Hermitian quantum object.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [0.30]
+        Density between [0,1] of output Hermitian operator.
+
+    distribution : str {"fill", "pos_def", "eigen"}
+        Method used to obtain the density matrices.
+
+        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
+          generated quantum operator with elements uniformly distributed
+          between ``[-1, 1] + [-1j, 1j]``.
+        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
+          random complex Jacobi rotations to shuffle the operator.
+        - "pos_def" : Return a positive semi-definite matrix by diagonal
+          dominance.
+
+    eigenvalues : array_like, optional
+        Eigenvalues of the output Hermitian matrix. The len must match the
+        shape of the matrix.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : :class:`qobj`
+        Hermitian quantum operator.
+
+    Notes
+    -----
+    If given a list of eigenvalues the object is created using complex Jacobi
+    rotations.  While this method is fast for small matrices, it should not be
+    repeatedly used for generating matrices larger than ~1000x1000.
+    """
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    generator = _get_generator(seed)
+    if distribution not in ["eigen", "fill", "pos_def"]:
+        raise ValueError("distribution must be one of {'eigen', 'fill', "
+                         "'pos_def'}")
+
+    if distribution == "eigen":
+        if N != len(eigenvalues):
+            raise ValueError("The number of eigenvalues does not match the "
+                             "desired shape.")
+        out = _data.diag[_data.CSR](eigenvalues, 0)
+        nvals = max([N**2 * density, 1])
+        out = _rand_jacobi_rotation(out, generator)
+        while _data.csr.nnz(out) < 0.95 * nvals:
+            out = _rand_jacobi_rotation(out, generator)
+        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
+        dtype = dtype or settings.core["default_dtype"] or _data.CSR
+
+    else:
+        pos_def = distribution == "pos_def"
+        if density < 0.5:
+            M = _rand_herm_sparse(N, density, pos_def, generator)
+            dtype = dtype or settings.core["default_dtype"] or _data.CSR
+        else:
+            M = _rand_herm_dense(N, density, pos_def, generator)
+            dtype = dtype or settings.core["default_dtype"] or _data.Dense
+
+        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
+
+    return out.to(dtype)
+
+
+def _rand_herm_sparse(N, density, pos_def, generator):
+    target = (1 - (1 - density)**0.5)
+    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
+    num_elems = max([num_elems, 1])
+    num_elems = int(num_elems)
+    data = (2 * generator.random(num_elems) - 1) + \
+           (2 * generator.random(num_elems) - 1) * 1j
+    row_idx, col_idx = zip(*[
+        divmod(index, N)
+        for index in generator.choice(N*N, num_elems, replace=False)
+    ])
+    M = sp.coo_matrix((data, (row_idx, col_idx)),
+                      dtype=complex, shape=(N, N))
+    M = 0.5 * (M + M.conj().transpose())
+    M.sort_indices()
+    rand_mat = _data.create(M)
+    if pos_def:
+        rand_mat = _data.add(
+            rand_mat,
+            _data.diag(np.ones(N, dtype=complex)),
+            np.sqrt(2) * N + 1
+        )
+    return rand_mat
+
+
+def _rand_herm_dense(N, density, pos_def, generator):
+    M = (
+        (2*generator.random((N, N)) - 1)
+        + 1j*(2*generator.random((N, N)) - 1)
+    )
+    M = 0.5 * (M + M.conj().transpose())
+    target = 1 - density**0.5
+    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
+    num_remove = max([num_remove, 1])
+    num_remove = int(num_remove)
+    for index in generator.choice(N*N, num_remove, replace=False):
+        row, col = divmod(index, N)
+        M[col, row] = 0
+        M[row, col] = 0
+    if pos_def:
+        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
+    return _data.create(M)
+
+
+def rand_unitary(dimensions, density=1, distribution="haar", *,
+                 seed=None, dtype=None):
+    r"""Creates a random sparse unitary quantum object.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [1]
+        Density between [0,1] of output unitary operator.
+
+    distribution : ["haar", "exp"]
+        Method used to obtain the unitary matrices.
+
+        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
+        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
+          Hermitian operator.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Unitary quantum operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    if distribution not in ["haar", "exp"]:
+        raise ValueError("distribution must be one of {'haar', 'exp'}")
+    generator = _get_generator(seed)
+    block_sizes = _get_block_sizes(N, density, generator)
+
+    blocks = []
+    for block in block_sizes:
+        if distribution == "haar":
+            mat = _rand_unitary_haar(block, generator)
+        elif distribution == "exp":
+            mat = scipy.linalg.expm(
+                -1.0j *
+                _rand_herm_dense(block, 1, False, generator).as_ndarray()
+            )
+        blocks.append(mat)
+
+    merged = _merge_shuffle_blocks(blocks, generator)
+
+    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
+    return mat.to(dtype)
+
+
+def _rand_unitary_haar(N, generator):
+    """
+    Returns a Haar random unitary matrix of dimension
+    ``dim``, using the algorithm of [Mez07]_.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of the unitary to be returned.
+
+    generator : numpy.random.generator
+        Random number generator.
+
+    Returns
+    -------
+    U : qutip.core.data.Dense
+        Unitary of shape ``(N, N)`` drawn from the Haar measure.
+    """
+    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
+    #               normal random variates.
+    Z = _randnz((N, N), generator)
+
+    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
+    Q, R = scipy.linalg.qr(Z)
+
+    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
+    #               the diagonal elements of R.
+    Lambda = np.diag(R).copy()
+    Lambda /= np.abs(Lambda)
+
+    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
+    #               strictly positive elements, such that
+    #               Q' = Q · Λ is Haar distributed.
+    # NOTE: Λ is a diagonal matrix, represented as a vector
+    #       of the diagonal entries. Thus, the matrix dot product
+    #       is represented nicely by the NumPy broadcasting of
+    #       the *scalar* multiplication. In particular,
+    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
+    #       As NumPy arrays, Q has shape (N, N) and
+    #       Lambda has shape (N, ), such that the broadcasting
+    #       represents precisely Q_ij λ_j.
+    return Q * Lambda
+
+
+def rand_ket(dimensions, density=1, distribution="haar", *,
+             seed=None, dtype=None):
+    """Creates a random ket vector.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [1]
+        Density between [0,1] of output ket state when using the ``fill``
+        method.
+
+    distribution : str {"haar", "fill"}
+        Method used to obtain the kets.
+
+        - haar : Haar random pure state obtained by applying a Haar random
+          unitary to a fixed pure state.
+        - fill : Fill the ket with uniformly distributed random complex number.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Ket quantum state vector.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    if distribution not in ["haar", "fill"]:
+        raise ValueError("distribution must be one of {'haar', 'fill'}")
+
+    if distribution == "haar":
+        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
+    else:
+        X = scipy.sparse.rand(N, 1, density, format='csr',
+                              random_state=generator)
+        while X.nnz == 0:
+            # ensure that the ket is not all zeros.
+            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
+                                  random_state=generator)
+        X.data = X.data - 0.5
+        Y = X.copy()
+        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
+        X = _data.csr.CSR(X + Y)
+        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
+                   copy=False, type="ket", isherm=False, isunitary=False)
+    ket.dims = [dims[0], [1]]
+    return ket.to(dtype)
+
+
+def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
+            eigenvalues=(), rank=None, seed=None,
+            dtype=None):
+    r"""Creates a random density matrix of the desired dimensions.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either ``oper`` or
+        ``super`` depending on the passed ``dimensions``.
+
+    density : float
+        Density between [0,1] of output density matrix. Used by the "pure",
+        "eigen" and "herm".
+
+    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
+        Method used to obtain the density matrices.
+
+        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
+          the algorithm of [BCSZ08]_.
+        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
+          operator.
+        - "pure" : Density matrix created from a random ket.
+        - "eigen" : A density matrix with the given ``eigenvalues``.
+        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
+
+    eigenvalues : array_like, optional
+        Eigenvalues of the output Hermitian matrix. The len must match the
+        shape of the matrix.
+
+    rank : int, optional
+        When using the "ginibre" distribution, rank of the density matrix.
+        Will default to a full rank operator when not provided.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Density matrix quantum operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
+    if distribution not in distributions:
+        raise ValueError(f"distribution must be one of {distributions}")
+
+    if distribution == "eigen":
+        if len(eigenvalues) != N:
+            raise ValueError("Number of eigenvalues does not match the shape.")
+        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
+            raise ValueError('Eigenvalues of a density matrix '
+                             f'must sum to one, not {np.sum(eigenvalues)}')
+        H = _data.diag(eigenvalues, 0)
+        nvals = N**2 * density
+        H = _rand_jacobi_rotation(H, generator)
+        while _data.csr.nnz(H) < 0.95*nvals:
+            H = _rand_jacobi_rotation(H, generator)
+    elif distribution == "ginibre":
+        H = _rand_dm_ginibre(N, rank, generator)
+    elif distribution == "hs":
+        H = _rand_dm_ginibre(N, N, generator)
+    elif distribution == "pure":
+        dm_density = np.sqrt(density)
+        psi = rand_ket(N, density=dm_density,
+                       distribution="fill", seed=generator)
+        H = psi.proj().data
+    elif distribution == "herm":
+        block_sizes = _get_block_sizes(N, density, generator)
+        blocks = []
+        first = True
+        for block in block_sizes:
+            if block != 1:
+                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
+            else:
+                mat = np.ones((1,1))
+                if not first:
+                    mat *= max(generator.random() - 0.5, 0)
+                first = False
+            blocks.append(mat.T.conj() @ mat)
+        H = _merge_shuffle_blocks(blocks, generator)
+        H /= H.trace()
+
+    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
+
+
+def _rand_dm_ginibre(N, rank, generator):
+    """
+    Returns a Ginibre random density operator of  rank ``rank`` by using the
+    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
+    (Hilbert-Schmidt ensemble) random density operator will be
+    returned.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of the density operator to be returned.
+
+    rank : int or None
+        Rank of the sampled density operator. If None, a full-rank
+        density operator is generated.
+
+    Returns
+    -------
+    rho : Qobj
+        An N × N density operator sampled from the Ginibre
+        or Hilbert-Schmidt distribution.
+    """
+    if not rank:
+        rank = N
+    if rank > N:
+        raise ValueError("Rank cannot exceed dimension.")
+
+    X = _randnz((N, rank), generator, norm='ginibre')
+    rho = np.dot(X, X.T.conj())
+    rho /= np.trace(rho)
+
+    return rho
+
+
+def rand_kraus_map(dimensions, *, seed=None,
+                   dtype=None):
+    """
+    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
+    form.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper_list : list of qobj
+        N^2 x N x N qobj operators.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    N, dims = _implicit_tensor_dimensions(dimensions)
+
+    # Random unitary (Stinespring Dilation)
+    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
+    orthog_cols = np.array(big_unitary[:, :N])
+    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
+    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
+            for x in oper_list]
+
+
+def rand_super(dimensions, *, superrep="super", seed=None,
+               dtype=None):
+    """
+    Returns a randomly drawn superoperator acting on operators acting on
+    N dimensions.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    superrop : str, optional, {"super"}
+        Representation of the super operator
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    from .solver.propagator import propagator
+    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
+    H = rand_herm(N, seed=generator, dtype=dtype)
+    S = propagator(H, generator.random(), [
+        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
+    ])
+    S.dims = dims
+    out = {
+            "choi" : to_choi,
+            "chi" : to_chi,
+            "super": to_super,
+        }[superrep](S).to(dtype)
+    return out
+
+
+def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
+                    superrep="super", seed=None,
+                    dtype=None):
+    """
+    Returns a random superoperator drawn from the Bruzda
+    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
+    finite numerical precision, for ranks less than full-rank,
+    zero eigenvalues may become slightly negative, such that the
+    returned operator is not actually completely positive.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If an int is provided, it is understood as
+        the Square root of the dimension of the superoperator to be returned,
+        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
+        as a list of ints, then the dimensions is understood as the space of
+        density matrices this superoperator is applied to: ``dimensions=[2,2]``
+        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
+
+    enforce_tp : bool
+        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
+        otherwise only complete positivity is enforced.
+
+    rank : int or None
+        Rank of the sampled superoperator. If None, a full-rank
+        superoperator is generated.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    superrop : str, optional, {"super"}
+        representation of the
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    rho : Qobj
+        A superoperator acting on vectorized dim × dim density operators,
+        sampled from the BCSZ distribution.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
+
+    if rank is None:
+        rank = N**2
+    if rank > N**2:
+        raise ValueError("Rank cannot exceed superoperator dimension.")
+
+    # We use mainly dense matrices here for speed in low
+    # dimensions. In the future, it would likely be better to switch off
+    # between sparse and dense matrices as the dimension grows.
+
+    # We start with a Ginibre uniform matrix X of the appropriate rank,
+    # and use it to construct a positive semidefinite matrix X X⁺.
+    X = _randnz((N**2, rank), generator, norm='ginibre')
+
+    # Precompute X X⁺, as we'll need it in two different places.
+    XXdag = np.dot(X, X.T.conj())
+    tmp_dims = [[[N], [N]], [[N], [N]]]
+
+    if enforce_tp:
+        # We do the partial trace over the first index by using dense reshape
+        # operations, so that we can avoid bouncing to a sparse representation
+        # and back.
+        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
+
+        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
+        # the square root and the inverse separately. As a possible
+        # improvement, iterative methods exist to find inverse square root
+        # matrices directly, as this is important in statistics.
+        Z = np.kron(
+            np.eye(N),
+            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
+        )
+
+        # Finally, we dot everything together and pack it into a Qobj,
+        # marking the dimensions as that of a type=super (that is,
+        # with left and right compound indices, each representing
+        # left and right indices on the underlying Hilbert space).
+        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
+    else:
+        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
+
+    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
+    # expects a column-stacking Choi matrix, we must permute the indices.
+    D = D.permute([[1], [0]])
+
+    # Mark that we've made a Choi matrix.
+    D.superrep = 'choi'
+    D.dims = dims
+    out = {
+            "choi" : to_choi,
+            "chi" : to_chi,
+            "super": to_super,
+        }[superrep](D).to(dtype)
+    return out
+
+
+def rand_stochastic(dimensions, density=0.75, kind='left',
+                    *, seed=None, dtype=None):
+    """Generates a random stochastic matrix.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [0.75]
+        Density between [0,1] of output density matrix.
+
+    kind : str (Default = 'left')
+        Generate 'left' or 'right' stochastic matrix.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Quantum operator form of stochastic matrix.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
+    data = generator.random(num_elems)
+    # Ensure an element on every row and column
+    row_idx = np.hstack([generator.permutation(N),
+                         generator.choice(N, num_elems-N)])
+    col_idx = np.hstack([generator.permutation(N),
+                         generator.choice(N, num_elems-N)])
+    M = sp.coo_matrix((data, (row_idx, col_idx)),
+                      dtype=np.complex128, shape=(N, N)).tocsr()
+    M = 0.5 * (M + M.conj().transpose())
+    num_rows = M.indptr.shape[0] - 1
+    for row in range(num_rows):
+        row_start = M.indptr[row]
+        row_end = M.indptr[row+1]
+        row_sum = np.sum(M.data[row_start:row_end])
+        M.data[row_start:row_end] /= row_sum
+    if kind == 'left':
+        M = M.transpose()
+    return Qobj(M, dims=dims).to(dtype)
diff --git a/qutip/settings.py b/qutip/settings.py
index 29ee053b75..ccf303714a 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -1,293 +1,293 @@
-"""
-This module contains settings for the QuTiP graphics, multiprocessing, and
-tidyup functionality, etc.
-"""
-import os
-import sys
-from ctypes import cdll
-import platform
-import numpy as np
-
-__all__ = ['settings']
-
-
-def _blas_info():
-    config = np.__config__
-    if hasattr(config, 'blas_ilp64_opt_info'):
-        blas_info = config.blas_ilp64_opt_info
-    elif hasattr(config, 'blas_opt_info'):
-        blas_info = config.blas_opt_info
-    else:
-        blas_info = {}
-
-    def _in_libaries(name):
-        return any(name in lib for lib in blas_info.get('libraries', []))
-
-    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
-        blas = 'INTEL MKL'
-    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
-        blas = 'OPENBLAS'
-    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
-        blas = 'Accelerate'
-    else:
-        blas = 'Generic'
-    return blas
-
-
-def available_cpu_count():
-    """
-    Get the number of cpus.
-    It tries to only get the number available to qutip.
-    """
-    import os
-    import multiprocessing
-    try:
-        import psutil
-    except ImportError:
-        psutil = None
-    num_cpu = 0
-
-    if 'QUTIP_NUM_PROCESSES' in os.environ:
-        # We consider QUTIP_NUM_PROCESSES=0 as unset.
-        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
-
-    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
-        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
-
-    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
-        num_cpu = len(os.sched_getaffinity(0))
-
-    if (
-        num_cpu == 0
-        and psutil is not None
-        and hasattr(psutil.Process(), "cpu_affinity")
-    ):
-        num_cpu = len(psutil.Process().cpu_affinity())
-
-    if num_cpu == 0:
-        try:
-            num_cpu = multiprocessing.cpu_count()
-        except NotImplementedError:
-            pass
-
-    return num_cpu or 1
-
-
-def _find_mkl():
-    """
-    Finds the MKL runtime library for the Anaconda and Intel Python
-    distributions.
-    """
-    mkl_lib = None
-    if _blas_info() == 'INTEL MKL':
-        plat = sys.platform
-        python_dir = os.path.dirname(sys.executable)
-        if plat in ['darwin', 'linux2', 'linux']:
-            python_dir = os.path.dirname(python_dir)
-
-        if plat == 'darwin':
-            lib = '/libmkl_rt.dylib'
-        elif plat == 'win32':
-            lib = r'\mkl_rt.dll'
-        elif plat in ['linux2', 'linux']:
-            lib = '/libmkl_rt.so'
-        else:
-            raise Exception('Unknown platfrom.')
-
-        if plat in ['darwin', 'linux2', 'linux']:
-            lib_dir = '/lib'
-        else:
-            lib_dir = r'\Library\bin'
-        # Try in default Anaconda location first
-        try:
-            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
-        except Exception:
-            pass
-
-        # Look in Intel Python distro location
-        if mkl_lib is None:
-            if plat in ['darwin', 'linux2', 'linux']:
-                lib_dir = '/ext/lib'
-            else:
-                lib_dir = r'\ext\lib'
-            try:
-                mkl_lib = \
-                    cdll.LoadLibrary(python_dir + lib_dir + lib)
-            except Exception:
-                pass
-    return mkl_lib
-
-
-class Settings:
-    """
-    Qutip's settings and options.
-    """
-    def __init__(self):
-        self._mkl_lib = ""
-        try:
-            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
-        except OSError:
-            self._tmproot = "."
-        self.core = None  # set in qutip.core.options
-        self.compile = None  # set in qutip.core.coefficient
-        self._debug = False
-        self._log_handler = "default"
-        self._colorblind_safe = False
-
-    @property
-    def has_mkl(self):
-        """ Whether qutip found an mkl installation. """
-        return self.mkl_lib is not None
-
-    @property
-    def mkl_lib(self):
-        """ Location of the mkl installation. """
-        if self._mkl_lib == "":
-            self._mkl_lib = _find_mkl()
-        return _find_mkl()
-
-    @property
-    def ipython(self):
-        """ Whether qutip is running in ipython. """
-        try:
-            __IPYTHON__
-            return True
-        except NameError:
-            return False
-
-    @property
-    def eigh_unsafe(self):
-        """
-        Whether `eigh` call is reliable.
-        Some implementation of blas have some issues on some OS.
-        """
-        from packaging import version as pac_version
-        import scipy
-        is_old_scipy = (
-            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
-        )
-        return (
-            # macOS OpenBLAS eigh is unstable, see #1288
-            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
-            # The combination of scipy<1.5 and MKL causes wrong results when
-            # calling eigh for big matrices.  See #1495, #1491 and #1498.
-            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
-        )
-
-    @property
-    def tmproot(self):
-        """
-        Location in which qutip place cython string coefficient folders.
-        The default is "$HOME/.qutip".
-        Can be updated.
-        """
-        return self._tmproot
-
-    @tmproot.setter
-    def tmproot(self, root):
-        if not os.path.exists(root):
-            os.mkdir(root)
-        self._tmproot = root
-
-    @property
-    def coeffroot(self):
-        """
-        Location in which qutip save cython string coefficient files.
-        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
-        Can be updated.
-        """
-        return self._coeffroot
-
-    @coeffroot.setter
-    def coeffroot(self, root):
-        if not os.path.exists(root):
-            os.mkdir(root)
-        if root not in sys.path:
-            sys.path.insert(0, root)
-        self._coeffroot = root
-
-    @property
-    def coeff_write_ok(self):
-        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
-        return os.access(self.coeffroot, os.W_OK)
-
-    @property
-    def has_openmp(self):
-        return False
-        # We keep this as a reminder for when openmp is restored: see Pull #652
-        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-
-    @property
-    def idxint_size(self):
-        """
-        Integer type used by ``CSR`` data.
-        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
-        non-zeros elements.
-        """
-        from .core import data
-        return data.base.idxint_size
-
-    @property
-    def num_cpus(self):
-        """
-        Number of cpu detected.
-        Use the solver options to control the number of cpus used.
-        """
-        if 'QUTIP_NUM_PROCESSES' in os.environ:
-            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
-        else:
-            num_cpus = available_cpu_count()
-            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
-        return num_cpus
-
-    @property
-    def debug(self):
-        """
-        Debug mode for development.
-        """
-        return self._debug
-
-    @debug.setter
-    def debug(self, value):
-        self._debug = value
-
-    @property
-    def log_handler(self):
-        """
-        Define whether log handler should be:
-        - default: switch based on IPython detection
-        - stream: set up non-propagating StreamHandler
-        - basic: call basicConfig
-        - null: leave logging to the user
-        """
-        return self._log_handler
-
-    @log_handler.setter
-    def log_handler(self, value):
-        self._log_handler = value
-
-    @property
-    def colorblind_safe(self):
-        """
-        Allow for a colorblind mode that uses different colormaps
-        and plotting options by default.
-        """
-        return self._colorblind_safe
-
-    @colorblind_safe.setter
-    def colorblind_safe(self, value):
-        self._colorblind_safe = value
-
-    def __str__(self):
-        lines = ["Qutip settings:"]
-        for attr in self.__dir__():
-            if not attr.startswith('_') and attr not in ["core", "compile"]:
-                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
-        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
-        return '\n'.join(lines)
-
-    def __repr__(self):
-        return self.__str__()
-
-
-settings = Settings()
+"""
+This module contains settings for the QuTiP graphics, multiprocessing, and
+tidyup functionality, etc.
+"""
+import os
+import sys
+from ctypes import cdll
+import platform
+import numpy as np
+
+__all__ = ['settings']
+
+
+def _blas_info():
+    config = np.__config__
+    if hasattr(config, 'blas_ilp64_opt_info'):
+        blas_info = config.blas_ilp64_opt_info
+    elif hasattr(config, 'blas_opt_info'):
+        blas_info = config.blas_opt_info
+    else:
+        blas_info = {}
+
+    def _in_libaries(name):
+        return any(name in lib for lib in blas_info.get('libraries', []))
+
+    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
+        blas = 'INTEL MKL'
+    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
+        blas = 'OPENBLAS'
+    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
+        blas = 'Accelerate'
+    else:
+        blas = 'Generic'
+    return blas
+
+
+def available_cpu_count():
+    """
+    Get the number of cpus.
+    It tries to only get the number available to qutip.
+    """
+    import os
+    import multiprocessing
+    try:
+        import psutil
+    except ImportError:
+        psutil = None
+    num_cpu = 0
+
+    if 'QUTIP_NUM_PROCESSES' in os.environ:
+        # We consider QUTIP_NUM_PROCESSES=0 as unset.
+        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
+
+    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
+        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
+
+    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
+        num_cpu = len(os.sched_getaffinity(0))
+
+    if (
+        num_cpu == 0
+        and psutil is not None
+        and hasattr(psutil.Process(), "cpu_affinity")
+    ):
+        num_cpu = len(psutil.Process().cpu_affinity())
+
+    if num_cpu == 0:
+        try:
+            num_cpu = multiprocessing.cpu_count()
+        except NotImplementedError:
+            pass
+
+    return num_cpu or 1
+
+
+def _find_mkl():
+    """
+    Finds the MKL runtime library for the Anaconda and Intel Python
+    distributions.
+    """
+    mkl_lib = None
+    if _blas_info() == 'INTEL MKL':
+        plat = sys.platform
+        python_dir = os.path.dirname(sys.executable)
+        if plat in ['darwin', 'linux2', 'linux']:
+            python_dir = os.path.dirname(python_dir)
+
+        if plat == 'darwin':
+            lib = '/libmkl_rt.dylib'
+        elif plat == 'win32':
+            lib = r'\mkl_rt.dll'
+        elif plat in ['linux2', 'linux']:
+            lib = '/libmkl_rt.so'
+        else:
+            raise Exception('Unknown platfrom.')
+
+        if plat in ['darwin', 'linux2', 'linux']:
+            lib_dir = '/lib'
+        else:
+            lib_dir = r'\Library\bin'
+        # Try in default Anaconda location first
+        try:
+            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
+        except Exception:
+            pass
+
+        # Look in Intel Python distro location
+        if mkl_lib is None:
+            if plat in ['darwin', 'linux2', 'linux']:
+                lib_dir = '/ext/lib'
+            else:
+                lib_dir = r'\ext\lib'
+            try:
+                mkl_lib = \
+                    cdll.LoadLibrary(python_dir + lib_dir + lib)
+            except Exception:
+                pass
+    return mkl_lib
+
+
+class Settings:
+    """
+    Qutip's settings and options.
+    """
+    def __init__(self):
+        self._mkl_lib = ""
+        try:
+            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
+        except OSError:
+            self._tmproot = "."
+        self.core = None  # set in qutip.core.options
+        self.compile = None  # set in qutip.core.coefficient
+        self._debug = False
+        self._log_handler = "default"
+        self._colorblind_safe = False
+
+    @property
+    def has_mkl(self):
+        """ Whether qutip found an mkl installation. """
+        return self.mkl_lib is not None
+
+    @property
+    def mkl_lib(self):
+        """ Location of the mkl installation. """
+        if self._mkl_lib == "":
+            self._mkl_lib = _find_mkl()
+        return _find_mkl()
+
+    @property
+    def ipython(self):
+        """ Whether qutip is running in ipython. """
+        try:
+            __IPYTHON__
+            return True
+        except NameError:
+            return False
+
+    @property
+    def eigh_unsafe(self):
+        """
+        Whether `eigh` call is reliable.
+        Some implementation of blas have some issues on some OS.
+        """
+        from packaging import version as pac_version
+        import scipy
+        is_old_scipy = (
+            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
+        )
+        return (
+            # macOS OpenBLAS eigh is unstable, see #1288
+            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
+            # The combination of scipy<1.5 and MKL causes wrong results when
+            # calling eigh for big matrices.  See #1495, #1491 and #1498.
+            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
+        )
+
+    @property
+    def tmproot(self):
+        """
+        Location in which qutip place cython string coefficient folders.
+        The default is "$HOME/.qutip".
+        Can be updated.
+        """
+        return self._tmproot
+
+    @tmproot.setter
+    def tmproot(self, root):
+        if not os.path.exists(root):
+            os.mkdir(root)
+        self._tmproot = root
+
+    @property
+    def coeffroot(self):
+        """
+        Location in which qutip save cython string coefficient files.
+        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
+        Can be updated.
+        """
+        return self._coeffroot
+
+    @coeffroot.setter
+    def coeffroot(self, root):
+        if not os.path.exists(root):
+            os.mkdir(root)
+        if root not in sys.path:
+            sys.path.insert(0, root)
+        self._coeffroot = root
+
+    @property
+    def coeff_write_ok(self):
+        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
+        return os.access(self.coeffroot, os.W_OK)
+
+    @property
+    def has_openmp(self):
+        return False
+        # We keep this as a reminder for when openmp is restored: see Pull #652
+        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+
+    @property
+    def idxint_size(self):
+        """
+        Integer type used by ``CSR`` data.
+        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
+        non-zeros elements.
+        """
+        from .core import data
+        return data.base.idxint_size
+
+    @property
+    def num_cpus(self):
+        """
+        Number of cpu detected.
+        Use the solver options to control the number of cpus used.
+        """
+        if 'QUTIP_NUM_PROCESSES' in os.environ:
+            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
+        else:
+            num_cpus = available_cpu_count()
+            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
+        return num_cpus
+
+    @property
+    def debug(self):
+        """
+        Debug mode for development.
+        """
+        return self._debug
+
+    @debug.setter
+    def debug(self, value):
+        self._debug = value
+
+    @property
+    def log_handler(self):
+        """
+        Define whether log handler should be:
+        - default: switch based on IPython detection
+        - stream: set up non-propagating StreamHandler
+        - basic: call basicConfig
+        - null: leave logging to the user
+        """
+        return self._log_handler
+
+    @log_handler.setter
+    def log_handler(self, value):
+        self._log_handler = value
+
+    @property
+    def colorblind_safe(self):
+        """
+        Allow for a colorblind mode that uses different colormaps
+        and plotting options by default.
+        """
+        return self._colorblind_safe
+
+    @colorblind_safe.setter
+    def colorblind_safe(self, value):
+        self._colorblind_safe = value
+
+    def __str__(self):
+        lines = ["Qutip settings:"]
+        for attr in self.__dir__():
+            if not attr.startswith('_') and attr not in ["core", "compile"]:
+                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
+        return '\n'.join(lines)
+
+    def __repr__(self):
+        return self.__str__()
+
+
+settings = Settings()
diff --git a/qutip/simdiag.py b/qutip/simdiag.py
index 370ade6552..a0105eee5d 100644
--- a/qutip/simdiag.py
+++ b/qutip/simdiag.py
@@ -1,120 +1,120 @@
-__all__ = ['simdiag']
-
-import numpy as np
-import scipy.linalg as la
-from . import Qobj
-from .core import data as _data
-
-
-def _degen(tol, vecs, ops, i=0):
-    """
-    Private function that finds eigen vals and vecs for degenerate matrices..
-    """
-    if len(ops) == i:
-        return vecs
-
-    # New eigenvectors are sometime not orthogonal.
-    for j in range(1, vecs.shape[1]):
-        for k in range(j):
-            dot = vecs[:, j].dot(vecs[:, k].conj())
-            if np.abs(dot) > tol:
-                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
-                              / (1 - np.abs(dot)**2)**0.5)
-
-    subspace = vecs.conj().T @ ops[i].full() @ vecs
-    eigvals, eigvecs = la.eig(subspace)
-
-    perm = np.argsort(eigvals)
-    eigvals = eigvals[perm]
-
-    vecs_new = vecs @ eigvecs[:, perm]
-    for k in range(len(eigvals)):
-        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
-
-    k = 0
-    while k < len(eigvals):
-        ttol = max(tol, tol * abs(eigvals[k]))
-        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
-        if len(inds) > 1:  # if at least 2 eigvals are degenerate
-            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
-        k = inds[-1] + 1
-    return vecs_new
-
-
-def simdiag(ops, evals: bool = True, *,
-            tol: float = 1e-14, safe_mode: bool = True):
-    """Simultaneous diagonalization of commuting Hermitian matrices.
-
-    Parameters
-    ----------
-    ops : list/array
-        ``list`` or ``array`` of qobjs representing commuting Hermitian
-        operators.
-
-    evals : bool [True]
-        Whether to return the eigenvalues for each ops and eigenvectors or just
-        the eigenvectors.
-
-    tol : float [1e-14]
-        Tolerance for detecting degenerate eigenstates.
-
-    safe_mode : bool [True]
-        Whether to check that all ops are Hermitian and commuting. If set to
-        ``False`` and operators are not commuting, the eigenvectors returned
-        will often be eigenvectors of only the first operator.
-
-    Returns
-    --------
-    eigs : tuple
-        Tuple of arrays representing eigvecs and eigvals of quantum objects
-        corresponding to simultaneous eigenvectors and eigenvalues for each
-        operator.
-
-    """
-    if not ops:
-        raise ValueError("No input matrices.")
-    N = ops[0].shape[0]
-    num_ops = len(ops) if safe_mode else 0
-    for jj in range(num_ops):
-        A = ops[jj]
-        shape = A.shape
-        if shape[0] != shape[1]:
-            raise TypeError('Matricies must be square.')
-        if shape[0] != N:
-            raise TypeError('All matrices. must be the same shape')
-        if not A.isherm:
-            raise TypeError('Matricies must be Hermitian')
-        for kk in range(jj):
-            B = ops[kk]
-            if (A * B - B * A).norm() / (A * B).norm() > tol:
-                raise TypeError('Matricies must commute.')
-
-    # TODO: rewrite using Data object
-    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
-    eigvecs = eigvecs.to_array()
-
-    k = 0
-    while k < N:
-        # find degenerate eigenvalues, get indicies of degenerate eigvals
-        ttol = max(tol, tol * abs(eigvals[k]))
-        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
-        if len(inds) > 1:  # if at least 2 eigvals are degenerate
-            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
-        k = inds[-1] + 1
-
-    for k in range(N):
-        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
-
-    kets_out = [
-        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
-        for j in range(N)
-    ]
-    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
-    if not evals:
-        return kets_out
-    else:
-        for kk in range(len(ops)):
-            for j in range(N):
-                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
-                                                            kets_out[j]).real
-        return eigvals_out, kets_out
+__all__ = ['simdiag']
+
+import numpy as np
+import scipy.linalg as la
+from . import Qobj
+from .core import data as _data
+
+
+def _degen(tol, vecs, ops, i=0):
+    """
+    Private function that finds eigen vals and vecs for degenerate matrices..
+    """
+    if len(ops) == i:
+        return vecs
+
+    # New eigenvectors are sometime not orthogonal.
+    for j in range(1, vecs.shape[1]):
+        for k in range(j):
+            dot = vecs[:, j].dot(vecs[:, k].conj())
+            if np.abs(dot) > tol:
+                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
+                              / (1 - np.abs(dot)**2)**0.5)
+
+    subspace = vecs.conj().T @ ops[i].full() @ vecs
+    eigvals, eigvecs = la.eig(subspace)
+
+    perm = np.argsort(eigvals)
+    eigvals = eigvals[perm]
+
+    vecs_new = vecs @ eigvecs[:, perm]
+    for k in range(len(eigvals)):
+        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
+
+    k = 0
+    while k < len(eigvals):
+        ttol = max(tol, tol * abs(eigvals[k]))
+        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
+        if len(inds) > 1:  # if at least 2 eigvals are degenerate
+            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
+        k = inds[-1] + 1
+    return vecs_new
+
+
+def simdiag(ops, evals: bool = True, *,
+            tol: float = 1e-14, safe_mode: bool = True):
+    """Simultaneous diagonalization of commuting Hermitian matrices.
+
+    Parameters
+    ----------
+    ops : list/array
+        ``list`` or ``array`` of qobjs representing commuting Hermitian
+        operators.
+
+    evals : bool [True]
+        Whether to return the eigenvalues for each ops and eigenvectors or just
+        the eigenvectors.
+
+    tol : float [1e-14]
+        Tolerance for detecting degenerate eigenstates.
+
+    safe_mode : bool [True]
+        Whether to check that all ops are Hermitian and commuting. If set to
+        ``False`` and operators are not commuting, the eigenvectors returned
+        will often be eigenvectors of only the first operator.
+
+    Returns
+    --------
+    eigs : tuple
+        Tuple of arrays representing eigvecs and eigvals of quantum objects
+        corresponding to simultaneous eigenvectors and eigenvalues for each
+        operator.
+
+    """
+    if not ops:
+        raise ValueError("No input matrices.")
+    N = ops[0].shape[0]
+    num_ops = len(ops) if safe_mode else 0
+    for jj in range(num_ops):
+        A = ops[jj]
+        shape = A.shape
+        if shape[0] != shape[1]:
+            raise TypeError('Matricies must be square.')
+        if shape[0] != N:
+            raise TypeError('All matrices. must be the same shape')
+        if not A.isherm:
+            raise TypeError('Matricies must be Hermitian')
+        for kk in range(jj):
+            B = ops[kk]
+            if (A * B - B * A).norm() / (A * B).norm() > tol:
+                raise TypeError('Matricies must commute.')
+
+    # TODO: rewrite using Data object
+    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
+    eigvecs = eigvecs.to_array()
+
+    k = 0
+    while k < N:
+        # find degenerate eigenvalues, get indicies of degenerate eigvals
+        ttol = max(tol, tol * abs(eigvals[k]))
+        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
+        if len(inds) > 1:  # if at least 2 eigvals are degenerate
+            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
+        k = inds[-1] + 1
+
+    for k in range(N):
+        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
+
+    kets_out = [
+        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
+        for j in range(N)
+    ]
+    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
+    if not evals:
+        return kets_out
+    else:
+        for kk in range(len(ops)):
+            for j in range(N):
+                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
+                                                            kets_out[j]).real
+        return eigvals_out, kets_out
diff --git a/qutip/solve/_piqs.pyx b/qutip/solve/_piqs.pyx
index fcb614dccd..4836237343 100644
--- a/qutip/solve/_piqs.pyx
+++ b/qutip/solve/_piqs.pyx
@@ -1,641 +1,641 @@
-#cython: language_level=3
-
-"""
-Cythonized code for permutationally invariant Lindbladian generation
-"""
-import numpy as np
-
-from scipy.sparse import csr_matrix, dok_matrix
-from qutip.core import Qobj
-
-cimport numpy as cnp
-cimport cython
-
-
-def _num_dicke_states(N):
-    """
-    Calculate the number of Dicke states.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    nds: int
-        The number of Dicke states.
-    """
-    if (not float(N).is_integer()):
-        raise ValueError("Number of TLS should be an integer")
-
-    if (N < 1):
-        raise ValueError("Number of TLS should be non-negative")
-
-    nds = (N/2 + 1)**2 - (N % 2)/4
-    return int(nds)
-
-def _num_dicke_ladders(N):
-    """
-    Calculate the total number of Dicke ladders in the Dicke space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    Nj: int
-        The number of Dicke ladders.
-    """
-    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
-    return int(Nj)
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef list get_blocks(int N):
-    """
-    Calculate the number of cumulative elements at each block boundary.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    blocks: np.ndarray
-        An array with the number of cumulative elements at the boundary of
-        each block.
-    """
-    cdef int num_blocks = _num_dicke_ladders(N)
-    cdef list blocks
-    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
-    return blocks
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef float j_min(N):
-    """
-    Calculate the minimum value of j for given N.
-
-    Parameters
-    ----------
-    N: int
-        Number of two-level systems.
-
-    Returns
-    -------
-    jmin: float
-        The minimum value of j for odd or even number of two
-        level systems.
-    """
-    if N % 2 == 0:
-        return 0
-    else:
-        return 0.5
-
-def j_vals(N):
-    """
-    Get the valid values of j for given N.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    jvals: np.ndarray
-        The j values for given N as a 1D array.
-    """
-    j = np.arange(j_min(N), N/2 + 1, 1)
-    return j
-
-def m_vals(j):
-    """
-    Get all the possible values of m or m1 for given j.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    mvals: np.ndarray
-        The m values for given j as a 1D array.
-    """
-    return np.arange(-j, j+1, 1)
-
-def get_index(N, j, m, m1, blocks):
-    """
-    Get the index in the density matrix for this j, m, m1 value.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    j, m, m1: float
-        The j, m, m1 values.
-
-    blocks: np.ndarray
-        An 1D array with the number of cumulative elements at the boundary of
-        each block.
-
-    Returns
-    -------
-    mvals: array
-        The m values for given j.
-    """
-    _k = int(j-m1)
-    _k_prime = int(j-m)
-    block_number = int(N/2 - j)
-    offset = 0
-    if block_number > 0:
-        offset = blocks[block_number-1]
-    i = _k_prime + offset
-    k = _k + offset
-    return (i, k)
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef list jmm1_dictionary(int N):
-    """
-    Get the index in the density matrix for this j, m, m1 value.
-
-    The (j, m, m1) values are mapped to the (i, k) index of a block
-    diagonal matrix which has the structure to capture the permutationally
-    symmetric part of the density matrix. For each (j, m, m1) value, first
-    we get the block by using the "j" value and then the addition in the
-    row/column due to the m and m1 is determined. Four dictionaries are
-    returned giving a map from the (j, m, m1) values to (i, k), the inverse
-    map, a flattened map and the inverse of the flattened map.
-    """
-    cdef long i
-    cdef long k
-    cdef dict jmm1_dict = {}
-    cdef dict jmm1_inv = {}
-    cdef dict jmm1_flat = {}
-    cdef dict jmm1_flat_inv = {}
-    cdef int l
-    cdef int nds = _num_dicke_states(N)
-    cdef list blocks = get_blocks(N)
-
-    jvalues = j_vals(N)
-    for j in jvalues:
-        mvalues = m_vals(j)
-        for m in mvalues:
-            for m1 in mvalues:
-                i, k = get_index(N, j, m, m1, blocks)
-                jmm1_dict[(i, k)] = (j, m, m1)
-                jmm1_inv[(j, m, m1)] = (i, k)
-                l = nds * i+k
-                jmm1_flat[l] = (j, m, m1)
-                jmm1_flat_inv[(j, m, m1)] = l
-    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef class Dicke(object):
-    """
-    A faster Cythonized Dicke state class to build the Lindbladian.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Attributes
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-    """
-    cdef int N
-    cdef float emission, dephasing, pumping
-    cdef float collective_emission, collective_dephasing, collective_pumping
-
-    def __init__(self, int N, float emission=0., float dephasing=0.,
-                 float pumping=0., float collective_emission=0.,
-                 collective_dephasing=0., collective_pumping=0.):
-        self.N = N
-        self.emission = emission
-        self.dephasing = dephasing
-        self.pumping = pumping
-        self.collective_emission = collective_emission
-        self.collective_dephasing = collective_dephasing
-        self.collective_pumping = collective_pumping
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef object lindbladian(self):
-        """
-        Build the Lindbladian superoperator of the dissipative dynamics as a
-        sparse matrix.
-
-        Returns
-        ----------
-        lindblad_qobj: :class: qutip.Qobj
-            The matrix size is (nds**2, nds**2) where nds is the number of
-            Dicke states.
-        """
-        N = self.N
-        cdef int nds = _num_dicke_states(N)
-        cdef int num_ladders = _num_dicke_ladders(N)
-
-        cdef list lindblad_row = []
-        cdef list lindblad_col = []
-        cdef list lindblad_data = []
-        cdef tuple jmm1_1
-        cdef tuple jmm1_2
-        cdef tuple jmm1_3
-        cdef tuple jmm1_4
-        cdef tuple jmm1_5
-        cdef tuple jmm1_6
-        cdef tuple jmm1_7
-        cdef tuple jmm1_8
-        cdef tuple jmm1_9
-
-        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
-
-        # perform loop in each row of matrix
-        for r in jmm1_row:
-            j, m, m1 = jmm1_row[r]
-            jmm1_1 = (j, m, m1)
-            jmm1_2 = (j, m+1, m1+1)
-            jmm1_3 = (j+1, m+1, m1+1)
-            jmm1_4 = (j-1, m+1, m1+1)
-            jmm1_5 = (j+1, m, m1)
-            jmm1_6 = (j-1, m, m1)
-            jmm1_7 = (j+1, m-1, m1-1)
-            jmm1_8 = (j, m-1, m1-1)
-            jmm1_9 = (j-1, m-1, m1-1)
-
-            g1 = self.gamma1(jmm1_1)
-            c1 = jmm1_inv[jmm1_1]
-
-            lindblad_row.append(int(r))
-            lindblad_col.append(int(c1))
-            lindblad_data.append(g1)
-
-            # generate gammas in the given row
-            # check if the gammas exist
-            # load gammas in the lindbladian in the correct position
-
-            if jmm1_2 in jmm1_inv:
-                g2 = self.gamma2(jmm1_2)
-                c2 = jmm1_inv[jmm1_2]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c2))
-                lindblad_data.append(g2)
-
-            if jmm1_3 in jmm1_inv:
-                g3 = self.gamma3(jmm1_3)
-                c3 = jmm1_inv[jmm1_3]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c3))
-                lindblad_data.append(g3)
-
-            if jmm1_4 in jmm1_inv:
-                g4 = self.gamma4(jmm1_4)
-                c4 = jmm1_inv[jmm1_4]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c4))
-                lindblad_data.append(g4)
-
-            if jmm1_5 in jmm1_inv:
-                g5 = self.gamma5(jmm1_5)
-                c5 = jmm1_inv[jmm1_5]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c5))
-                lindblad_data.append(g5)
-
-            if jmm1_6 in jmm1_inv:
-                g6 = self.gamma6(jmm1_6)
-                c6 = jmm1_inv[jmm1_6]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c6))
-                lindblad_data.append(g6)
-
-            if jmm1_7 in jmm1_inv:
-                g7 = self.gamma7(jmm1_7)
-                c7 = jmm1_inv[jmm1_7]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c7))
-                lindblad_data.append(g7)
-
-            if jmm1_8 in jmm1_inv:
-                g8 = self.gamma8(jmm1_8)
-                c8 = jmm1_inv[jmm1_8]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c8))
-                lindblad_data.append(g8)
-
-            if jmm1_9 in jmm1_inv:
-                g9 = self.gamma9(jmm1_9)
-                c9 = jmm1_inv[jmm1_9]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c9))
-                lindblad_data.append(g9)
-
-        cdef lindblad_matrix = csr_matrix((lindblad_data,
-                                          (lindblad_row, lindblad_col)),
-                                          shape=(nds**2, nds**2),
-                                          dtype=np.complex128)
-
-        # make matrix a Qobj superoperator with expected dims
-        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
-        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
-        return lindblad_qobj
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma1(self, tuple jmm1):
-        """
-        Calculate gamma1 for value of j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yCE, yE, yD, yP, yCP, yCD
-        cdef float N
-        cdef float spontaneous, losses, pump, collective_pump
-        cdef float dephase, collective_dephase, g1
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-
-        yE = self.emission
-        yD = self.dephasing
-        yP = self.pumping
-        yCE = self.collective_emission
-        yCP = self.collective_pumping
-        yCD = self.collective_dephasing
-
-        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
-        losses = (yE/2) * (N+m+m1)
-        pump = yP/2 * (N-m-m1)
-        collective_pump = yCP/2 * \
-            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
-        collective_dephase = yCD/2 * (m-m1)**2
-
-        if j <= 0:
-            dephase = yD*N/4
-        else:
-            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
-
-        g1 = spontaneous + losses + pump + dephase + \
-            collective_pump + collective_dephase
-
-        return -g1
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma2(self, tuple jmm1):
-        """
-        Calculate gamma2 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yCE, yE, yD, yP, yCP, yCD, g2
-        cdef float N
-        cdef float spontaneous, losses, pump, collective_pump
-        cdef float dephase, collective_dephase
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yCE = self.collective_emission
-        yE = self.emission
-
-        if yCE == 0:
-            spontaneous = 0.0
-        else:
-            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
-
-        if (yE == 0) or (j <= 0):
-            losses = 0.0
-        else:
-            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
-                                                      (N/2 + 1)/(j*(j+1))
-        g2 = spontaneous + losses
-        return g2
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma3(self, tuple jmm1):
-        """
-        Calculate gamma3 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yE
-        cdef float N
-        cdef float spontaneous, losses, pump, collective_pump
-        cdef float dephase, collective_dephase
-
-        cdef complex g3
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yE = self.emission
-
-        if (yE == 0) or (j <= 0):
-            g3 = 0.0
-        else:
-            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
-                 (N/2 + j+1)/(j*(2*j + 1))
-        return g3
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma4(self, tuple jmm1):
-        """
-        Calculate gamma4 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef complex g4
-        cdef float yE
-        cdef float N
-
-        N = float(self.N)
-        j, m, m1 = jmm1
-        yE = self.emission
-        if (yE == 0) or ((j+1) <= 0):
-            g4 = 0.0
-        else:
-            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
-                                (j-m1+2)) * (N/2 - j)/((j+1) *
-                                                       (2*j + 1))
-        return g4
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma5(self, tuple jmm1):
-        """
-        Calculate gamma5 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef complex g5
-        j, m, m1 = jmm1
-        cdef float yD
-        cdef float N
-
-        N = float(self.N)
-        yD = self.dephasing
-
-        if (yD == 0) or (j <= 0):
-            g5 = 0.0
-        else:
-            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
-                (N/2 + j + 1)/(j*(2*j + 1))
-
-        return g5
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma6(self, tuple jmm1):
-        """
-        Calculate gamma6 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yD
-        cdef float N
-        cdef complex g6
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-
-        yD = self.dephasing
-        if yD == 0:
-            g6 = 0.0
-        else:
-            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
-                                                   2-m1**2)) * \
-                                                   (N/2 - j)/((j+1) * (2*j+1))
-        return g6
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma7(self, tuple jmm1):
-        """
-        Calculate gamma7 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yP
-        cdef float N
-        cdef complex g7
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yP = self.pumping
-
-        if (yP == 0) or (j <= 0):
-            g7 = 0.0
-        else:
-            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
-                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
-        return g7
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma8(self, tuple jmm1):
-        """
-        Calculate gamma8 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yP, yCP
-        cdef float N
-        cdef complex g8
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yP = self.pumping
-        yCP = self.collective_pumping
-        if (yP == 0) or (j <= 0):
-            pump = 0.0
-        else:
-            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
-                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
-        if yCP == 0:
-            collective_pump = 0.0
-        else:
-            collective_pump = yCP * \
-                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
-        g8 = pump + collective_pump
-        return g8
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma9(self, tuple jmm1):
-        """
-        Calculate gamma9 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yP
-        cdef float N
-        cdef complex g9
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yP = self.pumping
-
-        if (yP == 0):
-            g9 = 0.0
-        else:
-            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
-                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
-        return g9
+#cython: language_level=3
+
+"""
+Cythonized code for permutationally invariant Lindbladian generation
+"""
+import numpy as np
+
+from scipy.sparse import csr_matrix, dok_matrix
+from qutip.core import Qobj
+
+cimport numpy as cnp
+cimport cython
+
+
+def _num_dicke_states(N):
+    """
+    Calculate the number of Dicke states.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    nds: int
+        The number of Dicke states.
+    """
+    if (not float(N).is_integer()):
+        raise ValueError("Number of TLS should be an integer")
+
+    if (N < 1):
+        raise ValueError("Number of TLS should be non-negative")
+
+    nds = (N/2 + 1)**2 - (N % 2)/4
+    return int(nds)
+
+def _num_dicke_ladders(N):
+    """
+    Calculate the total number of Dicke ladders in the Dicke space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    Nj: int
+        The number of Dicke ladders.
+    """
+    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
+    return int(Nj)
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef list get_blocks(int N):
+    """
+    Calculate the number of cumulative elements at each block boundary.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    blocks: np.ndarray
+        An array with the number of cumulative elements at the boundary of
+        each block.
+    """
+    cdef int num_blocks = _num_dicke_ladders(N)
+    cdef list blocks
+    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
+    return blocks
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef float j_min(N):
+    """
+    Calculate the minimum value of j for given N.
+
+    Parameters
+    ----------
+    N: int
+        Number of two-level systems.
+
+    Returns
+    -------
+    jmin: float
+        The minimum value of j for odd or even number of two
+        level systems.
+    """
+    if N % 2 == 0:
+        return 0
+    else:
+        return 0.5
+
+def j_vals(N):
+    """
+    Get the valid values of j for given N.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    jvals: np.ndarray
+        The j values for given N as a 1D array.
+    """
+    j = np.arange(j_min(N), N/2 + 1, 1)
+    return j
+
+def m_vals(j):
+    """
+    Get all the possible values of m or m1 for given j.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    mvals: np.ndarray
+        The m values for given j as a 1D array.
+    """
+    return np.arange(-j, j+1, 1)
+
+def get_index(N, j, m, m1, blocks):
+    """
+    Get the index in the density matrix for this j, m, m1 value.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    j, m, m1: float
+        The j, m, m1 values.
+
+    blocks: np.ndarray
+        An 1D array with the number of cumulative elements at the boundary of
+        each block.
+
+    Returns
+    -------
+    mvals: array
+        The m values for given j.
+    """
+    _k = int(j-m1)
+    _k_prime = int(j-m)
+    block_number = int(N/2 - j)
+    offset = 0
+    if block_number > 0:
+        offset = blocks[block_number-1]
+    i = _k_prime + offset
+    k = _k + offset
+    return (i, k)
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef list jmm1_dictionary(int N):
+    """
+    Get the index in the density matrix for this j, m, m1 value.
+
+    The (j, m, m1) values are mapped to the (i, k) index of a block
+    diagonal matrix which has the structure to capture the permutationally
+    symmetric part of the density matrix. For each (j, m, m1) value, first
+    we get the block by using the "j" value and then the addition in the
+    row/column due to the m and m1 is determined. Four dictionaries are
+    returned giving a map from the (j, m, m1) values to (i, k), the inverse
+    map, a flattened map and the inverse of the flattened map.
+    """
+    cdef long i
+    cdef long k
+    cdef dict jmm1_dict = {}
+    cdef dict jmm1_inv = {}
+    cdef dict jmm1_flat = {}
+    cdef dict jmm1_flat_inv = {}
+    cdef int l
+    cdef int nds = _num_dicke_states(N)
+    cdef list blocks = get_blocks(N)
+
+    jvalues = j_vals(N)
+    for j in jvalues:
+        mvalues = m_vals(j)
+        for m in mvalues:
+            for m1 in mvalues:
+                i, k = get_index(N, j, m, m1, blocks)
+                jmm1_dict[(i, k)] = (j, m, m1)
+                jmm1_inv[(j, m, m1)] = (i, k)
+                l = nds * i+k
+                jmm1_flat[l] = (j, m, m1)
+                jmm1_flat_inv[(j, m, m1)] = l
+    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef class Dicke(object):
+    """
+    A faster Cythonized Dicke state class to build the Lindbladian.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Attributes
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+    """
+    cdef int N
+    cdef float emission, dephasing, pumping
+    cdef float collective_emission, collective_dephasing, collective_pumping
+
+    def __init__(self, int N, float emission=0., float dephasing=0.,
+                 float pumping=0., float collective_emission=0.,
+                 collective_dephasing=0., collective_pumping=0.):
+        self.N = N
+        self.emission = emission
+        self.dephasing = dephasing
+        self.pumping = pumping
+        self.collective_emission = collective_emission
+        self.collective_dephasing = collective_dephasing
+        self.collective_pumping = collective_pumping
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef object lindbladian(self):
+        """
+        Build the Lindbladian superoperator of the dissipative dynamics as a
+        sparse matrix.
+
+        Returns
+        ----------
+        lindblad_qobj: :class: qutip.Qobj
+            The matrix size is (nds**2, nds**2) where nds is the number of
+            Dicke states.
+        """
+        N = self.N
+        cdef int nds = _num_dicke_states(N)
+        cdef int num_ladders = _num_dicke_ladders(N)
+
+        cdef list lindblad_row = []
+        cdef list lindblad_col = []
+        cdef list lindblad_data = []
+        cdef tuple jmm1_1
+        cdef tuple jmm1_2
+        cdef tuple jmm1_3
+        cdef tuple jmm1_4
+        cdef tuple jmm1_5
+        cdef tuple jmm1_6
+        cdef tuple jmm1_7
+        cdef tuple jmm1_8
+        cdef tuple jmm1_9
+
+        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
+
+        # perform loop in each row of matrix
+        for r in jmm1_row:
+            j, m, m1 = jmm1_row[r]
+            jmm1_1 = (j, m, m1)
+            jmm1_2 = (j, m+1, m1+1)
+            jmm1_3 = (j+1, m+1, m1+1)
+            jmm1_4 = (j-1, m+1, m1+1)
+            jmm1_5 = (j+1, m, m1)
+            jmm1_6 = (j-1, m, m1)
+            jmm1_7 = (j+1, m-1, m1-1)
+            jmm1_8 = (j, m-1, m1-1)
+            jmm1_9 = (j-1, m-1, m1-1)
+
+            g1 = self.gamma1(jmm1_1)
+            c1 = jmm1_inv[jmm1_1]
+
+            lindblad_row.append(int(r))
+            lindblad_col.append(int(c1))
+            lindblad_data.append(g1)
+
+            # generate gammas in the given row
+            # check if the gammas exist
+            # load gammas in the lindbladian in the correct position
+
+            if jmm1_2 in jmm1_inv:
+                g2 = self.gamma2(jmm1_2)
+                c2 = jmm1_inv[jmm1_2]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c2))
+                lindblad_data.append(g2)
+
+            if jmm1_3 in jmm1_inv:
+                g3 = self.gamma3(jmm1_3)
+                c3 = jmm1_inv[jmm1_3]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c3))
+                lindblad_data.append(g3)
+
+            if jmm1_4 in jmm1_inv:
+                g4 = self.gamma4(jmm1_4)
+                c4 = jmm1_inv[jmm1_4]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c4))
+                lindblad_data.append(g4)
+
+            if jmm1_5 in jmm1_inv:
+                g5 = self.gamma5(jmm1_5)
+                c5 = jmm1_inv[jmm1_5]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c5))
+                lindblad_data.append(g5)
+
+            if jmm1_6 in jmm1_inv:
+                g6 = self.gamma6(jmm1_6)
+                c6 = jmm1_inv[jmm1_6]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c6))
+                lindblad_data.append(g6)
+
+            if jmm1_7 in jmm1_inv:
+                g7 = self.gamma7(jmm1_7)
+                c7 = jmm1_inv[jmm1_7]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c7))
+                lindblad_data.append(g7)
+
+            if jmm1_8 in jmm1_inv:
+                g8 = self.gamma8(jmm1_8)
+                c8 = jmm1_inv[jmm1_8]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c8))
+                lindblad_data.append(g8)
+
+            if jmm1_9 in jmm1_inv:
+                g9 = self.gamma9(jmm1_9)
+                c9 = jmm1_inv[jmm1_9]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c9))
+                lindblad_data.append(g9)
+
+        cdef lindblad_matrix = csr_matrix((lindblad_data,
+                                          (lindblad_row, lindblad_col)),
+                                          shape=(nds**2, nds**2),
+                                          dtype=np.complex128)
+
+        # make matrix a Qobj superoperator with expected dims
+        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
+        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
+        return lindblad_qobj
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma1(self, tuple jmm1):
+        """
+        Calculate gamma1 for value of j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yCE, yE, yD, yP, yCP, yCD
+        cdef float N
+        cdef float spontaneous, losses, pump, collective_pump
+        cdef float dephase, collective_dephase, g1
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+
+        yE = self.emission
+        yD = self.dephasing
+        yP = self.pumping
+        yCE = self.collective_emission
+        yCP = self.collective_pumping
+        yCD = self.collective_dephasing
+
+        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
+        losses = (yE/2) * (N+m+m1)
+        pump = yP/2 * (N-m-m1)
+        collective_pump = yCP/2 * \
+            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
+        collective_dephase = yCD/2 * (m-m1)**2
+
+        if j <= 0:
+            dephase = yD*N/4
+        else:
+            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
+
+        g1 = spontaneous + losses + pump + dephase + \
+            collective_pump + collective_dephase
+
+        return -g1
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma2(self, tuple jmm1):
+        """
+        Calculate gamma2 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yCE, yE, yD, yP, yCP, yCD, g2
+        cdef float N
+        cdef float spontaneous, losses, pump, collective_pump
+        cdef float dephase, collective_dephase
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yCE = self.collective_emission
+        yE = self.emission
+
+        if yCE == 0:
+            spontaneous = 0.0
+        else:
+            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
+
+        if (yE == 0) or (j <= 0):
+            losses = 0.0
+        else:
+            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
+                                                      (N/2 + 1)/(j*(j+1))
+        g2 = spontaneous + losses
+        return g2
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma3(self, tuple jmm1):
+        """
+        Calculate gamma3 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yE
+        cdef float N
+        cdef float spontaneous, losses, pump, collective_pump
+        cdef float dephase, collective_dephase
+
+        cdef complex g3
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yE = self.emission
+
+        if (yE == 0) or (j <= 0):
+            g3 = 0.0
+        else:
+            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
+                 (N/2 + j+1)/(j*(2*j + 1))
+        return g3
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma4(self, tuple jmm1):
+        """
+        Calculate gamma4 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef complex g4
+        cdef float yE
+        cdef float N
+
+        N = float(self.N)
+        j, m, m1 = jmm1
+        yE = self.emission
+        if (yE == 0) or ((j+1) <= 0):
+            g4 = 0.0
+        else:
+            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
+                                (j-m1+2)) * (N/2 - j)/((j+1) *
+                                                       (2*j + 1))
+        return g4
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma5(self, tuple jmm1):
+        """
+        Calculate gamma5 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef complex g5
+        j, m, m1 = jmm1
+        cdef float yD
+        cdef float N
+
+        N = float(self.N)
+        yD = self.dephasing
+
+        if (yD == 0) or (j <= 0):
+            g5 = 0.0
+        else:
+            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
+                (N/2 + j + 1)/(j*(2*j + 1))
+
+        return g5
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma6(self, tuple jmm1):
+        """
+        Calculate gamma6 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yD
+        cdef float N
+        cdef complex g6
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+
+        yD = self.dephasing
+        if yD == 0:
+            g6 = 0.0
+        else:
+            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
+                                                   2-m1**2)) * \
+                                                   (N/2 - j)/((j+1) * (2*j+1))
+        return g6
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma7(self, tuple jmm1):
+        """
+        Calculate gamma7 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yP
+        cdef float N
+        cdef complex g7
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yP = self.pumping
+
+        if (yP == 0) or (j <= 0):
+            g7 = 0.0
+        else:
+            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
+                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
+        return g7
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma8(self, tuple jmm1):
+        """
+        Calculate gamma8 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yP, yCP
+        cdef float N
+        cdef complex g8
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yP = self.pumping
+        yCP = self.collective_pumping
+        if (yP == 0) or (j <= 0):
+            pump = 0.0
+        else:
+            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
+                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
+        if yCP == 0:
+            collective_pump = 0.0
+        else:
+            collective_pump = yCP * \
+                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
+        g8 = pump + collective_pump
+        return g8
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma9(self, tuple jmm1):
+        """
+        Calculate gamma9 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yP
+        cdef float N
+        cdef complex g9
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yP = self.pumping
+
+        if (yP == 0):
+            g9 = 0.0
+        else:
+            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
+                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
+        return g9
diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
index 91799251bf..4257fb2b86 100644
--- a/qutip/solve/_stochastic.pyx
+++ b/qutip/solve/_stochastic.pyx
@@ -1,2345 +1,2345 @@
-#cython: language_level=3
-
-import numpy as np
-cimport numpy as np
-cimport cython
-from cpython.exc cimport PyErr_CheckSignals
-from libc.math cimport fabs
-from qutip.core.cy.qobjevo cimport QobjEvo
-from .. import Qobj, unstack_columns
-import scipy.sparse as sp
-from scipy.sparse.linalg import LinearOperator
-from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
-from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
-
-from qutip.core.data cimport dense, Dense
-import qutip.core.data as _data
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-cdef int ZERO=0
-cdef double DZERO=0
-cdef complex ZZERO=0j
-cdef int ONE=1
-
-"""Some of blas wrapper"""
-@cython.boundscheck(False)
-cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
-    """ y += a*x"""
-    cdef int l = x.shape[0]
-    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void copy(complex[::1] x, complex[::1] y):
-    """ y = x """
-    cdef int l = x.shape[0]
-    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef complex _dot(complex[::1] x, complex[::1] y):
-    """ = x_i * y_i """
-    cdef int l = x.shape[0]
-    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef complex _dotc(complex[::1] x, complex[::1] y):
-    """ = conj(x_i) * y_i """
-    cdef int l = x.shape[0]
-    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef double _dznrm2(complex[::1] vec):
-    """ = sqrt( x_i**2 ) """
-    cdef int l = vec.shape[0]
-    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _scale(double a, complex[::1] x):
-    """ x *= a """
-    cdef int l = x.shape[0]
-    zdscal(&l, &a, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zscale(complex a, complex[::1] x):
-    """ x *= a """
-    cdef int l = x.shape[0]
-    zscal(&l, &a, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero(complex[::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]
-    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero_2d(complex[:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]
-    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero_3d(complex[:,:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
-    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero_4d(complex[:,:,:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
-    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
-
-@cython.boundscheck(False)
-@cython.initializedcheck(False)
-cdef Dense _dense_wrap(double complex [::1] x):
-    return dense.wrap(&x[0], x.shape[0], 1)
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%
-# functions for ensuring that the states stay physical
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cdef void _normalize_inplace(complex[::1] vec):
-    """ make norm of vec equal to 1"""
-    cdef int l = vec.shape[0]
-    cdef double norm = 1.0/_dznrm2(vec)
-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-
-# to move eventually, 10x faster than scipy's norm.
-@cython.cdivision(True)
-@cython.boundscheck(False)
-def normalize_inplace(complex[::1] vec):
-    """ make norm of vec equal to 1"""
-    cdef int l = vec.shape[0]
-    cdef double norm = 1.0/_dznrm2(vec)
-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-    return fabs(norm-1)
-
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cdef void _normalize_rho(complex[::1] rho):
-    """ Ensure that the density matrix trace is one and
-    that the composing states are normalized.
-    """
-    cdef int l = rho.shape[0]
-    cdef int N = np.sqrt(l)
-    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
-    cdef complex[::1,:] eivec
-    cdef double[::1] eival = np.zeros(N)
-    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
-
-    _zero(rho)
-    cdef int i, j, k
-    cdef double sum
-
-    sum = 0.
-    for i in range(N):
-        _normalize_inplace(eivec[:,i])
-        if eival[i] < 0:
-            eival[i] = 0.
-        sum += eival[i]
-    if sum != 1.:
-        for i in range(N):
-            eival[i] /= sum
-
-    for i in range(N):
-        for j in range(N):
-            for k in range(N):
-                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
-
-# Available solvers:
-cpdef enum Solvers:
-  # order 0.5
-  EULER_SOLVER           =  50
-  # order 0.5 strong, 1.0 weak?
-  PC_SOLVER              = 101
-  PC_2_SOLVER            = 104
-  # order 1.0
-  PLATEN_SOLVER          = 100
-  MILSTEIN_SOLVER        = 102
-  MILSTEIN_IMP_SOLVER    = 103
-  # order 1.5
-  EXPLICIT1_5_SOLVER     = 150
-  TAYLOR1_5_SOLVER       = 152
-  TAYLOR1_5_IMP_SOLVER   = 153
-  # order 2.0
-  TAYLOR2_0_SOLVER       = 202
-
-  # Special solvers
-  PHOTOCURRENT_SOLVER    =  60
-  PHOTOCURRENT_PC_SOLVER = 110
-  ROUCHON_SOLVER         = 120
-
-  # For initialisation
-  SOLVER_NOT_SET         =   0
-
-
-cdef class TaylorNoise:
-    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
-    Complex enough that I fell it should be kept separated from the main solver.
-    """
-    cdef:
-      int p
-      double rho, alpha
-      double aFactor, bFactor
-      double BFactor, CFactor
-      double dt, dt_sqrt
-
-    @cython.cdivision(True)
-    def __init__(self, int p, double dt):
-        self.p = p
-        self.dt = dt
-        self.dt_sqrt = dt**.5
-        cdef double pi = np.pi
-        cdef int i
-
-        cdef double rho = 0.
-        for i in range(1,p+1):
-            rho += (i+0.)**-2
-        rho = 1./3.-2*rho/(pi**2)
-        self.rho = (rho)**.5
-        self.aFactor = -(2)**.5/pi
-
-        cdef double alpha = 0.
-        for i in range(1,p+1):
-            alpha += (i+0.)**-4
-        alpha = pi/180-alpha/(2*pi**2)/pi
-        self.alpha = (alpha)**.5
-        self.bFactor = (0.5)**.5/pi**2
-
-        self.BFactor = 1/(4*pi**2)
-        self.CFactor = -1/(2*pi**2)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void order2(self, double[::1] noise, double[::1] dws):
-        cdef int p = self.p
-        cdef int r, l
-        cdef double s = 1/6.
-        cdef double a = 0
-        cdef double b = 0
-        cdef double AA = 0
-        cdef double BB = 0
-        cdef double CC = 0
-
-        for r in range(p):
-            a += noise[3+r]/(r+1.)
-            b += noise[3+r+p]/(r+1.)/(r+1.)
-            BB += (1/(r+1.)/(r+1.)) *\
-                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
-            for l in range(p):
-                if r != l:
-                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
-                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
-                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
-
-        a = self.aFactor * a + self.rho * noise[1]
-        b = self.bFactor * b + self.alpha * noise[2]
-        AA = 0.25*a*a
-        BB *= self.BFactor
-        CC *= self.CFactor
-
-        dws[0] = noise[0]                       # dw
-        dws[1] = 0.5*(noise[0]+a)               # dz
-        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
-        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
-        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
-
-
-cdef class StochasticSolver:
-    """ stochastic solver class base
-    Does most of the initialisation, drive the simulation and contain the
-    stochastic integration algorythm that do not depend on the physics.
-
-    This class is not to be used as is, the function computing the evolution's
-    derivative are specified in it's child class which define the deterministic
-    and stochastic contributions.
-
-    PYTHON METHODS:
-    set_solver:
-      Receive the data for the integration.
-      Prepare buffers
-
-    cy_sesolve_single_trajectory:
-      Run one trajectory.
-
-
-    INTERNAL METHODS
-    make_noise:
-      create the stochastic noise
-    run:
-      evolution between timestep (substep)
-    solver's method:
-      stochastic integration algorithm
-        euler
-        milstein
-        taylor
-        ...
-
-    CHILD:
-    SSESolver: stochastic schrodinger evolution
-    SMESolver: stochastic master evolution
-    PcSSESolver: photocurrent stochastic schrodinger evolution
-    PcSMESolver: photocurrent stochastic master evolution
-    PmSMESolver: positive map stochastic master evolution
-    GenericSSolver: general (user defined) stochastic evolution
-
-    CHILD METHODS:
-    set_data:
-      Read data about the system
-    d1:
-      deterministic part
-    d2:
-      non-deterministic part
-    derivatives:
-      d1, d2 and their derivatives up to dt**1.5
-      multiple sc_ops
-    derivativesO2:
-      d1, d2 and there derivatives up to dt**2.0
-      one sc_ops
-    """
-    cdef int l_vec, num_ops
-    cdef Solvers solver
-    cdef int num_step, num_substeps, num_dw
-    cdef int normalize
-    cdef double dt
-    cdef int noise_type
-    cdef object custom_noise
-    cdef double[::1] dW_factor
-    cdef unsigned int[::1] seed
-    cdef object sso
-
-    # buffer to not redo the initialisation at each substep
-    cdef complex[:, ::1] buffer_1d
-    cdef complex[:, :, ::1] buffer_2d
-    cdef complex[:, :, :, ::1] buffer_3d
-    cdef complex[:, :, :, ::1] buffer_4d
-    cdef complex[:, ::1] expect_buffer_1d
-    cdef complex[:, ::1] expect_buffer_2d
-    cdef complex[:, :, ::1] expect_buffer_3d
-    cdef complex[:, ::1] func_buffer_1d
-    cdef complex[:, ::1] func_buffer_2d
-    cdef complex[:, :, ::1] func_buffer_3d
-
-    cdef TaylorNoise order2noise
-
-    def __init__(self):
-        self.l_vec = 0
-        self.num_ops = 0
-        self.solver = SOLVER_NOT_SET
-
-    def set_solver(self, sso):
-        """ Prepare the solver from the info in StochasticSolverOptions
-
-        Parameters
-        ----------
-        sso : StochasticSolverOptions
-            Data of the stochastic system
-        """
-        self.set_data(sso)
-        self.sso = sso
-
-        self.solver = sso.solver_code
-        self.dt = sso.dt
-        self.num_substeps = sso.nsubsteps
-        self.normalize = sso.normalize
-        self.num_step = len(sso.times)
-        self.num_dw = len(sso.sops)
-        if self.solver in [EXPLICIT1_5_SOLVER,
-                           TAYLOR1_5_SOLVER,
-                           TAYLOR1_5_IMP_SOLVER]:
-            self.num_dw *= 2
-        if self.solver in [TAYLOR2_0_SOLVER]:
-            self.num_dw *= 3 + 2*sso.p
-            self.order2noise = TaylorNoise(sso.p, self.dt)
-        # prepare buffers for the solvers
-        nb_solver = [0,0,0,0]
-        nb_func = [0,0,0]
-        nb_expect = [0,0,0]
-
-        # %%%%%%%%%%%%%%%%%%%%%%%%%
-        # Depending on the solver, determine the numbers of buffers of each
-        # shape to prepare. (~30% slower when not preallocating buffer)
-        # nb_solver : buffer to contain the states used by solver
-        # nb_func : buffer for states used used by d1, d2 and derivative functions
-        # nb_expect : buffer to store expectation values.
-        if self.solver is EULER_SOLVER:
-            nb_solver = [0,1,0,0]
-        elif self.solver is PHOTOCURRENT_SOLVER:
-            nb_solver = [1,0,0,0]
-            nb_func = [1,0,0]
-        elif self.solver is PLATEN_SOLVER:
-            nb_solver = [2,5,0,0]
-        elif self.solver is PC_SOLVER:
-            nb_solver = [4,1,1,0]
-        elif self.solver is MILSTEIN_SOLVER:
-            nb_solver = [0,1,1,0]
-        elif self.solver is MILSTEIN_IMP_SOLVER:
-            nb_solver = [1,1,1,0]
-        elif self.solver is PC_2_SOLVER:
-            nb_solver = [5,1,1,0]
-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-            nb_solver = [1,1,0,0]
-            nb_func = [1,0,0]
-        elif self.solver is ROUCHON_SOLVER:
-            nb_solver = [2,0,0,0]
-        elif self.solver is EXPLICIT1_5_SOLVER:
-            nb_solver = [5,8,3,0]
-        elif self.solver is TAYLOR1_5_SOLVER:
-            nb_solver = [2,3,1,1]
-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-            nb_solver = [2,3,1,1]
-        elif self.solver is TAYLOR2_0_SOLVER:
-            nb_solver = [11,0,0,0]
-
-        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
-                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-          if sso.me:
-            nb_func = [1,0,0]
-            nb_expect = [1,1,0]
-          else:
-            nb_func = [2,1,1]
-            nb_expect = [2,1,1]
-        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
-            nb_expect = [1,0,0]
-        elif self.solver is TAYLOR2_0_SOLVER:
-          if sso.me:
-            nb_func = [2,0,0]
-            nb_expect = [2,0,0]
-          else:
-            nb_func = [14,0,0]
-            nb_expect = [0,0,0]
-        elif self.solver is ROUCHON_SOLVER:
-            nb_expect = [1,0,0]
-        else:
-          if not sso.me:
-            nb_func = [1,0,0]
-
-        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
-        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
-                                  dtype=complex)
-        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
-                                        dtype=complex)
-        if nb_solver[3]:
-          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
-                                        dtype=complex)
-
-        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
-        if nb_expect[1]:
-          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
-        if nb_expect[2]:
-          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
-
-        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
-        if nb_func[1]:
-          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
-        if nb_func[2]:
-          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
-
-        self.noise_type = sso.noise_type
-        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
-        if self.noise_type == 1:
-            self.custom_noise = sso.noise
-        elif self.noise_type == 0:
-            self.seed = sso.noise
-
-    def set_data(self, sso):
-        """Set solver specific operator"""
-        pass
-
-    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
-        """Create the random numbers for the stochastic process"""
-        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
-            # photocurrent, just seed,
-            np.random.seed(self.seed[n])
-            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
-        if self.noise_type == 0:
-            np.random.seed(self.seed[n])
-            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
-                                   np.sqrt(self.dt)
-        elif self.noise_type == 1:
-            return self.custom_noise[n,:,:,:]
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def cy_sesolve_single_trajectory(self, int n):
-        """ Run the one of the trajectories of the stochastic system.
-
-        Parameters
-        ----------
-        n : int
-            Number of the iterations
-
-        sso : StochasticSolverOptions
-            Data of the stochastic system
-
-        Returns
-        -------
-        states_list : list of qobj
-            State of the system at each time
-
-        noise : array
-            noise at each step of the solver
-
-        measurements : array
-            measurements value at each timestep for each m_ops
-
-        expect : array
-            expectation value at each timestep for each e_ops
-
-        """
-        sso = self.sso
-        cdef double[::1] times = sso.times
-        cdef complex[::1] rho_t
-        cdef double t
-        cdef int m_idx, t_idx, e_idx
-        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
-        cdef int tlast = times.shape[0]
-
-        rho_t = sso.rho0.copy()
-        dims = sso.state0.dims
-
-        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
-        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
-        states_list = []
-        for t_idx, t in enumerate(times):
-            PyErr_CheckSignals()
-            if sso.ce_ops:
-                for e_idx, e in enumerate(sso.ce_ops):
-                    s = e.expect_data(t, _dense_wrap(rho_t))
-                    expect[e_idx, t_idx] = s
-            if sso.store_states or not sso.ce_ops:
-                if sso.me:
-                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
-                        dims=dims))
-                else:
-                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
-
-            if t_idx != tlast-1:
-                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
-                                 rho_t, self.num_substeps)
-
-            if sso.store_measurement:
-                for m_idx, m in enumerate(sso.cm_ops):
-                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
-                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
-                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
-
-        if sso.method == 'heterodyne':
-            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
-
-        return states_list, noise, measurements, expect
-
-    @cython.boundscheck(False)
-    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
-                          complex[::1] vec, int num_substeps):
-        """ Do one time full step"""
-        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
-        cdef int i
-        if self.solver is EULER_SOLVER:
-            for i in range(num_substeps):
-                self.euler(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PHOTOCURRENT_SOLVER:
-            for i in range(num_substeps):
-                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PLATEN_SOLVER:
-            for i in range(num_substeps):
-                self.platen(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PC_SOLVER:
-            for i in range(num_substeps):
-                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is MILSTEIN_SOLVER:
-            for i in range(num_substeps):
-                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is MILSTEIN_IMP_SOLVER:
-            for i in range(num_substeps):
-                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PC_2_SOLVER:
-            for i in range(num_substeps):
-                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-            for i in range(num_substeps):
-                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is ROUCHON_SOLVER:
-            for i in range(num_substeps):
-                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is EXPLICIT1_5_SOLVER:
-            for i in range(num_substeps):
-                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR1_5_SOLVER:
-            for i in range(num_substeps):
-                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-            for i in range(num_substeps):
-                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR2_0_SOLVER:
-            for i in range(num_substeps):
-                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        if self.normalize:
-            self._normalize_inplace(vec)
-        return vec
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_inplace(vec)
-
-    # Dummy functions
-    # Needed for compilation since ssesolve is not stand-alone
-    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
-        """ deterministic part of the evolution
-        depend on schrodinger vs master vs photocurrent
-        """
-        pass
-
-    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
-        """ stochastic part of the evolution
-        depend on schrodinger vs master vs photocurrent
-        """
-        pass
-
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
-        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
-        pass
-
-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
-                              complex[::1] a, complex[:, ::1] b,
-                              complex[:, :, ::1] Lb, complex[:,::1] La,
-                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                              complex[::1] L0a):
-        """ Obtain the multiple terms for stochastic taylor expension
-        Up to order 1.5
-        multiple sc_ops
-        """
-        pass
-
-    cdef void derivativesO2(self, double t, complex[::1] rho,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """ Obtain the multiple terms for stochastic taylor expension
-        Up to order 2.0
-        One sc_ops
-        """
-        pass
-
-    cdef void photocurrent(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        photocurrent collapse + euler evolution
-        """
-        pass
-
-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        photocurrent collapse + predictor-corrector evolution
-        """
-        pass
-
-    cdef void rouchon(self, double t, double dt, double[:] noise,
-                      complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        Force valid density matrix using positive map
-        Pierre Rouchon, Jason F. Ralph
-        arXiv:1410.5345 [quant-ph]
-        """
-        pass
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void euler(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """Integration scheme:
-        Basic Euler order 0.5
-        dV = d1 dt + d2_i dW_i
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        _zero_2d(d2)
-        copy(vec, out)
-        self.d1(t, vec, out)
-        self.d2(t, vec, d2)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void platen(self, double t, double dt, double[:] noise,
-                       complex[::1] vec, complex[::1] out):
-        """
-        Platen rhs function for both master eq and schrodinger eq.
-        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
-             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
-             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
-
-        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
-        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
-        The Theory of Open Quantum Systems
-        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
-        """
-        cdef int i, j, k
-        cdef double sqrt_dt = np.sqrt(dt)
-        cdef double sqrt_dt_inv = 0.25/sqrt_dt
-        cdef double dw, dw2
-        cdef complex[::1] d1 = self.buffer_1d[0,:]
-        cdef complex[::1] Vt = self.buffer_1d[1,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
-        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
-        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
-        _zero(d1)
-        _zero_2d(d2)
-
-        self.d1(t, vec, d1)
-        self.d2(t, vec, d2)
-        _axpy(1.0,vec,d1)
-        copy(d1,Vt)
-        copy(d1,out)
-        _scale(0.5,out)
-        for i in range(self.num_ops):
-            copy(d1,Vp[i,:])
-            copy(d1,Vm[i,:])
-            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
-            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
-            _axpy(noise[i],d2[i,:],Vt)
-        _zero(d1)
-        self.d1(t, Vt, d1)
-        _axpy(0.5,d1,out)
-        _axpy(0.5,vec,out)
-        for i in range(self.num_ops):
-            _zero_2d(d2p)
-            _zero_2d(d2m)
-            self.d2(t, Vp[i,:], d2p)
-            self.d2(t, Vm[i,:], d2m)
-            dw = noise[i] * 0.25
-            _axpy(dw,d2m[i,:],out)
-            _axpy(2*dw,d2[i,:],out)
-            _axpy(dw,d2p[i,:],out)
-            for j in range(self.num_ops):
-                if i == j:
-                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
-                else:
-                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
-                _axpy(dw2,d2p[j,:],out)
-                _axpy(-dw2,d2m[j,:],out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void pred_corr(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 15.5 Eq. (5.4)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        # a=0. b=0.5
-        cdef double dt_2 = dt*0.5
-        cdef complex[::1] euler = self.buffer_1d[0,:]
-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-        cdef complex[::1] b_pred = self.buffer_1d[2,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero(a_pred)
-        _zero(b_pred)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-        copy(vec, euler)
-        copy(vec, out)
-        _axpy(1.0, a_pred, euler)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], b_pred)
-            _axpy(-dt_2, dd2[i,i,:], a_pred)
-        _axpy(1.0, a_pred, out)
-        _axpy(1.0, b_pred, euler)
-        _axpy(0.5, b_pred, out)
-        _zero_2d(d2)
-        self.d2(t + dt, euler, d2)
-        for i in range(self.num_ops):
-            _axpy(noise[i]*0.5, d2[i,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 15.5 Eq. (5.4)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        # a=0.5, b=0.5
-        cdef int i, j, k
-        cdef complex[::1] euler = self.buffer_1d[0,:]
-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-        _zero(a_pred)
-        cdef complex[::1] a_corr = self.buffer_1d[2,:]
-        _zero(a_corr)
-        cdef complex[::1] b_pred = self.buffer_1d[3,:]
-        _zero(b_pred)
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        _zero_2d(d2)
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero_3d(dd2)
-
-        cdef double dt_2 = dt*0.5
-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-        copy(vec, euler)
-        _axpy(1.0, a_pred, euler)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], b_pred)
-            _axpy(-dt_2, dd2[i,i,:], a_pred)
-        _axpy(1.0, b_pred, euler)
-        copy(vec, out)
-        _axpy(0.5, a_pred, out)
-        _axpy(0.5, b_pred, out)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
-        for i in range(self.num_ops):
-            _axpy(noise[i]*0.5, d2[i,:], out)
-            _axpy(-dt_2, dd2[i,i,:], a_corr)
-        _axpy(0.5, a_corr, out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void milstein(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 10.3 Eq. (3.1)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-
-        dV = -iH*V*dt + d1*dt + d2_i*dW_i
-             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
-        """
-        cdef int i, j, k
-        cdef double dw
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        copy(vec,out)
-        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
-        for i in range(self.num_ops):
-            _axpy(noise[i],d2[i,:],out)
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                if (i == j):
-                    dw = (noise[i] * noise[i] - dt) * 0.5
-                else:
-                    dw = (noise[i] * noise[j])
-                _axpy(dw,dd2[i,j,:],out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void milstein_imp(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out) except *:
-        """
-        Chapter 12.2 Eq. (2.9)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j, k
-        cdef double dw
-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-                                                          dtype=complex)
-        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
-                                                         dtype=complex)
-        cdef complex[::1] a = self.buffer_1d[0,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero(a)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
-        copy(vec, dvec)
-        _axpy(0.5, a, dvec)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], dvec)
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                if (i == j):
-                    dw = (noise[i] * noise[i] - dt) * 0.5
-                else:
-                    dw = (noise[i] * noise[j])
-                _axpy(dw, dd2[i,j,:], dvec)
-        copy(dvec, guess)
-        _axpy(0.5, a, guess)
-        self.implicit(t+dt, dvec, out, guess)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void taylor15(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """
-        Chapter 12.2 Eq. (2.18),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-        cdef complex[::1] L0a = self.buffer_1d[1, :]
-        _zero(a)
-        _zero_2d(b)
-        _zero_3d(Lb)
-        _zero_2d(L0b)
-        _zero_2d(La)
-        _zero_4d(LLb)
-        _zero(L0a)
-        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
-
-        cdef int i,j,k
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-        copy(vec,out)
-        _axpy(1.0, a, out)
-        _axpy(0.5, L0a, out)
-
-        for i in range(self.num_ops):
-            _axpy(dw[i], b[i,:], out)
-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
-            _axpy(dz[i], La[i,:], out)
-            _axpy(dw[i]-dz[i], L0b[i,:], out)
-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-                        LLb[i,i,i,:], out)
-            for j in range(i+1,self.num_ops):
-                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
-                for k in range(j+1,self.num_ops):
-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out) except *:
-        """
-        Chapter 12.2 Eq. (2.18),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-        cdef complex[::1] L0a = self.buffer_1d[1, :]
-        _zero(a)
-        _zero_2d(b)
-        _zero_3d(Lb)
-        _zero_2d(L0b)
-        _zero_2d(La)
-        _zero_4d(LLb)
-        _zero(L0a)
-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-                   dtype=complex)
-        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
-                  dtype=complex)
-        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
-
-        cdef int i,j,k
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-        copy(vec, vec_t)
-        _axpy(0.5, a, vec_t)
-        for i in range(self.num_ops):
-            _axpy(dw[i], b[i,:], vec_t)
-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
-            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
-            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-                        LLb[i,i,i,:], vec_t)
-            for j in range(i+1,self.num_ops):
-                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
-                for k in range(j+1,self.num_ops):
-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
-        copy(vec_t, guess)
-        _axpy(0.5, a, guess)
-
-        self.implicit(t+dt, vec_t, out, guess)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void platen15(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 11.2 Eq. (2.13)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j, k
-        cdef double sqrt_dt = np.sqrt(dt)
-        cdef double sqrt_dt_inv = 1./sqrt_dt
-        cdef double ddz, ddw, ddd
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-
-        cdef complex[::1] d1 = self.buffer_1d[0,:]
-        cdef complex[::1] d1p = self.buffer_1d[1,:]
-        cdef complex[::1] d1m = self.buffer_1d[2,:]
-        cdef complex[::1] V = self.buffer_1d[3,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
-        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
-        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
-        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
-        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
-        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
-        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
-        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
-
-        _zero(d1)
-        _zero_2d(d2)
-        _zero_2d(dd2)
-        self.d1(t, vec, d1)
-        self.d2(t, vec, d2)
-        self.d2(t + dt, vec, dd2)
-        # Euler part
-        copy(vec,out)
-        _axpy(1., d1, out)
-        for i in range(self.num_ops):
-            _axpy(dw[i], d2[i,:], out)
-
-        _zero(V)
-        _axpy(1., vec, V)
-        _axpy(1./self.num_ops, d1, V)
-
-        _zero_2d(v2p)
-        _zero_2d(v2m)
-        for i in range(self.num_ops):
-            _axpy(1., V, v2p[i,:])
-            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
-            _axpy(1., V, v2m[i,:])
-            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
-
-        _zero_3d(p2p)
-        _zero_3d(p2m)
-        for i in range(self.num_ops):
-            _zero_2d(d2p)
-            _zero_2d(d2m)
-            self.d2(t, v2p[i,:], d2p)
-            self.d2(t, v2m[i,:], d2m)
-            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
-            _axpy( ddw, d2p[i,:], out)
-            _axpy(-ddw, d2m[i,:], out)
-            for j in range(self.num_ops):
-                _axpy(      1., v2p[i,:], p2p[i,j,:])
-                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
-                _axpy(      1., v2p[i,:], p2m[i,j,:])
-                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
-
-        _axpy(-0.5*(self.num_ops), d1, out)
-        for i in range(self.num_ops):
-            ddz = dz[i]*0.5/sqrt_dt  # 1.5
-            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
-            _zero(d1p)
-            _zero(d1m)
-            _zero_2d(d2m)
-            _zero_2d(d2p)
-            _zero_2d(d2pp)
-            _zero_2d(d2mm)
-            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
-            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
-            self.d2(t, v2p[i,:], d2p)
-            self.d2(t, v2m[i,:], d2m)
-            self.d2(t, p2p[i,i,:], d2pp)
-            self.d2(t, p2m[i,i,:], d2mm)
-
-            _axpy( ddz+0.25, d1p, out)
-            _axpy(-ddz+0.25, d1m, out)
-
-            _axpy((dw[i]-dz[i]), dd2[i,:], out)
-            _axpy((dz[i]-dw[i]), d2[i,:], out)
-
-            _axpy( ddd, d2pp[i,:], out)
-            _axpy(-ddd, d2mm[i,:], out)
-            _axpy(-ddd, d2p[i,:], out)
-            _axpy( ddd, d2m[i,:], out)
-
-            for j in range(self.num_ops):
-              ddw = 0.5*(dw[j]-dz[j]) # 1.5
-              _axpy(ddw, d2p[j,:], out)
-              _axpy(-2*ddw, d2[j,:], out)
-              _axpy(ddw, d2m[j,:], out)
-
-              if j>i:
-                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
-                _axpy( ddw, d2p[j,:], out)
-                _axpy(-ddw, d2m[j,:], out)
-
-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-                _zero_2d(d2pp)
-                _zero_2d(d2mm)
-                self.d2(t, p2p[j,i,:], d2pp)
-                self.d2(t, p2m[j,i,:], d2mm)
-                _axpy( ddw, d2pp[j,:], out)
-                _axpy(-ddw, d2mm[j,:], out)
-                _axpy(-ddw, d2p[j,:], out)
-                _axpy( ddw, d2m[j,:], out)
-
-                for k in range(j+1,self.num_ops):
-                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
-                    _axpy( ddw, d2pp[k,:], out)
-                    _axpy(-ddw, d2mm[k,:], out)
-                    _axpy(-ddw, d2p[k,:], out)
-                    _axpy( ddw, d2m[k,:], out)
-
-              if j<i:
-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-                _zero_2d(d2pp)
-                _zero_2d(d2mm)
-                self.d2(t, p2p[j,i,:], d2pp)
-                self.d2(t, p2m[j,i,:], d2mm)
-                _axpy( ddw, d2pp[j,:], out)
-                _axpy(-ddw, d2mm[j,:], out)
-                _axpy(-ddw, d2p[j,:], out)
-                _axpy( ddw, d2m[j,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void taylor20(self, double t, double dt, double[::1] noise,
-                           complex[::1] vec, complex[::1] out):
-        """
-        Chapter 10.5 Eq. (5.1),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef double[::1] noises = np.empty(5)
-        cdef double dwn
-        self.order2noise.order2(noise,noises)
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[::1] b = self.buffer_1d[1, :]
-        cdef complex[::1] Lb = self.buffer_1d[2, :]
-        cdef complex[::1] La = self.buffer_1d[3, :]
-        cdef complex[::1] L0b = self.buffer_1d[4, :]
-        cdef complex[::1] LLb = self.buffer_1d[5, :]
-        cdef complex[::1] L0a = self.buffer_1d[6, :]
-        cdef complex[::1] LLa = self.buffer_1d[7, :]
-        cdef complex[::1] LL0b = self.buffer_1d[8, :]
-        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
-        cdef complex[::1] LLLb = self.buffer_1d[10, :]
-        _zero(a)
-        _zero(b)
-        _zero(Lb)
-        _zero(La)
-        _zero(L0b)
-        _zero(LLb)
-        _zero(L0a)
-        _zero(LLa)
-        _zero(LL0b)
-        _zero(L0Lb)
-        _zero(LLLb)
-        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
-                           L0a, LLa, LL0b, L0Lb, LLLb)
-
-        copy(vec,out)
-        _axpy(1.0, a, out)
-
-        _axpy(noises[0], b, out)
-        dwn = noises[0]*noises[0]*0.5
-        _axpy(dwn, Lb, out)
-
-        _axpy(noises[1], La, out)
-        _axpy(noises[0]-noises[1], L0b, out)
-        dwn *= noises[0]*(1/3.)
-        _axpy(dwn, LLb, out)
-        _axpy(0.5, L0a, out)
-
-        _axpy(noises[2], L0Lb, out)
-        _axpy(noises[3], LL0b, out)
-        _axpy(noises[4], LLa, out)
-        dwn *= noises[0]*0.25
-        _axpy(dwn, LLLb, out)
-
-
-cdef class SSESolver(StochasticSolver):
-    """stochastic Schrodinger system"""
-    cdef QobjEvo L
-    cdef object c_ops
-    cdef object cpcd_ops
-    cdef object imp
-    cdef double tol, imp_t
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.cpcd_ops = []
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op[0])
-            self.cpcd_ops.append(op[1])
-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-            self.tol = sso.tol
-            self.imp = LinearOperator( (self.l_vec,self.l_vec),
-                                      matvec=self.implicit_op, dtype=complex)
-
-    def implicit_op(self, vec):
-        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
-        self.d1(self.imp_t, vec, out)
-        cdef int i
-        _scale(-0.5,out)
-        _axpy(1.,vec,out)
-        return out
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
-        cdef int i
-        cdef complex e
-        cdef QobjEvo c_op
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        _zero(temp)
-        for i in range(self.num_ops):
-            c_op = self.cpcd_ops[i]
-            e = c_op.expect_data(t, _dense_wrap(vec))
-            _zero(temp)
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
-            _axpy(-0.125 * e * e * self.dt, vec, out)
-            _axpy(0.5 * e * self.dt, temp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-        cdef int i, k
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
-            c_op = self.cpcd_ops[i]
-            expect = c_op.expect_data(t, _dense_wrap(vec))
-            _axpy(-0.5*expect,vec,out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivatives(self, double t, int deg, complex[::1] vec,
-                          complex[::1] a, complex[:, ::1] b,
-                          complex[:, :, ::1] Lb, complex[:,::1] La,
-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                          complex[::1] L0a):
-        """
-        combinaisons of a and b derivatives for taylor order 1.5
-        dY ~ a dt + bi dwi
-                                         deg   use        noise
-        b[i.:]       bi                   >=0   d2 euler   dwi
-        a[:]         a                    >=0   d1 euler   dt
-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-
-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-        La[i,:]      ba'                  >=2   taylor15   dzi
-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-        """
-        cdef int i, j, k, l
-        cdef double dt = self.dt
-        cdef QobjEvo c_op
-        cdef complex e, de_bb
-
-        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
-        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
-        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
-        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
-        _zero_3d(dde_bb)
-        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
-        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-        _zero(temp)
-        _zero(temp2)
-        _zero_2d(Cvec)
-        _zero_3d(Cb)
-
-        # a b
-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
-            e = _dotc(vec,Cvec[i,:])
-            e_real[i] = e.real
-            _axpy(1., Cvec[i,:], b[i,:])
-            _axpy(-e_real[i], vec, b[i,:])
-            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
-            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
-
-        #Lb bb'
-        if deg >= 1:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            for j in range(self.num_ops):
-              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
-              for k in range(self.l_vec):
-                  temp[k] = conj(b[j,k])
-                  temp2[k] = 0.
-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
-                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-              _axpy(1., Cb[i,j,:], Lb[i,j,:])
-              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
-              _axpy(-de_b[i,j], vec, Lb[i,j,:])
-
-              for k in range(self.num_ops):
-                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
-                                  _dot(b[k,:], Cb[i,j,:]) + \
-                                  conj(_dotc(b[k,:], temp2)))*.5
-                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
-
-        #L0b La LLb
-        if deg >= 2:
-          for i in range(self.num_ops):
-              #ba'
-              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-              for j in range(self.num_ops):
-                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
-                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
-                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
-                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
-
-              #ab' + db/dt + bbb"/2
-              c_op = self.c_ops[i]
-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
-              for k in range(self.l_vec):
-                  temp[k] = conj(a[k])
-                  temp2[k] = 0.
-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
-                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-              _axpy(-e_real[i], a, L0b[i,:])
-              _axpy(-de_a[i], vec, L0b[i,:])
-
-              temp = np.zeros(self.l_vec, dtype=complex)
-              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
-              e = _dotc(vec,temp)
-              _axpy(1., temp, L0b[i,:])
-              _axpy(-e.real, vec, L0b[i,:])
-              _axpy(-1., b[i,:], L0b[i,:])
-
-              for j in range(self.num_ops):
-                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
-                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
-
-              #b(bb"+b'b')
-              for j in range(i,self.num_ops):
-                  for k in range(j, self.num_ops):
-                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
-                                  _dense_wrap(LLb[i,j,k,:]))
-                      for l in range(self.l_vec):
-                          temp[l] = conj(Lb[j,k,l])
-                          temp2[l] = 0.
-                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
-                               _dot(Lb[j,k,:], Cvec[i,:]) + \
-                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
-                               _dotc(vec, temp2)))*0.5
-                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
-                      _axpy(-de_bb, vec, LLb[i,j,k,:])
-                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
-                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
-                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
-
-        #da/dt + aa' + bba"
-        if deg == 2:
-          self.d1(t + dt, vec, L0a)
-          _axpy(-1.0, a, L0a)
-          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-          for j in range(self.num_ops):
-              c_op = self.c_ops[j]
-              temp = np.zeros(self.l_vec, dtype=complex)
-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
-              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
-              _axpy(e_real[j] * dt, temp, L0a[:])
-              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
-              for i in range(self.num_ops):
-                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
-                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
-                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
-                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
-                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
-                         complex[::1] vec, complex[::1] out):
-        cdef int k
-        cdef complex[::1] temp = self.func_buffer_1d[13,:]
-        for k in range(self.l_vec):
-            temp[k] = conj(vec[k])
-            out[k] = 0.
-        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivativesO2(self, double t, complex[::1] psi,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """
-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-        Use Stratonovich-Taylor expansion.
-        One one sc_ops
-        dY ~ a dt + bi dwi
-
-        b[:]     b                        d2 euler    dw
-        a[:]     a- Lb/2                  d1 euler    dt
-        Lb[:]    b'b                      milstein    dw^2/2
-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-
-        LLa[:]   ...                      taylor2.0   dwdt-dz
-        LL0b[:]  ...                      taylor2.0   dz
-        L0Lb[:]  ...                      taylor2.0   dw^3/6
-        LLLb[:]  ...                      taylor2.0   dt^2/2
-        """
-        cdef double dt = self.dt
-        cdef QobjEvo c_op = self.c_ops[0]
-        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
-        cdef complex de_a, dde_ba, de_La, de_L0b
-
-        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
-        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
-        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
-        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
-        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
-        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
-        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
-        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
-        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
-        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
-        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
-        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
-        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
-        _zero(Cpsi)
-        _zero(Cb)
-        _zero(CLb)
-        _zero(CLLb)
-        _zero(Ca)
-        _zero(CLa)
-        _zero(CL0b)
-
-        # b
-        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
-        e = _dotc(psi, Cpsi).real
-        _axpy(1., Cpsi, b)
-        _axpy(-e, psi, b)
-
-        # Lb
-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
-        self._c_vec_conj(t, c_op, b, Cbc)
-        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
-                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
-        _axpy(1., Cb, Lb)
-        _axpy(-e, b, Lb)
-        _axpy(-de_b, psi, Lb)
-
-        # LLb = b'b'b + b"bb
-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
-        self._c_vec_conj(t, c_op, Lb, CLbc)
-        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
-                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
-        _axpy(1, CLb, LLb)      # b'b'b
-        _axpy(-e, Lb, LLb)      # b'b'b
-        _axpy(-de_Lb, psi, LLb) # b'b'b
-        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
-        _axpy(-dde_bb, psi, LLb) # b"bb
-        _axpy(-de_b*2, b, LLb)   # b"bb
-
-        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
-        self._c_vec_conj(t, c_op, LLb, CLLbc)
-        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
-                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
-        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
-                    conj(_dotc(b, CLbc)))*.5
-        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
-        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
-        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
-        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
-        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
-        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
-        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
-
-        # a
-        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
-        _axpy(-0.5 * e * e * dt, psi, a)
-        _axpy(e * dt, Cpsi, a)
-        _axpy(-0.5 * dt, Lb, a)
-
-        #La
-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-        _axpy(-0.5 * e * e * dt, b, La)
-        _axpy(-e * de_b * dt, psi, La)
-        _axpy(e * dt, Cb, La)
-        _axpy(de_b * dt, Cpsi, La)
-        _axpy(-0.5 * dt, LLb, La)
-
-        #LLa
-        _axpy(-2 * e * de_b * dt, b, LLa)
-        _axpy(-de_b * de_b * dt, psi, LLa)
-        _axpy(-e * dde_bb * dt, psi, LLa)
-        _axpy( 2 * de_b * dt, Cb, LLa)
-        _axpy( dde_bb * dt, Cpsi, LLa)
-
-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-        _axpy(-de_Lb * e * dt, psi, LLa)
-        _axpy(-0.5 * e * e * dt, Lb, LLa)
-        _axpy( de_Lb * dt, Cpsi, LLa)
-        _axpy( e * dt, CLb, LLa)
-
-        _axpy(-0.5 * dt, LLLb, LLa)
-
-        # L0b = b'a
-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
-        self._c_vec_conj(t, c_op, a, Cac)
-        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
-                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
-        _axpy(1.0, Ca, L0b)
-        _axpy(-e, a, L0b)
-        _axpy(-de_a, psi, L0b)
-
-        # LL0b = b"ba + b'La
-        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
-                    conj(_dotc(b, Cac)))*.5
-        _axpy(-dde_ba, psi, LL0b)
-        _axpy(-de_a, b, LL0b)
-        _axpy(-de_b, a, LL0b)
-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
-        self._c_vec_conj(t, c_op, La, CLac)
-        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
-                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
-        _axpy(1., CLa, LL0b)
-        _axpy(-e, La, LL0b)
-        _axpy(-de_La, psi, LL0b)
-
-        # L0Lb = b"ba + b'L0b
-        _axpy(-dde_ba, psi, L0Lb)
-        _axpy(-de_a, b, L0Lb)
-        _axpy(-de_b, a, L0Lb)
-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
-        self._c_vec_conj(t, c_op, L0b, CL0bc)
-        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
-                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
-        _axpy(1., CL0b, L0Lb)
-        _axpy(-e, L0b, L0Lb)
-        _axpy(-de_L0b, psi, L0Lb)
-
-        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
-        self.d1(t + dt, psi, L0a) # da/dt
-        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
-        _axpy(-1.0, a, L0a)        # da/dt
-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
-        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
-        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
-        _axpy(e * dt, Ca, L0a)              # a'_a_
-        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
-        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
-
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                                        complex[::1] out,
-                                        np.ndarray[complex, ndim=1] guess) except *:
-        # np.ndarray to memoryview is OK but not the reverse
-        # scipy function only take np array, not memoryview
-        self.imp_t = t
-        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
-                                          tol=self.tol, atol=1e-12)
-        cdef int i
-        copy(spout, out)
-
-
-cdef class SMESolver(StochasticSolver):
-    """stochastic master equation system"""
-    cdef QobjEvo L
-    cdef object imp
-    cdef object c_ops
-    cdef int N_root
-    cdef double tol
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.N_root = np.sqrt(self.l_vec)
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op)
-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-            self.tol = sso.tol
-            self.imp = sso.imp
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-    @cython.boundscheck(False)
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef int i, k
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-            expect = self.expect(out[i,:])
-            _axpy(-expect, rho, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
-                          complex[::1] a, complex[:, ::1] b,
-                          complex[:, :, ::1] Lb, complex[:,::1] La,
-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                          complex[::1] L0a):
-        """
-        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
-        dY ~ a dt + bi dwi
-                                         deg   use        noise
-        b[i.:]       bi                   >=0   d2 euler   dwi
-        a[:]         a                    >=0   d1 euler   dt
-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-        La[i,:]      ba'                  >=2   taylor15   dzi
-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-        """
-        cdef int i, j, k
-        cdef QobjEvo c_op
-        cdef QobjEvo c_opj
-        cdef complex trApp, trAbb, trAa
-        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
-        cdef complex[:, ::1] trAb = self.expect_buffer_2d
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        #_zero(temp)
-
-        # a
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-
-        # b
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            # bi
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
-            trAp[i] = self.expect(b[i,:])
-            _axpy(-trAp[i], rho, b[i,:])
-
-        # Libj = bibj', i<=j
-        # sc_ops must commute (Libj = Ljbi)
-        if deg >= 1:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            for j in range(i, self.num_ops):
-                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
-                trAb[i,j] = self.expect(Lb[i,j,:])
-                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
-                _axpy(-trAb[i,j], rho, Lb[i,j,:])
-
-        # L0b La LLb
-        if deg >= 2:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            # Lia = bia'
-            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-
-            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
-            # db/dt
-            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
-            trApp = self.expect(L0b[i,:])
-            _axpy(-trApp, rho, L0b[i,:])
-            _axpy(-1, b[i,:], L0b[i,:])
-            # ab'
-            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
-            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-            trAa = self.expect(temp)
-            _axpy(1., temp, L0b[i,:])
-            _axpy(-trAp[i], a[:], L0b[i,:])
-            _axpy(-trAa, rho, L0b[i,:])
-            # bbb" : trAb[i,j] only defined for j>=i
-            for j in range(i):
-                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-            for j in range(i,self.num_ops):
-                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-
-            # LLb
-            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
-            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
-            for j in range(i,self.num_ops):
-              for k in range(j,self.num_ops):
-                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
-                trAbb = self.expect(LLb[i,j,k,:])
-                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
-                _axpy(-trAbb, rho, LLb[i,j,k,:])
-                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
-                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
-
-        # L0a = a'a + da/dt + bba"/2  (a" = 0)
-        if deg == 2:
-            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-            _axpy(-1, a, L0a)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivativesO2(self, double t, complex[::1] rho,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """
-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-        Use Stratonovich-Taylor expansion.
-        One one sc_ops
-        dY ~ a dt + bi dwi
-
-        b[:]     b                        d2 euler    dw
-        a[:]     a- Lb/2                  d1 euler    dt
-        Lb[:]    b'b                      milstein    dw^2/2
-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-
-        LLa[:]   ...                      taylor2.0   dwdt-dz
-        LL0b[:]  ...                      taylor2.0   dz
-        L0Lb[:]  ...                      taylor2.0   dw^3/6
-        LLLb[:]  ...                      taylor2.0   dt^2/2
-        """
-        cdef int i, j, k
-        cdef QobjEvo c_op = self.c_ops[0]
-        cdef QobjEvo c_opj
-        cdef complex trAp, trApt
-        cdef complex trAb, trALb, trALLb
-        cdef complex trAa, trALa
-        cdef complex trAL0b
-
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-
-        # b
-        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
-        trAp = self.expect(b)
-        _axpy(-trAp, rho, b)
-
-        # Lb = b'b
-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
-        trAb = self.expect(Lb)
-        _axpy(-trAp, b, Lb)
-        _axpy(-trAb, rho, Lb)
-
-        # LLb = b'Lb+b"bb
-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
-        trALb = self.expect(LLb)
-        _axpy(-trAp, Lb, LLb)
-        _axpy(-trALb, rho, LLb)
-        _axpy(-trAb*2, b, LLb)
-
-        # LLLb = b'LLb + 3 b"bLb + b"'bbb
-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
-        trALLb = self.expect(LLLb)
-        _axpy(-trAp, LLb, LLLb)
-        _axpy(-trALLb, rho, LLLb)
-        _axpy(-trALb*3, b, LLLb)
-        _axpy(-trAb*3, Lb, LLLb)
-
-        # _a_ = a - Lb/2
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-        _axpy(-0.5*self.dt, Lb, a)
-
-        # L_a_ = ba' - LLb/2
-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-        _axpy(-0.5*self.dt, LLb, La)
-
-        # LL_a_ = b(La)' - LLLb/2
-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-        _axpy(-0.5*self.dt, LLLb, LLa)
-
-        # _L0_b = b'(_a_)
-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
-        trAa = self.expect(L0b)
-        _axpy(-trAp, a, L0b)
-        _axpy(-trAa, rho, L0b)
-
-        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
-        trAL0b = self.expect(L0Lb)
-        _axpy(-trAp, L0b, L0Lb)
-        _axpy(-trAL0b, rho, L0Lb)
-        _axpy(-trAa, b, L0Lb)
-        _axpy(-trAb, a, L0Lb)
-
-        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
-        trAL0b = self.expect(LL0b)
-        _axpy(-trAp, La, LL0b)
-        _axpy(-trAL0b, rho, LL0b)
-        _axpy(-trAa, b, LL0b)
-        _axpy(-trAb, a, LL0b)
-
-        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
-        _axpy(-1, a, L0a)
-        _axpy(-self.dt*0.5, L0Lb, L0a)
-
-
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                                        complex[::1] out,
-                                        np.ndarray[complex, ndim=1] guess) except *:
-        # np.ndarray to memoryview is OK but not the reverse
-        # scipy function only take np array, not memoryview
-        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
-                                          dvec, x0=guess,
-                                          tol=self.tol, atol=1e-12)
-        cdef int i
-        copy(spout,out)
-
-
-cdef class PcSSESolver(StochasticSolver):
-    """photocurrent for Schrodinger equation"""
-    cdef QobjEvo L
-    cdef object c_ops
-    cdef object cdc_ops
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.cdc_ops = []
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op[0])
-            self.cdc_ops.append(op[1])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double rand
-        cdef int i, which = -1
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] d2 = self.buffer_1d[0,:]
-
-        copy(vec, out)
-        self.d1(t, vec, out)
-        rand = np.random.rand()
-        for i in range(self.num_ops):
-            c_op = self.cdc_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-            if expects[i].real * dt >= 1e-15:
-                rand -= expects[i].real *dt
-            if rand < 0:
-                which = i
-                noise[i] = 1.
-                break
-
-        if which >= 0:
-            self.collapse(t, which, expects[which].real, vec, d2)
-            _axpy(1, d2, out)
-            _axpy(-1, vec, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double expect
-        cdef int i, which=0, num_coll=0, did_collapse=0
-        cdef complex[::1] tmp = self.buffer_1d[0,:]
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef np.ndarray[int, ndim=1] colls
-
-        # Collapses are computed first
-        for i in range(self.num_ops):
-            c_op = self.cdc_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-            if expects[i].real > 0:
-                did_collapse = np.random.poisson(expects[i].real * dt)
-                num_coll += did_collapse
-                if did_collapse:
-                    which = i
-                noise[i] = did_collapse * 1.
-            else:
-                noise[i] = 0.
-
-        if num_coll == 0:
-            pass
-        elif num_coll == 1:
-            # Do one collapse
-            self.collapse(t, which, expects[which].real, vec, out)
-            copy(out, vec)
-        elif num_coll and noise[which] == num_coll:
-            # Do many collapse of one sc_ops.
-            # Recompute the expectation value, but only to check for zero.
-            c_op = self.cdc_ops[which]
-            for i in range(num_coll):
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, which, expect, vec, out)
-                    copy(out,vec)
-        elif num_coll >= 2:
-            # 2 or more collapses of different operators
-            # Ineficient, should be rare
-            coll = []
-            for i in range(self.num_ops):
-                coll += [i]*int(noise[i])
-            np.random.shuffle(coll)
-            for i in coll:
-                c_op = self.cdc_ops[i]
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, i, expect, vec, out)
-                    copy(out,vec)
-        copy(vec,tmp)
-        copy(vec,out)
-        self.d1(t, vec, tmp)
-        self.d1(t+dt, tmp, out)
-        _scale(0.5, out)
-        _axpy(0.5, tmp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        cdef int i
-        cdef complex e
-        cdef QobjEvo c_op
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        for i in range(self.num_ops):
-            _zero(temp)
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-            e = _dznrm2(temp)
-            _axpy(0.5 * e * e * self.dt, vec, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
-            expect = _dznrm2(out[i,:])
-            if expect.real >= 1e-15:
-                _zscale(1/expect, out[i,:])
-            else:
-                _zero(out[i,:])
-            _axpy(-1, vec, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void collapse(self, double t, int which, double expect,
-                       complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        c_op = self.c_ops[which]
-        _zero(out)
-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        _zscale(1/expect, out)
-
-
-cdef class PcSMESolver(StochasticSolver):
-    """photocurrent for master equation"""
-    cdef QobjEvo L
-    cdef object cdcr_cdcl_ops
-    cdef object cdcl_ops
-    cdef object clcdr_ops
-    cdef int N_root
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.cdcr_cdcl_ops = []
-        self.cdcl_ops = []
-        self.clcdr_ops = []
-        self.N_root = np.sqrt(self.l_vec)
-        for i, op in enumerate(c_ops):
-            self.cdcr_cdcl_ops.append(op[0])
-            self.cdcl_ops.append(op[1])
-            self.clcdr_ops.append(op[2])
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent(self, double t, double dt,  double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double rand
-        cdef int i, which = -1
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] d2 = self.buffer_1d[0,:]
-
-        copy(vec, out)
-        self.d1(t, vec, out)
-        rand = np.random.rand()
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-            if expects[i].real * dt >= 1e-15:
-                rand -= expects[i].real *dt
-            if rand < 0:
-                which = i
-                noise[i] = 1.
-                break
-
-        if which >= 0:
-            self.collapse(t, which, expects[which].real, vec, d2)
-            _axpy(1, d2, out)
-            _axpy(-1, vec, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef int i, which, num_coll=0, did_collapse
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] tmp = self.buffer_1d[0,:]
-        cdef double expect
-        cdef np.ndarray[int, ndim=1] colls
-
-        # Collapses are computed first
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-            if expects[i].real > 0:
-                did_collapse = np.random.poisson(expects[i].real* dt)
-                num_coll += did_collapse
-                if did_collapse:
-                    which = i
-                noise[i] = did_collapse * 1.
-            else:
-                noise[i] = 0.
-
-        if num_coll == 0:
-            pass
-        elif num_coll == 1:
-            # Do one collapse
-            self.collapse(t, which, expects[which].real, vec, out)
-            copy(out,vec)
-        elif noise[which] == num_coll:
-            # Do many collapse of one sc_ops.
-            # Recompute the expectation value, but only to check for zero.
-            c_op = self.clcdr_ops[which]
-            for i in range(num_coll):
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, which, expect, vec, out)
-                    copy(out,vec)
-        elif num_coll >= 2:
-            # 2 or more collapses of different operators
-            # Ineficient, should be rare
-            coll = []
-            for i in range(self.num_ops):
-                coll += [i] * int(noise[i])
-            np.random.shuffle(coll)
-            for i in coll:
-                c_op = self.clcdr_ops[i]
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, i, expect, vec, out)
-                    copy(out,vec)
-
-        copy(vec,tmp)
-        copy(vec,out)
-        self.d1(t, vec, tmp)
-        self.d1(t+dt, tmp, out)
-        _scale(0.5, out)
-        _axpy(0.5, tmp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-    @cython.boundscheck(False)
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex[::1] crho = self.func_buffer_1d[0,:]
-        cdef complex expect
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-        for i in range(self.num_ops):
-            c_op = self.cdcr_cdcl_ops[i]
-            _zero(crho)
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
-            expect = self.expect(crho)
-            _axpy(0.5*expect* self.dt, rho, out)
-            _axpy(-0.5* self.dt, crho, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-            expect = self.expect(out[i,:])
-            if expect.real >= 1e-15:
-                _zscale((1.+0j)/expect, out[i,:])
-            else:
-                _zero(out[i,:])
-            _axpy(-1, rho, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void collapse(self, double t, int which, double expect,
-                       complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        c_op = self.clcdr_ops[which]
-        _zero(out)
-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        _zscale(1./expect, out)
-
-cdef class PmSMESolver(StochasticSolver):
-    """positive map for master equation"""
-    cdef object L
-    cdef QobjEvo pp_ops
-    cdef QobjEvo preLH
-    cdef QobjEvo postLH
-    cdef object sops
-    cdef object preops
-    cdef object postops
-    cdef object preops2
-    cdef object postops2
-    cdef int N_root
-
-    def set_data(self, sso):
-        c_ops = sso.sops
-        self.l_vec = sso.pp.shape[0]
-        self.num_ops = len(c_ops)
-        self.preLH = sso.preLH
-        self.postLH = sso.postLH
-        self.pp_ops = sso.pp
-        self.sops = [op for op in sso.sops]
-        self.preops = [op for op in sso.preops]
-        self.postops = [op for op in sso.postops]
-        self.preops2 = [op for op in sso.preops2]
-        self.postops2 = [op for op in sso.postops2]
-        self.N_root = np.sqrt(self.l_vec)
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void rouchon(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
-        cdef complex[::1] temp = self.buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.buffer_1d[1,:]
-        cdef int i, j, k
-        cdef QobjEvo c_op, c_opj
-        cdef complex ddw, tr
-        _zero(out)
-        _zero(temp)
-        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-        for i in range(self.num_ops):
-            c_op = self.sops[i]
-            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
-            c_op = self.preops[i]
-            _zero(temp2)
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-            _axpy(dy[i], temp2, temp)
-
-        k = 0
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                c_op = self.preops2[k]
-                if i == j:
-                    ddw = (dy[i]*dy[j] - dt) *0.5
-                else:
-                    ddw = (dy[i]*dy[j])
-
-                _zero(temp2)
-                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-                _axpy(ddw, temp2, temp)
-                k += 1
-
-        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-        for i in range(self.num_ops):
-            dy[i] = conj(dy[i])
-            c_op = self.postops[i]
-            _zero(temp2)
-            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-            _axpy(dy[i], temp2, out)
-
-        k = 0
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                c_op = self.postops2[k]
-                if i == j:
-                    ddw = (dy[i]*dy[j] - dt) *0.5
-                else:
-                    ddw = (dy[i]*dy[j])
-                _zero(temp2)
-                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-                _axpy(ddw, temp2, out)
-                k += 1
-
-        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        tr = self.expect(out)
-        _zscale(1./tr, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-
-cdef class GenericSSolver(StochasticSolver):
-    """support for user defined system"""
-    cdef object d1_func, d2_func
-
-    def set_data(self, sso):
-        self.l_vec = sso.rho0.shape[0]
-        self.num_ops = len(sso.sops)
-        self.d1_func = sso.d1
-        self.d2_func = sso.d2
-
-
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        cdef np.ndarray[complex, ndim=1] in_np
-        cdef np.ndarray[complex, ndim=1] out_np
-        in_np = np.zeros((self.l_vec, ), dtype=complex)
-        copy(rho, in_np)
-        out_np = self.d1_func(t, in_np)
-        _axpy(self.dt, out_np, out) # d1 is += and * dt
-
-    @cython.boundscheck(False)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef np.ndarray[complex, ndim=1] in_np
-        cdef np.ndarray[complex, ndim=2] out_np
-        cdef int i
-        in_np = np.zeros((self.l_vec, ), dtype=complex)
-        copy(rho, in_np)
-        out_np = self.d2_func(t, in_np)
-        for i in range(self.num_ops):
-            copy(out_np[i,:], out[i,:])
+#cython: language_level=3
+
+import numpy as np
+cimport numpy as np
+cimport cython
+from cpython.exc cimport PyErr_CheckSignals
+from libc.math cimport fabs
+from qutip.core.cy.qobjevo cimport QobjEvo
+from .. import Qobj, unstack_columns
+import scipy.sparse as sp
+from scipy.sparse.linalg import LinearOperator
+from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
+from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
+
+from qutip.core.data cimport dense, Dense
+import qutip.core.data as _data
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+cdef int ZERO=0
+cdef double DZERO=0
+cdef complex ZZERO=0j
+cdef int ONE=1
+
+"""Some of blas wrapper"""
+@cython.boundscheck(False)
+cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
+    """ y += a*x"""
+    cdef int l = x.shape[0]
+    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void copy(complex[::1] x, complex[::1] y):
+    """ y = x """
+    cdef int l = x.shape[0]
+    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef complex _dot(complex[::1] x, complex[::1] y):
+    """ = x_i * y_i """
+    cdef int l = x.shape[0]
+    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef complex _dotc(complex[::1] x, complex[::1] y):
+    """ = conj(x_i) * y_i """
+    cdef int l = x.shape[0]
+    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef double _dznrm2(complex[::1] vec):
+    """ = sqrt( x_i**2 ) """
+    cdef int l = vec.shape[0]
+    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _scale(double a, complex[::1] x):
+    """ x *= a """
+    cdef int l = x.shape[0]
+    zdscal(&l, &a, <complex*>&x[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zscale(complex a, complex[::1] x):
+    """ x *= a """
+    cdef int l = x.shape[0]
+    zscal(&l, &a, <complex*>&x[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero(complex[::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]
+    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero_2d(complex[:,::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]*x.shape[1]
+    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero_3d(complex[:,:,::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
+    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero_4d(complex[:,:,:,::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
+    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
+
+@cython.boundscheck(False)
+@cython.initializedcheck(False)
+cdef Dense _dense_wrap(double complex [::1] x):
+    return dense.wrap(&x[0], x.shape[0], 1)
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%
+# functions for ensuring that the states stay physical
+@cython.cdivision(True)
+@cython.boundscheck(False)
+cdef void _normalize_inplace(complex[::1] vec):
+    """ make norm of vec equal to 1"""
+    cdef int l = vec.shape[0]
+    cdef double norm = 1.0/_dznrm2(vec)
+    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
+
+# to move eventually, 10x faster than scipy's norm.
+@cython.cdivision(True)
+@cython.boundscheck(False)
+def normalize_inplace(complex[::1] vec):
+    """ make norm of vec equal to 1"""
+    cdef int l = vec.shape[0]
+    cdef double norm = 1.0/_dznrm2(vec)
+    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
+    return fabs(norm-1)
+
+@cython.cdivision(True)
+@cython.boundscheck(False)
+cdef void _normalize_rho(complex[::1] rho):
+    """ Ensure that the density matrix trace is one and
+    that the composing states are normalized.
+    """
+    cdef int l = rho.shape[0]
+    cdef int N = np.sqrt(l)
+    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
+    cdef complex[::1,:] eivec
+    cdef double[::1] eival = np.zeros(N)
+    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
+
+    _zero(rho)
+    cdef int i, j, k
+    cdef double sum
+
+    sum = 0.
+    for i in range(N):
+        _normalize_inplace(eivec[:,i])
+        if eival[i] < 0:
+            eival[i] = 0.
+        sum += eival[i]
+    if sum != 1.:
+        for i in range(N):
+            eival[i] /= sum
+
+    for i in range(N):
+        for j in range(N):
+            for k in range(N):
+                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
+
+# Available solvers:
+cpdef enum Solvers:
+  # order 0.5
+  EULER_SOLVER           =  50
+  # order 0.5 strong, 1.0 weak?
+  PC_SOLVER              = 101
+  PC_2_SOLVER            = 104
+  # order 1.0
+  PLATEN_SOLVER          = 100
+  MILSTEIN_SOLVER        = 102
+  MILSTEIN_IMP_SOLVER    = 103
+  # order 1.5
+  EXPLICIT1_5_SOLVER     = 150
+  TAYLOR1_5_SOLVER       = 152
+  TAYLOR1_5_IMP_SOLVER   = 153
+  # order 2.0
+  TAYLOR2_0_SOLVER       = 202
+
+  # Special solvers
+  PHOTOCURRENT_SOLVER    =  60
+  PHOTOCURRENT_PC_SOLVER = 110
+  ROUCHON_SOLVER         = 120
+
+  # For initialisation
+  SOLVER_NOT_SET         =   0
+
+
+cdef class TaylorNoise:
+    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
+    Complex enough that I fell it should be kept separated from the main solver.
+    """
+    cdef:
+      int p
+      double rho, alpha
+      double aFactor, bFactor
+      double BFactor, CFactor
+      double dt, dt_sqrt
+
+    @cython.cdivision(True)
+    def __init__(self, int p, double dt):
+        self.p = p
+        self.dt = dt
+        self.dt_sqrt = dt**.5
+        cdef double pi = np.pi
+        cdef int i
+
+        cdef double rho = 0.
+        for i in range(1,p+1):
+            rho += (i+0.)**-2
+        rho = 1./3.-2*rho/(pi**2)
+        self.rho = (rho)**.5
+        self.aFactor = -(2)**.5/pi
+
+        cdef double alpha = 0.
+        for i in range(1,p+1):
+            alpha += (i+0.)**-4
+        alpha = pi/180-alpha/(2*pi**2)/pi
+        self.alpha = (alpha)**.5
+        self.bFactor = (0.5)**.5/pi**2
+
+        self.BFactor = 1/(4*pi**2)
+        self.CFactor = -1/(2*pi**2)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cpdef void order2(self, double[::1] noise, double[::1] dws):
+        cdef int p = self.p
+        cdef int r, l
+        cdef double s = 1/6.
+        cdef double a = 0
+        cdef double b = 0
+        cdef double AA = 0
+        cdef double BB = 0
+        cdef double CC = 0
+
+        for r in range(p):
+            a += noise[3+r]/(r+1.)
+            b += noise[3+r+p]/(r+1.)/(r+1.)
+            BB += (1/(r+1.)/(r+1.)) *\
+                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
+            for l in range(p):
+                if r != l:
+                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
+                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
+                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
+
+        a = self.aFactor * a + self.rho * noise[1]
+        b = self.bFactor * b + self.alpha * noise[2]
+        AA = 0.25*a*a
+        BB *= self.BFactor
+        CC *= self.CFactor
+
+        dws[0] = noise[0]                       # dw
+        dws[1] = 0.5*(noise[0]+a)               # dz
+        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
+        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
+        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
+
+
+cdef class StochasticSolver:
+    """ stochastic solver class base
+    Does most of the initialisation, drive the simulation and contain the
+    stochastic integration algorythm that do not depend on the physics.
+
+    This class is not to be used as is, the function computing the evolution's
+    derivative are specified in it's child class which define the deterministic
+    and stochastic contributions.
+
+    PYTHON METHODS:
+    set_solver:
+      Receive the data for the integration.
+      Prepare buffers
+
+    cy_sesolve_single_trajectory:
+      Run one trajectory.
+
+
+    INTERNAL METHODS
+    make_noise:
+      create the stochastic noise
+    run:
+      evolution between timestep (substep)
+    solver's method:
+      stochastic integration algorithm
+        euler
+        milstein
+        taylor
+        ...
+
+    CHILD:
+    SSESolver: stochastic schrodinger evolution
+    SMESolver: stochastic master evolution
+    PcSSESolver: photocurrent stochastic schrodinger evolution
+    PcSMESolver: photocurrent stochastic master evolution
+    PmSMESolver: positive map stochastic master evolution
+    GenericSSolver: general (user defined) stochastic evolution
+
+    CHILD METHODS:
+    set_data:
+      Read data about the system
+    d1:
+      deterministic part
+    d2:
+      non-deterministic part
+    derivatives:
+      d1, d2 and their derivatives up to dt**1.5
+      multiple sc_ops
+    derivativesO2:
+      d1, d2 and there derivatives up to dt**2.0
+      one sc_ops
+    """
+    cdef int l_vec, num_ops
+    cdef Solvers solver
+    cdef int num_step, num_substeps, num_dw
+    cdef int normalize
+    cdef double dt
+    cdef int noise_type
+    cdef object custom_noise
+    cdef double[::1] dW_factor
+    cdef unsigned int[::1] seed
+    cdef object sso
+
+    # buffer to not redo the initialisation at each substep
+    cdef complex[:, ::1] buffer_1d
+    cdef complex[:, :, ::1] buffer_2d
+    cdef complex[:, :, :, ::1] buffer_3d
+    cdef complex[:, :, :, ::1] buffer_4d
+    cdef complex[:, ::1] expect_buffer_1d
+    cdef complex[:, ::1] expect_buffer_2d
+    cdef complex[:, :, ::1] expect_buffer_3d
+    cdef complex[:, ::1] func_buffer_1d
+    cdef complex[:, ::1] func_buffer_2d
+    cdef complex[:, :, ::1] func_buffer_3d
+
+    cdef TaylorNoise order2noise
+
+    def __init__(self):
+        self.l_vec = 0
+        self.num_ops = 0
+        self.solver = SOLVER_NOT_SET
+
+    def set_solver(self, sso):
+        """ Prepare the solver from the info in StochasticSolverOptions
+
+        Parameters
+        ----------
+        sso : StochasticSolverOptions
+            Data of the stochastic system
+        """
+        self.set_data(sso)
+        self.sso = sso
+
+        self.solver = sso.solver_code
+        self.dt = sso.dt
+        self.num_substeps = sso.nsubsteps
+        self.normalize = sso.normalize
+        self.num_step = len(sso.times)
+        self.num_dw = len(sso.sops)
+        if self.solver in [EXPLICIT1_5_SOLVER,
+                           TAYLOR1_5_SOLVER,
+                           TAYLOR1_5_IMP_SOLVER]:
+            self.num_dw *= 2
+        if self.solver in [TAYLOR2_0_SOLVER]:
+            self.num_dw *= 3 + 2*sso.p
+            self.order2noise = TaylorNoise(sso.p, self.dt)
+        # prepare buffers for the solvers
+        nb_solver = [0,0,0,0]
+        nb_func = [0,0,0]
+        nb_expect = [0,0,0]
+
+        # %%%%%%%%%%%%%%%%%%%%%%%%%
+        # Depending on the solver, determine the numbers of buffers of each
+        # shape to prepare. (~30% slower when not preallocating buffer)
+        # nb_solver : buffer to contain the states used by solver
+        # nb_func : buffer for states used used by d1, d2 and derivative functions
+        # nb_expect : buffer to store expectation values.
+        if self.solver is EULER_SOLVER:
+            nb_solver = [0,1,0,0]
+        elif self.solver is PHOTOCURRENT_SOLVER:
+            nb_solver = [1,0,0,0]
+            nb_func = [1,0,0]
+        elif self.solver is PLATEN_SOLVER:
+            nb_solver = [2,5,0,0]
+        elif self.solver is PC_SOLVER:
+            nb_solver = [4,1,1,0]
+        elif self.solver is MILSTEIN_SOLVER:
+            nb_solver = [0,1,1,0]
+        elif self.solver is MILSTEIN_IMP_SOLVER:
+            nb_solver = [1,1,1,0]
+        elif self.solver is PC_2_SOLVER:
+            nb_solver = [5,1,1,0]
+        elif self.solver is PHOTOCURRENT_PC_SOLVER:
+            nb_solver = [1,1,0,0]
+            nb_func = [1,0,0]
+        elif self.solver is ROUCHON_SOLVER:
+            nb_solver = [2,0,0,0]
+        elif self.solver is EXPLICIT1_5_SOLVER:
+            nb_solver = [5,8,3,0]
+        elif self.solver is TAYLOR1_5_SOLVER:
+            nb_solver = [2,3,1,1]
+        elif self.solver is TAYLOR1_5_IMP_SOLVER:
+            nb_solver = [2,3,1,1]
+        elif self.solver is TAYLOR2_0_SOLVER:
+            nb_solver = [11,0,0,0]
+
+        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
+                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+          if sso.me:
+            nb_func = [1,0,0]
+            nb_expect = [1,1,0]
+          else:
+            nb_func = [2,1,1]
+            nb_expect = [2,1,1]
+        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
+            nb_expect = [1,0,0]
+        elif self.solver is TAYLOR2_0_SOLVER:
+          if sso.me:
+            nb_func = [2,0,0]
+            nb_expect = [2,0,0]
+          else:
+            nb_func = [14,0,0]
+            nb_expect = [0,0,0]
+        elif self.solver is ROUCHON_SOLVER:
+            nb_expect = [1,0,0]
+        else:
+          if not sso.me:
+            nb_func = [1,0,0]
+
+        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
+        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
+                                  dtype=complex)
+        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
+                                        dtype=complex)
+        if nb_solver[3]:
+          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
+                                        dtype=complex)
+
+        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
+        if nb_expect[1]:
+          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
+        if nb_expect[2]:
+          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
+
+        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
+        if nb_func[1]:
+          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
+        if nb_func[2]:
+          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
+
+        self.noise_type = sso.noise_type
+        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
+        if self.noise_type == 1:
+            self.custom_noise = sso.noise
+        elif self.noise_type == 0:
+            self.seed = sso.noise
+
+    def set_data(self, sso):
+        """Set solver specific operator"""
+        pass
+
+    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
+        """Create the random numbers for the stochastic process"""
+        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
+            # photocurrent, just seed,
+            np.random.seed(self.seed[n])
+            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
+        if self.noise_type == 0:
+            np.random.seed(self.seed[n])
+            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
+                                   np.sqrt(self.dt)
+        elif self.noise_type == 1:
+            return self.custom_noise[n,:,:,:]
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    def cy_sesolve_single_trajectory(self, int n):
+        """ Run the one of the trajectories of the stochastic system.
+
+        Parameters
+        ----------
+        n : int
+            Number of the iterations
+
+        sso : StochasticSolverOptions
+            Data of the stochastic system
+
+        Returns
+        -------
+        states_list : list of qobj
+            State of the system at each time
+
+        noise : array
+            noise at each step of the solver
+
+        measurements : array
+            measurements value at each timestep for each m_ops
+
+        expect : array
+            expectation value at each timestep for each e_ops
+
+        """
+        sso = self.sso
+        cdef double[::1] times = sso.times
+        cdef complex[::1] rho_t
+        cdef double t
+        cdef int m_idx, t_idx, e_idx
+        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
+        cdef int tlast = times.shape[0]
+
+        rho_t = sso.rho0.copy()
+        dims = sso.state0.dims
+
+        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
+        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
+        states_list = []
+        for t_idx, t in enumerate(times):
+            PyErr_CheckSignals()
+            if sso.ce_ops:
+                for e_idx, e in enumerate(sso.ce_ops):
+                    s = e.expect_data(t, _dense_wrap(rho_t))
+                    expect[e_idx, t_idx] = s
+            if sso.store_states or not sso.ce_ops:
+                if sso.me:
+                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
+                        dims=dims))
+                else:
+                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
+
+            if t_idx != tlast-1:
+                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
+                                 rho_t, self.num_substeps)
+
+            if sso.store_measurement:
+                for m_idx, m in enumerate(sso.cm_ops):
+                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
+                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
+                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
+
+        if sso.method == 'heterodyne':
+            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
+
+        return states_list, noise, measurements, expect
+
+    @cython.boundscheck(False)
+    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
+                          complex[::1] vec, int num_substeps):
+        """ Do one time full step"""
+        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
+        cdef int i
+        if self.solver is EULER_SOLVER:
+            for i in range(num_substeps):
+                self.euler(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PHOTOCURRENT_SOLVER:
+            for i in range(num_substeps):
+                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PLATEN_SOLVER:
+            for i in range(num_substeps):
+                self.platen(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PC_SOLVER:
+            for i in range(num_substeps):
+                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is MILSTEIN_SOLVER:
+            for i in range(num_substeps):
+                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is MILSTEIN_IMP_SOLVER:
+            for i in range(num_substeps):
+                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PC_2_SOLVER:
+            for i in range(num_substeps):
+                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PHOTOCURRENT_PC_SOLVER:
+            for i in range(num_substeps):
+                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is ROUCHON_SOLVER:
+            for i in range(num_substeps):
+                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is EXPLICIT1_5_SOLVER:
+            for i in range(num_substeps):
+                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is TAYLOR1_5_SOLVER:
+            for i in range(num_substeps):
+                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is TAYLOR1_5_IMP_SOLVER:
+            for i in range(num_substeps):
+                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is TAYLOR2_0_SOLVER:
+            for i in range(num_substeps):
+                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        if self.normalize:
+            self._normalize_inplace(vec)
+        return vec
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_inplace(vec)
+
+    # Dummy functions
+    # Needed for compilation since ssesolve is not stand-alone
+    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
+        """ deterministic part of the evolution
+        depend on schrodinger vs master vs photocurrent
+        """
+        pass
+
+    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
+        """ stochastic part of the evolution
+        depend on schrodinger vs master vs photocurrent
+        """
+        pass
+
+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
+        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
+        pass
+
+    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+                              complex[::1] a, complex[:, ::1] b,
+                              complex[:, :, ::1] Lb, complex[:,::1] La,
+                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+                              complex[::1] L0a):
+        """ Obtain the multiple terms for stochastic taylor expension
+        Up to order 1.5
+        multiple sc_ops
+        """
+        pass
+
+    cdef void derivativesO2(self, double t, complex[::1] rho,
+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+                            complex[::1] L0a,
+                            complex[::1] LLa, complex[::1] LL0b,
+                            complex[::1] L0Lb, complex[::1] LLLb):
+        """ Obtain the multiple terms for stochastic taylor expension
+        Up to order 2.0
+        One sc_ops
+        """
+        pass
+
+    cdef void photocurrent(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        """Special integration scheme:
+        photocurrent collapse + euler evolution
+        """
+        pass
+
+    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        """Special integration scheme:
+        photocurrent collapse + predictor-corrector evolution
+        """
+        pass
+
+    cdef void rouchon(self, double t, double dt, double[:] noise,
+                      complex[::1] vec, complex[::1] out):
+        """Special integration scheme:
+        Force valid density matrix using positive map
+        Pierre Rouchon, Jason F. Ralph
+        arXiv:1410.5345 [quant-ph]
+        """
+        pass
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void euler(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """Integration scheme:
+        Basic Euler order 0.5
+        dV = d1 dt + d2_i dW_i
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i, j
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        _zero_2d(d2)
+        copy(vec, out)
+        self.d1(t, vec, out)
+        self.d2(t, vec, d2)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void platen(self, double t, double dt, double[:] noise,
+                       complex[::1] vec, complex[::1] out):
+        """
+        Platen rhs function for both master eq and schrodinger eq.
+        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
+             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
+             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
+
+        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
+        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
+        The Theory of Open Quantum Systems
+        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
+        """
+        cdef int i, j, k
+        cdef double sqrt_dt = np.sqrt(dt)
+        cdef double sqrt_dt_inv = 0.25/sqrt_dt
+        cdef double dw, dw2
+        cdef complex[::1] d1 = self.buffer_1d[0,:]
+        cdef complex[::1] Vt = self.buffer_1d[1,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
+        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
+        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
+        _zero(d1)
+        _zero_2d(d2)
+
+        self.d1(t, vec, d1)
+        self.d2(t, vec, d2)
+        _axpy(1.0,vec,d1)
+        copy(d1,Vt)
+        copy(d1,out)
+        _scale(0.5,out)
+        for i in range(self.num_ops):
+            copy(d1,Vp[i,:])
+            copy(d1,Vm[i,:])
+            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
+            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
+            _axpy(noise[i],d2[i,:],Vt)
+        _zero(d1)
+        self.d1(t, Vt, d1)
+        _axpy(0.5,d1,out)
+        _axpy(0.5,vec,out)
+        for i in range(self.num_ops):
+            _zero_2d(d2p)
+            _zero_2d(d2m)
+            self.d2(t, Vp[i,:], d2p)
+            self.d2(t, Vm[i,:], d2m)
+            dw = noise[i] * 0.25
+            _axpy(dw,d2m[i,:],out)
+            _axpy(2*dw,d2[i,:],out)
+            _axpy(dw,d2p[i,:],out)
+            for j in range(self.num_ops):
+                if i == j:
+                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
+                else:
+                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
+                _axpy(dw2,d2p[j,:],out)
+                _axpy(-dw2,d2m[j,:],out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void pred_corr(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 15.5 Eq. (5.4)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        # a=0. b=0.5
+        cdef double dt_2 = dt*0.5
+        cdef complex[::1] euler = self.buffer_1d[0,:]
+        cdef complex[::1] a_pred = self.buffer_1d[1,:]
+        cdef complex[::1] b_pred = self.buffer_1d[2,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero(a_pred)
+        _zero(b_pred)
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
+        copy(vec, euler)
+        copy(vec, out)
+        _axpy(1.0, a_pred, euler)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], b_pred)
+            _axpy(-dt_2, dd2[i,i,:], a_pred)
+        _axpy(1.0, a_pred, out)
+        _axpy(1.0, b_pred, euler)
+        _axpy(0.5, b_pred, out)
+        _zero_2d(d2)
+        self.d2(t + dt, euler, d2)
+        for i in range(self.num_ops):
+            _axpy(noise[i]*0.5, d2[i,:], out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 15.5 Eq. (5.4)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        # a=0.5, b=0.5
+        cdef int i, j, k
+        cdef complex[::1] euler = self.buffer_1d[0,:]
+        cdef complex[::1] a_pred = self.buffer_1d[1,:]
+        _zero(a_pred)
+        cdef complex[::1] a_corr = self.buffer_1d[2,:]
+        _zero(a_corr)
+        cdef complex[::1] b_pred = self.buffer_1d[3,:]
+        _zero(b_pred)
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        _zero_2d(d2)
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero_3d(dd2)
+
+        cdef double dt_2 = dt*0.5
+        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
+        copy(vec, euler)
+        _axpy(1.0, a_pred, euler)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], b_pred)
+            _axpy(-dt_2, dd2[i,i,:], a_pred)
+        _axpy(1.0, b_pred, euler)
+        copy(vec, out)
+        _axpy(0.5, a_pred, out)
+        _axpy(0.5, b_pred, out)
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
+        for i in range(self.num_ops):
+            _axpy(noise[i]*0.5, d2[i,:], out)
+            _axpy(-dt_2, dd2[i,i,:], a_corr)
+        _axpy(0.5, a_corr, out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void milstein(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 10.3 Eq. (3.1)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+
+        dV = -iH*V*dt + d1*dt + d2_i*dW_i
+             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+        """
+        cdef int i, j, k
+        cdef double dw
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        copy(vec,out)
+        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
+        for i in range(self.num_ops):
+            _axpy(noise[i],d2[i,:],out)
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                if (i == j):
+                    dw = (noise[i] * noise[i] - dt) * 0.5
+                else:
+                    dw = (noise[i] * noise[j])
+                _axpy(dw,dd2[i,j,:],out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void milstein_imp(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out) except *:
+        """
+        Chapter 12.2 Eq. (2.9)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i, j, k
+        cdef double dw
+        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
+                                                          dtype=complex)
+        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
+                                                         dtype=complex)
+        cdef complex[::1] a = self.buffer_1d[0,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero(a)
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
+        copy(vec, dvec)
+        _axpy(0.5, a, dvec)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], dvec)
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                if (i == j):
+                    dw = (noise[i] * noise[i] - dt) * 0.5
+                else:
+                    dw = (noise[i] * noise[j])
+                _axpy(dw, dd2[i,j,:], dvec)
+        copy(dvec, guess)
+        _axpy(0.5, a, guess)
+        self.implicit(t+dt, dvec, out, guess)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void taylor15(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        """
+        Chapter 12.2 Eq. (2.18),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef complex[::1] a = self.buffer_1d[0, :]
+        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
+        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
+        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
+        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
+        cdef complex[::1] L0a = self.buffer_1d[1, :]
+        _zero(a)
+        _zero_2d(b)
+        _zero_3d(Lb)
+        _zero_2d(L0b)
+        _zero_2d(La)
+        _zero_4d(LLb)
+        _zero(L0a)
+        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
+
+        cdef int i,j,k
+        cdef double[::1] dz, dw
+        dw = np.empty(self.num_ops)
+        dz = np.empty(self.num_ops)
+        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
+        for i in range(self.num_ops):
+            dw[i] = noise[i]
+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+        copy(vec,out)
+        _axpy(1.0, a, out)
+        _axpy(0.5, L0a, out)
+
+        for i in range(self.num_ops):
+            _axpy(dw[i], b[i,:], out)
+            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
+            _axpy(dz[i], La[i,:], out)
+            _axpy(dw[i]-dz[i], L0b[i,:], out)
+            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
+                        LLb[i,i,i,:], out)
+            for j in range(i+1,self.num_ops):
+                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
+                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
+                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
+                for k in range(j+1,self.num_ops):
+                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out) except *:
+        """
+        Chapter 12.2 Eq. (2.18),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef complex[::1] a = self.buffer_1d[0, :]
+        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
+        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
+        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
+        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
+        cdef complex[::1] L0a = self.buffer_1d[1, :]
+        _zero(a)
+        _zero_2d(b)
+        _zero_3d(Lb)
+        _zero_2d(L0b)
+        _zero_2d(La)
+        _zero_4d(LLb)
+        _zero(L0a)
+        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
+                   dtype=complex)
+        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
+                  dtype=complex)
+        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
+
+        cdef int i,j,k
+        cdef double[::1] dz, dw
+        dw = np.empty(self.num_ops)
+        dz = np.empty(self.num_ops)
+        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
+        for i in range(self.num_ops):
+            dw[i] = noise[i]
+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+        copy(vec, vec_t)
+        _axpy(0.5, a, vec_t)
+        for i in range(self.num_ops):
+            _axpy(dw[i], b[i,:], vec_t)
+            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
+            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
+            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
+            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
+                        LLb[i,i,i,:], vec_t)
+            for j in range(i+1,self.num_ops):
+                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
+                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
+                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
+                for k in range(j+1,self.num_ops):
+                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
+        copy(vec_t, guess)
+        _axpy(0.5, a, guess)
+
+        self.implicit(t+dt, vec_t, out, guess)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void platen15(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 11.2 Eq. (2.13)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i, j, k
+        cdef double sqrt_dt = np.sqrt(dt)
+        cdef double sqrt_dt_inv = 1./sqrt_dt
+        cdef double ddz, ddw, ddd
+        cdef double[::1] dz, dw
+        dw = np.empty(self.num_ops)
+        dz = np.empty(self.num_ops)
+        for i in range(self.num_ops):
+            dw[i] = noise[i]
+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+
+        cdef complex[::1] d1 = self.buffer_1d[0,:]
+        cdef complex[::1] d1p = self.buffer_1d[1,:]
+        cdef complex[::1] d1m = self.buffer_1d[2,:]
+        cdef complex[::1] V = self.buffer_1d[3,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
+        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
+        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
+        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
+        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
+        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
+        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
+        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
+
+        _zero(d1)
+        _zero_2d(d2)
+        _zero_2d(dd2)
+        self.d1(t, vec, d1)
+        self.d2(t, vec, d2)
+        self.d2(t + dt, vec, dd2)
+        # Euler part
+        copy(vec,out)
+        _axpy(1., d1, out)
+        for i in range(self.num_ops):
+            _axpy(dw[i], d2[i,:], out)
+
+        _zero(V)
+        _axpy(1., vec, V)
+        _axpy(1./self.num_ops, d1, V)
+
+        _zero_2d(v2p)
+        _zero_2d(v2m)
+        for i in range(self.num_ops):
+            _axpy(1., V, v2p[i,:])
+            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
+            _axpy(1., V, v2m[i,:])
+            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
+
+        _zero_3d(p2p)
+        _zero_3d(p2m)
+        for i in range(self.num_ops):
+            _zero_2d(d2p)
+            _zero_2d(d2m)
+            self.d2(t, v2p[i,:], d2p)
+            self.d2(t, v2m[i,:], d2m)
+            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
+            _axpy( ddw, d2p[i,:], out)
+            _axpy(-ddw, d2m[i,:], out)
+            for j in range(self.num_ops):
+                _axpy(      1., v2p[i,:], p2p[i,j,:])
+                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
+                _axpy(      1., v2p[i,:], p2m[i,j,:])
+                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
+
+        _axpy(-0.5*(self.num_ops), d1, out)
+        for i in range(self.num_ops):
+            ddz = dz[i]*0.5/sqrt_dt  # 1.5
+            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
+            _zero(d1p)
+            _zero(d1m)
+            _zero_2d(d2m)
+            _zero_2d(d2p)
+            _zero_2d(d2pp)
+            _zero_2d(d2mm)
+            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
+            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
+            self.d2(t, v2p[i,:], d2p)
+            self.d2(t, v2m[i,:], d2m)
+            self.d2(t, p2p[i,i,:], d2pp)
+            self.d2(t, p2m[i,i,:], d2mm)
+
+            _axpy( ddz+0.25, d1p, out)
+            _axpy(-ddz+0.25, d1m, out)
+
+            _axpy((dw[i]-dz[i]), dd2[i,:], out)
+            _axpy((dz[i]-dw[i]), d2[i,:], out)
+
+            _axpy( ddd, d2pp[i,:], out)
+            _axpy(-ddd, d2mm[i,:], out)
+            _axpy(-ddd, d2p[i,:], out)
+            _axpy( ddd, d2m[i,:], out)
+
+            for j in range(self.num_ops):
+              ddw = 0.5*(dw[j]-dz[j]) # 1.5
+              _axpy(ddw, d2p[j,:], out)
+              _axpy(-2*ddw, d2[j,:], out)
+              _axpy(ddw, d2m[j,:], out)
+
+              if j>i:
+                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
+                _axpy( ddw, d2p[j,:], out)
+                _axpy(-ddw, d2m[j,:], out)
+
+                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
+                _zero_2d(d2pp)
+                _zero_2d(d2mm)
+                self.d2(t, p2p[j,i,:], d2pp)
+                self.d2(t, p2m[j,i,:], d2mm)
+                _axpy( ddw, d2pp[j,:], out)
+                _axpy(-ddw, d2mm[j,:], out)
+                _axpy(-ddw, d2p[j,:], out)
+                _axpy( ddw, d2m[j,:], out)
+
+                for k in range(j+1,self.num_ops):
+                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
+                    _axpy( ddw, d2pp[k,:], out)
+                    _axpy(-ddw, d2mm[k,:], out)
+                    _axpy(-ddw, d2p[k,:], out)
+                    _axpy( ddw, d2m[k,:], out)
+
+              if j<i:
+                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
+                _zero_2d(d2pp)
+                _zero_2d(d2mm)
+                self.d2(t, p2p[j,i,:], d2pp)
+                self.d2(t, p2m[j,i,:], d2mm)
+                _axpy( ddw, d2pp[j,:], out)
+                _axpy(-ddw, d2mm[j,:], out)
+                _axpy(-ddw, d2p[j,:], out)
+                _axpy( ddw, d2m[j,:], out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void taylor20(self, double t, double dt, double[::1] noise,
+                           complex[::1] vec, complex[::1] out):
+        """
+        Chapter 10.5 Eq. (5.1),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef double[::1] noises = np.empty(5)
+        cdef double dwn
+        self.order2noise.order2(noise,noises)
+        cdef complex[::1] a = self.buffer_1d[0, :]
+        cdef complex[::1] b = self.buffer_1d[1, :]
+        cdef complex[::1] Lb = self.buffer_1d[2, :]
+        cdef complex[::1] La = self.buffer_1d[3, :]
+        cdef complex[::1] L0b = self.buffer_1d[4, :]
+        cdef complex[::1] LLb = self.buffer_1d[5, :]
+        cdef complex[::1] L0a = self.buffer_1d[6, :]
+        cdef complex[::1] LLa = self.buffer_1d[7, :]
+        cdef complex[::1] LL0b = self.buffer_1d[8, :]
+        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
+        cdef complex[::1] LLLb = self.buffer_1d[10, :]
+        _zero(a)
+        _zero(b)
+        _zero(Lb)
+        _zero(La)
+        _zero(L0b)
+        _zero(LLb)
+        _zero(L0a)
+        _zero(LLa)
+        _zero(LL0b)
+        _zero(L0Lb)
+        _zero(LLLb)
+        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
+                           L0a, LLa, LL0b, L0Lb, LLLb)
+
+        copy(vec,out)
+        _axpy(1.0, a, out)
+
+        _axpy(noises[0], b, out)
+        dwn = noises[0]*noises[0]*0.5
+        _axpy(dwn, Lb, out)
+
+        _axpy(noises[1], La, out)
+        _axpy(noises[0]-noises[1], L0b, out)
+        dwn *= noises[0]*(1/3.)
+        _axpy(dwn, LLb, out)
+        _axpy(0.5, L0a, out)
+
+        _axpy(noises[2], L0Lb, out)
+        _axpy(noises[3], LL0b, out)
+        _axpy(noises[4], LLa, out)
+        dwn *= noises[0]*0.25
+        _axpy(dwn, LLLb, out)
+
+
+cdef class SSESolver(StochasticSolver):
+    """stochastic Schrodinger system"""
+    cdef QobjEvo L
+    cdef object c_ops
+    cdef object cpcd_ops
+    cdef object imp
+    cdef double tol, imp_t
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.c_ops = []
+        self.cpcd_ops = []
+        for i, op in enumerate(c_ops):
+            self.c_ops.append(op[0])
+            self.cpcd_ops.append(op[1])
+        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+            self.tol = sso.tol
+            self.imp = LinearOperator( (self.l_vec,self.l_vec),
+                                      matvec=self.implicit_op, dtype=complex)
+
+    def implicit_op(self, vec):
+        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
+        self.d1(self.imp_t, vec, out)
+        cdef int i
+        _scale(-0.5,out)
+        _axpy(1.,vec,out)
+        return out
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
+        cdef int i
+        cdef complex e
+        cdef QobjEvo c_op
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        _zero(temp)
+        for i in range(self.num_ops):
+            c_op = self.cpcd_ops[i]
+            e = c_op.expect_data(t, _dense_wrap(vec))
+            _zero(temp)
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
+            _axpy(-0.125 * e * e * self.dt, vec, out)
+            _axpy(0.5 * e * self.dt, temp, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+        cdef int i, k
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
+            c_op = self.cpcd_ops[i]
+            expect = c_op.expect_data(t, _dense_wrap(vec))
+            _axpy(-0.5*expect,vec,out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivatives(self, double t, int deg, complex[::1] vec,
+                          complex[::1] a, complex[:, ::1] b,
+                          complex[:, :, ::1] Lb, complex[:,::1] La,
+                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+                          complex[::1] L0a):
+        """
+        combinaisons of a and b derivatives for taylor order 1.5
+        dY ~ a dt + bi dwi
+                                         deg   use        noise
+        b[i.:]       bi                   >=0   d2 euler   dwi
+        a[:]         a                    >=0   d1 euler   dt
+        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
+        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
+
+        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
+        La[i,:]      ba'                  >=2   taylor15   dzi
+        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
+        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
+        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
+        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
+        """
+        cdef int i, j, k, l
+        cdef double dt = self.dt
+        cdef QobjEvo c_op
+        cdef complex e, de_bb
+
+        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
+        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
+        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
+        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
+        _zero_3d(dde_bb)
+        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
+        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
+        _zero(temp)
+        _zero(temp2)
+        _zero_2d(Cvec)
+        _zero_3d(Cb)
+
+        # a b
+        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
+            e = _dotc(vec,Cvec[i,:])
+            e_real[i] = e.real
+            _axpy(1., Cvec[i,:], b[i,:])
+            _axpy(-e_real[i], vec, b[i,:])
+            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
+            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
+
+        #Lb bb'
+        if deg >= 1:
+          for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            for j in range(self.num_ops):
+              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
+              for k in range(self.l_vec):
+                  temp[k] = conj(b[j,k])
+                  temp2[k] = 0.
+              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
+                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
+              _axpy(1., Cb[i,j,:], Lb[i,j,:])
+              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
+              _axpy(-de_b[i,j], vec, Lb[i,j,:])
+
+              for k in range(self.num_ops):
+                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
+                                  _dot(b[k,:], Cb[i,j,:]) + \
+                                  conj(_dotc(b[k,:], temp2)))*.5
+                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
+
+        #L0b La LLb
+        if deg >= 2:
+          for i in range(self.num_ops):
+              #ba'
+              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
+              for j in range(self.num_ops):
+                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
+                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
+                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
+                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
+
+              #ab' + db/dt + bbb"/2
+              c_op = self.c_ops[i]
+              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
+              for k in range(self.l_vec):
+                  temp[k] = conj(a[k])
+                  temp2[k] = 0.
+              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
+                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
+              _axpy(-e_real[i], a, L0b[i,:])
+              _axpy(-de_a[i], vec, L0b[i,:])
+
+              temp = np.zeros(self.l_vec, dtype=complex)
+              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
+              e = _dotc(vec,temp)
+              _axpy(1., temp, L0b[i,:])
+              _axpy(-e.real, vec, L0b[i,:])
+              _axpy(-1., b[i,:], L0b[i,:])
+
+              for j in range(self.num_ops):
+                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
+                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
+
+              #b(bb"+b'b')
+              for j in range(i,self.num_ops):
+                  for k in range(j, self.num_ops):
+                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
+                                  _dense_wrap(LLb[i,j,k,:]))
+                      for l in range(self.l_vec):
+                          temp[l] = conj(Lb[j,k,l])
+                          temp2[l] = 0.
+                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
+                               _dot(Lb[j,k,:], Cvec[i,:]) + \
+                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
+                               _dotc(vec, temp2)))*0.5
+                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
+                      _axpy(-de_bb, vec, LLb[i,j,k,:])
+                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
+                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
+                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
+
+        #da/dt + aa' + bba"
+        if deg == 2:
+          self.d1(t + dt, vec, L0a)
+          _axpy(-1.0, a, L0a)
+          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+          for j in range(self.num_ops):
+              c_op = self.c_ops[j]
+              temp = np.zeros(self.l_vec, dtype=complex)
+              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
+              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
+              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
+              _axpy(e_real[j] * dt, temp, L0a[:])
+              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
+              for i in range(self.num_ops):
+                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
+                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
+                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
+                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
+                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
+                         complex[::1] vec, complex[::1] out):
+        cdef int k
+        cdef complex[::1] temp = self.func_buffer_1d[13,:]
+        for k in range(self.l_vec):
+            temp[k] = conj(vec[k])
+            out[k] = 0.
+        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivativesO2(self, double t, complex[::1] psi,
+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+                            complex[::1] L0a,
+                            complex[::1] LLa, complex[::1] LL0b,
+                            complex[::1] L0Lb, complex[::1] LLLb):
+        """
+        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
+        Use Stratonovich-Taylor expansion.
+        One one sc_ops
+        dY ~ a dt + bi dwi
+
+        b[:]     b                        d2 euler    dw
+        a[:]     a- Lb/2                  d1 euler    dt
+        Lb[:]    b'b                      milstein    dw^2/2
+        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
+        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
+        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
+        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
+
+        LLa[:]   ...                      taylor2.0   dwdt-dz
+        LL0b[:]  ...                      taylor2.0   dz
+        L0Lb[:]  ...                      taylor2.0   dw^3/6
+        LLLb[:]  ...                      taylor2.0   dt^2/2
+        """
+        cdef double dt = self.dt
+        cdef QobjEvo c_op = self.c_ops[0]
+        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
+        cdef complex de_a, dde_ba, de_La, de_L0b
+
+        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
+        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
+        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
+        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
+        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
+        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
+        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
+        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
+        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
+        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
+        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
+        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
+        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
+        _zero(Cpsi)
+        _zero(Cb)
+        _zero(CLb)
+        _zero(CLLb)
+        _zero(Ca)
+        _zero(CLa)
+        _zero(CL0b)
+
+        # b
+        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
+        e = _dotc(psi, Cpsi).real
+        _axpy(1., Cpsi, b)
+        _axpy(-e, psi, b)
+
+        # Lb
+        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
+        self._c_vec_conj(t, c_op, b, Cbc)
+        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
+                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
+        _axpy(1., Cb, Lb)
+        _axpy(-e, b, Lb)
+        _axpy(-de_b, psi, Lb)
+
+        # LLb = b'b'b + b"bb
+        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
+        self._c_vec_conj(t, c_op, Lb, CLbc)
+        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
+                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
+        _axpy(1, CLb, LLb)      # b'b'b
+        _axpy(-e, Lb, LLb)      # b'b'b
+        _axpy(-de_Lb, psi, LLb) # b'b'b
+        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
+        _axpy(-dde_bb, psi, LLb) # b"bb
+        _axpy(-de_b*2, b, LLb)   # b"bb
+
+        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
+        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
+        self._c_vec_conj(t, c_op, LLb, CLLbc)
+        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
+                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
+        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
+                    conj(_dotc(b, CLbc)))*.5
+        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
+        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
+        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
+        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
+        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
+        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
+        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
+
+        # a
+        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
+        _axpy(-0.5 * e * e * dt, psi, a)
+        _axpy(e * dt, Cpsi, a)
+        _axpy(-0.5 * dt, Lb, a)
+
+        #La
+        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
+        _axpy(-0.5 * e * e * dt, b, La)
+        _axpy(-e * de_b * dt, psi, La)
+        _axpy(e * dt, Cb, La)
+        _axpy(de_b * dt, Cpsi, La)
+        _axpy(-0.5 * dt, LLb, La)
+
+        #LLa
+        _axpy(-2 * e * de_b * dt, b, LLa)
+        _axpy(-de_b * de_b * dt, psi, LLa)
+        _axpy(-e * dde_bb * dt, psi, LLa)
+        _axpy( 2 * de_b * dt, Cb, LLa)
+        _axpy( dde_bb * dt, Cpsi, LLa)
+
+        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
+        _axpy(-de_Lb * e * dt, psi, LLa)
+        _axpy(-0.5 * e * e * dt, Lb, LLa)
+        _axpy( de_Lb * dt, Cpsi, LLa)
+        _axpy( e * dt, CLb, LLa)
+
+        _axpy(-0.5 * dt, LLLb, LLa)
+
+        # L0b = b'a
+        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
+        self._c_vec_conj(t, c_op, a, Cac)
+        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
+                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
+        _axpy(1.0, Ca, L0b)
+        _axpy(-e, a, L0b)
+        _axpy(-de_a, psi, L0b)
+
+        # LL0b = b"ba + b'La
+        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
+                    conj(_dotc(b, Cac)))*.5
+        _axpy(-dde_ba, psi, LL0b)
+        _axpy(-de_a, b, LL0b)
+        _axpy(-de_b, a, LL0b)
+        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
+        self._c_vec_conj(t, c_op, La, CLac)
+        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
+                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
+        _axpy(1., CLa, LL0b)
+        _axpy(-e, La, LL0b)
+        _axpy(-de_La, psi, LL0b)
+
+        # L0Lb = b"ba + b'L0b
+        _axpy(-dde_ba, psi, L0Lb)
+        _axpy(-de_a, b, L0Lb)
+        _axpy(-de_b, a, L0Lb)
+        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
+        self._c_vec_conj(t, c_op, L0b, CL0bc)
+        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
+                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
+        _axpy(1., CL0b, L0Lb)
+        _axpy(-e, L0b, L0Lb)
+        _axpy(-de_L0b, psi, L0Lb)
+
+        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
+        self.d1(t + dt, psi, L0a) # da/dt
+        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
+        _axpy(-1.0, a, L0a)        # da/dt
+        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
+        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
+        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
+        _axpy(e * dt, Ca, L0a)              # a'_a_
+        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
+        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
+
+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+                                        complex[::1] out,
+                                        np.ndarray[complex, ndim=1] guess) except *:
+        # np.ndarray to memoryview is OK but not the reverse
+        # scipy function only take np array, not memoryview
+        self.imp_t = t
+        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
+                                          tol=self.tol, atol=1e-12)
+        cdef int i
+        copy(spout, out)
+
+
+cdef class SMESolver(StochasticSolver):
+    """stochastic master equation system"""
+    cdef QobjEvo L
+    cdef object imp
+    cdef object c_ops
+    cdef int N_root
+    cdef double tol
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.c_ops = []
+        self.N_root = np.sqrt(self.l_vec)
+        for i, op in enumerate(c_ops):
+            self.c_ops.append(op)
+        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+            self.tol = sso.tol
+            self.imp = sso.imp
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_rho(vec)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef complex expect(self, complex[::1] rho):
+        cdef complex e = 0.
+        cdef int k
+        for k in range(self.N_root):
+            e += rho[k*(self.N_root+1)]
+        return e
+
+    @cython.boundscheck(False)
+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+        cdef int i, k
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
+            expect = self.expect(out[i,:])
+            _axpy(-expect, rho, out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+                          complex[::1] a, complex[:, ::1] b,
+                          complex[:, :, ::1] Lb, complex[:,::1] La,
+                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+                          complex[::1] L0a):
+        """
+        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
+        dY ~ a dt + bi dwi
+                                         deg   use        noise
+        b[i.:]       bi                   >=0   d2 euler   dwi
+        a[:]         a                    >=0   d1 euler   dt
+        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
+        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
+        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
+        La[i,:]      ba'                  >=2   taylor15   dzi
+        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
+        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
+        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
+        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
+        """
+        cdef int i, j, k
+        cdef QobjEvo c_op
+        cdef QobjEvo c_opj
+        cdef complex trApp, trAbb, trAa
+        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
+        cdef complex[:, ::1] trAb = self.expect_buffer_2d
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        #_zero(temp)
+
+        # a
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
+
+        # b
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            # bi
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
+            trAp[i] = self.expect(b[i,:])
+            _axpy(-trAp[i], rho, b[i,:])
+
+        # Libj = bibj', i<=j
+        # sc_ops must commute (Libj = Ljbi)
+        if deg >= 1:
+          for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            for j in range(i, self.num_ops):
+                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
+                trAb[i,j] = self.expect(Lb[i,j,:])
+                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
+                _axpy(-trAb[i,j], rho, Lb[i,j,:])
+
+        # L0b La LLb
+        if deg >= 2:
+          for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            # Lia = bia'
+            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
+
+            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
+            # db/dt
+            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
+            trApp = self.expect(L0b[i,:])
+            _axpy(-trApp, rho, L0b[i,:])
+            _axpy(-1, b[i,:], L0b[i,:])
+            # ab'
+            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
+            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
+            trAa = self.expect(temp)
+            _axpy(1., temp, L0b[i,:])
+            _axpy(-trAp[i], a[:], L0b[i,:])
+            _axpy(-trAa, rho, L0b[i,:])
+            # bbb" : trAb[i,j] only defined for j>=i
+            for j in range(i):
+                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
+            for j in range(i,self.num_ops):
+                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
+
+            # LLb
+            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
+            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
+            for j in range(i,self.num_ops):
+              for k in range(j,self.num_ops):
+                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
+                trAbb = self.expect(LLb[i,j,k,:])
+                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
+                _axpy(-trAbb, rho, LLb[i,j,k,:])
+                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
+                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
+
+        # L0a = a'a + da/dt + bba"/2  (a" = 0)
+        if deg == 2:
+            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
+            _axpy(-1, a, L0a)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivativesO2(self, double t, complex[::1] rho,
+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+                            complex[::1] L0a,
+                            complex[::1] LLa, complex[::1] LL0b,
+                            complex[::1] L0Lb, complex[::1] LLLb):
+        """
+        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
+        Use Stratonovich-Taylor expansion.
+        One one sc_ops
+        dY ~ a dt + bi dwi
+
+        b[:]     b                        d2 euler    dw
+        a[:]     a- Lb/2                  d1 euler    dt
+        Lb[:]    b'b                      milstein    dw^2/2
+        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
+        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
+        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
+        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
+
+        LLa[:]   ...                      taylor2.0   dwdt-dz
+        LL0b[:]  ...                      taylor2.0   dz
+        L0Lb[:]  ...                      taylor2.0   dw^3/6
+        LLLb[:]  ...                      taylor2.0   dt^2/2
+        """
+        cdef int i, j, k
+        cdef QobjEvo c_op = self.c_ops[0]
+        cdef QobjEvo c_opj
+        cdef complex trAp, trApt
+        cdef complex trAb, trALb, trALLb
+        cdef complex trAa, trALa
+        cdef complex trAL0b
+
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
+
+        # b
+        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
+        trAp = self.expect(b)
+        _axpy(-trAp, rho, b)
+
+        # Lb = b'b
+        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
+        trAb = self.expect(Lb)
+        _axpy(-trAp, b, Lb)
+        _axpy(-trAb, rho, Lb)
+
+        # LLb = b'Lb+b"bb
+        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
+        trALb = self.expect(LLb)
+        _axpy(-trAp, Lb, LLb)
+        _axpy(-trALb, rho, LLb)
+        _axpy(-trAb*2, b, LLb)
+
+        # LLLb = b'LLb + 3 b"bLb + b"'bbb
+        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
+        trALLb = self.expect(LLLb)
+        _axpy(-trAp, LLb, LLLb)
+        _axpy(-trALLb, rho, LLLb)
+        _axpy(-trALb*3, b, LLLb)
+        _axpy(-trAb*3, Lb, LLLb)
+
+        # _a_ = a - Lb/2
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
+        _axpy(-0.5*self.dt, Lb, a)
+
+        # L_a_ = ba' - LLb/2
+        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
+        _axpy(-0.5*self.dt, LLb, La)
+
+        # LL_a_ = b(La)' - LLLb/2
+        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
+        _axpy(-0.5*self.dt, LLLb, LLa)
+
+        # _L0_b = b'(_a_)
+        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
+        trAa = self.expect(L0b)
+        _axpy(-trAp, a, L0b)
+        _axpy(-trAa, rho, L0b)
+
+        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
+        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
+        trAL0b = self.expect(L0Lb)
+        _axpy(-trAp, L0b, L0Lb)
+        _axpy(-trAL0b, rho, L0Lb)
+        _axpy(-trAa, b, L0Lb)
+        _axpy(-trAb, a, L0Lb)
+
+        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
+        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
+        trAL0b = self.expect(LL0b)
+        _axpy(-trAp, La, LL0b)
+        _axpy(-trAL0b, rho, LL0b)
+        _axpy(-trAa, b, LL0b)
+        _axpy(-trAb, a, LL0b)
+
+        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
+        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
+        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
+        _axpy(-1, a, L0a)
+        _axpy(-self.dt*0.5, L0Lb, L0a)
+
+
+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+                                        complex[::1] out,
+                                        np.ndarray[complex, ndim=1] guess) except *:
+        # np.ndarray to memoryview is OK but not the reverse
+        # scipy function only take np array, not memoryview
+        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
+                                          dvec, x0=guess,
+                                          tol=self.tol, atol=1e-12)
+        cdef int i
+        copy(spout,out)
+
+
+cdef class PcSSESolver(StochasticSolver):
+    """photocurrent for Schrodinger equation"""
+    cdef QobjEvo L
+    cdef object c_ops
+    cdef object cdc_ops
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.c_ops = []
+        self.cdc_ops = []
+        for i, op in enumerate(c_ops):
+            self.c_ops.append(op[0])
+            self.cdc_ops.append(op[1])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef double rand
+        cdef int i, which = -1
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef complex[::1] d2 = self.buffer_1d[0,:]
+
+        copy(vec, out)
+        self.d1(t, vec, out)
+        rand = np.random.rand()
+        for i in range(self.num_ops):
+            c_op = self.cdc_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
+            if expects[i].real * dt >= 1e-15:
+                rand -= expects[i].real *dt
+            if rand < 0:
+                which = i
+                noise[i] = 1.
+                break
+
+        if which >= 0:
+            self.collapse(t, which, expects[which].real, vec, d2)
+            _axpy(1, d2, out)
+            _axpy(-1, vec, out)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef double expect
+        cdef int i, which=0, num_coll=0, did_collapse=0
+        cdef complex[::1] tmp = self.buffer_1d[0,:]
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef np.ndarray[int, ndim=1] colls
+
+        # Collapses are computed first
+        for i in range(self.num_ops):
+            c_op = self.cdc_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
+            if expects[i].real > 0:
+                did_collapse = np.random.poisson(expects[i].real * dt)
+                num_coll += did_collapse
+                if did_collapse:
+                    which = i
+                noise[i] = did_collapse * 1.
+            else:
+                noise[i] = 0.
+
+        if num_coll == 0:
+            pass
+        elif num_coll == 1:
+            # Do one collapse
+            self.collapse(t, which, expects[which].real, vec, out)
+            copy(out, vec)
+        elif num_coll and noise[which] == num_coll:
+            # Do many collapse of one sc_ops.
+            # Recompute the expectation value, but only to check for zero.
+            c_op = self.cdc_ops[which]
+            for i in range(num_coll):
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, which, expect, vec, out)
+                    copy(out,vec)
+        elif num_coll >= 2:
+            # 2 or more collapses of different operators
+            # Ineficient, should be rare
+            coll = []
+            for i in range(self.num_ops):
+                coll += [i]*int(noise[i])
+            np.random.shuffle(coll)
+            for i in coll:
+                c_op = self.cdc_ops[i]
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, i, expect, vec, out)
+                    copy(out,vec)
+        copy(vec,tmp)
+        copy(vec,out)
+        self.d1(t, vec, tmp)
+        self.d1(t+dt, tmp, out)
+        _scale(0.5, out)
+        _axpy(0.5, tmp, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        cdef int i
+        cdef complex e
+        cdef QobjEvo c_op
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        for i in range(self.num_ops):
+            _zero(temp)
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
+            e = _dznrm2(temp)
+            _axpy(0.5 * e * e * self.dt, vec, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
+            expect = _dznrm2(out[i,:])
+            if expect.real >= 1e-15:
+                _zscale(1/expect, out[i,:])
+            else:
+                _zero(out[i,:])
+            _axpy(-1, vec, out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void collapse(self, double t, int which, double expect,
+                       complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        c_op = self.c_ops[which]
+        _zero(out)
+        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        _zscale(1/expect, out)
+
+
+cdef class PcSMESolver(StochasticSolver):
+    """photocurrent for master equation"""
+    cdef QobjEvo L
+    cdef object cdcr_cdcl_ops
+    cdef object cdcl_ops
+    cdef object clcdr_ops
+    cdef int N_root
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.cdcr_cdcl_ops = []
+        self.cdcl_ops = []
+        self.clcdr_ops = []
+        self.N_root = np.sqrt(self.l_vec)
+        for i, op in enumerate(c_ops):
+            self.cdcr_cdcl_ops.append(op[0])
+            self.cdcl_ops.append(op[1])
+            self.clcdr_ops.append(op[2])
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_rho(vec)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent(self, double t, double dt,  double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef double rand
+        cdef int i, which = -1
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef complex[::1] d2 = self.buffer_1d[0,:]
+
+        copy(vec, out)
+        self.d1(t, vec, out)
+        rand = np.random.rand()
+        for i in range(self.num_ops):
+            c_op = self.clcdr_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
+            if expects[i].real * dt >= 1e-15:
+                rand -= expects[i].real *dt
+            if rand < 0:
+                which = i
+                noise[i] = 1.
+                break
+
+        if which >= 0:
+            self.collapse(t, which, expects[which].real, vec, d2)
+            _axpy(1, d2, out)
+            _axpy(-1, vec, out)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef int i, which, num_coll=0, did_collapse
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef complex[::1] tmp = self.buffer_1d[0,:]
+        cdef double expect
+        cdef np.ndarray[int, ndim=1] colls
+
+        # Collapses are computed first
+        for i in range(self.num_ops):
+            c_op = self.clcdr_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
+            if expects[i].real > 0:
+                did_collapse = np.random.poisson(expects[i].real* dt)
+                num_coll += did_collapse
+                if did_collapse:
+                    which = i
+                noise[i] = did_collapse * 1.
+            else:
+                noise[i] = 0.
+
+        if num_coll == 0:
+            pass
+        elif num_coll == 1:
+            # Do one collapse
+            self.collapse(t, which, expects[which].real, vec, out)
+            copy(out,vec)
+        elif noise[which] == num_coll:
+            # Do many collapse of one sc_ops.
+            # Recompute the expectation value, but only to check for zero.
+            c_op = self.clcdr_ops[which]
+            for i in range(num_coll):
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, which, expect, vec, out)
+                    copy(out,vec)
+        elif num_coll >= 2:
+            # 2 or more collapses of different operators
+            # Ineficient, should be rare
+            coll = []
+            for i in range(self.num_ops):
+                coll += [i] * int(noise[i])
+            np.random.shuffle(coll)
+            for i in coll:
+                c_op = self.clcdr_ops[i]
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, i, expect, vec, out)
+                    copy(out,vec)
+
+        copy(vec,tmp)
+        copy(vec,out)
+        self.d1(t, vec, tmp)
+        self.d1(t+dt, tmp, out)
+        _scale(0.5, out)
+        _axpy(0.5, tmp, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef complex expect(self, complex[::1] rho):
+        cdef complex e = 0.
+        cdef int k
+        for k in range(self.N_root):
+            e += rho[k*(self.N_root+1)]
+        return e
+
+    @cython.boundscheck(False)
+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef complex[::1] crho = self.func_buffer_1d[0,:]
+        cdef complex expect
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
+        for i in range(self.num_ops):
+            c_op = self.cdcr_cdcl_ops[i]
+            _zero(crho)
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
+            expect = self.expect(crho)
+            _axpy(0.5*expect* self.dt, rho, out)
+            _axpy(-0.5* self.dt, crho, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.clcdr_ops[i]
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
+            expect = self.expect(out[i,:])
+            if expect.real >= 1e-15:
+                _zscale((1.+0j)/expect, out[i,:])
+            else:
+                _zero(out[i,:])
+            _axpy(-1, rho, out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void collapse(self, double t, int which, double expect,
+                       complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        c_op = self.clcdr_ops[which]
+        _zero(out)
+        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        _zscale(1./expect, out)
+
+cdef class PmSMESolver(StochasticSolver):
+    """positive map for master equation"""
+    cdef object L
+    cdef QobjEvo pp_ops
+    cdef QobjEvo preLH
+    cdef QobjEvo postLH
+    cdef object sops
+    cdef object preops
+    cdef object postops
+    cdef object preops2
+    cdef object postops2
+    cdef int N_root
+
+    def set_data(self, sso):
+        c_ops = sso.sops
+        self.l_vec = sso.pp.shape[0]
+        self.num_ops = len(c_ops)
+        self.preLH = sso.preLH
+        self.postLH = sso.postLH
+        self.pp_ops = sso.pp
+        self.sops = [op for op in sso.sops]
+        self.preops = [op for op in sso.preops]
+        self.postops = [op for op in sso.postops]
+        self.preops2 = [op for op in sso.preops2]
+        self.postops2 = [op for op in sso.postops2]
+        self.N_root = np.sqrt(self.l_vec)
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_rho(vec)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void rouchon(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
+        cdef complex[::1] temp = self.buffer_1d[0,:]
+        cdef complex[::1] temp2 = self.buffer_1d[1,:]
+        cdef int i, j, k
+        cdef QobjEvo c_op, c_opj
+        cdef complex ddw, tr
+        _zero(out)
+        _zero(temp)
+        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
+        for i in range(self.num_ops):
+            c_op = self.sops[i]
+            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
+            c_op = self.preops[i]
+            _zero(temp2)
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
+            _axpy(dy[i], temp2, temp)
+
+        k = 0
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                c_op = self.preops2[k]
+                if i == j:
+                    ddw = (dy[i]*dy[j] - dt) *0.5
+                else:
+                    ddw = (dy[i]*dy[j])
+
+                _zero(temp2)
+                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
+                _axpy(ddw, temp2, temp)
+                k += 1
+
+        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
+        for i in range(self.num_ops):
+            dy[i] = conj(dy[i])
+            c_op = self.postops[i]
+            _zero(temp2)
+            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+            _axpy(dy[i], temp2, out)
+
+        k = 0
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                c_op = self.postops2[k]
+                if i == j:
+                    ddw = (dy[i]*dy[j] - dt) *0.5
+                else:
+                    ddw = (dy[i]*dy[j])
+                _zero(temp2)
+                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+                _axpy(ddw, temp2, out)
+                k += 1
+
+        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        tr = self.expect(out)
+        _zscale(1./tr, out)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef complex expect(self, complex[::1] rho):
+        cdef complex e = 0.
+        cdef int k
+        for k in range(self.N_root):
+            e += rho[k*(self.N_root+1)]
+        return e
+
+
+cdef class GenericSSolver(StochasticSolver):
+    """support for user defined system"""
+    cdef object d1_func, d2_func
+
+    def set_data(self, sso):
+        self.l_vec = sso.rho0.shape[0]
+        self.num_ops = len(sso.sops)
+        self.d1_func = sso.d1
+        self.d2_func = sso.d2
+
+
+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+        cdef np.ndarray[complex, ndim=1] in_np
+        cdef np.ndarray[complex, ndim=1] out_np
+        in_np = np.zeros((self.l_vec, ), dtype=complex)
+        copy(rho, in_np)
+        out_np = self.d1_func(t, in_np)
+        _axpy(self.dt, out_np, out) # d1 is += and * dt
+
+    @cython.boundscheck(False)
+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+        cdef np.ndarray[complex, ndim=1] in_np
+        cdef np.ndarray[complex, ndim=2] out_np
+        cdef int i
+        in_np = np.zeros((self.l_vec, ), dtype=complex)
+        copy(rho, in_np)
+        out_np = self.d2_func(t, in_np)
+        for i in range(self.num_ops):
+            copy(out_np[i,:], out[i,:])
diff --git a/qutip/solve/nonmarkov/memorycascade.py b/qutip/solve/nonmarkov/memorycascade.py
index 35996d21cd..488b2515c4 100644
--- a/qutip/solve/nonmarkov/memorycascade.py
+++ b/qutip/solve/nonmarkov/memorycascade.py
@@ -1,405 +1,405 @@
-# -*- coding: utf-8 -*-
-
-# @author: Arne L. Grimsmo
-# @email1: arne.grimsmo@gmail.com
-# @organization: University of Sherbrooke
-
-"""
-This module is an implementation of the method introduced in [1], for
-solving open quantum systems subject to coherent feedback with a single
-discrete time-delay. This method is referred to as the ``memory cascade''
-method in qutip.
-
-[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
-"""
-
-import numpy as np
-import warnings
-
-import qutip as qt
-
-
-class MemoryCascade:
-    """Class for running memory cascade simulations of open quantum systems
-    with time-delayed coherent feedback.
-
-    Attributes
-    ----------
-    H_S : :class:`qutip.Qobj`
-        System Hamiltonian (can also be a Liouvillian)
-
-    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-        System operators coupling into the feedback loop. Can be a single
-        operator or a list of operators.
-
-    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-        System operators coupling out of the feedback loop. Can be a single
-        operator or a list of operators. L2 must have the same length as L1.
-
-    S_matrix: *array*
-        S matrix describing which operators in L1 are coupled to which
-        operators in L2 by the feedback channel. Defaults to an n by n identity
-        matrix where n is the number of elements in L1/L2.
-
-    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-        Decay operators describing conventional Markovian decay channels.
-        Can be a single operator or a list of operators.
-
-    integrator : str {'propagator', 'mesolve'}
-        Integrator method to use. Defaults to 'propagator' which tends to be
-        faster for long times (i.e., large Hilbert space).
-
-    parallel : bool
-        Run integrator in parallel if True. Only implemented for 'propagator'
-        as the integrator method.
-
-    options : dict
-        Generic solver options.
-    """
-
-    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
-                 integrator='propagator', parallel=False, options=None):
-
-        if options is None:
-            self.options = {}
-        else:
-            self.options = options
-
-        self.H_S = H_S
-        self.sysdims = H_S.dims
-        if isinstance(L1, qt.Qobj):
-            self.L1 = [L1]
-        else:
-            self.L1 = L1
-        if isinstance(L2, qt.Qobj):
-            self.L2 = [L2]
-        else:
-            self.L2 = L2
-        if not len(self.L1) == len(self.L2):
-            raise ValueError('L1 and L2 has to be of equal length.')
-        if isinstance(c_ops_markov, qt.Qobj):
-            self.c_ops_markov = [c_ops_markov]
-        else:
-            self.c_ops_markov = c_ops_markov
-
-        if S_matrix is None:
-            self.S_matrix = np.identity(len(self.L1))
-        else:
-            self.S_matrix = S_matrix
-        # create system identity superoperator
-        self.Id = qt.qeye(H_S.shape[0])
-        self.Id.dims = self.sysdims
-        self.Id = qt.sprepost(self.Id, self.Id)
-        self.store_states = self.options['store_states']
-        self.integrator = integrator
-        self.parallel = parallel
-
-    def propagator(self, t, tau, notrace=False):
-        """
-        Compute propagator for time t and time-delay tau
-
-        Parameters
-        ----------
-        t : *float*
-            current time
-
-        tau : *float*
-            time-delay
-
-        notrace : *bool* {False}
-            If this optional is set to True, a propagator is returned for a
-            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
-            If set to False (default), a generalized partial trace is performed
-            and a propagator for a single system is returned.
-        Returns
-        -------
-        : :class:`qutip.Qobj`
-            time-propagator for reduced system dynamics
-        """
-        k = int(t/tau)+1
-        s = t-(k-1)*tau
-        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
-                            self.c_ops_markov)
-        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
-                       parallel=self.parallel, opt=self.options)
-        if k > 1:
-            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
-                                  self.S_matrix, self.c_ops_markov)
-            G2 = qt.composite(G2, self.Id)
-            E = _integrate(G2, E, s, tau, integrator=self.integrator,
-                    parallel=self.parallel, opt=self.options)
-        E.dims = E0.dims
-        if not notrace:
-            E = _genptrace(E, k)
-        return E
-
-    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
-                           notrace=False):
-        r"""
-        Compute propagator for computing output field expectation values
-        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
-        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
-
-        Parameters
-        ----------
-        blist : array_like
-            List of integers specifying the field operators:
-            0: I (nothing)
-            1: b_out
-            2: b_out^\dagger
-            3: b_loop
-            4: b_loop^\dagger
-
-        tlist : array_like
-            list of corresponding times t1,..,tn at which to evaluate the field
-            operators
-
-        tau : float
-            time-delay
-
-        c1 : :class:`qutip.Qobj`
-            system collapse operator that couples to the in-loop field in
-            question (only needs to be specified if self.L1 has more than one
-            element)
-
-        c2 : :class:`qutip.Qobj`
-            system collapse operator that couples to the output field in
-            question (only needs to be specified if self.L2 has more than one
-            element)
-
-        notrace : bool {False}
-            If this optional is set to True, a propagator is returned for a
-            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
-            If set to False (default), a generalized partial trace is performed
-            and a propagator for a single system is returned.
-
-        Returns
-        -------
-        : :class:`qutip.Qobj`
-            time-propagator for computing field correlation function
-        """
-        if c1 is None and len(self.L1) == 1:
-            c1 = self.L1[0]
-        else:
-            raise ValueError('Argument c1 has to be specified when more than' +
-                             'one collapse operator couples to the feedback' +
-                             'loop.')
-        if c2 is None and len(self.L2) == 1:
-            c2 = self.L2[0]
-        else:
-            raise ValueError('Argument c1 has to be specified when more than' +
-                             'one collapse operator couples to the feedback' +
-                             'loop.')
-        klist = []
-        slist = []
-        for t in tlist:
-            klist.append(int(t/tau)+1)
-            slist.append(t-(klist[-1]-1)*tau)
-        kmax = max(klist)
-        zipped = sorted(zip(slist, klist, blist))
-        slist = [s for (s, k, b) in zipped]
-        klist = [k for (s, k, b) in zipped]
-        blist = [b for (s, k, b) in zipped]
-
-        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
-                            self.c_ops_markov)
-        sprev = 0.
-        E = E0
-        for i, s in enumerate(slist):
-            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
-                    parallel=self.parallel, opt=self.options)
-            if klist[i] == 1:
-                l1 = 0.*qt.Qobj()
-            else:
-                l1 = _localop(c1, klist[i]-1, kmax)
-            l2 = _localop(c2, klist[i], kmax)
-            if blist[i] == 0:
-                superop = self.Id
-            elif blist[i] == 1:
-                superop = qt.spre(l1+l2)
-            elif blist[i] == 2:
-                superop = qt.spost(l1.dag()+l2.dag())
-            elif blist[i] == 3:
-                superop = qt.spre(l1)
-            elif blist[i] == 4:
-                superop = qt.spost(l1.dag())
-            else:
-                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
-                                 'and 4.')
-            superop.dims = E.dims
-            E = superop*E
-            sprev = s
-        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
-                parallel=self.parallel, opt=self.options)
-
-        E.dims = E0.dims
-        if not notrace:
-            E = _genptrace(E, kmax)
-        return E
-
-    def rhot(self, rho0, t, tau):
-        """
-        Compute the reduced system density matrix :math:`\\rho(t)`
-
-        Parameters
-        ----------
-        rho0 : :class:`qutip.Qobj`
-            initial density matrix or state vector (ket)
-
-        t : float
-            current time
-
-        tau : float
-            time-delay
-
-        Returns
-        -------
-        : :class:`qutip.Qobj`
-            density matrix at time :math:`t`
-        """
-        if qt.isket(rho0):
-            rho0 = qt.ket2dm(rho0)
-
-        E = self.propagator(t, tau)
-        rhovec = qt.operator_to_vector(rho0)
-        return qt.vector_to_operator(E*rhovec)
-
-    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
-        r"""
-        Compute output field expectation value
-        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
-        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
-
-
-        Parameters
-        ----------
-        rho0 : :class:`qutip.Qobj`
-            initial density matrix or state vector (ket).
-
-        blist : array_like
-            List of integers specifying the field operators:
-            0: I (nothing)
-            1: b_out
-            2: b_out^\dagger
-            3: b_loop
-            4: b_loop^\dagger
-
-        tlist : array_like
-            list of corresponding times t1,..,tn at which to evaluate the field
-            operators
-
-        tau : float
-            time-delay
-
-        c1 : :class:`qutip.Qobj`
-            system collapse operator that couples to the in-loop field in
-            question (only needs to be specified if self.L1 has more than one
-            element)
-
-        c2 : :class:`qutip.Qobj`
-            system collapse operator that couples to the output field in
-            question (only needs to be specified if self.L2 has more than one
-            element)
-
-        Returns
-        -------
-        : complex
-            expectation value of field correlation function
-        """
-        E = self.outfieldpropagator(blist, tlist, tau)
-        rhovec = qt.operator_to_vector(rho0)
-        return (qt.vector_to_operator(E*rhovec)).tr()
-
-
-def _localop(op, l, k):
-    """
-    Create a local operator on the l'th system by tensoring
-    with identity operators on all the other k-1 systems
-    """
-    if l < 1 or l > k:
-        raise IndexError('index l out of range')
-    h = op
-    I = qt.qeye(op.shape[0])
-    I.dims = op.dims
-    for i in range(1, l):
-        h = qt.tensor(I, h)
-    for i in range(l+1, k+1):
-        h = qt.tensor(h, I)
-    return h
-
-
-def _genptrace(E, k):
-    """
-    Perform a gneralized partial trace on a superoperator E, tracing out all
-    subsystems but one.
-    """
-    for l in range(k-1):
-        nsys = len(E.dims[0][0])
-        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
-    return E
-
-
-def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
-    """
-    Create a Liouvillian for a cascaded chain of k system copies
-    """
-    id = qt.qeye(H.dims[0][0])
-    Id = qt.sprepost(id, id)
-    if S is None:
-        S = np.identity(len(L1))
-    # create Lindbladian
-    L = qt.Qobj()
-    E0 = Id
-    # first system
-    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
-    for l in range(1, k):
-        # Identiy superoperator
-        E0 = qt.composite(E0, Id)
-        # Bare Hamiltonian
-        Hl = _localop(H, l, k)
-        L += qt.liouvillian(Hl, [])
-        # Markovian Decay channels
-        if c_ops_markov is not None:
-            for c in c_ops_markov:
-                cl = _localop(c, l, k)
-                L += qt.liouvillian(None, [cl])
-        # Cascade coupling
-        c1 = np.array([_localop(c, l, k) for c in L1])
-        c2 = np.array([_localop(c, l+1, k) for c in L2])
-        c2dag = np.array([c.dag() for c in c2])
-        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
-        Hcasc += Hcasc.dag()
-        Lvec = c2 + np.dot(S, c1)
-        L += qt.liouvillian(Hcasc, [c for c in Lvec])
-    # last system
-    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
-    if c_ops_markov is not None:
-        for c in c_ops_markov:
-            cl = _localop(c, k, k)
-            L += qt.liouvillian(None, [cl])
-    E0.dims = L.dims
-    # return generator and identity superop E0
-    return L, E0
-
-
-def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
-        opt=None):
-    """
-    Basic ode integrator
-    """
-    opt = opt or {}
-    if tf > ti:
-        if integrator == 'mesolve':
-            if parallel:
-                warnings.warn('parallelization not implemented for "mesolve"')
-            opt.store_final_state = True
-            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
-            return sol.final_state
-        elif integrator == 'propagator':
-            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
-                                 options=opt)*E0
-        else:
-            raise ValueError('integrator keyword must be either "propagator"' +
-                              'or "mesolve"')
-    else:
-        return E0
+# -*- coding: utf-8 -*-
+
+# @author: Arne L. Grimsmo
+# @email1: arne.grimsmo@gmail.com
+# @organization: University of Sherbrooke
+
+"""
+This module is an implementation of the method introduced in [1], for
+solving open quantum systems subject to coherent feedback with a single
+discrete time-delay. This method is referred to as the ``memory cascade''
+method in qutip.
+
+[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
+"""
+
+import numpy as np
+import warnings
+
+import qutip as qt
+
+
+class MemoryCascade:
+    """Class for running memory cascade simulations of open quantum systems
+    with time-delayed coherent feedback.
+
+    Attributes
+    ----------
+    H_S : :class:`qutip.Qobj`
+        System Hamiltonian (can also be a Liouvillian)
+
+    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+        System operators coupling into the feedback loop. Can be a single
+        operator or a list of operators.
+
+    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+        System operators coupling out of the feedback loop. Can be a single
+        operator or a list of operators. L2 must have the same length as L1.
+
+    S_matrix: *array*
+        S matrix describing which operators in L1 are coupled to which
+        operators in L2 by the feedback channel. Defaults to an n by n identity
+        matrix where n is the number of elements in L1/L2.
+
+    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+        Decay operators describing conventional Markovian decay channels.
+        Can be a single operator or a list of operators.
+
+    integrator : str {'propagator', 'mesolve'}
+        Integrator method to use. Defaults to 'propagator' which tends to be
+        faster for long times (i.e., large Hilbert space).
+
+    parallel : bool
+        Run integrator in parallel if True. Only implemented for 'propagator'
+        as the integrator method.
+
+    options : dict
+        Generic solver options.
+    """
+
+    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
+                 integrator='propagator', parallel=False, options=None):
+
+        if options is None:
+            self.options = {}
+        else:
+            self.options = options
+
+        self.H_S = H_S
+        self.sysdims = H_S.dims
+        if isinstance(L1, qt.Qobj):
+            self.L1 = [L1]
+        else:
+            self.L1 = L1
+        if isinstance(L2, qt.Qobj):
+            self.L2 = [L2]
+        else:
+            self.L2 = L2
+        if not len(self.L1) == len(self.L2):
+            raise ValueError('L1 and L2 has to be of equal length.')
+        if isinstance(c_ops_markov, qt.Qobj):
+            self.c_ops_markov = [c_ops_markov]
+        else:
+            self.c_ops_markov = c_ops_markov
+
+        if S_matrix is None:
+            self.S_matrix = np.identity(len(self.L1))
+        else:
+            self.S_matrix = S_matrix
+        # create system identity superoperator
+        self.Id = qt.qeye(H_S.shape[0])
+        self.Id.dims = self.sysdims
+        self.Id = qt.sprepost(self.Id, self.Id)
+        self.store_states = self.options['store_states']
+        self.integrator = integrator
+        self.parallel = parallel
+
+    def propagator(self, t, tau, notrace=False):
+        """
+        Compute propagator for time t and time-delay tau
+
+        Parameters
+        ----------
+        t : *float*
+            current time
+
+        tau : *float*
+            time-delay
+
+        notrace : *bool* {False}
+            If this optional is set to True, a propagator is returned for a
+            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
+            If set to False (default), a generalized partial trace is performed
+            and a propagator for a single system is returned.
+        Returns
+        -------
+        : :class:`qutip.Qobj`
+            time-propagator for reduced system dynamics
+        """
+        k = int(t/tau)+1
+        s = t-(k-1)*tau
+        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
+                            self.c_ops_markov)
+        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
+                       parallel=self.parallel, opt=self.options)
+        if k > 1:
+            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
+                                  self.S_matrix, self.c_ops_markov)
+            G2 = qt.composite(G2, self.Id)
+            E = _integrate(G2, E, s, tau, integrator=self.integrator,
+                    parallel=self.parallel, opt=self.options)
+        E.dims = E0.dims
+        if not notrace:
+            E = _genptrace(E, k)
+        return E
+
+    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
+                           notrace=False):
+        r"""
+        Compute propagator for computing output field expectation values
+        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
+        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
+
+        Parameters
+        ----------
+        blist : array_like
+            List of integers specifying the field operators:
+            0: I (nothing)
+            1: b_out
+            2: b_out^\dagger
+            3: b_loop
+            4: b_loop^\dagger
+
+        tlist : array_like
+            list of corresponding times t1,..,tn at which to evaluate the field
+            operators
+
+        tau : float
+            time-delay
+
+        c1 : :class:`qutip.Qobj`
+            system collapse operator that couples to the in-loop field in
+            question (only needs to be specified if self.L1 has more than one
+            element)
+
+        c2 : :class:`qutip.Qobj`
+            system collapse operator that couples to the output field in
+            question (only needs to be specified if self.L2 has more than one
+            element)
+
+        notrace : bool {False}
+            If this optional is set to True, a propagator is returned for a
+            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
+            If set to False (default), a generalized partial trace is performed
+            and a propagator for a single system is returned.
+
+        Returns
+        -------
+        : :class:`qutip.Qobj`
+            time-propagator for computing field correlation function
+        """
+        if c1 is None and len(self.L1) == 1:
+            c1 = self.L1[0]
+        else:
+            raise ValueError('Argument c1 has to be specified when more than' +
+                             'one collapse operator couples to the feedback' +
+                             'loop.')
+        if c2 is None and len(self.L2) == 1:
+            c2 = self.L2[0]
+        else:
+            raise ValueError('Argument c1 has to be specified when more than' +
+                             'one collapse operator couples to the feedback' +
+                             'loop.')
+        klist = []
+        slist = []
+        for t in tlist:
+            klist.append(int(t/tau)+1)
+            slist.append(t-(klist[-1]-1)*tau)
+        kmax = max(klist)
+        zipped = sorted(zip(slist, klist, blist))
+        slist = [s for (s, k, b) in zipped]
+        klist = [k for (s, k, b) in zipped]
+        blist = [b for (s, k, b) in zipped]
+
+        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
+                            self.c_ops_markov)
+        sprev = 0.
+        E = E0
+        for i, s in enumerate(slist):
+            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
+                    parallel=self.parallel, opt=self.options)
+            if klist[i] == 1:
+                l1 = 0.*qt.Qobj()
+            else:
+                l1 = _localop(c1, klist[i]-1, kmax)
+            l2 = _localop(c2, klist[i], kmax)
+            if blist[i] == 0:
+                superop = self.Id
+            elif blist[i] == 1:
+                superop = qt.spre(l1+l2)
+            elif blist[i] == 2:
+                superop = qt.spost(l1.dag()+l2.dag())
+            elif blist[i] == 3:
+                superop = qt.spre(l1)
+            elif blist[i] == 4:
+                superop = qt.spost(l1.dag())
+            else:
+                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
+                                 'and 4.')
+            superop.dims = E.dims
+            E = superop*E
+            sprev = s
+        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
+                parallel=self.parallel, opt=self.options)
+
+        E.dims = E0.dims
+        if not notrace:
+            E = _genptrace(E, kmax)
+        return E
+
+    def rhot(self, rho0, t, tau):
+        """
+        Compute the reduced system density matrix :math:`\\rho(t)`
+
+        Parameters
+        ----------
+        rho0 : :class:`qutip.Qobj`
+            initial density matrix or state vector (ket)
+
+        t : float
+            current time
+
+        tau : float
+            time-delay
+
+        Returns
+        -------
+        : :class:`qutip.Qobj`
+            density matrix at time :math:`t`
+        """
+        if qt.isket(rho0):
+            rho0 = qt.ket2dm(rho0)
+
+        E = self.propagator(t, tau)
+        rhovec = qt.operator_to_vector(rho0)
+        return qt.vector_to_operator(E*rhovec)
+
+    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
+        r"""
+        Compute output field expectation value
+        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
+        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
+
+
+        Parameters
+        ----------
+        rho0 : :class:`qutip.Qobj`
+            initial density matrix or state vector (ket).
+
+        blist : array_like
+            List of integers specifying the field operators:
+            0: I (nothing)
+            1: b_out
+            2: b_out^\dagger
+            3: b_loop
+            4: b_loop^\dagger
+
+        tlist : array_like
+            list of corresponding times t1,..,tn at which to evaluate the field
+            operators
+
+        tau : float
+            time-delay
+
+        c1 : :class:`qutip.Qobj`
+            system collapse operator that couples to the in-loop field in
+            question (only needs to be specified if self.L1 has more than one
+            element)
+
+        c2 : :class:`qutip.Qobj`
+            system collapse operator that couples to the output field in
+            question (only needs to be specified if self.L2 has more than one
+            element)
+
+        Returns
+        -------
+        : complex
+            expectation value of field correlation function
+        """
+        E = self.outfieldpropagator(blist, tlist, tau)
+        rhovec = qt.operator_to_vector(rho0)
+        return (qt.vector_to_operator(E*rhovec)).tr()
+
+
+def _localop(op, l, k):
+    """
+    Create a local operator on the l'th system by tensoring
+    with identity operators on all the other k-1 systems
+    """
+    if l < 1 or l > k:
+        raise IndexError('index l out of range')
+    h = op
+    I = qt.qeye(op.shape[0])
+    I.dims = op.dims
+    for i in range(1, l):
+        h = qt.tensor(I, h)
+    for i in range(l+1, k+1):
+        h = qt.tensor(h, I)
+    return h
+
+
+def _genptrace(E, k):
+    """
+    Perform a gneralized partial trace on a superoperator E, tracing out all
+    subsystems but one.
+    """
+    for l in range(k-1):
+        nsys = len(E.dims[0][0])
+        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
+    return E
+
+
+def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
+    """
+    Create a Liouvillian for a cascaded chain of k system copies
+    """
+    id = qt.qeye(H.dims[0][0])
+    Id = qt.sprepost(id, id)
+    if S is None:
+        S = np.identity(len(L1))
+    # create Lindbladian
+    L = qt.Qobj()
+    E0 = Id
+    # first system
+    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
+    for l in range(1, k):
+        # Identiy superoperator
+        E0 = qt.composite(E0, Id)
+        # Bare Hamiltonian
+        Hl = _localop(H, l, k)
+        L += qt.liouvillian(Hl, [])
+        # Markovian Decay channels
+        if c_ops_markov is not None:
+            for c in c_ops_markov:
+                cl = _localop(c, l, k)
+                L += qt.liouvillian(None, [cl])
+        # Cascade coupling
+        c1 = np.array([_localop(c, l, k) for c in L1])
+        c2 = np.array([_localop(c, l+1, k) for c in L2])
+        c2dag = np.array([c.dag() for c in c2])
+        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
+        Hcasc += Hcasc.dag()
+        Lvec = c2 + np.dot(S, c1)
+        L += qt.liouvillian(Hcasc, [c for c in Lvec])
+    # last system
+    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
+    if c_ops_markov is not None:
+        for c in c_ops_markov:
+            cl = _localop(c, k, k)
+            L += qt.liouvillian(None, [cl])
+    E0.dims = L.dims
+    # return generator and identity superop E0
+    return L, E0
+
+
+def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
+        opt=None):
+    """
+    Basic ode integrator
+    """
+    opt = opt or {}
+    if tf > ti:
+        if integrator == 'mesolve':
+            if parallel:
+                warnings.warn('parallelization not implemented for "mesolve"')
+            opt.store_final_state = True
+            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
+            return sol.final_state
+        elif integrator == 'propagator':
+            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
+                                 options=opt)*E0
+        else:
+            raise ValueError('integrator keyword must be either "propagator"' +
+                              'or "mesolve"')
+    else:
+        return E0
diff --git a/qutip/solve/nonmarkov/transfertensor.py b/qutip/solve/nonmarkov/transfertensor.py
index 561b7554e1..ccd1ada8c8 100644
--- a/qutip/solve/nonmarkov/transfertensor.py
+++ b/qutip/solve/nonmarkov/transfertensor.py
@@ -1,254 +1,254 @@
-# -*- coding: utf-8 -*-
-# @author: Arne L. Grimsmo
-# @email1: arne.grimsmo@gmail.com
-# @organization: University of Sherbrooke
-
-"""
-This module contains an implementation of the non-Markovian transfer tensor
-method (TTM), introduced in [1].
-
-[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
-"""
-
-import numpy as np
-
-
-from qutip import spre, vector_to_operator, operator_to_vector
-from qutip.core import data as _data
-from ..solver import Result, SolverOptions
-
-
-class TTMSolverOptions:
-    """Class of options for the Transfer Tensor Method solver.
-
-    Attributes
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators),
-        or a callback function that returns the
-        superoperator at a given time.
-
-    times : array_like
-        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
-
-    learningtimes : array_like
-        List of times :math:`t_k` to use as learning times if argument
-        `dynmaps` is a callback function.
-
-    thres : float
-        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
-        treshold.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options.
-    """
-
-    def __init__(self, dynmaps=None, times=[], learningtimes=[],
-                 thres=0.0, options=None):
-        if options is None:
-            options = SolverOptions()
-
-        self.dynmaps = dynmaps
-        self.times = times
-        self.learningtimes = learningtimes
-        self.thres = thres
-        self.store_states = options['store_states']
-
-
-def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
-             **kwargs):
-    """
-    Solve time-evolution using the Transfer Tensor Method, based on a set of
-    precomputed dynamical maps.
-
-    Parameters
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators),
-        or a callback function that returns the
-        superoperator at a given time.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : array_like
-        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
-        Must be uniformily spaced.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    learningtimes : array_like
-        list of times :math:`t_k` for which we have knowledge of the dynamical
-        maps :math:`E(t_k)`.
-
-    tensors : array_like
-        optional list of precomputed tensors :math:`T_k`
-
-    kwargs : dictionary
-        Optional keyword arguments. See
-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
-
-    Returns
-    -------
-    output: :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-
-    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
-                           learningtimes=learningtimes, **kwargs)
-
-    diff = None
-
-    if rho0.isket:
-        rho0 = rho0.proj()
-
-    output = Result()
-    e_sops_data = []
-
-    if callable(e_ops):
-        n_expt_op = 0
-        expt_callback = True
-
-    else:
-        try:
-            tmp = e_ops[:]
-            del tmp
-
-            n_expt_op = len(e_ops)
-            expt_callback = False
-
-            if n_expt_op == 0:
-                # fall back on storing states
-                opt.store_states = True
-
-            for op in e_ops:
-                e_sops_data.append(spre(op).data)
-                if op.isherm and rho0.isherm:
-                    output.expect.append(np.zeros(len(times)))
-                else:
-                    output.expect.append(np.zeros(len(times), dtype=complex))
-        except TypeError:
-            raise TypeError("Argument 'e_ops' should be a callable or" +
-                            "list-like.")
-
-    if tensors is None:
-        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
-
-    if rho0.isoper:
-        # vectorize density matrix
-        rho0vec = operator_to_vector(rho0)
-    else:
-        # rho0 might be a super in which case we should not vectorize
-        rho0vec = rho0
-
-    K = len(tensors)
-    states = [rho0vec]
-    for n in range(1, len(times)):
-        # Set current state
-        state = None
-        for j in range(1, min(K, n + 1)):
-            tmp = tensors[j] * states[n - j]
-            state = tmp if state is None else tmp + state
-        # Append state to all states
-        states.append(state)
-    for i, r in enumerate(states):
-        if opt.store_states or expt_callback:
-            if r.type == 'operator-ket':
-                states[i] = vector_to_operator(r)
-            else:
-                states[i] = r
-            if expt_callback:
-                # use callback method
-                e_ops(times[i], states[i])
-        rdata = _data.column_stack(r.data)
-        for m in range(n_expt_op):
-            if output.expect[m].dtype == complex:
-                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
-            else:
-                output.expect[m][i] =\
-                    _data.expect_super(e_sops_data[m], rdata).real
-
-    output.solver = "ttmsolve"
-    output.times = times
-
-    output.ttmconvergence = diff
-
-    if opt.store_states:
-        output.states = states
-
-    return output
-
-
-def _generatetensors(dynmaps, learningtimes=None, **kwargs):
-    r"""
-    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
-    :math:`E(t_k)`.
-
-    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
-
-    Parameters
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators) at the times
-        specified in `learningtimes`, or a callback function that returns the
-        superoperator at a given time.
-
-    learningtimes : array_like
-        list of times :math:`t_k` to use if argument `dynmaps` is a callback
-        function.
-
-    kwargs : dictionary
-        Optional keyword arguments. See
-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
-
-    Returns
-    -------
-    Tlist: list of :class:`qutip.Qobj.`
-        A list of transfer tensors :math:`T_1,\dots,T_K`
-    """
-
-    # Determine if dynmaps is callable or list-like
-    if callable(dynmaps):
-        if learningtimes is None:
-            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
-                            "is a callback function.")
-
-        def dynmapfunc(n):
-            return dynmaps(learningtimes[n])
-
-        Kmax = len(learningtimes)
-    else:
-        try:
-            tmp = dynmaps[:]
-            del tmp
-
-            def dynmapfunc(n):
-                return dynmaps[n]
-
-            Kmax = len(dynmaps)
-        except TypeError:
-            raise TypeError("Argument 'dynmaps' should be a callable or" +
-                            "list-like.")
-
-    if "opt" not in kwargs:
-        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
-                               **kwargs)
-    else:
-        opt = kwargs['opt']
-
-    Tlist = []
-    diff = [0.0]
-    for n in range(Kmax):
-        T = dynmapfunc(n)
-        for m in range(1, n):
-            T -= Tlist[n - m] * dynmapfunc(m)
-        Tlist.append(T)
-        if n > 1:
-            diff.append((Tlist[-1] - Tlist[-2]).norm())
-            if diff[-1] < opt.thres:
-                # Below threshold for truncation
-                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
-                break
-    return Tlist, diff
+# -*- coding: utf-8 -*-
+# @author: Arne L. Grimsmo
+# @email1: arne.grimsmo@gmail.com
+# @organization: University of Sherbrooke
+
+"""
+This module contains an implementation of the non-Markovian transfer tensor
+method (TTM), introduced in [1].
+
+[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
+"""
+
+import numpy as np
+
+
+from qutip import spre, vector_to_operator, operator_to_vector
+from qutip.core import data as _data
+from ..solver import Result, SolverOptions
+
+
+class TTMSolverOptions:
+    """Class of options for the Transfer Tensor Method solver.
+
+    Attributes
+    ----------
+    dynmaps : list of :class:`qutip.Qobj`
+        List of precomputed dynamical maps (superoperators),
+        or a callback function that returns the
+        superoperator at a given time.
+
+    times : array_like
+        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
+
+    learningtimes : array_like
+        List of times :math:`t_k` to use as learning times if argument
+        `dynmaps` is a callback function.
+
+    thres : float
+        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
+        treshold.
+
+    options : :class:`qutip.solver.SolverOptions`
+        Generic solver options.
+    """
+
+    def __init__(self, dynmaps=None, times=[], learningtimes=[],
+                 thres=0.0, options=None):
+        if options is None:
+            options = SolverOptions()
+
+        self.dynmaps = dynmaps
+        self.times = times
+        self.learningtimes = learningtimes
+        self.thres = thres
+        self.store_states = options['store_states']
+
+
+def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
+             **kwargs):
+    """
+    Solve time-evolution using the Transfer Tensor Method, based on a set of
+    precomputed dynamical maps.
+
+    Parameters
+    ----------
+    dynmaps : list of :class:`qutip.Qobj`
+        List of precomputed dynamical maps (superoperators),
+        or a callback function that returns the
+        superoperator at a given time.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : array_like
+        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
+        Must be uniformily spaced.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    learningtimes : array_like
+        list of times :math:`t_k` for which we have knowledge of the dynamical
+        maps :math:`E(t_k)`.
+
+    tensors : array_like
+        optional list of precomputed tensors :math:`T_k`
+
+    kwargs : dictionary
+        Optional keyword arguments. See
+        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+
+    Returns
+    -------
+    output: :class:`qutip.solver.Result`
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+
+    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
+                           learningtimes=learningtimes, **kwargs)
+
+    diff = None
+
+    if rho0.isket:
+        rho0 = rho0.proj()
+
+    output = Result()
+    e_sops_data = []
+
+    if callable(e_ops):
+        n_expt_op = 0
+        expt_callback = True
+
+    else:
+        try:
+            tmp = e_ops[:]
+            del tmp
+
+            n_expt_op = len(e_ops)
+            expt_callback = False
+
+            if n_expt_op == 0:
+                # fall back on storing states
+                opt.store_states = True
+
+            for op in e_ops:
+                e_sops_data.append(spre(op).data)
+                if op.isherm and rho0.isherm:
+                    output.expect.append(np.zeros(len(times)))
+                else:
+                    output.expect.append(np.zeros(len(times), dtype=complex))
+        except TypeError:
+            raise TypeError("Argument 'e_ops' should be a callable or" +
+                            "list-like.")
+
+    if tensors is None:
+        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
+
+    if rho0.isoper:
+        # vectorize density matrix
+        rho0vec = operator_to_vector(rho0)
+    else:
+        # rho0 might be a super in which case we should not vectorize
+        rho0vec = rho0
+
+    K = len(tensors)
+    states = [rho0vec]
+    for n in range(1, len(times)):
+        # Set current state
+        state = None
+        for j in range(1, min(K, n + 1)):
+            tmp = tensors[j] * states[n - j]
+            state = tmp if state is None else tmp + state
+        # Append state to all states
+        states.append(state)
+    for i, r in enumerate(states):
+        if opt.store_states or expt_callback:
+            if r.type == 'operator-ket':
+                states[i] = vector_to_operator(r)
+            else:
+                states[i] = r
+            if expt_callback:
+                # use callback method
+                e_ops(times[i], states[i])
+        rdata = _data.column_stack(r.data)
+        for m in range(n_expt_op):
+            if output.expect[m].dtype == complex:
+                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
+            else:
+                output.expect[m][i] =\
+                    _data.expect_super(e_sops_data[m], rdata).real
+
+    output.solver = "ttmsolve"
+    output.times = times
+
+    output.ttmconvergence = diff
+
+    if opt.store_states:
+        output.states = states
+
+    return output
+
+
+def _generatetensors(dynmaps, learningtimes=None, **kwargs):
+    r"""
+    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
+    :math:`E(t_k)`.
+
+    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
+
+    Parameters
+    ----------
+    dynmaps : list of :class:`qutip.Qobj`
+        List of precomputed dynamical maps (superoperators) at the times
+        specified in `learningtimes`, or a callback function that returns the
+        superoperator at a given time.
+
+    learningtimes : array_like
+        list of times :math:`t_k` to use if argument `dynmaps` is a callback
+        function.
+
+    kwargs : dictionary
+        Optional keyword arguments. See
+        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+
+    Returns
+    -------
+    Tlist: list of :class:`qutip.Qobj.`
+        A list of transfer tensors :math:`T_1,\dots,T_K`
+    """
+
+    # Determine if dynmaps is callable or list-like
+    if callable(dynmaps):
+        if learningtimes is None:
+            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
+                            "is a callback function.")
+
+        def dynmapfunc(n):
+            return dynmaps(learningtimes[n])
+
+        Kmax = len(learningtimes)
+    else:
+        try:
+            tmp = dynmaps[:]
+            del tmp
+
+            def dynmapfunc(n):
+                return dynmaps[n]
+
+            Kmax = len(dynmaps)
+        except TypeError:
+            raise TypeError("Argument 'dynmaps' should be a callable or" +
+                            "list-like.")
+
+    if "opt" not in kwargs:
+        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
+                               **kwargs)
+    else:
+        opt = kwargs['opt']
+
+    Tlist = []
+    diff = [0.0]
+    for n in range(Kmax):
+        T = dynmapfunc(n)
+        for m in range(1, n):
+            T -= Tlist[n - m] * dynmapfunc(m)
+        Tlist.append(T)
+        if n > 1:
+            diff.append((Tlist[-1] - Tlist[-2]).norm())
+            if diff[-1] < opt.thres:
+                # Below threshold for truncation
+                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
+                break
+    return Tlist, diff
diff --git a/qutip/solve/optionsclass.py b/qutip/solve/optionsclass.py
index b82de81217..73c0e7090b 100644
--- a/qutip/solve/optionsclass.py
+++ b/qutip/solve/optionsclass.py
@@ -1,263 +1,263 @@
-
-
-class AllOptions:
-    """
-    Class that serve as the parent of all other options class.
-    """
-    # Temporary patch to make changes in solver's options minimal.
-    # TODO: Follow up PR based on #1812 should replace this.
-    def __init__(self):
-        self._isDefault = True
-        self._children = []
-        self._fullname = "qutip.settings"
-        self._defaultInstance = self
-
-    def _all_children(self):
-        optcls = []
-        for child in self._children:
-            optcls += child._all_children()
-        return optcls
-
-
-alloptions = AllOptions()
-
-
-def optionsclass(name, parent=alloptions):
-    """
-    Use as a decorator to register the options class to `qutip.settings`.
-    The default will be in added to qutip.setting.[parent].name.
-
-    The options class should contain an `options` dictionary containing the
-    option and their default value. Readonly settings can be defined in
-    `read_only_options` dict.
-
-    ```
-    >>> import qutip
-    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
-    >>> class MyOpt():
-    >>>     options = {"opt1": True}
-    >>>     read_only_options = {"hidden": 1}
-
-    >>> qutip.settings.solver.myopt['opt1'] = False
-    >>> qutip.settings.solver.myopt['hidden']
-    1
-
-    >>> qutip.settings.solver.myopt['hidden'] = 2
-    KeyError: "'hidden': Read-only value"
-
-    >>> print(qutip.settings.solver.myopt)
-    qutip.settings.solver.myopt:
-    opt1   : False
-    hidden : 1
-
-    print(MyOpt(opt1=2))
-    qutip.settings.solver.myopt:
-    opt1   : 2
-    hidden : 1
-    ```
-
-    It add the methods:
-        __init__(file=None, *, option=None... )
-            Allow to create from data in files or from defaults with attributes
-            overwritten by keywords.
-        __repr__():
-            Make a clean print for all 'options' and 'read_only_options'.
-        __getitem__(), __setitem__():
-            Pass through to 'self.options' and 'self.read_only_options'.
-            Option in 'self.read_only_options' can not be set.
-        save(file='qutiprc'):
-            Save the object in a file. 'qutiprc' file is loaded as default when
-            loading qutip.
-        load(file):
-            Overwrite with options previously saved.
-            Loaded options will have the same type as the default from one of:
-                (bool, int, float, complex, str, object)
-        reset():
-            If used on an instance, reset to the default in qutip.settings.
-            If used from qutip.settings..., go back to qutip's defaults.
-
-    """
-    # The real work is in _QtOptionsMaker
-    if isinstance(name, str):
-        # Called as
-        # @QtOptionsClass(name)
-        # class Options:
-        return _QtOptionsMaker(name, parent)
-    else:
-        # Called as
-        # @QtOptionsClass
-        # class Options:
-        return _QtOptionsMaker(name.__name__, parent)(name)
-
-
-class _QtOptionsMaker:
-    """
-    Apply the `optionsclass` decorator.
-    """
-    def __init__(self, name, parent):
-        self.name = name
-        self.parent = parent
-
-    def __call__(self, cls):
-        if hasattr(cls, "_isDefault"):
-            # Already a QtOptionsClass
-            return
-
-        if not hasattr(cls, "read_only_options"):
-            cls.read_only_options = {}
-        # type to used when loading from file.
-        cls._types = {key: type(val) for key, val in cls.options.items()}
-        # Name in settings and in files
-        cls._name = self.name
-        # Name when printing
-        cls._fullname = ".".join([self.parent._fullname, self.name])
-        # Is this instance the default for the other.
-        cls._isDefault = False
-        # Children in the settings tree
-        cls._children = []
-        # Build the default instance
-        # Do it before setting __init__ since it use this default
-        self._make_default(cls)
-
-        cls.__init__ = _make_init(cls.options)
-        cls.__repr__ = _repr
-        cls.__getitem__ = _getitem
-        cls.__setitem__ = _setitem
-        cls.__contains__ = _contains
-        cls.reset = _reset
-        cls.save = _save
-        cls.load = _load
-        cls._all_children = _all_children
-
-        return cls
-
-    def _make_default(self, cls):
-        """ Create the default and add it to the parent.
-        """
-        default = cls()
-        default.options = cls.options.copy()
-        default._isDefault = True
-        default._children = []
-        # The parent has the child twice: attribute and in a list.
-        self.parent._defaultInstance._children.append(default)
-        setattr(self.parent._defaultInstance, self.name, default)
-        cls._defaultInstance = default
-
-
-def _make_init(all_set):
-    attributes_kw = ",\n             ".join(["{}=None".format(key)
-                    for key in all_set])
-    attributes_set = "".join(["    if {0} is not None:\n"
-                              "        self.options['{0}'] = {0}\n".format(key)
-                     for key in all_set])
-    code = f"""
-def __init__(self, file='', *,
-             {attributes_kw},
-             _child_instance=False,
-             **kwargs):
-    self.options = self._defaultInstance.options.copy()
-{attributes_set}
-    if file:
-        self.load(file)
-    if hasattr(self, "extra_options"):
-        other_kw = dict()
-        for kw in kwargs:
-            if kw in self.extra_options:
-                self.options[kw] = kwargs[kw]
-            else:
-                other_kw[kw] = kwargs[kw]
-        kwargs = other_kw
-    self._children = []
-    for child in self._defaultInstance._children:
-        self._children.append(child.__class__(file, _child_instance=True,
-                                              **kwargs))
-        setattr(self, child._name, self._children[-1])
-        kwargs = self._children[-1].left_over_kwargs
-    if _child_instance:
-        self.left_over_kwargs = kwargs
-    elif kwargs:
-        raise KeyError("Unknown options: " +
-                       " ,".join(str(key) for key in kwargs))
-"""
-    ns = {}
-    exec(code, globals(), ns)
-    return ns["__init__"]
-
-
-def _repr(self, _recursive=True):
-    out = self._fullname + ":\n"
-    longest = max(len(key) for key in self.options)
-    if self.read_only_options:
-        longest_readonly = max(len(key) for key in self.read_only_options)
-        longest = max((longest, longest_readonly))
-    for key, val in self.options.items():
-        if isinstance(val, str):
-            out += "{:{width}} : '{}'\n".format(key, val,
-                                                width=longest)
-        else:
-            out += "{:{width}} : {}\n".format(key, val,
-                                              width=longest)
-    for key, val in self.read_only_options.items():
-        out += "{:{width}} : {}\n".format(key, val,
-                                          width=longest)
-    out += "\n"
-    if _recursive:
-         out += "".join([child.__repr__(_recursive)
-                         for child in self._children])
-    return out
-
-
-def _reset(self, _recursive=False):
-    """Reset instance to the default value or the default to Qutip's default"""
-    if self._isDefault:
-        self.options = self.__class__.options.copy()
-        if _recursive:
-            for child in self._children:
-                child.reset()
-    else:
-        self.options = self._defaultInstance.options.copy()
-
-
-def _all_children(self):
-    optcls = [self]
-    for child in self._children:
-         optcls += child._all_children()
-    return optcls
-
-
-def _save(self, file="qutiprc", _recursive=False):
-    """Save to desired file. 'qutiprc' if not specified"""
-    import qutip.configrc as qrc
-    if _recursive:
-        optcls = self._all_children()
-    else:
-        optcls = [self]
-    qrc.write_rc_object(file, optcls)
-
-
-def _load(self, file="qutiprc", _recursive=False):
-    """Load from desired file. 'qutiprc' if not specified"""
-    import qutip.configrc as qrc
-    if _recursive:
-        optcls = self._all_children()
-    else:
-        optcls = [self]
-    qrc.load_rc_object(file, optcls)
-
-
-def _contains(self, key):
-    return key in self.read_only_options or key in self.options
-
-
-def _getitem(self, key):
-    # Let the dict catch the KeyError
-    if key in self.read_only_options:
-        return self.read_only_options[key]
-    return self.options[key]
-
-
-def _setitem(self, key, value):
-    # Let the dict catch the KeyError
-    if key in self.read_only_options:
-        raise KeyError(f"'{key}': Read-only value")
-    self.options[key] = value
+
+
+class AllOptions:
+    """
+    Class that serve as the parent of all other options class.
+    """
+    # Temporary patch to make changes in solver's options minimal.
+    # TODO: Follow up PR based on #1812 should replace this.
+    def __init__(self):
+        self._isDefault = True
+        self._children = []
+        self._fullname = "qutip.settings"
+        self._defaultInstance = self
+
+    def _all_children(self):
+        optcls = []
+        for child in self._children:
+            optcls += child._all_children()
+        return optcls
+
+
+alloptions = AllOptions()
+
+
+def optionsclass(name, parent=alloptions):
+    """
+    Use as a decorator to register the options class to `qutip.settings`.
+    The default will be in added to qutip.setting.[parent].name.
+
+    The options class should contain an `options` dictionary containing the
+    option and their default value. Readonly settings can be defined in
+    `read_only_options` dict.
+
+    ```
+    >>> import qutip
+    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
+    >>> class MyOpt():
+    >>>     options = {"opt1": True}
+    >>>     read_only_options = {"hidden": 1}
+
+    >>> qutip.settings.solver.myopt['opt1'] = False
+    >>> qutip.settings.solver.myopt['hidden']
+    1
+
+    >>> qutip.settings.solver.myopt['hidden'] = 2
+    KeyError: "'hidden': Read-only value"
+
+    >>> print(qutip.settings.solver.myopt)
+    qutip.settings.solver.myopt:
+    opt1   : False
+    hidden : 1
+
+    print(MyOpt(opt1=2))
+    qutip.settings.solver.myopt:
+    opt1   : 2
+    hidden : 1
+    ```
+
+    It add the methods:
+        __init__(file=None, *, option=None... )
+            Allow to create from data in files or from defaults with attributes
+            overwritten by keywords.
+        __repr__():
+            Make a clean print for all 'options' and 'read_only_options'.
+        __getitem__(), __setitem__():
+            Pass through to 'self.options' and 'self.read_only_options'.
+            Option in 'self.read_only_options' can not be set.
+        save(file='qutiprc'):
+            Save the object in a file. 'qutiprc' file is loaded as default when
+            loading qutip.
+        load(file):
+            Overwrite with options previously saved.
+            Loaded options will have the same type as the default from one of:
+                (bool, int, float, complex, str, object)
+        reset():
+            If used on an instance, reset to the default in qutip.settings.
+            If used from qutip.settings..., go back to qutip's defaults.
+
+    """
+    # The real work is in _QtOptionsMaker
+    if isinstance(name, str):
+        # Called as
+        # @QtOptionsClass(name)
+        # class Options:
+        return _QtOptionsMaker(name, parent)
+    else:
+        # Called as
+        # @QtOptionsClass
+        # class Options:
+        return _QtOptionsMaker(name.__name__, parent)(name)
+
+
+class _QtOptionsMaker:
+    """
+    Apply the `optionsclass` decorator.
+    """
+    def __init__(self, name, parent):
+        self.name = name
+        self.parent = parent
+
+    def __call__(self, cls):
+        if hasattr(cls, "_isDefault"):
+            # Already a QtOptionsClass
+            return
+
+        if not hasattr(cls, "read_only_options"):
+            cls.read_only_options = {}
+        # type to used when loading from file.
+        cls._types = {key: type(val) for key, val in cls.options.items()}
+        # Name in settings and in files
+        cls._name = self.name
+        # Name when printing
+        cls._fullname = ".".join([self.parent._fullname, self.name])
+        # Is this instance the default for the other.
+        cls._isDefault = False
+        # Children in the settings tree
+        cls._children = []
+        # Build the default instance
+        # Do it before setting __init__ since it use this default
+        self._make_default(cls)
+
+        cls.__init__ = _make_init(cls.options)
+        cls.__repr__ = _repr
+        cls.__getitem__ = _getitem
+        cls.__setitem__ = _setitem
+        cls.__contains__ = _contains
+        cls.reset = _reset
+        cls.save = _save
+        cls.load = _load
+        cls._all_children = _all_children
+
+        return cls
+
+    def _make_default(self, cls):
+        """ Create the default and add it to the parent.
+        """
+        default = cls()
+        default.options = cls.options.copy()
+        default._isDefault = True
+        default._children = []
+        # The parent has the child twice: attribute and in a list.
+        self.parent._defaultInstance._children.append(default)
+        setattr(self.parent._defaultInstance, self.name, default)
+        cls._defaultInstance = default
+
+
+def _make_init(all_set):
+    attributes_kw = ",\n             ".join(["{}=None".format(key)
+                    for key in all_set])
+    attributes_set = "".join(["    if {0} is not None:\n"
+                              "        self.options['{0}'] = {0}\n".format(key)
+                     for key in all_set])
+    code = f"""
+def __init__(self, file='', *,
+             {attributes_kw},
+             _child_instance=False,
+             **kwargs):
+    self.options = self._defaultInstance.options.copy()
+{attributes_set}
+    if file:
+        self.load(file)
+    if hasattr(self, "extra_options"):
+        other_kw = dict()
+        for kw in kwargs:
+            if kw in self.extra_options:
+                self.options[kw] = kwargs[kw]
+            else:
+                other_kw[kw] = kwargs[kw]
+        kwargs = other_kw
+    self._children = []
+    for child in self._defaultInstance._children:
+        self._children.append(child.__class__(file, _child_instance=True,
+                                              **kwargs))
+        setattr(self, child._name, self._children[-1])
+        kwargs = self._children[-1].left_over_kwargs
+    if _child_instance:
+        self.left_over_kwargs = kwargs
+    elif kwargs:
+        raise KeyError("Unknown options: " +
+                       " ,".join(str(key) for key in kwargs))
+"""
+    ns = {}
+    exec(code, globals(), ns)
+    return ns["__init__"]
+
+
+def _repr(self, _recursive=True):
+    out = self._fullname + ":\n"
+    longest = max(len(key) for key in self.options)
+    if self.read_only_options:
+        longest_readonly = max(len(key) for key in self.read_only_options)
+        longest = max((longest, longest_readonly))
+    for key, val in self.options.items():
+        if isinstance(val, str):
+            out += "{:{width}} : '{}'\n".format(key, val,
+                                                width=longest)
+        else:
+            out += "{:{width}} : {}\n".format(key, val,
+                                              width=longest)
+    for key, val in self.read_only_options.items():
+        out += "{:{width}} : {}\n".format(key, val,
+                                          width=longest)
+    out += "\n"
+    if _recursive:
+         out += "".join([child.__repr__(_recursive)
+                         for child in self._children])
+    return out
+
+
+def _reset(self, _recursive=False):
+    """Reset instance to the default value or the default to Qutip's default"""
+    if self._isDefault:
+        self.options = self.__class__.options.copy()
+        if _recursive:
+            for child in self._children:
+                child.reset()
+    else:
+        self.options = self._defaultInstance.options.copy()
+
+
+def _all_children(self):
+    optcls = [self]
+    for child in self._children:
+         optcls += child._all_children()
+    return optcls
+
+
+def _save(self, file="qutiprc", _recursive=False):
+    """Save to desired file. 'qutiprc' if not specified"""
+    import qutip.configrc as qrc
+    if _recursive:
+        optcls = self._all_children()
+    else:
+        optcls = [self]
+    qrc.write_rc_object(file, optcls)
+
+
+def _load(self, file="qutiprc", _recursive=False):
+    """Load from desired file. 'qutiprc' if not specified"""
+    import qutip.configrc as qrc
+    if _recursive:
+        optcls = self._all_children()
+    else:
+        optcls = [self]
+    qrc.load_rc_object(file, optcls)
+
+
+def _contains(self, key):
+    return key in self.read_only_options or key in self.options
+
+
+def _getitem(self, key):
+    # Let the dict catch the KeyError
+    if key in self.read_only_options:
+        return self.read_only_options[key]
+    return self.options[key]
+
+
+def _setitem(self, key, value):
+    # Let the dict catch the KeyError
+    if key in self.read_only_options:
+        raise KeyError(f"'{key}': Read-only value")
+    self.options[key] = value
diff --git a/qutip/solve/parallel.py b/qutip/solve/parallel.py
index 36e35b8531..02f0d8f7c3 100644
--- a/qutip/solve/parallel.py
+++ b/qutip/solve/parallel.py
@@ -1,241 +1,241 @@
-"""
-This function provides functions for parallel execution of loops and function
-mappings, using the builtin Python module multiprocessing.
-"""
-__all__ = ['parallel_map', 'serial_map']
-
-from scipy import array
-import multiprocessing
-from functools import partial
-import os
-import sys
-import signal
-from qutip.settings import settings as qset
-from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
-
-
-if sys.platform == 'darwin':
-    Pool = multiprocessing.get_context('fork').Pool
-else:
-    Pool = multiprocessing.Pool
-
-
-def _task_wrapper(args):
-    try:
-        return args[0](*args[1])
-    except KeyboardInterrupt:
-        os.kill(args[2], signal.SIGINT)
-        sys.exit(1)
-
-
-def _task_wrapper_with_args(args, user_args):
-    try:
-        return args[0](*args[1], **user_args)
-    except KeyboardInterrupt:
-        os.kill(args[2], signal.SIGINT)
-        sys.exit(1)
-
-
-def parfor(func, *args, **kwargs):
-    """Executes a multi-variable function in parallel on the local machine.
-
-    Parallel execution of a for-loop over function `func` for multiple input
-    arguments and keyword arguments.
-
-    .. note::
-
-        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
-        instead of this function.
-
-    Parameters
-    ----------
-    func : function_type
-        A function to run in parallel on the local machine. The function 'func'
-        accepts a series of arguments that are passed to the function as
-        variables. In general, the function can have multiple input variables,
-        and these arguments must be passed in the same order as they are
-        defined in the function definition.  In addition, the user can pass
-        multiple keyword arguments to the function.
-
-    The following keyword argument is reserved:
-
-    num_cpus : int
-        Number of CPU's to use.  Default uses maximum number of CPU's.
-        Performance degrades if num_cpus is larger than the physical CPU
-        count of your machine.
-
-    Returns
-    -------
-    result : list
-        A ``list`` with length equal to number of input parameters
-        containing the output from `func`.
-
-    """
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    kw = _default_kwargs()
-    if 'num_cpus' in kwargs.keys():
-        kw['num_cpus'] = kwargs['num_cpus']
-        del kwargs['num_cpus']
-    if len(kwargs) != 0:
-        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
-    else:
-        task_func = _task_wrapper
-
-    # if kw['num_cpus'] > qset.num_cpus:
-    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
-    #          "is larger than physical number (%s)." % qset.num_cpus)
-    #    print("Reduce 'num_cpus' for greater performance.")
-
-    pool = Pool(processes=kw['num_cpus'])
-    args = [list(arg) for arg in args]
-    var = [[args[j][i] for j in range(len(args))]
-           for i in range(len(list(args[0])))]
-    try:
-        map_args = ((func, v, os.getpid()) for v in var)
-        par_return = list(pool.map(task_func, map_args))
-
-        pool.terminate()
-        pool.join()
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        if isinstance(par_return[0], tuple):
-            par_return = [elem for elem in par_return]
-            num_elems = len(par_return[0])
-            dt = [type(ii) for ii in par_return[0]]
-            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
-                    for ii in range(num_elems)]
-        else:
-            return par_return
-
-    except KeyboardInterrupt:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        pool.terminate()
-
-
-def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-    """
-    Serial mapping function with the same call signature as parallel_map, for
-    easy switching between serial and parallel execution. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    This function work as a drop-in replacement of
-    :func:`qutip.parallel.parallel_map`.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    progress_bar : ProgressBar
-        Progress bar class instance for showing progress.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for each
-        value in ``values``.
-
-    """
-    try:
-        progress_bar = kwargs['progress_bar']
-        if progress_bar is True:
-            progress_bar = TextProgressBar()
-    except:
-        progress_bar = BaseProgressBar()
-
-    progress_bar.start(len(values))
-    results = []
-    for n, value in enumerate(values):
-        progress_bar.update(n)
-        result = task(value, *task_args, **task_kwargs)
-        results.append(result)
-    progress_bar.finished()
-
-    return results
-
-
-def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    progress_bar : ProgressBar
-        Progress bar class instance for showing progress.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``.
-
-    """
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    kw = _default_kwargs()
-    if 'num_cpus' in kwargs:
-        kw['num_cpus'] = kwargs['num_cpus']
-
-    try:
-        progress_bar = kwargs['progress_bar']
-        if progress_bar is True:
-            progress_bar = TextProgressBar()
-    except:
-        progress_bar = BaseProgressBar()
-
-    progress_bar.start(len(values))
-    nfinished = [0]
-
-    def _update_progress_bar(x):
-        nfinished[0] += 1
-        progress_bar.update(nfinished[0])
-
-    try:
-        pool = Pool(processes=kw['num_cpus'])
-
-        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
-                                      _update_progress_bar)
-                     for value in values]
-
-        while not all([ar.ready() for ar in async_res]):
-            for ar in async_res:
-                ar.wait(timeout=0.1)
-
-        pool.terminate()
-        pool.join()
-
-    except KeyboardInterrupt as e:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        pool.terminate()
-        pool.join()
-        raise e
-
-    progress_bar.finished()
-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-    return [ar.get() for ar in async_res]
-
-
-def _default_kwargs():
-
-    settings = {'num_cpus': multiprocessing.cpu_count()}
-    return settings
+"""
+This function provides functions for parallel execution of loops and function
+mappings, using the builtin Python module multiprocessing.
+"""
+__all__ = ['parallel_map', 'serial_map']
+
+from scipy import array
+import multiprocessing
+from functools import partial
+import os
+import sys
+import signal
+from qutip.settings import settings as qset
+from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
+
+
+if sys.platform == 'darwin':
+    Pool = multiprocessing.get_context('fork').Pool
+else:
+    Pool = multiprocessing.Pool
+
+
+def _task_wrapper(args):
+    try:
+        return args[0](*args[1])
+    except KeyboardInterrupt:
+        os.kill(args[2], signal.SIGINT)
+        sys.exit(1)
+
+
+def _task_wrapper_with_args(args, user_args):
+    try:
+        return args[0](*args[1], **user_args)
+    except KeyboardInterrupt:
+        os.kill(args[2], signal.SIGINT)
+        sys.exit(1)
+
+
+def parfor(func, *args, **kwargs):
+    """Executes a multi-variable function in parallel on the local machine.
+
+    Parallel execution of a for-loop over function `func` for multiple input
+    arguments and keyword arguments.
+
+    .. note::
+
+        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
+        instead of this function.
+
+    Parameters
+    ----------
+    func : function_type
+        A function to run in parallel on the local machine. The function 'func'
+        accepts a series of arguments that are passed to the function as
+        variables. In general, the function can have multiple input variables,
+        and these arguments must be passed in the same order as they are
+        defined in the function definition.  In addition, the user can pass
+        multiple keyword arguments to the function.
+
+    The following keyword argument is reserved:
+
+    num_cpus : int
+        Number of CPU's to use.  Default uses maximum number of CPU's.
+        Performance degrades if num_cpus is larger than the physical CPU
+        count of your machine.
+
+    Returns
+    -------
+    result : list
+        A ``list`` with length equal to number of input parameters
+        containing the output from `func`.
+
+    """
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    kw = _default_kwargs()
+    if 'num_cpus' in kwargs.keys():
+        kw['num_cpus'] = kwargs['num_cpus']
+        del kwargs['num_cpus']
+    if len(kwargs) != 0:
+        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
+    else:
+        task_func = _task_wrapper
+
+    # if kw['num_cpus'] > qset.num_cpus:
+    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
+    #          "is larger than physical number (%s)." % qset.num_cpus)
+    #    print("Reduce 'num_cpus' for greater performance.")
+
+    pool = Pool(processes=kw['num_cpus'])
+    args = [list(arg) for arg in args]
+    var = [[args[j][i] for j in range(len(args))]
+           for i in range(len(list(args[0])))]
+    try:
+        map_args = ((func, v, os.getpid()) for v in var)
+        par_return = list(pool.map(task_func, map_args))
+
+        pool.terminate()
+        pool.join()
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+        if isinstance(par_return[0], tuple):
+            par_return = [elem for elem in par_return]
+            num_elems = len(par_return[0])
+            dt = [type(ii) for ii in par_return[0]]
+            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
+                    for ii in range(num_elems)]
+        else:
+            return par_return
+
+    except KeyboardInterrupt:
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+        pool.terminate()
+
+
+def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
+    """
+    Serial mapping function with the same call signature as parallel_map, for
+    easy switching between serial and parallel execution. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    This function work as a drop-in replacement of
+    :func:`qutip.parallel.parallel_map`.
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    progress_bar : ProgressBar
+        Progress bar class instance for showing progress.
+
+    Returns
+    --------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for each
+        value in ``values``.
+
+    """
+    try:
+        progress_bar = kwargs['progress_bar']
+        if progress_bar is True:
+            progress_bar = TextProgressBar()
+    except:
+        progress_bar = BaseProgressBar()
+
+    progress_bar.start(len(values))
+    results = []
+    for n, value in enumerate(values):
+        progress_bar.update(n)
+        result = task(value, *task_args, **task_kwargs)
+        results.append(result)
+    progress_bar.finished()
+
+    return results
+
+
+def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    progress_bar : ProgressBar
+        Progress bar class instance for showing progress.
+
+    Returns
+    --------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``.
+
+    """
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    kw = _default_kwargs()
+    if 'num_cpus' in kwargs:
+        kw['num_cpus'] = kwargs['num_cpus']
+
+    try:
+        progress_bar = kwargs['progress_bar']
+        if progress_bar is True:
+            progress_bar = TextProgressBar()
+    except:
+        progress_bar = BaseProgressBar()
+
+    progress_bar.start(len(values))
+    nfinished = [0]
+
+    def _update_progress_bar(x):
+        nfinished[0] += 1
+        progress_bar.update(nfinished[0])
+
+    try:
+        pool = Pool(processes=kw['num_cpus'])
+
+        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
+                                      _update_progress_bar)
+                     for value in values]
+
+        while not all([ar.ready() for ar in async_res]):
+            for ar in async_res:
+                ar.wait(timeout=0.1)
+
+        pool.terminate()
+        pool.join()
+
+    except KeyboardInterrupt as e:
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+        pool.terminate()
+        pool.join()
+        raise e
+
+    progress_bar.finished()
+    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+    return [ar.get() for ar in async_res]
+
+
+def _default_kwargs():
+
+    settings = {'num_cpus': multiprocessing.cpu_count()}
+    return settings
diff --git a/qutip/solve/pdpsolve.py b/qutip/solve/pdpsolve.py
index 1a1d2964d2..e295b23783 100644
--- a/qutip/solve/pdpsolve.py
+++ b/qutip/solve/pdpsolve.py
@@ -1,575 +1,575 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from numpy.random import RandomState
-
-from .. import (
-    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
-)
-from ..core import data as _data
-from .solver import Result, SolverOptions
-from .parallel import serial_map
-from ..ui.progressbar import TextProgressBar
-from ..settings import settings
-debug = settings.debug
-
-
-class StochasticSolverOptions:
-    """
-    Class of options for stochastic (piecewse deterministic process) PDP
-    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
-    :func:`qutip.pdpsolve.smepdpsolve`.
-    Options can be specified either as arguments to the constructor::
-
-        sso = StochasticSolverOptions(nsubsteps=100, ...)
-
-    or by changing the class attributes after creation::
-
-        sso = StochasticSolverOptions()
-        sso.nsubsteps = 1000
-
-    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
-    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
-    the constructor of these class, and internally they use these arguments to
-    construct an instance of this class, so it is rarely needed to explicitly
-    create an instance of this class.
-
-    Attributes
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        List of deterministic collapse operators.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    m_ops : list of :class:`qutip.Qobj`
-        List of operators representing the measurement operators. The expected
-        format is a nested list with one measurement operator for each
-        stochastic increament, for each stochastic collapse operator.
-
-    args : dict / list
-        List of dictionary of additional problem-specific parameters.
-        Implicit methods can adjust tolerance via args = {'tol':value}
-
-    ntraj : int
-        Number of trajectors.
-
-    nsubsteps : int
-        Number of sub steps between each time-spep given in `times`.
-
-    d1 : function
-        Function for calculating the operator-valued coefficient to the
-        deterministic increment dt.
-
-    d2 : function
-        Function for calculating the operator-valued coefficient to the
-        stochastic increment(s) dW_n, where n is in [0, d2_len[.
-
-    d2_len : int (default 1)
-        The number of stochastic increments in the process.
-
-    dW_factors : array
-        Array of length d2_len, containing scaling factors for each
-        measurement operator in m_ops.
-
-    rhs : function
-        Function for calculating the deterministic and stochastic contributions
-        to the right-hand side of the stochastic differential equation. This
-        only needs to be specified when implementing a custom SDE solver.
-
-    generate_A_ops : function
-        Function that generates a list of pre-computed operators or super-
-        operators. These precomputed operators are used in some d1 and d2
-        functions.
-
-    generate_noise : function
-        Function for generate an array of pre-computed noise signal.
-
-    homogeneous : bool (True)
-        Wheter or not the stochastic process is homogenous. Inhomogenous
-        processes are only supported for poisson distributions.
-
-    solver : string
-        Name of the solver method to use for solving the stochastic
-        equations. Valid values are:
-        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
-        'pc-euler' is a predictor-corrector method which is more
-        stable than explicit methods,
-        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
-        'milstein-imp' is semi-implicit Milstein method,
-        3/2 order algorithms: 'taylor15',
-        'taylor15-imp' is semi-implicit Taylor 1.5 method.
-        Implicit methods can adjust tolerance via args = {'tol':value},
-        default is {'tol':1e-6}
-
-    method : string ('homodyne', 'heterodyne', 'photocurrent')
-        The name of the type of measurement process that give rise to the
-        stochastic equation to solve. Specifying a method with this keyword
-        argument is a short-hand notation for using pre-defined d1 and d2
-        functions for the corresponding stochastic processes.
-
-    distribution : string ('normal', 'poisson')
-        The name of the distribution used for the stochastic increments.
-
-    store_measurements : bool (default False)
-        Whether or not to store the measurement results in the
-        :class:`qutip.solver.Result` instance returned by the solver.
-
-    noise : array
-        Vector specifying the noise.
-
-    normalize : bool (default True)
-        Whether or not to normalize the wave function during the evolution.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options.
-
-    map_func: function
-        A map function or managing the calls to single-trajactory solvers.
-
-    map_kwargs: dictionary
-        Optional keyword arguments to the map_func function function.
-
-    progress_bar : :class:`qutip.ui.BaseProgressBar`
-        Optional progress bar class instance.
-    """
-    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
-                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
-                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
-                 generate_A_ops=None, generate_noise=None, homogeneous=True,
-                 solver=None, method=None, distribution='normal',
-                 store_measurement=False, noise=None, normalize=True,
-                 options=None, progress_bar=None, map_func=None,
-                 map_kwargs=None):
-
-        if options is None:
-            options = SolverOptions()
-
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
-        self.H = H
-        self.d1 = d1
-        self.d2 = d2
-        self.d2_len = d2_len
-        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
-        self.state0 = state0
-        self.times = times
-        self.c_ops = c_ops
-        self.sc_ops = sc_ops
-        self.e_ops = e_ops
-        self.m_ops = m_ops
-
-        self.ntraj = ntraj
-        self.nsubsteps = nsubsteps
-        self.solver = solver
-        self.method = method
-        self.distribution = distribution
-        self.homogeneous = homogeneous
-        self.rhs = rhs
-        self.options = options
-        self.progress_bar = progress_bar
-        self.store_measurement = store_measurement
-        self.store_states = options['store_states']
-        self.noise = noise
-        self.args = args
-        self.normalize = normalize
-
-        self.generate_noise = generate_noise
-        self.generate_A_ops = generate_A_ops
-
-        if self.ntraj > 1 and map_func:
-            self.map_func = map_func
-        else:
-            self.map_func = serial_map
-
-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-
-        # Does any operator depend on time?
-        self.td = False
-        if not isinstance(H, Qobj):
-            self.td = True
-        for ops in c_ops:
-            if not isinstance(ops, Qobj):
-                self.td = True
-        for ops in sc_ops:
-            if not isinstance(ops, Qobj):
-                self.td = True
-
-
-def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-    trajectory simulations.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
-                                  e_ops=e_ops, **kwargs)
-
-    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for density matrix
-    evolution.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
-                                  e_ops=e_ops, **kwargs)
-
-    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-# -----------------------------------------------------------------------------
-# Generic parameterized stochastic SE PDP solver
-#
-def _ssepdpsolve_generic(sso, options, progress_bar):
-    """
-    For internal use. See ssepdpsolve.
-    """
-    N_store = len(sso.times)
-    N_substeps = sso.nsubsteps
-    dt = (sso.times[1] - sso.times[0]) / N_substeps
-    nt = sso.ntraj
-
-    data = Result()
-    data.solver = "sepdpsolve"
-    data.times = sso.tlist
-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.jump_times = []
-    data.jump_op_idx = []
-
-    # effective hamiltonian for deterministic part
-    Heff = sso.H
-    for c in sso.c_ops:
-        Heff += -0.5j * c.dag() * c
-
-    progress_bar.start(sso.ntraj)
-    for n in range(sso.ntraj):
-        progress_bar.update(n)
-        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
-
-        states_list, jump_times, jump_op_idx = \
-            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
-                                           N_store, N_substeps,
-                                           psi_t, sso.state0.dims,
-                                           sso.c_ops, sso.e_ops)
-
-        data.states.append(states_list)
-        data.jump_times.append(jump_times)
-        data.jump_op_idx.append(jump_op_idx)
-
-    progress_bar.finished()
-
-    # average density matrices
-    if options['average_states'] and np.any(data.states):
-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-                       for n in range(len(data.times))]
-
-    # average
-    data.expect = data.expect / nt
-
-    # standard error
-    if nt > 1:
-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-    else:
-        data.se = None
-
-    # convert complex data to real if hermitian
-    data.expect = [np.real(data.expect[n, :])
-                   if e.isherm else data.expect[n, :]
-                   for n, e in enumerate(sso.e_ops)]
-
-    return data
-
-
-def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
-    """
-    Internal function. See ssepdpsolve.
-    """
-    states_list = []
-
-    phi_t = psi_t.copy()
-
-    prng = RandomState()  # todo: seed it
-    r_jump, r_op = prng.rand(2)
-
-    jump_times = []
-    jump_op_idx = []
-
-    for t_idx, t in enumerate(times):
-
-        if e_ops:
-            for e_idx, e in enumerate(e_ops):
-                s = _data.expect(e, psi_t)
-                data.expect[e_idx, t_idx] += s
-                data.ss[e_idx, t_idx] += s ** 2
-        else:
-            states_list.append(Qobj(psi_t.to_array(), dims=dims))
-
-        for j in range(N_substeps):
-
-            if _data.norm.l2(phi_t) ** 2 < r_jump:
-                # jump occurs
-                p = np.array([
-                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-                    for c in c_ops
-                ])
-                p = np.cumsum(p / np.sum(p))
-                n = np.where(p >= r_op)[0][0]
-
-                # apply jump
-                psi_t = _data.matmul(c_ops[n].data, psi_t)
-                psi_t /= _data.norm.l2(psi_t)
-                phi_t = psi_t.copy()
-
-                # store info about jump
-                jump_times.append(times[t_idx] + dt * j)
-                jump_op_idx.append(n)
-
-                # get new random numbers for next jump
-                r_jump, r_op = prng.rand(2)
-
-            # deterministic evolution wihtout correction for norm decay
-            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
-
-            # deterministic evolution with correction for norm decay
-            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
-            A = 0.5 * np.sum([
-                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-                for c in c_ops
-            ])
-            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
-
-            # increment wavefunctions
-            phi_t = _data.add(phi_t, dphi_t)
-            psi_t = _data.add(psi_t, dpsi_t)
-
-            # ensure that normalized wavefunction remains normalized
-            # this allows larger time step than otherwise would be possible
-            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
-
-    return states_list, jump_times, jump_op_idx
-
-
-# -----------------------------------------------------------------------------
-# Generic parameterized stochastic ME PDP solver
-#
-def _smepdpsolve_generic(sso, options, progress_bar):
-    """
-    For internal use. See smepdpsolve.
-    """
-    N_store = len(sso.times)
-    N_substeps = sso.nsubsteps
-    dt = (sso.times[1] - sso.times[0]) / N_substeps
-    nt = sso.ntraj
-
-    data = Result()
-    data.solver = "smepdpsolve"
-    data.times = sso.times
-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.jump_times = []
-    data.jump_op_idx = []
-
-    # Liouvillian for the deterministic part.
-    # needs to be modified for TD systems
-    L = liouvillian(sso.H, sso.c_ops)
-
-    progress_bar.start(sso.ntraj)
-
-    for n in range(sso.ntraj):
-        progress_bar.update(n)
-        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
-        rho_t = _data.column_stack_dense(rho_t)
-
-        states_list, jump_times, jump_op_idx = \
-            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
-                                           N_store, N_substeps,
-                                           rho_t, sso.rho0.dims,
-                                           sso.c_ops, sso.e_ops)
-
-        data.states.append(states_list)
-        data.jump_times.append(jump_times)
-        data.jump_op_idx.append(jump_op_idx)
-
-    progress_bar.finished()
-
-    # average density matrices
-    if options['average_states'] and np.any(data.states):
-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-                       for n in range(len(data.times))]
-
-    # average
-    data.expect = data.expect / sso.ntraj
-
-    # standard error
-    if nt > 1:
-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-    else:
-        data.se = None
-
-    return data
-
-def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
-    """
-    Internal function. See smepdpsolve.
-    """
-    states_list = []
-
-    rho_t = np.copy(rho_t)
-    sigma_t = np.copy(rho_t)
-
-    prng = RandomState()  # todo: seed it
-    r_jump, r_op = prng.rand(2)
-
-    jump_times = []
-    jump_op_idx = []
-
-    for t_idx, t in enumerate(times):
-
-        if e_ops:
-            for e_idx, e in enumerate(e_ops):
-                data.expect[e_idx, t_idx] +=\
-                    _data.expect_super(e, rho_t)
-        else:
-            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
-
-        for j in range(N_substeps):
-
-            if sigma_t.norm() < r_jump:
-                # jump occurs
-                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
-                p = np.cumsum(p / np.sum(p))
-                n = np.where(p >= r_op)[0][0]
-
-                # apply jump
-                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
-                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
-                sigma_t = np.copy(rho_t)
-
-                # store info about jump
-                jump_times.append(times[t_idx] + dt * j)
-                jump_op_idx.append(n)
-
-                # get new random numbers for next jump
-                r_jump, r_op = prng.rand(2)
-
-            # deterministic evolution wihtout correction for norm decay
-            dsigma_t = _data.matmul(L.data, sigma_t) * dt
-
-            # deterministic evolution with correction for norm decay
-            drho_t = _data.matmul(L.data, rho_t) * dt
-
-            # increment density matrices
-            sigma_t = _data.add(sigma_t, dsigma_t)
-            rho_t = _data.add(rho_t, drho_t)
-
-    return states_list, jump_times, jump_op_idx
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from numpy.random import RandomState
+
+from .. import (
+    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
+)
+from ..core import data as _data
+from .solver import Result, SolverOptions
+from .parallel import serial_map
+from ..ui.progressbar import TextProgressBar
+from ..settings import settings
+debug = settings.debug
+
+
+class StochasticSolverOptions:
+    """
+    Class of options for stochastic (piecewse deterministic process) PDP
+    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
+    :func:`qutip.pdpsolve.smepdpsolve`.
+    Options can be specified either as arguments to the constructor::
+
+        sso = StochasticSolverOptions(nsubsteps=100, ...)
+
+    or by changing the class attributes after creation::
+
+        sso = StochasticSolverOptions()
+        sso.nsubsteps = 1000
+
+    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
+    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
+    the constructor of these class, and internally they use these arguments to
+    construct an instance of this class, so it is rarely needed to explicitly
+    create an instance of this class.
+
+    Attributes
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    state0 : :class:`qutip.Qobj`
+        Initial state vector (ket) or density matrix.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        List of deterministic collapse operators.
+
+    sc_ops : list of :class:`qutip.Qobj`
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the equation of motion according to how the d1 and d2 functions
+        are defined.
+
+    e_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    m_ops : list of :class:`qutip.Qobj`
+        List of operators representing the measurement operators. The expected
+        format is a nested list with one measurement operator for each
+        stochastic increament, for each stochastic collapse operator.
+
+    args : dict / list
+        List of dictionary of additional problem-specific parameters.
+        Implicit methods can adjust tolerance via args = {'tol':value}
+
+    ntraj : int
+        Number of trajectors.
+
+    nsubsteps : int
+        Number of sub steps between each time-spep given in `times`.
+
+    d1 : function
+        Function for calculating the operator-valued coefficient to the
+        deterministic increment dt.
+
+    d2 : function
+        Function for calculating the operator-valued coefficient to the
+        stochastic increment(s) dW_n, where n is in [0, d2_len[.
+
+    d2_len : int (default 1)
+        The number of stochastic increments in the process.
+
+    dW_factors : array
+        Array of length d2_len, containing scaling factors for each
+        measurement operator in m_ops.
+
+    rhs : function
+        Function for calculating the deterministic and stochastic contributions
+        to the right-hand side of the stochastic differential equation. This
+        only needs to be specified when implementing a custom SDE solver.
+
+    generate_A_ops : function
+        Function that generates a list of pre-computed operators or super-
+        operators. These precomputed operators are used in some d1 and d2
+        functions.
+
+    generate_noise : function
+        Function for generate an array of pre-computed noise signal.
+
+    homogeneous : bool (True)
+        Wheter or not the stochastic process is homogenous. Inhomogenous
+        processes are only supported for poisson distributions.
+
+    solver : string
+        Name of the solver method to use for solving the stochastic
+        equations. Valid values are:
+        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
+        'pc-euler' is a predictor-corrector method which is more
+        stable than explicit methods,
+        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
+        'milstein-imp' is semi-implicit Milstein method,
+        3/2 order algorithms: 'taylor15',
+        'taylor15-imp' is semi-implicit Taylor 1.5 method.
+        Implicit methods can adjust tolerance via args = {'tol':value},
+        default is {'tol':1e-6}
+
+    method : string ('homodyne', 'heterodyne', 'photocurrent')
+        The name of the type of measurement process that give rise to the
+        stochastic equation to solve. Specifying a method with this keyword
+        argument is a short-hand notation for using pre-defined d1 and d2
+        functions for the corresponding stochastic processes.
+
+    distribution : string ('normal', 'poisson')
+        The name of the distribution used for the stochastic increments.
+
+    store_measurements : bool (default False)
+        Whether or not to store the measurement results in the
+        :class:`qutip.solver.Result` instance returned by the solver.
+
+    noise : array
+        Vector specifying the noise.
+
+    normalize : bool (default True)
+        Whether or not to normalize the wave function during the evolution.
+
+    options : :class:`qutip.solver.SolverOptions`
+        Generic solver options.
+
+    map_func: function
+        A map function or managing the calls to single-trajactory solvers.
+
+    map_kwargs: dictionary
+        Optional keyword arguments to the map_func function function.
+
+    progress_bar : :class:`qutip.ui.BaseProgressBar`
+        Optional progress bar class instance.
+    """
+    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
+                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
+                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
+                 generate_A_ops=None, generate_noise=None, homogeneous=True,
+                 solver=None, method=None, distribution='normal',
+                 store_measurement=False, noise=None, normalize=True,
+                 options=None, progress_bar=None, map_func=None,
+                 map_kwargs=None):
+
+        if options is None:
+            options = SolverOptions()
+
+        if progress_bar is None:
+            progress_bar = TextProgressBar()
+
+        self.H = H
+        self.d1 = d1
+        self.d2 = d2
+        self.d2_len = d2_len
+        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
+        self.state0 = state0
+        self.times = times
+        self.c_ops = c_ops
+        self.sc_ops = sc_ops
+        self.e_ops = e_ops
+        self.m_ops = m_ops
+
+        self.ntraj = ntraj
+        self.nsubsteps = nsubsteps
+        self.solver = solver
+        self.method = method
+        self.distribution = distribution
+        self.homogeneous = homogeneous
+        self.rhs = rhs
+        self.options = options
+        self.progress_bar = progress_bar
+        self.store_measurement = store_measurement
+        self.store_states = options['store_states']
+        self.noise = noise
+        self.args = args
+        self.normalize = normalize
+
+        self.generate_noise = generate_noise
+        self.generate_A_ops = generate_A_ops
+
+        if self.ntraj > 1 and map_func:
+            self.map_func = map_func
+        else:
+            self.map_func = serial_map
+
+        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
+
+        # Does any operator depend on time?
+        self.td = False
+        if not isinstance(H, Qobj):
+            self.td = True
+        for ops in c_ops:
+            if not isinstance(ops, Qobj):
+                self.td = True
+        for ops in sc_ops:
+            if not isinstance(ops, Qobj):
+                self.td = True
+
+
+def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for wavefunction
+    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
+    trajectory simulations.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
+                                  e_ops=e_ops, **kwargs)
+
+    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+    return res
+
+
+def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for density matrix
+    evolution.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    sc_ops : list of :class:`qutip.Qobj`
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the equation of motion according to how the d1 and d2 functions
+        are defined.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
+                                  e_ops=e_ops, **kwargs)
+
+    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+    return res
+
+
+# -----------------------------------------------------------------------------
+# Generic parameterized stochastic SE PDP solver
+#
+def _ssepdpsolve_generic(sso, options, progress_bar):
+    """
+    For internal use. See ssepdpsolve.
+    """
+    N_store = len(sso.times)
+    N_substeps = sso.nsubsteps
+    dt = (sso.times[1] - sso.times[0]) / N_substeps
+    nt = sso.ntraj
+
+    data = Result()
+    data.solver = "sepdpsolve"
+    data.times = sso.tlist
+    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+    data.jump_times = []
+    data.jump_op_idx = []
+
+    # effective hamiltonian for deterministic part
+    Heff = sso.H
+    for c in sso.c_ops:
+        Heff += -0.5j * c.dag() * c
+
+    progress_bar.start(sso.ntraj)
+    for n in range(sso.ntraj):
+        progress_bar.update(n)
+        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
+
+        states_list, jump_times, jump_op_idx = \
+            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
+                                           N_store, N_substeps,
+                                           psi_t, sso.state0.dims,
+                                           sso.c_ops, sso.e_ops)
+
+        data.states.append(states_list)
+        data.jump_times.append(jump_times)
+        data.jump_op_idx.append(jump_op_idx)
+
+    progress_bar.finished()
+
+    # average density matrices
+    if options['average_states'] and np.any(data.states):
+        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
+                       for n in range(len(data.times))]
+
+    # average
+    data.expect = data.expect / nt
+
+    # standard error
+    if nt > 1:
+        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
+    else:
+        data.se = None
+
+    # convert complex data to real if hermitian
+    data.expect = [np.real(data.expect[n, :])
+                   if e.isherm else data.expect[n, :]
+                   for n, e in enumerate(sso.e_ops)]
+
+    return data
+
+
+def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
+    """
+    Internal function. See ssepdpsolve.
+    """
+    states_list = []
+
+    phi_t = psi_t.copy()
+
+    prng = RandomState()  # todo: seed it
+    r_jump, r_op = prng.rand(2)
+
+    jump_times = []
+    jump_op_idx = []
+
+    for t_idx, t in enumerate(times):
+
+        if e_ops:
+            for e_idx, e in enumerate(e_ops):
+                s = _data.expect(e, psi_t)
+                data.expect[e_idx, t_idx] += s
+                data.ss[e_idx, t_idx] += s ** 2
+        else:
+            states_list.append(Qobj(psi_t.to_array(), dims=dims))
+
+        for j in range(N_substeps):
+
+            if _data.norm.l2(phi_t) ** 2 < r_jump:
+                # jump occurs
+                p = np.array([
+                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
+                    for c in c_ops
+                ])
+                p = np.cumsum(p / np.sum(p))
+                n = np.where(p >= r_op)[0][0]
+
+                # apply jump
+                psi_t = _data.matmul(c_ops[n].data, psi_t)
+                psi_t /= _data.norm.l2(psi_t)
+                phi_t = psi_t.copy()
+
+                # store info about jump
+                jump_times.append(times[t_idx] + dt * j)
+                jump_op_idx.append(n)
+
+                # get new random numbers for next jump
+                r_jump, r_op = prng.rand(2)
+
+            # deterministic evolution wihtout correction for norm decay
+            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
+
+            # deterministic evolution with correction for norm decay
+            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
+            A = 0.5 * np.sum([
+                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
+                for c in c_ops
+            ])
+            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
+
+            # increment wavefunctions
+            phi_t = _data.add(phi_t, dphi_t)
+            psi_t = _data.add(psi_t, dpsi_t)
+
+            # ensure that normalized wavefunction remains normalized
+            # this allows larger time step than otherwise would be possible
+            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
+
+    return states_list, jump_times, jump_op_idx
+
+
+# -----------------------------------------------------------------------------
+# Generic parameterized stochastic ME PDP solver
+#
+def _smepdpsolve_generic(sso, options, progress_bar):
+    """
+    For internal use. See smepdpsolve.
+    """
+    N_store = len(sso.times)
+    N_substeps = sso.nsubsteps
+    dt = (sso.times[1] - sso.times[0]) / N_substeps
+    nt = sso.ntraj
+
+    data = Result()
+    data.solver = "smepdpsolve"
+    data.times = sso.times
+    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+    data.jump_times = []
+    data.jump_op_idx = []
+
+    # Liouvillian for the deterministic part.
+    # needs to be modified for TD systems
+    L = liouvillian(sso.H, sso.c_ops)
+
+    progress_bar.start(sso.ntraj)
+
+    for n in range(sso.ntraj):
+        progress_bar.update(n)
+        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
+        rho_t = _data.column_stack_dense(rho_t)
+
+        states_list, jump_times, jump_op_idx = \
+            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
+                                           N_store, N_substeps,
+                                           rho_t, sso.rho0.dims,
+                                           sso.c_ops, sso.e_ops)
+
+        data.states.append(states_list)
+        data.jump_times.append(jump_times)
+        data.jump_op_idx.append(jump_op_idx)
+
+    progress_bar.finished()
+
+    # average density matrices
+    if options['average_states'] and np.any(data.states):
+        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
+                       for n in range(len(data.times))]
+
+    # average
+    data.expect = data.expect / sso.ntraj
+
+    # standard error
+    if nt > 1:
+        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
+    else:
+        data.se = None
+
+    return data
+
+def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
+    """
+    Internal function. See smepdpsolve.
+    """
+    states_list = []
+
+    rho_t = np.copy(rho_t)
+    sigma_t = np.copy(rho_t)
+
+    prng = RandomState()  # todo: seed it
+    r_jump, r_op = prng.rand(2)
+
+    jump_times = []
+    jump_op_idx = []
+
+    for t_idx, t in enumerate(times):
+
+        if e_ops:
+            for e_idx, e in enumerate(e_ops):
+                data.expect[e_idx, t_idx] +=\
+                    _data.expect_super(e, rho_t)
+        else:
+            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
+
+        for j in range(N_substeps):
+
+            if sigma_t.norm() < r_jump:
+                # jump occurs
+                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
+                p = np.cumsum(p / np.sum(p))
+                n = np.where(p >= r_op)[0][0]
+
+                # apply jump
+                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
+                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
+                sigma_t = np.copy(rho_t)
+
+                # store info about jump
+                jump_times.append(times[t_idx] + dt * j)
+                jump_op_idx.append(n)
+
+                # get new random numbers for next jump
+                r_jump, r_op = prng.rand(2)
+
+            # deterministic evolution wihtout correction for norm decay
+            dsigma_t = _data.matmul(L.data, sigma_t) * dt
+
+            # deterministic evolution with correction for norm decay
+            drho_t = _data.matmul(L.data, rho_t) * dt
+
+            # increment density matrices
+            sigma_t = _data.add(sigma_t, dsigma_t)
+            rho_t = _data.add(rho_t, drho_t)
+
+    return states_list, jump_times, jump_op_idx
diff --git a/qutip/solve/piqs.py b/qutip/solve/piqs.py
index 2784e986cb..b475d7d9d6 100644
--- a/qutip/solve/piqs.py
+++ b/qutip/solve/piqs.py
@@ -1,1926 +1,1926 @@
-"""Permutational Invariant Quantum Solver (PIQS)
-
-This module calculates the Liouvillian for the dynamics of ensembles of
-identical two-level systems (TLS) in the presence of local and collective
-processes by exploiting permutational symmetry and using the Dicke basis.
-It also allows to characterize nonlinear functions of the density matrix.
-"""
-
-# Authors: Nathan Shammah, Shahnawaz Ahmed
-# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
-
-from math import factorial
-from decimal import Decimal
-
-import numpy as np
-from scipy.integrate import odeint
-from scipy.linalg import eigvalsh
-from scipy.special import entr
-from scipy.sparse import dok_matrix, block_diag, lil_matrix
-from .. import (
-    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
-    sigmap, sigmam,
-)
-from ..entropy import entropy_vn
-from .solver import SolverOptions, Result
-from ._piqs import Dicke as _Dicke
-from ._piqs import (
-    jmm1_dictionary,
-    _num_dicke_states,
-    _num_dicke_ladders,
-    get_blocks,
-    j_min,
-    j_vals,
-)
-
-__all__ = [
-    "num_dicke_states",
-    "num_dicke_ladders",
-    "num_tls",
-    "isdiagonal",
-    "dicke_blocks",
-    "dicke_blocks_full",
-    "dicke_function_trace",
-    "purity_dicke",
-    "entropy_vn_dicke",
-    "Dicke",
-    "state_degeneracy",
-    "m_degeneracy",
-    "energy_degeneracy",
-    "ap",
-    "am",
-    "spin_algebra",
-    "jspin",
-    "collapse_uncoupled",
-    "dicke_basis",
-    "dicke",
-    "excited",
-    "superradiant",
-    "css",
-    "ghz",
-    "ground",
-    "identity_uncoupled",
-    "block_matrix",
-    "tau_column",
-    "Pim",
-]
-
-
-def _ensure_int(x):
-    """
-    Ensure that a floating-point value `x` is exactly an integer, and return it
-    as an int.
-    """
-    out = int(x)
-    if out != x:
-        raise ValueError(f"{x} is not an integral value")
-    return out
-
-
-# Functions necessary to generate the Lindbladian/Liouvillian
-def num_dicke_states(N):
-    """Calculate the number of Dicke states.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    nds: int
-        The number of Dicke states.
-    """
-    return _num_dicke_states(N)
-
-
-def num_dicke_ladders(N):
-    """Calculate the total number of ladders in the Dicke space.
-
-    For a collection of N two-level systems it counts how many different
-    "j" exist or the number of blocks in the block-diagonal matrix.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    Nj: int
-        The number of Dicke ladders.
-    """
-    return _num_dicke_ladders(N)
-
-
-def num_tls(nds):
-    """Calculate the number of two-level systems.
-
-    Parameters
-    ----------
-    nds: int
-         The number of Dicke states.
-
-    Returns
-    -------
-    N: int
-        The number of two-level systems.
-    """
-    if np.sqrt(nds).is_integer():
-        # N is even
-        N = 2 * (np.sqrt(nds) - 1)
-    else:
-        # N is odd
-        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
-    return int(N)
-
-
-def isdiagonal(mat):
-    """
-    Check if the input matrix is diagonal.
-
-    Parameters
-    ==========
-    mat: ndarray/Qobj
-        A 2D numpy array
-
-    Returns
-    =======
-    diag: bool
-        True/False depending on whether the input matrix is diagonal.
-    """
-    if isinstance(mat, Qobj):
-        mat = mat.full()
-
-    return np.all(mat == np.diag(np.diagonal(mat)))
-
-
-# nonlinear functions of the density matrix
-def dicke_blocks(rho):
-    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems.
-
-    Returns
-    -------
-    square_blocks: list of np.array
-        Give back the blocks list.
-
-    """
-    shape_dimension = rho.shape[0]
-    N = num_tls(shape_dimension)
-    ladders = num_dicke_ladders(N)
-    # create a list with the sizes of the blocks, in order
-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-    blocks_list = [
-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-        for i in range(blocks_dimensions)
-    ]
-    blocks_list = np.flip(blocks_list, 0)
-    # create a list with each block matrix as element
-    square_blocks = []
-    block_position = 0
-    for block_size in blocks_list:
-        start_m = block_position
-        end_m = block_position + block_size
-        square_block = rho[start_m:end_m, start_m:end_m]
-        block_position = block_position + block_size
-        square_blocks.append(square_block)
-
-    return square_blocks
-
-
-def dicke_blocks_full(rho):
-    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems.
-
-    Returns
-    -------
-    full_blocks : list
-        The list of blocks expanded in the 2^N space for N qubits.
-
-    """
-    shape_dimension = rho.shape[0]
-    N = num_tls(shape_dimension)
-    ladders = num_dicke_ladders(N)
-    # create a list with the sizes of the blocks, in order
-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-    blocks_list = [
-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-        for i in range(blocks_dimensions)
-    ]
-    blocks_list = np.flip(blocks_list, 0)
-    # create a list with each block matrix as element
-    full_blocks = []
-    k = 0
-    block_position = 0
-    for block_size in blocks_list:
-        start_m = block_position
-        end_m = block_position + block_size
-        square_block = rho[start_m:end_m, start_m:end_m]
-        block_position = block_position + block_size
-        j = N / 2 - k
-        djn = state_degeneracy(N, j)
-        for block_counter in range(0, djn):
-            full_blocks.append(square_block / djn)  # preserve trace
-        k = k + 1
-    return full_blocks
-
-
-def dicke_function_trace(f, rho):
-    """Calculate the trace of a function on a Dicke density matrix.
-    Parameters
-    ----------
-    f : function
-        A Taylor-expandable function of `rho`.
-
-    rho : :class:`qutip.Qobj`
-        A density matrix in the Dicke basis.
-
-    Returns
-    -------
-    res : float
-        Trace of a nonlinear function on `rho`.
-    """
-    N = num_tls(rho.shape[0])
-    blocks = dicke_blocks(rho)
-    block_f = []
-    degen_blocks = np.flip(j_vals(N))
-    state_degeneracies = []
-    for j in degen_blocks:
-        dj = state_degeneracy(N, j)
-        state_degeneracies.append(dj)
-    eigenvals_degeneracy = []
-    deg = []
-    for i, block in enumerate(blocks):
-        dj = state_degeneracies[i]
-        normalized_block = block / dj
-        eigenvals_block = eigvalsh(normalized_block)
-        for val in eigenvals_block:
-            eigenvals_degeneracy.append(val)
-            deg.append(dj)
-
-    eigenvalue = np.array(eigenvals_degeneracy)
-    function_array = f(eigenvalue) * deg
-    return sum(function_array)
-
-
-def entropy_vn_dicke(rho):
-    """Von Neumann Entropy of a Dicke-basis density matrix.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems.
-
-    Returns
-    -------
-    entropy_dm: float
-        Entropy. Use degeneracy to multiply each block.
-
-    """
-    return dicke_function_trace(entr, rho)
-
-
-def purity_dicke(rho):
-    """Calculate purity of a density matrix in the Dicke basis.
-    It accounts for the degenerate blocks in the density matrix.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
-
-    Returns
-    -------
-    purity : float
-        The purity of the quantum state.
-        It's 1 for pure states, 0<=purity<1 for mixed states.
-    """
-    f = lambda x: x * x
-    return dicke_function_trace(f, rho)
-
-
-class Dicke(object):
-    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
-
-    Examples
-    --------
-    >>> from piqs import Dicke, jspin
-    >>> N = 2
-    >>> jx, jy, jz = jspin(N)
-    >>> jp = jspin(N, "+")
-    >>> jm = jspin(N, "-")
-    >>> ensemble = Dicke(N, emission=1.)
-    >>> L = ensemble.liouvillian()
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    hamiltonian : :class:`qutip.Qobj`
-        A Hamiltonian in the Dicke basis.
-
-        The matrix dimensions are (nds, nds),
-        with nds being the number of Dicke states.
-        The Hamiltonian can be built with the operators
-        given by the `jspin` functions.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Attributes
-    ----------
-    N: int
-        The number of two-level systems.
-
-    hamiltonian : :class:`qutip.Qobj`
-        A Hamiltonian in the Dicke basis.
-
-        The matrix dimensions are (nds, nds),
-        with nds being the number of Dicke states.
-        The Hamiltonian can be built with the operators given
-        by the `jspin` function in the "dicke" basis.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    nds: int
-        The number of Dicke states.
-
-    dshape: tuple
-        The shape of the Hilbert space in the Dicke or uncoupled basis.
-        default: (nds, nds).
-    """
-
-    def __init__(
-        self,
-        N,
-        hamiltonian=None,
-        emission=0.0,
-        dephasing=0.0,
-        pumping=0.0,
-        collective_emission=0.0,
-        collective_dephasing=0.0,
-        collective_pumping=0.0,
-    ):
-        self.N = N
-        self.hamiltonian = hamiltonian
-        self.emission = emission
-        self.dephasing = dephasing
-        self.pumping = pumping
-        self.collective_emission = collective_emission
-        self.collective_dephasing = collective_dephasing
-        self.collective_pumping = collective_pumping
-        self.nds = num_dicke_states(self.N)
-        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
-
-    def __repr__(self):
-        """Print the current parameters of the system."""
-        string = []
-        string.append("N = {}".format(self.N))
-        string.append("Hilbert space dim = {}".format(self.dshape))
-        string.append("Number of Dicke states = {}".format(self.nds))
-        string.append(
-            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
-        )
-        if self.emission != 0:
-            string.append("emission = {}".format(self.emission))
-        if self.dephasing != 0:
-            string.append("dephasing = {}".format(self.dephasing))
-        if self.pumping != 0:
-            string.append("pumping = {}".format(self.pumping))
-        if self.collective_emission != 0:
-            string.append(
-                "collective_emission = {}".format(self.collective_emission)
-            )
-        if self.collective_dephasing != 0:
-            string.append(
-                "collective_dephasing = {}".format(self.collective_dephasing)
-            )
-        if self.collective_pumping != 0:
-            string.append(
-                "collective_pumping = {}".format(self.collective_pumping)
-            )
-        return "\n".join(string)
-
-    def lindbladian(self):
-        """Build the Lindbladian superoperator of the dissipative dynamics.
-
-        Returns
-        -------
-        lindbladian : :class:`qutip.Qobj`
-            The Lindbladian matrix as a `qutip.Qobj`.
-        """
-        cythonized_dicke = _Dicke(
-            int(self.N),
-            float(self.emission),
-            float(self.dephasing),
-            float(self.pumping),
-            float(self.collective_emission),
-            float(self.collective_dephasing),
-            float(self.collective_pumping),
-        )
-        return cythonized_dicke.lindbladian()
-
-    def liouvillian(self):
-        """Build the total Liouvillian using the Dicke basis.
-
-        Returns
-        -------
-        liouv : :class:`qutip.Qobj`
-            The Liouvillian matrix for the system.
-        """
-        lindblad = self.lindbladian()
-        if self.hamiltonian is None:
-            liouv = lindblad
-
-        else:
-            hamiltonian = self.hamiltonian
-            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
-                hamiltonian
-            )
-            liouv = lindblad + hamiltonian_superoperator
-        return liouv
-
-    def pisolve(self, initial_state, tlist, options=None):
-        """
-        Solve for diagonal Hamiltonians and initial states faster.
-
-        Parameters
-        ==========
-        initial_state : :class:`qutip.Qobj`
-            An initial state specified as a density matrix of
-            `qutip.Qbj` type.
-
-        tlist: ndarray
-            A 1D numpy array of list of timesteps to integrate
-
-        options : :class:`qutip.solver.SolverOptions`
-            The options for the solver.
-
-        Returns
-        =======
-        result: list
-            A dictionary of the type `qutip.solver.Result` which holds the
-            results of the evolution.
-        """
-        if isdiagonal(initial_state) == False:
-            msg = "`pisolve` requires a diagonal initial density matrix. "
-            msg += "In general construct the Liouvillian using "
-            msg += "`piqs.liouvillian` and use qutip.mesolve."
-            raise ValueError(msg)
-
-        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
-            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
-            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
-            msg += "  use `qutip.mesolve`."
-            raise ValueError(msg)
-
-        if initial_state.full().shape != self.dshape:
-            msg = "Initial density matrix should be diagonal."
-            raise ValueError(msg)
-
-        pim = Pim(
-            self.N,
-            self.emission,
-            self.dephasing,
-            self.pumping,
-            self.collective_emission,
-            self.collective_pumping,
-            self.collective_dephasing,
-        )
-        result = pim.solve(initial_state, tlist, options=None)
-        return result
-
-    def c_ops(self):
-        """Build collapse operators in the full Hilbert space 2^N.
-
-        Returns
-        -------
-        c_ops_list: list
-            The list with the collapse operators in the 2^N Hilbert space.
-        """
-        ce = self.collective_emission
-        cd = self.collective_dephasing
-        cp = self.collective_pumping
-        c_ops_list = collapse_uncoupled(
-            N=self.N,
-            emission=self.emission,
-            dephasing=self.dephasing,
-            pumping=self.pumping,
-            collective_emission=ce,
-            collective_dephasing=cd,
-            collective_pumping=cp,
-        )
-        return c_ops_list
-
-    def coefficient_matrix(self):
-        """Build coefficient matrix for ODE for a diagonal problem.
-
-        Returns
-        -------
-        M: ndarray
-            The matrix M of the coefficients for the ODE dp/dt = Mp.
-            p is the vector of the diagonal matrix elements
-            of the density matrix rho in the Dicke basis.
-        """
-        diagonal_system = Pim(
-            N=self.N,
-            emission=self.emission,
-            dephasing=self.dephasing,
-            pumping=self.pumping,
-            collective_emission=self.collective_emission,
-            collective_dephasing=self.collective_dephasing,
-            collective_pumping=self.collective_pumping,
-        )
-        coef_matrix = diagonal_system.coefficient_matrix()
-        return coef_matrix
-
-
-# Utility functions for properties of the Dicke space
-def energy_degeneracy(N, m):
-    """Calculate the number of Dicke states with same energy.
-
-    The use of the `Decimals` class allows to explore N > 1000,
-    unlike the built-in function `scipy.special.binom`
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    m: float
-        Total spin z-axis projection eigenvalue.
-        This is proportional to the total energy.
-
-    Returns
-    -------
-    degeneracy: int
-        The energy degeneracy
-    """
-    numerator = Decimal(factorial(N))
-    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
-    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
-    degeneracy = numerator / (d1 * d2)
-    return int(degeneracy)
-
-
-def state_degeneracy(N, j):
-    r"""Calculate the degeneracy of the Dicke state.
-
-    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
-    representations :math:`\lvert j, m, \alpha\rangle`.
-
-    Uses Decimals to calculate higher numerator and denominators numbers.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    j: float
-        Total spin eigenvalue (cooperativity).
-
-    Returns
-    -------
-    degeneracy: int
-        The state degeneracy.
-    """
-    if j < 0:
-        raise ValueError("j value should be >= 0")
-    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
-    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
-    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
-    degeneracy = numerator / (denominator_1 * denominator_2)
-    degeneracy = int(np.round(float(degeneracy)))
-    return degeneracy
-
-
-def m_degeneracy(N, m):
-    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
-    same energy.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    m: float
-        Total spin z-axis projection eigenvalue (proportional to the total
-        energy).
-
-    Returns
-    -------
-    degeneracy: int
-        The m-degeneracy.
-    """
-    jvals = j_vals(N)
-    maxj = np.max(jvals)
-    if m < -maxj:
-        e = "m value is incorrect for this N."
-        e += " Minimum m value can be {}".format(-maxj)
-        raise ValueError(e)
-    degeneracy = N / 2 + 1 - abs(m)
-    return int(degeneracy)
-
-
-def ap(j, m):
-    r"""
-    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
-
-    The action of ap is given by:
-    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
-
-    Parameters
-    ----------
-    j, m: float
-        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
-
-    Returns
-    -------
-    a_plus: float
-        The value of :math:`a_{+}`.
-    """
-    a_plus = np.sqrt((j - m) * (j + m + 1))
-    return a_plus
-
-
-def am(j, m):
-    r"""Calculate the operator ``am`` used later.
-
-    The action of ``ap`` is given by:
-    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
-
-    Parameters
-    ----------
-    j: float
-        The value for j.
-
-    m: float
-        The value for m.
-
-    Returns
-    -------
-    a_minus: float
-        The value of :math:`a_{-}`.
-    """
-    a_minus = np.sqrt((j + m) * (j - m + 1))
-    return a_minus
-
-
-def spin_algebra(N, op=None):
-    """Create the list [sx, sy, sz] with the spin operators.
-
-    The operators are constructed for a collection of N two-level systems
-    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
-    objects (spin matrices), as it cointains the list of the SU(2) Pauli
-    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
-    is placed in a :math:`2^N`-dimensional Hilbert space.
-
-    Notes
-    -----
-    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    spin_operators: list or :class: qutip.Qobj
-        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
-        requested operator.
-    """
-    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
-    N = int(N)
-    sx = [0 for i in range(N)]
-    sy = [0 for i in range(N)]
-    sz = [0 for i in range(N)]
-    sp = [0 for i in range(N)]
-    sm = [0 for i in range(N)]
-
-    sx[0] = 0.5 * sigmax()
-    sy[0] = 0.5 * sigmay()
-    sz[0] = 0.5 * sigmaz()
-    sp[0] = sigmap()
-    sm[0] = sigmam()
-
-    # 2. Place operators in total Hilbert space
-    for k in range(N - 1):
-        sx[0] = tensor(sx[0], identity(2))
-        sy[0] = tensor(sy[0], identity(2))
-        sz[0] = tensor(sz[0], identity(2))
-        sp[0] = tensor(sp[0], identity(2))
-        sm[0] = tensor(sm[0], identity(2))
-
-    # 3. Cyclic sequence to create all N operators
-    a = [i for i in range(N)]
-    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
-
-    # 4. Create N operators
-    for i in range(1, N):
-        sx[i] = sx[0].permute(b[i])
-        sy[i] = sy[0].permute(b[i])
-        sz[i] = sz[0].permute(b[i])
-        sp[i] = sp[0].permute(b[i])
-        sm[i] = sm[0].permute(b[i])
-
-    spin_operators = [sx, sy, sz]
-
-    if not op:
-        return spin_operators
-    elif op == "x":
-        return sx
-    elif op == "y":
-        return sy
-    elif op == "z":
-        return sz
-    elif op == "+":
-        return sp
-    elif op == "-":
-        return sm
-    else:
-        raise TypeError("Invalid type")
-
-
-def _jspin_uncoupled(N, op=None):
-    """Construct the the collective spin algebra in the uncoupled basis.
-
-    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
-    two-level system (TLS). Each collective operator is placed in a
-    Hilbert space of dimension 2^N.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    op: str
-        The operator to return 'x','y','z','+','-'.
-        If no operator given, then output is the list of operators
-        for ['x','y','z',].
-
-    Returns
-    -------
-    collective_operators: list or :class: qutip.Qobj
-        A list of `qutip.Qobj` representing all the operators in
-        uncoupled" basis or a single operator requested.
-    """
-    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
-    N = int(N)
-
-    sx, sy, sz = spin_algebra(N)
-    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
-
-    jx = sum(sx)
-    jy = sum(sy)
-    jz = sum(sz)
-    jp = sum(sp)
-    jm = sum(sm)
-
-    collective_operators = [jx, jy, jz]
-
-    if not op:
-        return collective_operators
-    elif op == "x":
-        return jx
-    elif op == "y":
-        return jy
-    elif op == "z":
-        return jz
-    elif op == "+":
-        return jp
-    elif op == "-":
-        return jm
-    else:
-        raise TypeError("Invalid type")
-
-
-def jspin(N, op=None, basis="dicke"):
-    r"""
-    Calculate the list of collective operators of the total algebra.
-
-    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
-    default. Otherwise with "uncoupled" the operators are in a
-    :math:`2^N` space.
-
-    Parameters
-    ----------
-    N: int
-        Number of two-level systems.
-
-    op: str
-        The operator to return 'x','y','z','+','-'.
-        If no operator given, then output is the list of operators
-        for ['x','y','z'].
-
-    basis: str
-        The basis of the operators - "dicke" or "uncoupled"
-        default: "dicke".
-
-    Returns
-    -------
-    j_alg: list or :class: qutip.Qobj
-        A list of `qutip.Qobj` representing all the operators in
-        the "dicke" or "uncoupled" basis or a single operator requested.
-    """
-    if basis == "uncoupled":
-        return _jspin_uncoupled(N, op)
-
-    nds = num_dicke_states(N)
-    num_ladders = num_dicke_ladders(N)
-    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
-    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
-    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
-    s = 0
-
-    for k in range(0, num_ladders):
-        j = 0.5 * N - k
-        mmax = int(2 * j + 1)
-        for i in range(0, mmax):
-            m = j - i
-            jz_operator[s, s] = m
-            if (s + 1) in range(0, nds):
-                jp_operator[s, s + 1] = ap(j, m - 1)
-            if (s - 1) in range(0, nds):
-                jm_operator[s, s - 1] = am(j, m + 1)
-            s = s + 1
-
-    jx_operator = 1 / 2 * (jp_operator + jm_operator)
-    jy_operator = 1j / 2 * (jm_operator - jp_operator)
-    jx = Qobj(jx_operator)
-    jy = Qobj(jy_operator)
-    jz = Qobj(jz_operator)
-    jp = Qobj(jp_operator)
-    jm = Qobj(jm_operator)
-
-    if not op:
-        return [jx, jy, jz]
-    if op == "+":
-        return jp
-    elif op == "-":
-        return jm
-    elif op == "x":
-        return jx
-    elif op == "y":
-        return jy
-    elif op == "z":
-        return jz
-    else:
-        raise TypeError("Invalid type")
-
-
-def collapse_uncoupled(
-    N,
-    emission=0.0,
-    dephasing=0.0,
-    pumping=0.0,
-    collective_emission=0.0,
-    collective_dephasing=0.0,
-    collective_pumping=0.0,
-):
-    """
-    Create the collapse operators (c_ops) of the Lindbladian in the
-    uncoupled basis
-
-    These operators are in the uncoupled basis of the two-level
-    system (TLS) SU(2) Pauli matrices.
-
-    Notes
-    -----
-    The collapse operator list can be given to `qutip.mesolve`.
-    Notice that the operators are placed in a Hilbert space of
-    dimension :math:`2^N`. Thus the method is suitable only for
-    small N (of the order of 10).
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Returns
-    -------
-    c_ops: list
-        The list of collapse operators as `qutip.Qobj` for the system.
-    """
-    N = int(N)
-
-    if N > 10:
-        msg = "N > 10. dim(H) = 2^N. "
-        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
-        msg += "dimension and exploit permutational symmetry."
-        raise Warning(msg)
-
-    [sx, sy, sz] = spin_algebra(N)
-    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
-    [jx, jy, jz] = jspin(N, basis="uncoupled")
-    jp, jm = (
-        jspin(N, "+", basis="uncoupled"),
-        jspin(N, "-", basis="uncoupled"),
-    )
-
-    c_ops = []
-
-    if emission != 0:
-        for i in range(0, N):
-            c_ops.append(np.sqrt(emission) * sm[i])
-
-    if dephasing != 0:
-        for i in range(0, N):
-            c_ops.append(np.sqrt(dephasing) * sz[i])
-
-    if pumping != 0:
-        for i in range(0, N):
-            c_ops.append(np.sqrt(pumping) * sp[i])
-
-    if collective_emission != 0:
-        c_ops.append(np.sqrt(collective_emission) * jm)
-
-    if collective_dephasing != 0:
-        c_ops.append(np.sqrt(collective_dephasing) * jz)
-
-    if collective_pumping != 0:
-        c_ops.append(np.sqrt(collective_pumping) * jp)
-
-    return c_ops
-
-
-# State definitions in the Dicke basis with an option for basis transformation
-def dicke_basis(N, jmm1=None):
-    r"""
-    Initialize the density matrix of a Dicke state for several (j, m, m1).
-
-    This function can be used to build arbitrary states in the Dicke basis
-    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
-    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
-    index of the density matrix to the :math:`\lvert j, m\rangle` values is
-    given by the cythonized function `jmm1_dictionary`. A density matrix is
-    created from the given dictionary of coefficients for each (j, m, m1).
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    jmm1: dict
-        A dictionary of {(j, m, m1): p} that gives a density p for the
-        (j, m, m1) matrix element.
-
-    Returns
-    -------
-    rho: :class: qutip.Qobj
-        The density matrix in the Dicke basis.
-    """
-    if jmm1 is None:
-        msg = "Please specify the jmm1 values as a dictionary"
-        msg += "or use the `excited(N)` function to create an"
-        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
-        raise AttributeError(msg)
-
-    nds = _num_dicke_states(N)
-    rho = np.zeros((nds, nds))
-    jmm1_dict = jmm1_dictionary(N)[1]
-    for key in jmm1:
-        i, k = jmm1_dict[key]
-        rho[i, k] = jmm1[key]
-    return Qobj(rho)
-
-
-def dicke(N, j, m):
-    r"""
-    Generate a Dicke state as a pure density matrix in the Dicke basis.
-
-    For instance, the superradiant state given by
-    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
-    and the state is represented as a density matrix of size (nds, nds) or
-    (4, 4), with the (1, 1) element set to 1.
-
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    j: float
-        The eigenvalue j of the Dicke state (j, m).
-
-    m: float
-        The eigenvalue m of the Dicke state (j, m).
-
-    Returns
-    -------
-    rho: :class: qutip.Qobj
-        The density matrix.
-    """
-    nds = num_dicke_states(N)
-    rho = np.zeros((nds, nds))
-
-    jmm1_dict = jmm1_dictionary(N)[1]
-
-    i, k = jmm1_dict[(j, m, m)]
-    rho[i, k] = 1.0
-    return Qobj(rho)
-
-
-# Uncoupled states in the full Hilbert space. These are returned with the
-# choice of the keyword argument `basis="uncoupled"` in the state functions.
-def _uncoupled_excited(N):
-    """
-    Generate the density matrix of the excited Dicke state in the full
-    :math:`2^N` dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    psi0: :class: qutip.Qobj
-        The density matrix for the excited state in the uncoupled basis.
-    """
-    N = int(N)
-    jz = jspin(N, "z", basis="uncoupled")
-    en, vn = jz.eigenstates()
-    psi0 = vn[2 ** N - 1]
-    return ket2dm(psi0)
-
-
-def _uncoupled_superradiant(N):
-    """
-    Generate the density matrix of a superradiant state in the full
-    :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    psi0: :class: qutip.Qobj
-        The density matrix for the superradiant state in the full Hilbert
-        space.
-    """
-    N = int(N)
-    jz = jspin(N, "z", basis="uncoupled")
-    en, vn = jz.eigenstates()
-    psi0 = vn[2 ** N - (N + 1)]
-    return ket2dm(psi0)
-
-
-def _uncoupled_ground(N):
-    """
-    Generate the density matrix of the ground state in the full\
-    :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    psi0: :class: qutip.Qobj
-        The density matrix for the ground state in the full Hilbert space.
-    """
-    N = int(N)
-    jz = jspin(N, "z", basis="uncoupled")
-    en, vn = jz.eigenstates()
-    psi0 = vn[0]
-    return ket2dm(psi0)
-
-
-def _uncoupled_ghz(N):
-    """
-    Generate the density matrix of the GHZ state in the full 2^N
-    dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    ghz: :class: qutip.Qobj
-        The density matrix for the GHZ state in the full Hilbert space.
-    """
-    N = int(N)
-    rho = np.zeros((2 ** N, 2 ** N))
-    rho[0, 0] = 1 / 2
-    rho[2 ** N - 1, 0] = 1 / 2
-    rho[0, 2 ** N - 1] = 1 / 2
-    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
-    spin_dim = [2 for i in range(0, N)]
-    spins_dims = list((spin_dim, spin_dim))
-    rho = Qobj(rho, dims=spins_dims)
-    return rho
-
-
-def _uncoupled_css(N, a, b):
-    r"""
-    Generate the density matrix of the CSS state in the full 2^N
-    dimensional Hilbert space.
-
-    The CSS states are non-entangled states given by
-    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    a: complex
-        The coefficient of the :math:`\lvert1_i\rangle` state.
-
-    b: complex
-        The coefficient of the :math:`\lvert0_i\rangle` state.
-
-    Returns
-    -------
-    css: :class: qutip.Qobj
-        The density matrix for the CSS state in the full Hilbert space.
-    """
-    N = int(N)
-    # 1. Define i_th factorized density matrix in the uncoupled basis
-    rho_i = np.zeros((2, 2), dtype=complex)
-    rho_i[0, 0] = a * np.conj(a)
-    rho_i[1, 1] = b * np.conj(b)
-    rho_i[0, 1] = a * np.conj(b)
-    rho_i[1, 0] = b * np.conj(a)
-    rho_i = Qobj(rho_i)
-    rho = [0 for i in range(N)]
-    rho[0] = rho_i
-    # 2. Place single-two-level-system density matrices in total Hilbert space
-    for k in range(N - 1):
-        rho[0] = tensor(rho[0], identity(2))
-    # 3. Cyclic sequence to create all N factorized density matrices
-    # |CSS>_i<CSS|_i
-    a = [i for i in range(N)]
-    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
-    # 4. Create all other N-1 factorized density matrices
-    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
-    for i in range(1, N):
-        rho[i] = rho[0].permute(b[i])
-    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
-    rho_tot = identity_i
-    for i in range(0, N):
-        rho_tot = rho_tot * rho[i]
-    return rho_tot
-
-
-def excited(N, basis="dicke"):
-    """
-    Generate the density matrix for the excited state.
-
-    This state is given by (N/2, N/2) in the default Dicke basis. If the
-    argument `basis` is "uncoupled" then it generates the state in a
-    2**N dim Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The excited state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        state = _uncoupled_excited(N)
-        return state
-
-    jmm1 = {(N / 2, N / 2, N / 2): 1}
-    return dicke_basis(N, jmm1)
-
-
-def superradiant(N, basis="dicke"):
-    """
-    Generate the density matrix of the superradiant state.
-
-    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
-    If the argument `basis` is "uncoupled" then it generates the state
-    in a 2**N dim Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The superradiant state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        state = _uncoupled_superradiant(N)
-        return state
-
-    if N % 2 == 0:
-        jmm1 = {(N / 2, 0, 0): 1.0}
-        return dicke_basis(N, jmm1)
-    else:
-        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
-    return dicke_basis(N, jmm1)
-
-
-def css(
-    N,
-    x=1 / np.sqrt(2),
-    y=1 / np.sqrt(2),
-    basis="dicke",
-    coordinates="cartesian",
-):
-    r"""
-    Generate the density matrix of the Coherent Spin State (CSS).
-
-    It can be defined as,
-    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
-    with :math:`a = sin(\frac{\theta}{2})`,
-    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
-    The default basis is that of Dicke space
-    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
-    The default state is the symmetric CSS,
-    :math:`\lvert CSS\rangle = \lvert+\rangle`.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    x, y: float
-        The coefficients of the CSS state.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    coordinates: str
-        Either "cartesian" or "polar". If polar then the coefficients
-        are constructed as sin(x/2), cos(x/2)e^(iy).
-
-    Returns
-    -------
-    rho: :class: qutip.Qobj
-        The CSS state density matrix.
-    """
-    if coordinates == "polar":
-        a = np.cos(0.5 * x) * np.exp(1j * y)
-        b = np.sin(0.5 * x)
-    else:
-        a = x
-        b = y
-    if basis == "uncoupled":
-        return _uncoupled_css(N, a, b)
-    nds = num_dicke_states(N)
-    num_ladders = num_dicke_ladders(N)
-    rho = dok_matrix((nds, nds), dtype=np.complex128)
-
-    # loop in the allowed matrix elements
-    jmm1_dict = jmm1_dictionary(N)[1]
-
-    j = 0.5 * N
-    mmax = int(2 * j + 1)
-    for i in range(0, mmax):
-        m = j - i
-        psi_m = (
-            np.sqrt(float(energy_degeneracy(N, m)))
-            * a ** (N * 0.5 + m)
-            * b ** (N * 0.5 - m)
-        )
-        for i1 in range(0, mmax):
-            m1 = j - i1
-            row_column = jmm1_dict[(j, m, m1)]
-            psi_m1 = (
-                np.sqrt(float(energy_degeneracy(N, m1)))
-                * np.conj(a) ** (N * 0.5 + m1)
-                * np.conj(b) ** (N * 0.5 - m1)
-            )
-            rho[row_column] = psi_m * psi_m1
-    return Qobj(rho)
-
-
-def ghz(N, basis="dicke"):
-    """
-    Generate the density matrix of the GHZ state.
-
-    If the argument `basis` is "uncoupled" then it generates the state
-    in a :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The GHZ state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        return _uncoupled_ghz(N)
-    nds = _num_dicke_states(N)
-    rho = dok_matrix((nds, nds), dtype=np.complex128)
-    rho[0, 0] = 1 / 2
-    rho[N, N] = 1 / 2
-    rho[N, 0] = 1 / 2
-    rho[0, N] = 1 / 2
-    return Qobj(rho)
-
-
-def ground(N, basis="dicke"):
-    """
-    Generate the density matrix of the ground state.
-
-    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
-    `basis` is "uncoupled" then it generates the state in a
-    :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled"
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The ground state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        state = _uncoupled_ground(N)
-        return state
-    nds = _num_dicke_states(N)
-    rho = dok_matrix((nds, nds), dtype=np.complex128)
-    rho[N, N] = 1
-    return Qobj(rho)
-
-
-def identity_uncoupled(N):
-    """
-    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
-
-    The identity matrix is formed from the tensor product of N TLSs.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    identity: :class: qutip.Qobj
-        The identity matrix.
-    """
-    N = int(N)
-    rho = np.zeros((2 ** N, 2 ** N))
-    for i in range(0, 2 ** N):
-        rho[i, i] = 1
-    spin_dim = [2 for i in range(0, N)]
-    spins_dims = list((spin_dim, spin_dim))
-    identity = Qobj(rho, dims=spins_dims)
-    return identity
-
-
-def block_matrix(N, elements="ones"):
-    """Construct the block-diagonal matrix for the Dicke basis.
-
-    Parameters
-    ----------
-    N : int
-        Number of two-level systems.
-    elements : str {'ones' (default),'degeneracy'}
-
-    Returns
-    -------
-    block_matr : ndarray
-        A 2D block-diagonal matrix with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems. Filled with ones or the value of degeneracy
-        at each matrix element.
-    """
-    # create a list with the sizes of the blocks, in order
-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-    blocks_list = [
-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-        for i in range(blocks_dimensions)
-    ]
-    blocks_list = np.flip(blocks_list, 0)
-    # create a list with each block matrix as element
-    square_blocks = []
-    k = 0
-    for i in blocks_list:
-        if elements == "ones":
-            square_blocks.append(np.ones((i, i)))
-        elif elements == "degeneracy":
-            j = N / 2 - k
-            dj = state_degeneracy(N, j)
-            square_blocks.append(dj * np.ones((i, i)))
-        k = k + 1
-    return block_diag(square_blocks)
-
-
-# ============================================================================
-# Adding a faster version to make a Permutational Invariant matrix
-# ============================================================================
-def tau_column(tau, k, j):
-    """
-    Determine the column index for the non-zero elements of the matrix for a
-    particular row `k` and the value of `j` from the Dicke space.
-
-    Parameters
-    ----------
-    tau: str
-        The tau function to check for this `k` and `j`.
-
-    k: int
-        The row of the matrix M for which the non zero elements have
-        to be calculated.
-
-    j: float
-        The value of `j` for this row.
-    """
-    # In the notes, we indexed from k = 1, here we do it from k = 0
-    k = k + 1
-    mapping = {
-        "tau3": k - (2 * j + 3),
-        "tau2": k - 1,
-        "tau4": k + (2 * j - 1),
-        "tau5": k - (2 * j + 2),
-        "tau1": k,
-        "tau6": k + (2 * j),
-        "tau7": k - (2 * j + 1),
-        "tau8": k + 1,
-        "tau9": k + (2 * j + 1),
-    }
-    # we need to decrement k again as indexing is from 0
-    return int(mapping[tau] - 1)
-
-
-class Pim(object):
-    """
-    The Permutation Invariant Matrix class.
-
-    Initialize the class with the parameters for generating a Permutation
-    Invariant matrix which evolves a given diagonal initial state `p` as:
-
-                                dp/dt = Mp
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Attributes
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    M: dict
-        A nested dictionary of the structure {row: {col: val}} which holds
-        non zero elements of the matrix M
-    """
-
-    def __init__(
-        self,
-        N,
-        emission=0.0,
-        dephasing=0,
-        pumping=0,
-        collective_emission=0,
-        collective_pumping=0,
-        collective_dephasing=0,
-    ):
-        self.N = N
-        self.emission = emission
-        self.dephasing = dephasing
-        self.pumping = pumping
-        self.collective_pumping = collective_pumping
-        self.collective_dephasing = collective_dephasing
-        self.collective_emission = collective_emission
-        self.M = {}
-
-    def isdicke(self, dicke_row, dicke_col):
-        """
-        Check if an element in a matrix is a valid element in the Dicke space.
-        Dicke row: j value index. Dicke column: m value index.
-        The function returns True if the element exists in the Dicke space and
-        False otherwise.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col : int
-            Index of the element in Dicke space which needs to be checked
-        """
-        rows = self.N + 1
-        cols = 0
-
-        if (self.N % 2) == 0:
-            cols = int(self.N / 2 + 1)
-        else:
-            cols = int(self.N / 2 + 1 / 2)
-        if (dicke_row > rows) or (dicke_row < 0):
-            return False
-        if (dicke_col > cols) or (dicke_col < 0):
-            return False
-        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
-            return False
-        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
-            return False
-        else:
-            return True
-
-    def tau_valid(self, dicke_row, dicke_col):
-        """
-        Find the Tau functions which are valid for this value of (dicke_row,
-        dicke_col) given the number of TLS. This calculates the valid tau
-        values and reurns a dictionary specifying the tau function name and
-        the value.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col : int
-            Index of the element in Dicke space which needs to be checked.
-
-        Returns
-        -------
-        taus: dict
-            A dictionary of key, val as {tau: value} consisting of the valid
-            taus for this row and column of the Dicke space element.
-        """
-        tau_functions = [
-            self.tau3,
-            self.tau2,
-            self.tau4,
-            self.tau5,
-            self.tau1,
-            self.tau6,
-            self.tau7,
-            self.tau8,
-            self.tau9,
-        ]
-        N = self.N
-        if self.isdicke(dicke_row, dicke_col) is False:
-            return False
-        # The 3x3 sub matrix surrounding the Dicke space element to
-        # run the tau functions
-        indices = [
-            (dicke_row + x, dicke_col + y)
-            for x in range(-1, 2)
-            for y in range(-1, 2)
-        ]
-        taus = {}
-        for idx, tau in zip(indices, tau_functions):
-            if self.isdicke(idx[0], idx[1]):
-                j, m = self.calculate_j_m(idx[0], idx[1])
-                taus[tau.__name__] = tau(j, m)
-        return taus
-
-    def calculate_j_m(self, dicke_row, dicke_col):
-        """
-        Get the value of j and m for the particular Dicke space element.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col: int
-            The row and column from the Dicke space matrix
-
-        Returns
-        -------
-        j, m: float
-            The j and m values.
-        """
-        N = self.N
-        j = N / 2 - dicke_col
-        m = N / 2 - dicke_row
-        return (j, m)
-
-    def calculate_k(self, dicke_row, dicke_col):
-        """
-        Get k value from the current row and column element in the Dicke space.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col: int
-            The row and column from the Dicke space matrix.
-        Returns
-        -------
-        k: int
-            The row index for the matrix M for given Dicke space
-            element.
-        """
-        N = self.N
-        if dicke_row == 0:
-            k = dicke_col
-        else:
-            k = int(
-                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
-                + (dicke_row - (dicke_col))
-            )
-        return k
-
-    def coefficient_matrix(self):
-        """
-        Generate the matrix M governing the dynamics for diagonal cases.
-
-        If the initial density matrix and the Hamiltonian is diagonal, the
-        evolution of the system is given by the simple ODE: dp/dt = Mp.
-        """
-        N = self.N
-        nds = num_dicke_states(N)
-        rows = self.N + 1
-        cols = 0
-
-        sparse_M = lil_matrix((nds, nds), dtype=float)
-        if (self.N % 2) == 0:
-            cols = int(self.N / 2 + 1)
-        else:
-            cols = int(self.N / 2 + 1 / 2)
-        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
-            if self.isdicke(dicke_row, dicke_col):
-                k = int(self.calculate_k(dicke_row, dicke_col))
-                row = {}
-                taus = self.tau_valid(dicke_row, dicke_col)
-                for tau in taus:
-                    j, m = self.calculate_j_m(dicke_row, dicke_col)
-                    current_col = tau_column(tau, k, j)
-                    sparse_M[k, int(current_col)] = taus[tau]
-        return sparse_M.tocsr()
-
-    def solve(self, rho0, tlist, options=None):
-        """
-        Solve the ODE for the evolution of diagonal states and Hamiltonians.
-        """
-        if options is None:
-            options = SolverOptions()
-        output = Result()
-        output.solver = "pisolve"
-        output.times = tlist
-        output.states = []
-        output.states.append(Qobj(rho0))
-        rhs_generate = lambda y, tt, M: M.dot(y)
-        rho0_flat = np.diag(np.real(rho0.full()))
-        L = self.coefficient_matrix()
-        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
-        for r in rho_t[1:]:
-            diag = np.diag(r)
-            output.states.append(Qobj(diag))
-        return output
-
-    def tau1(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j, m, m).
-        """
-        yS = self.collective_emission
-        yL = self.emission
-        yD = self.dephasing
-        yP = self.pumping
-        yCP = self.collective_pumping
-        N = float(self.N)
-        spontaneous = yS * (1 + j - m) * (j + m)
-        losses = yL * (N / 2 + m)
-        pump = yP * (N / 2 - m)
-        collective_pump = yCP * (1 + j + m) * (j - m)
-        if j == 0:
-            dephase = yD * N / 4
-        else:
-            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
-        t1 = spontaneous + losses + pump + dephase + collective_pump
-        return -t1
-
-    def tau2(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j, m+1, m+1).
-        """
-        yS = self.collective_emission
-        yL = self.emission
-        N = float(self.N)
-        spontaneous = yS * (1 + j - m) * (j + m)
-        losses = yL * (
-            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
-        )
-        t2 = spontaneous + losses
-        return t2
-
-    def tau3(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
-        """
-        yL = self.emission
-        N = float(self.N)
-        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
-        den = 2 * j * (2 * j + 1)
-        t3 = yL * (num / den)
-        return t3
-
-    def tau4(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
-        """
-        yL = self.emission
-        N = float(self.N)
-        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
-        den = 2 * (j + 1) * (2 * j + 1)
-        t4 = yL * (num / den)
-        return t4
-
-    def tau5(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j+1, m, m).
-        """
-        yD = self.dephasing
-        N = float(self.N)
-        num = (j - m) * (j + m) * (j + 1 + N / 2)
-        den = 2 * j * (2 * j + 1)
-        t5 = yD * (num / den)
-        return t5
-
-    def tau6(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j-1, m, m).
-        """
-        yD = self.dephasing
-        N = float(self.N)
-        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
-        den = 2 * (j + 1) * (2 * j + 1)
-        t6 = yD * (num / den)
-        return t6
-
-    def tau7(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
-        """
-        yP = self.pumping
-        N = float(self.N)
-        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
-        den = 2 * j * (2 * j + 1)
-        t7 = yP * (float(num) / den)
-        return t7
-
-    def tau8(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j, m-1, m-1).
-        """
-        yP = self.pumping
-        yCP = self.collective_pumping
-        N = float(self.N)
-
-        num = (1 + N / 2) * (j - m) * (j + m + 1)
-        den = 2 * j * (j + 1)
-        pump = yP * (float(num) / den)
-        collective_pump = yCP * (j - m) * (j + m + 1)
-        t8 = pump + collective_pump
-        return t8
-
-    def tau9(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
-        """
-        yP = self.pumping
-        N = float(self.N)
-        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
-        den = 2 * (j + 1) * (2 * j + 1)
-        t9 = yP * (float(num) / den)
-        return t9
+"""Permutational Invariant Quantum Solver (PIQS)
+
+This module calculates the Liouvillian for the dynamics of ensembles of
+identical two-level systems (TLS) in the presence of local and collective
+processes by exploiting permutational symmetry and using the Dicke basis.
+It also allows to characterize nonlinear functions of the density matrix.
+"""
+
+# Authors: Nathan Shammah, Shahnawaz Ahmed
+# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
+
+from math import factorial
+from decimal import Decimal
+
+import numpy as np
+from scipy.integrate import odeint
+from scipy.linalg import eigvalsh
+from scipy.special import entr
+from scipy.sparse import dok_matrix, block_diag, lil_matrix
+from .. import (
+    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
+    sigmap, sigmam,
+)
+from ..entropy import entropy_vn
+from .solver import SolverOptions, Result
+from ._piqs import Dicke as _Dicke
+from ._piqs import (
+    jmm1_dictionary,
+    _num_dicke_states,
+    _num_dicke_ladders,
+    get_blocks,
+    j_min,
+    j_vals,
+)
+
+__all__ = [
+    "num_dicke_states",
+    "num_dicke_ladders",
+    "num_tls",
+    "isdiagonal",
+    "dicke_blocks",
+    "dicke_blocks_full",
+    "dicke_function_trace",
+    "purity_dicke",
+    "entropy_vn_dicke",
+    "Dicke",
+    "state_degeneracy",
+    "m_degeneracy",
+    "energy_degeneracy",
+    "ap",
+    "am",
+    "spin_algebra",
+    "jspin",
+    "collapse_uncoupled",
+    "dicke_basis",
+    "dicke",
+    "excited",
+    "superradiant",
+    "css",
+    "ghz",
+    "ground",
+    "identity_uncoupled",
+    "block_matrix",
+    "tau_column",
+    "Pim",
+]
+
+
+def _ensure_int(x):
+    """
+    Ensure that a floating-point value `x` is exactly an integer, and return it
+    as an int.
+    """
+    out = int(x)
+    if out != x:
+        raise ValueError(f"{x} is not an integral value")
+    return out
+
+
+# Functions necessary to generate the Lindbladian/Liouvillian
+def num_dicke_states(N):
+    """Calculate the number of Dicke states.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    nds: int
+        The number of Dicke states.
+    """
+    return _num_dicke_states(N)
+
+
+def num_dicke_ladders(N):
+    """Calculate the total number of ladders in the Dicke space.
+
+    For a collection of N two-level systems it counts how many different
+    "j" exist or the number of blocks in the block-diagonal matrix.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    Nj: int
+        The number of Dicke ladders.
+    """
+    return _num_dicke_ladders(N)
+
+
+def num_tls(nds):
+    """Calculate the number of two-level systems.
+
+    Parameters
+    ----------
+    nds: int
+         The number of Dicke states.
+
+    Returns
+    -------
+    N: int
+        The number of two-level systems.
+    """
+    if np.sqrt(nds).is_integer():
+        # N is even
+        N = 2 * (np.sqrt(nds) - 1)
+    else:
+        # N is odd
+        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
+    return int(N)
+
+
+def isdiagonal(mat):
+    """
+    Check if the input matrix is diagonal.
+
+    Parameters
+    ==========
+    mat: ndarray/Qobj
+        A 2D numpy array
+
+    Returns
+    =======
+    diag: bool
+        True/False depending on whether the input matrix is diagonal.
+    """
+    if isinstance(mat, Qobj):
+        mat = mat.full()
+
+    return np.all(mat == np.diag(np.diagonal(mat)))
+
+
+# nonlinear functions of the density matrix
+def dicke_blocks(rho):
+    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems.
+
+    Returns
+    -------
+    square_blocks: list of np.array
+        Give back the blocks list.
+
+    """
+    shape_dimension = rho.shape[0]
+    N = num_tls(shape_dimension)
+    ladders = num_dicke_ladders(N)
+    # create a list with the sizes of the blocks, in order
+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+    blocks_list = [
+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+        for i in range(blocks_dimensions)
+    ]
+    blocks_list = np.flip(blocks_list, 0)
+    # create a list with each block matrix as element
+    square_blocks = []
+    block_position = 0
+    for block_size in blocks_list:
+        start_m = block_position
+        end_m = block_position + block_size
+        square_block = rho[start_m:end_m, start_m:end_m]
+        block_position = block_position + block_size
+        square_blocks.append(square_block)
+
+    return square_blocks
+
+
+def dicke_blocks_full(rho):
+    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems.
+
+    Returns
+    -------
+    full_blocks : list
+        The list of blocks expanded in the 2^N space for N qubits.
+
+    """
+    shape_dimension = rho.shape[0]
+    N = num_tls(shape_dimension)
+    ladders = num_dicke_ladders(N)
+    # create a list with the sizes of the blocks, in order
+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+    blocks_list = [
+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+        for i in range(blocks_dimensions)
+    ]
+    blocks_list = np.flip(blocks_list, 0)
+    # create a list with each block matrix as element
+    full_blocks = []
+    k = 0
+    block_position = 0
+    for block_size in blocks_list:
+        start_m = block_position
+        end_m = block_position + block_size
+        square_block = rho[start_m:end_m, start_m:end_m]
+        block_position = block_position + block_size
+        j = N / 2 - k
+        djn = state_degeneracy(N, j)
+        for block_counter in range(0, djn):
+            full_blocks.append(square_block / djn)  # preserve trace
+        k = k + 1
+    return full_blocks
+
+
+def dicke_function_trace(f, rho):
+    """Calculate the trace of a function on a Dicke density matrix.
+    Parameters
+    ----------
+    f : function
+        A Taylor-expandable function of `rho`.
+
+    rho : :class:`qutip.Qobj`
+        A density matrix in the Dicke basis.
+
+    Returns
+    -------
+    res : float
+        Trace of a nonlinear function on `rho`.
+    """
+    N = num_tls(rho.shape[0])
+    blocks = dicke_blocks(rho)
+    block_f = []
+    degen_blocks = np.flip(j_vals(N))
+    state_degeneracies = []
+    for j in degen_blocks:
+        dj = state_degeneracy(N, j)
+        state_degeneracies.append(dj)
+    eigenvals_degeneracy = []
+    deg = []
+    for i, block in enumerate(blocks):
+        dj = state_degeneracies[i]
+        normalized_block = block / dj
+        eigenvals_block = eigvalsh(normalized_block)
+        for val in eigenvals_block:
+            eigenvals_degeneracy.append(val)
+            deg.append(dj)
+
+    eigenvalue = np.array(eigenvals_degeneracy)
+    function_array = f(eigenvalue) * deg
+    return sum(function_array)
+
+
+def entropy_vn_dicke(rho):
+    """Von Neumann Entropy of a Dicke-basis density matrix.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems.
+
+    Returns
+    -------
+    entropy_dm: float
+        Entropy. Use degeneracy to multiply each block.
+
+    """
+    return dicke_function_trace(entr, rho)
+
+
+def purity_dicke(rho):
+    """Calculate purity of a density matrix in the Dicke basis.
+    It accounts for the degenerate blocks in the density matrix.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
+
+    Returns
+    -------
+    purity : float
+        The purity of the quantum state.
+        It's 1 for pure states, 0<=purity<1 for mixed states.
+    """
+    f = lambda x: x * x
+    return dicke_function_trace(f, rho)
+
+
+class Dicke(object):
+    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
+
+    Examples
+    --------
+    >>> from piqs import Dicke, jspin
+    >>> N = 2
+    >>> jx, jy, jz = jspin(N)
+    >>> jp = jspin(N, "+")
+    >>> jm = jspin(N, "-")
+    >>> ensemble = Dicke(N, emission=1.)
+    >>> L = ensemble.liouvillian()
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    hamiltonian : :class:`qutip.Qobj`
+        A Hamiltonian in the Dicke basis.
+
+        The matrix dimensions are (nds, nds),
+        with nds being the number of Dicke states.
+        The Hamiltonian can be built with the operators
+        given by the `jspin` functions.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Attributes
+    ----------
+    N: int
+        The number of two-level systems.
+
+    hamiltonian : :class:`qutip.Qobj`
+        A Hamiltonian in the Dicke basis.
+
+        The matrix dimensions are (nds, nds),
+        with nds being the number of Dicke states.
+        The Hamiltonian can be built with the operators given
+        by the `jspin` function in the "dicke" basis.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    nds: int
+        The number of Dicke states.
+
+    dshape: tuple
+        The shape of the Hilbert space in the Dicke or uncoupled basis.
+        default: (nds, nds).
+    """
+
+    def __init__(
+        self,
+        N,
+        hamiltonian=None,
+        emission=0.0,
+        dephasing=0.0,
+        pumping=0.0,
+        collective_emission=0.0,
+        collective_dephasing=0.0,
+        collective_pumping=0.0,
+    ):
+        self.N = N
+        self.hamiltonian = hamiltonian
+        self.emission = emission
+        self.dephasing = dephasing
+        self.pumping = pumping
+        self.collective_emission = collective_emission
+        self.collective_dephasing = collective_dephasing
+        self.collective_pumping = collective_pumping
+        self.nds = num_dicke_states(self.N)
+        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
+
+    def __repr__(self):
+        """Print the current parameters of the system."""
+        string = []
+        string.append("N = {}".format(self.N))
+        string.append("Hilbert space dim = {}".format(self.dshape))
+        string.append("Number of Dicke states = {}".format(self.nds))
+        string.append(
+            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
+        )
+        if self.emission != 0:
+            string.append("emission = {}".format(self.emission))
+        if self.dephasing != 0:
+            string.append("dephasing = {}".format(self.dephasing))
+        if self.pumping != 0:
+            string.append("pumping = {}".format(self.pumping))
+        if self.collective_emission != 0:
+            string.append(
+                "collective_emission = {}".format(self.collective_emission)
+            )
+        if self.collective_dephasing != 0:
+            string.append(
+                "collective_dephasing = {}".format(self.collective_dephasing)
+            )
+        if self.collective_pumping != 0:
+            string.append(
+                "collective_pumping = {}".format(self.collective_pumping)
+            )
+        return "\n".join(string)
+
+    def lindbladian(self):
+        """Build the Lindbladian superoperator of the dissipative dynamics.
+
+        Returns
+        -------
+        lindbladian : :class:`qutip.Qobj`
+            The Lindbladian matrix as a `qutip.Qobj`.
+        """
+        cythonized_dicke = _Dicke(
+            int(self.N),
+            float(self.emission),
+            float(self.dephasing),
+            float(self.pumping),
+            float(self.collective_emission),
+            float(self.collective_dephasing),
+            float(self.collective_pumping),
+        )
+        return cythonized_dicke.lindbladian()
+
+    def liouvillian(self):
+        """Build the total Liouvillian using the Dicke basis.
+
+        Returns
+        -------
+        liouv : :class:`qutip.Qobj`
+            The Liouvillian matrix for the system.
+        """
+        lindblad = self.lindbladian()
+        if self.hamiltonian is None:
+            liouv = lindblad
+
+        else:
+            hamiltonian = self.hamiltonian
+            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
+                hamiltonian
+            )
+            liouv = lindblad + hamiltonian_superoperator
+        return liouv
+
+    def pisolve(self, initial_state, tlist, options=None):
+        """
+        Solve for diagonal Hamiltonians and initial states faster.
+
+        Parameters
+        ==========
+        initial_state : :class:`qutip.Qobj`
+            An initial state specified as a density matrix of
+            `qutip.Qbj` type.
+
+        tlist: ndarray
+            A 1D numpy array of list of timesteps to integrate
+
+        options : :class:`qutip.solver.SolverOptions`
+            The options for the solver.
+
+        Returns
+        =======
+        result: list
+            A dictionary of the type `qutip.solver.Result` which holds the
+            results of the evolution.
+        """
+        if isdiagonal(initial_state) == False:
+            msg = "`pisolve` requires a diagonal initial density matrix. "
+            msg += "In general construct the Liouvillian using "
+            msg += "`piqs.liouvillian` and use qutip.mesolve."
+            raise ValueError(msg)
+
+        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
+            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
+            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
+            msg += "  use `qutip.mesolve`."
+            raise ValueError(msg)
+
+        if initial_state.full().shape != self.dshape:
+            msg = "Initial density matrix should be diagonal."
+            raise ValueError(msg)
+
+        pim = Pim(
+            self.N,
+            self.emission,
+            self.dephasing,
+            self.pumping,
+            self.collective_emission,
+            self.collective_pumping,
+            self.collective_dephasing,
+        )
+        result = pim.solve(initial_state, tlist, options=None)
+        return result
+
+    def c_ops(self):
+        """Build collapse operators in the full Hilbert space 2^N.
+
+        Returns
+        -------
+        c_ops_list: list
+            The list with the collapse operators in the 2^N Hilbert space.
+        """
+        ce = self.collective_emission
+        cd = self.collective_dephasing
+        cp = self.collective_pumping
+        c_ops_list = collapse_uncoupled(
+            N=self.N,
+            emission=self.emission,
+            dephasing=self.dephasing,
+            pumping=self.pumping,
+            collective_emission=ce,
+            collective_dephasing=cd,
+            collective_pumping=cp,
+        )
+        return c_ops_list
+
+    def coefficient_matrix(self):
+        """Build coefficient matrix for ODE for a diagonal problem.
+
+        Returns
+        -------
+        M: ndarray
+            The matrix M of the coefficients for the ODE dp/dt = Mp.
+            p is the vector of the diagonal matrix elements
+            of the density matrix rho in the Dicke basis.
+        """
+        diagonal_system = Pim(
+            N=self.N,
+            emission=self.emission,
+            dephasing=self.dephasing,
+            pumping=self.pumping,
+            collective_emission=self.collective_emission,
+            collective_dephasing=self.collective_dephasing,
+            collective_pumping=self.collective_pumping,
+        )
+        coef_matrix = diagonal_system.coefficient_matrix()
+        return coef_matrix
+
+
+# Utility functions for properties of the Dicke space
+def energy_degeneracy(N, m):
+    """Calculate the number of Dicke states with same energy.
+
+    The use of the `Decimals` class allows to explore N > 1000,
+    unlike the built-in function `scipy.special.binom`
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    m: float
+        Total spin z-axis projection eigenvalue.
+        This is proportional to the total energy.
+
+    Returns
+    -------
+    degeneracy: int
+        The energy degeneracy
+    """
+    numerator = Decimal(factorial(N))
+    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
+    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
+    degeneracy = numerator / (d1 * d2)
+    return int(degeneracy)
+
+
+def state_degeneracy(N, j):
+    r"""Calculate the degeneracy of the Dicke state.
+
+    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
+    representations :math:`\lvert j, m, \alpha\rangle`.
+
+    Uses Decimals to calculate higher numerator and denominators numbers.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    j: float
+        Total spin eigenvalue (cooperativity).
+
+    Returns
+    -------
+    degeneracy: int
+        The state degeneracy.
+    """
+    if j < 0:
+        raise ValueError("j value should be >= 0")
+    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
+    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
+    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
+    degeneracy = numerator / (denominator_1 * denominator_2)
+    degeneracy = int(np.round(float(degeneracy)))
+    return degeneracy
+
+
+def m_degeneracy(N, m):
+    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
+    same energy.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    m: float
+        Total spin z-axis projection eigenvalue (proportional to the total
+        energy).
+
+    Returns
+    -------
+    degeneracy: int
+        The m-degeneracy.
+    """
+    jvals = j_vals(N)
+    maxj = np.max(jvals)
+    if m < -maxj:
+        e = "m value is incorrect for this N."
+        e += " Minimum m value can be {}".format(-maxj)
+        raise ValueError(e)
+    degeneracy = N / 2 + 1 - abs(m)
+    return int(degeneracy)
+
+
+def ap(j, m):
+    r"""
+    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
+
+    The action of ap is given by:
+    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
+
+    Parameters
+    ----------
+    j, m: float
+        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
+
+    Returns
+    -------
+    a_plus: float
+        The value of :math:`a_{+}`.
+    """
+    a_plus = np.sqrt((j - m) * (j + m + 1))
+    return a_plus
+
+
+def am(j, m):
+    r"""Calculate the operator ``am`` used later.
+
+    The action of ``ap`` is given by:
+    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
+
+    Parameters
+    ----------
+    j: float
+        The value for j.
+
+    m: float
+        The value for m.
+
+    Returns
+    -------
+    a_minus: float
+        The value of :math:`a_{-}`.
+    """
+    a_minus = np.sqrt((j + m) * (j - m + 1))
+    return a_minus
+
+
+def spin_algebra(N, op=None):
+    """Create the list [sx, sy, sz] with the spin operators.
+
+    The operators are constructed for a collection of N two-level systems
+    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
+    objects (spin matrices), as it cointains the list of the SU(2) Pauli
+    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
+    is placed in a :math:`2^N`-dimensional Hilbert space.
+
+    Notes
+    -----
+    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    spin_operators: list or :class: qutip.Qobj
+        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
+        requested operator.
+    """
+    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
+    N = int(N)
+    sx = [0 for i in range(N)]
+    sy = [0 for i in range(N)]
+    sz = [0 for i in range(N)]
+    sp = [0 for i in range(N)]
+    sm = [0 for i in range(N)]
+
+    sx[0] = 0.5 * sigmax()
+    sy[0] = 0.5 * sigmay()
+    sz[0] = 0.5 * sigmaz()
+    sp[0] = sigmap()
+    sm[0] = sigmam()
+
+    # 2. Place operators in total Hilbert space
+    for k in range(N - 1):
+        sx[0] = tensor(sx[0], identity(2))
+        sy[0] = tensor(sy[0], identity(2))
+        sz[0] = tensor(sz[0], identity(2))
+        sp[0] = tensor(sp[0], identity(2))
+        sm[0] = tensor(sm[0], identity(2))
+
+    # 3. Cyclic sequence to create all N operators
+    a = [i for i in range(N)]
+    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
+
+    # 4. Create N operators
+    for i in range(1, N):
+        sx[i] = sx[0].permute(b[i])
+        sy[i] = sy[0].permute(b[i])
+        sz[i] = sz[0].permute(b[i])
+        sp[i] = sp[0].permute(b[i])
+        sm[i] = sm[0].permute(b[i])
+
+    spin_operators = [sx, sy, sz]
+
+    if not op:
+        return spin_operators
+    elif op == "x":
+        return sx
+    elif op == "y":
+        return sy
+    elif op == "z":
+        return sz
+    elif op == "+":
+        return sp
+    elif op == "-":
+        return sm
+    else:
+        raise TypeError("Invalid type")
+
+
+def _jspin_uncoupled(N, op=None):
+    """Construct the the collective spin algebra in the uncoupled basis.
+
+    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
+    two-level system (TLS). Each collective operator is placed in a
+    Hilbert space of dimension 2^N.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    op: str
+        The operator to return 'x','y','z','+','-'.
+        If no operator given, then output is the list of operators
+        for ['x','y','z',].
+
+    Returns
+    -------
+    collective_operators: list or :class: qutip.Qobj
+        A list of `qutip.Qobj` representing all the operators in
+        uncoupled" basis or a single operator requested.
+    """
+    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
+    N = int(N)
+
+    sx, sy, sz = spin_algebra(N)
+    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
+
+    jx = sum(sx)
+    jy = sum(sy)
+    jz = sum(sz)
+    jp = sum(sp)
+    jm = sum(sm)
+
+    collective_operators = [jx, jy, jz]
+
+    if not op:
+        return collective_operators
+    elif op == "x":
+        return jx
+    elif op == "y":
+        return jy
+    elif op == "z":
+        return jz
+    elif op == "+":
+        return jp
+    elif op == "-":
+        return jm
+    else:
+        raise TypeError("Invalid type")
+
+
+def jspin(N, op=None, basis="dicke"):
+    r"""
+    Calculate the list of collective operators of the total algebra.
+
+    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
+    default. Otherwise with "uncoupled" the operators are in a
+    :math:`2^N` space.
+
+    Parameters
+    ----------
+    N: int
+        Number of two-level systems.
+
+    op: str
+        The operator to return 'x','y','z','+','-'.
+        If no operator given, then output is the list of operators
+        for ['x','y','z'].
+
+    basis: str
+        The basis of the operators - "dicke" or "uncoupled"
+        default: "dicke".
+
+    Returns
+    -------
+    j_alg: list or :class: qutip.Qobj
+        A list of `qutip.Qobj` representing all the operators in
+        the "dicke" or "uncoupled" basis or a single operator requested.
+    """
+    if basis == "uncoupled":
+        return _jspin_uncoupled(N, op)
+
+    nds = num_dicke_states(N)
+    num_ladders = num_dicke_ladders(N)
+    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
+    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
+    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
+    s = 0
+
+    for k in range(0, num_ladders):
+        j = 0.5 * N - k
+        mmax = int(2 * j + 1)
+        for i in range(0, mmax):
+            m = j - i
+            jz_operator[s, s] = m
+            if (s + 1) in range(0, nds):
+                jp_operator[s, s + 1] = ap(j, m - 1)
+            if (s - 1) in range(0, nds):
+                jm_operator[s, s - 1] = am(j, m + 1)
+            s = s + 1
+
+    jx_operator = 1 / 2 * (jp_operator + jm_operator)
+    jy_operator = 1j / 2 * (jm_operator - jp_operator)
+    jx = Qobj(jx_operator)
+    jy = Qobj(jy_operator)
+    jz = Qobj(jz_operator)
+    jp = Qobj(jp_operator)
+    jm = Qobj(jm_operator)
+
+    if not op:
+        return [jx, jy, jz]
+    if op == "+":
+        return jp
+    elif op == "-":
+        return jm
+    elif op == "x":
+        return jx
+    elif op == "y":
+        return jy
+    elif op == "z":
+        return jz
+    else:
+        raise TypeError("Invalid type")
+
+
+def collapse_uncoupled(
+    N,
+    emission=0.0,
+    dephasing=0.0,
+    pumping=0.0,
+    collective_emission=0.0,
+    collective_dephasing=0.0,
+    collective_pumping=0.0,
+):
+    """
+    Create the collapse operators (c_ops) of the Lindbladian in the
+    uncoupled basis
+
+    These operators are in the uncoupled basis of the two-level
+    system (TLS) SU(2) Pauli matrices.
+
+    Notes
+    -----
+    The collapse operator list can be given to `qutip.mesolve`.
+    Notice that the operators are placed in a Hilbert space of
+    dimension :math:`2^N`. Thus the method is suitable only for
+    small N (of the order of 10).
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Returns
+    -------
+    c_ops: list
+        The list of collapse operators as `qutip.Qobj` for the system.
+    """
+    N = int(N)
+
+    if N > 10:
+        msg = "N > 10. dim(H) = 2^N. "
+        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
+        msg += "dimension and exploit permutational symmetry."
+        raise Warning(msg)
+
+    [sx, sy, sz] = spin_algebra(N)
+    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
+    [jx, jy, jz] = jspin(N, basis="uncoupled")
+    jp, jm = (
+        jspin(N, "+", basis="uncoupled"),
+        jspin(N, "-", basis="uncoupled"),
+    )
+
+    c_ops = []
+
+    if emission != 0:
+        for i in range(0, N):
+            c_ops.append(np.sqrt(emission) * sm[i])
+
+    if dephasing != 0:
+        for i in range(0, N):
+            c_ops.append(np.sqrt(dephasing) * sz[i])
+
+    if pumping != 0:
+        for i in range(0, N):
+            c_ops.append(np.sqrt(pumping) * sp[i])
+
+    if collective_emission != 0:
+        c_ops.append(np.sqrt(collective_emission) * jm)
+
+    if collective_dephasing != 0:
+        c_ops.append(np.sqrt(collective_dephasing) * jz)
+
+    if collective_pumping != 0:
+        c_ops.append(np.sqrt(collective_pumping) * jp)
+
+    return c_ops
+
+
+# State definitions in the Dicke basis with an option for basis transformation
+def dicke_basis(N, jmm1=None):
+    r"""
+    Initialize the density matrix of a Dicke state for several (j, m, m1).
+
+    This function can be used to build arbitrary states in the Dicke basis
+    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
+    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
+    index of the density matrix to the :math:`\lvert j, m\rangle` values is
+    given by the cythonized function `jmm1_dictionary`. A density matrix is
+    created from the given dictionary of coefficients for each (j, m, m1).
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    jmm1: dict
+        A dictionary of {(j, m, m1): p} that gives a density p for the
+        (j, m, m1) matrix element.
+
+    Returns
+    -------
+    rho: :class: qutip.Qobj
+        The density matrix in the Dicke basis.
+    """
+    if jmm1 is None:
+        msg = "Please specify the jmm1 values as a dictionary"
+        msg += "or use the `excited(N)` function to create an"
+        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
+        raise AttributeError(msg)
+
+    nds = _num_dicke_states(N)
+    rho = np.zeros((nds, nds))
+    jmm1_dict = jmm1_dictionary(N)[1]
+    for key in jmm1:
+        i, k = jmm1_dict[key]
+        rho[i, k] = jmm1[key]
+    return Qobj(rho)
+
+
+def dicke(N, j, m):
+    r"""
+    Generate a Dicke state as a pure density matrix in the Dicke basis.
+
+    For instance, the superradiant state given by
+    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
+    and the state is represented as a density matrix of size (nds, nds) or
+    (4, 4), with the (1, 1) element set to 1.
+
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    j: float
+        The eigenvalue j of the Dicke state (j, m).
+
+    m: float
+        The eigenvalue m of the Dicke state (j, m).
+
+    Returns
+    -------
+    rho: :class: qutip.Qobj
+        The density matrix.
+    """
+    nds = num_dicke_states(N)
+    rho = np.zeros((nds, nds))
+
+    jmm1_dict = jmm1_dictionary(N)[1]
+
+    i, k = jmm1_dict[(j, m, m)]
+    rho[i, k] = 1.0
+    return Qobj(rho)
+
+
+# Uncoupled states in the full Hilbert space. These are returned with the
+# choice of the keyword argument `basis="uncoupled"` in the state functions.
+def _uncoupled_excited(N):
+    """
+    Generate the density matrix of the excited Dicke state in the full
+    :math:`2^N` dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    psi0: :class: qutip.Qobj
+        The density matrix for the excited state in the uncoupled basis.
+    """
+    N = int(N)
+    jz = jspin(N, "z", basis="uncoupled")
+    en, vn = jz.eigenstates()
+    psi0 = vn[2 ** N - 1]
+    return ket2dm(psi0)
+
+
+def _uncoupled_superradiant(N):
+    """
+    Generate the density matrix of a superradiant state in the full
+    :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    psi0: :class: qutip.Qobj
+        The density matrix for the superradiant state in the full Hilbert
+        space.
+    """
+    N = int(N)
+    jz = jspin(N, "z", basis="uncoupled")
+    en, vn = jz.eigenstates()
+    psi0 = vn[2 ** N - (N + 1)]
+    return ket2dm(psi0)
+
+
+def _uncoupled_ground(N):
+    """
+    Generate the density matrix of the ground state in the full\
+    :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    psi0: :class: qutip.Qobj
+        The density matrix for the ground state in the full Hilbert space.
+    """
+    N = int(N)
+    jz = jspin(N, "z", basis="uncoupled")
+    en, vn = jz.eigenstates()
+    psi0 = vn[0]
+    return ket2dm(psi0)
+
+
+def _uncoupled_ghz(N):
+    """
+    Generate the density matrix of the GHZ state in the full 2^N
+    dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    ghz: :class: qutip.Qobj
+        The density matrix for the GHZ state in the full Hilbert space.
+    """
+    N = int(N)
+    rho = np.zeros((2 ** N, 2 ** N))
+    rho[0, 0] = 1 / 2
+    rho[2 ** N - 1, 0] = 1 / 2
+    rho[0, 2 ** N - 1] = 1 / 2
+    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
+    spin_dim = [2 for i in range(0, N)]
+    spins_dims = list((spin_dim, spin_dim))
+    rho = Qobj(rho, dims=spins_dims)
+    return rho
+
+
+def _uncoupled_css(N, a, b):
+    r"""
+    Generate the density matrix of the CSS state in the full 2^N
+    dimensional Hilbert space.
+
+    The CSS states are non-entangled states given by
+    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    a: complex
+        The coefficient of the :math:`\lvert1_i\rangle` state.
+
+    b: complex
+        The coefficient of the :math:`\lvert0_i\rangle` state.
+
+    Returns
+    -------
+    css: :class: qutip.Qobj
+        The density matrix for the CSS state in the full Hilbert space.
+    """
+    N = int(N)
+    # 1. Define i_th factorized density matrix in the uncoupled basis
+    rho_i = np.zeros((2, 2), dtype=complex)
+    rho_i[0, 0] = a * np.conj(a)
+    rho_i[1, 1] = b * np.conj(b)
+    rho_i[0, 1] = a * np.conj(b)
+    rho_i[1, 0] = b * np.conj(a)
+    rho_i = Qobj(rho_i)
+    rho = [0 for i in range(N)]
+    rho[0] = rho_i
+    # 2. Place single-two-level-system density matrices in total Hilbert space
+    for k in range(N - 1):
+        rho[0] = tensor(rho[0], identity(2))
+    # 3. Cyclic sequence to create all N factorized density matrices
+    # |CSS>_i<CSS|_i
+    a = [i for i in range(N)]
+    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
+    # 4. Create all other N-1 factorized density matrices
+    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
+    for i in range(1, N):
+        rho[i] = rho[0].permute(b[i])
+    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
+    rho_tot = identity_i
+    for i in range(0, N):
+        rho_tot = rho_tot * rho[i]
+    return rho_tot
+
+
+def excited(N, basis="dicke"):
+    """
+    Generate the density matrix for the excited state.
+
+    This state is given by (N/2, N/2) in the default Dicke basis. If the
+    argument `basis` is "uncoupled" then it generates the state in a
+    2**N dim Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The excited state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        state = _uncoupled_excited(N)
+        return state
+
+    jmm1 = {(N / 2, N / 2, N / 2): 1}
+    return dicke_basis(N, jmm1)
+
+
+def superradiant(N, basis="dicke"):
+    """
+    Generate the density matrix of the superradiant state.
+
+    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
+    If the argument `basis` is "uncoupled" then it generates the state
+    in a 2**N dim Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The superradiant state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        state = _uncoupled_superradiant(N)
+        return state
+
+    if N % 2 == 0:
+        jmm1 = {(N / 2, 0, 0): 1.0}
+        return dicke_basis(N, jmm1)
+    else:
+        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
+    return dicke_basis(N, jmm1)
+
+
+def css(
+    N,
+    x=1 / np.sqrt(2),
+    y=1 / np.sqrt(2),
+    basis="dicke",
+    coordinates="cartesian",
+):
+    r"""
+    Generate the density matrix of the Coherent Spin State (CSS).
+
+    It can be defined as,
+    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
+    with :math:`a = sin(\frac{\theta}{2})`,
+    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
+    The default basis is that of Dicke space
+    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
+    The default state is the symmetric CSS,
+    :math:`\lvert CSS\rangle = \lvert+\rangle`.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    x, y: float
+        The coefficients of the CSS state.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    coordinates: str
+        Either "cartesian" or "polar". If polar then the coefficients
+        are constructed as sin(x/2), cos(x/2)e^(iy).
+
+    Returns
+    -------
+    rho: :class: qutip.Qobj
+        The CSS state density matrix.
+    """
+    if coordinates == "polar":
+        a = np.cos(0.5 * x) * np.exp(1j * y)
+        b = np.sin(0.5 * x)
+    else:
+        a = x
+        b = y
+    if basis == "uncoupled":
+        return _uncoupled_css(N, a, b)
+    nds = num_dicke_states(N)
+    num_ladders = num_dicke_ladders(N)
+    rho = dok_matrix((nds, nds), dtype=np.complex128)
+
+    # loop in the allowed matrix elements
+    jmm1_dict = jmm1_dictionary(N)[1]
+
+    j = 0.5 * N
+    mmax = int(2 * j + 1)
+    for i in range(0, mmax):
+        m = j - i
+        psi_m = (
+            np.sqrt(float(energy_degeneracy(N, m)))
+            * a ** (N * 0.5 + m)
+            * b ** (N * 0.5 - m)
+        )
+        for i1 in range(0, mmax):
+            m1 = j - i1
+            row_column = jmm1_dict[(j, m, m1)]
+            psi_m1 = (
+                np.sqrt(float(energy_degeneracy(N, m1)))
+                * np.conj(a) ** (N * 0.5 + m1)
+                * np.conj(b) ** (N * 0.5 - m1)
+            )
+            rho[row_column] = psi_m * psi_m1
+    return Qobj(rho)
+
+
+def ghz(N, basis="dicke"):
+    """
+    Generate the density matrix of the GHZ state.
+
+    If the argument `basis` is "uncoupled" then it generates the state
+    in a :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The GHZ state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        return _uncoupled_ghz(N)
+    nds = _num_dicke_states(N)
+    rho = dok_matrix((nds, nds), dtype=np.complex128)
+    rho[0, 0] = 1 / 2
+    rho[N, N] = 1 / 2
+    rho[N, 0] = 1 / 2
+    rho[0, N] = 1 / 2
+    return Qobj(rho)
+
+
+def ground(N, basis="dicke"):
+    """
+    Generate the density matrix of the ground state.
+
+    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
+    `basis` is "uncoupled" then it generates the state in a
+    :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled"
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The ground state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        state = _uncoupled_ground(N)
+        return state
+    nds = _num_dicke_states(N)
+    rho = dok_matrix((nds, nds), dtype=np.complex128)
+    rho[N, N] = 1
+    return Qobj(rho)
+
+
+def identity_uncoupled(N):
+    """
+    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
+
+    The identity matrix is formed from the tensor product of N TLSs.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    identity: :class: qutip.Qobj
+        The identity matrix.
+    """
+    N = int(N)
+    rho = np.zeros((2 ** N, 2 ** N))
+    for i in range(0, 2 ** N):
+        rho[i, i] = 1
+    spin_dim = [2 for i in range(0, N)]
+    spins_dims = list((spin_dim, spin_dim))
+    identity = Qobj(rho, dims=spins_dims)
+    return identity
+
+
+def block_matrix(N, elements="ones"):
+    """Construct the block-diagonal matrix for the Dicke basis.
+
+    Parameters
+    ----------
+    N : int
+        Number of two-level systems.
+    elements : str {'ones' (default),'degeneracy'}
+
+    Returns
+    -------
+    block_matr : ndarray
+        A 2D block-diagonal matrix with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems. Filled with ones or the value of degeneracy
+        at each matrix element.
+    """
+    # create a list with the sizes of the blocks, in order
+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+    blocks_list = [
+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+        for i in range(blocks_dimensions)
+    ]
+    blocks_list = np.flip(blocks_list, 0)
+    # create a list with each block matrix as element
+    square_blocks = []
+    k = 0
+    for i in blocks_list:
+        if elements == "ones":
+            square_blocks.append(np.ones((i, i)))
+        elif elements == "degeneracy":
+            j = N / 2 - k
+            dj = state_degeneracy(N, j)
+            square_blocks.append(dj * np.ones((i, i)))
+        k = k + 1
+    return block_diag(square_blocks)
+
+
+# ============================================================================
+# Adding a faster version to make a Permutational Invariant matrix
+# ============================================================================
+def tau_column(tau, k, j):
+    """
+    Determine the column index for the non-zero elements of the matrix for a
+    particular row `k` and the value of `j` from the Dicke space.
+
+    Parameters
+    ----------
+    tau: str
+        The tau function to check for this `k` and `j`.
+
+    k: int
+        The row of the matrix M for which the non zero elements have
+        to be calculated.
+
+    j: float
+        The value of `j` for this row.
+    """
+    # In the notes, we indexed from k = 1, here we do it from k = 0
+    k = k + 1
+    mapping = {
+        "tau3": k - (2 * j + 3),
+        "tau2": k - 1,
+        "tau4": k + (2 * j - 1),
+        "tau5": k - (2 * j + 2),
+        "tau1": k,
+        "tau6": k + (2 * j),
+        "tau7": k - (2 * j + 1),
+        "tau8": k + 1,
+        "tau9": k + (2 * j + 1),
+    }
+    # we need to decrement k again as indexing is from 0
+    return int(mapping[tau] - 1)
+
+
+class Pim(object):
+    """
+    The Permutation Invariant Matrix class.
+
+    Initialize the class with the parameters for generating a Permutation
+    Invariant matrix which evolves a given diagonal initial state `p` as:
+
+                                dp/dt = Mp
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Attributes
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    M: dict
+        A nested dictionary of the structure {row: {col: val}} which holds
+        non zero elements of the matrix M
+    """
+
+    def __init__(
+        self,
+        N,
+        emission=0.0,
+        dephasing=0,
+        pumping=0,
+        collective_emission=0,
+        collective_pumping=0,
+        collective_dephasing=0,
+    ):
+        self.N = N
+        self.emission = emission
+        self.dephasing = dephasing
+        self.pumping = pumping
+        self.collective_pumping = collective_pumping
+        self.collective_dephasing = collective_dephasing
+        self.collective_emission = collective_emission
+        self.M = {}
+
+    def isdicke(self, dicke_row, dicke_col):
+        """
+        Check if an element in a matrix is a valid element in the Dicke space.
+        Dicke row: j value index. Dicke column: m value index.
+        The function returns True if the element exists in the Dicke space and
+        False otherwise.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col : int
+            Index of the element in Dicke space which needs to be checked
+        """
+        rows = self.N + 1
+        cols = 0
+
+        if (self.N % 2) == 0:
+            cols = int(self.N / 2 + 1)
+        else:
+            cols = int(self.N / 2 + 1 / 2)
+        if (dicke_row > rows) or (dicke_row < 0):
+            return False
+        if (dicke_col > cols) or (dicke_col < 0):
+            return False
+        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
+            return False
+        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
+            return False
+        else:
+            return True
+
+    def tau_valid(self, dicke_row, dicke_col):
+        """
+        Find the Tau functions which are valid for this value of (dicke_row,
+        dicke_col) given the number of TLS. This calculates the valid tau
+        values and reurns a dictionary specifying the tau function name and
+        the value.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col : int
+            Index of the element in Dicke space which needs to be checked.
+
+        Returns
+        -------
+        taus: dict
+            A dictionary of key, val as {tau: value} consisting of the valid
+            taus for this row and column of the Dicke space element.
+        """
+        tau_functions = [
+            self.tau3,
+            self.tau2,
+            self.tau4,
+            self.tau5,
+            self.tau1,
+            self.tau6,
+            self.tau7,
+            self.tau8,
+            self.tau9,
+        ]
+        N = self.N
+        if self.isdicke(dicke_row, dicke_col) is False:
+            return False
+        # The 3x3 sub matrix surrounding the Dicke space element to
+        # run the tau functions
+        indices = [
+            (dicke_row + x, dicke_col + y)
+            for x in range(-1, 2)
+            for y in range(-1, 2)
+        ]
+        taus = {}
+        for idx, tau in zip(indices, tau_functions):
+            if self.isdicke(idx[0], idx[1]):
+                j, m = self.calculate_j_m(idx[0], idx[1])
+                taus[tau.__name__] = tau(j, m)
+        return taus
+
+    def calculate_j_m(self, dicke_row, dicke_col):
+        """
+        Get the value of j and m for the particular Dicke space element.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col: int
+            The row and column from the Dicke space matrix
+
+        Returns
+        -------
+        j, m: float
+            The j and m values.
+        """
+        N = self.N
+        j = N / 2 - dicke_col
+        m = N / 2 - dicke_row
+        return (j, m)
+
+    def calculate_k(self, dicke_row, dicke_col):
+        """
+        Get k value from the current row and column element in the Dicke space.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col: int
+            The row and column from the Dicke space matrix.
+        Returns
+        -------
+        k: int
+            The row index for the matrix M for given Dicke space
+            element.
+        """
+        N = self.N
+        if dicke_row == 0:
+            k = dicke_col
+        else:
+            k = int(
+                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
+                + (dicke_row - (dicke_col))
+            )
+        return k
+
+    def coefficient_matrix(self):
+        """
+        Generate the matrix M governing the dynamics for diagonal cases.
+
+        If the initial density matrix and the Hamiltonian is diagonal, the
+        evolution of the system is given by the simple ODE: dp/dt = Mp.
+        """
+        N = self.N
+        nds = num_dicke_states(N)
+        rows = self.N + 1
+        cols = 0
+
+        sparse_M = lil_matrix((nds, nds), dtype=float)
+        if (self.N % 2) == 0:
+            cols = int(self.N / 2 + 1)
+        else:
+            cols = int(self.N / 2 + 1 / 2)
+        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
+            if self.isdicke(dicke_row, dicke_col):
+                k = int(self.calculate_k(dicke_row, dicke_col))
+                row = {}
+                taus = self.tau_valid(dicke_row, dicke_col)
+                for tau in taus:
+                    j, m = self.calculate_j_m(dicke_row, dicke_col)
+                    current_col = tau_column(tau, k, j)
+                    sparse_M[k, int(current_col)] = taus[tau]
+        return sparse_M.tocsr()
+
+    def solve(self, rho0, tlist, options=None):
+        """
+        Solve the ODE for the evolution of diagonal states and Hamiltonians.
+        """
+        if options is None:
+            options = SolverOptions()
+        output = Result()
+        output.solver = "pisolve"
+        output.times = tlist
+        output.states = []
+        output.states.append(Qobj(rho0))
+        rhs_generate = lambda y, tt, M: M.dot(y)
+        rho0_flat = np.diag(np.real(rho0.full()))
+        L = self.coefficient_matrix()
+        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
+        for r in rho_t[1:]:
+            diag = np.diag(r)
+            output.states.append(Qobj(diag))
+        return output
+
+    def tau1(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j, m, m).
+        """
+        yS = self.collective_emission
+        yL = self.emission
+        yD = self.dephasing
+        yP = self.pumping
+        yCP = self.collective_pumping
+        N = float(self.N)
+        spontaneous = yS * (1 + j - m) * (j + m)
+        losses = yL * (N / 2 + m)
+        pump = yP * (N / 2 - m)
+        collective_pump = yCP * (1 + j + m) * (j - m)
+        if j == 0:
+            dephase = yD * N / 4
+        else:
+            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
+        t1 = spontaneous + losses + pump + dephase + collective_pump
+        return -t1
+
+    def tau2(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j, m+1, m+1).
+        """
+        yS = self.collective_emission
+        yL = self.emission
+        N = float(self.N)
+        spontaneous = yS * (1 + j - m) * (j + m)
+        losses = yL * (
+            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
+        )
+        t2 = spontaneous + losses
+        return t2
+
+    def tau3(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
+        """
+        yL = self.emission
+        N = float(self.N)
+        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
+        den = 2 * j * (2 * j + 1)
+        t3 = yL * (num / den)
+        return t3
+
+    def tau4(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
+        """
+        yL = self.emission
+        N = float(self.N)
+        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
+        den = 2 * (j + 1) * (2 * j + 1)
+        t4 = yL * (num / den)
+        return t4
+
+    def tau5(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j+1, m, m).
+        """
+        yD = self.dephasing
+        N = float(self.N)
+        num = (j - m) * (j + m) * (j + 1 + N / 2)
+        den = 2 * j * (2 * j + 1)
+        t5 = yD * (num / den)
+        return t5
+
+    def tau6(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j-1, m, m).
+        """
+        yD = self.dephasing
+        N = float(self.N)
+        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
+        den = 2 * (j + 1) * (2 * j + 1)
+        t6 = yD * (num / den)
+        return t6
+
+    def tau7(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
+        """
+        yP = self.pumping
+        N = float(self.N)
+        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
+        den = 2 * j * (2 * j + 1)
+        t7 = yP * (float(num) / den)
+        return t7
+
+    def tau8(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j, m-1, m-1).
+        """
+        yP = self.pumping
+        yCP = self.collective_pumping
+        N = float(self.N)
+
+        num = (1 + N / 2) * (j - m) * (j + m + 1)
+        den = 2 * j * (j + 1)
+        pump = yP * (float(num) / den)
+        collective_pump = yCP * (j - m) * (j + m + 1)
+        t8 = pump + collective_pump
+        return t8
+
+    def tau9(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
+        """
+        yP = self.pumping
+        N = float(self.N)
+        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
+        den = 2 * (j + 1) * (2 * j + 1)
+        t9 = yP * (float(num) / den)
+        return t9
diff --git a/qutip/solve/rcsolve.py b/qutip/solve/rcsolve.py
index b357bc6e02..7352b978df 100644
--- a/qutip/solve/rcsolve.py
+++ b/qutip/solve/rcsolve.py
@@ -1,127 +1,127 @@
-"""
-This module provides exact solvers for a system-bath setup using the
-reaction coordinate method.
-"""
-
-# Author: Neill Lambert, Anubhav Vardhan
-# Contact: nwlambert@gmail.com
-
-__all__ = ['rcsolve']
-
-import warnings
-import numpy as np
-import scipy.sparse as sp
-from numpy import matrix
-from numpy import linalg
-from .. import (
-    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
-    sigmaz, basis, qeye, mesolve
-)
-
-
-def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
-            options=None):
-    """
-    Function to solve for an open quantum system using the
-    reaction coordinate (RC) model.
-
-    Parameters
-    ----------
-    Hsys: Qobj
-        The system hamiltonian.
-    psi0: Qobj
-        Initial state of the system.
-    tlist: List.
-        Time over which system evolves.
-    e_ops: list of :class:`qutip.Qobj` / callback function single
-        Single operator or list of operators for which to evaluate
-        expectation values.
-    Q: Qobj
-        The coupling between system and bath.
-    wc: Float
-        Cutoff frequency.
-    alpha: Float
-        Coupling strength.
-    N: Integer
-        Number of cavity fock states.
-    w_th: Float
-        Temperature.
-    sparse: Boolean
-        Optional argument to call the sparse eigenstates solver if needed.
-    options : dict
-        Options for the solver.
-
-    Returns
-    -------
-    output: Result
-        System evolution.
-    """
-    if options is None:
-        options = {}
-
-    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
-    deltaE = dot_energy[1] - dot_energy[0]
-    if (w_th < deltaE/2):
-        warnings.warn("Given w_th might not provide accurate results")
-    gamma = deltaE / (2 * np.pi * wc)
-    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
-    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
-    nb = (1 / (np.exp(wa/w_th) - 1))
-
-    # Reaction coordinate hamiltonian/operators
-
-    dimensions = Q.dims
-    a = tensor(destroy(N), qeye(dimensions[1]))
-    unit = tensor(qeye(N), qeye(dimensions[1]))
-    Nmax = N * dimensions[1][0]
-    Q_exp = tensor(qeye(N), Q)
-    Hsys_exp = tensor(qeye(N), Hsys)
-    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
-
-    na = a.dag() * a
-    xa = a.dag() + a
-
-    # decoupled Hamiltonian
-    H0 = wa * a.dag() * a + Hsys_exp
-    # interaction
-    H1 = (g * (a.dag() + a) * Q_exp)
-    H = H0 + H1
-    L = 0
-    PsipreEta = 0
-    PsipreX = 0
-
-    all_energy, all_state = H.eigenstates(sparse=sparse)
-    Apre = spre((a + a.dag()))
-    Apost = spost(a + a.dag())
-    for j in range(Nmax):
-        for k in range(Nmax):
-            A = xa.matrix_element(all_state[j].dag(), all_state[k])
-            delE = (all_energy[j] - all_energy[k])
-            if abs(A) > 0.0:
-                if abs(delE) > 0.0:
-                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
-                         * (np.cosh((all_energy[j] - all_energy[k]) /
-                            (2 * w_th))
-                         / (np.sinh((all_energy[j] - all_energy[k]) /
-                            (2 * w_th)))) * A)
-                    eta = (0.5 * np.pi * gamma *
-                           (all_energy[j] - all_energy[k]) * A)
-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-                    PsipreEta = PsipreEta + (eta * all_state[j]
-                                             * all_state[k].dag())
-                else:
-                    X = 0.5 * np.pi * gamma * A * 2 * w_th
-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-
-    A = a + a.dag()
-    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
-         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
-         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
-         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
-
-    # Setup the operators and the Hamiltonian and the master equation
-    # and solve for time steps in tlist
-    rho0 = (tensor(thermal_dm(N, nb), psi0))
-    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
-
-    return output
+"""
+This module provides exact solvers for a system-bath setup using the
+reaction coordinate method.
+"""
+
+# Author: Neill Lambert, Anubhav Vardhan
+# Contact: nwlambert@gmail.com
+
+__all__ = ['rcsolve']
+
+import warnings
+import numpy as np
+import scipy.sparse as sp
+from numpy import matrix
+from numpy import linalg
+from .. import (
+    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
+    sigmaz, basis, qeye, mesolve
+)
+
+
+def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
+            options=None):
+    """
+    Function to solve for an open quantum system using the
+    reaction coordinate (RC) model.
+
+    Parameters
+    ----------
+    Hsys: Qobj
+        The system hamiltonian.
+    psi0: Qobj
+        Initial state of the system.
+    tlist: List.
+        Time over which system evolves.
+    e_ops: list of :class:`qutip.Qobj` / callback function single
+        Single operator or list of operators for which to evaluate
+        expectation values.
+    Q: Qobj
+        The coupling between system and bath.
+    wc: Float
+        Cutoff frequency.
+    alpha: Float
+        Coupling strength.
+    N: Integer
+        Number of cavity fock states.
+    w_th: Float
+        Temperature.
+    sparse: Boolean
+        Optional argument to call the sparse eigenstates solver if needed.
+    options : dict
+        Options for the solver.
+
+    Returns
+    -------
+    output: Result
+        System evolution.
+    """
+    if options is None:
+        options = {}
+
+    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
+    deltaE = dot_energy[1] - dot_energy[0]
+    if (w_th < deltaE/2):
+        warnings.warn("Given w_th might not provide accurate results")
+    gamma = deltaE / (2 * np.pi * wc)
+    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
+    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
+    nb = (1 / (np.exp(wa/w_th) - 1))
+
+    # Reaction coordinate hamiltonian/operators
+
+    dimensions = Q.dims
+    a = tensor(destroy(N), qeye(dimensions[1]))
+    unit = tensor(qeye(N), qeye(dimensions[1]))
+    Nmax = N * dimensions[1][0]
+    Q_exp = tensor(qeye(N), Q)
+    Hsys_exp = tensor(qeye(N), Hsys)
+    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
+
+    na = a.dag() * a
+    xa = a.dag() + a
+
+    # decoupled Hamiltonian
+    H0 = wa * a.dag() * a + Hsys_exp
+    # interaction
+    H1 = (g * (a.dag() + a) * Q_exp)
+    H = H0 + H1
+    L = 0
+    PsipreEta = 0
+    PsipreX = 0
+
+    all_energy, all_state = H.eigenstates(sparse=sparse)
+    Apre = spre((a + a.dag()))
+    Apost = spost(a + a.dag())
+    for j in range(Nmax):
+        for k in range(Nmax):
+            A = xa.matrix_element(all_state[j].dag(), all_state[k])
+            delE = (all_energy[j] - all_energy[k])
+            if abs(A) > 0.0:
+                if abs(delE) > 0.0:
+                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
+                         * (np.cosh((all_energy[j] - all_energy[k]) /
+                            (2 * w_th))
+                         / (np.sinh((all_energy[j] - all_energy[k]) /
+                            (2 * w_th)))) * A)
+                    eta = (0.5 * np.pi * gamma *
+                           (all_energy[j] - all_energy[k]) * A)
+                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
+                    PsipreEta = PsipreEta + (eta * all_state[j]
+                                             * all_state[k].dag())
+                else:
+                    X = 0.5 * np.pi * gamma * A * 2 * w_th
+                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
+
+    A = a + a.dag()
+    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
+         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
+         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
+         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
+
+    # Setup the operators and the Hamiltonian and the master equation
+    # and solve for time steps in tlist
+    rho0 = (tensor(thermal_dm(N, nb), psi0))
+    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
+
+    return output
diff --git a/qutip/solve/solver.py b/qutip/solve/solver.py
index 08a53fb64e..e466beb9fb 100644
--- a/qutip/solve/solver.py
+++ b/qutip/solve/solver.py
@@ -1,922 +1,922 @@
-from __future__ import print_function
-
-__all__ = ['SolverOptions', 'ExpectOps']
-
-import os
-import sys
-import warnings
-import datetime
-import numpy as np
-from collections import OrderedDict
-from types import FunctionType, BuiltinFunctionType
-
-from .. import __version__, Qobj, QobjEvo
-from .optionsclass import optionsclass
-from ..core import data as _data
-
-solver_safe = {}
-
-
-class SolverSystem():
-    pass
-
-
-class ExpectOps:
-    """
-        Contain and compute expectation values
-    """
-    def __init__(self, e_ops=[], super_=False):
-        # take care of expectation values, if any
-        self.isfunc = False
-        self.e_ops_dict = False
-        self.raw_e_ops = e_ops
-        self.e_ops_qoevo = []
-        self.e_num = 0
-        self.e_ops_isherm = []
-
-        if isinstance(e_ops, (Qobj, QobjEvo)):
-            e_ops = [e_ops]
-        elif isinstance(e_ops, dict):
-            self.e_ops_dict = e_ops
-            e_ops = [e for e in e_ops.values()]
-
-        self.e_ops = e_ops
-        if isinstance(e_ops, list):
-            self.e_num = len(e_ops)
-            self.e_ops_isherm = [e.isherm for e in e_ops]
-            if not super_:
-                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
-                                            dtype=object)
-            else:
-                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
-                                            dtype=object)
-        elif callable(e_ops):
-            self.isfunc = True
-            self.e_num = 1
-
-    def init(self, tlist):
-        self.tlist = tlist
-        if self.isfunc:
-            self.raw_out = []
-        else:
-            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
-
-    def check_dims(self, dims):
-        if not self.isfunc:
-            for op in self.e_ops_qoevo:
-                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
-                    raise TypeError(f"e_ops dims ({op.dims}) are not "
-                                    f"compatible with the system's ({dims})")
-
-    def copy(self):
-        out = ExpectOps.__new__(ExpectOps)
-        out.isfunc = self.isfunc
-        out.e_ops_dict = self.e_ops_dict
-        out.raw_e_ops = self.raw_e_ops
-        out.e_ops = self.e_ops
-        out.e_num = self.e_num
-        out.e_ops_isherm = self.e_ops_isherm
-        out.e_ops_qoevo = self.e_ops_qoevo
-        return out
-
-    def step(self, iter_, state):
-        if self.isfunc:
-            self.raw_out.append(self.e_ops(t, state))
-        else:
-            state = _data.dense.fast_from_numpy(state)
-            t = self.tlist[iter_]
-            for ii in range(self.e_num):
-                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
-                    self.raw_out[ii, iter_] = \
-                        self.e_ops_qoevo[ii].expect_data(t, state)
-                elif callable(self.e_ops_qoevo[ii]):
-                    self.raw_out[ii, iter_] = \
-                        self.e_ops_qoevo[ii](t, state)
-
-    def finish(self):
-        if self.isfunc:
-            result = self.raw_out
-        else:
-            result = []
-            for ii in range(self.e_num):
-                if self.e_ops_isherm[ii]:
-                    result.append(np.real(self.raw_out[ii, :]))
-                else:
-                    result.append(self.raw_out[ii, :])
-            if self.e_ops_dict:
-                result = {e: result[n]
-                          for n, e in enumerate(self.e_ops_dict.keys())}
-        return result
-
-    def __eq__(self, other):
-        if isinstance(other, ExpectOps):
-            other = other.raw_e_ops
-        return self.raw_e_ops == other
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __bool__(self):
-        return bool(self.e_num)
-
-
-@optionsclass("solver")
-class SolverOptions:
-    """
-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-    constructor::
-
-        opts = SolverOptions(order=10, ...)
-
-    or by changing the class attributes after creation::
-
-        opts = SolverOptions()
-        opts.order = 10
-
-    Returns options class to be used as options in evolution solvers.
-
-    The default can be changed by::
-
-        qutip.settings.solver['order'] = 10
-
-    Supported options:
-
-        atol : float {1e-8}
-            Absolute tolerance.
-        rtol : float {1e-6}
-            Relative tolerance.
-        method : str {'adams','bdf'}
-            Integration method.
-        order : int {12}
-            Order of integrator (<=12 'adams', <=5 'bdf')
-        nsteps : int {2500}
-            Max. number of internal steps/call.
-        first_step : float {0}
-            Size of initial step (0 = automatic).
-        min_step : float {0}
-            Minimum step size (0 = automatic).
-        max_step : float {0}
-            Maximum step size (0 = automatic)
-        tidy : bool {True,False}
-            Tidyup Hamiltonian and initial state by removing small terms.
-        average_states : bool {False}
-            Average states values over trajectories in stochastic solvers.
-        average_expect : bool {True}
-            Average expectation values over trajectories for stochastic solvers.
-        ntraj : int {500}
-            Number of trajectories in stochastic solvers.
-        store_final_state : bool {False, True}
-            Whether or not to store the final state of the evolution in the
-            result class.
-        store_states : bool {False, True}
-            Whether or not to store the state vectors or density matrices in the
-            result class, even if expectation values operators are given. If no
-            expectation are provided, then states are stored by default and this
-            option has no effect.
-    """
-    options = {
-        # Absolute tolerance (default = 1e-8)
-        "atol": 1e-8,
-        # Relative tolerance (default = 1e-6)
-        "rtol": 1e-6,
-        # Integration method (default = 'adams', for stiff 'bdf')
-        "method": 'adams',
-        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
-        "order": 12,
-        # Max. number of internal steps/call
-        "nsteps": 1000,
-        # Size of initial step (0 = determined by solver)
-        "first_step": 0,
-        # Max step size (0 = determined by solver)
-        "max_step": 0,
-        # Minimal step size (0 = determined by solver)
-        "min_step": 0,
-        # Average expectation values over trajectories (default = True)
-        "average_expect": True,
-        # average expectation values
-        "average_states": False,
-        # tidyup Hamiltonian before calculation (default = True)
-        "tidy": True,
-        # Number of trajectories (default = 500)
-        "ntraj": 500,
-        "gui": False,
-        # store final state?
-        "store_final_state": False,
-        # store states even if expectation operators are given?
-        "store_states": False,
-        # average mcsolver density matricies assuming steady state evolution
-        "steady_state_average": False,
-        # Normalize output of solvers
-        # (turned off for batch unitary propagator mode)
-        "normalize_output": True
-    }
-
-
-@optionsclass("mcsolve", SolverOptions)
-class McOptions:
-    """
-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-    constructor::
-
-        opts = SolverOptions(norm_tol=1e-3, ...)
-
-    or by changing the class attributes after creation::
-
-        opts = SolverOptions()
-        opts.['norm_tol'] = 1e-3
-
-    Returns options class to be used as options in evolution solvers.
-
-    The default can be changed by::
-
-        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
-
-    Options
-    -------
-
-    norm_tol : float {1e-4}
-        Tolerance used when finding wavefunction norm in mcsolve.
-    norm_t_tol : float {1e-6}
-        Tolerance used when finding wavefunction time in mcsolve.
-    norm_steps : int {5}
-        Max. number of steps used to find wavefunction norm to within norm_tol
-        in mcsolve.
-    mc_corr_eps : float {1e-10}
-        Arbitrarily small value for eliminating any divide-by-zero errors in
-        correlation calculations when using mcsolve.
-    """
-    options = {
-        # Tolerance for wavefunction norm (mcsolve only)
-        "norm_tol": 1e-4,
-        # Tolerance for collapse time precision (mcsolve only)
-        "norm_t_tol": 1e-6,
-        # Max. number of steps taken to find wavefunction norm to within
-        # norm_tol (mcsolve only)
-        "norm_steps": 5,
-        # small value in mc solver for computing correlations
-        "mc_corr_eps": 1e-10,
-    }
-
-
-class Result():
-    """Class for storing simulation results from any of the dynamics solvers.
-
-    Attributes
-    ----------
-
-    solver : str
-        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
-    times : list/array
-        Times at which simulation data was collected.
-    expect : list/array
-        Expectation values (if requested) for simulation.
-    states : array
-        State of the simulation (density matrix or ket) evaluated at ``times``.
-    num_expect : int
-        Number of expectation value operators in simulation.
-    num_collapse : int
-        Number of collapse operators in simualation.
-    ntraj : int/list
-        Number of trajectories (for stochastic solvers). A list indicates
-        that averaging of expectation values was done over a subset of total
-        number of trajectories.
-    col_times : list
-        Times at which state collpase occurred. Only for Monte Carlo solver.
-    col_which : list
-        Which collapse operator was responsible for each collapse in
-        ``col_times``. Only for Monte Carlo solver.
-
-    """
-    def __init__(self):
-        self.solver = None
-        self.times = None
-        self.states = []
-        self.expect = []
-        self.num_expect = 0
-        self.num_collapse = 0
-        self.ntraj = None
-        self.seeds = None
-        self.col_times = None
-        self.col_which = None
-
-    def __str__(self):
-        s = "Result object "
-        if self.solver:
-            s += "with " + self.solver + " data.\n"
-        else:
-            s += "missing solver information.\n"
-        s += "-" * (len(s) - 1) + "\n"
-        if self.states is not None and len(self.states) > 0:
-            s += "states = True\n"
-        elif self.expect is not None and len(self.expect) > 0:
-            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
-        else:
-            s += "states = True, expect = True\n" + \
-                "num_expect = " + str(self.num_expect) + ", "
-        s += "num_collapse = " + str(self.num_collapse)
-        if self.solver == 'mcsolve':
-            s += ", ntraj = " + str(self.ntraj)
-        return s
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __getstate__(self):
-        # defines what happens when Qobj object gets pickled
-        self.__dict__.update({'qutip_version': __version__[:5]})
-        return self.__dict__
-
-    def __setstate__(self, state):
-        # defines what happens when loading a pickled Qobj
-        if 'qutip_version' in state.keys():
-            del state['qutip_version']
-        (self.__dict__).update(state)
-
-
-# %%%%%%%%%%% remove ?
-class SolverConfiguration():
-    def __init__(self):
-
-        self.cgen_num = 0
-
-        self.reset()
-
-    def reset(self):
-        # General stuff
-        self.tlist = None       # evaluations times
-        self.ntraj = None       # number / list of trajectories
-        self.options = None     # options for solvers
-        self.norm_tol = None    # tolerance for wavefunction norm
-        self.norm_steps = None  # max. number of steps to take in finding
-        # Initial state stuff
-        self.psi0 = None        # initial state
-        self.psi0_dims = None   # initial state dims
-        self.psi0_shape = None  # initial state shape
-
-        # flags for setting time-dependence, collapse ops, and number of times
-        # codegen has been run
-        self.cflag = 0     # Flag signaling collapse operators
-        self.tflag = 0     # Flag signaling time-dependent problem
-
-        self.soft_reset()
-
-    def soft_reset(self):
-        # Hamiltonian stuff
-        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
-        self.h_tdterms = []  # List of td strs and funcs
-        self.h_data = None   # List of sparse matrix data
-        self.h_ind = None    # List of sparse matrix indices
-        self.h_ptr = None    # List of sparse matrix ptrs
-
-        # Expectation operator stuff
-        self.e_num = 0        # number of expect ops
-        self.e_ops_data = []  # expect op data
-        self.e_ops_ind = []   # expect op indices
-        self.e_ops_ptr = []   # expect op indptrs
-        self.e_ops_isherm = []  # expect op isherm
-
-        # Collapse operator stuff
-        self.c_num = 0          # number of collapse ops
-        self.c_const_inds = []  # indicies of constant collapse operators
-        self.c_td_inds = []     # indicies of time-dependent collapse operators
-        self.c_ops_data = []    # collapse op data
-        self.c_ops_ind = []     # collapse op indices
-        self.c_ops_ptr = []     # collapse op indptrs
-        self.c_args = []        # store args for time-dependent collapse func.
-
-        # Norm collapse operator stuff
-        self.n_ops_data = []  # norm collapse op data
-        self.n_ops_ind = []   # norm collapse op indices
-        self.n_ops_ptr = []   # norm collapse op indptrs
-
-        # holds executable strings for time-dependent collapse evaluation
-        self.col_expect_code = None
-        self.col_spmv_code = None
-
-        # hold stuff for function list based time dependence
-        self.h_td_inds = []
-        self.h_td_data = []
-        self.h_td_ind = []
-        self.h_td_ptr = []
-        self.h_funcs = None
-        self.h_func_args = None
-        self.c_funcs = None
-        self.c_func_args = None
-
-        # time-dependent (TD) function stuff
-        self.tdfunc = None     # Placeholder for TD RHS function.
-        self.tdname = None     # Name of td .pyx file
-        self.colspmv = None    # Placeholder for TD col-spmv function.
-        self.colexpect = None  # Placeholder for TD col_expect function.
-        self.string = None     # Holds string of variables passed to td solver
-
-
-def _format_time(t, tt=None, ttt=None):
-    time_str = str(datetime.timedelta(seconds=t))
-    if tt is not None and ttt is not None:
-        sect_percent = 100*t/tt
-        solve_percent = 100*t/ttt
-        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
-                                            sect_percent, solve_percent)
-    elif tt is not None:
-        sect_percent = 100*t/tt
-        time_str += " ({:03.2f}% section)".format(sect_percent)
-
-    elif ttt is not None:
-        solve_percent = 100*t/ttt
-        time_str += " ({:03.2f}% total)".format(solve_percent)
-
-    return time_str
-
-
-class Stats:
-    """
-    Statistical information on the solver performance
-    Statistics can be grouped into sections.
-    If no section names are given in the the contructor, then all statistics
-    will be added to one section 'main'
-
-    Parameters
-    ----------
-    section_names : list
-        list of keys that will be used as keys for the sections
-        These keys will also be used as names for the sections
-        The text in the output can be overidden by setting the header property
-        of the section
-        If no names are given then one section called 'main' is created
-
-    Attributes
-    ----------
-    sections : OrderedDict of _StatsSection
-        These are the sections that are created automatically on instantiation
-        or added using add_section
-
-    header : string
-        Some text that will be used as the heading in the report
-        By default there is None
-
-    total_time : float
-        Time in seconds for the solver to complete processing
-        Can be None, meaning that total timing percentages will be reported
-    """
-
-    def __init__(self, section_names=None):
-        self._def_section_name = 'main'
-        self.sections = OrderedDict()
-        self.total_time = None
-        self.header = None
-        if isinstance(section_names, list):
-            c = 0
-            for name in section_names:
-                self.sections[name] = _StatsSection(name, self)
-                if c == 0:
-                    self._def_section_name = name
-                c += 1
-
-        else:
-            self.sections[self._def_section_name] = \
-                        _StatsSection(self._def_section_name)
-
-    def _get_section(self, section):
-        if section is None:
-            return self.sections[self._def_section_name]
-        elif isinstance(section, _StatsSection):
-            return section
-        else:
-            sect = self.sections.get(section, None)
-            if sect is None:
-                raise ValueError("Unknown section {}".format(section))
-            else:
-                return sect
-
-    def add_section(self, name):
-        """
-        Add another section with the given name
-
-        Parameters
-        ----------
-        name : string
-            will be used as key for sections dict
-            will also be the header for the section
-
-        Returns
-        -------
-        section : :class:`_StatsSection`
-            The new section
-        """
-        sect = _StatsSection(name, self)
-        self.sections[name] = sect
-        return sect
-
-    def add_count(self, key, value, section=None):
-        """
-        Add value to count. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be an integer
-
-        Parameters
-        ----------
-        key : string
-            key for the section.counts dictionary
-            reusing a key will result in numerical addition of value
-
-        value : int
-            Initial value of the count, or added to an existing count
-
-        section : string or :class:`_StatsSection`
-            Section which to add the count to.
-            If None given, the default (first) section will be used
-        """
-
-        self._get_section(section).add_count(key, value)
-
-    def add_timing(self, key, value, section=None):
-        """
-        Add value to timing. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be a float, and given in seconds.
-
-        Parameters
-        ----------
-        key : string
-            key for the section.timings dictionary
-            reusing a key will result in numerical addition of value
-
-        value : int
-            Initial value of the timing, or added to an existing timing
-
-        section: string or `class` : _StatsSection
-            Section which to add the timing to.
-            If None given, the default (first) section will be used
-        """
-        self._get_section(section).add_timing(key, value)
-
-    def add_message(self, key, value, section=None, sep=";"):
-        """
-        Add value to message. If key does not already exist in section then
-        it is created with this value.
-        If key already exists the value is added to the message
-        The value will be converted to a string
-
-        Parameters
-        ----------
-        key : string
-            key for the section.messages dictionary
-            reusing a key will result in concatenation of value
-
-        value : int
-            Initial value of the message, or added to an existing message
-
-        sep : string
-            Message will be prefixed with this string when concatenating
-
-        section: string or `class` : _StatsSection
-            Section which to add the message to.
-            If None given, the default (first) section will be used
-        """
-        self._get_section(section).add_message(key, value, sep=sep)
-
-    def set_total_time(self, value, section=None):
-        """
-        Sets the total time for the complete solve or for a specific section
-        value is expected to be a float, and given in seconds
-
-        Parameters
-        ----------
-        value : float
-            Time in seconds to complete the solver section
-
-        section : string or `class` : _StatsSection
-            Section which to set the total_time for
-            If None given, the total_time for complete solve is set
-        """
-        if not isinstance(value, float):
-            try:
-                value = float(value)
-            except:
-                raise TypeError("value is expected to be a float")
-
-        if section is None:
-            self.total_time = value
-        else:
-            sect = self._get_section(section)
-            sect.total_time = value
-
-    def report(self, output=sys.stdout):
-        """
-        Report the counts, timings and messages from the sections.
-        Sections are reported in the order that the names were supplied
-        in the constructor.
-        The counts, timings and messages are reported in the order that they
-        are added to the sections
-        The output can be written to anything that supports a write method,
-        e.g. a file or the console (default)
-        The output is intended to in markdown format
-
-        Parameters
-        ----------
-        output : stream
-            file or console stream - anything that support write - where
-            the output will be written
-        """
-
-        if not hasattr(output, 'write'):
-            raise TypeError("output must have a write method")
-
-        if self.header:
-            output.write("{}\n{}\n".format(self.header,
-                                     ("="*len(self.header))))
-        for name, sect in self.sections.items():
-            sect.report(output)
-
-        if self.total_time is not None:
-            output.write("\nSummary\n-------\n")
-            output.write("{}\t solver total time\n".format(
-                                            _format_time(self.total_time)))
-
-    def clear(self):
-        """
-        Clear counts, timings and messages from all sections
-        """
-        for sect in self.sections.values():
-            sect.clear()
-        self.total_time = None
-
-
-class _StatsSection(object):
-    """
-    Not intended to be directly instantiated
-    This is the type for the SolverStats.sections values
-
-    The method parameter descriptions are the same as for those the parent
-    with the same method name
-
-    Parameters
-    ----------
-    name : string
-        key for the parent sections dictionary
-        will also be used as the header
-
-    parent : `class` :  SolverStats
-        The container for all the sections
-
-    Attributes
-    ----------
-    name : string
-        key for the parent sections dictionary
-        will also be used as the header
-
-    parent : `class` :  SolverStats
-        The container for all the sections
-
-    header : string
-        Used as heading for section in report
-
-    counts : OrderedDict
-        The integer type statistics for the stats section
-
-    timings : OrderedDict
-        The timing type statistics for the stats section
-        Expected to contain float values representing values in seconds
-
-    messages : OrderedDict
-        Text type output to be reported
-
-    total_time : float
-        Total time for processing in the section
-        Can be None, meaning that section timing percentages will be reported
-    """
-    def __init__(self, name, parent):
-        self.parent = parent
-        self.header = str(name)
-        self.name = name
-        self.counts = OrderedDict()
-        self.timings = OrderedDict()
-        self.messages = OrderedDict()
-        self.total_time = None
-
-    def add_count(self, key, value):
-        """
-        Add value to count. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the given value
-        value is expected to be an integer
-        """
-        if not isinstance(value, int):
-            try:
-                value = int(value)
-            except:
-                raise TypeError("value is expected to be an integer")
-
-        if key in self.counts:
-            self.counts[key] += value
-        else:
-            self.counts[key] = value
-
-    def add_timing(self, key, value):
-        """
-        Add value to timing. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be a float, and given in seconds.
-        """
-        if not isinstance(value, float):
-            try:
-                value = float(value)
-            except:
-                raise TypeError("value is expected to be a float")
-
-        if key in self.timings:
-            self.timings[key] += value
-        else:
-            self.timings[key] = value
-
-    def add_message(self, key, value, sep=";"):
-        """
-        Add value to message. If key does not already exist in section then
-        it is created with this value.
-        If key already exists the value is added to the message
-        The value will be converted to a string
-        """
-        value = str(value)
-
-        if key in self.messages:
-            if sep is not None:
-                try:
-                    value = sep + value
-                except:
-                    TypeError("It is not possible to concatenate the value "
-                              "with the given seperator")
-            self.messages[key] += value
-        else:
-            self.messages[key] = value
-
-    def report(self, output=sys.stdout):
-        """
-        Report the counts, timings and messages for this section.
-        Note the percentage of the section and solver total times will be
-        given if the parent and or section total_time is set
-        """
-        if self.header:
-            output.write("\n{}\n{}\n".format(self.header,
-                                     ("-"*len(self.header))))
-
-        # TODO: Make the timings and counts ouput in a table format
-        #       Generally make more pretty
-
-        # Report timings
-        try:
-            ttt = self.parent.total_time
-        except:
-            ttt = None
-
-        tt = self.total_time
-
-        output.write("### Timings:\n")
-        for key, value in self.timings.items():
-            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
-            output.write(l)
-        if tt is not None:
-            output.write(" - {}\t{} total time\n".format(_format_time(tt),
-                                                     self.name))
-
-        # Report counts
-        output.write("### Counts:\n")
-        for key, value in self.counts.items():
-            l = " - {}\t{}\n".format(value, key)
-            output.write(l)
-
-        # Report messages
-        output.write("### Messages:\n")
-        for key, value in self.messages.items():
-            l = " - {}:\t{}\n".format(key, value)
-            output.write(l)
-
-
-    def clear(self):
-        """
-        Clear counts, timings and messages from this section
-        """
-        self.counts.clear()
-        self.timings.clear()
-        self.messages.clear()
-        self.total_time = None
-
-
-def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
-    # Input is std Qobj (Hamiltonian or Liouvillian)
-    if isinstance(H, Qobj):
-        Hdims = H.dims
-        Htype = H.type
-        _structure_check(Hdims, Htype, state)
-    # Input H is function
-    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
-        Hdims = H(0,args).dims
-        Htype = H(0,args).type
-        _structure_check(Hdims, Htype, state)
-    # Input is td-list
-    elif isinstance(H, list):
-        if isinstance(H[0], Qobj):
-            Hdims = H[0].dims
-            Htype = H[0].type
-        elif isinstance(H[0], list):
-            Hdims = H[0][0].dims
-            Htype = H[0][0].type
-        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
-            Hdims = H[0](0,args).dims
-            Htype = H[0](0,args).type
-        else:
-            raise Exception('Invalid td-list element.')
-        # Check all operators in list
-        for ii in range(len(H)):
-            if isinstance(H[ii], Qobj):
-                _temp_dims = H[ii].dims
-                _temp_type = H[ii].type
-            elif isinstance(H[ii], list):
-                _temp_dims = H[ii][0].dims
-                _temp_type = H[ii][0].type
-            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
-                _temp_dims = H[ii](0,args).dims
-                _temp_type = H[ii](0,args).type
-            else:
-                raise Exception('Invalid td-list element.')
-            _structure_check(_temp_dims,_temp_type,state)
-
-    else:
-        raise Exception('Invalid time-dependent format.')
-
-
-    for ii in range(len(c_ops)):
-        do_tests = True
-        if isinstance(c_ops[ii], Qobj):
-            _temp_state = c_ops[ii]
-        elif isinstance(c_ops[ii], list):
-            if isinstance(c_ops[ii][0], Qobj):
-                _temp_state = c_ops[ii][0]
-            elif isinstance(c_ops[ii][0], tuple):
-                do_tests = False
-                for kk in range(len(c_ops[ii][0])):
-                    _temp_state = c_ops[ii][0][kk]
-                    _structure_check(Hdims, Htype, _temp_state)
-        else:
-            raise Exception('Invalid td-list element.')
-        if do_tests:
-            _structure_check(Hdims, Htype, _temp_state)
-
-    if isinstance(e_ops, list):
-        for ii in range(len(e_ops)):
-            if isinstance(e_ops[ii], Qobj):
-                _temp_state = e_ops[ii]
-            elif isinstance(e_ops[ii], list):
-                _temp_state = e_ops[ii][0]
-            else:
-                raise Exception('Invalid td-list element.')
-            _structure_check(Hdims,Htype,_temp_state)
-    elif isinstance(e_ops, FunctionType):
-        pass
-    else:
-        raise Exception('Invalid e_ops specification.')
-
-
-def _structure_check(Hdims, Htype, state):
-    if state is not None:
-        # Input state is a ket vector
-        if state.type == 'ket':
-            # Input is Hamiltonian
-            if Htype == 'oper':
-                if Hdims[1] != state.dims[0]:
-                    raise Exception('Input operator and ket do not '
-                                    'share same structure.')
-            # Input is super and state is ket
-            elif Htype == 'super':
-                if Hdims[1][1] != state.dims[0]:
-                    raise Exception('Input operator and ket do not '
-                                    'share same structure.')
-            else:
-                raise Exception('Invalid input operator.')
-        # Input state is a density matrix
-        elif state.type == 'oper':
-            # Input is Hamiltonian and state is density matrix
-            if Htype == 'oper':
-                if Hdims[1] != state.dims[0]:
-                    raise Exception('Input operators do not '
-                                    'share same structure.')
-            # Input is super op. and state is density matrix
-            elif Htype == 'super':
-                if Hdims[1] != state.dims:
-                    raise Exception('Input operators do not '
-                                    'share same structure.')
-
-
-#
-# create a global instance of the SolverConfiguration class
-#
-config = SolverConfiguration()
-
-# for backwards compatibility
-# Odeoptions = Options
-# Odedata = Result
+from __future__ import print_function
+
+__all__ = ['SolverOptions', 'ExpectOps']
+
+import os
+import sys
+import warnings
+import datetime
+import numpy as np
+from collections import OrderedDict
+from types import FunctionType, BuiltinFunctionType
+
+from .. import __version__, Qobj, QobjEvo
+from .optionsclass import optionsclass
+from ..core import data as _data
+
+solver_safe = {}
+
+
+class SolverSystem():
+    pass
+
+
+class ExpectOps:
+    """
+        Contain and compute expectation values
+    """
+    def __init__(self, e_ops=[], super_=False):
+        # take care of expectation values, if any
+        self.isfunc = False
+        self.e_ops_dict = False
+        self.raw_e_ops = e_ops
+        self.e_ops_qoevo = []
+        self.e_num = 0
+        self.e_ops_isherm = []
+
+        if isinstance(e_ops, (Qobj, QobjEvo)):
+            e_ops = [e_ops]
+        elif isinstance(e_ops, dict):
+            self.e_ops_dict = e_ops
+            e_ops = [e for e in e_ops.values()]
+
+        self.e_ops = e_ops
+        if isinstance(e_ops, list):
+            self.e_num = len(e_ops)
+            self.e_ops_isherm = [e.isherm for e in e_ops]
+            if not super_:
+                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
+                                            dtype=object)
+            else:
+                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
+                                            dtype=object)
+        elif callable(e_ops):
+            self.isfunc = True
+            self.e_num = 1
+
+    def init(self, tlist):
+        self.tlist = tlist
+        if self.isfunc:
+            self.raw_out = []
+        else:
+            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
+
+    def check_dims(self, dims):
+        if not self.isfunc:
+            for op in self.e_ops_qoevo:
+                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
+                    raise TypeError(f"e_ops dims ({op.dims}) are not "
+                                    f"compatible with the system's ({dims})")
+
+    def copy(self):
+        out = ExpectOps.__new__(ExpectOps)
+        out.isfunc = self.isfunc
+        out.e_ops_dict = self.e_ops_dict
+        out.raw_e_ops = self.raw_e_ops
+        out.e_ops = self.e_ops
+        out.e_num = self.e_num
+        out.e_ops_isherm = self.e_ops_isherm
+        out.e_ops_qoevo = self.e_ops_qoevo
+        return out
+
+    def step(self, iter_, state):
+        if self.isfunc:
+            self.raw_out.append(self.e_ops(t, state))
+        else:
+            state = _data.dense.fast_from_numpy(state)
+            t = self.tlist[iter_]
+            for ii in range(self.e_num):
+                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
+                    self.raw_out[ii, iter_] = \
+                        self.e_ops_qoevo[ii].expect_data(t, state)
+                elif callable(self.e_ops_qoevo[ii]):
+                    self.raw_out[ii, iter_] = \
+                        self.e_ops_qoevo[ii](t, state)
+
+    def finish(self):
+        if self.isfunc:
+            result = self.raw_out
+        else:
+            result = []
+            for ii in range(self.e_num):
+                if self.e_ops_isherm[ii]:
+                    result.append(np.real(self.raw_out[ii, :]))
+                else:
+                    result.append(self.raw_out[ii, :])
+            if self.e_ops_dict:
+                result = {e: result[n]
+                          for n, e in enumerate(self.e_ops_dict.keys())}
+        return result
+
+    def __eq__(self, other):
+        if isinstance(other, ExpectOps):
+            other = other.raw_e_ops
+        return self.raw_e_ops == other
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __bool__(self):
+        return bool(self.e_num)
+
+
+@optionsclass("solver")
+class SolverOptions:
+    """
+    Class of options for evolution solvers such as :func:`qutip.mesolve` and
+    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
+    constructor::
+
+        opts = SolverOptions(order=10, ...)
+
+    or by changing the class attributes after creation::
+
+        opts = SolverOptions()
+        opts.order = 10
+
+    Returns options class to be used as options in evolution solvers.
+
+    The default can be changed by::
+
+        qutip.settings.solver['order'] = 10
+
+    Supported options:
+
+        atol : float {1e-8}
+            Absolute tolerance.
+        rtol : float {1e-6}
+            Relative tolerance.
+        method : str {'adams','bdf'}
+            Integration method.
+        order : int {12}
+            Order of integrator (<=12 'adams', <=5 'bdf')
+        nsteps : int {2500}
+            Max. number of internal steps/call.
+        first_step : float {0}
+            Size of initial step (0 = automatic).
+        min_step : float {0}
+            Minimum step size (0 = automatic).
+        max_step : float {0}
+            Maximum step size (0 = automatic)
+        tidy : bool {True,False}
+            Tidyup Hamiltonian and initial state by removing small terms.
+        average_states : bool {False}
+            Average states values over trajectories in stochastic solvers.
+        average_expect : bool {True}
+            Average expectation values over trajectories for stochastic solvers.
+        ntraj : int {500}
+            Number of trajectories in stochastic solvers.
+        store_final_state : bool {False, True}
+            Whether or not to store the final state of the evolution in the
+            result class.
+        store_states : bool {False, True}
+            Whether or not to store the state vectors or density matrices in the
+            result class, even if expectation values operators are given. If no
+            expectation are provided, then states are stored by default and this
+            option has no effect.
+    """
+    options = {
+        # Absolute tolerance (default = 1e-8)
+        "atol": 1e-8,
+        # Relative tolerance (default = 1e-6)
+        "rtol": 1e-6,
+        # Integration method (default = 'adams', for stiff 'bdf')
+        "method": 'adams',
+        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
+        "order": 12,
+        # Max. number of internal steps/call
+        "nsteps": 1000,
+        # Size of initial step (0 = determined by solver)
+        "first_step": 0,
+        # Max step size (0 = determined by solver)
+        "max_step": 0,
+        # Minimal step size (0 = determined by solver)
+        "min_step": 0,
+        # Average expectation values over trajectories (default = True)
+        "average_expect": True,
+        # average expectation values
+        "average_states": False,
+        # tidyup Hamiltonian before calculation (default = True)
+        "tidy": True,
+        # Number of trajectories (default = 500)
+        "ntraj": 500,
+        "gui": False,
+        # store final state?
+        "store_final_state": False,
+        # store states even if expectation operators are given?
+        "store_states": False,
+        # average mcsolver density matricies assuming steady state evolution
+        "steady_state_average": False,
+        # Normalize output of solvers
+        # (turned off for batch unitary propagator mode)
+        "normalize_output": True
+    }
+
+
+@optionsclass("mcsolve", SolverOptions)
+class McOptions:
+    """
+    Class of options for evolution solvers such as :func:`qutip.mesolve` and
+    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
+    constructor::
+
+        opts = SolverOptions(norm_tol=1e-3, ...)
+
+    or by changing the class attributes after creation::
+
+        opts = SolverOptions()
+        opts.['norm_tol'] = 1e-3
+
+    Returns options class to be used as options in evolution solvers.
+
+    The default can be changed by::
+
+        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
+
+    Options
+    -------
+
+    norm_tol : float {1e-4}
+        Tolerance used when finding wavefunction norm in mcsolve.
+    norm_t_tol : float {1e-6}
+        Tolerance used when finding wavefunction time in mcsolve.
+    norm_steps : int {5}
+        Max. number of steps used to find wavefunction norm to within norm_tol
+        in mcsolve.
+    mc_corr_eps : float {1e-10}
+        Arbitrarily small value for eliminating any divide-by-zero errors in
+        correlation calculations when using mcsolve.
+    """
+    options = {
+        # Tolerance for wavefunction norm (mcsolve only)
+        "norm_tol": 1e-4,
+        # Tolerance for collapse time precision (mcsolve only)
+        "norm_t_tol": 1e-6,
+        # Max. number of steps taken to find wavefunction norm to within
+        # norm_tol (mcsolve only)
+        "norm_steps": 5,
+        # small value in mc solver for computing correlations
+        "mc_corr_eps": 1e-10,
+    }
+
+
+class Result():
+    """Class for storing simulation results from any of the dynamics solvers.
+
+    Attributes
+    ----------
+
+    solver : str
+        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
+    times : list/array
+        Times at which simulation data was collected.
+    expect : list/array
+        Expectation values (if requested) for simulation.
+    states : array
+        State of the simulation (density matrix or ket) evaluated at ``times``.
+    num_expect : int
+        Number of expectation value operators in simulation.
+    num_collapse : int
+        Number of collapse operators in simualation.
+    ntraj : int/list
+        Number of trajectories (for stochastic solvers). A list indicates
+        that averaging of expectation values was done over a subset of total
+        number of trajectories.
+    col_times : list
+        Times at which state collpase occurred. Only for Monte Carlo solver.
+    col_which : list
+        Which collapse operator was responsible for each collapse in
+        ``col_times``. Only for Monte Carlo solver.
+
+    """
+    def __init__(self):
+        self.solver = None
+        self.times = None
+        self.states = []
+        self.expect = []
+        self.num_expect = 0
+        self.num_collapse = 0
+        self.ntraj = None
+        self.seeds = None
+        self.col_times = None
+        self.col_which = None
+
+    def __str__(self):
+        s = "Result object "
+        if self.solver:
+            s += "with " + self.solver + " data.\n"
+        else:
+            s += "missing solver information.\n"
+        s += "-" * (len(s) - 1) + "\n"
+        if self.states is not None and len(self.states) > 0:
+            s += "states = True\n"
+        elif self.expect is not None and len(self.expect) > 0:
+            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
+        else:
+            s += "states = True, expect = True\n" + \
+                "num_expect = " + str(self.num_expect) + ", "
+        s += "num_collapse = " + str(self.num_collapse)
+        if self.solver == 'mcsolve':
+            s += ", ntraj = " + str(self.ntraj)
+        return s
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __getstate__(self):
+        # defines what happens when Qobj object gets pickled
+        self.__dict__.update({'qutip_version': __version__[:5]})
+        return self.__dict__
+
+    def __setstate__(self, state):
+        # defines what happens when loading a pickled Qobj
+        if 'qutip_version' in state.keys():
+            del state['qutip_version']
+        (self.__dict__).update(state)
+
+
+# %%%%%%%%%%% remove ?
+class SolverConfiguration():
+    def __init__(self):
+
+        self.cgen_num = 0
+
+        self.reset()
+
+    def reset(self):
+        # General stuff
+        self.tlist = None       # evaluations times
+        self.ntraj = None       # number / list of trajectories
+        self.options = None     # options for solvers
+        self.norm_tol = None    # tolerance for wavefunction norm
+        self.norm_steps = None  # max. number of steps to take in finding
+        # Initial state stuff
+        self.psi0 = None        # initial state
+        self.psi0_dims = None   # initial state dims
+        self.psi0_shape = None  # initial state shape
+
+        # flags for setting time-dependence, collapse ops, and number of times
+        # codegen has been run
+        self.cflag = 0     # Flag signaling collapse operators
+        self.tflag = 0     # Flag signaling time-dependent problem
+
+        self.soft_reset()
+
+    def soft_reset(self):
+        # Hamiltonian stuff
+        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
+        self.h_tdterms = []  # List of td strs and funcs
+        self.h_data = None   # List of sparse matrix data
+        self.h_ind = None    # List of sparse matrix indices
+        self.h_ptr = None    # List of sparse matrix ptrs
+
+        # Expectation operator stuff
+        self.e_num = 0        # number of expect ops
+        self.e_ops_data = []  # expect op data
+        self.e_ops_ind = []   # expect op indices
+        self.e_ops_ptr = []   # expect op indptrs
+        self.e_ops_isherm = []  # expect op isherm
+
+        # Collapse operator stuff
+        self.c_num = 0          # number of collapse ops
+        self.c_const_inds = []  # indicies of constant collapse operators
+        self.c_td_inds = []     # indicies of time-dependent collapse operators
+        self.c_ops_data = []    # collapse op data
+        self.c_ops_ind = []     # collapse op indices
+        self.c_ops_ptr = []     # collapse op indptrs
+        self.c_args = []        # store args for time-dependent collapse func.
+
+        # Norm collapse operator stuff
+        self.n_ops_data = []  # norm collapse op data
+        self.n_ops_ind = []   # norm collapse op indices
+        self.n_ops_ptr = []   # norm collapse op indptrs
+
+        # holds executable strings for time-dependent collapse evaluation
+        self.col_expect_code = None
+        self.col_spmv_code = None
+
+        # hold stuff for function list based time dependence
+        self.h_td_inds = []
+        self.h_td_data = []
+        self.h_td_ind = []
+        self.h_td_ptr = []
+        self.h_funcs = None
+        self.h_func_args = None
+        self.c_funcs = None
+        self.c_func_args = None
+
+        # time-dependent (TD) function stuff
+        self.tdfunc = None     # Placeholder for TD RHS function.
+        self.tdname = None     # Name of td .pyx file
+        self.colspmv = None    # Placeholder for TD col-spmv function.
+        self.colexpect = None  # Placeholder for TD col_expect function.
+        self.string = None     # Holds string of variables passed to td solver
+
+
+def _format_time(t, tt=None, ttt=None):
+    time_str = str(datetime.timedelta(seconds=t))
+    if tt is not None and ttt is not None:
+        sect_percent = 100*t/tt
+        solve_percent = 100*t/ttt
+        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
+                                            sect_percent, solve_percent)
+    elif tt is not None:
+        sect_percent = 100*t/tt
+        time_str += " ({:03.2f}% section)".format(sect_percent)
+
+    elif ttt is not None:
+        solve_percent = 100*t/ttt
+        time_str += " ({:03.2f}% total)".format(solve_percent)
+
+    return time_str
+
+
+class Stats:
+    """
+    Statistical information on the solver performance
+    Statistics can be grouped into sections.
+    If no section names are given in the the contructor, then all statistics
+    will be added to one section 'main'
+
+    Parameters
+    ----------
+    section_names : list
+        list of keys that will be used as keys for the sections
+        These keys will also be used as names for the sections
+        The text in the output can be overidden by setting the header property
+        of the section
+        If no names are given then one section called 'main' is created
+
+    Attributes
+    ----------
+    sections : OrderedDict of _StatsSection
+        These are the sections that are created automatically on instantiation
+        or added using add_section
+
+    header : string
+        Some text that will be used as the heading in the report
+        By default there is None
+
+    total_time : float
+        Time in seconds for the solver to complete processing
+        Can be None, meaning that total timing percentages will be reported
+    """
+
+    def __init__(self, section_names=None):
+        self._def_section_name = 'main'
+        self.sections = OrderedDict()
+        self.total_time = None
+        self.header = None
+        if isinstance(section_names, list):
+            c = 0
+            for name in section_names:
+                self.sections[name] = _StatsSection(name, self)
+                if c == 0:
+                    self._def_section_name = name
+                c += 1
+
+        else:
+            self.sections[self._def_section_name] = \
+                        _StatsSection(self._def_section_name)
+
+    def _get_section(self, section):
+        if section is None:
+            return self.sections[self._def_section_name]
+        elif isinstance(section, _StatsSection):
+            return section
+        else:
+            sect = self.sections.get(section, None)
+            if sect is None:
+                raise ValueError("Unknown section {}".format(section))
+            else:
+                return sect
+
+    def add_section(self, name):
+        """
+        Add another section with the given name
+
+        Parameters
+        ----------
+        name : string
+            will be used as key for sections dict
+            will also be the header for the section
+
+        Returns
+        -------
+        section : :class:`_StatsSection`
+            The new section
+        """
+        sect = _StatsSection(name, self)
+        self.sections[name] = sect
+        return sect
+
+    def add_count(self, key, value, section=None):
+        """
+        Add value to count. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the give value
+        value is expected to be an integer
+
+        Parameters
+        ----------
+        key : string
+            key for the section.counts dictionary
+            reusing a key will result in numerical addition of value
+
+        value : int
+            Initial value of the count, or added to an existing count
+
+        section : string or :class:`_StatsSection`
+            Section which to add the count to.
+            If None given, the default (first) section will be used
+        """
+
+        self._get_section(section).add_count(key, value)
+
+    def add_timing(self, key, value, section=None):
+        """
+        Add value to timing. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the give value
+        value is expected to be a float, and given in seconds.
+
+        Parameters
+        ----------
+        key : string
+            key for the section.timings dictionary
+            reusing a key will result in numerical addition of value
+
+        value : int
+            Initial value of the timing, or added to an existing timing
+
+        section: string or `class` : _StatsSection
+            Section which to add the timing to.
+            If None given, the default (first) section will be used
+        """
+        self._get_section(section).add_timing(key, value)
+
+    def add_message(self, key, value, section=None, sep=";"):
+        """
+        Add value to message. If key does not already exist in section then
+        it is created with this value.
+        If key already exists the value is added to the message
+        The value will be converted to a string
+
+        Parameters
+        ----------
+        key : string
+            key for the section.messages dictionary
+            reusing a key will result in concatenation of value
+
+        value : int
+            Initial value of the message, or added to an existing message
+
+        sep : string
+            Message will be prefixed with this string when concatenating
+
+        section: string or `class` : _StatsSection
+            Section which to add the message to.
+            If None given, the default (first) section will be used
+        """
+        self._get_section(section).add_message(key, value, sep=sep)
+
+    def set_total_time(self, value, section=None):
+        """
+        Sets the total time for the complete solve or for a specific section
+        value is expected to be a float, and given in seconds
+
+        Parameters
+        ----------
+        value : float
+            Time in seconds to complete the solver section
+
+        section : string or `class` : _StatsSection
+            Section which to set the total_time for
+            If None given, the total_time for complete solve is set
+        """
+        if not isinstance(value, float):
+            try:
+                value = float(value)
+            except:
+                raise TypeError("value is expected to be a float")
+
+        if section is None:
+            self.total_time = value
+        else:
+            sect = self._get_section(section)
+            sect.total_time = value
+
+    def report(self, output=sys.stdout):
+        """
+        Report the counts, timings and messages from the sections.
+        Sections are reported in the order that the names were supplied
+        in the constructor.
+        The counts, timings and messages are reported in the order that they
+        are added to the sections
+        The output can be written to anything that supports a write method,
+        e.g. a file or the console (default)
+        The output is intended to in markdown format
+
+        Parameters
+        ----------
+        output : stream
+            file or console stream - anything that support write - where
+            the output will be written
+        """
+
+        if not hasattr(output, 'write'):
+            raise TypeError("output must have a write method")
+
+        if self.header:
+            output.write("{}\n{}\n".format(self.header,
+                                     ("="*len(self.header))))
+        for name, sect in self.sections.items():
+            sect.report(output)
+
+        if self.total_time is not None:
+            output.write("\nSummary\n-------\n")
+            output.write("{}\t solver total time\n".format(
+                                            _format_time(self.total_time)))
+
+    def clear(self):
+        """
+        Clear counts, timings and messages from all sections
+        """
+        for sect in self.sections.values():
+            sect.clear()
+        self.total_time = None
+
+
+class _StatsSection(object):
+    """
+    Not intended to be directly instantiated
+    This is the type for the SolverStats.sections values
+
+    The method parameter descriptions are the same as for those the parent
+    with the same method name
+
+    Parameters
+    ----------
+    name : string
+        key for the parent sections dictionary
+        will also be used as the header
+
+    parent : `class` :  SolverStats
+        The container for all the sections
+
+    Attributes
+    ----------
+    name : string
+        key for the parent sections dictionary
+        will also be used as the header
+
+    parent : `class` :  SolverStats
+        The container for all the sections
+
+    header : string
+        Used as heading for section in report
+
+    counts : OrderedDict
+        The integer type statistics for the stats section
+
+    timings : OrderedDict
+        The timing type statistics for the stats section
+        Expected to contain float values representing values in seconds
+
+    messages : OrderedDict
+        Text type output to be reported
+
+    total_time : float
+        Total time for processing in the section
+        Can be None, meaning that section timing percentages will be reported
+    """
+    def __init__(self, name, parent):
+        self.parent = parent
+        self.header = str(name)
+        self.name = name
+        self.counts = OrderedDict()
+        self.timings = OrderedDict()
+        self.messages = OrderedDict()
+        self.total_time = None
+
+    def add_count(self, key, value):
+        """
+        Add value to count. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the given value
+        value is expected to be an integer
+        """
+        if not isinstance(value, int):
+            try:
+                value = int(value)
+            except:
+                raise TypeError("value is expected to be an integer")
+
+        if key in self.counts:
+            self.counts[key] += value
+        else:
+            self.counts[key] = value
+
+    def add_timing(self, key, value):
+        """
+        Add value to timing. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the give value
+        value is expected to be a float, and given in seconds.
+        """
+        if not isinstance(value, float):
+            try:
+                value = float(value)
+            except:
+                raise TypeError("value is expected to be a float")
+
+        if key in self.timings:
+            self.timings[key] += value
+        else:
+            self.timings[key] = value
+
+    def add_message(self, key, value, sep=";"):
+        """
+        Add value to message. If key does not already exist in section then
+        it is created with this value.
+        If key already exists the value is added to the message
+        The value will be converted to a string
+        """
+        value = str(value)
+
+        if key in self.messages:
+            if sep is not None:
+                try:
+                    value = sep + value
+                except:
+                    TypeError("It is not possible to concatenate the value "
+                              "with the given seperator")
+            self.messages[key] += value
+        else:
+            self.messages[key] = value
+
+    def report(self, output=sys.stdout):
+        """
+        Report the counts, timings and messages for this section.
+        Note the percentage of the section and solver total times will be
+        given if the parent and or section total_time is set
+        """
+        if self.header:
+            output.write("\n{}\n{}\n".format(self.header,
+                                     ("-"*len(self.header))))
+
+        # TODO: Make the timings and counts ouput in a table format
+        #       Generally make more pretty
+
+        # Report timings
+        try:
+            ttt = self.parent.total_time
+        except:
+            ttt = None
+
+        tt = self.total_time
+
+        output.write("### Timings:\n")
+        for key, value in self.timings.items():
+            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
+            output.write(l)
+        if tt is not None:
+            output.write(" - {}\t{} total time\n".format(_format_time(tt),
+                                                     self.name))
+
+        # Report counts
+        output.write("### Counts:\n")
+        for key, value in self.counts.items():
+            l = " - {}\t{}\n".format(value, key)
+            output.write(l)
+
+        # Report messages
+        output.write("### Messages:\n")
+        for key, value in self.messages.items():
+            l = " - {}:\t{}\n".format(key, value)
+            output.write(l)
+
+
+    def clear(self):
+        """
+        Clear counts, timings and messages from this section
+        """
+        self.counts.clear()
+        self.timings.clear()
+        self.messages.clear()
+        self.total_time = None
+
+
+def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
+    # Input is std Qobj (Hamiltonian or Liouvillian)
+    if isinstance(H, Qobj):
+        Hdims = H.dims
+        Htype = H.type
+        _structure_check(Hdims, Htype, state)
+    # Input H is function
+    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
+        Hdims = H(0,args).dims
+        Htype = H(0,args).type
+        _structure_check(Hdims, Htype, state)
+    # Input is td-list
+    elif isinstance(H, list):
+        if isinstance(H[0], Qobj):
+            Hdims = H[0].dims
+            Htype = H[0].type
+        elif isinstance(H[0], list):
+            Hdims = H[0][0].dims
+            Htype = H[0][0].type
+        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
+            Hdims = H[0](0,args).dims
+            Htype = H[0](0,args).type
+        else:
+            raise Exception('Invalid td-list element.')
+        # Check all operators in list
+        for ii in range(len(H)):
+            if isinstance(H[ii], Qobj):
+                _temp_dims = H[ii].dims
+                _temp_type = H[ii].type
+            elif isinstance(H[ii], list):
+                _temp_dims = H[ii][0].dims
+                _temp_type = H[ii][0].type
+            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
+                _temp_dims = H[ii](0,args).dims
+                _temp_type = H[ii](0,args).type
+            else:
+                raise Exception('Invalid td-list element.')
+            _structure_check(_temp_dims,_temp_type,state)
+
+    else:
+        raise Exception('Invalid time-dependent format.')
+
+
+    for ii in range(len(c_ops)):
+        do_tests = True
+        if isinstance(c_ops[ii], Qobj):
+            _temp_state = c_ops[ii]
+        elif isinstance(c_ops[ii], list):
+            if isinstance(c_ops[ii][0], Qobj):
+                _temp_state = c_ops[ii][0]
+            elif isinstance(c_ops[ii][0], tuple):
+                do_tests = False
+                for kk in range(len(c_ops[ii][0])):
+                    _temp_state = c_ops[ii][0][kk]
+                    _structure_check(Hdims, Htype, _temp_state)
+        else:
+            raise Exception('Invalid td-list element.')
+        if do_tests:
+            _structure_check(Hdims, Htype, _temp_state)
+
+    if isinstance(e_ops, list):
+        for ii in range(len(e_ops)):
+            if isinstance(e_ops[ii], Qobj):
+                _temp_state = e_ops[ii]
+            elif isinstance(e_ops[ii], list):
+                _temp_state = e_ops[ii][0]
+            else:
+                raise Exception('Invalid td-list element.')
+            _structure_check(Hdims,Htype,_temp_state)
+    elif isinstance(e_ops, FunctionType):
+        pass
+    else:
+        raise Exception('Invalid e_ops specification.')
+
+
+def _structure_check(Hdims, Htype, state):
+    if state is not None:
+        # Input state is a ket vector
+        if state.type == 'ket':
+            # Input is Hamiltonian
+            if Htype == 'oper':
+                if Hdims[1] != state.dims[0]:
+                    raise Exception('Input operator and ket do not '
+                                    'share same structure.')
+            # Input is super and state is ket
+            elif Htype == 'super':
+                if Hdims[1][1] != state.dims[0]:
+                    raise Exception('Input operator and ket do not '
+                                    'share same structure.')
+            else:
+                raise Exception('Invalid input operator.')
+        # Input state is a density matrix
+        elif state.type == 'oper':
+            # Input is Hamiltonian and state is density matrix
+            if Htype == 'oper':
+                if Hdims[1] != state.dims[0]:
+                    raise Exception('Input operators do not '
+                                    'share same structure.')
+            # Input is super op. and state is density matrix
+            elif Htype == 'super':
+                if Hdims[1] != state.dims:
+                    raise Exception('Input operators do not '
+                                    'share same structure.')
+
+
+#
+# create a global instance of the SolverConfiguration class
+#
+config = SolverConfiguration()
+
+# for backwards compatibility
+# Odeoptions = Options
+# Odedata = Result
diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index 99829ae8ff..63df5c468b 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -1,1405 +1,1405 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-import scipy.sparse as sp
-from .. import (
-    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
-    unstack_columns, liouvillian, lindblad_dissipator,
-)
-from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
-from ._stochastic import (
-    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
-    GenericSSolver, Solvers
-)
-from .solver import Result, SolverOptions, _solver_safety_check
-from .parallel import serial_map
-from ..ui.progressbar import TextProgressBar
-from qutip.core import data as _data
-
-__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
-           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
-           'stochastic_solvers', 'general_stochastic']
-
-
-def stochastic_solvers():
-    # This docstring contains several literal backslash characters inside LaTeX
-    # blocks, but it cannot be declared as a raw string because we also need to
-    # use a line continuation.  At one point we need a restructured text
-    # "definition list", where the heading _must_ be entirely on one line,
-    # however it will violate our line-length reporting if we do that.
-    """
-    This function is purely a reference point for documenting the available
-    stochastic solver methods, and takes no actions.
-
-    Notes
-    -----
-    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
-        euler-maruyama
-            A simple generalization of the Euler method for ordinary
-            differential equations to stochastic differential equations.  Only
-            solver which could take non-commuting ``sc_ops``. *not tested*
-
-            - Order 0.5
-            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
-
-        milstein
-            An order 1.0 strong Taylor scheme.  Better approximate numerical
-            solution to stochastic differential equations.  See eq. (2.9) of
-            chapter 12.2 of [1]_.
-
-            - Order strong 1.0
-            - Code: ``'milstein'`` or ``1.0``
-
-        milstein-imp
-            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
-            scheme for the numerical simulation of stiff stochastic
-            differential equations.
-
-            - Order strong 1.0
-            - Code: ``'milstein-imp'``
-
-        predictor-corrector
-            Generalization of the trapezoidal method to stochastic differential
-            equations. More stable than explicit methods.  See eq. (5.4) of
-            chapter 15.5 of [1]_.
-
-            - Order strong 0.5, weak 1.0
-            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
-              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
-              ``'pc-euler'``
-            - Codes to correct both the stochastic and deterministic parts
-              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
-              ``'pc-euler-2'`` or ``'pred-corr-2'``
-
-        platen
-            Explicit scheme, creates the Milstein using finite differences
-            instead of analytic derivatives. Also contains some higher order
-            terms, thus converges better than Milstein while staying strong
-            order 1.0.  Does not require derivatives, therefore usable by
-            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
-
-            - Order strong 1.0, weak 2.0
-            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
-
-        rouchon
-            Scheme keeping the positivity of the density matrix
-            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
-
-            - Order strong 1.0?
-            - Code: ``'rouchon'`` or ``'Rouchon'``
-
-        taylor1.5
-            Order 1.5 strong Taylor scheme.  Solver with more terms of the
-            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
-
-            - Order strong 1.5
-            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
-
-        taylor1.5-imp
-            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
-            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
-            (2.18) of chapter 12.2 of [1]_.
-
-            - Order strong 1.5
-            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
-
-        explicit1.5
-            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
-            Taylor scheme using finite difference instead of derivatives.
-            Slower than ``taylor15`` but usable by
-            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
-            [1]_.
-
-            - Order strong 1.5
-            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
-
-        taylor2.0
-            Order 2 strong Taylor scheme.  Solver with more terms of the
-            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
-
-            - Order strong 2.0
-            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
-
-        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
-        and for both heterodyne and homodyne. taylor2.0 only works for 1
-        stochastic operator independent of time with the homodyne method.
-        :func:`~general_stochastic` only accepts the derivative-free
-        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
-
-    Available solvers for :obj:`~photocurrent_sesolve` and \
-:obj:`~photocurrent_mesolve`
-        Photocurrent use ordinary differential equations between
-        stochastic "jump/collapse".
-
-        euler
-            Euler method for ordinary differential equations between jumps.
-            Only one jump per time interval.  Default solver.  See eqs. (4.19)
-            and (4.4) of chapter 4 of [4]_.
-
-            - Order 1.0
-            - Code: ``'euler'``
-
-        predictor–corrector
-            predictor–corrector method (PECE) for ordinary differential
-            equations.  Uses the Poisson distribution to obtain the number of
-            jumps at each timestep.
-
-            - Order 2.0
-            - Code: ``'pred-corr'``
-
-    References
-    ----------
-    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
-       Stochastic Differential Equations*.
-    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
-       Systems*.
-    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
-       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
-       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
-       (2015).
-    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
-       control*.
-    """
-
-
-class StochasticSolverOptions:
-    """Class of options for stochastic solvers such as
-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
-
-    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
-    :func:`qutip.stochastic.photocurrent_sesolve` and
-    :func:`qutip.stochastic.photocurrent_mesolve`
-    all take the same keyword arguments as
-    the constructor of these class, and internally they use these arguments to
-    construct an instance of this class, so it is rarely needed to explicitly
-    create an instance of this class.
-
-    Within the attribute list, a ``time_dependent_object`` is either
-
-    - :class:`~qutip.Qobj`: a constant term
-    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
-      where the ``Qobj`` will be multiplied by the time-dependent scalar.
-
-    For more details on all allowed time-dependent objects, see the
-    documentation for :class:`~qutip.QobjEvo`.
-
-    Attributes
-    ----------
-    H : time_dependent_object or list of time_dependent_object
-        System Hamiltonian in standard time-dependent list format.  This is the
-        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
-        If this is a list of elements, they are summed.
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix.
-
-    times : array_like of float
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of time_dependent_object
-        List of deterministic collapse operators.  Each element of the list is
-        a separate operator; unlike the Hamiltonian, there is no implicit
-        summation over the terms.
-
-    sc_ops : list of time_dependent_object
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.  Each element of the list is a separate operator, like
-        ``c_ops``.
-
-    e_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    m_ops : list of :class:`qutip.Qobj`
-        List of operators representing the measurement operators. The expected
-        format is a nested list with one measurement operator for each
-        stochastic increament, for each stochastic collapse operator.
-
-    args : dict
-        Dictionary of parameters for time dependent systems.
-
-    tol : float
-        Tolerance of the solver for implicit methods.
-
-    ntraj : int
-        Number of trajectors.
-
-    nsubsteps : int
-        Number of sub steps between each time-spep given in `times`.
-
-    dW_factors : array
-        Array of length len(sc_ops), containing scaling factors for each
-        measurement operator in m_ops.
-
-    solver : string
-        Name of the solver method to use for solving the stochastic
-        equations. Valid values are:
-
-        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
-        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
-        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
-        - order 2 algorithms: 'taylor2.0'
-
-        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
-        for a description of the solvers.  Implicit methods can adjust
-        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
-
-    method : string ('homodyne', 'heterodyne')
-        The name of the type of measurement process that give rise to the
-        stochastic equation to solve.
-
-    store_all_expect : bool (default False)
-        Whether or not to store the e_ops expect values for all paths.
-
-    store_measurement : bool (default False)
-        Whether or not to store the measurement results in the
-        :class:`qutip.solver.Result` instance returned by the solver.
-
-    noise : int, or 1D array of int, or 4D array of float
-        - int : seed of the noise
-        - 1D array : length = ntraj, seeds for each trajectories.
-        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
-          Vector for the noise, the len of the last dimensions is doubled for
-          solvers of order 1.5. This corresponds to results.noise.
-
-    noiseDepth : int
-        Number of terms kept of the truncated series used to create the
-        noise used by taylor2.0 solver.
-
-    normalize : bool
-        (default True for (photo)ssesolve, False for (photo)smesolve)
-        Whether or not to normalize the wave function during the evolution.
-        Normalizing density matrices introduce numerical errors.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options. Only options['average_states'] and
-        options['store_states'] are used.
-
-    map_func: function
-        A map function or managing the calls to single-trajactory solvers.
-
-    map_kwargs: dictionary
-        Optional keyword arguments to the map_func function function.
-
-    progress_bar : :class:`qutip.ui.BaseProgressBar`
-        Optional progress bar class instance.
-    """
-    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
-                 e_ops=[], m_ops=None, store_all_expect=False,
-                 store_measurement=False, dW_factors=None,
-                 solver=None, method="homodyne", normalize=None,
-                 times=None, nsubsteps=1, ntraj=1, tol=None,
-                 generate_noise=None, noise=None,
-                 progress_bar=None, map_func=None, map_kwargs=None,
-                 args={}, options=None, noiseDepth=20):
-
-        if options is None:
-            options = SolverOptions()
-
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
-        # System
-        # Cast to QobjEvo so the code has only one version for both the
-        # constant and time-dependent case.
-        self.me = me
-
-        if H is not None:
-            msg = "The Hamiltonian format is not valid. "
-            try:
-                self.H = QobjEvo(H, args=args, tlist=times)
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.H = H
-
-        if sc_ops:
-            msg = ("The sc_ops format is not valid. Options are "
-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-            try:
-                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
-                               for op in sc_ops]
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.sc_ops = sc_ops
-
-        if c_ops:
-            msg = ("The c_ops format is not valid. Options are "
-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-            try:
-                self.c_ops = [QobjEvo(op, args=args, tlist=times)
-                              for op in c_ops]
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.c_ops = c_ops
-
-        self.state0 = state0
-        self.rho0 = stack_columns(state0.full()).ravel()
-
-        # Observation
-
-        for e_op in e_ops:
-            if (
-                isinstance(e_op, Qobj)
-                and self.H is not None
-                and e_op.dims[1] != self.H.dims[0]
-            ):
-                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
-                                f"with the system's ({self.H.dims})")
-        self.e_ops = e_ops
-        self.m_ops = m_ops
-        self.store_measurement = store_measurement
-        self.store_all_expect = store_all_expect
-        self.store_states = options['store_states']
-        self.dW_factors = dW_factors
-
-        # Solver
-        self.solver = solver
-        self.method = method
-        if normalize is None and me:
-            self.normalize = 0
-        elif normalize is None and not me:
-            self.normalize = 1
-        elif normalize:
-            self.normalize = 1
-        else:
-            self.normalize = 0
-
-        self.times = times
-        self.nsubsteps = nsubsteps
-        self.dt = (times[1] - times[0]) / self.nsubsteps
-        self.ntraj = ntraj
-        if tol is not None:
-            self.tol = tol
-        elif "tol" in args:
-            self.tol = args["tol"]
-        else:
-            self.tol = 1e-7
-
-        # Noise
-        if noise is not None:
-            if isinstance(noise, int):
-                # noise contain a seed
-                np.random.seed(noise)
-                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-            noise = np.array(noise)
-            if len(noise.shape) == 1:
-                if noise.shape[0] < ntraj:
-                    raise ValueError("'noise' does not have enought seeds " +
-                                     "len(noise) >= ntraj")
-                # numpy seed must be between 0 and 2**32-1
-                # 'u4': unsigned 32bit int
-                self.noise = noise.astype("u4")
-                self.noise_type = 0
-
-            elif len(noise.shape) == 4:
-                # taylor case not included
-                dw_len = (2 if method == "heterodyne" else 1)
-                dw_len_str = (" * 2" if method == "heterodyne" else "")
-                msg = "Incorrect shape for 'noise': "
-                if noise.shape[0] < ntraj:
-                    raise ValueError(msg + "shape[0] >= ntraj")
-                if noise.shape[1] < len(times):
-                    raise ValueError(msg + "shape[1] >= len(times)")
-                if noise.shape[2] < nsubsteps:
-                    raise ValueError(msg + "shape[2] >= nsubsteps")
-                if noise.shape[3] < len(self.sc_ops) * dw_len:
-                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
-                                     dw_len_str)
-                self.noise_type = 1
-                self.noise = noise
-
-        else:
-            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-            self.noise_type = 0
-
-        # Map
-        self.progress_bar = progress_bar
-        if self.ntraj > 1 and map_func:
-            self.map_func = map_func
-        else:
-            self.map_func = serial_map
-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-
-        # Other
-        self.options = options
-        self.args = args
-        self.set_solver()
-        self.p = noiseDepth
-
-    def set_solver(self):
-        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
-            self.solver_code = 50
-            self.solver = 'euler-maruyama'
-        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
-            self.solver_code = 100
-            self.solver = 'platen'
-        elif self.solver in ['pred-corr', 'predictor-corrector',
-                             'pc-euler', 101]:
-            self.solver_code = 101
-            self.solver = 'pred-corr'
-        elif self.solver in ['milstein', 102, 1.0]:
-            self.solver_code = 102
-            self.solver = 'milstein'
-        elif self.solver in ['milstein-imp', 103]:
-            self.solver_code = 103
-            self.solver = 'milstein-imp'
-        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
-            self.solver_code = 104
-            self.solver = 'pred-corr-2'
-        elif self.solver in ['Rouchon', 'rouchon', 120]:
-            self.solver_code = 120
-            self.solver = 'rouchon'
-            if not all((op.isconstant for op in self.sc_ops)):
-                raise ValueError("Rouchon only works with constant sc_ops")
-        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
-            self.solver_code = 150
-            self.solver = 'explicit1.5'
-        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
-            self.solver_code = 152
-            self.solver = 'taylor1.5'
-        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
-            self.solver_code = 153
-            self.solver = 'taylor1.5-imp'
-        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
-            self.solver_code = 202
-            self.solver = 'taylor2.0'
-            if not len(self.sc_ops) == 1 or \
-                    not self.sc_ops[0].isconstant or \
-                    not self.method == "homodyne":
-                raise ValueError(
-                    "Taylor2.0 only works with 1 constant sc_ops and for"
-                    " homodyne method"
-                )
-        else:
-            known = [
-                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
-                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
-                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
-            ]
-            raise ValueError("The solver should be one of {!r}".format(known))
-
-
-class StochasticSolverOptionsPhoto(StochasticSolverOptions):
-    """
-    Attributes
-    ----------
-
-    solver : string
-        Name of the solver method to use for solving the evolution
-        of the system.*
-        order 1 algorithms: 'euler'
-        order 2 algorithms: 'pred-corr'
-        In photocurrent evolution
-    """
-    def set_solver(self):
-        if self.solver in [None, 'euler', 1, 60]:
-            self.solver_code = 60
-            self.solver = 'euler'
-        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
-            self.solver_code = 110
-            self.solver = 'pred-corr'
-        else:
-            raise Exception("The solver should be one of " +
-                            "[None, 'euler', 'predictor-corrector']")
-
-
-def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic master equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    if "method" in kwargs and kwargs["method"] == "photocurrent":
-        print("stochastic solver with photocurrent method has been moved to "
-              "it's own function: photocurrent_mesolve")
-        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
-                                    e_ops=e_ops, _safe_mode=_safe_mode,
-                                    args=args, **kwargs)
-    if isket(rho0):
-        rho0 = ket2dm(rho0)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
-                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-                                  args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.solver_code == 120:
-        return _positive_map(sso, e_ops_dict)
-
-    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
-    if sso.method == 'homodyne' or sso.method is None:
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sso.m_ops)
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise Exception("The len of dW_factors is not the same as m_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sso.sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
-                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-        elif len(sso.dW_factors) == len(sso.m_ops):
-            pass
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == "photocurrent":
-        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
-
-    else:
-        raise Exception("The method must be one of None, homodyne, heterodyne")
-
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-
-    if sso.solver_code in [103, 153]:
-        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
-
-    sso.solver_obj = SMESolver
-    sso.solver_name = "smesolve_" + sso.solver
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic schrodinger equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    psi0 : :class:`qutip.Qobj`
-        State vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if "method" in kwargs and kwargs["method"] == "photocurrent":
-        print("stochastic solver with photocurrent method has been moved to "
-              "it's own function: photocurrent_sesolve")
-        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
-                                    e_ops=e_ops, _safe_mode=_safe_mode,
-                                    args=args, **kwargs)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
-                                  sc_ops=sc_ops, e_ops=e_ops,
-                                  args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.solver_code == 120:
-        raise Exception("rouchon only work with smesolve")
-
-    if sso.method == 'homodyne' or sso.method is None:
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sso.sops)
-        elif len(sso.dW_factors) != len(sso.sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sso.sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            c1 = c / np.sqrt(2)
-            c2 = c * (-1j / np.sqrt(2))
-            sso.sops += [[c1, c1 + c1.dag()],
-                         [c2, c2 + c2.dag()]]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sso.sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == "photocurrent":
-        NotImplementedError("Moved to 'photocurrent_sesolve'")
-
-    else:
-        raise Exception("The method must be one of None, homodyne, heterodyne")
-
-    sso.LH = sso.H * (-1j * sso.dt)
-    for ops in sso.sops:
-        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
-
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-
-    sso.solver_obj = SSESolver
-    sso.solver_name = "ssesolve_" + sso.solver
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def _positive_map(sso, e_ops_dict):
-    if sso.method == 'homodyne' or sso.method is None:
-        sops = sso.sc_ops
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sops)
-        elif len(sso.dW_factors) != len(sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sops)
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-    else:
-        raise Exception("The method must be one of homodyne or heterodyne")
-
-    LH = 1 - (sso.H * 1j * sso.dt)
-    sso.pp = spre(sso.H) * 0
-    sso.sops = []
-    sso.preops = []
-    sso.postops = []
-    sso.preops2 = []
-    sso.postops2 = []
-
-    def _prespostdag(op):
-        return spre(op) * spost(op.dag())
-
-    for op in sso.c_ops:
-        LH += op.dag() @ op * (-sso.dt * 0.5)
-        sso.pp += spre(op) * spost(op.dag()) * sso.dt
-
-    for i, op in enumerate(sops):
-        LH += (-sso.dt * 0.5) * op.dag() @ op
-        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
-        sso.preops += [spre(op)]
-        sso.postops += [spost(op.dag())]
-        for op2 in sops[i:]:
-            sso.preops2 += [spre(op * op2)]
-            sso.postops2 += [spost(op.dag() * op2.dag())]
-
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-    sso.preLH = spre(LH)
-    sso.postLH = spost(LH.dag())
-
-    sso.solver_obj = PmSMESolver
-    sso.solver_name = "smesolve_" + sso.solver
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-                         _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic master equation using the photocurrent method.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isket(rho0):
-        rho0 = ket2dm(rho0)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
-                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-                                       args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.m_ops is None:
-        sso.m_ops = [op * 0 for op in sso.sc_ops]
-    if not isinstance(sso.dW_factors, list):
-        sso.dW_factors = [1] * len(sso.sc_ops)
-    elif len(sso.dW_factors) != len(sso.sc_ops):
-        raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    sso.solver_obj = PcSMESolver
-    sso.solver_name = "photocurrent_mesolve"
-    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
-
-    def _prespostdag(op):
-        return spre(op) * spost(op.dag())
-
-    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
-                 spre(op.dag() @ op),
-                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
-                         _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic schrodinger equation using the photocurrent method.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = list(e_ops.values())
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
-                                       sc_ops=sc_ops, e_ops=e_ops,
-                                       args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.m_ops is None:
-        sso.m_ops = [op * 0 for op in sso.sc_ops]
-    if not isinstance(sso.dW_factors, list):
-        sso.dW_factors = [1] * len(sso.sc_ops)
-    elif len(sso.dW_factors) != len(sso.sc_ops):
-        raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    sso.solver_obj = PcSSESolver
-    sso.solver_name = "photocurrent_sesolve"
-    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
-    sso.LH = sso.H * (-1j*sso.dt)
-    for ops in sso.sops:
-        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
-                       _safe_mode=True, len_d2=1, args={}, **kwargs):
-    """
-    Solve stochastic general equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-
-    Parameters
-    ----------
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix as a vector.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    d1 : function, callable class
-        Function representing the deterministic evolution of the system.
-
-        def d1(time (double), state (as a np.array vector)):
-            return 1d np.array
-
-    d2 : function, callable class
-        Function representing the stochastic evolution of the system.
-
-        def d2(time (double), state (as a np.array vector)):
-            return 2d np.array (N_sc_ops, len(state0))
-
-    len_d2 : int
-        Number of output vector produced by d2
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-        Must be a superoperator if the state vector is a density matrix.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    if "solver" not in kwargs:
-        kwargs["solver"] = 50
-
-    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
-                                  e_ops=e_ops, args=args, **kwargs)
-    if sso.solver_code not in [50, 100, 150]:
-        raise ValueError("Only Euler, platen, platen15 can be " +
-                         "used for the general stochastic solver.")
-
-    sso.d1 = d1
-    sso.d2 = d2
-    if _safe_mode:
-        # This state0_vec is computed as stack_columns(state0.full()).ravel()
-        # in the sso init.
-        state0_vec = sso.rho0
-        l_vec = state0_vec.shape[0]
-        try:
-            out_d1 = d1(0., sso.rho0)
-        except Exception as e:
-            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
-                               str(e)) from e
-        try:
-            out_d2 = d2(0., sso.rho0)
-        except Exception as e:
-            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
-                               str(e)) from e
-
-        msg_d1 = ("d1 must return an 1d numpy array with the same number "
-                  "of elements as the initial state as a vector.")
-        if not isinstance(out_d1, np.ndarray):
-            raise TypeError(msg_d1)
-        if (out_d1.ndim != 1
-                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
-            raise ValueError(msg_d1)
-
-        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
-                  "with the shape (len_d2, len(state0_vec) ).")
-        if not isinstance(out_d2, np.ndarray):
-            raise TypeError(msg_d2)
-        if (out_d2.ndim != 2
-                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
-            raise ValueError(msg_d2)
-        if out_d1.dtype != np.dtype('complex128') or \
-           out_d2.dtype != np.dtype('complex128'):
-            raise ValueError("Safety check: d1 and d2 must return " +
-                             "complex numpy array.")
-        msg_e_ops = ("Safety check: The shape of the e_ops "
-                     "does not fit the intial state.")
-        for op in sso.e_ops:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise ValueError(msg_e_ops)
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise ValueError(msg_e_ops +
-                                     " Expecting e_ops as superoperators.")
-
-    sso.m_ops = []
-    sso.cm_ops = []
-    if sso.store_measurement:
-        if not m_ops:
-            raise ValueError("General stochastic needs explicit " +
-                             "m_ops to store measurement.")
-        sso.m_ops = m_ops
-        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-        if sso.dW_factors is None:
-            sso.dW_factors = [1.] * len(sso.m_ops)
-        elif len(sso.dW_factors) == 1:
-            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise ValueError("The number of dW_factors must fit" +
-                             " the number of m_ops.")
-
-    if sso.dW_factors is None:
-        sso.dW_factors = [1.] * len_d2
-    sso.sops = [None] * len_d2
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-
-    sso.solver_obj = GenericSSolver
-    sso.solver_name = "general_stochastic_solver_" + sso.solver
-
-    ssolver = GenericSSolver()
-    # ssolver.set_data(sso)
-    ssolver.set_solver(sso)
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def _safety_checks(sso):
-    l_vec = sso.rho0.shape[0]
-    if sso.H.issuper:
-        if not sso.me:
-            raise ValueError(
-                "Given a Liouvillian for a Schrödinger equation problem."
-            )
-        shape_op = sso.H.shape
-        if shape_op[0] != l_vec or shape_op[1] != l_vec:
-            raise Exception("The size of the hamiltonian does "
-                            "not fit the intial state")
-    else:
-        shape_op = sso.H.shape
-        if sso.me:
-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                raise Exception("The size of the hamiltonian does "
-                                "not fit the intial state")
-        else:
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the hamiltonian does "
-                                "not fit the intial state")
-
-    for op in sso.sc_ops:
-        if op.issuper:
-            if not sso.me:
-                raise ValueError(
-                    "Given a Liouvillian for a Schrödinger equation problem."
-                )
-            shape_op = op.shape
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the sc_ops does "
-                                "not fit the intial state")
-        else:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the sc_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the sc_ops does "
-                                    "not fit the intial state")
-
-    for op in sso.c_ops:
-        if op.issuper:
-            if not sso.me:
-                raise ValueError(
-                    "Given a Liouvillian for a Schrödinger equation problem."
-                )
-            shape_op = op.shape
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the c_ops does "
-                                "not fit the intial state")
-        else:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the c_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the c_ops does "
-                                    "not fit the intial state")
-
-    for op in sso.e_ops:
-        shape_op = op.shape
-        if sso.me:
-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                raise Exception("The size of the e_ops does "
-                                "not fit the intial state")
-        else:
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the e_ops does "
-                                "not fit the intial state")
-
-    if sso.m_ops is not None:
-        for op in sso.m_ops:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the m_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the m_ops does "
-                                    "not fit the intial state")
-
-
-def _sesolve_generic(sso, options, progress_bar):
-    """
-    Internal function. See smesolve.
-    """
-    res = Result()
-    res.times = sso.times
-    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-    res.measurement = []
-    res.solver = sso.solver_name
-    res.ntraj = sso.ntraj
-    res.num_expect = len(sso.e_ops)
-
-    nt = sso.ntraj
-    task = _single_trajectory
-    map_kwargs = {'progress_bar': sso.progress_bar}
-    map_kwargs.update(sso.map_kwargs)
-    task_args = (sso,)
-    task_kwargs = {}
-
-    results = sso.map_func(task, list(range(sso.ntraj)),
-                           task_args, task_kwargs, **map_kwargs)
-    noise = []
-    for result in results:
-        states_list, dW, m, expect = result
-        res.states.append(states_list)
-        noise.append(dW)
-        res.measurement.append(m)
-        res.expect += expect
-        res.ss += expect * expect
-    res.noise = np.stack(noise)
-
-    if sso.store_all_expect:
-        paths_expect = []
-        for result in results:
-            paths_expect.append(result[3])
-        res.runs_expect = np.stack(paths_expect)
-
-    # average density matrices (vectorized maybe)
-    # ajgpitch 2019-10-25: np.any(res.states) seems to error
-    # I guess there may be a potential exception if there are no states?
-    # store individual trajectory states
-    res.traj_states = res.states
-    res.avg_states = None
-    if options['average_states'] and options['store_states']:
-        avg_states_list = []
-        for n in range(len(res.times)):
-            tslot_states = [res.states[mm][n].data for mm in range(nt)]
-            if len(tslot_states) > 0:
-                state = Qobj(np.sum(tslot_states),
-                             dims=res.states[0][n].dims).unit()
-                avg_states_list.append(state)
-        # store average states
-        res.states = res.avg_states = avg_states_list
-
-    # average
-    res.expect = res.expect / nt
-
-    # standard error
-    if nt > 1:
-        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
-    else:
-        res.se = None
-
-    # convert complex data to real if hermitian
-    res.expect = [np.real(res.expect[n, :])
-                  if e.isherm else res.expect[n, :]
-                  for n, e in enumerate(sso.e_ops)]
-
-    return res
-
-
-def _single_trajectory(i, sso):
-    # Only one step?
-    ssolver = sso.solver_obj()
-    ssolver.set_solver(sso)
-    result = ssolver.cy_sesolve_single_trajectory(i)
-    return result
-
-
-# The code for ssepdpsolve have been moved to the file pdpsolve.
-# The call is still in stochastic for consistance.
-def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-    trajectory simulations.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
-
-
-# The code for smepdpsolve have been moved to the file pdpsolve.
-# The call is still in stochastic for consistance.
-def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for density matrix
-    evolution.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import scipy.sparse as sp
+from .. import (
+    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
+    unstack_columns, liouvillian, lindblad_dissipator,
+)
+from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
+from ._stochastic import (
+    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
+    GenericSSolver, Solvers
+)
+from .solver import Result, SolverOptions, _solver_safety_check
+from .parallel import serial_map
+from ..ui.progressbar import TextProgressBar
+from qutip.core import data as _data
+
+__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
+           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
+           'stochastic_solvers', 'general_stochastic']
+
+
+def stochastic_solvers():
+    # This docstring contains several literal backslash characters inside LaTeX
+    # blocks, but it cannot be declared as a raw string because we also need to
+    # use a line continuation.  At one point we need a restructured text
+    # "definition list", where the heading _must_ be entirely on one line,
+    # however it will violate our line-length reporting if we do that.
+    """
+    This function is purely a reference point for documenting the available
+    stochastic solver methods, and takes no actions.
+
+    Notes
+    -----
+    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
+        euler-maruyama
+            A simple generalization of the Euler method for ordinary
+            differential equations to stochastic differential equations.  Only
+            solver which could take non-commuting ``sc_ops``. *not tested*
+
+            - Order 0.5
+            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
+
+        milstein
+            An order 1.0 strong Taylor scheme.  Better approximate numerical
+            solution to stochastic differential equations.  See eq. (2.9) of
+            chapter 12.2 of [1]_.
+
+            - Order strong 1.0
+            - Code: ``'milstein'`` or ``1.0``
+
+        milstein-imp
+            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
+            scheme for the numerical simulation of stiff stochastic
+            differential equations.
+
+            - Order strong 1.0
+            - Code: ``'milstein-imp'``
+
+        predictor-corrector
+            Generalization of the trapezoidal method to stochastic differential
+            equations. More stable than explicit methods.  See eq. (5.4) of
+            chapter 15.5 of [1]_.
+
+            - Order strong 0.5, weak 1.0
+            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
+              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
+              ``'pc-euler'``
+            - Codes to correct both the stochastic and deterministic parts
+              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
+              ``'pc-euler-2'`` or ``'pred-corr-2'``
+
+        platen
+            Explicit scheme, creates the Milstein using finite differences
+            instead of analytic derivatives. Also contains some higher order
+            terms, thus converges better than Milstein while staying strong
+            order 1.0.  Does not require derivatives, therefore usable by
+            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
+
+            - Order strong 1.0, weak 2.0
+            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
+
+        rouchon
+            Scheme keeping the positivity of the density matrix
+            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
+
+            - Order strong 1.0?
+            - Code: ``'rouchon'`` or ``'Rouchon'``
+
+        taylor1.5
+            Order 1.5 strong Taylor scheme.  Solver with more terms of the
+            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
+            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
+
+            - Order strong 1.5
+            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
+
+        taylor1.5-imp
+            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
+            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
+            (2.18) of chapter 12.2 of [1]_.
+
+            - Order strong 1.5
+            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
+
+        explicit1.5
+            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
+            Taylor scheme using finite difference instead of derivatives.
+            Slower than ``taylor15`` but usable by
+            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
+            [1]_.
+
+            - Order strong 1.5
+            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
+
+        taylor2.0
+            Order 2 strong Taylor scheme.  Solver with more terms of the
+            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
+
+            - Order strong 2.0
+            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
+
+        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
+        and for both heterodyne and homodyne. taylor2.0 only works for 1
+        stochastic operator independent of time with the homodyne method.
+        :func:`~general_stochastic` only accepts the derivative-free
+        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
+
+    Available solvers for :obj:`~photocurrent_sesolve` and \
+:obj:`~photocurrent_mesolve`
+        Photocurrent use ordinary differential equations between
+        stochastic "jump/collapse".
+
+        euler
+            Euler method for ordinary differential equations between jumps.
+            Only one jump per time interval.  Default solver.  See eqs. (4.19)
+            and (4.4) of chapter 4 of [4]_.
+
+            - Order 1.0
+            - Code: ``'euler'``
+
+        predictor–corrector
+            predictor–corrector method (PECE) for ordinary differential
+            equations.  Uses the Poisson distribution to obtain the number of
+            jumps at each timestep.
+
+            - Order 2.0
+            - Code: ``'pred-corr'``
+
+    References
+    ----------
+    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
+       Stochastic Differential Equations*.
+    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
+       Systems*.
+    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
+       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
+       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
+       (2015).
+    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
+       control*.
+    """
+
+
+class StochasticSolverOptions:
+    """Class of options for stochastic solvers such as
+    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
+
+    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
+    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
+    :func:`qutip.stochastic.photocurrent_sesolve` and
+    :func:`qutip.stochastic.photocurrent_mesolve`
+    all take the same keyword arguments as
+    the constructor of these class, and internally they use these arguments to
+    construct an instance of this class, so it is rarely needed to explicitly
+    create an instance of this class.
+
+    Within the attribute list, a ``time_dependent_object`` is either
+
+    - :class:`~qutip.Qobj`: a constant term
+    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
+      where the ``Qobj`` will be multiplied by the time-dependent scalar.
+
+    For more details on all allowed time-dependent objects, see the
+    documentation for :class:`~qutip.QobjEvo`.
+
+    Attributes
+    ----------
+    H : time_dependent_object or list of time_dependent_object
+        System Hamiltonian in standard time-dependent list format.  This is the
+        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
+        If this is a list of elements, they are summed.
+
+    state0 : :class:`qutip.Qobj`
+        Initial state vector (ket) or density matrix.
+
+    times : array_like of float
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of time_dependent_object
+        List of deterministic collapse operators.  Each element of the list is
+        a separate operator; unlike the Hamiltonian, there is no implicit
+        summation over the terms.
+
+    sc_ops : list of time_dependent_object
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the equation of motion according to how the d1 and d2 functions
+        are defined.  Each element of the list is a separate operator, like
+        ``c_ops``.
+
+    e_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    m_ops : list of :class:`qutip.Qobj`
+        List of operators representing the measurement operators. The expected
+        format is a nested list with one measurement operator for each
+        stochastic increament, for each stochastic collapse operator.
+
+    args : dict
+        Dictionary of parameters for time dependent systems.
+
+    tol : float
+        Tolerance of the solver for implicit methods.
+
+    ntraj : int
+        Number of trajectors.
+
+    nsubsteps : int
+        Number of sub steps between each time-spep given in `times`.
+
+    dW_factors : array
+        Array of length len(sc_ops), containing scaling factors for each
+        measurement operator in m_ops.
+
+    solver : string
+        Name of the solver method to use for solving the stochastic
+        equations. Valid values are:
+
+        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
+        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
+        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
+        - order 2 algorithms: 'taylor2.0'
+
+        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
+        for a description of the solvers.  Implicit methods can adjust
+        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
+
+    method : string ('homodyne', 'heterodyne')
+        The name of the type of measurement process that give rise to the
+        stochastic equation to solve.
+
+    store_all_expect : bool (default False)
+        Whether or not to store the e_ops expect values for all paths.
+
+    store_measurement : bool (default False)
+        Whether or not to store the measurement results in the
+        :class:`qutip.solver.Result` instance returned by the solver.
+
+    noise : int, or 1D array of int, or 4D array of float
+        - int : seed of the noise
+        - 1D array : length = ntraj, seeds for each trajectories.
+        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
+          Vector for the noise, the len of the last dimensions is doubled for
+          solvers of order 1.5. This corresponds to results.noise.
+
+    noiseDepth : int
+        Number of terms kept of the truncated series used to create the
+        noise used by taylor2.0 solver.
+
+    normalize : bool
+        (default True for (photo)ssesolve, False for (photo)smesolve)
+        Whether or not to normalize the wave function during the evolution.
+        Normalizing density matrices introduce numerical errors.
+
+    options : :class:`qutip.solver.SolverOptions`
+        Generic solver options. Only options['average_states'] and
+        options['store_states'] are used.
+
+    map_func: function
+        A map function or managing the calls to single-trajactory solvers.
+
+    map_kwargs: dictionary
+        Optional keyword arguments to the map_func function function.
+
+    progress_bar : :class:`qutip.ui.BaseProgressBar`
+        Optional progress bar class instance.
+    """
+    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
+                 e_ops=[], m_ops=None, store_all_expect=False,
+                 store_measurement=False, dW_factors=None,
+                 solver=None, method="homodyne", normalize=None,
+                 times=None, nsubsteps=1, ntraj=1, tol=None,
+                 generate_noise=None, noise=None,
+                 progress_bar=None, map_func=None, map_kwargs=None,
+                 args={}, options=None, noiseDepth=20):
+
+        if options is None:
+            options = SolverOptions()
+
+        if progress_bar is None:
+            progress_bar = TextProgressBar()
+
+        # System
+        # Cast to QobjEvo so the code has only one version for both the
+        # constant and time-dependent case.
+        self.me = me
+
+        if H is not None:
+            msg = "The Hamiltonian format is not valid. "
+            try:
+                self.H = QobjEvo(H, args=args, tlist=times)
+            except Exception as e:
+                raise ValueError(msg + str(e)) from e
+        else:
+            self.H = H
+
+        if sc_ops:
+            msg = ("The sc_ops format is not valid. Options are "
+                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
+            try:
+                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
+                               for op in sc_ops]
+            except Exception as e:
+                raise ValueError(msg + str(e)) from e
+        else:
+            self.sc_ops = sc_ops
+
+        if c_ops:
+            msg = ("The c_ops format is not valid. Options are "
+                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
+            try:
+                self.c_ops = [QobjEvo(op, args=args, tlist=times)
+                              for op in c_ops]
+            except Exception as e:
+                raise ValueError(msg + str(e)) from e
+        else:
+            self.c_ops = c_ops
+
+        self.state0 = state0
+        self.rho0 = stack_columns(state0.full()).ravel()
+
+        # Observation
+
+        for e_op in e_ops:
+            if (
+                isinstance(e_op, Qobj)
+                and self.H is not None
+                and e_op.dims[1] != self.H.dims[0]
+            ):
+                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
+                                f"with the system's ({self.H.dims})")
+        self.e_ops = e_ops
+        self.m_ops = m_ops
+        self.store_measurement = store_measurement
+        self.store_all_expect = store_all_expect
+        self.store_states = options['store_states']
+        self.dW_factors = dW_factors
+
+        # Solver
+        self.solver = solver
+        self.method = method
+        if normalize is None and me:
+            self.normalize = 0
+        elif normalize is None and not me:
+            self.normalize = 1
+        elif normalize:
+            self.normalize = 1
+        else:
+            self.normalize = 0
+
+        self.times = times
+        self.nsubsteps = nsubsteps
+        self.dt = (times[1] - times[0]) / self.nsubsteps
+        self.ntraj = ntraj
+        if tol is not None:
+            self.tol = tol
+        elif "tol" in args:
+            self.tol = args["tol"]
+        else:
+            self.tol = 1e-7
+
+        # Noise
+        if noise is not None:
+            if isinstance(noise, int):
+                # noise contain a seed
+                np.random.seed(noise)
+                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
+            noise = np.array(noise)
+            if len(noise.shape) == 1:
+                if noise.shape[0] < ntraj:
+                    raise ValueError("'noise' does not have enought seeds " +
+                                     "len(noise) >= ntraj")
+                # numpy seed must be between 0 and 2**32-1
+                # 'u4': unsigned 32bit int
+                self.noise = noise.astype("u4")
+                self.noise_type = 0
+
+            elif len(noise.shape) == 4:
+                # taylor case not included
+                dw_len = (2 if method == "heterodyne" else 1)
+                dw_len_str = (" * 2" if method == "heterodyne" else "")
+                msg = "Incorrect shape for 'noise': "
+                if noise.shape[0] < ntraj:
+                    raise ValueError(msg + "shape[0] >= ntraj")
+                if noise.shape[1] < len(times):
+                    raise ValueError(msg + "shape[1] >= len(times)")
+                if noise.shape[2] < nsubsteps:
+                    raise ValueError(msg + "shape[2] >= nsubsteps")
+                if noise.shape[3] < len(self.sc_ops) * dw_len:
+                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
+                                     dw_len_str)
+                self.noise_type = 1
+                self.noise = noise
+
+        else:
+            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
+            self.noise_type = 0
+
+        # Map
+        self.progress_bar = progress_bar
+        if self.ntraj > 1 and map_func:
+            self.map_func = map_func
+        else:
+            self.map_func = serial_map
+        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
+
+        # Other
+        self.options = options
+        self.args = args
+        self.set_solver()
+        self.p = noiseDepth
+
+    def set_solver(self):
+        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
+            self.solver_code = 50
+            self.solver = 'euler-maruyama'
+        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
+            self.solver_code = 100
+            self.solver = 'platen'
+        elif self.solver in ['pred-corr', 'predictor-corrector',
+                             'pc-euler', 101]:
+            self.solver_code = 101
+            self.solver = 'pred-corr'
+        elif self.solver in ['milstein', 102, 1.0]:
+            self.solver_code = 102
+            self.solver = 'milstein'
+        elif self.solver in ['milstein-imp', 103]:
+            self.solver_code = 103
+            self.solver = 'milstein-imp'
+        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
+            self.solver_code = 104
+            self.solver = 'pred-corr-2'
+        elif self.solver in ['Rouchon', 'rouchon', 120]:
+            self.solver_code = 120
+            self.solver = 'rouchon'
+            if not all((op.isconstant for op in self.sc_ops)):
+                raise ValueError("Rouchon only works with constant sc_ops")
+        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
+            self.solver_code = 150
+            self.solver = 'explicit1.5'
+        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
+            self.solver_code = 152
+            self.solver = 'taylor1.5'
+        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
+            self.solver_code = 153
+            self.solver = 'taylor1.5-imp'
+        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
+            self.solver_code = 202
+            self.solver = 'taylor2.0'
+            if not len(self.sc_ops) == 1 or \
+                    not self.sc_ops[0].isconstant or \
+                    not self.method == "homodyne":
+                raise ValueError(
+                    "Taylor2.0 only works with 1 constant sc_ops and for"
+                    " homodyne method"
+                )
+        else:
+            known = [
+                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
+                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
+                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
+            ]
+            raise ValueError("The solver should be one of {!r}".format(known))
+
+
+class StochasticSolverOptionsPhoto(StochasticSolverOptions):
+    """
+    Attributes
+    ----------
+
+    solver : string
+        Name of the solver method to use for solving the evolution
+        of the system.*
+        order 1 algorithms: 'euler'
+        order 2 algorithms: 'pred-corr'
+        In photocurrent evolution
+    """
+    def set_solver(self):
+        if self.solver in [None, 'euler', 1, 60]:
+            self.solver_code = 60
+            self.solver = 'euler'
+        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
+            self.solver_code = 110
+            self.solver = 'pred-corr'
+        else:
+            raise Exception("The solver should be one of " +
+                            "[None, 'euler', 'predictor-corrector']")
+
+
+def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
+             _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic master equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj`
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+    if "method" in kwargs and kwargs["method"] == "photocurrent":
+        print("stochastic solver with photocurrent method has been moved to "
+              "it's own function: photocurrent_mesolve")
+        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
+                                    e_ops=e_ops, _safe_mode=_safe_mode,
+                                    args=args, **kwargs)
+    if isket(rho0):
+        rho0 = ket2dm(rho0)
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
+                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
+                                  args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.solver_code == 120:
+        return _positive_map(sso, e_ops_dict)
+
+    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
+    if sso.method == 'homodyne' or sso.method is None:
+        if sso.m_ops is None:
+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [1] * len(sso.m_ops)
+        elif len(sso.dW_factors) != len(sso.m_ops):
+            raise Exception("The len of dW_factors is not the same as m_ops")
+
+    elif sso.method == 'heterodyne':
+        if sso.m_ops is None:
+            m_ops = []
+        sso.sops = []
+        for c in sso.sc_ops:
+            if sso.m_ops is None:
+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
+                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
+        sso.m_ops = m_ops
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
+        elif len(sso.dW_factors) == len(sso.m_ops):
+            pass
+        elif len(sso.dW_factors) == len(sso.sc_ops):
+            dW_factors = []
+            for fact in sso.dW_factors:
+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+            sso.dW_factors = dW_factors
+        elif len(sso.dW_factors) != len(sso.m_ops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == "photocurrent":
+        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
+
+    else:
+        raise Exception("The method must be one of None, homodyne, heterodyne")
+
+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+
+    if sso.solver_code in [103, 153]:
+        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
+
+    sso.solver_obj = SMESolver
+    sso.solver_name = "smesolve_" + sso.solver
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+    return res
+
+
+def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
+             _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic schrodinger equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    psi0 : :class:`qutip.Qobj`
+        State vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj`
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if "method" in kwargs and kwargs["method"] == "photocurrent":
+        print("stochastic solver with photocurrent method has been moved to "
+              "it's own function: photocurrent_sesolve")
+        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
+                                    e_ops=e_ops, _safe_mode=_safe_mode,
+                                    args=args, **kwargs)
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
+                                  sc_ops=sc_ops, e_ops=e_ops,
+                                  args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.solver_code == 120:
+        raise Exception("rouchon only work with smesolve")
+
+    if sso.method == 'homodyne' or sso.method is None:
+        if sso.m_ops is None:
+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [1] * len(sso.sops)
+        elif len(sso.dW_factors) != len(sso.sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == 'heterodyne':
+        if sso.m_ops is None:
+            m_ops = []
+        sso.sops = []
+        for c in sso.sc_ops:
+            if sso.m_ops is None:
+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+            c1 = c / np.sqrt(2)
+            c2 = c * (-1j / np.sqrt(2))
+            sso.sops += [[c1, c1 + c1.dag()],
+                         [c2, c2 + c2.dag()]]
+        sso.m_ops = m_ops
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
+        elif len(sso.dW_factors) == len(sso.sc_ops):
+            dW_factors = []
+            for fact in sso.dW_factors:
+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+            sso.dW_factors = dW_factors
+        elif len(sso.dW_factors) != len(sso.sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == "photocurrent":
+        NotImplementedError("Moved to 'photocurrent_sesolve'")
+
+    else:
+        raise Exception("The method must be one of None, homodyne, heterodyne")
+
+    sso.LH = sso.H * (-1j * sso.dt)
+    for ops in sso.sops:
+        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
+
+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+
+    sso.solver_obj = SSESolver
+    sso.solver_name = "ssesolve_" + sso.solver
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def _positive_map(sso, e_ops_dict):
+    if sso.method == 'homodyne' or sso.method is None:
+        sops = sso.sc_ops
+        if sso.m_ops is None:
+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [1] * len(sops)
+        elif len(sso.dW_factors) != len(sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == 'heterodyne':
+        if sso.m_ops is None:
+            m_ops = []
+        sops = []
+        for c in sso.sc_ops:
+            if sso.m_ops is None:
+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
+        sso.m_ops = m_ops
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [np.sqrt(2)] * len(sops)
+        elif len(sso.dW_factors) == len(sso.sc_ops):
+            dW_factors = []
+            for fact in sso.dW_factors:
+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+            sso.dW_factors = dW_factors
+        elif len(sso.dW_factors) != len(sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+    else:
+        raise Exception("The method must be one of homodyne or heterodyne")
+
+    LH = 1 - (sso.H * 1j * sso.dt)
+    sso.pp = spre(sso.H) * 0
+    sso.sops = []
+    sso.preops = []
+    sso.postops = []
+    sso.preops2 = []
+    sso.postops2 = []
+
+    def _prespostdag(op):
+        return spre(op) * spost(op.dag())
+
+    for op in sso.c_ops:
+        LH += op.dag() @ op * (-sso.dt * 0.5)
+        sso.pp += spre(op) * spost(op.dag()) * sso.dt
+
+    for i, op in enumerate(sops):
+        LH += (-sso.dt * 0.5) * op.dag() @ op
+        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
+        sso.preops += [spre(op)]
+        sso.postops += [spost(op.dag())]
+        for op2 in sops[i:]:
+            sso.preops2 += [spre(op * op2)]
+            sso.postops2 += [spost(op.dag() * op2.dag())]
+
+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+    sso.preLH = spre(LH)
+    sso.postLH = spost(LH.dag())
+
+    sso.solver_obj = PmSMESolver
+    sso.solver_name = "smesolve_" + sso.solver
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
+                         _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic master equation using the photocurrent method.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isket(rho0):
+        rho0 = ket2dm(rho0)
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
+                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
+                                       args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.m_ops is None:
+        sso.m_ops = [op * 0 for op in sso.sc_ops]
+    if not isinstance(sso.dW_factors, list):
+        sso.dW_factors = [1] * len(sso.sc_ops)
+    elif len(sso.dW_factors) != len(sso.sc_ops):
+        raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    sso.solver_obj = PcSMESolver
+    sso.solver_name = "photocurrent_mesolve"
+    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
+
+    def _prespostdag(op):
+        return spre(op) * spost(op.dag())
+
+    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
+                 spre(op.dag() @ op),
+                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
+                         _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic schrodinger equation using the photocurrent method.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = list(e_ops.values())
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
+                                       sc_ops=sc_ops, e_ops=e_ops,
+                                       args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.m_ops is None:
+        sso.m_ops = [op * 0 for op in sso.sc_ops]
+    if not isinstance(sso.dW_factors, list):
+        sso.dW_factors = [1] * len(sso.sc_ops)
+    elif len(sso.dW_factors) != len(sso.sc_ops):
+        raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    sso.solver_obj = PcSSESolver
+    sso.solver_name = "photocurrent_sesolve"
+    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
+    sso.LH = sso.H * (-1j*sso.dt)
+    for ops in sso.sops:
+        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
+                       _safe_mode=True, len_d2=1, args={}, **kwargs):
+    """
+    Solve stochastic general equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+
+    Parameters
+    ----------
+
+    state0 : :class:`qutip.Qobj`
+        Initial state vector (ket) or density matrix as a vector.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    d1 : function, callable class
+        Function representing the deterministic evolution of the system.
+
+        def d1(time (double), state (as a np.array vector)):
+            return 1d np.array
+
+    d2 : function, callable class
+        Function representing the stochastic evolution of the system.
+
+        def d2(time (double), state (as a np.array vector)):
+            return 2d np.array (N_sc_ops, len(state0))
+
+    len_d2 : int
+        Number of output vector produced by d2
+
+    e_ops : list of :class:`qutip.Qobj`
+        single operator or list of operators for which to evaluate
+        expectation values.
+        Must be a superoperator if the state vector is a density matrix.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    if "solver" not in kwargs:
+        kwargs["solver"] = 50
+
+    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
+                                  e_ops=e_ops, args=args, **kwargs)
+    if sso.solver_code not in [50, 100, 150]:
+        raise ValueError("Only Euler, platen, platen15 can be " +
+                         "used for the general stochastic solver.")
+
+    sso.d1 = d1
+    sso.d2 = d2
+    if _safe_mode:
+        # This state0_vec is computed as stack_columns(state0.full()).ravel()
+        # in the sso init.
+        state0_vec = sso.rho0
+        l_vec = state0_vec.shape[0]
+        try:
+            out_d1 = d1(0., sso.rho0)
+        except Exception as e:
+            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
+                               str(e)) from e
+        try:
+            out_d2 = d2(0., sso.rho0)
+        except Exception as e:
+            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
+                               str(e)) from e
+
+        msg_d1 = ("d1 must return an 1d numpy array with the same number "
+                  "of elements as the initial state as a vector.")
+        if not isinstance(out_d1, np.ndarray):
+            raise TypeError(msg_d1)
+        if (out_d1.ndim != 1
+                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
+            raise ValueError(msg_d1)
+
+        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
+                  "with the shape (len_d2, len(state0_vec) ).")
+        if not isinstance(out_d2, np.ndarray):
+            raise TypeError(msg_d2)
+        if (out_d2.ndim != 2
+                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
+            raise ValueError(msg_d2)
+        if out_d1.dtype != np.dtype('complex128') or \
+           out_d2.dtype != np.dtype('complex128'):
+            raise ValueError("Safety check: d1 and d2 must return " +
+                             "complex numpy array.")
+        msg_e_ops = ("Safety check: The shape of the e_ops "
+                     "does not fit the intial state.")
+        for op in sso.e_ops:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise ValueError(msg_e_ops)
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise ValueError(msg_e_ops +
+                                     " Expecting e_ops as superoperators.")
+
+    sso.m_ops = []
+    sso.cm_ops = []
+    if sso.store_measurement:
+        if not m_ops:
+            raise ValueError("General stochastic needs explicit " +
+                             "m_ops to store measurement.")
+        sso.m_ops = m_ops
+        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+        if sso.dW_factors is None:
+            sso.dW_factors = [1.] * len(sso.m_ops)
+        elif len(sso.dW_factors) == 1:
+            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
+        elif len(sso.dW_factors) != len(sso.m_ops):
+            raise ValueError("The number of dW_factors must fit" +
+                             " the number of m_ops.")
+
+    if sso.dW_factors is None:
+        sso.dW_factors = [1.] * len_d2
+    sso.sops = [None] * len_d2
+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+
+    sso.solver_obj = GenericSSolver
+    sso.solver_name = "general_stochastic_solver_" + sso.solver
+
+    ssolver = GenericSSolver()
+    # ssolver.set_data(sso)
+    ssolver.set_solver(sso)
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def _safety_checks(sso):
+    l_vec = sso.rho0.shape[0]
+    if sso.H.issuper:
+        if not sso.me:
+            raise ValueError(
+                "Given a Liouvillian for a Schrödinger equation problem."
+            )
+        shape_op = sso.H.shape
+        if shape_op[0] != l_vec or shape_op[1] != l_vec:
+            raise Exception("The size of the hamiltonian does "
+                            "not fit the intial state")
+    else:
+        shape_op = sso.H.shape
+        if sso.me:
+            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                raise Exception("The size of the hamiltonian does "
+                                "not fit the intial state")
+        else:
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the hamiltonian does "
+                                "not fit the intial state")
+
+    for op in sso.sc_ops:
+        if op.issuper:
+            if not sso.me:
+                raise ValueError(
+                    "Given a Liouvillian for a Schrödinger equation problem."
+                )
+            shape_op = op.shape
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the sc_ops does "
+                                "not fit the intial state")
+        else:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise Exception("The size of the sc_ops does "
+                                    "not fit the intial state")
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise Exception("The size of the sc_ops does "
+                                    "not fit the intial state")
+
+    for op in sso.c_ops:
+        if op.issuper:
+            if not sso.me:
+                raise ValueError(
+                    "Given a Liouvillian for a Schrödinger equation problem."
+                )
+            shape_op = op.shape
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the c_ops does "
+                                "not fit the intial state")
+        else:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise Exception("The size of the c_ops does "
+                                    "not fit the intial state")
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise Exception("The size of the c_ops does "
+                                    "not fit the intial state")
+
+    for op in sso.e_ops:
+        shape_op = op.shape
+        if sso.me:
+            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                raise Exception("The size of the e_ops does "
+                                "not fit the intial state")
+        else:
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the e_ops does "
+                                "not fit the intial state")
+
+    if sso.m_ops is not None:
+        for op in sso.m_ops:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise Exception("The size of the m_ops does "
+                                    "not fit the intial state")
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise Exception("The size of the m_ops does "
+                                    "not fit the intial state")
+
+
+def _sesolve_generic(sso, options, progress_bar):
+    """
+    Internal function. See smesolve.
+    """
+    res = Result()
+    res.times = sso.times
+    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
+    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
+    res.measurement = []
+    res.solver = sso.solver_name
+    res.ntraj = sso.ntraj
+    res.num_expect = len(sso.e_ops)
+
+    nt = sso.ntraj
+    task = _single_trajectory
+    map_kwargs = {'progress_bar': sso.progress_bar}
+    map_kwargs.update(sso.map_kwargs)
+    task_args = (sso,)
+    task_kwargs = {}
+
+    results = sso.map_func(task, list(range(sso.ntraj)),
+                           task_args, task_kwargs, **map_kwargs)
+    noise = []
+    for result in results:
+        states_list, dW, m, expect = result
+        res.states.append(states_list)
+        noise.append(dW)
+        res.measurement.append(m)
+        res.expect += expect
+        res.ss += expect * expect
+    res.noise = np.stack(noise)
+
+    if sso.store_all_expect:
+        paths_expect = []
+        for result in results:
+            paths_expect.append(result[3])
+        res.runs_expect = np.stack(paths_expect)
+
+    # average density matrices (vectorized maybe)
+    # ajgpitch 2019-10-25: np.any(res.states) seems to error
+    # I guess there may be a potential exception if there are no states?
+    # store individual trajectory states
+    res.traj_states = res.states
+    res.avg_states = None
+    if options['average_states'] and options['store_states']:
+        avg_states_list = []
+        for n in range(len(res.times)):
+            tslot_states = [res.states[mm][n].data for mm in range(nt)]
+            if len(tslot_states) > 0:
+                state = Qobj(np.sum(tslot_states),
+                             dims=res.states[0][n].dims).unit()
+                avg_states_list.append(state)
+        # store average states
+        res.states = res.avg_states = avg_states_list
+
+    # average
+    res.expect = res.expect / nt
+
+    # standard error
+    if nt > 1:
+        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
+    else:
+        res.se = None
+
+    # convert complex data to real if hermitian
+    res.expect = [np.real(res.expect[n, :])
+                  if e.isherm else res.expect[n, :]
+                  for n, e in enumerate(sso.e_ops)]
+
+    return res
+
+
+def _single_trajectory(i, sso):
+    # Only one step?
+    ssolver = sso.solver_obj()
+    ssolver.set_solver(sso)
+    result = ssolver.cy_sesolve_single_trajectory(i)
+    return result
+
+
+# The code for ssepdpsolve have been moved to the file pdpsolve.
+# The call is still in stochastic for consistance.
+def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for wavefunction
+    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
+    trajectory simulations.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
+
+
+# The code for smepdpsolve have been moved to the file pdpsolve.
+# The call is still in stochastic for consistance.
+def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for density matrix
+    evolution.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    sc_ops : list of :class:`qutip.Qobj`
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
index 99d84ccd88..0512198f45 100644
--- a/qutip/solver/__init__.py
+++ b/qutip/solver/__init__.py
@@ -1,18 +1,18 @@
-from .result import *
-from .options import *
-import qutip.solver.integrator
-from .integrator import IntegratorException
-from .sesolve import *
-from .mesolve import *
-from .mcsolve import *
-from .propagator import *
-from .scattering import *
-from .correlation import *
-from .spectrum import *
-from .floquet import *
-from .floquet_bwcomp import *
-from .steadystate import *
-from .countstat import *
-from .brmesolve import *
-from .krylovsolve import *
-from .parallel import *
+from .result import *
+from .options import *
+import qutip.solver.integrator
+from .integrator import IntegratorException
+from .sesolve import *
+from .mesolve import *
+from .mcsolve import *
+from .propagator import *
+from .scattering import *
+from .correlation import *
+from .spectrum import *
+from .floquet import *
+from .floquet_bwcomp import *
+from .steadystate import *
+from .countstat import *
+from .brmesolve import *
+from .krylovsolve import *
+from .parallel import *
diff --git a/qutip/solver/brmesolve.py b/qutip/solver/brmesolve.py
index 7bfc8b27ad..8da774942d 100644
--- a/qutip/solver/brmesolve.py
+++ b/qutip/solver/brmesolve.py
@@ -1,362 +1,362 @@
-"""
-This module provides solvers for the Lindblad master equation and von Neumann
-equation.
-"""
-
-__all__ = ['brmesolve', 'BRSolver']
-
-import numpy as np
-import inspect
-from time import time
-from .. import Qobj, QobjEvo, coefficient, Coefficient
-from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
-from ..core.cy.coefficient import InterCoefficient
-from ..core import data as _data
-from .solver_base import Solver
-from .options import _SolverOptions
-
-
-def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
-              args={}, sec_cutoff=0.1, options=None):
-    """
-    Solves for the dynamics of a system using the Bloch-Redfield master
-    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
-    their associated spectral functions, as well as possible Lindblad collapse
-    operators.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    psi0: Qobj
-        Initial density matrix or state vector (ket).
-
-    tlist : array_like
-        List of times for evaluating evolution
-
-    a_ops : list of (a_op, spectra)
-        Nested list of system operators that couple to the environment,
-        and the corresponding bath spectra.
-
-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-            The operator coupling to the environment. Must be hermitian.
-
-        spectra : :class:`Coefficient`, str, func
-            The corresponding bath spectral responce.
-            Can be a `Coefficient` using an 'w' args, a function of the
-            frequence or a string. Coefficient build from a numpy array are
-            understood as a function of ``w`` instead of ``t``. Function are
-            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
-
-            The spectra function can depend on ``t`` if the corresponding
-            ``a_op`` is a :class:`QobjEvo`.
-
-        Example:
-
-        .. code-block::
-
-            a_ops = [
-                (a+a.dag(), ('w>0', args={"w": 0})),
-                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
-                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-            ]
-
-        .. note:
-            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
-                ``spline = qutip.coefficient(array, tlist=times)``
-
-            Whether the ``a_ops`` is time dependent is decided by the type of
-            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
-            of the spectra.
-
-    e_ops : list of :class:`Qobj` / callback function
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation
-
-    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
-        List of collapse operators.
-
-    args : dict
-        Dictionary of parameters for time-dependent Hamiltonians and
-        collapse operators. The key ``w`` is reserved for the spectra function.
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - tensor_type : str ['sparse', 'dense', 'data']
-          Which data type to use when computing the brtensor.
-          With a cutoff 'sparse' is usually the most efficient.
-        - sparse_eigensolver : bool {False}
-          Whether to use the sparse eigensolver
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`, which contains
-        either an array of expectation values, for operators given in e_ops,
-        or a list of states for the times specified by `tlist`.
-
-    .. note:
-        The option ``operator_data_type`` is used to determine in which format
-        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
-        for dense array. With 'data', it will try to use the same data type as
-        the ``a_ops``, but it is usually less efficient than manually choosing
-        it.
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-
-    c_ops = c_ops if c_ops is not None else []
-    if not isinstance(c_ops, (list, tuple)):
-        c_ops = [c_ops]
-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-
-    new_a_ops = []
-    for (a_op, spectra) in a_ops:
-        aop = QobjEvo(a_op, args=args, tlist=tlist)
-        if isinstance(spectra, str):
-            new_a_ops.append(
-                (aop, coefficient(spectra, args={**args, 'w':0})))
-        elif isinstance(spectra, InterCoefficient):
-            new_a_ops.append((aop, SpectraCoefficient(spectra)))
-        elif isinstance(spectra, Coefficient):
-            new_a_ops.append((aop, spectra))
-        elif callable(spectra):
-            sig = inspect.signature(spectra)
-            if tuple(sig.parameters.keys()) == ("w",):
-                spec = SpectraCoefficient(coefficient(spectra))
-            else:
-                spec = coefficient(spectra, args={**args, 'w':0})
-            new_a_ops.append((aop, spec))
-        else:
-            raise TypeError("a_ops's spectra not known")
-
-    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
-
-    return solver.run(psi0, tlist, e_ops=e_ops)
-
-
-class BRSolver(Solver):
-    """
-    Bloch Redfield equation evolution of a density matrix for a given
-    Hamiltonian and set of bath coupling operators.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    a_ops : list of (a_op, spectra)
-        Nested list of system operators that couple to the environment,
-        and the corresponding bath spectra.
-
-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-            The operator coupling to the environment. Must be hermitian.
-
-        spectra : :class:`Coefficient`
-            The corresponding bath spectra. As a `Coefficient` using an 'w'
-            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
-            :class:`SpectraCoefficient` can be used to conver a coefficient
-            depending on ``t`` to one depending on ``w``.
-
-        Example:
-
-        .. code-block::
-
-            a_ops = [
-                (a+a.dag(), coefficient('w>0', args={'w':0})),
-                (QobjEvo([b+b.dag(), lambda t: ...]),
-                 coefficient(lambda t, w: ...), args={"w": 0}),
-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-            ]
-
-    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
-        Single collapse operator, or list of collapse operators, or a list
-        of Lindblad dissipator. None is equivalent to an empty list.
-
-    options : dict, optional
-        Options for the solver, see :obj:`BRSolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    attributes
-    ----------
-    stats: dict
-        Diverse diagnostic statistics of the evolution.
-    """
-    name = "brmesolve"
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size":10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": False,
-        'method': 'adams',
-        'tensor_type': 'sparse',
-        'sparse_eigensolver': False,
-    }
-    _avail_integrators = {}
-
-    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
-        _time_start = time()
-
-        self.rhs = None
-        self.sec_cutoff = sec_cutoff
-        self.options = options
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-        H = QobjEvo(H)
-
-        c_ops = c_ops or []
-        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
-        for c_op in c_ops:
-            if not isinstance(c_op, (Qobj, QobjEvo)):
-                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
-
-        a_ops = a_ops or []
-        if not hasattr(a_ops, "__iter__"):
-            TypeError("`a_ops` must be a list of (operator, spectra)")
-        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
-            a_ops = [a_ops]
-        for oper, spectra in a_ops:
-            if not isinstance(oper, (Qobj, QobjEvo)):
-                raise TypeError("All `a_ops` operators "
-                                "must be a Qobj or QobjEvo")
-            if not isinstance(spectra, Coefficient):
-                raise TypeError("All `a_ops` spectra "
-                                "must be a Coefficient.")
-
-        self._system = H, a_ops, c_ops
-        self._num_collapse = len(c_ops)
-        self._num_a_ops = len(a_ops)
-        self.rhs = self._prepare_rhs()
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "solver": "Bloch Redfield Equation Evolution",
-            "init time": stats["init time"] + self._init_rhs_time,
-            "num_collapse": self._num_collapse,
-            "num_a_ops": self._num_a_ops,
-        })
-        return stats
-
-    def _prepare_rhs(self):
-        _time_start = time()
-        rhs = bloch_redfield_tensor(
-            *self._system,
-            fock_basis=True,
-            sec_cutoff=self.sec_cutoff,
-            sparse_eigensolver=self.options['sparse_eigensolver'],
-            br_dtype=self.options['tensor_type']
-        )
-        self._init_rhs_time = time() - _time_start
-        return rhs
-
-    @property
-    def options(self):
-        """
-        Options for bloch redfield solver:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        normalize_output: bool, default=False
-            Normalize output state to hide ODE numerical errors.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error if
-            not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size":10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
-            Which data type to use when computing the brtensor.
-            With a cutoff 'sparse' is usually the most efficient.
-
-        sparse_eigensolver: bool, default=False
-            Whether to use the sparse eigensolver
-
-        method: str, default="adams"
-            Which ODE integrator methods are supported.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Solver.options.fset(self, new_options)
-
-    def _apply_options(self, keys):
-        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
-        need_new_rhs &= (
-            'sparse_eigensolver' in keys or 'tensor_type' in keys
-        )
-        if need_new_rhs:
-            self.rhs = self._prepare_rhs()
-
-        if self._integrator is None or not keys:
-            pass
-        elif 'method' in keys or need_new_rhs:
-            state = self._integrator.get_state()
-            self._integrator = self._get_integrator()
-            self._integrator.set_state(*state)
-        else:
-            self._integrator.options = self._options
-            self._integrator.reset(hard=True)
+"""
+This module provides solvers for the Lindblad master equation and von Neumann
+equation.
+"""
+
+__all__ = ['brmesolve', 'BRSolver']
+
+import numpy as np
+import inspect
+from time import time
+from .. import Qobj, QobjEvo, coefficient, Coefficient
+from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
+from ..core.cy.coefficient import InterCoefficient
+from ..core import data as _data
+from .solver_base import Solver
+from .options import _SolverOptions
+
+
+def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
+              args={}, sec_cutoff=0.1, options=None):
+    """
+    Solves for the dynamics of a system using the Bloch-Redfield master
+    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
+    their associated spectral functions, as well as possible Lindblad collapse
+    operators.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    psi0: Qobj
+        Initial density matrix or state vector (ket).
+
+    tlist : array_like
+        List of times for evaluating evolution
+
+    a_ops : list of (a_op, spectra)
+        Nested list of system operators that couple to the environment,
+        and the corresponding bath spectra.
+
+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+            The operator coupling to the environment. Must be hermitian.
+
+        spectra : :class:`Coefficient`, str, func
+            The corresponding bath spectral responce.
+            Can be a `Coefficient` using an 'w' args, a function of the
+            frequence or a string. Coefficient build from a numpy array are
+            understood as a function of ``w`` instead of ``t``. Function are
+            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
+
+            The spectra function can depend on ``t`` if the corresponding
+            ``a_op`` is a :class:`QobjEvo`.
+
+        Example:
+
+        .. code-block::
+
+            a_ops = [
+                (a+a.dag(), ('w>0', args={"w": 0})),
+                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
+                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+            ]
+
+        .. note:
+            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
+                ``spline = qutip.coefficient(array, tlist=times)``
+
+            Whether the ``a_ops`` is time dependent is decided by the type of
+            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
+            of the spectra.
+
+    e_ops : list of :class:`Qobj` / callback function
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation
+
+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        List of collapse operators.
+
+    args : dict
+        Dictionary of parameters for time-dependent Hamiltonians and
+        collapse operators. The key ``w`` is reserved for the spectra function.
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - tensor_type : str ['sparse', 'dense', 'data']
+          Which data type to use when computing the brtensor.
+          With a cutoff 'sparse' is usually the most efficient.
+        - sparse_eigensolver : bool {False}
+          Whether to use the sparse eigensolver
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`, which contains
+        either an array of expectation values, for operators given in e_ops,
+        or a list of states for the times specified by `tlist`.
+
+    .. note:
+        The option ``operator_data_type`` is used to determine in which format
+        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
+        for dense array. With 'data', it will try to use the same data type as
+        the ``a_ops``, but it is usually less efficient than manually choosing
+        it.
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+
+    c_ops = c_ops if c_ops is not None else []
+    if not isinstance(c_ops, (list, tuple)):
+        c_ops = [c_ops]
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+
+    new_a_ops = []
+    for (a_op, spectra) in a_ops:
+        aop = QobjEvo(a_op, args=args, tlist=tlist)
+        if isinstance(spectra, str):
+            new_a_ops.append(
+                (aop, coefficient(spectra, args={**args, 'w':0})))
+        elif isinstance(spectra, InterCoefficient):
+            new_a_ops.append((aop, SpectraCoefficient(spectra)))
+        elif isinstance(spectra, Coefficient):
+            new_a_ops.append((aop, spectra))
+        elif callable(spectra):
+            sig = inspect.signature(spectra)
+            if tuple(sig.parameters.keys()) == ("w",):
+                spec = SpectraCoefficient(coefficient(spectra))
+            else:
+                spec = coefficient(spectra, args={**args, 'w':0})
+            new_a_ops.append((aop, spec))
+        else:
+            raise TypeError("a_ops's spectra not known")
+
+    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
+
+    return solver.run(psi0, tlist, e_ops=e_ops)
+
+
+class BRSolver(Solver):
+    """
+    Bloch Redfield equation evolution of a density matrix for a given
+    Hamiltonian and set of bath coupling operators.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    a_ops : list of (a_op, spectra)
+        Nested list of system operators that couple to the environment,
+        and the corresponding bath spectra.
+
+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+            The operator coupling to the environment. Must be hermitian.
+
+        spectra : :class:`Coefficient`
+            The corresponding bath spectra. As a `Coefficient` using an 'w'
+            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
+            :class:`SpectraCoefficient` can be used to conver a coefficient
+            depending on ``t`` to one depending on ``w``.
+
+        Example:
+
+        .. code-block::
+
+            a_ops = [
+                (a+a.dag(), coefficient('w>0', args={'w':0})),
+                (QobjEvo([b+b.dag(), lambda t: ...]),
+                 coefficient(lambda t, w: ...), args={"w": 0}),
+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+            ]
+
+    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
+        Single collapse operator, or list of collapse operators, or a list
+        of Lindblad dissipator. None is equivalent to an empty list.
+
+    options : dict, optional
+        Options for the solver, see :obj:`BRSolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    attributes
+    ----------
+    stats: dict
+        Diverse diagnostic statistics of the evolution.
+    """
+    name = "brmesolve"
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size":10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": False,
+        'method': 'adams',
+        'tensor_type': 'sparse',
+        'sparse_eigensolver': False,
+    }
+    _avail_integrators = {}
+
+    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
+        _time_start = time()
+
+        self.rhs = None
+        self.sec_cutoff = sec_cutoff
+        self.options = options
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+        H = QobjEvo(H)
+
+        c_ops = c_ops or []
+        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
+        for c_op in c_ops:
+            if not isinstance(c_op, (Qobj, QobjEvo)):
+                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
+
+        a_ops = a_ops or []
+        if not hasattr(a_ops, "__iter__"):
+            TypeError("`a_ops` must be a list of (operator, spectra)")
+        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
+            a_ops = [a_ops]
+        for oper, spectra in a_ops:
+            if not isinstance(oper, (Qobj, QobjEvo)):
+                raise TypeError("All `a_ops` operators "
+                                "must be a Qobj or QobjEvo")
+            if not isinstance(spectra, Coefficient):
+                raise TypeError("All `a_ops` spectra "
+                                "must be a Coefficient.")
+
+        self._system = H, a_ops, c_ops
+        self._num_collapse = len(c_ops)
+        self._num_a_ops = len(a_ops)
+        self.rhs = self._prepare_rhs()
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "solver": "Bloch Redfield Equation Evolution",
+            "init time": stats["init time"] + self._init_rhs_time,
+            "num_collapse": self._num_collapse,
+            "num_a_ops": self._num_a_ops,
+        })
+        return stats
+
+    def _prepare_rhs(self):
+        _time_start = time()
+        rhs = bloch_redfield_tensor(
+            *self._system,
+            fock_basis=True,
+            sec_cutoff=self.sec_cutoff,
+            sparse_eigensolver=self.options['sparse_eigensolver'],
+            br_dtype=self.options['tensor_type']
+        )
+        self._init_rhs_time = time() - _time_start
+        return rhs
+
+    @property
+    def options(self):
+        """
+        Options for bloch redfield solver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        normalize_output: bool, default=False
+            Normalize output state to hide ODE numerical errors.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error if
+            not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size":10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
+            Which data type to use when computing the brtensor.
+            With a cutoff 'sparse' is usually the most efficient.
+
+        sparse_eigensolver: bool, default=False
+            Whether to use the sparse eigensolver
+
+        method: str, default="adams"
+            Which ODE integrator methods are supported.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Solver.options.fset(self, new_options)
+
+    def _apply_options(self, keys):
+        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
+        need_new_rhs &= (
+            'sparse_eigensolver' in keys or 'tensor_type' in keys
+        )
+        if need_new_rhs:
+            self.rhs = self._prepare_rhs()
+
+        if self._integrator is None or not keys:
+            pass
+        elif 'method' in keys or need_new_rhs:
+            state = self._integrator.get_state()
+            self._integrator = self._get_integrator()
+            self._integrator.set_state(*state)
+        else:
+            self._integrator.options = self._options
+            self._integrator.reset(hard=True)
diff --git a/qutip/solver/correlation.py b/qutip/solver/correlation.py
index b05514c519..e3be789f54 100644
--- a/qutip/solver/correlation.py
+++ b/qutip/solver/correlation.py
@@ -1,517 +1,517 @@
-__all__ = [
-    'correlation_3op',
-    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
-    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
-]
-
-import numpy as np
-import scipy.fftpack
-
-from ..core import (
-    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
-    tensor, qzero, expect
-)
-from .mesolve import MESolver
-from .mcsolve import MCSolver
-from .brmesolve import BRSolver
-from .heom.bofin_solvers import HEOMSolver
-
-from .steadystate import steadystate
-from ..ui.progressbar import progess_bars
-
-# -----------------------------------------------------------------------------
-# PUBLIC API
-# -----------------------------------------------------------------------------
-
-# low level correlation
-
-
-def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
-                       solver="me", reverse=False, args={},
-                       options={}):
-    r"""
-    Calculate the two-operator one-time correlation function:
-    :math:`\left<A(\tau)B(0)\right>`
-    along one time axis using the quantum regression theorem and the evolution
-    solver indicated by the `solver` parameter.
-
-    Parameters
-    ----------
-
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    reverse : bool {False}
-        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
-        :math:`\left<A(t+\tau)B(t)\right>`.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_vec : ndarray
-        An array of correlation values for the times specified by `taulist`.
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    if reverse:
-        A_op, B_op, C_op = a_op, b_op, 1
-    else:
-        A_op, B_op, C_op = 1, a_op, b_op
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-
-    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
-
-
-def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
-                       solver="me", reverse=False, args={},
-                       options={}):
-    r"""
-    Calculate the two-operator two-time correlation function:
-    :math:`\left<A(t+\tau)B(t)\right>`
-    along two time axes using the quantum regression theorem and the
-    evolution solver indicated by the ``solver`` parameter.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    tlist : array_like
-        List of times for :math:`t`. tlist must be positive and contain the
-        element `0`. When taking steady-steady correlations only one ``tlist``
-        value is necessary, i.e. when :math:`t \rightarrow \infty`.
-        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    reverse : bool {False}
-        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
-        :math:`\left<A(t+\tau)B(t)\right>`.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_mat : ndarray
-        An 2-dimensional array (matrix) of correlation values for the times
-        specified by `tlist` (first index) and `taulist` (second index).
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-    if tlist is None:
-        tlist = [0]
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-
-    if reverse:
-        A_op, B_op, C_op = a_op, b_op, 1
-    else:
-        A_op, B_op, C_op = 1, a_op, b_op
-
-    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
-
-
-def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
-                       solver="me", args={},
-                       options={}):
-    r"""
-    Calculate the three-operator two-time correlation function:
-    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
-    quantum regression theorem and the evolution solver indicated by the
-    `solver` parameter.
-
-    Note: it is not possibly to calculate a physically meaningful correlation
-    of this form where :math:`\tau<0`.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    c_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator C.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_vec : array
-        An array of correlation values for the times specified by `taulist`.
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
-
-
-def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
-                       solver="me", args={},
-                       options={}):
-    r"""
-    Calculate the three-operator two-time correlation function:
-    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
-    quantum regression theorem and the evolution solver indicated by the
-    `solver` parameter.
-
-    Note: it is not possibly to calculate a physically meaningful correlation
-    of this form where :math:`\tau<0`.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    tlist : array_like
-        List of times for :math:`t`. tlist must be positive and contain the
-        element `0`. When taking steady-steady correlations only one tlist
-        value is necessary, i.e. when :math:`t \rightarrow \infty`.
-        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    c_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator C.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_mat : array
-        An 2-dimensional array (matrix) of correlation values for the times
-        specified by `tlist` (first index) and `taulist` (second index).
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    if tlist is None:
-        tlist = [0]
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-
-    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
-
-
-# high level correlation
-
-def coherence_function_g1(
-    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
-):
-    r"""
-    Calculate the normalized first-order quantum coherence function:
-
-    .. math::
-
-        g^{(1)}(\tau) =
-        \frac{\langle A^\dagger(\tau)A(0)\rangle}
-        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
-                \langle A^\dagger(0)A(0)\rangle}}
-
-    using the quantum regression theorem and the evolution solver indicated by
-    the `solver` parameter.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    g1, G1 : tuple
-        The normalized and unnormalized second-order coherence function.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    # first calculate the photon number
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-        n = np.array([expect(state0, a_op.dag() * a_op)])
-    else:
-        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
-
-    # calculate the correlation function G1 and normalize with n to obtain g1
-    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
-
-    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
-    return g1, G1
-
-
-def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
-                          args={}, options={}):
-    r"""
-    Calculate the normalized second-order quantum coherence function:
-
-    .. math::
-
-         g^{(2)}(\tau) =
-        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
-        {\langle A^\dagger(\tau)A(\tau)\rangle
-         \langle A^\dagger(0)A(0)\rangle}
-
-    using the quantum regression theorem and the evolution solver indicated by
-    the `solver` parameter.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list
-        List of collapse operators, may be time-dependent for solver choice of
-        `me`.
-    a_op : :class:`Qobj`
-        Operator A.
-    args : dict
-        Dictionary of arguments to be passed to solver.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    g2, G2 : tuple
-        The normalized and unnormalized second-order coherence function.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    # first calculate the photon number
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-        n = np.array([expect(state0, a_op.dag() * a_op)])
-    else:
-        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
-
-    # calculate the correlation function G2 and normalize with n to obtain g2
-    G2 = correlation_3op(solver, state0, [0], taulist,
-                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
-
-    g2 = G2 / (n[0] * np.array(n))
-    return g2, G2
-
-
-def _make_solver(H, c_ops, args, options, solver):
-    H = QobjEvo(H, args=args)
-    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
-    if solver == "me":
-        solver_instance = MESolver(H, c_ops, options=options)
-    elif solver == "es":
-        options = {"method": "diag"}
-        solver_instance = MESolver(H, c_ops, options=options)
-    elif solver == "mc":
-        raise ValueError("MC solver for correlation has been removed")
-    return solver_instance
-
-
-def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
-    r"""
-    Calculate the three-operator two-time correlation function:
-
-        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
-
-    from a open system :class:`Solver`.
-
-    Note: it is not possible to calculate a physically meaningful correlation
-    where :math:`\tau<0`.
-
-    Parameters
-    ----------
-    solver : :class:`MESolver`, :class:`BRSolver`
-        Qutip solver for an open system.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`.
-    tlist : array_like
-        List of times for :math:`t`. tlist must be positive and contain the
-        element `0`.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
-        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
-        in the Schrodinger picture. They do not need to be all provided. For
-        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
-
-    Returns
-    -------
-    corr_mat : array
-        An 2-dimensional array (matrix) of correlation values for the times
-        specified by `tlist` (first index) and `taulist` (second index). If
-        `tlist` is `None`, then a 1-dimensional array of correlation values
-        is returned instead.
-    """
-    taulist = np.asarray(taulist)
-
-    dims = state0.dims[0]
-    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
-    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
-    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
-
-    if isinstance(solver, (MESolver, BRSolver)):
-        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
-    elif isinstance(solver, MCSolver):
-        raise TypeError("Monte Carlo support for correlation was removed. "
-                        "Please, tell us on GitHub issues if you need it!")
-    elif isinstance(solver, HEOMSolver):
-        raise TypeError("HEOM is not supported by correlation. "
-                        "Please, tell us on GitHub issues if you need it!")
-    else:
-        raise TypeError("Only solvers able to evolve density matrices"
-                        " are supported.")
-
-    return out
-
-
-def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
-    old_opt = solver.options.copy()
-    try:
-        # We don't want to modify the solver
-        # TODO: Solver could have a ``with`` or ``copy``.
-        solver.options["normalize_output"] = False
-        solver.options["progress_bar"] = False
-
-        progress_bar = progess_bars[old_opt['progress_bar']]()
-        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
-        rho_t = solver.run(state0, tlist).states
-        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
-        progress_bar.update()
-
-        for t_idx, rho in enumerate(rho_t):
-            t = tlist[t_idx]
-            corr_mat[t_idx, :] = solver.run(
-                C(t) @ rho @ A(t),
-                taulist + t,
-                e_ops=B
-            ).expect[0]
-            progress_bar.update()
-        progress_bar.finished()
-
-    finally:
-        solver.options = old_opt
-
-    return corr_mat
+__all__ = [
+    'correlation_3op',
+    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
+    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
+]
+
+import numpy as np
+import scipy.fftpack
+
+from ..core import (
+    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
+    tensor, qzero, expect
+)
+from .mesolve import MESolver
+from .mcsolve import MCSolver
+from .brmesolve import BRSolver
+from .heom.bofin_solvers import HEOMSolver
+
+from .steadystate import steadystate
+from ..ui.progressbar import progess_bars
+
+# -----------------------------------------------------------------------------
+# PUBLIC API
+# -----------------------------------------------------------------------------
+
+# low level correlation
+
+
+def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
+                       solver="me", reverse=False, args={},
+                       options={}):
+    r"""
+    Calculate the two-operator one-time correlation function:
+    :math:`\left<A(\tau)B(0)\right>`
+    along one time axis using the quantum regression theorem and the evolution
+    solver indicated by the `solver` parameter.
+
+    Parameters
+    ----------
+
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    reverse : bool {False}
+        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
+        :math:`\left<A(t+\tau)B(t)\right>`.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_vec : ndarray
+        An array of correlation values for the times specified by `taulist`.
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    if reverse:
+        A_op, B_op, C_op = a_op, b_op, 1
+    else:
+        A_op, B_op, C_op = 1, a_op, b_op
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+
+    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
+
+
+def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
+                       solver="me", reverse=False, args={},
+                       options={}):
+    r"""
+    Calculate the two-operator two-time correlation function:
+    :math:`\left<A(t+\tau)B(t)\right>`
+    along two time axes using the quantum regression theorem and the
+    evolution solver indicated by the ``solver`` parameter.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    tlist : array_like
+        List of times for :math:`t`. tlist must be positive and contain the
+        element `0`. When taking steady-steady correlations only one ``tlist``
+        value is necessary, i.e. when :math:`t \rightarrow \infty`.
+        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    reverse : bool {False}
+        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
+        :math:`\left<A(t+\tau)B(t)\right>`.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_mat : ndarray
+        An 2-dimensional array (matrix) of correlation values for the times
+        specified by `tlist` (first index) and `taulist` (second index).
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+    if tlist is None:
+        tlist = [0]
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+
+    if reverse:
+        A_op, B_op, C_op = a_op, b_op, 1
+    else:
+        A_op, B_op, C_op = 1, a_op, b_op
+
+    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
+
+
+def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
+                       solver="me", args={},
+                       options={}):
+    r"""
+    Calculate the three-operator two-time correlation function:
+    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
+    quantum regression theorem and the evolution solver indicated by the
+    `solver` parameter.
+
+    Note: it is not possibly to calculate a physically meaningful correlation
+    of this form where :math:`\tau<0`.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    c_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator C.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_vec : array
+        An array of correlation values for the times specified by `taulist`.
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
+
+
+def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
+                       solver="me", args={},
+                       options={}):
+    r"""
+    Calculate the three-operator two-time correlation function:
+    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
+    quantum regression theorem and the evolution solver indicated by the
+    `solver` parameter.
+
+    Note: it is not possibly to calculate a physically meaningful correlation
+    of this form where :math:`\tau<0`.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    tlist : array_like
+        List of times for :math:`t`. tlist must be positive and contain the
+        element `0`. When taking steady-steady correlations only one tlist
+        value is necessary, i.e. when :math:`t \rightarrow \infty`.
+        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    c_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator C.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_mat : array
+        An 2-dimensional array (matrix) of correlation values for the times
+        specified by `tlist` (first index) and `taulist` (second index).
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    if tlist is None:
+        tlist = [0]
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+
+    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
+
+
+# high level correlation
+
+def coherence_function_g1(
+    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
+):
+    r"""
+    Calculate the normalized first-order quantum coherence function:
+
+    .. math::
+
+        g^{(1)}(\tau) =
+        \frac{\langle A^\dagger(\tau)A(0)\rangle}
+        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
+                \langle A^\dagger(0)A(0)\rangle}}
+
+    using the quantum regression theorem and the evolution solver indicated by
+    the `solver` parameter.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    g1, G1 : tuple
+        The normalized and unnormalized second-order coherence function.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    # first calculate the photon number
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+        n = np.array([expect(state0, a_op.dag() * a_op)])
+    else:
+        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
+
+    # calculate the correlation function G1 and normalize with n to obtain g1
+    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
+
+    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
+    return g1, G1
+
+
+def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
+                          args={}, options={}):
+    r"""
+    Calculate the normalized second-order quantum coherence function:
+
+    .. math::
+
+         g^{(2)}(\tau) =
+        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
+        {\langle A^\dagger(\tau)A(\tau)\rangle
+         \langle A^\dagger(0)A(0)\rangle}
+
+    using the quantum regression theorem and the evolution solver indicated by
+    the `solver` parameter.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list
+        List of collapse operators, may be time-dependent for solver choice of
+        `me`.
+    a_op : :class:`Qobj`
+        Operator A.
+    args : dict
+        Dictionary of arguments to be passed to solver.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    g2, G2 : tuple
+        The normalized and unnormalized second-order coherence function.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    # first calculate the photon number
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+        n = np.array([expect(state0, a_op.dag() * a_op)])
+    else:
+        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
+
+    # calculate the correlation function G2 and normalize with n to obtain g2
+    G2 = correlation_3op(solver, state0, [0], taulist,
+                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
+
+    g2 = G2 / (n[0] * np.array(n))
+    return g2, G2
+
+
+def _make_solver(H, c_ops, args, options, solver):
+    H = QobjEvo(H, args=args)
+    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
+    if solver == "me":
+        solver_instance = MESolver(H, c_ops, options=options)
+    elif solver == "es":
+        options = {"method": "diag"}
+        solver_instance = MESolver(H, c_ops, options=options)
+    elif solver == "mc":
+        raise ValueError("MC solver for correlation has been removed")
+    return solver_instance
+
+
+def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
+    r"""
+    Calculate the three-operator two-time correlation function:
+
+        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
+
+    from a open system :class:`Solver`.
+
+    Note: it is not possible to calculate a physically meaningful correlation
+    where :math:`\tau<0`.
+
+    Parameters
+    ----------
+    solver : :class:`MESolver`, :class:`BRSolver`
+        Qutip solver for an open system.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`.
+    tlist : array_like
+        List of times for :math:`t`. tlist must be positive and contain the
+        element `0`.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
+        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
+        in the Schrodinger picture. They do not need to be all provided. For
+        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
+
+    Returns
+    -------
+    corr_mat : array
+        An 2-dimensional array (matrix) of correlation values for the times
+        specified by `tlist` (first index) and `taulist` (second index). If
+        `tlist` is `None`, then a 1-dimensional array of correlation values
+        is returned instead.
+    """
+    taulist = np.asarray(taulist)
+
+    dims = state0.dims[0]
+    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
+    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
+    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
+
+    if isinstance(solver, (MESolver, BRSolver)):
+        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
+    elif isinstance(solver, MCSolver):
+        raise TypeError("Monte Carlo support for correlation was removed. "
+                        "Please, tell us on GitHub issues if you need it!")
+    elif isinstance(solver, HEOMSolver):
+        raise TypeError("HEOM is not supported by correlation. "
+                        "Please, tell us on GitHub issues if you need it!")
+    else:
+        raise TypeError("Only solvers able to evolve density matrices"
+                        " are supported.")
+
+    return out
+
+
+def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
+    old_opt = solver.options.copy()
+    try:
+        # We don't want to modify the solver
+        # TODO: Solver could have a ``with`` or ``copy``.
+        solver.options["normalize_output"] = False
+        solver.options["progress_bar"] = False
+
+        progress_bar = progess_bars[old_opt['progress_bar']]()
+        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
+        rho_t = solver.run(state0, tlist).states
+        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
+        progress_bar.update()
+
+        for t_idx, rho in enumerate(rho_t):
+            t = tlist[t_idx]
+            corr_mat[t_idx, :] = solver.run(
+                C(t) @ rho @ A(t),
+                taulist + t,
+                e_ops=B
+            ).expect[0]
+            progress_bar.update()
+        progress_bar.finished()
+
+    finally:
+        solver.options = old_opt
+
+    return corr_mat
diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 4d4c60af9a..2237957d01 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -1,217 +1,217 @@
-"""
-This module contains functions for calculating current and current noise using
-the counting statistics formalism.
-"""
-__all__ = ['countstat_current', 'countstat_current_noise']
-
-import numpy as np
-import scipy.sparse as sp
-
-from itertools import product
-from ..core import (
-    sprepost, spre, qeye, tensor, expect, Qobj,
-    operator_to_vector, vector_to_operator
-)
-from ..core import data as _data
-from .steadystate import pseudo_inverse, steadystate
-from ..settings import settings
-
-# Load MKL spsolve if avaiable
-if settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_spsolve
-
-
-def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
-    """
-    Calculate the current corresponding to a system Liouvillian ``L`` and a
-    list of current collapse operators ``c_ops`` or current superoperators
-    ``J_ops``.
-
-    Parameters
-    ----------
-
-    L : :class:`qutip.Qobj`
-        Qobj representing the system Liouvillian.
-
-    c_ops : array / list (optional)
-        List of current collapse operators. Required if either ``rhoss`` or
-        ``J_ops`` is not given.
-
-    rhoss : :class:`qutip.Qobj` (optional)
-        The steadystate density matrix for the given system Liouvillian ``L``
-        and collapse operators. If not given, it defaults to
-        ``steadystate(L, c_ops)``.
-
-    J_ops : array / list (optional)
-        List of current superoperators. If not given, they default to
-        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
-
-    Returns
-    --------
-    I : array
-        The currents ``I`` corresponding to each current collapse operator
-        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
-    """
-
-    if J_ops is None:
-        if c_ops is None:
-            raise ValueError("c_ops must be given if J_ops is not")
-        J_ops = [sprepost(c, c.dag()) for c in c_ops]
-
-    if rhoss is None:
-        if c_ops is None:
-            raise ValueError("c_ops must be given if rhoss is not")
-        rhoss = steadystate(L, c_ops)
-
-    rhoss_vec = _data.column_stack(rhoss.data.copy())
-
-    N = len(J_ops)
-    current = np.zeros(N)
-
-    for i, Ji in enumerate(J_ops):
-        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
-
-    return current
-
-
-def _solve(A, V):
-    try:
-        return _data.solve(A, V)
-    except Exception:
-        return _data.solve(A, V, "lsqr")
-
-
-def _noise_direct(L, wlist, rhoss, J_ops):
-    J_ops = [op.data for op in J_ops]
-    rhoss_vec = operator_to_vector(rhoss).data
-
-    N_j_ops = len(J_ops)
-    current = np.zeros(N_j_ops)
-    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
-
-    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
-    tr_op_vec = operator_to_vector(tr_op)
-
-    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
-    Iop = _data.identity(np.prod(L.dims[0][0])**2)
-    Q = _data.sub(Iop, Pop)
-    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
-
-    for k, w in enumerate(wlist):
-        if w != 0.0:
-            L_temp = 1.0j * w * spre(tr_op) + L
-        else:
-            # At zero frequency some solvers fail for small systems.
-            # Adding a small finite frequency of order 1e-15
-            # helps prevent the solvers from throwing an exception.
-            L_temp = 1e-15j * spre(tr_op) + L
-
-        A = _data.to(_data.CSR, L_temp.data)
-        X_rho = [_solve(A, op) for op in Q_ops]
-
-        for i, j in product(range(N_j_ops), repeat=2):
-            if i == j:
-                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
-                noise[j, i, k] = current[i]
-            noise[j, i, k] -= (
-                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
-                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
-            ).real
-
-    return current, noise
-
-
-def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
-    N_j_ops = len(J_ops)
-    current = np.zeros(N_j_ops)
-    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
-    rhoss_vec = operator_to_vector(rhoss)
-    for k, w in enumerate(wlist):
-        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
-        for i, j in product(range(N_j_ops), repeat=2):
-            if i == j:
-                current[i] = J_ops[i](rhoss).tr().real
-                noise[i, j, k] = current[i]
-            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
-            noise[i, j, k] -= op(rhoss).tr().real
-    return current, noise
-
-
-def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
-                            sparse=True, method='direct'):
-    """
-    Compute the cross-current noise spectrum for a list of collapse operators
-    `c_ops` corresponding to monitored currents, given the system
-    Liouvillian `L`. The current collapse operators `c_ops` should be part
-    of the dissipative processes in `L`, but the `c_ops` given here does not
-    necessarily need to be all collapse operators contributing to dissipation
-    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
-    and the current operators `J_ops` correpsonding to the current collapse
-    operators `c_ops` can also be specified. If either of
-    `rhoss` and `J_ops` are omitted, they will be computed internally.
-    'wlist' is an optional list of frequencies at which to evaluate the noise
-    spectrum.
-
-    Parameters
-    ----------
-
-    L : :class:`qutip.Qobj`
-        Qobj representing the system Liouvillian.
-
-    c_ops : array / list
-        List of current collapse operators.
-
-    rhoss : :class:`qutip.Qobj` (optional)
-        The steadystate density matrix corresponding the system Liouvillian
-        `L`.
-
-    wlist : array / list (optional)
-        List of frequencies at which to evaluate (if none are given, evaluates
-        at zero frequency)
-
-    J_ops : array / list (optional)
-        List of current superoperators.
-
-    sparse : bool [True]
-        Flag that indicates whether to use sparse or dense matrix methods when
-        computing the pseudo inverse. Default is false, as sparse solvers
-        can fail for small systems. For larger systems the sparse solvers
-        are recommended.
-
-    method : str, ['direct']
-        Method used to compute the noise. The default, 'direct' with
-        ``sparse=True``, compute the noise directly. It is the recommended
-        method for larger systems. Otherwise, the pseudo inverse is computed
-        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
-        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
-        ``sparse=False``.
-
-    .. note::
-        The algoryth is described in page 67 of "Electrons in nanostructures"
-        C. Flindt, PhD Thesis, available online:
-        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
-
-    Returns
-    --------
-    I, S : tuple of arrays
-        The currents `I` corresponding to each current collapse operator
-        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
-        zero-frequency cross-current correlation `S`.
-    """
-    if rhoss is None:
-        rhoss = steadystate(L, c_ops)
-
-    if J_ops is None:
-        J_ops = [sprepost(c, c.dag()) for c in c_ops]
-
-    if wlist is None:
-        wlist = [0.]
-
-    if sparse and method == 'direct':
-        # rhoss_vec = operator_to_vector(rhoss).data
-        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
-    else:
-        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
-                                          sparse, method)
-
-    return current, noise
+"""
+This module contains functions for calculating current and current noise using
+the counting statistics formalism.
+"""
+__all__ = ['countstat_current', 'countstat_current_noise']
+
+import numpy as np
+import scipy.sparse as sp
+
+from itertools import product
+from ..core import (
+    sprepost, spre, qeye, tensor, expect, Qobj,
+    operator_to_vector, vector_to_operator
+)
+from ..core import data as _data
+from .steadystate import pseudo_inverse, steadystate
+from ..settings import settings
+
+# Load MKL spsolve if avaiable
+if settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_spsolve
+
+
+def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
+    """
+    Calculate the current corresponding to a system Liouvillian ``L`` and a
+    list of current collapse operators ``c_ops`` or current superoperators
+    ``J_ops``.
+
+    Parameters
+    ----------
+
+    L : :class:`qutip.Qobj`
+        Qobj representing the system Liouvillian.
+
+    c_ops : array / list (optional)
+        List of current collapse operators. Required if either ``rhoss`` or
+        ``J_ops`` is not given.
+
+    rhoss : :class:`qutip.Qobj` (optional)
+        The steadystate density matrix for the given system Liouvillian ``L``
+        and collapse operators. If not given, it defaults to
+        ``steadystate(L, c_ops)``.
+
+    J_ops : array / list (optional)
+        List of current superoperators. If not given, they default to
+        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
+
+    Returns
+    --------
+    I : array
+        The currents ``I`` corresponding to each current collapse operator
+        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
+    """
+
+    if J_ops is None:
+        if c_ops is None:
+            raise ValueError("c_ops must be given if J_ops is not")
+        J_ops = [sprepost(c, c.dag()) for c in c_ops]
+
+    if rhoss is None:
+        if c_ops is None:
+            raise ValueError("c_ops must be given if rhoss is not")
+        rhoss = steadystate(L, c_ops)
+
+    rhoss_vec = _data.column_stack(rhoss.data.copy())
+
+    N = len(J_ops)
+    current = np.zeros(N)
+
+    for i, Ji in enumerate(J_ops):
+        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
+
+    return current
+
+
+def _solve(A, V):
+    try:
+        return _data.solve(A, V)
+    except Exception:
+        return _data.solve(A, V, "lsqr")
+
+
+def _noise_direct(L, wlist, rhoss, J_ops):
+    J_ops = [op.data for op in J_ops]
+    rhoss_vec = operator_to_vector(rhoss).data
+
+    N_j_ops = len(J_ops)
+    current = np.zeros(N_j_ops)
+    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
+
+    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
+    tr_op_vec = operator_to_vector(tr_op)
+
+    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
+    Iop = _data.identity(np.prod(L.dims[0][0])**2)
+    Q = _data.sub(Iop, Pop)
+    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
+
+    for k, w in enumerate(wlist):
+        if w != 0.0:
+            L_temp = 1.0j * w * spre(tr_op) + L
+        else:
+            # At zero frequency some solvers fail for small systems.
+            # Adding a small finite frequency of order 1e-15
+            # helps prevent the solvers from throwing an exception.
+            L_temp = 1e-15j * spre(tr_op) + L
+
+        A = _data.to(_data.CSR, L_temp.data)
+        X_rho = [_solve(A, op) for op in Q_ops]
+
+        for i, j in product(range(N_j_ops), repeat=2):
+            if i == j:
+                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
+                noise[j, i, k] = current[i]
+            noise[j, i, k] -= (
+                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
+                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
+            ).real
+
+    return current, noise
+
+
+def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
+    N_j_ops = len(J_ops)
+    current = np.zeros(N_j_ops)
+    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
+    rhoss_vec = operator_to_vector(rhoss)
+    for k, w in enumerate(wlist):
+        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
+        for i, j in product(range(N_j_ops), repeat=2):
+            if i == j:
+                current[i] = J_ops[i](rhoss).tr().real
+                noise[i, j, k] = current[i]
+            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
+            noise[i, j, k] -= op(rhoss).tr().real
+    return current, noise
+
+
+def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
+                            sparse=True, method='direct'):
+    """
+    Compute the cross-current noise spectrum for a list of collapse operators
+    `c_ops` corresponding to monitored currents, given the system
+    Liouvillian `L`. The current collapse operators `c_ops` should be part
+    of the dissipative processes in `L`, but the `c_ops` given here does not
+    necessarily need to be all collapse operators contributing to dissipation
+    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
+    and the current operators `J_ops` correpsonding to the current collapse
+    operators `c_ops` can also be specified. If either of
+    `rhoss` and `J_ops` are omitted, they will be computed internally.
+    'wlist' is an optional list of frequencies at which to evaluate the noise
+    spectrum.
+
+    Parameters
+    ----------
+
+    L : :class:`qutip.Qobj`
+        Qobj representing the system Liouvillian.
+
+    c_ops : array / list
+        List of current collapse operators.
+
+    rhoss : :class:`qutip.Qobj` (optional)
+        The steadystate density matrix corresponding the system Liouvillian
+        `L`.
+
+    wlist : array / list (optional)
+        List of frequencies at which to evaluate (if none are given, evaluates
+        at zero frequency)
+
+    J_ops : array / list (optional)
+        List of current superoperators.
+
+    sparse : bool [True]
+        Flag that indicates whether to use sparse or dense matrix methods when
+        computing the pseudo inverse. Default is false, as sparse solvers
+        can fail for small systems. For larger systems the sparse solvers
+        are recommended.
+
+    method : str, ['direct']
+        Method used to compute the noise. The default, 'direct' with
+        ``sparse=True``, compute the noise directly. It is the recommended
+        method for larger systems. Otherwise, the pseudo inverse is computed
+        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
+        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
+        ``sparse=False``.
+
+    .. note::
+        The algoryth is described in page 67 of "Electrons in nanostructures"
+        C. Flindt, PhD Thesis, available online:
+        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
+
+    Returns
+    --------
+    I, S : tuple of arrays
+        The currents `I` corresponding to each current collapse operator
+        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
+        zero-frequency cross-current correlation `S`.
+    """
+    if rhoss is None:
+        rhoss = steadystate(L, c_ops)
+
+    if J_ops is None:
+        J_ops = [sprepost(c, c.dag()) for c in c_ops]
+
+    if wlist is None:
+        wlist = [0.]
+
+    if sparse and method == 'direct':
+        # rhoss_vec = operator_to_vector(rhoss).data
+        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
+    else:
+        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
+                                          sparse, method)
+
+    return current, noise
diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
index 7ce6cc4f11..9eea49b97b 100644
--- a/qutip/solver/floquet.py
+++ b/qutip/solver/floquet.py
@@ -1,931 +1,931 @@
-__all__ = [
-    "FloquetBasis",
-    "floquet_tensor",
-    "fsesolve",
-    "fmmesolve",
-    "FMESolver",
-]
-
-import numpy as np
-from qutip.core import data as _data
-from qutip import Qobj, QobjEvo
-from .propagator import Propagator
-from .mesolve import MESolver
-from .solver_base import Solver
-from .integrator import Integrator
-from .result import Result
-from time import time
-from ..ui.progressbar import progess_bars
-
-
-class FloquetBasis:
-    """
-    Utility to compute floquet modes and states.
-
-    Attributes
-    ----------
-    U : :class:`Propagator`
-        The propagator of the Hamiltonian over one period.
-
-    evecs : :class:`qutip.data.Data`
-        Matrix where each column is an initial Floquet mode.
-
-    e_quasi : np.ndarray[float]
-        The quasi energies of the Hamiltonian.
-    """
-
-    def __init__(
-        self,
-        H,
-        T,
-        args=None,
-        options=None,
-        sparse=False,
-        sort=True,
-        precompute=None,
-    ):
-        """
-        Parameters
-        ----------
-        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
-            System Hamiltonian, with period `T`.
-
-        T : float
-            Period of the Hamiltonian.
-
-        args : None / *dictionary*
-            dictionary of parameters for time-dependent Hamiltonians and
-            collapse operators.
-
-        options : dict [None]
-            Options used by sesolve to compute the floquet modes.
-
-        sparse : bool [False]
-            Whether to use the sparse eigen solver when computing the
-            quasi-energies.
-
-        sort : bool [True]
-            Whether to sort the quasi-energies.
-
-        precompute : list [None]
-            If provided, a list of time at which to store the propagators
-            for later use when computing modes and states. Default is
-            ``linspace(0, T, 101)`` corresponding to the default integration
-            steps used for the floquet tensor computation.
-        """
-        if not T > 0:
-            raise ValueError("The period need to be a positive number.")
-        self.T = T
-        if precompute is not None:
-            tlist = np.unique(np.atleast_1d(precompute) % self.T)
-            memoize = len(tlist)
-            if tlist[0] != 0:
-                memoize += 1
-            if tlist[-1] != T:
-                memoize += 1
-        else:
-            # Default computation
-            tlist = np.linspace(0, T, 101)
-            memoize = 101
-        self.U = Propagator(H, args=args, options=options, memoize=memoize)
-        for t in tlist:
-            # Do the evolution by steps to save the intermediate results.
-            self.U(t)
-        U_T = self.U(self.T)
-        if not sparse and isinstance(U_T.data, _data.CSR):
-            U_T = U_T.to("Dense")
-        evals, evecs = _data.eigs(U_T.data)
-        e_quasi = -np.angle(evals) / T
-        if sort:
-            perm = np.argsort(e_quasi)
-            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
-            self.e_quasi = e_quasi[perm]
-        else:
-            self.evecs = evecs
-            self.e_quasi = e_quasi
-
-    def _as_ketlist(self, kets_mat):
-        """
-        Split the Data array in a list of kets.
-        """
-        dims = [self.U(0).dims[0], [1]]
-        return [
-            Qobj(ket, dims=dims, type="ket")
-            for ket in _data.split_columns(kets_mat)
-        ]
-
-    def mode(self, t, data=False):
-        """
-        Calculate the Floquet modes at time ``t``.
-
-        Parameters
-        ----------
-        t : float
-            The time for which to evaluate the Floquet mode.
-
-        data : bool [False]
-            Whether to return the states as a single data matrix or a list of
-            ket states.
-
-        Returns
-        -------
-        output : list[:class:`Qobj`], :class:`qutip.data.Data`
-            A list of Floquet states for the time ``t`` or the states as column
-            in a single matrix.
-        """
-        t = t % self.T
-        if t == 0.0:
-            kets_mat = self.evecs
-        else:
-            U = self.U(t).data
-            phases = _data.diag(np.exp(1j * t * self.e_quasi))
-            kets_mat = U @ self.evecs @ phases
-        if data:
-            return kets_mat
-        else:
-            return self._as_ketlist(kets_mat)
-
-    def state(self, t, data=False):
-        """
-        Evaluate the floquet states at time t.
-
-        Parameters
-        ----------
-        t : float
-            The time for which to evaluate the Floquet states.
-
-        data : bool [False]
-            Whether to return the states as a single data matrix or a list of
-            ket states.
-
-        Returns
-        -------
-        output : list[:class:`Qobj`], :class:`qutip.data.Data`
-            A list of Floquet states for the time ``t`` or the states as column
-            in a single matrix.
-        """
-        if t:
-            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
-            states_mat = self.mode(t, True) @ phases
-        else:
-            states_mat = self.evecs
-        if data:
-            return states_mat
-        else:
-            return self._as_ketlist(states_mat)
-
-    def from_floquet_basis(self, floquet_basis, t=0):
-        """
-        Transform a ket or density matrix from the Floquet basis at time ``t``
-        to the lab basis.
-
-        Parameters
-        ----------
-        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
-            Initial state in the Floquet basis at time ``t``. May be either a
-            ket or density matrix.
-
-        t : float [0]
-            The time at which to evaluate the Floquet states.
-
-        Returns
-        -------
-        output : :class:`Qobj`, :class:`qutip.data.Data`
-            The state in the lab basis. The return type is the same as the type
-            of the input state.
-        """
-        is_Qobj = isinstance(floquet_basis, Qobj)
-        if is_Qobj:
-            dims = floquet_basis.dims
-            floquet_basis = floquet_basis.data
-            if dims[0] != self.U(0).dims[1]:
-                raise ValueError(
-                    "Dimensions of the state do not match the Hamiltonian"
-                )
-
-        state_mat = self.state(t, True)
-        lab_basis = state_mat @ floquet_basis
-        if floquet_basis.shape[1] != 1:
-            lab_basis = lab_basis @ state_mat.adjoint()
-
-        if is_Qobj:
-            return Qobj(lab_basis, dims=dims)
-        return lab_basis
-
-    def to_floquet_basis(self, lab_basis, t=0):
-        """
-        Transform a ket or density matrix in the lab basis
-        to the Floquet basis at time ``t``.
-
-        Parameters
-        ----------
-        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
-            Initial state in the lab basis.
-
-        t : float [0]
-            The time at which to evaluate the Floquet states.
-
-        Returns
-        -------
-        output : :class:`Qobj`, :class:`qutip.data.Data`
-            The state in the Floquet basis. The return type is the same as the
-            type of the input state.
-        """
-        is_Qobj = isinstance(lab_basis, Qobj)
-        if is_Qobj:
-            dims = lab_basis.dims
-            lab_basis = lab_basis.data
-            if dims[0] != self.U(0).dims[1]:
-                raise ValueError(
-                    "Dimensions of the state do not match the Hamiltonian"
-                )
-
-        state_mat = self.state(t, True)
-        floquet_basis = state_mat.adjoint() @ lab_basis
-        if lab_basis.shape[1] != 1:
-            floquet_basis = floquet_basis @ state_mat
-
-        if is_Qobj:
-            return Qobj(floquet_basis, dims=dims)
-        return floquet_basis
-
-
-def _floquet_delta_tensor(f_energies, kmax, T):
-    """
-    Floquet-Markov master equation X matrices.
-
-    Parameters
-    ----------
-    f_energies : np.ndarray
-        The Floquet energies.
-
-    kmax : int
-        The truncation of the number of sidebands (default 5).
-
-    T : float
-        The period of the time-dependence of the Hamiltonian.
-
-    Returns
-    -------
-    delta : np.ndarray
-        Floquet delta tensor.
-    """
-    delta = np.subtract.outer(f_energies, f_energies)
-    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
-
-
-def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
-    """
-    Floquet-Markov master equation X matrices.
-
-    Parameters
-    ----------
-    floquet_basis : :class:`FloquetBasis`
-        The system Hamiltonian wrapped in a FloquetBasis object.
-
-    c_ops : list of :class:`Qobj`
-        The collapse operators describing the dissipation.
-
-    kmax : int
-        The truncation of the number of sidebands (default 5).
-
-    ntimes : int [100]
-        The number of integration steps (for calculating X) within one period.
-
-    Returns
-    -------
-    X : list of dict of :class:`qutip.data.Data`
-        A dict of the sidebands ``k`` for the X matrices of each c_ops
-    """
-    T = floquet_basis.T
-    N = floquet_basis.U(0).shape[0]
-    omega = (2 * np.pi) / T
-    tlist = np.linspace(T / ntimes, T, ntimes)
-    ks = np.arange(-kmax, kmax + 1)
-    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
-
-    for t in tlist:
-        mode = floquet_basis.mode(t, data=True)
-        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
-        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
-            out[k] = [
-                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
-            ]
-
-    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
-
-
-def _floquet_gamma_matrices(X, delta, J_cb):
-    """
-    Floquet-Markov master equation gamma matrices.
-
-    Parameters
-    ----------
-    X : list of dict of :class:`qutip.data.Data`
-        Floquet X matrices created by :func:`_floquet_X_matrices`.
-
-    delta : np.ndarray
-        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
-
-    J_cb : list of callables
-        A list callback functions that compute the noise power spectrum as
-        a function of frequency. The list should contain one callable for each
-        collapse operator `c_op`, in the same order as the elements of `X`.
-        Each callable should accept a numpy array of frequencies and return a
-        numpy array of corresponding noise power.
-
-    Returns
-    -------
-    gammas : dict of :class:`qutip.data.Data`
-        A dict mapping the sidebands ``k`` to their gamma matrices.
-    """
-    N = delta.shape[0]
-    kmax = (delta.shape[2] - 1) // 2
-    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
-
-    for X_c_op, sp in zip(X, J_cb):
-        response = sp(delta) * ((2 + 0j) * np.pi)
-        response = [
-            _data.Dense(response[:, :, k], copy=False)
-            for k in range(2 * kmax + 1)
-        ]
-        for k in range(-kmax, kmax + 1, 1):
-            gamma[k] = _data.add(
-                gamma[k],
-                _data.multiply(
-                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
-                    response[k + kmax],
-                ),
-            )
-    return gamma
-
-
-def _floquet_A_matrix(delta, gamma, w_th):
-    """
-    Floquet-Markov master equation rate matrix.
-
-    Parameters
-    ----------
-    delta : np.ndarray
-        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
-
-    gamma : dict of :class:`qutip.data.Data`
-        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
-
-    w_th : float
-        The temperature in units of frequency.
-    """
-    kmax = (delta.shape[2] - 1) // 2
-
-    if w_th > 0.0:
-        deltap = np.copy(delta)
-        deltap[deltap == 0.0] = np.inf
-        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
-        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
-
-        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
-        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
-
-        for k in range(1, kmax + 1):
-            g_kk = _data.add(gamma[k], gamma[-k].transpose())
-            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
-            A = _data.add(A, _data.add(gamma[k], thermal_kk))
-            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
-            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
-    else:
-        # w_th is 0, thermal = 0s
-        A = gamma[0]
-        for k in range(1, kmax + 1):
-            A = _data.add(gamma[k], A)
-            A = _data.add(gamma[-k], A)
-
-    return A
-
-
-def _floquet_master_equation_tensor(A):
-    """
-    Construct a tensor that represents the master equation in the floquet
-    basis (with constant Hamiltonian and collapse operators?).
-
-    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
-
-    Parameters
-    ----------
-    A : :class:`qutip.data.Data`
-        Floquet-Markov master equation rate matrix.
-
-    Returns
-    -------
-    output : array
-        The Floquet-Markov master equation tensor `R`.
-    """
-    N = A.shape[0]
-
-    # R[i+N*i, j+N*j] = A[j, i]
-    cols = np.arange(N, dtype=np.int32)
-    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
-    data = np.ones(N, dtype=complex)
-    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
-
-    R = expand @ A.transpose() @ expand.transpose()
-
-    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
-    ket_1 = _data.Dense(np.ones(N, dtype=complex))
-    Asum = A @ ket_1
-    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
-    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
-
-    return _data.add(R, S)
-
-
-def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
-    """
-    Construct a tensor that represents the master equation in the floquet
-    basis.
-
-    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
-
-    Parameters
-    ----------
-    H : :class:`QobjEvo`
-        Periodic Hamiltonian
-
-    T : float
-        The period of the time-dependence of the hamiltonian.
-
-    c_ops : list of :class:`qutip.qobj`
-        list of collapse operators.
-
-    spectra_cb : list callback functions
-        List of callback functions that compute the noise power spectrum as
-        a function of frequency for the collapse operators in `c_ops`.
-
-    w_th : float
-        The temperature in units of frequency.
-
-    kmax : int
-        The truncation of the number of sidebands (default 5).
-
-    Returns
-    -------
-    output : array
-        The Floquet-Markov master equation tensor `R`.
-    """
-    if isinstance(H, FloquetBasis):
-        floquet_basis = H
-        T = H.T
-    else:
-        floquet_basis = FloquetBasis(H, T)
-    energy = floquet_basis.e_quasi
-    delta = _floquet_delta_tensor(energy, kmax, T)
-    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
-    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
-    a = _floquet_A_matrix(delta, gamma, w_th)
-    r = _floquet_master_equation_tensor(a)
-    dims = floquet_basis.U(0).dims
-    return Qobj(
-        r, dims=[dims, dims], type="super", superrep="super", copy=False
-    )
-
-
-def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
-    """
-    Solve the Schrodinger equation using the Floquet formalism.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Periodic system Hamiltonian as :class:`QobjEvo`. List of
-        [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    psi0 : :class:`qutip.qobj`
-        Initial state vector (ket). If an operator is provided,
-
-    tlist : *list* / *array*
-        List of times for :math:`t`.
-
-    e_ops : list of :class:`qutip.qobj` / callback function, optional
-        List of operators for which to evaluate expectation values. If this
-        list is empty, the state vectors for each time in `tlist` will be
-        returned instead of expectation values.
-
-    T : float, default=tlist[-1]
-        The period of the time-dependence of the hamiltonian.
-
-    args : dictionary, optional
-        Dictionary with variables required to evaluate H.
-
-    options : dict, optional
-        Options for the results.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-
-    Returns
-    -------
-    output : :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`, which
-        contains either an *array* of expectation values or an array of
-        state vectors, for the times specified by `tlist`.
-    """
-    if isinstance(H, FloquetBasis):
-        floquet_basis = H
-    else:
-        T = T or tlist[-1]
-        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
-        # are for the open system evolution.
-        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
-
-    f_coeff = floquet_basis.to_floquet_basis(psi0)
-    result_options = {
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-    }
-    result_options.update(options or {})
-    result = Result(e_ops, result_options, solver="fsesolve")
-    for t in tlist:
-        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
-        result.add(t, state_t)
-
-    return result
-
-
-def fmmesolve(
-    H,
-    rho0,
-    tlist,
-    c_ops=None,
-    e_ops=None,
-    spectra_cb=None,
-    T=0,
-    w_th=0.0,
-    args=None,
-    options=None,
-):
-    """
-    Solve the dynamics for the system using the Floquet-Markov master equation.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Periodic system Hamiltonian as :class:`QobjEvo`. List of
-        [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    rho0 / psi0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    tlist : *list* / *array*
-        List of times for :math:`t`.
-
-    c_ops : list of :class:`qutip.Qobj`
-        List of collapse operators. Time dependent collapse operators are not
-        supported.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function
-        List of operators for which to evaluate expectation values.
-        The states are reverted to the lab basis before applying the
-
-    spectra_cb : list callback functions
-        List of callback functions that compute the noise power spectrum as
-        a function of frequency for the collapse operators in `c_ops`.
-
-    T : float
-        The period of the time-dependence of the hamiltonian. The default value
-        'None' indicates that the 'tlist' spans a single period of the driving.
-
-    w_th : float
-        The temperature of the environment in units of frequency.
-        For example, if the Hamiltonian written in units of 2pi GHz, and the
-        temperature is given in K, use the following conversion:
-
-            temperature = 25e-3 # unit K
-            h = 6.626e-34
-            kB = 1.38e-23
-            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
-
-    args : *dictionary*
-        Dictionary of parameters for time-dependent Hamiltonian
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - store_floquet_states : bool
-          Whether or not to store the density matrices in the floquet basis in
-          ``result.floquet_states``.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        the expectation values for the times specified by `tlist`, and/or the
-        state density matrices corresponding to the times.
-    """
-    if c_ops is None:
-        return fsesolve(
-            H,
-            rho0,
-            tlist,
-            e_ops=e_ops,
-            T=T,
-            w_th=w_th,
-            args=args,
-            options=options,
-        )
-
-    if isinstance(H, FloquetBasis):
-        floquet_basis = H
-    else:
-        T = T or tlist[-1]
-        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
-        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
-        # are for the open system evolution.
-        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
-
-    if not w_th and args:
-        w_th = args.get("w_th", 0.0)
-
-    if isinstance(c_ops, Qobj):
-        c_ops = [c_ops]
-
-    if spectra_cb is None:
-        spectra_cb = [lambda w: (w > 0)]
-    elif callable(spectra_cb):
-        spectra_cb = [spectra_cb]
-    if len(spectra_cb) == 1:
-        spectra_cb = spectra_cb * len(c_ops)
-
-    a_ops = list(zip(c_ops, spectra_cb))
-
-    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
-    return solver.run(rho0, tlist, e_ops=e_ops)
-
-
-class FloquetResult(Result):
-    def _post_init(self, floquet_basis):
-        self.floquet_basis = floquet_basis
-        if self.options["store_floquet_states"]:
-            self.floquet_states = []
-        else:
-            self.floquet_states = None
-        super()._post_init()
-
-    def add(self, t, state):
-        if self.options["store_floquet_states"]:
-            self.floquet_states.append(state)
-
-        state = self.floquet_basis.from_floquet_basis(state, t)
-        super().add(t, state)
-
-
-class FMESolver(MESolver):
-    """
-    Solver for the Floquet-Markov master equation.
-
-    .. note ::
-        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
-
-    Parameters
-    ----------
-    floquet_basis : :class:`qutip.FloquetBasis`
-        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
-        different integrator for the ``floquet_basis`` than for the evolution
-        of the floquet state can improve the performance.
-
-    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
-        List of collapse operators and the corresponding function for the noise
-        power spectrum. The collapse operator must be a :class:`Qobj` and
-        cannot be time dependent. The spectrum function must take and return
-        an numpy array.
-
-    w_th : float
-        The temperature of the environment in units of Hamiltonian frequency.
-
-    kmax : int [5]
-        The truncation of the number of sidebands..
-
-    nT : int [20*kmax]
-        The number of integration steps (for calculating X) within one period.
-
-    options : dict, optional
-        Options for the solver, see :obj:`FMESolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-    """
-
-    name = "fmmesolve"
-    _avail_integrators = {}
-    resultclass = FloquetResult
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-        "method": "adams",
-        "store_floquet_states": False,
-    }
-
-    def __init__(
-        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
-    ):
-        self.options = options
-        if isinstance(floquet_basis, FloquetBasis):
-            self.floquet_basis = floquet_basis
-        else:
-            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
-
-        nT = nT or max(100, 20 * kmax)
-        self._num_collapse = len(a_ops)
-        c_ops, spectra_cb = zip(*a_ops)
-        if not all(
-            isinstance(c_op, Qobj) and callable(spectrum)
-            for c_op, spectrum in a_ops
-        ):
-            raise TypeError("a_ops must be tuple of (Qobj, callable)")
-        self.rhs = QobjEvo(
-            floquet_tensor(
-                self.floquet_basis,
-                c_ops,
-                spectra_cb,
-                w_th=w_th,
-                kmax=kmax,
-                nT=nT,
-            )
-        )
-
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-    def _initialize_stats(self):
-        stats = Solver._initialize_stats(self)
-        stats.update(
-            {
-                "solver": "Floquet-Markov master equation",
-                "num_collapse": self._num_collapse,
-            }
-        )
-        return stats
-
-    def _argument(self, args):
-        if args:
-            raise ValueError("FMESolver cannot update arguments")
-
-    def start(self, state0, t0, *, floquet=False):
-        """
-        Set the initial state and time for a step evolution.
-        ``options`` for the evolutions are read at this step.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        t0 : double
-            Initial time of the evolution.
-
-        floquet : bool, optional {False}
-            Whether the initial state is in the floquet basis or laboratory
-            basis.
-        """
-        if not floquet:
-            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
-        super().start(state0, t0)
-
-    def step(self, t, *, args=None, copy=True, floquet=False):
-        """
-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-
-        Parameters
-        ----------
-        t : double
-            Time to evolve to, must be higher than the last call.
-
-        copy : bool, optional {True}
-            Whether to return a copy of the data or the data in the ODE solver.
-
-        floquet : bool, optional {False}
-            Whether to return the state in the floquet basis or laboratory
-            basis.
-
-        args : dict, optional {None}
-            Not supported
-
-        .. note::
-            The state must be initialized first by calling ``start`` or
-            ``run``. If ``run`` is called, ``step`` will continue from the last
-            time and state obtained.
-        """
-        if args:
-            raise ValueError("FMESolver cannot update arguments")
-        state = super().step(t)
-        if not floquet:
-            state = self.floquet_basis.from_floquet_basis(state, t)
-        elif copy:
-            state = state.copy()
-        return state
-
-    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
-        """
-        Calculate the evolution of the quantum system.
-
-        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
-        ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :class:`Result`. The evolution method and
-        stored results are determined by ``options``.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        tlist : list of double
-            Time for which to save the results (state and/or expect) of the
-            evolution. The first element of the list is the initial time of the
-            evolution. Each times of the list must be increasing, but does not
-            need to be uniformy distributed.
-
-        floquet : bool, optional {False}
-            Whether the initial state in the floquet basis or laboratory basis.
-
-        args : dict, optional {None}
-            Not supported
-
-        e_ops : list {None}
-            List of Qobj, QobjEvo or callable to compute the expectation
-            values. Function[s] must have the signature
-            f(t : float, state : Qobj) -> expect.
-
-        Returns
-        -------
-        results : :class:`qutip.solver.FloquetResult`
-            Results of the evolution. States and/or expect will be saved. You
-            can control the saved data in the options.
-        """
-        if args:
-            raise ValueError("FMESolver cannot update arguments")
-        if not floquet:
-            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
-        _time_start = time()
-        _data0 = self._prepare_state(state0)
-        self._integrator.set_state(tlist[0], _data0)
-        stats = self._initialize_stats()
-        results = self.resultclass(
-            e_ops,
-            self.options,
-            solver=self.name,
-            stats=stats,
-            floquet_basis=self.floquet_basis,
-        )
-        results.add(tlist[0], self._restore_state(_data0, copy=False))
-        stats["preparation time"] += time() - _time_start
-
-        progress_bar = progess_bars[self.options["progress_bar"]]()
-        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
-        for t, state in self._integrator.run(tlist):
-            progress_bar.update()
-            results.add(t, self._restore_state(state, copy=False))
-        progress_bar.finished()
-
-        stats["run time"] = progress_bar.total_time()
-        # TODO: It would be nice if integrator could give evolution statistics
-        # stats.update(_integrator.stats)
-        return results
+__all__ = [
+    "FloquetBasis",
+    "floquet_tensor",
+    "fsesolve",
+    "fmmesolve",
+    "FMESolver",
+]
+
+import numpy as np
+from qutip.core import data as _data
+from qutip import Qobj, QobjEvo
+from .propagator import Propagator
+from .mesolve import MESolver
+from .solver_base import Solver
+from .integrator import Integrator
+from .result import Result
+from time import time
+from ..ui.progressbar import progess_bars
+
+
+class FloquetBasis:
+    """
+    Utility to compute floquet modes and states.
+
+    Attributes
+    ----------
+    U : :class:`Propagator`
+        The propagator of the Hamiltonian over one period.
+
+    evecs : :class:`qutip.data.Data`
+        Matrix where each column is an initial Floquet mode.
+
+    e_quasi : np.ndarray[float]
+        The quasi energies of the Hamiltonian.
+    """
+
+    def __init__(
+        self,
+        H,
+        T,
+        args=None,
+        options=None,
+        sparse=False,
+        sort=True,
+        precompute=None,
+    ):
+        """
+        Parameters
+        ----------
+        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
+            System Hamiltonian, with period `T`.
+
+        T : float
+            Period of the Hamiltonian.
+
+        args : None / *dictionary*
+            dictionary of parameters for time-dependent Hamiltonians and
+            collapse operators.
+
+        options : dict [None]
+            Options used by sesolve to compute the floquet modes.
+
+        sparse : bool [False]
+            Whether to use the sparse eigen solver when computing the
+            quasi-energies.
+
+        sort : bool [True]
+            Whether to sort the quasi-energies.
+
+        precompute : list [None]
+            If provided, a list of time at which to store the propagators
+            for later use when computing modes and states. Default is
+            ``linspace(0, T, 101)`` corresponding to the default integration
+            steps used for the floquet tensor computation.
+        """
+        if not T > 0:
+            raise ValueError("The period need to be a positive number.")
+        self.T = T
+        if precompute is not None:
+            tlist = np.unique(np.atleast_1d(precompute) % self.T)
+            memoize = len(tlist)
+            if tlist[0] != 0:
+                memoize += 1
+            if tlist[-1] != T:
+                memoize += 1
+        else:
+            # Default computation
+            tlist = np.linspace(0, T, 101)
+            memoize = 101
+        self.U = Propagator(H, args=args, options=options, memoize=memoize)
+        for t in tlist:
+            # Do the evolution by steps to save the intermediate results.
+            self.U(t)
+        U_T = self.U(self.T)
+        if not sparse and isinstance(U_T.data, _data.CSR):
+            U_T = U_T.to("Dense")
+        evals, evecs = _data.eigs(U_T.data)
+        e_quasi = -np.angle(evals) / T
+        if sort:
+            perm = np.argsort(e_quasi)
+            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
+            self.e_quasi = e_quasi[perm]
+        else:
+            self.evecs = evecs
+            self.e_quasi = e_quasi
+
+    def _as_ketlist(self, kets_mat):
+        """
+        Split the Data array in a list of kets.
+        """
+        dims = [self.U(0).dims[0], [1]]
+        return [
+            Qobj(ket, dims=dims, type="ket")
+            for ket in _data.split_columns(kets_mat)
+        ]
+
+    def mode(self, t, data=False):
+        """
+        Calculate the Floquet modes at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+            The time for which to evaluate the Floquet mode.
+
+        data : bool [False]
+            Whether to return the states as a single data matrix or a list of
+            ket states.
+
+        Returns
+        -------
+        output : list[:class:`Qobj`], :class:`qutip.data.Data`
+            A list of Floquet states for the time ``t`` or the states as column
+            in a single matrix.
+        """
+        t = t % self.T
+        if t == 0.0:
+            kets_mat = self.evecs
+        else:
+            U = self.U(t).data
+            phases = _data.diag(np.exp(1j * t * self.e_quasi))
+            kets_mat = U @ self.evecs @ phases
+        if data:
+            return kets_mat
+        else:
+            return self._as_ketlist(kets_mat)
+
+    def state(self, t, data=False):
+        """
+        Evaluate the floquet states at time t.
+
+        Parameters
+        ----------
+        t : float
+            The time for which to evaluate the Floquet states.
+
+        data : bool [False]
+            Whether to return the states as a single data matrix or a list of
+            ket states.
+
+        Returns
+        -------
+        output : list[:class:`Qobj`], :class:`qutip.data.Data`
+            A list of Floquet states for the time ``t`` or the states as column
+            in a single matrix.
+        """
+        if t:
+            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
+            states_mat = self.mode(t, True) @ phases
+        else:
+            states_mat = self.evecs
+        if data:
+            return states_mat
+        else:
+            return self._as_ketlist(states_mat)
+
+    def from_floquet_basis(self, floquet_basis, t=0):
+        """
+        Transform a ket or density matrix from the Floquet basis at time ``t``
+        to the lab basis.
+
+        Parameters
+        ----------
+        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
+            Initial state in the Floquet basis at time ``t``. May be either a
+            ket or density matrix.
+
+        t : float [0]
+            The time at which to evaluate the Floquet states.
+
+        Returns
+        -------
+        output : :class:`Qobj`, :class:`qutip.data.Data`
+            The state in the lab basis. The return type is the same as the type
+            of the input state.
+        """
+        is_Qobj = isinstance(floquet_basis, Qobj)
+        if is_Qobj:
+            dims = floquet_basis.dims
+            floquet_basis = floquet_basis.data
+            if dims[0] != self.U(0).dims[1]:
+                raise ValueError(
+                    "Dimensions of the state do not match the Hamiltonian"
+                )
+
+        state_mat = self.state(t, True)
+        lab_basis = state_mat @ floquet_basis
+        if floquet_basis.shape[1] != 1:
+            lab_basis = lab_basis @ state_mat.adjoint()
+
+        if is_Qobj:
+            return Qobj(lab_basis, dims=dims)
+        return lab_basis
+
+    def to_floquet_basis(self, lab_basis, t=0):
+        """
+        Transform a ket or density matrix in the lab basis
+        to the Floquet basis at time ``t``.
+
+        Parameters
+        ----------
+        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
+            Initial state in the lab basis.
+
+        t : float [0]
+            The time at which to evaluate the Floquet states.
+
+        Returns
+        -------
+        output : :class:`Qobj`, :class:`qutip.data.Data`
+            The state in the Floquet basis. The return type is the same as the
+            type of the input state.
+        """
+        is_Qobj = isinstance(lab_basis, Qobj)
+        if is_Qobj:
+            dims = lab_basis.dims
+            lab_basis = lab_basis.data
+            if dims[0] != self.U(0).dims[1]:
+                raise ValueError(
+                    "Dimensions of the state do not match the Hamiltonian"
+                )
+
+        state_mat = self.state(t, True)
+        floquet_basis = state_mat.adjoint() @ lab_basis
+        if lab_basis.shape[1] != 1:
+            floquet_basis = floquet_basis @ state_mat
+
+        if is_Qobj:
+            return Qobj(floquet_basis, dims=dims)
+        return floquet_basis
+
+
+def _floquet_delta_tensor(f_energies, kmax, T):
+    """
+    Floquet-Markov master equation X matrices.
+
+    Parameters
+    ----------
+    f_energies : np.ndarray
+        The Floquet energies.
+
+    kmax : int
+        The truncation of the number of sidebands (default 5).
+
+    T : float
+        The period of the time-dependence of the Hamiltonian.
+
+    Returns
+    -------
+    delta : np.ndarray
+        Floquet delta tensor.
+    """
+    delta = np.subtract.outer(f_energies, f_energies)
+    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
+
+
+def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
+    """
+    Floquet-Markov master equation X matrices.
+
+    Parameters
+    ----------
+    floquet_basis : :class:`FloquetBasis`
+        The system Hamiltonian wrapped in a FloquetBasis object.
+
+    c_ops : list of :class:`Qobj`
+        The collapse operators describing the dissipation.
+
+    kmax : int
+        The truncation of the number of sidebands (default 5).
+
+    ntimes : int [100]
+        The number of integration steps (for calculating X) within one period.
+
+    Returns
+    -------
+    X : list of dict of :class:`qutip.data.Data`
+        A dict of the sidebands ``k`` for the X matrices of each c_ops
+    """
+    T = floquet_basis.T
+    N = floquet_basis.U(0).shape[0]
+    omega = (2 * np.pi) / T
+    tlist = np.linspace(T / ntimes, T, ntimes)
+    ks = np.arange(-kmax, kmax + 1)
+    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
+
+    for t in tlist:
+        mode = floquet_basis.mode(t, data=True)
+        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
+        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
+            out[k] = [
+                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
+            ]
+
+    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
+
+
+def _floquet_gamma_matrices(X, delta, J_cb):
+    """
+    Floquet-Markov master equation gamma matrices.
+
+    Parameters
+    ----------
+    X : list of dict of :class:`qutip.data.Data`
+        Floquet X matrices created by :func:`_floquet_X_matrices`.
+
+    delta : np.ndarray
+        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
+
+    J_cb : list of callables
+        A list callback functions that compute the noise power spectrum as
+        a function of frequency. The list should contain one callable for each
+        collapse operator `c_op`, in the same order as the elements of `X`.
+        Each callable should accept a numpy array of frequencies and return a
+        numpy array of corresponding noise power.
+
+    Returns
+    -------
+    gammas : dict of :class:`qutip.data.Data`
+        A dict mapping the sidebands ``k`` to their gamma matrices.
+    """
+    N = delta.shape[0]
+    kmax = (delta.shape[2] - 1) // 2
+    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
+
+    for X_c_op, sp in zip(X, J_cb):
+        response = sp(delta) * ((2 + 0j) * np.pi)
+        response = [
+            _data.Dense(response[:, :, k], copy=False)
+            for k in range(2 * kmax + 1)
+        ]
+        for k in range(-kmax, kmax + 1, 1):
+            gamma[k] = _data.add(
+                gamma[k],
+                _data.multiply(
+                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
+                    response[k + kmax],
+                ),
+            )
+    return gamma
+
+
+def _floquet_A_matrix(delta, gamma, w_th):
+    """
+    Floquet-Markov master equation rate matrix.
+
+    Parameters
+    ----------
+    delta : np.ndarray
+        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
+
+    gamma : dict of :class:`qutip.data.Data`
+        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
+
+    w_th : float
+        The temperature in units of frequency.
+    """
+    kmax = (delta.shape[2] - 1) // 2
+
+    if w_th > 0.0:
+        deltap = np.copy(delta)
+        deltap[deltap == 0.0] = np.inf
+        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
+        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
+
+        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
+        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
+
+        for k in range(1, kmax + 1):
+            g_kk = _data.add(gamma[k], gamma[-k].transpose())
+            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
+            A = _data.add(A, _data.add(gamma[k], thermal_kk))
+            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
+            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
+    else:
+        # w_th is 0, thermal = 0s
+        A = gamma[0]
+        for k in range(1, kmax + 1):
+            A = _data.add(gamma[k], A)
+            A = _data.add(gamma[-k], A)
+
+    return A
+
+
+def _floquet_master_equation_tensor(A):
+    """
+    Construct a tensor that represents the master equation in the floquet
+    basis (with constant Hamiltonian and collapse operators?).
+
+    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
+
+    Parameters
+    ----------
+    A : :class:`qutip.data.Data`
+        Floquet-Markov master equation rate matrix.
+
+    Returns
+    -------
+    output : array
+        The Floquet-Markov master equation tensor `R`.
+    """
+    N = A.shape[0]
+
+    # R[i+N*i, j+N*j] = A[j, i]
+    cols = np.arange(N, dtype=np.int32)
+    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
+    data = np.ones(N, dtype=complex)
+    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
+
+    R = expand @ A.transpose() @ expand.transpose()
+
+    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
+    ket_1 = _data.Dense(np.ones(N, dtype=complex))
+    Asum = A @ ket_1
+    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
+    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
+
+    return _data.add(R, S)
+
+
+def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
+    """
+    Construct a tensor that represents the master equation in the floquet
+    basis.
+
+    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
+
+    Parameters
+    ----------
+    H : :class:`QobjEvo`
+        Periodic Hamiltonian
+
+    T : float
+        The period of the time-dependence of the hamiltonian.
+
+    c_ops : list of :class:`qutip.qobj`
+        list of collapse operators.
+
+    spectra_cb : list callback functions
+        List of callback functions that compute the noise power spectrum as
+        a function of frequency for the collapse operators in `c_ops`.
+
+    w_th : float
+        The temperature in units of frequency.
+
+    kmax : int
+        The truncation of the number of sidebands (default 5).
+
+    Returns
+    -------
+    output : array
+        The Floquet-Markov master equation tensor `R`.
+    """
+    if isinstance(H, FloquetBasis):
+        floquet_basis = H
+        T = H.T
+    else:
+        floquet_basis = FloquetBasis(H, T)
+    energy = floquet_basis.e_quasi
+    delta = _floquet_delta_tensor(energy, kmax, T)
+    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
+    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
+    a = _floquet_A_matrix(delta, gamma, w_th)
+    r = _floquet_master_equation_tensor(a)
+    dims = floquet_basis.U(0).dims
+    return Qobj(
+        r, dims=[dims, dims], type="super", superrep="super", copy=False
+    )
+
+
+def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
+    """
+    Solve the Schrodinger equation using the Floquet formalism.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Periodic system Hamiltonian as :class:`QobjEvo`. List of
+        [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    psi0 : :class:`qutip.qobj`
+        Initial state vector (ket). If an operator is provided,
+
+    tlist : *list* / *array*
+        List of times for :math:`t`.
+
+    e_ops : list of :class:`qutip.qobj` / callback function, optional
+        List of operators for which to evaluate expectation values. If this
+        list is empty, the state vectors for each time in `tlist` will be
+        returned instead of expectation values.
+
+    T : float, default=tlist[-1]
+        The period of the time-dependence of the hamiltonian.
+
+    args : dictionary, optional
+        Dictionary with variables required to evaluate H.
+
+    options : dict, optional
+        Options for the results.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+
+    Returns
+    -------
+    output : :class:`qutip.solver.Result`
+        An instance of the class :class:`qutip.solver.Result`, which
+        contains either an *array* of expectation values or an array of
+        state vectors, for the times specified by `tlist`.
+    """
+    if isinstance(H, FloquetBasis):
+        floquet_basis = H
+    else:
+        T = T or tlist[-1]
+        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
+        # are for the open system evolution.
+        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
+
+    f_coeff = floquet_basis.to_floquet_basis(psi0)
+    result_options = {
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+    }
+    result_options.update(options or {})
+    result = Result(e_ops, result_options, solver="fsesolve")
+    for t in tlist:
+        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
+        result.add(t, state_t)
+
+    return result
+
+
+def fmmesolve(
+    H,
+    rho0,
+    tlist,
+    c_ops=None,
+    e_ops=None,
+    spectra_cb=None,
+    T=0,
+    w_th=0.0,
+    args=None,
+    options=None,
+):
+    """
+    Solve the dynamics for the system using the Floquet-Markov master equation.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Periodic system Hamiltonian as :class:`QobjEvo`. List of
+        [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    rho0 / psi0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    tlist : *list* / *array*
+        List of times for :math:`t`.
+
+    c_ops : list of :class:`qutip.Qobj`
+        List of collapse operators. Time dependent collapse operators are not
+        supported.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function
+        List of operators for which to evaluate expectation values.
+        The states are reverted to the lab basis before applying the
+
+    spectra_cb : list callback functions
+        List of callback functions that compute the noise power spectrum as
+        a function of frequency for the collapse operators in `c_ops`.
+
+    T : float
+        The period of the time-dependence of the hamiltonian. The default value
+        'None' indicates that the 'tlist' spans a single period of the driving.
+
+    w_th : float
+        The temperature of the environment in units of frequency.
+        For example, if the Hamiltonian written in units of 2pi GHz, and the
+        temperature is given in K, use the following conversion:
+
+            temperature = 25e-3 # unit K
+            h = 6.626e-34
+            kB = 1.38e-23
+            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
+
+    args : *dictionary*
+        Dictionary of parameters for time-dependent Hamiltonian
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - store_floquet_states : bool
+          Whether or not to store the density matrices in the floquet basis in
+          ``result.floquet_states``.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        the expectation values for the times specified by `tlist`, and/or the
+        state density matrices corresponding to the times.
+    """
+    if c_ops is None:
+        return fsesolve(
+            H,
+            rho0,
+            tlist,
+            e_ops=e_ops,
+            T=T,
+            w_th=w_th,
+            args=args,
+            options=options,
+        )
+
+    if isinstance(H, FloquetBasis):
+        floquet_basis = H
+    else:
+        T = T or tlist[-1]
+        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
+        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
+        # are for the open system evolution.
+        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
+
+    if not w_th and args:
+        w_th = args.get("w_th", 0.0)
+
+    if isinstance(c_ops, Qobj):
+        c_ops = [c_ops]
+
+    if spectra_cb is None:
+        spectra_cb = [lambda w: (w > 0)]
+    elif callable(spectra_cb):
+        spectra_cb = [spectra_cb]
+    if len(spectra_cb) == 1:
+        spectra_cb = spectra_cb * len(c_ops)
+
+    a_ops = list(zip(c_ops, spectra_cb))
+
+    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
+    return solver.run(rho0, tlist, e_ops=e_ops)
+
+
+class FloquetResult(Result):
+    def _post_init(self, floquet_basis):
+        self.floquet_basis = floquet_basis
+        if self.options["store_floquet_states"]:
+            self.floquet_states = []
+        else:
+            self.floquet_states = None
+        super()._post_init()
+
+    def add(self, t, state):
+        if self.options["store_floquet_states"]:
+            self.floquet_states.append(state)
+
+        state = self.floquet_basis.from_floquet_basis(state, t)
+        super().add(t, state)
+
+
+class FMESolver(MESolver):
+    """
+    Solver for the Floquet-Markov master equation.
+
+    .. note ::
+        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
+
+    Parameters
+    ----------
+    floquet_basis : :class:`qutip.FloquetBasis`
+        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
+        different integrator for the ``floquet_basis`` than for the evolution
+        of the floquet state can improve the performance.
+
+    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
+        List of collapse operators and the corresponding function for the noise
+        power spectrum. The collapse operator must be a :class:`Qobj` and
+        cannot be time dependent. The spectrum function must take and return
+        an numpy array.
+
+    w_th : float
+        The temperature of the environment in units of Hamiltonian frequency.
+
+    kmax : int [5]
+        The truncation of the number of sidebands..
+
+    nT : int [20*kmax]
+        The number of integration steps (for calculating X) within one period.
+
+    options : dict, optional
+        Options for the solver, see :obj:`FMESolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+    """
+
+    name = "fmmesolve"
+    _avail_integrators = {}
+    resultclass = FloquetResult
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+        "method": "adams",
+        "store_floquet_states": False,
+    }
+
+    def __init__(
+        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
+    ):
+        self.options = options
+        if isinstance(floquet_basis, FloquetBasis):
+            self.floquet_basis = floquet_basis
+        else:
+            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
+
+        nT = nT or max(100, 20 * kmax)
+        self._num_collapse = len(a_ops)
+        c_ops, spectra_cb = zip(*a_ops)
+        if not all(
+            isinstance(c_op, Qobj) and callable(spectrum)
+            for c_op, spectrum in a_ops
+        ):
+            raise TypeError("a_ops must be tuple of (Qobj, callable)")
+        self.rhs = QobjEvo(
+            floquet_tensor(
+                self.floquet_basis,
+                c_ops,
+                spectra_cb,
+                w_th=w_th,
+                kmax=kmax,
+                nT=nT,
+            )
+        )
+
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+    def _initialize_stats(self):
+        stats = Solver._initialize_stats(self)
+        stats.update(
+            {
+                "solver": "Floquet-Markov master equation",
+                "num_collapse": self._num_collapse,
+            }
+        )
+        return stats
+
+    def _argument(self, args):
+        if args:
+            raise ValueError("FMESolver cannot update arguments")
+
+    def start(self, state0, t0, *, floquet=False):
+        """
+        Set the initial state and time for a step evolution.
+        ``options`` for the evolutions are read at this step.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        t0 : double
+            Initial time of the evolution.
+
+        floquet : bool, optional {False}
+            Whether the initial state is in the floquet basis or laboratory
+            basis.
+        """
+        if not floquet:
+            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
+        super().start(state0, t0)
+
+    def step(self, t, *, args=None, copy=True, floquet=False):
+        """
+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+
+        Parameters
+        ----------
+        t : double
+            Time to evolve to, must be higher than the last call.
+
+        copy : bool, optional {True}
+            Whether to return a copy of the data or the data in the ODE solver.
+
+        floquet : bool, optional {False}
+            Whether to return the state in the floquet basis or laboratory
+            basis.
+
+        args : dict, optional {None}
+            Not supported
+
+        .. note::
+            The state must be initialized first by calling ``start`` or
+            ``run``. If ``run`` is called, ``step`` will continue from the last
+            time and state obtained.
+        """
+        if args:
+            raise ValueError("FMESolver cannot update arguments")
+        state = super().step(t)
+        if not floquet:
+            state = self.floquet_basis.from_floquet_basis(state, t)
+        elif copy:
+            state = state.copy()
+        return state
+
+    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
+        """
+        Calculate the evolution of the quantum system.
+
+        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
+        ``rhs`` and for each time in ``tlist`` store the state and/or
+        expectation values in a :class:`Result`. The evolution method and
+        stored results are determined by ``options``.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        tlist : list of double
+            Time for which to save the results (state and/or expect) of the
+            evolution. The first element of the list is the initial time of the
+            evolution. Each times of the list must be increasing, but does not
+            need to be uniformy distributed.
+
+        floquet : bool, optional {False}
+            Whether the initial state in the floquet basis or laboratory basis.
+
+        args : dict, optional {None}
+            Not supported
+
+        e_ops : list {None}
+            List of Qobj, QobjEvo or callable to compute the expectation
+            values. Function[s] must have the signature
+            f(t : float, state : Qobj) -> expect.
+
+        Returns
+        -------
+        results : :class:`qutip.solver.FloquetResult`
+            Results of the evolution. States and/or expect will be saved. You
+            can control the saved data in the options.
+        """
+        if args:
+            raise ValueError("FMESolver cannot update arguments")
+        if not floquet:
+            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
+        _time_start = time()
+        _data0 = self._prepare_state(state0)
+        self._integrator.set_state(tlist[0], _data0)
+        stats = self._initialize_stats()
+        results = self.resultclass(
+            e_ops,
+            self.options,
+            solver=self.name,
+            stats=stats,
+            floquet_basis=self.floquet_basis,
+        )
+        results.add(tlist[0], self._restore_state(_data0, copy=False))
+        stats["preparation time"] += time() - _time_start
+
+        progress_bar = progess_bars[self.options["progress_bar"]]()
+        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
+        for t, state in self._integrator.run(tlist):
+            progress_bar.update()
+            results.add(t, self._restore_state(state, copy=False))
+        progress_bar.finished()
+
+        stats["run time"] = progress_bar.total_time()
+        # TODO: It would be nice if integrator could give evolution statistics
+        # stats.update(_integrator.stats)
+        return results
diff --git a/qutip/solver/floquet_bwcomp.py b/qutip/solver/floquet_bwcomp.py
index 8ee683ffd8..6937240fda 100644
--- a/qutip/solver/floquet_bwcomp.py
+++ b/qutip/solver/floquet_bwcomp.py
@@ -1,244 +1,244 @@
-""" Floquet solver compatibility functions that behave like the corresponding
-functions from QuTiP 4.7.
-
-These functions are indented to be used when porting code from QuTiP 4.7 to
-QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
-"""
-
-__all__ = [
-    "floquet_modes",
-    "floquet_modes_t",
-    "floquet_modes_table",
-    "floquet_modes_t_lookup",
-    "floquet_states",
-    "floquet_states_t",
-    "floquet_wavefunction",
-    "floquet_wavefunction_t",
-    "floquet_state_decomposition",
-    "floquet_master_equation_rates",
-]
-
-from .floquet import *
-import numpy as np
-import warnings
-
-
-def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
-    """
-    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
-    period T.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
-    f_mode_0 = fbasis.mode(0)
-    f_energies = fbasis.e_quasi
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
-    f_mode_0 = fbasis.mode(0)
-    f_energies = fbasis.e_quasi
-    return f_mode_0, f_energies
-
-
-def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
-    """
-    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
-    initial Floquet modes Phi_alpha(0).
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_mode_t = fbasis.mode(t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    return fbasis.mode(t)
-
-
-def floquet_modes_table(
-    f_modes_0, f_energies, tlist, H, T, args=None, options=None
-):
-    """
-    Pre-calculate the Floquet modes for a range of times spanning the floquet
-    period. Can later be used as a table to look up the floquet modes for
-    any time.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
-    """
-    raise NotImplementedError("`floquet_modes_table` is deprecated.")
-
-
-def floquet_modes_t_lookup(f_modes_table_t, t, T):
-    """
-    Lookup the floquet mode at time t in the pre-calculated table of floquet
-    modes in the first period of the time-dependence.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    f_modes_table_t = fbasis = FloquetBasis(...)
-    f_mode_t = f_modes_table_t.mode(t)
-    """
-    raise NotImplementedError(
-        "`floquet_modes_t_lookup` is no longer provided. "
-        "Use `FloquetBasis` instead."
-    )
-
-
-def floquet_states(f_modes_t, f_energies, t):
-    """
-    Evaluate the floquet states at time t given the Floquet modes at that time.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_state_t = fbasis.state(t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_states` is deprecated. "
-        "Use `FloquetBasis.state` instead."
-    ))
-    return [
-        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
-        for i in np.arange(len(f_energies))
-    ]
-
-
-def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
-    """
-    Evaluate the floquet states at time t given the initial Floquet modes.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_state_t = fbasis.state(t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_states_t` is deprecated. "
-        "Use `FloquetBasis.state` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    return fbasis.state(t)
-
-
-def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
-    """
-    Evaluate the wavefunction for a time t using the Floquet state
-    decompositon, given the Floquet modes at time `t`.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    psi_t = fbasis.from_floquet_basis(f_coeff, t)
-    """
-    raise NotImplementedError(
-        "`floquet_wavefunction` is not longer provided. "
-        "Use `FloquetBasis.from_floquet_basis` instead."
-    )
-
-
-def floquet_wavefunction_t(
-    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
-):
-    """
-    Evaluate the wavefunction for a time t using the Floquet state
-    decompositon, given the initial Floquet modes.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    psi_t = fbasis.from_floquet_basis(f_coeff, t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_wavefunction_t` is deprecated. "
-        "Use `FloquetBasis.from_floquet_basis` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    return fbasis.from_floquet_basis(f_coeff, t)
-
-
-def floquet_state_decomposition(f_states, f_energies, psi):
-    r"""
-    Decompose the wavefunction `psi` (typically an initial state) in terms of
-    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_coeff = fbasis.to_floquet_basis(psi)
-    """
-    raise NotImplementedError(
-        "`floquet_state_decomposition` is deprecated. "
-        "Use `FloquetBasis.to_floquet_basis` instead."
-    )
-
-
-def floquet_master_equation_rates(
-    f_modes_0,
-    f_energies,
-    c_op,
-    H,
-    T,
-    args,
-    J_cb,
-    w_th,
-    kmax=5,
-    f_modes_table_t=None,
-):
-    """
-    Calculate the rates and matrix elements for the Floquet-Markov master
-    equation.
-
-    .. note ::
-
-        Deprecated. For the Floquet-Markov master equation's tensor, use
-        :func:`floquet_tensor`. For the rates matrices, use
-        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
-        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
-
-    Parameters
-    ----------
-    f_modes_0 : Any
-        No longer used.
-    f_energies : Any
-        No longer used.
-    c_op : :class:`qutip.qobj`
-        The collapse operators describing the dissipation.
-    H : :class:`qutip.qobj`
-        System Hamiltonian, time-dependent with period `T`.
-    T : float
-        The period of the time-dependence of the hamiltonian.
-    args : dictionary
-        Dictionary with variables required to evaluate H.
-    J_cb : callback functions
-        A callback function that computes the noise power spectrum, as
-        a function of frequency, associated with the collapse operator `c_op`.
-    w_th : float
-        The temperature in units of frequency.
-    kmax : int, default=5
-        The truncation of the number of sidebands.
-    f_modes_table_t : Any
-        No longer used.
-
-    Returns
-    -------
-    output : list
-        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
-        and A used in the construction of the Floquet-Markov master equation.
-    """
-    warnings.warn(
-        FutureWarning("`floquet_master_equation_rates` is deprecated.")
-    )
-    floquet_basis = FloquetBasis(H, T, args=args)
-    energy = floquet_basis.e_quasi
-    delta = floquet_delta_tensor(energy, kmax, T)
-    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
-    gamma = floquet_gamma_matrices(x, delta, [J_cb])
-    a = floquet_A_matrix(delta, gamma, w_th)
-    return delta, x[0], gamma, a
+""" Floquet solver compatibility functions that behave like the corresponding
+functions from QuTiP 4.7.
+
+These functions are indented to be used when porting code from QuTiP 4.7 to
+QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
+"""
+
+__all__ = [
+    "floquet_modes",
+    "floquet_modes_t",
+    "floquet_modes_table",
+    "floquet_modes_t_lookup",
+    "floquet_states",
+    "floquet_states_t",
+    "floquet_wavefunction",
+    "floquet_wavefunction_t",
+    "floquet_state_decomposition",
+    "floquet_master_equation_rates",
+]
+
+from .floquet import *
+import numpy as np
+import warnings
+
+
+def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
+    """
+    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
+    period T.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
+    f_mode_0 = fbasis.mode(0)
+    f_energies = fbasis.e_quasi
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
+    f_mode_0 = fbasis.mode(0)
+    f_energies = fbasis.e_quasi
+    return f_mode_0, f_energies
+
+
+def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
+    """
+    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
+    initial Floquet modes Phi_alpha(0).
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_mode_t = fbasis.mode(t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    return fbasis.mode(t)
+
+
+def floquet_modes_table(
+    f_modes_0, f_energies, tlist, H, T, args=None, options=None
+):
+    """
+    Pre-calculate the Floquet modes for a range of times spanning the floquet
+    period. Can later be used as a table to look up the floquet modes for
+    any time.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
+    """
+    raise NotImplementedError("`floquet_modes_table` is deprecated.")
+
+
+def floquet_modes_t_lookup(f_modes_table_t, t, T):
+    """
+    Lookup the floquet mode at time t in the pre-calculated table of floquet
+    modes in the first period of the time-dependence.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    f_modes_table_t = fbasis = FloquetBasis(...)
+    f_mode_t = f_modes_table_t.mode(t)
+    """
+    raise NotImplementedError(
+        "`floquet_modes_t_lookup` is no longer provided. "
+        "Use `FloquetBasis` instead."
+    )
+
+
+def floquet_states(f_modes_t, f_energies, t):
+    """
+    Evaluate the floquet states at time t given the Floquet modes at that time.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_state_t = fbasis.state(t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_states` is deprecated. "
+        "Use `FloquetBasis.state` instead."
+    ))
+    return [
+        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
+        for i in np.arange(len(f_energies))
+    ]
+
+
+def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
+    """
+    Evaluate the floquet states at time t given the initial Floquet modes.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_state_t = fbasis.state(t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_states_t` is deprecated. "
+        "Use `FloquetBasis.state` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    return fbasis.state(t)
+
+
+def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
+    """
+    Evaluate the wavefunction for a time t using the Floquet state
+    decompositon, given the Floquet modes at time `t`.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    psi_t = fbasis.from_floquet_basis(f_coeff, t)
+    """
+    raise NotImplementedError(
+        "`floquet_wavefunction` is not longer provided. "
+        "Use `FloquetBasis.from_floquet_basis` instead."
+    )
+
+
+def floquet_wavefunction_t(
+    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
+):
+    """
+    Evaluate the wavefunction for a time t using the Floquet state
+    decompositon, given the initial Floquet modes.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    psi_t = fbasis.from_floquet_basis(f_coeff, t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_wavefunction_t` is deprecated. "
+        "Use `FloquetBasis.from_floquet_basis` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    return fbasis.from_floquet_basis(f_coeff, t)
+
+
+def floquet_state_decomposition(f_states, f_energies, psi):
+    r"""
+    Decompose the wavefunction `psi` (typically an initial state) in terms of
+    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_coeff = fbasis.to_floquet_basis(psi)
+    """
+    raise NotImplementedError(
+        "`floquet_state_decomposition` is deprecated. "
+        "Use `FloquetBasis.to_floquet_basis` instead."
+    )
+
+
+def floquet_master_equation_rates(
+    f_modes_0,
+    f_energies,
+    c_op,
+    H,
+    T,
+    args,
+    J_cb,
+    w_th,
+    kmax=5,
+    f_modes_table_t=None,
+):
+    """
+    Calculate the rates and matrix elements for the Floquet-Markov master
+    equation.
+
+    .. note ::
+
+        Deprecated. For the Floquet-Markov master equation's tensor, use
+        :func:`floquet_tensor`. For the rates matrices, use
+        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
+        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
+
+    Parameters
+    ----------
+    f_modes_0 : Any
+        No longer used.
+    f_energies : Any
+        No longer used.
+    c_op : :class:`qutip.qobj`
+        The collapse operators describing the dissipation.
+    H : :class:`qutip.qobj`
+        System Hamiltonian, time-dependent with period `T`.
+    T : float
+        The period of the time-dependence of the hamiltonian.
+    args : dictionary
+        Dictionary with variables required to evaluate H.
+    J_cb : callback functions
+        A callback function that computes the noise power spectrum, as
+        a function of frequency, associated with the collapse operator `c_op`.
+    w_th : float
+        The temperature in units of frequency.
+    kmax : int, default=5
+        The truncation of the number of sidebands.
+    f_modes_table_t : Any
+        No longer used.
+
+    Returns
+    -------
+    output : list
+        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
+        and A used in the construction of the Floquet-Markov master equation.
+    """
+    warnings.warn(
+        FutureWarning("`floquet_master_equation_rates` is deprecated.")
+    )
+    floquet_basis = FloquetBasis(H, T, args=args)
+    energy = floquet_basis.e_quasi
+    delta = floquet_delta_tensor(energy, kmax, T)
+    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
+    gamma = floquet_gamma_matrices(x, delta, [J_cb])
+    a = floquet_A_matrix(delta, gamma, w_th)
+    return delta, x[0], gamma, a
diff --git a/qutip/solver/heom/__init__.py b/qutip/solver/heom/__init__.py
index 9a8264b073..2ae10e1b41 100644
--- a/qutip/solver/heom/__init__.py
+++ b/qutip/solver/heom/__init__.py
@@ -1,55 +1,55 @@
-"""
-This module provides solvers for system-bath evoluation using the
-HEOM (hierarchy equations of motion).
-
-See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
-basic introduction to the technique.
-
-The implementation is derived from the BoFiN library (see
-https://github.com/tehruhn/bofin) which was itself derived from an earlier
-implementation in QuTiP itself.
-
-For backwards compatibility with QuTiP 4.6 and below, a new version of
-HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
-implemented on top of the new HEOMSolver but should largely be a drop-in
-replacement for the old HSolverDL.
-"""
-
-__all__ = [
-    "BathExponent",
-    "Bath",
-    "BosonicBath",
-    "DrudeLorentzBath",
-    "DrudeLorentzPadeBath",
-    "UnderDampedBath",
-    "FermionicBath",
-    "LorentzianBath",
-    "LorentzianPadeBath",
-    "heomsolve",
-    "HEOMSolver",
-    "HEOMResult",
-    "HSolverDL",
-    "HierarchyADOs",
-    "HierarchyADOsState",
-]
-
-from .bofin_baths import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-)
-
-from .bofin_solvers import (
-    heomsolve,
-    HEOMSolver,
-    HEOMResult,
-    HSolverDL,
-    HierarchyADOs,
-    HierarchyADOsState,
-)
+"""
+This module provides solvers for system-bath evoluation using the
+HEOM (hierarchy equations of motion).
+
+See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
+basic introduction to the technique.
+
+The implementation is derived from the BoFiN library (see
+https://github.com/tehruhn/bofin) which was itself derived from an earlier
+implementation in QuTiP itself.
+
+For backwards compatibility with QuTiP 4.6 and below, a new version of
+HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
+implemented on top of the new HEOMSolver but should largely be a drop-in
+replacement for the old HSolverDL.
+"""
+
+__all__ = [
+    "BathExponent",
+    "Bath",
+    "BosonicBath",
+    "DrudeLorentzBath",
+    "DrudeLorentzPadeBath",
+    "UnderDampedBath",
+    "FermionicBath",
+    "LorentzianBath",
+    "LorentzianPadeBath",
+    "heomsolve",
+    "HEOMSolver",
+    "HEOMResult",
+    "HSolverDL",
+    "HierarchyADOs",
+    "HierarchyADOsState",
+]
+
+from .bofin_baths import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+)
+
+from .bofin_solvers import (
+    heomsolve,
+    HEOMSolver,
+    HEOMResult,
+    HSolverDL,
+    HierarchyADOs,
+    HierarchyADOsState,
+)
diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
index ff64dfc610..0b7f2c2bca 100644
--- a/qutip/solver/heom/bofin_baths.py
+++ b/qutip/solver/heom/bofin_baths.py
@@ -1,982 +1,982 @@
-"""
-This module provides utilities for describing baths when using the
-HEOM (hierarchy equations of motion) to model system-bath interactions.
-
-See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
-
-The implementation is derived from the BoFiN library (see
-https://github.com/tehruhn/bofin) which was itself derived from an earlier
-implementation in QuTiP itself.
-"""
-
-import enum
-
-import numpy as np
-from scipy.linalg import eigvalsh
-
-from qutip.core import data as _data
-from qutip.core.qobj import Qobj
-from qutip.core.superoperator import spre, spost
-
-__all__ = [
-    "BathExponent",
-    "Bath",
-    "BosonicBath",
-    "DrudeLorentzBath",
-    "DrudeLorentzPadeBath",
-    "UnderDampedBath",
-    "FermionicBath",
-    "LorentzianBath",
-    "LorentzianPadeBath",
-]
-
-
-def _isequal(Q1, Q2, tol):
-    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
-    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
-
-
-class BathExponent:
-    """
-    Represents a single exponent (naively, an excitation mode) within the
-    decomposition of the correlation functions of a bath.
-
-    Parameters
-    ----------
-    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
-        The type of bath exponent.
-
-        "R" and "I" are bosonic bath exponents that appear in the real and
-        imaginary parts of the correlation expansion.
-
-        "RI" is combined bosonic bath exponent that appears in both the real
-        and imaginary parts of the correlation expansion. The combined exponent
-        has a single ``vk``. The ``ck`` is the coefficient in the real
-        expansion and ``ck2`` is the coefficient in the imaginary expansion.
-
-        "+" and "-" are fermionic bath exponents. These fermionic bath
-        exponents must specify ``sigma_bar_k_offset`` which specifies
-        the amount to add to ``k`` (the exponent index within the bath of this
-        exponent) to determine the ``k`` of the corresponding exponent with
-        the opposite sign (i.e. "-" or "+").
-
-    dim : int or None
-        The dimension (i.e. maximum number of excitations for this exponent).
-        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
-        bosonic exponents.
-
-    Q : Qobj
-        The coupling operator for this excitation mode.
-
-    vk : complex
-        The frequency of the exponent of the excitation term.
-
-    ck : complex
-        The coefficient of the excitation term.
-
-    ck2 : optional, complex
-        For exponents of type "RI" this is the coefficient of the term in the
-        imaginary expansion (and ``ck`` is the coefficient in the real
-        expansion).
-
-    sigma_bar_k_offset : optional, int
-        For exponents of type "+" this gives the offset (within the list of
-        exponents within the bath) of the corresponding "-" bath exponent.
-        For exponents of type "-" it gives the offset of the corresponding
-        "+" exponent.
-
-    tag : optional, str, tuple or any other object
-        A label for the exponent (often the name of the bath). It
-        defaults to None.
-
-    Attributes
-    ----------
-    fermionic : bool
-        True if the type of the exponent is a Fermionic type (i.e. either
-        "+" or "-") and False otherwise.
-
-    All of the parameters are also available as attributes.
-    """
-    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
-
-    def _check_ck2(self, type, ck2):
-        if type == self.types["RI"]:
-            if ck2 is None:
-                raise ValueError("RI bath exponents require ck2")
-        else:
-            if ck2 is not None:
-                raise ValueError(
-                    "Second co-efficient (ck2) should only be specified for RI"
-                    " bath exponents"
-                )
-
-    def _check_sigma_bar_k_offset(self, type, offset):
-        if type in (self.types["+"], self.types["-"]):
-            if offset is None:
-                raise ValueError(
-                    "+ and - bath exponents require sigma_bar_k_offset"
-                )
-        else:
-            if offset is not None:
-                raise ValueError(
-                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
-                    " specified for + and - bath exponents"
-                )
-
-    def _type_is_fermionic(self, type):
-        return type in (self.types["+"], self.types["-"])
-
-    def __init__(
-            self, type, dim, Q, ck, vk, ck2=None,
-            sigma_bar_k_offset=None, tag=None,
-    ):
-        if not isinstance(type, self.types):
-            type = self.types[type]
-        self._check_ck2(type, ck2)
-        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
-        self.type = type
-        self.fermionic = self._type_is_fermionic(type)
-        self.dim = dim
-        self.Q = Q
-        self.ck = ck
-        self.vk = vk
-        self.ck2 = ck2
-        self.sigma_bar_k_offset = sigma_bar_k_offset
-        self.tag = tag
-
-    def __repr__(self):
-        dims = getattr(self.Q, "dims", None)
-        return (
-            f"<{self.__class__.__name__} type={self.type.name}"
-            f" dim={self.dim!r}"
-            f" Q.dims={dims!r}"
-            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
-            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
-            f" fermionic={self.fermionic!r}"
-            f" tag={self.tag!r}>"
-        )
-
-
-class Bath:
-    """
-    Represents a list of bath expansion exponents.
-
-    Parameters
-    ----------
-    exponents : list of BathExponent
-        The exponents of the correlation function describing the bath.
-
-    Attributes
-    ----------
-
-    All of the parameters are available as attributes.
-    """
-    def __init__(self, exponents):
-        self.exponents = exponents
-
-
-class BosonicBath(Bath):
-    """
-    A helper class for constructing a bosonic bath from the expansion
-    coefficients and frequencies for the real and imaginary parts of
-    the bath correlation function.
-
-    If the correlation functions ``C(t)`` is split into real and imaginary
-    parts::
-
-        C(t) = C_real(t) + i * C_imag(t)
-
-    then::
-
-        C_real(t) = sum(ck_real * exp(- vk_real * t))
-        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
-
-    Defines the coefficients ``ck`` and the frequencies ``vk``.
-
-    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
-    and ``C_imag(t)`` (i.e. the sum) is real.
-
-    Parameters
-    ----------
-    Q : Qobj
-        The coupling operator for the bath.
-
-    ck_real : list of complex
-        The coefficients of the expansion terms for the real part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_real.
-
-    vk_real : list of complex
-        The frequencies (exponents) of the expansion terms for the real part of
-        the correlation function. The corresponding ceofficients are passed as
-        ck_real.
-
-    ck_imag : list of complex
-        The coefficients of the expansion terms in the imaginary part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_imag.
-
-    vk_imag : list of complex
-        The frequencies (exponents) of the expansion terms for the imaginary
-        part of the correlation function. The corresponding ceofficients are
-        passed as ck_imag.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
-        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
-            raise ValueError(
-                "The bath exponent lists ck_real and vk_real, and ck_imag and"
-                " vk_imag must be the same length."
-            )
-
-    def _check_coup_op(self, Q):
-        if not isinstance(Q, Qobj):
-            raise ValueError("The coupling operator Q must be a Qobj.")
-
-    def __init__(
-            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
-            tag=None,
-    ):
-        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
-        self._check_coup_op(Q)
-
-        exponents = []
-        exponents.extend(
-            BathExponent("R", None, Q, ck, vk, tag=tag)
-            for ck, vk in zip(ck_real, vk_real)
-        )
-        exponents.extend(
-            BathExponent("I", None, Q, ck, vk, tag=tag)
-            for ck, vk in zip(ck_imag, vk_imag)
-        )
-
-        if combine:
-            exponents = self.combine(exponents)
-
-        super().__init__(exponents)
-
-    @classmethod
-    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
-        """
-        Group bosonic exponents with the same frequency and return a
-        single exponent for each frequency present.
-
-        Exponents with the same frequency are only combined if they share the
-        same coupling operator ``.Q``.
-
-        Note that combined exponents take their tag from the first
-        exponent in the group being combined (i.e. the one that occurs first
-        in the given exponents list).
-
-        Parameters
-        ----------
-        exponents : list of BathExponent
-            The list of exponents to combine.
-
-        rtol : float, default 1e-5
-            The relative tolerance to use to when comparing frequencies and
-            coupling operators.
-
-        atol : float, default 1e-7
-            The absolute tolerance to use to when comparing frequencies and
-            coupling operators.
-
-        Returns
-        -------
-        list of BathExponent
-            The new reduced list of exponents.
-        """
-        groups = []
-        remaining = exponents[:]
-
-        while remaining:
-            e1 = remaining.pop(0)
-            group = [e1]
-            for e2 in remaining[:]:
-                if (
-                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
-                    _isequal(e1.Q, e2.Q, tol=atol)
-                ):
-                    group.append(e2)
-                    remaining.remove(e2)
-            groups.append(group)
-
-        new_exponents = []
-        for combine in groups:
-            exp1 = combine[0]
-            if (exp1.type != exp1.types.RI) and all(
-                exp2.type == exp1.type for exp2 in combine
-            ):
-                # the group is either type I or R
-                ck = sum(exp.ck for exp in combine)
-                new_exponents.append(BathExponent(
-                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
-                ))
-            else:
-                # the group includes both type I and R exponents
-                ck_R = (
-                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
-                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
-                )
-                ck_I = (
-                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
-                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
-                )
-                new_exponents.append(BathExponent(
-                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
-                    tag=exp1.tag,
-                ))
-
-        return new_exponents
-
-
-class DrudeLorentzBath(BosonicBath):
-    """
-    A helper class for constructing a Drude-Lorentz bosonic bath from the
-    bath parameters (see parameters below).
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    lam : float
-        Coupling strength.
-
-    gamma : float
-        Bath spectral density cutoff frequency.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(
-        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
-    ):
-        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
-            lam=lam,
-            gamma=gamma,
-            T=T,
-            Nk=Nk,
-        )
-
-        super().__init__(
-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-        )
-
-        self._dl_terminator = _DrudeLorentzTerminator(
-            Q=Q, lam=lam, gamma=gamma, T=T,
-        )
-
-    def terminator(self):
-        """
-        Return the Matsubara terminator for the bath and the calculated
-        approximation discrepancy.
-
-        Returns
-        -------
-        delta: float
-
-            The approximation discrepancy. That is, the difference between the
-            true correlation function of the Drude-Lorentz bath and the sum of
-            the ``Nk`` exponential terms is approximately ``2 * delta *
-            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
-
-        terminator : Qobj
-
-            The Matsubara terminator -- i.e. a liouvillian term representing
-            the contribution to the system-bath dynamics of all exponential
-            expansion terms beyond ``Nk``. It should be used by adding it to
-            the system liouvillian (i.e. ``liouvillian(H_sys)``).
-        """
-        delta, L = self._dl_terminator.terminator(self.exponents)
-        return delta, L
-
-    def _matsubara_params(self, lam, gamma, T, Nk):
-        """ Calculate the Matsubara coefficents and frequencies. """
-        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
-        ck_real.extend([
-            (8 * lam * gamma * T * np.pi * k * T /
-                ((2 * np.pi * k * T)**2 - gamma**2))
-            for k in range(1, Nk + 1)
-        ])
-        vk_real = [gamma]
-        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
-
-        ck_imag = [lam * gamma * (-1.0)]
-        vk_imag = [gamma]
-
-        return ck_real, vk_real, ck_imag, vk_imag
-
-
-class DrudeLorentzPadeBath(BosonicBath):
-    """
-    A helper class for constructing a Padé expansion for a Drude-Lorentz
-    bosonic bath from the bath parameters (see parameters below).
-
-    A Padé approximant is a sum-over-poles expansion (
-    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
-
-    The application of the Padé method to spectrum decompoisitions is described
-    in "Padé spectrum decompositions of quantum distribution functions and
-    optimal hierarchical equations of motion construction for quantum open
-    systems" [1].
-
-    The implementation here follows the approach in the paper.
-
-    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
-
-    This is an alternative to the :class:`DrudeLorentzBath` which constructs
-    a simpler exponential expansion.
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    lam : float
-        Coupling strength.
-
-    gamma : float
-        Bath spectral density cutoff frequency.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of Padé exponentials terms used to approximate the bath
-        correlation functions.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(
-        self, Q, lam, gamma, T, Nk, combine=True, tag=None
-    ):
-        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
-
-        ck_real = [np.real(eta) for eta in eta_p]
-        vk_real = [gam for gam in gamma_p]
-        # There is only one term in the expansion of the imaginary part of the
-        # Drude-Lorentz correlation function.
-        ck_imag = [np.imag(eta_p[0])]
-        vk_imag = [gamma_p[0]]
-
-        super().__init__(
-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-        )
-
-        self._dl_terminator = _DrudeLorentzTerminator(
-            Q=Q, lam=lam, gamma=gamma, T=T,
-        )
-
-    def terminator(self):
-        """
-        Return the Padé terminator for the bath and the calculated
-        approximation discrepancy.
-
-        Returns
-        -------
-        delta: float
-
-            The approximation discrepancy. That is, the difference between the
-            true correlation function of the Drude-Lorentz bath and the sum of
-            the ``Nk`` exponential terms is approximately ``2 * delta *
-            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
-
-        terminator : Qobj
-
-            The Padé terminator -- i.e. a liouvillian term representing
-            the contribution to the system-bath dynamics of all exponential
-            expansion terms beyond ``Nk``. It should be used by adding it to
-            the system liouvillian (i.e. ``liouvillian(H_sys)``).
-        """
-        delta, L = self._dl_terminator.terminator(self.exponents)
-        return delta, L
-
-    def _corr(self, lam, gamma, T, Nk):
-        beta = 1. / T
-        kappa, epsilon = self._kappa_epsilon(Nk)
-
-        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
-        gamma_p = [gamma]
-
-        for ll in range(1, Nk + 1):
-            eta_p.append(
-                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
-                / ((epsilon[ll]**2 / beta**2) - gamma**2)
-            )
-            gamma_p.append(epsilon[ll] / beta)
-
-        return eta_p, gamma_p
-
-    def _cot(self, x):
-        return 1. / np.tan(x)
-
-    def _kappa_epsilon(self, Nk):
-        eps = self._calc_eps(Nk)
-        chi = self._calc_chi(Nk)
-
-        kappa = [0]
-        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
-        for j in range(Nk):
-            term = prefactor
-            for k in range(Nk - 1):
-                term *= (
-                    (chi[k]**2 - eps[j]**2) /
-                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-                )
-            for k in [Nk - 1]:
-                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-            kappa.append(term)
-
-        epsilon = [0] + eps
-
-        return kappa, epsilon
-
-    def _delta(self, i, j):
-        return 1.0 if i == j else 0.0
-
-    def _calc_eps(self, Nk):
-        alpha = np.diag([
-                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
-                for k in range(2 * Nk - 1)
-        ], k=1)
-        alpha += alpha.transpose()
-        evals = eigvalsh(alpha)
-        eps = [-2. / val for val in evals[0: Nk]]
-        return eps
-
-    def _calc_chi(self, Nk):
-        alpha_p = np.diag([
-                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
-                for k in range(2 * Nk - 2)
-        ], k=1)
-        alpha_p += alpha_p.transpose()
-        evals = eigvalsh(alpha_p)
-        chi = [-2. / val for val in evals[0: Nk - 1]]
-        return chi
-
-
-class _DrudeLorentzTerminator:
-    """ A class for calculating the terminator of a Drude-Lorentz bath
-        expansion.
-    """
-    def __init__(self, Q, lam, gamma, T):
-        self.Q = Q
-        self.lam = lam
-        self.gamma = gamma
-        self.T = T
-
-    def terminator(self, exponents):
-        """ Calculate the terminator for a Drude-Lorentz bath. """
-        Q = self.Q
-        lam = self.lam
-        gamma = self.gamma
-        beta = 1 / self.T
-
-        delta = 2 * lam / (beta * gamma) - 1j * lam
-
-        for exp in exponents:
-            if exp.type == BathExponent.types["R"]:
-                delta -= exp.ck / exp.vk
-            elif exp.type == BathExponent.types["RI"]:
-                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
-            else:
-                delta -= 1j * exp.ck / exp.vk
-
-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-        L_bnd = -delta * op
-
-        return delta, L_bnd
-
-
-class UnderDampedBath(BosonicBath):
-    """
-    A helper class for constructing an under-damped bosonic bath from the
-    bath parameters (see parameters below).
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    lam : float
-        Coupling strength.
-
-    gamma : float
-        Bath spectral density cutoff frequency.
-
-    w0 : float
-        Bath spectral density resonance frequency.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(
-        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
-    ):
-        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
-            lam=lam,
-            gamma=gamma,
-            w0=w0,
-            T=T,
-            Nk=Nk,
-        )
-
-        super().__init__(
-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-        )
-
-    def _matsubara_params(self, lam, gamma, w0, T, Nk):
-        """ Calculate the Matsubara coefficents and frequencies. """
-        beta = 1/T
-        Om = np.sqrt(w0**2 - (gamma/2)**2)
-        Gamma = gamma/2.
-
-        ck_real = ([
-            (lam**2 / (4 * Om))
-            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
-            (lam**2 / (4*Om))
-            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
-        ])
-
-        ck_real.extend([
-            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
-            / (
-                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
-                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
-            )
-            for k in range(1, Nk + 1)
-        ])
-
-        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
-        vk_real.extend([
-            2 * np.pi * k * T
-            for k in range(1, Nk + 1)
-        ])
-
-        ck_imag = [
-            1.0j * lam**2 / (4 * Om),
-            -1.0j * lam**2 / (4 * Om),
-        ]
-
-        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
-
-        return ck_real, vk_real, ck_imag, vk_imag
-
-
-class FermionicBath(Bath):
-    """
-    A helper class for constructing a fermionic bath from the expansion
-    coefficients and frequencies for the ``+`` and ``-`` modes of
-    the bath correlation function.
-
-    There must be the same number of ``+`` and ``-`` modes and their
-    coefficients must be specified in the same order so that ``ck_plus[i],
-    vk_plus[i]`` are the plus coefficient and frequency corresponding
-    to the minus mode ``ck_minus[i], vk_minus[i]``.
-
-    In the fermionic case the order in which excitations are created or
-    destroyed is important, resulting in two different correlation functions
-    labelled ``C_plus(t)`` and ``C_plus(t)``::
-
-        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
-        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
-
-    where the expansions above define the coeffiients ``ck`` and the
-    frequencies ``vk``.
-
-    Parameters
-    ----------
-    Q : Qobj
-        The coupling operator for the bath.
-
-    ck_plus : list of complex
-        The coefficients of the expansion terms for the ``+`` part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_plus.
-
-    vk_plus : list of complex
-        The frequencies (exponents) of the expansion terms for the ``+`` part
-        of the correlation function. The corresponding ceofficients are passed
-        as ck_plus.
-
-    ck_minus : list of complex
-        The coefficients of the expansion terms for the ``-`` part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_minus.
-
-    vk_minus : list of complex
-        The frequencies (exponents) of the expansion terms for the ``-`` part
-        of the correlation function. The corresponding ceofficients are passed
-        as ck_minus.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-
-    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
-        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
-            raise ValueError(
-                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-                " vk_minus must be the same length."
-            )
-        if len(ck_plus) != len(ck_minus):
-            raise ValueError(
-                "The must be the same number of plus and minus exponents"
-                " in the bath, and elements of plus and minus arrays"
-                " should be arranged so that ck_plus[i] is the plus mode"
-                " corresponding to ck_minus[i]."
-            )
-
-    def _check_coup_op(self, Q):
-        if not isinstance(Q, Qobj):
-            raise ValueError("The coupling operator Q must be a Qobj.")
-
-    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
-        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
-        self._check_coup_op(Q)
-
-        exponents = []
-        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
-            exponents.append(BathExponent(
-                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
-            ))
-            exponents.append(BathExponent(
-                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
-            ))
-        super().__init__(exponents)
-
-
-class LorentzianBath(FermionicBath):
-    """
-    A helper class for constructing a Lorentzian fermionic bath from the
-    bath parameters (see parameters below).
-
-    .. note::
-
-        This Matsubara expansion used in this bath converges very slowly
-        and ``Nk > 20`` may be required to get good convergence. The
-        Padé expansion used by :class:`LorentzianPadeBath` converges much
-        more quickly.
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    gamma : float
-        The coupling strength between the system and the bath.
-
-    w : float
-        The width of the environment.
-
-    mu : float
-        The chemical potential of the bath.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
-        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
-        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
-
-        super().__init__(
-            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
-        )
-
-    def _corr(self, gamma, w, mu, T, Nk, sigma):
-        beta = 1. / T
-        kappa = [0.]
-        kappa.extend([1. for _ in range(1, Nk + 1)])
-        epsilon = [0]
-        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
-
-        def f(x):
-            return 1 / (np.exp(x) + 1)
-
-        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
-        gamma_list = [w - sigma * 1.0j * mu]
-
-        for ll in range(1, Nk + 1):
-            eta_list.append(
-                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
-                (-(epsilon[ll]**2 / beta**2) + w**2)
-            )
-            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
-
-        return eta_list, gamma_list
-
-
-class LorentzianPadeBath(FermionicBath):
-    """
-    A helper class for constructing a Padé expansion for Lorentzian fermionic
-    bath from the bath parameters (see parameters below).
-
-    A Padé approximant is a sum-over-poles expansion (
-    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
-
-    The application of the Padé method to spectrum decompoisitions is described
-    in "Padé spectrum decompositions of quantum distribution functions and
-    optimal hierarchical equations of motion construction for quantum open
-    systems" [1].
-
-    The implementation here follows the approach in the paper.
-
-    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
-
-    This is an alternative to the :class:`LorentzianBath` which constructs
-    a simpler exponential expansion that converges much more slowly in
-    this particular case.
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    gamma : float
-        The coupling strength between the system and the bath.
-
-    w : float
-        The width of the environment.
-
-    mu : float
-        The chemical potential of the bath.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
-        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
-        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
-
-        super().__init__(
-            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
-        )
-
-    def _corr(self, gamma, w, mu, T, Nk, sigma):
-        beta = 1. / T
-        kappa, epsilon = self._kappa_epsilon(Nk)
-
-        def f_approx(x):
-            f = 0.5
-            for ll in range(1, Nk + 1):
-                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
-            return f
-
-        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
-        gamma_list = [w - sigma * 1.0j * mu]
-
-        for ll in range(1, Nk + 1):
-            eta_list.append(
-                -1.0j * (kappa[ll] / beta) * gamma * w**2
-                / (-(epsilon[ll]**2 / beta**2) + w**2)
-            )
-            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
-
-        return eta_list, gamma_list
-
-    def _kappa_epsilon(self, Nk):
-        eps = self._calc_eps(Nk)
-        chi = self._calc_chi(Nk)
-
-        kappa = [0]
-        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
-        for j in range(Nk):
-            term = prefactor
-            for k in range(Nk - 1):
-                term *= (
-                    (chi[k]**2 - eps[j]**2) /
-                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-                )
-            for k in [Nk - 1]:
-                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-            kappa.append(term)
-
-        epsilon = [0] + eps
-
-        return kappa, epsilon
-
-    def _delta(self, i, j):
-        return 1.0 if i == j else 0.0
-
-    def _calc_eps(self, Nk):
-        alpha = np.diag([
-                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
-                for k in range(2 * Nk - 1)
-        ], k=1)
-        alpha += alpha.transpose()
-
-        evals = eigvalsh(alpha)
-        eps = [-2. / val for val in evals[0: Nk]]
-        return eps
-
-    def _calc_chi(self, Nk):
-        alpha_p = np.diag([
-                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
-                for k in range(2 * Nk - 2)
-        ], k=1)
-        alpha_p += alpha_p.transpose()
-        evals = eigvalsh(alpha_p)
-        chi = [-2. / val for val in evals[0: Nk - 1]]
-        return chi
+"""
+This module provides utilities for describing baths when using the
+HEOM (hierarchy equations of motion) to model system-bath interactions.
+
+See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
+
+The implementation is derived from the BoFiN library (see
+https://github.com/tehruhn/bofin) which was itself derived from an earlier
+implementation in QuTiP itself.
+"""
+
+import enum
+
+import numpy as np
+from scipy.linalg import eigvalsh
+
+from qutip.core import data as _data
+from qutip.core.qobj import Qobj
+from qutip.core.superoperator import spre, spost
+
+__all__ = [
+    "BathExponent",
+    "Bath",
+    "BosonicBath",
+    "DrudeLorentzBath",
+    "DrudeLorentzPadeBath",
+    "UnderDampedBath",
+    "FermionicBath",
+    "LorentzianBath",
+    "LorentzianPadeBath",
+]
+
+
+def _isequal(Q1, Q2, tol):
+    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
+    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
+
+
+class BathExponent:
+    """
+    Represents a single exponent (naively, an excitation mode) within the
+    decomposition of the correlation functions of a bath.
+
+    Parameters
+    ----------
+    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
+        The type of bath exponent.
+
+        "R" and "I" are bosonic bath exponents that appear in the real and
+        imaginary parts of the correlation expansion.
+
+        "RI" is combined bosonic bath exponent that appears in both the real
+        and imaginary parts of the correlation expansion. The combined exponent
+        has a single ``vk``. The ``ck`` is the coefficient in the real
+        expansion and ``ck2`` is the coefficient in the imaginary expansion.
+
+        "+" and "-" are fermionic bath exponents. These fermionic bath
+        exponents must specify ``sigma_bar_k_offset`` which specifies
+        the amount to add to ``k`` (the exponent index within the bath of this
+        exponent) to determine the ``k`` of the corresponding exponent with
+        the opposite sign (i.e. "-" or "+").
+
+    dim : int or None
+        The dimension (i.e. maximum number of excitations for this exponent).
+        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
+        bosonic exponents.
+
+    Q : Qobj
+        The coupling operator for this excitation mode.
+
+    vk : complex
+        The frequency of the exponent of the excitation term.
+
+    ck : complex
+        The coefficient of the excitation term.
+
+    ck2 : optional, complex
+        For exponents of type "RI" this is the coefficient of the term in the
+        imaginary expansion (and ``ck`` is the coefficient in the real
+        expansion).
+
+    sigma_bar_k_offset : optional, int
+        For exponents of type "+" this gives the offset (within the list of
+        exponents within the bath) of the corresponding "-" bath exponent.
+        For exponents of type "-" it gives the offset of the corresponding
+        "+" exponent.
+
+    tag : optional, str, tuple or any other object
+        A label for the exponent (often the name of the bath). It
+        defaults to None.
+
+    Attributes
+    ----------
+    fermionic : bool
+        True if the type of the exponent is a Fermionic type (i.e. either
+        "+" or "-") and False otherwise.
+
+    All of the parameters are also available as attributes.
+    """
+    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
+
+    def _check_ck2(self, type, ck2):
+        if type == self.types["RI"]:
+            if ck2 is None:
+                raise ValueError("RI bath exponents require ck2")
+        else:
+            if ck2 is not None:
+                raise ValueError(
+                    "Second co-efficient (ck2) should only be specified for RI"
+                    " bath exponents"
+                )
+
+    def _check_sigma_bar_k_offset(self, type, offset):
+        if type in (self.types["+"], self.types["-"]):
+            if offset is None:
+                raise ValueError(
+                    "+ and - bath exponents require sigma_bar_k_offset"
+                )
+        else:
+            if offset is not None:
+                raise ValueError(
+                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
+                    " specified for + and - bath exponents"
+                )
+
+    def _type_is_fermionic(self, type):
+        return type in (self.types["+"], self.types["-"])
+
+    def __init__(
+            self, type, dim, Q, ck, vk, ck2=None,
+            sigma_bar_k_offset=None, tag=None,
+    ):
+        if not isinstance(type, self.types):
+            type = self.types[type]
+        self._check_ck2(type, ck2)
+        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
+        self.type = type
+        self.fermionic = self._type_is_fermionic(type)
+        self.dim = dim
+        self.Q = Q
+        self.ck = ck
+        self.vk = vk
+        self.ck2 = ck2
+        self.sigma_bar_k_offset = sigma_bar_k_offset
+        self.tag = tag
+
+    def __repr__(self):
+        dims = getattr(self.Q, "dims", None)
+        return (
+            f"<{self.__class__.__name__} type={self.type.name}"
+            f" dim={self.dim!r}"
+            f" Q.dims={dims!r}"
+            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
+            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
+            f" fermionic={self.fermionic!r}"
+            f" tag={self.tag!r}>"
+        )
+
+
+class Bath:
+    """
+    Represents a list of bath expansion exponents.
+
+    Parameters
+    ----------
+    exponents : list of BathExponent
+        The exponents of the correlation function describing the bath.
+
+    Attributes
+    ----------
+
+    All of the parameters are available as attributes.
+    """
+    def __init__(self, exponents):
+        self.exponents = exponents
+
+
+class BosonicBath(Bath):
+    """
+    A helper class for constructing a bosonic bath from the expansion
+    coefficients and frequencies for the real and imaginary parts of
+    the bath correlation function.
+
+    If the correlation functions ``C(t)`` is split into real and imaginary
+    parts::
+
+        C(t) = C_real(t) + i * C_imag(t)
+
+    then::
+
+        C_real(t) = sum(ck_real * exp(- vk_real * t))
+        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
+
+    Defines the coefficients ``ck`` and the frequencies ``vk``.
+
+    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
+    and ``C_imag(t)`` (i.e. the sum) is real.
+
+    Parameters
+    ----------
+    Q : Qobj
+        The coupling operator for the bath.
+
+    ck_real : list of complex
+        The coefficients of the expansion terms for the real part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_real.
+
+    vk_real : list of complex
+        The frequencies (exponents) of the expansion terms for the real part of
+        the correlation function. The corresponding ceofficients are passed as
+        ck_real.
+
+    ck_imag : list of complex
+        The coefficients of the expansion terms in the imaginary part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_imag.
+
+    vk_imag : list of complex
+        The frequencies (exponents) of the expansion terms for the imaginary
+        part of the correlation function. The corresponding ceofficients are
+        passed as ck_imag.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
+        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
+            raise ValueError(
+                "The bath exponent lists ck_real and vk_real, and ck_imag and"
+                " vk_imag must be the same length."
+            )
+
+    def _check_coup_op(self, Q):
+        if not isinstance(Q, Qobj):
+            raise ValueError("The coupling operator Q must be a Qobj.")
+
+    def __init__(
+            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
+            tag=None,
+    ):
+        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
+        self._check_coup_op(Q)
+
+        exponents = []
+        exponents.extend(
+            BathExponent("R", None, Q, ck, vk, tag=tag)
+            for ck, vk in zip(ck_real, vk_real)
+        )
+        exponents.extend(
+            BathExponent("I", None, Q, ck, vk, tag=tag)
+            for ck, vk in zip(ck_imag, vk_imag)
+        )
+
+        if combine:
+            exponents = self.combine(exponents)
+
+        super().__init__(exponents)
+
+    @classmethod
+    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
+        """
+        Group bosonic exponents with the same frequency and return a
+        single exponent for each frequency present.
+
+        Exponents with the same frequency are only combined if they share the
+        same coupling operator ``.Q``.
+
+        Note that combined exponents take their tag from the first
+        exponent in the group being combined (i.e. the one that occurs first
+        in the given exponents list).
+
+        Parameters
+        ----------
+        exponents : list of BathExponent
+            The list of exponents to combine.
+
+        rtol : float, default 1e-5
+            The relative tolerance to use to when comparing frequencies and
+            coupling operators.
+
+        atol : float, default 1e-7
+            The absolute tolerance to use to when comparing frequencies and
+            coupling operators.
+
+        Returns
+        -------
+        list of BathExponent
+            The new reduced list of exponents.
+        """
+        groups = []
+        remaining = exponents[:]
+
+        while remaining:
+            e1 = remaining.pop(0)
+            group = [e1]
+            for e2 in remaining[:]:
+                if (
+                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
+                    _isequal(e1.Q, e2.Q, tol=atol)
+                ):
+                    group.append(e2)
+                    remaining.remove(e2)
+            groups.append(group)
+
+        new_exponents = []
+        for combine in groups:
+            exp1 = combine[0]
+            if (exp1.type != exp1.types.RI) and all(
+                exp2.type == exp1.type for exp2 in combine
+            ):
+                # the group is either type I or R
+                ck = sum(exp.ck for exp in combine)
+                new_exponents.append(BathExponent(
+                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
+                ))
+            else:
+                # the group includes both type I and R exponents
+                ck_R = (
+                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
+                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
+                )
+                ck_I = (
+                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
+                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
+                )
+                new_exponents.append(BathExponent(
+                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
+                    tag=exp1.tag,
+                ))
+
+        return new_exponents
+
+
+class DrudeLorentzBath(BosonicBath):
+    """
+    A helper class for constructing a Drude-Lorentz bosonic bath from the
+    bath parameters (see parameters below).
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    lam : float
+        Coupling strength.
+
+    gamma : float
+        Bath spectral density cutoff frequency.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(
+        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
+    ):
+        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
+            lam=lam,
+            gamma=gamma,
+            T=T,
+            Nk=Nk,
+        )
+
+        super().__init__(
+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+        )
+
+        self._dl_terminator = _DrudeLorentzTerminator(
+            Q=Q, lam=lam, gamma=gamma, T=T,
+        )
+
+    def terminator(self):
+        """
+        Return the Matsubara terminator for the bath and the calculated
+        approximation discrepancy.
+
+        Returns
+        -------
+        delta: float
+
+            The approximation discrepancy. That is, the difference between the
+            true correlation function of the Drude-Lorentz bath and the sum of
+            the ``Nk`` exponential terms is approximately ``2 * delta *
+            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
+
+        terminator : Qobj
+
+            The Matsubara terminator -- i.e. a liouvillian term representing
+            the contribution to the system-bath dynamics of all exponential
+            expansion terms beyond ``Nk``. It should be used by adding it to
+            the system liouvillian (i.e. ``liouvillian(H_sys)``).
+        """
+        delta, L = self._dl_terminator.terminator(self.exponents)
+        return delta, L
+
+    def _matsubara_params(self, lam, gamma, T, Nk):
+        """ Calculate the Matsubara coefficents and frequencies. """
+        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
+        ck_real.extend([
+            (8 * lam * gamma * T * np.pi * k * T /
+                ((2 * np.pi * k * T)**2 - gamma**2))
+            for k in range(1, Nk + 1)
+        ])
+        vk_real = [gamma]
+        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
+
+        ck_imag = [lam * gamma * (-1.0)]
+        vk_imag = [gamma]
+
+        return ck_real, vk_real, ck_imag, vk_imag
+
+
+class DrudeLorentzPadeBath(BosonicBath):
+    """
+    A helper class for constructing a Padé expansion for a Drude-Lorentz
+    bosonic bath from the bath parameters (see parameters below).
+
+    A Padé approximant is a sum-over-poles expansion (
+    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
+
+    The application of the Padé method to spectrum decompoisitions is described
+    in "Padé spectrum decompositions of quantum distribution functions and
+    optimal hierarchical equations of motion construction for quantum open
+    systems" [1].
+
+    The implementation here follows the approach in the paper.
+
+    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
+
+    This is an alternative to the :class:`DrudeLorentzBath` which constructs
+    a simpler exponential expansion.
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    lam : float
+        Coupling strength.
+
+    gamma : float
+        Bath spectral density cutoff frequency.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of Padé exponentials terms used to approximate the bath
+        correlation functions.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(
+        self, Q, lam, gamma, T, Nk, combine=True, tag=None
+    ):
+        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
+
+        ck_real = [np.real(eta) for eta in eta_p]
+        vk_real = [gam for gam in gamma_p]
+        # There is only one term in the expansion of the imaginary part of the
+        # Drude-Lorentz correlation function.
+        ck_imag = [np.imag(eta_p[0])]
+        vk_imag = [gamma_p[0]]
+
+        super().__init__(
+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+        )
+
+        self._dl_terminator = _DrudeLorentzTerminator(
+            Q=Q, lam=lam, gamma=gamma, T=T,
+        )
+
+    def terminator(self):
+        """
+        Return the Padé terminator for the bath and the calculated
+        approximation discrepancy.
+
+        Returns
+        -------
+        delta: float
+
+            The approximation discrepancy. That is, the difference between the
+            true correlation function of the Drude-Lorentz bath and the sum of
+            the ``Nk`` exponential terms is approximately ``2 * delta *
+            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
+
+        terminator : Qobj
+
+            The Padé terminator -- i.e. a liouvillian term representing
+            the contribution to the system-bath dynamics of all exponential
+            expansion terms beyond ``Nk``. It should be used by adding it to
+            the system liouvillian (i.e. ``liouvillian(H_sys)``).
+        """
+        delta, L = self._dl_terminator.terminator(self.exponents)
+        return delta, L
+
+    def _corr(self, lam, gamma, T, Nk):
+        beta = 1. / T
+        kappa, epsilon = self._kappa_epsilon(Nk)
+
+        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
+        gamma_p = [gamma]
+
+        for ll in range(1, Nk + 1):
+            eta_p.append(
+                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
+                / ((epsilon[ll]**2 / beta**2) - gamma**2)
+            )
+            gamma_p.append(epsilon[ll] / beta)
+
+        return eta_p, gamma_p
+
+    def _cot(self, x):
+        return 1. / np.tan(x)
+
+    def _kappa_epsilon(self, Nk):
+        eps = self._calc_eps(Nk)
+        chi = self._calc_chi(Nk)
+
+        kappa = [0]
+        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
+        for j in range(Nk):
+            term = prefactor
+            for k in range(Nk - 1):
+                term *= (
+                    (chi[k]**2 - eps[j]**2) /
+                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+                )
+            for k in [Nk - 1]:
+                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+            kappa.append(term)
+
+        epsilon = [0] + eps
+
+        return kappa, epsilon
+
+    def _delta(self, i, j):
+        return 1.0 if i == j else 0.0
+
+    def _calc_eps(self, Nk):
+        alpha = np.diag([
+                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
+                for k in range(2 * Nk - 1)
+        ], k=1)
+        alpha += alpha.transpose()
+        evals = eigvalsh(alpha)
+        eps = [-2. / val for val in evals[0: Nk]]
+        return eps
+
+    def _calc_chi(self, Nk):
+        alpha_p = np.diag([
+                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
+                for k in range(2 * Nk - 2)
+        ], k=1)
+        alpha_p += alpha_p.transpose()
+        evals = eigvalsh(alpha_p)
+        chi = [-2. / val for val in evals[0: Nk - 1]]
+        return chi
+
+
+class _DrudeLorentzTerminator:
+    """ A class for calculating the terminator of a Drude-Lorentz bath
+        expansion.
+    """
+    def __init__(self, Q, lam, gamma, T):
+        self.Q = Q
+        self.lam = lam
+        self.gamma = gamma
+        self.T = T
+
+    def terminator(self, exponents):
+        """ Calculate the terminator for a Drude-Lorentz bath. """
+        Q = self.Q
+        lam = self.lam
+        gamma = self.gamma
+        beta = 1 / self.T
+
+        delta = 2 * lam / (beta * gamma) - 1j * lam
+
+        for exp in exponents:
+            if exp.type == BathExponent.types["R"]:
+                delta -= exp.ck / exp.vk
+            elif exp.type == BathExponent.types["RI"]:
+                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
+            else:
+                delta -= 1j * exp.ck / exp.vk
+
+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+        L_bnd = -delta * op
+
+        return delta, L_bnd
+
+
+class UnderDampedBath(BosonicBath):
+    """
+    A helper class for constructing an under-damped bosonic bath from the
+    bath parameters (see parameters below).
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    lam : float
+        Coupling strength.
+
+    gamma : float
+        Bath spectral density cutoff frequency.
+
+    w0 : float
+        Bath spectral density resonance frequency.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(
+        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
+    ):
+        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
+            lam=lam,
+            gamma=gamma,
+            w0=w0,
+            T=T,
+            Nk=Nk,
+        )
+
+        super().__init__(
+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+        )
+
+    def _matsubara_params(self, lam, gamma, w0, T, Nk):
+        """ Calculate the Matsubara coefficents and frequencies. """
+        beta = 1/T
+        Om = np.sqrt(w0**2 - (gamma/2)**2)
+        Gamma = gamma/2.
+
+        ck_real = ([
+            (lam**2 / (4 * Om))
+            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
+            (lam**2 / (4*Om))
+            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
+        ])
+
+        ck_real.extend([
+            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
+            / (
+                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
+                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
+            )
+            for k in range(1, Nk + 1)
+        ])
+
+        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
+        vk_real.extend([
+            2 * np.pi * k * T
+            for k in range(1, Nk + 1)
+        ])
+
+        ck_imag = [
+            1.0j * lam**2 / (4 * Om),
+            -1.0j * lam**2 / (4 * Om),
+        ]
+
+        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
+
+        return ck_real, vk_real, ck_imag, vk_imag
+
+
+class FermionicBath(Bath):
+    """
+    A helper class for constructing a fermionic bath from the expansion
+    coefficients and frequencies for the ``+`` and ``-`` modes of
+    the bath correlation function.
+
+    There must be the same number of ``+`` and ``-`` modes and their
+    coefficients must be specified in the same order so that ``ck_plus[i],
+    vk_plus[i]`` are the plus coefficient and frequency corresponding
+    to the minus mode ``ck_minus[i], vk_minus[i]``.
+
+    In the fermionic case the order in which excitations are created or
+    destroyed is important, resulting in two different correlation functions
+    labelled ``C_plus(t)`` and ``C_plus(t)``::
+
+        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
+        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
+
+    where the expansions above define the coeffiients ``ck`` and the
+    frequencies ``vk``.
+
+    Parameters
+    ----------
+    Q : Qobj
+        The coupling operator for the bath.
+
+    ck_plus : list of complex
+        The coefficients of the expansion terms for the ``+`` part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_plus.
+
+    vk_plus : list of complex
+        The frequencies (exponents) of the expansion terms for the ``+`` part
+        of the correlation function. The corresponding ceofficients are passed
+        as ck_plus.
+
+    ck_minus : list of complex
+        The coefficients of the expansion terms for the ``-`` part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_minus.
+
+    vk_minus : list of complex
+        The frequencies (exponents) of the expansion terms for the ``-`` part
+        of the correlation function. The corresponding ceofficients are passed
+        as ck_minus.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+
+    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
+        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
+            raise ValueError(
+                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+                " vk_minus must be the same length."
+            )
+        if len(ck_plus) != len(ck_minus):
+            raise ValueError(
+                "The must be the same number of plus and minus exponents"
+                " in the bath, and elements of plus and minus arrays"
+                " should be arranged so that ck_plus[i] is the plus mode"
+                " corresponding to ck_minus[i]."
+            )
+
+    def _check_coup_op(self, Q):
+        if not isinstance(Q, Qobj):
+            raise ValueError("The coupling operator Q must be a Qobj.")
+
+    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
+        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
+        self._check_coup_op(Q)
+
+        exponents = []
+        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
+            exponents.append(BathExponent(
+                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
+            ))
+            exponents.append(BathExponent(
+                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
+            ))
+        super().__init__(exponents)
+
+
+class LorentzianBath(FermionicBath):
+    """
+    A helper class for constructing a Lorentzian fermionic bath from the
+    bath parameters (see parameters below).
+
+    .. note::
+
+        This Matsubara expansion used in this bath converges very slowly
+        and ``Nk > 20`` may be required to get good convergence. The
+        Padé expansion used by :class:`LorentzianPadeBath` converges much
+        more quickly.
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    gamma : float
+        The coupling strength between the system and the bath.
+
+    w : float
+        The width of the environment.
+
+    mu : float
+        The chemical potential of the bath.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
+        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
+        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
+
+        super().__init__(
+            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
+        )
+
+    def _corr(self, gamma, w, mu, T, Nk, sigma):
+        beta = 1. / T
+        kappa = [0.]
+        kappa.extend([1. for _ in range(1, Nk + 1)])
+        epsilon = [0]
+        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
+
+        def f(x):
+            return 1 / (np.exp(x) + 1)
+
+        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
+        gamma_list = [w - sigma * 1.0j * mu]
+
+        for ll in range(1, Nk + 1):
+            eta_list.append(
+                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
+                (-(epsilon[ll]**2 / beta**2) + w**2)
+            )
+            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
+
+        return eta_list, gamma_list
+
+
+class LorentzianPadeBath(FermionicBath):
+    """
+    A helper class for constructing a Padé expansion for Lorentzian fermionic
+    bath from the bath parameters (see parameters below).
+
+    A Padé approximant is a sum-over-poles expansion (
+    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
+
+    The application of the Padé method to spectrum decompoisitions is described
+    in "Padé spectrum decompositions of quantum distribution functions and
+    optimal hierarchical equations of motion construction for quantum open
+    systems" [1].
+
+    The implementation here follows the approach in the paper.
+
+    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
+
+    This is an alternative to the :class:`LorentzianBath` which constructs
+    a simpler exponential expansion that converges much more slowly in
+    this particular case.
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    gamma : float
+        The coupling strength between the system and the bath.
+
+    w : float
+        The width of the environment.
+
+    mu : float
+        The chemical potential of the bath.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
+        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
+        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
+
+        super().__init__(
+            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
+        )
+
+    def _corr(self, gamma, w, mu, T, Nk, sigma):
+        beta = 1. / T
+        kappa, epsilon = self._kappa_epsilon(Nk)
+
+        def f_approx(x):
+            f = 0.5
+            for ll in range(1, Nk + 1):
+                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
+            return f
+
+        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
+        gamma_list = [w - sigma * 1.0j * mu]
+
+        for ll in range(1, Nk + 1):
+            eta_list.append(
+                -1.0j * (kappa[ll] / beta) * gamma * w**2
+                / (-(epsilon[ll]**2 / beta**2) + w**2)
+            )
+            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
+
+        return eta_list, gamma_list
+
+    def _kappa_epsilon(self, Nk):
+        eps = self._calc_eps(Nk)
+        chi = self._calc_chi(Nk)
+
+        kappa = [0]
+        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
+        for j in range(Nk):
+            term = prefactor
+            for k in range(Nk - 1):
+                term *= (
+                    (chi[k]**2 - eps[j]**2) /
+                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+                )
+            for k in [Nk - 1]:
+                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+            kappa.append(term)
+
+        epsilon = [0] + eps
+
+        return kappa, epsilon
+
+    def _delta(self, i, j):
+        return 1.0 if i == j else 0.0
+
+    def _calc_eps(self, Nk):
+        alpha = np.diag([
+                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
+                for k in range(2 * Nk - 1)
+        ], k=1)
+        alpha += alpha.transpose()
+
+        evals = eigvalsh(alpha)
+        eps = [-2. / val for val in evals[0: Nk]]
+        return eps
+
+    def _calc_chi(self, Nk):
+        alpha_p = np.diag([
+                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
+                for k in range(2 * Nk - 2)
+        ], k=1)
+        alpha_p += alpha_p.transpose()
+        evals = eigvalsh(alpha_p)
+        chi = [-2. / val for val in evals[0: Nk - 1]]
+        return chi
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 740c2d5d0c..42cc98d1eb 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1,1322 +1,1322 @@
-"""
-This module provides solvers for system-bath evoluation using the
-HEOM (hierarchy equations of motion).
-
-See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
-basic introduction to the technique.
-
-The implementation is derived from the BoFiN library (see
-https://github.com/tehruhn/bofin) which was itself derived from an earlier
-implementation in QuTiP itself.
-"""
-
-from time import time
-
-import numpy as np
-import scipy.sparse as sp
-from scipy.sparse.linalg import spsolve
-
-from qutip.settings import settings
-from qutip import state_number_enumerate
-from qutip.core import data as _data
-from qutip.core.data import csr as _csr
-from qutip.core import Qobj, QobjEvo
-from qutip.core.superoperator import liouvillian, spre, spost
-from .bofin_baths import (
-    BathExponent, DrudeLorentzBath,
-)
-from ..solver_base import Solver
-from .. import Result
-
-# Load MKL spsolve if avaiable
-if settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_spsolve
-else:
-    mkl_spsolve = None
-
-__all__ = [
-    "heomsolve",
-    "HierarchyADOs",
-    "HierarchyADOsState",
-    "HEOMResult",
-    "HEOMSolver",
-    "HSolverDL",
-]
-
-
-class HierarchyADOs:
-    """
-    A description of ADOs (auxilliary density operators) with the
-    hierarchical equations of motion.
-
-    The list of ADOs is constructed from a list of bath exponents
-    (corresponding to one or more baths). Each ADO is referred to by a label
-    that lists the number of "excitations" of each bath exponent. The
-    level of a label within the hierarchy is the sum of the "excitations"
-    within the label.
-
-    For example the label ``(0, 0, ..., 0)`` represents the density matrix
-    of the system being solved and is the only 0th level label.
-
-    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
-    etc. are the 1st level labels.
-
-    The second level labels all have either two 1s or a single 2, and so on
-    for the third and higher levels of the hierarchy.
-
-    Parameters
-    ----------
-    exponents : list of BathExponent
-        The exponents of the correlation function describing the bath or
-        baths.
-
-    max_depth : int
-        The maximum depth of the hierarchy (i.e. the maximum sum of
-        "excitations" in the hierarchy ADO labels or maximum ADO level).
-
-    Attributes
-    ----------
-    exponents : list of BathExponent
-        The exponents of the correlation function describing the bath or
-        baths.
-
-    max_depth : int
-        The maximum depth of the hierarchy (i.e. the maximum sum of
-        "excitations" in the hierarchy ADO labels).
-
-    dims : list of int
-        The dimensions of each exponent within the bath(s).
-
-    vk : list of complex
-        The frequency of each exponent within the bath(s).
-
-    ck : list of complex
-        The coefficient of each exponent within the bath(s).
-
-    ck2: list of complex
-        For exponents of type "RI", the coefficient of the exponent within
-        the imaginary expansion. For other exponent types, the entry is None.
-
-    sigma_bar_k_offset: list of int
-        For exponents of type "+" or "-" the offset within the list of modes
-        of the corresponding "-" or "+" exponent. For other exponent types,
-        the entry is None.
-
-    labels: list of tuples
-        A list of the ADO labels within the hierarchy.
-    """
-    def __init__(self, exponents, max_depth):
-        self.exponents = exponents
-        self.max_depth = max_depth
-
-        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
-        self.vk = [exp.vk for exp in self.exponents]
-        self.ck = [exp.ck for exp in self.exponents]
-        self.ck2 = [exp.ck2 for exp in self.exponents]
-        self.sigma_bar_k_offset = [
-            exp.sigma_bar_k_offset for exp in self.exponents
-        ]
-
-        self.labels = list(state_number_enumerate(self.dims, max_depth))
-        self._label_idx = {s: i for i, s in enumerate(self.labels)}
-        self.idx = self._label_idx.__getitem__
-
-    def idx(self, label):
-        """
-        Return the index of the ADO label within the list of labels,
-        i.e. within ``self.labels``.
-
-        Parameters
-        ----------
-        label : tuple
-            The label to look up.
-
-        Returns
-        -------
-        int
-            The index of the label within the list of ADO labels.
-
-        Note
-        ----
-        This implementation of the ``.idx(...)`` method is just for
-        reference and documentation. To avoid the cost of a Python
-        function call, it is replaced with
-        ``self._label_idx.__getitem__`` when the instance is created.
-        """
-        return self._label_idx[label]
-
-    def next(self, label, k):
-        """
-        Return the ADO label with one more excitation in the k'th exponent
-        dimension or ``None`` if adding the excitation would exceed the
-        dimension or maximum depth of the hierarchy.
-
-        Parameters
-        ----------
-        label : tuple
-            The ADO label to add an excitation to.
-        k : int
-            The exponent to add the excitation to.
-
-        Returns
-        -------
-        tuple or None
-            The next label.
-        """
-        if label[k] >= self.dims[k] - 1:
-            return None
-        if sum(label) >= self.max_depth:
-            return None
-        return label[:k] + (label[k] + 1,) + label[k + 1:]
-
-    def prev(self, label, k):
-        """
-        Return the ADO label with one fewer excitation in the k'th
-        exponent dimension or ``None`` if the label has no exciations in the
-        k'th exponent.
-
-        Parameters
-        ----------
-        label : tuple
-            The ADO label to remove the excitation from.
-        k : int
-            The exponent to remove the excitation from.
-
-        Returns
-        -------
-        tuple or None
-            The previous label.
-        """
-        if label[k] <= 0:
-            return None
-        return label[:k] + (label[k] - 1,) + label[k + 1:]
-
-    def exps(self, label):
-        """
-        Converts an ADO label into a tuple of exponents, with one exponent
-        for each "excitation" within the label.
-
-        The number of exponents returned is always equal to the level of the
-        label within the hierarchy (i.e. the sum of the indices within the
-        label).
-
-        Parameters
-        ----------
-        label : tuple
-            The ADO label to convert to a list of exponents.
-
-        Returns
-        -------
-        tuple of BathExponent
-            A tuple of BathExponents.
-
-        Examples
-        --------
-
-        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
-
-        ``ados.exps((2, 0, 0))`` would return
-        ``[ados.exponents[0], ados.exponents[0]]``.
-
-        ``ados.exps((1, 2, 1))`` would return
-        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
-           ados.exponents[2]]``.
-        """
-        return sum(
-            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
-            (),
-        )
-
-    def filter(self, level=None, tags=None, dims=None, types=None):
-        """
-        Return a list of ADO labels for ADOs whose "excitations"
-        match the given patterns.
-
-        Each of the filter parameters (tags, dims, types) may be either
-        unspecified (None) or a list. Unspecified parameters are excluded
-        from the filtering.
-
-        All specified filter parameters must be lists of the same length.
-        Each position in the lists describes a particular excitation and
-        any exponent that matches the filters may supply that excitation.
-        The level of all labels returned is thus equal to the length of
-        the filter parameter lists.
-
-        Within a filter parameter list, items that are None represent
-        wildcards and match any value of that exponent attribute
-
-        Parameters
-        ----------
-        level : int
-            The hierarchy depth to return ADOs from.
-
-        tags : list of object or None
-            Filter parameter that matches the ``.tag`` attribute of
-            exponents.
-
-        dims : list of int
-            Filter parameter that matches the ``.dim`` attribute of
-            exponents.
-
-        types : list of BathExponent types or list of str
-            Filter parameter that matches the ``.type`` attribute
-            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
-            instead of by the actual type (e.g. ``BathExponent.types.R``).
-
-        Returns
-        -------
-        list of tuple
-            The ADO label for each ADO whose exponent excitations
-            (i.e. label) match the given filters or level.
-        """
-        if types is not None:
-            types = [
-                t if t is None or isinstance(t, BathExponent.types)
-                else BathExponent.types[t]
-                for t in types
-            ]
-        filters = [("tag", tags), ("type", types), ("dim", dims)]
-        filters = [(attr, f) for attr, f in filters if f is not None]
-        n = max((len(f) for _, f in filters), default=0)
-        if any(len(f) != n for _, f in filters):
-            raise ValueError(
-                "The tags, dims and types filters must all be the same length."
-            )
-        if n > self.max_depth:
-            raise ValueError(
-                f"The maximum depth for the hierarchy is {self.max_depth} but"
-                f" {n} levels of excitation filters were given."
-            )
-        if level is None:
-            if not filters:
-                # fast path for when there are no excitation filters
-                return self.labels[:]
-        else:
-            if not filters:
-                # fast path for when there are no excitation filters
-                return [label for label in self.labels if sum(label) == level]
-            if level != n:
-                raise ValueError(
-                    f"The level parameter is {level} but {n} levels of"
-                    " excitation filters were given."
-                )
-
-        filtered_dims = [1] * len(self.exponents)
-        for lvl in range(n):
-            level_filters = [
-                (attr, f[lvl]) for attr, f in filters
-                if f[lvl] is not None
-            ]
-            for j, exp in enumerate(self.exponents):
-                if any(getattr(exp, attr) != f for attr, f in level_filters):
-                    continue
-                filtered_dims[j] += 1
-                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
-
-        return [
-            label for label in state_number_enumerate(filtered_dims, n)
-            if sum(label) == n
-        ]
-
-
-class HierarchyADOsState:
-    """
-    Provides convenient access to the full hierarchy ADO state at a particular
-    point in time, ``t``.
-
-    Parameters
-    ----------
-    rho : :class:`~qutip.Qobj`
-        The current state of the system (i.e. the 0th component of the
-        hierarchy).
-    ados : :class:`HierarchyADOs`
-        The description of the hierarchy.
-    ado_state : numpy.array
-        The full state of the hierarchy.
-
-    Attributes
-    ----------
-    rho : Qobj
-        The system state.
-
-    In addition, all of the attributes of the hierarchy description,
-    i.e. ``HierarchyADOs``, are provided directly on this class for
-    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
-    call ``.idx(label)`` directly.
-
-    See :class:`HierarchyADOs` for a full list of the available attributes
-    and methods.
-    """
-    def __init__(self, rho, ados, ado_state):
-        self.rho = rho
-        self._ado_state = ado_state
-        self._ados = ados
-
-    def __getattr__(self, name):
-        return getattr(self._ados, name)
-
-    def extract(self, idx_or_label):
-        """
-        Extract a Qobj representing the specified ADO from a full
-        representation of the ADO states.
-
-        Parameters
-        ----------
-        idx : int or label
-            The index of the ADO to extract. If an ADO label, e.g.
-            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
-            is extracted by label instead.
-
-        Returns
-        -------
-        Qobj
-            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
-        """
-        if isinstance(idx_or_label, int):
-            idx = idx_or_label
-        else:
-            idx = self._ados.idx(idx_or_label)
-        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
-
-
-class HEOMResult(Result):
-    def _post_init(self):
-        super()._post_init()
-
-        self.store_ados = self.options["store_ados"]
-        if self.store_ados:
-            self.final_ado_state = None
-            self.ado_states = []
-
-    def _e_op_func(self, e_op):
-        """ Convert an e_op into a function ``f(t, ado_state)``. """
-        if isinstance(e_op, Qobj):
-            return lambda t, ado_state: (ado_state.rho * e_op).tr()
-        elif isinstance(e_op, QobjEvo):
-            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
-        elif callable(e_op):
-            return e_op
-        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
-
-    def _pre_copy(self, state):
-        return state
-
-    def _store_state(self, t, ado_state):
-        self.states.append(ado_state.rho)
-        if self.store_ados:
-            self.ado_states.append(ado_state)
-
-    def _store_final_state(self, t, ado_state):
-        self.final_state = ado_state.rho
-        if self.store_ados:
-            self.final_ado_state = ado_state
-
-
-def heomsolve(
-    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
-):
-    """
-    Hierarchical Equations of Motion (HEOM) solver that supports multiple
-    baths.
-
-    The baths must be all either bosonic or fermionic baths.
-
-    If you need to run many evolutions of the same system and bath, consider
-    using :class:`HEOMSolver` directly to avoid having to continually
-    reconstruct the equation hierarchy for every evolution.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    bath : Bath or list of Bath
-        A :obj:`Bath` containing the exponents of the expansion of the
-        bath correlation funcion and their associated coefficients
-        and coupling operators, or a list of baths.
-
-        If multiple baths are given, they must all be either fermionic
-        or bosonic baths.
-
-    max_depth : int
-        The maximum depth of the heirarchy (i.e. the maximum number of bath
-        exponent "excitations" to retain).
-
-    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
-        If ``rho0`` is a :class:`~Qobj` the it is the initial state
-        of the system (i.e. a :obj:`~Qobj` density matrix).
-
-        If it is a :class:`~HierarchyADOsState` or array-like, then
-        ``rho0`` gives the initial state of all ADOs.
-
-        Usually the state of the ADOs would be determine from a previous
-        call to ``.run(...)`` with the solver results option ``store_ados``
-        set to True. For example, ``result = solver.run(...)`` could be
-        followed by ``solver.run(result.ado_states[-1], tlist)``.
-
-        If a numpy array-like is passed its shape must be
-        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
-        (i.e. shape of the system density matrix) and the ADOs must
-        be in the same order as in ``.ados.labels``.
-
-    tlist : list
-        An ordered list of times at which to return the value of the state.
-
-    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
-        A list or dictionary of operators as :class:`~Qobj`,
-        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
-        a single operator or callable function. For an operator ``op``, the
-        result will be computed using ``(state * op).tr()`` and the state
-        at each time ``t``. For callable functions, ``f``, the result is
-        computed using ``f(t, ado_state)``. The values are stored in the
-        ``expect`` and ``e_data`` attributes of the result (see the return
-        section below).
-
-    args : dict, optional {None}
-        Change the ``args`` of the RHS for the evolution.
-
-    options : dict, optional {None}
-        Generic solver options.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - store_ados : bool {False, True}
-          Whether or not to store the HEOM ADOs.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - state_data_type: str {'dense'}
-          Name of the data type of the state used during the ODE evolution.
-          Use an empty string to keep the input state type. Many integrator can
-          only work with `Dense`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-    Returns
-    -------
-    :class:`~HEOMResult`
-        The results of the simulation run, with the following important
-        attributes:
-
-        * ``times``: the times ``t`` (i.e. the ``tlist``).
-
-        * ``states``: the system state at each time ``t`` (only available
-          if ``e_ops`` was ``None`` or if the solver option
-          ``store_states`` was set to ``True``).
-
-        * ``ado_states``: the full ADO state at each time (only available
-          if the results option ``ado_return`` was set to ``True``).
-          Each element is an instance of :class:`HierarchyADOsState`.
-          The state of a particular ADO may be extracted from
-          ``result.ado_states[i]`` by calling :meth:`.extract`.
-
-        * ``expect``: a list containing the values of each ``e_ops`` at
-          time ``t``.
-
-        * ``e_data``: a dictionary containing the values of each ``e_ops``
-          at tme ``t``. The keys are those given by ``e_ops`` if it was
-          a dict, otherwise they are the indexes of the supplied ``e_ops``.
-
-        See :class:`~HEOMResult` and :class:`~Result` for the complete
-        list of attributes.
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
-    return solver.run(state0, tlist, e_ops=e_ops)
-
-
-class HEOMSolver(Solver):
-    """
-    HEOM solver that supports multiple baths.
-
-    The baths must be all either bosonic or fermionic baths.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    bath : Bath or list of Bath
-        A :obj:`Bath` containing the exponents of the expansion of the
-        bath correlation funcion and their associated coefficients
-        and coupling operators, or a list of baths.
-
-        If multiple baths are given, they must all be either fermionic
-        or bosonic baths.
-
-    max_depth : int
-        The maximum depth of the heirarchy (i.e. the maximum number of bath
-        exponent "excitations" to retain).
-
-    options : dict, optional
-        Generic solver options.
-        If set to None the default options will be used. Keyword only.
-        Default: None.
-
-    Attributes
-    ----------
-    ados : :obj:`HierarchyADOs`
-        The description of the hierarchy constructed from the given bath
-        and maximum depth.
-
-    rhs : :obj:`QobjEvo`
-        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
-        the system and bath coupling operators are converted to
-        :class:`qutip.data.CSR` instances during construction of the RHS,
-        so the operators in the ``rhs`` will all be sparse.
-    """
-
-    name = "heomsolver"
-    resultclass = HEOMResult
-    _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": False,
-        "method": "adams",
-        "store_ados": False,
-        "state_data_type": "dense",
-    }
-
-    def __init__(self, H, bath, max_depth, *, options=None):
-        _time_start = time()
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
-
-        H = QobjEvo(H)
-        self.L_sys = (
-            liouvillian(H) if H.type == "oper"  # hamiltonian
-            else H  # already a liouvillian
-        )
-
-        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
-        self._sup_shape = self.L_sys.shape[0]
-        self._sys_dims = self.L_sys.dims[0]
-
-        self.ados = HierarchyADOs(
-            self._combine_bath_exponents(bath), max_depth,
-        )
-        self._n_ados = len(self.ados.labels)
-        self._n_exponents = len(self.ados.exponents)
-
-        self._init_ados_time = time() - _time_start
-        _time_start = time()
-
-        # pre-calculate identity matrix required by _grad_n
-        self._sId = _data.identity(self._sup_shape, dtype="csr")
-
-        # pre-calculate superoperators required by _grad_prev and _grad_next:
-        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
-        self._spreQ = [spre(op).data for op in Qs]
-        self._spostQ = [spost(op).data for op in Qs]
-        self._s_pre_minus_post_Q = [
-            _data.sub(self._spreQ[k], self._spostQ[k])
-            for k in range(self._n_exponents)
-        ]
-        self._s_pre_plus_post_Q = [
-            _data.add(self._spreQ[k], self._spostQ[k])
-            for k in range(self._n_exponents)
-        ]
-        self._spreQdag = [spre(op.dag()).data for op in Qs]
-        self._spostQdag = [spost(op.dag()).data for op in Qs]
-        self._s_pre_minus_post_Qdag = [
-            _data.sub(self._spreQdag[k], self._spostQdag[k])
-            for k in range(self._n_exponents)
-        ]
-        self._s_pre_plus_post_Qdag = [
-            _data.add(self._spreQdag[k], self._spostQdag[k])
-            for k in range(self._n_exponents)
-        ]
-
-        self._init_superop_cache_time = time() - _time_start
-        _time_start = time()
-
-        rhs = self._calculate_rhs()
-
-        self._init_rhs_time = time() - _time_start
-
-        super().__init__(rhs, options=options)
-
-    @property
-    def sys_dims(self):
-        """
-        Dimensions of the space that the system use, excluding any environment:
-
-        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
-        for this solver.
-        """
-        return self._sys_dims
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "init time": sum([
-                stats["init time"], self._init_ados_time,
-                self._init_superop_cache_time, self._init_rhs_time,
-            ]),
-            "init ados time": self._init_ados_time,
-            "init superop cache time": self._init_superop_cache_time,
-            "init rhs time": self._init_rhs_time,
-            "solver": "Hierarchical Equations of Motion Solver",
-            "max_depth": self.ados.max_depth,
-        })
-        return stats
-
-    def _combine_bath_exponents(self, bath):
-        """ Combine the exponents for the specified baths. """
-        if not isinstance(bath, (list, tuple)):
-            exponents = bath.exponents
-        else:
-            exponents = []
-            for b in bath:
-                exponents.extend(b.exponents)
-        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
-            raise ValueError(
-                "All bath exponents must have system coupling operators"
-                " with the same dimensions but a mixture of dimensions"
-                " was given."
-            )
-        return exponents
-
-    def _grad_n(self, he_n):
-        """ Get the gradient for the hierarchy ADO at level n. """
-        vk = self.ados.vk
-        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
-        op = _data.mul(self._sId, -vk_sum)
-        return op
-
-    def _grad_prev(self, he_n, k):
-        """ Get the previous gradient. """
-        if self.ados.exponents[k].fermionic:
-            return self._grad_prev_fermionic(he_n, k)
-        else:
-            return self._grad_prev_bosonic(he_n, k)
-
-    def _grad_prev_bosonic(self, he_n, k):
-        if self.ados.exponents[k].type == BathExponent.types.R:
-            op = _data.mul(
-                self._s_pre_minus_post_Q[k],
-                -1j * he_n[k] * self.ados.ck[k],
-            )
-        elif self.ados.exponents[k].type == BathExponent.types.I:
-            op = _data.mul(
-                self._s_pre_plus_post_Q[k],
-                -1j * he_n[k] * 1j * self.ados.ck[k],
-            )
-        elif self.ados.exponents[k].type == BathExponent.types.RI:
-            term1 = _data.mul(
-                self._s_pre_minus_post_Q[k],
-                he_n[k] * -1j * self.ados.ck[k],
-            )
-            term2 = _data.mul(
-                self._s_pre_plus_post_Q[k],
-                he_n[k] * self.ados.ck2[k],
-            )
-            op = _data.add(term1, term2)
-        else:
-            raise ValueError(
-                f"Unsupported type {self.ados.exponents[k].type}"
-                f" for exponent {k}"
-            )
-        return op
-
-    def _grad_prev_fermionic(self, he_n, k):
-        ck = self.ados.ck
-        he_fermionic_n = [
-            i * int(exp.fermionic)
-            for i, exp in zip(he_n, self.ados.exponents)
-        ]
-
-        n_excite = sum(he_fermionic_n)
-        sign1 = (-1) ** (n_excite + 1)
-
-        n_excite_before_m = sum(he_fermionic_n[:k])
-        sign2 = (-1) ** (n_excite_before_m)
-
-        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
-
-        if self.ados.exponents[k].type == BathExponent.types["+"]:
-            op = _data.sub(
-                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
-                _data.mul(
-                    self._spostQdag[k],
-                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
-                ),
-            )
-        elif self.ados.exponents[k].type == BathExponent.types["-"]:
-            op = _data.sub(
-                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
-                _data.mul(
-                    self._spostQ[k],
-                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
-                ),
-            )
-        else:
-            raise ValueError(
-                f"Unsupported type {self.ados.exponents[k].type}"
-                f" for exponent {k}"
-            )
-        return op
-
-    def _grad_next(self, he_n, k):
-        """ Get the previous gradient. """
-        if self.ados.exponents[k].fermionic:
-            return self._grad_next_fermionic(he_n, k)
-        else:
-            return self._grad_next_bosonic(he_n, k)
-
-    def _grad_next_bosonic(self, he_n, k):
-        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
-        return op
-
-    def _grad_next_fermionic(self, he_n, k):
-        he_fermionic_n = [
-            i * int(exp.fermionic)
-            for i, exp in zip(he_n, self.ados.exponents)
-        ]
-        n_excite = sum(he_fermionic_n)
-        sign1 = (-1) ** (n_excite + 1)
-
-        n_excite_before_m = sum(he_fermionic_n[:k])
-        sign2 = (-1) ** (n_excite_before_m)
-
-        if self.ados.exponents[k].type == BathExponent.types["+"]:
-            if sign1 == -1:
-                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
-            else:
-                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
-        elif self.ados.exponents[k].type == BathExponent.types["-"]:
-            if sign1 == -1:
-                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
-            else:
-                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
-        else:
-            raise ValueError(
-                f"Unsupported type {self.ados.exponents[k].type}"
-                f" for exponent {k}"
-            )
-        return op
-
-    def _rhs(self):
-        """ Make the RHS for the HEOM. """
-        ops = _GatherHEOMRHS(
-            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
-        )
-
-        for he_n in self.ados.labels:
-            op = self._grad_n(he_n)
-            ops.add_op(he_n, he_n, op)
-            for k in range(len(self.ados.dims)):
-                next_he = self.ados.next(he_n, k)
-                if next_he is not None:
-                    op = self._grad_next(he_n, k)
-                    ops.add_op(he_n, next_he, op)
-                prev_he = self.ados.prev(he_n, k)
-                if prev_he is not None:
-                    op = self._grad_prev(he_n, k)
-                    ops.add_op(he_n, prev_he, op)
-
-        return ops.gather()
-
-    def _calculate_rhs(self):
-        """ Make the full RHS required by the solver. """
-        rhs_mat = self._rhs()
-        rhs_dims = [
-            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
-        ]
-        h_identity = _data.identity(self._n_ados, dtype="csr")
-
-        if self.L_sys.isconstant:
-            # For the constant case, we just add the Liouvillian to the
-            # diagonal blocks of the RHS matrix.
-            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
-            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
-        else:
-            # In the time dependent case, we construct the parameters
-            # for the ODE gradient function under the assumption that
-            #
-            # RHSmat(t) = RHSmat + time dependent terms that only affect the
-            # diagonal blocks of the RHS matrix.
-            #
-            # This assumption holds because only _grad_n dependents on
-            # the system Liouvillian (and not _grad_prev or _grad_next) and
-            # the bath coupling operators are not time-dependent.
-            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
-
-            def _kron(x):
-                return Qobj(
-                    _data.kron(h_identity, x.data),
-                    dims=rhs_dims,
-                ).to("csr")
-
-            rhs += self.L_sys.linear_map(_kron)
-
-        # The assertion that rhs_mat has data type CSR is just a sanity
-        # check on the RHS creation. The base solver class will still
-        # convert the RHS to the type required by the ODE integrator if
-        # needed.
-        assert isinstance(rhs_mat, _csr.CSR)
-        assert isinstance(rhs, QobjEvo)
-        assert rhs.dims == rhs_dims
-
-        return rhs
-
-    def steady_state(
-        self,
-        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
-    ):
-        """
-        Compute the steady state of the system.
-
-        Parameters
-        ----------
-        use_mkl : bool, default=False
-            Whether to use mkl or not. If mkl is not installed or if
-            this is false, use the scipy splu solver instead.
-
-        mkl_max_iter_refine : int
-            Specifies the the maximum number of iterative refinement steps that
-            the MKL PARDISO solver performs.
-
-            For a complete description, see iparm(8) in
-            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
-
-        mkl_weighted_matching : bool
-            MKL PARDISO can use a maximum weighted matching algorithm to
-            permute large elements close the diagonal. This strategy adds an
-            additional level of reliability to the factorization methods.
-
-            For a complete description, see iparm(13) in
-            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
-
-        Returns
-        -------
-        steady_state : Qobj
-            The steady state density matrix of the system.
-
-        steady_ados : :class:`HierarchyADOsState`
-            The steady state of the full ADO hierarchy. A particular ADO may be
-            extracted from the full state by calling :meth:`.extract`.
-        """
-        if not self.L_sys.isconstant:
-            raise ValueError(
-                "A steady state cannot be determined for a time-dependent"
-                " system"
-            )
-        n = self._sys_shape
-
-        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
-        b_mat[0] = 1.0
-
-        L = self.rhs(0).data.copy().as_scipy()
-        L = L.tolil()
-        L[0, 0: n ** 2 * self._n_ados] = 0.0
-        L = L.tocsr()
-        L += sp.csr_matrix((
-            np.ones(n),
-            (np.zeros(n), [num * (n + 1) for num in range(n)])
-        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
-
-        if mkl_spsolve is not None and use_mkl:
-            L.sort_indices()
-            solution = mkl_spsolve(
-                L,
-                b_mat,
-                perm=None,
-                verbose=False,
-                max_iter_refine=mkl_max_iter_refine,
-                scaling_vectors=True,
-                weighted_matching=mkl_weighted_matching,
-            )
-        else:
-            L = L.tocsc()
-            solution = spsolve(L, b_mat)
-
-        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
-        data = _data.mul(_data.add(data, data.conj()), 0.5)
-        steady_state = Qobj(data, dims=self._sys_dims)
-
-        solution = solution.reshape((self._n_ados, n, n))
-        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
-
-        return steady_state, steady_ados
-
-    def run(self, state0, tlist, *, args=None, e_ops=None):
-        """
-        Solve for the time evolution of the system.
-
-        Parameters
-        ----------
-        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
-            If ``rho0`` is a :class:`~Qobj` the it is the initial state
-            of the system (i.e. a :obj:`~Qobj` density matrix).
-
-            If it is a :class:`~HierarchyADOsState` or array-like, then
-            ``rho0`` gives the initial state of all ADOs.
-
-            Usually the state of the ADOs would be determine from a previous
-            call to ``.run(...)`` with the solver results option ``store_ados``
-            set to True. For example, ``result = solver.run(...)`` could be
-            followed by ``solver.run(result.ado_states[-1], tlist)``.
-
-            If a numpy array-like is passed its shape must be
-            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
-            (i.e. shape of the system density matrix) and the ADOs must
-            be in the same order as in ``.ados.labels``.
-
-        tlist : list
-            An ordered list of times at which to return the value of the state.
-
-        args : dict, optional {None}
-            Change the ``args`` of the RHS for the evolution.
-
-        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
-            A list or dictionary of operators as :class:`~Qobj`,
-            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
-            a single operator or callable function. For an operator ``op``, the
-            result will be computed using ``(state * op).tr()`` and the state
-            at each time ``t``. For callable functions, ``f``, the result is
-            computed using ``f(t, ado_state)``. The values are stored in the
-            ``expect`` and ``e_data`` attributes of the result (see the return
-            section below).
-
-        Returns
-        -------
-        :class:`~HEOMResult`
-            The results of the simulation run, with the following important
-            attributes:
-
-            * ``times``: the times ``t`` (i.e. the ``tlist``).
-
-            * ``states``: the system state at each time ``t`` (only available
-              if ``e_ops`` was ``None`` or if the solver option
-              ``store_states`` was set to ``True``).
-
-            * ``ado_states``: the full ADO state at each time (only available
-              if the results option ``ado_return`` was set to ``True``).
-              Each element is an instance of :class:`HierarchyADOsState`.
-              The state of a particular ADO may be extracted from
-              ``result.ado_states[i]`` by calling :meth:`.extract`.
-
-            * ``expect``: a list containing the values of each ``e_ops`` at
-              time ``t``.
-
-            * ``e_data``: a dictionary containing the values of each ``e_ops``
-              at tme ``t``. The keys are those given by ``e_ops`` if it was
-              a dict, otherwise they are the indexes of the supplied ``e_ops``.
-
-            See :class:`~HEOMResult` and :class:`~Result` for the complete
-            list of attributes.
-        """
-        return super().run(state0, tlist, args=args, e_ops=e_ops)
-
-    def _prepare_state(self, state):
-        n = self._sys_shape
-        rho_dims = self._sys_dims
-        hierarchy_shape = (self._n_ados, n, n)
-
-        rho0 = state
-        ado_init = not isinstance(rho0, Qobj)
-
-        if ado_init:
-            if isinstance(rho0, HierarchyADOsState):
-                rho0_he = rho0._ado_state
-            elif hasattr(rho0, "shape"):  # array-like
-                rho0_he = rho0
-            else:
-                raise TypeError(
-                    f"Initial ADOs passed have type {type(rho0)}"
-                    " but a HierarchyADOsState or a numpy array-like instance"
-                    " was expected"
-                )
-            if rho0_he.shape != hierarchy_shape:
-                raise ValueError(
-                    f"Initial ADOs passed have shape {rho0_he.shape}"
-                    f" but the solver hierarchy shape is {hierarchy_shape}"
-                )
-            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
-            rho0_he = _data.create(rho0_he)
-        else:
-            if rho0.dims != rho_dims:
-                raise ValueError(
-                    f"Initial state rho has dims {rho0.dims}"
-                    f" but the system dims are {rho_dims}"
-                )
-            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
-            rho0_he[:n ** 2] = rho0.full().ravel('F')
-            rho0_he = _data.create(rho0_he)
-
-        if self.options["state_data_type"]:
-            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
-
-        return rho0_he
-
-    def _restore_state(self, state, *, copy=True):
-        n = self._sys_shape
-        rho_shape = (n, n)
-        rho_dims = self._sys_dims
-        hierarchy_shape = (self._n_ados, n, n)
-
-        rho = Qobj(
-            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
-            dims=rho_dims,
-        )
-        ado_state = HierarchyADOsState(
-            rho, self.ados, state.to_array().reshape(hierarchy_shape)
-        )
-        return ado_state
-
-    def start(self, state0, t0):
-        """
-        Set the initial state and time for a step evolution.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution. This may provide either just the
-            initial density matrix of the system, or the full set of ADOs
-            for the hierarchy. See the documentation for ``rho0`` in the
-            ``.run(...)`` method for details.
-
-        t0 : double
-            Initial time of the evolution.
-        """
-        super().start(state0, t0)
-
-    @property
-    def options(self):
-        """
-        Options for HEOMSolver:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        normalize_output: bool, default=False
-            Normalize output state to hide ODE numerical errors.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error
-            if not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size": 10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        method: str, default="adams"
-            Which ordinary differential equation integration method to use.
-
-        state_data_type: str, default="dense"
-            Name of the data type of the state used during the ODE evolution.
-            Use an empty string to keep the input state type. Many integrators
-            support only work with `Dense`.
-
-        store_ados : bool, default=False
-            Whether or not to store the HEOM ADOs. Only relevant when using
-            the HEOM solver.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Solver.options.fset(self, new_options)
-
-
-class HSolverDL(HEOMSolver):
-    """
-    A helper class for creating an :class:`HEOMSolver` that is backwards
-    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
-    in QuTiP 4.6 and below.
-
-    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
-    descriptions of the underlying solver and bath construction.
-
-    An exact copy of the QuTiP 4.6 HSolverDL is provided in
-    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
-    the older solver is required. The older solver will be completely
-    removed in QuTiP 5.
-
-    .. note::
-
-        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
-        supports supplying a time-dependent or Liouvillian ``H_sys``.
-
-    .. note::
-
-        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
-        parameter ``N_exp`` specifying the number of exponents to keep in
-        the expansion of the bath correlation function is one more than
-        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
-        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
-        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
-        order to better match common usage in the literature.
-
-    .. note::
-
-        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
-        are no longer supported.
-
-    Parameters
-    ----------
-    H_sys : Qobj or QobjEvo or list
-        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
-        a complete description.
-
-    coup_op : Qobj
-        Operator describing the coupling between system and bath.
-        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
-
-    coup_strength : float
-        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
-
-    temperature : float
-        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
-
-    N_cut : int
-        The maximum depth of the hierarchy. See ``max_depth`` in
-        :class:`HEOMSolver` for a full description.
-
-    N_exp : int
-        Number of exponential terms used to approximate the bath correlation
-        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
-        less than ``N_exp`` (see note above).
-
-    cut_freq : float
-        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
-        :class:`DrudeLorentzBath`.
-
-    bnd_cut_approx : bool
-        Use boundary cut off approximation. If true, the Matsubara
-        terminator is added to the system Liouvillian (and H_sys is
-        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
-        Default: False.
-
-    options : dict, optional
-        Generic solver options.
-        If set to None the default options will be used. Keyword only.
-        Default: None.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-        Keyword only. Default: True.
-    """
-    def __init__(
-        self, H_sys, coup_op, coup_strength, temperature,
-        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
-        combine=True,
-    ):
-        H_sys = QobjEvo(H_sys)
-        bath = DrudeLorentzBath(
-            Q=coup_op,
-            lam=coup_strength,
-            gamma=cut_freq,
-            Nk=N_exp - 1,
-            T=temperature,
-            combine=combine,
-        )
-
-        if bnd_cut_approx:
-            # upgrade H_sys to a Liouvillian if needed and add the
-            # bath terminator
-            if H_sys.type == "oper":  # H_sys is a Hamiltonian
-                H_sys = liouvillian(H_sys)
-            _, terminator = bath.terminator()
-            H_sys = H_sys + terminator
-
-        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
-
-        # store input parameters as attributes for politeness and compatibility
-        # with HSolverDL in QuTiP 4.6 and below.
-        self.coup_strength = coup_strength
-        self.cut_freq = cut_freq
-        self.temperature = temperature
-        self.N_exp = N_exp
-        self.bnd_cut_approx = bnd_cut_approx
-
-
-class _GatherHEOMRHS:
-    """ A class for collecting elements of the right-hand side matrix
-        of the HEOM.
-
-        Parameters
-        ----------
-        f_idx: function(he_state) -> he_idx
-            A function that returns the index of a hierarchy state
-            (i.e. an ADO label).
-        block : int
-            The size of a single ADO Liovillian operator in the hierarchy.
-        nhe : int
-            The number of ADOs in the hierarchy.
-    """
-    def __init__(self, f_idx, block, nhe):
-        self._block_size = block
-        self._n_blocks = nhe
-        self._f_idx = f_idx
-        self._ops = []
-
-    def add_op(self, row_he, col_he, op):
-        """ Add an block operator to the list. """
-        self._ops.append(
-            (self._f_idx(row_he), self._f_idx(col_he), op)
-        )
-
-    def gather(self):
-        """ Create the HEOM liouvillian from a sorted list of smaller sparse
-            matrices.
-
-            .. note::
-
-                The list of operators contains tuples of the form
-                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
-                *block* row and column for each op. An operator with
-                block indices ``(N, M)`` is placed at position
-                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
-                in the output matrix.
-
-            Returns
-            -------
-            rhs : :obj:`Data`
-                A combined matrix of shape ``(block * nhe, block * ne)``.
-        """
-        self._ops.sort()
-        ops = np.array(self._ops, dtype=[
-            ("row", _data.base.idxint_dtype),
-            ("col", _data.base.idxint_dtype),
-            ("op", _data.CSR),
-        ])
-        return _csr._from_csr_blocks(
-            ops["row"], ops["col"], ops["op"],
-            self._n_blocks, self._block_size,
-        )
+"""
+This module provides solvers for system-bath evoluation using the
+HEOM (hierarchy equations of motion).
+
+See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
+basic introduction to the technique.
+
+The implementation is derived from the BoFiN library (see
+https://github.com/tehruhn/bofin) which was itself derived from an earlier
+implementation in QuTiP itself.
+"""
+
+from time import time
+
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.linalg import spsolve
+
+from qutip.settings import settings
+from qutip import state_number_enumerate
+from qutip.core import data as _data
+from qutip.core.data import csr as _csr
+from qutip.core import Qobj, QobjEvo
+from qutip.core.superoperator import liouvillian, spre, spost
+from .bofin_baths import (
+    BathExponent, DrudeLorentzBath,
+)
+from ..solver_base import Solver
+from .. import Result
+
+# Load MKL spsolve if avaiable
+if settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_spsolve
+else:
+    mkl_spsolve = None
+
+__all__ = [
+    "heomsolve",
+    "HierarchyADOs",
+    "HierarchyADOsState",
+    "HEOMResult",
+    "HEOMSolver",
+    "HSolverDL",
+]
+
+
+class HierarchyADOs:
+    """
+    A description of ADOs (auxilliary density operators) with the
+    hierarchical equations of motion.
+
+    The list of ADOs is constructed from a list of bath exponents
+    (corresponding to one or more baths). Each ADO is referred to by a label
+    that lists the number of "excitations" of each bath exponent. The
+    level of a label within the hierarchy is the sum of the "excitations"
+    within the label.
+
+    For example the label ``(0, 0, ..., 0)`` represents the density matrix
+    of the system being solved and is the only 0th level label.
+
+    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
+    etc. are the 1st level labels.
+
+    The second level labels all have either two 1s or a single 2, and so on
+    for the third and higher levels of the hierarchy.
+
+    Parameters
+    ----------
+    exponents : list of BathExponent
+        The exponents of the correlation function describing the bath or
+        baths.
+
+    max_depth : int
+        The maximum depth of the hierarchy (i.e. the maximum sum of
+        "excitations" in the hierarchy ADO labels or maximum ADO level).
+
+    Attributes
+    ----------
+    exponents : list of BathExponent
+        The exponents of the correlation function describing the bath or
+        baths.
+
+    max_depth : int
+        The maximum depth of the hierarchy (i.e. the maximum sum of
+        "excitations" in the hierarchy ADO labels).
+
+    dims : list of int
+        The dimensions of each exponent within the bath(s).
+
+    vk : list of complex
+        The frequency of each exponent within the bath(s).
+
+    ck : list of complex
+        The coefficient of each exponent within the bath(s).
+
+    ck2: list of complex
+        For exponents of type "RI", the coefficient of the exponent within
+        the imaginary expansion. For other exponent types, the entry is None.
+
+    sigma_bar_k_offset: list of int
+        For exponents of type "+" or "-" the offset within the list of modes
+        of the corresponding "-" or "+" exponent. For other exponent types,
+        the entry is None.
+
+    labels: list of tuples
+        A list of the ADO labels within the hierarchy.
+    """
+    def __init__(self, exponents, max_depth):
+        self.exponents = exponents
+        self.max_depth = max_depth
+
+        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
+        self.vk = [exp.vk for exp in self.exponents]
+        self.ck = [exp.ck for exp in self.exponents]
+        self.ck2 = [exp.ck2 for exp in self.exponents]
+        self.sigma_bar_k_offset = [
+            exp.sigma_bar_k_offset for exp in self.exponents
+        ]
+
+        self.labels = list(state_number_enumerate(self.dims, max_depth))
+        self._label_idx = {s: i for i, s in enumerate(self.labels)}
+        self.idx = self._label_idx.__getitem__
+
+    def idx(self, label):
+        """
+        Return the index of the ADO label within the list of labels,
+        i.e. within ``self.labels``.
+
+        Parameters
+        ----------
+        label : tuple
+            The label to look up.
+
+        Returns
+        -------
+        int
+            The index of the label within the list of ADO labels.
+
+        Note
+        ----
+        This implementation of the ``.idx(...)`` method is just for
+        reference and documentation. To avoid the cost of a Python
+        function call, it is replaced with
+        ``self._label_idx.__getitem__`` when the instance is created.
+        """
+        return self._label_idx[label]
+
+    def next(self, label, k):
+        """
+        Return the ADO label with one more excitation in the k'th exponent
+        dimension or ``None`` if adding the excitation would exceed the
+        dimension or maximum depth of the hierarchy.
+
+        Parameters
+        ----------
+        label : tuple
+            The ADO label to add an excitation to.
+        k : int
+            The exponent to add the excitation to.
+
+        Returns
+        -------
+        tuple or None
+            The next label.
+        """
+        if label[k] >= self.dims[k] - 1:
+            return None
+        if sum(label) >= self.max_depth:
+            return None
+        return label[:k] + (label[k] + 1,) + label[k + 1:]
+
+    def prev(self, label, k):
+        """
+        Return the ADO label with one fewer excitation in the k'th
+        exponent dimension or ``None`` if the label has no exciations in the
+        k'th exponent.
+
+        Parameters
+        ----------
+        label : tuple
+            The ADO label to remove the excitation from.
+        k : int
+            The exponent to remove the excitation from.
+
+        Returns
+        -------
+        tuple or None
+            The previous label.
+        """
+        if label[k] <= 0:
+            return None
+        return label[:k] + (label[k] - 1,) + label[k + 1:]
+
+    def exps(self, label):
+        """
+        Converts an ADO label into a tuple of exponents, with one exponent
+        for each "excitation" within the label.
+
+        The number of exponents returned is always equal to the level of the
+        label within the hierarchy (i.e. the sum of the indices within the
+        label).
+
+        Parameters
+        ----------
+        label : tuple
+            The ADO label to convert to a list of exponents.
+
+        Returns
+        -------
+        tuple of BathExponent
+            A tuple of BathExponents.
+
+        Examples
+        --------
+
+        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
+
+        ``ados.exps((2, 0, 0))`` would return
+        ``[ados.exponents[0], ados.exponents[0]]``.
+
+        ``ados.exps((1, 2, 1))`` would return
+        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
+           ados.exponents[2]]``.
+        """
+        return sum(
+            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
+            (),
+        )
+
+    def filter(self, level=None, tags=None, dims=None, types=None):
+        """
+        Return a list of ADO labels for ADOs whose "excitations"
+        match the given patterns.
+
+        Each of the filter parameters (tags, dims, types) may be either
+        unspecified (None) or a list. Unspecified parameters are excluded
+        from the filtering.
+
+        All specified filter parameters must be lists of the same length.
+        Each position in the lists describes a particular excitation and
+        any exponent that matches the filters may supply that excitation.
+        The level of all labels returned is thus equal to the length of
+        the filter parameter lists.
+
+        Within a filter parameter list, items that are None represent
+        wildcards and match any value of that exponent attribute
+
+        Parameters
+        ----------
+        level : int
+            The hierarchy depth to return ADOs from.
+
+        tags : list of object or None
+            Filter parameter that matches the ``.tag`` attribute of
+            exponents.
+
+        dims : list of int
+            Filter parameter that matches the ``.dim`` attribute of
+            exponents.
+
+        types : list of BathExponent types or list of str
+            Filter parameter that matches the ``.type`` attribute
+            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
+            instead of by the actual type (e.g. ``BathExponent.types.R``).
+
+        Returns
+        -------
+        list of tuple
+            The ADO label for each ADO whose exponent excitations
+            (i.e. label) match the given filters or level.
+        """
+        if types is not None:
+            types = [
+                t if t is None or isinstance(t, BathExponent.types)
+                else BathExponent.types[t]
+                for t in types
+            ]
+        filters = [("tag", tags), ("type", types), ("dim", dims)]
+        filters = [(attr, f) for attr, f in filters if f is not None]
+        n = max((len(f) for _, f in filters), default=0)
+        if any(len(f) != n for _, f in filters):
+            raise ValueError(
+                "The tags, dims and types filters must all be the same length."
+            )
+        if n > self.max_depth:
+            raise ValueError(
+                f"The maximum depth for the hierarchy is {self.max_depth} but"
+                f" {n} levels of excitation filters were given."
+            )
+        if level is None:
+            if not filters:
+                # fast path for when there are no excitation filters
+                return self.labels[:]
+        else:
+            if not filters:
+                # fast path for when there are no excitation filters
+                return [label for label in self.labels if sum(label) == level]
+            if level != n:
+                raise ValueError(
+                    f"The level parameter is {level} but {n} levels of"
+                    " excitation filters were given."
+                )
+
+        filtered_dims = [1] * len(self.exponents)
+        for lvl in range(n):
+            level_filters = [
+                (attr, f[lvl]) for attr, f in filters
+                if f[lvl] is not None
+            ]
+            for j, exp in enumerate(self.exponents):
+                if any(getattr(exp, attr) != f for attr, f in level_filters):
+                    continue
+                filtered_dims[j] += 1
+                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
+
+        return [
+            label for label in state_number_enumerate(filtered_dims, n)
+            if sum(label) == n
+        ]
+
+
+class HierarchyADOsState:
+    """
+    Provides convenient access to the full hierarchy ADO state at a particular
+    point in time, ``t``.
+
+    Parameters
+    ----------
+    rho : :class:`~qutip.Qobj`
+        The current state of the system (i.e. the 0th component of the
+        hierarchy).
+    ados : :class:`HierarchyADOs`
+        The description of the hierarchy.
+    ado_state : numpy.array
+        The full state of the hierarchy.
+
+    Attributes
+    ----------
+    rho : Qobj
+        The system state.
+
+    In addition, all of the attributes of the hierarchy description,
+    i.e. ``HierarchyADOs``, are provided directly on this class for
+    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
+    call ``.idx(label)`` directly.
+
+    See :class:`HierarchyADOs` for a full list of the available attributes
+    and methods.
+    """
+    def __init__(self, rho, ados, ado_state):
+        self.rho = rho
+        self._ado_state = ado_state
+        self._ados = ados
+
+    def __getattr__(self, name):
+        return getattr(self._ados, name)
+
+    def extract(self, idx_or_label):
+        """
+        Extract a Qobj representing the specified ADO from a full
+        representation of the ADO states.
+
+        Parameters
+        ----------
+        idx : int or label
+            The index of the ADO to extract. If an ADO label, e.g.
+            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
+            is extracted by label instead.
+
+        Returns
+        -------
+        Qobj
+            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
+        """
+        if isinstance(idx_or_label, int):
+            idx = idx_or_label
+        else:
+            idx = self._ados.idx(idx_or_label)
+        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
+
+
+class HEOMResult(Result):
+    def _post_init(self):
+        super()._post_init()
+
+        self.store_ados = self.options["store_ados"]
+        if self.store_ados:
+            self.final_ado_state = None
+            self.ado_states = []
+
+    def _e_op_func(self, e_op):
+        """ Convert an e_op into a function ``f(t, ado_state)``. """
+        if isinstance(e_op, Qobj):
+            return lambda t, ado_state: (ado_state.rho * e_op).tr()
+        elif isinstance(e_op, QobjEvo):
+            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
+        elif callable(e_op):
+            return e_op
+        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
+
+    def _pre_copy(self, state):
+        return state
+
+    def _store_state(self, t, ado_state):
+        self.states.append(ado_state.rho)
+        if self.store_ados:
+            self.ado_states.append(ado_state)
+
+    def _store_final_state(self, t, ado_state):
+        self.final_state = ado_state.rho
+        if self.store_ados:
+            self.final_ado_state = ado_state
+
+
+def heomsolve(
+    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
+):
+    """
+    Hierarchical Equations of Motion (HEOM) solver that supports multiple
+    baths.
+
+    The baths must be all either bosonic or fermionic baths.
+
+    If you need to run many evolutions of the same system and bath, consider
+    using :class:`HEOMSolver` directly to avoid having to continually
+    reconstruct the equation hierarchy for every evolution.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    bath : Bath or list of Bath
+        A :obj:`Bath` containing the exponents of the expansion of the
+        bath correlation funcion and their associated coefficients
+        and coupling operators, or a list of baths.
+
+        If multiple baths are given, they must all be either fermionic
+        or bosonic baths.
+
+    max_depth : int
+        The maximum depth of the heirarchy (i.e. the maximum number of bath
+        exponent "excitations" to retain).
+
+    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
+        If ``rho0`` is a :class:`~Qobj` the it is the initial state
+        of the system (i.e. a :obj:`~Qobj` density matrix).
+
+        If it is a :class:`~HierarchyADOsState` or array-like, then
+        ``rho0`` gives the initial state of all ADOs.
+
+        Usually the state of the ADOs would be determine from a previous
+        call to ``.run(...)`` with the solver results option ``store_ados``
+        set to True. For example, ``result = solver.run(...)`` could be
+        followed by ``solver.run(result.ado_states[-1], tlist)``.
+
+        If a numpy array-like is passed its shape must be
+        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
+        (i.e. shape of the system density matrix) and the ADOs must
+        be in the same order as in ``.ados.labels``.
+
+    tlist : list
+        An ordered list of times at which to return the value of the state.
+
+    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
+        A list or dictionary of operators as :class:`~Qobj`,
+        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
+        a single operator or callable function. For an operator ``op``, the
+        result will be computed using ``(state * op).tr()`` and the state
+        at each time ``t``. For callable functions, ``f``, the result is
+        computed using ``f(t, ado_state)``. The values are stored in the
+        ``expect`` and ``e_data`` attributes of the result (see the return
+        section below).
+
+    args : dict, optional {None}
+        Change the ``args`` of the RHS for the evolution.
+
+    options : dict, optional {None}
+        Generic solver options.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - store_ados : bool {False, True}
+          Whether or not to store the HEOM ADOs.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - state_data_type: str {'dense'}
+          Name of the data type of the state used during the ODE evolution.
+          Use an empty string to keep the input state type. Many integrator can
+          only work with `Dense`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+    Returns
+    -------
+    :class:`~HEOMResult`
+        The results of the simulation run, with the following important
+        attributes:
+
+        * ``times``: the times ``t`` (i.e. the ``tlist``).
+
+        * ``states``: the system state at each time ``t`` (only available
+          if ``e_ops`` was ``None`` or if the solver option
+          ``store_states`` was set to ``True``).
+
+        * ``ado_states``: the full ADO state at each time (only available
+          if the results option ``ado_return`` was set to ``True``).
+          Each element is an instance of :class:`HierarchyADOsState`.
+          The state of a particular ADO may be extracted from
+          ``result.ado_states[i]`` by calling :meth:`.extract`.
+
+        * ``expect``: a list containing the values of each ``e_ops`` at
+          time ``t``.
+
+        * ``e_data``: a dictionary containing the values of each ``e_ops``
+          at tme ``t``. The keys are those given by ``e_ops`` if it was
+          a dict, otherwise they are the indexes of the supplied ``e_ops``.
+
+        See :class:`~HEOMResult` and :class:`~Result` for the complete
+        list of attributes.
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
+    return solver.run(state0, tlist, e_ops=e_ops)
+
+
+class HEOMSolver(Solver):
+    """
+    HEOM solver that supports multiple baths.
+
+    The baths must be all either bosonic or fermionic baths.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    bath : Bath or list of Bath
+        A :obj:`Bath` containing the exponents of the expansion of the
+        bath correlation funcion and their associated coefficients
+        and coupling operators, or a list of baths.
+
+        If multiple baths are given, they must all be either fermionic
+        or bosonic baths.
+
+    max_depth : int
+        The maximum depth of the heirarchy (i.e. the maximum number of bath
+        exponent "excitations" to retain).
+
+    options : dict, optional
+        Generic solver options.
+        If set to None the default options will be used. Keyword only.
+        Default: None.
+
+    Attributes
+    ----------
+    ados : :obj:`HierarchyADOs`
+        The description of the hierarchy constructed from the given bath
+        and maximum depth.
+
+    rhs : :obj:`QobjEvo`
+        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
+        the system and bath coupling operators are converted to
+        :class:`qutip.data.CSR` instances during construction of the RHS,
+        so the operators in the ``rhs`` will all be sparse.
+    """
+
+    name = "heomsolver"
+    resultclass = HEOMResult
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": False,
+        "method": "adams",
+        "store_ados": False,
+        "state_data_type": "dense",
+    }
+
+    def __init__(self, H, bath, max_depth, *, options=None):
+        _time_start = time()
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
+
+        H = QobjEvo(H)
+        self.L_sys = (
+            liouvillian(H) if H.type == "oper"  # hamiltonian
+            else H  # already a liouvillian
+        )
+
+        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
+        self._sup_shape = self.L_sys.shape[0]
+        self._sys_dims = self.L_sys.dims[0]
+
+        self.ados = HierarchyADOs(
+            self._combine_bath_exponents(bath), max_depth,
+        )
+        self._n_ados = len(self.ados.labels)
+        self._n_exponents = len(self.ados.exponents)
+
+        self._init_ados_time = time() - _time_start
+        _time_start = time()
+
+        # pre-calculate identity matrix required by _grad_n
+        self._sId = _data.identity(self._sup_shape, dtype="csr")
+
+        # pre-calculate superoperators required by _grad_prev and _grad_next:
+        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
+        self._spreQ = [spre(op).data for op in Qs]
+        self._spostQ = [spost(op).data for op in Qs]
+        self._s_pre_minus_post_Q = [
+            _data.sub(self._spreQ[k], self._spostQ[k])
+            for k in range(self._n_exponents)
+        ]
+        self._s_pre_plus_post_Q = [
+            _data.add(self._spreQ[k], self._spostQ[k])
+            for k in range(self._n_exponents)
+        ]
+        self._spreQdag = [spre(op.dag()).data for op in Qs]
+        self._spostQdag = [spost(op.dag()).data for op in Qs]
+        self._s_pre_minus_post_Qdag = [
+            _data.sub(self._spreQdag[k], self._spostQdag[k])
+            for k in range(self._n_exponents)
+        ]
+        self._s_pre_plus_post_Qdag = [
+            _data.add(self._spreQdag[k], self._spostQdag[k])
+            for k in range(self._n_exponents)
+        ]
+
+        self._init_superop_cache_time = time() - _time_start
+        _time_start = time()
+
+        rhs = self._calculate_rhs()
+
+        self._init_rhs_time = time() - _time_start
+
+        super().__init__(rhs, options=options)
+
+    @property
+    def sys_dims(self):
+        """
+        Dimensions of the space that the system use, excluding any environment:
+
+        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
+        for this solver.
+        """
+        return self._sys_dims
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "init time": sum([
+                stats["init time"], self._init_ados_time,
+                self._init_superop_cache_time, self._init_rhs_time,
+            ]),
+            "init ados time": self._init_ados_time,
+            "init superop cache time": self._init_superop_cache_time,
+            "init rhs time": self._init_rhs_time,
+            "solver": "Hierarchical Equations of Motion Solver",
+            "max_depth": self.ados.max_depth,
+        })
+        return stats
+
+    def _combine_bath_exponents(self, bath):
+        """ Combine the exponents for the specified baths. """
+        if not isinstance(bath, (list, tuple)):
+            exponents = bath.exponents
+        else:
+            exponents = []
+            for b in bath:
+                exponents.extend(b.exponents)
+        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
+            raise ValueError(
+                "All bath exponents must have system coupling operators"
+                " with the same dimensions but a mixture of dimensions"
+                " was given."
+            )
+        return exponents
+
+    def _grad_n(self, he_n):
+        """ Get the gradient for the hierarchy ADO at level n. """
+        vk = self.ados.vk
+        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
+        op = _data.mul(self._sId, -vk_sum)
+        return op
+
+    def _grad_prev(self, he_n, k):
+        """ Get the previous gradient. """
+        if self.ados.exponents[k].fermionic:
+            return self._grad_prev_fermionic(he_n, k)
+        else:
+            return self._grad_prev_bosonic(he_n, k)
+
+    def _grad_prev_bosonic(self, he_n, k):
+        if self.ados.exponents[k].type == BathExponent.types.R:
+            op = _data.mul(
+                self._s_pre_minus_post_Q[k],
+                -1j * he_n[k] * self.ados.ck[k],
+            )
+        elif self.ados.exponents[k].type == BathExponent.types.I:
+            op = _data.mul(
+                self._s_pre_plus_post_Q[k],
+                -1j * he_n[k] * 1j * self.ados.ck[k],
+            )
+        elif self.ados.exponents[k].type == BathExponent.types.RI:
+            term1 = _data.mul(
+                self._s_pre_minus_post_Q[k],
+                he_n[k] * -1j * self.ados.ck[k],
+            )
+            term2 = _data.mul(
+                self._s_pre_plus_post_Q[k],
+                he_n[k] * self.ados.ck2[k],
+            )
+            op = _data.add(term1, term2)
+        else:
+            raise ValueError(
+                f"Unsupported type {self.ados.exponents[k].type}"
+                f" for exponent {k}"
+            )
+        return op
+
+    def _grad_prev_fermionic(self, he_n, k):
+        ck = self.ados.ck
+        he_fermionic_n = [
+            i * int(exp.fermionic)
+            for i, exp in zip(he_n, self.ados.exponents)
+        ]
+
+        n_excite = sum(he_fermionic_n)
+        sign1 = (-1) ** (n_excite + 1)
+
+        n_excite_before_m = sum(he_fermionic_n[:k])
+        sign2 = (-1) ** (n_excite_before_m)
+
+        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
+
+        if self.ados.exponents[k].type == BathExponent.types["+"]:
+            op = _data.sub(
+                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
+                _data.mul(
+                    self._spostQdag[k],
+                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
+                ),
+            )
+        elif self.ados.exponents[k].type == BathExponent.types["-"]:
+            op = _data.sub(
+                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
+                _data.mul(
+                    self._spostQ[k],
+                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
+                ),
+            )
+        else:
+            raise ValueError(
+                f"Unsupported type {self.ados.exponents[k].type}"
+                f" for exponent {k}"
+            )
+        return op
+
+    def _grad_next(self, he_n, k):
+        """ Get the previous gradient. """
+        if self.ados.exponents[k].fermionic:
+            return self._grad_next_fermionic(he_n, k)
+        else:
+            return self._grad_next_bosonic(he_n, k)
+
+    def _grad_next_bosonic(self, he_n, k):
+        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
+        return op
+
+    def _grad_next_fermionic(self, he_n, k):
+        he_fermionic_n = [
+            i * int(exp.fermionic)
+            for i, exp in zip(he_n, self.ados.exponents)
+        ]
+        n_excite = sum(he_fermionic_n)
+        sign1 = (-1) ** (n_excite + 1)
+
+        n_excite_before_m = sum(he_fermionic_n[:k])
+        sign2 = (-1) ** (n_excite_before_m)
+
+        if self.ados.exponents[k].type == BathExponent.types["+"]:
+            if sign1 == -1:
+                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
+            else:
+                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
+        elif self.ados.exponents[k].type == BathExponent.types["-"]:
+            if sign1 == -1:
+                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
+            else:
+                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
+        else:
+            raise ValueError(
+                f"Unsupported type {self.ados.exponents[k].type}"
+                f" for exponent {k}"
+            )
+        return op
+
+    def _rhs(self):
+        """ Make the RHS for the HEOM. """
+        ops = _GatherHEOMRHS(
+            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
+        )
+
+        for he_n in self.ados.labels:
+            op = self._grad_n(he_n)
+            ops.add_op(he_n, he_n, op)
+            for k in range(len(self.ados.dims)):
+                next_he = self.ados.next(he_n, k)
+                if next_he is not None:
+                    op = self._grad_next(he_n, k)
+                    ops.add_op(he_n, next_he, op)
+                prev_he = self.ados.prev(he_n, k)
+                if prev_he is not None:
+                    op = self._grad_prev(he_n, k)
+                    ops.add_op(he_n, prev_he, op)
+
+        return ops.gather()
+
+    def _calculate_rhs(self):
+        """ Make the full RHS required by the solver. """
+        rhs_mat = self._rhs()
+        rhs_dims = [
+            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
+        ]
+        h_identity = _data.identity(self._n_ados, dtype="csr")
+
+        if self.L_sys.isconstant:
+            # For the constant case, we just add the Liouvillian to the
+            # diagonal blocks of the RHS matrix.
+            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
+        else:
+            # In the time dependent case, we construct the parameters
+            # for the ODE gradient function under the assumption that
+            #
+            # RHSmat(t) = RHSmat + time dependent terms that only affect the
+            # diagonal blocks of the RHS matrix.
+            #
+            # This assumption holds because only _grad_n dependents on
+            # the system Liouvillian (and not _grad_prev or _grad_next) and
+            # the bath coupling operators are not time-dependent.
+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
+
+            def _kron(x):
+                return Qobj(
+                    _data.kron(h_identity, x.data),
+                    dims=rhs_dims,
+                ).to("csr")
+
+            rhs += self.L_sys.linear_map(_kron)
+
+        # The assertion that rhs_mat has data type CSR is just a sanity
+        # check on the RHS creation. The base solver class will still
+        # convert the RHS to the type required by the ODE integrator if
+        # needed.
+        assert isinstance(rhs_mat, _csr.CSR)
+        assert isinstance(rhs, QobjEvo)
+        assert rhs.dims == rhs_dims
+
+        return rhs
+
+    def steady_state(
+        self,
+        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
+    ):
+        """
+        Compute the steady state of the system.
+
+        Parameters
+        ----------
+        use_mkl : bool, default=False
+            Whether to use mkl or not. If mkl is not installed or if
+            this is false, use the scipy splu solver instead.
+
+        mkl_max_iter_refine : int
+            Specifies the the maximum number of iterative refinement steps that
+            the MKL PARDISO solver performs.
+
+            For a complete description, see iparm(8) in
+            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
+
+        mkl_weighted_matching : bool
+            MKL PARDISO can use a maximum weighted matching algorithm to
+            permute large elements close the diagonal. This strategy adds an
+            additional level of reliability to the factorization methods.
+
+            For a complete description, see iparm(13) in
+            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
+
+        Returns
+        -------
+        steady_state : Qobj
+            The steady state density matrix of the system.
+
+        steady_ados : :class:`HierarchyADOsState`
+            The steady state of the full ADO hierarchy. A particular ADO may be
+            extracted from the full state by calling :meth:`.extract`.
+        """
+        if not self.L_sys.isconstant:
+            raise ValueError(
+                "A steady state cannot be determined for a time-dependent"
+                " system"
+            )
+        n = self._sys_shape
+
+        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
+        b_mat[0] = 1.0
+
+        L = self.rhs(0).data.copy().as_scipy()
+        L = L.tolil()
+        L[0, 0: n ** 2 * self._n_ados] = 0.0
+        L = L.tocsr()
+        L += sp.csr_matrix((
+            np.ones(n),
+            (np.zeros(n), [num * (n + 1) for num in range(n)])
+        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
+
+        if mkl_spsolve is not None and use_mkl:
+            L.sort_indices()
+            solution = mkl_spsolve(
+                L,
+                b_mat,
+                perm=None,
+                verbose=False,
+                max_iter_refine=mkl_max_iter_refine,
+                scaling_vectors=True,
+                weighted_matching=mkl_weighted_matching,
+            )
+        else:
+            L = L.tocsc()
+            solution = spsolve(L, b_mat)
+
+        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
+        data = _data.mul(_data.add(data, data.conj()), 0.5)
+        steady_state = Qobj(data, dims=self._sys_dims)
+
+        solution = solution.reshape((self._n_ados, n, n))
+        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
+
+        return steady_state, steady_ados
+
+    def run(self, state0, tlist, *, args=None, e_ops=None):
+        """
+        Solve for the time evolution of the system.
+
+        Parameters
+        ----------
+        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
+            If ``rho0`` is a :class:`~Qobj` the it is the initial state
+            of the system (i.e. a :obj:`~Qobj` density matrix).
+
+            If it is a :class:`~HierarchyADOsState` or array-like, then
+            ``rho0`` gives the initial state of all ADOs.
+
+            Usually the state of the ADOs would be determine from a previous
+            call to ``.run(...)`` with the solver results option ``store_ados``
+            set to True. For example, ``result = solver.run(...)`` could be
+            followed by ``solver.run(result.ado_states[-1], tlist)``.
+
+            If a numpy array-like is passed its shape must be
+            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
+            (i.e. shape of the system density matrix) and the ADOs must
+            be in the same order as in ``.ados.labels``.
+
+        tlist : list
+            An ordered list of times at which to return the value of the state.
+
+        args : dict, optional {None}
+            Change the ``args`` of the RHS for the evolution.
+
+        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
+            A list or dictionary of operators as :class:`~Qobj`,
+            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
+            a single operator or callable function. For an operator ``op``, the
+            result will be computed using ``(state * op).tr()`` and the state
+            at each time ``t``. For callable functions, ``f``, the result is
+            computed using ``f(t, ado_state)``. The values are stored in the
+            ``expect`` and ``e_data`` attributes of the result (see the return
+            section below).
+
+        Returns
+        -------
+        :class:`~HEOMResult`
+            The results of the simulation run, with the following important
+            attributes:
+
+            * ``times``: the times ``t`` (i.e. the ``tlist``).
+
+            * ``states``: the system state at each time ``t`` (only available
+              if ``e_ops`` was ``None`` or if the solver option
+              ``store_states`` was set to ``True``).
+
+            * ``ado_states``: the full ADO state at each time (only available
+              if the results option ``ado_return`` was set to ``True``).
+              Each element is an instance of :class:`HierarchyADOsState`.
+              The state of a particular ADO may be extracted from
+              ``result.ado_states[i]`` by calling :meth:`.extract`.
+
+            * ``expect``: a list containing the values of each ``e_ops`` at
+              time ``t``.
+
+            * ``e_data``: a dictionary containing the values of each ``e_ops``
+              at tme ``t``. The keys are those given by ``e_ops`` if it was
+              a dict, otherwise they are the indexes of the supplied ``e_ops``.
+
+            See :class:`~HEOMResult` and :class:`~Result` for the complete
+            list of attributes.
+        """
+        return super().run(state0, tlist, args=args, e_ops=e_ops)
+
+    def _prepare_state(self, state):
+        n = self._sys_shape
+        rho_dims = self._sys_dims
+        hierarchy_shape = (self._n_ados, n, n)
+
+        rho0 = state
+        ado_init = not isinstance(rho0, Qobj)
+
+        if ado_init:
+            if isinstance(rho0, HierarchyADOsState):
+                rho0_he = rho0._ado_state
+            elif hasattr(rho0, "shape"):  # array-like
+                rho0_he = rho0
+            else:
+                raise TypeError(
+                    f"Initial ADOs passed have type {type(rho0)}"
+                    " but a HierarchyADOsState or a numpy array-like instance"
+                    " was expected"
+                )
+            if rho0_he.shape != hierarchy_shape:
+                raise ValueError(
+                    f"Initial ADOs passed have shape {rho0_he.shape}"
+                    f" but the solver hierarchy shape is {hierarchy_shape}"
+                )
+            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
+            rho0_he = _data.create(rho0_he)
+        else:
+            if rho0.dims != rho_dims:
+                raise ValueError(
+                    f"Initial state rho has dims {rho0.dims}"
+                    f" but the system dims are {rho_dims}"
+                )
+            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
+            rho0_he[:n ** 2] = rho0.full().ravel('F')
+            rho0_he = _data.create(rho0_he)
+
+        if self.options["state_data_type"]:
+            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
+
+        return rho0_he
+
+    def _restore_state(self, state, *, copy=True):
+        n = self._sys_shape
+        rho_shape = (n, n)
+        rho_dims = self._sys_dims
+        hierarchy_shape = (self._n_ados, n, n)
+
+        rho = Qobj(
+            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
+            dims=rho_dims,
+        )
+        ado_state = HierarchyADOsState(
+            rho, self.ados, state.to_array().reshape(hierarchy_shape)
+        )
+        return ado_state
+
+    def start(self, state0, t0):
+        """
+        Set the initial state and time for a step evolution.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution. This may provide either just the
+            initial density matrix of the system, or the full set of ADOs
+            for the hierarchy. See the documentation for ``rho0`` in the
+            ``.run(...)`` method for details.
+
+        t0 : double
+            Initial time of the evolution.
+        """
+        super().start(state0, t0)
+
+    @property
+    def options(self):
+        """
+        Options for HEOMSolver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        normalize_output: bool, default=False
+            Normalize output state to hide ODE numerical errors.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error
+            if not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size": 10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        method: str, default="adams"
+            Which ordinary differential equation integration method to use.
+
+        state_data_type: str, default="dense"
+            Name of the data type of the state used during the ODE evolution.
+            Use an empty string to keep the input state type. Many integrators
+            support only work with `Dense`.
+
+        store_ados : bool, default=False
+            Whether or not to store the HEOM ADOs. Only relevant when using
+            the HEOM solver.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Solver.options.fset(self, new_options)
+
+
+class HSolverDL(HEOMSolver):
+    """
+    A helper class for creating an :class:`HEOMSolver` that is backwards
+    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
+    in QuTiP 4.6 and below.
+
+    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
+    descriptions of the underlying solver and bath construction.
+
+    An exact copy of the QuTiP 4.6 HSolverDL is provided in
+    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
+    the older solver is required. The older solver will be completely
+    removed in QuTiP 5.
+
+    .. note::
+
+        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
+        supports supplying a time-dependent or Liouvillian ``H_sys``.
+
+    .. note::
+
+        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
+        parameter ``N_exp`` specifying the number of exponents to keep in
+        the expansion of the bath correlation function is one more than
+        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
+        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
+        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
+        order to better match common usage in the literature.
+
+    .. note::
+
+        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
+        are no longer supported.
+
+    Parameters
+    ----------
+    H_sys : Qobj or QobjEvo or list
+        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
+        a complete description.
+
+    coup_op : Qobj
+        Operator describing the coupling between system and bath.
+        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
+
+    coup_strength : float
+        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
+
+    temperature : float
+        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
+
+    N_cut : int
+        The maximum depth of the hierarchy. See ``max_depth`` in
+        :class:`HEOMSolver` for a full description.
+
+    N_exp : int
+        Number of exponential terms used to approximate the bath correlation
+        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
+        less than ``N_exp`` (see note above).
+
+    cut_freq : float
+        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
+        :class:`DrudeLorentzBath`.
+
+    bnd_cut_approx : bool
+        Use boundary cut off approximation. If true, the Matsubara
+        terminator is added to the system Liouvillian (and H_sys is
+        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
+        Default: False.
+
+    options : dict, optional
+        Generic solver options.
+        If set to None the default options will be used. Keyword only.
+        Default: None.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+        Keyword only. Default: True.
+    """
+    def __init__(
+        self, H_sys, coup_op, coup_strength, temperature,
+        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
+        combine=True,
+    ):
+        H_sys = QobjEvo(H_sys)
+        bath = DrudeLorentzBath(
+            Q=coup_op,
+            lam=coup_strength,
+            gamma=cut_freq,
+            Nk=N_exp - 1,
+            T=temperature,
+            combine=combine,
+        )
+
+        if bnd_cut_approx:
+            # upgrade H_sys to a Liouvillian if needed and add the
+            # bath terminator
+            if H_sys.type == "oper":  # H_sys is a Hamiltonian
+                H_sys = liouvillian(H_sys)
+            _, terminator = bath.terminator()
+            H_sys = H_sys + terminator
+
+        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
+
+        # store input parameters as attributes for politeness and compatibility
+        # with HSolverDL in QuTiP 4.6 and below.
+        self.coup_strength = coup_strength
+        self.cut_freq = cut_freq
+        self.temperature = temperature
+        self.N_exp = N_exp
+        self.bnd_cut_approx = bnd_cut_approx
+
+
+class _GatherHEOMRHS:
+    """ A class for collecting elements of the right-hand side matrix
+        of the HEOM.
+
+        Parameters
+        ----------
+        f_idx: function(he_state) -> he_idx
+            A function that returns the index of a hierarchy state
+            (i.e. an ADO label).
+        block : int
+            The size of a single ADO Liovillian operator in the hierarchy.
+        nhe : int
+            The number of ADOs in the hierarchy.
+    """
+    def __init__(self, f_idx, block, nhe):
+        self._block_size = block
+        self._n_blocks = nhe
+        self._f_idx = f_idx
+        self._ops = []
+
+    def add_op(self, row_he, col_he, op):
+        """ Add an block operator to the list. """
+        self._ops.append(
+            (self._f_idx(row_he), self._f_idx(col_he), op)
+        )
+
+    def gather(self):
+        """ Create the HEOM liouvillian from a sorted list of smaller sparse
+            matrices.
+
+            .. note::
+
+                The list of operators contains tuples of the form
+                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
+                *block* row and column for each op. An operator with
+                block indices ``(N, M)`` is placed at position
+                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
+                in the output matrix.
+
+            Returns
+            -------
+            rhs : :obj:`Data`
+                A combined matrix of shape ``(block * nhe, block * ne)``.
+        """
+        self._ops.sort()
+        ops = np.array(self._ops, dtype=[
+            ("row", _data.base.idxint_dtype),
+            ("col", _data.base.idxint_dtype),
+            ("op", _data.CSR),
+        ])
+        return _csr._from_csr_blocks(
+            ops["row"], ops["col"], ops["op"],
+            self._n_blocks, self._block_size,
+        )
diff --git a/qutip/solver/integrator/__init__.py b/qutip/solver/integrator/__init__.py
index 987cfcd545..8e404a99a3 100644
--- a/qutip/solver/integrator/__init__.py
+++ b/qutip/solver/integrator/__init__.py
@@ -1,4 +1,4 @@
-from .integrator import *
-from .scipy_integrator import *
-from .qutip_integrator import *
-from .krylov import *
+from .integrator import *
+from .scipy_integrator import *
+from .qutip_integrator import *
+from .krylov import *
diff --git a/qutip/solver/integrator/explicit_rk.pxd b/qutip/solver/integrator/explicit_rk.pxd
index 46bbcf9712..c149c6c01b 100644
--- a/qutip/solver/integrator/explicit_rk.pxd
+++ b/qutip/solver/integrator/explicit_rk.pxd
@@ -1,63 +1,63 @@
-#cython: language_level=3
-from qutip.core.data cimport Data
-from qutip.core.cy.qobjevo cimport QobjEvo
-
-cpdef enum Status:
-    AT_FRONT = 2
-    INTERPOLATED = 1
-    NORMAL = 0
-    TOO_MUCH_WORK = -1
-    DT_UNDERFLOW = -2
-    OUTSIDE_RANGE = -3
-    NOT_INITIATED = -4
-
-cdef class Explicit_RungeKutta:
-    cdef QobjEvo qevo
-
-    # Ode state data, set in set_initial_value
-    cdef list k
-    cdef Data _y_temp, _y, _y_prev, _y_front
-    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
-    cdef double _t, _t_prev, _t_front
-    cdef Status _status
-    cdef dict status_messages
-
-    # options: set in init
-    cdef readonly double rtol, atol, first_step, min_step, max_step
-    cdef readonly int max_numsteps
-    cdef readonly bint interpolate
-    cdef readonly object method
-
-    # Runge Kutta tableau and info
-    cdef int rk_step, rk_extra_step, order, denseout_order
-    cdef bint adaptative_step, can_interpolate
-    cdef object b_factor_np
-    cdef double [:] b
-    cdef double [:] b_factor
-    cdef double [:] c
-    cdef double [:] e
-    cdef double [:, ::1] a
-    cdef double [:, ::1] bi
-
-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
-
-    cpdef void set_initial_value(self, Data y0, double t)
-
-    cdef int _step_in_err(self, double t, int max_step)
-
-    cdef double _compute_step(self, double dt)
-
-    cdef double _error(self, Data y_new, double dt)
-
-    cdef void _prep_dense_out(self)
-
-    cdef Data _interpolate_step(self, double t, Data out)
-
-    cdef inline Data _accumulate(self, Data target, double[:] factors,
-                                 double dt, int size)
-
-    cdef double _estimate_first_step(self, double t, Data y0)
-
-    cdef double _get_timestep(self, double t)
-
-    cdef void _recompute_safe_step(self, double err, double dt)
+#cython: language_level=3
+from qutip.core.data cimport Data
+from qutip.core.cy.qobjevo cimport QobjEvo
+
+cpdef enum Status:
+    AT_FRONT = 2
+    INTERPOLATED = 1
+    NORMAL = 0
+    TOO_MUCH_WORK = -1
+    DT_UNDERFLOW = -2
+    OUTSIDE_RANGE = -3
+    NOT_INITIATED = -4
+
+cdef class Explicit_RungeKutta:
+    cdef QobjEvo qevo
+
+    # Ode state data, set in set_initial_value
+    cdef list k
+    cdef Data _y_temp, _y, _y_prev, _y_front
+    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
+    cdef double _t, _t_prev, _t_front
+    cdef Status _status
+    cdef dict status_messages
+
+    # options: set in init
+    cdef readonly double rtol, atol, first_step, min_step, max_step
+    cdef readonly int max_numsteps
+    cdef readonly bint interpolate
+    cdef readonly object method
+
+    # Runge Kutta tableau and info
+    cdef int rk_step, rk_extra_step, order, denseout_order
+    cdef bint adaptative_step, can_interpolate
+    cdef object b_factor_np
+    cdef double [:] b
+    cdef double [:] b_factor
+    cdef double [:] c
+    cdef double [:] e
+    cdef double [:, ::1] a
+    cdef double [:, ::1] bi
+
+    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
+
+    cpdef void set_initial_value(self, Data y0, double t)
+
+    cdef int _step_in_err(self, double t, int max_step)
+
+    cdef double _compute_step(self, double dt)
+
+    cdef double _error(self, Data y_new, double dt)
+
+    cdef void _prep_dense_out(self)
+
+    cdef Data _interpolate_step(self, double t, Data out)
+
+    cdef inline Data _accumulate(self, Data target, double[:] factors,
+                                 double dt, int size)
+
+    cdef double _estimate_first_step(self, double t, Data y0)
+
+    cdef double _get_timestep(self, double t)
+
+    cdef void _recompute_safe_step(self, double err, double dt)
diff --git a/qutip/solver/integrator/explicit_rk.pyx b/qutip/solver/integrator/explicit_rk.pyx
index 17220ea25a..37dd384df5 100644
--- a/qutip/solver/integrator/explicit_rk.pyx
+++ b/qutip/solver/integrator/explicit_rk.pyx
@@ -1,510 +1,510 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
-"""
-Provide a cython implimentation for a general Explicit runge-Kutta method.
-"""
-from qutip.core.data cimport Data, Dense, CSR, dense
-from qutip.core.data.add cimport iadd_dense
-from qutip.core.data.add import add
-from qutip.core.data.mul import imul_data
-from qutip.core.data.tidyup import tidyup_csr
-from qutip.core.data.norm import frobenius_data
-from .verner7efficient import vern7_coeff
-from .verner9efficient import vern9_coeff
-cimport cython
-import numpy as np
-
-euler_coeff = {
-    'order': 1,
-    'a': np.array([[0.]], dtype=np.float64),
-    'b': np.array([1.], dtype=np.float64),
-    'c': np.array([0.], dtype=np.float64)
-}
-
-rk4_coeff = {
-    'order': 4,
-    'a': np.array([[0., 0., 0., 0.],
-                   [.5, 0., 0., 0.],
-                   [0., .5, 0., 0.],
-                   [0., 0., 1., 0.]], dtype=np.float64),
-    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
-    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
-}
-
-
-cdef Data copy_to(Data in_, Data out):
-    # Copy while reusing allocated buffer if possible.
-    # Does not check the shape, etc.
-    cdef size_t ptr
-    if type(in_) is Dense:
-        for ptr in range(in_.shape[0] * in_.shape[1]):
-            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
-        return out
-    else:
-        return in_.copy()
-
-
-cdef Data iadd_data(Data left, Data right, double complex factor):
-    # left += right * factor
-    # reusing `left' allocated buffer if possible.
-    # TODO: when/if iadd_csr is added: move to data/add.pyx.
-    if factor == 0:
-        return left
-    if type(left) is Dense:
-        iadd_dense(left, right, factor)
-        return left
-    else:
-        return add(left, right, factor)
-
-
-cdef class Explicit_RungeKutta:
-    """
-    Qutip implementation of Runge Kutta ODE.
-    Works in :class:`Data` allowing solving using sparse and gpu data.
-
-    Parameters
-    ----------
-    qevo : QobjEvo
-        The system to integrate: ```dX = qevo.matmul_data(t, X)``
-
-    rtol, atol : double
-        Relative and absolute tolerance of the integration error respectively.
-
-    nsteps : int
-        Maximum number of steps done during one call of integrate.
-
-    first_step : double
-        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
-        be determined automaticaly.
-
-    min_step, max_step : double
-        Bounds of the step lenght in ``t``. ``0`` means no bounds.
-
-    interpolate : bool
-        Whether to do longer step and interpolate back when the method support
-        it.
-        Example:
-            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
-            safely integrate up to ``t=3``. If ``interpolate=True``, it will
-            integrate up to ``t=3`` and then use interpolation to get the state
-            at ``t=2``. With ``interpolate=False``, it will integrate to
-            ``t=2``.
-
-    method : ['euler', 'rk4', 'vern7', 'vern9']
-        The integration method to use.
-        * It also accept a tuple of runge-kutta coefficients.
-        (See `Explicit_RungeKutta._init_coeff`)
-    """
-    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
-                 int nsteps=1000, double first_step=0, double min_step=0,
-                 double max_step=0, bint interpolate=True, method="euler"):
-        # Function to integrate.
-        self.qevo = qevo
-        # tolerances
-        self.atol = atol
-        self.rtol = rtol
-        self._dt_safe = atol
-        # Number of step to do before giving up
-        self.max_numsteps = nsteps
-
-        # contrain on the step times
-        self.first_step = first_step
-        self.min_step = min_step or 1e-15
-        self.max_step = max_step
-
-        # If True, will do the steps longer that the target and use
-        # interpolation to get the state at the wanted time.
-        self.interpolate = interpolate
-
-        self.k = []
-        if isinstance(method, dict):
-            self._init_coeff(**method)
-        elif "vern7" == method:
-            self._init_coeff(**vern7_coeff)
-        elif "vern9" == method:
-            self._init_coeff(**vern9_coeff)
-        elif "rk4" == method:
-            self._init_coeff(**rk4_coeff)
-        else:
-            self._init_coeff(**euler_coeff)
-        self.method = method
-        self._y_prev = None
-
-    def _init_coeff(self, order, a, b, c, e=None, bi=None):
-        """
-        Read the Butcher tableau.
-
-        Parameters
-        ----------
-        order : int
-            Order of the method
-
-        a, b, c : numpy.ndarray
-            The Butcher tableau:
-            c_0 | a_00 a_01
-            c_1 | a_10 a_11
-            ---------------
-                  b_0  b_1
-            The ``c`` vector should start with `0` and the first line of ``a``
-            is also expected to be zeros.
-            The ``a`` and ``c`` part of the tableau can be larger than the
-            number of step if dense output is available.
-
-        e : numpy.ndarray (optional)
-            The error coefficients. If given, adaptative step length will be
-            used to stay within the given tolerance.
-            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
-
-        bi : numpy.ndarray (optional)
-            The coefficients for the dense output.
-            The dense output is computed as:
-                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
-            with ``k[i]`` the derivative computed from ``a`` and ``c``.
-        """
-        self.order = order
-        self.rk_step = b.shape[0]
-        self.rk_extra_step = c.shape[0]
-        if (
-            self.rk_step > self.rk_extra_step or
-            a.shape[1] != self.rk_extra_step or
-            a.shape[0] != self.rk_extra_step
-        ):
-            raise ValueError("Inconsistant shape between the Butcher tableau "
-                             "parts.")
-
-        self.adaptative_step = e is not None
-        if self.adaptative_step and e.shape[0] != self.rk_step:
-            raise ValueError("The length of the error coefficients must be the"
-                             " same as the number of steps in the Butcher "
-                             f"tableau. Got {e.shape[0]} but expected "
-                             f"{self.rk_step}")
-
-        self.interpolate = bi is not None and self.interpolate
-        if self.interpolate:
-            self.denseout_order = bi.shape[1]
-            if bi.shape[0] != self.rk_extra_step:
-                raise ValueError("The interpolation coefficient's shape must "
-                                 "be (a.shape[0], dense output order)")
-
-        self.a = a
-        self.b = b
-        self.c = c
-        self.e = e
-        self.bi = bi
-        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
-        self.b_factor = self.b_factor_np
-
-    cpdef void set_initial_value(self, Data y0, double t):
-        """
-        Set the initial state and time of the integration.
-        """
-        self._t = t
-        self._t_prev = t
-        self._t_front = t
-        self._dt_int = 0
-        self._y = y0
-        self._norm_prev = frobenius_data(self._y)
-        self._norm_front = self._norm_prev
-
-        #prepare the buffers
-        for i in range(self.rk_extra_step):
-            self.k.append(self._y.copy())
-        self._y_temp = self._y.copy()
-        self._y_front = self._y.copy()
-        self._y_prev = self._y.copy()
-
-        if not self.first_step:
-            self._dt_safe = self._estimate_first_step(t, self._y)
-        else:
-            self._dt_safe = self.first_step
-
-    cdef double _estimate_first_step(self, double t, Data y0):
-        if not self.adaptative_step:
-            return 0.
-
-        cdef double dt1, dt2, dt, factorial = 1, t1
-        cdef double norm = frobenius_data(y0), tmp_norm
-        cdef double tol = self.atol + norm * self.rtol
-        cdef int i
-        self.k[0] = imul_data(<Data> self.k[0], 0)
-        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
-
-        # Ok approximation for linear system. But not in a general case.
-        if norm <= self.atol:
-            norm = 1
-        tmp_norm = frobenius_data(<Data> self.k[0])
-        for i in range(1, self.order+1):
-            factorial *= i
-        if tmp_norm >= (self.atol * 1e-6):
-            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
-                   / tmp_norm)
-        else:
-            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
-
-        t1 = t + dt1 / 100
-        self._y_temp = copy_to(y0, self._y_temp)
-        # below dt1 / 100 is an arbitrary small fraction of dt1:
-        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
-        self.k[1] = imul_data(<Data> self.k[1], 0)
-        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
-        tmp_norm = frobenius_data(<Data> self.k[1])
-        if tmp_norm >= (self.atol * 1e-6):
-            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
-                   / tmp_norm)
-        else:
-            dt2 = dt1
-
-        dt = min(dt1, dt2)
-        if self.max_step:
-            dt = min(self.max_step, dt)
-        if self.min_step:
-            dt = max(self.min_step, dt)
-        return dt
-
-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
-        """
-        Do the integration to t.
-        If ``step`` is True, it will make a maximum 1 step and may not reach
-        ``t``.
-        """
-        cdef int nsteps_left = self.max_numsteps
-        cdef double err = 0
-
-        if self._y_prev is None:
-            self._status = Status.NOT_INITIATED
-            return
-
-        self._status = Status.NORMAL
-
-        if t == self._t:
-            return
-
-        if t < self._t_prev:
-            self._status = Status.OUTSIDE_RANGE
-            return
-
-        if self.interpolate and t < self._t_front:
-             self._y = self._interpolate_step(t, self._y)
-             self._t = t
-
-        if step and self._t < self._t_front and t > self._t_front:
-            # To ensure that the self._t ... t_out interval can be covered.
-            t = self._t_front
-
-        while self._t_front < t:
-            self._y_prev = copy_to(self._y_front, self._y_prev)
-            self._t_prev = self._t_front
-            self._norm_prev = self._norm_front
-            nsteps_left -= self._step_in_err(t, nsteps_left)
-            if step:
-                break
-
-        if self._status < 0:
-            return
-
-        if self._t_front > t:
-            self._prep_dense_out()
-            self._status = Status.INTERPOLATED
-            self._t = t
-            self._y = self._interpolate_step(t, self._y)
-        else:
-            self._status = Status.AT_FRONT
-            self._t = self._t_front
-            self._y = copy_to(self._y_front, self._y)
-
-    cdef int _step_in_err(self, double t, int max_step):
-        """
-        Do compute one step, repeating until the error is within tolerance.
-        """
-        cdef double error = 1
-        cdef int nsteps = 0
-        while error >= 1:
-            dt = self._get_timestep(t)
-            error = self._compute_step(dt)
-            self._dt_int = dt
-            self._recompute_safe_step(error, dt)
-
-            if dt == self.min_step and error > 1:
-                # The tolerance was not reached but the dt is at the minimum.
-                self._status = Status.DT_UNDERFLOW
-                break
-            nsteps += 1
-            if nsteps > max_step:
-                self._status = Status.TOO_MUCH_WORK
-                break
-        return nsteps
-
-    cdef double _compute_step(self, double dt):
-        """
-        Do compute one step with fixed ``dt``, return the error.
-        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
-        """
-        cdef int i
-        for i in range(self.rk_step):
-            self.k[i] = imul_data(<Data> self.k[i], 0.)
-
-        # Compute the derivatives
-        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
-                                          <Data> self.k[0])
-        for i in range(1, self.rk_step):
-            self._y_temp = copy_to(self._y_prev, self._y_temp)
-            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
-            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
-                                              self._y_temp, <Data> self.k[i])
-
-        # Compute the state
-        self._y_front = copy_to(self._y_prev, self._y_front)
-        self._y_front = self._accumulate(self._y_front, self.b, dt,
-                                         self.rk_step)
-        self._t_front = self._t_prev + dt
-
-        if type(self._y_front) is CSR:
-            # issparse() test would be better.
-            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
-
-        return self._error(self._y_front, dt)
-
-    cdef double _error(self, Data y_new, double dt):
-        """ Compute the normalized error. (error/tol) """
-        if not self.adaptative_step:
-            return 0.
-        self._y_temp = imul_data(self._y_temp, 0.)
-        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
-        self._norm_front = frobenius_data(y_new)
-        return frobenius_data(self._y_temp) / (self.atol +
-                max(self._norm_prev, self._norm_front) * self.rtol)
-
-    cdef void _prep_dense_out(self):
-        """
-        Compute derivative for the interpolation step.
-        """
-        cdef double dt = self._dt_int
-
-        for i in range(self.rk_step, self.rk_extra_step):
-            self.k[i] = imul_data(<Data> self.k[i], 0.)
-            self._y_temp = copy_to(self._y_prev, self._y_temp)
-            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
-            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
-                                              self._y_temp, <Data> self.k[i])
-
-    cdef Data _interpolate_step(self, double t, Data out):
-        """
-        Compute the state at any points between _t_prev and _t_front
-        with an error of ~dt**denseout_order.
-        """
-        cdef:
-            int i, j
-            double t0 = self._t_prev
-            double dt = self._dt_int
-            double tau = (t - t0) / dt
-        for i in range(self.rk_extra_step):
-            self.b_factor[i] = 0.
-            for j in range(self.denseout_order-1, -1, -1):
-                self.b_factor[i] += self.bi[i,j]
-                self.b_factor[i] *= tau
-
-        out = copy_to(self._y_prev, out)
-        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
-        return out
-
-    cdef inline Data _accumulate(self, Data target, double[:] factors,
-                         double dt, int size):
-        cdef int i
-        for i in range(size):
-            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
-        return target
-
-    @cython.cdivision(True)
-    cdef double _get_timestep(self, double t):
-        """ Get the dt for the step. """
-        cdef double dt_needed = t - self._t_front
-        if not self.adaptative_step:
-            return dt_needed
-        if self.interpolate:
-            return self._dt_safe
-        if dt_needed <= self._dt_safe:
-            return dt_needed
-        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
-
-    cdef void _recompute_safe_step(self, double err, double dt):
-        """ Get maximum safe step in function of the error."""
-        cdef double factor
-        if not self.adaptative_step:
-            return
-        elif err == 0:
-            factor = 10
-        else:
-            factor = 0.9*err**(-1/(self.order+1))
-            factor = min(10, factor)
-            factor = max(0.2, factor)
-
-        self._dt_safe = dt * factor
-        if self.max_step:
-            self._dt_safe = min(self.max_step, self._dt_safe)
-        if self.min_step:
-            self._dt_safe = max(self.min_step, self._dt_safe)
-
-    def successful(self):
-        return self._status >= 0
-
-    @property
-    def status(self):
-        return self._status
-
-    def status_message(self):
-        "Status of the last step in a human readable format."
-        return {
-            AT_FRONT: "Internal state at the desired time.",
-            INTERPOLATED: (
-                "Internal state past the desired time and "
-                "interpolation to step done."),
-            NORMAL: 'No work done.',
-            TOO_MUCH_WORK: (
-                'Too much work done in one call. Try to increase '
-                'the nsteps parameter or increasing the tolerance.'
-            ),
-            DT_UNDERFLOW:
-                'Step size becomes too small. Try increasing tolerance.',
-            OUTSIDE_RANGE: 'Step outside available range.',
-            NOT_INITIATED: 'Not initialized.'
-        }[self._status]
-
-    @property
-    def y(self):
-        return self._y
-
-    @property
-    def y_prev(self):
-        return self._y_prev
-
-    @property
-    def y_front(self):
-        return self._y_front
-
-    @property
-    def t_front(self):
-        return self._t_front
-
-    @property
-    def t_prev(self):
-        return self._t_prev
-
-    @property
-    def t(self):
-        return self._t
-
-    def _debug_state(self):
-        print("t, y: ", self._t,
-              'None' if self._y is None else self._y.to_array())
-        print("t_prev, y_prev, |y_prev|", self._t_prev,
-              'None' if self._y_prev is None else self._y_prev.to_array(),
-              self._norm_prev)
-        print("t_front, y_front, |y_front|", self._t_front,
-              'None' if self._y_front is None else self._y_front.to_array(),
-              self._norm_front)
-        print("y_temp",
-              'None' if self._y_temp is None else self._y_temp.to_array())
-        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
-        for i in range(self.rk_extra_step):
-            print(f'k[{i}]',
-                  'None' if self.k[i] is None else self.k[i].to_array())
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
+"""
+Provide a cython implimentation for a general Explicit runge-Kutta method.
+"""
+from qutip.core.data cimport Data, Dense, CSR, dense
+from qutip.core.data.add cimport iadd_dense
+from qutip.core.data.add import add
+from qutip.core.data.mul import imul_data
+from qutip.core.data.tidyup import tidyup_csr
+from qutip.core.data.norm import frobenius_data
+from .verner7efficient import vern7_coeff
+from .verner9efficient import vern9_coeff
+cimport cython
+import numpy as np
+
+euler_coeff = {
+    'order': 1,
+    'a': np.array([[0.]], dtype=np.float64),
+    'b': np.array([1.], dtype=np.float64),
+    'c': np.array([0.], dtype=np.float64)
+}
+
+rk4_coeff = {
+    'order': 4,
+    'a': np.array([[0., 0., 0., 0.],
+                   [.5, 0., 0., 0.],
+                   [0., .5, 0., 0.],
+                   [0., 0., 1., 0.]], dtype=np.float64),
+    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
+    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
+}
+
+
+cdef Data copy_to(Data in_, Data out):
+    # Copy while reusing allocated buffer if possible.
+    # Does not check the shape, etc.
+    cdef size_t ptr
+    if type(in_) is Dense:
+        for ptr in range(in_.shape[0] * in_.shape[1]):
+            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
+        return out
+    else:
+        return in_.copy()
+
+
+cdef Data iadd_data(Data left, Data right, double complex factor):
+    # left += right * factor
+    # reusing `left' allocated buffer if possible.
+    # TODO: when/if iadd_csr is added: move to data/add.pyx.
+    if factor == 0:
+        return left
+    if type(left) is Dense:
+        iadd_dense(left, right, factor)
+        return left
+    else:
+        return add(left, right, factor)
+
+
+cdef class Explicit_RungeKutta:
+    """
+    Qutip implementation of Runge Kutta ODE.
+    Works in :class:`Data` allowing solving using sparse and gpu data.
+
+    Parameters
+    ----------
+    qevo : QobjEvo
+        The system to integrate: ```dX = qevo.matmul_data(t, X)``
+
+    rtol, atol : double
+        Relative and absolute tolerance of the integration error respectively.
+
+    nsteps : int
+        Maximum number of steps done during one call of integrate.
+
+    first_step : double
+        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
+        be determined automaticaly.
+
+    min_step, max_step : double
+        Bounds of the step lenght in ``t``. ``0`` means no bounds.
+
+    interpolate : bool
+        Whether to do longer step and interpolate back when the method support
+        it.
+        Example:
+            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
+            safely integrate up to ``t=3``. If ``interpolate=True``, it will
+            integrate up to ``t=3`` and then use interpolation to get the state
+            at ``t=2``. With ``interpolate=False``, it will integrate to
+            ``t=2``.
+
+    method : ['euler', 'rk4', 'vern7', 'vern9']
+        The integration method to use.
+        * It also accept a tuple of runge-kutta coefficients.
+        (See `Explicit_RungeKutta._init_coeff`)
+    """
+    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
+                 int nsteps=1000, double first_step=0, double min_step=0,
+                 double max_step=0, bint interpolate=True, method="euler"):
+        # Function to integrate.
+        self.qevo = qevo
+        # tolerances
+        self.atol = atol
+        self.rtol = rtol
+        self._dt_safe = atol
+        # Number of step to do before giving up
+        self.max_numsteps = nsteps
+
+        # contrain on the step times
+        self.first_step = first_step
+        self.min_step = min_step or 1e-15
+        self.max_step = max_step
+
+        # If True, will do the steps longer that the target and use
+        # interpolation to get the state at the wanted time.
+        self.interpolate = interpolate
+
+        self.k = []
+        if isinstance(method, dict):
+            self._init_coeff(**method)
+        elif "vern7" == method:
+            self._init_coeff(**vern7_coeff)
+        elif "vern9" == method:
+            self._init_coeff(**vern9_coeff)
+        elif "rk4" == method:
+            self._init_coeff(**rk4_coeff)
+        else:
+            self._init_coeff(**euler_coeff)
+        self.method = method
+        self._y_prev = None
+
+    def _init_coeff(self, order, a, b, c, e=None, bi=None):
+        """
+        Read the Butcher tableau.
+
+        Parameters
+        ----------
+        order : int
+            Order of the method
+
+        a, b, c : numpy.ndarray
+            The Butcher tableau:
+            c_0 | a_00 a_01
+            c_1 | a_10 a_11
+            ---------------
+                  b_0  b_1
+            The ``c`` vector should start with `0` and the first line of ``a``
+            is also expected to be zeros.
+            The ``a`` and ``c`` part of the tableau can be larger than the
+            number of step if dense output is available.
+
+        e : numpy.ndarray (optional)
+            The error coefficients. If given, adaptative step length will be
+            used to stay within the given tolerance.
+            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
+
+        bi : numpy.ndarray (optional)
+            The coefficients for the dense output.
+            The dense output is computed as:
+                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
+            with ``k[i]`` the derivative computed from ``a`` and ``c``.
+        """
+        self.order = order
+        self.rk_step = b.shape[0]
+        self.rk_extra_step = c.shape[0]
+        if (
+            self.rk_step > self.rk_extra_step or
+            a.shape[1] != self.rk_extra_step or
+            a.shape[0] != self.rk_extra_step
+        ):
+            raise ValueError("Inconsistant shape between the Butcher tableau "
+                             "parts.")
+
+        self.adaptative_step = e is not None
+        if self.adaptative_step and e.shape[0] != self.rk_step:
+            raise ValueError("The length of the error coefficients must be the"
+                             " same as the number of steps in the Butcher "
+                             f"tableau. Got {e.shape[0]} but expected "
+                             f"{self.rk_step}")
+
+        self.interpolate = bi is not None and self.interpolate
+        if self.interpolate:
+            self.denseout_order = bi.shape[1]
+            if bi.shape[0] != self.rk_extra_step:
+                raise ValueError("The interpolation coefficient's shape must "
+                                 "be (a.shape[0], dense output order)")
+
+        self.a = a
+        self.b = b
+        self.c = c
+        self.e = e
+        self.bi = bi
+        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
+        self.b_factor = self.b_factor_np
+
+    cpdef void set_initial_value(self, Data y0, double t):
+        """
+        Set the initial state and time of the integration.
+        """
+        self._t = t
+        self._t_prev = t
+        self._t_front = t
+        self._dt_int = 0
+        self._y = y0
+        self._norm_prev = frobenius_data(self._y)
+        self._norm_front = self._norm_prev
+
+        #prepare the buffers
+        for i in range(self.rk_extra_step):
+            self.k.append(self._y.copy())
+        self._y_temp = self._y.copy()
+        self._y_front = self._y.copy()
+        self._y_prev = self._y.copy()
+
+        if not self.first_step:
+            self._dt_safe = self._estimate_first_step(t, self._y)
+        else:
+            self._dt_safe = self.first_step
+
+    cdef double _estimate_first_step(self, double t, Data y0):
+        if not self.adaptative_step:
+            return 0.
+
+        cdef double dt1, dt2, dt, factorial = 1, t1
+        cdef double norm = frobenius_data(y0), tmp_norm
+        cdef double tol = self.atol + norm * self.rtol
+        cdef int i
+        self.k[0] = imul_data(<Data> self.k[0], 0)
+        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
+
+        # Ok approximation for linear system. But not in a general case.
+        if norm <= self.atol:
+            norm = 1
+        tmp_norm = frobenius_data(<Data> self.k[0])
+        for i in range(1, self.order+1):
+            factorial *= i
+        if tmp_norm >= (self.atol * 1e-6):
+            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
+                   / tmp_norm)
+        else:
+            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
+
+        t1 = t + dt1 / 100
+        self._y_temp = copy_to(y0, self._y_temp)
+        # below dt1 / 100 is an arbitrary small fraction of dt1:
+        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
+        self.k[1] = imul_data(<Data> self.k[1], 0)
+        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
+        tmp_norm = frobenius_data(<Data> self.k[1])
+        if tmp_norm >= (self.atol * 1e-6):
+            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
+                   / tmp_norm)
+        else:
+            dt2 = dt1
+
+        dt = min(dt1, dt2)
+        if self.max_step:
+            dt = min(self.max_step, dt)
+        if self.min_step:
+            dt = max(self.min_step, dt)
+        return dt
+
+    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
+        """
+        Do the integration to t.
+        If ``step`` is True, it will make a maximum 1 step and may not reach
+        ``t``.
+        """
+        cdef int nsteps_left = self.max_numsteps
+        cdef double err = 0
+
+        if self._y_prev is None:
+            self._status = Status.NOT_INITIATED
+            return
+
+        self._status = Status.NORMAL
+
+        if t == self._t:
+            return
+
+        if t < self._t_prev:
+            self._status = Status.OUTSIDE_RANGE
+            return
+
+        if self.interpolate and t < self._t_front:
+             self._y = self._interpolate_step(t, self._y)
+             self._t = t
+
+        if step and self._t < self._t_front and t > self._t_front:
+            # To ensure that the self._t ... t_out interval can be covered.
+            t = self._t_front
+
+        while self._t_front < t:
+            self._y_prev = copy_to(self._y_front, self._y_prev)
+            self._t_prev = self._t_front
+            self._norm_prev = self._norm_front
+            nsteps_left -= self._step_in_err(t, nsteps_left)
+            if step:
+                break
+
+        if self._status < 0:
+            return
+
+        if self._t_front > t:
+            self._prep_dense_out()
+            self._status = Status.INTERPOLATED
+            self._t = t
+            self._y = self._interpolate_step(t, self._y)
+        else:
+            self._status = Status.AT_FRONT
+            self._t = self._t_front
+            self._y = copy_to(self._y_front, self._y)
+
+    cdef int _step_in_err(self, double t, int max_step):
+        """
+        Do compute one step, repeating until the error is within tolerance.
+        """
+        cdef double error = 1
+        cdef int nsteps = 0
+        while error >= 1:
+            dt = self._get_timestep(t)
+            error = self._compute_step(dt)
+            self._dt_int = dt
+            self._recompute_safe_step(error, dt)
+
+            if dt == self.min_step and error > 1:
+                # The tolerance was not reached but the dt is at the minimum.
+                self._status = Status.DT_UNDERFLOW
+                break
+            nsteps += 1
+            if nsteps > max_step:
+                self._status = Status.TOO_MUCH_WORK
+                break
+        return nsteps
+
+    cdef double _compute_step(self, double dt):
+        """
+        Do compute one step with fixed ``dt``, return the error.
+        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
+        """
+        cdef int i
+        for i in range(self.rk_step):
+            self.k[i] = imul_data(<Data> self.k[i], 0.)
+
+        # Compute the derivatives
+        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
+                                          <Data> self.k[0])
+        for i in range(1, self.rk_step):
+            self._y_temp = copy_to(self._y_prev, self._y_temp)
+            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
+            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
+                                              self._y_temp, <Data> self.k[i])
+
+        # Compute the state
+        self._y_front = copy_to(self._y_prev, self._y_front)
+        self._y_front = self._accumulate(self._y_front, self.b, dt,
+                                         self.rk_step)
+        self._t_front = self._t_prev + dt
+
+        if type(self._y_front) is CSR:
+            # issparse() test would be better.
+            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
+
+        return self._error(self._y_front, dt)
+
+    cdef double _error(self, Data y_new, double dt):
+        """ Compute the normalized error. (error/tol) """
+        if not self.adaptative_step:
+            return 0.
+        self._y_temp = imul_data(self._y_temp, 0.)
+        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
+        self._norm_front = frobenius_data(y_new)
+        return frobenius_data(self._y_temp) / (self.atol +
+                max(self._norm_prev, self._norm_front) * self.rtol)
+
+    cdef void _prep_dense_out(self):
+        """
+        Compute derivative for the interpolation step.
+        """
+        cdef double dt = self._dt_int
+
+        for i in range(self.rk_step, self.rk_extra_step):
+            self.k[i] = imul_data(<Data> self.k[i], 0.)
+            self._y_temp = copy_to(self._y_prev, self._y_temp)
+            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
+            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
+                                              self._y_temp, <Data> self.k[i])
+
+    cdef Data _interpolate_step(self, double t, Data out):
+        """
+        Compute the state at any points between _t_prev and _t_front
+        with an error of ~dt**denseout_order.
+        """
+        cdef:
+            int i, j
+            double t0 = self._t_prev
+            double dt = self._dt_int
+            double tau = (t - t0) / dt
+        for i in range(self.rk_extra_step):
+            self.b_factor[i] = 0.
+            for j in range(self.denseout_order-1, -1, -1):
+                self.b_factor[i] += self.bi[i,j]
+                self.b_factor[i] *= tau
+
+        out = copy_to(self._y_prev, out)
+        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
+        return out
+
+    cdef inline Data _accumulate(self, Data target, double[:] factors,
+                         double dt, int size):
+        cdef int i
+        for i in range(size):
+            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
+        return target
+
+    @cython.cdivision(True)
+    cdef double _get_timestep(self, double t):
+        """ Get the dt for the step. """
+        cdef double dt_needed = t - self._t_front
+        if not self.adaptative_step:
+            return dt_needed
+        if self.interpolate:
+            return self._dt_safe
+        if dt_needed <= self._dt_safe:
+            return dt_needed
+        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
+
+    cdef void _recompute_safe_step(self, double err, double dt):
+        """ Get maximum safe step in function of the error."""
+        cdef double factor
+        if not self.adaptative_step:
+            return
+        elif err == 0:
+            factor = 10
+        else:
+            factor = 0.9*err**(-1/(self.order+1))
+            factor = min(10, factor)
+            factor = max(0.2, factor)
+
+        self._dt_safe = dt * factor
+        if self.max_step:
+            self._dt_safe = min(self.max_step, self._dt_safe)
+        if self.min_step:
+            self._dt_safe = max(self.min_step, self._dt_safe)
+
+    def successful(self):
+        return self._status >= 0
+
+    @property
+    def status(self):
+        return self._status
+
+    def status_message(self):
+        "Status of the last step in a human readable format."
+        return {
+            AT_FRONT: "Internal state at the desired time.",
+            INTERPOLATED: (
+                "Internal state past the desired time and "
+                "interpolation to step done."),
+            NORMAL: 'No work done.',
+            TOO_MUCH_WORK: (
+                'Too much work done in one call. Try to increase '
+                'the nsteps parameter or increasing the tolerance.'
+            ),
+            DT_UNDERFLOW:
+                'Step size becomes too small. Try increasing tolerance.',
+            OUTSIDE_RANGE: 'Step outside available range.',
+            NOT_INITIATED: 'Not initialized.'
+        }[self._status]
+
+    @property
+    def y(self):
+        return self._y
+
+    @property
+    def y_prev(self):
+        return self._y_prev
+
+    @property
+    def y_front(self):
+        return self._y_front
+
+    @property
+    def t_front(self):
+        return self._t_front
+
+    @property
+    def t_prev(self):
+        return self._t_prev
+
+    @property
+    def t(self):
+        return self._t
+
+    def _debug_state(self):
+        print("t, y: ", self._t,
+              'None' if self._y is None else self._y.to_array())
+        print("t_prev, y_prev, |y_prev|", self._t_prev,
+              'None' if self._y_prev is None else self._y_prev.to_array(),
+              self._norm_prev)
+        print("t_front, y_front, |y_front|", self._t_front,
+              'None' if self._y_front is None else self._y_front.to_array(),
+              self._norm_front)
+        print("y_temp",
+              'None' if self._y_temp is None else self._y_temp.to_array())
+        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
+        for i in range(self.rk_extra_step):
+            print(f'k[{i}]',
+                  'None' if self.k[i] is None else self.k[i].to_array())
diff --git a/qutip/solver/integrator/integrator.py b/qutip/solver/integrator/integrator.py
index 44df5546f1..4268621f01 100644
--- a/qutip/solver/integrator/integrator.py
+++ b/qutip/solver/integrator/integrator.py
@@ -1,240 +1,240 @@
-""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
-import numpy as np
-
-__all__ = ['Integrator', 'IntegratorException']
-
-
-class IntegratorException(Exception):
-    """Error from the ODE solver being unable to integrate with the given
-    parameters.
-
-    Example
-    -------
-    - The solver cannot reach the desired tolerance within the maximum number
-    of steps.
-    - The step needed to be within desired tolerance is too small.
-    """
-
-
-class Integrator:
-    """
-    A wrapper around ODE solvers.
-    It ensures a common interface for Solver usage.
-    It takes and return states as :class:`qutip.core.data.Data`, it may return
-    a different data-type than the input type.
-
-    Parameters
-    ----------
-    system: qutip.QobjEvo
-        Quantum system in which states evolve.
-
-    options: dict
-        Options for the integrator.
-
-    Class Attributes
-    ----------------
-    name : str
-        The name of the integrator.
-
-    supports_blackbox : bool
-        If True, then the integrator calls only ``system.matmul``,
-        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
-        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
-        the integrator to modify the system in creative ways. In particular,
-        the solver may modify the system depending on *both* the time ``t``
-        *and* the current ``state`` the system is being applied to.
-
-        If the integrator calls any other methods, set to False.
-
-    supports_time_dependent : bool
-        If True, then the integrator supports time dependent systems. If False,
-        ``supports_blackbox`` should usually be ``False`` too.
-
-    integrator_options : dict
-        A dictionary of options used by the integrator and their default
-        values. Once initiated, ``self.options`` will be a dict with the same
-        keys, not the full options object passed to the solver. Options' keys
-        included here will be supported by the :cls:SolverOdeOptions.
-    """
-    # Dict of used options and their default values
-    integrator_options = {}
-    _options = None
-    # Can evolve time dependent system
-    support_time_dependant = None
-    # Whether the integrator used the system QobjEvo as a blackbox
-    supports_blackbox = None
-    # The name of the integrator
-    name = None
-    method = ""
-
-    def __init__(self, system, options):
-        self.system = system
-        self._is_set = False  # get_state can be used and return a valid state.
-        self._back = (np.inf, None)
-        self._options = self.integrator_options.copy()
-        self.options = options
-        self._prepare()
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        It should also set the name of the solver to be displayed in Result.
-        """
-        raise NotImplementedError
-
-    def set_state(self, t, state0):
-        """
-        Set the state of the ODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        .. note:
-            It should set the flags `_is_set` to True.
-        """
-        raise NotImplementedError
-
-    def integrate(self, t, copy=True):
-        """
-        Evolve to t.
-
-        Before calling `integrate` for the first time, the initial state should
-        be set with `set_state`.
-
-        Parameters
-        ----------
-        t : float
-            Time to integrate to, should be larger than the previous time.
-
-        copy : bool [True]
-            Whether to return a copy of the state or the state itself.
-
-        Returns
-        -------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at ``t``.
-        """
-        raise NotImplementedError
-
-    def mcstep(self, t, copy=True):
-        """
-        Evolve toward the time ``t``.
-
-        If ``t`` is larger than the present state's ``t``, advance the internal
-        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
-        larger than the previous one, it does an interpolation step and returns
-        the state at that time. When advancing the state, it may return it at a
-        time between present time and the asked ``t`` if more efficent for
-        subsequent interpolation step.
-
-        Before calling `mcstep` for the first time, the initial state should
-        be set with `set_state`.
-
-        Parameters
-        ----------
-        t : float
-            Time to integrate to, should be larger than the previous time. If
-            the last integrate call was use with ``step=True``, the time can be
-            between the time at the start of the last call and now.
-
-        copy : bool [True]
-            Whether to return a copy of the state or the state itself.
-
-        Returns
-        -------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at ``t``. The returned time ``t`` can
-            differ from the input time only when ``step=True``.
-
-        .. note:
-            The default implementation may be overridden by integrators that
-            can provide a more efficient one.
-        """
-        t_last, state = self.get_state()
-        if t > t_last:
-            self._back = t_last, state
-        elif t > self._back[0]:
-            self.set_state(*self._back)
-        else:
-            raise IntegratorException(
-                "`t` is outside the integration range: "
-                f"{self._back[0]}..{t_last}."
-            )
-        return self.integrate(t, copy)
-
-    def get_state(self, copy=True):
-        """
-        Obtain the state of the solver as a pair (t, state).
-
-        Parameters
-        ----------
-        copy : bool (True)
-            Whether to return the data stored in the Integrator or a copy.
-
-        Returns
-        -------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at ``t``.
-        """
-        raise NotImplementedError
-
-    def run(self, tlist):
-        """
-        Integrate the system yielding the state for each times in tlist.
-
-        Parameters
-        ----------
-        tlist : *list* / *array*
-            List of times to yield the state.
-
-        Yields
-        ------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at each ``t`` of tlist.
-        """
-        for t in tlist[1:]:
-            yield self.integrate(t, False)
-
-    def reset(self, hard=False):
-        """Reset internal state of the ODE solver."""
-        if self._is_set:
-            state = self.get_state()
-        if hard:
-            self._prepare()
-        if self._is_set:
-            self.set_state(*state)
-
-    def arguments(self, args):
-        """
-        Change the argument of the system.
-        Reset the ODE solver to ensure numerical validity.
-
-        Parameters
-        ----------
-        args : dict
-            New arguments
-        """
-        self.system.arguments(args)
-        self.reset()
-
-    @property
-    def options(self):
-        # Options should be overwritten by each integrators.
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        # This does not apply the new options.
-        self._options = {
-            **self._options,
-            **{
-               key: new_options[key]
-               for key in self.integrator_options.keys()
-               if key in new_options and new_options[key] is not None
-            }
-        }
+""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
+import numpy as np
+
+__all__ = ['Integrator', 'IntegratorException']
+
+
+class IntegratorException(Exception):
+    """Error from the ODE solver being unable to integrate with the given
+    parameters.
+
+    Example
+    -------
+    - The solver cannot reach the desired tolerance within the maximum number
+    of steps.
+    - The step needed to be within desired tolerance is too small.
+    """
+
+
+class Integrator:
+    """
+    A wrapper around ODE solvers.
+    It ensures a common interface for Solver usage.
+    It takes and return states as :class:`qutip.core.data.Data`, it may return
+    a different data-type than the input type.
+
+    Parameters
+    ----------
+    system: qutip.QobjEvo
+        Quantum system in which states evolve.
+
+    options: dict
+        Options for the integrator.
+
+    Class Attributes
+    ----------------
+    name : str
+        The name of the integrator.
+
+    supports_blackbox : bool
+        If True, then the integrator calls only ``system.matmul``,
+        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
+        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
+        the integrator to modify the system in creative ways. In particular,
+        the solver may modify the system depending on *both* the time ``t``
+        *and* the current ``state`` the system is being applied to.
+
+        If the integrator calls any other methods, set to False.
+
+    supports_time_dependent : bool
+        If True, then the integrator supports time dependent systems. If False,
+        ``supports_blackbox`` should usually be ``False`` too.
+
+    integrator_options : dict
+        A dictionary of options used by the integrator and their default
+        values. Once initiated, ``self.options`` will be a dict with the same
+        keys, not the full options object passed to the solver. Options' keys
+        included here will be supported by the :cls:SolverOdeOptions.
+    """
+    # Dict of used options and their default values
+    integrator_options = {}
+    _options = None
+    # Can evolve time dependent system
+    support_time_dependant = None
+    # Whether the integrator used the system QobjEvo as a blackbox
+    supports_blackbox = None
+    # The name of the integrator
+    name = None
+    method = ""
+
+    def __init__(self, system, options):
+        self.system = system
+        self._is_set = False  # get_state can be used and return a valid state.
+        self._back = (np.inf, None)
+        self._options = self.integrator_options.copy()
+        self.options = options
+        self._prepare()
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        It should also set the name of the solver to be displayed in Result.
+        """
+        raise NotImplementedError
+
+    def set_state(self, t, state0):
+        """
+        Set the state of the ODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        .. note:
+            It should set the flags `_is_set` to True.
+        """
+        raise NotImplementedError
+
+    def integrate(self, t, copy=True):
+        """
+        Evolve to t.
+
+        Before calling `integrate` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+    def mcstep(self, t, copy=True):
+        """
+        Evolve toward the time ``t``.
+
+        If ``t`` is larger than the present state's ``t``, advance the internal
+        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
+        larger than the previous one, it does an interpolation step and returns
+        the state at that time. When advancing the state, it may return it at a
+        time between present time and the asked ``t`` if more efficent for
+        subsequent interpolation step.
+
+        Before calling `mcstep` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time. If
+            the last integrate call was use with ``step=True``, the time can be
+            between the time at the start of the last call and now.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at ``t``. The returned time ``t`` can
+            differ from the input time only when ``step=True``.
+
+        .. note:
+            The default implementation may be overridden by integrators that
+            can provide a more efficient one.
+        """
+        t_last, state = self.get_state()
+        if t > t_last:
+            self._back = t_last, state
+        elif t > self._back[0]:
+            self.set_state(*self._back)
+        else:
+            raise IntegratorException(
+                "`t` is outside the integration range: "
+                f"{self._back[0]}..{t_last}."
+            )
+        return self.integrate(t, copy)
+
+    def get_state(self, copy=True):
+        """
+        Obtain the state of the solver as a pair (t, state).
+
+        Parameters
+        ----------
+        copy : bool (True)
+            Whether to return the data stored in the Integrator or a copy.
+
+        Returns
+        -------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+    def run(self, tlist):
+        """
+        Integrate the system yielding the state for each times in tlist.
+
+        Parameters
+        ----------
+        tlist : *list* / *array*
+            List of times to yield the state.
+
+        Yields
+        ------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at each ``t`` of tlist.
+        """
+        for t in tlist[1:]:
+            yield self.integrate(t, False)
+
+    def reset(self, hard=False):
+        """Reset internal state of the ODE solver."""
+        if self._is_set:
+            state = self.get_state()
+        if hard:
+            self._prepare()
+        if self._is_set:
+            self.set_state(*state)
+
+    def arguments(self, args):
+        """
+        Change the argument of the system.
+        Reset the ODE solver to ensure numerical validity.
+
+        Parameters
+        ----------
+        args : dict
+            New arguments
+        """
+        self.system.arguments(args)
+        self.reset()
+
+    @property
+    def options(self):
+        # Options should be overwritten by each integrators.
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        # This does not apply the new options.
+        self._options = {
+            **self._options,
+            **{
+               key: new_options[key]
+               for key in self.integrator_options.keys()
+               if key in new_options and new_options[key] is not None
+            }
+        }
diff --git a/qutip/solver/integrator/krylov.py b/qutip/solver/integrator/krylov.py
index d9cf5757ed..a05d198b37 100644
--- a/qutip/solver/integrator/krylov.py
+++ b/qutip/solver/integrator/krylov.py
@@ -1,238 +1,238 @@
-from ..integrator import IntegratorException, Integrator
-import numpy as np
-from qutip.core import data as _data
-from scipy.optimize import root_scalar
-from ..sesolve import SESolver
-
-
-__all__ = ["IntegratorKrylov"]
-
-
-class IntegratorKrylov(Integrator):
-    """
-    Evolve the state vector ("psi0") finding an approximation for the time
-    evolution operator of Hamiltonian ("H") by obtaining the projection of
-    the time evolution operator on a set of small dimensional Krylov
-    subspaces (m << dim(H)).
-    """
-    integrator_options = {
-        'atol': 1e-7,
-        'nsteps': 100,
-        'min_step': 1e-5,
-        'max_step': 1e5,
-        'krylov_dim': 0,
-        'sub_system_tol': 1e-7,
-        'always_compute_step': False,
-    }
-    support_time_dependant = False
-    supports_blackbox = False
-    method = 'krylov'
-
-    def _prepare(self):
-        if not self.system.isconstant:
-            raise ValueError("krylov method only support constant system.")
-        self._max_step = -np.inf
-        krylov_dim = self.options["krylov_dim"]
-        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
-            raise ValueError("The options 'krylov_dim', must be a positive "
-                             "integer smaller that the system size")
-
-        if krylov_dim == 0:
-            # TODO: krylov_dim, max_step and error (atol) are related by
-            # err ~= exp(-krylov_dim / dt**(1~2))
-            # We could ask for 2 and determine the third one.
-            N = self.system.shape[0]
-            krylov_dim = min(int((N + 100)**0.5), N-1)
-            self.options["krylov_dim"]  = krylov_dim
-
-        if not self.options["always_compute_step"]:
-            from qutip import rand_ket
-            N = self.system.shape[0]
-            krylov_tridiag, krylov_basis = \
-                self._lanczos_algorithm(rand_ket(N).data)
-            if (
-                krylov_tridiag.shape[0] < self.options["krylov_dim"]
-                or krylov_tridiag.shape[0] == N
-            ):
-                self._max_step = np.inf
-            else:
-                self._max_step = self._compute_max_step(krylov_tridiag,
-                                                        krylov_basis)
-
-    def _lanczos_algorithm(self, psi):
-        """
-        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
-        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
-        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
-
-        Parameters
-        ------------
-        psi: np.ndarray
-            State used to calculate Krylov subspace.
-        """
-        krylov_dim = self.options['krylov_dim']
-        H = (1j * self.system(0)).data
-
-        v = []
-        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
-        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
-
-        w_prime = _data.matmul(H, psi)
-        T_diag[0] = _data.inner(w_prime, psi)
-        v.append(psi)
-        w = _data.add(w_prime, v[-1], -T_diag[0])
-        T_subdiag[0] = _data.norm.l2(w)
-        j = 0
-
-        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
-            j += 1
-            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
-            w_prime = _data.matmul(H, v[-1])
-            T_diag[j] = _data.inner(w_prime, v[-1])
-            w = _data.add(w_prime, v[-1], -T_diag[j])
-            w = _data.add(w, v[-2], -T_subdiag[j-1])
-            T_subdiag[j] = _data.norm.l2(w)
-
-        krylov_tridiag = _data.diag["dense"](
-            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
-            [-1, 0, 1]
-        )
-        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
-
-        return krylov_tridiag, krylov_basis
-
-    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
-        """
-        Compute the eigen energies, basis transformation operator (U) and e0.
-        """
-        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
-        N = eigenvalues.shape[0]
-        U = _data.matmul(krylov_basis, eigenvectors)
-        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
-        return eigenvalues, U, e0
-
-    def _compute_psi(self, dt, eigenvalues, U, e0):
-        """
-        compute the state at time ``t``.
-        """
-        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
-        aux = _data.multiply(phases, e0)
-        return _data.matmul(U, aux)
-
-    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
-        """
-        Compute the maximum step length to stay under the desired tolerance.
-        """
-        if not krylov_state:
-            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
-
-        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
-        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
-        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
-
-        def krylov_error(t):
-            # we divide by atol and take the log so that the error returned is 0
-            # at atol, which is convenient for calling root_scalar with.
-            return np.log(_data.norm.l2(
-                self._compute_psi(t, *krylov_state) -
-                self._compute_psi(t, *reduced_state)
-            ) / self.options["atol"])
-
-        dt = self.options["min_step"]
-        err = krylov_error(dt)
-        if err > 0:
-            ValueError(
-                f"With the krylov dim of {self.options['krylov_dim']}, the "
-                f"error with the minimum step {dt} is {err}, higher than the "
-                f"desired tolerance of {self.options['atol']}."
-            )
-
-        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
-            dt *= 10
-
-        if dt > self.options["max_step"]:
-            return self.options["max_step"]
-
-        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
-                          method="brentq", xtol=self.options['atol'])
-        if sol.converged:
-            return sol.root
-        else:
-            return dt
-
-    def set_state(self, t, state0):
-        self._t_0 = t
-        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
-        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
-
-        if (
-            krylov_tridiag.shape[0] <= self.options['krylov_dim']
-            or krylov_tridiag.shape == self.system.shape
-        ):
-            # happy_breakdown
-            self._max_step = np.inf
-            return
-
-        if (
-            not np.isfinite(self._max_step)
-            or self.options["always_compute_step"]
-        ):
-            self._max_step = self._compute_max_step(
-                krylov_tridiag, krylov_basis, self._krylov_state,
-            )
-
-    def get_state(self, copy=True):
-        return self._t_0, self._compute_psi(0, *self._krylov_state)
-
-    def integrate(self, t, copy=True):
-        step = 0
-        while t > self._t_0 + self._max_step:
-            # The approximation in only valid in the range t_0, t_0 + max step
-            # If outside, advance the range
-            step += 1
-            if step >= self.options["nsteps"]:
-                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
-            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
-            self.set_state(self._t_0 + self._max_step, new_psi)
-
-        delta_t = t - self._t_0
-        out = self._compute_psi(delta_t, *self._krylov_state)
-        return t, out
-
-    @property
-    def options(self):
-        """
-        Supported options by krylov method:
-
-        atol : float, default=1e-7
-            Absolute tolerance.
-
-        nsteps : int, default=100
-            Max. number of internal steps/call.
-
-        min_step, max_step : float, default=(1e-5, 1e5)
-            Minimum and maximum step size.
-
-        krylov_dim: int, default=0
-            Dimension of Krylov approximation subspaces used for the time
-            evolution approximation. If the defaut 0 is given, the dimension is calculated
-            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
-
-        sub_system_tol: float, default=1e-7
-            Tolerance to detect a happy breakdown. A happy breakdown occurs
-            when the initial ket is in a subspace of the Hamiltonian smaller
-            than ``krylov_dim``.
-
-        always_compute_step: bool, default=False
-            If True, the step length is computed each time a new Krylov
-            subspace is computed. Otherwise it is computed only once when
-            creating the integrator.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-SESolver.add_integrator(IntegratorKrylov, 'krylov')
+from ..integrator import IntegratorException, Integrator
+import numpy as np
+from qutip.core import data as _data
+from scipy.optimize import root_scalar
+from ..sesolve import SESolver
+
+
+__all__ = ["IntegratorKrylov"]
+
+
+class IntegratorKrylov(Integrator):
+    """
+    Evolve the state vector ("psi0") finding an approximation for the time
+    evolution operator of Hamiltonian ("H") by obtaining the projection of
+    the time evolution operator on a set of small dimensional Krylov
+    subspaces (m << dim(H)).
+    """
+    integrator_options = {
+        'atol': 1e-7,
+        'nsteps': 100,
+        'min_step': 1e-5,
+        'max_step': 1e5,
+        'krylov_dim': 0,
+        'sub_system_tol': 1e-7,
+        'always_compute_step': False,
+    }
+    support_time_dependant = False
+    supports_blackbox = False
+    method = 'krylov'
+
+    def _prepare(self):
+        if not self.system.isconstant:
+            raise ValueError("krylov method only support constant system.")
+        self._max_step = -np.inf
+        krylov_dim = self.options["krylov_dim"]
+        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
+            raise ValueError("The options 'krylov_dim', must be a positive "
+                             "integer smaller that the system size")
+
+        if krylov_dim == 0:
+            # TODO: krylov_dim, max_step and error (atol) are related by
+            # err ~= exp(-krylov_dim / dt**(1~2))
+            # We could ask for 2 and determine the third one.
+            N = self.system.shape[0]
+            krylov_dim = min(int((N + 100)**0.5), N-1)
+            self.options["krylov_dim"]  = krylov_dim
+
+        if not self.options["always_compute_step"]:
+            from qutip import rand_ket
+            N = self.system.shape[0]
+            krylov_tridiag, krylov_basis = \
+                self._lanczos_algorithm(rand_ket(N).data)
+            if (
+                krylov_tridiag.shape[0] < self.options["krylov_dim"]
+                or krylov_tridiag.shape[0] == N
+            ):
+                self._max_step = np.inf
+            else:
+                self._max_step = self._compute_max_step(krylov_tridiag,
+                                                        krylov_basis)
+
+    def _lanczos_algorithm(self, psi):
+        """
+        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
+        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
+        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
+
+        Parameters
+        ------------
+        psi: np.ndarray
+            State used to calculate Krylov subspace.
+        """
+        krylov_dim = self.options['krylov_dim']
+        H = (1j * self.system(0)).data
+
+        v = []
+        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
+        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
+
+        w_prime = _data.matmul(H, psi)
+        T_diag[0] = _data.inner(w_prime, psi)
+        v.append(psi)
+        w = _data.add(w_prime, v[-1], -T_diag[0])
+        T_subdiag[0] = _data.norm.l2(w)
+        j = 0
+
+        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
+            j += 1
+            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
+            w_prime = _data.matmul(H, v[-1])
+            T_diag[j] = _data.inner(w_prime, v[-1])
+            w = _data.add(w_prime, v[-1], -T_diag[j])
+            w = _data.add(w, v[-2], -T_subdiag[j-1])
+            T_subdiag[j] = _data.norm.l2(w)
+
+        krylov_tridiag = _data.diag["dense"](
+            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
+            [-1, 0, 1]
+        )
+        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
+
+        return krylov_tridiag, krylov_basis
+
+    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
+        """
+        Compute the eigen energies, basis transformation operator (U) and e0.
+        """
+        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
+        N = eigenvalues.shape[0]
+        U = _data.matmul(krylov_basis, eigenvectors)
+        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
+        return eigenvalues, U, e0
+
+    def _compute_psi(self, dt, eigenvalues, U, e0):
+        """
+        compute the state at time ``t``.
+        """
+        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
+        aux = _data.multiply(phases, e0)
+        return _data.matmul(U, aux)
+
+    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
+        """
+        Compute the maximum step length to stay under the desired tolerance.
+        """
+        if not krylov_state:
+            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
+
+        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
+        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
+        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
+
+        def krylov_error(t):
+            # we divide by atol and take the log so that the error returned is 0
+            # at atol, which is convenient for calling root_scalar with.
+            return np.log(_data.norm.l2(
+                self._compute_psi(t, *krylov_state) -
+                self._compute_psi(t, *reduced_state)
+            ) / self.options["atol"])
+
+        dt = self.options["min_step"]
+        err = krylov_error(dt)
+        if err > 0:
+            ValueError(
+                f"With the krylov dim of {self.options['krylov_dim']}, the "
+                f"error with the minimum step {dt} is {err}, higher than the "
+                f"desired tolerance of {self.options['atol']}."
+            )
+
+        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
+            dt *= 10
+
+        if dt > self.options["max_step"]:
+            return self.options["max_step"]
+
+        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
+                          method="brentq", xtol=self.options['atol'])
+        if sol.converged:
+            return sol.root
+        else:
+            return dt
+
+    def set_state(self, t, state0):
+        self._t_0 = t
+        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
+        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
+
+        if (
+            krylov_tridiag.shape[0] <= self.options['krylov_dim']
+            or krylov_tridiag.shape == self.system.shape
+        ):
+            # happy_breakdown
+            self._max_step = np.inf
+            return
+
+        if (
+            not np.isfinite(self._max_step)
+            or self.options["always_compute_step"]
+        ):
+            self._max_step = self._compute_max_step(
+                krylov_tridiag, krylov_basis, self._krylov_state,
+            )
+
+    def get_state(self, copy=True):
+        return self._t_0, self._compute_psi(0, *self._krylov_state)
+
+    def integrate(self, t, copy=True):
+        step = 0
+        while t > self._t_0 + self._max_step:
+            # The approximation in only valid in the range t_0, t_0 + max step
+            # If outside, advance the range
+            step += 1
+            if step >= self.options["nsteps"]:
+                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
+            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
+            self.set_state(self._t_0 + self._max_step, new_psi)
+
+        delta_t = t - self._t_0
+        out = self._compute_psi(delta_t, *self._krylov_state)
+        return t, out
+
+    @property
+    def options(self):
+        """
+        Supported options by krylov method:
+
+        atol : float, default=1e-7
+            Absolute tolerance.
+
+        nsteps : int, default=100
+            Max. number of internal steps/call.
+
+        min_step, max_step : float, default=(1e-5, 1e5)
+            Minimum and maximum step size.
+
+        krylov_dim: int, default=0
+            Dimension of Krylov approximation subspaces used for the time
+            evolution approximation. If the defaut 0 is given, the dimension is calculated
+            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
+
+        sub_system_tol: float, default=1e-7
+            Tolerance to detect a happy breakdown. A happy breakdown occurs
+            when the initial ket is in a subspace of the Hamiltonian smaller
+            than ``krylov_dim``.
+
+        always_compute_step: bool, default=False
+            If True, the step length is computed each time a new Krylov
+            subspace is computed. Otherwise it is computed only once when
+            creating the integrator.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+SESolver.add_integrator(IntegratorKrylov, 'krylov')
diff --git a/qutip/solver/integrator/qutip_integrator.py b/qutip/solver/integrator/qutip_integrator.py
index 03749a57bd..eca2da6383 100644
--- a/qutip/solver/integrator/qutip_integrator.py
+++ b/qutip/solver/integrator/qutip_integrator.py
@@ -1,200 +1,200 @@
-from ..integrator import IntegratorException, Integrator
-from ..solver_base import Solver
-from .explicit_rk import Explicit_RungeKutta
-import numpy as np
-from qutip import data as _data
-
-
-__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
-
-
-class IntegratorVern7(Integrator):
-    """
-    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
-    of order 7. These are Runge-Kutta methods with variable steps and dense
-    output.
-
-    The implementation uses QuTiP's Data objects for the state, allowing
-    sparse, GPU or other data layer objects to be used efficiently by the
-    solver in their native formats.
-
-    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
-    methods.
-
-    Usable with ``method="vern7"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 1000,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-        'interpolate': True,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'vern7'
-
-    def _prepare(self):
-        self._ode_solver = Explicit_RungeKutta(
-            self.system, method=self.method,
-            **self.options
-        )
-        self.name = self.method
-
-    def get_state(self, copy=True):
-        state = self._ode_solver.y
-        return self._ode_solver.t, state.copy() if copy else state
-
-    def set_state(self, t, state):
-        self._ode_solver.set_initial_value(state.copy(), t)
-        self._is_set = True
-
-    def integrate(self, t, copy=True):
-        self._ode_solver.integrate(t, step=False)
-        self._check_failed_integration()
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        self._ode_solver.integrate(t, step=True)
-        self._check_failed_integration()
-        return self.get_state(copy)
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        raise IntegratorException(self._ode_solver.status_message())
-
-    @property
-    def options(self):
-        """
-        Supported options by verner method:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        nsteps : int, default=1000
-            Max. number of internal steps/call.
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        min_step : float, default=0
-            Minimum step size (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-            When using pulses, change to half the thinest pulse otherwise it
-            may be skipped.
-
-        interpolate : bool, default=True
-            Whether to use interpolation step, faster most of the time.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-class IntegratorVern9(IntegratorVern7):
-    """
-    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
-    of order 9. These are Runge-Kutta methods with variable steps and dense
-    output.
-
-    The implementation uses QuTiP's Data objects for the state, allowing
-    sparse, GPU or other data layer objects to be used efficiently by the
-    solver in their native formats.
-
-    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
-    methods.
-
-    Usable with ``method="vern9"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 1000,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-        'interpolate': True,
-    }
-    method = 'vern9'
-
-
-class IntegratorDiag(Integrator):
-    """
-    Integrator solving the ODE by diagonalizing the system and solving
-    analytically. It can only solve constant system and has a long preparation
-    time, but the integration is fast.
-
-    Usable with ``method="diag"``
-    """
-    integrator_options = {"eigensolver_dtype": "dense"}
-    support_time_dependant = False
-    supports_blackbox = False
-    method = 'diag'
-
-    def __init__(self, system, options):
-        if not system.isconstant:
-            raise ValueError("Hamiltonian system must be constant to use "
-                             "diagonalized method")
-        super().__init__(system, options)
-
-    def _prepare(self):
-        self._dt = 0.
-        self._expH = None
-        H0 = self.system(0).to(self.options["eigensolver_dtype"])
-        self.diag, self.U = _data.eigs(H0.data, False)
-        self.diag = self.diag.reshape((-1, 1))
-        self.Uinv = _data.inv(self.U)
-        self.name = "qutip diagonalized"
-
-    def integrate(self, t, copy=True):
-        dt = t - self._t
-        if dt == 0:
-            return self.get_state()
-        elif self._dt != dt:
-            self._expH = np.exp(self.diag * dt)
-            self._dt = dt
-        self._y *= self._expH
-        self._t = t
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        return self.integrate(t, copy=copy)
-
-    def get_state(self, copy=True):
-        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
-
-    def set_state(self, t, state0):
-        self._t = t
-        self._y = _data.matmul(self.Uinv, state0).to_array()
-        self._is_set = True
-
-    @property
-    def options(self):
-        """
-        Supported options by "diag" method:
-
-        eigensolver_dtype : str, default="dense"
-            Qutip data type {"dense", "csr", etc.} to use when computing the
-            eigenstates. The dense eigen solver is usually faster and more
-            stable.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-Solver.add_integrator(IntegratorVern7, 'vern7')
-Solver.add_integrator(IntegratorVern9, 'vern9')
-Solver.add_integrator(IntegratorDiag, 'diag')
+from ..integrator import IntegratorException, Integrator
+from ..solver_base import Solver
+from .explicit_rk import Explicit_RungeKutta
+import numpy as np
+from qutip import data as _data
+
+
+__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
+
+
+class IntegratorVern7(Integrator):
+    """
+    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
+    of order 7. These are Runge-Kutta methods with variable steps and dense
+    output.
+
+    The implementation uses QuTiP's Data objects for the state, allowing
+    sparse, GPU or other data layer objects to be used efficiently by the
+    solver in their native formats.
+
+    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
+    methods.
+
+    Usable with ``method="vern7"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 1000,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+        'interpolate': True,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'vern7'
+
+    def _prepare(self):
+        self._ode_solver = Explicit_RungeKutta(
+            self.system, method=self.method,
+            **self.options
+        )
+        self.name = self.method
+
+    def get_state(self, copy=True):
+        state = self._ode_solver.y
+        return self._ode_solver.t, state.copy() if copy else state
+
+    def set_state(self, t, state):
+        self._ode_solver.set_initial_value(state.copy(), t)
+        self._is_set = True
+
+    def integrate(self, t, copy=True):
+        self._ode_solver.integrate(t, step=False)
+        self._check_failed_integration()
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        self._ode_solver.integrate(t, step=True)
+        self._check_failed_integration()
+        return self.get_state(copy)
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        raise IntegratorException(self._ode_solver.status_message())
+
+    @property
+    def options(self):
+        """
+        Supported options by verner method:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        nsteps : int, default=1000
+            Max. number of internal steps/call.
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        min_step : float, default=0
+            Minimum step size (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+            When using pulses, change to half the thinest pulse otherwise it
+            may be skipped.
+
+        interpolate : bool, default=True
+            Whether to use interpolation step, faster most of the time.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class IntegratorVern9(IntegratorVern7):
+    """
+    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
+    of order 9. These are Runge-Kutta methods with variable steps and dense
+    output.
+
+    The implementation uses QuTiP's Data objects for the state, allowing
+    sparse, GPU or other data layer objects to be used efficiently by the
+    solver in their native formats.
+
+    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
+    methods.
+
+    Usable with ``method="vern9"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 1000,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+        'interpolate': True,
+    }
+    method = 'vern9'
+
+
+class IntegratorDiag(Integrator):
+    """
+    Integrator solving the ODE by diagonalizing the system and solving
+    analytically. It can only solve constant system and has a long preparation
+    time, but the integration is fast.
+
+    Usable with ``method="diag"``
+    """
+    integrator_options = {"eigensolver_dtype": "dense"}
+    support_time_dependant = False
+    supports_blackbox = False
+    method = 'diag'
+
+    def __init__(self, system, options):
+        if not system.isconstant:
+            raise ValueError("Hamiltonian system must be constant to use "
+                             "diagonalized method")
+        super().__init__(system, options)
+
+    def _prepare(self):
+        self._dt = 0.
+        self._expH = None
+        H0 = self.system(0).to(self.options["eigensolver_dtype"])
+        self.diag, self.U = _data.eigs(H0.data, False)
+        self.diag = self.diag.reshape((-1, 1))
+        self.Uinv = _data.inv(self.U)
+        self.name = "qutip diagonalized"
+
+    def integrate(self, t, copy=True):
+        dt = t - self._t
+        if dt == 0:
+            return self.get_state()
+        elif self._dt != dt:
+            self._expH = np.exp(self.diag * dt)
+            self._dt = dt
+        self._y *= self._expH
+        self._t = t
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        return self.integrate(t, copy=copy)
+
+    def get_state(self, copy=True):
+        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
+
+    def set_state(self, t, state0):
+        self._t = t
+        self._y = _data.matmul(self.Uinv, state0).to_array()
+        self._is_set = True
+
+    @property
+    def options(self):
+        """
+        Supported options by "diag" method:
+
+        eigensolver_dtype : str, default="dense"
+            Qutip data type {"dense", "csr", etc.} to use when computing the
+            eigenstates. The dense eigen solver is usually faster and more
+            stable.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+Solver.add_integrator(IntegratorVern7, 'vern7')
+Solver.add_integrator(IntegratorVern9, 'vern9')
+Solver.add_integrator(IntegratorDiag, 'diag')
diff --git a/qutip/solver/integrator/scipy_integrator.py b/qutip/solver/integrator/scipy_integrator.py
index dac1028a61..7c71185f2d 100644
--- a/qutip/solver/integrator/scipy_integrator.py
+++ b/qutip/solver/integrator/scipy_integrator.py
@@ -1,527 +1,527 @@
-"""ODE integrator from scipy."""
-
-__all__ = [
-    'IntegratorScipyAdams',
-    'IntegratorScipyBDF',
-    'IntegratorScipyDop853',
-    'IntegratorScipylsoda',
-]
-
-import numpy as np
-from scipy.integrate import ode
-from scipy.integrate._ode import zvode
-from qutip.core import data as _data
-from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
-from ..integrator import IntegratorException, Integrator
-from ..solver_base import Solver
-import warnings
-
-
-class IntegratorScipyAdams(Integrator):
-    """
-    Integrator using Scipy `ode` with zvode integrator using adams method.
-    Ordinary Differential Equation solver by netlib
-    (http://www.netlib.org/odepack).
-
-    Usable with ``method="adams"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'order': 12,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'adams'
-
-    class _zvode(zvode):
-        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
-        def step(self, *args):
-            itask = self.call_args[2]
-            self.rwork[0] = args[4]
-            self.call_args[2] = 5
-            r = self.run(*args)
-            self.call_args[2] = itask
-            return r
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        """
-        self._ode_solver = ode(self._mul_np_vec)
-        self._ode_solver.set_integrator('zvode')
-        self._ode_solver._integrator = self._zvode(
-            method=self.method,
-            **self.options,
-        )
-        self.name = "scipy zvode " + self.method
-
-    def _mul_np_vec(self, t, vec):
-        """
-        Interface between scipy which use numpy and the driver, which use data.
-        """
-        state = _data.dense.fast_from_numpy(vec)
-        column_unstack_dense(state, self._size, inplace=True)
-        out = self.system.matmul_data(t, state)
-        column_stack_dense(out, inplace=True)
-        return out.as_ndarray().ravel()
-
-    def set_state(self, t, state0):
-        self._is_set = True
-        self._back = t
-        self._front = t
-        self._mat_state = state0.shape[1] > 1
-        self._size = state0.shape[0]
-        if self._mat_state:
-            state0 = _data.column_stack(state0)
-        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
-
-    def get_state(self, copy=True):
-        if not self._is_set:
-            raise IntegratorException("The state is not initialted")
-        self._check_failed_integration()
-        t = self._ode_solver.t
-        if self._mat_state:
-            state = _data.column_unstack_dense(
-                _data.dense.Dense(self._ode_solver._y, copy=copy),
-                self._size,
-                inplace=True)
-        else:
-            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
-        return t, state
-
-    def _check_handle(self):
-        """
-        Do the check for concurrent use of the integrator and reset if used
-        elsewhere.
-        """
-        integrator = self._ode_solver._integrator
-        if integrator.initialized:
-            if integrator.handle != integrator.__class__.active_global_handle:
-                integrator.reset(len(self._ode_solver._y), False)
-
-    def integrate(self, t, copy=True):
-        self._check_handle()
-        if t != self._ode_solver.t:
-            self._ode_solver.integrate(t)
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        # When working with mcstep, we use the dense output feature:
-        # a range in which the state at any time can be computed with
-        # minimal work. We keep track of the range with _back and _front.
-        self._check_handle()
-        if self._ode_solver.t == t:
-            # Exact same `t` as the last call, nothing to do.
-            pass
-        elif self._back > t:
-            # `t` before the range: not supported.
-            raise IntegratorException(
-                f"`t`={t} is behind the integration limit: "
-                f"{t} < {self._back}."
-            )
-        elif t <= self._front:
-            # In the range, ask for the new state.
-            self._ode_solver.integrate(t)
-        elif self._ode_solver.t < self._front:
-            # `t` after the range but last call (`t_prev`) not at the front.
-            # Advancing the range would make the interval `t_prev`..`_front`
-            # unreachable. Thus advance to _front.
-            self._ode_solver.integrate(self._front)
-        else:
-            # Advance the range.
-            self._back = self._front
-            self._ode_solver.integrate(t, step=True)
-            self._front = self._ode_solver._integrator.rwork[12]
-
-        return self.get_state(copy)
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        messages = {
-            -1: 'Excess work done on this call. Try to increasing '
-                'the nsteps parameter in the Options class',
-            -2: 'Excess accuracy requested. (Tolerances too small.)',
-            -3: 'Illegal input detected.',
-            -4: 'Repeated error test failures. (Check all input.)',
-            -5: 'Repeated convergence failures. (Perhaps bad'
-                ' Jacobian supplied or wrong choice of MF or tolerances.)',
-            -6: 'Error weight became zero during problem. (Solution'
-                ' component i vanished, and ATOL or ATOL(i) = 0.)'
-        }
-        raise IntegratorException(
-            messages[self._ode_solver._integrator.istate]
-        )
-
-    @property
-    def options(self):
-        """
-        Supported options by zvode integrator:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        order : int, default=12, 'adams' or 5, 'bdf'
-            Order of integrator <=12 'adams', <=5 'bdf'
-
-        nsteps : int, default=2500
-            Max. number of internal steps/call.
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        min_step : float, default=0
-            Minimum step size (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-            When using pulses, change to half the thinest pulse otherwise it
-            may be skipped.
-    """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-class IntegratorScipyBDF(IntegratorScipyAdams):
-    """
-    Integrator using Scipy `ode` with zvode integrator using bdf method.
-    Ordinary Differential Equation solver by netlib
-    (http://www.netlib.org/odepack).
-
-    Usable with ``method="bdf"``
-    """
-    method = 'bdf'
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'order': 5,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-    }
-
-
-class IntegratorScipyDop853(Integrator):
-    """
-    Integrator using Scipy `ode` with dop853 integrator. Eight order
-    runge-kutta method by Dormand & Prince. Use fortran implementation
-    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
-    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
-    Computational Mathematics, Springer-Verlag (1993)].
-
-    Usable with ``method="dop853"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'first_step': 0,
-        'max_step': 0,
-        'ifactor': 6.0,
-        'dfactor': 0.3,
-        'beta': 0.0,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'dop853'
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        """
-        self._ode_solver = ode(self._mul_np_vec)
-        self._ode_solver.set_integrator('dop853', **self.options)
-        self.name = "scipy ode dop853"
-
-    def _mul_np_vec(self, t, vec):
-        """
-        Interface between scipy which use numpy and the driver, which use data.
-        """
-        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
-        column_unstack_dense(state, self._size, inplace=True)
-        out = self.system.matmul_data(t, state)
-        column_stack_dense(out, inplace=True)
-        return out.as_ndarray().ravel().view(np.float64)
-
-    def integrate(self, t, copy=True):
-        if t != self._ode_solver.t:
-            self._ode_solver.integrate(t)
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        if self._ode_solver.t <= t:
-            # Scipy's DOP853 does not have a step function.
-            # It has a safe step length, but can be 0 if unknown.
-            dt = self._ode_solver._integrator.work[6]
-            if dt:
-                t = min(self._ode_solver.t + dt, t)
-            self._ode_solver.integrate(t)
-        else:
-            # While DOP853 support changing the direction of the integration,
-            # it does not do so efficiently. We do it manually.
-            self._ode_solver._integrator.work[6] *= -1
-            self._ode_solver.integrate(t)
-            self._ode_solver._integrator.work[6] *= -1
-        return self.get_state(copy)
-
-    def get_state(self, copy=True):
-        if not self._is_set:
-            raise IntegratorException("The state is not initialted")
-        self._check_failed_integration()
-        t = self._ode_solver.t
-        if self._mat_state:
-            state = _data.column_unstack_dense(
-                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
-                                  copy=copy),
-                self._size,
-                inplace=True)
-        else:
-            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
-                                      copy=copy)
-        return t, state
-
-    def set_state(self, t, state0):
-        self._is_set = True
-        self._mat_state = state0.shape[1] > 1
-        self._size = state0.shape[0]
-        if self._mat_state:
-            state0 = _data.column_stack(state0)
-        self._ode_solver.set_initial_value(
-            state0.to_array().ravel().view(np.float64),
-            t
-        )
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        messages = {
-            -1: 'input is not consistent',
-            -2: 'larger nsteps is needed, Try to increase the nsteps '
-                'parameter in the Options class.',
-            -3: 'step size becomes too small. Try increasing tolerance',
-            -4: 'problem is probably stiff (interrupted), try "bdf" '
-                'method instead',
-        }
-        raise IntegratorException(
-            messages[self._ode_solver._integrator.istate]
-        )
-
-    @property
-    def options(self):
-        """
-        Supported options by dop853 integrator:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        nsteps : int, default=2500
-            Max. number of internal steps/call.
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-
-        ifactor, dfactor : float, default=6., 0.3
-            Maximum factor to increase/decrease step size by in one step
-
-        beta : float, default=0
-            Beta parameter for stabilised step size control.
-
-        See scipy.integrate.ode ode for more detail
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-class IntegratorScipylsoda(IntegratorScipyDop853):
-    """
-    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
-    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
-    'BDF' methods to solve both stiff and non-stiff systems.
-
-    Usable with ``method="lsoda"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'max_order_ns': 12,
-        'max_order_s': 5,
-        'first_step': 0.0,
-        'max_step': 0.0,
-        'min_step': 0.0,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'lsoda'
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        """
-        self._ode_solver = ode(self._mul_np_vec)
-        self._ode_solver.set_integrator('lsoda', **self.options)
-        self.name = "scipy lsoda"
-
-    def _check_handle(self):
-        """
-        Do the check for concurrent use of the integrator and reset if used
-        elsewhere.
-        """
-        integrator = self._ode_solver._integrator
-        if integrator.initialized:
-            if integrator.handle != integrator.__class__.active_global_handle:
-                integrator.reset(len(self._ode_solver._y), False)
-
-    def integrate(self, t, copy=True):
-        self._check_handle()
-        return super().integrate(t, copy)
-
-    def set_state(self, t, state0):
-        self._front = t
-        super().set_state(t, state0)
-        self._back = self.get_state()
-
-    def mcstep(self, t, copy=True):
-        # This solver support dense output:
-        # a range in which the state at any time can be computed with
-        # minimal work. We keep track of the range with _back[0] and _front.
-        self._check_handle()
-        if self._ode_solver.t == t:
-            # Exact same `t` as the last call, nothing to do.
-            pass
-        elif self._back[0] <= t <= self._front:
-            # In the range, ask for the new state.
-            self._backstep(t)
-        elif self._front < t:
-            # Advance the range.
-            self._one_step(t)
-        else:
-            raise IntegratorException(
-                f"`t`={t} is behind the integration limit: "
-                f"{t} < {self._back[0]}."
-            )
-        return self.get_state(copy)
-
-    def _one_step(self, t):
-        """
-        Advance up to t by one internal solver step.
-        Should be able to retreive the state at any time between the present
-        time and the resulting time using `backstep`.
-        """
-        # Here we want to advance up to t doing maximum one step.
-        # lsoda officially support step, but sometime it does more work than
-        # needed, so we ask it to advance a fraction of the last step, where it
-        # will advance one internal step of length allowed by the tolerance and
-        # interpolate back to the asked time, effictively getting the single
-        # integration step we want. The first step and abrupt changes in the
-        # `rhs` can cause exceptions to this, but _backstep catch those cases.
-        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
-        t_ode = self._ode_solver.t
-
-        if t > self._front and t_ode >= self._front:
-            # The state is at self._front, do a step
-            self._back = self.get_state()
-            self._ode_solver.integrate(min(self._front + safe_delta, t))
-            self._front = self._ode_solver._integrator.rwork[12]
-            # We asked for a fraction of a step, now complete it.
-            self._ode_solver.integrate(min(self._front, t))
-        elif t > self._front:
-            # The state is at a time before t_front, advance to t_front
-            self._ode_solver.integrate(self._front)
-
-    def _backstep(self, t):
-        """
-        Retreive the state at time t, with t smaller than present ODE time.
-        The time t will always be between the last calls of `one_step`.
-        return the pair t, state.
-        """
-        delta = self._ode_solver._integrator.rwork[11]
-        if t == self._ode_solver.t:
-            pass
-        elif self._front - delta <= t:
-            self._ode_solver.integrate(t)
-        else:
-            self.set_state(*self._back)
-            self._ode_solver.integrate(t)
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        messages = {
-            -1: "Excess work done on this call."
-                "Try to increase the nsteps parameter in the Options class.",
-            -2: "Excess accuracy requested (tolerances too small).",
-            -3: "Illegal input detected (internal error).",
-            -4: "Repeated error test failures (internal error).",
-            -5: "Repeated convergence failures "
-                "(perhaps bad Jacobian or tolerances).",
-            -6: "Error weight became zero during problem.",
-            -7: "Internal workspace insufficient to finish (internal error)."
-        }
-        raise IntegratorException(
-            messages[self._ode_solver._integrator.istate]
-        )
-
-    @property
-    def options(self):
-        """
-        Supported options by lsoda integrator:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        nsteps : int, default=2500
-            Max. number of internal steps/call.
-
-        max_order_ns : int, default=12
-            Maximum order used in the nonstiff case (<= 12).
-
-        max_order_s : int, default=5
-            Maximum order used in the stiff case (<= 5).
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-            When using pulses, change to half the thinest pulse otherwise it
-            may be skipped.
-
-        min_step : float, default=0
-            Minimum step size (0 = automatic)
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-Solver.add_integrator(IntegratorScipyBDF, 'bdf')
-Solver.add_integrator(IntegratorScipyAdams, 'adams')
-Solver.add_integrator(IntegratorScipyDop853, 'dop853')
-Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
+"""ODE integrator from scipy."""
+
+__all__ = [
+    'IntegratorScipyAdams',
+    'IntegratorScipyBDF',
+    'IntegratorScipyDop853',
+    'IntegratorScipylsoda',
+]
+
+import numpy as np
+from scipy.integrate import ode
+from scipy.integrate._ode import zvode
+from qutip.core import data as _data
+from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
+from ..integrator import IntegratorException, Integrator
+from ..solver_base import Solver
+import warnings
+
+
+class IntegratorScipyAdams(Integrator):
+    """
+    Integrator using Scipy `ode` with zvode integrator using adams method.
+    Ordinary Differential Equation solver by netlib
+    (http://www.netlib.org/odepack).
+
+    Usable with ``method="adams"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'order': 12,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'adams'
+
+    class _zvode(zvode):
+        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
+        def step(self, *args):
+            itask = self.call_args[2]
+            self.rwork[0] = args[4]
+            self.call_args[2] = 5
+            r = self.run(*args)
+            self.call_args[2] = itask
+            return r
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        """
+        self._ode_solver = ode(self._mul_np_vec)
+        self._ode_solver.set_integrator('zvode')
+        self._ode_solver._integrator = self._zvode(
+            method=self.method,
+            **self.options,
+        )
+        self.name = "scipy zvode " + self.method
+
+    def _mul_np_vec(self, t, vec):
+        """
+        Interface between scipy which use numpy and the driver, which use data.
+        """
+        state = _data.dense.fast_from_numpy(vec)
+        column_unstack_dense(state, self._size, inplace=True)
+        out = self.system.matmul_data(t, state)
+        column_stack_dense(out, inplace=True)
+        return out.as_ndarray().ravel()
+
+    def set_state(self, t, state0):
+        self._is_set = True
+        self._back = t
+        self._front = t
+        self._mat_state = state0.shape[1] > 1
+        self._size = state0.shape[0]
+        if self._mat_state:
+            state0 = _data.column_stack(state0)
+        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
+
+    def get_state(self, copy=True):
+        if not self._is_set:
+            raise IntegratorException("The state is not initialted")
+        self._check_failed_integration()
+        t = self._ode_solver.t
+        if self._mat_state:
+            state = _data.column_unstack_dense(
+                _data.dense.Dense(self._ode_solver._y, copy=copy),
+                self._size,
+                inplace=True)
+        else:
+            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
+        return t, state
+
+    def _check_handle(self):
+        """
+        Do the check for concurrent use of the integrator and reset if used
+        elsewhere.
+        """
+        integrator = self._ode_solver._integrator
+        if integrator.initialized:
+            if integrator.handle != integrator.__class__.active_global_handle:
+                integrator.reset(len(self._ode_solver._y), False)
+
+    def integrate(self, t, copy=True):
+        self._check_handle()
+        if t != self._ode_solver.t:
+            self._ode_solver.integrate(t)
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        # When working with mcstep, we use the dense output feature:
+        # a range in which the state at any time can be computed with
+        # minimal work. We keep track of the range with _back and _front.
+        self._check_handle()
+        if self._ode_solver.t == t:
+            # Exact same `t` as the last call, nothing to do.
+            pass
+        elif self._back > t:
+            # `t` before the range: not supported.
+            raise IntegratorException(
+                f"`t`={t} is behind the integration limit: "
+                f"{t} < {self._back}."
+            )
+        elif t <= self._front:
+            # In the range, ask for the new state.
+            self._ode_solver.integrate(t)
+        elif self._ode_solver.t < self._front:
+            # `t` after the range but last call (`t_prev`) not at the front.
+            # Advancing the range would make the interval `t_prev`..`_front`
+            # unreachable. Thus advance to _front.
+            self._ode_solver.integrate(self._front)
+        else:
+            # Advance the range.
+            self._back = self._front
+            self._ode_solver.integrate(t, step=True)
+            self._front = self._ode_solver._integrator.rwork[12]
+
+        return self.get_state(copy)
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        messages = {
+            -1: 'Excess work done on this call. Try to increasing '
+                'the nsteps parameter in the Options class',
+            -2: 'Excess accuracy requested. (Tolerances too small.)',
+            -3: 'Illegal input detected.',
+            -4: 'Repeated error test failures. (Check all input.)',
+            -5: 'Repeated convergence failures. (Perhaps bad'
+                ' Jacobian supplied or wrong choice of MF or tolerances.)',
+            -6: 'Error weight became zero during problem. (Solution'
+                ' component i vanished, and ATOL or ATOL(i) = 0.)'
+        }
+        raise IntegratorException(
+            messages[self._ode_solver._integrator.istate]
+        )
+
+    @property
+    def options(self):
+        """
+        Supported options by zvode integrator:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        order : int, default=12, 'adams' or 5, 'bdf'
+            Order of integrator <=12 'adams', <=5 'bdf'
+
+        nsteps : int, default=2500
+            Max. number of internal steps/call.
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        min_step : float, default=0
+            Minimum step size (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+            When using pulses, change to half the thinest pulse otherwise it
+            may be skipped.
+    """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class IntegratorScipyBDF(IntegratorScipyAdams):
+    """
+    Integrator using Scipy `ode` with zvode integrator using bdf method.
+    Ordinary Differential Equation solver by netlib
+    (http://www.netlib.org/odepack).
+
+    Usable with ``method="bdf"``
+    """
+    method = 'bdf'
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'order': 5,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+    }
+
+
+class IntegratorScipyDop853(Integrator):
+    """
+    Integrator using Scipy `ode` with dop853 integrator. Eight order
+    runge-kutta method by Dormand & Prince. Use fortran implementation
+    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
+    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
+    Computational Mathematics, Springer-Verlag (1993)].
+
+    Usable with ``method="dop853"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'first_step': 0,
+        'max_step': 0,
+        'ifactor': 6.0,
+        'dfactor': 0.3,
+        'beta': 0.0,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'dop853'
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        """
+        self._ode_solver = ode(self._mul_np_vec)
+        self._ode_solver.set_integrator('dop853', **self.options)
+        self.name = "scipy ode dop853"
+
+    def _mul_np_vec(self, t, vec):
+        """
+        Interface between scipy which use numpy and the driver, which use data.
+        """
+        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
+        column_unstack_dense(state, self._size, inplace=True)
+        out = self.system.matmul_data(t, state)
+        column_stack_dense(out, inplace=True)
+        return out.as_ndarray().ravel().view(np.float64)
+
+    def integrate(self, t, copy=True):
+        if t != self._ode_solver.t:
+            self._ode_solver.integrate(t)
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        if self._ode_solver.t <= t:
+            # Scipy's DOP853 does not have a step function.
+            # It has a safe step length, but can be 0 if unknown.
+            dt = self._ode_solver._integrator.work[6]
+            if dt:
+                t = min(self._ode_solver.t + dt, t)
+            self._ode_solver.integrate(t)
+        else:
+            # While DOP853 support changing the direction of the integration,
+            # it does not do so efficiently. We do it manually.
+            self._ode_solver._integrator.work[6] *= -1
+            self._ode_solver.integrate(t)
+            self._ode_solver._integrator.work[6] *= -1
+        return self.get_state(copy)
+
+    def get_state(self, copy=True):
+        if not self._is_set:
+            raise IntegratorException("The state is not initialted")
+        self._check_failed_integration()
+        t = self._ode_solver.t
+        if self._mat_state:
+            state = _data.column_unstack_dense(
+                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
+                                  copy=copy),
+                self._size,
+                inplace=True)
+        else:
+            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
+                                      copy=copy)
+        return t, state
+
+    def set_state(self, t, state0):
+        self._is_set = True
+        self._mat_state = state0.shape[1] > 1
+        self._size = state0.shape[0]
+        if self._mat_state:
+            state0 = _data.column_stack(state0)
+        self._ode_solver.set_initial_value(
+            state0.to_array().ravel().view(np.float64),
+            t
+        )
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        messages = {
+            -1: 'input is not consistent',
+            -2: 'larger nsteps is needed, Try to increase the nsteps '
+                'parameter in the Options class.',
+            -3: 'step size becomes too small. Try increasing tolerance',
+            -4: 'problem is probably stiff (interrupted), try "bdf" '
+                'method instead',
+        }
+        raise IntegratorException(
+            messages[self._ode_solver._integrator.istate]
+        )
+
+    @property
+    def options(self):
+        """
+        Supported options by dop853 integrator:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        nsteps : int, default=2500
+            Max. number of internal steps/call.
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+
+        ifactor, dfactor : float, default=6., 0.3
+            Maximum factor to increase/decrease step size by in one step
+
+        beta : float, default=0
+            Beta parameter for stabilised step size control.
+
+        See scipy.integrate.ode ode for more detail
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class IntegratorScipylsoda(IntegratorScipyDop853):
+    """
+    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
+    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
+    'BDF' methods to solve both stiff and non-stiff systems.
+
+    Usable with ``method="lsoda"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'max_order_ns': 12,
+        'max_order_s': 5,
+        'first_step': 0.0,
+        'max_step': 0.0,
+        'min_step': 0.0,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'lsoda'
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        """
+        self._ode_solver = ode(self._mul_np_vec)
+        self._ode_solver.set_integrator('lsoda', **self.options)
+        self.name = "scipy lsoda"
+
+    def _check_handle(self):
+        """
+        Do the check for concurrent use of the integrator and reset if used
+        elsewhere.
+        """
+        integrator = self._ode_solver._integrator
+        if integrator.initialized:
+            if integrator.handle != integrator.__class__.active_global_handle:
+                integrator.reset(len(self._ode_solver._y), False)
+
+    def integrate(self, t, copy=True):
+        self._check_handle()
+        return super().integrate(t, copy)
+
+    def set_state(self, t, state0):
+        self._front = t
+        super().set_state(t, state0)
+        self._back = self.get_state()
+
+    def mcstep(self, t, copy=True):
+        # This solver support dense output:
+        # a range in which the state at any time can be computed with
+        # minimal work. We keep track of the range with _back[0] and _front.
+        self._check_handle()
+        if self._ode_solver.t == t:
+            # Exact same `t` as the last call, nothing to do.
+            pass
+        elif self._back[0] <= t <= self._front:
+            # In the range, ask for the new state.
+            self._backstep(t)
+        elif self._front < t:
+            # Advance the range.
+            self._one_step(t)
+        else:
+            raise IntegratorException(
+                f"`t`={t} is behind the integration limit: "
+                f"{t} < {self._back[0]}."
+            )
+        return self.get_state(copy)
+
+    def _one_step(self, t):
+        """
+        Advance up to t by one internal solver step.
+        Should be able to retreive the state at any time between the present
+        time and the resulting time using `backstep`.
+        """
+        # Here we want to advance up to t doing maximum one step.
+        # lsoda officially support step, but sometime it does more work than
+        # needed, so we ask it to advance a fraction of the last step, where it
+        # will advance one internal step of length allowed by the tolerance and
+        # interpolate back to the asked time, effictively getting the single
+        # integration step we want. The first step and abrupt changes in the
+        # `rhs` can cause exceptions to this, but _backstep catch those cases.
+        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
+        t_ode = self._ode_solver.t
+
+        if t > self._front and t_ode >= self._front:
+            # The state is at self._front, do a step
+            self._back = self.get_state()
+            self._ode_solver.integrate(min(self._front + safe_delta, t))
+            self._front = self._ode_solver._integrator.rwork[12]
+            # We asked for a fraction of a step, now complete it.
+            self._ode_solver.integrate(min(self._front, t))
+        elif t > self._front:
+            # The state is at a time before t_front, advance to t_front
+            self._ode_solver.integrate(self._front)
+
+    def _backstep(self, t):
+        """
+        Retreive the state at time t, with t smaller than present ODE time.
+        The time t will always be between the last calls of `one_step`.
+        return the pair t, state.
+        """
+        delta = self._ode_solver._integrator.rwork[11]
+        if t == self._ode_solver.t:
+            pass
+        elif self._front - delta <= t:
+            self._ode_solver.integrate(t)
+        else:
+            self.set_state(*self._back)
+            self._ode_solver.integrate(t)
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        messages = {
+            -1: "Excess work done on this call."
+                "Try to increase the nsteps parameter in the Options class.",
+            -2: "Excess accuracy requested (tolerances too small).",
+            -3: "Illegal input detected (internal error).",
+            -4: "Repeated error test failures (internal error).",
+            -5: "Repeated convergence failures "
+                "(perhaps bad Jacobian or tolerances).",
+            -6: "Error weight became zero during problem.",
+            -7: "Internal workspace insufficient to finish (internal error)."
+        }
+        raise IntegratorException(
+            messages[self._ode_solver._integrator.istate]
+        )
+
+    @property
+    def options(self):
+        """
+        Supported options by lsoda integrator:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        nsteps : int, default=2500
+            Max. number of internal steps/call.
+
+        max_order_ns : int, default=12
+            Maximum order used in the nonstiff case (<= 12).
+
+        max_order_s : int, default=5
+            Maximum order used in the stiff case (<= 5).
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+            When using pulses, change to half the thinest pulse otherwise it
+            may be skipped.
+
+        min_step : float, default=0
+            Minimum step size (0 = automatic)
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+Solver.add_integrator(IntegratorScipyBDF, 'bdf')
+Solver.add_integrator(IntegratorScipyAdams, 'adams')
+Solver.add_integrator(IntegratorScipyDop853, 'dop853')
+Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
diff --git a/qutip/solver/integrator/verner7efficient.py b/qutip/solver/integrator/verner7efficient.py
index c49882a221..3bda6a91eb 100644
--- a/qutip/solver/integrator/verner7efficient.py
+++ b/qutip/solver/integrator/verner7efficient.py
@@ -1,333 +1,333 @@
-"""
-Provide a cython implimentation verner 'most-efficient'
-order 7 runge-Kutta method.
-See http://people.math.sfu.ca/~jverner/
-"""
-# Verner 7 Efficient
-# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
-__all__ = ["vern7_coeff"]
-import numpy as np
-order = 7
-rk_step = 10
-rk_extra_step = 16
-denseout_order = 7
-
-bh = np.zeros(rk_step, dtype=np.float64)
-a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
-b = np.zeros(rk_step, dtype=np.float64)
-c = np.zeros(rk_extra_step, dtype=np.float64)
-e = np.zeros(rk_step, dtype=np.float64)
-bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
-
-c[0] = 0.
-c[1] = .5000000000000000000000000000000000000000e-2
-c[2] = .1088888888888888888888888888888888888889
-c[3] = .1633333333333333333333333333333333333333
-c[4] = .4555000000000000000000000000000000000000
-c[5] = .6095094489978381317087004421486024949638
-c[6] = .8840000000000000000000000000000000000000
-c[7] = .9250000000000000000000000000000000000000
-c[8] = 1.
-c[9] = 1.
-
-a[1, 0] = .5000000000000000000000000000000000000000e-2
-
-a[2, 0] = -1.076790123456790123456790123456790123457
-a[2, 1] = 1.185679012345679012345679012345679012346
-
-a[3, 0] = .4083333333333333333333333333333333333333e-1
-a[3, 1] = 0.
-a[3, 2] = .1225000000000000000000000000000000000000
-
-a[4, 0] = .6389139236255726780508121615993336109954
-a[4, 1] = 0.
-a[4, 2] = -2.455672638223656809662640566430653894211
-a[4, 3] = 2.272258714598084131611828404831320283215
-
-a[5, 0] = -2.661577375018757131119259297861818119279
-a[5, 1] = 0.
-a[5, 2] = 10.80451388645613769565396655365532838482
-a[5, 3] = -8.353914657396199411968048547819291691541
-a[5, 4] = .8204875949566569791420417341743839209619
-
-a[6, 0] = 6.067741434696770992718360183877276714679
-a[6, 1] = 0.
-a[6, 2] = -24.71127363591108579734203485290746001803
-a[6, 3] = 20.42751793078889394045773111748346612697
-a[6, 4] = -1.906157978816647150624096784352757010879
-a[6, 5] = 1.006172249242068014790040335899474187268
-
-a[7, 0] = 12.05467007625320299509109452892778311648
-a[7, 1] = 0.
-a[7, 2] = -49.75478495046898932807257615331444758322
-a[7, 3] = 41.14288863860467663259698416710157354209
-a[7, 4] = -4.461760149974004185641911603484815375051
-a[7, 5] = 2.042334822239174959821717077708608543738
-a[7, 6] = -0.9834843665406107379530801693870224403537e-1
-
-a[8, 0] = 10.13814652288180787641845141981689030769
-a[8, 1] = 0.
-a[8, 2] = -42.64113603171750214622846006736635730625
-a[8, 3] = 35.76384003992257007135021178023160054034
-a[8, 4] = -4.348022840392907653340370296908245943710
-a[8, 5] = 2.009862268377035895441943593011827554771
-a[8, 6] = .3487490460338272405953822853053145879140
-a[8, 7] = -.2714390051048312842371587140910297407572
-
-a[9, 0] = -45.03007203429867712435322405073769635151
-a[9, 1] = 0.
-a[9, 2] = 187.3272437654588840752418206154201997384
-a[9, 3] = -154.0288236935018690596728621034510402582
-a[9, 4] = 18.56465306347536233859492332958439136765
-a[9, 5] = -7.141809679295078854925420496823551192821
-a[9, 6] = 1.308808578161378625114762706007696696508
-a[9, 7] = 0.
-a[9, 8] = 0.
-
-b[0] = .4715561848627222170431765108838175679569e-1
-b[1] = 0.
-b[2] = 0.
-b[3] = .2575056429843415189596436101037687580986
-b[4] = .2621665397741262047713863095764527711129
-b[5] = .1521609265673855740323133199165117535523
-b[6] = .4939969170032484246907175893227876844296
-b[7] = -.2943031171403250441557244744092703429139
-b[8] = .8131747232495109999734599440136761892478e-1
-b[9] = 0.
-
-bh[0] = .4460860660634117628731817597479197781432e-1
-bh[1] = 0.
-bh[2] = 0.
-bh[3] = .2671640378571372680509102260943837899738
-bh[4] = .2201018300177293019979715776650753096323
-bh[5] = .2188431703143156830983120833512893824578
-bh[6] = .2289871705411202883378173889763552365362
-bh[7] = 0.
-bh[8] = 0.
-bh[9] = .2029518466335628222767054793810430358554e-1
-
-for i in range(10):
-    e[i] = b[i] - bh[i]
-
-c[10] = 1
-
-a[10, 0] = .4715561848627222170431765108838175679569e-1
-a[10, 1] = 0.
-a[10, 2] = 0.
-a[10, 3] = .2575056429843415189596436101037687580986
-a[10, 4] = .2621665397741262047713863095764527711129
-a[10, 5] = .1521609265673855740323133199165117535523
-a[10, 6] = .4939969170032484246907175893227876844296
-a[10, 7] = -.2943031171403250441557244744092703429139
-a[10, 8] = .8131747232495109999734599440136761892478e-1
-a[10, 9] = 0.
-
-c[11] = 29/100
-
-a[11, 0] = .5232227691599689815470932256735029887614e-1
-a[11, 1] = 0.
-a[11, 2] = 0.
-a[11, 3] = .2249586182670571550244187743667190903405
-a[11, 4] = .1744370924877637539031751304611402542578e-1
-a[11, 5] = -.7669379876829393188009028209348812321417e-2
-a[11, 6] = .3435896044073284645684381456417912794447e-1
-a[11, 7] = -.4102097230093949839125144540100346681769e-1
-a[11, 8] = .2565113300520561655297104906598973655221e-1
-a[11, 9] = 0.
-a[11, 10] = -.1604434570000000000000000000000000000000e-1
-
-c[12] = 1/8
-
-a[12, 0] = .5305334125785908638834747243817578898946e-1
-a[12, 1] = 0.
-a[12, 2] = 0.
-a[12, 3] = .1219530101140188607092225622195251463666
-a[12, 4] = .1774684073760249704011573985936092552347e-1
-a[12, 5] = -.5928372667681494328907467430302313286925e-3
-a[12, 6] = .8381833970853750873624781948796072714855e-2
-a[12, 7] = -.1293369259698611956700998079778496462996e-1
-a[12, 8] = .9412056815253860804791356641605087829772e-2
-a[12, 9] = 0.
-a[12, 10] = -.5353253107275676032399320754008272222345e-2
-a[12, 11] = -.6666729992455811078380186481263955324311e-1
-
-c[13] = 1/4
-
-a[13, 0] = .3887903257436303686399931060834951327899e-1
-a[13, 1] = 0.
-a[13, 2] = 0.
-a[13, 3] = -.2440320330830131517910045090190069290791e-2
-a[13, 4] = -.1392891721467262281273220992320214734208e-2
-a[13, 5] = -.4744629155868013465038358934145339168472e-3
-a[13, 6] = .3920793241315951369383517310870803393356e-3
-a[13, 7] = -.4055473328512800136385880031750264996936e-3
-a[13, 8] = .1989709314771672628794304728258886009267e-3
-a[13, 9] = 0.
-a[13, 10] = -.1027819879317916884712606136811051029682e-3
-a[13, 11] = .3385661513870266715302548402957613704604e-1
-a[13, 12] = .1814893063199928004309543737509423302792
-
-c[14] = 53/100
-
-a[14, 0] = .5723681204690012909606837582140921695189e-1
-a[14, 1] = 0.
-a[14, 2] = 0.
-a[14, 3] = .2226594806676118099285816235023183680020
-a[14, 4] = .1234486420018689904911221497830317287757
-a[14, 5] = .4006332526666490875113688731927762275433e-1
-a[14, 6] = -.5269894848581452066926326838943832327366e-1
-a[14, 7] = .4765971214244522856887315416093212596338e-1
-a[14, 8] = -.2138895885042213036387863538386958914368e-1
-a[14, 9] = 0.
-a[14, 10] = .1519389106403640165459624646184297766866e-1
-a[14, 11] = .1206054671628965554251364472502413614358
-a[14, 12] = -.2277942301618737288237298052574548913451e-1
-a[14, 13] = 0.
-
-c[15] = 79/100
-
-a[15, 0] = .5137203880275681426595607279552927584506e-1
-a[15, 1] = 0.
-a[15, 2] = 0.
-a[15, 3] = .5414214473439405582401399378307410450482
-a[15, 4] = .3503998066921840081154745647747846804810
-a[15, 5] = .1419311226969218216861835872156617148040
-a[15, 6] = .1052737747842942254816302629823570359198
-a[15, 7] = -.3108184780587401700842726199589213259835e-1
-a[15, 8] = -.7401883149519145061791854716430279714483e-2
-a[15, 9] = 0.
-a[15, 10] = -.6377932504865363437569726480040013149706e-2
-a[15, 11] = -.1732549590836186403386348310205265959935
-a[15, 12] = -.1822815677762202619429607513861847306420
-a[15, 13] = 0.
-a[15, 14] = 0.
-
-bi[0, 0] = 1.
-bi[0, 1] = -8.413387198332767469319987751201351965810
-bi[0, 2] = 33.67550888449089654479469983556967202215
-bi[0, 3] = -70.80159089484886164618905961010838757357
-bi[0, 4] = 80.64695108301297872968868805293298389704
-bi[0, 5] = -47.19413969837521580145883430419406103536
-bi[0, 6] = 11.13381344253924186418881142808952641234
-
-bi[1, 0] = 0.
-bi[1, 1] = 0.
-bi[1, 2] = 0.
-bi[1, 3] = 0.
-bi[1, 4] = 0.
-bi[1, 5] = 0.
-bi[1, 6] = 0.
-
-bi[2, 0] = 0.
-bi[2, 1] = 0.
-bi[2, 2] = 0.
-bi[2, 3] = 0.
-bi[2, 4] = 0.
-bi[2, 5] = 0.
-bi[2, 6] = 0.
-
-bi[3, 0] = 0.
-bi[3, 1] = 8.754921980674397160629587282876763437696
-bi[3, 2] = -88.45968286997709426134300934922618655402
-bi[3, 3] = 346.9017638429916309499891288356321692825
-bi[3, 4] = -629.2580030059837046812187141184986252218
-bi[3, 5] = 529.6773755604192983874116479833480529304
-bi[3, 6] = -167.3588698651401860365089970240284051167
-
-bi[4, 0] = 0.
-bi[4, 1] = 8.913387586637921662996190126913331844214
-bi[4, 2] = -90.06081846893217794712014609702916991513
-bi[4, 3] = 353.1807459217057824951538014683541349020
-bi[4, 4] = -640.6476819744374433668701027882567716886
-bi[4, 5] = 539.2646279047155261551781390920363285084
-bi[4, 6] = -170.3880944299154827945664954924414008798
-
-bi[5, 0] = 0.
-bi[5, 1] = 5.173312029847800338889849068990984974299
-bi[5, 2] = -52.27111590005538823385270070373176751689
-bi[5, 3] = 204.9853867374073094711024260808085419491
-bi[5, 4] = -371.8306118563602890875634623992262437796
-bi[5, 5] = 312.9880934374529000210073972654145891826
-bi[5, 6] = -98.89290352172494693555119599233959305606
-
-bi[6, 0] = 0.
-bi[6, 1] = 16.79537744079695986364946329034055578253
-bi[6, 2] = -169.7004000005972744435739149730966805754
-bi[6, 3] = 665.4937727009246303131700313781960584913
-bi[6, 4] = -1207.163889233600728395392916633015853882
-bi[6, 5] = 1016.129151581854603280159105697386989470
-bi[6, 6] = -321.0600155723749421933210511704882816019
-
-bi[7, 0] = 0.
-bi[7, 1] = -10.00599753609866476866352971232058330270
-bi[7, 2] = 101.1005433052275068199636113246449312792
-bi[7, 3] = -396.4739151237843754958939772727577263768
-bi[7, 4] = 719.1787707014182914108130834128646525498
-bi[7, 5] = -605.3681033918824350795711030652978269725
-bi[7, 6] = 191.2743989279793520691961908384572824802
-
-bi[8, 0] = 0.
-bi[8, 1] = 2.764708833638599139713222853969606774131
-bi[8, 2] = -27.93460263739046178114640484830267988046
-bi[8, 3] = 109.5477918613789217803046856340175757800
-bi[8, 4] = -198.7128113064482116421691972646370773711
-bi[8, 5] = 167.2663357164031670694252647113936863857
-bi[8, 6] = -52.85010499525706346613022509203974406942
-
-bi[9, 0] = 0.
-bi[9, 1] = 0.
-bi[9, 2] = 0.
-bi[9, 3] = 0.
-bi[9, 4] = 0.
-bi[9, 5] = 0.
-bi[9, 6] = 0.
-
-bi[10, 0] = 0.
-bi[10, 1] = -2.169632028016350481156919876642428429100
-bi[10, 2] = 22.01669603756987625585768587320929912766
-bi[10, 3] = -86.90152427798948350846176288615482496306
-bi[10, 4] = 159.2238897386147443720253338471077193471
-bi[10, 5] = -135.9618306534587908363115231453760181702
-bi[10, 6] = 43.79240118328000419804718618785625308759
-
-bi[11, 0] = 0.
-bi[11, 1] = -4.890070188793803933769786966428026149549
-bi[11, 2] = 22.75407737425176120799532459991506803585
-bi[11, 3] = -30.78034218537730965082079824005797506535
-bi[11, 4] = -2.797194317207249021142015125037024035537
-bi[11, 5] = 31.36945663750840183161406140272783187147
-bi[11, 6] = -15.65592732038180043387678567111987465689
-
-bi[12, 0] = 0.
-bi[12, 1] = 10.86217092955196715517224349929627754387
-bi[12, 2] = -50.54297141782710697188187875653305700081
-bi[12, 3] = 68.37148040407511827604242008548181691494
-bi[12, 4] = 6.213326521632409162585500428935637861213
-bi[12, 5] = -69.68006323194158104163196358466588618336
-bi[12, 6] = 34.77605679450919341971367832748521086414
-
-bi[13, 0] = 0.
-bi[13, 1] = -11.37286691922922915922346687401389055763
-bi[13, 2] = 130.7905807824671644130452602841032046030
-bi[13, 3] = -488.6511367778560207543260583489312609826
-bi[13, 4] = 832.2148793276440873476229585070779183432
-bi[13, 5] = -664.7743368554426242883314487337054193624
-bi[13, 6] = 201.7928804424166224412127551654694479565
-
-bi[14, 0] = 0.
-bi[14, 1] = -5.919778732715006698693070786679427540601
-bi[14, 2] = 63.27679965889218829298274978013773800731
-bi[14, 3] = -265.4326820887379575820873554556433306580
-bi[14, 4] = 520.1009254140610824835871087519714692468
-bi[14, 5] = -467.4121095339020118993777963241667608460
-bi[14, 6] = 155.3868452824017054035883640343803117904
-
-bi[15, 0] = 0.
-bi[15, 1] = -10.49214619796182281022379415510181241136
-bi[15, 2] = 105.3553852518801101042787230303396283676
-bi[15, 3] = -409.4397501198893846479834816688367917005
-bi[15, 4] = 732.8314489076540326880337353277812147333
-bi[15, 5] = -606.3044574733512377981129469949015057785
-bi[15, 6] = 188.0495196316683024640077644607192667895
-
-vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
+"""
+Provide a cython implimentation verner 'most-efficient'
+order 7 runge-Kutta method.
+See http://people.math.sfu.ca/~jverner/
+"""
+# Verner 7 Efficient
+# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
+__all__ = ["vern7_coeff"]
+import numpy as np
+order = 7
+rk_step = 10
+rk_extra_step = 16
+denseout_order = 7
+
+bh = np.zeros(rk_step, dtype=np.float64)
+a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
+b = np.zeros(rk_step, dtype=np.float64)
+c = np.zeros(rk_extra_step, dtype=np.float64)
+e = np.zeros(rk_step, dtype=np.float64)
+bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
+
+c[0] = 0.
+c[1] = .5000000000000000000000000000000000000000e-2
+c[2] = .1088888888888888888888888888888888888889
+c[3] = .1633333333333333333333333333333333333333
+c[4] = .4555000000000000000000000000000000000000
+c[5] = .6095094489978381317087004421486024949638
+c[6] = .8840000000000000000000000000000000000000
+c[7] = .9250000000000000000000000000000000000000
+c[8] = 1.
+c[9] = 1.
+
+a[1, 0] = .5000000000000000000000000000000000000000e-2
+
+a[2, 0] = -1.076790123456790123456790123456790123457
+a[2, 1] = 1.185679012345679012345679012345679012346
+
+a[3, 0] = .4083333333333333333333333333333333333333e-1
+a[3, 1] = 0.
+a[3, 2] = .1225000000000000000000000000000000000000
+
+a[4, 0] = .6389139236255726780508121615993336109954
+a[4, 1] = 0.
+a[4, 2] = -2.455672638223656809662640566430653894211
+a[4, 3] = 2.272258714598084131611828404831320283215
+
+a[5, 0] = -2.661577375018757131119259297861818119279
+a[5, 1] = 0.
+a[5, 2] = 10.80451388645613769565396655365532838482
+a[5, 3] = -8.353914657396199411968048547819291691541
+a[5, 4] = .8204875949566569791420417341743839209619
+
+a[6, 0] = 6.067741434696770992718360183877276714679
+a[6, 1] = 0.
+a[6, 2] = -24.71127363591108579734203485290746001803
+a[6, 3] = 20.42751793078889394045773111748346612697
+a[6, 4] = -1.906157978816647150624096784352757010879
+a[6, 5] = 1.006172249242068014790040335899474187268
+
+a[7, 0] = 12.05467007625320299509109452892778311648
+a[7, 1] = 0.
+a[7, 2] = -49.75478495046898932807257615331444758322
+a[7, 3] = 41.14288863860467663259698416710157354209
+a[7, 4] = -4.461760149974004185641911603484815375051
+a[7, 5] = 2.042334822239174959821717077708608543738
+a[7, 6] = -0.9834843665406107379530801693870224403537e-1
+
+a[8, 0] = 10.13814652288180787641845141981689030769
+a[8, 1] = 0.
+a[8, 2] = -42.64113603171750214622846006736635730625
+a[8, 3] = 35.76384003992257007135021178023160054034
+a[8, 4] = -4.348022840392907653340370296908245943710
+a[8, 5] = 2.009862268377035895441943593011827554771
+a[8, 6] = .3487490460338272405953822853053145879140
+a[8, 7] = -.2714390051048312842371587140910297407572
+
+a[9, 0] = -45.03007203429867712435322405073769635151
+a[9, 1] = 0.
+a[9, 2] = 187.3272437654588840752418206154201997384
+a[9, 3] = -154.0288236935018690596728621034510402582
+a[9, 4] = 18.56465306347536233859492332958439136765
+a[9, 5] = -7.141809679295078854925420496823551192821
+a[9, 6] = 1.308808578161378625114762706007696696508
+a[9, 7] = 0.
+a[9, 8] = 0.
+
+b[0] = .4715561848627222170431765108838175679569e-1
+b[1] = 0.
+b[2] = 0.
+b[3] = .2575056429843415189596436101037687580986
+b[4] = .2621665397741262047713863095764527711129
+b[5] = .1521609265673855740323133199165117535523
+b[6] = .4939969170032484246907175893227876844296
+b[7] = -.2943031171403250441557244744092703429139
+b[8] = .8131747232495109999734599440136761892478e-1
+b[9] = 0.
+
+bh[0] = .4460860660634117628731817597479197781432e-1
+bh[1] = 0.
+bh[2] = 0.
+bh[3] = .2671640378571372680509102260943837899738
+bh[4] = .2201018300177293019979715776650753096323
+bh[5] = .2188431703143156830983120833512893824578
+bh[6] = .2289871705411202883378173889763552365362
+bh[7] = 0.
+bh[8] = 0.
+bh[9] = .2029518466335628222767054793810430358554e-1
+
+for i in range(10):
+    e[i] = b[i] - bh[i]
+
+c[10] = 1
+
+a[10, 0] = .4715561848627222170431765108838175679569e-1
+a[10, 1] = 0.
+a[10, 2] = 0.
+a[10, 3] = .2575056429843415189596436101037687580986
+a[10, 4] = .2621665397741262047713863095764527711129
+a[10, 5] = .1521609265673855740323133199165117535523
+a[10, 6] = .4939969170032484246907175893227876844296
+a[10, 7] = -.2943031171403250441557244744092703429139
+a[10, 8] = .8131747232495109999734599440136761892478e-1
+a[10, 9] = 0.
+
+c[11] = 29/100
+
+a[11, 0] = .5232227691599689815470932256735029887614e-1
+a[11, 1] = 0.
+a[11, 2] = 0.
+a[11, 3] = .2249586182670571550244187743667190903405
+a[11, 4] = .1744370924877637539031751304611402542578e-1
+a[11, 5] = -.7669379876829393188009028209348812321417e-2
+a[11, 6] = .3435896044073284645684381456417912794447e-1
+a[11, 7] = -.4102097230093949839125144540100346681769e-1
+a[11, 8] = .2565113300520561655297104906598973655221e-1
+a[11, 9] = 0.
+a[11, 10] = -.1604434570000000000000000000000000000000e-1
+
+c[12] = 1/8
+
+a[12, 0] = .5305334125785908638834747243817578898946e-1
+a[12, 1] = 0.
+a[12, 2] = 0.
+a[12, 3] = .1219530101140188607092225622195251463666
+a[12, 4] = .1774684073760249704011573985936092552347e-1
+a[12, 5] = -.5928372667681494328907467430302313286925e-3
+a[12, 6] = .8381833970853750873624781948796072714855e-2
+a[12, 7] = -.1293369259698611956700998079778496462996e-1
+a[12, 8] = .9412056815253860804791356641605087829772e-2
+a[12, 9] = 0.
+a[12, 10] = -.5353253107275676032399320754008272222345e-2
+a[12, 11] = -.6666729992455811078380186481263955324311e-1
+
+c[13] = 1/4
+
+a[13, 0] = .3887903257436303686399931060834951327899e-1
+a[13, 1] = 0.
+a[13, 2] = 0.
+a[13, 3] = -.2440320330830131517910045090190069290791e-2
+a[13, 4] = -.1392891721467262281273220992320214734208e-2
+a[13, 5] = -.4744629155868013465038358934145339168472e-3
+a[13, 6] = .3920793241315951369383517310870803393356e-3
+a[13, 7] = -.4055473328512800136385880031750264996936e-3
+a[13, 8] = .1989709314771672628794304728258886009267e-3
+a[13, 9] = 0.
+a[13, 10] = -.1027819879317916884712606136811051029682e-3
+a[13, 11] = .3385661513870266715302548402957613704604e-1
+a[13, 12] = .1814893063199928004309543737509423302792
+
+c[14] = 53/100
+
+a[14, 0] = .5723681204690012909606837582140921695189e-1
+a[14, 1] = 0.
+a[14, 2] = 0.
+a[14, 3] = .2226594806676118099285816235023183680020
+a[14, 4] = .1234486420018689904911221497830317287757
+a[14, 5] = .4006332526666490875113688731927762275433e-1
+a[14, 6] = -.5269894848581452066926326838943832327366e-1
+a[14, 7] = .4765971214244522856887315416093212596338e-1
+a[14, 8] = -.2138895885042213036387863538386958914368e-1
+a[14, 9] = 0.
+a[14, 10] = .1519389106403640165459624646184297766866e-1
+a[14, 11] = .1206054671628965554251364472502413614358
+a[14, 12] = -.2277942301618737288237298052574548913451e-1
+a[14, 13] = 0.
+
+c[15] = 79/100
+
+a[15, 0] = .5137203880275681426595607279552927584506e-1
+a[15, 1] = 0.
+a[15, 2] = 0.
+a[15, 3] = .5414214473439405582401399378307410450482
+a[15, 4] = .3503998066921840081154745647747846804810
+a[15, 5] = .1419311226969218216861835872156617148040
+a[15, 6] = .1052737747842942254816302629823570359198
+a[15, 7] = -.3108184780587401700842726199589213259835e-1
+a[15, 8] = -.7401883149519145061791854716430279714483e-2
+a[15, 9] = 0.
+a[15, 10] = -.6377932504865363437569726480040013149706e-2
+a[15, 11] = -.1732549590836186403386348310205265959935
+a[15, 12] = -.1822815677762202619429607513861847306420
+a[15, 13] = 0.
+a[15, 14] = 0.
+
+bi[0, 0] = 1.
+bi[0, 1] = -8.413387198332767469319987751201351965810
+bi[0, 2] = 33.67550888449089654479469983556967202215
+bi[0, 3] = -70.80159089484886164618905961010838757357
+bi[0, 4] = 80.64695108301297872968868805293298389704
+bi[0, 5] = -47.19413969837521580145883430419406103536
+bi[0, 6] = 11.13381344253924186418881142808952641234
+
+bi[1, 0] = 0.
+bi[1, 1] = 0.
+bi[1, 2] = 0.
+bi[1, 3] = 0.
+bi[1, 4] = 0.
+bi[1, 5] = 0.
+bi[1, 6] = 0.
+
+bi[2, 0] = 0.
+bi[2, 1] = 0.
+bi[2, 2] = 0.
+bi[2, 3] = 0.
+bi[2, 4] = 0.
+bi[2, 5] = 0.
+bi[2, 6] = 0.
+
+bi[3, 0] = 0.
+bi[3, 1] = 8.754921980674397160629587282876763437696
+bi[3, 2] = -88.45968286997709426134300934922618655402
+bi[3, 3] = 346.9017638429916309499891288356321692825
+bi[3, 4] = -629.2580030059837046812187141184986252218
+bi[3, 5] = 529.6773755604192983874116479833480529304
+bi[3, 6] = -167.3588698651401860365089970240284051167
+
+bi[4, 0] = 0.
+bi[4, 1] = 8.913387586637921662996190126913331844214
+bi[4, 2] = -90.06081846893217794712014609702916991513
+bi[4, 3] = 353.1807459217057824951538014683541349020
+bi[4, 4] = -640.6476819744374433668701027882567716886
+bi[4, 5] = 539.2646279047155261551781390920363285084
+bi[4, 6] = -170.3880944299154827945664954924414008798
+
+bi[5, 0] = 0.
+bi[5, 1] = 5.173312029847800338889849068990984974299
+bi[5, 2] = -52.27111590005538823385270070373176751689
+bi[5, 3] = 204.9853867374073094711024260808085419491
+bi[5, 4] = -371.8306118563602890875634623992262437796
+bi[5, 5] = 312.9880934374529000210073972654145891826
+bi[5, 6] = -98.89290352172494693555119599233959305606
+
+bi[6, 0] = 0.
+bi[6, 1] = 16.79537744079695986364946329034055578253
+bi[6, 2] = -169.7004000005972744435739149730966805754
+bi[6, 3] = 665.4937727009246303131700313781960584913
+bi[6, 4] = -1207.163889233600728395392916633015853882
+bi[6, 5] = 1016.129151581854603280159105697386989470
+bi[6, 6] = -321.0600155723749421933210511704882816019
+
+bi[7, 0] = 0.
+bi[7, 1] = -10.00599753609866476866352971232058330270
+bi[7, 2] = 101.1005433052275068199636113246449312792
+bi[7, 3] = -396.4739151237843754958939772727577263768
+bi[7, 4] = 719.1787707014182914108130834128646525498
+bi[7, 5] = -605.3681033918824350795711030652978269725
+bi[7, 6] = 191.2743989279793520691961908384572824802
+
+bi[8, 0] = 0.
+bi[8, 1] = 2.764708833638599139713222853969606774131
+bi[8, 2] = -27.93460263739046178114640484830267988046
+bi[8, 3] = 109.5477918613789217803046856340175757800
+bi[8, 4] = -198.7128113064482116421691972646370773711
+bi[8, 5] = 167.2663357164031670694252647113936863857
+bi[8, 6] = -52.85010499525706346613022509203974406942
+
+bi[9, 0] = 0.
+bi[9, 1] = 0.
+bi[9, 2] = 0.
+bi[9, 3] = 0.
+bi[9, 4] = 0.
+bi[9, 5] = 0.
+bi[9, 6] = 0.
+
+bi[10, 0] = 0.
+bi[10, 1] = -2.169632028016350481156919876642428429100
+bi[10, 2] = 22.01669603756987625585768587320929912766
+bi[10, 3] = -86.90152427798948350846176288615482496306
+bi[10, 4] = 159.2238897386147443720253338471077193471
+bi[10, 5] = -135.9618306534587908363115231453760181702
+bi[10, 6] = 43.79240118328000419804718618785625308759
+
+bi[11, 0] = 0.
+bi[11, 1] = -4.890070188793803933769786966428026149549
+bi[11, 2] = 22.75407737425176120799532459991506803585
+bi[11, 3] = -30.78034218537730965082079824005797506535
+bi[11, 4] = -2.797194317207249021142015125037024035537
+bi[11, 5] = 31.36945663750840183161406140272783187147
+bi[11, 6] = -15.65592732038180043387678567111987465689
+
+bi[12, 0] = 0.
+bi[12, 1] = 10.86217092955196715517224349929627754387
+bi[12, 2] = -50.54297141782710697188187875653305700081
+bi[12, 3] = 68.37148040407511827604242008548181691494
+bi[12, 4] = 6.213326521632409162585500428935637861213
+bi[12, 5] = -69.68006323194158104163196358466588618336
+bi[12, 6] = 34.77605679450919341971367832748521086414
+
+bi[13, 0] = 0.
+bi[13, 1] = -11.37286691922922915922346687401389055763
+bi[13, 2] = 130.7905807824671644130452602841032046030
+bi[13, 3] = -488.6511367778560207543260583489312609826
+bi[13, 4] = 832.2148793276440873476229585070779183432
+bi[13, 5] = -664.7743368554426242883314487337054193624
+bi[13, 6] = 201.7928804424166224412127551654694479565
+
+bi[14, 0] = 0.
+bi[14, 1] = -5.919778732715006698693070786679427540601
+bi[14, 2] = 63.27679965889218829298274978013773800731
+bi[14, 3] = -265.4326820887379575820873554556433306580
+bi[14, 4] = 520.1009254140610824835871087519714692468
+bi[14, 5] = -467.4121095339020118993777963241667608460
+bi[14, 6] = 155.3868452824017054035883640343803117904
+
+bi[15, 0] = 0.
+bi[15, 1] = -10.49214619796182281022379415510181241136
+bi[15, 2] = 105.3553852518801101042787230303396283676
+bi[15, 3] = -409.4397501198893846479834816688367917005
+bi[15, 4] = 732.8314489076540326880337353277812147333
+bi[15, 5] = -606.3044574733512377981129469949015057785
+bi[15, 6] = 188.0495196316683024640077644607192667895
+
+vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
diff --git a/qutip/solver/integrator/verner9efficient.py b/qutip/solver/integrator/verner9efficient.py
index 02b1d92681..aa331a9109 100644
--- a/qutip/solver/integrator/verner9efficient.py
+++ b/qutip/solver/integrator/verner9efficient.py
@@ -1,706 +1,706 @@
-"""
-Provide a cython implimentation verner 'most-efficient'
-order 9 runge-Kutta method.
-See http://people.math.sfu.ca/~jverner/
-"""
-# Verner 9 Efficient
-# http://people.math.sfu.ca/~jverner/
-
-__all__ = ["vern9_coeff"]
-import numpy as np
-order = 9
-rk_step = 16
-rk_extra_step = 26
-denseout_order = 9
-
-bh = np.zeros(rk_step, dtype=np.float64)
-a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
-b = np.zeros(rk_step, dtype=np.float64)
-c = np.zeros(rk_extra_step, dtype=np.float64)
-e = np.zeros(rk_step, dtype=np.float64)
-bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
-
-c[0] = 0.
-c[1] = .3462e-1
-c[2] = .9702435063878044594828361677100617517633e-1
-c[3] = .1455365259581706689224254251565092627645
-c[4] = .561
-c[5] = .2290079115904850126662751771814700052182
-c[6] = .5449920884095149873337248228185299947818
-c[7] = .645
-c[8] = .4837500000000000000000000000000000000000
-c[9] = .6757e-1
-c[10] = .2500
-c[11] = .6590650618730998549405331618649220295334
-c[12] = .8206
-c[13] = .9012
-c[14] = 1.
-c[15] = 1.
-
-a[1, 0] = .3462e-1
-
-a[2, 0] = -.389335438857287327017042687229284478532e-1
-a[2, 1] = .1359578945245091786499878854939346230295
-
-a[3, 0] = .3638413148954266723060635628912731569111e-1
-a[3, 1] = 0.
-a[3, 2] = .1091523944686280016918190688673819470733
-
-a[4, 0] = 2.025763914393969636805657604282571047511
-a[4, 1] = 0.
-a[4, 2] = -7.638023836496292020387602153091964592952
-a[4, 3] = 6.173259922102322383581944548809393545442
-
-a[5, 0] = .5112275589406060872792270881648288397197e-1
-a[5, 1] = 0.
-a[5, 2] = 0.
-a[5, 3] = .1770823794555021537929910813839068684087
-a[5, 4] = .80277624092225014536138698108025283759e-3
-
-a[6, 0] = .1316006357975216279279871693164256985334
-a[6, 1] = 0.
-a[6, 2] = 0.
-a[6, 3] = -.2957276252669636417685183174672273730699
-a[6, 4] = .878137803564295237421124704053886667082e-1
-a[6, 5] = .6213052975225274774321435005639430026100
-
-a[7, 0] = .7166666666666666666666666666666666666667e-1
-a[7, 1] = 0.
-a[7, 2] = 0.
-a[7, 3] = 0.
-a[7, 4] = 0.
-a[7, 5] = .3305533578915319409260346730051472207728
-a[7, 6] = .2427799754418013924072986603281861125606
-
-a[8, 0] = .7180664062500000000000000000000000000000e-1
-a[8, 1] = 0.
-a[8, 2] = 0.
-a[8, 3] = 0.
-a[8, 4] = 0.
-a[8, 5] = .3294380283228177160744825466257672816401
-a[8, 6] = .1165190029271822839255174533742327183599
-a[8, 7] = -.3401367187500000000000000000000000000000e-1
-
-a[9, 0] = .4836757646340646986611287718844085773549e-1
-a[9, 1] = 0.
-a[9, 2] = 0.
-a[9, 3] = 0.
-a[9, 4] = 0.
-a[9, 5] = .3928989925676163974333190042057047002852e-1
-a[9, 6] = .1054740945890344608263649267140088017604
-a[9, 7] = -.2143865284648312665982642293830533996214e-1
-a[9, 8] = -.1041229174627194437759832813847147895623
-
-a[10, 0] = -.2664561487201478635337289243849737340534e-1
-a[10, 1] = 0.
-a[10, 2] = 0.
-a[10, 3] = 0.
-a[10, 4] = 0.
-a[10, 5] = .3333333333333333333333333333333333333333e-1
-a[10, 6] = -.1631072244872467239162704487554706387141
-a[10, 7] = .3396081684127761199487954930015522928244e-1
-a[10, 8] = .1572319413814626097110769806810024118077
-a[10, 9] = .2152267478031879552303534778794770376960
-
-a[11, 0] = .3689009248708622334786359863227633989718e-1
-a[11, 1] = 0.
-a[11, 2] = 0.
-a[11, 3] = 0.
-a[11, 4] = 0.
-a[11, 5] = -.1465181576725542928653609891758501156785
-a[11, 6] = .2242577768172024345345469822625833796001
-a[11, 7] = .2294405717066072637090897902753790803034e-1
-a[11, 8] = -.35850052905728761357394424889330334334e-2
-a[11, 9] = .8669223316444385506869203619044453906053e-1
-a[11, 10] = .4383840651968337846196219974168630120572
-
-a[12, 0] = -.4866012215113340846662212357570395295088
-a[12, 1] = 0.
-a[12, 2] = 0.
-a[12, 3] = 0.
-a[12, 4] = 0.
-a[12, 5] = -6.304602650282852990657772792012007122988
-a[12, 6] = -.281245618289472564778284183790118418111
-a[12, 7] = -2.679019236219849057687906597489223155566
-a[12, 8] = .518815663924157511565311164615012522024
-a[12, 9] = 1.365353187603341710683633635235238678626
-a[12, 10] = 5.885091088503946585721274891680604830712
-a[12, 11] = 2.802808786272062889819965117517532194812
-
-a[13, 0] = .4185367457753471441471025246471931649633
-a[13, 1] = 0.
-a[13, 2] = 0.
-a[13, 3] = 0.
-a[13, 4] = 0.
-a[13, 5] = 6.724547581906459363100870806514855026676
-a[13, 6] = -.425444280164611790606983409697113064616
-a[13, 7] = 3.343279153001265577811816947557982637749
-a[13, 8] = .617081663117537759528421117507709784737
-a[13, 9] = -.929966123939932833937749523988800852013
-a[13, 10] = -6.099948804751010722472962837945508844846
-a[13, 11] = -3.002206187889399044804158084895173690015
-a[13, 12] = .2553202529443445472336424602988558373637
-
-a[14, 0] = -.779374086122884664644623040843840506343
-a[14, 1] = 0.
-a[14, 2] = 0.
-a[14, 3] = 0.
-a[14, 4] = 0.
-a[14, 5] = -13.93734253810777678786523664804936051203
-a[14, 6] = 1.252048853379357320949735183924200895136
-a[14, 7] = -14.69150040801686878191527989293072091588
-a[14, 8] = -.494705058533141685655191992136962873577
-a[14, 9] = 2.242974909146236657906984549543692874755
-a[14, 10] = 13.36789380382864375813864978592679139881
-a[14, 11] = 14.39665048665068644512236935340272139005
-a[14, 12] = -.7975813331776800379127866056663258667437
-a[14, 13] = .4409353709534277758753793068298041158235
-
-a[15, 0] = 2.058051337466886442151242368989994043993
-a[15, 1] = 0.
-a[15, 2] = 0.
-a[15, 3] = 0.
-a[15, 4] = 0.
-a[15, 5] = 22.35793772796803295519317565842520212899
-a[15, 6] = .90949810997556332745009198137971890783
-a[15, 7] = 35.89110098240264104710550686568482456493
-a[15, 8] = -3.442515027624453437985000403608480262211
-a[15, 9] = -4.865481358036368826566013387928704014496
-a[15, 10] = -18.90980381354342625688427480879773032857
-a[15, 11] = -34.26354448030451782929251177395134170515
-a[15, 12] = 1.264756521695642578827783499806516664686
-a[15, 13] = 0.
-a[15, 14] = 0.
-
-b[0] = .1461197685842315252051541915018784713459e-1
-b[1] = 0.
-b[2] = 0.
-b[3] = 0.
-b[4] = 0.
-b[5] = 0.
-b[6] = 0.
-b[7] = -.3915211862331339089410228267288242030810
-b[8] = .2310932500289506415909675644868993669908
-b[9] = .1274766769992852382560589467488989175618
-b[10] = .2246434176204157731566981937082069688984
-b[11] = .5684352689748512932705226972873692126743
-b[12] = .5825871557215827200814768021863420902155e-1
-b[13] = .1364317403482215641609022744494239843327
-b[14] = .3057013983082797397721005067920369646664e-1
-b[15] = 0.
-
-bh[0] = .1996996514886773085518508418098868756464e-1
-bh[1] = 0.
-bh[2] = 0.
-bh[3] = 0.
-bh[4] = 0.
-bh[5] = 0.
-bh[6] = 0.
-bh[7] = 2.191499304949330054530747099310837524864
-bh[8] = .8857071848208438030833722031786358862953e-1
-bh[9] = .1140560234865965622484956605091432032674
-bh[10] = .2533163805345107065564577734569651977347
-bh[11] = -2.056564386240941011158999594595981300493
-bh[12] = .3408096799013119935160094894224543812830
-bh[13] = 0.
-bh[14] = 0.
-bh[15] = .4834231373823958314376726739772871714902e-1
-
-for i in range(16):
-    e[i] = b[i] - bh[i]
-
-c[16] = 1.0
-
-a[16, 0] = .1461197685842315252051541915018784713459e-1
-a[16, 1] = 0.
-a[16, 2] = 0.
-a[16, 3] = 0.
-a[16, 4] = 0.
-a[16, 5] = 0.
-a[16, 6] = 0.
-a[16, 7] = -.3915211862331339089410228267288242030810
-a[16, 8] = .2310932500289506415909675644868993669908
-a[16, 9] = .1274766769992852382560589467488989175618
-a[16, 10] = .2246434176204157731566981937082069688984
-a[16, 11] = .5684352689748512932705226972873692126743
-a[16, 12] = .5825871557215827200814768021863420902155e-1
-a[16, 13] = .1364317403482215641609022744494239843327
-a[16, 14] = .3057013983082797397721005067920369646664e-1
-a[16, 15] = 0.
-
-c[17] = .7404185470631561083004100761798676215811
-
-a[17, 0] = .1549973668189559302279946863304789372788e-1
-a[17, 1] = 0.
-a[17, 2] = 0.
-a[17, 3] = 0.
-a[17, 4] = 0.
-a[17, 5] = 0.
-a[17, 6] = 0.
-a[17, 7] = .3355153219059635054403439303177105512242
-a[17, 8] = .2003613944191860651552622660712101217322
-a[17, 9] = .1252060659283549312946162355194540994211
-a[17, 10] = .2298676393184206750544046308957155868736
-a[17, 11] = -.2020250653476181447824906889122391003637
-a[17, 12] = .5917103230665456601422111997583025339897e-1
-a[17, 13] = -.2651834783047638681693835956996437528251e-1
-a[17, 14] = -.2384094602130971415278110567256446033405e-1
-a[17, 15] = 0.
-a[17, 16] = .2718171570208501807097257892166705118335e-1
-
-c[18] = .888
-
-a[18, 0] = .1302453943114338366054520296881099431474e-1
-a[18, 1] = 0.
-a[18, 2] = 0.
-a[18, 3] = 0.
-a[18, 4] = 0.
-a[18, 5] = 0.
-a[18, 6] = 0.
-a[18, 7] = -.7452850902413112085299330666038981625179
-a[18, 8] = .2643867896429300961465132150322749722129
-a[18, 9] = .1313961758372753932588328082078842388890
-a[18, 10] = .2167253815122927263092467187957410643315
-a[18, 11] = .8734117564076052559016338094938888451419
-a[18, 12] = .1185905643935776688228545787724340848142e-1
-a[18, 13] = .5876002941689550612992712203494447529933e-1
-a[18, 14] = .3266518630202087866399279690939423159022e-2
-a[18, 15] = 0.
-a[18, 16] = -.8959308648417929824525368306101792182274e-2
-a[18, 17] = .6941415157202692219907482080827253287034e-1
-
-c[19] = .696
-
-a[19, 0] = .1397089996925942721283716334050740168797e-1
-a[19, 1] = 0.
-a[19, 2] = 0.
-a[19, 3] = 0.
-a[19, 4] = 0.
-a[19, 5] = 0.
-a[19, 6] = 0.
-a[19, 7] = -.4665765335957674596054673402956853940520
-a[19, 8] = .2416372787216257077935214889875485248580
-a[19, 9] = .1290363341345674735721677437066933999929
-a[19, 10] = .2216700671735105311080225734522323922813
-a[19, 11] = .6257275123364644931771253383573999863003
-a[19, 12] = .4355312415679284117869124964829805160429e-1
-a[19, 13] = .1011962491667290833450024852274278874501
-a[19, 14] = .1808582254679721049279369742685497400353e-1
-a[19, 15] = 0.
-a[19, 16] = -.2079875587689169691156509689282083267654e-1
-a[19, 17] = -.9022232517086218976198252891464664868640e-1
-a[19, 18] = -.1212796735622254216011467740438097427634
-
-c[20] = .487
-
-a[20, 0] = .1604638888318112738641232352800290501904e-1
-a[20, 1] = 0.
-a[20, 2] = 0.
-a[20, 3] = 0.
-a[20, 4] = 0.
-a[20, 5] = 0.
-a[20, 6] = 0.
-a[20, 7] = .9517712399458336651642257453589397190702e-1
-a[20, 8] = .1359187264655317806136927180199100622471
-a[20, 9] = .1237765280959854006935081364365637515893
-a[20, 10] = .2335656264102966047058755123098072346246
-a[20, 11] = -.9051508172625873314662090873741762206189e-1
-a[20, 12] = -.2537574270006131028513276914038326155331e-1
-a[20, 13] = -.1359631696887162048002744757083947500478
-a[20, 14] = -.4679214284145113075088049469061349990847e-1
-a[20, 15] = 0.
-a[20, 16] = .5177958859391748239949773879090325427473e-1
-a[20, 17] = .9672595677476773313884172931875718705561e-1
-a[20, 18] = .1477312690340742769720989417101989769314
-a[20, 19] = -.1150750712958503934434410263732282100773
-c[21] = .25e-1
-
-a[21, 0] = .1802918623893620731908165792176564180038e-1
-a[21, 1] = 0.
-a[21, 2] = 0.
-a[21, 3] = 0.
-a[21, 4] = 0.
-a[21, 5] = 0.
-a[21, 6] = 0.
-a[21, 7] = .6983601042028873702545973390560096201728e-1
-a[21, 8] = -.2541247660791663512384395986842781657182e-1
-a[21, 9] = .8487827035463274491721441398893680307535e-2
-a[21, 10] = -.2427525516089801645451101966852425715128e-2
-a[21, 11] = -.1047839752893819879012607694745789515746
-a[21, 12] = -.1473147795248041942353840372690095884761e-1
-a[21, 13] = -.3916338390816177165706892282751065537530e-1
-a[21, 14] = -.1005657343293959419073236542225421561652e-1
-a[21, 15] = 0.
-a[21, 16] = .1102510392204834322538452331445716455061e-1
-a[21, 17] = .5092830749095398308703438556315975226108e-2
-a[21, 18] = .4759715599420644505591133410826632557391e-1
-a[21, 19] = .3386307003288382751110965442296681690349e-1
-a[21, 20] = .2764422831404797700452373965825845732168e-1
-
-c[22] = .15
-
-a[22, 0] = .1677431640522778042988664067637191163626e-1
-a[22, 1] = 0.
-a[22, 2] = 0.
-a[22, 3] = 0.
-a[22, 4] = 0.
-a[22, 5] = 0.
-a[22, 6] = 0.
-a[22, 7] = .6220437408820475326702539861577894278533
-a[22, 8] = -.2060859809768841878234097076241307428139
-a[22, 9] = .1156394989766058889629372195583391792474
-a[22, 10] = .2664101793378358946544219293685167025971e-1
-a[22, 11] = -.9376810793418770527505892794460093668860
-a[22, 12] = -.1367806466702160302637074581619101741312
-a[22, 13] = -.3678480995268296672182605288991379118419
-a[22, 14] = -.9547871314402478902820445838193201497337e-1
-a[22, 15] = 0.
-a[22, 16] = .1013492018422369748729008873270013785313
-a[22, 17] = -.8911323084568593396468400926074881389560e-1
-a[22, 18] = .4664140988974760478895528270623735057521
-a[22, 19] = .4502736292354579812232681662308722738519
-a[22, 20] = .1838522463326818655346135218242696774099
-a[22, 21] = 0.
-
-c[23] = .32
-
-a[23, 0] = .1071149731491444187554380927165768658192e-1
-a[23, 1] = 0.
-a[23, 2] = 0.
-a[23, 3] = 0.
-a[23, 4] = 0.
-a[23, 5] = 0.
-a[23, 6] = 0.
-a[23, 7] = -.7094336118221108191937165464264324417735e-1
-a[23, 8] = .1002164900340091596740582334112699697590
-a[23, 9] = .1383453980468025108839271214703390659581
-a[23, 10] = .1796330633578163411338104055485109917477
-a[23, 11] = .9048246545576180974879274948815422276563e-1
-a[23, 12] = -.5460662294523338383345981122023862069115e-2
-a[23, 13] = -.3000457905119619782973021046143166498567e-1
-a[23, 14] = -.1145192026962799093665613252151017277867e-1
-a[23, 15] = 0.
-a[23, 16] = .1003394686109385076849515422360600302176e-1
-a[23, 17] = -.9506485282809046129031027932806241113157e-1
-a[23, 18] = .4853358804093591445756711642658478691640e-1
-a[23, 19] = .8013325919783924638483373011297347396327e-1
-a[23, 20] = -.1251643326835242045676140618774248455713
-a[23, 21] = 0.
-a[23, 22] = 0.
-
-c[24] = .78
-
-a[24, 0] = .1410172088869221367153586187761994182069e-1
-a[24, 1] = 0.
-a[24, 2] = 0.
-a[24, 3] = 0.
-a[24, 4] = 0.
-a[24, 5] = 0.
-a[24, 6] = 0.
-a[24, 7] = -.3713379753704491105936205420001801316029
-a[24, 8] = .2231265548117180273161442520179150684520
-a[24, 9] = .1287005345918120122888629169443916280865
-a[24, 10] = .2224600659675494761192249831098918110654
-a[24, 11] = .5382853042550701952740528638168708946100
-a[24, 12] = .5417202616988763101781128062036252796548e-1
-a[24, 13] = .1256968791308743925752109039299467082975
-a[24, 14] = .2784492789002054061504430663197543089132e-1
-a[24, 15] = 0.
-a[24, 16] = -.3077409246205059733390460511525401688205e-1
-a[24, 17] = .8569805293689777608077303071761466118035e-2
-a[24, 18] = -.1535174690587044615794997685221990516897
-a[24, 19] = -.2179957030548196497189489878038029238243e-1
-a[24, 20] = .1447128819737186799295514239727801525027e-1
-a[24, 21] = 0.
-a[24, 22] = 0.
-a[24, 23] = 0.
-
-c[25] = .96
-
-a[25, 0] = .1424600411735646609296566581447532773183e-1
-a[25, 1] = 0.
-a[25, 2] = 0.
-a[25, 3] = 0.
-a[25, 4] = 0.
-a[25, 5] = 0.
-a[25, 6] = 0.
-a[25, 7] = -.3767107393295407091303982522049390741260
-a[25, 8] = .2252399780730421480874737297000189000070
-a[25, 9] = .1283603076292529988314451246143633426068
-a[25, 10] = .2230238705261692544876826347415151339678
-a[25, 11] = .5463127827750747224899202176094949607118
-a[25, 12] = .5526190791375779994553849469706124289752e-1
-a[25, 13] = .1285613508749982456581494397108686240388
-a[25, 14] = .2857250681296406482698934635829147899039e-1
-a[25, 15] = 0.
-a[25, 16] = -.2398761886357108720930416967644499057175e-1
-a[25, 17] = .5556224458910509454379297181908734648749e-1
-a[25, 18] = -.1740675650762838674257930398070760254668e-1
-a[25, 19] = -.3815462365996979065575121886854199471011e-1
-a[25, 20] = .1111878504898917877407531966545730451506e-1
-a[25, 21] = 0.
-a[25, 22] = 0.
-a[25, 23] = 0.
-a[25, 24] = 0.
-
-bi[0, 0] = 1.
-bi[0, 1] = -28.33048870061739823290767301658881994700
-bi[0, 2] = 257.6535452078577977252092979905248156497
-bi[0, 3] = -1152.154455743457311528752964691951881858
-bi[0, 4] = 2909.390878345408890936564599116550031880
-bi[0, 5] = -4355.005172868188498048946108887283528629
-bi[0, 6] = 3834.083497036262189455855371796461857871
-bi[0, 7] = -1835.419052683407081215583427992189311730
-bi[0, 8] = 368.7958613829998340610814211036270246107
-
-bi[1, 0] = 0.
-bi[1, 1] = 0.
-bi[1, 2] = 0.
-bi[1, 3] = 0.
-bi[1, 4] = 0.
-bi[1, 5] = 0.
-bi[1, 6] = 0.
-bi[1, 7] = 0.
-bi[1, 8] = 0.
-
-bi[2, 0] = 0.
-bi[2, 1] = 0.
-bi[2, 2] = 0.
-bi[2, 3] = 0.
-bi[2, 4] = 0.
-bi[2, 5] = 0.
-bi[2, 6] = 0.
-bi[2, 7] = 0.
-bi[2, 8] = 0.
-
-bi[3, 0] = 0.
-bi[3, 1] = 0.
-bi[3, 2] = 0.
-bi[3, 3] = 0.
-bi[3, 4] = 0.
-bi[3, 5] = 0.
-bi[3, 6] = 0.
-bi[3, 7] = 0.
-bi[3, 8] = 0.
-
-bi[4, 0] = 0.
-bi[4, 1] = 0.
-bi[4, 2] = 0.
-bi[4, 3] = 0.
-bi[4, 4] = 0.
-bi[4, 5] = 0.
-bi[4, 6] = 0.
-bi[4, 7] = 0.
-bi[4, 8] = 0.
-
-bi[5, 0] = 0.
-bi[5, 1] = 0.
-bi[5, 2] = 0.
-bi[5, 3] = 0.
-bi[5, 4] = 0.
-bi[5, 5] = 0.
-bi[5, 6] = 0.
-bi[5, 7] = 0.
-bi[5, 8] = 0.
-
-bi[6, 0] = 0.
-bi[6, 1] = 0.
-bi[6, 2] = 0.
-bi[6, 3] = 0.
-bi[6, 4] = 0.
-bi[6, 5] = 0.
-bi[6, 6] = 0.
-bi[6, 7] = 0.
-bi[6, 8] = 0.
-
-bi[7, 0] = 0.
-bi[7, 1] = 2.649656243770091212685381903551424676261
-bi[7, 2] = -96.30312807816005963630382777245983513008
-bi[7, 3] = 869.3095462492795755338599928089438369769
-bi[7, 4] = -3395.688567551074115525201961265641584358
-bi[7, 5] = 6796.933987158715680563278170147156885480
-bi[7, 6] = -7340.848417712071304684606060804637321789
-bi[7, 7] = 4082.848896992365666259441580054990759905
-bi[7, 8] = -919.2934944890586676320942978986329899642
-
-bi[8, 0] = 0.
-bi[8, 1] = -1.563945181928732780647121505551017046606
-bi[8, 2] = 56.84239739272860000194549791973820565214
-bi[8, 3] = -513.1052300304284642178552372517916694426
-bi[8, 4] = 2004.286702110323162741493515173880535381
-bi[8, 5] = -4011.853305913929339500285683507736138334
-bi[8, 6] = 4332.895839278586189971336003691596594090
-bi[8, 7] = -2409.879347937144606091337260195738587773
-bi[8, 8] = 542.6079835318221405169412532400889768401
-
-bi[9, 0] = 0.
-bi[9, 1] = -.8627103334967223830653368770735555216700
-bi[9, 2] = 31.35565375185173442495465167501846267906
-bi[9, 3] = -283.0413682227354209126847112083546012674
-bi[9, 4] = 1105.613463426006937052739159664962261462
-bi[9, 5] = -2213.036200678452629288185991597653042989
-bi[9, 6] = 2390.131097754120588994847482867886207858
-bi[9, 7] = -1329.348266146873716496636094950745123424
-bi[9, 8] = 299.3158071265785138462868993727082901209
-
-bi[10, 0] = 0.
-bi[10, 1] = -1.520295337901214839055193576160469820911
-bi[10, 2] = 55.25592121120227100440616045452813504748
-bi[10, 3] = -498.7844190970740738969945498750124435385
-bi[10, 4] = 1948.346888525776056658403461666308795237
-bi[10, 5] = -3899.882136407551390287649940376076923682
-bi[10, 6] = 4211.964345158858030803618536151121927765
-bi[10, 7] = -2342.619408856117128087568672414857706561
-bi[10, 8] = 527.4637482204278644179968961638568925209
-
-bi[11, 0] = 0.
-bi[11, 1] = -3.846938844125523400516071820264700141179
-bi[11, 2] = 139.8189840986840520353362018994734906611
-bi[11, 3] = -1262.118687621600386514715930156791825893
-bi[11, 4] = 4930.075848057311658057235318456802793199
-bi[11, 5] = -9868.219486069539059368988308801366826185
-bi[11, 6] = 10657.90892434886730229746304583865145121
-bi[11, 7] = -5927.738759872814112912292792695856187255
-bi[11, 8] = 1334.688551172190921099749059976639173619
-
-bi[12, 0] = 0.
-bi[12, 1] = -.3942713061200141454309326713125653612517
-bi[12, 2] = 14.32999476067649707020689155180345562459
-bi[12, 3] = -129.3540665994558117853022852051786116929
-bi[12, 4] = 505.2816077002517600897861155496606850457
-bi[12, 5] = -1011.390080139433268878243655218566636574
-bi[12, 6] = 1092.325051781891697669369143688906543465
-bi[12, 7] = -607.5317019302810290917918493845279272648
-bi[12, 8] = 136.7917244480423273434147193694336909663
-
-bi[13, 0] = 0.
-bi[13, 1] = -.9233145622082101394378429409444333268499
-bi[13, 2] = 33.55834582309798808260613735851232640640
-bi[13, 3] = -302.9246397549735936661321348695774835448
-bi[13, 4] = 1183.281306967867553342903125095128753568
-bi[13, 5] = -2368.498986790111516106072390247333149007
-bi[13, 6] = 2558.034559755808027369106332027405169828
-bi[13, 7] = -1422.733175577880214903071122439856598476
-bi[13, 8] = 320.3423358787481875842587982911148385364
-
-bi[14, 0] = 0.
-bi[14, 1] = -.2068862802930053801253649628830330891017
-bi[14, 2] = 7.519388975651662772174695012120581518594
-bi[14, 3] = -67.87605708082904058354114755731111898667
-bi[14, 4] = 265.1367996984150421661637988925923843021
-bi[14, 5] = -530.7074807559025368587558119659212235622
-bi[14, 6] = 573.1765495641490277116961329189087439579
-bi[14, 7] = -318.7905688834868978004500126002971837241
-bi[14, 8] = 71.77882490212657594681492031347005327988
-
-bi[15, 0] = 0.
-bi[15, 1] = 0.
-bi[15, 2] = 0.
-bi[15, 3] = 0.
-bi[15, 4] = 0.
-bi[15, 5] = 0.
-bi[15, 6] = 0.
-bi[15, 7] = 0.
-bi[15, 8] = 0.
-
-bi[16, 0] = 0.
-bi[16, 1] = -.4472441906744099441704338175964823026105
-bi[16, 2] = 16.44684676010503791623763886833381020592
-bi[16, 3] = -154.4086105921295528355180056633078150675
-bi[16, 4] = 641.8986298540248497333509289273669726482
-bi[16, 5] = -1391.939225687982391028602609567895699003
-bi[16, 6] = 1643.890568302952013019278202625162156841
-bi[16, 7] = -1004.065297223317845596795060426393517046
-bi[16, 8] = 248.6243327770222987362193390543305737239
-
-bi[17, 0] = 0.
-bi[17, 1] = -.1507876007899797948720901584434839156279
-bi[17, 2] = 5.527328824824632235316362126620825363280
-bi[17, 3] = -51.33833743084618751433903968701557585387
-bi[17, 4] = 209.6022002703280347991393999433060881829
-bi[17, 5] = -442.7692650421825928714839983614217797969
-bi[17, 6] = 505.0579312588052893780948070449787925777
-bi[17, 7] = -295.6336410615619366143935619944592839974
-bi[17, 8] = 69.70457078142274038253812108643441743987
-
-bi[18, 0] = 0.
-bi[18, 1] = -.6413652207435296452288504944964177537185
-bi[18, 2] = 23.51013248624684600263471193689787394701
-bi[18, 3] = -218.3642683246972281497485359238725613162
-bi[18, 4] = 891.5292818535365634586829868055833114383
-bi[18, 5] = -1883.290177206007885518558760085145850658
-bi[18, 6] = 2148.230954488399755970660772306573864434
-bi[18, 7] = -1257.458401521712336970840850120592935471
-bi[18, 8] = 296.4838434449778148523985255750527153802
-
-bi[19, 0] = 0.
-bi[19, 1] = 1.810729313444845732964058528284532356045
-bi[19, 2] = -66.37479657295337371220255196726289169374
-bi[19, 3] = 616.4952025401106511929691356878863855003
-bi[19, 4] = -2517.003030777322559684753470471663859295
-bi[19, 5] = 5316.984175781033401491488704359579721604
-bi[19, 6] = -6064.976140789574108556866601189158423779
-bi[19, 7] = 3550.109538888391317555902194852386816092
-bi[19, 8] = -837.0456783831301740195014698000522807852
-
-bi[20, 0] = 0.
-bi[20, 1] = .5176008760353717918864555990277480363987e-1
-bi[20, 2] = -1.897337862580348756406065418550014243949
-bi[20, 3] = 17.62264820793629244181715147639285955422
-bi[20, 4] = -71.94907400242465946110661282550878163878
-bi[20, 5] = 151.9871383765666045085018751235590550206
-bi[20, 6] = -173.3686498747860565970136435029707518663
-bi[20, 7] = 101.4806461521468075879782291473158292931
-bi[20, 8] = -23.92713108446217690295957956014097092250
-
-bi[21, 0] = 0.
-bi[21, 1] = 31.32178255668799909977422939838912846070
-bi[21, 2] = -355.6570858339106059687054319211280026146
-bi[21, 3] = 1752.685282489515979253875884672206842255
-bi[21, 4] = -4708.092293138363367969732154806019707156
-bi[21, 5] = 7370.900776193488713149861391844801840850
-bi[21, 6] = -6716.504964764565347011489385051202629762
-bi[21, 7] = 3303.940398161185772296756776169088470785
-bi[21, 8] = -678.5938956640391428503413103061359428182
-
-bi[22, 0] = 0.
-bi[22, 1] = -2.719607334185924760747802644504744092917
-bi[22, 2] = 86.64045615858264001154848875638486632034
-bi[22, 3] = -454.1926030939030807863651114984001402596
-bi[22, 4] = 1014.749221100543425314268817989377200147
-bi[22, 5] = -1133.583456714543865890388885909333783663
-bi[22, 6] = 610.4671827718666569168001429679645990946
-bi[22, 7] = -109.0233499449543802317396567002119357593
-bi[22, 8] = -12.33784294340547057337599296127606178639
-
-bi[23, 0] = 0.
-bi[23, 1] = 3.177214801432923432265738869490200556403
-bi[23, 2] = -113.8098697715142983214434051918276259885
-bi[23, 3] = 978.0935981825675014833003847211971070224
-bi[23, 4] = -3575.129377623670076451027372711378100786
-bi[23, 5] = 6764.361519838450570830405988615992045681
-bi[23, 6] = -6987.161043852012362644872233028628887679
-bi[23, 7] = 3751.905762789571137088934326513342858381
-bi[23, 8] = -821.4378043648253954175634277881875971878
-
-bi[24, 0] = 0.
-bi[24, 1] = .8772843083465530069477626269697233842708
-bi[24, 2] = -31.51810423988375104361582759389916060143
-bi[24, 3] = 273.1229151353221133842213845530391043248
-bi[24, 4] = -993.2198643101781966584366870874238565290
-bi[24, 5] = 1787.888078312663987193988385659681964836
-bi[24, 6] = -1677.394835799640950953367739332661886275
-bi[24, 7] = 781.3579535062687952504707744453846824540
-bi[24, 8] = -141.1134269128985501802080532710905715931
-
-bi[25, 0] = 0.
-bi[25, 1] = 1.719427581798715782378897599231938082126
-bi[25, 2] = -62.89867309250732184389962568482931880335
-bi[25, 3] = 580.3335507873980391019057196688995930872
-bi[25, 4] = -2348.110620506760958600472968113883922730
-bi[25, 5] = 4921.119298612906015908637628774963068611
-bi[25, 6] = -5597.912448707916639109910311016358007839
-bi[25, 7] = 3288.597775149621789973016480733216881572
-bi[25, 8] = -782.8483098245396412116558219612402319811
-
-vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
+"""
+Provide a cython implimentation verner 'most-efficient'
+order 9 runge-Kutta method.
+See http://people.math.sfu.ca/~jverner/
+"""
+# Verner 9 Efficient
+# http://people.math.sfu.ca/~jverner/
+
+__all__ = ["vern9_coeff"]
+import numpy as np
+order = 9
+rk_step = 16
+rk_extra_step = 26
+denseout_order = 9
+
+bh = np.zeros(rk_step, dtype=np.float64)
+a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
+b = np.zeros(rk_step, dtype=np.float64)
+c = np.zeros(rk_extra_step, dtype=np.float64)
+e = np.zeros(rk_step, dtype=np.float64)
+bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
+
+c[0] = 0.
+c[1] = .3462e-1
+c[2] = .9702435063878044594828361677100617517633e-1
+c[3] = .1455365259581706689224254251565092627645
+c[4] = .561
+c[5] = .2290079115904850126662751771814700052182
+c[6] = .5449920884095149873337248228185299947818
+c[7] = .645
+c[8] = .4837500000000000000000000000000000000000
+c[9] = .6757e-1
+c[10] = .2500
+c[11] = .6590650618730998549405331618649220295334
+c[12] = .8206
+c[13] = .9012
+c[14] = 1.
+c[15] = 1.
+
+a[1, 0] = .3462e-1
+
+a[2, 0] = -.389335438857287327017042687229284478532e-1
+a[2, 1] = .1359578945245091786499878854939346230295
+
+a[3, 0] = .3638413148954266723060635628912731569111e-1
+a[3, 1] = 0.
+a[3, 2] = .1091523944686280016918190688673819470733
+
+a[4, 0] = 2.025763914393969636805657604282571047511
+a[4, 1] = 0.
+a[4, 2] = -7.638023836496292020387602153091964592952
+a[4, 3] = 6.173259922102322383581944548809393545442
+
+a[5, 0] = .5112275589406060872792270881648288397197e-1
+a[5, 1] = 0.
+a[5, 2] = 0.
+a[5, 3] = .1770823794555021537929910813839068684087
+a[5, 4] = .80277624092225014536138698108025283759e-3
+
+a[6, 0] = .1316006357975216279279871693164256985334
+a[6, 1] = 0.
+a[6, 2] = 0.
+a[6, 3] = -.2957276252669636417685183174672273730699
+a[6, 4] = .878137803564295237421124704053886667082e-1
+a[6, 5] = .6213052975225274774321435005639430026100
+
+a[7, 0] = .7166666666666666666666666666666666666667e-1
+a[7, 1] = 0.
+a[7, 2] = 0.
+a[7, 3] = 0.
+a[7, 4] = 0.
+a[7, 5] = .3305533578915319409260346730051472207728
+a[7, 6] = .2427799754418013924072986603281861125606
+
+a[8, 0] = .7180664062500000000000000000000000000000e-1
+a[8, 1] = 0.
+a[8, 2] = 0.
+a[8, 3] = 0.
+a[8, 4] = 0.
+a[8, 5] = .3294380283228177160744825466257672816401
+a[8, 6] = .1165190029271822839255174533742327183599
+a[8, 7] = -.3401367187500000000000000000000000000000e-1
+
+a[9, 0] = .4836757646340646986611287718844085773549e-1
+a[9, 1] = 0.
+a[9, 2] = 0.
+a[9, 3] = 0.
+a[9, 4] = 0.
+a[9, 5] = .3928989925676163974333190042057047002852e-1
+a[9, 6] = .1054740945890344608263649267140088017604
+a[9, 7] = -.2143865284648312665982642293830533996214e-1
+a[9, 8] = -.1041229174627194437759832813847147895623
+
+a[10, 0] = -.2664561487201478635337289243849737340534e-1
+a[10, 1] = 0.
+a[10, 2] = 0.
+a[10, 3] = 0.
+a[10, 4] = 0.
+a[10, 5] = .3333333333333333333333333333333333333333e-1
+a[10, 6] = -.1631072244872467239162704487554706387141
+a[10, 7] = .3396081684127761199487954930015522928244e-1
+a[10, 8] = .1572319413814626097110769806810024118077
+a[10, 9] = .2152267478031879552303534778794770376960
+
+a[11, 0] = .3689009248708622334786359863227633989718e-1
+a[11, 1] = 0.
+a[11, 2] = 0.
+a[11, 3] = 0.
+a[11, 4] = 0.
+a[11, 5] = -.1465181576725542928653609891758501156785
+a[11, 6] = .2242577768172024345345469822625833796001
+a[11, 7] = .2294405717066072637090897902753790803034e-1
+a[11, 8] = -.35850052905728761357394424889330334334e-2
+a[11, 9] = .8669223316444385506869203619044453906053e-1
+a[11, 10] = .4383840651968337846196219974168630120572
+
+a[12, 0] = -.4866012215113340846662212357570395295088
+a[12, 1] = 0.
+a[12, 2] = 0.
+a[12, 3] = 0.
+a[12, 4] = 0.
+a[12, 5] = -6.304602650282852990657772792012007122988
+a[12, 6] = -.281245618289472564778284183790118418111
+a[12, 7] = -2.679019236219849057687906597489223155566
+a[12, 8] = .518815663924157511565311164615012522024
+a[12, 9] = 1.365353187603341710683633635235238678626
+a[12, 10] = 5.885091088503946585721274891680604830712
+a[12, 11] = 2.802808786272062889819965117517532194812
+
+a[13, 0] = .4185367457753471441471025246471931649633
+a[13, 1] = 0.
+a[13, 2] = 0.
+a[13, 3] = 0.
+a[13, 4] = 0.
+a[13, 5] = 6.724547581906459363100870806514855026676
+a[13, 6] = -.425444280164611790606983409697113064616
+a[13, 7] = 3.343279153001265577811816947557982637749
+a[13, 8] = .617081663117537759528421117507709784737
+a[13, 9] = -.929966123939932833937749523988800852013
+a[13, 10] = -6.099948804751010722472962837945508844846
+a[13, 11] = -3.002206187889399044804158084895173690015
+a[13, 12] = .2553202529443445472336424602988558373637
+
+a[14, 0] = -.779374086122884664644623040843840506343
+a[14, 1] = 0.
+a[14, 2] = 0.
+a[14, 3] = 0.
+a[14, 4] = 0.
+a[14, 5] = -13.93734253810777678786523664804936051203
+a[14, 6] = 1.252048853379357320949735183924200895136
+a[14, 7] = -14.69150040801686878191527989293072091588
+a[14, 8] = -.494705058533141685655191992136962873577
+a[14, 9] = 2.242974909146236657906984549543692874755
+a[14, 10] = 13.36789380382864375813864978592679139881
+a[14, 11] = 14.39665048665068644512236935340272139005
+a[14, 12] = -.7975813331776800379127866056663258667437
+a[14, 13] = .4409353709534277758753793068298041158235
+
+a[15, 0] = 2.058051337466886442151242368989994043993
+a[15, 1] = 0.
+a[15, 2] = 0.
+a[15, 3] = 0.
+a[15, 4] = 0.
+a[15, 5] = 22.35793772796803295519317565842520212899
+a[15, 6] = .90949810997556332745009198137971890783
+a[15, 7] = 35.89110098240264104710550686568482456493
+a[15, 8] = -3.442515027624453437985000403608480262211
+a[15, 9] = -4.865481358036368826566013387928704014496
+a[15, 10] = -18.90980381354342625688427480879773032857
+a[15, 11] = -34.26354448030451782929251177395134170515
+a[15, 12] = 1.264756521695642578827783499806516664686
+a[15, 13] = 0.
+a[15, 14] = 0.
+
+b[0] = .1461197685842315252051541915018784713459e-1
+b[1] = 0.
+b[2] = 0.
+b[3] = 0.
+b[4] = 0.
+b[5] = 0.
+b[6] = 0.
+b[7] = -.3915211862331339089410228267288242030810
+b[8] = .2310932500289506415909675644868993669908
+b[9] = .1274766769992852382560589467488989175618
+b[10] = .2246434176204157731566981937082069688984
+b[11] = .5684352689748512932705226972873692126743
+b[12] = .5825871557215827200814768021863420902155e-1
+b[13] = .1364317403482215641609022744494239843327
+b[14] = .3057013983082797397721005067920369646664e-1
+b[15] = 0.
+
+bh[0] = .1996996514886773085518508418098868756464e-1
+bh[1] = 0.
+bh[2] = 0.
+bh[3] = 0.
+bh[4] = 0.
+bh[5] = 0.
+bh[6] = 0.
+bh[7] = 2.191499304949330054530747099310837524864
+bh[8] = .8857071848208438030833722031786358862953e-1
+bh[9] = .1140560234865965622484956605091432032674
+bh[10] = .2533163805345107065564577734569651977347
+bh[11] = -2.056564386240941011158999594595981300493
+bh[12] = .3408096799013119935160094894224543812830
+bh[13] = 0.
+bh[14] = 0.
+bh[15] = .4834231373823958314376726739772871714902e-1
+
+for i in range(16):
+    e[i] = b[i] - bh[i]
+
+c[16] = 1.0
+
+a[16, 0] = .1461197685842315252051541915018784713459e-1
+a[16, 1] = 0.
+a[16, 2] = 0.
+a[16, 3] = 0.
+a[16, 4] = 0.
+a[16, 5] = 0.
+a[16, 6] = 0.
+a[16, 7] = -.3915211862331339089410228267288242030810
+a[16, 8] = .2310932500289506415909675644868993669908
+a[16, 9] = .1274766769992852382560589467488989175618
+a[16, 10] = .2246434176204157731566981937082069688984
+a[16, 11] = .5684352689748512932705226972873692126743
+a[16, 12] = .5825871557215827200814768021863420902155e-1
+a[16, 13] = .1364317403482215641609022744494239843327
+a[16, 14] = .3057013983082797397721005067920369646664e-1
+a[16, 15] = 0.
+
+c[17] = .7404185470631561083004100761798676215811
+
+a[17, 0] = .1549973668189559302279946863304789372788e-1
+a[17, 1] = 0.
+a[17, 2] = 0.
+a[17, 3] = 0.
+a[17, 4] = 0.
+a[17, 5] = 0.
+a[17, 6] = 0.
+a[17, 7] = .3355153219059635054403439303177105512242
+a[17, 8] = .2003613944191860651552622660712101217322
+a[17, 9] = .1252060659283549312946162355194540994211
+a[17, 10] = .2298676393184206750544046308957155868736
+a[17, 11] = -.2020250653476181447824906889122391003637
+a[17, 12] = .5917103230665456601422111997583025339897e-1
+a[17, 13] = -.2651834783047638681693835956996437528251e-1
+a[17, 14] = -.2384094602130971415278110567256446033405e-1
+a[17, 15] = 0.
+a[17, 16] = .2718171570208501807097257892166705118335e-1
+
+c[18] = .888
+
+a[18, 0] = .1302453943114338366054520296881099431474e-1
+a[18, 1] = 0.
+a[18, 2] = 0.
+a[18, 3] = 0.
+a[18, 4] = 0.
+a[18, 5] = 0.
+a[18, 6] = 0.
+a[18, 7] = -.7452850902413112085299330666038981625179
+a[18, 8] = .2643867896429300961465132150322749722129
+a[18, 9] = .1313961758372753932588328082078842388890
+a[18, 10] = .2167253815122927263092467187957410643315
+a[18, 11] = .8734117564076052559016338094938888451419
+a[18, 12] = .1185905643935776688228545787724340848142e-1
+a[18, 13] = .5876002941689550612992712203494447529933e-1
+a[18, 14] = .3266518630202087866399279690939423159022e-2
+a[18, 15] = 0.
+a[18, 16] = -.8959308648417929824525368306101792182274e-2
+a[18, 17] = .6941415157202692219907482080827253287034e-1
+
+c[19] = .696
+
+a[19, 0] = .1397089996925942721283716334050740168797e-1
+a[19, 1] = 0.
+a[19, 2] = 0.
+a[19, 3] = 0.
+a[19, 4] = 0.
+a[19, 5] = 0.
+a[19, 6] = 0.
+a[19, 7] = -.4665765335957674596054673402956853940520
+a[19, 8] = .2416372787216257077935214889875485248580
+a[19, 9] = .1290363341345674735721677437066933999929
+a[19, 10] = .2216700671735105311080225734522323922813
+a[19, 11] = .6257275123364644931771253383573999863003
+a[19, 12] = .4355312415679284117869124964829805160429e-1
+a[19, 13] = .1011962491667290833450024852274278874501
+a[19, 14] = .1808582254679721049279369742685497400353e-1
+a[19, 15] = 0.
+a[19, 16] = -.2079875587689169691156509689282083267654e-1
+a[19, 17] = -.9022232517086218976198252891464664868640e-1
+a[19, 18] = -.1212796735622254216011467740438097427634
+
+c[20] = .487
+
+a[20, 0] = .1604638888318112738641232352800290501904e-1
+a[20, 1] = 0.
+a[20, 2] = 0.
+a[20, 3] = 0.
+a[20, 4] = 0.
+a[20, 5] = 0.
+a[20, 6] = 0.
+a[20, 7] = .9517712399458336651642257453589397190702e-1
+a[20, 8] = .1359187264655317806136927180199100622471
+a[20, 9] = .1237765280959854006935081364365637515893
+a[20, 10] = .2335656264102966047058755123098072346246
+a[20, 11] = -.9051508172625873314662090873741762206189e-1
+a[20, 12] = -.2537574270006131028513276914038326155331e-1
+a[20, 13] = -.1359631696887162048002744757083947500478
+a[20, 14] = -.4679214284145113075088049469061349990847e-1
+a[20, 15] = 0.
+a[20, 16] = .5177958859391748239949773879090325427473e-1
+a[20, 17] = .9672595677476773313884172931875718705561e-1
+a[20, 18] = .1477312690340742769720989417101989769314
+a[20, 19] = -.1150750712958503934434410263732282100773
+c[21] = .25e-1
+
+a[21, 0] = .1802918623893620731908165792176564180038e-1
+a[21, 1] = 0.
+a[21, 2] = 0.
+a[21, 3] = 0.
+a[21, 4] = 0.
+a[21, 5] = 0.
+a[21, 6] = 0.
+a[21, 7] = .6983601042028873702545973390560096201728e-1
+a[21, 8] = -.2541247660791663512384395986842781657182e-1
+a[21, 9] = .8487827035463274491721441398893680307535e-2
+a[21, 10] = -.2427525516089801645451101966852425715128e-2
+a[21, 11] = -.1047839752893819879012607694745789515746
+a[21, 12] = -.1473147795248041942353840372690095884761e-1
+a[21, 13] = -.3916338390816177165706892282751065537530e-1
+a[21, 14] = -.1005657343293959419073236542225421561652e-1
+a[21, 15] = 0.
+a[21, 16] = .1102510392204834322538452331445716455061e-1
+a[21, 17] = .5092830749095398308703438556315975226108e-2
+a[21, 18] = .4759715599420644505591133410826632557391e-1
+a[21, 19] = .3386307003288382751110965442296681690349e-1
+a[21, 20] = .2764422831404797700452373965825845732168e-1
+
+c[22] = .15
+
+a[22, 0] = .1677431640522778042988664067637191163626e-1
+a[22, 1] = 0.
+a[22, 2] = 0.
+a[22, 3] = 0.
+a[22, 4] = 0.
+a[22, 5] = 0.
+a[22, 6] = 0.
+a[22, 7] = .6220437408820475326702539861577894278533
+a[22, 8] = -.2060859809768841878234097076241307428139
+a[22, 9] = .1156394989766058889629372195583391792474
+a[22, 10] = .2664101793378358946544219293685167025971e-1
+a[22, 11] = -.9376810793418770527505892794460093668860
+a[22, 12] = -.1367806466702160302637074581619101741312
+a[22, 13] = -.3678480995268296672182605288991379118419
+a[22, 14] = -.9547871314402478902820445838193201497337e-1
+a[22, 15] = 0.
+a[22, 16] = .1013492018422369748729008873270013785313
+a[22, 17] = -.8911323084568593396468400926074881389560e-1
+a[22, 18] = .4664140988974760478895528270623735057521
+a[22, 19] = .4502736292354579812232681662308722738519
+a[22, 20] = .1838522463326818655346135218242696774099
+a[22, 21] = 0.
+
+c[23] = .32
+
+a[23, 0] = .1071149731491444187554380927165768658192e-1
+a[23, 1] = 0.
+a[23, 2] = 0.
+a[23, 3] = 0.
+a[23, 4] = 0.
+a[23, 5] = 0.
+a[23, 6] = 0.
+a[23, 7] = -.7094336118221108191937165464264324417735e-1
+a[23, 8] = .1002164900340091596740582334112699697590
+a[23, 9] = .1383453980468025108839271214703390659581
+a[23, 10] = .1796330633578163411338104055485109917477
+a[23, 11] = .9048246545576180974879274948815422276563e-1
+a[23, 12] = -.5460662294523338383345981122023862069115e-2
+a[23, 13] = -.3000457905119619782973021046143166498567e-1
+a[23, 14] = -.1145192026962799093665613252151017277867e-1
+a[23, 15] = 0.
+a[23, 16] = .1003394686109385076849515422360600302176e-1
+a[23, 17] = -.9506485282809046129031027932806241113157e-1
+a[23, 18] = .4853358804093591445756711642658478691640e-1
+a[23, 19] = .8013325919783924638483373011297347396327e-1
+a[23, 20] = -.1251643326835242045676140618774248455713
+a[23, 21] = 0.
+a[23, 22] = 0.
+
+c[24] = .78
+
+a[24, 0] = .1410172088869221367153586187761994182069e-1
+a[24, 1] = 0.
+a[24, 2] = 0.
+a[24, 3] = 0.
+a[24, 4] = 0.
+a[24, 5] = 0.
+a[24, 6] = 0.
+a[24, 7] = -.3713379753704491105936205420001801316029
+a[24, 8] = .2231265548117180273161442520179150684520
+a[24, 9] = .1287005345918120122888629169443916280865
+a[24, 10] = .2224600659675494761192249831098918110654
+a[24, 11] = .5382853042550701952740528638168708946100
+a[24, 12] = .5417202616988763101781128062036252796548e-1
+a[24, 13] = .1256968791308743925752109039299467082975
+a[24, 14] = .2784492789002054061504430663197543089132e-1
+a[24, 15] = 0.
+a[24, 16] = -.3077409246205059733390460511525401688205e-1
+a[24, 17] = .8569805293689777608077303071761466118035e-2
+a[24, 18] = -.1535174690587044615794997685221990516897
+a[24, 19] = -.2179957030548196497189489878038029238243e-1
+a[24, 20] = .1447128819737186799295514239727801525027e-1
+a[24, 21] = 0.
+a[24, 22] = 0.
+a[24, 23] = 0.
+
+c[25] = .96
+
+a[25, 0] = .1424600411735646609296566581447532773183e-1
+a[25, 1] = 0.
+a[25, 2] = 0.
+a[25, 3] = 0.
+a[25, 4] = 0.
+a[25, 5] = 0.
+a[25, 6] = 0.
+a[25, 7] = -.3767107393295407091303982522049390741260
+a[25, 8] = .2252399780730421480874737297000189000070
+a[25, 9] = .1283603076292529988314451246143633426068
+a[25, 10] = .2230238705261692544876826347415151339678
+a[25, 11] = .5463127827750747224899202176094949607118
+a[25, 12] = .5526190791375779994553849469706124289752e-1
+a[25, 13] = .1285613508749982456581494397108686240388
+a[25, 14] = .2857250681296406482698934635829147899039e-1
+a[25, 15] = 0.
+a[25, 16] = -.2398761886357108720930416967644499057175e-1
+a[25, 17] = .5556224458910509454379297181908734648749e-1
+a[25, 18] = -.1740675650762838674257930398070760254668e-1
+a[25, 19] = -.3815462365996979065575121886854199471011e-1
+a[25, 20] = .1111878504898917877407531966545730451506e-1
+a[25, 21] = 0.
+a[25, 22] = 0.
+a[25, 23] = 0.
+a[25, 24] = 0.
+
+bi[0, 0] = 1.
+bi[0, 1] = -28.33048870061739823290767301658881994700
+bi[0, 2] = 257.6535452078577977252092979905248156497
+bi[0, 3] = -1152.154455743457311528752964691951881858
+bi[0, 4] = 2909.390878345408890936564599116550031880
+bi[0, 5] = -4355.005172868188498048946108887283528629
+bi[0, 6] = 3834.083497036262189455855371796461857871
+bi[0, 7] = -1835.419052683407081215583427992189311730
+bi[0, 8] = 368.7958613829998340610814211036270246107
+
+bi[1, 0] = 0.
+bi[1, 1] = 0.
+bi[1, 2] = 0.
+bi[1, 3] = 0.
+bi[1, 4] = 0.
+bi[1, 5] = 0.
+bi[1, 6] = 0.
+bi[1, 7] = 0.
+bi[1, 8] = 0.
+
+bi[2, 0] = 0.
+bi[2, 1] = 0.
+bi[2, 2] = 0.
+bi[2, 3] = 0.
+bi[2, 4] = 0.
+bi[2, 5] = 0.
+bi[2, 6] = 0.
+bi[2, 7] = 0.
+bi[2, 8] = 0.
+
+bi[3, 0] = 0.
+bi[3, 1] = 0.
+bi[3, 2] = 0.
+bi[3, 3] = 0.
+bi[3, 4] = 0.
+bi[3, 5] = 0.
+bi[3, 6] = 0.
+bi[3, 7] = 0.
+bi[3, 8] = 0.
+
+bi[4, 0] = 0.
+bi[4, 1] = 0.
+bi[4, 2] = 0.
+bi[4, 3] = 0.
+bi[4, 4] = 0.
+bi[4, 5] = 0.
+bi[4, 6] = 0.
+bi[4, 7] = 0.
+bi[4, 8] = 0.
+
+bi[5, 0] = 0.
+bi[5, 1] = 0.
+bi[5, 2] = 0.
+bi[5, 3] = 0.
+bi[5, 4] = 0.
+bi[5, 5] = 0.
+bi[5, 6] = 0.
+bi[5, 7] = 0.
+bi[5, 8] = 0.
+
+bi[6, 0] = 0.
+bi[6, 1] = 0.
+bi[6, 2] = 0.
+bi[6, 3] = 0.
+bi[6, 4] = 0.
+bi[6, 5] = 0.
+bi[6, 6] = 0.
+bi[6, 7] = 0.
+bi[6, 8] = 0.
+
+bi[7, 0] = 0.
+bi[7, 1] = 2.649656243770091212685381903551424676261
+bi[7, 2] = -96.30312807816005963630382777245983513008
+bi[7, 3] = 869.3095462492795755338599928089438369769
+bi[7, 4] = -3395.688567551074115525201961265641584358
+bi[7, 5] = 6796.933987158715680563278170147156885480
+bi[7, 6] = -7340.848417712071304684606060804637321789
+bi[7, 7] = 4082.848896992365666259441580054990759905
+bi[7, 8] = -919.2934944890586676320942978986329899642
+
+bi[8, 0] = 0.
+bi[8, 1] = -1.563945181928732780647121505551017046606
+bi[8, 2] = 56.84239739272860000194549791973820565214
+bi[8, 3] = -513.1052300304284642178552372517916694426
+bi[8, 4] = 2004.286702110323162741493515173880535381
+bi[8, 5] = -4011.853305913929339500285683507736138334
+bi[8, 6] = 4332.895839278586189971336003691596594090
+bi[8, 7] = -2409.879347937144606091337260195738587773
+bi[8, 8] = 542.6079835318221405169412532400889768401
+
+bi[9, 0] = 0.
+bi[9, 1] = -.8627103334967223830653368770735555216700
+bi[9, 2] = 31.35565375185173442495465167501846267906
+bi[9, 3] = -283.0413682227354209126847112083546012674
+bi[9, 4] = 1105.613463426006937052739159664962261462
+bi[9, 5] = -2213.036200678452629288185991597653042989
+bi[9, 6] = 2390.131097754120588994847482867886207858
+bi[9, 7] = -1329.348266146873716496636094950745123424
+bi[9, 8] = 299.3158071265785138462868993727082901209
+
+bi[10, 0] = 0.
+bi[10, 1] = -1.520295337901214839055193576160469820911
+bi[10, 2] = 55.25592121120227100440616045452813504748
+bi[10, 3] = -498.7844190970740738969945498750124435385
+bi[10, 4] = 1948.346888525776056658403461666308795237
+bi[10, 5] = -3899.882136407551390287649940376076923682
+bi[10, 6] = 4211.964345158858030803618536151121927765
+bi[10, 7] = -2342.619408856117128087568672414857706561
+bi[10, 8] = 527.4637482204278644179968961638568925209
+
+bi[11, 0] = 0.
+bi[11, 1] = -3.846938844125523400516071820264700141179
+bi[11, 2] = 139.8189840986840520353362018994734906611
+bi[11, 3] = -1262.118687621600386514715930156791825893
+bi[11, 4] = 4930.075848057311658057235318456802793199
+bi[11, 5] = -9868.219486069539059368988308801366826185
+bi[11, 6] = 10657.90892434886730229746304583865145121
+bi[11, 7] = -5927.738759872814112912292792695856187255
+bi[11, 8] = 1334.688551172190921099749059976639173619
+
+bi[12, 0] = 0.
+bi[12, 1] = -.3942713061200141454309326713125653612517
+bi[12, 2] = 14.32999476067649707020689155180345562459
+bi[12, 3] = -129.3540665994558117853022852051786116929
+bi[12, 4] = 505.2816077002517600897861155496606850457
+bi[12, 5] = -1011.390080139433268878243655218566636574
+bi[12, 6] = 1092.325051781891697669369143688906543465
+bi[12, 7] = -607.5317019302810290917918493845279272648
+bi[12, 8] = 136.7917244480423273434147193694336909663
+
+bi[13, 0] = 0.
+bi[13, 1] = -.9233145622082101394378429409444333268499
+bi[13, 2] = 33.55834582309798808260613735851232640640
+bi[13, 3] = -302.9246397549735936661321348695774835448
+bi[13, 4] = 1183.281306967867553342903125095128753568
+bi[13, 5] = -2368.498986790111516106072390247333149007
+bi[13, 6] = 2558.034559755808027369106332027405169828
+bi[13, 7] = -1422.733175577880214903071122439856598476
+bi[13, 8] = 320.3423358787481875842587982911148385364
+
+bi[14, 0] = 0.
+bi[14, 1] = -.2068862802930053801253649628830330891017
+bi[14, 2] = 7.519388975651662772174695012120581518594
+bi[14, 3] = -67.87605708082904058354114755731111898667
+bi[14, 4] = 265.1367996984150421661637988925923843021
+bi[14, 5] = -530.7074807559025368587558119659212235622
+bi[14, 6] = 573.1765495641490277116961329189087439579
+bi[14, 7] = -318.7905688834868978004500126002971837241
+bi[14, 8] = 71.77882490212657594681492031347005327988
+
+bi[15, 0] = 0.
+bi[15, 1] = 0.
+bi[15, 2] = 0.
+bi[15, 3] = 0.
+bi[15, 4] = 0.
+bi[15, 5] = 0.
+bi[15, 6] = 0.
+bi[15, 7] = 0.
+bi[15, 8] = 0.
+
+bi[16, 0] = 0.
+bi[16, 1] = -.4472441906744099441704338175964823026105
+bi[16, 2] = 16.44684676010503791623763886833381020592
+bi[16, 3] = -154.4086105921295528355180056633078150675
+bi[16, 4] = 641.8986298540248497333509289273669726482
+bi[16, 5] = -1391.939225687982391028602609567895699003
+bi[16, 6] = 1643.890568302952013019278202625162156841
+bi[16, 7] = -1004.065297223317845596795060426393517046
+bi[16, 8] = 248.6243327770222987362193390543305737239
+
+bi[17, 0] = 0.
+bi[17, 1] = -.1507876007899797948720901584434839156279
+bi[17, 2] = 5.527328824824632235316362126620825363280
+bi[17, 3] = -51.33833743084618751433903968701557585387
+bi[17, 4] = 209.6022002703280347991393999433060881829
+bi[17, 5] = -442.7692650421825928714839983614217797969
+bi[17, 6] = 505.0579312588052893780948070449787925777
+bi[17, 7] = -295.6336410615619366143935619944592839974
+bi[17, 8] = 69.70457078142274038253812108643441743987
+
+bi[18, 0] = 0.
+bi[18, 1] = -.6413652207435296452288504944964177537185
+bi[18, 2] = 23.51013248624684600263471193689787394701
+bi[18, 3] = -218.3642683246972281497485359238725613162
+bi[18, 4] = 891.5292818535365634586829868055833114383
+bi[18, 5] = -1883.290177206007885518558760085145850658
+bi[18, 6] = 2148.230954488399755970660772306573864434
+bi[18, 7] = -1257.458401521712336970840850120592935471
+bi[18, 8] = 296.4838434449778148523985255750527153802
+
+bi[19, 0] = 0.
+bi[19, 1] = 1.810729313444845732964058528284532356045
+bi[19, 2] = -66.37479657295337371220255196726289169374
+bi[19, 3] = 616.4952025401106511929691356878863855003
+bi[19, 4] = -2517.003030777322559684753470471663859295
+bi[19, 5] = 5316.984175781033401491488704359579721604
+bi[19, 6] = -6064.976140789574108556866601189158423779
+bi[19, 7] = 3550.109538888391317555902194852386816092
+bi[19, 8] = -837.0456783831301740195014698000522807852
+
+bi[20, 0] = 0.
+bi[20, 1] = .5176008760353717918864555990277480363987e-1
+bi[20, 2] = -1.897337862580348756406065418550014243949
+bi[20, 3] = 17.62264820793629244181715147639285955422
+bi[20, 4] = -71.94907400242465946110661282550878163878
+bi[20, 5] = 151.9871383765666045085018751235590550206
+bi[20, 6] = -173.3686498747860565970136435029707518663
+bi[20, 7] = 101.4806461521468075879782291473158292931
+bi[20, 8] = -23.92713108446217690295957956014097092250
+
+bi[21, 0] = 0.
+bi[21, 1] = 31.32178255668799909977422939838912846070
+bi[21, 2] = -355.6570858339106059687054319211280026146
+bi[21, 3] = 1752.685282489515979253875884672206842255
+bi[21, 4] = -4708.092293138363367969732154806019707156
+bi[21, 5] = 7370.900776193488713149861391844801840850
+bi[21, 6] = -6716.504964764565347011489385051202629762
+bi[21, 7] = 3303.940398161185772296756776169088470785
+bi[21, 8] = -678.5938956640391428503413103061359428182
+
+bi[22, 0] = 0.
+bi[22, 1] = -2.719607334185924760747802644504744092917
+bi[22, 2] = 86.64045615858264001154848875638486632034
+bi[22, 3] = -454.1926030939030807863651114984001402596
+bi[22, 4] = 1014.749221100543425314268817989377200147
+bi[22, 5] = -1133.583456714543865890388885909333783663
+bi[22, 6] = 610.4671827718666569168001429679645990946
+bi[22, 7] = -109.0233499449543802317396567002119357593
+bi[22, 8] = -12.33784294340547057337599296127606178639
+
+bi[23, 0] = 0.
+bi[23, 1] = 3.177214801432923432265738869490200556403
+bi[23, 2] = -113.8098697715142983214434051918276259885
+bi[23, 3] = 978.0935981825675014833003847211971070224
+bi[23, 4] = -3575.129377623670076451027372711378100786
+bi[23, 5] = 6764.361519838450570830405988615992045681
+bi[23, 6] = -6987.161043852012362644872233028628887679
+bi[23, 7] = 3751.905762789571137088934326513342858381
+bi[23, 8] = -821.4378043648253954175634277881875971878
+
+bi[24, 0] = 0.
+bi[24, 1] = .8772843083465530069477626269697233842708
+bi[24, 2] = -31.51810423988375104361582759389916060143
+bi[24, 3] = 273.1229151353221133842213845530391043248
+bi[24, 4] = -993.2198643101781966584366870874238565290
+bi[24, 5] = 1787.888078312663987193988385659681964836
+bi[24, 6] = -1677.394835799640950953367739332661886275
+bi[24, 7] = 781.3579535062687952504707744453846824540
+bi[24, 8] = -141.1134269128985501802080532710905715931
+
+bi[25, 0] = 0.
+bi[25, 1] = 1.719427581798715782378897599231938082126
+bi[25, 2] = -62.89867309250732184389962568482931880335
+bi[25, 3] = 580.3335507873980391019057196688995930872
+bi[25, 4] = -2348.110620506760958600472968113883922730
+bi[25, 5] = 4921.119298612906015908637628774963068611
+bi[25, 6] = -5597.912448707916639109910311016358007839
+bi[25, 7] = 3288.597775149621789973016480733216881572
+bi[25, 8] = -782.8483098245396412116558219612402319811
+
+vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
diff --git a/qutip/solver/krylovsolve.py b/qutip/solver/krylovsolve.py
index 99fa78b229..4d14262ca5 100644
--- a/qutip/solver/krylovsolve.py
+++ b/qutip/solver/krylovsolve.py
@@ -1,102 +1,102 @@
-__all__ = ['krylovsolve']
-
-from .. import QobjEvo
-from .sesolve import SESolver
-
-
-def krylovsolve(
-    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
-):
-    """
-    Schrodinger equation evolution of a state vector for time independent
-    Hamiltonians using Krylov method.
-
-    Evolve the state vector ("psi0") finding an approximation for the time
-    evolution operator of Hamiltonian ("H") by obtaining the projection of
-    the time evolution operator on a set of small dimensional Krylov
-    subspaces (m << dim(H)).
-
-    The output is either the state vector or unitary matrix at arbitrary points
-    in time (`tlist`), or the expectation values of the supplied operators
-    (`e_ops`). If e_ops is a callback function, it is invoked for each
-    time in `tlist` with time and the state as arguments, and the function
-    does not use any return values. e_ops cannot be used in conjunction
-    with solving the Schrodinger operator equation
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    psi0 : :class:`qutip.qobj`
-        initial state vector (ket)
-        or initial unitary operator `psi0 = U`
-
-    tlist : *list* / *array*
-        list of times for :math:`t`.
-
-    krylov_dim: int
-        Dimension of Krylov approximation subspaces used for the time
-        evolution approximation.
-
-    e_ops : :class:`qutip.qobj`, callable, or list.
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation.
-
-    args : None / *dictionary*
-        dictionary of parameters for time-dependent Hamiltonians
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool, [False]
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, [None]
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool, [True]
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict, [{"chunk_size": 10}]
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - atol: float [1e-7]
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps : int [100]
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - min_step, max_step : float, [1e-5, 1e5]
-          Miniumum and maximum lenght of one internal step.
-        - always_compute_step: bool [False]
-          If True, the step lenght is computed each time a new Krylov
-          subspace is computed. Otherwise it is computed only once when
-          creating the integrator.
-        - sub_system_tol: float, [1e-7]
-          Tolerance to detect an happy breakdown. An happy breakdown happens
-          when the initial ket is in a subspace of the Hamiltonian smaller
-          than ``krylov_dim``.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        a *list of array* `result.expect` of expectation values for the times
-        specified by `tlist`, and/or a *list* `result.states` of state vectors
-        or density matrices corresponding to the times in `tlist` [if `e_ops`
-        is an empty list of `store_states=True` in options].
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    options = options or {}
-    options["method"] = "krylov"
-    options["krylov_dim"] = krylov_dim
-    solver = SESolver(H, options=options)
-    return solver.run(psi0, tlist, e_ops=e_ops)
+__all__ = ['krylovsolve']
+
+from .. import QobjEvo
+from .sesolve import SESolver
+
+
+def krylovsolve(
+    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
+):
+    """
+    Schrodinger equation evolution of a state vector for time independent
+    Hamiltonians using Krylov method.
+
+    Evolve the state vector ("psi0") finding an approximation for the time
+    evolution operator of Hamiltonian ("H") by obtaining the projection of
+    the time evolution operator on a set of small dimensional Krylov
+    subspaces (m << dim(H)).
+
+    The output is either the state vector or unitary matrix at arbitrary points
+    in time (`tlist`), or the expectation values of the supplied operators
+    (`e_ops`). If e_ops is a callback function, it is invoked for each
+    time in `tlist` with time and the state as arguments, and the function
+    does not use any return values. e_ops cannot be used in conjunction
+    with solving the Schrodinger operator equation
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    psi0 : :class:`qutip.qobj`
+        initial state vector (ket)
+        or initial unitary operator `psi0 = U`
+
+    tlist : *list* / *array*
+        list of times for :math:`t`.
+
+    krylov_dim: int
+        Dimension of Krylov approximation subspaces used for the time
+        evolution approximation.
+
+    e_ops : :class:`qutip.qobj`, callable, or list.
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
+
+    args : None / *dictionary*
+        dictionary of parameters for time-dependent Hamiltonians
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool, [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, [None]
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool, [True]
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - atol: float [1e-7]
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps : int [100]
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - min_step, max_step : float, [1e-5, 1e5]
+          Miniumum and maximum lenght of one internal step.
+        - always_compute_step: bool [False]
+          If True, the step lenght is computed each time a new Krylov
+          subspace is computed. Otherwise it is computed only once when
+          creating the integrator.
+        - sub_system_tol: float, [1e-7]
+          Tolerance to detect an happy breakdown. An happy breakdown happens
+          when the initial ket is in a subspace of the Hamiltonian smaller
+          than ``krylov_dim``.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        a *list of array* `result.expect` of expectation values for the times
+        specified by `tlist`, and/or a *list* `result.states` of state vectors
+        or density matrices corresponding to the times in `tlist` [if `e_ops`
+        is an empty list of `store_states=True` in options].
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    options = options or {}
+    options["method"] = "krylov"
+    options["krylov_dim"] = krylov_dim
+    solver = SESolver(H, options=options)
+    return solver.run(psi0, tlist, e_ops=e_ops)
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index bc3369b979..f1a55bf216 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,527 +1,527 @@
-__all__ = ['mcsolve', "MCSolver"]
-
-import warnings
-
-import numpy as np
-from copy import copy
-from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
-from .multitraj import MultiTrajSolver
-from .solver_base import Solver
-from .result import McResult, Result
-from .mesolve import mesolve, MESolver
-import qutip.core.data as _data
-from time import time
-
-
-def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
-            args=None, options=None, seeds=None, target_tol=None, timeout=None):
-    r"""
-    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
-    given Hamiltonian and sets of collapse operators. Options for the
-    underlying ODE solver are given by the Options class.
-
-    Parameters
-    ----------
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
-        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
-        ``H`` can also be a superoperator (liouvillian) if some collapse
-        operators are to be treated deterministically.
-
-    state : :class:`qutip.Qobj`
-        Initial state vector.
-
-    tlist : array_like
-        Times at which results are recorded.
-
-    c_ops : list
-        A ``list`` of collapse operators in any input type that QobjEvo accepts
-        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
-        even if ``H`` is a superoperator. If none are given, the solver will
-        defer to ``sesolve`` or ``mesolve``.
-
-    e_ops : list, [optional]
-        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
-        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
-        are given, the solver will default to save the states.
-
-    ntraj : int
-        Maximum number of trajectories to run. Can be cut short if a time limit
-        is passed with the ``timeout`` keyword or if the target tolerance is
-        reached, see ``target_tol``.
-
-    args : None / dict
-        Arguments for time-dependent Hamiltonian and collapse operator terms.
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool [False]
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, NoneType, [None]
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict, [{"chunk_size": 10}]
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
-          Which differential equation integration method to use.
-        - keep_runs_results : bool, [False]
-          Whether to store results from all trajectories or just store the
-          averages.
-        - map : str {"serial", "parallel", "loky"}, ["serial"]
-          How to run the trajectories. "parallel" uses concurent module to run
-          in parallel while "loky" use the module of the same name to do so.
-        - job_timeout : NoneType, int, [None]
-          Maximum time to compute one trajectory.
-        - num_cpus : NoneType, int, [None]
-          Number of cpus to use when running in parallel. ``None`` detect the
-          number of available cpus.
-        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
-          Parameters used to find the collapse location. ``norm_t_tol`` and
-          ``norm_tol`` are the tolerance in time and norm respectively.
-          An error will be raised if the collapse could not be found within
-          ``norm_steps`` tries.
-        - mc_corr_eps : float, [1e-10]
-          Small number used to detect non-physical collapse caused by numerical
-          imprecision.
-        - atol, rtol : float, [1e-8, 1e-6]
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps : int [2500]
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, [0]
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-    seeds : int, SeedSequence, list, [optional]
-        Seed for the random number generator. It can be a single seed used to
-        spawn seeds for each trajectory or a list of seeds, one for each
-        trajectory. Seeds are saved in the result and they can be reused with::
-
-            seeds=prev_result.seeds
-
-    target_tol : {float, tuple, list}, optional
-        Target tolerance of the evolution. The evolution will compute
-        trajectories until the error on the expectation values is lower than
-        this tolerance. The maximum number of trajectories employed is
-        given by ``ntraj``. The error is computed using jackknife resampling.
-        ``target_tol`` can be an absolute tolerance or a pair of absolute and
-        relative tolerance, in that order. Lastly, it can be a list of pairs of
-        (atol, rtol) for each e_ops.
-
-    timeout : float [optional]
-        Maximum time for the evolution in second. When reached, no more
-        trajectories will be computed. Overwrite the option of the same name.
-
-    Returns
-    -------
-    results : :class:`qutip.solver.Result`
-        Object storing all results from the simulation. Which results is saved
-        depends on the presence of ``e_ops`` and the options used. ``collapse``
-        and ``photocurrent`` is available to Monte Carlo simulation results.
-
-    .. note:
-        The simulation will end when the first end condition is reached between
-        ``ntraj``, ``timeout`` and ``target_tol``.
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    if not isinstance(c_ops, (list, tuple)):
-        c_ops = [c_ops]
-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-
-    if len(c_ops) == 0:
-        if options is None:
-            options = {}
-        options = {
-            key: options[key]
-            for key in options
-            if key in MESolver.solver_options
-        }
-        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
-                       options=options)
-
-    if isinstance(ntraj, (list, tuple)):
-        raise TypeError(
-            "ntraj must be an integer. "
-            "A list of numbers is not longer supported."
-        )
-
-    mc = MCSolver(H, c_ops, options=options)
-    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
-                    seed=seeds, target_tol=target_tol, timeout=timeout)
-    return result
-
-
-class MCIntegrator:
-    """
-    Integrator like object for mcsolve trajectory.
-    """
-    name = "mcsolve"
-
-    def __init__(self, integrator, c_ops, n_ops, options=None):
-        self._integrator = integrator
-        self._c_ops = c_ops
-        self._n_ops = n_ops
-        self.options = options
-        self._generator = None
-        self.method = f"{self.name} {self._integrator.method}"
-        self._is_set = False
-        self.issuper = c_ops[0].issuper
-
-    def set_state(self, t, state0, generator):
-        """
-        Set the state of the ODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        generator : numpy.random.generator
-            Random number generator.
-        """
-        self.collapses = []
-        self._generator = generator
-        self.target_norm = self._generator.random()
-        self._integrator.set_state(t, state0)
-        self._is_set = True
-
-    def get_state(self, copy=True):
-        return *self._integrator.get_state(copy), self._generator
-
-    def integrate(self, t, copy=False):
-        t_old, y_old = self._integrator.get_state(copy=False)
-        norm_old = self._prob_func(y_old)
-        while t_old < t:
-            t_step, state = self._integrator.mcstep(t, copy=False)
-            norm = self._prob_func(state)
-            if norm <= self.target_norm:
-                t_col, state = self._find_collapse_time(norm_old, norm,
-                                                        t_old, t_step)
-                self._do_collapse(t_col, state)
-                t_old, y_old = self._integrator.get_state(copy=False)
-                norm_old = 1.
-            else:
-                t_old, y_old = t_step, state
-                norm_old = norm
-
-        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
-
-    def run(self, tlist):
-        for t in tlist[1:]:
-            yield self.integrate(t, False)
-
-    def reset(self, hard=False):
-        self._integrator.reset(hard)
-
-    def _prob_func(self, state):
-        if self.issuper:
-            return _data.trace_oper_ket(state).real
-        return _data.norm.l2(state)**2
-
-    def _norm_func(self, state):
-        if self.issuper:
-            return _data.trace_oper_ket(state).real
-        return _data.norm.l2(state)
-
-    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
-        """Find the time of the collapse and state just before it."""
-        tries = 0
-        while tries < self.options['norm_steps']:
-            tries += 1
-            if (t_final - t_prev) < self.options['norm_t_tol']:
-                t_guess = t_final
-                _, state = self._integrator.get_state()
-                break
-            t_guess = (
-                t_prev
-                + ((t_final - t_prev)
-                   * np.log(norm_old / self.target_norm)
-                   / np.log(norm_old / norm))
-            )
-            if (t_guess - t_prev) < self.options['norm_t_tol']:
-                t_guess = t_prev + self.options['norm_t_tol']
-            _, state = self._integrator.mcstep(t_guess, copy=False)
-            norm2_guess = self._prob_func(state)
-            if (
-                np.abs(self.target_norm - norm2_guess) <
-                self.options['norm_tol'] * self.target_norm
-            ):
-                break
-            elif (norm2_guess < self.target_norm):
-                # t_guess is still > t_jump
-                t_final = t_guess
-                norm = norm2_guess
-            else:
-                # t_guess < t_jump
-                t_prev = t_guess
-                norm_old = norm2_guess
-
-        if tries >= self.options['norm_steps']:
-            raise RuntimeError(
-                "Could not find the collapse time within desired tolerance. "
-                "Increase accuracy of the ODE solver or lower the tolerance "
-                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
-
-        return t_guess, state
-
-    def _do_collapse(self, collapse_time, state):
-        """
-        Do the collapse:
-        - Find which operator did the collapse.
-        - Update the state and Integrator.
-        - Next collapse norm location
-        - Store collapse info.
-        """
-        # collapse_time, state is at the collapse
-        if len(self._n_ops) == 1:
-            which = 0
-        else:
-            probs = np.zeros(len(self._n_ops))
-            for i, n_op in enumerate(self._n_ops):
-                probs[i] = n_op.expect_data(collapse_time, state).real
-            probs = np.cumsum(probs)
-            which = np.searchsorted(probs,
-                                    probs[-1] * self._generator.random())
-
-        state_new = self._c_ops[which].matmul_data(collapse_time, state)
-        new_norm = self._norm_func(state_new)
-        if new_norm < self.options['mc_corr_eps']:
-            # This happen when the collapse is caused by numerical error
-            state_new = _data.mul(state, 1 / self._norm_func(state))
-        else:
-            state_new = _data.mul(state_new, 1 / new_norm)
-            self.collapses.append((collapse_time, which))
-            self.target_norm = self._generator.random()
-        self._integrator.set_state(collapse_time, state_new)
-
-    def arguments(self, args):
-        if args:
-            self._integrator.arguments(args)
-            for c_op in self._c_ops:
-                c_op.arguments(args)
-            for n_op in self._n_ops:
-                n_op.arguments(args)
-
-    @property
-    def integrator_options(self):
-        return self._integrator.integrator_options
-
-
-# -----------------------------------------------------------------------------
-# MONTE CARLO CLASS
-# -----------------------------------------------------------------------------
-class MCSolver(MultiTrajSolver):
-    r"""
-    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
-    given Hamiltonian and sets of collapse operators. Options for the
-    underlying ODE solver are given by the Options class.
-
-    Parameters
-    ----------
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
-        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
-        ``H`` can also be a superoperator (liouvillian) if some collapse
-        operators are to be treated deterministically.
-
-    c_ops : list
-        A ``list`` of collapse operators in any input type that QobjEvo accepts
-        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
-        even if ``H`` is a superoperator.
-
-    options : dict, [optional]
-        Options for the evolution.
-    """
-    name = "mcsolve"
-    resultclass = McResult
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "keep_runs_results": False,
-        "method": "adams",
-        "map": "serial",
-        "job_timeout": None,
-        "num_cpus": None,
-        "bitgenerator": None,
-        "mc_corr_eps": 1e-10,
-        "norm_steps": 5,
-        "norm_t_tol": 1e-6,
-        "norm_tol": 1e-4,
-    }
-
-    def __init__(self, H, c_ops, *, options=None):
-        _time_start = time()
-
-        if isinstance(c_ops, (Qobj, QobjEvo)):
-            c_ops = [c_ops]
-        c_ops = [QobjEvo(c_op) for c_op in c_ops]
-
-        if H.issuper:
-            self._c_ops = [
-                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
-                for c_op in c_ops
-            ]
-            self._n_ops = self._c_ops
-            rhs = QobjEvo(H)
-            for c_op in c_ops:
-                cdc = c_op.dag() @ c_op
-                rhs -= 0.5 * (spre(cdc) + spost(cdc))
-        else:
-            self._c_ops = c_ops
-            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
-            rhs = -1j * QobjEvo(H)
-            for n_op in self._n_ops:
-                rhs -= 0.5 * n_op
-
-        self._num_collapse = len(self._c_ops)
-
-        super().__init__(rhs, options=options)
-
-    def _restore_state(self, data, *, copy=True):
-        """
-        Retore the Qobj state from its data.
-        """
-        if self._state_metadata['dims'] == self.rhs.dims[1]:
-            state = Qobj(unstack_columns(data),
-                         **self._state_metadata, copy=False)
-        else:
-            state = Qobj(data, **self._state_metadata, copy=copy)
-
-        return state
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "method": self.options["method"],
-            "solver": "Master Equation Evolution",
-            "num_collapse": self._num_collapse,
-        })
-        return stats
-
-    def _argument(self, args):
-        self._integrator.arguments(args)
-        self.rhs.arguments(args)
-        for c_op in self._c_ops:
-            c_op.arguments(args)
-        for n_op in self._n_ops:
-            n_op.arguments(args)
-
-    def _run_one_traj(self, seed, state, tlist, e_ops):
-        """
-        Run one trajectory and return the result.
-        """
-        # The integrators is reused, but non-reentrant. They are are fine for
-        # multiprocessing, but will fail with multithreading.
-        # If a thread base parallel map is created, eahc trajectory should use
-        # a copy of the integrator.
-        result = Result(e_ops, {**self.options, "normalize_output": False})
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
-        for t in tlist[1:]:
-            t, state = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
-        result.collapse = self._integrator.collapses
-        return seed, result
-
-    def _get_integrator(self):
-        _time_start = time()
-        method = self.options["method"]
-        if method in self.avail_integrators():
-            integrator = self.avail_integrators()[method]
-        elif issubclass(method, Integrator):
-            integrator = method
-        else:
-            raise ValueError("Integrator method not supported.")
-        integrator_instance = integrator(self.rhs, self.options)
-        mc_integrator = MCIntegrator(
-            integrator_instance, self._c_ops, self._n_ops, self.options
-        )
-        self._init_integrator_time = time() - _time_start
-        return mc_integrator
-
-    @property
-    def options(self):
-        """
-        Options for monte carlo solver:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error if
-            not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size":10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        keep_runs_results: bool
-          Whether to store results from all trajectories or just store the
-          averages.
-
-        method: str, default="adams"
-            Which ODE integrator methods are supported.
-
-        map: str {"serial", "parallel", "loky"}
-            How to run the trajectories. "parallel" uses concurent module to
-            run in parallel while "loky" use the module of the same name to do
-            so.
-
-        job_timeout: None, int
-            Maximum time to compute one trajectory.
-
-        num_cpus: None, int
-            Number of cpus to use when running in parallel. ``None`` detect the
-            number of available cpus.
-
-        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
-            Which of numpy.random's bitgenerator to use. With ``None``, your
-            numpy version's default is used.
-
-        mc_corr_eps: float
-            Small number used to detect non-physical collapse caused by
-            numerical imprecision.
-
-        norm_t_tol: float
-            Tolerance in time used when finding the collapse.
-
-        norm_tol: float
-            Tolerance in norm used when finding the collapse.
-
-        norm_steps: int
-            Maximum number of tries to find the collapse.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        MultiTrajSolver.options.fset(self, new_options)
-
-    @classmethod
-    def avail_integrators(cls):
-        if cls is Solver:
-            return cls._avail_integrators.copy()
-        return {
-            **Solver.avail_integrators(),
-            **cls._avail_integrators,
-        }
+__all__ = ['mcsolve', "MCSolver"]
+
+import warnings
+
+import numpy as np
+from copy import copy
+from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
+from .multitraj import MultiTrajSolver
+from .solver_base import Solver
+from .result import McResult, Result
+from .mesolve import mesolve, MESolver
+import qutip.core.data as _data
+from time import time
+
+
+def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
+            args=None, options=None, seeds=None, target_tol=None, timeout=None):
+    r"""
+    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
+    given Hamiltonian and sets of collapse operators. Options for the
+    underlying ODE solver are given by the Options class.
+
+    Parameters
+    ----------
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        ``H`` can also be a superoperator (liouvillian) if some collapse
+        operators are to be treated deterministically.
+
+    state : :class:`qutip.Qobj`
+        Initial state vector.
+
+    tlist : array_like
+        Times at which results are recorded.
+
+    c_ops : list
+        A ``list`` of collapse operators in any input type that QobjEvo accepts
+        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
+        even if ``H`` is a superoperator. If none are given, the solver will
+        defer to ``sesolve`` or ``mesolve``.
+
+    e_ops : list, [optional]
+        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
+        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
+        are given, the solver will default to save the states.
+
+    ntraj : int
+        Maximum number of trajectories to run. Can be cut short if a time limit
+        is passed with the ``timeout`` keyword or if the target tolerance is
+        reached, see ``target_tol``.
+
+    args : None / dict
+        Arguments for time-dependent Hamiltonian and collapse operator terms.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, NoneType, [None]
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
+          Which differential equation integration method to use.
+        - keep_runs_results : bool, [False]
+          Whether to store results from all trajectories or just store the
+          averages.
+        - map : str {"serial", "parallel", "loky"}, ["serial"]
+          How to run the trajectories. "parallel" uses concurent module to run
+          in parallel while "loky" use the module of the same name to do so.
+        - job_timeout : NoneType, int, [None]
+          Maximum time to compute one trajectory.
+        - num_cpus : NoneType, int, [None]
+          Number of cpus to use when running in parallel. ``None`` detect the
+          number of available cpus.
+        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
+          Parameters used to find the collapse location. ``norm_t_tol`` and
+          ``norm_tol`` are the tolerance in time and norm respectively.
+          An error will be raised if the collapse could not be found within
+          ``norm_steps`` tries.
+        - mc_corr_eps : float, [1e-10]
+          Small number used to detect non-physical collapse caused by numerical
+          imprecision.
+        - atol, rtol : float, [1e-8, 1e-6]
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps : int [2500]
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, [0]
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+    seeds : int, SeedSequence, list, [optional]
+        Seed for the random number generator. It can be a single seed used to
+        spawn seeds for each trajectory or a list of seeds, one for each
+        trajectory. Seeds are saved in the result and they can be reused with::
+
+            seeds=prev_result.seeds
+
+    target_tol : {float, tuple, list}, optional
+        Target tolerance of the evolution. The evolution will compute
+        trajectories until the error on the expectation values is lower than
+        this tolerance. The maximum number of trajectories employed is
+        given by ``ntraj``. The error is computed using jackknife resampling.
+        ``target_tol`` can be an absolute tolerance or a pair of absolute and
+        relative tolerance, in that order. Lastly, it can be a list of pairs of
+        (atol, rtol) for each e_ops.
+
+    timeout : float [optional]
+        Maximum time for the evolution in second. When reached, no more
+        trajectories will be computed. Overwrite the option of the same name.
+
+    Returns
+    -------
+    results : :class:`qutip.solver.Result`
+        Object storing all results from the simulation. Which results is saved
+        depends on the presence of ``e_ops`` and the options used. ``collapse``
+        and ``photocurrent`` is available to Monte Carlo simulation results.
+
+    .. note:
+        The simulation will end when the first end condition is reached between
+        ``ntraj``, ``timeout`` and ``target_tol``.
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    if not isinstance(c_ops, (list, tuple)):
+        c_ops = [c_ops]
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+
+    if len(c_ops) == 0:
+        if options is None:
+            options = {}
+        options = {
+            key: options[key]
+            for key in options
+            if key in MESolver.solver_options
+        }
+        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
+                       options=options)
+
+    if isinstance(ntraj, (list, tuple)):
+        raise TypeError(
+            "ntraj must be an integer. "
+            "A list of numbers is not longer supported."
+        )
+
+    mc = MCSolver(H, c_ops, options=options)
+    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
+                    seed=seeds, target_tol=target_tol, timeout=timeout)
+    return result
+
+
+class MCIntegrator:
+    """
+    Integrator like object for mcsolve trajectory.
+    """
+    name = "mcsolve"
+
+    def __init__(self, integrator, c_ops, n_ops, options=None):
+        self._integrator = integrator
+        self._c_ops = c_ops
+        self._n_ops = n_ops
+        self.options = options
+        self._generator = None
+        self.method = f"{self.name} {self._integrator.method}"
+        self._is_set = False
+        self.issuper = c_ops[0].issuper
+
+    def set_state(self, t, state0, generator):
+        """
+        Set the state of the ODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        self.collapses = []
+        self._generator = generator
+        self.target_norm = self._generator.random()
+        self._integrator.set_state(t, state0)
+        self._is_set = True
+
+    def get_state(self, copy=True):
+        return *self._integrator.get_state(copy), self._generator
+
+    def integrate(self, t, copy=False):
+        t_old, y_old = self._integrator.get_state(copy=False)
+        norm_old = self._prob_func(y_old)
+        while t_old < t:
+            t_step, state = self._integrator.mcstep(t, copy=False)
+            norm = self._prob_func(state)
+            if norm <= self.target_norm:
+                t_col, state = self._find_collapse_time(norm_old, norm,
+                                                        t_old, t_step)
+                self._do_collapse(t_col, state)
+                t_old, y_old = self._integrator.get_state(copy=False)
+                norm_old = 1.
+            else:
+                t_old, y_old = t_step, state
+                norm_old = norm
+
+        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
+
+    def run(self, tlist):
+        for t in tlist[1:]:
+            yield self.integrate(t, False)
+
+    def reset(self, hard=False):
+        self._integrator.reset(hard)
+
+    def _prob_func(self, state):
+        if self.issuper:
+            return _data.trace_oper_ket(state).real
+        return _data.norm.l2(state)**2
+
+    def _norm_func(self, state):
+        if self.issuper:
+            return _data.trace_oper_ket(state).real
+        return _data.norm.l2(state)
+
+    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
+        """Find the time of the collapse and state just before it."""
+        tries = 0
+        while tries < self.options['norm_steps']:
+            tries += 1
+            if (t_final - t_prev) < self.options['norm_t_tol']:
+                t_guess = t_final
+                _, state = self._integrator.get_state()
+                break
+            t_guess = (
+                t_prev
+                + ((t_final - t_prev)
+                   * np.log(norm_old / self.target_norm)
+                   / np.log(norm_old / norm))
+            )
+            if (t_guess - t_prev) < self.options['norm_t_tol']:
+                t_guess = t_prev + self.options['norm_t_tol']
+            _, state = self._integrator.mcstep(t_guess, copy=False)
+            norm2_guess = self._prob_func(state)
+            if (
+                np.abs(self.target_norm - norm2_guess) <
+                self.options['norm_tol'] * self.target_norm
+            ):
+                break
+            elif (norm2_guess < self.target_norm):
+                # t_guess is still > t_jump
+                t_final = t_guess
+                norm = norm2_guess
+            else:
+                # t_guess < t_jump
+                t_prev = t_guess
+                norm_old = norm2_guess
+
+        if tries >= self.options['norm_steps']:
+            raise RuntimeError(
+                "Could not find the collapse time within desired tolerance. "
+                "Increase accuracy of the ODE solver or lower the tolerance "
+                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
+
+        return t_guess, state
+
+    def _do_collapse(self, collapse_time, state):
+        """
+        Do the collapse:
+        - Find which operator did the collapse.
+        - Update the state and Integrator.
+        - Next collapse norm location
+        - Store collapse info.
+        """
+        # collapse_time, state is at the collapse
+        if len(self._n_ops) == 1:
+            which = 0
+        else:
+            probs = np.zeros(len(self._n_ops))
+            for i, n_op in enumerate(self._n_ops):
+                probs[i] = n_op.expect_data(collapse_time, state).real
+            probs = np.cumsum(probs)
+            which = np.searchsorted(probs,
+                                    probs[-1] * self._generator.random())
+
+        state_new = self._c_ops[which].matmul_data(collapse_time, state)
+        new_norm = self._norm_func(state_new)
+        if new_norm < self.options['mc_corr_eps']:
+            # This happen when the collapse is caused by numerical error
+            state_new = _data.mul(state, 1 / self._norm_func(state))
+        else:
+            state_new = _data.mul(state_new, 1 / new_norm)
+            self.collapses.append((collapse_time, which))
+            self.target_norm = self._generator.random()
+        self._integrator.set_state(collapse_time, state_new)
+
+    def arguments(self, args):
+        if args:
+            self._integrator.arguments(args)
+            for c_op in self._c_ops:
+                c_op.arguments(args)
+            for n_op in self._n_ops:
+                n_op.arguments(args)
+
+    @property
+    def integrator_options(self):
+        return self._integrator.integrator_options
+
+
+# -----------------------------------------------------------------------------
+# MONTE CARLO CLASS
+# -----------------------------------------------------------------------------
+class MCSolver(MultiTrajSolver):
+    r"""
+    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
+    given Hamiltonian and sets of collapse operators. Options for the
+    underlying ODE solver are given by the Options class.
+
+    Parameters
+    ----------
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        ``H`` can also be a superoperator (liouvillian) if some collapse
+        operators are to be treated deterministically.
+
+    c_ops : list
+        A ``list`` of collapse operators in any input type that QobjEvo accepts
+        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
+        even if ``H`` is a superoperator.
+
+    options : dict, [optional]
+        Options for the evolution.
+    """
+    name = "mcsolve"
+    resultclass = McResult
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "method": "adams",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+        "mc_corr_eps": 1e-10,
+        "norm_steps": 5,
+        "norm_t_tol": 1e-6,
+        "norm_tol": 1e-4,
+    }
+
+    def __init__(self, H, c_ops, *, options=None):
+        _time_start = time()
+
+        if isinstance(c_ops, (Qobj, QobjEvo)):
+            c_ops = [c_ops]
+        c_ops = [QobjEvo(c_op) for c_op in c_ops]
+
+        if H.issuper:
+            self._c_ops = [
+                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
+                for c_op in c_ops
+            ]
+            self._n_ops = self._c_ops
+            rhs = QobjEvo(H)
+            for c_op in c_ops:
+                cdc = c_op.dag() @ c_op
+                rhs -= 0.5 * (spre(cdc) + spost(cdc))
+        else:
+            self._c_ops = c_ops
+            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
+            rhs = -1j * QobjEvo(H)
+            for n_op in self._n_ops:
+                rhs -= 0.5 * n_op
+
+        self._num_collapse = len(self._c_ops)
+
+        super().__init__(rhs, options=options)
+
+    def _restore_state(self, data, *, copy=True):
+        """
+        Retore the Qobj state from its data.
+        """
+        if self._state_metadata['dims'] == self.rhs.dims[1]:
+            state = Qobj(unstack_columns(data),
+                         **self._state_metadata, copy=False)
+        else:
+            state = Qobj(data, **self._state_metadata, copy=copy)
+
+        return state
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "method": self.options["method"],
+            "solver": "Master Equation Evolution",
+            "num_collapse": self._num_collapse,
+        })
+        return stats
+
+    def _argument(self, args):
+        self._integrator.arguments(args)
+        self.rhs.arguments(args)
+        for c_op in self._c_ops:
+            c_op.arguments(args)
+        for n_op in self._n_ops:
+            n_op.arguments(args)
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        # The integrators is reused, but non-reentrant. They are are fine for
+        # multiprocessing, but will fail with multithreading.
+        # If a thread base parallel map is created, eahc trajectory should use
+        # a copy of the integrator.
+        result = Result(e_ops, {**self.options, "normalize_output": False})
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
+        result.add(tlist[0], self._restore_state(state, copy=False))
+        for t in tlist[1:]:
+            t, state = self._integrator.integrate(t, copy=False)
+            result.add(t, self._restore_state(state, copy=False))
+        result.collapse = self._integrator.collapses
+        return seed, result
+
+    def _get_integrator(self):
+        _time_start = time()
+        method = self.options["method"]
+        if method in self.avail_integrators():
+            integrator = self.avail_integrators()[method]
+        elif issubclass(method, Integrator):
+            integrator = method
+        else:
+            raise ValueError("Integrator method not supported.")
+        integrator_instance = integrator(self.rhs, self.options)
+        mc_integrator = MCIntegrator(
+            integrator_instance, self._c_ops, self._n_ops, self.options
+        )
+        self._init_integrator_time = time() - _time_start
+        return mc_integrator
+
+    @property
+    def options(self):
+        """
+        Options for monte carlo solver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error if
+            not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size":10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        keep_runs_results: bool
+          Whether to store results from all trajectories or just store the
+          averages.
+
+        method: str, default="adams"
+            Which ODE integrator methods are supported.
+
+        map: str {"serial", "parallel", "loky"}
+            How to run the trajectories. "parallel" uses concurent module to
+            run in parallel while "loky" use the module of the same name to do
+            so.
+
+        job_timeout: None, int
+            Maximum time to compute one trajectory.
+
+        num_cpus: None, int
+            Number of cpus to use when running in parallel. ``None`` detect the
+            number of available cpus.
+
+        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
+            Which of numpy.random's bitgenerator to use. With ``None``, your
+            numpy version's default is used.
+
+        mc_corr_eps: float
+            Small number used to detect non-physical collapse caused by
+            numerical imprecision.
+
+        norm_t_tol: float
+            Tolerance in time used when finding the collapse.
+
+        norm_tol: float
+            Tolerance in norm used when finding the collapse.
+
+        norm_steps: int
+            Maximum number of tries to find the collapse.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        MultiTrajSolver.options.fset(self, new_options)
+
+    @classmethod
+    def avail_integrators(cls):
+        if cls is Solver:
+            return cls._avail_integrators.copy()
+        return {
+            **Solver.avail_integrators(),
+            **cls._avail_integrators,
+        }
diff --git a/qutip/solver/mesolve.py b/qutip/solver/mesolve.py
index 5792038af1..fb7ff5c777 100644
--- a/qutip/solver/mesolve.py
+++ b/qutip/solver/mesolve.py
@@ -1,217 +1,217 @@
-"""
-This module provides solvers for the Lindblad master equation and von Neumann
-equation.
-"""
-
-__all__ = ['mesolve', 'MESolver']
-
-import numpy as np
-from time import time
-from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
-from ..core import stack_columns, unstack_columns
-from ..core.data import to
-from .solver_base import Solver
-from .sesolve import sesolve, SESolver
-
-
-def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
-    """
-    Master equation evolution of a density matrix for a given Hamiltonian and
-    set of collapse operators, or a Liouvillian.
-
-    Evolve the state vector or density matrix (`rho0`) using a given
-    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
-    (`c_ops`), by integrating the set of ordinary differential equations
-    that define the system. In the absence of collapse operators the system is
-    evolved according to the unitary evolution of the Hamiltonian.
-
-    The output is either the state vector at arbitrary points in time
-    (`tlist`), or the expectation values of the supplied operators
-    (`e_ops`). If e_ops is a callback function, it is invoked for each
-    time in `tlist` with time and the state as arguments, and the function
-    does not use any return values.
-
-    If either `H` or the Qobj elements in `c_ops` are superoperators, they
-    will be treated as direct contributions to the total system Liouvillian.
-    This allows the solution of master equations that are not in standard
-    Lindblad form.
-
-    **Time-dependent operators**
-
-    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
-    object that can be interpreted as :class:`QobjEvo` such as a list of
-    (Qobj, Coefficient) pairs or a function.
-
-    **Additional options**
-
-    Additional options to mesolve can be set via the `options` argument. Many
-    ODE integration options can be set this way, and the `store_states` and
-    `store_final_state` options can be used to store states even though
-    expectation values are requested via the `e_ops` argument.
-
-    .. note::
-
-        When no collapse operator are given and the `H` is not a superoperator,
-        it will defer to :func:`sesolve`.
-
-    Parameters
-    ----------
-
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    rho0 : :class:`Qobj`
-        initial density matrix or state vector (ket).
-
-    tlist : *list* / *array*
-        list of times for :math:`t`.
-
-    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
-        Single collapse operator, or list of collapse operators, or a list
-        of Liouvillian superoperators. None is equivalent to an empty list.
-
-    e_ops : list of :class:`Qobj` / callback function
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation.
-
-    args : None / *dictionary*
-        dictionary of parameters for time-dependent Hamiltonians and
-        collapse operators.
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        a *list of array* `result.expect` of expectation values for the times
-        specified by `tlist`, and/or a *list* `result.states` of state vectors
-        or density matrices corresponding to the times in `tlist` [if `e_ops`
-        is an empty list of `store_states=True` in options].
-
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-
-    c_ops = c_ops if c_ops is not None else []
-    if not isinstance(c_ops, (list, tuple)):
-        c_ops = [c_ops]
-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-
-    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
-
-    if not use_mesolve:
-        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
-                       options=options)
-
-    solver = MESolver(H, c_ops, options=options)
-
-    return solver.run(rho0, tlist, e_ops=e_ops)
-
-
-class MESolver(SESolver):
-    """
-    Master equation evolution of a density matrix for a given Hamiltonian and
-    set of collapse operators, or a Liouvillian.
-
-    Evolve the density matrix (`rho0`) using a given
-    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
-    (`c_ops`), by integrating the set of ordinary differential equations
-    that define the system.
-
-    If either `H` or the Qobj elements in `c_ops` are superoperators, they
-    will be treated as direct contributions to the total system Liouvillian.
-    This allows the solution of master equations that are not in standard
-    Lindblad form.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
-        Single collapse operator, or list of collapse operators, or a list
-        of Liouvillian superoperators. None is equivalent to an empty list.
-
-    options : dict, optional
-        Options for the solver, see :obj:`MESolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-
-    attributes
-    ----------
-    stats: dict
-        Diverse diagnostic statistics of the evolution.
-    """
-    name = "mesolve"
-    _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size":10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-        'method': 'adams',
-    }
-
-    def __init__(self, H, c_ops=None, *, options=None):
-        _time_start = time()
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-        c_ops = c_ops or []
-        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
-        for c_op in c_ops:
-            if not isinstance(c_op, (Qobj, QobjEvo)):
-                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
-
-        self._num_collapse = len(c_ops)
-
-        rhs = H if H.issuper else liouvillian(H)
-        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
-                   for c_op in c_ops)
-
-        Solver.__init__(self, rhs, options=options)
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "solver": "Master Equation Evolution",
-            "num_collapse": self._num_collapse,
-        })
-        return stats
+"""
+This module provides solvers for the Lindblad master equation and von Neumann
+equation.
+"""
+
+__all__ = ['mesolve', 'MESolver']
+
+import numpy as np
+from time import time
+from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
+from ..core import stack_columns, unstack_columns
+from ..core.data import to
+from .solver_base import Solver
+from .sesolve import sesolve, SESolver
+
+
+def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
+    """
+    Master equation evolution of a density matrix for a given Hamiltonian and
+    set of collapse operators, or a Liouvillian.
+
+    Evolve the state vector or density matrix (`rho0`) using a given
+    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
+    (`c_ops`), by integrating the set of ordinary differential equations
+    that define the system. In the absence of collapse operators the system is
+    evolved according to the unitary evolution of the Hamiltonian.
+
+    The output is either the state vector at arbitrary points in time
+    (`tlist`), or the expectation values of the supplied operators
+    (`e_ops`). If e_ops is a callback function, it is invoked for each
+    time in `tlist` with time and the state as arguments, and the function
+    does not use any return values.
+
+    If either `H` or the Qobj elements in `c_ops` are superoperators, they
+    will be treated as direct contributions to the total system Liouvillian.
+    This allows the solution of master equations that are not in standard
+    Lindblad form.
+
+    **Time-dependent operators**
+
+    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
+    object that can be interpreted as :class:`QobjEvo` such as a list of
+    (Qobj, Coefficient) pairs or a function.
+
+    **Additional options**
+
+    Additional options to mesolve can be set via the `options` argument. Many
+    ODE integration options can be set this way, and the `store_states` and
+    `store_final_state` options can be used to store states even though
+    expectation values are requested via the `e_ops` argument.
+
+    .. note::
+
+        When no collapse operator are given and the `H` is not a superoperator,
+        it will defer to :func:`sesolve`.
+
+    Parameters
+    ----------
+
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    rho0 : :class:`Qobj`
+        initial density matrix or state vector (ket).
+
+    tlist : *list* / *array*
+        list of times for :math:`t`.
+
+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        Single collapse operator, or list of collapse operators, or a list
+        of Liouvillian superoperators. None is equivalent to an empty list.
+
+    e_ops : list of :class:`Qobj` / callback function
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
+
+    args : None / *dictionary*
+        dictionary of parameters for time-dependent Hamiltonians and
+        collapse operators.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        a *list of array* `result.expect` of expectation values for the times
+        specified by `tlist`, and/or a *list* `result.states` of state vectors
+        or density matrices corresponding to the times in `tlist` [if `e_ops`
+        is an empty list of `store_states=True` in options].
+
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+
+    c_ops = c_ops if c_ops is not None else []
+    if not isinstance(c_ops, (list, tuple)):
+        c_ops = [c_ops]
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+
+    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
+
+    if not use_mesolve:
+        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
+                       options=options)
+
+    solver = MESolver(H, c_ops, options=options)
+
+    return solver.run(rho0, tlist, e_ops=e_ops)
+
+
+class MESolver(SESolver):
+    """
+    Master equation evolution of a density matrix for a given Hamiltonian and
+    set of collapse operators, or a Liouvillian.
+
+    Evolve the density matrix (`rho0`) using a given
+    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
+    (`c_ops`), by integrating the set of ordinary differential equations
+    that define the system.
+
+    If either `H` or the Qobj elements in `c_ops` are superoperators, they
+    will be treated as direct contributions to the total system Liouvillian.
+    This allows the solution of master equations that are not in standard
+    Lindblad form.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
+        Single collapse operator, or list of collapse operators, or a list
+        of Liouvillian superoperators. None is equivalent to an empty list.
+
+    options : dict, optional
+        Options for the solver, see :obj:`MESolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+
+    attributes
+    ----------
+    stats: dict
+        Diverse diagnostic statistics of the evolution.
+    """
+    name = "mesolve"
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size":10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+        'method': 'adams',
+    }
+
+    def __init__(self, H, c_ops=None, *, options=None):
+        _time_start = time()
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+        c_ops = c_ops or []
+        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
+        for c_op in c_ops:
+            if not isinstance(c_op, (Qobj, QobjEvo)):
+                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
+
+        self._num_collapse = len(c_ops)
+
+        rhs = H if H.issuper else liouvillian(H)
+        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
+                   for c_op in c_ops)
+
+        Solver.__init__(self, rhs, options=options)
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "solver": "Master Equation Evolution",
+            "num_collapse": self._num_collapse,
+        })
+        return stats
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 204178d116..3123c72eaf 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -1,257 +1,257 @@
-from .. import Qobj, QobjEvo
-from .result import Result, MultiTrajResult
-from .parallel import _get_map
-from time import time
-from .solver_base import Solver
-import numpy as np
-from copy import copy
-
-__all__ = ["MultiTrajSolver", "TrajectorySolver"]
-
-
-class MultiTrajSolver(Solver):
-    """
-    Basic class for multi-trajectory evolutions.
-
-    As :class:`Solver` it can ``run`` or ``step`` evolution.
-    It manages the random seed for each trajectory.
-
-    The actual evolution is done by a single trajectory solver::
-        ``_traj_solver_class``
-
-    Parameters
-    ----------
-    rhs : Qobj, QobjEvo
-        Right hand side of the evolution::
-            d state / dt = rhs @ state
-
-    options : dict
-        Options for the solver.
-    """
-    name = "generic multi trajectory"
-    resultclass = MultiTrajResult
-    _avail_integrators = {}
-
-    # Class of option used by the solver
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "keep_runs_results": False,
-        "normalize_output": False,
-        "method": "",
-        "map": "serial",
-        "job_timeout": None,
-        "num_cpus": None,
-        "bitgenerator": None,
-    }
-
-    def __init__(self, rhs, *, options=None):
-        self.rhs = rhs
-        self.options = options
-        self.seed_sequence = np.random.SeedSequence()
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-    def start(self, state, t0, seed=None):
-        """
-        Set the initial state and time for a step evolution.
-
-        Parameters
-        ----------
-        state : :class:`Qobj`
-            Initial state of the evolution.
-
-        t0 : double
-            Initial time of the evolution.
-
-        seed : int, SeedSequence, list, {None}
-            Seed for the random number generator. It can be a single seed used
-            to spawn seeds for each trajectory or a list of seed, one for each
-            trajectory.
-
-        ..note ::
-            When using step evolution, only one trajectory can be computed at
-            once.
-        """
-        seeds = self._read_seed(seed, 1)
-        generator = self._get_generator(seeds[0])
-        self._integrator.set_state(t0, self._prepare_state(state), generator)
-
-    def step(self, t, *, args=None, copy=True):
-        """
-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-
-        Parameters
-        ----------
-        t : double
-            Time to evolve to, must be higher than the last call.
-
-        args : dict, optional {None}
-            Update the ``args`` of the system.
-            The change is effective from the beginning of the interval.
-            Changing ``args`` can slow the evolution.
-
-        copy : bool, optional {True}
-            Whether to return a copy of the data or the data in the ODE solver.
-        """
-        if not self._integrator._is_set:
-            raise RuntimeError("The `start` method must called first.")
-        self._argument(args)
-        _, state = self._integrator.integrate(t, copy=False)
-        return self._restore_state(state, copy=copy)
-
-    def run(self, state, tlist, ntraj=1, *,
-            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
-        """
-        Do the evolution of the Quantum system.
-
-        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
-        ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :cls:`Result`. The evolution method and stored
-        results are determined by ``options``.
-
-        Parameters
-        ----------
-        state : :class:`Qobj`
-            Initial state of the evolution.
-
-        tlist : list of double
-            Time for which to save the results (state and/or expect) of the
-            evolution. The first element of the list is the initial time of the
-            evolution. Time in the list must be in increasing order, but does
-            not need to be uniformly distributed.
-
-        ntraj : int
-            Number of trajectories to add.
-
-        args : dict, optional {None}
-            Change the ``args`` of the rhs for the evolution.
-
-        e_ops : list
-            list of Qobj or QobjEvo to compute the expectation values.
-            Alternatively, function[s] with the signature f(t, state) -> expect
-            can be used.
-
-        timeout : float, optional [1e8]
-            Maximum time in seconds for the trajectories to run. Once this time
-            is reached, the simulation will end even if the number
-            of trajectories is less than ``ntraj``. The map function, set in
-            options, can interupt the running trajectory or wait for it to
-            finish. Set to an arbitrary high number to disable.
-
-        target_tol : {float, tuple, list}, optional [None]
-            Target tolerance of the evolution. The evolution will compute
-            trajectories until the error on the expectation values is lower
-            than this tolerance. The maximum number of trajectories employed is
-            given by ``ntraj``. The error is computed using jackknife
-            resampling. ``target_tol`` can be an absolute tolerance or a pair
-            of absolute and relative tolerance, in that order. Lastly, it can
-            be a list of pairs of (atol, rtol) for each e_ops.
-
-        seed : {int, SeedSequence, list} optional
-            Seed or list of seeds for each trajectories.
-
-        Return
-        ------
-        results : :class:`qutip.solver.MultiTrajResult`
-            Results of the evolution. States and/or expect will be saved. You
-            can control the saved data in the options.
-
-        .. note:
-            The simulation will end when the first end condition is reached
-            between ``ntraj``, ``timeout`` and ``target_tol``.
-        """
-        start_time = time()
-        self._argument(args)
-        stats = self._initialize_stats()
-        seeds = self._read_seed(seed, ntraj)
-
-        result = self.resultclass(
-            e_ops, self.options, solver=self.name, stats=stats
-        )
-        result.add_end_condition(ntraj, target_tol)
-
-        map_func = _get_map[self.options['map']]
-        map_kw = {
-            'timeout': timeout,
-            'job_timeout': self.options['job_timeout'],
-            'num_cpus': self.options['num_cpus'],
-        }
-        state0 = self._prepare_state(state)
-        stats['preparation time'] += time() - start_time
-
-        start_time = time()
-        map_func(
-            self._run_one_traj, seeds,
-            (state0, tlist, e_ops),
-            reduce_func=result.add, map_kw=map_kw,
-            progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"]
-        )
-        result.stats['run time'] = time() - start_time
-        return result
-
-    def _run_one_traj(self, seed, state, tlist, e_ops):
-        """
-        Run one trajectory and return the result.
-        """
-        result = Result(e_ops, self.options)
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
-        for t in tlist[1:]:
-            t, state = self._integrator.step(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
-        return seed, result
-
-    def _read_seed(self, seed, ntraj):
-        """
-        Read user provided seed(s) and produce one for each trajectory.
-        Let numpy raise error for inputs that cannot be seeds.
-        """
-        if seed is None:
-            seeds = self.seed_sequence.spawn(ntraj)
-        elif isinstance(seed, np.random.SeedSequence):
-            seeds = seed.spawn(ntraj)
-        elif not isinstance(seed, list):
-            seeds = np.random.SeedSequence(seed).spawn(ntraj)
-        elif len(seed) >= ntraj:
-            seeds = [
-                seed_ if (isinstance(seed_, np.random.SeedSequence)
-                          or hasattr(seed_, 'random'))
-                else np.random.SeedSequence(seed_)
-                for seed_ in seed[:ntraj]
-            ]
-        else:
-            raise ValueError("A seed list must be longer than ntraj")
-        return seeds
-
-    def _argument(self, args):
-        """Update the args, for the `rhs` and `c_ops` and other operators."""
-        if args:
-            self.rhs.arguments(args)
-
-    def _get_generator(self, seed):
-        """
-        Read the seed and create the random number generator.
-        If the ``seed`` has a ``random`` method, it will be used as the
-        generator.
-        """
-        if hasattr(seed, 'random'):
-            # We check for the method, not the type to accept pseudo non-random
-            # generator for debug/testing purpose.
-            return seed
-
-        if self.options['bitgenerator']:
-            bit_gen = getattr(np.random, self.options['bitgenerator'])
-            generator = np.random.Generator(bit_gen(seed))
-        else:
-            generator = np.random.default_rng(seed)
-        return generator
-
-    @classmethod
-    def avail_integrators(cls):
-        return cls._avail_integrators
+from .. import Qobj, QobjEvo
+from .result import Result, MultiTrajResult
+from .parallel import _get_map
+from time import time
+from .solver_base import Solver
+import numpy as np
+from copy import copy
+
+__all__ = ["MultiTrajSolver", "TrajectorySolver"]
+
+
+class MultiTrajSolver(Solver):
+    """
+    Basic class for multi-trajectory evolutions.
+
+    As :class:`Solver` it can ``run`` or ``step`` evolution.
+    It manages the random seed for each trajectory.
+
+    The actual evolution is done by a single trajectory solver::
+        ``_traj_solver_class``
+
+    Parameters
+    ----------
+    rhs : Qobj, QobjEvo
+        Right hand side of the evolution::
+            d state / dt = rhs @ state
+
+    options : dict
+        Options for the solver.
+    """
+    name = "generic multi trajectory"
+    resultclass = MultiTrajResult
+    _avail_integrators = {}
+
+    # Class of option used by the solver
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "normalize_output": False,
+        "method": "",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+    }
+
+    def __init__(self, rhs, *, options=None):
+        self.rhs = rhs
+        self.options = options
+        self.seed_sequence = np.random.SeedSequence()
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+    def start(self, state, t0, seed=None):
+        """
+        Set the initial state and time for a step evolution.
+
+        Parameters
+        ----------
+        state : :class:`Qobj`
+            Initial state of the evolution.
+
+        t0 : double
+            Initial time of the evolution.
+
+        seed : int, SeedSequence, list, {None}
+            Seed for the random number generator. It can be a single seed used
+            to spawn seeds for each trajectory or a list of seed, one for each
+            trajectory.
+
+        ..note ::
+            When using step evolution, only one trajectory can be computed at
+            once.
+        """
+        seeds = self._read_seed(seed, 1)
+        generator = self._get_generator(seeds[0])
+        self._integrator.set_state(t0, self._prepare_state(state), generator)
+
+    def step(self, t, *, args=None, copy=True):
+        """
+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+
+        Parameters
+        ----------
+        t : double
+            Time to evolve to, must be higher than the last call.
+
+        args : dict, optional {None}
+            Update the ``args`` of the system.
+            The change is effective from the beginning of the interval.
+            Changing ``args`` can slow the evolution.
+
+        copy : bool, optional {True}
+            Whether to return a copy of the data or the data in the ODE solver.
+        """
+        if not self._integrator._is_set:
+            raise RuntimeError("The `start` method must called first.")
+        self._argument(args)
+        _, state = self._integrator.integrate(t, copy=False)
+        return self._restore_state(state, copy=copy)
+
+    def run(self, state, tlist, ntraj=1, *,
+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+        """
+        Do the evolution of the Quantum system.
+
+        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
+        ``rhs`` and for each time in ``tlist`` store the state and/or
+        expectation values in a :cls:`Result`. The evolution method and stored
+        results are determined by ``options``.
+
+        Parameters
+        ----------
+        state : :class:`Qobj`
+            Initial state of the evolution.
+
+        tlist : list of double
+            Time for which to save the results (state and/or expect) of the
+            evolution. The first element of the list is the initial time of the
+            evolution. Time in the list must be in increasing order, but does
+            not need to be uniformly distributed.
+
+        ntraj : int
+            Number of trajectories to add.
+
+        args : dict, optional {None}
+            Change the ``args`` of the rhs for the evolution.
+
+        e_ops : list
+            list of Qobj or QobjEvo to compute the expectation values.
+            Alternatively, function[s] with the signature f(t, state) -> expect
+            can be used.
+
+        timeout : float, optional [1e8]
+            Maximum time in seconds for the trajectories to run. Once this time
+            is reached, the simulation will end even if the number
+            of trajectories is less than ``ntraj``. The map function, set in
+            options, can interupt the running trajectory or wait for it to
+            finish. Set to an arbitrary high number to disable.
+
+        target_tol : {float, tuple, list}, optional [None]
+            Target tolerance of the evolution. The evolution will compute
+            trajectories until the error on the expectation values is lower
+            than this tolerance. The maximum number of trajectories employed is
+            given by ``ntraj``. The error is computed using jackknife
+            resampling. ``target_tol`` can be an absolute tolerance or a pair
+            of absolute and relative tolerance, in that order. Lastly, it can
+            be a list of pairs of (atol, rtol) for each e_ops.
+
+        seed : {int, SeedSequence, list} optional
+            Seed or list of seeds for each trajectories.
+
+        Return
+        ------
+        results : :class:`qutip.solver.MultiTrajResult`
+            Results of the evolution. States and/or expect will be saved. You
+            can control the saved data in the options.
+
+        .. note:
+            The simulation will end when the first end condition is reached
+            between ``ntraj``, ``timeout`` and ``target_tol``.
+        """
+        start_time = time()
+        self._argument(args)
+        stats = self._initialize_stats()
+        seeds = self._read_seed(seed, ntraj)
+
+        result = self.resultclass(
+            e_ops, self.options, solver=self.name, stats=stats
+        )
+        result.add_end_condition(ntraj, target_tol)
+
+        map_func = _get_map[self.options['map']]
+        map_kw = {
+            'timeout': timeout,
+            'job_timeout': self.options['job_timeout'],
+            'num_cpus': self.options['num_cpus'],
+        }
+        state0 = self._prepare_state(state)
+        stats['preparation time'] += time() - start_time
+
+        start_time = time()
+        map_func(
+            self._run_one_traj, seeds,
+            (state0, tlist, e_ops),
+            reduce_func=result.add, map_kw=map_kw,
+            progress_bar=self.options["progress_bar"],
+            progress_bar_kwargs=self.options["progress_kwargs"]
+        )
+        result.stats['run time'] = time() - start_time
+        return result
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        result = Result(e_ops, self.options)
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
+        result.add(tlist[0], self._restore_state(state, copy=False))
+        for t in tlist[1:]:
+            t, state = self._integrator.step(t, copy=False)
+            result.add(t, self._restore_state(state, copy=False))
+        return seed, result
+
+    def _read_seed(self, seed, ntraj):
+        """
+        Read user provided seed(s) and produce one for each trajectory.
+        Let numpy raise error for inputs that cannot be seeds.
+        """
+        if seed is None:
+            seeds = self.seed_sequence.spawn(ntraj)
+        elif isinstance(seed, np.random.SeedSequence):
+            seeds = seed.spawn(ntraj)
+        elif not isinstance(seed, list):
+            seeds = np.random.SeedSequence(seed).spawn(ntraj)
+        elif len(seed) >= ntraj:
+            seeds = [
+                seed_ if (isinstance(seed_, np.random.SeedSequence)
+                          or hasattr(seed_, 'random'))
+                else np.random.SeedSequence(seed_)
+                for seed_ in seed[:ntraj]
+            ]
+        else:
+            raise ValueError("A seed list must be longer than ntraj")
+        return seeds
+
+    def _argument(self, args):
+        """Update the args, for the `rhs` and `c_ops` and other operators."""
+        if args:
+            self.rhs.arguments(args)
+
+    def _get_generator(self, seed):
+        """
+        Read the seed and create the random number generator.
+        If the ``seed`` has a ``random`` method, it will be used as the
+        generator.
+        """
+        if hasattr(seed, 'random'):
+            # We check for the method, not the type to accept pseudo non-random
+            # generator for debug/testing purpose.
+            return seed
+
+        if self.options['bitgenerator']:
+            bit_gen = getattr(np.random, self.options['bitgenerator'])
+            generator = np.random.Generator(bit_gen(seed))
+        else:
+            generator = np.random.default_rng(seed)
+        return generator
+
+    @classmethod
+    def avail_integrators(cls):
+        return cls._avail_integrators
diff --git a/qutip/solver/options.py b/qutip/solver/options.py
index 207fa89737..737724b92a 100644
--- a/qutip/solver/options.py
+++ b/qutip/solver/options.py
@@ -1,106 +1,106 @@
-__all__ = ["Options", "SolverOptions"]
-
-import warnings
-
-
-def SolverOptions(*args, **kwargs):
-    warnings.warn(
-        "Dedicated options class are no longer needed, "
-        "options should be passed as dict to solvers.",
-        FutureWarning
-    )
-    return kwargs
-
-
-def Options(**kwargs):
-    warnings.warn(
-        "Dedicated options class are no longer needed, "
-        "options should be passed as dict to solvers.",
-        FutureWarning
-    )
-    return kwargs
-
-
-class _SolverOptions(dict):
-    """
-    Class to hold options for solver and integrator.
-
-    Parameters
-    ----------
-    default : dict
-        Default dict, only keys in this will be accepted.
-    feedback : callable, ``f(keys : set) -> None``, optional
-        Function to called when an item is updated.
-    name : str, optional
-        Name of the solver or integrator that use this. Used in __repr__ only.
-    doc : str, optional
-        Overwrite the __doc__ of the instance.
-    """
-    def __init__(
-        self, default, feedback=None, name="", doc="", /, **kwargs
-    ):
-        self._default = default
-        self.__doc__ = doc
-        self._feedback = feedback
-        self._name = name
-        extra_keys = kwargs.keys() - default.keys()
-        if extra_keys:
-            raise KeyError(f"Options {extra_keys} are not supported.")
-        super().__init__(**{**self._default, **kwargs})
-
-    def __setitem__(self, key, val):
-        if key not in self._default:
-            raise KeyError(f"Options {key} is not supported.")
-        if val is None:
-            val = self._default[key]
-        if val == self[key]:
-            return
-        super().__setitem__(key, val)
-        if self._feedback:
-            self._feedback(key)
-
-    def __delitem__(self, key):
-        if key not in self._default:
-            raise KeyError(f"Options {key} is not supported.")
-        super().__setitem__(key, self._default[key])
-        if self._feedback:
-            self._feedback(key)
-
-    def copy(self):
-        return self.__class__(
-            self._default,
-            self._feedback,
-            self._name,
-            self.__doc__,
-            **self
-        )
-
-    def __str__(self):
-        lines = []
-        longest = max(len(key) for key in self.keys())
-        lines.append(f"Options for {self._name}:")
-        for key in self.keys():
-            default = "(default)" if self[key] == self._default[key] else ""
-            lines.append(f"    {key:{longest}} : "
-                         f"{self[key].__repr__():{70-longest}}"
-                         f"{default}")
-        return "\n".join(lines)
-
-    @classmethod
-    def _from_reduced(cls, default, feedback, name, doc, keys, args):
-        return cls(default, feedback, name, doc, **{
-            key: arg for key, arg in zip(keys, args)
-        })
-
-    def __reduce__(self):
-        return (
-            self._from_reduced,
-            (
-                self._default,
-                self._feedback,
-                self._name,
-                self.__doc__,
-                tuple(self.keys()),
-                tuple(self.values())
-                )
-            )
+__all__ = ["Options", "SolverOptions"]
+
+import warnings
+
+
+def SolverOptions(*args, **kwargs):
+    warnings.warn(
+        "Dedicated options class are no longer needed, "
+        "options should be passed as dict to solvers.",
+        FutureWarning
+    )
+    return kwargs
+
+
+def Options(**kwargs):
+    warnings.warn(
+        "Dedicated options class are no longer needed, "
+        "options should be passed as dict to solvers.",
+        FutureWarning
+    )
+    return kwargs
+
+
+class _SolverOptions(dict):
+    """
+    Class to hold options for solver and integrator.
+
+    Parameters
+    ----------
+    default : dict
+        Default dict, only keys in this will be accepted.
+    feedback : callable, ``f(keys : set) -> None``, optional
+        Function to called when an item is updated.
+    name : str, optional
+        Name of the solver or integrator that use this. Used in __repr__ only.
+    doc : str, optional
+        Overwrite the __doc__ of the instance.
+    """
+    def __init__(
+        self, default, feedback=None, name="", doc="", /, **kwargs
+    ):
+        self._default = default
+        self.__doc__ = doc
+        self._feedback = feedback
+        self._name = name
+        extra_keys = kwargs.keys() - default.keys()
+        if extra_keys:
+            raise KeyError(f"Options {extra_keys} are not supported.")
+        super().__init__(**{**self._default, **kwargs})
+
+    def __setitem__(self, key, val):
+        if key not in self._default:
+            raise KeyError(f"Options {key} is not supported.")
+        if val is None:
+            val = self._default[key]
+        if val == self[key]:
+            return
+        super().__setitem__(key, val)
+        if self._feedback:
+            self._feedback(key)
+
+    def __delitem__(self, key):
+        if key not in self._default:
+            raise KeyError(f"Options {key} is not supported.")
+        super().__setitem__(key, self._default[key])
+        if self._feedback:
+            self._feedback(key)
+
+    def copy(self):
+        return self.__class__(
+            self._default,
+            self._feedback,
+            self._name,
+            self.__doc__,
+            **self
+        )
+
+    def __str__(self):
+        lines = []
+        longest = max(len(key) for key in self.keys())
+        lines.append(f"Options for {self._name}:")
+        for key in self.keys():
+            default = "(default)" if self[key] == self._default[key] else ""
+            lines.append(f"    {key:{longest}} : "
+                         f"{self[key].__repr__():{70-longest}}"
+                         f"{default}")
+        return "\n".join(lines)
+
+    @classmethod
+    def _from_reduced(cls, default, feedback, name, doc, keys, args):
+        return cls(default, feedback, name, doc, **{
+            key: arg for key, arg in zip(keys, args)
+        })
+
+    def __reduce__(self):
+        return (
+            self._from_reduced,
+            (
+                self._default,
+                self._feedback,
+                self._name,
+                self.__doc__,
+                tuple(self.keys()),
+                tuple(self.values())
+                )
+            )
diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
index 4ceeb0fc44..2c41fb7c06 100644
--- a/qutip/solver/parallel.py
+++ b/qutip/solver/parallel.py
@@ -1,370 +1,370 @@
-"""
-This module provides functions for parallel execution of loops and function
-mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
-"""
-__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
-
-import multiprocessing
-import os
-import sys
-import time
-import threading
-import concurrent.futures
-from qutip.ui.progressbar import progess_bars
-from qutip.settings import available_cpu_count
-
-if sys.platform == 'darwin':
-    mp_context = multiprocessing.get_context('fork')
-elif sys.platform == 'linux':
-    # forkserver would handle threads better, but is much slower at starting
-    # the executor and spawning tasks
-    mp_context = multiprocessing.get_context('fork')
-else:
-    mp_context = multiprocessing.get_context()
-
-
-default_map_kw = {
-    'job_timeout': threading.TIMEOUT_MAX,
-    'timeout': threading.TIMEOUT_MAX,
-    'num_cpus': available_cpu_count(),
-    'fail_fast': True,
-}
-
-
-def _read_map_kw(options):
-    options = options or {}
-    map_kw = default_map_kw.copy()
-    map_kw.update({k: v for k, v in options.items() if v is not None})
-    return map_kw
-
-
-class MapExceptions(Exception):
-    def __init__(self, msg, errors, results):
-        super().__init__(msg, errors, results)
-        self.errors = errors
-        self.results = results
-
-
-def serial_map(task, values, task_args=None, task_kwargs=None,
-               reduce_func=None, map_kw=None,
-               progress_bar=None, progress_bar_kwargs={}):
-    """
-    Serial mapping function with the same call signature as parallel_map, for
-    easy switching between serial and parallel execution. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    reduce_func : func (optional)
-        If provided, it will be called with the output of each tasks instead of
-        storing a them in a list.
-    progress_bar : string
-        Progress bar options's string for showing progress.
-    progress_bar_kwargs : dict
-        Options for the progress bar.
-    map_kw: dict (optional)
-        Dictionary containing:
-        - timeout: float, Maximum time (sec) for the whole map.
-        - fail_fast: bool, Raise an error at the first.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for each
-        value in ``values``. If a ``reduce_func`` is provided, and empty list
-        will be returned.
-
-    """
-    if task_args is None:
-        task_args = ()
-    if task_kwargs is None:
-        task_kwargs = {}
-    map_kw = _read_map_kw(map_kw)
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
-    end_time = map_kw['timeout'] + time.time()
-    results = None
-    if reduce_func is None:
-        results = [None] * len(values)
-    errors = {}
-    for n, value in enumerate(values):
-        if time.time() > end_time:
-            break
-        progress_bar.update(n)
-        try:
-            result = task(value, *task_args, **task_kwargs)
-        except Exception as err:
-            if map_kw["fail_fast"]:
-                raise err
-            else:
-                errors[n] = err
-        else:
-            if reduce_func is not None:
-                reduce_func(result)
-            else:
-                results[n] = result
-    progress_bar.finished()
-
-    if errors:
-        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
-                            errors, results)
-    return results
-
-
-def parallel_map(task, values, task_args=None, task_kwargs=None,
-                 reduce_func=None, map_kw=None,
-                 progress_bar=None, progress_bar_kwargs={}):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    reduce_func : func (optional)
-        If provided, it will be called with the output of each tasks instead of
-        storing a them in a list. Note that the order in which results are
-        passed to ``reduce_func`` is not defined.
-    progress_bar : string
-        Progress bar options's string for showing progress.
-    progress_bar_kwargs : dict
-        Options for the progress bar.
-    map_kw: dict (optional)
-        Dictionary containing entry for:
-        - timeout: float, Maximum time (sec) for the whole map.
-        - job_timeout: float, Maximum time (sec) for each job in the map.
-        - num_cpus: int, Number of job to run at once.
-        - fail_fast: bool, Raise an error at the first.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``. If a ``reduce_func`` is provided, and empty
-        list will be returned.
-
-    """
-    if task_args is None:
-        task_args = ()
-    if task_kwargs is None:
-        task_kwargs = {}
-    map_kw = _read_map_kw(map_kw)
-    end_time = map_kw['timeout'] + time.time()
-    job_time = map_kw['job_timeout']
-
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
-
-    errors = {}
-    if reduce_func is not None:
-        results = None
-        result_func = lambda i, value: reduce_func(value)
-    else:
-        results = [None] * len(values)
-        result_func = lambda i, value: results.__setitem__(i, value)
-
-    def _done_callback(future):
-        if not future.cancelled():
-            try:
-                result = future.result()
-            except Exception as e:
-                errors[future._i] = e
-        result_func(future._i, result)
-        progress_bar.update()
-
-    if sys.version_info >= (3, 7):
-        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
-        ctx_kw = {"mp_context": mp_context}
-    else:
-        ctx_kw = {}
-
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    try:
-        with concurrent.futures.ProcessPoolExecutor(
-            max_workers=map_kw['num_cpus'], **ctx_kw,
-        ) as executor:
-            waiting = set()
-            i = 0
-            while i < len(values):
-                # feed values to the executor, ensuring that there is at
-                # most one task per worker at any moment in time so that
-                # we can shutdown without waiting for greater than the time
-                # taken by the longest task
-                if len(waiting) >= map_kw['num_cpus']:
-                    # no space left, wait for a task to complete or
-                    # the time to run out
-                    timeout = max(0, end_time - time.time())
-                    _done, waiting = concurrent.futures.wait(
-                        waiting,
-                        timeout=timeout,
-                        return_when=concurrent.futures.FIRST_COMPLETED,
-                    )
-                if time.time() >= end_time or (errors and map_kw['fail_fast']):
-                    # no time left, exit the loop
-                    break
-                while len(waiting) < map_kw['num_cpus'] and i < len(values):
-                    # space and time available, add tasks
-                    value = values[i]
-                    future = executor.submit(
-                        task, *((value,) + task_args), **task_kwargs,
-                    )
-                    # small hack to avoid add_done_callback not supporting
-                    # extra arguments and closures inside loops retaining
-                    # a reference not a value:
-                    future._i = i
-                    future.add_done_callback(_done_callback)
-                    waiting.add(future)
-                    i += 1
-
-            timeout = max(0, end_time - time.time())
-            concurrent.futures.wait(waiting, timeout=timeout)
-    finally:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-
-    progress_bar.finished()
-    if errors and map_kw["fail_fast"]:
-        raise list(errors.values())[0]
-    elif errors:
-        raise MapExceptions(
-            f"{len(errors)} iterations failed in parallel_map",
-            errors, results
-        )
-
-    return results
-
-
-def loky_pmap(task, values, task_args=None, task_kwargs=None,
-              reduce_func=None, map_kw=None,
-              progress_bar=None, progress_bar_kwargs={}):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Use the loky module instead of multiprocessing.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    reduce_func : func (optional)
-        If provided, it will be called with the output of each tasks instead of
-        storing a them in a list.
-    progress_bar : string
-        Progress bar options's string for showing progress.
-    progress_bar_kwargs : dict
-        Options for the progress bar.
-    map_kw: dict (optional)
-        Dictionary containing entry for:
-        - timeout: float, Maximum time (sec) for the whole map.
-        - job_timeout: float, Maximum time (sec) for each job in the map.
-        - num_cpus: int, Number of job to run at once.
-        - fail_fast: bool, Raise an error at the first.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``. If a ``reduce_func`` is provided, and empty
-        list will be returned.
-
-    """
-    if task_args is None:
-        task_args = ()
-    if task_kwargs is None:
-        task_kwargs = {}
-    map_kw = _read_map_kw(map_kw)
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    from loky import get_reusable_executor, TimeoutError
-
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
-
-    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
-    end_time = map_kw['timeout'] + time.time()
-    job_time = map_kw['job_timeout']
-    results = None
-    errors = {}
-    if reduce_func is None:
-        results = [None] * len(values)
-
-    try:
-        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
-               for value in values]
-
-        for n, job in enumerate(jobs):
-            remaining_time = min(end_time - time.time(), job_time)
-            try:
-                result = job.result(remaining_time)
-            except Exception as err:
-                if map_kw["fail_fast"]:
-                    raise err
-                else:
-                    errors[n] = err
-            else:
-                if reduce_func is not None:
-                    reduce_func(result)
-                else:
-                    results[n] = result
-            progress_bar.update()
-
-    except KeyboardInterrupt as e:
-        [job.cancel() for job in jobs]
-        raise e
-
-    except TimeoutError:
-        [job.cancel() for job in jobs]
-
-    finally:
-        executor.shutdown()
-    progress_bar.finished()
-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-    if errors:
-        raise MapExceptions(
-            f"{len(errors)} iterations failed in loky_pmap",
-            errors, results
-        )
-    return results
-
-
-_get_map = {
-    "parallel_map": parallel_map,
-    "parallel": parallel_map,
-    "serial_map": serial_map,
-    "serial": serial_map,
-    "loky": loky_pmap
-}
+"""
+This module provides functions for parallel execution of loops and function
+mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
+"""
+__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
+
+import multiprocessing
+import os
+import sys
+import time
+import threading
+import concurrent.futures
+from qutip.ui.progressbar import progess_bars
+from qutip.settings import available_cpu_count
+
+if sys.platform == 'darwin':
+    mp_context = multiprocessing.get_context('fork')
+elif sys.platform == 'linux':
+    # forkserver would handle threads better, but is much slower at starting
+    # the executor and spawning tasks
+    mp_context = multiprocessing.get_context('fork')
+else:
+    mp_context = multiprocessing.get_context()
+
+
+default_map_kw = {
+    'job_timeout': threading.TIMEOUT_MAX,
+    'timeout': threading.TIMEOUT_MAX,
+    'num_cpus': available_cpu_count(),
+    'fail_fast': True,
+}
+
+
+def _read_map_kw(options):
+    options = options or {}
+    map_kw = default_map_kw.copy()
+    map_kw.update({k: v for k, v in options.items() if v is not None})
+    return map_kw
+
+
+class MapExceptions(Exception):
+    def __init__(self, msg, errors, results):
+        super().__init__(msg, errors, results)
+        self.errors = errors
+        self.results = results
+
+
+def serial_map(task, values, task_args=None, task_kwargs=None,
+               reduce_func=None, map_kw=None,
+               progress_bar=None, progress_bar_kwargs={}):
+    """
+    Serial mapping function with the same call signature as parallel_map, for
+    easy switching between serial and parallel execution. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    reduce_func : func (optional)
+        If provided, it will be called with the output of each tasks instead of
+        storing a them in a list.
+    progress_bar : string
+        Progress bar options's string for showing progress.
+    progress_bar_kwargs : dict
+        Options for the progress bar.
+    map_kw: dict (optional)
+        Dictionary containing:
+        - timeout: float, Maximum time (sec) for the whole map.
+        - fail_fast: bool, Raise an error at the first.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for each
+        value in ``values``. If a ``reduce_func`` is provided, and empty list
+        will be returned.
+
+    """
+    if task_args is None:
+        task_args = ()
+    if task_kwargs is None:
+        task_kwargs = {}
+    map_kw = _read_map_kw(map_kw)
+    progress_bar = progess_bars[progress_bar]()
+    progress_bar.start(len(values), **progress_bar_kwargs)
+    end_time = map_kw['timeout'] + time.time()
+    results = None
+    if reduce_func is None:
+        results = [None] * len(values)
+    errors = {}
+    for n, value in enumerate(values):
+        if time.time() > end_time:
+            break
+        progress_bar.update(n)
+        try:
+            result = task(value, *task_args, **task_kwargs)
+        except Exception as err:
+            if map_kw["fail_fast"]:
+                raise err
+            else:
+                errors[n] = err
+        else:
+            if reduce_func is not None:
+                reduce_func(result)
+            else:
+                results[n] = result
+    progress_bar.finished()
+
+    if errors:
+        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
+                            errors, results)
+    return results
+
+
+def parallel_map(task, values, task_args=None, task_kwargs=None,
+                 reduce_func=None, map_kw=None,
+                 progress_bar=None, progress_bar_kwargs={}):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    reduce_func : func (optional)
+        If provided, it will be called with the output of each tasks instead of
+        storing a them in a list. Note that the order in which results are
+        passed to ``reduce_func`` is not defined.
+    progress_bar : string
+        Progress bar options's string for showing progress.
+    progress_bar_kwargs : dict
+        Options for the progress bar.
+    map_kw: dict (optional)
+        Dictionary containing entry for:
+        - timeout: float, Maximum time (sec) for the whole map.
+        - job_timeout: float, Maximum time (sec) for each job in the map.
+        - num_cpus: int, Number of job to run at once.
+        - fail_fast: bool, Raise an error at the first.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``. If a ``reduce_func`` is provided, and empty
+        list will be returned.
+
+    """
+    if task_args is None:
+        task_args = ()
+    if task_kwargs is None:
+        task_kwargs = {}
+    map_kw = _read_map_kw(map_kw)
+    end_time = map_kw['timeout'] + time.time()
+    job_time = map_kw['job_timeout']
+
+    progress_bar = progess_bars[progress_bar]()
+    progress_bar.start(len(values), **progress_bar_kwargs)
+
+    errors = {}
+    if reduce_func is not None:
+        results = None
+        result_func = lambda i, value: reduce_func(value)
+    else:
+        results = [None] * len(values)
+        result_func = lambda i, value: results.__setitem__(i, value)
+
+    def _done_callback(future):
+        if not future.cancelled():
+            try:
+                result = future.result()
+            except Exception as e:
+                errors[future._i] = e
+        result_func(future._i, result)
+        progress_bar.update()
+
+    if sys.version_info >= (3, 7):
+        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
+        ctx_kw = {"mp_context": mp_context}
+    else:
+        ctx_kw = {}
+
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    try:
+        with concurrent.futures.ProcessPoolExecutor(
+            max_workers=map_kw['num_cpus'], **ctx_kw,
+        ) as executor:
+            waiting = set()
+            i = 0
+            while i < len(values):
+                # feed values to the executor, ensuring that there is at
+                # most one task per worker at any moment in time so that
+                # we can shutdown without waiting for greater than the time
+                # taken by the longest task
+                if len(waiting) >= map_kw['num_cpus']:
+                    # no space left, wait for a task to complete or
+                    # the time to run out
+                    timeout = max(0, end_time - time.time())
+                    _done, waiting = concurrent.futures.wait(
+                        waiting,
+                        timeout=timeout,
+                        return_when=concurrent.futures.FIRST_COMPLETED,
+                    )
+                if time.time() >= end_time or (errors and map_kw['fail_fast']):
+                    # no time left, exit the loop
+                    break
+                while len(waiting) < map_kw['num_cpus'] and i < len(values):
+                    # space and time available, add tasks
+                    value = values[i]
+                    future = executor.submit(
+                        task, *((value,) + task_args), **task_kwargs,
+                    )
+                    # small hack to avoid add_done_callback not supporting
+                    # extra arguments and closures inside loops retaining
+                    # a reference not a value:
+                    future._i = i
+                    future.add_done_callback(_done_callback)
+                    waiting.add(future)
+                    i += 1
+
+            timeout = max(0, end_time - time.time())
+            concurrent.futures.wait(waiting, timeout=timeout)
+    finally:
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+
+    progress_bar.finished()
+    if errors and map_kw["fail_fast"]:
+        raise list(errors.values())[0]
+    elif errors:
+        raise MapExceptions(
+            f"{len(errors)} iterations failed in parallel_map",
+            errors, results
+        )
+
+    return results
+
+
+def loky_pmap(task, values, task_args=None, task_kwargs=None,
+              reduce_func=None, map_kw=None,
+              progress_bar=None, progress_bar_kwargs={}):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    Use the loky module instead of multiprocessing.
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    reduce_func : func (optional)
+        If provided, it will be called with the output of each tasks instead of
+        storing a them in a list.
+    progress_bar : string
+        Progress bar options's string for showing progress.
+    progress_bar_kwargs : dict
+        Options for the progress bar.
+    map_kw: dict (optional)
+        Dictionary containing entry for:
+        - timeout: float, Maximum time (sec) for the whole map.
+        - job_timeout: float, Maximum time (sec) for each job in the map.
+        - num_cpus: int, Number of job to run at once.
+        - fail_fast: bool, Raise an error at the first.
+
+    Returns
+    --------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``. If a ``reduce_func`` is provided, and empty
+        list will be returned.
+
+    """
+    if task_args is None:
+        task_args = ()
+    if task_kwargs is None:
+        task_kwargs = {}
+    map_kw = _read_map_kw(map_kw)
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    from loky import get_reusable_executor, TimeoutError
+
+    progress_bar = progess_bars[progress_bar]()
+    progress_bar.start(len(values), **progress_bar_kwargs)
+
+    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
+    end_time = map_kw['timeout'] + time.time()
+    job_time = map_kw['job_timeout']
+    results = None
+    errors = {}
+    if reduce_func is None:
+        results = [None] * len(values)
+
+    try:
+        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
+               for value in values]
+
+        for n, job in enumerate(jobs):
+            remaining_time = min(end_time - time.time(), job_time)
+            try:
+                result = job.result(remaining_time)
+            except Exception as err:
+                if map_kw["fail_fast"]:
+                    raise err
+                else:
+                    errors[n] = err
+            else:
+                if reduce_func is not None:
+                    reduce_func(result)
+                else:
+                    results[n] = result
+            progress_bar.update()
+
+    except KeyboardInterrupt as e:
+        [job.cancel() for job in jobs]
+        raise e
+
+    except TimeoutError:
+        [job.cancel() for job in jobs]
+
+    finally:
+        executor.shutdown()
+    progress_bar.finished()
+    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+    if errors:
+        raise MapExceptions(
+            f"{len(errors)} iterations failed in loky_pmap",
+            errors, results
+        )
+    return results
+
+
+_get_map = {
+    "parallel_map": parallel_map,
+    "parallel": parallel_map,
+    "serial_map": serial_map,
+    "serial": serial_map,
+    "loky": loky_pmap
+}
diff --git a/qutip/solver/propagator.py b/qutip/solver/propagator.py
index 179c0dcef0..5ad10b6c6a 100644
--- a/qutip/solver/propagator.py
+++ b/qutip/solver/propagator.py
@@ -1,278 +1,278 @@
-__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
-
-import numbers
-import numpy as np
-
-from .. import Qobj, qeye, unstack_columns, QobjEvo
-from ..core import data as _data
-from .mesolve import mesolve, MESolver
-from .sesolve import sesolve, SESolver
-from .heom.bofin_solvers import HEOMSolver
-from .solver_base import Solver
-from .multitraj import MultiTrajSolver
-
-
-def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
-    r"""
-    Calculate the propagator U(t) for the density matrix or wave function such
-    that :math:`\psi(t) = U(t)\psi(0)` or
-    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
-    where :math:`\rho_{\mathrm vec}` is the vector representation of the
-    density matrix.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    t : float or array-like
-        Time or list of times for which to evaluate the propagator.
-
-    c_ops : list, optional
-        List of Qobj or QobjEvo collapse operators.
-
-    args : dictionary, optional
-        Parameters to callback functions for time-dependent Hamiltonians and
-        collapse operators.
-
-    options : dict, optional
-        Options for the solver.
-
-    **kwargs :
-        Extra parameters to use when creating the :class:`QobjEvo` from a list
-        format ``H``.
-
-    Returns
-    -------
-    U : qobj, list
-        Instance representing the propagator(s) :math:`U(t)`. Return a single
-        Qobj when ``t`` is a number or a list when ``t`` is a list.
-
-    """
-    if isinstance(t, numbers.Real):
-        tlist = [0, t]
-        list_output = False
-    else:
-        tlist = t
-        list_output = True
-
-    if not isinstance(H, (Qobj, QobjEvo)):
-        H = QobjEvo(H, args=args, **kwargs)
-
-    if H.issuper or c_ops:
-        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
-                      args=args, options=options).states
-    else:
-        out = sesolve(H, qeye(H.dims[0]), tlist,
-                      args=args, options=options).states
-
-    if list_output:
-        return out
-    else:
-        return out[-1]
-
-
-def propagator_steadystate(U):
-    r"""Find the steady state for successive applications of the propagator
-    :math:`U`.
-
-    Parameters
-    ----------
-    U : qobj
-        Operator representing the propagator.
-
-    Returns
-    -------
-    a : qobj
-        Instance representing the steady-state density matrix.
-    """
-    evals, estates = U.eigenstates()
-    shifted_vals = np.abs(evals - 1.0)
-    ev_idx = np.argmin(shifted_vals)
-    rho_data = unstack_columns(estates[ev_idx].data)
-    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
-    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
-                dims=U.dims[0],
-                type='oper',
-                isherm=True,
-                copy=False)
-
-
-class Propagator:
-    """
-    A generator of propagator for a system.
-
-    Usage:
-        U = Propagator(H, c_ops)
-        psi_t = U(t) @ psi_0
-
-    Save some previously computed propagator are stored to speed up subsequent
-    computation. Changing ``args`` will erase these stored probagator.
-
-    Parameters
-    ----------
-    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
-        Possibly time-dependent system driving the evolution, either already
-        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
-        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
-        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
-        be made into :class:`QobjEvo` are also accepted.
-
-        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
-        not supported.
-
-    c_ops : list, optional
-        List of Qobj or QobjEvo collapse operators.
-
-    args : dictionary
-        Parameters to callback functions for time-dependent Hamiltonians and
-        collapse operators.
-
-    options : dict
-        Options for the solver.
-
-    memoize : int [10]
-        Max number of propagator to save.
-
-    tol : float [1e-14]
-        Absolute tolerance for the time. If a previous propagator was computed
-        at a time within tolerance, that propagator will be returned.
-
-    .. note::
-        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
-        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
-        into a :class:`QobjEvo` with ::
-            U = QobjEvo(Propagator(H))
-    """
-    def __init__(self, system, *, c_ops=(), args=None, options=None,
-                 memoize=10, tol=1e-14):
-        if isinstance(system, MultiTrajSolver):
-            raise TypeError("Non-deterministic solvers cannot be used "
-                            "as a propagator system")
-        elif isinstance(system, HEOMSolver):
-            raise NotImplementedError(
-                "HEOM is not supported by Propagator. "
-                "Please, tell us on GitHub issues if you need it!"
-            )
-        elif isinstance(system, Solver):
-            self.solver = system
-        else:
-            Hevo = QobjEvo(system, args=args)
-            c_ops = [QobjEvo(op, args=args) for op in c_ops]
-            if Hevo.issuper or c_ops:
-                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
-            else:
-                self.solver = SESolver(Hevo, options=options)
-
-        self.times = [0]
-        self.invs = [None]
-        self.props = [qeye(self.solver.sys_dims)]
-        self.solver.start(self.props[0], self.times[0])
-        self.cte = self.solver.rhs.isconstant
-        H_0 = self.solver.rhs(0)
-        self.unitary = not H_0.issuper and H_0.isherm
-        self.args = args
-        self.memoize = max(3, int(memoize))
-        self.tol = tol
-
-    def _lookup_or_compute(self, t):
-        """
-        Get U(t) from cache or compute it.
-        """
-        idx = np.searchsorted(self.times, t)
-        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
-            U = self.props[idx]
-        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
-            U = self.props[idx-1]
-        else:
-            U = self._compute(t, idx)
-            self._insert(t, U, idx)
-        return U
-
-    def __call__(self, t, t_start=0, **args):
-        """
-        Get the propagator from ``t_start`` to ``t``.
-
-        Parameters
-        ----------
-        t : float
-            Time at which to compute the propagator.
-        t_start: float [0]
-            Time at which the propagator start such that:
-                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
-        args : dict
-            Argument to pass to a time dependent Hamiltonian.
-            Updating ``args`` take effect since ``t=0`` and the new ``args``
-            will be used in future call.
-        """
-        # We could improve it when the system is constant using U(2t) = U(t)**2
-        if not self.cte and args and args != self.args:
-            self.args = args
-            self.solver._argument(args)
-            self.times = [0]
-            self.props = [qeye(self.props[0].dims[0])]
-            self.solver.start(self.props[0], self.times[0])
-
-        if t_start:
-            if t == t_start:
-                U = self._lookup_or_compute(0)
-            if self.cte:
-                U = self._lookup_or_compute(t - t_start)
-            else:
-                Uinv = self._inv(self._lookup_or_compute(t_start))
-                U = self._lookup_or_compute(t) @ Uinv
-        else:
-            U = self._lookup_or_compute(t)
-        return U
-
-    def inv(self, t, **args):
-        """
-        Get the inverse of the propagator at ``t``, such that
-            ``psi_0 = U.inv(t) @ psi_t``
-
-        Parameters
-        ----------
-        t : float
-            Time at which to compute the propagator.
-        args : dict
-            Argument to pass to a time dependent Hamiltonian.
-            Updating ``args`` take effect since ``t=0`` and the new ``args``
-            will be used in future call.
-        """
-        return self._inv(self(t, **args))
-
-    def _compute(self, t, idx):
-        """
-        Compute the propagator at ``t``, ``idx`` point to a pair of
-        (time, propagator) close to the desired time.
-        """
-        t_last = self.solver._integrator.get_state(copy=False)[0]
-        if self.times[idx-1] <= t_last <= t:
-            U = self.solver.step(t)
-        elif idx > 0:
-            self.solver.start(self.props[idx-1], self.times[idx-1])
-            U = self.solver.step(t)
-        else:
-            # Evolving backward in time is not supported by all integrator.
-            self.solver.start(qeye(self.props[0].dims[0]), t)
-            Uinv = self.solver.step(self.times[idx])
-            U = self._inv(Uinv)
-        return U
-
-    def _inv(self, U):
-        return U.dag() if self.unitary else U.inv()
-
-    def _insert(self, t, U, idx):
-        """
-        Insert a new pair of (time, propagator) to the memorized states.
-        """
-        while len(self.times) >= self.memoize:
-            rm_idx = self.memoize // 2
-            if self.times[rm_idx] < t:
-                idx -= 1
-            del self.times[rm_idx]
-            del self.props[rm_idx]
-        self.times.insert(idx, t)
-        self.props.insert(idx, U)
+__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
+
+import numbers
+import numpy as np
+
+from .. import Qobj, qeye, unstack_columns, QobjEvo
+from ..core import data as _data
+from .mesolve import mesolve, MESolver
+from .sesolve import sesolve, SESolver
+from .heom.bofin_solvers import HEOMSolver
+from .solver_base import Solver
+from .multitraj import MultiTrajSolver
+
+
+def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
+    r"""
+    Calculate the propagator U(t) for the density matrix or wave function such
+    that :math:`\psi(t) = U(t)\psi(0)` or
+    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
+    where :math:`\rho_{\mathrm vec}` is the vector representation of the
+    density matrix.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    t : float or array-like
+        Time or list of times for which to evaluate the propagator.
+
+    c_ops : list, optional
+        List of Qobj or QobjEvo collapse operators.
+
+    args : dictionary, optional
+        Parameters to callback functions for time-dependent Hamiltonians and
+        collapse operators.
+
+    options : dict, optional
+        Options for the solver.
+
+    **kwargs :
+        Extra parameters to use when creating the :class:`QobjEvo` from a list
+        format ``H``.
+
+    Returns
+    -------
+    U : qobj, list
+        Instance representing the propagator(s) :math:`U(t)`. Return a single
+        Qobj when ``t`` is a number or a list when ``t`` is a list.
+
+    """
+    if isinstance(t, numbers.Real):
+        tlist = [0, t]
+        list_output = False
+    else:
+        tlist = t
+        list_output = True
+
+    if not isinstance(H, (Qobj, QobjEvo)):
+        H = QobjEvo(H, args=args, **kwargs)
+
+    if H.issuper or c_ops:
+        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
+                      args=args, options=options).states
+    else:
+        out = sesolve(H, qeye(H.dims[0]), tlist,
+                      args=args, options=options).states
+
+    if list_output:
+        return out
+    else:
+        return out[-1]
+
+
+def propagator_steadystate(U):
+    r"""Find the steady state for successive applications of the propagator
+    :math:`U`.
+
+    Parameters
+    ----------
+    U : qobj
+        Operator representing the propagator.
+
+    Returns
+    -------
+    a : qobj
+        Instance representing the steady-state density matrix.
+    """
+    evals, estates = U.eigenstates()
+    shifted_vals = np.abs(evals - 1.0)
+    ev_idx = np.argmin(shifted_vals)
+    rho_data = unstack_columns(estates[ev_idx].data)
+    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
+    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
+                dims=U.dims[0],
+                type='oper',
+                isherm=True,
+                copy=False)
+
+
+class Propagator:
+    """
+    A generator of propagator for a system.
+
+    Usage:
+        U = Propagator(H, c_ops)
+        psi_t = U(t) @ psi_0
+
+    Save some previously computed propagator are stored to speed up subsequent
+    computation. Changing ``args`` will erase these stored probagator.
+
+    Parameters
+    ----------
+    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
+        Possibly time-dependent system driving the evolution, either already
+        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
+        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
+        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
+        be made into :class:`QobjEvo` are also accepted.
+
+        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
+        not supported.
+
+    c_ops : list, optional
+        List of Qobj or QobjEvo collapse operators.
+
+    args : dictionary
+        Parameters to callback functions for time-dependent Hamiltonians and
+        collapse operators.
+
+    options : dict
+        Options for the solver.
+
+    memoize : int [10]
+        Max number of propagator to save.
+
+    tol : float [1e-14]
+        Absolute tolerance for the time. If a previous propagator was computed
+        at a time within tolerance, that propagator will be returned.
+
+    .. note::
+        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
+        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
+        into a :class:`QobjEvo` with ::
+            U = QobjEvo(Propagator(H))
+    """
+    def __init__(self, system, *, c_ops=(), args=None, options=None,
+                 memoize=10, tol=1e-14):
+        if isinstance(system, MultiTrajSolver):
+            raise TypeError("Non-deterministic solvers cannot be used "
+                            "as a propagator system")
+        elif isinstance(system, HEOMSolver):
+            raise NotImplementedError(
+                "HEOM is not supported by Propagator. "
+                "Please, tell us on GitHub issues if you need it!"
+            )
+        elif isinstance(system, Solver):
+            self.solver = system
+        else:
+            Hevo = QobjEvo(system, args=args)
+            c_ops = [QobjEvo(op, args=args) for op in c_ops]
+            if Hevo.issuper or c_ops:
+                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
+            else:
+                self.solver = SESolver(Hevo, options=options)
+
+        self.times = [0]
+        self.invs = [None]
+        self.props = [qeye(self.solver.sys_dims)]
+        self.solver.start(self.props[0], self.times[0])
+        self.cte = self.solver.rhs.isconstant
+        H_0 = self.solver.rhs(0)
+        self.unitary = not H_0.issuper and H_0.isherm
+        self.args = args
+        self.memoize = max(3, int(memoize))
+        self.tol = tol
+
+    def _lookup_or_compute(self, t):
+        """
+        Get U(t) from cache or compute it.
+        """
+        idx = np.searchsorted(self.times, t)
+        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
+            U = self.props[idx]
+        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
+            U = self.props[idx-1]
+        else:
+            U = self._compute(t, idx)
+            self._insert(t, U, idx)
+        return U
+
+    def __call__(self, t, t_start=0, **args):
+        """
+        Get the propagator from ``t_start`` to ``t``.
+
+        Parameters
+        ----------
+        t : float
+            Time at which to compute the propagator.
+        t_start: float [0]
+            Time at which the propagator start such that:
+                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
+        args : dict
+            Argument to pass to a time dependent Hamiltonian.
+            Updating ``args`` take effect since ``t=0`` and the new ``args``
+            will be used in future call.
+        """
+        # We could improve it when the system is constant using U(2t) = U(t)**2
+        if not self.cte and args and args != self.args:
+            self.args = args
+            self.solver._argument(args)
+            self.times = [0]
+            self.props = [qeye(self.props[0].dims[0])]
+            self.solver.start(self.props[0], self.times[0])
+
+        if t_start:
+            if t == t_start:
+                U = self._lookup_or_compute(0)
+            if self.cte:
+                U = self._lookup_or_compute(t - t_start)
+            else:
+                Uinv = self._inv(self._lookup_or_compute(t_start))
+                U = self._lookup_or_compute(t) @ Uinv
+        else:
+            U = self._lookup_or_compute(t)
+        return U
+
+    def inv(self, t, **args):
+        """
+        Get the inverse of the propagator at ``t``, such that
+            ``psi_0 = U.inv(t) @ psi_t``
+
+        Parameters
+        ----------
+        t : float
+            Time at which to compute the propagator.
+        args : dict
+            Argument to pass to a time dependent Hamiltonian.
+            Updating ``args`` take effect since ``t=0`` and the new ``args``
+            will be used in future call.
+        """
+        return self._inv(self(t, **args))
+
+    def _compute(self, t, idx):
+        """
+        Compute the propagator at ``t``, ``idx`` point to a pair of
+        (time, propagator) close to the desired time.
+        """
+        t_last = self.solver._integrator.get_state(copy=False)[0]
+        if self.times[idx-1] <= t_last <= t:
+            U = self.solver.step(t)
+        elif idx > 0:
+            self.solver.start(self.props[idx-1], self.times[idx-1])
+            U = self.solver.step(t)
+        else:
+            # Evolving backward in time is not supported by all integrator.
+            self.solver.start(qeye(self.props[0].dims[0]), t)
+            Uinv = self.solver.step(self.times[idx])
+            U = self._inv(Uinv)
+        return U
+
+    def _inv(self, U):
+        return U.dag() if self.unitary else U.inv()
+
+    def _insert(self, t, U, idx):
+        """
+        Insert a new pair of (time, propagator) to the memorized states.
+        """
+        while len(self.times) >= self.memoize:
+            rm_idx = self.memoize // 2
+            if self.times[rm_idx] < t:
+                idx -= 1
+            del self.times[rm_idx]
+            del self.props[rm_idx]
+        self.times.insert(idx, t)
+        self.props.insert(idx, U)
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index a87ad9206c..c6360d4e77 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1,972 +1,972 @@
-""" Class for solve function results"""
-import numpy as np
-from ..core import Qobj, QobjEvo, expect, qzero
-
-__all__ = ["Result", "MultiTrajResult", "McResult"]
-
-
-class _QobjExpectEop:
-    """
-    Pickable e_ops callable that calculates the expectation value for a given
-    operator.
-
-    Parameters
-    ----------
-    op : :obj:`~Qobj`
-        The expectation value operator.
-    """
-    def __init__(self, op):
-        self.op = op
-
-    def __call__(self, t, state):
-        return expect(self.op, state)
-
-
-class ExpectOp:
-    """
-    A result e_op (expectation operation).
-
-    Parameters
-    ----------
-    op : object
-        The original object used to define the e_op operation, e.g. a
-        :~obj:`Qobj` or a function ``f(t, state)``.
-
-    f : function
-        A callable ``f(t, state)`` that will return the value of the e_op
-        for the specified state and time.
-
-    append : function
-        A callable ``append(value)``, e.g. ``expect[k].append``, that will
-        store the result of the e_ops function ``f(t, state)``.
-
-    Attributes
-    ----------
-    op : object
-        The original object used to define the e_op operation.
-    """
-    def __init__(self, op, f, append):
-        self.op = op
-        self._f = f
-        self._append = append
-
-    def __call__(self, t, state):
-        """
-        Return the expectation value for the given time, ``t`` and
-        state, ``state``.
-        """
-        return self._f(t, state)
-
-    def _store(self, t, state):
-        """
-        Store the result of the e_op function. Should only be called by
-        :class:`~Result`.
-        """
-        self._append(self._f(t, state))
-
-
-class _BaseResult:
-    """
-    Common method for all ``Result``.
-    """
-    def __init__(self, options, *, solver=None, stats=None):
-        self.solver = solver
-        if stats is None:
-            stats = {}
-        self.stats = stats
-
-        self._state_processors = []
-        self._state_processors_require_copy = False
-
-        self.options = options
-
-    def _e_ops_to_dict(self, e_ops):
-        """ Convert the supplied e_ops to a dictionary of Eop instances. """
-        if e_ops is None:
-            e_ops = {}
-        elif isinstance(e_ops, (list, tuple)):
-            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
-        elif isinstance(e_ops, dict):
-            pass
-        else:
-            e_ops = {0: e_ops}
-        return e_ops
-
-    def add_processor(self, f, requires_copy=False):
-        """
-        Append a processor ``f`` to the list of state processors.
-
-        Parameters
-        ----------
-        f : function, ``f(t, state)``
-            A function to be called each time a state is added to this
-            result object. The state is the state passed to ``.add``, after
-            applying the pre-processors, if any.
-
-        requires_copy : bool, default False
-            Whether this processor requires a copy of the state rather than
-            a reference. A processor must never modify the supplied state, but
-            if a processor stores the state it should set ``require_copy`` to
-            true.
-        """
-        self._state_processors.append(f)
-        self._state_processors_require_copy |= requires_copy
-
-
-class Result(_BaseResult):
-    """
-    Base class for storing solver results.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``e_data`` and ``expect`` attributes of
-        this result object. ``e_data`` is a dictionary and ``expect`` is a
-        list, where each item contains the values of the corresponding
-        ``e_op``.
-
-    options : dict
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Attributes
-    ----------
-    times : list
-        A list of the times at which the expectation values and states were
-        recorded.
-
-    states : list of :obj:`~Qobj`
-        The state at each time ``t`` (if the recording of the state was
-        requested).
-
-    final_state : :obj:`~Qobj`:
-        The final state (if the recording of the final state was requested).
-
-    expect : list of arrays of expectation values
-        A list containing the values of each ``e_op``. The list is in
-        the same order in which the ``e_ops`` were supplied and empty if
-        no ``e_ops`` were given.
-
-        Each element is itself a list and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-        The same lists of values may be accessed via the ``.e_data`` dictionary
-        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
-
-    e_data : dict
-        A dictionary containing the values of each ``e_op``. If the ``e_ops``
-        were supplied as a dictionary, the keys are the same as in
-        that dictionary. Otherwise the keys are the index of the ``e_op``
-        in the ``.expect`` list.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    e_ops : dict
-        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
-        The keys of the dictionary are the same as for ``.e_data``.
-        Each value is object where ``.e_ops[k](t, state)`` calculates the
-        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
-        ``.e_ops[k].op`` is the original object supplied to create the
-        ``e_op``.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results.
-
-    options : dict
-        The options for this result class.
-    """
-    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
-        super().__init__(options, solver=solver, stats=stats)
-        raw_ops = self._e_ops_to_dict(e_ops)
-        self.e_data = {k: [] for k in raw_ops}
-        self.e_ops = {}
-        for k, op in raw_ops.items():
-            f = self._e_op_func(op)
-            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
-            self.add_processor(self.e_ops[k]._store)
-
-        self.times = []
-        self.states = []
-        self.final_state = None
-
-        self._post_init(**kw)
-
-    def _e_op_func(self, e_op):
-        """
-        Convert an e_op entry into a function, ``f(t, state)`` that returns
-        the appropriate value (usually an expectation value).
-
-        Sub-classes may override this function to calculate expectation values
-        in different ways.
-        """
-        if isinstance(e_op, Qobj):
-            return _QobjExpectEop(e_op)
-        elif isinstance(e_op, QobjEvo):
-            return e_op.expect
-        elif callable(e_op):
-            return e_op
-        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
-
-    def _post_init(self):
-        """
-        Perform post __init__ initialisation. In particular, add state
-        processors or pre-processors.
-
-        Sub-class may override this. If the sub-class wishes to register the
-        default processors for storing states, it should call this parent
-        ``.post_init()`` method.
-
-        Sub-class ``.post_init()`` implementation may take additional keyword
-        arguments if required.
-        """
-        store_states = self.options['store_states']
-        store_final_state = self.options['store_final_state']
-
-        if store_states is None:
-            store_states = len(self.e_ops) == 0
-        if store_states:
-            self.add_processor(self._store_state, requires_copy=True)
-
-        if store_states or store_final_state:
-            self.add_processor(self._store_final_state, requires_copy=True)
-
-    def _store_state(self, t, state):
-        """ Processor that stores a state in ``.states``. """
-        self.states.append(state)
-
-    def _store_final_state(self, t, state):
-        """ Processor that writes the state to ``.final_state``. """
-        self.final_state = state
-
-    def _pre_copy(self, state):
-        """ Return a copy of the state. Sub-classes may override this to
-            copy a state in different manner or to skip making a copy
-            altogether if a copy is not necessary.
-        """
-        return state.copy()
-
-    def add(self, t, state):
-        """
-        Add a state to the results for the time ``t`` of the evolution.
-
-        Adding a state calculates the expectation value of the state for
-        each of the supplied ``e_ops`` and stores the result in ``.expect``.
-
-        The state is recorded in ``.states`` and ``.final_state`` if specified
-        by the supplied result options.
-
-        Parameters
-        ----------
-        t : float
-            The time of the added state.
-
-        state : typically a :obj:`~Qobj`
-            The state a time ``t``. Usually this is a :obj:`~Qobj` with
-            suitable dimensions, but it sub-classes of result might support
-            other forms of the state.
-
-        .. note::
-
-           The expectation values, i.e. ``e_ops``, and states are recorded by
-           the state processors (see ``.add_processor``).
-
-           Additional processors may be added by sub-classes.
-        """
-        self.times.append(t)
-
-        if self._state_processors_require_copy:
-            state = self._pre_copy(state)
-
-        for op in self._state_processors:
-            op(t, state)
-
-    def __repr__(self):
-        lines = [
-            f"<{self.__class__.__name__}",
-            f"  Solver: {self.solver}",
-        ]
-        if self.stats:
-            lines.append("  Solver stats:")
-            lines.extend(
-                f"    {k}: {v!r}"
-                for k, v in self.stats.items()
-            )
-        if self.times:
-            lines.append(
-                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
-                f" ({len(self.times)} steps)"
-            )
-        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
-        if self.states:
-            lines.append("  States saved.")
-        elif self.final_state is not None:
-            lines.append("  Final state saved.")
-        else:
-            lines.append("  State not saved.")
-        lines.append(">")
-        return "\n".join(lines)
-
-    @property
-    def expect(self):
-        return [np.array(e_op) for e_op in self.e_data.values()]
-
-
-class MultiTrajResult(_BaseResult):
-    """
-    Base class for storing results for solver using multiple trajectories.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``.expect`` attribute of this result
-        object. ``.expect`` is a list, where each item contains the values
-        of the corresponding ``e_op``.
-
-        Function ``e_ops`` must return a number so the average can be computed.
-
-    options : dict
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Properties
-    ----------
-    times : list
-        A list of the times at which the expectation values and states were
-        recorded.
-
-    average_states : list of :obj:`~Qobj`
-        The state at each time ``t`` (if the recording of the state was
-        requested) averaged over all trajectories as a density matrix.
-
-    runs_states : list of list of :obj:`~Qobj`
-        The state for each trajectory and each time ``t`` (if the recording of
-        the states and trajectories was requested)
-
-    final_state : :obj:`~Qobj:
-        The final state (if the recording of the final state was requested)
-        averaged over all trajectories as a density matrix.
-
-    runs_final_state : list of :obj:`~Qobj`
-        The final state for each trajectory (if the recording of the final
-        state and trajectories was requested).
-
-    average_expect : list of array of expectation values
-        A list containing the values of each ``e_op`` averaged over each
-        trajectories. The list is in the same order in which the ``e_ops`` were
-        supplied and empty if no ``e_ops`` were given.
-
-        Each element is itself an array and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-    std_expect : list of array of expectation values
-        A list containing the standard derivation of each ``e_op`` over each
-        trajectories. The list is in the same order in which the ``e_ops`` were
-        supplied and empty if no ``e_ops`` were given.
-
-        Each element is itself an array and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-    runs_expect : list of array of expectation values
-        A list containing the values of each ``e_op`` for each trajectories.
-        The list is in the same order in which the ``e_ops`` were
-        supplied and empty if no ``e_ops`` were given. Only available if the
-        storing of trajectories was requested.
-
-        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
-
-        Each element is itself an array and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-    average_e_data : dict
-        A dictionary containing the values of each ``e_op`` averaged over each
-        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
-        are the same as in that dictionary. Otherwise the keys are the index of
-        the ``e_op`` in the ``.expect`` list.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    average_e_data : dict
-        A dictionary containing the standard derivation of each ``e_op`` over
-        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
-        keys are the same as in that dictionary. Otherwise the keys are the
-        index of the ``e_op`` in the ``.expect`` list.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    runs_e_data : dict
-        A dictionary containing the values of each ``e_op`` for each
-        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
-        are the same as in that dictionary. Otherwise the keys are the index of
-        the ``e_op`` in the ``.expect`` list. Only available if the storing
-        of trajectories was requested.
-
-        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results.
-
-    options : :obj:`~SolverResultsOptions`
-        The options for this result class.
-    """
-    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
-        super().__init__(options, solver=solver, stats=stats)
-        self._raw_ops = self._e_ops_to_dict(e_ops)
-
-        self.times = []
-        self.trajectories = []
-        self.num_trajectories = 0
-        self.seeds = []
-
-        self._sum_states = None
-        self._sum_final_states = None
-        self._sum_expect = None
-        self._sum2_expect = None
-        self._target_tols = None
-
-        self.average_e_data = {}
-        self.e_data = {}
-        self.std_e_data = {}
-        self.runs_e_data = {}
-
-        self._post_init(**kw)
-
-    @staticmethod
-    def _to_dm(state):
-        if state.type == 'ket':
-            state = state.proj()
-        return state
-
-    def _add_first_traj(self, trajectory):
-        """
-        Read the first trajectory, intitializing needed data.
-        """
-        self.times = trajectory.times
-
-        if trajectory.states:
-            state = trajectory.states[0]
-            self._sum_states = [qzero(state.dims[0])
-                                for state in trajectory.states]
-        if trajectory.final_state:
-            state = trajectory.final_state
-            self._sum_final_states = qzero(state.dims[0])
-
-        self._sum_expect = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
-        self._sum2_expect = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
-
-        self.e_ops = trajectory.e_ops
-
-        self.average_e_data = {
-            k: list(avg_expect)
-            for k, avg_expect
-            in zip(self._raw_ops, self._sum_expect)
-        }
-        self.e_data = self.average_e_data
-        if self.options['keep_runs_results']:
-            self.runs_e_data = {k: [] for k in self._raw_ops}
-            self.e_data = self.runs_e_data
-
-    def _store_trajectory(self, trajectory):
-        self.trajectories.append(trajectory)
-
-    def _reduce_states(self, trajectory):
-        self._sum_states = [
-            accu + self._to_dm(state)
-            for accu, state
-            in zip(self._sum_states, trajectory.states)
-        ]
-
-    def _reduce_final_state(self, trajectory):
-        self._sum_final_states += self._to_dm(trajectory.final_state)
-
-    def _reduce_expect(self, trajectory):
-        """
-        Compute the average of the expectation values and store it in it's
-        multiple formats.
-        """
-        for i, k in enumerate(self._raw_ops):
-            expect_traj = trajectory.expect[i]
-
-            self._sum_expect[i] += expect_traj
-            self._sum2_expect[i] += expect_traj**2
-
-            avg = self._sum_expect[i] / self.num_trajectories
-            avg2 = self._sum2_expect[i] / self.num_trajectories
-
-            self.average_e_data[k] = list(avg)
-
-            # mean(expect**2) - mean(expect)**2 can something be very small
-            # negative (-1e-15) which raise an error for float sqrt.
-            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
-
-            if self.runs_e_data:
-                self.runs_e_data[k].append(trajectory.e_data[k])
-
-    def _increment_traj(self, trajectory):
-        if self.num_trajectories == 0:
-            self._add_first_traj(trajectory)
-        self.num_trajectories += 1
-
-    def _no_end(self):
-        """
-        Remaining number of trajectories needed to finish cannot be determined
-        by this object.
-        """
-        return np.inf
-
-    def _fixed_end(self):
-        """
-        Finish at a known number of trajectories.
-        """
-        ntraj_left = self._target_ntraj - self.num_trajectories
-        if ntraj_left == 0:
-            self.stats['end_condition'] = 'ntraj reached'
-        return ntraj_left
-
-    def _target_tolerance_end(self):
-        """
-        Compute the error on the expectation values using jackknife resampling.
-        Return the approximate number of trajectories needed to have this
-        error within the tolerance fot all e_ops and times.
-        """
-        if self.num_trajectories <= 1:
-            return np.inf
-        avg = np.array(self._sum_expect) / self.num_trajectories
-        avg2 = np.array(self._sum2_expect) / self.num_trajectories
-        target = np.array([
-            atol + rtol * mean
-            for mean, (atol, rtol)
-            in zip(avg, self._target_tols)
-        ])
-        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
-
-        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
-        if (self._estimated_ntraj - self.num_trajectories) <= 0:
-            self.stats['end_condition'] = 'target tolerance reached'
-        return self._estimated_ntraj - self.num_trajectories
-
-    def _post_init(self):
-        self.num_trajectories = 0
-        self._target_ntraj = None
-
-        store_states = self.options['store_states']
-        store_final_state = self.options['store_final_state']
-        store_traj = self.options['keep_runs_results']
-
-        self.add_processor(self._increment_traj)
-        if store_traj:
-            self.add_processor(self._store_trajectory)
-        if store_states is None:
-            store_states = len(self._raw_ops) == 0
-        if store_states:
-            self.add_processor(self._reduce_states)
-        if store_states or store_final_state:
-            self.add_processor(self._reduce_final_state)
-        if self._raw_ops:
-            self.add_processor(self._reduce_expect)
-
-        self._early_finish_check = self._no_end
-        self.stats['end_condition'] = 'unknown'
-
-    def add(self, trajectory_info):
-        """
-        Add a trajectory to the evolution.
-
-        Trajectories can be saved or average canbe extracted depending on the
-        options ``keep_runs_results``.
-
-        Parameters
-        ----------
-        trajectory_info : tuple of seed and trajectory
-            - seed: int, SeedSequence
-              Seed used to generate the trajectory.
-            - trajectory : :class:`Result`
-              Run result for one evolution over the times.
-
-        Return
-        ------
-        remaing_traj : number
-            Return the number of trajectories still needed to reach the target
-            tolerance. If no tolerance is provided, return infinity.
-        """
-        seed, trajectory = trajectory_info
-        self.seeds.append(seed)
-
-        for op in self._state_processors:
-            op(trajectory)
-
-        return self._early_finish_check()
-
-    def add_end_condition(self, ntraj, target_tol=None):
-        """
-        Set the condition to stop the computing trajectories when the certain
-        condition are fullfilled.
-        Supported end condition for multi trajectories computation are:
-        - Reaching a number of trajectories.
-        - Error bar on the expectation values reach smaller than a given
-          tolerance.
-
-        Parameters
-        ----------
-        ntraj : int
-            Number of trajectories expected.
-
-        target_tol : float, array_like, [optional]
-            Target tolerance of the evolution. The evolution will compute
-            trajectories until the error on the expectation values is lower
-            than this tolerance. The error is computed using jackknife
-            resampling. ``target_tol`` can be an absolute tolerance, a pair of
-            absolute and relative tolerance, in that order. Lastly, it can be a
-            list of pairs of (atol, rtol) for each e_ops.
-
-            Error estimation is done with jackknife resampling.
-        """
-        self._target_ntraj = ntraj
-        self.stats['end_condition'] = 'timeout'
-
-        if target_tol is None:
-            self._early_finish_check = self._fixed_end
-            return
-
-        num_e_ops = len(self._raw_ops)
-
-        if not num_e_ops:
-            raise ValueError("Cannot target a tolerance without e_ops")
-
-        self._estimated_ntraj = ntraj
-
-        targets = np.array(target_tol)
-        if targets.ndim == 0:
-            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
-        elif targets.shape == (2,):
-            self._target_tols = np.ones((num_e_ops, 2)) * targets
-        elif targets.shape == (num_e_ops, 2):
-            self._target_tols = targets
-        else:
-            raise ValueError("target_tol must be a number, a pair of (atol, "
-                             "rtol) or a list of (atol, rtol) for each e_ops")
-
-        self._early_finish_check = self._target_tolerance_end
-
-    @property
-    def runs_states(self):
-        """
-        States of every runs as ``states[run][t]``.
-        """
-        if self.trajectories and self.trajectories[0].states:
-            return [traj.states for traj in self.trajectories]
-        else:
-            return None
-
-    @property
-    def average_states(self):
-        """
-        States averages as density matrices.
-        """
-        if self._sum_states is None:
-            return None
-        return [final / self.num_trajectories for final in self._sum_states]
-
-    @property
-    def states(self):
-        """
-        Runs final states if available, average otherwise.
-        """
-        return self.runs_states or self.average_states
-
-    @property
-    def runs_final_states(self):
-        """
-        Last states of each trajectories.
-        """
-        if self.trajectories and self.trajectories[0].final_state:
-            return [traj.final_state for traj in self.trajectories]
-        else:
-            return None
-
-    @property
-    def average_final_state(self):
-        """
-        Last states of each trajectories averaged into a density matrix.
-        """
-        if self._sum_final_states is None:
-            return None
-        return self._sum_final_states / self.num_trajectories
-
-    @property
-    def final_state(self):
-        """
-        Runs final states if available, average otherwise.
-        """
-        return self.runs_final_states or self.average_final_state
-
-    @property
-    def average_expect(self):
-        return [np.array(val) for val in self.average_e_data.values()]
-
-    @property
-    def std_expect(self):
-        return [np.array(val) for val in self.std_e_data.values()]
-
-    @property
-    def runs_expect(self):
-        return [np.array(val) for val in self.runs_e_data.values()]
-
-    @property
-    def expect(self):
-        return [np.array(val) for val in self.e_data.values()]
-
-    def steady_state(self, N=0):
-        """
-        Average the states of the last ``N`` times of every runs as a density
-        matrix. Should converge to the steady state in the right circumstances.
-
-        Parameters
-        ----------
-        N : int [optional]
-            Number of states from the end of ``tlist`` to average. Per default
-            all states will be averaged.
-        """
-        N = int(N) or len(self.times)
-        N = len(self.times) if N > len(self.times) else N
-        states = self.average_states
-        if states is not None:
-            return sum(states[-N:]) / N
-        else:
-            return None
-
-    def __repr__(self):
-        lines = [
-            f"<{self.__class__.__name__}",
-            f"  Solver: {self.solver}",
-        ]
-        if self.stats:
-            lines.append("  Solver stats:")
-            lines.extend(
-                f"    {k}: {v!r}"
-                for k, v in self.stats.items()
-            )
-        if self.times:
-            lines.append(
-                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
-                f" ({len(self.times)} steps)"
-            )
-        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
-        if self.states:
-            lines.append("  States saved.")
-        elif self.final_state is not None:
-            lines.append("  Final state saved.")
-        else:
-            lines.append("  State not saved.")
-        lines.append(f"  Number of trajectories: {self.num_trajectories}")
-        if self.trajectories:
-            lines.append("  Trajectories saved.")
-        else:
-            lines.append("  Trajectories not saved.")
-        lines.append(">")
-        return "\n".join(lines)
-
-    def __add__(self, other):
-        if not isinstance(other, MultiTrajResult):
-            return NotImplemented
-        if self._raw_ops != other._raw_ops:
-            raise ValueError("Shared `e_ops` is required to merge results")
-        if self.times != other.times:
-            raise ValueError("Shared `times` are is required to merge results")
-        new = self.__class__(self._raw_ops, self.options,
-                             solver=self.solver, stats=self.stats)
-        if self.trajectories and other.trajectories:
-            new.trajectories = self.trajectories + other.trajectories
-        new.num_trajectories = self.num_trajectories + other.num_trajectories
-        new.times = self.times
-        new.seeds = self.seeds + other.seeds
-
-        if self._sum_states is not None and other._sum_states is not None:
-            new._sum_states = self._sum_states + other._sum_states
-
-        if (
-            self._sum_final_states is not None
-            and other._sum_final_states is not None
-        ):
-            new._sum_final_states = (
-                self._sum_final_states + other._sum_final_states
-            )
-        new._target_tols = None
-
-        new._sum_expect = []
-        new._sum2_expect = []
-        new.average_e_data = {}
-        new.std_e_data = {}
-
-        for i, k in enumerate(self._raw_ops):
-            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
-            new._sum2_expect.append(self._sum2_expect[i]
-                                    + other._sum2_expect[i])
-
-            avg = new._sum_expect[i] / new.num_trajectories
-            avg2 = new._sum2_expect[i] / new.num_trajectories
-
-            new.average_e_data[k] = list(avg)
-            new.e_data = new.average_e_data
-
-            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
-
-            if new.trajectories:
-                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
-                new.e_data = new.runs_e_data
-
-        new.stats["run time"] += other.stats["run time"]
-        new.stats['end_condition'] = "Merged results"
-
-        return new
-
-
-class McResult(MultiTrajResult):
-    """
-    Base class for storing solver results.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``.expect`` attribute of this result
-        object. ``.expect`` is a list, where each item contains the values
-        of the corresponding ``e_op``.
-
-    options : :obj:`~SolverResultsOptions`
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-        Must include a value for "num_collapse".
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Properties
-    ----------
-    collapse : list
-        For each runs, a list of every collapse as a tuple of the time it
-        happened and the corresponding ``c_ops`` index.
-    """
-    # Collapse are only produced by mcsolve.
-
-    def _add_collapse(self, trajectory):
-        self.collapse.append(trajectory.collapse)
-
-    def _post_init(self):
-        super()._post_init()
-        self.num_c_ops = self.stats["num_collapse"]
-        self.collapse = []
-        self.add_processor(self._add_collapse)
-
-    @property
-    def col_times(self):
-        """
-        List of the times of the collapses for each runs.
-        """
-        out = []
-        for col_ in self.collapse:
-            col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[0])
-            out.append(col)
-        return out
-
-    @property
-    def col_which(self):
-        """
-        List of the indexes of the collapses for each runs.
-        """
-        out = []
-        for col_ in self.collapse:
-            col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[1])
-            out.append(col)
-        return out
-
-    @property
-    def photocurrent(self):
-        """
-        Average photocurrent or measurement of the evolution.
-        """
-        cols = [[] for _ in range(self.num_c_ops)]
-        tlist = self.times
-        for collapses in self.collapse:
-            for t, which in collapses:
-                cols[which].append(t)
-        mesurement = [
-            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
-            for i in range(self.num_c_ops)
-        ]
-        return mesurement
-
-    @property
-    def runs_photocurrent(self):
-        """
-        Photocurrent or measurement of each runs.
-        """
-        tlist = self.times
-        measurements = []
-        for collapses in self.collapse:
-            cols = [[] for _ in range(self.num_c_ops)]
-            for t, which in collapses:
-                cols[which].append(t)
-            measurements.append([
-                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
-                for i in range(self.num_c_ops)
-            ])
-        return measurements
+""" Class for solve function results"""
+import numpy as np
+from ..core import Qobj, QobjEvo, expect, qzero
+
+__all__ = ["Result", "MultiTrajResult", "McResult"]
+
+
+class _QobjExpectEop:
+    """
+    Pickable e_ops callable that calculates the expectation value for a given
+    operator.
+
+    Parameters
+    ----------
+    op : :obj:`~Qobj`
+        The expectation value operator.
+    """
+    def __init__(self, op):
+        self.op = op
+
+    def __call__(self, t, state):
+        return expect(self.op, state)
+
+
+class ExpectOp:
+    """
+    A result e_op (expectation operation).
+
+    Parameters
+    ----------
+    op : object
+        The original object used to define the e_op operation, e.g. a
+        :~obj:`Qobj` or a function ``f(t, state)``.
+
+    f : function
+        A callable ``f(t, state)`` that will return the value of the e_op
+        for the specified state and time.
+
+    append : function
+        A callable ``append(value)``, e.g. ``expect[k].append``, that will
+        store the result of the e_ops function ``f(t, state)``.
+
+    Attributes
+    ----------
+    op : object
+        The original object used to define the e_op operation.
+    """
+    def __init__(self, op, f, append):
+        self.op = op
+        self._f = f
+        self._append = append
+
+    def __call__(self, t, state):
+        """
+        Return the expectation value for the given time, ``t`` and
+        state, ``state``.
+        """
+        return self._f(t, state)
+
+    def _store(self, t, state):
+        """
+        Store the result of the e_op function. Should only be called by
+        :class:`~Result`.
+        """
+        self._append(self._f(t, state))
+
+
+class _BaseResult:
+    """
+    Common method for all ``Result``.
+    """
+    def __init__(self, options, *, solver=None, stats=None):
+        self.solver = solver
+        if stats is None:
+            stats = {}
+        self.stats = stats
+
+        self._state_processors = []
+        self._state_processors_require_copy = False
+
+        self.options = options
+
+    def _e_ops_to_dict(self, e_ops):
+        """ Convert the supplied e_ops to a dictionary of Eop instances. """
+        if e_ops is None:
+            e_ops = {}
+        elif isinstance(e_ops, (list, tuple)):
+            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
+        elif isinstance(e_ops, dict):
+            pass
+        else:
+            e_ops = {0: e_ops}
+        return e_ops
+
+    def add_processor(self, f, requires_copy=False):
+        """
+        Append a processor ``f`` to the list of state processors.
+
+        Parameters
+        ----------
+        f : function, ``f(t, state)``
+            A function to be called each time a state is added to this
+            result object. The state is the state passed to ``.add``, after
+            applying the pre-processors, if any.
+
+        requires_copy : bool, default False
+            Whether this processor requires a copy of the state rather than
+            a reference. A processor must never modify the supplied state, but
+            if a processor stores the state it should set ``require_copy`` to
+            true.
+        """
+        self._state_processors.append(f)
+        self._state_processors_require_copy |= requires_copy
+
+
+class Result(_BaseResult):
+    """
+    Base class for storing solver results.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``e_data`` and ``expect`` attributes of
+        this result object. ``e_data`` is a dictionary and ``expect`` is a
+        list, where each item contains the values of the corresponding
+        ``e_op``.
+
+    options : dict
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Attributes
+    ----------
+    times : list
+        A list of the times at which the expectation values and states were
+        recorded.
+
+    states : list of :obj:`~Qobj`
+        The state at each time ``t`` (if the recording of the state was
+        requested).
+
+    final_state : :obj:`~Qobj`:
+        The final state (if the recording of the final state was requested).
+
+    expect : list of arrays of expectation values
+        A list containing the values of each ``e_op``. The list is in
+        the same order in which the ``e_ops`` were supplied and empty if
+        no ``e_ops`` were given.
+
+        Each element is itself a list and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+        The same lists of values may be accessed via the ``.e_data`` dictionary
+        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
+
+    e_data : dict
+        A dictionary containing the values of each ``e_op``. If the ``e_ops``
+        were supplied as a dictionary, the keys are the same as in
+        that dictionary. Otherwise the keys are the index of the ``e_op``
+        in the ``.expect`` list.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    e_ops : dict
+        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
+        The keys of the dictionary are the same as for ``.e_data``.
+        Each value is object where ``.e_ops[k](t, state)`` calculates the
+        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
+        ``.e_ops[k].op`` is the original object supplied to create the
+        ``e_op``.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results.
+
+    options : dict
+        The options for this result class.
+    """
+    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
+        super().__init__(options, solver=solver, stats=stats)
+        raw_ops = self._e_ops_to_dict(e_ops)
+        self.e_data = {k: [] for k in raw_ops}
+        self.e_ops = {}
+        for k, op in raw_ops.items():
+            f = self._e_op_func(op)
+            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
+            self.add_processor(self.e_ops[k]._store)
+
+        self.times = []
+        self.states = []
+        self.final_state = None
+
+        self._post_init(**kw)
+
+    def _e_op_func(self, e_op):
+        """
+        Convert an e_op entry into a function, ``f(t, state)`` that returns
+        the appropriate value (usually an expectation value).
+
+        Sub-classes may override this function to calculate expectation values
+        in different ways.
+        """
+        if isinstance(e_op, Qobj):
+            return _QobjExpectEop(e_op)
+        elif isinstance(e_op, QobjEvo):
+            return e_op.expect
+        elif callable(e_op):
+            return e_op
+        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
+
+    def _post_init(self):
+        """
+        Perform post __init__ initialisation. In particular, add state
+        processors or pre-processors.
+
+        Sub-class may override this. If the sub-class wishes to register the
+        default processors for storing states, it should call this parent
+        ``.post_init()`` method.
+
+        Sub-class ``.post_init()`` implementation may take additional keyword
+        arguments if required.
+        """
+        store_states = self.options['store_states']
+        store_final_state = self.options['store_final_state']
+
+        if store_states is None:
+            store_states = len(self.e_ops) == 0
+        if store_states:
+            self.add_processor(self._store_state, requires_copy=True)
+
+        if store_states or store_final_state:
+            self.add_processor(self._store_final_state, requires_copy=True)
+
+    def _store_state(self, t, state):
+        """ Processor that stores a state in ``.states``. """
+        self.states.append(state)
+
+    def _store_final_state(self, t, state):
+        """ Processor that writes the state to ``.final_state``. """
+        self.final_state = state
+
+    def _pre_copy(self, state):
+        """ Return a copy of the state. Sub-classes may override this to
+            copy a state in different manner or to skip making a copy
+            altogether if a copy is not necessary.
+        """
+        return state.copy()
+
+    def add(self, t, state):
+        """
+        Add a state to the results for the time ``t`` of the evolution.
+
+        Adding a state calculates the expectation value of the state for
+        each of the supplied ``e_ops`` and stores the result in ``.expect``.
+
+        The state is recorded in ``.states`` and ``.final_state`` if specified
+        by the supplied result options.
+
+        Parameters
+        ----------
+        t : float
+            The time of the added state.
+
+        state : typically a :obj:`~Qobj`
+            The state a time ``t``. Usually this is a :obj:`~Qobj` with
+            suitable dimensions, but it sub-classes of result might support
+            other forms of the state.
+
+        .. note::
+
+           The expectation values, i.e. ``e_ops``, and states are recorded by
+           the state processors (see ``.add_processor``).
+
+           Additional processors may be added by sub-classes.
+        """
+        self.times.append(t)
+
+        if self._state_processors_require_copy:
+            state = self._pre_copy(state)
+
+        for op in self._state_processors:
+            op(t, state)
+
+    def __repr__(self):
+        lines = [
+            f"<{self.__class__.__name__}",
+            f"  Solver: {self.solver}",
+        ]
+        if self.stats:
+            lines.append("  Solver stats:")
+            lines.extend(
+                f"    {k}: {v!r}"
+                for k, v in self.stats.items()
+            )
+        if self.times:
+            lines.append(
+                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
+                f" ({len(self.times)} steps)"
+            )
+        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
+        if self.states:
+            lines.append("  States saved.")
+        elif self.final_state is not None:
+            lines.append("  Final state saved.")
+        else:
+            lines.append("  State not saved.")
+        lines.append(">")
+        return "\n".join(lines)
+
+    @property
+    def expect(self):
+        return [np.array(e_op) for e_op in self.e_data.values()]
+
+
+class MultiTrajResult(_BaseResult):
+    """
+    Base class for storing results for solver using multiple trajectories.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``.expect`` attribute of this result
+        object. ``.expect`` is a list, where each item contains the values
+        of the corresponding ``e_op``.
+
+        Function ``e_ops`` must return a number so the average can be computed.
+
+    options : dict
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Properties
+    ----------
+    times : list
+        A list of the times at which the expectation values and states were
+        recorded.
+
+    average_states : list of :obj:`~Qobj`
+        The state at each time ``t`` (if the recording of the state was
+        requested) averaged over all trajectories as a density matrix.
+
+    runs_states : list of list of :obj:`~Qobj`
+        The state for each trajectory and each time ``t`` (if the recording of
+        the states and trajectories was requested)
+
+    final_state : :obj:`~Qobj:
+        The final state (if the recording of the final state was requested)
+        averaged over all trajectories as a density matrix.
+
+    runs_final_state : list of :obj:`~Qobj`
+        The final state for each trajectory (if the recording of the final
+        state and trajectories was requested).
+
+    average_expect : list of array of expectation values
+        A list containing the values of each ``e_op`` averaged over each
+        trajectories. The list is in the same order in which the ``e_ops`` were
+        supplied and empty if no ``e_ops`` were given.
+
+        Each element is itself an array and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+    std_expect : list of array of expectation values
+        A list containing the standard derivation of each ``e_op`` over each
+        trajectories. The list is in the same order in which the ``e_ops`` were
+        supplied and empty if no ``e_ops`` were given.
+
+        Each element is itself an array and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+    runs_expect : list of array of expectation values
+        A list containing the values of each ``e_op`` for each trajectories.
+        The list is in the same order in which the ``e_ops`` were
+        supplied and empty if no ``e_ops`` were given. Only available if the
+        storing of trajectories was requested.
+
+        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
+
+        Each element is itself an array and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+    average_e_data : dict
+        A dictionary containing the values of each ``e_op`` averaged over each
+        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
+        are the same as in that dictionary. Otherwise the keys are the index of
+        the ``e_op`` in the ``.expect`` list.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    average_e_data : dict
+        A dictionary containing the standard derivation of each ``e_op`` over
+        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
+        keys are the same as in that dictionary. Otherwise the keys are the
+        index of the ``e_op`` in the ``.expect`` list.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    runs_e_data : dict
+        A dictionary containing the values of each ``e_op`` for each
+        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
+        are the same as in that dictionary. Otherwise the keys are the index of
+        the ``e_op`` in the ``.expect`` list. Only available if the storing
+        of trajectories was requested.
+
+        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results.
+
+    options : :obj:`~SolverResultsOptions`
+        The options for this result class.
+    """
+    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
+        super().__init__(options, solver=solver, stats=stats)
+        self._raw_ops = self._e_ops_to_dict(e_ops)
+
+        self.times = []
+        self.trajectories = []
+        self.num_trajectories = 0
+        self.seeds = []
+
+        self._sum_states = None
+        self._sum_final_states = None
+        self._sum_expect = None
+        self._sum2_expect = None
+        self._target_tols = None
+
+        self.average_e_data = {}
+        self.e_data = {}
+        self.std_e_data = {}
+        self.runs_e_data = {}
+
+        self._post_init(**kw)
+
+    @staticmethod
+    def _to_dm(state):
+        if state.type == 'ket':
+            state = state.proj()
+        return state
+
+    def _add_first_traj(self, trajectory):
+        """
+        Read the first trajectory, intitializing needed data.
+        """
+        self.times = trajectory.times
+
+        if trajectory.states:
+            state = trajectory.states[0]
+            self._sum_states = [qzero(state.dims[0])
+                                for state in trajectory.states]
+        if trajectory.final_state:
+            state = trajectory.final_state
+            self._sum_final_states = qzero(state.dims[0])
+
+        self._sum_expect = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum2_expect = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+
+        self.e_ops = trajectory.e_ops
+
+        self.average_e_data = {
+            k: list(avg_expect)
+            for k, avg_expect
+            in zip(self._raw_ops, self._sum_expect)
+        }
+        self.e_data = self.average_e_data
+        if self.options['keep_runs_results']:
+            self.runs_e_data = {k: [] for k in self._raw_ops}
+            self.e_data = self.runs_e_data
+
+    def _store_trajectory(self, trajectory):
+        self.trajectories.append(trajectory)
+
+    def _reduce_states(self, trajectory):
+        self._sum_states = [
+            accu + self._to_dm(state)
+            for accu, state
+            in zip(self._sum_states, trajectory.states)
+        ]
+
+    def _reduce_final_state(self, trajectory):
+        self._sum_final_states += self._to_dm(trajectory.final_state)
+
+    def _reduce_expect(self, trajectory):
+        """
+        Compute the average of the expectation values and store it in it's
+        multiple formats.
+        """
+        for i, k in enumerate(self._raw_ops):
+            expect_traj = trajectory.expect[i]
+
+            self._sum_expect[i] += expect_traj
+            self._sum2_expect[i] += expect_traj**2
+
+            avg = self._sum_expect[i] / self.num_trajectories
+            avg2 = self._sum2_expect[i] / self.num_trajectories
+
+            self.average_e_data[k] = list(avg)
+
+            # mean(expect**2) - mean(expect)**2 can something be very small
+            # negative (-1e-15) which raise an error for float sqrt.
+            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
+
+            if self.runs_e_data:
+                self.runs_e_data[k].append(trajectory.e_data[k])
+
+    def _increment_traj(self, trajectory):
+        if self.num_trajectories == 0:
+            self._add_first_traj(trajectory)
+        self.num_trajectories += 1
+
+    def _no_end(self):
+        """
+        Remaining number of trajectories needed to finish cannot be determined
+        by this object.
+        """
+        return np.inf
+
+    def _fixed_end(self):
+        """
+        Finish at a known number of trajectories.
+        """
+        ntraj_left = self._target_ntraj - self.num_trajectories
+        if ntraj_left == 0:
+            self.stats['end_condition'] = 'ntraj reached'
+        return ntraj_left
+
+    def _target_tolerance_end(self):
+        """
+        Compute the error on the expectation values using jackknife resampling.
+        Return the approximate number of trajectories needed to have this
+        error within the tolerance fot all e_ops and times.
+        """
+        if self.num_trajectories <= 1:
+            return np.inf
+        avg = np.array(self._sum_expect) / self.num_trajectories
+        avg2 = np.array(self._sum2_expect) / self.num_trajectories
+        target = np.array([
+            atol + rtol * mean
+            for mean, (atol, rtol)
+            in zip(avg, self._target_tols)
+        ])
+        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
+
+        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
+        if (self._estimated_ntraj - self.num_trajectories) <= 0:
+            self.stats['end_condition'] = 'target tolerance reached'
+        return self._estimated_ntraj - self.num_trajectories
+
+    def _post_init(self):
+        self.num_trajectories = 0
+        self._target_ntraj = None
+
+        store_states = self.options['store_states']
+        store_final_state = self.options['store_final_state']
+        store_traj = self.options['keep_runs_results']
+
+        self.add_processor(self._increment_traj)
+        if store_traj:
+            self.add_processor(self._store_trajectory)
+        if store_states is None:
+            store_states = len(self._raw_ops) == 0
+        if store_states:
+            self.add_processor(self._reduce_states)
+        if store_states or store_final_state:
+            self.add_processor(self._reduce_final_state)
+        if self._raw_ops:
+            self.add_processor(self._reduce_expect)
+
+        self._early_finish_check = self._no_end
+        self.stats['end_condition'] = 'unknown'
+
+    def add(self, trajectory_info):
+        """
+        Add a trajectory to the evolution.
+
+        Trajectories can be saved or average canbe extracted depending on the
+        options ``keep_runs_results``.
+
+        Parameters
+        ----------
+        trajectory_info : tuple of seed and trajectory
+            - seed: int, SeedSequence
+              Seed used to generate the trajectory.
+            - trajectory : :class:`Result`
+              Run result for one evolution over the times.
+
+        Return
+        ------
+        remaing_traj : number
+            Return the number of trajectories still needed to reach the target
+            tolerance. If no tolerance is provided, return infinity.
+        """
+        seed, trajectory = trajectory_info
+        self.seeds.append(seed)
+
+        for op in self._state_processors:
+            op(trajectory)
+
+        return self._early_finish_check()
+
+    def add_end_condition(self, ntraj, target_tol=None):
+        """
+        Set the condition to stop the computing trajectories when the certain
+        condition are fullfilled.
+        Supported end condition for multi trajectories computation are:
+        - Reaching a number of trajectories.
+        - Error bar on the expectation values reach smaller than a given
+          tolerance.
+
+        Parameters
+        ----------
+        ntraj : int
+            Number of trajectories expected.
+
+        target_tol : float, array_like, [optional]
+            Target tolerance of the evolution. The evolution will compute
+            trajectories until the error on the expectation values is lower
+            than this tolerance. The error is computed using jackknife
+            resampling. ``target_tol`` can be an absolute tolerance, a pair of
+            absolute and relative tolerance, in that order. Lastly, it can be a
+            list of pairs of (atol, rtol) for each e_ops.
+
+            Error estimation is done with jackknife resampling.
+        """
+        self._target_ntraj = ntraj
+        self.stats['end_condition'] = 'timeout'
+
+        if target_tol is None:
+            self._early_finish_check = self._fixed_end
+            return
+
+        num_e_ops = len(self._raw_ops)
+
+        if not num_e_ops:
+            raise ValueError("Cannot target a tolerance without e_ops")
+
+        self._estimated_ntraj = ntraj
+
+        targets = np.array(target_tol)
+        if targets.ndim == 0:
+            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
+        elif targets.shape == (2,):
+            self._target_tols = np.ones((num_e_ops, 2)) * targets
+        elif targets.shape == (num_e_ops, 2):
+            self._target_tols = targets
+        else:
+            raise ValueError("target_tol must be a number, a pair of (atol, "
+                             "rtol) or a list of (atol, rtol) for each e_ops")
+
+        self._early_finish_check = self._target_tolerance_end
+
+    @property
+    def runs_states(self):
+        """
+        States of every runs as ``states[run][t]``.
+        """
+        if self.trajectories and self.trajectories[0].states:
+            return [traj.states for traj in self.trajectories]
+        else:
+            return None
+
+    @property
+    def average_states(self):
+        """
+        States averages as density matrices.
+        """
+        if self._sum_states is None:
+            return None
+        return [final / self.num_trajectories for final in self._sum_states]
+
+    @property
+    def states(self):
+        """
+        Runs final states if available, average otherwise.
+        """
+        return self.runs_states or self.average_states
+
+    @property
+    def runs_final_states(self):
+        """
+        Last states of each trajectories.
+        """
+        if self.trajectories and self.trajectories[0].final_state:
+            return [traj.final_state for traj in self.trajectories]
+        else:
+            return None
+
+    @property
+    def average_final_state(self):
+        """
+        Last states of each trajectories averaged into a density matrix.
+        """
+        if self._sum_final_states is None:
+            return None
+        return self._sum_final_states / self.num_trajectories
+
+    @property
+    def final_state(self):
+        """
+        Runs final states if available, average otherwise.
+        """
+        return self.runs_final_states or self.average_final_state
+
+    @property
+    def average_expect(self):
+        return [np.array(val) for val in self.average_e_data.values()]
+
+    @property
+    def std_expect(self):
+        return [np.array(val) for val in self.std_e_data.values()]
+
+    @property
+    def runs_expect(self):
+        return [np.array(val) for val in self.runs_e_data.values()]
+
+    @property
+    def expect(self):
+        return [np.array(val) for val in self.e_data.values()]
+
+    def steady_state(self, N=0):
+        """
+        Average the states of the last ``N`` times of every runs as a density
+        matrix. Should converge to the steady state in the right circumstances.
+
+        Parameters
+        ----------
+        N : int [optional]
+            Number of states from the end of ``tlist`` to average. Per default
+            all states will be averaged.
+        """
+        N = int(N) or len(self.times)
+        N = len(self.times) if N > len(self.times) else N
+        states = self.average_states
+        if states is not None:
+            return sum(states[-N:]) / N
+        else:
+            return None
+
+    def __repr__(self):
+        lines = [
+            f"<{self.__class__.__name__}",
+            f"  Solver: {self.solver}",
+        ]
+        if self.stats:
+            lines.append("  Solver stats:")
+            lines.extend(
+                f"    {k}: {v!r}"
+                for k, v in self.stats.items()
+            )
+        if self.times:
+            lines.append(
+                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
+                f" ({len(self.times)} steps)"
+            )
+        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
+        if self.states:
+            lines.append("  States saved.")
+        elif self.final_state is not None:
+            lines.append("  Final state saved.")
+        else:
+            lines.append("  State not saved.")
+        lines.append(f"  Number of trajectories: {self.num_trajectories}")
+        if self.trajectories:
+            lines.append("  Trajectories saved.")
+        else:
+            lines.append("  Trajectories not saved.")
+        lines.append(">")
+        return "\n".join(lines)
+
+    def __add__(self, other):
+        if not isinstance(other, MultiTrajResult):
+            return NotImplemented
+        if self._raw_ops != other._raw_ops:
+            raise ValueError("Shared `e_ops` is required to merge results")
+        if self.times != other.times:
+            raise ValueError("Shared `times` are is required to merge results")
+        new = self.__class__(self._raw_ops, self.options,
+                             solver=self.solver, stats=self.stats)
+        if self.trajectories and other.trajectories:
+            new.trajectories = self.trajectories + other.trajectories
+        new.num_trajectories = self.num_trajectories + other.num_trajectories
+        new.times = self.times
+        new.seeds = self.seeds + other.seeds
+
+        if self._sum_states is not None and other._sum_states is not None:
+            new._sum_states = self._sum_states + other._sum_states
+
+        if (
+            self._sum_final_states is not None
+            and other._sum_final_states is not None
+        ):
+            new._sum_final_states = (
+                self._sum_final_states + other._sum_final_states
+            )
+        new._target_tols = None
+
+        new._sum_expect = []
+        new._sum2_expect = []
+        new.average_e_data = {}
+        new.std_e_data = {}
+
+        for i, k in enumerate(self._raw_ops):
+            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
+            new._sum2_expect.append(self._sum2_expect[i]
+                                    + other._sum2_expect[i])
+
+            avg = new._sum_expect[i] / new.num_trajectories
+            avg2 = new._sum2_expect[i] / new.num_trajectories
+
+            new.average_e_data[k] = list(avg)
+            new.e_data = new.average_e_data
+
+            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
+
+            if new.trajectories:
+                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
+                new.e_data = new.runs_e_data
+
+        new.stats["run time"] += other.stats["run time"]
+        new.stats['end_condition'] = "Merged results"
+
+        return new
+
+
+class McResult(MultiTrajResult):
+    """
+    Base class for storing solver results.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``.expect`` attribute of this result
+        object. ``.expect`` is a list, where each item contains the values
+        of the corresponding ``e_op``.
+
+    options : :obj:`~SolverResultsOptions`
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+        Must include a value for "num_collapse".
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Properties
+    ----------
+    collapse : list
+        For each runs, a list of every collapse as a tuple of the time it
+        happened and the corresponding ``c_ops`` index.
+    """
+    # Collapse are only produced by mcsolve.
+
+    def _add_collapse(self, trajectory):
+        self.collapse.append(trajectory.collapse)
+
+    def _post_init(self):
+        super()._post_init()
+        self.num_c_ops = self.stats["num_collapse"]
+        self.collapse = []
+        self.add_processor(self._add_collapse)
+
+    @property
+    def col_times(self):
+        """
+        List of the times of the collapses for each runs.
+        """
+        out = []
+        for col_ in self.collapse:
+            col = list(zip(*col_))
+            col = ([] if len(col) == 0 else col[0])
+            out.append(col)
+        return out
+
+    @property
+    def col_which(self):
+        """
+        List of the indexes of the collapses for each runs.
+        """
+        out = []
+        for col_ in self.collapse:
+            col = list(zip(*col_))
+            col = ([] if len(col) == 0 else col[1])
+            out.append(col)
+        return out
+
+    @property
+    def photocurrent(self):
+        """
+        Average photocurrent or measurement of the evolution.
+        """
+        cols = [[] for _ in range(self.num_c_ops)]
+        tlist = self.times
+        for collapses in self.collapse:
+            for t, which in collapses:
+                cols[which].append(t)
+        mesurement = [
+            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
+            for i in range(self.num_c_ops)
+        ]
+        return mesurement
+
+    @property
+    def runs_photocurrent(self):
+        """
+        Photocurrent or measurement of each runs.
+        """
+        tlist = self.times
+        measurements = []
+        for collapses in self.collapse:
+            cols = [[] for _ in range(self.num_c_ops)]
+            for t, which in collapses:
+                cols[which].append(t)
+            measurements.append([
+                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
+                for i in range(self.num_c_ops)
+            ])
+        return measurements
diff --git a/qutip/solver/scattering.py b/qutip/solver/scattering.py
index 5855832dbb..b7bdd2512a 100644
--- a/qutip/solver/scattering.py
+++ b/qutip/solver/scattering.py
@@ -1,301 +1,301 @@
-"""
-Photon scattering in quantum optical systems
-
-This module includes a collection of functions for numerically computing photon
-scattering in driven arbitrary systems coupled to some configuration of output
-waveguides. The implementation of these functions closely follows the
-mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
-Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
-"""
-# Author:  Ben Bartlett
-# Contact: benbartlett@stanford.edu
-
-import numpy as np
-from itertools import product, combinations_with_replacement
-from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
-from .propagator import propagator, Propagator
-
-__all__ = ['temporal_basis_vector',
-           'temporal_scattered_state',
-           'scattering_probability']
-
-
-def set_partition(collection, num_sets):
-    """
-    Enumerate all ways of partitioning collection into num_sets different
-    lists, e.g. :
-    list(set_partition([1,2], 2))
-    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
-
-    Parameters
-    ----------
-    collection : iterable
-        Collection to generate a set partition of.
-    num_sets : int
-        Number of sets to partition collection into.
-
-    Returns
-    -------
-    partition : iterable
-        The partitioning of collection into num_sets sets.
-    """
-    for partitioning in product(range(num_sets), repeat=len(collection)):
-        partition = [[] for _ in range(num_sets)]
-        for i, set_index in enumerate(partitioning):
-            partition[set_index].append(collection[i])
-        yield tuple(tuple(indices) for indices in partition)
-
-
-def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
-    """
-    Compute the scattering amplitude for a system emitting into multiple
-    waveguides.
-
-    Parameters
-    ----------
-    propagator : :class:Propagator
-        Propagator
-    c_ops : list
-        list of collapse operators for each waveguide; these are assumed to
-        include spontaneous decay rates, e.g.
-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
-    tlist : array_like
-        List of times starting at the beginning and ending at the end of the
-        evolution.
-    taus : list-like
-        List of (list of emission times) for each waveguide.
-    psi : Qobj
-        State at the start of the evolution
-    psit : Qobj
-        State at the end of the evolution.
-    """
-    # Extract the full list of taus
-    tau_collapse = []
-    for i, tau_wg in enumerate(taus):
-        for t in tau_wg:
-            tau_collapse.append((t, i))
-    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
-
-    tq = tlist[0]
-    # Compute Prod Ueff(tq, tq-1)
-    for tau in tau_collapse:
-        tprev = tq
-        tq, q = tau
-        psi = c_ops[q] * propagator(tq, tprev) * psi
-
-    psi = propagator(tlist[-1], tq) * psi
-    return psit.overlap(psi)
-
-
-def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
-    """
-    Generate a the global index for the excitation.
-    """
-    idx = []
-    for i, wg_indices in enumerate(waveguide_emission_indices):
-        for index in wg_indices:
-            idx += [i * n_time_bins + index]
-    idx = idx or [0]
-    return tuple(idx)
-
-
-def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
-                         n_emissions=None):
-    """
-    Return the dims of the ``temporal_basis_vector``.
-    """
-    num_col = len(waveguide_emission_indices)
-    if n_emissions is None:
-        n_emissions = sum(
-            [len(waveguide_indices)
-             for waveguide_indices in waveguide_emission_indices])
-    n_emissions = n_emissions or 1
-    return [num_col * n_time_bins] * n_emissions
-
-
-def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
-                          n_emissions=None):
-    """
-    Generate a temporal basis vector for emissions at specified time bins into
-    specified waveguides.
-
-    Parameters
-    ----------
-    waveguide_emission_indices : list or tuple
-        List of indices where photon emission occurs for each waveguide,
-        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
-    n_time_bins : int
-        Number of time bins; the range over which each index can vary.
-
-    Returns
-    -------
-    temporal_basis_vector : :class: qutip.Qobj
-        A basis vector representing photon scattering at the specified indices.
-        If there are W waveguides, T times, and N photon emissions, then the
-        basis vector has dimensionality (W*T)^N.
-    """
-    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
-    dims = _temporal_basis_dims(waveguide_emission_indices,
-                                n_time_bins, n_emissions)
-    return basis(dims, list(idx))
-
-
-def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
-                               system_zero_state=None,
-                               construct_effective_hamiltonian=True):
-    """
-    Compute the scattered n-photon state as an ndarray.
-    """
-    T = len(tlist)
-    W = len(c_ops)
-    em_dims = max(n_emissions, 1)
-    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
-
-    if construct_effective_hamiltonian:
-        # Construct an effective Hamiltonian from system hamiltonian and c_ops
-        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
-    else:
-        Heff = H
-
-    evolver = Propagator(Heff, memoize=len(tlist))
-
-    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
-
-    if system_zero_state is None:
-        system_zero_state = psi0
-
-    # Compute <omega_tau> for all combinations of tau
-    for emission_indices in all_emission_indices:
-        # Consider unique partitionings of emission times into waveguides
-        partition = tuple(set(set_partition(emission_indices, W)))
-        # Consider all possible partitionings of time bins by waveguide
-        for indices in partition:
-            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
-            phi_n_amp = photon_scattering_amplitude(
-                evolver, c_ops, tlist,
-                taus, psi0, system_zero_state
-            )
-            # Add scatter amplitude times temporal basis to overall state
-            idx = _temporal_basis_idx(indices, T)
-            phi_n[idx] = phi_n_amp
-    return phi_n
-
-
-def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
-                             system_zero_state=None,
-                             construct_effective_hamiltonian=True):
-    """
-    Compute the scattered n-photon state projected onto the temporal basis.
-
-    Parameters
-    ----------
-    H : :class: qutip.Qobj or list
-        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
-        list-callback format. If construct_effective_hamiltonian is not
-        specified, an effective Hamiltonian is constructed from `H` and
-        `c_ops`.
-    psi0 : :class: qutip.Qobj
-        Initial state density matrix :math:`\\rho(t_0)` or state vector
-        :math:`\\psi(t_0)`.
-    n_emissions : int
-        Number of photon emissions to calculate.
-    c_ops : list
-        List of collapse operators for each waveguide; these are assumed to
-        include spontaneous decay rates, e.g.
-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
-    tlist : array_like
-        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
-        the pulse duration / temporal region of interest.
-    system_zero_state : :class: qutip.Qobj
-        State representing zero excitations in the system. Defaults to
-        :math:`\\psi(t_0)`
-    construct_effective_hamiltonian : bool
-        Whether an effective Hamiltonian should be constructed from H and
-        c_ops:
-        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
-        Default: True.
-
-    Returns
-    -------
-    phi_n : :class: qutip.Qobj
-        The scattered bath state projected onto the temporal basis given by
-        tlist. If there are W waveguides, T times, and N photon emissions, then
-        the state is a tensor product state with dimensionality T^(W*N).
-    """
-    T = len(tlist)
-    W = len(c_ops)
-    em_dims = max(n_emissions, 1)
-    phi_n = _temporal_scattered_matrix(
-        H, psi0, n_emissions, c_ops, tlist,
-        system_zero_state, construct_effective_hamiltonian
-    )
-    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
-
-
-def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
-                           system_zero_state=None,
-                           construct_effective_hamiltonian=True):
-    """
-    Compute the integrated probability of scattering n photons in an arbitrary
-    system. This function accepts a nonlinearly spaced array of times.
-
-    Parameters
-    ----------
-    H : :class: qutip.Qobj or list
-        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
-        list-callback format. If construct_effective_hamiltonian is not
-        specified, an effective Hamiltonian is constructed from H and
-        `c_ops`.
-    psi0 : :class: qutip.Qobj
-        Initial state density matrix :math:`\\rho(t_0)` or state vector
-        :math:`\\psi(t_0)`.
-    n_emissions : int
-        Number of photons emitted by the system (into any combination of
-        waveguides).
-    c_ops : list
-        List of collapse operators for each waveguide; these are assumed to
-        include spontaneous decay rates, e.g.
-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
-    tlist : array_like
-        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
-        the pulse duration / temporal region of interest; tlist need not be
-        linearly spaced.
-    system_zero_state : :class: qutip.Qobj
-        State representing zero excitations in the system. Defaults to
-        `basis(systemDims, 0)`.
-    construct_effective_hamiltonian : bool
-        Whether an effective Hamiltonian should be constructed from H and
-        c_ops:
-        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
-        Default: True.
-
-    Returns
-    -------
-    scattering_prob : float
-        The probability of scattering n photons from the system over the time
-        range specified.
-    """
-    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
-                                       system_zero_state,
-                                       construct_effective_hamiltonian)
-    T = len(tlist)
-    W = len(c_ops)
-
-    # Compute <omega_tau> for all combinations of tau
-    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
-    probs = np.zeros([T] * n_emissions)
-
-    # Project scattered state onto temporal basis
-    for emit_indices in all_emission_indices:
-        # Consider unique emission time partitionings
-        partition = tuple(set(set_partition(emit_indices, W)))
-        # wg_indices_list = list(set_partition(indices, W))
-        for wg_indices in partition:
-            idx = _temporal_basis_idx(wg_indices, T)
-            amplitude = phi_n[idx]
-            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
-
-    # Iteratively integrate to obtain single value
-    while probs.shape != ():
-        probs = np.trapz(probs, x=tlist)
-    return np.abs(probs)
+"""
+Photon scattering in quantum optical systems
+
+This module includes a collection of functions for numerically computing photon
+scattering in driven arbitrary systems coupled to some configuration of output
+waveguides. The implementation of these functions closely follows the
+mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
+Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
+"""
+# Author:  Ben Bartlett
+# Contact: benbartlett@stanford.edu
+
+import numpy as np
+from itertools import product, combinations_with_replacement
+from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
+from .propagator import propagator, Propagator
+
+__all__ = ['temporal_basis_vector',
+           'temporal_scattered_state',
+           'scattering_probability']
+
+
+def set_partition(collection, num_sets):
+    """
+    Enumerate all ways of partitioning collection into num_sets different
+    lists, e.g. :
+    list(set_partition([1,2], 2))
+    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
+
+    Parameters
+    ----------
+    collection : iterable
+        Collection to generate a set partition of.
+    num_sets : int
+        Number of sets to partition collection into.
+
+    Returns
+    -------
+    partition : iterable
+        The partitioning of collection into num_sets sets.
+    """
+    for partitioning in product(range(num_sets), repeat=len(collection)):
+        partition = [[] for _ in range(num_sets)]
+        for i, set_index in enumerate(partitioning):
+            partition[set_index].append(collection[i])
+        yield tuple(tuple(indices) for indices in partition)
+
+
+def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
+    """
+    Compute the scattering amplitude for a system emitting into multiple
+    waveguides.
+
+    Parameters
+    ----------
+    propagator : :class:Propagator
+        Propagator
+    c_ops : list
+        list of collapse operators for each waveguide; these are assumed to
+        include spontaneous decay rates, e.g.
+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
+    tlist : array_like
+        List of times starting at the beginning and ending at the end of the
+        evolution.
+    taus : list-like
+        List of (list of emission times) for each waveguide.
+    psi : Qobj
+        State at the start of the evolution
+    psit : Qobj
+        State at the end of the evolution.
+    """
+    # Extract the full list of taus
+    tau_collapse = []
+    for i, tau_wg in enumerate(taus):
+        for t in tau_wg:
+            tau_collapse.append((t, i))
+    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
+
+    tq = tlist[0]
+    # Compute Prod Ueff(tq, tq-1)
+    for tau in tau_collapse:
+        tprev = tq
+        tq, q = tau
+        psi = c_ops[q] * propagator(tq, tprev) * psi
+
+    psi = propagator(tlist[-1], tq) * psi
+    return psit.overlap(psi)
+
+
+def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
+    """
+    Generate a the global index for the excitation.
+    """
+    idx = []
+    for i, wg_indices in enumerate(waveguide_emission_indices):
+        for index in wg_indices:
+            idx += [i * n_time_bins + index]
+    idx = idx or [0]
+    return tuple(idx)
+
+
+def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
+                         n_emissions=None):
+    """
+    Return the dims of the ``temporal_basis_vector``.
+    """
+    num_col = len(waveguide_emission_indices)
+    if n_emissions is None:
+        n_emissions = sum(
+            [len(waveguide_indices)
+             for waveguide_indices in waveguide_emission_indices])
+    n_emissions = n_emissions or 1
+    return [num_col * n_time_bins] * n_emissions
+
+
+def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
+                          n_emissions=None):
+    """
+    Generate a temporal basis vector for emissions at specified time bins into
+    specified waveguides.
+
+    Parameters
+    ----------
+    waveguide_emission_indices : list or tuple
+        List of indices where photon emission occurs for each waveguide,
+        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
+    n_time_bins : int
+        Number of time bins; the range over which each index can vary.
+
+    Returns
+    -------
+    temporal_basis_vector : :class: qutip.Qobj
+        A basis vector representing photon scattering at the specified indices.
+        If there are W waveguides, T times, and N photon emissions, then the
+        basis vector has dimensionality (W*T)^N.
+    """
+    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
+    dims = _temporal_basis_dims(waveguide_emission_indices,
+                                n_time_bins, n_emissions)
+    return basis(dims, list(idx))
+
+
+def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
+                               system_zero_state=None,
+                               construct_effective_hamiltonian=True):
+    """
+    Compute the scattered n-photon state as an ndarray.
+    """
+    T = len(tlist)
+    W = len(c_ops)
+    em_dims = max(n_emissions, 1)
+    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
+
+    if construct_effective_hamiltonian:
+        # Construct an effective Hamiltonian from system hamiltonian and c_ops
+        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
+    else:
+        Heff = H
+
+    evolver = Propagator(Heff, memoize=len(tlist))
+
+    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
+
+    if system_zero_state is None:
+        system_zero_state = psi0
+
+    # Compute <omega_tau> for all combinations of tau
+    for emission_indices in all_emission_indices:
+        # Consider unique partitionings of emission times into waveguides
+        partition = tuple(set(set_partition(emission_indices, W)))
+        # Consider all possible partitionings of time bins by waveguide
+        for indices in partition:
+            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
+            phi_n_amp = photon_scattering_amplitude(
+                evolver, c_ops, tlist,
+                taus, psi0, system_zero_state
+            )
+            # Add scatter amplitude times temporal basis to overall state
+            idx = _temporal_basis_idx(indices, T)
+            phi_n[idx] = phi_n_amp
+    return phi_n
+
+
+def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
+                             system_zero_state=None,
+                             construct_effective_hamiltonian=True):
+    """
+    Compute the scattered n-photon state projected onto the temporal basis.
+
+    Parameters
+    ----------
+    H : :class: qutip.Qobj or list
+        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
+        list-callback format. If construct_effective_hamiltonian is not
+        specified, an effective Hamiltonian is constructed from `H` and
+        `c_ops`.
+    psi0 : :class: qutip.Qobj
+        Initial state density matrix :math:`\\rho(t_0)` or state vector
+        :math:`\\psi(t_0)`.
+    n_emissions : int
+        Number of photon emissions to calculate.
+    c_ops : list
+        List of collapse operators for each waveguide; these are assumed to
+        include spontaneous decay rates, e.g.
+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
+    tlist : array_like
+        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
+        the pulse duration / temporal region of interest.
+    system_zero_state : :class: qutip.Qobj
+        State representing zero excitations in the system. Defaults to
+        :math:`\\psi(t_0)`
+    construct_effective_hamiltonian : bool
+        Whether an effective Hamiltonian should be constructed from H and
+        c_ops:
+        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
+        Default: True.
+
+    Returns
+    -------
+    phi_n : :class: qutip.Qobj
+        The scattered bath state projected onto the temporal basis given by
+        tlist. If there are W waveguides, T times, and N photon emissions, then
+        the state is a tensor product state with dimensionality T^(W*N).
+    """
+    T = len(tlist)
+    W = len(c_ops)
+    em_dims = max(n_emissions, 1)
+    phi_n = _temporal_scattered_matrix(
+        H, psi0, n_emissions, c_ops, tlist,
+        system_zero_state, construct_effective_hamiltonian
+    )
+    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
+
+
+def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
+                           system_zero_state=None,
+                           construct_effective_hamiltonian=True):
+    """
+    Compute the integrated probability of scattering n photons in an arbitrary
+    system. This function accepts a nonlinearly spaced array of times.
+
+    Parameters
+    ----------
+    H : :class: qutip.Qobj or list
+        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
+        list-callback format. If construct_effective_hamiltonian is not
+        specified, an effective Hamiltonian is constructed from H and
+        `c_ops`.
+    psi0 : :class: qutip.Qobj
+        Initial state density matrix :math:`\\rho(t_0)` or state vector
+        :math:`\\psi(t_0)`.
+    n_emissions : int
+        Number of photons emitted by the system (into any combination of
+        waveguides).
+    c_ops : list
+        List of collapse operators for each waveguide; these are assumed to
+        include spontaneous decay rates, e.g.
+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
+    tlist : array_like
+        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
+        the pulse duration / temporal region of interest; tlist need not be
+        linearly spaced.
+    system_zero_state : :class: qutip.Qobj
+        State representing zero excitations in the system. Defaults to
+        `basis(systemDims, 0)`.
+    construct_effective_hamiltonian : bool
+        Whether an effective Hamiltonian should be constructed from H and
+        c_ops:
+        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
+        Default: True.
+
+    Returns
+    -------
+    scattering_prob : float
+        The probability of scattering n photons from the system over the time
+        range specified.
+    """
+    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
+                                       system_zero_state,
+                                       construct_effective_hamiltonian)
+    T = len(tlist)
+    W = len(c_ops)
+
+    # Compute <omega_tau> for all combinations of tau
+    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
+    probs = np.zeros([T] * n_emissions)
+
+    # Project scattered state onto temporal basis
+    for emit_indices in all_emission_indices:
+        # Consider unique emission time partitionings
+        partition = tuple(set(set_partition(emit_indices, W)))
+        # wg_indices_list = list(set_partition(indices, W))
+        for wg_indices in partition:
+            idx = _temporal_basis_idx(wg_indices, T)
+            amplitude = phi_n[idx]
+            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
+
+    # Iteratively integrate to obtain single value
+    while probs.shape != ():
+        probs = np.trapz(probs, x=tlist)
+    return np.abs(probs)
diff --git a/qutip/solver/sesolve.py b/qutip/solver/sesolve.py
index 0914624232..8ed998ba15 100644
--- a/qutip/solver/sesolve.py
+++ b/qutip/solver/sesolve.py
@@ -1,189 +1,189 @@
-"""
-This module provides solvers for the unitary Schrodinger equation.
-"""
-
-__all__ = ['sesolve', 'SESolver']
-
-import numpy as np
-from time import time
-from .. import Qobj, QobjEvo
-from .solver_base import Solver
-
-
-def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
-    """
-    Schrodinger equation evolution of a state vector or unitary matrix
-    for a given Hamiltonian.
-
-    Evolve the state vector (`psi0`) using a given
-    Hamiltonian (`H`), by integrating the set of ordinary differential
-    equations that define the system. Alternatively evolve a unitary matrix in
-    solving the Schrodinger operator equation.
-
-    The output is either the state vector or unitary matrix at arbitrary points
-    in time (`tlist`), or the expectation values of the supplied operators
-    (`e_ops`). If e_ops is a callback function, it is invoked for each
-    time in `tlist` with time and the state as arguments, and the function
-    does not use any return values. e_ops cannot be used in conjunction
-    with solving the Schrodinger operator equation
-
-    **Time-dependent operators**
-
-    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
-    object that can be interpreted as :class:`QobjEvo` such as a list of
-    (Qobj, Coefficient) pairs or a function.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    psi0 : :class:`qutip.qobj`
-        initial state vector (ket)
-        or initial unitary operator `psi0 = U`
-
-    tlist : *list* / *array*
-        list of times for :math:`t`.
-
-    e_ops : :class:`qutip.qobj`, callable, or list.
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation.
-
-    args : None / *dictionary*
-        dictionary of parameters for time-dependent Hamiltonians
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        a *list of array* `result.expect` of expectation values for the times
-        specified by `tlist`, and/or a *list* `result.states` of state vectors
-        or density matrices corresponding to the times in `tlist` [if `e_ops`
-        is an empty list of `store_states=True` in options].
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    solver = SESolver(H, options=options)
-    return solver.run(psi0, tlist, e_ops=e_ops)
-
-
-class SESolver(Solver):
-    """
-    Schrodinger equation evolution of a state vector or unitary matrix
-    for a given Hamiltonian.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    options : dict, optional
-        Options for the solver, see :obj:`SESolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-
-    attributes
-    ----------
-    stats: dict
-        Diverse diagnostic statistics of the evolution.
-    """
-    name = "sesolve"
-    _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size":10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-        'method': 'adams',
-    }
-
-    def __init__(self, H, *, options=None):
-        _time_start = time()
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-
-        rhs = -1j * H
-        if not rhs.isoper:
-            raise ValueError("The hamiltonian must be an operator")
-        super().__init__(rhs, options=options)
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "solver": "Schrodinger Evolution",
-        })
-        return stats
-
-    @property
-    def options(self):
-        """
-        Solver's options:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        normalize_output: bool, default=True
-            Normalize output state to hide ODE numerical errors.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error
-            if not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size": 10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        method: str, default="adams"
-            Which ordinary differential equation integration method to use.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Solver.options.fset(self, new_options)
+"""
+This module provides solvers for the unitary Schrodinger equation.
+"""
+
+__all__ = ['sesolve', 'SESolver']
+
+import numpy as np
+from time import time
+from .. import Qobj, QobjEvo
+from .solver_base import Solver
+
+
+def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
+    """
+    Schrodinger equation evolution of a state vector or unitary matrix
+    for a given Hamiltonian.
+
+    Evolve the state vector (`psi0`) using a given
+    Hamiltonian (`H`), by integrating the set of ordinary differential
+    equations that define the system. Alternatively evolve a unitary matrix in
+    solving the Schrodinger operator equation.
+
+    The output is either the state vector or unitary matrix at arbitrary points
+    in time (`tlist`), or the expectation values of the supplied operators
+    (`e_ops`). If e_ops is a callback function, it is invoked for each
+    time in `tlist` with time and the state as arguments, and the function
+    does not use any return values. e_ops cannot be used in conjunction
+    with solving the Schrodinger operator equation
+
+    **Time-dependent operators**
+
+    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
+    object that can be interpreted as :class:`QobjEvo` such as a list of
+    (Qobj, Coefficient) pairs or a function.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    psi0 : :class:`qutip.qobj`
+        initial state vector (ket)
+        or initial unitary operator `psi0 = U`
+
+    tlist : *list* / *array*
+        list of times for :math:`t`.
+
+    e_ops : :class:`qutip.qobj`, callable, or list.
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
+
+    args : None / *dictionary*
+        dictionary of parameters for time-dependent Hamiltonians
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        a *list of array* `result.expect` of expectation values for the times
+        specified by `tlist`, and/or a *list* `result.states` of state vectors
+        or density matrices corresponding to the times in `tlist` [if `e_ops`
+        is an empty list of `store_states=True` in options].
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    solver = SESolver(H, options=options)
+    return solver.run(psi0, tlist, e_ops=e_ops)
+
+
+class SESolver(Solver):
+    """
+    Schrodinger equation evolution of a state vector or unitary matrix
+    for a given Hamiltonian.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    options : dict, optional
+        Options for the solver, see :obj:`SESolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+
+    attributes
+    ----------
+    stats: dict
+        Diverse diagnostic statistics of the evolution.
+    """
+    name = "sesolve"
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size":10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+        'method': 'adams',
+    }
+
+    def __init__(self, H, *, options=None):
+        _time_start = time()
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+
+        rhs = -1j * H
+        if not rhs.isoper:
+            raise ValueError("The hamiltonian must be an operator")
+        super().__init__(rhs, options=options)
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "solver": "Schrodinger Evolution",
+        })
+        return stats
+
+    @property
+    def options(self):
+        """
+        Solver's options:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        normalize_output: bool, default=True
+            Normalize output state to hide ODE numerical errors.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error
+            if not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size": 10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        method: str, default="adams"
+            Which ordinary differential equation integration method to use.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Solver.options.fset(self, new_options)
diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index 953bfab490..ae0db23247 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -1,395 +1,395 @@
-__all__ = ['Solver']
-
-from .. import Qobj, QobjEvo, ket2dm
-from .options import _SolverOptions
-from ..core import stack_columns, unstack_columns
-from .result import Result
-from .integrator import Integrator
-from ..ui.progressbar import progess_bars
-from time import time
-
-
-class Solver:
-    """
-    Runner for an evolution.
-    Can run the evolution at once using :method:`run` or step by step using
-    :method:`start` and :method:`step`.
-
-    Parameters
-    ----------
-    rhs : Qobj, QobjEvo
-        Right hand side of the evolution::
-            d state / dt = rhs @ state
-
-    options : dict
-        Options for the solver
-    """
-    name = ""
-
-    # State, time and Integrator of the stepper functionnality
-    _integrator = None
-    _avail_integrators = {}
-
-    # Class of option used by the solver
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": "ket",
-        "method": "adams",
-    }
-    resultclass = Result
-
-    def __init__(self, rhs, *, options=None):
-        if isinstance(rhs, (QobjEvo, Qobj)):
-            self.rhs = QobjEvo(rhs)
-        else:
-            TypeError("The rhs must be a QobjEvo")
-        self.options = options
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-    def _initialize_stats(self):
-        """ Return the initial values for the solver stats.
-        """
-        return {
-            "method": self._integrator.name,
-            "init time": self._init_integrator_time,
-            "preparation time": 0.0,
-            "run time": 0.0,
-        }
-
-    def _prepare_state(self, state):
-        """
-        Extract the data of the Qobj state.
-
-        Is responsible for dims checks, preparing the data (stack columns, ...)
-        determining the dims of the output for :method:`_restore_state`.
-
-        Should return the state's data such that it can be used by Integrators.
-        """
-        if self.rhs.issuper and state.isket:
-            state = ket2dm(state)
-
-        if (
-            self.rhs.dims[1] != state.dims[0]
-            and self.rhs.dims[1] != state.dims
-        ):
-            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
-                            f" and {state.dims}")
-
-        self._state_metadata = {
-            'dims': state.dims,
-            'type': state.type,
-            'isherm': state.isherm and not (self.rhs.dims == state.dims)
-        }
-        if self.rhs.dims[1] == state.dims:
-            return stack_columns(state.data)
-        return state.data
-
-    def _restore_state(self, data, *, copy=True):
-        """
-        Retore the Qobj state from its data.
-        """
-        if self._state_metadata['dims'] == self.rhs.dims[1]:
-            state = Qobj(unstack_columns(data),
-                         **self._state_metadata, copy=False)
-        else:
-            state = Qobj(data, **self._state_metadata, copy=copy)
-
-        if data.shape[1] == 1 and self._options['normalize_output']:
-            state = state * (1 / state.norm())
-
-        return state
-
-    def run(self, state0, tlist, *, args=None, e_ops=None):
-        """
-        Do the evolution of the Quantum system.
-
-        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
-        ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :cls:`Result`. The evolution method and stored
-        results are determined by ``options``.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        tlist : list of double
-            Time for which to save the results (state and/or expect) of the
-            evolution. The first element of the list is the initial time of the
-            evolution. Each times of the list must be increasing, but does not
-            need to be uniformy distributed.
-
-        args : dict, optional {None}
-            Change the ``args`` of the rhs for the evolution.
-
-        e_ops : list {None}
-            List of Qobj, QobjEvo or callable to compute the expectation
-            values. Function[s] must have the signature
-            f(t : float, state : Qobj) -> expect.
-
-        Return
-        ------
-        results : :class:`qutip.solver.Result`
-            Results of the evolution. States and/or expect will be saved. You
-            can control the saved data in the options.
-        """
-        _time_start = time()
-        _data0 = self._prepare_state(state0)
-        self._integrator.set_state(tlist[0], _data0)
-        self._argument(args)
-        stats = self._initialize_stats()
-        results = self.resultclass(
-            e_ops, self.options,
-            solver=self.name, stats=stats,
-        )
-        results.add(tlist[0], self._restore_state(_data0, copy=False))
-        stats['preparation time'] += time() - _time_start
-
-        progress_bar = progess_bars[self.options['progress_bar']]()
-        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
-        for t, state in self._integrator.run(tlist):
-            progress_bar.update()
-            results.add(t, self._restore_state(state, copy=False))
-        progress_bar.finished()
-
-        stats['run time'] = progress_bar.total_time()
-        # TODO: It would be nice if integrator could give evolution statistics
-        # stats.update(_integrator.stats)
-        return results
-
-    def start(self, state0, t0):
-        """
-        Set the initial state and time for a step evolution.
-        ``options`` for the evolutions are read at this step.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        t0 : double
-            Initial time of the evolution.
-        """
-        _time_start = time()
-        self._integrator.set_state(t0, self._prepare_state(state0))
-        self.stats["preparation time"] += time() - _time_start
-
-    def step(self, t, *, args=None, copy=True):
-        """
-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-
-        Parameters
-        ----------
-        t : double
-            Time to evolve to, must be higher than the last call.
-
-        args : dict, optional {None}
-            Update the ``args`` of the system.
-            The change is effective from the beginning of the interval.
-            Changing ``args`` can slow the evolution.
-
-        copy : bool, optional {True}
-            Whether to return a copy of the data or the data in the ODE solver.
-
-        .. note::
-            The state must be initialized first by calling ``start`` or
-            ``run``. If ``run`` is called, ``step`` will continue from the last
-            time and state obtained.
-        """
-        if not self._integrator._is_set:
-            raise RuntimeError("The `start` method must called first")
-        _time_start = time()
-        self._argument(args)
-        _, state = self._integrator.integrate(t, copy=False)
-        self.stats["run time"] += time() - _time_start
-        return self._restore_state(state, copy=copy)
-
-    def _get_integrator(self):
-        """ Return the initialted integrator. """
-        _time_start = time()
-        method = self._options["method"]
-        if method in self.avail_integrators():
-            integrator = self.avail_integrators()[method]
-        elif issubclass(method, Integrator):
-            integrator = method
-        else:
-            raise ValueError("Integrator method not supported.")
-        integrator_instance = integrator(self.rhs, self.options)
-        self._init_integrator_time = time() - _time_start
-        return integrator_instance
-
-    @property
-    def sys_dims(self):
-        """
-        Dimensions of the space that the system use:
-
-        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
-        for this solver.
-        """
-        return self.rhs.dims[0]
-
-    @property
-    def options(self):
-        """
-        method: str
-            Which ordinary differential equation integration method to use.
-        """
-        return self._options
-
-    def _parse_options(self, new_options, default, old_options):
-        """
-        Do a first read through of the options:
-        - Split new options' items included in the default from those that are
-          not.
-        - Replace ``None`` with the default value.
-        - Remove items that are unchanged.
-        """
-        included_options = {
-            key: val
-            for key, val in new_options.items()
-            if key in default
-        }
-        extra_options = {
-            key: val
-            for key, val in new_options.items()
-            if key not in default
-        }
-
-        # First pass: Have ``None`` refert to the default.
-        included_options = {
-            key: (val if val is not None else default[key])
-            for key, val in included_options.items()
-        }
-        # Second pass: Remove options that remain unchanged.
-        included_options = {
-            key: val
-            for key, val in included_options.items()
-            if not (key in old_options and val == old_options[key])
-        }
-        return included_options, extra_options
-
-    @options.setter
-    def options(self, new_options):
-        if not hasattr(self, "_options"):
-            self._options = {}
-        if new_options is None:
-            new_options = {}
-        if not isinstance(new_options, dict):
-            raise TypeError("options most to be a dictionary.")
-        new_solver_options, new_ode_options = self._parse_options(
-            new_options, self.solver_options, self.options
-        )
-        method = new_solver_options.get(
-            "method", self.options.get("method", self.solver_options["method"])
-        )
-        integrator = self.avail_integrators()[method]
-
-        if method == self.options.get("method", None):
-            # If method changed, drop old ode options
-            old_ode_options = self.options
-            old_options = self._options
-        else:
-            old_ode_options = {}
-            old_options, _ = self._parse_options(
-                self._options, self.solver_options, {}
-            )
-
-        new_ode_options, extra_options = self._parse_options(
-            new_ode_options, integrator.integrator_options, self.options
-        )
-        if extra_options:
-            raise KeyError(f"Options {extra_options.keys()} are not supported")
-        if self._options and not (new_solver_options or new_ode_options):
-            return  # Nothing to do
-
-        self._options = _SolverOptions(
-            {**self.solver_options, **integrator.integrator_options},
-            self._apply_options,
-            self.name + " with " + integrator.method + " integrator",
-            self.__class__.options.__doc__ + integrator.options.__doc__,
-            **{**old_options, **new_solver_options, **new_ode_options}
-        )
-
-        self._apply_options(set(new_options.keys()))
-
-    def _apply_options(self, keys):
-        """
-        Method called when options are changed, either through
-        ``solver.options[key] = value`` or ``solver.options = options``.
-        Allow to update the solver with the new options
-        """
-        from_setter = isinstance(keys, (set))
-        if not from_setter:
-            keys = set([keys])
-
-        if not from_setter and "method" in keys:
-            # Drop the ode's options.
-            old_solver_options, _ = self._parse_options(
-                self.options, self.solver_options, {}
-            )
-            method = self.options["method"]
-            integrator = self.avail_integrators()[method]
-
-            self._options = _SolverOptions(
-                {**self.solver_options, **integrator.integrator_options},
-                self._apply_options,
-                self.name + " with " + integrator.method + " integrator",
-                self.__class__.options.__doc__ + integrator.options.__doc__,
-                **old_solver_options
-            )
-
-        if self._integrator is None or not keys:
-            pass
-        elif 'method' in keys and self._integrator._is_set:
-            state = self._integrator.get_state()
-            self._integrator = self._get_integrator()
-            self._integrator.set_state(*state)
-        elif "method" in keys:
-            self._integrator = self._get_integrator()
-        elif keys & self._integrator.integrator_options.keys():
-            # Some of the keys are used by the integrator.
-            self._integrator.options = self._options
-            self._integrator.reset(hard=True)
-
-    def _argument(self, args):
-        """Update the args, for the `rhs` and other operators."""
-        if args:
-            self.rhs.arguments(args)
-            self._integrator.arguments(args)
-
-    @classmethod
-    def avail_integrators(cls):
-        if cls is Solver:
-            return cls._avail_integrators.copy()
-        return {
-            **Solver.avail_integrators(),
-            **cls._avail_integrators,
-        }
-
-    @classmethod
-    def integrator(cls, key):
-        return cls.avail_integrators()[key]
-
-    @classmethod
-    def add_integrator(cls, integrator, key):
-        """
-        Register an integrator.
-
-        Parameters
-        ----------
-        integrator : Integrator
-            The ODE solver to register.
-
-        keys : list of str
-            Values of the method options that refer to this integrator.
-        """
-        if not issubclass(integrator, Integrator):
-            raise TypeError(f"The integrator {integrator} must be a subclass"
-                            " of `qutip.solver.Integrator`")
-
-        cls._avail_integrators[key] = integrator
+__all__ = ['Solver']
+
+from .. import Qobj, QobjEvo, ket2dm
+from .options import _SolverOptions
+from ..core import stack_columns, unstack_columns
+from .result import Result
+from .integrator import Integrator
+from ..ui.progressbar import progess_bars
+from time import time
+
+
+class Solver:
+    """
+    Runner for an evolution.
+    Can run the evolution at once using :method:`run` or step by step using
+    :method:`start` and :method:`step`.
+
+    Parameters
+    ----------
+    rhs : Qobj, QobjEvo
+        Right hand side of the evolution::
+            d state / dt = rhs @ state
+
+    options : dict
+        Options for the solver
+    """
+    name = ""
+
+    # State, time and Integrator of the stepper functionnality
+    _integrator = None
+    _avail_integrators = {}
+
+    # Class of option used by the solver
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": "ket",
+        "method": "adams",
+    }
+    resultclass = Result
+
+    def __init__(self, rhs, *, options=None):
+        if isinstance(rhs, (QobjEvo, Qobj)):
+            self.rhs = QobjEvo(rhs)
+        else:
+            TypeError("The rhs must be a QobjEvo")
+        self.options = options
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+    def _initialize_stats(self):
+        """ Return the initial values for the solver stats.
+        """
+        return {
+            "method": self._integrator.name,
+            "init time": self._init_integrator_time,
+            "preparation time": 0.0,
+            "run time": 0.0,
+        }
+
+    def _prepare_state(self, state):
+        """
+        Extract the data of the Qobj state.
+
+        Is responsible for dims checks, preparing the data (stack columns, ...)
+        determining the dims of the output for :method:`_restore_state`.
+
+        Should return the state's data such that it can be used by Integrators.
+        """
+        if self.rhs.issuper and state.isket:
+            state = ket2dm(state)
+
+        if (
+            self.rhs.dims[1] != state.dims[0]
+            and self.rhs.dims[1] != state.dims
+        ):
+            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
+                            f" and {state.dims}")
+
+        self._state_metadata = {
+            'dims': state.dims,
+            'type': state.type,
+            'isherm': state.isherm and not (self.rhs.dims == state.dims)
+        }
+        if self.rhs.dims[1] == state.dims:
+            return stack_columns(state.data)
+        return state.data
+
+    def _restore_state(self, data, *, copy=True):
+        """
+        Retore the Qobj state from its data.
+        """
+        if self._state_metadata['dims'] == self.rhs.dims[1]:
+            state = Qobj(unstack_columns(data),
+                         **self._state_metadata, copy=False)
+        else:
+            state = Qobj(data, **self._state_metadata, copy=copy)
+
+        if data.shape[1] == 1 and self._options['normalize_output']:
+            state = state * (1 / state.norm())
+
+        return state
+
+    def run(self, state0, tlist, *, args=None, e_ops=None):
+        """
+        Do the evolution of the Quantum system.
+
+        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
+        ``rhs`` and for each time in ``tlist`` store the state and/or
+        expectation values in a :cls:`Result`. The evolution method and stored
+        results are determined by ``options``.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        tlist : list of double
+            Time for which to save the results (state and/or expect) of the
+            evolution. The first element of the list is the initial time of the
+            evolution. Each times of the list must be increasing, but does not
+            need to be uniformy distributed.
+
+        args : dict, optional {None}
+            Change the ``args`` of the rhs for the evolution.
+
+        e_ops : list {None}
+            List of Qobj, QobjEvo or callable to compute the expectation
+            values. Function[s] must have the signature
+            f(t : float, state : Qobj) -> expect.
+
+        Return
+        ------
+        results : :class:`qutip.solver.Result`
+            Results of the evolution. States and/or expect will be saved. You
+            can control the saved data in the options.
+        """
+        _time_start = time()
+        _data0 = self._prepare_state(state0)
+        self._integrator.set_state(tlist[0], _data0)
+        self._argument(args)
+        stats = self._initialize_stats()
+        results = self.resultclass(
+            e_ops, self.options,
+            solver=self.name, stats=stats,
+        )
+        results.add(tlist[0], self._restore_state(_data0, copy=False))
+        stats['preparation time'] += time() - _time_start
+
+        progress_bar = progess_bars[self.options['progress_bar']]()
+        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
+        for t, state in self._integrator.run(tlist):
+            progress_bar.update()
+            results.add(t, self._restore_state(state, copy=False))
+        progress_bar.finished()
+
+        stats['run time'] = progress_bar.total_time()
+        # TODO: It would be nice if integrator could give evolution statistics
+        # stats.update(_integrator.stats)
+        return results
+
+    def start(self, state0, t0):
+        """
+        Set the initial state and time for a step evolution.
+        ``options`` for the evolutions are read at this step.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        t0 : double
+            Initial time of the evolution.
+        """
+        _time_start = time()
+        self._integrator.set_state(t0, self._prepare_state(state0))
+        self.stats["preparation time"] += time() - _time_start
+
+    def step(self, t, *, args=None, copy=True):
+        """
+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+
+        Parameters
+        ----------
+        t : double
+            Time to evolve to, must be higher than the last call.
+
+        args : dict, optional {None}
+            Update the ``args`` of the system.
+            The change is effective from the beginning of the interval.
+            Changing ``args`` can slow the evolution.
+
+        copy : bool, optional {True}
+            Whether to return a copy of the data or the data in the ODE solver.
+
+        .. note::
+            The state must be initialized first by calling ``start`` or
+            ``run``. If ``run`` is called, ``step`` will continue from the last
+            time and state obtained.
+        """
+        if not self._integrator._is_set:
+            raise RuntimeError("The `start` method must called first")
+        _time_start = time()
+        self._argument(args)
+        _, state = self._integrator.integrate(t, copy=False)
+        self.stats["run time"] += time() - _time_start
+        return self._restore_state(state, copy=copy)
+
+    def _get_integrator(self):
+        """ Return the initialted integrator. """
+        _time_start = time()
+        method = self._options["method"]
+        if method in self.avail_integrators():
+            integrator = self.avail_integrators()[method]
+        elif issubclass(method, Integrator):
+            integrator = method
+        else:
+            raise ValueError("Integrator method not supported.")
+        integrator_instance = integrator(self.rhs, self.options)
+        self._init_integrator_time = time() - _time_start
+        return integrator_instance
+
+    @property
+    def sys_dims(self):
+        """
+        Dimensions of the space that the system use:
+
+        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
+        for this solver.
+        """
+        return self.rhs.dims[0]
+
+    @property
+    def options(self):
+        """
+        method: str
+            Which ordinary differential equation integration method to use.
+        """
+        return self._options
+
+    def _parse_options(self, new_options, default, old_options):
+        """
+        Do a first read through of the options:
+        - Split new options' items included in the default from those that are
+          not.
+        - Replace ``None`` with the default value.
+        - Remove items that are unchanged.
+        """
+        included_options = {
+            key: val
+            for key, val in new_options.items()
+            if key in default
+        }
+        extra_options = {
+            key: val
+            for key, val in new_options.items()
+            if key not in default
+        }
+
+        # First pass: Have ``None`` refert to the default.
+        included_options = {
+            key: (val if val is not None else default[key])
+            for key, val in included_options.items()
+        }
+        # Second pass: Remove options that remain unchanged.
+        included_options = {
+            key: val
+            for key, val in included_options.items()
+            if not (key in old_options and val == old_options[key])
+        }
+        return included_options, extra_options
+
+    @options.setter
+    def options(self, new_options):
+        if not hasattr(self, "_options"):
+            self._options = {}
+        if new_options is None:
+            new_options = {}
+        if not isinstance(new_options, dict):
+            raise TypeError("options most to be a dictionary.")
+        new_solver_options, new_ode_options = self._parse_options(
+            new_options, self.solver_options, self.options
+        )
+        method = new_solver_options.get(
+            "method", self.options.get("method", self.solver_options["method"])
+        )
+        integrator = self.avail_integrators()[method]
+
+        if method == self.options.get("method", None):
+            # If method changed, drop old ode options
+            old_ode_options = self.options
+            old_options = self._options
+        else:
+            old_ode_options = {}
+            old_options, _ = self._parse_options(
+                self._options, self.solver_options, {}
+            )
+
+        new_ode_options, extra_options = self._parse_options(
+            new_ode_options, integrator.integrator_options, self.options
+        )
+        if extra_options:
+            raise KeyError(f"Options {extra_options.keys()} are not supported")
+        if self._options and not (new_solver_options or new_ode_options):
+            return  # Nothing to do
+
+        self._options = _SolverOptions(
+            {**self.solver_options, **integrator.integrator_options},
+            self._apply_options,
+            self.name + " with " + integrator.method + " integrator",
+            self.__class__.options.__doc__ + integrator.options.__doc__,
+            **{**old_options, **new_solver_options, **new_ode_options}
+        )
+
+        self._apply_options(set(new_options.keys()))
+
+    def _apply_options(self, keys):
+        """
+        Method called when options are changed, either through
+        ``solver.options[key] = value`` or ``solver.options = options``.
+        Allow to update the solver with the new options
+        """
+        from_setter = isinstance(keys, (set))
+        if not from_setter:
+            keys = set([keys])
+
+        if not from_setter and "method" in keys:
+            # Drop the ode's options.
+            old_solver_options, _ = self._parse_options(
+                self.options, self.solver_options, {}
+            )
+            method = self.options["method"]
+            integrator = self.avail_integrators()[method]
+
+            self._options = _SolverOptions(
+                {**self.solver_options, **integrator.integrator_options},
+                self._apply_options,
+                self.name + " with " + integrator.method + " integrator",
+                self.__class__.options.__doc__ + integrator.options.__doc__,
+                **old_solver_options
+            )
+
+        if self._integrator is None or not keys:
+            pass
+        elif 'method' in keys and self._integrator._is_set:
+            state = self._integrator.get_state()
+            self._integrator = self._get_integrator()
+            self._integrator.set_state(*state)
+        elif "method" in keys:
+            self._integrator = self._get_integrator()
+        elif keys & self._integrator.integrator_options.keys():
+            # Some of the keys are used by the integrator.
+            self._integrator.options = self._options
+            self._integrator.reset(hard=True)
+
+    def _argument(self, args):
+        """Update the args, for the `rhs` and other operators."""
+        if args:
+            self.rhs.arguments(args)
+            self._integrator.arguments(args)
+
+    @classmethod
+    def avail_integrators(cls):
+        if cls is Solver:
+            return cls._avail_integrators.copy()
+        return {
+            **Solver.avail_integrators(),
+            **cls._avail_integrators,
+        }
+
+    @classmethod
+    def integrator(cls, key):
+        return cls.avail_integrators()[key]
+
+    @classmethod
+    def add_integrator(cls, integrator, key):
+        """
+        Register an integrator.
+
+        Parameters
+        ----------
+        integrator : Integrator
+            The ODE solver to register.
+
+        keys : list of str
+            Values of the method options that refer to this integrator.
+        """
+        if not issubclass(integrator, Integrator):
+            raise TypeError(f"The integrator {integrator} must be a subclass"
+                            " of `qutip.solver.Integrator`")
+
+        cls._avail_integrators[key] = integrator
diff --git a/qutip/solver/spectrum.py b/qutip/solver/spectrum.py
index cb92e1f0e6..a267ee6451 100644
--- a/qutip/solver/spectrum.py
+++ b/qutip/solver/spectrum.py
@@ -1,188 +1,188 @@
-__all__ = ['spectrum', 'spectrum_correlation_fft']
-
-import numpy as np
-import scipy.fftpack
-
-from .steadystate import steadystate
-from ..core import liouvillian, spre, expect
-from ..core import data as _data
-from qutip.settings import settings
-
-def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
-    r"""
-    Calculate the spectrum of the correlation function
-    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
-    i.e., the Fourier transform of the correlation function:
-
-    .. math::
-
-        S(\omega) = \int_{-\infty}^{\infty}
-        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
-        e^{-i\omega\tau} d\tau.
-
-    using the solver indicated by the `solver` parameter. Note: this spectrum
-    is only defined for stationary statistics (uses steady state rho0)
-
-    Parameters
-    ----------
-    H : :class:`qutip.qobj`
-        system Hamiltonian.
-    wlist : array_like
-        List of frequencies for :math:`\omega`.
-    c_ops : list
-        List of collapse operators.
-    a_op : Qobj
-        Operator A.
-    b_op : Qobj
-        Operator B.
-    solver : str
-        Choice of solver (`es` for exponential series and
-        `pi` for psuedo-inverse, `solve` for generic solver).
-
-    Returns
-    -------
-    spectrum : array
-        An array with spectrum :math:`S(\omega)` for the frequencies
-        specified in `wlist`.
-
-    """
-    if not H.issuper:
-        L = liouvillian(H, c_ops)
-    else:
-        L = H + sum([lindblad_dissipator(c) for c in c_ops])
-    if solver == "es":
-        return _spectrum_es(L, wlist, a_op, b_op)
-    elif solver in ["pi", "solve"]:
-        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
-    raise ValueError(
-        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
-    )
-
-
-def spectrum_correlation_fft(tlist, y, inverse=False):
-    """
-    Calculate the power spectrum corresponding to a two-time correlation
-    function using FFT.
-
-    Parameters
-    ----------
-    tlist : array_like
-        list/array of times :math:`t` which the correlation function is given.
-    y : array_like
-        list/array of correlations corresponding to time delays :math:`t`.
-    inverse: boolean
-        boolean parameter for using a positive exponent in the Fourier
-        Transform instead. Default is False.
-
-    Returns
-    -------
-    w, S : tuple
-        Returns an array of angular frequencies 'w' and the corresponding
-        two-sided power spectrum 'S(w)'.
-
-    """
-    tlist = np.asarray(tlist)
-    N = tlist.shape[0]
-    dt = tlist[1] - tlist[0]
-    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
-        raise ValueError('tlist must be equally spaced for FFT.')
-    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
-    # calculate the frequencies for the components in F
-    f = scipy.fftpack.fftfreq(N, dt)
-    # re-order frequencies from most negative to most positive (centre on 0)
-    idx = np.array([], dtype='int')
-    idx = np.append(idx, np.where(f < 0.0))
-    idx = np.append(idx, np.where(f >= 0.0))
-    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
-
-
-def _spectrum_es(L, wlist, a_op, b_op):
-    r"""
-    Internal function for calculating the spectrum of the correlation function
-    :math:`\left<A(\tau)B(0)\right>`.
-    """
-    # find the steady state density matrix and a_op and b_op expecation values
-    rho0 = steadystate(L)
-    a_op_ss = expect(a_op, rho0)
-    b_op_ss = expect(b_op, rho0)
-    # eseries solution for (b * rho0)(t)
-    states, rates = _diagonal_evolution(L, b_op * rho0)
-    # correlation
-    ampls = [_data.expect(a_op.data, state) for state in states]
-    # make covariance
-    ampls += [-a_op_ss * b_op_ss]
-    rates += [0]
-    # Tidy up similar rates.
-    order = np.argsort(rates)
-    clean_rates = []
-    clean_ampls = []
-    prev_rate = np.nan
-    for idx in order:
-        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
-            clean_ampls[-1] += ampls[idx]
-        else:
-            clean_rates.append(rates[idx])
-            clean_ampls.append(ampls[idx])
-            prev_rate = rates[idx]
-    # Remove 0 amplitude
-    rates, ampls = zip(*[
-        (rate, ampl)
-        for rate, ampl in zip(clean_rates, clean_ampls)
-        if np.abs(ampl) > settings.core["atol"]
-    ])
-    ampls, rates = np.array(ampls), np.array(rates)
-    LW = np.subtract.outer(1j * np.array(wlist), rates).T
-    return (ampls @ (2 / LW)).real
-
-
-#
-# pseudo-inverse solvers
-def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
-    r"""
-    Internal function for calculating the spectrum of the correlation function
-    :math:`\left<A(\tau)B(0)\right>`.
-    """
-    dtype = type(L.data)
-    rho_ss = steadystate(L)
-    tr_mat = _data.identity[dtype](rho_ss.shape[0])
-    tr_vec = _data.column_stack(tr_mat).transpose()
-    rho = _data.column_stack(rho_ss.data)
-
-    A = L.data
-    ket = spre(b_op).data @ rho
-    bra = tr_vec @ spre(a_op).data
-
-    I = _data.identity[dtype](L.shape[0])
-    P = _data.kron(rho, tr_vec)
-    Q = I - P
-
-    spectrum = np.zeros(len(wlist))
-    for idx, w in enumerate(wlist):
-        if use_pinv and np.abs(w) > settings.core["atol"]:
-            # At w == 0., "L - iw" is singular
-            MMR = _data.inv(-1.0j * w * I + A)
-        else:
-            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
-
-        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
-    return spectrum
-
-
-def _diagonal_evolution(L, rho0, sparse=False):
-    if rho0.norm() < settings.core["atol"]:
-        return [_data.zeros["CSR"](*rho0.shape)], [0]
-    if isinstance(L.data, _data.CSR) and not sparse:
-        L = L.to(_data.Dense)
-    evals, evecs = _data.eigs(L.data)
-    size = rho0.shape[0] * rho0.shape[1]
-    r0 = _data.column_stack(rho0.data)
-    v0 = _data.solve(evecs, r0)
-    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
-    states = []
-    rates = []
-    for ket, rate in zip(_data.split_columns(vv), evals):
-        if _data.norm.l2(ket) < settings.core["atol"]:
-            continue
-        states.append(_data.column_unstack(ket, rho0.shape[0]))
-        rates.append(rate)
-    return states, rates
+__all__ = ['spectrum', 'spectrum_correlation_fft']
+
+import numpy as np
+import scipy.fftpack
+
+from .steadystate import steadystate
+from ..core import liouvillian, spre, expect
+from ..core import data as _data
+from qutip.settings import settings
+
+def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
+    r"""
+    Calculate the spectrum of the correlation function
+    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
+    i.e., the Fourier transform of the correlation function:
+
+    .. math::
+
+        S(\omega) = \int_{-\infty}^{\infty}
+        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
+        e^{-i\omega\tau} d\tau.
+
+    using the solver indicated by the `solver` parameter. Note: this spectrum
+    is only defined for stationary statistics (uses steady state rho0)
+
+    Parameters
+    ----------
+    H : :class:`qutip.qobj`
+        system Hamiltonian.
+    wlist : array_like
+        List of frequencies for :math:`\omega`.
+    c_ops : list
+        List of collapse operators.
+    a_op : Qobj
+        Operator A.
+    b_op : Qobj
+        Operator B.
+    solver : str
+        Choice of solver (`es` for exponential series and
+        `pi` for psuedo-inverse, `solve` for generic solver).
+
+    Returns
+    -------
+    spectrum : array
+        An array with spectrum :math:`S(\omega)` for the frequencies
+        specified in `wlist`.
+
+    """
+    if not H.issuper:
+        L = liouvillian(H, c_ops)
+    else:
+        L = H + sum([lindblad_dissipator(c) for c in c_ops])
+    if solver == "es":
+        return _spectrum_es(L, wlist, a_op, b_op)
+    elif solver in ["pi", "solve"]:
+        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
+    raise ValueError(
+        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
+    )
+
+
+def spectrum_correlation_fft(tlist, y, inverse=False):
+    """
+    Calculate the power spectrum corresponding to a two-time correlation
+    function using FFT.
+
+    Parameters
+    ----------
+    tlist : array_like
+        list/array of times :math:`t` which the correlation function is given.
+    y : array_like
+        list/array of correlations corresponding to time delays :math:`t`.
+    inverse: boolean
+        boolean parameter for using a positive exponent in the Fourier
+        Transform instead. Default is False.
+
+    Returns
+    -------
+    w, S : tuple
+        Returns an array of angular frequencies 'w' and the corresponding
+        two-sided power spectrum 'S(w)'.
+
+    """
+    tlist = np.asarray(tlist)
+    N = tlist.shape[0]
+    dt = tlist[1] - tlist[0]
+    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
+        raise ValueError('tlist must be equally spaced for FFT.')
+    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
+    # calculate the frequencies for the components in F
+    f = scipy.fftpack.fftfreq(N, dt)
+    # re-order frequencies from most negative to most positive (centre on 0)
+    idx = np.array([], dtype='int')
+    idx = np.append(idx, np.where(f < 0.0))
+    idx = np.append(idx, np.where(f >= 0.0))
+    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
+
+
+def _spectrum_es(L, wlist, a_op, b_op):
+    r"""
+    Internal function for calculating the spectrum of the correlation function
+    :math:`\left<A(\tau)B(0)\right>`.
+    """
+    # find the steady state density matrix and a_op and b_op expecation values
+    rho0 = steadystate(L)
+    a_op_ss = expect(a_op, rho0)
+    b_op_ss = expect(b_op, rho0)
+    # eseries solution for (b * rho0)(t)
+    states, rates = _diagonal_evolution(L, b_op * rho0)
+    # correlation
+    ampls = [_data.expect(a_op.data, state) for state in states]
+    # make covariance
+    ampls += [-a_op_ss * b_op_ss]
+    rates += [0]
+    # Tidy up similar rates.
+    order = np.argsort(rates)
+    clean_rates = []
+    clean_ampls = []
+    prev_rate = np.nan
+    for idx in order:
+        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
+            clean_ampls[-1] += ampls[idx]
+        else:
+            clean_rates.append(rates[idx])
+            clean_ampls.append(ampls[idx])
+            prev_rate = rates[idx]
+    # Remove 0 amplitude
+    rates, ampls = zip(*[
+        (rate, ampl)
+        for rate, ampl in zip(clean_rates, clean_ampls)
+        if np.abs(ampl) > settings.core["atol"]
+    ])
+    ampls, rates = np.array(ampls), np.array(rates)
+    LW = np.subtract.outer(1j * np.array(wlist), rates).T
+    return (ampls @ (2 / LW)).real
+
+
+#
+# pseudo-inverse solvers
+def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
+    r"""
+    Internal function for calculating the spectrum of the correlation function
+    :math:`\left<A(\tau)B(0)\right>`.
+    """
+    dtype = type(L.data)
+    rho_ss = steadystate(L)
+    tr_mat = _data.identity[dtype](rho_ss.shape[0])
+    tr_vec = _data.column_stack(tr_mat).transpose()
+    rho = _data.column_stack(rho_ss.data)
+
+    A = L.data
+    ket = spre(b_op).data @ rho
+    bra = tr_vec @ spre(a_op).data
+
+    I = _data.identity[dtype](L.shape[0])
+    P = _data.kron(rho, tr_vec)
+    Q = I - P
+
+    spectrum = np.zeros(len(wlist))
+    for idx, w in enumerate(wlist):
+        if use_pinv and np.abs(w) > settings.core["atol"]:
+            # At w == 0., "L - iw" is singular
+            MMR = _data.inv(-1.0j * w * I + A)
+        else:
+            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
+
+        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
+    return spectrum
+
+
+def _diagonal_evolution(L, rho0, sparse=False):
+    if rho0.norm() < settings.core["atol"]:
+        return [_data.zeros["CSR"](*rho0.shape)], [0]
+    if isinstance(L.data, _data.CSR) and not sparse:
+        L = L.to(_data.Dense)
+    evals, evecs = _data.eigs(L.data)
+    size = rho0.shape[0] * rho0.shape[1]
+    r0 = _data.column_stack(rho0.data)
+    v0 = _data.solve(evecs, r0)
+    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
+    states = []
+    rates = []
+    for ket, rate in zip(_data.split_columns(vv), evals):
+        if _data.norm.l2(ket) < settings.core["atol"]:
+            continue
+        states.append(_data.column_unstack(ket, rho0.shape[0]))
+        rates.append(rate)
+    return states, rates
diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
index f576c9f2bb..71efa268b1 100644
--- a/qutip/solver/steadystate.py
+++ b/qutip/solver/steadystate.py
@@ -1,537 +1,537 @@
-from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
-from qutip import vector_to_operator, operator_to_vector
-from qutip import settings
-import qutip.core.data as _data
-import numpy as np
-import scipy.sparse.csgraph
-import scipy.sparse.linalg
-from warnings import warn
-
-
-__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
-
-
-def _permute_wbm(L, b):
-    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
-    L = _data.permute.indices(L, perm, None)
-    b = _data.permute.indices(b, perm, None)
-    return L, b
-
-
-def _permute_rcm(L, b):
-    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
-    L = _data.permute.indices(L, perm, perm)
-    b = _data.permute.indices(b, perm, None)
-    return L, b, perm
-
-
-def _reverse_rcm(rho, perm):
-    rev_perm = np.argsort(perm)
-    rho = _data.permute.indices(rho, rev_perm, None)
-    return rho
-
-
-def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
-    """
-    Calculates the steady state for quantum evolution subject to the supplied
-    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
-    collapse operators.
-
-    If the user passes a Hamiltonian then it, along with the list of collapse
-    operators, will be converted into a Liouvillian operator in Lindblad form.
-
-    Parameters
-    ----------
-    A : :obj:`~Qobj`
-        A Hamiltonian or Liouvillian operator.
-
-    c_op_list : list
-        A list of collapse operators.
-
-    method : str, default='direct'
-        The allowed methods are composed of 2 parts, the steadystate method:
-        - "direct": Solving ``L(rho_ss) = 0``
-        - "eigen" : Eigenvalue problem
-        - "svd" : Singular value decomposition
-        - "power" : Inverse-power method
-
-    solver : str, default=None
-        'direct' and 'power' methods only.
-        Solver to use when solving the ``L(rho_ss) = 0`` equation.
-        Default supported solver are:
-
-        - "solve", "lstsq"
-          dense solver from numpy.linalg
-        - "spsolve", "gmres", "lgmres", "bicgstab"
-          sparse solver from scipy.sparse.linalg
-        - "mkl_spsolve"
-          sparse solver by mkl.
-
-        Extension to qutip, such as qutip-tensorflow, can use come with their
-        own solver. When ``A`` and ``c_ops`` use these data backends, see the
-        corresponding libraries ``linalg`` for available solver.
-
-        Extra options for these solver can be passed in ``**kw``.
-
-    use_rcm : bool, default False
-        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
-        factorization of the Liouvillian.
-        Used with 'direct' or 'power' method.
-
-    use_wbm : bool, default False
-        Use Weighted Bipartite Matching reordering to make the Liouvillian
-        diagonally dominant.  This is useful for iterative preconditioners
-        only. Used with 'direct' or 'power' method.
-
-    weight : float, optional
-        Sets the size of the elements used for adding the unity trace condition
-        to the linear solvers.  This is set to the average abs value of the
-        Liouvillian elements if not specified by the user.
-        Used with 'direct' method.
-
-    power_tol : float, default 1e-12
-        Tolerance for the solution when using the 'power' method.
-
-    power_maxiter : int, default 10
-        Maximum number of iteration to use when looking for a solution when
-        using the 'power' method.
-
-    power_eps: double, default 1e-15
-        Small weight used in the "power" method.
-
-    sparse: bool
-        Whether to use the sparse eigen solver with the "eigen" method
-        (default sparse).  With "direct" and "power" method, when the solver is
-        not specified, it is used to set whether "solve" or "spsolve" is
-        used as default solver.
-
-    **kwargs :
-        Extra options to pass to the linear system solver. See the
-        documentation of the used solver in ``numpy.linalg`` or
-        ``scipy.sparse.linalg`` to see what extra arguments are supported.
-
-    Returns
-    -------
-    dm : qobj
-        Steady state density matrix.
-    info : dict, optional
-        Dictionary containing solver-specific information about the solution.
-
-    .. note::
-
-        The SVD method works only for dense operators (i.e. small systems).
-
-    """
-    if not A.issuper and not c_ops:
-        raise TypeError('Cannot calculate the steady state for a ' +
-                        'non-dissipative system.')
-    if not A.issuper:
-        A = liouvillian(A)
-    for op in c_ops:
-        A += lindblad_dissipator(op)
-
-    if "-" in method:
-        # to support v4's "power-gmres" method
-        method, solver = method.split("-")
-
-    if solver == "mkl":
-        solver = "mkl_spsolve"
-
-    # Keys supported in v4, but removed in v5
-    if kwargs.pop("return_info", False):
-        warn("Steadystate no longer supports return_info", DeprecationWarning)
-    if "mtol" in kwargs and "power_tol" not in kwargs:
-        kwargs["power_tol"] = kwargs["mtol"]
-    kwargs.pop("mtol", None)
-
-    if method == "eigen":
-        return _steadystate_eigen(A, **kwargs)
-    if method == "svd":
-        return _steadystate_svd(A, **kwargs)
-
-    # We want to be able to use this without having to know what data type the
-    # liouvillian uses. For extra data types (tensorflow) we can expect
-    # the users to know they are using them and choose an appropriate solver
-    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
-    if not isinstance(A.data, (_data.CSR, _data.Dense)):
-        # Tensorflow, jax, etc. data type
-        pass
-    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
-        A = A.to("dense")
-    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
-        A = A.to("csr")
-    elif solver is None and kwargs.get("sparse", False):
-        A = A.to("csr")
-        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
-    elif solver is None and (kwargs.get("sparse", None) is False):
-        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
-        A = A.to("dense")
-        solver = "solve"
-
-    if method in ["direct", "iterative"]:
-        # Remove unused kwargs, so only used and pass-through ones are included
-        kwargs.pop("power_tol", 0)
-        kwargs.pop("power_maxiter", 0)
-        kwargs.pop("power_eps", 0)
-        kwargs.pop("sparse", 0)
-        return _steadystate_direct(A, kwargs.pop("weight", 0),
-                                   method=solver, **kwargs)
-
-    elif method == "power":
-        # Remove unused kwargs, so only used and pass-through ones are included
-        kwargs.pop("weight", 0)
-        kwargs.pop("sparse", 0)
-        return _steadystate_power(A, method=solver, **kwargs)
-    else:
-        raise ValueError(f"method {method} not supported.")
-
-
-def _steadystate_direct(A, weight, **kw):
-    # Find the weight, no good dispatched function available...
-    if weight:
-        pass
-    elif isinstance(A.data, _data.CSR):
-        weight = np.mean(np.abs(A.data.as_scipy().data))
-    else:
-        A_np = np.abs(A.full())
-        weight = np.mean(A_np[A_np > 0])
-
-    # Add weight to the Liouvillian
-    # A[:, 0] = vectorized(eye * weight)
-    # We don't have a function to overwrite part of an array, so
-    N = A.shape[0]
-    n = int(N**0.5)
-    dtype = type(A.data)
-    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
-    weight_mat = _data.kron(
-        weight_vec.transpose(),
-        _data.one_element[dtype]((N, 1), (0, 0), 1)
-    )
-    L = _data.add(weight_mat, A.data)
-    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
-
-    # Permutation are part of scipy.sparse, thus only supported for CSR.
-    if kw.pop("use_wbm", False):
-        if isinstance(L, _data.CSR):
-            L, b = _permute_wbm(L, b)
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    use_rcm = False
-    if kw.pop("use_rcm", False):
-        if isinstance(L, _data.CSR):
-            L, b, perm = _permute_rcm(L, b)
-            use_rcm = True
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    if kw.pop("use_precond", False):
-        if isinstance(L, _data.CSR):
-            kw["M"] = _compute_precond(L, kw)
-        else:
-            warn("Only sparse solver use preconditioners.", RuntimeWarning)
-
-
-    method = kw.pop("method", None)
-    steadystate = _data.solve(L, b, method, options=kw)
-
-    if use_rcm:
-        steadystate = _reverse_rcm(steadystate, perm)
-
-    rho_ss = _data.column_unstack(steadystate, n)
-    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
-
-    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
-
-
-def _steadystate_eigen(L, **kw):
-    val, vec = (L.dag() @ L).eigenstates(
-        eigvals=1,
-        sort="low",
-        # v4's implementation only uses sparse eigen solver
-        sparse=kw.pop("sparse", True)
-    )
-    rho = vector_to_operator(vec[0])
-    return rho / rho.tr()
-
-
-def _steadystate_svd(L, **kw):
-    u, s, vh = _data.svd(L.data, True)
-    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
-    rho = vector_to_operator(vec)
-    return rho / rho.tr()
-
-
-def _steadystate_power(A, **kw):
-    A += kw.pop("power_eps", 1e-15)
-    L = A.data
-    N = L.shape[1]
-    y = _data.Dense([1]*N)
-
-    # Permutation are part of scipy.sparse, thus only supported for CSR.
-    if kw.pop("use_wbm", False):
-        if isinstance(L, _data.CSR):
-            L, y = _permute_wbm(L, y)
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    use_rcm = False
-    if kw.pop("use_rcm", False):
-        if isinstance(L, _data.CSR):
-            L, y, perm = _permute_rcm(L, y)
-            use_rcm = True
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    if kw.pop("use_precond", False):
-        if isinstance(L, _data.CSR):
-            kw["M"] = _compute_precond(L, kw)
-        else:
-            warn("Only sparse solver use preconditioners.", RuntimeWarning)
-
-    it = 0
-    maxiter = kw.pop("power_maxiter", 10)
-    tol = kw.pop("power_tol", 1e-12)
-    method = kw.pop("method", None)
-    while it < maxiter and _data.norm.max(L @ y) > tol:
-        y = _data.solve(L, y, method, options=kw)
-        y = y / _data.norm.max(y)
-        it += 1
-
-    if it >= maxiter:
-        raise Exception('Failed to find steady state after ' +
-                        str(maxiter) + ' iterations')
-
-    if use_rcm:
-        y = _reverse_rcm(y, perm)
-
-    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
-    rho_ss = rho_ss + rho_ss.dag()
-    rho_ss = rho_ss / rho_ss.tr()
-    rho_ss.isherm = True
-    return rho_ss
-
-
-def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
-                        solver=None, **kwargs):
-    """
-    Calculates the effective steady state for a driven
-     system with a time-dependent cosinusoidal term:
-
-    .. math::
-
-        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
-         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
-
-    Parameters
-    ----------
-    H_0 : :obj:`~Qobj`
-        A Hamiltonian or Liouvillian operator.
-
-    c_ops : list
-        A list of collapse operators.
-
-    Op_t : :obj:`~Qobj`
-        The the interaction operator which is multiplied by the cosine
-
-    w_d : float, default 1.0
-        The frequency of the drive
-
-    n_it : int, default 3
-        The number of iterations for the solver
-
-    sparse : bool, default False
-        Solve for the steady state using sparse algorithms.
-
-    solver : str, default=None
-        Solver to use when solving the linear system.
-        Default supported solver are:
-
-        - "solve", "lstsq"
-          dense solver from numpy.linalg
-        - "spsolve", "gmres", "lgmres", "bicgstab"
-          sparse solver from scipy.sparse.linalg
-        - "mkl_spsolve"
-          sparse solver by mkl.
-
-        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
-        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
-        for the names and details of additional solvers they may provide.
-
-    **kwargs:
-        Extra options to pass to the linear system solver. See the
-        documentation of the used solver in ``numpy.linalg`` or
-        ``scipy.sparse.linalg`` to see what extra arguments are supported.
-
-    Returns
-    -------
-    dm : qobj
-        Steady state density matrix.
-
-    .. note::
-
-        See: Sze Meng Tan,
-        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
-        Section (10.16)
-
-    """
-
-    L_0 = liouvillian(H_0, c_ops)
-    L_m = L_p = 0.5 * liouvillian(Op_t)
-    # L_p and L_m correspond to the positive and negative
-    # frequency terms respectively.
-    # They are independent in the model, so we keep both names.
-    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
-    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
-
-    if isinstance(H_0.data, _data.CSR) and not sparse:
-        L_0 = L_0.to("Dense")
-        L_m = L_m.to("Dense")
-        L_p = L_p.to("Dense")
-        Id = Id.to("Dense")
-
-    for n_i in np.arange(n_it, 0, -1):
-        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
-        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
-        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
-        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
-
-    M_subs = L_0 + L_m @ S + L_p @ T
-    return steadystate(M_subs, solver=solver, **kwargs)
-
-
-def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
-                   **kwargs):
-    """
-    Compute the pseudo inverse for a Liouvillian superoperator, optionally
-    given its steady state density matrix (which will be computed if not
-    given).
-
-    Parameters
-    ----------
-    L : Qobj
-        A Liouvillian superoperator for which to compute the pseudo inverse.
-
-    rhoss : Qobj
-        A steadystate density matrix as Qobj instance, for the Liouvillian
-        superoperator L.
-
-    w : double
-        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
-        systems and large sparse systems. Small sparse systems can fail for
-        zero frequencies.
-
-    sparse : bool
-        Flag that indicate whether to use sparse or dense matrix methods when
-        computing the pseudo inverse.
-
-    method : string
-        Method used to compte matrix inverse.
-        Choice are 'pinv' to use scipy's function of the same name, or a linear
-        system solver.
-        Default supported solver are:
-
-        - "solve", "lstsq"
-          dense solver from numpy.linalg
-        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
-          sparse solver from scipy.sparse.linalg
-        - "mkl_spsolve",
-          sparse solver by mkl.
-
-        Extension to qutip, such as qutip-tensorflow, can use come with their
-        own solver. When ``L`` use these data backends, see the corresponding
-        libraries ``linalg`` for available solver.
-
-    kwargs : dictionary
-        Additional keyword arguments for setting parameters for solver methods.
-
-    Returns
-    -------
-    R : Qobj
-        Returns a Qobj instance representing the pseudo inverse of L.
-
-    .. note::
-
-        In general the inverse of a sparse matrix will be dense.  If you
-        are applying the inverse to a density matrix then it is better to
-        cast the problem as an Ax=b type problem where the explicit calculation
-        of the inverse is not required. See page 67 of "Electrons in
-        nanostructures" C. Flindt, PhD Thesis available online:
-        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
-        file_4732600/content
-
-        Note also that the definition of the pseudo-inverse herein is different
-        from numpys pinv() alone, as it includes pre and post projection onto
-        the subspace defined by the projector Q.
-
-    """
-    if rhoss is None:
-        rhoss = steadystate(L)
-
-    sparse = kwargs.pop("sparse", False)
-    if method == "direct":
-        method = "splu" if sparse else "pinv"
-    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
-    dense_solvers = ["solve", "lstsq", "pinv"]
-    if isinstance(L.data, _data.CSR) and method in dense_solvers:
-        L = L.to("dense")
-    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
-        L = L.to("csr")
-
-    N = np.prod(L.dims[0][0])
-    dtype = type(L.data)
-    rhoss_vec = operator_to_vector(rhoss)
-
-    tr_op = qeye(L.dims[0][0])
-    tr_op_vec = operator_to_vector(tr_op)
-
-    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
-    I = _data.csr.identity(N * N)
-    Q = _data.sub(I, P)
-
-    if w in [None, 0.0]:
-        L += 1e-15j
-    else:
-        L += 1.0j*w
-
-    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
-
-    if use_rcm:
-        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
-        A = _data.permute.indices(L.data, perm, perm)
-        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
-    else:
-        A = L.data
-
-    if method in ["pinv", "numpy", "scipy", "scipy2"]:
-        # from scipy 1.7.0, they all use the same algorithm.
-        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
-        LIQ = _data.matmul(LI, Q)
-    elif method == "spilu":
-        if not isinstance(A, _data.CSR):
-            raise TypeError("'spilu' method can only be used with sparse data")
-        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
-        LIQ = _data.Dense(ILU.solve(Q.to_array()))
-    else:
-        LIQ = _data.solve(A, Q, method, options=kwargs)
-
-    R = _data.matmul(Q, LIQ)
-
-    if use_rcm:
-        rev_perm = np.argsort(perm)
-        R = _data.permute.indices(R, rev_perm, rev_perm)
-
-    return Qobj(R, dims=L.dims)
-
-
-def _compute_precond(L, args):
-    spilu_keys = {
-        'permc_spec',
-        'drop_tol',
-        'diag_pivot_thresh',
-        'fill_factor',
-        'options',
-    }
-    ss_args = {
-        key: args.pop(key)
-        for key in spilu_keys
-        if key in args
-    }
-    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
-    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
+from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
+from qutip import vector_to_operator, operator_to_vector
+from qutip import settings
+import qutip.core.data as _data
+import numpy as np
+import scipy.sparse.csgraph
+import scipy.sparse.linalg
+from warnings import warn
+
+
+__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
+
+
+def _permute_wbm(L, b):
+    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
+    L = _data.permute.indices(L, perm, None)
+    b = _data.permute.indices(b, perm, None)
+    return L, b
+
+
+def _permute_rcm(L, b):
+    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
+    L = _data.permute.indices(L, perm, perm)
+    b = _data.permute.indices(b, perm, None)
+    return L, b, perm
+
+
+def _reverse_rcm(rho, perm):
+    rev_perm = np.argsort(perm)
+    rho = _data.permute.indices(rho, rev_perm, None)
+    return rho
+
+
+def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
+    """
+    Calculates the steady state for quantum evolution subject to the supplied
+    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
+    collapse operators.
+
+    If the user passes a Hamiltonian then it, along with the list of collapse
+    operators, will be converted into a Liouvillian operator in Lindblad form.
+
+    Parameters
+    ----------
+    A : :obj:`~Qobj`
+        A Hamiltonian or Liouvillian operator.
+
+    c_op_list : list
+        A list of collapse operators.
+
+    method : str, default='direct'
+        The allowed methods are composed of 2 parts, the steadystate method:
+        - "direct": Solving ``L(rho_ss) = 0``
+        - "eigen" : Eigenvalue problem
+        - "svd" : Singular value decomposition
+        - "power" : Inverse-power method
+
+    solver : str, default=None
+        'direct' and 'power' methods only.
+        Solver to use when solving the ``L(rho_ss) = 0`` equation.
+        Default supported solver are:
+
+        - "solve", "lstsq"
+          dense solver from numpy.linalg
+        - "spsolve", "gmres", "lgmres", "bicgstab"
+          sparse solver from scipy.sparse.linalg
+        - "mkl_spsolve"
+          sparse solver by mkl.
+
+        Extension to qutip, such as qutip-tensorflow, can use come with their
+        own solver. When ``A`` and ``c_ops`` use these data backends, see the
+        corresponding libraries ``linalg`` for available solver.
+
+        Extra options for these solver can be passed in ``**kw``.
+
+    use_rcm : bool, default False
+        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
+        factorization of the Liouvillian.
+        Used with 'direct' or 'power' method.
+
+    use_wbm : bool, default False
+        Use Weighted Bipartite Matching reordering to make the Liouvillian
+        diagonally dominant.  This is useful for iterative preconditioners
+        only. Used with 'direct' or 'power' method.
+
+    weight : float, optional
+        Sets the size of the elements used for adding the unity trace condition
+        to the linear solvers.  This is set to the average abs value of the
+        Liouvillian elements if not specified by the user.
+        Used with 'direct' method.
+
+    power_tol : float, default 1e-12
+        Tolerance for the solution when using the 'power' method.
+
+    power_maxiter : int, default 10
+        Maximum number of iteration to use when looking for a solution when
+        using the 'power' method.
+
+    power_eps: double, default 1e-15
+        Small weight used in the "power" method.
+
+    sparse: bool
+        Whether to use the sparse eigen solver with the "eigen" method
+        (default sparse).  With "direct" and "power" method, when the solver is
+        not specified, it is used to set whether "solve" or "spsolve" is
+        used as default solver.
+
+    **kwargs :
+        Extra options to pass to the linear system solver. See the
+        documentation of the used solver in ``numpy.linalg`` or
+        ``scipy.sparse.linalg`` to see what extra arguments are supported.
+
+    Returns
+    -------
+    dm : qobj
+        Steady state density matrix.
+    info : dict, optional
+        Dictionary containing solver-specific information about the solution.
+
+    .. note::
+
+        The SVD method works only for dense operators (i.e. small systems).
+
+    """
+    if not A.issuper and not c_ops:
+        raise TypeError('Cannot calculate the steady state for a ' +
+                        'non-dissipative system.')
+    if not A.issuper:
+        A = liouvillian(A)
+    for op in c_ops:
+        A += lindblad_dissipator(op)
+
+    if "-" in method:
+        # to support v4's "power-gmres" method
+        method, solver = method.split("-")
+
+    if solver == "mkl":
+        solver = "mkl_spsolve"
+
+    # Keys supported in v4, but removed in v5
+    if kwargs.pop("return_info", False):
+        warn("Steadystate no longer supports return_info", DeprecationWarning)
+    if "mtol" in kwargs and "power_tol" not in kwargs:
+        kwargs["power_tol"] = kwargs["mtol"]
+    kwargs.pop("mtol", None)
+
+    if method == "eigen":
+        return _steadystate_eigen(A, **kwargs)
+    if method == "svd":
+        return _steadystate_svd(A, **kwargs)
+
+    # We want to be able to use this without having to know what data type the
+    # liouvillian uses. For extra data types (tensorflow) we can expect
+    # the users to know they are using them and choose an appropriate solver
+    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
+    if not isinstance(A.data, (_data.CSR, _data.Dense)):
+        # Tensorflow, jax, etc. data type
+        pass
+    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
+        A = A.to("dense")
+    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
+        A = A.to("csr")
+    elif solver is None and kwargs.get("sparse", False):
+        A = A.to("csr")
+        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
+    elif solver is None and (kwargs.get("sparse", None) is False):
+        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
+        A = A.to("dense")
+        solver = "solve"
+
+    if method in ["direct", "iterative"]:
+        # Remove unused kwargs, so only used and pass-through ones are included
+        kwargs.pop("power_tol", 0)
+        kwargs.pop("power_maxiter", 0)
+        kwargs.pop("power_eps", 0)
+        kwargs.pop("sparse", 0)
+        return _steadystate_direct(A, kwargs.pop("weight", 0),
+                                   method=solver, **kwargs)
+
+    elif method == "power":
+        # Remove unused kwargs, so only used and pass-through ones are included
+        kwargs.pop("weight", 0)
+        kwargs.pop("sparse", 0)
+        return _steadystate_power(A, method=solver, **kwargs)
+    else:
+        raise ValueError(f"method {method} not supported.")
+
+
+def _steadystate_direct(A, weight, **kw):
+    # Find the weight, no good dispatched function available...
+    if weight:
+        pass
+    elif isinstance(A.data, _data.CSR):
+        weight = np.mean(np.abs(A.data.as_scipy().data))
+    else:
+        A_np = np.abs(A.full())
+        weight = np.mean(A_np[A_np > 0])
+
+    # Add weight to the Liouvillian
+    # A[:, 0] = vectorized(eye * weight)
+    # We don't have a function to overwrite part of an array, so
+    N = A.shape[0]
+    n = int(N**0.5)
+    dtype = type(A.data)
+    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
+    weight_mat = _data.kron(
+        weight_vec.transpose(),
+        _data.one_element[dtype]((N, 1), (0, 0), 1)
+    )
+    L = _data.add(weight_mat, A.data)
+    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
+
+    # Permutation are part of scipy.sparse, thus only supported for CSR.
+    if kw.pop("use_wbm", False):
+        if isinstance(L, _data.CSR):
+            L, b = _permute_wbm(L, b)
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    use_rcm = False
+    if kw.pop("use_rcm", False):
+        if isinstance(L, _data.CSR):
+            L, b, perm = _permute_rcm(L, b)
+            use_rcm = True
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    if kw.pop("use_precond", False):
+        if isinstance(L, _data.CSR):
+            kw["M"] = _compute_precond(L, kw)
+        else:
+            warn("Only sparse solver use preconditioners.", RuntimeWarning)
+
+
+    method = kw.pop("method", None)
+    steadystate = _data.solve(L, b, method, options=kw)
+
+    if use_rcm:
+        steadystate = _reverse_rcm(steadystate, perm)
+
+    rho_ss = _data.column_unstack(steadystate, n)
+    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
+
+    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
+
+
+def _steadystate_eigen(L, **kw):
+    val, vec = (L.dag() @ L).eigenstates(
+        eigvals=1,
+        sort="low",
+        # v4's implementation only uses sparse eigen solver
+        sparse=kw.pop("sparse", True)
+    )
+    rho = vector_to_operator(vec[0])
+    return rho / rho.tr()
+
+
+def _steadystate_svd(L, **kw):
+    u, s, vh = _data.svd(L.data, True)
+    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
+    rho = vector_to_operator(vec)
+    return rho / rho.tr()
+
+
+def _steadystate_power(A, **kw):
+    A += kw.pop("power_eps", 1e-15)
+    L = A.data
+    N = L.shape[1]
+    y = _data.Dense([1]*N)
+
+    # Permutation are part of scipy.sparse, thus only supported for CSR.
+    if kw.pop("use_wbm", False):
+        if isinstance(L, _data.CSR):
+            L, y = _permute_wbm(L, y)
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    use_rcm = False
+    if kw.pop("use_rcm", False):
+        if isinstance(L, _data.CSR):
+            L, y, perm = _permute_rcm(L, y)
+            use_rcm = True
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    if kw.pop("use_precond", False):
+        if isinstance(L, _data.CSR):
+            kw["M"] = _compute_precond(L, kw)
+        else:
+            warn("Only sparse solver use preconditioners.", RuntimeWarning)
+
+    it = 0
+    maxiter = kw.pop("power_maxiter", 10)
+    tol = kw.pop("power_tol", 1e-12)
+    method = kw.pop("method", None)
+    while it < maxiter and _data.norm.max(L @ y) > tol:
+        y = _data.solve(L, y, method, options=kw)
+        y = y / _data.norm.max(y)
+        it += 1
+
+    if it >= maxiter:
+        raise Exception('Failed to find steady state after ' +
+                        str(maxiter) + ' iterations')
+
+    if use_rcm:
+        y = _reverse_rcm(y, perm)
+
+    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
+    rho_ss = rho_ss + rho_ss.dag()
+    rho_ss = rho_ss / rho_ss.tr()
+    rho_ss.isherm = True
+    return rho_ss
+
+
+def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
+                        solver=None, **kwargs):
+    """
+    Calculates the effective steady state for a driven
+     system with a time-dependent cosinusoidal term:
+
+    .. math::
+
+        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
+         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
+
+    Parameters
+    ----------
+    H_0 : :obj:`~Qobj`
+        A Hamiltonian or Liouvillian operator.
+
+    c_ops : list
+        A list of collapse operators.
+
+    Op_t : :obj:`~Qobj`
+        The the interaction operator which is multiplied by the cosine
+
+    w_d : float, default 1.0
+        The frequency of the drive
+
+    n_it : int, default 3
+        The number of iterations for the solver
+
+    sparse : bool, default False
+        Solve for the steady state using sparse algorithms.
+
+    solver : str, default=None
+        Solver to use when solving the linear system.
+        Default supported solver are:
+
+        - "solve", "lstsq"
+          dense solver from numpy.linalg
+        - "spsolve", "gmres", "lgmres", "bicgstab"
+          sparse solver from scipy.sparse.linalg
+        - "mkl_spsolve"
+          sparse solver by mkl.
+
+        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
+        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
+        for the names and details of additional solvers they may provide.
+
+    **kwargs:
+        Extra options to pass to the linear system solver. See the
+        documentation of the used solver in ``numpy.linalg`` or
+        ``scipy.sparse.linalg`` to see what extra arguments are supported.
+
+    Returns
+    -------
+    dm : qobj
+        Steady state density matrix.
+
+    .. note::
+
+        See: Sze Meng Tan,
+        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
+        Section (10.16)
+
+    """
+
+    L_0 = liouvillian(H_0, c_ops)
+    L_m = L_p = 0.5 * liouvillian(Op_t)
+    # L_p and L_m correspond to the positive and negative
+    # frequency terms respectively.
+    # They are independent in the model, so we keep both names.
+    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
+    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
+
+    if isinstance(H_0.data, _data.CSR) and not sparse:
+        L_0 = L_0.to("Dense")
+        L_m = L_m.to("Dense")
+        L_p = L_p.to("Dense")
+        Id = Id.to("Dense")
+
+    for n_i in np.arange(n_it, 0, -1):
+        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
+        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
+        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
+        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
+
+    M_subs = L_0 + L_m @ S + L_p @ T
+    return steadystate(M_subs, solver=solver, **kwargs)
+
+
+def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
+                   **kwargs):
+    """
+    Compute the pseudo inverse for a Liouvillian superoperator, optionally
+    given its steady state density matrix (which will be computed if not
+    given).
+
+    Parameters
+    ----------
+    L : Qobj
+        A Liouvillian superoperator for which to compute the pseudo inverse.
+
+    rhoss : Qobj
+        A steadystate density matrix as Qobj instance, for the Liouvillian
+        superoperator L.
+
+    w : double
+        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
+        systems and large sparse systems. Small sparse systems can fail for
+        zero frequencies.
+
+    sparse : bool
+        Flag that indicate whether to use sparse or dense matrix methods when
+        computing the pseudo inverse.
+
+    method : string
+        Method used to compte matrix inverse.
+        Choice are 'pinv' to use scipy's function of the same name, or a linear
+        system solver.
+        Default supported solver are:
+
+        - "solve", "lstsq"
+          dense solver from numpy.linalg
+        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
+          sparse solver from scipy.sparse.linalg
+        - "mkl_spsolve",
+          sparse solver by mkl.
+
+        Extension to qutip, such as qutip-tensorflow, can use come with their
+        own solver. When ``L`` use these data backends, see the corresponding
+        libraries ``linalg`` for available solver.
+
+    kwargs : dictionary
+        Additional keyword arguments for setting parameters for solver methods.
+
+    Returns
+    -------
+    R : Qobj
+        Returns a Qobj instance representing the pseudo inverse of L.
+
+    .. note::
+
+        In general the inverse of a sparse matrix will be dense.  If you
+        are applying the inverse to a density matrix then it is better to
+        cast the problem as an Ax=b type problem where the explicit calculation
+        of the inverse is not required. See page 67 of "Electrons in
+        nanostructures" C. Flindt, PhD Thesis available online:
+        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
+        file_4732600/content
+
+        Note also that the definition of the pseudo-inverse herein is different
+        from numpys pinv() alone, as it includes pre and post projection onto
+        the subspace defined by the projector Q.
+
+    """
+    if rhoss is None:
+        rhoss = steadystate(L)
+
+    sparse = kwargs.pop("sparse", False)
+    if method == "direct":
+        method = "splu" if sparse else "pinv"
+    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
+    dense_solvers = ["solve", "lstsq", "pinv"]
+    if isinstance(L.data, _data.CSR) and method in dense_solvers:
+        L = L.to("dense")
+    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
+        L = L.to("csr")
+
+    N = np.prod(L.dims[0][0])
+    dtype = type(L.data)
+    rhoss_vec = operator_to_vector(rhoss)
+
+    tr_op = qeye(L.dims[0][0])
+    tr_op_vec = operator_to_vector(tr_op)
+
+    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
+    I = _data.csr.identity(N * N)
+    Q = _data.sub(I, P)
+
+    if w in [None, 0.0]:
+        L += 1e-15j
+    else:
+        L += 1.0j*w
+
+    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
+
+    if use_rcm:
+        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
+        A = _data.permute.indices(L.data, perm, perm)
+        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
+    else:
+        A = L.data
+
+    if method in ["pinv", "numpy", "scipy", "scipy2"]:
+        # from scipy 1.7.0, they all use the same algorithm.
+        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
+        LIQ = _data.matmul(LI, Q)
+    elif method == "spilu":
+        if not isinstance(A, _data.CSR):
+            raise TypeError("'spilu' method can only be used with sparse data")
+        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
+        LIQ = _data.Dense(ILU.solve(Q.to_array()))
+    else:
+        LIQ = _data.solve(A, Q, method, options=kwargs)
+
+    R = _data.matmul(Q, LIQ)
+
+    if use_rcm:
+        rev_perm = np.argsort(perm)
+        R = _data.permute.indices(R, rev_perm, rev_perm)
+
+    return Qobj(R, dims=L.dims)
+
+
+def _compute_precond(L, args):
+    spilu_keys = {
+        'permc_spec',
+        'drop_tol',
+        'diag_pivot_thresh',
+        'fill_factor',
+        'options',
+    }
+    ss_args = {
+        key: args.pop(key)
+        for key in spilu_keys
+        if key in args
+    }
+    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
+    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
diff --git a/qutip/testing.py b/qutip/testing.py
index 60eb677f76..fc2d37689c 100644
--- a/qutip/testing.py
+++ b/qutip/testing.py
@@ -1,34 +1,34 @@
-from .about import about
-from .settings import settings as qset
-
-def run(full=False):
-    """
-    Run the test scripts for QuTiP.
-
-    Parameters
-    ----------
-    full: bool
-        If True run all test (30 min). Otherwise skip few variants of the
-        slowest tests.
-    """
-    # Call about to get all version info printed with tests
-    about()
-    import pytest
-    # real_num_cpu = qset.num_cpus
-    # real_thresh = qset.openmp_thresh
-    # if qset.has_openmp:
-        # For travis which VMs have only 1 cpu.
-        # Make sure the openmp version of the functions are tested.
-    #     qset.num_cpus = 2
-    #     qset.openmp_thresh = 100
-
-    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
-    if not full:
-        test_options += ['-m', 'not slow']
-    pytest.main(test_options + ["qutip"])
-    # runs tests in qutip.tests module only
-
-    # Restore previous settings
-    # if qset.has_openmp:
-    #     qset.num_cpus = real_num_cpu
-    #     qset.openmp_thresh = real_thresh
+from .about import about
+from .settings import settings as qset
+
+def run(full=False):
+    """
+    Run the test scripts for QuTiP.
+
+    Parameters
+    ----------
+    full: bool
+        If True run all test (30 min). Otherwise skip few variants of the
+        slowest tests.
+    """
+    # Call about to get all version info printed with tests
+    about()
+    import pytest
+    # real_num_cpu = qset.num_cpus
+    # real_thresh = qset.openmp_thresh
+    # if qset.has_openmp:
+        # For travis which VMs have only 1 cpu.
+        # Make sure the openmp version of the functions are tested.
+    #     qset.num_cpus = 2
+    #     qset.openmp_thresh = 100
+
+    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
+    if not full:
+        test_options += ['-m', 'not slow']
+    pytest.main(test_options + ["qutip"])
+    # runs tests in qutip.tests module only
+
+    # Restore previous settings
+    # if qset.has_openmp:
+    #     qset.num_cpus = real_num_cpu
+    #     qset.openmp_thresh = real_thresh
diff --git a/qutip/tests/Hadamard_params.ini b/qutip/tests/Hadamard_params.ini
index 60dc840fda..8d4ea5ab04 100644
--- a/qutip/tests/Hadamard_params.ini
+++ b/qutip/tests/Hadamard_params.ini
@@ -1,19 +1,19 @@
-[optimconfig]
-optim_method=FMIN_L_BFGS_B
-pulse_type = LIN
-
-[dynamics]
-evo_time = 6
-num_tslots = 6
-
-[termconds]
-fid_err_targ = 1e-10
-
-[optimizer]
-amp_lbound = -1.0
-amp_ubound = 1.0
-
-[pulsegen]
-scaling = 1.0
-lbound = -1.0
-ubound = 1.0
+[optimconfig]
+optim_method=FMIN_L_BFGS_B
+pulse_type = LIN
+
+[dynamics]
+evo_time = 6
+num_tslots = 6
+
+[termconds]
+fid_err_targ = 1e-10
+
+[optimizer]
+amp_lbound = -1.0
+amp_ubound = 1.0
+
+[pulsegen]
+scaling = 1.0
+lbound = -1.0
+ubound = 1.0
diff --git a/qutip/tests/conftest.py b/qutip/tests/conftest.py
index 49d4add02a..71c90d868f 100644
--- a/qutip/tests/conftest.py
+++ b/qutip/tests/conftest.py
@@ -1,158 +1,158 @@
-import pytest
-import functools
-import os
-import tempfile
-import numpy as np
-
-
-def _add_repeats_if_marked(metafunc):
-    """
-    If the metafunc is marked with the 'repeat' mark, then add the requisite
-    number of repeats via parametrisation.
-    """
-    marker = metafunc.definition.get_closest_marker('repeat')
-    if marker:
-        count = marker.args[0]
-        metafunc.fixturenames.append('_repeat_count')
-        metafunc.parametrize('_repeat_count',
-                             range(count),
-                             ids=["rep({})".format(x+1) for x in range(count)])
-
-
-def _skip_cython_tests_if_unavailable(item):
-    """
-    Skip the current test item if Cython is unavailable for import, or isn't a
-    high enough version.
-    """
-    if item.get_closest_marker("requires_cython"):
-        # importorskip rather than mark.skipif because this way we get pytest's
-        # version-handling semantics.
-        pytest.importorskip('Cython', minversion='0.14')
-
-
-@pytest.hookimpl(trylast=True)
-def pytest_generate_tests(metafunc):
-    _add_repeats_if_marked(metafunc)
-
-
-def pytest_runtest_setup(item):
-    _skip_cython_tests_if_unavailable(item)
-
-
-def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
-                           verbose=True, names=('ACTUAL', 'DESIRED'),
-                           precision=8):
-    """
-    Taken almost verbatim from `np.testing._private.utils`, except this version
-    doesn't truncate output if it's longer than three lines.
-
-    LICENCE
-    -------
-    Copyright (c) 2005-2020, NumPy Developers.
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    - Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-
-    - Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-
-    - Neither the name of the NumPy Developers nor the names of any
-      contributors may be used to endorse or promote products derived from this
-      software without specific prior written permission.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
-    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-    POSSIBILITY OF SUCH DAMAGE.
-    """
-    msg = ['\n' + header]
-    if err_msg:
-        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
-            msg = [msg[0] + ' ' + err_msg]
-        else:
-            msg.append(err_msg)
-    if verbose:
-        for i, a in enumerate(arrays):
-            if isinstance(a, np.ndarray):
-                # precision argument is only needed if the objects are ndarrays
-                r_func = functools.partial(np.core.array_repr,
-                                           precision=precision)
-            else:
-                r_func = repr
-
-            try:
-                # [diff] Remove truncation threshold from array output.
-                with np.printoptions(threshold=np.inf):
-                    r = r_func(a)
-            except Exception as exc:
-                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
-            # [diff] The original truncates the output to 3 lines here.
-            msg.append(' %s: %s' % (names[i], r))
-    return '\n'.join(msg)
-
-
-# Find the private module used by numpy to store its testing utility functions
-# so that we can monkeypatch the error messages to be more verbose.  QuTiP
-# supports numpy from 1.12 upwards, so we have to search.
-_numpy_private_utils_paths = [
-    ['_private', 'utils'],    # 1.15.0 <= x
-    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
-    ['utils'],                # 1.14.0 > x
-]
-for possible_path in _numpy_private_utils_paths:
-    try:
-        module = np.testing
-        for submodule in possible_path:
-            module = getattr(module, submodule)
-        _numpy_private_utils = module
-        break
-    except NameError:
-        pass
-else:
-    # If we can't locate it for some reason, then we don't attempt to patch.
-    _numpy_private_utils = None
-
-if _numpy_private_utils is not None:
-    @pytest.fixture(autouse=True)
-    def do_not_truncate_numpy_output(monkeypatch):
-        """
-        Monkeypatch the internal numpy function used for printing arrays so
-        that we get full output that isn't cut off after three lines.
-        """
-        with monkeypatch.context() as patch:
-            patch.setattr(np.testing._private.utils, "build_err_msg",
-                          _patched_build_err_msg)
-            # Yield inside context manager just to minimize the amount of time
-            # we've monkeypatched such a core library (and a private function!)
-            yield
-
-
-@pytest.fixture
-def in_temporary_directory():
-    """
-    Creates a temporary directory for the lifetime of the fixture and changes
-    into it.  All relative paths used will be in the temporary directory, and
-    everything will automatically be cleaned up at the end of the fixture's
-    life.
-    """
-    previous_dir = os.getcwd()
-    with tempfile.TemporaryDirectory() as temporary_dir:
-        os.chdir(temporary_dir)
-        yield
-        # pytest should catch exceptions occuring in functions using the
-        # fixture, so this should always be called.  We want it here rather
-        # than outside to prevent the case of the directory failing to be
-        # removed because it is 'busy'.
-        os.chdir(previous_dir)
+import pytest
+import functools
+import os
+import tempfile
+import numpy as np
+
+
+def _add_repeats_if_marked(metafunc):
+    """
+    If the metafunc is marked with the 'repeat' mark, then add the requisite
+    number of repeats via parametrisation.
+    """
+    marker = metafunc.definition.get_closest_marker('repeat')
+    if marker:
+        count = marker.args[0]
+        metafunc.fixturenames.append('_repeat_count')
+        metafunc.parametrize('_repeat_count',
+                             range(count),
+                             ids=["rep({})".format(x+1) for x in range(count)])
+
+
+def _skip_cython_tests_if_unavailable(item):
+    """
+    Skip the current test item if Cython is unavailable for import, or isn't a
+    high enough version.
+    """
+    if item.get_closest_marker("requires_cython"):
+        # importorskip rather than mark.skipif because this way we get pytest's
+        # version-handling semantics.
+        pytest.importorskip('Cython', minversion='0.14')
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_generate_tests(metafunc):
+    _add_repeats_if_marked(metafunc)
+
+
+def pytest_runtest_setup(item):
+    _skip_cython_tests_if_unavailable(item)
+
+
+def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
+                           verbose=True, names=('ACTUAL', 'DESIRED'),
+                           precision=8):
+    """
+    Taken almost verbatim from `np.testing._private.utils`, except this version
+    doesn't truncate output if it's longer than three lines.
+
+    LICENCE
+    -------
+    Copyright (c) 2005-2020, NumPy Developers.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    - Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    - Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    - Neither the name of the NumPy Developers nor the names of any
+      contributors may be used to endorse or promote products derived from this
+      software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+    """
+    msg = ['\n' + header]
+    if err_msg:
+        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
+            msg = [msg[0] + ' ' + err_msg]
+        else:
+            msg.append(err_msg)
+    if verbose:
+        for i, a in enumerate(arrays):
+            if isinstance(a, np.ndarray):
+                # precision argument is only needed if the objects are ndarrays
+                r_func = functools.partial(np.core.array_repr,
+                                           precision=precision)
+            else:
+                r_func = repr
+
+            try:
+                # [diff] Remove truncation threshold from array output.
+                with np.printoptions(threshold=np.inf):
+                    r = r_func(a)
+            except Exception as exc:
+                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
+            # [diff] The original truncates the output to 3 lines here.
+            msg.append(' %s: %s' % (names[i], r))
+    return '\n'.join(msg)
+
+
+# Find the private module used by numpy to store its testing utility functions
+# so that we can monkeypatch the error messages to be more verbose.  QuTiP
+# supports numpy from 1.12 upwards, so we have to search.
+_numpy_private_utils_paths = [
+    ['_private', 'utils'],    # 1.15.0 <= x
+    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
+    ['utils'],                # 1.14.0 > x
+]
+for possible_path in _numpy_private_utils_paths:
+    try:
+        module = np.testing
+        for submodule in possible_path:
+            module = getattr(module, submodule)
+        _numpy_private_utils = module
+        break
+    except NameError:
+        pass
+else:
+    # If we can't locate it for some reason, then we don't attempt to patch.
+    _numpy_private_utils = None
+
+if _numpy_private_utils is not None:
+    @pytest.fixture(autouse=True)
+    def do_not_truncate_numpy_output(monkeypatch):
+        """
+        Monkeypatch the internal numpy function used for printing arrays so
+        that we get full output that isn't cut off after three lines.
+        """
+        with monkeypatch.context() as patch:
+            patch.setattr(np.testing._private.utils, "build_err_msg",
+                          _patched_build_err_msg)
+            # Yield inside context manager just to minimize the amount of time
+            # we've monkeypatched such a core library (and a private function!)
+            yield
+
+
+@pytest.fixture
+def in_temporary_directory():
+    """
+    Creates a temporary directory for the lifetime of the fixture and changes
+    into it.  All relative paths used will be in the temporary directory, and
+    everything will automatically be cleaned up at the end of the fixture's
+    life.
+    """
+    previous_dir = os.getcwd()
+    with tempfile.TemporaryDirectory() as temporary_dir:
+        os.chdir(temporary_dir)
+        yield
+        # pytest should catch exceptions occuring in functions using the
+        # fixture, so this should always be called.  We want it here rather
+        # than outside to prevent the case of the directory failing to be
+        # removed because it is 'busy'.
+        os.chdir(previous_dir)
diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
index 01d05c01e8..c46297b1d8 100644
--- a/qutip/tests/core/data/conftest.py
+++ b/qutip/tests/core/data/conftest.py
@@ -1,66 +1,66 @@
-import numpy as np
-import scipy.sparse
-
-import qutip
-
-
-def shuffle_indices_scipy_csr(matrix):
-    """
-    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
-    return a new array.  This should represent the same matrix, but in the less
-    efficient, "unsorted" manner.  All mathematical operations should still
-    work the same after this, but may be slower.
-
-    This is not guaranteed to change the order of the indices in every case.
-    If there is at most one value per row, there is no unsorted order.  In
-    general, we attempt to shuffle, and if this returns the same order as
-    before, we just reverse it to ensure it's different.
-    """
-    out = matrix.copy()
-    for row in range(out.shape[0]):
-        ptr = (out.indptr[row], out.indptr[row + 1])
-        if ptr[1] - ptr[0] > 1:
-            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
-            # If sorted, reverse it.
-            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
-            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
-            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
-    return out
-
-
-def random_scipy_csr(shape, density, sorted_):
-    """
-    Generate a random scipy CSR matrix with the given shape, nnz density, and
-    with indices that are either sorted or unsorted.  The nnz elements will
-    always be at least one.
-    """
-    nnz = int(shape[0] * shape[1] * density) or 1
-    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-    rows = np.random.choice(np.arange(shape[0]), nnz)
-    cols = np.random.choice(np.arange(shape[1]), nnz)
-    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
-    if not sorted_:
-        shuffle_indices_scipy_csr(sci)
-    return sci
-
-
-def random_numpy_dense(shape, fortran):
-    """Generate a random numpy dense matrix with the given shape."""
-    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    if fortran:
-        out = np.asfortranarray(out)
-    return out
-
-
-def random_csr(shape, density, sorted_):
-    """
-    Generate a random qutip CSR matrix with the given shape, nnz density, and
-    with indices that are either sorted or unsorted.  The nnz elements will
-    always be at least one (use data.csr.zeros otherwise).
-    """
-    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
-
-
-def random_dense(shape, fortran):
-    """Generate a random qutip Dense matrix of the given shape."""
-    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
+import numpy as np
+import scipy.sparse
+
+import qutip
+
+
+def shuffle_indices_scipy_csr(matrix):
+    """
+    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
+    return a new array.  This should represent the same matrix, but in the less
+    efficient, "unsorted" manner.  All mathematical operations should still
+    work the same after this, but may be slower.
+
+    This is not guaranteed to change the order of the indices in every case.
+    If there is at most one value per row, there is no unsorted order.  In
+    general, we attempt to shuffle, and if this returns the same order as
+    before, we just reverse it to ensure it's different.
+    """
+    out = matrix.copy()
+    for row in range(out.shape[0]):
+        ptr = (out.indptr[row], out.indptr[row + 1])
+        if ptr[1] - ptr[0] > 1:
+            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
+            # If sorted, reverse it.
+            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
+            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
+            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
+    return out
+
+
+def random_scipy_csr(shape, density, sorted_):
+    """
+    Generate a random scipy CSR matrix with the given shape, nnz density, and
+    with indices that are either sorted or unsorted.  The nnz elements will
+    always be at least one.
+    """
+    nnz = int(shape[0] * shape[1] * density) or 1
+    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+    rows = np.random.choice(np.arange(shape[0]), nnz)
+    cols = np.random.choice(np.arange(shape[1]), nnz)
+    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
+    if not sorted_:
+        shuffle_indices_scipy_csr(sci)
+    return sci
+
+
+def random_numpy_dense(shape, fortran):
+    """Generate a random numpy dense matrix with the given shape."""
+    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    if fortran:
+        out = np.asfortranarray(out)
+    return out
+
+
+def random_csr(shape, density, sorted_):
+    """
+    Generate a random qutip CSR matrix with the given shape, nnz density, and
+    with indices that are either sorted or unsorted.  The nnz elements will
+    always be at least one (use data.csr.zeros otherwise).
+    """
+    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
+
+
+def random_dense(shape, fortran):
+    """Generate a random qutip Dense matrix of the given shape."""
+    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
index a7be4e6de9..77cf03cc82 100644
--- a/qutip/tests/core/data/test_convert.py
+++ b/qutip/tests/core/data/test_convert.py
@@ -1,78 +1,78 @@
-import numpy as np
-import pytest
-from scipy import sparse
-from qutip import data
-
-
-def test_init_empty_data():
-    shape = (3, 3)
-    base_data = data.Data(shape)
-    assert base_data.shape[0] == shape[0]
-    assert base_data.shape[1] == shape[1]
-
-
-@pytest.mark.parametrize(['base', 'dtype'], [
-    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
-    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
-    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
-                 id='array'),
-    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
-                 id='sparse'),
-    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
-    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
-                 id='sparse'),
-])
-def test_create(base, dtype):
-    # The test of exactitude is done in test_csr, test_dense.
-    created = data.create(base)
-    assert isinstance(created, dtype)
-
-
-@pytest.mark.parametrize(['from_', 'base'], [
-    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
-    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
-    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
-    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
-    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
-    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
-])
-@pytest.mark.parametrize(['to_', 'dtype'], [
-    pytest.param('dense', data.Dense, id='to Dense str'),
-    pytest.param('Dense', data.Dense, id='to Dense STR'),
-    pytest.param(data.Dense, data.Dense, id='to Dense type'),
-    pytest.param('csr', data.CSR, id='to CSR str'),
-    pytest.param('CSR', data.CSR, id='to CSR STR'),
-    pytest.param(data.CSR, data.CSR, id='to CSR type'),
-])
-def test_converters(from_, base, to_, dtype):
-    converter = data.to[to_, from_]
-    assert isinstance(converter(base), dtype)
-    converter = data.to[to_]
-    assert isinstance(converter(base), dtype)
-    assert isinstance(data.to(to_, base), dtype)
-
-
-dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
-dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
-@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-def test_parse_error(input, type_):
-    assert data.to.parse(input) is type_
-
-
-@pytest.mark.parametrize(['input', 'error', 'msg'], [
-    pytest.param(5, TypeError,
-                  "Invalid dtype is neither a type nor a type name: 5",
-                 id="wrong type"),
-    pytest.param("__this_is_not_a_known_type_name__", ValueError,
-                  "Type name is not known to the data-layer: "
-                  "'__this_is_not_a_known_type_name__'",
-                 id="not alias"),
-    pytest.param(object, ValueError,
-                  "Type is not a data-layer type: <class 'object'>",
-                 id="not Data"),
-])
-def test_parse_error(input, error, msg):
-    with pytest.raises(error) as exc:
-        data.to.parse(input)
-    assert str(exc.value) == msg
+import numpy as np
+import pytest
+from scipy import sparse
+from qutip import data
+
+
+def test_init_empty_data():
+    shape = (3, 3)
+    base_data = data.Data(shape)
+    assert base_data.shape[0] == shape[0]
+    assert base_data.shape[1] == shape[1]
+
+
+@pytest.mark.parametrize(['base', 'dtype'], [
+    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
+    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
+    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
+                 id='array'),
+    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
+                 id='sparse'),
+    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
+    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
+                 id='sparse'),
+])
+def test_create(base, dtype):
+    # The test of exactitude is done in test_csr, test_dense.
+    created = data.create(base)
+    assert isinstance(created, dtype)
+
+
+@pytest.mark.parametrize(['from_', 'base'], [
+    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
+    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
+    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
+    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
+    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
+    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
+])
+@pytest.mark.parametrize(['to_', 'dtype'], [
+    pytest.param('dense', data.Dense, id='to Dense str'),
+    pytest.param('Dense', data.Dense, id='to Dense STR'),
+    pytest.param(data.Dense, data.Dense, id='to Dense type'),
+    pytest.param('csr', data.CSR, id='to CSR str'),
+    pytest.param('CSR', data.CSR, id='to CSR STR'),
+    pytest.param(data.CSR, data.CSR, id='to CSR type'),
+])
+def test_converters(from_, base, to_, dtype):
+    converter = data.to[to_, from_]
+    assert isinstance(converter(base), dtype)
+    converter = data.to[to_]
+    assert isinstance(converter(base), dtype)
+    assert isinstance(data.to(to_, base), dtype)
+
+
+dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
+dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
+@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+def test_parse_error(input, type_):
+    assert data.to.parse(input) is type_
+
+
+@pytest.mark.parametrize(['input', 'error', 'msg'], [
+    pytest.param(5, TypeError,
+                  "Invalid dtype is neither a type nor a type name: 5",
+                 id="wrong type"),
+    pytest.param("__this_is_not_a_known_type_name__", ValueError,
+                  "Type name is not known to the data-layer: "
+                  "'__this_is_not_a_known_type_name__'",
+                 id="not alias"),
+    pytest.param(object, ValueError,
+                  "Type is not a data-layer type: <class 'object'>",
+                 id="not Data"),
+])
+def test_parse_error(input, error, msg):
+    with pytest.raises(error) as exc:
+        data.to.parse(input)
+    assert str(exc.value) == msg
diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
index 834c9febdb..853c762235 100644
--- a/qutip/tests/core/data/test_csr.py
+++ b/qutip/tests/core/data/test_csr.py
@@ -1,454 +1,454 @@
-import numpy as np
-import scipy.sparse
-import pytest
-
-from qutip.core import data
-from qutip.core.data import csr
-from qutip import qeye, CoreOptions
-
-from . import conftest
-
-# We only choose a small subset of dtypes to test so it isn't crazy.
-_dtype_complex = ['complex128']
-_dtype_float = ['float64']
-_dtype_int = ['int32', 'int64']
-_dtype_uint = ['uint32']
-
-
-# Set up some fixtures for automatic parametrisation.
-
-@pytest.fixture(params=[
-    pytest.param((1, 5), id='bra'),
-    pytest.param((5, 1), id='ket'),
-    pytest.param((5, 5), id='square'),
-    pytest.param((2, 4), id='wide'),
-    pytest.param((4, 2), id='tall'),
-])
-def shape(request): return request.param
-
-
-@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
-def density(request): return request.param
-
-
-@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
-def sorted_(request): return request.param
-
-
-def _valid_scipy():
-    """Arbitrary valid scipy CSR"""
-    return conftest.random_scipy_csr((10, 10), 0.5, True)
-
-
-def _valid_arg():
-    """
-    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
-    """
-    sci = _valid_scipy()
-    return (sci.data, sci.indices, sci.indptr)
-
-
-@pytest.fixture(scope='function')
-def scipy_csr(shape, density, sorted_):
-    return conftest.random_scipy_csr(shape, density, sorted_)
-
-
-@pytest.fixture(scope='function')
-def data_csr(shape, density, sorted_):
-    return conftest.random_csr(shape, density, sorted_)
-
-
-class TestClassMethods:
-    def test_init_from_tuple(self, scipy_csr):
-        """
-        Test that __init__ does not throw when passed a 3-tuple.  Also tests
-        the as_scipy() method succeeds.
-        """
-        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
-        out = data.CSR(arg, shape=scipy_csr.shape)
-        assert out.shape == scipy_csr.shape
-        assert (out.as_scipy() - scipy_csr).nnz == 0
-
-    @pytest.mark.parametrize('d_type', (
-        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
-    ))
-    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
-    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
-    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
-        """
-        Test that initialisation can use a variety of dtypes and converts into
-        the correct type.
-        """
-        sci = _valid_scipy()
-        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
-        col_index = sci.indices.astype(c_type, casting='unsafe')
-        row_index = sci.indptr.astype(r_type, casting='unsafe')
-        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
-                                            shape=sci.shape)
-        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
-        out_scipy = out.as_scipy()
-        assert out.shape == scipy_csr.shape
-        assert out_scipy.data.dtype == np.complex128
-        assert (out_scipy - scipy_csr).nnz == 0
-
-    def test_init_from_scipy(self, scipy_csr):
-        """Test that __init__ can accept a scipy CSR matrix."""
-        out = data.CSR(scipy_csr)
-        assert out.shape == scipy_csr.shape
-        assert (out.as_scipy() - scipy_csr).nnz == 0
-
-    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
-        pytest.param((), {}, ValueError, id="arg 0 tuple"),
-        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
-        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
-        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
-        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
-        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
-                     id="scipy-shape 0 tuple"),
-        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
-                     id="scipy-shape 1 tuple"),
-        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
-                     id="scipy-shape None tuple"),
-        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
-                     id="scipy-shape list"),
-        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
-                     id="scipy-shape 3 tuple"),
-        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
-                     id="arg-shape 0 tuple"),
-        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
-                     id="arg-shape 1 tuple"),
-        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
-                     id="arg-shape None tuple"),
-        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
-                     id="arg-shape list"),
-        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
-                     id="arg-shape 3 tuple"),
-        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
-                     id="arg-negative shape"),
-    ])
-    def test_init_from_wrong_input(self, arg, kwargs, error):
-        """
-        Test that the __init__ method raises a suitable error when passed
-        incorrectly formatted inputs.
-
-        This test also serves as a *partial* check that CSR safely handles
-        deallocation in the presence of exceptions in its __init__ method.  If
-        the tests segfault, it's quite likely that the memory management isn't
-        being done correctly in the hand-off us setting our data buffers up and
-        marking the numpy actually owns the data.
-        """
-        with pytest.raises(error):
-            data.CSR(arg, **kwargs)
-
-    def test_copy_returns_a_correct_copy(self, data_csr):
-        """
-        Test that the copy() method produces an actual copy, and that the
-        result represents the same matrix.
-        """
-        original = data_csr
-        copy = data_csr.copy()
-        assert original is not copy
-        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
-
-    def test_as_scipy_returns_a_view(self, data_csr):
-        """
-        Test that modifying the views in the result of as_scipy() also modifies
-        the underlying data structures.  This is important for allowing minor
-        data modifications from within Python-space.
-        """
-        unmodified_copy = data_csr.copy()
-        data_csr.as_scipy().data[0] += 1
-        modified_copy = data_csr.copy()
-        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
-        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
-
-    def test_as_scipy_caches_result(self, data_csr):
-        """
-        Test that the as_scipy() method always returns the same view, even if
-        called multiple times.
-        """
-        assert data_csr.as_scipy() is data_csr.as_scipy()
-
-    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
-        """
-        Test that we produce a new scipy matrix, regardless of how we have
-        initialised the type.
-        """
-        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
-
-    def test_as_scipy_of_copy_is_different(self, data_csr):
-        """
-        Test that as_scipy() does not return the same array, or the same views
-        if it's not the same input matrix.  We don't want two CSR matrices to
-        be linked.
-        """
-        original = data_csr.as_scipy()
-        copy = data_csr.copy().as_scipy()
-        assert original is not copy
-        assert not np.may_share_memory(original.data, copy.data)
-        assert not np.may_share_memory(original.indices, copy.indices)
-        assert not np.may_share_memory(original.indptr, copy.indptr)
-
-    def test_as_scipy_is_correct_result(self, scipy_csr):
-        """
-        Test that as_scipy is actually giving the matrix we expect for a given
-        input.
-        """
-        data_csr = data.CSR(scipy_csr)
-        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
-        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
-
-    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
-        nnz = int(shape[0] * shape[1] * density) or 1
-        base = csr.empty(shape[0], shape[1], nnz)
-        sci = base.as_scipy()
-        assert sci.nnz == 0
-        assert len(sci.data) == 0
-        assert len(sci.indices) == 0
-
-    def test_to_array_is_correct_result(self, data_csr):
-        test_array = data_csr.to_array()
-        assert isinstance(test_array, np.ndarray)
-        # It's not enough to be accurate within a tolerance here - there's no
-        # mathematics, so they should be _identical_.
-        assert np.all(test_array == data_csr.as_scipy().toarray())
-
-    def test_sorted_indices(self, data_csr):
-        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
-        # per row), so we add in this additional assertion message just to help
-        # out.
-        message = (
-            "Sort on {}sorted indices failed."
-            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
-        )
-        # We test on a copy because scipy attempts to cache
-        # `has_sorted_indices`, but since it's a view, it has no idea what
-        # we've done to the indices behind the scenes and typically would not
-        # notice the change.  The copy will return a difference scipy matrix,
-        # so the cache will not be built.
-        copy = data_csr.copy()
-        copy.sort_indices()
-        assert copy.as_scipy().has_sorted_indices, message
-
-
-class TestFactoryMethods:
-    def test_empty(self, shape, density):
-        nnz = int(shape[0] * shape[1] * density) or 1
-        base = csr.empty(shape[0], shape[1], nnz)
-        sci = base.as_scipy(full=True)
-        assert isinstance(base, data.CSR)
-        assert isinstance(sci, scipy.sparse.csr_matrix)
-        assert base.shape == shape
-        assert sci.data.shape == (nnz,)
-        assert sci.indices.shape == (nnz,)
-        assert sci.indptr.shape == (shape[0] + 1,)
-
-    def test_zeros(self, shape):
-        base = csr.zeros(shape[0], shape[1])
-        sci = base.as_scipy()
-        assert isinstance(base, data.CSR)
-        assert base.shape == shape
-        assert sci.nnz == 0
-        assert sci.indptr.shape == (shape[0] + 1,)
-
-    @pytest.mark.parametrize('dimension', [1, 5, 100])
-    @pytest.mark.parametrize(
-        'scale',
-        [None, 2, -0.1, 1.5, 1.5+1j],
-        ids=['none', 'int', 'negative', 'float', 'complex']
-    )
-    def test_identity(self, dimension, scale):
-        # scale=None is testing that the default value returns the identity.
-        base = (csr.identity(dimension) if scale is None
-                else csr.identity(dimension, scale))
-        sci = base.as_scipy()
-        scipy_test = scipy.sparse.eye(dimension,
-                                      dtype=np.complex128, format='csr')
-        if scale is not None:
-            scipy_test *= scale
-        assert isinstance(base, data.CSR)
-        assert base.shape == (dimension, dimension)
-        assert sci.nnz == dimension
-        assert (sci - scipy_test).nnz == 0
-
-    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
-        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
-        pytest.param([1], None, None, id='1x1'),
-        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
-        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
-        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
-        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
-                     id='two diagonals'),
-        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
-        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
-        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
-                     id='two wide super'),
-        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
-                     id='two tall sub'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
-                     id='out of order'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
-                     id='sum duplicates'),
-    ])
-    def test_diags(self, diagonals, offsets, shape):
-        base = csr.diags(diagonals, offsets, shape)
-        # Build numpy version test.
-        if not isinstance(diagonals[0], list):
-            diagonals = [diagonals]
-        offsets = np.atleast_1d(offsets if offsets is not None else [0])
-        if shape is None:
-            size = len(diagonals[0]) + abs(offsets[0])
-            shape = (size, size)
-        test = np.zeros(shape, dtype=np.complex128)
-        for diagonal, offset in zip(diagonals, offsets):
-            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-        assert isinstance(base, data.CSR)
-        assert base.shape == shape
-        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((1, 1), (0, 0), None, id='minimal'),
-        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
-        pytest.param((10, 10), (1, 5), 1., id='upper'),
-        pytest.param((10, 10), (5, 1), 2., id='lower'),
-        pytest.param((10, 1), (5, 0), None, id='column'),
-        pytest.param((1, 10), (0, 5), -5j, id='row'),
-        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
-        pytest.param((2, 10), (1, 5), 10, id='wide'),
-    ])
-    def test_one_element(self, shape, position, value):
-        test = np.zeros(shape, dtype=np.complex128)
-        if value is None:
-            base = data.one_element_csr(shape, position)
-            test[position] = 1.0+0.0j
-        else:
-            base = data.one_element_csr(shape, position, value)
-            test[position] = value
-        assert isinstance(base, data.CSR)
-        assert base.shape == shape
-        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((0, 0), (0, 0), None, id='zero shape'),
-        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
-        pytest.param((10, 10), (10, 5), 1., id='outside'),
-        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
-    ])
-    def test_one_element_error(self, shape, position, value):
-        with pytest.raises(ValueError) as exc:
-            base = data.one_element_csr(shape, position, value)
-        assert str(exc.value).startswith("Position of the elements"
-                                         " out of bound: ")
-
-
-class TestFromCSRBlocks:
-    class _blocks:
-        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
-            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
-            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
-            if isinstance(ops, int):
-                ops = [csr.zeros(block_size, block_size)] * ops
-            self.ops = np.array(ops, dtype=object)
-            self.n_blocks = n_blocks
-            self.block_size = block_size
-
-        def from_csr_blocks(self):
-            return csr._from_csr_blocks(
-                self.rows, self.cols, self.ops,
-                self.n_blocks, self.block_size,
-            )
-
-    @pytest.mark.parametrize(['blocks'], [
-        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
-        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
-    ])
-    def test_input_length_error(self, blocks):
-        with pytest.raises(ValueError) as exc:
-            blocks.from_csr_blocks()
-        assert str(exc.value) == (
-            "The arrays block_rows, block_cols and block_ops should have"
-            " the same length."
-        )
-
-    def test_op_shape_error(self):
-        blocks = self._blocks(
-            (0, 1), (0, 1),
-            (csr.zeros(2, 2), csr.zeros(3, 3)),
-        )
-        with pytest.raises(ValueError) as exc:
-            blocks.from_csr_blocks()
-        assert str(exc.value) == (
-            "Block operators (block_ops) do not have the correct shape."
-        )
-
-    @pytest.mark.parametrize(['blocks'], [
-        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
-        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
-        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
-    ])
-    def test_op_ordering_error(self, blocks):
-        with pytest.raises(ValueError) as exc:
-            blocks.from_csr_blocks()
-        assert str(exc.value) == (
-            "The arrays block_rows and block_cols must be sorted"
-            " by (row, column)."
-        )
-
-    @pytest.mark.parametrize(['blocks'], [
-        pytest.param(_blocks((), (), ()), id='no ops'),
-        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
-    ])
-    def test_zeros_output_fast_paths(self, blocks):
-        out = blocks.from_csr_blocks()
-        assert out == csr.zeros(2 * 2, 2 * 2)
-        assert csr.nnz(out) == 0
-
-    def test_construct_identity_with_empty(self):
-        # users are not expected to be exposed to
-        # csr.empty directly, but it is good to
-        # avoid segfaults, so we test passing
-        # csr.empty(..) blocks here explicitly
-        blocks = self._blocks(
-            [0, 0, 1, 1], [0, 1, 0, 1], [
-                csr.identity(2), csr.empty(2, 2, 0),
-                csr.empty(2, 2, 0), csr.identity(2),
-            ],
-        )
-        out = blocks.from_csr_blocks()
-        assert out == csr.identity(4)
-        assert csr.nnz(out) == 4
-
-    def test_construct_identity_with_zeros(self):
-        blocks = self._blocks(
-            [0, 0, 1, 1], [0, 1, 0, 1], [
-                csr.identity(2), csr.zeros(2, 2),
-                csr.zeros(2, 2), csr.identity(2),
-            ],
-        )
-        out = blocks.from_csr_blocks()
-        assert out == csr.identity(4)
-        assert csr.nnz(out) == 4
-
-    def test_construct_kron(self):
-        A = np.array([[1, 2], [3, 4]])
-        B = np.array([[0.3, 0.35], [0.4, 0.45]])
-        B_op = data.to("csr", data.Dense(B))
-        blocks = self._blocks(
-            [0, 0, 1, 1], [0, 1, 0, 1], [
-                A[0, 0] * B_op, A[0, 1] * B_op,
-                A[1, 0] * B_op, A[1, 1] * B_op,
-            ]
-        )
-        out = blocks.from_csr_blocks()
-        assert out == data.kron(data.Dense(A), data.Dense(B))
-        assert csr.nnz(out) == 16
-
-
-def test_tidyup():
-    small = qeye(1) * 1e-5
-    with CoreOptions(auto_tidyup_atol=1e-3):
-        assert (small + small).tr() == 0
-    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
-        assert (small + small).tr() == 2e-5
+import numpy as np
+import scipy.sparse
+import pytest
+
+from qutip.core import data
+from qutip.core.data import csr
+from qutip import qeye, CoreOptions
+
+from . import conftest
+
+# We only choose a small subset of dtypes to test so it isn't crazy.
+_dtype_complex = ['complex128']
+_dtype_float = ['float64']
+_dtype_int = ['int32', 'int64']
+_dtype_uint = ['uint32']
+
+
+# Set up some fixtures for automatic parametrisation.
+
+@pytest.fixture(params=[
+    pytest.param((1, 5), id='bra'),
+    pytest.param((5, 1), id='ket'),
+    pytest.param((5, 5), id='square'),
+    pytest.param((2, 4), id='wide'),
+    pytest.param((4, 2), id='tall'),
+])
+def shape(request): return request.param
+
+
+@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
+def density(request): return request.param
+
+
+@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
+def sorted_(request): return request.param
+
+
+def _valid_scipy():
+    """Arbitrary valid scipy CSR"""
+    return conftest.random_scipy_csr((10, 10), 0.5, True)
+
+
+def _valid_arg():
+    """
+    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
+    """
+    sci = _valid_scipy()
+    return (sci.data, sci.indices, sci.indptr)
+
+
+@pytest.fixture(scope='function')
+def scipy_csr(shape, density, sorted_):
+    return conftest.random_scipy_csr(shape, density, sorted_)
+
+
+@pytest.fixture(scope='function')
+def data_csr(shape, density, sorted_):
+    return conftest.random_csr(shape, density, sorted_)
+
+
+class TestClassMethods:
+    def test_init_from_tuple(self, scipy_csr):
+        """
+        Test that __init__ does not throw when passed a 3-tuple.  Also tests
+        the as_scipy() method succeeds.
+        """
+        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
+        out = data.CSR(arg, shape=scipy_csr.shape)
+        assert out.shape == scipy_csr.shape
+        assert (out.as_scipy() - scipy_csr).nnz == 0
+
+    @pytest.mark.parametrize('d_type', (
+        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
+    ))
+    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
+    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
+    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
+        """
+        Test that initialisation can use a variety of dtypes and converts into
+        the correct type.
+        """
+        sci = _valid_scipy()
+        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
+        col_index = sci.indices.astype(c_type, casting='unsafe')
+        row_index = sci.indptr.astype(r_type, casting='unsafe')
+        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
+                                            shape=sci.shape)
+        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
+        out_scipy = out.as_scipy()
+        assert out.shape == scipy_csr.shape
+        assert out_scipy.data.dtype == np.complex128
+        assert (out_scipy - scipy_csr).nnz == 0
+
+    def test_init_from_scipy(self, scipy_csr):
+        """Test that __init__ can accept a scipy CSR matrix."""
+        out = data.CSR(scipy_csr)
+        assert out.shape == scipy_csr.shape
+        assert (out.as_scipy() - scipy_csr).nnz == 0
+
+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+        pytest.param((), {}, ValueError, id="arg 0 tuple"),
+        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
+        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
+        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
+        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
+        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
+                     id="scipy-shape 0 tuple"),
+        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
+                     id="scipy-shape 1 tuple"),
+        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
+                     id="scipy-shape None tuple"),
+        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
+                     id="scipy-shape list"),
+        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
+                     id="scipy-shape 3 tuple"),
+        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
+                     id="arg-shape 0 tuple"),
+        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
+                     id="arg-shape 1 tuple"),
+        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
+                     id="arg-shape None tuple"),
+        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
+                     id="arg-shape list"),
+        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
+                     id="arg-shape 3 tuple"),
+        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
+                     id="arg-negative shape"),
+    ])
+    def test_init_from_wrong_input(self, arg, kwargs, error):
+        """
+        Test that the __init__ method raises a suitable error when passed
+        incorrectly formatted inputs.
+
+        This test also serves as a *partial* check that CSR safely handles
+        deallocation in the presence of exceptions in its __init__ method.  If
+        the tests segfault, it's quite likely that the memory management isn't
+        being done correctly in the hand-off us setting our data buffers up and
+        marking the numpy actually owns the data.
+        """
+        with pytest.raises(error):
+            data.CSR(arg, **kwargs)
+
+    def test_copy_returns_a_correct_copy(self, data_csr):
+        """
+        Test that the copy() method produces an actual copy, and that the
+        result represents the same matrix.
+        """
+        original = data_csr
+        copy = data_csr.copy()
+        assert original is not copy
+        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
+
+    def test_as_scipy_returns_a_view(self, data_csr):
+        """
+        Test that modifying the views in the result of as_scipy() also modifies
+        the underlying data structures.  This is important for allowing minor
+        data modifications from within Python-space.
+        """
+        unmodified_copy = data_csr.copy()
+        data_csr.as_scipy().data[0] += 1
+        modified_copy = data_csr.copy()
+        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
+        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
+
+    def test_as_scipy_caches_result(self, data_csr):
+        """
+        Test that the as_scipy() method always returns the same view, even if
+        called multiple times.
+        """
+        assert data_csr.as_scipy() is data_csr.as_scipy()
+
+    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
+        """
+        Test that we produce a new scipy matrix, regardless of how we have
+        initialised the type.
+        """
+        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
+
+    def test_as_scipy_of_copy_is_different(self, data_csr):
+        """
+        Test that as_scipy() does not return the same array, or the same views
+        if it's not the same input matrix.  We don't want two CSR matrices to
+        be linked.
+        """
+        original = data_csr.as_scipy()
+        copy = data_csr.copy().as_scipy()
+        assert original is not copy
+        assert not np.may_share_memory(original.data, copy.data)
+        assert not np.may_share_memory(original.indices, copy.indices)
+        assert not np.may_share_memory(original.indptr, copy.indptr)
+
+    def test_as_scipy_is_correct_result(self, scipy_csr):
+        """
+        Test that as_scipy is actually giving the matrix we expect for a given
+        input.
+        """
+        data_csr = data.CSR(scipy_csr)
+        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
+        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
+
+    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
+        nnz = int(shape[0] * shape[1] * density) or 1
+        base = csr.empty(shape[0], shape[1], nnz)
+        sci = base.as_scipy()
+        assert sci.nnz == 0
+        assert len(sci.data) == 0
+        assert len(sci.indices) == 0
+
+    def test_to_array_is_correct_result(self, data_csr):
+        test_array = data_csr.to_array()
+        assert isinstance(test_array, np.ndarray)
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(test_array == data_csr.as_scipy().toarray())
+
+    def test_sorted_indices(self, data_csr):
+        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
+        # per row), so we add in this additional assertion message just to help
+        # out.
+        message = (
+            "Sort on {}sorted indices failed."
+            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
+        )
+        # We test on a copy because scipy attempts to cache
+        # `has_sorted_indices`, but since it's a view, it has no idea what
+        # we've done to the indices behind the scenes and typically would not
+        # notice the change.  The copy will return a difference scipy matrix,
+        # so the cache will not be built.
+        copy = data_csr.copy()
+        copy.sort_indices()
+        assert copy.as_scipy().has_sorted_indices, message
+
+
+class TestFactoryMethods:
+    def test_empty(self, shape, density):
+        nnz = int(shape[0] * shape[1] * density) or 1
+        base = csr.empty(shape[0], shape[1], nnz)
+        sci = base.as_scipy(full=True)
+        assert isinstance(base, data.CSR)
+        assert isinstance(sci, scipy.sparse.csr_matrix)
+        assert base.shape == shape
+        assert sci.data.shape == (nnz,)
+        assert sci.indices.shape == (nnz,)
+        assert sci.indptr.shape == (shape[0] + 1,)
+
+    def test_zeros(self, shape):
+        base = csr.zeros(shape[0], shape[1])
+        sci = base.as_scipy()
+        assert isinstance(base, data.CSR)
+        assert base.shape == shape
+        assert sci.nnz == 0
+        assert sci.indptr.shape == (shape[0] + 1,)
+
+    @pytest.mark.parametrize('dimension', [1, 5, 100])
+    @pytest.mark.parametrize(
+        'scale',
+        [None, 2, -0.1, 1.5, 1.5+1j],
+        ids=['none', 'int', 'negative', 'float', 'complex']
+    )
+    def test_identity(self, dimension, scale):
+        # scale=None is testing that the default value returns the identity.
+        base = (csr.identity(dimension) if scale is None
+                else csr.identity(dimension, scale))
+        sci = base.as_scipy()
+        scipy_test = scipy.sparse.eye(dimension,
+                                      dtype=np.complex128, format='csr')
+        if scale is not None:
+            scipy_test *= scale
+        assert isinstance(base, data.CSR)
+        assert base.shape == (dimension, dimension)
+        assert sci.nnz == dimension
+        assert (sci - scipy_test).nnz == 0
+
+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+        pytest.param([1], None, None, id='1x1'),
+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+                     id='two diagonals'),
+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+                     id='two wide super'),
+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+                     id='two tall sub'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+                     id='out of order'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+                     id='sum duplicates'),
+    ])
+    def test_diags(self, diagonals, offsets, shape):
+        base = csr.diags(diagonals, offsets, shape)
+        # Build numpy version test.
+        if not isinstance(diagonals[0], list):
+            diagonals = [diagonals]
+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+        if shape is None:
+            size = len(diagonals[0]) + abs(offsets[0])
+            shape = (size, size)
+        test = np.zeros(shape, dtype=np.complex128)
+        for diagonal, offset in zip(diagonals, offsets):
+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+        assert isinstance(base, data.CSR)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((1, 1), (0, 0), None, id='minimal'),
+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+        pytest.param((10, 10), (1, 5), 1., id='upper'),
+        pytest.param((10, 10), (5, 1), 2., id='lower'),
+        pytest.param((10, 1), (5, 0), None, id='column'),
+        pytest.param((1, 10), (0, 5), -5j, id='row'),
+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+        pytest.param((2, 10), (1, 5), 10, id='wide'),
+    ])
+    def test_one_element(self, shape, position, value):
+        test = np.zeros(shape, dtype=np.complex128)
+        if value is None:
+            base = data.one_element_csr(shape, position)
+            test[position] = 1.0+0.0j
+        else:
+            base = data.one_element_csr(shape, position, value)
+            test[position] = value
+        assert isinstance(base, data.CSR)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+        pytest.param((10, 10), (10, 5), 1., id='outside'),
+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+    ])
+    def test_one_element_error(self, shape, position, value):
+        with pytest.raises(ValueError) as exc:
+            base = data.one_element_csr(shape, position, value)
+        assert str(exc.value).startswith("Position of the elements"
+                                         " out of bound: ")
+
+
+class TestFromCSRBlocks:
+    class _blocks:
+        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
+            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
+            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
+            if isinstance(ops, int):
+                ops = [csr.zeros(block_size, block_size)] * ops
+            self.ops = np.array(ops, dtype=object)
+            self.n_blocks = n_blocks
+            self.block_size = block_size
+
+        def from_csr_blocks(self):
+            return csr._from_csr_blocks(
+                self.rows, self.cols, self.ops,
+                self.n_blocks, self.block_size,
+            )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
+        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
+    ])
+    def test_input_length_error(self, blocks):
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "The arrays block_rows, block_cols and block_ops should have"
+            " the same length."
+        )
+
+    def test_op_shape_error(self):
+        blocks = self._blocks(
+            (0, 1), (0, 1),
+            (csr.zeros(2, 2), csr.zeros(3, 3)),
+        )
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "Block operators (block_ops) do not have the correct shape."
+        )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
+        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
+        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
+    ])
+    def test_op_ordering_error(self, blocks):
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "The arrays block_rows and block_cols must be sorted"
+            " by (row, column)."
+        )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((), (), ()), id='no ops'),
+        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
+    ])
+    def test_zeros_output_fast_paths(self, blocks):
+        out = blocks.from_csr_blocks()
+        assert out == csr.zeros(2 * 2, 2 * 2)
+        assert csr.nnz(out) == 0
+
+    def test_construct_identity_with_empty(self):
+        # users are not expected to be exposed to
+        # csr.empty directly, but it is good to
+        # avoid segfaults, so we test passing
+        # csr.empty(..) blocks here explicitly
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                csr.identity(2), csr.empty(2, 2, 0),
+                csr.empty(2, 2, 0), csr.identity(2),
+            ],
+        )
+        out = blocks.from_csr_blocks()
+        assert out == csr.identity(4)
+        assert csr.nnz(out) == 4
+
+    def test_construct_identity_with_zeros(self):
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                csr.identity(2), csr.zeros(2, 2),
+                csr.zeros(2, 2), csr.identity(2),
+            ],
+        )
+        out = blocks.from_csr_blocks()
+        assert out == csr.identity(4)
+        assert csr.nnz(out) == 4
+
+    def test_construct_kron(self):
+        A = np.array([[1, 2], [3, 4]])
+        B = np.array([[0.3, 0.35], [0.4, 0.45]])
+        B_op = data.to("csr", data.Dense(B))
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                A[0, 0] * B_op, A[0, 1] * B_op,
+                A[1, 0] * B_op, A[1, 1] * B_op,
+            ]
+        )
+        out = blocks.from_csr_blocks()
+        assert out == data.kron(data.Dense(A), data.Dense(B))
+        assert csr.nnz(out) == 16
+
+
+def test_tidyup():
+    small = qeye(1) * 1e-5
+    with CoreOptions(auto_tidyup_atol=1e-3):
+        assert (small + small).tr() == 0
+    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
+        assert (small + small).tr() == 2e-5
diff --git a/qutip/tests/core/data/test_dense.py b/qutip/tests/core/data/test_dense.py
index 072908115d..198ecf9828 100644
--- a/qutip/tests/core/data/test_dense.py
+++ b/qutip/tests/core/data/test_dense.py
@@ -1,297 +1,297 @@
-import numpy as np
-import pytest
-
-from qutip.core import data
-from qutip.core.data import dense, csr
-
-from . import conftest
-
-
-# Set up some fixtures for automatic parametrisation.
-
-@pytest.fixture(params=[
-    pytest.param((1, 5), id='ket'),
-    pytest.param((5, 1), id='bra'),
-    pytest.param((5, 5), id='square'),
-    pytest.param((2, 4), id='wide'),
-    pytest.param((4, 2), id='tall'),
-])
-def shape(request): return request.param
-
-
-@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
-def fortran(request): return request.param
-
-
-def _valid_numpy():
-    # Arbitrary valid numpy array.
-    return conftest.random_numpy_dense((5, 5), False)
-
-
-@pytest.fixture(scope='function')
-def numpy_dense(shape, fortran):
-    return conftest.random_numpy_dense(shape, fortran)
-
-
-@pytest.fixture(scope='function')
-def data_dense(shape, fortran):
-    return conftest.random_dense(shape, fortran)
-
-
-class TestClassMethods:
-    def test_init_from_ndarray(self, numpy_dense):
-        test = data.Dense(numpy_dense)
-        assert test.shape == numpy_dense.shape
-        assert np.all(test.as_ndarray() == numpy_dense)
-
-    @pytest.mark.parametrize('dtype', ['complex128',
-                                       'float64',
-                                       'int32', 'int64',
-                                       'uint32'])
-    def test_init_from_ndarray_other_dtype(self, shape, dtype):
-        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
-        test = data.Dense(numpy_dense)
-        assert test.shape == shape
-        assert test.as_ndarray().dtype == np.complex128
-        assert np.all(test.as_ndarray() == numpy_dense)
-
-    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
-        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
-                     id="numpy-shape 0 tuple"),
-        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
-                     id="numpy-shape 1 tuple"),
-        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
-                     id="numpy-shape None tuple"),
-        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
-                     id="numpy-shape list"),
-        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
-                     id="numpy-shape 3 tuple"),
-        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
-                     id="numpy-negative shape"),
-        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
-                     id="numpy-both negative shape"),
-        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
-                     id="numpy-different shape"),
-    ])
-    def test_init_from_wrong_input(self, arg, kwargs, error):
-        """
-        Test that the __init__ method raises a suitable error when passed
-        incorrectly formatted inputs.
-
-        This test also serves as a *partial* check that Dense safely handles
-        deallocation in the presence of exceptions in its __init__ method.  If
-        the tests segfault, it's quite likely that the memory management isn't
-        being done correctly in the hand-off us setting our data buffers up and
-        marking the numpy actually owns the data.
-        """
-        with pytest.raises(error):
-            data.Dense(arg, **kwargs)
-
-    def test_copy_returns_a_correct_copy(self, data_dense):
-        """
-        Test that the copy() method produces an actual copy, and that the
-        result represents the same matrix.
-        """
-        original = data_dense
-        copy = data_dense.copy()
-        assert original is not copy
-        assert np.all(original.as_ndarray() == copy.as_ndarray())
-
-    def test_as_ndarray_returns_a_view(self, data_dense):
-        """
-        Test that modifying the views in the result of as_ndarray() also
-        modifies the underlying data structures.  This is important for
-        allowing data modification from within Python-space.
-        """
-        unmodified_copy = data_dense.copy()
-        data_dense.as_ndarray()[0, 0] += 1
-        modified_copy = data_dense.copy()
-        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
-        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
-
-    def test_as_ndarray_caches_result(self, data_dense):
-        """
-        Test that the as_ndarray() method always returns the same view, even if
-        called multiple times.
-        """
-        assert data_dense.as_ndarray() is data_dense.as_ndarray()
-
-    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
-        """
-        Test that we produce a new ndarray, regardless of how we have
-        initialised the type.
-        """
-        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
-
-    def test_as_ndarray_of_copy_is_different(self, data_dense):
-        """
-        Test that as_ndarray() does not return the same array or a view to the
-        same data, if it's not the same input matrix.  We don't want two Dense
-        matrices to be linked.
-        """
-        original = data_dense.as_ndarray()
-        copy = data_dense.copy().as_ndarray()
-        assert original is not copy
-        assert not np.may_share_memory(original, copy)
-
-    def test_as_ndarray_is_correct_result(self, numpy_dense):
-        """
-        Test that as_ndarray is actually giving the matrix we expect for a given
-        input.
-        """
-        data_dense = data.Dense(numpy_dense)
-        nd_view = data_dense.as_ndarray()
-        assert isinstance(data_dense.as_ndarray(), np.ndarray)
-        assert nd_view.ndim == 2
-        assert nd_view.shape == numpy_dense.shape
-        assert nd_view.strides == numpy_dense.strides
-        assert np.all(nd_view == numpy_dense)
-        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
-        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
-
-    def test_to_array_is_correct_result(self, data_dense):
-        test_array = data_dense.to_array()
-        nd_view = data_dense.as_ndarray()
-        assert isinstance(test_array, np.ndarray)
-        assert test_array.ndim == 2
-        assert test_array.shape == nd_view.shape
-        assert test_array.strides == nd_view.strides
-        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
-        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
-        # It's not enough to be accurate within a tolerance here - there's no
-        # mathematics, so they should be _identical_.
-        assert np.all(test_array == nd_view)
-
-    @pytest.mark.parametrize('new_fortran', [
-        pytest.param(-1, id='swap'),
-        pytest.param(False, id='C'),
-        pytest.param(True, id='Fortran'),
-    ])
-    def test_reorder(self, data_dense, new_fortran):
-        reordered = data_dense.reorder(new_fortran)
-        assert isinstance(reordered, data.Dense)
-        assert reordered.shape == data_dense.shape
-        orig = data_dense.to_array()
-        test = reordered.to_array()
-        if new_fortran == -1:
-            orig.flags.f_contiguous == test.flags.c_contiguous
-            orig.flags.c_contiguous == test.flags.f_contiguous
-        elif new_fortran is True:
-            assert test.flags.f_contiguous
-        else:
-            assert test.flags.c_contiguous
-        assert np.all(orig == test)
-
-class TestFactoryMethods:
-    def test_empty(self, shape):
-        base = dense.empty(shape[0], shape[1])
-        nd = base.as_ndarray()
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        assert nd.shape == shape
-
-    def test_zeros(self, shape):
-        base = dense.zeros(shape[0], shape[1])
-        nd = base.as_ndarray()
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        assert nd.shape == shape
-        assert np.count_nonzero(nd) == 0
-
-    @pytest.mark.parametrize('dimension', [1, 5, 100])
-    @pytest.mark.parametrize(
-        'scale',
-        [None, 2, -0.1, 1.5, 1.5+1j],
-        ids=['none', 'int', 'negative', 'float', 'complex']
-    )
-    def test_identity(self, dimension, scale):
-        # scale=None is testing that the default value returns the identity.
-        base = (dense.identity(dimension) if scale is None
-                else dense.identity(dimension, scale))
-        nd = base.as_ndarray()
-        numpy_test = np.eye(dimension, dtype=np.complex128)
-        if scale is not None:
-            numpy_test *= scale
-        assert isinstance(base, data.Dense)
-        assert base.shape == (dimension, dimension)
-        assert np.count_nonzero(nd - numpy_test) == 0
-
-    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
-        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
-        pytest.param([1], None, None, id='1x1'),
-        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
-        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
-        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
-        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
-                     id='two diagonals'),
-        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
-        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
-        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
-                     id='two wide super'),
-        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
-                     id='two tall sub'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
-                     id='out of order'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
-                     id='sum duplicates'),
-    ])
-    def test_diags(self, diagonals, offsets, shape):
-        base = dense.diags(diagonals, offsets, shape)
-        # Build numpy version test.
-        if not isinstance(diagonals[0], list):
-            diagonals = [diagonals]
-        offsets = np.atleast_1d(offsets if offsets is not None else [0])
-        if shape is None:
-            size = len(diagonals[0]) + abs(offsets[0])
-            shape = (size, size)
-        test = np.zeros(shape, dtype=np.complex128)
-        for diagonal, offset in zip(diagonals, offsets):
-            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((1, 1), (0, 0), None, id='minimal'),
-        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
-        pytest.param((10, 10), (1, 5), 1., id='upper'),
-        pytest.param((10, 10), (5, 1), 2., id='lower'),
-        pytest.param((10, 1), (5, 0), None, id='column'),
-        pytest.param((1, 10), (0, 5), -5.j, id='row'),
-        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
-        pytest.param((2, 10), (1, 5), 10, id='wide'),
-    ])
-    def test_one_element(self, shape, position, value):
-        test = np.zeros(shape, dtype=np.complex128)
-        if value is None:
-            base = data.one_element_dense(shape, position)
-            test[position] = 1.0+0.0j
-        else:
-            base = data.one_element_dense(shape, position, value)
-            test[position] = value
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        assert np.allclose(base.to_array(), test, atol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((0, 0), (0, 0), None, id='zero shape'),
-        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
-        pytest.param((10, 10), (10, 5), 1., id='outside'),
-        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
-    ])
-    def test_one_element_error(self, shape, position, value):
-        with pytest.raises(ValueError) as exc:
-            base = data.one_element_dense(shape, position, value)
-        assert str(exc.value).startswith("Position of the elements"
-                                         " out of bound: ")
-
-
-def test_OrderEfficiencyWarning():
-    N = 5
-    M = csr.identity(N)
-    C_ordered = dense.zeros(N, 1, fortran=False)
-    fortran_ordered = dense.zeros(N, 1, fortran=True)
-    with pytest.warns(dense.OrderEfficiencyWarning):
-        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
+import numpy as np
+import pytest
+
+from qutip.core import data
+from qutip.core.data import dense, csr
+
+from . import conftest
+
+
+# Set up some fixtures for automatic parametrisation.
+
+@pytest.fixture(params=[
+    pytest.param((1, 5), id='ket'),
+    pytest.param((5, 1), id='bra'),
+    pytest.param((5, 5), id='square'),
+    pytest.param((2, 4), id='wide'),
+    pytest.param((4, 2), id='tall'),
+])
+def shape(request): return request.param
+
+
+@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
+def fortran(request): return request.param
+
+
+def _valid_numpy():
+    # Arbitrary valid numpy array.
+    return conftest.random_numpy_dense((5, 5), False)
+
+
+@pytest.fixture(scope='function')
+def numpy_dense(shape, fortran):
+    return conftest.random_numpy_dense(shape, fortran)
+
+
+@pytest.fixture(scope='function')
+def data_dense(shape, fortran):
+    return conftest.random_dense(shape, fortran)
+
+
+class TestClassMethods:
+    def test_init_from_ndarray(self, numpy_dense):
+        test = data.Dense(numpy_dense)
+        assert test.shape == numpy_dense.shape
+        assert np.all(test.as_ndarray() == numpy_dense)
+
+    @pytest.mark.parametrize('dtype', ['complex128',
+                                       'float64',
+                                       'int32', 'int64',
+                                       'uint32'])
+    def test_init_from_ndarray_other_dtype(self, shape, dtype):
+        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
+        test = data.Dense(numpy_dense)
+        assert test.shape == shape
+        assert test.as_ndarray().dtype == np.complex128
+        assert np.all(test.as_ndarray() == numpy_dense)
+
+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
+                     id="numpy-shape 0 tuple"),
+        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
+                     id="numpy-shape 1 tuple"),
+        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
+                     id="numpy-shape None tuple"),
+        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
+                     id="numpy-shape list"),
+        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
+                     id="numpy-shape 3 tuple"),
+        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
+                     id="numpy-negative shape"),
+        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
+                     id="numpy-both negative shape"),
+        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
+                     id="numpy-different shape"),
+    ])
+    def test_init_from_wrong_input(self, arg, kwargs, error):
+        """
+        Test that the __init__ method raises a suitable error when passed
+        incorrectly formatted inputs.
+
+        This test also serves as a *partial* check that Dense safely handles
+        deallocation in the presence of exceptions in its __init__ method.  If
+        the tests segfault, it's quite likely that the memory management isn't
+        being done correctly in the hand-off us setting our data buffers up and
+        marking the numpy actually owns the data.
+        """
+        with pytest.raises(error):
+            data.Dense(arg, **kwargs)
+
+    def test_copy_returns_a_correct_copy(self, data_dense):
+        """
+        Test that the copy() method produces an actual copy, and that the
+        result represents the same matrix.
+        """
+        original = data_dense
+        copy = data_dense.copy()
+        assert original is not copy
+        assert np.all(original.as_ndarray() == copy.as_ndarray())
+
+    def test_as_ndarray_returns_a_view(self, data_dense):
+        """
+        Test that modifying the views in the result of as_ndarray() also
+        modifies the underlying data structures.  This is important for
+        allowing data modification from within Python-space.
+        """
+        unmodified_copy = data_dense.copy()
+        data_dense.as_ndarray()[0, 0] += 1
+        modified_copy = data_dense.copy()
+        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
+        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
+
+    def test_as_ndarray_caches_result(self, data_dense):
+        """
+        Test that the as_ndarray() method always returns the same view, even if
+        called multiple times.
+        """
+        assert data_dense.as_ndarray() is data_dense.as_ndarray()
+
+    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
+        """
+        Test that we produce a new ndarray, regardless of how we have
+        initialised the type.
+        """
+        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
+
+    def test_as_ndarray_of_copy_is_different(self, data_dense):
+        """
+        Test that as_ndarray() does not return the same array or a view to the
+        same data, if it's not the same input matrix.  We don't want two Dense
+        matrices to be linked.
+        """
+        original = data_dense.as_ndarray()
+        copy = data_dense.copy().as_ndarray()
+        assert original is not copy
+        assert not np.may_share_memory(original, copy)
+
+    def test_as_ndarray_is_correct_result(self, numpy_dense):
+        """
+        Test that as_ndarray is actually giving the matrix we expect for a given
+        input.
+        """
+        data_dense = data.Dense(numpy_dense)
+        nd_view = data_dense.as_ndarray()
+        assert isinstance(data_dense.as_ndarray(), np.ndarray)
+        assert nd_view.ndim == 2
+        assert nd_view.shape == numpy_dense.shape
+        assert nd_view.strides == numpy_dense.strides
+        assert np.all(nd_view == numpy_dense)
+        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
+        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
+
+    def test_to_array_is_correct_result(self, data_dense):
+        test_array = data_dense.to_array()
+        nd_view = data_dense.as_ndarray()
+        assert isinstance(test_array, np.ndarray)
+        assert test_array.ndim == 2
+        assert test_array.shape == nd_view.shape
+        assert test_array.strides == nd_view.strides
+        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
+        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(test_array == nd_view)
+
+    @pytest.mark.parametrize('new_fortran', [
+        pytest.param(-1, id='swap'),
+        pytest.param(False, id='C'),
+        pytest.param(True, id='Fortran'),
+    ])
+    def test_reorder(self, data_dense, new_fortran):
+        reordered = data_dense.reorder(new_fortran)
+        assert isinstance(reordered, data.Dense)
+        assert reordered.shape == data_dense.shape
+        orig = data_dense.to_array()
+        test = reordered.to_array()
+        if new_fortran == -1:
+            orig.flags.f_contiguous == test.flags.c_contiguous
+            orig.flags.c_contiguous == test.flags.f_contiguous
+        elif new_fortran is True:
+            assert test.flags.f_contiguous
+        else:
+            assert test.flags.c_contiguous
+        assert np.all(orig == test)
+
+class TestFactoryMethods:
+    def test_empty(self, shape):
+        base = dense.empty(shape[0], shape[1])
+        nd = base.as_ndarray()
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert nd.shape == shape
+
+    def test_zeros(self, shape):
+        base = dense.zeros(shape[0], shape[1])
+        nd = base.as_ndarray()
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert nd.shape == shape
+        assert np.count_nonzero(nd) == 0
+
+    @pytest.mark.parametrize('dimension', [1, 5, 100])
+    @pytest.mark.parametrize(
+        'scale',
+        [None, 2, -0.1, 1.5, 1.5+1j],
+        ids=['none', 'int', 'negative', 'float', 'complex']
+    )
+    def test_identity(self, dimension, scale):
+        # scale=None is testing that the default value returns the identity.
+        base = (dense.identity(dimension) if scale is None
+                else dense.identity(dimension, scale))
+        nd = base.as_ndarray()
+        numpy_test = np.eye(dimension, dtype=np.complex128)
+        if scale is not None:
+            numpy_test *= scale
+        assert isinstance(base, data.Dense)
+        assert base.shape == (dimension, dimension)
+        assert np.count_nonzero(nd - numpy_test) == 0
+
+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+        pytest.param([1], None, None, id='1x1'),
+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+                     id='two diagonals'),
+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+                     id='two wide super'),
+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+                     id='two tall sub'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+                     id='out of order'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+                     id='sum duplicates'),
+    ])
+    def test_diags(self, diagonals, offsets, shape):
+        base = dense.diags(diagonals, offsets, shape)
+        # Build numpy version test.
+        if not isinstance(diagonals[0], list):
+            diagonals = [diagonals]
+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+        if shape is None:
+            size = len(diagonals[0]) + abs(offsets[0])
+            shape = (size, size)
+        test = np.zeros(shape, dtype=np.complex128)
+        for diagonal, offset in zip(diagonals, offsets):
+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((1, 1), (0, 0), None, id='minimal'),
+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+        pytest.param((10, 10), (1, 5), 1., id='upper'),
+        pytest.param((10, 10), (5, 1), 2., id='lower'),
+        pytest.param((10, 1), (5, 0), None, id='column'),
+        pytest.param((1, 10), (0, 5), -5.j, id='row'),
+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+        pytest.param((2, 10), (1, 5), 10, id='wide'),
+    ])
+    def test_one_element(self, shape, position, value):
+        test = np.zeros(shape, dtype=np.complex128)
+        if value is None:
+            base = data.one_element_dense(shape, position)
+            test[position] = 1.0+0.0j
+        else:
+            base = data.one_element_dense(shape, position, value)
+            test[position] = value
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert np.allclose(base.to_array(), test, atol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+        pytest.param((10, 10), (10, 5), 1., id='outside'),
+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+    ])
+    def test_one_element_error(self, shape, position, value):
+        with pytest.raises(ValueError) as exc:
+            base = data.one_element_dense(shape, position, value)
+        assert str(exc.value).startswith("Position of the elements"
+                                         " out of bound: ")
+
+
+def test_OrderEfficiencyWarning():
+    N = 5
+    M = csr.identity(N)
+    C_ordered = dense.zeros(N, 1, fortran=False)
+    fortran_ordered = dense.zeros(N, 1, fortran=True)
+    with pytest.warns(dense.OrderEfficiencyWarning):
+        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
index 256a703a89..29eaa5c231 100644
--- a/qutip/tests/core/data/test_expect.py
+++ b/qutip/tests/core/data/test_expect.py
@@ -1,67 +1,67 @@
-"""This file provides tests for expect specialisation. For tests at Qobj level
-see `qutip/tests/core/test_expect.py`"""
-
-from .test_mathematics import BinaryOpMixin
-import pytest
-import numpy as np
-from qutip import data
-from qutip.core.data import CSR, Dense
-from itertools import product
-
-
-class TestExpect(BinaryOpMixin):
-    def op_numpy(self, op, state):
-        is_ket = state.shape[1] == 1
-        if is_ket:
-            return np.conj(state.T)@op@state
-        else:
-            return np.trace(op@state)
-
-    _dim = 100
-    _ket = pytest.param((_dim, 1), id="ket")
-    _dm = pytest.param((_dim, _dim), id="dm")
-    _op = pytest.param((_dim, _dim), id="op")
-    _bra = pytest.param((1, _dim), id="bra")
-    _nonsquare = pytest.param((2, _dim), id="nonsquare")
-    _not_op = [_bra, _ket, _nonsquare]
-
-    shapes = [
-        (_op, _ket),
-        (_op, _dm),
-    ]
-    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
-    bad_shapes += [
-        (_op, _nonsquare),
-        (_op, _bra),
-    ]  # Bad ket/dm
-
-    specialisations = [
-        pytest.param(data.expect_csr, CSR, CSR, complex),
-        pytest.param(data.expect_dense, Dense, Dense, complex),
-        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
-    ]
-
-
-class TestExpectSuper(BinaryOpMixin):
-    def op_numpy(self, op, state):
-        n = np.sqrt(state.shape[0]).astype(int)
-        out_shape = (n, n)
-        return np.trace(np.reshape(op@state, newshape=out_shape))
-
-    _dim = 100
-    _super_ket = pytest.param((_dim, 1), id="super_ket")
-    _super_op = pytest.param((_dim, _dim), id="super_op")
-    _bra = pytest.param((1, _dim), id="row_stacked")
-    _nonsquare = pytest.param((2, _dim), id="nonsquare")
-    _not_super_ket = [_super_op, _bra, _nonsquare]
-    _not_super_op = [_super_ket, _bra, _nonsquare]
-
-    shapes = [(_super_op, _super_ket), ]
-    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
-    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
-
-    specialisations = [
-        pytest.param(data.expect_super_dense, Dense, Dense, complex),
-        pytest.param(data.expect_super_csr, CSR, CSR, complex),
-        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
-    ]
+"""This file provides tests for expect specialisation. For tests at Qobj level
+see `qutip/tests/core/test_expect.py`"""
+
+from .test_mathematics import BinaryOpMixin
+import pytest
+import numpy as np
+from qutip import data
+from qutip.core.data import CSR, Dense
+from itertools import product
+
+
+class TestExpect(BinaryOpMixin):
+    def op_numpy(self, op, state):
+        is_ket = state.shape[1] == 1
+        if is_ket:
+            return np.conj(state.T)@op@state
+        else:
+            return np.trace(op@state)
+
+    _dim = 100
+    _ket = pytest.param((_dim, 1), id="ket")
+    _dm = pytest.param((_dim, _dim), id="dm")
+    _op = pytest.param((_dim, _dim), id="op")
+    _bra = pytest.param((1, _dim), id="bra")
+    _nonsquare = pytest.param((2, _dim), id="nonsquare")
+    _not_op = [_bra, _ket, _nonsquare]
+
+    shapes = [
+        (_op, _ket),
+        (_op, _dm),
+    ]
+    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
+    bad_shapes += [
+        (_op, _nonsquare),
+        (_op, _bra),
+    ]  # Bad ket/dm
+
+    specialisations = [
+        pytest.param(data.expect_csr, CSR, CSR, complex),
+        pytest.param(data.expect_dense, Dense, Dense, complex),
+        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
+    ]
+
+
+class TestExpectSuper(BinaryOpMixin):
+    def op_numpy(self, op, state):
+        n = np.sqrt(state.shape[0]).astype(int)
+        out_shape = (n, n)
+        return np.trace(np.reshape(op@state, newshape=out_shape))
+
+    _dim = 100
+    _super_ket = pytest.param((_dim, 1), id="super_ket")
+    _super_op = pytest.param((_dim, _dim), id="super_op")
+    _bra = pytest.param((1, _dim), id="row_stacked")
+    _nonsquare = pytest.param((2, _dim), id="nonsquare")
+    _not_super_ket = [_super_op, _bra, _nonsquare]
+    _not_super_op = [_super_ket, _bra, _nonsquare]
+
+    shapes = [(_super_op, _super_ket), ]
+    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
+    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
+
+    specialisations = [
+        pytest.param(data.expect_super_dense, Dense, Dense, complex),
+        pytest.param(data.expect_super_csr, CSR, CSR, complex),
+        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
+    ]
diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index 50729bba9c..e1025fc229 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -1,139 +1,139 @@
-import qutip.settings as settings
-import numpy as np
-import scipy
-import pytest
-import qutip
-
-from qutip.core import data as _data
-from qutip.core.data import Data, Dense, CSR
-
-
-class TestSolve():
-    def op_numpy(self, A, b):
-        return np.linalg.solve(A, b)
-
-    def _gen_op(self, N, dtype):
-        return qutip.rand_unitary(N, dtype=dtype).data
-
-    def _gen_ket(self, N, dtype):
-        return qutip.rand_ket(N, dtype=dtype).data
-
-    @pytest.mark.parametrize(['method', "opt"], [
-        ("spsolve", {}),
-        ("splu", {"csc": True}),
-        ("gmres", {"atol": 1e-8}),
-        ("lsqr", {}),
-        pytest.param(
-            "mkl_spsolve", {},
-            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
-        ),
-    ],
-        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
-    )
-    def test_mathematically_correct_CSR(self, method, opt):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        A = self._gen_op(10, CSR)
-        b = self._gen_ket(10, Dense)
-        expected = self.op_numpy(A.to_array(), b.to_array())
-        test = _data.solve_csr_dense(A, b, method, opt)
-        test1 = _data.solve(A, b, method, opt)
-
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(test1.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-
-    @pytest.mark.parametrize(['method', "opt"], [
-        ("solve", {}),
-        ("lstsq", {}),
-    ])
-    def test_mathematically_correct_Dense(self, method, opt):
-        A = self._gen_op(10, Dense)
-        b = self._gen_ket(10, Dense)
-        expected = self.op_numpy(A.to_array(), b.to_array())
-        test = _data.solve_dense(A, b, method, opt)
-        test1 = _data.solve(A, b, method, opt)
-
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(test1.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-
-
-    def test_incorrect_shape_non_square(self):
-        A = qutip.Qobj(np.random.rand(5, 10)).data
-        b = qutip.Qobj(np.random.rand(10, 1)).data
-        with pytest.raises(ValueError):
-            test1 = _data.solve(A, b)
-
-
-    def test_incorrect_shape_mismatch(self):
-        A = qutip.Qobj(np.random.rand(10, 10)).data
-        b = qutip.Qobj(np.random.rand(9, 1)).data
-        with pytest.raises(ValueError):
-            test1 = _data.solve(A, b)
-
-
-class TestSVD():
-    def op_numpy(self, A):
-        return np.linalg.svd(A)
-
-    def _gen_dm(self, N, rank, dtype):
-        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
-
-    def _gen_non_square(self, N):
-        mat = np.random.randn(N, N//2)
-        for i in range(N//2):
-            # Ensure no zeros singular values
-            mat[i,i] += 5
-        return _data.Dense(mat)
-
-    @pytest.mark.parametrize("shape", ["square", "non-square"])
-    def test_mathematically_correct_svd(self, shape):
-        if shape == "square":
-            matrix = self._gen_dm(10, 6, Dense)
-        else:
-            matrix = self._gen_non_square(12)
-        u, s, v = self.op_numpy(matrix.to_array())
-        test_U, test_S, test_V = _data.svd(matrix, True)
-        only_S = _data.svd(matrix, False)
-
-        assert sum(test_S > 1e-10) == 6
-        # columns are definied up to a sign
-        np.testing.assert_allclose(
-            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
-        )
-        # rows are definied up to a sign
-        np.testing.assert_allclose(
-            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
-        )
-        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
-
-        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
-
-        np.testing.assert_allclose(
-            matrix.to_array(),
-            (test_U @ s_as_matrix @ test_V).to_array(),
-            atol=1e-7, rtol=1e-7
-        )
-
-    def test_mathematically_correct_svd_csr(self):
-        rank = 5
-        matrix = self._gen_dm(100, rank, CSR)
-        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
-        test_S2 = _data.svd_csr(matrix, False, k=rank)
-
-        assert len(test_S1) == rank
-        assert len(test_S2) == rank
-
-        np.testing.assert_allclose(
-            matrix.to_array(),
-            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
-            atol=1e-7, rtol=1e-7
-        )
+import qutip.settings as settings
+import numpy as np
+import scipy
+import pytest
+import qutip
+
+from qutip.core import data as _data
+from qutip.core.data import Data, Dense, CSR
+
+
+class TestSolve():
+    def op_numpy(self, A, b):
+        return np.linalg.solve(A, b)
+
+    def _gen_op(self, N, dtype):
+        return qutip.rand_unitary(N, dtype=dtype).data
+
+    def _gen_ket(self, N, dtype):
+        return qutip.rand_ket(N, dtype=dtype).data
+
+    @pytest.mark.parametrize(['method', "opt"], [
+        ("spsolve", {}),
+        ("splu", {"csc": True}),
+        ("gmres", {"atol": 1e-8}),
+        ("lsqr", {}),
+        pytest.param(
+            "mkl_spsolve", {},
+            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
+        ),
+    ],
+        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
+    )
+    def test_mathematically_correct_CSR(self, method, opt):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        A = self._gen_op(10, CSR)
+        b = self._gen_ket(10, Dense)
+        expected = self.op_numpy(A.to_array(), b.to_array())
+        test = _data.solve_csr_dense(A, b, method, opt)
+        test1 = _data.solve(A, b, method, opt)
+
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+        np.testing.assert_allclose(test1.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+
+    @pytest.mark.parametrize(['method', "opt"], [
+        ("solve", {}),
+        ("lstsq", {}),
+    ])
+    def test_mathematically_correct_Dense(self, method, opt):
+        A = self._gen_op(10, Dense)
+        b = self._gen_ket(10, Dense)
+        expected = self.op_numpy(A.to_array(), b.to_array())
+        test = _data.solve_dense(A, b, method, opt)
+        test1 = _data.solve(A, b, method, opt)
+
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+        np.testing.assert_allclose(test1.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+
+
+    def test_incorrect_shape_non_square(self):
+        A = qutip.Qobj(np.random.rand(5, 10)).data
+        b = qutip.Qobj(np.random.rand(10, 1)).data
+        with pytest.raises(ValueError):
+            test1 = _data.solve(A, b)
+
+
+    def test_incorrect_shape_mismatch(self):
+        A = qutip.Qobj(np.random.rand(10, 10)).data
+        b = qutip.Qobj(np.random.rand(9, 1)).data
+        with pytest.raises(ValueError):
+            test1 = _data.solve(A, b)
+
+
+class TestSVD():
+    def op_numpy(self, A):
+        return np.linalg.svd(A)
+
+    def _gen_dm(self, N, rank, dtype):
+        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
+
+    def _gen_non_square(self, N):
+        mat = np.random.randn(N, N//2)
+        for i in range(N//2):
+            # Ensure no zeros singular values
+            mat[i,i] += 5
+        return _data.Dense(mat)
+
+    @pytest.mark.parametrize("shape", ["square", "non-square"])
+    def test_mathematically_correct_svd(self, shape):
+        if shape == "square":
+            matrix = self._gen_dm(10, 6, Dense)
+        else:
+            matrix = self._gen_non_square(12)
+        u, s, v = self.op_numpy(matrix.to_array())
+        test_U, test_S, test_V = _data.svd(matrix, True)
+        only_S = _data.svd(matrix, False)
+
+        assert sum(test_S > 1e-10) == 6
+        # columns are definied up to a sign
+        np.testing.assert_allclose(
+            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
+        )
+        # rows are definied up to a sign
+        np.testing.assert_allclose(
+            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
+        )
+        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
+        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
+
+        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
+
+        np.testing.assert_allclose(
+            matrix.to_array(),
+            (test_U @ s_as_matrix @ test_V).to_array(),
+            atol=1e-7, rtol=1e-7
+        )
+
+    def test_mathematically_correct_svd_csr(self):
+        rank = 5
+        matrix = self._gen_dm(100, rank, CSR)
+        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
+        test_S2 = _data.svd_csr(matrix, False, k=rank)
+
+        assert len(test_S1) == rank
+        assert len(test_S2) == rank
+
+        np.testing.assert_allclose(
+            matrix.to_array(),
+            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
+            atol=1e-7, rtol=1e-7
+        )
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 459ab0d467..dfe3fe8a02 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -1,952 +1,952 @@
-import itertools
-import numpy as np
-import scipy
-import pytest
-
-from qutip.core import data
-from qutip.core.data import Data, Dense, CSR
-
-from . import conftest
-
-# The ParameterSet is actually a pretty hidden type, so it's easiest to access
-# it like this.
-_ParameterSet = type(pytest.param())
-
-# First set up a bunch of allowable shapes, for different types of functions so
-# we don't have to respecify a whole lot of things on repeat.
-
-
-def shapes_unary(dim=100):
-    """Base shapes to test for unary functions."""
-    # Be sure to test a full spectrum bra-type, ket-type and square and
-    # non-square operators.  Keep the dimension sensible, particularly for
-    # things like kron, since these shapes are reused to build the shapes for
-    # higher-order functions too.
-    return [
-        pytest.param((1, 1), id="scalar"),
-        pytest.param((1, dim), id="bra"),
-        pytest.param((dim, 1), id="ket"),
-        pytest.param((dim, dim), id="square"),
-        pytest.param((2, dim), id="nonsquare"),
-    ]
-
-
-def shapes_binary_identical(dim=100):
-    """
-    Allowed shapes for binary operators that need the two matrices to be the
-    same shape, e.g. addition.
-    """
-    return [(x, x) for x in shapes_unary(dim)]
-
-
-def shapes_binary_bad_identical(dim=100):
-    """
-    Disallowed shapes for binary operators that need the two matrices to be the
-    same shape, e.g. addition.
-    """
-    return [
-        (x, y)
-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-        if x.values[0] != y.values[0]
-    ]
-
-
-def shapes_binary_unrestricted(dim=100):
-    """
-    Allowed shapes for binary operators which can take any shapes, e.g. the
-    Kronecker product.
-    """
-    return list(itertools.product(shapes_unary(dim), repeat=2))
-
-
-def shapes_binary_bad_unrestricted(dim=100):
-    """
-    Disallowed shapes for binary operators which can take any shapes, e.g. the
-    Kronecker product.  There aren't actually any of these, but we keep it just
-    for consistency.
-    """
-    return []
-
-
-def shapes_binary_matmul(dim=100):
-    """
-    Allowed shapes for "matmul"-like operators that require that the "inner"
-    two indices are equal, i.e. the columns on the left equal the rows on the
-    right.
-    """
-    return [
-        (x, y)
-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-        if x.values[0][1] == y.values[0][0]
-    ]
-
-
-def shapes_binary_bad_matmul(dim=100):
-    """
-    Disallowed shapes for "matmul"-like operators that require that the "inner"
-    two indices are equal, i.e. the columns on the left equal the rows on the
-    right.
-    """
-    return [
-        (x, y)
-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-        if x.values[0][1] != y.values[0][0]
-    ]
-
-
-def shapes_square(dim=100):
-    """Allowed shapes for operations that require square matrices. Examples of
-    these operations are trace, pow, expm and the trace norm."""
-    return [
-        (pytest.param((1, 1), id="1"),),
-        (pytest.param((dim, dim), id=str(dim)),),
-    ]
-
-
-def shapes_not_square(dim=100):
-    """Disallowed shapes for operations that require square matrices. Examples
-    of these operations are trace, pow, expm and the trace norm."""
-    return [
-        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
-    ]
-
-
-# Set up the special cases for each type of matrix that will be tested.  These
-# should be kept low, because mathematical operations will test a Cartesian
-# product of all the cases of the same order as the operation, which can get
-# very large very fast.  The operations should each complete in a small amount
-# of time, so having 10000+ tests in this file still ought to take less than 2
-# minutes, but it's easy to accidentally add orders of magnitude on.
-#
-# There is a layer of indirection---the cases are returned as 0-ary generator
-# closures---for two reasons:
-#   1. we don't have to store huge amounts of data at test collection time, but
-#      the matrices are only generated, and subsequently freed, within in each
-#      individual test.
-#   2. each test can be repeated, and new random matrices will be generated for
-#      each repeat, rather than re-using the same set.  This is somewhat
-#      "defeating" pytest fixtures, but here we're not worried about re-usable
-#      inputs, we just want the managed parametrisation.
-
-def cases_csr(shape):
-    """
-    Return a list of generators of the different special cases for CSR
-    matrices of a given shape.
-    """
-    def factory(density, sort):
-        return lambda: conftest.random_csr(shape, density, sort)
-
-    def zero_factory():
-        return lambda: data.csr.zeros(shape[0], shape[1])
-    return [
-        pytest.param(factory(0.001, True), id="sparse"),
-        pytest.param(factory(0.8, True), id="filled,sorted"),
-        pytest.param(factory(0.8, False), id="filled,unsorted"),
-        pytest.param(zero_factory(), id="zero"),
-    ]
-
-
-def cases_dense(shape):
-    """
-    Return a list of generators of the different special cases for Dense
-    matrices of a given shape.
-    """
-    def factory(fortran):
-        return lambda: conftest.random_dense(shape, fortran)
-    return [
-        pytest.param(factory(False), id="C"),
-        pytest.param(factory(True), id="Fortran"),
-    ]
-
-
-# Factory methods for generating the cases, mapping type to the function.
-# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
-# getting just a single case from each.
-_ALL_CASES = {
-    CSR: cases_csr,
-    Dense: cases_dense,
-}
-_RANDOM = {
-    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
-    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
-}
-
-
-def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
-    """
-    Return a list of `pytest.ParameterSet` which is a flat list of all the
-    special cases that should be tested for this operator specialisation `op`,
-    which takes in several types `types`, where the arguments have shapes taken
-    from the iterable of iterables `shapes`.  If `out_type` is specified, it
-    will be added into the output parameter set and its name added to the id,
-    but is otherwise not used.
-
-    Parameters
-    ----------
-    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
-        Mapping to get the special case generator from.  This is one of
-        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
-        from the case generator should all be closures of the form `() -> Data`
-        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
-        containing exactly one value, which is the same closure type.
-
-    op: Function
-        The specialisation of a mathematical operation that is being tested.
-        This is actually generally unused - it's just added in to the output
-        ParameterSet at the end so that it will get correctly parametrised.
-
-    types: Tuple[Type]
-        A tuple of data.Data subclass types (not instances).  This defines the
-        inputs to this particular specialisation under test.  There should be
-        as many types as there are Data arguments to `op`.
-
-    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
-        An iterable containing several sets of shapes to parameterise over.
-        Each element of the iterable should be s tuple of shapes, or
-        `pytest.ParameterSet` instances each containing a single shape.  A
-        shape is a 2-tuple of integers.  There should be as many elements of
-        this inner tuple as there are `types`, since each individual `shape`
-        goes with a `type`.
-
-    out_type: Type
-        The output type for this specialisation.  Not used other than its name
-        being added to the id, and it being added at the end of the
-        specialisation (if it is given), similarly to `op`.
-
-    Returns
-    -------
-    List[ParameterSet]
-        A list of individual test cases for parametrisation.  Each ParameterSet
-        will be
-            [op, *data_inputs, ?out_type]
-        where `data_inputs` is of the same length as the input parameter
-        `types` and represents the Data arguments to the specialisation `op`.
-        Each element of `data_inputs` is a generator function which takes no
-        arguments and returns a data.Data subclass of the correct type and
-        shape.  `out_type` is present in the output only if it were given as a
-        parameter itself.
-    """
-    def case(type_, shape_case, generator_case):
-        """
-        Build a case parameter for _one_ generator function which will return
-        a given type and shape.
-        """
-        id_ = type_.__name__
-        inner = ""
-        for extra in [shape_case, generator_case]:
-            if hasattr(extra, 'id') and extra.id:
-                inner += ("," if inner else "") + extra.id
-        if inner:
-            id_ += "[" + inner + "]"
-        func = (
-            generator_case.values[0]
-            if isinstance(generator_case, _ParameterSet)
-            else generator_case
-        )
-        return pytest.param(func, id=id_)
-
-    cases = []
-    for shapes_ in shapes:
-        # Convert the list of types into a list of lists of the special cases
-        # needed for each type.
-        matrix_cases = [
-            [case(type_, shape_case, type_case)
-             for type_case in cases_lookup[type_](shape_case.values[0])]
-            for type_, shape_case in zip(types, shapes_)
-        ]
-        # Now Cartesian product all the special cases together to make the full
-        # set of parametrisations.
-        for matrices in itertools.product(*matrix_cases):
-            id_ = ",".join(m.id for m in matrices)
-            args = [m for p_m in matrices for m in p_m.values]
-            if out_type is not None:
-                id_ += "->" + out_type.__name__
-                args += [out_type]
-            cases.append(pytest.param(op, *args, id=id_))
-    return cases
-
-
-# Now we start to actually build up all the test cases.  Since all the
-# mathematical operations are really pretty similar, and most just need the
-# basic testing functionality, we do this with a series of mix-in classes which
-# provide various components of the testing and test-generation infrastructure.
-#
-# In each, we use the idiom that "test_<x>" is a test function which pytest
-# will collect for us, and "generate_<x>" a method which will be called by
-# `pytest_generate_tests` in order to generate all the parametrisations for the
-# given test.
-
-class _GenericOpMixin:
-    """
-    Abstract base mix-in which sets up the test generation for the two basic
-    test operations, and puts in the very generic test generator.  This does
-    not actually define the tests themselves, because subclasses need to define
-    them so the method arguments can be introspected to parametrise over the
-    correct number of arguments.
-
-    The tests `mathematically_correct` and `incorrect_shape_raises` will
-    parametrise Data types over method arguments which have names `data_*`.
-
-    The class arguments defined here are effectively parametrising the
-    mathematical tests.
-
-    Attributes
-    ----------
-    op_numpy: *args -> np.ndarray
-        Function which takes the same arguments as the mathematical operation,
-        but with all data arguments numpy arrays, and returns the expected
-        result.
-
-    atol: float
-        The absolute tolerance to use when comparing the test value with the
-        expected value.  If the output is a Data type, the tolerance is
-        per-element of the output.
-
-    rtol: float
-        The relative tolerance to use when comparing the test value with the
-        expected value.  If the output is a Data type, the tolerance is
-        per-element of the output.
-
-    shapes: list of (list of shapes)
-        A list of the sets of shapes which should be used for the tests of
-        mathematical correctness.  Each element of the list is a set of shapes,
-        each one corresponding to one of the arguments of the operation.
-
-    bad_shapes: list of (list of shapes)
-        Similar to `shapes`, but these should be shapes which are invalid for
-        the given mathematical operation.
-
-    specialisations: list of (function, Type, Type, [Type, ...])
-        The specialisations of each mathematical function, and the types that
-        it takes in and returns.  For example, the function
-            add(CSR, Dense) -> Other
-        would be specified as `(add, CSR, Dense, Other)`.
-    """
-    def op_numpy(self, *args): raise NotImplementedError
-    # With dimensions of around 100, we have to account for floating-point
-    # addition not being associative; the maths on full numpy arrays will often
-    # produce slightly different results to sparse algebra, since the order of
-    # multiplications and additions will be different.
-    atol = 1e-10
-    rtol = 1e-7  # Same default as numpy
-    shapes = []
-    bad_shapes = []
-    specialisations = []
-
-    def generate_mathematically_correct(self, metafunc):
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-            + ['out_type']
-        )
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, out_type = p_op.values
-            args = (op, types, self.shapes, out_type)
-            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
-        metafunc.parametrize(parameters, cases)
-
-    def generate_incorrect_shape_raises(self, metafunc):
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-        )
-        if not self.bad_shapes:
-            reason = "".join([
-                "no shapes are 'incorrect' for ",
-                metafunc.cls.__name__,
-                "::",
-                metafunc.function.__name__,
-            ])
-            false_case = pytest.param(*([None]*len(parameters)),
-                                      marks=pytest.mark.skip(reason),
-                                      id="no test")
-            metafunc.parametrize(parameters, [false_case])
-            return
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, _ = p_op.values
-            args = (op, types, self.bad_shapes)
-            cases.extend(cases_type_shape_product(_RANDOM, *args))
-        metafunc.parametrize(parameters, cases)
-
-    def pytest_generate_tests(self, metafunc):
-        # For every test function "test_xyz", we use the test generator
-        # "generate_xyz" if it exists.  This allows derived classes to add
-        # their own tests and generators without overiding this method, cutting
-        # down on boilerplate, but also that derived classes _may_ override the
-        # generation of tests defined in a base class, say if they have
-        # additional special arguments that need parametrising over.
-        generator_name = (
-            "generate_"
-            + metafunc.function.__name__.replace("test_", "")
-        )
-        try:
-            generator = getattr(self, generator_name)
-        except AttributeError:
-            return
-        generator(metafunc)
-
-
-class UnaryOpMixin(_GenericOpMixin):
-    """
-    Mix-in for unary mathematical operations on Data instances (e.g. unary
-    negation).
-    """
-    shapes = [(x,) for x in shapes_unary()]
-    bad_shapes = []
-
-    def test_mathematically_correct(self, op, data_m, out_type):
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array())
-        test = op(matrix)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        elif out_type is list:
-            for test_, expected_ in zip(test, expected):
-                assert test_.shape == expected_.shape
-                np.testing.assert_allclose(test_.to_array(), expected_,
-                                           atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_m):
-        """
-        Test that the operation produces a suitable error if the shape of the
-        given operand is not compatible with the operation. Useful for
-        operations that require square matrices (trace, pow, ...).
-        """
-        with pytest.raises(ValueError):
-            op(data_m())
-
-
-class UnaryScalarOpMixin(_GenericOpMixin):
-    """
-    Mix-in for unary mathematical operations on Data instances, but that also
-    take in a numeric scalar (e.g. scalar multiplication).  Only generates
-    the test `mathematically_correct`, since there can't be a shape mismatch
-    when there's only one Data argument.
-    """
-    shapes = [(x,) for x in shapes_unary()]
-
-    @pytest.mark.parametrize('scalar', [
-        pytest.param(0, id='zero'),
-        pytest.param(4.5, id='real'),
-        pytest.param(3j, id='complex'),
-    ])
-    def test_mathematically_correct(self, op, data_m, scalar, out_type):
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), scalar)
-        test = op(matrix, scalar)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol,
-                                       rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class BinaryOpMixin(_GenericOpMixin):
-    """
-    Mix-in for binary mathematical operations on Data instances (e.g. binary
-    addition).
-    """
-    def test_mathematically_correct(self, op, data_l, data_r, out_type):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        left, right = data_l(), data_r()
-        expected = self.op_numpy(left.to_array(), right.to_array())
-        test = op(left, right)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_l, data_r):
-        """
-        Test that the operation produces a suitable error if the shapes of the
-        given operands are not compatible.
-        """
-        with pytest.raises(ValueError):
-            op(data_l(), data_r())
-
-
-class TernaryOpMixin(_GenericOpMixin):
-    """
-    Mix-in for ternary mathematical operations on Data instances (e.g. inner
-    product with an operator in the middle).  This is pretty rare.
-    """
-    def test_mathematically_correct(self, op,
-                                    data_l, data_m, data_r,
-                                    out_type):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        left, mid, right = data_l(), data_m(), data_r()
-        expected = self.op_numpy(left.to_array(),
-                                 mid.to_array(),
-                                 right.to_array())
-        test = op(left, mid, right)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
-        """
-        Test that the operation produces a suitable error if the shapes of the
-        given operands are not compatible.
-        """
-        with pytest.raises(ValueError):
-            op(data_l(), data_m(), data_r())
-
-
-# And now finally we get into the meat of the actual mathematical tests.
-
-class TestAdd(BinaryOpMixin):
-    def op_numpy(self, left, right, scale):
-        return np.add(left, scale * right)
-
-    shapes = shapes_binary_identical()
-    bad_shapes = shapes_binary_bad_identical()
-    specialisations = [
-        pytest.param(data.add_csr, CSR, CSR, CSR),
-        pytest.param(data.add_dense, Dense, Dense, Dense),
-    ]
-
-    # `add` has an additional scalar parameter, because the operation is
-    # actually more like `A + c*B`.  We just parametrise that scalar
-    # separately.
-    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
-                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
-    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        left, right = data_l(), data_r()
-        if scale is not None:
-            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
-            test = op(left, right, scale)
-        else:
-            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
-            test = op(left, right)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class TestAdjoint(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.conj(matrix.T)
-
-    specialisations = [
-        pytest.param(data.adjoint_csr, CSR, CSR),
-        pytest.param(data.adjoint_dense, Dense, Dense),
-    ]
-
-
-class TestConj(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.conj(matrix)
-
-    specialisations = [
-        pytest.param(data.conj_csr, CSR, CSR),
-        pytest.param(data.conj_dense, Dense, Dense),
-    ]
-
-
-class TestInner(BinaryOpMixin):
-    # The inner product is a bit more specialist, since it has to handle inputs
-    # in a 1D space specially.  In order to keep things simple, we just
-    # generate those test cases completely separately from the standard
-    # `mathematically_correct`.
-
-    def op_numpy(self, left, right, scalar_is_ket=False):
-        if left.shape[1] == 1:
-            if left.shape[0] != 1 or scalar_is_ket:
-                left = np.conj(left.T)
-        return (left @ right)[0, 0]
-
-    # These shapes are a little more non-standard.
-    _dim = 100
-    _scalar = pytest.param((1, 1), id="scalar")
-    _bra = pytest.param((1, _dim), id="bra")
-    _ket = pytest.param((_dim, 1), id="ket")
-    _op = pytest.param((_dim, _dim), id="square")
-    shapes = [
-        (_bra, _ket),
-        (_ket, _ket),
-    ]
-    bad_shapes = [
-        (_bra, _bra),
-        (_ket, _bra),
-        (_op, _ket),
-        (_op, _bra),
-        (_bra, _op),
-        (_ket, _op),
-    ]
-
-    specialisations = [
-        pytest.param(data.inner_csr, CSR, CSR, complex),
-        pytest.param(data.inner_dense, Dense, Dense, complex),
-    ]
-
-    def generate_scalar_is_ket(self, metafunc):
-        # For 1D subspaces, the special cases don't really matter since there's
-        # only really one type of matrix available, so this is parametrised
-        # with only case for each input argument.
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-            + ['out_type']
-        )
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, out_type = p_op.values
-            args = (op, types, [(self._scalar, self._scalar)], out_type)
-            cases.extend(cases_type_shape_product(_RANDOM, *args))
-        metafunc.parametrize(parameters, cases)
-        metafunc.parametrize('scalar_is_ket',
-                             [True, False],
-                             ids=["ket", "bra"])
-
-    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
-        left, right = data_l(), data_r()
-        expected = self.op_numpy(left.to_array(), right.to_array(),
-                                 scalar_is_ket)
-        test = op(left, right, scalar_is_ket)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class TestInnerOp(TernaryOpMixin):
-    # This is very very similar to TestInner.
-    def op_numpy(self, left, mid, right, scalar_is_ket=False):
-        if left.shape[1] == 1:
-            if left.shape[0] != 1 or scalar_is_ket:
-                left = np.conj(left.T)
-        return (left @ mid @ right)[0, 0]
-
-    _dim = 100
-    _scalar = pytest.param((1, 1), id="scalar")
-    _bra = pytest.param((1, _dim), id="bra")
-    _ket = pytest.param((_dim, 1), id="ket")
-    _op = pytest.param((_dim, _dim), id="square")
-    shapes = [
-        (_bra, _op, _ket),
-        (_ket, _op, _ket),
-    ]
-    bad_shapes = [
-        (_bra, _op, _bra),
-        (_ket, _op, _bra),
-        (_op, _op, _ket),
-        (_op, _op, _bra),
-        (_bra, _op, _op),
-        (_ket, _op, _op),
-        (_bra, _bra, _ket),
-        (_ket, _bra, _ket),
-        (_bra, _ket, _ket),
-        (_ket, _ket, _ket),
-    ]
-
-    specialisations = [
-        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
-        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
-    ]
-
-    def generate_scalar_is_ket(self, metafunc):
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-            + ['out_type']
-        )
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, out_type = p_op.values
-            args = (op, types, [(self._scalar,) * 3], out_type)
-            cases.extend(cases_type_shape_product(_RANDOM, *args))
-        metafunc.parametrize(parameters, cases)
-        metafunc.parametrize('scalar_is_ket',
-                             [True, False], ids=["ket", "bra"])
-
-    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
-                           scalar_is_ket):
-        left, mid, right = data_l(), data_m(), data_r()
-        expected = self.op_numpy(left.to_array(),
-                                 mid.to_array(),
-                                 right.to_array(),
-                                 scalar_is_ket)
-        test = op(left, mid, right, scalar_is_ket)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol,
-                                       rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class TestKron(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return np.kron(left, right)
-
-    # Keep the dimension low because kron can get very expensive.
-    shapes = shapes_binary_unrestricted(dim=5)
-    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
-    specialisations = [
-        pytest.param(data.kron_csr, CSR, CSR, CSR),
-        pytest.param(data.kron_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestMatmul(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return np.matmul(left, right)
-
-    shapes = shapes_binary_matmul()
-    bad_shapes = shapes_binary_bad_matmul()
-    specialisations = [
-        pytest.param(data.matmul_csr, CSR, CSR, CSR),
-        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
-        pytest.param(data.matmul_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestMultiply(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return left * right
-
-    shapes = shapes_binary_identical()
-    bad_shapes = shapes_binary_bad_identical()
-    specialisations = [
-        pytest.param(data.multiply_csr, CSR, CSR, CSR),
-        pytest.param(data.multiply_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestMul(UnaryScalarOpMixin):
-    def op_numpy(self, matrix, scalar):
-        return scalar * matrix
-
-    specialisations = [
-        pytest.param(data.mul_csr, CSR, CSR),
-        pytest.param(data.mul_dense, Dense, Dense),
-    ]
-
-
-class TestNeg(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return -matrix
-
-    specialisations = [
-        pytest.param(data.neg_csr, CSR, CSR),
-        pytest.param(data.neg_dense, Dense, Dense),
-    ]
-
-
-class TestSub(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return left - right
-
-    shapes = shapes_binary_identical()
-    bad_shapes = shapes_binary_bad_identical()
-    specialisations = [
-        pytest.param(data.sub_csr, CSR, CSR, CSR),
-        pytest.param(data.sub_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestTrace(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.sum(np.diag(matrix))
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.trace_csr, CSR, complex),
-        pytest.param(data.trace_dense, Dense, complex),
-    ]
-
-
-class TestTrace_oper_ket(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        N = int(matrix.shape[0] ** 0.5)
-        return np.sum(np.diag(matrix.reshape((N, N))))
-
-    shapes = [
-        (pytest.param((100, 1), id="oper-ket"),),
-    ]
-    bad_shapes = [
-        (pytest.param((1, 100), id="bra"),),
-        (pytest.param((99, 1), id="ket"),),
-        (pytest.param((99, 99), id="ket"),),
-        (pytest.param((2, 99), id="nonsquare"),),
-    ]
-    specialisations = [
-        pytest.param(data.trace_oper_ket_csr, CSR, complex),
-        pytest.param(data.trace_oper_ket_dense, Dense, complex),
-    ]
-
-
-class TestPow(UnaryOpMixin):
-    def op_numpy(self, matrix, n):
-        return np.linalg.matrix_power(matrix, n)
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.pow_csr, CSR, CSR),
-        pytest.param(data.pow_dense, Dense, Dense),
-    ]
-
-    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
-    def test_mathematically_correct(self, op, data_m, out_type, n):
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), n)
-        test = op(matrix, n)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-                                   rtol=self.rtol)
-
-    # Pow actually does have bad shape, so we put that in too.
-    def test_incorrect_shape_raises(self, op, data_m):
-        """
-        Test that the operation produces a suitable error if the shape is not a
-        square matrix.
-        """
-        with pytest.raises(ValueError):
-            op(data_m(), 10)
-
-
-class TestExpm(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.expm(matrix)
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.expm_csr, CSR, CSR),
-        pytest.param(data.expm_csr_dense, CSR, Dense),
-        pytest.param(data.expm_dense, Dense, Dense),
-    ]
-
-
-class TestLogm(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.logm(matrix)
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.logm_dense, Dense, Dense),
-    ]
-
-
-class TestTranspose(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return matrix.T
-
-    specialisations = [
-        pytest.param(data.transpose_csr, CSR, CSR),
-        pytest.param(data.transpose_dense, Dense, Dense),
-    ]
-
-
-class TestProject(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        if matrix.shape[0] == 1:
-            return np.outer(np.conj(matrix), matrix)
-        else:
-            return np.outer(matrix, np.conj(matrix))
-
-    shapes = [
-        (pytest.param((1, 1), id="scalar"),),
-        (pytest.param((1, 100), id="bra"),),
-        (pytest.param((100, 1), id="ket"),),
-    ]
-    bad_shapes = [
-        (pytest.param((10, 10), id="square"),),
-        (pytest.param((2, 10), id="nonsquare"),),
-    ]
-
-    specialisations = [
-        pytest.param(data.project_csr, CSR, CSR),
-        pytest.param(data.project_dense, Dense, Dense),
-    ]
-
-
-def _inv_dense(matrix):
-    # Add a diagonal so `matrix` is not singular
-    return data.inv_dense(
-        data.add(
-            matrix,
-            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
-        )
-    )
-
-
-def _inv_csr(matrix):
-    # Add a diagonal so `matrix` is not singular
-    return data.inv_csr(
-        data.add(
-            matrix,
-            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
-        )
-    )
-
-
-class TestInv(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
-
-    shapes = [
-        (pytest.param((1, 1), id="scalar"),),
-        (pytest.param((10, 10), id="square"),),
-    ]
-    bad_shapes = [
-        (pytest.param((2, 10), id="nonsquare"),),
-        (pytest.param((1, 100), id="bra"),),
-        (pytest.param((100, 1), id="ket"),),
-    ]
-
-    specialisations = [
-        pytest.param(_inv_csr, CSR, CSR),
-        pytest.param(_inv_dense, Dense, Dense),
-    ]
+import itertools
+import numpy as np
+import scipy
+import pytest
+
+from qutip.core import data
+from qutip.core.data import Data, Dense, CSR
+
+from . import conftest
+
+# The ParameterSet is actually a pretty hidden type, so it's easiest to access
+# it like this.
+_ParameterSet = type(pytest.param())
+
+# First set up a bunch of allowable shapes, for different types of functions so
+# we don't have to respecify a whole lot of things on repeat.
+
+
+def shapes_unary(dim=100):
+    """Base shapes to test for unary functions."""
+    # Be sure to test a full spectrum bra-type, ket-type and square and
+    # non-square operators.  Keep the dimension sensible, particularly for
+    # things like kron, since these shapes are reused to build the shapes for
+    # higher-order functions too.
+    return [
+        pytest.param((1, 1), id="scalar"),
+        pytest.param((1, dim), id="bra"),
+        pytest.param((dim, 1), id="ket"),
+        pytest.param((dim, dim), id="square"),
+        pytest.param((2, dim), id="nonsquare"),
+    ]
+
+
+def shapes_binary_identical(dim=100):
+    """
+    Allowed shapes for binary operators that need the two matrices to be the
+    same shape, e.g. addition.
+    """
+    return [(x, x) for x in shapes_unary(dim)]
+
+
+def shapes_binary_bad_identical(dim=100):
+    """
+    Disallowed shapes for binary operators that need the two matrices to be the
+    same shape, e.g. addition.
+    """
+    return [
+        (x, y)
+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+        if x.values[0] != y.values[0]
+    ]
+
+
+def shapes_binary_unrestricted(dim=100):
+    """
+    Allowed shapes for binary operators which can take any shapes, e.g. the
+    Kronecker product.
+    """
+    return list(itertools.product(shapes_unary(dim), repeat=2))
+
+
+def shapes_binary_bad_unrestricted(dim=100):
+    """
+    Disallowed shapes for binary operators which can take any shapes, e.g. the
+    Kronecker product.  There aren't actually any of these, but we keep it just
+    for consistency.
+    """
+    return []
+
+
+def shapes_binary_matmul(dim=100):
+    """
+    Allowed shapes for "matmul"-like operators that require that the "inner"
+    two indices are equal, i.e. the columns on the left equal the rows on the
+    right.
+    """
+    return [
+        (x, y)
+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+        if x.values[0][1] == y.values[0][0]
+    ]
+
+
+def shapes_binary_bad_matmul(dim=100):
+    """
+    Disallowed shapes for "matmul"-like operators that require that the "inner"
+    two indices are equal, i.e. the columns on the left equal the rows on the
+    right.
+    """
+    return [
+        (x, y)
+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+        if x.values[0][1] != y.values[0][0]
+    ]
+
+
+def shapes_square(dim=100):
+    """Allowed shapes for operations that require square matrices. Examples of
+    these operations are trace, pow, expm and the trace norm."""
+    return [
+        (pytest.param((1, 1), id="1"),),
+        (pytest.param((dim, dim), id=str(dim)),),
+    ]
+
+
+def shapes_not_square(dim=100):
+    """Disallowed shapes for operations that require square matrices. Examples
+    of these operations are trace, pow, expm and the trace norm."""
+    return [
+        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
+    ]
+
+
+# Set up the special cases for each type of matrix that will be tested.  These
+# should be kept low, because mathematical operations will test a Cartesian
+# product of all the cases of the same order as the operation, which can get
+# very large very fast.  The operations should each complete in a small amount
+# of time, so having 10000+ tests in this file still ought to take less than 2
+# minutes, but it's easy to accidentally add orders of magnitude on.
+#
+# There is a layer of indirection---the cases are returned as 0-ary generator
+# closures---for two reasons:
+#   1. we don't have to store huge amounts of data at test collection time, but
+#      the matrices are only generated, and subsequently freed, within in each
+#      individual test.
+#   2. each test can be repeated, and new random matrices will be generated for
+#      each repeat, rather than re-using the same set.  This is somewhat
+#      "defeating" pytest fixtures, but here we're not worried about re-usable
+#      inputs, we just want the managed parametrisation.
+
+def cases_csr(shape):
+    """
+    Return a list of generators of the different special cases for CSR
+    matrices of a given shape.
+    """
+    def factory(density, sort):
+        return lambda: conftest.random_csr(shape, density, sort)
+
+    def zero_factory():
+        return lambda: data.csr.zeros(shape[0], shape[1])
+    return [
+        pytest.param(factory(0.001, True), id="sparse"),
+        pytest.param(factory(0.8, True), id="filled,sorted"),
+        pytest.param(factory(0.8, False), id="filled,unsorted"),
+        pytest.param(zero_factory(), id="zero"),
+    ]
+
+
+def cases_dense(shape):
+    """
+    Return a list of generators of the different special cases for Dense
+    matrices of a given shape.
+    """
+    def factory(fortran):
+        return lambda: conftest.random_dense(shape, fortran)
+    return [
+        pytest.param(factory(False), id="C"),
+        pytest.param(factory(True), id="Fortran"),
+    ]
+
+
+# Factory methods for generating the cases, mapping type to the function.
+# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
+# getting just a single case from each.
+_ALL_CASES = {
+    CSR: cases_csr,
+    Dense: cases_dense,
+}
+_RANDOM = {
+    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
+    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
+}
+
+
+def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
+    """
+    Return a list of `pytest.ParameterSet` which is a flat list of all the
+    special cases that should be tested for this operator specialisation `op`,
+    which takes in several types `types`, where the arguments have shapes taken
+    from the iterable of iterables `shapes`.  If `out_type` is specified, it
+    will be added into the output parameter set and its name added to the id,
+    but is otherwise not used.
+
+    Parameters
+    ----------
+    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
+        Mapping to get the special case generator from.  This is one of
+        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
+        from the case generator should all be closures of the form `() -> Data`
+        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
+        containing exactly one value, which is the same closure type.
+
+    op: Function
+        The specialisation of a mathematical operation that is being tested.
+        This is actually generally unused - it's just added in to the output
+        ParameterSet at the end so that it will get correctly parametrised.
+
+    types: Tuple[Type]
+        A tuple of data.Data subclass types (not instances).  This defines the
+        inputs to this particular specialisation under test.  There should be
+        as many types as there are Data arguments to `op`.
+
+    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
+        An iterable containing several sets of shapes to parameterise over.
+        Each element of the iterable should be s tuple of shapes, or
+        `pytest.ParameterSet` instances each containing a single shape.  A
+        shape is a 2-tuple of integers.  There should be as many elements of
+        this inner tuple as there are `types`, since each individual `shape`
+        goes with a `type`.
+
+    out_type: Type
+        The output type for this specialisation.  Not used other than its name
+        being added to the id, and it being added at the end of the
+        specialisation (if it is given), similarly to `op`.
+
+    Returns
+    -------
+    List[ParameterSet]
+        A list of individual test cases for parametrisation.  Each ParameterSet
+        will be
+            [op, *data_inputs, ?out_type]
+        where `data_inputs` is of the same length as the input parameter
+        `types` and represents the Data arguments to the specialisation `op`.
+        Each element of `data_inputs` is a generator function which takes no
+        arguments and returns a data.Data subclass of the correct type and
+        shape.  `out_type` is present in the output only if it were given as a
+        parameter itself.
+    """
+    def case(type_, shape_case, generator_case):
+        """
+        Build a case parameter for _one_ generator function which will return
+        a given type and shape.
+        """
+        id_ = type_.__name__
+        inner = ""
+        for extra in [shape_case, generator_case]:
+            if hasattr(extra, 'id') and extra.id:
+                inner += ("," if inner else "") + extra.id
+        if inner:
+            id_ += "[" + inner + "]"
+        func = (
+            generator_case.values[0]
+            if isinstance(generator_case, _ParameterSet)
+            else generator_case
+        )
+        return pytest.param(func, id=id_)
+
+    cases = []
+    for shapes_ in shapes:
+        # Convert the list of types into a list of lists of the special cases
+        # needed for each type.
+        matrix_cases = [
+            [case(type_, shape_case, type_case)
+             for type_case in cases_lookup[type_](shape_case.values[0])]
+            for type_, shape_case in zip(types, shapes_)
+        ]
+        # Now Cartesian product all the special cases together to make the full
+        # set of parametrisations.
+        for matrices in itertools.product(*matrix_cases):
+            id_ = ",".join(m.id for m in matrices)
+            args = [m for p_m in matrices for m in p_m.values]
+            if out_type is not None:
+                id_ += "->" + out_type.__name__
+                args += [out_type]
+            cases.append(pytest.param(op, *args, id=id_))
+    return cases
+
+
+# Now we start to actually build up all the test cases.  Since all the
+# mathematical operations are really pretty similar, and most just need the
+# basic testing functionality, we do this with a series of mix-in classes which
+# provide various components of the testing and test-generation infrastructure.
+#
+# In each, we use the idiom that "test_<x>" is a test function which pytest
+# will collect for us, and "generate_<x>" a method which will be called by
+# `pytest_generate_tests` in order to generate all the parametrisations for the
+# given test.
+
+class _GenericOpMixin:
+    """
+    Abstract base mix-in which sets up the test generation for the two basic
+    test operations, and puts in the very generic test generator.  This does
+    not actually define the tests themselves, because subclasses need to define
+    them so the method arguments can be introspected to parametrise over the
+    correct number of arguments.
+
+    The tests `mathematically_correct` and `incorrect_shape_raises` will
+    parametrise Data types over method arguments which have names `data_*`.
+
+    The class arguments defined here are effectively parametrising the
+    mathematical tests.
+
+    Attributes
+    ----------
+    op_numpy: *args -> np.ndarray
+        Function which takes the same arguments as the mathematical operation,
+        but with all data arguments numpy arrays, and returns the expected
+        result.
+
+    atol: float
+        The absolute tolerance to use when comparing the test value with the
+        expected value.  If the output is a Data type, the tolerance is
+        per-element of the output.
+
+    rtol: float
+        The relative tolerance to use when comparing the test value with the
+        expected value.  If the output is a Data type, the tolerance is
+        per-element of the output.
+
+    shapes: list of (list of shapes)
+        A list of the sets of shapes which should be used for the tests of
+        mathematical correctness.  Each element of the list is a set of shapes,
+        each one corresponding to one of the arguments of the operation.
+
+    bad_shapes: list of (list of shapes)
+        Similar to `shapes`, but these should be shapes which are invalid for
+        the given mathematical operation.
+
+    specialisations: list of (function, Type, Type, [Type, ...])
+        The specialisations of each mathematical function, and the types that
+        it takes in and returns.  For example, the function
+            add(CSR, Dense) -> Other
+        would be specified as `(add, CSR, Dense, Other)`.
+    """
+    def op_numpy(self, *args): raise NotImplementedError
+    # With dimensions of around 100, we have to account for floating-point
+    # addition not being associative; the maths on full numpy arrays will often
+    # produce slightly different results to sparse algebra, since the order of
+    # multiplications and additions will be different.
+    atol = 1e-10
+    rtol = 1e-7  # Same default as numpy
+    shapes = []
+    bad_shapes = []
+    specialisations = []
+
+    def generate_mathematically_correct(self, metafunc):
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+            + ['out_type']
+        )
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, out_type = p_op.values
+            args = (op, types, self.shapes, out_type)
+            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
+        metafunc.parametrize(parameters, cases)
+
+    def generate_incorrect_shape_raises(self, metafunc):
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+        )
+        if not self.bad_shapes:
+            reason = "".join([
+                "no shapes are 'incorrect' for ",
+                metafunc.cls.__name__,
+                "::",
+                metafunc.function.__name__,
+            ])
+            false_case = pytest.param(*([None]*len(parameters)),
+                                      marks=pytest.mark.skip(reason),
+                                      id="no test")
+            metafunc.parametrize(parameters, [false_case])
+            return
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, _ = p_op.values
+            args = (op, types, self.bad_shapes)
+            cases.extend(cases_type_shape_product(_RANDOM, *args))
+        metafunc.parametrize(parameters, cases)
+
+    def pytest_generate_tests(self, metafunc):
+        # For every test function "test_xyz", we use the test generator
+        # "generate_xyz" if it exists.  This allows derived classes to add
+        # their own tests and generators without overiding this method, cutting
+        # down on boilerplate, but also that derived classes _may_ override the
+        # generation of tests defined in a base class, say if they have
+        # additional special arguments that need parametrising over.
+        generator_name = (
+            "generate_"
+            + metafunc.function.__name__.replace("test_", "")
+        )
+        try:
+            generator = getattr(self, generator_name)
+        except AttributeError:
+            return
+        generator(metafunc)
+
+
+class UnaryOpMixin(_GenericOpMixin):
+    """
+    Mix-in for unary mathematical operations on Data instances (e.g. unary
+    negation).
+    """
+    shapes = [(x,) for x in shapes_unary()]
+    bad_shapes = []
+
+    def test_mathematically_correct(self, op, data_m, out_type):
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array())
+        test = op(matrix)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        elif out_type is list:
+            for test_, expected_ in zip(test, expected):
+                assert test_.shape == expected_.shape
+                np.testing.assert_allclose(test_.to_array(), expected_,
+                                           atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_m):
+        """
+        Test that the operation produces a suitable error if the shape of the
+        given operand is not compatible with the operation. Useful for
+        operations that require square matrices (trace, pow, ...).
+        """
+        with pytest.raises(ValueError):
+            op(data_m())
+
+
+class UnaryScalarOpMixin(_GenericOpMixin):
+    """
+    Mix-in for unary mathematical operations on Data instances, but that also
+    take in a numeric scalar (e.g. scalar multiplication).  Only generates
+    the test `mathematically_correct`, since there can't be a shape mismatch
+    when there's only one Data argument.
+    """
+    shapes = [(x,) for x in shapes_unary()]
+
+    @pytest.mark.parametrize('scalar', [
+        pytest.param(0, id='zero'),
+        pytest.param(4.5, id='real'),
+        pytest.param(3j, id='complex'),
+    ])
+    def test_mathematically_correct(self, op, data_m, scalar, out_type):
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), scalar)
+        test = op(matrix, scalar)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol,
+                                       rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class BinaryOpMixin(_GenericOpMixin):
+    """
+    Mix-in for binary mathematical operations on Data instances (e.g. binary
+    addition).
+    """
+    def test_mathematically_correct(self, op, data_l, data_r, out_type):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        left, right = data_l(), data_r()
+        expected = self.op_numpy(left.to_array(), right.to_array())
+        test = op(left, right)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_l, data_r):
+        """
+        Test that the operation produces a suitable error if the shapes of the
+        given operands are not compatible.
+        """
+        with pytest.raises(ValueError):
+            op(data_l(), data_r())
+
+
+class TernaryOpMixin(_GenericOpMixin):
+    """
+    Mix-in for ternary mathematical operations on Data instances (e.g. inner
+    product with an operator in the middle).  This is pretty rare.
+    """
+    def test_mathematically_correct(self, op,
+                                    data_l, data_m, data_r,
+                                    out_type):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        left, mid, right = data_l(), data_m(), data_r()
+        expected = self.op_numpy(left.to_array(),
+                                 mid.to_array(),
+                                 right.to_array())
+        test = op(left, mid, right)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
+        """
+        Test that the operation produces a suitable error if the shapes of the
+        given operands are not compatible.
+        """
+        with pytest.raises(ValueError):
+            op(data_l(), data_m(), data_r())
+
+
+# And now finally we get into the meat of the actual mathematical tests.
+
+class TestAdd(BinaryOpMixin):
+    def op_numpy(self, left, right, scale):
+        return np.add(left, scale * right)
+
+    shapes = shapes_binary_identical()
+    bad_shapes = shapes_binary_bad_identical()
+    specialisations = [
+        pytest.param(data.add_csr, CSR, CSR, CSR),
+        pytest.param(data.add_dense, Dense, Dense, Dense),
+    ]
+
+    # `add` has an additional scalar parameter, because the operation is
+    # actually more like `A + c*B`.  We just parametrise that scalar
+    # separately.
+    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
+                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
+    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        left, right = data_l(), data_r()
+        if scale is not None:
+            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
+            test = op(left, right, scale)
+        else:
+            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
+            test = op(left, right)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class TestAdjoint(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.conj(matrix.T)
+
+    specialisations = [
+        pytest.param(data.adjoint_csr, CSR, CSR),
+        pytest.param(data.adjoint_dense, Dense, Dense),
+    ]
+
+
+class TestConj(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.conj(matrix)
+
+    specialisations = [
+        pytest.param(data.conj_csr, CSR, CSR),
+        pytest.param(data.conj_dense, Dense, Dense),
+    ]
+
+
+class TestInner(BinaryOpMixin):
+    # The inner product is a bit more specialist, since it has to handle inputs
+    # in a 1D space specially.  In order to keep things simple, we just
+    # generate those test cases completely separately from the standard
+    # `mathematically_correct`.
+
+    def op_numpy(self, left, right, scalar_is_ket=False):
+        if left.shape[1] == 1:
+            if left.shape[0] != 1 or scalar_is_ket:
+                left = np.conj(left.T)
+        return (left @ right)[0, 0]
+
+    # These shapes are a little more non-standard.
+    _dim = 100
+    _scalar = pytest.param((1, 1), id="scalar")
+    _bra = pytest.param((1, _dim), id="bra")
+    _ket = pytest.param((_dim, 1), id="ket")
+    _op = pytest.param((_dim, _dim), id="square")
+    shapes = [
+        (_bra, _ket),
+        (_ket, _ket),
+    ]
+    bad_shapes = [
+        (_bra, _bra),
+        (_ket, _bra),
+        (_op, _ket),
+        (_op, _bra),
+        (_bra, _op),
+        (_ket, _op),
+    ]
+
+    specialisations = [
+        pytest.param(data.inner_csr, CSR, CSR, complex),
+        pytest.param(data.inner_dense, Dense, Dense, complex),
+    ]
+
+    def generate_scalar_is_ket(self, metafunc):
+        # For 1D subspaces, the special cases don't really matter since there's
+        # only really one type of matrix available, so this is parametrised
+        # with only case for each input argument.
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+            + ['out_type']
+        )
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, out_type = p_op.values
+            args = (op, types, [(self._scalar, self._scalar)], out_type)
+            cases.extend(cases_type_shape_product(_RANDOM, *args))
+        metafunc.parametrize(parameters, cases)
+        metafunc.parametrize('scalar_is_ket',
+                             [True, False],
+                             ids=["ket", "bra"])
+
+    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
+        left, right = data_l(), data_r()
+        expected = self.op_numpy(left.to_array(), right.to_array(),
+                                 scalar_is_ket)
+        test = op(left, right, scalar_is_ket)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class TestInnerOp(TernaryOpMixin):
+    # This is very very similar to TestInner.
+    def op_numpy(self, left, mid, right, scalar_is_ket=False):
+        if left.shape[1] == 1:
+            if left.shape[0] != 1 or scalar_is_ket:
+                left = np.conj(left.T)
+        return (left @ mid @ right)[0, 0]
+
+    _dim = 100
+    _scalar = pytest.param((1, 1), id="scalar")
+    _bra = pytest.param((1, _dim), id="bra")
+    _ket = pytest.param((_dim, 1), id="ket")
+    _op = pytest.param((_dim, _dim), id="square")
+    shapes = [
+        (_bra, _op, _ket),
+        (_ket, _op, _ket),
+    ]
+    bad_shapes = [
+        (_bra, _op, _bra),
+        (_ket, _op, _bra),
+        (_op, _op, _ket),
+        (_op, _op, _bra),
+        (_bra, _op, _op),
+        (_ket, _op, _op),
+        (_bra, _bra, _ket),
+        (_ket, _bra, _ket),
+        (_bra, _ket, _ket),
+        (_ket, _ket, _ket),
+    ]
+
+    specialisations = [
+        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
+        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
+    ]
+
+    def generate_scalar_is_ket(self, metafunc):
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+            + ['out_type']
+        )
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, out_type = p_op.values
+            args = (op, types, [(self._scalar,) * 3], out_type)
+            cases.extend(cases_type_shape_product(_RANDOM, *args))
+        metafunc.parametrize(parameters, cases)
+        metafunc.parametrize('scalar_is_ket',
+                             [True, False], ids=["ket", "bra"])
+
+    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
+                           scalar_is_ket):
+        left, mid, right = data_l(), data_m(), data_r()
+        expected = self.op_numpy(left.to_array(),
+                                 mid.to_array(),
+                                 right.to_array(),
+                                 scalar_is_ket)
+        test = op(left, mid, right, scalar_is_ket)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol,
+                                       rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class TestKron(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return np.kron(left, right)
+
+    # Keep the dimension low because kron can get very expensive.
+    shapes = shapes_binary_unrestricted(dim=5)
+    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
+    specialisations = [
+        pytest.param(data.kron_csr, CSR, CSR, CSR),
+        pytest.param(data.kron_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestMatmul(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return np.matmul(left, right)
+
+    shapes = shapes_binary_matmul()
+    bad_shapes = shapes_binary_bad_matmul()
+    specialisations = [
+        pytest.param(data.matmul_csr, CSR, CSR, CSR),
+        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
+        pytest.param(data.matmul_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestMultiply(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return left * right
+
+    shapes = shapes_binary_identical()
+    bad_shapes = shapes_binary_bad_identical()
+    specialisations = [
+        pytest.param(data.multiply_csr, CSR, CSR, CSR),
+        pytest.param(data.multiply_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestMul(UnaryScalarOpMixin):
+    def op_numpy(self, matrix, scalar):
+        return scalar * matrix
+
+    specialisations = [
+        pytest.param(data.mul_csr, CSR, CSR),
+        pytest.param(data.mul_dense, Dense, Dense),
+    ]
+
+
+class TestNeg(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return -matrix
+
+    specialisations = [
+        pytest.param(data.neg_csr, CSR, CSR),
+        pytest.param(data.neg_dense, Dense, Dense),
+    ]
+
+
+class TestSub(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return left - right
+
+    shapes = shapes_binary_identical()
+    bad_shapes = shapes_binary_bad_identical()
+    specialisations = [
+        pytest.param(data.sub_csr, CSR, CSR, CSR),
+        pytest.param(data.sub_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestTrace(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.sum(np.diag(matrix))
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.trace_csr, CSR, complex),
+        pytest.param(data.trace_dense, Dense, complex),
+    ]
+
+
+class TestTrace_oper_ket(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        N = int(matrix.shape[0] ** 0.5)
+        return np.sum(np.diag(matrix.reshape((N, N))))
+
+    shapes = [
+        (pytest.param((100, 1), id="oper-ket"),),
+    ]
+    bad_shapes = [
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((99, 1), id="ket"),),
+        (pytest.param((99, 99), id="ket"),),
+        (pytest.param((2, 99), id="nonsquare"),),
+    ]
+    specialisations = [
+        pytest.param(data.trace_oper_ket_csr, CSR, complex),
+        pytest.param(data.trace_oper_ket_dense, Dense, complex),
+    ]
+
+
+class TestPow(UnaryOpMixin):
+    def op_numpy(self, matrix, n):
+        return np.linalg.matrix_power(matrix, n)
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.pow_csr, CSR, CSR),
+        pytest.param(data.pow_dense, Dense, Dense),
+    ]
+
+    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
+    def test_mathematically_correct(self, op, data_m, out_type, n):
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), n)
+        test = op(matrix, n)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+                                   rtol=self.rtol)
+
+    # Pow actually does have bad shape, so we put that in too.
+    def test_incorrect_shape_raises(self, op, data_m):
+        """
+        Test that the operation produces a suitable error if the shape is not a
+        square matrix.
+        """
+        with pytest.raises(ValueError):
+            op(data_m(), 10)
+
+
+class TestExpm(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.expm(matrix)
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.expm_csr, CSR, CSR),
+        pytest.param(data.expm_csr_dense, CSR, Dense),
+        pytest.param(data.expm_dense, Dense, Dense),
+    ]
+
+
+class TestLogm(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.logm(matrix)
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.logm_dense, Dense, Dense),
+    ]
+
+
+class TestTranspose(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return matrix.T
+
+    specialisations = [
+        pytest.param(data.transpose_csr, CSR, CSR),
+        pytest.param(data.transpose_dense, Dense, Dense),
+    ]
+
+
+class TestProject(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        if matrix.shape[0] == 1:
+            return np.outer(np.conj(matrix), matrix)
+        else:
+            return np.outer(matrix, np.conj(matrix))
+
+    shapes = [
+        (pytest.param((1, 1), id="scalar"),),
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((100, 1), id="ket"),),
+    ]
+    bad_shapes = [
+        (pytest.param((10, 10), id="square"),),
+        (pytest.param((2, 10), id="nonsquare"),),
+    ]
+
+    specialisations = [
+        pytest.param(data.project_csr, CSR, CSR),
+        pytest.param(data.project_dense, Dense, Dense),
+    ]
+
+
+def _inv_dense(matrix):
+    # Add a diagonal so `matrix` is not singular
+    return data.inv_dense(
+        data.add(
+            matrix,
+            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
+        )
+    )
+
+
+def _inv_csr(matrix):
+    # Add a diagonal so `matrix` is not singular
+    return data.inv_csr(
+        data.add(
+            matrix,
+            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
+        )
+    )
+
+
+class TestInv(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
+
+    shapes = [
+        (pytest.param((1, 1), id="scalar"),),
+        (pytest.param((10, 10), id="square"),),
+    ]
+    bad_shapes = [
+        (pytest.param((2, 10), id="nonsquare"),),
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((100, 1), id="ket"),),
+    ]
+
+    specialisations = [
+        pytest.param(_inv_csr, CSR, CSR),
+        pytest.param(_inv_dense, Dense, Dense),
+    ]
diff --git a/qutip/tests/core/data/test_norm.py b/qutip/tests/core/data/test_norm.py
index d285bb3ebf..7abac8725e 100644
--- a/qutip/tests/core/data/test_norm.py
+++ b/qutip/tests/core/data/test_norm.py
@@ -1,69 +1,69 @@
-from . import test_mathematics as testing
-import numpy as np
-import scipy.linalg
-import pytest
-from qutip import data
-from qutip.core.data import CSR, Dense
-import numbers
-
-
-class TestOneNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.norm(matrix, 1)
-
-    specialisations = [
-        pytest.param(data.norm.one_csr, CSR, numbers.Number),
-        pytest.param(data.norm.one_dense, Dense, numbers.Number),
-    ]
-
-
-class TestFrobeniusNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.norm(matrix, 'fro')
-
-    specialisations = [
-        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
-        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
-    ]
-
-
-class TestMaxNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
-        # works differently for matrices.
-        return np.max(np.abs(matrix))
-
-    specialisations = [
-        pytest.param(data.norm.max_csr, CSR, numbers.Number),
-        pytest.param(data.norm.max_dense, Dense, numbers.Number),
-    ]
-
-
-class TestL2Norm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.norm(matrix, 'fro')
-
-    # These shapes correspond to kets or bras
-    shapes = [
-        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
-                                                 or x.values[0][1] == 1)
-    ]
-    # These shapes are everything except for kets and bras
-    bad_shapes = [
-        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
-                                                     or x.values[0][1] == 1)
-    ]
-    specialisations = [
-        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
-        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
-    ]
-
-
-class TestTraceNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.linalg.svd(matrix)[1].sum()
-
-    specialisations = [
-        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
-        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
-    ]
+from . import test_mathematics as testing
+import numpy as np
+import scipy.linalg
+import pytest
+from qutip import data
+from qutip.core.data import CSR, Dense
+import numbers
+
+
+class TestOneNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.norm(matrix, 1)
+
+    specialisations = [
+        pytest.param(data.norm.one_csr, CSR, numbers.Number),
+        pytest.param(data.norm.one_dense, Dense, numbers.Number),
+    ]
+
+
+class TestFrobeniusNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.norm(matrix, 'fro')
+
+    specialisations = [
+        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
+        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
+    ]
+
+
+class TestMaxNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
+        # works differently for matrices.
+        return np.max(np.abs(matrix))
+
+    specialisations = [
+        pytest.param(data.norm.max_csr, CSR, numbers.Number),
+        pytest.param(data.norm.max_dense, Dense, numbers.Number),
+    ]
+
+
+class TestL2Norm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.norm(matrix, 'fro')
+
+    # These shapes correspond to kets or bras
+    shapes = [
+        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
+                                                 or x.values[0][1] == 1)
+    ]
+    # These shapes are everything except for kets and bras
+    bad_shapes = [
+        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
+                                                     or x.values[0][1] == 1)
+    ]
+    specialisations = [
+        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
+        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
+    ]
+
+
+class TestTraceNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.linalg.svd(matrix)[1].sum()
+
+    specialisations = [
+        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
+        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
+    ]
diff --git a/qutip/tests/core/data/test_operators.py b/qutip/tests/core/data/test_operators.py
index 4416629b9d..eb2a750708 100644
--- a/qutip/tests/core/data/test_operators.py
+++ b/qutip/tests/core/data/test_operators.py
@@ -1,69 +1,69 @@
-import pytest
-import numpy
-import qutip
-from qutip.core import data as _data
-from qutip import settings
-
-
-@pytest.mark.parametrize('type_left', _data.to.dtypes)
-@pytest.mark.parametrize('type_right', _data.to.dtypes)
-@pytest.mark.parametrize(['operator', 'dispatch'], [
-    pytest.param(lambda left, right: left + right, _data.add, id="add"),
-    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
-    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
-])
-def test_data_binary_operator(type_left, type_right, operator, dispatch):
-    left = qutip.rand_dm(5, dtype=type_left).data
-    right = qutip.rand_dm(5, dtype=type_right).data
-    numpy.testing.assert_allclose(
-        operator(left, right).to_array(),
-        dispatch(left, right).to_array(),
-        rtol=1e-15
-    )
-
-
-@pytest.mark.parametrize('type_', _data.to.dtypes)
-@pytest.mark.parametrize(['operator', 'dispatch'], [
-    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
-    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
-    pytest.param(lambda data, number: data / number,
-                 lambda data, number: _data.mul(data, 1/number), id="div"),
-])
-def test_data_scalar_operator(type_, operator, dispatch):
-    data = qutip.qeye(2, dtype=type_).data
-    number = 3
-    numpy.testing.assert_allclose(
-        operator(data, number).to_array(),
-        dispatch(data, number).to_array(),
-        rtol=1e-15
-    )
-
-
-@pytest.mark.parametrize('type_', _data.to.dtypes)
-def test_data_neg_operator(type_):
-    data = qutip.qeye(2, dtype=type_).data
-    numpy.testing.assert_allclose(
-        (-data).to_array(), -data.to_array(), rtol=1e-15
-    )
-
-
-@pytest.mark.parametrize('type_left', _data.to.dtypes)
-@pytest.mark.parametrize('type_right', _data.to.dtypes)
-def test_data_eq_operator(type_left, type_right):
-    mat = qutip.rand_dm(5)
-    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
-
-    left = mat.to(type_left).data
-    right = mat.to(type_right).data
-    assert left == right
-    right = (mat + noise).to(type_right).data
-    assert left == right
-
-    right = (mat + noise * 100).to(type_right).data
-    assert left != right
-
-    right = qutip.operator_to_vector(mat).to(type_right).data
-    assert left != right
-
-    assert left != mat
-    assert numpy.all(left != mat.full())
+import pytest
+import numpy
+import qutip
+from qutip.core import data as _data
+from qutip import settings
+
+
+@pytest.mark.parametrize('type_left', _data.to.dtypes)
+@pytest.mark.parametrize('type_right', _data.to.dtypes)
+@pytest.mark.parametrize(['operator', 'dispatch'], [
+    pytest.param(lambda left, right: left + right, _data.add, id="add"),
+    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
+    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
+])
+def test_data_binary_operator(type_left, type_right, operator, dispatch):
+    left = qutip.rand_dm(5, dtype=type_left).data
+    right = qutip.rand_dm(5, dtype=type_right).data
+    numpy.testing.assert_allclose(
+        operator(left, right).to_array(),
+        dispatch(left, right).to_array(),
+        rtol=1e-15
+    )
+
+
+@pytest.mark.parametrize('type_', _data.to.dtypes)
+@pytest.mark.parametrize(['operator', 'dispatch'], [
+    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
+    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
+    pytest.param(lambda data, number: data / number,
+                 lambda data, number: _data.mul(data, 1/number), id="div"),
+])
+def test_data_scalar_operator(type_, operator, dispatch):
+    data = qutip.qeye(2, dtype=type_).data
+    number = 3
+    numpy.testing.assert_allclose(
+        operator(data, number).to_array(),
+        dispatch(data, number).to_array(),
+        rtol=1e-15
+    )
+
+
+@pytest.mark.parametrize('type_', _data.to.dtypes)
+def test_data_neg_operator(type_):
+    data = qutip.qeye(2, dtype=type_).data
+    numpy.testing.assert_allclose(
+        (-data).to_array(), -data.to_array(), rtol=1e-15
+    )
+
+
+@pytest.mark.parametrize('type_left', _data.to.dtypes)
+@pytest.mark.parametrize('type_right', _data.to.dtypes)
+def test_data_eq_operator(type_left, type_right):
+    mat = qutip.rand_dm(5)
+    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
+
+    left = mat.to(type_left).data
+    right = mat.to(type_right).data
+    assert left == right
+    right = (mat + noise).to(type_right).data
+    assert left == right
+
+    right = (mat + noise * 100).to(type_right).data
+    assert left != right
+
+    right = qutip.operator_to_vector(mat).to(type_right).data
+    assert left != right
+
+    assert left != mat
+    assert numpy.all(left != mat.full())
diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
index de844baec7..124d7d2f71 100644
--- a/qutip/tests/core/data/test_properties.py
+++ b/qutip/tests/core/data/test_properties.py
@@ -1,175 +1,175 @@
-import numpy as np
-import pytest
-
-from qutip import data as _data
-
-
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
-def datatype(request):
-    return request.param
-
-
-class Test_isherm:
-    tol = 1e-12
-
-    @pytest.mark.repeat(20)
-    @pytest.mark.parametrize("density", (0.1, 0.8))
-    @pytest.mark.parametrize("size", (10, 100))
-    def test_random_equal_structure(self, datatype, size, density):
-        # This is only going to be approximate, as entries generated onto the
-        # diagonal will fill only one slot, not two, after addition with the
-        # transpose.  The densities are arbitrary, though, so this doesn't
-        # matter much.
-        nnz = int(0.5 * size*size * density) or 1
-        indices = np.triu_indices(size)
-        choice = np.random.choice(indices[0].size, nnz, replace=False)
-        indices = (indices[0][choice], indices[1][choice])
-
-        # Real-symmetric matrices.
-        base = np.zeros((size, size), dtype=np.complex128)
-        base[indices] = np.random.rand(nnz)
-        base += base.T.conj()
-        base = _data.to(datatype, _data.create(base))
-        assert _data.isherm(base)
-
-        # Complex Hermitian matrices
-        base = np.zeros((size, size), dtype=np.complex128)
-        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-        base += base.T.conj()
-        base = _data.to(datatype, _data.create(base))
-        assert _data.isherm(base)
-
-        # Complex skew-Hermitian matrices
-        base = np.zeros((size, size), dtype=np.complex128)
-        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-        base += base.T
-        base = _data.to(datatype, _data.create(base))
-        assert not _data.isherm(base)
-
-    @pytest.mark.parametrize("cols", (2, 4))
-    @pytest.mark.parametrize("rows", (1, 5))
-    def test_nonsquare_shapes(self, datatype, rows, cols):
-        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
-        assert not _data.isherm(real, self.tol)
-        assert not _data.isherm(real.transpose(), self.tol)
-
-        imag = _data.to(
-            datatype,
-            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
-        )
-        assert not _data.isherm(imag, self.tol)
-        assert not _data.isherm(imag.transpose(), self.tol)
-
-    def test_diagonal_elements(self, datatype):
-        n = 10
-        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
-        assert _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
-
-    def test_compare_implicit_zero_structure(self, datatype):
-        """
-        Regression test for gh-1350, comparing explicitly stored values in the
-        matrix (but below the tolerance for allowable Hermicity) to implicit
-        zeros.
-        """
-
-        base = _data.to(
-            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
-        )
-        # If this first line fails, the zero has been stored explicitly and so
-        # the test is invalid.
-        assert np.count_nonzero(base.to_array()) == 3
-        assert _data.isherm(base, tol=self.tol)
-        assert _data.isherm(base.transpose(), tol=self.tol)
-
-        # A similar test if the structures are different, but it's not
-        # Hermitian.
-        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
-        assert np.count_nonzero(base.to_array()) == 3
-        assert not _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(base.transpose(), tol=self.tol)
-
-        # Catch possible edge case where it shouldn't be Hermitian, but faulty
-        # loop logic doesn't fully compare all rows.
-        base = _data.to(
-            datatype,
-            _data.create(
-                np.array(
-                    [
-                        [0, 0, 0, 0],
-                        [0, 0, 0, 0],
-                        [0, 1, 0, 0],
-                        [0, 0, 0, 0],
-                    ],
-                    dtype=np.complex128,
-                )
-            ),
-        )
-        assert np.count_nonzero(base.to_array()) == 1
-        assert not _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(base.transpose(), tol=self.tol)
-
-    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
-    def test_compare_implicit_zero_random(self, datatype, density):
-        """
-        Regression test of gh-1350.
-
-        Larger matrices where all off-diagonal elements are below the
-        absolute tolerance, so everything should always appear Hermitian, but
-        with random patterns of non-zero elements.  It doesn't matter that it
-        isn't Hermitian if scaled up; everything is below absolute tolerance,
-        so it should appear so.  We also set the diagonal to be larger to the
-        tolerance to ensure isherm can't just compare everything to zero.
-        """
-        n = 10
-        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
-        # Mask some values out to zero.
-        base[np.random.rand(n, n) > density] = 0
-        np.fill_diagonal(base, self.tol * 1000)
-        nnz = np.count_nonzero(base)
-        base = _data.to(datatype, _data.create(base))
-        assert np.count_nonzero(base.to_array()) == nnz
-        assert _data.isherm(base, tol=self.tol)
-        assert _data.isherm(base.transpose(), tol=self.tol)
-
-        # Similar test when it must be non-Hermitian.  We set the diagonal
-        # to be real because we want to test off-diagonal implicit zeros,
-        # and having an imaginary first element would automatically fail.
-        nnz = 0
-        while nnz <= n:
-            # Ensure that we don't just have the real diagonal.
-            base = self.tol * 1000j * np.random.rand(n, n)
-            # Mask some values out to zero.
-            base[np.random.rand(n, n) > density] = 0
-            np.fill_diagonal(base, self.tol * 1000)
-            nnz = np.count_nonzero(base)
-        base = _data.to(datatype, _data.create(base))
-        assert np.count_nonzero(base.to_array()) == nnz
-        assert not _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(base.transpose(), tol=self.tol)
-
-    def test_structure_detection(self, datatype):
-        base = np.array([[1,1,0],
-                         [0,1,1],
-                         [1,0,1]])
-        base = _data.to(datatype, _data.create(base))
-        assert not _data.isherm(base, tol=self.tol)
-
-
-class Test_isdiag:
-    @pytest.mark.parametrize("shape",
-        [(10, 1), (2, 5), (5, 2), (5, 5)]
-    )
-    def test_isdiag(self, shape, datatype):
-        mat = np.zeros(shape)
-        data = _data.to(datatype, _data.Dense(mat))
-        # empty matrices are diagonal
-        assert _data.isdiag(data)
-
-        mat[0, 0] = 1
-        data = _data.to(datatype, _data.Dense(mat))
-        assert _data.isdiag(data)
-
-        mat[1, 0] = 1
-        data = _data.to(datatype, _data.Dense(mat))
-        assert not _data.isdiag(data)
+import numpy as np
+import pytest
+
+from qutip import data as _data
+
+
+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+def datatype(request):
+    return request.param
+
+
+class Test_isherm:
+    tol = 1e-12
+
+    @pytest.mark.repeat(20)
+    @pytest.mark.parametrize("density", (0.1, 0.8))
+    @pytest.mark.parametrize("size", (10, 100))
+    def test_random_equal_structure(self, datatype, size, density):
+        # This is only going to be approximate, as entries generated onto the
+        # diagonal will fill only one slot, not two, after addition with the
+        # transpose.  The densities are arbitrary, though, so this doesn't
+        # matter much.
+        nnz = int(0.5 * size*size * density) or 1
+        indices = np.triu_indices(size)
+        choice = np.random.choice(indices[0].size, nnz, replace=False)
+        indices = (indices[0][choice], indices[1][choice])
+
+        # Real-symmetric matrices.
+        base = np.zeros((size, size), dtype=np.complex128)
+        base[indices] = np.random.rand(nnz)
+        base += base.T.conj()
+        base = _data.to(datatype, _data.create(base))
+        assert _data.isherm(base)
+
+        # Complex Hermitian matrices
+        base = np.zeros((size, size), dtype=np.complex128)
+        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+        base += base.T.conj()
+        base = _data.to(datatype, _data.create(base))
+        assert _data.isherm(base)
+
+        # Complex skew-Hermitian matrices
+        base = np.zeros((size, size), dtype=np.complex128)
+        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+        base += base.T
+        base = _data.to(datatype, _data.create(base))
+        assert not _data.isherm(base)
+
+    @pytest.mark.parametrize("cols", (2, 4))
+    @pytest.mark.parametrize("rows", (1, 5))
+    def test_nonsquare_shapes(self, datatype, rows, cols):
+        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
+        assert not _data.isherm(real, self.tol)
+        assert not _data.isherm(real.transpose(), self.tol)
+
+        imag = _data.to(
+            datatype,
+            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
+        )
+        assert not _data.isherm(imag, self.tol)
+        assert not _data.isherm(imag.transpose(), self.tol)
+
+    def test_diagonal_elements(self, datatype):
+        n = 10
+        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
+        assert _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
+
+    def test_compare_implicit_zero_structure(self, datatype):
+        """
+        Regression test for gh-1350, comparing explicitly stored values in the
+        matrix (but below the tolerance for allowable Hermicity) to implicit
+        zeros.
+        """
+
+        base = _data.to(
+            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
+        )
+        # If this first line fails, the zero has been stored explicitly and so
+        # the test is invalid.
+        assert np.count_nonzero(base.to_array()) == 3
+        assert _data.isherm(base, tol=self.tol)
+        assert _data.isherm(base.transpose(), tol=self.tol)
+
+        # A similar test if the structures are different, but it's not
+        # Hermitian.
+        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
+        assert np.count_nonzero(base.to_array()) == 3
+        assert not _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(base.transpose(), tol=self.tol)
+
+        # Catch possible edge case where it shouldn't be Hermitian, but faulty
+        # loop logic doesn't fully compare all rows.
+        base = _data.to(
+            datatype,
+            _data.create(
+                np.array(
+                    [
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 1, 0, 0],
+                        [0, 0, 0, 0],
+                    ],
+                    dtype=np.complex128,
+                )
+            ),
+        )
+        assert np.count_nonzero(base.to_array()) == 1
+        assert not _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(base.transpose(), tol=self.tol)
+
+    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
+    def test_compare_implicit_zero_random(self, datatype, density):
+        """
+        Regression test of gh-1350.
+
+        Larger matrices where all off-diagonal elements are below the
+        absolute tolerance, so everything should always appear Hermitian, but
+        with random patterns of non-zero elements.  It doesn't matter that it
+        isn't Hermitian if scaled up; everything is below absolute tolerance,
+        so it should appear so.  We also set the diagonal to be larger to the
+        tolerance to ensure isherm can't just compare everything to zero.
+        """
+        n = 10
+        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
+        # Mask some values out to zero.
+        base[np.random.rand(n, n) > density] = 0
+        np.fill_diagonal(base, self.tol * 1000)
+        nnz = np.count_nonzero(base)
+        base = _data.to(datatype, _data.create(base))
+        assert np.count_nonzero(base.to_array()) == nnz
+        assert _data.isherm(base, tol=self.tol)
+        assert _data.isherm(base.transpose(), tol=self.tol)
+
+        # Similar test when it must be non-Hermitian.  We set the diagonal
+        # to be real because we want to test off-diagonal implicit zeros,
+        # and having an imaginary first element would automatically fail.
+        nnz = 0
+        while nnz <= n:
+            # Ensure that we don't just have the real diagonal.
+            base = self.tol * 1000j * np.random.rand(n, n)
+            # Mask some values out to zero.
+            base[np.random.rand(n, n) > density] = 0
+            np.fill_diagonal(base, self.tol * 1000)
+            nnz = np.count_nonzero(base)
+        base = _data.to(datatype, _data.create(base))
+        assert np.count_nonzero(base.to_array()) == nnz
+        assert not _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(base.transpose(), tol=self.tol)
+
+    def test_structure_detection(self, datatype):
+        base = np.array([[1,1,0],
+                         [0,1,1],
+                         [1,0,1]])
+        base = _data.to(datatype, _data.create(base))
+        assert not _data.isherm(base, tol=self.tol)
+
+
+class Test_isdiag:
+    @pytest.mark.parametrize("shape",
+        [(10, 1), (2, 5), (5, 2), (5, 5)]
+    )
+    def test_isdiag(self, shape, datatype):
+        mat = np.zeros(shape)
+        data = _data.to(datatype, _data.Dense(mat))
+        # empty matrices are diagonal
+        assert _data.isdiag(data)
+
+        mat[0, 0] = 1
+        data = _data.to(datatype, _data.Dense(mat))
+        assert _data.isdiag(data)
+
+        mat[1, 0] = 1
+        data = _data.to(datatype, _data.Dense(mat))
+        assert not _data.isdiag(data)
diff --git a/qutip/tests/core/data/test_ptrace.py b/qutip/tests/core/data/test_ptrace.py
index 84fd41015d..37b28c2936 100644
--- a/qutip/tests/core/data/test_ptrace.py
+++ b/qutip/tests/core/data/test_ptrace.py
@@ -1,108 +1,108 @@
-from . import test_mathematics as testing
-import numpy as np
-import scipy.linalg
-import pytest
-from qutip import data
-from qutip.core.data import CSR, Dense
-
-
-class TestPtrace(testing.UnaryOpMixin):
-    def op_numpy(self, matrix, dims, sel):
-        sel.sort()
-        ndims = len(dims)
-        dkeep = [dims[x] for x in sel]
-        qtrace = list(set(range(ndims)) - set(sel))
-        dtrace = [dims[x] for x in qtrace]
-
-        matrix = matrix.reshape(dims + dims)
-        matrix = matrix.transpose(
-            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
-        )
-        matrix = matrix.reshape(
-            [
-                np.prod(dtrace, dtype=int),
-                np.prod(dtrace, dtype=int),
-                np.prod(dkeep, dtype=int),
-                np.prod(dkeep, dtype=int),
-            ]
-        )
-        return np.trace(matrix)
-
-    # Custom shapes to have also custom dims and sel arguments.
-    # These values should not be changed.
-    dims = [2] * 7
-    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
-    bad_shapes = testing.shapes_not_square(np.prod(dims))
-
-    specialisations = [
-        pytest.param(data.ptrace_csr, CSR, CSR),
-        pytest.param(data.ptrace_csr_dense, CSR, Dense),
-        pytest.param(data.ptrace_dense, Dense, Dense),
-    ]
-
-    @pytest.mark.parametrize(
-        "sel",
-        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
-        ids=[
-            "keep_one",
-            "keep_multiple_sorted",
-            "keep_multiple_unsorted",
-            "trace_none",
-            "trace_all",
-        ],
-    )
-    def test_mathematically_correct(self, op, data_m, out_type, sel):
-        """
-        Test that the unary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
-        test = op(matrix, self.dims, sel)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(
-            test.to_array(), expected, atol=self.atol, rtol=self.rtol
-        )
-
-    def test_incorrect_shape_raises(self, op, data_m):
-        """
-        Test that the operation produces a suitable error if the shape of the
-        operand is not square.
-        """
-        with pytest.raises(ValueError):
-            op(data_m(), self.dims, sel=[0, 1])
-
-    # `out_type` is included but not used so that
-    # `generate_mathematically_correct` can be re-used.
-    @pytest.mark.parametrize(
-        "dims",
-        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
-        ids=[
-            "dims_different_to_shape",
-            "dims_0",
-            "dims_prod_is_shape_but_negative",
-            "dims_is_not_int",
-        ],
-    )
-    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
-        with pytest.raises(ValueError):
-            op(data_m(), dims, sel=[0, 1])
-
-    def generate_incorrect_dims_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
-
-    @pytest.mark.parametrize(
-        "sel",
-        [[2, 10], [-1, 2]],
-        ids=[
-            "sel_value_larger_than_dims",
-            "sel_value_negative",
-        ],
-    )
-    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
-        with pytest.raises(IndexError):
-            op(data_m(), dims=self.dims, sel=sel)
-
-    def generate_incorrect_sel_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
+from . import test_mathematics as testing
+import numpy as np
+import scipy.linalg
+import pytest
+from qutip import data
+from qutip.core.data import CSR, Dense
+
+
+class TestPtrace(testing.UnaryOpMixin):
+    def op_numpy(self, matrix, dims, sel):
+        sel.sort()
+        ndims = len(dims)
+        dkeep = [dims[x] for x in sel]
+        qtrace = list(set(range(ndims)) - set(sel))
+        dtrace = [dims[x] for x in qtrace]
+
+        matrix = matrix.reshape(dims + dims)
+        matrix = matrix.transpose(
+            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
+        )
+        matrix = matrix.reshape(
+            [
+                np.prod(dtrace, dtype=int),
+                np.prod(dtrace, dtype=int),
+                np.prod(dkeep, dtype=int),
+                np.prod(dkeep, dtype=int),
+            ]
+        )
+        return np.trace(matrix)
+
+    # Custom shapes to have also custom dims and sel arguments.
+    # These values should not be changed.
+    dims = [2] * 7
+    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
+    bad_shapes = testing.shapes_not_square(np.prod(dims))
+
+    specialisations = [
+        pytest.param(data.ptrace_csr, CSR, CSR),
+        pytest.param(data.ptrace_csr_dense, CSR, Dense),
+        pytest.param(data.ptrace_dense, Dense, Dense),
+    ]
+
+    @pytest.mark.parametrize(
+        "sel",
+        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
+        ids=[
+            "keep_one",
+            "keep_multiple_sorted",
+            "keep_multiple_unsorted",
+            "trace_none",
+            "trace_all",
+        ],
+    )
+    def test_mathematically_correct(self, op, data_m, out_type, sel):
+        """
+        Test that the unary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
+        test = op(matrix, self.dims, sel)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(
+            test.to_array(), expected, atol=self.atol, rtol=self.rtol
+        )
+
+    def test_incorrect_shape_raises(self, op, data_m):
+        """
+        Test that the operation produces a suitable error if the shape of the
+        operand is not square.
+        """
+        with pytest.raises(ValueError):
+            op(data_m(), self.dims, sel=[0, 1])
+
+    # `out_type` is included but not used so that
+    # `generate_mathematically_correct` can be re-used.
+    @pytest.mark.parametrize(
+        "dims",
+        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
+        ids=[
+            "dims_different_to_shape",
+            "dims_0",
+            "dims_prod_is_shape_but_negative",
+            "dims_is_not_int",
+        ],
+    )
+    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
+        with pytest.raises(ValueError):
+            op(data_m(), dims, sel=[0, 1])
+
+    def generate_incorrect_dims_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
+
+    @pytest.mark.parametrize(
+        "sel",
+        [[2, 10], [-1, 2]],
+        ids=[
+            "sel_value_larger_than_dims",
+            "sel_value_negative",
+        ],
+    )
+    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
+        with pytest.raises(IndexError):
+            op(data_m(), dims=self.dims, sel=sel)
+
+    def generate_incorrect_sel_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
diff --git a/qutip/tests/core/data/test_reshape.py b/qutip/tests/core/data/test_reshape.py
index e86b327c8f..ad863b55e7 100644
--- a/qutip/tests/core/data/test_reshape.py
+++ b/qutip/tests/core/data/test_reshape.py
@@ -1,121 +1,121 @@
-from .test_mathematics import UnaryOpMixin
-import pytest
-import numpy as np
-from qutip import data
-from qutip.core.data import CSR, Dense
-
-
-class TestSplitColumns(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return [column[:, np.newaxis] for column in matrix.T]
-
-    specialisations = [
-        pytest.param(data.split_columns_csr, CSR, list),
-        pytest.param(data.split_columns_dense, Dense, list),
-    ]
-
-
-class TestColumnStack(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
-        return np.reshape(matrix, newshape=out_shape, order='F')
-
-    specialisations = [
-        pytest.param(data.column_stack_csr, CSR, CSR),
-        pytest.param(data.column_stack_dense, Dense, Dense),
-    ]
-
-
-class TestColumnUnstack(UnaryOpMixin):
-    def op_numpy(self, matrix, rows):
-        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
-        return np.reshape(matrix, newshape=out_shape, order='F')
-
-    shapes = [
-        (pytest.param((10, 1), id="ket"), ),
-    ]
-
-    bad_shapes = [
-        (pytest.param((1, 10), id="bra"), ),
-        (pytest.param((10, 10), id="square"), ),
-        (pytest.param((2, 10), id="non_square"), ),
-    ]
-
-    specialisations = [
-        pytest.param(data.column_unstack_csr, CSR, CSR),
-        pytest.param(data.column_unstack_dense, Dense, Dense),
-    ]
-
-    @pytest.mark.parametrize('rows', [2, 5])
-    def test_mathematically_correct(self, op, data_m, rows, out_type):
-        """
-        Test that the binary operation is correct for all the known type
-        specialisations.
-        """
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), rows)
-        test = op(matrix, rows)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-                                   rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_m):
-        with pytest.raises(ValueError):
-            op(data_m(), 1)  # We set rows to one so that it is always valid
-
-    # `out_type` is included but not used so that
-    # `generate_mathematically_correct` can be re-used.
-    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
-                                                      'invalid'])
-    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
-        with pytest.raises(ValueError):
-            op(data_m(), rows)
-
-    def generate_incorrect_rows_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
-
-
-class TestReshape(UnaryOpMixin):
-    def op_numpy(self, matrix, rows, columns):
-        out_shape = (rows, columns)
-        return np.reshape(matrix, newshape=out_shape, order='C')
-
-    # All matrices should have the same number of elements in total, so we can
-    # use the same (rows, columns) parametrisation for each input.
-    shapes = [
-        (pytest.param((1, 100), id="bra"), ),
-        (pytest.param((100, 1), id="ket"), ),
-        (pytest.param((2, 50), id="non_square"), ),
-        (pytest.param((10, 10), id="square"), ),
-    ]
-
-    specialisations = [
-        pytest.param(data.reshape_dense, Dense, Dense),
-        pytest.param(data.reshape_csr, CSR, CSR),
-    ]
-
-    # `out_type` is included but not used so that
-    # `generate_mathematically_correct` can be re-used.
-    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
-    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
-        """
-        Test that the binary operation is correct for all the known type
-        specialisations.
-        """
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), rows, columns)
-        test = op(matrix, rows, columns)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-                                   rtol=self.rtol)
-
-    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
-                             ids=["negative1", "negative2", "invalid"])
-    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
-        with pytest.raises(ValueError):
-            op(data_m(), rows, columns)
-
-    def generate_incorrect_rows_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
+from .test_mathematics import UnaryOpMixin
+import pytest
+import numpy as np
+from qutip import data
+from qutip.core.data import CSR, Dense
+
+
+class TestSplitColumns(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return [column[:, np.newaxis] for column in matrix.T]
+
+    specialisations = [
+        pytest.param(data.split_columns_csr, CSR, list),
+        pytest.param(data.split_columns_dense, Dense, list),
+    ]
+
+
+class TestColumnStack(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
+        return np.reshape(matrix, newshape=out_shape, order='F')
+
+    specialisations = [
+        pytest.param(data.column_stack_csr, CSR, CSR),
+        pytest.param(data.column_stack_dense, Dense, Dense),
+    ]
+
+
+class TestColumnUnstack(UnaryOpMixin):
+    def op_numpy(self, matrix, rows):
+        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
+        return np.reshape(matrix, newshape=out_shape, order='F')
+
+    shapes = [
+        (pytest.param((10, 1), id="ket"), ),
+    ]
+
+    bad_shapes = [
+        (pytest.param((1, 10), id="bra"), ),
+        (pytest.param((10, 10), id="square"), ),
+        (pytest.param((2, 10), id="non_square"), ),
+    ]
+
+    specialisations = [
+        pytest.param(data.column_unstack_csr, CSR, CSR),
+        pytest.param(data.column_unstack_dense, Dense, Dense),
+    ]
+
+    @pytest.mark.parametrize('rows', [2, 5])
+    def test_mathematically_correct(self, op, data_m, rows, out_type):
+        """
+        Test that the binary operation is correct for all the known type
+        specialisations.
+        """
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), rows)
+        test = op(matrix, rows)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+                                   rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_m):
+        with pytest.raises(ValueError):
+            op(data_m(), 1)  # We set rows to one so that it is always valid
+
+    # `out_type` is included but not used so that
+    # `generate_mathematically_correct` can be re-used.
+    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
+                                                      'invalid'])
+    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
+        with pytest.raises(ValueError):
+            op(data_m(), rows)
+
+    def generate_incorrect_rows_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
+
+
+class TestReshape(UnaryOpMixin):
+    def op_numpy(self, matrix, rows, columns):
+        out_shape = (rows, columns)
+        return np.reshape(matrix, newshape=out_shape, order='C')
+
+    # All matrices should have the same number of elements in total, so we can
+    # use the same (rows, columns) parametrisation for each input.
+    shapes = [
+        (pytest.param((1, 100), id="bra"), ),
+        (pytest.param((100, 1), id="ket"), ),
+        (pytest.param((2, 50), id="non_square"), ),
+        (pytest.param((10, 10), id="square"), ),
+    ]
+
+    specialisations = [
+        pytest.param(data.reshape_dense, Dense, Dense),
+        pytest.param(data.reshape_csr, CSR, CSR),
+    ]
+
+    # `out_type` is included but not used so that
+    # `generate_mathematically_correct` can be re-used.
+    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
+    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
+        """
+        Test that the binary operation is correct for all the known type
+        specialisations.
+        """
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), rows, columns)
+        test = op(matrix, rows, columns)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+                                   rtol=self.rtol)
+
+    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
+                             ids=["negative1", "negative2", "invalid"])
+    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
+        with pytest.raises(ValueError):
+            op(data_m(), rows, columns)
+
+    def generate_incorrect_rows_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
diff --git a/qutip/tests/core/test_brtools.py b/qutip/tests/core/test_brtools.py
index 527ca89778..c1b4318838 100644
--- a/qutip/tests/core/test_brtools.py
+++ b/qutip/tests/core/test_brtools.py
@@ -1,336 +1,336 @@
-import pytest
-import qutip
-import numpy as np
-from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
-from qutip.core.blochredfield import brterm, bloch_redfield_tensor
-from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
-                                  _br_term_data, _BlochRedfieldElement)
-
-
-def _make_rand_data(shape):
-    np.random.seed(11)
-    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    return qutip.data.Dense(array)
-
-
-transform = {
-    0: lambda x: x,
-    1: qutip.data.transpose,
-    2: qutip.data.conj,
-    3: qutip.data.adjoint
-}
-
-
-@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
-@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
-                         ids=['', 'transpose', 'conj', 'dag'])
-@pytest.mark.parametrize('transright', [0, 1, 2, 3],
-                         ids=['', 'transpose', 'conj', 'dag'])
-def test_matmul_var(datatype, transleft, transright):
-    shape = (5, 5)
-    np.random.seed(11)
-    left = qutip.data.to(datatype, _make_rand_data(shape))
-    right = qutip.data.to(datatype, _make_rand_data(shape))
-
-    expected = qutip.data.matmul(
-        transform[transleft](left),
-        transform[transright](right),
-        ).to_array()
-
-    computed = matmul_var_data(left, right, transleft, transright).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14)
-
-
-@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
-def test_eigen_transform(sparse):
-    a = qutip.destroy(5)
-    f = lambda t: t
-    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
-    eigenT = _EigenBasisTransform(op, sparse=sparse)
-    evecs_qevo = eigenT.as_Qobj()
-
-    for t in [0, 1, 1.5]:
-        eigenvals, ekets = op(t).eigenstates()
-        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
-                                   rtol=1e-14, atol=1e-14)
-        np.testing.assert_allclose(
-            np.abs(np.hstack([eket.full() for eket in ekets])),
-            np.abs(eigenT.evecs(t).to_array()),
-            rtol=1e-14, atol=1e-14
-        )
-        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
-                                   np.abs(eigenT.evecs(t).to_array()),
-                                   rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_ket():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.coherent(N, 1.1)
-
-    expected = (op @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_dm():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.coherent_dm(N, 1.1)
-
-    expected = (op @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_oper_ket():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
-
-    expected = (qutip.spre(op) @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(qutip.spre(op_diag).data,
-                          eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_super_ops():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.sprepost(
-        qutip.coherent_dm(N, 1.1),
-        qutip.thermal_dm(N, 1.1)
-    )
-
-    expected = (qutip.spre(op) @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(qutip.spre(op_diag).data,
-                          eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('func',
-                         [_br_term_dense, _br_term_sparse, _br_term_data],
-                         ids=['dense', 'sparse', 'data'])
-def test_br_term_linbblad_comp(func):
-    N = 5
-    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
-    A_op = a + a.dag()
-    H = qutip.num(N)
-    diag = H.eigenenergies()
-    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
-    spectrum = (skew > 0) * 1.
-    computation = func(A_op.data, spectrum, skew, 2).to_array()
-    lindblad = qutip.lindblad_dissipator(a).full()
-    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
-@pytest.mark.parametrize('spectra', [
-    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
-    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
-    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
-])
-def test_br_term(cutoff, spectra):
-    N = 5
-    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
-    A_op = a + a.dag()
-    H = qutip.num(N)
-    diag = H.eigenenergies()
-    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
-    spectrum = spectra(skew)
-    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
-    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
-    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
-    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
-    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_brterm(cutoff):
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
-    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
-    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
-    assert isinstance(R, qutip.Qobj)
-    assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
-    state = qutip.operator_to_vector(qutip.rand_dm(N))
-    fock_computed = R @ state
-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
-                               rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_td_brterm(cutoff):
-    N = 5
-    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
-    a = qutip.destroy(N)
-    A_op = qutip.QobjEvo([a + a.dag(), "t"])
-    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
-    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
-    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
-    assert isinstance(R, qutip.QobjEvo)
-    assert isinstance(R_eigs, qutip.QobjEvo)
-    assert isinstance(evecs, qutip.QobjEvo)
-    state = qutip.operator_to_vector(qutip.rand_dm(N))
-    fock_computed = R @ state
-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-    for t in [0, 0.5, 1.0]:
-        np.testing.assert_allclose(
-            (R(t) @ state).full(),
-            R.matmul(t, state).full(),
-            rtol=1e-14, atol=1e-14
-        )
-        np.testing.assert_allclose(fock_computed(t).full(),
-                                   eig_computed(t).full(),
-                                   rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_bloch_redfield_tensor_basis(cutoff):
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-    R = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        sec_cutoff=cutoff,
-        fock_basis=True
-    )
-    R_eigs, evecs = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        sec_cutoff=cutoff,
-        fock_basis=False
-    )
-    assert isinstance(R, qutip.Qobj)
-    assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
-    state = qutip.operator_to_vector(qutip.rand_dm(N))
-    fock_computed = R @ state
-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
-                               rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_bloch_redfield_tensor(cutoff):
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-    R = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        sec_cutoff=cutoff,
-        fock_basis=True
-    )
-    R_expected = qutip.liouvillian(H, [a**2])
-    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
-
-    assert isinstance(R, qutip.Qobj)
-    assert isinstance(R_expected, qutip.Qobj)
-    np.testing.assert_allclose(R.full(), R_expected.full(),
-                               rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('fock_basis', [True, False])
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
-    N = 3
-    H = qutip.QobjEvo([qutip.num(N), "t"])
-    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-    R = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[qutip.destroy(N)],
-        sec_cutoff=cutoff,
-        fock_basis=fock_basis
-    )
-    R = R[0] if not fock_basis else R
-    assert isinstance(R, qutip.QobjEvo)
-    for t in [0, 0.5, 1.0, 1.5]:
-        R_expected = bloch_redfield_tensor(
-            H=H(t),
-            a_ops=[(A_op(t), spectra)],
-            c_ops=[qutip.destroy(N)],
-            sec_cutoff=cutoff,
-            fock_basis=fock_basis
-        )
-        R_expected = R_expected[0] if not fock_basis else R_expected
-        np.testing.assert_allclose(R(t).full(), R_expected.full(),
-                                   rtol=1e-14, atol=1e-14)
-
-
-def test_bloch_redfield_tensor_spectral_string():
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = "(w>0) * 0.5"
-    R_eigs, evecs = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        fock_basis=False
-    )
-    assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
-
-def test_bloch_redfield_tensor_spectral_callable():
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = lambda w: (w>0) * 0.5
-    R_eigs, evecs = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        fock_basis=False
-    )
-    assert isinstance(R_eigs, qutip.Qobj)
+import pytest
+import qutip
+import numpy as np
+from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
+from qutip.core.blochredfield import brterm, bloch_redfield_tensor
+from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
+                                  _br_term_data, _BlochRedfieldElement)
+
+
+def _make_rand_data(shape):
+    np.random.seed(11)
+    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    return qutip.data.Dense(array)
+
+
+transform = {
+    0: lambda x: x,
+    1: qutip.data.transpose,
+    2: qutip.data.conj,
+    3: qutip.data.adjoint
+}
+
+
+@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
+@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
+                         ids=['', 'transpose', 'conj', 'dag'])
+@pytest.mark.parametrize('transright', [0, 1, 2, 3],
+                         ids=['', 'transpose', 'conj', 'dag'])
+def test_matmul_var(datatype, transleft, transright):
+    shape = (5, 5)
+    np.random.seed(11)
+    left = qutip.data.to(datatype, _make_rand_data(shape))
+    right = qutip.data.to(datatype, _make_rand_data(shape))
+
+    expected = qutip.data.matmul(
+        transform[transleft](left),
+        transform[transright](right),
+        ).to_array()
+
+    computed = matmul_var_data(left, right, transleft, transright).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14)
+
+
+@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
+def test_eigen_transform(sparse):
+    a = qutip.destroy(5)
+    f = lambda t: t
+    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
+    eigenT = _EigenBasisTransform(op, sparse=sparse)
+    evecs_qevo = eigenT.as_Qobj()
+
+    for t in [0, 1, 1.5]:
+        eigenvals, ekets = op(t).eigenstates()
+        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
+                                   rtol=1e-14, atol=1e-14)
+        np.testing.assert_allclose(
+            np.abs(np.hstack([eket.full() for eket in ekets])),
+            np.abs(eigenT.evecs(t).to_array()),
+            rtol=1e-14, atol=1e-14
+        )
+        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
+                                   np.abs(eigenT.evecs(t).to_array()),
+                                   rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_ket():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.coherent(N, 1.1)
+
+    expected = (op @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_dm():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.coherent_dm(N, 1.1)
+
+    expected = (op @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_oper_ket():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
+
+    expected = (qutip.spre(op) @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(qutip.spre(op_diag).data,
+                          eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_super_ops():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.sprepost(
+        qutip.coherent_dm(N, 1.1),
+        qutip.thermal_dm(N, 1.1)
+    )
+
+    expected = (qutip.spre(op) @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(qutip.spre(op_diag).data,
+                          eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('func',
+                         [_br_term_dense, _br_term_sparse, _br_term_data],
+                         ids=['dense', 'sparse', 'data'])
+def test_br_term_linbblad_comp(func):
+    N = 5
+    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
+    A_op = a + a.dag()
+    H = qutip.num(N)
+    diag = H.eigenenergies()
+    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
+    spectrum = (skew > 0) * 1.
+    computation = func(A_op.data, spectrum, skew, 2).to_array()
+    lindblad = qutip.lindblad_dissipator(a).full()
+    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
+@pytest.mark.parametrize('spectra', [
+    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
+    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
+    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
+])
+def test_br_term(cutoff, spectra):
+    N = 5
+    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
+    A_op = a + a.dag()
+    H = qutip.num(N)
+    diag = H.eigenenergies()
+    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
+    spectrum = spectra(skew)
+    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
+    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
+    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
+    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
+    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_brterm(cutoff):
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
+    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
+    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
+    assert isinstance(R, qutip.Qobj)
+    assert isinstance(R_eigs, qutip.Qobj)
+    assert isinstance(evecs, qutip.Qobj)
+    state = qutip.operator_to_vector(qutip.rand_dm(N))
+    fock_computed = R @ state
+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
+                               rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_td_brterm(cutoff):
+    N = 5
+    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
+    a = qutip.destroy(N)
+    A_op = qutip.QobjEvo([a + a.dag(), "t"])
+    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
+    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
+    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
+    assert isinstance(R, qutip.QobjEvo)
+    assert isinstance(R_eigs, qutip.QobjEvo)
+    assert isinstance(evecs, qutip.QobjEvo)
+    state = qutip.operator_to_vector(qutip.rand_dm(N))
+    fock_computed = R @ state
+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+    for t in [0, 0.5, 1.0]:
+        np.testing.assert_allclose(
+            (R(t) @ state).full(),
+            R.matmul(t, state).full(),
+            rtol=1e-14, atol=1e-14
+        )
+        np.testing.assert_allclose(fock_computed(t).full(),
+                                   eig_computed(t).full(),
+                                   rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_bloch_redfield_tensor_basis(cutoff):
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+    R = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        sec_cutoff=cutoff,
+        fock_basis=True
+    )
+    R_eigs, evecs = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        sec_cutoff=cutoff,
+        fock_basis=False
+    )
+    assert isinstance(R, qutip.Qobj)
+    assert isinstance(R_eigs, qutip.Qobj)
+    assert isinstance(evecs, qutip.Qobj)
+    state = qutip.operator_to_vector(qutip.rand_dm(N))
+    fock_computed = R @ state
+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
+                               rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_bloch_redfield_tensor(cutoff):
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+    R = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        sec_cutoff=cutoff,
+        fock_basis=True
+    )
+    R_expected = qutip.liouvillian(H, [a**2])
+    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
+
+    assert isinstance(R, qutip.Qobj)
+    assert isinstance(R_expected, qutip.Qobj)
+    np.testing.assert_allclose(R.full(), R_expected.full(),
+                               rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('fock_basis', [True, False])
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
+    N = 3
+    H = qutip.QobjEvo([qutip.num(N), "t"])
+    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+    R = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[qutip.destroy(N)],
+        sec_cutoff=cutoff,
+        fock_basis=fock_basis
+    )
+    R = R[0] if not fock_basis else R
+    assert isinstance(R, qutip.QobjEvo)
+    for t in [0, 0.5, 1.0, 1.5]:
+        R_expected = bloch_redfield_tensor(
+            H=H(t),
+            a_ops=[(A_op(t), spectra)],
+            c_ops=[qutip.destroy(N)],
+            sec_cutoff=cutoff,
+            fock_basis=fock_basis
+        )
+        R_expected = R_expected[0] if not fock_basis else R_expected
+        np.testing.assert_allclose(R(t).full(), R_expected.full(),
+                                   rtol=1e-14, atol=1e-14)
+
+
+def test_bloch_redfield_tensor_spectral_string():
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = "(w>0) * 0.5"
+    R_eigs, evecs = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        fock_basis=False
+    )
+    assert isinstance(R_eigs, qutip.Qobj)
+    assert isinstance(evecs, qutip.Qobj)
+
+def test_bloch_redfield_tensor_spectral_callable():
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = lambda w: (w>0) * 0.5
+    R_eigs, evecs = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        fock_basis=False
+    )
+    assert isinstance(R_eigs, qutip.Qobj)
     assert isinstance(evecs, qutip.Qobj)
\ No newline at end of file
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 2fe5ff0b6d..5c2807ac95 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -1,397 +1,397 @@
-import pytest
-import pickle
-import qutip
-import numpy as np
-import scipy.interpolate as interp
-from functools import partial
-from qutip.core.coefficient import (coefficient, norm, conj,
-                                    CompilationOptions, Coefficient,
-                                    clean_compiled_coefficient
-                                   )
-from qutip.core.options import CoreOptions
-
-# Ensure the latest version is tested
-clean_compiled_coefficient(True)
-
-
-def f(t, w):
-    return np.exp(w * t * np.pi)
-
-
-def g(t, w):
-    return np.cos(w * t * np.pi)
-
-
-def h(t, a, b):
-    return a + b + t
-
-
-def f_kw(t, w, **args):
-    return f(t, w)
-
-
-def g_kw(t, w, **args):
-    return g(t, w)
-
-
-def h_kw(t, a, b, **args):
-    return h(t, a, b)
-
-
-def f_qtv4(t, args):
-    return f(t, args["w"])
-
-
-def g_qtv4(t, args):
-    return g(t, args["w"])
-
-
-def h_qtv4(t, args):
-    return h(t, args["a"], args["b"])
-
-
-def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
-    "assert coeff1 == coeff2"
-    "inside refer to the range covered by tlistlog: [0.01, 1]"
-    ts = np.linspace(0.01, 1, 20)
-    eps = 1e-12
-    crit_times = [0.01+eps, 0.95, 1-eps]
-    if not inside:
-        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
-    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
-    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
-    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
-
-
-args = {"w": 1j}
-tlist = np.linspace(0, 1, 101)
-f_asarray = f(tlist, **args)
-g_asarray = g(tlist, **args)
-tlistlog = np.logspace(-2, 0, 501)
-f_asarraylog = f(tlistlog, **args)
-
-
-def coeff_generator(style, func):
-    """Make a Coefficient"""
-    if func == "f":
-        base = f
-    else:
-        base = g
-
-    if style == "func":
-        return coefficient(base, args=args)
-    if style == "array":
-        return coefficient(base(tlist, **args), tlist=tlist)
-    if style == "arraylog":
-        return coefficient(base(tlistlog, **args), tlist=tlistlog)
-    if style == "string" and func == "f":
-        return coefficient("exp(w * t * pi)", args=args)
-    if style == "string" and func == "g":
-        return coefficient("cos(w * t * pi)", args=args)
-    if style == "steparray":
-        return coefficient(base(tlist, **args), tlist=tlist,
-                           order=0)
-    if style == "steparraylog":
-        return coefficient(base(tlistlog, **args), tlist=tlistlog,
-                           order=0)
-
-
-@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
-    pytest.param(f, {'args': args},
-                 1e-10, id="func"),
-    pytest.param(f_kw, {'args': args},
-                 1e-10, id="func_keywords"),
-    pytest.param(f_qtv4, {'args': args},
-                 1e-10, id="func_qutip_v4"),
-    pytest.param(f_asarray, {'tlist': tlist},
-                 1e-6,  id="array"),
-    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
-                 1e-1, id="step_array"),
-    pytest.param(f_asarraylog, {'tlist': tlistlog},
-                 1e-6, id="nonlinear_array"),
-    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
-                 1e-1, id="nonlinear_step_array"),
-    pytest.param("exp(w * t * pi)", {'args': args},
-                 1e-10, id="string")
-])
-def test_CoeffCreationCall(base, kwargs, tol):
-    opt = CompilationOptions(recompile=True)
-    expected = lambda t: np.exp(1j * t * np.pi)
-    coeff = coefficient(base, **kwargs, compile_opt=opt)
-    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
-
-
-@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
-    pytest.param(f, {'args': args},
-                 1e-10, id="func"),
-    pytest.param(f_kw, {'args': args},
-                 1e-10, id="func_keywords"),
-    pytest.param(f_qtv4, {'args': args},
-                 1e-10, id="func_qutip_v4"),
-    pytest.param("exp(w * t * pi)", {'args': args},
-                 1e-10, id="string")
-])
-def test_CoeffCallArgs(base, kwargs, tol):
-    w = np.e + 0.5j
-    expected = lambda t: np.exp(w * t * np.pi)
-    coeff = coefficient(base, **kwargs)
-    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
-
-
-@pytest.mark.parametrize(['base', 'tol'], [
-    pytest.param(h, 1e-10, id="func"),
-    pytest.param(h_kw, 1e-10, id="func_keywords"),
-    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
-    pytest.param("a + b + t", 1e-10, id="string")
-])
-def test_CoeffCallArguments(base, tol):
-    # Partial args update
-    args = {"a": 1, "b": 1}
-    a = np.e
-    expected = lambda t: a + 1 + t
-    coeff = coefficient(base, args=args)
-    coeff = coeff.replace_arguments({"a": a})
-    _assert_eq_over_interval(coeff, expected, rtol=tol)
-    b = np.pi
-    expected = lambda t: a + b + t
-    coeff = coeff.replace_arguments(b=b)
-    _assert_eq_over_interval(coeff, expected, rtol=tol)
-
-
-@pytest.mark.parametrize(['style'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['transform', 'expected'], [
-    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
-    pytest.param(conj, lambda val: np.conj(val), id="conj"),
-])
-def test_CoeffUnitaryTransform(style, transform, expected):
-    coeff = coeff_generator(style, "f")
-    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
-
-
-@pytest.mark.parametrize(['style_left'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['style_right'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['oper'], [
-    pytest.param(lambda a, b: a+b, id="sum"),
-    pytest.param(lambda a, b: a*b, id="prod"),
-])
-def test_CoeffOperation(style_left, style_right, oper):
-    coeff_left = coeff_generator(style_left, "f")
-    coeff_right = coeff_generator(style_right, "g")
-    _assert_eq_over_interval(
-        oper(coeff_left, coeff_right),
-        lambda t: oper(coeff_left(t), coeff_right(t))
-    )
-
-
-@pytest.mark.requires_cython
-def test_CoeffReuse():
-    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
-    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
-    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
-    assert isinstance(coeff2, coeff1.__class__)
-    assert isinstance(coeff3, coeff1.__class__)
-
-
-@pytest.mark.requires_cython
-def test_CoeffOptions():
-    from itertools import combinations
-    base = "1 + 1. + 1j"
-    options = []
-    options.append(CompilationOptions(accept_int=True))
-    options.append(CompilationOptions(accept_float=False))
-    options.append(CompilationOptions(static_types=True))
-    options.append(CompilationOptions(try_parse=False))
-    options.append(CompilationOptions(use_cython=False))
-    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
-    for coeff in coeffs:
-        assert coeff(0) == 2+1j
-    for coeff1, coeff2 in combinations(coeffs, 2):
-        assert not isinstance(coeff1, coeff2.__class__)
-
-
-@pytest.mark.requires_cython
-@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
-    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
-                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
-                 lambda t: 0, id="long"),
-    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
-                 lambda t: t + 1, id="lots_of_ctes"),
-    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
-                 lambda t: np.cos(t), id="real_array_subscript"),
-    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
-                 lambda t: 1, id="cplx_array_subscript"),
-    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
-                 lambda t: np.cos(t), id="dictargs"),
-    pytest.param("cos(t*a); print(a)", {'a': 1},
-                 lambda t: np.cos(t), id="print"),
-    pytest.param("t + (0 if not 'something' else 1)", {},
-                 lambda t: t + 1, id="branch")
-])
-@pytest.mark.filterwarnings(
-    "ignore::qutip.core.coefficient.StringParsingWarning"
-)
-def test_CoeffParsingStressTest(codestring, args, reference):
-    opt = CompilationOptions(recompile=True)
-    coeff = coefficient(codestring, args=args, compile_opt=opt)
-    _assert_eq_over_interval(coeff, reference)
-
-
-@pytest.mark.requires_cython
-@pytest.mark.filterwarnings("error")
-def test_manual_typing():
-    opt = CompilationOptions(recompile=True)
-    coeff = coefficient("my_list[0] + my_dict[5]",
-                        args={"my_list": [1], "my_dict": {5: 2}},
-                        args_ctypes={"my_list": "list", "my_dict": "dict"},
-                        compile_opt=opt)
-    assert coeff(0) == 3
-
-
-@pytest.mark.requires_cython
-def test_advance_use():
-    opt = CompilationOptions(recompile=True, extra_import="""
-from qutip import basis
-from qutip.core.data cimport CSR
-from qutip.core.data.expect cimport expect_csr
-""")
-    csr = qutip.num(3).data
-    coeff = coefficient("expect_csr(op, op)",
-                        args={"op": csr},
-                        args_ctypes={"op": "CSR"},
-                        compile_opt=opt)
-    assert coeff(0) == 5.
-
-
-def _add(coeff):
-    return coeff + coeff
-
-
-def _pass(coeff):
-    return coeff
-
-
-def _mul(coeff):
-    return coeff * coeff
-
-
-@pytest.mark.parametrize(['style'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['transform'], [
-    pytest.param(_pass, id="single"),
-    pytest.param(_add, id="sum"),
-    pytest.param(_mul, id="prod"),
-    pytest.param(norm, id="norm"),
-    pytest.param(conj, id="conj"),
-])
-def test_Coeffpickle(style, transform):
-    coeff = coeff_generator(style, "f")
-    coeff = transform(coeff)
-    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
-    _assert_eq_over_interval(coeff, coeff_pick)
-
-
-@pytest.mark.parametrize(['style'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['transform'], [
-    pytest.param(_pass, id="single"),
-    pytest.param(_add, id="sum"),
-    pytest.param(_mul, id="prod"),
-    pytest.param(norm, id="norm"),
-    pytest.param(conj, id="conj"),
-])
-def test_Coeffcopy(style, transform):
-    coeff = coeff_generator(style, "f")
-    coeff = transform(coeff)
-    coeff_cp = coeff.copy()
-    _assert_eq_over_interval(coeff, coeff_cp)
-
-
-@pytest.mark.parametrize('order', [0, 1, 2, 3])
-def test_CoeffArray(order):
-    tlist = np.linspace(0, 1, 101)
-    y = np.exp((-1 + 1j) * tlist)
-    coeff = coefficient(y, tlist=tlist, order=order)
-    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
-    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
-                             inside=True)
-    dt = 1e-4
-    t = 0.0225
-    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
-    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
-    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
-             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
-    derrs = [derr, derr2, derr3]
-    for i in range(order):
-        assert derrs[i] != 0
-    for i in range(order, 3):
-        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
-
-
-def test_CoeffFromScipy():
-    tlist = np.linspace(0, 1.01, 101)
-    y = np.exp((-1 + 1j) * tlist)
-
-    coeff = coefficient(y, tlist=tlist, order=3)
-    from_scipy = coefficient(interp.CubicSpline(tlist, y))
-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-
-    coeff = coefficient(y, tlist=tlist, order=3)
-    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-
-    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
-    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-
-
-@pytest.mark.parametrize('map_func', [
-    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
-    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
-])
-@pytest.mark.requires_cython
-def test_coefficient_parallel(map_func):
-    otherwise_never_used = "np.log(np.exp(t + t + t))"
-    expected = coefficient(lambda t: 3 * t)
-
-    if map_func is qutip.solver.parallel.loky_pmap:
-        loky = pytest.importorskip("loky")
-        otherwise_never_used += " + 0"
-
-    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
-
-    for coeff in coeffs:
-        assert isinstance(coeff, Coefficient)
-        _assert_eq_over_interval(coeff, expected)
+import pytest
+import pickle
+import qutip
+import numpy as np
+import scipy.interpolate as interp
+from functools import partial
+from qutip.core.coefficient import (coefficient, norm, conj,
+                                    CompilationOptions, Coefficient,
+                                    clean_compiled_coefficient
+                                   )
+from qutip.core.options import CoreOptions
+
+# Ensure the latest version is tested
+clean_compiled_coefficient(True)
+
+
+def f(t, w):
+    return np.exp(w * t * np.pi)
+
+
+def g(t, w):
+    return np.cos(w * t * np.pi)
+
+
+def h(t, a, b):
+    return a + b + t
+
+
+def f_kw(t, w, **args):
+    return f(t, w)
+
+
+def g_kw(t, w, **args):
+    return g(t, w)
+
+
+def h_kw(t, a, b, **args):
+    return h(t, a, b)
+
+
+def f_qtv4(t, args):
+    return f(t, args["w"])
+
+
+def g_qtv4(t, args):
+    return g(t, args["w"])
+
+
+def h_qtv4(t, args):
+    return h(t, args["a"], args["b"])
+
+
+def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
+    "assert coeff1 == coeff2"
+    "inside refer to the range covered by tlistlog: [0.01, 1]"
+    ts = np.linspace(0.01, 1, 20)
+    eps = 1e-12
+    crit_times = [0.01+eps, 0.95, 1-eps]
+    if not inside:
+        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
+    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
+    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
+    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
+
+
+args = {"w": 1j}
+tlist = np.linspace(0, 1, 101)
+f_asarray = f(tlist, **args)
+g_asarray = g(tlist, **args)
+tlistlog = np.logspace(-2, 0, 501)
+f_asarraylog = f(tlistlog, **args)
+
+
+def coeff_generator(style, func):
+    """Make a Coefficient"""
+    if func == "f":
+        base = f
+    else:
+        base = g
+
+    if style == "func":
+        return coefficient(base, args=args)
+    if style == "array":
+        return coefficient(base(tlist, **args), tlist=tlist)
+    if style == "arraylog":
+        return coefficient(base(tlistlog, **args), tlist=tlistlog)
+    if style == "string" and func == "f":
+        return coefficient("exp(w * t * pi)", args=args)
+    if style == "string" and func == "g":
+        return coefficient("cos(w * t * pi)", args=args)
+    if style == "steparray":
+        return coefficient(base(tlist, **args), tlist=tlist,
+                           order=0)
+    if style == "steparraylog":
+        return coefficient(base(tlistlog, **args), tlist=tlistlog,
+                           order=0)
+
+
+@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
+    pytest.param(f, {'args': args},
+                 1e-10, id="func"),
+    pytest.param(f_kw, {'args': args},
+                 1e-10, id="func_keywords"),
+    pytest.param(f_qtv4, {'args': args},
+                 1e-10, id="func_qutip_v4"),
+    pytest.param(f_asarray, {'tlist': tlist},
+                 1e-6,  id="array"),
+    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
+                 1e-1, id="step_array"),
+    pytest.param(f_asarraylog, {'tlist': tlistlog},
+                 1e-6, id="nonlinear_array"),
+    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
+                 1e-1, id="nonlinear_step_array"),
+    pytest.param("exp(w * t * pi)", {'args': args},
+                 1e-10, id="string")
+])
+def test_CoeffCreationCall(base, kwargs, tol):
+    opt = CompilationOptions(recompile=True)
+    expected = lambda t: np.exp(1j * t * np.pi)
+    coeff = coefficient(base, **kwargs, compile_opt=opt)
+    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
+
+
+@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
+    pytest.param(f, {'args': args},
+                 1e-10, id="func"),
+    pytest.param(f_kw, {'args': args},
+                 1e-10, id="func_keywords"),
+    pytest.param(f_qtv4, {'args': args},
+                 1e-10, id="func_qutip_v4"),
+    pytest.param("exp(w * t * pi)", {'args': args},
+                 1e-10, id="string")
+])
+def test_CoeffCallArgs(base, kwargs, tol):
+    w = np.e + 0.5j
+    expected = lambda t: np.exp(w * t * np.pi)
+    coeff = coefficient(base, **kwargs)
+    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
+
+
+@pytest.mark.parametrize(['base', 'tol'], [
+    pytest.param(h, 1e-10, id="func"),
+    pytest.param(h_kw, 1e-10, id="func_keywords"),
+    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
+    pytest.param("a + b + t", 1e-10, id="string")
+])
+def test_CoeffCallArguments(base, tol):
+    # Partial args update
+    args = {"a": 1, "b": 1}
+    a = np.e
+    expected = lambda t: a + 1 + t
+    coeff = coefficient(base, args=args)
+    coeff = coeff.replace_arguments({"a": a})
+    _assert_eq_over_interval(coeff, expected, rtol=tol)
+    b = np.pi
+    expected = lambda t: a + b + t
+    coeff = coeff.replace_arguments(b=b)
+    _assert_eq_over_interval(coeff, expected, rtol=tol)
+
+
+@pytest.mark.parametrize(['style'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['transform', 'expected'], [
+    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
+    pytest.param(conj, lambda val: np.conj(val), id="conj"),
+])
+def test_CoeffUnitaryTransform(style, transform, expected):
+    coeff = coeff_generator(style, "f")
+    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
+
+
+@pytest.mark.parametrize(['style_left'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['style_right'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['oper'], [
+    pytest.param(lambda a, b: a+b, id="sum"),
+    pytest.param(lambda a, b: a*b, id="prod"),
+])
+def test_CoeffOperation(style_left, style_right, oper):
+    coeff_left = coeff_generator(style_left, "f")
+    coeff_right = coeff_generator(style_right, "g")
+    _assert_eq_over_interval(
+        oper(coeff_left, coeff_right),
+        lambda t: oper(coeff_left(t), coeff_right(t))
+    )
+
+
+@pytest.mark.requires_cython
+def test_CoeffReuse():
+    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
+    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
+    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
+    assert isinstance(coeff2, coeff1.__class__)
+    assert isinstance(coeff3, coeff1.__class__)
+
+
+@pytest.mark.requires_cython
+def test_CoeffOptions():
+    from itertools import combinations
+    base = "1 + 1. + 1j"
+    options = []
+    options.append(CompilationOptions(accept_int=True))
+    options.append(CompilationOptions(accept_float=False))
+    options.append(CompilationOptions(static_types=True))
+    options.append(CompilationOptions(try_parse=False))
+    options.append(CompilationOptions(use_cython=False))
+    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
+    for coeff in coeffs:
+        assert coeff(0) == 2+1j
+    for coeff1, coeff2 in combinations(coeffs, 2):
+        assert not isinstance(coeff1, coeff2.__class__)
+
+
+@pytest.mark.requires_cython
+@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
+    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
+                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
+                 lambda t: 0, id="long"),
+    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
+                 lambda t: t + 1, id="lots_of_ctes"),
+    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
+                 lambda t: np.cos(t), id="real_array_subscript"),
+    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
+                 lambda t: 1, id="cplx_array_subscript"),
+    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
+                 lambda t: np.cos(t), id="dictargs"),
+    pytest.param("cos(t*a); print(a)", {'a': 1},
+                 lambda t: np.cos(t), id="print"),
+    pytest.param("t + (0 if not 'something' else 1)", {},
+                 lambda t: t + 1, id="branch")
+])
+@pytest.mark.filterwarnings(
+    "ignore::qutip.core.coefficient.StringParsingWarning"
+)
+def test_CoeffParsingStressTest(codestring, args, reference):
+    opt = CompilationOptions(recompile=True)
+    coeff = coefficient(codestring, args=args, compile_opt=opt)
+    _assert_eq_over_interval(coeff, reference)
+
+
+@pytest.mark.requires_cython
+@pytest.mark.filterwarnings("error")
+def test_manual_typing():
+    opt = CompilationOptions(recompile=True)
+    coeff = coefficient("my_list[0] + my_dict[5]",
+                        args={"my_list": [1], "my_dict": {5: 2}},
+                        args_ctypes={"my_list": "list", "my_dict": "dict"},
+                        compile_opt=opt)
+    assert coeff(0) == 3
+
+
+@pytest.mark.requires_cython
+def test_advance_use():
+    opt = CompilationOptions(recompile=True, extra_import="""
+from qutip import basis
+from qutip.core.data cimport CSR
+from qutip.core.data.expect cimport expect_csr
+""")
+    csr = qutip.num(3).data
+    coeff = coefficient("expect_csr(op, op)",
+                        args={"op": csr},
+                        args_ctypes={"op": "CSR"},
+                        compile_opt=opt)
+    assert coeff(0) == 5.
+
+
+def _add(coeff):
+    return coeff + coeff
+
+
+def _pass(coeff):
+    return coeff
+
+
+def _mul(coeff):
+    return coeff * coeff
+
+
+@pytest.mark.parametrize(['style'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['transform'], [
+    pytest.param(_pass, id="single"),
+    pytest.param(_add, id="sum"),
+    pytest.param(_mul, id="prod"),
+    pytest.param(norm, id="norm"),
+    pytest.param(conj, id="conj"),
+])
+def test_Coeffpickle(style, transform):
+    coeff = coeff_generator(style, "f")
+    coeff = transform(coeff)
+    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
+    _assert_eq_over_interval(coeff, coeff_pick)
+
+
+@pytest.mark.parametrize(['style'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['transform'], [
+    pytest.param(_pass, id="single"),
+    pytest.param(_add, id="sum"),
+    pytest.param(_mul, id="prod"),
+    pytest.param(norm, id="norm"),
+    pytest.param(conj, id="conj"),
+])
+def test_Coeffcopy(style, transform):
+    coeff = coeff_generator(style, "f")
+    coeff = transform(coeff)
+    coeff_cp = coeff.copy()
+    _assert_eq_over_interval(coeff, coeff_cp)
+
+
+@pytest.mark.parametrize('order', [0, 1, 2, 3])
+def test_CoeffArray(order):
+    tlist = np.linspace(0, 1, 101)
+    y = np.exp((-1 + 1j) * tlist)
+    coeff = coefficient(y, tlist=tlist, order=order)
+    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
+    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
+                             inside=True)
+    dt = 1e-4
+    t = 0.0225
+    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
+    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
+    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
+             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
+    derrs = [derr, derr2, derr3]
+    for i in range(order):
+        assert derrs[i] != 0
+    for i in range(order, 3):
+        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
+
+
+def test_CoeffFromScipy():
+    tlist = np.linspace(0, 1.01, 101)
+    y = np.exp((-1 + 1j) * tlist)
+
+    coeff = coefficient(y, tlist=tlist, order=3)
+    from_scipy = coefficient(interp.CubicSpline(tlist, y))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
+    coeff = coefficient(y, tlist=tlist, order=3)
+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
+    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
+
+@pytest.mark.parametrize('map_func', [
+    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
+    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
+])
+@pytest.mark.requires_cython
+def test_coefficient_parallel(map_func):
+    otherwise_never_used = "np.log(np.exp(t + t + t))"
+    expected = coefficient(lambda t: 3 * t)
+
+    if map_func is qutip.solver.parallel.loky_pmap:
+        loky = pytest.importorskip("loky")
+        otherwise_never_used += " + 0"
+
+    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
+
+    for coeff in coeffs:
+        assert isinstance(coeff, Coefficient)
+        _assert_eq_over_interval(coeff, expected)
diff --git a/qutip/tests/core/test_dimensions.py b/qutip/tests/core/test_dimensions.py
index a32c302941..d21f298385 100644
--- a/qutip/tests/core/test_dimensions.py
+++ b/qutip/tests/core/test_dimensions.py
@@ -1,201 +1,201 @@
-# -*- coding: utf-8 -*-
-
-import pytest
-import collections
-import qutip
-from qutip.core.dimensions import (
-    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
-    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
-    collapse_dims_super, collapse_dims_oper,
-)
-
-_v = "vector"
-_vo = "vectorized_oper"
-
-
-@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
-    pytest.param([1], _v, True, id="scalar"),
-    pytest.param([1, 1], _v, True, id="tensor scalar"),
-    pytest.param([[1]], _vo, True, id="nested scalar"),
-    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
-    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
-    pytest.param([2], _v, False, id="vector"),
-    pytest.param([2, 3], _v, False, id="tensor vector"),
-    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
-    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
-    pytest.param([[2]], _vo, False, id="vectorised operator"),
-    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
-    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
-])
-@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
-def test_rank_type_detection(rank, actual_type, scalar, test_type):
-    """
-    Test the rank detection tests `is_scalar`, `is_vector` and
-    `is_vectorized_oper` for a range of different test cases.  These tests are
-    designed to be called on individual elements of the two-element `dims`
-    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
-
-    It's possible to be both a scalar and something else, but "vector" and
-    "vectorized_oper" are mutually exclusive.
-
-    These functions aren't properly specified for improper dimension setups, so
-    there are no tests for those.
-    """
-    expected = scalar if test_type == "scalar" else (actual_type == test_type)
-    function = getattr(qutip.dimensions, "is_" + test_type)
-    assert function(rank) == expected
-
-
-@pytest.mark.parametrize(["base", "flat"], [
-    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
-    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
-                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
-    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
-    pytest.param([], [], id="empty list"),
-    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
-])
-class TestFlattenUnflatten:
-    def test_flatten(self, base, flat):
-        assert flatten(base) == flat
-
-    def test_unflatten(self, base, flat):
-        labels = enumerate_flat(base)
-        assert unflatten(flat, labels) == base
-
-
-@pytest.mark.parametrize(["base", "expected"], [
-    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
-    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
-    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
-    pytest.param([], [], id="empty"),
-    pytest.param([[], [], [[[], [], []]]],
-                 [[], [], [[[], [], []]]], id="nested empty lists"),
-])
-def test_enumerate_flat(base, expected):
-    assert enumerate_flat(base) == expected
-
-
-@pytest.mark.parametrize(["base", "to_remove", "expected"], [
-    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
-    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
-                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
-    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
-    pytest.param([], (), [], id="empty"),
-])
-def test_deep_remove(base, to_remove, expected):
-    assert deep_remove(base, *to_remove) == expected
-
-
-@pytest.mark.parametrize("mapping", [
-    pytest.param(lambda x: x*2, id="(x -> 2x)"),
-    pytest.param(lambda x: [x], id="(x -> [x])"),
-])
-@pytest.mark.parametrize("base", [
-    pytest.param([[[0], 1], 2], id="standard"),
-    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
-    pytest.param([1, 2, 3], id="flat"),
-    pytest.param([], id="empty list"),
-    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
-])
-def test_deep_map(base, mapping):
-    """
-    Test the deep mapping.  To simplify generation of edge-cases, this tests
-    against an equivalent (but slower) operation of flattening and unflattening
-    the list.  We can get false negatives if the `flatten` or `unflatten`
-    functions are broken, but other tests should catch those.
-    """
-    # This function might not need to be public, and consequently might not
-    # need to be tested here.
-    labels = enumerate_flat(base)
-    expected = unflatten([mapping(x) for x in flatten(base)], labels)
-    assert deep_map(mapping, base) == expected
-
-
-_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
-
-
-@pytest.mark.parametrize("indices", [
-    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
-    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
-                 id="tensor-ket preserved"),
-    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
-    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
-                 id="tensor-bra preserved"),
-    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
-    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
-                 id="tensor-oper preserved"),
-    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
-                          [2, 3, 0, 1, 6, 7, 4, 5],
-                          (6, 8, 2, 4, 5, 7, 1, 3)),
-                 id="super-oper"),
-    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
-                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
-                 id="operator-ket"),
-    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
-                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
-                 id="operator-bra"),
-])
-class TestSuperOperatorDimsModification:
-    def test_dims_to_tensor_perm(self, indices):
-        # This function might not need to be public, and consequently might not
-        # need to be tested here.
-        assert dims_to_tensor_perm(indices.base) == indices.permutation
-
-    def test_dims_idxs_to_tensor_idxs(self, indices):
-        test_indices = list(range(len(flatten(indices.base))))
-        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
-                == indices.permutation)
-
-    def test_dims_to_tensor_shape(self, indices):
-        assert dims_to_tensor_shape(indices.base) == indices.shape
-
-
-class TestTypeFromDims:
-    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
-        pytest.param([[2], [2]], 'oper', True),
-        pytest.param([[2, 3], [2, 3]], 'oper', True),
-        pytest.param([[2], [3]], 'other', True),
-        pytest.param([[2], [3]], 'oper', False),
-        pytest.param([[2], [1]], 'ket', True),
-        pytest.param([[1], [2]], 'bra', True),
-        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
-        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
-        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
-        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
-        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
-    ])
-    def test_type_from_dims(self, base, expected, enforce_square):
-        assert type_from_dims(base, enforce_square=enforce_square) == expected
-
-    @pytest.mark.parametrize("qobj", [
-        pytest.param(qutip.rand_ket(10), id='ket'),
-        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
-        pytest.param(qutip.rand_dm(10), id='oper'),
-        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
-    ])
-    def test_qobj_dims_match_qobj(self, qobj):
-        assert type_from_dims(qobj.dims) == qobj.type
-
-
-class TestCollapseDims:
-    @pytest.mark.parametrize(["base", "expected"], [
-        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
-        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
-        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
-        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
-        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
-        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
-    ])
-    def test_oper(self, base, expected):
-        assert collapse_dims_oper(base) == expected
-
-    @pytest.mark.parametrize(["base", "expected"], [
-        pytest.param([[[1]], [[2, 3], [2, 3]]],
-                     [[[1]], [[6], [6]]], id="operator-ket"),
-        pytest.param([[[2, 3], [2, 3]], [[1]]],
-                     [[[6], [6]], [[1]]], id="operator-bra"),
-        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
-                     [[[6], [6]], [[6], [6]]], id="super"),
-    ])
-    def test_super(self, base, expected):
-        assert collapse_dims_super(base) == expected
+# -*- coding: utf-8 -*-
+
+import pytest
+import collections
+import qutip
+from qutip.core.dimensions import (
+    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
+    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
+    collapse_dims_super, collapse_dims_oper,
+)
+
+_v = "vector"
+_vo = "vectorized_oper"
+
+
+@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
+    pytest.param([1], _v, True, id="scalar"),
+    pytest.param([1, 1], _v, True, id="tensor scalar"),
+    pytest.param([[1]], _vo, True, id="nested scalar"),
+    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
+    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
+    pytest.param([2], _v, False, id="vector"),
+    pytest.param([2, 3], _v, False, id="tensor vector"),
+    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
+    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
+    pytest.param([[2]], _vo, False, id="vectorised operator"),
+    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
+    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
+])
+@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
+def test_rank_type_detection(rank, actual_type, scalar, test_type):
+    """
+    Test the rank detection tests `is_scalar`, `is_vector` and
+    `is_vectorized_oper` for a range of different test cases.  These tests are
+    designed to be called on individual elements of the two-element `dims`
+    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
+
+    It's possible to be both a scalar and something else, but "vector" and
+    "vectorized_oper" are mutually exclusive.
+
+    These functions aren't properly specified for improper dimension setups, so
+    there are no tests for those.
+    """
+    expected = scalar if test_type == "scalar" else (actual_type == test_type)
+    function = getattr(qutip.dimensions, "is_" + test_type)
+    assert function(rank) == expected
+
+
+@pytest.mark.parametrize(["base", "flat"], [
+    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
+    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
+                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
+    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
+    pytest.param([], [], id="empty list"),
+    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
+])
+class TestFlattenUnflatten:
+    def test_flatten(self, base, flat):
+        assert flatten(base) == flat
+
+    def test_unflatten(self, base, flat):
+        labels = enumerate_flat(base)
+        assert unflatten(flat, labels) == base
+
+
+@pytest.mark.parametrize(["base", "expected"], [
+    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
+    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
+    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
+    pytest.param([], [], id="empty"),
+    pytest.param([[], [], [[[], [], []]]],
+                 [[], [], [[[], [], []]]], id="nested empty lists"),
+])
+def test_enumerate_flat(base, expected):
+    assert enumerate_flat(base) == expected
+
+
+@pytest.mark.parametrize(["base", "to_remove", "expected"], [
+    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
+    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
+                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
+    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
+    pytest.param([], (), [], id="empty"),
+])
+def test_deep_remove(base, to_remove, expected):
+    assert deep_remove(base, *to_remove) == expected
+
+
+@pytest.mark.parametrize("mapping", [
+    pytest.param(lambda x: x*2, id="(x -> 2x)"),
+    pytest.param(lambda x: [x], id="(x -> [x])"),
+])
+@pytest.mark.parametrize("base", [
+    pytest.param([[[0], 1], 2], id="standard"),
+    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
+    pytest.param([1, 2, 3], id="flat"),
+    pytest.param([], id="empty list"),
+    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
+])
+def test_deep_map(base, mapping):
+    """
+    Test the deep mapping.  To simplify generation of edge-cases, this tests
+    against an equivalent (but slower) operation of flattening and unflattening
+    the list.  We can get false negatives if the `flatten` or `unflatten`
+    functions are broken, but other tests should catch those.
+    """
+    # This function might not need to be public, and consequently might not
+    # need to be tested here.
+    labels = enumerate_flat(base)
+    expected = unflatten([mapping(x) for x in flatten(base)], labels)
+    assert deep_map(mapping, base) == expected
+
+
+_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
+
+
+@pytest.mark.parametrize("indices", [
+    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
+    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
+                 id="tensor-ket preserved"),
+    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
+    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
+                 id="tensor-bra preserved"),
+    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
+    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
+                 id="tensor-oper preserved"),
+    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
+                          [2, 3, 0, 1, 6, 7, 4, 5],
+                          (6, 8, 2, 4, 5, 7, 1, 3)),
+                 id="super-oper"),
+    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
+                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
+                 id="operator-ket"),
+    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
+                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
+                 id="operator-bra"),
+])
+class TestSuperOperatorDimsModification:
+    def test_dims_to_tensor_perm(self, indices):
+        # This function might not need to be public, and consequently might not
+        # need to be tested here.
+        assert dims_to_tensor_perm(indices.base) == indices.permutation
+
+    def test_dims_idxs_to_tensor_idxs(self, indices):
+        test_indices = list(range(len(flatten(indices.base))))
+        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
+                == indices.permutation)
+
+    def test_dims_to_tensor_shape(self, indices):
+        assert dims_to_tensor_shape(indices.base) == indices.shape
+
+
+class TestTypeFromDims:
+    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
+        pytest.param([[2], [2]], 'oper', True),
+        pytest.param([[2, 3], [2, 3]], 'oper', True),
+        pytest.param([[2], [3]], 'other', True),
+        pytest.param([[2], [3]], 'oper', False),
+        pytest.param([[2], [1]], 'ket', True),
+        pytest.param([[1], [2]], 'bra', True),
+        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
+        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
+        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
+        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
+        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
+    ])
+    def test_type_from_dims(self, base, expected, enforce_square):
+        assert type_from_dims(base, enforce_square=enforce_square) == expected
+
+    @pytest.mark.parametrize("qobj", [
+        pytest.param(qutip.rand_ket(10), id='ket'),
+        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
+        pytest.param(qutip.rand_dm(10), id='oper'),
+        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
+    ])
+    def test_qobj_dims_match_qobj(self, qobj):
+        assert type_from_dims(qobj.dims) == qobj.type
+
+
+class TestCollapseDims:
+    @pytest.mark.parametrize(["base", "expected"], [
+        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
+        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
+        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
+        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
+        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
+        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
+    ])
+    def test_oper(self, base, expected):
+        assert collapse_dims_oper(base) == expected
+
+    @pytest.mark.parametrize(["base", "expected"], [
+        pytest.param([[[1]], [[2, 3], [2, 3]]],
+                     [[[1]], [[6], [6]]], id="operator-ket"),
+        pytest.param([[[2, 3], [2, 3]], [[1]]],
+                     [[[6], [6]], [[1]]], id="operator-bra"),
+        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
+                     [[[6], [6]], [[6], [6]]], id="super"),
+    ])
+    def test_super(self, base, expected):
+        assert collapse_dims_super(base) == expected
diff --git a/qutip/tests/core/test_eigen.py b/qutip/tests/core/test_eigen.py
index ecf6f6093c..05e06db0fc 100644
--- a/qutip/tests/core/test_eigen.py
+++ b/qutip/tests/core/test_eigen.py
@@ -1,118 +1,118 @@
-import scipy
-import numpy as np
-import pytest
-import qutip
-
-
-def is_eigen_set(oper, vals, vecs):
-    for val, vec in zip(vals, vecs):
-        assert abs(vec.norm() - 1) < 1e-13
-        assert abs(qutip.expect(oper, vec) - val) < 1e-13
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-def test_eigen_known_oper(sparse, dtype):
-    N = qutip.num(10, dtype=dtype)
-    spvals, spvecs = N.eigenstates(sparse=sparse)
-    expected = np.arange(10)
-    is_eigen_set(N, spvals, spvecs)
-    np.testing.assert_allclose(spvals, expected, atol=1e-13)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-@pytest.mark.parametrize(["rand"], [
-    pytest.param(qutip.rand_herm, id="hermitian"),
-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-])
-@pytest.mark.parametrize("order", ['low', 'high'])
-def test_eigen_rand_oper(rand, sparse, dtype, order):
-    H = rand(10, dtype=dtype)
-    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
-    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
-    if order == 'low':
-        assert np.all(np.diff(spvals).real >= 0)
-    else:
-        assert np.all(np.diff(spvals).real <= 0)
-    is_eigen_set(H, spvals, spvecs)
-    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-@pytest.mark.parametrize("rand", [
-    pytest.param(qutip.rand_herm, id="hermitian"),
-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-])
-@pytest.mark.parametrize("order", ['low', 'high'])
-@pytest.mark.parametrize("N", [1, 5, 8, 9])
-def test_FewState(rand, sparse, dtype, order, N):
-    H = rand(10, dtype=dtype)
-    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
-    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
-    assert np.allclose(all_spvals[:N], spvals)
-    is_eigen_set(H, spvals, spvecs)
-    if order == 'low':
-        assert np.all(np.diff(spvals).real >= 0)
-    else:
-        assert np.all(np.diff(spvals).real <= 0)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-@pytest.mark.parametrize(["rand"], [
-    pytest.param(qutip.rand_herm, id="hermitian"),
-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-])
-@pytest.mark.parametrize("order", ['low', 'high'])
-@pytest.mark.parametrize("N", [1, 5, 8, 9])
-def test_ValsOnly(rand, sparse, dtype, order, N):
-    H = rand(10, dtype=dtype)
-    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
-    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
-    assert np.allclose(all_spvals[:N], spvals)
-    if order == 'low':
-        assert np.all(np.diff(spvals).real >= 0)
-    else:
-        assert np.all(np.diff(spvals).real <= 0)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-def test_eigen_small(sparse, dtype):
-    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
-    all_spvals = H.eigenenergies(sparse=sparse)
-    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
-    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
-    is_eigen_set(H, spvals, spvecs)
-
-
-def test_BigDenseValsOnly():
-    """
-    This checks eigenvalue calculation for large dense matrices, which
-    historically have had instabilities with certain OS and BLAS combinations
-    (see e.g. #1288 and #1495).
-    """
-    dimension = 2000
-    # Allow an average absolute tolerance for each eigenvalue; we expect
-    # uncertainty in the sum to add in quadrature.
-    tol = 1e-12 * np.sqrt(dimension)
-    H = qutip.rand_herm(dimension, density=1e-2)
-    spvals = H.eigenenergies()
-    assert abs(H.tr() - spvals.sum()) < tol
+import scipy
+import numpy as np
+import pytest
+import qutip
+
+
+def is_eigen_set(oper, vals, vecs):
+    for val, vec in zip(vals, vecs):
+        assert abs(vec.norm() - 1) < 1e-13
+        assert abs(qutip.expect(oper, vec) - val) < 1e-13
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+def test_eigen_known_oper(sparse, dtype):
+    N = qutip.num(10, dtype=dtype)
+    spvals, spvecs = N.eigenstates(sparse=sparse)
+    expected = np.arange(10)
+    is_eigen_set(N, spvals, spvecs)
+    np.testing.assert_allclose(spvals, expected, atol=1e-13)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+@pytest.mark.parametrize(["rand"], [
+    pytest.param(qutip.rand_herm, id="hermitian"),
+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+])
+@pytest.mark.parametrize("order", ['low', 'high'])
+def test_eigen_rand_oper(rand, sparse, dtype, order):
+    H = rand(10, dtype=dtype)
+    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
+    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
+    if order == 'low':
+        assert np.all(np.diff(spvals).real >= 0)
+    else:
+        assert np.all(np.diff(spvals).real <= 0)
+    is_eigen_set(H, spvals, spvecs)
+    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+@pytest.mark.parametrize("rand", [
+    pytest.param(qutip.rand_herm, id="hermitian"),
+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+])
+@pytest.mark.parametrize("order", ['low', 'high'])
+@pytest.mark.parametrize("N", [1, 5, 8, 9])
+def test_FewState(rand, sparse, dtype, order, N):
+    H = rand(10, dtype=dtype)
+    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
+    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
+    assert np.allclose(all_spvals[:N], spvals)
+    is_eigen_set(H, spvals, spvecs)
+    if order == 'low':
+        assert np.all(np.diff(spvals).real >= 0)
+    else:
+        assert np.all(np.diff(spvals).real <= 0)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+@pytest.mark.parametrize(["rand"], [
+    pytest.param(qutip.rand_herm, id="hermitian"),
+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+])
+@pytest.mark.parametrize("order", ['low', 'high'])
+@pytest.mark.parametrize("N", [1, 5, 8, 9])
+def test_ValsOnly(rand, sparse, dtype, order, N):
+    H = rand(10, dtype=dtype)
+    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
+    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
+    assert np.allclose(all_spvals[:N], spvals)
+    if order == 'low':
+        assert np.all(np.diff(spvals).real >= 0)
+    else:
+        assert np.all(np.diff(spvals).real <= 0)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+def test_eigen_small(sparse, dtype):
+    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
+    all_spvals = H.eigenenergies(sparse=sparse)
+    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
+    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
+    is_eigen_set(H, spvals, spvecs)
+
+
+def test_BigDenseValsOnly():
+    """
+    This checks eigenvalue calculation for large dense matrices, which
+    historically have had instabilities with certain OS and BLAS combinations
+    (see e.g. #1288 and #1495).
+    """
+    dimension = 2000
+    # Allow an average absolute tolerance for each eigenvalue; we expect
+    # uncertainty in the sum to add in quadrature.
+    tol = 1e-12 * np.sqrt(dimension)
+    H = qutip.rand_herm(dimension, density=1e-2)
+    spvals = H.eigenenergies()
+    assert abs(H.tr() - spvals.sum()) < tol
diff --git a/qutip/tests/core/test_eigenstates.py b/qutip/tests/core/test_eigenstates.py
index e03add4be1..bbd00c2281 100644
--- a/qutip/tests/core/test_eigenstates.py
+++ b/qutip/tests/core/test_eigenstates.py
@@ -1,98 +1,98 @@
-import pytest
-import numpy as np
-import qutip
-from itertools import combinations
-
-
-def _canonicalise_eigenvector(vec):
-    """
-    Normalise an eigenvector so that the first non-zero value is equal to one,
-    and the array is flattened.  Just normalising based on vector magnitude
-    isn't enough to fully fix the gauge because the vectors could still be
-    multiplied by a unit complex number.
-    """
-    vec = vec.flatten()
-    nonzero = vec != 0
-    if not np.any(nonzero):
-        return vec
-    return vec / vec[np.argmax(nonzero)]
-
-
-# Random diagonal Hamiltonian.
-_diagonal_dimension = 10
-_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
-_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
-                                  for n in range(_diagonal_dimension)])
-_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
-
-# Arbitrary known non-diagonal complex Hamiltonian.
-_nondiagonal_hamiltonian = qutip.Qobj(np.array([
-    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
-    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
-    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
-_nondiagonal_eigenvalues = np.array([
-    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
-_nondiagonal_eigenstates = np.array([
-    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
-     0.009793118179759598+0.3029065489313791j],
-    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
-     -0.3741560255426259+0.6067259021655438j],
-    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
-     -0.5593181579625106+0.2953063897306936j]])
-
-
-@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
-    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
-    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
-                 _diagonal_eigenstates,
-                 id="diagonal-"+str(_diagonal_dimension)),
-    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
-    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
-                 _nondiagonal_eigenstates, id="non-diagonal"),
-])
-def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
-    test_values, test_states = hamiltonian.eigenstates()
-    eigenvalues = np.array(eigenvalues)
-    eigenstates = np.array(eigenstates)
-    test_order = np.argsort(test_values)
-    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
-                    for i in test_order]
-    expected_order = np.argsort(eigenvalues)
-    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
-                        for i in expected_order]
-    np.testing.assert_allclose(test_values[test_order],
-                               eigenvalues[expected_order],
-                               atol=1e-10)
-    for test, expected in zip(test_vectors, expected_vectors):
-        np.testing.assert_allclose(test, expected, atol=1e-10)
-
-
-# Specify parametrisation over a random Hamiltonian by specifying the
-# dimensions, rather than duplicating that logic.
-@pytest.fixture(params=[
-    pytest.param([10], id="simple"),
-    pytest.param([5, 3, 4], id="tensor"),
-    pytest.param([3, 3, 3], id="degenerate")])
-def random_hamiltonian(request):
-    dimensions = request.param
-    eigen = None
-    dist = "fill"
-    if dimensions == [3, 3, 3]:
-        eigen = [0, 1, 1] * 9
-        dist = "eigen"
-    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
-
-
-@pytest.mark.parametrize('sparse', [True, False])
-@pytest.mark.parametrize('dtype', ['csr', 'dense'])
-def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
-    random_hamiltonian = random_hamiltonian.to(dtype)
-    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
-    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
-        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
-                                   (eigenvalue * eigenstate).full(),
-                                   atol=1e-10)
-        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
-    errors = [evec1.overlap(evec2)
-              for evec1, evec2 in combinations(eigenstates, 2)]
-    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
+import pytest
+import numpy as np
+import qutip
+from itertools import combinations
+
+
+def _canonicalise_eigenvector(vec):
+    """
+    Normalise an eigenvector so that the first non-zero value is equal to one,
+    and the array is flattened.  Just normalising based on vector magnitude
+    isn't enough to fully fix the gauge because the vectors could still be
+    multiplied by a unit complex number.
+    """
+    vec = vec.flatten()
+    nonzero = vec != 0
+    if not np.any(nonzero):
+        return vec
+    return vec / vec[np.argmax(nonzero)]
+
+
+# Random diagonal Hamiltonian.
+_diagonal_dimension = 10
+_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
+_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
+                                  for n in range(_diagonal_dimension)])
+_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
+
+# Arbitrary known non-diagonal complex Hamiltonian.
+_nondiagonal_hamiltonian = qutip.Qobj(np.array([
+    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
+    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
+    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
+_nondiagonal_eigenvalues = np.array([
+    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
+_nondiagonal_eigenstates = np.array([
+    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
+     0.009793118179759598+0.3029065489313791j],
+    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
+     -0.3741560255426259+0.6067259021655438j],
+    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
+     -0.5593181579625106+0.2953063897306936j]])
+
+
+@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
+    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
+    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
+                 _diagonal_eigenstates,
+                 id="diagonal-"+str(_diagonal_dimension)),
+    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
+    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
+                 _nondiagonal_eigenstates, id="non-diagonal"),
+])
+def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
+    test_values, test_states = hamiltonian.eigenstates()
+    eigenvalues = np.array(eigenvalues)
+    eigenstates = np.array(eigenstates)
+    test_order = np.argsort(test_values)
+    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
+                    for i in test_order]
+    expected_order = np.argsort(eigenvalues)
+    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
+                        for i in expected_order]
+    np.testing.assert_allclose(test_values[test_order],
+                               eigenvalues[expected_order],
+                               atol=1e-10)
+    for test, expected in zip(test_vectors, expected_vectors):
+        np.testing.assert_allclose(test, expected, atol=1e-10)
+
+
+# Specify parametrisation over a random Hamiltonian by specifying the
+# dimensions, rather than duplicating that logic.
+@pytest.fixture(params=[
+    pytest.param([10], id="simple"),
+    pytest.param([5, 3, 4], id="tensor"),
+    pytest.param([3, 3, 3], id="degenerate")])
+def random_hamiltonian(request):
+    dimensions = request.param
+    eigen = None
+    dist = "fill"
+    if dimensions == [3, 3, 3]:
+        eigen = [0, 1, 1] * 9
+        dist = "eigen"
+    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
+
+
+@pytest.mark.parametrize('sparse', [True, False])
+@pytest.mark.parametrize('dtype', ['csr', 'dense'])
+def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
+    random_hamiltonian = random_hamiltonian.to(dtype)
+    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
+    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
+        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
+                                   (eigenvalue * eigenstate).full(),
+                                   atol=1e-10)
+        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
+    errors = [evec1.overlap(evec2)
+              for evec1, evec2 in combinations(eigenstates, 2)]
+    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
diff --git a/qutip/tests/core/test_expect.py b/qutip/tests/core/test_expect.py
index 906880ceca..96e7ff0fbd 100644
--- a/qutip/tests/core/test_expect.py
+++ b/qutip/tests/core/test_expect.py
@@ -1,179 +1,179 @@
-import pytest
-import collections
-import functools
-import numpy as np
-import qutip
-from qutip.core.data import CSR, Dense
-import qutip.core.data as _data
-
-# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
-# of different systems, without having to repeatedly specify the systems over
-# and over again.  We first store a small number of test cases for known
-# expectation value in the most bundled-up form, because it's easier to unroll
-# these by applying the expected broadcasting rules explicitly ourselves than
-# performing the inverse operation.
-#
-# We store a single test case in a record type, just to keep things neatly
-# together while we're munging them, so it's clear at all times what
-# constitutes a valid test case.
-
-_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
-
-
-def _case_to_dm(case):
-    return case._replace(state=[x.proj() for x in case.state])
-
-
-def _unwrap(list_):
-    """Unwrap lists until we reach the first non-list element."""
-    out = list_
-    while isinstance(out, list):
-        out = out[0]
-    return out
-
-
-def _case_id(case):
-    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
-    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
-    return op_part + "-" + state_part
-
-
-# This is the minimal set of test cases, with a Fock system and a qubit system
-# both in ket form and dm form.  The reference expectations are a 2D array
-# which would be found by broadcasting `operator` against `state` and applying
-# `qutip.expect` to the pairs.
-_dim = 5
-_num, _a = qutip.num(_dim), qutip.destroy(_dim)
-_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
-_known_fock = _Case([_num, _a],
-                    [qutip.fock(_dim, n) for n in range(_dim)],
-                    np.array([np.arange(_dim), np.zeros(_dim)]))
-_known_qubit = _Case([_sx, _sz, _sp],
-                     [qutip.basis(2, 0), qutip.basis(2, 1)],
-                     np.array([[0, 0], [1, -1], [0, 0]]))
-_known_cases = [_known_fock, _case_to_dm(_known_fock),
-                _known_qubit, _case_to_dm(_known_qubit)]
-
-
-class TestKnownExpectation:
-    def pytest_generate_tests(self, metafunc):
-        """
-        Perform the parametrisation over the test cases, performing the
-        explicit broadcasting into separate test cases when required.
-
-        We detect whether to perform explicit broadcasting over one of the
-        arguments of the `_Case` by looking for a singular/plural name of the
-        parameter in the test.  If the parameter is singular, then we manually
-        perform the broadcasting rule for that fixture, and parametrise over
-        the resulting list, taking care to pick out the correct parts of the
-        reference array.
-        """
-        cases = _known_cases
-        op_name, state_name = 'operator', 'state'
-        if op_name not in metafunc.fixturenames:
-            op_name += 's'
-        else:
-            cases = [_Case(op, case.state, expected)
-                     for case in cases
-                     for op, expected in zip(case.operator, case.expected)]
-        if state_name not in metafunc.fixturenames:
-            state_name += 's'
-        else:
-            cases = [_Case(case.operator, state, expected)
-                     for case in cases
-                     for state, expected in zip(case.state, case.expected.T)]
-        metafunc.parametrize([op_name, state_name, 'expected'], cases,
-                             ids=[_case_id(case) for case in cases])
-
-    def test_operator_by_basis(self, operator, state, expected):
-        result = qutip.expect(operator, state)
-        assert result == expected
-        assert isinstance(result, float if operator.isherm else complex)
-
-    def test_broadcast_operator_list(self, operators, state, expected):
-        result = qutip.expect(operators, state)
-        expected_dtype = (np.float64 if all(op.isherm for op in operators)
-                          else np.complex128)
-        assert isinstance(result, np.ndarray)
-        assert result.dtype == expected_dtype
-        assert list(result) == list(expected)
-
-    def test_broadcast_state_list(self, operator, states, expected):
-        result = qutip.expect(operator, states)
-        expected_dtype = np.float64 if operator.isherm else np.complex128
-        assert isinstance(result, np.ndarray)
-        assert result.dtype == expected_dtype
-        assert list(result) == list(expected)
-
-    def test_broadcast_both_lists(self, operators, states, expected):
-        result = qutip.expect(operators, states)
-        assert len(result) == len(operators)
-        for part, operator, expected_part in zip(result, operators, expected):
-            expected_dtype = np.float64 if operator.isherm else np.complex128
-            assert isinstance(part, np.ndarray)
-            assert part.dtype == expected_dtype
-            assert list(part) == list(expected_part)
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
-@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
-@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
-def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
-    dimension = 20
-    state = qutip.rand_ket(dimension, 0.3).to(op_type)
-    op = qutip.rand_herm(dimension, 0.2).to(state_type)
-    if not hermitian:
-        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
-    expected = state.dag() * op * state
-    assert abs(qutip.expect(op, state) - expected) < 1e-14
-
-
-@pytest.mark.parametrize("solve", [
-    pytest.param(qutip.sesolve, id="sesolve"),
-    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
-                 id="mesolve"),
-])
-def test_compatibility_with_solver(solve):
-    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
-    e_ops += [lambda t, psi: np.sin(t)]
-    h = qutip.sigmax()
-    state = qutip.basis(2, 0)
-    times = np.linspace(0, 10, 101)
-    options = {"store_states":True}
-    result = solve(h, state, times, e_ops=e_ops, options=options)
-    direct, states = result.expect, result.states
-    indirect = qutip.expect(e_ops[:-1], states)
-    # check measurement operators based on quantum objects
-    assert len(direct)-1 == len(indirect)
-    for direct_, indirect_ in zip(direct, indirect):
-        assert len(direct_) == len(indirect_)
-        assert isinstance(direct_, np.ndarray)
-        assert isinstance(indirect_, np.ndarray)
-        assert direct_.dtype == indirect_.dtype
-        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
-        # test measurement operators based on lambda functions
-        direct_ = direct[-1]
-        indirect_ = np.sin(times)
-        assert len(direct_) == len(indirect_)
-        assert isinstance(direct_, np.ndarray)
-        assert isinstance(indirect_, np.ndarray)
-        assert direct_.dtype == indirect_.dtype
-        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
-
-
-def test_no_real_attribute(monkeypatch):
-    """This tests ensures that expect still works even if the output of a
-    specialisation does not have the ``real`` attribute. This is the case for
-    the tensorflow and cupy data layers."""
-
-    def mocker_expect_return(oper, state):
-        """
-        We simply return None which does not have the `real` attribute.
-        """
-        return "object without .real"
-
-    monkeypatch.setattr(_data, "expect", mocker_expect_return)
-
-    sz = qutip.sigmaz() # the choice of the matrix does not matter
-    assert "object without .real" == qutip.expect(sz, sz)
+import pytest
+import collections
+import functools
+import numpy as np
+import qutip
+from qutip.core.data import CSR, Dense
+import qutip.core.data as _data
+
+# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
+# of different systems, without having to repeatedly specify the systems over
+# and over again.  We first store a small number of test cases for known
+# expectation value in the most bundled-up form, because it's easier to unroll
+# these by applying the expected broadcasting rules explicitly ourselves than
+# performing the inverse operation.
+#
+# We store a single test case in a record type, just to keep things neatly
+# together while we're munging them, so it's clear at all times what
+# constitutes a valid test case.
+
+_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
+
+
+def _case_to_dm(case):
+    return case._replace(state=[x.proj() for x in case.state])
+
+
+def _unwrap(list_):
+    """Unwrap lists until we reach the first non-list element."""
+    out = list_
+    while isinstance(out, list):
+        out = out[0]
+    return out
+
+
+def _case_id(case):
+    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
+    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
+    return op_part + "-" + state_part
+
+
+# This is the minimal set of test cases, with a Fock system and a qubit system
+# both in ket form and dm form.  The reference expectations are a 2D array
+# which would be found by broadcasting `operator` against `state` and applying
+# `qutip.expect` to the pairs.
+_dim = 5
+_num, _a = qutip.num(_dim), qutip.destroy(_dim)
+_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
+_known_fock = _Case([_num, _a],
+                    [qutip.fock(_dim, n) for n in range(_dim)],
+                    np.array([np.arange(_dim), np.zeros(_dim)]))
+_known_qubit = _Case([_sx, _sz, _sp],
+                     [qutip.basis(2, 0), qutip.basis(2, 1)],
+                     np.array([[0, 0], [1, -1], [0, 0]]))
+_known_cases = [_known_fock, _case_to_dm(_known_fock),
+                _known_qubit, _case_to_dm(_known_qubit)]
+
+
+class TestKnownExpectation:
+    def pytest_generate_tests(self, metafunc):
+        """
+        Perform the parametrisation over the test cases, performing the
+        explicit broadcasting into separate test cases when required.
+
+        We detect whether to perform explicit broadcasting over one of the
+        arguments of the `_Case` by looking for a singular/plural name of the
+        parameter in the test.  If the parameter is singular, then we manually
+        perform the broadcasting rule for that fixture, and parametrise over
+        the resulting list, taking care to pick out the correct parts of the
+        reference array.
+        """
+        cases = _known_cases
+        op_name, state_name = 'operator', 'state'
+        if op_name not in metafunc.fixturenames:
+            op_name += 's'
+        else:
+            cases = [_Case(op, case.state, expected)
+                     for case in cases
+                     for op, expected in zip(case.operator, case.expected)]
+        if state_name not in metafunc.fixturenames:
+            state_name += 's'
+        else:
+            cases = [_Case(case.operator, state, expected)
+                     for case in cases
+                     for state, expected in zip(case.state, case.expected.T)]
+        metafunc.parametrize([op_name, state_name, 'expected'], cases,
+                             ids=[_case_id(case) for case in cases])
+
+    def test_operator_by_basis(self, operator, state, expected):
+        result = qutip.expect(operator, state)
+        assert result == expected
+        assert isinstance(result, float if operator.isherm else complex)
+
+    def test_broadcast_operator_list(self, operators, state, expected):
+        result = qutip.expect(operators, state)
+        expected_dtype = (np.float64 if all(op.isherm for op in operators)
+                          else np.complex128)
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == expected_dtype
+        assert list(result) == list(expected)
+
+    def test_broadcast_state_list(self, operator, states, expected):
+        result = qutip.expect(operator, states)
+        expected_dtype = np.float64 if operator.isherm else np.complex128
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == expected_dtype
+        assert list(result) == list(expected)
+
+    def test_broadcast_both_lists(self, operators, states, expected):
+        result = qutip.expect(operators, states)
+        assert len(result) == len(operators)
+        for part, operator, expected_part in zip(result, operators, expected):
+            expected_dtype = np.float64 if operator.isherm else np.complex128
+            assert isinstance(part, np.ndarray)
+            assert part.dtype == expected_dtype
+            assert list(part) == list(expected_part)
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
+@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
+@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
+def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
+    dimension = 20
+    state = qutip.rand_ket(dimension, 0.3).to(op_type)
+    op = qutip.rand_herm(dimension, 0.2).to(state_type)
+    if not hermitian:
+        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
+    expected = state.dag() * op * state
+    assert abs(qutip.expect(op, state) - expected) < 1e-14
+
+
+@pytest.mark.parametrize("solve", [
+    pytest.param(qutip.sesolve, id="sesolve"),
+    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
+                 id="mesolve"),
+])
+def test_compatibility_with_solver(solve):
+    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
+    e_ops += [lambda t, psi: np.sin(t)]
+    h = qutip.sigmax()
+    state = qutip.basis(2, 0)
+    times = np.linspace(0, 10, 101)
+    options = {"store_states":True}
+    result = solve(h, state, times, e_ops=e_ops, options=options)
+    direct, states = result.expect, result.states
+    indirect = qutip.expect(e_ops[:-1], states)
+    # check measurement operators based on quantum objects
+    assert len(direct)-1 == len(indirect)
+    for direct_, indirect_ in zip(direct, indirect):
+        assert len(direct_) == len(indirect_)
+        assert isinstance(direct_, np.ndarray)
+        assert isinstance(indirect_, np.ndarray)
+        assert direct_.dtype == indirect_.dtype
+        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
+        # test measurement operators based on lambda functions
+        direct_ = direct[-1]
+        indirect_ = np.sin(times)
+        assert len(direct_) == len(indirect_)
+        assert isinstance(direct_, np.ndarray)
+        assert isinstance(indirect_, np.ndarray)
+        assert direct_.dtype == indirect_.dtype
+        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
+
+
+def test_no_real_attribute(monkeypatch):
+    """This tests ensures that expect still works even if the output of a
+    specialisation does not have the ``real`` attribute. This is the case for
+    the tensorflow and cupy data layers."""
+
+    def mocker_expect_return(oper, state):
+        """
+        We simply return None which does not have the `real` attribute.
+        """
+        return "object without .real"
+
+    monkeypatch.setattr(_data, "expect", mocker_expect_return)
+
+    sz = qutip.sigmaz() # the choice of the matrix does not matter
+    assert "object without .real" == qutip.expect(sz, sz)
diff --git a/qutip/tests/core/test_gates.py b/qutip/tests/core/test_gates.py
index 7b3795b50d..92f81c7f5c 100644
--- a/qutip/tests/core/test_gates.py
+++ b/qutip/tests/core/test_gates.py
@@ -1,144 +1,144 @@
-import pytest
-import numpy as np
-import qutip
-from qutip.core import gates
-
-
-def _infidelity(a, b):
-    """Infidelity between two kets."""
-    return 1 - abs(a.overlap(b))
-
-
-def _remove_global_phase(qobj):
-    """
-    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
-    we set the first non-zero element to be purely real-positive.
-    """
-    flat = qobj.tidyup(1e-14).full().flat.copy()
-    for phase in flat:
-        if phase != 0:
-            # Fix the gauge for any global phase.
-            flat = flat * np.exp(-1j * np.angle(phase))
-            break
-    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
-
-
-def _make_random_three_qubit_gate():
-    """Create a random three-qubit gate."""
-    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
-
-    def gate(N=None, controls=None, target=None):
-        if N is None:
-            return operation
-        return gates.gate_expand_3toN(operation, N, controls, target)
-    return gate
-
-
-def _make_controled(op):
-    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
-    out += qutip.tensor(qutip.fock_dm(2, 1), op)
-    return out
-
-
-class TestExplicitForm:
-    def test_swap(self):
-        states = [qutip.rand_ket(2) for _ in [None]*2]
-        start = qutip.tensor(states)
-        swapped = qutip.tensor(states[::-1])
-        swap = gates.swap()
-        assert _infidelity(swapped, swap*start) < 1e-12
-        assert _infidelity(start, swap*swap*start) < 1e-12
-
-    @pytest.mark.parametrize(["gate", "cgate", "args"], [
-        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
-        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
-        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
-        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
-        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
-        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
-        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
-        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
-        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
-    ])
-    def test_controled(self, gate, cgate, args):
-        expected = _make_controled(gate(*args))
-        assert cgate(*args) == expected
-
-    @pytest.mark.parametrize(["gate", "power", "expected"], [
-        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
-        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
-        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
-        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
-                     id="berkeley"),
-        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
-        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
-        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
-    ])
-    def gate_power_relation(self, gate, expected, power):
-        assert gate()**power == expected()
-
-    @pytest.mark.parametrize(['angle', 'expected'], [
-        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
-                     id="pi"),
-        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
-    ])
-    def test_molmer_sorensen(self, angle, expected):
-        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
-                                   expected.full(), atol=1e-15)
-
-    @pytest.mark.parametrize(["gate", "n_angles"], [
-        pytest.param(gates.rx, 1, id="Rx"),
-        pytest.param(gates.ry, 1, id="Ry"),
-        pytest.param(gates.rz, 1, id="Rz"),
-        pytest.param(gates.phasegate, 1, id="phase"),
-        pytest.param(gates.qrot, 2, id="Rabi rotation"),
-    ])
-    def test_zero_rotations_are_identity(self, gate, n_angles):
-        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
-                                   atol=1e-15)
-
-    def test_hadamard(self):
-        N = 3
-        expected = qutip.tensor([gates.snot()] * N)
-        assert gates.hadamard_transform(N) == expected
-
-    def test_globalphase(self):
-        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
-
-
-class TestCliffordGroup:
-    """
-    Test a sufficient set of conditions to prove that we have a full Clifford
-    group for a single qubit.
-    """
-    clifford = gates.qubit_clifford_group()
-    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-
-    def test_single_qubit_group_dimension_is_24(self):
-        assert len(self.clifford) == 24
-
-    def test_all_elements_different(self):
-        clifford = [_remove_global_phase(gate) for gate in self.clifford]
-        for i, gate in enumerate(clifford):
-            for other in clifford[i+1:]:
-                # Big tolerance because we actually want to test the inverse.
-                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
-
-    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
-    def test_gate_normalises_pauli_group(self, gate):
-        """
-        Test the fundamental definition of the Clifford group, i.e. that it
-        normalises the Pauli group.
-        """
-        # Assert that each Clifford gate maps the set of Pauli gates back onto
-        # itself (though not necessarily in order).  This condition is no
-        # stronger than simply considering each (gate, Pauli) pair separately.
-        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
-        normalised = [_remove_global_phase(gate * pauli * gate.dag())
-                      for pauli in self.pauli]
-        for gate in normalised:
-            for i, pauli in enumerate(pauli_gates):
-                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
-                    del pauli_gates[i]
-                    break
-        assert len(pauli_gates) == 0
+import pytest
+import numpy as np
+import qutip
+from qutip.core import gates
+
+
+def _infidelity(a, b):
+    """Infidelity between two kets."""
+    return 1 - abs(a.overlap(b))
+
+
+def _remove_global_phase(qobj):
+    """
+    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
+    we set the first non-zero element to be purely real-positive.
+    """
+    flat = qobj.tidyup(1e-14).full().flat.copy()
+    for phase in flat:
+        if phase != 0:
+            # Fix the gauge for any global phase.
+            flat = flat * np.exp(-1j * np.angle(phase))
+            break
+    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
+
+
+def _make_random_three_qubit_gate():
+    """Create a random three-qubit gate."""
+    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
+
+    def gate(N=None, controls=None, target=None):
+        if N is None:
+            return operation
+        return gates.gate_expand_3toN(operation, N, controls, target)
+    return gate
+
+
+def _make_controled(op):
+    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
+    out += qutip.tensor(qutip.fock_dm(2, 1), op)
+    return out
+
+
+class TestExplicitForm:
+    def test_swap(self):
+        states = [qutip.rand_ket(2) for _ in [None]*2]
+        start = qutip.tensor(states)
+        swapped = qutip.tensor(states[::-1])
+        swap = gates.swap()
+        assert _infidelity(swapped, swap*start) < 1e-12
+        assert _infidelity(start, swap*swap*start) < 1e-12
+
+    @pytest.mark.parametrize(["gate", "cgate", "args"], [
+        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
+        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
+        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
+        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
+        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
+        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
+        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
+        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
+        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
+    ])
+    def test_controled(self, gate, cgate, args):
+        expected = _make_controled(gate(*args))
+        assert cgate(*args) == expected
+
+    @pytest.mark.parametrize(["gate", "power", "expected"], [
+        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
+        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
+        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
+        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
+                     id="berkeley"),
+        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
+        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
+        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
+    ])
+    def gate_power_relation(self, gate, expected, power):
+        assert gate()**power == expected()
+
+    @pytest.mark.parametrize(['angle', 'expected'], [
+        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
+                     id="pi"),
+        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
+    ])
+    def test_molmer_sorensen(self, angle, expected):
+        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
+                                   expected.full(), atol=1e-15)
+
+    @pytest.mark.parametrize(["gate", "n_angles"], [
+        pytest.param(gates.rx, 1, id="Rx"),
+        pytest.param(gates.ry, 1, id="Ry"),
+        pytest.param(gates.rz, 1, id="Rz"),
+        pytest.param(gates.phasegate, 1, id="phase"),
+        pytest.param(gates.qrot, 2, id="Rabi rotation"),
+    ])
+    def test_zero_rotations_are_identity(self, gate, n_angles):
+        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
+                                   atol=1e-15)
+
+    def test_hadamard(self):
+        N = 3
+        expected = qutip.tensor([gates.snot()] * N)
+        assert gates.hadamard_transform(N) == expected
+
+    def test_globalphase(self):
+        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
+
+
+class TestCliffordGroup:
+    """
+    Test a sufficient set of conditions to prove that we have a full Clifford
+    group for a single qubit.
+    """
+    clifford = gates.qubit_clifford_group()
+    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+
+    def test_single_qubit_group_dimension_is_24(self):
+        assert len(self.clifford) == 24
+
+    def test_all_elements_different(self):
+        clifford = [_remove_global_phase(gate) for gate in self.clifford]
+        for i, gate in enumerate(clifford):
+            for other in clifford[i+1:]:
+                # Big tolerance because we actually want to test the inverse.
+                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
+
+    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
+    def test_gate_normalises_pauli_group(self, gate):
+        """
+        Test the fundamental definition of the Clifford group, i.e. that it
+        normalises the Pauli group.
+        """
+        # Assert that each Clifford gate maps the set of Pauli gates back onto
+        # itself (though not necessarily in order).  This condition is no
+        # stronger than simply considering each (gate, Pauli) pair separately.
+        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
+        normalised = [_remove_global_phase(gate * pauli * gate.dag())
+                      for pauli in self.pauli]
+        for gate in normalised:
+            for i, pauli in enumerate(pauli_gates):
+                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
+                    del pauli_gates[i]
+                    break
+        assert len(pauli_gates) == 0
diff --git a/qutip/tests/core/test_metrics.py b/qutip/tests/core/test_metrics.py
index e52a074b32..945c1cfb66 100644
--- a/qutip/tests/core/test_metrics.py
+++ b/qutip/tests/core/test_metrics.py
@@ -1,551 +1,551 @@
-# -*- coding: utf-8 -*-
-
-import platform
-
-import numpy as np
-import pytest
-
-from qutip import (
-    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
-    qeye, rand_ket, rand_super_bcsz, rand_dm,
-    rand_unitary, to_super, to_choi, kraus_to_choi,
-    to_chi, to_kraus,
-)
-from qutip.core.gates import snot, swap
-
-try:
-    import cvxpy
-    import cvxopt
-except ImportError:
-    cvxpy, cvxopt = None, None
-
-# These ones are the metrics functions that we actually want to test.
-from qutip import (
-    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
-    unitarity, hilbert_dist, bures_dist, process_fidelity,
-)
-from qutip.core.metrics import _hilbert_space_dims
-
-
-@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
-def dimension(request):
-    # There are also some cases in the file where this fixture is explicitly
-    # overridden by a more local mark.  That is deliberate; this dimension is
-    # intended for non-superoperators, and may cause inordinantly long tests if
-    # (for example) something uses dimension=100 then makes a superoperator out
-    # of it.
-    return request.param
-
-
-@pytest.fixture(scope="function", params=[
-    pytest.param(rand_ket, id="pure"),
-    pytest.param(rand_dm, id="mixed"),
-])
-def state(request, dimension):
-    return request.param(dimension)
-
-
-# Also parametrise left, right as if they're the names of two states for tests
-# that need to take two states.
-left = right = state
-
-
-# The class names have an unusual naming convention to make them more
-# convenient to use with the `pytest -k "expr"` selection syntax.  They start
-# with the standard `Test`, but then are the name of the function they are
-# testing in the function naming convention, so it's easy to remember the
-# selector to choose a particular function.
-
-class Test_fidelity:
-    def test_mixed_state_inequality(self, dimension):
-        tol = 1e-7
-        rho1 = rand_dm(dimension, density=0.25)
-        rho2 = rand_dm(dimension, density=0.25)
-        F = fidelity(rho1, rho2)
-        assert 1 - F <= np.sqrt(1 - F*F) + tol
-
-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-    def test_orthogonal(self, left_dm, right_dm, dimension):
-        left = basis(dimension, 0)
-        right = basis(dimension, dimension//2)
-        if left_dm:
-            left = left.proj()
-        if right_dm:
-            right = right.proj()
-        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
-
-    def test_invariant_under_unitary_transformation(self, dimension):
-        rho1 = rand_dm(dimension, density=0.25)
-        rho2 = rand_dm(dimension, density=0.25)
-        U = rand_unitary(dimension)
-        F = fidelity(rho1, rho2)
-        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
-        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
-
-    def test_state_with_itself(self, state):
-        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
-
-    def test_bounded(self, left, right, dimension):
-        """Test that fidelity is bounded on [0, 1]."""
-        tol = 1e-7
-        assert -tol <= fidelity(left, right) <= 1 + tol
-
-    def test_pure_state_equivalent_to_overlap(self, dimension):
-        """Check fidelity against pure-state overlap, see gh-361."""
-        psi = rand_ket(dimension)
-        phi = rand_ket(dimension)
-        overlap = np.abs(psi.overlap(phi))
-        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
-
-    ket_0 = basis(2, 0)
-    ket_1 = basis(2, 1)
-    ket_p = (ket_0 + ket_1).unit()
-    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
-    max_mixed = qeye(2).unit()
-
-    @pytest.mark.parametrize(['left', 'right', 'expected'], [
-        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
-        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
-        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
-        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
-                     id="|+>,|+'>"),
-    ])
-    def test_known_cases(self, left, right, expected):
-        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
-
-
-class Test_tracedist:
-    def test_state_with_itself(self, state):
-        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
-
-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-    def test_orthogonal(self, left_dm, right_dm, dimension):
-        left = basis(dimension, 0)
-        right = basis(dimension, dimension//2)
-        if left_dm:
-            left = left.proj()
-        if right_dm:
-            right = right.proj()
-        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
-
-    def test_invariant_under_unitary_transformation(self, dimension):
-        rho1 = rand_dm(dimension, density=0.25)
-        rho2 = rand_dm(dimension, density=0.25)
-        U = rand_unitary(dimension)
-        D = tracedist(rho1, rho2)
-        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
-        assert D == pytest.approx(DU, rel=1e-5)
-
-
-class Test_hellinger_dist:
-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-    def test_orthogonal(self, left_dm, right_dm, dimension):
-        left = basis(dimension, 0)
-        right = basis(dimension, dimension//2)
-        if left_dm:
-            left = left.proj()
-        if right_dm:
-            right = right.proj()
-        expected = np.sqrt(2)
-        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
-
-    def test_state_with_itself(self, state):
-        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
-
-    def test_known_cases_pure_states(self, dimension):
-        left = rand_ket(dimension)
-        right = rand_ket(dimension)
-        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
-        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
-
-    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
-    def test_monotonicity(self, dimension):
-        """
-        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
-        arXiv:1611.03449v2:
-            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
-            >= hellinger_dist(rhoA, sigmaA)
-        with equality iff sigmaB = rhoB where '&' is the tensor product.
-        """
-        tol = 1e-5
-        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
-        rho = tensor(rhoA, rhoB)
-        rho_sim = tensor(rhoA, sigmaB)
-        sigma = tensor(sigmaA, sigmaB)
-        dist = hellinger_dist(rhoA, sigmaA)
-        assert hellinger_dist(rho, sigma) + tol > dist
-        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
-
-
-class Test_average_gate_fidelity:
-    def test_identity(self, dimension):
-        id = qeye(dimension)
-        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
-
-    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
-    def test_bounded(self, dimension):
-        tol = 1e-7
-        channel = rand_super_bcsz(dimension)
-        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
-
-    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
-    def test_unitaries_equal_1(self, dimension):
-        """Tests that for random unitaries U, AGF(U, U) = 1."""
-        tol = 1e-7
-        U = rand_unitary(dimension)
-        SU = to_super(U)
-        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
-
-    def test_average_gate_fidelity_against_legacy_implementation(self):
-        """
-        Metrics: Test that AGF coincides with pre-5.0 implementation
-        """
-        def agf_pre_50(oper, target=None):
-            kraus = to_kraus(oper)
-            d = kraus[0].shape[0]
-
-            if kraus[0].shape[1] != d:
-                return TypeError(
-                    "Average gate fidelity only implemented for square "
-                    "superoperators.")
-
-            if target is None:
-                return (
-                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
-                    (d * d + d)
-                )
-            return (
-                (d + np.sum([
-                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
-                ])) / (d * d + d)
-            )
-
-        oper = rand_super_bcsz(16)
-        target = rand_unitary(16)
-        np.testing.assert_almost_equal(
-            average_gate_fidelity(oper, target),
-            agf_pre_50(oper, target)
-        )
-
-
-class Test_hilbert_dist:
-    def test_known_cases(self):
-        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
-        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
-        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
-
-
-paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
-
-
-class Test_unitarity:
-    @pytest.mark.parametrize(['operator', 'expected'], [
-        pytest.param(to_super(sigmax()), 1, id="sigmax"),
-        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
-        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
-                     id="id+sigmax"),
-    ])
-    def test_known_cases(self, operator, expected):
-        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
-
-    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
-    def test_bounded(self, n_qubits):
-        tol = 1e-7
-        operator = rand_super_bcsz(2**n_qubits)
-        assert -tol <= unitarity(operator) <= 1 + tol
-
-
-class TestComparisons:
-    """Test some known inequalities between two different metrics."""
-
-    def test_inequality_tracedist_to_fidelity(self, left, right):
-        tol = 1e-7
-        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
-
-    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
-        tol = 1e-7
-        hellinger = hellinger_dist(left, right)
-        bures = bures_dist(left, right)
-        assert bures <= hellinger + tol
-
-
-def overrotation(x):
-    return to_super((1j * np.pi * x * sigmax() / 2).expm())
-
-
-def had_mixture(x):
-    id_chan = to_choi(qeye(2))
-    S_eye = to_super(id_chan)
-    S_H = to_super(snot())
-    return (1 - x) * S_eye + x * S_H
-
-
-def swap_map(x):
-    base = (1j * x * swap()).expm()
-    dims = [[[2], [2]], [[2], [2]]]
-    return Qobj(base, dims=dims, type='super', superrep='super')
-
-
-def adc_choi(x):
-    kraus = [
-        np.sqrt(1 - x) * qeye(2),
-        np.sqrt(x) * destroy(2),
-        np.sqrt(x) * fock_dm(2, 0),
-    ]
-    return kraus_to_choi(kraus)
-
-
-# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
-# to solve the problem, and this can cause an entire test-suite failure.  As
-# long as we are using random tests (perhaps not ideal), this will happen
-# occasionally.  This isn't entirely a bug, it's just a reality of using a
-# one-size-fits-all solver; we've historically assumed users who come up
-# against this sort of thing will be accepting of the fact that dnorm
-# calculation is nontrivial, and isn't always entirely feasible.
-#
-# To deal with it, we allow each test to be rerun twice, using
-# pytest-rerunfailures.  This should forbid pathological cases where the test
-# is failing every time, but not penalise one-off failures.  As far as we know,
-# the failing tests always involve a random step, so triggering a re-run will
-# have them choose new variables as well.
-#
-# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
-# which is deprecated as of numpy 1.20.
-#
-# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
-# depends on them.
-@pytest.mark.skipif(cvxpy is None or cvxopt is None,
-                    reason="Skipping dnorm tests because dnorm requires cvxpy"
-                    " and cvxopt which are not installed.")
-@pytest.mark.skipif("Windows" in platform.system(),
-                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
-                    " installed on Windows but fail to correctly solve"
-                    " the given optimization problems.")
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.filterwarnings(
-    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
-)
-class Test_dnorm:
-    @pytest.fixture(params=[2, 3])
-    def dimension(self, request):
-        return request.param
-
-    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
-    def sparse(self, request):
-        return request.param
-
-    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
-    def test_sparse_against_dense_adc(self, variable):
-        """
-        Test sparse versus dense dnorm calculation for a sample of
-        amplitude-damping channels.
-        """
-        # Choi matrix for identity channel on 1 qubit
-        A = kraus_to_choi([qeye(2)])
-        B = adc_choi(variable)
-        dense = dnorm(A, B, force_solve=True, sparse=False)
-        sparse = dnorm(A, B, force_solve=True, sparse=True)
-        assert dense == pytest.approx(sparse, abs=1e-7)
-
-    @pytest.mark.repeat(3)
-    def test_sparse_against_dense_random(self, dimension):
-        """
-        Test sparse versus dense dnorm calculation for random superoperators.
-        """
-        A = rand_super_bcsz(dimension)
-        dense_run_result = dnorm(A, force_solve=True, sparse=False)
-        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
-        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
-
-    def test_bounded(self, dimension, sparse):
-        """dnorm(A - B) in [0, 2] for random superops A, B."""
-        tol = 1e-7
-        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
-        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
-
-    def test_qubit_simple_known_cases(self, sparse):
-        """Check agreement for known qubit channels."""
-        id_chan = to_choi(qeye(2))
-        X_chan = to_choi(sigmax())
-        depol = to_choi(Qobj(
-            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
-        ))
-        # We need to restrict the number of iterations for things on the
-        # boundary, such as perfectly distinguishable channels.
-        assert (
-            dnorm(id_chan, X_chan, sparse=sparse)
-            == pytest.approx(2, abs=1e-7)
-        )
-        assert (
-            dnorm(id_chan, depol, sparse=sparse)
-            == pytest.approx(1.5, abs=1e-7)
-        )
-        # Finally, we add a known case from Johnston's QETLAB documentation,
-        #   || Phi - I ||_♢,
-        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
-        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
-        assert (
-            dnorm(U, qeye(2), sparse=sparse)
-            == pytest.approx(np.sqrt(2), abs=1e-7)
-        )
-
-    @pytest.mark.parametrize(["variable", "expected", "generator"], [
-        [1.0e-3, 3.141591e-03, overrotation],
-        [3.1e-3, 9.738899e-03, overrotation],
-        [1.0e-2, 3.141463e-02, overrotation],
-        [3.1e-2, 9.735089e-02, overrotation],
-        [1.0e-1, 3.128689e-01, overrotation],
-        [3.1e-1, 9.358596e-01, overrotation],
-        [1.0e-3, 2.000000e-03, had_mixture],
-        [3.1e-3, 6.200000e-03, had_mixture],
-        [1.0e-2, 2.000000e-02, had_mixture],
-        [3.1e-2, 6.200000e-02, had_mixture],
-        [1.0e-1, 2.000000e-01, had_mixture],
-        [3.1e-1, 6.200000e-01, had_mixture],
-        [1.0e-3, 2.000000e-03, swap_map],
-        [3.1e-3, 6.199997e-03, swap_map],
-        [1.0e-2, 1.999992e-02, swap_map],
-        [3.1e-2, 6.199752e-02, swap_map],
-        [1.0e-1, 1.999162e-01, swap_map],
-        [3.1e-1, 6.173918e-01, swap_map],
-    ])
-    def test_qubit_known_cases(self, variable, expected, generator, sparse):
-        """
-        Test cases based on comparisons to pre-existing dnorm implementations.
-        In particular, the targets for the following test cases were generated
-        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
-        """
-        id_chan = to_choi(qeye(2))
-        channel = generator(variable)
-        assert (
-            dnorm(channel, id_chan, sparse=sparse)
-            == pytest.approx(expected, abs=1e-7)
-        )
-
-    def test_qubit_scalar(self, dimension):
-        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
-        a = np.random.random()
-        A = rand_super_bcsz(dimension)
-        B = rand_super_bcsz(dimension)
-        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
-
-    def test_qubit_triangle(self, dimension):
-        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
-        A = rand_super_bcsz(dimension)
-        B = rand_super_bcsz(dimension)
-        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
-
-    @pytest.mark.repeat(3)
-    @pytest.mark.parametrize("generator", [
-        pytest.param(rand_super_bcsz, id="super"),
-        pytest.param(rand_unitary, id="unitary"),
-    ])
-    def test_force_solve(self, dimension, generator):
-        """
-        Metrics: checks that special cases for dnorm agree with SDP solutions.
-        """
-        A, B = generator(dimension), generator(dimension)
-        assert (
-            dnorm(A, B, force_solve=False)
-            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
-        )
-
-    @pytest.mark.repeat(3)
-    def test_cptp(self, dimension, sparse):
-        """Check that the diamond norm is one for CPTP maps."""
-        A = rand_super_bcsz(dimension)
-        assert A.iscptp
-        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
-
-
-@pytest.mark.parametrize('superrep_conversion',
-                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
-def test_process_fidelity_of_identity(superrep_conversion):
-    """
-    Metrics: process fidelity of identity map is 1
-    """
-    num_qubits = 3
-    oper = qeye(num_qubits*[2])
-    f = process_fidelity(superrep_conversion(oper))
-    assert np.isrealobj(f)
-    assert f == pytest.approx(1)
-
-
-@pytest.mark.parametrize('superrep_conversion',
-                         [to_super, to_choi, to_chi, to_kraus])
-def test_process_fidelity_identical_channels(superrep_conversion):
-    """
-    Metrics: process fidelity of a map to itself is 1
-    """
-    num_qubits = 2
-    for k in range(10):
-        oper = rand_super_bcsz(num_qubits*[2])
-        oper = superrep_conversion(oper)
-        f = process_fidelity(oper, oper)
-        assert f == pytest.approx(1)
-
-
-def test_process_fidelity_identical_unitaries():
-    """
-    Metrics: process fidelity of a unitary to itself is 1
-    """
-    num_qubits = 3
-    for k in range(10):
-        oper = rand_unitary(num_qubits * [2])
-        f = process_fidelity(oper, oper)
-        assert f == pytest.approx(1)
-
-
-def test_process_fidelity_consistency():
-    """
-    Metrics: process fidelity independent of how channels are represented
-    """
-    num_qubits = 2
-    for k in range(10):
-        fidelities_u_to_u = []
-        fidelities_u_to_id = []
-        u1 = rand_unitary(num_qubits * [2])
-        u2 = rand_unitary(num_qubits * [2])
-        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
-            fidelities_u_to_id.append(process_fidelity(map1(u1)))
-            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
-                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
-        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
-        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
-
-
-def test_process_fidelity_unitary_invariance():
-    """
-    Metrics: process fidelity, invariance under unitary trans.
-    """
-    for k in range(10):
-        op1 = rand_super_bcsz(10)
-        op2 = rand_super_bcsz(10)
-        u = to_super(rand_unitary(10))
-        assert abs(
-            process_fidelity(op1, op2)
-            - process_fidelity(u*op1, u*op2)
-        ) < 1e-8
-
-
-@pytest.mark.parametrize('superrep_conversion',
-                         [lambda x: x, to_super, to_choi, to_kraus])
-def test_hilbert_space_dims(superrep_conversion):
-    """
-    Metrics: check _hilbert_space_dims
-    """
-    dims = [[2, 3], [4, 5]]
-    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
-    assert _hilbert_space_dims(superrep_conversion(u)) == dims
-
-
-def test_hilbert_space_dims_chi():
-    """
-    Metrics: check _hilbert_space_dims for a chi channel
-    """
-    dims = [[2, 2], [2, 2]]
-    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
-    assert _hilbert_space_dims(to_chi(u)) == dims
+# -*- coding: utf-8 -*-
+
+import platform
+
+import numpy as np
+import pytest
+
+from qutip import (
+    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
+    qeye, rand_ket, rand_super_bcsz, rand_dm,
+    rand_unitary, to_super, to_choi, kraus_to_choi,
+    to_chi, to_kraus,
+)
+from qutip.core.gates import snot, swap
+
+try:
+    import cvxpy
+    import cvxopt
+except ImportError:
+    cvxpy, cvxopt = None, None
+
+# These ones are the metrics functions that we actually want to test.
+from qutip import (
+    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
+    unitarity, hilbert_dist, bures_dist, process_fidelity,
+)
+from qutip.core.metrics import _hilbert_space_dims
+
+
+@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
+def dimension(request):
+    # There are also some cases in the file where this fixture is explicitly
+    # overridden by a more local mark.  That is deliberate; this dimension is
+    # intended for non-superoperators, and may cause inordinantly long tests if
+    # (for example) something uses dimension=100 then makes a superoperator out
+    # of it.
+    return request.param
+
+
+@pytest.fixture(scope="function", params=[
+    pytest.param(rand_ket, id="pure"),
+    pytest.param(rand_dm, id="mixed"),
+])
+def state(request, dimension):
+    return request.param(dimension)
+
+
+# Also parametrise left, right as if they're the names of two states for tests
+# that need to take two states.
+left = right = state
+
+
+# The class names have an unusual naming convention to make them more
+# convenient to use with the `pytest -k "expr"` selection syntax.  They start
+# with the standard `Test`, but then are the name of the function they are
+# testing in the function naming convention, so it's easy to remember the
+# selector to choose a particular function.
+
+class Test_fidelity:
+    def test_mixed_state_inequality(self, dimension):
+        tol = 1e-7
+        rho1 = rand_dm(dimension, density=0.25)
+        rho2 = rand_dm(dimension, density=0.25)
+        F = fidelity(rho1, rho2)
+        assert 1 - F <= np.sqrt(1 - F*F) + tol
+
+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+    def test_orthogonal(self, left_dm, right_dm, dimension):
+        left = basis(dimension, 0)
+        right = basis(dimension, dimension//2)
+        if left_dm:
+            left = left.proj()
+        if right_dm:
+            right = right.proj()
+        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
+
+    def test_invariant_under_unitary_transformation(self, dimension):
+        rho1 = rand_dm(dimension, density=0.25)
+        rho2 = rand_dm(dimension, density=0.25)
+        U = rand_unitary(dimension)
+        F = fidelity(rho1, rho2)
+        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
+        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
+
+    def test_state_with_itself(self, state):
+        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
+
+    def test_bounded(self, left, right, dimension):
+        """Test that fidelity is bounded on [0, 1]."""
+        tol = 1e-7
+        assert -tol <= fidelity(left, right) <= 1 + tol
+
+    def test_pure_state_equivalent_to_overlap(self, dimension):
+        """Check fidelity against pure-state overlap, see gh-361."""
+        psi = rand_ket(dimension)
+        phi = rand_ket(dimension)
+        overlap = np.abs(psi.overlap(phi))
+        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
+
+    ket_0 = basis(2, 0)
+    ket_1 = basis(2, 1)
+    ket_p = (ket_0 + ket_1).unit()
+    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
+    max_mixed = qeye(2).unit()
+
+    @pytest.mark.parametrize(['left', 'right', 'expected'], [
+        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
+        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
+        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
+        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
+                     id="|+>,|+'>"),
+    ])
+    def test_known_cases(self, left, right, expected):
+        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
+
+
+class Test_tracedist:
+    def test_state_with_itself(self, state):
+        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
+
+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+    def test_orthogonal(self, left_dm, right_dm, dimension):
+        left = basis(dimension, 0)
+        right = basis(dimension, dimension//2)
+        if left_dm:
+            left = left.proj()
+        if right_dm:
+            right = right.proj()
+        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
+
+    def test_invariant_under_unitary_transformation(self, dimension):
+        rho1 = rand_dm(dimension, density=0.25)
+        rho2 = rand_dm(dimension, density=0.25)
+        U = rand_unitary(dimension)
+        D = tracedist(rho1, rho2)
+        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
+        assert D == pytest.approx(DU, rel=1e-5)
+
+
+class Test_hellinger_dist:
+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+    def test_orthogonal(self, left_dm, right_dm, dimension):
+        left = basis(dimension, 0)
+        right = basis(dimension, dimension//2)
+        if left_dm:
+            left = left.proj()
+        if right_dm:
+            right = right.proj()
+        expected = np.sqrt(2)
+        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
+
+    def test_state_with_itself(self, state):
+        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
+
+    def test_known_cases_pure_states(self, dimension):
+        left = rand_ket(dimension)
+        right = rand_ket(dimension)
+        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
+        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
+
+    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
+    def test_monotonicity(self, dimension):
+        """
+        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
+        arXiv:1611.03449v2:
+            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
+            >= hellinger_dist(rhoA, sigmaA)
+        with equality iff sigmaB = rhoB where '&' is the tensor product.
+        """
+        tol = 1e-5
+        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
+        rho = tensor(rhoA, rhoB)
+        rho_sim = tensor(rhoA, sigmaB)
+        sigma = tensor(sigmaA, sigmaB)
+        dist = hellinger_dist(rhoA, sigmaA)
+        assert hellinger_dist(rho, sigma) + tol > dist
+        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
+
+
+class Test_average_gate_fidelity:
+    def test_identity(self, dimension):
+        id = qeye(dimension)
+        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
+
+    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
+    def test_bounded(self, dimension):
+        tol = 1e-7
+        channel = rand_super_bcsz(dimension)
+        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
+
+    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
+    def test_unitaries_equal_1(self, dimension):
+        """Tests that for random unitaries U, AGF(U, U) = 1."""
+        tol = 1e-7
+        U = rand_unitary(dimension)
+        SU = to_super(U)
+        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
+
+    def test_average_gate_fidelity_against_legacy_implementation(self):
+        """
+        Metrics: Test that AGF coincides with pre-5.0 implementation
+        """
+        def agf_pre_50(oper, target=None):
+            kraus = to_kraus(oper)
+            d = kraus[0].shape[0]
+
+            if kraus[0].shape[1] != d:
+                return TypeError(
+                    "Average gate fidelity only implemented for square "
+                    "superoperators.")
+
+            if target is None:
+                return (
+                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
+                    (d * d + d)
+                )
+            return (
+                (d + np.sum([
+                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
+                ])) / (d * d + d)
+            )
+
+        oper = rand_super_bcsz(16)
+        target = rand_unitary(16)
+        np.testing.assert_almost_equal(
+            average_gate_fidelity(oper, target),
+            agf_pre_50(oper, target)
+        )
+
+
+class Test_hilbert_dist:
+    def test_known_cases(self):
+        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
+        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
+        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
+
+
+paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
+
+
+class Test_unitarity:
+    @pytest.mark.parametrize(['operator', 'expected'], [
+        pytest.param(to_super(sigmax()), 1, id="sigmax"),
+        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
+        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
+                     id="id+sigmax"),
+    ])
+    def test_known_cases(self, operator, expected):
+        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
+
+    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
+    def test_bounded(self, n_qubits):
+        tol = 1e-7
+        operator = rand_super_bcsz(2**n_qubits)
+        assert -tol <= unitarity(operator) <= 1 + tol
+
+
+class TestComparisons:
+    """Test some known inequalities between two different metrics."""
+
+    def test_inequality_tracedist_to_fidelity(self, left, right):
+        tol = 1e-7
+        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
+
+    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
+        tol = 1e-7
+        hellinger = hellinger_dist(left, right)
+        bures = bures_dist(left, right)
+        assert bures <= hellinger + tol
+
+
+def overrotation(x):
+    return to_super((1j * np.pi * x * sigmax() / 2).expm())
+
+
+def had_mixture(x):
+    id_chan = to_choi(qeye(2))
+    S_eye = to_super(id_chan)
+    S_H = to_super(snot())
+    return (1 - x) * S_eye + x * S_H
+
+
+def swap_map(x):
+    base = (1j * x * swap()).expm()
+    dims = [[[2], [2]], [[2], [2]]]
+    return Qobj(base, dims=dims, type='super', superrep='super')
+
+
+def adc_choi(x):
+    kraus = [
+        np.sqrt(1 - x) * qeye(2),
+        np.sqrt(x) * destroy(2),
+        np.sqrt(x) * fock_dm(2, 0),
+    ]
+    return kraus_to_choi(kraus)
+
+
+# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
+# to solve the problem, and this can cause an entire test-suite failure.  As
+# long as we are using random tests (perhaps not ideal), this will happen
+# occasionally.  This isn't entirely a bug, it's just a reality of using a
+# one-size-fits-all solver; we've historically assumed users who come up
+# against this sort of thing will be accepting of the fact that dnorm
+# calculation is nontrivial, and isn't always entirely feasible.
+#
+# To deal with it, we allow each test to be rerun twice, using
+# pytest-rerunfailures.  This should forbid pathological cases where the test
+# is failing every time, but not penalise one-off failures.  As far as we know,
+# the failing tests always involve a random step, so triggering a re-run will
+# have them choose new variables as well.
+#
+# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
+# which is deprecated as of numpy 1.20.
+#
+# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
+# depends on them.
+@pytest.mark.skipif(cvxpy is None or cvxopt is None,
+                    reason="Skipping dnorm tests because dnorm requires cvxpy"
+                    " and cvxopt which are not installed.")
+@pytest.mark.skipif("Windows" in platform.system(),
+                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
+                    " installed on Windows but fail to correctly solve"
+                    " the given optimization problems.")
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.filterwarnings(
+    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
+)
+class Test_dnorm:
+    @pytest.fixture(params=[2, 3])
+    def dimension(self, request):
+        return request.param
+
+    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
+    def sparse(self, request):
+        return request.param
+
+    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
+    def test_sparse_against_dense_adc(self, variable):
+        """
+        Test sparse versus dense dnorm calculation for a sample of
+        amplitude-damping channels.
+        """
+        # Choi matrix for identity channel on 1 qubit
+        A = kraus_to_choi([qeye(2)])
+        B = adc_choi(variable)
+        dense = dnorm(A, B, force_solve=True, sparse=False)
+        sparse = dnorm(A, B, force_solve=True, sparse=True)
+        assert dense == pytest.approx(sparse, abs=1e-7)
+
+    @pytest.mark.repeat(3)
+    def test_sparse_against_dense_random(self, dimension):
+        """
+        Test sparse versus dense dnorm calculation for random superoperators.
+        """
+        A = rand_super_bcsz(dimension)
+        dense_run_result = dnorm(A, force_solve=True, sparse=False)
+        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
+        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
+
+    def test_bounded(self, dimension, sparse):
+        """dnorm(A - B) in [0, 2] for random superops A, B."""
+        tol = 1e-7
+        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
+        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
+
+    def test_qubit_simple_known_cases(self, sparse):
+        """Check agreement for known qubit channels."""
+        id_chan = to_choi(qeye(2))
+        X_chan = to_choi(sigmax())
+        depol = to_choi(Qobj(
+            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
+        ))
+        # We need to restrict the number of iterations for things on the
+        # boundary, such as perfectly distinguishable channels.
+        assert (
+            dnorm(id_chan, X_chan, sparse=sparse)
+            == pytest.approx(2, abs=1e-7)
+        )
+        assert (
+            dnorm(id_chan, depol, sparse=sparse)
+            == pytest.approx(1.5, abs=1e-7)
+        )
+        # Finally, we add a known case from Johnston's QETLAB documentation,
+        #   || Phi - I ||_♢,
+        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
+        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
+        assert (
+            dnorm(U, qeye(2), sparse=sparse)
+            == pytest.approx(np.sqrt(2), abs=1e-7)
+        )
+
+    @pytest.mark.parametrize(["variable", "expected", "generator"], [
+        [1.0e-3, 3.141591e-03, overrotation],
+        [3.1e-3, 9.738899e-03, overrotation],
+        [1.0e-2, 3.141463e-02, overrotation],
+        [3.1e-2, 9.735089e-02, overrotation],
+        [1.0e-1, 3.128689e-01, overrotation],
+        [3.1e-1, 9.358596e-01, overrotation],
+        [1.0e-3, 2.000000e-03, had_mixture],
+        [3.1e-3, 6.200000e-03, had_mixture],
+        [1.0e-2, 2.000000e-02, had_mixture],
+        [3.1e-2, 6.200000e-02, had_mixture],
+        [1.0e-1, 2.000000e-01, had_mixture],
+        [3.1e-1, 6.200000e-01, had_mixture],
+        [1.0e-3, 2.000000e-03, swap_map],
+        [3.1e-3, 6.199997e-03, swap_map],
+        [1.0e-2, 1.999992e-02, swap_map],
+        [3.1e-2, 6.199752e-02, swap_map],
+        [1.0e-1, 1.999162e-01, swap_map],
+        [3.1e-1, 6.173918e-01, swap_map],
+    ])
+    def test_qubit_known_cases(self, variable, expected, generator, sparse):
+        """
+        Test cases based on comparisons to pre-existing dnorm implementations.
+        In particular, the targets for the following test cases were generated
+        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
+        """
+        id_chan = to_choi(qeye(2))
+        channel = generator(variable)
+        assert (
+            dnorm(channel, id_chan, sparse=sparse)
+            == pytest.approx(expected, abs=1e-7)
+        )
+
+    def test_qubit_scalar(self, dimension):
+        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
+        a = np.random.random()
+        A = rand_super_bcsz(dimension)
+        B = rand_super_bcsz(dimension)
+        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
+
+    def test_qubit_triangle(self, dimension):
+        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
+        A = rand_super_bcsz(dimension)
+        B = rand_super_bcsz(dimension)
+        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
+
+    @pytest.mark.repeat(3)
+    @pytest.mark.parametrize("generator", [
+        pytest.param(rand_super_bcsz, id="super"),
+        pytest.param(rand_unitary, id="unitary"),
+    ])
+    def test_force_solve(self, dimension, generator):
+        """
+        Metrics: checks that special cases for dnorm agree with SDP solutions.
+        """
+        A, B = generator(dimension), generator(dimension)
+        assert (
+            dnorm(A, B, force_solve=False)
+            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
+        )
+
+    @pytest.mark.repeat(3)
+    def test_cptp(self, dimension, sparse):
+        """Check that the diamond norm is one for CPTP maps."""
+        A = rand_super_bcsz(dimension)
+        assert A.iscptp
+        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
+
+
+@pytest.mark.parametrize('superrep_conversion',
+                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
+def test_process_fidelity_of_identity(superrep_conversion):
+    """
+    Metrics: process fidelity of identity map is 1
+    """
+    num_qubits = 3
+    oper = qeye(num_qubits*[2])
+    f = process_fidelity(superrep_conversion(oper))
+    assert np.isrealobj(f)
+    assert f == pytest.approx(1)
+
+
+@pytest.mark.parametrize('superrep_conversion',
+                         [to_super, to_choi, to_chi, to_kraus])
+def test_process_fidelity_identical_channels(superrep_conversion):
+    """
+    Metrics: process fidelity of a map to itself is 1
+    """
+    num_qubits = 2
+    for k in range(10):
+        oper = rand_super_bcsz(num_qubits*[2])
+        oper = superrep_conversion(oper)
+        f = process_fidelity(oper, oper)
+        assert f == pytest.approx(1)
+
+
+def test_process_fidelity_identical_unitaries():
+    """
+    Metrics: process fidelity of a unitary to itself is 1
+    """
+    num_qubits = 3
+    for k in range(10):
+        oper = rand_unitary(num_qubits * [2])
+        f = process_fidelity(oper, oper)
+        assert f == pytest.approx(1)
+
+
+def test_process_fidelity_consistency():
+    """
+    Metrics: process fidelity independent of how channels are represented
+    """
+    num_qubits = 2
+    for k in range(10):
+        fidelities_u_to_u = []
+        fidelities_u_to_id = []
+        u1 = rand_unitary(num_qubits * [2])
+        u2 = rand_unitary(num_qubits * [2])
+        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
+            fidelities_u_to_id.append(process_fidelity(map1(u1)))
+            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
+                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
+        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
+        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
+
+
+def test_process_fidelity_unitary_invariance():
+    """
+    Metrics: process fidelity, invariance under unitary trans.
+    """
+    for k in range(10):
+        op1 = rand_super_bcsz(10)
+        op2 = rand_super_bcsz(10)
+        u = to_super(rand_unitary(10))
+        assert abs(
+            process_fidelity(op1, op2)
+            - process_fidelity(u*op1, u*op2)
+        ) < 1e-8
+
+
+@pytest.mark.parametrize('superrep_conversion',
+                         [lambda x: x, to_super, to_choi, to_kraus])
+def test_hilbert_space_dims(superrep_conversion):
+    """
+    Metrics: check _hilbert_space_dims
+    """
+    dims = [[2, 3], [4, 5]]
+    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
+    assert _hilbert_space_dims(superrep_conversion(u)) == dims
+
+
+def test_hilbert_space_dims_chi():
+    """
+    Metrics: check _hilbert_space_dims for a chi channel
+    """
+    dims = [[2, 2], [2, 2]]
+    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
+    assert _hilbert_space_dims(to_chi(u)) == dims
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index c8e6d72f0a..f59dce8f24 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -1,295 +1,295 @@
-import numbers
-import numpy as np
-import pytest
-import qutip
-
-
-N = 5
-
-
-def test_jmat_12():
-    spinhalf = qutip.jmat(1 / 2.)
-
-    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
-    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
-    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
-    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
-    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
-
-    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
-    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
-    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
-    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
-    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
-
-    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
-    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
-    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
-    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
-    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
-
-    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
-    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
-    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
-    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
-    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
-
-    spin_set = qutip.spin_J_set(0.5)
-    for i in range(3):
-        assert spinhalf[i] == spin_set[i]
-
-
-
-def test_jmat_32():
-    spin32 = qutip.jmat(3 / 2.)
-
-    paulix32 = np.array(
-        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
-         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
-         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
-         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
-
-    pauliy32 = np.array(
-        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
-         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
-         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
-         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
-
-    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
-                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
-                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
-                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
-
-    np.testing.assert_allclose(spin32[0].full(), paulix32)
-    np.testing.assert_allclose(spin32[1].full(), pauliy32)
-    np.testing.assert_allclose(spin32[2].full(), pauliz32)
-
-
-@pytest.mark.parametrize(['spin', 'N'], [
-    pytest.param(3/2., 4, id="1.5"),
-    pytest.param(5/2., 6, id="2.5"),
-    pytest.param(3.0, 7, id="3.0"),
-])
-def test_jmat_dims(spin, N):
-    spin_mat = qutip.jmat(spin, '+')
-    assert spin_mat.dims == [[N], [N]]
-    assert spin_mat.shape == (N, N)
-
-
-def test_jmat_raise():
-    with pytest.raises(ValueError) as e:
-        qutip.jmat(0.25)
-    assert str(e.value) == 'j must be a non-negative integer or half-integer'
-
-    with pytest.raises(ValueError) as e:
-        qutip.jmat(0.5, 'zx+')
-    assert "Invalid spin operator" in str(e.value)
-
-
-@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
-    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
-    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
-    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
-    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
-                 id="destroy_offset"),
-    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
-    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
-                 id="create_offset"),
-    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
-    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
-    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
-    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
-                 id="charge_args"),
-])
-def test_diagonal_operators(oper_func, diag, offset, args):
-    oper = oper_func(N, *args)
-    assert oper == qutip.Qobj(np.diag(diag, offset))
-
-
-@pytest.mark.parametrize(['function', 'message'], [
-    (qutip.qeye, "All dimensions must be integers >= 0"),
-    (qutip.destroy, "Hilbert space dimension must be integer value"),
-    (qutip.create, "Hilbert space dimension must be integer value"),
-], ids=["qeye", "destroy", "create"])
-def test_diagonal_raise(function, message):
-    with pytest.raises(ValueError) as e:
-        function(2.5)
-    assert str(e.value) == message
-
-
-@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
-@pytest.mark.parametrize("dimensions", [
-        2,
-        [2],
-        [2, 3, 4],
-        1,
-        [1],
-        [1, 1],
-    ])
-def test_implicit_tensor_creation(to_test, dimensions):
-    implicit = to_test(dimensions)
-    if isinstance(dimensions, numbers.Integral):
-        dimensions = [dimensions]
-    assert implicit.dims == [dimensions, dimensions]
-
-
-@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
-def test_super_operator_creation(to_test):
-    size = 2
-    implicit = to_test([[size], [size]])
-    explicit = qutip.to_super(to_test(size))
-    assert implicit == explicit
-
-
-def test_position():
-    operator = qutip.position(N)
-    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
-                np.diag((np.arange(1, N) / 2)**0.5, k=1))
-    np.testing.assert_allclose(operator.full(), expected)
-    assert operator._isherm == True
-
-
-def test_momentum():
-    operator = qutip.momentum(N)
-    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
-                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
-    np.testing.assert_allclose(operator.full(), expected)
-    assert operator._isherm == True
-
-
-def test_squeeze():
-    sq = qutip.squeeze(4, 0.1 + 0.1j)
-    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
-                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
-                         [0.00000000 + 0.j, 0.98503746 + 0.j,
-                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
-                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
-                          0.99500417 + 0.j, 0.00000000 + 0.j],
-                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
-                          0.00000000 + 0.j, 0.98503746 + 0.j]])
-    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
-
-
-def test_squeezing():
-    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
-    a = qutip.destroy(4)
-    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
-    assert squeeze == squeezing
-
-
-def test_displace():
-    dp = qutip.displace(4, 0.25)
-    dpmatrix = np.array(
-        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
-          0.00626025 + 0.j],
-         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
-          0.j, 0.07418172 + 0.j],
-         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
-          0.j, -0.41083747 + 0.j],
-         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
-          0.90866411 + 0.j]])
-    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
-
-
-@pytest.mark.parametrize("shift", [1, 2])
-def test_tunneling(shift):
-    N = 10
-    tn = qutip.tunneling(N, shift)
-    tn_matrix = np.diag(np.ones(N - shift), k=shift)
-    tn_matrix += tn_matrix.T
-    np.testing.assert_allclose(tn.full(), tn_matrix)
-
-
-def test_commutator():
-    A = qutip.qeye(N)
-    B = qutip.destroy(N)
-    assert qutip.commutator(A, B) == qutip.qzero(N)
-
-    sx = qutip.sigmax()
-    sy = qutip.sigmay()
-    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
-
-    A = qutip.qeye(N)
-    B = qutip.destroy(N)
-    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
-
-    sx = qutip.sigmax()
-    sy = qutip.sigmay()
-    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
-
-    with pytest.raises(TypeError) as e:
-        qutip.commutator(sx, sy, 'something')
-    assert str(e.value).startswith("Unknown commutator kind")
-
-def test_qutrit_ops():
-    ops = qutip.qutrit_ops()
-    assert qutip.qeye(3) == sum(ops[:3])
-    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
-    expected = np.zeros((3, 3))
-    expected[2, 0] = 1
-    np.testing.assert_allclose(expected, ops[5].full())
-
-
-def _id_func(val):
-    "ids generated from the function only"
-    if isinstance(val, tuple):
-        return ""
-
-
-# random object accept `str` and base.Data
-# Obtain all valid dtype from `to`
-dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
-dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-@pytest.mark.parametrize(['func', 'args'], [
-    (qutip.qdiags, ([0, 1, 2], 1)),
-    (qutip.jmat, (1,)),
-    (qutip.spin_Jx, (1,)),
-    (qutip.spin_Jy, (1,)),
-    (qutip.spin_Jz, (1,)),
-    (qutip.spin_Jp, (1,)),
-    (qutip.destroy, (5,)),
-    (qutip.create, (5,)),
-    (qutip.qzero, (5,)),
-    (qutip.qeye, (5,)),
-    (qutip.position, (5,)),
-    (qutip.momentum, (5,)),
-    (qutip.num, (5,)),
-    (qutip.squeeze, (5, 0.5)),
-    (qutip.displace, (5, 1.0)),
-    (qutip.qutrit_ops, ()),
-    (qutip.phase, (5,)),
-    (qutip.charge, (5,)),
-    (qutip.tunneling, (5,)),
-    (qutip.enr_destroy, ([3, 3, 3], 4)),
-    (qutip.enr_identity, ([3, 3, 3], 4)),
-], ids=_id_func)
-def test_operator_type(func, args, alias, dtype):
-    object = func(*args, dtype=alias)
-    if isinstance(object, qutip.Qobj):
-        assert isinstance(object.data, dtype)
-    else:
-        for obj in object:
-            assert isinstance(obj.data, dtype)
-
-    with qutip.CoreOptions(default_dtype=alias):
-        object = func(*args)
-        if isinstance(object, qutip.Qobj):
-            assert isinstance(object.data, dtype)
-        else:
-            for obj in object:
-                assert isinstance(obj.data, dtype)
-
-
-@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
-def test_qft(dims):
-    N = np.prod(dims)
-    qft = qutip.qft(N).full()
-    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
-    for i in range(N):
-        target = np.zeros(N)
-        target[i] = 1
-        fft = np.fft.fft(qft[:,i])
-        fft /= np.sum(fft)
-        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
+import numbers
+import numpy as np
+import pytest
+import qutip
+
+
+N = 5
+
+
+def test_jmat_12():
+    spinhalf = qutip.jmat(1 / 2.)
+
+    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
+    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
+    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
+    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
+    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
+
+    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
+    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
+    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
+    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
+    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
+
+    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
+    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
+    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
+    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
+    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
+
+    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
+    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
+    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
+    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
+    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
+
+    spin_set = qutip.spin_J_set(0.5)
+    for i in range(3):
+        assert spinhalf[i] == spin_set[i]
+
+
+
+def test_jmat_32():
+    spin32 = qutip.jmat(3 / 2.)
+
+    paulix32 = np.array(
+        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
+         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
+         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
+         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
+
+    pauliy32 = np.array(
+        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
+         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
+         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
+         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
+
+    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
+                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
+                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
+                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
+
+    np.testing.assert_allclose(spin32[0].full(), paulix32)
+    np.testing.assert_allclose(spin32[1].full(), pauliy32)
+    np.testing.assert_allclose(spin32[2].full(), pauliz32)
+
+
+@pytest.mark.parametrize(['spin', 'N'], [
+    pytest.param(3/2., 4, id="1.5"),
+    pytest.param(5/2., 6, id="2.5"),
+    pytest.param(3.0, 7, id="3.0"),
+])
+def test_jmat_dims(spin, N):
+    spin_mat = qutip.jmat(spin, '+')
+    assert spin_mat.dims == [[N], [N]]
+    assert spin_mat.shape == (N, N)
+
+
+def test_jmat_raise():
+    with pytest.raises(ValueError) as e:
+        qutip.jmat(0.25)
+    assert str(e.value) == 'j must be a non-negative integer or half-integer'
+
+    with pytest.raises(ValueError) as e:
+        qutip.jmat(0.5, 'zx+')
+    assert "Invalid spin operator" in str(e.value)
+
+
+@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
+    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
+    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
+    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
+    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
+                 id="destroy_offset"),
+    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
+    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
+                 id="create_offset"),
+    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
+    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
+    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
+    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
+                 id="charge_args"),
+])
+def test_diagonal_operators(oper_func, diag, offset, args):
+    oper = oper_func(N, *args)
+    assert oper == qutip.Qobj(np.diag(diag, offset))
+
+
+@pytest.mark.parametrize(['function', 'message'], [
+    (qutip.qeye, "All dimensions must be integers >= 0"),
+    (qutip.destroy, "Hilbert space dimension must be integer value"),
+    (qutip.create, "Hilbert space dimension must be integer value"),
+], ids=["qeye", "destroy", "create"])
+def test_diagonal_raise(function, message):
+    with pytest.raises(ValueError) as e:
+        function(2.5)
+    assert str(e.value) == message
+
+
+@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
+@pytest.mark.parametrize("dimensions", [
+        2,
+        [2],
+        [2, 3, 4],
+        1,
+        [1],
+        [1, 1],
+    ])
+def test_implicit_tensor_creation(to_test, dimensions):
+    implicit = to_test(dimensions)
+    if isinstance(dimensions, numbers.Integral):
+        dimensions = [dimensions]
+    assert implicit.dims == [dimensions, dimensions]
+
+
+@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
+def test_super_operator_creation(to_test):
+    size = 2
+    implicit = to_test([[size], [size]])
+    explicit = qutip.to_super(to_test(size))
+    assert implicit == explicit
+
+
+def test_position():
+    operator = qutip.position(N)
+    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
+                np.diag((np.arange(1, N) / 2)**0.5, k=1))
+    np.testing.assert_allclose(operator.full(), expected)
+    assert operator._isherm == True
+
+
+def test_momentum():
+    operator = qutip.momentum(N)
+    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
+                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
+    np.testing.assert_allclose(operator.full(), expected)
+    assert operator._isherm == True
+
+
+def test_squeeze():
+    sq = qutip.squeeze(4, 0.1 + 0.1j)
+    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
+                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
+                         [0.00000000 + 0.j, 0.98503746 + 0.j,
+                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
+                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
+                          0.99500417 + 0.j, 0.00000000 + 0.j],
+                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
+                          0.00000000 + 0.j, 0.98503746 + 0.j]])
+    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
+
+
+def test_squeezing():
+    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
+    a = qutip.destroy(4)
+    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
+    assert squeeze == squeezing
+
+
+def test_displace():
+    dp = qutip.displace(4, 0.25)
+    dpmatrix = np.array(
+        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
+          0.00626025 + 0.j],
+         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
+          0.j, 0.07418172 + 0.j],
+         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
+          0.j, -0.41083747 + 0.j],
+         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
+          0.90866411 + 0.j]])
+    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
+
+
+@pytest.mark.parametrize("shift", [1, 2])
+def test_tunneling(shift):
+    N = 10
+    tn = qutip.tunneling(N, shift)
+    tn_matrix = np.diag(np.ones(N - shift), k=shift)
+    tn_matrix += tn_matrix.T
+    np.testing.assert_allclose(tn.full(), tn_matrix)
+
+
+def test_commutator():
+    A = qutip.qeye(N)
+    B = qutip.destroy(N)
+    assert qutip.commutator(A, B) == qutip.qzero(N)
+
+    sx = qutip.sigmax()
+    sy = qutip.sigmay()
+    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
+
+    A = qutip.qeye(N)
+    B = qutip.destroy(N)
+    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
+
+    sx = qutip.sigmax()
+    sy = qutip.sigmay()
+    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
+
+    with pytest.raises(TypeError) as e:
+        qutip.commutator(sx, sy, 'something')
+    assert str(e.value).startswith("Unknown commutator kind")
+
+def test_qutrit_ops():
+    ops = qutip.qutrit_ops()
+    assert qutip.qeye(3) == sum(ops[:3])
+    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
+    expected = np.zeros((3, 3))
+    expected[2, 0] = 1
+    np.testing.assert_allclose(expected, ops[5].full())
+
+
+def _id_func(val):
+    "ids generated from the function only"
+    if isinstance(val, tuple):
+        return ""
+
+
+# random object accept `str` and base.Data
+# Obtain all valid dtype from `to`
+dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
+dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize(['func', 'args'], [
+    (qutip.qdiags, ([0, 1, 2], 1)),
+    (qutip.jmat, (1,)),
+    (qutip.spin_Jx, (1,)),
+    (qutip.spin_Jy, (1,)),
+    (qutip.spin_Jz, (1,)),
+    (qutip.spin_Jp, (1,)),
+    (qutip.destroy, (5,)),
+    (qutip.create, (5,)),
+    (qutip.qzero, (5,)),
+    (qutip.qeye, (5,)),
+    (qutip.position, (5,)),
+    (qutip.momentum, (5,)),
+    (qutip.num, (5,)),
+    (qutip.squeeze, (5, 0.5)),
+    (qutip.displace, (5, 1.0)),
+    (qutip.qutrit_ops, ()),
+    (qutip.phase, (5,)),
+    (qutip.charge, (5,)),
+    (qutip.tunneling, (5,)),
+    (qutip.enr_destroy, ([3, 3, 3], 4)),
+    (qutip.enr_identity, ([3, 3, 3], 4)),
+], ids=_id_func)
+def test_operator_type(func, args, alias, dtype):
+    object = func(*args, dtype=alias)
+    if isinstance(object, qutip.Qobj):
+        assert isinstance(object.data, dtype)
+    else:
+        for obj in object:
+            assert isinstance(obj.data, dtype)
+
+    with qutip.CoreOptions(default_dtype=alias):
+        object = func(*args)
+        if isinstance(object, qutip.Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
+
+
+@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
+def test_qft(dims):
+    N = np.prod(dims)
+    qft = qutip.qft(N).full()
+    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
+    for i in range(N):
+        target = np.zeros(N)
+        target[i] = 1
+        fft = np.fft.fft(qft[:,i])
+        fft /= np.sum(fft)
+        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
diff --git a/qutip/tests/core/test_ptrace.py b/qutip/tests/core/test_ptrace.py
index 40efd15109..8ae26d52ad 100644
--- a/qutip/tests/core/test_ptrace.py
+++ b/qutip/tests/core/test_ptrace.py
@@ -1,130 +1,130 @@
-import itertools
-
-import numpy as np
-import pytest
-
-import qutip
-from qutip.core import data as _data
-
-
-def expected(qobj, sel):
-    if qobj.isbra or qobj.isket:
-        qobj = qobj.proj()
-    sel = sorted(sel)
-    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
-    new_shape = (np.prod(dims[0], dtype=int),) * 2
-    out = qobj.full()
-    before, after = 1, qobj.shape[0]
-    for i, dim in enumerate(qobj.dims[0]):
-        after //= dim
-        if i in sel:
-            before = before * dim
-            continue
-        tmp_dims = (before, dim, after) * 2
-        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
-    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
-
-
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
-def dtype(request):
-    return request.param
-
-
-@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
-def dm(request):
-    return request.param
-
-
-@pytest.fixture
-def state(dtype, dm):
-    dims = [2, 3, 4]
-    state = qutip.rand_ket(dims)
-    if dm:
-        state = state.proj()
-    return state.to(dtype)
-
-
-def test_ptrace_noncompound_rand(dtype, dm):
-    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
-    for _ in range(5):
-        state = qutip.rand_ket(5)
-        if dm:
-            state = state.proj()
-        state = state.to(dtype)
-        assert state.ptrace(0) == (state if dm else state.proj())
-
-
-@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
-def test_ptrace_unsorted_selection_subset(state, pair):
-    """
-    Regression test for gh-1325.  ptrace should work the same independently of
-    the order of the input; no transposition in done in the trace operation.
-    """
-    # pair is always sorted.
-    state_ordered = state.ptrace(pair)
-    state_reversed = state.ptrace(pair[::-1])
-    assert state_ordered.dims == state_reversed.dims
-    assert state_ordered == state_reversed
-
-
-@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
-def test_ptrace_unsorted_selection_all(state, permutation):
-    state_ptraced = state.ptrace(permutation)
-    if state.isket:
-        state = state.proj()
-    assert state.dims == state_ptraced.dims
-    assert state == state_ptraced
-
-
-@pytest.mark.parametrize(['selection', 'exception'], [
-    pytest.param(4, IndexError, id='too big'),
-    pytest.param(-1, IndexError, id='too small'),
-    pytest.param([0, 0], ValueError, id='duplicate'),
-    # 'too many' may throw either from duplication or invalid index.
-    pytest.param([0, 1, 2, 3], Exception, id='too many'),
-])
-def test_ptrace_fails_on_invalid_input(state, selection, exception):
-    with pytest.raises(exception):
-        state.ptrace(selection)
-
-
-@pytest.mark.parametrize('dims, sel',
-                         [
-                             ([5, 2, 3], [2, 1]),
-                             ([5, 2, 3], [0, 2]),
-                             ([5, 2, 3], [0, 1]),
-                             ([2]*6, [3, 2]),
-                             ([2]*6, [0, 2]),
-                             ([2]*6, [0, 1]),
-                         ])
-def test_ptrace_rand_ket(dtype, dims, sel):
-    A = qutip.rand_ket(dims)
-    assert A.ptrace(sel) == expected(A, sel)
-
-
-@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
-                         ids=['trace_all',
-                              'trace_none',
-                              'trace_one',
-                              'trace_one_2',
-                              'trace_multiple',
-                              'trace_multiple_not_sorted',
-                              ])
-def test_ptrace_rand_dm(dtype, sel):
-    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
-    assert A.ptrace(sel) == expected(A, sel)
-
-
-@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
-                         ids=['trace_all',
-                              'trace_none',
-                              'trace_one',
-                              'trace_one_2',
-                              'trace_multiple',
-                              'trace_multiple_not_sorted',
-                              ])
-def test_ptrace_operator(dtype, sel):
-    A = qutip.tensor(
-        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
-    ).to(dtype)
-    assert A.ptrace(sel) == expected(A, sel)
+import itertools
+
+import numpy as np
+import pytest
+
+import qutip
+from qutip.core import data as _data
+
+
+def expected(qobj, sel):
+    if qobj.isbra or qobj.isket:
+        qobj = qobj.proj()
+    sel = sorted(sel)
+    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
+    new_shape = (np.prod(dims[0], dtype=int),) * 2
+    out = qobj.full()
+    before, after = 1, qobj.shape[0]
+    for i, dim in enumerate(qobj.dims[0]):
+        after //= dim
+        if i in sel:
+            before = before * dim
+            continue
+        tmp_dims = (before, dim, after) * 2
+        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
+    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
+
+
+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
+def dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
+def dm(request):
+    return request.param
+
+
+@pytest.fixture
+def state(dtype, dm):
+    dims = [2, 3, 4]
+    state = qutip.rand_ket(dims)
+    if dm:
+        state = state.proj()
+    return state.to(dtype)
+
+
+def test_ptrace_noncompound_rand(dtype, dm):
+    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
+    for _ in range(5):
+        state = qutip.rand_ket(5)
+        if dm:
+            state = state.proj()
+        state = state.to(dtype)
+        assert state.ptrace(0) == (state if dm else state.proj())
+
+
+@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
+def test_ptrace_unsorted_selection_subset(state, pair):
+    """
+    Regression test for gh-1325.  ptrace should work the same independently of
+    the order of the input; no transposition in done in the trace operation.
+    """
+    # pair is always sorted.
+    state_ordered = state.ptrace(pair)
+    state_reversed = state.ptrace(pair[::-1])
+    assert state_ordered.dims == state_reversed.dims
+    assert state_ordered == state_reversed
+
+
+@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
+def test_ptrace_unsorted_selection_all(state, permutation):
+    state_ptraced = state.ptrace(permutation)
+    if state.isket:
+        state = state.proj()
+    assert state.dims == state_ptraced.dims
+    assert state == state_ptraced
+
+
+@pytest.mark.parametrize(['selection', 'exception'], [
+    pytest.param(4, IndexError, id='too big'),
+    pytest.param(-1, IndexError, id='too small'),
+    pytest.param([0, 0], ValueError, id='duplicate'),
+    # 'too many' may throw either from duplication or invalid index.
+    pytest.param([0, 1, 2, 3], Exception, id='too many'),
+])
+def test_ptrace_fails_on_invalid_input(state, selection, exception):
+    with pytest.raises(exception):
+        state.ptrace(selection)
+
+
+@pytest.mark.parametrize('dims, sel',
+                         [
+                             ([5, 2, 3], [2, 1]),
+                             ([5, 2, 3], [0, 2]),
+                             ([5, 2, 3], [0, 1]),
+                             ([2]*6, [3, 2]),
+                             ([2]*6, [0, 2]),
+                             ([2]*6, [0, 1]),
+                         ])
+def test_ptrace_rand_ket(dtype, dims, sel):
+    A = qutip.rand_ket(dims)
+    assert A.ptrace(sel) == expected(A, sel)
+
+
+@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
+                         ids=['trace_all',
+                              'trace_none',
+                              'trace_one',
+                              'trace_one_2',
+                              'trace_multiple',
+                              'trace_multiple_not_sorted',
+                              ])
+def test_ptrace_rand_dm(dtype, sel):
+    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
+    assert A.ptrace(sel) == expected(A, sel)
+
+
+@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
+                         ids=['trace_all',
+                              'trace_none',
+                              'trace_one',
+                              'trace_one_2',
+                              'trace_multiple',
+                              'trace_multiple_not_sorted',
+                              ])
+def test_ptrace_operator(dtype, sel):
+    A = qutip.tensor(
+        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
+    ).to(dtype)
+    assert A.ptrace(sel) == expected(A, sel)
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 85e091b608..9c1aa1566d 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1,1228 +1,1228 @@
-import numbers
-import operator
-import pytest
-
-import numpy as np
-import scipy.sparse
-import scipy.linalg
-
-import qutip
-from qutip.core import data as _data
-
-
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
-def datatype(request):
-    return request.param
-
-
-def _random_not_singular(N):
-    """
-    return a N*N complex array with determinant not 0.
-    """
-    data = np.zeros((1, 1))
-    while np.linalg.det(data) == 0:
-        data = np.random.random((N, N)) + \
-               1j * np.random.random((N, N)) - (0.5 + 0.5j)
-    return data
-
-
-def assert_hermicity(oper, hermicity):
-    # Check the cached isherm, if any exists.
-    assert oper.isherm == hermicity
-    # Force a reset of the cached value for isherm.
-    oper._isherm = None
-    # Force a recalculation of isherm.
-    assert oper.isherm == hermicity
-
-
-def test_QobjData():
-    "qutip.Qobj data"
-    N = 10
-    data1 = _random_not_singular(N)
-    q1 = qutip.Qobj(data1)
-    assert isinstance(q1.data, qutip.core.data.Data)
-    assert np.all(q1.data.to_array() == data1)
-
-    data2 = _random_not_singular(N)
-    data2 = scipy.sparse.csr_matrix(data2)
-    q2 = qutip.Qobj(data2)
-    assert isinstance(q2.data, qutip.core.data.Data)
-
-
-@pytest.mark.parametrize("original_data",
-                         [
-                            qutip.data.Dense(_random_not_singular(2)),
-                            qutip.data.csr.identity(2),
-                            qutip.Qobj(_random_not_singular(2)),
-                            _random_not_singular(2),
-                         ],
-                         ids=[
-                             "Dense",
-                             "CSR",
-                             "Qobj",
-                             "ndarray",
-                         ])
-@pytest.mark.parametrize("copy", [True, False],
-                         ids=["copy=True", "copy=False"])
-def test_QobjCopyArgument(original_data, copy):
-    """Tests that Qobj copy argument works properly when instantiating Qobj."""
-    qobj_data = qutip.Qobj(original_data, copy=copy).data
-
-    if isinstance(original_data, qutip.Qobj):
-        # Qobj copies the data of another Qobj, so we take `data` if
-        # original_data was a Qobj
-        original_data = original_data.data
-
-    if isinstance(original_data, np.ndarray):
-        # For numpy object we compare with data's data. This should be dense so
-        # we get its data as ndarray.
-        qobj_data = qobj_data.as_ndarray()
-
-        # We look at the memory and see if it is shared or not to asses wether
-        # copy argument worked or not.
-        assert np.shares_memory(qobj_data, original_data) != copy
-
-    else:
-        assert (original_data is qobj_data) != copy
-
-
-def test_QobjType():
-    "qutip.Qobj type"
-    N = int(np.ceil(10.0 * np.random.random())) + 5
-
-    ket_data = np.random.random((N, 1))
-    ket_qobj = qutip.Qobj(ket_data)
-    assert ket_qobj.type == 'ket'
-    assert ket_qobj.isket
-
-    bra_data = np.random.random((1, N))
-    bra_qobj = qutip.Qobj(bra_data)
-    assert bra_qobj.type == 'bra'
-    assert bra_qobj.isbra
-
-    oper_data = np.random.random((N, N))
-    oper_qobj = qutip.Qobj(oper_data)
-    assert oper_qobj.type == 'oper'
-    assert oper_qobj.isoper
-
-    N = 9
-    super_data = np.random.random((N, N))
-    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
-    assert super_qobj.type == 'super'
-    assert super_qobj.issuper
-    assert super_qobj.superrep == 'super'
-
-    super_data = np.random.random(N)
-    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
-    assert super_qobj.type == 'operator-ket'
-    assert super_qobj.isoperket
-    assert super_qobj.superrep == 'super'
-
-    super_data = np.random.random(N)
-    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
-    assert super_qobj.type == 'operator-bra'
-    assert super_qobj.isoperbra
-    assert super_qobj.superrep == 'super'
-
-    operket_qobj = qutip.operator_to_vector(oper_qobj)
-    assert operket_qobj.isoperket
-    assert operket_qobj.dag().isoperbra
-
-
-class TestQobjHermicity:
-    def test_standard(self):
-        base = _random_not_singular(10)
-        assert_hermicity(qutip.Qobj(base), False)
-        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
-        assert_hermicity(qutip.destroy(5), False)
-        assert_hermicity(qutip.create(5), False)
-
-    def test_addition(self):
-        q_a, q_ad = qutip.destroy(5), qutip.create(5)
-        # test addition of two nonhermitian operators adding up to be hermitian
-        q_x = q_a + q_ad
-        assert_hermicity(q_x, True)
-        # test addition of one hermitan and one nonhermitian operator
-        assert_hermicity(q_x + q_a, False)
-        # test addition of two hermitan operators
-        assert_hermicity(q_x + q_x, True)
-
-    def test_multiplication(self):
-        # Test multiplication of two Hermitian operators.  This results in a
-        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
-        # set wrong metadata.
-        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
-        # Similarly, we need to check that -Z = X * iY is correctly identified
-        # as Hermitian.
-        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
-
-
-def assert_unitarity(oper, unitarity):
-    # Check the cached isunitary.
-    assert oper.isunitary == unitarity
-
-    # Force a reset of the cached value for isunitary.
-    oper._isunitary = None
-    # Force a recalculation of isunitary.
-    assert oper.isunitary == unitarity
-
-
-def test_QobjUnitaryOper():
-    "qutip.Qobj unitarity"
-    # Check some standard operators
-    Sx = qutip.sigmax()
-    Sy = qutip.sigmay()
-    assert_unitarity(qutip.qeye(4), True)
-    assert_unitarity(Sx, True)
-    assert_unitarity(Sy, True)
-    assert_unitarity(qutip.sigmam(), False)
-    assert_unitarity(qutip.destroy(10), False)
-    # Check multiplcation of unitary is unitary
-    assert_unitarity(Sx*Sy, True)
-    # Check some other operations clear unitarity
-    assert_unitarity(Sx+Sy, False)
-    assert_unitarity(4*Sx, False)
-    assert_unitarity(Sx*4, False)
-    assert_unitarity(4+Sx, False)
-    assert_unitarity(Sx+4, False)
-    # Check that when multipliying scalar numbers with absolute value 1 we
-    # maintain unitarity.
-    assert_unitarity(Sx*np.exp(5j), True)
-    assert_unitarity(Sx*1j, True)
-    assert_unitarity(Sx*1, True)
-    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
-    # We do not know if it is unitary until we check the whole matrix again.
-    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
-    # This may be removed in the future as if scalar has abs value of 1 and
-    # matrix is not unitary, output wont be unitary.
-    assert (qutip.sigmam()*1)._isunitary == None
-
-
-def test_QobjDimsShape():
-    "qutip.Qobj shape"
-    N = 10
-    data = _random_not_singular(N)
-
-    q1 = qutip.Qobj(data)
-    assert q1.dims == [[10], [10]]
-    assert q1.shape == (10, 10)
-
-    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
-
-    q1 = qutip.Qobj(data)
-    assert q1.dims == [[10], [1]]
-    assert q1.shape == (10, 1)
-
-    data = _random_not_singular(4)
-
-    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
-    assert q1.dims == [[2, 2], [2, 2]]
-    assert q1.shape == (4, 4)
-
-
-def test_QobjMulNonsquareDims():
-    """
-    qutip.Qobj: multiplication w/ non-square qobj.dims
-
-    Checks for regression of #331.
-    """
-    data = np.array([[0, 1], [1, 0]])
-
-    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
-    q2 = qutip.Qobj(data, dims=[[2], [2]])
-
-    assert (q1 * q2).dims == [[2, 1], [2]]
-    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
-    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
-
-    # Because of the above, we also need to check for extra indices
-    # that aren't of length 1.
-    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
-                     [0.+0.j,  1.+0.j],
-                     [0.+0.j,  1.+0.j],
-                     [1.+0.j,  0.+0.j],
-                     [0.+0.j,  0.-1.j],
-                     [0.+1.j,  0.+0.j],
-                     [1.+0.j,  0.+0.j],
-                     [0.+0.j, -1.+0.j]],
-                    dims=[[4, 2], [2]])
-    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
-
-
-def test_QobjAddition():
-    "qutip.Qobj addition"
-    data1 = np.array([[1, 2], [3, 4]])
-    data2 = np.array([[5, 6], [7, 8]])
-    data3 = data1 + data2
-
-    q1 = qutip.Qobj(data1)
-    q2 = qutip.Qobj(data2)
-    q3 = qutip.Qobj(data3)
-
-    q4 = q1 + q2
-    q4_type = q4.type
-    q4_isherm = q4.isherm
-    q4._type = None
-    q4._isherm = None  # clear cached values
-    assert q4_type == q4.type
-    assert q4_isherm == q4.isherm
-
-    # check elementwise addition/subtraction
-    assert q3 == q4
-
-    # check that addition is commutative
-    assert q1 + q2 == q2 + q1
-
-    data = np.random.random((5, 5))
-    q = qutip.Qobj(data)
-    x1 = q + 5
-    x2 = 5 + q
-    data = data + np.eye(5) * 5
-    assert np.all(x1.full() == data)
-    assert np.all(x2.full() == data)
-
-
-def test_QobjSubtraction():
-    "qutip.Qobj subtraction"
-    data1 = _random_not_singular(5)
-    q1 = qutip.Qobj(data1)
-
-    data2 = _random_not_singular(5)
-    q2 = qutip.Qobj(data2)
-
-    q3 = q1 - q2
-    data3 = data1 - data2
-    assert np.all(q3.full() == data3)
-
-    q4 = q2 - q1
-    data4 = data2 - data1
-    assert np.all(q4.full() == data4)
-
-
-def test_QobjMultiplication():
-    "qutip.Qobj multiplication"
-    data1 = np.array([[1, 2], [3, 4]])
-    data2 = np.array([[5, 6], [7, 8]])
-
-    data3 = np.dot(data1, data2)
-
-    q1 = qutip.Qobj(data1)
-    q2 = qutip.Qobj(data2)
-    q3 = qutip.Qobj(data3)
-
-    q4 = q1 * q2
-
-    assert q3 == q4
-
-
-# Allowed mul operations (scalar)
-@pytest.mark.parametrize("scalar",
-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
-                         ids=[
-                             "python_number",
-                             "scalar_like_array_shape_0",
-                             "scalar_like_array_shape_1",
-                         ])
-def test_QobjMulValidScalar(scalar):
-    "Tests multiplication of Qobj times scalar."
-    data = np.array([[1, 2], [3, 4]])
-    q = qutip.Qobj(data)
-    expect = data * (2+2j)
-
-    # Check __mul__
-    result = q * scalar
-    assert np.all(result.full() == expect)
-
-    # Check __rmul__
-    result = scalar * q
-    assert np.all(result.full() == expect)
-
-
-# We do not allow yet qobj being multiplied by a numpy array that does not
-# represent a scalar. If we include the feature of numpy broadcasting an qobj
-# as scalar, this test should be removed.
-@pytest.mark.parametrize("not_scalar",
-                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
-                         ids=[
-                             "not_scalar_like_vector",
-                             "not_scalar_like_matrix",
-                         ])
-def test_QobjMulNotValidScalar(not_scalar):
-    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-
-    with pytest.raises(TypeError):
-        not_scalar * q1
-
-    with pytest.raises(TypeError):
-        q1 * not_scalar
-
-
-# Allowed division operations (scalar)
-@pytest.mark.parametrize("scalar",
-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
-                         ids=[
-                             "python_number",
-                             "scalar_like_array_shape_0",
-                             "scalar_like_array_shape_1",
-                         ])
-def test_QobjDivisionValidScalar(scalar):
-    "Tests multiplication of Qobj times scalar."
-    data = np.array([[1, 2], [3, 4]])
-    q = qutip.Qobj(data)
-    expect = data / (2+2j)
-
-    # Check __truediv__
-    result = q / scalar
-    assert np.all(result.full() == expect)
-
-
-# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
-# non scalar numpy values. This should also be removed in case of implementing
-# broadcasting rules for Qobj.
-@pytest.mark.parametrize("not_scalar",
-                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
-                         ids=[
-                             "not_scalar_like_vector",
-                             "not_scalar_like_matrix",
-                         ])
-def test_QobjDivisionNotValidScalar(not_scalar):
-    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-
-    with pytest.raises(TypeError):
-        q1 / not_scalar
-
-
-def test_QobjNotImplemented():
-    class MockerScalar():
-        def __mul__(self, other):
-            return "object not accepted by _data.mul, mul"
-
-        def __rmul__(self, other):
-            return "object not accepted by _data.mul, rmul"
-
-        def __rtruediv__(self, other):
-            return "object not accepted by _data.mul, rtruediv"
-
-    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-    scalar = MockerScalar()
-    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
-    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
-    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
-
-def test_QobjDivision():
-    "qutip.Qobj division"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    randN = 10 * np.random.random()
-    q = q / randN
-    assert np.allclose(q.full(), data/randN)
-
-
-def test_QobjPower():
-    "qutip.Qobj power"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
-    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
-
-
-def test_QobjNeg():
-    "qutip.Qobj negation"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    x = -q
-    assert np.all(x.full() == -data)
-    assert q.isherm == x.isherm
-    assert q.type == x.type
-
-
-def test_QobjEquals():
-    "qutip.Qobj equals"
-    data = _random_not_singular(5)
-    q1 = qutip.Qobj(data)
-    q2 = qutip.Qobj(data)
-    assert q1 == q2
-
-    q1 = qutip.Qobj(data)
-    q2 = qutip.Qobj(-data)
-    assert q1 != q2
-
-
-def test_QobjGetItem():
-    "qutip.Qobj getitem"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    assert q[0, 0] == data[0, 0]
-    assert q[-1, 2] == data[-1, 2]
-
-
-def test_CheckMulType():
-    "qutip.Qobj multiplication type"
-    # ket-bra and bra-ket multiplication
-    psi = qutip.basis(5, 0)
-    dm = psi * psi.dag()
-    assert dm.isoper
-    assert dm.isherm
-
-    nrm = psi.dag() * psi
-    assert isinstance(nrm, numbers.Complex)
-    assert abs(nrm) == 1
-
-    # operator-operator multiplication
-    H1 = qutip.rand_herm(3)
-    H2 = qutip.rand_herm(3)
-    out = H1 * H2
-    assert out.isoper
-    out = H1 * H1
-    assert out.isoper
-    assert out.isherm
-    out = H2 * H2
-    assert out.isoper
-    assert out.isherm
-
-    U = qutip.rand_unitary(5)
-    out = U.dag() * U
-    assert out.isoper
-    assert out.isherm
-
-    N = qutip.num(5)
-
-    out = N * N
-    assert out.isoper
-    assert out.isherm
-
-    # operator-ket and bra-operator multiplication
-    op = qutip.sigmax()
-    ket1 = qutip.basis(2, 0)
-    ket2 = op * ket1
-    assert ket2.isket
-
-    bra1 = qutip.basis(2, 0).dag()
-    bra2 = bra1 * op
-    assert bra2.isbra
-
-    assert bra2.dag() == ket2
-
-    # superoperator-operket and operbra-superoperator multiplication
-    sop = qutip.to_super(qutip.sigmax())
-    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
-    opket2 = sop * opket1
-    assert opket2.isoperket
-
-    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
-    opbra2 = opbra1 * sop
-    assert opbra2.isoperbra
-
-    assert opbra2.dag() == opket2
-
-
-def test_operator_ket_superrep():
-    sop = qutip.to_super(qutip.sigmax())
-    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
-    opket2 = sop * opket1
-    assert opket1.superrep == opket2.superrep
-
-    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
-    opbra2 = opbra1 * sop
-    assert opbra1.superrep == opbra2.superrep
-
-
-def test_QobjConjugate():
-    "qutip.Qobj conjugate"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.conj()
-    assert np.all(B.full() == data.conj())
-    assert A.isherm == B.isherm
-    assert A.type == B.type
-    assert A.superrep == B.superrep
-
-
-def test_QobjDagger():
-    "qutip.Qobj adjoint (dagger)"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.dag()
-    assert np.all(B.full() == data.conj().T)
-    assert A.isherm == B.isherm
-    assert A.type == B.type
-    assert A.superrep == B.superrep
-
-
-def test_QobjDiagonals():
-    "qutip.Qobj diagonals"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    b = A.diag()
-    assert np.all(b == np.diag(data))
-
-
-def test_QobjEigenEnergies():
-    "qutip.Qobj eigenenergies"
-    data = np.eye(5)
-    A = qutip.Qobj(data)
-    b = A.eigenenergies()
-    assert np.all(b == np.ones(5))
-
-    data = np.diag(np.arange(10))
-    A = qutip.Qobj(data)
-    b = A.eigenenergies()
-    assert np.all(b == np.arange(10))
-
-    data = np.diag(np.arange(10))
-    A = 5 * qutip.Qobj(data)
-    b = A.eigenenergies()
-    assert np.all(b == 5*np.arange(10))
-
-
-def test_QobjEigenStates():
-    "qutip.Qobj eigenstates"
-    data = np.eye(5)
-    A = qutip.Qobj(data)
-    b, c = A.eigenstates()
-    assert np.all(b == np.ones(5))
-    kets = [qutip.basis(5, k) for k in range(5)]
-    for k in range(5):
-        assert c[k] == kets[k]
-
-
-def test_QobjExpm():
-    "qutip.Qobj expm (dense)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    B = A.expm()
-    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
-
-
-def test_QobjExpmExplicitlySparse():
-    "qutip.Qobj expm (sparse)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    B = A.expm(dtype=qutip.data.CSR)
-    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
-
-
-def test_QobjExpmZeroOper():
-    "qutip.Qobj expm zero_oper (#493)"
-    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
-    B = A.expm()
-    assert B == qutip.qeye(5)
-
-
-def test_QobjLogm():
-    "qutip.Qobj expm (dense)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    B = A.logm()
-    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
-
-
-def test_QobjLogmExplicitlySparse():
-    "qutip.Qobj logm (sparse)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data).to("csr")
-    B = A.logm()
-    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
-
-
-def test_QobjLogmZeroOper():
-    "qutip.Qobj logm zero_oper (#493)"
-    A = qutip.qeye(5)
-    B = A.logm()
-    assert B == qutip.qzero(5)
-
-
-def test_Qobj_sqrtm():
-    "qutip.Qobj sqrtm"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.sqrtm()
-    assert A == B * B
-
-
-def test_Qobj_inv():
-    "qutip.Qobj inv"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.inv()
-    assert qutip.qeye(5) == A * B
-    assert qutip.qeye(5) == B * A
-    B = A.inv(sparse=True)
-    assert qutip.qeye(5) == A * B
-    assert qutip.qeye(5) == B * A
-
-
-def test_QobjFull():
-    "qutip.Qobj full"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    b = A.full()
-    assert np.all(b == data)
-
-
-def test_QobjNorm():
-    "qutip.Qobj norm"
-    # vector L2-norm test
-    N = 20
-    x = np.random.random(N) + 1j*np.random.random(N)
-    A = qutip.Qobj(x)
-    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
-    # vector max (inf) norm test
-    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
-                               atol=1e-12)
-    # operator frobius norm
-    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
-    A = qutip.Qobj(x)
-    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
-                               atol=1e-12)
-    # operator trace norm
-    a = qutip.rand_herm(10, density=0.25)
-    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
-    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
-    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
-
-
-def test_QobjPurity():
-    "Tests the purity method of `qutip.Qobj`"
-    psi = qutip.basis(2, 1)
-    # check purity of pure ket state
-    np.testing.assert_allclose(psi.purity(), 1)
-    # check purity of pure ket state (superposition)
-    psi2 = qutip.basis(2, 0)
-    psi_tot = (psi+psi2).unit()
-    np.testing.assert_allclose(psi_tot.purity(), 1)
-    # check purity of density matrix of pure state
-    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
-    # check purity of maximally mixed density matrix
-    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
-    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
-
-
-def test_QobjPermute(datatype):
-    "qutip.Qobj permute"
-    A = qutip.basis(3, 0, dtype=datatype)
-    B = qutip.basis(5, 4, dtype=datatype)
-    C = qutip.basis(4, 2, dtype=datatype)
-    psi = qutip.tensor(A, B, C)
-    psi2 = psi.permute([2, 0, 1])
-    assert psi2 == qutip.tensor(C, A, B)
-
-    psi_bra = psi.dag()
-    psi2_bra = psi_bra.permute([2, 0, 1])
-    assert psi2_bra == qutip.tensor(C, A, B).dag()
-
-    A = qutip.fock_dm(3, 0, dtype=datatype)
-    B = qutip.fock_dm(5, 4, dtype=datatype)
-    C = qutip.fock_dm(4, 2, dtype=datatype)
-    rho = qutip.tensor(A, B, C)
-    rho2 = rho.permute([2, 0, 1])
-    assert rho2 == qutip.tensor(C, A, B)
-
-    for _ in range(3):
-        A = qutip.rand_ket(3, dtype=datatype)
-        B = qutip.rand_ket(4, dtype=datatype)
-        C = qutip.rand_ket(5, dtype=datatype)
-        psi = qutip.tensor(A, B, C)
-        psi2 = psi.permute([1, 0, 2])
-        assert psi2 == qutip.tensor(B, A, C)
-
-        psi_bra = psi.dag()
-        psi2_bra = psi_bra.permute([1, 0, 2])
-        assert psi2_bra == qutip.tensor(B, A, C).dag()
-
-    for _ in range(3):
-        A = qutip.rand_dm(3, dtype=datatype)
-        B = qutip.rand_dm(4, dtype=datatype)
-        C = qutip.rand_dm(5, dtype=datatype)
-        rho = qutip.tensor(A, B, C)
-        rho2 = rho.permute([1, 0, 2])
-        assert rho2 == qutip.tensor(B, A, C)
-
-        rho_vec = qutip.operator_to_vector(rho)
-        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
-        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
-
-        rho_vec_bra = qutip.operator_to_vector(rho).dag()
-        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
-        assert (rho2_vec_bra
-                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
-
-    for _ in range(3):
-        super_dims = [3, 5, 4]
-        U = qutip.rand_unitary(super_dims, dtype=datatype)
-        Unew = U.permute([2, 1, 0])
-        S_tens = qutip.to_super(U)
-        S_tens_new = qutip.to_super(Unew)
-        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
-
-
-def test_KetType():
-    "qutip.Qobj ket type"
-
-    psi = qutip.basis(2, 1)
-
-    assert psi.isket
-    assert not psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
-
-    assert psi.isket
-    assert not psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-
-def test_BraType():
-    "qutip.Qobj bra type"
-
-    psi = qutip.basis(2, 1).dag()
-    assert not psi.isket
-    assert psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
-    assert not psi.isket
-    assert psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-
-def test_OperType():
-    "qutip.Qobj operator type"
-
-    psi = qutip.basis(2, 1)
-    rho = psi * psi.dag()
-
-    assert not rho.isket
-    assert not rho.isbra
-    assert rho.isoper
-    assert not rho.issuper
-
-
-def test_SuperType():
-    "qutip.Qobj superoperator type"
-
-    psi = qutip.basis(2, 1)
-    rho = psi * psi.dag()
-
-    sop = qutip.spre(rho)
-
-    assert not sop.isket
-    assert not sop.isbra
-    assert not sop.isoper
-    assert sop.issuper
-
-    sop = qutip.spost(rho)
-
-    assert not sop.isket
-    assert not sop.isbra
-    assert not sop.isoper
-    assert sop.issuper
-
-
-@pytest.mark.parametrize("dimension", [2, 4, 8])
-@pytest.mark.parametrize("conversion", [
-    pytest.param(qutip.to_super, id='to_super'),
-    pytest.param(qutip.to_choi, id='to_choi'),
-    pytest.param(qutip.to_chi, id='to_chi'),
-])
-def test_dag_preserves_superrep(dimension, conversion):
-    """
-    Checks that dag() preserves superrep.
-    """
-    qobj = conversion(qutip.rand_super_bcsz(dimension))
-    assert qobj.superrep == qobj.dag().superrep
-
-
-@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
-@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
-    pytest.param(operator.add, True, True, id='add'),
-    pytest.param(operator.sub, True, True, id='sub'),
-    pytest.param(operator.mul, True, True, id='mul'),
-    pytest.param(operator.truediv, False, True, id='div'),
-    pytest.param(qutip.tensor, True, False, id='tensor'),
-])
-def test_arithmetic_preserves_superrep(superrep,
-                                       operation, check_op, check_scalar):
-    """
-    Checks that binary ops preserve 'superrep'.
-
-    .. note::
-
-        The random superoperators are not chosen in a way that reflects the
-        structure of that superrep, but are simply random matrices.
-    """
-    dims = [[[2], [2]], [[2], [2]]]
-    shape = (4, 4)
-    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
-    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
-    x = np.random.random()
-
-    check_list = []
-    if check_op:
-        check_list.append(operation(S1, S2))
-    if check_scalar:
-        check_list.append(operation(S1, x))
-    if check_op and check_scalar:
-        check_list.append(operation(x, S2))
-
-    for S in check_list:
-        assert S.issuper
-        assert S.type == "super"
-        assert S.superrep == superrep
-
-
-def test_isherm_skew():
-    """
-    mul and tensor of skew-Hermitian operators report ``isherm = True``.
-    """
-    iH = 1j * qutip.rand_herm(5)
-    assert_hermicity(iH, False)
-    assert_hermicity(iH * iH, True)
-    assert_hermicity(qutip.tensor(iH, iH), True)
-
-
-def test_super_tensor_operket():
-    """
-    Tensor: Checks that super_tensor respects states.
-    """
-    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
-    qutip.operator_to_vector(rho1)
-    qutip.operator_to_vector(rho2)
-
-
-def test_super_tensor_property():
-    """
-    Tensor: Super_tensor correctly tensors on underlying spaces.
-    """
-    U1 = qutip.rand_unitary(3)
-    U2 = qutip.rand_unitary(5)
-    U = qutip.tensor(U1, U2)
-    S_tens = qutip.to_super(U)
-    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
-    assert S_tens == S_supertens
-    assert S_supertens.superrep == 'super'
-
-
-def test_composite_oper():
-    """
-    Composite: Tests compositing unitaries and superoperators.
-    """
-    U1 = qutip.rand_unitary(3)
-    U2 = qutip.rand_unitary(5)
-    S1 = qutip.to_super(U1)
-    S2 = qutip.to_super(U2)
-    S3 = qutip.rand_super(4)
-    S4 = qutip.rand_super(7)
-
-    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
-    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
-    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
-    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
-
-
-def test_composite_vec():
-    """
-    Composite: Tests compositing states and density operators.
-    """
-    k1 = qutip.rand_ket(5)
-    k2 = qutip.rand_ket(7)
-    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
-    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
-
-    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
-    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
-
-    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
-    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
-    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
-    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
-
-# TODO: move out to a more appropriate module.
-
-
-def trunc_neg_case(qobj, method, expected=None):
-    pos_qobj = qobj.trunc_neg(method=method)
-    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
-    np.testing.assert_allclose(pos_qobj.tr(), 1)
-    if expected is not None:
-        test_array = pos_qobj.full()
-        exp_array = expected.full()
-        np.testing.assert_allclose(test_array, exp_array)
-
-
-class TestTruncNeg:
-    """Test qutip.Qobj.trunc_neg for several different cases."""
-    def test_positive_operator(self):
-        trunc_neg_case(qutip.rand_dm(5), 'clip')
-        trunc_neg_case(qutip.rand_dm(5), 'sgs')
-
-    def test_diagonal_operator(self):
-        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
-        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
-        trunc_neg_case(to_test, 'clip', expected)
-        trunc_neg_case(to_test, 'sgs', expected)
-
-    def test_nondiagonal_operator(self):
-        U = qutip.rand_unitary(3)
-        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
-        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
-        trunc_neg_case(to_test, 'clip', expected)
-        trunc_neg_case(to_test, 'sgs', expected)
-
-    def test_sgs_known_good(self):
-        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
-                       'sgs',
-                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
-
-
-def test_cosm():
-    """
-    Test qutip.Qobj: cosm
-    """
-    A = qutip.rand_herm(5)
-    B = A.cosm().full()
-    C = scipy.linalg.cosm(A.full())
-    np.testing.assert_allclose(B, C, atol=1e-14)
-
-
-def test_sinm():
-    """
-    Test qutip.Qobj: sinm
-    """
-    A = qutip.rand_herm(5)
-    B = A.sinm().full()
-    C = scipy.linalg.sinm(A.full())
-    np.testing.assert_allclose(B, C, atol=1e-14)
-
-
-@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
-def test_dual_channel(sub_dimensions, n_trials=50):
-    """
-    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
-    """
-    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
-    S.dims = [[sub_dimensions, sub_dimensions],
-              [sub_dimensions, sub_dimensions]]
-    S = qutip.to_super(S)
-    left_dims, right_dims = S.dims
-
-    # Assume for the purposes of the test that S maps square operators to
-    # square operators.
-    in_dim = np.prod(right_dims[0])
-    out_dim = np.prod(left_dims[0])
-
-    S_dual = qutip.to_super(S.dual_chan())
-
-    primals = []
-    duals = []
-
-    for _ in [None]*n_trials:
-        X = qutip.rand_dm(out_dim)
-        X.dims = left_dims
-        X = qutip.operator_to_vector(X)
-        Y = qutip.rand_dm(in_dim)
-        Y.dims = right_dims
-        Y = qutip.operator_to_vector(Y)
-
-        primals.append(X.dag() * S * Y)
-        duals.append(X.dag() * S_dual.dag() * Y)
-
-    np.testing.assert_allclose(primals, duals)
-
-
-def test_call():
-    """
-    Test qutip.Qobj: Call
-    """
-    # Make test objects.
-    psi = qutip.rand_ket(3)
-    rho = qutip.rand_dm(3)
-    U = qutip.rand_unitary(3)
-    S = qutip.rand_super_bcsz(3)
-
-    # Case 0: oper(ket).
-    assert U(psi) == U * psi
-    # Case 1: oper(oper). Should raise TypeError.
-    with pytest.raises(TypeError):
-        U(rho)
-    # Case 2: super(ket).
-    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
-    assert S(psi) == expected
-    # Case 3: super(oper).
-    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
-    assert S(rho) == expected
-    # Case 4: super(super). Should raise TypeError.
-    with pytest.raises(TypeError):
-        S(S)
-
-
-def test_mat_elem():
-    """
-    Test qutip.Qobj: Compute matrix elements
-    """
-    for _ in range(10):
-        N = 20
-        H = qutip.rand_herm(N, density=0.2)
-        L = qutip.rand_ket(N, density=0.3)
-        Ld = L.dag()
-        R = qutip.rand_ket(N, density=0.3)
-        ans = Ld * H * R
-        # bra-ket
-        out1 = H.matrix_element(Ld, R)
-        # ket-ket
-        out2 = H.matrix_element(Ld, R)
-        assert abs(ans - out1) < 1e-14
-        assert abs(ans - out2) < 1e-14
-
-
-def test_projection():
-    """
-    Test qutip.Qobj: Projection operator
-    """
-    for _ in range(10):
-        N = 5
-        K = qutip.rand_ket([N, N], density=0.75)
-        B = K.dag()
-        ans = K * K.dag()
-        out1 = K.proj()
-        out2 = B.proj()
-        assert out1 == ans
-        assert out2 == ans
-
-
-def test_overlap():
-    """
-    Test qutip.Qobj: Overlap (inner product)
-    """
-    for _ in range(10):
-        N = 10
-        A = qutip.rand_ket(N, density=0.75)
-        Ad = A.dag()
-        B = qutip.rand_ket(N, density=0.75)
-        Bd = B.dag()
-        ans = A.dag() * B
-        np.testing.assert_allclose(A.overlap(B), ans)
-        np.testing.assert_allclose(Ad.overlap(B), ans)
-        np.testing.assert_allclose(Ad.overlap(Bd), ans)
-        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
-
-
-def test_unit():
-    """
-    Test qutip.Qobj: unit
-    """
-    psi = (10*np.random.randn()*qutip.basis(2, 0)
-           - 10j*np.random.randn()*qutip.basis(2, 1))
-    psi2 = psi.unit()
-    psi.unit(inplace=True)
-    assert psi == psi2
-    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
-
-
-def test_trace():
-    sz = qutip.sigmaz()
-    assert sz.tr() == 0
-
-
-def test_no_real_attribute(monkeypatch):
-    """This tests ensures that trace still works even if the output of a
-    specialisation does not have the ``real`` attribute. This is the case for
-    the tensorflow and cupy data layers."""
-
-    def mocker_trace_return(oper):
-        """
-        We simply return a string which does not have the `real` attribute.
-        """
-        return "object without .real"
-
-    monkeypatch.setattr(_data, "trace", mocker_trace_return)
-
-    sz = qutip.sigmaz() # the choice of the matrix does not matter
-    assert "object without .real" == sz.tr()
-
-
-@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
-@pytest.mark.parametrize(['expanded', 'contracted'], [
-    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
-    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
-    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
-    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
-    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
-                 id='mixed'),
-    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
-                 id='mixed,unchanged'),
-    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
-                 id='mixed,unchanged'),
-    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
-    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
-    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
-                 id='ket,unchanged'),
-    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
-    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
-    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
-                 id='bra,unchanged'),
-    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
-                 id='operket'),
-    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
-                 id='operbra'),
-])
-def test_contract(expanded, contracted, inplace):
-    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    qobj = qutip.Qobj(data, dims=expanded)
-    assert qobj.dims == expanded
-    out = qobj.contract(inplace=inplace)
-    if inplace:
-        assert out is qobj
-    else:
-        assert out is not qobj
-    assert out.dims == contracted
-    assert out.shape == qobj.shape
-    assert np.all(out.full() == qobj.full())
-
-
-@pytest.mark.parametrize(["shape"], [
-    pytest.param((5, 1), id='ket'),
-    pytest.param((5, 2), id='tall'),
-    pytest.param((1, 5), id='bra'),
-    pytest.param((2, 5), id='wide'),
-    pytest.param((3, 3), id='oper'),
-])
-def test_sum_zero(shape):
-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    qobj = qutip.Qobj(data)
-    assert qobj + 0 == qobj
-    assert qobj - 0 == qobj
-    assert 0 + qobj == qobj
-    assert 0 - qobj == -qobj
-
-
-@pytest.mark.parametrize(["shape"], [
-    pytest.param((5, 1), id='ket'),
-    pytest.param((5, 2), id='tall'),
-    pytest.param((1, 5), id='bra'),
-    pytest.param((2, 5), id='wide'),
-    pytest.param((3, 3), id='oper'),
-])
-def test_sum_buildin(shape):
-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    qobj = qutip.Qobj(data)
-    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
-
-
-def test_groundstate():
-    eigenvals = np.sort(np.random.rand(10))
-    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
-    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
-    groundenergy, groundstate = qobj.groundstate()
-    assert groundenergy == pytest.approx(eigenvals[0])
-    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
-    assert groundstate.overlap(groundstate) == pytest.approx(1)
-
-    with pytest.warns(UserWarning) as warning:
-        qutip.qeye(5).groundstate()
-    assert "degenerate" in warning[0].message.args[0]
+import numbers
+import operator
+import pytest
+
+import numpy as np
+import scipy.sparse
+import scipy.linalg
+
+import qutip
+from qutip.core import data as _data
+
+
+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+def datatype(request):
+    return request.param
+
+
+def _random_not_singular(N):
+    """
+    return a N*N complex array with determinant not 0.
+    """
+    data = np.zeros((1, 1))
+    while np.linalg.det(data) == 0:
+        data = np.random.random((N, N)) + \
+               1j * np.random.random((N, N)) - (0.5 + 0.5j)
+    return data
+
+
+def assert_hermicity(oper, hermicity):
+    # Check the cached isherm, if any exists.
+    assert oper.isherm == hermicity
+    # Force a reset of the cached value for isherm.
+    oper._isherm = None
+    # Force a recalculation of isherm.
+    assert oper.isherm == hermicity
+
+
+def test_QobjData():
+    "qutip.Qobj data"
+    N = 10
+    data1 = _random_not_singular(N)
+    q1 = qutip.Qobj(data1)
+    assert isinstance(q1.data, qutip.core.data.Data)
+    assert np.all(q1.data.to_array() == data1)
+
+    data2 = _random_not_singular(N)
+    data2 = scipy.sparse.csr_matrix(data2)
+    q2 = qutip.Qobj(data2)
+    assert isinstance(q2.data, qutip.core.data.Data)
+
+
+@pytest.mark.parametrize("original_data",
+                         [
+                            qutip.data.Dense(_random_not_singular(2)),
+                            qutip.data.csr.identity(2),
+                            qutip.Qobj(_random_not_singular(2)),
+                            _random_not_singular(2),
+                         ],
+                         ids=[
+                             "Dense",
+                             "CSR",
+                             "Qobj",
+                             "ndarray",
+                         ])
+@pytest.mark.parametrize("copy", [True, False],
+                         ids=["copy=True", "copy=False"])
+def test_QobjCopyArgument(original_data, copy):
+    """Tests that Qobj copy argument works properly when instantiating Qobj."""
+    qobj_data = qutip.Qobj(original_data, copy=copy).data
+
+    if isinstance(original_data, qutip.Qobj):
+        # Qobj copies the data of another Qobj, so we take `data` if
+        # original_data was a Qobj
+        original_data = original_data.data
+
+    if isinstance(original_data, np.ndarray):
+        # For numpy object we compare with data's data. This should be dense so
+        # we get its data as ndarray.
+        qobj_data = qobj_data.as_ndarray()
+
+        # We look at the memory and see if it is shared or not to asses wether
+        # copy argument worked or not.
+        assert np.shares_memory(qobj_data, original_data) != copy
+
+    else:
+        assert (original_data is qobj_data) != copy
+
+
+def test_QobjType():
+    "qutip.Qobj type"
+    N = int(np.ceil(10.0 * np.random.random())) + 5
+
+    ket_data = np.random.random((N, 1))
+    ket_qobj = qutip.Qobj(ket_data)
+    assert ket_qobj.type == 'ket'
+    assert ket_qobj.isket
+
+    bra_data = np.random.random((1, N))
+    bra_qobj = qutip.Qobj(bra_data)
+    assert bra_qobj.type == 'bra'
+    assert bra_qobj.isbra
+
+    oper_data = np.random.random((N, N))
+    oper_qobj = qutip.Qobj(oper_data)
+    assert oper_qobj.type == 'oper'
+    assert oper_qobj.isoper
+
+    N = 9
+    super_data = np.random.random((N, N))
+    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
+    assert super_qobj.type == 'super'
+    assert super_qobj.issuper
+    assert super_qobj.superrep == 'super'
+
+    super_data = np.random.random(N)
+    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
+    assert super_qobj.type == 'operator-ket'
+    assert super_qobj.isoperket
+    assert super_qobj.superrep == 'super'
+
+    super_data = np.random.random(N)
+    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
+    assert super_qobj.type == 'operator-bra'
+    assert super_qobj.isoperbra
+    assert super_qobj.superrep == 'super'
+
+    operket_qobj = qutip.operator_to_vector(oper_qobj)
+    assert operket_qobj.isoperket
+    assert operket_qobj.dag().isoperbra
+
+
+class TestQobjHermicity:
+    def test_standard(self):
+        base = _random_not_singular(10)
+        assert_hermicity(qutip.Qobj(base), False)
+        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
+        assert_hermicity(qutip.destroy(5), False)
+        assert_hermicity(qutip.create(5), False)
+
+    def test_addition(self):
+        q_a, q_ad = qutip.destroy(5), qutip.create(5)
+        # test addition of two nonhermitian operators adding up to be hermitian
+        q_x = q_a + q_ad
+        assert_hermicity(q_x, True)
+        # test addition of one hermitan and one nonhermitian operator
+        assert_hermicity(q_x + q_a, False)
+        # test addition of two hermitan operators
+        assert_hermicity(q_x + q_x, True)
+
+    def test_multiplication(self):
+        # Test multiplication of two Hermitian operators.  This results in a
+        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
+        # set wrong metadata.
+        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
+        # Similarly, we need to check that -Z = X * iY is correctly identified
+        # as Hermitian.
+        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
+
+
+def assert_unitarity(oper, unitarity):
+    # Check the cached isunitary.
+    assert oper.isunitary == unitarity
+
+    # Force a reset of the cached value for isunitary.
+    oper._isunitary = None
+    # Force a recalculation of isunitary.
+    assert oper.isunitary == unitarity
+
+
+def test_QobjUnitaryOper():
+    "qutip.Qobj unitarity"
+    # Check some standard operators
+    Sx = qutip.sigmax()
+    Sy = qutip.sigmay()
+    assert_unitarity(qutip.qeye(4), True)
+    assert_unitarity(Sx, True)
+    assert_unitarity(Sy, True)
+    assert_unitarity(qutip.sigmam(), False)
+    assert_unitarity(qutip.destroy(10), False)
+    # Check multiplcation of unitary is unitary
+    assert_unitarity(Sx*Sy, True)
+    # Check some other operations clear unitarity
+    assert_unitarity(Sx+Sy, False)
+    assert_unitarity(4*Sx, False)
+    assert_unitarity(Sx*4, False)
+    assert_unitarity(4+Sx, False)
+    assert_unitarity(Sx+4, False)
+    # Check that when multipliying scalar numbers with absolute value 1 we
+    # maintain unitarity.
+    assert_unitarity(Sx*np.exp(5j), True)
+    assert_unitarity(Sx*1j, True)
+    assert_unitarity(Sx*1, True)
+    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
+    # We do not know if it is unitary until we check the whole matrix again.
+    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
+    # This may be removed in the future as if scalar has abs value of 1 and
+    # matrix is not unitary, output wont be unitary.
+    assert (qutip.sigmam()*1)._isunitary == None
+
+
+def test_QobjDimsShape():
+    "qutip.Qobj shape"
+    N = 10
+    data = _random_not_singular(N)
+
+    q1 = qutip.Qobj(data)
+    assert q1.dims == [[10], [10]]
+    assert q1.shape == (10, 10)
+
+    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
+
+    q1 = qutip.Qobj(data)
+    assert q1.dims == [[10], [1]]
+    assert q1.shape == (10, 1)
+
+    data = _random_not_singular(4)
+
+    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
+    assert q1.dims == [[2, 2], [2, 2]]
+    assert q1.shape == (4, 4)
+
+
+def test_QobjMulNonsquareDims():
+    """
+    qutip.Qobj: multiplication w/ non-square qobj.dims
+
+    Checks for regression of #331.
+    """
+    data = np.array([[0, 1], [1, 0]])
+
+    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
+    q2 = qutip.Qobj(data, dims=[[2], [2]])
+
+    assert (q1 * q2).dims == [[2, 1], [2]]
+    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
+    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
+
+    # Because of the above, we also need to check for extra indices
+    # that aren't of length 1.
+    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
+                     [0.+0.j,  1.+0.j],
+                     [0.+0.j,  1.+0.j],
+                     [1.+0.j,  0.+0.j],
+                     [0.+0.j,  0.-1.j],
+                     [0.+1.j,  0.+0.j],
+                     [1.+0.j,  0.+0.j],
+                     [0.+0.j, -1.+0.j]],
+                    dims=[[4, 2], [2]])
+    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
+
+
+def test_QobjAddition():
+    "qutip.Qobj addition"
+    data1 = np.array([[1, 2], [3, 4]])
+    data2 = np.array([[5, 6], [7, 8]])
+    data3 = data1 + data2
+
+    q1 = qutip.Qobj(data1)
+    q2 = qutip.Qobj(data2)
+    q3 = qutip.Qobj(data3)
+
+    q4 = q1 + q2
+    q4_type = q4.type
+    q4_isherm = q4.isherm
+    q4._type = None
+    q4._isherm = None  # clear cached values
+    assert q4_type == q4.type
+    assert q4_isherm == q4.isherm
+
+    # check elementwise addition/subtraction
+    assert q3 == q4
+
+    # check that addition is commutative
+    assert q1 + q2 == q2 + q1
+
+    data = np.random.random((5, 5))
+    q = qutip.Qobj(data)
+    x1 = q + 5
+    x2 = 5 + q
+    data = data + np.eye(5) * 5
+    assert np.all(x1.full() == data)
+    assert np.all(x2.full() == data)
+
+
+def test_QobjSubtraction():
+    "qutip.Qobj subtraction"
+    data1 = _random_not_singular(5)
+    q1 = qutip.Qobj(data1)
+
+    data2 = _random_not_singular(5)
+    q2 = qutip.Qobj(data2)
+
+    q3 = q1 - q2
+    data3 = data1 - data2
+    assert np.all(q3.full() == data3)
+
+    q4 = q2 - q1
+    data4 = data2 - data1
+    assert np.all(q4.full() == data4)
+
+
+def test_QobjMultiplication():
+    "qutip.Qobj multiplication"
+    data1 = np.array([[1, 2], [3, 4]])
+    data2 = np.array([[5, 6], [7, 8]])
+
+    data3 = np.dot(data1, data2)
+
+    q1 = qutip.Qobj(data1)
+    q2 = qutip.Qobj(data2)
+    q3 = qutip.Qobj(data3)
+
+    q4 = q1 * q2
+
+    assert q3 == q4
+
+
+# Allowed mul operations (scalar)
+@pytest.mark.parametrize("scalar",
+                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+                         ids=[
+                             "python_number",
+                             "scalar_like_array_shape_0",
+                             "scalar_like_array_shape_1",
+                         ])
+def test_QobjMulValidScalar(scalar):
+    "Tests multiplication of Qobj times scalar."
+    data = np.array([[1, 2], [3, 4]])
+    q = qutip.Qobj(data)
+    expect = data * (2+2j)
+
+    # Check __mul__
+    result = q * scalar
+    assert np.all(result.full() == expect)
+
+    # Check __rmul__
+    result = scalar * q
+    assert np.all(result.full() == expect)
+
+
+# We do not allow yet qobj being multiplied by a numpy array that does not
+# represent a scalar. If we include the feature of numpy broadcasting an qobj
+# as scalar, this test should be removed.
+@pytest.mark.parametrize("not_scalar",
+                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
+                         ids=[
+                             "not_scalar_like_vector",
+                             "not_scalar_like_matrix",
+                         ])
+def test_QobjMulNotValidScalar(not_scalar):
+    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+
+    with pytest.raises(TypeError):
+        not_scalar * q1
+
+    with pytest.raises(TypeError):
+        q1 * not_scalar
+
+
+# Allowed division operations (scalar)
+@pytest.mark.parametrize("scalar",
+                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+                         ids=[
+                             "python_number",
+                             "scalar_like_array_shape_0",
+                             "scalar_like_array_shape_1",
+                         ])
+def test_QobjDivisionValidScalar(scalar):
+    "Tests multiplication of Qobj times scalar."
+    data = np.array([[1, 2], [3, 4]])
+    q = qutip.Qobj(data)
+    expect = data / (2+2j)
+
+    # Check __truediv__
+    result = q / scalar
+    assert np.all(result.full() == expect)
+
+
+# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
+# non scalar numpy values. This should also be removed in case of implementing
+# broadcasting rules for Qobj.
+@pytest.mark.parametrize("not_scalar",
+                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
+                         ids=[
+                             "not_scalar_like_vector",
+                             "not_scalar_like_matrix",
+                         ])
+def test_QobjDivisionNotValidScalar(not_scalar):
+    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+
+    with pytest.raises(TypeError):
+        q1 / not_scalar
+
+
+def test_QobjNotImplemented():
+    class MockerScalar():
+        def __mul__(self, other):
+            return "object not accepted by _data.mul, mul"
+
+        def __rmul__(self, other):
+            return "object not accepted by _data.mul, rmul"
+
+        def __rtruediv__(self, other):
+            return "object not accepted by _data.mul, rtruediv"
+
+    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+    scalar = MockerScalar()
+    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
+    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
+    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
+
+def test_QobjDivision():
+    "qutip.Qobj division"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    randN = 10 * np.random.random()
+    q = q / randN
+    assert np.allclose(q.full(), data/randN)
+
+
+def test_QobjPower():
+    "qutip.Qobj power"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
+    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
+
+
+def test_QobjNeg():
+    "qutip.Qobj negation"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    x = -q
+    assert np.all(x.full() == -data)
+    assert q.isherm == x.isherm
+    assert q.type == x.type
+
+
+def test_QobjEquals():
+    "qutip.Qobj equals"
+    data = _random_not_singular(5)
+    q1 = qutip.Qobj(data)
+    q2 = qutip.Qobj(data)
+    assert q1 == q2
+
+    q1 = qutip.Qobj(data)
+    q2 = qutip.Qobj(-data)
+    assert q1 != q2
+
+
+def test_QobjGetItem():
+    "qutip.Qobj getitem"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    assert q[0, 0] == data[0, 0]
+    assert q[-1, 2] == data[-1, 2]
+
+
+def test_CheckMulType():
+    "qutip.Qobj multiplication type"
+    # ket-bra and bra-ket multiplication
+    psi = qutip.basis(5, 0)
+    dm = psi * psi.dag()
+    assert dm.isoper
+    assert dm.isherm
+
+    nrm = psi.dag() * psi
+    assert isinstance(nrm, numbers.Complex)
+    assert abs(nrm) == 1
+
+    # operator-operator multiplication
+    H1 = qutip.rand_herm(3)
+    H2 = qutip.rand_herm(3)
+    out = H1 * H2
+    assert out.isoper
+    out = H1 * H1
+    assert out.isoper
+    assert out.isherm
+    out = H2 * H2
+    assert out.isoper
+    assert out.isherm
+
+    U = qutip.rand_unitary(5)
+    out = U.dag() * U
+    assert out.isoper
+    assert out.isherm
+
+    N = qutip.num(5)
+
+    out = N * N
+    assert out.isoper
+    assert out.isherm
+
+    # operator-ket and bra-operator multiplication
+    op = qutip.sigmax()
+    ket1 = qutip.basis(2, 0)
+    ket2 = op * ket1
+    assert ket2.isket
+
+    bra1 = qutip.basis(2, 0).dag()
+    bra2 = bra1 * op
+    assert bra2.isbra
+
+    assert bra2.dag() == ket2
+
+    # superoperator-operket and operbra-superoperator multiplication
+    sop = qutip.to_super(qutip.sigmax())
+    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
+    opket2 = sop * opket1
+    assert opket2.isoperket
+
+    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
+    opbra2 = opbra1 * sop
+    assert opbra2.isoperbra
+
+    assert opbra2.dag() == opket2
+
+
+def test_operator_ket_superrep():
+    sop = qutip.to_super(qutip.sigmax())
+    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
+    opket2 = sop * opket1
+    assert opket1.superrep == opket2.superrep
+
+    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
+    opbra2 = opbra1 * sop
+    assert opbra1.superrep == opbra2.superrep
+
+
+def test_QobjConjugate():
+    "qutip.Qobj conjugate"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.conj()
+    assert np.all(B.full() == data.conj())
+    assert A.isherm == B.isherm
+    assert A.type == B.type
+    assert A.superrep == B.superrep
+
+
+def test_QobjDagger():
+    "qutip.Qobj adjoint (dagger)"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.dag()
+    assert np.all(B.full() == data.conj().T)
+    assert A.isherm == B.isherm
+    assert A.type == B.type
+    assert A.superrep == B.superrep
+
+
+def test_QobjDiagonals():
+    "qutip.Qobj diagonals"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    b = A.diag()
+    assert np.all(b == np.diag(data))
+
+
+def test_QobjEigenEnergies():
+    "qutip.Qobj eigenenergies"
+    data = np.eye(5)
+    A = qutip.Qobj(data)
+    b = A.eigenenergies()
+    assert np.all(b == np.ones(5))
+
+    data = np.diag(np.arange(10))
+    A = qutip.Qobj(data)
+    b = A.eigenenergies()
+    assert np.all(b == np.arange(10))
+
+    data = np.diag(np.arange(10))
+    A = 5 * qutip.Qobj(data)
+    b = A.eigenenergies()
+    assert np.all(b == 5*np.arange(10))
+
+
+def test_QobjEigenStates():
+    "qutip.Qobj eigenstates"
+    data = np.eye(5)
+    A = qutip.Qobj(data)
+    b, c = A.eigenstates()
+    assert np.all(b == np.ones(5))
+    kets = [qutip.basis(5, k) for k in range(5)]
+    for k in range(5):
+        assert c[k] == kets[k]
+
+
+def test_QobjExpm():
+    "qutip.Qobj expm (dense)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    B = A.expm()
+    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
+
+
+def test_QobjExpmExplicitlySparse():
+    "qutip.Qobj expm (sparse)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    B = A.expm(dtype=qutip.data.CSR)
+    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
+
+
+def test_QobjExpmZeroOper():
+    "qutip.Qobj expm zero_oper (#493)"
+    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
+    B = A.expm()
+    assert B == qutip.qeye(5)
+
+
+def test_QobjLogm():
+    "qutip.Qobj expm (dense)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    B = A.logm()
+    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
+
+
+def test_QobjLogmExplicitlySparse():
+    "qutip.Qobj logm (sparse)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data).to("csr")
+    B = A.logm()
+    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
+
+
+def test_QobjLogmZeroOper():
+    "qutip.Qobj logm zero_oper (#493)"
+    A = qutip.qeye(5)
+    B = A.logm()
+    assert B == qutip.qzero(5)
+
+
+def test_Qobj_sqrtm():
+    "qutip.Qobj sqrtm"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.sqrtm()
+    assert A == B * B
+
+
+def test_Qobj_inv():
+    "qutip.Qobj inv"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.inv()
+    assert qutip.qeye(5) == A * B
+    assert qutip.qeye(5) == B * A
+    B = A.inv(sparse=True)
+    assert qutip.qeye(5) == A * B
+    assert qutip.qeye(5) == B * A
+
+
+def test_QobjFull():
+    "qutip.Qobj full"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    b = A.full()
+    assert np.all(b == data)
+
+
+def test_QobjNorm():
+    "qutip.Qobj norm"
+    # vector L2-norm test
+    N = 20
+    x = np.random.random(N) + 1j*np.random.random(N)
+    A = qutip.Qobj(x)
+    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
+    # vector max (inf) norm test
+    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
+                               atol=1e-12)
+    # operator frobius norm
+    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
+    A = qutip.Qobj(x)
+    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
+                               atol=1e-12)
+    # operator trace norm
+    a = qutip.rand_herm(10, density=0.25)
+    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
+    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
+    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
+
+
+def test_QobjPurity():
+    "Tests the purity method of `qutip.Qobj`"
+    psi = qutip.basis(2, 1)
+    # check purity of pure ket state
+    np.testing.assert_allclose(psi.purity(), 1)
+    # check purity of pure ket state (superposition)
+    psi2 = qutip.basis(2, 0)
+    psi_tot = (psi+psi2).unit()
+    np.testing.assert_allclose(psi_tot.purity(), 1)
+    # check purity of density matrix of pure state
+    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
+    # check purity of maximally mixed density matrix
+    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
+    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
+
+
+def test_QobjPermute(datatype):
+    "qutip.Qobj permute"
+    A = qutip.basis(3, 0, dtype=datatype)
+    B = qutip.basis(5, 4, dtype=datatype)
+    C = qutip.basis(4, 2, dtype=datatype)
+    psi = qutip.tensor(A, B, C)
+    psi2 = psi.permute([2, 0, 1])
+    assert psi2 == qutip.tensor(C, A, B)
+
+    psi_bra = psi.dag()
+    psi2_bra = psi_bra.permute([2, 0, 1])
+    assert psi2_bra == qutip.tensor(C, A, B).dag()
+
+    A = qutip.fock_dm(3, 0, dtype=datatype)
+    B = qutip.fock_dm(5, 4, dtype=datatype)
+    C = qutip.fock_dm(4, 2, dtype=datatype)
+    rho = qutip.tensor(A, B, C)
+    rho2 = rho.permute([2, 0, 1])
+    assert rho2 == qutip.tensor(C, A, B)
+
+    for _ in range(3):
+        A = qutip.rand_ket(3, dtype=datatype)
+        B = qutip.rand_ket(4, dtype=datatype)
+        C = qutip.rand_ket(5, dtype=datatype)
+        psi = qutip.tensor(A, B, C)
+        psi2 = psi.permute([1, 0, 2])
+        assert psi2 == qutip.tensor(B, A, C)
+
+        psi_bra = psi.dag()
+        psi2_bra = psi_bra.permute([1, 0, 2])
+        assert psi2_bra == qutip.tensor(B, A, C).dag()
+
+    for _ in range(3):
+        A = qutip.rand_dm(3, dtype=datatype)
+        B = qutip.rand_dm(4, dtype=datatype)
+        C = qutip.rand_dm(5, dtype=datatype)
+        rho = qutip.tensor(A, B, C)
+        rho2 = rho.permute([1, 0, 2])
+        assert rho2 == qutip.tensor(B, A, C)
+
+        rho_vec = qutip.operator_to_vector(rho)
+        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
+        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
+
+        rho_vec_bra = qutip.operator_to_vector(rho).dag()
+        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
+        assert (rho2_vec_bra
+                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
+
+    for _ in range(3):
+        super_dims = [3, 5, 4]
+        U = qutip.rand_unitary(super_dims, dtype=datatype)
+        Unew = U.permute([2, 1, 0])
+        S_tens = qutip.to_super(U)
+        S_tens_new = qutip.to_super(Unew)
+        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
+
+
+def test_KetType():
+    "qutip.Qobj ket type"
+
+    psi = qutip.basis(2, 1)
+
+    assert psi.isket
+    assert not psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
+
+    assert psi.isket
+    assert not psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+
+def test_BraType():
+    "qutip.Qobj bra type"
+
+    psi = qutip.basis(2, 1).dag()
+    assert not psi.isket
+    assert psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
+    assert not psi.isket
+    assert psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+
+def test_OperType():
+    "qutip.Qobj operator type"
+
+    psi = qutip.basis(2, 1)
+    rho = psi * psi.dag()
+
+    assert not rho.isket
+    assert not rho.isbra
+    assert rho.isoper
+    assert not rho.issuper
+
+
+def test_SuperType():
+    "qutip.Qobj superoperator type"
+
+    psi = qutip.basis(2, 1)
+    rho = psi * psi.dag()
+
+    sop = qutip.spre(rho)
+
+    assert not sop.isket
+    assert not sop.isbra
+    assert not sop.isoper
+    assert sop.issuper
+
+    sop = qutip.spost(rho)
+
+    assert not sop.isket
+    assert not sop.isbra
+    assert not sop.isoper
+    assert sop.issuper
+
+
+@pytest.mark.parametrize("dimension", [2, 4, 8])
+@pytest.mark.parametrize("conversion", [
+    pytest.param(qutip.to_super, id='to_super'),
+    pytest.param(qutip.to_choi, id='to_choi'),
+    pytest.param(qutip.to_chi, id='to_chi'),
+])
+def test_dag_preserves_superrep(dimension, conversion):
+    """
+    Checks that dag() preserves superrep.
+    """
+    qobj = conversion(qutip.rand_super_bcsz(dimension))
+    assert qobj.superrep == qobj.dag().superrep
+
+
+@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
+@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
+    pytest.param(operator.add, True, True, id='add'),
+    pytest.param(operator.sub, True, True, id='sub'),
+    pytest.param(operator.mul, True, True, id='mul'),
+    pytest.param(operator.truediv, False, True, id='div'),
+    pytest.param(qutip.tensor, True, False, id='tensor'),
+])
+def test_arithmetic_preserves_superrep(superrep,
+                                       operation, check_op, check_scalar):
+    """
+    Checks that binary ops preserve 'superrep'.
+
+    .. note::
+
+        The random superoperators are not chosen in a way that reflects the
+        structure of that superrep, but are simply random matrices.
+    """
+    dims = [[[2], [2]], [[2], [2]]]
+    shape = (4, 4)
+    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
+    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
+    x = np.random.random()
+
+    check_list = []
+    if check_op:
+        check_list.append(operation(S1, S2))
+    if check_scalar:
+        check_list.append(operation(S1, x))
+    if check_op and check_scalar:
+        check_list.append(operation(x, S2))
+
+    for S in check_list:
+        assert S.issuper
+        assert S.type == "super"
+        assert S.superrep == superrep
+
+
+def test_isherm_skew():
+    """
+    mul and tensor of skew-Hermitian operators report ``isherm = True``.
+    """
+    iH = 1j * qutip.rand_herm(5)
+    assert_hermicity(iH, False)
+    assert_hermicity(iH * iH, True)
+    assert_hermicity(qutip.tensor(iH, iH), True)
+
+
+def test_super_tensor_operket():
+    """
+    Tensor: Checks that super_tensor respects states.
+    """
+    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
+    qutip.operator_to_vector(rho1)
+    qutip.operator_to_vector(rho2)
+
+
+def test_super_tensor_property():
+    """
+    Tensor: Super_tensor correctly tensors on underlying spaces.
+    """
+    U1 = qutip.rand_unitary(3)
+    U2 = qutip.rand_unitary(5)
+    U = qutip.tensor(U1, U2)
+    S_tens = qutip.to_super(U)
+    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
+    assert S_tens == S_supertens
+    assert S_supertens.superrep == 'super'
+
+
+def test_composite_oper():
+    """
+    Composite: Tests compositing unitaries and superoperators.
+    """
+    U1 = qutip.rand_unitary(3)
+    U2 = qutip.rand_unitary(5)
+    S1 = qutip.to_super(U1)
+    S2 = qutip.to_super(U2)
+    S3 = qutip.rand_super(4)
+    S4 = qutip.rand_super(7)
+
+    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
+    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
+    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
+    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
+
+
+def test_composite_vec():
+    """
+    Composite: Tests compositing states and density operators.
+    """
+    k1 = qutip.rand_ket(5)
+    k2 = qutip.rand_ket(7)
+    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
+    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
+
+    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
+    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
+
+    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
+    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
+    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
+    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
+
+# TODO: move out to a more appropriate module.
+
+
+def trunc_neg_case(qobj, method, expected=None):
+    pos_qobj = qobj.trunc_neg(method=method)
+    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
+    np.testing.assert_allclose(pos_qobj.tr(), 1)
+    if expected is not None:
+        test_array = pos_qobj.full()
+        exp_array = expected.full()
+        np.testing.assert_allclose(test_array, exp_array)
+
+
+class TestTruncNeg:
+    """Test qutip.Qobj.trunc_neg for several different cases."""
+    def test_positive_operator(self):
+        trunc_neg_case(qutip.rand_dm(5), 'clip')
+        trunc_neg_case(qutip.rand_dm(5), 'sgs')
+
+    def test_diagonal_operator(self):
+        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
+        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
+        trunc_neg_case(to_test, 'clip', expected)
+        trunc_neg_case(to_test, 'sgs', expected)
+
+    def test_nondiagonal_operator(self):
+        U = qutip.rand_unitary(3)
+        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
+        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
+        trunc_neg_case(to_test, 'clip', expected)
+        trunc_neg_case(to_test, 'sgs', expected)
+
+    def test_sgs_known_good(self):
+        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
+                       'sgs',
+                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
+
+
+def test_cosm():
+    """
+    Test qutip.Qobj: cosm
+    """
+    A = qutip.rand_herm(5)
+    B = A.cosm().full()
+    C = scipy.linalg.cosm(A.full())
+    np.testing.assert_allclose(B, C, atol=1e-14)
+
+
+def test_sinm():
+    """
+    Test qutip.Qobj: sinm
+    """
+    A = qutip.rand_herm(5)
+    B = A.sinm().full()
+    C = scipy.linalg.sinm(A.full())
+    np.testing.assert_allclose(B, C, atol=1e-14)
+
+
+@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
+def test_dual_channel(sub_dimensions, n_trials=50):
+    """
+    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
+    """
+    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
+    S.dims = [[sub_dimensions, sub_dimensions],
+              [sub_dimensions, sub_dimensions]]
+    S = qutip.to_super(S)
+    left_dims, right_dims = S.dims
+
+    # Assume for the purposes of the test that S maps square operators to
+    # square operators.
+    in_dim = np.prod(right_dims[0])
+    out_dim = np.prod(left_dims[0])
+
+    S_dual = qutip.to_super(S.dual_chan())
+
+    primals = []
+    duals = []
+
+    for _ in [None]*n_trials:
+        X = qutip.rand_dm(out_dim)
+        X.dims = left_dims
+        X = qutip.operator_to_vector(X)
+        Y = qutip.rand_dm(in_dim)
+        Y.dims = right_dims
+        Y = qutip.operator_to_vector(Y)
+
+        primals.append(X.dag() * S * Y)
+        duals.append(X.dag() * S_dual.dag() * Y)
+
+    np.testing.assert_allclose(primals, duals)
+
+
+def test_call():
+    """
+    Test qutip.Qobj: Call
+    """
+    # Make test objects.
+    psi = qutip.rand_ket(3)
+    rho = qutip.rand_dm(3)
+    U = qutip.rand_unitary(3)
+    S = qutip.rand_super_bcsz(3)
+
+    # Case 0: oper(ket).
+    assert U(psi) == U * psi
+    # Case 1: oper(oper). Should raise TypeError.
+    with pytest.raises(TypeError):
+        U(rho)
+    # Case 2: super(ket).
+    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
+    assert S(psi) == expected
+    # Case 3: super(oper).
+    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
+    assert S(rho) == expected
+    # Case 4: super(super). Should raise TypeError.
+    with pytest.raises(TypeError):
+        S(S)
+
+
+def test_mat_elem():
+    """
+    Test qutip.Qobj: Compute matrix elements
+    """
+    for _ in range(10):
+        N = 20
+        H = qutip.rand_herm(N, density=0.2)
+        L = qutip.rand_ket(N, density=0.3)
+        Ld = L.dag()
+        R = qutip.rand_ket(N, density=0.3)
+        ans = Ld * H * R
+        # bra-ket
+        out1 = H.matrix_element(Ld, R)
+        # ket-ket
+        out2 = H.matrix_element(Ld, R)
+        assert abs(ans - out1) < 1e-14
+        assert abs(ans - out2) < 1e-14
+
+
+def test_projection():
+    """
+    Test qutip.Qobj: Projection operator
+    """
+    for _ in range(10):
+        N = 5
+        K = qutip.rand_ket([N, N], density=0.75)
+        B = K.dag()
+        ans = K * K.dag()
+        out1 = K.proj()
+        out2 = B.proj()
+        assert out1 == ans
+        assert out2 == ans
+
+
+def test_overlap():
+    """
+    Test qutip.Qobj: Overlap (inner product)
+    """
+    for _ in range(10):
+        N = 10
+        A = qutip.rand_ket(N, density=0.75)
+        Ad = A.dag()
+        B = qutip.rand_ket(N, density=0.75)
+        Bd = B.dag()
+        ans = A.dag() * B
+        np.testing.assert_allclose(A.overlap(B), ans)
+        np.testing.assert_allclose(Ad.overlap(B), ans)
+        np.testing.assert_allclose(Ad.overlap(Bd), ans)
+        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
+
+
+def test_unit():
+    """
+    Test qutip.Qobj: unit
+    """
+    psi = (10*np.random.randn()*qutip.basis(2, 0)
+           - 10j*np.random.randn()*qutip.basis(2, 1))
+    psi2 = psi.unit()
+    psi.unit(inplace=True)
+    assert psi == psi2
+    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
+
+
+def test_trace():
+    sz = qutip.sigmaz()
+    assert sz.tr() == 0
+
+
+def test_no_real_attribute(monkeypatch):
+    """This tests ensures that trace still works even if the output of a
+    specialisation does not have the ``real`` attribute. This is the case for
+    the tensorflow and cupy data layers."""
+
+    def mocker_trace_return(oper):
+        """
+        We simply return a string which does not have the `real` attribute.
+        """
+        return "object without .real"
+
+    monkeypatch.setattr(_data, "trace", mocker_trace_return)
+
+    sz = qutip.sigmaz() # the choice of the matrix does not matter
+    assert "object without .real" == sz.tr()
+
+
+@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
+@pytest.mark.parametrize(['expanded', 'contracted'], [
+    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
+    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
+    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
+    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
+    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
+                 id='mixed'),
+    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
+                 id='mixed,unchanged'),
+    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
+                 id='mixed,unchanged'),
+    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
+    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
+    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
+                 id='ket,unchanged'),
+    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
+    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
+    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
+                 id='bra,unchanged'),
+    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
+                 id='operket'),
+    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
+                 id='operbra'),
+])
+def test_contract(expanded, contracted, inplace):
+    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    qobj = qutip.Qobj(data, dims=expanded)
+    assert qobj.dims == expanded
+    out = qobj.contract(inplace=inplace)
+    if inplace:
+        assert out is qobj
+    else:
+        assert out is not qobj
+    assert out.dims == contracted
+    assert out.shape == qobj.shape
+    assert np.all(out.full() == qobj.full())
+
+
+@pytest.mark.parametrize(["shape"], [
+    pytest.param((5, 1), id='ket'),
+    pytest.param((5, 2), id='tall'),
+    pytest.param((1, 5), id='bra'),
+    pytest.param((2, 5), id='wide'),
+    pytest.param((3, 3), id='oper'),
+])
+def test_sum_zero(shape):
+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    qobj = qutip.Qobj(data)
+    assert qobj + 0 == qobj
+    assert qobj - 0 == qobj
+    assert 0 + qobj == qobj
+    assert 0 - qobj == -qobj
+
+
+@pytest.mark.parametrize(["shape"], [
+    pytest.param((5, 1), id='ket'),
+    pytest.param((5, 2), id='tall'),
+    pytest.param((1, 5), id='bra'),
+    pytest.param((2, 5), id='wide'),
+    pytest.param((3, 3), id='oper'),
+])
+def test_sum_buildin(shape):
+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    qobj = qutip.Qobj(data)
+    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
+
+
+def test_groundstate():
+    eigenvals = np.sort(np.random.rand(10))
+    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
+    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
+    groundenergy, groundstate = qobj.groundstate()
+    assert groundenergy == pytest.approx(eigenvals[0])
+    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
+    assert groundstate.overlap(groundstate) == pytest.approx(1)
+
+    with pytest.warns(UserWarning) as warning:
+        qutip.qeye(5).groundstate()
+    assert "degenerate" in warning[0].message.args[0]
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index 77fe8fba93..dbcb397903 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -1,515 +1,515 @@
-import operator
-
-import pytest
-from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
-                   rand_stochastic, rand_herm, rand_ket, liouvillian,
-                   basis, spre, spost, to_choi)
-import numpy as np
-from numpy.testing import assert_allclose
-
-from qutip.core import data as _data
-
-# prepare coefficient
-class Pseudo_qevo:
-    # Mimic QobjEvo on __call__
-    # and can return parameter to create the equivalent QobjEvo
-    # for each coefficient type
-    def __init__(self, cte, qobj, func, string, args):
-        self.cte = cte
-        self.qobj = qobj
-        self.func = func
-        self.str = string
-        self.args = args
-
-    def array(self):
-        tlist = np.linspace(0, 10, 10001)
-        coeff = self.func(tlist, self.args)
-        return ([self.cte, [self.qobj, coeff]], {}, tlist)
-
-    def logarray(self):
-        tlist = np.logspace(-3, 1, 10001)
-        coeff = self.func(tlist, self.args)
-        return ([self.cte, [self.qobj, coeff]], {}, tlist)
-
-    def func_coeff(self):
-        return ([self.cte, [self.qobj, self.func]], self.args)
-
-    def string(self):
-        return ([self.cte, [self.qobj, self.str]], self.args)
-
-    def func_call(self):
-        return (self.__call__, self.args)
-
-    def __call__(self, t, args={}):
-        args = args or self.args
-        return self.cte + self.qobj * self.func(t, args)
-
-    def __getitem__(self, which):
-        return getattr(self, which)()
-
-
-N = 3
-args = {'w1': 1, "w2": 2}
-TESTTIMES = np.linspace(0.001, 1.0, 10)
-
-
-def _real(t, args):
-    return np.sin(t*args['w1'])
-
-
-def _cplx(t, args):
-    return np.exp(1j*t*args['w2'])
-
-
-real_qevo = Pseudo_qevo(
-    rand_stochastic(N).to(_data.CSR),
-    rand_stochastic(N).to(_data.CSR),
-    _real, "sin(t*w1)", args)
-
-herm_qevo = Pseudo_qevo(
-    rand_herm(N).to(_data.Dense),
-    rand_herm(N).to(_data.Dense),
-    _real, "sin(t*w1)", args)
-
-cplx_qevo = Pseudo_qevo(
-    rand_stochastic(N).to(_data.Dense),
-    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
-    _cplx, "exp(1j*t*w2)", args)
-
-
-@pytest.fixture(params=['func_coeff', 'string',
-                        'array', 'logarray', 'func_call'])
-def coeff_type(request):
-    # all available QobjEvo types
-    return request.param
-
-
-@pytest.fixture(params=[
-    pytest.param(real_qevo, id="real"),
-    pytest.param(herm_qevo, id="hermitian"),
-    pytest.param(cplx_qevo, id="complex"),
-])
-def pseudo_qevo(request):
-    return request.param
-
-
-@pytest.fixture
-def all_qevo(pseudo_qevo, coeff_type):
-    return QobjEvo(*pseudo_qevo[coeff_type])
-
-
-@pytest.fixture
-def other_qevo(all_qevo):
-    return all_qevo
-
-
-def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
-
-
-def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
-    assert obj1.dims == obj2.dims
-    assert obj1.shape == obj2.shape
-    assert obj1.type == obj2.type
-    assert _data.iszero((obj1 - obj2).data, tol)
-
-
-def _assert_qobjevo_different(obj1, obj2):
-    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
-
-
-def _div(a, b):
-    return a / b
-
-
-def test_call(pseudo_qevo, coeff_type):
-    # test creation of QobjEvo and call
-    qevo = QobjEvo(*pseudo_qevo[coeff_type])
-    assert isinstance(qevo(0), Qobj)
-    assert qevo.isoper
-    assert not qevo.isconstant
-    assert not qevo.issuper
-    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
-
-
-# Test the QobjEvo.__repr__()
-def test_QobjEvo_repr():
-    # case_n: cases with Objects of QobjEvo with unique __repr__
-    # expected_repr_n: are the Expected result from the __repr__
-
-    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
-    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
-    expected_repr_1 += 'type = oper, superrep = None, '
-    expected_repr_1 += 'isconstant = False, num_elements = 1'
-    assert case_1 == expected_repr_1
-
-    case_2 = repr(QobjEvo(qeye(2)))
-    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
-    expected_repr_2 += 'type = oper, superrep = None, '
-    expected_repr_2 += 'isconstant = True, num_elements = 1'
-    assert case_2 == expected_repr_2
-
-    case_3 = repr(QobjEvo(basis(5, 2)))
-    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
-    expected_repr_3 += 'type = ket, superrep = None, '
-    expected_repr_3 += 'isconstant = True, num_elements = 1'
-    assert case_3 == expected_repr_3
-
-    X = sigmax()
-    S = spre(X) * spost(X.dag())
-    case_4 = repr(QobjEvo(to_choi(S)))
-    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
-    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
-    expected_repr_4 += 'isconstant = True, num_elements = 1'
-    assert case_4 == expected_repr_4
-
-    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
-                           [qeye(4), lambda t: t]], compress=False))
-    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
-    expected_repr_5 += 'type = oper, superrep = None, '
-    expected_repr_5 += 'isconstant = False, num_elements = 2'
-    assert case_5 == expected_repr_5
-
-
-@pytest.mark.parametrize('coeff_type',
-                         ['func_coeff', 'string', 'array', 'logarray'])
-def test_product_coeff(pseudo_qevo, coeff_type):
-    # test creation of QobjEvo with Qobj * Coefficient
-    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
-    base = pseudo_qevo[coeff_type]
-    cte, [qobj, coeff] = base[0]
-    args = base[1] if len(base) >= 2 else {}
-    tlist = base[2] if len(base) >= 3 else None
-    coeff = coefficient(coeff, args=args, tlist=tlist)
-    created = cte + qobj * coeff
-    _assert_qobjevo_equivalent(pseudo_qevo, created)
-
-def test_copy(all_qevo):
-    qevo = all_qevo
-    copy = qevo.copy()
-    _assert_qobjevo_equivalent(copy, qevo)
-    assert copy is not qevo
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(lambda a, b: a + b, id="add"),
-    pytest.param(lambda a, b: a - b, id="sub"),
-    pytest.param(lambda a, b: a * b, id="mul"),
-    pytest.param(lambda a, b: a @ b, id="matmul"),
-    pytest.param(lambda a, b: a & b, id="tensor"),
-])
-def test_binopt(all_qevo, other_qevo, bin_op):
-    "QobjEvo arithmetic"
-    obj1 = all_qevo
-    obj2 = other_qevo
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj1, obj2)(t)
-        as_qobj = bin_op(obj1(t), obj2(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(operator.iadd, id="add"),
-    pytest.param(operator.isub, id="sub"),
-    pytest.param(operator.imul, id="mul"),
-    pytest.param(operator.imatmul, id="matmul"),
-    pytest.param(operator.iand, id="tensor"),
-])
-def test_binopt_inplace(all_qevo, other_qevo, bin_op):
-    obj1 = all_qevo
-    obj2 = other_qevo
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj1.copy(), obj2)(t)
-        as_qobj = bin_op(obj1(t).copy(), obj2(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(lambda a, b: a + b, id="add"),
-    pytest.param(lambda a, b: a - b, id="sub"),
-    pytest.param(lambda a, b: a * b, id="mul"),
-    pytest.param(lambda a, b: a @ b, id="matmul"),
-    pytest.param(lambda a, b: a & b, id="tensor"),
-])
-def test_binopt_qobj(all_qevo, bin_op):
-    "QobjEvo arithmetic"
-    obj = all_qevo
-    qobj = rand_herm(N)
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj, qobj)(t)
-        as_qobj = bin_op(obj(t), qobj)
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-        as_qevo = bin_op(qobj, obj)(t)
-        as_qobj = bin_op(qobj, obj(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(lambda a, b: a + b, id="add"),
-    pytest.param(lambda a, b: a - b, id="sub"),
-    pytest.param(lambda a, b: a * b, id="mul"),
-    pytest.param(_div, id="div"),
-])
-def test_binopt_scalar(all_qevo, bin_op):
-    "QobjEvo arithmetic"
-    obj = all_qevo
-    scalar = 0.5 + 1j
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj, scalar)(t)
-        as_qobj = bin_op(obj(t), scalar)
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-        if bin_op is not _div:
-            as_qevo = bin_op(scalar, obj)(t)
-            as_qobj = bin_op(scalar, obj(t))
-            _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-def binop_coeff(all_qevo):
-    obj = all_qevo
-    coeff = coeffient("t")
-    created = obj * coeff_t
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(created(t), obj(t) * t)
-
-
-@pytest.mark.parametrize('unary_op', [
-    pytest.param(lambda a: a.conj(), id="conj"),
-    pytest.param(lambda a: a.dag(), id="dag"),
-    pytest.param(lambda a: a.trans(), id="trans"),
-    pytest.param(lambda a: -a, id="neg"),
-])
-def test_unary(all_qevo, unary_op):
-    "QobjEvo arithmetic"
-    obj = all_qevo
-    for t in TESTTIMES:
-        as_qevo = unary_op(obj)(t)
-        as_qobj = unary_op(obj(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('args_coeff_type',
-                         ['func_coeff', 'string', 'func_call'])
-def test_args(pseudo_qevo, args_coeff_type):
-    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
-    args = {'w1': 3, "w2": 3}
-
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
-        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
-
-    # Did it modify original args
-    _assert_qobjevo_equivalent(obj, pseudo_qevo)
-
-    obj.arguments(args)
-    _assert_qobjevo_different(obj, pseudo_qevo)
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
-
-    args = {'w1': 4, "w2": 4}
-    obj.arguments(**args)
-    _assert_qobjevo_different(obj, pseudo_qevo)
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
-
-
-def test_copy_side_effects(all_qevo):
-    t = 0.2
-    qevo = all_qevo
-    copy = qevo.copy()
-    before = qevo(t)
-    # Ensure inplace modification of the copy do not affect the original
-    copy *= 2
-    copy += rand_herm(N)
-    copy *= rand_herm(N)
-    copy.arguments({'w1': 3, "w2": 3})
-    after = qevo(t)
-    _assert_qobj_almost_eq(before, after)
-
-
-@pytest.mark.parametrize('coeff_type',
-    ['func_coeff', 'string', 'array', 'logarray']
-)
-def test_tidyup(all_qevo):
-    "QobjEvo tidyup"
-    obj = all_qevo
-    obj *= 1e-12
-    obj.tidyup(atol=1e-8)
-    t = 0.2
-    # check that the Qobj are cleaned
-    assert_allclose(obj(t).full(), 0)
-
-
-def test_QobjEvo_pickle(all_qevo):
-    "QobjEvo pickle"
-    # used in parallel_map
-    import pickle
-    obj = all_qevo
-    pickled = pickle.dumps(obj, -1)
-    recreated = pickle.loads(pickled)
-    _assert_qobjevo_equivalent(recreated, obj)
-
-
-def test_QobjEvo_restore(all_qevo):
-    "QobjEvo pickle"
-    # used in parallel_map
-    obj = all_qevo
-    state = obj._getstate()
-    recreated = QobjEvo._restore(**state)
-    _assert_qobjevo_equivalent(recreated, obj)
-
-
-def test_mul_vec(all_qevo):
-    "QobjEvo matmul ket"
-    vec = Qobj(np.arange(N)*.5+.5j)
-    op = all_qevo
-    for t in TESTTIMES:
-        assert_allclose((op(t) @ vec).full(),
-                        op.matmul(t, vec).full(), atol=1e-14)
-
-
-def test_matmul(all_qevo):
-    "QobjEvo matmul oper"
-    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
-    matDense = Qobj(mat).to(_data.Dense)
-    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
-    matCSR = Qobj(mat).to(_data.CSR)
-    op = all_qevo
-    for t in TESTTIMES:
-        Qo1 = op(t)
-        assert_allclose((Qo1 @ mat).full(),
-                        op.matmul(t, matF).full(), atol=1e-14)
-        assert_allclose((Qo1 @ mat).full(),
-                        op.matmul(t, matDense).full(), atol=1e-14)
-        assert_allclose((Qo1 @ mat).full(),
-                        op.matmul(t, matCSR).full(), atol=1e-14)
-
-
-def test_expect_psi(all_qevo):
-    "QobjEvo expect psi"
-    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
-    qobj = Qobj(vec)
-    op = all_qevo
-    for t in TESTTIMES:
-        Qo1 = op(t)
-        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
-                        atol=1e-14)
-
-
-def test_expect_rho(all_qevo):
-    "QobjEvo expect rho"
-    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
-                                      + 1j * np.random.rand(N*N))
-    mat = _data.column_unstack_dense(vec, N)
-    qobj = Qobj(mat)
-    op = liouvillian(all_qevo)
-    for t in TESTTIMES:
-        Qo1 = op(t)
-        assert abs(_data.expect_super(Qo1.data, vec)
-                   - op.expect(t, qobj)) < 1e-14
-
-
-@pytest.mark.parametrize('dtype',
-[pytest.param(dtype, id=dtype.__name__)
-     for dtype in _data.to.dtypes])
-def test_convert(all_qevo, dtype):
-    "QobjEvo expect rho"
-    op = all_qevo.to(dtype)
-    assert isinstance(op(0.5).data, dtype)
-
-
-def test_compress():
-    "QobjEvo compress"
-    obj1 = QobjEvo(
-        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
-    assert obj1.num_elements == 1
-    obj2 = QobjEvo(
-        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
-    assert obj2.num_elements == 3
-    _assert_qobjevo_equivalent(obj1, obj2)
-    obj3 = obj2.copy()
-    assert obj3.num_elements == 3
-    obj3.compress()
-    assert obj3.num_elements == 1
-    _assert_qobjevo_equivalent(obj2, obj3)
-
-
-@pytest.mark.parametrize(['qobjdtype'],
-    [pytest.param(dtype, id=dtype.__name__)
-     for dtype in _data.to.dtypes])
-@pytest.mark.parametrize(['statedtype'],
-    [pytest.param(dtype, id=dtype.__name__)
-     for dtype in _data.to.dtypes])
-def test_layer_support(qobjdtype, statedtype):
-    N = 10
-    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
-    state_dense = rand_ket(N).to(_data.Dense)
-    state = state_dense.to(statedtype).data
-    state_dense = state_dense.data
-    exp_any = qevo.expect_data(0, state)
-    exp_dense = qevo.expect_data(0, state_dense)
-    assert_allclose(exp_any, exp_dense)
-    mul_any = qevo.matmul_data(0, state).to_array()
-    mul_dense = qevo.matmul_data(0, state_dense).to_array()
-    assert_allclose(mul_any, mul_dense)
-
-
-def test_QobjEvo_step_coeff():
-    "QobjEvo step interpolation"
-    coeff1 = np.random.rand(6)
-    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
-    # uniform t
-    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
-    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
-                      tlist=tlist, order=0)
-    assert qobjevo(2.0)[0,0] == coeff1[0]
-    assert qobjevo(7.0)[0,0] == coeff1[5]
-    assert qobjevo(5.0001)[0,0] == coeff1[3]
-    assert qobjevo(3.9999)[0,0] == coeff1[1]
-
-    assert qobjevo(2.0)[0,1] == coeff2[0]
-    assert qobjevo(7.0)[0,1] == coeff2[5]
-    assert qobjevo(5.0001)[0,1] == coeff2[3]
-    assert qobjevo(3.9999)[0,1] == coeff2[1]
-
-    # non-uniform t
-    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
-    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
-        tlist=tlist, order=0)
-    assert qobjevo(1.0)[0,0] == coeff1[0]
-    assert qobjevo(8.0)[0,0] == coeff1[5]
-    assert qobjevo(3.9999)[0,0] == coeff1[1]
-    assert qobjevo(4.23)[0,0] == coeff1[2]
-    assert qobjevo(1.23)[0,0] == coeff1[0]
-
-    assert qobjevo(1.0)[0,1] == coeff2[0]
-    assert qobjevo(8.0)[0,1] == coeff2[5]
-    assert qobjevo(6.7)[0,1] == coeff2[4]
-    assert qobjevo(7.9999)[0,1] == coeff2[4]
-    assert qobjevo(3.9999)[0,1] == coeff2[1]
-
-
-def test_QobjEvo_isherm_flag_knowcase():
-    assert QobjEvo(sigmax())(0)._isherm is True
-    non_hermitian = sigmax() + 1j
-    non_hermitian.isherm  # set flag
-    assert QobjEvo(non_hermitian)(0)._isherm is False
-    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
-    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
-    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
-    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
-    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
-
-
-@pytest.mark.parametrize(
-    "coeff_type",
-    ['func_coeff', 'string', 'array', 'logarray']
-)
-def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
-    qevo = QobjEvo(*pseudo_qevo[coeff_type])
-    as_list = qevo.to_list()
-    assert len(as_list) == 2
-    restored = QobjEvo(as_list)
-    _assert_qobjevo_equivalent(qevo, restored)
+import operator
+
+import pytest
+from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
+                   rand_stochastic, rand_herm, rand_ket, liouvillian,
+                   basis, spre, spost, to_choi)
+import numpy as np
+from numpy.testing import assert_allclose
+
+from qutip.core import data as _data
+
+# prepare coefficient
+class Pseudo_qevo:
+    # Mimic QobjEvo on __call__
+    # and can return parameter to create the equivalent QobjEvo
+    # for each coefficient type
+    def __init__(self, cte, qobj, func, string, args):
+        self.cte = cte
+        self.qobj = qobj
+        self.func = func
+        self.str = string
+        self.args = args
+
+    def array(self):
+        tlist = np.linspace(0, 10, 10001)
+        coeff = self.func(tlist, self.args)
+        return ([self.cte, [self.qobj, coeff]], {}, tlist)
+
+    def logarray(self):
+        tlist = np.logspace(-3, 1, 10001)
+        coeff = self.func(tlist, self.args)
+        return ([self.cte, [self.qobj, coeff]], {}, tlist)
+
+    def func_coeff(self):
+        return ([self.cte, [self.qobj, self.func]], self.args)
+
+    def string(self):
+        return ([self.cte, [self.qobj, self.str]], self.args)
+
+    def func_call(self):
+        return (self.__call__, self.args)
+
+    def __call__(self, t, args={}):
+        args = args or self.args
+        return self.cte + self.qobj * self.func(t, args)
+
+    def __getitem__(self, which):
+        return getattr(self, which)()
+
+
+N = 3
+args = {'w1': 1, "w2": 2}
+TESTTIMES = np.linspace(0.001, 1.0, 10)
+
+
+def _real(t, args):
+    return np.sin(t*args['w1'])
+
+
+def _cplx(t, args):
+    return np.exp(1j*t*args['w2'])
+
+
+real_qevo = Pseudo_qevo(
+    rand_stochastic(N).to(_data.CSR),
+    rand_stochastic(N).to(_data.CSR),
+    _real, "sin(t*w1)", args)
+
+herm_qevo = Pseudo_qevo(
+    rand_herm(N).to(_data.Dense),
+    rand_herm(N).to(_data.Dense),
+    _real, "sin(t*w1)", args)
+
+cplx_qevo = Pseudo_qevo(
+    rand_stochastic(N).to(_data.Dense),
+    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
+    _cplx, "exp(1j*t*w2)", args)
+
+
+@pytest.fixture(params=['func_coeff', 'string',
+                        'array', 'logarray', 'func_call'])
+def coeff_type(request):
+    # all available QobjEvo types
+    return request.param
+
+
+@pytest.fixture(params=[
+    pytest.param(real_qevo, id="real"),
+    pytest.param(herm_qevo, id="hermitian"),
+    pytest.param(cplx_qevo, id="complex"),
+])
+def pseudo_qevo(request):
+    return request.param
+
+
+@pytest.fixture
+def all_qevo(pseudo_qevo, coeff_type):
+    return QobjEvo(*pseudo_qevo[coeff_type])
+
+
+@pytest.fixture
+def other_qevo(all_qevo):
+    return all_qevo
+
+
+def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
+
+
+def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
+    assert obj1.dims == obj2.dims
+    assert obj1.shape == obj2.shape
+    assert obj1.type == obj2.type
+    assert _data.iszero((obj1 - obj2).data, tol)
+
+
+def _assert_qobjevo_different(obj1, obj2):
+    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
+
+
+def _div(a, b):
+    return a / b
+
+
+def test_call(pseudo_qevo, coeff_type):
+    # test creation of QobjEvo and call
+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+    assert isinstance(qevo(0), Qobj)
+    assert qevo.isoper
+    assert not qevo.isconstant
+    assert not qevo.issuper
+    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
+
+
+# Test the QobjEvo.__repr__()
+def test_QobjEvo_repr():
+    # case_n: cases with Objects of QobjEvo with unique __repr__
+    # expected_repr_n: are the Expected result from the __repr__
+
+    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
+    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
+    expected_repr_1 += 'type = oper, superrep = None, '
+    expected_repr_1 += 'isconstant = False, num_elements = 1'
+    assert case_1 == expected_repr_1
+
+    case_2 = repr(QobjEvo(qeye(2)))
+    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
+    expected_repr_2 += 'type = oper, superrep = None, '
+    expected_repr_2 += 'isconstant = True, num_elements = 1'
+    assert case_2 == expected_repr_2
+
+    case_3 = repr(QobjEvo(basis(5, 2)))
+    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
+    expected_repr_3 += 'type = ket, superrep = None, '
+    expected_repr_3 += 'isconstant = True, num_elements = 1'
+    assert case_3 == expected_repr_3
+
+    X = sigmax()
+    S = spre(X) * spost(X.dag())
+    case_4 = repr(QobjEvo(to_choi(S)))
+    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
+    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
+    expected_repr_4 += 'isconstant = True, num_elements = 1'
+    assert case_4 == expected_repr_4
+
+    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
+                           [qeye(4), lambda t: t]], compress=False))
+    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
+    expected_repr_5 += 'type = oper, superrep = None, '
+    expected_repr_5 += 'isconstant = False, num_elements = 2'
+    assert case_5 == expected_repr_5
+
+
+@pytest.mark.parametrize('coeff_type',
+                         ['func_coeff', 'string', 'array', 'logarray'])
+def test_product_coeff(pseudo_qevo, coeff_type):
+    # test creation of QobjEvo with Qobj * Coefficient
+    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
+    base = pseudo_qevo[coeff_type]
+    cte, [qobj, coeff] = base[0]
+    args = base[1] if len(base) >= 2 else {}
+    tlist = base[2] if len(base) >= 3 else None
+    coeff = coefficient(coeff, args=args, tlist=tlist)
+    created = cte + qobj * coeff
+    _assert_qobjevo_equivalent(pseudo_qevo, created)
+
+def test_copy(all_qevo):
+    qevo = all_qevo
+    copy = qevo.copy()
+    _assert_qobjevo_equivalent(copy, qevo)
+    assert copy is not qevo
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(lambda a, b: a + b, id="add"),
+    pytest.param(lambda a, b: a - b, id="sub"),
+    pytest.param(lambda a, b: a * b, id="mul"),
+    pytest.param(lambda a, b: a @ b, id="matmul"),
+    pytest.param(lambda a, b: a & b, id="tensor"),
+])
+def test_binopt(all_qevo, other_qevo, bin_op):
+    "QobjEvo arithmetic"
+    obj1 = all_qevo
+    obj2 = other_qevo
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj1, obj2)(t)
+        as_qobj = bin_op(obj1(t), obj2(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(operator.iadd, id="add"),
+    pytest.param(operator.isub, id="sub"),
+    pytest.param(operator.imul, id="mul"),
+    pytest.param(operator.imatmul, id="matmul"),
+    pytest.param(operator.iand, id="tensor"),
+])
+def test_binopt_inplace(all_qevo, other_qevo, bin_op):
+    obj1 = all_qevo
+    obj2 = other_qevo
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj1.copy(), obj2)(t)
+        as_qobj = bin_op(obj1(t).copy(), obj2(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(lambda a, b: a + b, id="add"),
+    pytest.param(lambda a, b: a - b, id="sub"),
+    pytest.param(lambda a, b: a * b, id="mul"),
+    pytest.param(lambda a, b: a @ b, id="matmul"),
+    pytest.param(lambda a, b: a & b, id="tensor"),
+])
+def test_binopt_qobj(all_qevo, bin_op):
+    "QobjEvo arithmetic"
+    obj = all_qevo
+    qobj = rand_herm(N)
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj, qobj)(t)
+        as_qobj = bin_op(obj(t), qobj)
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+        as_qevo = bin_op(qobj, obj)(t)
+        as_qobj = bin_op(qobj, obj(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(lambda a, b: a + b, id="add"),
+    pytest.param(lambda a, b: a - b, id="sub"),
+    pytest.param(lambda a, b: a * b, id="mul"),
+    pytest.param(_div, id="div"),
+])
+def test_binopt_scalar(all_qevo, bin_op):
+    "QobjEvo arithmetic"
+    obj = all_qevo
+    scalar = 0.5 + 1j
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj, scalar)(t)
+        as_qobj = bin_op(obj(t), scalar)
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+        if bin_op is not _div:
+            as_qevo = bin_op(scalar, obj)(t)
+            as_qobj = bin_op(scalar, obj(t))
+            _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+def binop_coeff(all_qevo):
+    obj = all_qevo
+    coeff = coeffient("t")
+    created = obj * coeff_t
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(created(t), obj(t) * t)
+
+
+@pytest.mark.parametrize('unary_op', [
+    pytest.param(lambda a: a.conj(), id="conj"),
+    pytest.param(lambda a: a.dag(), id="dag"),
+    pytest.param(lambda a: a.trans(), id="trans"),
+    pytest.param(lambda a: -a, id="neg"),
+])
+def test_unary(all_qevo, unary_op):
+    "QobjEvo arithmetic"
+    obj = all_qevo
+    for t in TESTTIMES:
+        as_qevo = unary_op(obj)(t)
+        as_qobj = unary_op(obj(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('args_coeff_type',
+                         ['func_coeff', 'string', 'func_call'])
+def test_args(pseudo_qevo, args_coeff_type):
+    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
+    args = {'w1': 3, "w2": 3}
+
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
+        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
+
+    # Did it modify original args
+    _assert_qobjevo_equivalent(obj, pseudo_qevo)
+
+    obj.arguments(args)
+    _assert_qobjevo_different(obj, pseudo_qevo)
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
+
+    args = {'w1': 4, "w2": 4}
+    obj.arguments(**args)
+    _assert_qobjevo_different(obj, pseudo_qevo)
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
+
+
+def test_copy_side_effects(all_qevo):
+    t = 0.2
+    qevo = all_qevo
+    copy = qevo.copy()
+    before = qevo(t)
+    # Ensure inplace modification of the copy do not affect the original
+    copy *= 2
+    copy += rand_herm(N)
+    copy *= rand_herm(N)
+    copy.arguments({'w1': 3, "w2": 3})
+    after = qevo(t)
+    _assert_qobj_almost_eq(before, after)
+
+
+@pytest.mark.parametrize('coeff_type',
+    ['func_coeff', 'string', 'array', 'logarray']
+)
+def test_tidyup(all_qevo):
+    "QobjEvo tidyup"
+    obj = all_qevo
+    obj *= 1e-12
+    obj.tidyup(atol=1e-8)
+    t = 0.2
+    # check that the Qobj are cleaned
+    assert_allclose(obj(t).full(), 0)
+
+
+def test_QobjEvo_pickle(all_qevo):
+    "QobjEvo pickle"
+    # used in parallel_map
+    import pickle
+    obj = all_qevo
+    pickled = pickle.dumps(obj, -1)
+    recreated = pickle.loads(pickled)
+    _assert_qobjevo_equivalent(recreated, obj)
+
+
+def test_QobjEvo_restore(all_qevo):
+    "QobjEvo pickle"
+    # used in parallel_map
+    obj = all_qevo
+    state = obj._getstate()
+    recreated = QobjEvo._restore(**state)
+    _assert_qobjevo_equivalent(recreated, obj)
+
+
+def test_mul_vec(all_qevo):
+    "QobjEvo matmul ket"
+    vec = Qobj(np.arange(N)*.5+.5j)
+    op = all_qevo
+    for t in TESTTIMES:
+        assert_allclose((op(t) @ vec).full(),
+                        op.matmul(t, vec).full(), atol=1e-14)
+
+
+def test_matmul(all_qevo):
+    "QobjEvo matmul oper"
+    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
+    matDense = Qobj(mat).to(_data.Dense)
+    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
+    matCSR = Qobj(mat).to(_data.CSR)
+    op = all_qevo
+    for t in TESTTIMES:
+        Qo1 = op(t)
+        assert_allclose((Qo1 @ mat).full(),
+                        op.matmul(t, matF).full(), atol=1e-14)
+        assert_allclose((Qo1 @ mat).full(),
+                        op.matmul(t, matDense).full(), atol=1e-14)
+        assert_allclose((Qo1 @ mat).full(),
+                        op.matmul(t, matCSR).full(), atol=1e-14)
+
+
+def test_expect_psi(all_qevo):
+    "QobjEvo expect psi"
+    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
+    qobj = Qobj(vec)
+    op = all_qevo
+    for t in TESTTIMES:
+        Qo1 = op(t)
+        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
+                        atol=1e-14)
+
+
+def test_expect_rho(all_qevo):
+    "QobjEvo expect rho"
+    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
+                                      + 1j * np.random.rand(N*N))
+    mat = _data.column_unstack_dense(vec, N)
+    qobj = Qobj(mat)
+    op = liouvillian(all_qevo)
+    for t in TESTTIMES:
+        Qo1 = op(t)
+        assert abs(_data.expect_super(Qo1.data, vec)
+                   - op.expect(t, qobj)) < 1e-14
+
+
+@pytest.mark.parametrize('dtype',
+[pytest.param(dtype, id=dtype.__name__)
+     for dtype in _data.to.dtypes])
+def test_convert(all_qevo, dtype):
+    "QobjEvo expect rho"
+    op = all_qevo.to(dtype)
+    assert isinstance(op(0.5).data, dtype)
+
+
+def test_compress():
+    "QobjEvo compress"
+    obj1 = QobjEvo(
+        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
+    assert obj1.num_elements == 1
+    obj2 = QobjEvo(
+        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
+    assert obj2.num_elements == 3
+    _assert_qobjevo_equivalent(obj1, obj2)
+    obj3 = obj2.copy()
+    assert obj3.num_elements == 3
+    obj3.compress()
+    assert obj3.num_elements == 1
+    _assert_qobjevo_equivalent(obj2, obj3)
+
+
+@pytest.mark.parametrize(['qobjdtype'],
+    [pytest.param(dtype, id=dtype.__name__)
+     for dtype in _data.to.dtypes])
+@pytest.mark.parametrize(['statedtype'],
+    [pytest.param(dtype, id=dtype.__name__)
+     for dtype in _data.to.dtypes])
+def test_layer_support(qobjdtype, statedtype):
+    N = 10
+    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
+    state_dense = rand_ket(N).to(_data.Dense)
+    state = state_dense.to(statedtype).data
+    state_dense = state_dense.data
+    exp_any = qevo.expect_data(0, state)
+    exp_dense = qevo.expect_data(0, state_dense)
+    assert_allclose(exp_any, exp_dense)
+    mul_any = qevo.matmul_data(0, state).to_array()
+    mul_dense = qevo.matmul_data(0, state_dense).to_array()
+    assert_allclose(mul_any, mul_dense)
+
+
+def test_QobjEvo_step_coeff():
+    "QobjEvo step interpolation"
+    coeff1 = np.random.rand(6)
+    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
+    # uniform t
+    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
+    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
+                      tlist=tlist, order=0)
+    assert qobjevo(2.0)[0,0] == coeff1[0]
+    assert qobjevo(7.0)[0,0] == coeff1[5]
+    assert qobjevo(5.0001)[0,0] == coeff1[3]
+    assert qobjevo(3.9999)[0,0] == coeff1[1]
+
+    assert qobjevo(2.0)[0,1] == coeff2[0]
+    assert qobjevo(7.0)[0,1] == coeff2[5]
+    assert qobjevo(5.0001)[0,1] == coeff2[3]
+    assert qobjevo(3.9999)[0,1] == coeff2[1]
+
+    # non-uniform t
+    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
+    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
+        tlist=tlist, order=0)
+    assert qobjevo(1.0)[0,0] == coeff1[0]
+    assert qobjevo(8.0)[0,0] == coeff1[5]
+    assert qobjevo(3.9999)[0,0] == coeff1[1]
+    assert qobjevo(4.23)[0,0] == coeff1[2]
+    assert qobjevo(1.23)[0,0] == coeff1[0]
+
+    assert qobjevo(1.0)[0,1] == coeff2[0]
+    assert qobjevo(8.0)[0,1] == coeff2[5]
+    assert qobjevo(6.7)[0,1] == coeff2[4]
+    assert qobjevo(7.9999)[0,1] == coeff2[4]
+    assert qobjevo(3.9999)[0,1] == coeff2[1]
+
+
+def test_QobjEvo_isherm_flag_knowcase():
+    assert QobjEvo(sigmax())(0)._isherm is True
+    non_hermitian = sigmax() + 1j
+    non_hermitian.isherm  # set flag
+    assert QobjEvo(non_hermitian)(0)._isherm is False
+    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
+    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
+    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
+    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
+    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
+
+
+@pytest.mark.parametrize(
+    "coeff_type",
+    ['func_coeff', 'string', 'array', 'logarray']
+)
+def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+    as_list = qevo.to_list()
+    assert len(as_list) == 2
+    restored = QobjEvo(as_list)
+    _assert_qobjevo_equivalent(qevo, restored)
diff --git a/qutip/tests/core/test_states.py b/qutip/tests/core/test_states.py
index be17941dec..edacd7d684 100644
--- a/qutip/tests/core/test_states.py
+++ b/qutip/tests/core/test_states.py
@@ -1,318 +1,318 @@
-import pytest
-import numpy as np
-import qutip
-from functools import partial
-from itertools import combinations
-
-
-@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
-def test_basis_simple(size, n):
-    qobj = qutip.basis(size, n)
-    numpy = np.zeros((size, 1), dtype=complex)
-    numpy[n, 0] = 1
-    assert np.array_equal(qobj.full(), numpy)
-
-
-@pytest.mark.parametrize("to_test", [
-    qutip.basis, qutip.fock, qutip.fock_dm,
-])
-@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
-def test_implicit_tensor_basis_like(to_test, size, n):
-    implicit = to_test(size, n)
-    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
-    assert implicit == explicit
-
-
-@pytest.mark.parametrize("size, n, offset, msg", [
-    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
-    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
-    (-1, 0, 0, "All dimensions must be >= 0."),
-    (1.5, 0, 0, "All dimensions must be >= 0."),
-    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
-    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
-], ids=["n too long", "offset too long", "neg dims",
-        "fraction dims", "n too large", "n too small"]
-)
-def test_basis_error(size, n, offset, msg):
-    with pytest.raises(ValueError) as e:
-        qutip.basis(size, n, offset)
-    assert str(e.value) == msg
-
-
-def test_basis_error_type():
-    with pytest.raises(TypeError) as e:
-        qutip.basis(5, 3.5)
-    assert str(e.value) == ("Dimensions must be an integer "
-                            "or list of integers.")
-
-
-@pytest.mark.parametrize("size, n, m", [
-        ([2, 2], [0, 0], [1, 1]),
-        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
-    ])
-def test_implicit_tensor_projection(size, n, m):
-    implicit = qutip.projection(size, n, m)
-    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
-                              for ss, nn, mm in zip(size, n, m)])
-    assert implicit == explicit
-
-
-@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
-    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
-                 id="basis"),
-    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
-                 id="basis,offset"),
-    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
-                 id="fock"),
-    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
-                 id="fock_dm"),
-    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
-                 id="fock_dm,offset"),
-    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
-                 id="coherent"),
-    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
-                 id="coherent,offset"),
-    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
-                 id="coherent_dm"),
-    pytest.param(qutip.phase_basis, qutip.phase,
-                 (10, 3), (10,), 3 * 2 * np.pi / 10,
-                 id="phase_basis"),
-    pytest.param(qutip.phase_basis, qutip.phase,
-                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
-                 id="phase_basis,phi0"),
-    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
-                 id="spin_state"),
-    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
-                 id="zero_ket"),
-])
-def test_diverse_basis(base, operator, args, opargs, eigenval):
-    # For state which are supposed to eigenvector of an operator
-    # Verify that correspondance
-    state = base(*args)
-    oper = operator(*opargs)
-    assert qutip.expect(oper, state) == pytest.approx(eigenval)
-
-
-@pytest.mark.parametrize('dm', [
-    partial(qutip.thermal_dm, n=1.),
-    qutip.maximally_mixed_dm,
-    partial(qutip.coherent_dm, alpha=0.5),
-    partial(qutip.fock_dm, n=1),
-    partial(qutip.spin_state, m=2, type='dm'),
-    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
-], ids=[
-    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
-    'fock_dm', 'spin_state', 'spin_coherent'
-])
-def test_dm(dm):
-    N = 5
-    rho = dm(N)
-    # make sure rho has trace close to 1.0
-    assert rho.tr() == pytest.approx(1.0)
-
-
-def test_CoherentState():
-    N = 10
-    alpha = 0.5
-    c1 = qutip.coherent(N, alpha)  # displacement method
-    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
-    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
-    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
-    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
-    with pytest.raises(TypeError) as e:
-        qutip.coherent(N, alpha, method="other")
-    assert all(method in str(e.value) for method in ["operator", "analytic"])
-    with pytest.raises(ValueError) as e:
-        qutip.coherent(N, alpha, offset=-1)
-    assert str(e.value) == ("Offset must be non-negative")
-    with pytest.raises(ValueError) as e:
-        qutip.coherent(N, alpha, offset=1, method="operator")
-    assert str(e.value) == (
-        "The method 'operator' does not support offset != 0. Please"
-        " select another method or set the offset to zero."
-    )
-
-
-def test_CoherentDensityMatrix():
-    N = 10
-    rho = qutip.coherent_dm(N, 1)
-    assert rho.tr() == pytest.approx(1.0)
-    with pytest.raises(TypeError) as e:
-        qutip.coherent_dm(N, 1, method="other")
-    assert all(method in str(e.value) for method in ["operator", "analytic"])
-    with pytest.raises(ValueError) as e:
-        qutip.coherent_dm(N, 1, offset=-1)
-    assert str(e.value) == ("Offset must be non-negative")
-    with pytest.raises(ValueError) as e:
-        qutip.coherent_dm(N, 1, offset=1, method="operator")
-    assert str(e.value) == (
-        "The method 'operator' does not support offset != 0. Please"
-        " select another method or set the offset to zero."
-    )
-
-
-def test_thermal():
-    N = 10
-    beta = 0.5
-    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
-
-    thermal_operator = qutip.thermal_dm(N, beta)
-    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
-    np.testing.assert_allclose(thermal_operator.full(),
-                               thermal_analytic.full(), atol=2e-5)
-
-    with pytest.raises(ValueError) as e:
-        qutip.thermal_dm(N, beta, method="other")
-    assert all(method in str(e.value) for method in ["operator", "analytic"])
-
-
-@pytest.mark.parametrize('func', [
-    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
-])
-def test_spin_output(func):
-    assert qutip.isket(func(1.0, 0, type='ket'))
-    assert qutip.isbra(func(1.0, 0, type='bra'))
-    assert qutip.isoper(func(1.0, 0, type='dm'))
-
-    with pytest.raises(ValueError) as e:
-        func(1.0, 0, type='something')
-    assert str(e.value).startswith("Invalid value keyword argument")
-
-
-@pytest.mark.parametrize('N', [2.5, -1])
-def test_maximally_mixed_dm_error(N):
-    with pytest.raises(ValueError) as e:
-        qutip.maximally_mixed_dm(N)
-    assert str(e.value) == "N must be integer N > 0"
-
-
-def test_TripletStateNorm():
-    for triplet in qutip.triplet_states():
-        assert triplet.norm() == pytest.approx(1.)
-    for t1, t2 in combinations(qutip.triplet_states(), 2):
-        assert t1.overlap(t2) == pytest.approx(0.)
-
-
-def test_ket2dm():
-    N = 5
-    ket = qutip.coherent(N, 2)
-    bra = ket.dag()
-    oper = qutip.ket2dm(ket)
-    oper_from_bra = qutip.ket2dm(bra)
-    assert qutip.expect(oper, ket) == pytest.approx(1.)
-    assert qutip.isoper(oper)
-    assert oper == ket * bra
-    assert oper == oper_from_bra
-    with pytest.raises(TypeError) as e:
-        qutip.ket2dm(oper)
-    assert str(e.value) == "Input is not a ket or bra vector."
-
-
-@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
-def test_qstate(state):
-    from_basis = qutip.basis([2] * len(state), state)
-    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
-    assert from_basis == from_qstate
-
-
-def test_qstate_error():
-    with pytest.raises(TypeError) as e:
-        qutip.qstate("eeggg")
-    assert str(e.value) == ('String input to QSTATE must consist ' +
-                            'of "u" and "d" elements only')
-
-
-@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
-def test_bra_ket(state):
-    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
-    from_ket = qutip.ket(state)
-    from_bra = qutip.bra(state).dag()
-    assert from_basis == from_ket
-    assert from_basis == from_bra
-
-
-def test_w_states():
-    state = (
-        qutip.qstate("uddd") +
-        qutip.qstate("dudd") +
-        qutip.qstate("ddud") +
-        qutip.qstate("dddu")
-    ) / 2
-    assert state == qutip.w_state(4)
-
-
-def test_ghz_states():
-    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
-    assert state == qutip.ghz_state(3)
-
-
-def test_bell_state():
-    states = [
-        qutip.bell_state('00'),
-        qutip.bell_state('01'),
-        qutip.bell_state('10'),
-        qutip.bell_state('11')
-    ]
-    exited = qutip.basis([2, 2], [1, 1])
-    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
-        assert state.norm() == pytest.approx(1.0)
-        assert state.overlap(exited) == pytest.approx(overlap)
-
-    for state1, state2 in combinations(states, 2):
-        assert state1.overlap(state2) == pytest.approx(0.0)
-
-    assert qutip.singlet_state() == qutip.bell_state('11')
-
-
-def _id_func(val):
-    "ids generated from the function only"
-    if isinstance(val, tuple):
-        return ""
-
-
-# random object accept `str` and base.Data
-# Obtain all valid dtype from `to`
-dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
-dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-@pytest.mark.parametrize(['func', 'args'], [
-    (qutip.basis, (5, 1)),
-    (qutip.fock, (5, 1)),
-    (qutip.fock_dm, (5, 1)),
-    (qutip.coherent, (5, 1)),
-    (qutip.coherent_dm, (5, 1)),
-    (qutip.thermal_dm, (5, 1)),
-    (qutip.maximally_mixed_dm, (5,)),
-    (qutip.phase_basis, (5, 1)),
-    (qutip.zero_ket, (5,)),
-    (qutip.spin_state, (5, 1)),
-    (qutip.spin_coherent, (5, 1, 0.5)),
-    (qutip.projection, (5, 1, 2)),
-    (qutip.ket, ("001",)),
-    (qutip.bra, ('010',)),
-    (qutip.qstate, ("uud",)),
-    (qutip.w_state, (5,)),
-    (qutip.ghz_state, (5,)),
-    (qutip.qutrit_basis, ()),
-    (qutip.triplet_states, ()),
-    (qutip.singlet_state, ()),
-    (qutip.bell_state, ('10',)),
-    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
-    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
-], ids=_id_func)
-def test_state_type(func, args, alias, dtype):
-    object = func(*args, dtype=alias)
-    if isinstance(object, qutip.Qobj):
-        assert isinstance(object.data, dtype)
-    else:
-        for obj in object:
-            assert isinstance(obj.data, dtype)
-
-    with qutip.CoreOptions(default_dtype=alias):
-        object = func(*args)
-        if isinstance(object, qutip.Qobj):
-            assert isinstance(object.data, dtype)
-        else:
-            for obj in object:
-                assert isinstance(obj.data, dtype)
+import pytest
+import numpy as np
+import qutip
+from functools import partial
+from itertools import combinations
+
+
+@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
+def test_basis_simple(size, n):
+    qobj = qutip.basis(size, n)
+    numpy = np.zeros((size, 1), dtype=complex)
+    numpy[n, 0] = 1
+    assert np.array_equal(qobj.full(), numpy)
+
+
+@pytest.mark.parametrize("to_test", [
+    qutip.basis, qutip.fock, qutip.fock_dm,
+])
+@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
+def test_implicit_tensor_basis_like(to_test, size, n):
+    implicit = to_test(size, n)
+    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
+    assert implicit == explicit
+
+
+@pytest.mark.parametrize("size, n, offset, msg", [
+    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
+    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
+    (-1, 0, 0, "All dimensions must be >= 0."),
+    (1.5, 0, 0, "All dimensions must be >= 0."),
+    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
+    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
+], ids=["n too long", "offset too long", "neg dims",
+        "fraction dims", "n too large", "n too small"]
+)
+def test_basis_error(size, n, offset, msg):
+    with pytest.raises(ValueError) as e:
+        qutip.basis(size, n, offset)
+    assert str(e.value) == msg
+
+
+def test_basis_error_type():
+    with pytest.raises(TypeError) as e:
+        qutip.basis(5, 3.5)
+    assert str(e.value) == ("Dimensions must be an integer "
+                            "or list of integers.")
+
+
+@pytest.mark.parametrize("size, n, m", [
+        ([2, 2], [0, 0], [1, 1]),
+        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
+    ])
+def test_implicit_tensor_projection(size, n, m):
+    implicit = qutip.projection(size, n, m)
+    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
+                              for ss, nn, mm in zip(size, n, m)])
+    assert implicit == explicit
+
+
+@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
+    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
+                 id="basis"),
+    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
+                 id="basis,offset"),
+    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
+                 id="fock"),
+    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
+                 id="fock_dm"),
+    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
+                 id="fock_dm,offset"),
+    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
+                 id="coherent"),
+    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
+                 id="coherent,offset"),
+    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
+                 id="coherent_dm"),
+    pytest.param(qutip.phase_basis, qutip.phase,
+                 (10, 3), (10,), 3 * 2 * np.pi / 10,
+                 id="phase_basis"),
+    pytest.param(qutip.phase_basis, qutip.phase,
+                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
+                 id="phase_basis,phi0"),
+    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
+                 id="spin_state"),
+    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
+                 id="zero_ket"),
+])
+def test_diverse_basis(base, operator, args, opargs, eigenval):
+    # For state which are supposed to eigenvector of an operator
+    # Verify that correspondance
+    state = base(*args)
+    oper = operator(*opargs)
+    assert qutip.expect(oper, state) == pytest.approx(eigenval)
+
+
+@pytest.mark.parametrize('dm', [
+    partial(qutip.thermal_dm, n=1.),
+    qutip.maximally_mixed_dm,
+    partial(qutip.coherent_dm, alpha=0.5),
+    partial(qutip.fock_dm, n=1),
+    partial(qutip.spin_state, m=2, type='dm'),
+    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
+], ids=[
+    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
+    'fock_dm', 'spin_state', 'spin_coherent'
+])
+def test_dm(dm):
+    N = 5
+    rho = dm(N)
+    # make sure rho has trace close to 1.0
+    assert rho.tr() == pytest.approx(1.0)
+
+
+def test_CoherentState():
+    N = 10
+    alpha = 0.5
+    c1 = qutip.coherent(N, alpha)  # displacement method
+    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
+    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
+    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
+    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
+    with pytest.raises(TypeError) as e:
+        qutip.coherent(N, alpha, method="other")
+    assert all(method in str(e.value) for method in ["operator", "analytic"])
+    with pytest.raises(ValueError) as e:
+        qutip.coherent(N, alpha, offset=-1)
+    assert str(e.value) == ("Offset must be non-negative")
+    with pytest.raises(ValueError) as e:
+        qutip.coherent(N, alpha, offset=1, method="operator")
+    assert str(e.value) == (
+        "The method 'operator' does not support offset != 0. Please"
+        " select another method or set the offset to zero."
+    )
+
+
+def test_CoherentDensityMatrix():
+    N = 10
+    rho = qutip.coherent_dm(N, 1)
+    assert rho.tr() == pytest.approx(1.0)
+    with pytest.raises(TypeError) as e:
+        qutip.coherent_dm(N, 1, method="other")
+    assert all(method in str(e.value) for method in ["operator", "analytic"])
+    with pytest.raises(ValueError) as e:
+        qutip.coherent_dm(N, 1, offset=-1)
+    assert str(e.value) == ("Offset must be non-negative")
+    with pytest.raises(ValueError) as e:
+        qutip.coherent_dm(N, 1, offset=1, method="operator")
+    assert str(e.value) == (
+        "The method 'operator' does not support offset != 0. Please"
+        " select another method or set the offset to zero."
+    )
+
+
+def test_thermal():
+    N = 10
+    beta = 0.5
+    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
+
+    thermal_operator = qutip.thermal_dm(N, beta)
+    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
+    np.testing.assert_allclose(thermal_operator.full(),
+                               thermal_analytic.full(), atol=2e-5)
+
+    with pytest.raises(ValueError) as e:
+        qutip.thermal_dm(N, beta, method="other")
+    assert all(method in str(e.value) for method in ["operator", "analytic"])
+
+
+@pytest.mark.parametrize('func', [
+    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
+])
+def test_spin_output(func):
+    assert qutip.isket(func(1.0, 0, type='ket'))
+    assert qutip.isbra(func(1.0, 0, type='bra'))
+    assert qutip.isoper(func(1.0, 0, type='dm'))
+
+    with pytest.raises(ValueError) as e:
+        func(1.0, 0, type='something')
+    assert str(e.value).startswith("Invalid value keyword argument")
+
+
+@pytest.mark.parametrize('N', [2.5, -1])
+def test_maximally_mixed_dm_error(N):
+    with pytest.raises(ValueError) as e:
+        qutip.maximally_mixed_dm(N)
+    assert str(e.value) == "N must be integer N > 0"
+
+
+def test_TripletStateNorm():
+    for triplet in qutip.triplet_states():
+        assert triplet.norm() == pytest.approx(1.)
+    for t1, t2 in combinations(qutip.triplet_states(), 2):
+        assert t1.overlap(t2) == pytest.approx(0.)
+
+
+def test_ket2dm():
+    N = 5
+    ket = qutip.coherent(N, 2)
+    bra = ket.dag()
+    oper = qutip.ket2dm(ket)
+    oper_from_bra = qutip.ket2dm(bra)
+    assert qutip.expect(oper, ket) == pytest.approx(1.)
+    assert qutip.isoper(oper)
+    assert oper == ket * bra
+    assert oper == oper_from_bra
+    with pytest.raises(TypeError) as e:
+        qutip.ket2dm(oper)
+    assert str(e.value) == "Input is not a ket or bra vector."
+
+
+@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
+def test_qstate(state):
+    from_basis = qutip.basis([2] * len(state), state)
+    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
+    assert from_basis == from_qstate
+
+
+def test_qstate_error():
+    with pytest.raises(TypeError) as e:
+        qutip.qstate("eeggg")
+    assert str(e.value) == ('String input to QSTATE must consist ' +
+                            'of "u" and "d" elements only')
+
+
+@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
+def test_bra_ket(state):
+    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
+    from_ket = qutip.ket(state)
+    from_bra = qutip.bra(state).dag()
+    assert from_basis == from_ket
+    assert from_basis == from_bra
+
+
+def test_w_states():
+    state = (
+        qutip.qstate("uddd") +
+        qutip.qstate("dudd") +
+        qutip.qstate("ddud") +
+        qutip.qstate("dddu")
+    ) / 2
+    assert state == qutip.w_state(4)
+
+
+def test_ghz_states():
+    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
+    assert state == qutip.ghz_state(3)
+
+
+def test_bell_state():
+    states = [
+        qutip.bell_state('00'),
+        qutip.bell_state('01'),
+        qutip.bell_state('10'),
+        qutip.bell_state('11')
+    ]
+    exited = qutip.basis([2, 2], [1, 1])
+    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
+        assert state.norm() == pytest.approx(1.0)
+        assert state.overlap(exited) == pytest.approx(overlap)
+
+    for state1, state2 in combinations(states, 2):
+        assert state1.overlap(state2) == pytest.approx(0.0)
+
+    assert qutip.singlet_state() == qutip.bell_state('11')
+
+
+def _id_func(val):
+    "ids generated from the function only"
+    if isinstance(val, tuple):
+        return ""
+
+
+# random object accept `str` and base.Data
+# Obtain all valid dtype from `to`
+dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
+dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize(['func', 'args'], [
+    (qutip.basis, (5, 1)),
+    (qutip.fock, (5, 1)),
+    (qutip.fock_dm, (5, 1)),
+    (qutip.coherent, (5, 1)),
+    (qutip.coherent_dm, (5, 1)),
+    (qutip.thermal_dm, (5, 1)),
+    (qutip.maximally_mixed_dm, (5,)),
+    (qutip.phase_basis, (5, 1)),
+    (qutip.zero_ket, (5,)),
+    (qutip.spin_state, (5, 1)),
+    (qutip.spin_coherent, (5, 1, 0.5)),
+    (qutip.projection, (5, 1, 2)),
+    (qutip.ket, ("001",)),
+    (qutip.bra, ('010',)),
+    (qutip.qstate, ("uud",)),
+    (qutip.w_state, (5,)),
+    (qutip.ghz_state, (5,)),
+    (qutip.qutrit_basis, ()),
+    (qutip.triplet_states, ()),
+    (qutip.singlet_state, ()),
+    (qutip.bell_state, ('10',)),
+    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
+    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
+], ids=_id_func)
+def test_state_type(func, args, alias, dtype):
+    object = func(*args, dtype=alias)
+    if isinstance(object, qutip.Qobj):
+        assert isinstance(object.data, dtype)
+    else:
+        for obj in object:
+            assert isinstance(obj.data, dtype)
+
+    with qutip.CoreOptions(default_dtype=alias):
+        object = func(*args)
+        if isinstance(object, qutip.Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
diff --git a/qutip/tests/core/test_superop_reps.py b/qutip/tests/core/test_superop_reps.py
index 31c538d118..7e04579c3b 100644
--- a/qutip/tests/core/test_superop_reps.py
+++ b/qutip/tests/core/test_superop_reps.py
@@ -1,347 +1,347 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Wed May 29 11:23:46 2013
-
-@author: dcriger
-"""
-
-from __future__ import division
-
-import numpy as np
-import pytest
-
-from qutip import (
-    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
-    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
-    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
-    vector_to_operator, sprepost, destroy
-)
-from qutip.core.gates import swap
-
-
-tol = 1e-8
-
-
-def assert_kraus_equivalence(a, b, tol=tol):
-    assert a.shape == b.shape
-    assert a.dims == b.dims
-    assert a.type == b.type
-    # Kraus operators may vary by a global phase.  Let's find the first
-    # non-zero element, set the phase such that that element has the same phase
-    # in both, and then compare.  We have to take care to find the first
-    # element.
-    a, b = a.full(), b.full()
-    a_nz = np.nonzero(np.abs(a) > tol)
-    if len(a_nz[0]) == 0:
-        np.testing.assert_allclose(b, 0, atol=tol)
-    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
-    assert b_el != 0
-    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
-    np.testing.assert_allclose(a, b)
-
-
-@pytest.fixture(scope="function", params=[2, 3, 7])
-def dimension(request):
-    # There are also some cases in the file where this fixture is explicitly
-    # overridden by a more local mark.  That is deliberate.
-    return request.param
-
-
-@pytest.fixture(scope="function", params=[
-    pytest.param(rand_super, id="super"),
-    pytest.param(rand_super_bcsz, id="super_bcz")
-])
-def superoperator(request, dimension):
-    return request.param(dimension)
-
-
-class TestSuperopReps:
-    """
-    A test class for the QuTiP function for applying superoperators to
-    subsystems.
-    """
-
-    def test_SuperChoiSuper(self, superoperator):
-        """
-        Superoperator: Converting superoperator to Choi matrix and back.
-        """
-        choi_matrix = to_choi(superoperator)
-        test_supe = to_super(choi_matrix)
-
-        # Assert both that the result is close to expected, and has the right
-        # type.
-        assert (test_supe - superoperator).norm() < tol
-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-        assert test_supe.type == "super" and test_supe.superrep == "super"
-
-    @pytest.mark.parametrize('dimension', [2, 4])
-    def test_SuperChoiChiSuper(self, dimension):
-        """
-        Superoperator: Converting two-qubit superoperator through
-        Choi and chi representations goes back to right superoperator.
-        """
-        superoperator = super_tensor(
-            rand_super(dimension), rand_super(dimension),
-        )
-
-        choi_matrix = to_choi(superoperator)
-        chi_matrix = to_chi(choi_matrix)
-        test_supe = to_super(chi_matrix)
-
-        # Assert both that the result is close to expected, and has the right
-        # type.
-        assert (test_supe - superoperator).norm() < tol
-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
-        assert test_supe.type == "super" and test_supe.superrep == "super"
-
-    def test_ChoiKrausChoi(self, superoperator):
-        """
-        Superoperator: Convert superoperator to Choi matrix and back.
-        """
-        choi_matrix = to_choi(superoperator)
-        kraus_ops = to_kraus(choi_matrix)
-        test_choi = kraus_to_choi(kraus_ops)
-
-        # Assert both that the result is close to expected, and has the right
-        # type.
-        assert (test_choi - choi_matrix).norm() < tol
-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-        assert test_choi.type == "super" and test_choi.superrep == "choi"
-
-    def test_NonSquareKrausSuperChoi(self):
-        """
-        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
-        and back.
-        """
-        zero = np.array([[1], [0]], dtype=complex)
-        one = np.array([[0], [1]], dtype=complex)
-        zero_log = np.kron(np.kron(zero, zero), zero)
-        one_log = np.kron(np.kron(one, one), one)
-        # non-square Kraus operator (isometry)
-        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
-        super = sprepost(kraus, kraus.dag())
-        choi = to_choi(super)
-        op1 = to_kraus(super)
-        op2 = to_kraus(choi)
-        op3 = to_super(choi)
-        assert choi.type == "super" and choi.superrep == "choi"
-        assert super.type == "super" and super.superrep == "super"
-        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
-        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
-        assert abs((op3 - super).norm()) < 1e-8
-
-    def test_NeglectSmallKraus(self):
-        """
-        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
-        Kraus operators.
-        """
-        zero = np.array([[1], [0]], dtype=complex)
-        one = np.array([[0], [1]], dtype=complex)
-        zero_log = np.kron(np.kron(zero, zero), zero)
-        one_log = np.kron(np.kron(one, one), one)
-        # non-square Kraus operator (isometry)
-        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
-        super = sprepost(kraus, kraus.dag())
-        # 1 non-zero Kraus operator the rest are zero
-        sixteen_kraus_ops = to_kraus(super, tol=0.0)
-        # default is tol=1e-9
-        one_kraus_op = to_kraus(super)
-        assert len(sixteen_kraus_ops) == 16
-        assert len(one_kraus_op) == 1
-        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
-
-    def test_SuperPreservesSelf(self, superoperator):
-        """
-        Superoperator: to_super(q) returns q if q is already a
-        supermatrix.
-        """
-
-        assert superoperator is to_super(superoperator)
-
-    def test_ChoiPreservesSelf(self, superoperator):
-        """
-        Superoperator: to_choi(q) returns q if q is already Choi.
-        """
-        choi = to_choi(superoperator)
-        assert choi is to_choi(choi)
-
-    def test_random_iscptp(self, superoperator):
-        """
-        Superoperator: Randomly generated superoperators are
-        correctly reported as CPTP and HP.
-        """
-        assert superoperator.iscptp
-        assert superoperator.ishp
-
-    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
-        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
-        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
-        pytest.param(qeye(2), True, True, True),
-        pytest.param(sigmax(), True, True, True),
-        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
-        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
-                            + to_super(tensor(qeye(2), sigmay()))),
-                     True, True, True,
-                     id="linear combination of bipartite unitaries"),
-        pytest.param(Qobj(swap(), type='super', superrep='choi'),
-                     True, False, True,
-                     id="partial transpose map"),
-        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
-                     id="subnormalized map"),
-        pytest.param(basis(2, 0), False, False, False, id="ket"),
-    ])
-    def test_known_iscptp(self, qobj, hp, cp, tp):
-        """
-        Superoperator: ishp, iscp, istp and iscptp known cases.
-        """
-        assert qobj.ishp == hp
-        assert qobj.iscp == cp
-        assert qobj.istp == tp
-        assert qobj.iscptp == (cp and tp)
-
-    def test_choi_tr(self):
-        """
-        Superoperator: Trace returned by to_choi matches docstring.
-        """
-        for dims in range(2, 5):
-            assert abs(to_choi(identity(dims)).tr() - dims) < tol
-
-
-    # Conjugation by a creation operator
-    a = create(2).dag()
-    S = sprepost(a, a.dag())
-
-    # A single off-diagonal element
-    S_ = sprepost(a, a)
-
-    # Check that a linear combination of bipartite unitaries is CPTP and HP.
-    S_U = (
-        to_super(tensor(sigmax(), identity(2))) +
-        to_super(tensor(identity(2), sigmay()))
-    ) / 2
-
-    # The partial transpose map, whose Choi matrix is SWAP
-    ptr_swap = Qobj(swap(), type='super', superrep='choi')
-
-    # Subnormalized maps (representing erasure channels, for instance)
-    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
-
-    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
-        pytest.param(S, True, True, False, id="conjugatio by create op"),
-        pytest.param(S_, False, False, False, id="single off-diag"),
-        pytest.param(identity(2), True, True, True, id="Identity"),
-        pytest.param(sigmax(), True, True, True, id="Pauli X"),
-        pytest.param(
-            tensor(sigmax(), identity(2)), True, True, True,
-            id="bipartite system",
-        ),
-        pytest.param(
-            S_U, True, True, True, id="linear combination of bip. unitaries",
-        ),
-        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
-        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
-        pytest.param(basis(2), False, False, False, id="not an operator"),
-
-    ])
-    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
-        """
-        Superoperator: ishp, iscp, istp and iscptp known cases.
-        """
-        assert qobj.ishp == shouldhp
-        assert qobj.iscp == shouldcp
-        assert qobj.istp == shouldtp
-        assert qobj.iscptp == (shouldcp and shouldtp)
-
-    def test_choi_tr(self, dimension):
-        """
-        Superoperator: Trace returned by to_choi matches docstring.
-        """
-        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
-
-    def test_stinespring_cp(self, dimension):
-        """
-        Stinespring: A and B match for CP maps.
-        """
-        superop = rand_super_bcsz(dimension)
-        A, B = to_stinespring(superop)
-
-        assert (A - B).norm() < tol
-
-    @pytest.mark.repeat(3)
-    def test_stinespring_agrees(self, dimension):
-        """
-        Stinespring: Partial Tr over pair agrees w/ supermatrix.
-        """
-
-        map = rand_super_bcsz(dimension)
-        state = rand_dm(dimension)
-
-        S = to_super(map)
-        A, B = to_stinespring(map)
-
-        q1 = vector_to_operator(
-            S * operator_to_vector(state)
-        )
-        # FIXME: problem if Kraus index is implicitly
-        #        ptraced!
-        q2 = (A * state * B.dag()).ptrace((0,))
-
-        assert (q1 - q2).norm('tr') <= tol
-
-    def test_stinespring_dims(self, dimension):
-        """
-        Stinespring: Check that dims of channels are preserved.
-        """
-        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
-        A, B = to_stinespring(chan)
-        assert A.dims == [[2, dimension, 1], [2, dimension]]
-        assert B.dims == [[2, dimension, 1], [2, dimension]]
-
-    @pytest.mark.parametrize('dimension', [2, 4, 8])
-    def test_chi_choi_roundtrip(self, dimension):
-
-        superop = rand_super_bcsz(dimension)
-        superop = to_chi(superop)
-        rt_superop = to_chi(to_choi(superop))
-        dif = (rt_superop - superop).norm()
-
-        assert dif == pytest.approx(0, abs=1e-7)
-        assert rt_superop.type == superop.type
-        assert rt_superop.dims == superop.dims
-
-    chi_sigmax = [
-        [0, 0, 0, 0],
-        [0, 4, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0]
-    ]
-    chi_diag2 = [
-        [4, 0, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0]
-    ]
-    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
-    chi_rotX_pi_4 = [
-        [2, 2j, 0, 0],
-        [-2j, 2, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0]
-    ]
-
-    @pytest.mark.parametrize(['superop', 'chi_expected'], [
-        pytest.param(sigmax(), chi_sigmax),
-        pytest.param(to_super(sigmax()), chi_sigmax),
-        pytest.param(qeye(2), chi_diag2),
-        pytest.param(rotX_pi_4, chi_rotX_pi_4)
-    ])
-    def test_chi_known(self, superop, chi_expected):
-        """
-        Superoperator: Chi-matrix for known cases is correct.
-        """
-        chi_actual = to_chi(superop)
-        chiq = Qobj(
-            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
-        )
-        assert (chi_actual - chiq).norm() < tol
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 29 11:23:46 2013
+
+@author: dcriger
+"""
+
+from __future__ import division
+
+import numpy as np
+import pytest
+
+from qutip import (
+    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
+    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
+    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
+    vector_to_operator, sprepost, destroy
+)
+from qutip.core.gates import swap
+
+
+tol = 1e-8
+
+
+def assert_kraus_equivalence(a, b, tol=tol):
+    assert a.shape == b.shape
+    assert a.dims == b.dims
+    assert a.type == b.type
+    # Kraus operators may vary by a global phase.  Let's find the first
+    # non-zero element, set the phase such that that element has the same phase
+    # in both, and then compare.  We have to take care to find the first
+    # element.
+    a, b = a.full(), b.full()
+    a_nz = np.nonzero(np.abs(a) > tol)
+    if len(a_nz[0]) == 0:
+        np.testing.assert_allclose(b, 0, atol=tol)
+    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
+    assert b_el != 0
+    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
+    np.testing.assert_allclose(a, b)
+
+
+@pytest.fixture(scope="function", params=[2, 3, 7])
+def dimension(request):
+    # There are also some cases in the file where this fixture is explicitly
+    # overridden by a more local mark.  That is deliberate.
+    return request.param
+
+
+@pytest.fixture(scope="function", params=[
+    pytest.param(rand_super, id="super"),
+    pytest.param(rand_super_bcsz, id="super_bcz")
+])
+def superoperator(request, dimension):
+    return request.param(dimension)
+
+
+class TestSuperopReps:
+    """
+    A test class for the QuTiP function for applying superoperators to
+    subsystems.
+    """
+
+    def test_SuperChoiSuper(self, superoperator):
+        """
+        Superoperator: Converting superoperator to Choi matrix and back.
+        """
+        choi_matrix = to_choi(superoperator)
+        test_supe = to_super(choi_matrix)
+
+        # Assert both that the result is close to expected, and has the right
+        # type.
+        assert (test_supe - superoperator).norm() < tol
+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+        assert test_supe.type == "super" and test_supe.superrep == "super"
+
+    @pytest.mark.parametrize('dimension', [2, 4])
+    def test_SuperChoiChiSuper(self, dimension):
+        """
+        Superoperator: Converting two-qubit superoperator through
+        Choi and chi representations goes back to right superoperator.
+        """
+        superoperator = super_tensor(
+            rand_super(dimension), rand_super(dimension),
+        )
+
+        choi_matrix = to_choi(superoperator)
+        chi_matrix = to_chi(choi_matrix)
+        test_supe = to_super(chi_matrix)
+
+        # Assert both that the result is close to expected, and has the right
+        # type.
+        assert (test_supe - superoperator).norm() < tol
+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
+        assert test_supe.type == "super" and test_supe.superrep == "super"
+
+    def test_ChoiKrausChoi(self, superoperator):
+        """
+        Superoperator: Convert superoperator to Choi matrix and back.
+        """
+        choi_matrix = to_choi(superoperator)
+        kraus_ops = to_kraus(choi_matrix)
+        test_choi = kraus_to_choi(kraus_ops)
+
+        # Assert both that the result is close to expected, and has the right
+        # type.
+        assert (test_choi - choi_matrix).norm() < tol
+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+        assert test_choi.type == "super" and test_choi.superrep == "choi"
+
+    def test_NonSquareKrausSuperChoi(self):
+        """
+        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
+        and back.
+        """
+        zero = np.array([[1], [0]], dtype=complex)
+        one = np.array([[0], [1]], dtype=complex)
+        zero_log = np.kron(np.kron(zero, zero), zero)
+        one_log = np.kron(np.kron(one, one), one)
+        # non-square Kraus operator (isometry)
+        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
+        super = sprepost(kraus, kraus.dag())
+        choi = to_choi(super)
+        op1 = to_kraus(super)
+        op2 = to_kraus(choi)
+        op3 = to_super(choi)
+        assert choi.type == "super" and choi.superrep == "choi"
+        assert super.type == "super" and super.superrep == "super"
+        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
+        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
+        assert abs((op3 - super).norm()) < 1e-8
+
+    def test_NeglectSmallKraus(self):
+        """
+        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
+        Kraus operators.
+        """
+        zero = np.array([[1], [0]], dtype=complex)
+        one = np.array([[0], [1]], dtype=complex)
+        zero_log = np.kron(np.kron(zero, zero), zero)
+        one_log = np.kron(np.kron(one, one), one)
+        # non-square Kraus operator (isometry)
+        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
+        super = sprepost(kraus, kraus.dag())
+        # 1 non-zero Kraus operator the rest are zero
+        sixteen_kraus_ops = to_kraus(super, tol=0.0)
+        # default is tol=1e-9
+        one_kraus_op = to_kraus(super)
+        assert len(sixteen_kraus_ops) == 16
+        assert len(one_kraus_op) == 1
+        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
+
+    def test_SuperPreservesSelf(self, superoperator):
+        """
+        Superoperator: to_super(q) returns q if q is already a
+        supermatrix.
+        """
+
+        assert superoperator is to_super(superoperator)
+
+    def test_ChoiPreservesSelf(self, superoperator):
+        """
+        Superoperator: to_choi(q) returns q if q is already Choi.
+        """
+        choi = to_choi(superoperator)
+        assert choi is to_choi(choi)
+
+    def test_random_iscptp(self, superoperator):
+        """
+        Superoperator: Randomly generated superoperators are
+        correctly reported as CPTP and HP.
+        """
+        assert superoperator.iscptp
+        assert superoperator.ishp
+
+    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
+        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
+        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
+        pytest.param(qeye(2), True, True, True),
+        pytest.param(sigmax(), True, True, True),
+        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
+        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
+                            + to_super(tensor(qeye(2), sigmay()))),
+                     True, True, True,
+                     id="linear combination of bipartite unitaries"),
+        pytest.param(Qobj(swap(), type='super', superrep='choi'),
+                     True, False, True,
+                     id="partial transpose map"),
+        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
+                     id="subnormalized map"),
+        pytest.param(basis(2, 0), False, False, False, id="ket"),
+    ])
+    def test_known_iscptp(self, qobj, hp, cp, tp):
+        """
+        Superoperator: ishp, iscp, istp and iscptp known cases.
+        """
+        assert qobj.ishp == hp
+        assert qobj.iscp == cp
+        assert qobj.istp == tp
+        assert qobj.iscptp == (cp and tp)
+
+    def test_choi_tr(self):
+        """
+        Superoperator: Trace returned by to_choi matches docstring.
+        """
+        for dims in range(2, 5):
+            assert abs(to_choi(identity(dims)).tr() - dims) < tol
+
+
+    # Conjugation by a creation operator
+    a = create(2).dag()
+    S = sprepost(a, a.dag())
+
+    # A single off-diagonal element
+    S_ = sprepost(a, a)
+
+    # Check that a linear combination of bipartite unitaries is CPTP and HP.
+    S_U = (
+        to_super(tensor(sigmax(), identity(2))) +
+        to_super(tensor(identity(2), sigmay()))
+    ) / 2
+
+    # The partial transpose map, whose Choi matrix is SWAP
+    ptr_swap = Qobj(swap(), type='super', superrep='choi')
+
+    # Subnormalized maps (representing erasure channels, for instance)
+    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
+
+    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
+        pytest.param(S, True, True, False, id="conjugatio by create op"),
+        pytest.param(S_, False, False, False, id="single off-diag"),
+        pytest.param(identity(2), True, True, True, id="Identity"),
+        pytest.param(sigmax(), True, True, True, id="Pauli X"),
+        pytest.param(
+            tensor(sigmax(), identity(2)), True, True, True,
+            id="bipartite system",
+        ),
+        pytest.param(
+            S_U, True, True, True, id="linear combination of bip. unitaries",
+        ),
+        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
+        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
+        pytest.param(basis(2), False, False, False, id="not an operator"),
+
+    ])
+    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
+        """
+        Superoperator: ishp, iscp, istp and iscptp known cases.
+        """
+        assert qobj.ishp == shouldhp
+        assert qobj.iscp == shouldcp
+        assert qobj.istp == shouldtp
+        assert qobj.iscptp == (shouldcp and shouldtp)
+
+    def test_choi_tr(self, dimension):
+        """
+        Superoperator: Trace returned by to_choi matches docstring.
+        """
+        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
+
+    def test_stinespring_cp(self, dimension):
+        """
+        Stinespring: A and B match for CP maps.
+        """
+        superop = rand_super_bcsz(dimension)
+        A, B = to_stinespring(superop)
+
+        assert (A - B).norm() < tol
+
+    @pytest.mark.repeat(3)
+    def test_stinespring_agrees(self, dimension):
+        """
+        Stinespring: Partial Tr over pair agrees w/ supermatrix.
+        """
+
+        map = rand_super_bcsz(dimension)
+        state = rand_dm(dimension)
+
+        S = to_super(map)
+        A, B = to_stinespring(map)
+
+        q1 = vector_to_operator(
+            S * operator_to_vector(state)
+        )
+        # FIXME: problem if Kraus index is implicitly
+        #        ptraced!
+        q2 = (A * state * B.dag()).ptrace((0,))
+
+        assert (q1 - q2).norm('tr') <= tol
+
+    def test_stinespring_dims(self, dimension):
+        """
+        Stinespring: Check that dims of channels are preserved.
+        """
+        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
+        A, B = to_stinespring(chan)
+        assert A.dims == [[2, dimension, 1], [2, dimension]]
+        assert B.dims == [[2, dimension, 1], [2, dimension]]
+
+    @pytest.mark.parametrize('dimension', [2, 4, 8])
+    def test_chi_choi_roundtrip(self, dimension):
+
+        superop = rand_super_bcsz(dimension)
+        superop = to_chi(superop)
+        rt_superop = to_chi(to_choi(superop))
+        dif = (rt_superop - superop).norm()
+
+        assert dif == pytest.approx(0, abs=1e-7)
+        assert rt_superop.type == superop.type
+        assert rt_superop.dims == superop.dims
+
+    chi_sigmax = [
+        [0, 0, 0, 0],
+        [0, 4, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]
+    ]
+    chi_diag2 = [
+        [4, 0, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]
+    ]
+    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
+    chi_rotX_pi_4 = [
+        [2, 2j, 0, 0],
+        [-2j, 2, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]
+    ]
+
+    @pytest.mark.parametrize(['superop', 'chi_expected'], [
+        pytest.param(sigmax(), chi_sigmax),
+        pytest.param(to_super(sigmax()), chi_sigmax),
+        pytest.param(qeye(2), chi_diag2),
+        pytest.param(rotX_pi_4, chi_rotX_pi_4)
+    ])
+    def test_chi_known(self, superop, chi_expected):
+        """
+        Superoperator: Chi-matrix for known cases is correct.
+        """
+        chi_actual = to_chi(superop)
+        chiq = Qobj(
+            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
+        )
+        assert (chi_actual - chiq).norm() < tol
diff --git a/qutip/tests/core/test_superoper.py b/qutip/tests/core/test_superoper.py
index b5ba6fd105..bbeeb68257 100644
--- a/qutip/tests/core/test_superoper.py
+++ b/qutip/tests/core/test_superoper.py
@@ -1,269 +1,269 @@
-import numpy as np
-import scipy.linalg
-
-import qutip
-from qutip.core import data as _data
-import pytest
-
-
-def f(t, args):
-    return t * (1 - 0.5j)
-
-
-def liouvillian_ref(H, c_ops=()):
-    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
-    for c in c_ops:
-        if c.issuper:
-            L += c
-        else:
-            cdc = c.dag() * c
-            L += qutip.sprepost(c, c.dag())
-            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
-    return L
-
-
-class TestMatVec:
-    """
-    A test class for the QuTiP function for matrix/vector conversion.
-    """
-    def testOperatorVector(self):
-        """
-        Superoperator: Operator - vector - operator conversion.
-        """
-        N = 3
-        rho1 = qutip.rand_dm(N)
-        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testsuperrep(self):
-        N = 3
-        rho1 = qutip.rand_dm(N)
-        as_vec = qutip.operator_to_vector(rho1)
-        assert as_vec.superrep == 'super'
-
-        with pytest.raises(TypeError) as err:
-            bad_vec = as_vec.copy()
-            bad_vec.superrep = ""
-            qutip.vector_to_operator(bad_vec)
-        assert err.value.args[0] == ("only defined for operator-kets "
-                                     "in super format")
-
-        with pytest.raises(TypeError) as err:
-            qutip.operator_to_vector(as_vec)
-        assert err.value.args[0] == ("Cannot convert object already "
-                                     "in super representation")
-
-    def testOperatorVectorTensor(self):
-        """
-        Superoperator: Operator - vector - operator conversion with a tensor
-        product state.
-        """
-        Na = 3
-        Nb = 2
-        rhoa = qutip.rand_dm(Na)
-        rhob = qutip.rand_dm(Nb)
-        rho1 = qutip.tensor(rhoa, rhob)
-        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testOperatorVectorNotSquare(self):
-        """
-        Superoperator: Operator - vector - operator conversion for non-square
-        matrix.
-        """
-        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
-        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
-        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
-
-    def testOperatorSpreAppl(self):
-        """
-        Superoperator: apply operator and superoperator from left (spre)
-        """
-        N = 3
-        rho = qutip.rand_dm(N)
-        U = qutip.rand_unitary(N)
-        rho1 = U * rho
-        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
-        rho2 = qutip.vector_to_operator(rho2_vec)
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testOperatorSpostAppl(self):
-        """
-        Superoperator: apply operator and superoperator from right (spost)
-        """
-        N = 3
-        rho = qutip.rand_dm(N)
-        U = qutip.rand_unitary(N)
-        rho1 = rho * U
-        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
-        rho2 = qutip.vector_to_operator(rho2_vec)
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testOperatorUnitaryTransform(self):
-        """
-        Superoperator: Unitary transformation with operators and superoperators
-        """
-        N = 3
-        rho = qutip.rand_dm(N)
-        U = qutip.rand_unitary(N)
-        rho1 = U * rho * U.dag()
-        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
-        rho2 = qutip.vector_to_operator(rho2_vec)
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testMatrixVecMat(self):
-        """
-        Superoperator: Conversion matrix to vector to matrix
-        """
-        M = _data.create(np.random.rand(10, 10))
-        V = qutip.stack_columns(M)
-        M2 = qutip.unstack_columns(V)
-        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
-
-    def testVecMatVec(self):
-        """
-        Superoperator: Conversion vector to matrix to vector
-        """
-        V = _data.create(np.random.rand(100, 1))
-        M = qutip.unstack_columns(V)
-        V2 = qutip.stack_columns(M)
-        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
-
-    def testVecMatIndexConversion(self):
-        """
-        Superoperator: Conversion between matrix and vector indices
-        """
-        N = 10
-        for i in range(N * N):
-            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
-
-    def testVecMatIndexCompability(self):
-        """
-        Superoperator: Compatibility between matrix/vector and
-        corresponding index conversions.
-        """
-        N = 10
-        M = _data.create(np.random.rand(N, N))
-        V = qutip.stack_columns(M)
-        for idx in range(N * N):
-            i, j = qutip.unstacked_index(N, idx)
-            assert V.to_array()[idx, 0] == M.to_array()[i, j]
-
-    def test_reshuffle(self):
-        U1 = qutip.rand_unitary(2)
-        U2 = qutip.rand_unitary(3)
-        U3 = qutip.rand_unitary(4)
-        U = qutip.tensor(U1, U2, U3)
-        S = qutip.to_super(U)
-        S_col = qutip.reshuffle(S)
-        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
-        assert qutip.reshuffle(S_col) == S
-
-    def test_sprepost(self):
-        U1 = qutip.rand_unitary(3)
-        U2 = qutip.rand_unitary(3)
-        S1 = qutip.spre(U1) * qutip.spost(U2)
-        S2 = qutip.sprepost(U1, U2)
-        assert S1 == S2
-
-    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
-    @pytest.mark.parametrize("operation", [qutip.spre,
-                                           qutip.spost,
-                                           qutip.liouvillian,
-                                           qutip.lindblad_dissipator])
-    def test_operation_dtype(self, dtype, operation):
-        """This test checks that the dtype is properly kept with the
-        `operation` function."""
-        U1 = qutip.rand_unitary(3).to(dtype)
-        result = operation(U1)
-        assert type(result.data) == dtype
-
-    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
-    def test_sprepost_dtype(self, dtype):
-        """This test checks that the dtype is properly kept with `sprepost`
-        function."""
-        U1 = qutip.rand_unitary(3).to(dtype)
-        result = qutip.sprepost(U1, U1)
-        assert type(result.data) == dtype
-
-    def testLiouvillianImplem(self):
-        """
-        Superoperator: Randomized comparison of standard and reference
-        Liouvillian functions.
-        """
-        N1, N2, N3 = 3, 4, 5
-        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
-                          qutip.qeye([N2, N3]))
-        a2 = qutip.tensor(qutip.qeye(N1),
-                          qutip.rand_dm(N2, density=0.75),
-                          qutip.qeye(N3))
-        a3 = qutip.tensor(qutip.qeye([N1, N2]),
-                          qutip.rand_dm(N3, density=0.75))
-        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
-        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
-        L1 = qutip.liouvillian(H, c_ops)
-        L2 = liouvillian_ref(H, c_ops)
-        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
-
-
-class TestSuper_td:
-    """
-    A test class for the QuTiP superoperator functions.
-    """
-    N = 3
-    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
-                        [qutip.create(N) * (1 - 0.1j), f]])
-    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
-    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
-    q1 = qutip.qeye(N) * (1 + 0.3j)
-    q2 = qutip.destroy(N) * (1 - 0.3j)
-    q3 = qutip.num(N) * (1 + 0.4j)
-
-    def test_spre_td(self):
-        "Superoperator: spre, time-dependent"
-        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
-
-    def test_spost_td(self):
-        "Superoperator: spre, time-dependent"
-        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
-
-    def test_sprepost_td(self):
-        "Superoperator: sprepost, time-dependent"
-        # left QobjEvo
-        assert (qutip.sprepost(self.t1, self.q2)(0.5)
-                == qutip.sprepost(self.t1(0.5), self.q2))
-        # left QobjEvo
-        assert (qutip.sprepost(self.q2, self.t1)(0.5)
-                == qutip.sprepost(self.q2, self.t1(0.5)))
-        # left 2 QobjEvo, one cte
-        assert (qutip.sprepost(self.t1, self.t2)(0.5)
-                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
-
-    def test_operator_vector_td(self):
-        "Superoperator: operator_to_vector, time-dependent"
-        assert (qutip.operator_to_vector(self.t1)(0.5)
-                == qutip.operator_to_vector(self.t1(0.5)))
-        vec = qutip.operator_to_vector(self.t1)
-        assert (qutip.vector_to_operator(vec)(0.5)
-                == qutip.vector_to_operator(vec(0.5)))
-
-    def test_liouvillian_td(self):
-        "Superoperator: liouvillian, time-dependent"
-        assert (qutip.liouvillian(self.t1)(0.5)
-                == qutip.liouvillian(self.t1(0.5)))
-        assert (qutip.liouvillian(None, [self.t2])(0.5)
-                == qutip.liouvillian(None, [self.t2(0.5)]))
-        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
-                                  chi=[1, 2, 3])(0.5)
-                == qutip.liouvillian(self.t1(0.5),
-                                     [self.t2(0.5), self.q1, self.t3(0.5)],
-                                     chi=[1, 2, 3]))
-
-    def test_lindblad_dissipator_td(self):
-        "Superoperator: lindblad_dissipator, time-dependent"
-        assert (qutip.lindblad_dissipator(self.t2)(0.5)
-                == qutip.lindblad_dissipator(self.t2(0.5)))
-        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
-                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
-        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
-                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
+import numpy as np
+import scipy.linalg
+
+import qutip
+from qutip.core import data as _data
+import pytest
+
+
+def f(t, args):
+    return t * (1 - 0.5j)
+
+
+def liouvillian_ref(H, c_ops=()):
+    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
+    for c in c_ops:
+        if c.issuper:
+            L += c
+        else:
+            cdc = c.dag() * c
+            L += qutip.sprepost(c, c.dag())
+            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
+    return L
+
+
+class TestMatVec:
+    """
+    A test class for the QuTiP function for matrix/vector conversion.
+    """
+    def testOperatorVector(self):
+        """
+        Superoperator: Operator - vector - operator conversion.
+        """
+        N = 3
+        rho1 = qutip.rand_dm(N)
+        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testsuperrep(self):
+        N = 3
+        rho1 = qutip.rand_dm(N)
+        as_vec = qutip.operator_to_vector(rho1)
+        assert as_vec.superrep == 'super'
+
+        with pytest.raises(TypeError) as err:
+            bad_vec = as_vec.copy()
+            bad_vec.superrep = ""
+            qutip.vector_to_operator(bad_vec)
+        assert err.value.args[0] == ("only defined for operator-kets "
+                                     "in super format")
+
+        with pytest.raises(TypeError) as err:
+            qutip.operator_to_vector(as_vec)
+        assert err.value.args[0] == ("Cannot convert object already "
+                                     "in super representation")
+
+    def testOperatorVectorTensor(self):
+        """
+        Superoperator: Operator - vector - operator conversion with a tensor
+        product state.
+        """
+        Na = 3
+        Nb = 2
+        rhoa = qutip.rand_dm(Na)
+        rhob = qutip.rand_dm(Nb)
+        rho1 = qutip.tensor(rhoa, rhob)
+        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testOperatorVectorNotSquare(self):
+        """
+        Superoperator: Operator - vector - operator conversion for non-square
+        matrix.
+        """
+        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
+        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
+        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
+
+    def testOperatorSpreAppl(self):
+        """
+        Superoperator: apply operator and superoperator from left (spre)
+        """
+        N = 3
+        rho = qutip.rand_dm(N)
+        U = qutip.rand_unitary(N)
+        rho1 = U * rho
+        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
+        rho2 = qutip.vector_to_operator(rho2_vec)
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testOperatorSpostAppl(self):
+        """
+        Superoperator: apply operator and superoperator from right (spost)
+        """
+        N = 3
+        rho = qutip.rand_dm(N)
+        U = qutip.rand_unitary(N)
+        rho1 = rho * U
+        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
+        rho2 = qutip.vector_to_operator(rho2_vec)
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testOperatorUnitaryTransform(self):
+        """
+        Superoperator: Unitary transformation with operators and superoperators
+        """
+        N = 3
+        rho = qutip.rand_dm(N)
+        U = qutip.rand_unitary(N)
+        rho1 = U * rho * U.dag()
+        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
+        rho2 = qutip.vector_to_operator(rho2_vec)
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testMatrixVecMat(self):
+        """
+        Superoperator: Conversion matrix to vector to matrix
+        """
+        M = _data.create(np.random.rand(10, 10))
+        V = qutip.stack_columns(M)
+        M2 = qutip.unstack_columns(V)
+        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
+
+    def testVecMatVec(self):
+        """
+        Superoperator: Conversion vector to matrix to vector
+        """
+        V = _data.create(np.random.rand(100, 1))
+        M = qutip.unstack_columns(V)
+        V2 = qutip.stack_columns(M)
+        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
+
+    def testVecMatIndexConversion(self):
+        """
+        Superoperator: Conversion between matrix and vector indices
+        """
+        N = 10
+        for i in range(N * N):
+            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
+
+    def testVecMatIndexCompability(self):
+        """
+        Superoperator: Compatibility between matrix/vector and
+        corresponding index conversions.
+        """
+        N = 10
+        M = _data.create(np.random.rand(N, N))
+        V = qutip.stack_columns(M)
+        for idx in range(N * N):
+            i, j = qutip.unstacked_index(N, idx)
+            assert V.to_array()[idx, 0] == M.to_array()[i, j]
+
+    def test_reshuffle(self):
+        U1 = qutip.rand_unitary(2)
+        U2 = qutip.rand_unitary(3)
+        U3 = qutip.rand_unitary(4)
+        U = qutip.tensor(U1, U2, U3)
+        S = qutip.to_super(U)
+        S_col = qutip.reshuffle(S)
+        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
+        assert qutip.reshuffle(S_col) == S
+
+    def test_sprepost(self):
+        U1 = qutip.rand_unitary(3)
+        U2 = qutip.rand_unitary(3)
+        S1 = qutip.spre(U1) * qutip.spost(U2)
+        S2 = qutip.sprepost(U1, U2)
+        assert S1 == S2
+
+    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
+    @pytest.mark.parametrize("operation", [qutip.spre,
+                                           qutip.spost,
+                                           qutip.liouvillian,
+                                           qutip.lindblad_dissipator])
+    def test_operation_dtype(self, dtype, operation):
+        """This test checks that the dtype is properly kept with the
+        `operation` function."""
+        U1 = qutip.rand_unitary(3).to(dtype)
+        result = operation(U1)
+        assert type(result.data) == dtype
+
+    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
+    def test_sprepost_dtype(self, dtype):
+        """This test checks that the dtype is properly kept with `sprepost`
+        function."""
+        U1 = qutip.rand_unitary(3).to(dtype)
+        result = qutip.sprepost(U1, U1)
+        assert type(result.data) == dtype
+
+    def testLiouvillianImplem(self):
+        """
+        Superoperator: Randomized comparison of standard and reference
+        Liouvillian functions.
+        """
+        N1, N2, N3 = 3, 4, 5
+        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
+                          qutip.qeye([N2, N3]))
+        a2 = qutip.tensor(qutip.qeye(N1),
+                          qutip.rand_dm(N2, density=0.75),
+                          qutip.qeye(N3))
+        a3 = qutip.tensor(qutip.qeye([N1, N2]),
+                          qutip.rand_dm(N3, density=0.75))
+        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
+        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
+        L1 = qutip.liouvillian(H, c_ops)
+        L2 = liouvillian_ref(H, c_ops)
+        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
+
+
+class TestSuper_td:
+    """
+    A test class for the QuTiP superoperator functions.
+    """
+    N = 3
+    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
+                        [qutip.create(N) * (1 - 0.1j), f]])
+    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
+    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
+    q1 = qutip.qeye(N) * (1 + 0.3j)
+    q2 = qutip.destroy(N) * (1 - 0.3j)
+    q3 = qutip.num(N) * (1 + 0.4j)
+
+    def test_spre_td(self):
+        "Superoperator: spre, time-dependent"
+        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
+
+    def test_spost_td(self):
+        "Superoperator: spre, time-dependent"
+        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
+
+    def test_sprepost_td(self):
+        "Superoperator: sprepost, time-dependent"
+        # left QobjEvo
+        assert (qutip.sprepost(self.t1, self.q2)(0.5)
+                == qutip.sprepost(self.t1(0.5), self.q2))
+        # left QobjEvo
+        assert (qutip.sprepost(self.q2, self.t1)(0.5)
+                == qutip.sprepost(self.q2, self.t1(0.5)))
+        # left 2 QobjEvo, one cte
+        assert (qutip.sprepost(self.t1, self.t2)(0.5)
+                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
+
+    def test_operator_vector_td(self):
+        "Superoperator: operator_to_vector, time-dependent"
+        assert (qutip.operator_to_vector(self.t1)(0.5)
+                == qutip.operator_to_vector(self.t1(0.5)))
+        vec = qutip.operator_to_vector(self.t1)
+        assert (qutip.vector_to_operator(vec)(0.5)
+                == qutip.vector_to_operator(vec(0.5)))
+
+    def test_liouvillian_td(self):
+        "Superoperator: liouvillian, time-dependent"
+        assert (qutip.liouvillian(self.t1)(0.5)
+                == qutip.liouvillian(self.t1(0.5)))
+        assert (qutip.liouvillian(None, [self.t2])(0.5)
+                == qutip.liouvillian(None, [self.t2(0.5)]))
+        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
+                                  chi=[1, 2, 3])(0.5)
+                == qutip.liouvillian(self.t1(0.5),
+                                     [self.t2(0.5), self.q1, self.t3(0.5)],
+                                     chi=[1, 2, 3]))
+
+    def test_lindblad_dissipator_td(self):
+        "Superoperator: lindblad_dissipator, time-dependent"
+        assert (qutip.lindblad_dissipator(self.t2)(0.5)
+                == qutip.lindblad_dissipator(self.t2(0.5)))
+        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
+                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
+        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
+                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
diff --git a/qutip/tests/core/test_tensor.py b/qutip/tests/core/test_tensor.py
index 10e493e46f..41ba5672ea 100644
--- a/qutip/tests/core/test_tensor.py
+++ b/qutip/tests/core/test_tensor.py
@@ -1,257 +1,257 @@
-import numpy as np
-
-from numpy.testing import assert_equal, assert_
-import pytest
-import functools
-import itertools
-import qutip
-from qutip import (
-    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
-    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
-    expand_operator
-)
-
-
-def test_tensor_contract_ident():
-    qobj = identity([2, 3, 4])
-    ans = 3 * identity([2, 4])
-
-    assert_(ans == tensor_contract(qobj, (1, 4)))
-
-    # Now try for superoperators.
-    # For now, we just ensure the dims are correct.
-    sqobj = to_super(qobj)
-    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
-    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
-
-
-def case_tensor_contract_other(left, right, pairs,
-                               expected_dims, expected_data):
-    dat = np.arange(np.prod(left) * np.prod(right))
-    dat = dat.reshape((np.prod(left), np.prod(right)))
-
-    qobj = Qobj(dat, dims=[left, right])
-    cqobj = tensor_contract(qobj, *pairs)
-    assert_equal(cqobj.dims, expected_dims)
-    assert_equal(cqobj.full(), expected_data)
-
-
-def test_tensor_contract_other():
-    case_tensor_contract_other(
-        [2, 3], [3, 4], [(1, 2)],
-        [[2], [4]],
-        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
-    )
-
-    case_tensor_contract_other(
-        [2, 3], [4, 3], [(1, 3)],
-        [[2], [4]],
-        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
-    )
-
-    case_tensor_contract_other(
-        [2, 3], [4, 3], [(1, 3)],
-        [[2], [4]],
-        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
-    )
-
-    # Make non-rectangular outputs in a column-/row-symmetric fashion.
-    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
-
-    case_tensor_contract_other(
-        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
-        [[[3], [3]], [[2, 3], [2, 3]]],
-        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
-
-    case_tensor_contract_other(
-        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
-        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
-        # We separate einsum into two calls due to a bug internal to
-        # einsum.
-        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
-
-    # Now we try collapsing in a way that's sensitive to column- and row-
-    # stacking conventions.
-    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
-    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
-    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
-    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
-
-    # Let's try a weird tensor contraction; this will likely never come up in
-    # practice, but it should serve as a good canary for more reasonable
-    # contractions.
-    case_tensor_contract_other(
-        big_dims[0], big_dims[1], [(0, 4)],
-        [[[2], [3, 3]], [[3], [2, 3]]],
-        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
-
-
-def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
-    sqobj = tensor_swap(qobj, *pairs)
-
-    assert_equal(sqobj.dims, expected_dims)
-    assert_equal(sqobj.full(), expected_data.full())
-
-
-def test_tensor_swap_other():
-    dims = (2, 3, 4, 5, 7)
-    for dim in dims:
-        S = to_super(rand_super_bcsz(dim))
-        # Swapping the inner indices on a superoperator should give a Choi
-        # matrix.
-        J = to_choi(S)
-        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
-
-
-def test_tensor_qobjevo():
-    N = 5
-    t = 1.5
-    left = QobjEvo([num(N),[destroy(N),"t"]])
-    right = QobjEvo([identity(2),[sigmax(),"t"]])
-    assert tensor(left, right)(t) == tensor(left(t), right(t))
-    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
-    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
-
-
-def test_tensor_qobjevo_non_square():
-    N = 5
-    t = 1.5
-    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
-    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
-    assert tensor(left, right)(t) == tensor(left(t), right(t))
-
-
-def test_tensor_qobjevo_multiple():
-    N = 5
-    t = 1.5
-    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
-    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
-    right = QobjEvo([sigmax()])
-    as_QobjEvo = tensor(left, center, right)(t)
-    as_Qobj = tensor(left(t), center(t), right(t))
-    assert as_QobjEvo == as_Qobj
-
-
-def test_tensor_and():
-    N = 5
-    t = 1.5
-    sx = sigmax()
-    evo = QobjEvo([num(N),[destroy(N),"t"]])
-    assert tensor([sx, sx, sx]) == sx & sx & sx
-    assert tensor(evo, sx)(t) == (evo & sx)(t)
-    assert tensor(sx, evo)(t) == (sx & evo)(t)
-    assert tensor(evo, evo)(t) == (evo & evo)(t)
-
-
-def _permutation_id(permutation):
-    return str(len(permutation)) + "-" + "".join(map(str, permutation))
-
-
-def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
-    """
-    Create a full tensor product when a subspace component is already in an
-    entangled state.  The locations in `all_qubits` which are the entangled
-    points in the output are ignored and can take any value.
-
-    For example,
-        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
-    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
-    in the final output are entangled, but the others are still separable.
-
-    Parameters:
-        all_qubits: list of kets --
-            A list of separable parts to tensor together.  States that are in
-            the locations referred to by `entangled_locations` are completely
-            ignored.
-        entangled: tensor-product ket -- the full entangled subspace
-        entangled_locations: list of int --
-            The locations that the qubits in the entangled subspace should be
-            in in the final tensor-product space.
-    """
-    n_entangled = len(entangled.dims[0])
-    n_separable = len(all_qubits) - n_entangled
-    separable = all_qubits.copy()
-    # Remove in reverse order so subsequent deletion locations don't change.
-    for location in sorted(entangled_locations, reverse=True):
-        del separable[location]
-    # Can't separate out entangled states to pass to tensor in the right places
-    # immediately, so tensor in at one end and then permute into place.
-    out = qutip.tensor(*separable, entangled)
-    permutation = list(range(n_separable))
-    current_locations = range(n_separable, n_separable + n_entangled)
-    # Sort to prevert later insertions changing previous locations.
-    insertions = sorted(zip(entangled_locations, current_locations),
-                        key=lambda x: x[0])
-    for out_location, current_location in insertions:
-        permutation.insert(out_location, current_location)
-    return out.permute(permutation)
-
-
-def _apply_permutation(permutation):
-    """
-    Permute the given permutation into the order denoted by its elements, i.e.
-        out[0] = permutation[permutation[0]]
-        out[1] = permutation[permutation[1]]
-        ...
-
-    This function is its own inverse.
-    """
-    out = [None] * len(permutation)
-    for value, location in enumerate(permutation):
-        out[location] = value
-    return out
-
-
-class Test_expand_operator:
-    @pytest.mark.parametrize(
-        'permutation',
-        tuple(itertools.chain(*[
-            itertools.permutations(range(k)) for k in [2, 3, 4]
-        ])),
-        ids=_permutation_id)
-    def test_permutation_without_expansion(self, permutation):
-        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
-        test = expand_operator(base, [2] * len(permutation), permutation)
-        expected = base.permute(_apply_permutation(permutation))
-        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
-
-    @pytest.mark.parametrize('n_targets', range(1, 5))
-    def test_general_qubit_expansion(self, n_targets):
-        # Test all permutations with the given number of targets.
-        n_qubits = 5
-        operation = qutip.rand_unitary([2]*n_targets)
-        for targets in itertools.permutations(range(n_qubits), n_targets):
-            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
-                                                 operation, targets)
-            test = expand_operator(operation, [2] * 5, targets)
-            np.testing.assert_allclose(test.full(), expected.full(),
-                                       atol=1e-15)
-
-    def test_cnot_explicit(self):
-        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
-        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
-                             [0, 0, 0, 0, 0, 1, 0, 0],
-                             [0, 0, 1, 0, 0, 0, 0, 0],
-                             [0, 0, 0, 0, 0, 0, 0, 1],
-                             [0, 0, 0, 0, 1, 0, 0, 0],
-                             [0, 1, 0, 0, 0, 0, 0, 0],
-                             [0, 0, 0, 0, 0, 0, 1, 0],
-                             [0, 0, 0, 1, 0, 0, 0, 0]])
-        np.testing.assert_allclose(test, expected, atol=1e-15)
-
-    @pytest.mark.parametrize('dimensions', [
-        pytest.param([3, 4, 5], id="standard"),
-        pytest.param([3, 3, 4, 4, 2], id="standard"),
-        pytest.param([1, 2, 3], id="1D space"),
-    ])
-    def test_non_qubit_systems(self, dimensions):
-        n_qubits = len(dimensions)
-        for targets in itertools.permutations(range(n_qubits), 2):
-            operators = [qutip.rand_unitary(dimension) if n in targets
-                         else qutip.qeye(dimension)
-                         for n, dimension in enumerate(dimensions)]
-            expected = qutip.tensor(*operators)
-            base_test = qutip.tensor(*[operators[x] for x in targets])
-            test = expand_operator(base_test, dims=dimensions, targets=targets)
-            assert test.dims == expected.dims
-            np.testing.assert_allclose(test.full(), expected.full())
+import numpy as np
+
+from numpy.testing import assert_equal, assert_
+import pytest
+import functools
+import itertools
+import qutip
+from qutip import (
+    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
+    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
+    expand_operator
+)
+
+
+def test_tensor_contract_ident():
+    qobj = identity([2, 3, 4])
+    ans = 3 * identity([2, 4])
+
+    assert_(ans == tensor_contract(qobj, (1, 4)))
+
+    # Now try for superoperators.
+    # For now, we just ensure the dims are correct.
+    sqobj = to_super(qobj)
+    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
+    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
+
+
+def case_tensor_contract_other(left, right, pairs,
+                               expected_dims, expected_data):
+    dat = np.arange(np.prod(left) * np.prod(right))
+    dat = dat.reshape((np.prod(left), np.prod(right)))
+
+    qobj = Qobj(dat, dims=[left, right])
+    cqobj = tensor_contract(qobj, *pairs)
+    assert_equal(cqobj.dims, expected_dims)
+    assert_equal(cqobj.full(), expected_data)
+
+
+def test_tensor_contract_other():
+    case_tensor_contract_other(
+        [2, 3], [3, 4], [(1, 2)],
+        [[2], [4]],
+        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
+    )
+
+    case_tensor_contract_other(
+        [2, 3], [4, 3], [(1, 3)],
+        [[2], [4]],
+        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
+    )
+
+    case_tensor_contract_other(
+        [2, 3], [4, 3], [(1, 3)],
+        [[2], [4]],
+        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
+    )
+
+    # Make non-rectangular outputs in a column-/row-symmetric fashion.
+    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
+
+    case_tensor_contract_other(
+        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
+        [[[3], [3]], [[2, 3], [2, 3]]],
+        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
+
+    case_tensor_contract_other(
+        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
+        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
+        # We separate einsum into two calls due to a bug internal to
+        # einsum.
+        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
+
+    # Now we try collapsing in a way that's sensitive to column- and row-
+    # stacking conventions.
+    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
+    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
+    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
+    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
+
+    # Let's try a weird tensor contraction; this will likely never come up in
+    # practice, but it should serve as a good canary for more reasonable
+    # contractions.
+    case_tensor_contract_other(
+        big_dims[0], big_dims[1], [(0, 4)],
+        [[[2], [3, 3]], [[3], [2, 3]]],
+        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
+
+
+def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
+    sqobj = tensor_swap(qobj, *pairs)
+
+    assert_equal(sqobj.dims, expected_dims)
+    assert_equal(sqobj.full(), expected_data.full())
+
+
+def test_tensor_swap_other():
+    dims = (2, 3, 4, 5, 7)
+    for dim in dims:
+        S = to_super(rand_super_bcsz(dim))
+        # Swapping the inner indices on a superoperator should give a Choi
+        # matrix.
+        J = to_choi(S)
+        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
+
+
+def test_tensor_qobjevo():
+    N = 5
+    t = 1.5
+    left = QobjEvo([num(N),[destroy(N),"t"]])
+    right = QobjEvo([identity(2),[sigmax(),"t"]])
+    assert tensor(left, right)(t) == tensor(left(t), right(t))
+    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
+    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
+
+
+def test_tensor_qobjevo_non_square():
+    N = 5
+    t = 1.5
+    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
+    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
+    assert tensor(left, right)(t) == tensor(left(t), right(t))
+
+
+def test_tensor_qobjevo_multiple():
+    N = 5
+    t = 1.5
+    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
+    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
+    right = QobjEvo([sigmax()])
+    as_QobjEvo = tensor(left, center, right)(t)
+    as_Qobj = tensor(left(t), center(t), right(t))
+    assert as_QobjEvo == as_Qobj
+
+
+def test_tensor_and():
+    N = 5
+    t = 1.5
+    sx = sigmax()
+    evo = QobjEvo([num(N),[destroy(N),"t"]])
+    assert tensor([sx, sx, sx]) == sx & sx & sx
+    assert tensor(evo, sx)(t) == (evo & sx)(t)
+    assert tensor(sx, evo)(t) == (sx & evo)(t)
+    assert tensor(evo, evo)(t) == (evo & evo)(t)
+
+
+def _permutation_id(permutation):
+    return str(len(permutation)) + "-" + "".join(map(str, permutation))
+
+
+def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
+    """
+    Create a full tensor product when a subspace component is already in an
+    entangled state.  The locations in `all_qubits` which are the entangled
+    points in the output are ignored and can take any value.
+
+    For example,
+        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
+    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
+    in the final output are entangled, but the others are still separable.
+
+    Parameters:
+        all_qubits: list of kets --
+            A list of separable parts to tensor together.  States that are in
+            the locations referred to by `entangled_locations` are completely
+            ignored.
+        entangled: tensor-product ket -- the full entangled subspace
+        entangled_locations: list of int --
+            The locations that the qubits in the entangled subspace should be
+            in in the final tensor-product space.
+    """
+    n_entangled = len(entangled.dims[0])
+    n_separable = len(all_qubits) - n_entangled
+    separable = all_qubits.copy()
+    # Remove in reverse order so subsequent deletion locations don't change.
+    for location in sorted(entangled_locations, reverse=True):
+        del separable[location]
+    # Can't separate out entangled states to pass to tensor in the right places
+    # immediately, so tensor in at one end and then permute into place.
+    out = qutip.tensor(*separable, entangled)
+    permutation = list(range(n_separable))
+    current_locations = range(n_separable, n_separable + n_entangled)
+    # Sort to prevert later insertions changing previous locations.
+    insertions = sorted(zip(entangled_locations, current_locations),
+                        key=lambda x: x[0])
+    for out_location, current_location in insertions:
+        permutation.insert(out_location, current_location)
+    return out.permute(permutation)
+
+
+def _apply_permutation(permutation):
+    """
+    Permute the given permutation into the order denoted by its elements, i.e.
+        out[0] = permutation[permutation[0]]
+        out[1] = permutation[permutation[1]]
+        ...
+
+    This function is its own inverse.
+    """
+    out = [None] * len(permutation)
+    for value, location in enumerate(permutation):
+        out[location] = value
+    return out
+
+
+class Test_expand_operator:
+    @pytest.mark.parametrize(
+        'permutation',
+        tuple(itertools.chain(*[
+            itertools.permutations(range(k)) for k in [2, 3, 4]
+        ])),
+        ids=_permutation_id)
+    def test_permutation_without_expansion(self, permutation):
+        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
+        test = expand_operator(base, [2] * len(permutation), permutation)
+        expected = base.permute(_apply_permutation(permutation))
+        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
+
+    @pytest.mark.parametrize('n_targets', range(1, 5))
+    def test_general_qubit_expansion(self, n_targets):
+        # Test all permutations with the given number of targets.
+        n_qubits = 5
+        operation = qutip.rand_unitary([2]*n_targets)
+        for targets in itertools.permutations(range(n_qubits), n_targets):
+            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
+                                                 operation, targets)
+            test = expand_operator(operation, [2] * 5, targets)
+            np.testing.assert_allclose(test.full(), expected.full(),
+                                       atol=1e-15)
+
+    def test_cnot_explicit(self):
+        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
+        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
+                             [0, 0, 0, 0, 0, 1, 0, 0],
+                             [0, 0, 1, 0, 0, 0, 0, 0],
+                             [0, 0, 0, 0, 0, 0, 0, 1],
+                             [0, 0, 0, 0, 1, 0, 0, 0],
+                             [0, 1, 0, 0, 0, 0, 0, 0],
+                             [0, 0, 0, 0, 0, 0, 1, 0],
+                             [0, 0, 0, 1, 0, 0, 0, 0]])
+        np.testing.assert_allclose(test, expected, atol=1e-15)
+
+    @pytest.mark.parametrize('dimensions', [
+        pytest.param([3, 4, 5], id="standard"),
+        pytest.param([3, 3, 4, 4, 2], id="standard"),
+        pytest.param([1, 2, 3], id="1D space"),
+    ])
+    def test_non_qubit_systems(self, dimensions):
+        n_qubits = len(dimensions)
+        for targets in itertools.permutations(range(n_qubits), 2):
+            operators = [qutip.rand_unitary(dimension) if n in targets
+                         else qutip.qeye(dimension)
+                         for n, dimension in enumerate(dimensions)]
+            expected = qutip.tensor(*operators)
+            base_test = qutip.tensor(*[operators[x] for x in targets])
+            test = expand_operator(base_test, dims=dimensions, targets=targets)
+            assert test.dims == expected.dims
+            np.testing.assert_allclose(test.full(), expected.full())
diff --git a/qutip/tests/pytest.ini b/qutip/tests/pytest.ini
index 02ffbe592c..97561c1575 100644
--- a/qutip/tests/pytest.ini
+++ b/qutip/tests/pytest.ini
@@ -1,5 +1,5 @@
-[pytest]
-markers =
-    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
-    repeat(n): Repeat the given test 'n' times.
-    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
+[pytest]
+markers =
+    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
+    repeat(n): Repeat the given test 'n' times.
+    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
diff --git a/qutip/tests/solve/test_piqs.py b/qutip/tests/solve/test_piqs.py
index a069a2905b..293cd586e6 100644
--- a/qutip/tests/solve/test_piqs.py
+++ b/qutip/tests/solve/test_piqs.py
@@ -1,1536 +1,1536 @@
-"""
-Tests for Permutational Invariant Quantum solver (PIQS).
-"""
-import numpy as np
-from numpy.testing import (
-    assert_,
-    run_module_suite,
-    assert_raises,
-    assert_array_equal,
-    assert_array_almost_equal,
-    assert_almost_equal,
-    assert_equal,
-)
-from scipy.sparse import block_diag
-from qutip import Qobj, entropy_vn, sigmax, sigmaz
-from qutip.solve._piqs import (
-    get_blocks,
-    j_min,
-    j_vals,
-    m_vals,
-    _num_dicke_states,
-    _num_dicke_ladders,
-    get_index,
-    jmm1_dictionary,
-)
-from qutip.solve._piqs import Dicke as _Dicke
-from qutip.solve.piqs import *
-
-import sys
-import unittest
-
-
-# Disable tests for python2 as qutip.piqs does not support python2.
-if sys.version_info[0] < 3:
-    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
-
-
-class TestDicke:
-    """
-    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
-    """
-
-    def test_num_dicke_states(self):
-        """
-        PIQS: Test the `num_dicke_state` function.
-        """
-        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
-        dicke_states = [num_dicke_states(i) for i in N_list]
-        assert_array_equal(
-            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
-        )
-        N = -1
-        assert_raises(ValueError, num_dicke_states, N)
-        N = 0.2
-        assert_raises(ValueError, num_dicke_states, N)
-
-    def test_num_tls(self):
-        """
-        PIQS: Test the `num_two_level` function.
-        """
-        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
-        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
-        calculated_N = [num_tls(i) for i in N_dicke]
-        assert_array_equal(calculated_N, N)
-
-    def test_num_dicke_ladders(self):
-        """
-        PIQS: Test the `_num_dicke_ladders` function.
-        """
-        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
-        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
-        assert_array_equal(ndl, ndl_true)
-
-    def test_get_blocks(self):
-        """
-        PIQS: Test the function to get blocks.
-        """
-        N_list = [1, 2, 5, 7]
-        blocks = [
-            np.array([2]),
-            np.array([3, 4]),
-            np.array([6, 10, 12]),
-            np.array([8, 14, 18, 20]),
-        ]
-        calculated_blocks = [get_blocks(i) for i in N_list]
-        for (i, j) in zip(calculated_blocks, blocks):
-            assert_array_equal(i, j)
-
-    def test_j_vals(self):
-        """
-        PIQS: Test calculation of j values for given N.
-        """
-        N_list = [1, 2, 3, 4, 7]
-        j_vals_real = [
-            np.array([0.5]),
-            np.array([0.0, 1.0]),
-            np.array([0.5, 1.5]),
-            np.array([0.0, 1.0, 2.0]),
-            np.array([0.5, 1.5, 2.5, 3.5]),
-        ]
-        j_vals_calc = [j_vals(i) for i in N_list]
-
-        for (i, j) in zip(j_vals_calc, j_vals_real):
-            assert_array_equal(i, j)
-
-    def test_m_vals(self):
-        """
-        PIQS: Test calculation of m values for a particular j.
-        """
-        j_list = [0.5, 1, 1.5, 2, 2.5]
-        m_real = [
-            np.array([-0.5, 0.5]),
-            np.array([-1, 0, 1]),
-            np.array([-1.5, -0.5, 0.5, 1.5]),
-            np.array([-2, -1, 0, 1, 2]),
-            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
-        ]
-
-        m_calc = [m_vals(i) for i in j_list]
-        for (i, j) in zip(m_real, m_calc):
-            assert_array_equal(i, j)
-
-    def test_dicke_blocks(self):
-        """
-        PIQS: Test the `dicke_blocks` function.
-        """
-        # test 1
-        # mixed state with non-symmetrical block matrix elements
-        N = 3
-        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        test_blocks = dicke_blocks(true_matrix)
-        test_matrix = Qobj(block_diag(test_blocks))
-        assert_(test_matrix == true_matrix)
-        # test 2
-        # all elements in block-diagonal matrix
-        N = 4
-        true_matrix = Qobj(block_matrix(N)).unit()
-        test_blocks = dicke_blocks(true_matrix)
-        test_matrix = Qobj(block_diag(test_blocks))
-        assert_(test_matrix == true_matrix)
-
-    def test_dicke_blocks_full(self):
-        """
-        PIQS: Test the `dicke_blocks_full` function.
-        """
-        N = 3
-        test_blocks = dicke_blocks_full(excited(3))
-        test_matrix = Qobj(block_diag(test_blocks))
-        true_expanded = np.zeros((8, 8))
-        true_expanded[0, 0] = 1.0
-        assert_(test_matrix == Qobj(true_expanded))
-
-    def test_dicke_function_trace(self):
-        """
-        PIQS: Test the `dicke_function_trace` function.
-        """
-        ## test for N odd
-        N = 3
-        # test trace
-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        f = lambda x: x
-        test_val = dicke_function_trace(f, rho_mixed)
-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
-        true_val2 = (rho_mixed).tr()
-        # test with linear function (trace)
-        assert_almost_equal(test_val, true_val)
-        assert_almost_equal(test_val, true_val2)
-        # test with nonlinear function
-        f = lambda rho: rho ** 3
-        test_val3 = dicke_function_trace(f, rho_mixed)
-        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
-        assert_almost_equal(test_val3, true_val3)
-        ## test for N even
-        N = 4
-        # test trace
-        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
-        f = lambda x: x
-        test_val = dicke_function_trace(f, rho_mixed)
-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
-        true_val2 = (rho_mixed).tr()
-        # test with linear function (trace)
-        assert_almost_equal(test_val, true_val)
-        assert_almost_equal(test_val, true_val2)
-        # test with nonlinear function
-        f = lambda rho: rho ** 3
-        test_val3 = dicke_function_trace(f, rho_mixed)
-        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
-        assert np.allclose(test_val3, true_val3)
-
-    def test_entropy_vn_dicke(self):
-        """
-        PIQS: Test the `entropy_vn_dicke` function.
-        """
-        N = 3
-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        test_val = entropy_vn_dicke(rho_mixed)
-        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
-        assert np.allclose(test_val, true_val)
-
-    def test_purity_dicke(self):
-        """
-        PIQS: Test the `purity_dicke` function.
-        """
-        N = 3
-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        test_val = purity_dicke(rho_mixed)
-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
-        assert np.allclose(test_val, true_val)
-
-    def test_get_index(self):
-        """
-        PIQS: Test the index fetching function for given j, m, m1 value.
-        """
-        N = 1
-        jmm1_list = [
-            (0.5, 0.5, 0.5),
-            (0.5, 0.5, -0.5),
-            (0.5, -0.5, 0.5),
-            (0.5, -0.5, -0.5),
-        ]
-        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
-
-        blocks = get_blocks(N)
-        calculated_indices = [
-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-            for jmm1 in jmm1_list
-        ]
-        assert_array_almost_equal(calculated_indices, indices)
-        N = 2
-        blocks = get_blocks(N)
-        jmm1_list = [
-            (1, 1, 1),
-            (1, 1, 0),
-            (1, 1, -1),
-            (1, 0, 1),
-            (1, 0, 0),
-            (1, 0, -1),
-            (1, -1, 1),
-            (1, -1, 0),
-            (1, -1, -1),
-            (0, 0, 0),
-        ]
-        indices = [
-            (0, 0),
-            (0, 1),
-            (0, 2),
-            (1, 0),
-            (1, 1),
-            (1, 2),
-            (2, 0),
-            (2, 1),
-            (2, 2),
-            (3, 3),
-        ]
-        calculated_indices = [
-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-            for jmm1 in jmm1_list
-        ]
-        assert_array_almost_equal(calculated_indices, indices)
-        N = 3
-        blocks = get_blocks(N)
-        jmm1_list = [
-            (1.5, 1.5, 1.5),
-            (1.5, 1.5, 0.5),
-            (1.5, 1.5, -0.5),
-            (1.5, 1.5, -1.5),
-            (1.5, 0.5, 0.5),
-            (1.5, -0.5, -0.5),
-            (1.5, -1.5, -1.5),
-            (1.5, -1.5, 1.5),
-            (0.5, 0.5, 0.5),
-            (0.5, 0.5, -0.5),
-            (0.5, -0.5, 0.5),
-            (0.5, -0.5, -0.5),
-        ]
-
-        indices = [
-            (0, 0),
-            (0, 1),
-            (0, 2),
-            (0, 3),
-            (1, 1),
-            (2, 2),
-            (3, 3),
-            (3, 0),
-            (4, 4),
-            (4, 5),
-            (5, 4),
-            (5, 5),
-        ]
-
-        calculated_indices = [
-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-            for jmm1 in jmm1_list
-        ]
-        assert_array_almost_equal(calculated_indices, indices)
-
-    def test_jmm1_dictionary(self):
-        """
-        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
-        """
-        d1, d2, d3, d4 = jmm1_dictionary(1)
-
-        d1_correct = {
-            (0, 0): (0.5, 0.5, 0.5),
-            (0, 1): (0.5, 0.5, -0.5),
-            (1, 0): (0.5, -0.5, 0.5),
-            (1, 1): (0.5, -0.5, -0.5),
-        }
-
-        d2_correct = {
-            (0.5, -0.5, -0.5): (1, 1),
-            (0.5, -0.5, 0.5): (1, 0),
-            (0.5, 0.5, -0.5): (0, 1),
-            (0.5, 0.5, 0.5): (0, 0),
-        }
-
-        d3_correct = {
-            0: (0.5, 0.5, 0.5),
-            1: (0.5, 0.5, -0.5),
-            2: (0.5, -0.5, 0.5),
-            3: (0.5, -0.5, -0.5),
-        }
-
-        d4_correct = {
-            (0.5, -0.5, -0.5): 3,
-            (0.5, -0.5, 0.5): 2,
-            (0.5, 0.5, -0.5): 1,
-            (0.5, 0.5, 0.5): 0,
-        }
-
-        assert_equal(d1, d1_correct)
-        assert_equal(d2, d2_correct)
-        assert_equal(d3, d3_correct)
-        assert_equal(d4, d4_correct)
-
-        d1, d2, d3, d4 = jmm1_dictionary(2)
-
-        d1_correct = {
-            (3, 3): (0.0, -0.0, -0.0),
-            (2, 2): (1.0, -1.0, -1.0),
-            (2, 1): (1.0, -1.0, 0.0),
-            (2, 0): (1.0, -1.0, 1.0),
-            (1, 2): (1.0, 0.0, -1.0),
-            (1, 1): (1.0, 0.0, 0.0),
-            (1, 0): (1.0, 0.0, 1.0),
-            (0, 2): (1.0, 1.0, -1.0),
-            (0, 1): (1.0, 1.0, 0.0),
-            (0, 0): (1.0, 1.0, 1.0),
-        }
-
-        d2_correct = {
-            (0.0, -0.0, -0.0): (3, 3),
-            (1.0, -1.0, -1.0): (2, 2),
-            (1.0, -1.0, 0.0): (2, 1),
-            (1.0, -1.0, 1.0): (2, 0),
-            (1.0, 0.0, -1.0): (1, 2),
-            (1.0, 0.0, 0.0): (1, 1),
-            (1.0, 0.0, 1.0): (1, 0),
-            (1.0, 1.0, -1.0): (0, 2),
-            (1.0, 1.0, 0.0): (0, 1),
-            (1.0, 1.0, 1.0): (0, 0),
-        }
-
-        d3_correct = {
-            15: (0.0, -0.0, -0.0),
-            10: (1.0, -1.0, -1.0),
-            9: (1.0, -1.0, 0.0),
-            8: (1.0, -1.0, 1.0),
-            6: (1.0, 0.0, -1.0),
-            5: (1.0, 0.0, 0.0),
-            4: (1.0, 0.0, 1.0),
-            2: (1.0, 1.0, -1.0),
-            1: (1.0, 1.0, 0.0),
-            0: (1.0, 1.0, 1.0),
-        }
-
-        d4_correct = {
-            (0.0, -0.0, -0.0): 15,
-            (1.0, -1.0, -1.0): 10,
-            (1.0, -1.0, 0.0): 9,
-            (1.0, -1.0, 1.0): 8,
-            (1.0, 0.0, -1.0): 6,
-            (1.0, 0.0, 0.0): 5,
-            (1.0, 0.0, 1.0): 4,
-            (1.0, 1.0, -1.0): 2,
-            (1.0, 1.0, 0.0): 1,
-            (1.0, 1.0, 1.0): 0,
-        }
-
-        assert_equal(d1, d1_correct)
-        assert_equal(d2, d2_correct)
-        assert_equal(d3, d3_correct)
-        assert_equal(d4, d4_correct)
-
-    def test_lindbladian(self):
-        """
-        PIQS: Test the generation of the Lindbladian matrix.
-        """
-        N = 1
-        gCE = 0.5
-        gCD = 0.5
-        gCP = 0.5
-        gE = 0.1
-        gD = 0.1
-        gP = 0.1
-
-        system = Dicke(
-            N=N,
-            emission=gE,
-            pumping=gP,
-            dephasing=gD,
-            collective_emission=gCE,
-            collective_pumping=gCP,
-            collective_dephasing=gCD,
-        )
-
-        lindbladian = system.lindbladian()
-        Ldata = np.zeros((4, 4), dtype="complex")
-        Ldata[0] = [-0.6, 0, 0, 0.6]
-        Ldata[1] = [0, -0.9, 0, 0]
-        Ldata[2] = [0, 0, -0.9, 0]
-        Ldata[3] = [0.6, 0, 0, -0.6]
-
-        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
-        assert_array_almost_equal(lindbladian.full(), Ldata)
-        N = 2
-        gCE = 0.5
-        gCD = 0.5
-        gCP = 0.5
-        gE = 0.1
-        gD = 0.1
-        gP = 0.1
-        system = Dicke(
-            N=N,
-            emission=gE,
-            pumping=gP,
-            dephasing=gD,
-            collective_emission=gCE,
-            collective_pumping=gCP,
-            collective_dephasing=gCD,
-        )
-
-        lindbladian = system.lindbladian()
-
-        Ldata = np.zeros((16, 16), dtype="complex")
-        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
-        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
-        Ldata[2, 2] = -2.2999999999999998
-        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
-        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
-            1.1,
-            -2.25,
-            1.1,
-            0.05,
-        )
-        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
-        Ldata[8, 8] = -2.2999999999999998
-        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
-        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
-        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
-            0.1,
-            0.05,
-            0.1,
-            -0.25,
-        )
-        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
-        assert_array_almost_equal(lindbladian.full(), Ldata)
-
-    def test_gamma(self):
-        """
-        PIQS: Test the calculation of various gamma values for diagonal system.
-
-        For N = 6 |j, m> would be :
-
-        | 3, 3>
-        | 3, 2> | 2, 2>
-        | 3, 1> | 2, 1> | 1, 1>
-        | 3, 0> | 2, 0> | 1, 0> |0, 0>
-        | 3,-1> | 2,-1> | 1,-1>
-        | 3,-2> | 2,-2>
-        | 3,-3>
-        """
-        N = 6
-        collective_emission = 1.0
-        emission = 1.0
-        dephasing = 1.0
-        pumping = 1.0
-        collective_pumping = 1.0
-        model = _Dicke(
-            N,
-            collective_emission=collective_emission,
-            emission=emission,
-            dephasing=dephasing,
-            pumping=pumping,
-            collective_pumping=collective_pumping,
-        )
-        tau_calculated = [
-            model.gamma3((3, 1, 1)),
-            model.gamma2((2, 1, 1)),
-            model.gamma4((1, 1, 1)),
-            model.gamma5((3, 0, 0)),
-            model.gamma1((2, 0, 0)),
-            model.gamma6((1, 0, 0)),
-            model.gamma7((3, -1, -1)),
-            model.gamma8((2, -1, -1)),
-            model.gamma9((1, -1, -1)),
-        ]
-        tau_real = [
-            2.0,
-            8.0,
-            0.333333,
-            1.5,
-            -19.5,
-            0.666667,
-            2.0,
-            8.0,
-            0.333333,
-        ]
-        assert_array_almost_equal(tau_calculated, tau_real)
-
-    def test_jspin(self):
-        """
-        PIQS: Test calculation of the j algebra relation for the total operators.
-
-        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
-        basis should follow the following algebra
-        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
-        """
-        N_list = [1, 2, 3, 4, 7]
-
-        for nn in N_list:
-            # tests 1
-            [jx, jy, jz] = jspin(nn)
-            jp, jm = jspin(nn, "+"), jspin(nn, "-")
-            test_jxjy = jx * jy - jy * jx
-            true_jxjy = 1j * jz
-            test_jpjm = jp * jm - jm * jp
-            true_jpjm = 2 * jz
-
-            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
-            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
-
-            # tests 2
-            [jx, jy, jz] = jspin(nn)
-            jp, jm = jspin(nn, "+"), jspin(nn, "-")
-            test_jxjy = jx * jy - jy * jx
-            true_jxjy = 1j * jz
-            test_jpjm = jp * jm - jm * jp
-            true_jpjm = 2 * jz
-
-            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
-            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
-
-            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
-            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
-            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
-            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
-            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
-            assert_raises(TypeError, jspin, nn, "q")
-
-    def test_j_min_(self):
-        """
-        PIQS: Test the `j_min` function.
-        """
-        even = [2, 4, 6, 8]
-        odd = [1, 3, 5, 7]
-
-        for i in even:
-            assert_(j_min(i) == 0)
-
-        for i in odd:
-            assert_(j_min(i) == 0.5)
-
-    def test_energy_degeneracy(self):
-        """
-        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
-        """
-        true_en_deg = [1, 1, 1, 1, 1]
-        true_en_deg_even = [2, 6, 20]
-        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
-        test_en_deg = []
-        test_en_deg_even = []
-        test_en_deg_odd = []
-
-        for nn in [1, 2, 3, 4, 7]:
-            test_en_deg.append(energy_degeneracy(nn, nn / 2))
-
-        for nn in [2, 4, 6]:
-            test_en_deg_even.append(energy_degeneracy(nn, 0))
-
-        for nn in [1, 3, 7]:
-            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
-            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
-
-        assert_array_equal(test_en_deg, true_en_deg)
-        assert_array_equal(test_en_deg_even, true_en_deg_even)
-        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
-
-    def test_state_degeneracy(self):
-        """
-        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
-        state_degeneracy(N, j).
-        """
-        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
-        state_deg = []
-        state_deg = []
-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-            state_deg.append(state_degeneracy(nn, nn / 2))
-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
-        assert_array_equal(state_deg, true_state_deg)
-
-        # check error
-        assert_raises(ValueError, state_degeneracy, 2, -1)
-
-    def test_m_degeneracy(self):
-        """
-        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
-        """
-        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
-        m_deg = []
-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
-        assert_array_equal(m_deg, true_m_deg)
-
-        # check error
-        assert_raises(ValueError, m_degeneracy, 6, -6)
-
-    def test_ap(self):
-        """
-        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
-
-        For given values of j, m. For a Dicke state,
-        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
-        """
-        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
-        ap_list = []
-        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
-            ap_list.append(ap(10, m) ** 2)
-
-        assert_almost_equal(ap_list, true_ap_list)
-
-    def test_am(self):
-        """
-        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
-
-        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
-        """
-        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
-        am_list = []
-        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
-            am_list.append(am(10, m) ** 2)
-
-        assert_almost_equal(am_list, true_am_list)
-
-    def test_spin_algebra(self):
-        """
-        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
-        The list [sx, sy, sz, sp, sm] is checked for N = 2.
-        """
-        sx1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sx2 = [
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sy1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sy2 = [
-            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
-        ]
-
-        sz1 = [
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
-        ]
-
-        sz2 = [
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
-        ]
-
-        sp1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sp2 = [
-            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sm1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sm2 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
-        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
-        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
-        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
-        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
-        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
-        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
-        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
-        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
-        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
-
-        # test error
-        assert_raises(TypeError, spin_algebra, 2, "q")
-
-    def test_collective_algebra(self):
-        """
-        PIQS: Test the generation of the collective algebra in uncoupled basis.
-
-        The list [jx, jy, jz] created in the 2^N Hilbert space is
-        checked for N = 2.
-        """
-
-        jx_n2 = [
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        jy_n2 = [
-            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
-        ]
-
-        jz_n2 = [
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
-        ]
-
-        jp_n2 = [
-            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        jm_n2 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
-        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
-        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
-        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
-        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
-
-        # error
-        assert_raises(TypeError, spin_algebra, 2, "q")
-
-    def test_block_matrix(self):
-        """
-        PIQS: Test the calculation of the block-diagonal matrix for given N.
-
-        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
-        """
-        # N = 1 TLSs
-        block_1 = [[1.0, 1.0], [1.0, 1.0]]
-
-        # N = 2 TLSs
-        block_2 = [
-            [1.0, 1.0, 1.0, 0.0],
-            [1.0, 1.0, 1.0, 0.0],
-            [1.0, 1.0, 1.0, 0.0],
-            [0.0, 0.0, 0.0, 1.0],
-        ]
-
-        # N = 3 TLSs
-        block_3 = [
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
-            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
-        ]
-
-        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
-        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
-        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
-
-    def test_dicke_basis(self):
-        """
-        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
-
-        We test the state with for N = 2,
-
-        0   0   0.3 0
-        0   0.5 0   0
-        0.3 0   0   0
-        0   0   0   0.5
-        """
-        N = 2
-        true_dicke_basis = np.zeros((4, 4))
-        true_dicke_basis[1, 1] = 0.5
-        true_dicke_basis[-1, -1] = 0.5
-        true_dicke_basis[0, 2] = 0.3
-        true_dicke_basis[2, 0] = 0.3
-        true_dicke_basis = Qobj(true_dicke_basis)
-        jmm1_1 = {(N / 2, 0, 0): 0.5}
-        jmm1_2 = {(0, 0, 0): 0.5}
-        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
-        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
-        db1 = dicke_basis(2, jmm1_1)
-        db2 = dicke_basis(2, jmm1_2)
-        db3 = dicke_basis(2, jmm1_3)
-        db4 = dicke_basis(2, jmm1_4)
-        test_dicke_basis = db1 + db2 + db3 + db4
-        assert_equal(test_dicke_basis, true_dicke_basis)
-
-        # error
-        assert_raises(AttributeError, dicke_basis, N)
-
-    def test_dicke(self):
-        """
-        PIQS: Test the calculation of the Dicke state as a pure state.
-        """
-        true_excited = np.zeros((4, 4))
-        true_excited[0, 0] = 1
-
-        true_superradiant = np.zeros((4, 4))
-        true_superradiant[1, 1] = 1
-
-        true_subradiant = np.zeros((4, 4))
-        true_subradiant[-1, -1] = 1
-
-        test_excited = dicke(2, 1, 1)
-        test_superradiant = dicke(2, 1, 0)
-        test_subradiant = dicke(2, 0, 0)
-
-        assert_equal(test_excited, Qobj(true_excited))
-        assert_equal(test_superradiant, Qobj(true_superradiant))
-        assert_equal(test_subradiant, Qobj(true_subradiant))
-
-    def test_excited(self):
-        """
-        PIQS: Test the calculation of the totally excited state density matrix.
-
-        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
-        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
-        """
-        N = 3
-        true_state = np.zeros((6, 6))
-        true_state[0, 0] = 1
-        true_state = Qobj(true_state)
-
-        test_state = excited(N)
-        assert_equal(test_state, true_state)
-
-        N = 4
-        true_state = np.zeros((9, 9))
-        true_state[0, 0] = 1
-        true_state = Qobj(true_state)
-
-        test_state = excited(N)
-        assert_equal(test_state, true_state)
-
-        # uncoupled
-        test_state_uncoupled = excited(2, basis="uncoupled")
-        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
-        assert_array_equal(test_state_uncoupled.shape, (4, 4))
-        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
-
-    def test_superradiant(self):
-        """
-        PIQS: Test the calculation of the superradiant state density matrix.
-
-        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
-        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
-        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
-        """
-        N = 3
-        true_state = np.zeros((6, 6))
-        true_state[1, 1] = 1
-        true_state = Qobj(true_state)
-        test_state = superradiant(N)
-        assert_equal(test_state, true_state)
-        N = 4
-        true_state = np.zeros((9, 9))
-        true_state[2, 2] = 1
-        true_state = Qobj(true_state)
-        test_state = superradiant(N)
-        assert_equal(test_state, true_state)
-
-        # uncoupled
-        test_state_uncoupled = superradiant(2, basis="uncoupled")
-        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
-        assert_array_equal(test_state_uncoupled.shape, (4, 4))
-        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
-
-    def test_ghz(self):
-        """
-        PIQS: Test the calculation of the density matrix of the GHZ state.
-
-        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
-        """
-        ghz_dicke = Qobj(
-            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
-        )
-        ghz_uncoupled = Qobj(
-            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
-        )
-        ghz_uncoupled.dims = [[2, 2], [2, 2]]
-        assert_equal(ghz(2), ghz_dicke)
-        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
-
-    def test_ground(self):
-        """
-        PIQS: Test the calculation of the density matrix of the ground state.
-
-        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
-        """
-        zeros = np.zeros((4, 4), dtype=np.complex128)
-        gdicke = zeros.copy()
-        guncoupled = zeros.copy()
-        gdicke[2, 2] = 1
-        guncoupled[3, 3] = 1
-
-        dim_dicke = [[4], [4]]
-        dim_uncoupled = [[2, 2], [2, 2]]
-
-        test_ground_dicke = ground(2)
-        test_ground_uncoupled = ground(2, "uncoupled")
-
-        assert_array_equal(test_ground_dicke.full(), gdicke)
-        assert_array_equal(test_ground_dicke.dims, dim_dicke)
-        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
-        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
-
-    def test_identity_uncoupled(self):
-        """
-        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
-        """
-        test_identity = identity_uncoupled(4)
-        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
-        assert_array_equal(
-            np.diag(test_identity.full()), np.ones(16, np.complex128)
-        )
-
-    def test_css(self):
-        """
-        PIQS: Test the calculation of the CSS state.
-        """
-        test_css_uncoupled = css(2, basis="uncoupled")
-        test_css_dicke = css(2)
-        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
-        css_dicke = np.array(
-            [
-                [
-                    0.25000000 + 0.0j,
-                    0.35355339 + 0.0j,
-                    0.25000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-                [
-                    0.35355339 + 0.0j,
-                    0.50000000 + 0.0j,
-                    0.35355339 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-                [
-                    0.25000000 + 0.0j,
-                    0.35355339 + 0.0j,
-                    0.25000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-                [
-                    0.00000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-            ]
-        )
-        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
-        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
-
-    def test_collapse_uncoupled(self):
-        """
-        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
-
-        In the "uncoupled" basis of N two-level system (TLS).
-        The test is performed for N = 2 and emission = 1.
-        """
-        c1 = Qobj(
-            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
-            dims=[[2, 2], [2, 2]],
-        )
-        c2 = Qobj(
-            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
-            dims=[[2, 2], [2, 2]],
-        )
-        true_c_ops = [c1, c2]
-        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
-        system = Dicke(N=2, emission=1)
-        assert_equal(true_c_ops, system.c_ops())
-
-    def test_get_blocks(self):
-        """
-        PIQS: Test the calculation of list of cumulative elements at each block.
-
-        For N = 4
-
-        1 1 1 1 1
-        1 1 1 1 1
-        1 1 1 1 1
-        1 1 1 1 1
-        1 1 1 1 1
-                1 1 1
-                1 1 1
-                1 1 1
-                     1
-        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
-        elements have been accounted for and so on.
-        """
-        trueb1 = [2]
-        trueb2 = [3, 4]
-        trueb3 = [4, 6]
-        trueb4 = [5, 8, 9]
-
-        test_b1 = get_blocks(1)
-        test_b2 = get_blocks(2)
-        test_b3 = get_blocks(3)
-        test_b4 = get_blocks(4)
-
-        assert_equal(test_b1, trueb1)
-        assert_equal(test_b2, trueb2)
-        assert_equal(test_b3, trueb3)
-
-    def test_lindbladian_dims(self):
-        """
-        PIQS: Test the calculation of the lindbladian matrix.
-        """
-        true_L = [
-            [-4, 0, 0, 3],
-            [0, -3.54999995, 0, 0],
-            [0, 0, -3.54999995, 0],
-            [4, 0, 0, -3],
-        ]
-        true_L = Qobj(true_L)
-        true_L.dims = [[[2], [2]], [[2], [2]]]
-        N = 1
-        test_dicke = _Dicke(
-            N=N,
-            pumping=1,
-            collective_pumping=2,
-            emission=1,
-            collective_emission=3,
-            dephasing=0.1,
-        )
-        test_L = test_dicke.lindbladian()
-        assert_array_almost_equal(test_L.full(), true_L.full())
-        assert_array_equal(test_L.dims, true_L.dims)
-
-    def test_liouvillian(self):
-        """
-        PIQS: Test the calculation of the liouvillian matrix.
-        """
-        true_L = [
-            [-4, 0, 0, 3],
-            [0, -3.54999995, 0, 0],
-            [0, 0, -3.54999995, 0],
-            [4, 0, 0, -3],
-        ]
-        true_L = Qobj(true_L)
-        true_L.dims = [[[2], [2]], [[2], [2]]]
-        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
-        true_H = Qobj(true_H)
-        true_H.dims = [[[2], [2]]]
-        true_liouvillian = [
-            [-4, -1.0j, 1.0j, 3],
-            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
-            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
-            [4, +1.0j, -1.0j, -3],
-        ]
-        true_liouvillian = Qobj(true_liouvillian)
-        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
-        N = 1
-        test_piqs = Dicke(
-            hamiltonian=sigmaz() + sigmax(),
-            N=N,
-            pumping=1,
-            collective_pumping=2,
-            emission=1,
-            collective_emission=3,
-            dephasing=0.1,
-        )
-        test_liouvillian = test_piqs.liouvillian()
-        test_hamiltonian = test_piqs.hamiltonian
-        assert_array_almost_equal(
-            test_liouvillian.full(), true_liouvillian.full()
-        )
-        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
-        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
-
-        # no Hamiltonian
-        test_piqs = Dicke(
-            N=N,
-            pumping=1,
-            collective_pumping=2,
-            emission=1,
-            collective_emission=3,
-            dephasing=0.1,
-        )
-        liouv = test_piqs.liouvillian()
-        lindblad = test_piqs.lindbladian()
-        assert_equal(liouv, lindblad)
-
-    def test_gamma1(self):
-        """
-        PIQS: Test the calculation of gamma1.
-        """
-        true_gamma_1 = -2
-        true_gamma_2 = -3
-        true_gamma_3 = -7
-        true_gamma_4 = -1
-        true_gamma_5 = 0
-        true_gamma_6 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, collective_emission=1)
-        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1)
-        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, dephasing=4)
-        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_pumping=2)
-        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_dephasing=2)
-        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-        assert_almost_equal(true_gamma_5, test_gamma_5)
-        assert_almost_equal(true_gamma_6, test_gamma_6)
-
-    def test_gamma2(self):
-        """
-        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 2
-        true_gamma_2 = 1.5
-        true_gamma_3 = 5.5
-        true_gamma_4 = 0
-        true_gamma_5 = 0
-        true_gamma_6 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, collective_emission=1)
-        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1)
-        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, dephasing=4)
-        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_pumping=2)
-        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_dephasing=2)
-        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-        assert_almost_equal(true_gamma_5, test_gamma_5)
-        assert_almost_equal(true_gamma_6, test_gamma_6)
-
-    def test_gamma3(self):
-        """
-        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 1.3333333730697632
-        true_gamma_3 = 1.3333333730697632
-        true_gamma_4 = 0
-        true_gamma_5 = 0
-        true_gamma_6 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, collective_emission=1)
-        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1)
-        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, dephasing=4)
-        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_pumping=2)
-        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_dephasing=2)
-        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
-        #
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-        assert_almost_equal(true_gamma_5, test_gamma_5)
-        assert_almost_equal(true_gamma_6, test_gamma_6)
-
-    def test_gamma4(self):
-        """
-        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0.1666666716337204
-        true_gamma_2 = 2
-        true_gamma_3 = 0
-        true_gamma_4 = 0.40824830532073975
-
-        N = 4
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
-        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
-        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma5(self):
-        """
-        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 0
-        true_gamma_3 = 0.75
-        true_gamma_4 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, dephasing=1)
-        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
-        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
-        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma6(self):
-        """
-        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0.25
-        true_gamma_2 = 1
-        true_gamma_3 = 0
-        true_gamma_4 = 0.25
-
-        N = 4
-        test_dicke = _Dicke(N=N, dephasing=1)
-        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
-        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
-        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma7(self):
-        """
-        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 0.5
-        true_gamma_3 = 0
-        true_gamma_4 = 1.5
-
-        N = 4
-        test_dicke = _Dicke(N=N, pumping=1)
-        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
-        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
-        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma8(self):
-        """
-        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 13.5
-        true_gamma_3 = 5.5
-        true_gamma_4 = 13.5
-
-        N = 4
-        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
-        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
-        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
-        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma9(self):
-        """
-        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 1
-        true_gamma_2 = 0
-        true_gamma_3 = 0.5
-        true_gamma_4 = 0
-        N = 4
-        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
-        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
-        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
-        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-
-class TestPim:
-    """
-    Tests for the `qutip.piqs.Pim` class.
-    """
-
-    def test_gamma(self):
-        """
-        PIQS: Test the calculation of various gamma values for diagonal system.
-
-        For N = 6 |j, m> would be :
-
-        | 3, 3>
-        | 3, 2> | 2, 2>
-        | 3, 1> | 2, 1> | 1, 1>
-        | 3, 0> | 2, 0> | 1, 0> |0, 0>
-        | 3,-1> | 2,-1> | 1,-1>
-        | 3,-2> | 2,-2>
-        | 3,-3>
-        """
-        N = 6
-        collective_emission = 1.0
-        emission = 1.0
-        dephasing = 1.0
-        pumping = 1.0
-        collective_pumping = 1.0
-        model = Pim(
-            N,
-            collective_emission=collective_emission,
-            emission=emission,
-            dephasing=dephasing,
-            pumping=pumping,
-            collective_pumping=collective_pumping,
-        )
-        tau_calculated = [
-            model.tau3(3, 1),
-            model.tau2(2, 1),
-            model.tau4(1, 1),
-            model.tau5(3, 0),
-            model.tau1(2, 0),
-            model.tau6(1, 0),
-            model.tau7(3, -1),
-            model.tau8(2, -1),
-            model.tau9(1, -1),
-        ]
-        tau_real = [
-            2.0,
-            8.0,
-            0.333333,
-            1.5,
-            -19.5,
-            0.666667,
-            2.0,
-            8.0,
-            0.333333,
-        ]
-        assert_array_almost_equal(tau_calculated, tau_real)
-
-    def test_isdicke(self):
-        """
-        PIQS: Test the `isdicke` function
-        """
-        N1 = 1
-        g0 = 0.01
-        nth = 0.01
-        gP = g0 * nth
-        gL = g0 * (0.1 + nth)
-        gS = 0.1
-        gD = 0.1
-
-        pim1 = Pim(N1, gS, gL, gD, gP)
-
-        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
-        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
-
-        N2 = 4
-
-        pim2 = Pim(N2, gS, gL, gD, gP)
-        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
-        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
-
-        assert_array_equal(dicke_labels, [True, False, True, False, True])
-
-    def test_isdiagonal(self):
-        """
-        PIQS: Test the isdiagonal function.
-        """
-        mat1 = np.array([[1, 2], [3, 4]])
-        mat2 = np.array([[1, 0.0], [0.0, 2]])
-        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
-        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
-        assert_equal(isdiagonal(mat1), False)
-        assert_equal(isdiagonal(mat2), True)
-        assert_equal(isdiagonal(mat3), False)
-        assert_equal(isdiagonal(mat4), True)
-
-    def test_pisolve(self):
-        """
-        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
-        """
-        jx, jy, jz = jspin(4)
-        jp, jm = jspin(4, "+"), jspin(4, "-")
-
-    def test_coefficient_matrix(self):
-        """
-        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
-        """
-        N = 2
-        ensemble = Pim(N, emission=1)
-        test_matrix = ensemble.coefficient_matrix().toarray()
-        ensemble2 = Dicke(N, emission=1)
-        test_matrix2 = ensemble.coefficient_matrix().toarray()
-        true_matrix = [
-            [-2, 0, 0, 0],
-            [1, -1, 0, 0],
-            [0, 1, 0, 1.0],
-            [1, 0, 0, -1.0],
-        ]
-
-        assert_array_almost_equal(test_matrix, true_matrix)
-        assert_array_almost_equal(test_matrix2, true_matrix)
-
-    def test_pisolve(self):
-        """
-        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
-        """
-        jx, jy, jz = jspin(4)
-        jp, jm = jspin(4, "+"), jspin(4, "-")
-        non_diag_hamiltonian = jx
-        diag_hamiltonian = jz
-
-        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
-        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
-
-        diag_initial_state = dicke(4, 1, 0)
-        non_diag_initial_state = ghz(4)
-        tlist = np.linspace(0, 10, 100)
-
-        assert_raises(
-            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
-        )
-        assert_raises(
-            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
-        )
-        assert_raises(
-            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
-        )
-
-        non_dicke_initial_state = excited(4, basis="uncoupled")
-        assert_raises(
-            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
-        )
-
-        # no Hamiltonian
-        no_hamiltonian_system = Dicke(4, emission=0.1)
-        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
-        assert_equal(True, len(result.states) > 0)
-
-
-if __name__ == "__main__":
-    run_module_suite()
+"""
+Tests for Permutational Invariant Quantum solver (PIQS).
+"""
+import numpy as np
+from numpy.testing import (
+    assert_,
+    run_module_suite,
+    assert_raises,
+    assert_array_equal,
+    assert_array_almost_equal,
+    assert_almost_equal,
+    assert_equal,
+)
+from scipy.sparse import block_diag
+from qutip import Qobj, entropy_vn, sigmax, sigmaz
+from qutip.solve._piqs import (
+    get_blocks,
+    j_min,
+    j_vals,
+    m_vals,
+    _num_dicke_states,
+    _num_dicke_ladders,
+    get_index,
+    jmm1_dictionary,
+)
+from qutip.solve._piqs import Dicke as _Dicke
+from qutip.solve.piqs import *
+
+import sys
+import unittest
+
+
+# Disable tests for python2 as qutip.piqs does not support python2.
+if sys.version_info[0] < 3:
+    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
+
+
+class TestDicke:
+    """
+    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
+    """
+
+    def test_num_dicke_states(self):
+        """
+        PIQS: Test the `num_dicke_state` function.
+        """
+        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
+        dicke_states = [num_dicke_states(i) for i in N_list]
+        assert_array_equal(
+            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
+        )
+        N = -1
+        assert_raises(ValueError, num_dicke_states, N)
+        N = 0.2
+        assert_raises(ValueError, num_dicke_states, N)
+
+    def test_num_tls(self):
+        """
+        PIQS: Test the `num_two_level` function.
+        """
+        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
+        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
+        calculated_N = [num_tls(i) for i in N_dicke]
+        assert_array_equal(calculated_N, N)
+
+    def test_num_dicke_ladders(self):
+        """
+        PIQS: Test the `_num_dicke_ladders` function.
+        """
+        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
+        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
+        assert_array_equal(ndl, ndl_true)
+
+    def test_get_blocks(self):
+        """
+        PIQS: Test the function to get blocks.
+        """
+        N_list = [1, 2, 5, 7]
+        blocks = [
+            np.array([2]),
+            np.array([3, 4]),
+            np.array([6, 10, 12]),
+            np.array([8, 14, 18, 20]),
+        ]
+        calculated_blocks = [get_blocks(i) for i in N_list]
+        for (i, j) in zip(calculated_blocks, blocks):
+            assert_array_equal(i, j)
+
+    def test_j_vals(self):
+        """
+        PIQS: Test calculation of j values for given N.
+        """
+        N_list = [1, 2, 3, 4, 7]
+        j_vals_real = [
+            np.array([0.5]),
+            np.array([0.0, 1.0]),
+            np.array([0.5, 1.5]),
+            np.array([0.0, 1.0, 2.0]),
+            np.array([0.5, 1.5, 2.5, 3.5]),
+        ]
+        j_vals_calc = [j_vals(i) for i in N_list]
+
+        for (i, j) in zip(j_vals_calc, j_vals_real):
+            assert_array_equal(i, j)
+
+    def test_m_vals(self):
+        """
+        PIQS: Test calculation of m values for a particular j.
+        """
+        j_list = [0.5, 1, 1.5, 2, 2.5]
+        m_real = [
+            np.array([-0.5, 0.5]),
+            np.array([-1, 0, 1]),
+            np.array([-1.5, -0.5, 0.5, 1.5]),
+            np.array([-2, -1, 0, 1, 2]),
+            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
+        ]
+
+        m_calc = [m_vals(i) for i in j_list]
+        for (i, j) in zip(m_real, m_calc):
+            assert_array_equal(i, j)
+
+    def test_dicke_blocks(self):
+        """
+        PIQS: Test the `dicke_blocks` function.
+        """
+        # test 1
+        # mixed state with non-symmetrical block matrix elements
+        N = 3
+        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        test_blocks = dicke_blocks(true_matrix)
+        test_matrix = Qobj(block_diag(test_blocks))
+        assert_(test_matrix == true_matrix)
+        # test 2
+        # all elements in block-diagonal matrix
+        N = 4
+        true_matrix = Qobj(block_matrix(N)).unit()
+        test_blocks = dicke_blocks(true_matrix)
+        test_matrix = Qobj(block_diag(test_blocks))
+        assert_(test_matrix == true_matrix)
+
+    def test_dicke_blocks_full(self):
+        """
+        PIQS: Test the `dicke_blocks_full` function.
+        """
+        N = 3
+        test_blocks = dicke_blocks_full(excited(3))
+        test_matrix = Qobj(block_diag(test_blocks))
+        true_expanded = np.zeros((8, 8))
+        true_expanded[0, 0] = 1.0
+        assert_(test_matrix == Qobj(true_expanded))
+
+    def test_dicke_function_trace(self):
+        """
+        PIQS: Test the `dicke_function_trace` function.
+        """
+        ## test for N odd
+        N = 3
+        # test trace
+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        f = lambda x: x
+        test_val = dicke_function_trace(f, rho_mixed)
+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
+        true_val2 = (rho_mixed).tr()
+        # test with linear function (trace)
+        assert_almost_equal(test_val, true_val)
+        assert_almost_equal(test_val, true_val2)
+        # test with nonlinear function
+        f = lambda rho: rho ** 3
+        test_val3 = dicke_function_trace(f, rho_mixed)
+        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
+        assert_almost_equal(test_val3, true_val3)
+        ## test for N even
+        N = 4
+        # test trace
+        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
+        f = lambda x: x
+        test_val = dicke_function_trace(f, rho_mixed)
+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
+        true_val2 = (rho_mixed).tr()
+        # test with linear function (trace)
+        assert_almost_equal(test_val, true_val)
+        assert_almost_equal(test_val, true_val2)
+        # test with nonlinear function
+        f = lambda rho: rho ** 3
+        test_val3 = dicke_function_trace(f, rho_mixed)
+        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
+        assert np.allclose(test_val3, true_val3)
+
+    def test_entropy_vn_dicke(self):
+        """
+        PIQS: Test the `entropy_vn_dicke` function.
+        """
+        N = 3
+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        test_val = entropy_vn_dicke(rho_mixed)
+        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
+        assert np.allclose(test_val, true_val)
+
+    def test_purity_dicke(self):
+        """
+        PIQS: Test the `purity_dicke` function.
+        """
+        N = 3
+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        test_val = purity_dicke(rho_mixed)
+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
+        assert np.allclose(test_val, true_val)
+
+    def test_get_index(self):
+        """
+        PIQS: Test the index fetching function for given j, m, m1 value.
+        """
+        N = 1
+        jmm1_list = [
+            (0.5, 0.5, 0.5),
+            (0.5, 0.5, -0.5),
+            (0.5, -0.5, 0.5),
+            (0.5, -0.5, -0.5),
+        ]
+        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
+
+        blocks = get_blocks(N)
+        calculated_indices = [
+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+            for jmm1 in jmm1_list
+        ]
+        assert_array_almost_equal(calculated_indices, indices)
+        N = 2
+        blocks = get_blocks(N)
+        jmm1_list = [
+            (1, 1, 1),
+            (1, 1, 0),
+            (1, 1, -1),
+            (1, 0, 1),
+            (1, 0, 0),
+            (1, 0, -1),
+            (1, -1, 1),
+            (1, -1, 0),
+            (1, -1, -1),
+            (0, 0, 0),
+        ]
+        indices = [
+            (0, 0),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 1),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+            (2, 2),
+            (3, 3),
+        ]
+        calculated_indices = [
+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+            for jmm1 in jmm1_list
+        ]
+        assert_array_almost_equal(calculated_indices, indices)
+        N = 3
+        blocks = get_blocks(N)
+        jmm1_list = [
+            (1.5, 1.5, 1.5),
+            (1.5, 1.5, 0.5),
+            (1.5, 1.5, -0.5),
+            (1.5, 1.5, -1.5),
+            (1.5, 0.5, 0.5),
+            (1.5, -0.5, -0.5),
+            (1.5, -1.5, -1.5),
+            (1.5, -1.5, 1.5),
+            (0.5, 0.5, 0.5),
+            (0.5, 0.5, -0.5),
+            (0.5, -0.5, 0.5),
+            (0.5, -0.5, -0.5),
+        ]
+
+        indices = [
+            (0, 0),
+            (0, 1),
+            (0, 2),
+            (0, 3),
+            (1, 1),
+            (2, 2),
+            (3, 3),
+            (3, 0),
+            (4, 4),
+            (4, 5),
+            (5, 4),
+            (5, 5),
+        ]
+
+        calculated_indices = [
+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+            for jmm1 in jmm1_list
+        ]
+        assert_array_almost_equal(calculated_indices, indices)
+
+    def test_jmm1_dictionary(self):
+        """
+        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
+        """
+        d1, d2, d3, d4 = jmm1_dictionary(1)
+
+        d1_correct = {
+            (0, 0): (0.5, 0.5, 0.5),
+            (0, 1): (0.5, 0.5, -0.5),
+            (1, 0): (0.5, -0.5, 0.5),
+            (1, 1): (0.5, -0.5, -0.5),
+        }
+
+        d2_correct = {
+            (0.5, -0.5, -0.5): (1, 1),
+            (0.5, -0.5, 0.5): (1, 0),
+            (0.5, 0.5, -0.5): (0, 1),
+            (0.5, 0.5, 0.5): (0, 0),
+        }
+
+        d3_correct = {
+            0: (0.5, 0.5, 0.5),
+            1: (0.5, 0.5, -0.5),
+            2: (0.5, -0.5, 0.5),
+            3: (0.5, -0.5, -0.5),
+        }
+
+        d4_correct = {
+            (0.5, -0.5, -0.5): 3,
+            (0.5, -0.5, 0.5): 2,
+            (0.5, 0.5, -0.5): 1,
+            (0.5, 0.5, 0.5): 0,
+        }
+
+        assert_equal(d1, d1_correct)
+        assert_equal(d2, d2_correct)
+        assert_equal(d3, d3_correct)
+        assert_equal(d4, d4_correct)
+
+        d1, d2, d3, d4 = jmm1_dictionary(2)
+
+        d1_correct = {
+            (3, 3): (0.0, -0.0, -0.0),
+            (2, 2): (1.0, -1.0, -1.0),
+            (2, 1): (1.0, -1.0, 0.0),
+            (2, 0): (1.0, -1.0, 1.0),
+            (1, 2): (1.0, 0.0, -1.0),
+            (1, 1): (1.0, 0.0, 0.0),
+            (1, 0): (1.0, 0.0, 1.0),
+            (0, 2): (1.0, 1.0, -1.0),
+            (0, 1): (1.0, 1.0, 0.0),
+            (0, 0): (1.0, 1.0, 1.0),
+        }
+
+        d2_correct = {
+            (0.0, -0.0, -0.0): (3, 3),
+            (1.0, -1.0, -1.0): (2, 2),
+            (1.0, -1.0, 0.0): (2, 1),
+            (1.0, -1.0, 1.0): (2, 0),
+            (1.0, 0.0, -1.0): (1, 2),
+            (1.0, 0.0, 0.0): (1, 1),
+            (1.0, 0.0, 1.0): (1, 0),
+            (1.0, 1.0, -1.0): (0, 2),
+            (1.0, 1.0, 0.0): (0, 1),
+            (1.0, 1.0, 1.0): (0, 0),
+        }
+
+        d3_correct = {
+            15: (0.0, -0.0, -0.0),
+            10: (1.0, -1.0, -1.0),
+            9: (1.0, -1.0, 0.0),
+            8: (1.0, -1.0, 1.0),
+            6: (1.0, 0.0, -1.0),
+            5: (1.0, 0.0, 0.0),
+            4: (1.0, 0.0, 1.0),
+            2: (1.0, 1.0, -1.0),
+            1: (1.0, 1.0, 0.0),
+            0: (1.0, 1.0, 1.0),
+        }
+
+        d4_correct = {
+            (0.0, -0.0, -0.0): 15,
+            (1.0, -1.0, -1.0): 10,
+            (1.0, -1.0, 0.0): 9,
+            (1.0, -1.0, 1.0): 8,
+            (1.0, 0.0, -1.0): 6,
+            (1.0, 0.0, 0.0): 5,
+            (1.0, 0.0, 1.0): 4,
+            (1.0, 1.0, -1.0): 2,
+            (1.0, 1.0, 0.0): 1,
+            (1.0, 1.0, 1.0): 0,
+        }
+
+        assert_equal(d1, d1_correct)
+        assert_equal(d2, d2_correct)
+        assert_equal(d3, d3_correct)
+        assert_equal(d4, d4_correct)
+
+    def test_lindbladian(self):
+        """
+        PIQS: Test the generation of the Lindbladian matrix.
+        """
+        N = 1
+        gCE = 0.5
+        gCD = 0.5
+        gCP = 0.5
+        gE = 0.1
+        gD = 0.1
+        gP = 0.1
+
+        system = Dicke(
+            N=N,
+            emission=gE,
+            pumping=gP,
+            dephasing=gD,
+            collective_emission=gCE,
+            collective_pumping=gCP,
+            collective_dephasing=gCD,
+        )
+
+        lindbladian = system.lindbladian()
+        Ldata = np.zeros((4, 4), dtype="complex")
+        Ldata[0] = [-0.6, 0, 0, 0.6]
+        Ldata[1] = [0, -0.9, 0, 0]
+        Ldata[2] = [0, 0, -0.9, 0]
+        Ldata[3] = [0.6, 0, 0, -0.6]
+
+        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
+        assert_array_almost_equal(lindbladian.full(), Ldata)
+        N = 2
+        gCE = 0.5
+        gCD = 0.5
+        gCP = 0.5
+        gE = 0.1
+        gD = 0.1
+        gP = 0.1
+        system = Dicke(
+            N=N,
+            emission=gE,
+            pumping=gP,
+            dephasing=gD,
+            collective_emission=gCE,
+            collective_pumping=gCP,
+            collective_dephasing=gCD,
+        )
+
+        lindbladian = system.lindbladian()
+
+        Ldata = np.zeros((16, 16), dtype="complex")
+        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
+        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
+        Ldata[2, 2] = -2.2999999999999998
+        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
+        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
+            1.1,
+            -2.25,
+            1.1,
+            0.05,
+        )
+        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
+        Ldata[8, 8] = -2.2999999999999998
+        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
+        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
+        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
+            0.1,
+            0.05,
+            0.1,
+            -0.25,
+        )
+        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
+        assert_array_almost_equal(lindbladian.full(), Ldata)
+
+    def test_gamma(self):
+        """
+        PIQS: Test the calculation of various gamma values for diagonal system.
+
+        For N = 6 |j, m> would be :
+
+        | 3, 3>
+        | 3, 2> | 2, 2>
+        | 3, 1> | 2, 1> | 1, 1>
+        | 3, 0> | 2, 0> | 1, 0> |0, 0>
+        | 3,-1> | 2,-1> | 1,-1>
+        | 3,-2> | 2,-2>
+        | 3,-3>
+        """
+        N = 6
+        collective_emission = 1.0
+        emission = 1.0
+        dephasing = 1.0
+        pumping = 1.0
+        collective_pumping = 1.0
+        model = _Dicke(
+            N,
+            collective_emission=collective_emission,
+            emission=emission,
+            dephasing=dephasing,
+            pumping=pumping,
+            collective_pumping=collective_pumping,
+        )
+        tau_calculated = [
+            model.gamma3((3, 1, 1)),
+            model.gamma2((2, 1, 1)),
+            model.gamma4((1, 1, 1)),
+            model.gamma5((3, 0, 0)),
+            model.gamma1((2, 0, 0)),
+            model.gamma6((1, 0, 0)),
+            model.gamma7((3, -1, -1)),
+            model.gamma8((2, -1, -1)),
+            model.gamma9((1, -1, -1)),
+        ]
+        tau_real = [
+            2.0,
+            8.0,
+            0.333333,
+            1.5,
+            -19.5,
+            0.666667,
+            2.0,
+            8.0,
+            0.333333,
+        ]
+        assert_array_almost_equal(tau_calculated, tau_real)
+
+    def test_jspin(self):
+        """
+        PIQS: Test calculation of the j algebra relation for the total operators.
+
+        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
+        basis should follow the following algebra
+        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
+        """
+        N_list = [1, 2, 3, 4, 7]
+
+        for nn in N_list:
+            # tests 1
+            [jx, jy, jz] = jspin(nn)
+            jp, jm = jspin(nn, "+"), jspin(nn, "-")
+            test_jxjy = jx * jy - jy * jx
+            true_jxjy = 1j * jz
+            test_jpjm = jp * jm - jm * jp
+            true_jpjm = 2 * jz
+
+            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
+            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
+
+            # tests 2
+            [jx, jy, jz] = jspin(nn)
+            jp, jm = jspin(nn, "+"), jspin(nn, "-")
+            test_jxjy = jx * jy - jy * jx
+            true_jxjy = 1j * jz
+            test_jpjm = jp * jm - jm * jp
+            true_jpjm = 2 * jz
+
+            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
+            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
+
+            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
+            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
+            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
+            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
+            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
+            assert_raises(TypeError, jspin, nn, "q")
+
+    def test_j_min_(self):
+        """
+        PIQS: Test the `j_min` function.
+        """
+        even = [2, 4, 6, 8]
+        odd = [1, 3, 5, 7]
+
+        for i in even:
+            assert_(j_min(i) == 0)
+
+        for i in odd:
+            assert_(j_min(i) == 0.5)
+
+    def test_energy_degeneracy(self):
+        """
+        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
+        """
+        true_en_deg = [1, 1, 1, 1, 1]
+        true_en_deg_even = [2, 6, 20]
+        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
+        test_en_deg = []
+        test_en_deg_even = []
+        test_en_deg_odd = []
+
+        for nn in [1, 2, 3, 4, 7]:
+            test_en_deg.append(energy_degeneracy(nn, nn / 2))
+
+        for nn in [2, 4, 6]:
+            test_en_deg_even.append(energy_degeneracy(nn, 0))
+
+        for nn in [1, 3, 7]:
+            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
+            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
+
+        assert_array_equal(test_en_deg, true_en_deg)
+        assert_array_equal(test_en_deg_even, true_en_deg_even)
+        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
+
+    def test_state_degeneracy(self):
+        """
+        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
+        state_degeneracy(N, j).
+        """
+        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
+        state_deg = []
+        state_deg = []
+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+            state_deg.append(state_degeneracy(nn, nn / 2))
+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
+        assert_array_equal(state_deg, true_state_deg)
+
+        # check error
+        assert_raises(ValueError, state_degeneracy, 2, -1)
+
+    def test_m_degeneracy(self):
+        """
+        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
+        """
+        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
+        m_deg = []
+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
+        assert_array_equal(m_deg, true_m_deg)
+
+        # check error
+        assert_raises(ValueError, m_degeneracy, 6, -6)
+
+    def test_ap(self):
+        """
+        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
+
+        For given values of j, m. For a Dicke state,
+        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
+        """
+        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
+        ap_list = []
+        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
+            ap_list.append(ap(10, m) ** 2)
+
+        assert_almost_equal(ap_list, true_ap_list)
+
+    def test_am(self):
+        """
+        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
+
+        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
+        """
+        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
+        am_list = []
+        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
+            am_list.append(am(10, m) ** 2)
+
+        assert_almost_equal(am_list, true_am_list)
+
+    def test_spin_algebra(self):
+        """
+        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
+        The list [sx, sy, sz, sp, sm] is checked for N = 2.
+        """
+        sx1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sx2 = [
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sy1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sy2 = [
+            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
+        ]
+
+        sz1 = [
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
+        ]
+
+        sz2 = [
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
+        ]
+
+        sp1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sp2 = [
+            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sm1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sm2 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
+        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
+        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
+        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
+        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
+        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
+        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
+        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
+        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
+        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
+
+        # test error
+        assert_raises(TypeError, spin_algebra, 2, "q")
+
+    def test_collective_algebra(self):
+        """
+        PIQS: Test the generation of the collective algebra in uncoupled basis.
+
+        The list [jx, jy, jz] created in the 2^N Hilbert space is
+        checked for N = 2.
+        """
+
+        jx_n2 = [
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        jy_n2 = [
+            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
+        ]
+
+        jz_n2 = [
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
+        ]
+
+        jp_n2 = [
+            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        jm_n2 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
+        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
+        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
+        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
+        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
+
+        # error
+        assert_raises(TypeError, spin_algebra, 2, "q")
+
+    def test_block_matrix(self):
+        """
+        PIQS: Test the calculation of the block-diagonal matrix for given N.
+
+        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
+        """
+        # N = 1 TLSs
+        block_1 = [[1.0, 1.0], [1.0, 1.0]]
+
+        # N = 2 TLSs
+        block_2 = [
+            [1.0, 1.0, 1.0, 0.0],
+            [1.0, 1.0, 1.0, 0.0],
+            [1.0, 1.0, 1.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0],
+        ]
+
+        # N = 3 TLSs
+        block_3 = [
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+        ]
+
+        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
+        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
+        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
+
+    def test_dicke_basis(self):
+        """
+        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
+
+        We test the state with for N = 2,
+
+        0   0   0.3 0
+        0   0.5 0   0
+        0.3 0   0   0
+        0   0   0   0.5
+        """
+        N = 2
+        true_dicke_basis = np.zeros((4, 4))
+        true_dicke_basis[1, 1] = 0.5
+        true_dicke_basis[-1, -1] = 0.5
+        true_dicke_basis[0, 2] = 0.3
+        true_dicke_basis[2, 0] = 0.3
+        true_dicke_basis = Qobj(true_dicke_basis)
+        jmm1_1 = {(N / 2, 0, 0): 0.5}
+        jmm1_2 = {(0, 0, 0): 0.5}
+        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
+        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
+        db1 = dicke_basis(2, jmm1_1)
+        db2 = dicke_basis(2, jmm1_2)
+        db3 = dicke_basis(2, jmm1_3)
+        db4 = dicke_basis(2, jmm1_4)
+        test_dicke_basis = db1 + db2 + db3 + db4
+        assert_equal(test_dicke_basis, true_dicke_basis)
+
+        # error
+        assert_raises(AttributeError, dicke_basis, N)
+
+    def test_dicke(self):
+        """
+        PIQS: Test the calculation of the Dicke state as a pure state.
+        """
+        true_excited = np.zeros((4, 4))
+        true_excited[0, 0] = 1
+
+        true_superradiant = np.zeros((4, 4))
+        true_superradiant[1, 1] = 1
+
+        true_subradiant = np.zeros((4, 4))
+        true_subradiant[-1, -1] = 1
+
+        test_excited = dicke(2, 1, 1)
+        test_superradiant = dicke(2, 1, 0)
+        test_subradiant = dicke(2, 0, 0)
+
+        assert_equal(test_excited, Qobj(true_excited))
+        assert_equal(test_superradiant, Qobj(true_superradiant))
+        assert_equal(test_subradiant, Qobj(true_subradiant))
+
+    def test_excited(self):
+        """
+        PIQS: Test the calculation of the totally excited state density matrix.
+
+        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
+        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
+        """
+        N = 3
+        true_state = np.zeros((6, 6))
+        true_state[0, 0] = 1
+        true_state = Qobj(true_state)
+
+        test_state = excited(N)
+        assert_equal(test_state, true_state)
+
+        N = 4
+        true_state = np.zeros((9, 9))
+        true_state[0, 0] = 1
+        true_state = Qobj(true_state)
+
+        test_state = excited(N)
+        assert_equal(test_state, true_state)
+
+        # uncoupled
+        test_state_uncoupled = excited(2, basis="uncoupled")
+        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
+        assert_array_equal(test_state_uncoupled.shape, (4, 4))
+        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
+
+    def test_superradiant(self):
+        """
+        PIQS: Test the calculation of the superradiant state density matrix.
+
+        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
+        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
+        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
+        """
+        N = 3
+        true_state = np.zeros((6, 6))
+        true_state[1, 1] = 1
+        true_state = Qobj(true_state)
+        test_state = superradiant(N)
+        assert_equal(test_state, true_state)
+        N = 4
+        true_state = np.zeros((9, 9))
+        true_state[2, 2] = 1
+        true_state = Qobj(true_state)
+        test_state = superradiant(N)
+        assert_equal(test_state, true_state)
+
+        # uncoupled
+        test_state_uncoupled = superradiant(2, basis="uncoupled")
+        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
+        assert_array_equal(test_state_uncoupled.shape, (4, 4))
+        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
+
+    def test_ghz(self):
+        """
+        PIQS: Test the calculation of the density matrix of the GHZ state.
+
+        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
+        """
+        ghz_dicke = Qobj(
+            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
+        )
+        ghz_uncoupled = Qobj(
+            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
+        )
+        ghz_uncoupled.dims = [[2, 2], [2, 2]]
+        assert_equal(ghz(2), ghz_dicke)
+        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
+
+    def test_ground(self):
+        """
+        PIQS: Test the calculation of the density matrix of the ground state.
+
+        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
+        """
+        zeros = np.zeros((4, 4), dtype=np.complex128)
+        gdicke = zeros.copy()
+        guncoupled = zeros.copy()
+        gdicke[2, 2] = 1
+        guncoupled[3, 3] = 1
+
+        dim_dicke = [[4], [4]]
+        dim_uncoupled = [[2, 2], [2, 2]]
+
+        test_ground_dicke = ground(2)
+        test_ground_uncoupled = ground(2, "uncoupled")
+
+        assert_array_equal(test_ground_dicke.full(), gdicke)
+        assert_array_equal(test_ground_dicke.dims, dim_dicke)
+        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
+        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
+
+    def test_identity_uncoupled(self):
+        """
+        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
+        """
+        test_identity = identity_uncoupled(4)
+        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
+        assert_array_equal(
+            np.diag(test_identity.full()), np.ones(16, np.complex128)
+        )
+
+    def test_css(self):
+        """
+        PIQS: Test the calculation of the CSS state.
+        """
+        test_css_uncoupled = css(2, basis="uncoupled")
+        test_css_dicke = css(2)
+        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
+        css_dicke = np.array(
+            [
+                [
+                    0.25000000 + 0.0j,
+                    0.35355339 + 0.0j,
+                    0.25000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+                [
+                    0.35355339 + 0.0j,
+                    0.50000000 + 0.0j,
+                    0.35355339 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+                [
+                    0.25000000 + 0.0j,
+                    0.35355339 + 0.0j,
+                    0.25000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+                [
+                    0.00000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+            ]
+        )
+        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
+        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
+
+    def test_collapse_uncoupled(self):
+        """
+        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
+
+        In the "uncoupled" basis of N two-level system (TLS).
+        The test is performed for N = 2 and emission = 1.
+        """
+        c1 = Qobj(
+            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
+            dims=[[2, 2], [2, 2]],
+        )
+        c2 = Qobj(
+            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
+            dims=[[2, 2], [2, 2]],
+        )
+        true_c_ops = [c1, c2]
+        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
+        system = Dicke(N=2, emission=1)
+        assert_equal(true_c_ops, system.c_ops())
+
+    def test_get_blocks(self):
+        """
+        PIQS: Test the calculation of list of cumulative elements at each block.
+
+        For N = 4
+
+        1 1 1 1 1
+        1 1 1 1 1
+        1 1 1 1 1
+        1 1 1 1 1
+        1 1 1 1 1
+                1 1 1
+                1 1 1
+                1 1 1
+                     1
+        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
+        elements have been accounted for and so on.
+        """
+        trueb1 = [2]
+        trueb2 = [3, 4]
+        trueb3 = [4, 6]
+        trueb4 = [5, 8, 9]
+
+        test_b1 = get_blocks(1)
+        test_b2 = get_blocks(2)
+        test_b3 = get_blocks(3)
+        test_b4 = get_blocks(4)
+
+        assert_equal(test_b1, trueb1)
+        assert_equal(test_b2, trueb2)
+        assert_equal(test_b3, trueb3)
+
+    def test_lindbladian_dims(self):
+        """
+        PIQS: Test the calculation of the lindbladian matrix.
+        """
+        true_L = [
+            [-4, 0, 0, 3],
+            [0, -3.54999995, 0, 0],
+            [0, 0, -3.54999995, 0],
+            [4, 0, 0, -3],
+        ]
+        true_L = Qobj(true_L)
+        true_L.dims = [[[2], [2]], [[2], [2]]]
+        N = 1
+        test_dicke = _Dicke(
+            N=N,
+            pumping=1,
+            collective_pumping=2,
+            emission=1,
+            collective_emission=3,
+            dephasing=0.1,
+        )
+        test_L = test_dicke.lindbladian()
+        assert_array_almost_equal(test_L.full(), true_L.full())
+        assert_array_equal(test_L.dims, true_L.dims)
+
+    def test_liouvillian(self):
+        """
+        PIQS: Test the calculation of the liouvillian matrix.
+        """
+        true_L = [
+            [-4, 0, 0, 3],
+            [0, -3.54999995, 0, 0],
+            [0, 0, -3.54999995, 0],
+            [4, 0, 0, -3],
+        ]
+        true_L = Qobj(true_L)
+        true_L.dims = [[[2], [2]], [[2], [2]]]
+        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
+        true_H = Qobj(true_H)
+        true_H.dims = [[[2], [2]]]
+        true_liouvillian = [
+            [-4, -1.0j, 1.0j, 3],
+            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
+            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
+            [4, +1.0j, -1.0j, -3],
+        ]
+        true_liouvillian = Qobj(true_liouvillian)
+        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
+        N = 1
+        test_piqs = Dicke(
+            hamiltonian=sigmaz() + sigmax(),
+            N=N,
+            pumping=1,
+            collective_pumping=2,
+            emission=1,
+            collective_emission=3,
+            dephasing=0.1,
+        )
+        test_liouvillian = test_piqs.liouvillian()
+        test_hamiltonian = test_piqs.hamiltonian
+        assert_array_almost_equal(
+            test_liouvillian.full(), true_liouvillian.full()
+        )
+        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
+        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
+
+        # no Hamiltonian
+        test_piqs = Dicke(
+            N=N,
+            pumping=1,
+            collective_pumping=2,
+            emission=1,
+            collective_emission=3,
+            dephasing=0.1,
+        )
+        liouv = test_piqs.liouvillian()
+        lindblad = test_piqs.lindbladian()
+        assert_equal(liouv, lindblad)
+
+    def test_gamma1(self):
+        """
+        PIQS: Test the calculation of gamma1.
+        """
+        true_gamma_1 = -2
+        true_gamma_2 = -3
+        true_gamma_3 = -7
+        true_gamma_4 = -1
+        true_gamma_5 = 0
+        true_gamma_6 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, collective_emission=1)
+        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1)
+        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, dephasing=4)
+        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_pumping=2)
+        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_dephasing=2)
+        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+        assert_almost_equal(true_gamma_5, test_gamma_5)
+        assert_almost_equal(true_gamma_6, test_gamma_6)
+
+    def test_gamma2(self):
+        """
+        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 2
+        true_gamma_2 = 1.5
+        true_gamma_3 = 5.5
+        true_gamma_4 = 0
+        true_gamma_5 = 0
+        true_gamma_6 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, collective_emission=1)
+        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1)
+        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, dephasing=4)
+        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_pumping=2)
+        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_dephasing=2)
+        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+        assert_almost_equal(true_gamma_5, test_gamma_5)
+        assert_almost_equal(true_gamma_6, test_gamma_6)
+
+    def test_gamma3(self):
+        """
+        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 1.3333333730697632
+        true_gamma_3 = 1.3333333730697632
+        true_gamma_4 = 0
+        true_gamma_5 = 0
+        true_gamma_6 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, collective_emission=1)
+        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1)
+        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, dephasing=4)
+        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_pumping=2)
+        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_dephasing=2)
+        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
+        #
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+        assert_almost_equal(true_gamma_5, test_gamma_5)
+        assert_almost_equal(true_gamma_6, test_gamma_6)
+
+    def test_gamma4(self):
+        """
+        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0.1666666716337204
+        true_gamma_2 = 2
+        true_gamma_3 = 0
+        true_gamma_4 = 0.40824830532073975
+
+        N = 4
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
+        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
+        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma5(self):
+        """
+        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 0
+        true_gamma_3 = 0.75
+        true_gamma_4 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, dephasing=1)
+        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
+        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
+        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma6(self):
+        """
+        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0.25
+        true_gamma_2 = 1
+        true_gamma_3 = 0
+        true_gamma_4 = 0.25
+
+        N = 4
+        test_dicke = _Dicke(N=N, dephasing=1)
+        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
+        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
+        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma7(self):
+        """
+        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 0.5
+        true_gamma_3 = 0
+        true_gamma_4 = 1.5
+
+        N = 4
+        test_dicke = _Dicke(N=N, pumping=1)
+        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
+        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
+        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma8(self):
+        """
+        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 13.5
+        true_gamma_3 = 5.5
+        true_gamma_4 = 13.5
+
+        N = 4
+        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
+        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
+        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
+        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma9(self):
+        """
+        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 1
+        true_gamma_2 = 0
+        true_gamma_3 = 0.5
+        true_gamma_4 = 0
+        N = 4
+        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
+        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
+        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
+        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+
+class TestPim:
+    """
+    Tests for the `qutip.piqs.Pim` class.
+    """
+
+    def test_gamma(self):
+        """
+        PIQS: Test the calculation of various gamma values for diagonal system.
+
+        For N = 6 |j, m> would be :
+
+        | 3, 3>
+        | 3, 2> | 2, 2>
+        | 3, 1> | 2, 1> | 1, 1>
+        | 3, 0> | 2, 0> | 1, 0> |0, 0>
+        | 3,-1> | 2,-1> | 1,-1>
+        | 3,-2> | 2,-2>
+        | 3,-3>
+        """
+        N = 6
+        collective_emission = 1.0
+        emission = 1.0
+        dephasing = 1.0
+        pumping = 1.0
+        collective_pumping = 1.0
+        model = Pim(
+            N,
+            collective_emission=collective_emission,
+            emission=emission,
+            dephasing=dephasing,
+            pumping=pumping,
+            collective_pumping=collective_pumping,
+        )
+        tau_calculated = [
+            model.tau3(3, 1),
+            model.tau2(2, 1),
+            model.tau4(1, 1),
+            model.tau5(3, 0),
+            model.tau1(2, 0),
+            model.tau6(1, 0),
+            model.tau7(3, -1),
+            model.tau8(2, -1),
+            model.tau9(1, -1),
+        ]
+        tau_real = [
+            2.0,
+            8.0,
+            0.333333,
+            1.5,
+            -19.5,
+            0.666667,
+            2.0,
+            8.0,
+            0.333333,
+        ]
+        assert_array_almost_equal(tau_calculated, tau_real)
+
+    def test_isdicke(self):
+        """
+        PIQS: Test the `isdicke` function
+        """
+        N1 = 1
+        g0 = 0.01
+        nth = 0.01
+        gP = g0 * nth
+        gL = g0 * (0.1 + nth)
+        gS = 0.1
+        gD = 0.1
+
+        pim1 = Pim(N1, gS, gL, gD, gP)
+
+        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
+        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
+
+        N2 = 4
+
+        pim2 = Pim(N2, gS, gL, gD, gP)
+        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
+        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
+
+        assert_array_equal(dicke_labels, [True, False, True, False, True])
+
+    def test_isdiagonal(self):
+        """
+        PIQS: Test the isdiagonal function.
+        """
+        mat1 = np.array([[1, 2], [3, 4]])
+        mat2 = np.array([[1, 0.0], [0.0, 2]])
+        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
+        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
+        assert_equal(isdiagonal(mat1), False)
+        assert_equal(isdiagonal(mat2), True)
+        assert_equal(isdiagonal(mat3), False)
+        assert_equal(isdiagonal(mat4), True)
+
+    def test_pisolve(self):
+        """
+        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
+        """
+        jx, jy, jz = jspin(4)
+        jp, jm = jspin(4, "+"), jspin(4, "-")
+
+    def test_coefficient_matrix(self):
+        """
+        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
+        """
+        N = 2
+        ensemble = Pim(N, emission=1)
+        test_matrix = ensemble.coefficient_matrix().toarray()
+        ensemble2 = Dicke(N, emission=1)
+        test_matrix2 = ensemble.coefficient_matrix().toarray()
+        true_matrix = [
+            [-2, 0, 0, 0],
+            [1, -1, 0, 0],
+            [0, 1, 0, 1.0],
+            [1, 0, 0, -1.0],
+        ]
+
+        assert_array_almost_equal(test_matrix, true_matrix)
+        assert_array_almost_equal(test_matrix2, true_matrix)
+
+    def test_pisolve(self):
+        """
+        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
+        """
+        jx, jy, jz = jspin(4)
+        jp, jm = jspin(4, "+"), jspin(4, "-")
+        non_diag_hamiltonian = jx
+        diag_hamiltonian = jz
+
+        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
+        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
+
+        diag_initial_state = dicke(4, 1, 0)
+        non_diag_initial_state = ghz(4)
+        tlist = np.linspace(0, 10, 100)
+
+        assert_raises(
+            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
+        )
+        assert_raises(
+            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
+        )
+        assert_raises(
+            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
+        )
+
+        non_dicke_initial_state = excited(4, basis="uncoupled")
+        assert_raises(
+            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
+        )
+
+        # no Hamiltonian
+        no_hamiltonian_system = Dicke(4, emission=0.1)
+        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
+        assert_equal(True, len(result.states) > 0)
+
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/solve/test_qubit_evolution.py b/qutip/tests/solve/test_qubit_evolution.py
index d75697f9df..7157e3ffac 100644
--- a/qutip/tests/solve/test_qubit_evolution.py
+++ b/qutip/tests/solve/test_qubit_evolution.py
@@ -1,124 +1,124 @@
-import numpy as np
-import pytest
-from qutip import (
-    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
-)
-
-
-def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
-
-    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
-
-    c_op_list = []
-
-    rate = g1
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sigmam())
-
-    rate = g2
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sigmaz())
-
-    e_ops = [sigmax(), sigmay(), sigmaz()]
-
-    if solver == "me":
-        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
-    elif solver == "mc":
-        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
-    else:
-        raise ValueError("unknown solver")
-
-    return output.expect[0], output.expect[1], output.expect[2]
-
-
-def test_MESolverCase1():
-    """
-    Test mesolve qubit, with dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi   # cavity frequency
-    delta = 1.0 * 2 * np.pi   # atom frequency
-    g2 = 0.1
-    g1 = 0.0
-    psi0 = basis(2, 0)        # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.05
-    assert max(abs(sy - sy_analytic)) < 0.05
-    assert max(abs(sz - sz_analytic)) < 0.05
-
-
-def test_MESolverCase2():
-    """
-    Test mesolve qubit, no dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi   # cavity frequency
-    delta = 1.0 * 2 * np.pi   # atom frequency
-    g2 = 0.0
-    g1 = 0.0
-    psi0 = basis(2, 0)        # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.05
-    assert max(abs(sy - sy_analytic)) < 0.05
-    assert max(abs(sz - sz_analytic)) < 0.05
-
-
-def test_MCSolverCase1():
-    """
-    Test mcsolve qubit, with dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi      # cavity frequency
-    delta = 1.0 * 2 * np.pi        # atom frequency
-    g2 = 0.1
-    g1 = 0.0
-    psi0 = basis(2, 0)          # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.25
-    assert max(abs(sy - sy_analytic)) < 0.25
-    assert max(abs(sz - sz_analytic)) < 0.25
-
-
-@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
-def test_MCSolverCase2():
-    """
-    Test mcsolve qubit, no dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi      # cavity frequency
-    delta = 1.0 * 2 * np.pi        # atom frequency
-    g2 = 0.0
-    g1 = 0.0
-    psi0 = basis(2, 0)          # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.25
-    assert max(abs(sy - sy_analytic)) < 0.25
-    assert max(abs(sz - sz_analytic)) < 0.25
+import numpy as np
+import pytest
+from qutip import (
+    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
+)
+
+
+def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
+
+    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
+
+    c_op_list = []
+
+    rate = g1
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sigmam())
+
+    rate = g2
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sigmaz())
+
+    e_ops = [sigmax(), sigmay(), sigmaz()]
+
+    if solver == "me":
+        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
+    elif solver == "mc":
+        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
+    else:
+        raise ValueError("unknown solver")
+
+    return output.expect[0], output.expect[1], output.expect[2]
+
+
+def test_MESolverCase1():
+    """
+    Test mesolve qubit, with dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi   # cavity frequency
+    delta = 1.0 * 2 * np.pi   # atom frequency
+    g2 = 0.1
+    g1 = 0.0
+    psi0 = basis(2, 0)        # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.05
+    assert max(abs(sy - sy_analytic)) < 0.05
+    assert max(abs(sz - sz_analytic)) < 0.05
+
+
+def test_MESolverCase2():
+    """
+    Test mesolve qubit, no dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi   # cavity frequency
+    delta = 1.0 * 2 * np.pi   # atom frequency
+    g2 = 0.0
+    g1 = 0.0
+    psi0 = basis(2, 0)        # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.05
+    assert max(abs(sy - sy_analytic)) < 0.05
+    assert max(abs(sz - sz_analytic)) < 0.05
+
+
+def test_MCSolverCase1():
+    """
+    Test mcsolve qubit, with dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi      # cavity frequency
+    delta = 1.0 * 2 * np.pi        # atom frequency
+    g2 = 0.1
+    g1 = 0.0
+    psi0 = basis(2, 0)          # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.25
+    assert max(abs(sy - sy_analytic)) < 0.25
+    assert max(abs(sz - sz_analytic)) < 0.25
+
+
+@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
+def test_MCSolverCase2():
+    """
+    Test mcsolve qubit, no dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi      # cavity frequency
+    delta = 1.0 * 2 * np.pi        # atom frequency
+    g2 = 0.0
+    g1 = 0.0
+    psi0 = basis(2, 0)          # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.25
+    assert max(abs(sy - sy_analytic)) < 0.25
+    assert max(abs(sz - sz_analytic)) < 0.25
diff --git a/qutip/tests/solve/test_stochastic_me.py b/qutip/tests/solve/test_stochastic_me.py
index 27ac7c821a..f282254bc7 100644
--- a/qutip/tests/solve/test_stochastic_me.py
+++ b/qutip/tests/solve/test_stochastic_me.py
@@ -1,309 +1,309 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-
-from qutip import (
-    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
-    destroy, coherent, qeye, fock_dm, general_stochastic, num,
-)
-from qutip.solve.parallel import parallel_map
-from qutip.core import data as _data
-def f(t, args):
-    return args["a"] * t
-
-
-@pytest.mark.slow
-def test_smesolve_homodyne_methods():
-    "Stochastic: smesolve: homodyne methods with single jump operator"
-
-    def arccoth(x):
-        return 0.5*np.log((1.+x)/(x-1.))
-
-    th = 0.1 # Interaction parameter
-    alpha = np.cos(th)
-    beta = np.sin(th)
-    gamma = 1.
-
-    N = 30                 # number of Fock states
-    Id = qeye(N)
-    a = destroy(N)
-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-    x = (a + a.dag()) * 2**-0.5
-    H = Id
-    c_op = [gamma**0.5 * a]
-    sc_op = [s]
-    e_op = [x, x*x]
-    rho0 = fock_dm(N,0)      # initial vacuum state
-
-    T = 3.                   # final time
-    # number of time steps for which we save the expectation values
-    N_store = 121
-    Nsub = 10
-    tlist = np.linspace(0, T, N_store)
-    ddt = (tlist[1]-tlist[0])
-
-    #### Analytic solution
-    y0 = 0.5
-    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
-    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
-    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
-
-
-    list_methods_tol = [['euler-maruyama', 2e-2],
-                        ['pc-euler', 2e-3],
-                        ['pc-euler-2', 2e-3],
-                        ['platen', 1e-3],
-                        ['milstein', 1e-3],
-                        ['milstein-imp', 1e-3],
-                        ['rouchon', 1e-3],
-                        ['taylor1.5', 1e-4],
-                        ['taylor1.5-imp', 1e-4],
-                        ['explicit1.5', 1e-4],
-                        ['taylor2.0', 1e-4]]
-    for n_method in list_methods_tol:
-        # Comparisons of error between sol and sol3 depend on the stochastic
-        # noise, thus the seed, fixing the seed remove random fails.
-        np.random.seed(1)
-        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
-        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
-                       noise = sol.noise)
-        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-                        nsubsteps=Nsub*5, method='homodyne',
-                        solver = n_method[0], tol=1e-8)
-        err = 1/T * np.sum(np.abs(y_an - \
-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-        err3 = 1/T * np.sum(np.abs(y_an - \
-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
-        assert_(err < n_method[1])
-        # 5* more substep should decrease the error
-        assert_(err3 < err)
-        # just to check that noise is not affected by smesolve
-        assert_(np.all(sol.noise == sol2.noise))
-        assert_(np.all(sol.expect[0] == sol2.expect[0]))
-
-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=1)
-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=0)
-    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the same seed, sol3 differ.
-    assert_(np.all(sol.noise == sol2.noise))
-    assert_(np.all(sol.noise != sol3.noise))
-    assert_(not np.all(sol.measurement[0] == 0.+0j))
-    assert_(np.all(sol2.measurement[0] == 0.+0j))
-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the seed of traj 1 and 2 reversed.
-    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
-    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
-
-
-def test_smesolve_photocurrent():
-    "Stochastic: photocurrent_mesolve"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
-                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
-                   map_func=parallel_map)
-
-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                 for idx in range(len(e_ops))]))
-    assert_(len(res.measurement) == ntraj)
-    assert_(all([m.shape == (len(times), len(sc_ops))
-                 for m in res.measurement]))
-
-
-def test_smesolve_homodyne():
-    "Stochastic: smesolve: homodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'pc-euler',
-                        'pc-euler-2',
-                        'platen',
-                        'milstein',
-                        'milstein-imp',
-                        'rouchon',
-                        'taylor15',
-                        'taylor15-imp',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-                       method='homodyne', store_measurement=True,
-                       solver=solver, map_func=parallel_map)
-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                     for idx in range(len(e_ops))]))
-        assert_(len(res.measurement) == ntraj)
-        assert_(all([m.shape == (len(times), len(sc_ops))
-                     for m in res.measurement]))
-
-
-@pytest.mark.slow
-def test_smesolve_heterodyne():
-    "Stochastic: smesolve: heterodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a, f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'pc-euler',
-                        'pc-euler-2',
-                        'platen',
-                        'milstein',
-                        'milstein-imp',
-                        'rouchon',
-                        'taylor15',
-                        'taylor15-imp',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-                       method='heterodyne', store_measurement=True,
-                       solver=solver, map_func=parallel_map)
-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                     for idx in range(len(e_ops))]))
-        assert_(len(res.measurement) == ntraj)
-        assert_(all([m.shape == (len(times), len(sc_ops), 2)
-                     for m in res.measurement]))
-
-
-@pytest.mark.slow
-def test_general_stochastic():
-    "Stochastic: general_stochastic"
-    "Reproduce smesolve homodyne"
-    tol = 0.025
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 50
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
-    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
-    e_opsM = [spre(op) for op in e_ops]
-
-    def d1(t, vec):
-        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
-
-    def d2(t, vec):
-        out = []
-        vec_d = _data.Dense(vec)
-        for op in sc_opsM:
-            scale = -op.expect_data(t,vec_d)
-            out.append(
-                _data.add(op.matmul_data(t,vec_d),
-                          vec_d, scale)
-                )
-        return np.stack([o.to_array().ravel() for o in out])
-
-    times = np.linspace(0, 0.5, 13)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'platen',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
-                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
-                                 nsubsteps=nsubsteps, solver=solver)
-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                 for idx in range(len(e_ops))]))
-    assert_(len(res.measurement) == ntraj)
-
-
-def f_dargs(a, args):
-    return args["expect_op_3"] - 1
-
-
-@pytest.mark.xfail(reason="not working yet")
-def test_ssesolve_feedback():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [[a + a.dag(), f_dargs]]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-
-    times = np.linspace(0, 10, 101)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-                      args={"expect_op_3":qeye(N)})
-    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
-
-    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
-
-
-def test_smesolve_bad_e_ops():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [a + a.dag()]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
-
-    times = np.linspace(0, 10, 101)
-    with pytest.raises(TypeError) as exc:
-        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                       map_func=parallel_map)
+import pytest
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+
+from qutip import (
+    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
+    destroy, coherent, qeye, fock_dm, general_stochastic, num,
+)
+from qutip.solve.parallel import parallel_map
+from qutip.core import data as _data
+def f(t, args):
+    return args["a"] * t
+
+
+@pytest.mark.slow
+def test_smesolve_homodyne_methods():
+    "Stochastic: smesolve: homodyne methods with single jump operator"
+
+    def arccoth(x):
+        return 0.5*np.log((1.+x)/(x-1.))
+
+    th = 0.1 # Interaction parameter
+    alpha = np.cos(th)
+    beta = np.sin(th)
+    gamma = 1.
+
+    N = 30                 # number of Fock states
+    Id = qeye(N)
+    a = destroy(N)
+    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
+    x = (a + a.dag()) * 2**-0.5
+    H = Id
+    c_op = [gamma**0.5 * a]
+    sc_op = [s]
+    e_op = [x, x*x]
+    rho0 = fock_dm(N,0)      # initial vacuum state
+
+    T = 3.                   # final time
+    # number of time steps for which we save the expectation values
+    N_store = 121
+    Nsub = 10
+    tlist = np.linspace(0, T, N_store)
+    ddt = (tlist[1]-tlist[0])
+
+    #### Analytic solution
+    y0 = 0.5
+    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
+    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
+    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
+
+
+    list_methods_tol = [['euler-maruyama', 2e-2],
+                        ['pc-euler', 2e-3],
+                        ['pc-euler-2', 2e-3],
+                        ['platen', 1e-3],
+                        ['milstein', 1e-3],
+                        ['milstein-imp', 1e-3],
+                        ['rouchon', 1e-3],
+                        ['taylor1.5', 1e-4],
+                        ['taylor1.5-imp', 1e-4],
+                        ['explicit1.5', 1e-4],
+                        ['taylor2.0', 1e-4]]
+    for n_method in list_methods_tol:
+        # Comparisons of error between sol and sol3 depend on the stochastic
+        # noise, thus the seed, fixing the seed remove random fails.
+        np.random.seed(1)
+        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
+                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
+        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
+                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
+                       noise = sol.noise)
+        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
+                        nsubsteps=Nsub*5, method='homodyne',
+                        solver = n_method[0], tol=1e-8)
+        err = 1/T * np.sum(np.abs(y_an - \
+                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
+        err3 = 1/T * np.sum(np.abs(y_an - \
+                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
+        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
+        assert_(err < n_method[1])
+        # 5* more substep should decrease the error
+        assert_(err3 < err)
+        # just to check that noise is not affected by smesolve
+        assert_(np.all(sol.noise == sol2.noise))
+        assert_(np.all(sol.expect[0] == sol2.expect[0]))
+
+    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=1)
+    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=0)
+    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the same seed, sol3 differ.
+    assert_(np.all(sol.noise == sol2.noise))
+    assert_(np.all(sol.noise != sol3.noise))
+    assert_(not np.all(sol.measurement[0] == 0.+0j))
+    assert_(np.all(sol2.measurement[0] == 0.+0j))
+    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the seed of traj 1 and 2 reversed.
+    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
+    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
+
+
+def test_smesolve_photocurrent():
+    "Stochastic: photocurrent_mesolve"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
+                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
+                   map_func=parallel_map)
+
+    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                 for idx in range(len(e_ops))]))
+    assert_(len(res.measurement) == ntraj)
+    assert_(all([m.shape == (len(times), len(sc_ops))
+                 for m in res.measurement]))
+
+
+def test_smesolve_homodyne():
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    list_methods_tol = ['euler-maruyama',
+                        'pc-euler',
+                        'pc-euler-2',
+                        'platen',
+                        'milstein',
+                        'milstein-imp',
+                        'rouchon',
+                        'taylor15',
+                        'taylor15-imp',
+                        'explicit15']
+    for solver in list_methods_tol:
+        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
+                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
+                       method='homodyne', store_measurement=True,
+                       solver=solver, map_func=parallel_map)
+        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                     for idx in range(len(e_ops))]))
+        assert_(len(res.measurement) == ntraj)
+        assert_(all([m.shape == (len(times), len(sc_ops))
+                     for m in res.measurement]))
+
+
+@pytest.mark.slow
+def test_smesolve_heterodyne():
+    "Stochastic: smesolve: heterodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a, f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    list_methods_tol = ['euler-maruyama',
+                        'pc-euler',
+                        'pc-euler-2',
+                        'platen',
+                        'milstein',
+                        'milstein-imp',
+                        'rouchon',
+                        'taylor15',
+                        'taylor15-imp',
+                        'explicit15']
+    for solver in list_methods_tol:
+        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
+                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
+                       method='heterodyne', store_measurement=True,
+                       solver=solver, map_func=parallel_map)
+        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                     for idx in range(len(e_ops))]))
+        assert_(len(res.measurement) == ntraj)
+        assert_(all([m.shape == (len(times), len(sc_ops), 2)
+                     for m in res.measurement]))
+
+
+@pytest.mark.slow
+def test_general_stochastic():
+    "Stochastic: general_stochastic"
+    "Reproduce smesolve homodyne"
+    tol = 0.025
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 50
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
+    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
+    e_opsM = [spre(op) for op in e_ops]
+
+    def d1(t, vec):
+        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
+
+    def d2(t, vec):
+        out = []
+        vec_d = _data.Dense(vec)
+        for op in sc_opsM:
+            scale = -op.expect_data(t,vec_d)
+            out.append(
+                _data.add(op.matmul_data(t,vec_d),
+                          vec_d, scale)
+                )
+        return np.stack([o.to_array().ravel() for o in out])
+
+    times = np.linspace(0, 0.5, 13)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    list_methods_tol = ['euler-maruyama',
+                        'platen',
+                        'explicit15']
+    for solver in list_methods_tol:
+        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
+                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
+                                 nsubsteps=nsubsteps, solver=solver)
+    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                 for idx in range(len(e_ops))]))
+    assert_(len(res.measurement) == ntraj)
+
+
+def f_dargs(a, args):
+    return args["expect_op_3"] - 1
+
+
+@pytest.mark.xfail(reason="not working yet")
+def test_ssesolve_feedback():
+    "Stochastic: ssesolve: time-dependent H with feedback"
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [[a + a.dag(), f_dargs]]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
+
+    times = np.linspace(0, 10, 101)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
+                      args={"expect_op_3":qeye(N)})
+    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
+                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
+
+    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
+
+
+def test_smesolve_bad_e_ops():
+    "Stochastic: ssesolve: time-dependent H with feedback"
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [a + a.dag()]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
+
+    times = np.linspace(0, 10, 101)
+    with pytest.raises(TypeError) as exc:
+        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
+                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                       map_func=parallel_map)
diff --git a/qutip/tests/solve/test_stochastic_se.py b/qutip/tests/solve/test_stochastic_se.py
index 8a40f2d756..e18ec023d5 100644
--- a/qutip/tests/solve/test_stochastic_se.py
+++ b/qutip/tests/solve/test_stochastic_se.py
@@ -1,230 +1,230 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_
-
-from qutip import (
-    ssesolve, destroy, coherent, mesolve, fock, qeye,
-    photocurrent_sesolve, num,
-)
-from qutip.solve.parallel import parallel_map
-
-def f(t, args):
-    return args["a"] * t
-
-
-@pytest.mark.slow
-def test_ssesolve_homodyne_methods():
-    "Stochastic: ssesolve: homodyne methods with single jump operator"
-
-    def arccoth(x):
-        return 0.5*np.log((1.+x)/(x-1.))
-
-    th = 0.1 # Interaction parameter
-    alpha = np.cos(th)
-    beta = np.sin(th)
-    gamma = 1.
-
-    N = 30                 # number of Fock states
-    Id = qeye(N)
-    a = destroy(N)
-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-    x = (a + a.dag()) * 2**-0.5
-    H = Id + gamma * a * a.dag()
-    sc_op = [s]
-    e_op = [x, x*x]
-    rho0 = fock(N,0)      # initial vacuum state
-
-    T = 6.                   # final time
-    # number of time steps for which we save the expectation values
-    N_store = 200
-    Nsub = 10
-    tlist = np.linspace(0, T, N_store)
-    ddt = (tlist[1]-tlist[0])
-
-    #### No analytic solution for ssesolve, taylor15 with 500 substep
-    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
-    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
-
-
-    list_methods_tol = [['euler-maruyama', 3e-2],
-                        ['pc-euler', 5e-3],
-                        ['pc-euler-2', 5e-3],
-                        ['platen', 5e-3],
-                        ['milstein', 5e-3],
-                        ['milstein-imp', 5e-3],
-                        ['taylor1.5', 5e-4],
-                        ['taylor1.5-imp', 5e-4],
-                        ['explicit1.5', 5e-4],
-                        ['taylor2.0', 5e-4]]
-    for n_method in list_methods_tol:
-        # Comparisons of error between sol and sol3 depend on the stochastic
-        # noise, thus the seed, fixing the seed remove random fails.
-        np.random.seed(1)
-        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
-        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
-                       noise = sol.noise)
-        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
-                        nsubsteps=Nsub*10, method='homodyne',
-                        solver=n_method[0], tol=1e-8)
-        err = 1/T * np.sum(np.abs(y_an - \
-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-        err3 = 1/T * np.sum(np.abs(y_an - \
-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-        assert err < n_method[1]
-        # 5* more substep should decrease the error
-        assert err3 < err
-        # just to check that noise is not affected by ssesolve
-        assert np.all(sol.noise == sol2.noise)
-        assert np.all(sol.expect[0] == sol2.expect[0])
-
-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=1)
-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=0)
-    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the same seed, sol3 differ.
-    assert np.all(sol.noise == sol2.noise)
-    assert np.all(sol.noise != sol3.noise)
-    assert not np.all(sol.measurement[0] == 0.+0j)
-    assert np.all(sol2.measurement[0] == 0.+0j)
-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the seed of traj 1 and 2 reversed.
-    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
-    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
-
-
-def test_ssesolve_photocurrent():
-    "Stochastic: photocurrent_sesolve"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
-                              nsubsteps=nsubsteps, store_measurement=True,
-                              map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
-
-
-def test_ssesolve_homodyne():
-    "Stochastic: ssesolve: homodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-                   ntraj=ntraj, nsubsteps=nsubsteps,
-                   method='homodyne', store_measurement=True,
-                   map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
-
-
-@pytest.mark.slow
-def test_ssesolve_heterodyne():
-    "Stochastic: ssesolve: heterodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-                   ntraj=ntraj, nsubsteps=nsubsteps,
-                   method='heterodyne', store_measurement=True,
-                   map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all(m.shape == (len(times), len(sc_ops), 2)
-               for m in res.measurement)
-
-
-def f_dargs(t, args):
-    return args["expect_op_3"] - 1
-
-
-@pytest.mark.xfail(reason="not yet working")
-def test_ssesolve_feedback():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [[a + a.dag(), f_dargs]]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-
-    times = np.linspace(0, 10, 101)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-                      args={"expect_op_3": qeye(N)})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-
-
-def test_ssesolve_bad_e_ops():
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-    b = destroy(N-1)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [a + a.dag()]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
-    times = np.linspace(0, 10, 101)
-    with pytest.raises(TypeError) as exc:
-        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                       map_func=parallel_map)
+import pytest
+import numpy as np
+from numpy.testing import assert_
+
+from qutip import (
+    ssesolve, destroy, coherent, mesolve, fock, qeye,
+    photocurrent_sesolve, num,
+)
+from qutip.solve.parallel import parallel_map
+
+def f(t, args):
+    return args["a"] * t
+
+
+@pytest.mark.slow
+def test_ssesolve_homodyne_methods():
+    "Stochastic: ssesolve: homodyne methods with single jump operator"
+
+    def arccoth(x):
+        return 0.5*np.log((1.+x)/(x-1.))
+
+    th = 0.1 # Interaction parameter
+    alpha = np.cos(th)
+    beta = np.sin(th)
+    gamma = 1.
+
+    N = 30                 # number of Fock states
+    Id = qeye(N)
+    a = destroy(N)
+    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
+    x = (a + a.dag()) * 2**-0.5
+    H = Id + gamma * a * a.dag()
+    sc_op = [s]
+    e_op = [x, x*x]
+    rho0 = fock(N,0)      # initial vacuum state
+
+    T = 6.                   # final time
+    # number of time steps for which we save the expectation values
+    N_store = 200
+    Nsub = 10
+    tlist = np.linspace(0, T, N_store)
+    ddt = (tlist[1]-tlist[0])
+
+    #### No analytic solution for ssesolve, taylor15 with 500 substep
+    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
+                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
+    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
+
+
+    list_methods_tol = [['euler-maruyama', 3e-2],
+                        ['pc-euler', 5e-3],
+                        ['pc-euler-2', 5e-3],
+                        ['platen', 5e-3],
+                        ['milstein', 5e-3],
+                        ['milstein-imp', 5e-3],
+                        ['taylor1.5', 5e-4],
+                        ['taylor1.5-imp', 5e-4],
+                        ['explicit1.5', 5e-4],
+                        ['taylor2.0', 5e-4]]
+    for n_method in list_methods_tol:
+        # Comparisons of error between sol and sol3 depend on the stochastic
+        # noise, thus the seed, fixing the seed remove random fails.
+        np.random.seed(1)
+        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
+                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
+        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
+                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
+                       noise = sol.noise)
+        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
+                        nsubsteps=Nsub*10, method='homodyne',
+                        solver=n_method[0], tol=1e-8)
+        err = 1/T * np.sum(np.abs(y_an - \
+                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
+        err3 = 1/T * np.sum(np.abs(y_an - \
+                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
+        assert err < n_method[1]
+        # 5* more substep should decrease the error
+        assert err3 < err
+        # just to check that noise is not affected by ssesolve
+        assert np.all(sol.noise == sol2.noise)
+        assert np.all(sol.expect[0] == sol2.expect[0])
+
+    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=1)
+    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=0)
+    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the same seed, sol3 differ.
+    assert np.all(sol.noise == sol2.noise)
+    assert np.all(sol.noise != sol3.noise)
+    assert not np.all(sol.measurement[0] == 0.+0j)
+    assert np.all(sol2.measurement[0] == 0.+0j)
+    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the seed of traj 1 and 2 reversed.
+    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
+    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
+
+
+def test_ssesolve_photocurrent():
+    "Stochastic: photocurrent_sesolve"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 25
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 2.5, 50)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
+                              nsubsteps=nsubsteps, store_measurement=True,
+                              map_func=parallel_map, args={"a":2})
+
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+    assert len(res.measurement) == ntraj
+    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
+
+
+def test_ssesolve_homodyne():
+    "Stochastic: ssesolve: homodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 25
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 2.5, 50)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = ssesolve(H, psi0, times, sc_ops, e_ops,
+                   ntraj=ntraj, nsubsteps=nsubsteps,
+                   method='homodyne', store_measurement=True,
+                   map_func=parallel_map, args={"a":2})
+
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+    assert len(res.measurement) == ntraj
+    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
+
+
+@pytest.mark.slow
+def test_ssesolve_heterodyne():
+    "Stochastic: ssesolve: heterodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 25
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 2.5, 50)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = ssesolve(H, psi0, times, sc_ops, e_ops,
+                   ntraj=ntraj, nsubsteps=nsubsteps,
+                   method='heterodyne', store_measurement=True,
+                   map_func=parallel_map, args={"a":2})
+
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+    assert len(res.measurement) == ntraj
+    assert all(m.shape == (len(times), len(sc_ops), 2)
+               for m in res.measurement)
+
+
+def f_dargs(t, args):
+    return args["expect_op_3"] - 1
+
+
+@pytest.mark.xfail(reason="not yet working")
+def test_ssesolve_feedback():
+    "Stochastic: ssesolve: time-dependent H with feedback"
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [[a + a.dag(), f_dargs]]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
+
+    times = np.linspace(0, 10, 101)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
+                      args={"expect_op_3": qeye(N)})
+    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
+                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+
+
+def test_ssesolve_bad_e_ops():
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+    b = destroy(N-1)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [a + a.dag()]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
+    times = np.linspace(0, 10, 101)
+    with pytest.raises(TypeError) as exc:
+        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
+                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                       map_func=parallel_map)
diff --git a/qutip/tests/solver/heom/test_bofin_baths.py b/qutip/tests/solver/heom/test_bofin_baths.py
index c6c5c80fc1..32a4eca261 100644
--- a/qutip/tests/solver/heom/test_bofin_baths.py
+++ b/qutip/tests/solver/heom/test_bofin_baths.py
@@ -1,465 +1,465 @@
-"""
-Tests for qutip.nonmarkov.bofin_baths.
-"""
-
-import numpy as np
-import pytest
-
-from qutip import spre, spost, sigmax, sigmaz
-from qutip.core import data as _data
-from qutip.solver.heom.bofin_baths import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-)
-
-
-def isequal(Q1, Q2, tol):
-    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
-    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
-
-
-def check_exponent(
-    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
-):
-    """ Check the attributes of a BathExponent. """
-    assert exp.type is BathExponent.types[type]
-    assert exp.fermionic == (type in ["+", "-"])
-    assert exp.dim == dim
-    assert exp.Q == Q
-    assert exp.ck == pytest.approx(ck)
-    assert exp.vk == pytest.approx(vk)
-    assert exp.ck2 == pytest.approx(ck2)
-    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
-    assert exp.tag == tag
-
-
-class TestBathExponent:
-    def test_create(self):
-        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
-        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
-
-        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
-        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
-
-        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
-        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
-
-        exp_p = BathExponent(
-            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-        )
-        check_exponent(
-            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-        )
-
-        exp_m = BathExponent(
-            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
-        )
-        check_exponent(
-            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
-        )
-
-        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
-        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
-
-        for exp_type, kw in [
-            ("R", {}),
-            ("I", {}),
-            ("+", {"sigma_bar_k_offset": 1}),
-            ("-", {"sigma_bar_k_offset": -1}),
-        ]:
-            with pytest.raises(ValueError) as err:
-                BathExponent(
-                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
-                )
-            assert str(err.value) == (
-                "Second co-efficient (ck2) should only be specified for RI"
-                " bath exponents"
-            )
-
-        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
-            with pytest.raises(ValueError) as err:
-                BathExponent(
-                    exp_type, None, Q=None, ck=1.0, vk=2.0,
-                    sigma_bar_k_offset=1, **kw,
-                )
-            assert str(err.value) == (
-                "Offset of sigma bar (sigma_bar_k_offset) should only be"
-                " specified for + and - bath exponents"
-            )
-
-    def test_repr(self):
-        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
-        assert repr(exp1) == (
-            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
-            " ck=1.0 vk=2.0 ck2=None"
-            " sigma_bar_k_offset=None fermionic=False tag=None>"
-        )
-        exp2 = BathExponent(
-            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-            tag="bath1",
-        )
-        assert repr(exp2) == (
-            "<BathExponent type=+ dim=None Q.dims=None"
-            " ck=1.0 vk=2.0 ck2=None"
-            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
-        )
-
-
-class TestBath:
-    def test_create(self):
-        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
-        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
-        bath = Bath([exp_r, exp_i])
-        assert bath.exponents == [exp_r, exp_i]
-
-
-class TestBosonicBath:
-    def test_create(self):
-        Q = sigmaz()
-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
-        exp_r, exp_i = bath.exponents
-        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
-        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
-
-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
-        [exp_ri] = bath.exponents
-        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
-
-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
-        exp_r, exp_i = bath.exponents
-        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
-        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
-
-        with pytest.raises(ValueError) as err:
-            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
-        assert str(err.value) == "The coupling operator Q must be a Qobj."
-
-        with pytest.raises(ValueError) as err:
-            BosonicBath(Q, [1.], [], [2.], [0.6])
-        assert str(err.value) == (
-            "The bath exponent lists ck_real and vk_real, and ck_imag and"
-            " vk_imag must be the same length."
-        )
-
-        with pytest.raises(ValueError) as err:
-            BosonicBath(Q, [1.], [0.5], [2.], [])
-        assert str(err.value) == (
-            "The bath exponent lists ck_real and vk_real, and ck_imag and"
-            " vk_imag must be the same length."
-        )
-
-    def test_combine(self):
-        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
-        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
-        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
-        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_rx, exp_rx])
-        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_ix, exp_ix])
-        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_rix, exp_rix])
-        check_exponent(
-            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
-        )
-
-        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
-        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
-        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_rx, exp_ix])
-        check_exponent(
-            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
-        )
-
-        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
-        check_exponent(
-            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
-        )
-
-
-class TestDrudeLorentzBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_real = [0.05262168274189053, 0.0007958201977617107]
-        vk_real = [0.05, 6.613879270715354]
-        ck_imag = [-0.0012500000000000002]
-        vk_imag = [0.05]
-
-        bath = DrudeLorentzBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
-        )
-        [exp1, exp2] = bath.exponents
-        check_exponent(
-            exp1, "RI", dim=None, Q=Q,
-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-            tag="bath1",
-        )
-        check_exponent(
-            exp2, "R", dim=None, Q=Q,
-            ck=ck_real[1], vk=vk_real[1],
-            tag="bath1",
-        )
-
-        bath = DrudeLorentzBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
-        )
-        [exp1, exp2, exp3] = bath.exponents
-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-
-    @pytest.mark.parametrize(['combine'], [
-        pytest.param(True, id="combine"),
-        pytest.param(False, id="no-combine"),
-    ])
-    def test_terminator(self, combine):
-        Q = sigmaz()
-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-
-        bath = DrudeLorentzBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
-        )
-        delta, terminator = bath.terminator()
-
-        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
-        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
-
-
-class TestDrudeLorentzPadeBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_real = [0.05262168274189053, 0.0016138037466648136]
-        vk_real = [0.05, 8.153649149910352]
-        ck_imag = [-0.0012500000000000002]
-        vk_imag = [0.05]
-
-        bath = DrudeLorentzPadeBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
-        )
-        [exp1, exp2] = bath.exponents
-        check_exponent(
-            exp1, "RI", dim=None, Q=Q,
-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-            tag="bath1",
-        )
-        check_exponent(
-            exp2, "R", dim=None, Q=Q,
-            ck=ck_real[1], vk=vk_real[1],
-            tag="bath1",
-        )
-
-        bath = DrudeLorentzPadeBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
-        )
-        [exp1, exp2, exp3] = bath.exponents
-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-
-    @pytest.mark.parametrize(['combine'], [
-        pytest.param(True, id="combine"),
-        pytest.param(False, id="no-combine"),
-    ])
-    def test_terminator(self, combine):
-        Q = sigmaz()
-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-
-        bath = DrudeLorentzPadeBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
-        )
-        delta, terminator = bath.terminator()
-
-        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
-        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
-
-
-class TestUnderDampedBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_real = [
-            0.0003533235200322013-7.634500355085952e-06j,
-            0.0003533235200322013+7.634500355085952e-06j,
-            -2.173594134367819e-07+0j,
-        ]
-        vk_real = [
-            0.025-0.9996874511566103j,
-            0.025+0.9996874511566103j,
-            6.613879270715354,
-        ]
-        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
-        vk_imag = [
-            0.025-0.9996874511566103j,
-            0.025+0.9996874511566103j,
-        ]
-
-        bath = UnderDampedBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
-        )
-        [exp1, exp2, exp3] = bath.exponents
-        check_exponent(
-            exp1, "RI", dim=None, Q=Q,
-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-            tag="bath1",
-        )
-        check_exponent(
-            exp2, "RI", dim=None, Q=Q,
-            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
-            tag="bath1",
-        )
-        check_exponent(
-            exp3, "R", dim=None, Q=Q,
-            ck=ck_real[2], vk=vk_real[2],
-            tag="bath1",
-        )
-
-        bath = UnderDampedBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
-        )
-        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
-        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
-
-
-class TestFermionicBath:
-    def test_create(self):
-        Q = 1j * sigmaz()
-        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
-        exp_p, exp_m = bath.exponents
-        check_exponent(
-            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
-        )
-        check_exponent(
-            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
-        )
-
-        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
-        exp_p, exp_m = bath.exponents
-        check_exponent(
-            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
-            tag="bath1",
-        )
-        check_exponent(
-            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
-            tag="bath1",
-        )
-
-        with pytest.raises(ValueError) as err:
-            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
-        assert str(err.value) == "The coupling operator Q must be a Qobj."
-
-        with pytest.raises(ValueError) as err:
-            FermionicBath(Q, [1.], [], [2.], [0.6])
-        assert str(err.value) == (
-            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-            " vk_minus must be the same length."
-        )
-
-        with pytest.raises(ValueError) as err:
-            FermionicBath(Q, [1.], [0.5], [2.], [])
-        assert str(err.value) == (
-            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-            " vk_minus must be the same length."
-        )
-
-
-class TestLorentzianBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_plus = [
-            0.0025-0.0013376935246402686j,
-            -0.00026023645770006167j,
-            -0.0002748355116913478j,
-        ]
-        vk_plus = [
-            1+1j,
-            0.08121642500626945+1j,
-            0.24364927501880834+1j,
-        ]
-        ck_minus = [
-            0.0025-0.0013376935246402686j,
-            -0.00026023645770006167j,
-            -0.0002748355116913478j,
-        ]
-        vk_minus = [
-            1-1j,
-            0.08121642500626945-1j,
-            0.24364927501880834-1j,
-        ]
-
-        bath = LorentzianBath(
-            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
-        )
-        assert len(bath.exponents) == 6
-        for i in range(len(ck_plus)):
-            exp_p = bath.exponents[2 * i]
-            exp_m = bath.exponents[2 * i + 1]
-            check_exponent(
-                exp_p, "+", dim=2, Q=Q,
-                ck=ck_plus[i], vk=vk_plus[i],
-                sigma_bar_k_offset=1,
-                tag="bath1",
-            )
-            check_exponent(
-                exp_m, "-", dim=2, Q=Q,
-                ck=ck_minus[i], vk=vk_minus[i],
-                sigma_bar_k_offset=-1,
-                tag="bath1",
-            )
-
-
-class TestLorentzianPadeBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_plus = [
-            0.0025+0.0014269000277373958j,
-            -0.0002608459250597002j,
-            -0.0011660541026776957j,
-        ]
-        vk_plus = [
-            1+1j,
-            0.08123902308117874+1j,
-            0.3371925267385835+1j,
-        ]
-        ck_minus = [
-            0.0025+0.0014269000277373958j,
-            -0.0002608459250597002j,
-            -0.0011660541026776957j,
-        ]
-        vk_minus = [
-            1-1j,
-            0.08123902308117874-1j,
-            0.3371925267385835-1j,
-        ]
-
-        bath = LorentzianPadeBath(
-            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
-        )
-        assert len(bath.exponents) == 6
-        for i in range(len(ck_plus)):
-            exp_p = bath.exponents[2 * i]
-            exp_m = bath.exponents[2 * i + 1]
-            check_exponent(
-                exp_p, "+", dim=2, Q=Q,
-                ck=ck_plus[i], vk=vk_plus[i],
-                sigma_bar_k_offset=1,
-                tag="bath1",
-            )
-            check_exponent(
-                exp_m, "-", dim=2, Q=Q,
-                ck=ck_minus[i], vk=vk_minus[i],
-                sigma_bar_k_offset=-1,
-                tag="bath1",
-            )
+"""
+Tests for qutip.nonmarkov.bofin_baths.
+"""
+
+import numpy as np
+import pytest
+
+from qutip import spre, spost, sigmax, sigmaz
+from qutip.core import data as _data
+from qutip.solver.heom.bofin_baths import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+)
+
+
+def isequal(Q1, Q2, tol):
+    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
+    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
+
+
+def check_exponent(
+    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
+):
+    """ Check the attributes of a BathExponent. """
+    assert exp.type is BathExponent.types[type]
+    assert exp.fermionic == (type in ["+", "-"])
+    assert exp.dim == dim
+    assert exp.Q == Q
+    assert exp.ck == pytest.approx(ck)
+    assert exp.vk == pytest.approx(vk)
+    assert exp.ck2 == pytest.approx(ck2)
+    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
+    assert exp.tag == tag
+
+
+class TestBathExponent:
+    def test_create(self):
+        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
+        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
+
+        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
+        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
+
+        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
+        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
+
+        exp_p = BathExponent(
+            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+        )
+        check_exponent(
+            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+        )
+
+        exp_m = BathExponent(
+            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
+        )
+        check_exponent(
+            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
+        )
+
+        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
+        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
+
+        for exp_type, kw in [
+            ("R", {}),
+            ("I", {}),
+            ("+", {"sigma_bar_k_offset": 1}),
+            ("-", {"sigma_bar_k_offset": -1}),
+        ]:
+            with pytest.raises(ValueError) as err:
+                BathExponent(
+                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
+                )
+            assert str(err.value) == (
+                "Second co-efficient (ck2) should only be specified for RI"
+                " bath exponents"
+            )
+
+        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
+            with pytest.raises(ValueError) as err:
+                BathExponent(
+                    exp_type, None, Q=None, ck=1.0, vk=2.0,
+                    sigma_bar_k_offset=1, **kw,
+                )
+            assert str(err.value) == (
+                "Offset of sigma bar (sigma_bar_k_offset) should only be"
+                " specified for + and - bath exponents"
+            )
+
+    def test_repr(self):
+        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
+        assert repr(exp1) == (
+            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
+            " ck=1.0 vk=2.0 ck2=None"
+            " sigma_bar_k_offset=None fermionic=False tag=None>"
+        )
+        exp2 = BathExponent(
+            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+            tag="bath1",
+        )
+        assert repr(exp2) == (
+            "<BathExponent type=+ dim=None Q.dims=None"
+            " ck=1.0 vk=2.0 ck2=None"
+            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
+        )
+
+
+class TestBath:
+    def test_create(self):
+        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
+        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
+        bath = Bath([exp_r, exp_i])
+        assert bath.exponents == [exp_r, exp_i]
+
+
+class TestBosonicBath:
+    def test_create(self):
+        Q = sigmaz()
+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
+        exp_r, exp_i = bath.exponents
+        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
+        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
+
+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
+        [exp_ri] = bath.exponents
+        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
+
+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
+        exp_r, exp_i = bath.exponents
+        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
+        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
+
+        with pytest.raises(ValueError) as err:
+            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
+        assert str(err.value) == "The coupling operator Q must be a Qobj."
+
+        with pytest.raises(ValueError) as err:
+            BosonicBath(Q, [1.], [], [2.], [0.6])
+        assert str(err.value) == (
+            "The bath exponent lists ck_real and vk_real, and ck_imag and"
+            " vk_imag must be the same length."
+        )
+
+        with pytest.raises(ValueError) as err:
+            BosonicBath(Q, [1.], [0.5], [2.], [])
+        assert str(err.value) == (
+            "The bath exponent lists ck_real and vk_real, and ck_imag and"
+            " vk_imag must be the same length."
+        )
+
+    def test_combine(self):
+        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
+        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
+        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
+        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_rx, exp_rx])
+        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_ix, exp_ix])
+        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_rix, exp_rix])
+        check_exponent(
+            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
+        )
+
+        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
+        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
+        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_rx, exp_ix])
+        check_exponent(
+            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
+        )
+
+        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
+        check_exponent(
+            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
+        )
+
+
+class TestDrudeLorentzBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_real = [0.05262168274189053, 0.0007958201977617107]
+        vk_real = [0.05, 6.613879270715354]
+        ck_imag = [-0.0012500000000000002]
+        vk_imag = [0.05]
+
+        bath = DrudeLorentzBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
+        )
+        [exp1, exp2] = bath.exponents
+        check_exponent(
+            exp1, "RI", dim=None, Q=Q,
+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+            tag="bath1",
+        )
+        check_exponent(
+            exp2, "R", dim=None, Q=Q,
+            ck=ck_real[1], vk=vk_real[1],
+            tag="bath1",
+        )
+
+        bath = DrudeLorentzBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
+        )
+        [exp1, exp2, exp3] = bath.exponents
+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+
+    @pytest.mark.parametrize(['combine'], [
+        pytest.param(True, id="combine"),
+        pytest.param(False, id="no-combine"),
+    ])
+    def test_terminator(self, combine):
+        Q = sigmaz()
+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+
+        bath = DrudeLorentzBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
+        )
+        delta, terminator = bath.terminator()
+
+        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
+        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
+
+
+class TestDrudeLorentzPadeBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_real = [0.05262168274189053, 0.0016138037466648136]
+        vk_real = [0.05, 8.153649149910352]
+        ck_imag = [-0.0012500000000000002]
+        vk_imag = [0.05]
+
+        bath = DrudeLorentzPadeBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
+        )
+        [exp1, exp2] = bath.exponents
+        check_exponent(
+            exp1, "RI", dim=None, Q=Q,
+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+            tag="bath1",
+        )
+        check_exponent(
+            exp2, "R", dim=None, Q=Q,
+            ck=ck_real[1], vk=vk_real[1],
+            tag="bath1",
+        )
+
+        bath = DrudeLorentzPadeBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
+        )
+        [exp1, exp2, exp3] = bath.exponents
+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+
+    @pytest.mark.parametrize(['combine'], [
+        pytest.param(True, id="combine"),
+        pytest.param(False, id="no-combine"),
+    ])
+    def test_terminator(self, combine):
+        Q = sigmaz()
+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+
+        bath = DrudeLorentzPadeBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
+        )
+        delta, terminator = bath.terminator()
+
+        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
+        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
+
+
+class TestUnderDampedBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_real = [
+            0.0003533235200322013-7.634500355085952e-06j,
+            0.0003533235200322013+7.634500355085952e-06j,
+            -2.173594134367819e-07+0j,
+        ]
+        vk_real = [
+            0.025-0.9996874511566103j,
+            0.025+0.9996874511566103j,
+            6.613879270715354,
+        ]
+        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
+        vk_imag = [
+            0.025-0.9996874511566103j,
+            0.025+0.9996874511566103j,
+        ]
+
+        bath = UnderDampedBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
+        )
+        [exp1, exp2, exp3] = bath.exponents
+        check_exponent(
+            exp1, "RI", dim=None, Q=Q,
+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+            tag="bath1",
+        )
+        check_exponent(
+            exp2, "RI", dim=None, Q=Q,
+            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
+            tag="bath1",
+        )
+        check_exponent(
+            exp3, "R", dim=None, Q=Q,
+            ck=ck_real[2], vk=vk_real[2],
+            tag="bath1",
+        )
+
+        bath = UnderDampedBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
+        )
+        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
+        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
+
+
+class TestFermionicBath:
+    def test_create(self):
+        Q = 1j * sigmaz()
+        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
+        exp_p, exp_m = bath.exponents
+        check_exponent(
+            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
+        )
+        check_exponent(
+            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
+        )
+
+        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
+        exp_p, exp_m = bath.exponents
+        check_exponent(
+            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
+            tag="bath1",
+        )
+        check_exponent(
+            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
+            tag="bath1",
+        )
+
+        with pytest.raises(ValueError) as err:
+            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
+        assert str(err.value) == "The coupling operator Q must be a Qobj."
+
+        with pytest.raises(ValueError) as err:
+            FermionicBath(Q, [1.], [], [2.], [0.6])
+        assert str(err.value) == (
+            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+            " vk_minus must be the same length."
+        )
+
+        with pytest.raises(ValueError) as err:
+            FermionicBath(Q, [1.], [0.5], [2.], [])
+        assert str(err.value) == (
+            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+            " vk_minus must be the same length."
+        )
+
+
+class TestLorentzianBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_plus = [
+            0.0025-0.0013376935246402686j,
+            -0.00026023645770006167j,
+            -0.0002748355116913478j,
+        ]
+        vk_plus = [
+            1+1j,
+            0.08121642500626945+1j,
+            0.24364927501880834+1j,
+        ]
+        ck_minus = [
+            0.0025-0.0013376935246402686j,
+            -0.00026023645770006167j,
+            -0.0002748355116913478j,
+        ]
+        vk_minus = [
+            1-1j,
+            0.08121642500626945-1j,
+            0.24364927501880834-1j,
+        ]
+
+        bath = LorentzianBath(
+            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
+        )
+        assert len(bath.exponents) == 6
+        for i in range(len(ck_plus)):
+            exp_p = bath.exponents[2 * i]
+            exp_m = bath.exponents[2 * i + 1]
+            check_exponent(
+                exp_p, "+", dim=2, Q=Q,
+                ck=ck_plus[i], vk=vk_plus[i],
+                sigma_bar_k_offset=1,
+                tag="bath1",
+            )
+            check_exponent(
+                exp_m, "-", dim=2, Q=Q,
+                ck=ck_minus[i], vk=vk_minus[i],
+                sigma_bar_k_offset=-1,
+                tag="bath1",
+            )
+
+
+class TestLorentzianPadeBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_plus = [
+            0.0025+0.0014269000277373958j,
+            -0.0002608459250597002j,
+            -0.0011660541026776957j,
+        ]
+        vk_plus = [
+            1+1j,
+            0.08123902308117874+1j,
+            0.3371925267385835+1j,
+        ]
+        ck_minus = [
+            0.0025+0.0014269000277373958j,
+            -0.0002608459250597002j,
+            -0.0011660541026776957j,
+        ]
+        vk_minus = [
+            1-1j,
+            0.08123902308117874-1j,
+            0.3371925267385835-1j,
+        ]
+
+        bath = LorentzianPadeBath(
+            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
+        )
+        assert len(bath.exponents) == 6
+        for i in range(len(ck_plus)):
+            exp_p = bath.exponents[2 * i]
+            exp_m = bath.exponents[2 * i + 1]
+            check_exponent(
+                exp_p, "+", dim=2, Q=Q,
+                ck=ck_plus[i], vk=vk_plus[i],
+                sigma_bar_k_offset=1,
+                tag="bath1",
+            )
+            check_exponent(
+                exp_m, "-", dim=2, Q=Q,
+                ck=ck_minus[i], vk=vk_minus[i],
+                sigma_bar_k_offset=-1,
+                tag="bath1",
+            )
diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index 72b737a91c..69935d0177 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -1,1396 +1,1396 @@
-"""
-Tests for qutip.nonmarkov.bofin_solvers.
-"""
-
-import numpy as np
-import pytest
-from numpy.linalg import eigvalsh
-from scipy.integrate import quad
-
-from qutip import (
-    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
-    tensor, Qobj, QobjEvo
-)
-from qutip.core import data as _data
-from qutip.solver.heom.bofin_baths import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-)
-from qutip.solver.heom.bofin_solvers import (
-    heomsolve,
-    HierarchyADOs,
-    HierarchyADOsState,
-    HEOMResult,
-    HEOMSolver,
-    HSolverDL,
-    _GatherHEOMRHS,
-)
-from qutip.solver import (
-    IntegratorException,
-)
-
-
-def fill_options(**kwargs):
-    """Fill the options with minimal entries needed by HEOMResult."""
-    return {
-        "store_final_state": False,
-        "store_states": None,
-        "store_ados": False,
-        **kwargs
-    }
-
-
-def assert_raises_steady_state_time_dependent(hsolver):
-    """ Assert that calling .steady_state() on a HEOMSolver with
-        a time-dependent Hamiltonian raises the appropriate exception.
-    """
-    with pytest.raises(ValueError) as err:
-        hsolver.steady_state()
-    assert str(err.value) == (
-       "A steady state cannot be determined for a time-dependent"
-       " system"
-    )
-
-
-class TestHierarchyADOs:
-    def mk_exponents(self, dims):
-        return [
-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
-        ]
-
-    def test_create(self):
-        exponents = self.mk_exponents([2, 3])
-        ados = HierarchyADOs(exponents, max_depth=2)
-
-        assert ados.exponents == exponents
-        assert ados.max_depth == 2
-
-        assert ados.dims == [2, 3]
-        assert ados.vk == [2.0, 2.0]
-        assert ados.ck == [1.0, 1.0]
-        assert ados.ck2 == [None, None]
-        assert ados.sigma_bar_k_offset == [None, None]
-
-        assert ados.labels == [
-            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
-        ]
-
-    def test_state_idx(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.idx((0, 0)) == 0
-        assert ados.idx((0, 1)) == 1
-        assert ados.idx((0, 2)) == 2
-        assert ados.idx((1, 0)) == 3
-        assert ados.idx((1, 1)) == 4
-
-    def test_next(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.next((0, 0), 0) == (1, 0)
-        assert ados.next((0, 0), 1) == (0, 1)
-        assert ados.next((1, 0), 0) is None
-        assert ados.next((1, 0), 1) == (1, 1)
-        assert ados.next((1, 1), 1) is None
-
-    def test_prev(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.prev((0, 0), 0) is None
-        assert ados.prev((0, 0), 1) is None
-        assert ados.prev((1, 0), 0) == (0, 0)
-        assert ados.prev((0, 1), 1) == (0, 0)
-        assert ados.prev((1, 1), 1) == (1, 0)
-        assert ados.prev((0, 2), 1) == (0, 1)
-
-    def test_exps(self):
-        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
-        assert ados.exps((0, 0, 0)) == ()
-        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
-        assert ados.exps((2, 0, 0)) == (
-            ados.exponents[0], ados.exponents[0],
-        )
-        assert ados.exps((1, 2, 1)) == (
-            ados.exponents[0],
-            ados.exponents[1], ados.exponents[1],
-            ados.exponents[2],
-        )
-
-    def test_filter_by_nothing(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.filter() == [
-            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
-        ]
-
-    def test_filter_by_level(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.filter(level=0) == [
-            (0, 0),
-        ]
-        assert ados.filter(level=1) == [
-            (0, 1),
-            (1, 0),
-        ]
-        assert ados.filter(level=2) == [
-            (0, 2),
-            (1, 1),
-        ]
-        assert ados.filter(level=3) == []
-
-    def test_filter_by_exponents(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.filter(dims=[]) == [
-            (0, 0),
-        ]
-        assert ados.filter(dims=[2]) == [
-            (1, 0),
-        ]
-        assert ados.filter(level=1, dims=[2]) == [
-            (1, 0),
-        ]
-        assert ados.filter(dims=[3]) == [
-            (0, 1),
-        ]
-        assert ados.filter(dims=[2, 3]) == [
-            (1, 1),
-        ]
-        assert ados.filter(level=2, dims=[2, 3]) == [
-            (1, 1),
-        ]
-        assert ados.filter(dims=[3, 3]) == [
-            (0, 2),
-        ]
-        assert ados.filter(types=["I"]) == [
-            (0, 1),
-            (1, 0),
-        ]
-        assert ados.filter(types=["I", "I"]) == [
-            (0, 2),
-            (1, 1),
-        ]
-
-        with pytest.raises(ValueError) as err:
-            ados.filter(types=[], dims=[2])
-        assert str(err.value) == (
-            "The tags, dims and types filters must all be the same length."
-        )
-
-        with pytest.raises(ValueError) as err:
-            ados.filter(dims=[2, 2, 2])
-        assert str(err.value) == (
-            "The maximum depth for the hierarchy is 2 but 3 levels of"
-            " excitation filters were given."
-        )
-
-        with pytest.raises(ValueError) as err:
-            ados.filter(level=0, dims=[2])
-        assert str(err.value) == (
-            "The level parameter is 0 but 1 levels of excitation filters"
-            " were given."
-        )
-
-
-class TestHierarchyADOsState:
-    def mk_ados(self, bath_dims, max_depth):
-        exponents = [
-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
-        ]
-        ados = HierarchyADOs(exponents, max_depth=max_depth)
-        return ados
-
-    def mk_rho_and_soln(self, ados, rho_dims):
-        n_ados = len(ados.labels)
-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
-        rho = Qobj(ado_soln[0, :], dims=rho_dims)
-        return rho, ado_soln
-
-    def test_create(self):
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-        assert ado_state.rho == rho
-        assert ado_state.labels == ados.labels
-        assert ado_state.exponents == ados.exponents
-        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
-        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
-
-    def test_extract(self):
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-        ado_state.extract((0, 0)) == rho
-        ado_state.extract(0) == rho
-        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
-        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
-
-
-class DrudeLorentzPureDephasingModel:
-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
-        solver.
-    """
-    def __init__(self, lam, gamma, T, Nk):
-        self.lam = lam
-        self.gamma = gamma
-        self.T = T
-        self.Nk = Nk
-        # we add a very weak system hamiltonian here to avoid having
-        # singular system that causes problems for the scipy.sparse.linalg
-        # superLU solver used in spsolve.
-        self.H = Qobj(1e-5 * np.ones((2, 2)))
-        self.Q = sigmaz()
-
-    def rho(self):
-        """ Initial state. """
-        return 0.5 * Qobj(np.ones((2, 2)))
-
-    def state_results(self, states):
-        projector = basis(2, 0) * basis(2, 1).dag()
-        return expect(states, projector)
-
-    def analytic_results(self, tlist):
-        lam, gamma, T = self.lam, self.gamma, self.T
-        lam_c = lam / np.pi
-
-        def _integrand(omega, t):
-            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
-            return (-4 * J * (1 - np.cos(omega*t))
-                    / (np.tanh(0.5*omega / T) * omega**2))
-
-        # Calculate the analytical results by numerical integration
-        return [
-            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-            for t in tlist
-        ]
-
-    def bath_coefficients(self):
-        """ Correlation function expansion coefficients for the Drude-Lorentz
-            bath.
-        """
-        lam, gamma, T = self.lam, self.gamma, self.T
-        Nk = self.Nk
-        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
-        ck_real.extend([
-            (4 * lam * gamma * T * 2 * np.pi * k * T /
-                ((2 * np.pi * k * T)**2 - gamma**2))
-            for k in range(1, Nk + 1)
-        ])
-        vk_real = [gamma]
-        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
-        ck_imag = [lam * gamma * (-1.0)]
-        vk_imag = [gamma]
-        return ck_real, vk_real, ck_imag, vk_imag
-
-
-class UnderdampedPureDephasingModel:
-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
-        solver.
-    """
-    def __init__(self, lam,  gamma, w0, T, Nk):
-        self.lam = lam
-        self.gamma = gamma
-        self.w0 = w0
-        self.T = T
-        self.Nk = Nk
-        # we add a very weak system hamiltonian here to avoid having
-        # singular system that causes problems for the scipy.sparse.linalg
-        # superLU solver used in spsolve.
-        self.H = Qobj(1e-5 * np.ones((2, 2)))
-        self.Q = sigmaz()
-
-    def rho(self):
-        """ Initial state. """
-        return 0.5 * Qobj(np.ones((2, 2)))
-
-    def state_results(self, states):
-        projector = basis(2, 0) * basis(2, 1).dag()
-        return expect(states, projector)
-
-    def analytic_results(self, tlist):
-        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
-        lam_c = lam**2 / np.pi
-
-        def _integrand(omega, t):
-            Jw = (
-                lam_c * omega * gamma /
-                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
-            )
-            return (-4 * Jw * (1 - np.cos(omega*t))
-                    / (np.tanh(0.5*omega / T) * omega**2))
-
-        return [
-            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-            for t in tlist
-        ]
-
-
-class BosonicMode:
-    """ A description of a bosonic mode for inclusion in a
-        DiscreteLevelCurrentModel.
-    """
-    def __init__(self, N, Lambda, Omega, gamma_b):
-        self.N = N
-        self.Lambda = Lambda
-        self.Omega = Omega
-        self.gamma_b = gamma_b
-
-    def bath_coefficients(self):
-        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
-        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
-
-        ck_imag = [
-            -1.0j * self.Omega + self.gamma_b / 2,
-            1.0j * self.Omega + self.gamma_b / 2,
-        ]
-        vk_imag = [
-            -1.0j * self.Omega + self.gamma_b / 2,
-            1.0j * self.Omega + self.gamma_b / 2,
-        ]
-        return ck_real, ck_imag, vk_real, vk_imag
-
-
-class DiscreteLevelCurrentModel:
-    """ Analytic discrete level current model for testing the HEOM solver
-        with a fermionic bath (and optionally a bosonic mode).
-    """
-    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
-        # single fermion
-        self.e1 = e1  # energy
-
-        # parameters for the fermionic leads
-        self.gamma = gamma
-        self.W = W
-        self.T = T
-        self.lmax = lmax  # Pade cut-off
-        self.beta = 1. / T
-        self.theta = theta  # bias
-
-        # bosonic_mode
-        self.bosonic_mode = bosonic_mode
-
-        # Construct Hamiltonian and coupling operator
-        if self.bosonic_mode is None:
-            d1 = destroy(2)
-            self.H = self.e1 * d1.dag() @ d1
-            self.Q = d1
-            self._sys_occupation_op = d1.dag() @ d1
-        else:
-            d1 = destroy(2) & qeye(self.bosonic_mode.N)
-            a = qeye(2) & destroy(self.bosonic_mode.N)
-            self.H = (
-                self.e1 * d1.dag() @ d1 +
-                self.bosonic_mode.Omega * a.dag() @ a +
-                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
-            )
-            if self.bosonic_mode.gamma_b != 0:
-                # apply phenomenological damping:
-                self.H = liouvillian(
-                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
-                )
-            self.Q = d1
-            self._sys_occupation_op = d1.dag() @ d1
-
-    def rho(self, rho_fermion=None):
-        """ Return initial system density matrix given the density matrix for
-            the single Fermionic mode.
-        """
-        if rho_fermion is None:
-            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
-        elif rho_fermion.isket:
-            rho_fermion = rho_fermion.proj()
-        if self.bosonic_mode is None:
-            rho = rho_fermion
-        else:
-            bm0 = basis(self.bosonic_mode.N, 0)
-            rho = rho_fermion & (bm0 @ bm0.dag())
-        return rho
-
-    def sys_occupation(self, state):
-        return expect(state, self._sys_occupation_op)
-
-    def state_current(self, ado_state, tags=None):
-        level_1_aux = [
-            (ado_state.extract(label), ado_state.exps(label)[0])
-            for label in ado_state.filter(level=1, tags=tags)
-        ]
-
-        def exp_sign(exp):
-            return 1 if exp.type == exp.types["+"] else -1
-
-        def exp_op(exp):
-            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
-
-        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
-        # and thus the first 2 * k exponents
-        k = self.lmax + 1
-        return 1.0j * sum(
-            exp_sign(exp) * (exp_op(exp) * aux).tr()
-            for aux, exp in level_1_aux[:2 * k]
-        )
-
-    def analytic_current(self):
-        if self.bosonic_mode is not None:
-            raise RuntimeError(
-                "Analytic calculation of the current is not implemented in the"
-                " case where a bosonic mode is present."
-            )
-
-        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
-        mu_l = self.theta / 2.
-        mu_r = - self.theta / 2.
-
-        def f(x):
-            return 1 / (np.exp(x) + 1.)
-
-        def Gamma_w(w, mu):
-            return Gamma * W**2 / ((w-mu)**2 + W**2)
-
-        def lamshift(w, mu):
-            return (w-mu)*Gamma_w(w, mu)/(2*W)
-
-        def integrand(w):
-            return (
-                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
-                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
-                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
-                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
-            )
-
-        def real_func(x):
-            return np.real(integrand(x))
-
-        def imag_func(x):
-            return np.imag(integrand(x))
-
-        # These integral bounds should be checked to be wide enough if the
-        # parameters are changed
-        a = -2
-        b = 2
-        real_integral = quad(real_func, a, b)
-        imag_integral = quad(imag_func, a, b)
-
-        return real_integral[0] + 1.0j * imag_integral[0]
-
-    def bath_coefficients(self):
-        """ Correlation function expansion coefficients for the fermionic bath.
-        """
-        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
-        mu_l = self.theta / 2.
-        mu_r = - self.theta / 2.
-
-        def deltafun(j, k):
-            return 1. if j == k else 0.
-
-        Alpha = np.zeros((2 * lmax, 2 * lmax))
-        for j in range(2*lmax):
-            for k in range(2*lmax):
-                Alpha[j][k] = (
-                    (deltafun(j, k + 1) + deltafun(j, k - 1))
-                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
-                )
-
-        eigvalsA = eigvalsh(Alpha)
-
-        eps = []
-        for val in eigvalsA[0:lmax]:
-            eps.append(-2 / val)
-
-        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
-        for j in range(2 * lmax - 1):
-            for k in range(2 * lmax - 1):
-                AlphaP[j][k] = (
-                    (deltafun(j, k + 1) + deltafun(j, k - 1))
-                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
-                )
-
-        eigvalsAP = eigvalsh(AlphaP)
-
-        chi = []
-        for val in eigvalsAP[0:lmax - 1]:
-            chi.append(-2/val)
-
-        eta_list = [
-            0.5 * lmax * (2 * (lmax + 1) - 1) * (
-                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
-                np.prod([
-                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
-                ])
-            )
-            for j in range(lmax)
-        ]
-
-        kappa = [0] + eta_list
-        epsilon = [0] + eps
-
-        def f_approx(x):
-            f = 0.5
-            for ll in range(1, lmax + 1):
-                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
-            return f
-
-        def C(sigma, mu):
-            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
-            gamma_0 = W - sigma*1.0j*mu
-            eta_list = [eta_0]
-            gamma_list = [gamma_0]
-            if lmax > 0:
-                for ll in range(1, lmax + 1):
-                    eta_list.append(
-                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
-                        / (-(epsilon[ll]**2 / beta**2) + W**2)
-                    )
-                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
-            return eta_list, gamma_list
-
-        etapL, gampL = C(1.0, mu_l)
-        etamL, gammL = C(-1.0, mu_l)
-
-        etapR, gampR = C(1.0, mu_r)
-        etamR, gammR = C(-1.0, mu_r)
-
-        ck_plus = etapR + etapL
-        vk_plus = gampR + gampL
-        ck_minus = etamR + etamL
-        vk_minus = gammR + gammL
-
-        return ck_plus, vk_plus, ck_minus, vk_minus
-
-
-_HAMILTONIAN_EVO_KINDS = {
-    "qobj": lambda H: H,
-    "qobjevo_const": lambda H: QobjEvo([H]),
-    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
-    "listevo_const": lambda H: [H],
-}
-
-
-def hamiltonian_to_sys(H, evo, liouvillianize):
-    if liouvillianize:
-        H = liouvillian(H)
-    H = _HAMILTONIAN_EVO_KINDS[evo](H)
-    return H
-
-
-class TestHEOMSolver:
-    def test_create_bosonic(self):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
-            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
-            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
-        ]
-        bath = Bath(exponents)
-
-        hsolver = HEOMSolver(H, bath, 2)
-        assert hsolver.ados.exponents == exponents
-        assert hsolver.ados.max_depth == 2
-
-        hsolver = HEOMSolver(H, [bath] * 3, 2)
-        assert hsolver.ados.exponents == exponents * 3
-        assert hsolver.ados.max_depth == 2
-
-    def test_create_fermionic(self):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
-            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
-        ]
-        bath = Bath(exponents)
-
-        hsolver = HEOMSolver(H, bath, 2)
-        assert hsolver.ados.exponents == exponents
-        assert hsolver.ados.max_depth == 2
-
-        hsolver = HEOMSolver(H, [bath] * 3, 2)
-        assert hsolver.ados.exponents == exponents * 3
-        assert hsolver.ados.max_depth == 2
-
-    def test_create_mixed_bosonic_and_fermionic(self):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
-            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
-            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
-        ]
-        bath = Bath(exponents)
-
-        hsolver = HEOMSolver(H, bath, 2)
-        assert hsolver.ados.exponents == exponents
-        assert hsolver.ados.max_depth == 2
-
-        hsolver = HEOMSolver(H, [bath] * 3, 2)
-        assert hsolver.ados.exponents == exponents * 3
-        assert hsolver.ados.max_depth == 2
-
-    def test_create_bath_errors(self):
-        Q = sigmaz()
-        H = sigmax()
-        mixed_q_dims = [
-            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
-            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
-        ]
-
-        with pytest.raises(ValueError) as err:
-            HEOMSolver(H, Bath(mixed_q_dims), 2)
-        assert str(err.value) == (
-            "All bath exponents must have system coupling operators with the"
-            " same dimensions but a mixture of dimensions was given."
-        )
-
-    def test_create_h_sys_errors(self):
-        H = object()
-        with pytest.raises(TypeError) as err:
-            HEOMSolver(H, Bath([]), 2)
-        assert str(err.value) == (
-            "The Hamiltonian (H) must be a Qobj or QobjEvo"
-        )
-
-        H = [sigmax()]
-        with pytest.raises(TypeError) as err:
-            HEOMSolver([H], Bath([]), 2)
-        assert str(err.value) == (
-            "The Hamiltonian (H) must be a Qobj or QobjEvo"
-        )
-
-    @pytest.mark.parametrize(['method'], [
-        pytest.param("run", id="run"),
-        pytest.param("start", id="start"),
-    ])
-    def test_invalid_rho0_errors(self, method):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
-            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
-            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
-        ]
-        bath = Bath(exponents)
-        hsolver = HEOMSolver(H, bath, 2)
-
-        if method == "run":
-            def solve_method(rho0):
-                return hsolver.run(rho0, [0, 1])
-        elif method == "start":
-            def solve_method(rho0):
-                return hsolver.start(rho0, 0)
-        else:
-            assert False, f"method {method} not supported by test"
-
-        with pytest.raises(ValueError) as err:
-            solve_method(basis(3, 0))
-        assert str(err.value) == (
-            "Initial state rho has dims [[3], [1]]"
-            " but the system dims are [[2], [2]]"
-        )
-
-        with pytest.raises(TypeError) as err:
-            solve_method("batman")
-        assert str(err.value) == (
-            "Initial ADOs passed have type <class 'str'> but a "
-            "HierarchyADOsState or a numpy array-like instance was expected"
-        )
-
-        with pytest.raises(ValueError) as err:
-            solve_method(np.array([1, 2, 3]))
-        assert str(err.value) == (
-            "Initial ADOs passed have shape (3,) but the solver hierarchy"
-            " shape is (10, 2, 2)"
-        )
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj", id="qobj"),
-        pytest.param("qobjevo_const", id="qobjevo_const"),
-        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_pure_dephasing_model_bosonic_bath(
-        self, evo, liouvillianize, atol=1e-3
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 15000, "store_states": True}
-        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(dlm.rho(), tlist)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            test = dlm.state_results([rho_final])
-            expected = dlm.analytic_results([100])
-            np.testing.assert_allclose(test, expected, atol=atol)
-            assert rho_final == ado_state.extract(0)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['terminator'], [
-        pytest.param(True, id="terminator"),
-        pytest.param(False, id="noterminator"),
-    ])
-    @pytest.mark.parametrize(['bath_cls'], [
-        pytest.param(DrudeLorentzBath, id="matsubara"),
-        pytest.param(DrudeLorentzPadeBath, id="pade"),
-    ])
-    def test_pure_dephasing_model_drude_lorentz_baths(
-        self, terminator, bath_cls, atol=1e-3
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        bath = bath_cls(
-            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
-        )
-        if terminator:
-            _, terminator_op = bath.terminator()
-            H_sys = liouvillian(dlm.H) + terminator_op
-        else:
-            H_sys = dlm.H
-
-        options = {"nsteps": 15000, "store_states": True}
-        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(dlm.rho(), tlist)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        rho_final, ado_state = hsolver.steady_state()
-        test = dlm.state_results([rho_final])
-        expected = dlm.analytic_results([100])
-        np.testing.assert_allclose(test, expected, atol=atol)
-        assert rho_final == ado_state.extract(0)
-
-    def test_underdamped_pure_dephasing_model_underdamped_bath(
-        self, atol=1e-3
-    ):
-        udm = UnderdampedPureDephasingModel(
-            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
-        )
-        bath = UnderDampedBath(
-            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
-            w0=udm.w0,
-        )
-
-        options = {"nsteps": 15000, "store_states": True}
-        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(udm.rho(), tlist)
-
-        test = udm.state_results(result.states)
-        expected = udm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        rho_final, ado_state = hsolver.steady_state()
-        test = udm.state_results([rho_final])
-        expected = udm.analytic_results([5000])
-        np.testing.assert_allclose(test, expected, atol=atol)
-        assert rho_final == ado_state.extract(0)
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj"),
-        pytest.param("qobjevo_const"),
-        pytest.param("qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.025851991, lmax=10,
-        )
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
-
-        options = {
-            "store_states": True,
-            "store_ados": True,
-            "nsteps": 15_000,
-            "rtol": 1e-7,
-            "atol": 1e-7,
-        }
-        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
-        # for a single impurity we converge with max_depth = 2
-        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
-
-        tlist = [0, 600]
-        result = hsolver.run(dlm.rho(), tlist)
-        current = dlm.state_current(result.ado_states[-1])
-        analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            current = dlm.state_current(ado_state)
-            analytic_current = dlm.analytic_current()
-            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
-        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
-        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
-    ])
-    def test_discrete_level_model_lorentzian_baths(
-        self, bath_cls, analytic_current, atol=1e-3
-    ):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.025851991, lmax=10,
-        )
-
-        options = {
-            "nsteps": 15_000, "store_states": True, "store_ados": True,
-            "rtol": 1e-7, "atol": 1e-7,
-        }
-        bath_l = bath_cls(
-            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
-            Nk=dlm.lmax,
-        )
-        bath_r = bath_cls(
-            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
-            Nk=dlm.lmax,
-        )
-        # for a single impurity we converge with max_depth = 2
-        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
-
-        tlist = [0, 600]
-        result = hsolver.run(dlm.rho(), tlist)
-        current = dlm.state_current(result.ado_states[-1])
-        # analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-        rho_final, ado_state = hsolver.steady_state()
-        current = dlm.state_current(ado_state)
-        # analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj"),
-        pytest.param("qobjevo_const"),
-        pytest.param("qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
-        self, evo, liouvillianize
-    ):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.025851991, lmax=10,
-        )
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
-
-        options = {
-            "store_states": True,
-            "store_ados": True,
-            "nsteps": 15_000,
-            "rtol": 1e-7,
-            "atol": 1e-7,
-        }
-        fermionic_bath = FermionicBath(
-            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
-        )
-        # very weak bosonic coupling which should not affect the dynamics of
-        # the interaction between the system and the fermionic bath:
-        eps = [1e-10] * 5
-        bosonic_Q = sigmax()
-        bosonic_bath = BosonicBath(
-            bosonic_Q, eps, eps, eps, eps, combine=False,
-        )
-        # for a single impurity we converge with max_depth = 2
-        # we specify the bosonic bath first to ensure that the test checks
-        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
-        # mode is before the fermionic ones
-        hsolver = HEOMSolver(
-            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
-        )
-
-        tlist = [0, 600]
-        result = hsolver.run(dlm.rho(), tlist)
-        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
-        analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            current = dlm.state_current(ado_state)
-            analytic_current = dlm.analytic_current()
-            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj"),
-        pytest.param("qobjevo_const"),
-        pytest.param("qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
-        self, evo, liouvillianize
-    ):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
-        )
-        bosonic_mode = BosonicMode(
-            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
-        )
-
-        dlm_ref = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
-            bosonic_mode=bosonic_mode,
-        )
-
-        options = {
-            "store_states": True,
-            "store_ados": True,
-            "nsteps": 15_000,
-            "rtol": 1e-7,
-            "atol": 1e-7,
-        }
-
-        # First we construct a solver with the boson modelled as part of the
-        # system and only a single Fermionic bath. This will provide the
-        # reference result for the test:
-        fermionic_bath_ref = FermionicBath(
-            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
-        )
-
-        hsolver_ref = HEOMSolver(
-            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
-        )
-
-        # Then we construct a solver for the same system, but with the
-        # bosonic mode as a bath This is the result we would like to check:
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        fermionic_bath = FermionicBath(
-            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
-        )
-
-        bosonic_bath = BosonicBath(
-            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
-            combine=True, tag="bosonic",
-        )
-
-        hsolver = HEOMSolver(
-            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
-        )
-
-        # Calculate currents and occupations:
-        tlist = np.linspace(0, 1000, 300)
-        psi0 = basis(2, 0)
-
-        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
-        current_ref = [
-            dlm_ref.state_current(ado_state, tags=["fermionic"])
-            for ado_state in result_ref.ado_states
-        ]
-        sys_occupation_ref = dlm_ref.sys_occupation(
-            result_ref.states
-        )
-
-        result = hsolver.run(dlm.rho(psi0), tlist)
-        current = [
-            dlm.state_current(ado_state, tags=["fermionic"])
-            for ado_state in result.ado_states
-        ]
-        sys_occupation = dlm.sys_occupation(result.states)
-
-        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
-        np.testing.assert_allclose(
-            sys_occupation_ref, sys_occupation, rtol=1e-3,
-        )
-
-        if evo != "qobjevo_timedep":
-            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
-            current_ss_ref = dlm_ref.state_current(ado_state_ref)
-            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
-
-            rho_final, ado_state = hsolver.steady_state()
-            current_ss = dlm.state_current(ado_state)
-            sys_occupation_ss = dlm.sys_occupation(rho_final)
-
-            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
-            np.testing.assert_allclose(
-                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
-            )
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['ado_format'], [
-        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
-        pytest.param("numpy", id="numpy"),
-    ])
-    def test_ado_input_and_return(self, ado_format):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {
-            "nsteps": 15_000, "store_states": True, "store_ados": True,
-        }
-        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
-
-        tlist_1 = [0, 1, 2]
-        result_1 = hsolver.run(dlm.rho(), tlist_1)
-
-        tlist_2 = [2, 3, 4]
-        rho0 = result_1.ado_states[-1]
-        if ado_format == "numpy":
-            rho0 = rho0._ado_state  # extract the raw numpy array
-        result_2 = hsolver.run(rho0, tlist_2)
-
-        tlist_full = tlist_1 + tlist_2[1:]
-        result_full = hsolver.run(dlm.rho(), tlist_full)
-
-        times_12 = result_1.times + result_2.times[1:]
-        times_full = result_full.times
-        assert times_12 == tlist_full
-        assert times_full == tlist_full
-
-        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
-        ado_states_full = result_full.ado_states
-        assert len(ado_states_12) == len(tlist_full)
-        assert len(ado_states_full) == len(tlist_full)
-        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
-            for label in hsolver.ados.labels:
-                np.testing.assert_allclose(
-                    ado_12.extract(label).full(),
-                    ado_full.extract(label).full(),
-                    atol=1e-6,
-                )
-
-        states_12 = result_1.states + result_2.states[1:]
-        states_full = result_full.states
-        assert len(states_12) == len(tlist_full)
-        assert len(states_full) == len(tlist_full)
-        for ado_12, state_12 in zip(ado_states_12, states_12):
-            assert ado_12.rho == state_12
-        for ado_full, state_full in zip(ado_states_full, states_full):
-            assert ado_full.rho == state_full
-
-        expected = dlm.analytic_results(tlist_full)
-        test_12 = dlm.state_results(states_12)
-        np.testing.assert_allclose(test_12, expected, atol=1e-3)
-        test_full = dlm.state_results(states_full)
-        np.testing.assert_allclose(test_full, expected, atol=1e-3)
-
-    def test_solving_with_step(self):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 15_000, "store_ados": True}
-        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        ado_state = None
-        states = [dlm.rho()]
-        hsolver.start(states[0], 0)
-        for t in tlist[1:]:
-            ado_state = hsolver.step(t)
-            states.append(ado_state.rho)
-
-        test = dlm.state_results(states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=1e-3)
-
-        assert states[-1] == ado_state.extract(0)
-
-
-class TestHeomsolveFunction:
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj", id="qobj"),
-        pytest.param("listevo_const", id="listevo_const"),
-        pytest.param("qobjevo_const", id="qobjevo_const"),
-        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_heomsolve_with_pure_dephasing_model(
-        self, evo, liouvillianize, atol=1e-3
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 15000, "store_states": True}
-
-        e_ops = {
-            "11": basis(2, 0) * basis(2, 0).dag(),
-            "22": basis(2, 1) * basis(2, 1).dag(),
-        }
-
-        tlist = np.linspace(0, 10, 21)
-        result = heomsolve(
-            H_sys, bath, 14, dlm.rho(), tlist,
-            e_ops=e_ops, args={"foo": 1}, options=options)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        for label in ["11", "22"]:
-            np.testing.assert_allclose(
-                result.e_data[label],
-                [expect(rho, e_ops[label]) for rho in result.states],
-                atol=atol,
-            )
-
-
-class TestHSolverDL:
-    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
-        pytest.param(True, 1e-4, id="bnd_cut_approx"),
-        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
-    ])
-    @pytest.mark.parametrize(['evo', 'combine'], [
-        pytest.param("qobj", True, id="qobj-combined"),
-        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
-        pytest.param("listevo_const", True, id="listevo-const-combined"),
-        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
-        pytest.param(
-            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
-        ),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_pure_dephasing_model(
-        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        options = {"nsteps": 15_000, "store_states": True}
-        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
-                            14, 2, dlm.gamma,
-                            bnd_cut_approx=bnd_cut_approx,
-                            options=options, combine=combine)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(dlm.rho(), tlist)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            test = dlm.state_results([rho_final])
-            expected = dlm.analytic_results([100])
-            np.testing.assert_allclose(test, expected, atol=atol)
-            assert rho_final == ado_state.extract(0)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
-        pytest.param(True, 1e-4, id="bnd_cut_approx"),
-        pytest.param(False, 1e-3, id="renorm"),
-    ])
-    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
-        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
-        # is repeated here to ensure the new HSolverDL remains compatibile
-        # with the old one until it is removed.
-        cut_frequency = 0.05
-        coupling_strength = 0.025
-        lam_c = coupling_strength / np.pi
-        temperature = 1 / 0.95
-        times = np.linspace(0, 10, 21)
-
-        def _integrand(omega, t):
-            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
-            return (-4 * J * (1 - np.cos(omega*t))
-                    / (np.tanh(0.5*omega / temperature) * omega**2))
-
-        # Calculate the analytical results by numerical integration
-        expected = [
-            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-            for t in times
-        ]
-
-        H_sys = Qobj(np.zeros((2, 2)))
-        Q = sigmaz()
-        initial_state = 0.5*Qobj(np.ones((2, 2)))
-        projector = basis(2, 0) * basis(2, 1).dag()
-        options = {"nsteps": 15_000, "store_states": True}
-        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
-                            20, 2, cut_frequency,
-                            bnd_cut_approx=bnd_cut_approx,
-                            options=options)
-        test = expect(hsolver.run(initial_state, times).states, projector)
-        np.testing.assert_allclose(test, expected, atol=tol)
-
-    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
-    def test_integration_error(self):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 10}
-        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
-
-        with pytest.raises(IntegratorException) as err:
-            hsolver.run(dlm.rho(), tlist=[0, 10])
-
-        assert str(err.value) == (
-            "Excess work done on this call. Try to increasing the nsteps"
-            " parameter in the Options class"
-        )
-
-
-class TestHEOMResult:
-    def mk_ados(self, bath_dims, max_depth):
-        exponents = [
-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
-        ]
-        ados = HierarchyADOs(exponents, max_depth=max_depth)
-        return ados
-
-    def mk_rho_and_soln(self, ados, rho_dims):
-        n_ados = len(ados.labels)
-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
-        rho = Qobj(ado_soln[0, :], dims=rho_dims)
-        return rho, ado_soln
-
-    def test_create_ado_states_attribute(self):
-        options = fill_options()
-        result = HEOMResult(e_ops=[], options=options)
-        assert not hasattr(result, "final_ado_state")
-        assert not hasattr(result, "ado_states")
-        assert result.store_ados is False
-
-        options = fill_options(store_ados=True)
-        result = HEOMResult(e_ops=[], options=options)
-        assert result.final_ado_state is None
-        assert result.ado_states == []
-        assert result.store_ados is True
-
-    @pytest.mark.parametrize(['e_op_type'], [
-        pytest.param("qobj", id="qobj"),
-        pytest.param("qobjevo", id="qobjevo"),
-        pytest.param("callable", id="callable"),
-    ])
-    def test_e_ops(self, e_op_type):
-        op = Qobj([[1, 0], [0, 0]])
-        if e_op_type == "qobj":
-            e_op = op
-        elif e_op_type == "qobjevo":
-            e_op = QobjEvo(op)
-        elif e_op_type == "callable":
-            def e_op(f, ado_state):
-                return expect(op, ado_state.rho)
-        else:
-            assert False, f"unknown e_op_type {e_op_type!r}"
-
-        options = fill_options()
-        result = HEOMResult(e_ops=e_op, options=options)
-
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        e_op_value = expect(op, rho)
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-
-        result.add(0.1, ado_state)
-
-        assert result.expect[0] == [e_op_value]
-        assert result.e_data[0] == [e_op_value]
-
-    def test_store_state(self):
-        options = fill_options()
-        result = HEOMResult(e_ops=[], options=options)
-
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-
-        result.add(0.1, ado_state)
-
-        assert result.times == [0.1]
-        assert result.states == [rho]
-        assert result.final_state is rho
-
-    def test_store_ados(self):
-        options = fill_options(store_ados=True)
-        result = HEOMResult(e_ops=[], options=options)
-
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-
-        result.add(0.1, ado_state)
-        assert result.times == [0.1]
-        assert result.states == [rho]
-        assert result.final_state is rho
-        assert result.ado_states == [ado_state]
-        assert result.final_ado_state is ado_state
-
-
-class Test_GatherHEOMRHS:
-    def test_simple_gather(self):
-        def f(label):
-            return int(label.lstrip("o"))
-
-        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
-
-        for i in range(3):
-            for j in range(3):
-                base = 10 * (j * 2) + (i * 2)
-                block_op = _data.to(
-                    _data.CSR,
-                    _data.create(np.array([
-                        [base, base + 10],
-                        [base + 1, base + 11],
-                    ]))
-                )
-                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
-
-        op = gather_heoms.gather()
-
-        expected_op = np.array([
-            [10 * i + j for i in range(2 * 3)]
-            for j in range(2 * 3)
-        ], dtype=np.complex128)
-
-        np.testing.assert_array_equal(op.to_array(), expected_op)
-        assert isinstance(op, _data.CSR)
+"""
+Tests for qutip.nonmarkov.bofin_solvers.
+"""
+
+import numpy as np
+import pytest
+from numpy.linalg import eigvalsh
+from scipy.integrate import quad
+
+from qutip import (
+    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
+    tensor, Qobj, QobjEvo
+)
+from qutip.core import data as _data
+from qutip.solver.heom.bofin_baths import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+)
+from qutip.solver.heom.bofin_solvers import (
+    heomsolve,
+    HierarchyADOs,
+    HierarchyADOsState,
+    HEOMResult,
+    HEOMSolver,
+    HSolverDL,
+    _GatherHEOMRHS,
+)
+from qutip.solver import (
+    IntegratorException,
+)
+
+
+def fill_options(**kwargs):
+    """Fill the options with minimal entries needed by HEOMResult."""
+    return {
+        "store_final_state": False,
+        "store_states": None,
+        "store_ados": False,
+        **kwargs
+    }
+
+
+def assert_raises_steady_state_time_dependent(hsolver):
+    """ Assert that calling .steady_state() on a HEOMSolver with
+        a time-dependent Hamiltonian raises the appropriate exception.
+    """
+    with pytest.raises(ValueError) as err:
+        hsolver.steady_state()
+    assert str(err.value) == (
+       "A steady state cannot be determined for a time-dependent"
+       " system"
+    )
+
+
+class TestHierarchyADOs:
+    def mk_exponents(self, dims):
+        return [
+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
+        ]
+
+    def test_create(self):
+        exponents = self.mk_exponents([2, 3])
+        ados = HierarchyADOs(exponents, max_depth=2)
+
+        assert ados.exponents == exponents
+        assert ados.max_depth == 2
+
+        assert ados.dims == [2, 3]
+        assert ados.vk == [2.0, 2.0]
+        assert ados.ck == [1.0, 1.0]
+        assert ados.ck2 == [None, None]
+        assert ados.sigma_bar_k_offset == [None, None]
+
+        assert ados.labels == [
+            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
+        ]
+
+    def test_state_idx(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.idx((0, 0)) == 0
+        assert ados.idx((0, 1)) == 1
+        assert ados.idx((0, 2)) == 2
+        assert ados.idx((1, 0)) == 3
+        assert ados.idx((1, 1)) == 4
+
+    def test_next(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.next((0, 0), 0) == (1, 0)
+        assert ados.next((0, 0), 1) == (0, 1)
+        assert ados.next((1, 0), 0) is None
+        assert ados.next((1, 0), 1) == (1, 1)
+        assert ados.next((1, 1), 1) is None
+
+    def test_prev(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.prev((0, 0), 0) is None
+        assert ados.prev((0, 0), 1) is None
+        assert ados.prev((1, 0), 0) == (0, 0)
+        assert ados.prev((0, 1), 1) == (0, 0)
+        assert ados.prev((1, 1), 1) == (1, 0)
+        assert ados.prev((0, 2), 1) == (0, 1)
+
+    def test_exps(self):
+        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
+        assert ados.exps((0, 0, 0)) == ()
+        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
+        assert ados.exps((2, 0, 0)) == (
+            ados.exponents[0], ados.exponents[0],
+        )
+        assert ados.exps((1, 2, 1)) == (
+            ados.exponents[0],
+            ados.exponents[1], ados.exponents[1],
+            ados.exponents[2],
+        )
+
+    def test_filter_by_nothing(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.filter() == [
+            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
+        ]
+
+    def test_filter_by_level(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.filter(level=0) == [
+            (0, 0),
+        ]
+        assert ados.filter(level=1) == [
+            (0, 1),
+            (1, 0),
+        ]
+        assert ados.filter(level=2) == [
+            (0, 2),
+            (1, 1),
+        ]
+        assert ados.filter(level=3) == []
+
+    def test_filter_by_exponents(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.filter(dims=[]) == [
+            (0, 0),
+        ]
+        assert ados.filter(dims=[2]) == [
+            (1, 0),
+        ]
+        assert ados.filter(level=1, dims=[2]) == [
+            (1, 0),
+        ]
+        assert ados.filter(dims=[3]) == [
+            (0, 1),
+        ]
+        assert ados.filter(dims=[2, 3]) == [
+            (1, 1),
+        ]
+        assert ados.filter(level=2, dims=[2, 3]) == [
+            (1, 1),
+        ]
+        assert ados.filter(dims=[3, 3]) == [
+            (0, 2),
+        ]
+        assert ados.filter(types=["I"]) == [
+            (0, 1),
+            (1, 0),
+        ]
+        assert ados.filter(types=["I", "I"]) == [
+            (0, 2),
+            (1, 1),
+        ]
+
+        with pytest.raises(ValueError) as err:
+            ados.filter(types=[], dims=[2])
+        assert str(err.value) == (
+            "The tags, dims and types filters must all be the same length."
+        )
+
+        with pytest.raises(ValueError) as err:
+            ados.filter(dims=[2, 2, 2])
+        assert str(err.value) == (
+            "The maximum depth for the hierarchy is 2 but 3 levels of"
+            " excitation filters were given."
+        )
+
+        with pytest.raises(ValueError) as err:
+            ados.filter(level=0, dims=[2])
+        assert str(err.value) == (
+            "The level parameter is 0 but 1 levels of excitation filters"
+            " were given."
+        )
+
+
+class TestHierarchyADOsState:
+    def mk_ados(self, bath_dims, max_depth):
+        exponents = [
+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
+        ]
+        ados = HierarchyADOs(exponents, max_depth=max_depth)
+        return ados
+
+    def mk_rho_and_soln(self, ados, rho_dims):
+        n_ados = len(ados.labels)
+        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+        rho = Qobj(ado_soln[0, :], dims=rho_dims)
+        return rho, ado_soln
+
+    def test_create(self):
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+        assert ado_state.rho == rho
+        assert ado_state.labels == ados.labels
+        assert ado_state.exponents == ados.exponents
+        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
+        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
+
+    def test_extract(self):
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+        ado_state.extract((0, 0)) == rho
+        ado_state.extract(0) == rho
+        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
+        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
+
+
+class DrudeLorentzPureDephasingModel:
+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+        solver.
+    """
+    def __init__(self, lam, gamma, T, Nk):
+        self.lam = lam
+        self.gamma = gamma
+        self.T = T
+        self.Nk = Nk
+        # we add a very weak system hamiltonian here to avoid having
+        # singular system that causes problems for the scipy.sparse.linalg
+        # superLU solver used in spsolve.
+        self.H = Qobj(1e-5 * np.ones((2, 2)))
+        self.Q = sigmaz()
+
+    def rho(self):
+        """ Initial state. """
+        return 0.5 * Qobj(np.ones((2, 2)))
+
+    def state_results(self, states):
+        projector = basis(2, 0) * basis(2, 1).dag()
+        return expect(states, projector)
+
+    def analytic_results(self, tlist):
+        lam, gamma, T = self.lam, self.gamma, self.T
+        lam_c = lam / np.pi
+
+        def _integrand(omega, t):
+            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
+            return (-4 * J * (1 - np.cos(omega*t))
+                    / (np.tanh(0.5*omega / T) * omega**2))
+
+        # Calculate the analytical results by numerical integration
+        return [
+            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+            for t in tlist
+        ]
+
+    def bath_coefficients(self):
+        """ Correlation function expansion coefficients for the Drude-Lorentz
+            bath.
+        """
+        lam, gamma, T = self.lam, self.gamma, self.T
+        Nk = self.Nk
+        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
+        ck_real.extend([
+            (4 * lam * gamma * T * 2 * np.pi * k * T /
+                ((2 * np.pi * k * T)**2 - gamma**2))
+            for k in range(1, Nk + 1)
+        ])
+        vk_real = [gamma]
+        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
+        ck_imag = [lam * gamma * (-1.0)]
+        vk_imag = [gamma]
+        return ck_real, vk_real, ck_imag, vk_imag
+
+
+class UnderdampedPureDephasingModel:
+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+        solver.
+    """
+    def __init__(self, lam,  gamma, w0, T, Nk):
+        self.lam = lam
+        self.gamma = gamma
+        self.w0 = w0
+        self.T = T
+        self.Nk = Nk
+        # we add a very weak system hamiltonian here to avoid having
+        # singular system that causes problems for the scipy.sparse.linalg
+        # superLU solver used in spsolve.
+        self.H = Qobj(1e-5 * np.ones((2, 2)))
+        self.Q = sigmaz()
+
+    def rho(self):
+        """ Initial state. """
+        return 0.5 * Qobj(np.ones((2, 2)))
+
+    def state_results(self, states):
+        projector = basis(2, 0) * basis(2, 1).dag()
+        return expect(states, projector)
+
+    def analytic_results(self, tlist):
+        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
+        lam_c = lam**2 / np.pi
+
+        def _integrand(omega, t):
+            Jw = (
+                lam_c * omega * gamma /
+                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
+            )
+            return (-4 * Jw * (1 - np.cos(omega*t))
+                    / (np.tanh(0.5*omega / T) * omega**2))
+
+        return [
+            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+            for t in tlist
+        ]
+
+
+class BosonicMode:
+    """ A description of a bosonic mode for inclusion in a
+        DiscreteLevelCurrentModel.
+    """
+    def __init__(self, N, Lambda, Omega, gamma_b):
+        self.N = N
+        self.Lambda = Lambda
+        self.Omega = Omega
+        self.gamma_b = gamma_b
+
+    def bath_coefficients(self):
+        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
+        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
+
+        ck_imag = [
+            -1.0j * self.Omega + self.gamma_b / 2,
+            1.0j * self.Omega + self.gamma_b / 2,
+        ]
+        vk_imag = [
+            -1.0j * self.Omega + self.gamma_b / 2,
+            1.0j * self.Omega + self.gamma_b / 2,
+        ]
+        return ck_real, ck_imag, vk_real, vk_imag
+
+
+class DiscreteLevelCurrentModel:
+    """ Analytic discrete level current model for testing the HEOM solver
+        with a fermionic bath (and optionally a bosonic mode).
+    """
+    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
+        # single fermion
+        self.e1 = e1  # energy
+
+        # parameters for the fermionic leads
+        self.gamma = gamma
+        self.W = W
+        self.T = T
+        self.lmax = lmax  # Pade cut-off
+        self.beta = 1. / T
+        self.theta = theta  # bias
+
+        # bosonic_mode
+        self.bosonic_mode = bosonic_mode
+
+        # Construct Hamiltonian and coupling operator
+        if self.bosonic_mode is None:
+            d1 = destroy(2)
+            self.H = self.e1 * d1.dag() @ d1
+            self.Q = d1
+            self._sys_occupation_op = d1.dag() @ d1
+        else:
+            d1 = destroy(2) & qeye(self.bosonic_mode.N)
+            a = qeye(2) & destroy(self.bosonic_mode.N)
+            self.H = (
+                self.e1 * d1.dag() @ d1 +
+                self.bosonic_mode.Omega * a.dag() @ a +
+                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
+            )
+            if self.bosonic_mode.gamma_b != 0:
+                # apply phenomenological damping:
+                self.H = liouvillian(
+                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
+                )
+            self.Q = d1
+            self._sys_occupation_op = d1.dag() @ d1
+
+    def rho(self, rho_fermion=None):
+        """ Return initial system density matrix given the density matrix for
+            the single Fermionic mode.
+        """
+        if rho_fermion is None:
+            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
+        elif rho_fermion.isket:
+            rho_fermion = rho_fermion.proj()
+        if self.bosonic_mode is None:
+            rho = rho_fermion
+        else:
+            bm0 = basis(self.bosonic_mode.N, 0)
+            rho = rho_fermion & (bm0 @ bm0.dag())
+        return rho
+
+    def sys_occupation(self, state):
+        return expect(state, self._sys_occupation_op)
+
+    def state_current(self, ado_state, tags=None):
+        level_1_aux = [
+            (ado_state.extract(label), ado_state.exps(label)[0])
+            for label in ado_state.filter(level=1, tags=tags)
+        ]
+
+        def exp_sign(exp):
+            return 1 if exp.type == exp.types["+"] else -1
+
+        def exp_op(exp):
+            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
+
+        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
+        # and thus the first 2 * k exponents
+        k = self.lmax + 1
+        return 1.0j * sum(
+            exp_sign(exp) * (exp_op(exp) * aux).tr()
+            for aux, exp in level_1_aux[:2 * k]
+        )
+
+    def analytic_current(self):
+        if self.bosonic_mode is not None:
+            raise RuntimeError(
+                "Analytic calculation of the current is not implemented in the"
+                " case where a bosonic mode is present."
+            )
+
+        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
+        mu_l = self.theta / 2.
+        mu_r = - self.theta / 2.
+
+        def f(x):
+            return 1 / (np.exp(x) + 1.)
+
+        def Gamma_w(w, mu):
+            return Gamma * W**2 / ((w-mu)**2 + W**2)
+
+        def lamshift(w, mu):
+            return (w-mu)*Gamma_w(w, mu)/(2*W)
+
+        def integrand(w):
+            return (
+                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
+                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
+                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
+                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
+            )
+
+        def real_func(x):
+            return np.real(integrand(x))
+
+        def imag_func(x):
+            return np.imag(integrand(x))
+
+        # These integral bounds should be checked to be wide enough if the
+        # parameters are changed
+        a = -2
+        b = 2
+        real_integral = quad(real_func, a, b)
+        imag_integral = quad(imag_func, a, b)
+
+        return real_integral[0] + 1.0j * imag_integral[0]
+
+    def bath_coefficients(self):
+        """ Correlation function expansion coefficients for the fermionic bath.
+        """
+        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
+        mu_l = self.theta / 2.
+        mu_r = - self.theta / 2.
+
+        def deltafun(j, k):
+            return 1. if j == k else 0.
+
+        Alpha = np.zeros((2 * lmax, 2 * lmax))
+        for j in range(2*lmax):
+            for k in range(2*lmax):
+                Alpha[j][k] = (
+                    (deltafun(j, k + 1) + deltafun(j, k - 1))
+                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
+                )
+
+        eigvalsA = eigvalsh(Alpha)
+
+        eps = []
+        for val in eigvalsA[0:lmax]:
+            eps.append(-2 / val)
+
+        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
+        for j in range(2 * lmax - 1):
+            for k in range(2 * lmax - 1):
+                AlphaP[j][k] = (
+                    (deltafun(j, k + 1) + deltafun(j, k - 1))
+                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
+                )
+
+        eigvalsAP = eigvalsh(AlphaP)
+
+        chi = []
+        for val in eigvalsAP[0:lmax - 1]:
+            chi.append(-2/val)
+
+        eta_list = [
+            0.5 * lmax * (2 * (lmax + 1) - 1) * (
+                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
+                np.prod([
+                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
+                ])
+            )
+            for j in range(lmax)
+        ]
+
+        kappa = [0] + eta_list
+        epsilon = [0] + eps
+
+        def f_approx(x):
+            f = 0.5
+            for ll in range(1, lmax + 1):
+                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
+            return f
+
+        def C(sigma, mu):
+            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
+            gamma_0 = W - sigma*1.0j*mu
+            eta_list = [eta_0]
+            gamma_list = [gamma_0]
+            if lmax > 0:
+                for ll in range(1, lmax + 1):
+                    eta_list.append(
+                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
+                        / (-(epsilon[ll]**2 / beta**2) + W**2)
+                    )
+                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
+            return eta_list, gamma_list
+
+        etapL, gampL = C(1.0, mu_l)
+        etamL, gammL = C(-1.0, mu_l)
+
+        etapR, gampR = C(1.0, mu_r)
+        etamR, gammR = C(-1.0, mu_r)
+
+        ck_plus = etapR + etapL
+        vk_plus = gampR + gampL
+        ck_minus = etamR + etamL
+        vk_minus = gammR + gammL
+
+        return ck_plus, vk_plus, ck_minus, vk_minus
+
+
+_HAMILTONIAN_EVO_KINDS = {
+    "qobj": lambda H: H,
+    "qobjevo_const": lambda H: QobjEvo([H]),
+    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
+    "listevo_const": lambda H: [H],
+}
+
+
+def hamiltonian_to_sys(H, evo, liouvillianize):
+    if liouvillianize:
+        H = liouvillian(H)
+    H = _HAMILTONIAN_EVO_KINDS[evo](H)
+    return H
+
+
+class TestHEOMSolver:
+    def test_create_bosonic(self):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
+            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
+            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
+        ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_fermionic(self):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
+            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
+        ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_mixed_bosonic_and_fermionic(self):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
+            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
+            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
+        ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_bath_errors(self):
+        Q = sigmaz()
+        H = sigmax()
+        mixed_q_dims = [
+            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
+            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
+        ]
+
+        with pytest.raises(ValueError) as err:
+            HEOMSolver(H, Bath(mixed_q_dims), 2)
+        assert str(err.value) == (
+            "All bath exponents must have system coupling operators with the"
+            " same dimensions but a mixture of dimensions was given."
+        )
+
+    def test_create_h_sys_errors(self):
+        H = object()
+        with pytest.raises(TypeError) as err:
+            HEOMSolver(H, Bath([]), 2)
+        assert str(err.value) == (
+            "The Hamiltonian (H) must be a Qobj or QobjEvo"
+        )
+
+        H = [sigmax()]
+        with pytest.raises(TypeError) as err:
+            HEOMSolver([H], Bath([]), 2)
+        assert str(err.value) == (
+            "The Hamiltonian (H) must be a Qobj or QobjEvo"
+        )
+
+    @pytest.mark.parametrize(['method'], [
+        pytest.param("run", id="run"),
+        pytest.param("start", id="start"),
+    ])
+    def test_invalid_rho0_errors(self, method):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
+            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
+            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
+        ]
+        bath = Bath(exponents)
+        hsolver = HEOMSolver(H, bath, 2)
+
+        if method == "run":
+            def solve_method(rho0):
+                return hsolver.run(rho0, [0, 1])
+        elif method == "start":
+            def solve_method(rho0):
+                return hsolver.start(rho0, 0)
+        else:
+            assert False, f"method {method} not supported by test"
+
+        with pytest.raises(ValueError) as err:
+            solve_method(basis(3, 0))
+        assert str(err.value) == (
+            "Initial state rho has dims [[3], [1]]"
+            " but the system dims are [[2], [2]]"
+        )
+
+        with pytest.raises(TypeError) as err:
+            solve_method("batman")
+        assert str(err.value) == (
+            "Initial ADOs passed have type <class 'str'> but a "
+            "HierarchyADOsState or a numpy array-like instance was expected"
+        )
+
+        with pytest.raises(ValueError) as err:
+            solve_method(np.array([1, 2, 3]))
+        assert str(err.value) == (
+            "Initial ADOs passed have shape (3,) but the solver hierarchy"
+            " shape is (10, 2, 2)"
+        )
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj", id="qobj"),
+        pytest.param("qobjevo_const", id="qobjevo_const"),
+        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_pure_dephasing_model_bosonic_bath(
+        self, evo, liouvillianize, atol=1e-3
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 15000, "store_states": True}
+        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(dlm.rho(), tlist)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            test = dlm.state_results([rho_final])
+            expected = dlm.analytic_results([100])
+            np.testing.assert_allclose(test, expected, atol=atol)
+            assert rho_final == ado_state.extract(0)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['terminator'], [
+        pytest.param(True, id="terminator"),
+        pytest.param(False, id="noterminator"),
+    ])
+    @pytest.mark.parametrize(['bath_cls'], [
+        pytest.param(DrudeLorentzBath, id="matsubara"),
+        pytest.param(DrudeLorentzPadeBath, id="pade"),
+    ])
+    def test_pure_dephasing_model_drude_lorentz_baths(
+        self, terminator, bath_cls, atol=1e-3
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        bath = bath_cls(
+            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
+        )
+        if terminator:
+            _, terminator_op = bath.terminator()
+            H_sys = liouvillian(dlm.H) + terminator_op
+        else:
+            H_sys = dlm.H
+
+        options = {"nsteps": 15000, "store_states": True}
+        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(dlm.rho(), tlist)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        rho_final, ado_state = hsolver.steady_state()
+        test = dlm.state_results([rho_final])
+        expected = dlm.analytic_results([100])
+        np.testing.assert_allclose(test, expected, atol=atol)
+        assert rho_final == ado_state.extract(0)
+
+    def test_underdamped_pure_dephasing_model_underdamped_bath(
+        self, atol=1e-3
+    ):
+        udm = UnderdampedPureDephasingModel(
+            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
+        )
+        bath = UnderDampedBath(
+            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
+            w0=udm.w0,
+        )
+
+        options = {"nsteps": 15000, "store_states": True}
+        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(udm.rho(), tlist)
+
+        test = udm.state_results(result.states)
+        expected = udm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        rho_final, ado_state = hsolver.steady_state()
+        test = udm.state_results([rho_final])
+        expected = udm.analytic_results([5000])
+        np.testing.assert_allclose(test, expected, atol=atol)
+        assert rho_final == ado_state.extract(0)
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
+        # for a single impurity we converge with max_depth = 2
+        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1])
+        analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            current = dlm.state_current(ado_state)
+            analytic_current = dlm.analytic_current()
+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
+        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
+        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
+    ])
+    def test_discrete_level_model_lorentzian_baths(
+        self, bath_cls, analytic_current, atol=1e-3
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+
+        options = {
+            "nsteps": 15_000, "store_states": True, "store_ados": True,
+            "rtol": 1e-7, "atol": 1e-7,
+        }
+        bath_l = bath_cls(
+            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
+            Nk=dlm.lmax,
+        )
+        bath_r = bath_cls(
+            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
+            Nk=dlm.lmax,
+        )
+        # for a single impurity we converge with max_depth = 2
+        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1])
+        # analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        rho_final, ado_state = hsolver.steady_state()
+        current = dlm.state_current(ado_state)
+        # analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
+        self, evo, liouvillianize
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+        fermionic_bath = FermionicBath(
+            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
+        )
+        # very weak bosonic coupling which should not affect the dynamics of
+        # the interaction between the system and the fermionic bath:
+        eps = [1e-10] * 5
+        bosonic_Q = sigmax()
+        bosonic_bath = BosonicBath(
+            bosonic_Q, eps, eps, eps, eps, combine=False,
+        )
+        # for a single impurity we converge with max_depth = 2
+        # we specify the bosonic bath first to ensure that the test checks
+        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
+        # mode is before the fermionic ones
+        hsolver = HEOMSolver(
+            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
+        )
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
+        analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            current = dlm.state_current(ado_state)
+            analytic_current = dlm.analytic_current()
+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
+        self, evo, liouvillianize
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+        )
+        bosonic_mode = BosonicMode(
+            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
+        )
+
+        dlm_ref = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+            bosonic_mode=bosonic_mode,
+        )
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+
+        # First we construct a solver with the boson modelled as part of the
+        # system and only a single Fermionic bath. This will provide the
+        # reference result for the test:
+        fermionic_bath_ref = FermionicBath(
+            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
+        )
+
+        hsolver_ref = HEOMSolver(
+            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
+        )
+
+        # Then we construct a solver for the same system, but with the
+        # bosonic mode as a bath This is the result we would like to check:
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        fermionic_bath = FermionicBath(
+            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
+        )
+
+        bosonic_bath = BosonicBath(
+            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
+            combine=True, tag="bosonic",
+        )
+
+        hsolver = HEOMSolver(
+            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
+        )
+
+        # Calculate currents and occupations:
+        tlist = np.linspace(0, 1000, 300)
+        psi0 = basis(2, 0)
+
+        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
+        current_ref = [
+            dlm_ref.state_current(ado_state, tags=["fermionic"])
+            for ado_state in result_ref.ado_states
+        ]
+        sys_occupation_ref = dlm_ref.sys_occupation(
+            result_ref.states
+        )
+
+        result = hsolver.run(dlm.rho(psi0), tlist)
+        current = [
+            dlm.state_current(ado_state, tags=["fermionic"])
+            for ado_state in result.ado_states
+        ]
+        sys_occupation = dlm.sys_occupation(result.states)
+
+        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
+        np.testing.assert_allclose(
+            sys_occupation_ref, sys_occupation, rtol=1e-3,
+        )
+
+        if evo != "qobjevo_timedep":
+            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
+            current_ss_ref = dlm_ref.state_current(ado_state_ref)
+            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
+
+            rho_final, ado_state = hsolver.steady_state()
+            current_ss = dlm.state_current(ado_state)
+            sys_occupation_ss = dlm.sys_occupation(rho_final)
+
+            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
+            np.testing.assert_allclose(
+                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
+            )
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['ado_format'], [
+        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
+        pytest.param("numpy", id="numpy"),
+    ])
+    def test_ado_input_and_return(self, ado_format):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {
+            "nsteps": 15_000, "store_states": True, "store_ados": True,
+        }
+        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
+
+        tlist_1 = [0, 1, 2]
+        result_1 = hsolver.run(dlm.rho(), tlist_1)
+
+        tlist_2 = [2, 3, 4]
+        rho0 = result_1.ado_states[-1]
+        if ado_format == "numpy":
+            rho0 = rho0._ado_state  # extract the raw numpy array
+        result_2 = hsolver.run(rho0, tlist_2)
+
+        tlist_full = tlist_1 + tlist_2[1:]
+        result_full = hsolver.run(dlm.rho(), tlist_full)
+
+        times_12 = result_1.times + result_2.times[1:]
+        times_full = result_full.times
+        assert times_12 == tlist_full
+        assert times_full == tlist_full
+
+        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
+        ado_states_full = result_full.ado_states
+        assert len(ado_states_12) == len(tlist_full)
+        assert len(ado_states_full) == len(tlist_full)
+        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
+            for label in hsolver.ados.labels:
+                np.testing.assert_allclose(
+                    ado_12.extract(label).full(),
+                    ado_full.extract(label).full(),
+                    atol=1e-6,
+                )
+
+        states_12 = result_1.states + result_2.states[1:]
+        states_full = result_full.states
+        assert len(states_12) == len(tlist_full)
+        assert len(states_full) == len(tlist_full)
+        for ado_12, state_12 in zip(ado_states_12, states_12):
+            assert ado_12.rho == state_12
+        for ado_full, state_full in zip(ado_states_full, states_full):
+            assert ado_full.rho == state_full
+
+        expected = dlm.analytic_results(tlist_full)
+        test_12 = dlm.state_results(states_12)
+        np.testing.assert_allclose(test_12, expected, atol=1e-3)
+        test_full = dlm.state_results(states_full)
+        np.testing.assert_allclose(test_full, expected, atol=1e-3)
+
+    def test_solving_with_step(self):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 15_000, "store_ados": True}
+        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        ado_state = None
+        states = [dlm.rho()]
+        hsolver.start(states[0], 0)
+        for t in tlist[1:]:
+            ado_state = hsolver.step(t)
+            states.append(ado_state.rho)
+
+        test = dlm.state_results(states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=1e-3)
+
+        assert states[-1] == ado_state.extract(0)
+
+
+class TestHeomsolveFunction:
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj", id="qobj"),
+        pytest.param("listevo_const", id="listevo_const"),
+        pytest.param("qobjevo_const", id="qobjevo_const"),
+        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_heomsolve_with_pure_dephasing_model(
+        self, evo, liouvillianize, atol=1e-3
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 15000, "store_states": True}
+
+        e_ops = {
+            "11": basis(2, 0) * basis(2, 0).dag(),
+            "22": basis(2, 1) * basis(2, 1).dag(),
+        }
+
+        tlist = np.linspace(0, 10, 21)
+        result = heomsolve(
+            H_sys, bath, 14, dlm.rho(), tlist,
+            e_ops=e_ops, args={"foo": 1}, options=options)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        for label in ["11", "22"]:
+            np.testing.assert_allclose(
+                result.e_data[label],
+                [expect(rho, e_ops[label]) for rho in result.states],
+                atol=atol,
+            )
+
+
+class TestHSolverDL:
+    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
+        pytest.param(True, 1e-4, id="bnd_cut_approx"),
+        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
+    ])
+    @pytest.mark.parametrize(['evo', 'combine'], [
+        pytest.param("qobj", True, id="qobj-combined"),
+        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
+        pytest.param("listevo_const", True, id="listevo-const-combined"),
+        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
+        pytest.param(
+            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
+        ),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_pure_dephasing_model(
+        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        options = {"nsteps": 15_000, "store_states": True}
+        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
+                            14, 2, dlm.gamma,
+                            bnd_cut_approx=bnd_cut_approx,
+                            options=options, combine=combine)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(dlm.rho(), tlist)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            test = dlm.state_results([rho_final])
+            expected = dlm.analytic_results([100])
+            np.testing.assert_allclose(test, expected, atol=atol)
+            assert rho_final == ado_state.extract(0)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
+        pytest.param(True, 1e-4, id="bnd_cut_approx"),
+        pytest.param(False, 1e-3, id="renorm"),
+    ])
+    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
+        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
+        # is repeated here to ensure the new HSolverDL remains compatibile
+        # with the old one until it is removed.
+        cut_frequency = 0.05
+        coupling_strength = 0.025
+        lam_c = coupling_strength / np.pi
+        temperature = 1 / 0.95
+        times = np.linspace(0, 10, 21)
+
+        def _integrand(omega, t):
+            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
+            return (-4 * J * (1 - np.cos(omega*t))
+                    / (np.tanh(0.5*omega / temperature) * omega**2))
+
+        # Calculate the analytical results by numerical integration
+        expected = [
+            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+            for t in times
+        ]
+
+        H_sys = Qobj(np.zeros((2, 2)))
+        Q = sigmaz()
+        initial_state = 0.5*Qobj(np.ones((2, 2)))
+        projector = basis(2, 0) * basis(2, 1).dag()
+        options = {"nsteps": 15_000, "store_states": True}
+        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
+                            20, 2, cut_frequency,
+                            bnd_cut_approx=bnd_cut_approx,
+                            options=options)
+        test = expect(hsolver.run(initial_state, times).states, projector)
+        np.testing.assert_allclose(test, expected, atol=tol)
+
+    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
+    def test_integration_error(self):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 10}
+        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
+
+        with pytest.raises(IntegratorException) as err:
+            hsolver.run(dlm.rho(), tlist=[0, 10])
+
+        assert str(err.value) == (
+            "Excess work done on this call. Try to increasing the nsteps"
+            " parameter in the Options class"
+        )
+
+
+class TestHEOMResult:
+    def mk_ados(self, bath_dims, max_depth):
+        exponents = [
+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
+        ]
+        ados = HierarchyADOs(exponents, max_depth=max_depth)
+        return ados
+
+    def mk_rho_and_soln(self, ados, rho_dims):
+        n_ados = len(ados.labels)
+        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+        rho = Qobj(ado_soln[0, :], dims=rho_dims)
+        return rho, ado_soln
+
+    def test_create_ado_states_attribute(self):
+        options = fill_options()
+        result = HEOMResult(e_ops=[], options=options)
+        assert not hasattr(result, "final_ado_state")
+        assert not hasattr(result, "ado_states")
+        assert result.store_ados is False
+
+        options = fill_options(store_ados=True)
+        result = HEOMResult(e_ops=[], options=options)
+        assert result.final_ado_state is None
+        assert result.ado_states == []
+        assert result.store_ados is True
+
+    @pytest.mark.parametrize(['e_op_type'], [
+        pytest.param("qobj", id="qobj"),
+        pytest.param("qobjevo", id="qobjevo"),
+        pytest.param("callable", id="callable"),
+    ])
+    def test_e_ops(self, e_op_type):
+        op = Qobj([[1, 0], [0, 0]])
+        if e_op_type == "qobj":
+            e_op = op
+        elif e_op_type == "qobjevo":
+            e_op = QobjEvo(op)
+        elif e_op_type == "callable":
+            def e_op(f, ado_state):
+                return expect(op, ado_state.rho)
+        else:
+            assert False, f"unknown e_op_type {e_op_type!r}"
+
+        options = fill_options()
+        result = HEOMResult(e_ops=e_op, options=options)
+
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        e_op_value = expect(op, rho)
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+
+        result.add(0.1, ado_state)
+
+        assert result.expect[0] == [e_op_value]
+        assert result.e_data[0] == [e_op_value]
+
+    def test_store_state(self):
+        options = fill_options()
+        result = HEOMResult(e_ops=[], options=options)
+
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+
+        result.add(0.1, ado_state)
+
+        assert result.times == [0.1]
+        assert result.states == [rho]
+        assert result.final_state is rho
+
+    def test_store_ados(self):
+        options = fill_options(store_ados=True)
+        result = HEOMResult(e_ops=[], options=options)
+
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+
+        result.add(0.1, ado_state)
+        assert result.times == [0.1]
+        assert result.states == [rho]
+        assert result.final_state is rho
+        assert result.ado_states == [ado_state]
+        assert result.final_ado_state is ado_state
+
+
+class Test_GatherHEOMRHS:
+    def test_simple_gather(self):
+        def f(label):
+            return int(label.lstrip("o"))
+
+        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
+
+        for i in range(3):
+            for j in range(3):
+                base = 10 * (j * 2) + (i * 2)
+                block_op = _data.to(
+                    _data.CSR,
+                    _data.create(np.array([
+                        [base, base + 10],
+                        [base + 1, base + 11],
+                    ]))
+                )
+                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
+
+        op = gather_heoms.gather()
+
+        expected_op = np.array([
+            [10 * i + j for i in range(2 * 3)]
+            for j in range(2 * 3)
+        ], dtype=np.complex128)
+
+        np.testing.assert_array_equal(op.to_array(), expected_op)
+        assert isinstance(op, _data.CSR)
diff --git a/qutip/tests/solver/heom/test_heom.py b/qutip/tests/solver/heom/test_heom.py
index c8988a168a..ad5680b6bf 100644
--- a/qutip/tests/solver/heom/test_heom.py
+++ b/qutip/tests/solver/heom/test_heom.py
@@ -1,46 +1,46 @@
-"""
-Tests for qutip.nonmarkov.heom.
-"""
-
-import pytest
-from qutip.solver.heom import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-    heomsolve,
-    HEOMSolver,
-    HEOMResult,
-    HSolverDL,
-    HierarchyADOs,
-    HierarchyADOsState,
-)
-
-class TestBathAPI:
-    def test_api(self):
-        # just assert that the baths are importable
-        assert BathExponent
-        assert Bath
-        assert BosonicBath
-        assert DrudeLorentzBath
-        assert DrudeLorentzPadeBath
-        assert UnderDampedBath
-        assert FermionicBath
-        assert LorentzianBath
-        assert LorentzianPadeBath
-
-
-class TestSolverAPI:
-    def test_api(self):
-        # just assert that the solvers and associated classes are importable
-        assert heomsolve
-        assert HEOMSolver
-        assert HEOMResult
-        assert HSolverDL
-        assert HierarchyADOs
-        assert HierarchyADOsState
+"""
+Tests for qutip.nonmarkov.heom.
+"""
+
+import pytest
+from qutip.solver.heom import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+    heomsolve,
+    HEOMSolver,
+    HEOMResult,
+    HSolverDL,
+    HierarchyADOs,
+    HierarchyADOsState,
+)
+
+class TestBathAPI:
+    def test_api(self):
+        # just assert that the baths are importable
+        assert BathExponent
+        assert Bath
+        assert BosonicBath
+        assert DrudeLorentzBath
+        assert DrudeLorentzPadeBath
+        assert UnderDampedBath
+        assert FermionicBath
+        assert LorentzianBath
+        assert LorentzianPadeBath
+
+
+class TestSolverAPI:
+    def test_api(self):
+        # just assert that the solvers and associated classes are importable
+        assert heomsolve
+        assert HEOMSolver
+        assert HEOMResult
+        assert HSolverDL
+        assert HierarchyADOs
+        assert HierarchyADOsState
diff --git a/qutip/tests/solver/test_brmesolve.py b/qutip/tests/solver/test_brmesolve.py
index 7b1aef0663..bc5b4c6dfb 100644
--- a/qutip/tests/solver/test_brmesolve.py
+++ b/qutip/tests/solver/test_brmesolve.py
@@ -1,296 +1,296 @@
-import pytest
-import numpy as np
-import qutip
-from qutip.solver.brmesolve import brmesolve
-
-
-def pauli_spin_operators():
-    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-
-
-_simple_qubit_gamma = 0.25
-coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
-                          args={'w':0})
-_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
-_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
-_x_a_op = [qutip.sigmax(), coeff]
-
-
-@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
-    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
-    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
-    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
-                 id="me collapse-br collapse-br coupling"),
-])
-def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
-    """
-    Test that the BR solver handles collapse and coupling operators correctly
-    relative to the standard ME solver.
-    """
-    delta = 0.0
-    epsilon = 0.5 * 2 * np.pi
-    e_ops = pauli_spin_operators()
-    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
-    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-    times = np.linspace(0, 10, 100)
-    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
-    opt = {"tensor_type": "dense"}
-    brme = brmesolve(
-        H, psi0, times,
-        a_ops=brme_a_ops, c_ops=brme_c_ops,
-        e_ops=e_ops, options=opt
-    )
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
-
-
-def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
-    if n_th == 0:
-        return lambda w: kappa * (w >= 0)
-
-    w_th = w0 / np.log(1 + 1/n_th)
-
-    def f(t, w):
-        scale = np.exp(w / w_th) if w < 0 else 1
-        return (n_th + 1) * kappa * scale
-    return f
-
-
-def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
-    a = qutip.destroy(dimension)
-    if n_th == 0:
-        return [np.sqrt(kappa) * a]
-    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
-
-
-@pytest.mark.parametrize("n_th", [0, 0.15])
-def test_harmonic_oscillator(n_th):
-    N = 10
-    w0 = 1.0 * 2*np.pi
-    g = 0.05 * w0
-    kappa = 0.15
-    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
-
-    a = qutip.destroy(N)
-    H = w0*a.dag()*a + g*(a+a.dag())
-    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
-    psi0 = qutip.ket2dm(psi0)
-    times = np.linspace(0, 20, 1000)
-
-    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
-    a_ops = [[a + a.dag(), S_w]]
-    e_ops = [a.dag()*a, a+a.dag()]
-
-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
-
-    num = qutip.num(N)
-    me_num = qutip.expect(num, me.states)
-    brme_num = qutip.expect(num, brme.states)
-    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
-
-
-def test_jaynes_cummings_zero_temperature_spectral_callable():
-    """
-    brmesolve: Jaynes-Cummings model, zero temperature
-    """
-    N = 10
-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
-    kappa = 0.05
-    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
-    e_ops = [a.dag()*a, sp.dag()*sp]
-
-    w0 = 1.0 * 2*np.pi
-    g = 0.05 * 2*np.pi
-    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
-
-    c_ops = [np.sqrt(kappa) * a]
-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-
-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        # Accept 5% error.
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
-
-
-def test_tensor_system():
-    """
-    brmesolve: Check for #572 bug.
-    """
-    w1, w2, w3 = 1, 2, 3
-    gamma2, gamma3 = 0.1, 0.1
-    id2 = qutip.qeye(2)
-
-    # Hamiltonian for three uncoupled qubits
-    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
-         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
-         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
-
-    # White noise
-    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
-    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
-
-    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
-    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
-
-    # Initial state : first qubit is excited
-    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
-    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
-    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
-
-    # Projector on the excited state of qubit 1
-    proj_up1 = qutip.tensor(exc2, id2, id2)
-    times = np.linspace(0, 10./gamma3, 1000)
-
-    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
-                    e_ops=[proj_up1]).expect[0]
-
-    np.testing.assert_allclose(sol, np.ones_like(times))
-
-
-def test_solver_accepts_list_hamiltonian():
-    """
-    brmesolve: input list of Qobj
-    """
-    delta = 0.0 * 2 * np.pi
-    epsilon = 0.5 * 2 * np.pi
-    gamma = 0.25
-    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
-    e_ops = pauli_spin_operators()
-    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
-    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-    times = np.linspace(0, 10, 100)
-    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
-    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
-    for me_expectation, brme_expectation in zip(me, brme):
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
-
-
-def test_jaynes_cummings_zero_temperature_spectral_str():
-    N = 10
-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
-    kappa = 0.05
-    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
-    e_ops = [a.dag()*a, sp.dag()*sp]
-
-    w0 = 1.0 * 2*np.pi
-    g = 0.05 * 2*np.pi
-    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
-
-    c_ops = [np.sqrt(kappa) * a]
-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-
-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        # Accept 5% error.
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
-
-
-def _mixed_string(kappa, _):
-    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
-
-
-def _separate_strings(kappa, _):
-    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
-
-
-def _string_w_interpolating_t(kappa, times):
-    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
-    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
-
-
-@pytest.mark.slow
-@pytest.mark.parametrize("time_dependence_tuple", [
-        _mixed_string,
-        _separate_strings,
-        _string_w_interpolating_t,
-    ])
-def test_time_dependence_tuples(time_dependence_tuple):
-    N = 10
-    a = qutip.destroy(N)
-    H = a.dag()*a
-    psi0 = qutip.basis(N, 9)
-    times = np.linspace(0, 10, 100)
-    kappa = 0.2
-    spectra, coeff = time_dependence_tuple(kappa, times)
-    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
-    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
-    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
-    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
-
-
-def test_time_dependent_spline_in_c_ops():
-    N = 10
-    a = qutip.destroy(N)
-    H = a.dag()*a
-    psi0 = qutip.basis(N, 9)
-    times = np.linspace(0, 10, 100)
-    kappa = 0.2
-    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
-    spectra, coeff = _string_w_interpolating_t(kappa, times)
-    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
-    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
-    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
-    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
-    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
-
-
-@pytest.mark.slow
-def test_nonhermitian_e_ops():
-    N = 5
-    a = qutip.destroy(N)
-    coefficient = np.random.random() + 1j*np.random.random()
-    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
-    H_brme = [[H, '1']]
-    psi0 = qutip.basis(N, 2)
-    times = np.linspace(0, 10, 10)
-    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
-    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
-    np.testing.assert_allclose(me, brme, atol=1e-4)
-
-
-@pytest.mark.slow
-def test_result_states():
-    N = 5
-    a = qutip.destroy(N)
-    coefficient = np.random.random() + 1j*np.random.random()
-    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
-    H_brme = [[H, '1']]
-    psi0 = qutip.fock_dm(N, 2)
-    times = np.linspace(0, 10, 10)
-    me = qutip.mesolve(H, psi0, times).states
-    brme = brmesolve(H_brme, psi0, times).states
-    assert max(np.abs((me_state - brme_state).full()).max()
-               for me_state, brme_state in zip(me, brme)) < 1e-5
-
-
-@pytest.mark.slow
-def test_hamiltonian_taking_arguments():
-    N = 10
-    w0 = 1.0 * 2*np.pi
-    g = 0.75 * 2*np.pi
-    kappa = 0.05
-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
-    psi0 = qutip.ket2dm(psi0)
-    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
-
-    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
-    e_ops = [a.dag()*a, sp.dag()*sp]
-
-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-    args = {'ii': 1}
-
-    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
-    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
-    for arg, no_arg in zip(args.expect, no_args.expect):
-        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
+import pytest
+import numpy as np
+import qutip
+from qutip.solver.brmesolve import brmesolve
+
+
+def pauli_spin_operators():
+    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+
+
+_simple_qubit_gamma = 0.25
+coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
+                          args={'w':0})
+_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
+_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
+_x_a_op = [qutip.sigmax(), coeff]
+
+
+@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
+    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
+    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
+    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
+                 id="me collapse-br collapse-br coupling"),
+])
+def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
+    """
+    Test that the BR solver handles collapse and coupling operators correctly
+    relative to the standard ME solver.
+    """
+    delta = 0.0
+    epsilon = 0.5 * 2 * np.pi
+    e_ops = pauli_spin_operators()
+    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
+    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    times = np.linspace(0, 10, 100)
+    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
+    opt = {"tensor_type": "dense"}
+    brme = brmesolve(
+        H, psi0, times,
+        a_ops=brme_a_ops, c_ops=brme_c_ops,
+        e_ops=e_ops, options=opt
+    )
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
+
+
+def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
+    if n_th == 0:
+        return lambda w: kappa * (w >= 0)
+
+    w_th = w0 / np.log(1 + 1/n_th)
+
+    def f(t, w):
+        scale = np.exp(w / w_th) if w < 0 else 1
+        return (n_th + 1) * kappa * scale
+    return f
+
+
+def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
+    a = qutip.destroy(dimension)
+    if n_th == 0:
+        return [np.sqrt(kappa) * a]
+    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
+
+
+@pytest.mark.parametrize("n_th", [0, 0.15])
+def test_harmonic_oscillator(n_th):
+    N = 10
+    w0 = 1.0 * 2*np.pi
+    g = 0.05 * w0
+    kappa = 0.15
+    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
+
+    a = qutip.destroy(N)
+    H = w0*a.dag()*a + g*(a+a.dag())
+    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
+    psi0 = qutip.ket2dm(psi0)
+    times = np.linspace(0, 20, 1000)
+
+    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
+    a_ops = [[a + a.dag(), S_w]]
+    e_ops = [a.dag()*a, a+a.dag()]
+
+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
+
+    num = qutip.num(N)
+    me_num = qutip.expect(num, me.states)
+    brme_num = qutip.expect(num, brme.states)
+    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
+
+
+def test_jaynes_cummings_zero_temperature_spectral_callable():
+    """
+    brmesolve: Jaynes-Cummings model, zero temperature
+    """
+    N = 10
+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
+    kappa = 0.05
+    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
+    e_ops = [a.dag()*a, sp.dag()*sp]
+
+    w0 = 1.0 * 2*np.pi
+    g = 0.05 * 2*np.pi
+    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
+
+    c_ops = [np.sqrt(kappa) * a]
+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+
+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        # Accept 5% error.
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
+
+
+def test_tensor_system():
+    """
+    brmesolve: Check for #572 bug.
+    """
+    w1, w2, w3 = 1, 2, 3
+    gamma2, gamma3 = 0.1, 0.1
+    id2 = qutip.qeye(2)
+
+    # Hamiltonian for three uncoupled qubits
+    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
+         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
+         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
+
+    # White noise
+    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
+    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
+
+    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
+    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
+
+    # Initial state : first qubit is excited
+    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
+    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
+    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
+
+    # Projector on the excited state of qubit 1
+    proj_up1 = qutip.tensor(exc2, id2, id2)
+    times = np.linspace(0, 10./gamma3, 1000)
+
+    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
+                    e_ops=[proj_up1]).expect[0]
+
+    np.testing.assert_allclose(sol, np.ones_like(times))
+
+
+def test_solver_accepts_list_hamiltonian():
+    """
+    brmesolve: input list of Qobj
+    """
+    delta = 0.0 * 2 * np.pi
+    epsilon = 0.5 * 2 * np.pi
+    gamma = 0.25
+    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
+    e_ops = pauli_spin_operators()
+    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
+    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    times = np.linspace(0, 10, 100)
+    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
+    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
+    for me_expectation, brme_expectation in zip(me, brme):
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
+
+
+def test_jaynes_cummings_zero_temperature_spectral_str():
+    N = 10
+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
+    kappa = 0.05
+    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
+    e_ops = [a.dag()*a, sp.dag()*sp]
+
+    w0 = 1.0 * 2*np.pi
+    g = 0.05 * 2*np.pi
+    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
+
+    c_ops = [np.sqrt(kappa) * a]
+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+
+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        # Accept 5% error.
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
+
+
+def _mixed_string(kappa, _):
+    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
+
+
+def _separate_strings(kappa, _):
+    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
+
+
+def _string_w_interpolating_t(kappa, times):
+    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
+    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("time_dependence_tuple", [
+        _mixed_string,
+        _separate_strings,
+        _string_w_interpolating_t,
+    ])
+def test_time_dependence_tuples(time_dependence_tuple):
+    N = 10
+    a = qutip.destroy(N)
+    H = a.dag()*a
+    psi0 = qutip.basis(N, 9)
+    times = np.linspace(0, 10, 100)
+    kappa = 0.2
+    spectra, coeff = time_dependence_tuple(kappa, times)
+    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
+    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
+    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
+    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
+
+
+def test_time_dependent_spline_in_c_ops():
+    N = 10
+    a = qutip.destroy(N)
+    H = a.dag()*a
+    psi0 = qutip.basis(N, 9)
+    times = np.linspace(0, 10, 100)
+    kappa = 0.2
+    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
+    spectra, coeff = _string_w_interpolating_t(kappa, times)
+    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
+    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
+    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
+    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
+    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
+
+
+@pytest.mark.slow
+def test_nonhermitian_e_ops():
+    N = 5
+    a = qutip.destroy(N)
+    coefficient = np.random.random() + 1j*np.random.random()
+    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
+    H_brme = [[H, '1']]
+    psi0 = qutip.basis(N, 2)
+    times = np.linspace(0, 10, 10)
+    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
+    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
+    np.testing.assert_allclose(me, brme, atol=1e-4)
+
+
+@pytest.mark.slow
+def test_result_states():
+    N = 5
+    a = qutip.destroy(N)
+    coefficient = np.random.random() + 1j*np.random.random()
+    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
+    H_brme = [[H, '1']]
+    psi0 = qutip.fock_dm(N, 2)
+    times = np.linspace(0, 10, 10)
+    me = qutip.mesolve(H, psi0, times).states
+    brme = brmesolve(H_brme, psi0, times).states
+    assert max(np.abs((me_state - brme_state).full()).max()
+               for me_state, brme_state in zip(me, brme)) < 1e-5
+
+
+@pytest.mark.slow
+def test_hamiltonian_taking_arguments():
+    N = 10
+    w0 = 1.0 * 2*np.pi
+    g = 0.75 * 2*np.pi
+    kappa = 0.05
+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
+    psi0 = qutip.ket2dm(psi0)
+    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
+
+    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
+    e_ops = [a.dag()*a, sp.dag()*sp]
+
+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+    args = {'ii': 1}
+
+    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
+    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
+    for arg, no_arg in zip(args.expect, no_args.expect):
+        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
diff --git a/qutip/tests/solver/test_correlation.py b/qutip/tests/solver/test_correlation.py
index bf96b045da..f2af197dcf 100644
--- a/qutip/tests/solver/test_correlation.py
+++ b/qutip/tests/solver/test_correlation.py
@@ -1,329 +1,329 @@
-import pytest
-import functools
-from itertools import product
-import numpy as np
-import qutip
-
-pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
-
-_equivalence_dimension = 15
-_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
-_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
-
-
-@pytest.mark.filterwarnings("ignore::FutureWarning")
-@pytest.mark.parametrize(["solver", "start"], [
-    pytest.param("es", _equivalence_coherent, id="es"),
-    pytest.param("es", None, id="es-steady state"),
-])
-def test_correlation_solver_equivalence(solver, start):
-    """
-    Test that all of the correlation solvers give the same results for a given
-    system.
-    """
-    a = qutip.destroy(_equivalence_dimension)
-    x = ( a + a.dag() ) / np.sqrt(2)
-    H = a.dag() * a
-    G1 = 0.75
-    n_th = 2
-    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
-             np.sqrt(G1 * n_th) * a.dag()]
-    times = np.linspace(0, 3, 61)
-    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
-    # long simulation time.
-    tol = 0.25 if solver == "mc" else 1e-4
-    # We use the master equation version as a base, but it doesn't actually
-    # matter - if all the tests fail, it implies that the "me" solver might be
-    # broken, whereas if only one fails, then it implies that only that one is
-    # broken.  We test that all solvers are equivalent by transitive equality
-    # to the "me" solver.
-    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
-                                    a.dag(), a, solver="me")
-    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
-                                   a.dag(), a, solver=solver)
-    np.testing.assert_allclose(base, cmp, atol=tol)
-
-
-def _spectrum_wrapper(solver):
-    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
-    @functools.wraps(qutip.spectrum)
-    def out(H, c_ops, a, b):
-        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
-                frequencies)
-    return out
-
-
-def _spectrum_fft(H, c_ops, a, b):
-    times = np.linspace(0, 100, 2500)
-    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
-    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
-    return spectrum, frequencies
-
-
-@pytest.mark.parametrize("spectrum", [
-    pytest.param(_spectrum_fft, id="fft"),
-    pytest.param(_spectrum_wrapper("es"), id="es"),
-    pytest.param(_spectrum_wrapper("pi"), id="pi"),
-    pytest.param(_spectrum_wrapper("solve"), id="solve"),
-])
-def test_spectrum_solver_equivalence_to_es(spectrum):
-    """Test equivalence of the spectrum solvers to the base "es" method."""
-    # Jaynes--Cummings model.
-    dimension = 4
-    wc = wa = 1.0 * 2*np.pi
-    g = 0.1 * 2*np.pi
-    kappa = 0.75
-    gamma = 0.25
-    n_th = 0.01
-
-    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
-    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
-    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
-    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
-             np.sqrt(kappa * n_th) * a.dag(),
-             np.sqrt(gamma) * sm.dag()]
-
-    test, frequencies = spectrum(H, c_ops, a.dag(), a)
-    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
-    np.testing.assert_allclose(base, test, atol=1e-3)
-
-
-def _trapz_2d(z, xy):
-    """2D trapezium-method integration assuming a square grid."""
-    dx = xy[1] - xy[0]
-    return dx*dx * np.trapz(np.trapz(z, axis=0))
-
-
-def _n_correlation(times, n):
-    """
-    Numerical integration of the correlation function given an array of
-    expectation values.
-    """
-    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
-                     for t in range(times.shape[0])])
-
-
-def _coefficient_function(t, args):
-    t_off, tp = args['t_off'], args['tp']
-    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
-
-
-_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
-
-
-def _h_qobj_function(t, args):
-    return args['H0'] * _coefficient_function(t, args)
-
-
-# 2LS and 3LS stand for two- and three-level system respectively.
-
-_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
-_2ls_times = np.linspace(0, 5, 51)
-_3ls_args = {'t_off': 2, 'tp': 1}
-_3ls_times = np.linspace(0, 6, 20)
-
-
-def _2ls_g2_0(H, c_ops):
-    sp = qutip.sigmap()
-    start = qutip.basis(2, 0)
-    times = _2ls_times
-    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
-    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
-                                           sp.dag(), sp.dag()*sp, sp,
-                                           args=_2ls_args)
-    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
-                                  e_ops=[qutip.num(2)],
-                                  args=_2ls_args).expect[0]
-    integral_correlation = _trapz_2d(np.real(correlation), times)
-    integral_n_expectation = np.trapz(n_expectation, times)
-    # Factor of two from negative time correlations.
-    return 2 * integral_correlation / integral_n_expectation**2
-
-
-@pytest.fixture(params=[
-    pytest.param(_coefficient_string, id="string"),
-    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
-    pytest.param(_coefficient_function, id="function"),
-])
-def dependence_2ls(request):
-    return request.param
-
-
-class TestTimeDependence:
-    """
-    Test correlations with time-dependent operators using a two-level system
-    (2LS) or a three-level system (3LS).
-    """
-    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
-        H = [[_2ls_args['H0'], dependence_2ls]]
-        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
-
-    def test_hamiltonian_from_function_2ls(self):
-        H = _h_qobj_function
-        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
-
-    @pytest.mark.slow
-    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
-        H = [[_2ls_args['H0'], dependence_2ls]]
-        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
-        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("dependence_3ls", [
-        pytest.param(_coefficient_string, id="string"),
-        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
-        pytest.param(_coefficient_function, id="function"),
-    ])
-    def test_coefficient_c_ops_3ls(self, dependence_3ls):
-        # Calculate zero-delay HOM cross-correlation for incoherently pumped
-        # three-level system, g2_ab[0] with gamma = 1.
-        dimension = 3
-        H = qutip.qzero(dimension)
-        start = qutip.basis(dimension, 2)
-        times = _3ls_times
-        project_0_1 = qutip.projection(dimension, 0, 1)
-        project_1_2 = qutip.projection(dimension, 1, 2)
-        population_1 = qutip.projection(dimension, 1, 1)
-        # Define the pi pulse to be when 99% of the population is transferred.
-        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
-        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
-                                      args=_3ls_args)
-        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
-        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
-                                            project_0_1.dag(), project_0_1,
-                                            args=_3ls_args)
-        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
-                                             project_0_1.dag(), project_0_1,
-                                             args=_3ls_args, reverse=True)
-        times2 = np.concatenate([times, times[1:] + times[-1]])
-        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
-                                 e_ops=[population_1]).expect[0]
-        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
-        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
-        assert abs(g2_ab_0 - 0.185) < 1e-2
-
-
-def _step(t):
-    return np.arctan(t)/np.pi + 0.5
-
-
-def test_hamiltonian_order_unimportant():
-    # Testing for regression on issue 1048.
-    sp = qutip.sigmap()
-    H = [[qutip.sigmax(), lambda t: _step(t-2)],
-         [qutip.qeye(2), lambda t: _step(-(t-2))]]
-    start = qutip.basis(2, 0)
-    times = np.linspace(0, 5, 6)
-    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
-                                        sp.dag(), sp)
-    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
-                                         sp.dag(), sp)
-    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
-
-
-@pytest.mark.parametrize(['solver', 'state'], [
-    pytest.param('me', _equivalence_fock, id="me-ket"),
-    pytest.param('me', _equivalence_coherent, id="me-dm"),
-    pytest.param('me', None, id="me-steady"),
-    pytest.param('es', _equivalence_fock, id="es-ket"),
-    pytest.param('es', _equivalence_coherent, id="es-dm"),
-    pytest.param('es', None, id="es-steady"),
-])
-@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
-                         ids=["hermitian", "nonhermitian"])
-@pytest.mark.parametrize("w", [1, 2])
-@pytest.mark.parametrize("gamma", [1, 10])
-def test_correlation_2op_1t_known_cases(solver,
-                                        state,
-                                        is_e_op_hermitian,
-                                        w,
-                                        gamma,
-                                       ):
-    """This test compares the output correlation_2op_1 solution to an analytical
-    solution."""
-
-    a = qutip.destroy(_equivalence_dimension)
-    x = (a + a.dag())/np.sqrt(2)
-
-    H = w * a.dag() * a
-
-    a_op = x if is_e_op_hermitian else a
-    b_op = x if is_e_op_hermitian else a.dag()
-    c_ops = [np.sqrt(gamma) * a]
-
-    times = np.linspace(0, 1, 30)
-
-    # Handle the case state==None when computing expt values
-    rho0 = state if state else qutip.steadystate(H, c_ops)
-    if is_e_op_hermitian:
-        # Analitycal solution for x,x as operators.
-        base = 0
-        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
-        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
-        base /= np.sqrt(2)
-    else:
-        # Analitycal solution for a,adag as operators.
-        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
-
-    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
-
-    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
-
-
-def test_correlation_timedependant_op():
-    num = qutip.num(2)
-    a = qutip.destroy(2)
-    sx = qutip.sigmax()
-    sz = qutip.sigmaz()
-    times = np.arange(4)
-    # switch between sx and sz at t=1.5
-    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
-
-    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
-    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
-    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
-    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
-    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
-
-
-def test_alternative_solver():
-    from qutip.solver.mesolve import MESolver
-    from qutip.solver.brmesolve import BRSolver
-
-    H = qutip.num(5)
-    a = qutip.destroy(5)
-    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
-
-    br = BRSolver(H, a_ops)
-    me = MESolver(H, [a])
-    times = np.arange(4)
-
-    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
-    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
-
-    np.testing.assert_allclose(br_corr, me_corr)
-
-
-def test_G1():
-    H = qutip.Qobj([[0,1], [1,0]])
-    psi0 = qutip.basis(2)
-    taus = np.linspace(0, 1, 11)
-    scale = 2
-    a_op = qutip.sigmaz() * scale
-    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
-    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
-    np.testing.assert_allclose(g1, expected, rtol=2e-5)
-    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
-
-
-def test_G2():
-    N = 10
-    H = qutip.rand_dm(N)
-    psi0 = qutip.rand_ket(N)
-    taus = np.linspace(0, 1, 11)
-    scale = 2
-    a_op = qutip.rand_unitary(N) * scale
-    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
-    expected = np.ones(11)
-    np.testing.assert_allclose(g1, expected, rtol=2e-5)
-    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
+import pytest
+import functools
+from itertools import product
+import numpy as np
+import qutip
+
+pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
+
+_equivalence_dimension = 15
+_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
+_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+@pytest.mark.parametrize(["solver", "start"], [
+    pytest.param("es", _equivalence_coherent, id="es"),
+    pytest.param("es", None, id="es-steady state"),
+])
+def test_correlation_solver_equivalence(solver, start):
+    """
+    Test that all of the correlation solvers give the same results for a given
+    system.
+    """
+    a = qutip.destroy(_equivalence_dimension)
+    x = ( a + a.dag() ) / np.sqrt(2)
+    H = a.dag() * a
+    G1 = 0.75
+    n_th = 2
+    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
+             np.sqrt(G1 * n_th) * a.dag()]
+    times = np.linspace(0, 3, 61)
+    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
+    # long simulation time.
+    tol = 0.25 if solver == "mc" else 1e-4
+    # We use the master equation version as a base, but it doesn't actually
+    # matter - if all the tests fail, it implies that the "me" solver might be
+    # broken, whereas if only one fails, then it implies that only that one is
+    # broken.  We test that all solvers are equivalent by transitive equality
+    # to the "me" solver.
+    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
+                                    a.dag(), a, solver="me")
+    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
+                                   a.dag(), a, solver=solver)
+    np.testing.assert_allclose(base, cmp, atol=tol)
+
+
+def _spectrum_wrapper(solver):
+    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
+    @functools.wraps(qutip.spectrum)
+    def out(H, c_ops, a, b):
+        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
+                frequencies)
+    return out
+
+
+def _spectrum_fft(H, c_ops, a, b):
+    times = np.linspace(0, 100, 2500)
+    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
+    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
+    return spectrum, frequencies
+
+
+@pytest.mark.parametrize("spectrum", [
+    pytest.param(_spectrum_fft, id="fft"),
+    pytest.param(_spectrum_wrapper("es"), id="es"),
+    pytest.param(_spectrum_wrapper("pi"), id="pi"),
+    pytest.param(_spectrum_wrapper("solve"), id="solve"),
+])
+def test_spectrum_solver_equivalence_to_es(spectrum):
+    """Test equivalence of the spectrum solvers to the base "es" method."""
+    # Jaynes--Cummings model.
+    dimension = 4
+    wc = wa = 1.0 * 2*np.pi
+    g = 0.1 * 2*np.pi
+    kappa = 0.75
+    gamma = 0.25
+    n_th = 0.01
+
+    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
+    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
+    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
+             np.sqrt(kappa * n_th) * a.dag(),
+             np.sqrt(gamma) * sm.dag()]
+
+    test, frequencies = spectrum(H, c_ops, a.dag(), a)
+    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
+    np.testing.assert_allclose(base, test, atol=1e-3)
+
+
+def _trapz_2d(z, xy):
+    """2D trapezium-method integration assuming a square grid."""
+    dx = xy[1] - xy[0]
+    return dx*dx * np.trapz(np.trapz(z, axis=0))
+
+
+def _n_correlation(times, n):
+    """
+    Numerical integration of the correlation function given an array of
+    expectation values.
+    """
+    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
+                     for t in range(times.shape[0])])
+
+
+def _coefficient_function(t, args):
+    t_off, tp = args['t_off'], args['tp']
+    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
+
+
+_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
+
+
+def _h_qobj_function(t, args):
+    return args['H0'] * _coefficient_function(t, args)
+
+
+# 2LS and 3LS stand for two- and three-level system respectively.
+
+_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
+_2ls_times = np.linspace(0, 5, 51)
+_3ls_args = {'t_off': 2, 'tp': 1}
+_3ls_times = np.linspace(0, 6, 20)
+
+
+def _2ls_g2_0(H, c_ops):
+    sp = qutip.sigmap()
+    start = qutip.basis(2, 0)
+    times = _2ls_times
+    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
+    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
+                                           sp.dag(), sp.dag()*sp, sp,
+                                           args=_2ls_args)
+    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
+                                  e_ops=[qutip.num(2)],
+                                  args=_2ls_args).expect[0]
+    integral_correlation = _trapz_2d(np.real(correlation), times)
+    integral_n_expectation = np.trapz(n_expectation, times)
+    # Factor of two from negative time correlations.
+    return 2 * integral_correlation / integral_n_expectation**2
+
+
+@pytest.fixture(params=[
+    pytest.param(_coefficient_string, id="string"),
+    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
+    pytest.param(_coefficient_function, id="function"),
+])
+def dependence_2ls(request):
+    return request.param
+
+
+class TestTimeDependence:
+    """
+    Test correlations with time-dependent operators using a two-level system
+    (2LS) or a three-level system (3LS).
+    """
+    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
+        H = [[_2ls_args['H0'], dependence_2ls]]
+        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
+
+    def test_hamiltonian_from_function_2ls(self):
+        H = _h_qobj_function
+        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
+
+    @pytest.mark.slow
+    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
+        H = [[_2ls_args['H0'], dependence_2ls]]
+        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
+        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("dependence_3ls", [
+        pytest.param(_coefficient_string, id="string"),
+        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
+        pytest.param(_coefficient_function, id="function"),
+    ])
+    def test_coefficient_c_ops_3ls(self, dependence_3ls):
+        # Calculate zero-delay HOM cross-correlation for incoherently pumped
+        # three-level system, g2_ab[0] with gamma = 1.
+        dimension = 3
+        H = qutip.qzero(dimension)
+        start = qutip.basis(dimension, 2)
+        times = _3ls_times
+        project_0_1 = qutip.projection(dimension, 0, 1)
+        project_1_2 = qutip.projection(dimension, 1, 2)
+        population_1 = qutip.projection(dimension, 1, 1)
+        # Define the pi pulse to be when 99% of the population is transferred.
+        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
+        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
+                                      args=_3ls_args)
+        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
+        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
+                                            project_0_1.dag(), project_0_1,
+                                            args=_3ls_args)
+        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
+                                             project_0_1.dag(), project_0_1,
+                                             args=_3ls_args, reverse=True)
+        times2 = np.concatenate([times, times[1:] + times[-1]])
+        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
+                                 e_ops=[population_1]).expect[0]
+        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
+        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
+        assert abs(g2_ab_0 - 0.185) < 1e-2
+
+
+def _step(t):
+    return np.arctan(t)/np.pi + 0.5
+
+
+def test_hamiltonian_order_unimportant():
+    # Testing for regression on issue 1048.
+    sp = qutip.sigmap()
+    H = [[qutip.sigmax(), lambda t: _step(t-2)],
+         [qutip.qeye(2), lambda t: _step(-(t-2))]]
+    start = qutip.basis(2, 0)
+    times = np.linspace(0, 5, 6)
+    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
+                                        sp.dag(), sp)
+    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
+                                         sp.dag(), sp)
+    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
+
+
+@pytest.mark.parametrize(['solver', 'state'], [
+    pytest.param('me', _equivalence_fock, id="me-ket"),
+    pytest.param('me', _equivalence_coherent, id="me-dm"),
+    pytest.param('me', None, id="me-steady"),
+    pytest.param('es', _equivalence_fock, id="es-ket"),
+    pytest.param('es', _equivalence_coherent, id="es-dm"),
+    pytest.param('es', None, id="es-steady"),
+])
+@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
+                         ids=["hermitian", "nonhermitian"])
+@pytest.mark.parametrize("w", [1, 2])
+@pytest.mark.parametrize("gamma", [1, 10])
+def test_correlation_2op_1t_known_cases(solver,
+                                        state,
+                                        is_e_op_hermitian,
+                                        w,
+                                        gamma,
+                                       ):
+    """This test compares the output correlation_2op_1 solution to an analytical
+    solution."""
+
+    a = qutip.destroy(_equivalence_dimension)
+    x = (a + a.dag())/np.sqrt(2)
+
+    H = w * a.dag() * a
+
+    a_op = x if is_e_op_hermitian else a
+    b_op = x if is_e_op_hermitian else a.dag()
+    c_ops = [np.sqrt(gamma) * a]
+
+    times = np.linspace(0, 1, 30)
+
+    # Handle the case state==None when computing expt values
+    rho0 = state if state else qutip.steadystate(H, c_ops)
+    if is_e_op_hermitian:
+        # Analitycal solution for x,x as operators.
+        base = 0
+        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
+        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
+        base /= np.sqrt(2)
+    else:
+        # Analitycal solution for a,adag as operators.
+        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
+
+    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
+
+    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
+
+
+def test_correlation_timedependant_op():
+    num = qutip.num(2)
+    a = qutip.destroy(2)
+    sx = qutip.sigmax()
+    sz = qutip.sigmaz()
+    times = np.arange(4)
+    # switch between sx and sz at t=1.5
+    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
+
+    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
+    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
+    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
+    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
+    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
+
+
+def test_alternative_solver():
+    from qutip.solver.mesolve import MESolver
+    from qutip.solver.brmesolve import BRSolver
+
+    H = qutip.num(5)
+    a = qutip.destroy(5)
+    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
+
+    br = BRSolver(H, a_ops)
+    me = MESolver(H, [a])
+    times = np.arange(4)
+
+    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
+    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
+
+    np.testing.assert_allclose(br_corr, me_corr)
+
+
+def test_G1():
+    H = qutip.Qobj([[0,1], [1,0]])
+    psi0 = qutip.basis(2)
+    taus = np.linspace(0, 1, 11)
+    scale = 2
+    a_op = qutip.sigmaz() * scale
+    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
+    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
+    np.testing.assert_allclose(g1, expected, rtol=2e-5)
+    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
+
+
+def test_G2():
+    N = 10
+    H = qutip.rand_dm(N)
+    psi0 = qutip.rand_ket(N)
+    taus = np.linspace(0, 1, 11)
+    scale = 2
+    a_op = qutip.rand_unitary(N) * scale
+    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
+    expected = np.ones(11)
+    np.testing.assert_allclose(g1, expected, rtol=2e-5)
+    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
diff --git a/qutip/tests/solver/test_countstat.py b/qutip/tests/solver/test_countstat.py
index 6d389b20d1..130afec6de 100644
--- a/qutip/tests/solver/test_countstat.py
+++ b/qutip/tests/solver/test_countstat.py
@@ -1,90 +1,90 @@
-import numpy as np
-import qutip
-import pytest
-
-
-@pytest.mark.filterwarnings("ignore::FutureWarning")
-def test_dqd_current():
-    "Counting statistics: current and current noise in a DQD model"
-
-    G = 0
-    L = 1
-    R = 2
-
-    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
-    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
-    sR = qutip.projection(3, G, R)
-    sL = qutip.projection(3, G, L)
-
-    w0 = 1
-    tc = 0.6 * w0
-    GammaR = 0.0075 * w0
-    GammaL = 0.0075 * w0
-    nth = 0.00
-    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
-
-    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
-
-    c_ops = [
-        np.sqrt(GammaR * (1 + nth)) * sR,
-        np.sqrt(GammaR * (nth)) * sR.dag(),
-        np.sqrt(GammaL * (nth)) * sL,
-        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
-    ]
-
-    current = np.zeros(len(eps_vec))
-    noise = np.zeros(len(eps_vec))
-
-    for n, eps in enumerate(eps_vec):
-        H = eps / 2 * sz + tc * sx
-        L0 = qutip.liouvillian(H)
-        L = qutip.liouvillian(H, c_ops)
-        rhoss = qutip.steadystate(L)
-        current_1, noise_1 = qutip.countstat_current_noise(
-            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
-        )
-        current[n] = current_1[0]
-        noise[n] = noise_1[0, 0, 0]
-
-        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
-        assert abs(current_1[0] - current_2[0]) < 1e-8
-
-        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
-        assert abs(current_1[0] - current_2[0]) < 1e-8
-
-        current_2 = qutip.countstat_current(H, c_ops)
-        assert abs(current_1[0] - current_2[0]) < 1e-8
-
-        current_3, noise_3 = qutip.countstat_current_noise(
-            L, c_ops, wlist=[0, 1], sparse=False
-        )
-        assert abs(current_1[0] - current_3[0]) < 1e-6
-        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
-                                   atol=1e-6)
-
-    current_target = (
-        tc**2
-        * GammaR
-        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
-    )
-    noise_target = current_target * (
-        1
-        - (
-            8
-            * GammaL
-            * tc**2
-            * (
-                4 * eps_vec**2 * (GammaR - GammaL)
-                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
-            )
-            / (
-                4 * tc**2 * (2 * GammaL + GammaR)
-                + GammaL * GammaR**2
-                + 4 * eps_vec**2 * GammaL
-            )
-            ** 2
-        )
-    )
-
-    np.testing.assert_allclose(current, current_target, atol=1e-4)
-    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
+import numpy as np
+import qutip
+import pytest
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_dqd_current():
+    "Counting statistics: current and current noise in a DQD model"
+
+    G = 0
+    L = 1
+    R = 2
+
+    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
+    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
+    sR = qutip.projection(3, G, R)
+    sL = qutip.projection(3, G, L)
+
+    w0 = 1
+    tc = 0.6 * w0
+    GammaR = 0.0075 * w0
+    GammaL = 0.0075 * w0
+    nth = 0.00
+    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
+
+    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
+
+    c_ops = [
+        np.sqrt(GammaR * (1 + nth)) * sR,
+        np.sqrt(GammaR * (nth)) * sR.dag(),
+        np.sqrt(GammaL * (nth)) * sL,
+        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
+    ]
+
+    current = np.zeros(len(eps_vec))
+    noise = np.zeros(len(eps_vec))
+
+    for n, eps in enumerate(eps_vec):
+        H = eps / 2 * sz + tc * sx
+        L0 = qutip.liouvillian(H)
+        L = qutip.liouvillian(H, c_ops)
+        rhoss = qutip.steadystate(L)
+        current_1, noise_1 = qutip.countstat_current_noise(
+            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
+        )
+        current[n] = current_1[0]
+        noise[n] = noise_1[0, 0, 0]
+
+        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
+        assert abs(current_1[0] - current_2[0]) < 1e-8
+
+        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
+        assert abs(current_1[0] - current_2[0]) < 1e-8
+
+        current_2 = qutip.countstat_current(H, c_ops)
+        assert abs(current_1[0] - current_2[0]) < 1e-8
+
+        current_3, noise_3 = qutip.countstat_current_noise(
+            L, c_ops, wlist=[0, 1], sparse=False
+        )
+        assert abs(current_1[0] - current_3[0]) < 1e-6
+        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
+                                   atol=1e-6)
+
+    current_target = (
+        tc**2
+        * GammaR
+        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
+    )
+    noise_target = current_target * (
+        1
+        - (
+            8
+            * GammaL
+            * tc**2
+            * (
+                4 * eps_vec**2 * (GammaR - GammaL)
+                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
+            )
+            / (
+                4 * tc**2 * (2 * GammaL + GammaR)
+                + GammaL * GammaR**2
+                + 4 * eps_vec**2 * GammaL
+            )
+            ** 2
+        )
+    )
+
+    np.testing.assert_allclose(current, current_target, atol=1e-4)
+    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
diff --git a/qutip/tests/solver/test_floquet.py b/qutip/tests/solver/test_floquet.py
index be90e6fab2..723bf68467 100644
--- a/qutip/tests/solver/test_floquet.py
+++ b/qutip/tests/solver/test_floquet.py
@@ -1,333 +1,333 @@
-import numpy as np
-from qutip import (
-    sigmax, sigmay, sigmaz,  sigmap, sigmam,
-    rand_ket, num, destroy,
-    mesolve, expect, sesolve,
-    Qobj, QobjEvo, coefficient
- )
-
-from qutip.solver.floquet import (
-    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
-    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
-)
-import pytest
-
-
-def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
-    """
-    Convert e_ops for fmmesolve to mesolve
-    """
-    c_op_mesolve = []
-    N = len(vp)
-    for i in range(N):
-        for j in range(N):
-            if i != j:
-                # caclculate the rate
-                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
-                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
-                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
-
-                # add c_op for mesolve
-                c_op_mesolve.append(
-                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
-                )
-    return c_op_mesolve
-
-
-class TestFloquet:
-    """
-    A test class for the QuTiP functions for Floquet formalism.
-    """
-
-    def testFloquetBasis(self):
-        N = 10
-        a = destroy(N)
-        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
-        T = 2 * np.pi
-        floquet_basis = FloquetBasis(H, T)
-        psi0 = rand_ket(N)
-        tlist = np.linspace(0, 10, 11)
-        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
-        states = sesolve(H, psi0, tlist).states
-        for t, state in zip(tlist, states):
-            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
-            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
-
-    def testFloquetUnitary(self):
-        N = 10
-        a = destroy(N)
-        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
-        T = 2 * np.pi
-        psi0 = rand_ket(N)
-        tlist = np.linspace(0, 10, 11)
-        states_se = sesolve(H, psi0, tlist).states
-        states_fse = fsesolve(H, psi0, tlist, T=T).states
-        for state_se, state_fse in zip(states_se, states_fse):
-            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
-
-
-    def testFloquetMasterEquation1(self):
-        """
-        Test Floquet-Markov Master Equation for a driven two-level system
-        without dissipation.
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.5 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
-        e_ops = [num(2)]
-        gamma1 = 0
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_op_fmmesolve = sigmax()
-
-        # Collapse operators for Lindblad Master Equation
-        def spectrum(omega):
-            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-
-        # Solve the floquet-markov master equation
-        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
-                         [spectrum], T, args=args).expect[0]
-
-        # Compare with mesolve
-        p_ex_ref = mesolve(
-            H, psi0, tlist, c_op_mesolve, [num(2)], args
-        ).expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-
-    def testFloquetMasterEquation2(self):
-        """
-        Test Floquet-Markov Master Equation for a two-level system
-        subject to dissipation.
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.0 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-                    args=args)
-        e_ops = [num(2)]
-        gamma1 = 1
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_op_fmmesolve = sigmax()
-
-        # Collapse operator for Lindblad Master Equation
-        def spectrum(omega):
-            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-
-        # Solve the floquet-markov master equation
-        p_ex = fmmesolve(
-            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
-            [spectrum], T, args=args
-        ).expect[0]
-
-        # Compare with mesolve
-        p_ex_ref = mesolve(
-            H, psi0, tlist, c_op_mesolve, [num(2)], args
-        ).expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-
-    @pytest.mark.parametrize("kmax", [5, 25, 100])
-    def testFloquetMasterEquation3(self, kmax):
-        """
-        Test Floquet-Markov Master Equation for a two-level system
-        subject to dissipation with internal transform of fmmesolve
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.0 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-                    args=args)
-        e_ops = [num(2)]
-        gamma1 = 1
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_op_fmmesolve = sigmax()
-
-        # Collapse operator for Lindblad Master Equation
-        def spectrum(omega):
-            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-
-        # Solve the floquet-markov master equation
-        floquet_basis = FloquetBasis(H, T)
-        solver = FMESolver(
-            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
-        )
-        solver.start(psi0, tlist[0])
-        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
-
-        # Compare with mesolve
-        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
-        p_ex_ref = output2.expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
-                                   atol=5 * 1e-4)
-
-    def testFloquetMasterEquation_multiple_coupling(self):
-        """
-        Test Floquet-Markov Master Equation for a two-level system
-        subject to dissipation with multiple coupling operators
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.0 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-                    args=args)
-        e_ops = [num(2)]
-        gamma1 = 1
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_ops_fmmesolve = [sigmax(), sigmay()]
-
-        # Collapse operator for Lindblad Master Equation
-        def noise_spectrum1(omega):
-            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
-
-        def noise_spectrum2(omega):
-            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
-
-        noise_spectra = [noise_spectrum1, noise_spectrum2]
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = []
-
-        # Convert the c_ops for fmmesolve to c_ops for mesolve
-        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
-                                                   noise_spectra):
-            c_op_mesolve += _convert_c_ops(
-                c_op_fmmesolve, noise_spectrum, vp, ep
-            )
-
-        # Solve the floquet-markov master equation
-        output1 = fmmesolve(
-            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
-        )
-        p_ex = output1.expect[0]
-        # Compare with mesolve
-        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
-        p_ex_ref = output2.expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-
-    def testFloquetRates(self):
-        """
-        Compare rate transition and frequency transitions to analytical
-        results for a driven two-level system, for different drive amplitudes.
-        """
-        # Parameters
-        wq = 5.4 * 2 * np.pi
-        wd = 6.7 * 2 * np.pi
-        delta = wq - wd
-        T = 2 * np.pi / wd
-        tlist = np.linspace(0.0, 2 * T, 101)
-        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
-        H0 = Qobj(wq / 2 * sigmaz())
-        args = {'wd': wd}
-        c_ops = sigmax()
-        gamma1 = 1
-        kmax = 5
-
-        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
-        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
-        array_ana_delta = [
-            2 * np.sqrt((delta / 2)**2 + a**2)
-            for a in array_A
-        ]
-
-        def noise_spectrum(omega):
-            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
-
-        idx = 0
-        for a in array_A:
-            # Hamiltonian
-            H1_p = a * sigmap()
-            H1_m = a * sigmam()
-            H = QobjEvo(
-                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
-                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
-            )
-
-            floquet_basis = FloquetBasis(H, T)
-            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
-            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
-
-            # Check energies
-            deltas = np.ndarray.flatten(DeltaMatrix)
-
-            # deltas and array_ana_delta have at least 1 value in common.
-            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
-
-            # Check matrix elements
-            Xs = np.concatenate(
-                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
-            ).flatten()
-
-            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
-            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
-
-            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
-            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
-            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
-            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
-            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
-            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
-            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
-            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
-            Xpm_p1 = (a / (normMinus * normPlus)
-                      * (array_ana_E0[idx]- delta / 2))
-            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
-            Xpm_m1 = (a / (normMinus * normPlus)
-                      * (array_ana_E1[idx] - delta / 2))
-            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
-            idx += 1
+import numpy as np
+from qutip import (
+    sigmax, sigmay, sigmaz,  sigmap, sigmam,
+    rand_ket, num, destroy,
+    mesolve, expect, sesolve,
+    Qobj, QobjEvo, coefficient
+ )
+
+from qutip.solver.floquet import (
+    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
+    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
+)
+import pytest
+
+
+def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
+    """
+    Convert e_ops for fmmesolve to mesolve
+    """
+    c_op_mesolve = []
+    N = len(vp)
+    for i in range(N):
+        for j in range(N):
+            if i != j:
+                # caclculate the rate
+                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
+                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
+                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
+
+                # add c_op for mesolve
+                c_op_mesolve.append(
+                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
+                )
+    return c_op_mesolve
+
+
+class TestFloquet:
+    """
+    A test class for the QuTiP functions for Floquet formalism.
+    """
+
+    def testFloquetBasis(self):
+        N = 10
+        a = destroy(N)
+        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
+        T = 2 * np.pi
+        floquet_basis = FloquetBasis(H, T)
+        psi0 = rand_ket(N)
+        tlist = np.linspace(0, 10, 11)
+        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
+        states = sesolve(H, psi0, tlist).states
+        for t, state in zip(tlist, states):
+            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
+            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
+
+    def testFloquetUnitary(self):
+        N = 10
+        a = destroy(N)
+        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
+        T = 2 * np.pi
+        psi0 = rand_ket(N)
+        tlist = np.linspace(0, 10, 11)
+        states_se = sesolve(H, psi0, tlist).states
+        states_fse = fsesolve(H, psi0, tlist, T=T).states
+        for state_se, state_fse in zip(states_se, states_fse):
+            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
+
+
+    def testFloquetMasterEquation1(self):
+        """
+        Test Floquet-Markov Master Equation for a driven two-level system
+        without dissipation.
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.5 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
+        e_ops = [num(2)]
+        gamma1 = 0
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_op_fmmesolve = sigmax()
+
+        # Collapse operators for Lindblad Master Equation
+        def spectrum(omega):
+            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+
+        # Solve the floquet-markov master equation
+        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
+                         [spectrum], T, args=args).expect[0]
+
+        # Compare with mesolve
+        p_ex_ref = mesolve(
+            H, psi0, tlist, c_op_mesolve, [num(2)], args
+        ).expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+
+    def testFloquetMasterEquation2(self):
+        """
+        Test Floquet-Markov Master Equation for a two-level system
+        subject to dissipation.
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.0 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+                    args=args)
+        e_ops = [num(2)]
+        gamma1 = 1
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_op_fmmesolve = sigmax()
+
+        # Collapse operator for Lindblad Master Equation
+        def spectrum(omega):
+            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+
+        # Solve the floquet-markov master equation
+        p_ex = fmmesolve(
+            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
+            [spectrum], T, args=args
+        ).expect[0]
+
+        # Compare with mesolve
+        p_ex_ref = mesolve(
+            H, psi0, tlist, c_op_mesolve, [num(2)], args
+        ).expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+
+    @pytest.mark.parametrize("kmax", [5, 25, 100])
+    def testFloquetMasterEquation3(self, kmax):
+        """
+        Test Floquet-Markov Master Equation for a two-level system
+        subject to dissipation with internal transform of fmmesolve
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.0 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+                    args=args)
+        e_ops = [num(2)]
+        gamma1 = 1
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_op_fmmesolve = sigmax()
+
+        # Collapse operator for Lindblad Master Equation
+        def spectrum(omega):
+            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+
+        # Solve the floquet-markov master equation
+        floquet_basis = FloquetBasis(H, T)
+        solver = FMESolver(
+            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
+        )
+        solver.start(psi0, tlist[0])
+        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
+
+        # Compare with mesolve
+        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
+        p_ex_ref = output2.expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
+                                   atol=5 * 1e-4)
+
+    def testFloquetMasterEquation_multiple_coupling(self):
+        """
+        Test Floquet-Markov Master Equation for a two-level system
+        subject to dissipation with multiple coupling operators
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.0 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+                    args=args)
+        e_ops = [num(2)]
+        gamma1 = 1
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_ops_fmmesolve = [sigmax(), sigmay()]
+
+        # Collapse operator for Lindblad Master Equation
+        def noise_spectrum1(omega):
+            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
+
+        def noise_spectrum2(omega):
+            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
+
+        noise_spectra = [noise_spectrum1, noise_spectrum2]
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = []
+
+        # Convert the c_ops for fmmesolve to c_ops for mesolve
+        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
+                                                   noise_spectra):
+            c_op_mesolve += _convert_c_ops(
+                c_op_fmmesolve, noise_spectrum, vp, ep
+            )
+
+        # Solve the floquet-markov master equation
+        output1 = fmmesolve(
+            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
+        )
+        p_ex = output1.expect[0]
+        # Compare with mesolve
+        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
+        p_ex_ref = output2.expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+
+    def testFloquetRates(self):
+        """
+        Compare rate transition and frequency transitions to analytical
+        results for a driven two-level system, for different drive amplitudes.
+        """
+        # Parameters
+        wq = 5.4 * 2 * np.pi
+        wd = 6.7 * 2 * np.pi
+        delta = wq - wd
+        T = 2 * np.pi / wd
+        tlist = np.linspace(0.0, 2 * T, 101)
+        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
+        H0 = Qobj(wq / 2 * sigmaz())
+        args = {'wd': wd}
+        c_ops = sigmax()
+        gamma1 = 1
+        kmax = 5
+
+        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
+        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
+        array_ana_delta = [
+            2 * np.sqrt((delta / 2)**2 + a**2)
+            for a in array_A
+        ]
+
+        def noise_spectrum(omega):
+            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
+
+        idx = 0
+        for a in array_A:
+            # Hamiltonian
+            H1_p = a * sigmap()
+            H1_m = a * sigmam()
+            H = QobjEvo(
+                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
+                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
+            )
+
+            floquet_basis = FloquetBasis(H, T)
+            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
+            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
+
+            # Check energies
+            deltas = np.ndarray.flatten(DeltaMatrix)
+
+            # deltas and array_ana_delta have at least 1 value in common.
+            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
+
+            # Check matrix elements
+            Xs = np.concatenate(
+                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
+            ).flatten()
+
+            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
+            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
+
+            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
+            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
+            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
+            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
+            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
+            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
+            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
+            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
+            Xpm_p1 = (a / (normMinus * normPlus)
+                      * (array_ana_E0[idx]- delta / 2))
+            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
+            Xpm_m1 = (a / (normMinus * normPlus)
+                      * (array_ana_E1[idx] - delta / 2))
+            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
+            idx += 1
diff --git a/qutip/tests/solver/test_integrator.py b/qutip/tests/solver/test_integrator.py
index 8779ea76a2..5c46c8f39b 100644
--- a/qutip/tests/solver/test_integrator.py
+++ b/qutip/tests/solver/test_integrator.py
@@ -1,164 +1,164 @@
-from qutip.solver.sesolve import SESolver
-from qutip.solver.mesolve import MESolver
-from qutip.solver.mcsolve import MCSolver
-from qutip.solver.solver_base import Solver
-from qutip.solver.integrator import *
-import qutip
-import numpy as np
-from numpy.testing import assert_allclose
-import pytest
-
-
-class TestIntegratorCte():
-    _analytical_se = lambda _, t: np.cos(t * np.pi)
-    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
-    _analytical_me = lambda _, t: 1 - np.exp(-t)
-    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
-                                  c_ops=[qutip.destroy(2)])
-
-    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
-    def se_method(self, request):
-        return request.param
-
-    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
-    def me_method(self, request):
-        return request.param
-
-    # TODO: Change when the MCSolver is added
-    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
-    def mc_method(self, request):
-        return request.param
-
-    def test_se_integration(self, se_method):
-        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
-        state0 = qutip.basis(2, 0).data
-        evol.set_state(0, state0)
-        for t, state in evol.run(np.linspace(0, 2, 21)):
-            assert_allclose(self._analytical_se(t),
-                            state.to_array()[0, 0], atol=2e-5)
-            assert state.shape == (2, 1)
-
-    def test_me_integration(self, me_method):
-        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
-        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
-        evol.set_state(0, state0)
-        for t in np.linspace(0, 2, 21):
-            t_, state = evol.integrate(t)
-            assert t_ == t
-            assert_allclose(self._analytical_me(t),
-                            state.to_array()[0, 0], atol=2e-5)
-
-    def test_mc_integration(self, mc_method):
-        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
-        state = qutip.basis(2,0).data
-        evol.set_state(0, state)
-        t = 0
-        for i in range(1, 21):
-            t_target = i * 0.05
-            while t < t_target:
-                t_old, y_old = evol.get_state()
-                t, state = evol.mcstep(t_target)
-                assert t <= t_target
-                assert t > t_old
-                assert_allclose(self._analytical_se(t),
-                                state.to_array()[0, 0], atol=2e-5)
-                t_back = (t + t_old) / 2
-                t_got, bstate = evol.mcstep(t_back)
-                assert t_back == t_got
-                assert_allclose(self._analytical_se(t),
-                                state.to_array()[0, 0], atol=2e-5)
-                t, state = evol.mcstep(t)
-
-
-    @pytest.mark.parametrize('start', [1, -1])
-    def test_mc_integration_mixed(self, start, mc_method):
-        system = qutip.QobjEvo(qutip.qeye(1))
-        evol = Solver.avail_integrators()[mc_method](system, {})
-
-        state = qutip.basis(1,0).data
-        evol.set_state(start, state)
-        t = start
-        t_target = start + .1
-        while t < t_target:
-            t, _ = evol.mcstep(start + .1)
-        _ = evol.mcstep(start + .2)
-        t_target = (start + .1 + t) / 2
-        t, state = evol.mcstep(t_target)
-        assert (
-            state.to_array()[0, 0]
-            == pytest.approx(np.exp(t - start), abs=1e-5)
-        )
-
-
-class TestIntegrator(TestIntegratorCte):
-    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
-    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
-    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
-    me_system = qutip.liouvillian(
-        qutip.QobjEvo(qutip.qeye(2)),
-        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
-    )
-
-    @pytest.fixture(
-        params=[key for key, integrator in SESolver.avail_integrators().items()
-                if integrator.support_time_dependant]
-    )
-    def se_method(self, request):
-        return request.param
-
-    @pytest.fixture(
-        params=[key for key, integrator in MESolver.avail_integrators().items()
-                if integrator.support_time_dependant]
-    )
-    def me_method(self, request):
-        return request.param
-
-    @pytest.fixture(
-        params=[key for key, integrator in MCSolver.avail_integrators().items()
-                if integrator.support_time_dependant]
-    )
-    def mc_method(self, request):
-        return request.param
-
-
-@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
-                     ids=["large", "multiple subspaces", "diagonal"])
-def test_krylov(sizes):
-    # Krylov solve act differently for large systems composed tensored
-    # sub systems.
-    N, M = sizes
-    H = qutip.qeye(N)
-    if M:
-        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
-    H = qutip.QobjEvo(-1j * H)
-    integrator = IntegratorKrylov(H, {})
-    ref_integrator = IntegratorDiag(H, {})
-    psi = qutip.basis(100, 95).data
-    integrator.set_state(0, psi)
-    ref_integrator.set_state(0, psi)
-    for t in np.linspace(0.25, 1, 4):
-        out = integrator.integrate(t)[1]
-        ref = ref_integrator.integrate(t)[1]
-        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
-
-
-@pytest.mark.parametrize('integrator',
-    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
-    ids=["adams", 'bdf', "lsoda"]
-)
-def test_concurent_usage(integrator):
-    opt = {'atol':1e-10, 'rtol':1e-7}
-
-    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
-    inter1 = integrator(sys1, opt)
-    inter1.set_state(0, qutip.basis(1,0).data)
-
-    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
-    inter2 = integrator(sys2, opt)
-    inter2.set_state(0, qutip.basis(1,0).data)
-
-    for t in np.linspace(0,1,6):
-        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
-        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
-        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
-        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
+from qutip.solver.sesolve import SESolver
+from qutip.solver.mesolve import MESolver
+from qutip.solver.mcsolve import MCSolver
+from qutip.solver.solver_base import Solver
+from qutip.solver.integrator import *
+import qutip
+import numpy as np
+from numpy.testing import assert_allclose
+import pytest
+
+
+class TestIntegratorCte():
+    _analytical_se = lambda _, t: np.cos(t * np.pi)
+    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
+    _analytical_me = lambda _, t: 1 - np.exp(-t)
+    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
+                                  c_ops=[qutip.destroy(2)])
+
+    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
+    def se_method(self, request):
+        return request.param
+
+    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
+    def me_method(self, request):
+        return request.param
+
+    # TODO: Change when the MCSolver is added
+    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
+    def mc_method(self, request):
+        return request.param
+
+    def test_se_integration(self, se_method):
+        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
+        state0 = qutip.basis(2, 0).data
+        evol.set_state(0, state0)
+        for t, state in evol.run(np.linspace(0, 2, 21)):
+            assert_allclose(self._analytical_se(t),
+                            state.to_array()[0, 0], atol=2e-5)
+            assert state.shape == (2, 1)
+
+    def test_me_integration(self, me_method):
+        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
+        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
+        evol.set_state(0, state0)
+        for t in np.linspace(0, 2, 21):
+            t_, state = evol.integrate(t)
+            assert t_ == t
+            assert_allclose(self._analytical_me(t),
+                            state.to_array()[0, 0], atol=2e-5)
+
+    def test_mc_integration(self, mc_method):
+        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
+        state = qutip.basis(2,0).data
+        evol.set_state(0, state)
+        t = 0
+        for i in range(1, 21):
+            t_target = i * 0.05
+            while t < t_target:
+                t_old, y_old = evol.get_state()
+                t, state = evol.mcstep(t_target)
+                assert t <= t_target
+                assert t > t_old
+                assert_allclose(self._analytical_se(t),
+                                state.to_array()[0, 0], atol=2e-5)
+                t_back = (t + t_old) / 2
+                t_got, bstate = evol.mcstep(t_back)
+                assert t_back == t_got
+                assert_allclose(self._analytical_se(t),
+                                state.to_array()[0, 0], atol=2e-5)
+                t, state = evol.mcstep(t)
+
+
+    @pytest.mark.parametrize('start', [1, -1])
+    def test_mc_integration_mixed(self, start, mc_method):
+        system = qutip.QobjEvo(qutip.qeye(1))
+        evol = Solver.avail_integrators()[mc_method](system, {})
+
+        state = qutip.basis(1,0).data
+        evol.set_state(start, state)
+        t = start
+        t_target = start + .1
+        while t < t_target:
+            t, _ = evol.mcstep(start + .1)
+        _ = evol.mcstep(start + .2)
+        t_target = (start + .1 + t) / 2
+        t, state = evol.mcstep(t_target)
+        assert (
+            state.to_array()[0, 0]
+            == pytest.approx(np.exp(t - start), abs=1e-5)
+        )
+
+
+class TestIntegrator(TestIntegratorCte):
+    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
+    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
+    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
+    me_system = qutip.liouvillian(
+        qutip.QobjEvo(qutip.qeye(2)),
+        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
+    )
+
+    @pytest.fixture(
+        params=[key for key, integrator in SESolver.avail_integrators().items()
+                if integrator.support_time_dependant]
+    )
+    def se_method(self, request):
+        return request.param
+
+    @pytest.fixture(
+        params=[key for key, integrator in MESolver.avail_integrators().items()
+                if integrator.support_time_dependant]
+    )
+    def me_method(self, request):
+        return request.param
+
+    @pytest.fixture(
+        params=[key for key, integrator in MCSolver.avail_integrators().items()
+                if integrator.support_time_dependant]
+    )
+    def mc_method(self, request):
+        return request.param
+
+
+@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
+                     ids=["large", "multiple subspaces", "diagonal"])
+def test_krylov(sizes):
+    # Krylov solve act differently for large systems composed tensored
+    # sub systems.
+    N, M = sizes
+    H = qutip.qeye(N)
+    if M:
+        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
+    H = qutip.QobjEvo(-1j * H)
+    integrator = IntegratorKrylov(H, {})
+    ref_integrator = IntegratorDiag(H, {})
+    psi = qutip.basis(100, 95).data
+    integrator.set_state(0, psi)
+    ref_integrator.set_state(0, psi)
+    for t in np.linspace(0.25, 1, 4):
+        out = integrator.integrate(t)[1]
+        ref = ref_integrator.integrate(t)[1]
+        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
+
+
+@pytest.mark.parametrize('integrator',
+    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
+    ids=["adams", 'bdf', "lsoda"]
+)
+def test_concurent_usage(integrator):
+    opt = {'atol':1e-10, 'rtol':1e-7}
+
+    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
+    inter1 = integrator(sys1, opt)
+    inter1.set_state(0, qutip.basis(1,0).data)
+
+    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
+    inter2 = integrator(sys2, opt)
+    inter2.set_state(0, qutip.basis(1,0).data)
+
+    for t in np.linspace(0,1,6):
+        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
+        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
+        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
+        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index be5b5b3bad..840f733706 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -1,439 +1,439 @@
-import pytest
-import numpy as np
-import qutip
-from copy import copy
-from qutip.solver.mcsolve import mcsolve, MCSolver
-from qutip.solver.solver_base import Solver
-
-def _return_constant(t, args):
-    return args['constant']
-
-
-def _return_decay(t, args):
-    return args['constant'] * np.exp(-args['rate'] * t)
-
-
-class callable_qobj:
-    def __init__(self, oper, coeff=None):
-        self.oper = oper
-        self.coeff = coeff
-
-    def __call__(self, t, args):
-        if self.coeff is not None:
-            return self.oper * self.coeff(t, args)
-        return self.oper
-
-
-@pytest.mark.usefixtures("in_temporary_directory")
-class StatesAndExpectOutputCase:
-    """
-    Mixin class to test the states and expectation values from ``mcsolve``.
-    """
-    size = 10
-    h = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 1, 101)
-    e_ops = [qutip.num(size)]
-    ntraj = 2000
-
-    def _assert_states(self, result, expected, tol):
-        assert hasattr(result, 'states')
-        assert len(result.states) == len(self.times)
-        assert len(self.e_ops) == len(expected)
-        for test_operator, expected_part in zip(self.e_ops, expected):
-            test = qutip.expect(test_operator, result.states)
-            np.testing.assert_allclose(test, expected_part, rtol=tol)
-
-    def _assert_expect(self, result, expected, tol):
-        assert hasattr(result, 'expect')
-        assert len(result.expect) == len(self.e_ops)
-        assert len(self.e_ops) == len(expected)
-        for test, expected_part in zip(result.expect, expected):
-            np.testing.assert_allclose(test, expected_part, rtol=tol)
-
-    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
-        options = {"store_states": True, "map": "serial"}
-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options=options, target_tol=0.05)
-        self._assert_expect(result, expected, tol)
-        self._assert_states(result, expected, tol)
-
-
-class TestNoCollapse(StatesAndExpectOutputCase):
-    """
-    Test that `mcsolve` correctly solves the system when there is a constant
-    Hamiltonian and no collapses.
-    """
-    def pytest_generate_tests(self, metafunc):
-        tol = 1e-8
-        expect = (qutip.expect(self.e_ops[0], self.state)
-                  * np.ones_like(self.times))
-        hamiltonian_types = [
-            (self.h, "Qobj"),
-            ([self.h], "list"),
-            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
-                           args= {'constant': 0}), "QobjEvo"),
-            (callable_qobj(self.h), "callable"),
-        ]
-        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
-                 for hamiltonian, id in hamiltonian_types]
-        metafunc.parametrize(
-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-            cases)
-
-    # Previously the "states_only" and "expect_only" tests were mixed in to
-    # every other test case.  We move them out into the simplest set so that
-    # their behaviour remains tested, but isn't repeated as often to keep test
-    # runtimes shorter.  The known-good cases are still tested in the other
-    # test cases, this is just testing the single-output behaviour.
-
-    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
-        options = {"store_states": True, "map": "serial"}
-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
-                         options=options)
-        self._assert_states(result, expected, tol)
-
-    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options={'map': 'serial'})
-        self._assert_expect(result, expected, tol)
-
-
-class TestConstantCollapse(StatesAndExpectOutputCase):
-    """
-    Test that `mcsolve` correctly solves the system when there is a constant
-    collapse operator.
-    """
-    def pytest_generate_tests(self, metafunc):
-        tol = 0.25
-        coupling = 0.2
-        expect = (qutip.expect(self.e_ops[0], self.state)
-                  * np.exp(-coupling * self.times))
-        collapse_op = qutip.destroy(self.size)
-        c_op_types = [
-            (np.sqrt(coupling)*collapse_op, {}, "constant"),
-            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
-            (callable_qobj(collapse_op, _return_constant),
-             {'constant': np.sqrt(coupling)}, "function"),
-        ]
-        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
-                 for c_op, args, id in c_op_types]
-        metafunc.parametrize(
-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-            cases)
-
-
-class TestTimeDependentCollapse(StatesAndExpectOutputCase):
-    """
-    Test that `mcsolve` correctly solves the system when the collapse operators
-    are time-dependent.
-    """
-    def pytest_generate_tests(self, metafunc):
-        tol = 0.25
-        coupling = 0.2
-        expect = (qutip.expect(self.e_ops[0], self.state)
-                  * np.exp(-coupling * (1 - np.exp(-self.times))))
-        collapse_op = qutip.destroy(self.size)
-        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
-        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
-        c_op_types = [
-            ([collapse_op, _return_decay], collapse_args, "function"),
-            ([collapse_op, collapse_string], {}, "string"),
-        ]
-        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
-                 for c_op, args, id in c_op_types]
-        metafunc.parametrize(
-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-            cases)
-
-
-def test_stored_collapse_operators_and_times():
-    """
-    Test that the output contains information on which collapses happened and
-    at what times, and make sure that this information makes sense.
-    """
-    size = 10
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 10, 100)
-    c_ops = [a, a]
-    result = mcsolve(H, state, times, c_ops, ntraj=3,
-                     options={'map': 'serial'})
-    assert len(result.col_times[0]) > 0
-    assert len(result.col_which) == len(result.col_times)
-    assert all(col in [0, 1] for col in result.col_which[0])
-
-
-@pytest.mark.parametrize('keep_runs_results', [True, False])
-def test_states_outputs(keep_runs_results):
-    # We're just testing the output value, so it's important whether certain
-    # things are complex or real, but not what the magnitudes of constants are.
-    focks = 5
-    ntraj = 5
-    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
-    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
-    H = 1j*a.dag()*sm + a
-    H = H + H.dag()
-    state = qutip.basis([focks, 2], [0, 1])
-    times = np.linspace(0, 10, 21)
-    c_ops = [a, sm]
-    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
-                   options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'})
-
-    assert len(data.average_states) == len(times)
-    assert isinstance(data.average_states[0], qutip.Qobj)
-    assert data.average_states[0].norm() == pytest.approx(1.)
-    assert data.average_states[0].isoper
-
-    assert isinstance(data.average_final_state, qutip.Qobj)
-    assert data.average_final_state.norm() == pytest.approx(1.)
-    assert data.average_final_state.isoper
-
-    assert isinstance(data.photocurrent[0][1], float)
-    assert isinstance(data.photocurrent[1][1], float)
-    assert (np.array(data.runs_photocurrent).shape
-        == (ntraj, len(c_ops), len(times)-1))
-
-    if keep_runs_results:
-        assert len(data.runs_states) == ntraj
-        assert len(data.runs_states[0]) == len(times)
-        assert isinstance(data.runs_states[0][0], qutip.Qobj)
-        assert data.runs_states[0][0].norm() == pytest.approx(1.)
-        assert data.runs_states[0][0].isket
-
-        assert len(data.runs_final_states) == ntraj
-        assert isinstance(data.runs_final_states[0], qutip.Qobj)
-        assert data.runs_final_states[0].norm() == pytest.approx(1.)
-        assert data.runs_final_states[0].isket
-
-    assert isinstance(data.steady_state(), qutip.Qobj)
-    assert data.steady_state().norm() == pytest.approx(1.)
-    assert data.steady_state().isoper
-
-    np.testing.assert_allclose(times, data.times)
-    assert data.num_trajectories == ntraj
-    assert len(data.e_ops) == 0
-    assert data.stats["num_collapse"] == len(c_ops)
-    assert len(data.col_times) == ntraj
-    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
-    assert data.stats['end_condition'] == "ntraj reached"
-
-
-@pytest.mark.parametrize('keep_runs_results', [True, False])
-def test_expectation_outputs(keep_runs_results):
-    # We're just testing the output value, so it's important whether certain
-    # things are complex or real, but not what the magnitudes of constants are.
-    focks = 5
-    ntraj = 5
-    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
-    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
-    H = 1j*a.dag()*sm + a
-    H = H + H.dag()
-    state = qutip.basis([focks, 2], [0, 1])
-    times = np.linspace(0, 10, 5)
-    c_ops = [a, sm]
-    e_ops = [a.dag()*a, sm.dag()*sm, a]
-    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                   options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'})
-    assert isinstance(data.average_expect[0][1], float)
-    assert isinstance(data.average_expect[1][1], float)
-    assert isinstance(data.average_expect[2][1], complex)
-    assert isinstance(data.std_expect[0][1], float)
-    assert isinstance(data.std_expect[1][1], float)
-    assert isinstance(data.std_expect[2][1], float)
-    if keep_runs_results:
-        assert len(data.runs_expect) == len(e_ops)
-        assert len(data.runs_expect[0]) == ntraj
-        assert isinstance(data.runs_expect[0][0][1], float)
-        assert isinstance(data.runs_expect[1][0][1], float)
-        assert isinstance(data.runs_expect[2][0][1], complex)
-    assert isinstance(data.photocurrent[0][0], float)
-    assert isinstance(data.photocurrent[1][0], float)
-    assert (np.array(data.runs_photocurrent).shape
-            == (ntraj, len(c_ops), len(times)-1))
-    np.testing.assert_allclose(times, data.times)
-    assert data.num_trajectories == ntraj
-    assert len(data.e_ops) == len(e_ops)
-    assert data.stats["num_collapse"] == len(c_ops)
-    assert len(data.col_times) == ntraj
-    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
-    assert data.stats['end_condition'] == "ntraj reached"
-
-
-class TestSeeds:
-    sizes = [6, 6, 6]
-    dampings = [0.1, 0.4, 0.1]
-    ntraj = 25  # Big enough to ensure there are differences without being slow
-    a = [qutip.destroy(size) for size in sizes]
-    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
-              - qutip.tensor(a[0].dag(), a[1], a[2]))
-    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
-                         qutip.basis(sizes[1:], [0, 0]))
-    times = np.linspace(0, 10, 2)
-    c_ops = [
-        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
-        (np.sqrt(2*dampings[1])
-         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
-        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
-    ]
-
-    def test_seeds_can_be_reused(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, **kwargs)
-        second = mcsolve(*args, seeds=first.seeds, **kwargs)
-        for first_t, second_t in zip(first.col_times, second.col_times):
-            np.testing.assert_equal(first_t, second_t)
-        for first_w, second_w in zip(first.col_which, second.col_which):
-            np.testing.assert_equal(first_w, second_w)
-
-    def test_seeds_are_not_reused_by_default(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, **kwargs)
-        second = mcsolve(*args, **kwargs)
-        assert not all(np.array_equal(first_t, second_t)
-                       for first_t, second_t in zip(first.col_times,
-                                                    second.col_times))
-        assert not all(np.array_equal(first_w, second_w)
-                       for first_w, second_w in zip(first.col_which,
-                                                    second.col_which))
-
-    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
-    def test_seed_type(self, seed):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, seeds=copy(seed), **kwargs)
-        second = mcsolve(*args, seeds=copy(seed), **kwargs)
-        for f_seed, s_seed in zip(first.seeds, second.seeds):
-            assert f_seed.state == s_seed.state
-
-    def test_bad_seed(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        with pytest.raises(ValueError):
-            first = mcsolve(*args, seeds=[1], **kwargs)
-
-    def test_generator(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
-                        **kwargs)
-        second = mcsolve(*args, seeds=1, **kwargs)
-        for f_seed, s_seed in zip(first.seeds, second.seeds):
-            assert f_seed.state == s_seed.state
-        assert not all(np.array_equal(first_t, second_t)
-                       for first_t, second_t in zip(first.col_times,
-                                                    second.col_times))
-        assert not all(np.array_equal(first_w, second_w)
-                       for first_w, second_w in zip(first.col_which,
-                                                    second.col_which))
-
-    def test_stepping(self):
-        size = 10
-        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
-        H = qutip.num(size)
-        mcsolver = MCSolver(H, a, options={'map': 'serial'})
-        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-        state_1 = mcsolver.step(1, args={'alpha':1})
-
-        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-        state_2 = mcsolver.step(1, args={'alpha':1})
-        assert state_1 == state_2
-
-
-def test_timeout():
-    size = 10
-    ntraj = 1000
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 1.0, 100)
-    coupling = 0.5
-    n_th = 0.05
-    c_ops = np.sqrt(coupling * (n_th + 1)) * a
-    e_ops = [qutip.num(size)]
-    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                  options={'map': 'serial'}, timeout=1e-6)
-    assert res.stats['end_condition'] == 'timeout'
-
-
-def test_super_H():
-    size = 10
-    ntraj = 1000
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 1.0, 100)
-    # Arbitrary coupling and bath temperature.
-    coupling = 0.5
-    n_th = 0.05
-    c_ops = np.sqrt(coupling * (n_th + 1)) * a
-    e_ops = [qutip.num(size)]
-    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                          target_tol=0.1, options={'map': 'serial'})
-    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
-                 target_tol=0.1, options={'map': 'serial'})
-    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
-
-
-def test_MCSolver_run():
-    size = 10
-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
-    H = qutip.num(size)
-    solver = MCSolver(H, a)
-    solver.options = {'store_final_state': True}
-    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
-                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
-    assert res.final_state is not None
-    assert len(res.collapse[0]) != 0
-    assert res.num_trajectories == 1
-    np.testing.assert_allclose(res.expect[0], np.ones(11))
-    res += solver.run(
-        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
-        e_ops=[qutip.qeye(size)], args={'coupling': 1},
-        ntraj=1000, target_tol=0.1
-    )
-    assert res.num_trajectories == 1001
-
-
-def test_MCSolver_stepping():
-    size = 10
-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
-    H = qutip.num(size)
-    solver = MCSolver(H, a)
-    solver.start(qutip.basis(size, size-1), 0, seed=0)
-    solver.options = {'method': 'lsoda'}
-    state = solver.step(1)
-    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
-    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
-    assert state.isket
-    state = solver.step(5, args={'coupling': 5})
-    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
-    assert qutip.expect(qutip.num(size), state) <= size - 1
-    assert state.isket
-
-
-# Defined in module-scope so it's pickleable.
-def _dynamic(t, args):
-    return 0 if args["collapse"] else 1
-
-
-@pytest.mark.xfail(reason="current limitation of McSolve")
-def test_dynamic_arguments():
-    """Test dynamically updated arguments are usable."""
-    size = 5
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    times = np.linspace(0, 1, 11)
-    state = qutip.basis(size, 2)
-
-    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
-    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
-    assert all(len(collapses) <= 1 for collapses in mc.col_which)
+import pytest
+import numpy as np
+import qutip
+from copy import copy
+from qutip.solver.mcsolve import mcsolve, MCSolver
+from qutip.solver.solver_base import Solver
+
+def _return_constant(t, args):
+    return args['constant']
+
+
+def _return_decay(t, args):
+    return args['constant'] * np.exp(-args['rate'] * t)
+
+
+class callable_qobj:
+    def __init__(self, oper, coeff=None):
+        self.oper = oper
+        self.coeff = coeff
+
+    def __call__(self, t, args):
+        if self.coeff is not None:
+            return self.oper * self.coeff(t, args)
+        return self.oper
+
+
+@pytest.mark.usefixtures("in_temporary_directory")
+class StatesAndExpectOutputCase:
+    """
+    Mixin class to test the states and expectation values from ``mcsolve``.
+    """
+    size = 10
+    h = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1, 101)
+    e_ops = [qutip.num(size)]
+    ntraj = 2000
+
+    def _assert_states(self, result, expected, tol):
+        assert hasattr(result, 'states')
+        assert len(result.states) == len(self.times)
+        assert len(self.e_ops) == len(expected)
+        for test_operator, expected_part in zip(self.e_ops, expected):
+            test = qutip.expect(test_operator, result.states)
+            np.testing.assert_allclose(test, expected_part, rtol=tol)
+
+    def _assert_expect(self, result, expected, tol):
+        assert hasattr(result, 'expect')
+        assert len(result.expect) == len(self.e_ops)
+        assert len(self.e_ops) == len(expected)
+        for test, expected_part in zip(result.expect, expected):
+            np.testing.assert_allclose(test, expected_part, rtol=tol)
+
+    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
+        options = {"store_states": True, "map": "serial"}
+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+                         options=options, target_tol=0.05)
+        self._assert_expect(result, expected, tol)
+        self._assert_states(result, expected, tol)
+
+
+class TestNoCollapse(StatesAndExpectOutputCase):
+    """
+    Test that `mcsolve` correctly solves the system when there is a constant
+    Hamiltonian and no collapses.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 1e-8
+        expect = (qutip.expect(self.e_ops[0], self.state)
+                  * np.ones_like(self.times))
+        hamiltonian_types = [
+            (self.h, "Qobj"),
+            ([self.h], "list"),
+            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
+                           args= {'constant': 0}), "QobjEvo"),
+            (callable_qobj(self.h), "callable"),
+        ]
+        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
+                 for hamiltonian, id in hamiltonian_types]
+        metafunc.parametrize(
+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+            cases)
+
+    # Previously the "states_only" and "expect_only" tests were mixed in to
+    # every other test case.  We move them out into the simplest set so that
+    # their behaviour remains tested, but isn't repeated as often to keep test
+    # runtimes shorter.  The known-good cases are still tested in the other
+    # test cases, this is just testing the single-output behaviour.
+
+    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
+        options = {"store_states": True, "map": "serial"}
+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
+                         options=options)
+        self._assert_states(result, expected, tol)
+
+    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+                         options={'map': 'serial'})
+        self._assert_expect(result, expected, tol)
+
+
+class TestConstantCollapse(StatesAndExpectOutputCase):
+    """
+    Test that `mcsolve` correctly solves the system when there is a constant
+    collapse operator.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 0.25
+        coupling = 0.2
+        expect = (qutip.expect(self.e_ops[0], self.state)
+                  * np.exp(-coupling * self.times))
+        collapse_op = qutip.destroy(self.size)
+        c_op_types = [
+            (np.sqrt(coupling)*collapse_op, {}, "constant"),
+            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
+            (callable_qobj(collapse_op, _return_constant),
+             {'constant': np.sqrt(coupling)}, "function"),
+        ]
+        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
+                 for c_op, args, id in c_op_types]
+        metafunc.parametrize(
+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+            cases)
+
+
+class TestTimeDependentCollapse(StatesAndExpectOutputCase):
+    """
+    Test that `mcsolve` correctly solves the system when the collapse operators
+    are time-dependent.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 0.25
+        coupling = 0.2
+        expect = (qutip.expect(self.e_ops[0], self.state)
+                  * np.exp(-coupling * (1 - np.exp(-self.times))))
+        collapse_op = qutip.destroy(self.size)
+        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
+        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
+        c_op_types = [
+            ([collapse_op, _return_decay], collapse_args, "function"),
+            ([collapse_op, collapse_string], {}, "string"),
+        ]
+        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
+                 for c_op, args, id in c_op_types]
+        metafunc.parametrize(
+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+            cases)
+
+
+def test_stored_collapse_operators_and_times():
+    """
+    Test that the output contains information on which collapses happened and
+    at what times, and make sure that this information makes sense.
+    """
+    size = 10
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 10, 100)
+    c_ops = [a, a]
+    result = mcsolve(H, state, times, c_ops, ntraj=3,
+                     options={'map': 'serial'})
+    assert len(result.col_times[0]) > 0
+    assert len(result.col_which) == len(result.col_times)
+    assert all(col in [0, 1] for col in result.col_which[0])
+
+
+@pytest.mark.parametrize('keep_runs_results', [True, False])
+def test_states_outputs(keep_runs_results):
+    # We're just testing the output value, so it's important whether certain
+    # things are complex or real, but not what the magnitudes of constants are.
+    focks = 5
+    ntraj = 5
+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+    H = 1j*a.dag()*sm + a
+    H = H + H.dag()
+    state = qutip.basis([focks, 2], [0, 1])
+    times = np.linspace(0, 10, 21)
+    c_ops = [a, sm]
+    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
+                   options={"keep_runs_results": keep_runs_results,
+                            'map': 'serial'})
+
+    assert len(data.average_states) == len(times)
+    assert isinstance(data.average_states[0], qutip.Qobj)
+    assert data.average_states[0].norm() == pytest.approx(1.)
+    assert data.average_states[0].isoper
+
+    assert isinstance(data.average_final_state, qutip.Qobj)
+    assert data.average_final_state.norm() == pytest.approx(1.)
+    assert data.average_final_state.isoper
+
+    assert isinstance(data.photocurrent[0][1], float)
+    assert isinstance(data.photocurrent[1][1], float)
+    assert (np.array(data.runs_photocurrent).shape
+        == (ntraj, len(c_ops), len(times)-1))
+
+    if keep_runs_results:
+        assert len(data.runs_states) == ntraj
+        assert len(data.runs_states[0]) == len(times)
+        assert isinstance(data.runs_states[0][0], qutip.Qobj)
+        assert data.runs_states[0][0].norm() == pytest.approx(1.)
+        assert data.runs_states[0][0].isket
+
+        assert len(data.runs_final_states) == ntraj
+        assert isinstance(data.runs_final_states[0], qutip.Qobj)
+        assert data.runs_final_states[0].norm() == pytest.approx(1.)
+        assert data.runs_final_states[0].isket
+
+    assert isinstance(data.steady_state(), qutip.Qobj)
+    assert data.steady_state().norm() == pytest.approx(1.)
+    assert data.steady_state().isoper
+
+    np.testing.assert_allclose(times, data.times)
+    assert data.num_trajectories == ntraj
+    assert len(data.e_ops) == 0
+    assert data.stats["num_collapse"] == len(c_ops)
+    assert len(data.col_times) == ntraj
+    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
+    assert data.stats['end_condition'] == "ntraj reached"
+
+
+@pytest.mark.parametrize('keep_runs_results', [True, False])
+def test_expectation_outputs(keep_runs_results):
+    # We're just testing the output value, so it's important whether certain
+    # things are complex or real, but not what the magnitudes of constants are.
+    focks = 5
+    ntraj = 5
+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+    H = 1j*a.dag()*sm + a
+    H = H + H.dag()
+    state = qutip.basis([focks, 2], [0, 1])
+    times = np.linspace(0, 10, 5)
+    c_ops = [a, sm]
+    e_ops = [a.dag()*a, sm.dag()*sm, a]
+    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+                   options={"keep_runs_results": keep_runs_results,
+                            'map': 'serial'})
+    assert isinstance(data.average_expect[0][1], float)
+    assert isinstance(data.average_expect[1][1], float)
+    assert isinstance(data.average_expect[2][1], complex)
+    assert isinstance(data.std_expect[0][1], float)
+    assert isinstance(data.std_expect[1][1], float)
+    assert isinstance(data.std_expect[2][1], float)
+    if keep_runs_results:
+        assert len(data.runs_expect) == len(e_ops)
+        assert len(data.runs_expect[0]) == ntraj
+        assert isinstance(data.runs_expect[0][0][1], float)
+        assert isinstance(data.runs_expect[1][0][1], float)
+        assert isinstance(data.runs_expect[2][0][1], complex)
+    assert isinstance(data.photocurrent[0][0], float)
+    assert isinstance(data.photocurrent[1][0], float)
+    assert (np.array(data.runs_photocurrent).shape
+            == (ntraj, len(c_ops), len(times)-1))
+    np.testing.assert_allclose(times, data.times)
+    assert data.num_trajectories == ntraj
+    assert len(data.e_ops) == len(e_ops)
+    assert data.stats["num_collapse"] == len(c_ops)
+    assert len(data.col_times) == ntraj
+    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
+    assert data.stats['end_condition'] == "ntraj reached"
+
+
+class TestSeeds:
+    sizes = [6, 6, 6]
+    dampings = [0.1, 0.4, 0.1]
+    ntraj = 25  # Big enough to ensure there are differences without being slow
+    a = [qutip.destroy(size) for size in sizes]
+    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
+              - qutip.tensor(a[0].dag(), a[1], a[2]))
+    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
+                         qutip.basis(sizes[1:], [0, 0]))
+    times = np.linspace(0, 10, 2)
+    c_ops = [
+        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
+        (np.sqrt(2*dampings[1])
+         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
+        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
+    ]
+
+    def test_seeds_can_be_reused(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, **kwargs)
+        second = mcsolve(*args, seeds=first.seeds, **kwargs)
+        for first_t, second_t in zip(first.col_times, second.col_times):
+            np.testing.assert_equal(first_t, second_t)
+        for first_w, second_w in zip(first.col_which, second.col_which):
+            np.testing.assert_equal(first_w, second_w)
+
+    def test_seeds_are_not_reused_by_default(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, **kwargs)
+        second = mcsolve(*args, **kwargs)
+        assert not all(np.array_equal(first_t, second_t)
+                       for first_t, second_t in zip(first.col_times,
+                                                    second.col_times))
+        assert not all(np.array_equal(first_w, second_w)
+                       for first_w, second_w in zip(first.col_which,
+                                                    second.col_which))
+
+    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
+    def test_seed_type(self, seed):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, seeds=copy(seed), **kwargs)
+        second = mcsolve(*args, seeds=copy(seed), **kwargs)
+        for f_seed, s_seed in zip(first.seeds, second.seeds):
+            assert f_seed.state == s_seed.state
+
+    def test_bad_seed(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        with pytest.raises(ValueError):
+            first = mcsolve(*args, seeds=[1], **kwargs)
+
+    def test_generator(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
+                        **kwargs)
+        second = mcsolve(*args, seeds=1, **kwargs)
+        for f_seed, s_seed in zip(first.seeds, second.seeds):
+            assert f_seed.state == s_seed.state
+        assert not all(np.array_equal(first_t, second_t)
+                       for first_t, second_t in zip(first.col_times,
+                                                    second.col_times))
+        assert not all(np.array_equal(first_w, second_w)
+                       for first_w, second_w in zip(first.col_which,
+                                                    second.col_which))
+
+    def test_stepping(self):
+        size = 10
+        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
+        H = qutip.num(size)
+        mcsolver = MCSolver(H, a, options={'map': 'serial'})
+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+        state_1 = mcsolver.step(1, args={'alpha':1})
+
+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+        state_2 = mcsolver.step(1, args={'alpha':1})
+        assert state_1 == state_2
+
+
+def test_timeout():
+    size = 10
+    ntraj = 1000
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1.0, 100)
+    coupling = 0.5
+    n_th = 0.05
+    c_ops = np.sqrt(coupling * (n_th + 1)) * a
+    e_ops = [qutip.num(size)]
+    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+                  options={'map': 'serial'}, timeout=1e-6)
+    assert res.stats['end_condition'] == 'timeout'
+
+
+def test_super_H():
+    size = 10
+    ntraj = 1000
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1.0, 100)
+    # Arbitrary coupling and bath temperature.
+    coupling = 0.5
+    n_th = 0.05
+    c_ops = np.sqrt(coupling * (n_th + 1)) * a
+    e_ops = [qutip.num(size)]
+    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+                          target_tol=0.1, options={'map': 'serial'})
+    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
+                 target_tol=0.1, options={'map': 'serial'})
+    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
+
+
+def test_MCSolver_run():
+    size = 10
+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+    H = qutip.num(size)
+    solver = MCSolver(H, a)
+    solver.options = {'store_final_state': True}
+    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
+    assert res.final_state is not None
+    assert len(res.collapse[0]) != 0
+    assert res.num_trajectories == 1
+    np.testing.assert_allclose(res.expect[0], np.ones(11))
+    res += solver.run(
+        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+        e_ops=[qutip.qeye(size)], args={'coupling': 1},
+        ntraj=1000, target_tol=0.1
+    )
+    assert res.num_trajectories == 1001
+
+
+def test_MCSolver_stepping():
+    size = 10
+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+    H = qutip.num(size)
+    solver = MCSolver(H, a)
+    solver.start(qutip.basis(size, size-1), 0, seed=0)
+    solver.options = {'method': 'lsoda'}
+    state = solver.step(1)
+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
+    assert state.isket
+    state = solver.step(5, args={'coupling': 5})
+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+    assert qutip.expect(qutip.num(size), state) <= size - 1
+    assert state.isket
+
+
+# Defined in module-scope so it's pickleable.
+def _dynamic(t, args):
+    return 0 if args["collapse"] else 1
+
+
+@pytest.mark.xfail(reason="current limitation of McSolve")
+def test_dynamic_arguments():
+    """Test dynamically updated arguments are usable."""
+    size = 5
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    times = np.linspace(0, 1, 11)
+    state = qutip.basis(size, 2)
+
+    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
+    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
+    assert all(len(collapses) <= 1 for collapses in mc.col_which)
diff --git a/qutip/tests/solver/test_mesolve.py b/qutip/tests/solver/test_mesolve.py
index 6f6bbab6c7..deb1247964 100644
--- a/qutip/tests/solver/test_mesolve.py
+++ b/qutip/tests/solver/test_mesolve.py
@@ -1,677 +1,677 @@
-import numpy as np
-from types import FunctionType
-
-import qutip
-from qutip.solver.mesolve import mesolve, MESolver
-from qutip.solver.solver_base import Solver
-import pickle
-import pytest
-
-all_ode_method = [
-    method for method, integrator in MESolver.avail_integrators().items()
-    if integrator.support_time_dependant
-]
-
-def fidelitycheck(out1, out2, rho0vec):
-    fid = np.zeros(len(out1.states))
-    for i, E in enumerate(out2.states):
-        rhot = qutip.vector_to_operator(E*rho0vec)
-        fid[i] = qutip.fidelity(out1.states[i], rhot)
-    return fid
-
-
-class TestMESolveDecay:
-    N = 10
-    a = qutip.destroy(N)
-    kappa = 0.2
-    tlist = np.linspace(0, 10, 201)
-    ada = a.dag() * a
-
-    @pytest.fixture(params=[
-        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
-        pytest.param([ada, '1'], id='Hlist_str'),
-        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
-        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
-        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
-                     id='func'),
-    ])
-    def H(self, request):
-        return request.param
-
-    @pytest.fixture(params=[
-        pytest.param(np.sqrt(kappa) * a,
-                     id='const'),
-        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
-                                      * qutip.destroy(10)),
-                     id='func'),
-        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
-                     id='list_func'),
-        pytest.param([a, 'sqrt(kappa)'],
-                     id='list_str'),
-        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
-                     id='list_array'),
-        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
-                     id='QobjEvo'),
-    ])
-    def cte_c_ops(self, request):
-        return request.param
-
-    @pytest.fixture(params=[
-        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
-                  id='list_func'),
-        pytest.param([a, 'sqrt(kappa * exp(-t))'],
-                  id='list_str'),
-        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
-                  id='list_array'),
-        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
-                          args={'kappa': kappa}),
-                  id='QobjEvo'),
-        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
-                                      qutip.destroy(10)),
-                     id='func'),
-    ])
-    def c_ops(self, request):
-        return request.param
-
-    c_ops_1 = c_ops
-
-    def testME_CteDecay(self, cte_c_ops):
-        "mesolve: simple constant decay"
-        me_error = 1e-6
-        H = self.a.dag() * self.a
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [cte_c_ops]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    @pytest.mark.parametrize('method',
-                             all_ode_method, ids=all_ode_method)
-    def testME_TDDecay(self, c_ops, method):
-        "mesolve: time-dependence as function list"
-        me_error = 1e-5
-        H = self.a.dag() * self.a
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [c_ops]
-        options = {"method": method, "progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-                         args={"kappa": self.kappa}, options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
-
-    def testME_2TDDecay(self, c_ops, c_ops_1):
-        "mesolve: time-dependence as function list"
-        me_error = 1e-5
-        H = self.a.dag() * self.a
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [c_ops, c_ops_1]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-2 * self.kappa *
-                                     (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    def testME_TDH_TDDecay(self, H, c_ops):
-        "mesolve: time-dependence as function list"
-        me_error = 5e-6
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [c_ops]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-self.kappa *
-                                     (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    def testME_TDH_longTDDecay(self, H, c_ops):
-        "mesolve: time-dependence as function list"
-        me_error = 2e-5
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        if isinstance(c_ops, FunctionType):
-            return
-        if isinstance(c_ops, qutip.QobjEvo):
-            c_op_list = [c_ops + c_ops]
-        else:
-            c_op_list = [[c_ops, c_ops]]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-4 * self.kappa *
-                                     (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    def testME_TDDecayUnitary(self, c_ops):
-        "mesolve: time-dependence as function list with super as init cond"
-        me_error = 5e-6
-
-        H = self.ada
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
-        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
-        options = {"progress_bar": None}
-        c_op_list = [c_ops]
-        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-
-        fid = fidelitycheck(out1, out2, rho0vec)
-        assert fid == pytest.approx(1., abs=me_error)
-
-    def testME_TDDecayliouvillian(self, c_ops):
-        "mesolve: time-dependence as function list with super as init cond"
-        me_error = 5e-6
-
-        H = self.ada
-        L = qutip.liouvillian(H)
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
-        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
-        options = {"progress_bar": None}
-        c_op_list = [c_ops]
-        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-
-        fid = fidelitycheck(out1, out2, rho0vec)
-        assert fid == pytest.approx(1., abs=me_error)
-
-    @pytest.mark.parametrize(['state_type'], [
-        pytest.param("ket", id="ket"),
-        pytest.param("dm", id="dm"),
-        pytest.param("unitary", id="unitary"),
-    ])
-    def test_mesolve_normalization(self, state_type):
-        # non-hermitean H causes state to evolve non-unitarily
-        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
-        H = qutip.sprepost(H, H) # ensure use of MeSolve
-        psi0 = qutip.basis(2, 0)
-        options = {"normalize_output": True, "progress_bar": None}
-
-        if state_type in {"ket", "dm"}:
-            if state_type == "dm":
-                psi0 = qutip.ket2dm(psi0)
-            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            np.testing.assert_allclose(
-                norms, [1.0 for _ in self.tlist], atol=1e-15,
-            )
-        else:
-            # evolution of unitaries should not be normalized
-            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
-            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            assert all(norm > 4 for norm in norms[1:])
-
-    def test_mesolver_pickling(self):
-        options = {"progress_bar": None}
-        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
-        solver_copy = pickle.loads(pickle.dumps(solver_obj))
-        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
-                            e_ops=[self.ada]).expect[0]
-        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
-                            e_ops=[self.ada]).expect[0]
-        np.testing.assert_allclose(e1, e2)
-
-    @pytest.mark.parametrize('method',
-                             all_ode_method, ids=all_ode_method)
-    def test_mesolver_stepping(self, method):
-        options = {"method": method, "progress_bar": None}
-        solver_obj = MESolver(
-            self.ada,
-            c_ops=qutip.QobjEvo(
-                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
-                args={'kappa': 1.}
-            ),
-            options=options
-        )
-        solver_obj.start(qutip.basis(self.N, 9), 0)
-        state1 = solver_obj.step(1)
-        assert qutip.expect(self.ada, state1) != (
-            qutip.expect(self.ada, qutip.basis(self.N, 9))
-        )
-        state2 = solver_obj.step(2, args={"kappa":0.})
-        np.testing.assert_allclose(qutip.expect(self.ada, state1),
-                                   qutip.expect(self.ada, state2), 1e-6)
-
-
-@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
-                         ids=["ket", "dm", "liouvillian"])
-def testME_SesolveFallback(super_):
-    "mesolve: final_state has correct dims"
-    N = 5
-    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
-    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
-    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
-    psi0 = qutip.tensor(qutip.basis(N+1,0),
-                        qutip.basis(N+1,0),
-                        qutip.basis(N+1,N))
-    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
-    if super_ == "dm":
-        state0 = qutip.ket2dm(psi0)
-    else:
-        state0 = psi0
-    if super_ == "liouvillian":
-        H = qutip.liouvillian(H)
-
-    times = np.linspace(0.0, 0.1, 3)
-    options = {
-        "store_states": False,
-        "store_final_state": True,
-        "progress_bar": None
-    }
-    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
-    if super_ == "ket":
-        assert result.final_state.dims == psi0.dims
-    else:
-        assert result.final_state.dims == qutip.ket2dm(psi0).dims
-
-
-class TestJCModelEvolution:
-    """
-    A test class for the QuTiP functions for the evolution of JC model
-    """
-    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
-
-        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
-
-        c_op_list = []
-
-        rate = g1
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
-
-        rate = g2
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
-
-        output = mesolve(H, psi0, tlist, c_op_list,
-            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-        )
-
-        return output.expect[0], output.expect[1], output.expect[2]
-
-    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
-                       pump, psi0, use_rwa, tlist):
-
-        # Hamiltonian
-        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
-        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
-
-        if use_rwa:
-            # use the rotating wave approxiation
-            H = (wc * a.dag() * a + wa * sm.dag() * sm
-                 + g * (a.dag() * sm + a * sm.dag()))
-        else:
-            H = (wc * a.dag() * a + wa * sm.dag() * sm
-                 + g * (a.dag() + a) * (sm + sm.dag()))
-
-        # collapse operators
-        c_op_list = []
-
-        n_th_a = 0.0  # zero temperature
-
-        rate = kappa * (1 + n_th_a)
-        c_op_list.append(np.sqrt(rate) * a)
-
-        rate = kappa * n_th_a
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * a.dag())
-
-        rate = gamma
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm)
-
-        rate = pump
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm.dag())
-
-        # find the steady state
-        rho_ss = qutip.steadystate(H, c_op_list)
-
-        return (qutip.expect(a.dag() * a, rho_ss),
-                qutip.expect(sm.dag() * sm, rho_ss))
-
-    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
-                     pump, psi0, use_rwa, tlist, oper_evo=False):
-
-        # Hamiltonian
-        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
-        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
-
-        # Identity super-operator
-        E0 = qutip.sprepost(
-            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
-            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
-        )
-
-        if use_rwa:
-            # use the rotating wave approxiation
-            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
-                a.dag() * sm + a * sm.dag())
-        else:
-            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
-                a.dag() + a) * (sm + sm.dag())
-
-        # collapse operators
-        c_op_list = []
-
-        n_th_a = 0.0  # zero temperature
-
-        rate = kappa * (1 + n_th_a)
-        c_op_list.append(np.sqrt(rate) * a)
-
-        rate = kappa * n_th_a
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * a.dag())
-
-        rate = gamma
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm)
-
-        rate = pump
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm.dag())
-
-        options = {"store_states": True, "progress_bar": None}
-
-        # evolve and calculate expectation values
-        output = mesolve(
-            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
-            options=options)
-        if oper_evo:
-            output2 = mesolve(H, E0, tlist, c_op_list, [])
-            return output, output2
-        return output.expect[0], output.expect[1]
-
-    def testSuperJC(self):
-        "mesolve: super vs. density matrix as initial condition"
-        me_error = 1e-6
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.1   # coupling strength
-        kappa = 0.05    # cavity dissipation rate
-        gamma = 0.001   # atom dissipation rate
-        pump = 0.25    # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.basis([N, 2], [n, 1])
-        rho0vec = qutip.operator_to_vector(psi0.proj())
-        tlist = np.linspace(0, 100, 50)
-
-        out1, out2 = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
-
-        fid = fidelitycheck(out1, out2, rho0vec)
-        assert fid == pytest.approx(1., abs=me_error)
-
-    def testQubitDynamics1(self):
-        "mesolve: qubit with dissipation"
-
-        epsilon = 0.0 * 2 * np.pi   # cavity frequency
-        delta = 1.0 * 2 * np.pi   # atom frequency
-        g2 = 0.1
-        g1 = 0.0
-        psi0 = qutip.basis(2, 0)        # initial state
-        tlist = np.linspace(0, 5, 200)
-
-        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
-
-        sx_analytic = np.zeros(np.shape(tlist))
-        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
-        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
-        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
-
-    def testQubitDynamics2(self):
-        "mesolve: qubit without dissipation"
-
-        epsilon = 0.0 * 2 * np.pi   # cavity frequency
-        delta = 1.0 * 2 * np.pi   # atom frequency
-        g2 = 0.0
-        g1 = 0.0
-        psi0 = qutip.basis(2, 0)        # initial state
-        tlist = np.linspace(0, 5, 200)
-
-        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
-
-        sx_analytic = np.zeros(np.shape(tlist))
-        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
-        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
-        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
-
-    def testCavity1(self):
-        "mesolve: cavity-qubit interaction, no dissipation"
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.01   # coupling strength
-        kappa = 0.0     # cavity dissipation rate
-        gamma = 0.0     # atom dissipation rate
-        pump = 0.0      # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-        tlist = np.linspace(0, 1000, 2000)
-
-        nc, na = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
-        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
-
-        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
-        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
-
-    def testCavity2(self):
-        "mesolve: cavity-qubit without interaction, decay"
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.0    # coupling strength
-        kappa = 0.005   # cavity dissipation rate
-        gamma = 0.01    # atom dissipation rate
-        pump = 0.0      # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-        tlist = np.linspace(0, 1000, 2000)
-
-        nc, na = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
-            np.exp(-kappa * tlist)
-        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
-            np.exp(-gamma * tlist)
-
-        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
-        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
-
-    def testCavity3(self):
-        "mesolve: cavity-qubit with interaction, decay"
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.1   # coupling strength
-        kappa = 0.05    # cavity dissipation rate
-        gamma = 0.001   # atom dissipation rate
-        pump = 0.25    # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-        tlist = np.linspace(0, 200, 500)
-
-        nc, na = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        # we don't have any analytics for this parameters, so
-        # compare with the steady state
-        nc_ss, na_ss = self.jc_steadystate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        nc_ss = nc_ss * np.ones(np.shape(nc))
-        na_ss = na_ss * np.ones(np.shape(na))
-
-        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
-        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
-
-
-class TestMESolveStepFuncCoeff:
-    """
-    A Test class for using time-dependent array coefficients
-    as step functions instead of doing interpolation
-    """
-    # Runge-Kutta method (dop853) behave better with step function evolution
-    # than multi-step methods (adams, qutip 4's default)
-    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
-
-    def python_coeff(self, t, args):
-        if t < np.pi/2:
-            return 1.
-        else:
-            return 0.
-
-    @pytest.mark.parametrize('method',
-                             all_ode_method, ids=all_ode_method)
-    def test_py_coeff(self, method):
-        """
-        Test for Python function as coefficient as step function coeff
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0, np.pi/2])
-        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
-        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
-                     tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_cte_coeff(self):
-        """
-        Test for Array coefficient with uniform tlist as step function coeff
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
-        npcoeff = np.array([0.25, 0.75, 0.75])
-        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_t_coeff(self):
-        """
-        Test for Array with non-uniform tlist as step function coeff
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
-        npcoeff = np.array([0.5, 0.25, 0.25])
-        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_str_coeff(self):
-        """
-        Test for Array and string as step function coeff.
-        qobjevo_codegen is used and uniform tlist
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
-        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
-        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
-        strcoeff = "1."
-        qu = qutip.QobjEvo(
-            [[qutip.sigmax(), npcoeff1],
-             [qutip.sigmax(), strcoeff],
-             [qutip.sigmax(), npcoeff2]],
-            tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_str_py_coeff(self):
-        """
-        Test for Array, string and Python function as step function coeff.
-        qobjevo_codegen is used and non non-uniform tlist
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
-        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
-        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
-        strcoeff = "1."
-        qu = qutip.QobjEvo(
-            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
-             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
-            tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-
-def test_num_collapse_set():
-    H = qutip.sigmaz()
-    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-    ts = [0, 1]
-    for c_ops in (
-        qutip.sigmax(),
-        [qutip.sigmax()],
-        [qutip.sigmay(), qutip.sigmax()],
-    ):
-        res = mesolve(H, psi, ts, c_ops=c_ops)
-        if not isinstance(c_ops, list):
-            c_ops = [c_ops]
-        assert res.stats["num_collapse"] == len(c_ops)
-
-
-def test_mesolve_bad_H():
-    with pytest.raises(TypeError):
-        MESolver([qutip.qeye(3), 't'], [])
-    with pytest.raises(TypeError):
-        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
-
-
-def test_mesolve_bad_state():
-    solver = MESolver(qutip.qeye(4), [])
-    with pytest.raises(TypeError):
-        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
-
-
-def test_mesolve_bad_options():
-    with pytest.raises(TypeError):
-        MESolver(qutip.qeye(4), [], options=False)
+import numpy as np
+from types import FunctionType
+
+import qutip
+from qutip.solver.mesolve import mesolve, MESolver
+from qutip.solver.solver_base import Solver
+import pickle
+import pytest
+
+all_ode_method = [
+    method for method, integrator in MESolver.avail_integrators().items()
+    if integrator.support_time_dependant
+]
+
+def fidelitycheck(out1, out2, rho0vec):
+    fid = np.zeros(len(out1.states))
+    for i, E in enumerate(out2.states):
+        rhot = qutip.vector_to_operator(E*rho0vec)
+        fid[i] = qutip.fidelity(out1.states[i], rhot)
+    return fid
+
+
+class TestMESolveDecay:
+    N = 10
+    a = qutip.destroy(N)
+    kappa = 0.2
+    tlist = np.linspace(0, 10, 201)
+    ada = a.dag() * a
+
+    @pytest.fixture(params=[
+        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
+        pytest.param([ada, '1'], id='Hlist_str'),
+        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
+        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
+        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
+                     id='func'),
+    ])
+    def H(self, request):
+        return request.param
+
+    @pytest.fixture(params=[
+        pytest.param(np.sqrt(kappa) * a,
+                     id='const'),
+        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
+                                      * qutip.destroy(10)),
+                     id='func'),
+        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
+                     id='list_func'),
+        pytest.param([a, 'sqrt(kappa)'],
+                     id='list_str'),
+        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
+                     id='list_array'),
+        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
+                     id='QobjEvo'),
+    ])
+    def cte_c_ops(self, request):
+        return request.param
+
+    @pytest.fixture(params=[
+        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
+                  id='list_func'),
+        pytest.param([a, 'sqrt(kappa * exp(-t))'],
+                  id='list_str'),
+        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
+                  id='list_array'),
+        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
+                          args={'kappa': kappa}),
+                  id='QobjEvo'),
+        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
+                                      qutip.destroy(10)),
+                     id='func'),
+    ])
+    def c_ops(self, request):
+        return request.param
+
+    c_ops_1 = c_ops
+
+    def testME_CteDecay(self, cte_c_ops):
+        "mesolve: simple constant decay"
+        me_error = 1e-6
+        H = self.a.dag() * self.a
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [cte_c_ops]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    @pytest.mark.parametrize('method',
+                             all_ode_method, ids=all_ode_method)
+    def testME_TDDecay(self, c_ops, method):
+        "mesolve: time-dependence as function list"
+        me_error = 1e-5
+        H = self.a.dag() * self.a
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [c_ops]
+        options = {"method": method, "progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+                         args={"kappa": self.kappa}, options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
+
+    def testME_2TDDecay(self, c_ops, c_ops_1):
+        "mesolve: time-dependence as function list"
+        me_error = 1e-5
+        H = self.a.dag() * self.a
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [c_ops, c_ops_1]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-2 * self.kappa *
+                                     (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    def testME_TDH_TDDecay(self, H, c_ops):
+        "mesolve: time-dependence as function list"
+        me_error = 5e-6
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [c_ops]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-self.kappa *
+                                     (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    def testME_TDH_longTDDecay(self, H, c_ops):
+        "mesolve: time-dependence as function list"
+        me_error = 2e-5
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        if isinstance(c_ops, FunctionType):
+            return
+        if isinstance(c_ops, qutip.QobjEvo):
+            c_op_list = [c_ops + c_ops]
+        else:
+            c_op_list = [[c_ops, c_ops]]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-4 * self.kappa *
+                                     (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    def testME_TDDecayUnitary(self, c_ops):
+        "mesolve: time-dependence as function list with super as init cond"
+        me_error = 5e-6
+
+        H = self.ada
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
+        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
+        options = {"progress_bar": None}
+        c_op_list = [c_ops]
+        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+
+        fid = fidelitycheck(out1, out2, rho0vec)
+        assert fid == pytest.approx(1., abs=me_error)
+
+    def testME_TDDecayliouvillian(self, c_ops):
+        "mesolve: time-dependence as function list with super as init cond"
+        me_error = 5e-6
+
+        H = self.ada
+        L = qutip.liouvillian(H)
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
+        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
+        options = {"progress_bar": None}
+        c_op_list = [c_ops]
+        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+
+        fid = fidelitycheck(out1, out2, rho0vec)
+        assert fid == pytest.approx(1., abs=me_error)
+
+    @pytest.mark.parametrize(['state_type'], [
+        pytest.param("ket", id="ket"),
+        pytest.param("dm", id="dm"),
+        pytest.param("unitary", id="unitary"),
+    ])
+    def test_mesolve_normalization(self, state_type):
+        # non-hermitean H causes state to evolve non-unitarily
+        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
+        H = qutip.sprepost(H, H) # ensure use of MeSolve
+        psi0 = qutip.basis(2, 0)
+        options = {"normalize_output": True, "progress_bar": None}
+
+        if state_type in {"ket", "dm"}:
+            if state_type == "dm":
+                psi0 = qutip.ket2dm(psi0)
+            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            np.testing.assert_allclose(
+                norms, [1.0 for _ in self.tlist], atol=1e-15,
+            )
+        else:
+            # evolution of unitaries should not be normalized
+            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
+            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            assert all(norm > 4 for norm in norms[1:])
+
+    def test_mesolver_pickling(self):
+        options = {"progress_bar": None}
+        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
+        solver_copy = pickle.loads(pickle.dumps(solver_obj))
+        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
+                            e_ops=[self.ada]).expect[0]
+        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
+                            e_ops=[self.ada]).expect[0]
+        np.testing.assert_allclose(e1, e2)
+
+    @pytest.mark.parametrize('method',
+                             all_ode_method, ids=all_ode_method)
+    def test_mesolver_stepping(self, method):
+        options = {"method": method, "progress_bar": None}
+        solver_obj = MESolver(
+            self.ada,
+            c_ops=qutip.QobjEvo(
+                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
+                args={'kappa': 1.}
+            ),
+            options=options
+        )
+        solver_obj.start(qutip.basis(self.N, 9), 0)
+        state1 = solver_obj.step(1)
+        assert qutip.expect(self.ada, state1) != (
+            qutip.expect(self.ada, qutip.basis(self.N, 9))
+        )
+        state2 = solver_obj.step(2, args={"kappa":0.})
+        np.testing.assert_allclose(qutip.expect(self.ada, state1),
+                                   qutip.expect(self.ada, state2), 1e-6)
+
+
+@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
+                         ids=["ket", "dm", "liouvillian"])
+def testME_SesolveFallback(super_):
+    "mesolve: final_state has correct dims"
+    N = 5
+    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
+    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
+    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
+    psi0 = qutip.tensor(qutip.basis(N+1,0),
+                        qutip.basis(N+1,0),
+                        qutip.basis(N+1,N))
+    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
+    if super_ == "dm":
+        state0 = qutip.ket2dm(psi0)
+    else:
+        state0 = psi0
+    if super_ == "liouvillian":
+        H = qutip.liouvillian(H)
+
+    times = np.linspace(0.0, 0.1, 3)
+    options = {
+        "store_states": False,
+        "store_final_state": True,
+        "progress_bar": None
+    }
+    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
+    if super_ == "ket":
+        assert result.final_state.dims == psi0.dims
+    else:
+        assert result.final_state.dims == qutip.ket2dm(psi0).dims
+
+
+class TestJCModelEvolution:
+    """
+    A test class for the QuTiP functions for the evolution of JC model
+    """
+    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
+
+        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
+
+        c_op_list = []
+
+        rate = g1
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
+
+        rate = g2
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
+
+        output = mesolve(H, psi0, tlist, c_op_list,
+            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+        )
+
+        return output.expect[0], output.expect[1], output.expect[2]
+
+    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
+                       pump, psi0, use_rwa, tlist):
+
+        # Hamiltonian
+        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
+        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
+
+        if use_rwa:
+            # use the rotating wave approxiation
+            H = (wc * a.dag() * a + wa * sm.dag() * sm
+                 + g * (a.dag() * sm + a * sm.dag()))
+        else:
+            H = (wc * a.dag() * a + wa * sm.dag() * sm
+                 + g * (a.dag() + a) * (sm + sm.dag()))
+
+        # collapse operators
+        c_op_list = []
+
+        n_th_a = 0.0  # zero temperature
+
+        rate = kappa * (1 + n_th_a)
+        c_op_list.append(np.sqrt(rate) * a)
+
+        rate = kappa * n_th_a
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * a.dag())
+
+        rate = gamma
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm)
+
+        rate = pump
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm.dag())
+
+        # find the steady state
+        rho_ss = qutip.steadystate(H, c_op_list)
+
+        return (qutip.expect(a.dag() * a, rho_ss),
+                qutip.expect(sm.dag() * sm, rho_ss))
+
+    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
+                     pump, psi0, use_rwa, tlist, oper_evo=False):
+
+        # Hamiltonian
+        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
+        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
+
+        # Identity super-operator
+        E0 = qutip.sprepost(
+            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
+            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
+        )
+
+        if use_rwa:
+            # use the rotating wave approxiation
+            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
+                a.dag() * sm + a * sm.dag())
+        else:
+            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
+                a.dag() + a) * (sm + sm.dag())
+
+        # collapse operators
+        c_op_list = []
+
+        n_th_a = 0.0  # zero temperature
+
+        rate = kappa * (1 + n_th_a)
+        c_op_list.append(np.sqrt(rate) * a)
+
+        rate = kappa * n_th_a
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * a.dag())
+
+        rate = gamma
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm)
+
+        rate = pump
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm.dag())
+
+        options = {"store_states": True, "progress_bar": None}
+
+        # evolve and calculate expectation values
+        output = mesolve(
+            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
+            options=options)
+        if oper_evo:
+            output2 = mesolve(H, E0, tlist, c_op_list, [])
+            return output, output2
+        return output.expect[0], output.expect[1]
+
+    def testSuperJC(self):
+        "mesolve: super vs. density matrix as initial condition"
+        me_error = 1e-6
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.1   # coupling strength
+        kappa = 0.05    # cavity dissipation rate
+        gamma = 0.001   # atom dissipation rate
+        pump = 0.25    # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.basis([N, 2], [n, 1])
+        rho0vec = qutip.operator_to_vector(psi0.proj())
+        tlist = np.linspace(0, 100, 50)
+
+        out1, out2 = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
+
+        fid = fidelitycheck(out1, out2, rho0vec)
+        assert fid == pytest.approx(1., abs=me_error)
+
+    def testQubitDynamics1(self):
+        "mesolve: qubit with dissipation"
+
+        epsilon = 0.0 * 2 * np.pi   # cavity frequency
+        delta = 1.0 * 2 * np.pi   # atom frequency
+        g2 = 0.1
+        g1 = 0.0
+        psi0 = qutip.basis(2, 0)        # initial state
+        tlist = np.linspace(0, 5, 200)
+
+        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
+
+        sx_analytic = np.zeros(np.shape(tlist))
+        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
+        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
+        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
+
+    def testQubitDynamics2(self):
+        "mesolve: qubit without dissipation"
+
+        epsilon = 0.0 * 2 * np.pi   # cavity frequency
+        delta = 1.0 * 2 * np.pi   # atom frequency
+        g2 = 0.0
+        g1 = 0.0
+        psi0 = qutip.basis(2, 0)        # initial state
+        tlist = np.linspace(0, 5, 200)
+
+        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
+
+        sx_analytic = np.zeros(np.shape(tlist))
+        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
+        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
+        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
+
+    def testCavity1(self):
+        "mesolve: cavity-qubit interaction, no dissipation"
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.01   # coupling strength
+        kappa = 0.0     # cavity dissipation rate
+        gamma = 0.0     # atom dissipation rate
+        pump = 0.0      # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+        tlist = np.linspace(0, 1000, 2000)
+
+        nc, na = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
+        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
+
+        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
+        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
+
+    def testCavity2(self):
+        "mesolve: cavity-qubit without interaction, decay"
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.0    # coupling strength
+        kappa = 0.005   # cavity dissipation rate
+        gamma = 0.01    # atom dissipation rate
+        pump = 0.0      # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+        tlist = np.linspace(0, 1000, 2000)
+
+        nc, na = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
+            np.exp(-kappa * tlist)
+        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
+            np.exp(-gamma * tlist)
+
+        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
+        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
+
+    def testCavity3(self):
+        "mesolve: cavity-qubit with interaction, decay"
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.1   # coupling strength
+        kappa = 0.05    # cavity dissipation rate
+        gamma = 0.001   # atom dissipation rate
+        pump = 0.25    # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+        tlist = np.linspace(0, 200, 500)
+
+        nc, na = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        # we don't have any analytics for this parameters, so
+        # compare with the steady state
+        nc_ss, na_ss = self.jc_steadystate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        nc_ss = nc_ss * np.ones(np.shape(nc))
+        na_ss = na_ss * np.ones(np.shape(na))
+
+        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
+        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
+
+
+class TestMESolveStepFuncCoeff:
+    """
+    A Test class for using time-dependent array coefficients
+    as step functions instead of doing interpolation
+    """
+    # Runge-Kutta method (dop853) behave better with step function evolution
+    # than multi-step methods (adams, qutip 4's default)
+    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
+
+    def python_coeff(self, t, args):
+        if t < np.pi/2:
+            return 1.
+        else:
+            return 0.
+
+    @pytest.mark.parametrize('method',
+                             all_ode_method, ids=all_ode_method)
+    def test_py_coeff(self, method):
+        """
+        Test for Python function as coefficient as step function coeff
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0, np.pi/2])
+        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
+        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
+                     tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_cte_coeff(self):
+        """
+        Test for Array coefficient with uniform tlist as step function coeff
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
+        npcoeff = np.array([0.25, 0.75, 0.75])
+        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_t_coeff(self):
+        """
+        Test for Array with non-uniform tlist as step function coeff
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
+        npcoeff = np.array([0.5, 0.25, 0.25])
+        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_str_coeff(self):
+        """
+        Test for Array and string as step function coeff.
+        qobjevo_codegen is used and uniform tlist
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
+        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
+        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
+        strcoeff = "1."
+        qu = qutip.QobjEvo(
+            [[qutip.sigmax(), npcoeff1],
+             [qutip.sigmax(), strcoeff],
+             [qutip.sigmax(), npcoeff2]],
+            tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_str_py_coeff(self):
+        """
+        Test for Array, string and Python function as step function coeff.
+        qobjevo_codegen is used and non non-uniform tlist
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
+        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
+        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
+        strcoeff = "1."
+        qu = qutip.QobjEvo(
+            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
+             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
+            tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+
+def test_num_collapse_set():
+    H = qutip.sigmaz()
+    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    ts = [0, 1]
+    for c_ops in (
+        qutip.sigmax(),
+        [qutip.sigmax()],
+        [qutip.sigmay(), qutip.sigmax()],
+    ):
+        res = mesolve(H, psi, ts, c_ops=c_ops)
+        if not isinstance(c_ops, list):
+            c_ops = [c_ops]
+        assert res.stats["num_collapse"] == len(c_ops)
+
+
+def test_mesolve_bad_H():
+    with pytest.raises(TypeError):
+        MESolver([qutip.qeye(3), 't'], [])
+    with pytest.raises(TypeError):
+        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
+
+
+def test_mesolve_bad_state():
+    solver = MESolver(qutip.qeye(4), [])
+    with pytest.raises(TypeError):
+        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
+
+
+def test_mesolve_bad_options():
+    with pytest.raises(TypeError):
+        MESolver(qutip.qeye(4), [], options=False)
diff --git a/qutip/tests/solver/test_options.py b/qutip/tests/solver/test_options.py
index 5f75405b1c..7337db1c92 100644
--- a/qutip/tests/solver/test_options.py
+++ b/qutip/tests/solver/test_options.py
@@ -1,142 +1,142 @@
-import pytest
-import qutip
-import numpy as np
-from qutip.solver.options import _SolverOptions
-
-
-default = {
-    "opt1": False,
-    "opt2": True,
-    "opt3": None,
-}
-
-
-def test_default():
-    opt = _SolverOptions(default)
-    assert opt
-    assert default.keys() == opt.keys()
-    assert opt["opt1"] is False
-    assert opt["opt2"] is True
-    assert opt["opt3"] is None
-
-
-def test_SolverOptions_dictlike():
-    opt_dict = {
-        "opt1": True,
-        "opt2": None,
-    }
-    opt = _SolverOptions(default, **opt_dict)
-    assert opt
-    assert default.keys() == opt.keys()
-    assert opt["opt1"] is True
-    assert opt["opt2"] is None
-    assert opt["opt3"] is None
-
-    copy = opt.copy()
-    assert opt.items() == copy.items()
-    copy['opt3'] = 2
-    assert opt.items() != copy.items()
-
-    assert len(opt.values()) == 3
-    assert len(opt.items()) == 3
-    assert len(opt.keys()) == 3
-
-
-def test_del():
-    opt_dict = {
-        "opt1": True,
-    }
-    opt = _SolverOptions(default, opt1=True)
-    del opt["opt1"]
-    assert opt["opt1"] is False
-
-
-def test_SolverOptions_Feedback():
-    called = []
-
-    def _catch(keys):
-        assert isinstance(keys, (set, str))
-        called.append(keys)
-
-    opt = _SolverOptions(default, _catch)
-    opt["opt1"] = 2
-    opt["opt2"] = 1e-5
-
-    assert "opt1" in called
-    assert "opt2" in called
-    assert len(called) == 2
-
-
-def test_error():
-    with pytest.raises(KeyError) as err:
-        _SolverOptions(default, opt4=4)
-    assert "opt4" in str(err.value)
-
-    with pytest.raises(KeyError) as err:
-        opt = _SolverOptions(default)
-        opt["opt4"] = 4
-    assert "opt4" in str(err.value)
-
-
-def test_print():
-    opt = _SolverOptions(default, None, "Test options", "Custom doc")
-    assert "Test options" in opt.__str__()
-    assert "opt1 : False" in opt.__str__()
-    assert "opt2 : True" in opt.__str__()
-    assert "opt3 : None" in opt.__str__()
-    assert opt.__doc__ == "Custom doc"
-
-
-def test_in_solver():
-    opt = {"method": "adams", "store_states": True, "atol": 1}
-    solver = qutip.SESolver(qutip.qeye(1), options=opt)
-    adams = qutip.integrator.IntegratorScipyAdams
-    lsoda = qutip.integrator.IntegratorScipylsoda
-    bdf = qutip.integrator.IntegratorScipyBDF
-    assert solver.options["store_states"] is True
-    assert solver.options["method"] == "adams"
-    assert solver.options["atol"] == 1
-    assert solver.options["order"] == adams.integrator_options["order"]
-
-    solver.options["method"] = "bdf"
-    assert solver.options["store_states"] is True
-    assert solver.options["method"] == "bdf"
-    assert solver.options["atol"] == bdf.integrator_options["atol"]
-    assert solver.options["order"] == bdf.integrator_options["order"]
-
-    solver.options = {
-        "method": "vern7",
-        "store_final_state": True,
-        "atol": 0.01
-    }
-    assert solver.options["store_states"] is True
-    assert solver.options["store_final_state"] is True
-    assert solver.options["method"] == "vern7"
-    assert solver.options["atol"] == 0.01
-    assert "order" not in solver.options
-    assert "interpolate" in solver.options
-
-
-def test_options_update_solver():
-    opt = {"method": "adams", "normalize_output": False}
-    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
-
-    solver.start(qutip.basis(1), 0)
-    err_atol_def = (solver.step(1) - np.exp(1)).norm()
-
-    solver.options["atol"] = 1
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
-
-    del solver.options["atol"]
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
-
-    solver.options["atol"] = 1
-    solver.options["atol"] = None
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
-
-    solver.options["method"] = "diag"
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
+import pytest
+import qutip
+import numpy as np
+from qutip.solver.options import _SolverOptions
+
+
+default = {
+    "opt1": False,
+    "opt2": True,
+    "opt3": None,
+}
+
+
+def test_default():
+    opt = _SolverOptions(default)
+    assert opt
+    assert default.keys() == opt.keys()
+    assert opt["opt1"] is False
+    assert opt["opt2"] is True
+    assert opt["opt3"] is None
+
+
+def test_SolverOptions_dictlike():
+    opt_dict = {
+        "opt1": True,
+        "opt2": None,
+    }
+    opt = _SolverOptions(default, **opt_dict)
+    assert opt
+    assert default.keys() == opt.keys()
+    assert opt["opt1"] is True
+    assert opt["opt2"] is None
+    assert opt["opt3"] is None
+
+    copy = opt.copy()
+    assert opt.items() == copy.items()
+    copy['opt3'] = 2
+    assert opt.items() != copy.items()
+
+    assert len(opt.values()) == 3
+    assert len(opt.items()) == 3
+    assert len(opt.keys()) == 3
+
+
+def test_del():
+    opt_dict = {
+        "opt1": True,
+    }
+    opt = _SolverOptions(default, opt1=True)
+    del opt["opt1"]
+    assert opt["opt1"] is False
+
+
+def test_SolverOptions_Feedback():
+    called = []
+
+    def _catch(keys):
+        assert isinstance(keys, (set, str))
+        called.append(keys)
+
+    opt = _SolverOptions(default, _catch)
+    opt["opt1"] = 2
+    opt["opt2"] = 1e-5
+
+    assert "opt1" in called
+    assert "opt2" in called
+    assert len(called) == 2
+
+
+def test_error():
+    with pytest.raises(KeyError) as err:
+        _SolverOptions(default, opt4=4)
+    assert "opt4" in str(err.value)
+
+    with pytest.raises(KeyError) as err:
+        opt = _SolverOptions(default)
+        opt["opt4"] = 4
+    assert "opt4" in str(err.value)
+
+
+def test_print():
+    opt = _SolverOptions(default, None, "Test options", "Custom doc")
+    assert "Test options" in opt.__str__()
+    assert "opt1 : False" in opt.__str__()
+    assert "opt2 : True" in opt.__str__()
+    assert "opt3 : None" in opt.__str__()
+    assert opt.__doc__ == "Custom doc"
+
+
+def test_in_solver():
+    opt = {"method": "adams", "store_states": True, "atol": 1}
+    solver = qutip.SESolver(qutip.qeye(1), options=opt)
+    adams = qutip.integrator.IntegratorScipyAdams
+    lsoda = qutip.integrator.IntegratorScipylsoda
+    bdf = qutip.integrator.IntegratorScipyBDF
+    assert solver.options["store_states"] is True
+    assert solver.options["method"] == "adams"
+    assert solver.options["atol"] == 1
+    assert solver.options["order"] == adams.integrator_options["order"]
+
+    solver.options["method"] = "bdf"
+    assert solver.options["store_states"] is True
+    assert solver.options["method"] == "bdf"
+    assert solver.options["atol"] == bdf.integrator_options["atol"]
+    assert solver.options["order"] == bdf.integrator_options["order"]
+
+    solver.options = {
+        "method": "vern7",
+        "store_final_state": True,
+        "atol": 0.01
+    }
+    assert solver.options["store_states"] is True
+    assert solver.options["store_final_state"] is True
+    assert solver.options["method"] == "vern7"
+    assert solver.options["atol"] == 0.01
+    assert "order" not in solver.options
+    assert "interpolate" in solver.options
+
+
+def test_options_update_solver():
+    opt = {"method": "adams", "normalize_output": False}
+    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
+
+    solver.start(qutip.basis(1), 0)
+    err_atol_def = (solver.step(1) - np.exp(1)).norm()
+
+    solver.options["atol"] = 1
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
+
+    del solver.options["atol"]
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
+
+    solver.options["atol"] = 1
+    solver.options["atol"] = None
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
+
+    solver.options["method"] = "diag"
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
diff --git a/qutip/tests/solver/test_parallel.py b/qutip/tests/solver/test_parallel.py
index 416369175e..9d18a70ded 100644
--- a/qutip/tests/solver/test_parallel.py
+++ b/qutip/tests/solver/test_parallel.py
@@ -1,121 +1,121 @@
-import numpy as np
-import time
-import pytest
-import threading
-
-from qutip.solver.parallel import (
-    parallel_map, serial_map, loky_pmap, MapExceptions
-)
-
-
-def _func1(x):
-    return x**2
-
-
-def _func2(x, a, b, c, d=0, e=0, f=0):
-    assert d > 0
-    assert e > 0
-    assert f > 0
-    time.sleep(np.random.rand() * 0.1)  # random delay
-    return x**2
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-@pytest.mark.parametrize('num_cpus',
-                         [1, 2],
-                         ids=['1', '2'])
-def test_map(map, num_cpus):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-
-    args = (1, 2, 3)
-    kwargs = {'d': 4, 'e': 5, 'f': 6}
-    map_kw = {
-        'job_timeout': threading.TIMEOUT_MAX,
-        'timeout': threading.TIMEOUT_MAX,
-        'num_cpus': num_cpus,
-    }
-
-    x = np.arange(10)
-    y1 = [_func1(xx) for xx in x]
-
-    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
-    assert ((np.array(y1) == np.array(y2)).all())
-
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-@pytest.mark.parametrize('num_cpus',
-                         [1, 2],
-                         ids=['1', '2'])
-def test_map_accumulator(map, num_cpus):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-    args = (1, 2, 3)
-    kwargs = {'d': 4, 'e': 5, 'f': 6}
-    map_kw = {
-        'job_timeout': threading.TIMEOUT_MAX,
-        'timeout': threading.TIMEOUT_MAX,
-        'num_cpus': num_cpus,
-    }
-    y2 = []
-
-    x = np.arange(10)
-    y1 = [_func1(xx) for xx in x]
-
-    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
-    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
-
-
-class CustomException(Exception):
-    pass
-
-
-def func(i):
-    if i % 2 == 1:
-        raise CustomException(f"Error in subprocess {i}")
-    return i
-
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-def test_map_pass_error(map):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-
-    with pytest.raises(CustomException) as err:
-        map(func, range(10))
-    assert "Error in subprocess" in str(err.value)
-
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-def test_map_store_error(map):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-
-    with pytest.raises(MapExceptions) as err:
-        map(func, range(10), map_kw={"fail_fast": False})
-    map_error = err.value
-    assert "iterations failed" in str(map_error)
-    for iter, error in map_error.errors.items():
-        assert isinstance(error, CustomException)
-        assert f"Error in subprocess {iter}" == str(error)
-    for n, result in enumerate(map_error.results):
-        if n % 2 == 0:
-            # Passed
-            assert result == n
-        else:
-            assert result is None
+import numpy as np
+import time
+import pytest
+import threading
+
+from qutip.solver.parallel import (
+    parallel_map, serial_map, loky_pmap, MapExceptions
+)
+
+
+def _func1(x):
+    return x**2
+
+
+def _func2(x, a, b, c, d=0, e=0, f=0):
+    assert d > 0
+    assert e > 0
+    assert f > 0
+    time.sleep(np.random.rand() * 0.1)  # random delay
+    return x**2
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+@pytest.mark.parametrize('num_cpus',
+                         [1, 2],
+                         ids=['1', '2'])
+def test_map(map, num_cpus):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    args = (1, 2, 3)
+    kwargs = {'d': 4, 'e': 5, 'f': 6}
+    map_kw = {
+        'job_timeout': threading.TIMEOUT_MAX,
+        'timeout': threading.TIMEOUT_MAX,
+        'num_cpus': num_cpus,
+    }
+
+    x = np.arange(10)
+    y1 = [_func1(xx) for xx in x]
+
+    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
+    assert ((np.array(y1) == np.array(y2)).all())
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+@pytest.mark.parametrize('num_cpus',
+                         [1, 2],
+                         ids=['1', '2'])
+def test_map_accumulator(map, num_cpus):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+    args = (1, 2, 3)
+    kwargs = {'d': 4, 'e': 5, 'f': 6}
+    map_kw = {
+        'job_timeout': threading.TIMEOUT_MAX,
+        'timeout': threading.TIMEOUT_MAX,
+        'num_cpus': num_cpus,
+    }
+    y2 = []
+
+    x = np.arange(10)
+    y1 = [_func1(xx) for xx in x]
+
+    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
+    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
+
+
+class CustomException(Exception):
+    pass
+
+
+def func(i):
+    if i % 2 == 1:
+        raise CustomException(f"Error in subprocess {i}")
+    return i
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+def test_map_pass_error(map):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    with pytest.raises(CustomException) as err:
+        map(func, range(10))
+    assert "Error in subprocess" in str(err.value)
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+def test_map_store_error(map):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    with pytest.raises(MapExceptions) as err:
+        map(func, range(10), map_kw={"fail_fast": False})
+    map_error = err.value
+    assert "iterations failed" in str(map_error)
+    for iter, error in map_error.errors.items():
+        assert isinstance(error, CustomException)
+        assert f"Error in subprocess {iter}" == str(error)
+    for n, result in enumerate(map_error.results):
+        if n % 2 == 0:
+            # Passed
+            assert result == n
+        else:
+            assert result is None
diff --git a/qutip/tests/solver/test_propagator.py b/qutip/tests/solver/test_propagator.py
index 2d36d9f977..0a7393ecfa 100644
--- a/qutip/tests/solver/test_propagator.py
+++ b/qutip/tests/solver/test_propagator.py
@@ -1,140 +1,140 @@
-import numpy as np
-from qutip import (destroy, propagator, Propagator, propagator_steadystate,
-                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
-import qutip
-import pytest
-from qutip.solver.brmesolve import BRSolver
-from qutip.solver.mesolve import MESolver
-from qutip.solver.sesolve import SESolver
-from qutip.solver.mcsolve import MCSolver
-
-
-def testPropHOB():
-    a = destroy(5)
-    H = a.dag()*a
-    U = propagator(H, 1)
-    U2 = (-1j * H).expm()
-    assert (U - U2).norm('max') < 1e-4
-
-
-def testPropObj():
-    opt = {"method": "dop853"}
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
-    # Few call to fill the stored propagators.
-    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
-    assert len(U.times) == 5
-    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
-    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
-    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
-    # Within tol, should use the precomupted value at U(0.5)
-    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
-
-
-def func(t):
-    return np.cos(t)
-
-
-def testPropHOTd():
-    "Propagator: func td format"
-    a = destroy(5)
-    H = a.dag()*a
-    Htd = [H, [H, func]]
-    U = propagator(Htd, 1)
-    ts = np.linspace(0, 1, 101)
-    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
-    assert (U - U2).norm('max') < 1e-4
-
-
-def testPropObjTd():
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
-    assert (
-        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
-    ).norm('max') < 1e-4
-    assert (
-        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
-    ).norm('max') < 1e-4
-    assert (
-        U(1.5, 0.5, w=1.5)
-        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
-    ).norm('max') < 1e-4
-
-
-def testPropHOSteady():
-    "Propagator: steady state"
-    a = destroy(5)
-    H = a.dag()*a
-    c_op_list = []
-    kappa = 0.1
-    n_th = 2
-    rate = kappa * (1 + n_th)
-    c_op_list.append(np.sqrt(rate) * a)
-    rate = kappa * n_th
-    c_op_list.append(np.sqrt(rate) * a.dag())
-    U = propagator(H, 2*np.pi, c_op_list)
-    rho_prop = propagator_steadystate(U)
-    rho_ss = steadystate(H, c_op_list)
-    assert (rho_prop - rho_ss).norm('max') < 1e-4
-
-
-def testPropHDims():
-    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
-    H = tensor([qeye(2), qeye(2)])
-    U = propagator(H, 1)
-    assert U.dims == H.dims
-
-
-def testPropEvo():
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
-    psi = QobjEvo(U) @ basis(5, 4)
-    tlist = np.linspace(0, 1, 6)
-    psi_expected = sesolve(
-        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
-    ).states
-    for t, psi_t in zip(tlist, psi_expected):
-        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
-
-
-def _make_se(H, a):
-    return SESolver(H)
-
-
-def _make_me(H, a):
-    return MESolver(H, [a])
-
-
-def _make_br(H, a):
-    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
-    return BRSolver(H, [(a+a.dag(), spectra)])
-
-
-@pytest.mark.parametrize('solver', [
-    pytest.param(_make_se, id='SESolver'),
-    pytest.param(_make_me, id='MESolver'),
-    pytest.param(_make_br, id='BRSolver'),
-])
-def testPropSolver(solver):
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator(solver(H, a))
-    c_ops = []
-    if solver is not _make_se:
-        c_ops = [a]
-
-    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
-    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
-    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
-
-
-def testPropMCSolver():
-    a = destroy(5)
-    H = a.dag()*a
-    solver = MCSolver(H, [a])
-    with pytest.raises(TypeError) as err:
-        Propagator(solver)
-    assert str(err.value).startswith("Non-deterministic")
+import numpy as np
+from qutip import (destroy, propagator, Propagator, propagator_steadystate,
+                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
+import qutip
+import pytest
+from qutip.solver.brmesolve import BRSolver
+from qutip.solver.mesolve import MESolver
+from qutip.solver.sesolve import SESolver
+from qutip.solver.mcsolve import MCSolver
+
+
+def testPropHOB():
+    a = destroy(5)
+    H = a.dag()*a
+    U = propagator(H, 1)
+    U2 = (-1j * H).expm()
+    assert (U - U2).norm('max') < 1e-4
+
+
+def testPropObj():
+    opt = {"method": "dop853"}
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
+    # Few call to fill the stored propagators.
+    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
+    assert len(U.times) == 5
+    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
+    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
+    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
+    # Within tol, should use the precomupted value at U(0.5)
+    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
+
+
+def func(t):
+    return np.cos(t)
+
+
+def testPropHOTd():
+    "Propagator: func td format"
+    a = destroy(5)
+    H = a.dag()*a
+    Htd = [H, [H, func]]
+    U = propagator(Htd, 1)
+    ts = np.linspace(0, 1, 101)
+    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
+    assert (U - U2).norm('max') < 1e-4
+
+
+def testPropObjTd():
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
+    assert (
+        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
+    ).norm('max') < 1e-4
+    assert (
+        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
+    ).norm('max') < 1e-4
+    assert (
+        U(1.5, 0.5, w=1.5)
+        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
+    ).norm('max') < 1e-4
+
+
+def testPropHOSteady():
+    "Propagator: steady state"
+    a = destroy(5)
+    H = a.dag()*a
+    c_op_list = []
+    kappa = 0.1
+    n_th = 2
+    rate = kappa * (1 + n_th)
+    c_op_list.append(np.sqrt(rate) * a)
+    rate = kappa * n_th
+    c_op_list.append(np.sqrt(rate) * a.dag())
+    U = propagator(H, 2*np.pi, c_op_list)
+    rho_prop = propagator_steadystate(U)
+    rho_ss = steadystate(H, c_op_list)
+    assert (rho_prop - rho_ss).norm('max') < 1e-4
+
+
+def testPropHDims():
+    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
+    H = tensor([qeye(2), qeye(2)])
+    U = propagator(H, 1)
+    assert U.dims == H.dims
+
+
+def testPropEvo():
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
+    psi = QobjEvo(U) @ basis(5, 4)
+    tlist = np.linspace(0, 1, 6)
+    psi_expected = sesolve(
+        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
+    ).states
+    for t, psi_t in zip(tlist, psi_expected):
+        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
+
+
+def _make_se(H, a):
+    return SESolver(H)
+
+
+def _make_me(H, a):
+    return MESolver(H, [a])
+
+
+def _make_br(H, a):
+    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
+    return BRSolver(H, [(a+a.dag(), spectra)])
+
+
+@pytest.mark.parametrize('solver', [
+    pytest.param(_make_se, id='SESolver'),
+    pytest.param(_make_me, id='MESolver'),
+    pytest.param(_make_br, id='BRSolver'),
+])
+def testPropSolver(solver):
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator(solver(H, a))
+    c_ops = []
+    if solver is not _make_se:
+        c_ops = [a]
+
+    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
+    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
+    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
+
+
+def testPropMCSolver():
+    a = destroy(5)
+    H = a.dag()*a
+    solver = MCSolver(H, [a])
+    with pytest.raises(TypeError) as err:
+        Propagator(solver)
+    assert str(err.value).startswith("Non-deterministic")
diff --git a/qutip/tests/solver/test_results.py b/qutip/tests/solver/test_results.py
index 3aa46982c9..2bcfa2e904 100644
--- a/qutip/tests/solver/test_results.py
+++ b/qutip/tests/solver/test_results.py
@@ -1,352 +1,352 @@
-import numpy as np
-import pytest
-
-import qutip
-from qutip.solver.result import Result, MultiTrajResult, McResult
-
-
-def fill_options(**kwargs):
-    return {
-        "store_states": None,
-        "store_final_state": False,
-        "keep_runs_results": False,
-        **kwargs
-    }
-
-
-def e_op_state_by_time(t, state):
-    """ An e_ops function that returns the state multiplied by the time. """
-    return t * state
-
-
-class TestResult:
-    @pytest.mark.parametrize(["N", "e_ops", "options"], [
-        pytest.param(10, (), {}, id="no-e-ops"),
-        pytest.param(
-            10, qutip.create(10), {"store_states": True}, id="store-states",
-        )
-    ])
-    def test_states(self, N, e_ops, options):
-        res = Result(e_ops, fill_options(**options))
-        for i in range(N):
-            res.add(i, qutip.basis(N, i))
-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-        assert res.states == [qutip.basis(N, i) for i in range(N)]
-        assert res.final_state == qutip.basis(N, N-1)
-
-    @pytest.mark.parametrize(["N", "e_ops", "options"], [
-        pytest.param(10, (), {
-            "store_states": False, "store_final_state": True
-        }, id="no-e-ops"),
-        pytest.param(10, qutip.create(10), {
-            "store_final_state": True,
-        }, id="with-eops"),
-    ])
-    def test_final_state_only(self, N, e_ops, options):
-        res = Result(e_ops, fill_options(**options))
-        for i in range(N):
-            res.add(i, qutip.basis(N, i))
-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-        assert res.states == []
-        assert res.final_state == qutip.basis(N, N-1)
-
-    @pytest.mark.parametrize(["N", "e_ops", "results"], [
-        pytest.param(
-            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
-        ),
-        pytest.param(
-            10,
-            [qutip.num(10), qutip.qeye(10)],
-            {0: np.arange(10), 1: np.ones(10)},
-            id="list-e-ops",
-        ),
-        pytest.param(
-            10,
-            {"a": qutip.num(10), "b": qutip.qeye(10)},
-            {"a": np.arange(10), "b": np.ones(10)},
-            id="dict-e-ops",
-        ),
-        pytest.param(
-            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
-        ),
-        pytest.param(
-            5, e_op_state_by_time,
-            {0: [i * qutip.basis(5, i) for i in range(5)]},
-            id="function",
-        )
-    ])
-    def test_expect_and_e_ops(self, N, e_ops, results):
-        res = Result(
-            e_ops,
-            fill_options(
-                store_final_state=False,
-                store_states=False),
-        )
-        if isinstance(e_ops, dict):
-            raw_ops = e_ops
-        elif isinstance(e_ops, (list, tuple)):
-            raw_ops = dict(enumerate(e_ops))
-        else:
-            raw_ops = {0: e_ops}
-        for i in range(N):
-            res.add(i, qutip.basis(N, i))
-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-        assert res.final_state is None
-        assert not res.states
-        for i, k in enumerate(results):
-            assert res.e_ops[k].op is raw_ops[k]
-            e_op_call_values = [
-                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
-            ]
-            if isinstance(res.expect[i][0], qutip.Qobj):
-                assert (res.expect[i] == results[k]).all()
-                assert res.e_data[k] == results[k]
-                assert e_op_call_values == results[k]
-            else:
-                np.testing.assert_allclose(res.expect[i], results[k])
-                np.testing.assert_allclose(res.e_data[k], results[k])
-                np.testing.assert_allclose(e_op_call_values, results[k])
-
-    def test_add_processor(self):
-        res = Result([], fill_options(store_states=False))
-        a = []
-        b = []
-        states = [{"t": 0}, {"t": 1}]
-
-        res.add_processor(lambda t, state: a.append((t, state)))
-        res.add(0, states[0])
-        res.add_processor(
-            lambda t, state: b.append((t, state)),
-            requires_copy=True,
-        )
-        res.add(1, states[1])
-
-        assert a == [(0, {"t": 0}), (1, {"t": 1})]
-        assert a[0][1] is states[0]  # no copy made
-        assert a[1][1] is not states[1]  # copy made (for b)
-        assert b == [(1, {"t": 1})]
-        assert b[0][1] is not states[1]  # copy made
-
-    def test_repr_minimal(self):
-        res = Result(
-            [],
-            fill_options(store_final_state=False, store_states=False),
-        )
-        assert repr(res) == "\n".join([
-            "<Result",
-            "  Solver: None",
-            "  Number of e_ops: 0",
-            "  State not saved.",
-            ">",
-        ])
-
-    def test_repr_full(self):
-        res = Result(
-            [qutip.num(5), qutip.qeye(5)],
-            fill_options(store_states=True),
-            solver="test-solver",
-            stats={"stat-a": 1, "stat-b": 2},
-        )
-        for i in range(5):
-            res.add(i, qutip.basis(5, i))
-        assert repr(res) == "\n".join([
-            "<Result",
-            "  Solver: test-solver",
-            "  Solver stats:",
-            "    stat-a: 1",
-            "    stat-b: 2",
-            "  Time interval: [0, 4] (5 steps)",
-            "  Number of e_ops: 2",
-            "  States saved.",
-            ">",
-        ])
-
-
-def e_op_num(t, state):
-    """ An e_ops function that returns the ground state occupation. """
-    return state.dag() @ qutip.num(5) @ state
-
-
-class TestMultiTrajResult:
-    def _fill_trajectories(self, multiresult, N, ntraj,
-                           collapse=False, noise=0, dm=False):
-        for _ in range(ntraj):
-            result = Result(multiresult._raw_ops, multiresult.options)
-            result.collapse = []
-            for t in range(N):
-                delta = 1 + noise * np.random.randn()
-                state = qutip.basis(N, t) * delta
-                if dm:
-                    state = state.proj()
-                result.add(t, state)
-                if collapse:
-                    result.collapse.append((t+0.1, 0))
-                    result.collapse.append((t+0.2, 1))
-                    result.collapse.append((t+0.3, 1))
-            if multiresult.add((0, result)) <= 0:
-                break
-
-    def _expect_check_types(self, multiresult):
-        assert isinstance(multiresult.std_expect, list)
-        assert isinstance(multiresult.average_e_data, dict)
-        assert isinstance(multiresult.std_expect, list)
-        assert isinstance(multiresult.average_e_data, dict)
-
-        if multiresult.trajectories:
-            assert isinstance(multiresult.runs_expect, list)
-            assert isinstance(multiresult.runs_e_data, dict)
-        else:
-            assert multiresult.runs_expect == []
-            assert multiresult.runs_e_data == {}
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize('dm', [True, False])
-    def test_McResult(self, dm, keep_runs_results):
-        N = 10
-        ntraj = 5
-        e_ops = [qutip.num(N), qutip.qeye(N)]
-        opt = fill_options(keep_runs_results=keep_runs_results)
-
-        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
-        m_res.add_end_condition(ntraj, None)
-        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
-
-        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
-        assert m_res.stats['end_condition'] == "ntraj reached"
-        self._expect_check_types(m_res)
-
-        assert np.all(np.array(m_res.col_which) < 2)
-        assert isinstance(m_res.collapse, list)
-        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
-        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
-        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize(["e_ops", "results"], [
-        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
-        pytest.param(
-            {"a": qutip.num(5), "b": qutip.qeye(5)},
-            [np.arange(5), np.ones(5)],
-            id="dict-e-ops",
-        ),
-        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
-        pytest.param(e_op_num, [np.arange(5)], id="function"),
-        pytest.param(
-            [qutip.num(5), e_op_num],
-            [np.arange(5), np.arange(5)],
-            id="list-e-ops",
-        ),
-    ])
-    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
-        N = 5
-        ntraj = 25
-        opt = fill_options(keep_runs_results=keep_runs_results)
-        m_res = MultiTrajResult(e_ops, opt, stats={})
-        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
-
-        for expect, expected in zip(m_res.average_expect, results):
-            np.testing.assert_allclose(expect, expected,
-                                       atol=1e-14, rtol=0.02)
-
-        for variance, expected in zip(m_res.std_expect, results):
-            np.testing.assert_allclose(variance, 0.02 * expected,
-                                       atol=1e-14, rtol=0.9)
-
-        if keep_runs_results:
-            for runs_expect, expected in zip(m_res.runs_expect, results):
-                for expect in runs_expect:
-                    np.testing.assert_allclose(expect, expected,
-                                               atol=1e-14, rtol=0.1)
-
-        self._expect_check_types(m_res)
-
-        assert m_res.stats['end_condition'] == "unknown"
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize('dm', [True, False])
-    def test_multitraj_state(self, keep_runs_results, dm):
-        N = 5
-        ntraj = 25
-        opt = fill_options(keep_runs_results=keep_runs_results)
-        m_res = MultiTrajResult([], opt)
-        self._fill_trajectories(m_res, N, ntraj, dm=dm)
-
-        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
-
-        for i in range(N):
-            assert m_res.average_states[i] == qutip.fock_dm(N, i)
-        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
-
-        if keep_runs_results:
-            assert len(m_res.runs_states) == 25
-            assert len(m_res.runs_states[0]) == N
-            for i in range(ntraj):
-                expected = qutip.basis(N, N-1)
-                if dm:
-                    expected = expected.proj()
-                assert m_res.runs_final_states[i] == expected
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize('targettol', [
-        pytest.param(0.1, id='atol'),
-        pytest.param([0.001, 0.1], id='rtol'),
-        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
-    ])
-    def test_multitraj_targettol(self, keep_runs_results, targettol):
-        N = 10
-        ntraj = 1000
-        opt = fill_options(
-            keep_runs_results=keep_runs_results, store_states=True
-        )
-        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
-        m_res.add_end_condition(ntraj, targettol)
-        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
-
-        assert m_res.stats['end_condition'] == "target tolerance reached"
-        assert m_res.num_trajectories <= 1000
-
-    def test_multitraj_steadystate(self):
-        N = 5
-        ntraj = 100
-        opt = fill_options()
-        m_res = MultiTrajResult([], opt, stats={})
-        m_res.add_end_condition(1000)
-        self._fill_trajectories(m_res, N, ntraj)
-        assert m_res.stats['end_condition'] == "timeout"
-        assert m_res.steady_state() == qutip.qeye(5) / 5
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    def test_repr(self, keep_runs_results):
-        N = 10
-        ntraj = 10
-        opt = fill_options(keep_runs_results=keep_runs_results)
-        m_res = MultiTrajResult([], opt)
-        self._fill_trajectories(m_res, N, ntraj)
-        repr = m_res.__repr__()
-        assert "Number of trajectories: 10" in repr
-        if keep_runs_results:
-            assert "Trajectories saved." in repr
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    def test_merge_result(self, keep_runs_results):
-        N = 10
-        opt = fill_options(
-            keep_runs_results=keep_runs_results, store_states=True
-        )
-        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
-        self._fill_trajectories(m_res1, N, 10, noise=0.1)
-
-        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
-        self._fill_trajectories(m_res2, N, 30, noise=0.1)
-
-        merged_res = m_res1 + m_res2
-        assert merged_res.num_trajectories == 40
-        np.testing.assert_allclose(merged_res.average_expect[0],
-                                   np.arange(10), rtol=0.1)
-        np.testing.assert_allclose(
-            np.diag(sum(merged_res.average_states).full()),
-            np.ones(N),
-            rtol=0.1
-        )
-        assert bool(merged_res.trajectories) == keep_runs_results
-        assert merged_res.stats["run time"] == 3
+import numpy as np
+import pytest
+
+import qutip
+from qutip.solver.result import Result, MultiTrajResult, McResult
+
+
+def fill_options(**kwargs):
+    return {
+        "store_states": None,
+        "store_final_state": False,
+        "keep_runs_results": False,
+        **kwargs
+    }
+
+
+def e_op_state_by_time(t, state):
+    """ An e_ops function that returns the state multiplied by the time. """
+    return t * state
+
+
+class TestResult:
+    @pytest.mark.parametrize(["N", "e_ops", "options"], [
+        pytest.param(10, (), {}, id="no-e-ops"),
+        pytest.param(
+            10, qutip.create(10), {"store_states": True}, id="store-states",
+        )
+    ])
+    def test_states(self, N, e_ops, options):
+        res = Result(e_ops, fill_options(**options))
+        for i in range(N):
+            res.add(i, qutip.basis(N, i))
+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+        assert res.states == [qutip.basis(N, i) for i in range(N)]
+        assert res.final_state == qutip.basis(N, N-1)
+
+    @pytest.mark.parametrize(["N", "e_ops", "options"], [
+        pytest.param(10, (), {
+            "store_states": False, "store_final_state": True
+        }, id="no-e-ops"),
+        pytest.param(10, qutip.create(10), {
+            "store_final_state": True,
+        }, id="with-eops"),
+    ])
+    def test_final_state_only(self, N, e_ops, options):
+        res = Result(e_ops, fill_options(**options))
+        for i in range(N):
+            res.add(i, qutip.basis(N, i))
+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+        assert res.states == []
+        assert res.final_state == qutip.basis(N, N-1)
+
+    @pytest.mark.parametrize(["N", "e_ops", "results"], [
+        pytest.param(
+            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
+        ),
+        pytest.param(
+            10,
+            [qutip.num(10), qutip.qeye(10)],
+            {0: np.arange(10), 1: np.ones(10)},
+            id="list-e-ops",
+        ),
+        pytest.param(
+            10,
+            {"a": qutip.num(10), "b": qutip.qeye(10)},
+            {"a": np.arange(10), "b": np.ones(10)},
+            id="dict-e-ops",
+        ),
+        pytest.param(
+            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
+        ),
+        pytest.param(
+            5, e_op_state_by_time,
+            {0: [i * qutip.basis(5, i) for i in range(5)]},
+            id="function",
+        )
+    ])
+    def test_expect_and_e_ops(self, N, e_ops, results):
+        res = Result(
+            e_ops,
+            fill_options(
+                store_final_state=False,
+                store_states=False),
+        )
+        if isinstance(e_ops, dict):
+            raw_ops = e_ops
+        elif isinstance(e_ops, (list, tuple)):
+            raw_ops = dict(enumerate(e_ops))
+        else:
+            raw_ops = {0: e_ops}
+        for i in range(N):
+            res.add(i, qutip.basis(N, i))
+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+        assert res.final_state is None
+        assert not res.states
+        for i, k in enumerate(results):
+            assert res.e_ops[k].op is raw_ops[k]
+            e_op_call_values = [
+                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
+            ]
+            if isinstance(res.expect[i][0], qutip.Qobj):
+                assert (res.expect[i] == results[k]).all()
+                assert res.e_data[k] == results[k]
+                assert e_op_call_values == results[k]
+            else:
+                np.testing.assert_allclose(res.expect[i], results[k])
+                np.testing.assert_allclose(res.e_data[k], results[k])
+                np.testing.assert_allclose(e_op_call_values, results[k])
+
+    def test_add_processor(self):
+        res = Result([], fill_options(store_states=False))
+        a = []
+        b = []
+        states = [{"t": 0}, {"t": 1}]
+
+        res.add_processor(lambda t, state: a.append((t, state)))
+        res.add(0, states[0])
+        res.add_processor(
+            lambda t, state: b.append((t, state)),
+            requires_copy=True,
+        )
+        res.add(1, states[1])
+
+        assert a == [(0, {"t": 0}), (1, {"t": 1})]
+        assert a[0][1] is states[0]  # no copy made
+        assert a[1][1] is not states[1]  # copy made (for b)
+        assert b == [(1, {"t": 1})]
+        assert b[0][1] is not states[1]  # copy made
+
+    def test_repr_minimal(self):
+        res = Result(
+            [],
+            fill_options(store_final_state=False, store_states=False),
+        )
+        assert repr(res) == "\n".join([
+            "<Result",
+            "  Solver: None",
+            "  Number of e_ops: 0",
+            "  State not saved.",
+            ">",
+        ])
+
+    def test_repr_full(self):
+        res = Result(
+            [qutip.num(5), qutip.qeye(5)],
+            fill_options(store_states=True),
+            solver="test-solver",
+            stats={"stat-a": 1, "stat-b": 2},
+        )
+        for i in range(5):
+            res.add(i, qutip.basis(5, i))
+        assert repr(res) == "\n".join([
+            "<Result",
+            "  Solver: test-solver",
+            "  Solver stats:",
+            "    stat-a: 1",
+            "    stat-b: 2",
+            "  Time interval: [0, 4] (5 steps)",
+            "  Number of e_ops: 2",
+            "  States saved.",
+            ">",
+        ])
+
+
+def e_op_num(t, state):
+    """ An e_ops function that returns the ground state occupation. """
+    return state.dag() @ qutip.num(5) @ state
+
+
+class TestMultiTrajResult:
+    def _fill_trajectories(self, multiresult, N, ntraj,
+                           collapse=False, noise=0, dm=False):
+        for _ in range(ntraj):
+            result = Result(multiresult._raw_ops, multiresult.options)
+            result.collapse = []
+            for t in range(N):
+                delta = 1 + noise * np.random.randn()
+                state = qutip.basis(N, t) * delta
+                if dm:
+                    state = state.proj()
+                result.add(t, state)
+                if collapse:
+                    result.collapse.append((t+0.1, 0))
+                    result.collapse.append((t+0.2, 1))
+                    result.collapse.append((t+0.3, 1))
+            if multiresult.add((0, result)) <= 0:
+                break
+
+    def _expect_check_types(self, multiresult):
+        assert isinstance(multiresult.std_expect, list)
+        assert isinstance(multiresult.average_e_data, dict)
+        assert isinstance(multiresult.std_expect, list)
+        assert isinstance(multiresult.average_e_data, dict)
+
+        if multiresult.trajectories:
+            assert isinstance(multiresult.runs_expect, list)
+            assert isinstance(multiresult.runs_e_data, dict)
+        else:
+            assert multiresult.runs_expect == []
+            assert multiresult.runs_e_data == {}
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize('dm', [True, False])
+    def test_McResult(self, dm, keep_runs_results):
+        N = 10
+        ntraj = 5
+        e_ops = [qutip.num(N), qutip.qeye(N)]
+        opt = fill_options(keep_runs_results=keep_runs_results)
+
+        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
+        m_res.add_end_condition(ntraj, None)
+        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
+
+        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
+        assert m_res.stats['end_condition'] == "ntraj reached"
+        self._expect_check_types(m_res)
+
+        assert np.all(np.array(m_res.col_which) < 2)
+        assert isinstance(m_res.collapse, list)
+        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
+        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
+        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize(["e_ops", "results"], [
+        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
+        pytest.param(
+            {"a": qutip.num(5), "b": qutip.qeye(5)},
+            [np.arange(5), np.ones(5)],
+            id="dict-e-ops",
+        ),
+        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
+        pytest.param(e_op_num, [np.arange(5)], id="function"),
+        pytest.param(
+            [qutip.num(5), e_op_num],
+            [np.arange(5), np.arange(5)],
+            id="list-e-ops",
+        ),
+    ])
+    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
+        N = 5
+        ntraj = 25
+        opt = fill_options(keep_runs_results=keep_runs_results)
+        m_res = MultiTrajResult(e_ops, opt, stats={})
+        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
+
+        for expect, expected in zip(m_res.average_expect, results):
+            np.testing.assert_allclose(expect, expected,
+                                       atol=1e-14, rtol=0.02)
+
+        for variance, expected in zip(m_res.std_expect, results):
+            np.testing.assert_allclose(variance, 0.02 * expected,
+                                       atol=1e-14, rtol=0.9)
+
+        if keep_runs_results:
+            for runs_expect, expected in zip(m_res.runs_expect, results):
+                for expect in runs_expect:
+                    np.testing.assert_allclose(expect, expected,
+                                               atol=1e-14, rtol=0.1)
+
+        self._expect_check_types(m_res)
+
+        assert m_res.stats['end_condition'] == "unknown"
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize('dm', [True, False])
+    def test_multitraj_state(self, keep_runs_results, dm):
+        N = 5
+        ntraj = 25
+        opt = fill_options(keep_runs_results=keep_runs_results)
+        m_res = MultiTrajResult([], opt)
+        self._fill_trajectories(m_res, N, ntraj, dm=dm)
+
+        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
+
+        for i in range(N):
+            assert m_res.average_states[i] == qutip.fock_dm(N, i)
+        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
+
+        if keep_runs_results:
+            assert len(m_res.runs_states) == 25
+            assert len(m_res.runs_states[0]) == N
+            for i in range(ntraj):
+                expected = qutip.basis(N, N-1)
+                if dm:
+                    expected = expected.proj()
+                assert m_res.runs_final_states[i] == expected
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize('targettol', [
+        pytest.param(0.1, id='atol'),
+        pytest.param([0.001, 0.1], id='rtol'),
+        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
+    ])
+    def test_multitraj_targettol(self, keep_runs_results, targettol):
+        N = 10
+        ntraj = 1000
+        opt = fill_options(
+            keep_runs_results=keep_runs_results, store_states=True
+        )
+        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
+        m_res.add_end_condition(ntraj, targettol)
+        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
+
+        assert m_res.stats['end_condition'] == "target tolerance reached"
+        assert m_res.num_trajectories <= 1000
+
+    def test_multitraj_steadystate(self):
+        N = 5
+        ntraj = 100
+        opt = fill_options()
+        m_res = MultiTrajResult([], opt, stats={})
+        m_res.add_end_condition(1000)
+        self._fill_trajectories(m_res, N, ntraj)
+        assert m_res.stats['end_condition'] == "timeout"
+        assert m_res.steady_state() == qutip.qeye(5) / 5
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    def test_repr(self, keep_runs_results):
+        N = 10
+        ntraj = 10
+        opt = fill_options(keep_runs_results=keep_runs_results)
+        m_res = MultiTrajResult([], opt)
+        self._fill_trajectories(m_res, N, ntraj)
+        repr = m_res.__repr__()
+        assert "Number of trajectories: 10" in repr
+        if keep_runs_results:
+            assert "Trajectories saved." in repr
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    def test_merge_result(self, keep_runs_results):
+        N = 10
+        opt = fill_options(
+            keep_runs_results=keep_runs_results, store_states=True
+        )
+        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
+        self._fill_trajectories(m_res1, N, 10, noise=0.1)
+
+        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
+        self._fill_trajectories(m_res2, N, 30, noise=0.1)
+
+        merged_res = m_res1 + m_res2
+        assert merged_res.num_trajectories == 40
+        np.testing.assert_allclose(merged_res.average_expect[0],
+                                   np.arange(10), rtol=0.1)
+        np.testing.assert_allclose(
+            np.diag(sum(merged_res.average_states).full()),
+            np.ones(N),
+            rtol=0.1
+        )
+        assert bool(merged_res.trajectories) == keep_runs_results
+        assert merged_res.stats["run time"] == 3
diff --git a/qutip/tests/solver/test_scattering.py b/qutip/tests/solver/test_scattering.py
index 0ad7257ec4..339050677e 100644
--- a/qutip/tests/solver/test_scattering.py
+++ b/qutip/tests/solver/test_scattering.py
@@ -1,92 +1,92 @@
-"""
-This module includes a collection of testing functions for the QuTiP scattering
-module. Tests are approximate with low resolution to minimize runtime.
-"""
-
-# Author:  Ben Bartlett
-# Contact: benbartlett@stanford.edu
-
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-from qutip import create, destroy, basis
-from qutip.solver.scattering import *
-
-
-class TestScattering:
-    """
-    A test class for the QuTiP quantum optical scattering module. These tests
-    only use the two-level system for comparison, since larger systems can
-    take a long time to run.
-    """
-
-    def testScatteringProbability(self):
-        """
-        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
-        """
-        w0 = 1.0 * 2 * np.pi
-        gamma = 1.0
-        sm = np.sqrt(gamma) * destroy(2)
-        pulseArea = np.pi
-        pulseLength = 0.2 / gamma
-        RabiFreq = pulseArea / (2 * pulseLength)
-        psi0 = basis(2, 0)
-        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
-        # Define TLS Hamiltonian
-        H0S = w0 * create(2) * destroy(2)
-        H1S1 = lambda t, args: \
-            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
-        H1S2 = lambda t, args: \
-            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
-        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
-        # Run the test
-        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
-        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
-        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
-        assert P0 < 1e-3
-        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
-
-    def testScatteringAmplitude(self):
-        """
-        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
-        """
-        w0 = 1.0 * 2 * np.pi
-        gamma = 1.0
-        sm = np.sqrt(gamma) * destroy(2)
-        pulseArea = 2 * np.pi
-        pulseLength = 0.2 / gamma
-        RabiFreq = pulseArea / (2 * pulseLength)
-        psi0 = basis(2, 0)
-        T = 50
-        tlist = np.linspace(0, 1 / gamma, T)
-        # Define TLS Hamiltonian
-        H0S = w0 * create(2) * destroy(2)
-        H1S1 = lambda t, args: \
-            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
-        H1S2 = lambda t, args: \
-            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
-        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
-        # Run the test
-        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
-        basisVec = temporal_basis_vector([[40]], T)
-        assert np.abs(basisVec.dag() @ state) < 1e-3
-
-    def testWaveguideSplit(self):
-        """
-        Checks that a trivial splitting of a waveguide collapse operator like
-        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
-        """
-        gamma = 1.0
-        sm = np.sqrt(gamma) * destroy(2)
-        pulseArea = np.pi
-        pulseLength = 0.2 / gamma
-        RabiFreq = pulseArea / (2 * pulseLength)
-        psi0 = basis(2, 0)
-        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
-        # Define TLS Hamiltonian with rotating frame transformation
-        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
-        # Run the test
-        c_ops = [sm]
-        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
-        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
-        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
-        assert np.abs(P1/P1_split - 1) < 1e-7
+"""
+This module includes a collection of testing functions for the QuTiP scattering
+module. Tests are approximate with low resolution to minimize runtime.
+"""
+
+# Author:  Ben Bartlett
+# Contact: benbartlett@stanford.edu
+
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+from qutip import create, destroy, basis
+from qutip.solver.scattering import *
+
+
+class TestScattering:
+    """
+    A test class for the QuTiP quantum optical scattering module. These tests
+    only use the two-level system for comparison, since larger systems can
+    take a long time to run.
+    """
+
+    def testScatteringProbability(self):
+        """
+        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
+        """
+        w0 = 1.0 * 2 * np.pi
+        gamma = 1.0
+        sm = np.sqrt(gamma) * destroy(2)
+        pulseArea = np.pi
+        pulseLength = 0.2 / gamma
+        RabiFreq = pulseArea / (2 * pulseLength)
+        psi0 = basis(2, 0)
+        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
+        # Define TLS Hamiltonian
+        H0S = w0 * create(2) * destroy(2)
+        H1S1 = lambda t, args: \
+            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
+        H1S2 = lambda t, args: \
+            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
+        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
+        # Run the test
+        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
+        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
+        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
+        assert P0 < 1e-3
+        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
+
+    def testScatteringAmplitude(self):
+        """
+        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
+        """
+        w0 = 1.0 * 2 * np.pi
+        gamma = 1.0
+        sm = np.sqrt(gamma) * destroy(2)
+        pulseArea = 2 * np.pi
+        pulseLength = 0.2 / gamma
+        RabiFreq = pulseArea / (2 * pulseLength)
+        psi0 = basis(2, 0)
+        T = 50
+        tlist = np.linspace(0, 1 / gamma, T)
+        # Define TLS Hamiltonian
+        H0S = w0 * create(2) * destroy(2)
+        H1S1 = lambda t, args: \
+            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
+        H1S2 = lambda t, args: \
+            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
+        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
+        # Run the test
+        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
+        basisVec = temporal_basis_vector([[40]], T)
+        assert np.abs(basisVec.dag() @ state) < 1e-3
+
+    def testWaveguideSplit(self):
+        """
+        Checks that a trivial splitting of a waveguide collapse operator like
+        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
+        """
+        gamma = 1.0
+        sm = np.sqrt(gamma) * destroy(2)
+        pulseArea = np.pi
+        pulseLength = 0.2 / gamma
+        RabiFreq = pulseArea / (2 * pulseLength)
+        psi0 = basis(2, 0)
+        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
+        # Define TLS Hamiltonian with rotating frame transformation
+        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
+        # Run the test
+        c_ops = [sm]
+        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
+        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
+        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
+        assert np.abs(P1/P1_split - 1) < 1e-7
diff --git a/qutip/tests/solver/test_sesolve.py b/qutip/tests/solver/test_sesolve.py
index 5ca744f973..1814b0ca3f 100644
--- a/qutip/tests/solver/test_sesolve.py
+++ b/qutip/tests/solver/test_sesolve.py
@@ -1,301 +1,301 @@
-import pytest
-import pickle
-import qutip
-import numpy as np
-from qutip.solver.sesolve import sesolve, SESolver
-from qutip.solver.krylovsolve import krylovsolve
-from qutip.solver.solver_base import Solver
-
-all_ode_method = [
-    method for method, integrator in SESolver.avail_integrators().items()
-    if integrator.support_time_dependant
-]
-
-def _analytic(t, alpha):
-    return ((1 - np.exp(-alpha * t)) / alpha)
-
-
-class TestSeSolve():
-    H0 = 0.2 * np.pi * qutip.sigmaz()
-    H1 = np.pi * qutip.sigmax()
-    tlist = np.linspace(0, 20, 200)
-    args = {'alpha': 0.5}
-    w_a = 0.35
-    a = 0.5
-
-    @pytest.mark.parametrize(['unitary_op'], [
-        pytest.param(None, id="state"),
-        pytest.param(qutip.qeye(2), id="unitary"),
-    ])
-    @pytest.mark.parametrize(['H', 'analytical'], [
-        pytest.param(H1, lambda t, _: t, id='const_H'),
-        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
-                                       * np.exp(-alpha * t)),
-                     _analytic, id='func_H'),
-        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
-                     _analytic, id='list_func_H'),
-        pytest.param([[H1, 'exp(-alpha*t)']],
-                     _analytic, id='list_str_H'),
-        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
-                     _analytic, id='list_array_H'),
-        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
-                     _analytic, id='QobjEvo_H'),
-    ])
-    def test_sesolve(self, H, analytical, unitary_op):
-        """
-        Compare integrated evolution with analytical result
-        If U0 is not None then operator evo is checked
-        Otherwise state evo
-        """
-        tol = 5e-3
-        psi0 = qutip.basis(2, 0)
-        options = {"progress_bar": None}
-
-        if unitary_op is None:
-            output = sesolve(H, psi0, self.tlist,
-                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
-                             args=self.args, options=options)
-            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
-        else:
-            output = sesolve(H, unitary_op, self.tlist, args=self.args,
-                             options=options)
-            sx = [qutip.expect(qutip.sigmax(), U * psi0)
-                  for U in output.states]
-            sy = [qutip.expect(qutip.sigmay(), U * psi0)
-                  for U in output.states]
-            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
-                  for U in output.states]
-
-        sx_analytic = np.zeros(np.shape(self.tlist))
-        sy_analytic = np.array(
-            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-        sz_analytic = np.array(
-            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
-        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
-        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
-
-    @pytest.mark.parametrize(['state_type'], [
-        pytest.param("ket", id="ket"),
-        pytest.param("unitary", id="unitary"),
-    ])
-    def test_sesolve_normalization(self, state_type):
-        # non-hermitean H causes state to evolve non-unitarily
-        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
-        psi0 = qutip.basis(2, 0)
-        options = {"normalize_output": True, "progress_bar": None}
-
-        if state_type == "ket":
-            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            np.testing.assert_allclose(
-                norms, [1.0 for _ in self.tlist], atol=1e-15,
-            )
-        else:
-            # evolution of unitaries should not be normalized
-            U = qutip.qeye(2)
-            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            assert all(norm > 2 for norm in norms[1:])
-
-    @pytest.mark.parametrize(['unitary_op'], [
-        pytest.param(None, id="state"),
-        pytest.param(qutip.qeye(2), id="unitary"),
-    ])
-    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
-    def test_sesolve_method(self, method, unitary_op):
-        """
-        Compare integrated evolution with analytical result
-        If U0 is not None then operator evo is checked
-        Otherwise state evo
-        """
-        tol = 5e-3
-        psi0 = qutip.basis(2, 0)
-        options = {"method": method, "progress_bar": None}
-        H = [[self.H1, 'exp(-alpha*t)']]
-
-        if unitary_op is None:
-            output = sesolve(H, psi0, self.tlist,
-                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
-                             args=self.args, options=options)
-            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
-        else:
-            output = sesolve(H, unitary_op, self.tlist,
-                             args=self.args, options=options)
-            sx = [qutip.expect(qutip.sigmax(), U * psi0)
-                  for U in output.states]
-            sy = [qutip.expect(qutip.sigmay(), U * psi0)
-                  for U in output.states]
-            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
-                  for U in output.states]
-
-        sx_analytic = np.zeros(np.shape(self.tlist))
-        sy_analytic = np.array(
-            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-        sz_analytic = np.array(
-            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
-        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
-        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
-
-    @pytest.mark.parametrize('normalize', [True, False],
-                             ids=['Normalized', ''])
-    @pytest.mark.parametrize(['H', 'args'],
-        [pytest.param(H0 + H1, {}, id='const_H'),
-         pytest.param(lambda t, a, w_a: (
-             a * t * 0.2 * np.pi * qutip.sigmaz() +
-             np.cos(w_a * t) * np.pi * qutip.sigmax()
-         ), {'a':a, 'w_a':w_a}, id='func_H'),
-         pytest.param([
-             [H0, lambda t, args: args['a']*t],
-             [H1, lambda t, args: np.cos(args['w_a']*t)]
-         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
-         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
-    ])
-    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
-        """
-        Compare integrated evolution of unitary operator with state evo
-        """
-        psi0 = qutip.basis(2, 0)
-        U0 = qutip.qeye(2)
-
-        options = {
-            "store_states": True,
-            "normalize_output": normalize,
-            "progress_bar": None
-        }
-        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
-                                              qutip.sigmay(),
-                                              qutip.sigmaz()],
-                        options=options, args=args)
-        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
-        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
-        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
-        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
-
-        np.testing.assert_allclose(xs, xss, atol=tol)
-        np.testing.assert_allclose(ys, yss, atol=tol)
-        np.testing.assert_allclose(zs, zss, atol=tol)
-
-        if normalize:
-            # propagator evolution is not normalized (yet?)
-            tol = 5e-4
-        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
-        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
-        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
-        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
-
-        np.testing.assert_allclose(xs, xu, atol=tol)
-        np.testing.assert_allclose(ys, yu, atol=tol)
-        np.testing.assert_allclose(zs, zu, atol=tol)
-
-    def test_sesolver_args(self):
-        options = {"progress_bar": None}
-        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
-                                            args={'a': 1}),
-                              options=options)
-        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
-                             e_ops=[qutip.num(2)], args={'a':0})
-        np.testing.assert_allclose(res.expect[0], 1)
-
-    def test_sesolver_pickling(self):
-        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-        options = {"progress_bar": None}
-        solver_obj = SESolver(self.H0 + self.H1,
-                              options=options)
-        solver_copy = pickle.loads(pickle.dumps(solver_obj))
-        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
-                                    e_ops=e_ops).expect
-        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
-                                       e_ops=e_ops).expect
-        np.testing.assert_allclose(sx, csx)
-        np.testing.assert_allclose(sy, csy)
-        np.testing.assert_allclose(sz, csz)
-
-    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
-    def test_sesolver_stepping(self, method):
-        options = {
-            "method": method,
-            "atol": 1e-7,
-            "rtol": 1e-8,
-            "progress_bar": None
-        }
-        solver_obj = SESolver(
-            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
-            options=options
-        )
-        solver_obj.start(qutip.basis(2,0), 0)
-        sr2 = -(2**.5)/2
-        state = solver_obj.step(1)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
-                                   atol=2e-6)
-
-        state = solver_obj.step(2, args={"a":0.125})
-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
-                                   atol=2e-6)
-
-        solver_obj.options = {
-            "method": "adams",
-            "atol": 1e-7,
-            "rtol": 1e-8,
-            "progress_bar": None
-        }
-        state = solver_obj.step(3, args={"a":0})
-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
-                                   atol=2e-6)
-
-
-def test_sesolve_bad_H():
-    with pytest.raises(TypeError):
-        SESolver(np.eye(3))
-    with pytest.raises(ValueError):
-        SESolver(qutip.basis(3,1))
-
-
-def test_sesolve_bad_state():
-    solver = SESolver(qutip.qeye(4))
-    with pytest.raises(TypeError):
-        solver.start(qutip.basis(4,1).dag(), 0)
-    with pytest.raises(TypeError):
-        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
-
-
-def test_sesolve_step_no_start():
-    solver = SESolver(qutip.qeye(4))
-    with pytest.raises(RuntimeError):
-        solver.step(1)
-
-
-@pytest.mark.parametrize("always_compute_step", [True, False])
-def test_krylovsolve(always_compute_step):
-    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
-    psi0 = qutip.basis([2]*8, [1]*8)
-    e_op = qutip.num(256)
-    e_op.dims = H.dims
-    tlist = np.linspace(0, 1, 11)
-    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
-    options = {"always_compute_step", always_compute_step}
-    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
-    np.testing.assert_allclose(ref, krylov_sol)
+import pytest
+import pickle
+import qutip
+import numpy as np
+from qutip.solver.sesolve import sesolve, SESolver
+from qutip.solver.krylovsolve import krylovsolve
+from qutip.solver.solver_base import Solver
+
+all_ode_method = [
+    method for method, integrator in SESolver.avail_integrators().items()
+    if integrator.support_time_dependant
+]
+
+def _analytic(t, alpha):
+    return ((1 - np.exp(-alpha * t)) / alpha)
+
+
+class TestSeSolve():
+    H0 = 0.2 * np.pi * qutip.sigmaz()
+    H1 = np.pi * qutip.sigmax()
+    tlist = np.linspace(0, 20, 200)
+    args = {'alpha': 0.5}
+    w_a = 0.35
+    a = 0.5
+
+    @pytest.mark.parametrize(['unitary_op'], [
+        pytest.param(None, id="state"),
+        pytest.param(qutip.qeye(2), id="unitary"),
+    ])
+    @pytest.mark.parametrize(['H', 'analytical'], [
+        pytest.param(H1, lambda t, _: t, id='const_H'),
+        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
+                                       * np.exp(-alpha * t)),
+                     _analytic, id='func_H'),
+        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
+                     _analytic, id='list_func_H'),
+        pytest.param([[H1, 'exp(-alpha*t)']],
+                     _analytic, id='list_str_H'),
+        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
+                     _analytic, id='list_array_H'),
+        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
+                     _analytic, id='QobjEvo_H'),
+    ])
+    def test_sesolve(self, H, analytical, unitary_op):
+        """
+        Compare integrated evolution with analytical result
+        If U0 is not None then operator evo is checked
+        Otherwise state evo
+        """
+        tol = 5e-3
+        psi0 = qutip.basis(2, 0)
+        options = {"progress_bar": None}
+
+        if unitary_op is None:
+            output = sesolve(H, psi0, self.tlist,
+                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
+                             args=self.args, options=options)
+            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
+        else:
+            output = sesolve(H, unitary_op, self.tlist, args=self.args,
+                             options=options)
+            sx = [qutip.expect(qutip.sigmax(), U * psi0)
+                  for U in output.states]
+            sy = [qutip.expect(qutip.sigmay(), U * psi0)
+                  for U in output.states]
+            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
+                  for U in output.states]
+
+        sx_analytic = np.zeros(np.shape(self.tlist))
+        sy_analytic = np.array(
+            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+        sz_analytic = np.array(
+            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
+        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
+        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
+
+    @pytest.mark.parametrize(['state_type'], [
+        pytest.param("ket", id="ket"),
+        pytest.param("unitary", id="unitary"),
+    ])
+    def test_sesolve_normalization(self, state_type):
+        # non-hermitean H causes state to evolve non-unitarily
+        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
+        psi0 = qutip.basis(2, 0)
+        options = {"normalize_output": True, "progress_bar": None}
+
+        if state_type == "ket":
+            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            np.testing.assert_allclose(
+                norms, [1.0 for _ in self.tlist], atol=1e-15,
+            )
+        else:
+            # evolution of unitaries should not be normalized
+            U = qutip.qeye(2)
+            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            assert all(norm > 2 for norm in norms[1:])
+
+    @pytest.mark.parametrize(['unitary_op'], [
+        pytest.param(None, id="state"),
+        pytest.param(qutip.qeye(2), id="unitary"),
+    ])
+    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
+    def test_sesolve_method(self, method, unitary_op):
+        """
+        Compare integrated evolution with analytical result
+        If U0 is not None then operator evo is checked
+        Otherwise state evo
+        """
+        tol = 5e-3
+        psi0 = qutip.basis(2, 0)
+        options = {"method": method, "progress_bar": None}
+        H = [[self.H1, 'exp(-alpha*t)']]
+
+        if unitary_op is None:
+            output = sesolve(H, psi0, self.tlist,
+                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
+                             args=self.args, options=options)
+            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
+        else:
+            output = sesolve(H, unitary_op, self.tlist,
+                             args=self.args, options=options)
+            sx = [qutip.expect(qutip.sigmax(), U * psi0)
+                  for U in output.states]
+            sy = [qutip.expect(qutip.sigmay(), U * psi0)
+                  for U in output.states]
+            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
+                  for U in output.states]
+
+        sx_analytic = np.zeros(np.shape(self.tlist))
+        sy_analytic = np.array(
+            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+        sz_analytic = np.array(
+            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
+        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
+        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
+
+    @pytest.mark.parametrize('normalize', [True, False],
+                             ids=['Normalized', ''])
+    @pytest.mark.parametrize(['H', 'args'],
+        [pytest.param(H0 + H1, {}, id='const_H'),
+         pytest.param(lambda t, a, w_a: (
+             a * t * 0.2 * np.pi * qutip.sigmaz() +
+             np.cos(w_a * t) * np.pi * qutip.sigmax()
+         ), {'a':a, 'w_a':w_a}, id='func_H'),
+         pytest.param([
+             [H0, lambda t, args: args['a']*t],
+             [H1, lambda t, args: np.cos(args['w_a']*t)]
+         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
+         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
+    ])
+    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
+        """
+        Compare integrated evolution of unitary operator with state evo
+        """
+        psi0 = qutip.basis(2, 0)
+        U0 = qutip.qeye(2)
+
+        options = {
+            "store_states": True,
+            "normalize_output": normalize,
+            "progress_bar": None
+        }
+        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
+                                              qutip.sigmay(),
+                                              qutip.sigmaz()],
+                        options=options, args=args)
+        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
+        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
+        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
+        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
+
+        np.testing.assert_allclose(xs, xss, atol=tol)
+        np.testing.assert_allclose(ys, yss, atol=tol)
+        np.testing.assert_allclose(zs, zss, atol=tol)
+
+        if normalize:
+            # propagator evolution is not normalized (yet?)
+            tol = 5e-4
+        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
+        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
+        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
+        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
+
+        np.testing.assert_allclose(xs, xu, atol=tol)
+        np.testing.assert_allclose(ys, yu, atol=tol)
+        np.testing.assert_allclose(zs, zu, atol=tol)
+
+    def test_sesolver_args(self):
+        options = {"progress_bar": None}
+        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
+                                            args={'a': 1}),
+                              options=options)
+        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
+                             e_ops=[qutip.num(2)], args={'a':0})
+        np.testing.assert_allclose(res.expect[0], 1)
+
+    def test_sesolver_pickling(self):
+        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+        options = {"progress_bar": None}
+        solver_obj = SESolver(self.H0 + self.H1,
+                              options=options)
+        solver_copy = pickle.loads(pickle.dumps(solver_obj))
+        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
+                                    e_ops=e_ops).expect
+        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
+                                       e_ops=e_ops).expect
+        np.testing.assert_allclose(sx, csx)
+        np.testing.assert_allclose(sy, csy)
+        np.testing.assert_allclose(sz, csz)
+
+    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
+    def test_sesolver_stepping(self, method):
+        options = {
+            "method": method,
+            "atol": 1e-7,
+            "rtol": 1e-8,
+            "progress_bar": None
+        }
+        solver_obj = SESolver(
+            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
+            options=options
+        )
+        solver_obj.start(qutip.basis(2,0), 0)
+        sr2 = -(2**.5)/2
+        state = solver_obj.step(1)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
+                                   atol=2e-6)
+
+        state = solver_obj.step(2, args={"a":0.125})
+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
+                                   atol=2e-6)
+
+        solver_obj.options = {
+            "method": "adams",
+            "atol": 1e-7,
+            "rtol": 1e-8,
+            "progress_bar": None
+        }
+        state = solver_obj.step(3, args={"a":0})
+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
+                                   atol=2e-6)
+
+
+def test_sesolve_bad_H():
+    with pytest.raises(TypeError):
+        SESolver(np.eye(3))
+    with pytest.raises(ValueError):
+        SESolver(qutip.basis(3,1))
+
+
+def test_sesolve_bad_state():
+    solver = SESolver(qutip.qeye(4))
+    with pytest.raises(TypeError):
+        solver.start(qutip.basis(4,1).dag(), 0)
+    with pytest.raises(TypeError):
+        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
+
+
+def test_sesolve_step_no_start():
+    solver = SESolver(qutip.qeye(4))
+    with pytest.raises(RuntimeError):
+        solver.step(1)
+
+
+@pytest.mark.parametrize("always_compute_step", [True, False])
+def test_krylovsolve(always_compute_step):
+    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
+    psi0 = qutip.basis([2]*8, [1]*8)
+    e_op = qutip.num(256)
+    e_op.dims = H.dims
+    tlist = np.linspace(0, 1, 11)
+    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
+    options = {"always_compute_step", always_compute_step}
+    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
+    np.testing.assert_allclose(ref, krylov_sol)
diff --git a/qutip/tests/solver/test_steadystate.py b/qutip/tests/solver/test_steadystate.py
index 6ae02a6489..38c85dfaa8 100644
--- a/qutip/tests/solver/test_steadystate.py
+++ b/qutip/tests/solver/test_steadystate.py
@@ -1,241 +1,241 @@
-import numpy as np
-import pytest
-import qutip
-import warnings
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-                                          reason='MKL extensions not found.')),
-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
-    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
-    pytest.param('eigen', {}, id="eigen"),
-    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
-    pytest.param('svd', {}, id="svd"),
-    pytest.param('power', {'power_tol':1e-5}, id="power"),
-    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-                                          reason='MKL extensions not found.')),
-    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
-    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
-                 id="power-gmres_perm"),
-    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
-    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
-    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
-                 id="iterative-gmres_perm"),
-    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
-                 id="iterative-bicgstab"),
-])
-def test_qubit(method, kwargs):
-    # thermal steadystate of a qubit: compare numerics with analytical formula
-    sz = qutip.sigmaz()
-    sm = qutip.destroy(2)
-
-    H = 0.5 * 2 * np.pi * sz
-    gamma1 = 0.05
-
-    wth_vec = np.linspace(0.1, 3, 20)
-    p_ss = np.zeros(np.shape(wth_vec))
-
-    for idx, wth in enumerate(wth_vec):
-        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
-        c_op_list = []
-        rate = gamma1 * (1 + n_th)
-        c_op_list.append(np.sqrt(rate) * sm)
-        rate = gamma1 * n_th
-        c_op_list.append(np.sqrt(rate) * sm.dag())
-        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
-        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
-
-    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
-    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-                                          reason='MKL extensions not found.')),
-    pytest.param('direct', {'sparse': False}, id="direct_dense"),
-    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
-    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
-    pytest.param('eigen', {}, id="eigen"),
-    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
-    pytest.param('svd', {}, id="svd"),
-])
-def test_exact_solution_for_simple_methods(method, kwargs):
-    # this tests that simple methods correctly determine the steadystate
-    # with high accuracy for a small Liouvillian requiring correct weighting.
-    H = qutip.identity(2)
-    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
-    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
-    expected_rho_ss = np.array([
-        [1.e-10+0.j, 0.e+00-0.j],
-        [0.e+00-0.j, 1.e+00+0.j],
-    ])
-    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
-    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-    pytest.param('eigen', {'sparse':False}, id="eigen"),
-    pytest.param('power', {'power_tol':1e-5}, id="power"),
-    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
-    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
-    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
-])
-def test_ho(method, kwargs):
-    # thermal steadystate of an oscillator: compare numerics with analytical
-    # formula
-    a = qutip.destroy(30)
-    H = 0.5 * 2 * np.pi * a.dag() * a
-    gamma1 = 0.05
-
-    wth_vec = np.linspace(0.1, 3, 11)
-    p_ss = np.zeros(np.shape(wth_vec))
-
-    for idx, wth in enumerate(wth_vec):
-
-        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
-        c_op_list = []
-        rate = gamma1 * (1 + n_th)
-        c_op_list.append(np.sqrt(rate) * a)
-        rate = gamma1 * n_th
-        c_op_list.append(np.sqrt(rate) * a.dag())
-        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
-        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
-
-    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
-    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-    pytest.param('eigen', {}, id="eigen"),
-    pytest.param('svd', {}, id="svd"),
-    pytest.param('power', {}, id="power"),
-    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
-                 id="power-gmres"),
-    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
-                 id="power-bicgstab"),
-    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
-    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
-])
-def test_driven_cavity(method, kwargs):
-    N = 30
-    Omega = 0.01 * 2 * np.pi
-    Gamma = 0.05
-
-    a = qutip.destroy(N)
-    H = Omega * (a.dag() + a)
-    c_ops = [np.sqrt(Gamma) * a]
-    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
-    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
-
-    np.testing.assert_allclose(
-        rho_ss, rho_ss_analytic, atol=1e-4
-    )
-    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('solve', {}, id="dense_direct"),
-    pytest.param('numpy', {}, id="dense_numpy"),
-    pytest.param('spilu', {},  id="spilu"),
-])
-def test_pseudo_inverse(method, kwargs):
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    L = qutip.liouvillian(H, [a])
-    rho = qutip.steadystate(L)
-    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
-    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
-    np.testing.assert_allclose(
-        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
-    )
-    assert rho.tr() == pytest.approx(1, abs=3e-15)
-
-
-@pytest.mark.parametrize('sparse', [True, False])
-def test_steadystate_floquet(sparse):
-    """
-    Test the steadystate solution for a periodically
-    driven system.
-    """
-    N_c = 20
-
-    a = qutip.destroy(N_c)
-    a_d = a.dag()
-    X_c = a + a_d
-
-    w_c = 1
-
-    A_l = 0.001
-    w_l = w_c
-    gam = 0.01
-
-    H = w_c * a_d * a
-
-    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
-
-    psi0 = qutip.fock(N_c, 0)
-
-    args = {"A_l": A_l, "w_l": w_l}
-
-    c_ops = []
-    c_ops.append(np.sqrt(gam) * a)
-
-    t_l = np.linspace(0, 20 / gam, 2000)
-
-    expect_me = qutip.mesolve(H_t, psi0, t_l,
-                        c_ops, [a_d * a], args=args).expect[0]
-
-    rho_ss = qutip.steadystate_floquet(H, c_ops,
-                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
-    expect_ss = qutip.expect(a_d * a, rho_ss)
-
-    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
-    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
-
-
-def test_bad_options_steadystate():
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    c_ops = [a]
-    with pytest.raises(ValueError):
-        qutip.steadystate(H, c_ops, method='not a method')
-    with pytest.raises(TypeError):
-        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
-    with pytest.raises(ValueError):
-        qutip.steadystate(H, c_ops, method='direct', solver='Error')
-
-
-def test_bad_options_pseudo_inverse():
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    L = qutip.liouvillian(H, [a])
-    with pytest.raises(TypeError):
-        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
-    with pytest.raises(ValueError):
-        qutip.pseudo_inverse(L, method='not a method', sparse=False)
-    with pytest.raises(ValueError):
-        qutip.pseudo_inverse(L, method='not a method')
-
-
-def test_bad_system():
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    with pytest.raises(TypeError):
-        qutip.steadystate(H, [], method='direct')
-    with pytest.raises(TypeError):
-        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
+import numpy as np
+import pytest
+import qutip
+import warnings
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+                                          reason='MKL extensions not found.')),
+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
+    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
+    pytest.param('eigen', {}, id="eigen"),
+    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
+    pytest.param('svd', {}, id="svd"),
+    pytest.param('power', {'power_tol':1e-5}, id="power"),
+    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+                                          reason='MKL extensions not found.')),
+    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
+    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
+                 id="power-gmres_perm"),
+    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
+    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
+    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
+                 id="iterative-gmres_perm"),
+    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
+                 id="iterative-bicgstab"),
+])
+def test_qubit(method, kwargs):
+    # thermal steadystate of a qubit: compare numerics with analytical formula
+    sz = qutip.sigmaz()
+    sm = qutip.destroy(2)
+
+    H = 0.5 * 2 * np.pi * sz
+    gamma1 = 0.05
+
+    wth_vec = np.linspace(0.1, 3, 20)
+    p_ss = np.zeros(np.shape(wth_vec))
+
+    for idx, wth in enumerate(wth_vec):
+        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
+        c_op_list = []
+        rate = gamma1 * (1 + n_th)
+        c_op_list.append(np.sqrt(rate) * sm)
+        rate = gamma1 * n_th
+        c_op_list.append(np.sqrt(rate) * sm.dag())
+        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
+        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
+
+    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
+    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+                                          reason='MKL extensions not found.')),
+    pytest.param('direct', {'sparse': False}, id="direct_dense"),
+    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
+    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
+    pytest.param('eigen', {}, id="eigen"),
+    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
+    pytest.param('svd', {}, id="svd"),
+])
+def test_exact_solution_for_simple_methods(method, kwargs):
+    # this tests that simple methods correctly determine the steadystate
+    # with high accuracy for a small Liouvillian requiring correct weighting.
+    H = qutip.identity(2)
+    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
+    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
+    expected_rho_ss = np.array([
+        [1.e-10+0.j, 0.e+00-0.j],
+        [0.e+00-0.j, 1.e+00+0.j],
+    ])
+    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
+    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+    pytest.param('eigen', {'sparse':False}, id="eigen"),
+    pytest.param('power', {'power_tol':1e-5}, id="power"),
+    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
+    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
+    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
+])
+def test_ho(method, kwargs):
+    # thermal steadystate of an oscillator: compare numerics with analytical
+    # formula
+    a = qutip.destroy(30)
+    H = 0.5 * 2 * np.pi * a.dag() * a
+    gamma1 = 0.05
+
+    wth_vec = np.linspace(0.1, 3, 11)
+    p_ss = np.zeros(np.shape(wth_vec))
+
+    for idx, wth in enumerate(wth_vec):
+
+        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
+        c_op_list = []
+        rate = gamma1 * (1 + n_th)
+        c_op_list.append(np.sqrt(rate) * a)
+        rate = gamma1 * n_th
+        c_op_list.append(np.sqrt(rate) * a.dag())
+        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
+        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
+
+    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
+    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+    pytest.param('eigen', {}, id="eigen"),
+    pytest.param('svd', {}, id="svd"),
+    pytest.param('power', {}, id="power"),
+    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
+                 id="power-gmres"),
+    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
+                 id="power-bicgstab"),
+    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
+    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
+])
+def test_driven_cavity(method, kwargs):
+    N = 30
+    Omega = 0.01 * 2 * np.pi
+    Gamma = 0.05
+
+    a = qutip.destroy(N)
+    H = Omega * (a.dag() + a)
+    c_ops = [np.sqrt(Gamma) * a]
+    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
+    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
+
+    np.testing.assert_allclose(
+        rho_ss, rho_ss_analytic, atol=1e-4
+    )
+    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('solve', {}, id="dense_direct"),
+    pytest.param('numpy', {}, id="dense_numpy"),
+    pytest.param('spilu', {},  id="spilu"),
+])
+def test_pseudo_inverse(method, kwargs):
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    L = qutip.liouvillian(H, [a])
+    rho = qutip.steadystate(L)
+    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
+    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
+    np.testing.assert_allclose(
+        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
+    )
+    assert rho.tr() == pytest.approx(1, abs=3e-15)
+
+
+@pytest.mark.parametrize('sparse', [True, False])
+def test_steadystate_floquet(sparse):
+    """
+    Test the steadystate solution for a periodically
+    driven system.
+    """
+    N_c = 20
+
+    a = qutip.destroy(N_c)
+    a_d = a.dag()
+    X_c = a + a_d
+
+    w_c = 1
+
+    A_l = 0.001
+    w_l = w_c
+    gam = 0.01
+
+    H = w_c * a_d * a
+
+    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
+
+    psi0 = qutip.fock(N_c, 0)
+
+    args = {"A_l": A_l, "w_l": w_l}
+
+    c_ops = []
+    c_ops.append(np.sqrt(gam) * a)
+
+    t_l = np.linspace(0, 20 / gam, 2000)
+
+    expect_me = qutip.mesolve(H_t, psi0, t_l,
+                        c_ops, [a_d * a], args=args).expect[0]
+
+    rho_ss = qutip.steadystate_floquet(H, c_ops,
+                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
+    expect_ss = qutip.expect(a_d * a, rho_ss)
+
+    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
+    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
+
+
+def test_bad_options_steadystate():
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    c_ops = [a]
+    with pytest.raises(ValueError):
+        qutip.steadystate(H, c_ops, method='not a method')
+    with pytest.raises(TypeError):
+        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
+    with pytest.raises(ValueError):
+        qutip.steadystate(H, c_ops, method='direct', solver='Error')
+
+
+def test_bad_options_pseudo_inverse():
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    L = qutip.liouvillian(H, [a])
+    with pytest.raises(TypeError):
+        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
+    with pytest.raises(ValueError):
+        qutip.pseudo_inverse(L, method='not a method', sparse=False)
+    with pytest.raises(ValueError):
+        qutip.pseudo_inverse(L, method='not a method')
+
+
+def test_bad_system():
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    with pytest.raises(TypeError):
+        qutip.steadystate(H, [], method='direct')
+    with pytest.raises(TypeError):
+        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
diff --git a/qutip/tests/test_basis_transformation.py b/qutip/tests/test_basis_transformation.py
index 1e406e9fa5..080296a325 100644
--- a/qutip/tests/test_basis_transformation.py
+++ b/qutip/tests/test_basis_transformation.py
@@ -1,55 +1,55 @@
-import numpy as np
-import pytest
-import qutip
-
-
-def real_hermitian(n_levels):
-    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
-    return qobj + qobj.dag()
-
-
-def imaginary_hermitian(n_levels):
-    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
-    return qobj + qobj.dag()
-
-
-def complex_hermitian(n_levels):
-    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
-
-
-def rand_bra(n_levels):
-    return qutip.rand_ket(n_levels).dag()
-
-
-@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
-                                                   imaginary_hermitian,
-                                                   complex_hermitian])
-@pytest.mark.parametrize("n_levels", [2, 10])
-def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
-                                                    n_levels):
-    """Transform n-level real-values to eigenbasis and back"""
-    H1 = hermitian_constructor(n_levels)
-    _, ekets = H1.eigenstates()
-    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
-    H2 = Heb.transform(ekets, True)  # Back to original basis
-    assert (H1 - H2).norm() < 1e-6
-
-
-@pytest.mark.parametrize("n_levels", [4])
-def test_ket_and_dm_transformations_equivalent(n_levels):
-    """Consistency between transformations of kets and density matrices."""
-    psi0 = qutip.rand_ket(n_levels)
-    # Generate a random basis
-    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
-    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
-    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
-    assert (rho1 - rho2).norm() < 1e-6
-
-
-def test_eigenbasis_transformation_makes_diagonal_operator():
-    """Check diagonalization via eigenbasis transformation."""
-    cx, cy, cz = np.random.random_sample((3,))
-    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
-    _, ekets = H.eigenstates()
-    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
-    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
+import numpy as np
+import pytest
+import qutip
+
+
+def real_hermitian(n_levels):
+    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
+    return qobj + qobj.dag()
+
+
+def imaginary_hermitian(n_levels):
+    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
+    return qobj + qobj.dag()
+
+
+def complex_hermitian(n_levels):
+    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
+
+
+def rand_bra(n_levels):
+    return qutip.rand_ket(n_levels).dag()
+
+
+@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
+                                                   imaginary_hermitian,
+                                                   complex_hermitian])
+@pytest.mark.parametrize("n_levels", [2, 10])
+def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
+                                                    n_levels):
+    """Transform n-level real-values to eigenbasis and back"""
+    H1 = hermitian_constructor(n_levels)
+    _, ekets = H1.eigenstates()
+    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
+    H2 = Heb.transform(ekets, True)  # Back to original basis
+    assert (H1 - H2).norm() < 1e-6
+
+
+@pytest.mark.parametrize("n_levels", [4])
+def test_ket_and_dm_transformations_equivalent(n_levels):
+    """Consistency between transformations of kets and density matrices."""
+    psi0 = qutip.rand_ket(n_levels)
+    # Generate a random basis
+    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
+    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
+    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
+    assert (rho1 - rho2).norm() < 1e-6
+
+
+def test_eigenbasis_transformation_makes_diagonal_operator():
+    """Check diagonalization via eigenbasis transformation."""
+    cx, cy, cz = np.random.random_sample((3,))
+    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
+    _, ekets = H.eigenstates()
+    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
+    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
diff --git a/qutip/tests/test_bloch.py b/qutip/tests/test_bloch.py
index 33e8fb2fae..e87517d394 100644
--- a/qutip/tests/test_bloch.py
+++ b/qutip/tests/test_bloch.py
@@ -1,479 +1,479 @@
-import copy
-
-import numpy as np
-import pytest
-
-from qutip.bloch import Bloch
-from qutip import ket, ket2dm
-
-try:
-    import matplotlib.pyplot as plt
-    from matplotlib.testing.decorators import check_figures_equal
-    import IPython
-    check_pngs_equal = check_figures_equal(extensions=["png"])
-except ImportError:
-    plt = None
-    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
-
-
-class RefBloch(Bloch):
-    """ A helper for rendering reference Bloch spheres. """
-    def render(self):
-        raise NotImplementedError("RefBloch disables .render()")
-
-    def render_back(self):
-        old_plot_front = self.plot_front
-        self.plot_front = lambda: None
-        try:
-            Bloch.render(self)
-        finally:
-            self.plot_front = old_plot_front
-
-    def render_front(self):
-        self.plot_front()
-
-
-class TestBloch:
-    def plot_arc_test(self, fig, *args, **kw):
-        b = Bloch(fig=fig)
-        b.add_arc(*args, **kw)
-        b.render()
-
-    def plot_arc_ref(self, fig, start, end, **kw):
-        fmt = kw.pop("fmt", "b")
-        steps = kw.pop("steps", None)
-        start = np.array(start)
-        end = np.array(end)
-        if steps is None:
-            steps = int(np.linalg.norm(start - end) * 100)
-            steps = max(2, steps)
-
-        t = np.linspace(0, 1, steps)
-        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
-        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
-
-        b = RefBloch(fig=fig)
-        b.render_back()
-        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
-        b.render_front()
-
-    @pytest.mark.parametrize([
-        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
-    ], [
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
-        pytest.param(
-            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
-            id="small-radius"),
-        pytest.param(
-            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
-            id="tiny-radius"),
-        pytest.param(
-            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
-            id="large-radius"),
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
-            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
-        ),
-        pytest.param(
-            ket("0"), (0, 0, 1),
-            (ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="kets",
-        ),
-        pytest.param(
-            ket2dm(ket("0")), (0, 0, 1),
-            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="dms",
-        ),
-        pytest.param(
-            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
-            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
-            {}, id="non-unit-dms",
-        ),
-    ])
-    @check_pngs_equal
-    def test_arc(
-        self, start_test, start_ref, end_test, end_ref, kwargs,
-        fig_test, fig_ref,
-    ):
-        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
-        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
-
-    @pytest.mark.parametrize([
-        "start", "end", "err_msg",
-    ], [
-        pytest.param(
-            (0, 0, 0), (0, 1, 0),
-            "Polar and azimuthal angles undefined at origin.",
-            id="start-origin",
-        ),
-        pytest.param(
-            (1, 0, 0), (0, 0, 0),
-            "Polar and azimuthal angles undefined at origin.",
-            id="end-origin",
-        ),
-        pytest.param(
-            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
-            id="different-spheres",
-        ),
-        pytest.param(
-            (1, 0, 0), (1, 0, 0),
-            "Start and end represent the same point. No arc can be formed.",
-            id="same-points",
-        ),
-        pytest.param(
-            (1, 0, 0), (-1, 0, 0),
-            "Start and end are diagonally opposite, no unique arc is"
-            " possible.",
-            id="opposite-points",
-        ),
-    ])
-    def test_arc_errors(self, start, end, err_msg):
-        b = Bloch()
-        with pytest.raises(ValueError) as err:
-            b.add_arc(start, end)
-        assert str(err.value) == err_msg
-
-    def plot_line_test(self, fig, *args, **kw):
-        b = Bloch(fig=fig)
-        b.add_line(*args, **kw)
-        b.render()
-
-    def plot_line_ref(self, fig, start, end, **kw):
-        fmt = kw.pop("fmt", "k")
-
-        x = [start[1], end[1]]
-        y = [-start[0], -end[0]]
-        z = [start[2], end[2]]
-
-        b = RefBloch(fig=fig)
-        b.render_back()
-        b.axes.plot(x, y, z, fmt, **kw)
-        b.render_front()
-
-    @pytest.mark.parametrize([
-        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
-    ], [
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
-            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
-        ),
-        pytest.param(
-            ket("0"), (0, 0, 1),
-            (ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="kets",
-        ),
-        pytest.param(
-            ket2dm(ket("0")), (0, 0, 1),
-            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="dms",
-        ),
-        pytest.param(
-            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
-            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
-            {}, id="non-unit-dms",
-        ),
-    ])
-    @check_pngs_equal
-    def test_line(
-        self, start_test, start_ref, end_test, end_ref, kwargs,
-        fig_test, fig_ref,
-    ):
-        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
-        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
-
-    def plot_point_test(self, fig, point_kws):
-        b = Bloch(fig=fig)
-        for kw in point_kws:
-            points = kw.pop("points")
-            b.add_points(points, **kw)
-        b.render()
-
-    def plot_point_ref(self, fig, point_kws):
-        b = RefBloch(fig=fig)
-        b.render_back()
-        point_colors = ['b', 'r', 'g', '#CC6600']
-        point_sizes = [25, 32, 35, 45]
-        point_markers = ["o", "s", "d", "^"]
-
-        for idx, kw in enumerate(point_kws):
-            points = kw.pop("points")
-            if not isinstance(points[0], (list, tuple, np.ndarray)):
-                points = [[points[0]], [points[1]], [points[2]]]
-            points = np.array(points)
-
-            point_style = kw.pop("meth", "s")
-            colors = kw.pop("colors", None)
-            if colors is None and point_style in ['s', 'l']:
-                colors = point_colors[idx % len(point_colors)]
-            elif colors is None and point_style == 'm':
-                colors = np.tile(point_colors,
-                                 np.ceil(points.shape[1]/len(point_colors)
-                                         ).astype(int))
-                colors = colors[:points.shape[1]]
-            point_size = point_sizes[idx % len(point_sizes)]
-            point_marker = point_markers[idx % len(point_markers)]
-            point_alpha = kw.get("alpha", 1.0)
-
-            if len(points[0]) == 1 and point_style == "s":
-                points = np.append(points, points, axis=1)
-
-            if point_style == 's':
-                b.axes.scatter(
-                    np.real(points[1]),
-                    -np.real(points[0]),
-                    np.real(points[2]),
-                    s=point_size,
-                    alpha=point_alpha,
-                    edgecolor=None,
-                    zdir='z',
-                    color=colors,
-                    marker=point_marker)
-            elif point_style == 'l':
-                b.axes.plot(
-                    np.real(points[1]),
-                    -np.real(points[0]),
-                    np.real(points[2]),
-                    alpha=point_alpha,
-                    zdir='z',
-                    color=colors,
-                )
-            elif point_style == 'm':
-                b.axes.scatter(
-                    np.real(points[1]),
-                    -np.real(points[0]),
-                    np.real(points[2]),
-                    s=point_size,
-                    marker=point_marker,
-                    color=colors,
-                    alpha=point_alpha,
-                    edgecolor=None,
-                    zdir='z',
-                )
-            else:
-                raise ValueError(
-                    "Tests currently only support point method 's'"
-                )
-        b.render_front()
-
-    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
-                                                               "scatter",
-                                                               "line",
-                                                               "multicolored"])
-    @pytest.mark.parametrize([
-        "point_kws"
-    ], [
-        pytest.param(
-            dict(points=np.array([
-                [
-                    np.cos(np.pi / 4) * np.cos(t),
-                    np.sin(np.pi / 4) * np.cos(t),
-                    np.sin(t),
-                ]
-                for t in np.linspace(0, 2 * np.pi, 20)
-            ]).T, alpha=0.5), id="circle-of-points"),
-        pytest.param(
-            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
-        pytest.param(
-            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
-        pytest.param(
-            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
-        pytest.param(
-            dict(points=(0, 0, 1)), id="alpha-default"),
-        pytest.param(
-            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
-            id="color-green"),
-        pytest.param([
-            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
-            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
-        ], id="alpha-multiple-point-sets"),
-        pytest.param([
-            dict(points=[(0), (0), (1)], alpha=1.0),
-            dict(points=[(0), (1), (0)], alpha=1.0),
-            dict(points=[(1), (0), (0)], alpha=1.0),
-            dict(points=[(1), (1), (1)], alpha=1.0),
-        ], id="alpha-multiple-point-sets-all_sizes_markers"),
-    ])
-    @check_pngs_equal
-    def test_point(self, point_kws, meth, fig_test, fig_ref):
-        if meth and isinstance(point_kws, dict):
-            point_kws["meth"] = meth
-
-        elif meth and isinstance(point_kws, list):
-            for point_kw in point_kws:
-                point_kw["meth"] = meth
-
-        if isinstance(point_kws, dict):
-            point_kws = [point_kws]
-
-        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
-        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
-
-    def test_point_errors_meth(self):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_points((0, 0, 1), meth='k')
-            b.render()
-
-        err_msg = ("The value for meth = k is not valid."
-                   " Please use 's', 'l' or 'm'.")
-        assert str(err.value) == err_msg
-
-    @pytest.mark.parametrize("points",
-                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
-                              np.arange(12).reshape((3, 2, 2))],
-                             ids=["long_tuple", "short_tuple", "short_list",
-                                  "short_numpy", "wrong_shape_numpy"]
-                             )
-    def test_point_errors_wrong_points(self, points):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_points(points)
-            b.render()
-
-        err_msg = ("The included points are not valid. Points must "
-                   "be equivalent to a 2D array where the first "
-                   "index represents the x,y,z values and the "
-                   "second index iterates over the points.")
-        assert str(err.value) == err_msg
-
-    def plot_vector_test(self, fig, vector_kws):
-        b = Bloch(fig=fig)
-        for kw in vector_kws:
-            vectors = kw.pop("vectors")
-            b.add_vectors(vectors, **kw)
-        b.render()
-
-    def plot_vector_ref(self, fig, vector_kws):
-        from qutip.bloch import Arrow3D
-        b = RefBloch(fig=fig)
-        b.render_back()
-        vector_colors = ['g', '#CC6600', 'b', 'r']
-        idx = 0
-
-        for kw in vector_kws:
-            vectors = kw.pop("vectors")
-
-            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
-                vectors = [vectors]
-
-            colors = kw.pop("colors", None)
-            for k, v in enumerate(vectors):
-                if colors is None:
-                    color = vector_colors[idx % len(vector_colors)]
-                else:
-                    color = colors[k]
-
-                alpha = kw.get("alpha", 1.0)
-                idx += 1
-
-                xs3d = v[1] * np.array([0, 1])
-                ys3d = -v[0] * np.array([0, 1])
-                zs3d = v[2] * np.array([0, 1])
-                a = Arrow3D(
-                    xs3d, ys3d, zs3d,
-                    mutation_scale=20, lw=3, arrowstyle="-|>",
-                    color=color, alpha=alpha)
-                b.axes.add_artist(a)
-        b.render_front()
-
-    @pytest.mark.parametrize([
-        "vector_kws"
-    ], [
-        pytest.param(
-            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
-        pytest.param(
-            dict(vectors=[0, 0, 1]), id="single-vector-list"),
-        pytest.param(
-            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
-        pytest.param(
-            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
-        pytest.param(
-            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
-        pytest.param(
-            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
-        pytest.param(
-            dict(vectors=[
-                [
-                    np.cos(np.pi / 4) * np.cos(t),
-                    np.sin(np.pi / 4) * np.cos(t),
-                    np.sin(t),
-                ]
-                for t in np.linspace(0, 2 * np.pi, 20)
-            ], alpha=0.5), id="circle-of-vectors"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
-        pytest.param(
-            dict(vectors=(0, 0, 1)), id="alpha-default"),
-        pytest.param([
-            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
-            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
-        ], id="alpha-multiple-vector-sets"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
-        pytest.param(
-            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
-            id="color-two-y"),
-        pytest.param([
-            dict(vectors=[(0, 0, 1)], colors=['y']),
-            dict(vectors=[(1, 0, 1)], colors=['g']),
-        ], id="color-yg"),
-    ])
-    @check_pngs_equal
-    def test_vector(self, vector_kws, fig_test, fig_ref):
-        if isinstance(vector_kws, dict):
-            vector_kws = [vector_kws]
-        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
-        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
-
-    @pytest.mark.parametrize("vectors",
-                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
-                              np.arange(12).reshape((3, 2, 2))],
-                             ids=["long_tuple", "short_tuple", "short_list",
-                                  "short_numpy", "wrong_shape_numpy"]
-                             )
-    def test_vector_errors_wrong_vectors(self, vectors):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_vectors(vectors)
-            b.render()
-
-        err_msg = ("The included vectors are not valid. Vectors must "
-                   "be equivalent to a 2D array where the first "
-                   "index represents the iteration over the vectors and the "
-                   "second index represents the position in 3D of vector "
-                   "head.")
-        assert str(err.value) == err_msg
-
-    @pytest.mark.parametrize("vectors, colors",
-                             [([0, 0, 1], ['g', 'y']),
-                              ([[0, 0, 1], [0, 1, 0]], ['y']),
-                              ([0, 0, 1], [['g', 'y']])],
-                             ids=["one-vec-two-colors", "two-vec-one-color",
-                                  "wrong-dimension-list"]
-                             )
-    def test_vector_errors_color_length(self, vectors, colors):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_vectors(vectors, colors=colors)
-            b.render()
-
-        err_msg = ("The included colors are not valid. colors must "
-                   "be equivalent to a 1D array with the same "
-                   "size as the number of vectors. ")
-        assert str(err.value) == err_msg
-
-
-def test_repr_svg():
-    pytest.importorskip("matplotlib")
-    pytest.importorskip("ipython")
-    svg = Bloch()._repr_svg_()
-    assert isinstance(svg, str)
-    assert svg.startswith("<?xml")
-    assert svg.endswith("</svg>\n")
+import copy
+
+import numpy as np
+import pytest
+
+from qutip.bloch import Bloch
+from qutip import ket, ket2dm
+
+try:
+    import matplotlib.pyplot as plt
+    from matplotlib.testing.decorators import check_figures_equal
+    import IPython
+    check_pngs_equal = check_figures_equal(extensions=["png"])
+except ImportError:
+    plt = None
+    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
+
+
+class RefBloch(Bloch):
+    """ A helper for rendering reference Bloch spheres. """
+    def render(self):
+        raise NotImplementedError("RefBloch disables .render()")
+
+    def render_back(self):
+        old_plot_front = self.plot_front
+        self.plot_front = lambda: None
+        try:
+            Bloch.render(self)
+        finally:
+            self.plot_front = old_plot_front
+
+    def render_front(self):
+        self.plot_front()
+
+
+class TestBloch:
+    def plot_arc_test(self, fig, *args, **kw):
+        b = Bloch(fig=fig)
+        b.add_arc(*args, **kw)
+        b.render()
+
+    def plot_arc_ref(self, fig, start, end, **kw):
+        fmt = kw.pop("fmt", "b")
+        steps = kw.pop("steps", None)
+        start = np.array(start)
+        end = np.array(end)
+        if steps is None:
+            steps = int(np.linalg.norm(start - end) * 100)
+            steps = max(2, steps)
+
+        t = np.linspace(0, 1, steps)
+        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
+        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
+
+        b = RefBloch(fig=fig)
+        b.render_back()
+        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
+        b.render_front()
+
+    @pytest.mark.parametrize([
+        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
+    ], [
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
+        pytest.param(
+            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
+            id="small-radius"),
+        pytest.param(
+            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
+            id="tiny-radius"),
+        pytest.param(
+            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
+            id="large-radius"),
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
+            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
+        ),
+        pytest.param(
+            ket("0"), (0, 0, 1),
+            (ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="kets",
+        ),
+        pytest.param(
+            ket2dm(ket("0")), (0, 0, 1),
+            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="dms",
+        ),
+        pytest.param(
+            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
+            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
+            {}, id="non-unit-dms",
+        ),
+    ])
+    @check_pngs_equal
+    def test_arc(
+        self, start_test, start_ref, end_test, end_ref, kwargs,
+        fig_test, fig_ref,
+    ):
+        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
+        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
+
+    @pytest.mark.parametrize([
+        "start", "end", "err_msg",
+    ], [
+        pytest.param(
+            (0, 0, 0), (0, 1, 0),
+            "Polar and azimuthal angles undefined at origin.",
+            id="start-origin",
+        ),
+        pytest.param(
+            (1, 0, 0), (0, 0, 0),
+            "Polar and azimuthal angles undefined at origin.",
+            id="end-origin",
+        ),
+        pytest.param(
+            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
+            id="different-spheres",
+        ),
+        pytest.param(
+            (1, 0, 0), (1, 0, 0),
+            "Start and end represent the same point. No arc can be formed.",
+            id="same-points",
+        ),
+        pytest.param(
+            (1, 0, 0), (-1, 0, 0),
+            "Start and end are diagonally opposite, no unique arc is"
+            " possible.",
+            id="opposite-points",
+        ),
+    ])
+    def test_arc_errors(self, start, end, err_msg):
+        b = Bloch()
+        with pytest.raises(ValueError) as err:
+            b.add_arc(start, end)
+        assert str(err.value) == err_msg
+
+    def plot_line_test(self, fig, *args, **kw):
+        b = Bloch(fig=fig)
+        b.add_line(*args, **kw)
+        b.render()
+
+    def plot_line_ref(self, fig, start, end, **kw):
+        fmt = kw.pop("fmt", "k")
+
+        x = [start[1], end[1]]
+        y = [-start[0], -end[0]]
+        z = [start[2], end[2]]
+
+        b = RefBloch(fig=fig)
+        b.render_back()
+        b.axes.plot(x, y, z, fmt, **kw)
+        b.render_front()
+
+    @pytest.mark.parametrize([
+        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
+    ], [
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
+            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
+        ),
+        pytest.param(
+            ket("0"), (0, 0, 1),
+            (ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="kets",
+        ),
+        pytest.param(
+            ket2dm(ket("0")), (0, 0, 1),
+            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="dms",
+        ),
+        pytest.param(
+            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
+            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
+            {}, id="non-unit-dms",
+        ),
+    ])
+    @check_pngs_equal
+    def test_line(
+        self, start_test, start_ref, end_test, end_ref, kwargs,
+        fig_test, fig_ref,
+    ):
+        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
+        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
+
+    def plot_point_test(self, fig, point_kws):
+        b = Bloch(fig=fig)
+        for kw in point_kws:
+            points = kw.pop("points")
+            b.add_points(points, **kw)
+        b.render()
+
+    def plot_point_ref(self, fig, point_kws):
+        b = RefBloch(fig=fig)
+        b.render_back()
+        point_colors = ['b', 'r', 'g', '#CC6600']
+        point_sizes = [25, 32, 35, 45]
+        point_markers = ["o", "s", "d", "^"]
+
+        for idx, kw in enumerate(point_kws):
+            points = kw.pop("points")
+            if not isinstance(points[0], (list, tuple, np.ndarray)):
+                points = [[points[0]], [points[1]], [points[2]]]
+            points = np.array(points)
+
+            point_style = kw.pop("meth", "s")
+            colors = kw.pop("colors", None)
+            if colors is None and point_style in ['s', 'l']:
+                colors = point_colors[idx % len(point_colors)]
+            elif colors is None and point_style == 'm':
+                colors = np.tile(point_colors,
+                                 np.ceil(points.shape[1]/len(point_colors)
+                                         ).astype(int))
+                colors = colors[:points.shape[1]]
+            point_size = point_sizes[idx % len(point_sizes)]
+            point_marker = point_markers[idx % len(point_markers)]
+            point_alpha = kw.get("alpha", 1.0)
+
+            if len(points[0]) == 1 and point_style == "s":
+                points = np.append(points, points, axis=1)
+
+            if point_style == 's':
+                b.axes.scatter(
+                    np.real(points[1]),
+                    -np.real(points[0]),
+                    np.real(points[2]),
+                    s=point_size,
+                    alpha=point_alpha,
+                    edgecolor=None,
+                    zdir='z',
+                    color=colors,
+                    marker=point_marker)
+            elif point_style == 'l':
+                b.axes.plot(
+                    np.real(points[1]),
+                    -np.real(points[0]),
+                    np.real(points[2]),
+                    alpha=point_alpha,
+                    zdir='z',
+                    color=colors,
+                )
+            elif point_style == 'm':
+                b.axes.scatter(
+                    np.real(points[1]),
+                    -np.real(points[0]),
+                    np.real(points[2]),
+                    s=point_size,
+                    marker=point_marker,
+                    color=colors,
+                    alpha=point_alpha,
+                    edgecolor=None,
+                    zdir='z',
+                )
+            else:
+                raise ValueError(
+                    "Tests currently only support point method 's'"
+                )
+        b.render_front()
+
+    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
+                                                               "scatter",
+                                                               "line",
+                                                               "multicolored"])
+    @pytest.mark.parametrize([
+        "point_kws"
+    ], [
+        pytest.param(
+            dict(points=np.array([
+                [
+                    np.cos(np.pi / 4) * np.cos(t),
+                    np.sin(np.pi / 4) * np.cos(t),
+                    np.sin(t),
+                ]
+                for t in np.linspace(0, 2 * np.pi, 20)
+            ]).T, alpha=0.5), id="circle-of-points"),
+        pytest.param(
+            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
+        pytest.param(
+            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
+        pytest.param(
+            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
+        pytest.param(
+            dict(points=(0, 0, 1)), id="alpha-default"),
+        pytest.param(
+            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
+            id="color-green"),
+        pytest.param([
+            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
+            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
+        ], id="alpha-multiple-point-sets"),
+        pytest.param([
+            dict(points=[(0), (0), (1)], alpha=1.0),
+            dict(points=[(0), (1), (0)], alpha=1.0),
+            dict(points=[(1), (0), (0)], alpha=1.0),
+            dict(points=[(1), (1), (1)], alpha=1.0),
+        ], id="alpha-multiple-point-sets-all_sizes_markers"),
+    ])
+    @check_pngs_equal
+    def test_point(self, point_kws, meth, fig_test, fig_ref):
+        if meth and isinstance(point_kws, dict):
+            point_kws["meth"] = meth
+
+        elif meth and isinstance(point_kws, list):
+            for point_kw in point_kws:
+                point_kw["meth"] = meth
+
+        if isinstance(point_kws, dict):
+            point_kws = [point_kws]
+
+        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
+        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
+
+    def test_point_errors_meth(self):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_points((0, 0, 1), meth='k')
+            b.render()
+
+        err_msg = ("The value for meth = k is not valid."
+                   " Please use 's', 'l' or 'm'.")
+        assert str(err.value) == err_msg
+
+    @pytest.mark.parametrize("points",
+                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
+                              np.arange(12).reshape((3, 2, 2))],
+                             ids=["long_tuple", "short_tuple", "short_list",
+                                  "short_numpy", "wrong_shape_numpy"]
+                             )
+    def test_point_errors_wrong_points(self, points):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_points(points)
+            b.render()
+
+        err_msg = ("The included points are not valid. Points must "
+                   "be equivalent to a 2D array where the first "
+                   "index represents the x,y,z values and the "
+                   "second index iterates over the points.")
+        assert str(err.value) == err_msg
+
+    def plot_vector_test(self, fig, vector_kws):
+        b = Bloch(fig=fig)
+        for kw in vector_kws:
+            vectors = kw.pop("vectors")
+            b.add_vectors(vectors, **kw)
+        b.render()
+
+    def plot_vector_ref(self, fig, vector_kws):
+        from qutip.bloch import Arrow3D
+        b = RefBloch(fig=fig)
+        b.render_back()
+        vector_colors = ['g', '#CC6600', 'b', 'r']
+        idx = 0
+
+        for kw in vector_kws:
+            vectors = kw.pop("vectors")
+
+            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
+                vectors = [vectors]
+
+            colors = kw.pop("colors", None)
+            for k, v in enumerate(vectors):
+                if colors is None:
+                    color = vector_colors[idx % len(vector_colors)]
+                else:
+                    color = colors[k]
+
+                alpha = kw.get("alpha", 1.0)
+                idx += 1
+
+                xs3d = v[1] * np.array([0, 1])
+                ys3d = -v[0] * np.array([0, 1])
+                zs3d = v[2] * np.array([0, 1])
+                a = Arrow3D(
+                    xs3d, ys3d, zs3d,
+                    mutation_scale=20, lw=3, arrowstyle="-|>",
+                    color=color, alpha=alpha)
+                b.axes.add_artist(a)
+        b.render_front()
+
+    @pytest.mark.parametrize([
+        "vector_kws"
+    ], [
+        pytest.param(
+            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
+        pytest.param(
+            dict(vectors=[0, 0, 1]), id="single-vector-list"),
+        pytest.param(
+            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
+        pytest.param(
+            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
+        pytest.param(
+            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
+        pytest.param(
+            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
+        pytest.param(
+            dict(vectors=[
+                [
+                    np.cos(np.pi / 4) * np.cos(t),
+                    np.sin(np.pi / 4) * np.cos(t),
+                    np.sin(t),
+                ]
+                for t in np.linspace(0, 2 * np.pi, 20)
+            ], alpha=0.5), id="circle-of-vectors"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
+        pytest.param(
+            dict(vectors=(0, 0, 1)), id="alpha-default"),
+        pytest.param([
+            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
+            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
+        ], id="alpha-multiple-vector-sets"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
+        pytest.param(
+            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
+            id="color-two-y"),
+        pytest.param([
+            dict(vectors=[(0, 0, 1)], colors=['y']),
+            dict(vectors=[(1, 0, 1)], colors=['g']),
+        ], id="color-yg"),
+    ])
+    @check_pngs_equal
+    def test_vector(self, vector_kws, fig_test, fig_ref):
+        if isinstance(vector_kws, dict):
+            vector_kws = [vector_kws]
+        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
+        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
+
+    @pytest.mark.parametrize("vectors",
+                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
+                              np.arange(12).reshape((3, 2, 2))],
+                             ids=["long_tuple", "short_tuple", "short_list",
+                                  "short_numpy", "wrong_shape_numpy"]
+                             )
+    def test_vector_errors_wrong_vectors(self, vectors):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_vectors(vectors)
+            b.render()
+
+        err_msg = ("The included vectors are not valid. Vectors must "
+                   "be equivalent to a 2D array where the first "
+                   "index represents the iteration over the vectors and the "
+                   "second index represents the position in 3D of vector "
+                   "head.")
+        assert str(err.value) == err_msg
+
+    @pytest.mark.parametrize("vectors, colors",
+                             [([0, 0, 1], ['g', 'y']),
+                              ([[0, 0, 1], [0, 1, 0]], ['y']),
+                              ([0, 0, 1], [['g', 'y']])],
+                             ids=["one-vec-two-colors", "two-vec-one-color",
+                                  "wrong-dimension-list"]
+                             )
+    def test_vector_errors_color_length(self, vectors, colors):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_vectors(vectors, colors=colors)
+            b.render()
+
+        err_msg = ("The included colors are not valid. colors must "
+                   "be equivalent to a 1D array with the same "
+                   "size as the number of vectors. ")
+        assert str(err.value) == err_msg
+
+
+def test_repr_svg():
+    pytest.importorskip("matplotlib")
+    pytest.importorskip("ipython")
+    svg = Bloch()._repr_svg_()
+    assert isinstance(svg, str)
+    assert svg.startswith("<?xml")
+    assert svg.endswith("</svg>\n")
diff --git a/qutip/tests/test_enr_state_operator.py b/qutip/tests/test_enr_state_operator.py
index 9002c3759b..d07b7ebbec 100644
--- a/qutip/tests/test_enr_state_operator.py
+++ b/qutip/tests/test_enr_state_operator.py
@@ -1,116 +1,116 @@
-import pytest
-import itertools
-import random
-import numpy as np
-import qutip
-
-
-def _n_enr_states(dimensions, n_excitations):
-    """
-    Calculate the total number of distinct ENR states for a given set of
-    subspaces.  This method is not intended to be fast or efficient, it's
-    intended to be obviously correct for testing purposes.
-    """
-    count = 0
-    for excitations in itertools.product(*map(range, dimensions)):
-        count += int(sum(excitations) <= n_excitations)
-    return count
-
-
-@pytest.fixture(params=[
-    pytest.param([4], id="single"),
-    pytest.param([4]*2, id="tensor-equal-2"),
-    pytest.param([4]*3, id="tensor-equal-3"),
-    pytest.param([4]*4, id="tensor-equal-4"),
-    pytest.param([2, 3, 4], id="tensor-not-equal"),
-])
-def dimensions(request):
-    return request.param
-
-
-@pytest.fixture(params=[1, 2, 3, 1_000_000])
-def n_excitations(request):
-    return request.param
-
-
-class TestOperator:
-    def test_no_restrictions(self, dimensions):
-        """
-        Test that the restricted-excitation operators are equal to the standard
-        operators when there aren't any restrictions.
-        """
-        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
-        a = [qutip.destroy(n) for n in dimensions]
-        iden = [qutip.qeye(n) for n in dimensions]
-        for i, test in enumerate(test_operators):
-            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
-            assert test == expected
-            assert test.dims == [dimensions, dimensions]
-
-    def test_space_size_reduction(self, dimensions, n_excitations):
-        test_operators = qutip.enr_destroy(dimensions, n_excitations)
-        expected_size = _n_enr_states(dimensions, n_excitations)
-        expected_shape = (expected_size, expected_size)
-        for test in test_operators:
-            assert test.shape == expected_shape
-            assert test.dims == [dimensions, dimensions]
-
-    def test_identity(self, dimensions, n_excitations):
-        iden = qutip.enr_identity(dimensions, n_excitations)
-        expected_size = _n_enr_states(dimensions, n_excitations)
-        expected_shape = (expected_size, expected_size)
-        assert np.all(iden.diag() == 1)
-        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
-        assert iden.shape == expected_shape
-        assert iden.dims == [dimensions, dimensions]
-
-
-def test_fock_state(dimensions, n_excitations):
-    """
-    Test Fock state creation agrees with the number operators implied by the
-    existence of the ENR annihiliation operators.
-    """
-    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
-    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
-    n_samples = min((len(bases), 5))
-    for basis in random.sample(bases, n_samples):
-        state = qutip.enr_fock(dimensions, n_excitations, basis)
-        for n, x in zip(number, basis):
-            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
-
-
-def test_fock_state_error():
-    with pytest.raises(ValueError) as e:
-        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
-    assert str(e.value).startswith("The state tuple ")
-
-
-def _reference_dm(dimensions, n_excitations, nbars):
-    """
-    Get the reference density matrix explicitly, to compare to the direct ENR
-    construction.
-    """
-    if np.isscalar(nbars):
-        nbars = [nbars] * len(dimensions)
-    keep = np.array([
-        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
-        if sum(state) <= n_excitations
-    ])
-    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
-                       for dimension, nbar in zip(dimensions, nbars)])
-    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
-    return out / out.tr()
-
-
-@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
-def test_thermal_dm(dimensions, n_excitations, nbar_type):
-    # Ensure that the average number of excitations over all the states is
-    # much less than the total number of allowed excitations.
-    if nbar_type == "scalar":
-        nbars = 0.1 * n_excitations / len(dimensions)
-    else:
-        nbars = np.random.rand(len(dimensions))
-        nbars *= (0.1 * n_excitations) / np.sum(nbars)
-    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
-    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
-    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
+import pytest
+import itertools
+import random
+import numpy as np
+import qutip
+
+
+def _n_enr_states(dimensions, n_excitations):
+    """
+    Calculate the total number of distinct ENR states for a given set of
+    subspaces.  This method is not intended to be fast or efficient, it's
+    intended to be obviously correct for testing purposes.
+    """
+    count = 0
+    for excitations in itertools.product(*map(range, dimensions)):
+        count += int(sum(excitations) <= n_excitations)
+    return count
+
+
+@pytest.fixture(params=[
+    pytest.param([4], id="single"),
+    pytest.param([4]*2, id="tensor-equal-2"),
+    pytest.param([4]*3, id="tensor-equal-3"),
+    pytest.param([4]*4, id="tensor-equal-4"),
+    pytest.param([2, 3, 4], id="tensor-not-equal"),
+])
+def dimensions(request):
+    return request.param
+
+
+@pytest.fixture(params=[1, 2, 3, 1_000_000])
+def n_excitations(request):
+    return request.param
+
+
+class TestOperator:
+    def test_no_restrictions(self, dimensions):
+        """
+        Test that the restricted-excitation operators are equal to the standard
+        operators when there aren't any restrictions.
+        """
+        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
+        a = [qutip.destroy(n) for n in dimensions]
+        iden = [qutip.qeye(n) for n in dimensions]
+        for i, test in enumerate(test_operators):
+            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
+            assert test == expected
+            assert test.dims == [dimensions, dimensions]
+
+    def test_space_size_reduction(self, dimensions, n_excitations):
+        test_operators = qutip.enr_destroy(dimensions, n_excitations)
+        expected_size = _n_enr_states(dimensions, n_excitations)
+        expected_shape = (expected_size, expected_size)
+        for test in test_operators:
+            assert test.shape == expected_shape
+            assert test.dims == [dimensions, dimensions]
+
+    def test_identity(self, dimensions, n_excitations):
+        iden = qutip.enr_identity(dimensions, n_excitations)
+        expected_size = _n_enr_states(dimensions, n_excitations)
+        expected_shape = (expected_size, expected_size)
+        assert np.all(iden.diag() == 1)
+        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
+        assert iden.shape == expected_shape
+        assert iden.dims == [dimensions, dimensions]
+
+
+def test_fock_state(dimensions, n_excitations):
+    """
+    Test Fock state creation agrees with the number operators implied by the
+    existence of the ENR annihiliation operators.
+    """
+    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
+    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
+    n_samples = min((len(bases), 5))
+    for basis in random.sample(bases, n_samples):
+        state = qutip.enr_fock(dimensions, n_excitations, basis)
+        for n, x in zip(number, basis):
+            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
+
+
+def test_fock_state_error():
+    with pytest.raises(ValueError) as e:
+        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
+    assert str(e.value).startswith("The state tuple ")
+
+
+def _reference_dm(dimensions, n_excitations, nbars):
+    """
+    Get the reference density matrix explicitly, to compare to the direct ENR
+    construction.
+    """
+    if np.isscalar(nbars):
+        nbars = [nbars] * len(dimensions)
+    keep = np.array([
+        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
+        if sum(state) <= n_excitations
+    ])
+    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
+                       for dimension, nbar in zip(dimensions, nbars)])
+    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
+    return out / out.tr()
+
+
+@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
+def test_thermal_dm(dimensions, n_excitations, nbar_type):
+    # Ensure that the average number of excitations over all the states is
+    # much less than the total number of allowed excitations.
+    if nbar_type == "scalar":
+        nbars = 0.1 * n_excitations / len(dimensions)
+    else:
+        nbars = np.random.rand(len(dimensions))
+        nbars *= (0.1 * n_excitations) / np.sum(nbars)
+    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
+    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
+    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
diff --git a/qutip/tests/test_entropy.py b/qutip/tests/test_entropy.py
index ecf465c9bf..ea0f0c3543 100644
--- a/qutip/tests/test_entropy.py
+++ b/qutip/tests/test_entropy.py
@@ -1,212 +1,212 @@
-import pytest
-import numpy as np
-import qutip
-
-
-class TestVonNeumannEntropy:
-    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
-    def test_binary(self, p):
-        dm = qutip.qdiags([p, 1 - p], 0)
-        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
-        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
-
-    @pytest.mark.repeat(10)
-    def test_pure_state(self):
-        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
-
-
-class TestLinearEntropy:
-    @pytest.mark.repeat(10)
-    def test_less_than_von_neumann(self):
-        dm = qutip.rand_dm(10)
-        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
-
-    @pytest.mark.repeat(10)
-    def test_pure_state(self):
-        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
-
-
-class TestConcurrence:
-    @pytest.mark.parametrize("dm", [
-        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
-        for x in ['00', '01', '10', '11']
-    ])
-    def test_maximally_entangled(self, dm):
-        assert abs(qutip.concurrence(dm) - 1) < 1e-12
-
-    @pytest.mark.repeat(10)
-    def test_nonzero(self):
-        dm = qutip.rand_dm([2, 2])
-        assert qutip.concurrence(dm) >= 0
-
-
-@pytest.mark.repeat(10)
-class TestMutualInformation:
-    def test_pure_state_additive(self):
-        # Verify mutual information = S(A) + S(B) for pure states.
-        dm = qutip.rand_dm([5, 5], distribution="pure")
-        expect = (qutip.entropy_vn(dm.ptrace(0))
-                  + qutip.entropy_vn(dm.ptrace(1)))
-        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
-
-    def test_component_selection(self):
-        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
-        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
-                  + qutip.entropy_vn(dm.ptrace(1)))
-        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
-
-
-class TestRelativeEntropy:
-    def _simple_relative_entropy_implementation(
-            self, rho, sigma, log_base=np.log, tol=1e-12):
-        """ A simplified relative entropy implementation for use in
-            double-checking the optimised implementation within
-            QuTiP itself.
-        """
-        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
-        rvals, rvecs = rho.eigenstates()
-        svals, svecs = sigma.eigenstates()
-        rvecs = np.hstack([vec.full() for vec in rvecs]).T
-        svecs = np.hstack([vec.full() for vec in svecs]).T
-        # Calculate S
-        S = 0
-        for i in range(len(rvals)):
-            if abs(rvals[i]) >= tol:
-                S += rvals[i] * log_base(rvals[i])
-            for j in range(len(svals)):
-                P_ij = (
-                    np.dot(rvecs[i], svecs[j].conjugate()) *
-                    np.dot(svecs[j], rvecs[i].conjugate())
-                )
-                if abs(svals[j]) < tol and not (
-                        abs(rvals[i]) < tol or abs(P_ij) < tol):
-                    # kernel of sigma intersects support of rho
-                    return np.inf
-                if abs(svals[j]) >= tol:
-                    S -= rvals[i] * P_ij * log_base(svals[j])
-        return np.real(S)
-
-    def test_rho_or_sigma_not_oper(self):
-        rho = qutip.bra("00")
-        sigma = qutip.bra("01")
-        with pytest.raises(TypeError) as exc:
-            qutip.entropy_relative(rho.dag(), sigma)
-        assert str(exc.value) == "Inputs must be density matrices."
-        with pytest.raises(TypeError) as exc:
-            qutip.entropy_relative(rho, sigma.dag())
-        assert str(exc.value) == "Inputs must be density matrices."
-        with pytest.raises(TypeError) as exc:
-            qutip.entropy_relative(rho, sigma)
-        assert str(exc.value) == "Inputs must be density matrices."
-
-    def test_rho_and_sigma_have_different_shape_and_dims(self):
-        # test different shape and dims
-        rho = qutip.ket("00")
-        sigma = qutip.ket("0")
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma)
-        assert str(exc.value) == "Inputs must have the same shape and dims."
-        # test same shape, difference dims
-        rho = qutip.basis([2, 3], [0, 0])
-        sigma = qutip.basis([3, 2], [0, 0])
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma)
-        assert str(exc.value) == "Inputs must have the same shape and dims."
-
-    def test_base_not_2_or_e(self):
-        rho = qutip.ket("00")
-        sigma = qutip.ket("01")
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma, base=3)
-        assert str(exc.value) == "Base must be 2 or e."
-
-    def test_infinite_relative_entropy(self):
-        rho = qutip.ket("00")
-        sigma = qutip.ket("01")
-        assert qutip.entropy_relative(rho, sigma) == np.inf
-
-    def test_base_2_or_e(self):
-        rho = qutip.ket2dm(qutip.ket("00"))
-        sigma = rho + qutip.ket2dm(qutip.ket("01"))
-        sigma = sigma.unit()
-        assert (
-            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
-        )
-        assert (
-            qutip.entropy_relative(rho, sigma, base=np.e)
-            == pytest.approx(0.69314718)
-        )
-        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
-
-    def test_pure_vs_maximally_mixed_state(self):
-        rho = qutip.ket("00")
-        sigma = sum(
-            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
-        ).unit()
-        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
-
-    def test_density_matrices_with_non_real_eigenvalues(self):
-        rho = qutip.ket2dm(qutip.ket("00"))
-        sigma = qutip.ket2dm(qutip.ket("01"))
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho + 1j, sigma)
-        assert str(exc.value) == "Input rho has non-real eigenvalues."
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho - 1j, sigma)
-        assert str(exc.value) == "Input rho has non-real eigenvalues."
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma + 1j)
-        assert str(exc.value) == "Input sigma has non-real eigenvalues."
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma - 1j)
-        assert str(exc.value) == "Input sigma has non-real eigenvalues."
-
-    @pytest.mark.repeat(20)
-    def test_random_dm_with_self(self):
-        rho = qutip.rand_dm(8)
-        rel = qutip.entropy_relative(rho, rho)
-        assert abs(rel) < 1e-13
-
-    @pytest.mark.repeat(20)
-    def test_random_rho_sigma(self):
-        rho = qutip.rand_dm(8)
-        sigma = qutip.rand_dm(8)
-        rel = qutip.entropy_relative(rho, sigma)
-        assert rel >= 0
-        assert rel == pytest.approx(
-            self._simple_relative_entropy_implementation(rho, sigma, np.log)
-        )
-
-
-@pytest.mark.repeat(20)
-class TestConditionalEntropy:
-    def test_inequality_3_qubits(self):
-        # S(A | B,C) <= S(A|B)
-        full = qutip.rand_dm([2]*3, distribution="pure")
-        ab = full.ptrace([0, 1])
-        assert (qutip.entropy_conditional(full, [1, 2])
-                <= qutip.entropy_conditional(ab, 1))
-
-    def test_triangle_inequality_4_qubits(self):
-        # S(A,B | C,D) <= S(A|C) + S(B|D)
-        full = qutip.rand_dm([2]*4, distribution="pure")
-        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
-        assert (qutip.entropy_conditional(full, [2, 3])
-                <= (qutip.entropy_conditional(ac, 1)
-                    + qutip.entropy_conditional(bd, 1)))
-
-
-_alpha = 2*np.pi * np.random.rand()
-
-
-@pytest.mark.parametrize(["gate", "expected"], [
-    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
-    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
-    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
-    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
-    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
-    pytest.param(qutip.gates.swapalpha(_alpha),
-                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
-])
-def test_entangling_power(gate, expected):
-    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
+import pytest
+import numpy as np
+import qutip
+
+
+class TestVonNeumannEntropy:
+    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
+    def test_binary(self, p):
+        dm = qutip.qdiags([p, 1 - p], 0)
+        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
+        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
+
+    @pytest.mark.repeat(10)
+    def test_pure_state(self):
+        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
+
+
+class TestLinearEntropy:
+    @pytest.mark.repeat(10)
+    def test_less_than_von_neumann(self):
+        dm = qutip.rand_dm(10)
+        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
+
+    @pytest.mark.repeat(10)
+    def test_pure_state(self):
+        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
+
+
+class TestConcurrence:
+    @pytest.mark.parametrize("dm", [
+        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
+        for x in ['00', '01', '10', '11']
+    ])
+    def test_maximally_entangled(self, dm):
+        assert abs(qutip.concurrence(dm) - 1) < 1e-12
+
+    @pytest.mark.repeat(10)
+    def test_nonzero(self):
+        dm = qutip.rand_dm([2, 2])
+        assert qutip.concurrence(dm) >= 0
+
+
+@pytest.mark.repeat(10)
+class TestMutualInformation:
+    def test_pure_state_additive(self):
+        # Verify mutual information = S(A) + S(B) for pure states.
+        dm = qutip.rand_dm([5, 5], distribution="pure")
+        expect = (qutip.entropy_vn(dm.ptrace(0))
+                  + qutip.entropy_vn(dm.ptrace(1)))
+        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
+
+    def test_component_selection(self):
+        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
+        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
+                  + qutip.entropy_vn(dm.ptrace(1)))
+        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
+
+
+class TestRelativeEntropy:
+    def _simple_relative_entropy_implementation(
+            self, rho, sigma, log_base=np.log, tol=1e-12):
+        """ A simplified relative entropy implementation for use in
+            double-checking the optimised implementation within
+            QuTiP itself.
+        """
+        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
+        rvals, rvecs = rho.eigenstates()
+        svals, svecs = sigma.eigenstates()
+        rvecs = np.hstack([vec.full() for vec in rvecs]).T
+        svecs = np.hstack([vec.full() for vec in svecs]).T
+        # Calculate S
+        S = 0
+        for i in range(len(rvals)):
+            if abs(rvals[i]) >= tol:
+                S += rvals[i] * log_base(rvals[i])
+            for j in range(len(svals)):
+                P_ij = (
+                    np.dot(rvecs[i], svecs[j].conjugate()) *
+                    np.dot(svecs[j], rvecs[i].conjugate())
+                )
+                if abs(svals[j]) < tol and not (
+                        abs(rvals[i]) < tol or abs(P_ij) < tol):
+                    # kernel of sigma intersects support of rho
+                    return np.inf
+                if abs(svals[j]) >= tol:
+                    S -= rvals[i] * P_ij * log_base(svals[j])
+        return np.real(S)
+
+    def test_rho_or_sigma_not_oper(self):
+        rho = qutip.bra("00")
+        sigma = qutip.bra("01")
+        with pytest.raises(TypeError) as exc:
+            qutip.entropy_relative(rho.dag(), sigma)
+        assert str(exc.value) == "Inputs must be density matrices."
+        with pytest.raises(TypeError) as exc:
+            qutip.entropy_relative(rho, sigma.dag())
+        assert str(exc.value) == "Inputs must be density matrices."
+        with pytest.raises(TypeError) as exc:
+            qutip.entropy_relative(rho, sigma)
+        assert str(exc.value) == "Inputs must be density matrices."
+
+    def test_rho_and_sigma_have_different_shape_and_dims(self):
+        # test different shape and dims
+        rho = qutip.ket("00")
+        sigma = qutip.ket("0")
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma)
+        assert str(exc.value) == "Inputs must have the same shape and dims."
+        # test same shape, difference dims
+        rho = qutip.basis([2, 3], [0, 0])
+        sigma = qutip.basis([3, 2], [0, 0])
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma)
+        assert str(exc.value) == "Inputs must have the same shape and dims."
+
+    def test_base_not_2_or_e(self):
+        rho = qutip.ket("00")
+        sigma = qutip.ket("01")
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma, base=3)
+        assert str(exc.value) == "Base must be 2 or e."
+
+    def test_infinite_relative_entropy(self):
+        rho = qutip.ket("00")
+        sigma = qutip.ket("01")
+        assert qutip.entropy_relative(rho, sigma) == np.inf
+
+    def test_base_2_or_e(self):
+        rho = qutip.ket2dm(qutip.ket("00"))
+        sigma = rho + qutip.ket2dm(qutip.ket("01"))
+        sigma = sigma.unit()
+        assert (
+            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
+        )
+        assert (
+            qutip.entropy_relative(rho, sigma, base=np.e)
+            == pytest.approx(0.69314718)
+        )
+        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
+
+    def test_pure_vs_maximally_mixed_state(self):
+        rho = qutip.ket("00")
+        sigma = sum(
+            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
+        ).unit()
+        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
+
+    def test_density_matrices_with_non_real_eigenvalues(self):
+        rho = qutip.ket2dm(qutip.ket("00"))
+        sigma = qutip.ket2dm(qutip.ket("01"))
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho + 1j, sigma)
+        assert str(exc.value) == "Input rho has non-real eigenvalues."
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho - 1j, sigma)
+        assert str(exc.value) == "Input rho has non-real eigenvalues."
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma + 1j)
+        assert str(exc.value) == "Input sigma has non-real eigenvalues."
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma - 1j)
+        assert str(exc.value) == "Input sigma has non-real eigenvalues."
+
+    @pytest.mark.repeat(20)
+    def test_random_dm_with_self(self):
+        rho = qutip.rand_dm(8)
+        rel = qutip.entropy_relative(rho, rho)
+        assert abs(rel) < 1e-13
+
+    @pytest.mark.repeat(20)
+    def test_random_rho_sigma(self):
+        rho = qutip.rand_dm(8)
+        sigma = qutip.rand_dm(8)
+        rel = qutip.entropy_relative(rho, sigma)
+        assert rel >= 0
+        assert rel == pytest.approx(
+            self._simple_relative_entropy_implementation(rho, sigma, np.log)
+        )
+
+
+@pytest.mark.repeat(20)
+class TestConditionalEntropy:
+    def test_inequality_3_qubits(self):
+        # S(A | B,C) <= S(A|B)
+        full = qutip.rand_dm([2]*3, distribution="pure")
+        ab = full.ptrace([0, 1])
+        assert (qutip.entropy_conditional(full, [1, 2])
+                <= qutip.entropy_conditional(ab, 1))
+
+    def test_triangle_inequality_4_qubits(self):
+        # S(A,B | C,D) <= S(A|C) + S(B|D)
+        full = qutip.rand_dm([2]*4, distribution="pure")
+        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
+        assert (qutip.entropy_conditional(full, [2, 3])
+                <= (qutip.entropy_conditional(ac, 1)
+                    + qutip.entropy_conditional(bd, 1)))
+
+
+_alpha = 2*np.pi * np.random.rand()
+
+
+@pytest.mark.parametrize(["gate", "expected"], [
+    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
+    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
+    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
+    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
+    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
+    pytest.param(qutip.gates.swapalpha(_alpha),
+                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
+])
+def test_entangling_power(gate, expected):
+    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
diff --git a/qutip/tests/test_fileio.py b/qutip/tests/test_fileio.py
index 7433760684..13e2045893 100644
--- a/qutip/tests/test_fileio.py
+++ b/qutip/tests/test_fileio.py
@@ -1,62 +1,62 @@
-import pytest
-import numpy as np
-import uuid
-import qutip
-from pathlib import Path
-
-# qsave _always_ appends a suffix to the file name at the time of writing, but
-# in case this changes in the future, to ensure that we never leak a temporary
-# file into the user's folders, we simply apply these tests in a temporary
-# directory.  Windows also does not allow temporary files to be opened multiple
-# times, so using a temporary directory is best.
-pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
-
-_dimension = 10
-
-
-def _random_file_name():
-    return "_" + str(uuid.uuid4())
-
-
-class Test_file_data_store_file_data_read:
-    # Tests parametrised seprately to give nicer descriptions in verbose mode.
-
-    def case(self, filename, kwargs):
-        data = 1 - 2*np.random.rand(_dimension, _dimension)
-        if kwargs.get('numtype', 'complex') == 'complex':
-            data = data * (0.5*0.5j)
-        qutip.file_data_store(filename, data, **kwargs)
-        out = qutip.file_data_read(filename)
-        np.testing.assert_allclose(data, out, atol=1e-8)
-
-    def test_defaults(self):
-        return self.case(_random_file_name(), {})
-
-    @pytest.mark.parametrize("type_", ["real", "complex"])
-    @pytest.mark.parametrize("format_", ["decimal", "exp"])
-    def test_type_format(self, type_, format_):
-
-        kwargs = {'numtype': type_, 'numformat': format_}
-        return self.case(_random_file_name(), kwargs)
-
-    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
-                             ids=lambda x: "'" + x + "'")
-    def test_separator_detection(self, separator):
-        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
-        return self.case(_random_file_name(), kwargs)
-
-
-@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
-@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
-def test_qsave_qload(use_path, suffix):
-    ops_in = [qutip.sigmax(),
-              qutip.num(_dimension),
-              qutip.coherent_dm(_dimension, 1j)]
-    filename = _random_file_name() + suffix
-    if use_path:
-        filename = Path.cwd() / filename
-    qutip.qsave(ops_in, filename)
-    ops_out = qutip.qload(filename)
-    assert ops_in == ops_out
-    # check that the file was saved with the correct name:
-    assert Path(str(filename) + ".qu").exists()
+import pytest
+import numpy as np
+import uuid
+import qutip
+from pathlib import Path
+
+# qsave _always_ appends a suffix to the file name at the time of writing, but
+# in case this changes in the future, to ensure that we never leak a temporary
+# file into the user's folders, we simply apply these tests in a temporary
+# directory.  Windows also does not allow temporary files to be opened multiple
+# times, so using a temporary directory is best.
+pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
+
+_dimension = 10
+
+
+def _random_file_name():
+    return "_" + str(uuid.uuid4())
+
+
+class Test_file_data_store_file_data_read:
+    # Tests parametrised seprately to give nicer descriptions in verbose mode.
+
+    def case(self, filename, kwargs):
+        data = 1 - 2*np.random.rand(_dimension, _dimension)
+        if kwargs.get('numtype', 'complex') == 'complex':
+            data = data * (0.5*0.5j)
+        qutip.file_data_store(filename, data, **kwargs)
+        out = qutip.file_data_read(filename)
+        np.testing.assert_allclose(data, out, atol=1e-8)
+
+    def test_defaults(self):
+        return self.case(_random_file_name(), {})
+
+    @pytest.mark.parametrize("type_", ["real", "complex"])
+    @pytest.mark.parametrize("format_", ["decimal", "exp"])
+    def test_type_format(self, type_, format_):
+
+        kwargs = {'numtype': type_, 'numformat': format_}
+        return self.case(_random_file_name(), kwargs)
+
+    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
+                             ids=lambda x: "'" + x + "'")
+    def test_separator_detection(self, separator):
+        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
+        return self.case(_random_file_name(), kwargs)
+
+
+@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
+@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
+def test_qsave_qload(use_path, suffix):
+    ops_in = [qutip.sigmax(),
+              qutip.num(_dimension),
+              qutip.coherent_dm(_dimension, 1j)]
+    filename = _random_file_name() + suffix
+    if use_path:
+        filename = Path.cwd() / filename
+    qutip.qsave(ops_in, filename)
+    ops_out = qutip.qload(filename)
+    assert ops_in == ops_out
+    # check that the file was saved with the correct name:
+    assert Path(str(filename) + ".qu").exists()
diff --git a/qutip/tests/test_ipynbtools.py b/qutip/tests/test_ipynbtools.py
index 2b1c76559a..25f3ec165b 100644
--- a/qutip/tests/test_ipynbtools.py
+++ b/qutip/tests/test_ipynbtools.py
@@ -1,24 +1,24 @@
-from qutip.ipynbtools import version_table
-import pytest
-
-
-@pytest.mark.parametrize('verbose', [False, True])
-def test_version_table(verbose):
-    html_data = version_table(verbose=verbose).data
-    assert "<th>Software</th>" in html_data
-    assert "<th>Version</th>" in html_data
-    assert "<td>QuTiP</td>" in html_data
-    assert "<td>Numpy</td>" in html_data
-    assert "<td>SciPy</td>" in html_data
-    assert "<td>matplotlib</td>" in html_data
-    assert "<td>IPython</td>" in html_data
-    if verbose:
-        assert "<td>Installation path</td>" in html_data
-        if pytest.importorskip("getpass") is not None:
-            assert "<td>User</td>" in html_data
-
-
-@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
-def test_version_table_with_cython():
-    html_data = version_table().data
-    assert "<td>Cython</td>" in html_data
+from qutip.ipynbtools import version_table
+import pytest
+
+
+@pytest.mark.parametrize('verbose', [False, True])
+def test_version_table(verbose):
+    html_data = version_table(verbose=verbose).data
+    assert "<th>Software</th>" in html_data
+    assert "<th>Version</th>" in html_data
+    assert "<td>QuTiP</td>" in html_data
+    assert "<td>Numpy</td>" in html_data
+    assert "<td>SciPy</td>" in html_data
+    assert "<td>matplotlib</td>" in html_data
+    assert "<td>IPython</td>" in html_data
+    if verbose:
+        assert "<td>Installation path</td>" in html_data
+        if pytest.importorskip("getpass") is not None:
+            assert "<td>User</td>" in html_data
+
+
+@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
+def test_version_table_with_cython():
+    html_data = version_table().data
+    assert "<td>Cython</td>" in html_data
diff --git a/qutip/tests/test_measurement.py b/qutip/tests/test_measurement.py
index 6bccd1a35c..b904e2c3bf 100644
--- a/qutip/tests/test_measurement.py
+++ b/qutip/tests/test_measurement.py
@@ -1,324 +1,324 @@
-import numpy as np
-import scipy
-import pytest
-from math import sqrt
-from qutip import (
-    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
-    rand_ket,
-)
-from qutip.measurement import (
-    measure_povm, measurement_statistics_povm, measure_observable,
-    measurement_statistics_observable,
-)
-
-
-class EigenPairs:
-    """ Manage pairs of eigenvalues and eigenstates for an operator. """
-    def __init__(self, pairs):
-        self.pairs = pairs
-        self.eigenvalues = [p[0] for p in pairs]
-        self.eigenstates = [p[1] for p in pairs]
-        self.projectors = [v * v.dag() for v in self.eigenstates]
-
-    def __getitem__(self, i):
-        return self.pairs[i]
-
-    def __contains__(self, other):
-        for i, val in enumerate(self.eigenvalues):
-            if abs(val - other[0]) < 1e-8:
-                break
-        else:
-            return False
-        return _equivalent(other[1], self.eigenstates[i])
-
-
-def pairs2dm(pairs):
-    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
-    return [(v, e.proj()) for v, e in pairs]
-
-
-SIGMAZ = EigenPairs([
-    (-1.0, -basis(2, 1)),
-    (1.0, -basis(2, 0)),
-])
-
-SIGMAX = EigenPairs([
-    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
-    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
-])
-
-SIGMAY = EigenPairs([
-    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
-    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
-])
-
-state0 = basis(2, 0)
-state1 = basis(2, 1)
-stateplus = (basis(2, 0) + basis(2, 1)).unit()
-stateminus = (basis(2, 0) - basis(2, 1)).unit()
-stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
-stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
-PZ = [ket2dm(state0), ket2dm(state1)]
-PX = [ket2dm(stateplus), ket2dm(stateminus)]
-PY = [ket2dm(stateR), ket2dm(stateL)]
-PZ_ket = [state0, state1]
-
-
-def _equivalent(left, right, tol=1e-8):
-    """ Equal up to a phase """
-    return 1 - abs(left.overlap(right)) < tol
-
-
-@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
-    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
-    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
-    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
-    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
-                 id="sigmax_dm"),
-    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
-    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
-                 id="sigmay_dm"),
-])
-def test_measurement_statistics_observable(op, state, pairs, probabilities):
-    """ measurement_statistics_observable: observables on basis states. """
-
-    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
-    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
-    if state.isket:
-        ess = ess_or_projs
-        assert len(ess) == len(pairs.eigenstates)
-        for a, b in zip(ess, pairs.eigenstates):
-            assert _equivalent(a, b)
-    else:
-        projs = ess_or_projs
-        assert len(projs) == len(pairs.projectors)
-        for a, b in zip(projs, pairs.projectors):
-            assert _equivalent(a, b)
-    np.testing.assert_almost_equal(probs, probabilities)
-
-
-@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
-    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
-    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
-                 id="PZ_dm"),
-    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
-    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
-                 id="PZket_dm"),
-    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
-                 id="PX_ket"),
-    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
-                 [0.5, 0.5], id="PX_dm"),
-    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
-    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
-                 [0.5, 0.5], id="PY_dm")])
-def test_measurement_statistics_povm(ops, state, final_states, probabilities):
-    """ measurement_statistics_povm: projectors applied to basis states. """
-
-    collapsed_states, probs = measurement_statistics_povm(state, ops)
-    for i, final_state in enumerate(final_states):
-        collapsed_state = collapsed_states[i]
-        if final_state:
-            assert collapsed_state == final_state
-        else:
-            assert collapsed_state is None
-    np.testing.assert_almost_equal(probs, probabilities)
-
-
-def test_measurement_statistics_povm_input_errors():
-    """ measurement_statistics_povm: check input errors """
-
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measurement_statistics_povm,
-        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measurement_statistics_povm, "notqobj", [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measurement_statistics_povm, basis(3, 0), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
-
-
-def test_measurement_statistics_observable_input_errors():
-    """ measurement_statistics_observable: check input errors """
-
-    np.testing.assert_raises_regex(
-        TypeError, "op must be a Qobj",
-        measurement_statistics_observable, basis(2, 0), "notqobj")
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measurement_statistics_observable, basis(2, 0), basis(2, 1))
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measurement_statistics_observable, "notqobj",  sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measurement_statistics_observable, basis(3, 0), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
-
-
-@pytest.mark.parametrize(["op", "state"], [
-                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
-                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
-                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
-                                 id="sigmaz_dm1"),
-                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
-                                 id="sigmaz_dm2"),
-
-                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
-                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
-                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
-                                 id="sigmax_dm"),
-
-                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
-                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
-                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
-                                 id="sigmay_dm")])
-def test_measure_observable(op, state):
-    """ measure_observable: basis states using different observables """
-    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
-
-    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
-    for _ in range(10):
-        assert (measure_observable(state, op) in expected_measurements)
-
-
-@pytest.mark.parametrize(["ops", "state"], [
-
-                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
-                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
-                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
-                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
-
-                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
-                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
-                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
-                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
-
-                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
-                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
-                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
-
-                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
-                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
-                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
-def test_measure(ops, state):
-    """measure_povm: test on basis states using different projectors """
-
-    collapsed_states, _ = measurement_statistics_povm(state, ops)
-    for _ in range(10):
-        index, final_state = measure_povm(state, ops)
-        assert final_state == collapsed_states[index]
-
-
-def test_measure_input_errors():
-    """ measure_povm: check input errors """
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measure_povm, "notqobj", [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measure_povm, basis(2, 0).dag(), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measure_povm, basis(3, 0), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measure_povm, basis(2, 0), [basis(2, 0)])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
-
-
-def test_measure_observable_input_errors():
-    """ measure_observable: check input errors """
-    np.testing.assert_raises_regex(
-        TypeError, "op must be a Qobj",
-        measure_observable, basis(2, 0), "notqobj")
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measure_observable, basis(2, 0),  basis(2, 1))
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measure_observable, "notqobj", sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measure_observable, basis(2, 0).dag(), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measure_observable, basis(3, 0), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measure_observable, ket2dm(basis(3, 0)), sigmaz())
-
-
-def test_povm():
-    """
-    Test if povm formulation works correctly by checking probabilities for
-    the quantum state discrimination example
-    """
-
-    coeff = (sqrt(2)/(1+sqrt(2)))
-
-    E_1 = coeff * ket2dm(basis(2, 1))
-    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
-    E_3 = identity(2) - E_1 - E_2
-
-    M_1 = E_1.sqrtm()
-    M_2 = E_2.sqrtm()
-    M_3 = E_3.sqrtm()
-
-    ket1 = basis(2, 0)
-    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
-
-    dm1 = ket2dm(ket1)
-    dm2 = ket2dm(ket2)
-
-    M = [M_1, M_2, M_3]
-
-    _, probabilities = measurement_statistics_povm(ket1, M)
-    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
-
-    _, probabilities = measurement_statistics_povm(ket2, M)
-    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
-
-    _, probabilities = measurement_statistics_povm(dm1, M)
-    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
-
-    _, probabilities = measurement_statistics_povm(dm2, M)
-    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
+import numpy as np
+import scipy
+import pytest
+from math import sqrt
+from qutip import (
+    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
+    rand_ket,
+)
+from qutip.measurement import (
+    measure_povm, measurement_statistics_povm, measure_observable,
+    measurement_statistics_observable,
+)
+
+
+class EigenPairs:
+    """ Manage pairs of eigenvalues and eigenstates for an operator. """
+    def __init__(self, pairs):
+        self.pairs = pairs
+        self.eigenvalues = [p[0] for p in pairs]
+        self.eigenstates = [p[1] for p in pairs]
+        self.projectors = [v * v.dag() for v in self.eigenstates]
+
+    def __getitem__(self, i):
+        return self.pairs[i]
+
+    def __contains__(self, other):
+        for i, val in enumerate(self.eigenvalues):
+            if abs(val - other[0]) < 1e-8:
+                break
+        else:
+            return False
+        return _equivalent(other[1], self.eigenstates[i])
+
+
+def pairs2dm(pairs):
+    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
+    return [(v, e.proj()) for v, e in pairs]
+
+
+SIGMAZ = EigenPairs([
+    (-1.0, -basis(2, 1)),
+    (1.0, -basis(2, 0)),
+])
+
+SIGMAX = EigenPairs([
+    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
+    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
+])
+
+SIGMAY = EigenPairs([
+    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
+    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
+])
+
+state0 = basis(2, 0)
+state1 = basis(2, 1)
+stateplus = (basis(2, 0) + basis(2, 1)).unit()
+stateminus = (basis(2, 0) - basis(2, 1)).unit()
+stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
+stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
+PZ = [ket2dm(state0), ket2dm(state1)]
+PX = [ket2dm(stateplus), ket2dm(stateminus)]
+PY = [ket2dm(stateR), ket2dm(stateL)]
+PZ_ket = [state0, state1]
+
+
+def _equivalent(left, right, tol=1e-8):
+    """ Equal up to a phase """
+    return 1 - abs(left.overlap(right)) < tol
+
+
+@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
+    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
+    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
+    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
+    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
+                 id="sigmax_dm"),
+    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
+    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
+                 id="sigmay_dm"),
+])
+def test_measurement_statistics_observable(op, state, pairs, probabilities):
+    """ measurement_statistics_observable: observables on basis states. """
+
+    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
+    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
+    if state.isket:
+        ess = ess_or_projs
+        assert len(ess) == len(pairs.eigenstates)
+        for a, b in zip(ess, pairs.eigenstates):
+            assert _equivalent(a, b)
+    else:
+        projs = ess_or_projs
+        assert len(projs) == len(pairs.projectors)
+        for a, b in zip(projs, pairs.projectors):
+            assert _equivalent(a, b)
+    np.testing.assert_almost_equal(probs, probabilities)
+
+
+@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
+    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
+    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
+                 id="PZ_dm"),
+    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
+    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
+                 id="PZket_dm"),
+    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
+                 id="PX_ket"),
+    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
+                 [0.5, 0.5], id="PX_dm"),
+    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
+    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
+                 [0.5, 0.5], id="PY_dm")])
+def test_measurement_statistics_povm(ops, state, final_states, probabilities):
+    """ measurement_statistics_povm: projectors applied to basis states. """
+
+    collapsed_states, probs = measurement_statistics_povm(state, ops)
+    for i, final_state in enumerate(final_states):
+        collapsed_state = collapsed_states[i]
+        if final_state:
+            assert collapsed_state == final_state
+        else:
+            assert collapsed_state is None
+    np.testing.assert_almost_equal(probs, probabilities)
+
+
+def test_measurement_statistics_povm_input_errors():
+    """ measurement_statistics_povm: check input errors """
+
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measurement_statistics_povm,
+        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measurement_statistics_povm, "notqobj", [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measurement_statistics_povm, basis(3, 0), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
+
+
+def test_measurement_statistics_observable_input_errors():
+    """ measurement_statistics_observable: check input errors """
+
+    np.testing.assert_raises_regex(
+        TypeError, "op must be a Qobj",
+        measurement_statistics_observable, basis(2, 0), "notqobj")
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measurement_statistics_observable, basis(2, 0), basis(2, 1))
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measurement_statistics_observable, "notqobj",  sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measurement_statistics_observable, basis(3, 0), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
+
+
+@pytest.mark.parametrize(["op", "state"], [
+                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
+                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
+                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
+                                 id="sigmaz_dm1"),
+                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
+                                 id="sigmaz_dm2"),
+
+                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
+                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
+                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
+                                 id="sigmax_dm"),
+
+                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
+                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
+                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
+                                 id="sigmay_dm")])
+def test_measure_observable(op, state):
+    """ measure_observable: basis states using different observables """
+    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
+
+    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
+    for _ in range(10):
+        assert (measure_observable(state, op) in expected_measurements)
+
+
+@pytest.mark.parametrize(["ops", "state"], [
+
+                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
+                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
+                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
+                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
+
+                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
+                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
+                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
+                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
+
+                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
+                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
+                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
+
+                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
+                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
+                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
+def test_measure(ops, state):
+    """measure_povm: test on basis states using different projectors """
+
+    collapsed_states, _ = measurement_statistics_povm(state, ops)
+    for _ in range(10):
+        index, final_state = measure_povm(state, ops)
+        assert final_state == collapsed_states[index]
+
+
+def test_measure_input_errors():
+    """ measure_povm: check input errors """
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measure_povm, "notqobj", [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measure_povm, basis(2, 0).dag(), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measure_povm, basis(3, 0), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measure_povm, basis(2, 0), [basis(2, 0)])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
+
+
+def test_measure_observable_input_errors():
+    """ measure_observable: check input errors """
+    np.testing.assert_raises_regex(
+        TypeError, "op must be a Qobj",
+        measure_observable, basis(2, 0), "notqobj")
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measure_observable, basis(2, 0),  basis(2, 1))
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measure_observable, "notqobj", sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measure_observable, basis(2, 0).dag(), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measure_observable, basis(3, 0), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measure_observable, ket2dm(basis(3, 0)), sigmaz())
+
+
+def test_povm():
+    """
+    Test if povm formulation works correctly by checking probabilities for
+    the quantum state discrimination example
+    """
+
+    coeff = (sqrt(2)/(1+sqrt(2)))
+
+    E_1 = coeff * ket2dm(basis(2, 1))
+    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
+    E_3 = identity(2) - E_1 - E_2
+
+    M_1 = E_1.sqrtm()
+    M_2 = E_2.sqrtm()
+    M_3 = E_3.sqrtm()
+
+    ket1 = basis(2, 0)
+    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
+
+    dm1 = ket2dm(ket1)
+    dm2 = ket2dm(ket2)
+
+    M = [M_1, M_2, M_3]
+
+    _, probabilities = measurement_statistics_povm(ket1, M)
+    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
+
+    _, probabilities = measurement_statistics_povm(ket2, M)
+    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
+
+    _, probabilities = measurement_statistics_povm(dm1, M)
+    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
+
+    _, probabilities = measurement_statistics_povm(dm2, M)
+    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
diff --git a/qutip/tests/test_mkl.py b/qutip/tests/test_mkl.py
index 734f33e25e..3eeb83f17b 100644
--- a/qutip/tests/test_mkl.py
+++ b/qutip/tests/test_mkl.py
@@ -1,116 +1,116 @@
-import pytest
-import numpy as np
-import scipy.linalg
-import scipy.sparse
-
-import qutip
-if qutip.settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
-
-pytestmark = [
-    pytest.mark.skipif(not qutip.settings.has_mkl,
-                       reason='MKL extensions not found.'),
-]
-
-
-class Test_spsolve:
-    def test_single_rhs_vector_real(self):
-        Adense = np.array([[0, 1, 1],
-                           [1, 0, 1],
-                           [0, 0, 1]])
-        As = scipy.sparse.csr_matrix(Adense)
-        np.random.seed(1234)
-        x = np.random.randn(3)
-        b = As * x
-        x2 = mkl_spsolve(As, b, verbose=True)
-        np.testing.assert_allclose(x, x2)
-
-    def test_single_rhs_vector_complex(self):
-        A = qutip.rand_herm(10, density=0.8, dtype='csr')
-        x = qutip.rand_ket(10).full()
-        b = A.full() @ x
-        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
-        np.testing.assert_allclose(x, y)
-
-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-    def test_multi_rhs_vector(self, dtype):
-        M = np.array([
-            [1, 0, 2],
-            [0, 0, 3],
-            [-4, 5, 6],
-        ], dtype=dtype)
-        sM = scipy.sparse.csr_matrix(M)
-        N = np.array([
-            [3, 0, 1],
-            [0, 2, 0],
-            [0, 0, 0],
-        ], dtype=dtype)
-        sX = mkl_spsolve(sM, N, verbose=True)
-        X = scipy.linalg.solve(M, N)
-        np.testing.assert_allclose(X, sX)
-
-    def test_rhs_shape_is_maintained(self):
-        A = scipy.sparse.csr_matrix(np.array([
-            [1, 0, 2],
-            [0, 0, 3],
-            [-4, 5, 6],
-        ], dtype=np.complex128))
-        b = np.array([0, 2, 0], dtype=np.complex128)
-        out = mkl_spsolve(A, b, verbose=True)
-        assert b.shape == out.shape
-
-        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
-        out = mkl_spsolve(A, b, verbose=True)
-        assert b.shape == out.shape
-
-    def test_sparse_rhs(self):
-        A = scipy.sparse.csr_matrix([
-            [1, 2, 0],
-            [0, 3, 0],
-            [0, 0, 5],
-        ])
-        b = scipy.sparse.csr_matrix([
-            [0, 1],
-            [1, 0],
-            [0, 0],
-        ])
-        x = mkl_spsolve(A, b, verbose=True)
-        ans = np.array([[-0.66666667, 1],
-                        [0.33333333, 0],
-                        [0, 0]])
-        np.testing.assert_allclose(x.toarray(), ans)
-
-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-    def test_symmetric_solver(self, dtype):
-        A = qutip.rand_herm(10, distribution="eigen",
-                            eigenvalues=np.arange(1, 11),
-                            dtype='csr').data.as_scipy()
-        if dtype == np.float64:
-            A = A.real
-        x = np.ones(10, dtype=dtype)
-        b = A.dot(x)
-        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
-        np.testing.assert_allclose(x, y)
-
-
-class Test_splu:
-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-    def test_repeated_rhs_solve(self, dtype):
-        M = np.array([
-            [1, 0, 2],
-            [0, 0, 3],
-            [-4, 5, 6],
-        ], dtype=dtype)
-        sM = scipy.sparse.csr_matrix(M)
-        N = np.array([
-            [3, 0, 1],
-            [0, 2, 0],
-            [0, 0, 0],
-        ], dtype=dtype)
-        test_X = np.zeros((3, 3), dtype=dtype)
-        lu = mkl_splu(sM, verbose=True)
-        for k in range(3):
-            test_X[:, k] = lu.solve(N[:, k])
-        lu.delete()
-        expected_X = scipy.linalg.solve(M, N)
-        np.testing.assert_allclose(test_X, expected_X)
+import pytest
+import numpy as np
+import scipy.linalg
+import scipy.sparse
+
+import qutip
+if qutip.settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
+
+pytestmark = [
+    pytest.mark.skipif(not qutip.settings.has_mkl,
+                       reason='MKL extensions not found.'),
+]
+
+
+class Test_spsolve:
+    def test_single_rhs_vector_real(self):
+        Adense = np.array([[0, 1, 1],
+                           [1, 0, 1],
+                           [0, 0, 1]])
+        As = scipy.sparse.csr_matrix(Adense)
+        np.random.seed(1234)
+        x = np.random.randn(3)
+        b = As * x
+        x2 = mkl_spsolve(As, b, verbose=True)
+        np.testing.assert_allclose(x, x2)
+
+    def test_single_rhs_vector_complex(self):
+        A = qutip.rand_herm(10, density=0.8, dtype='csr')
+        x = qutip.rand_ket(10).full()
+        b = A.full() @ x
+        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
+        np.testing.assert_allclose(x, y)
+
+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+    def test_multi_rhs_vector(self, dtype):
+        M = np.array([
+            [1, 0, 2],
+            [0, 0, 3],
+            [-4, 5, 6],
+        ], dtype=dtype)
+        sM = scipy.sparse.csr_matrix(M)
+        N = np.array([
+            [3, 0, 1],
+            [0, 2, 0],
+            [0, 0, 0],
+        ], dtype=dtype)
+        sX = mkl_spsolve(sM, N, verbose=True)
+        X = scipy.linalg.solve(M, N)
+        np.testing.assert_allclose(X, sX)
+
+    def test_rhs_shape_is_maintained(self):
+        A = scipy.sparse.csr_matrix(np.array([
+            [1, 0, 2],
+            [0, 0, 3],
+            [-4, 5, 6],
+        ], dtype=np.complex128))
+        b = np.array([0, 2, 0], dtype=np.complex128)
+        out = mkl_spsolve(A, b, verbose=True)
+        assert b.shape == out.shape
+
+        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
+        out = mkl_spsolve(A, b, verbose=True)
+        assert b.shape == out.shape
+
+    def test_sparse_rhs(self):
+        A = scipy.sparse.csr_matrix([
+            [1, 2, 0],
+            [0, 3, 0],
+            [0, 0, 5],
+        ])
+        b = scipy.sparse.csr_matrix([
+            [0, 1],
+            [1, 0],
+            [0, 0],
+        ])
+        x = mkl_spsolve(A, b, verbose=True)
+        ans = np.array([[-0.66666667, 1],
+                        [0.33333333, 0],
+                        [0, 0]])
+        np.testing.assert_allclose(x.toarray(), ans)
+
+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+    def test_symmetric_solver(self, dtype):
+        A = qutip.rand_herm(10, distribution="eigen",
+                            eigenvalues=np.arange(1, 11),
+                            dtype='csr').data.as_scipy()
+        if dtype == np.float64:
+            A = A.real
+        x = np.ones(10, dtype=dtype)
+        b = A.dot(x)
+        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
+        np.testing.assert_allclose(x, y)
+
+
+class Test_splu:
+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+    def test_repeated_rhs_solve(self, dtype):
+        M = np.array([
+            [1, 0, 2],
+            [0, 0, 3],
+            [-4, 5, 6],
+        ], dtype=dtype)
+        sM = scipy.sparse.csr_matrix(M)
+        N = np.array([
+            [3, 0, 1],
+            [0, 2, 0],
+            [0, 0, 0],
+        ], dtype=dtype)
+        test_X = np.zeros((3, 3), dtype=dtype)
+        lu = mkl_splu(sM, verbose=True)
+        for k in range(3):
+            test_X[:, k] = lu.solve(N[:, k])
+        lu.delete()
+        expected_X = scipy.linalg.solve(M, N)
+        np.testing.assert_allclose(test_X, expected_X)
diff --git a/qutip/tests/test_openmp.py b/qutip/tests/test_openmp.py
index 05804ca5e9..604df3c6ec 100644
--- a/qutip/tests/test_openmp.py
+++ b/qutip/tests/test_openmp.py
@@ -1,111 +1,111 @@
-import numpy as np
-from numpy.testing import assert_equal, assert_, run_module_suite
-import unittest
-from qutip import *
-from qutip.settings import settings as qset
-# if qset.has_openmp:
-#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
-
-
-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-@unittest.skipIf(True, 'OPENMP disabled.')
-def test_openmp_spmv():
-    "OPENMP : spmvpy_openmp == spmvpy"
-    for k in range(100):
-        L = rand_herm(10,0.25).data
-        vec = rand_ket(L.shape[0],0.25).full().ravel()
-        out = np.zeros_like(vec)
-        out_openmp = np.zeros_like(vec)
-        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
-        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
-        assert_(np.allclose(out, out_openmp, 1e-15))
-
-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-@unittest.skipIf(True, 'OPENMP disabled.')
-def test_openmp_mesolve():
-    "OPENMP : mesolve"
-    N = 100
-    wc = 1.0  * 2 * np.pi  # cavity frequency
-    wa = 1.0  * 2 * np.pi  # atom frequency
-    g  = 0.05 * 2 * np.pi  # coupling strength
-    kappa = 0.005          # cavity dissipation rate
-    gamma = 0.05           # atom dissipation rate
-    n_th_a = 1           # temperature in frequency units
-    use_rwa = 0
-    # operators
-    a  = tensor(destroy(N), qeye(2))
-    sm = tensor(qeye(N), destroy(2))
-    # Hamiltonian
-    if use_rwa:
-        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
-    else:
-        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
-    c_op_list = []
-
-    rate = kappa * (1 + n_th_a)
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a)
-
-    rate = kappa * n_th_a
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a.dag())
-
-    rate = gamma
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sm)
-
-    n = N - 2
-    psi0 = tensor(basis(N, n), basis(2, 1))
-    tlist = np.linspace(0, 1, 100)
-    opts = SolverOptions(use_openmp=False)
-    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    opts = SolverOptions(use_openmp=True)
-    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
-
-
-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-@unittest.skipIf(True, 'OPENMP disabled.')
-def test_openmp_mesolve_td():
-    "OPENMP : mesolve (td)"
-    N = 100
-    wc = 1.0  * 2 * np.pi  # cavity frequency
-    wa = 1.0  * 2 * np.pi  # atom frequency
-    g  = 0.5 * 2 * np.pi  # coupling strength
-    kappa = 0.005          # cavity dissipation rate
-    gamma = 0.05           # atom dissipation rate
-    n_th_a = 1           # temperature in frequency units
-    use_rwa = 0
-    # operators
-    a  = tensor(destroy(N), qeye(2))
-    sm = tensor(qeye(N), destroy(2))
-    # Hamiltonian
-    H0 = wc * a.dag() * a + wa * sm.dag() * sm
-    H1 = g * (a.dag() + a) * (sm + sm.dag())
-
-    H = [H0, [H1,'sin(t)']]
-
-    c_op_list = []
-
-    rate = kappa * (1 + n_th_a)
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a)
-
-    rate = kappa * n_th_a
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a.dag())
-
-    rate = gamma
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sm)
-
-    n = N - 10
-    psi0 = tensor(basis(N, n), basis(2, 1))
-    tlist = np.linspace(0, 1, 100)
-    opts = SolverOptions(use_openmp=True)
-    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    opts = SolverOptions(use_openmp=False)
-    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+import numpy as np
+from numpy.testing import assert_equal, assert_, run_module_suite
+import unittest
+from qutip import *
+from qutip.settings import settings as qset
+# if qset.has_openmp:
+#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
+
+
+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+@unittest.skipIf(True, 'OPENMP disabled.')
+def test_openmp_spmv():
+    "OPENMP : spmvpy_openmp == spmvpy"
+    for k in range(100):
+        L = rand_herm(10,0.25).data
+        vec = rand_ket(L.shape[0],0.25).full().ravel()
+        out = np.zeros_like(vec)
+        out_openmp = np.zeros_like(vec)
+        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
+        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
+        assert_(np.allclose(out, out_openmp, 1e-15))
+
+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+@unittest.skipIf(True, 'OPENMP disabled.')
+def test_openmp_mesolve():
+    "OPENMP : mesolve"
+    N = 100
+    wc = 1.0  * 2 * np.pi  # cavity frequency
+    wa = 1.0  * 2 * np.pi  # atom frequency
+    g  = 0.05 * 2 * np.pi  # coupling strength
+    kappa = 0.005          # cavity dissipation rate
+    gamma = 0.05           # atom dissipation rate
+    n_th_a = 1           # temperature in frequency units
+    use_rwa = 0
+    # operators
+    a  = tensor(destroy(N), qeye(2))
+    sm = tensor(qeye(N), destroy(2))
+    # Hamiltonian
+    if use_rwa:
+        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
+    else:
+        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
+    c_op_list = []
+
+    rate = kappa * (1 + n_th_a)
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a)
+
+    rate = kappa * n_th_a
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a.dag())
+
+    rate = gamma
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sm)
+
+    n = N - 2
+    psi0 = tensor(basis(N, n), basis(2, 1))
+    tlist = np.linspace(0, 1, 100)
+    opts = SolverOptions(use_openmp=False)
+    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    opts = SolverOptions(use_openmp=True)
+    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
+    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+
+
+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+@unittest.skipIf(True, 'OPENMP disabled.')
+def test_openmp_mesolve_td():
+    "OPENMP : mesolve (td)"
+    N = 100
+    wc = 1.0  * 2 * np.pi  # cavity frequency
+    wa = 1.0  * 2 * np.pi  # atom frequency
+    g  = 0.5 * 2 * np.pi  # coupling strength
+    kappa = 0.005          # cavity dissipation rate
+    gamma = 0.05           # atom dissipation rate
+    n_th_a = 1           # temperature in frequency units
+    use_rwa = 0
+    # operators
+    a  = tensor(destroy(N), qeye(2))
+    sm = tensor(qeye(N), destroy(2))
+    # Hamiltonian
+    H0 = wc * a.dag() * a + wa * sm.dag() * sm
+    H1 = g * (a.dag() + a) * (sm + sm.dag())
+
+    H = [H0, [H1,'sin(t)']]
+
+    c_op_list = []
+
+    rate = kappa * (1 + n_th_a)
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a)
+
+    rate = kappa * n_th_a
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a.dag())
+
+    rate = gamma
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sm)
+
+    n = N - 10
+    psi0 = tensor(basis(N, n), basis(2, 1))
+    tlist = np.linspace(0, 1, 100)
+    opts = SolverOptions(use_openmp=True)
+    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    opts = SolverOptions(use_openmp=False)
+    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
+    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
diff --git a/qutip/tests/test_orbital.py b/qutip/tests/test_orbital.py
index e5a1829766..0fe0fb3fce 100644
--- a/qutip/tests/test_orbital.py
+++ b/qutip/tests/test_orbital.py
@@ -1,55 +1,55 @@
-import pytest
-from scipy.special import sph_harm
-from qutip.orbital import orbital
-import qutip
-import numpy as np
-
-
-def test_orbital_single_ket():
-    """ Checks output for a single ket as input"""
-    # setup mesh for theta and phi
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    for theta, phi in zip(theta_list, phi_list):
-        # set l and m
-        for l in range(0, 5):
-            for m in range(-l, l + 1):
-                q = qutip.basis(2 * l + 1, l + m)
-                # check that outputs are the same,
-                # note that theta and phi are interchanged for scipy
-                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
-
-
-def test_orbital_multiple_ket():
-    """ Checks if the combination of multiple kets works """
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    l, m = 5, 2
-    q1 = qutip.basis(2 * l + 1, l + m)
-    l, m = 3, -1
-    q2 = qutip.basis(2 * l + 1, l + m)
-    for theta, phi in zip(theta_list, phi_list):
-        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
-        assert orbital(theta, phi, q1, q2) ==  exp
-
-
-def test_orbital_explicit():
-    """ Checks explicit configurations of orbital functions"""
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    # Constant function
-    l, m = 0, 0
-    q = qutip.basis(2 * l + 1, l + m)
-    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
-    # cosine function
-    l, m = 1, 0
-    q = qutip.basis(2 * l + 1, l + m)
-    assert np.allclose(orbital(theta_list, 0, q),
-                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
-    # cosine with phase
-    l, m = 1, 1
-    q = qutip.basis(2 * l + 1, l + m)
-    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
-    assert np.allclose(orbital(theta_list, phi_list, q),
-                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
-                           theta_mesh) * np.exp(1j * phi_mesh))
+import pytest
+from scipy.special import sph_harm
+from qutip.orbital import orbital
+import qutip
+import numpy as np
+
+
+def test_orbital_single_ket():
+    """ Checks output for a single ket as input"""
+    # setup mesh for theta and phi
+    theta_list = np.linspace(0, np.pi, num=50)
+    phi_list = np.linspace(0, 2 * np.pi, num=100)
+    for theta, phi in zip(theta_list, phi_list):
+        # set l and m
+        for l in range(0, 5):
+            for m in range(-l, l + 1):
+                q = qutip.basis(2 * l + 1, l + m)
+                # check that outputs are the same,
+                # note that theta and phi are interchanged for scipy
+                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
+
+
+def test_orbital_multiple_ket():
+    """ Checks if the combination of multiple kets works """
+    theta_list = np.linspace(0, np.pi, num=50)
+    phi_list = np.linspace(0, 2 * np.pi, num=100)
+    l, m = 5, 2
+    q1 = qutip.basis(2 * l + 1, l + m)
+    l, m = 3, -1
+    q2 = qutip.basis(2 * l + 1, l + m)
+    for theta, phi in zip(theta_list, phi_list):
+        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
+        assert orbital(theta, phi, q1, q2) ==  exp
+
+
+def test_orbital_explicit():
+    """ Checks explicit configurations of orbital functions"""
+    theta_list = np.linspace(0, np.pi, num=50)
+    phi_list = np.linspace(0, 2 * np.pi, num=100)
+    # Constant function
+    l, m = 0, 0
+    q = qutip.basis(2 * l + 1, l + m)
+    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
+    # cosine function
+    l, m = 1, 0
+    q = qutip.basis(2 * l + 1, l + m)
+    assert np.allclose(orbital(theta_list, 0, q),
+                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
+    # cosine with phase
+    l, m = 1, 1
+    q = qutip.basis(2 * l + 1, l + m)
+    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
+    assert np.allclose(orbital(theta_list, phi_list, q),
+                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
+                           theta_mesh) * np.exp(1j * phi_mesh))
diff --git a/qutip/tests/test_partial_transpose.py b/qutip/tests/test_partial_transpose.py
index 02d3fec328..26dffb3a70 100644
--- a/qutip/tests/test_partial_transpose.py
+++ b/qutip/tests/test_partial_transpose.py
@@ -1,78 +1,78 @@
-"""
-Unit tests for QuTiP partial transpose functions.
-"""
-
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-
-from qutip import Qobj, partial_transpose, tensor, rand_dm
-from qutip.partial_transpose import _partial_transpose_reference
-
-
-def test_partial_transpose_bipartite():
-    """partial transpose of bipartite systems"""
-
-    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
-
-    # no transpose
-    rho_pt = partial_transpose(rho, [0, 0])
-    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
-
-    # partial transpose subsystem 1
-    rho_pt = partial_transpose(rho, [1, 0])
-    rho_pt_expected = np.array([[0, 1,  8,  9],
-                                [4, 5, 12, 13],
-                                [2, 3, 10, 11],
-                                [6, 7, 14, 15]])
-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
-
-    # partial transpose subsystem 2
-    rho_pt = partial_transpose(rho, [0, 1])
-    rho_pt_expected = np.array([[0, 4, 2, 6],
-                                [1, 5, 3, 7],
-                                [8, 12, 10, 14],
-                                [9, 13, 11, 15]])
-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
-
-    # full transpose
-    rho_pt = partial_transpose(rho, [1, 1])
-    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
-
-
-def test_partial_transpose_comparison():
-    """partial transpose: comparing sparse and dense implementations"""
-
-    N = 10
-    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
-
-    # partial transpose of system 1
-    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
-    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
-    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
-
-    # partial transpose of system 2
-    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
-    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
-    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
-
-
-def test_partial_transpose_randomized():
-    """partial transpose: randomized tests on tripartite system"""
-
-    rho = tensor(rand_dm(2, density=1),
-                 rand_dm(2, density=1),
-                 rand_dm(2, density=1))
-
-    mask = np.random.randint(2, size=3)
-
-    rho_pt_ref = _partial_transpose_reference(rho, mask)
-
-    rho_pt1 = partial_transpose(rho, mask, method="dense")
-    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
-
-    rho_pt2 = partial_transpose(rho, mask, method="sparse")
-    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
-
-
-if __name__ == "__main__":
-    run_module_suite()
+"""
+Unit tests for QuTiP partial transpose functions.
+"""
+
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+
+from qutip import Qobj, partial_transpose, tensor, rand_dm
+from qutip.partial_transpose import _partial_transpose_reference
+
+
+def test_partial_transpose_bipartite():
+    """partial transpose of bipartite systems"""
+
+    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
+
+    # no transpose
+    rho_pt = partial_transpose(rho, [0, 0])
+    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
+
+    # partial transpose subsystem 1
+    rho_pt = partial_transpose(rho, [1, 0])
+    rho_pt_expected = np.array([[0, 1,  8,  9],
+                                [4, 5, 12, 13],
+                                [2, 3, 10, 11],
+                                [6, 7, 14, 15]])
+    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+
+    # partial transpose subsystem 2
+    rho_pt = partial_transpose(rho, [0, 1])
+    rho_pt_expected = np.array([[0, 4, 2, 6],
+                                [1, 5, 3, 7],
+                                [8, 12, 10, 14],
+                                [9, 13, 11, 15]])
+    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+
+    # full transpose
+    rho_pt = partial_transpose(rho, [1, 1])
+    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
+
+
+def test_partial_transpose_comparison():
+    """partial transpose: comparing sparse and dense implementations"""
+
+    N = 10
+    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
+
+    # partial transpose of system 1
+    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
+    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
+    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
+
+    # partial transpose of system 2
+    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
+    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
+    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
+
+
+def test_partial_transpose_randomized():
+    """partial transpose: randomized tests on tripartite system"""
+
+    rho = tensor(rand_dm(2, density=1),
+                 rand_dm(2, density=1),
+                 rand_dm(2, density=1))
+
+    mask = np.random.randint(2, size=3)
+
+    rho_pt_ref = _partial_transpose_reference(rho, mask)
+
+    rho_pt1 = partial_transpose(rho, mask, method="dense")
+    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
+
+    rho_pt2 = partial_transpose(rho, mask, method="sparse")
+    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
+
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/test_qip.py b/qutip/tests/test_qip.py
index d016878710..3f34d4f052 100644
--- a/qutip/tests/test_qip.py
+++ b/qutip/tests/test_qip.py
@@ -1,46 +1,46 @@
-import sys
-
-import pytest
-
-
-@pytest.fixture
-def without_qutip_qip(monkeypatch):
-    monkeypatch.setitem(sys.modules, "qutip_qip", None)
-    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
-
-
-@pytest.fixture
-def with_qutip_qip_stub(tmp_path, monkeypatch):
-    pkg_dir = tmp_path / "qutip_qip"
-    pkg_dir.mkdir()
-    init_file = pkg_dir / "__init__.py"
-    init_file.write_text("__version__ = 'x.y.z'")
-    circuit_file = pkg_dir / "circuit.py"
-    circuit_file.write_text("class QubitCircuit:\n    pass")
-
-    monkeypatch.syspath_prepend(tmp_path)
-    # Make sure the stub modules is the one imported
-    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
-    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
-
-
-def test_failed_import(without_qutip_qip):
-    # Ensure 'qutip.qip' is not imported yet
-    assert "qutip.qip" not in sys.modules
-    with pytest.raises(
-        ImportError,
-        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
-    ):
-        import qutip.qip
-
-
-def test_with_qip(with_qutip_qip_stub):
-    import qutip.qip
-    import qutip.qip.circuit as circuit
-    from qutip.qip.circuit import QubitCircuit
-    import qutip_qip
-
-    assert qutip.qip.__version__ == "x.y.z"
-    assert qutip.qip is qutip_qip
-    assert circuit is qutip_qip.circuit
-    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
+import sys
+
+import pytest
+
+
+@pytest.fixture
+def without_qutip_qip(monkeypatch):
+    monkeypatch.setitem(sys.modules, "qutip_qip", None)
+    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
+
+
+@pytest.fixture
+def with_qutip_qip_stub(tmp_path, monkeypatch):
+    pkg_dir = tmp_path / "qutip_qip"
+    pkg_dir.mkdir()
+    init_file = pkg_dir / "__init__.py"
+    init_file.write_text("__version__ = 'x.y.z'")
+    circuit_file = pkg_dir / "circuit.py"
+    circuit_file.write_text("class QubitCircuit:\n    pass")
+
+    monkeypatch.syspath_prepend(tmp_path)
+    # Make sure the stub modules is the one imported
+    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
+    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
+
+
+def test_failed_import(without_qutip_qip):
+    # Ensure 'qutip.qip' is not imported yet
+    assert "qutip.qip" not in sys.modules
+    with pytest.raises(
+        ImportError,
+        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
+    ):
+        import qutip.qip
+
+
+def test_with_qip(with_qutip_qip_stub):
+    import qutip.qip
+    import qutip.qip.circuit as circuit
+    from qutip.qip.circuit import QubitCircuit
+    import qutip_qip
+
+    assert qutip.qip.__version__ == "x.y.z"
+    assert qutip.qip is qutip_qip
+    assert circuit is qutip_qip.circuit
+    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
diff --git a/qutip/tests/test_qpt.py b/qutip/tests/test_qpt.py
index c2d092e207..896a8da936 100644
--- a/qutip/tests/test_qpt.py
+++ b/qutip/tests/test_qpt.py
@@ -1,50 +1,50 @@
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-import scipy.linalg as la
-
-from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
-from qutip.core.gates import snot, cnot
-
-
-def test_qpt_snot():
-    "quantum process tomography for snot gate"
-
-    U_psi = snot()
-    U_rho = spre(U_psi) * spost(U_psi.dag())
-    N = 1
-    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
-    # op_label = [["i", "x", "y", "z"] for i in range(N)]
-    chi1 = qpt(U_rho, op_basis)
-
-    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
-    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
-
-    assert_(la.norm(chi2 - chi1) < 1e-8)
-
-
-def test_qpt_cnot():
-    "quantum process tomography for cnot gate"
-
-    U_psi = cnot()
-    U_rho = spre(U_psi) * spost(U_psi.dag())
-    N = 2
-    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
-    # op_label = [["i", "x", "y", "z"] for i in range(N)]
-    chi1 = qpt(U_rho, op_basis)
-
-    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
-    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
-
-    chi2[12, 0] = chi2[12, 1] = 0.25
-    chi2[13, 0] = chi2[13, 1] = -0.25
-
-    chi2[0, 12] = chi2[1, 12] = 0.25
-    chi2[0, 13] = chi2[1, 13] = -0.25
-
-    chi2[12, 12] = chi2[13, 13] = 0.25
-    chi2[13, 12] = chi2[12, 13] = -0.25
-
-    assert_(la.norm(chi2 - chi1) < 1e-8)
-
-if __name__ == "__main__":
-    run_module_suite()
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+import scipy.linalg as la
+
+from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
+from qutip.core.gates import snot, cnot
+
+
+def test_qpt_snot():
+    "quantum process tomography for snot gate"
+
+    U_psi = snot()
+    U_rho = spre(U_psi) * spost(U_psi.dag())
+    N = 1
+    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
+    # op_label = [["i", "x", "y", "z"] for i in range(N)]
+    chi1 = qpt(U_rho, op_basis)
+
+    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
+    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
+
+    assert_(la.norm(chi2 - chi1) < 1e-8)
+
+
+def test_qpt_cnot():
+    "quantum process tomography for cnot gate"
+
+    U_psi = cnot()
+    U_rho = spre(U_psi) * spost(U_psi.dag())
+    N = 2
+    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
+    # op_label = [["i", "x", "y", "z"] for i in range(N)]
+    chi1 = qpt(U_rho, op_basis)
+
+    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
+    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
+
+    chi2[12, 0] = chi2[12, 1] = 0.25
+    chi2[13, 0] = chi2[13, 1] = -0.25
+
+    chi2[0, 12] = chi2[1, 12] = 0.25
+    chi2[0, 13] = chi2[1, 13] = -0.25
+
+    chi2[12, 12] = chi2[13, 13] = 0.25
+    chi2[13, 12] = chi2[12, 13] = -0.25
+
+    assert_(la.norm(chi2 - chi1) < 1e-8)
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/test_random.py b/qutip/tests/test_random.py
index 13f9554bbf..8b70029650 100644
--- a/qutip/tests/test_random.py
+++ b/qutip/tests/test_random.py
@@ -1,311 +1,311 @@
-import numpy as np
-from numpy.random import SeedSequence, default_rng
-import scipy.sparse as sp
-import scipy.linalg as la
-import pytest
-
-from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
-from qutip import data as _data
-from qutip.random_objects import (
-    rand_herm,
-    rand_unitary,
-    rand_dm,
-    rand_ket,
-    rand_stochastic,
-    rand_super,
-    rand_super_bcsz,
-    rand_kraus_map,
-)
-
-
-@pytest.fixture(params=[
-    12,
-    [8],
-    [2, 2, 3],
-    [[2], [2]]
-], ids=["int", "list", "tensor", "super"])
-def dimensions(request):
-    return request.param
-
-
-@pytest.fixture(
-    params=list(_data.to.dtypes),
-    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
-)
-def dtype(request):
-    return request.param
-
-
-def _assert_density(qobj, density):
-    N = np.sum(qobj.full() != 0)
-    density = N / np.prod(qobj.shape)
-    assert density == pytest.approx(density, abs=0.2)
-
-
-def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
-    if isinstance(dims, int):
-        dims = [dims]
-    N = np.prod(dims)
-    if super and not isinstance(dims[0], list):
-        target_dims_0 = [dims, dims]
-        shape0 = N**2
-    else:
-        target_dims_0 = dims
-        shape0 = N
-
-    if ket:
-        target_dims_1 = [1]
-        shape1 = 1
-    else:
-        target_dims_1 = target_dims_0
-        shape1 = shape0
-
-    assert random_qobj.dims[0] == target_dims_0
-    assert random_qobj.dims[1] == target_dims_1
-    assert random_qobj.shape == (shape0, shape1)
-
-    if dtype:
-        assert isinstance(random_qobj.data, dtype)
-
-
-@pytest.mark.repeat(3)
-@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
-@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
-def test_rand_herm(dimensions, density, distribution, dtype):
-    """
-    Random Qobjs: Hermitian matrix
-    """
-    random_qobj = rand_herm(
-        dimensions,
-        density=density,
-        distribution=distribution,
-        dtype=dtype
-    )
-    if distribution == "pos_def":
-        assert all(random_qobj.eigenenergies() > -1e14)
-    assert random_qobj.isherm
-    assert _data.isherm(random_qobj.data)
-    _assert_metadata(random_qobj, dimensions, dtype)
-    _assert_density(random_qobj, density)
-
-
-@pytest.mark.repeat(3)
-@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
-def test_rand_herm_Eigs(dimensions, density):
-    """
-    Random Qobjs: Hermitian matrix - Eigs given
-    """
-    N = np.prod(dimensions)
-    eigs = np.random.random(N)
-    eigs /= np.sum(eigs)
-    eigs.sort()
-    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
-    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
-    # verify hermitian
-    assert random_qobj.isherm
-    assert _data.isherm(random_qobj.data)
-    _assert_metadata(random_qobj, dimensions)
-    _assert_density(random_qobj, density)
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize('distribution', ["haar", "exp"])
-@pytest.mark.parametrize('density', [0.2, 0.8])
-def test_rand_unitary(dimensions, distribution, density, dtype):
-    """
-    Random Qobjs: Tests that unitaries are actually unitary.
-    """
-    N = np.prod(dimensions)
-    random_qobj = rand_unitary(
-        dimensions, distribution=distribution,
-        density=density, dtype=dtype
-    )
-    I = qeye(dimensions)
-    assert random_qobj * random_qobj.dag() == I
-    _assert_metadata(random_qobj, dimensions, dtype)
-    if distribution == "exp":
-        _assert_density(random_qobj, density)
-
-
-@pytest.mark.repeat(3)
-@pytest.mark.parametrize(["distribution", "kw"], [
-    pytest.param("ginibre", {"rank": 3}),
-    pytest.param("ginibre", {"rank": 1}),
-    pytest.param("hs", {"rank": 0}),
-    pytest.param("pure", {"rank": 1, "density": 0.5}),
-    pytest.param("eigen", {"eigenvalues": True}),
-    pytest.param("herm", {"density": 0.7}),
-    pytest.param("herm", {"density": 0.3}),
-])
-def test_rand_dm(dimensions, kw, dtype, distribution):
-    """
-    Random Qobjs: Density matrix
-    """
-    N = np.prod(dimensions)
-    print(N, kw)
-    if "eigenvalues" in kw:
-        eigs = np.random.random(N)
-        eigs /= np.sum(eigs)
-        eigs.sort()
-        kw["eigenvalues"] = eigs
-
-    random_qobj = rand_dm(
-        dimensions,
-        distribution=distribution,
-        dtype=dtype,
-        **kw
-    )
-    assert abs(random_qobj.tr() - 1.0) < 1e-14
-    # verify all eigvals are >=0
-    assert all(random_qobj.eigenenergies() >= -1e-14)
-    # verify hermitian
-    assert random_qobj.isherm
-    assert _data.isherm(random_qobj.data)
-
-    _assert_metadata(random_qobj, dimensions, dtype)
-
-    eigenvalues = random_qobj.eigenenergies()
-
-    if "rank" in kw:
-        print(kw["rank"], N, kw["rank"] or N)
-        desired_rank = kw["rank"] or N  # 'hs' is full rank.
-        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
-        assert rank == desired_rank
-
-    if "eigenvalues" in kw:
-        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
-
-    if "density" in kw:
-        _assert_density(random_qobj, kw["density"])
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize('kind', ["left", "right"])
-def test_rand_stochastic(dimensions, kind, dtype):
-    """
-    Random Qobjs: Test random stochastic
-    """
-    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
-    axis = {"left":0, "right":1}[kind]
-    np.testing.assert_allclose(
-        np.sum(random_qobj.full(), axis=axis),
-        1, atol=1e-14
-    )
-    _assert_metadata(random_qobj, dimensions, dtype)
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize('distribution', ["haar", "fill"])
-def test_rand_ket(dimensions, distribution, dtype):
-    """
-    Random Qobjs: Test random ket type and norm.
-    """
-    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
-
-    assert random_qobj.type == 'ket'
-    assert abs(random_qobj.norm() - 1) < 1e-14
-
-    if isinstance(dimensions, int):
-        dims = [dimensions]
-    N = np.prod(dimensions)
-    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
-
-
-@pytest.mark.repeat(2)
-@pytest.mark.parametrize('superrep', ["choi", "super"])
-def test_rand_super(dimensions, dtype, superrep):
-    """
-    Random Qobjs: Super operator.
-    """
-    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
-    assert random_qobj.issuper
-    with CoreOptions(atol=1e-9):
-        assert random_qobj.iscptp
-    assert random_qobj.superrep == superrep
-    _assert_metadata(random_qobj, dimensions, dtype, super=True)
-
-
-@pytest.mark.repeat(2)
-@pytest.mark.parametrize('rank', [None, 4])
-@pytest.mark.parametrize('superrep', ["choi", "super"])
-def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
-    """
-    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
-    """
-
-    random_qobj = rand_super_bcsz(dimensions, rank=rank,
-                                  dtype=dtype, superrep=superrep)
-    assert random_qobj.issuper
-    with CoreOptions(atol=1e-9):
-        assert random_qobj.iscptp
-    assert random_qobj.superrep == superrep
-    _assert_metadata(random_qobj, dimensions, dtype, super=True)
-    if (
-        not rank
-        and isinstance(dimensions, list)
-        and isinstance(dimensions[0], list)
-    ):
-        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
-        rank = np.prod(dimensions)
-    elif not rank:
-        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
-        rank = np.prod(dimensions)**2
-    rank = rank or N
-    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
-    assert obtained_rank == rank
-
-
-@pytest.mark.parametrize("function", [
-    pytest.param(rand_herm, id="rand_herm"),
-    pytest.param(rand_unitary, id="rand_unitary"),
-    pytest.param(rand_dm, id="rand_dm"),
-    pytest.param(rand_ket, id="rand_ket"),
-    pytest.param(rand_stochastic, id="rand_stochastic"),
-    pytest.param(rand_super, id="rand_super"),
-    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
-])
-@pytest.mark.parametrize("seed", [
-    pytest.param(lambda : 123, id="int"),
-    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
-    pytest.param(lambda : default_rng(123), id="Generator")
-])
-def test_random_seeds(function, seed):
-    """
-    Random Qobjs: Random number generator seed
-    """
-    U0 = function(5, seed=seed())
-    U1 = function(5, seed=None)
-    U2 = function(5, seed=seed())
-    assert U0 != U1
-    assert U0 == U2
-
-
-def test_kraus_map(dimensions, dtype):
-    kmap = rand_kraus_map(dimensions, dtype=dtype)
-    _assert_metadata(kmap[0], dimensions, dtype)
-    with CoreOptions(atol=1e-9):
-        assert kraus_to_choi(kmap).iscptp
-
-
-dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
-dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-@pytest.mark.parametrize('func', [
-    rand_herm,
-    rand_unitary,
-    rand_dm,
-    rand_ket,
-    rand_stochastic,
-    rand_super,
-    rand_super_bcsz,
-    rand_kraus_map,
-])
-def test_random_dtype(func, alias, dtype):
-    with CoreOptions(default_dtype=alias):
-        object = func(2)
-        if isinstance(object, Qobj):
-            assert isinstance(object.data, dtype)
-        else:
-            for obj in object:
-                assert isinstance(obj.data, dtype)
+import numpy as np
+from numpy.random import SeedSequence, default_rng
+import scipy.sparse as sp
+import scipy.linalg as la
+import pytest
+
+from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
+from qutip import data as _data
+from qutip.random_objects import (
+    rand_herm,
+    rand_unitary,
+    rand_dm,
+    rand_ket,
+    rand_stochastic,
+    rand_super,
+    rand_super_bcsz,
+    rand_kraus_map,
+)
+
+
+@pytest.fixture(params=[
+    12,
+    [8],
+    [2, 2, 3],
+    [[2], [2]]
+], ids=["int", "list", "tensor", "super"])
+def dimensions(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=list(_data.to.dtypes),
+    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
+)
+def dtype(request):
+    return request.param
+
+
+def _assert_density(qobj, density):
+    N = np.sum(qobj.full() != 0)
+    density = N / np.prod(qobj.shape)
+    assert density == pytest.approx(density, abs=0.2)
+
+
+def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
+    if isinstance(dims, int):
+        dims = [dims]
+    N = np.prod(dims)
+    if super and not isinstance(dims[0], list):
+        target_dims_0 = [dims, dims]
+        shape0 = N**2
+    else:
+        target_dims_0 = dims
+        shape0 = N
+
+    if ket:
+        target_dims_1 = [1]
+        shape1 = 1
+    else:
+        target_dims_1 = target_dims_0
+        shape1 = shape0
+
+    assert random_qobj.dims[0] == target_dims_0
+    assert random_qobj.dims[1] == target_dims_1
+    assert random_qobj.shape == (shape0, shape1)
+
+    if dtype:
+        assert isinstance(random_qobj.data, dtype)
+
+
+@pytest.mark.repeat(3)
+@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
+@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
+def test_rand_herm(dimensions, density, distribution, dtype):
+    """
+    Random Qobjs: Hermitian matrix
+    """
+    random_qobj = rand_herm(
+        dimensions,
+        density=density,
+        distribution=distribution,
+        dtype=dtype
+    )
+    if distribution == "pos_def":
+        assert all(random_qobj.eigenenergies() > -1e14)
+    assert random_qobj.isherm
+    assert _data.isherm(random_qobj.data)
+    _assert_metadata(random_qobj, dimensions, dtype)
+    _assert_density(random_qobj, density)
+
+
+@pytest.mark.repeat(3)
+@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
+def test_rand_herm_Eigs(dimensions, density):
+    """
+    Random Qobjs: Hermitian matrix - Eigs given
+    """
+    N = np.prod(dimensions)
+    eigs = np.random.random(N)
+    eigs /= np.sum(eigs)
+    eigs.sort()
+    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
+    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
+    # verify hermitian
+    assert random_qobj.isherm
+    assert _data.isherm(random_qobj.data)
+    _assert_metadata(random_qobj, dimensions)
+    _assert_density(random_qobj, density)
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize('distribution', ["haar", "exp"])
+@pytest.mark.parametrize('density', [0.2, 0.8])
+def test_rand_unitary(dimensions, distribution, density, dtype):
+    """
+    Random Qobjs: Tests that unitaries are actually unitary.
+    """
+    N = np.prod(dimensions)
+    random_qobj = rand_unitary(
+        dimensions, distribution=distribution,
+        density=density, dtype=dtype
+    )
+    I = qeye(dimensions)
+    assert random_qobj * random_qobj.dag() == I
+    _assert_metadata(random_qobj, dimensions, dtype)
+    if distribution == "exp":
+        _assert_density(random_qobj, density)
+
+
+@pytest.mark.repeat(3)
+@pytest.mark.parametrize(["distribution", "kw"], [
+    pytest.param("ginibre", {"rank": 3}),
+    pytest.param("ginibre", {"rank": 1}),
+    pytest.param("hs", {"rank": 0}),
+    pytest.param("pure", {"rank": 1, "density": 0.5}),
+    pytest.param("eigen", {"eigenvalues": True}),
+    pytest.param("herm", {"density": 0.7}),
+    pytest.param("herm", {"density": 0.3}),
+])
+def test_rand_dm(dimensions, kw, dtype, distribution):
+    """
+    Random Qobjs: Density matrix
+    """
+    N = np.prod(dimensions)
+    print(N, kw)
+    if "eigenvalues" in kw:
+        eigs = np.random.random(N)
+        eigs /= np.sum(eigs)
+        eigs.sort()
+        kw["eigenvalues"] = eigs
+
+    random_qobj = rand_dm(
+        dimensions,
+        distribution=distribution,
+        dtype=dtype,
+        **kw
+    )
+    assert abs(random_qobj.tr() - 1.0) < 1e-14
+    # verify all eigvals are >=0
+    assert all(random_qobj.eigenenergies() >= -1e-14)
+    # verify hermitian
+    assert random_qobj.isherm
+    assert _data.isherm(random_qobj.data)
+
+    _assert_metadata(random_qobj, dimensions, dtype)
+
+    eigenvalues = random_qobj.eigenenergies()
+
+    if "rank" in kw:
+        print(kw["rank"], N, kw["rank"] or N)
+        desired_rank = kw["rank"] or N  # 'hs' is full rank.
+        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
+        assert rank == desired_rank
+
+    if "eigenvalues" in kw:
+        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
+
+    if "density" in kw:
+        _assert_density(random_qobj, kw["density"])
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize('kind', ["left", "right"])
+def test_rand_stochastic(dimensions, kind, dtype):
+    """
+    Random Qobjs: Test random stochastic
+    """
+    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
+    axis = {"left":0, "right":1}[kind]
+    np.testing.assert_allclose(
+        np.sum(random_qobj.full(), axis=axis),
+        1, atol=1e-14
+    )
+    _assert_metadata(random_qobj, dimensions, dtype)
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize('distribution', ["haar", "fill"])
+def test_rand_ket(dimensions, distribution, dtype):
+    """
+    Random Qobjs: Test random ket type and norm.
+    """
+    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
+
+    assert random_qobj.type == 'ket'
+    assert abs(random_qobj.norm() - 1) < 1e-14
+
+    if isinstance(dimensions, int):
+        dims = [dimensions]
+    N = np.prod(dimensions)
+    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
+
+
+@pytest.mark.repeat(2)
+@pytest.mark.parametrize('superrep', ["choi", "super"])
+def test_rand_super(dimensions, dtype, superrep):
+    """
+    Random Qobjs: Super operator.
+    """
+    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
+    assert random_qobj.issuper
+    with CoreOptions(atol=1e-9):
+        assert random_qobj.iscptp
+    assert random_qobj.superrep == superrep
+    _assert_metadata(random_qobj, dimensions, dtype, super=True)
+
+
+@pytest.mark.repeat(2)
+@pytest.mark.parametrize('rank', [None, 4])
+@pytest.mark.parametrize('superrep', ["choi", "super"])
+def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
+    """
+    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
+    """
+
+    random_qobj = rand_super_bcsz(dimensions, rank=rank,
+                                  dtype=dtype, superrep=superrep)
+    assert random_qobj.issuper
+    with CoreOptions(atol=1e-9):
+        assert random_qobj.iscptp
+    assert random_qobj.superrep == superrep
+    _assert_metadata(random_qobj, dimensions, dtype, super=True)
+    if (
+        not rank
+        and isinstance(dimensions, list)
+        and isinstance(dimensions[0], list)
+    ):
+        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
+        rank = np.prod(dimensions)
+    elif not rank:
+        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
+        rank = np.prod(dimensions)**2
+    rank = rank or N
+    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
+    assert obtained_rank == rank
+
+
+@pytest.mark.parametrize("function", [
+    pytest.param(rand_herm, id="rand_herm"),
+    pytest.param(rand_unitary, id="rand_unitary"),
+    pytest.param(rand_dm, id="rand_dm"),
+    pytest.param(rand_ket, id="rand_ket"),
+    pytest.param(rand_stochastic, id="rand_stochastic"),
+    pytest.param(rand_super, id="rand_super"),
+    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
+])
+@pytest.mark.parametrize("seed", [
+    pytest.param(lambda : 123, id="int"),
+    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
+    pytest.param(lambda : default_rng(123), id="Generator")
+])
+def test_random_seeds(function, seed):
+    """
+    Random Qobjs: Random number generator seed
+    """
+    U0 = function(5, seed=seed())
+    U1 = function(5, seed=None)
+    U2 = function(5, seed=seed())
+    assert U0 != U1
+    assert U0 == U2
+
+
+def test_kraus_map(dimensions, dtype):
+    kmap = rand_kraus_map(dimensions, dtype=dtype)
+    _assert_metadata(kmap[0], dimensions, dtype)
+    with CoreOptions(atol=1e-9):
+        assert kraus_to_choi(kmap).iscptp
+
+
+dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
+dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize('func', [
+    rand_herm,
+    rand_unitary,
+    rand_dm,
+    rand_ket,
+    rand_stochastic,
+    rand_super,
+    rand_super_bcsz,
+    rand_kraus_map,
+])
+def test_random_dtype(func, alias, dtype):
+    with CoreOptions(default_dtype=alias):
+        object = func(2)
+        if isinstance(object, Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
diff --git a/qutip/tests/test_simdiag.py b/qutip/tests/test_simdiag.py
index a45076fd60..b388ad336d 100644
--- a/qutip/tests/test_simdiag.py
+++ b/qutip/tests/test_simdiag.py
@@ -1,92 +1,92 @@
-import pytest
-import numpy as np
-import qutip
-
-
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
-def test_simdiag(num_mat):
-    N = 10
-
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
-                          for _ in range(num_mat)]
-    all_evals, evecs = qutip.simdiag(commuting_matrices)
-
-    for matrix, evals in zip(commuting_matrices, all_evals):
-        for eval, evec in zip(evals, evecs):
-            assert matrix * evec == evec * eval
-
-
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
-def test_simdiag_no_evals(num_mat):
-    N = 10
-
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
-                          for _ in range(num_mat)]
-    evecs = qutip.simdiag(commuting_matrices, evals=False)
-
-    for matrix in commuting_matrices:
-        for evec in evecs:
-            Mvec = matrix * evec
-            eval = Mvec.norm() / evec.norm()
-            assert matrix * evec == evec * eval
-
-
-@pytest.mark.flaky(reruns=2)
-def test_simdiag_degen():
-    N = 10
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [
-        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
-        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
-        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
-    ]
-    all_evals, evecs = qutip.simdiag(commuting_matrices)
-
-    for matrix, evals in zip(commuting_matrices, all_evals):
-        for eval, evec in zip(evals, evecs):
-            np.testing.assert_allclose(
-                (matrix * evec).full(),
-                (evec * eval).full(),
-                atol=3e-14
-            )
-
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.repeat(2)
-def test_simdiag_degen_large():
-    N = 20
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [
-        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
-        for _ in range(5)
-    ]
-    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
-
-    for matrix, evals in zip(commuting_matrices, all_evals):
-        for eval, evec in zip(evals, evecs):
-            np.testing.assert_allclose(
-                (matrix * evec).full(),
-                (evec * eval).full(),
-                atol=1e-13
-            )
-
-
-def test_simdiag_no_input():
-    with pytest.raises(ValueError):
-        qutip.simdiag([])
-
-
-@pytest.mark.parametrize(['ops', 'error'], [
-    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
-    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
-    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
-    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
-                 id="Not commuting"),
-])
-def test_simdiag_errors(ops, error):
-    with pytest.raises(TypeError) as err:
-        qutip.simdiag(ops)
-    assert error in str(err.value)
+import pytest
+import numpy as np
+import qutip
+
+
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
+def test_simdiag(num_mat):
+    N = 10
+
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
+                          for _ in range(num_mat)]
+    all_evals, evecs = qutip.simdiag(commuting_matrices)
+
+    for matrix, evals in zip(commuting_matrices, all_evals):
+        for eval, evec in zip(evals, evecs):
+            assert matrix * evec == evec * eval
+
+
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
+def test_simdiag_no_evals(num_mat):
+    N = 10
+
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
+                          for _ in range(num_mat)]
+    evecs = qutip.simdiag(commuting_matrices, evals=False)
+
+    for matrix in commuting_matrices:
+        for evec in evecs:
+            Mvec = matrix * evec
+            eval = Mvec.norm() / evec.norm()
+            assert matrix * evec == evec * eval
+
+
+@pytest.mark.flaky(reruns=2)
+def test_simdiag_degen():
+    N = 10
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [
+        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
+        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
+        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
+    ]
+    all_evals, evecs = qutip.simdiag(commuting_matrices)
+
+    for matrix, evals in zip(commuting_matrices, all_evals):
+        for eval, evec in zip(evals, evecs):
+            np.testing.assert_allclose(
+                (matrix * evec).full(),
+                (evec * eval).full(),
+                atol=3e-14
+            )
+
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.repeat(2)
+def test_simdiag_degen_large():
+    N = 20
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [
+        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
+        for _ in range(5)
+    ]
+    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
+
+    for matrix, evals in zip(commuting_matrices, all_evals):
+        for eval, evec in zip(evals, evecs):
+            np.testing.assert_allclose(
+                (matrix * evec).full(),
+                (evec * eval).full(),
+                atol=1e-13
+            )
+
+
+def test_simdiag_no_input():
+    with pytest.raises(ValueError):
+        qutip.simdiag([])
+
+
+@pytest.mark.parametrize(['ops', 'error'], [
+    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
+    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
+    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
+    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
+                 id="Not commuting"),
+])
+def test_simdiag_errors(ops, error):
+    with pytest.raises(TypeError) as err:
+        qutip.simdiag(ops)
+    assert error in str(err.value)
diff --git a/qutip/tests/test_subsys_apply.py b/qutip/tests/test_subsys_apply.py
index ed85466625..0c73ff12df 100644
--- a/qutip/tests/test_subsys_apply.py
+++ b/qutip/tests/test_subsys_apply.py
@@ -1,141 +1,141 @@
-from numpy.linalg import norm
-from numpy.testing import assert_, run_module_suite
-
-from qutip import (
-    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
-    subsystem_apply, rand_dm, rand_unitary,
-)
-from qutip.random_objects import rand_kraus_map
-
-
-class TestSubsysApply(object):
-    """
-    A test class for the QuTiP function for applying superoperators to
-    subsystems.
-    The four tests below determine whether efficient numerics, naive numerics
-    and semi-analytic results are identical.
-    """
-
-    def test_SimpleSingleApply(self):
-        """
-        Non-composite system, operator on Hilbert space.
-        """
-        tol = 1e-12
-        rho_3 = rand_dm(3)
-        single_op = rand_unitary(3)
-        analytic_result = single_op * rho_3 * single_op.dag()
-        naive_result = subsystem_apply(rho_3, single_op, [True],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="SimpleSingle: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_3, single_op, [True])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="SimpleSingle: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
-
-    def test_SimpleSuperApply(self):
-        """
-        Non-composite system, operator on Liouville space.
-        """
-        tol = 1e-12
-        rho_3 = rand_dm(3)
-        superop = kraus_to_super(rand_kraus_map(3))
-        analytic_result = vector_to_operator(superop @
-                                             operator_to_vector(rho_3))
-        naive_result = subsystem_apply(rho_3, superop, [True],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="SimpleSuper: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_3, superop, [True])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="SimpleSuper: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
-
-    def test_ComplexSingleApply(self):
-        """
-        Composite system, operator on Hilbert space.
-        """
-        tol = 1e-12
-        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
-        rho_input = tensor(rho_list)
-        single_op = rand_unitary(3)
-
-        analytic_result = rho_list
-        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
-        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
-        analytic_result = tensor(analytic_result)
-
-        naive_result = subsystem_apply(rho_input, single_op,
-                                       [False, True, False, True, False],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="ComplexSingle: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_input, single_op,
-                                           [False, True, False, True, False])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="ComplexSingle: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
-
-    def test_ComplexSuperApply(self):
-        """
-        Superoperator: Efficient numerics and reference return same result,
-        acting on non-composite system
-        """
-        tol = 1e-10
-        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
-        rho_input = tensor(rho_list)
-        superop = kraus_to_super(rand_kraus_map(3))
-
-        analytic_result = rho_list
-        analytic_result[1] = Qobj(
-            vector_to_operator(
-                superop @ operator_to_vector(analytic_result[1])
-            ))
-        analytic_result[3] = Qobj(
-            vector_to_operator(
-                superop @ operator_to_vector(analytic_result[3])
-            ))
-        analytic_result = tensor(analytic_result)
-
-        naive_result = subsystem_apply(rho_input, superop,
-                                       [False, True, False, True, False],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="ComplexSuper: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_input, superop,
-                                           [False, True, False, True, False])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="ComplexSuper: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
+from numpy.linalg import norm
+from numpy.testing import assert_, run_module_suite
+
+from qutip import (
+    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
+    subsystem_apply, rand_dm, rand_unitary,
+)
+from qutip.random_objects import rand_kraus_map
+
+
+class TestSubsysApply(object):
+    """
+    A test class for the QuTiP function for applying superoperators to
+    subsystems.
+    The four tests below determine whether efficient numerics, naive numerics
+    and semi-analytic results are identical.
+    """
+
+    def test_SimpleSingleApply(self):
+        """
+        Non-composite system, operator on Hilbert space.
+        """
+        tol = 1e-12
+        rho_3 = rand_dm(3)
+        single_op = rand_unitary(3)
+        analytic_result = single_op * rho_3 * single_op.dag()
+        naive_result = subsystem_apply(rho_3, single_op, [True],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="SimpleSingle: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_3, single_op, [True])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="SimpleSingle: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
+
+    def test_SimpleSuperApply(self):
+        """
+        Non-composite system, operator on Liouville space.
+        """
+        tol = 1e-12
+        rho_3 = rand_dm(3)
+        superop = kraus_to_super(rand_kraus_map(3))
+        analytic_result = vector_to_operator(superop @
+                                             operator_to_vector(rho_3))
+        naive_result = subsystem_apply(rho_3, superop, [True],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="SimpleSuper: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_3, superop, [True])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="SimpleSuper: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
+
+    def test_ComplexSingleApply(self):
+        """
+        Composite system, operator on Hilbert space.
+        """
+        tol = 1e-12
+        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
+        rho_input = tensor(rho_list)
+        single_op = rand_unitary(3)
+
+        analytic_result = rho_list
+        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
+        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
+        analytic_result = tensor(analytic_result)
+
+        naive_result = subsystem_apply(rho_input, single_op,
+                                       [False, True, False, True, False],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="ComplexSingle: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_input, single_op,
+                                           [False, True, False, True, False])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="ComplexSingle: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
+
+    def test_ComplexSuperApply(self):
+        """
+        Superoperator: Efficient numerics and reference return same result,
+        acting on non-composite system
+        """
+        tol = 1e-10
+        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
+        rho_input = tensor(rho_list)
+        superop = kraus_to_super(rand_kraus_map(3))
+
+        analytic_result = rho_list
+        analytic_result[1] = Qobj(
+            vector_to_operator(
+                superop @ operator_to_vector(analytic_result[1])
+            ))
+        analytic_result[3] = Qobj(
+            vector_to_operator(
+                superop @ operator_to_vector(analytic_result[3])
+            ))
+        analytic_result = tensor(analytic_result)
+
+        naive_result = subsystem_apply(rho_input, superop,
+                                       [False, True, False, True, False],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="ComplexSuper: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_input, superop,
+                                           [False, True, False, True, False])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="ComplexSuper: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
diff --git a/qutip/tests/test_three_level.py b/qutip/tests/test_three_level.py
index 6aee63c071..372605d784 100644
--- a/qutip/tests/test_three_level.py
+++ b/qutip/tests/test_three_level.py
@@ -1,27 +1,27 @@
-import numpy as np
-from numpy.testing import assert_, assert_equal, run_module_suite
-from qutip import basis
-from qutip.three_level_atom import *
-
-
-three_states = three_level_basis()
-three_check = np.empty((3,), dtype=object)
-three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
-three_ops = three_level_ops()
-
-
-def testThreeStates():
-    "Three-level atom: States"
-    assert_equal(np.all(three_states == three_check), True)
-
-
-def testThreeOps():
-    "Three-level atom: Operators"
-    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
-    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
-    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
-    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
-    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
-
-if __name__ == "__main__":
-    run_module_suite()
+import numpy as np
+from numpy.testing import assert_, assert_equal, run_module_suite
+from qutip import basis
+from qutip.three_level_atom import *
+
+
+three_states = three_level_basis()
+three_check = np.empty((3,), dtype=object)
+three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
+three_ops = three_level_ops()
+
+
+def testThreeStates():
+    "Three-level atom: States"
+    assert_equal(np.all(three_states == three_check), True)
+
+
+def testThreeOps():
+    "Three-level atom: Operators"
+    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
+    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
+    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
+    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
+    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/test_transfertensor.py b/qutip/tests/test_transfertensor.py
index c736ef04ac..34cacd2c1f 100644
--- a/qutip/tests/test_transfertensor.py
+++ b/qutip/tests/test_transfertensor.py
@@ -1,45 +1,45 @@
-import pytest
-import qutip as qt
-import numpy as np
-from qutip.solve.nonmarkov.transfertensor import ttmsolve
-
-
-def test_ttmsolve_jc_model():
-    """
-    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
-    which can also be found in the qutip-notebooks repository.
-    """
-    # Define Hamiltonian and states
-    N, kappa, g = 3, 1.0, 10
-    a = qt.tensor(qt.qeye(2), qt.destroy(N))
-    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
-    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
-    H = g * (a.dag() * sm + a * sm.dag())
-    c_ops = [np.sqrt(kappa) * a]
-    # identity superoperator
-    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
-    E0 = qt.sprepost(Id, Id)
-    # partial trace superoperator
-    ptracesuper = qt.tensor_contract(E0, (1, N))
-    # initial states
-    rho0a = qt.ket2dm(qt.basis(2, 0))
-    psi0c = qt.basis(N, 0)
-    rho0c = qt.ket2dm(psi0c)
-    rho0 = qt.tensor(rho0a, rho0c)
-    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
-                               qt.tensor(qt.qeye(2), psi0c.dag()))
-
-    # calculate exact solution using mesolve
-    times = np.arange(0, 5.0, 0.1)
-    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
-    exact_z = qt.expect(sz, exactsol.states)
-
-    # solve using transfer method
-    learning_times = np.arange(0, 2.0, 0.1)
-    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
-    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
-    ttmsol = ttmsolve(learning_maps, rho0a, times)
-    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
-
-    # check that ttm result and exact solution are close in the learning times
-    assert np.allclose(ttm_z, exact_z, atol=1e-5)
+import pytest
+import qutip as qt
+import numpy as np
+from qutip.solve.nonmarkov.transfertensor import ttmsolve
+
+
+def test_ttmsolve_jc_model():
+    """
+    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
+    which can also be found in the qutip-notebooks repository.
+    """
+    # Define Hamiltonian and states
+    N, kappa, g = 3, 1.0, 10
+    a = qt.tensor(qt.qeye(2), qt.destroy(N))
+    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
+    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
+    H = g * (a.dag() * sm + a * sm.dag())
+    c_ops = [np.sqrt(kappa) * a]
+    # identity superoperator
+    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
+    E0 = qt.sprepost(Id, Id)
+    # partial trace superoperator
+    ptracesuper = qt.tensor_contract(E0, (1, N))
+    # initial states
+    rho0a = qt.ket2dm(qt.basis(2, 0))
+    psi0c = qt.basis(N, 0)
+    rho0c = qt.ket2dm(psi0c)
+    rho0 = qt.tensor(rho0a, rho0c)
+    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
+                               qt.tensor(qt.qeye(2), psi0c.dag()))
+
+    # calculate exact solution using mesolve
+    times = np.arange(0, 5.0, 0.1)
+    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
+    exact_z = qt.expect(sz, exactsol.states)
+
+    # solve using transfer method
+    learning_times = np.arange(0, 2.0, 0.1)
+    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
+    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
+    ttmsol = ttmsolve(learning_maps, rho0a, times)
+    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
+
+    # check that ttm result and exact solution are close in the learning times
+    assert np.allclose(ttm_z, exact_z, atol=1e-5)
diff --git a/qutip/tests/test_utilities.py b/qutip/tests/test_utilities.py
index f29d8224c6..648d6a4dc3 100644
--- a/qutip/tests/test_utilities.py
+++ b/qutip/tests/test_utilities.py
@@ -1,121 +1,121 @@
-import numpy as np
-from qutip import convert_unit, clebsch, n_thermal
-import qutip.utilities as utils
-from functools import partial
-import pytest
-
-
-@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
-    pytest.param(np.log(2), 1, 1, id='log(2)'),
-    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
-    pytest.param(0, 1, 0, id="0_energy"),
-    pytest.param(1, -1, 0, id="neg_temp"),
-    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
-                 np.array([1, 1/2, 1/3]), id="array"),
-])
-def test_n_thermal(w, w_th, expected):
-    np.testing.assert_allclose(n_thermal(w, w_th), expected)
-
-
-def _get_converter(orig, target):
-    """get funtion 'convert_{}_to_{}' when available for coverage """
-    try:
-        func = getattr(utils, f'convert_{orig}_to_{target}')
-    except AttributeError:
-        func = partial(convert_unit, orig=orig, to=target)
-    return func
-
-
-@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
-@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
-def test_unit_conversions(orig, target):
-    T = np.random.rand() * 100.0
-    T_converted = convert_unit(T, orig=orig, to=target)
-    T_back = convert_unit(T_converted, orig=target, to=orig)
-
-    assert T == pytest.approx(T_back)
-
-    T_converted = _get_converter(orig=orig, target=target)(T)
-    T_back = _get_converter(orig=target, target=orig)(T_converted)
-
-    assert T == pytest.approx(T_back)
-
-
-@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
-@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
-@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
-def test_unit_conversions_loop(orig, middle, target):
-    T = np.random.rand() * 100.0
-    T_middle = convert_unit(T, orig=orig, to=middle)
-    T_converted = convert_unit(T_middle, orig=middle, to=target)
-    T_back = convert_unit(T_converted, orig=target, to=orig)
-
-    assert T == pytest.approx(T_back)
-
-
-def test_unit_conversions_bad_unit():
-    with pytest.raises(TypeError):
-        convert_unit(10, orig="bad", to="J")
-    with pytest.raises(TypeError):
-        convert_unit(10, orig="J", to="bad")
-
-
-@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-def test_unit_clebsch_delta_j(j1, j2):
-    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
-    delta j3,j3' delta m3,m3'"""
-    for _ in range(10):
-        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
-        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
-        m3 = np.random.choice(np.arange(-j3, j3+1))
-        m3p = np.random.choice(np.arange(-j3p, j3p+1))
-
-        sum_match = 0
-        sum_differ = 0
-        for m1 in np.arange(-j1, j1+1):
-            for m2 in np.arange(-j2, j2+1):
-                c1 = clebsch(j1, j2, j3, m1, m2, m3)
-                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
-                sum_match += c1**2
-                sum_differ += c1*c2
-        assert sum_match == pytest.approx(1)
-        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
-
-
-@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-def test_unit_clebsch_delta_m(j1, j2):
-    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
-    delta m1,m1' delta m2,m2'"""
-    for _ in range(10):
-        m1 = np.random.choice(np.arange(-j1, j1+1))
-        m1p = np.random.choice(np.arange(-j1, j1+1))
-        m2 = np.random.choice(np.arange(-j2, j2+1))
-        m2p = np.random.choice(np.arange(-j2, j2+1))
-
-        sum_match = 0
-        sum_differ = 0
-        for j3 in np.arange(abs(j1-j2), j1+j2+1):
-            for m3 in np.arange(-j3, j3+1):
-                c1 = clebsch(j1, j2, j3, m1, m2, m3)
-                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
-                sum_match += c1**2
-                sum_differ += c1*c2
-        assert sum_match == pytest.approx(1)
-        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
-
-
-def test_cpu_count(monkeypatch):
-    from qutip.settings import available_cpu_count
-    ncpus = available_cpu_count()
-    assert isinstance(ncpus, int)
-    assert ncpus >= 1
-
-    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
-    new_ncpus = available_cpu_count()
-    assert new_ncpus == ncpus + 2
-
-    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
-    new_ncpus = available_cpu_count()
-    assert new_ncpus >= 1
+import numpy as np
+from qutip import convert_unit, clebsch, n_thermal
+import qutip.utilities as utils
+from functools import partial
+import pytest
+
+
+@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
+    pytest.param(np.log(2), 1, 1, id='log(2)'),
+    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
+    pytest.param(0, 1, 0, id="0_energy"),
+    pytest.param(1, -1, 0, id="neg_temp"),
+    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
+                 np.array([1, 1/2, 1/3]), id="array"),
+])
+def test_n_thermal(w, w_th, expected):
+    np.testing.assert_allclose(n_thermal(w, w_th), expected)
+
+
+def _get_converter(orig, target):
+    """get funtion 'convert_{}_to_{}' when available for coverage """
+    try:
+        func = getattr(utils, f'convert_{orig}_to_{target}')
+    except AttributeError:
+        func = partial(convert_unit, orig=orig, to=target)
+    return func
+
+
+@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
+@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
+def test_unit_conversions(orig, target):
+    T = np.random.rand() * 100.0
+    T_converted = convert_unit(T, orig=orig, to=target)
+    T_back = convert_unit(T_converted, orig=target, to=orig)
+
+    assert T == pytest.approx(T_back)
+
+    T_converted = _get_converter(orig=orig, target=target)(T)
+    T_back = _get_converter(orig=target, target=orig)(T_converted)
+
+    assert T == pytest.approx(T_back)
+
+
+@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
+@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
+@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
+def test_unit_conversions_loop(orig, middle, target):
+    T = np.random.rand() * 100.0
+    T_middle = convert_unit(T, orig=orig, to=middle)
+    T_converted = convert_unit(T_middle, orig=middle, to=target)
+    T_back = convert_unit(T_converted, orig=target, to=orig)
+
+    assert T == pytest.approx(T_back)
+
+
+def test_unit_conversions_bad_unit():
+    with pytest.raises(TypeError):
+        convert_unit(10, orig="bad", to="J")
+    with pytest.raises(TypeError):
+        convert_unit(10, orig="J", to="bad")
+
+
+@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+def test_unit_clebsch_delta_j(j1, j2):
+    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
+    delta j3,j3' delta m3,m3'"""
+    for _ in range(10):
+        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
+        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
+        m3 = np.random.choice(np.arange(-j3, j3+1))
+        m3p = np.random.choice(np.arange(-j3p, j3p+1))
+
+        sum_match = 0
+        sum_differ = 0
+        for m1 in np.arange(-j1, j1+1):
+            for m2 in np.arange(-j2, j2+1):
+                c1 = clebsch(j1, j2, j3, m1, m2, m3)
+                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
+                sum_match += c1**2
+                sum_differ += c1*c2
+        assert sum_match == pytest.approx(1)
+        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
+
+
+@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+def test_unit_clebsch_delta_m(j1, j2):
+    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
+    delta m1,m1' delta m2,m2'"""
+    for _ in range(10):
+        m1 = np.random.choice(np.arange(-j1, j1+1))
+        m1p = np.random.choice(np.arange(-j1, j1+1))
+        m2 = np.random.choice(np.arange(-j2, j2+1))
+        m2p = np.random.choice(np.arange(-j2, j2+1))
+
+        sum_match = 0
+        sum_differ = 0
+        for j3 in np.arange(abs(j1-j2), j1+j2+1):
+            for m3 in np.arange(-j3, j3+1):
+                c1 = clebsch(j1, j2, j3, m1, m2, m3)
+                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
+                sum_match += c1**2
+                sum_differ += c1*c2
+        assert sum_match == pytest.approx(1)
+        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
+
+
+def test_cpu_count(monkeypatch):
+    from qutip.settings import available_cpu_count
+    ncpus = available_cpu_count()
+    assert isinstance(ncpus, int)
+    assert ncpus >= 1
+
+    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
+    new_ncpus = available_cpu_count()
+    assert new_ncpus == ncpus + 2
+
+    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
+    new_ncpus = available_cpu_count()
+    assert new_ncpus >= 1
diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
index 78c5714845..5dd34556b8 100644
--- a/qutip/tests/test_wigner.py
+++ b/qutip/tests/test_wigner.py
@@ -1,693 +1,693 @@
-import pytest
-import numpy as np
-import itertools
-from scipy.special import laguerre
-from numpy.random import rand
-from numpy.testing import assert_, run_module_suite, assert_equal, \
-    assert_almost_equal, assert_allclose
-
-import qutip
-from qutip.core.states import coherent, fock, ket, bell_state
-from qutip.wigner import wigner, wigner_transform, _parity
-from qutip.random_objects import rand_dm, rand_ket
-
-
-class TestHusimiQ:
-    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
-    def test_failure_if_non_arraylike_coordinates(self, xs):
-        state = qutip.rand_ket(4)
-        valid = np.linspace(-1, 1, 5)
-        with pytest.raises(TypeError) as e:
-            qutip.qfunc(state, xs, valid)
-        assert "must be array-like" in e.value.args[0]
-        with pytest.raises(TypeError) as e:
-            qutip.qfunc(state, valid, xs)
-        assert "must be array-like" in e.value.args[0]
-        with pytest.raises(TypeError) as e:
-            qutip.QFunc(xs, valid)
-        assert "must be array-like" in e.value.args[0]
-        with pytest.raises(TypeError) as e:
-            qutip.QFunc(valid, xs)
-        assert "must be array-like" in e.value.args[0]
-
-    @pytest.mark.parametrize('ndim', [2, 3])
-    def test_failure_if_coordinates_not_1d(self, ndim):
-        state = qutip.rand_ket(4)
-        valid = np.linspace(-1, 1, 5)
-        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, bad, valid)
-        assert "must be 1D" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, valid, bad)
-        assert "must be 1D" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.QFunc(bad, valid)
-        assert "must be 1D" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.QFunc(valid, bad)
-        assert "must be 1D" in e.value.args[0]
-
-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-    def test_failure_if_tensor_hilbert_space(self, dm):
-        if dm:
-            state = qutip.rand_dm([2, 2])
-        else:
-            state = qutip.rand_ket([2, 2])
-        xs = np.linspace(-1, 1, 5)
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, xs, xs)
-        assert "must not have tensor structure" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.QFunc(xs, xs)(state)
-        assert "must not have tensor structure" in e.value.args[0]
-
-    def test_QFunc_raises_if_insufficient_memory(self):
-        xs = np.linspace(-1, 1, 11)
-        state = qutip.rand_ket(4)
-        qfunc = qutip.QFunc(xs, xs, memory=0)
-        with pytest.raises(MemoryError) as e:
-            qfunc(state)
-        assert e.value.args[0].startswith("Refusing to precompute")
-
-    def test_qfunc_warns_if_insufficient_memory(self):
-        xs = np.linspace(-1, 1, 11)
-        state = qutip.rand_dm(4)
-        with pytest.warns(UserWarning) as e:
-            qutip.qfunc(state, xs, xs, precompute_memory=0)
-        assert (
-            e[0].message.args[0]
-            .startswith("Falling back to iterative algorithm")
-        )
-
-    @pytest.mark.parametrize('obj', [
-        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
-        pytest.param([[1, 0], [0, 1]], id='list'),
-        pytest.param(1, id='int'),
-    ])
-    def test_failure_if_not_a_Qobj(self, obj):
-        xs = np.linspace(-1, 1, 11)
-        with pytest.raises(TypeError) as e:
-            qutip.qfunc(obj, xs, xs)
-        assert e.value.args[0].startswith("state must be Qobj")
-        qfunc = qutip.QFunc(xs, xs)
-        with pytest.raises(TypeError) as e:
-            qfunc(obj)
-        assert e.value.args[0].startswith("state must be Qobj")
-
-    # Use indirection so that the tests can still be collected if there's a bug
-    # in the generating QuTiP functions.
-    @pytest.mark.parametrize('state', [
-        pytest.param(lambda: qutip.rand_super(2), id='super'),
-        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
-        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
-        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
-                     id='nonsquare dm'),
-        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
-                     id='operator-ket'),
-        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
-                     id='operator-bra'),
-    ])
-    def test_failure_if_not_a_state(self, state):
-        xs = np.linspace(-1, 1, 11)
-        state = state()
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, xs, xs)
-        assert (
-            e.value.args[0].startswith("state must be a ket or density matrix")
-        )
-        qfunc = qutip.QFunc(xs, xs)
-        with pytest.raises(ValueError) as e:
-            qfunc(state)
-        assert (
-            e.value.args[0].startswith("state must be a ket or density matrix")
-        )
-
-    @pytest.mark.parametrize('g', [
-        pytest.param(np.sqrt(2), id='natural units'),
-        pytest.param(1, id='arb units'),
-    ])
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-    @pytest.mark.parametrize('size', [5, 32])
-    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(0, 2, n_ys)
-        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
-        function = qutip.qfunc(state, xs, ys, g)
-        class_ = qutip.QFunc(xs, ys, g)(state)
-        np.testing.assert_allclose(function, class_)
-
-    @pytest.mark.parametrize('g', [
-        pytest.param(np.sqrt(2), id='natural units'),
-        pytest.param(1, id='arb units'),
-    ])
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('size', [5, 32])
-    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(0, 2, n_ys)
-        state = qutip.rand_dm(size)
-        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
-        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
-        np.testing.assert_allclose(iterate, precompute)
-
-    @pytest.mark.parametrize('initial_size', [5, 8])
-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-    def test_same_class_can_take_many_sizes(self, dm, initial_size):
-        xs = np.linspace(-1, 1, 11)
-        ys = np.linspace(0, 2, 11)
-        shape = np.meshgrid(xs, ys)[0].shape
-        sizes = initial_size + np.array([0, 1, -1, 4])
-        qfunc = qutip.QFunc(xs, ys)
-        for size in sizes:
-            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
-            out = qfunc(state)
-            assert isinstance(out, np.ndarray)
-            assert out.shape == shape
-
-    @pytest.mark.parametrize('dm_first', [True, False])
-    def test_same_class_can_mix_ket_and_dm(self, dm_first):
-        dms = [True, False, True, False]
-        if not dm_first:
-            dms = dms[::-1]
-        xs = np.linspace(-1, 1, 11)
-        ys = np.linspace(0, 2, 11)
-        shape = np.meshgrid(xs, ys)[0].shape
-        qfunc = qutip.QFunc(xs, ys)
-        for dm in dms:
-            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
-            out = qfunc(state)
-            assert isinstance(out, np.ndarray)
-            assert out.shape == shape
-
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('mix', [0.1, 0.5])
-    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(-1, 1, n_ys)
-        qfunc = qutip.QFunc(xs, ys)
-        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
-        qleft, qright = qfunc(left), qfunc(right)
-        qboth = qfunc(mix*left + (1-mix)*right)
-        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
-
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('size', [5, 32])
-    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(-1, 1, n_ys)
-        state = qutip.rand_ket(size)
-        qfunc = qutip.QFunc(xs, ys)
-        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
-
-    @pytest.mark.parametrize('g', [
-        pytest.param(np.sqrt(2), id='natural units'),
-        pytest.param(1, id='arb units'),
-    ])
-    @pytest.mark.parametrize('ys', [
-        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
-        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
-    ])
-    @pytest.mark.parametrize('xs', [
-        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
-        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
-    ])
-    @pytest.mark.parametrize('size', [3, 5])
-    def test_against_naive_implementation(self, xs, ys, g, size):
-        state = qutip.rand_dm(size)
-        state_np = state.full()
-        x, y = np.meshgrid(xs, ys)
-        alphas = 0.5*g * (x + 1j*y)
-        naive = np.empty(alphas.shape, dtype=np.float64)
-        for i, alpha in enumerate(alphas.flat):
-            coh = qutip.coherent(size, alpha, method='analytic').full()
-            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
-        naive *= (0.5*g)**2 / np.pi
-        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
-        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
-
-
-def test_wigner_bell1_su2parity():
-    """wigner: testing the SU2 parity of the first Bell state.
-    """
-    psi = bell_state('00')
-
-    steps = 25
-    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
-    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
-    slicearray = ['l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
-                                            * np.cos(theta[0, t]))
-                                           * (1 + np.sqrt(3)
-                                           * np.cos(theta[1, t]))
-                                           + 3 * (np.sin(theta[0, t])
-                                           * np.exp(-1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(-1j * phi[1, p])
-                                           + np.sin(theta[0, t])
-                                           * np.exp(1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(1j * phi[1, p]))
-                                           + (1 - np.sqrt(3)
-                                           * np.cos(theta[0, t]))
-                                           * (1 - np.sqrt(3)
-                                           * np.cos(theta[1, t]))) / 8.)
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_bell4_su2parity():
-    """wigner: testing the SU2 parity of the fourth Bell state.
-    """
-    psi = bell_state('11')
-
-    steps = 25
-    slicearray = ['l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = -0.5
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_bell4_fullparity():
-    """wigner: testing the parity of the fourth Bell state using the parity of
-    the full space.
-    """
-    psi = bell_state('11')
-
-    steps = 25
-    slicearray = ['l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = -0.30901699
-
-    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
-
-
-def test_parity():
-    """wigner: testing the parity function.
-    """
-    j = 0.5
-    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
-    assert_(_parity(2, j)[0, 1] < 1e-11)
-    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
-    assert_(_parity(2, j)[1, 0] < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_pure_su2():
-    """wigner: testing the SU2 wigner transformation of a pure state.
-    """
-    psi = (ket([1]))
-    steps = 25
-    theta = np.linspace(0, np.pi, steps)
-    phi = np.linspace(0, 2 * np.pi, steps)
-    theta = theta[None, :]
-    phi = phi[None, :]
-    slicearray = ['l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_ghz_su2parity():
-    """wigner: testing the SU2 wigner transformation of the GHZ state.
-    """
-    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
-
-    steps = 25
-    N = 3
-    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
-    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
-    slicearray = ['l', 'l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
-                                           * (1 + np.sqrt(3)
-                                           * np.cos(theta[1, t]))
-                                           * (1 + np.sqrt(3)
-                                           * np.cos(theta[2, t]))
-                                           + 3**(3 / 2) * (np.sin(theta[0, t])
-                                           * np.exp(-1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(-1j * phi[1, p])
-                                           * np.sin(theta[2, t])
-                                           * np.exp(-1j * phi[2, p])
-                                           + np.sin(theta[0, t])
-                                           * np.exp(1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(1j * phi[1, p])
-                                           * np.sin(theta[2, t])
-                                           * np.exp(1j * phi[2, p]))
-                                           + (1 - np.sqrt(3)
-                                           * np.cos(theta[0, t]))
-                                           * (1 - np.sqrt(3)
-                                           * np.cos(theta[1, t]))
-                                           * (1 - np.sqrt(3)
-                                           * np.cos(theta[2, t]))) / 16.)
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_angle_slicing():
-    """wigner: tests angle slicing.
-    """
-    psi1 = bell_state('00')
-    psi2 = bell_state('01')
-    psi3 = bell_state('10')
-    psi4 = bell_state('11')
-
-    steps = 25
-    j = 0.5
-
-    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
-    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
-    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
-    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
-
-    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
-    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
-    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
-    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
-
-
-def test_wigner_coherent():
-    "wigner: test wigner function calculation for coherent states"
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 20
-    beta = rand() + rand() * 1.0j
-    psi = coherent(N, beta)
-
-    # calculate the wigner function using qutip and analytic formula
-    W_qutip = wigner(psi, xvec, yvec, g=2)
-    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
-    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
-
-    # check difference
-    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
-    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
-
-    # check normalization
-    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_fock():
-    "wigner: test wigner function calculation for Fock states"
-
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 15
-
-    for n in [2, 3, 4, 5, 6]:
-
-        psi = fock(N, n)
-
-        # calculate the wigner function using qutip and analytic formula
-        W_qutip = wigner(psi, xvec, yvec, g=2)
-        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
-        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
-        W_analytic = 2 / np.pi * (-1) ** n * \
-            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
-
-        # check difference
-        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
-        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
-        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
-
-        # check normalization
-        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_compare_methods_dm():
-    "wigner: compare wigner methods for random density matrices"
-
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    # a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 15
-
-    for n in range(10):
-        # try ten different random density matrices
-
-        rho = rand_dm(N, density=0.5 + rand() / 2)
-
-        # calculate the wigner function using qutip and analytic formula
-        W_qutip1 = wigner(rho, xvec, yvec, g=2)
-        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
-
-        # check difference
-        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
-
-        # check normalization
-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_compare_methods_ket():
-    "wigner: compare wigner methods for random state vectors"
-
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    # a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 15
-
-    for n in range(10):
-        # try ten different random density matrices
-
-        psi = rand_ket(N, density=0.5 + rand() / 2)
-
-        # calculate the wigner function using qutip and analytic formula
-        W_qutip1 = wigner(psi, xvec, yvec, g=2)
-        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
-
-        # check difference
-        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
-
-        # check normalization
-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_fft_comparse_ket():
-    "Wigner: Compare Wigner fft and iterative for rand. ket"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_ket(N)
-
-        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
-        W = wigner(rho, xvec, yvec, method='iterative')
-
-        Wdiff = abs(W - Wfft)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-
-def test_wigner_fft_comparse_dm():
-    "Wigner: Compare Wigner fft and iterative for rand. dm"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_dm(N)
-
-        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
-        W = wigner(rho, xvec, yvec, method='iterative')
-
-        Wdiff = abs(W - Wfft)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-
-def test_wigner_clenshaw_iter_dm():
-    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_dm(N)
-
-        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
-        W = wigner(rho, xvec, xvec, method='iterative')
-
-        Wdiff = abs(W - Wclen)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-
-def test_wigner_clenshaw_sp_iter_dm():
-    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_dm(N)
-
-        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
-        W = wigner(rho, xvec, xvec, method='iterative')
-
-        Wdiff = abs(W - Wclen)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-@pytest.mark.parametrize(['spin'], [
-    pytest.param(1/2, id="spin-one-half"),
-    pytest.param(3, id="spin-three"),
-    pytest.param(13/2, id="spin-thirteen-half"),
-    pytest.param(7, id="spin-seven")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_q_function(spin, pure):
-    d = int(2*spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Q function
-    theta = np.linspace(0, np.pi, 16, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
-    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
-
-    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
-        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
-        direct_Q = abs(state.dag() * rho * state)
-        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
-
-@pytest.mark.parametrize(['spin'], [
-    pytest.param(1/2, id="spin-one-half"),
-    pytest.param(3, id="spin-three"),
-    pytest.param(13/2, id="spin-thirteen-half"),
-    pytest.param(7, id="spin-seven")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_q_function_normalized(spin, pure):
-    d = int(2 * spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Q function
-    theta = np.linspace(0, np.pi, 128, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
-    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
-
-    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
-    assert_almost_equal(norm, 1, decimal=4)
-
-
-@pytest.mark.parametrize(["spin"], [
-    pytest.param(1/2, id="spin-one-half"),
-    pytest.param(1, id="spin-one"),
-    pytest.param(3/2, id="spin-three-half"),
-    pytest.param(2, id="spin-two")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_wigner_normalized(spin, pure):
-    d = int(2*spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Wigner function
-    theta = np.linspace(0, np.pi, 256, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
-    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
-
-    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
-    assert_almost_equal(norm, 1, decimal=4)
-
-@pytest.mark.parametrize(['spin'], [
-    pytest.param(1 / 2, id="spin-one-half"),
-    pytest.param(1, id="spin-one"),
-    pytest.param(3 / 2, id="spin-three-half"),
-    pytest.param(2, id="spin-two")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_wigner_overlap(spin, pure, n=5):
-    d = int(2*spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Wigner function
-    theta = np.linspace(0, np.pi, 256, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
-    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
-
-    for k in range(n):
-        test_state = rand_dm(d)
-        state_overlap = (test_state*rho).tr().real
-
-        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
-        W_overlap = np.trapz(
-            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
-        assert_almost_equal(W_overlap, state_overlap, decimal=4)
-
-if __name__ == "__main__":
-    run_module_suite()
+import pytest
+import numpy as np
+import itertools
+from scipy.special import laguerre
+from numpy.random import rand
+from numpy.testing import assert_, run_module_suite, assert_equal, \
+    assert_almost_equal, assert_allclose
+
+import qutip
+from qutip.core.states import coherent, fock, ket, bell_state
+from qutip.wigner import wigner, wigner_transform, _parity
+from qutip.random_objects import rand_dm, rand_ket
+
+
+class TestHusimiQ:
+    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
+    def test_failure_if_non_arraylike_coordinates(self, xs):
+        state = qutip.rand_ket(4)
+        valid = np.linspace(-1, 1, 5)
+        with pytest.raises(TypeError) as e:
+            qutip.qfunc(state, xs, valid)
+        assert "must be array-like" in e.value.args[0]
+        with pytest.raises(TypeError) as e:
+            qutip.qfunc(state, valid, xs)
+        assert "must be array-like" in e.value.args[0]
+        with pytest.raises(TypeError) as e:
+            qutip.QFunc(xs, valid)
+        assert "must be array-like" in e.value.args[0]
+        with pytest.raises(TypeError) as e:
+            qutip.QFunc(valid, xs)
+        assert "must be array-like" in e.value.args[0]
+
+    @pytest.mark.parametrize('ndim', [2, 3])
+    def test_failure_if_coordinates_not_1d(self, ndim):
+        state = qutip.rand_ket(4)
+        valid = np.linspace(-1, 1, 5)
+        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, bad, valid)
+        assert "must be 1D" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, valid, bad)
+        assert "must be 1D" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.QFunc(bad, valid)
+        assert "must be 1D" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.QFunc(valid, bad)
+        assert "must be 1D" in e.value.args[0]
+
+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+    def test_failure_if_tensor_hilbert_space(self, dm):
+        if dm:
+            state = qutip.rand_dm([2, 2])
+        else:
+            state = qutip.rand_ket([2, 2])
+        xs = np.linspace(-1, 1, 5)
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, xs, xs)
+        assert "must not have tensor structure" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.QFunc(xs, xs)(state)
+        assert "must not have tensor structure" in e.value.args[0]
+
+    def test_QFunc_raises_if_insufficient_memory(self):
+        xs = np.linspace(-1, 1, 11)
+        state = qutip.rand_ket(4)
+        qfunc = qutip.QFunc(xs, xs, memory=0)
+        with pytest.raises(MemoryError) as e:
+            qfunc(state)
+        assert e.value.args[0].startswith("Refusing to precompute")
+
+    def test_qfunc_warns_if_insufficient_memory(self):
+        xs = np.linspace(-1, 1, 11)
+        state = qutip.rand_dm(4)
+        with pytest.warns(UserWarning) as e:
+            qutip.qfunc(state, xs, xs, precompute_memory=0)
+        assert (
+            e[0].message.args[0]
+            .startswith("Falling back to iterative algorithm")
+        )
+
+    @pytest.mark.parametrize('obj', [
+        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
+        pytest.param([[1, 0], [0, 1]], id='list'),
+        pytest.param(1, id='int'),
+    ])
+    def test_failure_if_not_a_Qobj(self, obj):
+        xs = np.linspace(-1, 1, 11)
+        with pytest.raises(TypeError) as e:
+            qutip.qfunc(obj, xs, xs)
+        assert e.value.args[0].startswith("state must be Qobj")
+        qfunc = qutip.QFunc(xs, xs)
+        with pytest.raises(TypeError) as e:
+            qfunc(obj)
+        assert e.value.args[0].startswith("state must be Qobj")
+
+    # Use indirection so that the tests can still be collected if there's a bug
+    # in the generating QuTiP functions.
+    @pytest.mark.parametrize('state', [
+        pytest.param(lambda: qutip.rand_super(2), id='super'),
+        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
+        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
+        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
+                     id='nonsquare dm'),
+        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
+                     id='operator-ket'),
+        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
+                     id='operator-bra'),
+    ])
+    def test_failure_if_not_a_state(self, state):
+        xs = np.linspace(-1, 1, 11)
+        state = state()
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, xs, xs)
+        assert (
+            e.value.args[0].startswith("state must be a ket or density matrix")
+        )
+        qfunc = qutip.QFunc(xs, xs)
+        with pytest.raises(ValueError) as e:
+            qfunc(state)
+        assert (
+            e.value.args[0].startswith("state must be a ket or density matrix")
+        )
+
+    @pytest.mark.parametrize('g', [
+        pytest.param(np.sqrt(2), id='natural units'),
+        pytest.param(1, id='arb units'),
+    ])
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+    @pytest.mark.parametrize('size', [5, 32])
+    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(0, 2, n_ys)
+        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
+        function = qutip.qfunc(state, xs, ys, g)
+        class_ = qutip.QFunc(xs, ys, g)(state)
+        np.testing.assert_allclose(function, class_)
+
+    @pytest.mark.parametrize('g', [
+        pytest.param(np.sqrt(2), id='natural units'),
+        pytest.param(1, id='arb units'),
+    ])
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('size', [5, 32])
+    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(0, 2, n_ys)
+        state = qutip.rand_dm(size)
+        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
+        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
+        np.testing.assert_allclose(iterate, precompute)
+
+    @pytest.mark.parametrize('initial_size', [5, 8])
+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+    def test_same_class_can_take_many_sizes(self, dm, initial_size):
+        xs = np.linspace(-1, 1, 11)
+        ys = np.linspace(0, 2, 11)
+        shape = np.meshgrid(xs, ys)[0].shape
+        sizes = initial_size + np.array([0, 1, -1, 4])
+        qfunc = qutip.QFunc(xs, ys)
+        for size in sizes:
+            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
+            out = qfunc(state)
+            assert isinstance(out, np.ndarray)
+            assert out.shape == shape
+
+    @pytest.mark.parametrize('dm_first', [True, False])
+    def test_same_class_can_mix_ket_and_dm(self, dm_first):
+        dms = [True, False, True, False]
+        if not dm_first:
+            dms = dms[::-1]
+        xs = np.linspace(-1, 1, 11)
+        ys = np.linspace(0, 2, 11)
+        shape = np.meshgrid(xs, ys)[0].shape
+        qfunc = qutip.QFunc(xs, ys)
+        for dm in dms:
+            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
+            out = qfunc(state)
+            assert isinstance(out, np.ndarray)
+            assert out.shape == shape
+
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('mix', [0.1, 0.5])
+    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(-1, 1, n_ys)
+        qfunc = qutip.QFunc(xs, ys)
+        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
+        qleft, qright = qfunc(left), qfunc(right)
+        qboth = qfunc(mix*left + (1-mix)*right)
+        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
+
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('size', [5, 32])
+    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(-1, 1, n_ys)
+        state = qutip.rand_ket(size)
+        qfunc = qutip.QFunc(xs, ys)
+        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
+
+    @pytest.mark.parametrize('g', [
+        pytest.param(np.sqrt(2), id='natural units'),
+        pytest.param(1, id='arb units'),
+    ])
+    @pytest.mark.parametrize('ys', [
+        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
+        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
+    ])
+    @pytest.mark.parametrize('xs', [
+        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
+        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
+    ])
+    @pytest.mark.parametrize('size', [3, 5])
+    def test_against_naive_implementation(self, xs, ys, g, size):
+        state = qutip.rand_dm(size)
+        state_np = state.full()
+        x, y = np.meshgrid(xs, ys)
+        alphas = 0.5*g * (x + 1j*y)
+        naive = np.empty(alphas.shape, dtype=np.float64)
+        for i, alpha in enumerate(alphas.flat):
+            coh = qutip.coherent(size, alpha, method='analytic').full()
+            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
+        naive *= (0.5*g)**2 / np.pi
+        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
+        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
+
+
+def test_wigner_bell1_su2parity():
+    """wigner: testing the SU2 parity of the first Bell state.
+    """
+    psi = bell_state('00')
+
+    steps = 25
+    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
+    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
+    slicearray = ['l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
+                                            * np.cos(theta[0, t]))
+                                           * (1 + np.sqrt(3)
+                                           * np.cos(theta[1, t]))
+                                           + 3 * (np.sin(theta[0, t])
+                                           * np.exp(-1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(-1j * phi[1, p])
+                                           + np.sin(theta[0, t])
+                                           * np.exp(1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(1j * phi[1, p]))
+                                           + (1 - np.sqrt(3)
+                                           * np.cos(theta[0, t]))
+                                           * (1 - np.sqrt(3)
+                                           * np.cos(theta[1, t]))) / 8.)
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_bell4_su2parity():
+    """wigner: testing the SU2 parity of the fourth Bell state.
+    """
+    psi = bell_state('11')
+
+    steps = 25
+    slicearray = ['l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = -0.5
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_bell4_fullparity():
+    """wigner: testing the parity of the fourth Bell state using the parity of
+    the full space.
+    """
+    psi = bell_state('11')
+
+    steps = 25
+    slicearray = ['l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = -0.30901699
+
+    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
+
+
+def test_parity():
+    """wigner: testing the parity function.
+    """
+    j = 0.5
+    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
+    assert_(_parity(2, j)[0, 1] < 1e-11)
+    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
+    assert_(_parity(2, j)[1, 0] < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_pure_su2():
+    """wigner: testing the SU2 wigner transformation of a pure state.
+    """
+    psi = (ket([1]))
+    steps = 25
+    theta = np.linspace(0, np.pi, steps)
+    phi = np.linspace(0, 2 * np.pi, steps)
+    theta = theta[None, :]
+    phi = phi[None, :]
+    slicearray = ['l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_ghz_su2parity():
+    """wigner: testing the SU2 wigner transformation of the GHZ state.
+    """
+    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
+
+    steps = 25
+    N = 3
+    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
+    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
+    slicearray = ['l', 'l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
+                                           * (1 + np.sqrt(3)
+                                           * np.cos(theta[1, t]))
+                                           * (1 + np.sqrt(3)
+                                           * np.cos(theta[2, t]))
+                                           + 3**(3 / 2) * (np.sin(theta[0, t])
+                                           * np.exp(-1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(-1j * phi[1, p])
+                                           * np.sin(theta[2, t])
+                                           * np.exp(-1j * phi[2, p])
+                                           + np.sin(theta[0, t])
+                                           * np.exp(1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(1j * phi[1, p])
+                                           * np.sin(theta[2, t])
+                                           * np.exp(1j * phi[2, p]))
+                                           + (1 - np.sqrt(3)
+                                           * np.cos(theta[0, t]))
+                                           * (1 - np.sqrt(3)
+                                           * np.cos(theta[1, t]))
+                                           * (1 - np.sqrt(3)
+                                           * np.cos(theta[2, t]))) / 16.)
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_angle_slicing():
+    """wigner: tests angle slicing.
+    """
+    psi1 = bell_state('00')
+    psi2 = bell_state('01')
+    psi3 = bell_state('10')
+    psi4 = bell_state('11')
+
+    steps = 25
+    j = 0.5
+
+    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
+    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
+    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
+    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
+
+    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
+    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
+    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
+    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
+
+
+def test_wigner_coherent():
+    "wigner: test wigner function calculation for coherent states"
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 20
+    beta = rand() + rand() * 1.0j
+    psi = coherent(N, beta)
+
+    # calculate the wigner function using qutip and analytic formula
+    W_qutip = wigner(psi, xvec, yvec, g=2)
+    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
+    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
+
+    # check difference
+    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
+    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
+
+    # check normalization
+    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_fock():
+    "wigner: test wigner function calculation for Fock states"
+
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 15
+
+    for n in [2, 3, 4, 5, 6]:
+
+        psi = fock(N, n)
+
+        # calculate the wigner function using qutip and analytic formula
+        W_qutip = wigner(psi, xvec, yvec, g=2)
+        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
+        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
+        W_analytic = 2 / np.pi * (-1) ** n * \
+            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
+
+        # check difference
+        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
+        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
+        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
+
+        # check normalization
+        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_compare_methods_dm():
+    "wigner: compare wigner methods for random density matrices"
+
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    # a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 15
+
+    for n in range(10):
+        # try ten different random density matrices
+
+        rho = rand_dm(N, density=0.5 + rand() / 2)
+
+        # calculate the wigner function using qutip and analytic formula
+        W_qutip1 = wigner(rho, xvec, yvec, g=2)
+        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
+
+        # check difference
+        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
+
+        # check normalization
+        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_compare_methods_ket():
+    "wigner: compare wigner methods for random state vectors"
+
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    # a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 15
+
+    for n in range(10):
+        # try ten different random density matrices
+
+        psi = rand_ket(N, density=0.5 + rand() / 2)
+
+        # calculate the wigner function using qutip and analytic formula
+        W_qutip1 = wigner(psi, xvec, yvec, g=2)
+        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
+
+        # check difference
+        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
+
+        # check normalization
+        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_fft_comparse_ket():
+    "Wigner: Compare Wigner fft and iterative for rand. ket"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_ket(N)
+
+        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
+        W = wigner(rho, xvec, yvec, method='iterative')
+
+        Wdiff = abs(W - Wfft)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+
+def test_wigner_fft_comparse_dm():
+    "Wigner: Compare Wigner fft and iterative for rand. dm"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_dm(N)
+
+        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
+        W = wigner(rho, xvec, yvec, method='iterative')
+
+        Wdiff = abs(W - Wfft)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+
+def test_wigner_clenshaw_iter_dm():
+    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_dm(N)
+
+        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
+        W = wigner(rho, xvec, xvec, method='iterative')
+
+        Wdiff = abs(W - Wclen)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+
+def test_wigner_clenshaw_sp_iter_dm():
+    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_dm(N)
+
+        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
+        W = wigner(rho, xvec, xvec, method='iterative')
+
+        Wdiff = abs(W - Wclen)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+@pytest.mark.parametrize(['spin'], [
+    pytest.param(1/2, id="spin-one-half"),
+    pytest.param(3, id="spin-three"),
+    pytest.param(13/2, id="spin-thirteen-half"),
+    pytest.param(7, id="spin-seven")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_q_function(spin, pure):
+    d = int(2*spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Q function
+    theta = np.linspace(0, np.pi, 16, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
+    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
+
+    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
+        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
+        direct_Q = abs(state.dag() * rho * state)
+        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
+
+@pytest.mark.parametrize(['spin'], [
+    pytest.param(1/2, id="spin-one-half"),
+    pytest.param(3, id="spin-three"),
+    pytest.param(13/2, id="spin-thirteen-half"),
+    pytest.param(7, id="spin-seven")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_q_function_normalized(spin, pure):
+    d = int(2 * spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Q function
+    theta = np.linspace(0, np.pi, 128, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
+    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
+
+    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
+    assert_almost_equal(norm, 1, decimal=4)
+
+
+@pytest.mark.parametrize(["spin"], [
+    pytest.param(1/2, id="spin-one-half"),
+    pytest.param(1, id="spin-one"),
+    pytest.param(3/2, id="spin-three-half"),
+    pytest.param(2, id="spin-two")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_wigner_normalized(spin, pure):
+    d = int(2*spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Wigner function
+    theta = np.linspace(0, np.pi, 256, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
+    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
+
+    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
+    assert_almost_equal(norm, 1, decimal=4)
+
+@pytest.mark.parametrize(['spin'], [
+    pytest.param(1 / 2, id="spin-one-half"),
+    pytest.param(1, id="spin-one"),
+    pytest.param(3 / 2, id="spin-three-half"),
+    pytest.param(2, id="spin-two")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_wigner_overlap(spin, pure, n=5):
+    d = int(2*spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Wigner function
+    theta = np.linspace(0, np.pi, 256, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
+    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
+
+    for k in range(n):
+        test_state = rand_dm(d)
+        state_overlap = (test_state*rho).tr().real
+
+        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
+        W_overlap = np.trapz(
+            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
+        assert_almost_equal(W_overlap, state_overlap, decimal=4)
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/three_level_atom.py b/qutip/three_level_atom.py
index eee506ef56..8db037df9c 100644
--- a/qutip/three_level_atom.py
+++ b/qutip/three_level_atom.py
@@ -1,74 +1,74 @@
-r'''
-This module provides functions that are useful for simulating the
-three level atom with QuTiP.  A three level atom (qutrit) has three states,
-which are linked by dipole transitions so that 1 <-> 2 <-> 3.
-Depending on there relative energies they are in the ladder, lambda or
-vee configuration. The structure of the relevant operators is the same
-for any of the three configurations::
-
-    Ladder:          Lambda:                 Vee:
-                                |two>                       |three>
-      -------|three>           -------                      -------
-         |                       / \             |one>         /
-         |                      /   \           -------       /
-         |                     /     \             \         /
-      -------|two>            /       \             \       /
-         |                   /         \             \     /
-         |                  /           \             \   /
-         |                 /        --------           \ /
-      -------|one>      -------      |three>         -------
-                         |one>                       |two>
-
-References
-----------
-The naming of qutip operators follows the convention in [1]_ .
-
-.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
-   Wiley, 1990.
-
-Notes
------
-Contributed by Markus Baden, Oct. 07, 2011
-
-'''
-
-__all__ = ['three_level_basis', 'three_level_ops']
-
-import numpy as np
-from . import qutrit_basis
-
-
-def three_level_basis():
-    ''' Basis states for a three level atom.
-
-    Returns
-    -------
-    states : np.array
-        :obj:`numpy.ndarray` of three level atom basis vectors.
-    '''
-    # A three level atom has the same representation as a qutrit, i.e.
-    # three states
-    return qutrit_basis()
-
-
-def three_level_ops():
-    """
-    Operators for a three level system (qutrit)
-
-    Returns
-    -------
-    ops : np.array
-        :obj:`numpy.ndarray` of three level operators.
-    """
-    out = np.empty((5,), dtype=object)
-    one, two, three = qutrit_basis()
-    # Note that the three level operators are different
-    # from the qutrit operators. A three level atom only
-    # has transitions 1 <-> 2 <-> 3, so we define the
-    # operators seperately from the qutrit code
-    out[0] = one * one.dag()
-    out[1] = two * two.dag()
-    out[2] = three * three.dag()
-    out[3] = one * two.dag()
-    out[4] = three * two.dag()
-    return out
+r'''
+This module provides functions that are useful for simulating the
+three level atom with QuTiP.  A three level atom (qutrit) has three states,
+which are linked by dipole transitions so that 1 <-> 2 <-> 3.
+Depending on there relative energies they are in the ladder, lambda or
+vee configuration. The structure of the relevant operators is the same
+for any of the three configurations::
+
+    Ladder:          Lambda:                 Vee:
+                                |two>                       |three>
+      -------|three>           -------                      -------
+         |                       / \             |one>         /
+         |                      /   \           -------       /
+         |                     /     \             \         /
+      -------|two>            /       \             \       /
+         |                   /         \             \     /
+         |                  /           \             \   /
+         |                 /        --------           \ /
+      -------|one>      -------      |three>         -------
+                         |one>                       |two>
+
+References
+----------
+The naming of qutip operators follows the convention in [1]_ .
+
+.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
+   Wiley, 1990.
+
+Notes
+-----
+Contributed by Markus Baden, Oct. 07, 2011
+
+'''
+
+__all__ = ['three_level_basis', 'three_level_ops']
+
+import numpy as np
+from . import qutrit_basis
+
+
+def three_level_basis():
+    ''' Basis states for a three level atom.
+
+    Returns
+    -------
+    states : np.array
+        :obj:`numpy.ndarray` of three level atom basis vectors.
+    '''
+    # A three level atom has the same representation as a qutrit, i.e.
+    # three states
+    return qutrit_basis()
+
+
+def three_level_ops():
+    """
+    Operators for a three level system (qutrit)
+
+    Returns
+    -------
+    ops : np.array
+        :obj:`numpy.ndarray` of three level operators.
+    """
+    out = np.empty((5,), dtype=object)
+    one, two, three = qutrit_basis()
+    # Note that the three level operators are different
+    # from the qutrit operators. A three level atom only
+    # has transitions 1 <-> 2 <-> 3, so we define the
+    # operators seperately from the qutrit code
+    out[0] = one * one.dag()
+    out[1] = two * two.dag()
+    out[2] = three * three.dag()
+    out[3] = one * two.dag()
+    out[4] = three * two.dag()
+    return out
diff --git a/qutip/tomography.py b/qutip/tomography.py
index a663ee30b4..bf83020e83 100644
--- a/qutip/tomography.py
+++ b/qutip/tomography.py
@@ -1,190 +1,190 @@
-__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
-
-from numpy import hstack, real, imag
-import scipy.linalg as la
-from . import tensor, spre, spost, stack_columns, unstack_columns
-from .visualization import matrix_histogram, matrix_histogram_complex
-
-try:
-    import matplotlib.pyplot as plt
-except:
-    pass
-
-
-def _index_permutations(size_list, perm=[]):
-    """
-    Generate a list with all index permutations.
-
-    Parameters
-    ----------
-    size_list : list
-        A list that contains the sizes for each composite system.
-    perm : list
-        A list of permutations
-
-    Returns
-    -------
-    perm_idx : list
-        List containing index permutations.
-
-
-    """
-    if len(size_list) == 0:
-        yield perm
-    else:
-        for n in range(size_list[0]):
-            for ip in _index_permutations(size_list[1:], perm + [n]):
-                yield ip
-
-
-def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
-    """
-    Visualize the quantum process tomography chi matrix. Plot the real and
-    imaginary parts separately.
-
-    Parameters
-    ----------
-    chi : array
-        Input QPT chi matrix.
-    lbls_list : list
-        List of labels for QPT plot axes.
-    title : string
-        Plot title.
-    fig : figure instance
-        User defined figure instance used for generating QPT plot.
-    axes : list of figure axis instance
-        User defined figure axis instance (list of two axes) used for
-        generating QPT plot.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    if axes is None or len(axes) != 2:
-        if fig is None:
-            fig = plt.figure(figsize=(16, 8))
-
-        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
-        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
-
-        axes = [ax1, ax2]
-
-    xlabels = []
-    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
-        xlabels.append("".join([lbls_list[k][inds[k]]
-                                for k in range(len(lbls_list))]))
-
-    matrix_histogram(real(chi), xlabels, xlabels,
-                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
-    matrix_histogram(imag(chi), xlabels, xlabels,
-                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
-
-    if title and fig:
-        fig.suptitle(title)
-
-    return fig, axes
-
-
-def qpt_plot_combined(chi, lbls_list, title=None,
-                      fig=None, ax=None, figsize=(8, 6),
-                      threshold=None):
-    """
-    Visualize the quantum process tomography chi matrix. Plot bars with
-    height and color corresponding to the absolute value and phase,
-    respectively.
-
-    Parameters
-    ----------
-    chi : array
-        Input QPT chi matrix.
-
-    lbls_list : list
-        List of labels for QPT plot axes.
-
-    title : string
-        Plot title.
-
-    fig : figure instance
-        User defined figure instance used for generating QPT plot.
-
-    ax : figure axis instance
-        User defined figure axis instance used for generating QPT plot
-        (alternative to the fig argument).
-
-    threshold: float (None)
-        Threshold for when bars of smaller height should be transparent. If
-        not set, all bars are colored according to the color map.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if ax is None:
-        if fig is None:
-            fig = plt.figure(figsize=figsize)
-        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
-
-    xlabels = []
-    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
-        xlabels.append("".join(
-            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
-
-    if not title:
-        title = r"$\chi$"
-
-    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
-                             threshold=threshold)
-
-    return fig, ax
-
-
-def qpt(U, op_basis_list):
-    """
-    Calculate the quantum process tomography chi matrix for a given (possibly
-    nonunitary) transformation matrix U, which transforms a density matrix in
-    vector form according to:
-
-        vec(rho) = U * vec(rho0)
-
-        or
-
-        rho = unstack_columns(U * stack_columns(rho0))
-
-    U can be calculated for an open quantum system using the QuTiP propagator
-    function.
-
-    Parameters
-    ----------
-    U : Qobj
-        Transformation operator. Can be calculated using QuTiP propagator
-        function.
-
-    op_basis_list : list
-        A list of Qobj's representing the basis states.
-
-    Returns
-    -------
-    chi : array
-        QPT chi matrix
-
-    """
-
-    E_ops = []
-    # loop over all index permutations
-    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
-        # loop over all composite systems
-        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
-            op_basis_list))]
-        E_ops.append(tensor(E_op_list))
-    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
-    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
-    Uvec = U.full().ravel('F')
-    chi_vec = la.solve(M, Uvec)
-    return chi_vec.reshape(U.shape).T
+__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
+
+from numpy import hstack, real, imag
+import scipy.linalg as la
+from . import tensor, spre, spost, stack_columns, unstack_columns
+from .visualization import matrix_histogram, matrix_histogram_complex
+
+try:
+    import matplotlib.pyplot as plt
+except:
+    pass
+
+
+def _index_permutations(size_list, perm=[]):
+    """
+    Generate a list with all index permutations.
+
+    Parameters
+    ----------
+    size_list : list
+        A list that contains the sizes for each composite system.
+    perm : list
+        A list of permutations
+
+    Returns
+    -------
+    perm_idx : list
+        List containing index permutations.
+
+
+    """
+    if len(size_list) == 0:
+        yield perm
+    else:
+        for n in range(size_list[0]):
+            for ip in _index_permutations(size_list[1:], perm + [n]):
+                yield ip
+
+
+def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
+    """
+    Visualize the quantum process tomography chi matrix. Plot the real and
+    imaginary parts separately.
+
+    Parameters
+    ----------
+    chi : array
+        Input QPT chi matrix.
+    lbls_list : list
+        List of labels for QPT plot axes.
+    title : string
+        Plot title.
+    fig : figure instance
+        User defined figure instance used for generating QPT plot.
+    axes : list of figure axis instance
+        User defined figure axis instance (list of two axes) used for
+        generating QPT plot.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+
+    if axes is None or len(axes) != 2:
+        if fig is None:
+            fig = plt.figure(figsize=(16, 8))
+
+        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
+        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
+
+        axes = [ax1, ax2]
+
+    xlabels = []
+    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
+        xlabels.append("".join([lbls_list[k][inds[k]]
+                                for k in range(len(lbls_list))]))
+
+    matrix_histogram(real(chi), xlabels, xlabels,
+                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
+    matrix_histogram(imag(chi), xlabels, xlabels,
+                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
+
+    if title and fig:
+        fig.suptitle(title)
+
+    return fig, axes
+
+
+def qpt_plot_combined(chi, lbls_list, title=None,
+                      fig=None, ax=None, figsize=(8, 6),
+                      threshold=None):
+    """
+    Visualize the quantum process tomography chi matrix. Plot bars with
+    height and color corresponding to the absolute value and phase,
+    respectively.
+
+    Parameters
+    ----------
+    chi : array
+        Input QPT chi matrix.
+
+    lbls_list : list
+        List of labels for QPT plot axes.
+
+    title : string
+        Plot title.
+
+    fig : figure instance
+        User defined figure instance used for generating QPT plot.
+
+    ax : figure axis instance
+        User defined figure axis instance used for generating QPT plot
+        (alternative to the fig argument).
+
+    threshold: float (None)
+        Threshold for when bars of smaller height should be transparent. If
+        not set, all bars are colored according to the color map.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if ax is None:
+        if fig is None:
+            fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
+
+    xlabels = []
+    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
+        xlabels.append("".join(
+            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
+
+    if not title:
+        title = r"$\chi$"
+
+    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
+                             threshold=threshold)
+
+    return fig, ax
+
+
+def qpt(U, op_basis_list):
+    """
+    Calculate the quantum process tomography chi matrix for a given (possibly
+    nonunitary) transformation matrix U, which transforms a density matrix in
+    vector form according to:
+
+        vec(rho) = U * vec(rho0)
+
+        or
+
+        rho = unstack_columns(U * stack_columns(rho0))
+
+    U can be calculated for an open quantum system using the QuTiP propagator
+    function.
+
+    Parameters
+    ----------
+    U : Qobj
+        Transformation operator. Can be calculated using QuTiP propagator
+        function.
+
+    op_basis_list : list
+        A list of Qobj's representing the basis states.
+
+    Returns
+    -------
+    chi : array
+        QPT chi matrix
+
+    """
+
+    E_ops = []
+    # loop over all index permutations
+    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
+        # loop over all composite systems
+        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
+            op_basis_list))]
+        E_ops.append(tensor(E_op_list))
+    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
+    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
+    Uvec = U.full().ravel('F')
+    chi_vec = la.solve(M, Uvec)
+    return chi_vec.reshape(U.shape).T
diff --git a/qutip/ui/__init__.py b/qutip/ui/__init__.py
index d9fdd46838..a640ed1f53 100644
--- a/qutip/ui/__init__.py
+++ b/qutip/ui/__init__.py
@@ -1 +1 @@
-from qutip.ui.progressbar import *
+from qutip.ui.progressbar import *
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index 8bebca7038..a862a24d98 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -1,212 +1,212 @@
-__all__ = ['BaseProgressBar', 'TextProgressBar',
-           'EnhancedTextProgressBar', 'TqdmProgressBar',
-           'HTMLProgressBar', 'progess_bars']
-
-import time
-import datetime
-import sys
-
-
-class BaseProgressBar(object):
-    """
-    An abstract progress bar with some shared functionality.
-
-    Example usage:
-
-        n_vec = linspace(0, 10, 100)
-        pbar = TextProgressBar(len(n_vec))
-        for n in n_vec:
-            pbar.update(n)
-            compute_with_n(n)
-        pbar.finished()
-
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        self.N = float(iterations)
-        self.n = 0
-        self.p_chunk_size = chunk_size
-        self.p_chunk = chunk_size
-        self.t_start = time.time()
-        self.t_done = self.t_start - 1
-
-    def update(self, n=None):
-        pass
-
-    def total_time(self):
-        return self.t_done - self.t_start
-
-    def time_elapsed(self):
-        return "%6.2fs" % (time.time() - self.t_start)
-
-    def time_remaining_est(self, p):
-        if p > 0.0:
-            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
-        else:
-            t_r_est = 0
-
-        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
-        time_string = "%02d:%02d:%02d:%02d" % \
-            (dd.day - 1, dd.hour, dd.minute, dd.second)
-
-        return time_string
-
-    def finished(self):
-        self.t_done = time.time()
-
-
-class TextProgressBar(BaseProgressBar):
-    """
-    A simple text-based progress bar.
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-        # super(TextProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        super(TextProgressBar, self).start(iterations, chunk_size)
-
-    def update(self, n=None):
-        self.n += 1
-        n = self.n
-        p = (n / self.N) * 100.0
-        if p >= self.p_chunk:
-            print("%4.1f%%." % p +
-                  " Run time: %s." % self.time_elapsed() +
-                  " Est. time left: %s" % self.time_remaining_est(p))
-            sys.stdout.flush()
-            self.p_chunk += self.p_chunk_size
-
-    def finished(self):
-        self.t_done = time.time()
-        print("Total run time: %s" % self.time_elapsed())
-
-
-class EnhancedTextProgressBar(BaseProgressBar):
-    """
-    An enhanced text-based progress bar.
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-        self.fill_char = '*'
-        self.width = 25
-
-    def update(self, n=None):
-        self.n += 1
-        n = self.n
-        percent_done = int(round(n / self.N * 100.0))
-        all_full = self.width - 2
-        num_hashes = int(round((percent_done / 100.0) * all_full))
-        prog_bar = ('[' + self.fill_char * num_hashes +
-                    ' ' * (all_full - num_hashes) + ']')
-        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
-        pct_string = '%d%%' % percent_done
-        prog_bar = (prog_bar[0:pct_place] +
-                    (pct_string + prog_bar[pct_place + len(pct_string):]))
-        prog_bar += ' Elapsed %s / Remaining %s' % (
-            self.time_elapsed().strip(),
-            self.time_remaining_est(percent_done))
-        print('\r', prog_bar, end='')
-        sys.stdout.flush()
-
-    def finished(self):
-        self.t_done = time.time()
-        print("\r", "Total run time: %s" % self.time_elapsed())
-
-
-class TqdmProgressBar(BaseProgressBar):
-    """
-    A progress bar using tqdm module
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        from tqdm.auto import tqdm
-        self.tqdm = tqdm
-
-    def start(self, iterations, **kwargs):
-        self.pbar = self.tqdm(total=iterations, **kwargs)
-        self.t_start = time.time()
-        self.t_done = self.t_start - 1
-
-    def update(self, n=None):
-        self.pbar.update()
-
-    def finished(self):
-        self.pbar.close()
-        self.t_done = time.time()
-
-
-class HTMLProgressBar(BaseProgressBar):
-    """
-    A simple HTML progress bar for using in IPython notebooks. Based on
-    IPython ProgressBar demo notebook:
-    https://github.com/ipython/ipython/tree/master/examples/notebooks
-
-    Example usage:
-
-        n_vec = linspace(0, 10, 100)
-        pbar = HTMLProgressBar(len(n_vec))
-        for n in n_vec:
-            pbar.update(n)
-            compute_with_n(n)
-    """
-
-    def __init__(self, iterations=0, chunk_size=1.0):
-        self.divid = str(uuid.uuid4())
-        self.textid = str(uuid.uuid4())
-        self.pb = HTML("""\
-<div style="border: 2px solid grey; width: 600px">
-  <div id="%s" \
-style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
-</div>
-<p id="%s"></p>
-""" % (self.divid, self.textid))
-        display(self.pb)
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations=0, chunk_size=1.0):
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def update(self, n):
-        p = (n / self.N) * 100.0
-        if p >= self.p_chunk:
-            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
-                   "Est. remaining time: %s." % self.time_remaining_est(p))
-            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
-                       "$('p#%s').text('%s');" % (self.textid, lbl))
-            display(Javascript(js_code))
-            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
-            # p)))
-            self.p_chunk += self.p_chunk_size
-
-    def finished(self):
-        self.t_done = time.time()
-        lbl = "Elapsed time: %s" % self.time_elapsed()
-        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
-                   "$('p#%s').text('%s');" % (self.textid, lbl))
-        display(Javascript(js_code))
-
-
-progess_bars = {
-    "Enhanced": EnhancedTextProgressBar,
-    "enhanced": EnhancedTextProgressBar,
-    "Text": TextProgressBar,
-    "text": TextProgressBar,
-    True: TextProgressBar,
-    "Tqdm": TqdmProgressBar,
-    "tqdm": TqdmProgressBar,
-    "Html": HTMLProgressBar,
-    "html": HTMLProgressBar,
-    "": BaseProgressBar,
-    False: BaseProgressBar,
-    None: BaseProgressBar,
-}
+__all__ = ['BaseProgressBar', 'TextProgressBar',
+           'EnhancedTextProgressBar', 'TqdmProgressBar',
+           'HTMLProgressBar', 'progess_bars']
+
+import time
+import datetime
+import sys
+
+
+class BaseProgressBar(object):
+    """
+    An abstract progress bar with some shared functionality.
+
+    Example usage:
+
+        n_vec = linspace(0, 10, 100)
+        pbar = TextProgressBar(len(n_vec))
+        for n in n_vec:
+            pbar.update(n)
+            compute_with_n(n)
+        pbar.finished()
+
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        pass
+
+    def start(self, iterations, chunk_size=10, **kwargs):
+        self.N = float(iterations)
+        self.n = 0
+        self.p_chunk_size = chunk_size
+        self.p_chunk = chunk_size
+        self.t_start = time.time()
+        self.t_done = self.t_start - 1
+
+    def update(self, n=None):
+        pass
+
+    def total_time(self):
+        return self.t_done - self.t_start
+
+    def time_elapsed(self):
+        return "%6.2fs" % (time.time() - self.t_start)
+
+    def time_remaining_est(self, p):
+        if p > 0.0:
+            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
+        else:
+            t_r_est = 0
+
+        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
+        time_string = "%02d:%02d:%02d:%02d" % \
+            (dd.day - 1, dd.hour, dd.minute, dd.second)
+
+        return time_string
+
+    def finished(self):
+        self.t_done = time.time()
+
+
+class TextProgressBar(BaseProgressBar):
+    """
+    A simple text-based progress bar.
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        pass
+        # super(TextProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations, chunk_size=10, **kwargs):
+        super(TextProgressBar, self).start(iterations, chunk_size)
+
+    def update(self, n=None):
+        self.n += 1
+        n = self.n
+        p = (n / self.N) * 100.0
+        if p >= self.p_chunk:
+            print("%4.1f%%." % p +
+                  " Run time: %s." % self.time_elapsed() +
+                  " Est. time left: %s" % self.time_remaining_est(p))
+            sys.stdout.flush()
+            self.p_chunk += self.p_chunk_size
+
+    def finished(self):
+        self.t_done = time.time()
+        print("Total run time: %s" % self.time_elapsed())
+
+
+class EnhancedTextProgressBar(BaseProgressBar):
+    """
+    An enhanced text-based progress bar.
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        pass
+        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations, chunk_size=10, **kwargs):
+        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+        self.fill_char = '*'
+        self.width = 25
+
+    def update(self, n=None):
+        self.n += 1
+        n = self.n
+        percent_done = int(round(n / self.N * 100.0))
+        all_full = self.width - 2
+        num_hashes = int(round((percent_done / 100.0) * all_full))
+        prog_bar = ('[' + self.fill_char * num_hashes +
+                    ' ' * (all_full - num_hashes) + ']')
+        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
+        pct_string = '%d%%' % percent_done
+        prog_bar = (prog_bar[0:pct_place] +
+                    (pct_string + prog_bar[pct_place + len(pct_string):]))
+        prog_bar += ' Elapsed %s / Remaining %s' % (
+            self.time_elapsed().strip(),
+            self.time_remaining_est(percent_done))
+        print('\r', prog_bar, end='')
+        sys.stdout.flush()
+
+    def finished(self):
+        self.t_done = time.time()
+        print("\r", "Total run time: %s" % self.time_elapsed())
+
+
+class TqdmProgressBar(BaseProgressBar):
+    """
+    A progress bar using tqdm module
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        from tqdm.auto import tqdm
+        self.tqdm = tqdm
+
+    def start(self, iterations, **kwargs):
+        self.pbar = self.tqdm(total=iterations, **kwargs)
+        self.t_start = time.time()
+        self.t_done = self.t_start - 1
+
+    def update(self, n=None):
+        self.pbar.update()
+
+    def finished(self):
+        self.pbar.close()
+        self.t_done = time.time()
+
+
+class HTMLProgressBar(BaseProgressBar):
+    """
+    A simple HTML progress bar for using in IPython notebooks. Based on
+    IPython ProgressBar demo notebook:
+    https://github.com/ipython/ipython/tree/master/examples/notebooks
+
+    Example usage:
+
+        n_vec = linspace(0, 10, 100)
+        pbar = HTMLProgressBar(len(n_vec))
+        for n in n_vec:
+            pbar.update(n)
+            compute_with_n(n)
+    """
+
+    def __init__(self, iterations=0, chunk_size=1.0):
+        self.divid = str(uuid.uuid4())
+        self.textid = str(uuid.uuid4())
+        self.pb = HTML("""\
+<div style="border: 2px solid grey; width: 600px">
+  <div id="%s" \
+style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
+</div>
+<p id="%s"></p>
+""" % (self.divid, self.textid))
+        display(self.pb)
+        super(HTMLProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations=0, chunk_size=1.0):
+        super(HTMLProgressBar, self).start(iterations, chunk_size)
+
+    def update(self, n):
+        p = (n / self.N) * 100.0
+        if p >= self.p_chunk:
+            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
+                   "Est. remaining time: %s." % self.time_remaining_est(p))
+            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
+                       "$('p#%s').text('%s');" % (self.textid, lbl))
+            display(Javascript(js_code))
+            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
+            # p)))
+            self.p_chunk += self.p_chunk_size
+
+    def finished(self):
+        self.t_done = time.time()
+        lbl = "Elapsed time: %s" % self.time_elapsed()
+        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
+                   "$('p#%s').text('%s');" % (self.textid, lbl))
+        display(Javascript(js_code))
+
+
+progess_bars = {
+    "Enhanced": EnhancedTextProgressBar,
+    "enhanced": EnhancedTextProgressBar,
+    "Text": TextProgressBar,
+    "text": TextProgressBar,
+    True: TextProgressBar,
+    "Tqdm": TqdmProgressBar,
+    "tqdm": TqdmProgressBar,
+    "Html": HTMLProgressBar,
+    "html": HTMLProgressBar,
+    "": BaseProgressBar,
+    False: BaseProgressBar,
+    None: BaseProgressBar,
+}
diff --git a/qutip/utilities.py b/qutip/utilities.py
index 8d6383071a..5413730a4e 100644
--- a/qutip/utilities.py
+++ b/qutip/utilities.py
@@ -1,332 +1,332 @@
-"""
-This module contains utility functions that are commonly needed in other
-qutip modules.
-"""
-
-__all__ = ['n_thermal', 'clebsch', 'convert_unit']
-
-import numpy as np
-
-def n_thermal(w, w_th):
-    """
-    Return the number of photons in thermal equilibrium for an harmonic
-    oscillator mode with frequency 'w', at the temperature described by
-    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
-
-    Parameters
-    ----------
-
-    w : *float* or *array*
-        Frequency of the oscillator.
-
-    w_th : *float*
-        The temperature in units of frequency (or the same units as `w`).
-
-
-    Returns
-    -------
-
-    n_avg : *float* or *array*
-
-        Return the number of average photons in thermal equilibrium for a
-        an oscillator with the given frequency and temperature.
-
-
-    """
-
-    if isinstance(w, np.ndarray):
-        return 1.0 / (np.exp(w / w_th) - 1.0)
-
-    else:
-        if (w_th > 0) and np.exp(w / w_th) != 1.0:
-            return 1.0 / (np.exp(w / w_th) - 1.0)
-        else:
-            return 0.0
-
-
-def _factorial_prod(N, arr):
-    arr[:int(N)] += 1
-
-
-def _factorial_div(N, arr):
-    arr[:int(N)] -= 1
-
-
-def _to_long(arr):
-    prod = 1
-    for i, v in enumerate(arr):
-        prod *= (i+1)**int(v)
-    return prod
-
-
-def clebsch(j1, j2, j3, m1, m2, m3):
-    """Calculates the Clebsch-Gordon coefficient
-    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
-
-    Parameters
-    ----------
-    j1 : float
-        Total angular momentum 1.
-
-    j2 : float
-        Total angular momentum 2.
-
-    j3 : float
-        Total angular momentum 3.
-
-    m1 : float
-        z-component of angular momentum 1.
-
-    m2 : float
-        z-component of angular momentum 2.
-
-    m3 : float
-        z-component of angular momentum 3.
-
-    Returns
-    -------
-    cg_coeff : float
-        Requested Clebsch-Gordan coefficient.
-
-    """
-    if m3 != m1 + m2:
-        return 0
-    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
-    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
-
-    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
-    _factorial_prod(j3 + j1 - j2, c_factor)
-    _factorial_prod(j3 - j1 + j2, c_factor)
-    _factorial_prod(j1 + j2 - j3, c_factor)
-    _factorial_prod(j3 + m3, c_factor)
-    _factorial_prod(j3 - m3, c_factor)
-    _factorial_div(j1 + j2 + j3 + 1, c_factor)
-    _factorial_div(j1 - m1, c_factor)
-    _factorial_div(j1 + m1, c_factor)
-    _factorial_div(j2 - m2, c_factor)
-    _factorial_div(j2 + m2, c_factor)
-    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
-
-    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
-    sign = (-1) ** (vmin + j2 + m2)
-    for i,v in enumerate(range(vmin, vmax + 1)):
-        factor = s_factors[i,:]
-        _factorial_prod(j2 + j3 + m1 - v, factor)
-        _factorial_prod(j1 - m1 + v, factor)
-        _factorial_div(j3 - j1 + j2 - v, factor)
-        _factorial_div(j3 + m3 - v, factor)
-        _factorial_div(v + j1 - j2 - m3, factor)
-        _factorial_div(v, factor)
-    common_denominator = -np.min(s_factors, axis=0)
-    numerators = s_factors + common_denominator
-    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
-        sign / _to_long(common_denominator)
-    return C * S
-
-
-# -----------------------------------------------------------------------------
-# Functions for unit conversions
-#
-_e = 1.602176565e-19  # C
-_kB = 1.3806488e-23   # J/K
-_h = 6.62606957e-34   # Js
-
-_unit_factor_tbl = {
-    #   "unit": "factor that convert argument from unit 'unit' to Joule"
-    "J": 1.0,
-    "eV": _e,
-    "meV": 1.0e-3 * _e,
-    "GHz": 1.0e9 * _h,
-    "mK": 1.0e-3 * _kB,
-}
-
-
-def convert_unit(value, orig="meV", to="GHz"):
-    """
-    Convert an energy from unit `orig` to unit `to`.
-
-    Parameters
-    ----------
-    value : float / array
-        The energy in the old unit.
-
-    orig : string
-        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
-
-    to : string
-        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
-
-    Returns
-    -------
-    value_new_unit : float / array
-        The energy in the new unit.
-    """
-    if orig not in _unit_factor_tbl:
-        raise TypeError("Unsupported unit %s" % orig)
-
-    if to not in _unit_factor_tbl:
-        raise TypeError("Unsupported unit %s" % to)
-
-    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
-
-
-def convert_GHz_to_meV(w):
-    """
-    Convert an energy from unit GHz to unit meV.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
-    w_meV = w * 4.1357e-3
-    return w_meV
-
-
-def convert_meV_to_GHz(w):
-    """
-    Convert an energy from unit meV to unit GHz.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 meV = 1.0/4.1357e-3 GHz
-    w_GHz = w / 4.1357e-3
-    return w_GHz
-
-
-def convert_J_to_meV(w):
-    """
-    Convert an energy from unit J to unit meV.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 eV = 1.602e-19 J
-    w_meV = 1000.0 * w / _e
-    return w_meV
-
-
-def convert_meV_to_J(w):
-    """
-    Convert an energy from unit meV to unit J.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 eV = 1.602e-19 J
-    w_J = 0.001 * w * _e
-    return w_J
-
-
-def convert_meV_to_mK(w):
-    """
-    Convert an energy from unit meV to unit mK.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 mK = 0.0000861740 meV
-    w_mK = w / 0.0000861740
-    return w_mK
-
-
-def convert_mK_to_meV(w):
-    """
-    Convert an energy from unit mK to unit meV.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 mK = 0.0000861740 meV
-    w_meV = w * 0.0000861740
-    return w_meV
-
-
-def convert_GHz_to_mK(w):
-    """
-    Convert an energy from unit GHz to unit mK.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # h v [Hz] = kB T [K]
-    # h 1e9 v [GHz] = kB 1e-3 T [mK]
-    # T [mK] = 1e12 * (h/kB) * v [GHz]
-    w_mK = w * 1.0e12 * (_h / _kB)
-    return w_mK
-
-
-def convert_mK_to_GHz(w):
-    """
-    Convert an energy from unit mK to unit GHz.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-
-    """
-    w_GHz = w * 1.0e-12 * (_kB / _h)
-    return w_GHz
-
-
-def _version2int(version_string):
-    str_list = version_string.split(
-        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
-        "post")[0].split('.')
-    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
-                for n, d in enumerate(str_list[:3])])
+"""
+This module contains utility functions that are commonly needed in other
+qutip modules.
+"""
+
+__all__ = ['n_thermal', 'clebsch', 'convert_unit']
+
+import numpy as np
+
+def n_thermal(w, w_th):
+    """
+    Return the number of photons in thermal equilibrium for an harmonic
+    oscillator mode with frequency 'w', at the temperature described by
+    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
+
+    Parameters
+    ----------
+
+    w : *float* or *array*
+        Frequency of the oscillator.
+
+    w_th : *float*
+        The temperature in units of frequency (or the same units as `w`).
+
+
+    Returns
+    -------
+
+    n_avg : *float* or *array*
+
+        Return the number of average photons in thermal equilibrium for a
+        an oscillator with the given frequency and temperature.
+
+
+    """
+
+    if isinstance(w, np.ndarray):
+        return 1.0 / (np.exp(w / w_th) - 1.0)
+
+    else:
+        if (w_th > 0) and np.exp(w / w_th) != 1.0:
+            return 1.0 / (np.exp(w / w_th) - 1.0)
+        else:
+            return 0.0
+
+
+def _factorial_prod(N, arr):
+    arr[:int(N)] += 1
+
+
+def _factorial_div(N, arr):
+    arr[:int(N)] -= 1
+
+
+def _to_long(arr):
+    prod = 1
+    for i, v in enumerate(arr):
+        prod *= (i+1)**int(v)
+    return prod
+
+
+def clebsch(j1, j2, j3, m1, m2, m3):
+    """Calculates the Clebsch-Gordon coefficient
+    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
+
+    Parameters
+    ----------
+    j1 : float
+        Total angular momentum 1.
+
+    j2 : float
+        Total angular momentum 2.
+
+    j3 : float
+        Total angular momentum 3.
+
+    m1 : float
+        z-component of angular momentum 1.
+
+    m2 : float
+        z-component of angular momentum 2.
+
+    m3 : float
+        z-component of angular momentum 3.
+
+    Returns
+    -------
+    cg_coeff : float
+        Requested Clebsch-Gordan coefficient.
+
+    """
+    if m3 != m1 + m2:
+        return 0
+    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
+    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
+
+    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
+    _factorial_prod(j3 + j1 - j2, c_factor)
+    _factorial_prod(j3 - j1 + j2, c_factor)
+    _factorial_prod(j1 + j2 - j3, c_factor)
+    _factorial_prod(j3 + m3, c_factor)
+    _factorial_prod(j3 - m3, c_factor)
+    _factorial_div(j1 + j2 + j3 + 1, c_factor)
+    _factorial_div(j1 - m1, c_factor)
+    _factorial_div(j1 + m1, c_factor)
+    _factorial_div(j2 - m2, c_factor)
+    _factorial_div(j2 + m2, c_factor)
+    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
+
+    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
+    sign = (-1) ** (vmin + j2 + m2)
+    for i,v in enumerate(range(vmin, vmax + 1)):
+        factor = s_factors[i,:]
+        _factorial_prod(j2 + j3 + m1 - v, factor)
+        _factorial_prod(j1 - m1 + v, factor)
+        _factorial_div(j3 - j1 + j2 - v, factor)
+        _factorial_div(j3 + m3 - v, factor)
+        _factorial_div(v + j1 - j2 - m3, factor)
+        _factorial_div(v, factor)
+    common_denominator = -np.min(s_factors, axis=0)
+    numerators = s_factors + common_denominator
+    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
+        sign / _to_long(common_denominator)
+    return C * S
+
+
+# -----------------------------------------------------------------------------
+# Functions for unit conversions
+#
+_e = 1.602176565e-19  # C
+_kB = 1.3806488e-23   # J/K
+_h = 6.62606957e-34   # Js
+
+_unit_factor_tbl = {
+    #   "unit": "factor that convert argument from unit 'unit' to Joule"
+    "J": 1.0,
+    "eV": _e,
+    "meV": 1.0e-3 * _e,
+    "GHz": 1.0e9 * _h,
+    "mK": 1.0e-3 * _kB,
+}
+
+
+def convert_unit(value, orig="meV", to="GHz"):
+    """
+    Convert an energy from unit `orig` to unit `to`.
+
+    Parameters
+    ----------
+    value : float / array
+        The energy in the old unit.
+
+    orig : string
+        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
+
+    to : string
+        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
+
+    Returns
+    -------
+    value_new_unit : float / array
+        The energy in the new unit.
+    """
+    if orig not in _unit_factor_tbl:
+        raise TypeError("Unsupported unit %s" % orig)
+
+    if to not in _unit_factor_tbl:
+        raise TypeError("Unsupported unit %s" % to)
+
+    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
+
+
+def convert_GHz_to_meV(w):
+    """
+    Convert an energy from unit GHz to unit meV.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
+    w_meV = w * 4.1357e-3
+    return w_meV
+
+
+def convert_meV_to_GHz(w):
+    """
+    Convert an energy from unit meV to unit GHz.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 meV = 1.0/4.1357e-3 GHz
+    w_GHz = w / 4.1357e-3
+    return w_GHz
+
+
+def convert_J_to_meV(w):
+    """
+    Convert an energy from unit J to unit meV.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 eV = 1.602e-19 J
+    w_meV = 1000.0 * w / _e
+    return w_meV
+
+
+def convert_meV_to_J(w):
+    """
+    Convert an energy from unit meV to unit J.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 eV = 1.602e-19 J
+    w_J = 0.001 * w * _e
+    return w_J
+
+
+def convert_meV_to_mK(w):
+    """
+    Convert an energy from unit meV to unit mK.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 mK = 0.0000861740 meV
+    w_mK = w / 0.0000861740
+    return w_mK
+
+
+def convert_mK_to_meV(w):
+    """
+    Convert an energy from unit mK to unit meV.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 mK = 0.0000861740 meV
+    w_meV = w * 0.0000861740
+    return w_meV
+
+
+def convert_GHz_to_mK(w):
+    """
+    Convert an energy from unit GHz to unit mK.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # h v [Hz] = kB T [K]
+    # h 1e9 v [GHz] = kB 1e-3 T [mK]
+    # T [mK] = 1e12 * (h/kB) * v [GHz]
+    w_mK = w * 1.0e12 * (_h / _kB)
+    return w_mK
+
+
+def convert_mK_to_GHz(w):
+    """
+    Convert an energy from unit mK to unit GHz.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+
+    """
+    w_GHz = w * 1.0e-12 * (_kB / _h)
+    return w_GHz
+
+
+def _version2int(version_string):
+    str_list = version_string.split(
+        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
+        "post")[0].split('.')
+    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
+                for n, d in enumerate(str_list[:3])])
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 27fe62c60a..3262da1882 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1,1819 +1,1819 @@
-"""
-Functions for visualizing results of quantum dynamics simulations,
-visualizations of quantum states and processes.
-"""
-
-__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
-           'plot_energy_levels', 'fock_distribution',
-           'plot_fock_distribution', 'wigner_fock_distribution',
-           'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution_2d',
-           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
-           'complex_array_to_rgb', 'matrix_histogram',
-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
-
-import warnings
-import itertools as it
-import numpy as np
-from numpy import pi, array, sin, cos, angle, log2
-
-from packaging.version import parse as parse_version
-
-from . import (
-    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
-)
-from .core.dimensions import flatten
-from .core.superop_reps import _to_superpauli, isqubitdims
-from .wigner import wigner
-from .matplotlib_utilities import complex_phase_cmap
-
-try:
-    import matplotlib.pyplot as plt
-    import matplotlib as mpl
-    from matplotlib import cm
-    from mpl_toolkits.mplot3d import Axes3D
-
-    # Define a custom _axes3D function based on the matplotlib version.
-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-    if parse_version(mpl.__version__) >= parse_version('3.4'):
-        def _axes3D(fig, *args, **kwargs):
-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-            return fig.add_axes(ax)
-    else:
-        def _axes3D(*args, **kwargs):
-            return Axes3D(*args, **kwargs)
-except:
-    pass
-
-
-def plot_wigner_sphere(fig, ax, wigner, reflections):
-    """Plots a coloured Bloch sphere.
-
-    Parameters
-    ----------
-    fig : :obj:`matplotlib.figure.Figure`
-        An instance of :obj:`~matplotlib.figure.Figure`.
-    ax : :obj:`matplotlib.axes.Axes`
-        An axes instance in the given figure.
-    wigner : list of float
-        The wigner transformation at `steps` different theta and phi.
-    reflections : bool
-        If the reflections of the sphere should be plotted as well.
-
-    Notes
-    -----
-    Special thanks to Russell P Rundle for writing this function.
-    """
-    ax.set_xlabel("x")
-    ax.set_ylabel("y")
-    ax.set_zlabel("z")
-
-    steps = len(wigner)
-
-    theta = np.linspace(0, np.pi, steps)
-    phi = np.linspace(0, 2 * np.pi, steps)
-    x = np.outer(np.sin(theta), np.cos(phi))
-    y = np.outer(np.sin(theta), np.sin(phi))
-    z = np.outer(np.cos(theta), np.ones(steps))
-    wigner = np.real(wigner)
-    wigner_max = np.real(np.amax(np.abs(wigner)))
-
-    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
-
-    # Plot coloured Bloch sphere:
-    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
-                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
-                    zorder=0.5, antialiased=None)
-
-    if reflections:
-        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # bottom
-        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # side
-        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # back
-
-        # Plot bottom reflection:
-        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
-                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-        # Plot side reflection:
-        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
-                        z[0:steps, 0:steps], facecolors=wigner_c3,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-        # Plot back reflection:
-        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
-                        z[0:steps, 0:steps], facecolors=wigner_c4,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-    # Create colourbar:
-    m = cm.ScalarMappable(cmap=cm.seismic_r)
-    m.set_array([-wigner_max, wigner_max])
-    plt.colorbar(m, shrink=0.5, aspect=10)
-
-    plt.show()
-
-
-# Adopted from the SciPy Cookbook.
-def _blob(x, y, w, w_max, area, color_fn, ax=None):
-    """
-    Draws a square-shaped blob with the given area (< 1) at
-    the given coordinates.
-    """
-    hs = np.sqrt(area) / 2
-    xcorners = array([x - hs, x + hs, x + hs, x - hs])
-    ycorners = array([y - hs, y - hs, y + hs, y + hs])
-
-    if ax is not None:
-        handle = ax
-    else:
-        handle = plt
-
-    handle.fill(xcorners, ycorners,
-             color=color_fn(w))
-
-
-def _cb_labels(left_dims):
-    """Creates plot labels for matrix elements in the computational basis.
-
-    Parameters
-    ----------
-    left_dims : flat list of ints
-        Dimensions of the left index of a density operator. E. g.
-        [2, 3] for a qubit tensored with a qutrit.
-
-    Returns
-    -------
-    left_labels, right_labels : lists of strings
-        Labels for the left and right indices of a density operator
-        (kets and bras, respectively).
-    """
-    # FIXME: assumes dims, such that we only need left_dims == dims[0].
-    basis_labels = list(map(",".join, it.product(*[
-        map(str, range(dim))
-        for dim in left_dims
-    ])))
-    return [
-        map(fmt.format, basis_labels) for fmt in
-        (
-            r"$\langle{}|$",
-            r"$|{}\rangle$",
-        )
-    ]
-
-
-# Adopted from the SciPy Cookbook.
-def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
-           label_top=True, color_style="scaled"):
-    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
-
-    Parameters
-    ----------
-    rho : qobj
-        Input density matrix or superoperator.
-
-    xlabels : list of strings or False
-        list of x labels
-
-    ylabels : list of strings or False
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    cmap : a matplotlib colormap instance
-        Color map to use when plotting.
-
-    label_top : bool
-        If True, x-axis labels will be placed on top, otherwise
-        they will appear below the plot.
-
-    color_style : string
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"scaled"`` (default), each color is chosen by
-           passing the absolute value of the corresponding matrix
-           element into `cmap` with the sign of the real part.
-        -  If set to ``"threshold"``, each square is plotted as
-           the maximum of `cmap` for the positive real part and as
-           the minimum for the negative part of the matrix element;
-           note that this generalizes `"threshold"` to complex numbers.
-        -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not a quantum object.
-
-    Examples
-    --------
-    >>> import qutip
-    >>>
-    >>> dm = qutip.rand_dm(4)
-    >>> fig, ax = qutip.hinton(dm)
-    >>> fig.show()
-    >>>
-    >>> qutip.settings.colorblind_safe = True
-    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
-    >>> fig.show()
-    >>> qutip.settings.colorblind_safe = False
-    >>>
-    >>> fig, ax = qutip.hinton(dm, color_style="phase")
-    >>> fig.show()
-    """
-
-    # Apply default colormaps.
-    # TODO: abstract this away into something that makes default
-    #       colormaps.
-    cmap = (
-        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
-        if cmap is None else cmap
-    )
-
-    # Extract plotting data W from the input.
-    if isinstance(rho, Qobj):
-        if rho.isoper:
-            W = rho.full()
-
-            # Create default labels if none are given.
-            if xlabels is None or ylabels is None:
-                labels = _cb_labels(rho.dims[0])
-                xlabels = xlabels if xlabels is not None else list(labels[0])
-                ylabels = ylabels if ylabels is not None else list(labels[1])
-
-        elif rho.isoperket:
-            W = vector_to_operator(rho).full()
-        elif rho.isoperbra:
-            W = vector_to_operator(rho.dag()).full()
-        elif rho.issuper:
-            if not isqubitdims(rho.dims):
-                raise ValueError("Hinton plots of superoperators are "
-                                 "currently only supported for qubits.")
-            # Convert to a superoperator in the Pauli basis,
-            # so that all the elements are real.
-            sqobj = _to_superpauli(rho)
-            nq = int(log2(sqobj.shape[0]) / 2)
-            W = sqobj.full().T
-            # Create default labels, too.
-            if (xlabels is None) or (ylabels is None):
-                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                xlabels = xlabels if xlabels is not None else labels
-                ylabels = ylabels if ylabels is not None else labels
-
-        else:
-            raise ValueError(
-                "Input quantum object must be an operator or superoperator."
-            )
-
-    else:
-        W = rho
-
-    if ax is None:
-        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
-    else:
-        fig = None
-
-    if not (xlabels or ylabels):
-        ax.axis('off')
-    if title:
-        ax.set_title(title)
-
-    ax.axis('equal')
-    ax.set_frame_on(False)
-
-    height, width = W.shape
-
-    w_max = 1.25 * max(abs(np.array(W)).flatten())
-    if w_max <= 0.0:
-        w_max = 1.0
-
-    # Set color_fn here.
-    if color_style == "scaled":
-        def color_fn(w):
-            w = np.abs(w) * np.sign(np.real(w))
-            return cmap(int((w + w_max) * 256 / (2 * w_max)))
-    elif color_style == "threshold":
-        def color_fn(w):
-            w = np.real(w)
-            return cmap(255 if w > 0 else 0)
-    elif color_style == "phase":
-        def color_fn(w):
-            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
-    else:
-        raise ValueError(
-            "Unknown color style {} for Hinton diagrams.".format(color_style)
-        )
-
-    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
-            color=cmap(128))
-    for x in range(width):
-        for y in range(height):
-            _x = x + 1
-            _y = y + 1
-            _blob(
-                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
-                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
-
-    # color axis
-    vmax = np.pi if color_style == "phase" else abs(W).max()
-    norm = mpl.colors.Normalize(-vmax, vmax)
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-
-    xtics = 0.5 + np.arange(width)
-    # x axis
-    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-        if label_top:
-            ax.xaxis.tick_top()
-    ax.tick_params(axis='x', labelsize=14)
-
-    # y axis
-    ytics = 0.5 + np.arange(height)
-    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(list(reversed(ylabels)))
-    ax.tick_params(axis='y', labelsize=14)
-
-    return fig, ax
-
-
-def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    theta : float
-        Angle with respect to z-axis
-
-    phi : float
-        Angle in x-y plane
-
-    values : array
-        Data set to be plotted
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    save : bool {False , True}
-        Whether to save the figure or not
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-    if fig is None or ax is None:
-        fig = plt.figure()
-        ax = _axes3D(fig)
-
-    thetam, phim = np.meshgrid(theta, phi)
-    xx = sin(thetam) * cos(phim)
-    yy = sin(thetam) * sin(phim)
-    zz = cos(thetam)
-    r = array(abs(values))
-    ph = angle(values)
-    # normalize color range based on phase angles in list ph
-    nrm = mpl.colors.Normalize(ph.min(), ph.max())
-
-    # plot with facecolors set to cm.jet colormap normalized to nrm
-    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
-                    facecolors=cm.jet(nrm(ph)), linewidth=0)
-    # create new axes on plot for colorbar and shrink it a bit.
-    # pad shifts location of bar with repsect to the main plot
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-
-    # create new colorbar in axes cax with cm jet and normalized to nrm like
-    # our facecolors
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
-    # add our colorbar label
-    cb1.set_label('Angle')
-
-    if save:
-        plt.savefig("sphereplot.png")
-
-    return fig, ax
-
-
-def _remove_margins(axis):
-    """
-    removes margins about z = 0 and improves the style
-    by monkey patching
-    """
-    def _get_coord_info_new(renderer):
-        mins, maxs, centers, deltas, tc, highs = \
-            _get_coord_info_old(renderer)
-        mins += deltas / 4
-        maxs -= deltas / 4
-        return mins, maxs, centers, deltas, tc, highs
-
-    _get_coord_info_old = axis._get_coord_info
-    axis._get_coord_info = _get_coord_info_new
-
-
-def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
-    """
-    truncates portion of a colormap and returns the new one
-    """
-    if isinstance(cmap, str):
-        cmap = plt.get_cmap(cmap)
-    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
-        'trunc({n},{a:.2f},{b:.2f})'.format(
-            n=cmap.name, a=minval, b=maxval),
-        cmap(np.linspace(minval, maxval, n)))
-    return new_cmap
-
-
-def _stick_to_planes(stick, azim, ax, M, spacing):
-    """adjusts xlim and ylim in way that bars will
-    Stick to xz and yz planes
-    """
-    if stick is True:
-        azim = azim % 360
-        if 0 <= azim <= 90:
-            ax.set_ylim(1 - .5,)
-            ax.set_xlim(1 - .5,)
-        elif 90 < azim <= 180:
-            ax.set_ylim(1 - .5,)
-            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
-        elif 180 < azim <= 270:
-            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
-            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
-        elif 270 < azim < 360:
-            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
-            ax.set_xlim(1 - .5,)
-
-
-def _update_yaxis(spacing, M, ax, ylabels):
-    """
-    updates the y-axis
-    """
-    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(ylabels)
-    else:
-        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
-        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
-    ax.tick_params(axis='y', labelsize=14)
-    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
-
-
-def _update_xaxis(spacing, M, ax, xlabels):
-    """
-    updates the x-axis
-    """
-    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-    else:
-        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
-        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
-    ax.tick_params(axis='x', labelsize=14)
-    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
-
-
-def _update_zaxis(ax, z_min, z_max, zticks):
-    """
-    updates the z-axis
-    """
-    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
-    if isinstance(zticks, list):
-        ax.set_zticks(zticks)
-    ax.set_zlim3d([min(z_min, 0), z_max])
-
-
-def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
-                     colorbar=True, fig=None, ax=None, options=None):
-    """
-    Draw a histogram for the matrix M, with the given x and y labels and title.
-
-    Parameters
-    ----------
-    M : Matrix of Qobj
-        The matrix to visualize
-
-    xlabels : list of strings
-        list of x labels
-
-    ylabels : list of strings
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    colorbar : bool (default: True)
-        show colorbar
-
-    options : dict
-        A dictionary containing extra options for the plot.
-        The names (keys) and values of the options are
-        described below:
-
-        'zticks' : list of numbers
-            A list of z-axis tick locations.
-
-        'cmap' : string (default: 'jet')
-            The name of the color map to use.
-
-        'cmap_min' : float (default: 0.0)
-            The lower bound to truncate the color map at.
-            A value in range 0 - 1. The default, 0, leaves the lower
-            bound of the map unchanged.
-
-        'cmap_max' : float (default: 1.0)
-            The upper bound to truncate the color map at.
-            A value in range 0 - 1. The default, 1, leaves the upper
-            bound of the map unchanged.
-
-        'bars_spacing' : float (default: 0.1)
-            spacing between bars.
-
-        'bars_alpha' : float (default: 1.)
-            transparency of bars, should be in range 0 - 1
-
-        'bars_lw' : float (default: 0.5)
-            linewidth of bars' edges.
-
-        'bars_edgecolor' : color (default: 'k')
-            The colors of the bars' edges.
-            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
-
-        'shade' : bool (default: True)
-            Whether to shade the dark sides of the bars (True) or not (False).
-            The shading is relative to plot's source of light.
-
-        'azim' : float
-            The azimuthal viewing angle.
-
-        'elev' : float
-            The elevation viewing angle.
-
-        'proj_type' : string (default: 'ortho' if ax is not passed)
-            The type of projection ('ortho' or 'persp')
-
-        'stick' : bool (default: False)
-            Changes xlim and ylim in such a way that bars next to
-            XZ and YZ planes will stick to those planes.
-            This option has no effect if ``ax`` is passed as a parameter.
-
-        'cbar_pad' : float (default: 0.04)
-            The fraction of the original axes between the colorbar
-            and the new image axes.
-            (i.e. the padding between the 3D figure and the colorbar).
-
-        'cbar_to_z' : bool (default: False)
-            Whether to set the color of maximum and minimum z-values to the
-            maximum and minimum colors in the colorbar (True) or not (False).
-
-        'figsize' : tuple of two numbers
-            The size of the figure.
-
-    Returns :
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not valid.
-
-    """
-
-    # default options
-    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
-                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
-                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-                    'shade': False, 'azim': -35, 'elev': 35,
-                    'proj_type': 'ortho', 'stick': False,
-                    'cbar_pad': 0.04, 'cbar_to_z': False}
-
-    # update default_opts from input options
-    if options is None:
-        pass
-    elif isinstance(options, dict):
-        # check if keys in options dict are valid
-        if set(options) - set(default_opts):
-            raise ValueError("invalid key(s) found in options: "
-                             f"{', '.join(set(options) - set(default_opts))}")
-        else:
-            # updating default options
-            default_opts.update(options)
-    else:
-        raise ValueError("options must be a dictionary")
-
-    if isinstance(M, Qobj):
-        # extract matrix data from Qobj
-        M = M.full()
-
-    n = np.size(M)
-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-    xpos = xpos.T.flatten() + 0.5
-    ypos = ypos.T.flatten() + 0.5
-    zpos = np.zeros(n)
-    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
-    dz = np.real(M.flatten())
-
-    if isinstance(limits, list) and len(limits) == 2:
-        z_min = limits[0]
-        z_max = limits[1]
-    else:
-        z_min = min(dz)
-        z_max = max(dz)
-        if z_min == z_max:
-            z_min -= 0.1
-            z_max += 0.1
-
-    if default_opts['cbar_to_z']:
-        norm = mpl.colors.Normalize(min(dz), max(dz))
-    else:
-        norm = mpl.colors.Normalize(z_min, z_max)
-    cmap = _truncate_colormap(default_opts['cmap'],
-                              default_opts['cmap_min'],
-                              default_opts['cmap_max'])
-    colors = cmap(norm(dz))
-
-    if ax is None:
-        fig = plt.figure(figsize=default_opts['figsize'])
-        ax = _axes3D(fig,
-                     azim=default_opts['azim'] % 360,
-                     elev=default_opts['elev'] % 360)
-        ax.set_proj_type(default_opts['proj_type'])
-
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
-             edgecolors=default_opts['bars_edgecolor'],
-             linewidths=default_opts['bars_lw'],
-             alpha=default_opts['bars_alpha'],
-             shade=default_opts['shade'])
-    # remove vertical lines on xz and yz plane
-    ax.yaxis._axinfo["grid"]['linewidth'] = 0
-    ax.xaxis._axinfo["grid"]['linewidth'] = 0
-
-    if title:
-        ax.set_title(title)
-
-    # x axis
-    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
-
-    # y axis
-    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
-
-    # z axis
-    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
-
-    # stick to xz and yz plane
-    _stick_to_planes(default_opts['stick'],
-                     default_opts['azim'], ax, M,
-                     default_opts['bars_spacing'])
-
-    # color axis
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=default_opts['cbar_pad'])
-        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-
-    # removing margins
-    _remove_margins(ax.xaxis)
-    _remove_margins(ax.yaxis)
-    _remove_margins(ax.zaxis)
-
-    return fig, ax
-
-
-def matrix_histogram_complex(M, xlabels=None, ylabels=None,
-                             title=None, limits=None, phase_limits=None,
-                             colorbar=True, fig=None, ax=None,
-                             threshold=None):
-    """
-    Draw a histogram for the amplitudes of matrix M, using the argument
-    of each element for coloring the bars, with the given x and y labels
-    and title.
-
-    Parameters
-    ----------
-    M : Matrix of Qobj
-        The matrix to visualize
-
-    xlabels : list of strings
-        list of x labels
-
-    ylabels : list of strings
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
-
-    phase_limits : list/array with two float numbers
-        The phase-axis (colorbar) limits [min, max] (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    threshold: float (None)
-        Threshold for when bars of smaller height should be transparent. If
-        not set, all bars are colored according to the color map.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not valid.
-
-    """
-
-    if isinstance(M, Qobj):
-        # extract matrix data from Qobj
-        M = M.full()
-
-    n = np.size(M)
-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-    xpos = xpos.T.flatten() - 0.5
-    ypos = ypos.T.flatten() - 0.5
-    zpos = np.zeros(n)
-    dx = dy = 0.8 * np.ones(n)
-    Mvec = M.flatten()
-    dz = abs(Mvec)
-
-    # make small numbers real, to avoid random colors
-    idx, = np.where(abs(Mvec) < 0.001)
-    Mvec[idx] = abs(Mvec[idx])
-
-    if phase_limits:  # check that limits is a list type
-        phase_min = phase_limits[0]
-        phase_max = phase_limits[1]
-    else:
-        phase_min = -pi
-        phase_max = pi
-
-    norm = mpl.colors.Normalize(phase_min, phase_max)
-    cmap = complex_phase_cmap()
-
-    colors = cmap(norm(angle(Mvec)))
-    if threshold is not None:
-        colors[:, 3] = 1 * (dz > threshold)
-
-    if ax is None:
-        fig = plt.figure()
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
-
-    if title:
-        ax.set_title(title)
-
-    # x axis
-    xtics = -0.5 + np.arange(M.shape[0])
-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-    ax.tick_params(axis='x', labelsize=12)
-
-    # y axis
-    ytics = -0.5 + np.arange(M.shape[1])
-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(ylabels)
-    ax.tick_params(axis='y', labelsize=12)
-
-    # z axis
-    if limits and isinstance(limits, list):
-        ax.set_zlim3d(limits)
-    else:
-        ax.set_zlim3d([0, 1])  # use min/max
-    # ax.set_zlabel('abs')
-
-    # color axis
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
-        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-        cb.set_ticklabels(
-            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
-        cb.set_label('arg')
-
-    return fig, ax
-
-
-def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
-                       figsize=(8, 12), fig=None, ax=None):
-    """
-    Plot the energy level diagrams for a list of Hamiltonians. Include
-    up to N energy levels. For each element in H_list, the energy
-    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
-    where n is the index of an element in H_list.
-
-    Parameters
-    ----------
-
-        H_list : List of Qobj
-            A list of Hamiltonians.
-
-        labels : List of string
-            A list of labels for each Hamiltonian
-
-        show_ylabels : Bool (default False)
-            Show y labels to the left of energy levels of the initial
-            Hamiltonian.
-
-        N : int
-            The number of energy levels to plot
-
-        figsize : tuple (int,int)
-            The size of the figure (width, height).
-
-        fig : a matplotlib Figure instance
-            The Figure canvas in which the plot will be drawn.
-
-        ax : a matplotlib axes instance
-            The axes context in which the plot will be drawn.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-
-        ValueError
-            Input argument is not valid.
-
-    """
-
-    if not isinstance(H_list, list):
-        raise ValueError("H_list must be a list of Qobj instances")
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    H = H_list[0]
-    N = H.shape[0] if N == 0 else min(H.shape[0], N)
-
-    xticks = []
-    yticks = []
-
-    x = 0
-    evals0 = H.eigenenergies(eigvals=N)
-    for e_idx, e in enumerate(evals0[:N]):
-        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
-        yticks.append(e)
-    xticks.append(x + 1)
-    x += 2
-
-    for H1 in H_list[1:]:
-
-        H = H + H1
-        evals1 = H.eigenenergies()
-
-        for e_idx, e in enumerate(evals1[:N]):
-            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
-        x += 1
-
-        for e_idx, e in enumerate(evals1[:N]):
-            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
-        xticks.append(x + 1)
-        x += 2
-
-        evals0 = evals1
-
-    ax.set_frame_on(False)
-
-    if show_ylabels:
-        yticks = np.unique(np.around(yticks, 1))
-        ax.set_yticks(yticks)
-    else:
-        ax.axes.get_yaxis().set_visible(False)
-
-    if labels:
-        ax.get_xaxis().tick_bottom()
-        ax.set_xticks(xticks)
-        ax.set_xticklabels(labels, fontsize=16)
-    else:
-        ax.axes.get_xaxis().set_visible(False)
-
-    return fig, ax
-
-
-def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
-                         figsize=(8, 12), fig=None, ax=None):
-    warnings.warn("Deprecated: Use plot_energy_levels")
-    return plot_energy_levels(H_list, N=N, labels=labels,
-                              show_ylabels=show_ylabels,
-                              figsize=figsize, fig=fig, ax=ax)
-
-
-def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
-                           figsize=(8, 6), title=None, unit_y_range=True):
-    """
-    Plot the Fock distribution for a density matrix (or ket) that describes
-    an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    title : string
-        An optional title for the figure.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    N = rho.shape[0]
-
-    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
-           color="green", alpha=0.6, width=0.8)
-    if unit_y_range:
-        ax.set_ylim(0, 1)
-
-    ax.set_xlim(-.5 + offset, N + offset)
-    ax.set_xlabel('Fock number', fontsize=12)
-    ax.set_ylabel('Occupation probability', fontsize=12)
-
-    if title:
-        ax.set_title(title)
-
-    return fig, ax
-
-
-def fock_distribution(rho, offset=0, fig=None, ax=None,
-                      figsize=(8, 6), title=None, unit_y_range=True):
-    warnings.warn("Deprecated: Use plot_fock_distribution")
-    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
-                                  figsize=figsize, title=title,
-                                  unit_y_range=unit_y_range)
-
-
-def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
-                cmap=None, alpha_max=7.5, colorbar=False,
-                method='clenshaw', projection='2d'):
-    """
-    Plot the the Wigner function for a density matrix (or ket) that describes
-    an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    cmap : a matplotlib cmap instance
-        The colormap.
-
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
-    colorbar : bool
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig and not ax:
-        if projection == '2d':
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-        elif projection == '3d':
-            fig = plt.figure(figsize=figsize)
-            ax = fig.add_subplot(1, 1, 1, projection='3d')
-        else:
-            raise ValueError('Unexpected value of projection keyword argument')
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    xvec = np.linspace(-alpha_max, alpha_max, 200)
-    W0 = wigner(rho, xvec, xvec, method=method)
-
-    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
-
-    wlim = abs(W).max()
-
-    if cmap is None:
-        cmap = cm.get_cmap('RdBu')
-
-    if projection == '2d':
-        cf = ax.contourf(xvec, yvec, W, 100,
-                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-    elif projection == '3d':
-        X, Y = np.meshgrid(xvec, xvec)
-        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
-                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-    else:
-        raise ValueError('Unexpected value of projection keyword argument.')
-
-    if xvec is not yvec:
-        ax.set_ylim(xvec.min(), xvec.max())
-
-    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
-    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
-
-    if colorbar:
-        fig.colorbar(cf, ax=ax)
-
-    ax.set_title("Wigner function", fontsize=12)
-
-    return fig, ax
-
-
-def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-                                  cmap=None, alpha_max=7.5, colorbar=False,
-                                  method='iterative', projection='2d'):
-    """
-    Plot the Fock distribution and the Wigner function for a density matrix
-    (or ket) that describes an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    axes : a list of two matplotlib axes instances
-        The axes context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    cmap : a matplotlib cmap instance
-        The colormap.
-
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
-    colorbar : bool
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    method : string {'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig and not axes:
-        if projection == '2d':
-            fig, axes = plt.subplots(1, 2, figsize=figsize)
-        elif projection == '3d':
-            fig = plt.figure(figsize=figsize)
-            axes = [fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2, projection='3d')]
-        else:
-            raise ValueError('Unexpected value of projection keyword argument')
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    plot_fock_distribution(rho, fig=fig, ax=axes[0])
-    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
-                alpha_max=alpha_max, colorbar=colorbar, method=method,
-                projection=projection)
-
-    return fig, axes
-
-
-def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-                             cmap=None, alpha_max=7.5, colorbar=False,
-                             method='iterative'):
-    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
-    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
-                                         figsize=figsize, cmap=cmap,
-                                         alpha_max=alpha_max,
-                                         colorbar=colorbar,
-                                         method=method)
-
-
-def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
-                            fig=None, axes=None, figsize=(8, 4)):
-    """
-    Visualize the results (expectation values) for an evolution solver.
-    `results` is assumed to be an instance of Result, or a list of Result
-    instances.
-
-    Parameters
-    ----------
-    results : (list of) :class:`qutip.solver.Result`
-        List of results objects returned by any of the QuTiP evolution solvers.
-
-    ylabels : list of strings
-        The y-axis labels. List should be of the same length as `results`.
-
-    title : string
-        The title of the figure.
-
-    show_legend : bool
-        Whether or not to show the legend.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    axes : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-    if not isinstance(results, list):
-        results = [results]
-
-    n_e_ops = max([len(result.expect) for result in results])
-
-    if not fig or not axes:
-        if not figsize:
-            figsize = (12, 3 * n_e_ops)
-        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
-                                 figsize=figsize, squeeze=False)
-
-    for r_idx, result in enumerate(results):
-        for e_idx, e in enumerate(result.expect):
-            axes[e_idx, 0].plot(result.times, e,
-                                label="%s [%d]" % (result.solver, e_idx))
-
-    if title:
-        fig.suptitle(title)
-
-    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
-    for n in range(n_e_ops):
-        if show_legend:
-            axes[n, 0].legend()
-        if ylabels:
-            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
-
-    return fig, axes
-
-
-def plot_spin_distribution_2d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 8)):
-    """
-    Plot a spin distribution function (given as meshgrid data) with a 2D
-    projection where the surface of the unit sphere is mapped on the unit disk.
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig or not ax:
-        if not figsize:
-            figsize = (8, 8)
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    Y = (THETA - pi / 2) / (pi / 2)
-    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-    else:
-        cmap = cm.RdYlBu
-
-    ax.pcolor(X, Y, P.real, cmap=cmap)
-    ax.set_xlabel(r'$\varphi$', fontsize=18)
-    ax.set_ylabel(r'$\theta$', fontsize=18)
-
-    ax.set_xticks([-1, 0, 1])
-    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
-    ax.set_yticks([-1, 0, 1])
-    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-
-    return fig, ax
-
-
-def plot_spin_distribution_3d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 6)):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    if fig is None or ax is None:
-        fig = plt.figure(figsize=figsize)
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    xx = sin(THETA) * cos(PHI)
-    yy = sin(THETA) * sin(PHI)
-    zz = cos(THETA)
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-        norm = mpl.colors.Normalize(-P.max(), P.max())
-    else:
-        cmap = cm.RdYlBu
-        norm = mpl.colors.Normalize(P.min(), P.max())
-
-    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-                    facecolors=cmap(norm(P)), linewidth=0)
-
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-    cb1.set_label('magnitude')
-
-    return fig, ax
-
-
-#
-# Qubism and other qubistic visualizations
-#
-def complex_array_to_rgb(X, theme='light', rmax=None):
-    """
-    Makes an array of complex number and converts it to an array of [r, g, b],
-    where phase gives hue and saturation/value are given by the absolute value.
-    Especially for use with imshow for complex plots.
-
-    For more info on coloring, see:
-        Emilia Petrisor,
-        Visualizing complex-valued functions with Matplotlib and Mayavi
-        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
-
-    Parameters
-    ----------
-    X : array
-        Array (of any dimension) of complex numbers.
-
-    theme : 'light' (default) or 'dark'
-        Set coloring theme for mapping complex values into colors.
-
-    rmax : float
-        Maximal abs value for color normalization.
-        If None (default), uses np.abs(X).max().
-
-    Returns
-    -------
-    Y : array
-        Array of colors (of shape X.shape + (3,)).
-
-    """
-
-    absmax = rmax or np.abs(X).max()
-    if absmax == 0.:
-        absmax = 1.
-    Y = np.zeros(X.shape + (3,), dtype='float')
-    Y[..., 0] = np.angle(X) / (2 * pi) % 1
-    if theme == 'light':
-        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
-        Y[..., 2] = 1
-    elif theme == 'dark':
-        Y[..., 1] = 1
-        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
-    Y = mpl.colors.hsv_to_rgb(Y)
-    return Y
-
-
-def _index_to_sequence(i, dim_list):
-    """
-    For a matrix entry with index i it returns state it corresponds to.
-    In particular, for dim_list=[2]*n it returns i written as a binary number.
-
-    Parameters
-    ----------
-    i : int
-        Index in a matrix.
-
-    dim_list : list of int
-        List of dimensions of consecutive particles.
-
-    Returns
-    -------
-    seq : list
-        List of coordinates for each particle.
-
-    """
-    res = []
-    j = i
-    for d in reversed(dim_list):
-        j, s = divmod(j, d)
-        res.append(s)
-    return list(reversed(res))
-
-
-def _sequence_to_index(seq, dim_list):
-    """
-    Inverse of _index_to_sequence.
-
-    Parameters
-    ----------
-    seq : list of ints
-        List of coordinates for each particle.
-
-    dim_list : list of int
-        List of dimensions of consecutive particles.
-
-    Returns
-    -------
-    i : list
-        Index in a matrix.
-
-    """
-    i = 0
-    for s, d in zip(seq, dim_list):
-        i *= d
-        i += s
-
-    return i
-
-
-def _to_qubism_index_pair(i, dim_list, how='pairs'):
-    """
-    For a matrix entry with index i
-    it returns x, y coordinates in qubism mapping.
-
-    Parameters
-    ----------
-    i : int
-        Index in a matrix.
-
-    dim_list : list of int
-        List of dimensions of consecutive particles.
-
-    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
-        Type of qubistic plot.
-
-    Returns
-    -------
-    x, y : tuple of ints
-        List of coordinates for each particle.
-
-    """
-    seq = _index_to_sequence(i, dim_list)
-
-    if how == 'pairs':
-        y = _sequence_to_index(seq[::2], dim_list[::2])
-        x = _sequence_to_index(seq[1::2], dim_list[1::2])
-    elif how == 'pairs_skewed':
-        dim_list2 = dim_list[::2]
-        y = _sequence_to_index(seq[::2], dim_list2)
-        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
-        x = _sequence_to_index(seq2, dim_list2)
-    elif how == 'before_after':
-        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
-        n = len(dim_list)
-        y = _sequence_to_index(reversed(seq[:(n // 2)]),
-                               reversed(dim_list[:(n // 2)]))
-        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
-    else:
-        raise Exception("No such 'how'.")
-
-    return x, y
-
-
-def _sequence_to_latex(seq, style='ket'):
-    """
-    For a sequence of particle states generate LaTeX code.
-
-    Parameters
-    ----------
-    seq : list of ints
-        List of coordinates for each particle.
-
-    style : 'ket' (default), 'bra' or 'bare'
-        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
-
-    Returns
-    -------
-    latex : str
-        LaTeX output.
-
-    """
-    if style == 'ket':
-        latex = "$\\left|{0}\\right\\rangle$"
-    elif style == 'bra':
-        latex = "$\\left\\langle{0}\\right|$"
-    elif style == 'bare':
-        latex = "${0}$"
-    else:
-        raise Exception("No such style.")
-    return latex.format("".join(map(str, seq)))
-
-
-def plot_qubism(ket, theme='light', how='pairs',
-                grid_iteration=1, legend_iteration=0,
-                fig=None, ax=None, figsize=(6, 6)):
-    """
-    Qubism plot for pure states of many qudits.  Works best for spin chains,
-    especially with even number of particles of the same dimension.  Allows to
-    see entanglement between first 2k particles and the rest.
-
-    Parameters
-    ----------
-    ket : Qobj
-        Pure state for plotting.
-
-    theme : 'light' (default) or 'dark'
-        Set coloring theme for mapping complex values into colors.
-        See: complex_array_to_rgb.
-
-    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
-        Type of Qubism plotting.  Options:
-
-        - 'pairs' - typical coordinates,
-        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
-        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
-
-    grid_iteration : int (default 1)
-        Helper lines to be drawn on plot.
-        Show tiles for 2*grid_iteration particles vs all others.
-
-    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
-        Show labels for first ``2*legend_iteration`` particles.  Option
-        'grid_iteration' sets the same number of particles as for
-        grid_iteration.  Option 'all' makes label for all particles.  Typically
-        it should be 0, 1, 2 or perhaps 3.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Notes
-    -----
-    See also [1]_.
-
-    References
-    ----------
-    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
-       and G. Sierra, *Qubism: self-similar visualization of many-body
-       wavefunctions*, `New J. Phys. 14 053028
-       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
-       (2012), open access.
-    """
-
-    if not isket(ket):
-        raise Exception("Qubism works only for pure states, i.e. kets.")
-        # add for dm? (perhaps a separate function, plot_qubism_dm)
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    dim_list = ket.dims[0]
-    n = len(dim_list)
-
-    # for odd number of particles - pixels are rectangular
-    if n % 2 == 1:
-        ket = tensor(ket, Qobj([1] * dim_list[-1]))
-        dim_list = ket.dims[0]
-        n += 1
-
-    ketdata = ket.full()
-
-    if how == 'pairs':
-        dim_list_y = dim_list[::2]
-        dim_list_x = dim_list[1::2]
-    elif how == 'pairs_skewed':
-        dim_list_y = dim_list[::2]
-        dim_list_x = dim_list[1::2]
-        if dim_list_x != dim_list_y:
-            raise Exception("For 'pairs_skewed' pairs " +
-                            "of dimensions need to be the same.")
-    elif how == 'before_after':
-        dim_list_y = list(reversed(dim_list[:(n // 2)]))
-        dim_list_x = dim_list[(n // 2):]
-    else:
-        raise Exception("No such 'how'.")
-
-    size_x = np.prod(dim_list_x)
-    size_y = np.prod(dim_list_y)
-
-    qub = np.zeros([size_x, size_y], dtype=complex)
-    for i in range(ketdata.size):
-        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
-    qub = qub.transpose()
-
-    quadrants_x = np.prod(dim_list_x[:grid_iteration])
-    quadrants_y = np.prod(dim_list_y[:grid_iteration])
-
-    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
-    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
-
-    ax.set_xticks(ticks_x)
-    ax.set_xticklabels([""] * (quadrants_x - 1))
-    ax.set_yticks(ticks_y)
-    ax.set_yticklabels([""] * (quadrants_y - 1))
-    theme2color_of_lines = {'light': '#000000',
-                            'dark': '#FFFFFF'}
-    ax.grid(True, color=theme2color_of_lines[theme])
-    ax.imshow(complex_array_to_rgb(qub, theme=theme),
-              interpolation="none",
-              extent=(0, size_x, 0, size_y))
-
-    if legend_iteration == 'all':
-        label_n = n // 2
-    elif legend_iteration == 'grid_iteration':
-        label_n = grid_iteration
-    else:
-        try:
-            label_n = int(legend_iteration)
-        except:
-            raise Exception("No such option for legend_iteration keyword " +
-                            "argument. Use 'all', 'grid_iteration' or an " +
-                            "integer.")
-
-    if label_n:
-
-        if how == 'before_after':
-            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
-                + dim_list_x[:label_n]
-        else:
-            dim_list_small = []
-            for j in range(label_n):
-                dim_list_small.append(dim_list_y[j])
-                dim_list_small.append(dim_list_x[j])
-
-        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
-        shift_x = 0.5 * scale_x
-        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
-        shift_y = 0.5 * scale_y
-
-        bbox = ax.get_window_extent().transformed(
-            fig.dpi_scale_trans.inverted())
-        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
-        opts = {'fontsize': fontsize,
-                'color': theme2color_of_lines[theme],
-                'horizontalalignment': 'center',
-                'verticalalignment': 'center'}
-        for i in range(np.prod(dim_list_small)):
-            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
-            seq = _index_to_sequence(i, dim_list=dim_list_small)
-            ax.text(scale_x * x + shift_x,
-                    size_y - (scale_y * y + shift_y),
-                    _sequence_to_latex(seq),
-                    **opts)
-    return fig, ax
-
-
-def plot_schmidt(ket, splitting=None,
-                 labels_iteration=(3, 2),
-                 theme='light',
-                 fig=None, ax=None, figsize=(6, 6)):
-    """
-    Plotting scheme related to Schmidt decomposition.
-    Converts a state into a matrix (A_ij -> A_i^j),
-    where rows are first particles and columns - last.
-
-    See also: plot_qubism with how='before_after' for a similar plot.
-
-    Parameters
-    ----------
-    ket : Qobj
-        Pure state for plotting.
-
-    splitting : int
-        Plot for a number of first particles versus the rest.
-        If not given, it is (number of particles + 1) // 2.
-
-    theme : 'light' (default) or 'dark'
-        Set coloring theme for mapping complex values into colors.
-        See: complex_array_to_rgb.
-
-    labels_iteration : int or pair of ints (default (3,2))
-        Number of particles to be shown as tick labels,
-        for first (vertical) and last (horizontal) particles, respectively.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-    if not isket(ket):
-        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    dim_list = ket.dims[0]
-
-    if splitting is None:
-        splitting = (len(dim_list) + 1) // 2
-
-    if isinstance(labels_iteration, int):
-        labels_iteration = labels_iteration, labels_iteration
-
-    ketdata = ket.full()
-
-    dim_list_y = dim_list[:splitting]
-    dim_list_x = dim_list[splitting:]
-
-    size_x = np.prod(dim_list_x)
-    size_y = np.prod(dim_list_y)
-
-    ketdata = ketdata.reshape((size_y, size_x))
-
-    dim_list_small_x = dim_list_x[:labels_iteration[1]]
-    dim_list_small_y = dim_list_y[:labels_iteration[0]]
-
-    quadrants_x = np.prod(dim_list_small_x)
-    quadrants_y = np.prod(dim_list_small_y)
-
-    ticks_x = [size_x / quadrants_x * (i + 0.5)
-               for i in range(quadrants_x)]
-    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
-               for i in range(quadrants_y)]
-
-    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
-                                                      dim_list=dim_list_x))
-                for i in range(quadrants_x)]
-    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
-                                                      dim_list=dim_list_y))
-                for i in range(quadrants_y)]
-
-    ax.set_xticks(ticks_x)
-    ax.set_xticklabels(labels_x)
-    ax.set_yticks(ticks_y)
-    ax.set_yticklabels(labels_y)
-    ax.set_xlabel("last particles")
-    ax.set_ylabel("first particles")
-
-    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
-              interpolation="none",
-              extent=(0, size_x, 0, size_y))
-
-    return fig, ax
+"""
+Functions for visualizing results of quantum dynamics simulations,
+visualizations of quantum states and processes.
+"""
+
+__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
+           'plot_energy_levels', 'fock_distribution',
+           'plot_fock_distribution', 'wigner_fock_distribution',
+           'plot_wigner_fock_distribution', 'plot_wigner',
+           'plot_expectation_values', 'plot_spin_distribution_2d',
+           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
+           'complex_array_to_rgb', 'matrix_histogram',
+           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
+
+import warnings
+import itertools as it
+import numpy as np
+from numpy import pi, array, sin, cos, angle, log2
+
+from packaging.version import parse as parse_version
+
+from . import (
+    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
+)
+from .core.dimensions import flatten
+from .core.superop_reps import _to_superpauli, isqubitdims
+from .wigner import wigner
+from .matplotlib_utilities import complex_phase_cmap
+
+try:
+    import matplotlib.pyplot as plt
+    import matplotlib as mpl
+    from matplotlib import cm
+    from mpl_toolkits.mplot3d import Axes3D
+
+    # Define a custom _axes3D function based on the matplotlib version.
+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+    if parse_version(mpl.__version__) >= parse_version('3.4'):
+        def _axes3D(fig, *args, **kwargs):
+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+            return fig.add_axes(ax)
+    else:
+        def _axes3D(*args, **kwargs):
+            return Axes3D(*args, **kwargs)
+except:
+    pass
+
+
+def plot_wigner_sphere(fig, ax, wigner, reflections):
+    """Plots a coloured Bloch sphere.
+
+    Parameters
+    ----------
+    fig : :obj:`matplotlib.figure.Figure`
+        An instance of :obj:`~matplotlib.figure.Figure`.
+    ax : :obj:`matplotlib.axes.Axes`
+        An axes instance in the given figure.
+    wigner : list of float
+        The wigner transformation at `steps` different theta and phi.
+    reflections : bool
+        If the reflections of the sphere should be plotted as well.
+
+    Notes
+    -----
+    Special thanks to Russell P Rundle for writing this function.
+    """
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+    steps = len(wigner)
+
+    theta = np.linspace(0, np.pi, steps)
+    phi = np.linspace(0, 2 * np.pi, steps)
+    x = np.outer(np.sin(theta), np.cos(phi))
+    y = np.outer(np.sin(theta), np.sin(phi))
+    z = np.outer(np.cos(theta), np.ones(steps))
+    wigner = np.real(wigner)
+    wigner_max = np.real(np.amax(np.abs(wigner)))
+
+    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
+
+    # Plot coloured Bloch sphere:
+    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
+                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
+                    zorder=0.5, antialiased=None)
+
+    if reflections:
+        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+                                 (2*wigner_max))  # bottom
+        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+                                 (2*wigner_max))  # side
+        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+                                 (2*wigner_max))  # back
+
+        # Plot bottom reflection:
+        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
+                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+                        ccount=steps/2, linewidth=0, zorder=0.5,
+                        antialiased=False)
+
+        # Plot side reflection:
+        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
+                        z[0:steps, 0:steps], facecolors=wigner_c3,
+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+                        ccount=steps/2, linewidth=0, zorder=0.5,
+                        antialiased=False)
+
+        # Plot back reflection:
+        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
+                        z[0:steps, 0:steps], facecolors=wigner_c4,
+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+                        ccount=steps/2, linewidth=0, zorder=0.5,
+                        antialiased=False)
+
+    # Create colourbar:
+    m = cm.ScalarMappable(cmap=cm.seismic_r)
+    m.set_array([-wigner_max, wigner_max])
+    plt.colorbar(m, shrink=0.5, aspect=10)
+
+    plt.show()
+
+
+# Adopted from the SciPy Cookbook.
+def _blob(x, y, w, w_max, area, color_fn, ax=None):
+    """
+    Draws a square-shaped blob with the given area (< 1) at
+    the given coordinates.
+    """
+    hs = np.sqrt(area) / 2
+    xcorners = array([x - hs, x + hs, x + hs, x - hs])
+    ycorners = array([y - hs, y - hs, y + hs, y + hs])
+
+    if ax is not None:
+        handle = ax
+    else:
+        handle = plt
+
+    handle.fill(xcorners, ycorners,
+             color=color_fn(w))
+
+
+def _cb_labels(left_dims):
+    """Creates plot labels for matrix elements in the computational basis.
+
+    Parameters
+    ----------
+    left_dims : flat list of ints
+        Dimensions of the left index of a density operator. E. g.
+        [2, 3] for a qubit tensored with a qutrit.
+
+    Returns
+    -------
+    left_labels, right_labels : lists of strings
+        Labels for the left and right indices of a density operator
+        (kets and bras, respectively).
+    """
+    # FIXME: assumes dims, such that we only need left_dims == dims[0].
+    basis_labels = list(map(",".join, it.product(*[
+        map(str, range(dim))
+        for dim in left_dims
+    ])))
+    return [
+        map(fmt.format, basis_labels) for fmt in
+        (
+            r"$\langle{}|$",
+            r"$|{}\rangle$",
+        )
+    ]
+
+
+# Adopted from the SciPy Cookbook.
+def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
+           label_top=True, color_style="scaled"):
+    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
+
+    Parameters
+    ----------
+    rho : qobj
+        Input density matrix or superoperator.
+
+    xlabels : list of strings or False
+        list of x labels
+
+    ylabels : list of strings or False
+        list of y labels
+
+    title : string
+        title of the plot (optional)
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    cmap : a matplotlib colormap instance
+        Color map to use when plotting.
+
+    label_top : bool
+        If True, x-axis labels will be placed on top, otherwise
+        they will appear below the plot.
+
+    color_style : string
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"scaled"`` (default), each color is chosen by
+           passing the absolute value of the corresponding matrix
+           element into `cmap` with the sign of the real part.
+        -  If set to ``"threshold"``, each square is plotted as
+           the maximum of `cmap` for the positive real part and as
+           the minimum for the negative part of the matrix element;
+           note that this generalizes `"threshold"` to complex numbers.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not a quantum object.
+
+    Examples
+    --------
+    >>> import qutip
+    >>>
+    >>> dm = qutip.rand_dm(4)
+    >>> fig, ax = qutip.hinton(dm)
+    >>> fig.show()
+    >>>
+    >>> qutip.settings.colorblind_safe = True
+    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
+    >>> fig.show()
+    >>> qutip.settings.colorblind_safe = False
+    >>>
+    >>> fig, ax = qutip.hinton(dm, color_style="phase")
+    >>> fig.show()
+    """
+
+    # Apply default colormaps.
+    # TODO: abstract this away into something that makes default
+    #       colormaps.
+    cmap = (
+        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
+        if cmap is None else cmap
+    )
+
+    # Extract plotting data W from the input.
+    if isinstance(rho, Qobj):
+        if rho.isoper:
+            W = rho.full()
+
+            # Create default labels if none are given.
+            if xlabels is None or ylabels is None:
+                labels = _cb_labels(rho.dims[0])
+                xlabels = xlabels if xlabels is not None else list(labels[0])
+                ylabels = ylabels if ylabels is not None else list(labels[1])
+
+        elif rho.isoperket:
+            W = vector_to_operator(rho).full()
+        elif rho.isoperbra:
+            W = vector_to_operator(rho.dag()).full()
+        elif rho.issuper:
+            if not isqubitdims(rho.dims):
+                raise ValueError("Hinton plots of superoperators are "
+                                 "currently only supported for qubits.")
+            # Convert to a superoperator in the Pauli basis,
+            # so that all the elements are real.
+            sqobj = _to_superpauli(rho)
+            nq = int(log2(sqobj.shape[0]) / 2)
+            W = sqobj.full().T
+            # Create default labels, too.
+            if (xlabels is None) or (ylabels is None):
+                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+                xlabels = xlabels if xlabels is not None else labels
+                ylabels = ylabels if ylabels is not None else labels
+
+        else:
+            raise ValueError(
+                "Input quantum object must be an operator or superoperator."
+            )
+
+    else:
+        W = rho
+
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
+    else:
+        fig = None
+
+    if not (xlabels or ylabels):
+        ax.axis('off')
+    if title:
+        ax.set_title(title)
+
+    ax.axis('equal')
+    ax.set_frame_on(False)
+
+    height, width = W.shape
+
+    w_max = 1.25 * max(abs(np.array(W)).flatten())
+    if w_max <= 0.0:
+        w_max = 1.0
+
+    # Set color_fn here.
+    if color_style == "scaled":
+        def color_fn(w):
+            w = np.abs(w) * np.sign(np.real(w))
+            return cmap(int((w + w_max) * 256 / (2 * w_max)))
+    elif color_style == "threshold":
+        def color_fn(w):
+            w = np.real(w)
+            return cmap(255 if w > 0 else 0)
+    elif color_style == "phase":
+        def color_fn(w):
+            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
+    else:
+        raise ValueError(
+            "Unknown color style {} for Hinton diagrams.".format(color_style)
+        )
+
+    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
+            color=cmap(128))
+    for x in range(width):
+        for y in range(height):
+            _x = x + 1
+            _y = y + 1
+            _blob(
+                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
+                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
+
+    # color axis
+    vmax = np.pi if color_style == "phase" else abs(W).max()
+    norm = mpl.colors.Normalize(-vmax, vmax)
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+
+    xtics = 0.5 + np.arange(width)
+    # x axis
+    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        ax.set_xticklabels(xlabels)
+        if label_top:
+            ax.xaxis.tick_top()
+    ax.tick_params(axis='x', labelsize=14)
+
+    # y axis
+    ytics = 0.5 + np.arange(height)
+    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        ax.set_yticklabels(list(reversed(ylabels)))
+    ax.tick_params(axis='y', labelsize=14)
+
+    return fig, ax
+
+
+def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
+    """Plots a matrix of values on a sphere
+
+    Parameters
+    ----------
+    theta : float
+        Angle with respect to z-axis
+
+    phi : float
+        Angle in x-y plane
+
+    values : array
+        Data set to be plotted
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    save : bool {False , True}
+        Whether to save the figure or not
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+    if fig is None or ax is None:
+        fig = plt.figure()
+        ax = _axes3D(fig)
+
+    thetam, phim = np.meshgrid(theta, phi)
+    xx = sin(thetam) * cos(phim)
+    yy = sin(thetam) * sin(phim)
+    zz = cos(thetam)
+    r = array(abs(values))
+    ph = angle(values)
+    # normalize color range based on phase angles in list ph
+    nrm = mpl.colors.Normalize(ph.min(), ph.max())
+
+    # plot with facecolors set to cm.jet colormap normalized to nrm
+    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
+                    facecolors=cm.jet(nrm(ph)), linewidth=0)
+    # create new axes on plot for colorbar and shrink it a bit.
+    # pad shifts location of bar with repsect to the main plot
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+
+    # create new colorbar in axes cax with cm jet and normalized to nrm like
+    # our facecolors
+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
+    # add our colorbar label
+    cb1.set_label('Angle')
+
+    if save:
+        plt.savefig("sphereplot.png")
+
+    return fig, ax
+
+
+def _remove_margins(axis):
+    """
+    removes margins about z = 0 and improves the style
+    by monkey patching
+    """
+    def _get_coord_info_new(renderer):
+        mins, maxs, centers, deltas, tc, highs = \
+            _get_coord_info_old(renderer)
+        mins += deltas / 4
+        maxs -= deltas / 4
+        return mins, maxs, centers, deltas, tc, highs
+
+    _get_coord_info_old = axis._get_coord_info
+    axis._get_coord_info = _get_coord_info_new
+
+
+def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
+    """
+    truncates portion of a colormap and returns the new one
+    """
+    if isinstance(cmap, str):
+        cmap = plt.get_cmap(cmap)
+    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
+        'trunc({n},{a:.2f},{b:.2f})'.format(
+            n=cmap.name, a=minval, b=maxval),
+        cmap(np.linspace(minval, maxval, n)))
+    return new_cmap
+
+
+def _stick_to_planes(stick, azim, ax, M, spacing):
+    """adjusts xlim and ylim in way that bars will
+    Stick to xz and yz planes
+    """
+    if stick is True:
+        azim = azim % 360
+        if 0 <= azim <= 90:
+            ax.set_ylim(1 - .5,)
+            ax.set_xlim(1 - .5,)
+        elif 90 < azim <= 180:
+            ax.set_ylim(1 - .5,)
+            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
+        elif 180 < azim <= 270:
+            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
+            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
+        elif 270 < azim < 360:
+            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
+            ax.set_xlim(1 - .5,)
+
+
+def _update_yaxis(spacing, M, ax, ylabels):
+    """
+    updates the y-axis
+    """
+    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        ax.set_yticklabels(ylabels)
+    else:
+        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
+        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
+    ax.tick_params(axis='y', labelsize=14)
+    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
+
+
+def _update_xaxis(spacing, M, ax, xlabels):
+    """
+    updates the x-axis
+    """
+    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        ax.set_xticklabels(xlabels)
+    else:
+        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
+        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
+    ax.tick_params(axis='x', labelsize=14)
+    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
+
+
+def _update_zaxis(ax, z_min, z_max, zticks):
+    """
+    updates the z-axis
+    """
+    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
+    if isinstance(zticks, list):
+        ax.set_zticks(zticks)
+    ax.set_zlim3d([min(z_min, 0), z_max])
+
+
+def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
+                     colorbar=True, fig=None, ax=None, options=None):
+    """
+    Draw a histogram for the matrix M, with the given x and y labels and title.
+
+    Parameters
+    ----------
+    M : Matrix of Qobj
+        The matrix to visualize
+
+    xlabels : list of strings
+        list of x labels
+
+    ylabels : list of strings
+        list of y labels
+
+    title : string
+        title of the plot (optional)
+
+    limits : list/array with two float numbers
+        The z-axis limits [min, max] (optional)
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    colorbar : bool (default: True)
+        show colorbar
+
+    options : dict
+        A dictionary containing extra options for the plot.
+        The names (keys) and values of the options are
+        described below:
+
+        'zticks' : list of numbers
+            A list of z-axis tick locations.
+
+        'cmap' : string (default: 'jet')
+            The name of the color map to use.
+
+        'cmap_min' : float (default: 0.0)
+            The lower bound to truncate the color map at.
+            A value in range 0 - 1. The default, 0, leaves the lower
+            bound of the map unchanged.
+
+        'cmap_max' : float (default: 1.0)
+            The upper bound to truncate the color map at.
+            A value in range 0 - 1. The default, 1, leaves the upper
+            bound of the map unchanged.
+
+        'bars_spacing' : float (default: 0.1)
+            spacing between bars.
+
+        'bars_alpha' : float (default: 1.)
+            transparency of bars, should be in range 0 - 1
+
+        'bars_lw' : float (default: 0.5)
+            linewidth of bars' edges.
+
+        'bars_edgecolor' : color (default: 'k')
+            The colors of the bars' edges.
+            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
+
+        'shade' : bool (default: True)
+            Whether to shade the dark sides of the bars (True) or not (False).
+            The shading is relative to plot's source of light.
+
+        'azim' : float
+            The azimuthal viewing angle.
+
+        'elev' : float
+            The elevation viewing angle.
+
+        'proj_type' : string (default: 'ortho' if ax is not passed)
+            The type of projection ('ortho' or 'persp')
+
+        'stick' : bool (default: False)
+            Changes xlim and ylim in such a way that bars next to
+            XZ and YZ planes will stick to those planes.
+            This option has no effect if ``ax`` is passed as a parameter.
+
+        'cbar_pad' : float (default: 0.04)
+            The fraction of the original axes between the colorbar
+            and the new image axes.
+            (i.e. the padding between the 3D figure and the colorbar).
+
+        'cbar_to_z' : bool (default: False)
+            Whether to set the color of maximum and minimum z-values to the
+            maximum and minimum colors in the colorbar (True) or not (False).
+
+        'figsize' : tuple of two numbers
+            The size of the figure.
+
+    Returns :
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not valid.
+
+    """
+
+    # default options
+    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
+                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
+                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
+                    'shade': False, 'azim': -35, 'elev': 35,
+                    'proj_type': 'ortho', 'stick': False,
+                    'cbar_pad': 0.04, 'cbar_to_z': False}
+
+    # update default_opts from input options
+    if options is None:
+        pass
+    elif isinstance(options, dict):
+        # check if keys in options dict are valid
+        if set(options) - set(default_opts):
+            raise ValueError("invalid key(s) found in options: "
+                             f"{', '.join(set(options) - set(default_opts))}")
+        else:
+            # updating default options
+            default_opts.update(options)
+    else:
+        raise ValueError("options must be a dictionary")
+
+    if isinstance(M, Qobj):
+        # extract matrix data from Qobj
+        M = M.full()
+
+    n = np.size(M)
+    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+    xpos = xpos.T.flatten() + 0.5
+    ypos = ypos.T.flatten() + 0.5
+    zpos = np.zeros(n)
+    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
+    dz = np.real(M.flatten())
+
+    if isinstance(limits, list) and len(limits) == 2:
+        z_min = limits[0]
+        z_max = limits[1]
+    else:
+        z_min = min(dz)
+        z_max = max(dz)
+        if z_min == z_max:
+            z_min -= 0.1
+            z_max += 0.1
+
+    if default_opts['cbar_to_z']:
+        norm = mpl.colors.Normalize(min(dz), max(dz))
+    else:
+        norm = mpl.colors.Normalize(z_min, z_max)
+    cmap = _truncate_colormap(default_opts['cmap'],
+                              default_opts['cmap_min'],
+                              default_opts['cmap_max'])
+    colors = cmap(norm(dz))
+
+    if ax is None:
+        fig = plt.figure(figsize=default_opts['figsize'])
+        ax = _axes3D(fig,
+                     azim=default_opts['azim'] % 360,
+                     elev=default_opts['elev'] % 360)
+        ax.set_proj_type(default_opts['proj_type'])
+
+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
+             edgecolors=default_opts['bars_edgecolor'],
+             linewidths=default_opts['bars_lw'],
+             alpha=default_opts['bars_alpha'],
+             shade=default_opts['shade'])
+    # remove vertical lines on xz and yz plane
+    ax.yaxis._axinfo["grid"]['linewidth'] = 0
+    ax.xaxis._axinfo["grid"]['linewidth'] = 0
+
+    if title:
+        ax.set_title(title)
+
+    # x axis
+    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
+
+    # y axis
+    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
+
+    # z axis
+    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
+
+    # stick to xz and yz plane
+    _stick_to_planes(default_opts['stick'],
+                     default_opts['azim'], ax, M,
+                     default_opts['bars_spacing'])
+
+    # color axis
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
+                                         pad=default_opts['cbar_pad'])
+        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+
+    # removing margins
+    _remove_margins(ax.xaxis)
+    _remove_margins(ax.yaxis)
+    _remove_margins(ax.zaxis)
+
+    return fig, ax
+
+
+def matrix_histogram_complex(M, xlabels=None, ylabels=None,
+                             title=None, limits=None, phase_limits=None,
+                             colorbar=True, fig=None, ax=None,
+                             threshold=None):
+    """
+    Draw a histogram for the amplitudes of matrix M, using the argument
+    of each element for coloring the bars, with the given x and y labels
+    and title.
+
+    Parameters
+    ----------
+    M : Matrix of Qobj
+        The matrix to visualize
+
+    xlabels : list of strings
+        list of x labels
+
+    ylabels : list of strings
+        list of y labels
+
+    title : string
+        title of the plot (optional)
+
+    limits : list/array with two float numbers
+        The z-axis limits [min, max] (optional)
+
+    phase_limits : list/array with two float numbers
+        The phase-axis (colorbar) limits [min, max] (optional)
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    threshold: float (None)
+        Threshold for when bars of smaller height should be transparent. If
+        not set, all bars are colored according to the color map.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not valid.
+
+    """
+
+    if isinstance(M, Qobj):
+        # extract matrix data from Qobj
+        M = M.full()
+
+    n = np.size(M)
+    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+    xpos = xpos.T.flatten() - 0.5
+    ypos = ypos.T.flatten() - 0.5
+    zpos = np.zeros(n)
+    dx = dy = 0.8 * np.ones(n)
+    Mvec = M.flatten()
+    dz = abs(Mvec)
+
+    # make small numbers real, to avoid random colors
+    idx, = np.where(abs(Mvec) < 0.001)
+    Mvec[idx] = abs(Mvec[idx])
+
+    if phase_limits:  # check that limits is a list type
+        phase_min = phase_limits[0]
+        phase_max = phase_limits[1]
+    else:
+        phase_min = -pi
+        phase_max = pi
+
+    norm = mpl.colors.Normalize(phase_min, phase_max)
+    cmap = complex_phase_cmap()
+
+    colors = cmap(norm(angle(Mvec)))
+    if threshold is not None:
+        colors[:, 3] = 1 * (dz > threshold)
+
+    if ax is None:
+        fig = plt.figure()
+        ax = _axes3D(fig, azim=-35, elev=35)
+
+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
+
+    if title:
+        ax.set_title(title)
+
+    # x axis
+    xtics = -0.5 + np.arange(M.shape[0])
+    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        ax.set_xticklabels(xlabels)
+    ax.tick_params(axis='x', labelsize=12)
+
+    # y axis
+    ytics = -0.5 + np.arange(M.shape[1])
+    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        ax.set_yticklabels(ylabels)
+    ax.tick_params(axis='y', labelsize=12)
+
+    # z axis
+    if limits and isinstance(limits, list):
+        ax.set_zlim3d(limits)
+    else:
+        ax.set_zlim3d([0, 1])  # use min/max
+    # ax.set_zlabel('abs')
+
+    # color axis
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
+        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+        cb.set_ticklabels(
+            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
+        cb.set_label('arg')
+
+    return fig, ax
+
+
+def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
+                       figsize=(8, 12), fig=None, ax=None):
+    """
+    Plot the energy level diagrams for a list of Hamiltonians. Include
+    up to N energy levels. For each element in H_list, the energy
+    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
+    where n is the index of an element in H_list.
+
+    Parameters
+    ----------
+
+        H_list : List of Qobj
+            A list of Hamiltonians.
+
+        labels : List of string
+            A list of labels for each Hamiltonian
+
+        show_ylabels : Bool (default False)
+            Show y labels to the left of energy levels of the initial
+            Hamiltonian.
+
+        N : int
+            The number of energy levels to plot
+
+        figsize : tuple (int,int)
+            The size of the figure (width, height).
+
+        fig : a matplotlib Figure instance
+            The Figure canvas in which the plot will be drawn.
+
+        ax : a matplotlib axes instance
+            The axes context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+
+        ValueError
+            Input argument is not valid.
+
+    """
+
+    if not isinstance(H_list, list):
+        raise ValueError("H_list must be a list of Qobj instances")
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    H = H_list[0]
+    N = H.shape[0] if N == 0 else min(H.shape[0], N)
+
+    xticks = []
+    yticks = []
+
+    x = 0
+    evals0 = H.eigenenergies(eigvals=N)
+    for e_idx, e in enumerate(evals0[:N]):
+        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+        yticks.append(e)
+    xticks.append(x + 1)
+    x += 2
+
+    for H1 in H_list[1:]:
+
+        H = H + H1
+        evals1 = H.eigenenergies()
+
+        for e_idx, e in enumerate(evals1[:N]):
+            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
+        x += 1
+
+        for e_idx, e in enumerate(evals1[:N]):
+            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+        xticks.append(x + 1)
+        x += 2
+
+        evals0 = evals1
+
+    ax.set_frame_on(False)
+
+    if show_ylabels:
+        yticks = np.unique(np.around(yticks, 1))
+        ax.set_yticks(yticks)
+    else:
+        ax.axes.get_yaxis().set_visible(False)
+
+    if labels:
+        ax.get_xaxis().tick_bottom()
+        ax.set_xticks(xticks)
+        ax.set_xticklabels(labels, fontsize=16)
+    else:
+        ax.axes.get_xaxis().set_visible(False)
+
+    return fig, ax
+
+
+def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
+                         figsize=(8, 12), fig=None, ax=None):
+    warnings.warn("Deprecated: Use plot_energy_levels")
+    return plot_energy_levels(H_list, N=N, labels=labels,
+                              show_ylabels=show_ylabels,
+                              figsize=figsize, fig=fig, ax=ax)
+
+
+def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
+                           figsize=(8, 6), title=None, unit_y_range=True):
+    """
+    Plot the Fock distribution for a density matrix (or ket) that describes
+    an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    title : string
+        An optional title for the figure.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    if isket(rho):
+        rho = ket2dm(rho)
+
+    N = rho.shape[0]
+
+    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
+           color="green", alpha=0.6, width=0.8)
+    if unit_y_range:
+        ax.set_ylim(0, 1)
+
+    ax.set_xlim(-.5 + offset, N + offset)
+    ax.set_xlabel('Fock number', fontsize=12)
+    ax.set_ylabel('Occupation probability', fontsize=12)
+
+    if title:
+        ax.set_title(title)
+
+    return fig, ax
+
+
+def fock_distribution(rho, offset=0, fig=None, ax=None,
+                      figsize=(8, 6), title=None, unit_y_range=True):
+    warnings.warn("Deprecated: Use plot_fock_distribution")
+    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
+                                  figsize=figsize, title=title,
+                                  unit_y_range=unit_y_range)
+
+
+def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
+                cmap=None, alpha_max=7.5, colorbar=False,
+                method='clenshaw', projection='2d'):
+    """
+    Plot the the Wigner function for a density matrix (or ket) that describes
+    an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    cmap : a matplotlib cmap instance
+        The colormap.
+
+    alpha_max : float
+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig and not ax:
+        if projection == '2d':
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+        elif projection == '3d':
+            fig = plt.figure(figsize=figsize)
+            ax = fig.add_subplot(1, 1, 1, projection='3d')
+        else:
+            raise ValueError('Unexpected value of projection keyword argument')
+
+    if isket(rho):
+        rho = ket2dm(rho)
+
+    xvec = np.linspace(-alpha_max, alpha_max, 200)
+    W0 = wigner(rho, xvec, xvec, method=method)
+
+    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
+
+    wlim = abs(W).max()
+
+    if cmap is None:
+        cmap = cm.get_cmap('RdBu')
+
+    if projection == '2d':
+        cf = ax.contourf(xvec, yvec, W, 100,
+                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
+    elif projection == '3d':
+        X, Y = np.meshgrid(xvec, xvec)
+        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
+                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
+    else:
+        raise ValueError('Unexpected value of projection keyword argument.')
+
+    if xvec is not yvec:
+        ax.set_ylim(xvec.min(), xvec.max())
+
+    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
+    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+
+    if colorbar:
+        fig.colorbar(cf, ax=ax)
+
+    ax.set_title("Wigner function", fontsize=12)
+
+    return fig, ax
+
+
+def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
+                                  cmap=None, alpha_max=7.5, colorbar=False,
+                                  method='iterative', projection='2d'):
+    """
+    Plot the Fock distribution and the Wigner function for a density matrix
+    (or ket) that describes an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    axes : a list of two matplotlib axes instances
+        The axes context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    cmap : a matplotlib cmap instance
+        The colormap.
+
+    alpha_max : float
+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    method : string {'iterative', 'laguerre', 'fft'}
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig and not axes:
+        if projection == '2d':
+            fig, axes = plt.subplots(1, 2, figsize=figsize)
+        elif projection == '3d':
+            fig = plt.figure(figsize=figsize)
+            axes = [fig.add_subplot(1, 2, 1),
+                    fig.add_subplot(1, 2, 2, projection='3d')]
+        else:
+            raise ValueError('Unexpected value of projection keyword argument')
+
+    if isket(rho):
+        rho = ket2dm(rho)
+
+    plot_fock_distribution(rho, fig=fig, ax=axes[0])
+    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
+                alpha_max=alpha_max, colorbar=colorbar, method=method,
+                projection=projection)
+
+    return fig, axes
+
+
+def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
+                             cmap=None, alpha_max=7.5, colorbar=False,
+                             method='iterative'):
+    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
+    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
+                                         figsize=figsize, cmap=cmap,
+                                         alpha_max=alpha_max,
+                                         colorbar=colorbar,
+                                         method=method)
+
+
+def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
+                            fig=None, axes=None, figsize=(8, 4)):
+    """
+    Visualize the results (expectation values) for an evolution solver.
+    `results` is assumed to be an instance of Result, or a list of Result
+    instances.
+
+    Parameters
+    ----------
+    results : (list of) :class:`qutip.solver.Result`
+        List of results objects returned by any of the QuTiP evolution solvers.
+
+    ylabels : list of strings
+        The y-axis labels. List should be of the same length as `results`.
+
+    title : string
+        The title of the figure.
+
+    show_legend : bool
+        Whether or not to show the legend.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    axes : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+    if not isinstance(results, list):
+        results = [results]
+
+    n_e_ops = max([len(result.expect) for result in results])
+
+    if not fig or not axes:
+        if not figsize:
+            figsize = (12, 3 * n_e_ops)
+        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
+                                 figsize=figsize, squeeze=False)
+
+    for r_idx, result in enumerate(results):
+        for e_idx, e in enumerate(result.expect):
+            axes[e_idx, 0].plot(result.times, e,
+                                label="%s [%d]" % (result.solver, e_idx))
+
+    if title:
+        fig.suptitle(title)
+
+    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
+    for n in range(n_e_ops):
+        if show_legend:
+            axes[n, 0].legend()
+        if ylabels:
+            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
+
+    return fig, axes
+
+
+def plot_spin_distribution_2d(P, THETA, PHI,
+                              fig=None, ax=None, figsize=(8, 8)):
+    """
+    Plot a spin distribution function (given as meshgrid data) with a 2D
+    projection where the surface of the unit sphere is mapped on the unit disk.
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig or not ax:
+        if not figsize:
+            figsize = (8, 8)
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    Y = (THETA - pi / 2) / (pi / 2)
+    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+    else:
+        cmap = cm.RdYlBu
+
+    ax.pcolor(X, Y, P.real, cmap=cmap)
+    ax.set_xlabel(r'$\varphi$', fontsize=18)
+    ax.set_ylabel(r'$\theta$', fontsize=18)
+
+    ax.set_xticks([-1, 0, 1])
+    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
+    ax.set_yticks([-1, 0, 1])
+    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
+
+    return fig, ax
+
+
+def plot_spin_distribution_3d(P, THETA, PHI,
+                              fig=None, ax=None, figsize=(8, 6)):
+    """Plots a matrix of values on a sphere
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+
+    if fig is None or ax is None:
+        fig = plt.figure(figsize=figsize)
+        ax = _axes3D(fig, azim=-35, elev=35)
+
+    xx = sin(THETA) * cos(PHI)
+    yy = sin(THETA) * sin(PHI)
+    zz = cos(THETA)
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+        norm = mpl.colors.Normalize(-P.max(), P.max())
+    else:
+        cmap = cm.RdYlBu
+        norm = mpl.colors.Normalize(P.min(), P.max())
+
+    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+                    facecolors=cmap(norm(P)), linewidth=0)
+
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+    cb1.set_label('magnitude')
+
+    return fig, ax
+
+
+#
+# Qubism and other qubistic visualizations
+#
+def complex_array_to_rgb(X, theme='light', rmax=None):
+    """
+    Makes an array of complex number and converts it to an array of [r, g, b],
+    where phase gives hue and saturation/value are given by the absolute value.
+    Especially for use with imshow for complex plots.
+
+    For more info on coloring, see:
+        Emilia Petrisor,
+        Visualizing complex-valued functions with Matplotlib and Mayavi
+        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
+
+    Parameters
+    ----------
+    X : array
+        Array (of any dimension) of complex numbers.
+
+    theme : 'light' (default) or 'dark'
+        Set coloring theme for mapping complex values into colors.
+
+    rmax : float
+        Maximal abs value for color normalization.
+        If None (default), uses np.abs(X).max().
+
+    Returns
+    -------
+    Y : array
+        Array of colors (of shape X.shape + (3,)).
+
+    """
+
+    absmax = rmax or np.abs(X).max()
+    if absmax == 0.:
+        absmax = 1.
+    Y = np.zeros(X.shape + (3,), dtype='float')
+    Y[..., 0] = np.angle(X) / (2 * pi) % 1
+    if theme == 'light':
+        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
+        Y[..., 2] = 1
+    elif theme == 'dark':
+        Y[..., 1] = 1
+        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
+    Y = mpl.colors.hsv_to_rgb(Y)
+    return Y
+
+
+def _index_to_sequence(i, dim_list):
+    """
+    For a matrix entry with index i it returns state it corresponds to.
+    In particular, for dim_list=[2]*n it returns i written as a binary number.
+
+    Parameters
+    ----------
+    i : int
+        Index in a matrix.
+
+    dim_list : list of int
+        List of dimensions of consecutive particles.
+
+    Returns
+    -------
+    seq : list
+        List of coordinates for each particle.
+
+    """
+    res = []
+    j = i
+    for d in reversed(dim_list):
+        j, s = divmod(j, d)
+        res.append(s)
+    return list(reversed(res))
+
+
+def _sequence_to_index(seq, dim_list):
+    """
+    Inverse of _index_to_sequence.
+
+    Parameters
+    ----------
+    seq : list of ints
+        List of coordinates for each particle.
+
+    dim_list : list of int
+        List of dimensions of consecutive particles.
+
+    Returns
+    -------
+    i : list
+        Index in a matrix.
+
+    """
+    i = 0
+    for s, d in zip(seq, dim_list):
+        i *= d
+        i += s
+
+    return i
+
+
+def _to_qubism_index_pair(i, dim_list, how='pairs'):
+    """
+    For a matrix entry with index i
+    it returns x, y coordinates in qubism mapping.
+
+    Parameters
+    ----------
+    i : int
+        Index in a matrix.
+
+    dim_list : list of int
+        List of dimensions of consecutive particles.
+
+    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
+        Type of qubistic plot.
+
+    Returns
+    -------
+    x, y : tuple of ints
+        List of coordinates for each particle.
+
+    """
+    seq = _index_to_sequence(i, dim_list)
+
+    if how == 'pairs':
+        y = _sequence_to_index(seq[::2], dim_list[::2])
+        x = _sequence_to_index(seq[1::2], dim_list[1::2])
+    elif how == 'pairs_skewed':
+        dim_list2 = dim_list[::2]
+        y = _sequence_to_index(seq[::2], dim_list2)
+        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
+        x = _sequence_to_index(seq2, dim_list2)
+    elif how == 'before_after':
+        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
+        n = len(dim_list)
+        y = _sequence_to_index(reversed(seq[:(n // 2)]),
+                               reversed(dim_list[:(n // 2)]))
+        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
+    else:
+        raise Exception("No such 'how'.")
+
+    return x, y
+
+
+def _sequence_to_latex(seq, style='ket'):
+    """
+    For a sequence of particle states generate LaTeX code.
+
+    Parameters
+    ----------
+    seq : list of ints
+        List of coordinates for each particle.
+
+    style : 'ket' (default), 'bra' or 'bare'
+        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
+
+    Returns
+    -------
+    latex : str
+        LaTeX output.
+
+    """
+    if style == 'ket':
+        latex = "$\\left|{0}\\right\\rangle$"
+    elif style == 'bra':
+        latex = "$\\left\\langle{0}\\right|$"
+    elif style == 'bare':
+        latex = "${0}$"
+    else:
+        raise Exception("No such style.")
+    return latex.format("".join(map(str, seq)))
+
+
+def plot_qubism(ket, theme='light', how='pairs',
+                grid_iteration=1, legend_iteration=0,
+                fig=None, ax=None, figsize=(6, 6)):
+    """
+    Qubism plot for pure states of many qudits.  Works best for spin chains,
+    especially with even number of particles of the same dimension.  Allows to
+    see entanglement between first 2k particles and the rest.
+
+    Parameters
+    ----------
+    ket : Qobj
+        Pure state for plotting.
+
+    theme : 'light' (default) or 'dark'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
+        Type of Qubism plotting.  Options:
+
+        - 'pairs' - typical coordinates,
+        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
+        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
+
+    grid_iteration : int (default 1)
+        Helper lines to be drawn on plot.
+        Show tiles for 2*grid_iteration particles vs all others.
+
+    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
+        Show labels for first ``2*legend_iteration`` particles.  Option
+        'grid_iteration' sets the same number of particles as for
+        grid_iteration.  Option 'all' makes label for all particles.  Typically
+        it should be 0, 1, 2 or perhaps 3.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Notes
+    -----
+    See also [1]_.
+
+    References
+    ----------
+    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
+       and G. Sierra, *Qubism: self-similar visualization of many-body
+       wavefunctions*, `New J. Phys. 14 053028
+       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
+       (2012), open access.
+    """
+
+    if not isket(ket):
+        raise Exception("Qubism works only for pure states, i.e. kets.")
+        # add for dm? (perhaps a separate function, plot_qubism_dm)
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    dim_list = ket.dims[0]
+    n = len(dim_list)
+
+    # for odd number of particles - pixels are rectangular
+    if n % 2 == 1:
+        ket = tensor(ket, Qobj([1] * dim_list[-1]))
+        dim_list = ket.dims[0]
+        n += 1
+
+    ketdata = ket.full()
+
+    if how == 'pairs':
+        dim_list_y = dim_list[::2]
+        dim_list_x = dim_list[1::2]
+    elif how == 'pairs_skewed':
+        dim_list_y = dim_list[::2]
+        dim_list_x = dim_list[1::2]
+        if dim_list_x != dim_list_y:
+            raise Exception("For 'pairs_skewed' pairs " +
+                            "of dimensions need to be the same.")
+    elif how == 'before_after':
+        dim_list_y = list(reversed(dim_list[:(n // 2)]))
+        dim_list_x = dim_list[(n // 2):]
+    else:
+        raise Exception("No such 'how'.")
+
+    size_x = np.prod(dim_list_x)
+    size_y = np.prod(dim_list_y)
+
+    qub = np.zeros([size_x, size_y], dtype=complex)
+    for i in range(ketdata.size):
+        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
+    qub = qub.transpose()
+
+    quadrants_x = np.prod(dim_list_x[:grid_iteration])
+    quadrants_y = np.prod(dim_list_y[:grid_iteration])
+
+    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
+    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+
+    ax.set_xticks(ticks_x)
+    ax.set_xticklabels([""] * (quadrants_x - 1))
+    ax.set_yticks(ticks_y)
+    ax.set_yticklabels([""] * (quadrants_y - 1))
+    theme2color_of_lines = {'light': '#000000',
+                            'dark': '#FFFFFF'}
+    ax.grid(True, color=theme2color_of_lines[theme])
+    ax.imshow(complex_array_to_rgb(qub, theme=theme),
+              interpolation="none",
+              extent=(0, size_x, 0, size_y))
+
+    if legend_iteration == 'all':
+        label_n = n // 2
+    elif legend_iteration == 'grid_iteration':
+        label_n = grid_iteration
+    else:
+        try:
+            label_n = int(legend_iteration)
+        except:
+            raise Exception("No such option for legend_iteration keyword " +
+                            "argument. Use 'all', 'grid_iteration' or an " +
+                            "integer.")
+
+    if label_n:
+
+        if how == 'before_after':
+            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
+                + dim_list_x[:label_n]
+        else:
+            dim_list_small = []
+            for j in range(label_n):
+                dim_list_small.append(dim_list_y[j])
+                dim_list_small.append(dim_list_x[j])
+
+        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
+        shift_x = 0.5 * scale_x
+        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
+        shift_y = 0.5 * scale_y
+
+        bbox = ax.get_window_extent().transformed(
+            fig.dpi_scale_trans.inverted())
+        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
+        opts = {'fontsize': fontsize,
+                'color': theme2color_of_lines[theme],
+                'horizontalalignment': 'center',
+                'verticalalignment': 'center'}
+        for i in range(np.prod(dim_list_small)):
+            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
+            seq = _index_to_sequence(i, dim_list=dim_list_small)
+            ax.text(scale_x * x + shift_x,
+                    size_y - (scale_y * y + shift_y),
+                    _sequence_to_latex(seq),
+                    **opts)
+    return fig, ax
+
+
+def plot_schmidt(ket, splitting=None,
+                 labels_iteration=(3, 2),
+                 theme='light',
+                 fig=None, ax=None, figsize=(6, 6)):
+    """
+    Plotting scheme related to Schmidt decomposition.
+    Converts a state into a matrix (A_ij -> A_i^j),
+    where rows are first particles and columns - last.
+
+    See also: plot_qubism with how='before_after' for a similar plot.
+
+    Parameters
+    ----------
+    ket : Qobj
+        Pure state for plotting.
+
+    splitting : int
+        Plot for a number of first particles versus the rest.
+        If not given, it is (number of particles + 1) // 2.
+
+    theme : 'light' (default) or 'dark'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    labels_iteration : int or pair of ints (default (3,2))
+        Number of particles to be shown as tick labels,
+        for first (vertical) and last (horizontal) particles, respectively.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+    if not isket(ket):
+        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    dim_list = ket.dims[0]
+
+    if splitting is None:
+        splitting = (len(dim_list) + 1) // 2
+
+    if isinstance(labels_iteration, int):
+        labels_iteration = labels_iteration, labels_iteration
+
+    ketdata = ket.full()
+
+    dim_list_y = dim_list[:splitting]
+    dim_list_x = dim_list[splitting:]
+
+    size_x = np.prod(dim_list_x)
+    size_y = np.prod(dim_list_y)
+
+    ketdata = ketdata.reshape((size_y, size_x))
+
+    dim_list_small_x = dim_list_x[:labels_iteration[1]]
+    dim_list_small_y = dim_list_y[:labels_iteration[0]]
+
+    quadrants_x = np.prod(dim_list_small_x)
+    quadrants_y = np.prod(dim_list_small_y)
+
+    ticks_x = [size_x / quadrants_x * (i + 0.5)
+               for i in range(quadrants_x)]
+    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
+               for i in range(quadrants_y)]
+
+    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
+                                                      dim_list=dim_list_x))
+                for i in range(quadrants_x)]
+    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
+                                                      dim_list=dim_list_y))
+                for i in range(quadrants_y)]
+
+    ax.set_xticks(ticks_x)
+    ax.set_xticklabels(labels_x)
+    ax.set_yticks(ticks_y)
+    ax.set_yticklabels(labels_y)
+    ax.set_xlabel("last particles")
+    ax.set_ylabel("first particles")
+
+    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
+              interpolation="none",
+              extent=(0, size_x, 0, size_y))
+
+    return fig, ax
diff --git a/qutip/wigner.py b/qutip/wigner.py
index 48abd66385..cc0a130fbd 100644
--- a/qutip/wigner.py
+++ b/qutip/wigner.py
@@ -1,1003 +1,1003 @@
-__all__ = [
-    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
-    'wigner_transform',
-]
-
-import numpy as np
-import warnings
-from numpy import (
-    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
-)
-import scipy.sparse as sp
-import scipy.fftpack as ft
-import scipy.linalg as la
-import scipy.special
-from scipy.special import genlaguerre, binom, sph_harm, factorial
-
-import qutip
-from qutip import Qobj, ket2dm, jmat
-from .solver.parallel import parallel_map
-from .utilities import clebsch
-from .core import data as _data
-from .core.data.eigen import eigh
-
-
-def wigner_transform(psi, j, fullparity, steps, slicearray):
-    """takes the density matrix or state vector of any finite state and
-    generates the Wigner function for that state on a sphere, generating a spin
-    Wigner function useful for displaying the quasi-probability for a qubit or
-    any qudit. For the standard, continuous-variable Wigner function for
-    position and momentum variables, wigner() should be used.
-
-    Parameters
-    ----------
-        psi : qobj
-              a state vector or density matrix.
-        j : int
-            the total angular momentum of the quantum state.
-        fullparity : bool
-                     should the parity of the full SU space be used?
-        steps : int
-                number of points at which the Wigner transform is calculated.
-        slicearray : list of str
-                     the angle slice to be used for each particle in case of a
-                     multi-particle quantum state. 'l' yields an equal angle
-                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
-
-    Returns
-    ----------
-        wigner : list of float
-                 the wigner transformation at `steps` different theta and phi.
-
-    Raises
-    ------
-    ComplexWarning
-        This can be ignored as it is caused due to rounding errors.
-
-    Notes
-    ------
-    See example notebook wigner_visualisation.
-
-    References
-    ------
-    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
-        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
-    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
-        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
-    """
-    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
-        raise TypeError('Input state is not a valid operator.')
-
-    if psi.isket or psi.isbra:
-        rho = psi.proj()
-    else:
-        rho = psi
-
-    sun = 2   # The order of the SU group
-
-    # calculate total number of particles in quantum state:
-    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
-
-    theta = np.zeros((N, steps))
-    phi = np.zeros((N, steps))
-
-    for i in range(N):
-        theta[i, :] = np.linspace(0, np.pi, steps)
-        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
-
-    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
-
-    wigner = np.zeros((steps, steps))
-    if fullparity:
-        pari = _parity(sun**N, j)
-    else:
-        pari = _parity(sun, j)
-    for t in range(steps):
-        for p in range(steps):
-            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
-            kernel = _data.dense.fast_from_numpy(kernel)
-            wigner[t, p] = _data.expect(rho.data, kernel).real
-    return wigner
-
-
-def _parity(N, j):
-    """Private function to calculate the parity of the quantum system.
-    """
-    if j == 0.5:
-        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
-        return pi / N
-    elif j > 0.5:
-        mult = np.int32(2 * j + 1)
-        matrix = np.zeros((mult, mult))
-        foo = np.ones(mult)
-        for n in np.arange(-j, j + 1, 1):
-            for l in np.arange(0, mult, 1):
-                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
-            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
-        return matrix / mult
-
-
-def _lambda_f(N):
-    """Private function needed for the calculation of the parity.
-    """
-    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
-    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
-    return matrix
-
-
-def _kernelsu2(theta, phi, N, j, parity, fullparity):
-    """Private function that calculates the kernel for the SU2 unitary group.
-    """
-    U = np.ones(1)
-    # calculate the total rotation matrix (tensor product for each particle):
-    for i in range(0, N):
-        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
-    if not fullparity:
-        op_parity = parity   # The parity for a one particle system
-        for i in range(1, N):
-            parity = np.kron(parity, op_parity)
-    matrix = U @ parity @ U.conj().T
-    return matrix
-
-
-def _rotation_matrix(theta, phi, j):
-    """Private function to calculate the rotation operator for the SU2 kernel.
-    """
-    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
-           la.expm(1j * theta * jmat(j, 'y').full())
-
-
-def _angle_slice(slicearray, theta, phi):
-    """Private function to modify theta and phi for angle slicing.
-    """
-    xind = np.where(slicearray == 'x')
-    theta[xind, :] = np.pi - theta[xind, :]
-    phi[xind, :] = -phi[xind, :]
-    yind = np.where(slicearray == 'y')
-    theta[yind, :] = np.pi - theta[yind, :]
-    phi[yind, :] = np.pi - phi[yind, :]
-    zind = np.where(slicearray == 'z')
-    phi[zind, :] = phi[zind, :] + np.pi
-    return theta, phi
-
-
-def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
-           sparse=False, parfor=False):
-    """Wigner function for a state vector or density matrix at points
-    `xvec + i * yvec`.
-
-    Parameters
-    ----------
-
-    state : qobj
-        A state vector or density matrix.
-
-    xvec : array_like
-        x-coordinates at which to calculate the Wigner function.
-
-    yvec : array_like
-        y-coordinates at which to calculate the Wigner function.  Does not
-        apply to the 'fft' method.
-
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation
-        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
-        value `hbar=1`.
-
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
-        and 'iterative' use an iterative method to evaluate the Wigner functions for density
-        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
-        in scipy for the same task. The 'fft' method evaluates the Fourier
-        transform of the density matrix. The 'iterative' method is default, and
-        in general recommended, but the 'laguerre' method is more efficient for
-        very sparse density matrices (e.g., superpositions of Fock states in a
-        large Hilbert space). The 'clenshaw' method is the preferred method for
-        dealing with density matrices that have a large number of excitations
-        (>~50). 'clenshaw' is a fast and numerically stable method.
-
-    sparse : bool {False, True}
-        Tells the default solver whether or not to keep the input density
-        matrix in sparse format.  As the dimensions of the density matrix
-        grow, setthing this flag can result in increased performance.
-
-    parfor : bool {False, True}
-        Flag for calculating the Laguerre polynomial based Wigner function
-        method='laguerre' in parallel using the parfor function.
-
-
-    Returns
-    -------
-
-    W : array
-        Values representing the Wigner function calculated over the specified
-        range [xvec,yvec].
-
-    yvex : array
-        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
-        transform.
-
-    Notes
-    -----
-    The 'fft' method accepts only an xvec input for the x-coordinate.
-    The y-coordinates are calculated internally.
-
-    References
-    ----------
-
-    Ulf Leonhardt,
-    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
-
-    """
-
-    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
-        raise TypeError('Input state is not a valid operator.')
-
-    if method == 'fft':
-        return _wigner_fourier(psi, xvec, g)
-
-    if psi.isket or psi.isbra:
-        rho = psi.proj()
-    else:
-        rho = psi
-
-    if method == 'iterative':
-        return _wigner_iterative(rho, xvec, yvec, g)
-
-    elif method == 'laguerre':
-        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
-
-    elif method == 'clenshaw':
-        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
-
-    else:
-        raise TypeError(
-            "method must be either 'iterative', 'laguerre', or 'fft'.")
-
-
-def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
-    r"""
-    Using an iterative method to evaluate the wigner functions for the Fock
-    state :math:`|m><n|`.
-
-    The Wigner function is calculated as
-    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
-    function for the density matrix :math:`|m><n|`.
-
-    In this implementation, for each row m, Wlist contains the Wigner functions
-    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
-    calculated, the corresponding contribution is added to the total Wigner
-    function, weighted by the corresponding element in the density matrix
-    :math:`rho_{mn}`.
-    """
-
-    M = np.prod(rho.shape[0])
-    X, Y = meshgrid(xvec, yvec)
-    A = 0.5 * g * (X + 1.0j * Y)
-
-    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
-    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
-
-    W = real(rho[0, 0]) * real(Wlist[0])
-    for n in range(1, M):
-        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
-        W += 2 * real(rho[0, n] * Wlist[n])
-
-    for m in range(1, M):
-        temp = copy(Wlist[m])
-        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
-
-        # Wlist[m] = Wigner function for |m><m|
-        W += real(rho[m, m] * Wlist[m])
-
-        for n in range(m + 1, M):
-            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
-            temp = copy(Wlist[n])
-            Wlist[n] = temp2
-
-            # Wlist[n] = Wigner function for |m><n|
-            W += 2 * real(rho[m, n] * Wlist[n])
-
-    return 0.5 * W * g ** 2
-
-
-def _wigner_laguerre(rho, xvec, yvec, g, parallel):
-    r"""
-    Using Laguerre polynomials from scipy to evaluate the Wigner function for
-    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
-    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
-    """
-
-    M = np.prod(rho.shape[0])
-    X, Y = meshgrid(xvec, yvec)
-    A = 0.5 * g * (X + 1.0j * Y)
-    W = zeros(np.shape(A))
-
-    # compute wigner functions for density matrices |m><n| and
-    # weight by all the elements in the density matrix
-    B = 4 * abs(A) ** 2
-    if sp.isspmatrix_csr(rho.data):
-        # for compress sparse row matrices
-        if parallel:
-            iterator = (
-                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
-            W1_out = parallel_map(_par_wig_eval, iterator)
-            W += sum(W1_out)
-        else:
-            for m in range(len(rho.data.indptr) - 1):
-                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
-                    n = rho.data.indices[jj]
-
-                    if m == n:
-                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-
-                    elif n > m:
-                        W += 2.0 * real(rho[m, n] * (-1) ** m *
-                                        (2 * A) ** (n - m) *
-                                        sqrt(factorial(m) / factorial(n)) *
-                                        genlaguerre(m, n - m)(B))
-    else:
-        # for dense density matrices
-        B = 4 * abs(A) ** 2
-        for m in range(M):
-            if abs(rho[m, m]) > 0.0:
-                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-            for n in range(m + 1, M):
-                if abs(rho[m, n]) > 0.0:
-                    W += 2.0 * real(rho[m, n] * (-1) ** m *
-                                    (2 * A) ** (n - m) *
-                                    sqrt(factorial(m) / factorial(n)) *
-                                    genlaguerre(m, n - m)(B))
-
-    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
-
-
-def _par_wig_eval(args):
-    """
-    Private function for calculating terms of Laguerre Wigner function
-    using parfor.
-    """
-    m, rho, A, B = args
-    W1 = zeros(np.shape(A))
-    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
-        n = rho.data.indices[jj]
-
-        if m == n:
-            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-
-        elif n > m:
-            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
-                             (2 * A) ** (n - m) *
-                             sqrt(factorial(m) / factorial(n)) *
-                             genlaguerre(m, n - m)(B))
-    return W1
-
-
-def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
-    """
-    Evaluate the Wigner function via the Fourier transform.
-    """
-    if psi.type == 'bra':
-        psi = psi.dag()
-    if psi.type == 'ket':
-        return _psi_wigner_fft(psi.full(), xvec, g)
-    elif psi.type == 'oper':
-        eig_vals, eig_vecs = eigh(psi.full())
-        W = 0
-        for ii in range(psi.shape[0]):
-            W1, yvec = _psi_wigner_fft(
-                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
-            W += eig_vals[ii] * W1
-        return W, yvec
-
-
-def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
-    """
-    FFT method for a single state vector.  Called multiple times when the
-    input is a density matrix.
-    """
-    n = len(psi)
-    A = _osc_eigen(n, xvec * g / np.sqrt(2))
-    xpsi = np.dot(psi.T, A)
-    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
-    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
-
-
-def _wigner_fft(psi, xvec):
-    """
-    Evaluates the Fourier transformation of a given state vector.
-    Returns the corresponding density matrix and range
-    """
-    n = 2*len(psi.T)
-    r1 = np.concatenate((np.array([[0]]),
-                        np.fliplr(psi.conj()),
-                        np.zeros((1, n//2 - 1))), axis=1)
-    r2 = np.concatenate((np.array([[0]]), psi,
-                        np.zeros((1, n//2 - 1))), axis=1)
-    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
-        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
-    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
-    w = ft.fft(w)
-    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
-    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
-    w = w / (p[1] - p[0]) / n
-    return w, p
-
-
-def _osc_eigen(N, pnts):
-    """
-    Vector of and N-dim oscillator eigenfunctions evaluated
-    at the points in pnts.
-    """
-    pnts = np.asarray(pnts)
-    lpnts = len(pnts)
-    A = np.zeros((N, lpnts))
-    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
-    if N == 1:
-        return A
-    else:
-        A[1, :] = np.sqrt(2) * pnts * A[0, :]
-        for k in range(2, N):
-            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
-                np.sqrt((k - 1.0) / k) * A[k - 2, :]
-        return A
-
-
-def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
-    r"""
-    Using Clenshaw summation - numerically stable and efficient
-    iterative algorithm to evaluate polynomial series.
-
-    The Wigner function is calculated as
-    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
-    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
-    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
-    """
-
-    M = np.prod(rho.shape[0])
-    X,Y = np.meshgrid(xvec, yvec)
-    #A = 0.5 * g * (X + 1.0j * Y)
-    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
-
-    B = np.abs(A2)
-    B *= B
-    w0 = (2*rho[0, -1])*np.ones_like(A2)
-    L = M-1
-    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
-    #using Horner's method
-    if not sparse:
-        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
-        while L > 0:
-            L -= 1
-            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
-            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
-    else:
-        # TODO: fix dispatch.
-        _rho = _data.to(_data.CSR, rho.data).as_scipy()
-        while L > 0:
-            L -= 1
-            diag = _rho.diagonal(L)
-            if L != 0:
-                diag *= 2
-            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
-            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
-
-    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
-
-
-def _wig_laguerre_val(L, x, c):
-    r"""
-    this is evaluation of polynomial series inspired by hermval from numpy.
-    Returns polynomial series
-
-    .. math:
-        \sum_n b_n LL_n^L,
-
-    where
-
-    .. math:
-        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
-
-    The evaluation uses Clenshaw recursion.
-    """
-
-    if len(c) == 1:
-        y0 = c[0]
-        y1 = 0
-    elif len(c) == 2:
-        y0 = c[0]
-        y1 = c[1]
-    else:
-        k = len(c)
-        y0 = c[-2]
-        y1 = c[-1]
-        for i in range(3, len(c) + 1):
-            k -= 1
-            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
-            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
-
-    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
-
-
-# -----------------------------------------------------------------------------
-# Q FUNCTION
-#
-def _qfunc_check_state(state: Qobj):
-    if not isinstance(state, Qobj):
-        raise TypeError(f"state must be Qobj, but is {state}")
-    # This is only approximate, but it's enough for our purposes; doing more
-    # than this would take computational effort we don't _need_ to do.
-    isdm = (
-        state.isoper
-        and state.dims[0] == state.dims[1]
-        and state.isherm
-        and abs(state.tr() - 1) < qutip.settings.core['atol']
-    )
-    if not (state.isket or isdm):
-        raise ValueError(
-            f"state must be a ket or density matrix, but is {state}"
-        )
-    if len(state.dims[0]) != 1:
-        raise ValueError(
-            "state must not have tensor structure, but has dimensions:"
-            f" {state.dims}"
-        )
-    return state
-
-
-def _qfunc_check_coordinates(xvec, yvec):
-    if np.isscalar(xvec) or xvec is None:
-        raise TypeError("xvec must be array-like, but is " + repr(xvec))
-    if np.isscalar(yvec) or yvec is None:
-        raise TypeError("yvec must be array-like, but is " + repr(yvec))
-    xvec = np.asarray(xvec, dtype=np.float64)
-    yvec = np.asarray(yvec, dtype=np.float64)
-    if xvec.ndim != 1 or yvec.ndim != 1:
-        raise ValueError(
-            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
-        )
-    return xvec, yvec
-
-
-class _QFuncCoherentGrid:
-    """
-    Internal function to compute coherent state operators corresponding to a
-    grid of complex values in phase space.  For efficiency reasons, this class
-    produces the adjoint of the coherent states, to save allocations when
-    calculating inner products later.
-
-    Examples
-    --------
-    Initialise the grid calculator.
-
-    >>> xvec = yvec = np.linspace(-1, 1, 21)
-    >>> g = np.sqrt(0.5)
-    >>> max_ns = 10
-    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
-
-    The naive construction of the grid is
-
-    >>> xs, ys = np.meshgrid(xvec, yvec)
-    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
-    >>> naive = np.array([
-    ...     [
-    ...         qutip.coherent(max_ns, alpha, method='analytic')
-    ...             .dag().full().ravel()
-    ...         for alpha in x_alphas
-    ...     ]
-    ...     for y_alphas in all_alphas
-    ... ])
-
-    The naive approach is typically several of orders of magnitude slower than
-    this class, which uses much simpler vectorised operations.  The outputs are
-    within close tolerance, however:
-
-    >>> np.allclose(naive, grid(max_ns))
-    True
-    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
-    True
-    """
-    def __init__(self, xvec, yvec, g: float):
-        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
-        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
-        self.grid = np.empty(x.shape, dtype=np.complex128)
-        self.grid.real = x
-        # We produce the adjoint of the coherent states to save an operation
-        # later when computing dot products, hence the negative imaginary part.
-        self.grid.imag = -y
-        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
-
-    def _start(self, first: int):
-        """
-        Get the coherent state matrix corresponding to the first needed Fock
-        state.
-        """
-        if first == 0:
-            return self.prefactor.copy()
-        out = np.power(self.grid, first)
-        out *= self.prefactor
-        return out
-
-    def __call__(self, first: int, last: int = None):
-        """
-        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
-        coherent-state vectors for all the Fock states in the range ``first``
-        to ``last``, excluding the end point.  The first two axes are the y-
-        and x-coordinates of phase space (i.e. Cartesian indexing, like
-        ``numpy.meshgrid``), and the last runs over the selected range of
-        Fock-space dimensions.
-        """
-        ns = np.arange(first, last).reshape(1, 1, -1)
-        # Technically we could avoid hitting the limits of floating-point
-        # exponents for longer by doing all this in logarithmic space (using
-        # scipy.special.gammaln), but that ends up involving more
-        # floating-point operations overall, and needs special care around the
-        # point alpha = 0 to avoid nan appearing, due to how Python handles
-        # mixed-width arithmetic operations.
-        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
-        out[:, :, 0] = self._start(ns.flat[0])
-        for i in range(ns.size - 1):
-            out[:, :, i+1] = out[:, :, i] * self.grid
-        out /= np.sqrt(scipy.special.factorial(ns))
-        return out
-
-
-class QFunc:
-    r"""
-    Class-based method of calculating the Husimi-Q function of many different
-    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
-    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
-    subsequent operations will be several times faster. However, it can require
-    quite a lot of memory. Call the created object as a function to retrieve
-    the Husimi-Q function.
-
-    Parameters
-    ----------
-    xvec, yvec : array_like
-        x- and y-coordinates at which to calculate the Husimi-Q function.
-
-    g : float, default sqrt(2)
-        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
-        related to the value of `hbar` in the commutation relation
-        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
-        corresponds to :math:`\hbar=1`.
-
-    memory : real, default 1024
-        Size in MB that may be used internally as workspace.  This class will
-        raise ``MemoryError`` if subsequently passed a state of sufficiently
-        large dimension that this bound would be exceeded.  In those cases, use
-        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
-        the slower, more memory-efficient algorithm.
-
-    Examples
-    --------
-    Initialise the class for a square set of coordinates, with some states we
-    want to investigate.
-
-    >>> xvec = np.linspace(-2, 2, 101)
-    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
-    >>> qfunc = qutip.QFunc(xvec, xvec)
-
-    Now we can calculate the Husimi-Q function over each of the states more
-    efficiently with:
-
-    >>> husimiq = np.array([qfunc(state) for state in states])
-
-    See Also
-    --------
-    :obj:`.qfunc` :
-        a single function version, which will involve computing several
-        quantities multiple times in order to use less memory.
-    """
-
-    def __init__(
-        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
-    ):
-        self._g = g
-        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
-        # 16 bytes per complex, 1024**2 bytes per MB.
-        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
-        self._memory_mb = memory
-        self._max_size = int(self._memory_mb // self._size_mb)
-        self._current_size = 0
-        self._cache = None
-
-    def _alphas(self, size: int):
-        r"""
-        Retrive the full tensor of (the conjugate of) coherent states over all
-        values of :math:`\alpha`, for states of dimension ``size``.
-        """
-        if self._current_size >= size:
-            return self._cache[:, :, :size]
-        if size > self._max_size:
-            requirement = self._size_mb * size
-            raise MemoryError(
-                f"Refusing to precompute up to {size} basis states."
-                f" This would require {requirement:.2f} MB,"
-                f" but only {self._memory_mb} MB is allowed."
-            )
-        if self._cache is None:
-            self._cache = self._coherent_grid(self._current_size, size)
-        else:
-            self._cache = np.dstack(
-                [self._cache, self._coherent_grid(self._current_size, size)]
-            )
-        self._current_size = size
-        return self._cache
-
-    def _single(self, vector: np.ndarray, alphas: np.ndarray):
-        r"""
-        Get the Q function (without the :math:`\pi` scaling factor) of a single
-        state vector.
-        """
-        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
-
-    def __call__(self, state: Qobj):
-        """
-        Get the Husimi-Q function for the given state vector or density matrix,
-        over the coordinates used to initialise the class.  If called multiple
-        times, the states do not need to have the same dimensions, but none of
-        them can have tensor-product structure.
-        """
-        state = _qfunc_check_state(state)
-        alphas = self._alphas(state.shape[0])
-        if state.isket:
-            return self._single(state.full().ravel(), alphas) / np.pi
-        # We don't use Qobj.eigenstates() to avoid building many unnecessary
-        # CSR versions of dense matrices.
-        values, vectors = eigh(state.full())
-        vectors = vectors.T
-        out = values[0] * self._single(vectors[0], alphas)
-        for value, vector in zip(values[1:], vectors[1:]):
-            out += value * self._single(vector, alphas)
-        return out / np.pi
-
-
-def _qfunc_iterative_single(
-    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
-):
-    r"""
-    Get the Q function (without the :math:`\pi` scaling factor) of a single
-    state vector, using the iterative algorithm which recomputes the powers of
-    the coherent-state matrix.
-    """
-    ns = np.arange(vector.shape[0])
-    out = np.polyval(
-        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
-        alpha_grid.grid,
-    )
-    out *= alpha_grid.prefactor
-    return np.abs(out)**2
-
-
-def qfunc(
-    state: Qobj,
-    xvec,
-    yvec,
-    g: float = sqrt(2),
-    precompute_memory: float = 1024,
-):
-    r"""
-    Husimi-Q function of a given state vector or density matrix at phase-space
-    points ``0.5 * g * (xvec + i*yvec)``.
-
-    Parameters
-    ----------
-    state : :obj:`.Qobj`
-        A state vector or density matrix.  This cannot have tensor-product
-        structure.
-
-    xvec, yvec : array_like
-        x- and y-coordinates at which to calculate the Husimi-Q function.
-
-    g : float, default sqrt(2)
-        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
-        related to the value of :math:`\hbar` in the commutation relation
-        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
-        corresponds to :math:`\hbar=1`.
-
-    precompute_memory : real, default 1024
-        Size in MB that may be used during calculations as working space when
-        dealing with density-matrix inputs.  This is ignored for state-vector
-        inputs.  The bound is not quite exact due to other, order-of-magnitude
-        smaller, intermediaries being necessary, but is a good approximation.
-        If you want to use the same iterative algorithm for density matrices
-        that is used for single kets, set ``precompute_memory=None``.
-
-    Returns
-    -------
-    ndarray
-        Values representing the Husimi-Q function calculated over the specified
-        range ``[xvec, yvec]``.
-
-    See Also
-    --------
-    :obj:`.QFunc` :
-        a class-based version, more efficient if you want to calculate the
-        Husimi-Q function for several states over the same coordinates.
-    """
-    state = _qfunc_check_state(state)
-    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
-    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
-    enough_memory = (
-        precompute_memory is not None
-        and precompute_memory > required_memory
-    )
-    if state.isoper and enough_memory:
-        return QFunc(xvec, yvec, g)(state)
-    if precompute_memory is not None and state.isoper:
-        warnings.warn(
-            "Falling back to iterative algorithm due to lack of memory."
-            f" Needed {required_memory:.2f} MB, but only allowed to use"
-            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
-            " raise limit, or set to `None` to suppress warning."
-        )
-    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
-    if state.isket:
-        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
-        out /= np.pi
-        return out
-    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
-    # versions of dense matrices.
-    values, vectors = eigh(state.full())
-    vectors = vectors.T
-    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
-    for value, vector in zip(values[1:], vectors[1:]):
-        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
-    out /= np.pi
-    return out
-
-
-# -----------------------------------------------------------------------------
-# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
-#
-def spin_q_function(rho, theta, phi):
-    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
-    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
-    j, theta, phi)`` where j is the spin length.
-    The implementation here is more efficient as it doesn't
-    generate all of the SCS at theta and phi (see references).
-
-    The spin Q function is normal when integrated over the surface of the
-    sphere
-
-    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
-              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
-
-    Parameters
-    ----------
-    state : qobj
-        A state vector or density matrix for a spin-j quantum system.
-    theta : array_like
-        Polar (colatitude) angle at which to calculate the Husimi-Q function.
-    phi : array_like
-        Azimuthal angle at which to calculate the Husimi-Q function.
-
-    Returns
-    -------
-    Q, THETA, PHI : 2d-array
-        Values representing the spin Husimi Q function at the values specified
-        by THETA and PHI.
-
-    References
-    ----------
-    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
-    https://doi.org/10.1119/1.4898595
-
-    """
-
-    if rho.isket or rho.isbra:
-        rho = rho.proj()
-
-    J = rho.shape[0]
-    j = (J - 1) / 2
-
-    THETA, PHI = meshgrid(theta, phi)
-
-    Q = np.zeros_like(THETA, dtype=complex)
-    data = rho.full()
-
-    for m1 in arange(-j, j + 1):
-        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
-             sin(THETA / 2) ** (2 * (j - m1)) * \
-             data[int(j - m1), int(j - m1)]
-
-        for m2 in arange(m1 + 1, j + 1):
-            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
-                  cos(THETA / 2) ** (2 * j + m1 + m2) *
-                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
-             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
-              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
-
-    return Q.real, THETA, PHI
-
-
-def _rho_kq(rho, j, k, q):
-    """
-    This calculates the trace of the multipole operator T_kq and the density
-    matrix rho for use in the spin Wigner quasiprobability distribution.
-
-    Parameters
-    ----------
-    rho : qobj
-        A density matrix for a spin-j quantum system.
-    j : float
-        The spin length of the system.
-    k : int
-        Spherical harmonic degree
-    q : int
-        Spherical harmonic order
-
-    Returns
-    -------
-    v : float
-        Overlap of state with multipole operator T_kq
-    """
-
-    v = 0j
-    data = rho.full()
-    for m1 in arange(-j, j+1):
-        for m2 in arange(-j, j+1):
-            v += (
-                    (-1) ** (2 * j - k - m1 - m2)
-                    * np.sqrt((2 * k + 1) / (2 * j + 1))
-                    * clebsch(j, k, j, -m1, q, -m2)
-                    * data[int(j - m1), int(j - m2)]
-            )
-    return v
-
-
-def spin_wigner(rho, theta, phi):
-    r"""Wigner function for a spin-j system.
-
-    The spin W function is normal when integrated over the surface of the
-    sphere
-
-    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
-              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
-
-
-    Parameters
-    ----------
-    state : qobj
-        A state vector or density matrix for a spin-j quantum system.
-    theta : array_like
-        Polar (colatitude) angle at which to calculate the W function.
-    phi : array_like
-        Azimuthal angle at which to calculate the W function.
-
-    Returns
-    -------
-    W, THETA, PHI : 2d-array
-        Values representing the spin Wigner function at the values specified
-        by THETA and PHI.
-
-    References
-    ----------
-    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
-    https://doi.org/10.1103/PhysRevA.24.2889
-
-    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
-    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
-
-    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
-    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
-
-    """
-    if rho.isket or rho.isbra:
-        rho = rho.proj()
-
-    J = rho.shape[0]
-    j = (J - 1) / 2
-
-    THETA, PHI = meshgrid(theta, phi)
-
-    W = np.zeros_like(THETA, dtype=complex)
-
-    for k in range(int(2 * j)+1):
-        for q in arange(-k, k+1):
-            # sph_harm takes azimuthal angle then polar angle as arguments
-            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
-
-    return W.real, THETA, PHI
+__all__ = [
+    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
+    'wigner_transform',
+]
+
+import numpy as np
+import warnings
+from numpy import (
+    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
+)
+import scipy.sparse as sp
+import scipy.fftpack as ft
+import scipy.linalg as la
+import scipy.special
+from scipy.special import genlaguerre, binom, sph_harm, factorial
+
+import qutip
+from qutip import Qobj, ket2dm, jmat
+from .solver.parallel import parallel_map
+from .utilities import clebsch
+from .core import data as _data
+from .core.data.eigen import eigh
+
+
+def wigner_transform(psi, j, fullparity, steps, slicearray):
+    """takes the density matrix or state vector of any finite state and
+    generates the Wigner function for that state on a sphere, generating a spin
+    Wigner function useful for displaying the quasi-probability for a qubit or
+    any qudit. For the standard, continuous-variable Wigner function for
+    position and momentum variables, wigner() should be used.
+
+    Parameters
+    ----------
+        psi : qobj
+              a state vector or density matrix.
+        j : int
+            the total angular momentum of the quantum state.
+        fullparity : bool
+                     should the parity of the full SU space be used?
+        steps : int
+                number of points at which the Wigner transform is calculated.
+        slicearray : list of str
+                     the angle slice to be used for each particle in case of a
+                     multi-particle quantum state. 'l' yields an equal angle
+                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
+
+    Returns
+    ----------
+        wigner : list of float
+                 the wigner transformation at `steps` different theta and phi.
+
+    Raises
+    ------
+    ComplexWarning
+        This can be ignored as it is caused due to rounding errors.
+
+    Notes
+    ------
+    See example notebook wigner_visualisation.
+
+    References
+    ------
+    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
+        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
+    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
+        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
+    """
+    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
+        raise TypeError('Input state is not a valid operator.')
+
+    if psi.isket or psi.isbra:
+        rho = psi.proj()
+    else:
+        rho = psi
+
+    sun = 2   # The order of the SU group
+
+    # calculate total number of particles in quantum state:
+    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
+
+    theta = np.zeros((N, steps))
+    phi = np.zeros((N, steps))
+
+    for i in range(N):
+        theta[i, :] = np.linspace(0, np.pi, steps)
+        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
+
+    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
+
+    wigner = np.zeros((steps, steps))
+    if fullparity:
+        pari = _parity(sun**N, j)
+    else:
+        pari = _parity(sun, j)
+    for t in range(steps):
+        for p in range(steps):
+            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
+            kernel = _data.dense.fast_from_numpy(kernel)
+            wigner[t, p] = _data.expect(rho.data, kernel).real
+    return wigner
+
+
+def _parity(N, j):
+    """Private function to calculate the parity of the quantum system.
+    """
+    if j == 0.5:
+        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
+        return pi / N
+    elif j > 0.5:
+        mult = np.int32(2 * j + 1)
+        matrix = np.zeros((mult, mult))
+        foo = np.ones(mult)
+        for n in np.arange(-j, j + 1, 1):
+            for l in np.arange(0, mult, 1):
+                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
+            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
+        return matrix / mult
+
+
+def _lambda_f(N):
+    """Private function needed for the calculation of the parity.
+    """
+    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
+    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
+    return matrix
+
+
+def _kernelsu2(theta, phi, N, j, parity, fullparity):
+    """Private function that calculates the kernel for the SU2 unitary group.
+    """
+    U = np.ones(1)
+    # calculate the total rotation matrix (tensor product for each particle):
+    for i in range(0, N):
+        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
+    if not fullparity:
+        op_parity = parity   # The parity for a one particle system
+        for i in range(1, N):
+            parity = np.kron(parity, op_parity)
+    matrix = U @ parity @ U.conj().T
+    return matrix
+
+
+def _rotation_matrix(theta, phi, j):
+    """Private function to calculate the rotation operator for the SU2 kernel.
+    """
+    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
+           la.expm(1j * theta * jmat(j, 'y').full())
+
+
+def _angle_slice(slicearray, theta, phi):
+    """Private function to modify theta and phi for angle slicing.
+    """
+    xind = np.where(slicearray == 'x')
+    theta[xind, :] = np.pi - theta[xind, :]
+    phi[xind, :] = -phi[xind, :]
+    yind = np.where(slicearray == 'y')
+    theta[yind, :] = np.pi - theta[yind, :]
+    phi[yind, :] = np.pi - phi[yind, :]
+    zind = np.where(slicearray == 'z')
+    phi[zind, :] = phi[zind, :] + np.pi
+    return theta, phi
+
+
+def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
+           sparse=False, parfor=False):
+    """Wigner function for a state vector or density matrix at points
+    `xvec + i * yvec`.
+
+    Parameters
+    ----------
+
+    state : qobj
+        A state vector or density matrix.
+
+    xvec : array_like
+        x-coordinates at which to calculate the Wigner function.
+
+    yvec : array_like
+        y-coordinates at which to calculate the Wigner function.  Does not
+        apply to the 'fft' method.
+
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation
+        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
+        value `hbar=1`.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
+        and 'iterative' use an iterative method to evaluate the Wigner functions for density
+        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
+        in scipy for the same task. The 'fft' method evaluates the Fourier
+        transform of the density matrix. The 'iterative' method is default, and
+        in general recommended, but the 'laguerre' method is more efficient for
+        very sparse density matrices (e.g., superpositions of Fock states in a
+        large Hilbert space). The 'clenshaw' method is the preferred method for
+        dealing with density matrices that have a large number of excitations
+        (>~50). 'clenshaw' is a fast and numerically stable method.
+
+    sparse : bool {False, True}
+        Tells the default solver whether or not to keep the input density
+        matrix in sparse format.  As the dimensions of the density matrix
+        grow, setthing this flag can result in increased performance.
+
+    parfor : bool {False, True}
+        Flag for calculating the Laguerre polynomial based Wigner function
+        method='laguerre' in parallel using the parfor function.
+
+
+    Returns
+    -------
+
+    W : array
+        Values representing the Wigner function calculated over the specified
+        range [xvec,yvec].
+
+    yvex : array
+        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
+        transform.
+
+    Notes
+    -----
+    The 'fft' method accepts only an xvec input for the x-coordinate.
+    The y-coordinates are calculated internally.
+
+    References
+    ----------
+
+    Ulf Leonhardt,
+    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
+
+    """
+
+    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
+        raise TypeError('Input state is not a valid operator.')
+
+    if method == 'fft':
+        return _wigner_fourier(psi, xvec, g)
+
+    if psi.isket or psi.isbra:
+        rho = psi.proj()
+    else:
+        rho = psi
+
+    if method == 'iterative':
+        return _wigner_iterative(rho, xvec, yvec, g)
+
+    elif method == 'laguerre':
+        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
+
+    elif method == 'clenshaw':
+        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
+
+    else:
+        raise TypeError(
+            "method must be either 'iterative', 'laguerre', or 'fft'.")
+
+
+def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
+    r"""
+    Using an iterative method to evaluate the wigner functions for the Fock
+    state :math:`|m><n|`.
+
+    The Wigner function is calculated as
+    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
+    function for the density matrix :math:`|m><n|`.
+
+    In this implementation, for each row m, Wlist contains the Wigner functions
+    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
+    calculated, the corresponding contribution is added to the total Wigner
+    function, weighted by the corresponding element in the density matrix
+    :math:`rho_{mn}`.
+    """
+
+    M = np.prod(rho.shape[0])
+    X, Y = meshgrid(xvec, yvec)
+    A = 0.5 * g * (X + 1.0j * Y)
+
+    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
+    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
+
+    W = real(rho[0, 0]) * real(Wlist[0])
+    for n in range(1, M):
+        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
+        W += 2 * real(rho[0, n] * Wlist[n])
+
+    for m in range(1, M):
+        temp = copy(Wlist[m])
+        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
+
+        # Wlist[m] = Wigner function for |m><m|
+        W += real(rho[m, m] * Wlist[m])
+
+        for n in range(m + 1, M):
+            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
+            temp = copy(Wlist[n])
+            Wlist[n] = temp2
+
+            # Wlist[n] = Wigner function for |m><n|
+            W += 2 * real(rho[m, n] * Wlist[n])
+
+    return 0.5 * W * g ** 2
+
+
+def _wigner_laguerre(rho, xvec, yvec, g, parallel):
+    r"""
+    Using Laguerre polynomials from scipy to evaluate the Wigner function for
+    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
+    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
+    """
+
+    M = np.prod(rho.shape[0])
+    X, Y = meshgrid(xvec, yvec)
+    A = 0.5 * g * (X + 1.0j * Y)
+    W = zeros(np.shape(A))
+
+    # compute wigner functions for density matrices |m><n| and
+    # weight by all the elements in the density matrix
+    B = 4 * abs(A) ** 2
+    if sp.isspmatrix_csr(rho.data):
+        # for compress sparse row matrices
+        if parallel:
+            iterator = (
+                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
+            W1_out = parallel_map(_par_wig_eval, iterator)
+            W += sum(W1_out)
+        else:
+            for m in range(len(rho.data.indptr) - 1):
+                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
+                    n = rho.data.indices[jj]
+
+                    if m == n:
+                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+
+                    elif n > m:
+                        W += 2.0 * real(rho[m, n] * (-1) ** m *
+                                        (2 * A) ** (n - m) *
+                                        sqrt(factorial(m) / factorial(n)) *
+                                        genlaguerre(m, n - m)(B))
+    else:
+        # for dense density matrices
+        B = 4 * abs(A) ** 2
+        for m in range(M):
+            if abs(rho[m, m]) > 0.0:
+                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+            for n in range(m + 1, M):
+                if abs(rho[m, n]) > 0.0:
+                    W += 2.0 * real(rho[m, n] * (-1) ** m *
+                                    (2 * A) ** (n - m) *
+                                    sqrt(factorial(m) / factorial(n)) *
+                                    genlaguerre(m, n - m)(B))
+
+    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
+
+
+def _par_wig_eval(args):
+    """
+    Private function for calculating terms of Laguerre Wigner function
+    using parfor.
+    """
+    m, rho, A, B = args
+    W1 = zeros(np.shape(A))
+    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
+        n = rho.data.indices[jj]
+
+        if m == n:
+            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+
+        elif n > m:
+            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
+                             (2 * A) ** (n - m) *
+                             sqrt(factorial(m) / factorial(n)) *
+                             genlaguerre(m, n - m)(B))
+    return W1
+
+
+def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
+    """
+    Evaluate the Wigner function via the Fourier transform.
+    """
+    if psi.type == 'bra':
+        psi = psi.dag()
+    if psi.type == 'ket':
+        return _psi_wigner_fft(psi.full(), xvec, g)
+    elif psi.type == 'oper':
+        eig_vals, eig_vecs = eigh(psi.full())
+        W = 0
+        for ii in range(psi.shape[0]):
+            W1, yvec = _psi_wigner_fft(
+                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
+            W += eig_vals[ii] * W1
+        return W, yvec
+
+
+def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
+    """
+    FFT method for a single state vector.  Called multiple times when the
+    input is a density matrix.
+    """
+    n = len(psi)
+    A = _osc_eigen(n, xvec * g / np.sqrt(2))
+    xpsi = np.dot(psi.T, A)
+    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
+    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
+
+
+def _wigner_fft(psi, xvec):
+    """
+    Evaluates the Fourier transformation of a given state vector.
+    Returns the corresponding density matrix and range
+    """
+    n = 2*len(psi.T)
+    r1 = np.concatenate((np.array([[0]]),
+                        np.fliplr(psi.conj()),
+                        np.zeros((1, n//2 - 1))), axis=1)
+    r2 = np.concatenate((np.array([[0]]), psi,
+                        np.zeros((1, n//2 - 1))), axis=1)
+    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
+        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
+    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
+    w = ft.fft(w)
+    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
+    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
+    w = w / (p[1] - p[0]) / n
+    return w, p
+
+
+def _osc_eigen(N, pnts):
+    """
+    Vector of and N-dim oscillator eigenfunctions evaluated
+    at the points in pnts.
+    """
+    pnts = np.asarray(pnts)
+    lpnts = len(pnts)
+    A = np.zeros((N, lpnts))
+    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
+    if N == 1:
+        return A
+    else:
+        A[1, :] = np.sqrt(2) * pnts * A[0, :]
+        for k in range(2, N):
+            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
+                np.sqrt((k - 1.0) / k) * A[k - 2, :]
+        return A
+
+
+def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
+    r"""
+    Using Clenshaw summation - numerically stable and efficient
+    iterative algorithm to evaluate polynomial series.
+
+    The Wigner function is calculated as
+    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
+    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
+    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
+    """
+
+    M = np.prod(rho.shape[0])
+    X,Y = np.meshgrid(xvec, yvec)
+    #A = 0.5 * g * (X + 1.0j * Y)
+    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
+
+    B = np.abs(A2)
+    B *= B
+    w0 = (2*rho[0, -1])*np.ones_like(A2)
+    L = M-1
+    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
+    #using Horner's method
+    if not sparse:
+        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
+        while L > 0:
+            L -= 1
+            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
+            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
+    else:
+        # TODO: fix dispatch.
+        _rho = _data.to(_data.CSR, rho.data).as_scipy()
+        while L > 0:
+            L -= 1
+            diag = _rho.diagonal(L)
+            if L != 0:
+                diag *= 2
+            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
+            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
+
+    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
+
+
+def _wig_laguerre_val(L, x, c):
+    r"""
+    this is evaluation of polynomial series inspired by hermval from numpy.
+    Returns polynomial series
+
+    .. math:
+        \sum_n b_n LL_n^L,
+
+    where
+
+    .. math:
+        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
+
+    The evaluation uses Clenshaw recursion.
+    """
+
+    if len(c) == 1:
+        y0 = c[0]
+        y1 = 0
+    elif len(c) == 2:
+        y0 = c[0]
+        y1 = c[1]
+    else:
+        k = len(c)
+        y0 = c[-2]
+        y1 = c[-1]
+        for i in range(3, len(c) + 1):
+            k -= 1
+            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
+            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
+
+    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
+
+
+# -----------------------------------------------------------------------------
+# Q FUNCTION
+#
+def _qfunc_check_state(state: Qobj):
+    if not isinstance(state, Qobj):
+        raise TypeError(f"state must be Qobj, but is {state}")
+    # This is only approximate, but it's enough for our purposes; doing more
+    # than this would take computational effort we don't _need_ to do.
+    isdm = (
+        state.isoper
+        and state.dims[0] == state.dims[1]
+        and state.isherm
+        and abs(state.tr() - 1) < qutip.settings.core['atol']
+    )
+    if not (state.isket or isdm):
+        raise ValueError(
+            f"state must be a ket or density matrix, but is {state}"
+        )
+    if len(state.dims[0]) != 1:
+        raise ValueError(
+            "state must not have tensor structure, but has dimensions:"
+            f" {state.dims}"
+        )
+    return state
+
+
+def _qfunc_check_coordinates(xvec, yvec):
+    if np.isscalar(xvec) or xvec is None:
+        raise TypeError("xvec must be array-like, but is " + repr(xvec))
+    if np.isscalar(yvec) or yvec is None:
+        raise TypeError("yvec must be array-like, but is " + repr(yvec))
+    xvec = np.asarray(xvec, dtype=np.float64)
+    yvec = np.asarray(yvec, dtype=np.float64)
+    if xvec.ndim != 1 or yvec.ndim != 1:
+        raise ValueError(
+            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
+        )
+    return xvec, yvec
+
+
+class _QFuncCoherentGrid:
+    """
+    Internal function to compute coherent state operators corresponding to a
+    grid of complex values in phase space.  For efficiency reasons, this class
+    produces the adjoint of the coherent states, to save allocations when
+    calculating inner products later.
+
+    Examples
+    --------
+    Initialise the grid calculator.
+
+    >>> xvec = yvec = np.linspace(-1, 1, 21)
+    >>> g = np.sqrt(0.5)
+    >>> max_ns = 10
+    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
+
+    The naive construction of the grid is
+
+    >>> xs, ys = np.meshgrid(xvec, yvec)
+    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
+    >>> naive = np.array([
+    ...     [
+    ...         qutip.coherent(max_ns, alpha, method='analytic')
+    ...             .dag().full().ravel()
+    ...         for alpha in x_alphas
+    ...     ]
+    ...     for y_alphas in all_alphas
+    ... ])
+
+    The naive approach is typically several of orders of magnitude slower than
+    this class, which uses much simpler vectorised operations.  The outputs are
+    within close tolerance, however:
+
+    >>> np.allclose(naive, grid(max_ns))
+    True
+    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
+    True
+    """
+    def __init__(self, xvec, yvec, g: float):
+        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
+        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
+        self.grid = np.empty(x.shape, dtype=np.complex128)
+        self.grid.real = x
+        # We produce the adjoint of the coherent states to save an operation
+        # later when computing dot products, hence the negative imaginary part.
+        self.grid.imag = -y
+        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
+
+    def _start(self, first: int):
+        """
+        Get the coherent state matrix corresponding to the first needed Fock
+        state.
+        """
+        if first == 0:
+            return self.prefactor.copy()
+        out = np.power(self.grid, first)
+        out *= self.prefactor
+        return out
+
+    def __call__(self, first: int, last: int = None):
+        """
+        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
+        coherent-state vectors for all the Fock states in the range ``first``
+        to ``last``, excluding the end point.  The first two axes are the y-
+        and x-coordinates of phase space (i.e. Cartesian indexing, like
+        ``numpy.meshgrid``), and the last runs over the selected range of
+        Fock-space dimensions.
+        """
+        ns = np.arange(first, last).reshape(1, 1, -1)
+        # Technically we could avoid hitting the limits of floating-point
+        # exponents for longer by doing all this in logarithmic space (using
+        # scipy.special.gammaln), but that ends up involving more
+        # floating-point operations overall, and needs special care around the
+        # point alpha = 0 to avoid nan appearing, due to how Python handles
+        # mixed-width arithmetic operations.
+        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
+        out[:, :, 0] = self._start(ns.flat[0])
+        for i in range(ns.size - 1):
+            out[:, :, i+1] = out[:, :, i] * self.grid
+        out /= np.sqrt(scipy.special.factorial(ns))
+        return out
+
+
+class QFunc:
+    r"""
+    Class-based method of calculating the Husimi-Q function of many different
+    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
+    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
+    subsequent operations will be several times faster. However, it can require
+    quite a lot of memory. Call the created object as a function to retrieve
+    the Husimi-Q function.
+
+    Parameters
+    ----------
+    xvec, yvec : array_like
+        x- and y-coordinates at which to calculate the Husimi-Q function.
+
+    g : float, default sqrt(2)
+        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
+        related to the value of `hbar` in the commutation relation
+        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
+        corresponds to :math:`\hbar=1`.
+
+    memory : real, default 1024
+        Size in MB that may be used internally as workspace.  This class will
+        raise ``MemoryError`` if subsequently passed a state of sufficiently
+        large dimension that this bound would be exceeded.  In those cases, use
+        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
+        the slower, more memory-efficient algorithm.
+
+    Examples
+    --------
+    Initialise the class for a square set of coordinates, with some states we
+    want to investigate.
+
+    >>> xvec = np.linspace(-2, 2, 101)
+    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
+    >>> qfunc = qutip.QFunc(xvec, xvec)
+
+    Now we can calculate the Husimi-Q function over each of the states more
+    efficiently with:
+
+    >>> husimiq = np.array([qfunc(state) for state in states])
+
+    See Also
+    --------
+    :obj:`.qfunc` :
+        a single function version, which will involve computing several
+        quantities multiple times in order to use less memory.
+    """
+
+    def __init__(
+        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
+    ):
+        self._g = g
+        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
+        # 16 bytes per complex, 1024**2 bytes per MB.
+        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
+        self._memory_mb = memory
+        self._max_size = int(self._memory_mb // self._size_mb)
+        self._current_size = 0
+        self._cache = None
+
+    def _alphas(self, size: int):
+        r"""
+        Retrive the full tensor of (the conjugate of) coherent states over all
+        values of :math:`\alpha`, for states of dimension ``size``.
+        """
+        if self._current_size >= size:
+            return self._cache[:, :, :size]
+        if size > self._max_size:
+            requirement = self._size_mb * size
+            raise MemoryError(
+                f"Refusing to precompute up to {size} basis states."
+                f" This would require {requirement:.2f} MB,"
+                f" but only {self._memory_mb} MB is allowed."
+            )
+        if self._cache is None:
+            self._cache = self._coherent_grid(self._current_size, size)
+        else:
+            self._cache = np.dstack(
+                [self._cache, self._coherent_grid(self._current_size, size)]
+            )
+        self._current_size = size
+        return self._cache
+
+    def _single(self, vector: np.ndarray, alphas: np.ndarray):
+        r"""
+        Get the Q function (without the :math:`\pi` scaling factor) of a single
+        state vector.
+        """
+        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
+
+    def __call__(self, state: Qobj):
+        """
+        Get the Husimi-Q function for the given state vector or density matrix,
+        over the coordinates used to initialise the class.  If called multiple
+        times, the states do not need to have the same dimensions, but none of
+        them can have tensor-product structure.
+        """
+        state = _qfunc_check_state(state)
+        alphas = self._alphas(state.shape[0])
+        if state.isket:
+            return self._single(state.full().ravel(), alphas) / np.pi
+        # We don't use Qobj.eigenstates() to avoid building many unnecessary
+        # CSR versions of dense matrices.
+        values, vectors = eigh(state.full())
+        vectors = vectors.T
+        out = values[0] * self._single(vectors[0], alphas)
+        for value, vector in zip(values[1:], vectors[1:]):
+            out += value * self._single(vector, alphas)
+        return out / np.pi
+
+
+def _qfunc_iterative_single(
+    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
+):
+    r"""
+    Get the Q function (without the :math:`\pi` scaling factor) of a single
+    state vector, using the iterative algorithm which recomputes the powers of
+    the coherent-state matrix.
+    """
+    ns = np.arange(vector.shape[0])
+    out = np.polyval(
+        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
+        alpha_grid.grid,
+    )
+    out *= alpha_grid.prefactor
+    return np.abs(out)**2
+
+
+def qfunc(
+    state: Qobj,
+    xvec,
+    yvec,
+    g: float = sqrt(2),
+    precompute_memory: float = 1024,
+):
+    r"""
+    Husimi-Q function of a given state vector or density matrix at phase-space
+    points ``0.5 * g * (xvec + i*yvec)``.
+
+    Parameters
+    ----------
+    state : :obj:`.Qobj`
+        A state vector or density matrix.  This cannot have tensor-product
+        structure.
+
+    xvec, yvec : array_like
+        x- and y-coordinates at which to calculate the Husimi-Q function.
+
+    g : float, default sqrt(2)
+        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
+        related to the value of :math:`\hbar` in the commutation relation
+        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
+        corresponds to :math:`\hbar=1`.
+
+    precompute_memory : real, default 1024
+        Size in MB that may be used during calculations as working space when
+        dealing with density-matrix inputs.  This is ignored for state-vector
+        inputs.  The bound is not quite exact due to other, order-of-magnitude
+        smaller, intermediaries being necessary, but is a good approximation.
+        If you want to use the same iterative algorithm for density matrices
+        that is used for single kets, set ``precompute_memory=None``.
+
+    Returns
+    -------
+    ndarray
+        Values representing the Husimi-Q function calculated over the specified
+        range ``[xvec, yvec]``.
+
+    See Also
+    --------
+    :obj:`.QFunc` :
+        a class-based version, more efficient if you want to calculate the
+        Husimi-Q function for several states over the same coordinates.
+    """
+    state = _qfunc_check_state(state)
+    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
+    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
+    enough_memory = (
+        precompute_memory is not None
+        and precompute_memory > required_memory
+    )
+    if state.isoper and enough_memory:
+        return QFunc(xvec, yvec, g)(state)
+    if precompute_memory is not None and state.isoper:
+        warnings.warn(
+            "Falling back to iterative algorithm due to lack of memory."
+            f" Needed {required_memory:.2f} MB, but only allowed to use"
+            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
+            " raise limit, or set to `None` to suppress warning."
+        )
+    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
+    if state.isket:
+        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
+        out /= np.pi
+        return out
+    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
+    # versions of dense matrices.
+    values, vectors = eigh(state.full())
+    vectors = vectors.T
+    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
+    for value, vector in zip(values[1:], vectors[1:]):
+        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
+    out /= np.pi
+    return out
+
+
+# -----------------------------------------------------------------------------
+# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
+#
+def spin_q_function(rho, theta, phi):
+    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
+    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
+    j, theta, phi)`` where j is the spin length.
+    The implementation here is more efficient as it doesn't
+    generate all of the SCS at theta and phi (see references).
+
+    The spin Q function is normal when integrated over the surface of the
+    sphere
+
+    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
+              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
+
+    Parameters
+    ----------
+    state : qobj
+        A state vector or density matrix for a spin-j quantum system.
+    theta : array_like
+        Polar (colatitude) angle at which to calculate the Husimi-Q function.
+    phi : array_like
+        Azimuthal angle at which to calculate the Husimi-Q function.
+
+    Returns
+    -------
+    Q, THETA, PHI : 2d-array
+        Values representing the spin Husimi Q function at the values specified
+        by THETA and PHI.
+
+    References
+    ----------
+    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
+    https://doi.org/10.1119/1.4898595
+
+    """
+
+    if rho.isket or rho.isbra:
+        rho = rho.proj()
+
+    J = rho.shape[0]
+    j = (J - 1) / 2
+
+    THETA, PHI = meshgrid(theta, phi)
+
+    Q = np.zeros_like(THETA, dtype=complex)
+    data = rho.full()
+
+    for m1 in arange(-j, j + 1):
+        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
+             sin(THETA / 2) ** (2 * (j - m1)) * \
+             data[int(j - m1), int(j - m1)]
+
+        for m2 in arange(m1 + 1, j + 1):
+            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
+                  cos(THETA / 2) ** (2 * j + m1 + m2) *
+                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
+             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
+              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
+
+    return Q.real, THETA, PHI
+
+
+def _rho_kq(rho, j, k, q):
+    """
+    This calculates the trace of the multipole operator T_kq and the density
+    matrix rho for use in the spin Wigner quasiprobability distribution.
+
+    Parameters
+    ----------
+    rho : qobj
+        A density matrix for a spin-j quantum system.
+    j : float
+        The spin length of the system.
+    k : int
+        Spherical harmonic degree
+    q : int
+        Spherical harmonic order
+
+    Returns
+    -------
+    v : float
+        Overlap of state with multipole operator T_kq
+    """
+
+    v = 0j
+    data = rho.full()
+    for m1 in arange(-j, j+1):
+        for m2 in arange(-j, j+1):
+            v += (
+                    (-1) ** (2 * j - k - m1 - m2)
+                    * np.sqrt((2 * k + 1) / (2 * j + 1))
+                    * clebsch(j, k, j, -m1, q, -m2)
+                    * data[int(j - m1), int(j - m2)]
+            )
+    return v
+
+
+def spin_wigner(rho, theta, phi):
+    r"""Wigner function for a spin-j system.
+
+    The spin W function is normal when integrated over the surface of the
+    sphere
+
+    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
+              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
+
+
+    Parameters
+    ----------
+    state : qobj
+        A state vector or density matrix for a spin-j quantum system.
+    theta : array_like
+        Polar (colatitude) angle at which to calculate the W function.
+    phi : array_like
+        Azimuthal angle at which to calculate the W function.
+
+    Returns
+    -------
+    W, THETA, PHI : 2d-array
+        Values representing the spin Wigner function at the values specified
+        by THETA and PHI.
+
+    References
+    ----------
+    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
+    https://doi.org/10.1103/PhysRevA.24.2889
+
+    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
+    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
+
+    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
+    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
+
+    """
+    if rho.isket or rho.isbra:
+        rho = rho.proj()
+
+    J = rho.shape[0]
+    j = (J - 1) / 2
+
+    THETA, PHI = meshgrid(theta, phi)
+
+    W = np.zeros_like(THETA, dtype=complex)
+
+    for k in range(int(2 * j)+1):
+        for q in arange(-k, k+1):
+            # sph_harm takes azimuthal angle then polar angle as arguments
+            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
+
+    return W.real, THETA, PHI
diff --git a/requirements.txt b/requirements.txt
index 41d2c09a1b..ce27f29833 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
-cython>=0.29.20
-numpy>=1.16.6
-scipy>=1.5
-packaging
+cython>=0.29.20
+numpy>=1.16.6
+scipy>=1.5
+packaging
diff --git a/setup.cfg b/setup.cfg
index 1eb1f11cd2..d5d6815f21 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,70 +1,70 @@
-[metadata]
-name = qutip
-url = https://qutip.org
-description = QuTiP: The Quantum Toolbox in Python
-long_description = file: README.md
-long_description_content_type = text/markdown; variant=GFM
-keywords = quantum, physics, dynamics
-license = BSD 3-Clause License
-license_files = LICENSE.txt
-project_urls =
-    Bug Tracker = https://github.com/qutip/qutip/issues
-    Documentation = https://qutip.org/docs/latest/
-    Source Code = https://github.com/qutip/qutip
-classifiers =
-    Development Status :: 2 - Pre-Alpha
-    Intended Audience :: Science/Research
-    License :: OSI Approved :: BSD License
-    Programming Language :: Python
-    Programming Language :: Python :: 3
-    Topic :: Scientific/Engineering
-    Operating System :: MacOS
-    Operating System :: POSIX
-    Operating System :: Unix
-    Operating System :: Microsoft :: Windows
-author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
-author_email = qutip-admin@googlegroups.com
-platforms = Linux, Mac OSX, Unix, Windows
-
-[options]
-packages = find:
-include_package_data = True
-zip_safe = False
-install_requires =
-    numpy>=1.16.6
-    scipy>=1.0
-    packaging
-setup_requires =
-    numpy>=1.13.3
-    scipy>=1.0
-    cython>=0.29.20
-    packaging
-
-[options.packages.find]
-include = qutip*
-
-[options.extras_require]
-graphics = matplotlib>=1.2.1
-runtime_compilation =
-    cython>=0.29.20
-    filelock
-semidefinite =
-    cvxpy>=1.0
-    cvxopt
-tests =
-    pytest>=5.2
-    pytest-rerunfailures
-ipython =
-    ipython
-extras =
-    loky
-    tqdm
-; This uses ConfigParser's string interpolation to include all the above
-; dependencies into one single target, convenient for testing full builds.
-full =
-    %(graphics)s
-    %(runtime_compilation)s
-    %(semidefinite)s
-    %(tests)s
-    %(ipython)s
-    %(extras)s
+[metadata]
+name = qutip
+url = https://qutip.org
+description = QuTiP: The Quantum Toolbox in Python
+long_description = file: README.md
+long_description_content_type = text/markdown; variant=GFM
+keywords = quantum, physics, dynamics
+license = BSD 3-Clause License
+license_files = LICENSE.txt
+project_urls =
+    Bug Tracker = https://github.com/qutip/qutip/issues
+    Documentation = https://qutip.org/docs/latest/
+    Source Code = https://github.com/qutip/qutip
+classifiers =
+    Development Status :: 2 - Pre-Alpha
+    Intended Audience :: Science/Research
+    License :: OSI Approved :: BSD License
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Topic :: Scientific/Engineering
+    Operating System :: MacOS
+    Operating System :: POSIX
+    Operating System :: Unix
+    Operating System :: Microsoft :: Windows
+author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
+author_email = qutip-admin@googlegroups.com
+platforms = Linux, Mac OSX, Unix, Windows
+
+[options]
+packages = find:
+include_package_data = True
+zip_safe = False
+install_requires =
+    numpy>=1.16.6
+    scipy>=1.0
+    packaging
+setup_requires =
+    numpy>=1.13.3
+    scipy>=1.0
+    cython>=0.29.20
+    packaging
+
+[options.packages.find]
+include = qutip*
+
+[options.extras_require]
+graphics = matplotlib>=1.2.1
+runtime_compilation =
+    cython>=0.29.20
+    filelock
+semidefinite =
+    cvxpy>=1.0
+    cvxopt
+tests =
+    pytest>=5.2
+    pytest-rerunfailures
+ipython =
+    ipython
+extras =
+    loky
+    tqdm
+; This uses ConfigParser's string interpolation to include all the above
+; dependencies into one single target, convenient for testing full builds.
+full =
+    %(graphics)s
+    %(runtime_compilation)s
+    %(semidefinite)s
+    %(tests)s
+    %(ipython)s
+    %(extras)s
diff --git a/setup.py b/setup.py
index 0bf5b8def4..ddde76588e 100755
--- a/setup.py
+++ b/setup.py
@@ -1,312 +1,312 @@
-#!/usr/bin/env python
-
-import collections
-import os
-import pathlib
-import subprocess
-import sys
-import sysconfig
-import warnings
-
-# Required third-party imports, must be specified in pyproject.toml.
-import packaging.version
-from setuptools import setup, Extension
-import distutils.sysconfig
-import numpy as np
-from Cython.Build import cythonize
-from Cython.Distutils import build_ext
-
-
-def process_options():
-    """
-    Determine all runtime options, returning a dictionary of the results.  The
-    keys are:
-        'rootdir': str
-            The root directory of the setup.  Almost certainly the directory
-            that this setup.py file is contained in.
-        'release': bool
-            Is this a release build (True) or a local development build (False)
-        'openmp': bool
-            Should we build our OpenMP extensions and attempt to link in OpenMP
-            libraries? (Not supported in this version.)
-        'cflags': list of str
-            Flags to be passed to the C++ compiler.
-        'ldflags': list of str
-            Flags to be passed to the linker.
-        'include': list of str
-            Additional directories to be added to the header files include
-            path.  These files will be detected by Cython as dependencies, so
-            changes to them will trigger recompilation of .pyx files, whereas
-            includes added in 'cflags' as '-I/path/to/include' may not.
-    """
-    options = {}
-    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
-    options = _determine_user_arguments(options)
-    options = _determine_version(options)
-    options = _determine_compilation_options(options)
-    options = _determine_cythonize_options(options)
-    return options
-
-
-def _get_environment_bool(var, default=False):
-    """
-    Get a boolean value from the environment variable `var`.  This evalutes to
-    `default` if the environment variable is not present.  The false-y values
-    are '0', 'false', 'none' and empty string, insensitive to case.  All other
-    values are truth-y.
-    """
-    from_env = os.environ.get(var)
-    if from_env is None:
-        return default
-    return from_env.lower() not in {'0', 'false', 'none', ''}
-
-
-def _parse_bool_user_argument(options, name):
-    """
-    Parse a single boolean option from the commandline or environment.
-    """
-    cmd_flag = "--with-" + name.lower().replace("_", "-")
-    env_var = "CI_QUTIP_WITH_" + name.upper()
-    options[name] = (
-        cmd_flag in sys.argv
-        or _get_environment_bool(env_var)
-    )
-    if cmd_flag in sys.argv:
-        sys.argv.remove(cmd_flag)
-    return options
-
-
-def _determine_user_arguments(options):
-    """
-    Add the 'openmp' option to the collection, based on the passed command-line
-    arguments or environment variables.
-
-    If using PEP517 builds, one can pass these options on the command-line
-    using, for example:
-
-        python -m build \
-            --wheel \
-            --config-setting="--global-option=--with-openmp"
-    """
-    # options = _parse_bool_user_argument(options, 'openmp')
-    options['openmp'] = False  # Not supported yet
-    options = _parse_bool_user_argument(options, 'idxint_64')
-    return options
-
-
-def _determine_compilation_options(options):
-    """
-    Add additional options specific to C/C++ compilation.  These are 'cflags',
-    'ldflags' and 'include'.
-    """
-    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
-    # process uses in addition to user-specified ones; the flag is not valid
-    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
-    config = distutils.sysconfig.get_config_vars()
-    if "CFLAGS" in config:
-        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
-    options['cflags'] = []
-    options['ldflags'] = []
-    options['include'] = [np.get_include()]
-    if (
-        sysconfig.get_platform().startswith("win")
-        and os.environ.get('MSYSTEM') is None
-    ):
-        # Visual Studio
-        options['cflags'].extend(['/w', '/Ox'])
-        if options['openmp']:
-            options['cflags'].append('/openmp')
-    else:
-        # Everything else
-        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
-        if options['openmp']:
-            options['cflags'].append('-fopenmp')
-            options['ldflags'].append('-fopenmp')
-    if sysconfig.get_platform().startswith("macos"):
-        # These are needed for compiling on OSX 10.14+
-        options['cflags'].append('-mmacosx-version-min=10.9')
-        options['ldflags'].append('-mmacosx-version-min=10.9')
-        if options['openmp']:
-            options['cflags'].append('-fopenmp')
-            options['ldflags'].append('-fopenmp')
-    return options
-
-
-def _determine_cythonize_options(options):
-    options["annotate"] = False
-    if "--annotate" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("--annotate")
-    if "-a" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("-a")
-    return options
-
-
-def _determine_version(options):
-    """
-    Adds the 'short_version', 'version' and 'release' options.
-
-    Read from the VERSION file to discover the version.  This should be a
-    single line file containing valid Python package public identifier (see PEP
-    440), for example
-      4.5.2rc2
-      5.0.0
-      5.1.1a1
-    We do that here rather than in setup.cfg so we can apply the local
-    versioning number as well.
-    """
-    version_filename = os.path.join(options['rootdir'], 'VERSION')
-    with open(version_filename, "r") as version_file:
-        version_string = version_file.read().strip()
-    version = packaging.version.Version(version_string)
-    options['short_version'] = str(version.public)
-    options['release'] = not version.is_devrelease
-    if not options['release']:
-        # Put the version string into canonical form, if it wasn't already.
-        version_string = str(version)
-        version_string += "+"
-        try:
-            git_out = subprocess.run(
-                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
-                check=True,
-                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            )
-            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
-            version_string += git_hash or "nogit"
-        # CalledProcessError is for if the git command fails for internal
-        # reasons (e.g. we're not in a git repository), OSError is for if
-        # something goes wrong when trying to run git (e.g. it's not installed,
-        # or a permission error).
-        except (subprocess.CalledProcessError, OSError):
-            version_string += "nogit"
-    options['version'] = version_string
-    return options
-
-
-def create_version_py_file(options):
-    """
-    Generate and write out the file qutip/version.py, which is used to produce
-    the '__version__' information for the module.  This function will overwrite
-    an existing file at that location.
-    """
-    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
-    content = "\n".join([
-        f"# This file is automatically generated by QuTiP's setup.py.",
-        f"short_version = '{options['short_version']}'",
-        f"version = '{options['version']}'",
-        f"release = {options['release']}",
-    ])
-    with open(filename, 'w') as file:
-        print(content, file=file)
-
-
-def _extension_extra_sources():
-    """
-    Get a mapping of {module: extra_sources} for all modules to be built.  The
-    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
-    and extra_sources is a list of strings of relative paths to files.  If no
-    extra sources are known for a given module, the mapping will return an
-    empty list.
-    """
-    # For typing brevity we specify sources in Unix-style string form, then
-    # normalise them into the OS-specific form later.
-    extra_sources = {
-        'qutip.core.data.matmul': [
-            'qutip/core/data/src/matmul_csr_vector.cpp',
-        ],
-    }
-    out = collections.defaultdict(list)
-    for module, sources in extra_sources.items():
-        # Normalise the sources into OS-specific form.
-        out[module] = [str(pathlib.Path(source)) for source in sources]
-    return out
-
-
-def _create_int_type_file(options):
-    """
-    Create the `data/src/intdtype.h` file.
-    """
-    if options['idxint_64']:
-        typedef = "typedef int64_t idxint;\n"
-        typedef += "int _idxint_size=64;\n"
-    else:
-        typedef = "typedef int32_t idxint;\n"
-        typedef += "int _idxint_size=32;\n"
-    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
-    file = os.path.join(path, 'intdtype.h')
-    if os.path.exists(file):
-        with open(file, 'r') as source:
-            if source.read() == typedef:
-                # The file is already existing and the same, nothing to do.
-                return
-
-    with open(file, 'w') as source:
-        source.write(typedef)
-
-
-def create_extension_modules(options):
-    """
-    Discover and Cythonise all extension modules that need to be built.  These
-    are returned so they can be passed into the setup command.
-    """
-    out = []
-    root = pathlib.Path(options['rootdir'])
-    _create_int_type_file(options)
-    pyx_files = set(root.glob('qutip/**/*.pyx'))
-    if not options['openmp']:
-        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
-    extra_sources = _extension_extra_sources()
-    # Add Cython files from qutip
-    for pyx_file in pyx_files:
-        pyx_file = pyx_file.relative_to(root)
-        pyx_file_str = str(pyx_file)
-        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
-            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
-            # Cythonised time-dependent coefficients would get dropped in the
-            # qutip directory if you weren't careful - this is just trying to
-            # minimise the occasional developer error.
-            warnings.warn(
-                "skipping generated time-dependent coefficient: "
-                + pyx_file_str
-            )
-            continue
-        # The module name is the same as the folder structure, but with dots in
-        # place of separators ('/' or '\'), and without the '.pyx' extension.
-        pyx_module = ".".join(pyx_file.parts)[:-4]
-        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
-        out.append(Extension(pyx_module,
-                             sources=pyx_sources,
-                             include_dirs=options['include'],
-                             extra_compile_args=options['cflags'],
-                             extra_link_args=options['ldflags'],
-                             language='c++'))
-    return cythonize(out, annotate=options["annotate"])
-
-
-def print_epilogue():
-    """Display a post-setup epilogue."""
-    longbar = "="*80
-    message = "\n".join([
-        longbar,
-        "Installation complete",
-        "Please cite QuTiP in your publication.",
-        longbar,
-        "For your convenience a BibTeX reference can be easily generated with",
-        "`qutip.cite()`",
-    ])
-    print(message)
-
-
-if __name__ == "__main__":
-    options = process_options()
-    create_version_py_file(options)
-    extensions = create_extension_modules(options)
-    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
-    # keep here are ones that we have done some compile-time processing on.
-    setup(
-        version=options['version'],
-        ext_modules=extensions,
-        cmdclass={'build_ext': build_ext},
-    )
-    print_epilogue()
+#!/usr/bin/env python
+
+import collections
+import os
+import pathlib
+import subprocess
+import sys
+import sysconfig
+import warnings
+
+# Required third-party imports, must be specified in pyproject.toml.
+import packaging.version
+from setuptools import setup, Extension
+import distutils.sysconfig
+import numpy as np
+from Cython.Build import cythonize
+from Cython.Distutils import build_ext
+
+
+def process_options():
+    """
+    Determine all runtime options, returning a dictionary of the results.  The
+    keys are:
+        'rootdir': str
+            The root directory of the setup.  Almost certainly the directory
+            that this setup.py file is contained in.
+        'release': bool
+            Is this a release build (True) or a local development build (False)
+        'openmp': bool
+            Should we build our OpenMP extensions and attempt to link in OpenMP
+            libraries? (Not supported in this version.)
+        'cflags': list of str
+            Flags to be passed to the C++ compiler.
+        'ldflags': list of str
+            Flags to be passed to the linker.
+        'include': list of str
+            Additional directories to be added to the header files include
+            path.  These files will be detected by Cython as dependencies, so
+            changes to them will trigger recompilation of .pyx files, whereas
+            includes added in 'cflags' as '-I/path/to/include' may not.
+    """
+    options = {}
+    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
+    options = _determine_user_arguments(options)
+    options = _determine_version(options)
+    options = _determine_compilation_options(options)
+    options = _determine_cythonize_options(options)
+    return options
+
+
+def _get_environment_bool(var, default=False):
+    """
+    Get a boolean value from the environment variable `var`.  This evalutes to
+    `default` if the environment variable is not present.  The false-y values
+    are '0', 'false', 'none' and empty string, insensitive to case.  All other
+    values are truth-y.
+    """
+    from_env = os.environ.get(var)
+    if from_env is None:
+        return default
+    return from_env.lower() not in {'0', 'false', 'none', ''}
+
+
+def _parse_bool_user_argument(options, name):
+    """
+    Parse a single boolean option from the commandline or environment.
+    """
+    cmd_flag = "--with-" + name.lower().replace("_", "-")
+    env_var = "CI_QUTIP_WITH_" + name.upper()
+    options[name] = (
+        cmd_flag in sys.argv
+        or _get_environment_bool(env_var)
+    )
+    if cmd_flag in sys.argv:
+        sys.argv.remove(cmd_flag)
+    return options
+
+
+def _determine_user_arguments(options):
+    """
+    Add the 'openmp' option to the collection, based on the passed command-line
+    arguments or environment variables.
+
+    If using PEP517 builds, one can pass these options on the command-line
+    using, for example:
+
+        python -m build \
+            --wheel \
+            --config-setting="--global-option=--with-openmp"
+    """
+    # options = _parse_bool_user_argument(options, 'openmp')
+    options['openmp'] = False  # Not supported yet
+    options = _parse_bool_user_argument(options, 'idxint_64')
+    return options
+
+
+def _determine_compilation_options(options):
+    """
+    Add additional options specific to C/C++ compilation.  These are 'cflags',
+    'ldflags' and 'include'.
+    """
+    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
+    # process uses in addition to user-specified ones; the flag is not valid
+    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
+    config = distutils.sysconfig.get_config_vars()
+    if "CFLAGS" in config:
+        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
+    options['cflags'] = []
+    options['ldflags'] = []
+    options['include'] = [np.get_include()]
+    if (
+        sysconfig.get_platform().startswith("win")
+        and os.environ.get('MSYSTEM') is None
+    ):
+        # Visual Studio
+        options['cflags'].extend(['/w', '/Ox'])
+        if options['openmp']:
+            options['cflags'].append('/openmp')
+    else:
+        # Everything else
+        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
+        if options['openmp']:
+            options['cflags'].append('-fopenmp')
+            options['ldflags'].append('-fopenmp')
+    if sysconfig.get_platform().startswith("macos"):
+        # These are needed for compiling on OSX 10.14+
+        options['cflags'].append('-mmacosx-version-min=10.9')
+        options['ldflags'].append('-mmacosx-version-min=10.9')
+        if options['openmp']:
+            options['cflags'].append('-fopenmp')
+            options['ldflags'].append('-fopenmp')
+    return options
+
+
+def _determine_cythonize_options(options):
+    options["annotate"] = False
+    if "--annotate" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("--annotate")
+    if "-a" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("-a")
+    return options
+
+
+def _determine_version(options):
+    """
+    Adds the 'short_version', 'version' and 'release' options.
+
+    Read from the VERSION file to discover the version.  This should be a
+    single line file containing valid Python package public identifier (see PEP
+    440), for example
+      4.5.2rc2
+      5.0.0
+      5.1.1a1
+    We do that here rather than in setup.cfg so we can apply the local
+    versioning number as well.
+    """
+    version_filename = os.path.join(options['rootdir'], 'VERSION')
+    with open(version_filename, "r") as version_file:
+        version_string = version_file.read().strip()
+    version = packaging.version.Version(version_string)
+    options['short_version'] = str(version.public)
+    options['release'] = not version.is_devrelease
+    if not options['release']:
+        # Put the version string into canonical form, if it wasn't already.
+        version_string = str(version)
+        version_string += "+"
+        try:
+            git_out = subprocess.run(
+                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
+                check=True,
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            )
+            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
+            version_string += git_hash or "nogit"
+        # CalledProcessError is for if the git command fails for internal
+        # reasons (e.g. we're not in a git repository), OSError is for if
+        # something goes wrong when trying to run git (e.g. it's not installed,
+        # or a permission error).
+        except (subprocess.CalledProcessError, OSError):
+            version_string += "nogit"
+    options['version'] = version_string
+    return options
+
+
+def create_version_py_file(options):
+    """
+    Generate and write out the file qutip/version.py, which is used to produce
+    the '__version__' information for the module.  This function will overwrite
+    an existing file at that location.
+    """
+    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
+    content = "\n".join([
+        f"# This file is automatically generated by QuTiP's setup.py.",
+        f"short_version = '{options['short_version']}'",
+        f"version = '{options['version']}'",
+        f"release = {options['release']}",
+    ])
+    with open(filename, 'w') as file:
+        print(content, file=file)
+
+
+def _extension_extra_sources():
+    """
+    Get a mapping of {module: extra_sources} for all modules to be built.  The
+    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
+    and extra_sources is a list of strings of relative paths to files.  If no
+    extra sources are known for a given module, the mapping will return an
+    empty list.
+    """
+    # For typing brevity we specify sources in Unix-style string form, then
+    # normalise them into the OS-specific form later.
+    extra_sources = {
+        'qutip.core.data.matmul': [
+            'qutip/core/data/src/matmul_csr_vector.cpp',
+        ],
+    }
+    out = collections.defaultdict(list)
+    for module, sources in extra_sources.items():
+        # Normalise the sources into OS-specific form.
+        out[module] = [str(pathlib.Path(source)) for source in sources]
+    return out
+
+
+def _create_int_type_file(options):
+    """
+    Create the `data/src/intdtype.h` file.
+    """
+    if options['idxint_64']:
+        typedef = "typedef int64_t idxint;\n"
+        typedef += "int _idxint_size=64;\n"
+    else:
+        typedef = "typedef int32_t idxint;\n"
+        typedef += "int _idxint_size=32;\n"
+    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
+    file = os.path.join(path, 'intdtype.h')
+    if os.path.exists(file):
+        with open(file, 'r') as source:
+            if source.read() == typedef:
+                # The file is already existing and the same, nothing to do.
+                return
+
+    with open(file, 'w') as source:
+        source.write(typedef)
+
+
+def create_extension_modules(options):
+    """
+    Discover and Cythonise all extension modules that need to be built.  These
+    are returned so they can be passed into the setup command.
+    """
+    out = []
+    root = pathlib.Path(options['rootdir'])
+    _create_int_type_file(options)
+    pyx_files = set(root.glob('qutip/**/*.pyx'))
+    if not options['openmp']:
+        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
+    extra_sources = _extension_extra_sources()
+    # Add Cython files from qutip
+    for pyx_file in pyx_files:
+        pyx_file = pyx_file.relative_to(root)
+        pyx_file_str = str(pyx_file)
+        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
+            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
+            # Cythonised time-dependent coefficients would get dropped in the
+            # qutip directory if you weren't careful - this is just trying to
+            # minimise the occasional developer error.
+            warnings.warn(
+                "skipping generated time-dependent coefficient: "
+                + pyx_file_str
+            )
+            continue
+        # The module name is the same as the folder structure, but with dots in
+        # place of separators ('/' or '\'), and without the '.pyx' extension.
+        pyx_module = ".".join(pyx_file.parts)[:-4]
+        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
+        out.append(Extension(pyx_module,
+                             sources=pyx_sources,
+                             include_dirs=options['include'],
+                             extra_compile_args=options['cflags'],
+                             extra_link_args=options['ldflags'],
+                             language='c++'))
+    return cythonize(out, annotate=options["annotate"])
+
+
+def print_epilogue():
+    """Display a post-setup epilogue."""
+    longbar = "="*80
+    message = "\n".join([
+        longbar,
+        "Installation complete",
+        "Please cite QuTiP in your publication.",
+        longbar,
+        "For your convenience a BibTeX reference can be easily generated with",
+        "`qutip.cite()`",
+    ])
+    print(message)
+
+
+if __name__ == "__main__":
+    options = process_options()
+    create_version_py_file(options)
+    extensions = create_extension_modules(options)
+    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
+    # keep here are ones that we have done some compile-time processing on.
+    setup(
+        version=options['version'],
+        ext_modules=extensions,
+        cmdclass={'build_ext': build_ext},
+    )
+    print_epilogue()

From e2f35bc0ca963a8ff700d500e56d1637483e1ce6 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 27 Mar 2023 16:08:20 +0200
Subject: [PATCH 217/602] Create 2136.doc

---
 doc/changes/2136.doc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2136.doc

diff --git a/doc/changes/2136.doc b/doc/changes/2136.doc
new file mode 100644
index 0000000000..485f7a053f
--- /dev/null
+++ b/doc/changes/2136.doc
@@ -0,0 +1 @@
+added info about sec_cutoff to the documentation 
\ No newline at end of file

From 122e0f7c5037a1bf011c4b8eb37f6e7c08111bfb Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 27 Mar 2023 19:27:23 +0200
Subject: [PATCH 218/602] Revert "added info about sec_cutoff to the
 documentation"

This reverts commit dd00413ee05fdb22d1492f507c61b99bc53be867.
---
 .codeclimate.yml                              |     92 +-
 .coveragerc                                   |     20 +-
 .github/ISSUE_TEMPLATE/bug_report.yaml        |    104 +-
 .github/ISSUE_TEMPLATE/feature_request.yaml   |     70 +-
 .github/ISSUE_TEMPLATE/others.yaml            |     28 +-
 .github/pull_request_template.md              |     32 +-
 .github/workflows/build.yml                   |    428 +-
 .github/workflows/build_documentation.yml     |    132 +-
 .github/workflows/tests.yml                   |    458 +-
 .gitignore                                    |     90 +-
 .mailmap                                      |     54 +-
 .readthedocs.yaml                             |     38 +-
 CITATION.bib                                  |     50 +-
 CODE_OF_CONDUCT.md                            |     50 +-
 CONTRIBUTING.md                               |     14 +-
 LICENSE.txt                                   |     54 +-
 MANIFEST.in                                   |     22 +-
 README.md                                     |    228 +-
 VERSION                                       |      2 +-
 doc/branch.diff                               | 144221 ---------------
 .../dynamics/dynamics-bloch-redfield.rst      |      6 -
 pyproject.toml                                |    108 +-
 qutip/__init__.py                             |    136 +-
 qutip/_mkl/__init__.py                        |      2 +-
 qutip/_mkl/spmv.py                            |     76 +-
 qutip/_mkl/spsolve.py                         |    810 +-
 qutip/about.py                                |    150 +-
 qutip/bloch.py                                |   1856 +-
 qutip/bloch3d.py                              |   1034 +-
 qutip/cite.py                                 |    120 +-
 qutip/continuous_variables.py                 |    518 +-
 qutip/control.py                              |     26 +-
 qutip/core/__init__.py                        |     32 +-
 qutip/core/_brtensor.pyx                      |    674 +-
 qutip/core/_brtools.pxd                       |     64 +-
 qutip/core/_brtools.pyx                       |    654 +-
 qutip/core/blochredfield.py                   |    376 +-
 qutip/core/coefficient.py                     |   1552 +-
 qutip/core/cy/_element.pxd                    |     84 +-
 qutip/core/cy/_element.pyx                    |   1250 +-
 qutip/core/cy/coefficient.pxd                 |     10 +-
 qutip/core/cy/coefficient.pyx                 |   1456 +-
 qutip/core/cy/complex_math.pxd                |     48 +-
 qutip/core/cy/math.pxd                        |     10 +-
 qutip/core/cy/math.pyx                        |    318 +-
 qutip/core/cy/openmp/bench_openmp.py          |    308 +-
 qutip/core/cy/openmp/parfuncs.pxd             |     18 +-
 qutip/core/cy/openmp/parfuncs.pyx             |     26 +-
 qutip/core/cy/openmp/src/zspmv_openmp.cpp     |    332 +-
 qutip/core/cy/openmp/utilities.py             |     82 +-
 qutip/core/cy/qobjevo.pxd                     |     48 +-
 qutip/core/cy/qobjevo.pyx                     |   2038 +-
 qutip/core/data/__init__.pxd                  |     26 +-
 qutip/core/data/__init__.py                   |    112 +-
 qutip/core/data/_creator_utils.py             |     62 +-
 qutip/core/data/add.pxd                       |     24 +-
 qutip/core/data/add.pyx                       |    552 +-
 qutip/core/data/adjoint.pxd                   |     24 +-
 qutip/core/data/adjoint.pyx                   |    320 +-
 qutip/core/data/base.pxd                      |     34 +-
 qutip/core/data/base.pyx                      |    178 +-
 qutip/core/data/constant.py                   |    146 +-
 qutip/core/data/convert.pyx                   |    872 +-
 qutip/core/data/csr.pxd                       |    332 +-
 qutip/core/data/csr.pyx                       |   1930 +-
 qutip/core/data/dense.pxd                     |     60 +-
 qutip/core/data/dense.pyx                     |    818 +-
 qutip/core/data/dispatch.pyx                  |   1166 +-
 qutip/core/data/eigen.py                      |    908 +-
 qutip/core/data/expect.pxd                    |     32 +-
 qutip/core/data/expect.pyx                    |    650 +-
 qutip/core/data/expm.py                       |    186 +-
 qutip/core/data/inner.pxd                     |     12 +-
 qutip/core/data/inner.pyx                     |    572 +-
 qutip/core/data/kron.pxd                      |     10 +-
 qutip/core/data/kron.pyx                      |    182 +-
 qutip/core/data/linalg.py                     |    110 +-
 qutip/core/data/make.py                       |    202 +-
 qutip/core/data/matmul.pxd                    |     28 +-
 qutip/core/data/matmul.pyx                    |    948 +-
 qutip/core/data/mul.pxd                       |     26 +-
 qutip/core/data/mul.pyx                       |    268 +-
 qutip/core/data/norm.pxd                      |     30 +-
 qutip/core/data/norm.pyx                      |    458 +-
 qutip/core/data/permute.pxd                   |     14 +-
 qutip/core/data/permute.pyx                   |    810 +-
 qutip/core/data/pow.pxd                       |     10 +-
 qutip/core/data/pow.pyx                       |    172 +-
 qutip/core/data/project.pxd                   |     10 +-
 qutip/core/data/project.pyx                   |    288 +-
 qutip/core/data/properties.pxd                |     16 +-
 qutip/core/data/properties.pyx                |    638 +-
 qutip/core/data/ptrace.pxd                    |     14 +-
 qutip/core/data/ptrace.pyx                    |    432 +-
 qutip/core/data/reshape.pxd                   |     24 +-
 qutip/core/data/reshape.pyx                   |    570 +-
 qutip/core/data/solve.py                      |    416 +-
 qutip/core/data/src/intdtype.h                |      4 +-
 qutip/core/data/src/matmul_csr_vector.cpp     |    232 +-
 qutip/core/data/src/matmul_csr_vector.hpp     |     34 +-
 qutip/core/data/tidyup.pxd                    |     14 +-
 qutip/core/data/tidyup.pyx                    |    212 +-
 qutip/core/data/trace.pxd                     |     18 +-
 qutip/core/data/trace.pyx                     |    218 +-
 qutip/core/dimensions.py                      |    690 +-
 qutip/core/expect.py                          |    194 +-
 qutip/core/gates.py                           |   1494 +-
 qutip/core/metrics.py                         |   1180 +-
 qutip/core/operators.py                       |   2146 +-
 qutip/core/options.py                         |    246 +-
 qutip/core/qobj.py                            |   3622 +-
 qutip/core/semidefinite.py                    |    416 +-
 qutip/core/states.py                          |   2684 +-
 qutip/core/subsystem_apply.py                 |    420 +-
 qutip/core/superop_reps.py                    |   1044 +-
 qutip/core/superoperator.py                   |    824 +-
 qutip/core/tensor.py                          |    924 +-
 qutip/distributions.py                        |    844 +-
 qutip/entropy.py                              |    752 +-
 qutip/fileio.py                               |    514 +-
 qutip/ipynbtools.py                           |    652 +-
 qutip/logging_utils.py                        |    218 +-
 qutip/matplotlib_utilities.py                 |    308 +-
 qutip/measurement.py                          |    762 +-
 qutip/orbital.py                              |    162 +-
 qutip/partial_transpose.py                    |    244 +-
 qutip/qip.py                                  |     26 +-
 qutip/random_objects.py                       |   1736 +-
 qutip/settings.py                             |    586 +-
 qutip/simdiag.py                              |    240 +-
 qutip/solve/_piqs.pyx                         |   1282 +-
 qutip/solve/_stochastic.pyx                   |   4690 +-
 qutip/solve/nonmarkov/memorycascade.py        |    810 +-
 qutip/solve/nonmarkov/transfertensor.py       |    508 +-
 qutip/solve/optionsclass.py                   |    526 +-
 qutip/solve/parallel.py                       |    482 +-
 qutip/solve/pdpsolve.py                       |   1150 +-
 qutip/solve/piqs.py                           |   3852 +-
 qutip/solve/rcsolve.py                        |    254 +-
 qutip/solve/solver.py                         |   1844 +-
 qutip/solve/stochastic.py                     |   2810 +-
 qutip/solver/__init__.py                      |     36 +-
 qutip/solver/brmesolve.py                     |    724 +-
 qutip/solver/correlation.py                   |   1034 +-
 qutip/solver/countstat.py                     |    434 +-
 qutip/solver/floquet.py                       |   1862 +-
 qutip/solver/floquet_bwcomp.py                |    488 +-
 qutip/solver/heom/__init__.py                 |    110 +-
 qutip/solver/heom/bofin_baths.py              |   1964 +-
 qutip/solver/heom/bofin_solvers.py            |   2644 +-
 qutip/solver/integrator/__init__.py           |      8 +-
 qutip/solver/integrator/explicit_rk.pxd       |    126 +-
 qutip/solver/integrator/explicit_rk.pyx       |   1020 +-
 qutip/solver/integrator/integrator.py         |    480 +-
 qutip/solver/integrator/krylov.py             |    476 +-
 qutip/solver/integrator/qutip_integrator.py   |    400 +-
 qutip/solver/integrator/scipy_integrator.py   |   1054 +-
 qutip/solver/integrator/verner7efficient.py   |    666 +-
 qutip/solver/integrator/verner9efficient.py   |   1412 +-
 qutip/solver/krylovsolve.py                   |    204 +-
 qutip/solver/mcsolve.py                       |   1054 +-
 qutip/solver/mesolve.py                       |    434 +-
 qutip/solver/multitraj.py                     |    514 +-
 qutip/solver/options.py                       |    212 +-
 qutip/solver/parallel.py                      |    740 +-
 qutip/solver/propagator.py                    |    556 +-
 qutip/solver/result.py                        |   1944 +-
 qutip/solver/scattering.py                    |    602 +-
 qutip/solver/sesolve.py                       |    378 +-
 qutip/solver/solver_base.py                   |    790 +-
 qutip/solver/spectrum.py                      |    376 +-
 qutip/solver/steadystate.py                   |   1074 +-
 qutip/testing.py                              |     68 +-
 qutip/tests/Hadamard_params.ini               |     38 +-
 qutip/tests/conftest.py                       |    316 +-
 qutip/tests/core/data/conftest.py             |    132 +-
 qutip/tests/core/data/test_convert.py         |    156 +-
 qutip/tests/core/data/test_csr.py             |    908 +-
 qutip/tests/core/data/test_dense.py           |    594 +-
 qutip/tests/core/data/test_expect.py          |    134 +-
 qutip/tests/core/data/test_linalg.py          |    278 +-
 qutip/tests/core/data/test_mathematics.py     |   1904 +-
 qutip/tests/core/data/test_norm.py            |    138 +-
 qutip/tests/core/data/test_operators.py       |    138 +-
 qutip/tests/core/data/test_properties.py      |    350 +-
 qutip/tests/core/data/test_ptrace.py          |    216 +-
 qutip/tests/core/data/test_reshape.py         |    242 +-
 qutip/tests/core/test_brtools.py              |    670 +-
 qutip/tests/core/test_coefficient.py          |    794 +-
 qutip/tests/core/test_dimensions.py           |    402 +-
 qutip/tests/core/test_eigen.py                |    236 +-
 qutip/tests/core/test_eigenstates.py          |    196 +-
 qutip/tests/core/test_expect.py               |    358 +-
 qutip/tests/core/test_gates.py                |    288 +-
 qutip/tests/core/test_metrics.py              |   1102 +-
 qutip/tests/core/test_operators.py            |    590 +-
 qutip/tests/core/test_ptrace.py               |    260 +-
 qutip/tests/core/test_qobj.py                 |   2456 +-
 qutip/tests/core/test_qobjevo.py              |   1030 +-
 qutip/tests/core/test_states.py               |    636 +-
 qutip/tests/core/test_superop_reps.py         |    694 +-
 qutip/tests/core/test_superoper.py            |    538 +-
 qutip/tests/core/test_tensor.py               |    514 +-
 qutip/tests/pytest.ini                        |     10 +-
 qutip/tests/solve/test_piqs.py                |   3072 +-
 qutip/tests/solve/test_qubit_evolution.py     |    248 +-
 qutip/tests/solve/test_stochastic_me.py       |    618 +-
 qutip/tests/solve/test_stochastic_se.py       |    460 +-
 qutip/tests/solver/heom/test_bofin_baths.py   |    930 +-
 qutip/tests/solver/heom/test_bofin_solvers.py |   2792 +-
 qutip/tests/solver/heom/test_heom.py          |     92 +-
 qutip/tests/solver/test_brmesolve.py          |    592 +-
 qutip/tests/solver/test_correlation.py        |    658 +-
 qutip/tests/solver/test_countstat.py          |    180 +-
 qutip/tests/solver/test_floquet.py            |    666 +-
 qutip/tests/solver/test_integrator.py         |    328 +-
 qutip/tests/solver/test_mcsolve.py            |    878 +-
 qutip/tests/solver/test_mesolve.py            |   1354 +-
 qutip/tests/solver/test_options.py            |    284 +-
 qutip/tests/solver/test_parallel.py           |    242 +-
 qutip/tests/solver/test_propagator.py         |    280 +-
 qutip/tests/solver/test_results.py            |    704 +-
 qutip/tests/solver/test_scattering.py         |    184 +-
 qutip/tests/solver/test_sesolve.py            |    602 +-
 qutip/tests/solver/test_steadystate.py        |    482 +-
 qutip/tests/test_basis_transformation.py      |    110 +-
 qutip/tests/test_bloch.py                     |    958 +-
 qutip/tests/test_enr_state_operator.py        |    232 +-
 qutip/tests/test_entropy.py                   |    424 +-
 qutip/tests/test_fileio.py                    |    124 +-
 qutip/tests/test_ipynbtools.py                |     48 +-
 qutip/tests/test_measurement.py               |    648 +-
 qutip/tests/test_mkl.py                       |    232 +-
 qutip/tests/test_openmp.py                    |    222 +-
 qutip/tests/test_orbital.py                   |    110 +-
 qutip/tests/test_partial_transpose.py         |    156 +-
 qutip/tests/test_qip.py                       |     92 +-
 qutip/tests/test_qpt.py                       |    100 +-
 qutip/tests/test_random.py                    |    622 +-
 qutip/tests/test_simdiag.py                   |    184 +-
 qutip/tests/test_subsys_apply.py              |    282 +-
 qutip/tests/test_three_level.py               |     54 +-
 qutip/tests/test_transfertensor.py            |     90 +-
 qutip/tests/test_utilities.py                 |    242 +-
 qutip/tests/test_wigner.py                    |   1386 +-
 qutip/three_level_atom.py                     |    148 +-
 qutip/tomography.py                           |    380 +-
 qutip/ui/__init__.py                          |      2 +-
 qutip/ui/progressbar.py                       |    424 +-
 qutip/utilities.py                            |    664 +-
 qutip/visualization.py                        |   3638 +-
 qutip/wigner.py                               |   2006 +-
 requirements.txt                              |      8 +-
 setup.cfg                                     |    140 +-
 setup.py                                      |    624 +-
 255 files changed, 71470 insertions(+), 215697 deletions(-)
 delete mode 100644 doc/branch.diff

diff --git a/.codeclimate.yml b/.codeclimate.yml
index 68f82f86ac..35d5f48a17 100644
--- a/.codeclimate.yml
+++ b/.codeclimate.yml
@@ -1,46 +1,46 @@
-version: "2"
-exclude_patterns:
-- "doc/"
-- "dist/"
-- "**/tests/"
-checks:
-  argument-count:
-    config:
-      threshold: 10
-  complex-logic:
-    config:
-      threshold: 20
-  file-lines:
-    enabled: false
-  method-complexity:
-    config:
-      threshold: 20
-  method-count:
-    config:
-      threshold: 75
-  method-lines:
-    config:
-      threshold: 100
-  nested-control-flow:
-    config:
-      threshold: 4
-  return-statements:
-    config:
-      threshold: 4
-  similar-code:
-    config:
-      threshold: 64
-  identical-code:
-    config:
-      threshold: 64
-plugins:
-  fixme:
-    enabled: true
-  pep8:
-    enabled: true
-  duplication:
-    enabled: true
-    config:
-      languages:
-        python:
-          python_version: 3
+version: "2"
+exclude_patterns:
+- "doc/"
+- "dist/"
+- "**/tests/"
+checks:
+  argument-count:
+    config:
+      threshold: 10
+  complex-logic:
+    config:
+      threshold: 20
+  file-lines:
+    enabled: false
+  method-complexity:
+    config:
+      threshold: 20
+  method-count:
+    config:
+      threshold: 75
+  method-lines:
+    config:
+      threshold: 100
+  nested-control-flow:
+    config:
+      threshold: 4
+  return-statements:
+    config:
+      threshold: 4
+  similar-code:
+    config:
+      threshold: 64
+  identical-code:
+    config:
+      threshold: 64
+plugins:
+  fixme:
+    enabled: true
+  pep8:
+    enabled: true
+  duplication:
+    enabled: true
+    config:
+      languages:
+        python:
+          python_version: 3
diff --git a/.coveragerc b/.coveragerc
index ca1eba23d6..96024441ef 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,10 +1,10 @@
-[run]
-source = qutip
-omit =
-    # QuTiP test files
-    */qutip/tests/*
-
-[report]
-exclude_lines =
-    # Skip Python wrappers which help load in C extension modules.
-    __bootstrap__()
+[run]
+source = qutip
+omit =
+    # QuTiP test files
+    */qutip/tests/*
+
+[report]
+exclude_lines =
+    # Skip Python wrappers which help load in C extension modules.
+    __bootstrap__()
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml
index b297a12bb3..b942d02aa4 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@@ -1,53 +1,53 @@
-name: 🐛 Bug Report
-description: Spotted a bug? Report it to us!
-labels: ["bug"]
-body:
-  - type: textarea
-    id: bug-description
-    attributes:
-      label: Bug Description
-      description: Tell us what went wrong (including what triggered the bug)
-      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
-    validations:
-      required: true
-  - type: textarea
-    id: code-to-reproduce
-    attributes:
-      label: Code to Reproduce the Bug
-      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
-      placeholder: "from qutip import identity\nprint(identity(2))"
-      render: shell
-  - type: textarea
-    id: bug-output
-    attributes:
-      label: Code Output
-      description: Please paste the relevant output here (automatically formatted)
-      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
-      render: shell
-  - type: textarea
-    id: expected-behaviour
-    attributes:
-      label: Expected Behaviour
-      description: What should have happened instead?
-      placeholder: "A clear and concise description of what you expected to happen"
-    validations:
-      required: true
-  - type: textarea
-    id: your-environment
-    attributes:
-      label: Your Environment
-      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
-      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: Add anything else you want to tell us. You can include images, plots, etc.
-      placeholder: "Additional information, images, graphs, plots, etc."
-  - type: markdown
-    id: thank-you
-    attributes:
+name: 🐛 Bug Report
+description: Spotted a bug? Report it to us!
+labels: ["bug"]
+body:
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: Bug Description
+      description: Tell us what went wrong (including what triggered the bug)
+      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
+    validations:
+      required: true
+  - type: textarea
+    id: code-to-reproduce
+    attributes:
+      label: Code to Reproduce the Bug
+      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
+      placeholder: "from qutip import identity\nprint(identity(2))"
+      render: shell
+  - type: textarea
+    id: bug-output
+    attributes:
+      label: Code Output
+      description: Please paste the relevant output here (automatically formatted)
+      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
+      render: shell
+  - type: textarea
+    id: expected-behaviour
+    attributes:
+      label: Expected Behaviour
+      description: What should have happened instead?
+      placeholder: "A clear and concise description of what you expected to happen"
+    validations:
+      required: true
+  - type: textarea
+    id: your-environment
+    attributes:
+      label: Your Environment
+      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
+      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add anything else you want to tell us. You can include images, plots, etc.
+      placeholder: "Additional information, images, graphs, plots, etc."
+  - type: markdown
+    id: thank-you
+    attributes:
       value: Thanks for taking the time to fill out this bug report!
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
index a39ab3fc05..d0a2805406 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yaml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yaml
@@ -1,36 +1,36 @@
-name: 🚀 Feature Request
-description: Suggest an idea for this project!
-labels: ["ENH"]
-body:
-  - type: textarea
-    id: problem-description
-    attributes:
-      label: Problem Description
-      description: Give us a clear and concise description of what the problem is!
-      placeholder: "Example - It would be better if [...]"
-    validations:
-      required: true
-  - type: textarea
-    id: proposed-solution
-    attributes:
-      label: Proposed Solution
-      description: Give us a description of your proposed solution
-      placeholder: "A clear and concise description of what you want to happen"
-    validations:
-      required: true
-  - type: textarea
-    id: alternate-solutions
-    attributes:
-      label: Alternate Solutions
-      description: Are there other ways of implementing this feature?
-      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: You can tell us more about your idea, add code snippets or images, etc.
-      placeholder: "Give us more context or screenshots about the feature request here"
-  - type: markdown
-    id: thank-you
-    attributes:
+name: 🚀 Feature Request
+description: Suggest an idea for this project!
+labels: ["ENH"]
+body:
+  - type: textarea
+    id: problem-description
+    attributes:
+      label: Problem Description
+      description: Give us a clear and concise description of what the problem is!
+      placeholder: "Example - It would be better if [...]"
+    validations:
+      required: true
+  - type: textarea
+    id: proposed-solution
+    attributes:
+      label: Proposed Solution
+      description: Give us a description of your proposed solution
+      placeholder: "A clear and concise description of what you want to happen"
+    validations:
+      required: true
+  - type: textarea
+    id: alternate-solutions
+    attributes:
+      label: Alternate Solutions
+      description: Are there other ways of implementing this feature?
+      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: You can tell us more about your idea, add code snippets or images, etc.
+      placeholder: "Give us more context or screenshots about the feature request here"
+  - type: markdown
+    id: thank-you
+    attributes:
       value: Thanks for taking the time to fill out this feature request!
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/others.yaml b/.github/ISSUE_TEMPLATE/others.yaml
index 77ac0ab4eb..7750f51837 100644
--- a/.github/ISSUE_TEMPLATE/others.yaml
+++ b/.github/ISSUE_TEMPLATE/others.yaml
@@ -1,15 +1,15 @@
-name: 🤔 Others
-description: Tell us about issues that aren't exactly bugs or features
-body:
-  - type: textarea
-    id: issue-description
-    attributes:
-      label: Describe the Issue!
-      description: Tell us about your issue. You can include screenshots, code snippets, etc.
-      placeholder: "Please describe the issue here"
-    validations:
-      required: true
-  - type: markdown
-    id: thank-you
-    attributes:
+name: 🤔 Others
+description: Tell us about issues that aren't exactly bugs or features
+body:
+  - type: textarea
+    id: issue-description
+    attributes:
+      label: Describe the Issue!
+      description: Tell us about your issue. You can include screenshots, code snippets, etc.
+      placeholder: "Please describe the issue here"
+    validations:
+      required: true
+  - type: markdown
+    id: thank-you
+    attributes:
       value: Thanks for taking the time to fill out this issue!
\ No newline at end of file
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 99453d7a6c..d68410d7cb 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,17 +1,17 @@
-**Checklist**
-Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
-
-- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
-- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
-You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
-- [ ] Please add tests to cover your changes if applicable.
-- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
-- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
-
-Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
-
-**Description**
-Describe here the proposed change.
-
-**Related issues or PRs**
+**Checklist**
+Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
+
+- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
+- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
+You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
+- [ ] Please add tests to cover your changes if applicable.
+- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
+- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
+
+Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
+
+**Description**
+Describe here the proposed change.
+
+**Related issues or PRs**
 Please mention the related issues or PRs here. If the PR fixes an issue, use the keyword fix/fixes/fixed followed by the issue id, e.g. fix #1184
\ No newline at end of file
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f0b852501a..45b648fa35 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,214 +1,214 @@
-name: Build wheels, optionally deploy to PyPI
-
-on:
-  workflow_dispatch:
-    inputs:
-      confirm_ref:
-        description: "Confirm chosen branch name to deploy to PyPI (optional):"
-        default: ""
-      override_version:
-        description: "Override version number (optional):"
-        default: ""
-
-
-jobs:
-  # The deploy_test job is part of the test of whether we should deploy to PyPI
-  # or test.PyPI. The job will succeed if either the confirmation reference is
-  # empty, 'test' or if the confirmation is the selected branch or tag name.
-  # It will fail if it is nonempty and does not match.  All later jobs depend
-  # on this job, so that they will be immediately cancelled if the confirmation
-  # is bad.  The dependency is currently necessary (2021-03) because GitHub
-  # Actions does not have a simpler method of cancelling an entire workflow---
-  # the normal use-case expects to try and run as much as possible despite one
-  # or two failures.
-  deploy_test:
-    name: Verify PyPI deployment confirmation
-    runs-on: ubuntu-latest
-    env:
-      GITHUB_REF: ${{ github.ref }}
-      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
-    steps:
-      - name: Compare confirmation to current reference
-        shell: bash
-        run: |
-          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
-          if [[ $CONFIRM_REF == "test" ]]; then
-            echo "Build and deploy to test.pypi.org."
-          elif [[ -z $CONFIRM_REF ]]; then
-            echo "Build only.  Nothing will be uploaded to PyPI."
-          else
-            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
-          fi
-
-
-  build_sdist:
-    name: Build sdist on Ubuntu
-    needs: deploy_test
-    runs-on: ubuntu-latest
-    env:
-      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          # For the sdist we should be as conservative as possible with our
-          # Python version.  This should be the lowest supported version.  This
-          # means that no unsupported syntax can sneak through.
-          python-version: '3.8'
-
-      - name: Install pip build
-        run: |
-          python -m pip install 'build'
-
-      - name: Build sdist tarball
-        shell: bash
-        run: |
-          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
-          # The build package is the reference PEP 517 package builder.  All
-          # dependencies are specified by our setup code.
-          python -m build --sdist .
-
-      # Zip files are not part of PEP 517, so we need to make our own.
-      - name: Create zipfile from tarball
-        shell: bash
-        working-directory: dist
-        run: |
-          # First assert that there is exactly one tarball, and find its name.
-          shopt -s failglob
-          tarball_pattern="*.tar.gz"
-          tarballs=($tarball_pattern)
-          [[ ${#tarballs[@]} == 1 ]]
-          tarball="${tarballs[0]}"
-          # Get the stem and make the zipfile name.
-          stem="${tarball%.tar.gz}"
-          zipfile="${stem}.zip"
-          # Extract the tarball and rezip it.
-          tar -xzf "$tarball"
-          zip "$zipfile" -r "$stem"
-          rm -r "$stem"
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: sdist
-          path: |
-            dist/*.tar.gz
-            dist/*.zip
-          if-no-files-found: error
-
-
-  build_wheels:
-    name: Build wheels on ${{ matrix.os }}
-    needs: deploy_test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    env:
-      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
-      CIBW_BUILD: "cp3{8,9,10,11}-*"
-      # Numpy and SciPy do not supply wheels for i686 or win32 for
-      # Python 3.10+, so we skip those:
-      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
-      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          # This is about the build environment, not the released wheel version.
-          python-version: '3.8'
-
-      - name: Install cibuildwheel
-        run: |
-          # cibuildwheel does the heavy lifting for us. Originally tested on
-          # 2.11.3, but should be fine at least up to any minor new release.
-          python -m pip install 'cibuildwheel==2.11.*'
-
-      - name: Build wheels
-        shell: bash
-        run: |
-          # If the version override was specified, then write it the VERSION
-          # file with it.
-          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
-          python -m cibuildwheel --output-dir wheelhouse
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: wheels
-          path: ./wheelhouse/*.whl
-
-
-  deploy:
-    name: "Deploy to PyPI if desired"
-    # The confirmation is tested explicitly in `deploy_test`, so we know it is
-    # either a missing confirmation (so we shouldn't run this job), 'test' or a
-    # valid confirmation.  We don't need to retest the value of the
-    # confirmation, beyond checking that one existed.
-    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
-    needs: [deploy_test, build_sdist, build_wheels]
-    runs-on: ubuntu-latest
-    env:
-      TWINE_USERNAME: __token__
-      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-      TWINE_NON_INTERACTIVE: 1
-      TWINE_REPOSITORY: pypi
-
-    steps:
-      - name: Download build artifacts to local runner
-        uses: actions/download-artifact@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          python-version: '3.8'
-
-      - name: Verify this is not a dev version
-        shell: bash
-        run: |
-          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
-          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
-
-      # We built the zipfile for convenience distributing to Windows users on
-      # our end, but PyPI only needs the tarball.
-      - name: Upload sdist and wheels to PyPI
-        run: |
-          python -m pip install "twine"
-          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
-
-
-  deploy_testpypi:
-    name: "Deploy to TestPyPI if desired"
-    if: ${{ github.event.inputs.confirm_ref == 'test' }}
-    needs: [deploy_test, build_sdist, build_wheels]
-    runs-on: ubuntu-latest
-    env:
-      TWINE_USERNAME: __token__
-      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
-      TWINE_NON_INTERACTIVE: 1
-
-    steps:
-      - name: Download build artifacts to local runner
-        uses: actions/download-artifact@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          python-version: '3.8'
-
-      - name: Verify this is not a dev version
-        shell: bash
-        run: |
-          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
-          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
-
-      # We built the zipfile for convenience distributing to Windows users on
-      # our end, but PyPI only needs the tarball.
-      - name: Upload sdist and wheels to TestPyPI
-        run: |
-          python -m pip install "twine"
-          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
+name: Build wheels, optionally deploy to PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      confirm_ref:
+        description: "Confirm chosen branch name to deploy to PyPI (optional):"
+        default: ""
+      override_version:
+        description: "Override version number (optional):"
+        default: ""
+
+
+jobs:
+  # The deploy_test job is part of the test of whether we should deploy to PyPI
+  # or test.PyPI. The job will succeed if either the confirmation reference is
+  # empty, 'test' or if the confirmation is the selected branch or tag name.
+  # It will fail if it is nonempty and does not match.  All later jobs depend
+  # on this job, so that they will be immediately cancelled if the confirmation
+  # is bad.  The dependency is currently necessary (2021-03) because GitHub
+  # Actions does not have a simpler method of cancelling an entire workflow---
+  # the normal use-case expects to try and run as much as possible despite one
+  # or two failures.
+  deploy_test:
+    name: Verify PyPI deployment confirmation
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_REF: ${{ github.ref }}
+      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
+    steps:
+      - name: Compare confirmation to current reference
+        shell: bash
+        run: |
+          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
+          if [[ $CONFIRM_REF == "test" ]]; then
+            echo "Build and deploy to test.pypi.org."
+          elif [[ -z $CONFIRM_REF ]]; then
+            echo "Build only.  Nothing will be uploaded to PyPI."
+          else
+            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
+          fi
+
+
+  build_sdist:
+    name: Build sdist on Ubuntu
+    needs: deploy_test
+    runs-on: ubuntu-latest
+    env:
+      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          # For the sdist we should be as conservative as possible with our
+          # Python version.  This should be the lowest supported version.  This
+          # means that no unsupported syntax can sneak through.
+          python-version: '3.8'
+
+      - name: Install pip build
+        run: |
+          python -m pip install 'build'
+
+      - name: Build sdist tarball
+        shell: bash
+        run: |
+          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
+          # The build package is the reference PEP 517 package builder.  All
+          # dependencies are specified by our setup code.
+          python -m build --sdist .
+
+      # Zip files are not part of PEP 517, so we need to make our own.
+      - name: Create zipfile from tarball
+        shell: bash
+        working-directory: dist
+        run: |
+          # First assert that there is exactly one tarball, and find its name.
+          shopt -s failglob
+          tarball_pattern="*.tar.gz"
+          tarballs=($tarball_pattern)
+          [[ ${#tarballs[@]} == 1 ]]
+          tarball="${tarballs[0]}"
+          # Get the stem and make the zipfile name.
+          stem="${tarball%.tar.gz}"
+          zipfile="${stem}.zip"
+          # Extract the tarball and rezip it.
+          tar -xzf "$tarball"
+          zip "$zipfile" -r "$stem"
+          rm -r "$stem"
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: sdist
+          path: |
+            dist/*.tar.gz
+            dist/*.zip
+          if-no-files-found: error
+
+
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    needs: deploy_test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    env:
+      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
+      CIBW_BUILD: "cp3{8,9,10,11}-*"
+      # Numpy and SciPy do not supply wheels for i686 or win32 for
+      # Python 3.10+, so we skip those:
+      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
+      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          # This is about the build environment, not the released wheel version.
+          python-version: '3.8'
+
+      - name: Install cibuildwheel
+        run: |
+          # cibuildwheel does the heavy lifting for us. Originally tested on
+          # 2.11.3, but should be fine at least up to any minor new release.
+          python -m pip install 'cibuildwheel==2.11.*'
+
+      - name: Build wheels
+        shell: bash
+        run: |
+          # If the version override was specified, then write it the VERSION
+          # file with it.
+          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
+          python -m cibuildwheel --output-dir wheelhouse
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: ./wheelhouse/*.whl
+
+
+  deploy:
+    name: "Deploy to PyPI if desired"
+    # The confirmation is tested explicitly in `deploy_test`, so we know it is
+    # either a missing confirmation (so we shouldn't run this job), 'test' or a
+    # valid confirmation.  We don't need to retest the value of the
+    # confirmation, beyond checking that one existed.
+    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
+    needs: [deploy_test, build_sdist, build_wheels]
+    runs-on: ubuntu-latest
+    env:
+      TWINE_USERNAME: __token__
+      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+      TWINE_NON_INTERACTIVE: 1
+      TWINE_REPOSITORY: pypi
+
+    steps:
+      - name: Download build artifacts to local runner
+        uses: actions/download-artifact@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          python-version: '3.8'
+
+      - name: Verify this is not a dev version
+        shell: bash
+        run: |
+          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
+          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
+
+      # We built the zipfile for convenience distributing to Windows users on
+      # our end, but PyPI only needs the tarball.
+      - name: Upload sdist and wheels to PyPI
+        run: |
+          python -m pip install "twine"
+          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
+
+
+  deploy_testpypi:
+    name: "Deploy to TestPyPI if desired"
+    if: ${{ github.event.inputs.confirm_ref == 'test' }}
+    needs: [deploy_test, build_sdist, build_wheels]
+    runs-on: ubuntu-latest
+    env:
+      TWINE_USERNAME: __token__
+      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
+      TWINE_NON_INTERACTIVE: 1
+
+    steps:
+      - name: Download build artifacts to local runner
+        uses: actions/download-artifact@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          python-version: '3.8'
+
+      - name: Verify this is not a dev version
+        shell: bash
+        run: |
+          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
+          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
+
+      # We built the zipfile for convenience distributing to Windows users on
+      # our end, but PyPI only needs the tarball.
+      - name: Upload sdist and wheels to TestPyPI
+        run: |
+          python -m pip install "twine"
+          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml
index 33d94a88ac..b5c6eb9cf6 100644
--- a/.github/workflows/build_documentation.yml
+++ b/.github/workflows/build_documentation.yml
@@ -1,66 +1,66 @@
-name: Build documentation
-
-on:
-  [push, pull_request]
-
-jobs:
-  build:
-    name: Build documentation
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-python@v4
-        name: Install Python
-        with:
-          python-version: '3.8'
-
-      - name: Install documentation dependencies
-        run: |
-          pip install pip --upgrade
-          python -mpip install -r doc/requirements.txt
-          sudo apt-get update
-          sudo apt-get install texlive-full
-
-      - name: Install QuTiP from GitHub
-        run: |
-          # Build without build isolation so that we use the build
-          # dependencies already installed from doc/requirements.txt.
-          python -m pip install -e .[full] --no-build-isolation
-          # Install in editable mode so it doesn't matter if we import from
-          # inside the installation directory, otherwise we can get some errors
-          # because we're importing from the wrong location.
-          python -c 'import qutip; qutip.about()'
-
-      - name: Build PDF documentation
-        working-directory: doc
-        run: |
-          make latexpdf SPHINXOPTS="-W --keep-going -T"
-          # Above flags are:
-          #   -W : turn warnings into errors
-          #   --keep-going : do not stop after the first error
-          #   -T : display a full traceback if a Python exception occurs
-
-      - name: Upload built PDF files
-        uses: actions/upload-artifact@v3
-        with:
-          name: qutip_pdf_docs
-          path: doc/_build/latex/*
-          if-no-files-found: error
-
-      - name: Build HTML documentation
-        working-directory: doc
-        run: |
-          make html SPHINXOPTS="-W --keep-going -T"
-          # Above flags are:
-          #   -W : turn warnings into errors
-          #   --keep-going : do not stop after the first error
-          #   -T : display a full traceback if a Python exception occurs
-
-      - name: Upload built HTML files
-        uses: actions/upload-artifact@v3
-        with:
-          name: qutip_html_docs
-          path: doc/_build/html/*
-          if-no-files-found: error
+name: Build documentation
+
+on:
+  [push, pull_request]
+
+jobs:
+  build:
+    name: Build documentation
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        name: Install Python
+        with:
+          python-version: '3.8'
+
+      - name: Install documentation dependencies
+        run: |
+          pip install pip --upgrade
+          python -mpip install -r doc/requirements.txt
+          sudo apt-get update
+          sudo apt-get install texlive-full
+
+      - name: Install QuTiP from GitHub
+        run: |
+          # Build without build isolation so that we use the build
+          # dependencies already installed from doc/requirements.txt.
+          python -m pip install -e .[full] --no-build-isolation
+          # Install in editable mode so it doesn't matter if we import from
+          # inside the installation directory, otherwise we can get some errors
+          # because we're importing from the wrong location.
+          python -c 'import qutip; qutip.about()'
+
+      - name: Build PDF documentation
+        working-directory: doc
+        run: |
+          make latexpdf SPHINXOPTS="-W --keep-going -T"
+          # Above flags are:
+          #   -W : turn warnings into errors
+          #   --keep-going : do not stop after the first error
+          #   -T : display a full traceback if a Python exception occurs
+
+      - name: Upload built PDF files
+        uses: actions/upload-artifact@v3
+        with:
+          name: qutip_pdf_docs
+          path: doc/_build/latex/*
+          if-no-files-found: error
+
+      - name: Build HTML documentation
+        working-directory: doc
+        run: |
+          make html SPHINXOPTS="-W --keep-going -T"
+          # Above flags are:
+          #   -W : turn warnings into errors
+          #   --keep-going : do not stop after the first error
+          #   -T : display a full traceback if a Python exception occurs
+
+      - name: Upload built HTML files
+        uses: actions/upload-artifact@v3
+        with:
+          name: qutip_html_docs
+          path: doc/_build/html/*
+          if-no-files-found: error
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index de383e1f6d..dd172510de 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -1,229 +1,229 @@
-# The name is short because we mostly care how it appears in the pull request
-# "checks" dialogue box - it looks like
-#     Tests / ubuntu-latest, python-3.9, defaults
-# or similar.
-name: Tests
-
-on:
-    [push, pull_request]
-
-defaults:
-  run:
-    # The slightly odd shell call is to force bash to read .bashrc, which is
-    # necessary for having conda behave sensibly.  We use bash as the shell even
-    # on Windows, since we don't run anything much complicated, and it makes
-    # things much simpler.
-    shell: bash -l -e {0}
-
-jobs:
-  cases:
-    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
-    runs-on: ${{ matrix.os }}
-    env:
-      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest]
-        # Test other versions of Python in special cases to avoid exploding the
-        # matrix size; make sure to test all supported versions in some form.
-        python-version: ["3.9"]
-        case-name: [defaults]
-        numpy-requirement: [">=1.20,<1.21"]
-        coverage-requirement: ["==6.5"]
-        # Extra special cases.  In these, the new variable defined should always
-        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
-        # the lack of a variable is _always_ false-y, and the defaults lack all
-        # the special cases.
-        include:
-          # Mac
-          # Mac has issues with MKL since september 2022.
-          - case-name: macos
-            os: macos-latest
-            python-version: "3.10"
-            condaforge: 1
-            nomkl: 1
-
-          # Scipy 1.5
-          - case-name: old SciPy
-            os: ubuntu-latest
-            python-version: "3.8"
-            numpy-requirement: ">=1.20,<1.21"
-            scipy-requirement: ">=1.5,<1.6"
-            condaforge: 1
-
-          # No MKL runs.  MKL is now the default for conda installations, but
-          # not necessarily for pip.
-          - case-name: no MKL
-            os: ubuntu-latest
-            python-version: "3.9"
-            numpy-requirement: ">=1.20,<1.21"
-            nomkl: 1
-
-          # Builds without Cython at runtime.  This is a core feature;
-          # everything should be able to run this.
-          - case-name: no Cython
-            os: ubuntu-latest
-            python-version: "3.8"
-            nocython: 1
-
-          # Python 3.10 and numpy 1.22
-          # Use conda-forge to provide numpy 1.22
-          - case-name: Python 3.10
-            os: ubuntu-latest
-            python-version: "3.10"
-            condaforge: 1
-
-          # Python 3.11 and latest numpy
-          # Use conda-forge to provide Python 3.11 and latest numpy
-          # Ignore deprecation of the cgi module in Python 3.11 that is
-          # still imported by Cython.Tempita. This was addressed in
-          # https://github.com/cython/cython/pull/5128 but not backported
-          # to any currently released version.
-          - case-name: Python 3.11
-            os: ubuntu-latest
-            python-version: "3.11"
-            condaforge: 1
-            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
-            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
-
-          # Windows. Once all tests pass without special options needed, this
-          # can be moved to the main os list in the test matrix. All the tests
-          # that fail currently seem to do so because mcsolve uses
-          # multiprocessing under the hood. Windows does not support fork()
-          # well, which makes transfering objects to the child processes
-          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
-          - case-name: Windows Latest
-            os: windows-latest
-            python-version: "3.10"
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: conda-incubator/setup-miniconda@v2
-        with:
-          auto-update-conda: true
-          python-version: ${{ matrix.python-version }}
-          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
-
-      - name: Install QuTiP and dependencies
-        # In the run, first we handle any special cases.  We do this in bash
-        # rather than in the GitHub Actions file directly, because bash gives us
-        # a proper programming language to use.
-        run: |
-          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
-          if [[ -z "${{ matrix.nocython }}" ]]; then
-            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
-          fi
-          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
-          if [[ -z "${{ matrix.nomkl }}" ]]; then
-            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
-            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
-            # pip not automatically linking to MKL.
-            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-          else
-            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-          fi
-          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
-            conda install "${{ matrix.conda-extra-pkgs }}"
-          fi
-          python -m pip install -e .[$QUTIP_TARGET]
-          python -m pip install "coverage${{ matrix.coverage-requirement }}"
-          python -m pip install pytest-cov coveralls pytest-fail-slow
-
-      - name: Package information
-        run: |
-          conda list
-          python -c "import qutip; qutip.about()"
-          python -c "import qutip; print(qutip.settings)"
-
-      - name: Environment information
-        run: |
-          uname -a
-          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
-              hostnamectl
-              lscpu
-              free -h
-          fi
-
-      - name: Run tests
-        # If our tests are running for longer than an hour, _something_ is wrong
-        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
-        # to see if something hung.
-        timeout-minutes: 60
-        run: |
-          if [[ -n "${{ matrix.openmp }}" ]]; then
-            # Force OpenMP runs to use more threads, even if there aren't
-            # actually that many CPUs.  We have to check any dispatch code is
-            # truly being executed.
-            export QUTIP_NUM_PROCESSES=2
-          fi
-          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
-          # Above flags are:
-          #  -Werror
-          #     treat warnings as errors
-          #  --strict-config
-          #     error out if the configuration file is not parseable
-          #  --strict-markers
-          #     error out if a marker is used but not defined in the
-          #     configuration file
-          #  --timeout=300
-          #     error any individual test that goes longer than the given time
-          #  --durations=0 --durations-min=1.0
-          #     at the end, show a list of all the tests that took longer than a
-          #     second to run
-          #  --verbosity=1
-          #     turn the verbosity up so pytest prints the names of the tests
-          #     it's currently working on
-          #  --cov=qutip
-          #     limit coverage reporting to code that's within the qutip package
-          #  --cov-report=
-          #     don't print the coverage report to the terminal---it just adds
-          #     cruft, and we're going to upload the .coverage file to Coveralls
-          #  --color=yes
-          #     force coloured output in the terminal
-
-      - name: Upload to Coveralls
-        env:
-          GITHUB_TOKEN: ${{ secrets.github_token }}
-          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
-          COVERALLS_PARALLEL: true
-        run: coveralls --service=github
-
-  towncrier-check:
-    name: Verify Towncrier entry added
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Install Towncrier
-        run: |
-          python -m pip install towncrier
-
-      - name: Verify Towncrier entry added
-        if: github.event_name == 'pull_request'
-        env:
-          BASE_BRANCH: ${{ github.base_ref }}
-        run: |
-          # Fetch the pull request' base branch so towncrier will be able to
-          # compare the current branch with the base branch.
-          # Source: https://github.com/actions/checkout/#fetch-all-branches.
-          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
-          towncrier check --compare-with origin/${BASE_BRANCH}
-          towncrier build --version "$(cat VERSION)" --draft
-
-  finalise:
-    name: Finalise coverage reporting
-    needs: cases
-    runs-on: ubuntu-latest
-    container: python:3-slim
-    steps:
-      - name: Finalise coverage reporting
-        env:
-          GITHUB_TOKEN: ${{ secrets.github_token }}
-        run: |
-          python -m pip install coveralls
-          coveralls --service=github --finish
+# The name is short because we mostly care how it appears in the pull request
+# "checks" dialogue box - it looks like
+#     Tests / ubuntu-latest, python-3.9, defaults
+# or similar.
+name: Tests
+
+on:
+    [push, pull_request]
+
+defaults:
+  run:
+    # The slightly odd shell call is to force bash to read .bashrc, which is
+    # necessary for having conda behave sensibly.  We use bash as the shell even
+    # on Windows, since we don't run anything much complicated, and it makes
+    # things much simpler.
+    shell: bash -l -e {0}
+
+jobs:
+  cases:
+    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
+    runs-on: ${{ matrix.os }}
+    env:
+      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        # Test other versions of Python in special cases to avoid exploding the
+        # matrix size; make sure to test all supported versions in some form.
+        python-version: ["3.9"]
+        case-name: [defaults]
+        numpy-requirement: [">=1.20,<1.21"]
+        coverage-requirement: ["==6.5"]
+        # Extra special cases.  In these, the new variable defined should always
+        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
+        # the lack of a variable is _always_ false-y, and the defaults lack all
+        # the special cases.
+        include:
+          # Mac
+          # Mac has issues with MKL since september 2022.
+          - case-name: macos
+            os: macos-latest
+            python-version: "3.10"
+            condaforge: 1
+            nomkl: 1
+
+          # Scipy 1.5
+          - case-name: old SciPy
+            os: ubuntu-latest
+            python-version: "3.8"
+            numpy-requirement: ">=1.20,<1.21"
+            scipy-requirement: ">=1.5,<1.6"
+            condaforge: 1
+
+          # No MKL runs.  MKL is now the default for conda installations, but
+          # not necessarily for pip.
+          - case-name: no MKL
+            os: ubuntu-latest
+            python-version: "3.9"
+            numpy-requirement: ">=1.20,<1.21"
+            nomkl: 1
+
+          # Builds without Cython at runtime.  This is a core feature;
+          # everything should be able to run this.
+          - case-name: no Cython
+            os: ubuntu-latest
+            python-version: "3.8"
+            nocython: 1
+
+          # Python 3.10 and numpy 1.22
+          # Use conda-forge to provide numpy 1.22
+          - case-name: Python 3.10
+            os: ubuntu-latest
+            python-version: "3.10"
+            condaforge: 1
+
+          # Python 3.11 and latest numpy
+          # Use conda-forge to provide Python 3.11 and latest numpy
+          # Ignore deprecation of the cgi module in Python 3.11 that is
+          # still imported by Cython.Tempita. This was addressed in
+          # https://github.com/cython/cython/pull/5128 but not backported
+          # to any currently released version.
+          - case-name: Python 3.11
+            os: ubuntu-latest
+            python-version: "3.11"
+            condaforge: 1
+            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
+            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
+
+          # Windows. Once all tests pass without special options needed, this
+          # can be moved to the main os list in the test matrix. All the tests
+          # that fail currently seem to do so because mcsolve uses
+          # multiprocessing under the hood. Windows does not support fork()
+          # well, which makes transfering objects to the child processes
+          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
+          - case-name: Windows Latest
+            os: windows-latest
+            python-version: "3.10"
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: conda-incubator/setup-miniconda@v2
+        with:
+          auto-update-conda: true
+          python-version: ${{ matrix.python-version }}
+          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
+
+      - name: Install QuTiP and dependencies
+        # In the run, first we handle any special cases.  We do this in bash
+        # rather than in the GitHub Actions file directly, because bash gives us
+        # a proper programming language to use.
+        run: |
+          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
+          if [[ -z "${{ matrix.nocython }}" ]]; then
+            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
+          fi
+          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
+          if [[ -z "${{ matrix.nomkl }}" ]]; then
+            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
+            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
+            # pip not automatically linking to MKL.
+            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+          else
+            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
+          fi
+          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
+            conda install "${{ matrix.conda-extra-pkgs }}"
+          fi
+          python -m pip install -e .[$QUTIP_TARGET]
+          python -m pip install "coverage${{ matrix.coverage-requirement }}"
+          python -m pip install pytest-cov coveralls pytest-fail-slow
+
+      - name: Package information
+        run: |
+          conda list
+          python -c "import qutip; qutip.about()"
+          python -c "import qutip; print(qutip.settings)"
+
+      - name: Environment information
+        run: |
+          uname -a
+          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
+              hostnamectl
+              lscpu
+              free -h
+          fi
+
+      - name: Run tests
+        # If our tests are running for longer than an hour, _something_ is wrong
+        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
+        # to see if something hung.
+        timeout-minutes: 60
+        run: |
+          if [[ -n "${{ matrix.openmp }}" ]]; then
+            # Force OpenMP runs to use more threads, even if there aren't
+            # actually that many CPUs.  We have to check any dispatch code is
+            # truly being executed.
+            export QUTIP_NUM_PROCESSES=2
+          fi
+          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
+          # Above flags are:
+          #  -Werror
+          #     treat warnings as errors
+          #  --strict-config
+          #     error out if the configuration file is not parseable
+          #  --strict-markers
+          #     error out if a marker is used but not defined in the
+          #     configuration file
+          #  --timeout=300
+          #     error any individual test that goes longer than the given time
+          #  --durations=0 --durations-min=1.0
+          #     at the end, show a list of all the tests that took longer than a
+          #     second to run
+          #  --verbosity=1
+          #     turn the verbosity up so pytest prints the names of the tests
+          #     it's currently working on
+          #  --cov=qutip
+          #     limit coverage reporting to code that's within the qutip package
+          #  --cov-report=
+          #     don't print the coverage report to the terminal---it just adds
+          #     cruft, and we're going to upload the .coverage file to Coveralls
+          #  --color=yes
+          #     force coloured output in the terminal
+
+      - name: Upload to Coveralls
+        env:
+          GITHUB_TOKEN: ${{ secrets.github_token }}
+          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
+          COVERALLS_PARALLEL: true
+        run: coveralls --service=github
+
+  towncrier-check:
+    name: Verify Towncrier entry added
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install Towncrier
+        run: |
+          python -m pip install towncrier
+
+      - name: Verify Towncrier entry added
+        if: github.event_name == 'pull_request'
+        env:
+          BASE_BRANCH: ${{ github.base_ref }}
+        run: |
+          # Fetch the pull request' base branch so towncrier will be able to
+          # compare the current branch with the base branch.
+          # Source: https://github.com/actions/checkout/#fetch-all-branches.
+          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
+          towncrier check --compare-with origin/${BASE_BRANCH}
+          towncrier build --version "$(cat VERSION)" --draft
+
+  finalise:
+    name: Finalise coverage reporting
+    needs: cases
+    runs-on: ubuntu-latest
+    container: python:3-slim
+    steps:
+      - name: Finalise coverage reporting
+        env:
+          GITHUB_TOKEN: ${{ secrets.github_token }}
+        run: |
+          python -m pip install coveralls
+          coveralls --service=github --finish
diff --git a/.gitignore b/.gitignore
index a83f90df9d..e9cd9d2670 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,45 +1,45 @@
-*~
-*.py[cod]
-*.so
-.DS_Store
-.f2py_f2cmap
-.idea/
-.vscode/
-
-# Packages
-*.egg
-.eggs
-*.egg-info
-dist
-build
-eggs
-parts
-bin
-var
-sdist
-develop-eggs
-.installed.cfg
-lib
-lib64
-
-
-qutip/version.py
-qutip/__config__.py
-rhs*.pyx
-
-qutip/cy/*.c
-*.cpp
-*.dat
-qutip/core/*.h
-
-
-qutip/**/*.html
-qutip/solver/ode/*.c
-
-
-*.qo
-
-benchmark/benchmark_data.js
-*-tasks.txt
-*compiled_coeff*
-result_images/
+*~
+*.py[cod]
+*.so
+.DS_Store
+.f2py_f2cmap
+.idea/
+.vscode/
+
+# Packages
+*.egg
+.eggs
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+
+
+qutip/version.py
+qutip/__config__.py
+rhs*.pyx
+
+qutip/cy/*.c
+*.cpp
+*.dat
+qutip/core/*.h
+
+
+qutip/**/*.html
+qutip/solver/ode/*.c
+
+
+*.qo
+
+benchmark/benchmark_data.js
+*-tasks.txt
+*compiled_coeff*
+result_images/
diff --git a/.mailmap b/.mailmap
index 3cb7a2a1b4..346044be7b 100644
--- a/.mailmap
+++ b/.mailmap
@@ -1,27 +1,27 @@
-Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
-Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
-Ben Criger <bcriger@gmail.com>
-Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
-Kevin Fischer <fischer.kevin.a@gmail.com>
-Eric Giguère <eric.giguere@calculquebec.ca>
-Canoming <canoming@163.com>
-Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
-Christopher Granade <cgranade@cgranade.com>
-Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
-Arne Grimsmo <arne.grimsmo@gmail.com>
-Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
-Neill Lambert <nwlambert@gmail.com>
-Boxi Li <etamin1201@gmail.com>
-Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
-Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
-Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
-Alexander Pitchford <alex.pitchford@gmail.com>
-Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
-Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
-Tarun Raheja <trolldemort9@gmail.com>
-Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
-Sidhant Saraogi <ssaraogi@uwaterloo.ca>
-Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
-Anubhav Vardhan <anubhavvardhan@gmail.com>
-Lucas Verney <phyks@phyks.me>
-Florestan Ziem <flo.zie@gmx.de>
+Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
+Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
+Ben Criger <bcriger@gmail.com>
+Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
+Kevin Fischer <fischer.kevin.a@gmail.com>
+Eric Giguère <eric.giguere@calculquebec.ca>
+Canoming <canoming@163.com>
+Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
+Christopher Granade <cgranade@cgranade.com>
+Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
+Arne Grimsmo <arne.grimsmo@gmail.com>
+Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
+Neill Lambert <nwlambert@gmail.com>
+Boxi Li <etamin1201@gmail.com>
+Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
+Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
+Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
+Alexander Pitchford <alex.pitchford@gmail.com>
+Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
+Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
+Tarun Raheja <trolldemort9@gmail.com>
+Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
+Sidhant Saraogi <ssaraogi@uwaterloo.ca>
+Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
+Anubhav Vardhan <anubhavvardhan@gmail.com>
+Lucas Verney <phyks@phyks.me>
+Florestan Ziem <flo.zie@gmx.de>
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 4336b4794b..c5e1295754 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -1,20 +1,20 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-version: 2
-
-formats:
-  - pdf
-
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "mambaforge-4.10"
-
-conda:
-  environment: doc/rtd-environment.yml
-
-sphinx:
-  configuration: doc/conf.py
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+formats:
+  - pdf
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "mambaforge-4.10"
+
+conda:
+  environment: doc/rtd-environment.yml
+
+sphinx:
+  configuration: doc/conf.py
   fail_on_warning: true
\ No newline at end of file
diff --git a/CITATION.bib b/CITATION.bib
index 2ea12d327e..143e992d27 100644
--- a/CITATION.bib
+++ b/CITATION.bib
@@ -1,26 +1,26 @@
-@article{qutip2,
-doi = {10.1016/j.cpc.2012.11.019},
-url = {https://doi.org/10.1016/j.cpc.2012.11.019},
-year  = {2013},
-month = {apr},
-publisher = {Elsevier {BV}},
-volume = {184},
-number = {4},
-pages = {1234--1240},
-author = {J.R. Johansson and P.D. Nation and F. Nori},
-title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
-journal = {Computer Physics Communications}
-}
-@article{qutip1,
-doi = {10.1016/j.cpc.2012.02.021},
-url = {https://doi.org/10.1016/j.cpc.2012.02.021},
-year  = {2012},
-month = {aug},
-publisher = {Elsevier {BV}},
-volume = {183},
-number = {8},
-pages = {1760--1772},
-author = {J.R. Johansson and P.D. Nation and F. Nori},
-title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
-journal = {Computer Physics Communications}
+@article{qutip2,
+doi = {10.1016/j.cpc.2012.11.019},
+url = {https://doi.org/10.1016/j.cpc.2012.11.019},
+year  = {2013},
+month = {apr},
+publisher = {Elsevier {BV}},
+volume = {184},
+number = {4},
+pages = {1234--1240},
+author = {J.R. Johansson and P.D. Nation and F. Nori},
+title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
+journal = {Computer Physics Communications}
+}
+@article{qutip1,
+doi = {10.1016/j.cpc.2012.02.021},
+url = {https://doi.org/10.1016/j.cpc.2012.02.021},
+year  = {2012},
+month = {aug},
+publisher = {Elsevier {BV}},
+volume = {183},
+number = {8},
+pages = {1760--1772},
+author = {J.R. Johansson and P.D. Nation and F. Nori},
+title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
+journal = {Computer Physics Communications}
 }
\ No newline at end of file
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 23c17f3e77..ddf531d0cd 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,25 +1,25 @@
-# Contributor Covenant Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic addresses, without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
-
-This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
-
-This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
-
-[homepage]: https://contributor-covenant.org
-[version]: https://contributor-covenant.org/version/1/2/
+# Contributor Covenant Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
+
+This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/2/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 83f103e9ca..104456854c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,7 +1,7 @@
-# Contributing to QuTiP Development
-
-You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
-You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
-
-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+# Contributing to QuTiP Development
+
+You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
+You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
+All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+
+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
diff --git a/LICENSE.txt b/LICENSE.txt
index 34e8c029f3..bb2d6131bb 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,27 +1,27 @@
-Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-   may be used to endorse or promote products derived from this software without
-   specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/MANIFEST.in b/MANIFEST.in
index 0b5f0e2129..dd7423f79c 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,12 +1,12 @@
-include README.md
-include LICENSE.txt
-include VERSION
-include requirements.txt
-include CITATION.bib
-include pyproject.toml
-recursive-include qutip *.pyx
-recursive-include qutip *.pxd
-recursive-include qutip *.hpp
-recursive-include qutip *.cpp
-recursive-include qutip *.ini
+include README.md
+include LICENSE.txt
+include VERSION
+include requirements.txt
+include CITATION.bib
+include pyproject.toml
+recursive-include qutip *.pyx
+recursive-include qutip *.pxd
+recursive-include qutip *.hpp
+recursive-include qutip *.cpp
+recursive-include qutip *.ini
 recursive-include qutip *.h
\ No newline at end of file
diff --git a/README.md b/README.md
index 03a223d474..376e25b3a8 100644
--- a/README.md
+++ b/README.md
@@ -1,114 +1,114 @@
-QuTiP: Quantum Toolbox in Python
-================================
-
-[A. Pitchford](https://github.com/ajgpitch),
-[C. Granade](https://github.com/cgranade),
-[A. Grimsmo](https://github.com/arnelg),
-[N. Shammah](https://github.com/nathanshammah),
-[S. Ahmed](https://github.com/quantshah),
-[N. Lambert](https://github.com/nwlambert),
-[E. Giguère](https://github.com/ericgig),
-[B. Li](https://github.com/boxili),
-[J. Lishman](https://github.com/jakelishman),
-[S. Cross](https://github.com/hodgestar),
-[A. Galicia](https://github.com/AGaliciaMartinez),
-[P. D. Nation](https://github.com/nonhermitian),
-and [J. R. Johansson](https://github.com/jrjohansson)
-
-[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
-[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
-[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
-[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
-[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
-
-> **Note**
->
-> The master branch now contains the alpha version of QuTiP 5. This is major
-> revision that breaks compatibility in many small ways withh QuTiP 4.7.
->
-> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
-> please use the `qutip-4.7.X` branch.
->
-> If you need to track QuTiP 5 changes or submit  pull request for 5,
-> please use the `master` branch (and not the `dev.major` branch).
->
-> The change to master happened on 16 January 2023 in commit @fccec5d.
-
-QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
-It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
-QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
-QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
-Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
-
-Support
--------
-
-[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
-[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
-
-We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
-QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
-
-
-Installation
-------------
-
-[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
-[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
-
-QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
-You can install QuTiP from `pip` by doing
-
-```bash
-pip install qutip
-```
-
-to get the minimal installation.
-You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
-For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
-
-All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
-For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
-
-
-The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
-
-```bash
-pip install --pre qutip
-```
-
-This version breaks compatibility with QuTiP 4.7 in many small ways.
-Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
-This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
-
-
-Documentation
--------------
-
-[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
-
-The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
-
-The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
-
-The latest development documentation is available in this repository in the `doc` folder.
-
-A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
-These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
-
-
-Contribute
-----------
-
-You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
-You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
-
-For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
-
-
-Citing QuTiP
-------------
-
-If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
+QuTiP: Quantum Toolbox in Python
+================================
+
+[A. Pitchford](https://github.com/ajgpitch),
+[C. Granade](https://github.com/cgranade),
+[A. Grimsmo](https://github.com/arnelg),
+[N. Shammah](https://github.com/nathanshammah),
+[S. Ahmed](https://github.com/quantshah),
+[N. Lambert](https://github.com/nwlambert),
+[E. Giguère](https://github.com/ericgig),
+[B. Li](https://github.com/boxili),
+[J. Lishman](https://github.com/jakelishman),
+[S. Cross](https://github.com/hodgestar),
+[A. Galicia](https://github.com/AGaliciaMartinez),
+[P. D. Nation](https://github.com/nonhermitian),
+and [J. R. Johansson](https://github.com/jrjohansson)
+
+[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
+[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
+[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
+[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
+[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
+
+> **Note**
+>
+> The master branch now contains the alpha version of QuTiP 5. This is major
+> revision that breaks compatibility in many small ways withh QuTiP 4.7.
+>
+> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
+> please use the `qutip-4.7.X` branch.
+>
+> If you need to track QuTiP 5 changes or submit  pull request for 5,
+> please use the `master` branch (and not the `dev.major` branch).
+>
+> The change to master happened on 16 January 2023 in commit @fccec5d.
+
+QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
+It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
+QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
+QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
+Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
+
+Support
+-------
+
+[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
+[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+
+We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
+QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
+
+
+Installation
+------------
+
+[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
+[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
+
+QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
+You can install QuTiP from `pip` by doing
+
+```bash
+pip install qutip
+```
+
+to get the minimal installation.
+You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
+For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
+
+All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
+For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
+
+
+The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
+
+```bash
+pip install --pre qutip
+```
+
+This version breaks compatibility with QuTiP 4.7 in many small ways.
+Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
+This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
+
+
+Documentation
+-------------
+
+[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
+
+The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
+
+The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
+
+The latest development documentation is available in this repository in the `doc` folder.
+
+A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
+These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
+
+
+Contribute
+----------
+
+You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
+You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
+All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
+
+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
+
+
+Citing QuTiP
+------------
+
+If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
diff --git a/VERSION b/VERSION
index 706882a482..6f5f6c392d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-5.0.0.dev
+5.0.0.dev
diff --git a/doc/branch.diff b/doc/branch.diff
deleted file mode 100644
index bd053dfb84..0000000000
--- a/doc/branch.diff
+++ /dev/null
@@ -1,144221 +0,0 @@
-diff --git a/.codeclimate.yml b/.codeclimate.yml
-index 35d5f48a..68f82f86 100644
---- a/.codeclimate.yml
-+++ b/.codeclimate.yml
-@@ -1,46 +1,46 @@
--version: "2"
--exclude_patterns:
--- "doc/"
--- "dist/"
--- "**/tests/"
--checks:
--  argument-count:
--    config:
--      threshold: 10
--  complex-logic:
--    config:
--      threshold: 20
--  file-lines:
--    enabled: false
--  method-complexity:
--    config:
--      threshold: 20
--  method-count:
--    config:
--      threshold: 75
--  method-lines:
--    config:
--      threshold: 100
--  nested-control-flow:
--    config:
--      threshold: 4
--  return-statements:
--    config:
--      threshold: 4
--  similar-code:
--    config:
--      threshold: 64
--  identical-code:
--    config:
--      threshold: 64
--plugins:
--  fixme:
--    enabled: true
--  pep8:
--    enabled: true
--  duplication:
--    enabled: true
--    config:
--      languages:
--        python:
--          python_version: 3
-+version: "2"
-+exclude_patterns:
-+- "doc/"
-+- "dist/"
-+- "**/tests/"
-+checks:
-+  argument-count:
-+    config:
-+      threshold: 10
-+  complex-logic:
-+    config:
-+      threshold: 20
-+  file-lines:
-+    enabled: false
-+  method-complexity:
-+    config:
-+      threshold: 20
-+  method-count:
-+    config:
-+      threshold: 75
-+  method-lines:
-+    config:
-+      threshold: 100
-+  nested-control-flow:
-+    config:
-+      threshold: 4
-+  return-statements:
-+    config:
-+      threshold: 4
-+  similar-code:
-+    config:
-+      threshold: 64
-+  identical-code:
-+    config:
-+      threshold: 64
-+plugins:
-+  fixme:
-+    enabled: true
-+  pep8:
-+    enabled: true
-+  duplication:
-+    enabled: true
-+    config:
-+      languages:
-+        python:
-+          python_version: 3
-diff --git a/.coveragerc b/.coveragerc
-index 96024441..ca1eba23 100644
---- a/.coveragerc
-+++ b/.coveragerc
-@@ -1,10 +1,10 @@
--[run]
--source = qutip
--omit =
--    # QuTiP test files
--    */qutip/tests/*
--
--[report]
--exclude_lines =
--    # Skip Python wrappers which help load in C extension modules.
--    __bootstrap__()
-+[run]
-+source = qutip
-+omit =
-+    # QuTiP test files
-+    */qutip/tests/*
-+
-+[report]
-+exclude_lines =
-+    # Skip Python wrappers which help load in C extension modules.
-+    __bootstrap__()
-diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml
-index b942d02a..b297a12b 100644
---- a/.github/ISSUE_TEMPLATE/bug_report.yaml
-+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
-@@ -1,53 +1,53 @@
--name: 🐛 Bug Report
--description: Spotted a bug? Report it to us!
--labels: ["bug"]
--body:
--  - type: textarea
--    id: bug-description
--    attributes:
--      label: Bug Description
--      description: Tell us what went wrong (including what triggered the bug)
--      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
--    validations:
--      required: true
--  - type: textarea
--    id: code-to-reproduce
--    attributes:
--      label: Code to Reproduce the Bug
--      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
--      placeholder: "from qutip import identity\nprint(identity(2))"
--      render: shell
--  - type: textarea
--    id: bug-output
--    attributes:
--      label: Code Output
--      description: Please paste the relevant output here (automatically formatted)
--      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
--      render: shell
--  - type: textarea
--    id: expected-behaviour
--    attributes:
--      label: Expected Behaviour
--      description: What should have happened instead?
--      placeholder: "A clear and concise description of what you expected to happen"
--    validations:
--      required: true
--  - type: textarea
--    id: your-environment
--    attributes:
--      label: Your Environment
--      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
--      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
--      render: shell
--    validations:
--      required: true
--  - type: textarea
--    id: additional-context
--    attributes:
--      label: Additional Context
--      description: Add anything else you want to tell us. You can include images, plots, etc.
--      placeholder: "Additional information, images, graphs, plots, etc."
--  - type: markdown
--    id: thank-you
--    attributes:
-+name: 🐛 Bug Report
-+description: Spotted a bug? Report it to us!
-+labels: ["bug"]
-+body:
-+  - type: textarea
-+    id: bug-description
-+    attributes:
-+      label: Bug Description
-+      description: Tell us what went wrong (including what triggered the bug)
-+      placeholder: "A clear and concise description of what the bug is, and the steps to reproduce it"
-+    validations:
-+      required: true
-+  - type: textarea
-+    id: code-to-reproduce
-+    attributes:
-+      label: Code to Reproduce the Bug
-+      description: Please provide a minimal working example. Paste your code directly (It will be automatically formatted, so there's no need for backticks)
-+      placeholder: "from qutip import identity\nprint(identity(2))"
-+      render: shell
-+  - type: textarea
-+    id: bug-output
-+    attributes:
-+      label: Code Output
-+      description: Please paste the relevant output here (automatically formatted)
-+      placeholder: "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\nQobj data =\n[[1. 0.]\n[0. 1.]]"
-+      render: shell
-+  - type: textarea
-+    id: expected-behaviour
-+    attributes:
-+      label: Expected Behaviour
-+      description: What should have happened instead?
-+      placeholder: "A clear and concise description of what you expected to happen"
-+    validations:
-+      required: true
-+  - type: textarea
-+    id: your-environment
-+    attributes:
-+      label: Your Environment
-+      description: Please use `qutip.about()` to get the information about your environment and paste it here (automatically formatted)
-+      placeholder: "QuTiP Version:      ***\nNumpy Version:      ***\nScipy Version:      ***\nCython Version:     ***\nMatplotlib Version: ***\nPython Version:     ***\nNumber of CPUs:     ***\nBLAS Info:          ***\nOPENMP Installed:   ***\nINTEL MKL Ext:      ***\nPlatform Info:      ***"
-+      render: shell
-+    validations:
-+      required: true
-+  - type: textarea
-+    id: additional-context
-+    attributes:
-+      label: Additional Context
-+      description: Add anything else you want to tell us. You can include images, plots, etc.
-+      placeholder: "Additional information, images, graphs, plots, etc."
-+  - type: markdown
-+    id: thank-you
-+    attributes:
-       value: Thanks for taking the time to fill out this bug report!
-\ No newline at end of file
-diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
-index d0a28054..a39ab3fc 100644
---- a/.github/ISSUE_TEMPLATE/feature_request.yaml
-+++ b/.github/ISSUE_TEMPLATE/feature_request.yaml
-@@ -1,36 +1,36 @@
--name: 🚀 Feature Request
--description: Suggest an idea for this project!
--labels: ["ENH"]
--body:
--  - type: textarea
--    id: problem-description
--    attributes:
--      label: Problem Description
--      description: Give us a clear and concise description of what the problem is!
--      placeholder: "Example - It would be better if [...]"
--    validations:
--      required: true
--  - type: textarea
--    id: proposed-solution
--    attributes:
--      label: Proposed Solution
--      description: Give us a description of your proposed solution
--      placeholder: "A clear and concise description of what you want to happen"
--    validations:
--      required: true
--  - type: textarea
--    id: alternate-solutions
--    attributes:
--      label: Alternate Solutions
--      description: Are there other ways of implementing this feature?
--      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
--  - type: textarea
--    id: additional-context
--    attributes:
--      label: Additional Context
--      description: You can tell us more about your idea, add code snippets or images, etc.
--      placeholder: "Give us more context or screenshots about the feature request here"
--  - type: markdown
--    id: thank-you
--    attributes:
-+name: 🚀 Feature Request
-+description: Suggest an idea for this project!
-+labels: ["ENH"]
-+body:
-+  - type: textarea
-+    id: problem-description
-+    attributes:
-+      label: Problem Description
-+      description: Give us a clear and concise description of what the problem is!
-+      placeholder: "Example - It would be better if [...]"
-+    validations:
-+      required: true
-+  - type: textarea
-+    id: proposed-solution
-+    attributes:
-+      label: Proposed Solution
-+      description: Give us a description of your proposed solution
-+      placeholder: "A clear and concise description of what you want to happen"
-+    validations:
-+      required: true
-+  - type: textarea
-+    id: alternate-solutions
-+    attributes:
-+      label: Alternate Solutions
-+      description: Are there other ways of implementing this feature?
-+      placeholder: "A clear and concise description of any alternative solutions or features you've considered"
-+  - type: textarea
-+    id: additional-context
-+    attributes:
-+      label: Additional Context
-+      description: You can tell us more about your idea, add code snippets or images, etc.
-+      placeholder: "Give us more context or screenshots about the feature request here"
-+  - type: markdown
-+    id: thank-you
-+    attributes:
-       value: Thanks for taking the time to fill out this feature request!
-\ No newline at end of file
-diff --git a/.github/ISSUE_TEMPLATE/others.yaml b/.github/ISSUE_TEMPLATE/others.yaml
-index 7750f518..77ac0ab4 100644
---- a/.github/ISSUE_TEMPLATE/others.yaml
-+++ b/.github/ISSUE_TEMPLATE/others.yaml
-@@ -1,15 +1,15 @@
--name: 🤔 Others
--description: Tell us about issues that aren't exactly bugs or features
--body:
--  - type: textarea
--    id: issue-description
--    attributes:
--      label: Describe the Issue!
--      description: Tell us about your issue. You can include screenshots, code snippets, etc.
--      placeholder: "Please describe the issue here"
--    validations:
--      required: true
--  - type: markdown
--    id: thank-you
--    attributes:
-+name: 🤔 Others
-+description: Tell us about issues that aren't exactly bugs or features
-+body:
-+  - type: textarea
-+    id: issue-description
-+    attributes:
-+      label: Describe the Issue!
-+      description: Tell us about your issue. You can include screenshots, code snippets, etc.
-+      placeholder: "Please describe the issue here"
-+    validations:
-+      required: true
-+  - type: markdown
-+    id: thank-you
-+    attributes:
-       value: Thanks for taking the time to fill out this issue!
-\ No newline at end of file
-diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
-index d68410d7..99453d7a 100644
---- a/.github/pull_request_template.md
-+++ b/.github/pull_request_template.md
-@@ -1,17 +1,17 @@
--**Checklist**
--Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
--
--- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
--- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
--You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
--- [ ] Please add tests to cover your changes if applicable.
--- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
--- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
--
--Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
--
--**Description**
--Describe here the proposed change.
--
--**Related issues or PRs**
-+**Checklist**
-+Thank you for contributing to QuTiP! Please make sure you have finished the following tasks before opening the PR.
-+
-+- [ ] Please read [Contributing to QuTiP Development](http://qutip.org/docs/latest/development/contributing.html)
-+- [ ] Contributions to qutip should follow the [pep8 style](https://www.python.org/dev/peps/pep-0008/).
-+You can use [pycodestyle](http://pycodestyle.pycqa.org/en/latest/index.html) to check your code automatically
-+- [ ] Please add tests to cover your changes if applicable.
-+- [ ] If the behavior of the code has changed or new feature has been added, please also update the documentation in the `doc` folder, and the [notebook](https://github.com/qutip/qutip-tutorials). Feel free to ask if you are not sure.
-+- [ ] Include the changelog in a file named: `doc/changes/<PR number>.<type>` 'type' can be one of the following: feature, bugfix, doc, removal, misc, or deprecation (see [here](http://qutip.org/docs/latest/development/contributing.html#changelog-generation) for more information).
-+
-+Delete this checklist after you have completed all the tasks. If you have not finished them all, you can also open a [Draft Pull Request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) to let the others know this on-going work and keep this checklist in the PR description.
-+
-+**Description**
-+Describe here the proposed change.
-+
-+**Related issues or PRs**
- Please mention the related issues or PRs here. If the PR fixes an issue, use the keyword fix/fixes/fixed followed by the issue id, e.g. fix #1184
-\ No newline at end of file
-diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
-index 45b648fa..f0b85250 100644
---- a/.github/workflows/build.yml
-+++ b/.github/workflows/build.yml
-@@ -1,214 +1,214 @@
--name: Build wheels, optionally deploy to PyPI
--
--on:
--  workflow_dispatch:
--    inputs:
--      confirm_ref:
--        description: "Confirm chosen branch name to deploy to PyPI (optional):"
--        default: ""
--      override_version:
--        description: "Override version number (optional):"
--        default: ""
--
--
--jobs:
--  # The deploy_test job is part of the test of whether we should deploy to PyPI
--  # or test.PyPI. The job will succeed if either the confirmation reference is
--  # empty, 'test' or if the confirmation is the selected branch or tag name.
--  # It will fail if it is nonempty and does not match.  All later jobs depend
--  # on this job, so that they will be immediately cancelled if the confirmation
--  # is bad.  The dependency is currently necessary (2021-03) because GitHub
--  # Actions does not have a simpler method of cancelling an entire workflow---
--  # the normal use-case expects to try and run as much as possible despite one
--  # or two failures.
--  deploy_test:
--    name: Verify PyPI deployment confirmation
--    runs-on: ubuntu-latest
--    env:
--      GITHUB_REF: ${{ github.ref }}
--      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
--    steps:
--      - name: Compare confirmation to current reference
--        shell: bash
--        run: |
--          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
--          if [[ $CONFIRM_REF == "test" ]]; then
--            echo "Build and deploy to test.pypi.org."
--          elif [[ -z $CONFIRM_REF ]]; then
--            echo "Build only.  Nothing will be uploaded to PyPI."
--          else
--            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
--          fi
--
--
--  build_sdist:
--    name: Build sdist on Ubuntu
--    needs: deploy_test
--    runs-on: ubuntu-latest
--    env:
--      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
--
--    steps:
--      - uses: actions/checkout@v3
--
--      - uses: actions/setup-python@v4
--        name: Install Python
--        with:
--          # For the sdist we should be as conservative as possible with our
--          # Python version.  This should be the lowest supported version.  This
--          # means that no unsupported syntax can sneak through.
--          python-version: '3.8'
--
--      - name: Install pip build
--        run: |
--          python -m pip install 'build'
--
--      - name: Build sdist tarball
--        shell: bash
--        run: |
--          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
--          # The build package is the reference PEP 517 package builder.  All
--          # dependencies are specified by our setup code.
--          python -m build --sdist .
--
--      # Zip files are not part of PEP 517, so we need to make our own.
--      - name: Create zipfile from tarball
--        shell: bash
--        working-directory: dist
--        run: |
--          # First assert that there is exactly one tarball, and find its name.
--          shopt -s failglob
--          tarball_pattern="*.tar.gz"
--          tarballs=($tarball_pattern)
--          [[ ${#tarballs[@]} == 1 ]]
--          tarball="${tarballs[0]}"
--          # Get the stem and make the zipfile name.
--          stem="${tarball%.tar.gz}"
--          zipfile="${stem}.zip"
--          # Extract the tarball and rezip it.
--          tar -xzf "$tarball"
--          zip "$zipfile" -r "$stem"
--          rm -r "$stem"
--
--      - uses: actions/upload-artifact@v3
--        with:
--          name: sdist
--          path: |
--            dist/*.tar.gz
--            dist/*.zip
--          if-no-files-found: error
--
--
--  build_wheels:
--    name: Build wheels on ${{ matrix.os }}
--    needs: deploy_test
--    runs-on: ${{ matrix.os }}
--    strategy:
--      matrix:
--        os: [ubuntu-latest, windows-latest, macos-latest]
--    env:
--      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
--      CIBW_BUILD: "cp3{8,9,10,11}-*"
--      # Numpy and SciPy do not supply wheels for i686 or win32 for
--      # Python 3.10+, so we skip those:
--      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
--      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
--
--    steps:
--      - uses: actions/checkout@v3
--
--      - uses: actions/setup-python@v4
--        name: Install Python
--        with:
--          # This is about the build environment, not the released wheel version.
--          python-version: '3.8'
--
--      - name: Install cibuildwheel
--        run: |
--          # cibuildwheel does the heavy lifting for us. Originally tested on
--          # 2.11.3, but should be fine at least up to any minor new release.
--          python -m pip install 'cibuildwheel==2.11.*'
--
--      - name: Build wheels
--        shell: bash
--        run: |
--          # If the version override was specified, then write it the VERSION
--          # file with it.
--          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
--          python -m cibuildwheel --output-dir wheelhouse
--
--      - uses: actions/upload-artifact@v3
--        with:
--          name: wheels
--          path: ./wheelhouse/*.whl
--
--
--  deploy:
--    name: "Deploy to PyPI if desired"
--    # The confirmation is tested explicitly in `deploy_test`, so we know it is
--    # either a missing confirmation (so we shouldn't run this job), 'test' or a
--    # valid confirmation.  We don't need to retest the value of the
--    # confirmation, beyond checking that one existed.
--    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
--    needs: [deploy_test, build_sdist, build_wheels]
--    runs-on: ubuntu-latest
--    env:
--      TWINE_USERNAME: __token__
--      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
--      TWINE_NON_INTERACTIVE: 1
--      TWINE_REPOSITORY: pypi
--
--    steps:
--      - name: Download build artifacts to local runner
--        uses: actions/download-artifact@v3
--
--      - uses: actions/setup-python@v4
--        name: Install Python
--        with:
--          python-version: '3.8'
--
--      - name: Verify this is not a dev version
--        shell: bash
--        run: |
--          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
--          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
--
--      # We built the zipfile for convenience distributing to Windows users on
--      # our end, but PyPI only needs the tarball.
--      - name: Upload sdist and wheels to PyPI
--        run: |
--          python -m pip install "twine"
--          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
--
--
--  deploy_testpypi:
--    name: "Deploy to TestPyPI if desired"
--    if: ${{ github.event.inputs.confirm_ref == 'test' }}
--    needs: [deploy_test, build_sdist, build_wheels]
--    runs-on: ubuntu-latest
--    env:
--      TWINE_USERNAME: __token__
--      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
--      TWINE_NON_INTERACTIVE: 1
--
--    steps:
--      - name: Download build artifacts to local runner
--        uses: actions/download-artifact@v3
--
--      - uses: actions/setup-python@v4
--        name: Install Python
--        with:
--          python-version: '3.8'
--
--      - name: Verify this is not a dev version
--        shell: bash
--        run: |
--          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
--          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
--
--      # We built the zipfile for convenience distributing to Windows users on
--      # our end, but PyPI only needs the tarball.
--      - name: Upload sdist and wheels to TestPyPI
--        run: |
--          python -m pip install "twine"
--          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
-+name: Build wheels, optionally deploy to PyPI
-+
-+on:
-+  workflow_dispatch:
-+    inputs:
-+      confirm_ref:
-+        description: "Confirm chosen branch name to deploy to PyPI (optional):"
-+        default: ""
-+      override_version:
-+        description: "Override version number (optional):"
-+        default: ""
-+
-+
-+jobs:
-+  # The deploy_test job is part of the test of whether we should deploy to PyPI
-+  # or test.PyPI. The job will succeed if either the confirmation reference is
-+  # empty, 'test' or if the confirmation is the selected branch or tag name.
-+  # It will fail if it is nonempty and does not match.  All later jobs depend
-+  # on this job, so that they will be immediately cancelled if the confirmation
-+  # is bad.  The dependency is currently necessary (2021-03) because GitHub
-+  # Actions does not have a simpler method of cancelling an entire workflow---
-+  # the normal use-case expects to try and run as much as possible despite one
-+  # or two failures.
-+  deploy_test:
-+    name: Verify PyPI deployment confirmation
-+    runs-on: ubuntu-latest
-+    env:
-+      GITHUB_REF: ${{ github.ref }}
-+      CONFIRM_REF: ${{ github.event.inputs.confirm_ref }}
-+    steps:
-+      - name: Compare confirmation to current reference
-+        shell: bash
-+        run: |
-+          [[ -z $CONFIRM_REF || $GITHUB_REF =~ ^refs/(heads|tags)/$CONFIRM_REF$ || $CONFIRM_REF == "test" ]]
-+          if [[ $CONFIRM_REF == "test" ]]; then
-+            echo "Build and deploy to test.pypi.org."
-+          elif [[ -z $CONFIRM_REF ]]; then
-+            echo "Build only.  Nothing will be uploaded to PyPI."
-+          else
-+            echo "Full build and deploy.  Wheels and source will be uploaded to PyPI."
-+          fi
-+
-+
-+  build_sdist:
-+    name: Build sdist on Ubuntu
-+    needs: deploy_test
-+    runs-on: ubuntu-latest
-+    env:
-+      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
-+
-+    steps:
-+      - uses: actions/checkout@v3
-+
-+      - uses: actions/setup-python@v4
-+        name: Install Python
-+        with:
-+          # For the sdist we should be as conservative as possible with our
-+          # Python version.  This should be the lowest supported version.  This
-+          # means that no unsupported syntax can sneak through.
-+          python-version: '3.8'
-+
-+      - name: Install pip build
-+        run: |
-+          python -m pip install 'build'
-+
-+      - name: Build sdist tarball
-+        shell: bash
-+        run: |
-+          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
-+          # The build package is the reference PEP 517 package builder.  All
-+          # dependencies are specified by our setup code.
-+          python -m build --sdist .
-+
-+      # Zip files are not part of PEP 517, so we need to make our own.
-+      - name: Create zipfile from tarball
-+        shell: bash
-+        working-directory: dist
-+        run: |
-+          # First assert that there is exactly one tarball, and find its name.
-+          shopt -s failglob
-+          tarball_pattern="*.tar.gz"
-+          tarballs=($tarball_pattern)
-+          [[ ${#tarballs[@]} == 1 ]]
-+          tarball="${tarballs[0]}"
-+          # Get the stem and make the zipfile name.
-+          stem="${tarball%.tar.gz}"
-+          zipfile="${stem}.zip"
-+          # Extract the tarball and rezip it.
-+          tar -xzf "$tarball"
-+          zip "$zipfile" -r "$stem"
-+          rm -r "$stem"
-+
-+      - uses: actions/upload-artifact@v3
-+        with:
-+          name: sdist
-+          path: |
-+            dist/*.tar.gz
-+            dist/*.zip
-+          if-no-files-found: error
-+
-+
-+  build_wheels:
-+    name: Build wheels on ${{ matrix.os }}
-+    needs: deploy_test
-+    runs-on: ${{ matrix.os }}
-+    strategy:
-+      matrix:
-+        os: [ubuntu-latest, windows-latest, macos-latest]
-+    env:
-+      # Set up wheels matrix.  This is CPython 3.8--3.10 for all OS targets.
-+      CIBW_BUILD: "cp3{8,9,10,11}-*"
-+      # Numpy and SciPy do not supply wheels for i686 or win32 for
-+      # Python 3.10+, so we skip those:
-+      CIBW_SKIP: "*-musllinux* cp3{8,9,10,11}-manylinux_i686 cp3{8,9,10,11}-win32"
-+      OVERRIDE_VERSION: ${{ github.event.inputs.override_version }}
-+
-+    steps:
-+      - uses: actions/checkout@v3
-+
-+      - uses: actions/setup-python@v4
-+        name: Install Python
-+        with:
-+          # This is about the build environment, not the released wheel version.
-+          python-version: '3.8'
-+
-+      - name: Install cibuildwheel
-+        run: |
-+          # cibuildwheel does the heavy lifting for us. Originally tested on
-+          # 2.11.3, but should be fine at least up to any minor new release.
-+          python -m pip install 'cibuildwheel==2.11.*'
-+
-+      - name: Build wheels
-+        shell: bash
-+        run: |
-+          # If the version override was specified, then write it the VERSION
-+          # file with it.
-+          if [[ ! -z "$OVERRIDE_VERSION" ]]; then echo "$OVERRIDE_VERSION" > VERSION; fi
-+          python -m cibuildwheel --output-dir wheelhouse
-+
-+      - uses: actions/upload-artifact@v3
-+        with:
-+          name: wheels
-+          path: ./wheelhouse/*.whl
-+
-+
-+  deploy:
-+    name: "Deploy to PyPI if desired"
-+    # The confirmation is tested explicitly in `deploy_test`, so we know it is
-+    # either a missing confirmation (so we shouldn't run this job), 'test' or a
-+    # valid confirmation.  We don't need to retest the value of the
-+    # confirmation, beyond checking that one existed.
-+    if: ${{ github.event.inputs.confirm_ref != '' && github.event.inputs.confirm_ref != 'test' }}
-+    needs: [deploy_test, build_sdist, build_wheels]
-+    runs-on: ubuntu-latest
-+    env:
-+      TWINE_USERNAME: __token__
-+      TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-+      TWINE_NON_INTERACTIVE: 1
-+      TWINE_REPOSITORY: pypi
-+
-+    steps:
-+      - name: Download build artifacts to local runner
-+        uses: actions/download-artifact@v3
-+
-+      - uses: actions/setup-python@v4
-+        name: Install Python
-+        with:
-+          python-version: '3.8'
-+
-+      - name: Verify this is not a dev version
-+        shell: bash
-+        run: |
-+          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
-+          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
-+
-+      # We built the zipfile for convenience distributing to Windows users on
-+      # our end, but PyPI only needs the tarball.
-+      - name: Upload sdist and wheels to PyPI
-+        run: |
-+          python -m pip install "twine"
-+          python -m twine upload --verbose wheels/*.whl sdist/*.tar.gz
-+
-+
-+  deploy_testpypi:
-+    name: "Deploy to TestPyPI if desired"
-+    if: ${{ github.event.inputs.confirm_ref == 'test' }}
-+    needs: [deploy_test, build_sdist, build_wheels]
-+    runs-on: ubuntu-latest
-+    env:
-+      TWINE_USERNAME: __token__
-+      TWINE_PASSWORD: ${{ secrets.TESTPYPI_TOKEN }}
-+      TWINE_NON_INTERACTIVE: 1
-+
-+    steps:
-+      - name: Download build artifacts to local runner
-+        uses: actions/download-artifact@v3
-+
-+      - uses: actions/setup-python@v4
-+        name: Install Python
-+        with:
-+          python-version: '3.8'
-+
-+      - name: Verify this is not a dev version
-+        shell: bash
-+        run: |
-+          python -m pip install wheels/*-cp38-cp38-manylinux*.whl
-+          python -c 'import qutip; print(qutip.__version__); assert "dev" not in qutip.__version__; assert "+" not in qutip.__version__'
-+
-+      # We built the zipfile for convenience distributing to Windows users on
-+      # our end, but PyPI only needs the tarball.
-+      - name: Upload sdist and wheels to TestPyPI
-+        run: |
-+          python -m pip install "twine"
-+          python -m twine upload --repository testpypi --verbose wheels/*.whl sdist/*.tar.gz
-diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml
-index b5c6eb9c..33d94a88 100644
---- a/.github/workflows/build_documentation.yml
-+++ b/.github/workflows/build_documentation.yml
-@@ -1,66 +1,66 @@
--name: Build documentation
--
--on:
--  [push, pull_request]
--
--jobs:
--  build:
--    name: Build documentation
--    runs-on: ubuntu-latest
--
--    steps:
--      - uses: actions/checkout@v3
--
--      - uses: actions/setup-python@v4
--        name: Install Python
--        with:
--          python-version: '3.8'
--
--      - name: Install documentation dependencies
--        run: |
--          pip install pip --upgrade
--          python -mpip install -r doc/requirements.txt
--          sudo apt-get update
--          sudo apt-get install texlive-full
--
--      - name: Install QuTiP from GitHub
--        run: |
--          # Build without build isolation so that we use the build
--          # dependencies already installed from doc/requirements.txt.
--          python -m pip install -e .[full] --no-build-isolation
--          # Install in editable mode so it doesn't matter if we import from
--          # inside the installation directory, otherwise we can get some errors
--          # because we're importing from the wrong location.
--          python -c 'import qutip; qutip.about()'
--
--      - name: Build PDF documentation
--        working-directory: doc
--        run: |
--          make latexpdf SPHINXOPTS="-W --keep-going -T"
--          # Above flags are:
--          #   -W : turn warnings into errors
--          #   --keep-going : do not stop after the first error
--          #   -T : display a full traceback if a Python exception occurs
--
--      - name: Upload built PDF files
--        uses: actions/upload-artifact@v3
--        with:
--          name: qutip_pdf_docs
--          path: doc/_build/latex/*
--          if-no-files-found: error
--
--      - name: Build HTML documentation
--        working-directory: doc
--        run: |
--          make html SPHINXOPTS="-W --keep-going -T"
--          # Above flags are:
--          #   -W : turn warnings into errors
--          #   --keep-going : do not stop after the first error
--          #   -T : display a full traceback if a Python exception occurs
--
--      - name: Upload built HTML files
--        uses: actions/upload-artifact@v3
--        with:
--          name: qutip_html_docs
--          path: doc/_build/html/*
--          if-no-files-found: error
-+name: Build documentation
-+
-+on:
-+  [push, pull_request]
-+
-+jobs:
-+  build:
-+    name: Build documentation
-+    runs-on: ubuntu-latest
-+
-+    steps:
-+      - uses: actions/checkout@v3
-+
-+      - uses: actions/setup-python@v4
-+        name: Install Python
-+        with:
-+          python-version: '3.8'
-+
-+      - name: Install documentation dependencies
-+        run: |
-+          pip install pip --upgrade
-+          python -mpip install -r doc/requirements.txt
-+          sudo apt-get update
-+          sudo apt-get install texlive-full
-+
-+      - name: Install QuTiP from GitHub
-+        run: |
-+          # Build without build isolation so that we use the build
-+          # dependencies already installed from doc/requirements.txt.
-+          python -m pip install -e .[full] --no-build-isolation
-+          # Install in editable mode so it doesn't matter if we import from
-+          # inside the installation directory, otherwise we can get some errors
-+          # because we're importing from the wrong location.
-+          python -c 'import qutip; qutip.about()'
-+
-+      - name: Build PDF documentation
-+        working-directory: doc
-+        run: |
-+          make latexpdf SPHINXOPTS="-W --keep-going -T"
-+          # Above flags are:
-+          #   -W : turn warnings into errors
-+          #   --keep-going : do not stop after the first error
-+          #   -T : display a full traceback if a Python exception occurs
-+
-+      - name: Upload built PDF files
-+        uses: actions/upload-artifact@v3
-+        with:
-+          name: qutip_pdf_docs
-+          path: doc/_build/latex/*
-+          if-no-files-found: error
-+
-+      - name: Build HTML documentation
-+        working-directory: doc
-+        run: |
-+          make html SPHINXOPTS="-W --keep-going -T"
-+          # Above flags are:
-+          #   -W : turn warnings into errors
-+          #   --keep-going : do not stop after the first error
-+          #   -T : display a full traceback if a Python exception occurs
-+
-+      - name: Upload built HTML files
-+        uses: actions/upload-artifact@v3
-+        with:
-+          name: qutip_html_docs
-+          path: doc/_build/html/*
-+          if-no-files-found: error
-diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
-index dd172510..de383e1f 100644
---- a/.github/workflows/tests.yml
-+++ b/.github/workflows/tests.yml
-@@ -1,229 +1,229 @@
--# The name is short because we mostly care how it appears in the pull request
--# "checks" dialogue box - it looks like
--#     Tests / ubuntu-latest, python-3.9, defaults
--# or similar.
--name: Tests
--
--on:
--    [push, pull_request]
--
--defaults:
--  run:
--    # The slightly odd shell call is to force bash to read .bashrc, which is
--    # necessary for having conda behave sensibly.  We use bash as the shell even
--    # on Windows, since we don't run anything much complicated, and it makes
--    # things much simpler.
--    shell: bash -l -e {0}
--
--jobs:
--  cases:
--    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
--    runs-on: ${{ matrix.os }}
--    env:
--      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
--    strategy:
--      fail-fast: false
--      matrix:
--        os: [ubuntu-latest]
--        # Test other versions of Python in special cases to avoid exploding the
--        # matrix size; make sure to test all supported versions in some form.
--        python-version: ["3.9"]
--        case-name: [defaults]
--        numpy-requirement: [">=1.20,<1.21"]
--        coverage-requirement: ["==6.5"]
--        # Extra special cases.  In these, the new variable defined should always
--        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
--        # the lack of a variable is _always_ false-y, and the defaults lack all
--        # the special cases.
--        include:
--          # Mac
--          # Mac has issues with MKL since september 2022.
--          - case-name: macos
--            os: macos-latest
--            python-version: "3.10"
--            condaforge: 1
--            nomkl: 1
--
--          # Scipy 1.5
--          - case-name: old SciPy
--            os: ubuntu-latest
--            python-version: "3.8"
--            numpy-requirement: ">=1.20,<1.21"
--            scipy-requirement: ">=1.5,<1.6"
--            condaforge: 1
--
--          # No MKL runs.  MKL is now the default for conda installations, but
--          # not necessarily for pip.
--          - case-name: no MKL
--            os: ubuntu-latest
--            python-version: "3.9"
--            numpy-requirement: ">=1.20,<1.21"
--            nomkl: 1
--
--          # Builds without Cython at runtime.  This is a core feature;
--          # everything should be able to run this.
--          - case-name: no Cython
--            os: ubuntu-latest
--            python-version: "3.8"
--            nocython: 1
--
--          # Python 3.10 and numpy 1.22
--          # Use conda-forge to provide numpy 1.22
--          - case-name: Python 3.10
--            os: ubuntu-latest
--            python-version: "3.10"
--            condaforge: 1
--
--          # Python 3.11 and latest numpy
--          # Use conda-forge to provide Python 3.11 and latest numpy
--          # Ignore deprecation of the cgi module in Python 3.11 that is
--          # still imported by Cython.Tempita. This was addressed in
--          # https://github.com/cython/cython/pull/5128 but not backported
--          # to any currently released version.
--          - case-name: Python 3.11
--            os: ubuntu-latest
--            python-version: "3.11"
--            condaforge: 1
--            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
--            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
--
--          # Windows. Once all tests pass without special options needed, this
--          # can be moved to the main os list in the test matrix. All the tests
--          # that fail currently seem to do so because mcsolve uses
--          # multiprocessing under the hood. Windows does not support fork()
--          # well, which makes transfering objects to the child processes
--          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
--          - case-name: Windows Latest
--            os: windows-latest
--            python-version: "3.10"
--
--    steps:
--      - uses: actions/checkout@v3
--
--      - uses: conda-incubator/setup-miniconda@v2
--        with:
--          auto-update-conda: true
--          python-version: ${{ matrix.python-version }}
--          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
--
--      - name: Install QuTiP and dependencies
--        # In the run, first we handle any special cases.  We do this in bash
--        # rather than in the GitHub Actions file directly, because bash gives us
--        # a proper programming language to use.
--        run: |
--          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
--          if [[ -z "${{ matrix.nocython }}" ]]; then
--            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
--          fi
--          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
--          if [[ -z "${{ matrix.nomkl }}" ]]; then
--            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
--          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
--            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
--            # pip not automatically linking to MKL.
--            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
--          else
--            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
--          fi
--          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
--            conda install "${{ matrix.conda-extra-pkgs }}"
--          fi
--          python -m pip install -e .[$QUTIP_TARGET]
--          python -m pip install "coverage${{ matrix.coverage-requirement }}"
--          python -m pip install pytest-cov coveralls pytest-fail-slow
--
--      - name: Package information
--        run: |
--          conda list
--          python -c "import qutip; qutip.about()"
--          python -c "import qutip; print(qutip.settings)"
--
--      - name: Environment information
--        run: |
--          uname -a
--          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
--              hostnamectl
--              lscpu
--              free -h
--          fi
--
--      - name: Run tests
--        # If our tests are running for longer than an hour, _something_ is wrong
--        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
--        # to see if something hung.
--        timeout-minutes: 60
--        run: |
--          if [[ -n "${{ matrix.openmp }}" ]]; then
--            # Force OpenMP runs to use more threads, even if there aren't
--            # actually that many CPUs.  We have to check any dispatch code is
--            # truly being executed.
--            export QUTIP_NUM_PROCESSES=2
--          fi
--          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
--          # Above flags are:
--          #  -Werror
--          #     treat warnings as errors
--          #  --strict-config
--          #     error out if the configuration file is not parseable
--          #  --strict-markers
--          #     error out if a marker is used but not defined in the
--          #     configuration file
--          #  --timeout=300
--          #     error any individual test that goes longer than the given time
--          #  --durations=0 --durations-min=1.0
--          #     at the end, show a list of all the tests that took longer than a
--          #     second to run
--          #  --verbosity=1
--          #     turn the verbosity up so pytest prints the names of the tests
--          #     it's currently working on
--          #  --cov=qutip
--          #     limit coverage reporting to code that's within the qutip package
--          #  --cov-report=
--          #     don't print the coverage report to the terminal---it just adds
--          #     cruft, and we're going to upload the .coverage file to Coveralls
--          #  --color=yes
--          #     force coloured output in the terminal
--
--      - name: Upload to Coveralls
--        env:
--          GITHUB_TOKEN: ${{ secrets.github_token }}
--          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
--          COVERALLS_PARALLEL: true
--        run: coveralls --service=github
--
--  towncrier-check:
--    name: Verify Towncrier entry added
--    runs-on: ubuntu-latest
--    steps:
--      - uses: actions/checkout@v3
--        with:
--          fetch-depth: 0
--
--      - name: Install Towncrier
--        run: |
--          python -m pip install towncrier
--
--      - name: Verify Towncrier entry added
--        if: github.event_name == 'pull_request'
--        env:
--          BASE_BRANCH: ${{ github.base_ref }}
--        run: |
--          # Fetch the pull request' base branch so towncrier will be able to
--          # compare the current branch with the base branch.
--          # Source: https://github.com/actions/checkout/#fetch-all-branches.
--          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
--          towncrier check --compare-with origin/${BASE_BRANCH}
--          towncrier build --version "$(cat VERSION)" --draft
--
--  finalise:
--    name: Finalise coverage reporting
--    needs: cases
--    runs-on: ubuntu-latest
--    container: python:3-slim
--    steps:
--      - name: Finalise coverage reporting
--        env:
--          GITHUB_TOKEN: ${{ secrets.github_token }}
--        run: |
--          python -m pip install coveralls
--          coveralls --service=github --finish
-+# The name is short because we mostly care how it appears in the pull request
-+# "checks" dialogue box - it looks like
-+#     Tests / ubuntu-latest, python-3.9, defaults
-+# or similar.
-+name: Tests
-+
-+on:
-+    [push, pull_request]
-+
-+defaults:
-+  run:
-+    # The slightly odd shell call is to force bash to read .bashrc, which is
-+    # necessary for having conda behave sensibly.  We use bash as the shell even
-+    # on Windows, since we don't run anything much complicated, and it makes
-+    # things much simpler.
-+    shell: bash -l -e {0}
-+
-+jobs:
-+  cases:
-+    name: ${{ matrix.os }}, python${{ matrix.python-version }}, ${{ matrix.case-name }}
-+    runs-on: ${{ matrix.os }}
-+    env:
-+      MPLBACKEND: Agg  # Explicitly define matplotlib backend for Windows tests
-+    strategy:
-+      fail-fast: false
-+      matrix:
-+        os: [ubuntu-latest]
-+        # Test other versions of Python in special cases to avoid exploding the
-+        # matrix size; make sure to test all supported versions in some form.
-+        python-version: ["3.9"]
-+        case-name: [defaults]
-+        numpy-requirement: [">=1.20,<1.21"]
-+        coverage-requirement: ["==6.5"]
-+        # Extra special cases.  In these, the new variable defined should always
-+        # be a truth-y value (hence 'nomkl: 1' rather than 'mkl: 0'), because
-+        # the lack of a variable is _always_ false-y, and the defaults lack all
-+        # the special cases.
-+        include:
-+          # Mac
-+          # Mac has issues with MKL since september 2022.
-+          - case-name: macos
-+            os: macos-latest
-+            python-version: "3.10"
-+            condaforge: 1
-+            nomkl: 1
-+
-+          # Scipy 1.5
-+          - case-name: old SciPy
-+            os: ubuntu-latest
-+            python-version: "3.8"
-+            numpy-requirement: ">=1.20,<1.21"
-+            scipy-requirement: ">=1.5,<1.6"
-+            condaforge: 1
-+
-+          # No MKL runs.  MKL is now the default for conda installations, but
-+          # not necessarily for pip.
-+          - case-name: no MKL
-+            os: ubuntu-latest
-+            python-version: "3.9"
-+            numpy-requirement: ">=1.20,<1.21"
-+            nomkl: 1
-+
-+          # Builds without Cython at runtime.  This is a core feature;
-+          # everything should be able to run this.
-+          - case-name: no Cython
-+            os: ubuntu-latest
-+            python-version: "3.8"
-+            nocython: 1
-+
-+          # Python 3.10 and numpy 1.22
-+          # Use conda-forge to provide numpy 1.22
-+          - case-name: Python 3.10
-+            os: ubuntu-latest
-+            python-version: "3.10"
-+            condaforge: 1
-+
-+          # Python 3.11 and latest numpy
-+          # Use conda-forge to provide Python 3.11 and latest numpy
-+          # Ignore deprecation of the cgi module in Python 3.11 that is
-+          # still imported by Cython.Tempita. This was addressed in
-+          # https://github.com/cython/cython/pull/5128 but not backported
-+          # to any currently released version.
-+          - case-name: Python 3.11
-+            os: ubuntu-latest
-+            python-version: "3.11"
-+            condaforge: 1
-+            conda-extra-pkgs: "suitesparse"  # for compiling cvxopt
-+            pytest-extra-options: "-W ignore::DeprecationWarning:Cython.Tempita"
-+
-+          # Windows. Once all tests pass without special options needed, this
-+          # can be moved to the main os list in the test matrix. All the tests
-+          # that fail currently seem to do so because mcsolve uses
-+          # multiprocessing under the hood. Windows does not support fork()
-+          # well, which makes transfering objects to the child processes
-+          # error prone. See, e.g., https://github.com/qutip/qutip/issues/1202
-+          - case-name: Windows Latest
-+            os: windows-latest
-+            python-version: "3.10"
-+
-+    steps:
-+      - uses: actions/checkout@v3
-+
-+      - uses: conda-incubator/setup-miniconda@v2
-+        with:
-+          auto-update-conda: true
-+          python-version: ${{ matrix.python-version }}
-+          channels: ${{ matrix.condaforge == 1 && 'conda-forge' || 'defaults' }}
-+
-+      - name: Install QuTiP and dependencies
-+        # In the run, first we handle any special cases.  We do this in bash
-+        # rather than in the GitHub Actions file directly, because bash gives us
-+        # a proper programming language to use.
-+        run: |
-+          QUTIP_TARGET="tests,graphics,semidefinite,ipython"
-+          if [[ -z "${{ matrix.nocython }}" ]]; then
-+            QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
-+          fi
-+          export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
-+          if [[ -z "${{ matrix.nomkl }}" ]]; then
-+            conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-+          elif [[ "${{ matrix.os }}" =~ ^windows.*$ ]]; then
-+            # Conda doesn't supply forced nomkl builds on Windows, so we rely on
-+            # pip not automatically linking to MKL.
-+            pip install "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-+          else
-+            conda install nomkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"
-+          fi
-+          if [[ -n "${{ matrix.conda-extra-pkgs }}" ]]; then
-+            conda install "${{ matrix.conda-extra-pkgs }}"
-+          fi
-+          python -m pip install -e .[$QUTIP_TARGET]
-+          python -m pip install "coverage${{ matrix.coverage-requirement }}"
-+          python -m pip install pytest-cov coveralls pytest-fail-slow
-+
-+      - name: Package information
-+        run: |
-+          conda list
-+          python -c "import qutip; qutip.about()"
-+          python -c "import qutip; print(qutip.settings)"
-+
-+      - name: Environment information
-+        run: |
-+          uname -a
-+          if [[ "ubuntu-latest" == "${{ matrix.os }}" ]]; then
-+              hostnamectl
-+              lscpu
-+              free -h
-+          fi
-+
-+      - name: Run tests
-+        # If our tests are running for longer than an hour, _something_ is wrong
-+        # somewhere.  The GitHub default is 6 hours, which is a bit long to wait
-+        # to see if something hung.
-+        timeout-minutes: 60
-+        run: |
-+          if [[ -n "${{ matrix.openmp }}" ]]; then
-+            # Force OpenMP runs to use more threads, even if there aren't
-+            # actually that many CPUs.  We have to check any dispatch code is
-+            # truly being executed.
-+            export QUTIP_NUM_PROCESSES=2
-+          fi
-+          pytest -Werror --strict-config --strict-markers --fail-slow=300 --durations=0 --durations-min=1.0 --verbosity=1 --cov=qutip --cov-report= --color=yes ${{ matrix.pytest-extra-options }} qutip/tests
-+          # Above flags are:
-+          #  -Werror
-+          #     treat warnings as errors
-+          #  --strict-config
-+          #     error out if the configuration file is not parseable
-+          #  --strict-markers
-+          #     error out if a marker is used but not defined in the
-+          #     configuration file
-+          #  --timeout=300
-+          #     error any individual test that goes longer than the given time
-+          #  --durations=0 --durations-min=1.0
-+          #     at the end, show a list of all the tests that took longer than a
-+          #     second to run
-+          #  --verbosity=1
-+          #     turn the verbosity up so pytest prints the names of the tests
-+          #     it's currently working on
-+          #  --cov=qutip
-+          #     limit coverage reporting to code that's within the qutip package
-+          #  --cov-report=
-+          #     don't print the coverage report to the terminal---it just adds
-+          #     cruft, and we're going to upload the .coverage file to Coveralls
-+          #  --color=yes
-+          #     force coloured output in the terminal
-+
-+      - name: Upload to Coveralls
-+        env:
-+          GITHUB_TOKEN: ${{ secrets.github_token }}
-+          COVERALLS_FLAG_NAME: ${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.case-name }}
-+          COVERALLS_PARALLEL: true
-+        run: coveralls --service=github
-+
-+  towncrier-check:
-+    name: Verify Towncrier entry added
-+    runs-on: ubuntu-latest
-+    steps:
-+      - uses: actions/checkout@v3
-+        with:
-+          fetch-depth: 0
-+
-+      - name: Install Towncrier
-+        run: |
-+          python -m pip install towncrier
-+
-+      - name: Verify Towncrier entry added
-+        if: github.event_name == 'pull_request'
-+        env:
-+          BASE_BRANCH: ${{ github.base_ref }}
-+        run: |
-+          # Fetch the pull request' base branch so towncrier will be able to
-+          # compare the current branch with the base branch.
-+          # Source: https://github.com/actions/checkout/#fetch-all-branches.
-+          git fetch --no-tags origin +refs/heads/${BASE_BRANCH}:refs/remotes/origin/${BASE_BRANCH}
-+          towncrier check --compare-with origin/${BASE_BRANCH}
-+          towncrier build --version "$(cat VERSION)" --draft
-+
-+  finalise:
-+    name: Finalise coverage reporting
-+    needs: cases
-+    runs-on: ubuntu-latest
-+    container: python:3-slim
-+    steps:
-+      - name: Finalise coverage reporting
-+        env:
-+          GITHUB_TOKEN: ${{ secrets.github_token }}
-+        run: |
-+          python -m pip install coveralls
-+          coveralls --service=github --finish
-diff --git a/.gitignore b/.gitignore
-index e9cd9d26..a83f90df 100644
---- a/.gitignore
-+++ b/.gitignore
-@@ -1,45 +1,45 @@
--*~
--*.py[cod]
--*.so
--.DS_Store
--.f2py_f2cmap
--.idea/
--.vscode/
--
--# Packages
--*.egg
--.eggs
--*.egg-info
--dist
--build
--eggs
--parts
--bin
--var
--sdist
--develop-eggs
--.installed.cfg
--lib
--lib64
--
--
--qutip/version.py
--qutip/__config__.py
--rhs*.pyx
--
--qutip/cy/*.c
--*.cpp
--*.dat
--qutip/core/*.h
--
--
--qutip/**/*.html
--qutip/solver/ode/*.c
--
--
--*.qo
--
--benchmark/benchmark_data.js
--*-tasks.txt
--*compiled_coeff*
--result_images/
-+*~
-+*.py[cod]
-+*.so
-+.DS_Store
-+.f2py_f2cmap
-+.idea/
-+.vscode/
-+
-+# Packages
-+*.egg
-+.eggs
-+*.egg-info
-+dist
-+build
-+eggs
-+parts
-+bin
-+var
-+sdist
-+develop-eggs
-+.installed.cfg
-+lib
-+lib64
-+
-+
-+qutip/version.py
-+qutip/__config__.py
-+rhs*.pyx
-+
-+qutip/cy/*.c
-+*.cpp
-+*.dat
-+qutip/core/*.h
-+
-+
-+qutip/**/*.html
-+qutip/solver/ode/*.c
-+
-+
-+*.qo
-+
-+benchmark/benchmark_data.js
-+*-tasks.txt
-+*compiled_coeff*
-+result_images/
-diff --git a/.mailmap b/.mailmap
-index 346044be..3cb7a2a1 100644
---- a/.mailmap
-+++ b/.mailmap
-@@ -1,27 +1,27 @@
--Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
--Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
--Ben Criger <bcriger@gmail.com>
--Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
--Kevin Fischer <fischer.kevin.a@gmail.com>
--Eric Giguère <eric.giguere@calculquebec.ca>
--Canoming <canoming@163.com>
--Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
--Christopher Granade <cgranade@cgranade.com>
--Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
--Arne Grimsmo <arne.grimsmo@gmail.com>
--Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
--Neill Lambert <nwlambert@gmail.com>
--Boxi Li <etamin1201@gmail.com>
--Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
--Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
--Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
--Alexander Pitchford <alex.pitchford@gmail.com>
--Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
--Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
--Tarun Raheja <trolldemort9@gmail.com>
--Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
--Sidhant Saraogi <ssaraogi@uwaterloo.ca>
--Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
--Anubhav Vardhan <anubhavvardhan@gmail.com>
--Lucas Verney <phyks@phyks.me>
--Florestan Ziem <flo.zie@gmx.de>
-+Markus Baden <markus.baden@gmail.com> <Markus.Baden@gmail.com>
-+Ivan Carvalho <ivan.carvalho@alumni.ubc.ca> <ivan.ivancps.cn@gmail.com>
-+Ben Criger <bcriger@gmail.com>
-+Simon Cross <hodgestar@gmail.com> <hodgestar+github@gmail.com>
-+Kevin Fischer <fischer.kevin.a@gmail.com>
-+Eric Giguère <eric.giguere@calculquebec.ca>
-+Canoming <canoming@163.com>
-+Canoming <canoming@163.com> <36161480+Canoming@users.noreply.github.com>
-+Christopher Granade <cgranade@cgranade.com>
-+Christopher Granade <cgranade@cgranade.com> <cgranade@gmail.com>
-+Arne Grimsmo <arne.grimsmo@gmail.com>
-+Stefan Krastanov <krastanov.stefan@gmail.com> <stefan@debian.krastanov>
-+Neill Lambert <nwlambert@gmail.com>
-+Boxi Li <etamin1201@gmail.com>
-+Jake Lishman <jake@binhbar.com> <jakelishman@gmail.com>
-+Paul Nation <nonhermitian@gmail.com> <paul@Pauls-Air.local>
-+Paul Nation <nonhermitian@gmail.com> <paul@Pauls-MacBook-Pro.local>
-+Alexander Pitchford <alex.pitchford@gmail.com>
-+Alexander Pitchford <alex.pitchford@gmail.com> Alexander James Pitchford <agp1@aber.ac.uk>
-+Nicolas Quesada <zeitus@gmail.com> <nicolas@xanadu.ai>
-+Tarun Raheja <trolldemort9@gmail.com>
-+Tarun Raheja <trolldemort9@gmail.com> <31796197+tehruhn@users.noreply.github.com>
-+Sidhant Saraogi <ssaraogi@uwaterloo.ca>
-+Sidhant Saraogi <ssaraogi@uwaterloo.ca> sid <ssaraogi@edu.uwaterloo.ca>
-+Anubhav Vardhan <anubhavvardhan@gmail.com>
-+Lucas Verney <phyks@phyks.me>
-+Florestan Ziem <flo.zie@gmx.de>
-diff --git a/.readthedocs.yaml b/.readthedocs.yaml
-index c5e12957..4336b479 100644
---- a/.readthedocs.yaml
-+++ b/.readthedocs.yaml
-@@ -1,20 +1,20 @@
--# .readthedocs.yaml
--# Read the Docs configuration file
--# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
--
--version: 2
--
--formats:
--  - pdf
--
--build:
--  os: ubuntu-22.04
--  tools:
--    python: "mambaforge-4.10"
--
--conda:
--  environment: doc/rtd-environment.yml
--
--sphinx:
--  configuration: doc/conf.py
-+# .readthedocs.yaml
-+# Read the Docs configuration file
-+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-+
-+version: 2
-+
-+formats:
-+  - pdf
-+
-+build:
-+  os: ubuntu-22.04
-+  tools:
-+    python: "mambaforge-4.10"
-+
-+conda:
-+  environment: doc/rtd-environment.yml
-+
-+sphinx:
-+  configuration: doc/conf.py
-   fail_on_warning: true
-\ No newline at end of file
-diff --git a/CITATION.bib b/CITATION.bib
-index 143e992d..2ea12d32 100644
---- a/CITATION.bib
-+++ b/CITATION.bib
-@@ -1,26 +1,26 @@
--@article{qutip2,
--doi = {10.1016/j.cpc.2012.11.019},
--url = {https://doi.org/10.1016/j.cpc.2012.11.019},
--year  = {2013},
--month = {apr},
--publisher = {Elsevier {BV}},
--volume = {184},
--number = {4},
--pages = {1234--1240},
--author = {J.R. Johansson and P.D. Nation and F. Nori},
--title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
--journal = {Computer Physics Communications}
--}
--@article{qutip1,
--doi = {10.1016/j.cpc.2012.02.021},
--url = {https://doi.org/10.1016/j.cpc.2012.02.021},
--year  = {2012},
--month = {aug},
--publisher = {Elsevier {BV}},
--volume = {183},
--number = {8},
--pages = {1760--1772},
--author = {J.R. Johansson and P.D. Nation and F. Nori},
--title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
--journal = {Computer Physics Communications}
-+@article{qutip2,
-+doi = {10.1016/j.cpc.2012.11.019},
-+url = {https://doi.org/10.1016/j.cpc.2012.11.019},
-+year  = {2013},
-+month = {apr},
-+publisher = {Elsevier {BV}},
-+volume = {184},
-+number = {4},
-+pages = {1234--1240},
-+author = {J.R. Johansson and P.D. Nation and F. Nori},
-+title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},
-+journal = {Computer Physics Communications}
-+}
-+@article{qutip1,
-+doi = {10.1016/j.cpc.2012.02.021},
-+url = {https://doi.org/10.1016/j.cpc.2012.02.021},
-+year  = {2012},
-+month = {aug},
-+publisher = {Elsevier {BV}},
-+volume = {183},
-+number = {8},
-+pages = {1760--1772},
-+author = {J.R. Johansson and P.D. Nation and F. Nori},
-+title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},
-+journal = {Computer Physics Communications}
- }
-\ No newline at end of file
-diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
-index ddf531d0..23c17f3e 100644
---- a/CODE_OF_CONDUCT.md
-+++ b/CODE_OF_CONDUCT.md
-@@ -1,25 +1,25 @@
--# Contributor Covenant Code of Conduct
--
--As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
--
--We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
--
--Examples of unacceptable behavior by participants include:
--
--* The use of sexualized language or imagery
--* Personal attacks
--* Trolling or insulting/derogatory comments
--* Public or private harassment
--* Publishing other's private information, such as physical or electronic addresses, without explicit permission
--* Other unethical or unprofessional conduct
--
--Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
--
--This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
--
--Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
--
--This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
--
--[homepage]: https://contributor-covenant.org
--[version]: https://contributor-covenant.org/version/1/2/
-+# Contributor Covenant Code of Conduct
-+
-+As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
-+
-+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
-+
-+Examples of unacceptable behavior by participants include:
-+
-+* The use of sexualized language or imagery
-+* Personal attacks
-+* Trolling or insulting/derogatory comments
-+* Public or private harassment
-+* Publishing other's private information, such as physical or electronic addresses, without explicit permission
-+* Other unethical or unprofessional conduct
-+
-+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
-+
-+This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 
-+
-+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers. 
-+
-+This Code of Conduct is adapted from the Contributor Covenant , version 1.2.0, available at https://www.contributor-covenant.org/version/1/2/0/code-of-conduct.html 
-+
-+[homepage]: https://contributor-covenant.org
-+[version]: https://contributor-covenant.org/version/1/2/
-diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
-index 10445685..83f103e9 100644
---- a/CONTRIBUTING.md
-+++ b/CONTRIBUTING.md
-@@ -1,7 +1,7 @@
--# Contributing to QuTiP Development
--
--You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
--You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
--All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
--
--For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
-+# Contributing to QuTiP Development
-+
-+You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
-+You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-+All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
-+
-+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
-diff --git a/LICENSE.txt b/LICENSE.txt
-index bb2d6131..34e8c029 100644
---- a/LICENSE.txt
-+++ b/LICENSE.txt
-@@ -1,27 +1,27 @@
--Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
--All rights reserved.
--
--Redistribution and use in source and binary forms, with or without modification,
--are permitted provided that the following conditions are met:
--
--1. Redistributions of source code must retain the above copyright notice, this
--   list of conditions and the following disclaimer.
--
--2. Redistributions in binary form must reproduce the above copyright notice,
--   this list of conditions and the following disclaimer in the documentation
--   and/or other materials provided with the distribution.
--
--3. Neither the name of the copyright holder nor the names of its contributors
--   may be used to endorse or promote products derived from this software without
--   specific prior written permission.
--
--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
--ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
--WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
--DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
--ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
--(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
--LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
--ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
--(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+Copyright (c) 2011 to 2022 inclusive, QuTiP developers and contributors.
-+All rights reserved.
-+
-+Redistribution and use in source and binary forms, with or without modification,
-+are permitted provided that the following conditions are met:
-+
-+1. Redistributions of source code must retain the above copyright notice, this
-+   list of conditions and the following disclaimer.
-+
-+2. Redistributions in binary form must reproduce the above copyright notice,
-+   this list of conditions and the following disclaimer in the documentation
-+   and/or other materials provided with the distribution.
-+
-+3. Neither the name of the copyright holder nor the names of its contributors
-+   may be used to endorse or promote products derived from this software without
-+   specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-diff --git a/MANIFEST.in b/MANIFEST.in
-index dd7423f7..0b5f0e21 100644
---- a/MANIFEST.in
-+++ b/MANIFEST.in
-@@ -1,12 +1,12 @@
--include README.md
--include LICENSE.txt
--include VERSION
--include requirements.txt
--include CITATION.bib
--include pyproject.toml
--recursive-include qutip *.pyx
--recursive-include qutip *.pxd
--recursive-include qutip *.hpp
--recursive-include qutip *.cpp
--recursive-include qutip *.ini
-+include README.md
-+include LICENSE.txt
-+include VERSION
-+include requirements.txt
-+include CITATION.bib
-+include pyproject.toml
-+recursive-include qutip *.pyx
-+recursive-include qutip *.pxd
-+recursive-include qutip *.hpp
-+recursive-include qutip *.cpp
-+recursive-include qutip *.ini
- recursive-include qutip *.h
-\ No newline at end of file
-diff --git a/README.md b/README.md
-index 376e25b3..03a223d4 100644
---- a/README.md
-+++ b/README.md
-@@ -1,114 +1,114 @@
--QuTiP: Quantum Toolbox in Python
--================================
--
--[A. Pitchford](https://github.com/ajgpitch),
--[C. Granade](https://github.com/cgranade),
--[A. Grimsmo](https://github.com/arnelg),
--[N. Shammah](https://github.com/nathanshammah),
--[S. Ahmed](https://github.com/quantshah),
--[N. Lambert](https://github.com/nwlambert),
--[E. Giguère](https://github.com/ericgig),
--[B. Li](https://github.com/boxili),
--[J. Lishman](https://github.com/jakelishman),
--[S. Cross](https://github.com/hodgestar),
--[A. Galicia](https://github.com/AGaliciaMartinez),
--[P. D. Nation](https://github.com/nonhermitian),
--and [J. R. Johansson](https://github.com/jrjohansson)
--
--[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
--[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
--[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
--[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
--[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
--[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
--
--> **Note**
-->
--> The master branch now contains the alpha version of QuTiP 5. This is major
--> revision that breaks compatibility in many small ways withh QuTiP 4.7.
-->
--> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
--> please use the `qutip-4.7.X` branch.
-->
--> If you need to track QuTiP 5 changes or submit  pull request for 5,
--> please use the `master` branch (and not the `dev.major` branch).
-->
--> The change to master happened on 16 January 2023 in commit @fccec5d.
--
--QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
--It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
--QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
--QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
--Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
--
--Support
---------
--
--[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
--[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
--
--We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
--QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
--
--
--Installation
--------------
--
--[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
--[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
--
--QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
--You can install QuTiP from `pip` by doing
--
--```bash
--pip install qutip
--```
--
--to get the minimal installation.
--You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
--For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
--
--All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
--For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
--
--
--The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
--
--```bash
--pip install --pre qutip
--```
--
--This version breaks compatibility with QuTiP 4.7 in many small ways.
--Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
--This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
--
--
--Documentation
---------------
--
--[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
--
--The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
--
--The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
--
--The latest development documentation is available in this repository in the `doc` folder.
--
--A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
--These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
--
--
--Contribute
------------
--
--You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
--You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
--All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
--
--For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
--
--
--Citing QuTiP
--------------
--
--If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
-+QuTiP: Quantum Toolbox in Python
-+================================
-+
-+[A. Pitchford](https://github.com/ajgpitch),
-+[C. Granade](https://github.com/cgranade),
-+[A. Grimsmo](https://github.com/arnelg),
-+[N. Shammah](https://github.com/nathanshammah),
-+[S. Ahmed](https://github.com/quantshah),
-+[N. Lambert](https://github.com/nwlambert),
-+[E. Giguère](https://github.com/ericgig),
-+[B. Li](https://github.com/boxili),
-+[J. Lishman](https://github.com/jakelishman),
-+[S. Cross](https://github.com/hodgestar),
-+[A. Galicia](https://github.com/AGaliciaMartinez),
-+[P. D. Nation](https://github.com/nonhermitian),
-+and [J. R. Johansson](https://github.com/jrjohansson)
-+
-+[![Build Status](https://github.com/qutip/qutip/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/qutip/qutip/actions/workflows/tests.yml)
-+[![Coverage Status](https://img.shields.io/coveralls/qutip/qutip.svg?logo=Coveralls)](https://coveralls.io/r/qutip/qutip)
-+[![Maintainability](https://api.codeclimate.com/v1/badges/df502674f1dfa1f1b67a/maintainability)](https://codeclimate.com/github/qutip/qutip/maintainability)
-+[![license](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-+[![PyPi Downloads](https://img.shields.io/pypi/dm/qutip?label=downloads%20%7C%20pip&logo=PyPI)](https://pypi.org/project/qutip)
-+[![Conda-Forge Downloads](https://img.shields.io/conda/dn/conda-forge/qutip?label=downloads%20%7C%20conda&logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
-+
-+> **Note**
-+>
-+> The master branch now contains the alpha version of QuTiP 5. This is major
-+> revision that breaks compatibility in many small ways withh QuTiP 4.7.
-+>
-+> If you need to track QuTiP 4.7 changes or submit pull requests for 4.7,
-+> please use the `qutip-4.7.X` branch.
-+>
-+> If you need to track QuTiP 5 changes or submit  pull request for 5,
-+> please use the `master` branch (and not the `dev.major` branch).
-+>
-+> The change to master happened on 16 January 2023 in commit @fccec5d.
-+
-+QuTiP is open-source software for simulating the dynamics of closed and open quantum systems.
-+It uses the excellent Numpy, Scipy, and Cython packages as numerical backends, and graphical output is provided by Matplotlib.
-+QuTiP aims to provide user-friendly and efficient numerical simulations of a wide variety of quantum mechanical problems, including those with Hamiltonians and/or collapse operators with arbitrary time-dependence, commonly found in a wide range of physics applications.
-+QuTiP is freely available for use and/or modification, and it can be used on all Unix-based platforms and on Windows.
-+Being free of any licensing fees, QuTiP is ideal for exploring quantum mechanics in research as well as in the classroom.
-+
-+Support
-+-------
-+
-+[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=flat)](https://unitary.fund)
-+[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
-+
-+We are proud to be affiliated with [Unitary Fund](https://unitary.fund) and [numFOCUS](https://numfocus.org).
-+QuTiP development is supported by [Nori's lab](https://dml.riken.jp/) at RIKEN, by the University of Sherbrooke, and by Aberystwyth University, [among other supporting organizations](https://qutip.org/#supporting-organizations).
-+
-+
-+Installation
-+------------
-+
-+[![Pip Package](https://img.shields.io/pypi/v/qutip?logo=PyPI)](https://pypi.org/project/qutip)
-+[![Conda-Forge Package](https://img.shields.io/conda/vn/conda-forge/qutip?logo=Conda-Forge)](https://anaconda.org/conda-forge/qutip)
-+
-+QuTiP is available on both `pip` and `conda` (the latter in the `conda-forge` channel).
-+You can install QuTiP from `pip` by doing
-+
-+```bash
-+pip install qutip
-+```
-+
-+to get the minimal installation.
-+You can instead use the target `qutip[full]` to install QuTiP with all its optional dependencies.
-+For more details, including instructions on how to build from source, see [the detailed installation guide in the documentation](https://qutip.org/docs/latest/installation.html).
-+
-+All back releases are also available for download in the [releases section of this repository](https://github.com/qutip/qutip/releases), where you can also find per-version changelogs.
-+For the most complete set of release notes and changelogs for historic versions, see the [changelog](https://qutip.org/docs/latest/changelog.html) section in the documentation.
-+
-+
-+The pre-release of QuTiP 5.0 is available on PyPI and can be installed using pip:
-+
-+```bash
-+pip install --pre qutip
-+```
-+
-+This version breaks compatibility with QuTiP 4.7 in many small ways.
-+Please see the [changelog](https://github.com/qutip/qutip/blob/master/doc/changelog.rst) for a list of changes, new features and deprecations.
-+This version should be fully working. If you find any bugs, confusing documentation or missing features, please create a GitHub issue.
-+
-+
-+Documentation
-+-------------
-+
-+[![Documentation Status - Latest](https://readthedocs.org/projects/qutip/badge/?version=latest)](https://qutip.readthedocs.io/en/latest/?badge=latest)
-+
-+The documentation for the latest [stable release](https://qutip.readthedocs.io/en/latest/) and the [master](https://qutip.readthedocs.io/en/master/) branch is available for reading on Read The Docs.
-+
-+The documentation for official releases, in HTML and PDF formats, can be found in the [documentation section of the QuTiP website](https://qutip.org/documentation.html).
-+
-+The latest development documentation is available in this repository in the `doc` folder.
-+
-+A [selection of demonstration notebooks is available](https://qutip.org/tutorials.html), which demonstrate some of the many features of QuTiP.
-+These are stored in the [qutip/qutip-tutorials repository](https://github.com/qutip/qutip-tutorials) here on GitHub.
-+
-+
-+Contribute
-+----------
-+
-+You are most welcome to contribute to QuTiP development by forking this repository and sending pull requests, or filing bug reports at the [issues page](https://github.com/qutip/qutip/issues).
-+You can also help out with users' questions, or discuss proposed changes in the [QuTiP discussion group](https://groups.google.com/g/qutip).
-+All code contributions are acknowledged in the [contributors](https://qutip.org/docs/latest/contributors.html) section in the documentation.
-+
-+For more information, including technical advice, please see the ["contributing to QuTiP development" section of the documentation](https://qutip.org/docs/latest/development/contributing.html).
-+
-+
-+Citing QuTiP
-+------------
-+
-+If you use QuTiP in your research, please cite the original QuTiP papers that are available [here](https://dml.riken.jp/?s=QuTiP).
-diff --git a/VERSION b/VERSION
-index 6f5f6c39..706882a4 100644
---- a/VERSION
-+++ b/VERSION
-@@ -1 +1 @@
--5.0.0.dev
-+5.0.0.dev
-diff --git a/pyproject.toml b/pyproject.toml
-index f854fa46..c858ef1e 100644
---- a/pyproject.toml
-+++ b/pyproject.toml
-@@ -1,54 +1,54 @@
--[build-system]
--requires = [
--    "setuptools",
--    "packaging",
--    "wheel",
--    "cython>=0.29.20",
--    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
--    # the recommended way to build against numpy's C API:
--    "oldest-supported-numpy",
--    "scipy>=1.0",
--]
--build-backend = "setuptools.build_meta"
--
--[tool.cibuildwheel]
--manylinux-x86_64-image = "manylinux2014"
--manylinux-i686-image = "manylinux2014"
--# Change in future version to "build"
--build-frontend = "pip"
--
--[[tool.cibuildwheel.overrides]]
--# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
--select = "cp3{6,7}-*"
--manylinux-x86_64-image = "manylinux2010"
--manylinux-i686-image = "manylinux2010"
--
--[tool.towncrier]
--directory = "doc/changes"
--filename = "doc/changelog.rst"
--name = "QuTiP"
--package = "qutip"
--[[tool.towncrier.type]]
--directory = "deprecation"
--name = "Deprecations"
--showcontent = true
--[[tool.towncrier.type]]
--directory = "feature"
--name = "Features"
--showcontent = true
--[[tool.towncrier.type]]
--directory = "bugfix"
--name = "Bug Fixes"
--showcontent = true
--[[tool.towncrier.type]]
--directory = "removal"
--name = "Removals"
--showcontent = true
--[[tool.towncrier.type]]
--directory = "doc"
--name = "Documentation"
--showcontent = true
--[[tool.towncrier.type]]
--directory = "misc"
--name = "Miscellaneous"
--showcontent = true
-+[build-system]
-+requires = [
-+    "setuptools",
-+    "packaging",
-+    "wheel",
-+    "cython>=0.29.20",
-+    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
-+    # the recommended way to build against numpy's C API:
-+    "oldest-supported-numpy",
-+    "scipy>=1.0",
-+]
-+build-backend = "setuptools.build_meta"
-+
-+[tool.cibuildwheel]
-+manylinux-x86_64-image = "manylinux2014"
-+manylinux-i686-image = "manylinux2014"
-+# Change in future version to "build"
-+build-frontend = "pip"
-+
-+[[tool.cibuildwheel.overrides]]
-+# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
-+select = "cp3{6,7}-*"
-+manylinux-x86_64-image = "manylinux2010"
-+manylinux-i686-image = "manylinux2010"
-+
-+[tool.towncrier]
-+directory = "doc/changes"
-+filename = "doc/changelog.rst"
-+name = "QuTiP"
-+package = "qutip"
-+[[tool.towncrier.type]]
-+directory = "deprecation"
-+name = "Deprecations"
-+showcontent = true
-+[[tool.towncrier.type]]
-+directory = "feature"
-+name = "Features"
-+showcontent = true
-+[[tool.towncrier.type]]
-+directory = "bugfix"
-+name = "Bug Fixes"
-+showcontent = true
-+[[tool.towncrier.type]]
-+directory = "removal"
-+name = "Removals"
-+showcontent = true
-+[[tool.towncrier.type]]
-+directory = "doc"
-+name = "Documentation"
-+showcontent = true
-+[[tool.towncrier.type]]
-+directory = "misc"
-+name = "Miscellaneous"
-+showcontent = true
-diff --git a/qutip/__init__.py b/qutip/__init__.py
-index fc7f65b4..fe889959 100644
---- a/qutip/__init__.py
-+++ b/qutip/__init__.py
-@@ -1,68 +1,68 @@
--import os
--import warnings
--
--import qutip.settings
--from qutip.settings import settings
--import qutip.version
--from qutip.version import version as __version__
--
--# -----------------------------------------------------------------------------
--# Look to see if we are running with OPENMP
--#
--# Set environ variable to determin if running in parallel mode
--# (i.e. in parfor or parallel_map)
--os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--
--
--# -----------------------------------------------------------------------------
--# Check that import modules are compatible with requested configuration
--#
--
--# Check for Matplotlib
--try:
--    import matplotlib
--except ImportError:
--    warnings.warn("matplotlib not found: Graphics will not work.")
--else:
--    del matplotlib
--
--
--# -----------------------------------------------------------------------------
--# Load modules
--#
--
--from .core import *
--from .solver import *
--from .solve import nonmarkov
--import qutip.solve.piqs as piqs
--from .solve.stochastic import *
--
--# graphics
--from .bloch import *
--from .visualization import *
--from .orbital import *
--from .bloch3d import *
--from .matplotlib_utilities import *
--
--# library functions
--from .tomography import *
--from .wigner import *
--from .random_objects import *
--from .simdiag import *
--from .entropy import *
--from .partial_transpose import *
--from .continuous_variables import *
--from .distributions import *
--from .three_level_atom import *
--
--
--# utilities
--from .utilities import *
--from .fileio import *
--from .about import *
--from .cite import *
--
--# -----------------------------------------------------------------------------
--# Clean name space
--#
--del os, warnings
-+import os
-+import warnings
-+
-+import qutip.settings
-+from qutip.settings import settings
-+import qutip.version
-+from qutip.version import version as __version__
-+
-+# -----------------------------------------------------------------------------
-+# Look to see if we are running with OPENMP
-+#
-+# Set environ variable to determin if running in parallel mode
-+# (i.e. in parfor or parallel_map)
-+os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+
-+
-+# -----------------------------------------------------------------------------
-+# Check that import modules are compatible with requested configuration
-+#
-+
-+# Check for Matplotlib
-+try:
-+    import matplotlib
-+except ImportError:
-+    warnings.warn("matplotlib not found: Graphics will not work.")
-+else:
-+    del matplotlib
-+
-+
-+# -----------------------------------------------------------------------------
-+# Load modules
-+#
-+
-+from .core import *
-+from .solver import *
-+from .solve import nonmarkov
-+import qutip.solve.piqs as piqs
-+from .solve.stochastic import *
-+
-+# graphics
-+from .bloch import *
-+from .visualization import *
-+from .orbital import *
-+from .bloch3d import *
-+from .matplotlib_utilities import *
-+
-+# library functions
-+from .tomography import *
-+from .wigner import *
-+from .random_objects import *
-+from .simdiag import *
-+from .entropy import *
-+from .partial_transpose import *
-+from .continuous_variables import *
-+from .distributions import *
-+from .three_level_atom import *
-+
-+
-+# utilities
-+from .utilities import *
-+from .fileio import *
-+from .about import *
-+from .cite import *
-+
-+# -----------------------------------------------------------------------------
-+# Clean name space
-+#
-+del os, warnings
-diff --git a/qutip/_mkl/__init__.py b/qutip/_mkl/__init__.py
-index 8b137891..d3f5a12f 100644
---- a/qutip/_mkl/__init__.py
-+++ b/qutip/_mkl/__init__.py
-@@ -1 +1 @@
--
-+
-diff --git a/qutip/_mkl/spmv.py b/qutip/_mkl/spmv.py
-index ac2ca16c..909e7b4b 100644
---- a/qutip/_mkl/spmv.py
-+++ b/qutip/_mkl/spmv.py
-@@ -1,38 +1,38 @@
--import numpy as np
--from ctypes import POINTER, c_int, c_char, byref
--from numpy.ctypeslib import ndpointer
--import qutip.settings as qset
--zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
--
--
--def mkl_spmv(A, x):
--    """
--    sparse csr_spmv using MKL
--    """
--    m, _ = A.shape
--
--    # Pointers to data of the matrix
--    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
--    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
--    indices = A.indices.ctypes.data_as(POINTER(c_int))
--
--    # Allocate output, using same conventions as input
--    if x.ndim == 1:
--        y = np.empty(m, dtype=np.complex128, order='C')
--    elif x.ndim == 2 and x.shape[1] == 1:
--        y = np.empty((m, 1), dtype=np.complex128, order='C')
--    else:
--        raise Exception('Input vector must be 1D row or 2D column vector')
--
--    # Now call MKL. This returns the answer in the last argument, which shares
--    # memory with y.
--    zcsrgemv(
--        byref(c_char(bytes(b'N'))),
--        byref(c_int(m)),
--        data,
--        indptr,
--        indices,
--        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
--        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
--    )
--    return y
-+import numpy as np
-+from ctypes import POINTER, c_int, c_char, byref
-+from numpy.ctypeslib import ndpointer
-+import qutip.settings as qset
-+zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
-+
-+
-+def mkl_spmv(A, x):
-+    """
-+    sparse csr_spmv using MKL
-+    """
-+    m, _ = A.shape
-+
-+    # Pointers to data of the matrix
-+    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
-+    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
-+    indices = A.indices.ctypes.data_as(POINTER(c_int))
-+
-+    # Allocate output, using same conventions as input
-+    if x.ndim == 1:
-+        y = np.empty(m, dtype=np.complex128, order='C')
-+    elif x.ndim == 2 and x.shape[1] == 1:
-+        y = np.empty((m, 1), dtype=np.complex128, order='C')
-+    else:
-+        raise Exception('Input vector must be 1D row or 2D column vector')
-+
-+    # Now call MKL. This returns the answer in the last argument, which shares
-+    # memory with y.
-+    zcsrgemv(
-+        byref(c_char(bytes(b'N'))),
-+        byref(c_int(m)),
-+        data,
-+        indptr,
-+        indices,
-+        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
-+        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
-+    )
-+    return y
-diff --git a/qutip/_mkl/spsolve.py b/qutip/_mkl/spsolve.py
-index 7a38c515..82d2266b 100644
---- a/qutip/_mkl/spsolve.py
-+++ b/qutip/_mkl/spsolve.py
-@@ -1,405 +1,405 @@
--import sys
--import numpy as np
--import scipy.sparse as sp
--from ctypes import c_int, byref
--from numpy.ctypeslib import ndpointer
--import time
--from qutip.settings import settings as qset
--
--# Load solver functions from mkl_lib
--pardiso = qset.mkl_lib.pardiso
--pardiso_delete = qset.mkl_lib.pardiso_handle_delete
--if sys.maxsize > 2**32: #Running 64-bit
--    pardiso_64 = qset.mkl_lib.pardiso_64
--    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
--
--
--def _pardiso_parameters(hermitian, has_perm,
--                        max_iter_refine,
--                        scaling_vectors,
--                        weighted_matching):
--    iparm = np.zeros(64, dtype=np.int32)
--    iparm[0] = 1  # Do not use default values
--    iparm[1] = 3  # Use openmp nested dissection
--    if has_perm:
--        iparm[4] = 1
--    iparm[7] = max_iter_refine  # Max number of iterative refinements
--    if hermitian:
--        iparm[9] = 8
--    else:
--        iparm[9] = 13
--    if not hermitian:
--        iparm[10] = int(scaling_vectors)
--        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
--    iparm[17] = -1
--    iparm[20] = 1
--    iparm[23] = 1  # Parallel factorization
--    iparm[26] = 0  # Check matrix structure
--    iparm[34] = 1  # Use zero-based indexing
--    return iparm
--
--
--# Set error messages
--pardiso_error_msgs = {
--    '-1': 'Input inconsistant',
--    '-2': 'Out of memory',
--    '-3': 'Reordering problem',
--    '-4':
--        'Zero pivot, numerical factorization or iterative refinement problem',
--    '-5': 'Unclassified internal error',
--    '-6': 'Reordering failed',
--    '-7': 'Diagonal matrix is singular',
--    '-8': '32-bit integer overflow',
--    '-9': 'Not enough memory for OOC',
--    '-10': 'Error opening OOC files',
--    '-11': 'Read/write error with OOC files',
--    '-12': 'Pardiso-64 called from 32-bit library',
--}
--
--
--def _default_solver_args():
--    return {
--        'hermitian': False,
--        'posdef': False,
--        'max_iter_refine': 10,
--        'scaling_vectors': True,
--        'weighted_matching': True,
--        'return_info': False,
--    }
--
--
--class mkl_lu:
--    """
--    Object pointing to LU factorization of a sparse matrix
--    generated by mkl_splu.
--
--    Methods
--    -------
--    solve(b, verbose=False)
--        Solve system of equations using given RHS vector 'b'.
--        Returns solution ndarray with same shape as input.
--
--    info()
--        Returns the statistics of the factorization and
--        solution in the lu.info attribute.
--
--    delete()
--        Deletes the allocated solver memory.
--
--    """
--    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
--                 indptr=None, indices=None, iparm=None, np_iparm=None,
--                 mtype=None, perm=None, np_perm=None, factor_time=None):
--        self._np_pt = np_pt
--        self._dim = dim
--        self._is_complex = is_complex
--        self._data = data
--        self._indptr = indptr
--        self._indices = indices
--        self._iparm = iparm
--        self._np_iparm = np_iparm
--        self._mtype = mtype
--        self._perm = perm
--        self._np_perm = np_perm
--        self._factor_time = factor_time
--        self._solve_time = None
--
--    def solve(self, b, verbose=None):
--        b_shp = b.shape
--        if b.ndim == 2 and b.shape[1] == 1:
--            b = b.ravel()
--            nrhs = 1
--        elif b.ndim == 2 and b.shape[1] != 1:
--            nrhs = b.shape[1]
--            b = b.ravel(order='F')
--        else:
--            b = b.ravel()
--            nrhs = 1
--
--        data_type = np.complex128 if self._is_complex else np.float64
--        if b.dtype != data_type:
--            b = b.astype(np.complex128, copy=False)
--
--        # Create solution array (x) and pointers to x and b
--        x = np.zeros(b.shape, dtype=data_type, order='C')
--        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
--        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
--
--        error = np.zeros(1, dtype=np.int32)
--        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--
--        # Call solver
--        _solve_start = time.time()
--        pardiso(
--            self._np_pt,
--            byref(c_int(1)),
--            byref(c_int(1)),
--            byref(c_int(self._mtype)),
--            byref(c_int(33)),
--            byref(c_int(self._dim)),
--            self._data,
--            self._indptr,
--            self._indices,
--            self._np_perm,
--            byref(c_int(nrhs)),
--            self._np_iparm,
--            byref(c_int(0)),
--            np_b,
--            np_x,
--            np_error,
--        )
--        self._solve_time = time.time() - _solve_start
--        if error[0] != 0:
--            raise Exception(pardiso_error_msgs[str(error[0])])
--
--        if verbose:
--            print('Solution Stage')
--            print('--------------')
--            print('Solution time:                  ',
--                  round(self._solve_time, 4))
--            print('Solution memory (Mb):           ',
--                  round(self._iparm[16]/1024, 4))
--            print('Number of iterative refinements:',
--                  self._iparm[6])
--            print('Total memory (Mb):              ',
--                  round(sum(self._iparm[15:17])/1024, 4))
--            print()
--        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
--
--    def info(self):
--        info = {'FactorTime': self._factor_time,
--                'SolveTime': self._solve_time,
--                'Factormem': round(self._iparm[15]/1024, 4),
--                'Solvemem': round(self._iparm[16]/1024, 4),
--                'IterRefine': self._iparm[6]}
--        return info
--
--    def delete(self):
--        # Delete all data
--        error = np.zeros(1, dtype=np.int32)
--        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--        pardiso(
--            self._np_pt,
--            byref(c_int(1)),
--            byref(c_int(1)),
--            byref(c_int(self._mtype)),
--            byref(c_int(-1)),
--            byref(c_int(self._dim)),
--            self._data,
--            self._indptr,
--            self._indices,
--            self._np_perm,
--            byref(c_int(1)),
--            self._np_iparm,
--            byref(c_int(0)),
--            byref(c_int(0)),
--            byref(c_int(0)),
--            np_error,
--        )
--        if error[0] == -10:
--            raise Exception('Error freeing solver memory')
--
--
--_MATRIX_TYPE_NAMES = {
--    4: 'Complex Hermitian positive-definite',
--    -4: 'Complex Hermitian indefinite',
--    2: 'Real symmetric positive-definite',
--    -2: 'Real symmetric indefinite',
--    11: 'Real non-symmetric',
--    13: 'Complex non-symmetric',
--}
--
--
--def _mkl_matrix_type(dtype, solver_args):
--    if not solver_args['hermitian']:
--        return 13 if dtype == np.complex128 else 11
--    out = 4 if dtype == np.complex128 else 2
--    return out if solver_args['posdef'] else -out
--
--
--def mkl_splu(A, perm=None, verbose=False, **kwargs):
--    """
--    Returns the LU factorization of the sparse matrix A.
--
--    Parameters
--    ----------
--    A : csr_matrix
--        Sparse input matrix.
--    perm : ndarray (optional)
--        User defined matrix factorization permutation.
--    verbose : bool {False, True}
--        Report factorization details.
--
--    Returns
--    -------
--    lu : mkl_lu
--        Returns object containing LU factorization with a
--        solve method for solving with a given RHS vector.
--
--    """
--    if not sp.isspmatrix_csr(A):
--        raise TypeError('Input matrix must be in sparse CSR format.')
--
--    if A.shape[0] != A.shape[1]:
--        raise Exception('Input matrix must be square')
--
--    dim = A.shape[0]
--    solver_args = _default_solver_args()
--    if set(kwargs) - set(solver_args):
--        raise ValueError(
--            "Unknown keyword arguments pass to mkl_splu: {!r}"
--            .format(set(kwargs) - set(solver_args))
--        )
--    solver_args.update(kwargs)
--
--    # If hermitian, then take upper-triangle of matrix only
--    if solver_args['hermitian']:
--        B = sp.triu(A, format='csr')
--        A = B  # This gets around making a full copy of A in triu
--    is_complex = bool(A.dtype == np.complex128)
--    if not is_complex:
--        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
--    data_type = A.dtype
--
--    # Create pointer to internal memory
--    pt = np.zeros(64, dtype=int)
--    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
--
--    # Create pointers to sparse matrix arrays
--    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
--    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--
--    # Setup perm array
--    if perm is None:
--        perm = np.zeros(dim, dtype=np.int32)
--        has_perm = 0
--    else:
--        has_perm = 1
--    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--
--    # setup iparm
--    iparm = _pardiso_parameters(
--        solver_args['hermitian'],
--        has_perm,
--        solver_args['max_iter_refine'],
--        solver_args['scaling_vectors'],
--        solver_args['weighted_matching'],
--    )
--    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--
--    # setup call parameters
--    mtype = _mkl_matrix_type(data_type, solver_args)
--
--    if verbose:
--        print('Solver Initialization')
--        print('---------------------')
--        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
--        print('Input matrix shape:', A.shape)
--        print('Input matrix NNZ:  ', A.nnz)
--        print()
--
--    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
--    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
--    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
--    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
--
--    error = np.zeros(1, dtype=np.int32)
--    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
--
--    # Call solver
--    _factor_start = time.time()
--    pardiso(
--        np_pt,
--        byref(c_int(1)),
--        byref(c_int(1)),
--        byref(c_int(mtype)),
--        byref(c_int(12)),
--        byref(c_int(dim)),
--        data,
--        indptr,
--        indices,
--        np_perm,
--        byref(c_int(1)),
--        np_iparm,
--        byref(c_int(0)),
--        np_b,
--        np_x,
--        np_error,
--    )
--    _factor_time = time.time() - _factor_start
--    if error[0] != 0:
--        raise Exception(pardiso_error_msgs[str(error[0])])
--
--    if verbose:
--        print('Analysis and Factorization Stage')
--        print('--------------------------------')
--        print('Factorization time:       ', round(_factor_time, 4))
--        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
--        print('NNZ in LU factors:        ', iparm[17])
--        print()
--
--    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
--                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
--
--
--def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
--    """
--    Solves a sparse linear system of equations using the
--    Intel MKL Pardiso solver.
--
--    Parameters
--    ----------
--    A : csr_matrix
--        Sparse matrix.
--    b : ndarray or sparse matrix
--        The vector or matrix representing the right hand side of the equation.
--        If a vector, b.shape must be (n,) or (n, 1).
--    perm : ndarray (optional)
--        User defined matrix factorization permutation.
--
--    Returns
--    -------
--    x : ndarray or csr_matrix
--        The solution of the sparse linear equation.
--        If b is a vector, then x is a vector of size A.shape[1]
--        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
--
--    """
--    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
--    b_is_sparse = sp.isspmatrix(b)
--    b_shp = b.shape
--    if b_is_sparse and b.shape[1] == 1:
--        b = b.toarray()
--        b_is_sparse = False
--    elif b_is_sparse and b.shape[1] != 1:
--        nrhs = b.shape[1]
--        if lu._is_complex:
--            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
--        else:
--            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
--
--    # Do dense RHS solving
--    if not b_is_sparse:
--        x = lu.solve(b, verbose=verbose)
--    # Solve each RHS vec individually and convert to sparse
--    else:
--        data_segs = []
--        row_segs = []
--        col_segs = []
--        for j in range(nrhs):
--            bj = b[:, j].A.ravel()
--            xj = lu.solve(bj)
--            w = np.flatnonzero(xj)
--            segment_length = w.shape[0]
--            row_segs.append(w)
--            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
--            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
--        sp_data = np.concatenate(data_segs)
--        sp_row = np.concatenate(row_segs)
--        sp_col = np.concatenate(col_segs)
--        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
--
--    info = lu.info()
--    lu.delete()
--    return (x, info) if kwargs.get('return_info', False) else x
-+import sys
-+import numpy as np
-+import scipy.sparse as sp
-+from ctypes import c_int, byref
-+from numpy.ctypeslib import ndpointer
-+import time
-+from qutip.settings import settings as qset
-+
-+# Load solver functions from mkl_lib
-+pardiso = qset.mkl_lib.pardiso
-+pardiso_delete = qset.mkl_lib.pardiso_handle_delete
-+if sys.maxsize > 2**32: #Running 64-bit
-+    pardiso_64 = qset.mkl_lib.pardiso_64
-+    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
-+
-+
-+def _pardiso_parameters(hermitian, has_perm,
-+                        max_iter_refine,
-+                        scaling_vectors,
-+                        weighted_matching):
-+    iparm = np.zeros(64, dtype=np.int32)
-+    iparm[0] = 1  # Do not use default values
-+    iparm[1] = 3  # Use openmp nested dissection
-+    if has_perm:
-+        iparm[4] = 1
-+    iparm[7] = max_iter_refine  # Max number of iterative refinements
-+    if hermitian:
-+        iparm[9] = 8
-+    else:
-+        iparm[9] = 13
-+    if not hermitian:
-+        iparm[10] = int(scaling_vectors)
-+        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
-+    iparm[17] = -1
-+    iparm[20] = 1
-+    iparm[23] = 1  # Parallel factorization
-+    iparm[26] = 0  # Check matrix structure
-+    iparm[34] = 1  # Use zero-based indexing
-+    return iparm
-+
-+
-+# Set error messages
-+pardiso_error_msgs = {
-+    '-1': 'Input inconsistant',
-+    '-2': 'Out of memory',
-+    '-3': 'Reordering problem',
-+    '-4':
-+        'Zero pivot, numerical factorization or iterative refinement problem',
-+    '-5': 'Unclassified internal error',
-+    '-6': 'Reordering failed',
-+    '-7': 'Diagonal matrix is singular',
-+    '-8': '32-bit integer overflow',
-+    '-9': 'Not enough memory for OOC',
-+    '-10': 'Error opening OOC files',
-+    '-11': 'Read/write error with OOC files',
-+    '-12': 'Pardiso-64 called from 32-bit library',
-+}
-+
-+
-+def _default_solver_args():
-+    return {
-+        'hermitian': False,
-+        'posdef': False,
-+        'max_iter_refine': 10,
-+        'scaling_vectors': True,
-+        'weighted_matching': True,
-+        'return_info': False,
-+    }
-+
-+
-+class mkl_lu:
-+    """
-+    Object pointing to LU factorization of a sparse matrix
-+    generated by mkl_splu.
-+
-+    Methods
-+    -------
-+    solve(b, verbose=False)
-+        Solve system of equations using given RHS vector 'b'.
-+        Returns solution ndarray with same shape as input.
-+
-+    info()
-+        Returns the statistics of the factorization and
-+        solution in the lu.info attribute.
-+
-+    delete()
-+        Deletes the allocated solver memory.
-+
-+    """
-+    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
-+                 indptr=None, indices=None, iparm=None, np_iparm=None,
-+                 mtype=None, perm=None, np_perm=None, factor_time=None):
-+        self._np_pt = np_pt
-+        self._dim = dim
-+        self._is_complex = is_complex
-+        self._data = data
-+        self._indptr = indptr
-+        self._indices = indices
-+        self._iparm = iparm
-+        self._np_iparm = np_iparm
-+        self._mtype = mtype
-+        self._perm = perm
-+        self._np_perm = np_perm
-+        self._factor_time = factor_time
-+        self._solve_time = None
-+
-+    def solve(self, b, verbose=None):
-+        b_shp = b.shape
-+        if b.ndim == 2 and b.shape[1] == 1:
-+            b = b.ravel()
-+            nrhs = 1
-+        elif b.ndim == 2 and b.shape[1] != 1:
-+            nrhs = b.shape[1]
-+            b = b.ravel(order='F')
-+        else:
-+            b = b.ravel()
-+            nrhs = 1
-+
-+        data_type = np.complex128 if self._is_complex else np.float64
-+        if b.dtype != data_type:
-+            b = b.astype(np.complex128, copy=False)
-+
-+        # Create solution array (x) and pointers to x and b
-+        x = np.zeros(b.shape, dtype=data_type, order='C')
-+        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-+        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-+
-+        error = np.zeros(1, dtype=np.int32)
-+        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+
-+        # Call solver
-+        _solve_start = time.time()
-+        pardiso(
-+            self._np_pt,
-+            byref(c_int(1)),
-+            byref(c_int(1)),
-+            byref(c_int(self._mtype)),
-+            byref(c_int(33)),
-+            byref(c_int(self._dim)),
-+            self._data,
-+            self._indptr,
-+            self._indices,
-+            self._np_perm,
-+            byref(c_int(nrhs)),
-+            self._np_iparm,
-+            byref(c_int(0)),
-+            np_b,
-+            np_x,
-+            np_error,
-+        )
-+        self._solve_time = time.time() - _solve_start
-+        if error[0] != 0:
-+            raise Exception(pardiso_error_msgs[str(error[0])])
-+
-+        if verbose:
-+            print('Solution Stage')
-+            print('--------------')
-+            print('Solution time:                  ',
-+                  round(self._solve_time, 4))
-+            print('Solution memory (Mb):           ',
-+                  round(self._iparm[16]/1024, 4))
-+            print('Number of iterative refinements:',
-+                  self._iparm[6])
-+            print('Total memory (Mb):              ',
-+                  round(sum(self._iparm[15:17])/1024, 4))
-+            print()
-+        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
-+
-+    def info(self):
-+        info = {'FactorTime': self._factor_time,
-+                'SolveTime': self._solve_time,
-+                'Factormem': round(self._iparm[15]/1024, 4),
-+                'Solvemem': round(self._iparm[16]/1024, 4),
-+                'IterRefine': self._iparm[6]}
-+        return info
-+
-+    def delete(self):
-+        # Delete all data
-+        error = np.zeros(1, dtype=np.int32)
-+        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+        pardiso(
-+            self._np_pt,
-+            byref(c_int(1)),
-+            byref(c_int(1)),
-+            byref(c_int(self._mtype)),
-+            byref(c_int(-1)),
-+            byref(c_int(self._dim)),
-+            self._data,
-+            self._indptr,
-+            self._indices,
-+            self._np_perm,
-+            byref(c_int(1)),
-+            self._np_iparm,
-+            byref(c_int(0)),
-+            byref(c_int(0)),
-+            byref(c_int(0)),
-+            np_error,
-+        )
-+        if error[0] == -10:
-+            raise Exception('Error freeing solver memory')
-+
-+
-+_MATRIX_TYPE_NAMES = {
-+    4: 'Complex Hermitian positive-definite',
-+    -4: 'Complex Hermitian indefinite',
-+    2: 'Real symmetric positive-definite',
-+    -2: 'Real symmetric indefinite',
-+    11: 'Real non-symmetric',
-+    13: 'Complex non-symmetric',
-+}
-+
-+
-+def _mkl_matrix_type(dtype, solver_args):
-+    if not solver_args['hermitian']:
-+        return 13 if dtype == np.complex128 else 11
-+    out = 4 if dtype == np.complex128 else 2
-+    return out if solver_args['posdef'] else -out
-+
-+
-+def mkl_splu(A, perm=None, verbose=False, **kwargs):
-+    """
-+    Returns the LU factorization of the sparse matrix A.
-+
-+    Parameters
-+    ----------
-+    A : csr_matrix
-+        Sparse input matrix.
-+    perm : ndarray (optional)
-+        User defined matrix factorization permutation.
-+    verbose : bool {False, True}
-+        Report factorization details.
-+
-+    Returns
-+    -------
-+    lu : mkl_lu
-+        Returns object containing LU factorization with a
-+        solve method for solving with a given RHS vector.
-+
-+    """
-+    if not sp.isspmatrix_csr(A):
-+        raise TypeError('Input matrix must be in sparse CSR format.')
-+
-+    if A.shape[0] != A.shape[1]:
-+        raise Exception('Input matrix must be square')
-+
-+    dim = A.shape[0]
-+    solver_args = _default_solver_args()
-+    if set(kwargs) - set(solver_args):
-+        raise ValueError(
-+            "Unknown keyword arguments pass to mkl_splu: {!r}"
-+            .format(set(kwargs) - set(solver_args))
-+        )
-+    solver_args.update(kwargs)
-+
-+    # If hermitian, then take upper-triangle of matrix only
-+    if solver_args['hermitian']:
-+        B = sp.triu(A, format='csr')
-+        A = B  # This gets around making a full copy of A in triu
-+    is_complex = bool(A.dtype == np.complex128)
-+    if not is_complex:
-+        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
-+    data_type = A.dtype
-+
-+    # Create pointer to internal memory
-+    pt = np.zeros(64, dtype=int)
-+    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
-+
-+    # Create pointers to sparse matrix arrays
-+    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-+    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+
-+    # Setup perm array
-+    if perm is None:
-+        perm = np.zeros(dim, dtype=np.int32)
-+        has_perm = 0
-+    else:
-+        has_perm = 1
-+    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+
-+    # setup iparm
-+    iparm = _pardiso_parameters(
-+        solver_args['hermitian'],
-+        has_perm,
-+        solver_args['max_iter_refine'],
-+        solver_args['scaling_vectors'],
-+        solver_args['weighted_matching'],
-+    )
-+    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+
-+    # setup call parameters
-+    mtype = _mkl_matrix_type(data_type, solver_args)
-+
-+    if verbose:
-+        print('Solver Initialization')
-+        print('---------------------')
-+        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
-+        print('Input matrix shape:', A.shape)
-+        print('Input matrix NNZ:  ', A.nnz)
-+        print()
-+
-+    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
-+    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-+    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
-+    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-+
-+    error = np.zeros(1, dtype=np.int32)
-+    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-+
-+    # Call solver
-+    _factor_start = time.time()
-+    pardiso(
-+        np_pt,
-+        byref(c_int(1)),
-+        byref(c_int(1)),
-+        byref(c_int(mtype)),
-+        byref(c_int(12)),
-+        byref(c_int(dim)),
-+        data,
-+        indptr,
-+        indices,
-+        np_perm,
-+        byref(c_int(1)),
-+        np_iparm,
-+        byref(c_int(0)),
-+        np_b,
-+        np_x,
-+        np_error,
-+    )
-+    _factor_time = time.time() - _factor_start
-+    if error[0] != 0:
-+        raise Exception(pardiso_error_msgs[str(error[0])])
-+
-+    if verbose:
-+        print('Analysis and Factorization Stage')
-+        print('--------------------------------')
-+        print('Factorization time:       ', round(_factor_time, 4))
-+        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
-+        print('NNZ in LU factors:        ', iparm[17])
-+        print()
-+
-+    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
-+                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
-+
-+
-+def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
-+    """
-+    Solves a sparse linear system of equations using the
-+    Intel MKL Pardiso solver.
-+
-+    Parameters
-+    ----------
-+    A : csr_matrix
-+        Sparse matrix.
-+    b : ndarray or sparse matrix
-+        The vector or matrix representing the right hand side of the equation.
-+        If a vector, b.shape must be (n,) or (n, 1).
-+    perm : ndarray (optional)
-+        User defined matrix factorization permutation.
-+
-+    Returns
-+    -------
-+    x : ndarray or csr_matrix
-+        The solution of the sparse linear equation.
-+        If b is a vector, then x is a vector of size A.shape[1]
-+        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
-+
-+    """
-+    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
-+    b_is_sparse = sp.isspmatrix(b)
-+    b_shp = b.shape
-+    if b_is_sparse and b.shape[1] == 1:
-+        b = b.toarray()
-+        b_is_sparse = False
-+    elif b_is_sparse and b.shape[1] != 1:
-+        nrhs = b.shape[1]
-+        if lu._is_complex:
-+            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
-+        else:
-+            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
-+
-+    # Do dense RHS solving
-+    if not b_is_sparse:
-+        x = lu.solve(b, verbose=verbose)
-+    # Solve each RHS vec individually and convert to sparse
-+    else:
-+        data_segs = []
-+        row_segs = []
-+        col_segs = []
-+        for j in range(nrhs):
-+            bj = b[:, j].A.ravel()
-+            xj = lu.solve(bj)
-+            w = np.flatnonzero(xj)
-+            segment_length = w.shape[0]
-+            row_segs.append(w)
-+            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
-+            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
-+        sp_data = np.concatenate(data_segs)
-+        sp_row = np.concatenate(row_segs)
-+        sp_col = np.concatenate(col_segs)
-+        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
-+
-+    info = lu.info()
-+    lu.delete()
-+    return (x, info) if kwargs.get('return_info', False) else x
-diff --git a/qutip/about.py b/qutip/about.py
-index 0e5eb166..57e7322c 100644
---- a/qutip/about.py
-+++ b/qutip/about.py
-@@ -1,75 +1,75 @@
--"""
--Command line output of information on QuTiP and dependencies.
--"""
--__all__ = ['about']
--
--import sys
--import os
--import platform
--import numpy
--import scipy
--import inspect
--import qutip
--from qutip.settings import _blas_info, settings
--
--
--def about():
--    """
--    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
--    and MatPlotLib.
--    """
--    print("")
--    print("QuTiP: Quantum Toolbox in Python")
--    print("================================")
--    print("Copyright (c) QuTiP team 2011 and later.")
--    print(
--        "Current admin team: Alexander Pitchford, "
--        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
--        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
--    )
--    print(
--        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
--        "Franco Nori and Will Zeng."
--    )
--    print("Original developers: R. J. Johansson & P. D. Nation.")
--    print("Previous lead developers: Chris Granade & A. Grimsmo.")
--    print("Currently developed through wide collaboration. "
--          "See https://github.com/qutip for details.")
--    print("")
--    print("QuTiP Version:      %s" % qutip.__version__)
--    print("Numpy Version:      %s" % numpy.__version__)
--    print("Scipy Version:      %s" % scipy.__version__)
--    try:
--        import Cython
--        cython_ver = Cython.__version__
--    except ImportError:
--        cython_ver = 'None'
--    print("Cython Version:     %s" % cython_ver)
--    try:
--        import matplotlib
--        matplotlib_ver = matplotlib.__version__
--    except ImportError:
--        matplotlib_ver = 'None'
--    print("Matplotlib Version: %s" % matplotlib_ver)
--    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
--    print("Number of CPUs:     %s" % settings.num_cpus)
--    print("BLAS Info:          %s" % _blas_info())
--    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
--    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
--    print("Platform Info:      %s (%s)" % (platform.system(),
--                                           platform.machine()))
--    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
--    print("Installation path:  %s" % qutip_install_path)
--
--    # citation
--    longbar = "=" * 80
--    cite_msg = "For your convenience a bibtex reference can be easily"
--    cite_msg += " generated using `qutip.cite()`"
--    print(longbar)
--    print("Please cite QuTiP in your publication.")
--    print(longbar)
--    print(cite_msg)
--
--
--if __name__ == "__main__":
--    about()
-+"""
-+Command line output of information on QuTiP and dependencies.
-+"""
-+__all__ = ['about']
-+
-+import sys
-+import os
-+import platform
-+import numpy
-+import scipy
-+import inspect
-+import qutip
-+from qutip.settings import _blas_info, settings
-+
-+
-+def about():
-+    """
-+    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
-+    and MatPlotLib.
-+    """
-+    print("")
-+    print("QuTiP: Quantum Toolbox in Python")
-+    print("================================")
-+    print("Copyright (c) QuTiP team 2011 and later.")
-+    print(
-+        "Current admin team: Alexander Pitchford, "
-+        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
-+        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
-+    )
-+    print(
-+        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
-+        "Franco Nori and Will Zeng."
-+    )
-+    print("Original developers: R. J. Johansson & P. D. Nation.")
-+    print("Previous lead developers: Chris Granade & A. Grimsmo.")
-+    print("Currently developed through wide collaboration. "
-+          "See https://github.com/qutip for details.")
-+    print("")
-+    print("QuTiP Version:      %s" % qutip.__version__)
-+    print("Numpy Version:      %s" % numpy.__version__)
-+    print("Scipy Version:      %s" % scipy.__version__)
-+    try:
-+        import Cython
-+        cython_ver = Cython.__version__
-+    except ImportError:
-+        cython_ver = 'None'
-+    print("Cython Version:     %s" % cython_ver)
-+    try:
-+        import matplotlib
-+        matplotlib_ver = matplotlib.__version__
-+    except ImportError:
-+        matplotlib_ver = 'None'
-+    print("Matplotlib Version: %s" % matplotlib_ver)
-+    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
-+    print("Number of CPUs:     %s" % settings.num_cpus)
-+    print("BLAS Info:          %s" % _blas_info())
-+    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
-+    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
-+    print("Platform Info:      %s (%s)" % (platform.system(),
-+                                           platform.machine()))
-+    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
-+    print("Installation path:  %s" % qutip_install_path)
-+
-+    # citation
-+    longbar = "=" * 80
-+    cite_msg = "For your convenience a bibtex reference can be easily"
-+    cite_msg += " generated using `qutip.cite()`"
-+    print(longbar)
-+    print("Please cite QuTiP in your publication.")
-+    print(longbar)
-+    print(cite_msg)
-+
-+
-+if __name__ == "__main__":
-+    about()
-diff --git a/qutip/bloch.py b/qutip/bloch.py
-index 980502dd..e67ed504 100644
---- a/qutip/bloch.py
-+++ b/qutip/bloch.py
-@@ -1,928 +1,928 @@
--__all__ = ['Bloch']
--
--import os
--
--import numpy as np
--from numpy import (outer, cos, sin, ones)
--
--from packaging.version import parse as parse_version
--
--from . import Qobj, expect, sigmax, sigmay, sigmaz
--
--try:
--    import matplotlib
--    import matplotlib.pyplot as plt
--    from mpl_toolkits.mplot3d import Axes3D
--    from matplotlib.patches import FancyArrowPatch
--    from mpl_toolkits.mplot3d import proj3d
--
--    # Define a custom _axes3D function based on the matplotlib version.
--    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
--    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
--        def _axes3D(fig, *args, **kwargs):
--            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
--            return fig.add_axes(ax)
--    else:
--        def _axes3D(*args, **kwargs):
--            return Axes3D(*args, **kwargs)
--
--    class Arrow3D(FancyArrowPatch):
--        def __init__(self, xs, ys, zs, *args, **kwargs):
--            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
--
--            self._verts3d = xs, ys, zs
--
--        def draw(self, renderer):
--            xs3d, ys3d, zs3d = self._verts3d
--            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
--
--            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
--            FancyArrowPatch.draw(self, renderer)
--
--        def do_3d_projection(self, renderer=None):
--            # only called by matplotlib >= 3.5
--            xs3d, ys3d, zs3d = self._verts3d
--            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
--            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
--            return np.min(zs)
--except ImportError:
--    pass
--
--try:
--    from IPython.display import display
--except ImportError:
--    pass
--
--
--class Bloch:
--    r"""
--    Class for plotting data on the Bloch sphere.  Valid data can be either
--    points, vectors, or Qobj objects.
--
--    Attributes
--    ----------
--    axes : matplotlib.axes.Axes
--        User supplied Matplotlib axes for Bloch sphere animation.
--    fig : matplotlib.figure.Figure
--        User supplied Matplotlib Figure instance for plotting Bloch sphere.
--    font_color : str, default 'black'
--        Color of font used for Bloch sphere labels.
--    font_size : int, default 20
--        Size of font used for Bloch sphere labels.
--    frame_alpha : float, default 0.1
--        Sets transparency of Bloch sphere frame.
--    frame_color : str, default 'gray'
--        Color of sphere wireframe.
--    frame_width : int, default 1
--        Width of wireframe.
--    point_color : list, default ["b", "r", "g", "#CC6600"]
--        List of colors for Bloch sphere point markers to cycle through, i.e.
--        by default, points 0 and 4 will both be blue ('b').
--    point_marker : list, default ["o", "s", "d", "^"]
--        List of point marker shapes to cycle through.
--    point_size : list, default [25, 32, 35, 45]
--        List of point marker sizes. Note, not all point markers look the same
--        size when plotted!
--    sphere_alpha : float, default 0.2
--        Transparency of Bloch sphere itself.
--    sphere_color : str, default '#FFDDDD'
--        Color of Bloch sphere.
--    figsize : list, default [7, 7]
--        Figure size of Bloch sphere plot.  Best to have both numbers the same;
--        otherwise you will have a Bloch sphere that looks like a football.
--    vector_color : list, ["g", "#CC6600", "b", "r"]
--        List of vector colors to cycle through.
--    vector_width : int, default 5
--        Width of displayed vectors.
--    vector_style : str, default '-\|>'
--        Vector arrowhead style (from matplotlib's arrow style).
--    vector_mutation : int, default 20
--        Width of vectors arrowhead.
--    view : list, default [-60, 30]
--        Azimuthal and Elevation viewing angles.
--    xlabel : list, default ["$x$", ""]
--        List of strings corresponding to +x and -x axes labels, respectively.
--    xlpos : list, default [1.1, -1.1]
--        Positions of +x and -x labels respectively.
--    ylabel : list, default ["$y$", ""]
--        List of strings corresponding to +y and -y axes labels, respectively.
--    ylpos : list, default [1.2, -1.2]
--        Positions of +y and -y labels respectively.
--    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
--        List of strings corresponding to +z and -z axes labels, respectively.
--    zlpos : list, default [1.2, -1.2]
--        Positions of +z and -z labels respectively.
--    """
--    def __init__(self, fig=None, axes=None, view=None, figsize=None,
--                 background=False):
--        # Figure and axes
--        self.fig = fig
--        self._ext_fig = fig is not None
--        self.axes = axes
--        # Background axes, default = False
--        self.background = background
--        # The size of the figure in inches, default = [5,5].
--        self.figsize = figsize if figsize else [5, 5]
--        # Azimuthal and Elvation viewing angles, default = [-60,30].
--        self.view = view if view else [-60, 30]
--        # Color of Bloch sphere, default = #FFDDDD
--        self.sphere_color = '#FFDDDD'
--        # Transparency of Bloch sphere, default = 0.2
--        self.sphere_alpha = 0.2
--        # Color of wireframe, default = 'gray'
--        self.frame_color = 'gray'
--        # Width of wireframe, default = 1
--        self.frame_width = 1
--        # Transparency of wireframe, default = 0.2
--        self.frame_alpha = 0.2
--        # Labels for x-axis (in LaTex), default = ['$x$', '']
--        self.xlabel = ['$x$', '']
--        # Position of x-axis labels, default = [1.2, -1.2]
--        self.xlpos = [1.2, -1.2]
--        # Labels for y-axis (in LaTex), default = ['$y$', '']
--        self.ylabel = ['$y$', '']
--        # Position of y-axis labels, default = [1.1, -1.1]
--        self.ylpos = [1.2, -1.2]
--        # Labels for z-axis (in LaTex),
--        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
--        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
--        # Position of z-axis labels, default = [1.2, -1.2]
--        self.zlpos = [1.2, -1.2]
--        # ---font options---
--        # Color of fonts, default = 'black'
--        self.font_color = 'black'
--        # Size of fonts, default = 20
--        self.font_size = 20
--
--        # ---vector options---
--        # List of colors for Bloch vectors, default = ['b','g','r','y']
--        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
--        # List that stores the display colors for each vector
--        self.vector_color = []
--        #: Width of Bloch vectors, default = 5
--        self.vector_width = 3
--        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
--        self.vector_style = '-|>'
--        #: Sets the width of the vectors arrowhead
--        self.vector_mutation = 20
--
--        # ---point options---
--        # List of colors for Bloch point markers, default = ['b','g','r','y']
--        self.point_default_color = ['b', 'r', 'g', '#CC6600']
--        # List that stores the display colors for each set of points
--        self.point_color = []
--        # Size of point markers, default = 25
--        self.point_size = [25, 32, 35, 45]
--        # Shape of point markers, default = ['o','^','d','s']
--        self.point_marker = ['o', 's', 'd', '^']
--
--        # ---data lists---
--        # Data for point markers
--        self.points = []
--        # Data for Bloch vectors
--        self.vectors = []
--        # Transparency of vectors, alpha value from 0 to 1
--        self.vector_alpha = []
--        # Data for annotations
--        self.annotations = []
--        # Number of times sphere has been saved
--        self.savenum = 0
--        # Style of points, 'm' for multiple colors, 's' for single color
--        self.point_style = []
--        # Transparency of points, alpha value from 0 to 1
--        self.point_alpha = []
--        # Data for line segment
--        self._lines = []
--        # Data for arcs and arc style
--        self._arcs = []
--
--    def set_label_convention(self, convention):
--        """Set x, y and z labels according to one of conventions.
--
--        Parameters
--        ----------
--        convention : string
--            One of the following:
--
--            - "original"
--            - "xyz"
--            - "sx sy sz"
--            - "01"
--            - "polarization jones"
--            - "polarization jones letters"
--              see also: https://en.wikipedia.org/wiki/Jones_calculus
--            - "polarization stokes"
--              see also: https://en.wikipedia.org/wiki/Stokes_parameters
--        """
--        ketex = "$\\left.|%s\\right\\rangle$"
--        # \left.| is on purpose, so that every ket has the same size
--
--        if convention == "original":
--            self.xlabel = ['$x$', '']
--            self.ylabel = ['$y$', '']
--            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
--        elif convention == "xyz":
--            self.xlabel = ['$x$', '']
--            self.ylabel = ['$y$', '']
--            self.zlabel = ['$z$', '']
--        elif convention == "sx sy sz":
--            self.xlabel = ['$s_x$', '']
--            self.ylabel = ['$s_y$', '']
--            self.zlabel = ['$s_z$', '']
--        elif convention == "01":
--            self.xlabel = ['', '']
--            self.ylabel = ['', '']
--            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
--        elif convention == "polarization jones":
--            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
--                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
--            self.ylabel = [ketex % "\\circlearrowleft", ketex %
--                           "\\circlearrowright"]
--            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
--        elif convention == "polarization jones letters":
--            self.xlabel = [ketex % "D", ketex % "A"]
--            self.ylabel = [ketex % "L", ketex % "R"]
--            self.zlabel = [ketex % "H", ketex % "V"]
--        elif convention == "polarization stokes":
--            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
--                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
--            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
--            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
--        else:
--            raise Exception("No such convention.")
--
--    def __str__(self):
--        s = ""
--        s += "Bloch data:\n"
--        s += "-----------\n"
--        s += "Number of points:  " + str(len(self.points)) + "\n"
--        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
--        s += "\n"
--        s += "Bloch sphere properties:\n"
--        s += "------------------------\n"
--        s += "font_color:      " + str(self.font_color) + "\n"
--        s += "font_size:       " + str(self.font_size) + "\n"
--        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
--        s += "frame_color:     " + str(self.frame_color) + "\n"
--        s += "frame_width:     " + str(self.frame_width) + "\n"
--        s += "point_default_color:" + str(self.point_default_color) + "\n"
--        s += "point_marker:    " + str(self.point_marker) + "\n"
--        s += "point_size:      " + str(self.point_size) + "\n"
--        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
--        s += "sphere_color:    " + str(self.sphere_color) + "\n"
--        s += "figsize:         " + str(self.figsize) + "\n"
--        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
--        s += "vector_width:    " + str(self.vector_width) + "\n"
--        s += "vector_style:    " + str(self.vector_style) + "\n"
--        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
--        s += "view:            " + str(self.view) + "\n"
--        s += "xlabel:          " + str(self.xlabel) + "\n"
--        s += "xlpos:           " + str(self.xlpos) + "\n"
--        s += "ylabel:          " + str(self.ylabel) + "\n"
--        s += "ylpos:           " + str(self.ylpos) + "\n"
--        s += "zlabel:          " + str(self.zlabel) + "\n"
--        s += "zlpos:           " + str(self.zlpos) + "\n"
--        return s
--
--    def _repr_png_(self):
--        from IPython.core.pylabtools import print_figure
--        self.render()
--        fig_data = print_figure(self.fig, 'png')
--        plt.close(self.fig)
--        return fig_data
--
--    def _repr_svg_(self):
--        from IPython.core.pylabtools import print_figure
--        self.render()
--        fig_data = print_figure(self.fig, 'svg')
--        plt.close(self.fig)
--        return fig_data
--
--    def clear(self):
--        """Resets Bloch sphere data sets to empty.
--        """
--        self.points = []
--        self.vectors = []
--        self.point_style = []
--        self.point_alpha = []
--        self.vector_alpha = []
--        self.annotations = []
--        self.vector_color = []
--        self.point_color = []
--        self._lines = []
--        self._arcs = []
--
--    def add_points(self, points, meth='s', colors=None, alpha=1.0):
--        """Add a list of data points to bloch sphere.
--
--        Parameters
--        ----------
--        points : array_like
--            Collection of data points.
--
--        meth : {'s', 'm', 'l'}
--            Type of points to plot, use 'm' for multicolored, 'l' for points
--            connected with a line.
--
--        colors : array_like
--            Optional array with colors for the points.
--            A single color for meth 's', and list of colors for meth 'm'
--
--        alpha : float, default=1.
--            Transparency value for the vectors. Values between 0 and 1.
--
--        .. note::
--
--           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
--           to ``0.75`` and there was no way to alter it.
--           When the ``alpha`` parameter was added in QuTiP 4.7, the default
--           became ``alpha=1.0`` for values of ``meth``.
--        """
--
--        points = np.asarray(points)
--
--        if points.ndim == 1:
--            points = points[:, np.newaxis]
--
--        if points.ndim != 2 or points.shape[0] != 3:
--            raise ValueError("The included points are not valid. Points must "
--                             "be equivalent to a 2D array where the first "
--                             "index represents the x,y,z values and the "
--                             "second index iterates over the points.")
--
--        if meth not in ['s', 'm', 'l']:
--            raise ValueError(f"The value for meth = {meth} is not valid."
--                             " Please use 's', 'l' or 'm'.")
--
--        if meth == 's' and points.shape[1] == 1:
--            points = np.append(points[:, :1], points, axis=1)
--
--        self.point_style.append(meth)
--        self.points.append(points)
--        self.point_alpha.append(alpha)
--        self.point_color.append(colors)
--
--    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
--        """Add a state vector Qobj to Bloch sphere.
--
--        Parameters
--        ----------
--        state : Qobj
--            Input state vector.
--
--        kind : {'vector', 'point'}
--            Type of object to plot.
--
--        colors : array_like
--            Optional array with colors for the states.
--
--        alpha : float, default=1.
--            Transparency value for the vectors. Values between 0 and 1.
--        """
--        if isinstance(state, Qobj):
--            state = [state]
--        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
--            colors = [colors]
--
--        for k, st in enumerate(state):
--            vec = [expect(sigmax(), st),
--                   expect(sigmay(), st),
--                   expect(sigmaz(), st)]
--
--            if kind == 'vector':
--                if colors is not None:
--                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
--                else:
--                    self.add_vectors(vec)
--            elif kind == 'point':
--                if colors is not None:
--                    self.add_points(vec, colors=colors[k], alpha=alpha)
--                else:
--                    self.add_points(vec)
--
--    def add_vectors(self, vectors, colors=None, alpha=1.0):
--        """Add a list of vectors to Bloch sphere.
--
--        Parameters
--        ----------
--        vectors : array_like
--            Array with vectors of unit length or smaller.
--
--        colors : array_like
--            Optional array with colors for the vectors.
--
--        alpha : float, default=1.
--            Transparency value for the vectors. Values between 0 and 1.
--
--        """
--        vectors = np.asarray(vectors)
--
--        if vectors.ndim == 1:
--            vectors = vectors[np.newaxis, :]
--
--        if vectors.ndim != 2 or vectors.shape[1] != 3:
--            raise ValueError(
--                "The included vectors are not valid. Vectors must "
--                "be equivalent to a 2D array where the first "
--                "index represents the iteration over the vectors and the "
--                "second index represents the position in 3D of vector head.")
--
--        n_vectors = vectors.shape[0]
--        if colors is None:
--            colors = np.array([None] * n_vectors)
--        else:
--            colors = np.asarray(colors)
--
--        if colors.ndim != 1 or colors.size != n_vectors:
--            raise ValueError("The included colors are not valid. colors must "
--                             "be equivalent to a 1D array with the same "
--                             "size as the number of vectors. ")
--
--        for k, vec in enumerate(vectors):
--            self.vectors.append(vec)
--            self.vector_alpha.append(alpha)
--            self.vector_color.append(colors[k])
--
--    def add_annotation(self, state_or_vector, text, **kwargs):
--        """
--        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
--        state or a vector.
--
--        Parameters
--        ----------
--        state_or_vector : Qobj/array/list/tuple
--            Position for the annotaion.
--            Qobj of a qubit or a vector of 3 elements.
--
--        text : str
--            Annotation text.
--            You can use LaTeX, but remember to use raw string
--            e.g. r"$\\langle x \\rangle$"
--            or escape backslashes
--            e.g. "$\\\\langle x \\\\rangle$".
--
--        kwargs :
--            Options as for mplot3d.axes3d.text, including:
--            fontsize, color, horizontalalignment, verticalalignment.
--
--        """
--        if isinstance(state_or_vector, Qobj):
--            vec = [expect(sigmax(), state_or_vector),
--                   expect(sigmay(), state_or_vector),
--                   expect(sigmaz(), state_or_vector)]
--        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
--                and len(state_or_vector) == 3:
--            vec = state_or_vector
--        else:
--            raise Exception("Position needs to be specified by a qubit " +
--                            "state or a 3D vector.")
--        self.annotations.append({'position': vec,
--                                 'text': text,
--                                 'opts': kwargs})
--
--    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
--        """Adds an arc between two points on a sphere. The arc is set to be
--        blue solid curve by default.
--
--        The start and end points must be on the same sphere (i.e. have the
--        same radius) but need not be on the unit sphere.
--
--        Parameters
--        ----------
--        start : Qobj or array-like
--            Array with cartesian coordinates of the first point, or a state
--            vector or density matrix that can be mapped to a point on or
--            within the Bloch sphere.
--        end : Qobj or array-like
--            Array with cartesian coordinates of the second point, or a state
--            vector or density matrix that can be mapped to a point on or
--            within the Bloch sphere.
--        fmt : str, default: "b"
--            A matplotlib format string for rendering the arc.
--        steps : int, default: None
--            The number of segments to use when rendering the arc. The default
--            uses 100 steps times the distance between the start and end points,
--            with a minimum of 2 steps.
--        **kwargs : dict
--            Additional parameters to pass to the matplotlib .plot function
--            when rendering this arc.
--        """
--        if isinstance(start, Qobj):
--            pt1 = [
--                expect(sigmax(), start),
--                expect(sigmay(), start),
--                expect(sigmaz(), start),
--            ]
--        else:
--            pt1 = start
--
--        if isinstance(end, Qobj):
--            pt2 = [
--                expect(sigmax(), end),
--                expect(sigmay(), end),
--                expect(sigmaz(), end),
--            ]
--        else:
--            pt2 = end
--
--        pt1 = np.asarray(pt1)
--        pt2 = np.asarray(pt2)
--
--        len1 = np.linalg.norm(pt1)
--        len2 = np.linalg.norm(pt2)
--        if len1 < 1e-12 or len2 < 1e-12:
--            raise ValueError('Polar and azimuthal angles undefined at origin.')
--        elif abs(len1 - len2) > 1e-12:
--            raise ValueError("Points not on the same sphere.")
--        elif (pt1 == pt2).all():
--            raise ValueError(
--                "Start and end represent the same point. No arc can be formed."
--            )
--        elif (pt1 == -pt2).all():
--            raise ValueError(
--                "Start and end are diagonally opposite, no unique arc is"
--                " possible."
--            )
--
--        if steps is None:
--            steps = int(np.linalg.norm(pt1 - pt2) * 100)
--            steps = max(2, steps)
--        t = np.linspace(0, 1, steps)
--        # All the points in this line are contained in the plane defined
--        # by pt1, pt2 and the origin.
--        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
--        # Normalize all the points in the line so that are distance len1 from
--        # the origin.
--        arc = line * len1 / np.linalg.norm(line, axis=0)
--        self._arcs.append([arc, fmt, kwargs])
--
--    def add_line(self, start, end, fmt="k", **kwargs):
--        """Adds a line segment connecting two points on the bloch sphere.
--
--        The line segment is set to be a black solid line by default.
--
--        Parameters
--        ----------
--        start : Qobj or array-like
--            Array with cartesian coordinates of the first point, or a state
--            vector or density matrix that can be mapped to a point on or
--            within the Bloch sphere.
--        end : Qobj or array-like
--            Array with cartesian coordinates of the second point, or a state
--            vector or density matrix that can be mapped to a point on or
--            within the Bloch sphere.
--        fmt : str, default: "k"
--            A matplotlib format string for rendering the line.
--        **kwargs : dict
--            Additional parameters to pass to the matplotlib .plot function
--            when rendering this line.
--        """
--        if isinstance(start, Qobj):
--            pt1 = [
--                expect(sigmax(), start),
--                expect(sigmay(), start),
--                expect(sigmaz(), start),
--            ]
--        else:
--            pt1 = start
--
--        if isinstance(end, Qobj):
--            pt2 = [
--                expect(sigmax(), end),
--                expect(sigmay(), end),
--                expect(sigmaz(), end),
--            ]
--        else:
--            pt2 = end
--
--        pt1 = np.asarray(pt1)
--        pt2 = np.asarray(pt2)
--
--        x = [pt1[1], pt2[1]]
--        y = [-pt1[0], -pt2[0]]
--        z = [pt1[2], pt2[2]]
--        v = [x, y, z]
--        self._lines.append([v, fmt, kwargs])
--
--    def make_sphere(self):
--        """
--        Plots Bloch sphere and data sets.
--        """
--        self.render()
--
--    def run_from_ipython(self):
--        try:
--            __IPYTHON__
--            return True
--        except NameError:
--            return False
--
--    def _is_inline_backend(self):
--        backend = matplotlib.get_backend()
--        return backend == "module://matplotlib_inline.backend_inline"
--
--    def render(self):
--        """
--        Render the Bloch sphere and its data sets in on given figure and axes.
--        """
--        if not self._ext_fig and not self._is_inline_backend():
--            # If no external figure was supplied, we check to see if the
--            # figure we created in a previous call to .render() has been
--            # closed, and re-create if has been. This has the unfortunate
--            # side effect of losing any modifications made to the axes or
--            # figure, but the alternative is to crash the matplotlib backend.
--            #
--            # The inline backend used by, e.g. jupyter notebooks, is happy to
--            # use closed figures so we leave those figures intact.
--            if (
--                self.fig is not None and
--                not plt.fignum_exists(self.fig.number)
--            ):
--                self.fig = None
--                self.axes = None
--
--        if self.fig is None:
--            self.fig = plt.figure(figsize=self.figsize)
--            if self._is_inline_backend():
--                # We immediately close the inline figure do avoid displaying
--                # the figure twice when .show() calls display.
--                plt.close(self.fig)
--
--        if self.axes is None:
--            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
--
--        # Clearing the axes is horrifically slow and loses a lot of the
--        # axes state, but matplotlib doesn't seem to provide a better way
--        # to redraw Axes3D. :/
--        self.axes.clear()
--        self.axes.grid(False)
--        if self.background:
--            self.axes.set_xlim3d(-1.3, 1.3)
--            self.axes.set_ylim3d(-1.3, 1.3)
--            self.axes.set_zlim3d(-1.3, 1.3)
--        else:
--            self.axes.set_axis_off()
--            self.axes.set_xlim3d(-0.7, 0.7)
--            self.axes.set_ylim3d(-0.7, 0.7)
--            self.axes.set_zlim3d(-0.7, 0.7)
--        # Manually set aspect ratio to fit a square bounding box.
--        # Matplotlib did this stretching for < 3.3.0, but not above.
--        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
--            self.axes.set_box_aspect((1, 1, 1))
--        if not self.background:
--            self.plot_axes()
--
--        self.plot_back()
--        self.plot_points()
--        self.plot_vectors()
--        self.plot_lines()
--        self.plot_arcs()
--        self.plot_front()
--        self.plot_axes_labels()
--        self.plot_annotations()
--        # Trigger an update of the Bloch sphere if it is already shown:
--        self.fig.canvas.draw()
--
--    def plot_back(self):
--        # back half of sphere
--        u = np.linspace(0, np.pi, 25)
--        v = np.linspace(0, np.pi, 25)
--        x = outer(cos(u), sin(v))
--        y = outer(sin(u), sin(v))
--        z = outer(ones(np.size(u)), cos(v))
--        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
--                               color=self.sphere_color, linewidth=0,
--                               alpha=self.sphere_alpha)
--        # wireframe
--        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
--                                 color=self.frame_color,
--                                 alpha=self.frame_alpha)
--        # equator
--        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
--                       lw=self.frame_width, color=self.frame_color)
--        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
--                       lw=self.frame_width, color=self.frame_color)
--
--    def plot_front(self):
--        # front half of sphere
--        u = np.linspace(-np.pi, 0, 25)
--        v = np.linspace(0, np.pi, 25)
--        x = outer(cos(u), sin(v))
--        y = outer(sin(u), sin(v))
--        z = outer(ones(np.size(u)), cos(v))
--        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
--                               color=self.sphere_color, linewidth=0,
--                               alpha=self.sphere_alpha)
--        # wireframe
--        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
--                                 color=self.frame_color,
--                                 alpha=self.frame_alpha)
--        # equator
--        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
--                       zs=0, zdir='z', lw=self.frame_width,
--                       color=self.frame_color)
--        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
--                       zs=0, zdir='x', lw=self.frame_width,
--                       color=self.frame_color)
--
--    def plot_axes(self):
--        # axes
--        span = np.linspace(-1.0, 1.0, 2)
--        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
--                       lw=self.frame_width, color=self.frame_color)
--        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
--                       lw=self.frame_width, color=self.frame_color)
--        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
--                       lw=self.frame_width, color=self.frame_color)
--
--    def plot_axes_labels(self):
--        # axes labels
--        opts = {'fontsize': self.font_size,
--                'color': self.font_color,
--                'horizontalalignment': 'center',
--                'verticalalignment': 'center'}
--        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
--        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
--
--        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
--        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
--
--        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
--        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
--
--        for a in (self.axes.xaxis.get_ticklines() +
--                  self.axes.xaxis.get_ticklabels()):
--            a.set_visible(False)
--        for a in (self.axes.yaxis.get_ticklines() +
--                  self.axes.yaxis.get_ticklabels()):
--            a.set_visible(False)
--        for a in (self.axes.zaxis.get_ticklines() +
--                  self.axes.zaxis.get_ticklabels()):
--            a.set_visible(False)
--
--    def plot_vectors(self):
--        # -X and Y data are switched for plotting purposes
--        for k, vec in enumerate(self.vectors):
--
--            xs3d = vec[1] * np.array([0, 1])
--            ys3d = -vec[0] * np.array([0, 1])
--            zs3d = vec[2] * np.array([0, 1])
--
--            alpha = self.vector_alpha[k]
--            color = self.vector_color[k]
--            if color is None:
--                idx = k % len(self.vector_default_color)
--                color = self.vector_default_color[idx]
--
--            # decorated style, with arrow heads
--            a = Arrow3D(xs3d, ys3d, zs3d,
--                        mutation_scale=self.vector_mutation,
--                        lw=self.vector_width,
--                        arrowstyle=self.vector_style,
--                        color=color, alpha=alpha)
--
--            self.axes.add_artist(a)
--
--    def plot_points(self):
--        # -X and Y data are switched for plotting purposes
--        for k, points in enumerate(self.points):
--            points = np.asarray(points)
--            num_points = points.shape[1]
--
--            dist = np.linalg.norm(points, axis=0)
--            if not np.allclose(dist, dist[0], rtol=1e-12):
--                indperm = np.argsort(dist)
--                points = points[:, indperm]
--            else:
--                indperm = np.arange(num_points)
--
--            s = self.point_size[np.mod(k, len(self.point_size))]
--            marker = self.point_marker[np.mod(k, len(self.point_marker))]
--            style = self.point_style[k]
--            if self.point_color[k] is not None:
--                color = self.point_color[k]
--            elif self.point_style[k] in ['s', 'l']:
--                color = self.point_default_color[
--                    k % len(self.point_default_color)
--                ]
--            elif self.point_style[k] == 'm':
--                length = np.ceil(num_points/len(self.point_default_color))
--                color = np.tile(self.point_default_color, length.astype(int))
--                color = color[indperm]
--
--            if self.point_style[k] in ['s', 'm']:
--                self.axes.scatter(np.real(points[1]),
--                                  -np.real(points[0]),
--                                  np.real(points[2]),
--                                  s=s,
--                                  marker=marker,
--                                  color=color,
--                                  alpha=self.point_alpha[k],
--                                  edgecolor=None,
--                                  zdir='z',
--                                  )
--
--            elif self.point_style[k] == 'l':
--                self.axes.plot(np.real(points[1]),
--                               -np.real(points[0]),
--                               np.real(points[2]),
--                               color=color,
--                               alpha=self.point_alpha[k],
--                               zdir='z',
--                               )
--
--    def plot_annotations(self):
--        # -X and Y data are switched for plotting purposes
--        for annotation in self.annotations:
--            vec = annotation['position']
--            opts = {'fontsize': self.font_size,
--                    'color': self.font_color,
--                    'horizontalalignment': 'center',
--                    'verticalalignment': 'center'}
--            opts.update(annotation['opts'])
--            self.axes.text(vec[1], -vec[0], vec[2],
--                           annotation['text'], **opts)
--
--    def plot_lines(self):
--        for line, fmt, kw in self._lines:
--            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
--
--    def plot_arcs(self):
--        for arc, fmt, kw in self._arcs:
--            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
--
--    def show(self):
--        """
--        Display Bloch sphere and corresponding data sets.
--
--        Notes
--        -----
--
--        When using inline plotting in Jupyter notebooks, any figure created
--        in a notebook cell is displayed after the cell executes. Thus if you
--        create a figure yourself and use it create a Bloch sphere with
--        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
--        cell, then the figure will be displayed twice. If you do create your
--        own figure, the simplest solution to this is to not call ``.show()``
--        in the cell you create the figure in.
--        """
--        self.render()
--        if self.run_from_ipython():
--            display(self.fig)
--        else:
--            self.fig.show()
--
--    def save(self, name=None, format='png', dirc=None, dpin=None):
--        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
--
--        Parameters
--        ----------
--
--        name : str
--            Name of saved image. Must include path and format as well.
--            i.e. '/Users/Paul/Desktop/bloch.png'
--            This overrides the 'format' and 'dirc' arguments.
--        format : str
--            Format of output image.
--        dirc : str
--            Directory for output images. Defaults to current working directory.
--        dpin : int
--            Resolution in dots per inch.
--
--        Returns
--        -------
--        File containing plot of Bloch sphere.
--
--        """
--        self.render()
--        # Conditional variable for first argument to savefig
--        # that is set in subsequent if-elses
--        complete_path = ""
--        if dirc:
--            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
--                os.makedirs(os.getcwd() + "/" + str(dirc))
--        if name is None:
--            if dirc:
--                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
--                                + str(self.savenum) + '.' + format
--            else:
--                complete_path = os.getcwd() + '/bloch_' + \
--                                str(self.savenum) + '.' + format
--        else:
--            complete_path = name
--
--        if dpin:
--            self.fig.savefig(complete_path, dpi=dpin)
--        else:
--            self.fig.savefig(complete_path)
--        self.savenum += 1
--        if self.fig:
--            plt.close(self.fig)
--
--
--def _hide_tick_lines_and_labels(axis):
--    '''
--    Set visible property of ticklines and ticklabels of an axis to False
--    '''
--    for a in axis.get_ticklines() + axis.get_ticklabels():
--        a.set_visible(False)
-+__all__ = ['Bloch']
-+
-+import os
-+
-+import numpy as np
-+from numpy import (outer, cos, sin, ones)
-+
-+from packaging.version import parse as parse_version
-+
-+from . import Qobj, expect, sigmax, sigmay, sigmaz
-+
-+try:
-+    import matplotlib
-+    import matplotlib.pyplot as plt
-+    from mpl_toolkits.mplot3d import Axes3D
-+    from matplotlib.patches import FancyArrowPatch
-+    from mpl_toolkits.mplot3d import proj3d
-+
-+    # Define a custom _axes3D function based on the matplotlib version.
-+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-+    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
-+        def _axes3D(fig, *args, **kwargs):
-+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-+            return fig.add_axes(ax)
-+    else:
-+        def _axes3D(*args, **kwargs):
-+            return Axes3D(*args, **kwargs)
-+
-+    class Arrow3D(FancyArrowPatch):
-+        def __init__(self, xs, ys, zs, *args, **kwargs):
-+            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
-+
-+            self._verts3d = xs, ys, zs
-+
-+        def draw(self, renderer):
-+            xs3d, ys3d, zs3d = self._verts3d
-+            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
-+
-+            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
-+            FancyArrowPatch.draw(self, renderer)
-+
-+        def do_3d_projection(self, renderer=None):
-+            # only called by matplotlib >= 3.5
-+            xs3d, ys3d, zs3d = self._verts3d
-+            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
-+            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
-+            return np.min(zs)
-+except ImportError:
-+    pass
-+
-+try:
-+    from IPython.display import display
-+except ImportError:
-+    pass
-+
-+
-+class Bloch:
-+    r"""
-+    Class for plotting data on the Bloch sphere.  Valid data can be either
-+    points, vectors, or Qobj objects.
-+
-+    Attributes
-+    ----------
-+    axes : matplotlib.axes.Axes
-+        User supplied Matplotlib axes for Bloch sphere animation.
-+    fig : matplotlib.figure.Figure
-+        User supplied Matplotlib Figure instance for plotting Bloch sphere.
-+    font_color : str, default 'black'
-+        Color of font used for Bloch sphere labels.
-+    font_size : int, default 20
-+        Size of font used for Bloch sphere labels.
-+    frame_alpha : float, default 0.1
-+        Sets transparency of Bloch sphere frame.
-+    frame_color : str, default 'gray'
-+        Color of sphere wireframe.
-+    frame_width : int, default 1
-+        Width of wireframe.
-+    point_color : list, default ["b", "r", "g", "#CC6600"]
-+        List of colors for Bloch sphere point markers to cycle through, i.e.
-+        by default, points 0 and 4 will both be blue ('b').
-+    point_marker : list, default ["o", "s", "d", "^"]
-+        List of point marker shapes to cycle through.
-+    point_size : list, default [25, 32, 35, 45]
-+        List of point marker sizes. Note, not all point markers look the same
-+        size when plotted!
-+    sphere_alpha : float, default 0.2
-+        Transparency of Bloch sphere itself.
-+    sphere_color : str, default '#FFDDDD'
-+        Color of Bloch sphere.
-+    figsize : list, default [7, 7]
-+        Figure size of Bloch sphere plot.  Best to have both numbers the same;
-+        otherwise you will have a Bloch sphere that looks like a football.
-+    vector_color : list, ["g", "#CC6600", "b", "r"]
-+        List of vector colors to cycle through.
-+    vector_width : int, default 5
-+        Width of displayed vectors.
-+    vector_style : str, default '-\|>'
-+        Vector arrowhead style (from matplotlib's arrow style).
-+    vector_mutation : int, default 20
-+        Width of vectors arrowhead.
-+    view : list, default [-60, 30]
-+        Azimuthal and Elevation viewing angles.
-+    xlabel : list, default ["$x$", ""]
-+        List of strings corresponding to +x and -x axes labels, respectively.
-+    xlpos : list, default [1.1, -1.1]
-+        Positions of +x and -x labels respectively.
-+    ylabel : list, default ["$y$", ""]
-+        List of strings corresponding to +y and -y axes labels, respectively.
-+    ylpos : list, default [1.2, -1.2]
-+        Positions of +y and -y labels respectively.
-+    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
-+        List of strings corresponding to +z and -z axes labels, respectively.
-+    zlpos : list, default [1.2, -1.2]
-+        Positions of +z and -z labels respectively.
-+    """
-+    def __init__(self, fig=None, axes=None, view=None, figsize=None,
-+                 background=False):
-+        # Figure and axes
-+        self.fig = fig
-+        self._ext_fig = fig is not None
-+        self.axes = axes
-+        # Background axes, default = False
-+        self.background = background
-+        # The size of the figure in inches, default = [5,5].
-+        self.figsize = figsize if figsize else [5, 5]
-+        # Azimuthal and Elvation viewing angles, default = [-60,30].
-+        self.view = view if view else [-60, 30]
-+        # Color of Bloch sphere, default = #FFDDDD
-+        self.sphere_color = '#FFDDDD'
-+        # Transparency of Bloch sphere, default = 0.2
-+        self.sphere_alpha = 0.2
-+        # Color of wireframe, default = 'gray'
-+        self.frame_color = 'gray'
-+        # Width of wireframe, default = 1
-+        self.frame_width = 1
-+        # Transparency of wireframe, default = 0.2
-+        self.frame_alpha = 0.2
-+        # Labels for x-axis (in LaTex), default = ['$x$', '']
-+        self.xlabel = ['$x$', '']
-+        # Position of x-axis labels, default = [1.2, -1.2]
-+        self.xlpos = [1.2, -1.2]
-+        # Labels for y-axis (in LaTex), default = ['$y$', '']
-+        self.ylabel = ['$y$', '']
-+        # Position of y-axis labels, default = [1.1, -1.1]
-+        self.ylpos = [1.2, -1.2]
-+        # Labels for z-axis (in LaTex),
-+        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
-+        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
-+        # Position of z-axis labels, default = [1.2, -1.2]
-+        self.zlpos = [1.2, -1.2]
-+        # ---font options---
-+        # Color of fonts, default = 'black'
-+        self.font_color = 'black'
-+        # Size of fonts, default = 20
-+        self.font_size = 20
-+
-+        # ---vector options---
-+        # List of colors for Bloch vectors, default = ['b','g','r','y']
-+        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
-+        # List that stores the display colors for each vector
-+        self.vector_color = []
-+        #: Width of Bloch vectors, default = 5
-+        self.vector_width = 3
-+        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
-+        self.vector_style = '-|>'
-+        #: Sets the width of the vectors arrowhead
-+        self.vector_mutation = 20
-+
-+        # ---point options---
-+        # List of colors for Bloch point markers, default = ['b','g','r','y']
-+        self.point_default_color = ['b', 'r', 'g', '#CC6600']
-+        # List that stores the display colors for each set of points
-+        self.point_color = []
-+        # Size of point markers, default = 25
-+        self.point_size = [25, 32, 35, 45]
-+        # Shape of point markers, default = ['o','^','d','s']
-+        self.point_marker = ['o', 's', 'd', '^']
-+
-+        # ---data lists---
-+        # Data for point markers
-+        self.points = []
-+        # Data for Bloch vectors
-+        self.vectors = []
-+        # Transparency of vectors, alpha value from 0 to 1
-+        self.vector_alpha = []
-+        # Data for annotations
-+        self.annotations = []
-+        # Number of times sphere has been saved
-+        self.savenum = 0
-+        # Style of points, 'm' for multiple colors, 's' for single color
-+        self.point_style = []
-+        # Transparency of points, alpha value from 0 to 1
-+        self.point_alpha = []
-+        # Data for line segment
-+        self._lines = []
-+        # Data for arcs and arc style
-+        self._arcs = []
-+
-+    def set_label_convention(self, convention):
-+        """Set x, y and z labels according to one of conventions.
-+
-+        Parameters
-+        ----------
-+        convention : string
-+            One of the following:
-+
-+            - "original"
-+            - "xyz"
-+            - "sx sy sz"
-+            - "01"
-+            - "polarization jones"
-+            - "polarization jones letters"
-+              see also: https://en.wikipedia.org/wiki/Jones_calculus
-+            - "polarization stokes"
-+              see also: https://en.wikipedia.org/wiki/Stokes_parameters
-+        """
-+        ketex = "$\\left.|%s\\right\\rangle$"
-+        # \left.| is on purpose, so that every ket has the same size
-+
-+        if convention == "original":
-+            self.xlabel = ['$x$', '']
-+            self.ylabel = ['$y$', '']
-+            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
-+        elif convention == "xyz":
-+            self.xlabel = ['$x$', '']
-+            self.ylabel = ['$y$', '']
-+            self.zlabel = ['$z$', '']
-+        elif convention == "sx sy sz":
-+            self.xlabel = ['$s_x$', '']
-+            self.ylabel = ['$s_y$', '']
-+            self.zlabel = ['$s_z$', '']
-+        elif convention == "01":
-+            self.xlabel = ['', '']
-+            self.ylabel = ['', '']
-+            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
-+        elif convention == "polarization jones":
-+            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
-+                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
-+            self.ylabel = [ketex % "\\circlearrowleft", ketex %
-+                           "\\circlearrowright"]
-+            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
-+        elif convention == "polarization jones letters":
-+            self.xlabel = [ketex % "D", ketex % "A"]
-+            self.ylabel = [ketex % "L", ketex % "R"]
-+            self.zlabel = [ketex % "H", ketex % "V"]
-+        elif convention == "polarization stokes":
-+            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
-+                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
-+            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
-+            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
-+        else:
-+            raise Exception("No such convention.")
-+
-+    def __str__(self):
-+        s = ""
-+        s += "Bloch data:\n"
-+        s += "-----------\n"
-+        s += "Number of points:  " + str(len(self.points)) + "\n"
-+        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
-+        s += "\n"
-+        s += "Bloch sphere properties:\n"
-+        s += "------------------------\n"
-+        s += "font_color:      " + str(self.font_color) + "\n"
-+        s += "font_size:       " + str(self.font_size) + "\n"
-+        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
-+        s += "frame_color:     " + str(self.frame_color) + "\n"
-+        s += "frame_width:     " + str(self.frame_width) + "\n"
-+        s += "point_default_color:" + str(self.point_default_color) + "\n"
-+        s += "point_marker:    " + str(self.point_marker) + "\n"
-+        s += "point_size:      " + str(self.point_size) + "\n"
-+        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
-+        s += "sphere_color:    " + str(self.sphere_color) + "\n"
-+        s += "figsize:         " + str(self.figsize) + "\n"
-+        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
-+        s += "vector_width:    " + str(self.vector_width) + "\n"
-+        s += "vector_style:    " + str(self.vector_style) + "\n"
-+        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
-+        s += "view:            " + str(self.view) + "\n"
-+        s += "xlabel:          " + str(self.xlabel) + "\n"
-+        s += "xlpos:           " + str(self.xlpos) + "\n"
-+        s += "ylabel:          " + str(self.ylabel) + "\n"
-+        s += "ylpos:           " + str(self.ylpos) + "\n"
-+        s += "zlabel:          " + str(self.zlabel) + "\n"
-+        s += "zlpos:           " + str(self.zlpos) + "\n"
-+        return s
-+
-+    def _repr_png_(self):
-+        from IPython.core.pylabtools import print_figure
-+        self.render()
-+        fig_data = print_figure(self.fig, 'png')
-+        plt.close(self.fig)
-+        return fig_data
-+
-+    def _repr_svg_(self):
-+        from IPython.core.pylabtools import print_figure
-+        self.render()
-+        fig_data = print_figure(self.fig, 'svg')
-+        plt.close(self.fig)
-+        return fig_data
-+
-+    def clear(self):
-+        """Resets Bloch sphere data sets to empty.
-+        """
-+        self.points = []
-+        self.vectors = []
-+        self.point_style = []
-+        self.point_alpha = []
-+        self.vector_alpha = []
-+        self.annotations = []
-+        self.vector_color = []
-+        self.point_color = []
-+        self._lines = []
-+        self._arcs = []
-+
-+    def add_points(self, points, meth='s', colors=None, alpha=1.0):
-+        """Add a list of data points to bloch sphere.
-+
-+        Parameters
-+        ----------
-+        points : array_like
-+            Collection of data points.
-+
-+        meth : {'s', 'm', 'l'}
-+            Type of points to plot, use 'm' for multicolored, 'l' for points
-+            connected with a line.
-+
-+        colors : array_like
-+            Optional array with colors for the points.
-+            A single color for meth 's', and list of colors for meth 'm'
-+
-+        alpha : float, default=1.
-+            Transparency value for the vectors. Values between 0 and 1.
-+
-+        .. note::
-+
-+           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
-+           to ``0.75`` and there was no way to alter it.
-+           When the ``alpha`` parameter was added in QuTiP 4.7, the default
-+           became ``alpha=1.0`` for values of ``meth``.
-+        """
-+
-+        points = np.asarray(points)
-+
-+        if points.ndim == 1:
-+            points = points[:, np.newaxis]
-+
-+        if points.ndim != 2 or points.shape[0] != 3:
-+            raise ValueError("The included points are not valid. Points must "
-+                             "be equivalent to a 2D array where the first "
-+                             "index represents the x,y,z values and the "
-+                             "second index iterates over the points.")
-+
-+        if meth not in ['s', 'm', 'l']:
-+            raise ValueError(f"The value for meth = {meth} is not valid."
-+                             " Please use 's', 'l' or 'm'.")
-+
-+        if meth == 's' and points.shape[1] == 1:
-+            points = np.append(points[:, :1], points, axis=1)
-+
-+        self.point_style.append(meth)
-+        self.points.append(points)
-+        self.point_alpha.append(alpha)
-+        self.point_color.append(colors)
-+
-+    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
-+        """Add a state vector Qobj to Bloch sphere.
-+
-+        Parameters
-+        ----------
-+        state : Qobj
-+            Input state vector.
-+
-+        kind : {'vector', 'point'}
-+            Type of object to plot.
-+
-+        colors : array_like
-+            Optional array with colors for the states.
-+
-+        alpha : float, default=1.
-+            Transparency value for the vectors. Values between 0 and 1.
-+        """
-+        if isinstance(state, Qobj):
-+            state = [state]
-+        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
-+            colors = [colors]
-+
-+        for k, st in enumerate(state):
-+            vec = [expect(sigmax(), st),
-+                   expect(sigmay(), st),
-+                   expect(sigmaz(), st)]
-+
-+            if kind == 'vector':
-+                if colors is not None:
-+                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
-+                else:
-+                    self.add_vectors(vec)
-+            elif kind == 'point':
-+                if colors is not None:
-+                    self.add_points(vec, colors=colors[k], alpha=alpha)
-+                else:
-+                    self.add_points(vec)
-+
-+    def add_vectors(self, vectors, colors=None, alpha=1.0):
-+        """Add a list of vectors to Bloch sphere.
-+
-+        Parameters
-+        ----------
-+        vectors : array_like
-+            Array with vectors of unit length or smaller.
-+
-+        colors : array_like
-+            Optional array with colors for the vectors.
-+
-+        alpha : float, default=1.
-+            Transparency value for the vectors. Values between 0 and 1.
-+
-+        """
-+        vectors = np.asarray(vectors)
-+
-+        if vectors.ndim == 1:
-+            vectors = vectors[np.newaxis, :]
-+
-+        if vectors.ndim != 2 or vectors.shape[1] != 3:
-+            raise ValueError(
-+                "The included vectors are not valid. Vectors must "
-+                "be equivalent to a 2D array where the first "
-+                "index represents the iteration over the vectors and the "
-+                "second index represents the position in 3D of vector head.")
-+
-+        n_vectors = vectors.shape[0]
-+        if colors is None:
-+            colors = np.array([None] * n_vectors)
-+        else:
-+            colors = np.asarray(colors)
-+
-+        if colors.ndim != 1 or colors.size != n_vectors:
-+            raise ValueError("The included colors are not valid. colors must "
-+                             "be equivalent to a 1D array with the same "
-+                             "size as the number of vectors. ")
-+
-+        for k, vec in enumerate(vectors):
-+            self.vectors.append(vec)
-+            self.vector_alpha.append(alpha)
-+            self.vector_color.append(colors[k])
-+
-+    def add_annotation(self, state_or_vector, text, **kwargs):
-+        """
-+        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
-+        state or a vector.
-+
-+        Parameters
-+        ----------
-+        state_or_vector : Qobj/array/list/tuple
-+            Position for the annotaion.
-+            Qobj of a qubit or a vector of 3 elements.
-+
-+        text : str
-+            Annotation text.
-+            You can use LaTeX, but remember to use raw string
-+            e.g. r"$\\langle x \\rangle$"
-+            or escape backslashes
-+            e.g. "$\\\\langle x \\\\rangle$".
-+
-+        kwargs :
-+            Options as for mplot3d.axes3d.text, including:
-+            fontsize, color, horizontalalignment, verticalalignment.
-+
-+        """
-+        if isinstance(state_or_vector, Qobj):
-+            vec = [expect(sigmax(), state_or_vector),
-+                   expect(sigmay(), state_or_vector),
-+                   expect(sigmaz(), state_or_vector)]
-+        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
-+                and len(state_or_vector) == 3:
-+            vec = state_or_vector
-+        else:
-+            raise Exception("Position needs to be specified by a qubit " +
-+                            "state or a 3D vector.")
-+        self.annotations.append({'position': vec,
-+                                 'text': text,
-+                                 'opts': kwargs})
-+
-+    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
-+        """Adds an arc between two points on a sphere. The arc is set to be
-+        blue solid curve by default.
-+
-+        The start and end points must be on the same sphere (i.e. have the
-+        same radius) but need not be on the unit sphere.
-+
-+        Parameters
-+        ----------
-+        start : Qobj or array-like
-+            Array with cartesian coordinates of the first point, or a state
-+            vector or density matrix that can be mapped to a point on or
-+            within the Bloch sphere.
-+        end : Qobj or array-like
-+            Array with cartesian coordinates of the second point, or a state
-+            vector or density matrix that can be mapped to a point on or
-+            within the Bloch sphere.
-+        fmt : str, default: "b"
-+            A matplotlib format string for rendering the arc.
-+        steps : int, default: None
-+            The number of segments to use when rendering the arc. The default
-+            uses 100 steps times the distance between the start and end points,
-+            with a minimum of 2 steps.
-+        **kwargs : dict
-+            Additional parameters to pass to the matplotlib .plot function
-+            when rendering this arc.
-+        """
-+        if isinstance(start, Qobj):
-+            pt1 = [
-+                expect(sigmax(), start),
-+                expect(sigmay(), start),
-+                expect(sigmaz(), start),
-+            ]
-+        else:
-+            pt1 = start
-+
-+        if isinstance(end, Qobj):
-+            pt2 = [
-+                expect(sigmax(), end),
-+                expect(sigmay(), end),
-+                expect(sigmaz(), end),
-+            ]
-+        else:
-+            pt2 = end
-+
-+        pt1 = np.asarray(pt1)
-+        pt2 = np.asarray(pt2)
-+
-+        len1 = np.linalg.norm(pt1)
-+        len2 = np.linalg.norm(pt2)
-+        if len1 < 1e-12 or len2 < 1e-12:
-+            raise ValueError('Polar and azimuthal angles undefined at origin.')
-+        elif abs(len1 - len2) > 1e-12:
-+            raise ValueError("Points not on the same sphere.")
-+        elif (pt1 == pt2).all():
-+            raise ValueError(
-+                "Start and end represent the same point. No arc can be formed."
-+            )
-+        elif (pt1 == -pt2).all():
-+            raise ValueError(
-+                "Start and end are diagonally opposite, no unique arc is"
-+                " possible."
-+            )
-+
-+        if steps is None:
-+            steps = int(np.linalg.norm(pt1 - pt2) * 100)
-+            steps = max(2, steps)
-+        t = np.linspace(0, 1, steps)
-+        # All the points in this line are contained in the plane defined
-+        # by pt1, pt2 and the origin.
-+        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
-+        # Normalize all the points in the line so that are distance len1 from
-+        # the origin.
-+        arc = line * len1 / np.linalg.norm(line, axis=0)
-+        self._arcs.append([arc, fmt, kwargs])
-+
-+    def add_line(self, start, end, fmt="k", **kwargs):
-+        """Adds a line segment connecting two points on the bloch sphere.
-+
-+        The line segment is set to be a black solid line by default.
-+
-+        Parameters
-+        ----------
-+        start : Qobj or array-like
-+            Array with cartesian coordinates of the first point, or a state
-+            vector or density matrix that can be mapped to a point on or
-+            within the Bloch sphere.
-+        end : Qobj or array-like
-+            Array with cartesian coordinates of the second point, or a state
-+            vector or density matrix that can be mapped to a point on or
-+            within the Bloch sphere.
-+        fmt : str, default: "k"
-+            A matplotlib format string for rendering the line.
-+        **kwargs : dict
-+            Additional parameters to pass to the matplotlib .plot function
-+            when rendering this line.
-+        """
-+        if isinstance(start, Qobj):
-+            pt1 = [
-+                expect(sigmax(), start),
-+                expect(sigmay(), start),
-+                expect(sigmaz(), start),
-+            ]
-+        else:
-+            pt1 = start
-+
-+        if isinstance(end, Qobj):
-+            pt2 = [
-+                expect(sigmax(), end),
-+                expect(sigmay(), end),
-+                expect(sigmaz(), end),
-+            ]
-+        else:
-+            pt2 = end
-+
-+        pt1 = np.asarray(pt1)
-+        pt2 = np.asarray(pt2)
-+
-+        x = [pt1[1], pt2[1]]
-+        y = [-pt1[0], -pt2[0]]
-+        z = [pt1[2], pt2[2]]
-+        v = [x, y, z]
-+        self._lines.append([v, fmt, kwargs])
-+
-+    def make_sphere(self):
-+        """
-+        Plots Bloch sphere and data sets.
-+        """
-+        self.render()
-+
-+    def run_from_ipython(self):
-+        try:
-+            __IPYTHON__
-+            return True
-+        except NameError:
-+            return False
-+
-+    def _is_inline_backend(self):
-+        backend = matplotlib.get_backend()
-+        return backend == "module://matplotlib_inline.backend_inline"
-+
-+    def render(self):
-+        """
-+        Render the Bloch sphere and its data sets in on given figure and axes.
-+        """
-+        if not self._ext_fig and not self._is_inline_backend():
-+            # If no external figure was supplied, we check to see if the
-+            # figure we created in a previous call to .render() has been
-+            # closed, and re-create if has been. This has the unfortunate
-+            # side effect of losing any modifications made to the axes or
-+            # figure, but the alternative is to crash the matplotlib backend.
-+            #
-+            # The inline backend used by, e.g. jupyter notebooks, is happy to
-+            # use closed figures so we leave those figures intact.
-+            if (
-+                self.fig is not None and
-+                not plt.fignum_exists(self.fig.number)
-+            ):
-+                self.fig = None
-+                self.axes = None
-+
-+        if self.fig is None:
-+            self.fig = plt.figure(figsize=self.figsize)
-+            if self._is_inline_backend():
-+                # We immediately close the inline figure do avoid displaying
-+                # the figure twice when .show() calls display.
-+                plt.close(self.fig)
-+
-+        if self.axes is None:
-+            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
-+
-+        # Clearing the axes is horrifically slow and loses a lot of the
-+        # axes state, but matplotlib doesn't seem to provide a better way
-+        # to redraw Axes3D. :/
-+        self.axes.clear()
-+        self.axes.grid(False)
-+        if self.background:
-+            self.axes.set_xlim3d(-1.3, 1.3)
-+            self.axes.set_ylim3d(-1.3, 1.3)
-+            self.axes.set_zlim3d(-1.3, 1.3)
-+        else:
-+            self.axes.set_axis_off()
-+            self.axes.set_xlim3d(-0.7, 0.7)
-+            self.axes.set_ylim3d(-0.7, 0.7)
-+            self.axes.set_zlim3d(-0.7, 0.7)
-+        # Manually set aspect ratio to fit a square bounding box.
-+        # Matplotlib did this stretching for < 3.3.0, but not above.
-+        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
-+            self.axes.set_box_aspect((1, 1, 1))
-+        if not self.background:
-+            self.plot_axes()
-+
-+        self.plot_back()
-+        self.plot_points()
-+        self.plot_vectors()
-+        self.plot_lines()
-+        self.plot_arcs()
-+        self.plot_front()
-+        self.plot_axes_labels()
-+        self.plot_annotations()
-+        # Trigger an update of the Bloch sphere if it is already shown:
-+        self.fig.canvas.draw()
-+
-+    def plot_back(self):
-+        # back half of sphere
-+        u = np.linspace(0, np.pi, 25)
-+        v = np.linspace(0, np.pi, 25)
-+        x = outer(cos(u), sin(v))
-+        y = outer(sin(u), sin(v))
-+        z = outer(ones(np.size(u)), cos(v))
-+        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
-+                               color=self.sphere_color, linewidth=0,
-+                               alpha=self.sphere_alpha)
-+        # wireframe
-+        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
-+                                 color=self.frame_color,
-+                                 alpha=self.frame_alpha)
-+        # equator
-+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
-+                       lw=self.frame_width, color=self.frame_color)
-+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
-+                       lw=self.frame_width, color=self.frame_color)
-+
-+    def plot_front(self):
-+        # front half of sphere
-+        u = np.linspace(-np.pi, 0, 25)
-+        v = np.linspace(0, np.pi, 25)
-+        x = outer(cos(u), sin(v))
-+        y = outer(sin(u), sin(v))
-+        z = outer(ones(np.size(u)), cos(v))
-+        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
-+                               color=self.sphere_color, linewidth=0,
-+                               alpha=self.sphere_alpha)
-+        # wireframe
-+        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
-+                                 color=self.frame_color,
-+                                 alpha=self.frame_alpha)
-+        # equator
-+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
-+                       zs=0, zdir='z', lw=self.frame_width,
-+                       color=self.frame_color)
-+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
-+                       zs=0, zdir='x', lw=self.frame_width,
-+                       color=self.frame_color)
-+
-+    def plot_axes(self):
-+        # axes
-+        span = np.linspace(-1.0, 1.0, 2)
-+        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
-+                       lw=self.frame_width, color=self.frame_color)
-+        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
-+                       lw=self.frame_width, color=self.frame_color)
-+        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
-+                       lw=self.frame_width, color=self.frame_color)
-+
-+    def plot_axes_labels(self):
-+        # axes labels
-+        opts = {'fontsize': self.font_size,
-+                'color': self.font_color,
-+                'horizontalalignment': 'center',
-+                'verticalalignment': 'center'}
-+        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
-+        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
-+
-+        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
-+        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
-+
-+        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
-+        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
-+
-+        for a in (self.axes.xaxis.get_ticklines() +
-+                  self.axes.xaxis.get_ticklabels()):
-+            a.set_visible(False)
-+        for a in (self.axes.yaxis.get_ticklines() +
-+                  self.axes.yaxis.get_ticklabels()):
-+            a.set_visible(False)
-+        for a in (self.axes.zaxis.get_ticklines() +
-+                  self.axes.zaxis.get_ticklabels()):
-+            a.set_visible(False)
-+
-+    def plot_vectors(self):
-+        # -X and Y data are switched for plotting purposes
-+        for k, vec in enumerate(self.vectors):
-+
-+            xs3d = vec[1] * np.array([0, 1])
-+            ys3d = -vec[0] * np.array([0, 1])
-+            zs3d = vec[2] * np.array([0, 1])
-+
-+            alpha = self.vector_alpha[k]
-+            color = self.vector_color[k]
-+            if color is None:
-+                idx = k % len(self.vector_default_color)
-+                color = self.vector_default_color[idx]
-+
-+            # decorated style, with arrow heads
-+            a = Arrow3D(xs3d, ys3d, zs3d,
-+                        mutation_scale=self.vector_mutation,
-+                        lw=self.vector_width,
-+                        arrowstyle=self.vector_style,
-+                        color=color, alpha=alpha)
-+
-+            self.axes.add_artist(a)
-+
-+    def plot_points(self):
-+        # -X and Y data are switched for plotting purposes
-+        for k, points in enumerate(self.points):
-+            points = np.asarray(points)
-+            num_points = points.shape[1]
-+
-+            dist = np.linalg.norm(points, axis=0)
-+            if not np.allclose(dist, dist[0], rtol=1e-12):
-+                indperm = np.argsort(dist)
-+                points = points[:, indperm]
-+            else:
-+                indperm = np.arange(num_points)
-+
-+            s = self.point_size[np.mod(k, len(self.point_size))]
-+            marker = self.point_marker[np.mod(k, len(self.point_marker))]
-+            style = self.point_style[k]
-+            if self.point_color[k] is not None:
-+                color = self.point_color[k]
-+            elif self.point_style[k] in ['s', 'l']:
-+                color = self.point_default_color[
-+                    k % len(self.point_default_color)
-+                ]
-+            elif self.point_style[k] == 'm':
-+                length = np.ceil(num_points/len(self.point_default_color))
-+                color = np.tile(self.point_default_color, length.astype(int))
-+                color = color[indperm]
-+
-+            if self.point_style[k] in ['s', 'm']:
-+                self.axes.scatter(np.real(points[1]),
-+                                  -np.real(points[0]),
-+                                  np.real(points[2]),
-+                                  s=s,
-+                                  marker=marker,
-+                                  color=color,
-+                                  alpha=self.point_alpha[k],
-+                                  edgecolor=None,
-+                                  zdir='z',
-+                                  )
-+
-+            elif self.point_style[k] == 'l':
-+                self.axes.plot(np.real(points[1]),
-+                               -np.real(points[0]),
-+                               np.real(points[2]),
-+                               color=color,
-+                               alpha=self.point_alpha[k],
-+                               zdir='z',
-+                               )
-+
-+    def plot_annotations(self):
-+        # -X and Y data are switched for plotting purposes
-+        for annotation in self.annotations:
-+            vec = annotation['position']
-+            opts = {'fontsize': self.font_size,
-+                    'color': self.font_color,
-+                    'horizontalalignment': 'center',
-+                    'verticalalignment': 'center'}
-+            opts.update(annotation['opts'])
-+            self.axes.text(vec[1], -vec[0], vec[2],
-+                           annotation['text'], **opts)
-+
-+    def plot_lines(self):
-+        for line, fmt, kw in self._lines:
-+            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
-+
-+    def plot_arcs(self):
-+        for arc, fmt, kw in self._arcs:
-+            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
-+
-+    def show(self):
-+        """
-+        Display Bloch sphere and corresponding data sets.
-+
-+        Notes
-+        -----
-+
-+        When using inline plotting in Jupyter notebooks, any figure created
-+        in a notebook cell is displayed after the cell executes. Thus if you
-+        create a figure yourself and use it create a Bloch sphere with
-+        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
-+        cell, then the figure will be displayed twice. If you do create your
-+        own figure, the simplest solution to this is to not call ``.show()``
-+        in the cell you create the figure in.
-+        """
-+        self.render()
-+        if self.run_from_ipython():
-+            display(self.fig)
-+        else:
-+            self.fig.show()
-+
-+    def save(self, name=None, format='png', dirc=None, dpin=None):
-+        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
-+
-+        Parameters
-+        ----------
-+
-+        name : str
-+            Name of saved image. Must include path and format as well.
-+            i.e. '/Users/Paul/Desktop/bloch.png'
-+            This overrides the 'format' and 'dirc' arguments.
-+        format : str
-+            Format of output image.
-+        dirc : str
-+            Directory for output images. Defaults to current working directory.
-+        dpin : int
-+            Resolution in dots per inch.
-+
-+        Returns
-+        -------
-+        File containing plot of Bloch sphere.
-+
-+        """
-+        self.render()
-+        # Conditional variable for first argument to savefig
-+        # that is set in subsequent if-elses
-+        complete_path = ""
-+        if dirc:
-+            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
-+                os.makedirs(os.getcwd() + "/" + str(dirc))
-+        if name is None:
-+            if dirc:
-+                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
-+                                + str(self.savenum) + '.' + format
-+            else:
-+                complete_path = os.getcwd() + '/bloch_' + \
-+                                str(self.savenum) + '.' + format
-+        else:
-+            complete_path = name
-+
-+        if dpin:
-+            self.fig.savefig(complete_path, dpi=dpin)
-+        else:
-+            self.fig.savefig(complete_path)
-+        self.savenum += 1
-+        if self.fig:
-+            plt.close(self.fig)
-+
-+
-+def _hide_tick_lines_and_labels(axis):
-+    '''
-+    Set visible property of ticklines and ticklabels of an axis to False
-+    '''
-+    for a in axis.get_ticklines() + axis.get_ticklabels():
-+        a.set_visible(False)
-diff --git a/qutip/bloch3d.py b/qutip/bloch3d.py
-index d387b6c4..748e5cf7 100644
---- a/qutip/bloch3d.py
-+++ b/qutip/bloch3d.py
-@@ -1,517 +1,517 @@
--__all__ = ['Bloch3d']
--
--import numpy as np
--from . import Qobj, expect, sigmax, sigmay, sigmaz
--
--
--class Bloch3d:
--    """Class for plotting data on a 3D Bloch sphere using mayavi.
--    Valid data can be either points, vectors, or qobj objects
--    corresponding to state vectors or density matrices. for
--    a two-state system (or subsystem).
--
--    Attributes
--    ----------
--    fig : instance {None}
--        User supplied Matplotlib Figure instance for plotting Bloch sphere.
--    font_color : str {'black'}
--        Color of font used for Bloch sphere labels.
--    font_scale : float {0.08}
--        Scale for font used for Bloch sphere labels.
--    frame : bool {True}
--        Draw frame for Bloch sphere
--    frame_alpha : float {0.05}
--        Sets transparency of Bloch sphere frame.
--    frame_color : str {'gray'}
--        Color of sphere wireframe.
--    frame_num : int {8}
--        Number of frame elements to draw.
--    frame_radius : floats {0.005}
--        Width of wireframe.
--    point_color : list {['r', 'g', 'b', 'y']}
--        List of colors for Bloch sphere point markers to cycle through.
--        i.e. By default, points 0 and 4 will both be blue ('r').
--    point_mode : string {'sphere','cone','cube','cylinder','point'}
--        Point marker shapes.
--    point_size : float {0.075}
--        Size of points on Bloch sphere.
--    sphere_alpha : float {0.1}
--        Transparency of Bloch sphere itself.
--    sphere_color : str {'#808080'}
--        Color of Bloch sphere.
--    size : list {[500,500]}
--        Size of Bloch sphere plot in pixels. Best to have both numbers the same
--        otherwise you will have a Bloch sphere that looks like a football.
--    vector_color : list {['r', 'g', 'b', 'y']}
--        List of vector colors to cycle through.
--    vector_width : int {3}
--        Width of displayed vectors.
--    view : list {[45,65]}
--        Azimuthal and Elevation viewing angles.
--    xlabel : list {``['|x>', '']``}
--        List of strings corresponding to +x and -x axes labels, respectively.
--    xlpos : list {[1.07,-1.07]}
--        Positions of +x and -x labels respectively.
--    ylabel : list {``['|y>', '']``}
--        List of strings corresponding to +y and -y axes labels, respectively.
--    ylpos : list {[1.07,-1.07]}
--        Positions of +y and -y labels respectively.
--    zlabel : list {``['|0>', '|1>']``}
--        List of strings corresponding to +z and -z axes labels, respectively.
--    zlpos : list {[1.07,-1.07]}
--        Positions of +z and -z labels respectively.
--
--    Notes
--    -----
--    The use of mayavi for 3D rendering of the Bloch sphere comes with
--    a few limitations: I) You can not embed a Bloch3d figure into a
--    matplotlib window. II) The use of LaTex is not supported by the
--    mayavi rendering engine. Therefore all labels must be defined using
--    standard text. Of course you can post-process the generated figures
--    later to add LaTeX using other software if needed.
--
--
--    """
--    def __init__(self, fig=None):
--        # ----check for mayavi-----
--        try:
--            from mayavi import mlab
--        except:
--            raise Exception("This function requires the mayavi module.")
--
--        # ---Image options---
--        self.fig = None
--        self.user_fig = None
--        # check if user specified figure or axes.
--        if fig:
--            self.user_fig = fig
--        # The size of the figure in inches, default = [500,500].
--        self.size = [500, 500]
--        # Azimuthal and Elvation viewing angles, default = [45,65].
--        self.view = [45, 65]
--        # Image background color
--        self.bgcolor = 'white'
--        # Image foreground color. Other options can override.
--        self.fgcolor = 'black'
--
--        # ---Sphere options---
--        # Color of Bloch sphere, default = #808080
--        self.sphere_color = '#808080'
--        # Transparency of Bloch sphere, default = 0.1
--        self.sphere_alpha = 0.1
--
--        # ---Frame options---
--        # Draw frame?
--        self.frame = True
--        # number of lines to draw for frame
--        self.frame_num = 8
--        # Color of wireframe, default = 'gray'
--        self.frame_color = 'black'
--        # Transparency of wireframe, default = 0.2
--        self.frame_alpha = 0.05
--        # Radius of frame lines
--        self.frame_radius = 0.005
--
--        # --Axes---
--        # Axes color
--        self.axes_color = 'black'
--        # Transparency of axes
--        self.axes_alpha = 0.4
--        # Radius of axes lines
--        self.axes_radius = 0.005
--
--        # ---Labels---
--        # Labels for x-axis (in LaTex), default = ['$x$','']
--        self.xlabel = ['|x>', '']
--        # Position of x-axis labels, default = [1.2,-1.2]
--        self.xlpos = [1.07, -1.07]
--        # Labels for y-axis (in LaTex), default = ['$y$','']
--        self.ylabel = ['|y>', '']
--        # Position of y-axis labels, default = [1.1,-1.1]
--        self.ylpos = [1.07, -1.07]
--        # Labels for z-axis
--        self.zlabel = ['|0>', '|1>']
--        # Position of z-axis labels, default = [1.05,-1.05]
--        self.zlpos = [1.07, -1.07]
--
--        # ---Font options---
--        # Color of fonts, default = 'black'
--        self.font_color = 'black'
--        # Size of fonts, default = 20
--        self.font_scale = 0.08
--
--        # ---Vector options---
--        # Object used for representing vectors on Bloch sphere.
--        # List of colors for Bloch vectors, default = ['b','g','r','y']
--        self.vector_color = ['r', 'g', 'b', 'y']
--        # Width of Bloch vectors, default = 2
--        self.vector_width = 2.0
--        # Height of vector head
--        self.vector_head_height = 0.15
--        # Radius of vector head
--        self.vector_head_radius = 0.075
--
--        # ---Point options---
--        # List of colors for Bloch point markers, default = ['b','g','r','y']
--        self.point_color = ['r', 'g', 'b', 'y']
--        # Size of point markers
--        self.point_size = 0.06
--        # Shape of point markers
--        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
--        # Default = 'sphere'
--        self.point_mode = 'sphere'
--
--        # ---Data lists---
--        # Data for point markers
--        self.points = []
--        # Data for Bloch vectors
--        self.vectors = []
--        # Number of times sphere has been saved
--        self.savenum = 0
--        # Style of points, 'm' for multiple colors, 's' for single color
--        self.point_style = []
--        # Transparency of points
--        self.point_alpha = []
--        # Transparency of vectors
--        self.vector_alpha = []
--
--    def __str__(self):
--        s = ""
--        s += "Bloch3D data:\n"
--        s += "-----------\n"
--        s += "Number of points:  " + str(len(self.points)) + "\n"
--        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
--        s += "\n"
--        s += "Bloch3D sphere properties:\n"
--        s += "--------------------------\n"
--        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
--        s += "axes_color:         " + str(self.axes_color) + "\n"
--        s += "axes_radius:        " + str(self.axes_radius) + "\n"
--        s += "bgcolor:            " + str(self.bgcolor) + "\n"
--        s += "fgcolor:            " + str(self.fgcolor) + "\n"
--        s += "font_color:         " + str(self.font_color) + "\n"
--        s += "font_scale:         " + str(self.font_scale) + "\n"
--        s += "frame:              " + str(self.frame) + "\n"
--        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
--        s += "frame_color:        " + str(self.frame_color) + "\n"
--        s += "frame_num:          " + str(self.frame_num) + "\n"
--        s += "frame_radius:       " + str(self.frame_radius) + "\n"
--        s += "point_color:        " + str(self.point_color) + "\n"
--        s += "point_mode:         " + str(self.point_mode) + "\n"
--        s += "point_size:         " + str(self.point_size) + "\n"
--        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
--        s += "sphere_color:       " + str(self.sphere_color) + "\n"
--        s += "size:               " + str(self.size) + "\n"
--        s += "vector_color:       " + str(self.vector_color) + "\n"
--        s += "vector_width:       " + str(self.vector_width) + "\n"
--        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
--        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
--        s += "view:               " + str(self.view) + "\n"
--        s += "xlabel:             " + str(self.xlabel) + "\n"
--        s += "xlpos:              " + str(self.xlpos) + "\n"
--        s += "ylabel:             " + str(self.ylabel) + "\n"
--        s += "ylpos:              " + str(self.ylpos) + "\n"
--        s += "zlabel:             " + str(self.zlabel) + "\n"
--        s += "zlpos:              " + str(self.zlpos) + "\n"
--        return s
--
--    def clear(self):
--        """Resets the Bloch sphere data sets to empty.
--        """
--        self.points = []
--        self.vectors = []
--        self.point_style = []
--
--    def add_points(self, points, meth='s', alpha=1.0):
--        """Add a list of data points to bloch sphere.
--
--        Parameters
--        ----------
--        points : array/list
--            Collection of data points.
--
--        meth : str {'s','m'}
--            Type of points to plot, use 'm' for multicolored.
--
--        alpha : float, default=1.
--            Transparency value for the vectors. Values between 0 and 1.
--
--        """
--        if not isinstance(points[0], (list, np.ndarray)):
--            points = [[points[0]], [points[1]], [points[2]]]
--        points = np.array(points)
--        if meth == 's':
--            if len(points[0]) == 1:
--                pnts = np.array(
--                    [[points[0][0]], [points[1][0]], [points[2][0]]])
--                pnts = np.append(pnts, points, axis=1)
--            else:
--                pnts = points
--            self.points.append(pnts)
--            self.point_style.append('s')
--        else:
--            self.points.append(points)
--            self.point_style.append('m')
--        self.point_alpha.append(alpha)
--
--    def add_states(self, state, kind='vector', alpha=1.0):
--        """Add a state vector Qobj to Bloch sphere.
--
--        Parameters
--        ----------
--        state : qobj
--            Input state vector.
--
--        kind : str {'vector','point'}
--            Type of object to plot.
--
--        alpha : float, default=1.
--            Transparency value for the vectors. Values between 0 and 1.
--        """
--        if isinstance(state, Qobj):
--            state = [state]
--        for st in state:
--            if kind == 'vector':
--                vec = [expect(sigmax(), st), expect(sigmay(), st),
--                       expect(sigmaz(), st)]
--                self.add_vectors(vec, alpha=alpha)
--            elif kind == 'point':
--                pnt = [expect(sigmax(), st), expect(sigmay(), st),
--                       expect(sigmaz(), st)]
--                self.add_points(pnt, alpha=alpha)
--
--    def add_vectors(self, vectors, alpha=1.0):
--        """Add a list of vectors to Bloch sphere.
--
--        Parameters
--        ----------
--        vectors : array/list
--            Array with vectors of unit length or smaller.
--
--        alpha : float, default=1.
--            Transparency value for the vectors. Values between 0 and 1.
--
--        """
--        if isinstance(vectors[0], (list, np.ndarray)):
--            for vec in vectors:
--                self.vectors.append(vec)
--                self.vector_alpha.append(alpha)
--        else:
--            self.vectors.append(vectors)
--            self.vector_alpha.append(alpha)
--
--    def plot_vectors(self):
--        """
--        Plots vectors on the Bloch sphere.
--        """
--        from mayavi import mlab
--        from tvtk.api import tvtk
--        import matplotlib.colors as colors
--        ii = 0
--        for k in range(len(self.vectors)):
--            vec = np.array(self.vectors[k])
--            norm = np.linalg.norm(vec)
--            theta = np.arccos(vec[2] / norm)
--            phi = np.arctan2(vec[1], vec[0])
--            vec -= 0.5 * self.vector_head_height * \
--                np.array([np.sin(theta) * np.cos(phi),
--                          np.sin(theta) * np.sin(phi), np.cos(theta)])
--
--            color = colors.colorConverter.to_rgb(
--                self.vector_color[np.mod(k, len(self.vector_color))])
--
--            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
--                        name='vector' + str(ii), tube_sides=100,
--                        line_width=self.vector_width,
--                        opacity=self.vector_alpha[k],
--                        color=color)
--
--            cone = tvtk.ConeSource(height=self.vector_head_height,
--                                   radius=self.vector_head_radius,
--                                   resolution=100)
--            cone_mapper = tvtk.PolyDataMapper(
--                input_connection=cone.output_port)
--            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
--            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
--            cc.rotate_z(np.degrees(phi))
--            cc.rotate_y(-90 + np.degrees(theta))
--            cc.position = vec
--            self.fig.scene.add_actor(cc)
--
--    def plot_points(self):
--        """
--        Plots points on the Bloch sphere.
--        """
--        from mayavi import mlab
--        import matplotlib.colors as colors
--        for k in range(len(self.points)):
--            num = len(self.points[k][0])
--            dist = [np.sqrt(self.points[k][0][j] ** 2 +
--                            self.points[k][1][j] ** 2 +
--                            self.points[k][2][j] ** 2) for j in range(num)]
--            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
--                # combine arrays so that they can be sorted together
--                # and sort rates from lowest to highest
--                zipped = sorted(zip(dist, range(num)))
--                dist, indperm = zip(*zipped)
--                indperm = np.array(indperm)
--            else:
--                indperm = range(num)
--            if self.point_style[k] == 's':
--                color = colors.colorConverter.to_rgb(
--                    self.point_color[np.mod(k, len(self.point_color))])
--                mlab.points3d(
--                    self.points[k][0][indperm], self.points[k][1][indperm],
--                    self.points[k][2][indperm], figure=self.fig,
--                    resolution=100, scale_factor=self.point_size,
--                    mode=self.point_mode, color=color,
--                    opacity=self.point_alpha[k])
--
--            elif self.point_style[k] == 'm':
--                pnt_colors = np.array(self.point_color * np.ceil(
--                    num / float(len(self.point_color))))
--                pnt_colors = pnt_colors[0:num]
--                pnt_colors = list(pnt_colors[indperm])
--                for kk in range(num):
--                    mlab.points3d(
--                        self.points[k][0][
--                            indperm[kk]], self.points[k][1][indperm[kk]],
--                        self.points[k][2][
--                            indperm[kk]], figure=self.fig, resolution=100,
--                        scale_factor=self.point_size, mode=self.point_mode,
--                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
--                        opacity=self.point_alpha[k])
--
--    def make_sphere(self):
--        """
--        Plots Bloch sphere and data sets.
--        """
--        # setup plot
--        # Figure instance for Bloch sphere plot
--        from mayavi import mlab
--        import matplotlib.colors as colors
--        if self.user_fig:
--            self.fig = self.user_fig
--        else:
--            self.fig = mlab.figure(
--                1, size=self.size,
--                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
--                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
--
--        sphere = mlab.points3d(
--            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
--            color=colors.colorConverter.to_rgb(self.sphere_color),
--            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
--
--        # Thse commands make the sphere look better
--        sphere.actor.property.specular = 0.45
--        sphere.actor.property.specular_power = 5
--        sphere.actor.property.backface_culling = True
--
--        # make frame for sphere surface
--        if self.frame:
--            theta = np.linspace(0, 2 * np.pi, 100)
--            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
--                xlat = np.cos(theta) * np.cos(angle)
--                ylat = np.sin(theta) * np.cos(angle)
--                zlat = np.ones_like(theta) * np.sin(angle)
--                xlon = np.sin(angle) * np.sin(theta)
--                ylon = np.cos(angle) * np.sin(theta)
--                zlon = np.cos(theta)
--                mlab.plot3d(
--                    xlat, ylat, zlat,
--                    color=colors.colorConverter.to_rgb(self.frame_color),
--                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
--                mlab.plot3d(
--                    xlon, ylon, zlon,
--                    color=colors.colorConverter.to_rgb(self.frame_color),
--                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
--
--        # add axes
--        axis = np.linspace(-1.0, 1.0, 10)
--        other = np.zeros_like(axis)
--        mlab.plot3d(
--            axis, other, other,
--            color=colors.colorConverter.to_rgb(self.axes_color),
--            tube_radius=self.axes_radius, opacity=self.axes_alpha)
--        mlab.plot3d(
--            other, axis, other,
--            color=colors.colorConverter.to_rgb(self.axes_color),
--            tube_radius=self.axes_radius, opacity=self.axes_alpha)
--        mlab.plot3d(
--            other, other, axis,
--            color=colors.colorConverter.to_rgb(self.axes_color),
--            tube_radius=self.axes_radius, opacity=self.axes_alpha)
--
--        # add data to sphere
--        self.plot_points()
--        self.plot_vectors()
--
--        # #add labels
--        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
--                    color=colors.colorConverter.to_rgb(self.font_color),
--                    scale=self.font_scale)
--        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
--                    color=colors.colorConverter.to_rgb(self.font_color),
--                    scale=self.font_scale)
--        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
--                    color=colors.colorConverter.to_rgb(self.font_color),
--                    scale=self.font_scale)
--        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
--                    color=colors.colorConverter.to_rgb(self.font_color),
--                    scale=self.font_scale)
--        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
--                    color=colors.colorConverter.to_rgb(self.font_color),
--                    scale=self.font_scale)
--        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
--                    color=colors.colorConverter.to_rgb(self.font_color),
--                    scale=self.font_scale)
--
--    def show(self):
--        """
--        Display the Bloch sphere and corresponding data sets.
--        """
--        from mayavi import mlab
--        self.make_sphere()
--        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
--        if self.fig:
--            mlab.show()
--
--    def save(self, name=None, format='png', dirc=None):
--        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
--
--        Parameters
--        ----------
--        name : str
--            Name of saved image. Must include path and format as well.
--            i.e. '/Users/Paul/Desktop/bloch.png'
--            This overrides the 'format' and 'dirc' arguments.
--        format : str
--            Format of output image. Default is 'png'.
--        dirc : str
--            Directory for output images. Defaults to current working directory.
--
--        Returns
--        -------
--        File containing plot of Bloch sphere.
--
--        """
--        from mayavi import mlab
--        import os
--        self.make_sphere()
--        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
--        if dirc:
--            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
--                os.makedirs(os.getcwd() + "/" + str(dirc))
--        if name is None:
--            if dirc:
--                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
--                             str(self.savenum) + '.' + format)
--            else:
--                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
--                             '.' + format)
--        else:
--            mlab.savefig(name)
--        self.savenum += 1
--        if self.fig:
--            mlab.close(self.fig)
-+__all__ = ['Bloch3d']
-+
-+import numpy as np
-+from . import Qobj, expect, sigmax, sigmay, sigmaz
-+
-+
-+class Bloch3d:
-+    """Class for plotting data on a 3D Bloch sphere using mayavi.
-+    Valid data can be either points, vectors, or qobj objects
-+    corresponding to state vectors or density matrices. for
-+    a two-state system (or subsystem).
-+
-+    Attributes
-+    ----------
-+    fig : instance {None}
-+        User supplied Matplotlib Figure instance for plotting Bloch sphere.
-+    font_color : str {'black'}
-+        Color of font used for Bloch sphere labels.
-+    font_scale : float {0.08}
-+        Scale for font used for Bloch sphere labels.
-+    frame : bool {True}
-+        Draw frame for Bloch sphere
-+    frame_alpha : float {0.05}
-+        Sets transparency of Bloch sphere frame.
-+    frame_color : str {'gray'}
-+        Color of sphere wireframe.
-+    frame_num : int {8}
-+        Number of frame elements to draw.
-+    frame_radius : floats {0.005}
-+        Width of wireframe.
-+    point_color : list {['r', 'g', 'b', 'y']}
-+        List of colors for Bloch sphere point markers to cycle through.
-+        i.e. By default, points 0 and 4 will both be blue ('r').
-+    point_mode : string {'sphere','cone','cube','cylinder','point'}
-+        Point marker shapes.
-+    point_size : float {0.075}
-+        Size of points on Bloch sphere.
-+    sphere_alpha : float {0.1}
-+        Transparency of Bloch sphere itself.
-+    sphere_color : str {'#808080'}
-+        Color of Bloch sphere.
-+    size : list {[500,500]}
-+        Size of Bloch sphere plot in pixels. Best to have both numbers the same
-+        otherwise you will have a Bloch sphere that looks like a football.
-+    vector_color : list {['r', 'g', 'b', 'y']}
-+        List of vector colors to cycle through.
-+    vector_width : int {3}
-+        Width of displayed vectors.
-+    view : list {[45,65]}
-+        Azimuthal and Elevation viewing angles.
-+    xlabel : list {``['|x>', '']``}
-+        List of strings corresponding to +x and -x axes labels, respectively.
-+    xlpos : list {[1.07,-1.07]}
-+        Positions of +x and -x labels respectively.
-+    ylabel : list {``['|y>', '']``}
-+        List of strings corresponding to +y and -y axes labels, respectively.
-+    ylpos : list {[1.07,-1.07]}
-+        Positions of +y and -y labels respectively.
-+    zlabel : list {``['|0>', '|1>']``}
-+        List of strings corresponding to +z and -z axes labels, respectively.
-+    zlpos : list {[1.07,-1.07]}
-+        Positions of +z and -z labels respectively.
-+
-+    Notes
-+    -----
-+    The use of mayavi for 3D rendering of the Bloch sphere comes with
-+    a few limitations: I) You can not embed a Bloch3d figure into a
-+    matplotlib window. II) The use of LaTex is not supported by the
-+    mayavi rendering engine. Therefore all labels must be defined using
-+    standard text. Of course you can post-process the generated figures
-+    later to add LaTeX using other software if needed.
-+
-+
-+    """
-+    def __init__(self, fig=None):
-+        # ----check for mayavi-----
-+        try:
-+            from mayavi import mlab
-+        except:
-+            raise Exception("This function requires the mayavi module.")
-+
-+        # ---Image options---
-+        self.fig = None
-+        self.user_fig = None
-+        # check if user specified figure or axes.
-+        if fig:
-+            self.user_fig = fig
-+        # The size of the figure in inches, default = [500,500].
-+        self.size = [500, 500]
-+        # Azimuthal and Elvation viewing angles, default = [45,65].
-+        self.view = [45, 65]
-+        # Image background color
-+        self.bgcolor = 'white'
-+        # Image foreground color. Other options can override.
-+        self.fgcolor = 'black'
-+
-+        # ---Sphere options---
-+        # Color of Bloch sphere, default = #808080
-+        self.sphere_color = '#808080'
-+        # Transparency of Bloch sphere, default = 0.1
-+        self.sphere_alpha = 0.1
-+
-+        # ---Frame options---
-+        # Draw frame?
-+        self.frame = True
-+        # number of lines to draw for frame
-+        self.frame_num = 8
-+        # Color of wireframe, default = 'gray'
-+        self.frame_color = 'black'
-+        # Transparency of wireframe, default = 0.2
-+        self.frame_alpha = 0.05
-+        # Radius of frame lines
-+        self.frame_radius = 0.005
-+
-+        # --Axes---
-+        # Axes color
-+        self.axes_color = 'black'
-+        # Transparency of axes
-+        self.axes_alpha = 0.4
-+        # Radius of axes lines
-+        self.axes_radius = 0.005
-+
-+        # ---Labels---
-+        # Labels for x-axis (in LaTex), default = ['$x$','']
-+        self.xlabel = ['|x>', '']
-+        # Position of x-axis labels, default = [1.2,-1.2]
-+        self.xlpos = [1.07, -1.07]
-+        # Labels for y-axis (in LaTex), default = ['$y$','']
-+        self.ylabel = ['|y>', '']
-+        # Position of y-axis labels, default = [1.1,-1.1]
-+        self.ylpos = [1.07, -1.07]
-+        # Labels for z-axis
-+        self.zlabel = ['|0>', '|1>']
-+        # Position of z-axis labels, default = [1.05,-1.05]
-+        self.zlpos = [1.07, -1.07]
-+
-+        # ---Font options---
-+        # Color of fonts, default = 'black'
-+        self.font_color = 'black'
-+        # Size of fonts, default = 20
-+        self.font_scale = 0.08
-+
-+        # ---Vector options---
-+        # Object used for representing vectors on Bloch sphere.
-+        # List of colors for Bloch vectors, default = ['b','g','r','y']
-+        self.vector_color = ['r', 'g', 'b', 'y']
-+        # Width of Bloch vectors, default = 2
-+        self.vector_width = 2.0
-+        # Height of vector head
-+        self.vector_head_height = 0.15
-+        # Radius of vector head
-+        self.vector_head_radius = 0.075
-+
-+        # ---Point options---
-+        # List of colors for Bloch point markers, default = ['b','g','r','y']
-+        self.point_color = ['r', 'g', 'b', 'y']
-+        # Size of point markers
-+        self.point_size = 0.06
-+        # Shape of point markers
-+        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
-+        # Default = 'sphere'
-+        self.point_mode = 'sphere'
-+
-+        # ---Data lists---
-+        # Data for point markers
-+        self.points = []
-+        # Data for Bloch vectors
-+        self.vectors = []
-+        # Number of times sphere has been saved
-+        self.savenum = 0
-+        # Style of points, 'm' for multiple colors, 's' for single color
-+        self.point_style = []
-+        # Transparency of points
-+        self.point_alpha = []
-+        # Transparency of vectors
-+        self.vector_alpha = []
-+
-+    def __str__(self):
-+        s = ""
-+        s += "Bloch3D data:\n"
-+        s += "-----------\n"
-+        s += "Number of points:  " + str(len(self.points)) + "\n"
-+        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
-+        s += "\n"
-+        s += "Bloch3D sphere properties:\n"
-+        s += "--------------------------\n"
-+        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
-+        s += "axes_color:         " + str(self.axes_color) + "\n"
-+        s += "axes_radius:        " + str(self.axes_radius) + "\n"
-+        s += "bgcolor:            " + str(self.bgcolor) + "\n"
-+        s += "fgcolor:            " + str(self.fgcolor) + "\n"
-+        s += "font_color:         " + str(self.font_color) + "\n"
-+        s += "font_scale:         " + str(self.font_scale) + "\n"
-+        s += "frame:              " + str(self.frame) + "\n"
-+        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
-+        s += "frame_color:        " + str(self.frame_color) + "\n"
-+        s += "frame_num:          " + str(self.frame_num) + "\n"
-+        s += "frame_radius:       " + str(self.frame_radius) + "\n"
-+        s += "point_color:        " + str(self.point_color) + "\n"
-+        s += "point_mode:         " + str(self.point_mode) + "\n"
-+        s += "point_size:         " + str(self.point_size) + "\n"
-+        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
-+        s += "sphere_color:       " + str(self.sphere_color) + "\n"
-+        s += "size:               " + str(self.size) + "\n"
-+        s += "vector_color:       " + str(self.vector_color) + "\n"
-+        s += "vector_width:       " + str(self.vector_width) + "\n"
-+        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
-+        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
-+        s += "view:               " + str(self.view) + "\n"
-+        s += "xlabel:             " + str(self.xlabel) + "\n"
-+        s += "xlpos:              " + str(self.xlpos) + "\n"
-+        s += "ylabel:             " + str(self.ylabel) + "\n"
-+        s += "ylpos:              " + str(self.ylpos) + "\n"
-+        s += "zlabel:             " + str(self.zlabel) + "\n"
-+        s += "zlpos:              " + str(self.zlpos) + "\n"
-+        return s
-+
-+    def clear(self):
-+        """Resets the Bloch sphere data sets to empty.
-+        """
-+        self.points = []
-+        self.vectors = []
-+        self.point_style = []
-+
-+    def add_points(self, points, meth='s', alpha=1.0):
-+        """Add a list of data points to bloch sphere.
-+
-+        Parameters
-+        ----------
-+        points : array/list
-+            Collection of data points.
-+
-+        meth : str {'s','m'}
-+            Type of points to plot, use 'm' for multicolored.
-+
-+        alpha : float, default=1.
-+            Transparency value for the vectors. Values between 0 and 1.
-+
-+        """
-+        if not isinstance(points[0], (list, np.ndarray)):
-+            points = [[points[0]], [points[1]], [points[2]]]
-+        points = np.array(points)
-+        if meth == 's':
-+            if len(points[0]) == 1:
-+                pnts = np.array(
-+                    [[points[0][0]], [points[1][0]], [points[2][0]]])
-+                pnts = np.append(pnts, points, axis=1)
-+            else:
-+                pnts = points
-+            self.points.append(pnts)
-+            self.point_style.append('s')
-+        else:
-+            self.points.append(points)
-+            self.point_style.append('m')
-+        self.point_alpha.append(alpha)
-+
-+    def add_states(self, state, kind='vector', alpha=1.0):
-+        """Add a state vector Qobj to Bloch sphere.
-+
-+        Parameters
-+        ----------
-+        state : qobj
-+            Input state vector.
-+
-+        kind : str {'vector','point'}
-+            Type of object to plot.
-+
-+        alpha : float, default=1.
-+            Transparency value for the vectors. Values between 0 and 1.
-+        """
-+        if isinstance(state, Qobj):
-+            state = [state]
-+        for st in state:
-+            if kind == 'vector':
-+                vec = [expect(sigmax(), st), expect(sigmay(), st),
-+                       expect(sigmaz(), st)]
-+                self.add_vectors(vec, alpha=alpha)
-+            elif kind == 'point':
-+                pnt = [expect(sigmax(), st), expect(sigmay(), st),
-+                       expect(sigmaz(), st)]
-+                self.add_points(pnt, alpha=alpha)
-+
-+    def add_vectors(self, vectors, alpha=1.0):
-+        """Add a list of vectors to Bloch sphere.
-+
-+        Parameters
-+        ----------
-+        vectors : array/list
-+            Array with vectors of unit length or smaller.
-+
-+        alpha : float, default=1.
-+            Transparency value for the vectors. Values between 0 and 1.
-+
-+        """
-+        if isinstance(vectors[0], (list, np.ndarray)):
-+            for vec in vectors:
-+                self.vectors.append(vec)
-+                self.vector_alpha.append(alpha)
-+        else:
-+            self.vectors.append(vectors)
-+            self.vector_alpha.append(alpha)
-+
-+    def plot_vectors(self):
-+        """
-+        Plots vectors on the Bloch sphere.
-+        """
-+        from mayavi import mlab
-+        from tvtk.api import tvtk
-+        import matplotlib.colors as colors
-+        ii = 0
-+        for k in range(len(self.vectors)):
-+            vec = np.array(self.vectors[k])
-+            norm = np.linalg.norm(vec)
-+            theta = np.arccos(vec[2] / norm)
-+            phi = np.arctan2(vec[1], vec[0])
-+            vec -= 0.5 * self.vector_head_height * \
-+                np.array([np.sin(theta) * np.cos(phi),
-+                          np.sin(theta) * np.sin(phi), np.cos(theta)])
-+
-+            color = colors.colorConverter.to_rgb(
-+                self.vector_color[np.mod(k, len(self.vector_color))])
-+
-+            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
-+                        name='vector' + str(ii), tube_sides=100,
-+                        line_width=self.vector_width,
-+                        opacity=self.vector_alpha[k],
-+                        color=color)
-+
-+            cone = tvtk.ConeSource(height=self.vector_head_height,
-+                                   radius=self.vector_head_radius,
-+                                   resolution=100)
-+            cone_mapper = tvtk.PolyDataMapper(
-+                input_connection=cone.output_port)
-+            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
-+            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
-+            cc.rotate_z(np.degrees(phi))
-+            cc.rotate_y(-90 + np.degrees(theta))
-+            cc.position = vec
-+            self.fig.scene.add_actor(cc)
-+
-+    def plot_points(self):
-+        """
-+        Plots points on the Bloch sphere.
-+        """
-+        from mayavi import mlab
-+        import matplotlib.colors as colors
-+        for k in range(len(self.points)):
-+            num = len(self.points[k][0])
-+            dist = [np.sqrt(self.points[k][0][j] ** 2 +
-+                            self.points[k][1][j] ** 2 +
-+                            self.points[k][2][j] ** 2) for j in range(num)]
-+            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
-+                # combine arrays so that they can be sorted together
-+                # and sort rates from lowest to highest
-+                zipped = sorted(zip(dist, range(num)))
-+                dist, indperm = zip(*zipped)
-+                indperm = np.array(indperm)
-+            else:
-+                indperm = range(num)
-+            if self.point_style[k] == 's':
-+                color = colors.colorConverter.to_rgb(
-+                    self.point_color[np.mod(k, len(self.point_color))])
-+                mlab.points3d(
-+                    self.points[k][0][indperm], self.points[k][1][indperm],
-+                    self.points[k][2][indperm], figure=self.fig,
-+                    resolution=100, scale_factor=self.point_size,
-+                    mode=self.point_mode, color=color,
-+                    opacity=self.point_alpha[k])
-+
-+            elif self.point_style[k] == 'm':
-+                pnt_colors = np.array(self.point_color * np.ceil(
-+                    num / float(len(self.point_color))))
-+                pnt_colors = pnt_colors[0:num]
-+                pnt_colors = list(pnt_colors[indperm])
-+                for kk in range(num):
-+                    mlab.points3d(
-+                        self.points[k][0][
-+                            indperm[kk]], self.points[k][1][indperm[kk]],
-+                        self.points[k][2][
-+                            indperm[kk]], figure=self.fig, resolution=100,
-+                        scale_factor=self.point_size, mode=self.point_mode,
-+                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
-+                        opacity=self.point_alpha[k])
-+
-+    def make_sphere(self):
-+        """
-+        Plots Bloch sphere and data sets.
-+        """
-+        # setup plot
-+        # Figure instance for Bloch sphere plot
-+        from mayavi import mlab
-+        import matplotlib.colors as colors
-+        if self.user_fig:
-+            self.fig = self.user_fig
-+        else:
-+            self.fig = mlab.figure(
-+                1, size=self.size,
-+                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
-+                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
-+
-+        sphere = mlab.points3d(
-+            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
-+            color=colors.colorConverter.to_rgb(self.sphere_color),
-+            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
-+
-+        # Thse commands make the sphere look better
-+        sphere.actor.property.specular = 0.45
-+        sphere.actor.property.specular_power = 5
-+        sphere.actor.property.backface_culling = True
-+
-+        # make frame for sphere surface
-+        if self.frame:
-+            theta = np.linspace(0, 2 * np.pi, 100)
-+            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
-+                xlat = np.cos(theta) * np.cos(angle)
-+                ylat = np.sin(theta) * np.cos(angle)
-+                zlat = np.ones_like(theta) * np.sin(angle)
-+                xlon = np.sin(angle) * np.sin(theta)
-+                ylon = np.cos(angle) * np.sin(theta)
-+                zlon = np.cos(theta)
-+                mlab.plot3d(
-+                    xlat, ylat, zlat,
-+                    color=colors.colorConverter.to_rgb(self.frame_color),
-+                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
-+                mlab.plot3d(
-+                    xlon, ylon, zlon,
-+                    color=colors.colorConverter.to_rgb(self.frame_color),
-+                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
-+
-+        # add axes
-+        axis = np.linspace(-1.0, 1.0, 10)
-+        other = np.zeros_like(axis)
-+        mlab.plot3d(
-+            axis, other, other,
-+            color=colors.colorConverter.to_rgb(self.axes_color),
-+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-+        mlab.plot3d(
-+            other, axis, other,
-+            color=colors.colorConverter.to_rgb(self.axes_color),
-+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-+        mlab.plot3d(
-+            other, other, axis,
-+            color=colors.colorConverter.to_rgb(self.axes_color),
-+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-+
-+        # add data to sphere
-+        self.plot_points()
-+        self.plot_vectors()
-+
-+        # #add labels
-+        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
-+                    color=colors.colorConverter.to_rgb(self.font_color),
-+                    scale=self.font_scale)
-+        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
-+                    color=colors.colorConverter.to_rgb(self.font_color),
-+                    scale=self.font_scale)
-+        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
-+                    color=colors.colorConverter.to_rgb(self.font_color),
-+                    scale=self.font_scale)
-+        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
-+                    color=colors.colorConverter.to_rgb(self.font_color),
-+                    scale=self.font_scale)
-+        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
-+                    color=colors.colorConverter.to_rgb(self.font_color),
-+                    scale=self.font_scale)
-+        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
-+                    color=colors.colorConverter.to_rgb(self.font_color),
-+                    scale=self.font_scale)
-+
-+    def show(self):
-+        """
-+        Display the Bloch sphere and corresponding data sets.
-+        """
-+        from mayavi import mlab
-+        self.make_sphere()
-+        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
-+        if self.fig:
-+            mlab.show()
-+
-+    def save(self, name=None, format='png', dirc=None):
-+        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
-+
-+        Parameters
-+        ----------
-+        name : str
-+            Name of saved image. Must include path and format as well.
-+            i.e. '/Users/Paul/Desktop/bloch.png'
-+            This overrides the 'format' and 'dirc' arguments.
-+        format : str
-+            Format of output image. Default is 'png'.
-+        dirc : str
-+            Directory for output images. Defaults to current working directory.
-+
-+        Returns
-+        -------
-+        File containing plot of Bloch sphere.
-+
-+        """
-+        from mayavi import mlab
-+        import os
-+        self.make_sphere()
-+        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
-+        if dirc:
-+            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
-+                os.makedirs(os.getcwd() + "/" + str(dirc))
-+        if name is None:
-+            if dirc:
-+                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
-+                             str(self.savenum) + '.' + format)
-+            else:
-+                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
-+                             '.' + format)
-+        else:
-+            mlab.savefig(name)
-+        self.savenum += 1
-+        if self.fig:
-+            mlab.close(self.fig)
-diff --git a/qutip/cite.py b/qutip/cite.py
-index e3efb3e1..124b1197 100644
---- a/qutip/cite.py
-+++ b/qutip/cite.py
-@@ -1,60 +1,60 @@
--"""
--Citation generator for QuTiP
--"""
--import os
--
--__all__ = ['cite']
--
--
--def cite(save=False, path=None):
--    """
--    Citation information and bibtex generator for QuTiP
--
--    Parameters
--    ----------
--    save: bool
--        The flag specifying whether to save the .bib file.
--
--    path: str
--        The complete directory path to generate the bibtex file.
--        If not specified then the citation will be generated in cwd
--    """
--    citation = ["@article{qutip2,",
--                "doi = {10.1016/j.cpc.2012.11.019},",
--                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
--                "year  = {2013},",
--                "month = {apr},",
--                "publisher = {Elsevier {BV}},",
--                "volume = {184},",
--                "number = {4},",
--                "pages = {1234--1240},",
--                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
--                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
--                "journal = {Computer Physics Communications}",
--                "}",
--                "@article{qutip1,",
--                "doi = {10.1016/j.cpc.2012.02.021},",
--                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
--                "year  = {2012},",
--                "month = {aug},",
--                "publisher = {Elsevier {BV}},",
--                "volume = {183},",
--                "number = {8},",
--                "pages = {1760--1772},",
--                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
--                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
--                "journal = {Computer Physics Communications}",
--                "}"]
--    print("\n".join(citation))
--
--    if not path:
--        path = os.getcwd()
--
--    if save:
--        filename = "qutip.bib"
--        with open(os.path.join(path, filename), 'w') as f:
--            f.write("\n".join(citation))
--
--
--if __name__ == "__main__":
--    cite()
-+"""
-+Citation generator for QuTiP
-+"""
-+import os
-+
-+__all__ = ['cite']
-+
-+
-+def cite(save=False, path=None):
-+    """
-+    Citation information and bibtex generator for QuTiP
-+
-+    Parameters
-+    ----------
-+    save: bool
-+        The flag specifying whether to save the .bib file.
-+
-+    path: str
-+        The complete directory path to generate the bibtex file.
-+        If not specified then the citation will be generated in cwd
-+    """
-+    citation = ["@article{qutip2,",
-+                "doi = {10.1016/j.cpc.2012.11.019},",
-+                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
-+                "year  = {2013},",
-+                "month = {apr},",
-+                "publisher = {Elsevier {BV}},",
-+                "volume = {184},",
-+                "number = {4},",
-+                "pages = {1234--1240},",
-+                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
-+                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
-+                "journal = {Computer Physics Communications}",
-+                "}",
-+                "@article{qutip1,",
-+                "doi = {10.1016/j.cpc.2012.02.021},",
-+                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
-+                "year  = {2012},",
-+                "month = {aug},",
-+                "publisher = {Elsevier {BV}},",
-+                "volume = {183},",
-+                "number = {8},",
-+                "pages = {1760--1772},",
-+                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
-+                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
-+                "journal = {Computer Physics Communications}",
-+                "}"]
-+    print("\n".join(citation))
-+
-+    if not path:
-+        path = os.getcwd()
-+
-+    if save:
-+        filename = "qutip.bib"
-+        with open(os.path.join(path, filename), 'w') as f:
-+            f.write("\n".join(citation))
-+
-+
-+if __name__ == "__main__":
-+    cite()
-diff --git a/qutip/continuous_variables.py b/qutip/continuous_variables.py
-index 519f070f..004b5b36 100644
---- a/qutip/continuous_variables.py
-+++ b/qutip/continuous_variables.py
-@@ -1,259 +1,259 @@
--"""
--This module contains a collection functions for calculating continuous variable
--quantities from fock-basis representation of the state of multi-mode fields.
--"""
--
--__all__ = ['correlation_matrix', 'covariance_matrix',
--           'correlation_matrix_field', 'correlation_matrix_quadrature',
--           'wigner_covariance_matrix', 'logarithmic_negativity']
--
--from . import expect
--import numpy as np
--
--
--def correlation_matrix(basis, rho=None):
--    r"""
--    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
--    matrix:
--
--    .. math::
--
--        C_{mn} = \langle a_m a_n \rangle
--
--    Parameters
--    ----------
--    basis : list
--        List of operators that defines the basis for the correlation matrix.
--    rho : Qobj
--        Density matrix for which to calculate the correlation matrix. If
--        `rho` is `None`, then a matrix of correlation matrix operators is
--        returned instead of expectation values of those operators.
--
--    Returns
--    -------
--    corr_mat : ndarray
--        A 2-dimensional *array* of correlation values or operators.
--
--
--    """
--    if rho is None:
--        # return array of operators
--        out = np.empty((len(basis), len(basis)), dtype=object)
--        for i, op2 in enumerate(basis):
--            out[i, :] = [op1 * op2 for op1 in basis]
--        return out
--    else:
--        # return array of expectation values
--        return np.array([[expect(op1 * op2, rho)
--                          for op1 in basis] for op2 in basis])
--
--
--def covariance_matrix(basis, rho, symmetrized=True):
--    r"""
--    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
--    matrix:
--
--    .. math::
--
--        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
--        \langle a_m \rangle \langle a_n\rangle
--
--    or, if of the optional argument `symmetrized=False`,
--
--    .. math::
--
--        V_{mn} = \langle a_m a_n\rangle -
--        \langle a_m \rangle \langle a_n\rangle
--
--    Parameters
--    ----------
--    basis : list
--        List of operators that defines the basis for the covariance matrix.
--    rho : Qobj
--        Density matrix for which to calculate the covariance matrix.
--    symmetrized : bool {True, False}
--        Flag indicating whether the symmetrized (default) or non-symmetrized
--        correlation matrix is to be calculated.
--
--    Returns
--    -------
--    corr_mat : ndarray
--        A 2-dimensional array of covariance values.
--
--    """
--    if symmetrized:
--        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
--                          expect(op1, rho) * expect(op2, rho)
--                          for op1 in basis] for op2 in basis])
--    else:
--        return np.array([[expect(op1 * op2, rho) -
--                          expect(op1, rho) * expect(op2, rho)
--                          for op1 in basis] for op2 in basis])
--
--
--def correlation_matrix_field(a1, a2, rho=None):
--    """
--    Calculates the correlation matrix for given field operators :math:`a_1` and
--    :math:`a_2`. If a density matrix is given the expectation values are
--    calculated, otherwise a matrix with operators is returned.
--
--    Parameters
--    ----------
--    a1 : Qobj
--        Field operator for mode 1.
--    a2 : Qobj
--        Field operator for mode 2.
--    rho : Qobj
--        Density matrix for which to calculate the covariance matrix.
--
--    Returns
--    -------
--    cov_mat : ndarray 
--        Array of complex numbers or Qobj's
--        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
--        of operators.
--    """
--    basis = [a1, a1.dag(), a2, a2.dag()]
--    return correlation_matrix(basis, rho)
--
--
--def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
--    """
--    Calculate the quadrature correlation matrix with given field operators
--    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
--    values are calculated, otherwise a matrix with operators is returned.
--
--    Parameters
--    ----------
--    a1 : Qobj
--        Field operator for mode 1.
--    a2 : Qobj
--        Field operator for mode 2.
--    rho : Qobj
--        Density matrix for which to calculate the covariance matrix.
--    g : float
--        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
--        The value of `g` is related to the value of `hbar` in the commutation 
--        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
--        value `hbar=1`. 
--
--    Returns
--    -------
--    corr_mat : ndarray 
--        Array of complex numbers or Qobj's
--        A 2-dimensional *array* of covariance values for the field quadratures,
--        or, if rho=0, a matrix of operators.
--
--    """
--    x1 = (a1 + a1.dag()) / g
--    p1 = -1j * (a1 - a1.dag()) / g
--    x2 = (a2 + a2.dag()) / g
--    p2 = -1j * (a2 - a2.dag()) / g
--    basis = [x1, p1, x2, p2]
--    return correlation_matrix(basis, rho)
--
--
--def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
--    r"""
--    Calculates the Wigner covariance matrix
--    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
--    the quadrature correlation matrix
--    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
--    \langle R_{i}\rangle \langle R_{j}\rangle`, where
--    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
--    for the two modes.
--
--    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
--    for the two modes are supplied instead, the quadrature correlation matrix
--    is constructed from the annihilation operators before then the covariance
--    matrix is calculated.
--
--    Parameters
--    ----------
--
--    a1 : Qobj
--        Field operator for mode 1.
--
--    a2 : Qobj
--        Field operator for mode 2.
--
--    R : ndarray
--        The quadrature correlation matrix.
--
--    rho : Qobj
--        Density matrix for which to calculate the covariance matrix.
--
--    g : float
--        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
--        The value of `g` is related to the value of `hbar` in the commutation 
--        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
--        value `hbar=1`. 
--
--    Returns
--    -------
--    cov_mat : ndarray
--        A 2-dimensional array of covariance values.
--
--    """
--    if R is not None:
--        if rho is None:
--            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
--                              for i in range(4)]
--                             for j in range(4)], dtype=np.float64)
--        else:
--            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
--                              for i in range(4)]
--                             for j in range(4)], dtype=np.float64)
--    elif a1 is not None and a2 is not None:
--        if rho is not None:
--            x1 = (a1 + a1.dag()) / g
--            p1 = -1j * (a1 - a1.dag()) / g
--            x2 = (a2 + a2.dag()) / g
--            p2 = -1j * (a2 - a2.dag()) / g
--            return covariance_matrix([x1, p1, x2, p2], rho)
--        else:
--            raise ValueError("Must give rho if using field operators " +
--                             "(a1 and a2)")
--    else:
--        raise ValueError("Must give either field operators (a1 and a2) " +
--                         "or a precomputed correlation matrix (R)")
--
--
--def logarithmic_negativity(V, g=np.sqrt(2)):
--    """
--    Calculates the logarithmic negativity given a symmetrized covariance
--    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
--    the two-mode field state that is described by `V` must be Gaussian for this
--    function to applicable.
--
--    Parameters
--    ----------
--
--    V : *2d array*
--        The covariance matrix.
--
--    g : float
--        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
--        The value of `g` is related to the value of `hbar` in the commutation 
--        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
--        value `hbar=1`. 
--
--    Returns
--    -------
--
--    N : float 
--        The logarithmic negativity for the two-mode Gaussian state
--        that is described by the the Wigner covariance matrix V.
--
--    """
--    A = 0.5 * V[0:2, 0:2] * g ** 2
--    B = 0.5 * V[2:4, 2:4] * g ** 2
--    C = 0.5 * V[0:2, 2:4] * g ** 2
--    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
--    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
--    if nu_ < 0.0:
--        return 0.0
--    nu = np.sqrt(nu_)
--    lognu = -np.log(2 * nu)
--    logneg = max(0, lognu)
--    return logneg
-+"""
-+This module contains a collection functions for calculating continuous variable
-+quantities from fock-basis representation of the state of multi-mode fields.
-+"""
-+
-+__all__ = ['correlation_matrix', 'covariance_matrix',
-+           'correlation_matrix_field', 'correlation_matrix_quadrature',
-+           'wigner_covariance_matrix', 'logarithmic_negativity']
-+
-+from . import expect
-+import numpy as np
-+
-+
-+def correlation_matrix(basis, rho=None):
-+    r"""
-+    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
-+    matrix:
-+
-+    .. math::
-+
-+        C_{mn} = \langle a_m a_n \rangle
-+
-+    Parameters
-+    ----------
-+    basis : list
-+        List of operators that defines the basis for the correlation matrix.
-+    rho : Qobj
-+        Density matrix for which to calculate the correlation matrix. If
-+        `rho` is `None`, then a matrix of correlation matrix operators is
-+        returned instead of expectation values of those operators.
-+
-+    Returns
-+    -------
-+    corr_mat : ndarray
-+        A 2-dimensional *array* of correlation values or operators.
-+
-+
-+    """
-+    if rho is None:
-+        # return array of operators
-+        out = np.empty((len(basis), len(basis)), dtype=object)
-+        for i, op2 in enumerate(basis):
-+            out[i, :] = [op1 * op2 for op1 in basis]
-+        return out
-+    else:
-+        # return array of expectation values
-+        return np.array([[expect(op1 * op2, rho)
-+                          for op1 in basis] for op2 in basis])
-+
-+
-+def covariance_matrix(basis, rho, symmetrized=True):
-+    r"""
-+    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
-+    matrix:
-+
-+    .. math::
-+
-+        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
-+        \langle a_m \rangle \langle a_n\rangle
-+
-+    or, if of the optional argument `symmetrized=False`,
-+
-+    .. math::
-+
-+        V_{mn} = \langle a_m a_n\rangle -
-+        \langle a_m \rangle \langle a_n\rangle
-+
-+    Parameters
-+    ----------
-+    basis : list
-+        List of operators that defines the basis for the covariance matrix.
-+    rho : Qobj
-+        Density matrix for which to calculate the covariance matrix.
-+    symmetrized : bool {True, False}
-+        Flag indicating whether the symmetrized (default) or non-symmetrized
-+        correlation matrix is to be calculated.
-+
-+    Returns
-+    -------
-+    corr_mat : ndarray
-+        A 2-dimensional array of covariance values.
-+
-+    """
-+    if symmetrized:
-+        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
-+                          expect(op1, rho) * expect(op2, rho)
-+                          for op1 in basis] for op2 in basis])
-+    else:
-+        return np.array([[expect(op1 * op2, rho) -
-+                          expect(op1, rho) * expect(op2, rho)
-+                          for op1 in basis] for op2 in basis])
-+
-+
-+def correlation_matrix_field(a1, a2, rho=None):
-+    """
-+    Calculates the correlation matrix for given field operators :math:`a_1` and
-+    :math:`a_2`. If a density matrix is given the expectation values are
-+    calculated, otherwise a matrix with operators is returned.
-+
-+    Parameters
-+    ----------
-+    a1 : Qobj
-+        Field operator for mode 1.
-+    a2 : Qobj
-+        Field operator for mode 2.
-+    rho : Qobj
-+        Density matrix for which to calculate the covariance matrix.
-+
-+    Returns
-+    -------
-+    cov_mat : ndarray 
-+        Array of complex numbers or Qobj's
-+        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
-+        of operators.
-+    """
-+    basis = [a1, a1.dag(), a2, a2.dag()]
-+    return correlation_matrix(basis, rho)
-+
-+
-+def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
-+    """
-+    Calculate the quadrature correlation matrix with given field operators
-+    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
-+    values are calculated, otherwise a matrix with operators is returned.
-+
-+    Parameters
-+    ----------
-+    a1 : Qobj
-+        Field operator for mode 1.
-+    a2 : Qobj
-+        Field operator for mode 2.
-+    rho : Qobj
-+        Density matrix for which to calculate the covariance matrix.
-+    g : float
-+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-+        The value of `g` is related to the value of `hbar` in the commutation 
-+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
-+        value `hbar=1`. 
-+
-+    Returns
-+    -------
-+    corr_mat : ndarray 
-+        Array of complex numbers or Qobj's
-+        A 2-dimensional *array* of covariance values for the field quadratures,
-+        or, if rho=0, a matrix of operators.
-+
-+    """
-+    x1 = (a1 + a1.dag()) / g
-+    p1 = -1j * (a1 - a1.dag()) / g
-+    x2 = (a2 + a2.dag()) / g
-+    p2 = -1j * (a2 - a2.dag()) / g
-+    basis = [x1, p1, x2, p2]
-+    return correlation_matrix(basis, rho)
-+
-+
-+def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
-+    r"""
-+    Calculates the Wigner covariance matrix
-+    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
-+    the quadrature correlation matrix
-+    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
-+    \langle R_{i}\rangle \langle R_{j}\rangle`, where
-+    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
-+    for the two modes.
-+
-+    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
-+    for the two modes are supplied instead, the quadrature correlation matrix
-+    is constructed from the annihilation operators before then the covariance
-+    matrix is calculated.
-+
-+    Parameters
-+    ----------
-+
-+    a1 : Qobj
-+        Field operator for mode 1.
-+
-+    a2 : Qobj
-+        Field operator for mode 2.
-+
-+    R : ndarray
-+        The quadrature correlation matrix.
-+
-+    rho : Qobj
-+        Density matrix for which to calculate the covariance matrix.
-+
-+    g : float
-+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-+        The value of `g` is related to the value of `hbar` in the commutation 
-+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
-+        value `hbar=1`. 
-+
-+    Returns
-+    -------
-+    cov_mat : ndarray
-+        A 2-dimensional array of covariance values.
-+
-+    """
-+    if R is not None:
-+        if rho is None:
-+            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
-+                              for i in range(4)]
-+                             for j in range(4)], dtype=np.float64)
-+        else:
-+            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
-+                              for i in range(4)]
-+                             for j in range(4)], dtype=np.float64)
-+    elif a1 is not None and a2 is not None:
-+        if rho is not None:
-+            x1 = (a1 + a1.dag()) / g
-+            p1 = -1j * (a1 - a1.dag()) / g
-+            x2 = (a2 + a2.dag()) / g
-+            p2 = -1j * (a2 - a2.dag()) / g
-+            return covariance_matrix([x1, p1, x2, p2], rho)
-+        else:
-+            raise ValueError("Must give rho if using field operators " +
-+                             "(a1 and a2)")
-+    else:
-+        raise ValueError("Must give either field operators (a1 and a2) " +
-+                         "or a precomputed correlation matrix (R)")
-+
-+
-+def logarithmic_negativity(V, g=np.sqrt(2)):
-+    """
-+    Calculates the logarithmic negativity given a symmetrized covariance
-+    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
-+    the two-mode field state that is described by `V` must be Gaussian for this
-+    function to applicable.
-+
-+    Parameters
-+    ----------
-+
-+    V : *2d array*
-+        The covariance matrix.
-+
-+    g : float
-+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-+        The value of `g` is related to the value of `hbar` in the commutation 
-+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
-+        value `hbar=1`. 
-+
-+    Returns
-+    -------
-+
-+    N : float 
-+        The logarithmic negativity for the two-mode Gaussian state
-+        that is described by the the Wigner covariance matrix V.
-+
-+    """
-+    A = 0.5 * V[0:2, 0:2] * g ** 2
-+    B = 0.5 * V[2:4, 2:4] * g ** 2
-+    C = 0.5 * V[0:2, 2:4] * g ** 2
-+    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
-+    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
-+    if nu_ < 0.0:
-+        return 0.0
-+    nu = np.sqrt(nu_)
-+    lognu = -np.log(2 * nu)
-+    logneg = max(0, lognu)
-+    return logneg
-diff --git a/qutip/control.py b/qutip/control.py
-index 559a6a8d..7b3fb74f 100644
---- a/qutip/control.py
-+++ b/qutip/control.py
-@@ -1,13 +1,13 @@
--"""Module replicating the qutip_qtrl package from within qutip."""
--import sys
--
--try:
--    import qutip_qtrl
--    del qutip_qtrl
--    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
--except ImportError:
--    raise ImportError(
--        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
--        "Install it with `pip install qutip-qtrl` (for more details, go to "
--        "https://qutip-qtrl.readthedocs.io/)."
--    )
-+"""Module replicating the qutip_qtrl package from within qutip."""
-+import sys
-+
-+try:
-+    import qutip_qtrl
-+    del qutip_qtrl
-+    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
-+except ImportError:
-+    raise ImportError(
-+        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
-+        "Install it with `pip install qutip-qtrl` (for more details, go to "
-+        "https://qutip-qtrl.readthedocs.io/)."
-+    )
-diff --git a/qutip/core/__init__.py b/qutip/core/__init__.py
-index b12830ba..dc183518 100644
---- a/qutip/core/__init__.py
-+++ b/qutip/core/__init__.py
-@@ -1,16 +1,16 @@
--from .options import *
--from .coefficient import *
--from .qobj import *
--from .cy.qobjevo import *
--from .expect import *
--from .tensor import *
--from .states import *
--from .operators import *
--from .metrics import *
--from .superoperator import *
--from .superop_reps import *
--from .subsystem_apply import *
--from .blochredfield import *
--from . import gates
--
--del cy  # File in cy are not public facing
-+from .options import *
-+from .coefficient import *
-+from .qobj import *
-+from .cy.qobjevo import *
-+from .expect import *
-+from .tensor import *
-+from .states import *
-+from .operators import *
-+from .metrics import *
-+from .superoperator import *
-+from .superop_reps import *
-+from .subsystem_apply import *
-+from .blochredfield import *
-+from . import gates
-+
-+del cy  # File in cy are not public facing
-diff --git a/qutip/core/_brtensor.pyx b/qutip/core/_brtensor.pyx
-index 530cf63d..25788233 100644
---- a/qutip/core/_brtensor.pyx
-+++ b/qutip/core/_brtensor.pyx
-@@ -1,337 +1,337 @@
--#cython: language_level=3
--cimport cython
--
--import qutip.core.data as _data
--from qutip.core.data cimport Dense, CSR, Data, idxint, csr
--from qutip.core.cy.qobjevo cimport QobjEvo
--from qutip.core.cy.coefficient cimport Coefficient
--from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
--from qutip.core._brtools cimport _EigenBasisTransform
--from qutip.core.qobj import Qobj
--
--import numpy as np
--from libcpp.vector cimport vector
--from libc.math cimport fabs, fmin
--
--__all__ = []
--
--
--cpdef enum TensorType:
--    SPARSE = 0
--    DENSE = 1
--    DATA = 2
--
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
--                         double[:, ::1] skew, double cutoff):
--    """
--    Compute the contribution of A to the Bloch Redfield tensor.
--    Computation are done using dispatched function.
--    """
--    cdef object cutoff_arr
--    cdef int nrows = A.shape[0], a, b, c, d
--    cdef Data S, I, AS, AST, out, C
--    cdef type cls = type(A)
--
--    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
--    I = _data.identity[cls](nrows)
--    AS = _data.multiply(A, S)
--    AST = _data.multiply(A, _data.transpose(S))
--
--    out = _data.kron(AST, _data.transpose(A))
--    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
--    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
--    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
--
--    if cutoff == np.inf:
--        return out
--
--    # The cutoff_arr should be sparse most of the time, but it depend on the
--    # cutoff and we cannot easily guess a nnz to make it efficiently...
--    # But there is probably room from improvement.
--    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
--    for a in range(nrows):
--        for b in range(nrows):
--            for c in range(nrows):
--                for d in range(nrows):
--                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
--                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
--    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
--    return _data.multiply(out, C)
--
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
--                           double[:, ::1] skew, double cutoff):
--    """
--    Compute the contribution of A to the Bloch Redfield tensor.
--    Allocate a Dense array and fill it.
--    """
--    cdef size_t nrows = A.shape[0]
--    cdef size_t a, b, c, d, k # matrix indexing variables
--    cdef double complex elem
--    cdef double complex[:,:] A_mat, ac_term, bd_term
--    cdef object np2term
--    cdef Dense out
--    cdef double complex[::1, :] out_array
--
--    if type(A) is Dense:
--        A_mat = A.as_ndarray()
--    else:
--        A_mat = A.to_array()
--
--    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
--    out_array = out.as_ndarray()
--
--    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
--    ac_term = np2term[:, :, 0]
--    bd_term = np2term[:, :, 1]
--
--
--    for a in range(nrows):
--        for b in range(nrows-1, -1, -1):
--            if fabs(skew[a, b]) < cutoff:
--                for k in range(nrows):
--                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
--                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
--
--    # TODO: we could use openmp to speed up.
--    for a in range(nrows):
--        for b in range(nrows):
--            for c in range(nrows):
--                for d in range(nrows):
--                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
--                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
--                        elem *= (spectrum[c, a] + spectrum[d, b])
--                        if a == c:
--                            elem = elem - 0.5 * ac_term[d, b]
--                        if b == d:
--                            elem = elem - 0.5 * bd_term[a, c]
--                        out_array[a * nrows + b, c * nrows + d] = elem
--    return out
--
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
--                          double[:, ::1] skew, double cutoff):
--    """
--    Compute the contribution of A to the Bloch Redfield tensor.
--    Create it as coo pointers and return as CSR.
--    """
--    cdef size_t nrows = A.shape[0]
--    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
--    cdef double complex elem, ac_elem, bd_elem
--    cdef double complex[:,:] A_mat, ac_term, bd_term
--    cdef double dskew
--    cdef object np2term
--    cdef vector[idxint] coo_rows, coo_cols
--    cdef vector[double complex] coo_data
--
--    if type(A) is Dense:
--        A_mat = A.as_ndarray()
--    else:
--        A_mat = A.to_array()
--
--    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
--    ac_term = np2term[:, :, 0]
--    bd_term = np2term[:, :, 1]
--
--    for a in range(nrows):
--        for b in range(nrows-1, -1, -1):
--            if fabs(skew[a, b]) < cutoff:
--                for k in range(nrows):
--                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
--                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
--            elif skew[a, b] > cutoff:
--                break
--
--    # skew[a,b] = w[a] - w[b]
--    # (w[a] - w[b] - w[c] + w[d]) < cutoff
--    # w's are sorted so we can skip part of the loop.
--    for a in range(nrows):
--        for b in range(nrows):
--            d_min = 0
--            for c in range(nrows):
--                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
--                    break
--                for d in range(d_min, nrows):
--                    dskew = skew[a, b] - skew[c, d]
--                    if -dskew > cutoff:
--                        d_min = d
--                    elif fabs(dskew) < cutoff:
--                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
--                        elem *= (spectrum[c, a] + spectrum[d, b])
--                        if a == c:
--                            elem -= 0.5 * ac_term[d, b]
--                        if b == d:
--                            elem -= 0.5 * bd_term[a, c]
--                        if elem != 0:
--                            coo_rows.push_back(a * nrows + b)
--                            coo_cols.push_back(c * nrows + d)
--                            coo_data.push_back(elem)
--                    elif dskew >= cutoff:
--                        break
--
--    return csr.from_coo_pointers(
--        coo_rows.data(), coo_cols.data(), coo_data.data(),
--        nrows*nrows, nrows*nrows, coo_rows.size()
--    )
--
--
--cdef class _BlochRedfieldElement(_BaseElement):
--    """
--    Element for individual Bloch Redfield collapse term.
--
--    The tensor is computed in the ``eig_basis``, but is returned in the outside
--    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
--    on a state expected to be in that basis. It transform the state instead of
--    the tensor as it is usually faster, the state being a density matrix in
--    most cases.
--
--    Diffenrent term can share a same instance of the eigen transform tool
--    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
--    only once even when needed by multiple terms.
--    """
--    cdef readonly _EigenBasisTransform H
--    cdef readonly QobjEvo a_op
--    cdef readonly Coefficient spectra
--    cdef readonly double sec_cutoff
--    cdef readonly size_t nrows
--    cdef readonly (idxint, idxint) shape
--    cdef readonly list dims
--    cdef readonly object np_datas
--    cdef readonly double[:, ::1] skew
--    cdef readonly double[:, ::1] spectrum
--    cdef readonly bint eig_basis
--    cdef readonly TensorType tensortype
--
--    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
--                 dtype=None):
--        if isinstance(H, _EigenBasisTransform):
--            self.H = H
--        else:
--            self.H = _EigenBasisTransform(H)
--
--        self.a_op = a_op
--        self.spectra = spectra
--        self.sec_cutoff = sec_cutoff
--        self.eig_basis = eig_basis
--        self.nrows = a_op.shape[0]
--        self.dims = [a_op.dims, a_op.dims]
--
--        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
--        self.tensortype = {
--            'sparse': SPARSE,
--            'dense': DENSE,
--            'data': DATA
--        }[dtype]
--
--        # Allocate some array
--        # Let numpy manage memory
--        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
--                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
--        self.skew = self.np_datas[0]
--        self.spectrum = self.np_datas[1]
--
--    cpdef double _compute_spectrum(self, double t) except *:
--        "Compute the skew, spectrum and dw_min"
--        cdef Coefficient spec
--        cdef double dw_min = np.inf
--        eigvals = self.H.eigenvalues(t)
--
--        for col in range(0, self.nrows):
--            self.skew[col, col] = 0.
--            self.spectrum[col, col] = self.spectra(t, w=0).real
--            for row in range(col, self.nrows):
--                dw = eigvals[row] - eigvals[col]
--                self.skew[row, col] = dw
--                self.skew[col, row] = -dw
--                if dw != 0:
--                    dw_min = fmin(fabs(dw), dw_min)
--                self.spectrum[row, col] = self.spectra(t, w=dw).real
--                self.spectrum[col, row] = self.spectra(t, w=-dw).real
--        return dw_min
--
--    cdef Data _br_term(self, Data A_eig, double cutoff):
--        if self.tensortype == DENSE:
--            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
--        elif self.tensortype == SPARSE:
--            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
--        elif self.tensortype == DATA:
--            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
--        raise ValueError('Invalid tensortype')
--
--    cpdef object qobj(self, t):
--        return Qobj(self.data(t), dims=self.dims, type="super",
--                    copy=False, superrep="super")
--
--    cpdef object coeff(self, t):
--        return 1.
--
--    cpdef Data data(self, t):
--        cdef size_t i
--        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
--        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
--        BR_eig = self._br_term(A_eig, cutoff)
--        if self.eig_basis:
--            return BR_eig
--        return self.H.from_eigbasis(t, BR_eig)
--
--    cdef Data matmul_data_t(self, t, Data state, Data out=None):
--        cdef size_t i
--        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
--        cdef Data A_eig, BR_eig
--
--        if not self.eig_basis:
--            state = self.H.to_eigbasis(t, state)
--        if not self.eig_basis and out is not None:
--            out = self.H.to_eigbasis(t, out)
--        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
--        BR_eig = self._br_term(A_eig, cutoff)
--        out = _data.add(_data.matmul(BR_eig, state), out)
--        if not self.eig_basis:
--            out = self.H.from_eigbasis(t, out)
--        return out
--
--    def linear_map(self, f, anti=False):
--        return _MapElement(self, [f])
--
--    def replace_arguments(self, args, cache=None):
--        if cache is None:
--            return _BlochRedfieldElement(
--                self.H,
--                QobjEvo(self.a_op, args=args),
--                self.spectra,
--                self.sec_cutoff
--            )
--        H = None
--        for old, new in cache:
--            if old is self:
--                return new
--            if old is self.H:
--                H = new
--        if H is None:
--            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
--                                     type(self.H.oper) is CSR)
--        new = _BlochRedfieldElement(
--            H, QobjEvo(self.a_op, args=args),
--            self.spectra.replace_arguments(**args), self.sec_cutoff
--        )
--        cache.append((self, new))
--        cache.append((self.H, H))
--        return new
--
--    def __matmul__(left, right):
--        return _ProdElement(left, right, [])
--
--    def __mul__(left, right):
--        cdef _MapElement out
--        if type(left) is _BlochRedfieldElement:
--            out = _MapElement(left, [], right)
--        if type(right) is _BlochRedfieldElement:
--            out = _MapElement(right, [], left)
--        return out
-+#cython: language_level=3
-+cimport cython
-+
-+import qutip.core.data as _data
-+from qutip.core.data cimport Dense, CSR, Data, idxint, csr
-+from qutip.core.cy.qobjevo cimport QobjEvo
-+from qutip.core.cy.coefficient cimport Coefficient
-+from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
-+from qutip.core._brtools cimport _EigenBasisTransform
-+from qutip.core.qobj import Qobj
-+
-+import numpy as np
-+from libcpp.vector cimport vector
-+from libc.math cimport fabs, fmin
-+
-+__all__ = []
-+
-+
-+cpdef enum TensorType:
-+    SPARSE = 0
-+    DENSE = 1
-+    DATA = 2
-+
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
-+                         double[:, ::1] skew, double cutoff):
-+    """
-+    Compute the contribution of A to the Bloch Redfield tensor.
-+    Computation are done using dispatched function.
-+    """
-+    cdef object cutoff_arr
-+    cdef int nrows = A.shape[0], a, b, c, d
-+    cdef Data S, I, AS, AST, out, C
-+    cdef type cls = type(A)
-+
-+    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
-+    I = _data.identity[cls](nrows)
-+    AS = _data.multiply(A, S)
-+    AST = _data.multiply(A, _data.transpose(S))
-+
-+    out = _data.kron(AST, _data.transpose(A))
-+    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
-+    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
-+    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
-+
-+    if cutoff == np.inf:
-+        return out
-+
-+    # The cutoff_arr should be sparse most of the time, but it depend on the
-+    # cutoff and we cannot easily guess a nnz to make it efficiently...
-+    # But there is probably room from improvement.
-+    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
-+    for a in range(nrows):
-+        for b in range(nrows):
-+            for c in range(nrows):
-+                for d in range(nrows):
-+                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
-+                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
-+    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
-+    return _data.multiply(out, C)
-+
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
-+                           double[:, ::1] skew, double cutoff):
-+    """
-+    Compute the contribution of A to the Bloch Redfield tensor.
-+    Allocate a Dense array and fill it.
-+    """
-+    cdef size_t nrows = A.shape[0]
-+    cdef size_t a, b, c, d, k # matrix indexing variables
-+    cdef double complex elem
-+    cdef double complex[:,:] A_mat, ac_term, bd_term
-+    cdef object np2term
-+    cdef Dense out
-+    cdef double complex[::1, :] out_array
-+
-+    if type(A) is Dense:
-+        A_mat = A.as_ndarray()
-+    else:
-+        A_mat = A.to_array()
-+
-+    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
-+    out_array = out.as_ndarray()
-+
-+    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
-+    ac_term = np2term[:, :, 0]
-+    bd_term = np2term[:, :, 1]
-+
-+
-+    for a in range(nrows):
-+        for b in range(nrows-1, -1, -1):
-+            if fabs(skew[a, b]) < cutoff:
-+                for k in range(nrows):
-+                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
-+                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
-+
-+    # TODO: we could use openmp to speed up.
-+    for a in range(nrows):
-+        for b in range(nrows):
-+            for c in range(nrows):
-+                for d in range(nrows):
-+                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
-+                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
-+                        elem *= (spectrum[c, a] + spectrum[d, b])
-+                        if a == c:
-+                            elem = elem - 0.5 * ac_term[d, b]
-+                        if b == d:
-+                            elem = elem - 0.5 * bd_term[a, c]
-+                        out_array[a * nrows + b, c * nrows + d] = elem
-+    return out
-+
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
-+                          double[:, ::1] skew, double cutoff):
-+    """
-+    Compute the contribution of A to the Bloch Redfield tensor.
-+    Create it as coo pointers and return as CSR.
-+    """
-+    cdef size_t nrows = A.shape[0]
-+    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
-+    cdef double complex elem, ac_elem, bd_elem
-+    cdef double complex[:,:] A_mat, ac_term, bd_term
-+    cdef double dskew
-+    cdef object np2term
-+    cdef vector[idxint] coo_rows, coo_cols
-+    cdef vector[double complex] coo_data
-+
-+    if type(A) is Dense:
-+        A_mat = A.as_ndarray()
-+    else:
-+        A_mat = A.to_array()
-+
-+    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
-+    ac_term = np2term[:, :, 0]
-+    bd_term = np2term[:, :, 1]
-+
-+    for a in range(nrows):
-+        for b in range(nrows-1, -1, -1):
-+            if fabs(skew[a, b]) < cutoff:
-+                for k in range(nrows):
-+                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
-+                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
-+            elif skew[a, b] > cutoff:
-+                break
-+
-+    # skew[a,b] = w[a] - w[b]
-+    # (w[a] - w[b] - w[c] + w[d]) < cutoff
-+    # w's are sorted so we can skip part of the loop.
-+    for a in range(nrows):
-+        for b in range(nrows):
-+            d_min = 0
-+            for c in range(nrows):
-+                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
-+                    break
-+                for d in range(d_min, nrows):
-+                    dskew = skew[a, b] - skew[c, d]
-+                    if -dskew > cutoff:
-+                        d_min = d
-+                    elif fabs(dskew) < cutoff:
-+                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
-+                        elem *= (spectrum[c, a] + spectrum[d, b])
-+                        if a == c:
-+                            elem -= 0.5 * ac_term[d, b]
-+                        if b == d:
-+                            elem -= 0.5 * bd_term[a, c]
-+                        if elem != 0:
-+                            coo_rows.push_back(a * nrows + b)
-+                            coo_cols.push_back(c * nrows + d)
-+                            coo_data.push_back(elem)
-+                    elif dskew >= cutoff:
-+                        break
-+
-+    return csr.from_coo_pointers(
-+        coo_rows.data(), coo_cols.data(), coo_data.data(),
-+        nrows*nrows, nrows*nrows, coo_rows.size()
-+    )
-+
-+
-+cdef class _BlochRedfieldElement(_BaseElement):
-+    """
-+    Element for individual Bloch Redfield collapse term.
-+
-+    The tensor is computed in the ``eig_basis``, but is returned in the outside
-+    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
-+    on a state expected to be in that basis. It transform the state instead of
-+    the tensor as it is usually faster, the state being a density matrix in
-+    most cases.
-+
-+    Diffenrent term can share a same instance of the eigen transform tool
-+    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
-+    only once even when needed by multiple terms.
-+    """
-+    cdef readonly _EigenBasisTransform H
-+    cdef readonly QobjEvo a_op
-+    cdef readonly Coefficient spectra
-+    cdef readonly double sec_cutoff
-+    cdef readonly size_t nrows
-+    cdef readonly (idxint, idxint) shape
-+    cdef readonly list dims
-+    cdef readonly object np_datas
-+    cdef readonly double[:, ::1] skew
-+    cdef readonly double[:, ::1] spectrum
-+    cdef readonly bint eig_basis
-+    cdef readonly TensorType tensortype
-+
-+    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
-+                 dtype=None):
-+        if isinstance(H, _EigenBasisTransform):
-+            self.H = H
-+        else:
-+            self.H = _EigenBasisTransform(H)
-+
-+        self.a_op = a_op
-+        self.spectra = spectra
-+        self.sec_cutoff = sec_cutoff
-+        self.eig_basis = eig_basis
-+        self.nrows = a_op.shape[0]
-+        self.dims = [a_op.dims, a_op.dims]
-+
-+        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
-+        self.tensortype = {
-+            'sparse': SPARSE,
-+            'dense': DENSE,
-+            'data': DATA
-+        }[dtype]
-+
-+        # Allocate some array
-+        # Let numpy manage memory
-+        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
-+                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
-+        self.skew = self.np_datas[0]
-+        self.spectrum = self.np_datas[1]
-+
-+    cpdef double _compute_spectrum(self, double t) except *:
-+        "Compute the skew, spectrum and dw_min"
-+        cdef Coefficient spec
-+        cdef double dw_min = np.inf
-+        eigvals = self.H.eigenvalues(t)
-+
-+        for col in range(0, self.nrows):
-+            self.skew[col, col] = 0.
-+            self.spectrum[col, col] = self.spectra(t, w=0).real
-+            for row in range(col, self.nrows):
-+                dw = eigvals[row] - eigvals[col]
-+                self.skew[row, col] = dw
-+                self.skew[col, row] = -dw
-+                if dw != 0:
-+                    dw_min = fmin(fabs(dw), dw_min)
-+                self.spectrum[row, col] = self.spectra(t, w=dw).real
-+                self.spectrum[col, row] = self.spectra(t, w=-dw).real
-+        return dw_min
-+
-+    cdef Data _br_term(self, Data A_eig, double cutoff):
-+        if self.tensortype == DENSE:
-+            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
-+        elif self.tensortype == SPARSE:
-+            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
-+        elif self.tensortype == DATA:
-+            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
-+        raise ValueError('Invalid tensortype')
-+
-+    cpdef object qobj(self, t):
-+        return Qobj(self.data(t), dims=self.dims, type="super",
-+                    copy=False, superrep="super")
-+
-+    cpdef object coeff(self, t):
-+        return 1.
-+
-+    cpdef Data data(self, t):
-+        cdef size_t i
-+        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
-+        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
-+        BR_eig = self._br_term(A_eig, cutoff)
-+        if self.eig_basis:
-+            return BR_eig
-+        return self.H.from_eigbasis(t, BR_eig)
-+
-+    cdef Data matmul_data_t(self, t, Data state, Data out=None):
-+        cdef size_t i
-+        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
-+        cdef Data A_eig, BR_eig
-+
-+        if not self.eig_basis:
-+            state = self.H.to_eigbasis(t, state)
-+        if not self.eig_basis and out is not None:
-+            out = self.H.to_eigbasis(t, out)
-+        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
-+        BR_eig = self._br_term(A_eig, cutoff)
-+        out = _data.add(_data.matmul(BR_eig, state), out)
-+        if not self.eig_basis:
-+            out = self.H.from_eigbasis(t, out)
-+        return out
-+
-+    def linear_map(self, f, anti=False):
-+        return _MapElement(self, [f])
-+
-+    def replace_arguments(self, args, cache=None):
-+        if cache is None:
-+            return _BlochRedfieldElement(
-+                self.H,
-+                QobjEvo(self.a_op, args=args),
-+                self.spectra,
-+                self.sec_cutoff
-+            )
-+        H = None
-+        for old, new in cache:
-+            if old is self:
-+                return new
-+            if old is self.H:
-+                H = new
-+        if H is None:
-+            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
-+                                     type(self.H.oper) is CSR)
-+        new = _BlochRedfieldElement(
-+            H, QobjEvo(self.a_op, args=args),
-+            self.spectra.replace_arguments(**args), self.sec_cutoff
-+        )
-+        cache.append((self, new))
-+        cache.append((self.H, H))
-+        return new
-+
-+    def __matmul__(left, right):
-+        return _ProdElement(left, right, [])
-+
-+    def __mul__(left, right):
-+        cdef _MapElement out
-+        if type(left) is _BlochRedfieldElement:
-+            out = _MapElement(left, [], right)
-+        if type(right) is _BlochRedfieldElement:
-+            out = _MapElement(right, [], left)
-+        return out
-diff --git a/qutip/core/_brtools.pxd b/qutip/core/_brtools.pxd
-index ca9e3dd3..508d8460 100644
---- a/qutip/core/_brtools.pxd
-+++ b/qutip/core/_brtools.pxd
-@@ -1,32 +1,32 @@
--#cython: language_level=3
--from qutip.core.cy.qobjevo cimport QobjEvo
--from qutip.core.cy.coefficient cimport Coefficient
--from qutip.core.data cimport Data
--
--cdef class SpectraCoefficient(Coefficient):
--    cdef Coefficient coeff_t
--    cdef Coefficient coeff_w
--    cdef double w
--
--cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
--
--cdef class _EigenBasisTransform:
--    cdef:
--        QobjEvo oper
--        int size
--        readonly bint isconstant
--        double _t
--        object _eigvals  # np.ndarray
--        Data _evecs, _evecs_inv
--
--    cpdef object eigenvalues(self, double t)
--    cpdef Data evecs(self, double t)
--
--    cpdef Data to_eigbasis(self, double t, Data fock)
--    cpdef Data from_eigbasis(self, double t, Data eig)
--
--    cdef Data _inv(self, double t)
--    cdef void _compute_eigen(self, double t) except *
--
--    cdef Data _S_converter(self, double t)
--    cdef Data _S_converter_inverse(self, double t)
-+#cython: language_level=3
-+from qutip.core.cy.qobjevo cimport QobjEvo
-+from qutip.core.cy.coefficient cimport Coefficient
-+from qutip.core.data cimport Data
-+
-+cdef class SpectraCoefficient(Coefficient):
-+    cdef Coefficient coeff_t
-+    cdef Coefficient coeff_w
-+    cdef double w
-+
-+cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
-+
-+cdef class _EigenBasisTransform:
-+    cdef:
-+        QobjEvo oper
-+        int size
-+        readonly bint isconstant
-+        double _t
-+        object _eigvals  # np.ndarray
-+        Data _evecs, _evecs_inv
-+
-+    cpdef object eigenvalues(self, double t)
-+    cpdef Data evecs(self, double t)
-+
-+    cpdef Data to_eigbasis(self, double t, Data fock)
-+    cpdef Data from_eigbasis(self, double t, Data eig)
-+
-+    cdef Data _inv(self, double t)
-+    cdef void _compute_eigen(self, double t) except *
-+
-+    cdef Data _S_converter(self, double t)
-+    cdef Data _S_converter_inverse(self, double t)
-diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
-index a7e379c9..98737b0f 100644
---- a/qutip/core/_brtools.pyx
-+++ b/qutip/core/_brtools.pyx
-@@ -1,327 +1,327 @@
--#cython: language_level=3
--from libc.math cimport fabs, fmin
--from libc.float cimport DBL_MAX
--
--cimport numpy as cnp
--import numpy as np
--
--cimport cython
--
--from qutip.core.cy.qobjevo cimport QobjEvo
--from qutip.core.cy.coefficient cimport Coefficient
--from qutip.core.data cimport Data, Dense, idxint
--import qutip.core.data as _data
--from qutip.core import Qobj
--from scipy.linalg cimport cython_blas as blas
--
--
--__all__ = ['SpectraCoefficient']
--
--
--cdef class SpectraCoefficient(Coefficient):
--    """
--    Change a Coefficient with `t` dependence to one with `w` dependence to use
--    in Bloch-Redfield tensor to allow array based coefficients to be used as
--    spectral functions.
--    If 2 coefficients are passed, the first one is the frequence response and
--    the second is the time response.
--    """
--    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
--        self.coeff_t = coeff_t
--        self.coeff_w = coeff_w
--        self.w = w
--
--    cdef complex _call(self, double t) except *:
--        if self.coeff_t is None:
--            return self.coeff_w(self.w)
--        return self.coeff_t(t) * self.coeff_w(self.w)
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
--
--    def replace_arguments(self, _args=None, *, w=None, **kwargs):
--        if _args:
--            kwargs.update(_args)
--        if kwargs:
--            return SpectraCoefficient(
--                self.coeff_w.replace(**kwargs),
--                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
--                kwargs.get('w', w or self.w)
--              )
--        if w is not None:
--            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
--        return self
--
--
--@cython.overflowcheck(True)
--cdef size_t _mul_checked(size_t a, size_t b) except? -1:
--    return a * b
--
--
--cdef Data _apply_trans(Data original, int trans):
--    """helper function for matmul_var_data, apply transform."""
--    cdef Data out
--    if trans == 0:
--        out = original
--    elif trans == 1:
--        out = original.transpose()
--    elif trans == 2:
--        out = original.conj()
--    elif trans == 3:
--        out = original.adjoint()
--    return out
--
--
--cdef char _fetch_trans_code(int trans):
--    """helper function for matmul_var_Dense, fetch the blas flag byte"""
--    if trans == 0:
--        return b'N'
--    elif trans == 1:
--        return b'T'
--    elif trans == 3:
--        return b'C'
--
--
--cpdef Data matmul_var_data(Data left, Data right,
--                           int transleft, int transright):
--    """
--    matmul which input matrices can be transposed or adjoint.
--    out = transleft(left) @ transright(right)
--
--    with trans[left, right]:
--        0 : Normal
--        1 : Transpose
--        2 : Conjugate
--        3 : Adjoint
--    """
--    # Should this be supported in data.matmul?
--    # A.dag() @ A is quite common.
--    cdef int size
--    cdef double complex beta
--    cdef char left_code, right_code
--    if (
--        type(left) is Dense
--        and type(right) is Dense
--        and left.shape[0] == left.shape[1]
--        and left.shape[0] == right.shape[0]
--        and left.shape[0] == right.shape[1]
--    ):
--        return matmul_var_Dense(left, right, transleft, transright)
--    left = _apply_trans(left, transleft)
--    right = _apply_trans(right, transright)
--    return _data.matmul(left, right)
--
--
--cdef Dense matmul_var_Dense(Dense left, Dense right,
--                            int transleft, int transright):
--    """
--    matmul which input matrices can be transposed or adjoint.
--    out = transleft(left) @ transright(right)
--
--    with trans[left, right]:
--       0 : Normal
--       1 : Transpose
--       2 : Conjugate
--       3 : Adjoint
--    """
--    # blas support matmul for normal, transpose, adjoint for fortran ordered
--    # matrices.
--    if not (
--        left.shape[0] == left.shape[1]
--        and left.shape[0] == right.shape[0]
--        and left.shape[0] == right.shape[1]
--    ):
--        raise ValueError("Only implemented for square operators")
--    cdef Dense out, a, b
--    cdef double complex alpha = 1., beta = 0.
--    cdef int tleft, tright, size = left.shape[0]
--
--    # Since fortran to C equivalent to transpose, fix the codes to fortran
--    tleft = transleft ^ (not left.fortran)
--    tright = transright ^ (not right.fortran)
--
--    # blas.zgemm does not support adjoint.
--    if tleft + tright == 5:
--        # adjoint and conjugate, we can't transpose the output to use zgemm
--        out = matmul_var_data(left, right, transleft-2, transright-2)
--        return out.conj()
--    if tleft == 2 or tright == 2:
--        # Need a conjugate, we compute the transpose of the desired results.
--        # A.conj @ B^op -> (B^T^op @ A.dag)^T
--        out = _data.dense.empty(left.shape[0], right.shape[1], False)
--        a, b = right, left
--        tleft, tright = tright ^ 1, tleft ^ 1
--    else:
--        out = _data.dense.empty(left.shape[0], right.shape[1], True)
--        a, b = left, right
--
--    left_code = _fetch_trans_code(tleft)
--    right_code = _fetch_trans_code(tright)
--    blas.zgemm(&left_code, &right_code, &size, &size, &size,
--               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
--               &beta, (<Dense> out).data, &size)
--
--    return out
--
--
--class _eigen_qevo:
--    """
--    Callable function to represent the eigenvectors of a QobjEvo at a time
--    ``t``.
--    """
--    def __init__(self, qevo):
--        self.qevo = QobjEvo(qevo)  # Force a copy
--        self.args = None
--        # This is a base conversion operator, the eigen basis part of the dims
--        # are flat.
--        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
--
--    def __call__(self, t, args):
--        if args is not self.args:
--            self.args = args
--            self.qevo.arguments(self.args)
--        _, data = _data.eigs(self.qevo._call(t), True, True)
--        return Qobj(data, copy=False, dims=self.out_dims)
--
--
--cdef class _EigenBasisTransform:
--    """
--    For an hermitian operator, compute the eigenvalues and eigenstates and do
--    the base change to and from that eigenbasis.
--
--    parameter
--    ---------
--    oper : QobjEvo
--        Hermitian operator for which to compute the eigenbasis.
--
--    sparse : bool [False]
--        Whether to use sparse solver for eigen decomposition.
--    """
--    def __init__(self, QobjEvo oper, bint sparse=False):
--        if oper.dims[0] != oper.dims[1]:
--            raise ValueError
--        if type(oper(0).data) is _data.CSR and not sparse:
--            oper = oper.to(Dense)
--        self.oper = oper
--        self.isconstant = oper.isconstant
--        self.size = oper.shape[0]
--
--        if oper.isconstant:
--            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
--                                                    True, True)
--        else:
--            self._evecs = None
--            self._eigvals = None
--
--        self._t = np.nan
--        self._evecs_inv = None
--
--    def as_Qobj(self):
--        """Make an Qobj or QobjEvo of the eigenvectors."""
--        if self.isconstant:
--            return Qobj(self.evecs(0), dims=self.oper.dims)
--        else:
--            return QobjEvo(_eigen_qevo(self.oper))
--
--    cdef void _compute_eigen(self, double t) except *:
--        if self._t != t and not self.isconstant:
--            self._t = t
--            self._evecs_inv = None
--            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
--
--    cpdef object eigenvalues(self, double t):
--        """
--        Return the eigenvalues at ``t``.
--        """
--        self._compute_eigen(t)
--        return self._eigvals
--
--    cpdef Data evecs(self, double t):
--        """
--        Return the eigenstates at ``t``.
--        """
--        self._compute_eigen(t)
--        return self._evecs
--
--    cdef Data _inv(self, double t):
--        if self._evecs_inv is None:
--            self._evecs_inv = self.evecs(t).adjoint()
--        return self._evecs_inv
--
--    cdef Data _S_converter(self, double t):
--        return _data.kron(self.evecs(t).transpose(), self._inv(t))
--
--    cdef Data _S_converter_inverse(self, double t):
--        return _data.kron(self._inv(t).transpose(), self.evecs(t))
--
--    cpdef Data to_eigbasis(self, double t, Data fock):
--        """
--        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
--        ``oper(t)`` is diagonalized.
--        """
--        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
--        # Blas include A.dag @ B in one operation. We use it if we can so we
--        # don't make unneeded copy of evecs.
--        cdef Data temp
--        if fock.shape[0] == self.size and fock.shape[1] == 1:
--            return matmul_var_data(self.evecs(t), fock, 3, 0)
--
--        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
--            if type(fock) is Dense and (<Dense> fock).fortran:
--                fock = _data.column_unstack_dense(fock, self.size, True)
--                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
--                                    self.evecs(t))
--                fock = _data.column_stack_dense(fock, True)
--            else:
--                fock = _data.column_unstack(fock, self.size)
--                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
--                                    self.evecs(t))
--            if type(temp) is Dense:
--                return _data.column_stack_dense(temp, True)
--            return _data.column_stack(temp)
--
--        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
--            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
--                                self.evecs(t))
--
--        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
--            temp = self._S_converter_inverse(t)
--            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
--
--        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
--                         "can't guess type from shape.")
--
--    cpdef Data from_eigbasis(self, double t, Data eig):
--        """
--        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
--        ``oper(t)`` is diagonalized to the outside basis.
--        """
--        cdef Data temp
--        if eig.shape[0] == self.size and eig.shape[1] == 1:
--            return _data.matmul(self.evecs(t), eig)
--
--        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
--            if type(eig) is Dense and (<Dense> eig).fortran:
--                eig = _data.column_unstack_dense(eig, self.size, True)
--                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
--                                  self.evecs(t), 0, 3)
--                eig = _data.column_stack_dense(eig, True)
--            else:
--                eig = _data.column_unstack(eig, self.size)
--                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
--                                  self.evecs(t), 0, 3)
--            if type(temp) is Dense:
--                return _data.column_stack_dense(temp, True)
--            return _data.column_stack(temp)
--
--        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
--            temp = self.evecs(t)
--            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
--
--        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
--            temp = self._S_converter_inverse(t)
--            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
--
--        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
--                         "can't guess type from shape.")
-+#cython: language_level=3
-+from libc.math cimport fabs, fmin
-+from libc.float cimport DBL_MAX
-+
-+cimport numpy as cnp
-+import numpy as np
-+
-+cimport cython
-+
-+from qutip.core.cy.qobjevo cimport QobjEvo
-+from qutip.core.cy.coefficient cimport Coefficient
-+from qutip.core.data cimport Data, Dense, idxint
-+import qutip.core.data as _data
-+from qutip.core import Qobj
-+from scipy.linalg cimport cython_blas as blas
-+
-+
-+__all__ = ['SpectraCoefficient']
-+
-+
-+cdef class SpectraCoefficient(Coefficient):
-+    """
-+    Change a Coefficient with `t` dependence to one with `w` dependence to use
-+    in Bloch-Redfield tensor to allow array based coefficients to be used as
-+    spectral functions.
-+    If 2 coefficients are passed, the first one is the frequence response and
-+    the second is the time response.
-+    """
-+    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
-+        self.coeff_t = coeff_t
-+        self.coeff_w = coeff_w
-+        self.w = w
-+
-+    cdef complex _call(self, double t) except *:
-+        if self.coeff_t is None:
-+            return self.coeff_w(self.w)
-+        return self.coeff_t(t) * self.coeff_w(self.w)
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
-+
-+    def replace_arguments(self, _args=None, *, w=None, **kwargs):
-+        if _args:
-+            kwargs.update(_args)
-+        if kwargs:
-+            return SpectraCoefficient(
-+                self.coeff_w.replace(**kwargs),
-+                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
-+                kwargs.get('w', w or self.w)
-+              )
-+        if w is not None:
-+            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
-+        return self
-+
-+
-+@cython.overflowcheck(True)
-+cdef size_t _mul_checked(size_t a, size_t b) except? -1:
-+    return a * b
-+
-+
-+cdef Data _apply_trans(Data original, int trans):
-+    """helper function for matmul_var_data, apply transform."""
-+    cdef Data out
-+    if trans == 0:
-+        out = original
-+    elif trans == 1:
-+        out = original.transpose()
-+    elif trans == 2:
-+        out = original.conj()
-+    elif trans == 3:
-+        out = original.adjoint()
-+    return out
-+
-+
-+cdef char _fetch_trans_code(int trans):
-+    """helper function for matmul_var_Dense, fetch the blas flag byte"""
-+    if trans == 0:
-+        return b'N'
-+    elif trans == 1:
-+        return b'T'
-+    elif trans == 3:
-+        return b'C'
-+
-+
-+cpdef Data matmul_var_data(Data left, Data right,
-+                           int transleft, int transright):
-+    """
-+    matmul which input matrices can be transposed or adjoint.
-+    out = transleft(left) @ transright(right)
-+
-+    with trans[left, right]:
-+        0 : Normal
-+        1 : Transpose
-+        2 : Conjugate
-+        3 : Adjoint
-+    """
-+    # Should this be supported in data.matmul?
-+    # A.dag() @ A is quite common.
-+    cdef int size
-+    cdef double complex beta
-+    cdef char left_code, right_code
-+    if (
-+        type(left) is Dense
-+        and type(right) is Dense
-+        and left.shape[0] == left.shape[1]
-+        and left.shape[0] == right.shape[0]
-+        and left.shape[0] == right.shape[1]
-+    ):
-+        return matmul_var_Dense(left, right, transleft, transright)
-+    left = _apply_trans(left, transleft)
-+    right = _apply_trans(right, transright)
-+    return _data.matmul(left, right)
-+
-+
-+cdef Dense matmul_var_Dense(Dense left, Dense right,
-+                            int transleft, int transright):
-+    """
-+    matmul which input matrices can be transposed or adjoint.
-+    out = transleft(left) @ transright(right)
-+
-+    with trans[left, right]:
-+       0 : Normal
-+       1 : Transpose
-+       2 : Conjugate
-+       3 : Adjoint
-+    """
-+    # blas support matmul for normal, transpose, adjoint for fortran ordered
-+    # matrices.
-+    if not (
-+        left.shape[0] == left.shape[1]
-+        and left.shape[0] == right.shape[0]
-+        and left.shape[0] == right.shape[1]
-+    ):
-+        raise ValueError("Only implemented for square operators")
-+    cdef Dense out, a, b
-+    cdef double complex alpha = 1., beta = 0.
-+    cdef int tleft, tright, size = left.shape[0]
-+
-+    # Since fortran to C equivalent to transpose, fix the codes to fortran
-+    tleft = transleft ^ (not left.fortran)
-+    tright = transright ^ (not right.fortran)
-+
-+    # blas.zgemm does not support adjoint.
-+    if tleft + tright == 5:
-+        # adjoint and conjugate, we can't transpose the output to use zgemm
-+        out = matmul_var_data(left, right, transleft-2, transright-2)
-+        return out.conj()
-+    if tleft == 2 or tright == 2:
-+        # Need a conjugate, we compute the transpose of the desired results.
-+        # A.conj @ B^op -> (B^T^op @ A.dag)^T
-+        out = _data.dense.empty(left.shape[0], right.shape[1], False)
-+        a, b = right, left
-+        tleft, tright = tright ^ 1, tleft ^ 1
-+    else:
-+        out = _data.dense.empty(left.shape[0], right.shape[1], True)
-+        a, b = left, right
-+
-+    left_code = _fetch_trans_code(tleft)
-+    right_code = _fetch_trans_code(tright)
-+    blas.zgemm(&left_code, &right_code, &size, &size, &size,
-+               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
-+               &beta, (<Dense> out).data, &size)
-+
-+    return out
-+
-+
-+class _eigen_qevo:
-+    """
-+    Callable function to represent the eigenvectors of a QobjEvo at a time
-+    ``t``.
-+    """
-+    def __init__(self, qevo):
-+        self.qevo = QobjEvo(qevo)  # Force a copy
-+        self.args = None
-+        # This is a base conversion operator, the eigen basis part of the dims
-+        # are flat.
-+        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
-+
-+    def __call__(self, t, args):
-+        if args is not self.args:
-+            self.args = args
-+            self.qevo.arguments(self.args)
-+        _, data = _data.eigs(self.qevo._call(t), True, True)
-+        return Qobj(data, copy=False, dims=self.out_dims)
-+
-+
-+cdef class _EigenBasisTransform:
-+    """
-+    For an hermitian operator, compute the eigenvalues and eigenstates and do
-+    the base change to and from that eigenbasis.
-+
-+    parameter
-+    ---------
-+    oper : QobjEvo
-+        Hermitian operator for which to compute the eigenbasis.
-+
-+    sparse : bool [False]
-+        Whether to use sparse solver for eigen decomposition.
-+    """
-+    def __init__(self, QobjEvo oper, bint sparse=False):
-+        if oper.dims[0] != oper.dims[1]:
-+            raise ValueError
-+        if type(oper(0).data) is _data.CSR and not sparse:
-+            oper = oper.to(Dense)
-+        self.oper = oper
-+        self.isconstant = oper.isconstant
-+        self.size = oper.shape[0]
-+
-+        if oper.isconstant:
-+            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
-+                                                    True, True)
-+        else:
-+            self._evecs = None
-+            self._eigvals = None
-+
-+        self._t = np.nan
-+        self._evecs_inv = None
-+
-+    def as_Qobj(self):
-+        """Make an Qobj or QobjEvo of the eigenvectors."""
-+        if self.isconstant:
-+            return Qobj(self.evecs(0), dims=self.oper.dims)
-+        else:
-+            return QobjEvo(_eigen_qevo(self.oper))
-+
-+    cdef void _compute_eigen(self, double t) except *:
-+        if self._t != t and not self.isconstant:
-+            self._t = t
-+            self._evecs_inv = None
-+            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
-+
-+    cpdef object eigenvalues(self, double t):
-+        """
-+        Return the eigenvalues at ``t``.
-+        """
-+        self._compute_eigen(t)
-+        return self._eigvals
-+
-+    cpdef Data evecs(self, double t):
-+        """
-+        Return the eigenstates at ``t``.
-+        """
-+        self._compute_eigen(t)
-+        return self._evecs
-+
-+    cdef Data _inv(self, double t):
-+        if self._evecs_inv is None:
-+            self._evecs_inv = self.evecs(t).adjoint()
-+        return self._evecs_inv
-+
-+    cdef Data _S_converter(self, double t):
-+        return _data.kron(self.evecs(t).transpose(), self._inv(t))
-+
-+    cdef Data _S_converter_inverse(self, double t):
-+        return _data.kron(self._inv(t).transpose(), self.evecs(t))
-+
-+    cpdef Data to_eigbasis(self, double t, Data fock):
-+        """
-+        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
-+        ``oper(t)`` is diagonalized.
-+        """
-+        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
-+        # Blas include A.dag @ B in one operation. We use it if we can so we
-+        # don't make unneeded copy of evecs.
-+        cdef Data temp
-+        if fock.shape[0] == self.size and fock.shape[1] == 1:
-+            return matmul_var_data(self.evecs(t), fock, 3, 0)
-+
-+        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
-+            if type(fock) is Dense and (<Dense> fock).fortran:
-+                fock = _data.column_unstack_dense(fock, self.size, True)
-+                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-+                                    self.evecs(t))
-+                fock = _data.column_stack_dense(fock, True)
-+            else:
-+                fock = _data.column_unstack(fock, self.size)
-+                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-+                                    self.evecs(t))
-+            if type(temp) is Dense:
-+                return _data.column_stack_dense(temp, True)
-+            return _data.column_stack(temp)
-+
-+        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
-+            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-+                                self.evecs(t))
-+
-+        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
-+            temp = self._S_converter_inverse(t)
-+            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
-+
-+        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
-+                         "can't guess type from shape.")
-+
-+    cpdef Data from_eigbasis(self, double t, Data eig):
-+        """
-+        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
-+        ``oper(t)`` is diagonalized to the outside basis.
-+        """
-+        cdef Data temp
-+        if eig.shape[0] == self.size and eig.shape[1] == 1:
-+            return _data.matmul(self.evecs(t), eig)
-+
-+        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
-+            if type(eig) is Dense and (<Dense> eig).fortran:
-+                eig = _data.column_unstack_dense(eig, self.size, True)
-+                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
-+                                  self.evecs(t), 0, 3)
-+                eig = _data.column_stack_dense(eig, True)
-+            else:
-+                eig = _data.column_unstack(eig, self.size)
-+                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
-+                                  self.evecs(t), 0, 3)
-+            if type(temp) is Dense:
-+                return _data.column_stack_dense(temp, True)
-+            return _data.column_stack(temp)
-+
-+        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
-+            temp = self.evecs(t)
-+            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
-+
-+        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
-+            temp = self._S_converter_inverse(t)
-+            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
-+
-+        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
-+                         "can't guess type from shape.")
-diff --git a/qutip/core/blochredfield.py b/qutip/core/blochredfield.py
-index e23f6af9..7a3c6d25 100644
---- a/qutip/core/blochredfield.py
-+++ b/qutip/core/blochredfield.py
-@@ -1,188 +1,188 @@
--import os
--import inspect
--import numpy as np
--from qutip.settings import settings as qset
--
--from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
--from ._brtools import SpectraCoefficient, _EigenBasisTransform
--from .cy.coefficient import InterCoefficient, Coefficient
--from ._brtensor import _BlochRedfieldElement
--
--
--__all__ = ['bloch_redfield_tensor', 'brterm']
--
--
--def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
--                          fock_basis=False, sparse_eigensolver=False,
--                          br_dtype='sparse'):
--    """
--    Calculates the Bloch-Redfield tensor for a system given
--    a set of operators and corresponding spectral functions that describes the
--    system's coupling to its environment.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
--        System Hamiltonian.
--
--    a_ops : list of (a_op, spectra)
--        Nested list of system operators that couple to the environment,
--        and the corresponding bath spectra.
--
--        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
--            The operator coupling to the environment. Must be hermitian.
--
--        spectra : :class:`Coefficient`, func, str
--            The corresponding bath spectra.
--            Can be a :class:`~Coefficient` using an 'w' args, a function of the
--            frequency or a string. The :class:`SpectraCoefficient` can be used for
--            array based coefficient.
--            The spectra can depend on ``t`` if the corresponding
--            ``a_op`` is a :class:`QobjEvo`.
--
--        Example:
--
--        .. code-block::
--
--            a_ops = [
--                (a+a.dag(), ('w>0', args={"w": 0})),
--                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
--                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
--                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
--            ]
--
--
--    c_ops : list
--        List of system collapse operators.
--
--    sec_cutoff : float {0.1}
--        Cutoff for secular approximation. Use ``-1`` if secular approximation
--        is not used when evaluating bath-coupling terms.
--
--    fock_basis : bool {False}
--        Whether to return the tensor in the input basis or the diagonalized
--        basis.
--
--    sparse_eigensolver : bool {False}
--        Whether to use the sparse eigensolver
--
--    br_dtype : ['sparse', 'dense', 'data']
--        Which data type to use when computing the brtensor.
--        With a cutoff 'sparse' is usually the most efficient.
--
--    Returns
--    -------
--    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
--        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
--        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
--        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
--        column.
--    """
--    R = liouvillian(H, c_ops)
--    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
--
--    if fock_basis:
--        for (a_op, spectra) in a_ops:
--            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
--                        br_dtype=br_dtype)
--        return R
--    else:
--        # When the Hamiltonian is time-dependent, the transformation of `L` to
--        # eigenbasis is not optimized.
--        if isinstance(R, QobjEvo):
--            # The `sprepost` will be computed 2 times for each parts of `R`.
--            # Compressing the QobjEvo will lower the number of parts.
--            R.compress()
--        evec = H_transform.as_Qobj()
--        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
--        for (a_op, spectra) in a_ops:
--            R += brterm(H_transform, a_op, spectra, sec_cutoff,
--                        False, br_dtype=br_dtype)[0]
--        return R, H_transform.as_Qobj()
--
--
--def brterm(H, a_op, spectra, sec_cutoff=0.1,
--           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
--    """
--    Calculates the contribution of one coupling operator to the Bloch-Redfield
--    tensor.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
--        System Hamiltonian.
--
--    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
--        The operator coupling to the environment. Must be hermitian.
--
--    spectra : :class:`Coefficient`, func, str
--        The corresponding bath spectra.
--        Can be a :class:`~Coefficient` using an 'w' args, a function of the
--        frequency or a string. The :class:`SpectraCoefficient` can be used for
--        array based coefficient.
--        The spectra can depend on ``t`` if the corresponding
--        ``a_op`` is a :class:`QobjEvo`.
--
--        Example:
--
--            coefficient('w>0', args={"w": 0})
--            SpectraCoefficient(coefficient(array, tlist=...))
--
--    sec_cutoff : float {0.1}
--        Cutoff for secular approximation. Use ``-1`` if secular approximation
--        is not used when evaluating bath-coupling terms.
--
--    fock_basis : bool {False}
--        Whether to return the tensor in the input basis or the diagonalized
--        basis.
--
--    sparse_eigensolver : bool {False}
--        Whether to use the sparse eigensolver on the Hamiltonian.
--
--    br_dtype : ['sparse', 'dense', 'data']
--        Which data type to use when computing the brtensor.
--        With a cutoff 'sparse' is usually the most efficient.
--
--    Returns
--    -------
--    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
--        If ``fock_basis``, return the Bloch Redfield tensor in the outside
--        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
--        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
--        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
--        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
--    """
--    if isinstance(H, _EigenBasisTransform):
--        Hdiag = H
--    else:
--        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
--
--    # convert spectra to Coefficient
--    if isinstance(spectra, str):
--        spectra = coefficient(spectra, args={'w': 0})
--    elif isinstance(spectra, InterCoefficient):
--        spectra = SpectraCoefficient(spectra)
--    elif isinstance(spectra, Coefficient):
--        pass
--    elif callable(spectra):
--        sig = inspect.signature(spectra)
--        if tuple(sig.parameters.keys()) == ("w",):
--            spectra = SpectraCoefficient(coefficient(spectra))
--        else:
--            spectra = coefficient(spectra, args={'w': 0})
--    else:
--        raise TypeError("a_ops's spectra not known")
--
--    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
--    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
--                sec_cutoff, not fock_basis, dtype=br_dtype))
--
--    if (
--        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
--         or isinstance(H, Qobj))
--        and isinstance(a_op, Qobj)
--    ):
--        R = R(0)
--    return R if fock_basis else (R, Hdiag.as_Qobj())
-+import os
-+import inspect
-+import numpy as np
-+from qutip.settings import settings as qset
-+
-+from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
-+from ._brtools import SpectraCoefficient, _EigenBasisTransform
-+from .cy.coefficient import InterCoefficient, Coefficient
-+from ._brtensor import _BlochRedfieldElement
-+
-+
-+__all__ = ['bloch_redfield_tensor', 'brterm']
-+
-+
-+def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
-+                          fock_basis=False, sparse_eigensolver=False,
-+                          br_dtype='sparse'):
-+    """
-+    Calculates the Bloch-Redfield tensor for a system given
-+    a set of operators and corresponding spectral functions that describes the
-+    system's coupling to its environment.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-+        System Hamiltonian.
-+
-+    a_ops : list of (a_op, spectra)
-+        Nested list of system operators that couple to the environment,
-+        and the corresponding bath spectra.
-+
-+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-+            The operator coupling to the environment. Must be hermitian.
-+
-+        spectra : :class:`Coefficient`, func, str
-+            The corresponding bath spectra.
-+            Can be a :class:`~Coefficient` using an 'w' args, a function of the
-+            frequency or a string. The :class:`SpectraCoefficient` can be used for
-+            array based coefficient.
-+            The spectra can depend on ``t`` if the corresponding
-+            ``a_op`` is a :class:`QobjEvo`.
-+
-+        Example:
-+
-+        .. code-block::
-+
-+            a_ops = [
-+                (a+a.dag(), ('w>0', args={"w": 0})),
-+                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
-+                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
-+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-+            ]
-+
-+
-+    c_ops : list
-+        List of system collapse operators.
-+
-+    sec_cutoff : float {0.1}
-+        Cutoff for secular approximation. Use ``-1`` if secular approximation
-+        is not used when evaluating bath-coupling terms.
-+
-+    fock_basis : bool {False}
-+        Whether to return the tensor in the input basis or the diagonalized
-+        basis.
-+
-+    sparse_eigensolver : bool {False}
-+        Whether to use the sparse eigensolver
-+
-+    br_dtype : ['sparse', 'dense', 'data']
-+        Which data type to use when computing the brtensor.
-+        With a cutoff 'sparse' is usually the most efficient.
-+
-+    Returns
-+    -------
-+    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
-+        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
-+        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
-+        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
-+        column.
-+    """
-+    R = liouvillian(H, c_ops)
-+    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
-+
-+    if fock_basis:
-+        for (a_op, spectra) in a_ops:
-+            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
-+                        br_dtype=br_dtype)
-+        return R
-+    else:
-+        # When the Hamiltonian is time-dependent, the transformation of `L` to
-+        # eigenbasis is not optimized.
-+        if isinstance(R, QobjEvo):
-+            # The `sprepost` will be computed 2 times for each parts of `R`.
-+            # Compressing the QobjEvo will lower the number of parts.
-+            R.compress()
-+        evec = H_transform.as_Qobj()
-+        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
-+        for (a_op, spectra) in a_ops:
-+            R += brterm(H_transform, a_op, spectra, sec_cutoff,
-+                        False, br_dtype=br_dtype)[0]
-+        return R, H_transform.as_Qobj()
-+
-+
-+def brterm(H, a_op, spectra, sec_cutoff=0.1,
-+           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
-+    """
-+    Calculates the contribution of one coupling operator to the Bloch-Redfield
-+    tensor.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-+        System Hamiltonian.
-+
-+    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-+        The operator coupling to the environment. Must be hermitian.
-+
-+    spectra : :class:`Coefficient`, func, str
-+        The corresponding bath spectra.
-+        Can be a :class:`~Coefficient` using an 'w' args, a function of the
-+        frequency or a string. The :class:`SpectraCoefficient` can be used for
-+        array based coefficient.
-+        The spectra can depend on ``t`` if the corresponding
-+        ``a_op`` is a :class:`QobjEvo`.
-+
-+        Example:
-+
-+            coefficient('w>0', args={"w": 0})
-+            SpectraCoefficient(coefficient(array, tlist=...))
-+
-+    sec_cutoff : float {0.1}
-+        Cutoff for secular approximation. Use ``-1`` if secular approximation
-+        is not used when evaluating bath-coupling terms.
-+
-+    fock_basis : bool {False}
-+        Whether to return the tensor in the input basis or the diagonalized
-+        basis.
-+
-+    sparse_eigensolver : bool {False}
-+        Whether to use the sparse eigensolver on the Hamiltonian.
-+
-+    br_dtype : ['sparse', 'dense', 'data']
-+        Which data type to use when computing the brtensor.
-+        With a cutoff 'sparse' is usually the most efficient.
-+
-+    Returns
-+    -------
-+    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
-+        If ``fock_basis``, return the Bloch Redfield tensor in the outside
-+        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
-+        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
-+        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
-+        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
-+    """
-+    if isinstance(H, _EigenBasisTransform):
-+        Hdiag = H
-+    else:
-+        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
-+
-+    # convert spectra to Coefficient
-+    if isinstance(spectra, str):
-+        spectra = coefficient(spectra, args={'w': 0})
-+    elif isinstance(spectra, InterCoefficient):
-+        spectra = SpectraCoefficient(spectra)
-+    elif isinstance(spectra, Coefficient):
-+        pass
-+    elif callable(spectra):
-+        sig = inspect.signature(spectra)
-+        if tuple(sig.parameters.keys()) == ("w",):
-+            spectra = SpectraCoefficient(coefficient(spectra))
-+        else:
-+            spectra = coefficient(spectra, args={'w': 0})
-+    else:
-+        raise TypeError("a_ops's spectra not known")
-+
-+    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
-+    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
-+                sec_cutoff, not fock_basis, dtype=br_dtype))
-+
-+    if (
-+        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
-+         or isinstance(H, Qobj))
-+        and isinstance(a_op, Qobj)
-+    ):
-+        R = R(0)
-+    return R if fock_basis else (R, Hdiag.as_Qobj())
-diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
-index d029461f..a738e630 100644
---- a/qutip/core/coefficient.py
-+++ b/qutip/core/coefficient.py
-@@ -1,776 +1,776 @@
--import numpy as np
--import scipy
--import scipy.interpolate
--import os
--import sys
--import re
--import dis
--import hashlib
--import glob
--import importlib
--import warnings
--import numbers
--from contextlib import contextmanager
--from collections import defaultdict
--from setuptools import setup, Extension
--try:
--    from Cython.Build import cythonize
--    import filelock
--except ImportError:
--    pass
--
--from ..settings import settings as qset
--from .options import QutipOptions
--from .data import Data
--from .cy.coefficient import (
--    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
--    ConjCoefficient, NormCoefficient
--)
--
--
--__all__ = ["coefficient", "CompilationOptions", "Coefficient",
--           "clean_compiled_coefficient"]
--
--
--class StringParsingWarning(Warning):
--    pass
--
--
--def _return(base, **kwargs):
--    return base
--
--
--# The `coefficient` function is dispatcher for the type of the `base` to the
--# function that created the `Coefficient` object. `coefficient_builders` stores
--# the map `type -> function(base, **kw)`. Optional module can add their
--# `Coefficient` specializations here.
--coefficient_builders = {
--    Coefficient: _return,
--    np.ndarray: InterCoefficient,
--    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
--    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
--}
--
--
--def coefficient(base, *, tlist=None, args={}, args_ctypes={},
--                order=3, compile_opt=None, function_style=None,
--                boundary_conditions=None, **kwargs):
--    """Build ``Coefficient`` for time dependent systems:
--
--    ```
--    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
--    ```
--
--    The coefficients can be a function, a string or a numpy array. Other
--    packages may add support for other kind of coefficients.
--
--    For function based coefficients, the function signature must be either:
--
--    * ``f(t, ...)`` where the other arguments are supplied as ordinary
--      "pythonic" arguments (e.g. ``f(t, w, a=5))
--    * ``f(t, args)`` where the arguments are supplied in a "dict" named
--      ``args``
--
--    By default the signature style is controlled by the
--    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
--    may be overriden here by specifying either ``function_style="pythonic"``
--    or ``function_style="dict"``.
--
--    *Examples*
--        # pythonic style function signature
--
--        def f1_t(t, w):
--            return np.exp(-1j * t * w)
--
--        coeff1 = coefficient(f1_t, args={"w": 1.})
--
--        # dict style function signature
--
--        def f2_t(t, args):
--            return np.exp(-1j * t * args["w"])
--
--        coeff2 = coefficient(f2_t, args={"w": 1.})
--
--    For string based coeffients, the string must be a compilable python code
--    resulting in a complex. The following symbols are defined:
--        sin cos tan asin acos atan pi
--        sinh cosh tanh asinh acosh atanh
--        exp log log10 erf zerf sqrt
--        real imag conj abs norm arg proj
--        numpy as np,
--        scipy.special as spe (python interface)
--        and cython_special (scipy cython interface)
--
--    *Examples*
--        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
--    'args' is needed for string coefficient at compilation.
--    It is a dict of (name:object). The keys must be a valid variables string.
--
--    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
--
--    For numpy array format, the array must be an 1d of dtype float or complex.
--    A list of times (float64) at which the coeffients must be given (tlist).
--    The coeffients array must have the same len as the tlist.
--    The time of the tlist do not need to be equidistant, but must be sorted.
--    By default, a cubic spline interpolation will be used to compute the
--    coefficient at time t. The keyword ``order`` sets the order of the
--    interpolation. When ``order = 0``, the interpolation is step function that
--    evaluates to the most recent value.
--
--    *Examples*
--        tlist = np.logspace(-5,0,100)
--        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
--
--    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
--    also converted to interpolated coefficients (the same kind of coefficient
--    created from ``ndarray``). Other interpolation methods from
--    scipy are converted to a function-based coefficient (the same kind of
--    coefficient created from callables).
--
--    Parameters
--    ----------
--    base : object
--        Base object to make into a Coefficient.
--
--    args : dict, optional
--        Dictionary of arguments to pass to the function or string coefficient.
--
--    order : int, default=3
--        Order of the spline for array based coefficient.
--
--    tlist : iterable, optional
--        Times for each element of an array based coefficient.
--
--    function_style : str, ["dict", "pythonic", None]
--        Function signature of function based coefficients.
--
--    args_ctypes : dict, optional
--        C type for the args when compiling array based coefficients.
--
--    compile_opt : CompilationOptions, optional
--        Sets of options for the compilation of string based coefficients.
--
--    boundary_conditions: 2-tupule, str or None, optional
--        Specify boundary conditions for spline interpolation.
--
--    **kwargs
--        Extra arguments to pass the the coefficients.
--    """
--    kwargs.update({
--        "tlist": tlist,
--        'args': args,
--        'args_ctypes': args_ctypes,
--        'order': order,
--        'compile_opt': compile_opt,
--        'function_style': function_style,
--        'boundary_conditions': boundary_conditions
--    })
--
--    for type_ in coefficient_builders:
--        if isinstance(base, type_):
--            return coefficient_builders[type_](base, **kwargs)
--
--    if callable(base):
--        op = FunctionCoefficient(base, args.copy(), style=function_style)
--        if not isinstance(op(0), numbers.Number):
--            raise TypeError("The coefficient function must return a number")
--        return op
--    else:
--        raise ValueError("coefficient format not understood")
--
--
--def norm(coeff):
--    """ return a Coefficient with is the norm: |c|^2.
--    """
--    return NormCoefficient(coeff)
--
--
--def conj(coeff):
--    """ return a Coefficient with is the conjugate.
--    """
--    return ConjCoefficient(coeff)
--
--
--# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
--# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--class CompilationOptions(QutipOptions):
--    """
--    Compilation options:
--
--    use_cython: bool
--        Whether to compile strings as cython code or use python's ``exec``.
--
--    try_parse: bool [True]
--        Whether to try parsing the string for reuse and static typing.
--
--    static_types : bool [True]
--        Whether to use C types for constant and args.
--
--    accept_int : None, bool
--        Whether to use the type ``int`` for integer constants and args or
--        upgrade it to ``float`` or ``complex``.
--        If `None`, it will only use ``int`` when subscription is found in the
--        code.
--
--    accept_float : bool
--        Whether to use the type ``float`` or upgrade them to ``complex``.
--
--    recompile : bool
--        Do not use previously made files but build a new one.
--
--    compiler_flags : str
--        Flags to pass to the compiler, ex: "-Wall -O3"...
--        Flags not matching your comiler and OS may cause compilation to fail.
--        Use "recompile=True", when trying to if the string pattern was
--        previously used.
--
--    link_flags : str
--        Libraries to link to pass to the compiler. They can not be used to add
--        function to the string coefficient.
--
--    extra_import : str
--        Cython code to add at the head of the file. Can be used to add extra
--        import or cimport code, ex:
--        extra_import="from scipy.linalg import det"
--        extra_import="from qutip.core.data cimport CSR"
--
--    clean_on_error : bool [True]
--        When writing a cython file that cannot be imported, erase it.
--    """
--    _link_flags = ""
--    _compiler_flags = ""
--    if sys.platform == 'win32':
--        _compiler_flags = ''
--    elif sys.platform == 'darwin':
--        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
--        _link_flags += '-mmacosx-version-min=10.9'
--    else:
--        _compiler_flags = '-w -O3 -funroll-loops'
--
--    try:
--        import cython
--        import filelock
--        _use_cython = True
--    except ImportError:
--        _use_cython = False
--
--    _options = {
--        "use_cython": _use_cython,
--        "try_parse": True,
--        "static_types": True,
--        "accept_int": None,
--        "accept_float": True,
--        "recompile": False,
--        "compiler_flags": _compiler_flags,
--        "link_flags": _link_flags,
--        "extra_import": "",
--        "clean_on_error": True,
--    }
--    _settings_name = "compile"
--
--
--# Create the default instance in settings.
--qset.compile = CompilationOptions()
--
--
--# Version number of the Coefficient
--COEFF_VERSION = "1.1"
--
--try:
--    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
--    qset.coeffroot = root
--except OSError:
--    qset.coeffroot = "."
--
--
--def clean_compiled_coefficient(all=False):
--    """
--    Remove previouly compiled string Coefficient.
--
--    Parameter:
--    ----------
--    all: bool
--        If not `all` will remove only previous version.
--    """
--    import glob
--    import shutil
--    tmproot = qset.tmproot
--    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
--    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
--    for folder in folders:
--        if all or folder != root:
--            shutil.rmtree(folder)
--    # Recreate the empty folder.
--    qset.coeffroot = qset.coeffroot
--
--
--def proj(x):
--    if np.isfinite(x):
--        return (x)
--    else:
--        return np.inf + 0j * np.imag(x)
--
--
--str_env = {
--    "sin": np.sin,
--    "cos": np.cos,
--    "tan": np.tan,
--    "asin": np.arcsin,
--    "acos": np.arccos,
--    "atan": np.arctan,
--    "pi": np.pi,
--    "sinh": np.sinh,
--    "cosh": np.cosh,
--    "tanh": np.tanh,
--    "asinh": np.arcsinh,
--    "acosh": np.arccosh,
--    "atanh": np.arctanh,
--    "exp": np.exp,
--    "log": np.log,
--    "log10": np.log10,
--    "erf": scipy.special.erf,
--    "zerf": scipy.special.erf,
--    "sqrt": np.sqrt,
--    "real": np.real,
--    "imag": np.imag,
--    "conj": np.conj,
--    "abs": np.abs,
--    "norm": lambda x: np.abs(x)**2,
--    "arg": np.angle,
--    "proj": proj,
--    "np": np,
--    "spe": scipy.special}
--
--
--def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
--    """
--    Entry point for string based coefficients
--    - Test if the string is valid
--    - Parse: "cos(a*t)" and "cos( w1 * t )"
--        should be recognised as the same compiled object.
--    - Verify if already compiled and compile if not
--    """
--    # First, a sanity check before thinking of compiling
--    if compile_opt is None:
--        compile_opt = qset.compile
--    if not compile_opt['extra_import']:
--        try:
--            env = {"t": 0}
--            env.update(args)
--            exec(base, str_env, env)
--        except Exception as err:
--            raise Exception("Invalid string coefficient") from err
--    coeff = None
--    # Do we compile?
--    if not compile_opt['use_cython']:
--        return StrFunctionCoefficient(base, args)
--    # Parsing tries to make the code in common pattern
--    parsed, variables, constants, raw = try_parse(base, args,
--                                                  args_ctypes, compile_opt)
--    # Once parsed, the code should be unique enough to get a filename
--    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
--    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
--    # See if it already exist and import it.
--    if not compile_opt['recompile']:
--        coeff = try_import(file_name, parsed)
--
--    if not coeff and qset.coeff_write_ok:
--        # Previously compiled coefficient not available: create the cython code
--        code = make_cy_code(parsed, variables, constants,
--                            raw, compile_opt)
--        try :
--            coeff = compile_code(code, file_name, parsed, compile_opt)
--        except PermissionError:
--            pass
--    if coeff is None:
--        # We don't use cython or compilation failed
--        return StrFunctionCoefficient(base, args)
--    keys = [key for _, key, _ in variables]
--    const = [fromstr(val) for _, val, _ in constants]
--    return coeff(base, keys, const, args)
--
--
--coefficient_builders[str] = coeff_from_str
--
--
--def try_import(file_name, parsed_in):
--    """ Import the compiled coefficient if existing and check for
--    name collision.
--    """
--    try:
--        mod = importlib.import_module(file_name)
--    except ModuleNotFoundError:
--        # Coefficient does not exist, to compile as file_name
--        return None
--
--    if mod.parsed_code == parsed_in:
--        # Coefficient found!
--        return mod.StrCoefficient
--    else:
--        raise ValueError("string hash collision, change the string "
--                         "or clean files in qutip.settings.coeffroot")
--
--
--def make_cy_code(code, variables, constants, raw, compile_opt):
--    """
--    Generate the code for the string coefficients.
--    """
--    cdef_cte = ""
--    init_cte = ""
--    copy_cte = ""
--    for i, (name, val, ctype) in enumerate(constants):
--        cdef_cte += "        {} {}\n".format(ctype, name[5:])
--        copy_cte += "        out.{} = {}\n".format(name[5:], name)
--        init_cte += "        {} = cte[{}]\n".format(name, i)
--    cdef_var = ""
--    init_var = ""
--    init_arg = ""
--    replace_var = ""
--    call_var = ""
--    copy_var = ""
--    for i, (name, val, ctype) in enumerate(variables):
--        cdef_var += "        str key{}\n".format(i)
--        cdef_var += "        {} {}\n".format(ctype, name[5:])
--        copy_var += "        out.key{} = self.key{}\n".format(i, i)
--        copy_var += "        out.{} = {}\n".format(name[5:], name)
--        if not raw:
--            init_var += "        self.key{} = var[{}]\n".format(i, i)
--        else:
--            init_var += "        self.key{} = '{}'\n".format(i, val)
--        init_arg += "        {} = args[self.key{}]\n".format(name, i)
--        replace_var += "            if self.key{} in kwargs:\n".format(i)
--        replace_var += ("                out.{}"
--                        " = kwargs[self.key{}]\n".format(name[5:], i))
--        if raw:
--            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
--
--    code = f"""#cython: language_level=3
--# This file is generated automatically by QuTiP.
--
--import numpy as np
--import scipy.special as spe
--from scipy.special cimport cython_special
--cimport cython
--from qutip.core.cy.coefficient cimport Coefficient
--from qutip.core.cy.math cimport erf, zerf
--from qutip.core.cy.complex_math cimport *
--from qutip.core.data cimport Data
--cdef double pi = 3.14159265358979323
--{compile_opt['extra_import']}
--
--parsed_code = "{code}"
--
--@cython.auto_pickle(True)
--cdef class StrCoefficient(Coefficient):
--    \"\"\"
--    String compiled as a :obj:`Coefficient` using cython.
--    \"\"\"
--    cdef:
--        str codeString
--{cdef_cte}{cdef_var}
--
--    def __init__(self, base, var, cte, args):
--        self.codeString = base
--{init_cte}{init_var}{init_arg}
--
--    cpdef Coefficient copy(self):
--        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
--        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
--        out.codeString = self.codeString
--{copy_cte}{copy_var}
--        return out
--
--    def replace_arguments(self, _args=None, **kwargs):
--        \"\"\"
--        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
--        built from 'str' or a python function. Or a the :obj:`Coefficient`
--        itself if the :obj:`Coefficient` does not use arguments. New arguments
--        can be passed as a dict or as keywords.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        \"\"\"
--        cdef StrCoefficient out
--
--        if _args:
--            kwargs.update(_args)
--        if kwargs:
--            out = self.copy()
--{replace_var}
--            return out
--        return self
--
--    @cython.initializedcheck(False)
--    @cython.cdivision(True)
--    cdef complex _call(self, double t) except *:
--{call_var}        return {code}
--"""
--    return code
--
--
--def compile_code(code, file_name, parsed, c_opt):
--    pwd = os.getcwd()
--    os.chdir(qset.coeffroot)
--    # Files with the same name, but differents extension than the pyx file, are
--    # erased during cythonization process, breaking filelock.
--    # Adding a prefix make them safe to use.
--    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
--    try:
--        lock.acquire(timeout=0)
--        for file in glob.glob(file_name + "*"):
--            os.remove(file)
--        file_ = open(file_name + ".pyx", "w")
--        file_.writelines(code)
--        file_.close()
--        oldargs = sys.argv
--        try:
--            sys.argv = ["setup.py", "build_ext", "--inplace"]
--            coeff_file = Extension(
--                file_name,
--                sources=[file_name + ".pyx"],
--                extra_compile_args=c_opt['compiler_flags'].split(),
--                extra_link_args=c_opt['link_flags'].split(),
--                include_dirs=[np.get_include()],
--                language='c++'
--            )
--            ext_modules = cythonize(coeff_file, force=True)
--            setup(ext_modules=ext_modules)
--        except Exception as e:
--            if c_opt['clean_on_error']:
--                for file in glob.glob(file_name + "*"):
--                    os.remove(file)
--            raise Exception("Could not compile") from e
--        finally:
--            sys.argv = oldargs
--    except filelock.Timeout:
--        with lock:
--            # We wait for the lock to be released and then retry the import.
--            pass
--    finally:
--        lock.release()
--        os.chdir(pwd)
--    return try_import(file_name, parsed)
--
--
--# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
--# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--# Parsing here is extracting constants and args name to replace them with
--# attribute of the Coefficient so similar string like:
--# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
--# are all reconized as the same compiled object and only compiled once.
--# Weakness:
--#   typing: "1" and "1j" or the type of args ("w1") make different object
--#   complex: "1+1j" is seens as cte(double) + cte(complex)
--#   negative: "-1" is not seens as a constant but "- constant"
--#
--# int and double can be seens as complex with flags in CompilationOptions
--
--def fromstr(base):
--    """Read a varibles in a string"""
--    ls = {}
--    exec("out = " + base, {}, ls)
--    return ls["out"]
--
--
--typeCodes = {
--    "Data": "_datalayer",
--    "complex": "_cpl",
--    "double": "_dbl",
--    "int": "_int",
--    "str": "_str",
--    "object": "_obj"
--}
--
--
--def compileType(value):
--    """Obtain the index of typeCodes that correspond to the value
--    4.5 -> 'double'..."""
--    if isinstance(value, Data):
--        ctype = "Data"
--    elif isinstance(value, numbers.Integral):
--        ctype = "int"
--    elif isinstance(value, numbers.Real):
--        ctype = "double"
--    elif isinstance(value, numbers.Complex):
--        ctype = "complex"
--    elif isinstance(value, str):
--        ctype = "str"
--    else:
--        ctype = "object"
--    return ctype
--
--
--def find_type_from_str(chars):
--    """ '1j' -> complex """
--    try:
--        lc = {}
--        exec("out = " + chars, {}, lc)
--        return compileType(lc["out"])
--    except Exception:
--        return None
--
--
--def fix_type(ctype, accept_int, accept_float):
--    """int and double could be complex to limit the number of compiled object.
--    change the types is we choose not to support all.
--    """
--    if ctype == "int" and not accept_int:
--        ctype = "double"
--    if ctype == "double" and not accept_float:
--        ctype = "complex"
--    return ctype
--
--
--def extract_constant(code):
--    """Look for floating and complex constants and replace them with variable.
--    """
--    code = " " + code + " "
--    contants = []
--    code = extract_cte_pattern(code, contants,
--                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
--    code = extract_cte_pattern(code, contants,
--                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
--    code = extract_cte_pattern(code, contants,
--                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
--    code = extract_cte_pattern(code, contants,
--                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
--    return code, contants
--
--
--def extract_cte_pattern(code, constants, pattern):
--    """replace the constant following a pattern with variable"""
--    const_strs = re.findall(pattern, code)
--    for cte in const_strs:
--        name = " _cte_temp{}_ ".format(len(constants))
--        code = code.replace(cte, cte[0] + name, 1)
--        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
--    return code
--
--
--def space_parts(code, names):
--    """Force spacing: single space between element"""
--    for name in names:
--        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
--                      " " + name + " ", code)
--    code = " ".join(code.split())
--    return code
--
--
--def parse(code, args, compile_opt):
--    """
--    Read the code and rewrite it in a reutilisable form:
--    Ins:
--        '2.*cos(a*t)', {"a":5+1j}
--    Outs:
--        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
--        variables = [('self._arg_cpl0', 'a', 'complex')]
--        ordered_constants = [('self._cte_dbl0', 2, 'double')]
--    """
--    code, constants = extract_constant(code)
--    names = re.findall("[0-9a-zA-Z_]+", code)
--    code = space_parts(code, names)
--    constants_names = [const[0] for const in constants]
--    new_code = []
--    ordered_constants = []
--    variables = []
--    typeCounts = defaultdict(lambda: 0)
--    accept_int = compile_opt['accept_int']
--    accept_float = compile_opt['accept_float']
--    if accept_int is None:
--        # If there is a subscript: a[b] int are always accepted to be safe
--        # with TypeError
--        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
--    for word in code.split():
--        if word not in names:
--            # syntax
--            new_code.append(word)
--        elif word in args:
--            # find first if the variable is use more than once and reuse
--            var_name = [var_name for var_name, name, _ in variables
--                        if word == name]
--            if var_name:
--                var_name = var_name[0]
--            else:
--                ctype = compileType(args[word])
--                ctype = fix_type(ctype, accept_int, accept_float)
--                var_name = ("self._arg" + typeCodes[ctype] +
--                            str(typeCounts[ctype]))
--                typeCounts[ctype] += 1
--                variables.append((var_name, word, ctype))
--            new_code.append(var_name)
--        elif word in constants_names:
--            name, val, ctype = constants[int(word[9:-1])]
--            ctype = fix_type(ctype, accept_int, accept_float)
--            cte_name = "self._cte" + typeCodes[ctype] +\
--                       str(len(ordered_constants))
--            new_code.append(cte_name)
--            ordered_constants.append((cte_name, val, ctype))
--        else:
--            # Hopefully a buildin or known object
--            new_code.append(word)
--        code = " ".join(new_code)
--    return code, variables, ordered_constants
--
--
--def use_hinted_type(variables, code, args_ctypes):
--    variables_manually_typed = []
--    for i, (name, key, type_) in enumerate(variables):
--        if key in args_ctypes:
--            new_name = "self._custom_" + args_ctypes[key] + str(i)
--            code = code.replace(name, new_name)
--            variables_manually_typed.append((new_name, key, args_ctypes[key]))
--        else:
--            variables_manually_typed.append((name, key, type_))
--    return code, variables_manually_typed
--
--
--def try_parse(code, args, args_ctypes, compile_opt):
--    """
--    Try to parse and verify that the result is still usable.
--    """
--    if not compile_opt['try_parse']:
--        variables = [("self." + name, name, "object") for name in args
--                     if name in code]
--        code, variables = use_hinted_type(variables, code, args_ctypes)
--        return code, variables, [], True
--    ncode, variables, constants = parse(code, args, compile_opt)
--    if not compile_opt['static_types']:
--        # Fallback to object
--        variables = [(f, s, "object") for f, s, _ in variables]
--        constants = [(f, s, "object") for f, s, _ in constants]
--    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
--    if (
--        (compile_opt['extra_import']
--         and not compile_opt['extra_import'].isspace())
--        or test_parsed(ncode, variables, constants, args)
--    ):
--        return ncode, variables, constants, False
--    else:
--        warnings.warn("Could not find c types", StringParsingWarning)
--        remaped_variable = []
--        for _, name, ctype in variables:
--            remaped_variable.append(("self." + name, name, "object"))
--        return code, remaped_variable, [], True
--
--
--def test_parsed(code, variables, constants, args):
--    """
--    Test if parsed code broke anything.
--    """
--    class DummySelf:
--        pass
--    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
--    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
--    loc_env = {"t": 0, 'self': DummySelf}
--    try:
--        exec(code, str_env, loc_env)
--    except Exception as e:
--        return False
--    return True
-+import numpy as np
-+import scipy
-+import scipy.interpolate
-+import os
-+import sys
-+import re
-+import dis
-+import hashlib
-+import glob
-+import importlib
-+import warnings
-+import numbers
-+from contextlib import contextmanager
-+from collections import defaultdict
-+from setuptools import setup, Extension
-+try:
-+    from Cython.Build import cythonize
-+    import filelock
-+except ImportError:
-+    pass
-+
-+from ..settings import settings as qset
-+from .options import QutipOptions
-+from .data import Data
-+from .cy.coefficient import (
-+    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
-+    ConjCoefficient, NormCoefficient
-+)
-+
-+
-+__all__ = ["coefficient", "CompilationOptions", "Coefficient",
-+           "clean_compiled_coefficient"]
-+
-+
-+class StringParsingWarning(Warning):
-+    pass
-+
-+
-+def _return(base, **kwargs):
-+    return base
-+
-+
-+# The `coefficient` function is dispatcher for the type of the `base` to the
-+# function that created the `Coefficient` object. `coefficient_builders` stores
-+# the map `type -> function(base, **kw)`. Optional module can add their
-+# `Coefficient` specializations here.
-+coefficient_builders = {
-+    Coefficient: _return,
-+    np.ndarray: InterCoefficient,
-+    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
-+    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
-+}
-+
-+
-+def coefficient(base, *, tlist=None, args={}, args_ctypes={},
-+                order=3, compile_opt=None, function_style=None,
-+                boundary_conditions=None, **kwargs):
-+    """Build ``Coefficient`` for time dependent systems:
-+
-+    ```
-+    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
-+    ```
-+
-+    The coefficients can be a function, a string or a numpy array. Other
-+    packages may add support for other kind of coefficients.
-+
-+    For function based coefficients, the function signature must be either:
-+
-+    * ``f(t, ...)`` where the other arguments are supplied as ordinary
-+      "pythonic" arguments (e.g. ``f(t, w, a=5))
-+    * ``f(t, args)`` where the arguments are supplied in a "dict" named
-+      ``args``
-+
-+    By default the signature style is controlled by the
-+    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
-+    may be overriden here by specifying either ``function_style="pythonic"``
-+    or ``function_style="dict"``.
-+
-+    *Examples*
-+        # pythonic style function signature
-+
-+        def f1_t(t, w):
-+            return np.exp(-1j * t * w)
-+
-+        coeff1 = coefficient(f1_t, args={"w": 1.})
-+
-+        # dict style function signature
-+
-+        def f2_t(t, args):
-+            return np.exp(-1j * t * args["w"])
-+
-+        coeff2 = coefficient(f2_t, args={"w": 1.})
-+
-+    For string based coeffients, the string must be a compilable python code
-+    resulting in a complex. The following symbols are defined:
-+        sin cos tan asin acos atan pi
-+        sinh cosh tanh asinh acosh atanh
-+        exp log log10 erf zerf sqrt
-+        real imag conj abs norm arg proj
-+        numpy as np,
-+        scipy.special as spe (python interface)
-+        and cython_special (scipy cython interface)
-+
-+    *Examples*
-+        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
-+    'args' is needed for string coefficient at compilation.
-+    It is a dict of (name:object). The keys must be a valid variables string.
-+
-+    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
-+
-+    For numpy array format, the array must be an 1d of dtype float or complex.
-+    A list of times (float64) at which the coeffients must be given (tlist).
-+    The coeffients array must have the same len as the tlist.
-+    The time of the tlist do not need to be equidistant, but must be sorted.
-+    By default, a cubic spline interpolation will be used to compute the
-+    coefficient at time t. The keyword ``order`` sets the order of the
-+    interpolation. When ``order = 0``, the interpolation is step function that
-+    evaluates to the most recent value.
-+
-+    *Examples*
-+        tlist = np.logspace(-5,0,100)
-+        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
-+
-+    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
-+    also converted to interpolated coefficients (the same kind of coefficient
-+    created from ``ndarray``). Other interpolation methods from
-+    scipy are converted to a function-based coefficient (the same kind of
-+    coefficient created from callables).
-+
-+    Parameters
-+    ----------
-+    base : object
-+        Base object to make into a Coefficient.
-+
-+    args : dict, optional
-+        Dictionary of arguments to pass to the function or string coefficient.
-+
-+    order : int, default=3
-+        Order of the spline for array based coefficient.
-+
-+    tlist : iterable, optional
-+        Times for each element of an array based coefficient.
-+
-+    function_style : str, ["dict", "pythonic", None]
-+        Function signature of function based coefficients.
-+
-+    args_ctypes : dict, optional
-+        C type for the args when compiling array based coefficients.
-+
-+    compile_opt : CompilationOptions, optional
-+        Sets of options for the compilation of string based coefficients.
-+
-+    boundary_conditions: 2-tupule, str or None, optional
-+        Specify boundary conditions for spline interpolation.
-+
-+    **kwargs
-+        Extra arguments to pass the the coefficients.
-+    """
-+    kwargs.update({
-+        "tlist": tlist,
-+        'args': args,
-+        'args_ctypes': args_ctypes,
-+        'order': order,
-+        'compile_opt': compile_opt,
-+        'function_style': function_style,
-+        'boundary_conditions': boundary_conditions
-+    })
-+
-+    for type_ in coefficient_builders:
-+        if isinstance(base, type_):
-+            return coefficient_builders[type_](base, **kwargs)
-+
-+    if callable(base):
-+        op = FunctionCoefficient(base, args.copy(), style=function_style)
-+        if not isinstance(op(0), numbers.Number):
-+            raise TypeError("The coefficient function must return a number")
-+        return op
-+    else:
-+        raise ValueError("coefficient format not understood")
-+
-+
-+def norm(coeff):
-+    """ return a Coefficient with is the norm: |c|^2.
-+    """
-+    return NormCoefficient(coeff)
-+
-+
-+def conj(coeff):
-+    """ return a Coefficient with is the conjugate.
-+    """
-+    return ConjCoefficient(coeff)
-+
-+
-+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-+# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
-+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-+class CompilationOptions(QutipOptions):
-+    """
-+    Compilation options:
-+
-+    use_cython: bool
-+        Whether to compile strings as cython code or use python's ``exec``.
-+
-+    try_parse: bool [True]
-+        Whether to try parsing the string for reuse and static typing.
-+
-+    static_types : bool [True]
-+        Whether to use C types for constant and args.
-+
-+    accept_int : None, bool
-+        Whether to use the type ``int`` for integer constants and args or
-+        upgrade it to ``float`` or ``complex``.
-+        If `None`, it will only use ``int`` when subscription is found in the
-+        code.
-+
-+    accept_float : bool
-+        Whether to use the type ``float`` or upgrade them to ``complex``.
-+
-+    recompile : bool
-+        Do not use previously made files but build a new one.
-+
-+    compiler_flags : str
-+        Flags to pass to the compiler, ex: "-Wall -O3"...
-+        Flags not matching your comiler and OS may cause compilation to fail.
-+        Use "recompile=True", when trying to if the string pattern was
-+        previously used.
-+
-+    link_flags : str
-+        Libraries to link to pass to the compiler. They can not be used to add
-+        function to the string coefficient.
-+
-+    extra_import : str
-+        Cython code to add at the head of the file. Can be used to add extra
-+        import or cimport code, ex:
-+        extra_import="from scipy.linalg import det"
-+        extra_import="from qutip.core.data cimport CSR"
-+
-+    clean_on_error : bool [True]
-+        When writing a cython file that cannot be imported, erase it.
-+    """
-+    _link_flags = ""
-+    _compiler_flags = ""
-+    if sys.platform == 'win32':
-+        _compiler_flags = ''
-+    elif sys.platform == 'darwin':
-+        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
-+        _link_flags += '-mmacosx-version-min=10.9'
-+    else:
-+        _compiler_flags = '-w -O3 -funroll-loops'
-+
-+    try:
-+        import cython
-+        import filelock
-+        _use_cython = True
-+    except ImportError:
-+        _use_cython = False
-+
-+    _options = {
-+        "use_cython": _use_cython,
-+        "try_parse": True,
-+        "static_types": True,
-+        "accept_int": None,
-+        "accept_float": True,
-+        "recompile": False,
-+        "compiler_flags": _compiler_flags,
-+        "link_flags": _link_flags,
-+        "extra_import": "",
-+        "clean_on_error": True,
-+    }
-+    _settings_name = "compile"
-+
-+
-+# Create the default instance in settings.
-+qset.compile = CompilationOptions()
-+
-+
-+# Version number of the Coefficient
-+COEFF_VERSION = "1.1"
-+
-+try:
-+    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
-+    qset.coeffroot = root
-+except OSError:
-+    qset.coeffroot = "."
-+
-+
-+def clean_compiled_coefficient(all=False):
-+    """
-+    Remove previouly compiled string Coefficient.
-+
-+    Parameter:
-+    ----------
-+    all: bool
-+        If not `all` will remove only previous version.
-+    """
-+    import glob
-+    import shutil
-+    tmproot = qset.tmproot
-+    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
-+    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
-+    for folder in folders:
-+        if all or folder != root:
-+            shutil.rmtree(folder)
-+    # Recreate the empty folder.
-+    qset.coeffroot = qset.coeffroot
-+
-+
-+def proj(x):
-+    if np.isfinite(x):
-+        return (x)
-+    else:
-+        return np.inf + 0j * np.imag(x)
-+
-+
-+str_env = {
-+    "sin": np.sin,
-+    "cos": np.cos,
-+    "tan": np.tan,
-+    "asin": np.arcsin,
-+    "acos": np.arccos,
-+    "atan": np.arctan,
-+    "pi": np.pi,
-+    "sinh": np.sinh,
-+    "cosh": np.cosh,
-+    "tanh": np.tanh,
-+    "asinh": np.arcsinh,
-+    "acosh": np.arccosh,
-+    "atanh": np.arctanh,
-+    "exp": np.exp,
-+    "log": np.log,
-+    "log10": np.log10,
-+    "erf": scipy.special.erf,
-+    "zerf": scipy.special.erf,
-+    "sqrt": np.sqrt,
-+    "real": np.real,
-+    "imag": np.imag,
-+    "conj": np.conj,
-+    "abs": np.abs,
-+    "norm": lambda x: np.abs(x)**2,
-+    "arg": np.angle,
-+    "proj": proj,
-+    "np": np,
-+    "spe": scipy.special}
-+
-+
-+def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
-+    """
-+    Entry point for string based coefficients
-+    - Test if the string is valid
-+    - Parse: "cos(a*t)" and "cos( w1 * t )"
-+        should be recognised as the same compiled object.
-+    - Verify if already compiled and compile if not
-+    """
-+    # First, a sanity check before thinking of compiling
-+    if compile_opt is None:
-+        compile_opt = qset.compile
-+    if not compile_opt['extra_import']:
-+        try:
-+            env = {"t": 0}
-+            env.update(args)
-+            exec(base, str_env, env)
-+        except Exception as err:
-+            raise Exception("Invalid string coefficient") from err
-+    coeff = None
-+    # Do we compile?
-+    if not compile_opt['use_cython']:
-+        return StrFunctionCoefficient(base, args)
-+    # Parsing tries to make the code in common pattern
-+    parsed, variables, constants, raw = try_parse(base, args,
-+                                                  args_ctypes, compile_opt)
-+    # Once parsed, the code should be unique enough to get a filename
-+    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
-+    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
-+    # See if it already exist and import it.
-+    if not compile_opt['recompile']:
-+        coeff = try_import(file_name, parsed)
-+
-+    if not coeff and qset.coeff_write_ok:
-+        # Previously compiled coefficient not available: create the cython code
-+        code = make_cy_code(parsed, variables, constants,
-+                            raw, compile_opt)
-+        try :
-+            coeff = compile_code(code, file_name, parsed, compile_opt)
-+        except PermissionError:
-+            pass
-+    if coeff is None:
-+        # We don't use cython or compilation failed
-+        return StrFunctionCoefficient(base, args)
-+    keys = [key for _, key, _ in variables]
-+    const = [fromstr(val) for _, val, _ in constants]
-+    return coeff(base, keys, const, args)
-+
-+
-+coefficient_builders[str] = coeff_from_str
-+
-+
-+def try_import(file_name, parsed_in):
-+    """ Import the compiled coefficient if existing and check for
-+    name collision.
-+    """
-+    try:
-+        mod = importlib.import_module(file_name)
-+    except ModuleNotFoundError:
-+        # Coefficient does not exist, to compile as file_name
-+        return None
-+
-+    if mod.parsed_code == parsed_in:
-+        # Coefficient found!
-+        return mod.StrCoefficient
-+    else:
-+        raise ValueError("string hash collision, change the string "
-+                         "or clean files in qutip.settings.coeffroot")
-+
-+
-+def make_cy_code(code, variables, constants, raw, compile_opt):
-+    """
-+    Generate the code for the string coefficients.
-+    """
-+    cdef_cte = ""
-+    init_cte = ""
-+    copy_cte = ""
-+    for i, (name, val, ctype) in enumerate(constants):
-+        cdef_cte += "        {} {}\n".format(ctype, name[5:])
-+        copy_cte += "        out.{} = {}\n".format(name[5:], name)
-+        init_cte += "        {} = cte[{}]\n".format(name, i)
-+    cdef_var = ""
-+    init_var = ""
-+    init_arg = ""
-+    replace_var = ""
-+    call_var = ""
-+    copy_var = ""
-+    for i, (name, val, ctype) in enumerate(variables):
-+        cdef_var += "        str key{}\n".format(i)
-+        cdef_var += "        {} {}\n".format(ctype, name[5:])
-+        copy_var += "        out.key{} = self.key{}\n".format(i, i)
-+        copy_var += "        out.{} = {}\n".format(name[5:], name)
-+        if not raw:
-+            init_var += "        self.key{} = var[{}]\n".format(i, i)
-+        else:
-+            init_var += "        self.key{} = '{}'\n".format(i, val)
-+        init_arg += "        {} = args[self.key{}]\n".format(name, i)
-+        replace_var += "            if self.key{} in kwargs:\n".format(i)
-+        replace_var += ("                out.{}"
-+                        " = kwargs[self.key{}]\n".format(name[5:], i))
-+        if raw:
-+            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
-+
-+    code = f"""#cython: language_level=3
-+# This file is generated automatically by QuTiP.
-+
-+import numpy as np
-+import scipy.special as spe
-+from scipy.special cimport cython_special
-+cimport cython
-+from qutip.core.cy.coefficient cimport Coefficient
-+from qutip.core.cy.math cimport erf, zerf
-+from qutip.core.cy.complex_math cimport *
-+from qutip.core.data cimport Data
-+cdef double pi = 3.14159265358979323
-+{compile_opt['extra_import']}
-+
-+parsed_code = "{code}"
-+
-+@cython.auto_pickle(True)
-+cdef class StrCoefficient(Coefficient):
-+    \"\"\"
-+    String compiled as a :obj:`Coefficient` using cython.
-+    \"\"\"
-+    cdef:
-+        str codeString
-+{cdef_cte}{cdef_var}
-+
-+    def __init__(self, base, var, cte, args):
-+        self.codeString = base
-+{init_cte}{init_var}{init_arg}
-+
-+    cpdef Coefficient copy(self):
-+        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
-+        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
-+        out.codeString = self.codeString
-+{copy_cte}{copy_var}
-+        return out
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        \"\"\"
-+        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
-+        built from 'str' or a python function. Or a the :obj:`Coefficient`
-+        itself if the :obj:`Coefficient` does not use arguments. New arguments
-+        can be passed as a dict or as keywords.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        \"\"\"
-+        cdef StrCoefficient out
-+
-+        if _args:
-+            kwargs.update(_args)
-+        if kwargs:
-+            out = self.copy()
-+{replace_var}
-+            return out
-+        return self
-+
-+    @cython.initializedcheck(False)
-+    @cython.cdivision(True)
-+    cdef complex _call(self, double t) except *:
-+{call_var}        return {code}
-+"""
-+    return code
-+
-+
-+def compile_code(code, file_name, parsed, c_opt):
-+    pwd = os.getcwd()
-+    os.chdir(qset.coeffroot)
-+    # Files with the same name, but differents extension than the pyx file, are
-+    # erased during cythonization process, breaking filelock.
-+    # Adding a prefix make them safe to use.
-+    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
-+    try:
-+        lock.acquire(timeout=0)
-+        for file in glob.glob(file_name + "*"):
-+            os.remove(file)
-+        file_ = open(file_name + ".pyx", "w")
-+        file_.writelines(code)
-+        file_.close()
-+        oldargs = sys.argv
-+        try:
-+            sys.argv = ["setup.py", "build_ext", "--inplace"]
-+            coeff_file = Extension(
-+                file_name,
-+                sources=[file_name + ".pyx"],
-+                extra_compile_args=c_opt['compiler_flags'].split(),
-+                extra_link_args=c_opt['link_flags'].split(),
-+                include_dirs=[np.get_include()],
-+                language='c++'
-+            )
-+            ext_modules = cythonize(coeff_file, force=True)
-+            setup(ext_modules=ext_modules)
-+        except Exception as e:
-+            if c_opt['clean_on_error']:
-+                for file in glob.glob(file_name + "*"):
-+                    os.remove(file)
-+            raise Exception("Could not compile") from e
-+        finally:
-+            sys.argv = oldargs
-+    except filelock.Timeout:
-+        with lock:
-+            # We wait for the lock to be released and then retry the import.
-+            pass
-+    finally:
-+        lock.release()
-+        os.chdir(pwd)
-+    return try_import(file_name, parsed)
-+
-+
-+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-+# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
-+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-+# Parsing here is extracting constants and args name to replace them with
-+# attribute of the Coefficient so similar string like:
-+# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
-+# are all reconized as the same compiled object and only compiled once.
-+# Weakness:
-+#   typing: "1" and "1j" or the type of args ("w1") make different object
-+#   complex: "1+1j" is seens as cte(double) + cte(complex)
-+#   negative: "-1" is not seens as a constant but "- constant"
-+#
-+# int and double can be seens as complex with flags in CompilationOptions
-+
-+def fromstr(base):
-+    """Read a varibles in a string"""
-+    ls = {}
-+    exec("out = " + base, {}, ls)
-+    return ls["out"]
-+
-+
-+typeCodes = {
-+    "Data": "_datalayer",
-+    "complex": "_cpl",
-+    "double": "_dbl",
-+    "int": "_int",
-+    "str": "_str",
-+    "object": "_obj"
-+}
-+
-+
-+def compileType(value):
-+    """Obtain the index of typeCodes that correspond to the value
-+    4.5 -> 'double'..."""
-+    if isinstance(value, Data):
-+        ctype = "Data"
-+    elif isinstance(value, numbers.Integral):
-+        ctype = "int"
-+    elif isinstance(value, numbers.Real):
-+        ctype = "double"
-+    elif isinstance(value, numbers.Complex):
-+        ctype = "complex"
-+    elif isinstance(value, str):
-+        ctype = "str"
-+    else:
-+        ctype = "object"
-+    return ctype
-+
-+
-+def find_type_from_str(chars):
-+    """ '1j' -> complex """
-+    try:
-+        lc = {}
-+        exec("out = " + chars, {}, lc)
-+        return compileType(lc["out"])
-+    except Exception:
-+        return None
-+
-+
-+def fix_type(ctype, accept_int, accept_float):
-+    """int and double could be complex to limit the number of compiled object.
-+    change the types is we choose not to support all.
-+    """
-+    if ctype == "int" and not accept_int:
-+        ctype = "double"
-+    if ctype == "double" and not accept_float:
-+        ctype = "complex"
-+    return ctype
-+
-+
-+def extract_constant(code):
-+    """Look for floating and complex constants and replace them with variable.
-+    """
-+    code = " " + code + " "
-+    contants = []
-+    code = extract_cte_pattern(code, contants,
-+                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
-+    code = extract_cte_pattern(code, contants,
-+                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
-+    code = extract_cte_pattern(code, contants,
-+                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
-+    code = extract_cte_pattern(code, contants,
-+                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
-+    return code, contants
-+
-+
-+def extract_cte_pattern(code, constants, pattern):
-+    """replace the constant following a pattern with variable"""
-+    const_strs = re.findall(pattern, code)
-+    for cte in const_strs:
-+        name = " _cte_temp{}_ ".format(len(constants))
-+        code = code.replace(cte, cte[0] + name, 1)
-+        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
-+    return code
-+
-+
-+def space_parts(code, names):
-+    """Force spacing: single space between element"""
-+    for name in names:
-+        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
-+                      " " + name + " ", code)
-+    code = " ".join(code.split())
-+    return code
-+
-+
-+def parse(code, args, compile_opt):
-+    """
-+    Read the code and rewrite it in a reutilisable form:
-+    Ins:
-+        '2.*cos(a*t)', {"a":5+1j}
-+    Outs:
-+        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
-+        variables = [('self._arg_cpl0', 'a', 'complex')]
-+        ordered_constants = [('self._cte_dbl0', 2, 'double')]
-+    """
-+    code, constants = extract_constant(code)
-+    names = re.findall("[0-9a-zA-Z_]+", code)
-+    code = space_parts(code, names)
-+    constants_names = [const[0] for const in constants]
-+    new_code = []
-+    ordered_constants = []
-+    variables = []
-+    typeCounts = defaultdict(lambda: 0)
-+    accept_int = compile_opt['accept_int']
-+    accept_float = compile_opt['accept_float']
-+    if accept_int is None:
-+        # If there is a subscript: a[b] int are always accepted to be safe
-+        # with TypeError
-+        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
-+    for word in code.split():
-+        if word not in names:
-+            # syntax
-+            new_code.append(word)
-+        elif word in args:
-+            # find first if the variable is use more than once and reuse
-+            var_name = [var_name for var_name, name, _ in variables
-+                        if word == name]
-+            if var_name:
-+                var_name = var_name[0]
-+            else:
-+                ctype = compileType(args[word])
-+                ctype = fix_type(ctype, accept_int, accept_float)
-+                var_name = ("self._arg" + typeCodes[ctype] +
-+                            str(typeCounts[ctype]))
-+                typeCounts[ctype] += 1
-+                variables.append((var_name, word, ctype))
-+            new_code.append(var_name)
-+        elif word in constants_names:
-+            name, val, ctype = constants[int(word[9:-1])]
-+            ctype = fix_type(ctype, accept_int, accept_float)
-+            cte_name = "self._cte" + typeCodes[ctype] +\
-+                       str(len(ordered_constants))
-+            new_code.append(cte_name)
-+            ordered_constants.append((cte_name, val, ctype))
-+        else:
-+            # Hopefully a buildin or known object
-+            new_code.append(word)
-+        code = " ".join(new_code)
-+    return code, variables, ordered_constants
-+
-+
-+def use_hinted_type(variables, code, args_ctypes):
-+    variables_manually_typed = []
-+    for i, (name, key, type_) in enumerate(variables):
-+        if key in args_ctypes:
-+            new_name = "self._custom_" + args_ctypes[key] + str(i)
-+            code = code.replace(name, new_name)
-+            variables_manually_typed.append((new_name, key, args_ctypes[key]))
-+        else:
-+            variables_manually_typed.append((name, key, type_))
-+    return code, variables_manually_typed
-+
-+
-+def try_parse(code, args, args_ctypes, compile_opt):
-+    """
-+    Try to parse and verify that the result is still usable.
-+    """
-+    if not compile_opt['try_parse']:
-+        variables = [("self." + name, name, "object") for name in args
-+                     if name in code]
-+        code, variables = use_hinted_type(variables, code, args_ctypes)
-+        return code, variables, [], True
-+    ncode, variables, constants = parse(code, args, compile_opt)
-+    if not compile_opt['static_types']:
-+        # Fallback to object
-+        variables = [(f, s, "object") for f, s, _ in variables]
-+        constants = [(f, s, "object") for f, s, _ in constants]
-+    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
-+    if (
-+        (compile_opt['extra_import']
-+         and not compile_opt['extra_import'].isspace())
-+        or test_parsed(ncode, variables, constants, args)
-+    ):
-+        return ncode, variables, constants, False
-+    else:
-+        warnings.warn("Could not find c types", StringParsingWarning)
-+        remaped_variable = []
-+        for _, name, ctype in variables:
-+            remaped_variable.append(("self." + name, name, "object"))
-+        return code, remaped_variable, [], True
-+
-+
-+def test_parsed(code, variables, constants, args):
-+    """
-+    Test if parsed code broke anything.
-+    """
-+    class DummySelf:
-+        pass
-+    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
-+    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
-+    loc_env = {"t": 0, 'self': DummySelf}
-+    try:
-+        exec(code, str_env, loc_env)
-+    except Exception as e:
-+        return False
-+    return True
-diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
-index 46f869b2..55c6c847 100644
---- a/qutip/core/cy/_element.pxd
-+++ b/qutip/core/cy/_element.pxd
-@@ -1,42 +1,42 @@
--#cython: language_level=3
--
--from qutip.core.data cimport CSR, Dense, Data
--from qutip.core.cy.coefficient cimport Coefficient
--from qutip.core.data.base cimport idxint
--from libcpp cimport bool
--
--cdef class _BaseElement:
--    cpdef Data data(self, t)
--    cpdef object qobj(self, t)
--    cpdef object coeff(self, t)
--    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
--
--
--cdef class _ConstantElement(_BaseElement):
--    cdef readonly object _qobj
--
--
--cdef class _EvoElement(_BaseElement):
--    cdef readonly object _qobj
--    cdef readonly Coefficient _coefficient
--
--
--cdef class _FuncElement(_BaseElement):
--    cdef readonly object _func
--    cdef readonly dict _args
--    cdef readonly tuple _previous
--    cdef readonly bint _f_pythonic
--    cdef readonly set _f_parameters
--
--
--cdef class _MapElement(_BaseElement):
--    cdef readonly _FuncElement _base
--    cdef readonly list _transform
--    cdef readonly double complex _coeff
--
--
--cdef class _ProdElement(_BaseElement):
--    cdef readonly _BaseElement _left
--    cdef readonly _BaseElement _right
--    cdef readonly list _transform
--    cdef readonly bool _conj
-+#cython: language_level=3
-+
-+from qutip.core.data cimport CSR, Dense, Data
-+from qutip.core.cy.coefficient cimport Coefficient
-+from qutip.core.data.base cimport idxint
-+from libcpp cimport bool
-+
-+cdef class _BaseElement:
-+    cpdef Data data(self, t)
-+    cpdef object qobj(self, t)
-+    cpdef object coeff(self, t)
-+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
-+
-+
-+cdef class _ConstantElement(_BaseElement):
-+    cdef readonly object _qobj
-+
-+
-+cdef class _EvoElement(_BaseElement):
-+    cdef readonly object _qobj
-+    cdef readonly Coefficient _coefficient
-+
-+
-+cdef class _FuncElement(_BaseElement):
-+    cdef readonly object _func
-+    cdef readonly dict _args
-+    cdef readonly tuple _previous
-+    cdef readonly bint _f_pythonic
-+    cdef readonly set _f_parameters
-+
-+
-+cdef class _MapElement(_BaseElement):
-+    cdef readonly _FuncElement _base
-+    cdef readonly list _transform
-+    cdef readonly double complex _coeff
-+
-+
-+cdef class _ProdElement(_BaseElement):
-+    cdef readonly _BaseElement _left
-+    cdef readonly _BaseElement _right
-+    cdef readonly list _transform
-+    cdef readonly bool _conj
-diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
-index 999d51d0..a845b63d 100644
---- a/qutip/core/cy/_element.pyx
-+++ b/qutip/core/cy/_element.pyx
-@@ -1,625 +1,625 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
--
--from .. import data as _data
--from qutip.core.cy.coefficient import coefficient_function_parameters
--from qutip.core.data cimport Dense, Data, dense
--from qutip.core.data.matmul cimport *
--from math import nan as Nan
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex conj(double complex x)
--
--__all__ = ['_ConstantElement', '_EvoElement',
--           '_FuncElement', '_MapElement', '_ProdElement']
--
--
--cdef class _BaseElement:
--    """
--    The representation of a single time-dependent term in the list of
--    terms used by QobjEvo and solvers to describe operators.
--
--    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
--    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
--    are functions of time. :meth:`~_BaseElement.coeff` returns the
--    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
--
--    For example, a :obj:`QobjEvo` instance created by::
--
--      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
--
--    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
--    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
--
--    :obj:`~_BaseElement` defines the interface to time-dependent terms.
--    Sub-classes implement terms defined in different ways.
--    For example, :obj:`~_ConstantElement` implements a term that
--    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
--    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
--    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
--    so on.
--
--    .. note::
--
--      There are three methods to return the factors of the term.
--
--      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
--      coefficient and operator factors respectively. They are separate to
--      avoid constructing an intermediate Python object when called from
--      Cython code (which may take as long as the rest of the call).
--
--      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
--      provides a convenience method for this common operation.
--
--    .. note::
--
--      All :obj:`~_BaseElement` instances are immutable and methods that would
--      modify an object return a new instance instead.
--    """
--    cpdef Data data(self, t):
--        """
--        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
--        of the term at time ``t``.
--
--        Parameters
--        ----------
--        t : double
--          The time, ``t``.
--
--        Returns
--        -------
--        :obj:`~Data`
--          The underlying data of the :obj:`~Qobj` component of the term
--          at time ``t``.
--        """
--        raise NotImplementedError(
--          "Sub-classes of _BaseElement should implement .data(t)."
--        )
--
--    cpdef object qobj(self, t):
--        """
--        Returns the :obj:`~Qobj` component of the term at time ``t``.
--
--        Parameters
--        ----------
--        t : float
--          The time, ``t``.
--
--        Returns
--        -------
--        :obj:`~Qobj`
--          The :obj:`~Qobj` component of the term at time ``t``.
--        """
--        raise NotImplementedError(
--          "Sub-classes of _BaseElement should implement .qobj(t)."
--        )
--
--    cpdef object coeff(self, t):
--        """
--        Returns the complex coefficient of the term at time ``t``.
--
--        Parameters
--        ----------
--        t : float
--          The time, ``t``.
--
--        Returns
--        -------
--        complex
--          The complex coefficient of the term at time ``t``.
--        """
--        raise NotImplementedError(
--          "Sub-classes of _BaseElement should implement .coeff(t)."
--        )
--
--    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
--        """
--        Possibly in-place multiplication and addition. Multiplies a given state
--        by the elemen's value at time ``t`` and adds the result to ``out``.
--        Equivalent to::
--
--          out += self.coeff(t) * self.qobj(t) @ state
--
--        Sub-classes may override :meth:`~matmul_data_t` to provide an more
--        efficient implementation.
--
--        Parameters
--        ----------
--        t : double
--          The time, ``t``.
--
--        state : :obj:`~Data`
--          The state to multiply by the element term.
--
--        out : :obj:`~Data` or ``NULL``
--          The output to add the result of the multiplication to. If ``NULL``,
--          the result of the multiplication is returned directly (i.e. ``out``
--          is assumed to be the zero matrix).
--
--        Returns
--        -------
--        data
--          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
--          the addition possibly having been performed in-place on ``out``.
--
--        .. note::
--
--          Because of the possibly but not definitely in-place behaviour of
--          this function, the result should always be assigned to some variable
--          and surrounding code should assume that ``out`` maybe have been
--          modified and that the result may be a reference to ``out``. The
--          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
--
--        .. note::
--
--          This method would ideally be implemented using a special
--          function dispatched by the data layer so that it did not have to
--          special case the ``Dense`` operation itself, but the data layer
--          dispatch does not yet support in-place operations. Once it does
--          this method should be updated to use the new support.
--        """
--        if out is None:
--            return _data.matmul(self.data(t), state, self.coeff(t))
--        elif type(state) is Dense and type(out) is Dense:
--            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
--            return out
--        else:
--            return _data.add(
--                out,
--                _data.matmul(self.data(t), state, self.coeff(t))
--            )
--
--    def linear_map(self, f, anti=False):
--        """
--        Return a new element representing a linear transformation ``f``
--        of the :obj:`~Qobj` portion of this element and possibly a
--        complex conjucation of the coefficient portion (when ``f`` is an
--        antilinear map).
--
--        If this element represents ``coeff * qobj`` the returned element
--        represents ``coeff * f(obj)`` (if ``anti=False``) or
--        ``conj(coeff) * f(obj)`` (if ``anti=True``).
--
--        Parameters
--        ----------
--        f : function
--          The linear transformation to apply to the :obj:`~Qobj` of this
--          element.
--        anti : bool
--          Whether to take the complex conjugate of the coefficient. Default
--          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
--          map such as the adjoint (i.e. dagger).
--
--        Returns
--        -------
--        _BaseElement
--          A new element with the transformation applied.
--        """
--        raise NotImplementedError(
--          "Sub-classes of _BaseElement should implement .linear_map(t)."
--        )
--
--    def replace_arguments(self, args, cache=None):
--        """
--        Return a copy of the element with the (possible) additional arguments
--        to any time-dependent functions updated to the given argument values.
--        The arguments of any contained :obj:`~Coefficient` instances are also
--        replaced.
--
--        If the operation does not modify this element, the original element
--        may be returned.
--
--        Parameters
--        ----------
--        args : dict
--          A dictionary of arguments to update. Keys are the names of the
--          arguments and values are the new argument values. Arguments
--          not included retain their original values.
--
--        cache : list or ``None``
--          A cache to add updated elements to. Unmodified elements are not
--          added to the cache. If a cache is supplied and ``.replace_arguments``
--          would be called again on the same element with the same arguments,
--          the new element from the cache will be returned instead.
--
--          By default the cache is ``None`` and no caching is performed. Cache
--          users should supply either ``cache=[]`` (which activates caching)
--          or an existing cache (for example, if making calls on sub-elements
--          of some composite element).
--
--        Returns
--        -------
--        _BaseElement
--          A new element with the arguments replaced, or possibly this element
--          if it would not be modified.
--
--        Example
--        -------
--
--        If ``elem`` is a product element for ``op * op.dag()`` it will contain
--        two references to the same element for ``op``. Calling::
--
--          elem = elem.replace_arguments({"theta": 3.1416})
--
--        will return a new element that contains two *different* copies of
--        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
--        to be evaluated *twice* when ``elem.qobj(t)`` is called.
--
--        Calling instead::
--
--          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
--
--        will return a new element that contains two references to *one* copy
--        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
--        performance when calling ``elem.qobj(t)`` later.
--        """
--        raise NotImplementedError(
--          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
--        )
--
--    def __call__(self, t, args=None):
--        if args:
--            cache = []
--            self = self.replace_arguments(args, cache)
--        return self.qobj(t) * self.coeff(t)
--
--
--cdef class _ConstantElement(_BaseElement):
--    """
--    Constant part of a list format :obj:`QobjEvo`.
--    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
--
--      qevo = QobjEvo(H0)
--      qevo.elements = [_ConstantElement(H0)]
--    """
--    def __init__(self, qobj):
--        self._qobj = qobj
--
--    def __mul__(left, right):
--        if type(left) is _ConstantElement:
--            return _ConstantElement((<_ConstantElement> left)._qobj * right)
--        elif type(right) is _ConstantElement:
--            return _ConstantElement((<_ConstantElement> right)._qobj * left)
--        return NotImplemented
--
--    def __matmul__(left, right):
--        if type(left) is _ConstantElement and type(right) is _ConstantElement:
--            return _ConstantElement(
--                (<_ConstantElement> left)._qobj @
--                (<_ConstantElement> right)._qobj
--            )
--        return NotImplemented
--
--    cpdef Data data(self, t):
--        return self._qobj.data
--
--    cpdef object qobj(self, t):
--        return self._qobj
--
--    cpdef object coeff(self, t):
--        return 1.
--
--    def linear_map(self, f, anti=False):
--        return _ConstantElement(f(self._qobj))
--
--    def replace_arguments(self, args, cache=None):
--        return self
--
--    def __call__(self, t, args=None):
--        return self._qobj
--
--
--cdef class _EvoElement(_BaseElement):
--    """
--    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
--    time-dependent operator::
--
--      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
--      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
--    """
--    def __init__(self, qobj, coefficient):
--        self._qobj = qobj
--        self._coefficient = coefficient
--
--    def __mul__(left, right):
--        cdef _EvoElement base
--        cdef object factor
--        if type(left) is _EvoElement:
--            base = left
--            factor = right
--        if type(right) is _EvoElement:
--            base = right
--            factor = left
--        return _EvoElement(base._qobj * factor, base._coefficient)
--
--    def __matmul__(left, right):
--        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
--            coefficient = left._coefficient * right._coefficient
--        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
--            coefficient = left._coefficient
--        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
--            coefficient = right._coefficient
--        else:
--            return NotImplemented
--        return _EvoElement(left._qobj * right._qobj, coefficient)
--
--    cpdef Data data(self, t):
--        return self._qobj.data
--
--    cpdef object qobj(self, t):
--        return self._qobj
--
--    cpdef object coeff(self, t):
--        return self._coefficient(t)
--
--    def linear_map(self, f, anti=False):
--        return _EvoElement(
--            f(self._qobj),
--            self._coefficient.conj() if anti else self._coefficient,
--        )
--
--    def replace_arguments(self, args, cache=None):
--        return _EvoElement(
--            self._qobj.copy(),
--            self._coefficient.replace_arguments(args)
--        )
--
--
--cdef class _FuncElement(_BaseElement):
--    """
--    Used with :obj:`QobjEvo` to build an evolution term from a function with
--    either the signature: ::
--
--        func(t: float, ...) -> Qobj
--
--    or the older QuTiP 4 style signature: ::
--
--        func(t: float, args: dict) -> Qobj
--
--    In the new style, ``func`` may accept arbitrary named arguments and
--    is called as ``func(t, **args)``.
--
--    A :obj:`QobjEvo` created from such a function contains one
--    :obj:`_FuncElement`: ::
--
--        qevo = QobjEvo(func, args=args)
--        qevo.elements = [_FuncElement(func, args)]
--
--    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
--    of function and argument.
--
--    This class has a basic capacity to memoize calls to ``func`` by saving the
--    result of the last call ::
--
--        op = QobjEvo(func, args=args)
--        (op.dag() * op)(t)
--
--    calls ``func`` only once.
--
--    Parameters
--    ----------
--    func : callable(t : float, ...) -> Qobj
--        Function returning the element value at time ``t``.
--
--    args : dict
--        Values of the arguments to pass to ``func``.
--
--    style : {None, "pythonic", "dict", "auto"}
--        The style of the signature used. If style is ``None``,
--        the value of ``qutip.settings.core["function_coefficient_style"]``
--        is used. Otherwise the supplied value overrides the global setting.
--
--    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
--    style and parameter detection and are not intended to be part of
--    the public interface.
--    """
--
--    _UNSET = object()
--
--    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
--        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
--            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
--                raise TypeError(
--                    "_f_pythonic and _f_parameters should always be given together."
--                )
--            _f_pythonic, _f_parameters = coefficient_function_parameters(
--                func, style=style)
--            if _f_parameters is not None:
--                args = {k: args[k] for k in _f_parameters & args.keys()}
--            else:
--                args = args.copy()
--        self._func = func
--        self._args = args
--        self._f_pythonic = _f_pythonic
--        self._f_parameters = _f_parameters
--        self._previous = (Nan, None)
--
--    def __mul__(left, right):
--        cdef _MapElement out
--        if type(left) is _FuncElement:
--            out = _MapElement(left, [], right)
--        if type(right) is _FuncElement:
--            out = _MapElement(right, [], left)
--        return out
--
--    def __matmul__(left, right):
--        return _ProdElement(left, right, [])
--
--    cpdef Data data(self, t):
--        return self.qobj(t).data
--
--    cpdef object qobj(self, t):
--        cdef double _t
--        cdef object _qobj
--        _t, _qobj = self._previous
--        if t == _t:
--            return _qobj
--        if self._f_pythonic:
--            _qobj = self._func(t, **self._args)
--        else:
--            _qobj = self._func(t, self._args)
--        self._previous = (t, _qobj)
--        return _qobj
--
--    cpdef object coeff(self, t):
--        return 1.
--
--    def linear_map(self, f, anti=False):
--        return _MapElement(self, [f])
--
--    def replace_arguments(_FuncElement self, args, cache=None):
--        if self._f_parameters is not None:
--            args = {k: args[k] for k in self._f_parameters & args.keys()}
--        if not args:
--            return self
--        if cache is not None:
--            for old, new in cache:
--                if old is self:
--                    return new
--        new = _FuncElement(
--                self._func,
--                {**self._args, **args},
--                _f_pythonic=self._f_pythonic,
--                _f_parameters=self._f_parameters,
--        )
--        if cache is not None:
--            cache.append((self, new))
--        return new
--
--
--cdef class _MapElement(_BaseElement):
--    """
--    :obj:`_FuncElement` decorated with linear tranformations.
--
--    Linear tranformations available in :obj:`QobjEvo` include transpose,
--    adjoint, conjugate, convertion and product with number::
--    ```
--        op = QobjEvo(f, args=args)
--        op2 = op.conj().dag() * 2
--    ```
--    Then ``op2.elements`` is::
--        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
--
--    """
--    def __init__(self, _FuncElement base, transform, coeff=1.):
--        self._base = base
--        self._transform = transform
--        self._coeff = coeff
--
--    def __mul__(left, right):
--        cdef _MapElement out, self
--        cdef double complex factor
--        if type(left) is _MapElement:
--            self = left
--            factor = right
--        elif type(right) is _MapElement:
--            self = right
--            factor = left
--        return _MapElement(
--            self._base,
--            self._transform.copy(),
--            self._coeff*factor
--        )
--
--    def __matmul__(left, right):
--        return _ProdElement(left, right, [])
--
--    cpdef Data data(self, t):
--        return self.qobj(t).data
--
--    cpdef object qobj(self, t):
--        out = self._base.qobj(t)
--        for func in self._transform:
--            out = func(out)
--        return out
--
--    cpdef object coeff(self, t):
--        return self._coeff
--
--    def linear_map(self, f, anti=False):
--        return _MapElement(
--            self._base,
--            self._transform + [f],
--            conj(self._coeff) if anti else self._coeff
--        )
--
--    def replace_arguments(_MapElement self, args, cache=None):
--        return _MapElement(
--            self._base.replace_arguments(args, cache=cache),
--            self._transform.copy(),
--            self._coeff,
--        )
--
--
--cdef class _ProdElement(_BaseElement):
--    """
--    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
--    :obj:`_BaseElement`. Include a stack of linear transformation to be
--    applied after the product::
--
--        ``op = QobjEvo(f) * qobj1``
--    Then ``op.elements`` is::
--        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
--    """
--    def __init__(self, left, right, transform, conj=False):
--        self._left = left
--        self._right = right
--        self._conj = conj
--        self._transform = transform
--
--    def __mul__(left, right):
--        cdef _ProdElement self
--        cdef double complex factor
--        if type(left) is _ProdElement:
--            self = left
--            factor = right
--        if type(right) is _ProdElement:
--            self = right
--            factor = left
--        return _ProdElement(self._left, self._right * factor,
--                            self._transform.copy(), self._conj)
--
--    def __matmul__(left, right):
--        return _ProdElement(left, right, [])
--
--    cpdef Data data(self, t):
--        return self.qobj(t).data
--
--    cpdef object qobj(self, t):
--        out = self._left.qobj(t) @ self._right.qobj(t)
--        for func in self._transform:
--            out = func(out)
--        return out
--
--    cpdef object coeff(self, t):
--        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
--        return conj(out) if self._conj else out
--
--    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
--        cdef Data temp
--        if not self._transform:
--            temp = self._right.matmul_data_t(t, state)
--            out = self._left.matmul_data_t(t, temp, out)
--            return out
--        elif type(state) is Dense and type(out) is Dense:
--            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
--            return out
--        else:
--            return _data.add(
--                out,
--                _data.matmul(self.data(t), state, self.coeff(t))
--            )
--
--    def linear_map(self, f, anti=False):
--        return _ProdElement(
--            self._left, self._right,
--            self._transform + [f],
--            self._conj ^ anti
--        )
--
--    def replace_arguments(_ProdElement self, args, cache=None):
--        return _ProdElement(
--            self._left.replace_arguments(args, cache=cache),
--            self._right.replace_arguments(args, cache=cache),
--            self._transform.copy(),
--            self._conj
--        )
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
-+
-+from .. import data as _data
-+from qutip.core.cy.coefficient import coefficient_function_parameters
-+from qutip.core.data cimport Dense, Data, dense
-+from qutip.core.data.matmul cimport *
-+from math import nan as Nan
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex conj(double complex x)
-+
-+__all__ = ['_ConstantElement', '_EvoElement',
-+           '_FuncElement', '_MapElement', '_ProdElement']
-+
-+
-+cdef class _BaseElement:
-+    """
-+    The representation of a single time-dependent term in the list of
-+    terms used by QobjEvo and solvers to describe operators.
-+
-+    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
-+    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
-+    are functions of time. :meth:`~_BaseElement.coeff` returns the
-+    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
-+
-+    For example, a :obj:`QobjEvo` instance created by::
-+
-+      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
-+
-+    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
-+    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
-+
-+    :obj:`~_BaseElement` defines the interface to time-dependent terms.
-+    Sub-classes implement terms defined in different ways.
-+    For example, :obj:`~_ConstantElement` implements a term that
-+    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
-+    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
-+    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
-+    so on.
-+
-+    .. note::
-+
-+      There are three methods to return the factors of the term.
-+
-+      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
-+      coefficient and operator factors respectively. They are separate to
-+      avoid constructing an intermediate Python object when called from
-+      Cython code (which may take as long as the rest of the call).
-+
-+      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
-+      provides a convenience method for this common operation.
-+
-+    .. note::
-+
-+      All :obj:`~_BaseElement` instances are immutable and methods that would
-+      modify an object return a new instance instead.
-+    """
-+    cpdef Data data(self, t):
-+        """
-+        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
-+        of the term at time ``t``.
-+
-+        Parameters
-+        ----------
-+        t : double
-+          The time, ``t``.
-+
-+        Returns
-+        -------
-+        :obj:`~Data`
-+          The underlying data of the :obj:`~Qobj` component of the term
-+          at time ``t``.
-+        """
-+        raise NotImplementedError(
-+          "Sub-classes of _BaseElement should implement .data(t)."
-+        )
-+
-+    cpdef object qobj(self, t):
-+        """
-+        Returns the :obj:`~Qobj` component of the term at time ``t``.
-+
-+        Parameters
-+        ----------
-+        t : float
-+          The time, ``t``.
-+
-+        Returns
-+        -------
-+        :obj:`~Qobj`
-+          The :obj:`~Qobj` component of the term at time ``t``.
-+        """
-+        raise NotImplementedError(
-+          "Sub-classes of _BaseElement should implement .qobj(t)."
-+        )
-+
-+    cpdef object coeff(self, t):
-+        """
-+        Returns the complex coefficient of the term at time ``t``.
-+
-+        Parameters
-+        ----------
-+        t : float
-+          The time, ``t``.
-+
-+        Returns
-+        -------
-+        complex
-+          The complex coefficient of the term at time ``t``.
-+        """
-+        raise NotImplementedError(
-+          "Sub-classes of _BaseElement should implement .coeff(t)."
-+        )
-+
-+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
-+        """
-+        Possibly in-place multiplication and addition. Multiplies a given state
-+        by the elemen's value at time ``t`` and adds the result to ``out``.
-+        Equivalent to::
-+
-+          out += self.coeff(t) * self.qobj(t) @ state
-+
-+        Sub-classes may override :meth:`~matmul_data_t` to provide an more
-+        efficient implementation.
-+
-+        Parameters
-+        ----------
-+        t : double
-+          The time, ``t``.
-+
-+        state : :obj:`~Data`
-+          The state to multiply by the element term.
-+
-+        out : :obj:`~Data` or ``NULL``
-+          The output to add the result of the multiplication to. If ``NULL``,
-+          the result of the multiplication is returned directly (i.e. ``out``
-+          is assumed to be the zero matrix).
-+
-+        Returns
-+        -------
-+        data
-+          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
-+          the addition possibly having been performed in-place on ``out``.
-+
-+        .. note::
-+
-+          Because of the possibly but not definitely in-place behaviour of
-+          this function, the result should always be assigned to some variable
-+          and surrounding code should assume that ``out`` maybe have been
-+          modified and that the result may be a reference to ``out``. The
-+          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
-+
-+        .. note::
-+
-+          This method would ideally be implemented using a special
-+          function dispatched by the data layer so that it did not have to
-+          special case the ``Dense`` operation itself, but the data layer
-+          dispatch does not yet support in-place operations. Once it does
-+          this method should be updated to use the new support.
-+        """
-+        if out is None:
-+            return _data.matmul(self.data(t), state, self.coeff(t))
-+        elif type(state) is Dense and type(out) is Dense:
-+            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
-+            return out
-+        else:
-+            return _data.add(
-+                out,
-+                _data.matmul(self.data(t), state, self.coeff(t))
-+            )
-+
-+    def linear_map(self, f, anti=False):
-+        """
-+        Return a new element representing a linear transformation ``f``
-+        of the :obj:`~Qobj` portion of this element and possibly a
-+        complex conjucation of the coefficient portion (when ``f`` is an
-+        antilinear map).
-+
-+        If this element represents ``coeff * qobj`` the returned element
-+        represents ``coeff * f(obj)`` (if ``anti=False``) or
-+        ``conj(coeff) * f(obj)`` (if ``anti=True``).
-+
-+        Parameters
-+        ----------
-+        f : function
-+          The linear transformation to apply to the :obj:`~Qobj` of this
-+          element.
-+        anti : bool
-+          Whether to take the complex conjugate of the coefficient. Default
-+          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
-+          map such as the adjoint (i.e. dagger).
-+
-+        Returns
-+        -------
-+        _BaseElement
-+          A new element with the transformation applied.
-+        """
-+        raise NotImplementedError(
-+          "Sub-classes of _BaseElement should implement .linear_map(t)."
-+        )
-+
-+    def replace_arguments(self, args, cache=None):
-+        """
-+        Return a copy of the element with the (possible) additional arguments
-+        to any time-dependent functions updated to the given argument values.
-+        The arguments of any contained :obj:`~Coefficient` instances are also
-+        replaced.
-+
-+        If the operation does not modify this element, the original element
-+        may be returned.
-+
-+        Parameters
-+        ----------
-+        args : dict
-+          A dictionary of arguments to update. Keys are the names of the
-+          arguments and values are the new argument values. Arguments
-+          not included retain their original values.
-+
-+        cache : list or ``None``
-+          A cache to add updated elements to. Unmodified elements are not
-+          added to the cache. If a cache is supplied and ``.replace_arguments``
-+          would be called again on the same element with the same arguments,
-+          the new element from the cache will be returned instead.
-+
-+          By default the cache is ``None`` and no caching is performed. Cache
-+          users should supply either ``cache=[]`` (which activates caching)
-+          or an existing cache (for example, if making calls on sub-elements
-+          of some composite element).
-+
-+        Returns
-+        -------
-+        _BaseElement
-+          A new element with the arguments replaced, or possibly this element
-+          if it would not be modified.
-+
-+        Example
-+        -------
-+
-+        If ``elem`` is a product element for ``op * op.dag()`` it will contain
-+        two references to the same element for ``op``. Calling::
-+
-+          elem = elem.replace_arguments({"theta": 3.1416})
-+
-+        will return a new element that contains two *different* copies of
-+        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
-+        to be evaluated *twice* when ``elem.qobj(t)`` is called.
-+
-+        Calling instead::
-+
-+          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
-+
-+        will return a new element that contains two references to *one* copy
-+        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
-+        performance when calling ``elem.qobj(t)`` later.
-+        """
-+        raise NotImplementedError(
-+          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
-+        )
-+
-+    def __call__(self, t, args=None):
-+        if args:
-+            cache = []
-+            self = self.replace_arguments(args, cache)
-+        return self.qobj(t) * self.coeff(t)
-+
-+
-+cdef class _ConstantElement(_BaseElement):
-+    """
-+    Constant part of a list format :obj:`QobjEvo`.
-+    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
-+
-+      qevo = QobjEvo(H0)
-+      qevo.elements = [_ConstantElement(H0)]
-+    """
-+    def __init__(self, qobj):
-+        self._qobj = qobj
-+
-+    def __mul__(left, right):
-+        if type(left) is _ConstantElement:
-+            return _ConstantElement((<_ConstantElement> left)._qobj * right)
-+        elif type(right) is _ConstantElement:
-+            return _ConstantElement((<_ConstantElement> right)._qobj * left)
-+        return NotImplemented
-+
-+    def __matmul__(left, right):
-+        if type(left) is _ConstantElement and type(right) is _ConstantElement:
-+            return _ConstantElement(
-+                (<_ConstantElement> left)._qobj @
-+                (<_ConstantElement> right)._qobj
-+            )
-+        return NotImplemented
-+
-+    cpdef Data data(self, t):
-+        return self._qobj.data
-+
-+    cpdef object qobj(self, t):
-+        return self._qobj
-+
-+    cpdef object coeff(self, t):
-+        return 1.
-+
-+    def linear_map(self, f, anti=False):
-+        return _ConstantElement(f(self._qobj))
-+
-+    def replace_arguments(self, args, cache=None):
-+        return self
-+
-+    def __call__(self, t, args=None):
-+        return self._qobj
-+
-+
-+cdef class _EvoElement(_BaseElement):
-+    """
-+    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
-+    time-dependent operator::
-+
-+      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
-+      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
-+    """
-+    def __init__(self, qobj, coefficient):
-+        self._qobj = qobj
-+        self._coefficient = coefficient
-+
-+    def __mul__(left, right):
-+        cdef _EvoElement base
-+        cdef object factor
-+        if type(left) is _EvoElement:
-+            base = left
-+            factor = right
-+        if type(right) is _EvoElement:
-+            base = right
-+            factor = left
-+        return _EvoElement(base._qobj * factor, base._coefficient)
-+
-+    def __matmul__(left, right):
-+        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
-+            coefficient = left._coefficient * right._coefficient
-+        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
-+            coefficient = left._coefficient
-+        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
-+            coefficient = right._coefficient
-+        else:
-+            return NotImplemented
-+        return _EvoElement(left._qobj * right._qobj, coefficient)
-+
-+    cpdef Data data(self, t):
-+        return self._qobj.data
-+
-+    cpdef object qobj(self, t):
-+        return self._qobj
-+
-+    cpdef object coeff(self, t):
-+        return self._coefficient(t)
-+
-+    def linear_map(self, f, anti=False):
-+        return _EvoElement(
-+            f(self._qobj),
-+            self._coefficient.conj() if anti else self._coefficient,
-+        )
-+
-+    def replace_arguments(self, args, cache=None):
-+        return _EvoElement(
-+            self._qobj.copy(),
-+            self._coefficient.replace_arguments(args)
-+        )
-+
-+
-+cdef class _FuncElement(_BaseElement):
-+    """
-+    Used with :obj:`QobjEvo` to build an evolution term from a function with
-+    either the signature: ::
-+
-+        func(t: float, ...) -> Qobj
-+
-+    or the older QuTiP 4 style signature: ::
-+
-+        func(t: float, args: dict) -> Qobj
-+
-+    In the new style, ``func`` may accept arbitrary named arguments and
-+    is called as ``func(t, **args)``.
-+
-+    A :obj:`QobjEvo` created from such a function contains one
-+    :obj:`_FuncElement`: ::
-+
-+        qevo = QobjEvo(func, args=args)
-+        qevo.elements = [_FuncElement(func, args)]
-+
-+    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
-+    of function and argument.
-+
-+    This class has a basic capacity to memoize calls to ``func`` by saving the
-+    result of the last call ::
-+
-+        op = QobjEvo(func, args=args)
-+        (op.dag() * op)(t)
-+
-+    calls ``func`` only once.
-+
-+    Parameters
-+    ----------
-+    func : callable(t : float, ...) -> Qobj
-+        Function returning the element value at time ``t``.
-+
-+    args : dict
-+        Values of the arguments to pass to ``func``.
-+
-+    style : {None, "pythonic", "dict", "auto"}
-+        The style of the signature used. If style is ``None``,
-+        the value of ``qutip.settings.core["function_coefficient_style"]``
-+        is used. Otherwise the supplied value overrides the global setting.
-+
-+    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
-+    style and parameter detection and are not intended to be part of
-+    the public interface.
-+    """
-+
-+    _UNSET = object()
-+
-+    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
-+        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
-+            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
-+                raise TypeError(
-+                    "_f_pythonic and _f_parameters should always be given together."
-+                )
-+            _f_pythonic, _f_parameters = coefficient_function_parameters(
-+                func, style=style)
-+            if _f_parameters is not None:
-+                args = {k: args[k] for k in _f_parameters & args.keys()}
-+            else:
-+                args = args.copy()
-+        self._func = func
-+        self._args = args
-+        self._f_pythonic = _f_pythonic
-+        self._f_parameters = _f_parameters
-+        self._previous = (Nan, None)
-+
-+    def __mul__(left, right):
-+        cdef _MapElement out
-+        if type(left) is _FuncElement:
-+            out = _MapElement(left, [], right)
-+        if type(right) is _FuncElement:
-+            out = _MapElement(right, [], left)
-+        return out
-+
-+    def __matmul__(left, right):
-+        return _ProdElement(left, right, [])
-+
-+    cpdef Data data(self, t):
-+        return self.qobj(t).data
-+
-+    cpdef object qobj(self, t):
-+        cdef double _t
-+        cdef object _qobj
-+        _t, _qobj = self._previous
-+        if t == _t:
-+            return _qobj
-+        if self._f_pythonic:
-+            _qobj = self._func(t, **self._args)
-+        else:
-+            _qobj = self._func(t, self._args)
-+        self._previous = (t, _qobj)
-+        return _qobj
-+
-+    cpdef object coeff(self, t):
-+        return 1.
-+
-+    def linear_map(self, f, anti=False):
-+        return _MapElement(self, [f])
-+
-+    def replace_arguments(_FuncElement self, args, cache=None):
-+        if self._f_parameters is not None:
-+            args = {k: args[k] for k in self._f_parameters & args.keys()}
-+        if not args:
-+            return self
-+        if cache is not None:
-+            for old, new in cache:
-+                if old is self:
-+                    return new
-+        new = _FuncElement(
-+                self._func,
-+                {**self._args, **args},
-+                _f_pythonic=self._f_pythonic,
-+                _f_parameters=self._f_parameters,
-+        )
-+        if cache is not None:
-+            cache.append((self, new))
-+        return new
-+
-+
-+cdef class _MapElement(_BaseElement):
-+    """
-+    :obj:`_FuncElement` decorated with linear tranformations.
-+
-+    Linear tranformations available in :obj:`QobjEvo` include transpose,
-+    adjoint, conjugate, convertion and product with number::
-+    ```
-+        op = QobjEvo(f, args=args)
-+        op2 = op.conj().dag() * 2
-+    ```
-+    Then ``op2.elements`` is::
-+        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
-+
-+    """
-+    def __init__(self, _FuncElement base, transform, coeff=1.):
-+        self._base = base
-+        self._transform = transform
-+        self._coeff = coeff
-+
-+    def __mul__(left, right):
-+        cdef _MapElement out, self
-+        cdef double complex factor
-+        if type(left) is _MapElement:
-+            self = left
-+            factor = right
-+        elif type(right) is _MapElement:
-+            self = right
-+            factor = left
-+        return _MapElement(
-+            self._base,
-+            self._transform.copy(),
-+            self._coeff*factor
-+        )
-+
-+    def __matmul__(left, right):
-+        return _ProdElement(left, right, [])
-+
-+    cpdef Data data(self, t):
-+        return self.qobj(t).data
-+
-+    cpdef object qobj(self, t):
-+        out = self._base.qobj(t)
-+        for func in self._transform:
-+            out = func(out)
-+        return out
-+
-+    cpdef object coeff(self, t):
-+        return self._coeff
-+
-+    def linear_map(self, f, anti=False):
-+        return _MapElement(
-+            self._base,
-+            self._transform + [f],
-+            conj(self._coeff) if anti else self._coeff
-+        )
-+
-+    def replace_arguments(_MapElement self, args, cache=None):
-+        return _MapElement(
-+            self._base.replace_arguments(args, cache=cache),
-+            self._transform.copy(),
-+            self._coeff,
-+        )
-+
-+
-+cdef class _ProdElement(_BaseElement):
-+    """
-+    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
-+    :obj:`_BaseElement`. Include a stack of linear transformation to be
-+    applied after the product::
-+
-+        ``op = QobjEvo(f) * qobj1``
-+    Then ``op.elements`` is::
-+        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
-+    """
-+    def __init__(self, left, right, transform, conj=False):
-+        self._left = left
-+        self._right = right
-+        self._conj = conj
-+        self._transform = transform
-+
-+    def __mul__(left, right):
-+        cdef _ProdElement self
-+        cdef double complex factor
-+        if type(left) is _ProdElement:
-+            self = left
-+            factor = right
-+        if type(right) is _ProdElement:
-+            self = right
-+            factor = left
-+        return _ProdElement(self._left, self._right * factor,
-+                            self._transform.copy(), self._conj)
-+
-+    def __matmul__(left, right):
-+        return _ProdElement(left, right, [])
-+
-+    cpdef Data data(self, t):
-+        return self.qobj(t).data
-+
-+    cpdef object qobj(self, t):
-+        out = self._left.qobj(t) @ self._right.qobj(t)
-+        for func in self._transform:
-+            out = func(out)
-+        return out
-+
-+    cpdef object coeff(self, t):
-+        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
-+        return conj(out) if self._conj else out
-+
-+    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
-+        cdef Data temp
-+        if not self._transform:
-+            temp = self._right.matmul_data_t(t, state)
-+            out = self._left.matmul_data_t(t, temp, out)
-+            return out
-+        elif type(state) is Dense and type(out) is Dense:
-+            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
-+            return out
-+        else:
-+            return _data.add(
-+                out,
-+                _data.matmul(self.data(t), state, self.coeff(t))
-+            )
-+
-+    def linear_map(self, f, anti=False):
-+        return _ProdElement(
-+            self._left, self._right,
-+            self._transform + [f],
-+            self._conj ^ anti
-+        )
-+
-+    def replace_arguments(_ProdElement self, args, cache=None):
-+        return _ProdElement(
-+            self._left.replace_arguments(args, cache=cache),
-+            self._right.replace_arguments(args, cache=cache),
-+            self._transform.copy(),
-+            self._conj
-+        )
-diff --git a/qutip/core/cy/coefficient.pxd b/qutip/core/cy/coefficient.pxd
-index f81858c2..c4824b7d 100644
---- a/qutip/core/cy/coefficient.pxd
-+++ b/qutip/core/cy/coefficient.pxd
-@@ -1,5 +1,5 @@
--#cython: language_level=3
--cdef class Coefficient:
--    cdef readonly dict args
--    cdef double complex _call(self, double t) except *
--    cpdef Coefficient copy(self)
-+#cython: language_level=3
-+cdef class Coefficient:
-+    cdef readonly dict args
-+    cdef double complex _call(self, double t) except *
-+    cpdef Coefficient copy(self)
-diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
-index 79fd84e5..b2755c3a 100644
---- a/qutip/core/cy/coefficient.pyx
-+++ b/qutip/core/cy/coefficient.pyx
-@@ -1,728 +1,728 @@
--#cython: language_level=3
--import inspect
--import pickle
--import scipy
--from scipy.interpolate import make_interp_spline
--import numpy as np
--cimport numpy as cnp
--cimport cython
--import qutip
--
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex conj(double complex x)
--    double         norm(double complex x)
--
--
--def coefficient_function_parameters(func, style=None):
--    """
--    Return the function style (either "pythonic" or not) and a list of
--    additional parameters accepted.
--
--    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
--    call signature of the supplied function based on the given style (or
--    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
--    and the signature of the given function.
--
--    Parameters
--    ----------
--    func : function
--        The :obj:`FunctionCoefficient` to inspect. The first argument
--        of the function is assumed to be ``t`` (the time at which to
--        evaluate the coefficient). The remaining arguments depend on
--        the signature style (see below).
--
--    style : {None, "pythonic", "dict", "auto"}
--        The style of the signature used. If style is ``None``,
--        the value of ``qutip.settings.core["function_coefficient_style"]``
--        is used. Otherwise the supplied value overrides the global setting.
--
--    Returns
--    -------
--    (f_pythonic, f_parameters)
--
--    f_pythonic : bool
--        True if the function should be called as ``f(t, **kw)`` and False
--        if the function should be called as ``f(t, kw_dict)``.
--
--    f_parameters : set or None
--        The set of parameters (other than ``t``) of the function or
--        ``None`` if the function accepts arbitrary parameters.
--    """
--    sig = inspect.signature(func)
--    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
--    if style is None:
--        style = qutip.settings.core["function_coefficient_style"]
--    if style == "auto":
--        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
--            # if the signature is exactly f(t, args), then assume parameters
--            # are supplied in an argument dictionary
--            style = "dict"
--        else:
--            style = "pythonic"
--    if style == "dict" or f_has_kw:
--        # f might accept any parameter
--        f_parameters = None
--    else:
--        # f accepts only t and the named parameters
--        f_parameters = set(list(sig.parameters.keys())[1:])
--    return (style == "pythonic", f_parameters)
--
--
--cdef class Coefficient:
--    """
--    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
--    composing time-dependant operator in list format for :obj:`QobjEvo`.
--
--    :obj:`Coefficient` are immutable.
--    """
--    def __init__(self, args, **_):
--        self.args = args
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        return self
--
--    def __call__(self, t, dict _args=None, **kwargs):
--        """
--        Return the coefficient value at time `t`.
--        Stored arguments can overwriten with `_args` or as keywords parameters.
--
--        Parameters
--        ----------
--        t : float
--            Time at which to evaluate the :obj:`Coefficient`.
--
--        _args : dict
--            Dictionary of arguments to use instead of the stored ones.
--
--        **kwargs
--            Arguments to overwrite for this call.
--        """
--        if _args is not None or kwargs:
--            return (<Coefficient> self.replace_arguments(_args,
--                                                         **kwargs))._call(t)
--        return self._call(t)
--
--    cdef double complex _call(self, double t) except *:
--        """Core computation of the :obj:`Coefficient`."""
--        # All Coefficient sub-classes should overwrite this or __call__
--        return complex(self(t))
--
--    def __add__(left, right):
--        if (
--            isinstance(left, InterCoefficient)
--            and isinstance(right, InterCoefficient)
--        ):
--            return add_inter(left, right)
--        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
--            return SumCoefficient(left.copy(), right.copy())
--        return NotImplemented
--
--    def __mul__(left, right):
--        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
--            return MulCoefficient(left.copy(), right.copy())
--        if isinstance(left, qutip.Qobj):
--            return qutip.QobjEvo([left.copy(), right.copy()])
--        if isinstance(right, qutip.Qobj):
--            return qutip.QobjEvo([right.copy(), left.copy()])
--        return NotImplemented
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return pickle.loads(pickle.dumps(self))
--
--    def conj(self):
--        """ Return a conjugate :obj:`Coefficient` of this"""
--        return ConjCoefficient(self)
--
--    def _cdc(self):
--        """ Return a :obj:`Coefficient` being the norm of this"""
--        return NormCoefficient(self)
--
--
--@cython.auto_pickle(True)
--cdef class FunctionCoefficient(Coefficient):
--    """
--    :obj:`Coefficient` wrapping a Python function.
--
--    Parameters
--    ----------
--    func : callable(t : float, ...) -> complex
--        Function returning the coefficient value at time ``t``.
--
--    args : dict
--        Values of the arguments to pass to ``func``.
--
--    style : {None, "pythonic", "dict", "auto"}
--        The style of function signature used. If style is ``None``,
--        the value of ``qutip.settings.core["function_coefficient_style"]``
--        is used. Otherwise the supplied value overrides the global setting.
--
--    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
--    style and parameter detection and are not intended to be part of
--    the public interface.
--    """
--    cdef object func
--    cdef bint _f_pythonic
--    cdef set _f_parameters
--
--    _UNSET = object()
--
--    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
--                 _f_parameters=_UNSET, **_):
--        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
--            if not (_f_pythonic is self._UNSET
--                    and _f_parameters is self._UNSET):
--                raise TypeError(
--                    "_f_pythonic and _f_parameters should "
--                    "always be given together."
--                )
--            _f_pythonic, _f_parameters = coefficient_function_parameters(
--                func, style=style)
--            if _f_parameters is not None:
--                args = {k: args[k] for k in _f_parameters & args.keys()}
--            else:
--                args = args.copy()
--        self.func = func
--        self.args = args
--        self._f_pythonic = _f_pythonic
--        self._f_parameters = _f_parameters
--
--    def __call__(self, t, dict _args=None, **kwargs):
--        if _args is not None or kwargs:
--            return self.replace_arguments(_args, **kwargs)(t)
--        if self._f_pythonic:
--            return self.func(t, **self.args)
--        return self.func(t, self.args)
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return FunctionCoefficient(
--            self.func,
--            self.args.copy(),
--            _f_pythonic=self._f_pythonic,
--            _f_parameters=self._f_parameters,
--        )
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        if _args:
--            kwargs.update(_args)
--        if self._f_parameters is not None:
--            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
--        if not kwargs:
--            return self
--        return FunctionCoefficient(
--            self.func,
--            {**self.args, **kwargs},
--            _f_pythonic=self._f_pythonic,
--            _f_parameters=self._f_parameters,
--        )
--
--
--def proj(x):
--    if np.isfinite(x):
--        return (x)
--    else:
--        return np.inf + 0j * np.imag(x)
--
--
--cdef class StrFunctionCoefficient(Coefficient):
--    """
--    A :obj:`Coefficient` defined by a string containing a simple Python
--    expression.
--
--    The string should contain a compilable Python expression that results in a
--    complex number. The time ``t`` is available as a local variable, as are the
--    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
--    itself is not accessible.
--
--    The following symbols are defined:
--        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
--        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
--        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
--        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
--        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
--
--    Examples
--    --------
--    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
--
--    Parameters
--    ----------
--    base : str
--        A string representing a compilable Python expression that results in a
--        complex number.
--
--    args : dict
--        A dictionary of variable used in the code string. It may include unused
--        variables.
--    """
--    cdef object func
--    cdef str base
--
--    str_env = {
--        "sin": np.sin,
--        "cos": np.cos,
--        "tan": np.tan,
--        "asin": np.arcsin,
--        "acos": np.arccos,
--        "atan": np.arctan,
--        "pi": np.pi,
--        "sinh": np.sinh,
--        "cosh": np.cosh,
--        "tanh": np.tanh,
--        "asinh": np.arcsinh,
--        "acosh": np.arccosh,
--        "atanh": np.arctanh,
--        "exp": np.exp,
--        "log": np.log,
--        "log10": np.log10,
--        "erf": scipy.special.erf,
--        "zerf": scipy.special.erf,
--        "sqrt": np.sqrt,
--        "real": np.real,
--        "imag": np.imag,
--        "conj": np.conj,
--        "abs": np.abs,
--        "norm": lambda x: np.abs(x)**2,
--        "arg": np.angle,
--        "proj": proj,
--        "np": np,
--        "spe": scipy.special}
--
--    def __init__(self, base, dict args, **_):
--        args2var = "\n".join(["    {} = args['{}']".format(key, key)
--                              for key in args])
--        code = f"""
--def coeff(t, args):
--{args2var}
--    return {base}"""
--        lc = {}
--        exec(code, self.str_env, lc)
--        self.base = base
--        self.func = lc["coeff"]
--        self.args = args
--
--    cdef complex _call(self, double t) except *:
--        return self.func(t, self.args)
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return StrFunctionCoefficient(self.base, self.args.copy())
--
--    def __reduce__(self):
--        return (StrFunctionCoefficient, (self.base, self.args))
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        if _args:
--            kwargs.update(_args)
--        if kwargs:
--            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
--        return self
--
--
--cdef class InterCoefficient(Coefficient):
--    """
--    A :obj:`Coefficient` built from an interpolation of a numpy array.
--
--    Parameters
--    ----------
--    coeff_arr : np.ndarray
--        The array of coefficient values to interpolate.
--
--    tlist : np.ndarray
--        An array of times corresponding to each coefficient value. The times
--        must be increasing, but do not need to be uniformly spaced.
--
--    order : int
--        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
--        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
--
--    boundary_conditions : 2-Tuple, str or None, optional
--        Boundary conditions for spline evaluation. Default value is `None`.
--        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
--        Refer to Scipy's documentation for further details:
--        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
--    """
--    cdef int order
--    cdef double dt
--    cdef double[::1] tlist
--    cdef complex[:, :] poly
--    cdef object np_arrays
--
--    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
--        tlist = np.array(tlist, dtype=np.float64)
--        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
--
--        if coeff_arr.ndim != 1:
--            raise ValueError("The array to interpolate must be a 1D array")
--        if coeff_arr.shape != tlist.shape:
--            raise ValueError("tlist must be the same len "
--                             "as the array to interpolate")
--        if order < 0:
--            raise ValueError("order must be a positive integer")
--
--        order = min(order, len(tlist) - 1)
--
--        if order == 0:
--            coeff_arr = coeff_arr.reshape((1, -1))
--        elif order == 1:
--            coeff_arr = np.vstack([
--                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
--                    coeff_arr
--                ])
--        elif order >= 2:
--            # Use scipy to compute the spline and transform it to polynomes
--            # as used in scipy's PPoly which is easier for us to use.
--            spline = make_interp_spline(tlist, coeff_arr, k=order,
--                                        bc_type=boundary_conditions)
--            # Scipy can move knots, we add them to tlist
--            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
--            a = np.arange(spline.k+1)
--            a[0] = 1
--            fact = np.cumprod(a)
--            coeff_arr = np.concatenate([
--                spline(tlist, i) / fact[i]
--                for i in range(spline.k, -1, -1)
--            ]).reshape((spline.k+1, -1))
--
--        self._prepare(tlist, coeff_arr)
--
--    def _prepare(self, np_tlist, np_poly, dt=None):
--        self.np_arrays = (np_tlist, np_poly)
--        self.tlist = np_tlist
--        self.poly = np_poly
--        self.order = self.poly.shape[0] - 1
--        diff = np.diff(self.np_arrays[0])
--        if dt is not None:
--            self.dt = dt
--        elif len(diff) >= 1 and np.allclose(diff[0], diff):
--            self.dt = diff[0]
--        else:
--            self.dt = 0
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef size_t _binary_search(self, double x):
--        # Binary search for the interval
--        # return the indice of the of the biggest element where t <= x
--        cdef size_t low = 0
--        cdef size_t high = self.tlist.shape[0]
--        cdef size_t middle
--        cdef size_t count = 0
--        while low+1 != high and count < 64:
--            middle = (low + high)//2
--            if x < self.tlist[middle]:
--                high = middle
--            else:
--                low = middle
--            # We keep a count to be sure that it never get into an infinit loop
--            # even if tlist has an unexpected format.
--            count += 1
--        return low
--
--    @cython.initializedcheck(False)
--    @cython.cdivision(True)
--    cdef double complex _call(self, double t) except *:
--        cdef size_t idx, i
--        cdef double factor
--        cdef double complex out
--        cdef double complex[:] slice
--        if t <= self.tlist[0]:
--            return self.poly[-1, 0]
--        elif t >= self.tlist[-1]:
--            return self.poly[-1, -1]
--        if self.dt:
--            idx = <size_t>((t - self.tlist[0]) / self.dt)
--        else:
--            idx = self._binary_search(t)
--        if self.order == 0:
--            out = self.poly[0, idx]
--        else:
--            factor = t - self.tlist[idx]
--            slice = self.poly[:, idx]
--            out = 0.
--            for i in range(self.order+1):
--                out *= factor
--                out += slice[i]
--        return out
--
--    def __reduce__(self):
--        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
--
--    @classmethod
--    def restore(cls, np_tlist, np_poly, dt=None):
--        cdef InterCoefficient out = cls.__new__(cls)
--        out._prepare(np_tlist, np_poly, dt)
--        return out
--
--    @classmethod
--    def from_PPoly(cls, ppoly, **_):
--        return cls.restore(ppoly.x, ppoly.c)
--
--    @classmethod
--    def from_Bspline(cls, spline, **_):
--        tlist = np.unique(spline.t)
--        a = np.arange(spline.k+1)
--        a[0] = 1
--        fact = np.cumprod(a) + 0j
--        poly = np.concatenate([
--            spline(tlist, i) / fact[i]
--            for i in range(spline.k, -1, -1)
--        ]).reshape((spline.k+1, -1))
--        return cls.restore(tlist, poly)
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return InterCoefficient.restore(*self.np_arrays, self.dt)
--
--
--cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
--    """ Add two array coefficient with matching tlist into one."""
--    if (
--        left.np_arrays[0].shape == right.np_arrays[0].shape
--        and np.allclose(left.np_arrays[0], right.np_arrays[0],
--                        rtol=1e-15, atol=1e-15)
--        and (left.order == right.order)
--    ):
--        return InterCoefficient.restore(
--            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
--            left.dt
--        )
--    else:
--        # It would be possible to add them by merging tlist.
--        return SumCoefficient(left, right)
--
--
--@cython.auto_pickle(True)
--cdef class SumCoefficient(Coefficient):
--    """
--    A :obj:`Coefficient` built from the sum of two other coefficients.
--
--    A :obj:`SumCoefficient` is returned as the result of the addition of two
--    coefficients, e.g. ::
--
--        coefficient("t * t") + coefficient("t")  # SumCoefficient
--    """
--    cdef Coefficient first
--    cdef Coefficient second
--
--    def __init__(self, Coefficient first, Coefficient second):
--        self.first = first
--        self.second = second
--
--    cdef complex _call(self, double t) except *:
--        return self.first._call(t) + self.second._call(t)
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return SumCoefficient(self.first.copy(), self.second.copy())
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        return SumCoefficient(
--            self.first.replace_arguments(_args, **kwargs),
--            self.second.replace_arguments(_args, **kwargs)
--        )
--
--
--@cython.auto_pickle(True)
--cdef class MulCoefficient(Coefficient):
--    """
--    A :obj:`Coefficient` built from the product of two other coefficients.
--
--    A :obj:`MulCoefficient` is returned as the result of the multiplication of
--    two coefficients, e.g. ::
--
--        coefficient("w * t", args={'w': 1}) * coefficient("t")
--    """
--    cdef Coefficient first
--    cdef Coefficient second
--
--    def __init__(self, Coefficient first, Coefficient second):
--        self.first = first
--        self.second = second
--
--    cdef complex _call(self, double t) except *:
--        return self.first._call(t) * self.second._call(t)
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return MulCoefficient(self.first.copy(), self.second.copy())
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        return MulCoefficient(
--            self.first.replace_arguments(_args, **kwargs),
--            self.second.replace_arguments(_args, **kwargs)
--        )
--
--
--@cython.auto_pickle(True)
--cdef class ConjCoefficient(Coefficient):
--    """
--    The conjugate of a :obj:`Coefficient`.
--
--    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
--    ``qutip.coefficent.conj(Coefficient)``.
--    """
--    cdef Coefficient base
--
--    def __init__(self, Coefficient base):
--        self.base = base
--
--    cdef complex _call(self, double t) except *:
--        return conj(self.base._call(t))
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return ConjCoefficient(self.base.copy())
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        return ConjCoefficient(
--            self.base.replace_arguments(_args, **kwargs)
--        )
--
--
--@cython.auto_pickle(True)
--cdef class NormCoefficient(Coefficient):
--    """
--    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
--    ``conj(coeff) * coeff``.
--
--    :obj:`NormCoefficient` is returned by
--    ``qutip.coefficent.norm(Coefficient)``.
--    """
--    cdef Coefficient base
--
--    def __init__(self, Coefficient base):
--        self.base = base
--
--    def replace_arguments(self, _args=None, **kwargs):
--        """
--        Replace the arguments (``args``) of a coefficient.
--
--        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
--        the original coefficient if it does not. Arguments to replace may be
--        supplied either in a dictionary as the first position argument, or
--        passed as keywords, or as a combination of the two. Arguments not
--        replaced retain their previous values.
--
--        Parameters
--        ----------
--        _args : dict
--            Dictionary of arguments to replace.
--
--        **kwargs
--            Arguments to replace.
--        """
--        return NormCoefficient(
--            self.base.replace_arguments(_args, **kwargs)
--        )
--
--    cdef complex _call(self, double t) except *:
--        return norm(self.base._call(t))
--
--    cpdef Coefficient copy(self):
--        """Return a copy of the :obj:`Coefficient`."""
--        return NormCoefficient(self.base.copy())
-+#cython: language_level=3
-+import inspect
-+import pickle
-+import scipy
-+from scipy.interpolate import make_interp_spline
-+import numpy as np
-+cimport numpy as cnp
-+cimport cython
-+import qutip
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex conj(double complex x)
-+    double         norm(double complex x)
-+
-+
-+def coefficient_function_parameters(func, style=None):
-+    """
-+    Return the function style (either "pythonic" or not) and a list of
-+    additional parameters accepted.
-+
-+    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
-+    call signature of the supplied function based on the given style (or
-+    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
-+    and the signature of the given function.
-+
-+    Parameters
-+    ----------
-+    func : function
-+        The :obj:`FunctionCoefficient` to inspect. The first argument
-+        of the function is assumed to be ``t`` (the time at which to
-+        evaluate the coefficient). The remaining arguments depend on
-+        the signature style (see below).
-+
-+    style : {None, "pythonic", "dict", "auto"}
-+        The style of the signature used. If style is ``None``,
-+        the value of ``qutip.settings.core["function_coefficient_style"]``
-+        is used. Otherwise the supplied value overrides the global setting.
-+
-+    Returns
-+    -------
-+    (f_pythonic, f_parameters)
-+
-+    f_pythonic : bool
-+        True if the function should be called as ``f(t, **kw)`` and False
-+        if the function should be called as ``f(t, kw_dict)``.
-+
-+    f_parameters : set or None
-+        The set of parameters (other than ``t``) of the function or
-+        ``None`` if the function accepts arbitrary parameters.
-+    """
-+    sig = inspect.signature(func)
-+    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
-+    if style is None:
-+        style = qutip.settings.core["function_coefficient_style"]
-+    if style == "auto":
-+        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
-+            # if the signature is exactly f(t, args), then assume parameters
-+            # are supplied in an argument dictionary
-+            style = "dict"
-+        else:
-+            style = "pythonic"
-+    if style == "dict" or f_has_kw:
-+        # f might accept any parameter
-+        f_parameters = None
-+    else:
-+        # f accepts only t and the named parameters
-+        f_parameters = set(list(sig.parameters.keys())[1:])
-+    return (style == "pythonic", f_parameters)
-+
-+
-+cdef class Coefficient:
-+    """
-+    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
-+    composing time-dependant operator in list format for :obj:`QobjEvo`.
-+
-+    :obj:`Coefficient` are immutable.
-+    """
-+    def __init__(self, args, **_):
-+        self.args = args
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        return self
-+
-+    def __call__(self, t, dict _args=None, **kwargs):
-+        """
-+        Return the coefficient value at time `t`.
-+        Stored arguments can overwriten with `_args` or as keywords parameters.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time at which to evaluate the :obj:`Coefficient`.
-+
-+        _args : dict
-+            Dictionary of arguments to use instead of the stored ones.
-+
-+        **kwargs
-+            Arguments to overwrite for this call.
-+        """
-+        if _args is not None or kwargs:
-+            return (<Coefficient> self.replace_arguments(_args,
-+                                                         **kwargs))._call(t)
-+        return self._call(t)
-+
-+    cdef double complex _call(self, double t) except *:
-+        """Core computation of the :obj:`Coefficient`."""
-+        # All Coefficient sub-classes should overwrite this or __call__
-+        return complex(self(t))
-+
-+    def __add__(left, right):
-+        if (
-+            isinstance(left, InterCoefficient)
-+            and isinstance(right, InterCoefficient)
-+        ):
-+            return add_inter(left, right)
-+        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
-+            return SumCoefficient(left.copy(), right.copy())
-+        return NotImplemented
-+
-+    def __mul__(left, right):
-+        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
-+            return MulCoefficient(left.copy(), right.copy())
-+        if isinstance(left, qutip.Qobj):
-+            return qutip.QobjEvo([left.copy(), right.copy()])
-+        if isinstance(right, qutip.Qobj):
-+            return qutip.QobjEvo([right.copy(), left.copy()])
-+        return NotImplemented
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return pickle.loads(pickle.dumps(self))
-+
-+    def conj(self):
-+        """ Return a conjugate :obj:`Coefficient` of this"""
-+        return ConjCoefficient(self)
-+
-+    def _cdc(self):
-+        """ Return a :obj:`Coefficient` being the norm of this"""
-+        return NormCoefficient(self)
-+
-+
-+@cython.auto_pickle(True)
-+cdef class FunctionCoefficient(Coefficient):
-+    """
-+    :obj:`Coefficient` wrapping a Python function.
-+
-+    Parameters
-+    ----------
-+    func : callable(t : float, ...) -> complex
-+        Function returning the coefficient value at time ``t``.
-+
-+    args : dict
-+        Values of the arguments to pass to ``func``.
-+
-+    style : {None, "pythonic", "dict", "auto"}
-+        The style of function signature used. If style is ``None``,
-+        the value of ``qutip.settings.core["function_coefficient_style"]``
-+        is used. Otherwise the supplied value overrides the global setting.
-+
-+    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
-+    style and parameter detection and are not intended to be part of
-+    the public interface.
-+    """
-+    cdef object func
-+    cdef bint _f_pythonic
-+    cdef set _f_parameters
-+
-+    _UNSET = object()
-+
-+    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
-+                 _f_parameters=_UNSET, **_):
-+        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
-+            if not (_f_pythonic is self._UNSET
-+                    and _f_parameters is self._UNSET):
-+                raise TypeError(
-+                    "_f_pythonic and _f_parameters should "
-+                    "always be given together."
-+                )
-+            _f_pythonic, _f_parameters = coefficient_function_parameters(
-+                func, style=style)
-+            if _f_parameters is not None:
-+                args = {k: args[k] for k in _f_parameters & args.keys()}
-+            else:
-+                args = args.copy()
-+        self.func = func
-+        self.args = args
-+        self._f_pythonic = _f_pythonic
-+        self._f_parameters = _f_parameters
-+
-+    def __call__(self, t, dict _args=None, **kwargs):
-+        if _args is not None or kwargs:
-+            return self.replace_arguments(_args, **kwargs)(t)
-+        if self._f_pythonic:
-+            return self.func(t, **self.args)
-+        return self.func(t, self.args)
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return FunctionCoefficient(
-+            self.func,
-+            self.args.copy(),
-+            _f_pythonic=self._f_pythonic,
-+            _f_parameters=self._f_parameters,
-+        )
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        if _args:
-+            kwargs.update(_args)
-+        if self._f_parameters is not None:
-+            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
-+        if not kwargs:
-+            return self
-+        return FunctionCoefficient(
-+            self.func,
-+            {**self.args, **kwargs},
-+            _f_pythonic=self._f_pythonic,
-+            _f_parameters=self._f_parameters,
-+        )
-+
-+
-+def proj(x):
-+    if np.isfinite(x):
-+        return (x)
-+    else:
-+        return np.inf + 0j * np.imag(x)
-+
-+
-+cdef class StrFunctionCoefficient(Coefficient):
-+    """
-+    A :obj:`Coefficient` defined by a string containing a simple Python
-+    expression.
-+
-+    The string should contain a compilable Python expression that results in a
-+    complex number. The time ``t`` is available as a local variable, as are the
-+    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
-+    itself is not accessible.
-+
-+    The following symbols are defined:
-+        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
-+        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
-+        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
-+        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
-+        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
-+
-+    Examples
-+    --------
-+    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
-+
-+    Parameters
-+    ----------
-+    base : str
-+        A string representing a compilable Python expression that results in a
-+        complex number.
-+
-+    args : dict
-+        A dictionary of variable used in the code string. It may include unused
-+        variables.
-+    """
-+    cdef object func
-+    cdef str base
-+
-+    str_env = {
-+        "sin": np.sin,
-+        "cos": np.cos,
-+        "tan": np.tan,
-+        "asin": np.arcsin,
-+        "acos": np.arccos,
-+        "atan": np.arctan,
-+        "pi": np.pi,
-+        "sinh": np.sinh,
-+        "cosh": np.cosh,
-+        "tanh": np.tanh,
-+        "asinh": np.arcsinh,
-+        "acosh": np.arccosh,
-+        "atanh": np.arctanh,
-+        "exp": np.exp,
-+        "log": np.log,
-+        "log10": np.log10,
-+        "erf": scipy.special.erf,
-+        "zerf": scipy.special.erf,
-+        "sqrt": np.sqrt,
-+        "real": np.real,
-+        "imag": np.imag,
-+        "conj": np.conj,
-+        "abs": np.abs,
-+        "norm": lambda x: np.abs(x)**2,
-+        "arg": np.angle,
-+        "proj": proj,
-+        "np": np,
-+        "spe": scipy.special}
-+
-+    def __init__(self, base, dict args, **_):
-+        args2var = "\n".join(["    {} = args['{}']".format(key, key)
-+                              for key in args])
-+        code = f"""
-+def coeff(t, args):
-+{args2var}
-+    return {base}"""
-+        lc = {}
-+        exec(code, self.str_env, lc)
-+        self.base = base
-+        self.func = lc["coeff"]
-+        self.args = args
-+
-+    cdef complex _call(self, double t) except *:
-+        return self.func(t, self.args)
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return StrFunctionCoefficient(self.base, self.args.copy())
-+
-+    def __reduce__(self):
-+        return (StrFunctionCoefficient, (self.base, self.args))
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        if _args:
-+            kwargs.update(_args)
-+        if kwargs:
-+            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
-+        return self
-+
-+
-+cdef class InterCoefficient(Coefficient):
-+    """
-+    A :obj:`Coefficient` built from an interpolation of a numpy array.
-+
-+    Parameters
-+    ----------
-+    coeff_arr : np.ndarray
-+        The array of coefficient values to interpolate.
-+
-+    tlist : np.ndarray
-+        An array of times corresponding to each coefficient value. The times
-+        must be increasing, but do not need to be uniformly spaced.
-+
-+    order : int
-+        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
-+        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
-+
-+    boundary_conditions : 2-Tuple, str or None, optional
-+        Boundary conditions for spline evaluation. Default value is `None`.
-+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
-+        Refer to Scipy's documentation for further details:
-+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-+    """
-+    cdef int order
-+    cdef double dt
-+    cdef double[::1] tlist
-+    cdef complex[:, :] poly
-+    cdef object np_arrays
-+
-+    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
-+        tlist = np.array(tlist, dtype=np.float64)
-+        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
-+
-+        if coeff_arr.ndim != 1:
-+            raise ValueError("The array to interpolate must be a 1D array")
-+        if coeff_arr.shape != tlist.shape:
-+            raise ValueError("tlist must be the same len "
-+                             "as the array to interpolate")
-+        if order < 0:
-+            raise ValueError("order must be a positive integer")
-+
-+        order = min(order, len(tlist) - 1)
-+
-+        if order == 0:
-+            coeff_arr = coeff_arr.reshape((1, -1))
-+        elif order == 1:
-+            coeff_arr = np.vstack([
-+                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
-+                    coeff_arr
-+                ])
-+        elif order >= 2:
-+            # Use scipy to compute the spline and transform it to polynomes
-+            # as used in scipy's PPoly which is easier for us to use.
-+            spline = make_interp_spline(tlist, coeff_arr, k=order,
-+                                        bc_type=boundary_conditions)
-+            # Scipy can move knots, we add them to tlist
-+            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
-+            a = np.arange(spline.k+1)
-+            a[0] = 1
-+            fact = np.cumprod(a)
-+            coeff_arr = np.concatenate([
-+                spline(tlist, i) / fact[i]
-+                for i in range(spline.k, -1, -1)
-+            ]).reshape((spline.k+1, -1))
-+
-+        self._prepare(tlist, coeff_arr)
-+
-+    def _prepare(self, np_tlist, np_poly, dt=None):
-+        self.np_arrays = (np_tlist, np_poly)
-+        self.tlist = np_tlist
-+        self.poly = np_poly
-+        self.order = self.poly.shape[0] - 1
-+        diff = np.diff(self.np_arrays[0])
-+        if dt is not None:
-+            self.dt = dt
-+        elif len(diff) >= 1 and np.allclose(diff[0], diff):
-+            self.dt = diff[0]
-+        else:
-+            self.dt = 0
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef size_t _binary_search(self, double x):
-+        # Binary search for the interval
-+        # return the indice of the of the biggest element where t <= x
-+        cdef size_t low = 0
-+        cdef size_t high = self.tlist.shape[0]
-+        cdef size_t middle
-+        cdef size_t count = 0
-+        while low+1 != high and count < 64:
-+            middle = (low + high)//2
-+            if x < self.tlist[middle]:
-+                high = middle
-+            else:
-+                low = middle
-+            # We keep a count to be sure that it never get into an infinit loop
-+            # even if tlist has an unexpected format.
-+            count += 1
-+        return low
-+
-+    @cython.initializedcheck(False)
-+    @cython.cdivision(True)
-+    cdef double complex _call(self, double t) except *:
-+        cdef size_t idx, i
-+        cdef double factor
-+        cdef double complex out
-+        cdef double complex[:] slice
-+        if t <= self.tlist[0]:
-+            return self.poly[-1, 0]
-+        elif t >= self.tlist[-1]:
-+            return self.poly[-1, -1]
-+        if self.dt:
-+            idx = <size_t>((t - self.tlist[0]) / self.dt)
-+        else:
-+            idx = self._binary_search(t)
-+        if self.order == 0:
-+            out = self.poly[0, idx]
-+        else:
-+            factor = t - self.tlist[idx]
-+            slice = self.poly[:, idx]
-+            out = 0.
-+            for i in range(self.order+1):
-+                out *= factor
-+                out += slice[i]
-+        return out
-+
-+    def __reduce__(self):
-+        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
-+
-+    @classmethod
-+    def restore(cls, np_tlist, np_poly, dt=None):
-+        cdef InterCoefficient out = cls.__new__(cls)
-+        out._prepare(np_tlist, np_poly, dt)
-+        return out
-+
-+    @classmethod
-+    def from_PPoly(cls, ppoly, **_):
-+        return cls.restore(ppoly.x, ppoly.c)
-+
-+    @classmethod
-+    def from_Bspline(cls, spline, **_):
-+        tlist = np.unique(spline.t)
-+        a = np.arange(spline.k+1)
-+        a[0] = 1
-+        fact = np.cumprod(a) + 0j
-+        poly = np.concatenate([
-+            spline(tlist, i) / fact[i]
-+            for i in range(spline.k, -1, -1)
-+        ]).reshape((spline.k+1, -1))
-+        return cls.restore(tlist, poly)
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return InterCoefficient.restore(*self.np_arrays, self.dt)
-+
-+
-+cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
-+    """ Add two array coefficient with matching tlist into one."""
-+    if (
-+        left.np_arrays[0].shape == right.np_arrays[0].shape
-+        and np.allclose(left.np_arrays[0], right.np_arrays[0],
-+                        rtol=1e-15, atol=1e-15)
-+        and (left.order == right.order)
-+    ):
-+        return InterCoefficient.restore(
-+            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
-+            left.dt
-+        )
-+    else:
-+        # It would be possible to add them by merging tlist.
-+        return SumCoefficient(left, right)
-+
-+
-+@cython.auto_pickle(True)
-+cdef class SumCoefficient(Coefficient):
-+    """
-+    A :obj:`Coefficient` built from the sum of two other coefficients.
-+
-+    A :obj:`SumCoefficient` is returned as the result of the addition of two
-+    coefficients, e.g. ::
-+
-+        coefficient("t * t") + coefficient("t")  # SumCoefficient
-+    """
-+    cdef Coefficient first
-+    cdef Coefficient second
-+
-+    def __init__(self, Coefficient first, Coefficient second):
-+        self.first = first
-+        self.second = second
-+
-+    cdef complex _call(self, double t) except *:
-+        return self.first._call(t) + self.second._call(t)
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return SumCoefficient(self.first.copy(), self.second.copy())
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        return SumCoefficient(
-+            self.first.replace_arguments(_args, **kwargs),
-+            self.second.replace_arguments(_args, **kwargs)
-+        )
-+
-+
-+@cython.auto_pickle(True)
-+cdef class MulCoefficient(Coefficient):
-+    """
-+    A :obj:`Coefficient` built from the product of two other coefficients.
-+
-+    A :obj:`MulCoefficient` is returned as the result of the multiplication of
-+    two coefficients, e.g. ::
-+
-+        coefficient("w * t", args={'w': 1}) * coefficient("t")
-+    """
-+    cdef Coefficient first
-+    cdef Coefficient second
-+
-+    def __init__(self, Coefficient first, Coefficient second):
-+        self.first = first
-+        self.second = second
-+
-+    cdef complex _call(self, double t) except *:
-+        return self.first._call(t) * self.second._call(t)
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return MulCoefficient(self.first.copy(), self.second.copy())
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        return MulCoefficient(
-+            self.first.replace_arguments(_args, **kwargs),
-+            self.second.replace_arguments(_args, **kwargs)
-+        )
-+
-+
-+@cython.auto_pickle(True)
-+cdef class ConjCoefficient(Coefficient):
-+    """
-+    The conjugate of a :obj:`Coefficient`.
-+
-+    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
-+    ``qutip.coefficent.conj(Coefficient)``.
-+    """
-+    cdef Coefficient base
-+
-+    def __init__(self, Coefficient base):
-+        self.base = base
-+
-+    cdef complex _call(self, double t) except *:
-+        return conj(self.base._call(t))
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return ConjCoefficient(self.base.copy())
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        return ConjCoefficient(
-+            self.base.replace_arguments(_args, **kwargs)
-+        )
-+
-+
-+@cython.auto_pickle(True)
-+cdef class NormCoefficient(Coefficient):
-+    """
-+    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
-+    ``conj(coeff) * coeff``.
-+
-+    :obj:`NormCoefficient` is returned by
-+    ``qutip.coefficent.norm(Coefficient)``.
-+    """
-+    cdef Coefficient base
-+
-+    def __init__(self, Coefficient base):
-+        self.base = base
-+
-+    def replace_arguments(self, _args=None, **kwargs):
-+        """
-+        Replace the arguments (``args``) of a coefficient.
-+
-+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-+        the original coefficient if it does not. Arguments to replace may be
-+        supplied either in a dictionary as the first position argument, or
-+        passed as keywords, or as a combination of the two. Arguments not
-+        replaced retain their previous values.
-+
-+        Parameters
-+        ----------
-+        _args : dict
-+            Dictionary of arguments to replace.
-+
-+        **kwargs
-+            Arguments to replace.
-+        """
-+        return NormCoefficient(
-+            self.base.replace_arguments(_args, **kwargs)
-+        )
-+
-+    cdef complex _call(self, double t) except *:
-+        return norm(self.base._call(t))
-+
-+    cpdef Coefficient copy(self):
-+        """Return a copy of the :obj:`Coefficient`."""
-+        return NormCoefficient(self.base.copy())
-diff --git a/qutip/core/cy/complex_math.pxd b/qutip/core/cy/complex_math.pxd
-index 43f0fd17..5271c330 100644
---- a/qutip/core/cy/complex_math.pxd
-+++ b/qutip/core/cy/complex_math.pxd
-@@ -1,24 +1,24 @@
--cdef extern from "<complex>" namespace "std" nogil:
--    double         abs(double complex x)
--    double complex acos(double complex x)
--    double complex acosh(double complex x)
--    double         arg(double complex x)
--    double complex asin(double complex x)
--    double complex asinh(double complex x)
--    double complex atan(double complex x)
--    double complex atanh(double complex x)
--    double complex conj(double complex x)
--    double complex cos(double complex x)
--    double complex cosh(double complex x)
--    double complex exp(double complex x)
--    double         imag(double complex x)
--    double complex log(double complex x)
--    double complex log10(double complex x)
--    double         norm(double complex x)
--    double complex proj(double complex x)
--    double         real(double complex x)
--    double complex sin(double complex x)
--    double complex sinh(double complex x)
--    double complex sqrt(double complex x)
--    double complex tan(double complex x)
--    double complex tanh(double complex x)
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double         abs(double complex x)
-+    double complex acos(double complex x)
-+    double complex acosh(double complex x)
-+    double         arg(double complex x)
-+    double complex asin(double complex x)
-+    double complex asinh(double complex x)
-+    double complex atan(double complex x)
-+    double complex atanh(double complex x)
-+    double complex conj(double complex x)
-+    double complex cos(double complex x)
-+    double complex cosh(double complex x)
-+    double complex exp(double complex x)
-+    double         imag(double complex x)
-+    double complex log(double complex x)
-+    double complex log10(double complex x)
-+    double         norm(double complex x)
-+    double complex proj(double complex x)
-+    double         real(double complex x)
-+    double complex sin(double complex x)
-+    double complex sinh(double complex x)
-+    double complex sqrt(double complex x)
-+    double complex tan(double complex x)
-+    double complex tanh(double complex x)
-diff --git a/qutip/core/cy/math.pxd b/qutip/core/cy/math.pxd
-index 6f304b49..6002bf9c 100644
---- a/qutip/core/cy/math.pxd
-+++ b/qutip/core/cy/math.pxd
-@@ -1,5 +1,5 @@
--#cython: language_level=3
--
--cdef double erf(double x)
--
--cdef double complex zerf(double complex Z)
-+#cython: language_level=3
-+
-+cdef double erf(double x)
-+
-+cdef double complex zerf(double complex Z)
-diff --git a/qutip/core/cy/math.pyx b/qutip/core/cy/math.pyx
-index abdda8c5..e9f113cf 100644
---- a/qutip/core/cy/math.pyx
-+++ b/qutip/core/cy/math.pyx
-@@ -1,159 +1,159 @@
--#cython: language_level=3
--
--cimport cython
--from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
--
--cdef extern from "<complex>" namespace "std" nogil:
--    double real(double complex x)
--    double imag(double complex x)
--
--@cython.boundscheck(False)
--@cython.cdivision(True)
--cdef double erf(double x):
--    """
--    A Cython version of the erf function from the cdflib in SciPy.
--    """
--    cdef double c = 0.564189583547756
--
--    cdef double a[5]
--    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
--                     0.479137145607681e-1, 0.128379167095513]
--
--    cdef double b[3]
--    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
--
--    cdef double p[8]
--    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
--                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
--                     4.51918953711873e2, 3.00459261020162e2]
--
--    cdef double q[8]
--    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
--                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
--                     3.00459260956983e2]
--
--    cdef double r[5]
--    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
--                      4.65807828718470, 2.82094791773523e-1]
--
--    cdef double s[4]
--    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
--                     1.80124575948747e1]
--
--    cdef double ax = fabs(x)
--    cdef double t, x2, top, bot, erf
--
--    if ax <= 0.5:
--        t = x*x
--        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
--        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
--        erf = x * (top/bot)
--        return erf
--    elif ax <= 4.0:
--        x2 = x*x
--        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
--        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
--        erf = 0.5 + (0.5-exp(-x2)*top/bot)
--        if x < 0.0:
--            erf = -erf
--        return erf
--    elif ax < 5.8:
--        x2 = x*x
--        t = 1.0/x2
--        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
--        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
--        erf = (c-top/(x2*bot))/ax
--        erf = 0.5 + (0.5-exp(-x2)*erf)
--        if x < 0.0:
--            erf = -erf
--        return erf
--    else:
--        erf = copysign(1.0, x)
--        return erf
--
--
--#       COMPUTATION OF SPECIAL FUNCTIONS
--#
--#          Shanjie Zhang and Jianming Jin
--#
--#       Copyrighted but permission granted to use code in programs.
--# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
--    
--@cython.cdivision(True)
--@cython.boundscheck(False)
--cdef double complex zerf(double complex Z):
--    """
--    Parameters
--    ----------
--    Z : double complex
--        Input parameter.
--    X : double
--        Real part of Z.
--    Y : double
--        Imag part of Z.
--
--    Returns
--    -------
--    erf(z) : double complex
--    """
--    
--    cdef double EPS = 1e-12
--    cdef double X = real(Z)
--    cdef double Y = imag(Z)
--    cdef double X2 = X * X
--    
--    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
--    
--    cdef size_t K, N
--    
--    if X < 3.5:
--        ER = 1.0
--        R = 1.0
--        W = 0.0
--        for K in range(1, 100):
--            R = R*X2/(K+0.5)
--            ER = ER+R
--            if (fabs(ER-W) < EPS*fabs(ER)):
--                break
--            W = ER
--        C0 = 2.0/sqrt(pi)*X*exp(-X2)
--        ER0 = C0*ER
--    else:
--        ER = 1.0
--        R=1.0
--        for K in range(1, 12):
--            R = -R*(K-0.5)/X2
--            ER = ER+R
--        C0 = exp(-X2)/(X*sqrt(pi))
--        ER0 = 1.0-C0*ER
--    
--    if Y == 0.0:
--        ERR = ER0
--        ERI = 0.0
--    else:
--        CS = cos(2.0*X*Y)
--        SS = sin(2.0*X*Y)
--        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
--        EI1 = exp(-X2)*SS/(2.0*pi*X)
--        ER2 = 0.0
--        W1 = 0.0
--        
--        for N in range(1,100):
--            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
--            if (fabs((ER2-W1)/ER2) < EPS):
--                break
--            W1 = ER2
--        
--        C0 = 2.0*exp(-X2)/pi
--        ERR = ER0+ER1+C0*ER2
--        EI2 = 0.0
--        W2 = 0.0
--        
--        for N in range(1,100):
--            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
--            if (fabs((EI2-W2)/EI2) < EPS):
--                break
--            W2 = EI2
--        ERI = EI1+C0*EI2
--        
--    return ERR + 1j*ERI
-+#cython: language_level=3
-+
-+cimport cython
-+from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double real(double complex x)
-+    double imag(double complex x)
-+
-+@cython.boundscheck(False)
-+@cython.cdivision(True)
-+cdef double erf(double x):
-+    """
-+    A Cython version of the erf function from the cdflib in SciPy.
-+    """
-+    cdef double c = 0.564189583547756
-+
-+    cdef double a[5]
-+    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
-+                     0.479137145607681e-1, 0.128379167095513]
-+
-+    cdef double b[3]
-+    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
-+
-+    cdef double p[8]
-+    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
-+                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
-+                     4.51918953711873e2, 3.00459261020162e2]
-+
-+    cdef double q[8]
-+    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
-+                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
-+                     3.00459260956983e2]
-+
-+    cdef double r[5]
-+    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
-+                      4.65807828718470, 2.82094791773523e-1]
-+
-+    cdef double s[4]
-+    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
-+                     1.80124575948747e1]
-+
-+    cdef double ax = fabs(x)
-+    cdef double t, x2, top, bot, erf
-+
-+    if ax <= 0.5:
-+        t = x*x
-+        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
-+        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
-+        erf = x * (top/bot)
-+        return erf
-+    elif ax <= 4.0:
-+        x2 = x*x
-+        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
-+        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
-+        erf = 0.5 + (0.5-exp(-x2)*top/bot)
-+        if x < 0.0:
-+            erf = -erf
-+        return erf
-+    elif ax < 5.8:
-+        x2 = x*x
-+        t = 1.0/x2
-+        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
-+        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
-+        erf = (c-top/(x2*bot))/ax
-+        erf = 0.5 + (0.5-exp(-x2)*erf)
-+        if x < 0.0:
-+            erf = -erf
-+        return erf
-+    else:
-+        erf = copysign(1.0, x)
-+        return erf
-+
-+
-+#       COMPUTATION OF SPECIAL FUNCTIONS
-+#
-+#          Shanjie Zhang and Jianming Jin
-+#
-+#       Copyrighted but permission granted to use code in programs.
-+# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
-+    
-+@cython.cdivision(True)
-+@cython.boundscheck(False)
-+cdef double complex zerf(double complex Z):
-+    """
-+    Parameters
-+    ----------
-+    Z : double complex
-+        Input parameter.
-+    X : double
-+        Real part of Z.
-+    Y : double
-+        Imag part of Z.
-+
-+    Returns
-+    -------
-+    erf(z) : double complex
-+    """
-+    
-+    cdef double EPS = 1e-12
-+    cdef double X = real(Z)
-+    cdef double Y = imag(Z)
-+    cdef double X2 = X * X
-+    
-+    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
-+    
-+    cdef size_t K, N
-+    
-+    if X < 3.5:
-+        ER = 1.0
-+        R = 1.0
-+        W = 0.0
-+        for K in range(1, 100):
-+            R = R*X2/(K+0.5)
-+            ER = ER+R
-+            if (fabs(ER-W) < EPS*fabs(ER)):
-+                break
-+            W = ER
-+        C0 = 2.0/sqrt(pi)*X*exp(-X2)
-+        ER0 = C0*ER
-+    else:
-+        ER = 1.0
-+        R=1.0
-+        for K in range(1, 12):
-+            R = -R*(K-0.5)/X2
-+            ER = ER+R
-+        C0 = exp(-X2)/(X*sqrt(pi))
-+        ER0 = 1.0-C0*ER
-+    
-+    if Y == 0.0:
-+        ERR = ER0
-+        ERI = 0.0
-+    else:
-+        CS = cos(2.0*X*Y)
-+        SS = sin(2.0*X*Y)
-+        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
-+        EI1 = exp(-X2)*SS/(2.0*pi*X)
-+        ER2 = 0.0
-+        W1 = 0.0
-+        
-+        for N in range(1,100):
-+            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
-+            if (fabs((ER2-W1)/ER2) < EPS):
-+                break
-+            W1 = ER2
-+        
-+        C0 = 2.0*exp(-X2)/pi
-+        ERR = ER0+ER1+C0*ER2
-+        EI2 = 0.0
-+        W2 = 0.0
-+        
-+        for N in range(1,100):
-+            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
-+            if (fabs((EI2-W2)/EI2) < EPS):
-+                break
-+            W2 = EI2
-+        ERI = EI1+C0*EI2
-+        
-+    return ERR + 1j*ERI
-diff --git a/qutip/core/cy/openmp/bench_openmp.py b/qutip/core/cy/openmp/bench_openmp.py
-index 84db486b..88868a82 100644
---- a/qutip/core/cy/openmp/bench_openmp.py
-+++ b/qutip/core/cy/openmp/bench_openmp.py
-@@ -1,154 +1,154 @@
--import numpy as np
--from qutip.settings import settings as qset
--from timeit import default_timer as timer
--
--
--def _min_timer(function, *args, **kwargs):
--    min_time = 1e6
--    for kk in range(10000):
--        t0 = timer()
--        function(*args, **kwargs)
--        t1 = timer()
--        min_time = min(min_time, t1-t0)
--    return min_time
--
--
--def system_bench(func, dims):
--    from qutip.random_objects import rand_ket
--    ratio = 0
--    ratio_old = 0
--    nnz_old = 0
--    for N in dims:
--        L = func(N).data
--        vec = rand_ket(L.shape[0], 0.25).full().ravel()
--        nnz = L.nnz
--        out = np.zeros_like(vec)
--        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
--        out = np.zeros_like(vec)
--        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
--        ratio = ser/par
--        if ratio > 1:
--            break
--        nnz_old = nnz
--        ratio_old = ratio
--    if ratio > 1:
--        rate = (ratio-ratio_old)/(nnz-nnz_old)
--        return int((1.0-ratio_old)/rate+nnz_old)
--    else:
--        return -1
--
--
--def calculate_openmp_thresh():
--    # if qset.num_cpus == 1:
--    #    return qset.openmp_thresh
--    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
--    jc_result = system_bench(_jc_liouvillian, jc_dims)
--
--    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
--    opto_result = system_bench(_opto_liouvillian, opto_dims)
--
--    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
--    spin_result = system_bench(_spin_hamiltonian, spin_dims)
--
--    # Double result to be conservative
--    thresh = 2*int(max([jc_result, opto_result, spin_result]))
--    if thresh < 0:
--        thresh = np.iinfo(np.int32).max
--    return thresh
--
--
--def _jc_liouvillian(N):
--    from qutip.core import tensor, destroy, qeye, liouvillian
--    wc = 2*np.pi * 1.0   # cavity frequency
--    wa = 2*np.pi * 1.0   # atom frequency
--    g = 2*np.pi * 0.05   # coupling strength
--    kappa = 0.005        # cavity dissipation rate
--    gamma = 0.05         # atom dissipation rate
--    n_th_a = 1           # temperature in frequency units
--    use_rwa = 0
--    # operators
--    a = tensor(destroy(N), qeye(2))
--    sm = tensor(qeye(N), destroy(2))
--    # Hamiltonian
--    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
--    c_op_list = []
--
--    rate = kappa * (1 + n_th_a)
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * a)
--
--    rate = kappa * n_th_a
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * a.dag())
--
--    rate = gamma
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * sm)
--
--    return liouvillian(H, c_op_list)
--
--
--def _opto_liouvillian(N):
--    from qutip.core import tensor, destroy, qeye, liouvillian
--    Nc = 5                      # Number of cavity states
--    Nm = N                     # Number of mech states
--    kappa = 0.3                 # Cavity damping rate
--    E = 0.1                     # Driving Amplitude
--    g0 = 2.4*kappa              # Coupling strength
--    Qm = 1e4                    # Mech quality factor
--    gamma = 1/Qm                # Mech damping rate
--    n_th = 1                    # Mech bath temperature
--    delta = -0.43               # Detuning
--    a = tensor(destroy(Nc), qeye(Nm))
--    b = tensor(qeye(Nc), destroy(Nm))
--    num_b = b.dag()*b
--    num_a = a.dag()*a
--    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
--    cc = np.sqrt(kappa)*a
--    cm = np.sqrt(gamma*(1.0 + n_th))*b
--    cp = np.sqrt(gamma*n_th)*b.dag()
--    c_ops = [cc, cm, cp]
--    return liouvillian(H, c_ops)
--
--
--def _spin_hamiltonian(N):
--    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
--    # array of spin energy splittings and coupling strengths. here we use
--    # uniform parameters, but in general we don't have too
--    h = 2*np.pi * 1.0 * np.ones(N)
--    Jz = 2*np.pi * 0.1 * np.ones(N)
--    Jx = 2*np.pi * 0.1 * np.ones(N)
--    Jy = 2*np.pi * 0.1 * np.ones(N)
--    # dephasing rate
--
--    si = qeye(2)
--    sx = sigmax()
--    sy = sigmay()
--    sz = sigmaz()
--
--    sx_list = []
--    sy_list = []
--    sz_list = []
--
--    for n in range(N):
--        op_list = [si] * N
--        op_list[n] = sx
--        sx_list.append(tensor(op_list))
--        op_list[n] = sy
--        sy_list.append(tensor(op_list))
--        op_list[n] = sz
--        sz_list.append(tensor(op_list))
--
--    # construct the hamiltonian
--    H = 0
--
--    # energy splitting terms
--    for n in range(N):
--        H += - 0.5 * h[n] * sz_list[n]
--
--    # interaction terms
--    for n in range(N-1):
--        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
--        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
--        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
--    return H
-+import numpy as np
-+from qutip.settings import settings as qset
-+from timeit import default_timer as timer
-+
-+
-+def _min_timer(function, *args, **kwargs):
-+    min_time = 1e6
-+    for kk in range(10000):
-+        t0 = timer()
-+        function(*args, **kwargs)
-+        t1 = timer()
-+        min_time = min(min_time, t1-t0)
-+    return min_time
-+
-+
-+def system_bench(func, dims):
-+    from qutip.random_objects import rand_ket
-+    ratio = 0
-+    ratio_old = 0
-+    nnz_old = 0
-+    for N in dims:
-+        L = func(N).data
-+        vec = rand_ket(L.shape[0], 0.25).full().ravel()
-+        nnz = L.nnz
-+        out = np.zeros_like(vec)
-+        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
-+        out = np.zeros_like(vec)
-+        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
-+        ratio = ser/par
-+        if ratio > 1:
-+            break
-+        nnz_old = nnz
-+        ratio_old = ratio
-+    if ratio > 1:
-+        rate = (ratio-ratio_old)/(nnz-nnz_old)
-+        return int((1.0-ratio_old)/rate+nnz_old)
-+    else:
-+        return -1
-+
-+
-+def calculate_openmp_thresh():
-+    # if qset.num_cpus == 1:
-+    #    return qset.openmp_thresh
-+    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
-+    jc_result = system_bench(_jc_liouvillian, jc_dims)
-+
-+    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
-+    opto_result = system_bench(_opto_liouvillian, opto_dims)
-+
-+    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
-+    spin_result = system_bench(_spin_hamiltonian, spin_dims)
-+
-+    # Double result to be conservative
-+    thresh = 2*int(max([jc_result, opto_result, spin_result]))
-+    if thresh < 0:
-+        thresh = np.iinfo(np.int32).max
-+    return thresh
-+
-+
-+def _jc_liouvillian(N):
-+    from qutip.core import tensor, destroy, qeye, liouvillian
-+    wc = 2*np.pi * 1.0   # cavity frequency
-+    wa = 2*np.pi * 1.0   # atom frequency
-+    g = 2*np.pi * 0.05   # coupling strength
-+    kappa = 0.005        # cavity dissipation rate
-+    gamma = 0.05         # atom dissipation rate
-+    n_th_a = 1           # temperature in frequency units
-+    use_rwa = 0
-+    # operators
-+    a = tensor(destroy(N), qeye(2))
-+    sm = tensor(qeye(N), destroy(2))
-+    # Hamiltonian
-+    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
-+    c_op_list = []
-+
-+    rate = kappa * (1 + n_th_a)
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * a)
-+
-+    rate = kappa * n_th_a
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * a.dag())
-+
-+    rate = gamma
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * sm)
-+
-+    return liouvillian(H, c_op_list)
-+
-+
-+def _opto_liouvillian(N):
-+    from qutip.core import tensor, destroy, qeye, liouvillian
-+    Nc = 5                      # Number of cavity states
-+    Nm = N                     # Number of mech states
-+    kappa = 0.3                 # Cavity damping rate
-+    E = 0.1                     # Driving Amplitude
-+    g0 = 2.4*kappa              # Coupling strength
-+    Qm = 1e4                    # Mech quality factor
-+    gamma = 1/Qm                # Mech damping rate
-+    n_th = 1                    # Mech bath temperature
-+    delta = -0.43               # Detuning
-+    a = tensor(destroy(Nc), qeye(Nm))
-+    b = tensor(qeye(Nc), destroy(Nm))
-+    num_b = b.dag()*b
-+    num_a = a.dag()*a
-+    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
-+    cc = np.sqrt(kappa)*a
-+    cm = np.sqrt(gamma*(1.0 + n_th))*b
-+    cp = np.sqrt(gamma*n_th)*b.dag()
-+    c_ops = [cc, cm, cp]
-+    return liouvillian(H, c_ops)
-+
-+
-+def _spin_hamiltonian(N):
-+    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
-+    # array of spin energy splittings and coupling strengths. here we use
-+    # uniform parameters, but in general we don't have too
-+    h = 2*np.pi * 1.0 * np.ones(N)
-+    Jz = 2*np.pi * 0.1 * np.ones(N)
-+    Jx = 2*np.pi * 0.1 * np.ones(N)
-+    Jy = 2*np.pi * 0.1 * np.ones(N)
-+    # dephasing rate
-+
-+    si = qeye(2)
-+    sx = sigmax()
-+    sy = sigmay()
-+    sz = sigmaz()
-+
-+    sx_list = []
-+    sy_list = []
-+    sz_list = []
-+
-+    for n in range(N):
-+        op_list = [si] * N
-+        op_list[n] = sx
-+        sx_list.append(tensor(op_list))
-+        op_list[n] = sy
-+        sy_list.append(tensor(op_list))
-+        op_list[n] = sz
-+        sz_list.append(tensor(op_list))
-+
-+    # construct the hamiltonian
-+    H = 0
-+
-+    # energy splitting terms
-+    for n in range(N):
-+        H += - 0.5 * h[n] * sz_list[n]
-+
-+    # interaction terms
-+    for n in range(N-1):
-+        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
-+        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
-+        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
-+    return H
-diff --git a/qutip/core/cy/openmp/parfuncs.pxd b/qutip/core/cy/openmp/parfuncs.pxd
-index a8a14bea..73a4186d 100644
---- a/qutip/core/cy/openmp/parfuncs.pxd
-+++ b/qutip/core/cy/openmp/parfuncs.pxd
-@@ -1,9 +1,9 @@
--#cython: language_level=3
--
--cimport numpy as cnp
--cimport cython
--
--cdef void spmvpy_openmp(
--    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
--    unsigned int nrows, unsigned int nthr,
--)
-+#cython: language_level=3
-+
-+cimport numpy as cnp
-+cimport cython
-+
-+cdef void spmvpy_openmp(
-+    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
-+    unsigned int nrows, unsigned int nthr,
-+)
-diff --git a/qutip/core/cy/openmp/parfuncs.pyx b/qutip/core/cy/openmp/parfuncs.pyx
-index 919a209e..382c75b4 100644
---- a/qutip/core/cy/openmp/parfuncs.pyx
-+++ b/qutip/core/cy/openmp/parfuncs.pyx
-@@ -1,13 +1,13 @@
--#cython: language_level=3
--
--cdef extern from "src/zspmv_openmp.hpp" nogil:
--    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
--                double complex a, double complex *out, int nrows, int nthr)
--
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
--                               complex * vec, complex a, complex * out,
--                               unsigned int nrows, unsigned int nthr):
--    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
-+#cython: language_level=3
-+
-+cdef extern from "src/zspmv_openmp.hpp" nogil:
-+    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
-+                double complex a, double complex *out, int nrows, int nthr)
-+
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
-+                               complex * vec, complex a, complex * out,
-+                               unsigned int nrows, unsigned int nthr):
-+    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
-diff --git a/qutip/core/cy/openmp/src/zspmv_openmp.cpp b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
-index 7e98b934..f6b42c3a 100644
---- a/qutip/core/cy/openmp/src/zspmv_openmp.cpp
-+++ b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
-@@ -1,166 +1,166 @@
--#include <complex>
--#include <omp.h>
--
--#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
--#include <pmmintrin.h>
--void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
--            const int * __restrict__ ptr,
--            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
--            std::complex<double> * __restrict__ out, const unsigned int nrows,
--            const unsigned int nthr)
--{
--    size_t row, jj;
--    unsigned int row_start, row_end;
--    __m128d num1, num2, num3, num4;
--    #pragma omp parallel for \
--        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
--        shared(data,ind,ptr,out,vec) schedule(static) \
--        num_threads(nthr)
--    for (row=0; row < nrows; row++)
--    {
--        num4 = _mm_setzero_pd();
--        row_start = ptr[row];
--        row_end = ptr[row+1];
--        for (jj=row_start; jj <row_end; jj++)
--        {
--            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
--            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
--            num3 = _mm_mul_pd(num2, num1);
--            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
--            num2 = _mm_shuffle_pd(num2, num2, 1);
--            num2 = _mm_mul_pd(num2, num1);
--            num3 = _mm_addsub_pd(num3, num2);
--            num4 = _mm_add_pd(num3, num4);
--        }
--        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
--        num3 = _mm_mul_pd(num4, num1);
--        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
--        num4 = _mm_shuffle_pd(num4, num4, 1);
--        num4 = _mm_mul_pd(num4, num1);
--        num3 = _mm_addsub_pd(num3, num4);
--        num2 = _mm_loadu_pd((double *)&out[row]);
--        num3 = _mm_add_pd(num2, num3);
--        _mm_storeu_pd((double *)&out[row], num3);
--    }
--}
--#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
--void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
--            const int * __restrict__ ptr,
--            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
--            std::complex<double> * __restrict__ out, const unsigned int nrows,
--            const unsigned int nthr)
--{
--    size_t row, jj;
--    unsigned int row_start, row_end;
--    std::complex<double> dot;
--    #pragma omp parallel for \
--        private(row,dot,row_start,row_end,jj) \
--        shared(data,ind,ptr,out,vec) schedule(static) \
--        num_threads(nthr)
--    for (row=0; row < nrows; row++)
--    {
--        dot = 0;
--        row_start = ptr[row];
--        row_end = ptr[row+1];
--        for (jj=row_start; jj <row_end; jj++)
--        {
--            dot += data[jj]*vec[ind[jj]];
--        }
--        out[row] += a*dot;
--    }
--}
--#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
--#include <pmmintrin.h>
--void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
--            const int * __restrict ptr,
--            const std::complex<double> * __restrict vec, const std::complex<double> a,
--            std::complex<double> * __restrict out, const int nrows,
--            const unsigned int nthr)
--{
--    int row, jj;
--    int row_start, row_end;
--    __m128d num1, num2, num3, num4;
--    #pragma omp parallel for \
--        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
--        shared(data,ind,ptr,out,vec) schedule(static) \
--        num_threads(nthr)
--    for (row=0; row < nrows; row++)
--    {
--        num4 = _mm_setzero_pd();
--        row_start = ptr[row];
--        row_end = ptr[row+1];
--        for (jj=row_start; jj <row_end; jj++)
--        {
--            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
--            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
--            num3 = _mm_mul_pd(num2, num1);
--            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
--            num2 = _mm_shuffle_pd(num2, num2, 1);
--            num2 = _mm_mul_pd(num2, num1);
--            num3 = _mm_addsub_pd(num3, num2);
--            num4 = _mm_add_pd(num3, num4);
--        }
--        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
--        num3 = _mm_mul_pd(num4, num1);
--        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
--        num4 = _mm_shuffle_pd(num4, num4, 1);
--        num4 = _mm_mul_pd(num4, num1);
--        num3 = _mm_addsub_pd(num3, num4);
--        num2 = _mm_loadu_pd((double *)&out[row]);
--        num3 = _mm_add_pd(num2, num3);
--        _mm_storeu_pd((double *)&out[row], num3);
--    }
--}
--#elif defined(_MSC_VER) // Visual Studio no AVX
--void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
--            const int * __restrict ptr,
--            const std::complex<double> * __restrict vec, const std::complex<double> a,
--            std::complex<double> * __restrict out, const int nrows,
--            const unsigned int nthr)
--{
--    int row, jj;
--    int row_start, row_end;
--    std::complex<double> dot;
--    #pragma omp parallel for \
--        private(row,dot,row_start,row_end,jj) \
--        shared(data,ind,ptr,out,vec) schedule(static) \
--        num_threads(nthr)
--    for (row=0; row < nrows; row++)
--    {
--        dot = 0;
--        row_start = ptr[row];
--        row_end = ptr[row+1];
--        for (jj=row_start; jj <row_end; jj++)
--        {
--            dot += data[jj]*vec[ind[jj]];
--        }
--        out[row] += a*dot;
--    }
--}
--#else // Everything else
--void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
--            const int * ptr,
--            const std::complex<double> * vec, const std::complex<double> a,
--            std::complex<double> * out, const unsigned int nrows,
--            const unsigned int nthr)
--{
--    size_t row, jj;
--    unsigned int row_start, row_end;
--    std::complex<double> dot;
--    #pragma omp parallel for \
--        private(row,dot,row_start,row_end,jj) \
--        shared(data,ind,ptr,out,vec) schedule(static) \
--        num_threads(nthr)
--    for (row=0; row < nrows; row++)
--    {
--        dot = 0;
--        row_start = ptr[row];
--        row_end = ptr[row+1];
--        for (jj=row_start; jj <row_end; jj++)
--        {
--            dot += data[jj]*vec[ind[jj]];
--        }
--        out[row] += a*dot;
--    }
--}
--#endif
-+#include <complex>
-+#include <omp.h>
-+
-+#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
-+#include <pmmintrin.h>
-+void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-+            const int * __restrict__ ptr,
-+            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-+            std::complex<double> * __restrict__ out, const unsigned int nrows,
-+            const unsigned int nthr)
-+{
-+    size_t row, jj;
-+    unsigned int row_start, row_end;
-+    __m128d num1, num2, num3, num4;
-+    #pragma omp parallel for \
-+        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
-+        shared(data,ind,ptr,out,vec) schedule(static) \
-+        num_threads(nthr)
-+    for (row=0; row < nrows; row++)
-+    {
-+        num4 = _mm_setzero_pd();
-+        row_start = ptr[row];
-+        row_end = ptr[row+1];
-+        for (jj=row_start; jj <row_end; jj++)
-+        {
-+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-+            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-+            num3 = _mm_mul_pd(num2, num1);
-+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-+            num2 = _mm_shuffle_pd(num2, num2, 1);
-+            num2 = _mm_mul_pd(num2, num1);
-+            num3 = _mm_addsub_pd(num3, num2);
-+            num4 = _mm_add_pd(num3, num4);
-+        }
-+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-+        num3 = _mm_mul_pd(num4, num1);
-+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-+        num4 = _mm_shuffle_pd(num4, num4, 1);
-+        num4 = _mm_mul_pd(num4, num1);
-+        num3 = _mm_addsub_pd(num3, num4);
-+        num2 = _mm_loadu_pd((double *)&out[row]);
-+        num3 = _mm_add_pd(num2, num3);
-+        _mm_storeu_pd((double *)&out[row], num3);
-+    }
-+}
-+#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
-+void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-+            const int * __restrict__ ptr,
-+            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-+            std::complex<double> * __restrict__ out, const unsigned int nrows,
-+            const unsigned int nthr)
-+{
-+    size_t row, jj;
-+    unsigned int row_start, row_end;
-+    std::complex<double> dot;
-+    #pragma omp parallel for \
-+        private(row,dot,row_start,row_end,jj) \
-+        shared(data,ind,ptr,out,vec) schedule(static) \
-+        num_threads(nthr)
-+    for (row=0; row < nrows; row++)
-+    {
-+        dot = 0;
-+        row_start = ptr[row];
-+        row_end = ptr[row+1];
-+        for (jj=row_start; jj <row_end; jj++)
-+        {
-+            dot += data[jj]*vec[ind[jj]];
-+        }
-+        out[row] += a*dot;
-+    }
-+}
-+#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
-+#include <pmmintrin.h>
-+void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
-+            const int * __restrict ptr,
-+            const std::complex<double> * __restrict vec, const std::complex<double> a,
-+            std::complex<double> * __restrict out, const int nrows,
-+            const unsigned int nthr)
-+{
-+    int row, jj;
-+    int row_start, row_end;
-+    __m128d num1, num2, num3, num4;
-+    #pragma omp parallel for \
-+        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
-+        shared(data,ind,ptr,out,vec) schedule(static) \
-+        num_threads(nthr)
-+    for (row=0; row < nrows; row++)
-+    {
-+        num4 = _mm_setzero_pd();
-+        row_start = ptr[row];
-+        row_end = ptr[row+1];
-+        for (jj=row_start; jj <row_end; jj++)
-+        {
-+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-+            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-+            num3 = _mm_mul_pd(num2, num1);
-+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-+            num2 = _mm_shuffle_pd(num2, num2, 1);
-+            num2 = _mm_mul_pd(num2, num1);
-+            num3 = _mm_addsub_pd(num3, num2);
-+            num4 = _mm_add_pd(num3, num4);
-+        }
-+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-+        num3 = _mm_mul_pd(num4, num1);
-+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-+        num4 = _mm_shuffle_pd(num4, num4, 1);
-+        num4 = _mm_mul_pd(num4, num1);
-+        num3 = _mm_addsub_pd(num3, num4);
-+        num2 = _mm_loadu_pd((double *)&out[row]);
-+        num3 = _mm_add_pd(num2, num3);
-+        _mm_storeu_pd((double *)&out[row], num3);
-+    }
-+}
-+#elif defined(_MSC_VER) // Visual Studio no AVX
-+void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
-+            const int * __restrict ptr,
-+            const std::complex<double> * __restrict vec, const std::complex<double> a,
-+            std::complex<double> * __restrict out, const int nrows,
-+            const unsigned int nthr)
-+{
-+    int row, jj;
-+    int row_start, row_end;
-+    std::complex<double> dot;
-+    #pragma omp parallel for \
-+        private(row,dot,row_start,row_end,jj) \
-+        shared(data,ind,ptr,out,vec) schedule(static) \
-+        num_threads(nthr)
-+    for (row=0; row < nrows; row++)
-+    {
-+        dot = 0;
-+        row_start = ptr[row];
-+        row_end = ptr[row+1];
-+        for (jj=row_start; jj <row_end; jj++)
-+        {
-+            dot += data[jj]*vec[ind[jj]];
-+        }
-+        out[row] += a*dot;
-+    }
-+}
-+#else // Everything else
-+void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
-+            const int * ptr,
-+            const std::complex<double> * vec, const std::complex<double> a,
-+            std::complex<double> * out, const unsigned int nrows,
-+            const unsigned int nthr)
-+{
-+    size_t row, jj;
-+    unsigned int row_start, row_end;
-+    std::complex<double> dot;
-+    #pragma omp parallel for \
-+        private(row,dot,row_start,row_end,jj) \
-+        shared(data,ind,ptr,out,vec) schedule(static) \
-+        num_threads(nthr)
-+    for (row=0; row < nrows; row++)
-+    {
-+        dot = 0;
-+        row_start = ptr[row];
-+        row_end = ptr[row+1];
-+        for (jj=row_start; jj <row_end; jj++)
-+        {
-+            dot += data[jj]*vec[ind[jj]];
-+        }
-+        out[row] += a*dot;
-+    }
-+}
-+#endif
-diff --git a/qutip/core/cy/openmp/utilities.py b/qutip/core/cy/openmp/utilities.py
-index 96275769..ac5bab86 100644
---- a/qutip/core/cy/openmp/utilities.py
-+++ b/qutip/core/cy/openmp/utilities.py
-@@ -1,41 +1,41 @@
--import os
--from qutip.settings import settings as qset
--
--
--def check_use_openmp(options):
--    """
--    Check to see if OPENMP should be used in dynamic solvers.
--    """
--    # TODO: sort this out.
--    return False
--    """
--    force_omp = False
--    if qset.has_openmp:
--        if options.use_openmp is None:
--            options.use_openmp = True
--        else:
--            force_omp = bool(options.use_openmp)
--    elif (not qset.has_openmp) and options.use_openmp:
--        raise Exception('OPENMP not available.')
--    else:
--        options.use_openmp = False
--        force_omp = False
--    # Disable OPENMP in parallel mode unless explicitly set.
--    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
--        options.use_openmp = False"""
--
--
--def use_openmp():
--    """
--    Check for using openmp in general cases outside of dynamics
--    """
--    return False
--    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
--        return True
--    else:
--        return False
--
--
--def openmp_components(ptr_list):
--    return np.array([False for ptr in ptr_list], dtype=bool)
--    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
-+import os
-+from qutip.settings import settings as qset
-+
-+
-+def check_use_openmp(options):
-+    """
-+    Check to see if OPENMP should be used in dynamic solvers.
-+    """
-+    # TODO: sort this out.
-+    return False
-+    """
-+    force_omp = False
-+    if qset.has_openmp:
-+        if options.use_openmp is None:
-+            options.use_openmp = True
-+        else:
-+            force_omp = bool(options.use_openmp)
-+    elif (not qset.has_openmp) and options.use_openmp:
-+        raise Exception('OPENMP not available.')
-+    else:
-+        options.use_openmp = False
-+        force_omp = False
-+    # Disable OPENMP in parallel mode unless explicitly set.
-+    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
-+        options.use_openmp = False"""
-+
-+
-+def use_openmp():
-+    """
-+    Check for using openmp in general cases outside of dynamics
-+    """
-+    return False
-+    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
-+        return True
-+    else:
-+        return False
-+
-+
-+def openmp_components(ptr_list):
-+    return np.array([False for ptr in ptr_list], dtype=bool)
-+    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
-diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
-index 07e0d3df..73b7f01b 100644
---- a/qutip/core/cy/qobjevo.pxd
-+++ b/qutip/core/cy/qobjevo.pxd
-@@ -1,24 +1,24 @@
--#cython: language_level=3
--
--from qutip.core.data cimport Dense, Data
--from qutip.core.data.base cimport idxint
--
--cdef class QobjEvo:
--    cdef:
--        list elements
--        readonly list dims
--        readonly (idxint, idxint) shape
--        readonly str type
--        readonly str superrep
--        int _issuper
--        int _isoper
--
--    cpdef Data _call(QobjEvo self, double t)
--
--    cdef object _prepare(QobjEvo self, object t, Data state=*)
--
--    cpdef object expect_data(QobjEvo self, object t, Data state)
--
--    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
--
--    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
-+#cython: language_level=3
-+
-+from qutip.core.data cimport Dense, Data
-+from qutip.core.data.base cimport idxint
-+
-+cdef class QobjEvo:
-+    cdef:
-+        list elements
-+        readonly list dims
-+        readonly (idxint, idxint) shape
-+        readonly str type
-+        readonly str superrep
-+        int _issuper
-+        int _isoper
-+
-+    cpdef Data _call(QobjEvo self, double t)
-+
-+    cdef object _prepare(QobjEvo self, object t, Data state=*)
-+
-+    cpdef object expect_data(QobjEvo self, object t, Data state)
-+
-+    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
-+
-+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
-diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
-index 513d3ae5..cddeb5d0 100644
---- a/qutip/core/cy/qobjevo.pyx
-+++ b/qutip/core/cy/qobjevo.pyx
-@@ -1,1019 +1,1019 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
--
--import numpy as np
--import numbers
--import itertools
--from functools import partial
--
--import qutip
--from .. import Qobj
--from .. import data as _data
--from ..coefficient import coefficient, CompilationOptions
--from ._element import *
--from ..dimensions import type_from_dims
--from qutip.settings import settings
--
--from qutip.core.cy._element cimport _BaseElement
--from qutip.core.data cimport Dense, Data, dense
--from qutip.core.data.expect cimport *
--from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
--from qutip.core.cy.coefficient cimport Coefficient
--from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
--from libc.math cimport fabs
--
--__all__ = ['QobjEvo']
--
--cdef class QobjEvo:
--    """
--    A class for representing time-dependent quantum objects, such as quantum
--    operators and states.
--
--    Importantly, :obj:`~QobjEvo` instances are used to represent such
--    time-dependent quantum objects when working with QuTiP solvers.
--
--    A :obj:`~QobjEvo` instance may be constructed from one of the following:
--
--      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
--        value of the quantum object at time ``t``.
--
--      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
--        any item that can be used to construct a coefficient (e.g. a function,
--        a numpy array of coefficient values, a string expression).
--
--      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
--
--      * a list of such callables, pairs or :obj:`~Qobj`\s.
--
--      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
--        are ignored except ``args`` which, if passed, replaces the existing
--        arguments).
--
--    Parameters
--    ----------
--    Q_object : callable, list or Qobj
--        A specification of the time-depedent quantum object. See the
--        paragraph above for a full description and the examples section below
--        for examples.
--
--    args : dict, optional
--        A dictionary that contains the arguments for the coefficients.
--        Arguments may be omitted if no function or string coefficients that
--        require arguments are present.
--
--    tlist : array-like, optional
--        A list of times corresponding to the values of the coefficients
--        supplied as numpy arrays. If no coefficients are supplied as numpy
--        arrays, ``tlist`` may be omitted, otherwise it is required.
--
--        The times in ``tlist`` do not need to be equidistant, but must
--        be sorted.
--
--        By default, a cubic spline interpolation will be used to interpolate
--        the value of the (numpy array) coefficients at time ``t``. If the
--        coefficients are to be treated as step functions, pass the argument
--        ``order=0`` (see below).
--
--    order : int, default=3
--        Order of the spline interpolation that is to be used to interpolate
--        the value of the (numpy array) coefficients at time ``t``.
--        ``0`` use previous or left value.
--
--    copy : bool, default=True
--        Whether to make a copy of the :obj:`Qobj` instances supplied in
--        the ``Q_object`` parameter.
--
--    compress : bool, default=True
--        Whether to compress the :obj:`QobjEvo` instance terms after the
--        instance has been created.
--
--        This sums the constant terms in a single term and combines
--        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
--        pair containing the sum of the coefficients.
--
--        See :meth:`compress`.
--
--    function_style : {None, "pythonic", "dict", "auto"}
--        The style of function signature used by callables in ``Q_object``.
--        If style is ``None``, the value of
--        ``qutip.settings.core["function_coefficient_style"]``
--        is used. Otherwise the supplied value overrides the global setting.
--
--
--    boundary_conditions : 2-Tuple, str or None, optional
--        Boundary conditions for spline evaluation. Default value is `None`.
--        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
--        Refer to Scipy's documentation for further details:
--        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
--
--
--    Attributes
--    ----------
--    dims : list
--        List of dimensions keeping track of the tensor structure.
--
--    shape : (int, int)
--        List of dimensions keeping track of the tensor structure.
--
--    type : str
--        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
--        'operator-bra', or 'super'.
--
--    superrep : str
--        Representation used if `type` is 'super'. One of 'super'
--        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
--
--    Examples
--    --------
--
--    A :obj:`~QobjEvo` constructed from a function:
--
--    .. code-block::
--
--        def f(t, args):
--            return qutip.qeye(N) * np.exp(args['w'] * t)
--
--        QobjEvo(f, args={'w': 1j})
--
--
--    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
--    ``[Qobj, Coefficient]`` pairs:
--
--    .. code-block::
--
--        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
--
--    The coefficients may be specified either using a :obj:`~Coefficient`
--    object or by a function, string, numpy array or any object that
--    can be passed to the :func:`~coefficient` function. See the documentation
--    of :func:`coefficient` for a full description.
--
--    An example of a coefficient specified by a function:
--
--    .. code-block::
--
--        def f1_t(t, args):
--            return np.exp(-1j * t * args["w1"])
--
--        QobjEvo([[H1, f1_t]], args={"w1": 1.})
--
--    And of coefficients specified by string expressions:
--
--    .. code-block::
--
--        H = QobjEvo(
--            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
--            args={"w1": 1., "w2": 2.}
--        )
--
--    Coefficients maybe also be expressed as numpy arrays giving a list
--    of the coefficient values:
--
--    .. code-block:: python
--
--        tlist = np.logspace(-5, 0, 100)
--        H = QobjEvo(
--            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
--            tlist=tlist
--        )
--
--    The coeffients array must have the same len as the tlist.
--
--    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
--    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
--
--    .. code-block:: python
--
--        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
--        qevo = H0 + H1 * coeff
--
--    """
--    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
--                 order=3, copy=True, compress=True,
--                 function_style=None, boundary_conditions=None):
--        if isinstance(Q_object, QobjEvo):
--            self.dims = Q_object.dims.copy()
--            self.shape = Q_object.shape
--            self.type = Q_object.type
--            self._issuper = (<QobjEvo> Q_object)._issuper
--            self._isoper = (<QobjEvo> Q_object)._isoper
--            self.elements = (<QobjEvo> Q_object).elements.copy()
--            if args:
--                self.arguments(args)
--            if compress:
--                self.compress()
--            return
--
--        self.elements = []
--        self.dims = None
--        self.shape = (0, 0)
--        self._issuper = -1
--        self._isoper = -1
--        args = args or {}
--
--        if (
--            isinstance(Q_object, list)
--            and len(Q_object) == 2
--            and isinstance(Q_object[0], Qobj)
--            and not isinstance(Q_object[1], (Qobj, list))
--        ):
--            # The format is [Qobj, coefficient]
--            Q_object = [Q_object]
--
--        if isinstance(Q_object, list):
--            for op in Q_object:
--                self.elements.append(
--                    self._read_element(
--                        op, copy=copy, tlist=tlist, args=args, order=order,
--                        function_style=function_style,
--                        boundary_conditions=boundary_conditions
--                    )
--                )
--        else:
--            self.elements.append(
--                self._read_element(
--                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
--                    function_style=function_style,
--                    boundary_conditions=boundary_conditions
--                )
--            )
--
--        if compress:
--            self.compress()
--
--    def __repr__(self):
--        cls = self.__class__.__name__
--        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
--        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
--        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
--        return repr_str
--
--    def _read_element(self, op, copy, tlist, args, order, function_style, 
--                      boundary_conditions):
--        """ Read a Q_object item and return an element for that item. """
--        if isinstance(op, Qobj):
--            out = _ConstantElement(op.copy() if copy else op)
--            qobj = op
--        elif isinstance(op, list):
--            out = _EvoElement(
--                op[0].copy() if copy else op[0],
--                coefficient(op[1], tlist=tlist, args=args, order=order, 
--                            boundary_conditions=boundary_conditions)
--            )
--            qobj = op[0]
--        elif isinstance(op, _BaseElement):
--            out = op
--            qobj = op.qobj(0)
--        elif callable(op):
--            out = _FuncElement(op, args, style=function_style)
--            qobj = out.qobj(0)
--            if not isinstance(qobj, Qobj):
--                raise TypeError(
--                    "Function based time-dependent elements must have the"
--                    " signature f(t: double, args: dict) -> Qobj, but"
--                    " {!r} returned: {!r}".format(op, qobj)
--                )
--        else:
--            raise TypeError(
--                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
--                " or a function f(t: double, args: dict) -> Qobj, but"
--                " received: {!r}".format(op)
--            )
--
--        if self.dims is None:
--            self.dims = qobj.dims
--            self.shape = qobj.shape
--            self.type = qobj.type
--            self.superrep = qobj.superrep
--        elif self.dims != qobj.dims or self.shape != qobj.shape:
--            raise ValueError(
--                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
--                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
--                f" and shape {self.shape!r}."
--            )
--        elif self.type != qobj.type:
--            raise ValueError(
--                f"QobjEvo term {op!r} has type {qobj.type!r} but "
--                f"previous terms had type {self.type!r}."
--            )
--        elif self.superrep != qobj.superrep:
--            raise ValueError(
--                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
--                f"previous terms had superrep {self.superrep!r}."
--            )
--
--        return out
--
--    @classmethod
--    def _restore(cls, elements, dims, shape, type, superrep, flags):
--        """Recreate a QobjEvo without using __init__. """
--        cdef QobjEvo out = cls.__new__(cls)
--        out.elements = elements
--        out.dims = dims
--        out.shape = shape
--        out.type = type
--        out.superrep = superrep
--        out._issuper, out._isoper = flags
--        return out
--
--    def _getstate(self):
--        """ Obtain the state """
--        # For jax pytree representation
--        # auto_pickle create similar method __getstate__, but since it's
--        # automatically created, it could change depending on cython version
--        # etc., so we create our own.
--        return {
--            "elements": self.elements,
--            "dims": self.dims,
--            "shape": self.shape,
--            "type": self.type,
--            "superrep": self.superrep,
--            "flags": (self._issuper, self._isoper,)
--        }
--
--    def __call__(self, double t, dict _args=None, **kwargs):
--        """
--        Get the :class:`~Qobj` at ``t``.
--
--        Parameters
--        ----------
--        t : float
--            Time at which the ``QobjEvo`` is to be evalued.
--
--        _args : dict [optional]
--            New arguments as a dict. Update args with ``arguments(new_args)``.
--
--        **kwargs :
--            New arguments as a keywors. Update args with
--            ``arguments(**new_args)``.
--
--        .. note::
--            If both the positional ``_args`` and keywords are passed new values
--            from both will be used. If a key is present with both, the
--            ``_args`` dict value will take priority.
--        """
--        if _args is not None or kwargs:
--            if _args is not None:
--                kwargs.update(_args)
--            return QobjEvo(self, args=kwargs)(t)
--
--        t = self._prepare(t, None)
--
--        if self.isconstant:
--            # For constant QobjEvo's, we sum the contained Qobjs directly in
--            # order to retain the cached values of attributes like .isherm when
--            # possible, rather than calling _call(t) which may lose this cached
--            # information.
--            return sum(element.qobj(t) for element in self.elements)
--
--        cdef _BaseElement part = self.elements[0]
--        cdef double complex coeff = part.coeff(t)
--        obj = part.qobj(t)
--        cdef Data out = _data.mul(obj.data, coeff)
--        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
--        for element in self.elements[1:]:
--            part = <_BaseElement> element
--            coeff = part.coeff(t)
--            obj = part.qobj(t)
--            isherm &= <bint> obj._isherm and coeff.imag == 0
--            out = _data.add(out, obj.data, coeff)
--
--        return Qobj(
--            out, dims=self.dims, copy=False, isherm=isherm or None,
--            type=self.type, superrep=self.superrep
--        )
--
--    cpdef Data _call(QobjEvo self, double t):
--        t = self._prepare(t, None)
--        cdef Data out
--        cdef _BaseElement part = self.elements[0]
--        out = _data.mul(part.data(t),
--                        part.coeff(t))
--        for element in self.elements[1:]:
--            part = <_BaseElement> element
--
--            out = _data.add(
--                out,
--                part.data(t),
--                part.coeff(t)
--            )
--        return out
--
--    cdef object _prepare(QobjEvo self, object t, Data state=None):
--        """ Precomputation before computing getting the element at `t`"""
--        # We keep the function for feedback eventually
--        return t
--
--    def copy(QobjEvo self):
--        """Return a copy of this `QobjEvo`"""
--        return QobjEvo(self, compress=False)
--
--    def arguments(QobjEvo self, dict _args=None, **kwargs):
--        """
--        Update the arguments.
--
--        Parameters
--        ----------
--        _args : dict [optional]
--            New arguments as a dict. Update args with ``arguments(new_args)``.
--
--        **kwargs :
--            New arguments as a keywors. Update args with
--            ``arguments(**new_args)``.
--
--        .. note::
--            If both the positional ``_args`` and keywords are passed new values
--            from both will be used. If a key is present with both, the ``_args``
--            dict value will take priority.
--        """
--        if _args is not None:
--            kwargs.update(_args)
--        cache = []
--        self.elements = [
--            element.replace_arguments(kwargs, cache=cache)
--            for element in self.elements
--        ]
--
--
--    ###########################################################################
--    # Math function                                                           #
--    ###########################################################################
--    def __add__(left, right):
--        if isinstance(left, QobjEvo):
--            self = left
--            other = right
--        else:
--            self = right
--            other = left
--        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
--            return NotImplemented
--        res = self.copy()
--        res += other
--        return res
--
--    def __radd__(self, other):
--        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
--            return NotImplemented
--        res = self.copy()
--        res += other
--        return res
--
--    def __iadd__(QobjEvo self, other):
--        cdef _BaseElement element
--        if isinstance(other, QobjEvo):
--            if other.dims != self.dims:
--                raise TypeError("incompatible dimensions" +
--                                str(self.dims) + ", " + str(other.dims))
--            for element in (<QobjEvo> other).elements:
--                self.elements.append(element)
--        elif isinstance(other, Qobj):
--            if other.dims != self.dims:
--                raise TypeError("incompatible dimensions" +
--                                str(self.dims) + ", " + str(other.dims))
--            self.elements.append(_ConstantElement(other))
--        elif (
--            isinstance(other, numbers.Number) and
--            self.dims[0] == self.dims[1]
--        ):
--            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
--        else:
--            return NotImplemented
--        return self
--
--    def __sub__(left, right):
--        if isinstance(left, QobjEvo):
--            res = left.copy()
--            res += -right
--            return res
--        else:
--            res = -right.copy()
--            res += left
--            return res
--
--    def __rsub__(self, other):
--        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
--            return NotImplemented
--        res = -self
--        res += other
--        return res
--
--    def __isub__(self, other):
--        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
--            return NotImplemented
--        self += (-other)
--        return self
--
--    def __matmul__(left, right):
--        cdef QobjEvo res
--        if isinstance(left, QobjEvo):
--            return left.copy().__imatmul__(right)
--        elif isinstance(left, Qobj):
--            if left.dims[1] != (<QobjEvo> right).dims[0]:
--                raise TypeError("incompatible dimensions" +
--                                 str(left.dims[1]) + ", " +
--                                 str((<QobjEvo> right).dims[0]))
--
--            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
--            if type_ is None:
--                raise TypeError(
--                    "incompatible matmul types "
--                    + repr(left.type) + " and " + repr(right.type)
--                )
--
--            res = right.copy()
--            res.dims = [left.dims[0], right.dims[1]]
--            res.shape = (left.shape[0], right.shape[1])
--            res.type = type_
--            left = _ConstantElement(left)
--            res.elements = [left @ element for element in res.elements]
--            res._issuper = -1
--            res._isoper = -1
--            return res
--        else:
--            return NotImplemented
--
--    def __rmatmul__(QobjEvo self, other):
--        cdef QobjEvo res
--        if isinstance(other, Qobj):
--            if other.dims[1] != self.dims[0]:
--                raise TypeError("incompatible dimensions" +
--                                 str(other.dims[1]) + ", " +
--                                 str(self.dims[0]))
--
--            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
--            if type_ is None:
--                raise TypeError(
--                    "incompatible matmul types "
--                    + repr(other.type) + " and " + repr(self.type)
--                )
--
--            res = self.copy()
--            res.dims = [other.dims[0], res.dims[1]]
--            res.shape = (other.shape[0], res.shape[1])
--            res.type = type_
--            other = _ConstantElement(other)
--            res.elements = [other @ element for element in res.elements]
--            res._issuper = -1
--            res._isoper = -1
--            return res
--        else:
--            return NotImplemented
--
--    def __imatmul__(QobjEvo self, other):
--        if isinstance(other, (Qobj, QobjEvo)):
--            if self.dims[1] != other.dims[0]:
--                raise TypeError("incompatible dimensions" +
--                                str(self.dims[1]) + ", " +
--                                str(other.dims[0]))
--
--            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
--            if type_ is None:
--                raise TypeError(
--                    "incompatible matmul types "
--                    + repr(self.type) + " and " + repr(other.type)
--                )
--
--            self.dims = [self.dims[0], other.dims[1]]
--            self.shape = (self.shape[0], other.shape[1])
--            self.type = type_
--            self._issuper = -1
--            self._isoper = -1
--            if isinstance(other, Qobj):
--                other = _ConstantElement(other)
--                self.elements = [element @ other for element in self.elements]
--
--            elif isinstance(other, QobjEvo):
--                self.elements = [left @ right
--                    for left, right in itertools.product(
--                        self.elements, (<QobjEvo> other).elements
--                    )]
--        else:
--            return NotImplemented
--        return self
--
--    def __mul__(left, right):
--        if isinstance(left, QobjEvo):
--            return left.copy().__imul__(right)
--        elif isinstance(left, Qobj):
--            return right.__rmatmul__(left)
--        elif isinstance(left, (numbers.Number, Coefficient)):
--            return right.copy().__imul__(left)
--        else:
--            return NotImplemented
--
--    def __rmul__(self, other):
--        if isinstance(other, Qobj):
--            return self.__rmatmul__(other)
--        else:
--            res = self.copy()
--            res *= other
--            return res
--
--    def __imul__(QobjEvo self, other):
--        if isinstance(other, (Qobj, QobjEvo)):
--            self @= other
--        elif isinstance(other, numbers.Number):
--            self.elements = [element * other for element in self.elements]
--        elif isinstance(other, Coefficient):
--            other = _EvoElement(qutip.qeye(self.dims[1]), other)
--            self.elements = [element @ other for element in self.elements]
--        else:
--            return NotImplemented
--        return self
--
--    def __truediv__(left, right):
--        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
--            res = left.copy()
--            res *= 1 / right
--            return res
--        return NotImplemented
--
--    def __idiv__(self, other):
--        if not isinstance(other, numbers.Number):
--            return NotImplemented
--        self *= 1 / other
--        return self
--
--    def __neg__(self):
--        res = self.copy()
--        res *= -1
--        return res
--
--    ###########################################################################
--    # tensor                                                                  #
--    ###########################################################################
--    def __and__(left, right):
--        """
--        Syntax shortcut for tensor:
--        A & B ==> tensor(A, B)
--        """
--        return qutip.tensor(left, right)
--
--    ###########################################################################
--    # Unary transformation                                                    #
--    ###########################################################################
--    def trans(self):
--        """ Transpose of the quantum object """
--        cdef QobjEvo res = self.copy()
--        res.elements = [element.linear_map(Qobj.trans)
--                        for element in res.elements]
--        return res
--
--    def conj(self):
--        """Get the element-wise conjugation of the quantum object."""
--        cdef QobjEvo res = self.copy()
--        res.elements = [element.linear_map(Qobj.conj, True)
--                        for element in res.elements]
--        return res
--
--    def dag(self):
--        """Get the Hermitian adjoint of the quantum object."""
--        cdef QobjEvo res = self.copy()
--        res.elements = [element.linear_map(Qobj.dag, True)
--                        for element in res.elements]
--        return res
--
--    def to(self, data_type):
--        """
--        Convert the underlying data store of all component into the desired
--        storage representation.
--
--        The different storage representations available are the "data-layer
--        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
--        which respectively construct a dense matrix store and a compressed
--        sparse row one.
--
--        The `QobjEvo` is transformed inplace.
--
--        Parameters
--        ----------
--        data_type : type
--            The data-layer type that the data of this `Qobj` should be
--            converted to.
--
--        Returns
--        -------
--        None
--        """
--        return self.linear_map(partial(Qobj.to, data_type=data_type),
--                               _skip_check=True)
--
--    def tidyup(self, atol=1e-12):
--        """Removes small elements from quantum object."""
--        for element in self.elements:
--            if type(element) is _ConstantElement:
--                element = _ConstantElement(element.qobj(0).tidyup(atol))
--            elif type(element) is _EvoElement:
--                element = _EvoElement(element.qobj(0).tidyup(atol),
--                                      element._coefficient)
--        return self
--
--    def linear_map(self, op_mapping, *, _skip_check=False):
--        """
--        Apply mapping to each Qobj contribution.
--
--        Example:
--        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
--        gives the same result has
--        ``QobjEvo([spre(sigmax()), coeff])``
--
--        Returns
--        -------
--        :class:`.QobjEvo`
--            Modified object
--
--        Notes
--        -----
--        Does not modify the coefficients, thus ``linear_map(conj)`` would not
--        give the the conjugate of the QobjEvo. It's only valid for linear
--        transformations.
--        """
--        if not _skip_check:
--            out = op_mapping(self(0))
--            if not isinstance(out, Qobj):
--                raise TypeError("The op_mapping function must return a Qobj")
--        cdef QobjEvo res = self.copy()
--        res.elements = [element.linear_map(op_mapping) for element in res.elements]
--        res.dims = res.elements[0].qobj(0).dims
--        res.shape = res.elements[0].qobj(0).shape
--        res.type = res.elements[0].qobj(0).type
--        res._issuper = res.elements[0].qobj(0).issuper
--        res._isoper = res.elements[0].qobj(0).isoper
--        if not _skip_check:
--            if res(0) != out:
--                raise ValueError("The mapping is not linear")
--
--        return res
--
--    ###########################################################################
--    # Cleaning and compress                                                   #
--    ###########################################################################
--    def _compress_merge_qobj(self, coeff_elements):
--        """Merge element with matching qobj:
--        ``[A, f1], [A, f2] -> [A, f1+f2]``
--        """
--        cleaned_elements = []
--        # Mimic a dict with Qobj not hashable
--        qobjs = []
--        coeffs = []
--        for element in coeff_elements:
--            for i, qobj in enumerate(qobjs):
--                if element.qobj(0) == qobj:
--                    coeffs[i] = coeffs[i] + element._coefficient
--                    break
--            else:
--                qobjs.append(element.qobj(0))
--                coeffs.append(element._coefficient)
--        for qobj, coeff in zip(qobjs, coeffs):
--            cleaned_elements.append(_EvoElement(qobj, coeff))
--        return cleaned_elements
--
--    def compress(self):
--        """
--        Look for redundance in the :obj:`~QobjEvo` components:
--
--        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
--        summed.
--        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
--
--        Example:
--        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
--
--        The :class:`~QobjEvo` is transformed inplace.
--
--        Returns
--        -------
--        None
--        """
--        cte_elements = []
--        coeff_elements = []
--        func_elements = []
--        for element in self.elements:
--            if type(element) is _ConstantElement:
--                cte_elements.append(element)
--            elif type(element) is _EvoElement:
--                coeff_elements.append(element)
--            else:
--                func_elements.append(element)
--
--        cleaned_elements = []
--        if len(cte_elements) >= 2:
--            # Multiple constant parts
--            cleaned_elements.append(_ConstantElement(
--                sum(element.qobj(0) for element in cte_elements)))
--        else:
--            cleaned_elements += cte_elements
--
--        coeff_elements = self._compress_merge_qobj(coeff_elements)
--        cleaned_elements += coeff_elements + func_elements
--
--        self.elements = cleaned_elements
--
--    def to_list(QobjEvo self):
--        """
--        Restore the QobjEvo to a list form.
--
--        Returns
--        -------
--        list_qevo: list
--            The QobjEvo as a list, element are either :class:`Qobj` for
--            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
--            The original format of the :class:`Coefficient` is not restored.
--            Lastly if the original `QobjEvo` is constructed with a function
--            returning a Qobj, the term is returned as a pair of the original
--            function and args (``dict``).
--        """
--        out = []
--        for element in self.elements:
--            if isinstance(element, _ConstantElement):
--                out.append(element.qobj(0))
--            elif isinstance(element, _EvoElement):
--                coeff = element._coefficient
--                out.append([element.qobj(0), coeff])
--            elif isinstance(element, _FuncElement):
--                func = element._func
--                args = element._args
--                out.append([func, args])
--            else:
--                out.append([element, {}])
--        return out
--
--    ###########################################################################
--    # properties                                                              #
--    ###########################################################################
--    @property
--    def num_elements(self):
--        """Number of parts composing the system"""
--        return len(self.elements)
--
--    @property
--    def isconstant(self):
--        """Does the system change depending on ``t``"""
--        return not any(type(element) is not _ConstantElement
--                       for element in self.elements)
--
--    @property
--    def isoper(self):
--        """Indicates if the system represents an operator."""
--        # TODO: isoper should be part of dims
--        if self._isoper == -1:
--            self._isoper = type_from_dims(self.dims) == "oper"
--        return self._isoper
--
--    @property
--    def issuper(self):
--        """Indicates if the system represents a superoperator."""
--        # TODO: issuper should/will be part of dims
--        # remove self._issuper then
--        if self._issuper == -1:
--            self._issuper = type_from_dims(self.dims) == "super"
--        return self._issuper
--
--    ###########################################################################
--    # operation methods                                                       #
--    ###########################################################################
--    def expect(QobjEvo self, object t, state, check_real=True):
--        """
--        Expectation value of this operator at time ``t`` with the state.
--
--        Parameters
--        ----------
--        t : float
--            Time of the operator to apply.
--
--        state : Qobj
--            right matrix of the product
--
--        check_real : bool (True)
--            Whether to convert the result to a `real` when the imaginary part
--            is smaller than the real part by a dactor of
--            ``settings.core['rtol']``.
--
--        Returns
--        -------
--        expect : float or complex
--            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
--            ``trace(self @ matrix)`` is ``state`` is an operator or
--            operator-ket.
--        """
--        # TODO: remove reading from `settings` for a typed value when options
--        # support property.
--        cdef float herm_rtol = settings.core['rtol']
--        if not isinstance(state, Qobj):
--            raise TypeError("A Qobj state is expected")
--        if not (self.isoper or self.issuper):
--            raise ValueError("Must be an operator or super operator to compute"
--                             " an expectation value")
--        if not (
--            (self.dims[1] == state.dims[0]) or
--            (self.issuper and self.dims[1] == state.dims)
--        ):
--            raise ValueError("incompatible dimensions " + str(self.dims) +
--                             ", " + str(state.dims))
--        out = self.expect_data(t, state.data)
--        if (
--            check_real and
--            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
--        ):
--            return out.real
--        return out
--
--    cpdef object expect_data(QobjEvo self, object t, Data state):
--        """
--        Expectation is defined as ``state.adjoint() @ self @ state`` if
--        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
--        superoperator.  If ``state`` is an operator and ``self`` is an
--        operator, then expectation is ``trace(self @ matrix)``.
--        """
--        if type(state) is Dense:
--            return self._expect_dense(t, state)
--        cdef _BaseElement part
--        cdef object out = 0.
--        cdef Data part_data
--        cdef object expect_func
--        t = self._prepare(t, state)
--        if self.issuper:
--            if state.shape[1] != 1:
--                state = _data.column_stack(state)
--            expect_func = _data.expect_super
--        else:
--            expect_func = _data.expect
--
--        for element in self.elements:
--            part = (<_BaseElement> element)
--            part_data = part.data(t)
--            out += part.coeff(t) * expect_func(part_data, state)
--        return out
--
--    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
--        """For Dense state, ``column_stack_dense`` can be done inplace if in
--        fortran format."""
--        cdef size_t nrow = state.shape[0]
--        cdef _BaseElement part
--        cdef double complex out = 0., coeff
--        cdef Data part_data
--        t = self._prepare(t, state)
--        if self.issuper:
--            if state.shape[1] != 1:
--                state = column_stack_dense(state, inplace=state.fortran)
--            try:
--                for element in self.elements:
--                    part = (<_BaseElement> element)
--                    coeff = part.coeff(t)
--                    part_data = part.data(t)
--                    out += coeff * expect_super_data_dense(part_data, state)
--            finally:
--                if state.fortran:
--                    # `state` was reshaped inplace, restore it's original shape
--                    column_unstack_dense(state, nrow, inplace=state.fortran)
--        else:
--            for element in self.elements:
--                part = (<_BaseElement> element)
--                coeff = part.coeff(t)
--                part_data = part.data(t)
--                out += coeff * expect_data_dense(part_data, state)
--        return out
--
--    def matmul(self, t, state):
--        """
--        Product of this operator at time ``t`` to the state.
--        ``self(t) @ state``
--
--        Parameters
--        ----------
--        t : float
--            Time of the operator to apply.
--        state : Qobj
--            right matrix of the product
--
--        Returns
--        -------
--        product : Qobj
--            The result product as a Qobj
--        """
--        if not isinstance(state, Qobj):
--            raise TypeError("A Qobj state is expected")
--
--        if self.dims[1] != state.dims[0]:
--            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
--                             ", " + str(state.dims[0]))
--
--        return Qobj(self.matmul_data(t, state.data),
--                    dims=[self.dims[0], state.dims[1]],
--                    copy=False
--                    )
--
--    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
--        """Compute ``out += self(t) @ state``"""
--        cdef _BaseElement part
--        t = self._prepare(t, state)
--        if out is None and type(state) is Dense:
--            out = dense.zeros(self.shape[0], state.shape[1],
--                              (<Dense> state).fortran)
--        elif out is None:
--            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
--
--        for element in self.elements:
--            part = (<_BaseElement> element)
--            out = part.matmul_data_t(t, state, out)
--        return out
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
-+
-+import numpy as np
-+import numbers
-+import itertools
-+from functools import partial
-+
-+import qutip
-+from .. import Qobj
-+from .. import data as _data
-+from ..coefficient import coefficient, CompilationOptions
-+from ._element import *
-+from ..dimensions import type_from_dims
-+from qutip.settings import settings
-+
-+from qutip.core.cy._element cimport _BaseElement
-+from qutip.core.data cimport Dense, Data, dense
-+from qutip.core.data.expect cimport *
-+from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
-+from qutip.core.cy.coefficient cimport Coefficient
-+from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
-+from libc.math cimport fabs
-+
-+__all__ = ['QobjEvo']
-+
-+cdef class QobjEvo:
-+    """
-+    A class for representing time-dependent quantum objects, such as quantum
-+    operators and states.
-+
-+    Importantly, :obj:`~QobjEvo` instances are used to represent such
-+    time-dependent quantum objects when working with QuTiP solvers.
-+
-+    A :obj:`~QobjEvo` instance may be constructed from one of the following:
-+
-+      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
-+        value of the quantum object at time ``t``.
-+
-+      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
-+        any item that can be used to construct a coefficient (e.g. a function,
-+        a numpy array of coefficient values, a string expression).
-+
-+      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
-+
-+      * a list of such callables, pairs or :obj:`~Qobj`\s.
-+
-+      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
-+        are ignored except ``args`` which, if passed, replaces the existing
-+        arguments).
-+
-+    Parameters
-+    ----------
-+    Q_object : callable, list or Qobj
-+        A specification of the time-depedent quantum object. See the
-+        paragraph above for a full description and the examples section below
-+        for examples.
-+
-+    args : dict, optional
-+        A dictionary that contains the arguments for the coefficients.
-+        Arguments may be omitted if no function or string coefficients that
-+        require arguments are present.
-+
-+    tlist : array-like, optional
-+        A list of times corresponding to the values of the coefficients
-+        supplied as numpy arrays. If no coefficients are supplied as numpy
-+        arrays, ``tlist`` may be omitted, otherwise it is required.
-+
-+        The times in ``tlist`` do not need to be equidistant, but must
-+        be sorted.
-+
-+        By default, a cubic spline interpolation will be used to interpolate
-+        the value of the (numpy array) coefficients at time ``t``. If the
-+        coefficients are to be treated as step functions, pass the argument
-+        ``order=0`` (see below).
-+
-+    order : int, default=3
-+        Order of the spline interpolation that is to be used to interpolate
-+        the value of the (numpy array) coefficients at time ``t``.
-+        ``0`` use previous or left value.
-+
-+    copy : bool, default=True
-+        Whether to make a copy of the :obj:`Qobj` instances supplied in
-+        the ``Q_object`` parameter.
-+
-+    compress : bool, default=True
-+        Whether to compress the :obj:`QobjEvo` instance terms after the
-+        instance has been created.
-+
-+        This sums the constant terms in a single term and combines
-+        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
-+        pair containing the sum of the coefficients.
-+
-+        See :meth:`compress`.
-+
-+    function_style : {None, "pythonic", "dict", "auto"}
-+        The style of function signature used by callables in ``Q_object``.
-+        If style is ``None``, the value of
-+        ``qutip.settings.core["function_coefficient_style"]``
-+        is used. Otherwise the supplied value overrides the global setting.
-+
-+
-+    boundary_conditions : 2-Tuple, str or None, optional
-+        Boundary conditions for spline evaluation. Default value is `None`.
-+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
-+        Refer to Scipy's documentation for further details:
-+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-+
-+
-+    Attributes
-+    ----------
-+    dims : list
-+        List of dimensions keeping track of the tensor structure.
-+
-+    shape : (int, int)
-+        List of dimensions keeping track of the tensor structure.
-+
-+    type : str
-+        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
-+        'operator-bra', or 'super'.
-+
-+    superrep : str
-+        Representation used if `type` is 'super'. One of 'super'
-+        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
-+
-+    Examples
-+    --------
-+
-+    A :obj:`~QobjEvo` constructed from a function:
-+
-+    .. code-block::
-+
-+        def f(t, args):
-+            return qutip.qeye(N) * np.exp(args['w'] * t)
-+
-+        QobjEvo(f, args={'w': 1j})
-+
-+
-+    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
-+    ``[Qobj, Coefficient]`` pairs:
-+
-+    .. code-block::
-+
-+        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
-+
-+    The coefficients may be specified either using a :obj:`~Coefficient`
-+    object or by a function, string, numpy array or any object that
-+    can be passed to the :func:`~coefficient` function. See the documentation
-+    of :func:`coefficient` for a full description.
-+
-+    An example of a coefficient specified by a function:
-+
-+    .. code-block::
-+
-+        def f1_t(t, args):
-+            return np.exp(-1j * t * args["w1"])
-+
-+        QobjEvo([[H1, f1_t]], args={"w1": 1.})
-+
-+    And of coefficients specified by string expressions:
-+
-+    .. code-block::
-+
-+        H = QobjEvo(
-+            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
-+            args={"w1": 1., "w2": 2.}
-+        )
-+
-+    Coefficients maybe also be expressed as numpy arrays giving a list
-+    of the coefficient values:
-+
-+    .. code-block:: python
-+
-+        tlist = np.logspace(-5, 0, 100)
-+        H = QobjEvo(
-+            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
-+            tlist=tlist
-+        )
-+
-+    The coeffients array must have the same len as the tlist.
-+
-+    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
-+    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
-+
-+    .. code-block:: python
-+
-+        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
-+        qevo = H0 + H1 * coeff
-+
-+    """
-+    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
-+                 order=3, copy=True, compress=True,
-+                 function_style=None, boundary_conditions=None):
-+        if isinstance(Q_object, QobjEvo):
-+            self.dims = Q_object.dims.copy()
-+            self.shape = Q_object.shape
-+            self.type = Q_object.type
-+            self._issuper = (<QobjEvo> Q_object)._issuper
-+            self._isoper = (<QobjEvo> Q_object)._isoper
-+            self.elements = (<QobjEvo> Q_object).elements.copy()
-+            if args:
-+                self.arguments(args)
-+            if compress:
-+                self.compress()
-+            return
-+
-+        self.elements = []
-+        self.dims = None
-+        self.shape = (0, 0)
-+        self._issuper = -1
-+        self._isoper = -1
-+        args = args or {}
-+
-+        if (
-+            isinstance(Q_object, list)
-+            and len(Q_object) == 2
-+            and isinstance(Q_object[0], Qobj)
-+            and not isinstance(Q_object[1], (Qobj, list))
-+        ):
-+            # The format is [Qobj, coefficient]
-+            Q_object = [Q_object]
-+
-+        if isinstance(Q_object, list):
-+            for op in Q_object:
-+                self.elements.append(
-+                    self._read_element(
-+                        op, copy=copy, tlist=tlist, args=args, order=order,
-+                        function_style=function_style,
-+                        boundary_conditions=boundary_conditions
-+                    )
-+                )
-+        else:
-+            self.elements.append(
-+                self._read_element(
-+                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
-+                    function_style=function_style,
-+                    boundary_conditions=boundary_conditions
-+                )
-+            )
-+
-+        if compress:
-+            self.compress()
-+
-+    def __repr__(self):
-+        cls = self.__class__.__name__
-+        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
-+        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
-+        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
-+        return repr_str
-+
-+    def _read_element(self, op, copy, tlist, args, order, function_style, 
-+                      boundary_conditions):
-+        """ Read a Q_object item and return an element for that item. """
-+        if isinstance(op, Qobj):
-+            out = _ConstantElement(op.copy() if copy else op)
-+            qobj = op
-+        elif isinstance(op, list):
-+            out = _EvoElement(
-+                op[0].copy() if copy else op[0],
-+                coefficient(op[1], tlist=tlist, args=args, order=order, 
-+                            boundary_conditions=boundary_conditions)
-+            )
-+            qobj = op[0]
-+        elif isinstance(op, _BaseElement):
-+            out = op
-+            qobj = op.qobj(0)
-+        elif callable(op):
-+            out = _FuncElement(op, args, style=function_style)
-+            qobj = out.qobj(0)
-+            if not isinstance(qobj, Qobj):
-+                raise TypeError(
-+                    "Function based time-dependent elements must have the"
-+                    " signature f(t: double, args: dict) -> Qobj, but"
-+                    " {!r} returned: {!r}".format(op, qobj)
-+                )
-+        else:
-+            raise TypeError(
-+                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
-+                " or a function f(t: double, args: dict) -> Qobj, but"
-+                " received: {!r}".format(op)
-+            )
-+
-+        if self.dims is None:
-+            self.dims = qobj.dims
-+            self.shape = qobj.shape
-+            self.type = qobj.type
-+            self.superrep = qobj.superrep
-+        elif self.dims != qobj.dims or self.shape != qobj.shape:
-+            raise ValueError(
-+                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
-+                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
-+                f" and shape {self.shape!r}."
-+            )
-+        elif self.type != qobj.type:
-+            raise ValueError(
-+                f"QobjEvo term {op!r} has type {qobj.type!r} but "
-+                f"previous terms had type {self.type!r}."
-+            )
-+        elif self.superrep != qobj.superrep:
-+            raise ValueError(
-+                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
-+                f"previous terms had superrep {self.superrep!r}."
-+            )
-+
-+        return out
-+
-+    @classmethod
-+    def _restore(cls, elements, dims, shape, type, superrep, flags):
-+        """Recreate a QobjEvo without using __init__. """
-+        cdef QobjEvo out = cls.__new__(cls)
-+        out.elements = elements
-+        out.dims = dims
-+        out.shape = shape
-+        out.type = type
-+        out.superrep = superrep
-+        out._issuper, out._isoper = flags
-+        return out
-+
-+    def _getstate(self):
-+        """ Obtain the state """
-+        # For jax pytree representation
-+        # auto_pickle create similar method __getstate__, but since it's
-+        # automatically created, it could change depending on cython version
-+        # etc., so we create our own.
-+        return {
-+            "elements": self.elements,
-+            "dims": self.dims,
-+            "shape": self.shape,
-+            "type": self.type,
-+            "superrep": self.superrep,
-+            "flags": (self._issuper, self._isoper,)
-+        }
-+
-+    def __call__(self, double t, dict _args=None, **kwargs):
-+        """
-+        Get the :class:`~Qobj` at ``t``.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time at which the ``QobjEvo`` is to be evalued.
-+
-+        _args : dict [optional]
-+            New arguments as a dict. Update args with ``arguments(new_args)``.
-+
-+        **kwargs :
-+            New arguments as a keywors. Update args with
-+            ``arguments(**new_args)``.
-+
-+        .. note::
-+            If both the positional ``_args`` and keywords are passed new values
-+            from both will be used. If a key is present with both, the
-+            ``_args`` dict value will take priority.
-+        """
-+        if _args is not None or kwargs:
-+            if _args is not None:
-+                kwargs.update(_args)
-+            return QobjEvo(self, args=kwargs)(t)
-+
-+        t = self._prepare(t, None)
-+
-+        if self.isconstant:
-+            # For constant QobjEvo's, we sum the contained Qobjs directly in
-+            # order to retain the cached values of attributes like .isherm when
-+            # possible, rather than calling _call(t) which may lose this cached
-+            # information.
-+            return sum(element.qobj(t) for element in self.elements)
-+
-+        cdef _BaseElement part = self.elements[0]
-+        cdef double complex coeff = part.coeff(t)
-+        obj = part.qobj(t)
-+        cdef Data out = _data.mul(obj.data, coeff)
-+        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
-+        for element in self.elements[1:]:
-+            part = <_BaseElement> element
-+            coeff = part.coeff(t)
-+            obj = part.qobj(t)
-+            isherm &= <bint> obj._isherm and coeff.imag == 0
-+            out = _data.add(out, obj.data, coeff)
-+
-+        return Qobj(
-+            out, dims=self.dims, copy=False, isherm=isherm or None,
-+            type=self.type, superrep=self.superrep
-+        )
-+
-+    cpdef Data _call(QobjEvo self, double t):
-+        t = self._prepare(t, None)
-+        cdef Data out
-+        cdef _BaseElement part = self.elements[0]
-+        out = _data.mul(part.data(t),
-+                        part.coeff(t))
-+        for element in self.elements[1:]:
-+            part = <_BaseElement> element
-+
-+            out = _data.add(
-+                out,
-+                part.data(t),
-+                part.coeff(t)
-+            )
-+        return out
-+
-+    cdef object _prepare(QobjEvo self, object t, Data state=None):
-+        """ Precomputation before computing getting the element at `t`"""
-+        # We keep the function for feedback eventually
-+        return t
-+
-+    def copy(QobjEvo self):
-+        """Return a copy of this `QobjEvo`"""
-+        return QobjEvo(self, compress=False)
-+
-+    def arguments(QobjEvo self, dict _args=None, **kwargs):
-+        """
-+        Update the arguments.
-+
-+        Parameters
-+        ----------
-+        _args : dict [optional]
-+            New arguments as a dict. Update args with ``arguments(new_args)``.
-+
-+        **kwargs :
-+            New arguments as a keywors. Update args with
-+            ``arguments(**new_args)``.
-+
-+        .. note::
-+            If both the positional ``_args`` and keywords are passed new values
-+            from both will be used. If a key is present with both, the ``_args``
-+            dict value will take priority.
-+        """
-+        if _args is not None:
-+            kwargs.update(_args)
-+        cache = []
-+        self.elements = [
-+            element.replace_arguments(kwargs, cache=cache)
-+            for element in self.elements
-+        ]
-+
-+
-+    ###########################################################################
-+    # Math function                                                           #
-+    ###########################################################################
-+    def __add__(left, right):
-+        if isinstance(left, QobjEvo):
-+            self = left
-+            other = right
-+        else:
-+            self = right
-+            other = left
-+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-+            return NotImplemented
-+        res = self.copy()
-+        res += other
-+        return res
-+
-+    def __radd__(self, other):
-+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-+            return NotImplemented
-+        res = self.copy()
-+        res += other
-+        return res
-+
-+    def __iadd__(QobjEvo self, other):
-+        cdef _BaseElement element
-+        if isinstance(other, QobjEvo):
-+            if other.dims != self.dims:
-+                raise TypeError("incompatible dimensions" +
-+                                str(self.dims) + ", " + str(other.dims))
-+            for element in (<QobjEvo> other).elements:
-+                self.elements.append(element)
-+        elif isinstance(other, Qobj):
-+            if other.dims != self.dims:
-+                raise TypeError("incompatible dimensions" +
-+                                str(self.dims) + ", " + str(other.dims))
-+            self.elements.append(_ConstantElement(other))
-+        elif (
-+            isinstance(other, numbers.Number) and
-+            self.dims[0] == self.dims[1]
-+        ):
-+            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
-+        else:
-+            return NotImplemented
-+        return self
-+
-+    def __sub__(left, right):
-+        if isinstance(left, QobjEvo):
-+            res = left.copy()
-+            res += -right
-+            return res
-+        else:
-+            res = -right.copy()
-+            res += left
-+            return res
-+
-+    def __rsub__(self, other):
-+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-+            return NotImplemented
-+        res = -self
-+        res += other
-+        return res
-+
-+    def __isub__(self, other):
-+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-+            return NotImplemented
-+        self += (-other)
-+        return self
-+
-+    def __matmul__(left, right):
-+        cdef QobjEvo res
-+        if isinstance(left, QobjEvo):
-+            return left.copy().__imatmul__(right)
-+        elif isinstance(left, Qobj):
-+            if left.dims[1] != (<QobjEvo> right).dims[0]:
-+                raise TypeError("incompatible dimensions" +
-+                                 str(left.dims[1]) + ", " +
-+                                 str((<QobjEvo> right).dims[0]))
-+
-+            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
-+            if type_ is None:
-+                raise TypeError(
-+                    "incompatible matmul types "
-+                    + repr(left.type) + " and " + repr(right.type)
-+                )
-+
-+            res = right.copy()
-+            res.dims = [left.dims[0], right.dims[1]]
-+            res.shape = (left.shape[0], right.shape[1])
-+            res.type = type_
-+            left = _ConstantElement(left)
-+            res.elements = [left @ element for element in res.elements]
-+            res._issuper = -1
-+            res._isoper = -1
-+            return res
-+        else:
-+            return NotImplemented
-+
-+    def __rmatmul__(QobjEvo self, other):
-+        cdef QobjEvo res
-+        if isinstance(other, Qobj):
-+            if other.dims[1] != self.dims[0]:
-+                raise TypeError("incompatible dimensions" +
-+                                 str(other.dims[1]) + ", " +
-+                                 str(self.dims[0]))
-+
-+            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
-+            if type_ is None:
-+                raise TypeError(
-+                    "incompatible matmul types "
-+                    + repr(other.type) + " and " + repr(self.type)
-+                )
-+
-+            res = self.copy()
-+            res.dims = [other.dims[0], res.dims[1]]
-+            res.shape = (other.shape[0], res.shape[1])
-+            res.type = type_
-+            other = _ConstantElement(other)
-+            res.elements = [other @ element for element in res.elements]
-+            res._issuper = -1
-+            res._isoper = -1
-+            return res
-+        else:
-+            return NotImplemented
-+
-+    def __imatmul__(QobjEvo self, other):
-+        if isinstance(other, (Qobj, QobjEvo)):
-+            if self.dims[1] != other.dims[0]:
-+                raise TypeError("incompatible dimensions" +
-+                                str(self.dims[1]) + ", " +
-+                                str(other.dims[0]))
-+
-+            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
-+            if type_ is None:
-+                raise TypeError(
-+                    "incompatible matmul types "
-+                    + repr(self.type) + " and " + repr(other.type)
-+                )
-+
-+            self.dims = [self.dims[0], other.dims[1]]
-+            self.shape = (self.shape[0], other.shape[1])
-+            self.type = type_
-+            self._issuper = -1
-+            self._isoper = -1
-+            if isinstance(other, Qobj):
-+                other = _ConstantElement(other)
-+                self.elements = [element @ other for element in self.elements]
-+
-+            elif isinstance(other, QobjEvo):
-+                self.elements = [left @ right
-+                    for left, right in itertools.product(
-+                        self.elements, (<QobjEvo> other).elements
-+                    )]
-+        else:
-+            return NotImplemented
-+        return self
-+
-+    def __mul__(left, right):
-+        if isinstance(left, QobjEvo):
-+            return left.copy().__imul__(right)
-+        elif isinstance(left, Qobj):
-+            return right.__rmatmul__(left)
-+        elif isinstance(left, (numbers.Number, Coefficient)):
-+            return right.copy().__imul__(left)
-+        else:
-+            return NotImplemented
-+
-+    def __rmul__(self, other):
-+        if isinstance(other, Qobj):
-+            return self.__rmatmul__(other)
-+        else:
-+            res = self.copy()
-+            res *= other
-+            return res
-+
-+    def __imul__(QobjEvo self, other):
-+        if isinstance(other, (Qobj, QobjEvo)):
-+            self @= other
-+        elif isinstance(other, numbers.Number):
-+            self.elements = [element * other for element in self.elements]
-+        elif isinstance(other, Coefficient):
-+            other = _EvoElement(qutip.qeye(self.dims[1]), other)
-+            self.elements = [element @ other for element in self.elements]
-+        else:
-+            return NotImplemented
-+        return self
-+
-+    def __truediv__(left, right):
-+        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
-+            res = left.copy()
-+            res *= 1 / right
-+            return res
-+        return NotImplemented
-+
-+    def __idiv__(self, other):
-+        if not isinstance(other, numbers.Number):
-+            return NotImplemented
-+        self *= 1 / other
-+        return self
-+
-+    def __neg__(self):
-+        res = self.copy()
-+        res *= -1
-+        return res
-+
-+    ###########################################################################
-+    # tensor                                                                  #
-+    ###########################################################################
-+    def __and__(left, right):
-+        """
-+        Syntax shortcut for tensor:
-+        A & B ==> tensor(A, B)
-+        """
-+        return qutip.tensor(left, right)
-+
-+    ###########################################################################
-+    # Unary transformation                                                    #
-+    ###########################################################################
-+    def trans(self):
-+        """ Transpose of the quantum object """
-+        cdef QobjEvo res = self.copy()
-+        res.elements = [element.linear_map(Qobj.trans)
-+                        for element in res.elements]
-+        return res
-+
-+    def conj(self):
-+        """Get the element-wise conjugation of the quantum object."""
-+        cdef QobjEvo res = self.copy()
-+        res.elements = [element.linear_map(Qobj.conj, True)
-+                        for element in res.elements]
-+        return res
-+
-+    def dag(self):
-+        """Get the Hermitian adjoint of the quantum object."""
-+        cdef QobjEvo res = self.copy()
-+        res.elements = [element.linear_map(Qobj.dag, True)
-+                        for element in res.elements]
-+        return res
-+
-+    def to(self, data_type):
-+        """
-+        Convert the underlying data store of all component into the desired
-+        storage representation.
-+
-+        The different storage representations available are the "data-layer
-+        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
-+        which respectively construct a dense matrix store and a compressed
-+        sparse row one.
-+
-+        The `QobjEvo` is transformed inplace.
-+
-+        Parameters
-+        ----------
-+        data_type : type
-+            The data-layer type that the data of this `Qobj` should be
-+            converted to.
-+
-+        Returns
-+        -------
-+        None
-+        """
-+        return self.linear_map(partial(Qobj.to, data_type=data_type),
-+                               _skip_check=True)
-+
-+    def tidyup(self, atol=1e-12):
-+        """Removes small elements from quantum object."""
-+        for element in self.elements:
-+            if type(element) is _ConstantElement:
-+                element = _ConstantElement(element.qobj(0).tidyup(atol))
-+            elif type(element) is _EvoElement:
-+                element = _EvoElement(element.qobj(0).tidyup(atol),
-+                                      element._coefficient)
-+        return self
-+
-+    def linear_map(self, op_mapping, *, _skip_check=False):
-+        """
-+        Apply mapping to each Qobj contribution.
-+
-+        Example:
-+        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
-+        gives the same result has
-+        ``QobjEvo([spre(sigmax()), coeff])``
-+
-+        Returns
-+        -------
-+        :class:`.QobjEvo`
-+            Modified object
-+
-+        Notes
-+        -----
-+        Does not modify the coefficients, thus ``linear_map(conj)`` would not
-+        give the the conjugate of the QobjEvo. It's only valid for linear
-+        transformations.
-+        """
-+        if not _skip_check:
-+            out = op_mapping(self(0))
-+            if not isinstance(out, Qobj):
-+                raise TypeError("The op_mapping function must return a Qobj")
-+        cdef QobjEvo res = self.copy()
-+        res.elements = [element.linear_map(op_mapping) for element in res.elements]
-+        res.dims = res.elements[0].qobj(0).dims
-+        res.shape = res.elements[0].qobj(0).shape
-+        res.type = res.elements[0].qobj(0).type
-+        res._issuper = res.elements[0].qobj(0).issuper
-+        res._isoper = res.elements[0].qobj(0).isoper
-+        if not _skip_check:
-+            if res(0) != out:
-+                raise ValueError("The mapping is not linear")
-+
-+        return res
-+
-+    ###########################################################################
-+    # Cleaning and compress                                                   #
-+    ###########################################################################
-+    def _compress_merge_qobj(self, coeff_elements):
-+        """Merge element with matching qobj:
-+        ``[A, f1], [A, f2] -> [A, f1+f2]``
-+        """
-+        cleaned_elements = []
-+        # Mimic a dict with Qobj not hashable
-+        qobjs = []
-+        coeffs = []
-+        for element in coeff_elements:
-+            for i, qobj in enumerate(qobjs):
-+                if element.qobj(0) == qobj:
-+                    coeffs[i] = coeffs[i] + element._coefficient
-+                    break
-+            else:
-+                qobjs.append(element.qobj(0))
-+                coeffs.append(element._coefficient)
-+        for qobj, coeff in zip(qobjs, coeffs):
-+            cleaned_elements.append(_EvoElement(qobj, coeff))
-+        return cleaned_elements
-+
-+    def compress(self):
-+        """
-+        Look for redundance in the :obj:`~QobjEvo` components:
-+
-+        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
-+        summed.
-+        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
-+
-+        Example:
-+        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
-+
-+        The :class:`~QobjEvo` is transformed inplace.
-+
-+        Returns
-+        -------
-+        None
-+        """
-+        cte_elements = []
-+        coeff_elements = []
-+        func_elements = []
-+        for element in self.elements:
-+            if type(element) is _ConstantElement:
-+                cte_elements.append(element)
-+            elif type(element) is _EvoElement:
-+                coeff_elements.append(element)
-+            else:
-+                func_elements.append(element)
-+
-+        cleaned_elements = []
-+        if len(cte_elements) >= 2:
-+            # Multiple constant parts
-+            cleaned_elements.append(_ConstantElement(
-+                sum(element.qobj(0) for element in cte_elements)))
-+        else:
-+            cleaned_elements += cte_elements
-+
-+        coeff_elements = self._compress_merge_qobj(coeff_elements)
-+        cleaned_elements += coeff_elements + func_elements
-+
-+        self.elements = cleaned_elements
-+
-+    def to_list(QobjEvo self):
-+        """
-+        Restore the QobjEvo to a list form.
-+
-+        Returns
-+        -------
-+        list_qevo: list
-+            The QobjEvo as a list, element are either :class:`Qobj` for
-+            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
-+            The original format of the :class:`Coefficient` is not restored.
-+            Lastly if the original `QobjEvo` is constructed with a function
-+            returning a Qobj, the term is returned as a pair of the original
-+            function and args (``dict``).
-+        """
-+        out = []
-+        for element in self.elements:
-+            if isinstance(element, _ConstantElement):
-+                out.append(element.qobj(0))
-+            elif isinstance(element, _EvoElement):
-+                coeff = element._coefficient
-+                out.append([element.qobj(0), coeff])
-+            elif isinstance(element, _FuncElement):
-+                func = element._func
-+                args = element._args
-+                out.append([func, args])
-+            else:
-+                out.append([element, {}])
-+        return out
-+
-+    ###########################################################################
-+    # properties                                                              #
-+    ###########################################################################
-+    @property
-+    def num_elements(self):
-+        """Number of parts composing the system"""
-+        return len(self.elements)
-+
-+    @property
-+    def isconstant(self):
-+        """Does the system change depending on ``t``"""
-+        return not any(type(element) is not _ConstantElement
-+                       for element in self.elements)
-+
-+    @property
-+    def isoper(self):
-+        """Indicates if the system represents an operator."""
-+        # TODO: isoper should be part of dims
-+        if self._isoper == -1:
-+            self._isoper = type_from_dims(self.dims) == "oper"
-+        return self._isoper
-+
-+    @property
-+    def issuper(self):
-+        """Indicates if the system represents a superoperator."""
-+        # TODO: issuper should/will be part of dims
-+        # remove self._issuper then
-+        if self._issuper == -1:
-+            self._issuper = type_from_dims(self.dims) == "super"
-+        return self._issuper
-+
-+    ###########################################################################
-+    # operation methods                                                       #
-+    ###########################################################################
-+    def expect(QobjEvo self, object t, state, check_real=True):
-+        """
-+        Expectation value of this operator at time ``t`` with the state.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time of the operator to apply.
-+
-+        state : Qobj
-+            right matrix of the product
-+
-+        check_real : bool (True)
-+            Whether to convert the result to a `real` when the imaginary part
-+            is smaller than the real part by a dactor of
-+            ``settings.core['rtol']``.
-+
-+        Returns
-+        -------
-+        expect : float or complex
-+            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
-+            ``trace(self @ matrix)`` is ``state`` is an operator or
-+            operator-ket.
-+        """
-+        # TODO: remove reading from `settings` for a typed value when options
-+        # support property.
-+        cdef float herm_rtol = settings.core['rtol']
-+        if not isinstance(state, Qobj):
-+            raise TypeError("A Qobj state is expected")
-+        if not (self.isoper or self.issuper):
-+            raise ValueError("Must be an operator or super operator to compute"
-+                             " an expectation value")
-+        if not (
-+            (self.dims[1] == state.dims[0]) or
-+            (self.issuper and self.dims[1] == state.dims)
-+        ):
-+            raise ValueError("incompatible dimensions " + str(self.dims) +
-+                             ", " + str(state.dims))
-+        out = self.expect_data(t, state.data)
-+        if (
-+            check_real and
-+            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
-+        ):
-+            return out.real
-+        return out
-+
-+    cpdef object expect_data(QobjEvo self, object t, Data state):
-+        """
-+        Expectation is defined as ``state.adjoint() @ self @ state`` if
-+        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
-+        superoperator.  If ``state`` is an operator and ``self`` is an
-+        operator, then expectation is ``trace(self @ matrix)``.
-+        """
-+        if type(state) is Dense:
-+            return self._expect_dense(t, state)
-+        cdef _BaseElement part
-+        cdef object out = 0.
-+        cdef Data part_data
-+        cdef object expect_func
-+        t = self._prepare(t, state)
-+        if self.issuper:
-+            if state.shape[1] != 1:
-+                state = _data.column_stack(state)
-+            expect_func = _data.expect_super
-+        else:
-+            expect_func = _data.expect
-+
-+        for element in self.elements:
-+            part = (<_BaseElement> element)
-+            part_data = part.data(t)
-+            out += part.coeff(t) * expect_func(part_data, state)
-+        return out
-+
-+    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
-+        """For Dense state, ``column_stack_dense`` can be done inplace if in
-+        fortran format."""
-+        cdef size_t nrow = state.shape[0]
-+        cdef _BaseElement part
-+        cdef double complex out = 0., coeff
-+        cdef Data part_data
-+        t = self._prepare(t, state)
-+        if self.issuper:
-+            if state.shape[1] != 1:
-+                state = column_stack_dense(state, inplace=state.fortran)
-+            try:
-+                for element in self.elements:
-+                    part = (<_BaseElement> element)
-+                    coeff = part.coeff(t)
-+                    part_data = part.data(t)
-+                    out += coeff * expect_super_data_dense(part_data, state)
-+            finally:
-+                if state.fortran:
-+                    # `state` was reshaped inplace, restore it's original shape
-+                    column_unstack_dense(state, nrow, inplace=state.fortran)
-+        else:
-+            for element in self.elements:
-+                part = (<_BaseElement> element)
-+                coeff = part.coeff(t)
-+                part_data = part.data(t)
-+                out += coeff * expect_data_dense(part_data, state)
-+        return out
-+
-+    def matmul(self, t, state):
-+        """
-+        Product of this operator at time ``t`` to the state.
-+        ``self(t) @ state``
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time of the operator to apply.
-+        state : Qobj
-+            right matrix of the product
-+
-+        Returns
-+        -------
-+        product : Qobj
-+            The result product as a Qobj
-+        """
-+        if not isinstance(state, Qobj):
-+            raise TypeError("A Qobj state is expected")
-+
-+        if self.dims[1] != state.dims[0]:
-+            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
-+                             ", " + str(state.dims[0]))
-+
-+        return Qobj(self.matmul_data(t, state.data),
-+                    dims=[self.dims[0], state.dims[1]],
-+                    copy=False
-+                    )
-+
-+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
-+        """Compute ``out += self(t) @ state``"""
-+        cdef _BaseElement part
-+        t = self._prepare(t, state)
-+        if out is None and type(state) is Dense:
-+            out = dense.zeros(self.shape[0], state.shape[1],
-+                              (<Dense> state).fortran)
-+        elif out is None:
-+            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
-+
-+        for element in self.elements:
-+            part = (<_BaseElement> element)
-+            out = part.matmul_data_t(t, state, out)
-+        return out
-diff --git a/qutip/core/data/__init__.pxd b/qutip/core/data/__init__.pxd
-index c1b4e680..1f5c75d9 100644
---- a/qutip/core/data/__init__.pxd
-+++ b/qutip/core/data/__init__.pxd
-@@ -1,13 +1,13 @@
--#cython: language_level=3
--
--# Package-level relative imports in Cython (0.29.17) are temperamental.
--from qutip.core.data cimport dense, csr
--from qutip.core.data.base cimport Data, idxint
--from qutip.core.data.dense cimport Dense
--from qutip.core.data.csr cimport CSR
--
--from qutip.core.data.add cimport *
--from qutip.core.data.adjoint cimport *
--from qutip.core.data.kron cimport *
--from qutip.core.data.matmul cimport *
--from qutip.core.data.mul cimport *
-+#cython: language_level=3
-+
-+# Package-level relative imports in Cython (0.29.17) are temperamental.
-+from qutip.core.data cimport dense, csr
-+from qutip.core.data.base cimport Data, idxint
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data.csr cimport CSR
-+
-+from qutip.core.data.add cimport *
-+from qutip.core.data.adjoint cimport *
-+from qutip.core.data.kron cimport *
-+from qutip.core.data.matmul cimport *
-+from qutip.core.data.mul cimport *
-diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
-index 557aff5c..5fd15509 100644
---- a/qutip/core/data/__init__.py
-+++ b/qutip/core/data/__init__.py
-@@ -1,56 +1,56 @@
--# First-class type imports
--
--from . import dense, csr
--from .dense import Dense
--from .csr import CSR
--from .base import Data
--
--from .add import *
--from .adjoint import *
--from .constant import *
--from .eigen import *
--from .expect import *
--from .expm import *
--from .inner import *
--from .kron import *
--from .linalg import *
--from .matmul import *
--from .make import *
--from .mul import *
--from .pow import *
--from .project import *
--from .properties import *
--from .ptrace import *
--from .reshape import *
--from .tidyup import *
--from .trace import *
--from .solve import *
--# For operations with mulitple related versions, we just import the module.
--from . import norm, permute
--
--
--# Set up the data conversions that are known by us.  All types covered by
--# conversions will be made available for use in the dispatcher functions.
--
--from .convert import to, create
--to.add_conversions([
--    (Dense, CSR, dense.from_csr, 1),
--    (CSR, Dense, csr.from_dense, 1.4),
--])
--to.register_aliases(['csr', 'CSR'], CSR)
--to.register_aliases(['Dense', 'dense'], Dense)
--
--
--from . import _creator_utils
--import numpy as np
--create.add_creators([
--    (_creator_utils.is_data, _creator_utils.data_copy, 100),
--    (_creator_utils.isspmatrix_csr, CSR, 80),
--    (_creator_utils.is_nparray, Dense, 80),
--    (_creator_utils.issparse, CSR, 20),
--    (_creator_utils.true, Dense, -np.inf),
--])
--del _creator_utils
--del np
--
--from .dispatch import Dispatcher
-+# First-class type imports
-+
-+from . import dense, csr
-+from .dense import Dense
-+from .csr import CSR
-+from .base import Data
-+
-+from .add import *
-+from .adjoint import *
-+from .constant import *
-+from .eigen import *
-+from .expect import *
-+from .expm import *
-+from .inner import *
-+from .kron import *
-+from .linalg import *
-+from .matmul import *
-+from .make import *
-+from .mul import *
-+from .pow import *
-+from .project import *
-+from .properties import *
-+from .ptrace import *
-+from .reshape import *
-+from .tidyup import *
-+from .trace import *
-+from .solve import *
-+# For operations with mulitple related versions, we just import the module.
-+from . import norm, permute
-+
-+
-+# Set up the data conversions that are known by us.  All types covered by
-+# conversions will be made available for use in the dispatcher functions.
-+
-+from .convert import to, create
-+to.add_conversions([
-+    (Dense, CSR, dense.from_csr, 1),
-+    (CSR, Dense, csr.from_dense, 1.4),
-+])
-+to.register_aliases(['csr', 'CSR'], CSR)
-+to.register_aliases(['Dense', 'dense'], Dense)
-+
-+
-+from . import _creator_utils
-+import numpy as np
-+create.add_creators([
-+    (_creator_utils.is_data, _creator_utils.data_copy, 100),
-+    (_creator_utils.isspmatrix_csr, CSR, 80),
-+    (_creator_utils.is_nparray, Dense, 80),
-+    (_creator_utils.issparse, CSR, 20),
-+    (_creator_utils.true, Dense, -np.inf),
-+])
-+del _creator_utils
-+del np
-+
-+from .dispatch import Dispatcher
-diff --git a/qutip/core/data/_creator_utils.py b/qutip/core/data/_creator_utils.py
-index 3f3779e2..1432804b 100644
---- a/qutip/core/data/_creator_utils.py
-+++ b/qutip/core/data/_creator_utils.py
-@@ -1,31 +1,31 @@
--"""
--Define functions to use as Data creator for `create` in `convert.py`.
--"""
--
--from scipy.sparse import isspmatrix_csr, issparse
--import numpy as np
--from .csr import CSR
--from .base import Data
--from .dense import Dense
--
--__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
--
--
--def is_data(arg):
--    return isinstance(arg, Data)
--
--
--def is_nparray(arg):
--    return isinstance(arg, np.ndarray)
--
--
--def true(arg):
--    return True
--
--
--def data_copy(arg, shape, copy=True):
--    if shape is not None and shape != arg.shape:
--        raise ValueError("".join([
--            "shapes do not match: ", str(shape), " and ", str(arg.shape),
--        ]))
--    return arg.copy() if copy else arg
-+"""
-+Define functions to use as Data creator for `create` in `convert.py`.
-+"""
-+
-+from scipy.sparse import isspmatrix_csr, issparse
-+import numpy as np
-+from .csr import CSR
-+from .base import Data
-+from .dense import Dense
-+
-+__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
-+
-+
-+def is_data(arg):
-+    return isinstance(arg, Data)
-+
-+
-+def is_nparray(arg):
-+    return isinstance(arg, np.ndarray)
-+
-+
-+def true(arg):
-+    return True
-+
-+
-+def data_copy(arg, shape, copy=True):
-+    if shape is not None and shape != arg.shape:
-+        raise ValueError("".join([
-+            "shapes do not match: ", str(shape), " and ", str(arg.shape),
-+        ]))
-+    return arg.copy() if copy else arg
-diff --git a/qutip/core/data/add.pxd b/qutip/core/data/add.pxd
-index edb30f14..e0594187 100644
---- a/qutip/core/data/add.pxd
-+++ b/qutip/core/data/add.pxd
-@@ -1,12 +1,12 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--
--cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
--cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
--cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
--cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
--
--cpdef CSR sub_csr(CSR left, CSR right)
--cpdef Dense sub_dense(Dense left, Dense right)
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+
-+cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
-+cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
-+cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
-+cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
-+
-+cpdef CSR sub_csr(CSR left, CSR right)
-+cpdef Dense sub_dense(Dense left, Dense right)
-diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
-index 4a24a193..0b65d2e3 100644
---- a/qutip/core/data/add.pyx
-+++ b/qutip/core/data/add.pyx
-@@ -1,276 +1,276 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--cimport cython
--import numpy as np
--cimport numpy as cnp
--from scipy.linalg cimport cython_blas as blas
--from qutip.settings import settings
--
--from qutip.core.data.base cimport idxint, Data
--from qutip.core.data.dense cimport Dense
--from qutip.core.data.csr cimport (
--    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
--)
--from qutip.core.data cimport csr, dense
--
--cnp.import_array()
--
--cdef extern from *:
--    void *PyDataMem_NEW(size_t size)
--    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
--    void PyDataMem_FREE(void *ptr)
--
--
--__all__ = [
--    'add', 'add_csr', 'add_dense', 'iadd_dense',
--    'sub', 'sub_csr', 'sub_dense',
--]
--
--
--cdef int _ONE=1
--
--
--cdef void _check_shape(Data left, Data right) nogil except *:
--    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
--        raise ValueError(
--            "incompatible matrix shapes "
--            + str(left.shape)
--            + " and "
--            + str(right.shape)
--        )
--
--
--cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
--    """
--    Perform the operation
--        c := a + b
--    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
--    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
--
--    Return the true value of nnz(c).
--    """
--    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
--    cdef idxint ncols = a.shape[1]
--    c.row_index[0] = nnz
--    ptr_a_max = ptr_b_max = 0
--    for row in range(a.shape[0]):
--        ptr_a = ptr_a_max
--        ptr_a_max = a.row_index[row + 1]
--        ptr_b = ptr_b_max
--        ptr_b_max = b.row_index[row + 1]
--        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
--        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
--        # We use this method of going through the row to give the Accumulator
--        # the best chance of receiving the scatters in a sorted order.  We
--        # could also safely iterate through a completely then b, which would be
--        # more cache efficient, but would quite often require a sort within the
--        # gather, making the algorithimic complexity worse.
--        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
--            if col_a < col_b:
--                acc_scatter(acc, a.data[ptr_a], col_a)
--                ptr_a += 1
--                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
--            else:
--                acc_scatter(acc, b.data[ptr_b], col_b)
--                ptr_b += 1
--                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
--            # There's no need to test col_a == col_b because the Accumulator
--            # already tests that in all scatters anyway.
--        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
--        acc_reset(acc)
--        c.row_index[row + 1] = nnz
--    return nnz
--
--
--cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
--                           double complex scale, double tol) nogil:
--    """
--    Perform the operation
--        c := a + scale*b
--    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
--    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
--
--    Return the true value of nnz(c).
--    """
--    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
--    cdef idxint ncols = a.shape[1]
--    c.row_index[0] = nnz
--    ptr_a_max = ptr_b_max = 0
--    for row in range(a.shape[0]):
--        ptr_a = ptr_a_max
--        ptr_a_max = a.row_index[row + 1]
--        ptr_b = ptr_b_max
--        ptr_b_max = b.row_index[row + 1]
--        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
--        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
--        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
--            if col_a < col_b:
--                acc_scatter(acc, a.data[ptr_a], col_a)
--                ptr_a += 1
--                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
--            else:
--                acc_scatter(acc, scale * b.data[ptr_b], col_b)
--                ptr_b += 1
--                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
--        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
--        acc_reset(acc)
--        c.row_index[row + 1] = nnz
--    return nnz
--
--
--cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
--    """
--    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
--    `right` is multiplied by `scale`, so the full operation is
--        ``out := left + scale*right``
--    The two matrices must be of exactly the same shape.
--
--    Parameters
--    ----------
--    left : CSR
--        Matrix to be added.
--    right : CSR
--        Matrix to be added.  If `scale` is given, this matrix will be
--        multiplied by `scale` before addition.
--    scale : optional double complex (1)
--        The scalar value to multiply `right` by before addition.
--
--    Returns
--    -------
--    out : CSR
--        The result `left + scale*right`.
--    """
--    _check_shape(left, right)
--    cdef idxint left_nnz = csr.nnz(left)
--    cdef idxint right_nnz = csr.nnz(right)
--    cdef idxint worst_nnz = left_nnz + right_nnz
--    cdef idxint i
--    cdef CSR out
--    cdef Accumulator acc
--    cdef double tol = 0
--    if settings.core['auto_tidyup']:
--        tol = settings.core['auto_tidyup_atol']
--    # Fast paths for zero matrices.
--    if right_nnz == 0 or scale == 0:
--        return left.copy()
--    if left_nnz == 0:
--        out = right.copy()
--        # Fast path if the multiplication is a no-op.
--        if scale != 1:
--            for i in range(right_nnz):
--                out.data[i] *= scale
--        return out
--    # Main path.
--    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
--    acc = acc_alloc(left.shape[1])
--    if scale == 1:
--        _add_csr(&acc, left, right, out, tol)
--    else:
--        _add_csr_scale(&acc, left, right, out, scale, tol)
--    acc_free(&acc)
--    return out
--
--
--cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
--    cdef int size = left.shape[0] * left.shape[1]
--    with nogil:
--        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
--
--
--cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
--    cdef Dense out = left.copy()
--    cdef int size = left.shape[0] * left.shape[1]
--    with nogil:
--        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
--    return out
--
--
--cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
--    _check_shape(left, right)
--    if not (left.fortran ^ right.fortran):
--        return _add_dense_eq_order(left, right, scale)
--    cdef Dense out = left.copy()
--    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
--    # We always iterate through `left` and `out` in memory-layout order.
--    cdef int dim1, dim2
--    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
--    with nogil:
--        for idx in range(dim2):
--            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
--    return out
--
--
--cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
--    _check_shape(left, right)
--    cdef int size = left.shape[0] * left.shape[1]
--    cdef int dim1, dim2
--    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
--    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
--    with nogil:
--        if not (left.fortran ^ right.fortran):
--            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
--        else:
--            for idx in range(dim2):
--                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
--                           left.data + idx*dim1, &_ONE)
--    return left
--
--
--cpdef CSR sub_csr(CSR left, CSR right):
--    return add_csr(left, right, -1)
--
--
--cpdef Dense sub_dense(Dense left, Dense right):
--    return add_dense(left, right, -1)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--add = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=1),
--    ]),
--    name='add',
--    module=__name__,
--    inputs=('left', 'right'),
--    out=True,
--)
--add.__doc__ =\
--    """
--    Perform the operation
--        left + scale*right
--    where `left` and `right` are matrices, and `scale` is an optional complex
--    scalar.
--    """
--add.add_specialisations([
--    (Dense, Dense, Dense, add_dense),
--    (CSR, CSR, CSR, add_csr),
--], _defer=True)
--
--sub = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='sub',
--    module=__name__,
--    inputs=('left', 'right'),
--    out=True,
--)
--sub.__doc__ =\
--    """
--    Perform the operation
--        left - right
--    where `left` and `right` are matrices.
--    """
--sub.add_specialisations([
--    (Dense, Dense, Dense, sub_dense),
--    (CSR, CSR, CSR, sub_csr),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+cimport cython
-+import numpy as np
-+cimport numpy as cnp
-+from scipy.linalg cimport cython_blas as blas
-+from qutip.settings import settings
-+
-+from qutip.core.data.base cimport idxint, Data
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data.csr cimport (
-+    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
-+)
-+from qutip.core.data cimport csr, dense
-+
-+cnp.import_array()
-+
-+cdef extern from *:
-+    void *PyDataMem_NEW(size_t size)
-+    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-+    void PyDataMem_FREE(void *ptr)
-+
-+
-+__all__ = [
-+    'add', 'add_csr', 'add_dense', 'iadd_dense',
-+    'sub', 'sub_csr', 'sub_dense',
-+]
-+
-+
-+cdef int _ONE=1
-+
-+
-+cdef void _check_shape(Data left, Data right) nogil except *:
-+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-+        raise ValueError(
-+            "incompatible matrix shapes "
-+            + str(left.shape)
-+            + " and "
-+            + str(right.shape)
-+        )
-+
-+
-+cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
-+    """
-+    Perform the operation
-+        c := a + b
-+    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
-+    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
-+
-+    Return the true value of nnz(c).
-+    """
-+    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
-+    cdef idxint ncols = a.shape[1]
-+    c.row_index[0] = nnz
-+    ptr_a_max = ptr_b_max = 0
-+    for row in range(a.shape[0]):
-+        ptr_a = ptr_a_max
-+        ptr_a_max = a.row_index[row + 1]
-+        ptr_b = ptr_b_max
-+        ptr_b_max = b.row_index[row + 1]
-+        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-+        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-+        # We use this method of going through the row to give the Accumulator
-+        # the best chance of receiving the scatters in a sorted order.  We
-+        # could also safely iterate through a completely then b, which would be
-+        # more cache efficient, but would quite often require a sort within the
-+        # gather, making the algorithimic complexity worse.
-+        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
-+            if col_a < col_b:
-+                acc_scatter(acc, a.data[ptr_a], col_a)
-+                ptr_a += 1
-+                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-+            else:
-+                acc_scatter(acc, b.data[ptr_b], col_b)
-+                ptr_b += 1
-+                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-+            # There's no need to test col_a == col_b because the Accumulator
-+            # already tests that in all scatters anyway.
-+        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
-+        acc_reset(acc)
-+        c.row_index[row + 1] = nnz
-+    return nnz
-+
-+
-+cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
-+                           double complex scale, double tol) nogil:
-+    """
-+    Perform the operation
-+        c := a + scale*b
-+    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
-+    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
-+
-+    Return the true value of nnz(c).
-+    """
-+    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
-+    cdef idxint ncols = a.shape[1]
-+    c.row_index[0] = nnz
-+    ptr_a_max = ptr_b_max = 0
-+    for row in range(a.shape[0]):
-+        ptr_a = ptr_a_max
-+        ptr_a_max = a.row_index[row + 1]
-+        ptr_b = ptr_b_max
-+        ptr_b_max = b.row_index[row + 1]
-+        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-+        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-+        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
-+            if col_a < col_b:
-+                acc_scatter(acc, a.data[ptr_a], col_a)
-+                ptr_a += 1
-+                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-+            else:
-+                acc_scatter(acc, scale * b.data[ptr_b], col_b)
-+                ptr_b += 1
-+                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-+        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
-+        acc_reset(acc)
-+        c.row_index[row + 1] = nnz
-+    return nnz
-+
-+
-+cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
-+    """
-+    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
-+    `right` is multiplied by `scale`, so the full operation is
-+        ``out := left + scale*right``
-+    The two matrices must be of exactly the same shape.
-+
-+    Parameters
-+    ----------
-+    left : CSR
-+        Matrix to be added.
-+    right : CSR
-+        Matrix to be added.  If `scale` is given, this matrix will be
-+        multiplied by `scale` before addition.
-+    scale : optional double complex (1)
-+        The scalar value to multiply `right` by before addition.
-+
-+    Returns
-+    -------
-+    out : CSR
-+        The result `left + scale*right`.
-+    """
-+    _check_shape(left, right)
-+    cdef idxint left_nnz = csr.nnz(left)
-+    cdef idxint right_nnz = csr.nnz(right)
-+    cdef idxint worst_nnz = left_nnz + right_nnz
-+    cdef idxint i
-+    cdef CSR out
-+    cdef Accumulator acc
-+    cdef double tol = 0
-+    if settings.core['auto_tidyup']:
-+        tol = settings.core['auto_tidyup_atol']
-+    # Fast paths for zero matrices.
-+    if right_nnz == 0 or scale == 0:
-+        return left.copy()
-+    if left_nnz == 0:
-+        out = right.copy()
-+        # Fast path if the multiplication is a no-op.
-+        if scale != 1:
-+            for i in range(right_nnz):
-+                out.data[i] *= scale
-+        return out
-+    # Main path.
-+    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
-+    acc = acc_alloc(left.shape[1])
-+    if scale == 1:
-+        _add_csr(&acc, left, right, out, tol)
-+    else:
-+        _add_csr_scale(&acc, left, right, out, scale, tol)
-+    acc_free(&acc)
-+    return out
-+
-+
-+cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
-+    cdef int size = left.shape[0] * left.shape[1]
-+    with nogil:
-+        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
-+
-+
-+cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
-+    cdef Dense out = left.copy()
-+    cdef int size = left.shape[0] * left.shape[1]
-+    with nogil:
-+        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
-+    return out
-+
-+
-+cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
-+    _check_shape(left, right)
-+    if not (left.fortran ^ right.fortran):
-+        return _add_dense_eq_order(left, right, scale)
-+    cdef Dense out = left.copy()
-+    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
-+    # We always iterate through `left` and `out` in memory-layout order.
-+    cdef int dim1, dim2
-+    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
-+    with nogil:
-+        for idx in range(dim2):
-+            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
-+    return out
-+
-+
-+cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
-+    _check_shape(left, right)
-+    cdef int size = left.shape[0] * left.shape[1]
-+    cdef int dim1, dim2
-+    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
-+    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
-+    with nogil:
-+        if not (left.fortran ^ right.fortran):
-+            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
-+        else:
-+            for idx in range(dim2):
-+                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
-+                           left.data + idx*dim1, &_ONE)
-+    return left
-+
-+
-+cpdef CSR sub_csr(CSR left, CSR right):
-+    return add_csr(left, right, -1)
-+
-+
-+cpdef Dense sub_dense(Dense left, Dense right):
-+    return add_dense(left, right, -1)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+add = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=1),
-+    ]),
-+    name='add',
-+    module=__name__,
-+    inputs=('left', 'right'),
-+    out=True,
-+)
-+add.__doc__ =\
-+    """
-+    Perform the operation
-+        left + scale*right
-+    where `left` and `right` are matrices, and `scale` is an optional complex
-+    scalar.
-+    """
-+add.add_specialisations([
-+    (Dense, Dense, Dense, add_dense),
-+    (CSR, CSR, CSR, add_csr),
-+], _defer=True)
-+
-+sub = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='sub',
-+    module=__name__,
-+    inputs=('left', 'right'),
-+    out=True,
-+)
-+sub.__doc__ =\
-+    """
-+    Perform the operation
-+        left - right
-+    where `left` and `right` are matrices.
-+    """
-+sub.add_specialisations([
-+    (Dense, Dense, Dense, sub_dense),
-+    (CSR, CSR, CSR, sub_csr),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/adjoint.pxd b/qutip/core/data/adjoint.pxd
-index 793aac64..ced7be52 100644
---- a/qutip/core/data/adjoint.pxd
-+++ b/qutip/core/data/adjoint.pxd
-@@ -1,12 +1,12 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--
--cpdef CSR adjoint_csr(CSR matrix)
--cpdef CSR transpose_csr(CSR matrix)
--cpdef CSR conj_csr(CSR matrix)
--
--cpdef Dense adjoint_dense(Dense matrix)
--cpdef Dense transpose_dense(Dense matrix)
--cpdef Dense conj_dense(Dense matrix)
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+
-+cpdef CSR adjoint_csr(CSR matrix)
-+cpdef CSR transpose_csr(CSR matrix)
-+cpdef CSR conj_csr(CSR matrix)
-+
-+cpdef Dense adjoint_dense(Dense matrix)
-+cpdef Dense transpose_dense(Dense matrix)
-+cpdef Dense conj_dense(Dense matrix)
-diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
-index ebff9e4d..4f1543cd 100644
---- a/qutip/core/data/adjoint.pyx
-+++ b/qutip/core/data/adjoint.pyx
-@@ -1,160 +1,160 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.string cimport memset
--
--cimport cython
--
--from qutip.core.data.base cimport idxint
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--from qutip.core.data cimport csr, dense
--
--# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex _conj "conj"(double complex x)
--
--__all__ = [
--    'adjoint', 'adjoint_csr', 'adjoint_dense',
--    'conj', 'conj_csr', 'conj_dense',
--    'transpose', 'transpose_csr', 'transpose_dense',
--]
--
--
--cpdef CSR transpose_csr(CSR matrix):
--    """Transpose the CSR matrix, and return a new object."""
--    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
--    cdef idxint row, col, ptr, ptr_out
--    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
--    with nogil:
--        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
--        for row in range(rows_in):
--            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--                col = matrix.col_index[ptr] + 1
--                out.row_index[col] += 1
--        for row in range(rows_out):
--            out.row_index[row + 1] += out.row_index[row]
--        for row in range(rows_in):
--            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--                col = matrix.col_index[ptr]
--                ptr_out = out.row_index[col]
--                out.data[ptr_out] = matrix.data[ptr]
--                out.col_index[ptr_out] = row
--                out.row_index[col] = ptr_out + 1
--        for row in range(rows_out, 0, -1):
--            out.row_index[row] = out.row_index[row - 1]
--        out.row_index[0] = 0
--    return out
--
--
--cpdef CSR adjoint_csr(CSR matrix):
--    """Conjugate-transpose the CSR matrix, and return a new object."""
--    cdef idxint nnz_ = csr.nnz(matrix)
--    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
--    cdef idxint row, col, ptr, ptr_out
--    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
--    with nogil:
--        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
--        for row in range(rows_in):
--            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--                col = matrix.col_index[ptr] + 1
--                out.row_index[col] += 1
--        for row in range(rows_out):
--            out.row_index[row + 1] += out.row_index[row]
--        for row in range(rows_in):
--            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--                col = matrix.col_index[ptr]
--                ptr_out = out.row_index[col]
--                out.data[ptr_out] = _conj(matrix.data[ptr])
--                out.col_index[ptr_out] = row
--                out.row_index[col] = ptr_out + 1
--        for row in range(rows_out, 0, -1):
--            out.row_index[row] = out.row_index[row - 1]
--        out.row_index[0] = 0
--    return out
--
--
--cpdef CSR conj_csr(CSR matrix):
--    """Conjugate the CSR matrix, and return a new object."""
--    cdef CSR out = csr.copy_structure(matrix)
--    cdef idxint ptr
--    with nogil:
--        for ptr in range(csr.nnz(matrix)):
--            out.data[ptr] = _conj(matrix.data[ptr])
--    return out
--
--
--cpdef Dense adjoint_dense(Dense matrix):
--    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
--    out.shape = (out.shape[1], out.shape[0])
--    with nogil:
--        for ptr in range(matrix.shape[0] * matrix.shape[1]):
--            out.data[ptr] = _conj(matrix.data[ptr])
--    return out
--
--
--cpdef Dense transpose_dense(Dense matrix):
--    cdef Dense out = matrix.copy()
--    out.shape = (out.shape[1], out.shape[0])
--    out.fortran = not out.fortran
--    return out
--
--
--cpdef Dense conj_dense(Dense matrix):
--    cdef Dense out = dense.empty_like(matrix)
--    cdef size_t ptr
--    with nogil:
--        for ptr in range(matrix.shape[0] * matrix.shape[1]):
--            out.data[ptr] = _conj(matrix.data[ptr])
--    return out
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--adjoint = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='adjoint',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
--adjoint.add_specialisations([
--    (Dense, Dense, adjoint_dense),
--    (CSR, CSR, adjoint_csr),
--], _defer=True)
--
--transpose = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='transpose',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--transpose.__doc__ = """Transpose of a matrix."""
--transpose.add_specialisations([
--    (Dense, Dense, transpose_dense),
--    (CSR, CSR, transpose_csr),
--], _defer=True)
--
--conj = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='conj',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--conj.__doc__ = """Element-wise conjugation of a matrix."""
--conj.add_specialisations([
--    (Dense, Dense, conj_dense),
--    (CSR, CSR, conj_csr),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.string cimport memset
-+
-+cimport cython
-+
-+from qutip.core.data.base cimport idxint
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data cimport csr, dense
-+
-+# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex _conj "conj"(double complex x)
-+
-+__all__ = [
-+    'adjoint', 'adjoint_csr', 'adjoint_dense',
-+    'conj', 'conj_csr', 'conj_dense',
-+    'transpose', 'transpose_csr', 'transpose_dense',
-+]
-+
-+
-+cpdef CSR transpose_csr(CSR matrix):
-+    """Transpose the CSR matrix, and return a new object."""
-+    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
-+    cdef idxint row, col, ptr, ptr_out
-+    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
-+    with nogil:
-+        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
-+        for row in range(rows_in):
-+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+                col = matrix.col_index[ptr] + 1
-+                out.row_index[col] += 1
-+        for row in range(rows_out):
-+            out.row_index[row + 1] += out.row_index[row]
-+        for row in range(rows_in):
-+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+                col = matrix.col_index[ptr]
-+                ptr_out = out.row_index[col]
-+                out.data[ptr_out] = matrix.data[ptr]
-+                out.col_index[ptr_out] = row
-+                out.row_index[col] = ptr_out + 1
-+        for row in range(rows_out, 0, -1):
-+            out.row_index[row] = out.row_index[row - 1]
-+        out.row_index[0] = 0
-+    return out
-+
-+
-+cpdef CSR adjoint_csr(CSR matrix):
-+    """Conjugate-transpose the CSR matrix, and return a new object."""
-+    cdef idxint nnz_ = csr.nnz(matrix)
-+    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
-+    cdef idxint row, col, ptr, ptr_out
-+    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
-+    with nogil:
-+        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
-+        for row in range(rows_in):
-+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+                col = matrix.col_index[ptr] + 1
-+                out.row_index[col] += 1
-+        for row in range(rows_out):
-+            out.row_index[row + 1] += out.row_index[row]
-+        for row in range(rows_in):
-+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+                col = matrix.col_index[ptr]
-+                ptr_out = out.row_index[col]
-+                out.data[ptr_out] = _conj(matrix.data[ptr])
-+                out.col_index[ptr_out] = row
-+                out.row_index[col] = ptr_out + 1
-+        for row in range(rows_out, 0, -1):
-+            out.row_index[row] = out.row_index[row - 1]
-+        out.row_index[0] = 0
-+    return out
-+
-+
-+cpdef CSR conj_csr(CSR matrix):
-+    """Conjugate the CSR matrix, and return a new object."""
-+    cdef CSR out = csr.copy_structure(matrix)
-+    cdef idxint ptr
-+    with nogil:
-+        for ptr in range(csr.nnz(matrix)):
-+            out.data[ptr] = _conj(matrix.data[ptr])
-+    return out
-+
-+
-+cpdef Dense adjoint_dense(Dense matrix):
-+    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
-+    out.shape = (out.shape[1], out.shape[0])
-+    with nogil:
-+        for ptr in range(matrix.shape[0] * matrix.shape[1]):
-+            out.data[ptr] = _conj(matrix.data[ptr])
-+    return out
-+
-+
-+cpdef Dense transpose_dense(Dense matrix):
-+    cdef Dense out = matrix.copy()
-+    out.shape = (out.shape[1], out.shape[0])
-+    out.fortran = not out.fortran
-+    return out
-+
-+
-+cpdef Dense conj_dense(Dense matrix):
-+    cdef Dense out = dense.empty_like(matrix)
-+    cdef size_t ptr
-+    with nogil:
-+        for ptr in range(matrix.shape[0] * matrix.shape[1]):
-+            out.data[ptr] = _conj(matrix.data[ptr])
-+    return out
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+adjoint = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='adjoint',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
-+adjoint.add_specialisations([
-+    (Dense, Dense, adjoint_dense),
-+    (CSR, CSR, adjoint_csr),
-+], _defer=True)
-+
-+transpose = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='transpose',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+transpose.__doc__ = """Transpose of a matrix."""
-+transpose.add_specialisations([
-+    (Dense, Dense, transpose_dense),
-+    (CSR, CSR, transpose_csr),
-+], _defer=True)
-+
-+conj = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='conj',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+conj.__doc__ = """Element-wise conjugation of a matrix."""
-+conj.add_specialisations([
-+    (Dense, Dense, conj_dense),
-+    (CSR, CSR, conj_csr),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/base.pxd b/qutip/core/data/base.pxd
-index f34a80ff..4aa8d083 100644
---- a/qutip/core/data/base.pxd
-+++ b/qutip/core/data/base.pxd
-@@ -1,17 +1,17 @@
--#cython: language_level=3
--
--cdef extern from "src/intdtype.h":
--    # cython is smart enough to understand this int can be 32 or 64 bits.
--    ctypedef int idxint
--    cdef int _idxint_size
--
--cdef int idxint_DTYPE
--
--cdef class Data:
--    cdef readonly (idxint, idxint) shape
--    cpdef object to_array(self)
--    cpdef double complex trace(self)
--    cpdef Data adjoint(self)
--    cpdef Data conj(self)
--    cpdef Data transpose(self)
--    cpdef Data copy(self)
-+#cython: language_level=3
-+
-+cdef extern from "src/intdtype.h":
-+    # cython is smart enough to understand this int can be 32 or 64 bits.
-+    ctypedef int idxint
-+    cdef int _idxint_size
-+
-+cdef int idxint_DTYPE
-+
-+cdef class Data:
-+    cdef readonly (idxint, idxint) shape
-+    cpdef object to_array(self)
-+    cpdef double complex trace(self)
-+    cpdef Data adjoint(self)
-+    cpdef Data conj(self)
-+    cpdef Data transpose(self)
-+    cpdef Data copy(self)
-diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
-index a463bf38..a7c59939 100644
---- a/qutip/core/data/base.pyx
-+++ b/qutip/core/data/base.pyx
-@@ -1,89 +1,89 @@
--#cython: language_level=3
--
--import numpy as np
--cimport numpy as cnp
--import qutip.core.data as _data
--from qutip.settings import settings
--
--__all__ = [
--    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
--]
--
--if _idxint_size == 32:
--    idxint_dtype = np.int32
--    idxint_DTYPE = cnp.NPY_INT32
--else:
--    idxint_dtype = np.int64
--    idxint_DTYPE = cnp.NPY_INT64
--
--idxint_size = _idxint_size
--
--# As this is an abstract base class with C entry points, we have to explicitly
--# stub out methods since we can't mark them as abstract.
--cdef class Data:
--    def __init__(self, shape):
--        self.shape = shape
--
--    cpdef object to_array(self):
--        raise NotImplementedError
--
--    cpdef double complex trace(self):
--        return NotImplementedError
--
--    cpdef Data adjoint(self):
--        raise NotImplementedError
--
--    cpdef Data conj(self):
--        raise NotImplementedError
--
--    cpdef Data transpose(self):
--        raise NotImplementedError
--
--    cpdef Data copy(self):
--        raise NotImplementedError
--
--    def __add__(left, right):
--        if isinstance(left, Data) and isinstance(right, Data):
--            return _data.add(left, right)
--        return NotImplemented
--
--    def __sub__(left, right):
--        if isinstance(left, Data) and isinstance(right, Data):
--            return _data.sub(left, right)
--        return NotImplemented
--
--    def __matmul__(left, right):
--        if isinstance(left, Data) and isinstance(right, Data):
--            return _data.matmul(left, right)
--        return NotImplemented
--
--    def __mul__(left, right):
--        data, number = (left, right) if isinstance(left, Data) else (right, left)
--        try:
--            return _data.mul(data, number)
--        except TypeError:
--            return NotImplemented
--
--    def __truediv__(left, right):
--        data, number = (left, right) if isinstance(left, Data) else (right, left)
--        try:
--            return _data.mul(data, 1/number)
--        except TypeError:
--            return NotImplemented
--
--    def __neg__(self):
--        return _data.neg(self)
--
--    def __eq__(left, right):
--        if not (isinstance(left, Data) and isinstance(right, Data)):
--            return NotImplemented
--        if (
--            left.shape[0] == right.shape[0]
--            and left.shape[1] == right.shape[1]
--        ):
--            return _data.iszero(_data.sub(left, right), settings.core['atol'])
--        return False
--
--
--class EfficiencyWarning(Warning):
--    pass
-+#cython: language_level=3
-+
-+import numpy as np
-+cimport numpy as cnp
-+import qutip.core.data as _data
-+from qutip.settings import settings
-+
-+__all__ = [
-+    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
-+]
-+
-+if _idxint_size == 32:
-+    idxint_dtype = np.int32
-+    idxint_DTYPE = cnp.NPY_INT32
-+else:
-+    idxint_dtype = np.int64
-+    idxint_DTYPE = cnp.NPY_INT64
-+
-+idxint_size = _idxint_size
-+
-+# As this is an abstract base class with C entry points, we have to explicitly
-+# stub out methods since we can't mark them as abstract.
-+cdef class Data:
-+    def __init__(self, shape):
-+        self.shape = shape
-+
-+    cpdef object to_array(self):
-+        raise NotImplementedError
-+
-+    cpdef double complex trace(self):
-+        return NotImplementedError
-+
-+    cpdef Data adjoint(self):
-+        raise NotImplementedError
-+
-+    cpdef Data conj(self):
-+        raise NotImplementedError
-+
-+    cpdef Data transpose(self):
-+        raise NotImplementedError
-+
-+    cpdef Data copy(self):
-+        raise NotImplementedError
-+
-+    def __add__(left, right):
-+        if isinstance(left, Data) and isinstance(right, Data):
-+            return _data.add(left, right)
-+        return NotImplemented
-+
-+    def __sub__(left, right):
-+        if isinstance(left, Data) and isinstance(right, Data):
-+            return _data.sub(left, right)
-+        return NotImplemented
-+
-+    def __matmul__(left, right):
-+        if isinstance(left, Data) and isinstance(right, Data):
-+            return _data.matmul(left, right)
-+        return NotImplemented
-+
-+    def __mul__(left, right):
-+        data, number = (left, right) if isinstance(left, Data) else (right, left)
-+        try:
-+            return _data.mul(data, number)
-+        except TypeError:
-+            return NotImplemented
-+
-+    def __truediv__(left, right):
-+        data, number = (left, right) if isinstance(left, Data) else (right, left)
-+        try:
-+            return _data.mul(data, 1/number)
-+        except TypeError:
-+            return NotImplemented
-+
-+    def __neg__(self):
-+        return _data.neg(self)
-+
-+    def __eq__(left, right):
-+        if not (isinstance(left, Data) and isinstance(right, Data)):
-+            return NotImplemented
-+        if (
-+            left.shape[0] == right.shape[0]
-+            and left.shape[1] == right.shape[1]
-+        ):
-+            return _data.iszero(_data.sub(left, right), settings.core['atol'])
-+        return False
-+
-+
-+class EfficiencyWarning(Warning):
-+    pass
-diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
-index a60341a3..6f850d22 100644
---- a/qutip/core/data/constant.py
-+++ b/qutip/core/data/constant.py
-@@ -1,73 +1,73 @@
--# This module exists to supply a couple of very standard constant matrices
--# which are used in the data layer, and within `Qobj` itself.  Other matrices
--# (e.g. `create`) should not be here, but should be defined within the
--# higher-level components of QuTiP instead.
--
--from . import csr, dense
--from .csr import CSR
--from .dense import Dense
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--__all__ = ['zeros', 'identity']
--
--zeros = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='zeros',
--    module=__name__,
--    inputs=(),
--    out=True,
--)
--zeros.__doc__ =\
--    """
--    Create matrix representation of 0 with the given dimensions.
--
--    Depending on the selected output type, this may or may not actually
--    contained explicit values; sparse matrices will typically contain nothing
--    (which is their representation of 0), and dense matrices will still be
--    filled.
--
--    Parameters
--    ----------
--    rows, cols : int
--        The number of rows and columns in the output matrix.
--    """
--zeros.add_specialisations([
--    (CSR, csr.zeros),
--    (Dense, dense.zeros),
--], _defer=True)
--
--identity = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('dimension',
--                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=1),
--    ]),
--    name='identity',
--    module=__name__,
--    inputs=(),
--    out=True,
--)
--identity.__doc__ =\
--    """
--    Create a square identity matrix of the given dimension.  Optionally, the
--    `scale` can be given, where all the diagonal elements will be that instead
--    of 1.
--
--    Parameters
--    ----------
--    dimension : int
--        The dimension of the square output identity matrix.
--    scale : complex, optional
--        The element which should be placed on the diagonal.
--    """
--identity.add_specialisations([
--    (CSR, csr.identity),
--    (Dense, dense.identity),
--], _defer=True)
--
--del _Dispatcher, _inspect
-+# This module exists to supply a couple of very standard constant matrices
-+# which are used in the data layer, and within `Qobj` itself.  Other matrices
-+# (e.g. `create`) should not be here, but should be defined within the
-+# higher-level components of QuTiP instead.
-+
-+from . import csr, dense
-+from .csr import CSR
-+from .dense import Dense
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+__all__ = ['zeros', 'identity']
-+
-+zeros = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='zeros',
-+    module=__name__,
-+    inputs=(),
-+    out=True,
-+)
-+zeros.__doc__ =\
-+    """
-+    Create matrix representation of 0 with the given dimensions.
-+
-+    Depending on the selected output type, this may or may not actually
-+    contained explicit values; sparse matrices will typically contain nothing
-+    (which is their representation of 0), and dense matrices will still be
-+    filled.
-+
-+    Parameters
-+    ----------
-+    rows, cols : int
-+        The number of rows and columns in the output matrix.
-+    """
-+zeros.add_specialisations([
-+    (CSR, csr.zeros),
-+    (Dense, dense.zeros),
-+], _defer=True)
-+
-+identity = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('dimension',
-+                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=1),
-+    ]),
-+    name='identity',
-+    module=__name__,
-+    inputs=(),
-+    out=True,
-+)
-+identity.__doc__ =\
-+    """
-+    Create a square identity matrix of the given dimension.  Optionally, the
-+    `scale` can be given, where all the diagonal elements will be that instead
-+    of 1.
-+
-+    Parameters
-+    ----------
-+    dimension : int
-+        The dimension of the square output identity matrix.
-+    scale : complex, optional
-+        The element which should be placed on the diagonal.
-+    """
-+identity.add_specialisations([
-+    (CSR, csr.identity),
-+    (Dense, dense.identity),
-+], _defer=True)
-+
-+del _Dispatcher, _inspect
-diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
-index c2feed3d..6826ac81 100644
---- a/qutip/core/data/convert.pyx
-+++ b/qutip/core/data/convert.pyx
-@@ -1,436 +1,436 @@
--#cython: language_level=3
--
--"""
--The conversion machinery between different data-layer types, and creation
--routines from arbitrary data.  The classes `_to` and `_create` are not intended
--to be exported names, but are the backing machinery of the functions `data.to`
--and `data.create`, which are built up as the last objects in the `__init__.py`
--initialisation of the `data` module.
--"""
--
--# This module is compiled by Cython because it's the core of the entire
--# dispatch table, and having it compiled to a C extension saves about 1µs per
--# call.  This is not much at all, and there's very little which benefits from
--# Cython compiliation, but such core functionality is called millions of times
--# even in a simple interactive QuTiP session, and it all adds up.
--
--import numbers
--
--import numpy as np
--from scipy.sparse import dok_matrix, csgraph
--cimport cython
--
--__all__ = ['to', 'create']
--
--
--def _raise_if_unconnected(dtype_list, weights):
--    unconnected = {}
--    for i, type_ in enumerate(dtype_list):
--        missing = [dtype_list[j].__name__
--                   for j, weight in enumerate(weights[:, i])
--                   if weight == np.inf]
--        if missing:
--            unconnected[type_.__name__] = missing
--    if unconnected:
--        message = "Conversion graph not connected.  Cannot reach:\n * "
--        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
--                                for to, froms in unconnected.items())
--        raise NotImplementedError(message)
--
--
--cdef class _converter:
--    """Callable which converts objects of type `x.from_` to type `x.to`."""
--
--    cdef list functions
--    cdef Py_ssize_t n_functions
--    cdef readonly type to
--    cdef readonly type from_
--
--    def __init__(self, functions, to_type, from_type):
--        self.functions = list(functions)
--        self.n_functions = len(self.functions)
--        self.to = to_type
--        self.from_ = from_type
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    def __call__(self, arg):
--        if not isinstance(arg, self.from_):
--            raise TypeError(str(arg) + " is not of type " + str(self.from_))
--        cdef Py_ssize_t i
--        for i in range(self.n_functions):
--            arg = self.functions[i](arg)
--        return arg
--
--    def __repr__(self):
--        return ("<converter to "
--                + self.to.__name__
--                + " from " + self.from_.__name__
--                + ">")
--
--
--cdef class _partial_converter:
--    """Convert from any known data-layer type into the type `x.to`."""
--
--    cdef dict converters
--    cdef readonly type to
--
--    def __init__(self, converters, to_type):
--        self.converters = dict(converters)
--        self.to = to_type
--
--    def __call__(self, arg):
--        try:
--            return self.converters[type(arg)](arg)
--        except KeyError:
--            raise TypeError("unknown type of input: " + str(arg)) from None
--
--    def __repr__(self):
--        return "<converter to " + self.to.__name__ + ">"
--
--
--# While `_to` and `_create` are defined as objects here, they are actually
--# exported by `data.__init__.py` as singleton function objects of their
--# respective types (without the leading underscore).
--
--cdef class _to:
--    """
--    Convert data into a different type.  This object is the knowledge source
--    for every allowable data-layer type in QuTiP, and provides the conversions
--    between all of them.
--
--    The base use is to call this object as a function with signature
--        (type, data) -> converted_data
--    where `type` is a type object (such as `data.CSR`, or that obtained by
--    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
--    want to create a data-layer type from non-data-layer data, use `create`
--    instead.
--
--    You can get individual converters by using the key-lookup syntax.  For
--    example, the item
--        to[CSR, Dense]
--    is a callable which accepts arguments of type `Dense` and returns the
--    equivalent item of type `CSR`.  You can also get a generic converter to a
--    particular data type if only one type is specified, so
--        to[Dense]
--    is a callable which accepts all known (at the time of the lookup)
--    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
--    section below for more detail.
--
--    Internally, the conversion process may go through several steps if new
--    data-layer types have been defined with few conversions specified between
--    them and the pre-existing converters.  The first-class QuTiP data types
--    `Dense` and `CSR` will typically have the best connectivity.
--
--
--    Adding new types
--    ----------------
--    You can add new data-layer types by calling the `add_conversions` method of
--    this object, and then rebuilding all of the mathematical dispatchers.  See
--    the docstring of that method for more information.
--
--
--    Efficiency notes
--    ----------------
--    From an efficiency perspective, there is very little benefit to using the
--    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
--    `to[to_type, type(data)]`, so storing the object elides the creation of a
--    single tuple and a dict lookup, but the cost of this is generally less than
--    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
--    efficient than the general call at all, but can be used in cases where a
--    single callable is required and is more efficient than `functools.partial`.
--    """
--
--    cdef readonly set dtypes
--    cdef readonly list dispatchers
--    cdef dict _direct_convert
--    cdef dict _convert
--    cdef readonly dict weight
--    cdef readonly dict _str2type
--
--    def __init__(self):
--        self._direct_convert = {}
--        self._convert = {}
--        self.dtypes = set()
--        self.weight = {}
--        self.dispatchers = []
--        self._str2type = {}
--
--    def add_conversions(self, converters):
--        """
--        Add conversion functions between different data types.  This is an
--        advanced function, and is only intended for the QuTiP user who wants to
--        add a new underlying data type to QuTiP.
--
--        Any new data type must have at least one converter function given to
--        produce the new data type from an existing data type, and at least one
--        which produces an existing data type from the new one.  You need not
--        specify any more than this, although for efficiency reasons, you may
--        want to specify direct conversions for all types you expect the new
--        type to interact with frequently.
--
--        Parameters
--        ----------
--        converters : iterable of (to_type, from_type, converter, [weight])
--            An iterable of 3- or 4-tuples describing all the new conversions.
--            Each element can individually be a 3- or 4-tuple; they do not need
--            to be all one or the other.
--
--            Elements
--            ........
--            to_type : type
--                The data-layer type that is output by the converter.
--
--            from_type : type
--                The data-layer type to be input to the converter.
--
--            converter : callable (Data -> Data)
--                The converter function.  This should take a single argument
--                (the input data-layer function) and output a data-layer object
--                of `to_type`.  The converter may assume without error checking
--                that its input will always be of `to_type`.  It is safe to
--                specify the same conversion function for multiple inputs so
--                long as the function handles them all safely, but it must
--                always return a single output type.
--
--            weight : positive real, optional (1)
--                The weight associated with this conversion.  This must be > 0,
--                and defaults to `1` if not supplied (which is fixed to be the
--                cost of conversion to `Dense` from `CSR`).  It is generally
--                safe just to leave this blank; it is always at best an
--                approximation.  The currently defined weights are accessible in
--                the `weights` attribute of this object.
--        """
--        for arg in converters:
--            if len(arg) == 3:
--                to_type, from_type, converter = arg
--                weight = 1
--            elif len(arg) == 4:
--                to_type, from_type, converter, weight = arg
--            else:
--                raise TypeError("unknown converter specification: " + str(arg))
--            if not isinstance(to_type, type):
--                raise TypeError(repr(to_type) + " is not a type object")
--            if not isinstance(from_type, type):
--                raise TypeError(repr(from_type) + " is not a type object")
--            if not isinstance(weight, numbers.Real) or weight <= 0:
--                raise TypeError("weight " + repr(weight) + " is not valid")
--            self.dtypes.add(from_type)
--            self.dtypes.add(to_type)
--            self._direct_convert[(to_type, from_type)] = (converter, weight)
--        # Two-way mapping to convert between the type of a dtype and an integer
--        # enumeration value for it.
--        order, index = [], {}
--        for i, dtype in enumerate(self.dtypes):
--            order.append(dtype)
--            index[dtype] = i
--        # Treat the conversion problem as a shortest-path graph problem.  We
--        # build up the graph description as a matrix, then solve the
--        # all-pairs-shortest-path problem.  We forbid negative weights and
--        # there are unlikely to be many data types, so the choice of algorithm
--        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
--        graph = dok_matrix((len(order), len(order)))
--        for (to_type, from_type), (_, weight) in self._direct_convert.items():
--            graph[index[from_type], index[to_type]] = weight
--        weights, predecessors =\
--            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
--        _raise_if_unconnected(order, weights)
--        # Build the whole shortest path conversion lookup.  We directly store
--        # all complete shortest paths, even though this is not the most memory
--        # efficient, because we expect that there will generally be a small
--        # number of available data types, and we care more about minimising the
--        # number of lookups required.
--        self.weight = {}
--        self._convert = {}
--        for i, from_t in enumerate(order):
--            for j, to_t in enumerate(order):
--                convert = []
--                weight = 0
--                cur_t = to_t
--                pred_i = predecessors[i, j]
--                while pred_i >= 0:
--                    pred_t = order[pred_i]
--                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
--                    convert.append(_convert)
--                    weight += _weight
--                    cur_t = pred_t
--                    pred_i = predecessors[i, pred_i]
--                self.weight[(to_t, from_t)] = weight
--                self._convert[(to_t, from_t)] =\
--                    _converter(convert[::-1], to_t, from_t)
--        for dispatcher in self.dispatchers:
--            dispatcher.rebuild_lookup()
--
--    def register_aliases(self, aliases, layer_type):
--        """
--        Register a user frendly name for a data-layer type to be recognized by
--        the :method:`parse` method.
--
--        Parameters
--        ----------
--        aliases : str or list of str
--            Name of list of names to be understood to represent the layer_type.
--
--        layer_type : type
--            Data-layer type, must have been registered with
--            :method:`add_conversions` first.
--        """
--        if layer_type not in self.dtypes:
--            raise ValueError(
--                "Type is not a data-layer type: " + repr(layer_type))
--        if isinstance(aliases, str):
--            aliases = [aliases]
--        for alias in aliases:
--            if type(alias) is not str:
--                raise TypeError("The alias must be a str : " + repr(alias))
--            self._str2type[alias] = layer_type
--
--    def parse(self, dtype):
--        """
--        Return a data-layer type object given its name or the type itself.
--
--        Parameters
--        ----------
--        dtype : type, str
--            Either the name of a data-layer type or a type itself.
--
--        Returns
--        -------
--        type
--            A data-layer type.
--
--        Raises
--        ------
--        TypeError
--            If ``dtype`` is neither a string nor a type.
--        ValueError
--            If ``dtype`` is a name, but no data-layer type of that name is
--            registered, or if ``dtype`` is a type, but not a known data-layer
--            type.
--        """
--        if type(dtype) is type:
--            if dtype not in self.dtypes:
--                raise ValueError(
--                    "Type is not a data-layer type: " + repr(dtype))
--            return dtype
--        elif type(dtype) is str:
--            try:
--                return self._str2type[dtype]
--            except KeyError:
--                raise ValueError(
--                    "Type name is not known to the data-layer: " + repr(dtype)
--                    ) from None
--
--        raise TypeError(
--            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    def __getitem__(self, arg):
--        if type(arg) is not tuple:
--            arg = (arg,)
--        if not arg or len(arg) > 2:
--            raise KeyError(arg)
--        to_t = self.parse(arg[0])
--        if len(arg) == 1:
--            converters = {
--                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
--            }
--            return _partial_converter(converters, to_t)
--        from_t = self.parse(arg[1])
--        return self._convert[to_t, from_t]
--
--    def __call__(self, to_type, data):
--        to_type = self.parse(to_type)
--        from_type = self.parse(type(data))
--        if to_type == from_type:
--            return data
--        return self._convert[to_type, from_type](data)
--
--
--cdef class _create:
--    cdef readonly list _creators
--
--    def __init__(self):
--        self._creators = []
--
--    def add_creators(self, creators):
--        """
--        Add creation functions to make a data-layer object from an arbitrary
--        Python object.
--
--        Parameters
--        ----------
--        creators : iterable of (condition, creator, [priority])
--            An iterable of 2- or 3-tuples describing the new data layer
--            creation functions.
--            Each element can individually be a 2- or 3-tuple; they do not need
--            to be all one or the other.
--
--            Elements
--            ........
--            condition : callable (object) -> bool
--                Function determining if the given object can be converted to a
--                data-layer type using this creator.
--
--            creator function: callable (object, shape, copy=True) -> Data
--                The creator function. It should take an object and a shape and
--                return a data-layer type instance. The object may be any object
--                for which the condition function returned ``True`` when tested.
--                The ``object`` and ``shape`` parameters are passed positionally,
--                and the ``copy`` parameter is passed by keyword.
--
--            priority : real, optional (0)
--                The priority associated with this creator. Higher priority
--                conditions will be tested first and the first valid creator
--                (i.e. for which ``condition(object) == True``) will handle
--                the creation.
--
--        Notes
--        -----
--        Default creators are added with the following priorities:
--
--        * Objects that are instances of data-layer types are
--          converted using ``.copy`` with priority 100.
--        * Objects that have a direct equivalent such as ``numpy.ndarray``
--          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
--        * Objects for which ``scipy.sparse.issparse`` is ``True``
--          are converted using an internal CSR converter with
--          priority 20.
--        * If no condition are meet, ``numpy.array`` is used to try convert
--          the input to an array (priority -inf).
--        """
--        for condition, creator, *priority in creators:
--            if not callable(condition):
--                raise TypeError(repr(condition) + " is not a callable")
--            if not callable(create):
--                raise TypeError(repr(create) + " is not a callable")
--            if len(priority) >= 2:
--                raise ValueError("Too many values to unpack for a creator, " +
--                                 "expected 2 or 3, got "+ str(2+len(priority)))
--            priority = float(priority[0] if priority else 0)
--            self._creators.append((condition, creator, priority))
--        self._creators.sort(key=lambda creator: creator[2], reverse=True)
--
--    def __call__(self, arg, shape=None, copy=True):
--        """
--        Build a :class:`qutip.data.Data` object from arg.
--
--        Parameters
--        ----------
--        arg : object
--            Object to be converted to `qutip.data.Data`. Anything that can be
--            converted to a numpy array are valid input.
--
--        shape : tuple, optional
--            The shape of the output as (``rows``, ``columns``).
--        """
--        for condition, create, _ in self._creators:
--            if condition(arg):
--                return create(arg, shape, copy=copy)
--        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
--                        "qutip data format")
--
--
--to = _to()
--create = _create()
-+#cython: language_level=3
-+
-+"""
-+The conversion machinery between different data-layer types, and creation
-+routines from arbitrary data.  The classes `_to` and `_create` are not intended
-+to be exported names, but are the backing machinery of the functions `data.to`
-+and `data.create`, which are built up as the last objects in the `__init__.py`
-+initialisation of the `data` module.
-+"""
-+
-+# This module is compiled by Cython because it's the core of the entire
-+# dispatch table, and having it compiled to a C extension saves about 1µs per
-+# call.  This is not much at all, and there's very little which benefits from
-+# Cython compiliation, but such core functionality is called millions of times
-+# even in a simple interactive QuTiP session, and it all adds up.
-+
-+import numbers
-+
-+import numpy as np
-+from scipy.sparse import dok_matrix, csgraph
-+cimport cython
-+
-+__all__ = ['to', 'create']
-+
-+
-+def _raise_if_unconnected(dtype_list, weights):
-+    unconnected = {}
-+    for i, type_ in enumerate(dtype_list):
-+        missing = [dtype_list[j].__name__
-+                   for j, weight in enumerate(weights[:, i])
-+                   if weight == np.inf]
-+        if missing:
-+            unconnected[type_.__name__] = missing
-+    if unconnected:
-+        message = "Conversion graph not connected.  Cannot reach:\n * "
-+        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
-+                                for to, froms in unconnected.items())
-+        raise NotImplementedError(message)
-+
-+
-+cdef class _converter:
-+    """Callable which converts objects of type `x.from_` to type `x.to`."""
-+
-+    cdef list functions
-+    cdef Py_ssize_t n_functions
-+    cdef readonly type to
-+    cdef readonly type from_
-+
-+    def __init__(self, functions, to_type, from_type):
-+        self.functions = list(functions)
-+        self.n_functions = len(self.functions)
-+        self.to = to_type
-+        self.from_ = from_type
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    def __call__(self, arg):
-+        if not isinstance(arg, self.from_):
-+            raise TypeError(str(arg) + " is not of type " + str(self.from_))
-+        cdef Py_ssize_t i
-+        for i in range(self.n_functions):
-+            arg = self.functions[i](arg)
-+        return arg
-+
-+    def __repr__(self):
-+        return ("<converter to "
-+                + self.to.__name__
-+                + " from " + self.from_.__name__
-+                + ">")
-+
-+
-+cdef class _partial_converter:
-+    """Convert from any known data-layer type into the type `x.to`."""
-+
-+    cdef dict converters
-+    cdef readonly type to
-+
-+    def __init__(self, converters, to_type):
-+        self.converters = dict(converters)
-+        self.to = to_type
-+
-+    def __call__(self, arg):
-+        try:
-+            return self.converters[type(arg)](arg)
-+        except KeyError:
-+            raise TypeError("unknown type of input: " + str(arg)) from None
-+
-+    def __repr__(self):
-+        return "<converter to " + self.to.__name__ + ">"
-+
-+
-+# While `_to` and `_create` are defined as objects here, they are actually
-+# exported by `data.__init__.py` as singleton function objects of their
-+# respective types (without the leading underscore).
-+
-+cdef class _to:
-+    """
-+    Convert data into a different type.  This object is the knowledge source
-+    for every allowable data-layer type in QuTiP, and provides the conversions
-+    between all of them.
-+
-+    The base use is to call this object as a function with signature
-+        (type, data) -> converted_data
-+    where `type` is a type object (such as `data.CSR`, or that obtained by
-+    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
-+    want to create a data-layer type from non-data-layer data, use `create`
-+    instead.
-+
-+    You can get individual converters by using the key-lookup syntax.  For
-+    example, the item
-+        to[CSR, Dense]
-+    is a callable which accepts arguments of type `Dense` and returns the
-+    equivalent item of type `CSR`.  You can also get a generic converter to a
-+    particular data type if only one type is specified, so
-+        to[Dense]
-+    is a callable which accepts all known (at the time of the lookup)
-+    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
-+    section below for more detail.
-+
-+    Internally, the conversion process may go through several steps if new
-+    data-layer types have been defined with few conversions specified between
-+    them and the pre-existing converters.  The first-class QuTiP data types
-+    `Dense` and `CSR` will typically have the best connectivity.
-+
-+
-+    Adding new types
-+    ----------------
-+    You can add new data-layer types by calling the `add_conversions` method of
-+    this object, and then rebuilding all of the mathematical dispatchers.  See
-+    the docstring of that method for more information.
-+
-+
-+    Efficiency notes
-+    ----------------
-+    From an efficiency perspective, there is very little benefit to using the
-+    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
-+    `to[to_type, type(data)]`, so storing the object elides the creation of a
-+    single tuple and a dict lookup, but the cost of this is generally less than
-+    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
-+    efficient than the general call at all, but can be used in cases where a
-+    single callable is required and is more efficient than `functools.partial`.
-+    """
-+
-+    cdef readonly set dtypes
-+    cdef readonly list dispatchers
-+    cdef dict _direct_convert
-+    cdef dict _convert
-+    cdef readonly dict weight
-+    cdef readonly dict _str2type
-+
-+    def __init__(self):
-+        self._direct_convert = {}
-+        self._convert = {}
-+        self.dtypes = set()
-+        self.weight = {}
-+        self.dispatchers = []
-+        self._str2type = {}
-+
-+    def add_conversions(self, converters):
-+        """
-+        Add conversion functions between different data types.  This is an
-+        advanced function, and is only intended for the QuTiP user who wants to
-+        add a new underlying data type to QuTiP.
-+
-+        Any new data type must have at least one converter function given to
-+        produce the new data type from an existing data type, and at least one
-+        which produces an existing data type from the new one.  You need not
-+        specify any more than this, although for efficiency reasons, you may
-+        want to specify direct conversions for all types you expect the new
-+        type to interact with frequently.
-+
-+        Parameters
-+        ----------
-+        converters : iterable of (to_type, from_type, converter, [weight])
-+            An iterable of 3- or 4-tuples describing all the new conversions.
-+            Each element can individually be a 3- or 4-tuple; they do not need
-+            to be all one or the other.
-+
-+            Elements
-+            ........
-+            to_type : type
-+                The data-layer type that is output by the converter.
-+
-+            from_type : type
-+                The data-layer type to be input to the converter.
-+
-+            converter : callable (Data -> Data)
-+                The converter function.  This should take a single argument
-+                (the input data-layer function) and output a data-layer object
-+                of `to_type`.  The converter may assume without error checking
-+                that its input will always be of `to_type`.  It is safe to
-+                specify the same conversion function for multiple inputs so
-+                long as the function handles them all safely, but it must
-+                always return a single output type.
-+
-+            weight : positive real, optional (1)
-+                The weight associated with this conversion.  This must be > 0,
-+                and defaults to `1` if not supplied (which is fixed to be the
-+                cost of conversion to `Dense` from `CSR`).  It is generally
-+                safe just to leave this blank; it is always at best an
-+                approximation.  The currently defined weights are accessible in
-+                the `weights` attribute of this object.
-+        """
-+        for arg in converters:
-+            if len(arg) == 3:
-+                to_type, from_type, converter = arg
-+                weight = 1
-+            elif len(arg) == 4:
-+                to_type, from_type, converter, weight = arg
-+            else:
-+                raise TypeError("unknown converter specification: " + str(arg))
-+            if not isinstance(to_type, type):
-+                raise TypeError(repr(to_type) + " is not a type object")
-+            if not isinstance(from_type, type):
-+                raise TypeError(repr(from_type) + " is not a type object")
-+            if not isinstance(weight, numbers.Real) or weight <= 0:
-+                raise TypeError("weight " + repr(weight) + " is not valid")
-+            self.dtypes.add(from_type)
-+            self.dtypes.add(to_type)
-+            self._direct_convert[(to_type, from_type)] = (converter, weight)
-+        # Two-way mapping to convert between the type of a dtype and an integer
-+        # enumeration value for it.
-+        order, index = [], {}
-+        for i, dtype in enumerate(self.dtypes):
-+            order.append(dtype)
-+            index[dtype] = i
-+        # Treat the conversion problem as a shortest-path graph problem.  We
-+        # build up the graph description as a matrix, then solve the
-+        # all-pairs-shortest-path problem.  We forbid negative weights and
-+        # there are unlikely to be many data types, so the choice of algorithm
-+        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
-+        graph = dok_matrix((len(order), len(order)))
-+        for (to_type, from_type), (_, weight) in self._direct_convert.items():
-+            graph[index[from_type], index[to_type]] = weight
-+        weights, predecessors =\
-+            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
-+        _raise_if_unconnected(order, weights)
-+        # Build the whole shortest path conversion lookup.  We directly store
-+        # all complete shortest paths, even though this is not the most memory
-+        # efficient, because we expect that there will generally be a small
-+        # number of available data types, and we care more about minimising the
-+        # number of lookups required.
-+        self.weight = {}
-+        self._convert = {}
-+        for i, from_t in enumerate(order):
-+            for j, to_t in enumerate(order):
-+                convert = []
-+                weight = 0
-+                cur_t = to_t
-+                pred_i = predecessors[i, j]
-+                while pred_i >= 0:
-+                    pred_t = order[pred_i]
-+                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
-+                    convert.append(_convert)
-+                    weight += _weight
-+                    cur_t = pred_t
-+                    pred_i = predecessors[i, pred_i]
-+                self.weight[(to_t, from_t)] = weight
-+                self._convert[(to_t, from_t)] =\
-+                    _converter(convert[::-1], to_t, from_t)
-+        for dispatcher in self.dispatchers:
-+            dispatcher.rebuild_lookup()
-+
-+    def register_aliases(self, aliases, layer_type):
-+        """
-+        Register a user frendly name for a data-layer type to be recognized by
-+        the :method:`parse` method.
-+
-+        Parameters
-+        ----------
-+        aliases : str or list of str
-+            Name of list of names to be understood to represent the layer_type.
-+
-+        layer_type : type
-+            Data-layer type, must have been registered with
-+            :method:`add_conversions` first.
-+        """
-+        if layer_type not in self.dtypes:
-+            raise ValueError(
-+                "Type is not a data-layer type: " + repr(layer_type))
-+        if isinstance(aliases, str):
-+            aliases = [aliases]
-+        for alias in aliases:
-+            if type(alias) is not str:
-+                raise TypeError("The alias must be a str : " + repr(alias))
-+            self._str2type[alias] = layer_type
-+
-+    def parse(self, dtype):
-+        """
-+        Return a data-layer type object given its name or the type itself.
-+
-+        Parameters
-+        ----------
-+        dtype : type, str
-+            Either the name of a data-layer type or a type itself.
-+
-+        Returns
-+        -------
-+        type
-+            A data-layer type.
-+
-+        Raises
-+        ------
-+        TypeError
-+            If ``dtype`` is neither a string nor a type.
-+        ValueError
-+            If ``dtype`` is a name, but no data-layer type of that name is
-+            registered, or if ``dtype`` is a type, but not a known data-layer
-+            type.
-+        """
-+        if type(dtype) is type:
-+            if dtype not in self.dtypes:
-+                raise ValueError(
-+                    "Type is not a data-layer type: " + repr(dtype))
-+            return dtype
-+        elif type(dtype) is str:
-+            try:
-+                return self._str2type[dtype]
-+            except KeyError:
-+                raise ValueError(
-+                    "Type name is not known to the data-layer: " + repr(dtype)
-+                    ) from None
-+
-+        raise TypeError(
-+            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    def __getitem__(self, arg):
-+        if type(arg) is not tuple:
-+            arg = (arg,)
-+        if not arg or len(arg) > 2:
-+            raise KeyError(arg)
-+        to_t = self.parse(arg[0])
-+        if len(arg) == 1:
-+            converters = {
-+                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
-+            }
-+            return _partial_converter(converters, to_t)
-+        from_t = self.parse(arg[1])
-+        return self._convert[to_t, from_t]
-+
-+    def __call__(self, to_type, data):
-+        to_type = self.parse(to_type)
-+        from_type = self.parse(type(data))
-+        if to_type == from_type:
-+            return data
-+        return self._convert[to_type, from_type](data)
-+
-+
-+cdef class _create:
-+    cdef readonly list _creators
-+
-+    def __init__(self):
-+        self._creators = []
-+
-+    def add_creators(self, creators):
-+        """
-+        Add creation functions to make a data-layer object from an arbitrary
-+        Python object.
-+
-+        Parameters
-+        ----------
-+        creators : iterable of (condition, creator, [priority])
-+            An iterable of 2- or 3-tuples describing the new data layer
-+            creation functions.
-+            Each element can individually be a 2- or 3-tuple; they do not need
-+            to be all one or the other.
-+
-+            Elements
-+            ........
-+            condition : callable (object) -> bool
-+                Function determining if the given object can be converted to a
-+                data-layer type using this creator.
-+
-+            creator function: callable (object, shape, copy=True) -> Data
-+                The creator function. It should take an object and a shape and
-+                return a data-layer type instance. The object may be any object
-+                for which the condition function returned ``True`` when tested.
-+                The ``object`` and ``shape`` parameters are passed positionally,
-+                and the ``copy`` parameter is passed by keyword.
-+
-+            priority : real, optional (0)
-+                The priority associated with this creator. Higher priority
-+                conditions will be tested first and the first valid creator
-+                (i.e. for which ``condition(object) == True``) will handle
-+                the creation.
-+
-+        Notes
-+        -----
-+        Default creators are added with the following priorities:
-+
-+        * Objects that are instances of data-layer types are
-+          converted using ``.copy`` with priority 100.
-+        * Objects that have a direct equivalent such as ``numpy.ndarray``
-+          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
-+        * Objects for which ``scipy.sparse.issparse`` is ``True``
-+          are converted using an internal CSR converter with
-+          priority 20.
-+        * If no condition are meet, ``numpy.array`` is used to try convert
-+          the input to an array (priority -inf).
-+        """
-+        for condition, creator, *priority in creators:
-+            if not callable(condition):
-+                raise TypeError(repr(condition) + " is not a callable")
-+            if not callable(create):
-+                raise TypeError(repr(create) + " is not a callable")
-+            if len(priority) >= 2:
-+                raise ValueError("Too many values to unpack for a creator, " +
-+                                 "expected 2 or 3, got "+ str(2+len(priority)))
-+            priority = float(priority[0] if priority else 0)
-+            self._creators.append((condition, creator, priority))
-+        self._creators.sort(key=lambda creator: creator[2], reverse=True)
-+
-+    def __call__(self, arg, shape=None, copy=True):
-+        """
-+        Build a :class:`qutip.data.Data` object from arg.
-+
-+        Parameters
-+        ----------
-+        arg : object
-+            Object to be converted to `qutip.data.Data`. Anything that can be
-+            converted to a numpy array are valid input.
-+
-+        shape : tuple, optional
-+            The shape of the output as (``rows``, ``columns``).
-+        """
-+        for condition, create, _ in self._creators:
-+            if condition(arg):
-+                return create(arg, shape, copy=copy)
-+        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
-+                        "qutip data format")
-+
-+
-+to = _to()
-+create = _create()
-diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
-index 65dcd319..a05e9b9c 100644
---- a/qutip/core/data/csr.pxd
-+++ b/qutip/core/data/csr.pxd
-@@ -1,166 +1,166 @@
--#cython: language_level=3
--
--from cpython cimport mem
--from libcpp.algorithm cimport sort
--from libc.math cimport fabs
--
--cdef extern from *:
--    void *PyMem_Calloc(size_t n, size_t elsize)
--
--import numpy as np
--cimport numpy as cnp
--
--from qutip.core.data cimport base
--from qutip.core.data.dense cimport Dense
--
--cdef class CSR(base.Data):
--    cdef double complex *data
--    cdef base.idxint *col_index
--    cdef base.idxint *row_index
--    cdef size_t size
--    cdef object _scipy
--    cdef bint _deallocate
--    cpdef CSR copy(CSR self)
--    cpdef object as_scipy(CSR self, bint full=*)
--    cpdef CSR sort_indices(CSR self)
--    cpdef double complex trace(CSR self)
--    cpdef CSR adjoint(CSR self)
--    cpdef CSR conj(CSR self)
--    cpdef CSR transpose(CSR self)
--
--
--cdef struct Accumulator:
--    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
--    # matrices row-by-row (or column-by-column for CSC) where entries may need
--    # to be accumulated (summed) from several locations which may not be
--    # sorted.
--    #
--    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
--    # to the accumulator for this row by calling `scatter`, then fill the row
--    # in the output by calling `gather`.  Prepare the accumulator to receive
--    # the next row by calling `reset`.
--    double complex *values
--    size_t *modified
--    base.idxint *nonzero
--    size_t _cur_row, nnz, size
--    bint _sorted
--
--cdef inline Accumulator acc_alloc(size_t size):
--    """
--    Initialise this accumulator.  `size` should be the number of columns in the
--    matrix (for CSR) or the number of rows (for CSC).
--    """
--    cdef Accumulator acc
--    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
--    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
--    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
--    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
--        raise MemoryError
--    acc.size = size
--    acc.nnz = 0
--    # The value of _cur_row doesn't actually need to match the true row in
--    # the output, it just needs to be a unique number so that we can use it
--    # as a sentinel in `modified` to tell if there's a value in the current
--    # column.
--    acc._cur_row = 1
--    acc._sorted = True
--    return acc
--
--cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
--    """
--    Add a value to the accumulator for this row, in column `position`.  The
--    value is added on to any value already scattered into this position.
--    """
--    # We have to branch on modified[position] anyway (to know whether to add an
--    # entry in nonzero), so we _actually_ reset `values` here.  This has the
--    # potential to save operations too, if the same column is never touched
--    # again.
--    if acc.modified[position] == acc._cur_row:
--        acc.values[position] += value
--    else:
--        acc.values[position] = value
--        acc.modified[position] = acc._cur_row
--        acc.nonzero[acc.nnz] = position
--        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
--        acc.nnz += 1
--
--cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
--    """
--    Copy all the accumulated values into this row into the output pointers.
--    This will always output its values in sorted order.  The pointers should
--    point to the first free space for data to be copied into.  This method will
--    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
--    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
--    updated after each `self.scatter()` operation, and is reset by
--    `self.reset()`.
--
--    Return the actual number of elements copied in.
--    """
--    cdef size_t i, nnz=0, position
--    cdef double complex value
--    if not acc._sorted:
--        sort(acc.nonzero, acc.nonzero + acc.nnz)
--        acc._sorted = True
--    for i in range(acc.nnz):
--        position = acc.nonzero[i]
--        value = acc.values[position]
--        if fabs(value.real) < tol:
--            value.real = 0
--        if fabs(value.imag) < tol:
--            value.imag = 0
--        if value != 0:
--            values[nnz] = value
--            indices[nnz] = position
--            nnz += 1
--    return nnz
--
--cdef inline void acc_reset(Accumulator *acc) nogil:
--    """Prepare the accumulator to accept the next row of input."""
--    # We actually don't need to do anything to reset other than to change
--    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
--    # whether a value was set in this current row (and if not, `scatter`
--    # resets it when it's used), while `nnz`
--    acc.nnz = 0
--    acc._sorted = True
--    acc._cur_row += 1
--
--cdef inline void acc_free(Accumulator *acc):
--    mem.PyMem_Free(acc.values)
--    mem.PyMem_Free(acc.modified)
--    mem.PyMem_Free(acc.nonzero)
--
--
--# Internal structure for sorting pairs of elements.  Not actually meant to be
--# used in external code.
--cdef struct _data_col:
--    double complex data
--    base.idxint col
--
--cdef class Sorter:
--    cdef size_t size
--    cdef base.idxint **argsort
--    cdef _data_col *sort
--
--    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
--    cdef void copy(Sorter self,
--                   double complex *dest_data, base.idxint *dest_cols,
--                   double complex *src_data, base.idxint *src_cols,
--                   size_t size) nogil
--
--
--cpdef CSR fast_from_scipy(object sci)
--cpdef CSR copy_structure(CSR matrix)
--cpdef CSR sorted(CSR matrix)
--cpdef base.idxint nnz(CSR matrix) nogil
--cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
--cpdef CSR empty_like(CSR other)
--cpdef CSR zeros(base.idxint rows, base.idxint cols)
--cpdef CSR identity(base.idxint dimension, double complex scale=*)
--
--cpdef CSR from_dense(Dense matrix)
--cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
--                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
--                           double tol=*)
--
--cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
--                          base.idxint n_blocks, base.idxint block_size)
-+#cython: language_level=3
-+
-+from cpython cimport mem
-+from libcpp.algorithm cimport sort
-+from libc.math cimport fabs
-+
-+cdef extern from *:
-+    void *PyMem_Calloc(size_t n, size_t elsize)
-+
-+import numpy as np
-+cimport numpy as cnp
-+
-+from qutip.core.data cimport base
-+from qutip.core.data.dense cimport Dense
-+
-+cdef class CSR(base.Data):
-+    cdef double complex *data
-+    cdef base.idxint *col_index
-+    cdef base.idxint *row_index
-+    cdef size_t size
-+    cdef object _scipy
-+    cdef bint _deallocate
-+    cpdef CSR copy(CSR self)
-+    cpdef object as_scipy(CSR self, bint full=*)
-+    cpdef CSR sort_indices(CSR self)
-+    cpdef double complex trace(CSR self)
-+    cpdef CSR adjoint(CSR self)
-+    cpdef CSR conj(CSR self)
-+    cpdef CSR transpose(CSR self)
-+
-+
-+cdef struct Accumulator:
-+    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
-+    # matrices row-by-row (or column-by-column for CSC) where entries may need
-+    # to be accumulated (summed) from several locations which may not be
-+    # sorted.
-+    #
-+    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
-+    # to the accumulator for this row by calling `scatter`, then fill the row
-+    # in the output by calling `gather`.  Prepare the accumulator to receive
-+    # the next row by calling `reset`.
-+    double complex *values
-+    size_t *modified
-+    base.idxint *nonzero
-+    size_t _cur_row, nnz, size
-+    bint _sorted
-+
-+cdef inline Accumulator acc_alloc(size_t size):
-+    """
-+    Initialise this accumulator.  `size` should be the number of columns in the
-+    matrix (for CSR) or the number of rows (for CSC).
-+    """
-+    cdef Accumulator acc
-+    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
-+    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
-+    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
-+    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
-+        raise MemoryError
-+    acc.size = size
-+    acc.nnz = 0
-+    # The value of _cur_row doesn't actually need to match the true row in
-+    # the output, it just needs to be a unique number so that we can use it
-+    # as a sentinel in `modified` to tell if there's a value in the current
-+    # column.
-+    acc._cur_row = 1
-+    acc._sorted = True
-+    return acc
-+
-+cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
-+    """
-+    Add a value to the accumulator for this row, in column `position`.  The
-+    value is added on to any value already scattered into this position.
-+    """
-+    # We have to branch on modified[position] anyway (to know whether to add an
-+    # entry in nonzero), so we _actually_ reset `values` here.  This has the
-+    # potential to save operations too, if the same column is never touched
-+    # again.
-+    if acc.modified[position] == acc._cur_row:
-+        acc.values[position] += value
-+    else:
-+        acc.values[position] = value
-+        acc.modified[position] = acc._cur_row
-+        acc.nonzero[acc.nnz] = position
-+        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
-+        acc.nnz += 1
-+
-+cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
-+    """
-+    Copy all the accumulated values into this row into the output pointers.
-+    This will always output its values in sorted order.  The pointers should
-+    point to the first free space for data to be copied into.  This method will
-+    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
-+    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
-+    updated after each `self.scatter()` operation, and is reset by
-+    `self.reset()`.
-+
-+    Return the actual number of elements copied in.
-+    """
-+    cdef size_t i, nnz=0, position
-+    cdef double complex value
-+    if not acc._sorted:
-+        sort(acc.nonzero, acc.nonzero + acc.nnz)
-+        acc._sorted = True
-+    for i in range(acc.nnz):
-+        position = acc.nonzero[i]
-+        value = acc.values[position]
-+        if fabs(value.real) < tol:
-+            value.real = 0
-+        if fabs(value.imag) < tol:
-+            value.imag = 0
-+        if value != 0:
-+            values[nnz] = value
-+            indices[nnz] = position
-+            nnz += 1
-+    return nnz
-+
-+cdef inline void acc_reset(Accumulator *acc) nogil:
-+    """Prepare the accumulator to accept the next row of input."""
-+    # We actually don't need to do anything to reset other than to change
-+    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
-+    # whether a value was set in this current row (and if not, `scatter`
-+    # resets it when it's used), while `nnz`
-+    acc.nnz = 0
-+    acc._sorted = True
-+    acc._cur_row += 1
-+
-+cdef inline void acc_free(Accumulator *acc):
-+    mem.PyMem_Free(acc.values)
-+    mem.PyMem_Free(acc.modified)
-+    mem.PyMem_Free(acc.nonzero)
-+
-+
-+# Internal structure for sorting pairs of elements.  Not actually meant to be
-+# used in external code.
-+cdef struct _data_col:
-+    double complex data
-+    base.idxint col
-+
-+cdef class Sorter:
-+    cdef size_t size
-+    cdef base.idxint **argsort
-+    cdef _data_col *sort
-+
-+    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
-+    cdef void copy(Sorter self,
-+                   double complex *dest_data, base.idxint *dest_cols,
-+                   double complex *src_data, base.idxint *src_cols,
-+                   size_t size) nogil
-+
-+
-+cpdef CSR fast_from_scipy(object sci)
-+cpdef CSR copy_structure(CSR matrix)
-+cpdef CSR sorted(CSR matrix)
-+cpdef base.idxint nnz(CSR matrix) nogil
-+cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
-+cpdef CSR empty_like(CSR other)
-+cpdef CSR zeros(base.idxint rows, base.idxint cols)
-+cpdef CSR identity(base.idxint dimension, double complex scale=*)
-+
-+cpdef CSR from_dense(Dense matrix)
-+cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
-+                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
-+                           double tol=*)
-+
-+cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
-+                          base.idxint n_blocks, base.idxint block_size)
-diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
-index 6cf30b06..fb9fa244 100644
---- a/qutip/core/data/csr.pyx
-+++ b/qutip/core/data/csr.pyx
-@@ -1,965 +1,965 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.string cimport memset, memcpy
--
--from libcpp cimport bool
--from libcpp.algorithm cimport sort
--
--cimport cython
--
--from cpython cimport mem
--
--import numbers
--import warnings
--
--import numpy as np
--cimport numpy as cnp
--import scipy.sparse
--from scipy.sparse import csr_matrix as scipy_csr_matrix
--try:
--    from scipy.sparse.data import _data_matrix as scipy_data_matrix
--except ImportError:
--    # The file data was renamed to _data from scipy 1.8.0
--    from scipy.sparse._data import _data_matrix as scipy_data_matrix
--from scipy.linalg cimport cython_blas as blas
--
--from qutip.core.data cimport base, Dense
--from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
--from qutip.core.data.trace cimport trace_csr
--from qutip.core.data.tidyup cimport tidyup_csr
--from .base import idxint_dtype
--from qutip.settings import settings
--
--cnp.import_array()
--
--cdef extern from *:
--    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
--    void *PyDataMem_NEW(size_t size)
--    void PyDataMem_FREE(void *ptr)
--
--# Very little should be exported on star-import, because most stuff will have
--# naming collisions with other type modules.
--__all__ = ['CSR']
--
--cdef int _ONE = 1
--
--cdef object _csr_matrix(data, indices, indptr, shape):
--    """
--    Factory method of scipy csr_matrix: we skip all the index type-checking
--    because this takes tens of microseconds, and we already know we're in
--    a sensible format.
--    """
--    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
--    # `_data_matrix` is the first object in the inheritance chain which
--    # doesn't have a really slow __init__.
--    scipy_data_matrix.__init__(out)
--    out.data = data
--    out.indices = indices
--    out.indptr = indptr
--    out._shape = shape
--    return out
--
--
--cdef class CSR(base.Data):
--    """
--    Data type for quantum objects storing its data in compressed sparse row
--    (CSR) format.  This is similar to the `scipy` type
--    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
--    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
--    using the `as_scipy()` method.
--    """
--    def __cinit__(self, *args, **kwargs):
--        # By default, we want CSR to deallocate its memory (we depend on Cython
--        # to ensure we don't deallocate a NULL pointer), and we only flip this
--        # when we create a scipy backing.  Since creating the scipy backing
--        # depends on knowing the shape, which happens _after_ data
--        # initialisation and may throw an exception, it is better to have a
--        # single flag that is set as soon as the pointers are assigned.
--        self._deallocate = True
--
--    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
--        # This is the Python __init__ method, so we do not care that it is not
--        # super-fast C access.  Typically Cython code will not call this, but
--        # will use a factory method in this module or at worst, call
--        # CSR.__new__ and manually set everything.  We must be very careful in
--        # this function that the deallocation is set up correctly if any
--        # exceptions occur.
--        cdef size_t ptr
--        cdef base.idxint col
--        cdef object data, col_index, row_index
--        if isinstance(arg, scipy.sparse.spmatrix):
--            arg = arg.tocsr()
--            if shape is not None and shape != arg.shape:
--                raise ValueError("".join([
--                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
--                ]))
--            shape = arg.shape
--            arg = (arg.data, arg.indices, arg.indptr)
--        if not isinstance(arg, tuple):
--            raise TypeError("arg must be a scipy matrix or tuple")
--        if len(arg) != 3:
--            raise ValueError("arg must be a (data, col_index, row_index) tuple")
--        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
--        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
--        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
--        # This flag must be set at the same time as data, col_index and
--        # row_index are assigned.  These assignments cannot raise an exception
--        # in user code due to the above three lines, but further code may.
--        self._deallocate = False
--        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
--        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
--        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
--        self.size = (cnp.PyArray_SIZE(data)
--                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
--                     else cnp.PyArray_SIZE(col_index))
--        if shape is None:
--            warnings.warn("instantiating CSR matrix of unknown shape")
--            # row_index contains an extra element which is nnz.  We assume the
--            # smallest matrix which can hold all these values by iterating
--            # through the columns.  This is slow and probably inaccurate, since
--            # there could be columns containing zero (hence the warning).
--            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
--            col = 1
--            for ptr in range(self.size):
--                col = self.col_index[ptr] if self.col_index[ptr] > col else col
--            self.shape[1] = col
--        else:
--            if not isinstance(shape, tuple):
--                raise TypeError("shape must be a 2-tuple of positive ints")
--            if not (len(shape) == 2
--                    and isinstance(shape[0], int)
--                    and isinstance(shape[1], int)
--                    and shape[0] > 0
--                    and shape[1] > 0):
--                raise ValueError("shape must be a 2-tuple of positive ints")
--            self.shape = shape
--        # Store a reference to the backing scipy matrix so it doesn't get
--        # deallocated before us.
--        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
--        if tidyup:
--            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
--
--    def __reduce__(self):
--        return (fast_from_scipy, (self.as_scipy(),))
--
--    cpdef CSR copy(self):
--        """
--        Return a complete (deep) copy of this object.
--
--        If the type currently has a scipy backing, such as that produced by
--        `as_scipy`, this will not be copied.  The backing is a view onto our
--        data, and a straight copy of this view would be incorrect.  We do not
--        create a new view at copy time, since the user may only access this
--        through a creation method, and creating it ahead of time would incur an
--        unnecessary speed penalty for users who do not need it (including
--        low-level C code).
--        """
--        cdef base.idxint nnz_ = nnz(self)
--        cdef CSR out = empty_like(self)
--        memcpy(out.data, self.data, nnz_*sizeof(double complex))
--        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
--        memcpy(out.row_index, self.row_index,
--               (self.shape[0] + 1)*sizeof(base.idxint))
--        return out
--
--    cpdef object to_array(self):
--        """
--        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
--        is not a view onto the data, and changes to new array will not affect
--        the original data structure.
--        """
--        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
--        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
--        cdef double complex [:, ::1] buffer = out
--        cdef size_t row, ptr
--        for row in range(self.shape[0]):
--            for ptr in range(self.row_index[row], self.row_index[row + 1]):
--                buffer[row, self.col_index[ptr]] = self.data[ptr]
--        return out
--
--    cpdef object as_scipy(self, bint full=False):
--        """
--        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
--        underlying data structures are exposed, such that modifications to the
--        `data`, `indices` and `indptr` buffers in the resulting object will
--        modify this object too.
--
--        If `full` is False (the default), the output array is squeezed so that
--        the SciPy array sees only the filled elements.  If `full` is True,
--        SciPy will see the full underlying buffers, which may include
--        uninitialised elements.  Setting `full=True` is intended for
--        Python-space factory methods.  In all other use cases, `full=False` is
--        much less error prone.
--        """
--        # We store a reference to the scipy matrix not only for caching this
--        # relatively expensive method, but also because we transferred
--        # ownership of our data to the numpy arrays, and we can't allow them to
--        # be collected while we're alive.
--        if self._scipy is not None:
--            return self._scipy
--        cdef cnp.npy_intp length = self.size if full else nnz(self)
--        data = cnp.PyArray_SimpleNewFromData(1, [length],
--                                             cnp.NPY_COMPLEX128,
--                                             self.data)
--        indices = cnp.PyArray_SimpleNewFromData(1, [length],
--                                                base.idxint_DTYPE,
--                                                self.col_index)
--        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
--                                               base.idxint_DTYPE,
--                                               self.row_index)
--        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
--        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
--        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
--        self._deallocate = False
--        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
--        return self._scipy
--
--    cpdef CSR sort_indices(self):
--        cdef Sorter sort
--        cdef base.idxint ptr
--        cdef size_t row, diff, size=0
--        for row in range(self.shape[0]):
--            diff = self.row_index[row + 1] - self.row_index[row]
--            size = diff if diff > size else size
--        sort = Sorter(size)
--        for row in range(self.shape[0]):
--            ptr = self.row_index[row]
--            diff = self.row_index[row + 1] - ptr
--            sort.inplace(self, ptr, diff)
--        return self
--
--    cpdef double complex trace(self):
--        return trace_csr(self)
--
--    cpdef CSR adjoint(self):
--        return adjoint_csr(self)
--
--    cpdef CSR conj(self):
--        return conj_csr(self)
--
--    cpdef CSR transpose(self):
--        return transpose_csr(self)
--
--    def __repr__(self):
--        return "".join([
--            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
--        ])
--
--    def __str__(self):
--        return self.__repr__()
--
--    def __dealloc__(self):
--        # If we have a reference to a scipy type, then we've passed ownership
--        # of the data to numpy, so we let it handle refcounting and we don't
--        # need to deallocate anything ourselves.
--        if not self._deallocate:
--            return
--        if self.data != NULL:
--            PyDataMem_FREE(self.data)
--        if self.col_index != NULL:
--            PyDataMem_FREE(self.col_index)
--        if self.row_index != NULL:
--            PyDataMem_FREE(self.row_index)
--
--
--cpdef CSR fast_from_scipy(object sci):
--    """
--    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
--    checking on any of the inputs, and should consequently be considered very
--    unsafe.  This is primarily for use in the unpickling operation.
--    """
--    cdef CSR out = CSR.__new__(CSR)
--    out.shape = sci.shape
--    out._deallocate = False
--    out._scipy = sci
--    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
--    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
--    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
--    out.size = cnp.PyArray_SIZE(sci.data)
--    return out
--
--
--cpdef CSR copy_structure(CSR matrix):
--    """
--    Return a copy of the input matrix with identical `col_index` and
--    `row_index` matrices, and an allocated, but empty, `data`.  The returned
--    pointers are all separately allocated, but contain the same information.
--
--    This is intended for unary functions on CSR types that maintain the exact
--    structure, but modify each non-zero data element without change their
--    location.
--    """
--    cdef CSR out = empty_like(matrix)
--    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
--    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
--    return out
--
--
--cpdef inline base.idxint nnz(CSR matrix) nogil:
--    """Get the number of non-zero elements of a CSR matrix."""
--    return matrix.row_index[matrix.shape[0]]
--
--
--cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
--    return i[0] < j[0]
--
--cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
--    return x.col < y.col
--
--ctypedef fused _swap_data:
--    double complex
--    base.idxint
--
--cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
--    a[0], b[0] = b[0], a[0]
--
--cdef class Sorter:
--    # Look on my works, ye mighty, and despair!
--    #
--    # This class has hard-coded sorts for up to three elements, for both
--    # copying and in-place varieties.  Everything above that we delegate to a
--    # proper sorting algorithm.
--    def __init__(self, size_t size):
--        self.size = size
--
--    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
--        cdef size_t n
--        cdef base.idxint col0, col1, col2
--        # Fast paths for tridiagonal matrices.  These fast paths minimise the
--        # number of comparisons and swaps made.
--        if size < 2:
--            return
--        if size == 2:
--            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
--                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
--                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
--            return
--        if size == 3:
--            # Faster to store rather than re-dereference, and if someone
--            # changes the data underneath us, we've got larger problems anyway.
--            col0 = matrix.col_index[ptr]
--            col1 = matrix.col_index[ptr + 1]
--            col2 = matrix.col_index[ptr + 2]
--            if col0 < col1:
--                if col1 > col2:
--                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
--                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
--                    if col0 > col2:
--                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
--                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
--            elif col1 < col2:
--                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
--                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
--                if col0 > col2:
--                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
--                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
--            else:
--                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
--                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
--            return
--        # Now we actually have to do the sort properly.  It's easiest just to
--        # copy the data into a temporary structure.
--        if size > self.size or self.sort == NULL:
--            # realloc(NULL, size) is equivalent to malloc(size), so there's no
--            # problem if cols and argsort weren't allocated before.
--            self.size = size if size > self.size else self.size
--            with gil:
--                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
--                                                            self.size * sizeof(_data_col))
--        for n in range(size):
--            self.sort[n].data = matrix.data[ptr + n]
--            self.sort[n].col = matrix.col_index[ptr + n]
--        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
--        for n in range(size):
--            matrix.data[ptr + n] = self.sort[n].data
--            matrix.col_index[ptr + n] = self.sort[n].col
--
--    cdef void copy(self,
--                   double complex *dest_data, base.idxint *dest_cols,
--                   double complex *src_data, base.idxint *src_cols,
--                   size_t size) nogil:
--        cdef size_t n, ptr
--        # Fast paths for small sizes.  Not pretty, but it speeds things up a
--        # lot for up to triadiaongal systems (which are pretty common).
--        if size == 0:
--            return
--        if size == 1:
--            dest_cols[0] = src_cols[0]
--            dest_data[0] = src_data[0]
--            return
--        if size == 2:
--            if src_cols[0] < src_cols[1]:
--                dest_cols[0] = src_cols[0]
--                dest_data[0] = src_data[0]
--                dest_cols[1] = src_cols[1]
--                dest_data[1] = src_data[1]
--            else:
--                dest_cols[1] = src_cols[0]
--                dest_data[1] = src_data[0]
--                dest_cols[0] = src_cols[1]
--                dest_data[0] = src_data[1]
--            return
--        if size == 3:
--            if src_cols[0] < src_cols[1]:
--                if src_cols[0] < src_cols[2]:
--                    dest_cols[0] = src_cols[0]
--                    dest_data[0] = src_data[0]
--                    if src_cols[1] < src_cols[2]:
--                        dest_cols[1] = src_cols[1]
--                        dest_data[1] = src_data[1]
--                        dest_cols[2] = src_cols[2]
--                        dest_data[2] = src_data[2]
--                    else:
--                        dest_cols[2] = src_cols[1]
--                        dest_data[2] = src_data[1]
--                        dest_cols[1] = src_cols[2]
--                        dest_data[1] = src_data[2]
--                else:
--                    dest_cols[1] = src_cols[0]
--                    dest_data[1] = src_data[0]
--                    dest_cols[2] = src_cols[1]
--                    dest_data[2] = src_data[1]
--                    dest_cols[0] = src_cols[2]
--                    dest_data[0] = src_data[2]
--            elif src_cols[0] < src_cols[2]:
--                dest_cols[1] = src_cols[0]
--                dest_data[1] = src_data[0]
--                dest_cols[0] = src_cols[1]
--                dest_data[0] = src_data[1]
--                dest_cols[2] = src_cols[2]
--                dest_data[2] = src_data[2]
--            else:
--                dest_cols[2] = src_cols[0]
--                dest_data[2] = src_data[0]
--                if src_cols[1] < src_cols[2]:
--                    dest_cols[0] = src_cols[1]
--                    dest_data[0] = src_data[1]
--                    dest_cols[1] = src_cols[2]
--                    dest_data[1] = src_data[2]
--                else:
--                    dest_cols[1] = src_cols[1]
--                    dest_data[1] = src_data[1]
--                    dest_cols[0] = src_cols[2]
--                    dest_data[0] = src_data[2]
--            return
--        # Now we're left with the full case, and we have to sort properly.
--        if size > self.size or self.argsort == NULL:
--            # realloc(NULL, size) is equivalent to malloc(size), so there's no
--            # problem if cols and argsort weren't allocated before.
--            self.size = size if size > self.size else self.size
--            with gil:
--                self.argsort = (
--                    <base.idxint **>
--                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
--                )
--        # We do the argsort with two levels of indirection to minimise memory
--        # allocation and copying requirements when this function is being used
--        # to assemble a CSR matrix under an operation which may change the
--        # order of the columns (e.g. permute).  First the user makes the
--        # columns accessible in some contiguous memory (or if they're not
--        # changing them, they can just use the CSR buffers).  We put pointers
--        # to each of those columns in the array which actually gets sorted
--        # using a comparison function which dereferences the pointers and
--        # compares the result.  After the sort, `argsort` will be the pointers
--        # sorted according to the new column, and we know that the "lowest"
--        # pointer in there has the value `src_cols`, so we can do pointer
--        # arithmetic to know which element we should take.
--        #
--        # This is about 30-40% faster than allocating space for structs of
--        # (double complex, idxint), copying in the data and column, sorting and
--        # copying into the new arrays.  Allocating the structs actually
--        # allocates more space than the pointer method (double complex is
--        # very likely to be 2x the size of a pointer, _and_ the struct may need
--        # extra padding to be aligned), so it's probably actually worse for
--        # cache locality.  Despite the sort relying on pointer dereference in
--        # this case, it's actually got very good cache locality.
--        for n in range(size):
--            self.argsort[n] = src_cols + n
--        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
--        for n in range(size):
--            ptr = self.argsort[n] - src_cols
--            dest_cols[n] = src_cols[ptr]
--            dest_data[n] = src_data[ptr]
--
--    def __dealloc__(self):
--        if self.argsort != NULL:
--            mem.PyMem_Free(self.argsort)
--        if self.sort != NULL:
--            mem.PyMem_Free(self.sort)
--
--cpdef CSR sorted(CSR matrix):
--    cdef CSR out = empty_like(matrix)
--    cdef Sorter sort
--    cdef base.idxint ptr
--    cdef size_t row, diff, size=0
--    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
--    for row in range(matrix.shape[0]):
--        diff = matrix.row_index[row + 1] - matrix.row_index[row]
--        size = diff if diff > size else size
--    sort = Sorter(size)
--    for row in range(matrix.shape[0]):
--        ptr = matrix.row_index[row]
--        diff = matrix.row_index[row + 1] - ptr
--        sort.copy(out.data + ptr, out.col_index + ptr,
--                  matrix.data + ptr, matrix.col_index + ptr,
--                  diff)
--    return out
--
--
--cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
--    """
--    Allocate an empty CSR matrix of the given shape, with space for `size`
--    elements in the `data` and `col_index` arrays.
--
--    This does not initialise any of the memory returned, but sets the last
--    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
--    """
--    if size < 0:
--        raise ValueError("size must be a positive integer.")
--    # Python doesn't like allocating nothing.
--    if size == 0:
--        size += 1
--    cdef CSR out = CSR.__new__(CSR)
--    cdef base.idxint row_size = rows + 1
--    out.shape = (rows, cols)
--    out.size = size
--    out.data =\
--        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
--    out.col_index =\
--        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
--    out.row_index =\
--        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
--    # Set the number of non-zero elements to 0.
--    out.row_index[rows] = 0
--    return out
--
--
--cpdef CSR empty_like(CSR other):
--    return empty(other.shape[0], other.shape[1], nnz(other))
--
--
--cpdef CSR zeros(base.idxint rows, base.idxint cols):
--    """
--    Allocate the zero matrix with a given shape.  There will not be any room in
--    the `data` and `col_index` buffers to add new elements.
--    """
--    # We always allocate matrices with at least one element to ensure that we
--    # actually _are_ asking for memory (Python doesn't like allocating nothing)
--    cdef CSR out = empty(rows, cols, 1)
--    out.data[0] = out.col_index[0] = 0
--    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
--    return out
--
--
--cpdef CSR identity(base.idxint dimension, double complex scale=1):
--    """
--    Return a square matrix of the specified dimension, with a constant along
--    the diagonal.  By default this will be the identity matrix, but if `scale`
--    is passed, then the result will be `scale` times the identity.
--    """
--    cdef CSR out = empty(dimension, dimension, dimension)
--    cdef base.idxint i
--    for i in range(dimension):
--        out.data[i] = scale
--        out.col_index[i] = i
--        out.row_index[i] = i
--    out.row_index[dimension] = dimension
--    return out
--
--cpdef CSR from_dense(Dense matrix):
--    # Assume worst-case scenario for non-zero.
--    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
--                         matrix.shape[0]*matrix.shape[1])
--    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
--    row_stride = 1 if matrix.fortran else matrix.shape[1]
--    col_stride = matrix.shape[0] if matrix.fortran else 1
--    out.row_index[0] = 0
--    for row in range(matrix.shape[0]):
--        ptr_in = row_stride * row
--        for col in range(matrix.shape[1]):
--            if matrix.data[ptr_in] != 0:
--                out.data[ptr_out] = matrix.data[ptr_in]
--                out.col_index[ptr_out] = col
--                ptr_out += 1
--            ptr_in += col_stride
--        out.row_index[row + 1] = ptr_out
--    return out
--
--cdef CSR from_coo_pointers(
--    base.idxint *rows, base.idxint *cols, double complex *data,
--    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
--):
--    # Note that COO pointers may not be sorted in row-major order, and that
--    # they may contain duplicate entries which should be implicitly summed.
--    cdef Accumulator acc = acc_alloc(n_cols)
--    cdef CSR out = empty(n_rows, n_cols, nnz)
--    cdef double complex *data_tmp
--    cdef base.idxint *cols_tmp
--    cdef base.idxint row
--    cdef size_t ptr_in, ptr_out, ptr_prev
--    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
--    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
--    if data_tmp == NULL or cols_tmp == NULL:
--        raise MemoryError
--    with nogil:
--        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
--        for ptr_in in range(nnz):
--            out.row_index[rows[ptr_in] + 1] += 1
--        for ptr_out in range(n_rows):
--            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
--        # out.row_index is currently in the normal output form, but we're
--        # temporarily going to modify it to keep track of how many values we've
--        # placed in each row as we iterate through.  At every state,
--        # out.row_index[row] will contain a pointer to the next location that
--        # an element should be placed in this row.
--        for ptr_in in range(nnz):
--            row = rows[ptr_in]
--            ptr_out = out.row_index[row]
--            cols_tmp[ptr_out] = cols[ptr_in]
--            data_tmp[ptr_out] = data[ptr_in]
--            out.row_index[row] += 1
--        # Apply the scatter/gather pattern to find the actual number of
--        # non-zero elements we're writing into each row (since there's a sum,
--        # there may be some zeros of duplicates).  Remember we also need to
--        # shift the row_index array back to what it was before as well.
--        ptr_out = 0
--        ptr_prev = 0
--        for row in range(n_rows):
--            for ptr_in in range(ptr_prev, out.row_index[row]):
--                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
--            ptr_prev = out.row_index[row]
--            out.row_index[row] = ptr_out
--            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
--            acc_reset(&acc)
--        out.row_index[n_rows] = ptr_out
--    mem.PyMem_Free(data_tmp)
--    mem.PyMem_Free(cols_tmp)
--    acc_free(&acc)
--    return out
--
--
--cdef inline base.idxint _diagonal_length(
--    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
--) nogil:
--    if offset > 0:
--        return n_rows if offset <= n_cols - n_rows else n_cols - offset
--    return n_cols if offset > n_cols - n_rows else n_rows + offset
--
--cdef CSR diag(
--    double complex[:] diagonal, base.idxint offset,
--    base.idxint n_rows, base.idxint n_cols,
--):
--    """
--    Construct a CSR matrix with a single non-zero diagonal.
--
--    Parameters
--    ----------
--    diagonal : indexable of double complex
--        The entries (including zeros) that should be placed on the diagonal in
--        the output matrix.  Each entry must have enough entries in it to fill
--        the relevant diagonal.
--
--    offsets : idxint
--        The index of the diagonals.  An offset of 0 is the main diagonal,
--        positive values are above the main diagonal and negative ones are below
--        the main diagonal.
--
--    n_rows, n_cols : idxint
--        The shape of the output.  The result does not need to be square, but
--        the diagonal must be of the correct length to fit in.
--    """
--    if n_rows < 0 or n_cols < 0:
--        raise ValueError("shape must be positive")
--    cdef base.idxint nnz = len(diagonal)
--    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
--    if nnz != n_diag:
--        raise ValueError("incorrect number of diagonal elements")
--    cdef CSR out = empty(n_rows, n_cols, nnz)
--    cdef base.idxint start_row = 0 if offset >= 0 else -offset
--    cdef base.idxint col = 0 if offset <= 0 else offset
--    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
--    nnz = 0
--    for row in range(start_row + 1, start_row + n_diag + 1):
--        out.col_index[nnz] = col
--        out.data[nnz] = diagonal[nnz]
--        col += 1
--        nnz += 1
--        out.row_index[row] = nnz
--    for row in range(start_row + n_diag + 1, n_rows + 1):
--        out.row_index[row] = nnz
--    return out
--
--cdef CSR diags_(
--    list diagonals, base.idxint[:] offsets,
--    base.idxint n_rows, base.idxint n_cols,
--):
--    """
--    Construct a CSR matrix from a list of diagonals and their offsets.  The
--    offsets are assumed to be in sorted order.  This is the C-only interface to
--    csr.diags, and inputs are not sanity checked (use the Python interface for
--    that).
--
--    Parameters
--    ----------
--    diagonals : list of indexable of double complex
--        The entries (including zeros) that should be placed on the diagonals in
--        the output matrix.  Each entry must have enough entries in it to fill
--        the relevant diagonal (not checked).
--
--    offsets : idxint[:]
--        The indices of the diagonals.  These should be sorted and without
--        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
--        An offset of 0 is the main diagonal, positive values are above the main
--        diagonal and negative ones are below the main diagonal.
--
--    n_rows, n_cols : idxint
--        The shape of the output.  The result does not need to be square, but
--        the diagonals must be of the correct length to fit in.
--    """
--    cdef size_t n_diagonals = len(diagonals)
--    if n_diagonals == 0:
--        return zeros(n_rows, n_cols)
--    cdef base.idxint k, row, start_row, offset, nnz=0,
--    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
--    cdef double complex value
--    for k in range(n_diagonals):
--        offset = offsets[k]
--        if offset >= 0 and min_k > k:
--            min_k = k
--        nnz += _diagonal_length(offset, n_rows, n_cols)
--    cdef CSR out = empty(n_rows, n_cols, nnz)
--    nnz = 0
--    out.row_index[0] = 0
--    for row in range(n_rows):
--        if min_k > 0:
--            offset = offsets[min_k - 1]
--            start_row = 0 if offset >= 0 else -offset
--            if start_row == row:
--                min_k -= 1
--        if max_k > 0:
--            offset = offsets[max_k - 1]
--            start_row = 0 if offset >= 0 else -offset
--            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
--                max_k -= 1
--        for k in range(min_k, max_k):
--            offset = offsets[k]
--            value = diagonals[k][row if offset >= 0 else row + offset]
--            if value == 0:
--                continue
--            out.data[nnz] = value
--            out.col_index[nnz] = row + offset
--            nnz += 1
--        out.row_index[row + 1] = nnz
--    return out
--
--@cython.wraparound(True)
--def diags(diagonals, offsets=None, shape=None):
--    """
--    Construct a CSR matrix from diagonals and their offsets.  Using this
--    function in single-argument form produces a square matrix with the given
--    values on the main diagonal.
--
--    With lists of diagonals and offsets, the matrix will be the smallest
--    possible square matrix if shape is not given, but in all cases the
--    diagonals must fit exactly with no extra or missing elements.  Duplicated
--    diagonals will be summed together in the output.
--
--    Parameters
--    ----------
--    diagonals : sequence of array_like of complex or array_like of complex
--        The entries (including zeros) that should be placed on the diagonals in
--        the output matrix.  Each entry must have enough entries in it to fill
--        the relevant diagonal and no more.
--
--    offsets : sequence of integer or integer, optional
--        The indices of the diagonals.  `offsets[i]` is the location of the
--        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
--        values are above the main diagonal and negative ones are below the main
--        diagonal.
--
--    shape : tuple, optional
--        The shape of the output as (``rows``, ``columns``).  The result does
--        not need to be square, but the diagonals must be of the correct length
--        to fit in exactly.
--    """
--    cdef base.idxint n_rows, n_cols, offset
--    try:
--        diagonals = list(diagonals)
--        if diagonals and np.isscalar(diagonals[0]):
--            # Catch the case where we're being called as (for example)
--            #   diags([1, 2, 3], 0)
--            # with a single diagonal and offset.
--            diagonals = [diagonals]
--    except TypeError:
--        raise TypeError("diagonals must be a list of arrays of complex") from None
--    if offsets is None:
--        if len(diagonals) == 0:
--            offsets = []
--        elif len(diagonals) == 1:
--            offsets = [0]
--        else:
--            raise TypeError("offsets must be supplied if passing more than one diagonal")
--    offsets = np.atleast_1d(offsets)
--    if offsets.ndim > 1:
--        raise ValueError("offsets must be a 1D array of integers")
--    if len(diagonals) != len(offsets):
--        raise ValueError("number of diagonals does not match number of offsets")
--    if len(diagonals) == 0:
--        if shape is None:
--            raise ValueError("cannot construct matrix with no diagonals without a shape")
--        else:
--            n_rows, n_cols = shape
--        return zeros(n_rows, n_cols)
--    order = np.argsort(offsets)
--    diagonals_ = []
--    offsets_ = []
--    prev, cur = None, None
--    for i in order:
--        cur = offsets[i]
--        if cur == prev:
--            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
--        else:
--            offsets_.append(cur)
--            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
--        prev = cur
--    if shape is None:
--        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
--    else:
--        try:
--            n_rows, n_cols = shape
--        except (TypeError, ValueError):
--            raise TypeError("shape must be a 2-tuple of positive integers")
--        if n_rows < 0 or n_cols < 0:
--            raise ValueError("shape must be a 2-tuple of positive integers")
--    for i in range(len(diagonals_)):
--        offset = offsets_[i]
--        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
--            raise ValueError("given diagonals do not have the correct lengths")
--    if n_rows == 0 and n_cols == 0:
--        raise ValueError("can't produce a 0x0 matrix")
--    if len(offsets) == 1:
--        # Fast path for a single diagonal.
--        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
--    return diags_(
--        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
--    )
--
--
--cpdef CSR _from_csr_blocks(
--    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
--    base.idxint n_blocks, base.idxint block_size
--):
--    """
--    Construct a CSR from non-overlapping blocks.
--
--    Each operator in ``block_ops`` should be a square CSR operator with
--    shape ``(block_size, block_size)``. The output operator consists of
--    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
--    ``(n_blocks * block_size, n_blocks * block_size)``.
--
--    None of the operators should overlap (i.e. the list of block row and
--    column pairs should be unique).
--
--    Parameters
--    ----------
--    block_rows : sequence of base.idxint integers
--        The block row for each operator. The block row should be in
--        ``range(0, n_blocks)``.
--
--    block_cols : sequence of base.idxint integers
--        The block column for each operator. The block column should be in
--        ``range(0, n_blocks)``.
--
--    block_ops : sequence of CSR matrixes
--        The operators corresponding to the rows and columns in ``block_rows``
--        and ``block_cols``.
--
--    n_blocks : base.idxint
--        Number of blocks. The shape of the final matrix is
--        (n_blocks * block, n_blocks * block).
--
--    block_size : base.idxint
--        Size of each block. The shape of matrices in ``block_ops`` is
--        ``(block_size, block_size)``.
--    """
--    cdef CSR op
--    cdef base.idxint shape = n_blocks * block_size
--    cdef base.idxint nnz_ = 0
--    cdef base.idxint n_ops = len(block_ops)
--    cdef base.idxint i, j
--    cdef base.idxint row_idx, col_idx
--
--    # check arrays are the same length
--    if len(block_rows) != n_ops or len(block_cols) != n_ops:
--        raise ValueError(
--            "The arrays block_rows, block_cols and block_ops should have"
--            " the same length."
--        )
--
--    if n_ops == 0:
--        return zeros(shape, shape)
--
--    # check op shapes and calculate nnz
--    for op in block_ops:
--        nnz_ += nnz(op)
--        if op.shape[0] != block_size or op.shape[1] != block_size:
--            raise ValueError(
--                "Block operators (block_ops) do not have the correct shape."
--            )
--
--    # check ops are ordered by (row, column)
--    row_idx = block_rows[0]
--    col_idx = block_cols[0]
--    for i in range(1, n_ops):
--        if (
--            block_rows[i] < row_idx or
--            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
--        ):
--            raise ValueError(
--                "The arrays block_rows and block_cols must be sorted"
--                " by (row, column)."
--            )
--        row_idx = block_rows[i]
--        col_idx = block_cols[i]
--
--    if nnz_ == 0:
--        return zeros(shape, shape)
--
--    cdef CSR out = empty(shape, shape, nnz_)
--    cdef base.idxint op_idx = 0
--    cdef base.idxint prev_op_idx = 0
--    cdef base.idxint end = 0
--    cdef base.idxint row_pos, col_pos
--    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
--
--    out.row_index[0] = 0
--
--    for row_idx in range(n_blocks):
--        prev_op_idx = op_idx
--        while op_idx < n_ops:
--            if block_rows[op_idx] != row_idx:
--                break
--            op_idx += 1
--
--        row_pos = row_idx * block_size
--        for op_row in range(block_size):
--            for i in range(prev_op_idx, op_idx):
--                op = block_ops[i]
--                if nnz(op) == 0:
--                    # empty CSR matrices have uninitialized row_index entries.
--                    # it's unclear whether users should ever see such matrixes
--                    # but we support them here anyway.
--                    continue
--                col_idx = block_cols[i]
--                col_pos = col_idx * block_size
--                op_row_start = op.row_index[op_row]
--                op_row_end = op.row_index[op_row + 1]
--                op_row_len = op_row_end - op_row_start
--                for j in range(op_row_len):
--                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
--                    out.data[end + j] = op.data[op_row_start + j]
--                end += op_row_len
--            out.row_index[row_pos + op_row + 1] = end
--
--    return out
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.string cimport memset, memcpy
-+
-+from libcpp cimport bool
-+from libcpp.algorithm cimport sort
-+
-+cimport cython
-+
-+from cpython cimport mem
-+
-+import numbers
-+import warnings
-+
-+import numpy as np
-+cimport numpy as cnp
-+import scipy.sparse
-+from scipy.sparse import csr_matrix as scipy_csr_matrix
-+try:
-+    from scipy.sparse.data import _data_matrix as scipy_data_matrix
-+except ImportError:
-+    # The file data was renamed to _data from scipy 1.8.0
-+    from scipy.sparse._data import _data_matrix as scipy_data_matrix
-+from scipy.linalg cimport cython_blas as blas
-+
-+from qutip.core.data cimport base, Dense
-+from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
-+from qutip.core.data.trace cimport trace_csr
-+from qutip.core.data.tidyup cimport tidyup_csr
-+from .base import idxint_dtype
-+from qutip.settings import settings
-+
-+cnp.import_array()
-+
-+cdef extern from *:
-+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-+    void *PyDataMem_NEW(size_t size)
-+    void PyDataMem_FREE(void *ptr)
-+
-+# Very little should be exported on star-import, because most stuff will have
-+# naming collisions with other type modules.
-+__all__ = ['CSR']
-+
-+cdef int _ONE = 1
-+
-+cdef object _csr_matrix(data, indices, indptr, shape):
-+    """
-+    Factory method of scipy csr_matrix: we skip all the index type-checking
-+    because this takes tens of microseconds, and we already know we're in
-+    a sensible format.
-+    """
-+    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
-+    # `_data_matrix` is the first object in the inheritance chain which
-+    # doesn't have a really slow __init__.
-+    scipy_data_matrix.__init__(out)
-+    out.data = data
-+    out.indices = indices
-+    out.indptr = indptr
-+    out._shape = shape
-+    return out
-+
-+
-+cdef class CSR(base.Data):
-+    """
-+    Data type for quantum objects storing its data in compressed sparse row
-+    (CSR) format.  This is similar to the `scipy` type
-+    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
-+    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
-+    using the `as_scipy()` method.
-+    """
-+    def __cinit__(self, *args, **kwargs):
-+        # By default, we want CSR to deallocate its memory (we depend on Cython
-+        # to ensure we don't deallocate a NULL pointer), and we only flip this
-+        # when we create a scipy backing.  Since creating the scipy backing
-+        # depends on knowing the shape, which happens _after_ data
-+        # initialisation and may throw an exception, it is better to have a
-+        # single flag that is set as soon as the pointers are assigned.
-+        self._deallocate = True
-+
-+    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
-+        # This is the Python __init__ method, so we do not care that it is not
-+        # super-fast C access.  Typically Cython code will not call this, but
-+        # will use a factory method in this module or at worst, call
-+        # CSR.__new__ and manually set everything.  We must be very careful in
-+        # this function that the deallocation is set up correctly if any
-+        # exceptions occur.
-+        cdef size_t ptr
-+        cdef base.idxint col
-+        cdef object data, col_index, row_index
-+        if isinstance(arg, scipy.sparse.spmatrix):
-+            arg = arg.tocsr()
-+            if shape is not None and shape != arg.shape:
-+                raise ValueError("".join([
-+                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
-+                ]))
-+            shape = arg.shape
-+            arg = (arg.data, arg.indices, arg.indptr)
-+        if not isinstance(arg, tuple):
-+            raise TypeError("arg must be a scipy matrix or tuple")
-+        if len(arg) != 3:
-+            raise ValueError("arg must be a (data, col_index, row_index) tuple")
-+        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
-+        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
-+        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
-+        # This flag must be set at the same time as data, col_index and
-+        # row_index are assigned.  These assignments cannot raise an exception
-+        # in user code due to the above three lines, but further code may.
-+        self._deallocate = False
-+        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
-+        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
-+        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
-+        self.size = (cnp.PyArray_SIZE(data)
-+                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
-+                     else cnp.PyArray_SIZE(col_index))
-+        if shape is None:
-+            warnings.warn("instantiating CSR matrix of unknown shape")
-+            # row_index contains an extra element which is nnz.  We assume the
-+            # smallest matrix which can hold all these values by iterating
-+            # through the columns.  This is slow and probably inaccurate, since
-+            # there could be columns containing zero (hence the warning).
-+            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
-+            col = 1
-+            for ptr in range(self.size):
-+                col = self.col_index[ptr] if self.col_index[ptr] > col else col
-+            self.shape[1] = col
-+        else:
-+            if not isinstance(shape, tuple):
-+                raise TypeError("shape must be a 2-tuple of positive ints")
-+            if not (len(shape) == 2
-+                    and isinstance(shape[0], int)
-+                    and isinstance(shape[1], int)
-+                    and shape[0] > 0
-+                    and shape[1] > 0):
-+                raise ValueError("shape must be a 2-tuple of positive ints")
-+            self.shape = shape
-+        # Store a reference to the backing scipy matrix so it doesn't get
-+        # deallocated before us.
-+        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
-+        if tidyup:
-+            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
-+
-+    def __reduce__(self):
-+        return (fast_from_scipy, (self.as_scipy(),))
-+
-+    cpdef CSR copy(self):
-+        """
-+        Return a complete (deep) copy of this object.
-+
-+        If the type currently has a scipy backing, such as that produced by
-+        `as_scipy`, this will not be copied.  The backing is a view onto our
-+        data, and a straight copy of this view would be incorrect.  We do not
-+        create a new view at copy time, since the user may only access this
-+        through a creation method, and creating it ahead of time would incur an
-+        unnecessary speed penalty for users who do not need it (including
-+        low-level C code).
-+        """
-+        cdef base.idxint nnz_ = nnz(self)
-+        cdef CSR out = empty_like(self)
-+        memcpy(out.data, self.data, nnz_*sizeof(double complex))
-+        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
-+        memcpy(out.row_index, self.row_index,
-+               (self.shape[0] + 1)*sizeof(base.idxint))
-+        return out
-+
-+    cpdef object to_array(self):
-+        """
-+        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
-+        is not a view onto the data, and changes to new array will not affect
-+        the original data structure.
-+        """
-+        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
-+        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
-+        cdef double complex [:, ::1] buffer = out
-+        cdef size_t row, ptr
-+        for row in range(self.shape[0]):
-+            for ptr in range(self.row_index[row], self.row_index[row + 1]):
-+                buffer[row, self.col_index[ptr]] = self.data[ptr]
-+        return out
-+
-+    cpdef object as_scipy(self, bint full=False):
-+        """
-+        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
-+        underlying data structures are exposed, such that modifications to the
-+        `data`, `indices` and `indptr` buffers in the resulting object will
-+        modify this object too.
-+
-+        If `full` is False (the default), the output array is squeezed so that
-+        the SciPy array sees only the filled elements.  If `full` is True,
-+        SciPy will see the full underlying buffers, which may include
-+        uninitialised elements.  Setting `full=True` is intended for
-+        Python-space factory methods.  In all other use cases, `full=False` is
-+        much less error prone.
-+        """
-+        # We store a reference to the scipy matrix not only for caching this
-+        # relatively expensive method, but also because we transferred
-+        # ownership of our data to the numpy arrays, and we can't allow them to
-+        # be collected while we're alive.
-+        if self._scipy is not None:
-+            return self._scipy
-+        cdef cnp.npy_intp length = self.size if full else nnz(self)
-+        data = cnp.PyArray_SimpleNewFromData(1, [length],
-+                                             cnp.NPY_COMPLEX128,
-+                                             self.data)
-+        indices = cnp.PyArray_SimpleNewFromData(1, [length],
-+                                                base.idxint_DTYPE,
-+                                                self.col_index)
-+        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
-+                                               base.idxint_DTYPE,
-+                                               self.row_index)
-+        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
-+        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
-+        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
-+        self._deallocate = False
-+        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
-+        return self._scipy
-+
-+    cpdef CSR sort_indices(self):
-+        cdef Sorter sort
-+        cdef base.idxint ptr
-+        cdef size_t row, diff, size=0
-+        for row in range(self.shape[0]):
-+            diff = self.row_index[row + 1] - self.row_index[row]
-+            size = diff if diff > size else size
-+        sort = Sorter(size)
-+        for row in range(self.shape[0]):
-+            ptr = self.row_index[row]
-+            diff = self.row_index[row + 1] - ptr
-+            sort.inplace(self, ptr, diff)
-+        return self
-+
-+    cpdef double complex trace(self):
-+        return trace_csr(self)
-+
-+    cpdef CSR adjoint(self):
-+        return adjoint_csr(self)
-+
-+    cpdef CSR conj(self):
-+        return conj_csr(self)
-+
-+    cpdef CSR transpose(self):
-+        return transpose_csr(self)
-+
-+    def __repr__(self):
-+        return "".join([
-+            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
-+        ])
-+
-+    def __str__(self):
-+        return self.__repr__()
-+
-+    def __dealloc__(self):
-+        # If we have a reference to a scipy type, then we've passed ownership
-+        # of the data to numpy, so we let it handle refcounting and we don't
-+        # need to deallocate anything ourselves.
-+        if not self._deallocate:
-+            return
-+        if self.data != NULL:
-+            PyDataMem_FREE(self.data)
-+        if self.col_index != NULL:
-+            PyDataMem_FREE(self.col_index)
-+        if self.row_index != NULL:
-+            PyDataMem_FREE(self.row_index)
-+
-+
-+cpdef CSR fast_from_scipy(object sci):
-+    """
-+    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
-+    checking on any of the inputs, and should consequently be considered very
-+    unsafe.  This is primarily for use in the unpickling operation.
-+    """
-+    cdef CSR out = CSR.__new__(CSR)
-+    out.shape = sci.shape
-+    out._deallocate = False
-+    out._scipy = sci
-+    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
-+    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
-+    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
-+    out.size = cnp.PyArray_SIZE(sci.data)
-+    return out
-+
-+
-+cpdef CSR copy_structure(CSR matrix):
-+    """
-+    Return a copy of the input matrix with identical `col_index` and
-+    `row_index` matrices, and an allocated, but empty, `data`.  The returned
-+    pointers are all separately allocated, but contain the same information.
-+
-+    This is intended for unary functions on CSR types that maintain the exact
-+    structure, but modify each non-zero data element without change their
-+    location.
-+    """
-+    cdef CSR out = empty_like(matrix)
-+    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
-+    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
-+    return out
-+
-+
-+cpdef inline base.idxint nnz(CSR matrix) nogil:
-+    """Get the number of non-zero elements of a CSR matrix."""
-+    return matrix.row_index[matrix.shape[0]]
-+
-+
-+cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
-+    return i[0] < j[0]
-+
-+cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
-+    return x.col < y.col
-+
-+ctypedef fused _swap_data:
-+    double complex
-+    base.idxint
-+
-+cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
-+    a[0], b[0] = b[0], a[0]
-+
-+cdef class Sorter:
-+    # Look on my works, ye mighty, and despair!
-+    #
-+    # This class has hard-coded sorts for up to three elements, for both
-+    # copying and in-place varieties.  Everything above that we delegate to a
-+    # proper sorting algorithm.
-+    def __init__(self, size_t size):
-+        self.size = size
-+
-+    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
-+        cdef size_t n
-+        cdef base.idxint col0, col1, col2
-+        # Fast paths for tridiagonal matrices.  These fast paths minimise the
-+        # number of comparisons and swaps made.
-+        if size < 2:
-+            return
-+        if size == 2:
-+            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
-+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-+            return
-+        if size == 3:
-+            # Faster to store rather than re-dereference, and if someone
-+            # changes the data underneath us, we've got larger problems anyway.
-+            col0 = matrix.col_index[ptr]
-+            col1 = matrix.col_index[ptr + 1]
-+            col2 = matrix.col_index[ptr + 2]
-+            if col0 < col1:
-+                if col1 > col2:
-+                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
-+                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
-+                    if col0 > col2:
-+                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-+                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-+            elif col1 < col2:
-+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-+                if col0 > col2:
-+                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
-+                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
-+            else:
-+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
-+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
-+            return
-+        # Now we actually have to do the sort properly.  It's easiest just to
-+        # copy the data into a temporary structure.
-+        if size > self.size or self.sort == NULL:
-+            # realloc(NULL, size) is equivalent to malloc(size), so there's no
-+            # problem if cols and argsort weren't allocated before.
-+            self.size = size if size > self.size else self.size
-+            with gil:
-+                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
-+                                                            self.size * sizeof(_data_col))
-+        for n in range(size):
-+            self.sort[n].data = matrix.data[ptr + n]
-+            self.sort[n].col = matrix.col_index[ptr + n]
-+        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
-+        for n in range(size):
-+            matrix.data[ptr + n] = self.sort[n].data
-+            matrix.col_index[ptr + n] = self.sort[n].col
-+
-+    cdef void copy(self,
-+                   double complex *dest_data, base.idxint *dest_cols,
-+                   double complex *src_data, base.idxint *src_cols,
-+                   size_t size) nogil:
-+        cdef size_t n, ptr
-+        # Fast paths for small sizes.  Not pretty, but it speeds things up a
-+        # lot for up to triadiaongal systems (which are pretty common).
-+        if size == 0:
-+            return
-+        if size == 1:
-+            dest_cols[0] = src_cols[0]
-+            dest_data[0] = src_data[0]
-+            return
-+        if size == 2:
-+            if src_cols[0] < src_cols[1]:
-+                dest_cols[0] = src_cols[0]
-+                dest_data[0] = src_data[0]
-+                dest_cols[1] = src_cols[1]
-+                dest_data[1] = src_data[1]
-+            else:
-+                dest_cols[1] = src_cols[0]
-+                dest_data[1] = src_data[0]
-+                dest_cols[0] = src_cols[1]
-+                dest_data[0] = src_data[1]
-+            return
-+        if size == 3:
-+            if src_cols[0] < src_cols[1]:
-+                if src_cols[0] < src_cols[2]:
-+                    dest_cols[0] = src_cols[0]
-+                    dest_data[0] = src_data[0]
-+                    if src_cols[1] < src_cols[2]:
-+                        dest_cols[1] = src_cols[1]
-+                        dest_data[1] = src_data[1]
-+                        dest_cols[2] = src_cols[2]
-+                        dest_data[2] = src_data[2]
-+                    else:
-+                        dest_cols[2] = src_cols[1]
-+                        dest_data[2] = src_data[1]
-+                        dest_cols[1] = src_cols[2]
-+                        dest_data[1] = src_data[2]
-+                else:
-+                    dest_cols[1] = src_cols[0]
-+                    dest_data[1] = src_data[0]
-+                    dest_cols[2] = src_cols[1]
-+                    dest_data[2] = src_data[1]
-+                    dest_cols[0] = src_cols[2]
-+                    dest_data[0] = src_data[2]
-+            elif src_cols[0] < src_cols[2]:
-+                dest_cols[1] = src_cols[0]
-+                dest_data[1] = src_data[0]
-+                dest_cols[0] = src_cols[1]
-+                dest_data[0] = src_data[1]
-+                dest_cols[2] = src_cols[2]
-+                dest_data[2] = src_data[2]
-+            else:
-+                dest_cols[2] = src_cols[0]
-+                dest_data[2] = src_data[0]
-+                if src_cols[1] < src_cols[2]:
-+                    dest_cols[0] = src_cols[1]
-+                    dest_data[0] = src_data[1]
-+                    dest_cols[1] = src_cols[2]
-+                    dest_data[1] = src_data[2]
-+                else:
-+                    dest_cols[1] = src_cols[1]
-+                    dest_data[1] = src_data[1]
-+                    dest_cols[0] = src_cols[2]
-+                    dest_data[0] = src_data[2]
-+            return
-+        # Now we're left with the full case, and we have to sort properly.
-+        if size > self.size or self.argsort == NULL:
-+            # realloc(NULL, size) is equivalent to malloc(size), so there's no
-+            # problem if cols and argsort weren't allocated before.
-+            self.size = size if size > self.size else self.size
-+            with gil:
-+                self.argsort = (
-+                    <base.idxint **>
-+                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
-+                )
-+        # We do the argsort with two levels of indirection to minimise memory
-+        # allocation and copying requirements when this function is being used
-+        # to assemble a CSR matrix under an operation which may change the
-+        # order of the columns (e.g. permute).  First the user makes the
-+        # columns accessible in some contiguous memory (or if they're not
-+        # changing them, they can just use the CSR buffers).  We put pointers
-+        # to each of those columns in the array which actually gets sorted
-+        # using a comparison function which dereferences the pointers and
-+        # compares the result.  After the sort, `argsort` will be the pointers
-+        # sorted according to the new column, and we know that the "lowest"
-+        # pointer in there has the value `src_cols`, so we can do pointer
-+        # arithmetic to know which element we should take.
-+        #
-+        # This is about 30-40% faster than allocating space for structs of
-+        # (double complex, idxint), copying in the data and column, sorting and
-+        # copying into the new arrays.  Allocating the structs actually
-+        # allocates more space than the pointer method (double complex is
-+        # very likely to be 2x the size of a pointer, _and_ the struct may need
-+        # extra padding to be aligned), so it's probably actually worse for
-+        # cache locality.  Despite the sort relying on pointer dereference in
-+        # this case, it's actually got very good cache locality.
-+        for n in range(size):
-+            self.argsort[n] = src_cols + n
-+        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
-+        for n in range(size):
-+            ptr = self.argsort[n] - src_cols
-+            dest_cols[n] = src_cols[ptr]
-+            dest_data[n] = src_data[ptr]
-+
-+    def __dealloc__(self):
-+        if self.argsort != NULL:
-+            mem.PyMem_Free(self.argsort)
-+        if self.sort != NULL:
-+            mem.PyMem_Free(self.sort)
-+
-+cpdef CSR sorted(CSR matrix):
-+    cdef CSR out = empty_like(matrix)
-+    cdef Sorter sort
-+    cdef base.idxint ptr
-+    cdef size_t row, diff, size=0
-+    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
-+    for row in range(matrix.shape[0]):
-+        diff = matrix.row_index[row + 1] - matrix.row_index[row]
-+        size = diff if diff > size else size
-+    sort = Sorter(size)
-+    for row in range(matrix.shape[0]):
-+        ptr = matrix.row_index[row]
-+        diff = matrix.row_index[row + 1] - ptr
-+        sort.copy(out.data + ptr, out.col_index + ptr,
-+                  matrix.data + ptr, matrix.col_index + ptr,
-+                  diff)
-+    return out
-+
-+
-+cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
-+    """
-+    Allocate an empty CSR matrix of the given shape, with space for `size`
-+    elements in the `data` and `col_index` arrays.
-+
-+    This does not initialise any of the memory returned, but sets the last
-+    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
-+    """
-+    if size < 0:
-+        raise ValueError("size must be a positive integer.")
-+    # Python doesn't like allocating nothing.
-+    if size == 0:
-+        size += 1
-+    cdef CSR out = CSR.__new__(CSR)
-+    cdef base.idxint row_size = rows + 1
-+    out.shape = (rows, cols)
-+    out.size = size
-+    out.data =\
-+        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
-+    out.col_index =\
-+        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
-+    out.row_index =\
-+        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
-+    # Set the number of non-zero elements to 0.
-+    out.row_index[rows] = 0
-+    return out
-+
-+
-+cpdef CSR empty_like(CSR other):
-+    return empty(other.shape[0], other.shape[1], nnz(other))
-+
-+
-+cpdef CSR zeros(base.idxint rows, base.idxint cols):
-+    """
-+    Allocate the zero matrix with a given shape.  There will not be any room in
-+    the `data` and `col_index` buffers to add new elements.
-+    """
-+    # We always allocate matrices with at least one element to ensure that we
-+    # actually _are_ asking for memory (Python doesn't like allocating nothing)
-+    cdef CSR out = empty(rows, cols, 1)
-+    out.data[0] = out.col_index[0] = 0
-+    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
-+    return out
-+
-+
-+cpdef CSR identity(base.idxint dimension, double complex scale=1):
-+    """
-+    Return a square matrix of the specified dimension, with a constant along
-+    the diagonal.  By default this will be the identity matrix, but if `scale`
-+    is passed, then the result will be `scale` times the identity.
-+    """
-+    cdef CSR out = empty(dimension, dimension, dimension)
-+    cdef base.idxint i
-+    for i in range(dimension):
-+        out.data[i] = scale
-+        out.col_index[i] = i
-+        out.row_index[i] = i
-+    out.row_index[dimension] = dimension
-+    return out
-+
-+cpdef CSR from_dense(Dense matrix):
-+    # Assume worst-case scenario for non-zero.
-+    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
-+                         matrix.shape[0]*matrix.shape[1])
-+    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
-+    row_stride = 1 if matrix.fortran else matrix.shape[1]
-+    col_stride = matrix.shape[0] if matrix.fortran else 1
-+    out.row_index[0] = 0
-+    for row in range(matrix.shape[0]):
-+        ptr_in = row_stride * row
-+        for col in range(matrix.shape[1]):
-+            if matrix.data[ptr_in] != 0:
-+                out.data[ptr_out] = matrix.data[ptr_in]
-+                out.col_index[ptr_out] = col
-+                ptr_out += 1
-+            ptr_in += col_stride
-+        out.row_index[row + 1] = ptr_out
-+    return out
-+
-+cdef CSR from_coo_pointers(
-+    base.idxint *rows, base.idxint *cols, double complex *data,
-+    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
-+):
-+    # Note that COO pointers may not be sorted in row-major order, and that
-+    # they may contain duplicate entries which should be implicitly summed.
-+    cdef Accumulator acc = acc_alloc(n_cols)
-+    cdef CSR out = empty(n_rows, n_cols, nnz)
-+    cdef double complex *data_tmp
-+    cdef base.idxint *cols_tmp
-+    cdef base.idxint row
-+    cdef size_t ptr_in, ptr_out, ptr_prev
-+    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
-+    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
-+    if data_tmp == NULL or cols_tmp == NULL:
-+        raise MemoryError
-+    with nogil:
-+        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
-+        for ptr_in in range(nnz):
-+            out.row_index[rows[ptr_in] + 1] += 1
-+        for ptr_out in range(n_rows):
-+            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
-+        # out.row_index is currently in the normal output form, but we're
-+        # temporarily going to modify it to keep track of how many values we've
-+        # placed in each row as we iterate through.  At every state,
-+        # out.row_index[row] will contain a pointer to the next location that
-+        # an element should be placed in this row.
-+        for ptr_in in range(nnz):
-+            row = rows[ptr_in]
-+            ptr_out = out.row_index[row]
-+            cols_tmp[ptr_out] = cols[ptr_in]
-+            data_tmp[ptr_out] = data[ptr_in]
-+            out.row_index[row] += 1
-+        # Apply the scatter/gather pattern to find the actual number of
-+        # non-zero elements we're writing into each row (since there's a sum,
-+        # there may be some zeros of duplicates).  Remember we also need to
-+        # shift the row_index array back to what it was before as well.
-+        ptr_out = 0
-+        ptr_prev = 0
-+        for row in range(n_rows):
-+            for ptr_in in range(ptr_prev, out.row_index[row]):
-+                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
-+            ptr_prev = out.row_index[row]
-+            out.row_index[row] = ptr_out
-+            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
-+            acc_reset(&acc)
-+        out.row_index[n_rows] = ptr_out
-+    mem.PyMem_Free(data_tmp)
-+    mem.PyMem_Free(cols_tmp)
-+    acc_free(&acc)
-+    return out
-+
-+
-+cdef inline base.idxint _diagonal_length(
-+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-+) nogil:
-+    if offset > 0:
-+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-+    return n_cols if offset > n_cols - n_rows else n_rows + offset
-+
-+cdef CSR diag(
-+    double complex[:] diagonal, base.idxint offset,
-+    base.idxint n_rows, base.idxint n_cols,
-+):
-+    """
-+    Construct a CSR matrix with a single non-zero diagonal.
-+
-+    Parameters
-+    ----------
-+    diagonal : indexable of double complex
-+        The entries (including zeros) that should be placed on the diagonal in
-+        the output matrix.  Each entry must have enough entries in it to fill
-+        the relevant diagonal.
-+
-+    offsets : idxint
-+        The index of the diagonals.  An offset of 0 is the main diagonal,
-+        positive values are above the main diagonal and negative ones are below
-+        the main diagonal.
-+
-+    n_rows, n_cols : idxint
-+        The shape of the output.  The result does not need to be square, but
-+        the diagonal must be of the correct length to fit in.
-+    """
-+    if n_rows < 0 or n_cols < 0:
-+        raise ValueError("shape must be positive")
-+    cdef base.idxint nnz = len(diagonal)
-+    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
-+    if nnz != n_diag:
-+        raise ValueError("incorrect number of diagonal elements")
-+    cdef CSR out = empty(n_rows, n_cols, nnz)
-+    cdef base.idxint start_row = 0 if offset >= 0 else -offset
-+    cdef base.idxint col = 0 if offset <= 0 else offset
-+    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
-+    nnz = 0
-+    for row in range(start_row + 1, start_row + n_diag + 1):
-+        out.col_index[nnz] = col
-+        out.data[nnz] = diagonal[nnz]
-+        col += 1
-+        nnz += 1
-+        out.row_index[row] = nnz
-+    for row in range(start_row + n_diag + 1, n_rows + 1):
-+        out.row_index[row] = nnz
-+    return out
-+
-+cdef CSR diags_(
-+    list diagonals, base.idxint[:] offsets,
-+    base.idxint n_rows, base.idxint n_cols,
-+):
-+    """
-+    Construct a CSR matrix from a list of diagonals and their offsets.  The
-+    offsets are assumed to be in sorted order.  This is the C-only interface to
-+    csr.diags, and inputs are not sanity checked (use the Python interface for
-+    that).
-+
-+    Parameters
-+    ----------
-+    diagonals : list of indexable of double complex
-+        The entries (including zeros) that should be placed on the diagonals in
-+        the output matrix.  Each entry must have enough entries in it to fill
-+        the relevant diagonal (not checked).
-+
-+    offsets : idxint[:]
-+        The indices of the diagonals.  These should be sorted and without
-+        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
-+        An offset of 0 is the main diagonal, positive values are above the main
-+        diagonal and negative ones are below the main diagonal.
-+
-+    n_rows, n_cols : idxint
-+        The shape of the output.  The result does not need to be square, but
-+        the diagonals must be of the correct length to fit in.
-+    """
-+    cdef size_t n_diagonals = len(diagonals)
-+    if n_diagonals == 0:
-+        return zeros(n_rows, n_cols)
-+    cdef base.idxint k, row, start_row, offset, nnz=0,
-+    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
-+    cdef double complex value
-+    for k in range(n_diagonals):
-+        offset = offsets[k]
-+        if offset >= 0 and min_k > k:
-+            min_k = k
-+        nnz += _diagonal_length(offset, n_rows, n_cols)
-+    cdef CSR out = empty(n_rows, n_cols, nnz)
-+    nnz = 0
-+    out.row_index[0] = 0
-+    for row in range(n_rows):
-+        if min_k > 0:
-+            offset = offsets[min_k - 1]
-+            start_row = 0 if offset >= 0 else -offset
-+            if start_row == row:
-+                min_k -= 1
-+        if max_k > 0:
-+            offset = offsets[max_k - 1]
-+            start_row = 0 if offset >= 0 else -offset
-+            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
-+                max_k -= 1
-+        for k in range(min_k, max_k):
-+            offset = offsets[k]
-+            value = diagonals[k][row if offset >= 0 else row + offset]
-+            if value == 0:
-+                continue
-+            out.data[nnz] = value
-+            out.col_index[nnz] = row + offset
-+            nnz += 1
-+        out.row_index[row + 1] = nnz
-+    return out
-+
-+@cython.wraparound(True)
-+def diags(diagonals, offsets=None, shape=None):
-+    """
-+    Construct a CSR matrix from diagonals and their offsets.  Using this
-+    function in single-argument form produces a square matrix with the given
-+    values on the main diagonal.
-+
-+    With lists of diagonals and offsets, the matrix will be the smallest
-+    possible square matrix if shape is not given, but in all cases the
-+    diagonals must fit exactly with no extra or missing elements.  Duplicated
-+    diagonals will be summed together in the output.
-+
-+    Parameters
-+    ----------
-+    diagonals : sequence of array_like of complex or array_like of complex
-+        The entries (including zeros) that should be placed on the diagonals in
-+        the output matrix.  Each entry must have enough entries in it to fill
-+        the relevant diagonal and no more.
-+
-+    offsets : sequence of integer or integer, optional
-+        The indices of the diagonals.  `offsets[i]` is the location of the
-+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-+        values are above the main diagonal and negative ones are below the main
-+        diagonal.
-+
-+    shape : tuple, optional
-+        The shape of the output as (``rows``, ``columns``).  The result does
-+        not need to be square, but the diagonals must be of the correct length
-+        to fit in exactly.
-+    """
-+    cdef base.idxint n_rows, n_cols, offset
-+    try:
-+        diagonals = list(diagonals)
-+        if diagonals and np.isscalar(diagonals[0]):
-+            # Catch the case where we're being called as (for example)
-+            #   diags([1, 2, 3], 0)
-+            # with a single diagonal and offset.
-+            diagonals = [diagonals]
-+    except TypeError:
-+        raise TypeError("diagonals must be a list of arrays of complex") from None
-+    if offsets is None:
-+        if len(diagonals) == 0:
-+            offsets = []
-+        elif len(diagonals) == 1:
-+            offsets = [0]
-+        else:
-+            raise TypeError("offsets must be supplied if passing more than one diagonal")
-+    offsets = np.atleast_1d(offsets)
-+    if offsets.ndim > 1:
-+        raise ValueError("offsets must be a 1D array of integers")
-+    if len(diagonals) != len(offsets):
-+        raise ValueError("number of diagonals does not match number of offsets")
-+    if len(diagonals) == 0:
-+        if shape is None:
-+            raise ValueError("cannot construct matrix with no diagonals without a shape")
-+        else:
-+            n_rows, n_cols = shape
-+        return zeros(n_rows, n_cols)
-+    order = np.argsort(offsets)
-+    diagonals_ = []
-+    offsets_ = []
-+    prev, cur = None, None
-+    for i in order:
-+        cur = offsets[i]
-+        if cur == prev:
-+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-+        else:
-+            offsets_.append(cur)
-+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-+        prev = cur
-+    if shape is None:
-+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-+    else:
-+        try:
-+            n_rows, n_cols = shape
-+        except (TypeError, ValueError):
-+            raise TypeError("shape must be a 2-tuple of positive integers")
-+        if n_rows < 0 or n_cols < 0:
-+            raise ValueError("shape must be a 2-tuple of positive integers")
-+    for i in range(len(diagonals_)):
-+        offset = offsets_[i]
-+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-+            raise ValueError("given diagonals do not have the correct lengths")
-+    if n_rows == 0 and n_cols == 0:
-+        raise ValueError("can't produce a 0x0 matrix")
-+    if len(offsets) == 1:
-+        # Fast path for a single diagonal.
-+        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
-+    return diags_(
-+        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
-+    )
-+
-+
-+cpdef CSR _from_csr_blocks(
-+    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
-+    base.idxint n_blocks, base.idxint block_size
-+):
-+    """
-+    Construct a CSR from non-overlapping blocks.
-+
-+    Each operator in ``block_ops`` should be a square CSR operator with
-+    shape ``(block_size, block_size)``. The output operator consists of
-+    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
-+    ``(n_blocks * block_size, n_blocks * block_size)``.
-+
-+    None of the operators should overlap (i.e. the list of block row and
-+    column pairs should be unique).
-+
-+    Parameters
-+    ----------
-+    block_rows : sequence of base.idxint integers
-+        The block row for each operator. The block row should be in
-+        ``range(0, n_blocks)``.
-+
-+    block_cols : sequence of base.idxint integers
-+        The block column for each operator. The block column should be in
-+        ``range(0, n_blocks)``.
-+
-+    block_ops : sequence of CSR matrixes
-+        The operators corresponding to the rows and columns in ``block_rows``
-+        and ``block_cols``.
-+
-+    n_blocks : base.idxint
-+        Number of blocks. The shape of the final matrix is
-+        (n_blocks * block, n_blocks * block).
-+
-+    block_size : base.idxint
-+        Size of each block. The shape of matrices in ``block_ops`` is
-+        ``(block_size, block_size)``.
-+    """
-+    cdef CSR op
-+    cdef base.idxint shape = n_blocks * block_size
-+    cdef base.idxint nnz_ = 0
-+    cdef base.idxint n_ops = len(block_ops)
-+    cdef base.idxint i, j
-+    cdef base.idxint row_idx, col_idx
-+
-+    # check arrays are the same length
-+    if len(block_rows) != n_ops or len(block_cols) != n_ops:
-+        raise ValueError(
-+            "The arrays block_rows, block_cols and block_ops should have"
-+            " the same length."
-+        )
-+
-+    if n_ops == 0:
-+        return zeros(shape, shape)
-+
-+    # check op shapes and calculate nnz
-+    for op in block_ops:
-+        nnz_ += nnz(op)
-+        if op.shape[0] != block_size or op.shape[1] != block_size:
-+            raise ValueError(
-+                "Block operators (block_ops) do not have the correct shape."
-+            )
-+
-+    # check ops are ordered by (row, column)
-+    row_idx = block_rows[0]
-+    col_idx = block_cols[0]
-+    for i in range(1, n_ops):
-+        if (
-+            block_rows[i] < row_idx or
-+            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
-+        ):
-+            raise ValueError(
-+                "The arrays block_rows and block_cols must be sorted"
-+                " by (row, column)."
-+            )
-+        row_idx = block_rows[i]
-+        col_idx = block_cols[i]
-+
-+    if nnz_ == 0:
-+        return zeros(shape, shape)
-+
-+    cdef CSR out = empty(shape, shape, nnz_)
-+    cdef base.idxint op_idx = 0
-+    cdef base.idxint prev_op_idx = 0
-+    cdef base.idxint end = 0
-+    cdef base.idxint row_pos, col_pos
-+    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
-+
-+    out.row_index[0] = 0
-+
-+    for row_idx in range(n_blocks):
-+        prev_op_idx = op_idx
-+        while op_idx < n_ops:
-+            if block_rows[op_idx] != row_idx:
-+                break
-+            op_idx += 1
-+
-+        row_pos = row_idx * block_size
-+        for op_row in range(block_size):
-+            for i in range(prev_op_idx, op_idx):
-+                op = block_ops[i]
-+                if nnz(op) == 0:
-+                    # empty CSR matrices have uninitialized row_index entries.
-+                    # it's unclear whether users should ever see such matrixes
-+                    # but we support them here anyway.
-+                    continue
-+                col_idx = block_cols[i]
-+                col_pos = col_idx * block_size
-+                op_row_start = op.row_index[op_row]
-+                op_row_end = op.row_index[op_row + 1]
-+                op_row_len = op_row_end - op_row_start
-+                for j in range(op_row_len):
-+                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
-+                    out.data[end + j] = op.data[op_row_start + j]
-+                end += op_row_len
-+            out.row_index[row_pos + op_row + 1] = end
-+
-+    return out
-diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
-index 3c3dad93..354bf510 100644
---- a/qutip/core/data/dense.pxd
-+++ b/qutip/core/data/dense.pxd
-@@ -1,30 +1,30 @@
--#cython: language_level=3
--
--cimport numpy as cnp
--
--from . cimport base
--from .csr cimport CSR
--
--cdef class Dense(base.Data):
--    cdef double complex *data
--    cdef bint fortran
--    cdef object _np
--    cdef bint _deallocate
--    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
--    cpdef Dense reorder(Dense self, int fortran=*)
--    cpdef Dense copy(Dense self)
--    cpdef object as_ndarray(Dense self)
--    cpdef object to_array(Dense self)
--    cpdef double complex trace(Dense self)
--    cpdef Dense adjoint(Dense self)
--    cpdef Dense conj(Dense self)
--    cpdef Dense transpose(Dense self)
--
--cpdef Dense fast_from_numpy(object array)
--cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
--cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
--cpdef Dense empty_like(Dense other, int fortran=*)
--cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
--cpdef Dense identity(base.idxint dimension, double complex scale=*,
--                     bint fortran=*)
--cpdef Dense from_csr(CSR matrix, bint fortran=*)
-+#cython: language_level=3
-+
-+cimport numpy as cnp
-+
-+from . cimport base
-+from .csr cimport CSR
-+
-+cdef class Dense(base.Data):
-+    cdef double complex *data
-+    cdef bint fortran
-+    cdef object _np
-+    cdef bint _deallocate
-+    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
-+    cpdef Dense reorder(Dense self, int fortran=*)
-+    cpdef Dense copy(Dense self)
-+    cpdef object as_ndarray(Dense self)
-+    cpdef object to_array(Dense self)
-+    cpdef double complex trace(Dense self)
-+    cpdef Dense adjoint(Dense self)
-+    cpdef Dense conj(Dense self)
-+    cpdef Dense transpose(Dense self)
-+
-+cpdef Dense fast_from_numpy(object array)
-+cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
-+cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
-+cpdef Dense empty_like(Dense other, int fortran=*)
-+cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
-+cpdef Dense identity(base.idxint dimension, double complex scale=*,
-+                     bint fortran=*)
-+cpdef Dense from_csr(CSR matrix, bint fortran=*)
-diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
-index 38c32f5b..f16578b4 100644
---- a/qutip/core/data/dense.pyx
-+++ b/qutip/core/data/dense.pyx
-@@ -1,409 +1,409 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.string cimport memcpy
--cimport cython
--
--import numbers
--
--import numpy as np
--cimport numpy as cnp
--from scipy.linalg cimport cython_blas as blas
--
--from .base import EfficiencyWarning
--from qutip.core.data cimport base, CSR
--from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
--from qutip.core.data.trace cimport trace_dense
--
--cnp.import_array()
--
--cdef int _ONE = 1
--
--cdef extern from *:
--    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
--    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
--    void *PyDataMem_NEW(size_t size)
--    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
--    void PyDataMem_FREE(void *ptr)
--
--
--# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
--# to avoid naming clashes with other type modules.
--__all__ = [
--    'Dense', 'OrderEfficiencyWarning',
--]
--
--
--class OrderEfficiencyWarning(EfficiencyWarning):
--    pass
--
--
--cdef class Dense(base.Data):
--    def __init__(self, data, shape=None, copy=True):
--        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
--        # Ensure that the array is contiguous.
--        # Non contiguous array with copy=False would otherwise slip through
--        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
--                cnp.PyArray_IS_F_CONTIGUOUS(base)):
--            base = base.copy()
--        if shape is None:
--            shape = base.shape
--            if len(shape) == 0:
--                shape = (1, 1)
--            # Promote to a ket by default if passed 1D data.
--            if len(shape) == 1:
--                shape = (shape[0], 1)
--        if not (
--            len(shape) == 2
--            and isinstance(shape[0], numbers.Integral)
--            and isinstance(shape[1], numbers.Integral)
--            and shape[0] > 0
--            and shape[1] > 0
--        ):
--            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
--        if shape[0] * shape[1] != base.size:
--            raise ValueError("".join([
--                "invalid shape ",
--                str(shape),
--                " for input data with size ",
--                str(base.size)
--            ]))
--        self._np = base.reshape(shape, order='A')
--        self._deallocate = False
--        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
--        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
--        self.shape = (shape[0], shape[1])
--
--    def __reduce__(self):
--        return (fast_from_numpy, (self.as_ndarray(),))
--
--    def __repr__(self):
--        return "".join([
--            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
--        ])
--
--    def __str__(self):
--        return self.__repr__()
--
--    cpdef Dense reorder(self, int fortran=-1):
--        cdef bint fortran_
--        if fortran < 0:
--            fortran_ = not self.fortran
--        else:
--            fortran_ = fortran
--        if bool(fortran_) == bool(self.fortran):
--            return self.copy()
--        cdef Dense out = empty_like(self, fortran_)
--        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
--        stride = self.shape[1] if self.fortran else self.shape[0]
--        splits = self.shape[0] if self.fortran else self.shape[1]
--        for idx_out_start in range(stride):
--            idx_out = idx_out_start
--            for _ in range(splits):
--                out.data[idx_out] = self.data[idx_self]
--                idx_self += 1
--                idx_out += stride
--        return out
--
--    cpdef Dense copy(self):
--        """
--        Return a complete (deep) copy of this object.
--
--        If the type currently has a numpy backing, such as that produced by
--        `as_ndarray`, this will not be copied.  The backing is a view onto our
--        data, and a straight copy of this view would be incorrect.  We do not
--        create a new view at copy time, since the user may only access this
--        through a creation method, and creating it ahead of time would incur an
--        unnecessary speed penalty for users who do not need it (including
--        low-level C code).
--        """
--        cdef Dense out = Dense.__new__(Dense)
--        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
--        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
--        memcpy(ptr, self.data, size)
--        out.shape = self.shape
--        out.data = ptr
--        out.fortran = self.fortran
--        out._deallocate = True
--        return out
--
--    cdef void _fix_flags(self, object array, bint make_owner=False):
--        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
--        cdef int disable = 0
--        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
--        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
--        # Not necessary when creating a new array because this will already
--        # have been done, but needed for as_ndarray() if we have been mutated.
--        dims[0] = self.shape[0]
--        dims[1] = self.shape[1]
--        if self.shape[0] == 1 or self.shape[1] == 1:
--            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
--            strides[0] = self.shape[1] * sizeof(double complex)
--            strides[1] = sizeof(double complex)
--        elif self.fortran:
--            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
--            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
--            strides[0] = sizeof(double complex)
--            strides[1] = self.shape[0] * sizeof(double complex)
--        else:
--            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
--            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
--            strides[0] = self.shape[1] * sizeof(double complex)
--            strides[1] = sizeof(double complex)
--        PyArray_ENABLEFLAGS(array, enable)
--        PyArray_CLEARFLAGS(array, disable)
--
--    cpdef object to_array(self):
--        """
--        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
--        be Fortran or C-ordered, but will be contiguous in one of the
--        dimensions.  This is not a view onto the data, and changes to new array
--        will not affect the original data structure.
--        """
--        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
--        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
--        memcpy(ptr, self.data, size)
--        cdef object out =\
--            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
--                                          cnp.NPY_COMPLEX128, ptr)
--        self._fix_flags(out, make_owner=True)
--        return out
--
--    cpdef object as_ndarray(self):
--        """
--        Get a view onto this object as a `numpy.ndarray`.  The underlying data
--        structure is exposed, such that modifications to the array will modify
--        this object too.
--
--        The array may be uninitialised, depending on how the Dense type was
--        created.  The output will be contiguous and of dtype 'complex128', but
--        may be C- or Fortran-ordered.
--        """
--        if self._np is not None:
--            # We have to do this every time in case someone has changed our
--            # ordering or shape inplace.
--            self._fix_flags(self._np, make_owner=False)
--            return self._np
--        self._np =\
--            cnp.PyArray_SimpleNewFromData(
--                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
--            )
--        self._fix_flags(self._np, make_owner=self._deallocate)
--        self._deallocate = False
--        return self._np
--
--    cpdef double complex trace(self):
--        return trace_dense(self)
--
--    cpdef Dense adjoint(self):
--        return adjoint_dense(self)
--
--    cpdef Dense conj(self):
--        return conj_dense(self)
--
--    cpdef Dense transpose(self):
--        return transpose_dense(self)
--
--    def __dealloc__(self):
--        if self._deallocate and self.data != NULL:
--            PyDataMem_FREE(self.data)
--
--
--cpdef Dense fast_from_numpy(object array):
--    """
--    Fast path construction from numpy ndarray.  This does _no_ type checking on
--    the input, and should consequently be considered very unsafe.  This is
--    primarily for use in the unpickling operation.
--    """
--    cdef Dense out = Dense.__new__(Dense)
--    if array.ndim == 1:
--        out.shape = (array.shape[0], 1)
--        array = array[:, None]
--    else:
--        out.shape = (array.shape[0], array.shape[1])
--    out._deallocate = False
--    out._np = array
--    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
--    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
--    return out
--
--cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
--    cdef Dense out = Dense.__new__(Dense)
--    out.data = data
--    out._deallocate = False
--    out.fortran = fortran or cols == 1 or rows == 1
--    out.shape = (rows, cols)
--    return out
--
--
--cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
--    """
--    Return a new Dense type of the given shape, with the data allocated but
--    uninitialised.
--    """
--    cdef Dense out = Dense.__new__(Dense)
--    out.shape = (rows, cols)
--    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
--    out._deallocate = True
--    out.fortran = fortran
--    return out
--
--
--cpdef Dense empty_like(Dense other, int fortran=-1):
--    cdef bint fortran_
--    if fortran < 0:
--        fortran_ = other.fortran
--    else:
--        fortran_ = fortran
--    return empty(other.shape[0], other.shape[1], fortran=fortran_)
--
--
--cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
--    """Return the zero matrix with the given shape."""
--    cdef Dense out = Dense.__new__(Dense)
--    out.shape = (rows, cols)
--    out.data =\
--        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
--    out.fortran = fortran
--    out._deallocate = True
--    return out
--
--
--cpdef Dense identity(base.idxint dimension, double complex scale=1,
--                     bint fortran=True):
--    """
--    Return a square matrix of the specified dimension, with a constant along
--    the diagonal.  By default this will be the identity matrix, but if `scale`
--    is passed, then the result will be `scale` times the identity.
--    """
--    cdef size_t row
--    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
--    for row in range(dimension):
--        out.data[row*dimension + row] = scale
--    return out
--
--
--cpdef Dense from_csr(CSR matrix, bint fortran=False):
--    cdef Dense out = Dense.__new__(Dense)
--    out.shape = matrix.shape
--    out.data = (
--        <double complex *>
--        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
--    )
--    out.fortran = fortran
--    out._deallocate = True
--    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
--    row_stride = 1 if fortran else out.shape[1]
--    col_stride = out.shape[0] if fortran else 1
--    ptr_out = 0
--    for row in range(out.shape[0]):
--        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
--            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
--        ptr_out += row_stride
--    return out
--
--
--cdef inline base.idxint _diagonal_length(
--    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
--) nogil:
--    if offset > 0:
--        return n_rows if offset <= n_cols - n_rows else n_cols - offset
--    return n_cols if offset > n_cols - n_rows else n_rows + offset
--
--
--@cython.wraparound(True)
--def diags(diagonals, offsets=None, shape=None):
--    """
--    Construct a matrix from diagonals and their offsets.  Using this
--    function in single-argument form produces a square matrix with the given
--    values on the main diagonal.
--    With lists of diagonals and offsets, the matrix will be the smallest
--    possible square matrix if shape is not given, but in all cases the
--    diagonals must fit exactly with no extra or missing elements. Duplicated
--    diagonals will be summed together in the output.
--
--    Parameters
--    ----------
--    diagonals : sequence of array_like of complex or array_like of complex
--        The entries (including zeros) that should be placed on the diagonals in
--        the output matrix.  Each entry must have enough entries in it to fill
--        the relevant diagonal and no more.
--    offsets : sequence of integer or integer, optional
--        The indices of the diagonals.  `offsets[i]` is the location of the
--        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
--        values are above the main diagonal and negative ones are below the main
--        diagonal.
--    shape : tuple, optional
--        The shape of the output as (``rows``, ``columns``).  The result does
--        not need to be square, but the diagonals must be of the correct length
--        to fit in exactly.
--    """
--    cdef base.idxint n_rows, n_cols, offset
--    try:
--        diagonals = list(diagonals)
--        if diagonals and np.isscalar(diagonals[0]):
--            # Catch the case where we're being called as (for example)
--            #   diags([1, 2, 3], 0)
--            # with a single diagonal and offset.
--            diagonals = [diagonals]
--    except TypeError:
--        raise TypeError("diagonals must be a list of arrays of complex") from None
--    if offsets is None:
--        if len(diagonals) == 0:
--            offsets = []
--        elif len(diagonals) == 1:
--            offsets = [0]
--        else:
--            raise TypeError("offsets must be supplied if passing more than one diagonal")
--    offsets = np.atleast_1d(offsets)
--    if offsets.ndim > 1:
--        raise ValueError("offsets must be a 1D array of integers")
--    if len(diagonals) != len(offsets):
--        raise ValueError("number of diagonals does not match number of offsets")
--    if len(diagonals) == 0:
--        if shape is None:
--            raise ValueError("cannot construct matrix with no diagonals without a shape")
--        else:
--            n_rows, n_cols = shape
--        return zeros(n_rows, n_cols)
--    order = np.argsort(offsets)
--    diagonals_ = []
--    offsets_ = []
--    prev, cur = None, None
--    for i in order:
--        cur = offsets[i]
--        if cur == prev:
--            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
--        else:
--            offsets_.append(cur)
--            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
--        prev = cur
--    if shape is None:
--        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
--    else:
--        try:
--            n_rows, n_cols = shape
--        except (TypeError, ValueError):
--            raise TypeError("shape must be a 2-tuple of positive integers")
--        if n_rows < 0 or n_cols < 0:
--            raise ValueError("shape must be a 2-tuple of positive integers")
--    for i in range(len(diagonals_)):
--        offset = offsets_[i]
--        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
--            raise ValueError("given diagonals do not have the correct lengths")
--    if n_rows == 0 and n_cols == 0:
--        raise ValueError("can't produce a 0x0 matrix")
--
--    out = zeros(n_rows, n_cols, fortran=True)
--
--    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
--
--    for diag_idx in range(n_diagonals):
--        offset = offsets_[diag_idx]
--        if offset <= 0:
--            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
--                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
--        else:
--            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
--                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
--    return out
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.string cimport memcpy
-+cimport cython
-+
-+import numbers
-+
-+import numpy as np
-+cimport numpy as cnp
-+from scipy.linalg cimport cython_blas as blas
-+
-+from .base import EfficiencyWarning
-+from qutip.core.data cimport base, CSR
-+from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
-+from qutip.core.data.trace cimport trace_dense
-+
-+cnp.import_array()
-+
-+cdef int _ONE = 1
-+
-+cdef extern from *:
-+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-+    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
-+    void *PyDataMem_NEW(size_t size)
-+    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-+    void PyDataMem_FREE(void *ptr)
-+
-+
-+# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
-+# to avoid naming clashes with other type modules.
-+__all__ = [
-+    'Dense', 'OrderEfficiencyWarning',
-+]
-+
-+
-+class OrderEfficiencyWarning(EfficiencyWarning):
-+    pass
-+
-+
-+cdef class Dense(base.Data):
-+    def __init__(self, data, shape=None, copy=True):
-+        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
-+        # Ensure that the array is contiguous.
-+        # Non contiguous array with copy=False would otherwise slip through
-+        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
-+                cnp.PyArray_IS_F_CONTIGUOUS(base)):
-+            base = base.copy()
-+        if shape is None:
-+            shape = base.shape
-+            if len(shape) == 0:
-+                shape = (1, 1)
-+            # Promote to a ket by default if passed 1D data.
-+            if len(shape) == 1:
-+                shape = (shape[0], 1)
-+        if not (
-+            len(shape) == 2
-+            and isinstance(shape[0], numbers.Integral)
-+            and isinstance(shape[1], numbers.Integral)
-+            and shape[0] > 0
-+            and shape[1] > 0
-+        ):
-+            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
-+        if shape[0] * shape[1] != base.size:
-+            raise ValueError("".join([
-+                "invalid shape ",
-+                str(shape),
-+                " for input data with size ",
-+                str(base.size)
-+            ]))
-+        self._np = base.reshape(shape, order='A')
-+        self._deallocate = False
-+        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
-+        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
-+        self.shape = (shape[0], shape[1])
-+
-+    def __reduce__(self):
-+        return (fast_from_numpy, (self.as_ndarray(),))
-+
-+    def __repr__(self):
-+        return "".join([
-+            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
-+        ])
-+
-+    def __str__(self):
-+        return self.__repr__()
-+
-+    cpdef Dense reorder(self, int fortran=-1):
-+        cdef bint fortran_
-+        if fortran < 0:
-+            fortran_ = not self.fortran
-+        else:
-+            fortran_ = fortran
-+        if bool(fortran_) == bool(self.fortran):
-+            return self.copy()
-+        cdef Dense out = empty_like(self, fortran_)
-+        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
-+        stride = self.shape[1] if self.fortran else self.shape[0]
-+        splits = self.shape[0] if self.fortran else self.shape[1]
-+        for idx_out_start in range(stride):
-+            idx_out = idx_out_start
-+            for _ in range(splits):
-+                out.data[idx_out] = self.data[idx_self]
-+                idx_self += 1
-+                idx_out += stride
-+        return out
-+
-+    cpdef Dense copy(self):
-+        """
-+        Return a complete (deep) copy of this object.
-+
-+        If the type currently has a numpy backing, such as that produced by
-+        `as_ndarray`, this will not be copied.  The backing is a view onto our
-+        data, and a straight copy of this view would be incorrect.  We do not
-+        create a new view at copy time, since the user may only access this
-+        through a creation method, and creating it ahead of time would incur an
-+        unnecessary speed penalty for users who do not need it (including
-+        low-level C code).
-+        """
-+        cdef Dense out = Dense.__new__(Dense)
-+        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
-+        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
-+        memcpy(ptr, self.data, size)
-+        out.shape = self.shape
-+        out.data = ptr
-+        out.fortran = self.fortran
-+        out._deallocate = True
-+        return out
-+
-+    cdef void _fix_flags(self, object array, bint make_owner=False):
-+        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
-+        cdef int disable = 0
-+        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
-+        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
-+        # Not necessary when creating a new array because this will already
-+        # have been done, but needed for as_ndarray() if we have been mutated.
-+        dims[0] = self.shape[0]
-+        dims[1] = self.shape[1]
-+        if self.shape[0] == 1 or self.shape[1] == 1:
-+            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
-+            strides[0] = self.shape[1] * sizeof(double complex)
-+            strides[1] = sizeof(double complex)
-+        elif self.fortran:
-+            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
-+            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
-+            strides[0] = sizeof(double complex)
-+            strides[1] = self.shape[0] * sizeof(double complex)
-+        else:
-+            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
-+            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
-+            strides[0] = self.shape[1] * sizeof(double complex)
-+            strides[1] = sizeof(double complex)
-+        PyArray_ENABLEFLAGS(array, enable)
-+        PyArray_CLEARFLAGS(array, disable)
-+
-+    cpdef object to_array(self):
-+        """
-+        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
-+        be Fortran or C-ordered, but will be contiguous in one of the
-+        dimensions.  This is not a view onto the data, and changes to new array
-+        will not affect the original data structure.
-+        """
-+        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
-+        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
-+        memcpy(ptr, self.data, size)
-+        cdef object out =\
-+            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
-+                                          cnp.NPY_COMPLEX128, ptr)
-+        self._fix_flags(out, make_owner=True)
-+        return out
-+
-+    cpdef object as_ndarray(self):
-+        """
-+        Get a view onto this object as a `numpy.ndarray`.  The underlying data
-+        structure is exposed, such that modifications to the array will modify
-+        this object too.
-+
-+        The array may be uninitialised, depending on how the Dense type was
-+        created.  The output will be contiguous and of dtype 'complex128', but
-+        may be C- or Fortran-ordered.
-+        """
-+        if self._np is not None:
-+            # We have to do this every time in case someone has changed our
-+            # ordering or shape inplace.
-+            self._fix_flags(self._np, make_owner=False)
-+            return self._np
-+        self._np =\
-+            cnp.PyArray_SimpleNewFromData(
-+                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
-+            )
-+        self._fix_flags(self._np, make_owner=self._deallocate)
-+        self._deallocate = False
-+        return self._np
-+
-+    cpdef double complex trace(self):
-+        return trace_dense(self)
-+
-+    cpdef Dense adjoint(self):
-+        return adjoint_dense(self)
-+
-+    cpdef Dense conj(self):
-+        return conj_dense(self)
-+
-+    cpdef Dense transpose(self):
-+        return transpose_dense(self)
-+
-+    def __dealloc__(self):
-+        if self._deallocate and self.data != NULL:
-+            PyDataMem_FREE(self.data)
-+
-+
-+cpdef Dense fast_from_numpy(object array):
-+    """
-+    Fast path construction from numpy ndarray.  This does _no_ type checking on
-+    the input, and should consequently be considered very unsafe.  This is
-+    primarily for use in the unpickling operation.
-+    """
-+    cdef Dense out = Dense.__new__(Dense)
-+    if array.ndim == 1:
-+        out.shape = (array.shape[0], 1)
-+        array = array[:, None]
-+    else:
-+        out.shape = (array.shape[0], array.shape[1])
-+    out._deallocate = False
-+    out._np = array
-+    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
-+    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
-+    return out
-+
-+cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
-+    cdef Dense out = Dense.__new__(Dense)
-+    out.data = data
-+    out._deallocate = False
-+    out.fortran = fortran or cols == 1 or rows == 1
-+    out.shape = (rows, cols)
-+    return out
-+
-+
-+cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
-+    """
-+    Return a new Dense type of the given shape, with the data allocated but
-+    uninitialised.
-+    """
-+    cdef Dense out = Dense.__new__(Dense)
-+    out.shape = (rows, cols)
-+    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
-+    out._deallocate = True
-+    out.fortran = fortran
-+    return out
-+
-+
-+cpdef Dense empty_like(Dense other, int fortran=-1):
-+    cdef bint fortran_
-+    if fortran < 0:
-+        fortran_ = other.fortran
-+    else:
-+        fortran_ = fortran
-+    return empty(other.shape[0], other.shape[1], fortran=fortran_)
-+
-+
-+cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
-+    """Return the zero matrix with the given shape."""
-+    cdef Dense out = Dense.__new__(Dense)
-+    out.shape = (rows, cols)
-+    out.data =\
-+        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
-+    out.fortran = fortran
-+    out._deallocate = True
-+    return out
-+
-+
-+cpdef Dense identity(base.idxint dimension, double complex scale=1,
-+                     bint fortran=True):
-+    """
-+    Return a square matrix of the specified dimension, with a constant along
-+    the diagonal.  By default this will be the identity matrix, but if `scale`
-+    is passed, then the result will be `scale` times the identity.
-+    """
-+    cdef size_t row
-+    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
-+    for row in range(dimension):
-+        out.data[row*dimension + row] = scale
-+    return out
-+
-+
-+cpdef Dense from_csr(CSR matrix, bint fortran=False):
-+    cdef Dense out = Dense.__new__(Dense)
-+    out.shape = matrix.shape
-+    out.data = (
-+        <double complex *>
-+        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
-+    )
-+    out.fortran = fortran
-+    out._deallocate = True
-+    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
-+    row_stride = 1 if fortran else out.shape[1]
-+    col_stride = out.shape[0] if fortran else 1
-+    ptr_out = 0
-+    for row in range(out.shape[0]):
-+        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
-+        ptr_out += row_stride
-+    return out
-+
-+
-+cdef inline base.idxint _diagonal_length(
-+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-+) nogil:
-+    if offset > 0:
-+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-+    return n_cols if offset > n_cols - n_rows else n_rows + offset
-+
-+
-+@cython.wraparound(True)
-+def diags(diagonals, offsets=None, shape=None):
-+    """
-+    Construct a matrix from diagonals and their offsets.  Using this
-+    function in single-argument form produces a square matrix with the given
-+    values on the main diagonal.
-+    With lists of diagonals and offsets, the matrix will be the smallest
-+    possible square matrix if shape is not given, but in all cases the
-+    diagonals must fit exactly with no extra or missing elements. Duplicated
-+    diagonals will be summed together in the output.
-+
-+    Parameters
-+    ----------
-+    diagonals : sequence of array_like of complex or array_like of complex
-+        The entries (including zeros) that should be placed on the diagonals in
-+        the output matrix.  Each entry must have enough entries in it to fill
-+        the relevant diagonal and no more.
-+    offsets : sequence of integer or integer, optional
-+        The indices of the diagonals.  `offsets[i]` is the location of the
-+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-+        values are above the main diagonal and negative ones are below the main
-+        diagonal.
-+    shape : tuple, optional
-+        The shape of the output as (``rows``, ``columns``).  The result does
-+        not need to be square, but the diagonals must be of the correct length
-+        to fit in exactly.
-+    """
-+    cdef base.idxint n_rows, n_cols, offset
-+    try:
-+        diagonals = list(diagonals)
-+        if diagonals and np.isscalar(diagonals[0]):
-+            # Catch the case where we're being called as (for example)
-+            #   diags([1, 2, 3], 0)
-+            # with a single diagonal and offset.
-+            diagonals = [diagonals]
-+    except TypeError:
-+        raise TypeError("diagonals must be a list of arrays of complex") from None
-+    if offsets is None:
-+        if len(diagonals) == 0:
-+            offsets = []
-+        elif len(diagonals) == 1:
-+            offsets = [0]
-+        else:
-+            raise TypeError("offsets must be supplied if passing more than one diagonal")
-+    offsets = np.atleast_1d(offsets)
-+    if offsets.ndim > 1:
-+        raise ValueError("offsets must be a 1D array of integers")
-+    if len(diagonals) != len(offsets):
-+        raise ValueError("number of diagonals does not match number of offsets")
-+    if len(diagonals) == 0:
-+        if shape is None:
-+            raise ValueError("cannot construct matrix with no diagonals without a shape")
-+        else:
-+            n_rows, n_cols = shape
-+        return zeros(n_rows, n_cols)
-+    order = np.argsort(offsets)
-+    diagonals_ = []
-+    offsets_ = []
-+    prev, cur = None, None
-+    for i in order:
-+        cur = offsets[i]
-+        if cur == prev:
-+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-+        else:
-+            offsets_.append(cur)
-+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-+        prev = cur
-+    if shape is None:
-+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-+    else:
-+        try:
-+            n_rows, n_cols = shape
-+        except (TypeError, ValueError):
-+            raise TypeError("shape must be a 2-tuple of positive integers")
-+        if n_rows < 0 or n_cols < 0:
-+            raise ValueError("shape must be a 2-tuple of positive integers")
-+    for i in range(len(diagonals_)):
-+        offset = offsets_[i]
-+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-+            raise ValueError("given diagonals do not have the correct lengths")
-+    if n_rows == 0 and n_cols == 0:
-+        raise ValueError("can't produce a 0x0 matrix")
-+
-+    out = zeros(n_rows, n_cols, fortran=True)
-+
-+    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
-+
-+    for diag_idx in range(n_diagonals):
-+        offset = offsets_[diag_idx]
-+        if offset <= 0:
-+            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
-+                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
-+        else:
-+            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
-+                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
-+    return out
-diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
-index e8abebd7..276477b4 100644
---- a/qutip/core/data/dispatch.pyx
-+++ b/qutip/core/data/dispatch.pyx
-@@ -1,583 +1,583 @@
--#cython: language_level=3
--
--import functools
--import inspect
--import itertools
--import warnings
--
--from .convert import to as _to
--
--cimport cython
--from libc cimport math
--from libcpp cimport bool
--
--__all__ = ['Dispatcher']
--
--cdef class _bind:
--    """
--    Cythonised implementation of inspect.Signature.bind, supporting faster
--    binding and handling of default arguments.  On construction, the signature
--    of the base function is extracted, and all parameters are parsed into
--    positional or keyword slots, using positional wherever possible, and their
--    defaults are stored.
--    """
--    # Instance of inpsect.Signature representing the function.
--    cdef object signature
--    cdef object inputs
--    # Mapping of (str: int), where str is the name of any argument which may be
--    # specified by a keyword, and int is its location in `self._pos` if
--    # available, or -1 if it is keyword-only.
--    cdef dict _locations
--    # Default values (or inspect.Parameter.empty) for every parameter which
--    # may be passed as a positional argument.
--    cdef list _pos
--    # For each dispatcher input which can be given as a positional argument,
--    # these two lists hold the index of the input in the given tuple of input
--    # names and the corresponding index into the positional arguments after
--    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
--    # effectively the same mapping as _kw_inputs (but for positional
--    # arguments), but we use two lists rather than a dictionary for speed.
--    cdef list _pos_inputs_input, _pos_inputs_pos
--    # Default values (or inspect.Parameter.empty) for every parameter which
--    # _must_ be passed as a keyword argument.
--    cdef dict _kw
--    # Mapping of (name, index into the input tuple) for each input which must
--    # be specified as a keyword argument
--    cdef list _kw_inputs
--    # Names of the keyword arguments which have default values.
--    cdef set _default_kw_names
--    # Respectively, numbers of positional parameters, keyword-only parameters
--    # and dispatcher inputs.
--    cdef Py_ssize_t n_args, n_kwargs, n_inputs
--    # Respectively, numbers of inputs which are positional and keyword-only.
--    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
--    # Respectively, numbers of positional arguments without a default, and
--    # number of keyword-only arguments which _have_ a default.
--    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
--
--
--    def __init__(self, signature, tuple inputs):
--        for arg in inputs:
--            if arg not in signature.parameters:
--                raise AttributeError("No argument matches '{}'.".format(arg))
--        self.signature = signature
--        self.inputs = inputs
--        self._locations = {}
--        self._pos = []
--        self._pos_inputs_input = []
--        self._pos_inputs_pos = []
--        self._kw = {}
--        self._kw_inputs = []
--        self._default_kw_names = set()
--        self._n_pos_no_default = 0
--        # signature.parameters is ordered for all Python versions.
--        for i, (name, parameter) in enumerate(signature.parameters.items()):
--            kind = parameter.kind
--            if (kind == parameter.VAR_POSITIONAL
--                    or kind == parameter.VAR_KEYWORD):
--                raise TypeError("Cannot dispatch with *args or **kwargs.")
--            if kind == parameter.KEYWORD_ONLY:
--                self._kw[name] = parameter.default
--                self._locations[name] = -1
--                if parameter.default is not parameter.empty:
--                    self._default_kw_names.add(name)
--                if name in inputs:
--                    self._kw_inputs.append((name, inputs.index(name)))
--            else:
--                self._pos.append(parameter.default)
--                if kind != parameter.POSITIONAL_ONLY:
--                    self._locations[name] = i
--                if parameter.default is parameter.empty:
--                    self._n_pos_no_default += 1
--                if name in inputs:
--                    # Effectively a mapping.
--                    self._pos_inputs_input.append(inputs.index(name))
--                    self._pos_inputs_pos.append(len(self._pos) - 1)
--        self.n_args = len(self._pos)
--        self.n_kwargs = len(self._kw)
--        self.n_inputs = len(inputs)
--        self._n_pos_inputs = len(self._pos_inputs_input)
--        self._n_kw_inputs = len(self._kw_inputs)
--        self._n_kw_default = len(self._default_kw_names)
--
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef tuple bind(self, tuple args, dict kwargs):
--        """
--        Cython reimplementation of inspect.Signature.bind for binding the
--        collected `*args` and `**kwargs` of a generic call to a specific
--        signature, checking that everything matches.
--
--        The output is a parsed tuple (args, kwargs), where `args` is a list and
--        `kwargs` is a dict, however all arguments which _can_ be passed
--        positionally will be moved from `kwargs` into `args` for the output.
--        The resultant `args` and `kwargs` can be unpacked into the underlying
--        function call safely.  Default values are not filled in by this method.
--
--        This is necessary to allow a generic `Dispatcher` class to work with
--        all type signatures.  The result of this function can be fed to
--        `_bind.convert_types` and `_bind.dispatch_types`.
--        """
--        cdef Py_ssize_t location, got_pos=0, got_kw=0
--        cdef Py_ssize_t n_passed_args = len(args)
--        if n_passed_args > self.n_args:
--            raise TypeError(
--                "Too many arguments: expected at most {} but received {}."
--                .format(n_passed_args, self.n_args)
--            )
--        # _pos and _kw are filled with their defaults at initialisation, and
--        # _pos is already the correct length (no-default parameters have
--        # sentinel values).
--        cdef list out_pos = self._pos.copy()
--        cdef dict out_kw = self._kw.copy()
--        got_pos = self.n_args - self._n_pos_no_default
--        got_kw = self._n_kw_default
--        # Positional arguments unambiguously fill the first positional slots.
--        for location in range(n_passed_args):
--            out_pos[location] = args[location]
--        # How many arguments that we didn't have defaults for did we just get?
--        # Positionals with a default are always after those without one.
--        if n_passed_args > self._n_pos_no_default:
--            got_pos += self._n_pos_no_default
--        else:
--            got_pos += n_passed_args
--        # Everything else has been passed by keyword, but it may be allowed to
--        # be passed positionally, which is the case we prefer.  dict.items() is
--        # (relatively) expensive, so we use a boolean test for the fast path.
--        cdef str kw
--        cdef object arg
--        if kwargs:
--            for kw, arg in kwargs.items():
--                try:
--                    location = self._locations[kw]
--                except KeyError:
--                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
--                # _locations[kw] = -1 if kw is keyword-only, otherwise the
--                # corresponding positional location.
--                if location >= 0:
--                    if location < n_passed_args:
--                        raise TypeError("Multiple values for '{}'".format(kw))
--                    out_pos[location] = arg
--                    if location < self._n_pos_no_default:
--                        got_pos += 1
--                else:
--                    out_kw[kw] = arg
--                    if kw not in self._default_kw_names:
--                        got_kw += 1
--        if got_pos < self.n_args:
--            raise TypeError("Too few positional arguments passed.")
--        if got_kw < self.n_kwargs:
--            raise TypeError("Not all keyword arguments were filled.")
--        return out_pos, out_kw
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef list dispatch_types(self, list args, dict kwargs):
--        """
--        Get a list of the types which the dispatch should operate over, given
--        the output of `_bind.bind`.  The return value is a list of the _input_
--        types to be dispatched on, in order that they were specified at
--        `Dispatcher` creation.  The output type is not returned as part of this
--        list, because there is no way for `_bind` to know it.
--        """
--        cdef list dispatch = [None] * self.n_inputs
--        cdef str kw
--        cdef Py_ssize_t location, i
--        for location in range(self._n_pos_inputs):
--            dispatch[self._pos_inputs_input[location]]\
--                = type(args[self._pos_inputs_pos[location]])
--        for i in range(self._n_kw_inputs):
--            kw, location = self._kw_inputs[i]
--            dispatch[location] = type(kwargs[kw])
--        return dispatch
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
--        """
--        Apply the type converters `converters` to the parsed arguments `args`
--        and `kwargs`.
--
--        If there are `n` inputs which are dispatched on, `converters` should be
--        a tuple whose first `n` elements are converters (such as those obtained
--        from `data.to[to_type, from_type]`) to the desired types.
--
--        `args` and `kwargs` should be the output of `_bind.bind`; the function
--        will likely fail if called on unparsed arguments.
--        """
--        cdef str kw
--        cdef Py_ssize_t location, i
--        for location in range(self._n_pos_inputs):
--            args[location] = converters[location](args[location])
--        for i in range(self._n_kw_inputs):
--            kw, location = self._kw_inputs[i]
--            kwargs[kw] = converters[location](kwargs[kw])
--        return args, kwargs
--
--
--cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
--    """
--    Find the total weight of conversion if the types in `froms` are converted
--    element-wise to the types in `tos`.  `weight_map` is a mapping of
--    `(to_type, from_type): real`; it should almost certainly be
--    `data.to.weight`.
--    """
--    cdef double weight = 0.0
--    cdef Py_ssize_t i, n=len(froms)
--    if len(tos) != n:
--        raise ValueError(
--            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
--        )
--    if out:
--        n = n - 1
--        weight += weight_map[froms[n], tos[n]]
--    for i in range(n):
--        weight += weight_map[tos[i], froms[i]]
--    return weight
--
--
--cdef class _constructed_specialisation:
--    """
--    Callable object providing the specialisation of a data-layer operation for
--    a particular set of types (`self.types`).  This may or may not involve
--    conversion of the input types and the output to match a known
--    specialisation; if it has no conversions, `self.direct` will be `True`,
--    otherwise it will be `False`.
--
--    See `self.__signature__` or `self.__text_signature__` for the call
--    signature of this object.
--    """
--    cdef _bind _parameters
--    cdef bint _output
--    cdef object _call
--    cdef Py_ssize_t _n_dispatch
--    cdef readonly tuple types
--    cdef tuple _converters
--    cdef str _short_name
--    cdef public str __doc__
--    cdef public str __name__
--    cdef public str __module__
--    cdef public object __signature__
--    cdef readonly str __text_signature__
--    cdef readonly bint direct
--
--    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
--                 direct):
--        self.__doc__ = inspect.getdoc(dispatcher)
--        self._short_name = dispatcher.__name__
--        self.__name__ = (
--            self._short_name
--            + "_"
--            + "_".join([x.__name__ for x in types])
--        )
--        self.__module__ = dispatcher.__module__
--        self.__signature__ = dispatcher.__signature__
--        self.__text_signature__ = dispatcher.__text_signature__
--        self._parameters = dispatcher._parameters
--        self._output = out
--        self._call = base
--        self._n_dispatch = len(types)
--        self.types = types
--        self.direct = direct
--        self._converters = converters
--
--    cdef object prebound(self, list args, dict kwargs):
--        """
--        Call this specialisation with pre-parsed arguments and keyword
--        arguments.  `args` and `kwargs` must be the output of the relevant
--        `_bind.bind` method for this function.
--        """
--        self._parameters.convert_types(args, kwargs, self._converters)
--        out = self._call(*args, **kwargs)
--        if self._output:
--            out = self._converters[self._n_dispatch - 1](out)
--        return out
--
--    def __call__(self, *args, **kwargs):
--        cdef list args_
--        cdef dict kwargs_
--        args_, kwargs_ = self._parameters.bind(args, kwargs)
--        return self.prebound(args_, kwargs_)
--
--    def __repr__(self):
--        if len(self.types) == 1:
--            spec = self.types[0].__name__
--        else:
--            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
--        direct = ("" if self.direct else "in") + "direct"
--        return "".join([
--            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
--        ])
--
--
--cdef class Dispatcher:
--    """
--    Dispatcher for a data-layer operation.  This object can be called with the
--    signature shown in `self.__signature__` or `self.__text_signature__`, where
--    the arguments listed in `self.inputs` can be any data-layer types (i.e.
--    ones that have valid conversions in `data.to`).
--
--    You can define additional specialisations for this dispatcher by calling
--    its `add_specialisations` method.  New data types must be added to
--    `data.to` before they can be added as specialisations to a dispatcher.
--
--    You can get a callable object representing a single set of dispatcher types
--    by using the key-lookup syntax
--        Dispatcher[type1, type2, ...]
--    where `type1`, `type2`, etc are the dispatched arguments (with the output
--    type on the end, if this is a dispatcher over the output type.
--    """
--    cdef _bind _parameters
--    cdef readonly dict _specialisations
--    cdef Py_ssize_t _n_dispatch
--    cdef readonly dict _lookup
--    cdef set _dtypes
--    cdef bint _pass_on_dtype
--    cdef readonly tuple inputs
--    cdef readonly bint output
--    cdef public str __doc__
--    cdef public str __name__
--    cdef public str __module__
--    cdef public object __signature__
--    cdef readonly str __text_signature__
--
--    def __init__(self, signature_source, inputs, bint out=False,
--                 str name=None, str module=None):
--        """
--        Create a new data layer dispatching operator.
--
--        Parameters
--        ----------
--        signature_source : callable or inspect.Signature
--            An object from which the call signature of operation can be
--            determined.  You can pass any callable defined in Python space, and
--            the signature will be extracted.  Note that the callable will not
--            be added as a specialisation by this; you will still have to call
--            `add_specialisations`.
--
--            If you cannot provide a callable with an extractable signature
--            (e.g. Cython extension methods), you can instead directly provide
--            an instance of `inspect.Signature`, which will be used instead.
--
--        inputs : iterable of str
--            The parameters which should be dispatched over.  These can be
--            positional or keyword arguments, but must feature in the signature
--            provided.
--
--        out : bool, optional (False)
--            Whether to dispatch on the output of the function.  Defaults to
--            `False`.
--
--        name : str, optional
--            If given, the `__name__` parameter of the dispatcher is set to
--            this.  If not given and `signature_source` is _not_ an instance of
--            `inspect.Signature`, then we will attempt to read `__name__` from
--            there instead.
--
--        module : str, optional
--            If given, the `__module__` parameter of the dispatcher is set to
--            this.  If not given and `signature_source` is _not_ an instance of
--            `inspect.Signature`, then we will attempt to read `__module__` from
--            there instead.
--        """
--        if isinstance(inputs, str):
--            inputs = (inputs,)
--        inputs = tuple(inputs)
--        if inputs == () and out is False:
--            warnings.warn(
--                "No parameters to dispatch on."
--                " Maybe you meant to specify 'inputs' or 'out'?"
--            )
--        self.inputs = inputs
--        if isinstance(signature_source, inspect.Signature):
--            self.__signature__ = signature_source
--        else:
--            self.__signature__ = inspect.signature(signature_source)
--        self._parameters = _bind(self.__signature__, inputs)
--        if name is not None:
--            self.__name__ = name
--        elif not isinstance(signature_source, inspect.Signature):
--            self.__name__ = signature_source.__name__
--        else:
--            self.__name__ = 'dispatcher'
--        if module is not None:
--            self.__module__ = module
--        elif not isinstance(signature_source, inspect.Signature):
--            self.__module__ = signature_source.__module__
--        self.__text_signature__ = self.__name__ + str(self.__signature__)
--        if not isinstance(signature_source, inspect.Signature):
--            self.__doc__ = inspect.getdoc(signature_source)
--        self.output = out
--        self._specialisations = {}
--        self._lookup = {}
--        self._n_dispatch = self._parameters.n_inputs + self.output
--        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
--        # Add ourselves to the list of dispatchers to be updated.
--        _to.dispatchers.append(self)
--
--    def add_specialisations(self, specialisations, _defer=False):
--        """
--        Add specialisations for particular combinations of data types to this
--        operation.  The data types must already be known in `data.to` before
--        you try to provide them here.  All data types defined in `data.to` will
--        automatically work with this dispatcher, but will involve inefficient
--        conversions to and from other types unless you define a closer
--        specialisation using this method.
--
--        The lookup table will automatically be rebuilt after this method is
--        called.  Specialisations defined more than once will use the most
--        recent version; you can use this to override currently known
--        specialisations if desired.
--
--        Parameters
--        ----------
--        specialisations : iterable of tuples
--            An iterable where each element specifies a new specialisation for
--            this operation.  Each element of the iterable should be a tuple,
--            whose items are the types (instances of `type`) which this
--            specialisation takes in each of the slots defined by
--            `Dispatcher.inputs`, and the output type if this is a dispatcher
--            over output types.  The last element should be the callable itself.
--
--            The callable must have exactly the same signature as
--            `Dispatcher.__signature__`; it is not enough that it takes all the
--            same keyword arguments, but they must come in the same order as
--            well (this is a speed optimisation for the dispatching operation).
--
--            For example, if this is a dispatcher with the signature
--                add(left, right, scale=1)
--            which also dispatches over its output, and we have specialisations
--                add_1(left: CSR, right: Dense, scale=1) -> Dense
--                add_2(left: Dense, right: CSC, scale=1) -> CSR
--            then to add this, `specialisations` should look like
--                [
--                    (CSR, Dense, Dense, add_1),
--                    (Dense, CSC, CSR, add_2),
--                ]
--            Type annotations present in the specialisation objects are ignored.
--
--        _defer : bool, optional (False)
--            Only intended for internal library use during initialisation. If
--            `True`, then the input types are not checked, and the full lookup
--            table is not built until a manual call to
--            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
--            remember that you should add the data type conversions to `data.to`
--            before you try to add specialisations.
--        """
--        for arg in specialisations:
--            arg = tuple(arg)
--            if len(arg) != self._n_dispatch + 1:
--                raise ValueError(
--                    "specialisation " + str(arg)
--                    + " has wrong number of parameters: needed types for "
--                    + str(self._parameters.inputs)
--                    + (", an output type" if self.output else "")
--                    + " and a callable"
--                )
--            for i in range(self._n_dispatch):
--                if (not _defer) and arg[i] not in _to.dtypes:
--                    raise ValueError(str(arg[i]) + " is not a known data type")
--            if not callable(arg[self._n_dispatch]):
--                raise TypeError(str(arg[-1]) + " is not callable")
--            self._specialisations[arg[:-1]] = arg[-1]
--        if not _defer:
--            self.rebuild_lookup()
--
--    def rebuild_lookup(self):
--        """
--        Manually trigger a rebuild of the lookup table for this dispatcher.
--        This is called automatically when new data types are added to
--        `data.to`, or when specialisations are added to this object with
--        `Dispatcher.add_specialisations`.
--
--        You most likely do not need to call this function yourself.
--        """
--        cdef double weight, cur
--        cdef tuple types, out_types
--        cdef object function
--        if not self._specialisations:
--            return
--        self._dtypes = _to.dtypes.copy()
--        # The complexity of building the table here is very poor, but it's a
--        # cost we pay very infrequently, and until it's proved to be a
--        # bottle-neck in real code, we stick with the simple algorithm.
--        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
--            weight = math.INFINITY
--            types = None
--            function = None
--            for out_types, out_function in self._specialisations.items():
--                cur = _conversion_weight(in_types, out_types, _to.weight,
--                                         out=self.output)
--                if cur < weight:
--                    weight = cur
--                    types = out_types
--                    function = out_function
--            if self.output:
--                converters = tuple(
--                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
--                    + [_to[in_types[-1], types[-1]]]
--                )
--            else:
--                converters = tuple(_to[pair] for pair in zip(types, in_types))
--            self._lookup[in_types] =\
--                _constructed_specialisation(function, self, in_types,
--                                            converters, self.output,
--                                            weight == 0)
--        # Now build the lookup table in the case that we dispatch on the output
--        # type as well, but the user has called us without specifying it.
--        # TODO: option to control default output type choice if unspecified?
--        if self.output:
--            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
--                weight = math.INFINITY
--                types = None
--                function = None
--                for out_types, out_function in self._specialisations.items():
--                    cur = _conversion_weight(in_types, out_types[:-1],
--                                             _to.weight, out=False)
--                    if cur < weight:
--                        weight = cur
--                        types = out_types
--                        function = out_function
--                converters = tuple(_to[pair] for pair in zip(types, in_types))
--                self._lookup[in_types] =\
--                    _constructed_specialisation(function, self,
--                                                in_types + (types[-1],),
--                                                converters, False,
--                                                weight == 0)
--
--    def __getitem__(self, types):
--        """
--        Get the particular specialisation for the given types.  The output is a
--        callable object which requires that the dispatched arguments match
--        those specified in `types`.
--        """
--        if type(types) is not tuple:
--            types = (types,)
--        types = tuple(_to.parse(arg) for arg in types)
--        try:
--            return self._lookup[types]
--        except KeyError:
--            raise TypeError("specialisation not known for types: " + str(types)) from None
--
--    def __repr__(self):
--        return "<dispatcher: " + self.__text_signature__ + ">"
--
--    def __call__(self, *args, dtype=None, **kwargs):
--        cdef list args_, dispatch
--        cdef dict kwargs_
--        if self._pass_on_dtype:
--            kwargs['dtype'] = dtype
--        if not (self._pass_on_dtype or self.output) and dtype is not None:
--            raise TypeError("unknown argument 'dtype'")
--        args_, kwargs_ = self._parameters.bind(args, kwargs)
--        dispatch = self._parameters.dispatch_types(args_, kwargs_)
--        if self.output and dtype is not None:
--            dtype = _to.parse(dtype)
--            dispatch.append(dtype)
--        cdef _constructed_specialisation function
--        try:
--            function = self._lookup[tuple(dispatch)]
--        except KeyError:
--            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
--        return function.prebound(args_, kwargs_)
-+#cython: language_level=3
-+
-+import functools
-+import inspect
-+import itertools
-+import warnings
-+
-+from .convert import to as _to
-+
-+cimport cython
-+from libc cimport math
-+from libcpp cimport bool
-+
-+__all__ = ['Dispatcher']
-+
-+cdef class _bind:
-+    """
-+    Cythonised implementation of inspect.Signature.bind, supporting faster
-+    binding and handling of default arguments.  On construction, the signature
-+    of the base function is extracted, and all parameters are parsed into
-+    positional or keyword slots, using positional wherever possible, and their
-+    defaults are stored.
-+    """
-+    # Instance of inpsect.Signature representing the function.
-+    cdef object signature
-+    cdef object inputs
-+    # Mapping of (str: int), where str is the name of any argument which may be
-+    # specified by a keyword, and int is its location in `self._pos` if
-+    # available, or -1 if it is keyword-only.
-+    cdef dict _locations
-+    # Default values (or inspect.Parameter.empty) for every parameter which
-+    # may be passed as a positional argument.
-+    cdef list _pos
-+    # For each dispatcher input which can be given as a positional argument,
-+    # these two lists hold the index of the input in the given tuple of input
-+    # names and the corresponding index into the positional arguments after
-+    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
-+    # effectively the same mapping as _kw_inputs (but for positional
-+    # arguments), but we use two lists rather than a dictionary for speed.
-+    cdef list _pos_inputs_input, _pos_inputs_pos
-+    # Default values (or inspect.Parameter.empty) for every parameter which
-+    # _must_ be passed as a keyword argument.
-+    cdef dict _kw
-+    # Mapping of (name, index into the input tuple) for each input which must
-+    # be specified as a keyword argument
-+    cdef list _kw_inputs
-+    # Names of the keyword arguments which have default values.
-+    cdef set _default_kw_names
-+    # Respectively, numbers of positional parameters, keyword-only parameters
-+    # and dispatcher inputs.
-+    cdef Py_ssize_t n_args, n_kwargs, n_inputs
-+    # Respectively, numbers of inputs which are positional and keyword-only.
-+    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
-+    # Respectively, numbers of positional arguments without a default, and
-+    # number of keyword-only arguments which _have_ a default.
-+    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
-+
-+
-+    def __init__(self, signature, tuple inputs):
-+        for arg in inputs:
-+            if arg not in signature.parameters:
-+                raise AttributeError("No argument matches '{}'.".format(arg))
-+        self.signature = signature
-+        self.inputs = inputs
-+        self._locations = {}
-+        self._pos = []
-+        self._pos_inputs_input = []
-+        self._pos_inputs_pos = []
-+        self._kw = {}
-+        self._kw_inputs = []
-+        self._default_kw_names = set()
-+        self._n_pos_no_default = 0
-+        # signature.parameters is ordered for all Python versions.
-+        for i, (name, parameter) in enumerate(signature.parameters.items()):
-+            kind = parameter.kind
-+            if (kind == parameter.VAR_POSITIONAL
-+                    or kind == parameter.VAR_KEYWORD):
-+                raise TypeError("Cannot dispatch with *args or **kwargs.")
-+            if kind == parameter.KEYWORD_ONLY:
-+                self._kw[name] = parameter.default
-+                self._locations[name] = -1
-+                if parameter.default is not parameter.empty:
-+                    self._default_kw_names.add(name)
-+                if name in inputs:
-+                    self._kw_inputs.append((name, inputs.index(name)))
-+            else:
-+                self._pos.append(parameter.default)
-+                if kind != parameter.POSITIONAL_ONLY:
-+                    self._locations[name] = i
-+                if parameter.default is parameter.empty:
-+                    self._n_pos_no_default += 1
-+                if name in inputs:
-+                    # Effectively a mapping.
-+                    self._pos_inputs_input.append(inputs.index(name))
-+                    self._pos_inputs_pos.append(len(self._pos) - 1)
-+        self.n_args = len(self._pos)
-+        self.n_kwargs = len(self._kw)
-+        self.n_inputs = len(inputs)
-+        self._n_pos_inputs = len(self._pos_inputs_input)
-+        self._n_kw_inputs = len(self._kw_inputs)
-+        self._n_kw_default = len(self._default_kw_names)
-+
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef tuple bind(self, tuple args, dict kwargs):
-+        """
-+        Cython reimplementation of inspect.Signature.bind for binding the
-+        collected `*args` and `**kwargs` of a generic call to a specific
-+        signature, checking that everything matches.
-+
-+        The output is a parsed tuple (args, kwargs), where `args` is a list and
-+        `kwargs` is a dict, however all arguments which _can_ be passed
-+        positionally will be moved from `kwargs` into `args` for the output.
-+        The resultant `args` and `kwargs` can be unpacked into the underlying
-+        function call safely.  Default values are not filled in by this method.
-+
-+        This is necessary to allow a generic `Dispatcher` class to work with
-+        all type signatures.  The result of this function can be fed to
-+        `_bind.convert_types` and `_bind.dispatch_types`.
-+        """
-+        cdef Py_ssize_t location, got_pos=0, got_kw=0
-+        cdef Py_ssize_t n_passed_args = len(args)
-+        if n_passed_args > self.n_args:
-+            raise TypeError(
-+                "Too many arguments: expected at most {} but received {}."
-+                .format(n_passed_args, self.n_args)
-+            )
-+        # _pos and _kw are filled with their defaults at initialisation, and
-+        # _pos is already the correct length (no-default parameters have
-+        # sentinel values).
-+        cdef list out_pos = self._pos.copy()
-+        cdef dict out_kw = self._kw.copy()
-+        got_pos = self.n_args - self._n_pos_no_default
-+        got_kw = self._n_kw_default
-+        # Positional arguments unambiguously fill the first positional slots.
-+        for location in range(n_passed_args):
-+            out_pos[location] = args[location]
-+        # How many arguments that we didn't have defaults for did we just get?
-+        # Positionals with a default are always after those without one.
-+        if n_passed_args > self._n_pos_no_default:
-+            got_pos += self._n_pos_no_default
-+        else:
-+            got_pos += n_passed_args
-+        # Everything else has been passed by keyword, but it may be allowed to
-+        # be passed positionally, which is the case we prefer.  dict.items() is
-+        # (relatively) expensive, so we use a boolean test for the fast path.
-+        cdef str kw
-+        cdef object arg
-+        if kwargs:
-+            for kw, arg in kwargs.items():
-+                try:
-+                    location = self._locations[kw]
-+                except KeyError:
-+                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
-+                # _locations[kw] = -1 if kw is keyword-only, otherwise the
-+                # corresponding positional location.
-+                if location >= 0:
-+                    if location < n_passed_args:
-+                        raise TypeError("Multiple values for '{}'".format(kw))
-+                    out_pos[location] = arg
-+                    if location < self._n_pos_no_default:
-+                        got_pos += 1
-+                else:
-+                    out_kw[kw] = arg
-+                    if kw not in self._default_kw_names:
-+                        got_kw += 1
-+        if got_pos < self.n_args:
-+            raise TypeError("Too few positional arguments passed.")
-+        if got_kw < self.n_kwargs:
-+            raise TypeError("Not all keyword arguments were filled.")
-+        return out_pos, out_kw
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef list dispatch_types(self, list args, dict kwargs):
-+        """
-+        Get a list of the types which the dispatch should operate over, given
-+        the output of `_bind.bind`.  The return value is a list of the _input_
-+        types to be dispatched on, in order that they were specified at
-+        `Dispatcher` creation.  The output type is not returned as part of this
-+        list, because there is no way for `_bind` to know it.
-+        """
-+        cdef list dispatch = [None] * self.n_inputs
-+        cdef str kw
-+        cdef Py_ssize_t location, i
-+        for location in range(self._n_pos_inputs):
-+            dispatch[self._pos_inputs_input[location]]\
-+                = type(args[self._pos_inputs_pos[location]])
-+        for i in range(self._n_kw_inputs):
-+            kw, location = self._kw_inputs[i]
-+            dispatch[location] = type(kwargs[kw])
-+        return dispatch
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
-+        """
-+        Apply the type converters `converters` to the parsed arguments `args`
-+        and `kwargs`.
-+
-+        If there are `n` inputs which are dispatched on, `converters` should be
-+        a tuple whose first `n` elements are converters (such as those obtained
-+        from `data.to[to_type, from_type]`) to the desired types.
-+
-+        `args` and `kwargs` should be the output of `_bind.bind`; the function
-+        will likely fail if called on unparsed arguments.
-+        """
-+        cdef str kw
-+        cdef Py_ssize_t location, i
-+        for location in range(self._n_pos_inputs):
-+            args[location] = converters[location](args[location])
-+        for i in range(self._n_kw_inputs):
-+            kw, location = self._kw_inputs[i]
-+            kwargs[kw] = converters[location](kwargs[kw])
-+        return args, kwargs
-+
-+
-+cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
-+    """
-+    Find the total weight of conversion if the types in `froms` are converted
-+    element-wise to the types in `tos`.  `weight_map` is a mapping of
-+    `(to_type, from_type): real`; it should almost certainly be
-+    `data.to.weight`.
-+    """
-+    cdef double weight = 0.0
-+    cdef Py_ssize_t i, n=len(froms)
-+    if len(tos) != n:
-+        raise ValueError(
-+            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
-+        )
-+    if out:
-+        n = n - 1
-+        weight += weight_map[froms[n], tos[n]]
-+    for i in range(n):
-+        weight += weight_map[tos[i], froms[i]]
-+    return weight
-+
-+
-+cdef class _constructed_specialisation:
-+    """
-+    Callable object providing the specialisation of a data-layer operation for
-+    a particular set of types (`self.types`).  This may or may not involve
-+    conversion of the input types and the output to match a known
-+    specialisation; if it has no conversions, `self.direct` will be `True`,
-+    otherwise it will be `False`.
-+
-+    See `self.__signature__` or `self.__text_signature__` for the call
-+    signature of this object.
-+    """
-+    cdef _bind _parameters
-+    cdef bint _output
-+    cdef object _call
-+    cdef Py_ssize_t _n_dispatch
-+    cdef readonly tuple types
-+    cdef tuple _converters
-+    cdef str _short_name
-+    cdef public str __doc__
-+    cdef public str __name__
-+    cdef public str __module__
-+    cdef public object __signature__
-+    cdef readonly str __text_signature__
-+    cdef readonly bint direct
-+
-+    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
-+                 direct):
-+        self.__doc__ = inspect.getdoc(dispatcher)
-+        self._short_name = dispatcher.__name__
-+        self.__name__ = (
-+            self._short_name
-+            + "_"
-+            + "_".join([x.__name__ for x in types])
-+        )
-+        self.__module__ = dispatcher.__module__
-+        self.__signature__ = dispatcher.__signature__
-+        self.__text_signature__ = dispatcher.__text_signature__
-+        self._parameters = dispatcher._parameters
-+        self._output = out
-+        self._call = base
-+        self._n_dispatch = len(types)
-+        self.types = types
-+        self.direct = direct
-+        self._converters = converters
-+
-+    cdef object prebound(self, list args, dict kwargs):
-+        """
-+        Call this specialisation with pre-parsed arguments and keyword
-+        arguments.  `args` and `kwargs` must be the output of the relevant
-+        `_bind.bind` method for this function.
-+        """
-+        self._parameters.convert_types(args, kwargs, self._converters)
-+        out = self._call(*args, **kwargs)
-+        if self._output:
-+            out = self._converters[self._n_dispatch - 1](out)
-+        return out
-+
-+    def __call__(self, *args, **kwargs):
-+        cdef list args_
-+        cdef dict kwargs_
-+        args_, kwargs_ = self._parameters.bind(args, kwargs)
-+        return self.prebound(args_, kwargs_)
-+
-+    def __repr__(self):
-+        if len(self.types) == 1:
-+            spec = self.types[0].__name__
-+        else:
-+            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
-+        direct = ("" if self.direct else "in") + "direct"
-+        return "".join([
-+            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
-+        ])
-+
-+
-+cdef class Dispatcher:
-+    """
-+    Dispatcher for a data-layer operation.  This object can be called with the
-+    signature shown in `self.__signature__` or `self.__text_signature__`, where
-+    the arguments listed in `self.inputs` can be any data-layer types (i.e.
-+    ones that have valid conversions in `data.to`).
-+
-+    You can define additional specialisations for this dispatcher by calling
-+    its `add_specialisations` method.  New data types must be added to
-+    `data.to` before they can be added as specialisations to a dispatcher.
-+
-+    You can get a callable object representing a single set of dispatcher types
-+    by using the key-lookup syntax
-+        Dispatcher[type1, type2, ...]
-+    where `type1`, `type2`, etc are the dispatched arguments (with the output
-+    type on the end, if this is a dispatcher over the output type.
-+    """
-+    cdef _bind _parameters
-+    cdef readonly dict _specialisations
-+    cdef Py_ssize_t _n_dispatch
-+    cdef readonly dict _lookup
-+    cdef set _dtypes
-+    cdef bint _pass_on_dtype
-+    cdef readonly tuple inputs
-+    cdef readonly bint output
-+    cdef public str __doc__
-+    cdef public str __name__
-+    cdef public str __module__
-+    cdef public object __signature__
-+    cdef readonly str __text_signature__
-+
-+    def __init__(self, signature_source, inputs, bint out=False,
-+                 str name=None, str module=None):
-+        """
-+        Create a new data layer dispatching operator.
-+
-+        Parameters
-+        ----------
-+        signature_source : callable or inspect.Signature
-+            An object from which the call signature of operation can be
-+            determined.  You can pass any callable defined in Python space, and
-+            the signature will be extracted.  Note that the callable will not
-+            be added as a specialisation by this; you will still have to call
-+            `add_specialisations`.
-+
-+            If you cannot provide a callable with an extractable signature
-+            (e.g. Cython extension methods), you can instead directly provide
-+            an instance of `inspect.Signature`, which will be used instead.
-+
-+        inputs : iterable of str
-+            The parameters which should be dispatched over.  These can be
-+            positional or keyword arguments, but must feature in the signature
-+            provided.
-+
-+        out : bool, optional (False)
-+            Whether to dispatch on the output of the function.  Defaults to
-+            `False`.
-+
-+        name : str, optional
-+            If given, the `__name__` parameter of the dispatcher is set to
-+            this.  If not given and `signature_source` is _not_ an instance of
-+            `inspect.Signature`, then we will attempt to read `__name__` from
-+            there instead.
-+
-+        module : str, optional
-+            If given, the `__module__` parameter of the dispatcher is set to
-+            this.  If not given and `signature_source` is _not_ an instance of
-+            `inspect.Signature`, then we will attempt to read `__module__` from
-+            there instead.
-+        """
-+        if isinstance(inputs, str):
-+            inputs = (inputs,)
-+        inputs = tuple(inputs)
-+        if inputs == () and out is False:
-+            warnings.warn(
-+                "No parameters to dispatch on."
-+                " Maybe you meant to specify 'inputs' or 'out'?"
-+            )
-+        self.inputs = inputs
-+        if isinstance(signature_source, inspect.Signature):
-+            self.__signature__ = signature_source
-+        else:
-+            self.__signature__ = inspect.signature(signature_source)
-+        self._parameters = _bind(self.__signature__, inputs)
-+        if name is not None:
-+            self.__name__ = name
-+        elif not isinstance(signature_source, inspect.Signature):
-+            self.__name__ = signature_source.__name__
-+        else:
-+            self.__name__ = 'dispatcher'
-+        if module is not None:
-+            self.__module__ = module
-+        elif not isinstance(signature_source, inspect.Signature):
-+            self.__module__ = signature_source.__module__
-+        self.__text_signature__ = self.__name__ + str(self.__signature__)
-+        if not isinstance(signature_source, inspect.Signature):
-+            self.__doc__ = inspect.getdoc(signature_source)
-+        self.output = out
-+        self._specialisations = {}
-+        self._lookup = {}
-+        self._n_dispatch = self._parameters.n_inputs + self.output
-+        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
-+        # Add ourselves to the list of dispatchers to be updated.
-+        _to.dispatchers.append(self)
-+
-+    def add_specialisations(self, specialisations, _defer=False):
-+        """
-+        Add specialisations for particular combinations of data types to this
-+        operation.  The data types must already be known in `data.to` before
-+        you try to provide them here.  All data types defined in `data.to` will
-+        automatically work with this dispatcher, but will involve inefficient
-+        conversions to and from other types unless you define a closer
-+        specialisation using this method.
-+
-+        The lookup table will automatically be rebuilt after this method is
-+        called.  Specialisations defined more than once will use the most
-+        recent version; you can use this to override currently known
-+        specialisations if desired.
-+
-+        Parameters
-+        ----------
-+        specialisations : iterable of tuples
-+            An iterable where each element specifies a new specialisation for
-+            this operation.  Each element of the iterable should be a tuple,
-+            whose items are the types (instances of `type`) which this
-+            specialisation takes in each of the slots defined by
-+            `Dispatcher.inputs`, and the output type if this is a dispatcher
-+            over output types.  The last element should be the callable itself.
-+
-+            The callable must have exactly the same signature as
-+            `Dispatcher.__signature__`; it is not enough that it takes all the
-+            same keyword arguments, but they must come in the same order as
-+            well (this is a speed optimisation for the dispatching operation).
-+
-+            For example, if this is a dispatcher with the signature
-+                add(left, right, scale=1)
-+            which also dispatches over its output, and we have specialisations
-+                add_1(left: CSR, right: Dense, scale=1) -> Dense
-+                add_2(left: Dense, right: CSC, scale=1) -> CSR
-+            then to add this, `specialisations` should look like
-+                [
-+                    (CSR, Dense, Dense, add_1),
-+                    (Dense, CSC, CSR, add_2),
-+                ]
-+            Type annotations present in the specialisation objects are ignored.
-+
-+        _defer : bool, optional (False)
-+            Only intended for internal library use during initialisation. If
-+            `True`, then the input types are not checked, and the full lookup
-+            table is not built until a manual call to
-+            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
-+            remember that you should add the data type conversions to `data.to`
-+            before you try to add specialisations.
-+        """
-+        for arg in specialisations:
-+            arg = tuple(arg)
-+            if len(arg) != self._n_dispatch + 1:
-+                raise ValueError(
-+                    "specialisation " + str(arg)
-+                    + " has wrong number of parameters: needed types for "
-+                    + str(self._parameters.inputs)
-+                    + (", an output type" if self.output else "")
-+                    + " and a callable"
-+                )
-+            for i in range(self._n_dispatch):
-+                if (not _defer) and arg[i] not in _to.dtypes:
-+                    raise ValueError(str(arg[i]) + " is not a known data type")
-+            if not callable(arg[self._n_dispatch]):
-+                raise TypeError(str(arg[-1]) + " is not callable")
-+            self._specialisations[arg[:-1]] = arg[-1]
-+        if not _defer:
-+            self.rebuild_lookup()
-+
-+    def rebuild_lookup(self):
-+        """
-+        Manually trigger a rebuild of the lookup table for this dispatcher.
-+        This is called automatically when new data types are added to
-+        `data.to`, or when specialisations are added to this object with
-+        `Dispatcher.add_specialisations`.
-+
-+        You most likely do not need to call this function yourself.
-+        """
-+        cdef double weight, cur
-+        cdef tuple types, out_types
-+        cdef object function
-+        if not self._specialisations:
-+            return
-+        self._dtypes = _to.dtypes.copy()
-+        # The complexity of building the table here is very poor, but it's a
-+        # cost we pay very infrequently, and until it's proved to be a
-+        # bottle-neck in real code, we stick with the simple algorithm.
-+        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
-+            weight = math.INFINITY
-+            types = None
-+            function = None
-+            for out_types, out_function in self._specialisations.items():
-+                cur = _conversion_weight(in_types, out_types, _to.weight,
-+                                         out=self.output)
-+                if cur < weight:
-+                    weight = cur
-+                    types = out_types
-+                    function = out_function
-+            if self.output:
-+                converters = tuple(
-+                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
-+                    + [_to[in_types[-1], types[-1]]]
-+                )
-+            else:
-+                converters = tuple(_to[pair] for pair in zip(types, in_types))
-+            self._lookup[in_types] =\
-+                _constructed_specialisation(function, self, in_types,
-+                                            converters, self.output,
-+                                            weight == 0)
-+        # Now build the lookup table in the case that we dispatch on the output
-+        # type as well, but the user has called us without specifying it.
-+        # TODO: option to control default output type choice if unspecified?
-+        if self.output:
-+            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
-+                weight = math.INFINITY
-+                types = None
-+                function = None
-+                for out_types, out_function in self._specialisations.items():
-+                    cur = _conversion_weight(in_types, out_types[:-1],
-+                                             _to.weight, out=False)
-+                    if cur < weight:
-+                        weight = cur
-+                        types = out_types
-+                        function = out_function
-+                converters = tuple(_to[pair] for pair in zip(types, in_types))
-+                self._lookup[in_types] =\
-+                    _constructed_specialisation(function, self,
-+                                                in_types + (types[-1],),
-+                                                converters, False,
-+                                                weight == 0)
-+
-+    def __getitem__(self, types):
-+        """
-+        Get the particular specialisation for the given types.  The output is a
-+        callable object which requires that the dispatched arguments match
-+        those specified in `types`.
-+        """
-+        if type(types) is not tuple:
-+            types = (types,)
-+        types = tuple(_to.parse(arg) for arg in types)
-+        try:
-+            return self._lookup[types]
-+        except KeyError:
-+            raise TypeError("specialisation not known for types: " + str(types)) from None
-+
-+    def __repr__(self):
-+        return "<dispatcher: " + self.__text_signature__ + ">"
-+
-+    def __call__(self, *args, dtype=None, **kwargs):
-+        cdef list args_, dispatch
-+        cdef dict kwargs_
-+        if self._pass_on_dtype:
-+            kwargs['dtype'] = dtype
-+        if not (self._pass_on_dtype or self.output) and dtype is not None:
-+            raise TypeError("unknown argument 'dtype'")
-+        args_, kwargs_ = self._parameters.bind(args, kwargs)
-+        dispatch = self._parameters.dispatch_types(args_, kwargs_)
-+        if self.output and dtype is not None:
-+            dtype = _to.parse(dtype)
-+            dispatch.append(dtype)
-+        cdef _constructed_specialisation function
-+        try:
-+            function = self._lookup[tuple(dispatch)]
-+        except KeyError:
-+            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
-+        return function.prebound(args_, kwargs_)
-diff --git a/qutip/core/data/eigen.py b/qutip/core/data/eigen.py
-index c860fc20..f5aa6e0f 100644
---- a/qutip/core/data/eigen.py
-+++ b/qutip/core/data/eigen.py
-@@ -1,454 +1,454 @@
--import numpy as np
--import scipy.linalg
--import scipy.sparse as sp
--import scipy.sparse.linalg
--from itertools import combinations
--
--from .dense import Dense, from_csr
--from .csr import CSR
--from .properties import isherm as _isherm
--from qutip.settings import settings
--
--__all__ = [
--    'eigs', 'eigs_csr', 'eigs_dense',
--    'svd', 'svd_csr', 'svd_dense',
--]
--
--
--def _orthogonalize(vec, other):
--    cross = np.sum(np.conj(other) * vec)
--    vec -= cross * other
--    norm = np.sum(np.conj(vec) * vec)**0.5
--    vec /= norm
--
--
--if settings.eigh_unsafe:
--    def eigh(mat, eigvals=None):
--        val, vec = scipy.linalg.eig(mat)
--        val = np.real(val)
--        idx = np.argsort(val)
--        val = val[idx]
--        vec = vec[:, idx]
--        if eigvals:
--            val = val[eigvals[0]:eigvals[1]+1]
--            vec = vec[:, eigvals[0]:eigvals[1]+1]
--        same_eigv = 0
--        for i in range(1, len(val)):
--            if abs(val[i] - val[i-1]) < 1e-12:
--                same_eigv += 1
--                for j in range(same_eigv):
--                    _orthogonalize(vec[:, i], vec[:, i-j-1])
--            else:
--                same_eigv = 0
--        return val, vec
--
--    def eigvalsh(a, eigvals=None):
--        val = scipy.linalg.eigvals(a)
--        val = np.sort(np.real(val))
--        if eigvals:
--            return val[eigvals[0]:eigvals[1]+1]
--        return val
--else:
--    eigh = scipy.linalg.eigh
--    eigvalsh = scipy.linalg.eigvalsh
--
--
--def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
--    """
--    Internal functions for computing eigenvalues and eigenstates for a dense
--    matrix.
--    """
--    N = data.shape[0]
--    kwargs = {}
--    if eigvals != 0 and isherm:
--        kwargs['subset_by_index'] = (
--            [0, num_small-1] if num_small else [N-num_large, N-1]
--        )
--    if vecs:
--        driver = eigh if isherm else scipy.linalg.eig
--        evals, evecs = driver(data, **kwargs)
--    else:
--        driver = eigvalsh if isherm else scipy.linalg.eigvals
--        evals = driver(data, **kwargs)
--        evecs = None
--
--    _zipped = list(zip(evals, range(len(evals))))
--    _zipped.sort()
--    evals, perm = list(zip(*_zipped))
--
--    if vecs:
--        evecs = np.array([evecs[:, k] for k in perm]).T
--
--    if not isherm and eigvals > 0:
--        if vecs:
--            if num_small > 0:
--                evals, evecs = evals[:num_small], evecs[:, :num_small]
--            elif num_large > 0:
--                evals = evals[(N - num_large):]
--                evecs = evecs[:, (N - num_large):]
--        else:
--            if num_small > 0:
--                evals = evals[:num_small]
--            elif num_large > 0:
--                evals = evals[(N - num_large):]
--    return np.array(evals), evecs
--
--
--def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
--    """
--    Internal functions for computing eigenvalues and eigenstates for a sparse
--    matrix.
--    """
--    N = data.shape[0]
--    big_vals = np.array([])
--    small_vals = np.array([])
--    evecs = None
--
--    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
--    if eigvals == (N - 1):
--        # calculate all eigenvalues and remove one at output if using sparse
--        # 1: remove the smallest, -1, remove the largest
--        remove_one = 1 if (num_small > 0) else -1
--        eigvals = 0
--        num_small = num_large = N // 2
--        num_small += N % 2
--
--    if vecs:
--        if isherm:
--            if num_large > 0:
--                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
--                                                     which='LA', tol=tol,
--                                                     maxiter=maxiter)
--            if num_small > 0:
--                small_vals, small_vecs = sp.linalg.eigsh(
--                    data, k=num_small, which='SA',
--                    tol=tol, maxiter=maxiter)
--
--        else:
--            if num_large > 0:
--                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
--                                                    which='LR', tol=tol,
--                                                    maxiter=maxiter)
--            if num_small > 0:
--                small_vals, small_vecs = sp.linalg.eigs(
--                    data, k=num_small, which='SR',
--                    tol=tol, maxiter=maxiter)
--
--        if num_large != 0 and num_small != 0:
--            evecs = np.hstack([small_vecs, big_vecs])
--        elif num_large != 0 and num_small == 0:
--            evecs = big_vecs
--        elif num_large == 0 and num_small != 0:
--            evecs = small_vecs
--    else:
--        if isherm:
--            if num_large > 0:
--                big_vals = sp.linalg.eigsh(
--                    data, k=num_large, which='LA',
--                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
--            if num_small > 0:
--                small_vals = sp.linalg.eigsh(
--                    data, k=num_small, which='SA',
--                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
--        else:
--            if num_large > 0:
--                big_vals = sp.linalg.eigs(
--                    data, k=num_large, which='LR',
--                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
--            if num_small > 0:
--                small_vals = sp.linalg.eigs(
--                    data, k=num_small, which='SR',
--                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
--
--    evals = np.hstack((small_vals, big_vals))
--    if isherm:
--        evals = np.real(evals)
--
--    _zipped = list(zip(evals, range(len(evals))))
--    _zipped.sort()
--    evals, perm = list(zip(*_zipped))
--
--    if vecs:
--        evecs = np.array([evecs[:, k] for k in perm]).T
--
--    # remove last element if requesting N-1 eigs and using sparse
--    if remove_one == 1:
--        evals = evals[:-1]
--        if vecs:
--            evecs = evecs[:, :-1]
--    elif remove_one == -1:
--        evals = evals[1:]
--        if vecs:
--            evecs = evecs[:, 1:]
--
--    return np.array(evals), evecs
--
--
--def _eigs_check_shape(data):
--    if data.shape[0] != data.shape[1]:
--        raise TypeError("Can only diagonalize square matrices")
--
--
--def _eigs_fix_eigvals(data, eigvals, sort):
--    N = data.shape[0]
--    if eigvals == N:
--        eigvals = 0
--    if eigvals > N:
--        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
--    if sort not in ('low', 'high'):
--        raise ValueError("'sort' must be 'low' or 'high'")
--
--    # set number of large and small eigenvals/vecs
--    if eigvals == 0:  # user wants all eigs (default)
--        num_small = num_large = N // 2
--        num_small += N % 2
--    else:  # if user wants only a few eigen vals/vecs
--        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
--    return eigvals, num_large, num_small
--
--
--def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
--             tol=0, maxiter=100000):
--    """
--    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
--    may take some extra keyword arguments in addition to the full documentation
--    specified in :func:`.eigs`.
--
--    This method is typically slower and less accurate than the dense eigenvalue
--    solver; you probably want that, unless memory concerns deem it impossible.
--
--    Extra keyword arguments
--    -----------------------
--    tol : float (0)
--        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
--        as 0) cause the solver to use machine precision.
--    maxiter : int (100_000)
--        Max number of iterations used by sparse eigensolver.
--    """
--    if not isinstance(data, CSR):
--        raise TypeError("expected data in CSR format but got "
--                        + str(type(data)))
--    if data.shape[0] < 4:
--        # For small matrix, the sparse solver can't compute all eigenvalues.
--        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
--    _eigs_check_shape(data)
--    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
--    isherm = isherm if isherm is not None else _isherm(data)
--    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
--                             num_large, num_small, tol, maxiter)
--
--    if vecs and isherm:
--        i = 0
--        while i < len(evals):
--            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
--            # orthogonalize vectors 1 .. k with respect to the first, then
--            # 2 .. k with respect to the second, and so on. Relies on both the
--            # order of each pair and the ordering of pairs returned by
--            # combinations.
--            for k, l in combinations(range(num_degen), 2):
--                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
--            i += num_degen
--
--    if sort == 'high':
--        # Flip arrays around.
--        if vecs:
--            evecs = np.fliplr(evecs)
--        evals = evals[::-1]
--    return (evals, Dense(evecs, copy=False)) if vecs else evals
--
--
--def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
--    """
--    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
--    keyword arguments; see the primary documentation in :func:`.eigs`.
--    """
--    if not isinstance(data, Dense):
--        raise TypeError("expected data in Dense format but got "
--                        + str(type(data)))
--    _eigs_check_shape(data)
--    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
--    isherm = isherm if isherm is not None else _isherm(data)
--    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
--                               num_large, num_small)
--    if sort == 'high':
--        # Flip arrays around.
--        if vecs:
--            evecs = np.fliplr(evecs)
--        evals = evals[::-1]
--    return (evals, Dense(evecs, copy=False)) if vecs else evals
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--
--# We use eigs_dense as the signature source, since in this case it has the
--# complete signature that we allow, so we don't need to manually set it.
--eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
--eigs.__doc__ =\
--    """
--    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
--
--    Some particular specialisations of this function may take additional
--    keyword arguments (such as the CSR solver).  See their particular
--    docstrings for details on those.
--
--    Parameters
--    ----------
--    data : Data
--        Input matrix
--    isherm : bool, optional
--        Indicate whether the matrix is Hermitian or not.  There are special
--        Hermitian eigenvalue and -vector solvers for this case, which will take
--        care of orthonormalisation and ensuring better accuracy.  If this is
--        not specified either way, it will be calculated from the data.
--    vecs : bool, optional (True)
--        Whether the eigenvectors should be returned as well.
--    sort : {'low', 'high'}, optional
--        Sort the output of the eigenvalues and -vectors ordered by the relevant
--        size of the real part of the eigenvalue from 'low' to high or from
--        'high' to low.  If not all of the eigenvalues are requested, this
--        influences which eigenvalues will be found.
--    eigvals : int, optional
--        Number of eigenvalues and -vectors to return.  If `0`, then returns
--        all.
--
--    Returns
--    -------
--    eigenvalues : np.ndarray
--        The requested eigenvalues, sorted in the expected order.  The dtype is
--        `np.complex128`, unless `isherm=True`, in which case it will be
--        `np.float64`.
--    eigenvectors : Data
--        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
--        order of the eigenvalues.
--    """
--eigs.add_specialisations([
--    (CSR, eigs_csr),
--    (Dense, eigs_dense),
--], _defer=True)
--
--
--def svd_csr(data, vecs=True, k=6, **kw):
--    """
--    Singular Value Decomposition:
--
--    ``data = U @ S @ Vh``
--
--    Where ``S`` is diagonal.
--
--    Parameters
--    ----------
--    data : Data
--        Input matrix
--    vecs : bool, optional (True)
--        Whether the singular vectors (``U``, ``Vh``) should be returned.
--    k : int, optional (6)
--        Number of state to compute, default is ``6`` to match scipy's default.
--    **kw : dict
--        Options to pass to ``scipy.sparse.linalg.svds``.
--
--    Returns
--    -------
--    U : Dense
--        Left singular vectors as columns. Only returned if ``vecs == True``.
--        shape = (data.shape[0], k)
--    S : np.ndarray
--        The ``k``'s largest singular values.
--    Vh : Dense
--        Right singular vectors as rows. Only returned if ``vecs == True``.
--        shape = (k, data.shape[1])
--
--    .. note::
--        svds cannot compute all states at once. While it could find the
--        largest and smallest in 2 calls, it has issues converging with when
--        solving for the smallest (finding the 5 smallest in a 50x50 matrix
--        can fail with default options). It should be used when not all states
--        are needed.
--    """
--    out = scipy.sparse.linalg.svds(
--        data.as_scipy(), k, return_singular_vectors=vecs, **kw
--    )
--    if vecs:
--        u, s, vh = out
--        return Dense(u, copy=False), s, Dense(vh, copy=False)
--    return out
--
--
--def svd_dense(data, vecs=True, **kw):
--    """
--    Singular Value Decomposition:
--
--    ``data = U @ S @ Vh``
--
--    Where ``S`` is diagonal.
--
--    Parameters
--    ----------
--    data : Data
--        Input matrix
--    vecs : bool, optional (True)
--        Whether the singular vectors (``U``, ``Vh``) should be returned.
--    **kw : dict
--        Options to pass to ``scipy.linalg.svd``.
--
--    Returns
--    -------
--    U : Dense
--        Left singular vectors as columns. Only returned if ``vecs == True``.
--    S : np.ndarray
--        Singular values.
--    Vh : Dense
--        Right singular vectors as rows. Only returned if ``vecs == True``.
--    """
--    out = scipy.linalg.svd(
--        data.to_array(), compute_uv=vecs, **kw
--    )
--    if vecs:
--        u, s, vh = out
--        return Dense(u, copy=False), s, Dense(vh, copy=False)
--    return out
--
--
--svd = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='svd',
--    module=__name__,
--    inputs=('data',),
--    out=False)
--svd.__doc__ =\
--    """
--    Singular Value Decomposition:
--
--    ``data = U @ S @ Vh``
--
--    Where ``S`` is diagonal.
--
--    Parameters
--    ----------
--    data : Data
--        Input matrix
--    vecs : bool, optional (True)
--        Whether the singular vectors (``U``, ``Vh``) should be returned.
--
--    Returns
--    -------
--    U : Dense
--        Left singular vectors as columns. Only returned if ``vecs == True``.
--    S : np.ndarray
--        Singular values.
--    Vh : Dense
--        Right singular vectors as rows. Only returned if ``vecs == True``.
--    """
--# Dense implementation return all states, but sparse implementation compute
--# only a few states. So only the dense version is registered.
--svd.add_specialisations([
--    (Dense, svd_dense),
--], _defer=True)
--
--
--del _Dispatcher
--del _inspect
-+import numpy as np
-+import scipy.linalg
-+import scipy.sparse as sp
-+import scipy.sparse.linalg
-+from itertools import combinations
-+
-+from .dense import Dense, from_csr
-+from .csr import CSR
-+from .properties import isherm as _isherm
-+from qutip.settings import settings
-+
-+__all__ = [
-+    'eigs', 'eigs_csr', 'eigs_dense',
-+    'svd', 'svd_csr', 'svd_dense',
-+]
-+
-+
-+def _orthogonalize(vec, other):
-+    cross = np.sum(np.conj(other) * vec)
-+    vec -= cross * other
-+    norm = np.sum(np.conj(vec) * vec)**0.5
-+    vec /= norm
-+
-+
-+if settings.eigh_unsafe:
-+    def eigh(mat, eigvals=None):
-+        val, vec = scipy.linalg.eig(mat)
-+        val = np.real(val)
-+        idx = np.argsort(val)
-+        val = val[idx]
-+        vec = vec[:, idx]
-+        if eigvals:
-+            val = val[eigvals[0]:eigvals[1]+1]
-+            vec = vec[:, eigvals[0]:eigvals[1]+1]
-+        same_eigv = 0
-+        for i in range(1, len(val)):
-+            if abs(val[i] - val[i-1]) < 1e-12:
-+                same_eigv += 1
-+                for j in range(same_eigv):
-+                    _orthogonalize(vec[:, i], vec[:, i-j-1])
-+            else:
-+                same_eigv = 0
-+        return val, vec
-+
-+    def eigvalsh(a, eigvals=None):
-+        val = scipy.linalg.eigvals(a)
-+        val = np.sort(np.real(val))
-+        if eigvals:
-+            return val[eigvals[0]:eigvals[1]+1]
-+        return val
-+else:
-+    eigh = scipy.linalg.eigh
-+    eigvalsh = scipy.linalg.eigvalsh
-+
-+
-+def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
-+    """
-+    Internal functions for computing eigenvalues and eigenstates for a dense
-+    matrix.
-+    """
-+    N = data.shape[0]
-+    kwargs = {}
-+    if eigvals != 0 and isherm:
-+        kwargs['subset_by_index'] = (
-+            [0, num_small-1] if num_small else [N-num_large, N-1]
-+        )
-+    if vecs:
-+        driver = eigh if isherm else scipy.linalg.eig
-+        evals, evecs = driver(data, **kwargs)
-+    else:
-+        driver = eigvalsh if isherm else scipy.linalg.eigvals
-+        evals = driver(data, **kwargs)
-+        evecs = None
-+
-+    _zipped = list(zip(evals, range(len(evals))))
-+    _zipped.sort()
-+    evals, perm = list(zip(*_zipped))
-+
-+    if vecs:
-+        evecs = np.array([evecs[:, k] for k in perm]).T
-+
-+    if not isherm and eigvals > 0:
-+        if vecs:
-+            if num_small > 0:
-+                evals, evecs = evals[:num_small], evecs[:, :num_small]
-+            elif num_large > 0:
-+                evals = evals[(N - num_large):]
-+                evecs = evecs[:, (N - num_large):]
-+        else:
-+            if num_small > 0:
-+                evals = evals[:num_small]
-+            elif num_large > 0:
-+                evals = evals[(N - num_large):]
-+    return np.array(evals), evecs
-+
-+
-+def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
-+    """
-+    Internal functions for computing eigenvalues and eigenstates for a sparse
-+    matrix.
-+    """
-+    N = data.shape[0]
-+    big_vals = np.array([])
-+    small_vals = np.array([])
-+    evecs = None
-+
-+    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
-+    if eigvals == (N - 1):
-+        # calculate all eigenvalues and remove one at output if using sparse
-+        # 1: remove the smallest, -1, remove the largest
-+        remove_one = 1 if (num_small > 0) else -1
-+        eigvals = 0
-+        num_small = num_large = N // 2
-+        num_small += N % 2
-+
-+    if vecs:
-+        if isherm:
-+            if num_large > 0:
-+                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
-+                                                     which='LA', tol=tol,
-+                                                     maxiter=maxiter)
-+            if num_small > 0:
-+                small_vals, small_vecs = sp.linalg.eigsh(
-+                    data, k=num_small, which='SA',
-+                    tol=tol, maxiter=maxiter)
-+
-+        else:
-+            if num_large > 0:
-+                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
-+                                                    which='LR', tol=tol,
-+                                                    maxiter=maxiter)
-+            if num_small > 0:
-+                small_vals, small_vecs = sp.linalg.eigs(
-+                    data, k=num_small, which='SR',
-+                    tol=tol, maxiter=maxiter)
-+
-+        if num_large != 0 and num_small != 0:
-+            evecs = np.hstack([small_vecs, big_vecs])
-+        elif num_large != 0 and num_small == 0:
-+            evecs = big_vecs
-+        elif num_large == 0 and num_small != 0:
-+            evecs = small_vecs
-+    else:
-+        if isherm:
-+            if num_large > 0:
-+                big_vals = sp.linalg.eigsh(
-+                    data, k=num_large, which='LA',
-+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-+            if num_small > 0:
-+                small_vals = sp.linalg.eigsh(
-+                    data, k=num_small, which='SA',
-+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-+        else:
-+            if num_large > 0:
-+                big_vals = sp.linalg.eigs(
-+                    data, k=num_large, which='LR',
-+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-+            if num_small > 0:
-+                small_vals = sp.linalg.eigs(
-+                    data, k=num_small, which='SR',
-+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-+
-+    evals = np.hstack((small_vals, big_vals))
-+    if isherm:
-+        evals = np.real(evals)
-+
-+    _zipped = list(zip(evals, range(len(evals))))
-+    _zipped.sort()
-+    evals, perm = list(zip(*_zipped))
-+
-+    if vecs:
-+        evecs = np.array([evecs[:, k] for k in perm]).T
-+
-+    # remove last element if requesting N-1 eigs and using sparse
-+    if remove_one == 1:
-+        evals = evals[:-1]
-+        if vecs:
-+            evecs = evecs[:, :-1]
-+    elif remove_one == -1:
-+        evals = evals[1:]
-+        if vecs:
-+            evecs = evecs[:, 1:]
-+
-+    return np.array(evals), evecs
-+
-+
-+def _eigs_check_shape(data):
-+    if data.shape[0] != data.shape[1]:
-+        raise TypeError("Can only diagonalize square matrices")
-+
-+
-+def _eigs_fix_eigvals(data, eigvals, sort):
-+    N = data.shape[0]
-+    if eigvals == N:
-+        eigvals = 0
-+    if eigvals > N:
-+        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
-+    if sort not in ('low', 'high'):
-+        raise ValueError("'sort' must be 'low' or 'high'")
-+
-+    # set number of large and small eigenvals/vecs
-+    if eigvals == 0:  # user wants all eigs (default)
-+        num_small = num_large = N // 2
-+        num_small += N % 2
-+    else:  # if user wants only a few eigen vals/vecs
-+        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
-+    return eigvals, num_large, num_small
-+
-+
-+def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
-+             tol=0, maxiter=100000):
-+    """
-+    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
-+    may take some extra keyword arguments in addition to the full documentation
-+    specified in :func:`.eigs`.
-+
-+    This method is typically slower and less accurate than the dense eigenvalue
-+    solver; you probably want that, unless memory concerns deem it impossible.
-+
-+    Extra keyword arguments
-+    -----------------------
-+    tol : float (0)
-+        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
-+        as 0) cause the solver to use machine precision.
-+    maxiter : int (100_000)
-+        Max number of iterations used by sparse eigensolver.
-+    """
-+    if not isinstance(data, CSR):
-+        raise TypeError("expected data in CSR format but got "
-+                        + str(type(data)))
-+    if data.shape[0] < 4:
-+        # For small matrix, the sparse solver can't compute all eigenvalues.
-+        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
-+    _eigs_check_shape(data)
-+    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
-+    isherm = isherm if isherm is not None else _isherm(data)
-+    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
-+                             num_large, num_small, tol, maxiter)
-+
-+    if vecs and isherm:
-+        i = 0
-+        while i < len(evals):
-+            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
-+            # orthogonalize vectors 1 .. k with respect to the first, then
-+            # 2 .. k with respect to the second, and so on. Relies on both the
-+            # order of each pair and the ordering of pairs returned by
-+            # combinations.
-+            for k, l in combinations(range(num_degen), 2):
-+                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
-+            i += num_degen
-+
-+    if sort == 'high':
-+        # Flip arrays around.
-+        if vecs:
-+            evecs = np.fliplr(evecs)
-+        evals = evals[::-1]
-+    return (evals, Dense(evecs, copy=False)) if vecs else evals
-+
-+
-+def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
-+    """
-+    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
-+    keyword arguments; see the primary documentation in :func:`.eigs`.
-+    """
-+    if not isinstance(data, Dense):
-+        raise TypeError("expected data in Dense format but got "
-+                        + str(type(data)))
-+    _eigs_check_shape(data)
-+    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
-+    isherm = isherm if isherm is not None else _isherm(data)
-+    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
-+                               num_large, num_small)
-+    if sort == 'high':
-+        # Flip arrays around.
-+        if vecs:
-+            evecs = np.fliplr(evecs)
-+        evals = evals[::-1]
-+    return (evals, Dense(evecs, copy=False)) if vecs else evals
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+
-+# We use eigs_dense as the signature source, since in this case it has the
-+# complete signature that we allow, so we don't need to manually set it.
-+eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
-+eigs.__doc__ =\
-+    """
-+    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
-+
-+    Some particular specialisations of this function may take additional
-+    keyword arguments (such as the CSR solver).  See their particular
-+    docstrings for details on those.
-+
-+    Parameters
-+    ----------
-+    data : Data
-+        Input matrix
-+    isherm : bool, optional
-+        Indicate whether the matrix is Hermitian or not.  There are special
-+        Hermitian eigenvalue and -vector solvers for this case, which will take
-+        care of orthonormalisation and ensuring better accuracy.  If this is
-+        not specified either way, it will be calculated from the data.
-+    vecs : bool, optional (True)
-+        Whether the eigenvectors should be returned as well.
-+    sort : {'low', 'high'}, optional
-+        Sort the output of the eigenvalues and -vectors ordered by the relevant
-+        size of the real part of the eigenvalue from 'low' to high or from
-+        'high' to low.  If not all of the eigenvalues are requested, this
-+        influences which eigenvalues will be found.
-+    eigvals : int, optional
-+        Number of eigenvalues and -vectors to return.  If `0`, then returns
-+        all.
-+
-+    Returns
-+    -------
-+    eigenvalues : np.ndarray
-+        The requested eigenvalues, sorted in the expected order.  The dtype is
-+        `np.complex128`, unless `isherm=True`, in which case it will be
-+        `np.float64`.
-+    eigenvectors : Data
-+        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
-+        order of the eigenvalues.
-+    """
-+eigs.add_specialisations([
-+    (CSR, eigs_csr),
-+    (Dense, eigs_dense),
-+], _defer=True)
-+
-+
-+def svd_csr(data, vecs=True, k=6, **kw):
-+    """
-+    Singular Value Decomposition:
-+
-+    ``data = U @ S @ Vh``
-+
-+    Where ``S`` is diagonal.
-+
-+    Parameters
-+    ----------
-+    data : Data
-+        Input matrix
-+    vecs : bool, optional (True)
-+        Whether the singular vectors (``U``, ``Vh``) should be returned.
-+    k : int, optional (6)
-+        Number of state to compute, default is ``6`` to match scipy's default.
-+    **kw : dict
-+        Options to pass to ``scipy.sparse.linalg.svds``.
-+
-+    Returns
-+    -------
-+    U : Dense
-+        Left singular vectors as columns. Only returned if ``vecs == True``.
-+        shape = (data.shape[0], k)
-+    S : np.ndarray
-+        The ``k``'s largest singular values.
-+    Vh : Dense
-+        Right singular vectors as rows. Only returned if ``vecs == True``.
-+        shape = (k, data.shape[1])
-+
-+    .. note::
-+        svds cannot compute all states at once. While it could find the
-+        largest and smallest in 2 calls, it has issues converging with when
-+        solving for the smallest (finding the 5 smallest in a 50x50 matrix
-+        can fail with default options). It should be used when not all states
-+        are needed.
-+    """
-+    out = scipy.sparse.linalg.svds(
-+        data.as_scipy(), k, return_singular_vectors=vecs, **kw
-+    )
-+    if vecs:
-+        u, s, vh = out
-+        return Dense(u, copy=False), s, Dense(vh, copy=False)
-+    return out
-+
-+
-+def svd_dense(data, vecs=True, **kw):
-+    """
-+    Singular Value Decomposition:
-+
-+    ``data = U @ S @ Vh``
-+
-+    Where ``S`` is diagonal.
-+
-+    Parameters
-+    ----------
-+    data : Data
-+        Input matrix
-+    vecs : bool, optional (True)
-+        Whether the singular vectors (``U``, ``Vh``) should be returned.
-+    **kw : dict
-+        Options to pass to ``scipy.linalg.svd``.
-+
-+    Returns
-+    -------
-+    U : Dense
-+        Left singular vectors as columns. Only returned if ``vecs == True``.
-+    S : np.ndarray
-+        Singular values.
-+    Vh : Dense
-+        Right singular vectors as rows. Only returned if ``vecs == True``.
-+    """
-+    out = scipy.linalg.svd(
-+        data.to_array(), compute_uv=vecs, **kw
-+    )
-+    if vecs:
-+        u, s, vh = out
-+        return Dense(u, copy=False), s, Dense(vh, copy=False)
-+    return out
-+
-+
-+svd = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='svd',
-+    module=__name__,
-+    inputs=('data',),
-+    out=False)
-+svd.__doc__ =\
-+    """
-+    Singular Value Decomposition:
-+
-+    ``data = U @ S @ Vh``
-+
-+    Where ``S`` is diagonal.
-+
-+    Parameters
-+    ----------
-+    data : Data
-+        Input matrix
-+    vecs : bool, optional (True)
-+        Whether the singular vectors (``U``, ``Vh``) should be returned.
-+
-+    Returns
-+    -------
-+    U : Dense
-+        Left singular vectors as columns. Only returned if ``vecs == True``.
-+    S : np.ndarray
-+        Singular values.
-+    Vh : Dense
-+        Right singular vectors as rows. Only returned if ``vecs == True``.
-+    """
-+# Dense implementation return all states, but sparse implementation compute
-+# only a few states. So only the dense version is registered.
-+svd.add_specialisations([
-+    (Dense, svd_dense),
-+], _defer=True)
-+
-+
-+del _Dispatcher
-+del _inspect
-diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
-index 4e7d2af1..da6ab987 100644
---- a/qutip/core/data/expect.pxd
-+++ b/qutip/core/data/expect.pxd
-@@ -1,16 +1,16 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from qutip.core.data cimport CSR, Dense, Data
--
--cpdef double complex expect_csr(CSR op, CSR state) nogil except *
--cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
--
--cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
--cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
--
--cpdef double complex expect_dense(Dense op, Dense state) nogil except *
--cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
--
--cdef double complex expect_data_dense(Data op, Dense state) except *
--cdef double complex expect_super_data_dense(Data op, Dense state) except *
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from qutip.core.data cimport CSR, Dense, Data
-+
-+cpdef double complex expect_csr(CSR op, CSR state) nogil except *
-+cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
-+
-+cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
-+cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
-+
-+cpdef double complex expect_dense(Dense op, Dense state) nogil except *
-+cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
-+
-+cdef double complex expect_data_dense(Data op, Dense state) except *
-+cdef double complex expect_super_data_dense(Data op, Dense state) except *
-diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
-index 9b208994..72903acb 100644
---- a/qutip/core/data/expect.pyx
-+++ b/qutip/core/data/expect.pyx
-@@ -1,325 +1,325 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--# The exported function `expect(op, state)` is equivalent to
--# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
--# `trace(op @ state)` if state is a density matrix, but it's optimised to not
--# make unnecessary extra allocations, or calculate extra factors.
--
--from libc.math cimport sqrt
--
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex conj(double complex x)
--
--from qutip.core.data.base cimport idxint, Data
--from qutip.core.data cimport csr, CSR, Dense
--
--__all__ = [
--    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
--    'expect_super', 'expect_super_csr',
--    'expect_super_csr_dense', 'expect_super_dense',
--]
--
--cdef void _check_shape_ket(Data op, Data state) nogil except *:
--    if (
--        op.shape[1] != state.shape[0]  # Matrix multiplication
--        or state.shape[1] != 1  # State is ket
--        or op.shape[0] != op.shape[1]  # op must be square matrix
--    ):
--        raise ValueError("incorrect input shapes "
--                         + str(op.shape) + " and " + str(state.shape))
--
--cdef void _check_shape_dm(Data op, Data state) nogil except *:
--    if (
--        op.shape[1] != state.shape[0]  # Matrix multiplication
--        or state.shape[0] != state.shape[1]  # State is square 
--        or op.shape[0] != op.shape[1]  # Op is square
--    ):
--        raise ValueError("incorrect input shapes "
--                         + str(op.shape) + " and " + str(state.shape))
--
--cdef void _check_shape_super(Data op, Data state) nogil except *:
--    if state.shape[1] != 1:
--        raise ValueError("expected a column-stacked matrix")
--    if (
--        op.shape[1] != state.shape[0]  # Matrix multiplication
--        or op.shape[0] != op.shape[1]  # Square matrix
--    ):
--        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
--
--
--cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
--    """
--    Perform the operation
--        state.adjoint() @ op @ state
--    for a ket `state` and a square operator `op`.
--    """
--    _check_shape_ket(op, state)
--    cdef double complex out=0, sum=0, mul
--    cdef size_t row, col, ptr_op, ptr_ket
--    for row in range(state.shape[0]):
--        ptr_ket = state.row_index[row]
--        if ptr_ket == state.row_index[row + 1]:
--            continue
--        sum = 0
--        mul = conj(state.data[ptr_ket])
--        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
--            col = op.col_index[ptr_op]
--            ptr_ket = state.row_index[col]
--            if ptr_ket != state.row_index[col + 1]:
--                sum += op.data[ptr_op] * state.data[ptr_ket]
--        out += mul * sum
--    return out
--
--cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
--    """
--    Perform the operation
--        tr(op @ state)
--    for an operator `op` and a density matrix `state`.
--    """
--    _check_shape_dm(op, state)
--    cdef double complex out=0
--    cdef size_t row, col, ptr_op, ptr_state
--    for row in range(op.shape[0]):
--        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
--            col = op.col_index[ptr_op]
--            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
--                if state.col_index[ptr_state] == row:
--                    out += op.data[ptr_op] * state.data[ptr_state]
--                    break
--    return out
--
--
--cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
--    """
--    Perform the operation `tr(op @ state)` where `op` is supplied as a
--    superoperator, and `state` is a column-stacked operator.
--    """
--    _check_shape_super(op, state)
--    cdef double complex out = 0.0
--    cdef size_t row=0, ptr, col
--    cdef size_t n = <size_t> sqrt(state.shape[0])
--    for _ in range(n):
--        for ptr in range(op.row_index[row], op.row_index[row + 1]):
--            col = op.col_index[ptr]
--            if state.row_index[col] != state.row_index[col + 1]:
--                out += op.data[ptr] * state.data[state.row_index[col]]
--        row += n + 1
--    return out
--
--
--cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
--    """
--    Get the expectation value of the operator `op` over the state `state`.  The
--    state can be either a ket or a density matrix.
--
--    The expectation of a state is defined as the operation:
--        state.adjoint() @ op @ state
--    and of a density matrix:
--        tr(op @ state)
--    """
--    if state.shape[1] == 1:
--        return _expect_csr_ket(op, state)
--    return _expect_csr_dm(op, state)
--
--cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
--    _check_shape_ket(op, state)
--    cdef double complex out=0, sum
--    cdef size_t row, ptr
--    for row in range(op.shape[0]):
--        if op.row_index[row] == op.row_index[row + 1]:
--            continue
--        sum = 0
--        for ptr in range(op.row_index[row], op.row_index[row + 1]):
--            sum += op.data[ptr] * state.data[op.col_index[ptr]]
--        out += sum * conj(state.data[row])
--    return out
--
--cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
--    _check_shape_dm(op, state)
--    cdef double complex out=0
--    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
--    row_stride = 1 if state.fortran else state.shape[1]
--    col_stride = state.shape[0] if state.fortran else 1
--    for row in range(op.shape[0]):
--        if op.row_index[row] == op.row_index[row + 1]:
--            continue
--        ptr_state = row * col_stride
--        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
--            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
--    return out
--
--
--cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
--    _check_shape_ket(op, state)
--    cdef double complex out=0, sum
--    cdef size_t row, col, op_row_stride, op_col_stride
--    op_row_stride = 1 if op.fortran else op.shape[1]
--    op_col_stride = op.shape[0] if op.fortran else 1
--
--    for row in range(op.shape[0]):
--        sum = 0
--        for col in range(op.shape[0]):
--            sum += (op.data[row * op_row_stride + col * op_col_stride] *
--                    state.data[col])
--        out += sum * conj(state.data[row])
--    return out
--
--cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
--    _check_shape_dm(op, state)
--    cdef double complex out=0
--    cdef size_t row, col, op_row_stride, op_col_stride
--    cdef size_t state_row_stride, state_col_stride
--    state_row_stride = 1 if state.fortran else state.shape[1]
--    state_col_stride = state.shape[0] if state.fortran else 1
--    op_row_stride = 1 if op.fortran else op.shape[1]
--    op_col_stride = op.shape[0] if op.fortran else 1
--
--    for row in range(op.shape[0]):
--        for col in range(op.shape[1]):
--            out += op.data[row * op_row_stride + col * op_col_stride] * \
--                   state.data[col * state_row_stride + row * state_col_stride]
--    return out
--
--
--cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
--    """
--    Get the expectation value of the operator `op` over the state `state`.  The
--    state can be either a ket or a density matrix.
--
--    The expectation of a state is defined as the operation:
--        state.adjoint() @ op @ state
--    and of a density matrix:
--        tr(op @ state)
--    """
--    if state.shape[1] == 1:
--        return _expect_csr_dense_ket(op, state)
--    return _expect_csr_dense_dm(op, state)
--
--
--cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
--    """
--    Get the expectation value of the operator `op` over the state `state`.  The
--    state can be either a ket or a density matrix.
--
--    The expectation of a state is defined as the operation:
--        state.adjoint() @ op @ state
--    and of a density matrix:
--        tr(op @ state)
--    """
--    if state.shape[1] == 1:
--        return _expect_dense_ket(op, state)
--    return _expect_dense_dense_dm(op, state)
--
--
--cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
--    """
--    Perform the operation `tr(op @ state)` where `op` is supplied as a
--    superoperator, and `state` is a column-stacked operator.
--    """
--    _check_shape_super(op, state)
--    cdef double complex out=0
--    cdef size_t row=0, ptr
--    cdef size_t n = <size_t> sqrt(state.shape[0])
--    for _ in range(n):
--        for ptr in range(op.row_index[row], op.row_index[row + 1]):
--            out += op.data[ptr] * state.data[op.col_index[ptr]]
--        row += n + 1
--    return out
--
--
--cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
--    """
--    Perform the operation `tr(op @ state)` where `op` is supplied as a
--    superoperator, and `state` is a column-stacked operator.
--    """
--    _check_shape_super(op, state)
--    cdef double complex out=0
--    cdef size_t row=0, col, N = state.shape[0]
--    cdef size_t n = <size_t> sqrt(state.shape[0])
--    cdef size_t op_row_stride, op_col_stride
--    op_row_stride = 1 if op.fortran else op.shape[1]
--    op_col_stride = op.shape[0] if op.fortran else 1
--
--    for _ in range(n):
--        for col in range(N):
--            out += op.data[row * op_row_stride + col * op_col_stride] * \
--                   state.data[col]
--        row += n + 1
--    return out
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--expect = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='expect',
--    module=__name__,
--    inputs=('op', 'state'),
--    out=False,
--)
--expect.__doc__ =\
--    """
--    Get the expectation value of the operator `op` over the state `state`.  The
--    state can be either a ket or a density matrix.  Returns a complex number.
--
--    The expectation of a state is defined as the operation:
--        state.adjoint() @ op @ state
--    and of a density matrix:
--        tr(op @ state)
--    """
--expect.add_specialisations([
--    (CSR, CSR, expect_csr),
--    (CSR, Dense, expect_csr_dense),
--    (Dense, Dense, expect_dense),
--], _defer=True)
--
--expect_super = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='expect_super',
--    module=__name__,
--    inputs=('op', 'state'),
--    out=False,
--)
--expect_super.__doc__ =\
--    """
--    Perform the operation `tr(op @ state)` where `op` is supplied as a
--    superoperator, and `state` is a column-stacked operator.  Returns a complex
--    number.
--    """
--expect_super.add_specialisations([
--    (CSR, CSR, expect_super_csr),
--    (CSR, Dense, expect_super_csr_dense),
--    (Dense, Dense, expect_super_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
--
--
--cdef double complex expect_data_dense(Data op, Dense state) except *:
--    cdef double complex out
--    if type(op) is CSR:
--        out = expect_csr_dense(op, state)
--    elif type(op) is Dense:
--        out = expect_dense(op, state)
--    else:
--        out = expect(op, state)
--    return out
--
--
--cdef double complex expect_super_data_dense(Data op, Dense state) except *:
--    cdef double complex out
--    if type(op) is CSR:
--        out = expect_super_csr_dense(op, state)
--    elif type(op) is Dense:
--        out = expect_super_dense(op, state)
--    else:
--        out = expect_super(op, state)
--    return out
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+# The exported function `expect(op, state)` is equivalent to
-+# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
-+# `trace(op @ state)` if state is a density matrix, but it's optimised to not
-+# make unnecessary extra allocations, or calculate extra factors.
-+
-+from libc.math cimport sqrt
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex conj(double complex x)
-+
-+from qutip.core.data.base cimport idxint, Data
-+from qutip.core.data cimport csr, CSR, Dense
-+
-+__all__ = [
-+    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
-+    'expect_super', 'expect_super_csr',
-+    'expect_super_csr_dense', 'expect_super_dense',
-+]
-+
-+cdef void _check_shape_ket(Data op, Data state) nogil except *:
-+    if (
-+        op.shape[1] != state.shape[0]  # Matrix multiplication
-+        or state.shape[1] != 1  # State is ket
-+        or op.shape[0] != op.shape[1]  # op must be square matrix
-+    ):
-+        raise ValueError("incorrect input shapes "
-+                         + str(op.shape) + " and " + str(state.shape))
-+
-+cdef void _check_shape_dm(Data op, Data state) nogil except *:
-+    if (
-+        op.shape[1] != state.shape[0]  # Matrix multiplication
-+        or state.shape[0] != state.shape[1]  # State is square 
-+        or op.shape[0] != op.shape[1]  # Op is square
-+    ):
-+        raise ValueError("incorrect input shapes "
-+                         + str(op.shape) + " and " + str(state.shape))
-+
-+cdef void _check_shape_super(Data op, Data state) nogil except *:
-+    if state.shape[1] != 1:
-+        raise ValueError("expected a column-stacked matrix")
-+    if (
-+        op.shape[1] != state.shape[0]  # Matrix multiplication
-+        or op.shape[0] != op.shape[1]  # Square matrix
-+    ):
-+        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
-+
-+
-+cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
-+    """
-+    Perform the operation
-+        state.adjoint() @ op @ state
-+    for a ket `state` and a square operator `op`.
-+    """
-+    _check_shape_ket(op, state)
-+    cdef double complex out=0, sum=0, mul
-+    cdef size_t row, col, ptr_op, ptr_ket
-+    for row in range(state.shape[0]):
-+        ptr_ket = state.row_index[row]
-+        if ptr_ket == state.row_index[row + 1]:
-+            continue
-+        sum = 0
-+        mul = conj(state.data[ptr_ket])
-+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-+            col = op.col_index[ptr_op]
-+            ptr_ket = state.row_index[col]
-+            if ptr_ket != state.row_index[col + 1]:
-+                sum += op.data[ptr_op] * state.data[ptr_ket]
-+        out += mul * sum
-+    return out
-+
-+cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
-+    """
-+    Perform the operation
-+        tr(op @ state)
-+    for an operator `op` and a density matrix `state`.
-+    """
-+    _check_shape_dm(op, state)
-+    cdef double complex out=0
-+    cdef size_t row, col, ptr_op, ptr_state
-+    for row in range(op.shape[0]):
-+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-+            col = op.col_index[ptr_op]
-+            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
-+                if state.col_index[ptr_state] == row:
-+                    out += op.data[ptr_op] * state.data[ptr_state]
-+                    break
-+    return out
-+
-+
-+cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
-+    """
-+    Perform the operation `tr(op @ state)` where `op` is supplied as a
-+    superoperator, and `state` is a column-stacked operator.
-+    """
-+    _check_shape_super(op, state)
-+    cdef double complex out = 0.0
-+    cdef size_t row=0, ptr, col
-+    cdef size_t n = <size_t> sqrt(state.shape[0])
-+    for _ in range(n):
-+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-+            col = op.col_index[ptr]
-+            if state.row_index[col] != state.row_index[col + 1]:
-+                out += op.data[ptr] * state.data[state.row_index[col]]
-+        row += n + 1
-+    return out
-+
-+
-+cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
-+    """
-+    Get the expectation value of the operator `op` over the state `state`.  The
-+    state can be either a ket or a density matrix.
-+
-+    The expectation of a state is defined as the operation:
-+        state.adjoint() @ op @ state
-+    and of a density matrix:
-+        tr(op @ state)
-+    """
-+    if state.shape[1] == 1:
-+        return _expect_csr_ket(op, state)
-+    return _expect_csr_dm(op, state)
-+
-+cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
-+    _check_shape_ket(op, state)
-+    cdef double complex out=0, sum
-+    cdef size_t row, ptr
-+    for row in range(op.shape[0]):
-+        if op.row_index[row] == op.row_index[row + 1]:
-+            continue
-+        sum = 0
-+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-+            sum += op.data[ptr] * state.data[op.col_index[ptr]]
-+        out += sum * conj(state.data[row])
-+    return out
-+
-+cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
-+    _check_shape_dm(op, state)
-+    cdef double complex out=0
-+    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
-+    row_stride = 1 if state.fortran else state.shape[1]
-+    col_stride = state.shape[0] if state.fortran else 1
-+    for row in range(op.shape[0]):
-+        if op.row_index[row] == op.row_index[row + 1]:
-+            continue
-+        ptr_state = row * col_stride
-+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-+            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
-+    return out
-+
-+
-+cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
-+    _check_shape_ket(op, state)
-+    cdef double complex out=0, sum
-+    cdef size_t row, col, op_row_stride, op_col_stride
-+    op_row_stride = 1 if op.fortran else op.shape[1]
-+    op_col_stride = op.shape[0] if op.fortran else 1
-+
-+    for row in range(op.shape[0]):
-+        sum = 0
-+        for col in range(op.shape[0]):
-+            sum += (op.data[row * op_row_stride + col * op_col_stride] *
-+                    state.data[col])
-+        out += sum * conj(state.data[row])
-+    return out
-+
-+cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
-+    _check_shape_dm(op, state)
-+    cdef double complex out=0
-+    cdef size_t row, col, op_row_stride, op_col_stride
-+    cdef size_t state_row_stride, state_col_stride
-+    state_row_stride = 1 if state.fortran else state.shape[1]
-+    state_col_stride = state.shape[0] if state.fortran else 1
-+    op_row_stride = 1 if op.fortran else op.shape[1]
-+    op_col_stride = op.shape[0] if op.fortran else 1
-+
-+    for row in range(op.shape[0]):
-+        for col in range(op.shape[1]):
-+            out += op.data[row * op_row_stride + col * op_col_stride] * \
-+                   state.data[col * state_row_stride + row * state_col_stride]
-+    return out
-+
-+
-+cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
-+    """
-+    Get the expectation value of the operator `op` over the state `state`.  The
-+    state can be either a ket or a density matrix.
-+
-+    The expectation of a state is defined as the operation:
-+        state.adjoint() @ op @ state
-+    and of a density matrix:
-+        tr(op @ state)
-+    """
-+    if state.shape[1] == 1:
-+        return _expect_csr_dense_ket(op, state)
-+    return _expect_csr_dense_dm(op, state)
-+
-+
-+cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
-+    """
-+    Get the expectation value of the operator `op` over the state `state`.  The
-+    state can be either a ket or a density matrix.
-+
-+    The expectation of a state is defined as the operation:
-+        state.adjoint() @ op @ state
-+    and of a density matrix:
-+        tr(op @ state)
-+    """
-+    if state.shape[1] == 1:
-+        return _expect_dense_ket(op, state)
-+    return _expect_dense_dense_dm(op, state)
-+
-+
-+cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
-+    """
-+    Perform the operation `tr(op @ state)` where `op` is supplied as a
-+    superoperator, and `state` is a column-stacked operator.
-+    """
-+    _check_shape_super(op, state)
-+    cdef double complex out=0
-+    cdef size_t row=0, ptr
-+    cdef size_t n = <size_t> sqrt(state.shape[0])
-+    for _ in range(n):
-+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-+            out += op.data[ptr] * state.data[op.col_index[ptr]]
-+        row += n + 1
-+    return out
-+
-+
-+cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
-+    """
-+    Perform the operation `tr(op @ state)` where `op` is supplied as a
-+    superoperator, and `state` is a column-stacked operator.
-+    """
-+    _check_shape_super(op, state)
-+    cdef double complex out=0
-+    cdef size_t row=0, col, N = state.shape[0]
-+    cdef size_t n = <size_t> sqrt(state.shape[0])
-+    cdef size_t op_row_stride, op_col_stride
-+    op_row_stride = 1 if op.fortran else op.shape[1]
-+    op_col_stride = op.shape[0] if op.fortran else 1
-+
-+    for _ in range(n):
-+        for col in range(N):
-+            out += op.data[row * op_row_stride + col * op_col_stride] * \
-+                   state.data[col]
-+        row += n + 1
-+    return out
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+expect = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='expect',
-+    module=__name__,
-+    inputs=('op', 'state'),
-+    out=False,
-+)
-+expect.__doc__ =\
-+    """
-+    Get the expectation value of the operator `op` over the state `state`.  The
-+    state can be either a ket or a density matrix.  Returns a complex number.
-+
-+    The expectation of a state is defined as the operation:
-+        state.adjoint() @ op @ state
-+    and of a density matrix:
-+        tr(op @ state)
-+    """
-+expect.add_specialisations([
-+    (CSR, CSR, expect_csr),
-+    (CSR, Dense, expect_csr_dense),
-+    (Dense, Dense, expect_dense),
-+], _defer=True)
-+
-+expect_super = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='expect_super',
-+    module=__name__,
-+    inputs=('op', 'state'),
-+    out=False,
-+)
-+expect_super.__doc__ =\
-+    """
-+    Perform the operation `tr(op @ state)` where `op` is supplied as a
-+    superoperator, and `state` is a column-stacked operator.  Returns a complex
-+    number.
-+    """
-+expect_super.add_specialisations([
-+    (CSR, CSR, expect_super_csr),
-+    (CSR, Dense, expect_super_csr_dense),
-+    (Dense, Dense, expect_super_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-+
-+
-+cdef double complex expect_data_dense(Data op, Dense state) except *:
-+    cdef double complex out
-+    if type(op) is CSR:
-+        out = expect_csr_dense(op, state)
-+    elif type(op) is Dense:
-+        out = expect_dense(op, state)
-+    else:
-+        out = expect(op, state)
-+    return out
-+
-+
-+cdef double complex expect_super_data_dense(Data op, Dense state) except *:
-+    cdef double complex out
-+    if type(op) is CSR:
-+        out = expect_super_csr_dense(op, state)
-+    elif type(op) is Dense:
-+        out = expect_super_dense(op, state)
-+    else:
-+        out = expect_super(op, state)
-+    return out
-diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
-index 27586d16..5d3bfc61 100644
---- a/qutip/core/data/expm.py
-+++ b/qutip/core/data/expm.py
-@@ -1,93 +1,93 @@
--import numpy as np
--import scipy.sparse.linalg
--import scipy.linalg
--
--from .dense import Dense
--from .csr import CSR
--from .properties import isdiag_csr
--from qutip.settings import settings
--from .base import idxint_dtype
--
--__all__ = [
--    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
--    'logm', 'logm_dense',
--]
--
--
--def expm_csr(matrix: CSR) -> CSR:
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("can only exponentiate square matrix")
--    if isdiag_csr(matrix):
--        matrix_sci = matrix.as_scipy()
--        data = np.ones(matrix.shape[0], dtype=np.complex128)
--        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
--        return CSR(
--            (
--                data,
--                np.arange(matrix.shape[0], dtype=idxint_dtype),
--                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
--            ),
--            shape=matrix.shape,
--            copy=False,
--        )
--    # The scipy solvers for the Pade approximant are more efficient with the
--    # CSC format than the CSR one.
--    csc = matrix.as_scipy().tocsc()
--    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
--               tidyup=settings.core['auto_tidyup'])
--
--
--def expm_csr_dense(matrix: CSR) -> Dense:
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("can only exponentiate square matrix")
--    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
--
--
--def expm_dense(matrix: Dense) -> Dense:
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("can only exponentiate square matrix")
--    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--
--expm = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='expm',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
--expm.add_specialisations([
--    (CSR, CSR, expm_csr),
--    (CSR, Dense, expm_csr_dense),
--    (Dense, Dense, expm_dense),
--], _defer=True)
--
--
--def logm_dense(matrix: Dense) -> Dense:
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("can only compute logarithm square matrix")
--    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
--
--
--logm = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='logm',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
--logm.add_specialisations([
--    (Dense, Dense, logm_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+import numpy as np
-+import scipy.sparse.linalg
-+import scipy.linalg
-+
-+from .dense import Dense
-+from .csr import CSR
-+from .properties import isdiag_csr
-+from qutip.settings import settings
-+from .base import idxint_dtype
-+
-+__all__ = [
-+    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
-+    'logm', 'logm_dense',
-+]
-+
-+
-+def expm_csr(matrix: CSR) -> CSR:
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("can only exponentiate square matrix")
-+    if isdiag_csr(matrix):
-+        matrix_sci = matrix.as_scipy()
-+        data = np.ones(matrix.shape[0], dtype=np.complex128)
-+        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
-+        return CSR(
-+            (
-+                data,
-+                np.arange(matrix.shape[0], dtype=idxint_dtype),
-+                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
-+            ),
-+            shape=matrix.shape,
-+            copy=False,
-+        )
-+    # The scipy solvers for the Pade approximant are more efficient with the
-+    # CSC format than the CSR one.
-+    csc = matrix.as_scipy().tocsc()
-+    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
-+               tidyup=settings.core['auto_tidyup'])
-+
-+
-+def expm_csr_dense(matrix: CSR) -> Dense:
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("can only exponentiate square matrix")
-+    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
-+
-+
-+def expm_dense(matrix: Dense) -> Dense:
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("can only exponentiate square matrix")
-+    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+
-+expm = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='expm',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
-+expm.add_specialisations([
-+    (CSR, CSR, expm_csr),
-+    (CSR, Dense, expm_csr_dense),
-+    (Dense, Dense, expm_dense),
-+], _defer=True)
-+
-+
-+def logm_dense(matrix: Dense) -> Dense:
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("can only compute logarithm square matrix")
-+    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
-+
-+
-+logm = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='logm',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
-+logm.add_specialisations([
-+    (Dense, Dense, logm_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/inner.pxd b/qutip/core/data/inner.pxd
-index 1d5000dd..2560e435 100644
---- a/qutip/core/data/inner.pxd
-+++ b/qutip/core/data/inner.pxd
-@@ -1,6 +1,6 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--
--cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
--cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+
-+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
-+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
-diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
-index 94919700..47331c71 100644
---- a/qutip/core/data/inner.pyx
-+++ b/qutip/core/data/inner.pyx
-@@ -1,286 +1,286 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex conj(double complex x)
--
--from qutip.core.data.base cimport idxint, Data
--from qutip.core.data cimport csr, dense
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--from qutip.core.data.matmul cimport matmul_dense
--
--__all__ = [
--    'inner', 'inner_csr', 'inner_dense',
--    'inner_op', 'inner_op_csr', 'inner_op_dense',
--]
--
--
--cdef void _check_shape_inner(Data left, Data right) nogil except *:
--    if (
--        (left.shape[0] != 1 and left.shape[1] != 1)
--        or right.shape[1] != 1
--    ):
--        raise ValueError(
--            "incompatible matrix shapes "
--            + str(left.shape)
--            + " and "
--            + str(right.shape)
--        )
--
--cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
--    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
--    cdef bint left_op = (
--        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
--        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
--    )
--    cdef bint op_right = op.shape[1] == right.shape[0]
--    cdef bint right_shape = right.shape[1] == 1
--    if not (left_shape and left_op and op_right and right_shape):
--        raise ValueError("".join([
--            "incompatible matrix shapes ",
--            str(left.shape),
--            ", ",
--            str(op.shape),
--            " and ",
--            str(right.shape),
--        ]))
--
--cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
--    cdef size_t col, ptr_bra, ptr_ket
--    cdef double complex out = 0
--    # We actually don't care if left is sorted or not.
--    for ptr_bra in range(csr.nnz(left)):
--        col = left.col_index[ptr_bra]
--        ptr_ket = right.row_index[col]
--        if right.row_index[col + 1] != ptr_ket:
--            out += left.data[ptr_bra] * right.data[ptr_ket]
--    return out
--
--cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
--    cdef size_t row, ptr_l, ptr_r
--    cdef double complex out = 0
--    for row in range(left.shape[0]):
--        ptr_l = left.row_index[row]
--        ptr_r = right.row_index[row]
--        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
--            out += conj(left.data[ptr_l]) * right.data[ptr_r]
--    return out
--
--cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
--    """
--    Compute the complex inner product <left|right>.  The shape of `left` is
--    used to determine if it has been supplied as a ket or a bra.  The result of
--    this function will be identical if passed `left` or `adjoint(left)`.
--
--    The parameter `scalar_is_ket` is only intended for the case where `left`
--    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
--    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
--    all other times.
--    """
--    _check_shape_inner(left, right)
--    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
--        if csr.nnz(left) and csr.nnz(right):
--            return (
--                conj(left.data[0]) * right.data[0] if scalar_is_ket
--                else left.data[0] * right.data[0]
--            )
--        return 0
--    if left.shape[0] == 1:
--        return _inner_csr_bra_ket(left, right)
--    return _inner_csr_ket_ket(left, right)
--
--cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
--    """
--    Compute the complex inner product <left|right>.  The shape of `left` is
--    used to determine if it has been supplied as a ket or a bra.  The result of
--    this function will be identical if passed `left` or `adjoint(left)`.
--
--    The parameter `scalar_is_ket` is only intended for the case where `left`
--    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
--    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
--    all other times.
--    """
--    _check_shape_inner(left, right)
--    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
--        return (
--                conj(left.data[0]) * right.data[0] if scalar_is_ket
--                else left.data[0] * right.data[0]
--        )
--    cdef double complex out = 0
--    cdef size_t i
--    if left.shape[0] == 1:
--        for i in range(right.shape[0]):
--            out += left.data[i] * right.data[i]
--    else:
--        for i in range(right.shape[0]):
--            out += conj(left.data[i]) * right.data[i]
--    return out
--
--
--cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
--    cdef size_t ptr_l, ptr_op, ptr_r, row, col
--    cdef double complex sum, out=0
--    # left does not need to be sorted.
--    for ptr_l in range(csr.nnz(left)):
--        row = left.col_index[ptr_l]
--        sum = 0
--        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
--            col = op.col_index[ptr_op]
--            ptr_r = right.row_index[col]
--            if ptr_r != right.row_index[col + 1]:
--                sum += op.data[ptr_op] * right.data[ptr_r]
--        out += left.data[ptr_l] * sum
--    return out
--
--cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
--    cdef size_t ptr_l, ptr_op, ptr_r, row, col
--    cdef double complex sum, out=0
--    for row in range(op.shape[0]):
--        ptr_l = left.row_index[row]
--        if left.row_index[row + 1] == ptr_l:
--            continue
--        sum = 0
--        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
--            col = op.col_index[ptr_op]
--            ptr_r = right.row_index[col]
--            if ptr_r != right.row_index[col + 1]:
--                sum += op.data[ptr_op] * right.data[ptr_r]
--        out += conj(left.data[ptr_l]) * sum
--    return out
--
--cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
--                                  bint scalar_is_ket=False) nogil except *:
--    """
--    Compute the complex inner product <left|op|right>.  The shape of `left` is
--    used to determine if it has been supplied as a ket or a bra.  The result of
--    this function will be identical if passed `left` or `adjoint(left)`.
--
--    The parameter `scalar_is_ket` is only intended for the case where `left`
--    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
--    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
--    all other times.
--    """
--    _check_shape_inner_op(left, op, right)
--    cdef double complex l
--    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
--        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
--            return 0
--        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
--        return l * op.data[0] * right.data[0]
--    if left.shape[0] == 1:
--        return _inner_op_csr_bra_ket(left, op, right)
--    return _inner_op_csr_ket_ket(left, op, right)
--
--cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
--                                  bint scalar_is_ket=False) except *:
--    """
--    Compute the complex inner product <left|op|right>.  The shape of `left` is
--    used to determine if it has been supplied as a ket or a bra.  The result of
--    this function will be identical if passed `left` or `adjoint(left)`.
--
--    The parameter `scalar_is_ket` is only intended for the case where `left`
--    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
--    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
--    all other times.
--    """
--    _check_shape_inner_op(left, op, right)
--    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--inner = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=False),
--    ]),
--    name='inner',
--    module=__name__,
--    inputs=('left', 'right'),
--    out=False,
--)
--inner.__doc__ =\
--    """
--    Compute the complex inner product <left|right>.  Return the complex value.
--
--    The shape of `left` is used to determine if it has been supplied as a ket
--    or a bra.  The result of this function will be identical if passed `left`
--    or `adjoint(left)`.
--
--    The parameter `scalar_is_ket` is only intended for the case where `left`
--    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
--    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
--    all other times.
--
--    Parameters
--    ----------
--    left : Data
--        The left operand as either a bra or a ket matrix.
--
--    right : Data
--        The right operand as a ket matrix.
--
--    scalar_is_ket : bool, optional (False)
--        If `False`, then `left` is assumed to be a bra if it is
--        one-dimensional.  If `True`, then it is assumed to be a ket.  This
--        parameter is ignored if `left` and `right` are not one-dimensional.
--    """
--inner.add_specialisations([
--    (CSR, CSR, inner_csr),
--    (Dense, Dense, inner_dense),
--], _defer=True)
--
--inner_op = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=False),
--    ]),
--    name='inner_op',
--    module=__name__,
--    inputs=('left', 'op', 'right'),
--    out=False,
--)
--inner_op.__doc__ =\
--    """
--    Compute the complex inner product <left|op|right>.  Return the complex
--    value.  This operation is also known as taking a matrix element.
--
--    The shape of `left` is used to determine if it has been supplied as a ket
--    or a bra.  The result of this function will be identical if passed `left`
--    or `adjoint(left)`.
--
--    The parameter `scalar_is_ket` is only intended for the case where `left`
--    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
--    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
--    all other times.
--
--    Parameters
--    ----------
--    left : Data
--        The left operand as either a bra or a ket matrix.
--
--    op : Data
--        The operator of which to take the matrix element.  Must have dimensions
--        which match `left` and `right`.
--
--    right : Data
--        The right operand as a ket matrix.
--
--    scalar_is_ket : bool, optional (False)
--        If `False`, then `left` is assumed to be a bra if it is
--        one-dimensional.  If `True`, then it is assumed to be a ket.  This
--        parameter is ignored if `left` and `right` are not one-dimensional.
--    """
--inner_op.add_specialisations([
--    (CSR, CSR, CSR, inner_op_csr),
--    (Dense, Dense, Dense, inner_op_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex conj(double complex x)
-+
-+from qutip.core.data.base cimport idxint, Data
-+from qutip.core.data cimport csr, dense
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data.matmul cimport matmul_dense
-+
-+__all__ = [
-+    'inner', 'inner_csr', 'inner_dense',
-+    'inner_op', 'inner_op_csr', 'inner_op_dense',
-+]
-+
-+
-+cdef void _check_shape_inner(Data left, Data right) nogil except *:
-+    if (
-+        (left.shape[0] != 1 and left.shape[1] != 1)
-+        or right.shape[1] != 1
-+    ):
-+        raise ValueError(
-+            "incompatible matrix shapes "
-+            + str(left.shape)
-+            + " and "
-+            + str(right.shape)
-+        )
-+
-+cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
-+    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
-+    cdef bint left_op = (
-+        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
-+        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
-+    )
-+    cdef bint op_right = op.shape[1] == right.shape[0]
-+    cdef bint right_shape = right.shape[1] == 1
-+    if not (left_shape and left_op and op_right and right_shape):
-+        raise ValueError("".join([
-+            "incompatible matrix shapes ",
-+            str(left.shape),
-+            ", ",
-+            str(op.shape),
-+            " and ",
-+            str(right.shape),
-+        ]))
-+
-+cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
-+    cdef size_t col, ptr_bra, ptr_ket
-+    cdef double complex out = 0
-+    # We actually don't care if left is sorted or not.
-+    for ptr_bra in range(csr.nnz(left)):
-+        col = left.col_index[ptr_bra]
-+        ptr_ket = right.row_index[col]
-+        if right.row_index[col + 1] != ptr_ket:
-+            out += left.data[ptr_bra] * right.data[ptr_ket]
-+    return out
-+
-+cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
-+    cdef size_t row, ptr_l, ptr_r
-+    cdef double complex out = 0
-+    for row in range(left.shape[0]):
-+        ptr_l = left.row_index[row]
-+        ptr_r = right.row_index[row]
-+        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
-+            out += conj(left.data[ptr_l]) * right.data[ptr_r]
-+    return out
-+
-+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
-+    """
-+    Compute the complex inner product <left|right>.  The shape of `left` is
-+    used to determine if it has been supplied as a ket or a bra.  The result of
-+    this function will be identical if passed `left` or `adjoint(left)`.
-+
-+    The parameter `scalar_is_ket` is only intended for the case where `left`
-+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-+    all other times.
-+    """
-+    _check_shape_inner(left, right)
-+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
-+        if csr.nnz(left) and csr.nnz(right):
-+            return (
-+                conj(left.data[0]) * right.data[0] if scalar_is_ket
-+                else left.data[0] * right.data[0]
-+            )
-+        return 0
-+    if left.shape[0] == 1:
-+        return _inner_csr_bra_ket(left, right)
-+    return _inner_csr_ket_ket(left, right)
-+
-+cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
-+    """
-+    Compute the complex inner product <left|right>.  The shape of `left` is
-+    used to determine if it has been supplied as a ket or a bra.  The result of
-+    this function will be identical if passed `left` or `adjoint(left)`.
-+
-+    The parameter `scalar_is_ket` is only intended for the case where `left`
-+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-+    all other times.
-+    """
-+    _check_shape_inner(left, right)
-+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
-+        return (
-+                conj(left.data[0]) * right.data[0] if scalar_is_ket
-+                else left.data[0] * right.data[0]
-+        )
-+    cdef double complex out = 0
-+    cdef size_t i
-+    if left.shape[0] == 1:
-+        for i in range(right.shape[0]):
-+            out += left.data[i] * right.data[i]
-+    else:
-+        for i in range(right.shape[0]):
-+            out += conj(left.data[i]) * right.data[i]
-+    return out
-+
-+
-+cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
-+    cdef size_t ptr_l, ptr_op, ptr_r, row, col
-+    cdef double complex sum, out=0
-+    # left does not need to be sorted.
-+    for ptr_l in range(csr.nnz(left)):
-+        row = left.col_index[ptr_l]
-+        sum = 0
-+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-+            col = op.col_index[ptr_op]
-+            ptr_r = right.row_index[col]
-+            if ptr_r != right.row_index[col + 1]:
-+                sum += op.data[ptr_op] * right.data[ptr_r]
-+        out += left.data[ptr_l] * sum
-+    return out
-+
-+cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
-+    cdef size_t ptr_l, ptr_op, ptr_r, row, col
-+    cdef double complex sum, out=0
-+    for row in range(op.shape[0]):
-+        ptr_l = left.row_index[row]
-+        if left.row_index[row + 1] == ptr_l:
-+            continue
-+        sum = 0
-+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-+            col = op.col_index[ptr_op]
-+            ptr_r = right.row_index[col]
-+            if ptr_r != right.row_index[col + 1]:
-+                sum += op.data[ptr_op] * right.data[ptr_r]
-+        out += conj(left.data[ptr_l]) * sum
-+    return out
-+
-+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
-+                                  bint scalar_is_ket=False) nogil except *:
-+    """
-+    Compute the complex inner product <left|op|right>.  The shape of `left` is
-+    used to determine if it has been supplied as a ket or a bra.  The result of
-+    this function will be identical if passed `left` or `adjoint(left)`.
-+
-+    The parameter `scalar_is_ket` is only intended for the case where `left`
-+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-+    all other times.
-+    """
-+    _check_shape_inner_op(left, op, right)
-+    cdef double complex l
-+    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
-+        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
-+            return 0
-+        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
-+        return l * op.data[0] * right.data[0]
-+    if left.shape[0] == 1:
-+        return _inner_op_csr_bra_ket(left, op, right)
-+    return _inner_op_csr_ket_ket(left, op, right)
-+
-+cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
-+                                  bint scalar_is_ket=False) except *:
-+    """
-+    Compute the complex inner product <left|op|right>.  The shape of `left` is
-+    used to determine if it has been supplied as a ket or a bra.  The result of
-+    this function will be identical if passed `left` or `adjoint(left)`.
-+
-+    The parameter `scalar_is_ket` is only intended for the case where `left`
-+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-+    all other times.
-+    """
-+    _check_shape_inner_op(left, op, right)
-+    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+inner = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=False),
-+    ]),
-+    name='inner',
-+    module=__name__,
-+    inputs=('left', 'right'),
-+    out=False,
-+)
-+inner.__doc__ =\
-+    """
-+    Compute the complex inner product <left|right>.  Return the complex value.
-+
-+    The shape of `left` is used to determine if it has been supplied as a ket
-+    or a bra.  The result of this function will be identical if passed `left`
-+    or `adjoint(left)`.
-+
-+    The parameter `scalar_is_ket` is only intended for the case where `left`
-+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-+    all other times.
-+
-+    Parameters
-+    ----------
-+    left : Data
-+        The left operand as either a bra or a ket matrix.
-+
-+    right : Data
-+        The right operand as a ket matrix.
-+
-+    scalar_is_ket : bool, optional (False)
-+        If `False`, then `left` is assumed to be a bra if it is
-+        one-dimensional.  If `True`, then it is assumed to be a ket.  This
-+        parameter is ignored if `left` and `right` are not one-dimensional.
-+    """
-+inner.add_specialisations([
-+    (CSR, CSR, inner_csr),
-+    (Dense, Dense, inner_dense),
-+], _defer=True)
-+
-+inner_op = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=False),
-+    ]),
-+    name='inner_op',
-+    module=__name__,
-+    inputs=('left', 'op', 'right'),
-+    out=False,
-+)
-+inner_op.__doc__ =\
-+    """
-+    Compute the complex inner product <left|op|right>.  Return the complex
-+    value.  This operation is also known as taking a matrix element.
-+
-+    The shape of `left` is used to determine if it has been supplied as a ket
-+    or a bra.  The result of this function will be identical if passed `left`
-+    or `adjoint(left)`.
-+
-+    The parameter `scalar_is_ket` is only intended for the case where `left`
-+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-+    all other times.
-+
-+    Parameters
-+    ----------
-+    left : Data
-+        The left operand as either a bra or a ket matrix.
-+
-+    op : Data
-+        The operator of which to take the matrix element.  Must have dimensions
-+        which match `left` and `right`.
-+
-+    right : Data
-+        The right operand as a ket matrix.
-+
-+    scalar_is_ket : bool, optional (False)
-+        If `False`, then `left` is assumed to be a bra if it is
-+        one-dimensional.  If `True`, then it is assumed to be a ket.  This
-+        parameter is ignored if `left` and `right` are not one-dimensional.
-+    """
-+inner_op.add_specialisations([
-+    (CSR, CSR, CSR, inner_op_csr),
-+    (Dense, Dense, Dense, inner_op_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/kron.pxd b/qutip/core/data/kron.pxd
-index 6caa2619..89f717f8 100644
---- a/qutip/core/data/kron.pxd
-+++ b/qutip/core/data/kron.pxd
-@@ -1,5 +1,5 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--
--cpdef CSR kron_csr(CSR left, CSR right)
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+
-+cpdef CSR kron_csr(CSR left, CSR right)
-diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
-index fd94adc3..5cd9d569 100644
---- a/qutip/core/data/kron.pyx
-+++ b/qutip/core/data/kron.pyx
-@@ -1,91 +1,91 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--cimport cython
--
--from qutip.core.data.base cimport idxint
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--from qutip.core.data cimport csr
--import numpy
--
--__all__ = [
--    'kron', 'kron_csr', 'kron_dense'
--]
--
--
--@cython.overflowcheck(True)
--cdef idxint _mul_checked(idxint a, idxint b):
--    return a * b
--
--
--cpdef Dense kron_dense(Dense left, Dense right):
--    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
--
--
--cpdef CSR kron_csr(CSR left, CSR right):
--    """Kronecker product of two CSR matrices."""
--    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
--    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
--    cdef idxint row_l, row_r, row_out
--    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
--    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
--    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
--                             _mul_checked(ncols_l, ncols_r),
--                             _mul_checked(csr.nnz(left), csr.nnz(right)))
--    with nogil:
--        row_out = 0
--        out.row_index[row_out] = 0
--        for row_l in range(nrows_l):
--            ptr_start_l = left.row_index[row_l]
--            ptr_end_l = left.row_index[row_l + 1]
--            dist_l = ptr_end_l - ptr_start_l
--
--            for row_r in range(nrows_r):
--                ptr_start_r = right.row_index[row_r]
--                ptr_end_r = right.row_index[row_r + 1]
--                dist_r = ptr_end_r - ptr_start_r
--
--                ptr_start_out = out.row_index[row_out]
--                ptr_end_out = ptr_start_out + dist_r
--
--                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
--                row_out += 1
--
--                for ptr_l in range(ptr_start_l, ptr_end_l):
--                    ptr_r = ptr_start_r
--                    for ptr_out in range(ptr_start_out, ptr_end_out):
--                        out.col_index[ptr_out] =\
--                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
--                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
--                        ptr_r += 1
--
--                    ptr_start_out += dist_r
--                    ptr_end_out += dist_r
--    return out
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--kron = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='kron',
--    module=__name__,
--    inputs=('left', 'right'),
--    out=True,
--)
--kron.__doc__ =\
--    """
--    Compute the Kronecker product of two matrices.  This is used to represent
--    quantum tensor products of vector spaces.
--    """
--kron.add_specialisations([
--    (CSR, CSR, CSR, kron_csr),
--    (Dense, Dense, Dense, kron_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+cimport cython
-+
-+from qutip.core.data.base cimport idxint
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data cimport csr
-+import numpy
-+
-+__all__ = [
-+    'kron', 'kron_csr', 'kron_dense'
-+]
-+
-+
-+@cython.overflowcheck(True)
-+cdef idxint _mul_checked(idxint a, idxint b):
-+    return a * b
-+
-+
-+cpdef Dense kron_dense(Dense left, Dense right):
-+    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
-+
-+
-+cpdef CSR kron_csr(CSR left, CSR right):
-+    """Kronecker product of two CSR matrices."""
-+    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
-+    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
-+    cdef idxint row_l, row_r, row_out
-+    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
-+    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
-+    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
-+                             _mul_checked(ncols_l, ncols_r),
-+                             _mul_checked(csr.nnz(left), csr.nnz(right)))
-+    with nogil:
-+        row_out = 0
-+        out.row_index[row_out] = 0
-+        for row_l in range(nrows_l):
-+            ptr_start_l = left.row_index[row_l]
-+            ptr_end_l = left.row_index[row_l + 1]
-+            dist_l = ptr_end_l - ptr_start_l
-+
-+            for row_r in range(nrows_r):
-+                ptr_start_r = right.row_index[row_r]
-+                ptr_end_r = right.row_index[row_r + 1]
-+                dist_r = ptr_end_r - ptr_start_r
-+
-+                ptr_start_out = out.row_index[row_out]
-+                ptr_end_out = ptr_start_out + dist_r
-+
-+                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
-+                row_out += 1
-+
-+                for ptr_l in range(ptr_start_l, ptr_end_l):
-+                    ptr_r = ptr_start_r
-+                    for ptr_out in range(ptr_start_out, ptr_end_out):
-+                        out.col_index[ptr_out] =\
-+                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
-+                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
-+                        ptr_r += 1
-+
-+                    ptr_start_out += dist_r
-+                    ptr_end_out += dist_r
-+    return out
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+kron = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='kron',
-+    module=__name__,
-+    inputs=('left', 'right'),
-+    out=True,
-+)
-+kron.__doc__ =\
-+    """
-+    Compute the Kronecker product of two matrices.  This is used to represent
-+    quantum tensor products of vector spaces.
-+    """
-+kron.add_specialisations([
-+    (CSR, CSR, CSR, kron_csr),
-+    (Dense, Dense, Dense, kron_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/linalg.py b/qutip/core/data/linalg.py
-index f5507738..e3847257 100644
---- a/qutip/core/data/linalg.py
-+++ b/qutip/core/data/linalg.py
-@@ -1,55 +1,55 @@
--import scipy.linalg
--import scipy.sparse
--from .dense import Dense
--from .csr import CSR
--
--__all__ = ['inv', 'inv_csr', 'inv_dense']
--
--
--def inv_dense(data):
--    """Compute the inverse of a matrix"""
--    if not isinstance(data, Dense):
--        raise TypeError("expected data in Dense format but got "
--                        + str(type(data)))
--    if data.shape[0] != data.shape[1]:
--        raise ValueError('Cannot compute the matrix inverse'
--                         ' of a nonsquare matrix')
--    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
--
--
--def inv_csr(data):
--    """Compute the inverse of a sparse matrix"""
--    if not isinstance(data, CSR):
--        raise TypeError("expected data in CSR format but got "
--                        + str(type(data)))
--    if data.shape[0] != data.shape[1]:
--        raise ValueError('Cannot compute the matrix inverse '
--                         'of a nonsquare matrix')
--    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
--    # scipy.sparse.linalg.inv can return dense or sparse arrays.
--    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--
--inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
--inv.__doc__ =\
--    """
--    Return matrix inverse for a data-layer object.
--
--    Parameters
--    ----------
--    data : Data
--        Input matrix
--
--    Returns
--    -------
--    inverse : Data
--        Inverse of data
--    """
--inv.add_specialisations([
--    (CSR, CSR, inv_csr),
--    (Dense, Dense, inv_dense),
--], _defer=True)
--
--del _Dispatcher
-+import scipy.linalg
-+import scipy.sparse
-+from .dense import Dense
-+from .csr import CSR
-+
-+__all__ = ['inv', 'inv_csr', 'inv_dense']
-+
-+
-+def inv_dense(data):
-+    """Compute the inverse of a matrix"""
-+    if not isinstance(data, Dense):
-+        raise TypeError("expected data in Dense format but got "
-+                        + str(type(data)))
-+    if data.shape[0] != data.shape[1]:
-+        raise ValueError('Cannot compute the matrix inverse'
-+                         ' of a nonsquare matrix')
-+    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
-+
-+
-+def inv_csr(data):
-+    """Compute the inverse of a sparse matrix"""
-+    if not isinstance(data, CSR):
-+        raise TypeError("expected data in CSR format but got "
-+                        + str(type(data)))
-+    if data.shape[0] != data.shape[1]:
-+        raise ValueError('Cannot compute the matrix inverse '
-+                         'of a nonsquare matrix')
-+    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
-+    # scipy.sparse.linalg.inv can return dense or sparse arrays.
-+    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+
-+inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
-+inv.__doc__ =\
-+    """
-+    Return matrix inverse for a data-layer object.
-+
-+    Parameters
-+    ----------
-+    data : Data
-+        Input matrix
-+
-+    Returns
-+    -------
-+    inverse : Data
-+        Inverse of data
-+    """
-+inv.add_specialisations([
-+    (CSR, CSR, inv_csr),
-+    (Dense, Dense, inv_dense),
-+], _defer=True)
-+
-+del _Dispatcher
-diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
-index 8b34d656..69f1ddcb 100644
---- a/qutip/core/data/make.py
-+++ b/qutip/core/data/make.py
-@@ -1,101 +1,101 @@
--from .dispatch import Dispatcher as _Dispatcher
--from . import csr, dense, CSR, Dense
--
--__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
--
--
--def _diag_signature(diagonals, offsets=0, shape=None):
--    """
--    Construct a matrix from diagonals and their offsets.  Using this
--    function in single-argument form produces a square matrix with the given
--    values on the main diagonal.
--    With lists of diagonals and offsets, the matrix will be the smallest
--    possible square matrix if shape is not given, but in all cases the
--    diagonals must fit exactly with no extra or missing elements. Duplicated
--    diagonals will be summed together in the output.
--
--    Parameters
--    ----------
--    diagonals : sequence of array_like of complex or array_like of complex
--        The entries (including zeros) that should be placed on the diagonals in
--        the output matrix.  Each entry must have enough entries in it to fill
--        the relevant diagonal and no more.
--    offsets : sequence of integer or integer, optional
--        The indices of the diagonals.  `offsets[i]` is the location of the
--        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
--        values are above the main diagonal and negative ones are below the main
--        diagonal.
--    shape : tuple, optional
--        The shape of the output as (``rows``, ``columns``).  The result does
--        not need to be square, but the diagonals must be of the correct length
--        to fit in exactly.
--    """
--    pass
--
--
--diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
--diag.add_specialisations([
--    (CSR, csr.diags),
--    (Dense, dense.diags),
--], _defer=True)
--
--del _diag_signature
--
--
--def one_element_csr(shape, position, value=1.0):
--    """
--    Create a matrix with only one nonzero element.
--
--    Parameters
--    ----------
--    shape : tuple
--        The shape of the output as (``rows``, ``columns``).
--
--    position : tuple
--        The position of the non zero in the matrix as (``rows``, ``columns``).
--
--    value : complex, optional
--        The value of the non-null element.
--    """
--    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
--        raise ValueError("Position of the elements out of bound: " +
--                         str(position) + " in " + str(shape))
--    data = csr.empty(*shape, 1)
--    sci = data.as_scipy(full=True)
--    sci.data[0] = value
--    sci.indices[0] = position[1]
--    sci.indptr[:position[0]+1] = 0
--    sci.indptr[position[0]+1:] = 1
--    return data
--
--
--def one_element_dense(shape, position, value=1.0):
--    """
--    Create a matrix with only one nonzero element.
--
--    Parameters
--    ----------
--    shape : tuple
--        The shape of the output as (``rows``, ``columns``).
--
--    position : tuple
--        The position of the non zero in the matrix as (``rows``, ``columns``).
--
--    value : complex, optional
--        The value of the non-null element.
--    """
--    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
--        raise ValueError("Position of the elements out of bound: " +
--                         str(position) + " in " + str(shape))
--    data = dense.zeros(*shape, 1)
--    nda = data.as_ndarray()
--    nda[position] = value
--    return data
--
--
--one_element = _Dispatcher(one_element_dense, name='one_element',
--                          inputs=(), out=True)
--one_element.add_specialisations([
--    (CSR, one_element_csr),
--    (Dense, one_element_dense),
--], _defer=True)
-+from .dispatch import Dispatcher as _Dispatcher
-+from . import csr, dense, CSR, Dense
-+
-+__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
-+
-+
-+def _diag_signature(diagonals, offsets=0, shape=None):
-+    """
-+    Construct a matrix from diagonals and their offsets.  Using this
-+    function in single-argument form produces a square matrix with the given
-+    values on the main diagonal.
-+    With lists of diagonals and offsets, the matrix will be the smallest
-+    possible square matrix if shape is not given, but in all cases the
-+    diagonals must fit exactly with no extra or missing elements. Duplicated
-+    diagonals will be summed together in the output.
-+
-+    Parameters
-+    ----------
-+    diagonals : sequence of array_like of complex or array_like of complex
-+        The entries (including zeros) that should be placed on the diagonals in
-+        the output matrix.  Each entry must have enough entries in it to fill
-+        the relevant diagonal and no more.
-+    offsets : sequence of integer or integer, optional
-+        The indices of the diagonals.  `offsets[i]` is the location of the
-+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-+        values are above the main diagonal and negative ones are below the main
-+        diagonal.
-+    shape : tuple, optional
-+        The shape of the output as (``rows``, ``columns``).  The result does
-+        not need to be square, but the diagonals must be of the correct length
-+        to fit in exactly.
-+    """
-+    pass
-+
-+
-+diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
-+diag.add_specialisations([
-+    (CSR, csr.diags),
-+    (Dense, dense.diags),
-+], _defer=True)
-+
-+del _diag_signature
-+
-+
-+def one_element_csr(shape, position, value=1.0):
-+    """
-+    Create a matrix with only one nonzero element.
-+
-+    Parameters
-+    ----------
-+    shape : tuple
-+        The shape of the output as (``rows``, ``columns``).
-+
-+    position : tuple
-+        The position of the non zero in the matrix as (``rows``, ``columns``).
-+
-+    value : complex, optional
-+        The value of the non-null element.
-+    """
-+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
-+        raise ValueError("Position of the elements out of bound: " +
-+                         str(position) + " in " + str(shape))
-+    data = csr.empty(*shape, 1)
-+    sci = data.as_scipy(full=True)
-+    sci.data[0] = value
-+    sci.indices[0] = position[1]
-+    sci.indptr[:position[0]+1] = 0
-+    sci.indptr[position[0]+1:] = 1
-+    return data
-+
-+
-+def one_element_dense(shape, position, value=1.0):
-+    """
-+    Create a matrix with only one nonzero element.
-+
-+    Parameters
-+    ----------
-+    shape : tuple
-+        The shape of the output as (``rows``, ``columns``).
-+
-+    position : tuple
-+        The position of the non zero in the matrix as (``rows``, ``columns``).
-+
-+    value : complex, optional
-+        The value of the non-null element.
-+    """
-+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
-+        raise ValueError("Position of the elements out of bound: " +
-+                         str(position) + " in " + str(shape))
-+    data = dense.zeros(*shape, 1)
-+    nda = data.as_ndarray()
-+    nda[position] = value
-+    return data
-+
-+
-+one_element = _Dispatcher(one_element_dense, name='one_element',
-+                          inputs=(), out=True)
-+one_element.add_specialisations([
-+    (CSR, one_element_csr),
-+    (Dense, one_element_dense),
-+], _defer=True)
-diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
-index 54d21798..b9d85556 100644
---- a/qutip/core/data/matmul.pxd
-+++ b/qutip/core/data/matmul.pxd
-@@ -1,14 +1,14 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--from qutip.core.data.base cimport Data
--
--cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
--cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
--cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
--cdef Dense matmul_data_dense(Data left, Dense right)
--cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
--
--cpdef Dense multiply_dense(Dense left, Dense right)
--cpdef CSR multiply_csr(CSR left, CSR right)
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data.base cimport Data
-+
-+cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
-+cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
-+cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
-+cdef Dense matmul_data_dense(Data left, Dense right)
-+cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
-+
-+cpdef Dense multiply_dense(Dense left, Dense right)
-+cpdef CSR multiply_csr(CSR left, CSR right)
-diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
-index 1d053879..d2d67e97 100644
---- a/qutip/core/data/matmul.pyx
-+++ b/qutip/core/data/matmul.pyx
-@@ -1,474 +1,474 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.string cimport memset, memcpy
--from libc.math cimport fabs
--
--import warnings
--from qutip.settings import settings
--
--cimport cython
--
--from cpython cimport mem
--
--import numpy as np
--cimport numpy as cnp
--from scipy.linalg cimport cython_blas as blas
--
--from qutip.core.data.base import idxint_dtype
--from qutip.core.data.base cimport idxint, Data
--from qutip.core.data.dense cimport Dense
--from qutip.core.data.csr cimport CSR
--from qutip.core.data cimport csr, dense
--from qutip.core.data.add cimport iadd_dense, add_csr
--from qutip.core.data.dense import OrderEfficiencyWarning
--
--cnp.import_array()
--
--cdef extern from *:
--    void *PyMem_Calloc(size_t n, size_t elsize)
--
--# This function is templated over integral types on import to allow `idxint` to
--# be any signed integer (though likely things will only work for >=32-bit).  To
--# change integral types, you only need to change the `idxint` definitions in
--# `core.data.base` at compile-time.
--cdef extern from "src/matmul_csr_vector.hpp" nogil:
--    void _matmul_csr_vector[T](
--        double complex *data, T *col_index, T *row_index,
--        double complex *vec, double complex scale, double complex *out,
--        T nrows)
--
--__all__ = [
--    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
--    'multiply', 'multiply_csr', 'multiply_dense',
--]
--
--
--cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
--    if left.shape[1] != right.shape[0]:
--        raise ValueError(
--            "incompatible matrix shapes "
--            + str(left.shape)
--            + " and "
--            + str(right.shape)
--        )
--    if (
--        out is not None
--        and out.shape[0] != left.shape[0]
--        and out.shape[1] != right.shape[1]
--    ):
--        raise ValueError(
--            "incompatible output shape, got "
--            + str(out.shape)
--            + " but needed "
--            + str((left.shape[0], right.shape[1]))
--        )
--
--
--cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
--    """
--    Produce a sensible upper-bound for the number of non-zero elements that
--    will be present in a matrix multiplication between the two matrices.
--    """
--    cdef idxint j, k, nnz=0
--    cdef idxint ii, jj, kk
--    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
--    # Setup mask array
--    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
--    with nogil:
--        for ii in range(ncols):
--            mask[ii] = -1
--        for ii in range(nrows):
--            for jj in range(left.row_index[ii], left.row_index[ii+1]):
--                j = left.col_index[jj]
--                for kk in range(right.row_index[j], right.row_index[j+1]):
--                    k = right.col_index[kk]
--                    if mask[k] != ii:
--                        mask[k] = ii
--                        nnz += 1
--    mem.PyMem_Free(mask)
--    return nnz
--
--
--cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
--    """
--    Multiply two CSR matrices together to produce another CSR.  If `out` is
--    specified, it must be pre-allocated with enough space to hold the output
--    result.
--
--    This is the operation
--        ``out := left @ right``
--    where `out` will be allocated if not supplied.
--
--    Parameters
--    ----------
--    left : CSR
--        CSR matrix on the left of the multiplication.
--    right : CSR
--        CSR matrix on the right of the multiplication.
--    out : optional CSR
--        Allocated space to store the result.  This must have enough space in
--        the `data`, `col_index` and `row_index` pointers already allocated.
--
--    Returns
--    -------
--    out : CSR
--        The result of the matrix multiplication.  This will be the same object
--        as the input parameter `out` if that was supplied.
--    """
--    _check_shape(left, right)
--    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
--    if out is not None:
--        raise TypeError("passing an `out` entry for CSR operations makes no sense")
--    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
--    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
--        # Ensure the out array row_index is zeroed.  The others need not be,
--        # because they don't represent valid entries since row_index is zeroed.
--        with nogil:
--            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
--        return out
--
--    # Initialise actual matrix multiplication.
--    nnz = 0
--    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
--    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
--    cdef double complex val
--    cdef double complex *sums
--    cdef idxint *nxt
--    cdef double tol = 0
--    if settings.core['auto_tidyup']:
--        tol = settings.core['auto_tidyup_atol']
--    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
--    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
--    with nogil:
--        for col_r in range(ncols):
--            nxt[col_r] = -1
--
--        # Perform operation.
--        out.row_index[0] = 0
--        for row_l in range(nrows):
--            head = -2
--            length = 0
--            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
--                row_r = left.col_index[ptr_l]
--                val = left.data[ptr_l]
--                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
--                    col_r = right.col_index[ptr_r]
--                    sums[col_r] += val * right.data[ptr_r]
--                    if nxt[col_r] == -1:
--                        nxt[col_r] = head
--                        head = col_r
--                        length += 1
--            for col_r in range(length):
--                if fabs(sums[head].real) < tol:
--                    sums[head].real = 0
--                if fabs(sums[head].imag) < tol:
--                    sums[head].imag = 0
--                if sums[head] != 0:
--                    out.col_index[nnz] = head
--                    out.data[nnz] = scale * sums[head]
--                    nnz += 1
--                tmp = head
--                head = nxt[head]
--                nxt[tmp] = -1
--                sums[tmp] = 0
--            out.row_index[row_l + 1] = nnz
--    mem.PyMem_Free(sums)
--    mem.PyMem_Free(nxt)
--    return out
--
--
--cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
--                                   double complex scale=1, Dense out=None):
--    """
--    Perform the operation
--        ``out := scale * (left @ right) + out``
--    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
--    defaulting to 1.
--
--    If `out` is not given, it will be allocated as if it were a zero matrix.
--    """
--    _check_shape(left, right, out)
--    cdef Dense tmp = None
--    if out is None:
--        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
--    if bool(right.fortran) != bool(out.fortran):
--        msg = (
--            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
--            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
--        )
--        warnings.warn(msg, OrderEfficiencyWarning)
--        # Rather than making loads of copies of the same code, we just moan at
--        # the user and then transpose one of the arrays.  We prefer to have
--        # `right` in Fortran-order for cache efficiency.
--        if right.fortran:
--            tmp = out
--            out = out.reorder()
--        else:
--            right = right.reorder()
--    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
--    cdef double complex val
--    if right.fortran:
--        idx_r = idx_out = 0
--        for _ in range(ncols):
--            _matmul_csr_vector(left.data, left.col_index, left.row_index,
--                               right.data + idx_r,
--                               scale,
--                               out.data + idx_out,
--                               nrows)
--            idx_out += nrows
--            idx_r += right.shape[0]
--    else:
--        for row in range(nrows):
--            for ptr in range(left.row_index[row], left.row_index[row + 1]):
--                val = scale * left.data[ptr]
--                idx_out = row * ncols
--                idx_r = left.col_index[ptr] * ncols
--                for _ in range(ncols):
--                    out.data[idx_out] += val * right.data[idx_r]
--                    idx_out += 1
--                    idx_r += 1
--    if tmp is None:
--        return out
--    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
--    return tmp
--
--
--cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
--    """
--    Perform the operation
--        ``out := scale * (left @ right) + out``
--    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
--    defaulting to 1.
--
--    If `out` is not given, it will be allocated as if it were a zero matrix.
--    """
--    _check_shape(left, right, out)
--    cdef double complex out_scale
--    # If not supplied, it's more efficient from a memory allocation perspective
--    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
--    if out is None:
--        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
--        out_scale = 0
--    else:
--        out_scale = 1
--    cdef double complex *a
--    cdef double complex *b
--    cdef char transa, transb
--    cdef int m, n, k=left.shape[1], lda, ldb
--    if right.shape[1] == 1:
--        # Matrix Vector product
--        a, b = left.data, right.data
--        if left.fortran:
--            lda = left.shape[0]
--            transa = b'n'
--            m = left.shape[0]
--            n = left.shape[1]
--        else:
--            lda = left.shape[1]
--            transa = b't'
--            m = left.shape[1]
--            n = left.shape[0]
--        ldb = 1
--        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
--                   &out_scale, out.data, &ldb)
--        return out
--    # We use the BLAS routine zgemm for every single call and pretend that
--    # we're always supplying it with Fortran-ordered matrices, but to achieve
--    # what we want, we use the property of matrix multiplication that
--    #   A.B = (B'.A')'
--    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
--    # matrix as a C-ordered one is equivalent to taking the transpose.  If
--    # `right` is supplied in C-order, then from Fortran's perspective we
--    # actually have `B'`, so to retrieve `B` should we want to use it, we set
--    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
--    # need to switch the input order, _not_ whether we actually need B'.
--    #
--    # In order to make the output correct, we ensure that we put A.B in if the
--    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
--    # This is actually more flexible than `np.dot` which requires that the
--    # output is C-ordered.
--    if out.fortran:
--        # Need to make A.B
--        a, b = left.data, right.data
--        m, n = left.shape[0], right.shape[1]
--        lda = left.shape[0] if left.fortran else left.shape[1]
--        transa = b'n' if left.fortran else b't'
--        ldb = right.shape[0] if right.fortran else right.shape[1]
--        transb = b'n' if right.fortran else b't'
--    else:
--        # Need to make B'.A'
--        a, b = right.data, left.data
--        m, n = right.shape[1], left.shape[0]
--        lda = right.shape[0] if right.fortran else right.shape[1]
--        transa = b't' if right.fortran else b'n'
--        ldb = left.shape[0] if left.fortran else left.shape[1]
--        transb = b't' if left.fortran else b'n'
--    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
--               &out_scale, out.data, &m)
--    return out
--
--
--cpdef CSR multiply_csr(CSR left, CSR right):
--    """Element-wise multiplication of CSR matrices."""
--    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
--        raise ValueError(
--            "incompatible matrix shapes "
--            + str(left.shape)
--            + " and "
--            + str(right.shape)
--        )
--    cdef idxint col_left, left_nnz = csr.nnz(left)
--    cdef idxint col_right, right_nnz = csr.nnz(right)
--    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
--    cdef idxint row, nnz=0, ncols=left.shape[1]
--    cdef CSR out
--    cdef list nans=[]
--    # Fast paths for zero matrices.
--    if right_nnz == 0 or left_nnz == 0:
--        return csr.zeros(left.shape[0], left.shape[1])
--    # Main path.
--    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
--    out.row_index[0] = nnz
--    ptr_left_max = ptr_right_max = 0
--
--    for row in range(left.shape[0]):
--        ptr_left = ptr_left_max
--        ptr_left_max = left.row_index[row + 1]
--        ptr_right = ptr_right_max
--        ptr_right_max = right.row_index[row + 1]
--        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
--            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
--            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
--            if col_left == col_right:
--                out.col_index[nnz] = col_left
--                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
--                ptr_left += 1
--                ptr_right += 1
--                nnz += 1
--            elif col_left <= col_right:
--                if left.data[ptr_left] is np.nan:
--                    # Test for NaN since `NaN * 0 = NaN`
--                    nans.append((row, col_left))
--                ptr_left += 1
--            else:
--                if right.data[ptr_right] != right.data[ptr_right]:
--                    nans.append((row, col_right))
--                ptr_right += 1
--        out.row_index[row + 1] = nnz
--    if nans:
--        # We expect Nan to be rare enough that we don't allocate memory for
--        # them, but add them here after the loop.
--        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
--        nnz = nans_pos.shape[0]
--        nans_csr = csr.from_coo_pointers(
--            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
--            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
--            <double complex *> cnp.PyArray_GETPTR1(
--                np.array([np.nan]*nnz, dtype=np.complex128), 0),
--            left.shape[0], left.shape[1], nnz
--        )
--        out = add_csr(out, nans_csr)
--    return out
--
--
--cpdef Dense multiply_dense(Dense left, Dense right):
--    """Element-wise multiplication of Dense matrices."""
--    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
--        raise ValueError(
--            "incompatible matrix shapes "
--            + str(left.shape)
--            + " and "
--            + str(right.shape)
--        )
--    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--# At the time of putting in the dispatchers, the idea of an "out" parameter
--# isn't really supported in the model; since `out` would be potentially
--# modified in-place, it couldn't safely go through a conversion process.  For
--# the dispatched operation, then, we omit the `scale` and `out` parameters, and
--# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
--# are needed, the library will have to manually do any relevant conversions,
--# and then call a direct specialisation (which are exported to the `data`
--# namespace).
--
--matmul = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=1),
--    ]),
--    name='matmul',
--    module=__name__,
--    inputs=('left', 'right'),
--    out=True,
--)
--matmul.__doc__ =\
--    """
--    Compute the matrix multiplication of two matrices, with the operation
--        scale * (left @ right)
--    where `scale` is (optionally) a scalar, and `left` and `right` are
--    matrices.
--
--    Parameters
--    ----------
--    left : Data
--        The left operand as either a bra or a ket matrix.
--
--    right : Data
--        The right operand as a ket matrix.
--
--    scale : complex, optional
--        The scalar to multiply the output by.
--    """
--matmul.add_specialisations([
--    (CSR, CSR, CSR, matmul_csr),
--    (CSR, Dense, Dense, matmul_csr_dense_dense),
--    (Dense, Dense, Dense, matmul_dense),
--], _defer=True)
--
--
--multiply = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='multiply',
--    module=__name__,
--    inputs=('left', 'right'),
--    out=True,
--)
--multiply.__doc__ =\
--    """Element-wise multiplication of matrices."""
--multiply.add_specialisations([
--    (CSR, CSR, CSR, multiply_csr),
--    (Dense, Dense, Dense, multiply_dense),
--], _defer=True)
--
--
--del _inspect, _Dispatcher
--
--
--cdef Dense matmul_data_dense(Data left, Dense right):
--    cdef Dense out
--    if type(left) is CSR:
--        out = matmul_csr_dense_dense(left, right)
--    elif type(left) is Dense:
--        out = matmul_dense(left, right)
--    else:
--        out = matmul(left, right)
--    return out
--
--
--cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
--    if type(left) is CSR:
--        matmul_csr_dense_dense(left, right, scale, out)
--    elif type(left) is Dense:
--        matmul_dense(left, right, scale, out)
--    else:
--        iadd_dense(out, matmul(left, right), scale)
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.string cimport memset, memcpy
-+from libc.math cimport fabs
-+
-+import warnings
-+from qutip.settings import settings
-+
-+cimport cython
-+
-+from cpython cimport mem
-+
-+import numpy as np
-+cimport numpy as cnp
-+from scipy.linalg cimport cython_blas as blas
-+
-+from qutip.core.data.base import idxint_dtype
-+from qutip.core.data.base cimport idxint, Data
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data cimport csr, dense
-+from qutip.core.data.add cimport iadd_dense, add_csr
-+from qutip.core.data.dense import OrderEfficiencyWarning
-+
-+cnp.import_array()
-+
-+cdef extern from *:
-+    void *PyMem_Calloc(size_t n, size_t elsize)
-+
-+# This function is templated over integral types on import to allow `idxint` to
-+# be any signed integer (though likely things will only work for >=32-bit).  To
-+# change integral types, you only need to change the `idxint` definitions in
-+# `core.data.base` at compile-time.
-+cdef extern from "src/matmul_csr_vector.hpp" nogil:
-+    void _matmul_csr_vector[T](
-+        double complex *data, T *col_index, T *row_index,
-+        double complex *vec, double complex scale, double complex *out,
-+        T nrows)
-+
-+__all__ = [
-+    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
-+    'multiply', 'multiply_csr', 'multiply_dense',
-+]
-+
-+
-+cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
-+    if left.shape[1] != right.shape[0]:
-+        raise ValueError(
-+            "incompatible matrix shapes "
-+            + str(left.shape)
-+            + " and "
-+            + str(right.shape)
-+        )
-+    if (
-+        out is not None
-+        and out.shape[0] != left.shape[0]
-+        and out.shape[1] != right.shape[1]
-+    ):
-+        raise ValueError(
-+            "incompatible output shape, got "
-+            + str(out.shape)
-+            + " but needed "
-+            + str((left.shape[0], right.shape[1]))
-+        )
-+
-+
-+cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
-+    """
-+    Produce a sensible upper-bound for the number of non-zero elements that
-+    will be present in a matrix multiplication between the two matrices.
-+    """
-+    cdef idxint j, k, nnz=0
-+    cdef idxint ii, jj, kk
-+    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
-+    # Setup mask array
-+    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
-+    with nogil:
-+        for ii in range(ncols):
-+            mask[ii] = -1
-+        for ii in range(nrows):
-+            for jj in range(left.row_index[ii], left.row_index[ii+1]):
-+                j = left.col_index[jj]
-+                for kk in range(right.row_index[j], right.row_index[j+1]):
-+                    k = right.col_index[kk]
-+                    if mask[k] != ii:
-+                        mask[k] = ii
-+                        nnz += 1
-+    mem.PyMem_Free(mask)
-+    return nnz
-+
-+
-+cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
-+    """
-+    Multiply two CSR matrices together to produce another CSR.  If `out` is
-+    specified, it must be pre-allocated with enough space to hold the output
-+    result.
-+
-+    This is the operation
-+        ``out := left @ right``
-+    where `out` will be allocated if not supplied.
-+
-+    Parameters
-+    ----------
-+    left : CSR
-+        CSR matrix on the left of the multiplication.
-+    right : CSR
-+        CSR matrix on the right of the multiplication.
-+    out : optional CSR
-+        Allocated space to store the result.  This must have enough space in
-+        the `data`, `col_index` and `row_index` pointers already allocated.
-+
-+    Returns
-+    -------
-+    out : CSR
-+        The result of the matrix multiplication.  This will be the same object
-+        as the input parameter `out` if that was supplied.
-+    """
-+    _check_shape(left, right)
-+    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
-+    if out is not None:
-+        raise TypeError("passing an `out` entry for CSR operations makes no sense")
-+    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
-+    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
-+        # Ensure the out array row_index is zeroed.  The others need not be,
-+        # because they don't represent valid entries since row_index is zeroed.
-+        with nogil:
-+            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
-+        return out
-+
-+    # Initialise actual matrix multiplication.
-+    nnz = 0
-+    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
-+    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
-+    cdef double complex val
-+    cdef double complex *sums
-+    cdef idxint *nxt
-+    cdef double tol = 0
-+    if settings.core['auto_tidyup']:
-+        tol = settings.core['auto_tidyup_atol']
-+    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
-+    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
-+    with nogil:
-+        for col_r in range(ncols):
-+            nxt[col_r] = -1
-+
-+        # Perform operation.
-+        out.row_index[0] = 0
-+        for row_l in range(nrows):
-+            head = -2
-+            length = 0
-+            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
-+                row_r = left.col_index[ptr_l]
-+                val = left.data[ptr_l]
-+                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
-+                    col_r = right.col_index[ptr_r]
-+                    sums[col_r] += val * right.data[ptr_r]
-+                    if nxt[col_r] == -1:
-+                        nxt[col_r] = head
-+                        head = col_r
-+                        length += 1
-+            for col_r in range(length):
-+                if fabs(sums[head].real) < tol:
-+                    sums[head].real = 0
-+                if fabs(sums[head].imag) < tol:
-+                    sums[head].imag = 0
-+                if sums[head] != 0:
-+                    out.col_index[nnz] = head
-+                    out.data[nnz] = scale * sums[head]
-+                    nnz += 1
-+                tmp = head
-+                head = nxt[head]
-+                nxt[tmp] = -1
-+                sums[tmp] = 0
-+            out.row_index[row_l + 1] = nnz
-+    mem.PyMem_Free(sums)
-+    mem.PyMem_Free(nxt)
-+    return out
-+
-+
-+cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
-+                                   double complex scale=1, Dense out=None):
-+    """
-+    Perform the operation
-+        ``out := scale * (left @ right) + out``
-+    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
-+    defaulting to 1.
-+
-+    If `out` is not given, it will be allocated as if it were a zero matrix.
-+    """
-+    _check_shape(left, right, out)
-+    cdef Dense tmp = None
-+    if out is None:
-+        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
-+    if bool(right.fortran) != bool(out.fortran):
-+        msg = (
-+            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
-+            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
-+        )
-+        warnings.warn(msg, OrderEfficiencyWarning)
-+        # Rather than making loads of copies of the same code, we just moan at
-+        # the user and then transpose one of the arrays.  We prefer to have
-+        # `right` in Fortran-order for cache efficiency.
-+        if right.fortran:
-+            tmp = out
-+            out = out.reorder()
-+        else:
-+            right = right.reorder()
-+    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
-+    cdef double complex val
-+    if right.fortran:
-+        idx_r = idx_out = 0
-+        for _ in range(ncols):
-+            _matmul_csr_vector(left.data, left.col_index, left.row_index,
-+                               right.data + idx_r,
-+                               scale,
-+                               out.data + idx_out,
-+                               nrows)
-+            idx_out += nrows
-+            idx_r += right.shape[0]
-+    else:
-+        for row in range(nrows):
-+            for ptr in range(left.row_index[row], left.row_index[row + 1]):
-+                val = scale * left.data[ptr]
-+                idx_out = row * ncols
-+                idx_r = left.col_index[ptr] * ncols
-+                for _ in range(ncols):
-+                    out.data[idx_out] += val * right.data[idx_r]
-+                    idx_out += 1
-+                    idx_r += 1
-+    if tmp is None:
-+        return out
-+    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
-+    return tmp
-+
-+
-+cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
-+    """
-+    Perform the operation
-+        ``out := scale * (left @ right) + out``
-+    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
-+    defaulting to 1.
-+
-+    If `out` is not given, it will be allocated as if it were a zero matrix.
-+    """
-+    _check_shape(left, right, out)
-+    cdef double complex out_scale
-+    # If not supplied, it's more efficient from a memory allocation perspective
-+    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
-+    if out is None:
-+        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
-+        out_scale = 0
-+    else:
-+        out_scale = 1
-+    cdef double complex *a
-+    cdef double complex *b
-+    cdef char transa, transb
-+    cdef int m, n, k=left.shape[1], lda, ldb
-+    if right.shape[1] == 1:
-+        # Matrix Vector product
-+        a, b = left.data, right.data
-+        if left.fortran:
-+            lda = left.shape[0]
-+            transa = b'n'
-+            m = left.shape[0]
-+            n = left.shape[1]
-+        else:
-+            lda = left.shape[1]
-+            transa = b't'
-+            m = left.shape[1]
-+            n = left.shape[0]
-+        ldb = 1
-+        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
-+                   &out_scale, out.data, &ldb)
-+        return out
-+    # We use the BLAS routine zgemm for every single call and pretend that
-+    # we're always supplying it with Fortran-ordered matrices, but to achieve
-+    # what we want, we use the property of matrix multiplication that
-+    #   A.B = (B'.A')'
-+    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
-+    # matrix as a C-ordered one is equivalent to taking the transpose.  If
-+    # `right` is supplied in C-order, then from Fortran's perspective we
-+    # actually have `B'`, so to retrieve `B` should we want to use it, we set
-+    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
-+    # need to switch the input order, _not_ whether we actually need B'.
-+    #
-+    # In order to make the output correct, we ensure that we put A.B in if the
-+    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
-+    # This is actually more flexible than `np.dot` which requires that the
-+    # output is C-ordered.
-+    if out.fortran:
-+        # Need to make A.B
-+        a, b = left.data, right.data
-+        m, n = left.shape[0], right.shape[1]
-+        lda = left.shape[0] if left.fortran else left.shape[1]
-+        transa = b'n' if left.fortran else b't'
-+        ldb = right.shape[0] if right.fortran else right.shape[1]
-+        transb = b'n' if right.fortran else b't'
-+    else:
-+        # Need to make B'.A'
-+        a, b = right.data, left.data
-+        m, n = right.shape[1], left.shape[0]
-+        lda = right.shape[0] if right.fortran else right.shape[1]
-+        transa = b't' if right.fortran else b'n'
-+        ldb = left.shape[0] if left.fortran else left.shape[1]
-+        transb = b't' if left.fortran else b'n'
-+    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
-+               &out_scale, out.data, &m)
-+    return out
-+
-+
-+cpdef CSR multiply_csr(CSR left, CSR right):
-+    """Element-wise multiplication of CSR matrices."""
-+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-+        raise ValueError(
-+            "incompatible matrix shapes "
-+            + str(left.shape)
-+            + " and "
-+            + str(right.shape)
-+        )
-+    cdef idxint col_left, left_nnz = csr.nnz(left)
-+    cdef idxint col_right, right_nnz = csr.nnz(right)
-+    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
-+    cdef idxint row, nnz=0, ncols=left.shape[1]
-+    cdef CSR out
-+    cdef list nans=[]
-+    # Fast paths for zero matrices.
-+    if right_nnz == 0 or left_nnz == 0:
-+        return csr.zeros(left.shape[0], left.shape[1])
-+    # Main path.
-+    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
-+    out.row_index[0] = nnz
-+    ptr_left_max = ptr_right_max = 0
-+
-+    for row in range(left.shape[0]):
-+        ptr_left = ptr_left_max
-+        ptr_left_max = left.row_index[row + 1]
-+        ptr_right = ptr_right_max
-+        ptr_right_max = right.row_index[row + 1]
-+        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
-+            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
-+            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
-+            if col_left == col_right:
-+                out.col_index[nnz] = col_left
-+                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
-+                ptr_left += 1
-+                ptr_right += 1
-+                nnz += 1
-+            elif col_left <= col_right:
-+                if left.data[ptr_left] is np.nan:
-+                    # Test for NaN since `NaN * 0 = NaN`
-+                    nans.append((row, col_left))
-+                ptr_left += 1
-+            else:
-+                if right.data[ptr_right] != right.data[ptr_right]:
-+                    nans.append((row, col_right))
-+                ptr_right += 1
-+        out.row_index[row + 1] = nnz
-+    if nans:
-+        # We expect Nan to be rare enough that we don't allocate memory for
-+        # them, but add them here after the loop.
-+        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
-+        nnz = nans_pos.shape[0]
-+        nans_csr = csr.from_coo_pointers(
-+            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
-+            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
-+            <double complex *> cnp.PyArray_GETPTR1(
-+                np.array([np.nan]*nnz, dtype=np.complex128), 0),
-+            left.shape[0], left.shape[1], nnz
-+        )
-+        out = add_csr(out, nans_csr)
-+    return out
-+
-+
-+cpdef Dense multiply_dense(Dense left, Dense right):
-+    """Element-wise multiplication of Dense matrices."""
-+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-+        raise ValueError(
-+            "incompatible matrix shapes "
-+            + str(left.shape)
-+            + " and "
-+            + str(right.shape)
-+        )
-+    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+# At the time of putting in the dispatchers, the idea of an "out" parameter
-+# isn't really supported in the model; since `out` would be potentially
-+# modified in-place, it couldn't safely go through a conversion process.  For
-+# the dispatched operation, then, we omit the `scale` and `out` parameters, and
-+# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
-+# are needed, the library will have to manually do any relevant conversions,
-+# and then call a direct specialisation (which are exported to the `data`
-+# namespace).
-+
-+matmul = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=1),
-+    ]),
-+    name='matmul',
-+    module=__name__,
-+    inputs=('left', 'right'),
-+    out=True,
-+)
-+matmul.__doc__ =\
-+    """
-+    Compute the matrix multiplication of two matrices, with the operation
-+        scale * (left @ right)
-+    where `scale` is (optionally) a scalar, and `left` and `right` are
-+    matrices.
-+
-+    Parameters
-+    ----------
-+    left : Data
-+        The left operand as either a bra or a ket matrix.
-+
-+    right : Data
-+        The right operand as a ket matrix.
-+
-+    scale : complex, optional
-+        The scalar to multiply the output by.
-+    """
-+matmul.add_specialisations([
-+    (CSR, CSR, CSR, matmul_csr),
-+    (CSR, Dense, Dense, matmul_csr_dense_dense),
-+    (Dense, Dense, Dense, matmul_dense),
-+], _defer=True)
-+
-+
-+multiply = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='multiply',
-+    module=__name__,
-+    inputs=('left', 'right'),
-+    out=True,
-+)
-+multiply.__doc__ =\
-+    """Element-wise multiplication of matrices."""
-+multiply.add_specialisations([
-+    (CSR, CSR, CSR, multiply_csr),
-+    (Dense, Dense, Dense, multiply_dense),
-+], _defer=True)
-+
-+
-+del _inspect, _Dispatcher
-+
-+
-+cdef Dense matmul_data_dense(Data left, Dense right):
-+    cdef Dense out
-+    if type(left) is CSR:
-+        out = matmul_csr_dense_dense(left, right)
-+    elif type(left) is Dense:
-+        out = matmul_dense(left, right)
-+    else:
-+        out = matmul(left, right)
-+    return out
-+
-+
-+cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
-+    if type(left) is CSR:
-+        matmul_csr_dense_dense(left, right, scale, out)
-+    elif type(left) is Dense:
-+        matmul_dense(left, right, scale, out)
-+    else:
-+        iadd_dense(out, matmul(left, right), scale)
-diff --git a/qutip/core/data/mul.pxd b/qutip/core/data/mul.pxd
-index 2c292596..f935e1ee 100644
---- a/qutip/core/data/mul.pxd
-+++ b/qutip/core/data/mul.pxd
-@@ -1,13 +1,13 @@
--#cython: language_level=3
--
--from qutip.core.data cimport CSR, Dense, Data
--
--cpdef CSR imul_csr(CSR matrix, double complex value)
--cpdef CSR mul_csr(CSR matrix, double complex value)
--cpdef CSR neg_csr(CSR matrix)
--
--cpdef Dense imul_dense(Dense matrix, double complex value)
--cpdef Dense mul_dense(Dense matrix, double complex value)
--cpdef Dense neg_dense(Dense matrix)
--
--cpdef Data imul_data(Data matrix, double complex value)
-+#cython: language_level=3
-+
-+from qutip.core.data cimport CSR, Dense, Data
-+
-+cpdef CSR imul_csr(CSR matrix, double complex value)
-+cpdef CSR mul_csr(CSR matrix, double complex value)
-+cpdef CSR neg_csr(CSR matrix)
-+
-+cpdef Dense imul_dense(Dense matrix, double complex value)
-+cpdef Dense mul_dense(Dense matrix, double complex value)
-+cpdef Dense neg_dense(Dense matrix)
-+
-+cpdef Data imul_data(Data matrix, double complex value)
-diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
-index 439c6cf6..80928ede 100644
---- a/qutip/core/data/mul.pyx
-+++ b/qutip/core/data/mul.pyx
-@@ -1,134 +1,134 @@
--#cython: language_level=3
--#cython: boundscheck=False, wrapround=False, initializedcheck=False
--
--from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
--from scipy.linalg.cython_blas cimport zscal
--
--__all__ = [
--    'mul', 'mul_csr', 'mul_dense',
--    'imul', 'imul_csr', 'imul_dense', 'imul_data',
--    'neg', 'neg_csr', 'neg_dense',
--]
--
--
--cpdef CSR imul_csr(CSR matrix, double complex value):
--    """Multiply this CSR `matrix` by a complex scalar `value`."""
--    cdef idxint l = csr.nnz(matrix)
--    cdef int ONE=1
--    zscal(&l, &value, matrix.data, &ONE)
--    return matrix
--
--cpdef CSR mul_csr(CSR matrix, double complex value):
--    """Multiply this CSR `matrix` by a complex scalar `value`."""
--    if value == 0:
--        return csr.zeros(matrix.shape[0], matrix.shape[1])
--    cdef CSR out = csr.copy_structure(matrix)
--    cdef idxint ptr
--    with nogil:
--        for ptr in range(csr.nnz(matrix)):
--            out.data[ptr] = value * matrix.data[ptr]
--    return out
--
--cpdef CSR neg_csr(CSR matrix):
--    """Unary negation of this CSR `matrix`.  Return a new object."""
--    cdef CSR out = csr.copy_structure(matrix)
--    cdef idxint ptr
--    with nogil:
--        for ptr in range(csr.nnz(matrix)):
--            out.data[ptr] = -matrix.data[ptr]
--    return out
--
--
--cpdef Dense imul_dense(Dense matrix, double complex value):
--    """Multiply this Dense `matrix` by a complex scalar `value`."""
--    cdef size_t ptr
--    cdef int ONE=1
--    cdef idxint l = matrix.shape[0]*matrix.shape[1]
--    zscal(&l, &value, matrix.data, &ONE)
--    return matrix
--
--cpdef Dense mul_dense(Dense matrix, double complex value):
--    """Multiply this Dense `matrix` by a complex scalar `value`."""
--    cdef Dense out = dense.empty_like(matrix)
--    cdef size_t ptr
--    with nogil:
--        for ptr in range(matrix.shape[0]*matrix.shape[1]):
--            out.data[ptr] = value * matrix.data[ptr]
--    return out
--
--cpdef Dense neg_dense(Dense matrix):
--    """Unary negation of this Dense `matrix`.  Return a new object."""
--    cdef Dense out = dense.empty_like(matrix)
--    cdef size_t ptr
--    with nogil:
--        for ptr in range(matrix.shape[0]*matrix.shape[1]):
--            out.data[ptr] = -matrix.data[ptr]
--    return out
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--mul = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='mul',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--mul.__doc__ =\
--    """Multiply a matrix element-wise by a scalar."""
--mul.add_specialisations([
--    (CSR, CSR, mul_csr),
--    (Dense, Dense, mul_dense),
--], _defer=True)
--
--imul = _Dispatcher(
--    # Will not be inplce if specialisation does not exist but should still
--    # give expected results if used as:
--    # mat = imul(mat, x)
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='imul',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--imul.__doc__ =\
--    """Multiply inplace a matrix element-wise by a scalar."""
--imul.add_specialisations([
--    (CSR, CSR, imul_csr),
--    (Dense, Dense, imul_dense),
--], _defer=True)
--
--neg = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='neg',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--neg.__doc__ =\
--    """Unary element-wise negation of a matrix."""
--neg.add_specialisations([
--    (CSR, CSR, neg_csr),
--    (Dense, Dense, neg_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
--
--
--cpdef Data imul_data(Data matrix, double complex value):
--    if type(matrix) is CSR:
--        return imul_csr(matrix, value)
--    elif type(matrix) is Dense:
--        return imul_dense(matrix, value)
--    else:
--        return imul(matrix, value)
-+#cython: language_level=3
-+#cython: boundscheck=False, wrapround=False, initializedcheck=False
-+
-+from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
-+from scipy.linalg.cython_blas cimport zscal
-+
-+__all__ = [
-+    'mul', 'mul_csr', 'mul_dense',
-+    'imul', 'imul_csr', 'imul_dense', 'imul_data',
-+    'neg', 'neg_csr', 'neg_dense',
-+]
-+
-+
-+cpdef CSR imul_csr(CSR matrix, double complex value):
-+    """Multiply this CSR `matrix` by a complex scalar `value`."""
-+    cdef idxint l = csr.nnz(matrix)
-+    cdef int ONE=1
-+    zscal(&l, &value, matrix.data, &ONE)
-+    return matrix
-+
-+cpdef CSR mul_csr(CSR matrix, double complex value):
-+    """Multiply this CSR `matrix` by a complex scalar `value`."""
-+    if value == 0:
-+        return csr.zeros(matrix.shape[0], matrix.shape[1])
-+    cdef CSR out = csr.copy_structure(matrix)
-+    cdef idxint ptr
-+    with nogil:
-+        for ptr in range(csr.nnz(matrix)):
-+            out.data[ptr] = value * matrix.data[ptr]
-+    return out
-+
-+cpdef CSR neg_csr(CSR matrix):
-+    """Unary negation of this CSR `matrix`.  Return a new object."""
-+    cdef CSR out = csr.copy_structure(matrix)
-+    cdef idxint ptr
-+    with nogil:
-+        for ptr in range(csr.nnz(matrix)):
-+            out.data[ptr] = -matrix.data[ptr]
-+    return out
-+
-+
-+cpdef Dense imul_dense(Dense matrix, double complex value):
-+    """Multiply this Dense `matrix` by a complex scalar `value`."""
-+    cdef size_t ptr
-+    cdef int ONE=1
-+    cdef idxint l = matrix.shape[0]*matrix.shape[1]
-+    zscal(&l, &value, matrix.data, &ONE)
-+    return matrix
-+
-+cpdef Dense mul_dense(Dense matrix, double complex value):
-+    """Multiply this Dense `matrix` by a complex scalar `value`."""
-+    cdef Dense out = dense.empty_like(matrix)
-+    cdef size_t ptr
-+    with nogil:
-+        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-+            out.data[ptr] = value * matrix.data[ptr]
-+    return out
-+
-+cpdef Dense neg_dense(Dense matrix):
-+    """Unary negation of this Dense `matrix`.  Return a new object."""
-+    cdef Dense out = dense.empty_like(matrix)
-+    cdef size_t ptr
-+    with nogil:
-+        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-+            out.data[ptr] = -matrix.data[ptr]
-+    return out
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+mul = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='mul',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+mul.__doc__ =\
-+    """Multiply a matrix element-wise by a scalar."""
-+mul.add_specialisations([
-+    (CSR, CSR, mul_csr),
-+    (Dense, Dense, mul_dense),
-+], _defer=True)
-+
-+imul = _Dispatcher(
-+    # Will not be inplce if specialisation does not exist but should still
-+    # give expected results if used as:
-+    # mat = imul(mat, x)
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='imul',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+imul.__doc__ =\
-+    """Multiply inplace a matrix element-wise by a scalar."""
-+imul.add_specialisations([
-+    (CSR, CSR, imul_csr),
-+    (Dense, Dense, imul_dense),
-+], _defer=True)
-+
-+neg = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='neg',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+neg.__doc__ =\
-+    """Unary element-wise negation of a matrix."""
-+neg.add_specialisations([
-+    (CSR, CSR, neg_csr),
-+    (Dense, Dense, neg_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-+
-+
-+cpdef Data imul_data(Data matrix, double complex value):
-+    if type(matrix) is CSR:
-+        return imul_csr(matrix, value)
-+    elif type(matrix) is Dense:
-+        return imul_dense(matrix, value)
-+    else:
-+        return imul(matrix, value)
-diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
-index 5e1b7ebe..560d163e 100644
---- a/qutip/core/data/norm.pxd
-+++ b/qutip/core/data/norm.pxd
-@@ -1,15 +1,15 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from qutip.core.data cimport CSR, Dense, Data
--
--cpdef double one_csr(CSR matrix) except -1
--cpdef double trace_csr(CSR matrix) except -1
--cpdef double max_csr(CSR matrix) nogil
--cpdef double frobenius_csr(CSR matrix) nogil
--cpdef double l2_csr(CSR matrix) nogil except -1
--
--cpdef double frobenius_dense(Dense matrix) nogil
--cpdef double l2_dense(Dense matrix) nogil except -1
--
--cpdef double frobenius_data(Data state)
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from qutip.core.data cimport CSR, Dense, Data
-+
-+cpdef double one_csr(CSR matrix) except -1
-+cpdef double trace_csr(CSR matrix) except -1
-+cpdef double max_csr(CSR matrix) nogil
-+cpdef double frobenius_csr(CSR matrix) nogil
-+cpdef double l2_csr(CSR matrix) nogil except -1
-+
-+cpdef double frobenius_dense(Dense matrix) nogil
-+cpdef double l2_dense(Dense matrix) nogil except -1
-+
-+cpdef double frobenius_data(Data state)
-diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
-index 998d49d1..40f15837 100644
---- a/qutip/core/data/norm.pyx
-+++ b/qutip/core/data/norm.pyx
-@@ -1,229 +1,229 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc cimport math
--
--from cpython cimport mem
--
--from scipy.linalg cimport cython_blas as blas
--import scipy
--
--from qutip.core.data cimport CSR, Dense, csr, dense, Data
--
--from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
--from qutip.core.data.matmul cimport matmul_csr
--
--from qutip.core.data import eigs_csr, eigs_dense
--
--cdef extern from *:
--    # Not included in Cython for some reason?
--    void *PyMem_Calloc(size_t n, size_t elsize)
--
--cdef extern from "<complex>" namespace "std" nogil:
--    # abs is templated such that Cython treats std::abs as complex->complex
--    double abs(double complex x)
--
--cdef double abssq(double complex x) nogil:
--    return x.real*x.real + x.imag*x.imag
--
--# We always use BLAS routines where possible because architecture-specific
--# libraries will typically apply vectorised operations for us.
--
--# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
--__all__ = []
--
--cpdef double one_csr(CSR matrix) except -1:
--    cdef int n=matrix.shape[1], inc=1
--    cdef size_t ptr
--    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
--    try:
--        for ptr in range(csr.nnz(matrix)):
--            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
--        # BLAS is a Fortran library, so it's one-indexed of course...
--        return col[blas.idamax(&n, col, &inc) - 1]
--    finally:
--        mem.PyMem_Free(col)
--
--
--cpdef double trace_dense(Dense matrix) except -1:
--    """Compute the trace norm relaying scipy for dense operations."""
--    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
--
--
--cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
--    """Compute the trace norm using only sparse operations. These consist
--    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
--    their square roots."""
--    # For column and row vectors we simply use the l2 norm as it is equivalent
--    # to the trace norm.
--    if matrix.shape[0]==1 or matrix.shape[1]==1:
--        return l2_csr(matrix)
--
--    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
--    cdef size_t i
--    cdef double [::1] eigs
--
--    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
--
--    cdef double total = 0
--    for i in range(matrix.shape[0]):
--        # The abs is technically not part of the definition, but since all
--        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
--        # which are lower will just be ~1e-15 due to numerical approximations.
--        total += math.sqrt(abs(eigs[i]))
--    return total
--
--
--cpdef double max_csr(CSR matrix) nogil:
--    cdef size_t ptr
--    cdef double total=0, cur
--    for ptr in range(csr.nnz(matrix)):
--        # The positive square root is monotonic over positive reals, so we can
--        # find the maximum value by considering the abs squared (which doesn't
--        # require a sqrt) rather than the abs(which does), and then perform
--        # only a single sqrt at the end.
--        cur = abssq(matrix.data[ptr])
--        total = cur if cur > total else total
--    return math.sqrt(total)
--
--cpdef double frobenius_csr(CSR matrix) nogil:
--    # The Frobenius norm is effectively the same as the L2 norm when
--    # considering the non-zero elements as a vector.
--    cdef int n=csr.nnz(matrix), inc=1
--    return blas.dznrm2(&n, &matrix.data[0], &inc)
--
--cpdef double l2_csr(CSR matrix) nogil except -1:
--    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
--        raise ValueError("L2 norm is only defined on vectors")
--    return frobenius_csr(matrix)
--
--cpdef double one_dense(Dense matrix) nogil:
--    cdef size_t ptr, col, row, col_stride, row_stride
--    cdef double out=0, cur
--    col_stride = matrix.shape[0] if matrix.fortran else 1
--    row_stride = 1 if matrix.fortran else matrix.shape[1]
--    for col in range(matrix.shape[1]):
--        ptr = col * col_stride
--        cur = 0
--        for row in range(matrix.shape[0]):
--            cur += abs(matrix.data[ptr])
--            ptr += row_stride
--        out = cur if cur > out else out
--    return out
--
--cpdef double max_dense(Dense matrix) nogil:
--    cdef size_t ptr
--    cdef double total=0, cur
--    for ptr in range(matrix.shape[0] * matrix.shape[1]):
--        # The positive square root is monotonic over positive reals, so we can
--        # find the maximum value by considering the abs squared (which doesn't
--        # require a sqrt) rather than the abs(which does), and then perform
--        # only a single sqrt at the end.
--        cur = abssq(matrix.data[ptr])
--        total = cur if cur > total else total
--    return math.sqrt(total)
--
--cpdef double frobenius_dense(Dense matrix) nogil:
--    cdef int n = matrix.shape[0] * matrix.shape[1]
--    cdef int inc = 1
--    return blas.dznrm2(&n, matrix.data, &inc)
--
--cpdef double l2_dense(Dense matrix) nogil except -1:
--    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
--        raise ValueError("L2 norm is only defined on vectors")
--    return frobenius_dense(matrix)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--l2 = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='l2',
--    module=__name__,
--    inputs=('vector',),
--)
--l2.__doc__ =\
--    """
--    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
--        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
--    This is only defined for vectors, but see `norm.frobenius` for the similar
--    norm defined on all matrices.
--    """
--l2.add_specialisations([
--    (Dense, l2_dense),
--    (CSR, l2_csr),
--], _defer=True)
--
--_norm_signature = _inspect.Signature([
--    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--])
--
--frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
--frobenius.__doc__ =\
--    """
--    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
--    as the
--        sqrt(sum_i sum_j |matrix[i, j]|**2)
--    and is similar to an extension of the vector L2 norm to all matrices.
--    """
--frobenius.add_specialisations([
--    (Dense, frobenius_dense),
--    (CSR, frobenius_csr),
--], _defer=True)
--
--max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
--max.__doc__ =\
--    """
--    Compute the max norm of a matrix.  This is the largest absolute value of an
--    entry in the matrix, or mathematically
--        max_{i,j} |matrix[i, j]|
--    """
--max.add_specialisations([
--    (Dense, max_dense),
--    (CSR, max_csr),
--], _defer=True)
--
--one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
--one.__doc__ =\
--    """
--    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
--    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
--    the sum of the absolute values.
--    """
--one.add_specialisations([
--    (Dense, one_dense),
--    (CSR, one_csr),
--], _defer=True)
--
--
--trace = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    inputs=('matrix',),
--    name='trace',
--    module=__name__,
--    out=False,
--)
--trace.__doc__ =\
--    """
--    Compute the trace-norm of a matrix.  This is the sum of the singular values
--    of the matrix, or equivalently
--        Tr(sqrt(A @ A.adjoint()))
--    """
--trace.add_specialisations([
--    (CSR, trace_csr),
--    (Dense, trace_dense),
--], _defer=True)
--
--
--cpdef double frobenius_data(Data state):
--    if type(state) is Dense:
--        return frobenius_dense(state)
--    elif type(state) is CSR:
--        return frobenius_csr(state)
--    else:
--        return frobenius(state)
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc cimport math
-+
-+from cpython cimport mem
-+
-+from scipy.linalg cimport cython_blas as blas
-+import scipy
-+
-+from qutip.core.data cimport CSR, Dense, csr, dense, Data
-+
-+from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
-+from qutip.core.data.matmul cimport matmul_csr
-+
-+from qutip.core.data import eigs_csr, eigs_dense
-+
-+cdef extern from *:
-+    # Not included in Cython for some reason?
-+    void *PyMem_Calloc(size_t n, size_t elsize)
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    # abs is templated such that Cython treats std::abs as complex->complex
-+    double abs(double complex x)
-+
-+cdef double abssq(double complex x) nogil:
-+    return x.real*x.real + x.imag*x.imag
-+
-+# We always use BLAS routines where possible because architecture-specific
-+# libraries will typically apply vectorised operations for us.
-+
-+# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
-+__all__ = []
-+
-+cpdef double one_csr(CSR matrix) except -1:
-+    cdef int n=matrix.shape[1], inc=1
-+    cdef size_t ptr
-+    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
-+    try:
-+        for ptr in range(csr.nnz(matrix)):
-+            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
-+        # BLAS is a Fortran library, so it's one-indexed of course...
-+        return col[blas.idamax(&n, col, &inc) - 1]
-+    finally:
-+        mem.PyMem_Free(col)
-+
-+
-+cpdef double trace_dense(Dense matrix) except -1:
-+    """Compute the trace norm relaying scipy for dense operations."""
-+    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
-+
-+
-+cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
-+    """Compute the trace norm using only sparse operations. These consist
-+    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
-+    their square roots."""
-+    # For column and row vectors we simply use the l2 norm as it is equivalent
-+    # to the trace norm.
-+    if matrix.shape[0]==1 or matrix.shape[1]==1:
-+        return l2_csr(matrix)
-+
-+    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
-+    cdef size_t i
-+    cdef double [::1] eigs
-+
-+    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
-+
-+    cdef double total = 0
-+    for i in range(matrix.shape[0]):
-+        # The abs is technically not part of the definition, but since all
-+        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
-+        # which are lower will just be ~1e-15 due to numerical approximations.
-+        total += math.sqrt(abs(eigs[i]))
-+    return total
-+
-+
-+cpdef double max_csr(CSR matrix) nogil:
-+    cdef size_t ptr
-+    cdef double total=0, cur
-+    for ptr in range(csr.nnz(matrix)):
-+        # The positive square root is monotonic over positive reals, so we can
-+        # find the maximum value by considering the abs squared (which doesn't
-+        # require a sqrt) rather than the abs(which does), and then perform
-+        # only a single sqrt at the end.
-+        cur = abssq(matrix.data[ptr])
-+        total = cur if cur > total else total
-+    return math.sqrt(total)
-+
-+cpdef double frobenius_csr(CSR matrix) nogil:
-+    # The Frobenius norm is effectively the same as the L2 norm when
-+    # considering the non-zero elements as a vector.
-+    cdef int n=csr.nnz(matrix), inc=1
-+    return blas.dznrm2(&n, &matrix.data[0], &inc)
-+
-+cpdef double l2_csr(CSR matrix) nogil except -1:
-+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
-+        raise ValueError("L2 norm is only defined on vectors")
-+    return frobenius_csr(matrix)
-+
-+cpdef double one_dense(Dense matrix) nogil:
-+    cdef size_t ptr, col, row, col_stride, row_stride
-+    cdef double out=0, cur
-+    col_stride = matrix.shape[0] if matrix.fortran else 1
-+    row_stride = 1 if matrix.fortran else matrix.shape[1]
-+    for col in range(matrix.shape[1]):
-+        ptr = col * col_stride
-+        cur = 0
-+        for row in range(matrix.shape[0]):
-+            cur += abs(matrix.data[ptr])
-+            ptr += row_stride
-+        out = cur if cur > out else out
-+    return out
-+
-+cpdef double max_dense(Dense matrix) nogil:
-+    cdef size_t ptr
-+    cdef double total=0, cur
-+    for ptr in range(matrix.shape[0] * matrix.shape[1]):
-+        # The positive square root is monotonic over positive reals, so we can
-+        # find the maximum value by considering the abs squared (which doesn't
-+        # require a sqrt) rather than the abs(which does), and then perform
-+        # only a single sqrt at the end.
-+        cur = abssq(matrix.data[ptr])
-+        total = cur if cur > total else total
-+    return math.sqrt(total)
-+
-+cpdef double frobenius_dense(Dense matrix) nogil:
-+    cdef int n = matrix.shape[0] * matrix.shape[1]
-+    cdef int inc = 1
-+    return blas.dznrm2(&n, matrix.data, &inc)
-+
-+cpdef double l2_dense(Dense matrix) nogil except -1:
-+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
-+        raise ValueError("L2 norm is only defined on vectors")
-+    return frobenius_dense(matrix)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+l2 = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='l2',
-+    module=__name__,
-+    inputs=('vector',),
-+)
-+l2.__doc__ =\
-+    """
-+    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
-+        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
-+    This is only defined for vectors, but see `norm.frobenius` for the similar
-+    norm defined on all matrices.
-+    """
-+l2.add_specialisations([
-+    (Dense, l2_dense),
-+    (CSR, l2_csr),
-+], _defer=True)
-+
-+_norm_signature = _inspect.Signature([
-+    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+])
-+
-+frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
-+frobenius.__doc__ =\
-+    """
-+    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
-+    as the
-+        sqrt(sum_i sum_j |matrix[i, j]|**2)
-+    and is similar to an extension of the vector L2 norm to all matrices.
-+    """
-+frobenius.add_specialisations([
-+    (Dense, frobenius_dense),
-+    (CSR, frobenius_csr),
-+], _defer=True)
-+
-+max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
-+max.__doc__ =\
-+    """
-+    Compute the max norm of a matrix.  This is the largest absolute value of an
-+    entry in the matrix, or mathematically
-+        max_{i,j} |matrix[i, j]|
-+    """
-+max.add_specialisations([
-+    (Dense, max_dense),
-+    (CSR, max_csr),
-+], _defer=True)
-+
-+one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
-+one.__doc__ =\
-+    """
-+    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
-+    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
-+    the sum of the absolute values.
-+    """
-+one.add_specialisations([
-+    (Dense, one_dense),
-+    (CSR, one_csr),
-+], _defer=True)
-+
-+
-+trace = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    inputs=('matrix',),
-+    name='trace',
-+    module=__name__,
-+    out=False,
-+)
-+trace.__doc__ =\
-+    """
-+    Compute the trace-norm of a matrix.  This is the sum of the singular values
-+    of the matrix, or equivalently
-+        Tr(sqrt(A @ A.adjoint()))
-+    """
-+trace.add_specialisations([
-+    (CSR, trace_csr),
-+    (Dense, trace_dense),
-+], _defer=True)
-+
-+
-+cpdef double frobenius_data(Data state):
-+    if type(state) is Dense:
-+        return frobenius_dense(state)
-+    elif type(state) is CSR:
-+        return frobenius_csr(state)
-+    else:
-+        return frobenius(state)
-diff --git a/qutip/core/data/permute.pxd b/qutip/core/data/permute.pxd
-index 1ac9a335..422be089 100644
---- a/qutip/core/data/permute.pxd
-+++ b/qutip/core/data/permute.pxd
-@@ -1,7 +1,7 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from qutip.core.data.csr cimport CSR
--
--cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
--cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from qutip.core.data.csr cimport CSR
-+
-+cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
-+cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
-diff --git a/qutip/core/data/permute.pyx b/qutip/core/data/permute.pyx
-index 72f44af2..4e08fa74 100644
---- a/qutip/core/data/permute.pyx
-+++ b/qutip/core/data/permute.pyx
-@@ -1,405 +1,405 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.string cimport memset, memcpy
--
--from libcpp cimport bool
--from libcpp.algorithm cimport sort
--
--cimport cython
--
--from cpython cimport mem
--
--import numpy as np
--cimport numpy as cnp
--
--from qutip.core.data.base cimport idxint, idxint_DTYPE
--from qutip.core.data cimport csr, dense, CSR, Dense
--
--from qutip.core.data.base import idxint_dtype
--
--cnp.import_array()
--
--cdef extern from *:
--    void *PyMem_Calloc(size_t n, size_t elsize)
--
--# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
--__all__ = []
--
--
--cdef class _Indexer:
--    cdef size_t ndims, size
--    cdef readonly cnp.ndarray new_dimensions
--    cdef idxint[:] dimensions
--    cdef idxint *cumprod
--
--    def __init__(self, idxint[:] dimensions, idxint[:] order):
--        cdef size_t i
--        cdef idxint dim, ord
--        cdef idxint prev
--        self.ndims = dimensions.shape[0]
--        self.dimensions = dimensions
--        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
--        cdef idxint[:] new_dimensions = self.new_dimensions
--        if order.shape[0] != self.ndims:
--            raise ValueError("invalid order: wrong number of elements")
--        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
--        try:
--            for i in range(self.ndims):
--                ord = order[i]
--                if ord < 0 or ord >= self.ndims:
--                    raise ValueError("invalid order element: " + str(ord))
--                if tmp[ord]:
--                    raise ValueError("duplicate order element: " + str(ord))
--                tmp[ord] = True
--                dim = self.dimensions[ord]
--                if dim < 0:
--                    raise ValueError("found negative dimension: " + str(dim))
--                elif dim == 0:
--                    raise ValueError("found zero dimension")
--                new_dimensions[i] = dim
--        finally:
--            mem.PyMem_Free(tmp)
--        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
--        prev = self.cumprod[order[self.ndims - 1]] = 1
--        for i in range(self.ndims - 2, -1, -1):
--            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
--        self.size = self.cumprod[order[0]] * new_dimensions[0]
--
--    @cython.cdivision(True)
--    cdef cnp.ndarray all(self):
--        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
--        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
--        cdef idxint i
--        for i in range(self.size):
--            _out[i] = self.single(i)
--        return out
--
--    @cython.cdivision(True)
--    cdef idxint single(self, idxint idx) nogil:
--        cdef size_t i
--        cdef idxint out=0, dim
--        for i in range(self.ndims - 1, -1, -1):
--            dim = self.dimensions[i]
--            # Dimensions cannot be zero due to the check in __init__.
--            out += self.cumprod[i] * (idx % dim)
--            idx //= dim
--            if idx == 0:
--                break
--        return out
--
--    def __dealloc__(self):
--        if self.cumprod != NULL:
--            mem.PyMem_Free(self.cumprod)
--
--cdef bint _check_indices(size_t size, idxint[:] order) except True:
--    """
--    Test whether the permutation `order` is a valid permutation of `size`
--    number of elements.  This is functionally equivalent to
--
--    ```
--    if np.sort(order) != np.arange(size):
--        raise ValueError
--    return False
--    ```
--
--    In other words, we test that each integer on [0, size) is present exactly
--    once in `order`, and raise ValueError if that is not the case (returns True
--    if an error is detected, and False if not to help pure Cython avoiding
--    exceptions).
--    """
--    if order.shape[0] != size:
--        raise ValueError("invalid permutation: wrong number of elements")
--    cdef size_t ptr
--    cdef idxint value
--    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
--    if test == NULL:
--        raise MemoryError
--    try:
--        for ptr in range(size):
--            value = order[ptr]
--            if not 0 <= value < size:
--                raise ValueError("invalid entry in permutation: " + str(value))
--            if test[value]:
--                raise ValueError("duplicate entry in permutation: " + str(value))
--            test[value] = True
--        return False
--    finally:
--        mem.PyMem_Free(test)
--
--cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
--    cdef size_t n_rows=matrix.shape[0]
--    _check_indices(n_rows, rows)
--    cdef CSR out = csr.empty_like(matrix)
--    cdef size_t row, ptr_in, ptr_out, len
--    out.row_index[0] = 0
--    for row in range(matrix.shape[0]):
--        out.row_index[rows[row] + 1] =\
--            matrix.row_index[row + 1] - matrix.row_index[row]
--    for row in range(matrix.shape[0]):
--        out.row_index[row + 1] += out.row_index[row]
--    for row in range(matrix.shape[0]):
--        ptr_in = matrix.row_index[row]
--        ptr_out = out.row_index[rows[row]]
--        len = matrix.row_index[row + 1] - ptr_in
--        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
--        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
--    return out
--
--cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
--    _check_indices(matrix.shape[0], rows)
--    _check_indices(matrix.shape[1], cols)
--    cdef CSR out = csr.empty_like(matrix)
--    cdef size_t row, ptr_in, ptr_out, len, n
--    # First build up the row index structure by cumulative sum, so we know
--    # where to place the data and column indices.  We also use this opportunity
--    # to find the maximum number of non-zero elements in a row.
--    with nogil:
--        len = 0
--        out.row_index[0] = 0
--        for row in range(matrix.shape[0]):
--            n = matrix.row_index[row + 1] - matrix.row_index[row]
--            out.row_index[rows[row] + 1] = n
--            len = n if n > len else len
--        for row in range(matrix.shape[0]):
--            out.row_index[row + 1] += out.row_index[row]
--    # Now we know that `len` is the most number of non-zero elements in a row,
--    # so we can allocate space to sort only once.
--    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
--    cdef csr.Sorter sort = csr.Sorter(len)
--    for row in range(matrix.shape[0]):
--        ptr_in = matrix.row_index[row]
--        ptr_out = out.row_index[rows[row]]
--        len = matrix.row_index[row + 1] - ptr_in
--        for n in range(len):
--            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
--        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
--                  &matrix.data[ptr_in], new_cols,
--                  len)
--    mem.PyMem_Free(new_cols)
--    return out
--
--cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
--    if row_perm is None and col_perm is None:
--        return matrix.copy()
--    if col_perm is None:
--        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
--    cdef idxint *rows = NULL
--    cdef idxint n
--    if row_perm is None:
--        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
--        for n in range(matrix.shape[0]):
--            rows[n] = n
--        try:
--            return _indices_csr_full(matrix,
--                                     <idxint [:matrix.shape[0]]>rows,
--                                     np.asarray(col_perm, dtype=idxint_dtype))
--        finally:
--            mem.PyMem_Free(rows)
--    return _indices_csr_full(matrix,
--                             np.asarray(row_perm, dtype=idxint_dtype),
--                             np.asarray(col_perm, dtype=idxint_dtype))
--
--cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
--    if row_perm is None and col_perm is None:
--        return matrix.copy()
--    array = matrix.as_ndarray()
--    if row_perm is not None:
--        array = array[np.argsort(row_perm), :]
--    if col_perm is not None:
--        array = array[:, np.argsort(col_perm)]
--    return Dense(array)
--
--
--cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
--    if matrix.shape[0] != 1:
--        raise ValueError("expected bra-like matrix")
--    cdef size_t nnz = csr.nnz(matrix)
--    cdef CSR out = csr.empty_like(matrix)
--    out.row_index[0] = 0
--    out.row_index[1] = nnz
--    cdef size_t n
--    cdef csr.Sorter sort = csr.Sorter(nnz)
--    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
--    try:
--        for n in range(nnz):
--            new_cols[n] = index.single(matrix.col_index[n])
--        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
--        return out
--    finally:
--        mem.PyMem_Free(new_cols)
--
--cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
--    cdef CSR out = csr.empty_like(matrix)
--    cdef csr.Sorter sort
--    cdef size_t row, n, len=0
--    cdef idxint ptr_in, ptr_out, col
--    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
--    try:
--        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
--        with nogil:
--            for row in range(matrix.shape[0]):
--                n = matrix.row_index[row + 1] - matrix.row_index[row]
--                if n:
--                    idx_lookup[row] = index.single(row)
--                    out.row_index[idx_lookup[row] + 1] = n
--                    len = n if n > len else len
--                else:
--                    # Use a sentinel value so we can avoid looking up columns
--                    # that we already know about later.  Not all values in
--                    # idx_lookup will even be filled---this is the speed up
--                    # this function achieves over `_indices_csr_all`.
--                    idx_lookup[row] = -1
--            for row in range(matrix.shape[0]):
--                out.row_index[row + 1] += out.row_index[row]
--        # Since this is very sparse, we expect almost all rows to have at most two
--        # elements in them.  It will be faster to copy them across, and perform the
--        # sort in place rather than allocating temporary space and making an
--        # additional copy.  This will still work even if there are more in a row,
--        # it just won't be quite as efficient in that case (which should be rare).
--        sort = csr.Sorter(len)
--        for row in range(matrix.shape[0]):
--            ptr_in = matrix.row_index[row]
--            len = matrix.row_index[row + 1] - ptr_in
--            if len == 0:
--                continue
--            ptr_out = out.row_index[idx_lookup[row]]
--            for n in range(len):
--                col = matrix.col_index[ptr_in + n]
--                if idx_lookup[col] == -1:
--                    idx_lookup[col] = index.single(col)
--                out.col_index[ptr_out + n] = idx_lookup[col]
--            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
--            sort.inplace(out, ptr_out, len)
--        return out
--    finally:
--        mem.PyMem_Free(idx_lookup)
--
--@cython.cdivision(True)
--cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
--    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
--                                   np.asarray(order, dtype=idxint_dtype))
--    cdef idxint[:] permutation
--    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
--        return matrix.copy()
--    if matrix.shape[0] == 1:
--        return _dimensions_csr_columns(matrix, index)
--    if matrix.shape[1] == 1:
--        return _indices_csr_rowonly(matrix, index.all())
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("dimensional permute requires square operators")
--    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
--    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
--    # calls to `index.single()` than the matrix dimension.  To be sure of this,
--    # we actually require the density per row to be less than 1/2, because we
--    # have to look up both the row _and_ column on output.  This only
--    # corresponds to exceptionally sparse matrices.  We try to avoid these
--    # calls because index.single has ~logarithmic complexity in the dimension
--    # (so for qubit systems it's linear in the number of qubits), and
--    # consequently `index.all()` is a hidden quadratic complexity.
--    if row_density >= 0.5:
--        permutation = index.all()
--        return _indices_csr_full(matrix, permutation, permutation)
--    return _dimensions_csr_sparse(matrix, index)
--
--@cython.cdivision(True)
--cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
--    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
--                                   np.asarray(order, dtype=idxint_dtype))
--    cdef idxint[:] permutation = index.all()
--    row_perm, col_perm = None, None
--    if matrix.shape[0] != 1:
--        row_perm = permutation
--    if matrix.shape[1] != 1:
--        col_perm = permutation
--    return indices_dense(matrix, row_perm, col_perm)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--dimensions = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='dimensions',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--dimensions.__doc__ =\
--    """
--    Reorder the tensor-product structure of a matrix, assuming that the
--    underlying structure is defined by `dimensions`.  For a separable system,
--    this function produces a matrix which is equivalent to having performed
--    `kron` in a different order on the separable parts.
--
--    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
--    respectively, then
--        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
--                                                  [2, 3, 4],
--                                                  [1, 2, 0])
--    In other words, the inputs to `kron` are reordered so that input `n` moves
--    to position `order[n]`.
--
--    Parameters
--    ----------
--    matrix : Data
--        Input matrix to reorder.  This can either be a square matrix
--        representing an operator, or a bra- or ket-like vector.
--
--    dimensions : 1D array_like of integers
--        The tensor-product structure of the space the matrix lives on.  This
--        will typically be one of the two elements of `Qobj.dims` (e.g. for a
--        ket, it will be `Qobj.dims[0]`).
--
--    order : 1D array_like of integers
--        The new order of the tensor-product elements.  This should be a 1D list
--        with the integers from `0` to `N - 1` inclusive, if there are `N`
--        elements in the tensor product.
--    """
--dimensions.add_specialisations([
--    (CSR, CSR, dimensions_csr),
--    (Dense, Dense, dimensions_dense),
--], _defer=True)
--
--indices = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=None),
--        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=None),
--    ]),
--    name='indices',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--indices.__doc__ =\
--    """
--    Permute the rows and columns of a matrix according to a row and column
--    permutation.  This is a "dumb" operation with regards to the representation
--    of quantum states; if you want to "reorder" the tensor-product structure of
--    a system, you want `permute.dimensions` instead.
--
--    Parameters
--    ----------
--    matrix : Data
--        The input matrix.
--
--    row_perm, col_perm : 1D array_like of integer, optional
--        The new order that the rows or columns should be shuffled into.  If the
--        input matrix is `N x M`, then `row_perm` would be an array containing
--        all the integers from `0` to `N - 1` inclusive in some new order.  Row
--        `n` in the input will be at row `row_perm[n]` in the output, and
--        similar for the column permutation.
--    """
--indices.add_specialisations([
--    (CSR, CSR, indices_csr),
--    (Dense, Dense, indices_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.string cimport memset, memcpy
-+
-+from libcpp cimport bool
-+from libcpp.algorithm cimport sort
-+
-+cimport cython
-+
-+from cpython cimport mem
-+
-+import numpy as np
-+cimport numpy as cnp
-+
-+from qutip.core.data.base cimport idxint, idxint_DTYPE
-+from qutip.core.data cimport csr, dense, CSR, Dense
-+
-+from qutip.core.data.base import idxint_dtype
-+
-+cnp.import_array()
-+
-+cdef extern from *:
-+    void *PyMem_Calloc(size_t n, size_t elsize)
-+
-+# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
-+__all__ = []
-+
-+
-+cdef class _Indexer:
-+    cdef size_t ndims, size
-+    cdef readonly cnp.ndarray new_dimensions
-+    cdef idxint[:] dimensions
-+    cdef idxint *cumprod
-+
-+    def __init__(self, idxint[:] dimensions, idxint[:] order):
-+        cdef size_t i
-+        cdef idxint dim, ord
-+        cdef idxint prev
-+        self.ndims = dimensions.shape[0]
-+        self.dimensions = dimensions
-+        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
-+        cdef idxint[:] new_dimensions = self.new_dimensions
-+        if order.shape[0] != self.ndims:
-+            raise ValueError("invalid order: wrong number of elements")
-+        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
-+        try:
-+            for i in range(self.ndims):
-+                ord = order[i]
-+                if ord < 0 or ord >= self.ndims:
-+                    raise ValueError("invalid order element: " + str(ord))
-+                if tmp[ord]:
-+                    raise ValueError("duplicate order element: " + str(ord))
-+                tmp[ord] = True
-+                dim = self.dimensions[ord]
-+                if dim < 0:
-+                    raise ValueError("found negative dimension: " + str(dim))
-+                elif dim == 0:
-+                    raise ValueError("found zero dimension")
-+                new_dimensions[i] = dim
-+        finally:
-+            mem.PyMem_Free(tmp)
-+        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
-+        prev = self.cumprod[order[self.ndims - 1]] = 1
-+        for i in range(self.ndims - 2, -1, -1):
-+            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
-+        self.size = self.cumprod[order[0]] * new_dimensions[0]
-+
-+    @cython.cdivision(True)
-+    cdef cnp.ndarray all(self):
-+        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
-+        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
-+        cdef idxint i
-+        for i in range(self.size):
-+            _out[i] = self.single(i)
-+        return out
-+
-+    @cython.cdivision(True)
-+    cdef idxint single(self, idxint idx) nogil:
-+        cdef size_t i
-+        cdef idxint out=0, dim
-+        for i in range(self.ndims - 1, -1, -1):
-+            dim = self.dimensions[i]
-+            # Dimensions cannot be zero due to the check in __init__.
-+            out += self.cumprod[i] * (idx % dim)
-+            idx //= dim
-+            if idx == 0:
-+                break
-+        return out
-+
-+    def __dealloc__(self):
-+        if self.cumprod != NULL:
-+            mem.PyMem_Free(self.cumprod)
-+
-+cdef bint _check_indices(size_t size, idxint[:] order) except True:
-+    """
-+    Test whether the permutation `order` is a valid permutation of `size`
-+    number of elements.  This is functionally equivalent to
-+
-+    ```
-+    if np.sort(order) != np.arange(size):
-+        raise ValueError
-+    return False
-+    ```
-+
-+    In other words, we test that each integer on [0, size) is present exactly
-+    once in `order`, and raise ValueError if that is not the case (returns True
-+    if an error is detected, and False if not to help pure Cython avoiding
-+    exceptions).
-+    """
-+    if order.shape[0] != size:
-+        raise ValueError("invalid permutation: wrong number of elements")
-+    cdef size_t ptr
-+    cdef idxint value
-+    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
-+    if test == NULL:
-+        raise MemoryError
-+    try:
-+        for ptr in range(size):
-+            value = order[ptr]
-+            if not 0 <= value < size:
-+                raise ValueError("invalid entry in permutation: " + str(value))
-+            if test[value]:
-+                raise ValueError("duplicate entry in permutation: " + str(value))
-+            test[value] = True
-+        return False
-+    finally:
-+        mem.PyMem_Free(test)
-+
-+cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
-+    cdef size_t n_rows=matrix.shape[0]
-+    _check_indices(n_rows, rows)
-+    cdef CSR out = csr.empty_like(matrix)
-+    cdef size_t row, ptr_in, ptr_out, len
-+    out.row_index[0] = 0
-+    for row in range(matrix.shape[0]):
-+        out.row_index[rows[row] + 1] =\
-+            matrix.row_index[row + 1] - matrix.row_index[row]
-+    for row in range(matrix.shape[0]):
-+        out.row_index[row + 1] += out.row_index[row]
-+    for row in range(matrix.shape[0]):
-+        ptr_in = matrix.row_index[row]
-+        ptr_out = out.row_index[rows[row]]
-+        len = matrix.row_index[row + 1] - ptr_in
-+        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
-+        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
-+    return out
-+
-+cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
-+    _check_indices(matrix.shape[0], rows)
-+    _check_indices(matrix.shape[1], cols)
-+    cdef CSR out = csr.empty_like(matrix)
-+    cdef size_t row, ptr_in, ptr_out, len, n
-+    # First build up the row index structure by cumulative sum, so we know
-+    # where to place the data and column indices.  We also use this opportunity
-+    # to find the maximum number of non-zero elements in a row.
-+    with nogil:
-+        len = 0
-+        out.row_index[0] = 0
-+        for row in range(matrix.shape[0]):
-+            n = matrix.row_index[row + 1] - matrix.row_index[row]
-+            out.row_index[rows[row] + 1] = n
-+            len = n if n > len else len
-+        for row in range(matrix.shape[0]):
-+            out.row_index[row + 1] += out.row_index[row]
-+    # Now we know that `len` is the most number of non-zero elements in a row,
-+    # so we can allocate space to sort only once.
-+    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
-+    cdef csr.Sorter sort = csr.Sorter(len)
-+    for row in range(matrix.shape[0]):
-+        ptr_in = matrix.row_index[row]
-+        ptr_out = out.row_index[rows[row]]
-+        len = matrix.row_index[row + 1] - ptr_in
-+        for n in range(len):
-+            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
-+        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
-+                  &matrix.data[ptr_in], new_cols,
-+                  len)
-+    mem.PyMem_Free(new_cols)
-+    return out
-+
-+cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
-+    if row_perm is None and col_perm is None:
-+        return matrix.copy()
-+    if col_perm is None:
-+        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
-+    cdef idxint *rows = NULL
-+    cdef idxint n
-+    if row_perm is None:
-+        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
-+        for n in range(matrix.shape[0]):
-+            rows[n] = n
-+        try:
-+            return _indices_csr_full(matrix,
-+                                     <idxint [:matrix.shape[0]]>rows,
-+                                     np.asarray(col_perm, dtype=idxint_dtype))
-+        finally:
-+            mem.PyMem_Free(rows)
-+    return _indices_csr_full(matrix,
-+                             np.asarray(row_perm, dtype=idxint_dtype),
-+                             np.asarray(col_perm, dtype=idxint_dtype))
-+
-+cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
-+    if row_perm is None and col_perm is None:
-+        return matrix.copy()
-+    array = matrix.as_ndarray()
-+    if row_perm is not None:
-+        array = array[np.argsort(row_perm), :]
-+    if col_perm is not None:
-+        array = array[:, np.argsort(col_perm)]
-+    return Dense(array)
-+
-+
-+cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
-+    if matrix.shape[0] != 1:
-+        raise ValueError("expected bra-like matrix")
-+    cdef size_t nnz = csr.nnz(matrix)
-+    cdef CSR out = csr.empty_like(matrix)
-+    out.row_index[0] = 0
-+    out.row_index[1] = nnz
-+    cdef size_t n
-+    cdef csr.Sorter sort = csr.Sorter(nnz)
-+    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
-+    try:
-+        for n in range(nnz):
-+            new_cols[n] = index.single(matrix.col_index[n])
-+        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
-+        return out
-+    finally:
-+        mem.PyMem_Free(new_cols)
-+
-+cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
-+    cdef CSR out = csr.empty_like(matrix)
-+    cdef csr.Sorter sort
-+    cdef size_t row, n, len=0
-+    cdef idxint ptr_in, ptr_out, col
-+    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
-+    try:
-+        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
-+        with nogil:
-+            for row in range(matrix.shape[0]):
-+                n = matrix.row_index[row + 1] - matrix.row_index[row]
-+                if n:
-+                    idx_lookup[row] = index.single(row)
-+                    out.row_index[idx_lookup[row] + 1] = n
-+                    len = n if n > len else len
-+                else:
-+                    # Use a sentinel value so we can avoid looking up columns
-+                    # that we already know about later.  Not all values in
-+                    # idx_lookup will even be filled---this is the speed up
-+                    # this function achieves over `_indices_csr_all`.
-+                    idx_lookup[row] = -1
-+            for row in range(matrix.shape[0]):
-+                out.row_index[row + 1] += out.row_index[row]
-+        # Since this is very sparse, we expect almost all rows to have at most two
-+        # elements in them.  It will be faster to copy them across, and perform the
-+        # sort in place rather than allocating temporary space and making an
-+        # additional copy.  This will still work even if there are more in a row,
-+        # it just won't be quite as efficient in that case (which should be rare).
-+        sort = csr.Sorter(len)
-+        for row in range(matrix.shape[0]):
-+            ptr_in = matrix.row_index[row]
-+            len = matrix.row_index[row + 1] - ptr_in
-+            if len == 0:
-+                continue
-+            ptr_out = out.row_index[idx_lookup[row]]
-+            for n in range(len):
-+                col = matrix.col_index[ptr_in + n]
-+                if idx_lookup[col] == -1:
-+                    idx_lookup[col] = index.single(col)
-+                out.col_index[ptr_out + n] = idx_lookup[col]
-+            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
-+            sort.inplace(out, ptr_out, len)
-+        return out
-+    finally:
-+        mem.PyMem_Free(idx_lookup)
-+
-+@cython.cdivision(True)
-+cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
-+    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
-+                                   np.asarray(order, dtype=idxint_dtype))
-+    cdef idxint[:] permutation
-+    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
-+        return matrix.copy()
-+    if matrix.shape[0] == 1:
-+        return _dimensions_csr_columns(matrix, index)
-+    if matrix.shape[1] == 1:
-+        return _indices_csr_rowonly(matrix, index.all())
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("dimensional permute requires square operators")
-+    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
-+    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
-+    # calls to `index.single()` than the matrix dimension.  To be sure of this,
-+    # we actually require the density per row to be less than 1/2, because we
-+    # have to look up both the row _and_ column on output.  This only
-+    # corresponds to exceptionally sparse matrices.  We try to avoid these
-+    # calls because index.single has ~logarithmic complexity in the dimension
-+    # (so for qubit systems it's linear in the number of qubits), and
-+    # consequently `index.all()` is a hidden quadratic complexity.
-+    if row_density >= 0.5:
-+        permutation = index.all()
-+        return _indices_csr_full(matrix, permutation, permutation)
-+    return _dimensions_csr_sparse(matrix, index)
-+
-+@cython.cdivision(True)
-+cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
-+    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
-+                                   np.asarray(order, dtype=idxint_dtype))
-+    cdef idxint[:] permutation = index.all()
-+    row_perm, col_perm = None, None
-+    if matrix.shape[0] != 1:
-+        row_perm = permutation
-+    if matrix.shape[1] != 1:
-+        col_perm = permutation
-+    return indices_dense(matrix, row_perm, col_perm)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+dimensions = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='dimensions',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+dimensions.__doc__ =\
-+    """
-+    Reorder the tensor-product structure of a matrix, assuming that the
-+    underlying structure is defined by `dimensions`.  For a separable system,
-+    this function produces a matrix which is equivalent to having performed
-+    `kron` in a different order on the separable parts.
-+
-+    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
-+    respectively, then
-+        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
-+                                                  [2, 3, 4],
-+                                                  [1, 2, 0])
-+    In other words, the inputs to `kron` are reordered so that input `n` moves
-+    to position `order[n]`.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        Input matrix to reorder.  This can either be a square matrix
-+        representing an operator, or a bra- or ket-like vector.
-+
-+    dimensions : 1D array_like of integers
-+        The tensor-product structure of the space the matrix lives on.  This
-+        will typically be one of the two elements of `Qobj.dims` (e.g. for a
-+        ket, it will be `Qobj.dims[0]`).
-+
-+    order : 1D array_like of integers
-+        The new order of the tensor-product elements.  This should be a 1D list
-+        with the integers from `0` to `N - 1` inclusive, if there are `N`
-+        elements in the tensor product.
-+    """
-+dimensions.add_specialisations([
-+    (CSR, CSR, dimensions_csr),
-+    (Dense, Dense, dimensions_dense),
-+], _defer=True)
-+
-+indices = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=None),
-+        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=None),
-+    ]),
-+    name='indices',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+indices.__doc__ =\
-+    """
-+    Permute the rows and columns of a matrix according to a row and column
-+    permutation.  This is a "dumb" operation with regards to the representation
-+    of quantum states; if you want to "reorder" the tensor-product structure of
-+    a system, you want `permute.dimensions` instead.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The input matrix.
-+
-+    row_perm, col_perm : 1D array_like of integer, optional
-+        The new order that the rows or columns should be shuffled into.  If the
-+        input matrix is `N x M`, then `row_perm` would be an array containing
-+        all the integers from `0` to `N - 1` inclusive in some new order.  Row
-+        `n` in the input will be at row `row_perm[n]` in the output, and
-+        similar for the column permutation.
-+    """
-+indices.add_specialisations([
-+    (CSR, CSR, indices_csr),
-+    (Dense, Dense, indices_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/pow.pxd b/qutip/core/data/pow.pxd
-index d74b871f..04a0c79f 100644
---- a/qutip/core/data/pow.pxd
-+++ b/qutip/core/data/pow.pxd
-@@ -1,5 +1,5 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--
--cpdef CSR pow_csr(CSR matrix, unsigned long long n)
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+
-+cpdef CSR pow_csr(CSR matrix, unsigned long long n)
-diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
-index b90a1a44..7c0c6bf7 100644
---- a/qutip/core/data/pow.pyx
-+++ b/qutip/core/data/pow.pyx
-@@ -1,86 +1,86 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--cimport cython
--
--from qutip.core.data cimport csr, dense
--from qutip.core.data.csr cimport CSR
--from qutip.core.data.dense cimport Dense
--from qutip.core.data.matmul cimport matmul_csr
--import numpy as np
--
--__all__ = [
--    'pow', 'pow_csr', 'pow_dense',
--]
--
--
--@cython.nonecheck(False)
--@cython.cdivision(True)
--cpdef CSR pow_csr(CSR matrix, unsigned long long n):
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("matrix power only works with square matrices")
--    if n == 0:
--        return csr.identity(matrix.shape[0])
--    if n == 1:
--        return matrix.copy()
--    # We do the matrix power in terms of powers of two, so we can do it
--    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
--    # number of set bits in the input.
--    #
--    # We don't have to do matrix.copy() or pow.copy() here, because we've
--    # guaranteed that we won't be returning without at least one matrix
--    # multiplcation, which will allocate a new matrix.
--    cdef CSR pow = matrix
--    cdef CSR out = pow if n & 1 else None
--    n >>= 1
--    while n:
--        pow = matmul_csr(pow, pow)
--        if n & 1:
--            out = pow if out is None else matmul_csr(out, pow)
--        n >>= 1
--    return out
--
--
--cpdef Dense pow_dense(Dense matrix, unsigned long long n):
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("matrix power only works with square matrices")
--    if n == 0:
--        return dense.identity(matrix.shape[0])
--    if n == 1:
--        return matrix.copy()
--    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--pow = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='pow',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--pow.__doc__ =\
--    """
--    Compute the integer matrix power of the square input matrix.  The power
--    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
--    the same shape.
--
--    Parameters
--    ----------
--    matrix : Data
--        Input matrix to take the power of.
--
--    n : non-negative integer
--        The power to which to raise the matrix.
--    """
--pow.add_specialisations([
--    (CSR, CSR, pow_csr),
--    (Dense, Dense, pow_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+cimport cython
-+
-+from qutip.core.data cimport csr, dense
-+from qutip.core.data.csr cimport CSR
-+from qutip.core.data.dense cimport Dense
-+from qutip.core.data.matmul cimport matmul_csr
-+import numpy as np
-+
-+__all__ = [
-+    'pow', 'pow_csr', 'pow_dense',
-+]
-+
-+
-+@cython.nonecheck(False)
-+@cython.cdivision(True)
-+cpdef CSR pow_csr(CSR matrix, unsigned long long n):
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("matrix power only works with square matrices")
-+    if n == 0:
-+        return csr.identity(matrix.shape[0])
-+    if n == 1:
-+        return matrix.copy()
-+    # We do the matrix power in terms of powers of two, so we can do it
-+    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
-+    # number of set bits in the input.
-+    #
-+    # We don't have to do matrix.copy() or pow.copy() here, because we've
-+    # guaranteed that we won't be returning without at least one matrix
-+    # multiplcation, which will allocate a new matrix.
-+    cdef CSR pow = matrix
-+    cdef CSR out = pow if n & 1 else None
-+    n >>= 1
-+    while n:
-+        pow = matmul_csr(pow, pow)
-+        if n & 1:
-+            out = pow if out is None else matmul_csr(out, pow)
-+        n >>= 1
-+    return out
-+
-+
-+cpdef Dense pow_dense(Dense matrix, unsigned long long n):
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("matrix power only works with square matrices")
-+    if n == 0:
-+        return dense.identity(matrix.shape[0])
-+    if n == 1:
-+        return matrix.copy()
-+    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+pow = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='pow',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+pow.__doc__ =\
-+    """
-+    Compute the integer matrix power of the square input matrix.  The power
-+    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
-+    the same shape.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        Input matrix to take the power of.
-+
-+    n : non-negative integer
-+        The power to which to raise the matrix.
-+    """
-+pow.add_specialisations([
-+    (CSR, CSR, pow_csr),
-+    (Dense, Dense, pow_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/project.pxd b/qutip/core/data/project.pxd
-index 07dabb79..86baf762 100644
---- a/qutip/core/data/project.pxd
-+++ b/qutip/core/data/project.pxd
-@@ -1,5 +1,5 @@
--#cython: language_level=3
--
--from qutip.core.data.csr cimport CSR
--
--cpdef CSR project_csr(CSR state)
-+#cython: language_level=3
-+
-+from qutip.core.data.csr cimport CSR
-+
-+cpdef CSR project_csr(CSR state)
-diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
-index b88771e3..03a8bf73 100644
---- a/qutip/core/data/project.pyx
-+++ b/qutip/core/data/project.pyx
-@@ -1,144 +1,144 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.string cimport memcpy
--
--from qutip.core.data.base cimport idxint
--from qutip.core.data cimport csr, dense, Dense
--from qutip.core.data.csr cimport CSR
--
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex conj(double complex x)
--
--__all__ = [
--    'project', 'project_csr', 'project_dense',
--]
--
--
--cdef void _project_ket_csr(CSR ket, CSR out) nogil:
--    """
--    Calculate the projection of the given ket, and place the output in out.
--    """
--    cdef size_t row, ptr, offset=0
--    cdef idxint nnz_in = csr.nnz(ket)
--    for row in range(ket.shape[0]):
--        out.row_index[row] = ket.row_index[row] * nnz_in
--        if ket.row_index[row + 1] != ket.row_index[row]:
--            for ptr in range(nnz_in):
--                out.col_index[offset + ptr*nnz_in] = row
--            offset += 1
--    out.row_index[ket.shape[0]] = nnz_in * nnz_in
--    offset = 0
--    for row in range(nnz_in):
--        for ptr in range(nnz_in):
--            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
--        offset += nnz_in
--
--
--cdef void _project_bra_csr(CSR bra, CSR out) nogil:
--    """
--    Calculate the projection of the given bra, and place the output in out.
--    """
--    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
--    cdef double complex mul
--    cdef idxint nnz_in = csr.nnz(bra)
--    # The algorithm is much more simple conceptually if the indices are sorted,
--    # and doesn't affect runtime much since sorting is worst-case
--    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
--    # sort now than later while there are fewer entries.  No need to sort when
--    # projecting a ket because all the col_index values are 0.
--    with gil:
--        bra.sort_indices()
--    out.row_index[0] = cur
--    for ptr_bra in range(nnz_in):
--        # Handle all zero rows between the last non-zero entry and this one.
--        for row_out in range(row_out, bra.col_index[ptr_bra]):
--            out.row_index[row_out + 1] = cur
--        row_out = bra.col_index[ptr_bra]
--        cur += nnz_in
--        out.row_index[row_out + 1] = cur
--        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
--        mul = conj(bra.data[ptr_bra])
--        for ptr in range(nnz_in):
--            out.data[ptr_out] = mul * bra.data[ptr]
--            ptr_out += 1
--        row_out += 1
--    # Handle all zero rows after the last non-zero entry.
--    for row_out in range(row_out, out.shape[0]):
--        out.row_index[row_out + 1] = cur
--
--cpdef CSR project_csr(CSR state):
--    """
--    Calculate the projection |state><state|.  The shape of `state` will be used
--    to determine if it has been supplied as a ket or a bra.  The result of this
--    function will be identical is passed `state` or `adjoint(state)`.
--    """
--    cdef size_t nnz_in = csr.nnz(state)
--    cdef CSR out
--    # We don't actually need to both handling the shape=(1, 1) case specially,
--    # because it doesn't matter if we interpret it as a ket or a bra---the
--    # output will be a shape=(1, 1) matrix with the only data element equal to
--    # abs(state.data[0])**2 either way.
--    if state.shape[1] == 1:
--        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
--        _project_ket_csr(state, out)
--        return out
--    if state.shape[0] == 1:
--        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
--        _project_bra_csr(state, out)
--        return out
--    raise ValueError("state must be a ket or a bra.")
--
--cpdef Dense project_dense(Dense state):
--    """
--    Calculate the projection |state><state|.  The shape of `state` will be used
--    to determine if it has been supplied as a ket or a bra.  The result of this
--    function will be identical is passed `state` or `adjoint(state)`.
--    """
--    cdef Dense out
--    cdef size_t size, i
--    cdef bint fortran
--    if state.shape[1] == 1:
--        size = state.shape[0]
--        fortran = True
--    elif state.shape[0] == 1:
--        size = state.shape[1]
--        fortran = False
--    else:
--        raise ValueError("state must be a ket or a bra.")
--    out = dense.zeros(size, size, fortran)
--    for i in range(size):
--        for j in range(size):
--            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
--    return out
--
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--project = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='project',
--    module=__name__,
--    inputs=('state',),
--    out=True,
--)
--project.__doc__ =\
--    """
--    Get the projector of a state with itself.  Mathematically, if passed an
--    object `|a>` or `<a|`, then return the matrix `|a><a|`.
--
--    Parameters
--    ----------
--    state : Data
--        The input state bra- or ket-like vector.
--    """
--project.add_specialisations([
--    (CSR, CSR, project_csr),
--    (Dense, Dense, project_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.string cimport memcpy
-+
-+from qutip.core.data.base cimport idxint
-+from qutip.core.data cimport csr, dense, Dense
-+from qutip.core.data.csr cimport CSR
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex conj(double complex x)
-+
-+__all__ = [
-+    'project', 'project_csr', 'project_dense',
-+]
-+
-+
-+cdef void _project_ket_csr(CSR ket, CSR out) nogil:
-+    """
-+    Calculate the projection of the given ket, and place the output in out.
-+    """
-+    cdef size_t row, ptr, offset=0
-+    cdef idxint nnz_in = csr.nnz(ket)
-+    for row in range(ket.shape[0]):
-+        out.row_index[row] = ket.row_index[row] * nnz_in
-+        if ket.row_index[row + 1] != ket.row_index[row]:
-+            for ptr in range(nnz_in):
-+                out.col_index[offset + ptr*nnz_in] = row
-+            offset += 1
-+    out.row_index[ket.shape[0]] = nnz_in * nnz_in
-+    offset = 0
-+    for row in range(nnz_in):
-+        for ptr in range(nnz_in):
-+            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
-+        offset += nnz_in
-+
-+
-+cdef void _project_bra_csr(CSR bra, CSR out) nogil:
-+    """
-+    Calculate the projection of the given bra, and place the output in out.
-+    """
-+    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
-+    cdef double complex mul
-+    cdef idxint nnz_in = csr.nnz(bra)
-+    # The algorithm is much more simple conceptually if the indices are sorted,
-+    # and doesn't affect runtime much since sorting is worst-case
-+    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
-+    # sort now than later while there are fewer entries.  No need to sort when
-+    # projecting a ket because all the col_index values are 0.
-+    with gil:
-+        bra.sort_indices()
-+    out.row_index[0] = cur
-+    for ptr_bra in range(nnz_in):
-+        # Handle all zero rows between the last non-zero entry and this one.
-+        for row_out in range(row_out, bra.col_index[ptr_bra]):
-+            out.row_index[row_out + 1] = cur
-+        row_out = bra.col_index[ptr_bra]
-+        cur += nnz_in
-+        out.row_index[row_out + 1] = cur
-+        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
-+        mul = conj(bra.data[ptr_bra])
-+        for ptr in range(nnz_in):
-+            out.data[ptr_out] = mul * bra.data[ptr]
-+            ptr_out += 1
-+        row_out += 1
-+    # Handle all zero rows after the last non-zero entry.
-+    for row_out in range(row_out, out.shape[0]):
-+        out.row_index[row_out + 1] = cur
-+
-+cpdef CSR project_csr(CSR state):
-+    """
-+    Calculate the projection |state><state|.  The shape of `state` will be used
-+    to determine if it has been supplied as a ket or a bra.  The result of this
-+    function will be identical is passed `state` or `adjoint(state)`.
-+    """
-+    cdef size_t nnz_in = csr.nnz(state)
-+    cdef CSR out
-+    # We don't actually need to both handling the shape=(1, 1) case specially,
-+    # because it doesn't matter if we interpret it as a ket or a bra---the
-+    # output will be a shape=(1, 1) matrix with the only data element equal to
-+    # abs(state.data[0])**2 either way.
-+    if state.shape[1] == 1:
-+        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
-+        _project_ket_csr(state, out)
-+        return out
-+    if state.shape[0] == 1:
-+        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
-+        _project_bra_csr(state, out)
-+        return out
-+    raise ValueError("state must be a ket or a bra.")
-+
-+cpdef Dense project_dense(Dense state):
-+    """
-+    Calculate the projection |state><state|.  The shape of `state` will be used
-+    to determine if it has been supplied as a ket or a bra.  The result of this
-+    function will be identical is passed `state` or `adjoint(state)`.
-+    """
-+    cdef Dense out
-+    cdef size_t size, i
-+    cdef bint fortran
-+    if state.shape[1] == 1:
-+        size = state.shape[0]
-+        fortran = True
-+    elif state.shape[0] == 1:
-+        size = state.shape[1]
-+        fortran = False
-+    else:
-+        raise ValueError("state must be a ket or a bra.")
-+    out = dense.zeros(size, size, fortran)
-+    for i in range(size):
-+        for j in range(size):
-+            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
-+    return out
-+
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+project = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='project',
-+    module=__name__,
-+    inputs=('state',),
-+    out=True,
-+)
-+project.__doc__ =\
-+    """
-+    Get the projector of a state with itself.  Mathematically, if passed an
-+    object `|a>` or `<a|`, then return the matrix `|a><a|`.
-+
-+    Parameters
-+    ----------
-+    state : Data
-+        The input state bra- or ket-like vector.
-+    """
-+project.add_specialisations([
-+    (CSR, CSR, project_csr),
-+    (Dense, Dense, project_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/properties.pxd b/qutip/core/data/properties.pxd
-index 57424d96..9ce22e12 100644
---- a/qutip/core/data/properties.pxd
-+++ b/qutip/core/data/properties.pxd
-@@ -1,8 +1,8 @@
--#cython: language_level=3
--
--from qutip.core.data cimport CSR, Dense
--
--cpdef bint isherm_csr(CSR matrix, double tol=*)
--cpdef bint isdiag_csr(CSR matrix) nogil
--cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
--cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
-+#cython: language_level=3
-+
-+from qutip.core.data cimport CSR, Dense
-+
-+cpdef bint isherm_csr(CSR matrix, double tol=*)
-+cpdef bint isdiag_csr(CSR matrix) nogil
-+cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
-+cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
-diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
-index ded226cb..38116cab 100644
---- a/qutip/core/data/properties.pyx
-+++ b/qutip/core/data/properties.pyx
-@@ -1,319 +1,319 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--cimport cython
--from cpython cimport mem
--
--from qutip.settings import settings
--
--from qutip.core.data.base cimport idxint
--from qutip.core.data cimport csr, dense, CSR, Dense
--from qutip.core.data.adjoint cimport transpose_csr
--
--cdef extern from *:
--    # Not defined in cpython.mem for some reason, but is in pymem.h.
--    void *PyMem_Calloc(size_t nelem, size_t elsize)
--
--__all__ = [
--    'isherm', 'isherm_csr', 'isherm_dense',
--    'isdiag', 'isdiag_csr', 'isdiag_dense',
--    'iszero', 'iszero_csr', 'iszero_dense',
--]
--
--cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
--    """Check whether a == conj(b) up to an absolute tolerance."""
--    cdef double re = a.real - b.real
--    cdef double im = a.imag + b.imag
--    # Comparing the squares should be fine---there is possible precision loss
--    # in the addition, but as re*re and im*im are both positive semidefinite,
--    # the floating point result is strictly not greater than the true value.
--    # Save the cycles: don't sqrt.
--    return re*re + im*im < tol*tol
--
--cdef inline bint _feq_zero(double complex a, double tol) nogil:
--    return a.real*a.real + a.imag*a.imag < tol*tol
--
--cdef inline double _abssq(double complex x) nogil:
--    return x.real*x.real + x.imag*x.imag
--
--
--cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
--    """
--    Full, structural test for Hermicity of a matrix.  We assume that the input
--    matrix has already had its shape tested (must be square).
--
--    This test is only necessary when there is at least one value which is less
--    than the tolerance, and needed to be compared to an implicit zero.  In
--    general it is less efficient than the other test, and allocates more
--    memory.
--    """
--    cdef CSR transpose = transpose_csr(matrix)
--    cdef idxint row, ptr_a, ptr_b, col_a, col_b
--    for row in range(matrix.shape[0]):
--        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
--        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
--        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
--            # Doing this on every loop actually involves a few more
--            # de-references than are strictly necessary, but just
--            # simplifies the logic checking for the end of the row.
--            col_a = matrix.col_index[ptr_a]
--            col_b = transpose.col_index[ptr_b]
--            if col_a == col_b:
--                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
--                    return False
--                ptr_a += 1
--                ptr_b += 1
--            elif col_a < col_b:
--                if not _feq_zero(matrix.data[ptr_a], tol):
--                    return False
--                ptr_a += 1
--            else:
--                if not _feq_zero(transpose.data[ptr_b], tol):
--                    return False
--                ptr_b += 1
--        for ptr_a in range(ptr_a, ptr_a_end):
--            if not _feq_zero(matrix.data[ptr_a], tol):
--                return False
--        for ptr_b in range(ptr_b, ptr_b_end):
--            if not _feq_zero(transpose.data[ptr_b], tol):
--                return False
--    return True
--
--cpdef bint isherm_csr(CSR matrix, double tol=-1):
--    """
--    Determine whether an input CSR matrix is Hermitian up to a given
--    floating-point tolerance.
--
--    Parameters
--    ----------
--    matrix : CSR
--        Input matrix to test
--    tol : double, optional
--        Absolute tolerance value to use.  Defaults to
--        :obj:`settings.core['atol']`.
--
--    Returns
--    -------
--    bint
--        Boolean True if it is Hermitian, False if not.
--
--    Notes
--    -----
--    The implementation is effectively just taking the adjoint, but rather than
--    actually allocating and creating a new matrix, we just check whether the
--    output would match the input matrix.  If we cannot be certain of Hermicity
--    because the sizes of some elements are within tolerance of 0, we have to
--    resort to a complete adjoint calculation.
--    """
--    tol = tol if tol >= 0 else settings.core["atol"]
--    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
--    if matrix.shape[0] != matrix.shape[1]:
--        return False
--    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
--    if out_row_index == NULL:
--        raise MemoryError
--    matrix.sort_indices()
--    try:
--        for row in range(nrows):
--            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--                col = matrix.col_index[ptr] + 1
--                out_row_index[col] += 1
--        for row in range(nrows):
--            out_row_index[row+1] += out_row_index[row]
--            if out_row_index[row + 1] != matrix.row_index[row + 1]:
--                # Structures are not the same, but it could still be Hermitian
--                # if any value is less than the tolerance.  That is the
--                # worst-case scenario, so we sacrifice its speed in favour of
--                # returning faster for the more common failure cases.
--                for ptr in range(matrix.row_index[nrows]):
--                    if _conj_feq(matrix.data[ptr], 0, tol):
--                        return _isherm_csr_full(matrix, tol)
--                return False
--        for row in range(nrows):
--            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--                col = matrix.col_index[ptr]
--                # Pointer into the "transposed" matrix.
--                ptr_t = out_row_index[col]
--                out_row_index[col] += 1
--                if row != matrix.col_index[ptr_t]:
--                    return _isherm_csr_full(matrix, tol)
--                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
--                    return False
--        return True
--    finally:
--        mem.PyMem_Free(out_row_index)
--
--
--cpdef bint isherm_dense(Dense matrix, double tol=-1):
--    """
--    Determine whether an input Dense matrix is Hermitian up to a given
--    floating-point tolerance.
--
--    Parameters
--    ----------
--    matrix : Dense
--        Input matrix to test
--    tol : double, optional
--        Absolute tolerance value to use.  Defaults to
--        :obj:`settings.core['atol']`.
--
--    Returns
--    -------
--    bint
--        Boolean True if it is Hermitian, False if not.
--    """
--    if matrix.shape[0] != matrix.shape[1]:
--        return False
--    tol = tol if tol >= 0 else settings.core["atol"]
--    cdef size_t row, col, size=matrix.shape[0]
--    for row in range(size):
--        for col in range(row + 1):
--            if not _conj_feq(
--                matrix.data[col*size+row],
--                matrix.data[row*size+col],
--                tol
--            ):
--                return False
--    return True
--
--
--cpdef bint isdiag_csr(CSR matrix) nogil:
--    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
--    for row in range(matrix.shape[0]):
--        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
--        if ptr_end - ptr_start > 1:
--            return False
--        if ptr_end - ptr_start == 1:
--            if matrix.col_index[ptr_start] != row:
--                return False
--    return True
--
--
--cpdef bint isdiag_dense(Dense matrix) nogil:
--    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
--    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
--    for row in range(matrix.shape[0]):
--        for col in range(matrix.shape[1]):
--            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
--                return False
--    return True
--
--
--cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
--    cdef size_t ptr
--    if tol < 0:
--        with gil:
--            tol = settings.core["atol"]
--    tolsq = tol*tol
--    for ptr in range(csr.nnz(matrix)):
--        if _abssq(matrix.data[ptr]) > tolsq:
--            return False
--    return True
--
--cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
--    cdef size_t ptr
--    if tol < 0:
--        with gil:
--            tol = settings.core["atol"]
--    tolsq = tol*tol
--    for ptr in range(matrix.shape[0]*matrix.shape[1]):
--        if _abssq(matrix.data[ptr]) > tolsq:
--            return False
--    return True
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--isherm = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=-1),
--    ]),
--    name='isherm',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--isherm.__doc__ =\
--    """
--    Check if the matrix is Hermitian up to a optional element-wise absolute
--    tolerance.  If the tolerance given is less than zero, the global settings
--    value `qutip.settings.atol` will be used instead.
--
--    Only square matrices can possibly be Hermitian.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to test for Hermicity.
--
--    tol : real, optional
--        If given, the absolute tolerance used to compare two values for
--        equality.  If not given, or given and negative, the value of
--        `qutip.settings.atol` is used instead.
--    """
--isherm.add_specialisations([
--    (Dense, isherm_dense),
--    (CSR, isherm_csr),
--], _defer=True)
--
--isdiag = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='isdiag',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--isdiag.__doc__ =\
--    """
--    Check if the matrix is diagonal.  The matrix need not be square to test.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to test for diagonality.
--    """
--isdiag.add_specialisations([
--    (Dense, isdiag_dense),
--    (CSR, isdiag_csr),
--], _defer=True)
--
--iszero = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=-1),
--    ]),
--    name='iszero',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--iszero.__doc__ =\
--    """
--    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to test.
--    tol : real, optional
--        The absolute tolerance to use when comparing to zero.  If not given, or
--        less than 0, use the core setting `atol`.
--
--    Returns
--    -------
--    bool
--        Whether the matrix is equivalent to 0 under the given absolute
--        tolerance.
--    """
--iszero.add_specialisations([
--    (CSR, iszero_csr),
--    (Dense, iszero_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+cimport cython
-+from cpython cimport mem
-+
-+from qutip.settings import settings
-+
-+from qutip.core.data.base cimport idxint
-+from qutip.core.data cimport csr, dense, CSR, Dense
-+from qutip.core.data.adjoint cimport transpose_csr
-+
-+cdef extern from *:
-+    # Not defined in cpython.mem for some reason, but is in pymem.h.
-+    void *PyMem_Calloc(size_t nelem, size_t elsize)
-+
-+__all__ = [
-+    'isherm', 'isherm_csr', 'isherm_dense',
-+    'isdiag', 'isdiag_csr', 'isdiag_dense',
-+    'iszero', 'iszero_csr', 'iszero_dense',
-+]
-+
-+cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
-+    """Check whether a == conj(b) up to an absolute tolerance."""
-+    cdef double re = a.real - b.real
-+    cdef double im = a.imag + b.imag
-+    # Comparing the squares should be fine---there is possible precision loss
-+    # in the addition, but as re*re and im*im are both positive semidefinite,
-+    # the floating point result is strictly not greater than the true value.
-+    # Save the cycles: don't sqrt.
-+    return re*re + im*im < tol*tol
-+
-+cdef inline bint _feq_zero(double complex a, double tol) nogil:
-+    return a.real*a.real + a.imag*a.imag < tol*tol
-+
-+cdef inline double _abssq(double complex x) nogil:
-+    return x.real*x.real + x.imag*x.imag
-+
-+
-+cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
-+    """
-+    Full, structural test for Hermicity of a matrix.  We assume that the input
-+    matrix has already had its shape tested (must be square).
-+
-+    This test is only necessary when there is at least one value which is less
-+    than the tolerance, and needed to be compared to an implicit zero.  In
-+    general it is less efficient than the other test, and allocates more
-+    memory.
-+    """
-+    cdef CSR transpose = transpose_csr(matrix)
-+    cdef idxint row, ptr_a, ptr_b, col_a, col_b
-+    for row in range(matrix.shape[0]):
-+        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
-+        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
-+        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
-+            # Doing this on every loop actually involves a few more
-+            # de-references than are strictly necessary, but just
-+            # simplifies the logic checking for the end of the row.
-+            col_a = matrix.col_index[ptr_a]
-+            col_b = transpose.col_index[ptr_b]
-+            if col_a == col_b:
-+                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
-+                    return False
-+                ptr_a += 1
-+                ptr_b += 1
-+            elif col_a < col_b:
-+                if not _feq_zero(matrix.data[ptr_a], tol):
-+                    return False
-+                ptr_a += 1
-+            else:
-+                if not _feq_zero(transpose.data[ptr_b], tol):
-+                    return False
-+                ptr_b += 1
-+        for ptr_a in range(ptr_a, ptr_a_end):
-+            if not _feq_zero(matrix.data[ptr_a], tol):
-+                return False
-+        for ptr_b in range(ptr_b, ptr_b_end):
-+            if not _feq_zero(transpose.data[ptr_b], tol):
-+                return False
-+    return True
-+
-+cpdef bint isherm_csr(CSR matrix, double tol=-1):
-+    """
-+    Determine whether an input CSR matrix is Hermitian up to a given
-+    floating-point tolerance.
-+
-+    Parameters
-+    ----------
-+    matrix : CSR
-+        Input matrix to test
-+    tol : double, optional
-+        Absolute tolerance value to use.  Defaults to
-+        :obj:`settings.core['atol']`.
-+
-+    Returns
-+    -------
-+    bint
-+        Boolean True if it is Hermitian, False if not.
-+
-+    Notes
-+    -----
-+    The implementation is effectively just taking the adjoint, but rather than
-+    actually allocating and creating a new matrix, we just check whether the
-+    output would match the input matrix.  If we cannot be certain of Hermicity
-+    because the sizes of some elements are within tolerance of 0, we have to
-+    resort to a complete adjoint calculation.
-+    """
-+    tol = tol if tol >= 0 else settings.core["atol"]
-+    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
-+    if matrix.shape[0] != matrix.shape[1]:
-+        return False
-+    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
-+    if out_row_index == NULL:
-+        raise MemoryError
-+    matrix.sort_indices()
-+    try:
-+        for row in range(nrows):
-+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+                col = matrix.col_index[ptr] + 1
-+                out_row_index[col] += 1
-+        for row in range(nrows):
-+            out_row_index[row+1] += out_row_index[row]
-+            if out_row_index[row + 1] != matrix.row_index[row + 1]:
-+                # Structures are not the same, but it could still be Hermitian
-+                # if any value is less than the tolerance.  That is the
-+                # worst-case scenario, so we sacrifice its speed in favour of
-+                # returning faster for the more common failure cases.
-+                for ptr in range(matrix.row_index[nrows]):
-+                    if _conj_feq(matrix.data[ptr], 0, tol):
-+                        return _isherm_csr_full(matrix, tol)
-+                return False
-+        for row in range(nrows):
-+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+                col = matrix.col_index[ptr]
-+                # Pointer into the "transposed" matrix.
-+                ptr_t = out_row_index[col]
-+                out_row_index[col] += 1
-+                if row != matrix.col_index[ptr_t]:
-+                    return _isherm_csr_full(matrix, tol)
-+                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
-+                    return False
-+        return True
-+    finally:
-+        mem.PyMem_Free(out_row_index)
-+
-+
-+cpdef bint isherm_dense(Dense matrix, double tol=-1):
-+    """
-+    Determine whether an input Dense matrix is Hermitian up to a given
-+    floating-point tolerance.
-+
-+    Parameters
-+    ----------
-+    matrix : Dense
-+        Input matrix to test
-+    tol : double, optional
-+        Absolute tolerance value to use.  Defaults to
-+        :obj:`settings.core['atol']`.
-+
-+    Returns
-+    -------
-+    bint
-+        Boolean True if it is Hermitian, False if not.
-+    """
-+    if matrix.shape[0] != matrix.shape[1]:
-+        return False
-+    tol = tol if tol >= 0 else settings.core["atol"]
-+    cdef size_t row, col, size=matrix.shape[0]
-+    for row in range(size):
-+        for col in range(row + 1):
-+            if not _conj_feq(
-+                matrix.data[col*size+row],
-+                matrix.data[row*size+col],
-+                tol
-+            ):
-+                return False
-+    return True
-+
-+
-+cpdef bint isdiag_csr(CSR matrix) nogil:
-+    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
-+    for row in range(matrix.shape[0]):
-+        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
-+        if ptr_end - ptr_start > 1:
-+            return False
-+        if ptr_end - ptr_start == 1:
-+            if matrix.col_index[ptr_start] != row:
-+                return False
-+    return True
-+
-+
-+cpdef bint isdiag_dense(Dense matrix) nogil:
-+    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
-+    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
-+    for row in range(matrix.shape[0]):
-+        for col in range(matrix.shape[1]):
-+            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
-+                return False
-+    return True
-+
-+
-+cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
-+    cdef size_t ptr
-+    if tol < 0:
-+        with gil:
-+            tol = settings.core["atol"]
-+    tolsq = tol*tol
-+    for ptr in range(csr.nnz(matrix)):
-+        if _abssq(matrix.data[ptr]) > tolsq:
-+            return False
-+    return True
-+
-+cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
-+    cdef size_t ptr
-+    if tol < 0:
-+        with gil:
-+            tol = settings.core["atol"]
-+    tolsq = tol*tol
-+    for ptr in range(matrix.shape[0]*matrix.shape[1]):
-+        if _abssq(matrix.data[ptr]) > tolsq:
-+            return False
-+    return True
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+isherm = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=-1),
-+    ]),
-+    name='isherm',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+isherm.__doc__ =\
-+    """
-+    Check if the matrix is Hermitian up to a optional element-wise absolute
-+    tolerance.  If the tolerance given is less than zero, the global settings
-+    value `qutip.settings.atol` will be used instead.
-+
-+    Only square matrices can possibly be Hermitian.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to test for Hermicity.
-+
-+    tol : real, optional
-+        If given, the absolute tolerance used to compare two values for
-+        equality.  If not given, or given and negative, the value of
-+        `qutip.settings.atol` is used instead.
-+    """
-+isherm.add_specialisations([
-+    (Dense, isherm_dense),
-+    (CSR, isherm_csr),
-+], _defer=True)
-+
-+isdiag = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='isdiag',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+isdiag.__doc__ =\
-+    """
-+    Check if the matrix is diagonal.  The matrix need not be square to test.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to test for diagonality.
-+    """
-+isdiag.add_specialisations([
-+    (Dense, isdiag_dense),
-+    (CSR, isdiag_csr),
-+], _defer=True)
-+
-+iszero = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=-1),
-+    ]),
-+    name='iszero',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+iszero.__doc__ =\
-+    """
-+    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to test.
-+    tol : real, optional
-+        The absolute tolerance to use when comparing to zero.  If not given, or
-+        less than 0, use the core setting `atol`.
-+
-+    Returns
-+    -------
-+    bool
-+        Whether the matrix is equivalent to 0 under the given absolute
-+        tolerance.
-+    """
-+iszero.add_specialisations([
-+    (CSR, iszero_csr),
-+    (Dense, iszero_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/ptrace.pxd b/qutip/core/data/ptrace.pxd
-index 6689bafa..a233d0c0 100644
---- a/qutip/core/data/ptrace.pxd
-+++ b/qutip/core/data/ptrace.pxd
-@@ -1,7 +1,7 @@
--#cython: language_level=3
--
--from qutip.core.data cimport CSR, Dense
--
--cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
--cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
--cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
-+#cython: language_level=3
-+
-+from qutip.core.data cimport CSR, Dense
-+
-+cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
-+cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
-+cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
-diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
-index 3e58e82d..e45522ef 100644
---- a/qutip/core/data/ptrace.pyx
-+++ b/qutip/core/data/ptrace.pyx
-@@ -1,216 +1,216 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
--
--import numbers
--
--import numpy as np
--
--cimport numpy as cnp
--
--from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
--from qutip.core.data.base import idxint_dtype
--from qutip.settings import settings
--
--cnp.import_array()
--
--__all__ = [
--    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
--]
--
--cdef tuple _parse_inputs(object dims, object sel, tuple shape):
--    cdef Py_ssize_t i
--
--    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
--    sel = np.atleast_1d(sel).astype(idxint_dtype)
--    sel.sort()
--
--    if shape[0] != shape[1]:
--        raise ValueError("ptrace is only defined for square density matrices")
--
--    if shape[0] != np.prod(dims, dtype=int):
--        raise ValueError(f"the input matrix shape, {shape} and the"
--                         f" dimension argument, {dims}, are not compatible.")
--    if sel.ndim != 1:
--        raise ValueError("Selection must be one-dimensional")
--
--    if any(d < 1 for d in dims):
--        raise ValueError("dimensions must be greated than zero but where"
--                         f" dims={dims}.")
--
--    for i in range(sel.shape[0]):
--        if sel[i] < 0 or sel[i] >= dims.size:
--            raise IndexError("Invalid selection index in ptrace.")
--        if i > 0 and sel[i] == sel[i - 1]:
--            raise ValueError("Duplicate selection index in ptrace.")
--
--    return dims, sel
--
--cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
--    """
--    Populate the helper structure `tensor_table`.  Returns the size (number of
--    rows and number of columns) of the matrix which will be output.
--    """
--    cdef size_t ii
--    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
--    cdef size_t num_dims = _dims.shape[0]
--    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
--    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
--    for ii in range(_sel.shape[0]):
--        if _sel[ii] < 0 or _sel[ii] >= num_dims:
--            raise TypeError("Invalid selection index in ptrace.")
--    for ii in range(num_dims - 1,-1,-1):
--        tensor_table[ii, 0] = factor_tensor
--        factor_tensor *= _dims[ii]
--        if _in(ii, _sel):
--            tensor_table[ii, 1] = factor_keep
--            factor_keep *= _dims[ii]
--        else:
--            tensor_table[ii, 2]  = factor_trace
--            factor_trace *= _dims[ii]
--    return factor_keep
--
--
--cdef bint _in(idxint val, idxint[::1] vec):
--    cdef int ii
--    for ii in range(vec.shape[0]):
--        if val == vec[ii]:
--            return True
--    return False
--
--
--cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
--    # indices determining function for ptrace
--    cdef size_t ii
--    cdef idxint t1, t2
--    out[0] = out[1] = 0
--    for ii in range(tensor_table.shape[0]):
--        t1 = tensor_table[ii, 0]
--        t2 = N / t1
--        N = N % t1
--        out[0] += tensor_table[ii, 1] * t2
--        out[1] += tensor_table[ii, 2] * t2
--
--
--cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
--    dims, sel = _parse_inputs(dims, sel, matrix.shape)
--
--    if len(sel) == len(dims):
--        return matrix.copy()
--    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
--    cdef idxint size
--    size = _populate_tensor_table(dims, sel, tensor_table)
--    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
--    cdef idxint pos_c[2]
--    cdef idxint pos_r[2]
--    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
--    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
--    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
--    cdef double tol = 0
--    if settings.core['auto_tidyup']:
--        tol = settings.core['auto_tidyup_atol']
--    for row in range(matrix.shape[0]):
--        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
--            _i2_k_t(row, tensor_table, pos_r)
--            if pos_c[1] == pos_r[1]:
--                new_data[p] = matrix.data[ptr]
--                new_row[p] = pos_r[0]
--                new_col[p] = pos_c[0]
--                p += 1
--    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
--                                 size, size, p, tol)
--
--
--cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
--    dims, sel = _parse_inputs(dims, sel, matrix.shape)
--
--    if len(sel) == len(dims):
--        return dense.from_csr(matrix)
--    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
--    cdef idxint size
--    size = _populate_tensor_table(dims, sel, tensor_table)
--    cdef size_t ii, jj
--    cdef idxint pos_c[2]
--    cdef idxint pos_r[2]
--    cdef Dense out = dense.zeros(size, size, fortran=False)
--    for ii in range(matrix.shape[0]):
--        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
--            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
--            _i2_k_t(ii, tensor_table, pos_r)
--            if pos_c[1] == pos_r[1]:
--                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
--    return out
--
--
--cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
--    dims, sel = _parse_inputs(dims, sel, matrix.shape)
--
--    if len(sel) == len(dims):
--        return matrix.copy()
--    nd = dims.shape[0]
--    dkeep = [dims[x] for x in sel]
--    qtrace = list(set(np.arange(nd)) - set(sel))
--    dtrace = [dims[x] for x in qtrace]
--    dims = list(dims)
--    sel = list(sel)
--    rhomat = np.trace(matrix.as_ndarray()
--                      .reshape(dims + dims)
--                      .transpose(qtrace + [nd + q for q in qtrace] +
--                                 sel + [nd + q for q in sel])
--                      .reshape([np.prod(dtrace, dtype=int),
--                                np.prod(dtrace, dtype=int),
--                                np.prod(dkeep, dtype=int),
--                                np.prod(dkeep, dtype=int)]))
--    return dense.fast_from_numpy(rhomat)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--ptrace = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='ptrace',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--ptrace.__doc__ =\
--    """
--    Compute the partial trace of this matrix, leaving the subspaces whose
--    indices are in `sel`.  This is only defined for square density matrices,
--    and always returns a density matrix.
--
--    The order of the indices in `sel` do not matter; the output matrix will
--    always have the selected subspaces in the same order that they are in the
--    input matrix.
--
--    For example, if the input is the matrix backing a `Qobj` with
--    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
--        ptrace(data, [2, 3, 4], [0, 2])
--    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
--
--    Parameters
--    ----------
--    matrix : Data
--        The density matrix to be partially traced.
--
--    dims : array_like of integer
--        The dimensions of the subspaces.  This is most likely a 1D list, and
--        since this is only defined on square matrices, there is no need to pass
--        before the left and right sides.  Typically the input matrix will be
--        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
--
--    sel : integer or array_like of integer
--        The indices of the subspaces which should be _kept_.
--    """
--ptrace.add_specialisations([
--    (CSR, CSR, ptrace_csr),
--    (CSR, Dense, ptrace_csr_dense),
--    (Dense, Dense, ptrace_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
-+
-+import numbers
-+
-+import numpy as np
-+
-+cimport numpy as cnp
-+
-+from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
-+from qutip.core.data.base import idxint_dtype
-+from qutip.settings import settings
-+
-+cnp.import_array()
-+
-+__all__ = [
-+    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
-+]
-+
-+cdef tuple _parse_inputs(object dims, object sel, tuple shape):
-+    cdef Py_ssize_t i
-+
-+    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
-+    sel = np.atleast_1d(sel).astype(idxint_dtype)
-+    sel.sort()
-+
-+    if shape[0] != shape[1]:
-+        raise ValueError("ptrace is only defined for square density matrices")
-+
-+    if shape[0] != np.prod(dims, dtype=int):
-+        raise ValueError(f"the input matrix shape, {shape} and the"
-+                         f" dimension argument, {dims}, are not compatible.")
-+    if sel.ndim != 1:
-+        raise ValueError("Selection must be one-dimensional")
-+
-+    if any(d < 1 for d in dims):
-+        raise ValueError("dimensions must be greated than zero but where"
-+                         f" dims={dims}.")
-+
-+    for i in range(sel.shape[0]):
-+        if sel[i] < 0 or sel[i] >= dims.size:
-+            raise IndexError("Invalid selection index in ptrace.")
-+        if i > 0 and sel[i] == sel[i - 1]:
-+            raise ValueError("Duplicate selection index in ptrace.")
-+
-+    return dims, sel
-+
-+cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
-+    """
-+    Populate the helper structure `tensor_table`.  Returns the size (number of
-+    rows and number of columns) of the matrix which will be output.
-+    """
-+    cdef size_t ii
-+    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
-+    cdef size_t num_dims = _dims.shape[0]
-+    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
-+    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
-+    for ii in range(_sel.shape[0]):
-+        if _sel[ii] < 0 or _sel[ii] >= num_dims:
-+            raise TypeError("Invalid selection index in ptrace.")
-+    for ii in range(num_dims - 1,-1,-1):
-+        tensor_table[ii, 0] = factor_tensor
-+        factor_tensor *= _dims[ii]
-+        if _in(ii, _sel):
-+            tensor_table[ii, 1] = factor_keep
-+            factor_keep *= _dims[ii]
-+        else:
-+            tensor_table[ii, 2]  = factor_trace
-+            factor_trace *= _dims[ii]
-+    return factor_keep
-+
-+
-+cdef bint _in(idxint val, idxint[::1] vec):
-+    cdef int ii
-+    for ii in range(vec.shape[0]):
-+        if val == vec[ii]:
-+            return True
-+    return False
-+
-+
-+cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
-+    # indices determining function for ptrace
-+    cdef size_t ii
-+    cdef idxint t1, t2
-+    out[0] = out[1] = 0
-+    for ii in range(tensor_table.shape[0]):
-+        t1 = tensor_table[ii, 0]
-+        t2 = N / t1
-+        N = N % t1
-+        out[0] += tensor_table[ii, 1] * t2
-+        out[1] += tensor_table[ii, 2] * t2
-+
-+
-+cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
-+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-+
-+    if len(sel) == len(dims):
-+        return matrix.copy()
-+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-+    cdef idxint size
-+    size = _populate_tensor_table(dims, sel, tensor_table)
-+    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
-+    cdef idxint pos_c[2]
-+    cdef idxint pos_r[2]
-+    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
-+    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
-+    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
-+    cdef double tol = 0
-+    if settings.core['auto_tidyup']:
-+        tol = settings.core['auto_tidyup_atol']
-+    for row in range(matrix.shape[0]):
-+        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
-+            _i2_k_t(row, tensor_table, pos_r)
-+            if pos_c[1] == pos_r[1]:
-+                new_data[p] = matrix.data[ptr]
-+                new_row[p] = pos_r[0]
-+                new_col[p] = pos_c[0]
-+                p += 1
-+    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
-+                                 size, size, p, tol)
-+
-+
-+cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
-+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-+
-+    if len(sel) == len(dims):
-+        return dense.from_csr(matrix)
-+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-+    cdef idxint size
-+    size = _populate_tensor_table(dims, sel, tensor_table)
-+    cdef size_t ii, jj
-+    cdef idxint pos_c[2]
-+    cdef idxint pos_r[2]
-+    cdef Dense out = dense.zeros(size, size, fortran=False)
-+    for ii in range(matrix.shape[0]):
-+        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
-+            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
-+            _i2_k_t(ii, tensor_table, pos_r)
-+            if pos_c[1] == pos_r[1]:
-+                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
-+    return out
-+
-+
-+cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
-+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-+
-+    if len(sel) == len(dims):
-+        return matrix.copy()
-+    nd = dims.shape[0]
-+    dkeep = [dims[x] for x in sel]
-+    qtrace = list(set(np.arange(nd)) - set(sel))
-+    dtrace = [dims[x] for x in qtrace]
-+    dims = list(dims)
-+    sel = list(sel)
-+    rhomat = np.trace(matrix.as_ndarray()
-+                      .reshape(dims + dims)
-+                      .transpose(qtrace + [nd + q for q in qtrace] +
-+                                 sel + [nd + q for q in sel])
-+                      .reshape([np.prod(dtrace, dtype=int),
-+                                np.prod(dtrace, dtype=int),
-+                                np.prod(dkeep, dtype=int),
-+                                np.prod(dkeep, dtype=int)]))
-+    return dense.fast_from_numpy(rhomat)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+ptrace = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='ptrace',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+ptrace.__doc__ =\
-+    """
-+    Compute the partial trace of this matrix, leaving the subspaces whose
-+    indices are in `sel`.  This is only defined for square density matrices,
-+    and always returns a density matrix.
-+
-+    The order of the indices in `sel` do not matter; the output matrix will
-+    always have the selected subspaces in the same order that they are in the
-+    input matrix.
-+
-+    For example, if the input is the matrix backing a `Qobj` with
-+    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
-+        ptrace(data, [2, 3, 4], [0, 2])
-+    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The density matrix to be partially traced.
-+
-+    dims : array_like of integer
-+        The dimensions of the subspaces.  This is most likely a 1D list, and
-+        since this is only defined on square matrices, there is no need to pass
-+        before the left and right sides.  Typically the input matrix will be
-+        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
-+
-+    sel : integer or array_like of integer
-+        The indices of the subspaces which should be _kept_.
-+    """
-+ptrace.add_specialisations([
-+    (CSR, CSR, ptrace_csr),
-+    (CSR, Dense, ptrace_csr_dense),
-+    (Dense, Dense, ptrace_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/reshape.pxd b/qutip/core/data/reshape.pxd
-index 4efae3a0..1b04512f 100644
---- a/qutip/core/data/reshape.pxd
-+++ b/qutip/core/data/reshape.pxd
-@@ -1,12 +1,12 @@
--#cython: language_level=3
--
--from qutip.core.data.base cimport idxint
--from qutip.core.data cimport CSR, Dense
--
--cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
--cpdef CSR column_stack_csr(CSR matrix)
--cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
--
--cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
--cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
--cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
-+#cython: language_level=3
-+
-+from qutip.core.data.base cimport idxint
-+from qutip.core.data cimport CSR, Dense
-+
-+cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
-+cpdef CSR column_stack_csr(CSR matrix)
-+cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
-+
-+cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
-+cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
-+cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
-diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
-index 6871e12c..aeb83a22 100644
---- a/qutip/core/data/reshape.pyx
-+++ b/qutip/core/data/reshape.pyx
-@@ -1,285 +1,285 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
--
--from libc.string cimport memcpy, memset
--
--cimport cython
--
--import warnings
--
--from qutip.core.data.base cimport idxint
--from qutip.core.data cimport csr, dense, CSR, Dense, Data
--
--__all__ = [
--    'reshape', 'reshape_csr', 'reshape_dense',
--    'column_stack', 'column_stack_csr', 'column_stack_dense',
--    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
--    'split_columns', 'split_columns_dense', 'split_columns_csr',
--]
--
--
--cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
--    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
--        message = "".join([
--            "cannot reshape ", str(matrix.shape), " to ",
--            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
--        ])
--        raise ValueError(message)
--    if n_rows_out <= 0 or n_cols_out <= 0:
--        raise ValueError("must have > 0 rows and columns")
--
--
--cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
--    cdef size_t ptr, row_in, row_out=0, loc, cur=0
--    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
--    cdef idxint nnz = csr.nnz(matrix)
--    cdef CSR out
--    _reshape_check_input(matrix, n_rows_out, n_cols_out)
--    out = csr.empty(n_rows_out, n_cols_out, nnz)
--    matrix.sort_indices()
--    with nogil:
--        # Since the indices are now sorted, the data arrays will be identical.
--        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
--        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
--        for row_in in range(n_rows_in):
--            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
--                loc = cur + matrix.col_index[ptr]
--                out.row_index[loc // n_cols_out + 1] += 1
--                out.col_index[ptr] = loc % n_cols_out
--            cur += n_cols_in
--        for row_out in range(n_rows_out):
--            out.row_index[row_out + 1] += out.row_index[row_out]
--    return out
--
--
--cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
--    return (idx // size) + (idx % size)
--
--
--cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
--    _reshape_check_input(matrix, n_rows_out, n_cols_out)
--    cdef Dense out
--    if not matrix.fortran:
--        out = matrix.copy()
--        out.shape = (n_rows_out, n_cols_out)
--        return out
--    out = dense.zeros(n_rows_out, n_cols_out)
--    cdef size_t idx_in=0, idx_out=0
--    cdef size_t size = n_rows_out * n_cols_out
--    # TODO: improve the algorithm here.
--    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
--    for idx_in in range(size):
--        out.data[idx_out] = matrix.data[idx_in]
--        idx_out = _reshape_dense_reindex(idx_out + stride, size)
--    return out
--
--
--cpdef CSR column_stack_csr(CSR matrix):
--    if matrix.shape[1] == 1:
--        return matrix.copy()
--    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
--
--
--cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
--    cdef Dense out
--    if inplace and matrix.fortran:
--        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
--        return matrix
--    if matrix.fortran:
--        out = matrix.copy()
--        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
--        return out
--    if inplace:
--        warnings.warn("cannot stack columns inplace for C-ordered matrix")
--    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
--
--
--cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
--    if matrix.shape[1] != 1:
--        raise ValueError("input is not a single column")
--    if rows < 1:
--        raise ValueError("rows must be a positive integer")
--    if matrix.shape[0] % rows:
--        raise ValueError("number of rows does not divide into the shape")
--
--
--cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
--    _column_unstack_check_shape(matrix, rows)
--    cdef idxint cols = matrix.shape[0] // rows
--    return reshape_csr(matrix, cols, rows).transpose()
--
--cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
--    _column_unstack_check_shape(matrix, rows)
--    cdef idxint cols = matrix.shape[0] // rows
--    if inplace and matrix.fortran:
--        matrix.shape = (rows, cols)
--        return matrix
--    elif inplace:
--        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
--    out = dense.empty(rows, cols, fortran=True)
--    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
--    return out
--
--
--cpdef list split_columns_dense(Dense matrix, copy=True):
--    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
--            for k in range(matrix.shape[1])]
--
--cpdef list split_columns_csr(CSR matrix, copy=True):
--    return [CSR(matrix.as_scipy()[:, k], copy=copy)
--            for k in range(matrix.shape[1])]
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--reshape = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='reshape',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--reshape.__doc__ =\
--    """
--    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
--    match the current total number of elements of the matrix.
--
--    Parameters
--    ----------
--    matrix : Data
--        The input matrix to reshape.
--
--    n_rows_out, n_cols_out : integer
--        The number of rows and columns in the output matrix.
--    """
--reshape.add_specialisations([
--    (CSR, CSR, reshape_csr),
--    (Dense, Dense, reshape_dense),
--], _defer=True)
--
--
--# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
--# signature of `column_stack` because the dispatcher logic currently doesn't
--# support the idea of an input parameter also being the output.
--
--column_stack = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='column_stack',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--column_stack.__doc__ =\
--    """
--    Stack the columns of a matrix so it becomes a ket-like vector.  For
--    example, the matrix
--        [[0, 1, 2],
--         [3, 4, 5],
--         [6, 7, 8]]
--    would be transformed to
--        [[0],
--         [3],
--         [6],
--         [1],
--         ...
--         [5],
--         [8]]
--    This is used for transforming between operator and operator-ket
--    representations in the super-operator formalism.
--
--    The inverse of this operation is `column_unstack`.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to stack the columns of.
--    """
--column_stack.add_specialisations([
--    (CSR, CSR, column_stack_csr),
--    (Dense, Dense, column_stack_dense),
--], _defer=True)
--
--column_unstack = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='column_unstack',
--    module=__name__,
--    inputs=('matrix',),
--    out=True,
--)
--column_unstack.__doc__ =\
--    """
--    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
--    number of rows.  For example, the matrix
--        [[0],
--         [1],
--         [2],
--         [3]]
--    would be unstacked with `rows = 2` to
--        [[0, 2],
--         [1, 3]]
--    This is used for transforming between the operator-ket and operator
--    representations in the super-operator formalism.
--
--    The inverse of this operation is `column_stack`.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to unstack the columns of.
--
--    rows : integer
--        The number of rows there should be in the output matrix.  This must
--        divide into the total number of elements in the input.
--    """
--column_unstack.add_specialisations([
--    (CSR, CSR, column_unstack_csr),
--    (Dense, Dense, column_unstack_dense),
--], _defer=True)
--
--
--split_columns = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=1),
--    ]),
--    name='split_columns',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--split_columns.__doc__ =\
--    """
--    Make a ket-shaped data out of each columns of the matrix.
--    This is used for to split the eigenvectors from :obj:`eigs`.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to unstack the columns of.
--
--    copy : bool, optional
--        The number of rows there should be in the output matrix.  This must
--        divide into the total number of elements in the input.
--
--    Returns
--    -------
--    kets : list
--        list of Data of each columns of the matrix.
--    """
--split_columns.add_specialisations([
--    (CSR, split_columns_csr),
--    (Dense, split_columns_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
-+
-+from libc.string cimport memcpy, memset
-+
-+cimport cython
-+
-+import warnings
-+
-+from qutip.core.data.base cimport idxint
-+from qutip.core.data cimport csr, dense, CSR, Dense, Data
-+
-+__all__ = [
-+    'reshape', 'reshape_csr', 'reshape_dense',
-+    'column_stack', 'column_stack_csr', 'column_stack_dense',
-+    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
-+    'split_columns', 'split_columns_dense', 'split_columns_csr',
-+]
-+
-+
-+cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
-+    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
-+        message = "".join([
-+            "cannot reshape ", str(matrix.shape), " to ",
-+            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
-+        ])
-+        raise ValueError(message)
-+    if n_rows_out <= 0 or n_cols_out <= 0:
-+        raise ValueError("must have > 0 rows and columns")
-+
-+
-+cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
-+    cdef size_t ptr, row_in, row_out=0, loc, cur=0
-+    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
-+    cdef idxint nnz = csr.nnz(matrix)
-+    cdef CSR out
-+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
-+    out = csr.empty(n_rows_out, n_cols_out, nnz)
-+    matrix.sort_indices()
-+    with nogil:
-+        # Since the indices are now sorted, the data arrays will be identical.
-+        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
-+        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
-+        for row_in in range(n_rows_in):
-+            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
-+                loc = cur + matrix.col_index[ptr]
-+                out.row_index[loc // n_cols_out + 1] += 1
-+                out.col_index[ptr] = loc % n_cols_out
-+            cur += n_cols_in
-+        for row_out in range(n_rows_out):
-+            out.row_index[row_out + 1] += out.row_index[row_out]
-+    return out
-+
-+
-+cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
-+    return (idx // size) + (idx % size)
-+
-+
-+cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
-+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
-+    cdef Dense out
-+    if not matrix.fortran:
-+        out = matrix.copy()
-+        out.shape = (n_rows_out, n_cols_out)
-+        return out
-+    out = dense.zeros(n_rows_out, n_cols_out)
-+    cdef size_t idx_in=0, idx_out=0
-+    cdef size_t size = n_rows_out * n_cols_out
-+    # TODO: improve the algorithm here.
-+    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
-+    for idx_in in range(size):
-+        out.data[idx_out] = matrix.data[idx_in]
-+        idx_out = _reshape_dense_reindex(idx_out + stride, size)
-+    return out
-+
-+
-+cpdef CSR column_stack_csr(CSR matrix):
-+    if matrix.shape[1] == 1:
-+        return matrix.copy()
-+    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
-+
-+
-+cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
-+    cdef Dense out
-+    if inplace and matrix.fortran:
-+        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
-+        return matrix
-+    if matrix.fortran:
-+        out = matrix.copy()
-+        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
-+        return out
-+    if inplace:
-+        warnings.warn("cannot stack columns inplace for C-ordered matrix")
-+    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
-+
-+
-+cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
-+    if matrix.shape[1] != 1:
-+        raise ValueError("input is not a single column")
-+    if rows < 1:
-+        raise ValueError("rows must be a positive integer")
-+    if matrix.shape[0] % rows:
-+        raise ValueError("number of rows does not divide into the shape")
-+
-+
-+cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
-+    _column_unstack_check_shape(matrix, rows)
-+    cdef idxint cols = matrix.shape[0] // rows
-+    return reshape_csr(matrix, cols, rows).transpose()
-+
-+cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
-+    _column_unstack_check_shape(matrix, rows)
-+    cdef idxint cols = matrix.shape[0] // rows
-+    if inplace and matrix.fortran:
-+        matrix.shape = (rows, cols)
-+        return matrix
-+    elif inplace:
-+        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
-+    out = dense.empty(rows, cols, fortran=True)
-+    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
-+    return out
-+
-+
-+cpdef list split_columns_dense(Dense matrix, copy=True):
-+    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
-+            for k in range(matrix.shape[1])]
-+
-+cpdef list split_columns_csr(CSR matrix, copy=True):
-+    return [CSR(matrix.as_scipy()[:, k], copy=copy)
-+            for k in range(matrix.shape[1])]
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+reshape = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='reshape',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+reshape.__doc__ =\
-+    """
-+    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
-+    match the current total number of elements of the matrix.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The input matrix to reshape.
-+
-+    n_rows_out, n_cols_out : integer
-+        The number of rows and columns in the output matrix.
-+    """
-+reshape.add_specialisations([
-+    (CSR, CSR, reshape_csr),
-+    (Dense, Dense, reshape_dense),
-+], _defer=True)
-+
-+
-+# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
-+# signature of `column_stack` because the dispatcher logic currently doesn't
-+# support the idea of an input parameter also being the output.
-+
-+column_stack = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='column_stack',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+column_stack.__doc__ =\
-+    """
-+    Stack the columns of a matrix so it becomes a ket-like vector.  For
-+    example, the matrix
-+        [[0, 1, 2],
-+         [3, 4, 5],
-+         [6, 7, 8]]
-+    would be transformed to
-+        [[0],
-+         [3],
-+         [6],
-+         [1],
-+         ...
-+         [5],
-+         [8]]
-+    This is used for transforming between operator and operator-ket
-+    representations in the super-operator formalism.
-+
-+    The inverse of this operation is `column_unstack`.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to stack the columns of.
-+    """
-+column_stack.add_specialisations([
-+    (CSR, CSR, column_stack_csr),
-+    (Dense, Dense, column_stack_dense),
-+], _defer=True)
-+
-+column_unstack = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='column_unstack',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=True,
-+)
-+column_unstack.__doc__ =\
-+    """
-+    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
-+    number of rows.  For example, the matrix
-+        [[0],
-+         [1],
-+         [2],
-+         [3]]
-+    would be unstacked with `rows = 2` to
-+        [[0, 2],
-+         [1, 3]]
-+    This is used for transforming between the operator-ket and operator
-+    representations in the super-operator formalism.
-+
-+    The inverse of this operation is `column_stack`.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to unstack the columns of.
-+
-+    rows : integer
-+        The number of rows there should be in the output matrix.  This must
-+        divide into the total number of elements in the input.
-+    """
-+column_unstack.add_specialisations([
-+    (CSR, CSR, column_unstack_csr),
-+    (Dense, Dense, column_unstack_dense),
-+], _defer=True)
-+
-+
-+split_columns = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=1),
-+    ]),
-+    name='split_columns',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+split_columns.__doc__ =\
-+    """
-+    Make a ket-shaped data out of each columns of the matrix.
-+    This is used for to split the eigenvectors from :obj:`eigs`.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to unstack the columns of.
-+
-+    copy : bool, optional
-+        The number of rows there should be in the output matrix.  This must
-+        divide into the total number of elements in the input.
-+
-+    Returns
-+    -------
-+    kets : list
-+        list of Data of each columns of the matrix.
-+    """
-+split_columns.add_specialisations([
-+    (CSR, split_columns_csr),
-+    (Dense, split_columns_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
-index a164d4f7..30cb4dd6 100644
---- a/qutip/core/data/solve.py
-+++ b/qutip/core/data/solve.py
-@@ -1,208 +1,208 @@
--from qutip.core.data import CSR, Data, csr, Dense
--import qutip.core.data as _data
--import scipy.sparse.linalg as splinalg
--import numpy as np
--from qutip.settings import settings
--if settings.has_mkl:
--    from qutip._mkl.spsolve import mkl_spsolve
--else:
--    mkl_spsolve = None
--
--
--def _splu(A, B, **kwargs):
--    lu = splinalg.splu(A, **kwargs)
--    return lu.solve(B)
--
--
--def solve_csr_dense(matrix: CSR, target: Dense, method=None,
--                    options: dict={}) -> Dense:
--    """
--    Solve ``Ax=b`` for ``x``.
--
--    Parameters:
--    -----------
--
--    matrix : CSR
--        The matrix ``A``.
--
--    target : Data
--        The matrix or vector ``b``.
--
--    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
--        The function to use to solve the system. Any function from
--        scipy.sparse.linalg which solve the equation Ax=b can be used.
--        `splu` from the same and `mkl_spsolve` are also valid choice.
--
--    options : dict
--        Keywork options to pass to the solver. Refer to the documenentation in
--        scipy.sparse.linalg of the used method for a list of supported keyword.
--        The keyword "csc" can be set to ``True`` to convert the sparse matrix
--        before passing it to the solver.
--
--    .. note::
--        Options for ``mkl_spsolve`` are presently only found in the source
--        code.
--
--    Returns:
--    --------
--    x : Dense
--        Solution to the system Ax = b.
--    """
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("can only solve using square matrix")
--    if matrix.shape[1] != target.shape[0]:
--        raise ValueError("target does not match the system")
--
--    b = target.as_ndarray()
--
--    method = method or "spsolve"
--
--    if method == "splu":
--        solver = _splu
--    elif hasattr(splinalg, method):
--        solver = getattr(splinalg, method)
--    elif method == "mkl_spsolve" and mkl_spsolve is None:
--        raise ValueError("mkl is not available")
--    elif method == "mkl_spsolve":
--        solver = mkl_spsolve
--    else:
--        raise ValueError(f"Unknown sparse solver {method}.")
--
--    options = options.copy()
--    M = matrix.as_scipy()
--    if options.pop("csc", False):
--        M = M.tocsc()
--
--    out = solver(M, b, **options)
--
--    if isinstance(out, tuple) and len(out) == 2:
--        # iterative method return a success flag
--        out, check = out
--        if check == 0:
--            # Successful
--            pass
--        elif check > 0:
--            raise RuntimeError(
--                f"scipy.sparse.linalg.{method} error: Tolerance was not"
--                f" reached. Error code: {check}"
--            )
--
--        elif check < 0:
--            raise RuntimeError(
--                f"scipy.sparse.linalg.{method} error: Bad input. "
--                f"Error code: {check}"
--            )
--    elif isinstance(out, tuple) and len(out) > 2:
--        # least sqare method return residual, flag, etc.
--        out, *_ = out
--    return Dense(out, copy=False)
--
--
--def solve_dense(matrix: Dense, target: Data, method=None,
--                options: dict={}) -> Dense:
--    """
--    Solve ``Ax=b`` for ``x``.
--
--    Parameters:
--    -----------
--
--    matrix : Dense
--        The matrix ``A``.
--
--    target : Data
--        The matrix or vector ``b``.
--
--    method : str {"solve", "lstsq"}, default="solve"
--        The function from numpy.linalg to use to solve the system.
--
--    options : dict
--        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
--        not use any.
--
--    Returns:
--    --------
--    x : Dense
--        Solution to the system Ax = b.
--    """
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("can only solve using square matrix")
--    if matrix.shape[1] != target.shape[0]:
--        raise ValueError("target does not match the system")
--
--    if isinstance(target, Dense):
--        b = target.as_ndarray()
--    else:
--        b = target.to_array()
--
--    if method in ["solve", None]:
--        out = np.linalg.solve(matrix.as_ndarray(), b)
--    elif method == "lstsq":
--        out, *_ = np.linalg.lstsq(
--            matrix.as_ndarray(),
--            b,
--            rcond=options.get("rcond", None)
--        )
--    else:
--        raise ValueError(f"Unknown solver {method},"
--                         " 'solve' and 'lstsq' are supported.")
--    return Dense(out, copy=False)
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--
--solve = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=None),
--        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default={}),
--    ]),
--    name='solve',
--    module=__name__,
--    inputs=('matrix', 'target'),
--    out=True,
--)
--solve.__doc__ = """
--    Solve ``Ax=b`` for ``x``.
--
--    Parameters:
--    -----------
--    matrix : Data
--    The matrix ``A``.
--
--    target : Data
--    The matrix or vector ``b``.
--
--    method : str
--        The function to use to solve the system. Function which solve the
--        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
--        numpy.linalg (Dense ``matrix``) can be used.
--        Sparse cases also accept `splu` and `mkl_spsolve`.
--
--    options : dict
--        Keywork options to pass to the solver. Refer to the documenentation
--        for the chosen method in scipy.sparse.linalg or numpy.linalg.
--        The keyword "csc" can be set to ``True`` to convert the sparse matrix
--        in sparse cases.
--
--    .. note::
--        Options for ``mkl_spsolve`` are presently only found in the source
--        code.
--
--    Returns:
--    --------
--    x : Data
--        Solution to the system Ax = b.
--"""
--solve.add_specialisations([
--    (CSR, Dense, Dense, solve_csr_dense),
--    (Dense, Dense, Dense, solve_dense),
--], _defer=True)
--
--
--del _Dispatcher
--del _inspect
-+from qutip.core.data import CSR, Data, csr, Dense
-+import qutip.core.data as _data
-+import scipy.sparse.linalg as splinalg
-+import numpy as np
-+from qutip.settings import settings
-+if settings.has_mkl:
-+    from qutip._mkl.spsolve import mkl_spsolve
-+else:
-+    mkl_spsolve = None
-+
-+
-+def _splu(A, B, **kwargs):
-+    lu = splinalg.splu(A, **kwargs)
-+    return lu.solve(B)
-+
-+
-+def solve_csr_dense(matrix: CSR, target: Dense, method=None,
-+                    options: dict={}) -> Dense:
-+    """
-+    Solve ``Ax=b`` for ``x``.
-+
-+    Parameters:
-+    -----------
-+
-+    matrix : CSR
-+        The matrix ``A``.
-+
-+    target : Data
-+        The matrix or vector ``b``.
-+
-+    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
-+        The function to use to solve the system. Any function from
-+        scipy.sparse.linalg which solve the equation Ax=b can be used.
-+        `splu` from the same and `mkl_spsolve` are also valid choice.
-+
-+    options : dict
-+        Keywork options to pass to the solver. Refer to the documenentation in
-+        scipy.sparse.linalg of the used method for a list of supported keyword.
-+        The keyword "csc" can be set to ``True`` to convert the sparse matrix
-+        before passing it to the solver.
-+
-+    .. note::
-+        Options for ``mkl_spsolve`` are presently only found in the source
-+        code.
-+
-+    Returns:
-+    --------
-+    x : Dense
-+        Solution to the system Ax = b.
-+    """
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("can only solve using square matrix")
-+    if matrix.shape[1] != target.shape[0]:
-+        raise ValueError("target does not match the system")
-+
-+    b = target.as_ndarray()
-+
-+    method = method or "spsolve"
-+
-+    if method == "splu":
-+        solver = _splu
-+    elif hasattr(splinalg, method):
-+        solver = getattr(splinalg, method)
-+    elif method == "mkl_spsolve" and mkl_spsolve is None:
-+        raise ValueError("mkl is not available")
-+    elif method == "mkl_spsolve":
-+        solver = mkl_spsolve
-+    else:
-+        raise ValueError(f"Unknown sparse solver {method}.")
-+
-+    options = options.copy()
-+    M = matrix.as_scipy()
-+    if options.pop("csc", False):
-+        M = M.tocsc()
-+
-+    out = solver(M, b, **options)
-+
-+    if isinstance(out, tuple) and len(out) == 2:
-+        # iterative method return a success flag
-+        out, check = out
-+        if check == 0:
-+            # Successful
-+            pass
-+        elif check > 0:
-+            raise RuntimeError(
-+                f"scipy.sparse.linalg.{method} error: Tolerance was not"
-+                f" reached. Error code: {check}"
-+            )
-+
-+        elif check < 0:
-+            raise RuntimeError(
-+                f"scipy.sparse.linalg.{method} error: Bad input. "
-+                f"Error code: {check}"
-+            )
-+    elif isinstance(out, tuple) and len(out) > 2:
-+        # least sqare method return residual, flag, etc.
-+        out, *_ = out
-+    return Dense(out, copy=False)
-+
-+
-+def solve_dense(matrix: Dense, target: Data, method=None,
-+                options: dict={}) -> Dense:
-+    """
-+    Solve ``Ax=b`` for ``x``.
-+
-+    Parameters:
-+    -----------
-+
-+    matrix : Dense
-+        The matrix ``A``.
-+
-+    target : Data
-+        The matrix or vector ``b``.
-+
-+    method : str {"solve", "lstsq"}, default="solve"
-+        The function from numpy.linalg to use to solve the system.
-+
-+    options : dict
-+        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
-+        not use any.
-+
-+    Returns:
-+    --------
-+    x : Dense
-+        Solution to the system Ax = b.
-+    """
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("can only solve using square matrix")
-+    if matrix.shape[1] != target.shape[0]:
-+        raise ValueError("target does not match the system")
-+
-+    if isinstance(target, Dense):
-+        b = target.as_ndarray()
-+    else:
-+        b = target.to_array()
-+
-+    if method in ["solve", None]:
-+        out = np.linalg.solve(matrix.as_ndarray(), b)
-+    elif method == "lstsq":
-+        out, *_ = np.linalg.lstsq(
-+            matrix.as_ndarray(),
-+            b,
-+            rcond=options.get("rcond", None)
-+        )
-+    else:
-+        raise ValueError(f"Unknown solver {method},"
-+                         " 'solve' and 'lstsq' are supported.")
-+    return Dense(out, copy=False)
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+
-+solve = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=None),
-+        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default={}),
-+    ]),
-+    name='solve',
-+    module=__name__,
-+    inputs=('matrix', 'target'),
-+    out=True,
-+)
-+solve.__doc__ = """
-+    Solve ``Ax=b`` for ``x``.
-+
-+    Parameters:
-+    -----------
-+    matrix : Data
-+    The matrix ``A``.
-+
-+    target : Data
-+    The matrix or vector ``b``.
-+
-+    method : str
-+        The function to use to solve the system. Function which solve the
-+        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
-+        numpy.linalg (Dense ``matrix``) can be used.
-+        Sparse cases also accept `splu` and `mkl_spsolve`.
-+
-+    options : dict
-+        Keywork options to pass to the solver. Refer to the documenentation
-+        for the chosen method in scipy.sparse.linalg or numpy.linalg.
-+        The keyword "csc" can be set to ``True`` to convert the sparse matrix
-+        in sparse cases.
-+
-+    .. note::
-+        Options for ``mkl_spsolve`` are presently only found in the source
-+        code.
-+
-+    Returns:
-+    --------
-+    x : Data
-+        Solution to the system Ax = b.
-+"""
-+solve.add_specialisations([
-+    (CSR, Dense, Dense, solve_csr_dense),
-+    (Dense, Dense, Dense, solve_dense),
-+], _defer=True)
-+
-+
-+del _Dispatcher
-+del _inspect
-diff --git a/qutip/core/data/src/intdtype.h b/qutip/core/data/src/intdtype.h
-index f88c65f9..40920a71 100644
---- a/qutip/core/data/src/intdtype.h
-+++ b/qutip/core/data/src/intdtype.h
-@@ -1,2 +1,2 @@
--typedef int32_t idxint;
--int _idxint_size=32;
-+typedef int32_t idxint;
-+int _idxint_size=32;
-diff --git a/qutip/core/data/src/matmul_csr_vector.cpp b/qutip/core/data/src/matmul_csr_vector.cpp
-index 2294f3b7..08424c02 100644
---- a/qutip/core/data/src/matmul_csr_vector.cpp
-+++ b/qutip/core/data/src/matmul_csr_vector.cpp
-@@ -1,116 +1,116 @@
--#include <complex>
--#if \
--    (defined(__GNUC__) && defined(__SSE3__))\
--    || (defined(_MSC_VER) && defined(__AVX__))
--/* If we're going to manually do the vectorisation, we need to make sure we've
-- * included the preprocessor directives.
-- */
--# include <pmmintrin.h>
--#endif
--
--#include "matmul_csr_vector.hpp"
--
--template <typename IntT>
--#if \
--    (defined(__GNUC__) && defined(__SSE3__))\
--    || (defined(_MSC_VER) && defined(__AVX__))
--/* Manually apply the vectorisation. */
--void _matmul_csr_vector(
--        const std::complex<double> * _RESTRICT data,
--        const IntT * _RESTRICT col_index,
--        const IntT * _RESTRICT row_index,
--        const std::complex<double> * _RESTRICT vec,
--        const std::complex<double> scale,
--        std::complex<double> * _RESTRICT out,
--        const IntT nrows)
--{
--    IntT row_start, row_end;
--    __m128d num1, num2, num3, num4;
--    for (IntT row=0; row < nrows; row++) {
--        num4 = _mm_setzero_pd();
--        row_start = row_index[row];
--        row_end = row_index[row+1];
--        for (IntT ptr=row_start; ptr < row_end; ptr++) {
--            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
--            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
--                              std::real(vec[col_index[ptr]]));
--            num3 = _mm_mul_pd(num2, num1);
--            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
--            num2 = _mm_shuffle_pd(num2, num2, 1);
--            num2 = _mm_mul_pd(num2, num1);
--            num3 = _mm_addsub_pd(num3, num2);
--            num4 = _mm_add_pd(num3, num4);
--        }
--        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
--        num3 = _mm_mul_pd(num4, num1);
--        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
--        num4 = _mm_shuffle_pd(num4, num4, 1);
--        num4 = _mm_mul_pd(num4, num1);
--        num3 = _mm_addsub_pd(num3, num4);
--        num2 = _mm_loadu_pd((double *)&out[row]);
--        num3 = _mm_add_pd(num2, num3);
--        _mm_storeu_pd((double *)&out[row], num3);
--    }
--}
--#else
--/* No manual vectorisation. */
--void _matmul_csr_vector(
--        const std::complex<double> * _RESTRICT data,
--        const IntT * _RESTRICT col_index,
--        const IntT * _RESTRICT row_index,
--        const std::complex<double> * _RESTRICT vec,
--        const std::complex<double> scale,
--        std::complex<double> * _RESTRICT out,
--        const IntT nrows)
--{
--    IntT row_start, row_end;
--    std::complex<double> dot;
--    for (size_t row=0; row < nrows; row++)
--    {
--        dot = 0;
--        row_start = row_index[row];
--        row_end = row_index[row+1];
--        for (size_t ptr=row_start; ptr < row_end; ptr++)
--        {
--            dot += data[ptr]*vec[col_index[ptr]];
--        }
--        out[row] += scale * dot;
--    }
--}
--#endif
--
--/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
-- * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
-- * latter causes compatibility issues with defining the sized types with the
-- * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
-- * three of `int`, `long` and `long long` when doing things this way (despite
-- * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
-- * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
-- * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
-- * and `long long`.
-- * - Jake Lishman 2020-08-10.
-- */
--template void _matmul_csr_vector<>(
--        const std::complex<double> * _RESTRICT,
--        const int * _RESTRICT,
--        const int * _RESTRICT,
--        const std::complex<double> * _RESTRICT,
--        const std::complex<double>,
--        std::complex<double> * _RESTRICT,
--        const int);
--template void _matmul_csr_vector<>(
--        const std::complex<double> * _RESTRICT,
--        const long * _RESTRICT,
--        const long * _RESTRICT,
--        const std::complex<double> * _RESTRICT,
--        const std::complex<double>,
--        std::complex<double> * _RESTRICT,
--        const long);
--template void _matmul_csr_vector<>(
--        const std::complex<double> * _RESTRICT,
--        const long long * _RESTRICT,
--        const long long * _RESTRICT,
--        const std::complex<double> * _RESTRICT,
--        const std::complex<double>,
--        std::complex<double> * _RESTRICT,
--        const long long);
-+#include <complex>
-+#if \
-+    (defined(__GNUC__) && defined(__SSE3__))\
-+    || (defined(_MSC_VER) && defined(__AVX__))
-+/* If we're going to manually do the vectorisation, we need to make sure we've
-+ * included the preprocessor directives.
-+ */
-+# include <pmmintrin.h>
-+#endif
-+
-+#include "matmul_csr_vector.hpp"
-+
-+template <typename IntT>
-+#if \
-+    (defined(__GNUC__) && defined(__SSE3__))\
-+    || (defined(_MSC_VER) && defined(__AVX__))
-+/* Manually apply the vectorisation. */
-+void _matmul_csr_vector(
-+        const std::complex<double> * _RESTRICT data,
-+        const IntT * _RESTRICT col_index,
-+        const IntT * _RESTRICT row_index,
-+        const std::complex<double> * _RESTRICT vec,
-+        const std::complex<double> scale,
-+        std::complex<double> * _RESTRICT out,
-+        const IntT nrows)
-+{
-+    IntT row_start, row_end;
-+    __m128d num1, num2, num3, num4;
-+    for (IntT row=0; row < nrows; row++) {
-+        num4 = _mm_setzero_pd();
-+        row_start = row_index[row];
-+        row_end = row_index[row+1];
-+        for (IntT ptr=row_start; ptr < row_end; ptr++) {
-+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
-+            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
-+                              std::real(vec[col_index[ptr]]));
-+            num3 = _mm_mul_pd(num2, num1);
-+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
-+            num2 = _mm_shuffle_pd(num2, num2, 1);
-+            num2 = _mm_mul_pd(num2, num1);
-+            num3 = _mm_addsub_pd(num3, num2);
-+            num4 = _mm_add_pd(num3, num4);
-+        }
-+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
-+        num3 = _mm_mul_pd(num4, num1);
-+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
-+        num4 = _mm_shuffle_pd(num4, num4, 1);
-+        num4 = _mm_mul_pd(num4, num1);
-+        num3 = _mm_addsub_pd(num3, num4);
-+        num2 = _mm_loadu_pd((double *)&out[row]);
-+        num3 = _mm_add_pd(num2, num3);
-+        _mm_storeu_pd((double *)&out[row], num3);
-+    }
-+}
-+#else
-+/* No manual vectorisation. */
-+void _matmul_csr_vector(
-+        const std::complex<double> * _RESTRICT data,
-+        const IntT * _RESTRICT col_index,
-+        const IntT * _RESTRICT row_index,
-+        const std::complex<double> * _RESTRICT vec,
-+        const std::complex<double> scale,
-+        std::complex<double> * _RESTRICT out,
-+        const IntT nrows)
-+{
-+    IntT row_start, row_end;
-+    std::complex<double> dot;
-+    for (size_t row=0; row < nrows; row++)
-+    {
-+        dot = 0;
-+        row_start = row_index[row];
-+        row_end = row_index[row+1];
-+        for (size_t ptr=row_start; ptr < row_end; ptr++)
-+        {
-+            dot += data[ptr]*vec[col_index[ptr]];
-+        }
-+        out[row] += scale * dot;
-+    }
-+}
-+#endif
-+
-+/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
-+ * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
-+ * latter causes compatibility issues with defining the sized types with the
-+ * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
-+ * three of `int`, `long` and `long long` when doing things this way (despite
-+ * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
-+ * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
-+ * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
-+ * and `long long`.
-+ * - Jake Lishman 2020-08-10.
-+ */
-+template void _matmul_csr_vector<>(
-+        const std::complex<double> * _RESTRICT,
-+        const int * _RESTRICT,
-+        const int * _RESTRICT,
-+        const std::complex<double> * _RESTRICT,
-+        const std::complex<double>,
-+        std::complex<double> * _RESTRICT,
-+        const int);
-+template void _matmul_csr_vector<>(
-+        const std::complex<double> * _RESTRICT,
-+        const long * _RESTRICT,
-+        const long * _RESTRICT,
-+        const std::complex<double> * _RESTRICT,
-+        const std::complex<double>,
-+        std::complex<double> * _RESTRICT,
-+        const long);
-+template void _matmul_csr_vector<>(
-+        const std::complex<double> * _RESTRICT,
-+        const long long * _RESTRICT,
-+        const long long * _RESTRICT,
-+        const std::complex<double> * _RESTRICT,
-+        const std::complex<double>,
-+        std::complex<double> * _RESTRICT,
-+        const long long);
-diff --git a/qutip/core/data/src/matmul_csr_vector.hpp b/qutip/core/data/src/matmul_csr_vector.hpp
-index 694329ac..4dd3e72e 100755
---- a/qutip/core/data/src/matmul_csr_vector.hpp
-+++ b/qutip/core/data/src/matmul_csr_vector.hpp
-@@ -1,17 +1,17 @@
--#include <complex>
--
--#if defined(__GNUC__) || defined(_MSC_VER)
--# define _RESTRICT __restrict
--#else
--# define _RESTRICT
--#endif
--
--template <typename IntT>
--void _matmul_csr_vector(
--        const std::complex<double> * _RESTRICT data,
--        const IntT * _RESTRICT col_index,
--        const IntT * _RESTRICT row_index,
--        const std::complex<double> * _RESTRICT vec,
--        const std::complex<double> scale,
--        std::complex<double> * _RESTRICT out,
--        const IntT nrows);
-+#include <complex>
-+
-+#if defined(__GNUC__) || defined(_MSC_VER)
-+# define _RESTRICT __restrict
-+#else
-+# define _RESTRICT
-+#endif
-+
-+template <typename IntT>
-+void _matmul_csr_vector(
-+        const std::complex<double> * _RESTRICT data,
-+        const IntT * _RESTRICT col_index,
-+        const IntT * _RESTRICT row_index,
-+        const std::complex<double> * _RESTRICT vec,
-+        const std::complex<double> scale,
-+        std::complex<double> * _RESTRICT out,
-+        const IntT nrows);
-diff --git a/qutip/core/data/tidyup.pxd b/qutip/core/data/tidyup.pxd
-index 44447145..cd88c290 100644
---- a/qutip/core/data/tidyup.pxd
-+++ b/qutip/core/data/tidyup.pxd
-@@ -1,7 +1,7 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from qutip.core.data cimport CSR, Dense
--
--cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
--cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from qutip.core.data cimport CSR, Dense
-+
-+cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
-+cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
-diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
-index a9b80798..b7338718 100644
---- a/qutip/core/data/tidyup.pyx
-+++ b/qutip/core/data/tidyup.pyx
-@@ -1,106 +1,106 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--from libc.math cimport fabs
--
--cimport numpy as cnp
--
--from qutip.core.data cimport csr, dense, CSR, Dense
--
--cdef extern from "<complex>" namespace "std" nogil:
--    # abs is templated such that Cython treats std::abs as complex->complex
--    double abs(double complex x)
--
--__all__ = [
--    'tidyup', 'tidyup_csr', 'tidyup_dense',
--]
--
--
--cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
--    cdef bint re, im
--    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
--    cdef double complex value
--    cdef CSR out = matrix if inplace else matrix.copy()
--    nnz = 0
--    out.row_index[0] = 0
--    for row in range(matrix.shape[0]):
--        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
--        for ptr in range(ptr_start, ptr_end):
--            re = im = False
--            value = matrix.data[ptr]
--            if fabs(value.real) < tol:
--                re = True
--                value.real = 0
--            if fabs(value.imag) < tol:
--                im = True
--                value.imag = 0
--            if not (re & im):
--                out.data[nnz] = value
--                out.col_index[nnz] = matrix.col_index[ptr]
--                nnz += 1
--        out.row_index[row + 1] = nnz
--    return out
--
--
--cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
--    cdef Dense out = matrix if inplace else matrix.copy()
--    cdef double complex value
--    cdef size_t ptr
--    for ptr in range(matrix.shape[0] * matrix.shape[1]):
--        value = matrix.data[ptr]
--        if fabs(value.real) < tol:
--            matrix.data[ptr].real = 0
--        if fabs(value.imag) < tol:
--            matrix.data[ptr].imag = 0
--    return out
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--# In this case, to support the `inplace` argument, we do not support
--# dispatching on the output.
--
--tidyup = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
--                           default=True),
--    ]),
--    name='tidyup',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--tidyup.__doc__ =\
--    """
--    Tidy up the input matrix by truncating small values to zero.  The real and
--    imaginary parts are treated individually, so (for example) the number
--        1e-18 + 2j
--    would be truncated with a tolerance of `1e-15` to just
--        2j
--
--    By default, this operation is in-place.  The output type will always match
--    the input type; no dispatching takes place on the output.
--
--    Parameters
--    ----------
--    matrix : Data
--        The matrix to tidy up.
--
--    tol : real
--        The absolute tolerance to use to determine whether a real or imaginary
--        part should be truncated to zero.
--
--    inplace : bool, optional (True)
--        Whether to do the operation in-place.  The output matrix will always be
--        returned, even if this argument is `True`; it will just be the same
--        Python object as was input.
--    """
--tidyup.add_specialisations([
--    (CSR, tidyup_csr),
--    (Dense, tidyup_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+from libc.math cimport fabs
-+
-+cimport numpy as cnp
-+
-+from qutip.core.data cimport csr, dense, CSR, Dense
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    # abs is templated such that Cython treats std::abs as complex->complex
-+    double abs(double complex x)
-+
-+__all__ = [
-+    'tidyup', 'tidyup_csr', 'tidyup_dense',
-+]
-+
-+
-+cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
-+    cdef bint re, im
-+    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
-+    cdef double complex value
-+    cdef CSR out = matrix if inplace else matrix.copy()
-+    nnz = 0
-+    out.row_index[0] = 0
-+    for row in range(matrix.shape[0]):
-+        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
-+        for ptr in range(ptr_start, ptr_end):
-+            re = im = False
-+            value = matrix.data[ptr]
-+            if fabs(value.real) < tol:
-+                re = True
-+                value.real = 0
-+            if fabs(value.imag) < tol:
-+                im = True
-+                value.imag = 0
-+            if not (re & im):
-+                out.data[nnz] = value
-+                out.col_index[nnz] = matrix.col_index[ptr]
-+                nnz += 1
-+        out.row_index[row + 1] = nnz
-+    return out
-+
-+
-+cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
-+    cdef Dense out = matrix if inplace else matrix.copy()
-+    cdef double complex value
-+    cdef size_t ptr
-+    for ptr in range(matrix.shape[0] * matrix.shape[1]):
-+        value = matrix.data[ptr]
-+        if fabs(value.real) < tol:
-+            matrix.data[ptr].real = 0
-+        if fabs(value.imag) < tol:
-+            matrix.data[ptr].imag = 0
-+    return out
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+# In this case, to support the `inplace` argument, we do not support
-+# dispatching on the output.
-+
-+tidyup = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-+                           default=True),
-+    ]),
-+    name='tidyup',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+tidyup.__doc__ =\
-+    """
-+    Tidy up the input matrix by truncating small values to zero.  The real and
-+    imaginary parts are treated individually, so (for example) the number
-+        1e-18 + 2j
-+    would be truncated with a tolerance of `1e-15` to just
-+        2j
-+
-+    By default, this operation is in-place.  The output type will always match
-+    the input type; no dispatching takes place on the output.
-+
-+    Parameters
-+    ----------
-+    matrix : Data
-+        The matrix to tidy up.
-+
-+    tol : real
-+        The absolute tolerance to use to determine whether a real or imaginary
-+        part should be truncated to zero.
-+
-+    inplace : bool, optional (True)
-+        Whether to do the operation in-place.  The output matrix will always be
-+        returned, even if this argument is `True`; it will just be the same
-+        Python object as was input.
-+    """
-+tidyup.add_specialisations([
-+    (CSR, tidyup_csr),
-+    (Dense, tidyup_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
-index e231896f..0c9a9d4d 100644
---- a/qutip/core/data/trace.pxd
-+++ b/qutip/core/data/trace.pxd
-@@ -1,9 +1,9 @@
--#cython: language_level=3
--
--from qutip.core.data cimport CSR, Dense
--
--cpdef double complex trace_csr(CSR matrix) nogil except *
--cpdef double complex trace_dense(Dense matrix) nogil except *
--
--cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
--cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
-+#cython: language_level=3
-+
-+from qutip.core.data cimport CSR, Dense
-+
-+cpdef double complex trace_csr(CSR matrix) nogil except *
-+cpdef double complex trace_dense(Dense matrix) nogil except *
-+
-+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
-+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
-diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
-index c256f537..5dec3f6d 100644
---- a/qutip/core/data/trace.pyx
-+++ b/qutip/core/data/trace.pyx
-@@ -1,109 +1,109 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False
--
--cimport cython
--from libc.math cimport sqrt
--
--from qutip.core.data cimport Data, CSR, Dense
--from qutip.core.data cimport base
--
--__all__ = [
--    'trace', 'trace_csr', 'trace_dense',
--    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
--]
--
--
--cdef void _check_shape(Data matrix) nogil except *:
--    if matrix.shape[0] != matrix.shape[1]:
--        raise ValueError("".join([
--            "matrix shape ", str(matrix.shape), " is not square.",
--        ]))
--
--
--cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
--    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
--        raise ValueError("".join([
--            "matrix ", str(matrix.shape), " is not a stacked square matrix."
--        ]))
--
--
--cpdef double complex trace_csr(CSR matrix) nogil except *:
--    _check_shape(matrix)
--    cdef size_t row, ptr
--    cdef double complex trace = 0
--    for row in range(matrix.shape[0]):
--        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
--            if matrix.col_index[ptr] == row:
--                trace += matrix.data[ptr]
--                break
--    return trace
--
--cpdef double complex trace_dense(Dense matrix) nogil except *:
--    _check_shape(matrix)
--    cdef double complex trace = 0
--    cdef size_t ptr = 0
--    cdef size_t stride = matrix.shape[0] + 1
--    for _ in range(matrix.shape[0]):
--        trace += matrix.data[ptr]
--        ptr += stride
--    return trace
--
--
--cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
--    cdef size_t N = <size_t>sqrt(matrix.shape[0])
--    _check_shape_oper_ket(N, matrix)
--    cdef size_t row
--    cdef double complex trace = 0
--    cdef size_t stride = N + 1
--    for row in range(N):
--        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
--            trace += matrix.data[matrix.row_index[row * stride]]
--    return trace
--
--cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
--    cdef size_t N = <size_t>sqrt(matrix.shape[0])
--    _check_shape_oper_ket(N, matrix)
--    cdef double complex trace = 0
--    cdef size_t ptr = 0
--    cdef size_t stride = N + 1
--    for ptr in range(N):
--        trace += matrix.data[ptr * stride]
--    return trace
--
--
--from .dispatch import Dispatcher as _Dispatcher
--import inspect as _inspect
--
--trace = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='trace',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--trace.__doc__ =\
--    """Compute the trace (sum of digaonal elements) of a square matrix."""
--trace.add_specialisations([
--    (CSR, trace_csr),
--    (Dense, trace_dense),
--], _defer=True)
--
--trace_oper_ket = _Dispatcher(
--    _inspect.Signature([
--        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
--    ]),
--    name='trace_oper_ket',
--    module=__name__,
--    inputs=('matrix',),
--    out=False,
--)
--trace_oper_ket.__doc__ =\
--    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
--trace_oper_ket.add_specialisations([
--    (CSR, trace_oper_ket_csr),
--    (Dense, trace_oper_ket_dense),
--], _defer=True)
--
--del _inspect, _Dispatcher
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False
-+
-+cimport cython
-+from libc.math cimport sqrt
-+
-+from qutip.core.data cimport Data, CSR, Dense
-+from qutip.core.data cimport base
-+
-+__all__ = [
-+    'trace', 'trace_csr', 'trace_dense',
-+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
-+]
-+
-+
-+cdef void _check_shape(Data matrix) nogil except *:
-+    if matrix.shape[0] != matrix.shape[1]:
-+        raise ValueError("".join([
-+            "matrix shape ", str(matrix.shape), " is not square.",
-+        ]))
-+
-+
-+cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
-+    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
-+        raise ValueError("".join([
-+            "matrix ", str(matrix.shape), " is not a stacked square matrix."
-+        ]))
-+
-+
-+cpdef double complex trace_csr(CSR matrix) nogil except *:
-+    _check_shape(matrix)
-+    cdef size_t row, ptr
-+    cdef double complex trace = 0
-+    for row in range(matrix.shape[0]):
-+        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-+            if matrix.col_index[ptr] == row:
-+                trace += matrix.data[ptr]
-+                break
-+    return trace
-+
-+cpdef double complex trace_dense(Dense matrix) nogil except *:
-+    _check_shape(matrix)
-+    cdef double complex trace = 0
-+    cdef size_t ptr = 0
-+    cdef size_t stride = matrix.shape[0] + 1
-+    for _ in range(matrix.shape[0]):
-+        trace += matrix.data[ptr]
-+        ptr += stride
-+    return trace
-+
-+
-+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
-+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
-+    _check_shape_oper_ket(N, matrix)
-+    cdef size_t row
-+    cdef double complex trace = 0
-+    cdef size_t stride = N + 1
-+    for row in range(N):
-+        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
-+            trace += matrix.data[matrix.row_index[row * stride]]
-+    return trace
-+
-+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
-+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
-+    _check_shape_oper_ket(N, matrix)
-+    cdef double complex trace = 0
-+    cdef size_t ptr = 0
-+    cdef size_t stride = N + 1
-+    for ptr in range(N):
-+        trace += matrix.data[ptr * stride]
-+    return trace
-+
-+
-+from .dispatch import Dispatcher as _Dispatcher
-+import inspect as _inspect
-+
-+trace = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='trace',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+trace.__doc__ =\
-+    """Compute the trace (sum of digaonal elements) of a square matrix."""
-+trace.add_specialisations([
-+    (CSR, trace_csr),
-+    (Dense, trace_dense),
-+], _defer=True)
-+
-+trace_oper_ket = _Dispatcher(
-+    _inspect.Signature([
-+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-+    ]),
-+    name='trace_oper_ket',
-+    module=__name__,
-+    inputs=('matrix',),
-+    out=False,
-+)
-+trace_oper_ket.__doc__ =\
-+    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
-+trace_oper_ket.add_specialisations([
-+    (CSR, trace_oper_ket_csr),
-+    (Dense, trace_oper_ket_dense),
-+], _defer=True)
-+
-+del _inspect, _Dispatcher
-diff --git a/qutip/core/dimensions.py b/qutip/core/dimensions.py
-index a2a4003a..612e97c8 100644
---- a/qutip/core/dimensions.py
-+++ b/qutip/core/dimensions.py
-@@ -1,345 +1,345 @@
--"""
--Internal use module for manipulating dims specifications.
--"""
--
--# Everything should be explicitly imported, not made available by default.
--
--import numpy as np
--from operator import getitem
--from functools import partial
--
--
--def is_scalar(dims):
--    """
--    Returns True if a dims specification is effectively
--    a scalar (has dimension 1).
--    """
--    return np.prod(flatten(dims)) == 1
--
--
--def is_vector(dims):
--    return (
--        isinstance(dims, list) and
--        isinstance(dims[0], (int, np.integer))
--    )
--
--
--def is_vectorized_oper(dims):
--    return (
--        isinstance(dims, list) and
--        isinstance(dims[0], list)
--    )
--
--
--def type_from_dims(dims, enforce_square=False):
--    bra_like, ket_like = map(is_scalar, dims)
--
--    if bra_like:
--        if is_vector(dims[1]):
--            return 'bra'
--        elif is_vectorized_oper(dims[1]):
--            return 'operator-bra'
--
--    if ket_like:
--        if is_vector(dims[0]):
--            return 'ket'
--        elif is_vectorized_oper(dims[0]):
--            return 'operator-ket'
--
--    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
--        return 'oper'
--
--    elif (
--        is_vectorized_oper(dims[0])
--        and (
--            not enforce_square
--            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
--        )
--    ):
--        return 'super'
--    return 'other'
--
--
--def flatten(l):
--    """Flattens a list of lists to the first level.
--
--    Given a list containing a mix of scalars and lists,
--    flattens down to a list of the scalars within the original
--    list.
--
--    Examples
--    --------
--
--    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
--    [0, 1, 2]
--
--    """
--    if not isinstance(l, list):
--        return [l]
--    else:
--        return sum(map(flatten, l), [])
--
--
--def deep_remove(l, *what):
--    """Removes scalars from all levels of a nested list.
--
--    Given a list containing a mix of scalars and lists,
--    returns a list of the same structure, but where one or
--    more scalars have been removed.
--
--    Examples
--    --------
--
--    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
--    [[[[1, 2]], [3, 4], [], [6, 7]]]
--
--    """
--    if isinstance(l, list):
--        # Make a shallow copy at this level.
--        l = l[:]
--        for to_remove in what:
--            if to_remove in l:
--                l.remove(to_remove)
--            else:
--                l = [deep_remove(elem, to_remove) for elem in l]
--    return l
--
--
--def unflatten(l, idxs):
--    """Unflattens a list by a given structure.
--
--    Given a list of scalars and a deep list of indices
--    as produced by `flatten`, returns an "unflattened"
--    form of the list. This perfectly inverts `flatten`.
--
--    Examples
--    --------
--
--    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
--    >>> idxs = enumerate_flat(l) # doctest: +SKIP
--    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
--    True
--
--    """
--    acc = []
--    for idx in idxs:
--        if isinstance(idx, list):
--            acc.append(unflatten(l, idx))
--        else:
--            acc.append(l[idx])
--    return acc
--
--
--def _enumerate_flat(l, idx=0):
--    if not isinstance(l, list):
--        # Found a scalar, so return and increment.
--        return idx, idx + 1
--    else:
--        # Found a list, so append all the scalars
--        # from it and recurse to keep the increment
--        # correct.
--        acc = []
--        for elem in l:
--            labels, idx = _enumerate_flat(elem, idx)
--            acc.append(labels)
--        return acc, idx
--
--
--def _collapse_composite_index(dims):
--    """
--    Given the dimensions specification for a composite index
--    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
--    returns a dimensions specification for an index of the same shape,
--    but collapsed to a single "leg." In the previous example, [2, 3]
--    would collapse to [6].
--    """
--    return [np.prod(dims)]
--
--
--def _collapse_dims_to_level(dims, level=1):
--    """
--    Recursively collapses all indices in a dimensions specification
--    appearing at a given level, such that the returned dimensions
--    specification does not represent any composite systems.
--    """
--    if level == 0:
--        return _collapse_composite_index(dims)
--    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
--
--
--def collapse_dims_oper(dims):
--    """
--    Given the dimensions specifications for a ket-, bra- or oper-type
--    Qobj, returns a dimensions specification describing the same shape
--    by collapsing all composite systems. For instance, the bra-type
--    dimensions specification ``[[2, 3], [1]]`` collapses to
--    ``[[6], [1]]``.
--
--    Parameters
--    ----------
--
--    dims : list of lists of ints
--        Dimensions specifications to be collapsed.
--
--    Returns
--    -------
--
--    collapsed_dims : list of lists of ints
--        Collapsed dimensions specification describing the same shape
--        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
--    """
--    return _collapse_dims_to_level(dims, 1)
--
--
--def collapse_dims_super(dims):
--    """
--    Given the dimensions specifications for an operator-ket-, operator-bra- or
--    super-type Qobj, returns a dimensions specification describing the same shape
--    by collapsing all composite systems. For instance, the super-type
--    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
--    ``[[[6], [6]], [[6], [6]]]``.
--
--    Parameters
--    ----------
--
--    dims : list of lists of ints
--        Dimensions specifications to be collapsed.
--
--    Returns
--    -------
--
--    collapsed_dims : list of lists of ints
--        Collapsed dimensions specification describing the same shape
--        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
--        in ``range(2)``.
--    """
--    return _collapse_dims_to_level(dims, 2)
--
--
--def enumerate_flat(l):
--    """Labels the indices at which scalars occur in a flattened list.
--
--    Given a list containing a mix of scalars and lists,
--    returns a list of the same structure, where each scalar
--    has been replaced by an index into the flattened list.
--
--    Examples
--    --------
--
--    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
--    [[[0], [1, 2]], 3]
--
--    """
--    return _enumerate_flat(l)[0]
--
--
--def deep_map(fn, collection, over=(tuple, list)):
--    if isinstance(collection, over):
--        return type(collection)(deep_map(fn, el, over) for el in collection)
--    else:
--        return fn(collection)
--
--
--def dims_to_tensor_perm(dims):
--    """
--    Given the dims of a Qobj instance, returns a list representing
--    a permutation from the flattening of that dims specification to
--    the corresponding tensor indices.
--
--    Parameters
--    ----------
--
--    dims : list
--        Dimensions specification for a Qobj.
--
--    Returns
--    -------
--
--    perm : list
--        A list such that ``data[flatten(dims)[idx]]`` gives the
--        index of the tensor ``data`` corresponding to the ``idx``th
--        dimension of ``dims``.
--    """
--    # We figure out the type of the dims specification,
--    # relaxing the requirement that operators be square.
--    # This means that dims_type need not coincide with
--    # Qobj.type, but that works fine for our purposes here.
--    dims_type = type_from_dims(dims, enforce_square=False)
--    perm = enumerate_flat(dims)
--    if dims_type in ('oper', 'ket', 'bra'):
--        return flatten(perm)
--
--    # If the type is other, we need to figure out if the
--    # dims is superlike on its outputs and inputs
--    # This is the case if the dims type for left or right
--    # are, respectively, oper-like.
--    if dims_type == 'other':
--        raise NotImplementedError("Not yet implemented for type='other'.")
--
--    # If we're still here, the story is more complicated. We'll
--    # follow the strategy of creating a permutation by using
--    # enumerate_flat then transforming the result to swap
--    # input and output indices of vectorized matrices, then flattening
--    # the result. We'll then rebuild indices using this permutation.
--    if dims_type in ('operator-ket', 'super'):
--        # Swap the input and output spaces of the right part of
--        # perm.
--        perm[1] = list(reversed(perm[1]))
--    if dims_type in ('operator-bra', 'super'):
--        # Ditto, but for the left indices.
--        perm[0] = list(reversed(perm[0]))
--    return flatten(perm)
--
--
--def dims_to_tensor_shape(dims):
--    """
--    Given the dims of a Qobj instance, returns the shape of the
--    corresponding tensor. This helps, for instance, resolve the
--    column-stacking convention for superoperators.
--
--    Parameters
--    ----------
--
--    dims : list
--        Dimensions specification for a Qobj.
--
--    Returns
--    -------
--
--    tensor_shape : tuple
--        NumPy shape of the corresponding tensor.
--    """
--    perm = dims_to_tensor_perm(dims)
--    dims = flatten(dims)
--    return tuple(map(partial(getitem, dims), perm))
--
--
--def dims_idxs_to_tensor_idxs(dims, indices):
--    """
--    Given the dims of a Qobj instance, and some indices into
--    dims, returns the corresponding tensor indices. This helps
--    resolve, for instance, that column-stacking for superoperators,
--    oper-ket and oper-bra implies that the input and output tensor
--    indices are reversed from their order in dims.
--
--    Parameters
--    ----------
--
--    dims : list
--        Dimensions specification for a Qobj.
--
--    indices : int, list or tuple
--        Indices to convert to tensor indices. Can be specified
--        as a single index, or as a collection of indices.
--        In the latter case, this can be nested arbitrarily
--        deep. For instance, [0, [0, (2, 3)]].
--
--    Returns
--    -------
--
--    tens_indices : int, list or tuple
--        Container of the same structure as indices containing
--        the tensor indices for each element of indices.
--    """
--    perm = dims_to_tensor_perm(dims)
--    return deep_map(partial(getitem, perm), indices)
-+"""
-+Internal use module for manipulating dims specifications.
-+"""
-+
-+# Everything should be explicitly imported, not made available by default.
-+
-+import numpy as np
-+from operator import getitem
-+from functools import partial
-+
-+
-+def is_scalar(dims):
-+    """
-+    Returns True if a dims specification is effectively
-+    a scalar (has dimension 1).
-+    """
-+    return np.prod(flatten(dims)) == 1
-+
-+
-+def is_vector(dims):
-+    return (
-+        isinstance(dims, list) and
-+        isinstance(dims[0], (int, np.integer))
-+    )
-+
-+
-+def is_vectorized_oper(dims):
-+    return (
-+        isinstance(dims, list) and
-+        isinstance(dims[0], list)
-+    )
-+
-+
-+def type_from_dims(dims, enforce_square=False):
-+    bra_like, ket_like = map(is_scalar, dims)
-+
-+    if bra_like:
-+        if is_vector(dims[1]):
-+            return 'bra'
-+        elif is_vectorized_oper(dims[1]):
-+            return 'operator-bra'
-+
-+    if ket_like:
-+        if is_vector(dims[0]):
-+            return 'ket'
-+        elif is_vectorized_oper(dims[0]):
-+            return 'operator-ket'
-+
-+    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
-+        return 'oper'
-+
-+    elif (
-+        is_vectorized_oper(dims[0])
-+        and (
-+            not enforce_square
-+            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
-+        )
-+    ):
-+        return 'super'
-+    return 'other'
-+
-+
-+def flatten(l):
-+    """Flattens a list of lists to the first level.
-+
-+    Given a list containing a mix of scalars and lists,
-+    flattens down to a list of the scalars within the original
-+    list.
-+
-+    Examples
-+    --------
-+
-+    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
-+    [0, 1, 2]
-+
-+    """
-+    if not isinstance(l, list):
-+        return [l]
-+    else:
-+        return sum(map(flatten, l), [])
-+
-+
-+def deep_remove(l, *what):
-+    """Removes scalars from all levels of a nested list.
-+
-+    Given a list containing a mix of scalars and lists,
-+    returns a list of the same structure, but where one or
-+    more scalars have been removed.
-+
-+    Examples
-+    --------
-+
-+    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
-+    [[[[1, 2]], [3, 4], [], [6, 7]]]
-+
-+    """
-+    if isinstance(l, list):
-+        # Make a shallow copy at this level.
-+        l = l[:]
-+        for to_remove in what:
-+            if to_remove in l:
-+                l.remove(to_remove)
-+            else:
-+                l = [deep_remove(elem, to_remove) for elem in l]
-+    return l
-+
-+
-+def unflatten(l, idxs):
-+    """Unflattens a list by a given structure.
-+
-+    Given a list of scalars and a deep list of indices
-+    as produced by `flatten`, returns an "unflattened"
-+    form of the list. This perfectly inverts `flatten`.
-+
-+    Examples
-+    --------
-+
-+    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
-+    >>> idxs = enumerate_flat(l) # doctest: +SKIP
-+    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
-+    True
-+
-+    """
-+    acc = []
-+    for idx in idxs:
-+        if isinstance(idx, list):
-+            acc.append(unflatten(l, idx))
-+        else:
-+            acc.append(l[idx])
-+    return acc
-+
-+
-+def _enumerate_flat(l, idx=0):
-+    if not isinstance(l, list):
-+        # Found a scalar, so return and increment.
-+        return idx, idx + 1
-+    else:
-+        # Found a list, so append all the scalars
-+        # from it and recurse to keep the increment
-+        # correct.
-+        acc = []
-+        for elem in l:
-+            labels, idx = _enumerate_flat(elem, idx)
-+            acc.append(labels)
-+        return acc, idx
-+
-+
-+def _collapse_composite_index(dims):
-+    """
-+    Given the dimensions specification for a composite index
-+    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
-+    returns a dimensions specification for an index of the same shape,
-+    but collapsed to a single "leg." In the previous example, [2, 3]
-+    would collapse to [6].
-+    """
-+    return [np.prod(dims)]
-+
-+
-+def _collapse_dims_to_level(dims, level=1):
-+    """
-+    Recursively collapses all indices in a dimensions specification
-+    appearing at a given level, such that the returned dimensions
-+    specification does not represent any composite systems.
-+    """
-+    if level == 0:
-+        return _collapse_composite_index(dims)
-+    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
-+
-+
-+def collapse_dims_oper(dims):
-+    """
-+    Given the dimensions specifications for a ket-, bra- or oper-type
-+    Qobj, returns a dimensions specification describing the same shape
-+    by collapsing all composite systems. For instance, the bra-type
-+    dimensions specification ``[[2, 3], [1]]`` collapses to
-+    ``[[6], [1]]``.
-+
-+    Parameters
-+    ----------
-+
-+    dims : list of lists of ints
-+        Dimensions specifications to be collapsed.
-+
-+    Returns
-+    -------
-+
-+    collapsed_dims : list of lists of ints
-+        Collapsed dimensions specification describing the same shape
-+        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
-+    """
-+    return _collapse_dims_to_level(dims, 1)
-+
-+
-+def collapse_dims_super(dims):
-+    """
-+    Given the dimensions specifications for an operator-ket-, operator-bra- or
-+    super-type Qobj, returns a dimensions specification describing the same shape
-+    by collapsing all composite systems. For instance, the super-type
-+    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
-+    ``[[[6], [6]], [[6], [6]]]``.
-+
-+    Parameters
-+    ----------
-+
-+    dims : list of lists of ints
-+        Dimensions specifications to be collapsed.
-+
-+    Returns
-+    -------
-+
-+    collapsed_dims : list of lists of ints
-+        Collapsed dimensions specification describing the same shape
-+        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
-+        in ``range(2)``.
-+    """
-+    return _collapse_dims_to_level(dims, 2)
-+
-+
-+def enumerate_flat(l):
-+    """Labels the indices at which scalars occur in a flattened list.
-+
-+    Given a list containing a mix of scalars and lists,
-+    returns a list of the same structure, where each scalar
-+    has been replaced by an index into the flattened list.
-+
-+    Examples
-+    --------
-+
-+    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
-+    [[[0], [1, 2]], 3]
-+
-+    """
-+    return _enumerate_flat(l)[0]
-+
-+
-+def deep_map(fn, collection, over=(tuple, list)):
-+    if isinstance(collection, over):
-+        return type(collection)(deep_map(fn, el, over) for el in collection)
-+    else:
-+        return fn(collection)
-+
-+
-+def dims_to_tensor_perm(dims):
-+    """
-+    Given the dims of a Qobj instance, returns a list representing
-+    a permutation from the flattening of that dims specification to
-+    the corresponding tensor indices.
-+
-+    Parameters
-+    ----------
-+
-+    dims : list
-+        Dimensions specification for a Qobj.
-+
-+    Returns
-+    -------
-+
-+    perm : list
-+        A list such that ``data[flatten(dims)[idx]]`` gives the
-+        index of the tensor ``data`` corresponding to the ``idx``th
-+        dimension of ``dims``.
-+    """
-+    # We figure out the type of the dims specification,
-+    # relaxing the requirement that operators be square.
-+    # This means that dims_type need not coincide with
-+    # Qobj.type, but that works fine for our purposes here.
-+    dims_type = type_from_dims(dims, enforce_square=False)
-+    perm = enumerate_flat(dims)
-+    if dims_type in ('oper', 'ket', 'bra'):
-+        return flatten(perm)
-+
-+    # If the type is other, we need to figure out if the
-+    # dims is superlike on its outputs and inputs
-+    # This is the case if the dims type for left or right
-+    # are, respectively, oper-like.
-+    if dims_type == 'other':
-+        raise NotImplementedError("Not yet implemented for type='other'.")
-+
-+    # If we're still here, the story is more complicated. We'll
-+    # follow the strategy of creating a permutation by using
-+    # enumerate_flat then transforming the result to swap
-+    # input and output indices of vectorized matrices, then flattening
-+    # the result. We'll then rebuild indices using this permutation.
-+    if dims_type in ('operator-ket', 'super'):
-+        # Swap the input and output spaces of the right part of
-+        # perm.
-+        perm[1] = list(reversed(perm[1]))
-+    if dims_type in ('operator-bra', 'super'):
-+        # Ditto, but for the left indices.
-+        perm[0] = list(reversed(perm[0]))
-+    return flatten(perm)
-+
-+
-+def dims_to_tensor_shape(dims):
-+    """
-+    Given the dims of a Qobj instance, returns the shape of the
-+    corresponding tensor. This helps, for instance, resolve the
-+    column-stacking convention for superoperators.
-+
-+    Parameters
-+    ----------
-+
-+    dims : list
-+        Dimensions specification for a Qobj.
-+
-+    Returns
-+    -------
-+
-+    tensor_shape : tuple
-+        NumPy shape of the corresponding tensor.
-+    """
-+    perm = dims_to_tensor_perm(dims)
-+    dims = flatten(dims)
-+    return tuple(map(partial(getitem, dims), perm))
-+
-+
-+def dims_idxs_to_tensor_idxs(dims, indices):
-+    """
-+    Given the dims of a Qobj instance, and some indices into
-+    dims, returns the corresponding tensor indices. This helps
-+    resolve, for instance, that column-stacking for superoperators,
-+    oper-ket and oper-bra implies that the input and output tensor
-+    indices are reversed from their order in dims.
-+
-+    Parameters
-+    ----------
-+
-+    dims : list
-+        Dimensions specification for a Qobj.
-+
-+    indices : int, list or tuple
-+        Indices to convert to tensor indices. Can be specified
-+        as a single index, or as a collection of indices.
-+        In the latter case, this can be nested arbitrarily
-+        deep. For instance, [0, [0, (2, 3)]].
-+
-+    Returns
-+    -------
-+
-+    tens_indices : int, list or tuple
-+        Container of the same structure as indices containing
-+        the tensor indices for each element of indices.
-+    """
-+    perm = dims_to_tensor_perm(dims)
-+    return deep_map(partial(getitem, perm), indices)
-diff --git a/qutip/core/expect.py b/qutip/core/expect.py
-index 65888f8c..f290a25b 100644
---- a/qutip/core/expect.py
-+++ b/qutip/core/expect.py
-@@ -1,97 +1,97 @@
--__all__ = ['expect', 'variance']
--
--import numpy as np
--
--from .qobj import Qobj
--from . import data as _data
--
--
--def expect(oper, state):
--    """
--    Calculate the expectation value for operator(s) and state(s).  The
--    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
--    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
--
--    Parameters
--    ----------
--    oper : qobj/array-like
--        A single or a `list` or operators for expectation value.
--
--    state : qobj/array-like
--        A single or a `list` of quantum states or density matrices.
--
--    Returns
--    -------
--    expt : float/complex/array-like
--        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
--        otherwise. A (nested) array of expectaction values of state or operator
--        are arrays.
--
--    Examples
--    --------
--    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
--        True
--
--    """
--    if isinstance(state, Qobj) and isinstance(oper, Qobj):
--        return _single_qobj_expect(oper, state)
--
--    elif isinstance(oper, (list, np.ndarray)):
--        if isinstance(state, Qobj):
--            dtype = np.complex128
--            if all(op.isherm for op in oper) and (state.isket or state.isherm):
--                dtype = np.float64
--            return np.array([_single_qobj_expect(op, state) for op in oper],
--                            dtype=dtype)
--        return [expect(op, state) for op in oper]
--
--    elif isinstance(state, (list, np.ndarray)):
--        dtype = np.complex128
--        if oper.isherm and all(op.isherm or op.isket for op in state):
--            dtype = np.float64
--        return np.array([_single_qobj_expect(oper, x) for x in state],
--                        dtype=dtype)
--    raise TypeError('Arguments must be quantum objects')
--
--
--def _single_qobj_expect(oper, state):
--    """
--    Private function used by expect to calculate expectation values of Qobjs.
--    """
--    if not oper.isoper or not (state.isket or state.isoper):
--        raise TypeError('invalid operand types')
--    if oper.dims[1] != state.dims[0]:
--        msg = (
--            "incompatible dimensions "
--            + str(oper.dims[1]) + " and " + str(state.dims[0])
--        )
--        raise ValueError(msg)
--    out = _data.expect(oper.data, state.data)
--
--    # This ensures that expect can return something that is not a number such
--    # as a `tensorflow.Tensor` in qutip-tensorflow.
--    return out.real if (oper.isherm
--                        and (state.isket or state.isherm)
--                        and hasattr(out, "real")
--                        ) else out
--
--
--def variance(oper, state):
--    """
--    Variance of an operator for the given state vector or density matrix.
--
--    Parameters
--    ----------
--    oper : qobj
--        Operator for expectation value.
--
--    state : qobj/list
--        A single or `list` of quantum states or density matrices..
--
--    Returns
--    -------
--    var : float
--        Variance of operator 'oper' for given state.
--
--    """
--    return expect(oper**2, state) - expect(oper, state)**2
-+__all__ = ['expect', 'variance']
-+
-+import numpy as np
-+
-+from .qobj import Qobj
-+from . import data as _data
-+
-+
-+def expect(oper, state):
-+    """
-+    Calculate the expectation value for operator(s) and state(s).  The
-+    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
-+    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
-+
-+    Parameters
-+    ----------
-+    oper : qobj/array-like
-+        A single or a `list` or operators for expectation value.
-+
-+    state : qobj/array-like
-+        A single or a `list` of quantum states or density matrices.
-+
-+    Returns
-+    -------
-+    expt : float/complex/array-like
-+        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
-+        otherwise. A (nested) array of expectaction values of state or operator
-+        are arrays.
-+
-+    Examples
-+    --------
-+    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
-+        True
-+
-+    """
-+    if isinstance(state, Qobj) and isinstance(oper, Qobj):
-+        return _single_qobj_expect(oper, state)
-+
-+    elif isinstance(oper, (list, np.ndarray)):
-+        if isinstance(state, Qobj):
-+            dtype = np.complex128
-+            if all(op.isherm for op in oper) and (state.isket or state.isherm):
-+                dtype = np.float64
-+            return np.array([_single_qobj_expect(op, state) for op in oper],
-+                            dtype=dtype)
-+        return [expect(op, state) for op in oper]
-+
-+    elif isinstance(state, (list, np.ndarray)):
-+        dtype = np.complex128
-+        if oper.isherm and all(op.isherm or op.isket for op in state):
-+            dtype = np.float64
-+        return np.array([_single_qobj_expect(oper, x) for x in state],
-+                        dtype=dtype)
-+    raise TypeError('Arguments must be quantum objects')
-+
-+
-+def _single_qobj_expect(oper, state):
-+    """
-+    Private function used by expect to calculate expectation values of Qobjs.
-+    """
-+    if not oper.isoper or not (state.isket or state.isoper):
-+        raise TypeError('invalid operand types')
-+    if oper.dims[1] != state.dims[0]:
-+        msg = (
-+            "incompatible dimensions "
-+            + str(oper.dims[1]) + " and " + str(state.dims[0])
-+        )
-+        raise ValueError(msg)
-+    out = _data.expect(oper.data, state.data)
-+
-+    # This ensures that expect can return something that is not a number such
-+    # as a `tensorflow.Tensor` in qutip-tensorflow.
-+    return out.real if (oper.isherm
-+                        and (state.isket or state.isherm)
-+                        and hasattr(out, "real")
-+                        ) else out
-+
-+
-+def variance(oper, state):
-+    """
-+    Variance of an operator for the given state vector or density matrix.
-+
-+    Parameters
-+    ----------
-+    oper : qobj
-+        Operator for expectation value.
-+
-+    state : qobj/list
-+        A single or `list` of quantum states or density matrices..
-+
-+    Returns
-+    -------
-+    var : float
-+        Variance of operator 'oper' for given state.
-+
-+    """
-+    return expect(oper**2, state) - expect(oper, state)**2
-diff --git a/qutip/core/gates.py b/qutip/core/gates.py
-index 28726e29..ae99fc44 100644
---- a/qutip/core/gates.py
-+++ b/qutip/core/gates.py
-@@ -1,747 +1,747 @@
--from itertools import product
--from functools import partial, reduce
--from operator import mul
--
--import numpy as np
--import scipy.sparse as sp
--from . import Qobj, qeye, sigmax, fock_dm, qdiags
--
--
--__all__ = [
--    "rx",
--    "ry",
--    "rz",
--    "sqrtnot",
--    "snot",
--    "phasegate",
--    "qrot",
--    "cy_gate",
--    "cz_gate",
--    "s_gate",
--    "t_gate",
--    "cs_gate",
--    "ct_gate",
--    "cphase",
--    "cnot",
--    "csign",
--    "berkeley",
--    "swapalpha",
--    "swap",
--    "iswap",
--    "sqrtswap",
--    "sqrtiswap",
--    "fredkin",
--    "molmer_sorensen",
--    "toffoli",
--    "hadamard_transform",
--    "qubit_clifford_group",
--]
--
--
--def cy_gate(*, dtype="csr"):
--    """Controlled Y gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : :class:`qutip.Qobj`
--        Quantum object for operator describing the rotation.
--    """
--    return Qobj(
--        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def cz_gate(*, dtype="csr"):
--    """Controlled Z gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : :class:`qutip.Qobj`
--        Quantum object for operator describing the rotation.
--    """
--    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
--
--
--def s_gate(*, dtype="csr"):
--    """Single-qubit rotation also called Phase gate or the Z90 gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : :class:`qutip.Qobj`
--        Quantum object for operator describing
--        a 90 degree rotation around the z-axis.
--
--    """
--    return qdiags([1, 1j], dtype=dtype)
--
--
--def cs_gate(*, dtype="csr"):
--    """Controlled S gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : :class:`qutip.Qobj`
--        Quantum object for operator describing the rotation.
--
--    """
--    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
--
--
--def t_gate(*, dtype="csr"):
--    """Single-qubit rotation related to the S gate by the relationship S=T*T.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : :class:`qutip.Qobj`
--        Quantum object for operator describing a phase shift of pi/4.
--
--    """
--    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
--
--
--def ct_gate(*, dtype="csr"):
--    """Controlled T gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : :class:`qutip.Qobj`
--        Quantum object for operator describing the rotation.
--
--    """
--    return qdiags(
--        [1, 1, 1, np.exp(1j * np.pi / 4)],
--        dims=[[2, 2], [2, 2]],
--        dtype=dtype,
--    )
--
--
--def rx(phi, *, dtype="dense"):
--    """Single-qubit rotation for operator sigmax with angle phi.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : qobj
--        Quantum object for operator describing the rotation.
--
--    """
--    return Qobj(
--        [
--            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
--            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
--        ]
--    ).to(dtype)
--
--
--def ry(phi, *, dtype="dense"):
--    """Single-qubit rotation for operator sigmay with angle phi.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : qobj
--        Quantum object for operator describing the rotation.
--
--    """
--    return Qobj(
--        [
--            [np.cos(phi / 2), -np.sin(phi / 2)],
--            [np.sin(phi / 2), np.cos(phi / 2)],
--        ]
--    ).to(dtype)
--
--
--def rz(phi, *, dtype="csr"):
--    """Single-qubit rotation for operator sigmaz with angle phi.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : qobj
--        Quantum object for operator describing the rotation.
--
--    """
--    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
--
--
--def sqrtnot(*, dtype="dense"):
--    """Single-qubit square root NOT gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    result : qobj
--        Quantum object for operator describing the square root NOT gate.
--
--    """
--    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
--
--
--def snot(*, dtype="dense"):
--    """Quantum object representing the SNOT (Hadamard) gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    snot_gate : qobj
--        Quantum object representation of SNOT gate.
--
--    """
--    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
--
--
--def phasegate(theta, *, dtype="csr"):
--    """
--    Returns quantum object representing the phase shift gate.
--
--    Parameters
--    ----------
--    theta : float
--        Phase rotation angle.
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    phase_gate : qobj
--        Quantum object representation of phase shift gate.
--
--    """
--    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
--
--
--def qrot(theta, phi, *, dtype="dense"):
--    """
--    Single qubit rotation driving by Rabi oscillation with 0 detune.
--
--    Parameters
--    ----------
--    phi : float
--        The inital phase of the rabi pulse.
--    theta : float
--        The duration of the rabi pulse.
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    qrot_gate : :class:`qutip.Qobj`
--        Quantum object representation of physical qubit rotation under
--        a rabi pulse.
--    """
--    return Qobj(
--        [
--            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
--            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
--        ]
--    ).to(dtype)
--
--
--#
--# 2 Qubit Gates
--#
--
--
--def cphase(theta, *, dtype="csr"):
--    """
--    Returns quantum object representing the controlled phase shift gate.
--
--    Parameters
--    ----------
--    theta : float
--        Phase rotation angle.
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    U : qobj
--        Quantum object representation of controlled phase gate.
--    """
--    return qdiags(
--        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
--    )
--
--
--def cnot(*, dtype="csr"):
--    """
--    Quantum object representing the CNOT gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    cnot_gate : qobj
--        Quantum object representation of CNOT gate
--
--    """
--    return Qobj(
--        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def csign(*, dtype="csr"):
--    """
--    Quantum object representing the CSIGN gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    csign_gate : qobj
--        Quantum object representation of CSIGN gate
--
--    """
--    return cz_gate(dtype=dtype)
--
--
--def berkeley(*, dtype="dense"):
--    """
--    Quantum object representing the Berkeley gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    berkeley_gate : qobj
--        Quantum object representation of Berkeley gate
--
--    """
--    return Qobj(
--        [
--            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
--            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
--            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
--            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
--        ],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def swapalpha(alpha, *, dtype="csr"):
--    """
--    Quantum object representing the SWAPalpha gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    swapalpha_gate : qobj
--        Quantum object representation of SWAPalpha gate
--    """
--    phase = np.exp(1.0j * np.pi * alpha)
--    return Qobj(
--        [
--            [1, 0, 0, 0],
--            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
--            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
--            [0, 0, 0, 1],
--        ],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def swap(*, dtype="csr"):
--    """Quantum object representing the SWAP gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    swap_gate : qobj
--        Quantum object representation of SWAP gate
--
--    """
--    return Qobj(
--        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def iswap(*, dtype="csr"):
--    """Quantum object representing the iSWAP gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    iswap_gate : qobj
--        Quantum object representation of iSWAP gate
--    """
--    return Qobj(
--        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def sqrtswap(*, dtype="dense"):
--    """Quantum object representing the square root SWAP gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    sqrtswap_gate : qobj
--        Quantum object representation of square root SWAP gate
--
--    """
--    return Qobj(
--        np.array(
--            [
--                [1, 0, 0, 0],
--                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
--                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
--                [0, 0, 0, 1],
--            ]
--        ),
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def sqrtiswap(*, dtype="dense"):
--    """Quantum object representing the square root iSWAP gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    sqrtiswap_gate : qobj
--        Quantum object representation of square root iSWAP gate
--    """
--    return Qobj(
--        np.array(
--            [
--                [1, 0, 0, 0],
--                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
--                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
--                [0, 0, 0, 1],
--            ]
--        ),
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--def molmer_sorensen(theta, *, dtype="dense"):
--    """
--    Quantum object of a Mølmer–Sørensen gate.
--
--    Parameters
--    ----------
--    theta: float
--        The duration of the interaction pulse.
--    N: int
--        Number of qubits in the system.
--    target: int
--        The indices of the target qubits.
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    molmer_sorensen_gate: :class:`qutip.Qobj`
--        Quantum object representation of the Mølmer–Sørensen gate.
--    """
--    return Qobj(
--        [
--            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
--            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
--            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
--            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
--        ],
--        dims=[[2, 2], [2, 2]],
--    ).to(dtype)
--
--
--#
--# 3 Qubit Gates
--#
--
--
--def fredkin(*, dtype="csr"):
--    """Quantum object representing the Fredkin gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    fredkin_gate : qobj
--        Quantum object representation of Fredkin gate.
--
--    """
--    return Qobj(
--        [
--            [1, 0, 0, 0, 0, 0, 0, 0],
--            [0, 1, 0, 0, 0, 0, 0, 0],
--            [0, 0, 1, 0, 0, 0, 0, 0],
--            [0, 0, 0, 1, 0, 0, 0, 0],
--            [0, 0, 0, 0, 1, 0, 0, 0],
--            [0, 0, 0, 0, 0, 0, 1, 0],
--            [0, 0, 0, 0, 0, 1, 0, 0],
--            [0, 0, 0, 0, 0, 0, 0, 1],
--        ],
--        dims=[[2, 2, 2], [2, 2, 2]],
--    ).to(dtype)
--
--
--def toffoli(*, dtype="csr"):
--    """Quantum object representing the Toffoli gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    toff_gate : qobj
--        Quantum object representation of Toffoli gate.
--
--    """
--    return Qobj(
--        [
--            [1, 0, 0, 0, 0, 0, 0, 0],
--            [0, 1, 0, 0, 0, 0, 0, 0],
--            [0, 0, 1, 0, 0, 0, 0, 0],
--            [0, 0, 0, 1, 0, 0, 0, 0],
--            [0, 0, 0, 0, 1, 0, 0, 0],
--            [0, 0, 0, 0, 0, 1, 0, 0],
--            [0, 0, 0, 0, 0, 0, 0, 1],
--            [0, 0, 0, 0, 0, 0, 1, 0],
--        ],
--        dims=[[2, 2, 2], [2, 2, 2]],
--    ).to(dtype)
--
--
--#
--# Miscellaneous Gates
--#
--
--
--def globalphase(theta, N=1, *, dtype="csr"):
--    """
--    Returns quantum object representing the global phase shift gate.
--
--    Parameters
--    ----------
--    theta : float
--        Phase rotation angle.
--
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    phase_gate : qobj
--        Quantum object representation of global phase shift gate.
--
--    """
--    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
--
--
--#
--# Operation on Gates
--#
--
--
--def _hamming_distance(x):
--    """
--    Calculate the bit-wise Hamming distance of x from 0: That is, the number
--    1s in the integer x.
--    """
--    tot = 0
--    while x:
--        tot += 1
--        x &= x - 1
--    return tot
--
--
--def hadamard_transform(N=1, *, dtype="dense"):
--    """Quantum object representing the N-qubit Hadamard gate.
--
--    Parameters
--    ----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    q : qobj
--        Quantum object representation of the N-qubit Hadamard gate.
--
--    """
--    data = 2 ** (-N / 2) * np.array(
--        [
--            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
--            for j in range(2**N)
--        ]
--    )
--
--    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
--
--
--def _powers(op, N):
--    """
--    Generator that yields powers of an operator `op`,
--    through to `N`.
--    """
--    acc = qeye(op.dims[0])
--    yield acc
--
--    for _ in range(N - 1):
--        acc *= op
--        yield acc
--
--
--def qubit_clifford_group(*, dtype="dense"):
--    """
--    Generates the Clifford group on a single qubit,
--    using the presentation of the group given by Ross and Selinger
--    (http://www.mathstat.dal.ca/~selinger/newsynth/).
--
--    Parameters
--    -----------
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Return
--    ------
--    op : list of Qobj
--        Clifford operators, represented as Qobj instances.
--
--    """
--
--    # The Ross-Selinger presentation of the single-qubit Clifford
--    # group expresses each element in the form C_{ijk} = E^i X^j S^k
--    # for gates E, X and S, and for i in range(3), j in range(2) and
--    # k in range(4).
--    #
--    # We start by defining these gates. E is defined in terms of H,
--    # \omega and S, so we define \omega and H first.
--    w = np.exp(1j * 2 * np.pi / 8)
--    H = snot()
--
--    X = sigmax()
--    S = phasegate(np.pi / 2)
--    E = H * (S**3) * w**3
--
--    # partial(reduce, mul) returns a function that takes products
--    # of its argument, by analogy to sum. Note that by analogy,
--    # sum can be written as partial(reduce, add).
--
--    # product(...) yields the Cartesian product of its arguments.
--    # Here, each element is a tuple (E**i, X**j, S**k) such that
--    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
--    return [
--        op.to(dtype)
--        for op in map(
--            partial(reduce, mul),
--            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
--        )
--    ]
-+from itertools import product
-+from functools import partial, reduce
-+from operator import mul
-+
-+import numpy as np
-+import scipy.sparse as sp
-+from . import Qobj, qeye, sigmax, fock_dm, qdiags
-+
-+
-+__all__ = [
-+    "rx",
-+    "ry",
-+    "rz",
-+    "sqrtnot",
-+    "snot",
-+    "phasegate",
-+    "qrot",
-+    "cy_gate",
-+    "cz_gate",
-+    "s_gate",
-+    "t_gate",
-+    "cs_gate",
-+    "ct_gate",
-+    "cphase",
-+    "cnot",
-+    "csign",
-+    "berkeley",
-+    "swapalpha",
-+    "swap",
-+    "iswap",
-+    "sqrtswap",
-+    "sqrtiswap",
-+    "fredkin",
-+    "molmer_sorensen",
-+    "toffoli",
-+    "hadamard_transform",
-+    "qubit_clifford_group",
-+]
-+
-+
-+def cy_gate(*, dtype="csr"):
-+    """Controlled Y gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : :class:`qutip.Qobj`
-+        Quantum object for operator describing the rotation.
-+    """
-+    return Qobj(
-+        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def cz_gate(*, dtype="csr"):
-+    """Controlled Z gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : :class:`qutip.Qobj`
-+        Quantum object for operator describing the rotation.
-+    """
-+    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
-+
-+
-+def s_gate(*, dtype="csr"):
-+    """Single-qubit rotation also called Phase gate or the Z90 gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : :class:`qutip.Qobj`
-+        Quantum object for operator describing
-+        a 90 degree rotation around the z-axis.
-+
-+    """
-+    return qdiags([1, 1j], dtype=dtype)
-+
-+
-+def cs_gate(*, dtype="csr"):
-+    """Controlled S gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : :class:`qutip.Qobj`
-+        Quantum object for operator describing the rotation.
-+
-+    """
-+    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
-+
-+
-+def t_gate(*, dtype="csr"):
-+    """Single-qubit rotation related to the S gate by the relationship S=T*T.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : :class:`qutip.Qobj`
-+        Quantum object for operator describing a phase shift of pi/4.
-+
-+    """
-+    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
-+
-+
-+def ct_gate(*, dtype="csr"):
-+    """Controlled T gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : :class:`qutip.Qobj`
-+        Quantum object for operator describing the rotation.
-+
-+    """
-+    return qdiags(
-+        [1, 1, 1, np.exp(1j * np.pi / 4)],
-+        dims=[[2, 2], [2, 2]],
-+        dtype=dtype,
-+    )
-+
-+
-+def rx(phi, *, dtype="dense"):
-+    """Single-qubit rotation for operator sigmax with angle phi.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : qobj
-+        Quantum object for operator describing the rotation.
-+
-+    """
-+    return Qobj(
-+        [
-+            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
-+            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
-+        ]
-+    ).to(dtype)
-+
-+
-+def ry(phi, *, dtype="dense"):
-+    """Single-qubit rotation for operator sigmay with angle phi.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : qobj
-+        Quantum object for operator describing the rotation.
-+
-+    """
-+    return Qobj(
-+        [
-+            [np.cos(phi / 2), -np.sin(phi / 2)],
-+            [np.sin(phi / 2), np.cos(phi / 2)],
-+        ]
-+    ).to(dtype)
-+
-+
-+def rz(phi, *, dtype="csr"):
-+    """Single-qubit rotation for operator sigmaz with angle phi.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : qobj
-+        Quantum object for operator describing the rotation.
-+
-+    """
-+    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
-+
-+
-+def sqrtnot(*, dtype="dense"):
-+    """Single-qubit square root NOT gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    result : qobj
-+        Quantum object for operator describing the square root NOT gate.
-+
-+    """
-+    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
-+
-+
-+def snot(*, dtype="dense"):
-+    """Quantum object representing the SNOT (Hadamard) gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    snot_gate : qobj
-+        Quantum object representation of SNOT gate.
-+
-+    """
-+    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
-+
-+
-+def phasegate(theta, *, dtype="csr"):
-+    """
-+    Returns quantum object representing the phase shift gate.
-+
-+    Parameters
-+    ----------
-+    theta : float
-+        Phase rotation angle.
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    phase_gate : qobj
-+        Quantum object representation of phase shift gate.
-+
-+    """
-+    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
-+
-+
-+def qrot(theta, phi, *, dtype="dense"):
-+    """
-+    Single qubit rotation driving by Rabi oscillation with 0 detune.
-+
-+    Parameters
-+    ----------
-+    phi : float
-+        The inital phase of the rabi pulse.
-+    theta : float
-+        The duration of the rabi pulse.
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    qrot_gate : :class:`qutip.Qobj`
-+        Quantum object representation of physical qubit rotation under
-+        a rabi pulse.
-+    """
-+    return Qobj(
-+        [
-+            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
-+            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
-+        ]
-+    ).to(dtype)
-+
-+
-+#
-+# 2 Qubit Gates
-+#
-+
-+
-+def cphase(theta, *, dtype="csr"):
-+    """
-+    Returns quantum object representing the controlled phase shift gate.
-+
-+    Parameters
-+    ----------
-+    theta : float
-+        Phase rotation angle.
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    U : qobj
-+        Quantum object representation of controlled phase gate.
-+    """
-+    return qdiags(
-+        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
-+    )
-+
-+
-+def cnot(*, dtype="csr"):
-+    """
-+    Quantum object representing the CNOT gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    cnot_gate : qobj
-+        Quantum object representation of CNOT gate
-+
-+    """
-+    return Qobj(
-+        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def csign(*, dtype="csr"):
-+    """
-+    Quantum object representing the CSIGN gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    csign_gate : qobj
-+        Quantum object representation of CSIGN gate
-+
-+    """
-+    return cz_gate(dtype=dtype)
-+
-+
-+def berkeley(*, dtype="dense"):
-+    """
-+    Quantum object representing the Berkeley gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    berkeley_gate : qobj
-+        Quantum object representation of Berkeley gate
-+
-+    """
-+    return Qobj(
-+        [
-+            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
-+            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
-+            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
-+            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
-+        ],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def swapalpha(alpha, *, dtype="csr"):
-+    """
-+    Quantum object representing the SWAPalpha gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    swapalpha_gate : qobj
-+        Quantum object representation of SWAPalpha gate
-+    """
-+    phase = np.exp(1.0j * np.pi * alpha)
-+    return Qobj(
-+        [
-+            [1, 0, 0, 0],
-+            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
-+            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
-+            [0, 0, 0, 1],
-+        ],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def swap(*, dtype="csr"):
-+    """Quantum object representing the SWAP gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    swap_gate : qobj
-+        Quantum object representation of SWAP gate
-+
-+    """
-+    return Qobj(
-+        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def iswap(*, dtype="csr"):
-+    """Quantum object representing the iSWAP gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    iswap_gate : qobj
-+        Quantum object representation of iSWAP gate
-+    """
-+    return Qobj(
-+        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def sqrtswap(*, dtype="dense"):
-+    """Quantum object representing the square root SWAP gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    sqrtswap_gate : qobj
-+        Quantum object representation of square root SWAP gate
-+
-+    """
-+    return Qobj(
-+        np.array(
-+            [
-+                [1, 0, 0, 0],
-+                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
-+                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
-+                [0, 0, 0, 1],
-+            ]
-+        ),
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def sqrtiswap(*, dtype="dense"):
-+    """Quantum object representing the square root iSWAP gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    sqrtiswap_gate : qobj
-+        Quantum object representation of square root iSWAP gate
-+    """
-+    return Qobj(
-+        np.array(
-+            [
-+                [1, 0, 0, 0],
-+                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
-+                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
-+                [0, 0, 0, 1],
-+            ]
-+        ),
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+def molmer_sorensen(theta, *, dtype="dense"):
-+    """
-+    Quantum object of a Mølmer–Sørensen gate.
-+
-+    Parameters
-+    ----------
-+    theta: float
-+        The duration of the interaction pulse.
-+    N: int
-+        Number of qubits in the system.
-+    target: int
-+        The indices of the target qubits.
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    molmer_sorensen_gate: :class:`qutip.Qobj`
-+        Quantum object representation of the Mølmer–Sørensen gate.
-+    """
-+    return Qobj(
-+        [
-+            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
-+            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
-+            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
-+            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
-+        ],
-+        dims=[[2, 2], [2, 2]],
-+    ).to(dtype)
-+
-+
-+#
-+# 3 Qubit Gates
-+#
-+
-+
-+def fredkin(*, dtype="csr"):
-+    """Quantum object representing the Fredkin gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    fredkin_gate : qobj
-+        Quantum object representation of Fredkin gate.
-+
-+    """
-+    return Qobj(
-+        [
-+            [1, 0, 0, 0, 0, 0, 0, 0],
-+            [0, 1, 0, 0, 0, 0, 0, 0],
-+            [0, 0, 1, 0, 0, 0, 0, 0],
-+            [0, 0, 0, 1, 0, 0, 0, 0],
-+            [0, 0, 0, 0, 1, 0, 0, 0],
-+            [0, 0, 0, 0, 0, 0, 1, 0],
-+            [0, 0, 0, 0, 0, 1, 0, 0],
-+            [0, 0, 0, 0, 0, 0, 0, 1],
-+        ],
-+        dims=[[2, 2, 2], [2, 2, 2]],
-+    ).to(dtype)
-+
-+
-+def toffoli(*, dtype="csr"):
-+    """Quantum object representing the Toffoli gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    toff_gate : qobj
-+        Quantum object representation of Toffoli gate.
-+
-+    """
-+    return Qobj(
-+        [
-+            [1, 0, 0, 0, 0, 0, 0, 0],
-+            [0, 1, 0, 0, 0, 0, 0, 0],
-+            [0, 0, 1, 0, 0, 0, 0, 0],
-+            [0, 0, 0, 1, 0, 0, 0, 0],
-+            [0, 0, 0, 0, 1, 0, 0, 0],
-+            [0, 0, 0, 0, 0, 1, 0, 0],
-+            [0, 0, 0, 0, 0, 0, 0, 1],
-+            [0, 0, 0, 0, 0, 0, 1, 0],
-+        ],
-+        dims=[[2, 2, 2], [2, 2, 2]],
-+    ).to(dtype)
-+
-+
-+#
-+# Miscellaneous Gates
-+#
-+
-+
-+def globalphase(theta, N=1, *, dtype="csr"):
-+    """
-+    Returns quantum object representing the global phase shift gate.
-+
-+    Parameters
-+    ----------
-+    theta : float
-+        Phase rotation angle.
-+
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    phase_gate : qobj
-+        Quantum object representation of global phase shift gate.
-+
-+    """
-+    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
-+
-+
-+#
-+# Operation on Gates
-+#
-+
-+
-+def _hamming_distance(x):
-+    """
-+    Calculate the bit-wise Hamming distance of x from 0: That is, the number
-+    1s in the integer x.
-+    """
-+    tot = 0
-+    while x:
-+        tot += 1
-+        x &= x - 1
-+    return tot
-+
-+
-+def hadamard_transform(N=1, *, dtype="dense"):
-+    """Quantum object representing the N-qubit Hadamard gate.
-+
-+    Parameters
-+    ----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    q : qobj
-+        Quantum object representation of the N-qubit Hadamard gate.
-+
-+    """
-+    data = 2 ** (-N / 2) * np.array(
-+        [
-+            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
-+            for j in range(2**N)
-+        ]
-+    )
-+
-+    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
-+
-+
-+def _powers(op, N):
-+    """
-+    Generator that yields powers of an operator `op`,
-+    through to `N`.
-+    """
-+    acc = qeye(op.dims[0])
-+    yield acc
-+
-+    for _ in range(N - 1):
-+        acc *= op
-+        yield acc
-+
-+
-+def qubit_clifford_group(*, dtype="dense"):
-+    """
-+    Generates the Clifford group on a single qubit,
-+    using the presentation of the group given by Ross and Selinger
-+    (http://www.mathstat.dal.ca/~selinger/newsynth/).
-+
-+    Parameters
-+    -----------
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Return
-+    ------
-+    op : list of Qobj
-+        Clifford operators, represented as Qobj instances.
-+
-+    """
-+
-+    # The Ross-Selinger presentation of the single-qubit Clifford
-+    # group expresses each element in the form C_{ijk} = E^i X^j S^k
-+    # for gates E, X and S, and for i in range(3), j in range(2) and
-+    # k in range(4).
-+    #
-+    # We start by defining these gates. E is defined in terms of H,
-+    # \omega and S, so we define \omega and H first.
-+    w = np.exp(1j * 2 * np.pi / 8)
-+    H = snot()
-+
-+    X = sigmax()
-+    S = phasegate(np.pi / 2)
-+    E = H * (S**3) * w**3
-+
-+    # partial(reduce, mul) returns a function that takes products
-+    # of its argument, by analogy to sum. Note that by analogy,
-+    # sum can be written as partial(reduce, add).
-+
-+    # product(...) yields the Cartesian product of its arguments.
-+    # Here, each element is a tuple (E**i, X**j, S**k) such that
-+    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
-+    return [
-+        op.to(dtype)
-+        for op in map(
-+            partial(reduce, mul),
-+            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
-+        )
-+    ]
-diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
-index 08c63532..c87c1375 100644
---- a/qutip/core/metrics.py
-+++ b/qutip/core/metrics.py
-@@ -1,590 +1,590 @@
--# -*- coding: utf-8 -*-
--
--"""
--This module contains a collection of functions for calculating metrics
--(distance measures) between states and operators.
--"""
--
--__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
--           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
--           'process_fidelity', 'unitarity', 'dnorm']
--
--import warnings
--
--import numpy as np
--from scipy import linalg as la
--import scipy.sparse as sp
--from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
--                           kraus_to_choi)
--from .superoperator import operator_to_vector, vector_to_operator
--from .operators import qeye
--from .states import ket2dm
--from .semidefinite import dnorm_problem, dnorm_sparse_problem
--from . import data as _data
--
--try:
--    import cvxpy
--except ImportError:
--    cvxpy = None
--
--
--def fidelity(A, B):
--    """
--    Calculates the fidelity (pseudo-metric) between two density matrices.
--    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
--
--    Parameters
--    ----------
--    A : qobj
--        Density matrix or state vector.
--    B : qobj
--        Density matrix or state vector with same dimensions as A.
--
--    Returns
--    -------
--    fid : float
--        Fidelity pseudo-metric between A and B.
--
--    Examples
--    --------
--    >>> x = fock_dm(5,3)
--    >>> y = coherent_dm(5,1)
--    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
--    """
--    if A.isket or A.isbra:
--        if B.isket or B.isbra:
--            # The fidelity for pure states reduces to the modulus of their
--            # inner product.
--            return np.abs(A.overlap(B))
--        # Take advantage of the fact that the density operator for A
--        # is a projector to avoid a sqrtm call.
--        sqrtmA = ket2dm(A)
--    else:
--        if B.isket or B.isbra:
--            # Swap the order so that we can take a more numerically
--            # stable square root of B.
--            return fidelity(B, A)
--        # If we made it here, both A and B are operators, so
--        # we have to take the sqrtm of one of them.
--        sqrtmA = A.sqrtm()
--
--    if sqrtmA.dims != B.dims:
--        raise TypeError('Density matrices do not have same dimensions.')
--
--    # We don't actually need the whole matrix here, just the trace
--    # of its square root, so let's just get its eigenenergies instead.
--    # We also truncate negative eigenvalues to avoid nan propagation;
--    # even for positive semidefinite matrices, small negative eigenvalues
--    # can be reported.
--    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
--    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
--
--
--def _hilbert_space_dims(oper):
--    """
--    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
--    of the output Hilbert space and the input Hilbert space.
--    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
--    - If oper is a list of Kraus operators, then
--     `oper[0].dims == [dims_out, dims_in]`.
--    - If oper is a superoperator with `oper.superrep == 'super'`:
--     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
--    - If oper is a superoperator with `oper.superrep == 'choi'`:
--     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
--    - If oper is a superoperator with `oper.superrep == 'chi', then
--      `dims_out == dims_in` and
--      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
--    :param oper: A quantum channel, represented by a unitary, a list of Kraus
--    operators, or a superoperator
--    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
--     of integers
--    """
--    if isinstance(oper, list):
--        return oper[0].dims
--    elif oper.type == 'oper':  # interpret as unitary quantum channel
--        return oper.dims
--    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
--        return [oper.dims[0][1], oper.dims[1][0]]
--    else:
--        raise TypeError('oper is not a valid quantum channel!')
--
--
--def _process_fidelity_to_id(oper):
--    """
--    Internal function returning the process fidelity of a quantum channel
--    to the identity quantum channel.
--    Parameters
--    ----------
--    oper : :class:`qutip.Qobj`/list
--        A unitary operator, or a superoperator in supermatrix, Choi or
--        chi-matrix form, or a list of Kraus operators
--    Returns
--    -------
--    fid : float
--    """
--    dims_out, dims_in = _hilbert_space_dims(oper)
--    if dims_out != dims_in:
--        raise TypeError('The process fidelity to identity is only defined '
--                        'for dimension preserving channels.')
--    d = np.prod(dims_in)
--    if isinstance(oper, list):  # oper is a list of Kraus operators
--        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
--    elif oper.type == 'oper':  # interpret as unitary
--        return np.abs(oper.tr()) ** 2 / d ** 2
--    elif oper.type == 'super':
--        if oper.superrep == 'chi':
--            return oper[0, 0].real / d ** 2
--        else:  # oper.superrep is either 'super' or 'choi':
--            return to_super(oper).tr().real / d ** 2
--
--
--def _kraus_or_qobj_to_choi(oper):
--    if isinstance(oper, list):
--        return kraus_to_choi(oper)
--    else:
--        return to_choi(oper)
--
--
--def process_fidelity(oper, target=None):
--    """
--    Returns the process fidelity of a quantum channel to the target
--    channel, or to the identity channel if no target is given.
--    The process fidelity between two channels is defined as the state
--    fidelity between their normalized Choi matrices.
--
--    Parameters
--    ----------
--    oper : :class:`qutip.Qobj`/list
--        A unitary operator, or a superoperator in supermatrix, Choi or
--        chi-matrix form, or a list of Kraus operators
--    target : :class:`qutip.Qobj`/list
--        A unitary operator, or a superoperator in supermatrix, Choi or
--        chi-matrix form, or a list of Kraus operators
--
--    Returns
--    -------
--    fid : float
--        Process fidelity between oper and target, or between oper and identity.
--
--    Notes
--    -----
--    Since Qutip 5.0, this function computes the process fidelity as defined
--    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
--    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
--    that is now implemented in
--    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
--    The definition of state fidelity that the process fidelity is based on
--    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
--    It is the square of the one implemented in
--    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
--    "Quantum Computation and Quantum Information"
--
--    """
--    if target is None:
--        return _process_fidelity_to_id(oper)
--
--    dims_out, dims_in = _hilbert_space_dims(oper)
--    if dims_out != dims_in:
--        raise NotImplementedError('Process fidelity only implemented for '
--                                  'dimension-preserving operators.')
--    dims_out_target, dims_in_target = _hilbert_space_dims(target)
--    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
--        raise TypeError('Dimensions of oper and target do not match')
--
--    if not isinstance(target, list) and target.type == 'oper':
--        # interpret target as unitary.
--        if isinstance(oper, list):  # oper is a list of Kraus operators
--            return _process_fidelity_to_id([k * target.dag() for k in oper])
--        elif oper.type == 'oper':
--            return _process_fidelity_to_id(oper*target.dag())
--        elif oper.type == 'super':
--            oper_super = to_super(oper)
--            target_dag_super = to_super(target.dag())
--            return _process_fidelity_to_id(oper_super * target_dag_super)
--    else:  # target is a list of Kraus operators or a superoperator
--        if not isinstance(oper, list) and oper.type == 'oper':
--            return process_fidelity(target, oper)  # reverse order
--        oper_choi = _kraus_or_qobj_to_choi(oper)
--        target_choi = _kraus_or_qobj_to_choi(target)
--        d = np.prod(dims_in)
--        return (fidelity(oper_choi, target_choi)/d)**2
--
--
--def average_gate_fidelity(oper, target=None):
--    """
--    Returns the average gate fidelity of a quantum channel to the target
--    channel, or to the identity channel if no target is given.
--
--    Parameters
--    ----------
--    oper : :class:`qutip.Qobj`/list
--        A unitary operator, or a superoperator in supermatrix, Choi or
--        chi-matrix form, or a list of Kraus operators
--    target : :class:`qutip.Qobj`
--        A unitary operator
--
--    Returns
--    -------
--    fid : float
--        Average gate fidelity between oper and target,
--        or between oper and identity.
--
--    Notes
--    -----
--    The average gate fidelity is defined for example in:
--    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
--    The definition of state fidelity that the average gate fidelity is based on
--    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
--    It is the square of the fidelity implemented in
--    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
--    "Quantum Computation and Quantum Information"
--
--    """
--    dims_out, dims_in = _hilbert_space_dims(oper)
--    if not (target is None or target.type == 'oper'):
--        raise TypeError(
--            'target must be None or a Qobj representing a unitary.')
--
--    d = np.prod(dims_in)
--    return (d * process_fidelity(oper, target) + 1) / (d + 1)
--
--
--def tracedist(A, B, sparse=False, tol=0):
--    """
--    Calculates the trace distance between two density matrices..
--    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
--
--    Parameters
--    ----------!=
--    A : qobj
--        Density matrix or state vector.
--    B : qobj
--        Density matrix or state vector with same dimensions as A.
--    tol : float
--        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
--    sparse : {False, True}
--        Use sparse eigensolver.
--
--    Returns
--    -------
--    tracedist : float
--        Trace distance between A and B.
--
--    Examples
--    --------
--    >>> x=fock_dm(5,3)
--    >>> y=coherent_dm(5,1)
--    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
--    """
--    if A.isket or A.isbra:
--        A = A.proj()
--    if B.isket or B.isbra:
--        B = B.proj()
--    if A.dims != B.dims:
--        raise TypeError("A and B do not have same dimensions.")
--    diff = A - B
--    diff = diff.dag() * diff
--    vals = diff.eigenenergies(sparse=sparse, tol=tol)
--    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
--
--
--def hilbert_dist(A, B):
--    """
--    Returns the Hilbert-Schmidt distance between two density matrices A & B.
--
--    Parameters
--    ----------
--    A : qobj
--        Density matrix or state vector.
--    B : qobj
--        Density matrix or state vector with same dimensions as A.
--
--    Returns
--    -------
--    dist : float
--        Hilbert-Schmidt distance between density matrices.
--
--    Notes
--    -----
--    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
--
--    """
--    if A.isket or A.isbra:
--        A = A.proj()
--    if B.isket or B.isbra:
--        B = B.proj()
--    if A.dims != B.dims:
--        raise TypeError('A and B do not have same dimensions.')
--    return ((A - B)**2).tr()
--
--
--def bures_dist(A, B):
--    """
--    Returns the Bures distance between two density matrices A & B.
--
--    The Bures distance ranges from 0, for states with unit fidelity,
--    to sqrt(2).
--
--    Parameters
--    ----------
--    A : qobj
--        Density matrix or state vector.
--    B : qobj
--        Density matrix or state vector with same dimensions as A.
--
--    Returns
--    -------
--    dist : float
--        Bures distance between density matrices.
--    """
--    if A.isket or A.isbra:
--        A = A.proj()
--    if B.isket or B.isbra:
--        B = B.proj()
--    if A.dims != B.dims:
--        raise TypeError('A and B do not have same dimensions.')
--    dist = np.sqrt(2 * (1 - fidelity(A, B)))
--    return dist
--
--
--def bures_angle(A, B):
--    """
--    Returns the Bures Angle between two density matrices A & B.
--
--    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
--
--    Parameters
--    ----------
--    A : qobj
--        Density matrix or state vector.
--    B : qobj
--        Density matrix or state vector with same dimensions as A.
--
--    Returns
--    -------
--    angle : float
--        Bures angle between density matrices.
--    """
--    if A.isket or A.isbra:
--        A = A.proj()
--    if B.isket or B.isbra:
--        B = B.proj()
--    if A.dims != B.dims:
--        raise TypeError('A and B do not have same dimensions.')
--    return np.arccos(fidelity(A, B))
--
--
--def hellinger_dist(A, B, sparse=False, tol=0):
--    """
--    Calculates the quantum Hellinger distance between two density matrices.
--
--    Formula:
--    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
--
--    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
--    measures of quantum correlations with Bures and Hellinger distances"
--    arXiv:1611.03449
--
--    Parameters
--    ----------
--    A : :class:`qutip.Qobj`
--        Density matrix or state vector.
--    B : :class:`qutip.Qobj`
--        Density matrix or state vector with same dimensions as A.
--    tol : float
--        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
--    sparse : {False, True}
--        Use sparse eigensolver.
--
--    Returns
--    -------
--    hellinger_dist : float
--        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
--
--    Examples
--    --------
--    >>> x=fock_dm(5,3)
--    >>> y=coherent_dm(5,1)
--    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
--    """
--    if A.isket or A.isbra:
--        sqrtmA = ket2dm(A)
--    else:
--        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
--    if B.isket or B.isbra:
--        sqrtmB = ket2dm(B)
--    else:
--        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
--
--    if sqrtmA.dims != sqrtmB.dims:
--        raise TypeError("A and B do not have compatible dimensions.")
--
--    product = sqrtmA*sqrtmB
--    eigs = product.eigenenergies(sparse=sparse, tol=tol)
--    # np.maximum() is to avoid nan appearing sometimes due to numerical
--    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
--    # hellinger_dist(A, B) is called for A=B
--    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
--
--
--def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
--          sparse=True):
--    """
--    Calculates the diamond norm of the quantum map q_oper, using
--    the simplified semidefinite program of [Wat13]_.
--
--    The diamond norm SDP is solved by using CVXPY_.
--
--    Parameters
--    ----------
--    A : Qobj
--        Quantum map to take the diamond norm of.
--    B : Qobj or None
--        If provided, the diamond norm of :math:`A - B` is taken instead.
--    solver : str
--        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
--        latter tends to be significantly faster, but somewhat less accurate.
--    verbose : bool
--        If True, prints additional information about the solution.
--    force_solve : bool
--        If True, forces dnorm to solve the associated SDP, even if a special
--        case is known for the argument.
--    sparse : bool
--        Whether to use sparse matrices in the convex optimisation problem.
--        Default True.
--
--    Returns
--    -------
--    dn : float
--        Diamond norm of q_oper.
--
--    Raises
--    ------
--    ImportError
--        If CVXPY cannot be imported.
--
--    .. _cvxpy: https://www.cvxpy.org/en/latest/
--    """
--    if cvxpy is None:  # pragma: no cover
--        raise ImportError("dnorm() requires CVXPY to be installed.")
--
--    # We follow the strategy of using Watrous' simpler semidefinite
--    # program in its primal form. This is the same strategy used,
--    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
--    # QETLAB uses the dual problem.)
--
--    # Check if A and B are both unitaries. If so, then we can without
--    # loss of generality choose B to be the identity by using the
--    # unitary invariance of the diamond norm,
--    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
--    # Then, using the technique mentioned by each of Johnston and
--    # da Silva,
--    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
--    # where \lambda_i(U) is the ith eigenvalue of U.
--
--    # There's a lot of conditions to check for this path.  Only check if they
--    # aren't superoperators.  The difference of unitaries optimization is
--    # currently only implemented for d == 2. Much of the code below is more
--    # general, though, in anticipation of generalizing the optimization.
--    if (
--        not force_solve
--        and B is not None
--        and A.isoper and B.isoper
--        and A.shape[0] == 2
--    ):
--        # Make an identity the same size as A and B to
--        # compare against.
--        I = qeye(A.dims[0])
--        # Compare to B first, so that an error is raised
--        # as soon as possible.
--        Bd = B.dag()
--        if (
--            (B * Bd - I).norm() < 1e-6 and
--            (A * A.dag() - I).norm() < 1e-6
--        ):
--            # Now we are on the fast path, so let's compute the
--            # eigenvalues, then find the diameter of the smallest circle
--            # containing all of them.
--            #
--            # For now, this is only implemented for dim = 2, such that
--            # generalizing here will allow for generalizing the optimization.
--            # A reasonable approach would probably be to use Welzl's algorithm
--            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
--            U = A * B.dag()
--            eigs = U.eigenenergies()
--            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
--            return np.max(eig_distances)
--
--    # Force the input superoperator to be a Choi matrix.
--    J = to_choi(A)
--
--    if B is not None:
--        J -= to_choi(B)
--
--    # Watrous 2012 also points out that the diamond norm of Lambda
--    # is the same as the completely-bounded operator-norm (∞-norm)
--    # of the dual map of Lambda. We can evaluate that norm much more
--    # easily if Lambda is completely positive, since then the largest
--    # eigenvalue is the same as the largest singular value.
--
--    if not force_solve and J.iscp:
--        S_dual = to_super(J.dual_chan())
--        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
--        op = vector_to_operator(S_dual * vec_eye)
--        # The 2-norm was not implemented for sparse matrices as of the time
--        # of this writing. Thus, we must yet again go dense.
--        return la.norm(op.full(), 2)
--
--    # If we're still here, we need to actually solve the problem.
--
--    # Assume square...
--    dim = np.prod(J.dims[0][0])
--
--    # The constraints only depend on the dimension, so
--    # we can cache them efficiently.
--    problem, Jr, Ji, *_ = dnorm_problem(dim)
--
--    # Load the parameters with the Choi matrix passed in.
--    J_dat = _data.to('csr', J.data).as_scipy()
--
--    if not sparse:
--        # The parameters and constraints only depend on the dimension, so
--        # we can cache them efficiently.
--        problem, Jr, Ji = dnorm_problem(dim)
--
--        # Load the parameters with the Choi matrix passed in.
--        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
--                                  J_dat.indptr),
--                                 shape=J_dat.shape).toarray()
--
--        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
--                                  J_dat.indptr),
--                                 shape=J_dat.shape).toarray()
--    else:
--
--        # The parameters do not depend solely on the dimension,
--        # so we can not cache them efficiently.
--        problem = dnorm_sparse_problem(dim, J_dat)
--
--    problem.solve(solver=solver, verbose=verbose)
--
--    return problem.value
--
--
--def unitarity(oper):
--    """
--    Returns the unitarity of a quantum map, defined as the Frobenius norm
--    of the unital block of that map's superoperator representation.
--
--    Parameters
--    ----------
--    oper : Qobj
--        Quantum map under consideration.
--
--    Returns
--    -------
--    u : float
--        Unitarity of ``oper``.
--    """
--    Eu = _to_superpauli(oper).full()[1:, 1:]
--    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
-+# -*- coding: utf-8 -*-
-+
-+"""
-+This module contains a collection of functions for calculating metrics
-+(distance measures) between states and operators.
-+"""
-+
-+__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
-+           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
-+           'process_fidelity', 'unitarity', 'dnorm']
-+
-+import warnings
-+
-+import numpy as np
-+from scipy import linalg as la
-+import scipy.sparse as sp
-+from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
-+                           kraus_to_choi)
-+from .superoperator import operator_to_vector, vector_to_operator
-+from .operators import qeye
-+from .states import ket2dm
-+from .semidefinite import dnorm_problem, dnorm_sparse_problem
-+from . import data as _data
-+
-+try:
-+    import cvxpy
-+except ImportError:
-+    cvxpy = None
-+
-+
-+def fidelity(A, B):
-+    """
-+    Calculates the fidelity (pseudo-metric) between two density matrices.
-+    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
-+
-+    Parameters
-+    ----------
-+    A : qobj
-+        Density matrix or state vector.
-+    B : qobj
-+        Density matrix or state vector with same dimensions as A.
-+
-+    Returns
-+    -------
-+    fid : float
-+        Fidelity pseudo-metric between A and B.
-+
-+    Examples
-+    --------
-+    >>> x = fock_dm(5,3)
-+    >>> y = coherent_dm(5,1)
-+    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
-+    """
-+    if A.isket or A.isbra:
-+        if B.isket or B.isbra:
-+            # The fidelity for pure states reduces to the modulus of their
-+            # inner product.
-+            return np.abs(A.overlap(B))
-+        # Take advantage of the fact that the density operator for A
-+        # is a projector to avoid a sqrtm call.
-+        sqrtmA = ket2dm(A)
-+    else:
-+        if B.isket or B.isbra:
-+            # Swap the order so that we can take a more numerically
-+            # stable square root of B.
-+            return fidelity(B, A)
-+        # If we made it here, both A and B are operators, so
-+        # we have to take the sqrtm of one of them.
-+        sqrtmA = A.sqrtm()
-+
-+    if sqrtmA.dims != B.dims:
-+        raise TypeError('Density matrices do not have same dimensions.')
-+
-+    # We don't actually need the whole matrix here, just the trace
-+    # of its square root, so let's just get its eigenenergies instead.
-+    # We also truncate negative eigenvalues to avoid nan propagation;
-+    # even for positive semidefinite matrices, small negative eigenvalues
-+    # can be reported.
-+    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
-+    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
-+
-+
-+def _hilbert_space_dims(oper):
-+    """
-+    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
-+    of the output Hilbert space and the input Hilbert space.
-+    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
-+    - If oper is a list of Kraus operators, then
-+     `oper[0].dims == [dims_out, dims_in]`.
-+    - If oper is a superoperator with `oper.superrep == 'super'`:
-+     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
-+    - If oper is a superoperator with `oper.superrep == 'choi'`:
-+     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
-+    - If oper is a superoperator with `oper.superrep == 'chi', then
-+      `dims_out == dims_in` and
-+      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
-+    :param oper: A quantum channel, represented by a unitary, a list of Kraus
-+    operators, or a superoperator
-+    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
-+     of integers
-+    """
-+    if isinstance(oper, list):
-+        return oper[0].dims
-+    elif oper.type == 'oper':  # interpret as unitary quantum channel
-+        return oper.dims
-+    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
-+        return [oper.dims[0][1], oper.dims[1][0]]
-+    else:
-+        raise TypeError('oper is not a valid quantum channel!')
-+
-+
-+def _process_fidelity_to_id(oper):
-+    """
-+    Internal function returning the process fidelity of a quantum channel
-+    to the identity quantum channel.
-+    Parameters
-+    ----------
-+    oper : :class:`qutip.Qobj`/list
-+        A unitary operator, or a superoperator in supermatrix, Choi or
-+        chi-matrix form, or a list of Kraus operators
-+    Returns
-+    -------
-+    fid : float
-+    """
-+    dims_out, dims_in = _hilbert_space_dims(oper)
-+    if dims_out != dims_in:
-+        raise TypeError('The process fidelity to identity is only defined '
-+                        'for dimension preserving channels.')
-+    d = np.prod(dims_in)
-+    if isinstance(oper, list):  # oper is a list of Kraus operators
-+        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
-+    elif oper.type == 'oper':  # interpret as unitary
-+        return np.abs(oper.tr()) ** 2 / d ** 2
-+    elif oper.type == 'super':
-+        if oper.superrep == 'chi':
-+            return oper[0, 0].real / d ** 2
-+        else:  # oper.superrep is either 'super' or 'choi':
-+            return to_super(oper).tr().real / d ** 2
-+
-+
-+def _kraus_or_qobj_to_choi(oper):
-+    if isinstance(oper, list):
-+        return kraus_to_choi(oper)
-+    else:
-+        return to_choi(oper)
-+
-+
-+def process_fidelity(oper, target=None):
-+    """
-+    Returns the process fidelity of a quantum channel to the target
-+    channel, or to the identity channel if no target is given.
-+    The process fidelity between two channels is defined as the state
-+    fidelity between their normalized Choi matrices.
-+
-+    Parameters
-+    ----------
-+    oper : :class:`qutip.Qobj`/list
-+        A unitary operator, or a superoperator in supermatrix, Choi or
-+        chi-matrix form, or a list of Kraus operators
-+    target : :class:`qutip.Qobj`/list
-+        A unitary operator, or a superoperator in supermatrix, Choi or
-+        chi-matrix form, or a list of Kraus operators
-+
-+    Returns
-+    -------
-+    fid : float
-+        Process fidelity between oper and target, or between oper and identity.
-+
-+    Notes
-+    -----
-+    Since Qutip 5.0, this function computes the process fidelity as defined
-+    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
-+    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
-+    that is now implemented in
-+    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
-+    The definition of state fidelity that the process fidelity is based on
-+    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
-+    It is the square of the one implemented in
-+    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
-+    "Quantum Computation and Quantum Information"
-+
-+    """
-+    if target is None:
-+        return _process_fidelity_to_id(oper)
-+
-+    dims_out, dims_in = _hilbert_space_dims(oper)
-+    if dims_out != dims_in:
-+        raise NotImplementedError('Process fidelity only implemented for '
-+                                  'dimension-preserving operators.')
-+    dims_out_target, dims_in_target = _hilbert_space_dims(target)
-+    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
-+        raise TypeError('Dimensions of oper and target do not match')
-+
-+    if not isinstance(target, list) and target.type == 'oper':
-+        # interpret target as unitary.
-+        if isinstance(oper, list):  # oper is a list of Kraus operators
-+            return _process_fidelity_to_id([k * target.dag() for k in oper])
-+        elif oper.type == 'oper':
-+            return _process_fidelity_to_id(oper*target.dag())
-+        elif oper.type == 'super':
-+            oper_super = to_super(oper)
-+            target_dag_super = to_super(target.dag())
-+            return _process_fidelity_to_id(oper_super * target_dag_super)
-+    else:  # target is a list of Kraus operators or a superoperator
-+        if not isinstance(oper, list) and oper.type == 'oper':
-+            return process_fidelity(target, oper)  # reverse order
-+        oper_choi = _kraus_or_qobj_to_choi(oper)
-+        target_choi = _kraus_or_qobj_to_choi(target)
-+        d = np.prod(dims_in)
-+        return (fidelity(oper_choi, target_choi)/d)**2
-+
-+
-+def average_gate_fidelity(oper, target=None):
-+    """
-+    Returns the average gate fidelity of a quantum channel to the target
-+    channel, or to the identity channel if no target is given.
-+
-+    Parameters
-+    ----------
-+    oper : :class:`qutip.Qobj`/list
-+        A unitary operator, or a superoperator in supermatrix, Choi or
-+        chi-matrix form, or a list of Kraus operators
-+    target : :class:`qutip.Qobj`
-+        A unitary operator
-+
-+    Returns
-+    -------
-+    fid : float
-+        Average gate fidelity between oper and target,
-+        or between oper and identity.
-+
-+    Notes
-+    -----
-+    The average gate fidelity is defined for example in:
-+    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
-+    The definition of state fidelity that the average gate fidelity is based on
-+    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
-+    It is the square of the fidelity implemented in
-+    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
-+    "Quantum Computation and Quantum Information"
-+
-+    """
-+    dims_out, dims_in = _hilbert_space_dims(oper)
-+    if not (target is None or target.type == 'oper'):
-+        raise TypeError(
-+            'target must be None or a Qobj representing a unitary.')
-+
-+    d = np.prod(dims_in)
-+    return (d * process_fidelity(oper, target) + 1) / (d + 1)
-+
-+
-+def tracedist(A, B, sparse=False, tol=0):
-+    """
-+    Calculates the trace distance between two density matrices..
-+    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
-+
-+    Parameters
-+    ----------!=
-+    A : qobj
-+        Density matrix or state vector.
-+    B : qobj
-+        Density matrix or state vector with same dimensions as A.
-+    tol : float
-+        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
-+    sparse : {False, True}
-+        Use sparse eigensolver.
-+
-+    Returns
-+    -------
-+    tracedist : float
-+        Trace distance between A and B.
-+
-+    Examples
-+    --------
-+    >>> x=fock_dm(5,3)
-+    >>> y=coherent_dm(5,1)
-+    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
-+    """
-+    if A.isket or A.isbra:
-+        A = A.proj()
-+    if B.isket or B.isbra:
-+        B = B.proj()
-+    if A.dims != B.dims:
-+        raise TypeError("A and B do not have same dimensions.")
-+    diff = A - B
-+    diff = diff.dag() * diff
-+    vals = diff.eigenenergies(sparse=sparse, tol=tol)
-+    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
-+
-+
-+def hilbert_dist(A, B):
-+    """
-+    Returns the Hilbert-Schmidt distance between two density matrices A & B.
-+
-+    Parameters
-+    ----------
-+    A : qobj
-+        Density matrix or state vector.
-+    B : qobj
-+        Density matrix or state vector with same dimensions as A.
-+
-+    Returns
-+    -------
-+    dist : float
-+        Hilbert-Schmidt distance between density matrices.
-+
-+    Notes
-+    -----
-+    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
-+
-+    """
-+    if A.isket or A.isbra:
-+        A = A.proj()
-+    if B.isket or B.isbra:
-+        B = B.proj()
-+    if A.dims != B.dims:
-+        raise TypeError('A and B do not have same dimensions.')
-+    return ((A - B)**2).tr()
-+
-+
-+def bures_dist(A, B):
-+    """
-+    Returns the Bures distance between two density matrices A & B.
-+
-+    The Bures distance ranges from 0, for states with unit fidelity,
-+    to sqrt(2).
-+
-+    Parameters
-+    ----------
-+    A : qobj
-+        Density matrix or state vector.
-+    B : qobj
-+        Density matrix or state vector with same dimensions as A.
-+
-+    Returns
-+    -------
-+    dist : float
-+        Bures distance between density matrices.
-+    """
-+    if A.isket or A.isbra:
-+        A = A.proj()
-+    if B.isket or B.isbra:
-+        B = B.proj()
-+    if A.dims != B.dims:
-+        raise TypeError('A and B do not have same dimensions.')
-+    dist = np.sqrt(2 * (1 - fidelity(A, B)))
-+    return dist
-+
-+
-+def bures_angle(A, B):
-+    """
-+    Returns the Bures Angle between two density matrices A & B.
-+
-+    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
-+
-+    Parameters
-+    ----------
-+    A : qobj
-+        Density matrix or state vector.
-+    B : qobj
-+        Density matrix or state vector with same dimensions as A.
-+
-+    Returns
-+    -------
-+    angle : float
-+        Bures angle between density matrices.
-+    """
-+    if A.isket or A.isbra:
-+        A = A.proj()
-+    if B.isket or B.isbra:
-+        B = B.proj()
-+    if A.dims != B.dims:
-+        raise TypeError('A and B do not have same dimensions.')
-+    return np.arccos(fidelity(A, B))
-+
-+
-+def hellinger_dist(A, B, sparse=False, tol=0):
-+    """
-+    Calculates the quantum Hellinger distance between two density matrices.
-+
-+    Formula:
-+    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
-+
-+    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
-+    measures of quantum correlations with Bures and Hellinger distances"
-+    arXiv:1611.03449
-+
-+    Parameters
-+    ----------
-+    A : :class:`qutip.Qobj`
-+        Density matrix or state vector.
-+    B : :class:`qutip.Qobj`
-+        Density matrix or state vector with same dimensions as A.
-+    tol : float
-+        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
-+    sparse : {False, True}
-+        Use sparse eigensolver.
-+
-+    Returns
-+    -------
-+    hellinger_dist : float
-+        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
-+
-+    Examples
-+    --------
-+    >>> x=fock_dm(5,3)
-+    >>> y=coherent_dm(5,1)
-+    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
-+    """
-+    if A.isket or A.isbra:
-+        sqrtmA = ket2dm(A)
-+    else:
-+        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
-+    if B.isket or B.isbra:
-+        sqrtmB = ket2dm(B)
-+    else:
-+        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
-+
-+    if sqrtmA.dims != sqrtmB.dims:
-+        raise TypeError("A and B do not have compatible dimensions.")
-+
-+    product = sqrtmA*sqrtmB
-+    eigs = product.eigenenergies(sparse=sparse, tol=tol)
-+    # np.maximum() is to avoid nan appearing sometimes due to numerical
-+    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
-+    # hellinger_dist(A, B) is called for A=B
-+    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
-+
-+
-+def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
-+          sparse=True):
-+    """
-+    Calculates the diamond norm of the quantum map q_oper, using
-+    the simplified semidefinite program of [Wat13]_.
-+
-+    The diamond norm SDP is solved by using CVXPY_.
-+
-+    Parameters
-+    ----------
-+    A : Qobj
-+        Quantum map to take the diamond norm of.
-+    B : Qobj or None
-+        If provided, the diamond norm of :math:`A - B` is taken instead.
-+    solver : str
-+        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
-+        latter tends to be significantly faster, but somewhat less accurate.
-+    verbose : bool
-+        If True, prints additional information about the solution.
-+    force_solve : bool
-+        If True, forces dnorm to solve the associated SDP, even if a special
-+        case is known for the argument.
-+    sparse : bool
-+        Whether to use sparse matrices in the convex optimisation problem.
-+        Default True.
-+
-+    Returns
-+    -------
-+    dn : float
-+        Diamond norm of q_oper.
-+
-+    Raises
-+    ------
-+    ImportError
-+        If CVXPY cannot be imported.
-+
-+    .. _cvxpy: https://www.cvxpy.org/en/latest/
-+    """
-+    if cvxpy is None:  # pragma: no cover
-+        raise ImportError("dnorm() requires CVXPY to be installed.")
-+
-+    # We follow the strategy of using Watrous' simpler semidefinite
-+    # program in its primal form. This is the same strategy used,
-+    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
-+    # QETLAB uses the dual problem.)
-+
-+    # Check if A and B are both unitaries. If so, then we can without
-+    # loss of generality choose B to be the identity by using the
-+    # unitary invariance of the diamond norm,
-+    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
-+    # Then, using the technique mentioned by each of Johnston and
-+    # da Silva,
-+    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
-+    # where \lambda_i(U) is the ith eigenvalue of U.
-+
-+    # There's a lot of conditions to check for this path.  Only check if they
-+    # aren't superoperators.  The difference of unitaries optimization is
-+    # currently only implemented for d == 2. Much of the code below is more
-+    # general, though, in anticipation of generalizing the optimization.
-+    if (
-+        not force_solve
-+        and B is not None
-+        and A.isoper and B.isoper
-+        and A.shape[0] == 2
-+    ):
-+        # Make an identity the same size as A and B to
-+        # compare against.
-+        I = qeye(A.dims[0])
-+        # Compare to B first, so that an error is raised
-+        # as soon as possible.
-+        Bd = B.dag()
-+        if (
-+            (B * Bd - I).norm() < 1e-6 and
-+            (A * A.dag() - I).norm() < 1e-6
-+        ):
-+            # Now we are on the fast path, so let's compute the
-+            # eigenvalues, then find the diameter of the smallest circle
-+            # containing all of them.
-+            #
-+            # For now, this is only implemented for dim = 2, such that
-+            # generalizing here will allow for generalizing the optimization.
-+            # A reasonable approach would probably be to use Welzl's algorithm
-+            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
-+            U = A * B.dag()
-+            eigs = U.eigenenergies()
-+            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
-+            return np.max(eig_distances)
-+
-+    # Force the input superoperator to be a Choi matrix.
-+    J = to_choi(A)
-+
-+    if B is not None:
-+        J -= to_choi(B)
-+
-+    # Watrous 2012 also points out that the diamond norm of Lambda
-+    # is the same as the completely-bounded operator-norm (∞-norm)
-+    # of the dual map of Lambda. We can evaluate that norm much more
-+    # easily if Lambda is completely positive, since then the largest
-+    # eigenvalue is the same as the largest singular value.
-+
-+    if not force_solve and J.iscp:
-+        S_dual = to_super(J.dual_chan())
-+        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
-+        op = vector_to_operator(S_dual * vec_eye)
-+        # The 2-norm was not implemented for sparse matrices as of the time
-+        # of this writing. Thus, we must yet again go dense.
-+        return la.norm(op.full(), 2)
-+
-+    # If we're still here, we need to actually solve the problem.
-+
-+    # Assume square...
-+    dim = np.prod(J.dims[0][0])
-+
-+    # The constraints only depend on the dimension, so
-+    # we can cache them efficiently.
-+    problem, Jr, Ji, *_ = dnorm_problem(dim)
-+
-+    # Load the parameters with the Choi matrix passed in.
-+    J_dat = _data.to('csr', J.data).as_scipy()
-+
-+    if not sparse:
-+        # The parameters and constraints only depend on the dimension, so
-+        # we can cache them efficiently.
-+        problem, Jr, Ji = dnorm_problem(dim)
-+
-+        # Load the parameters with the Choi matrix passed in.
-+        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
-+                                  J_dat.indptr),
-+                                 shape=J_dat.shape).toarray()
-+
-+        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
-+                                  J_dat.indptr),
-+                                 shape=J_dat.shape).toarray()
-+    else:
-+
-+        # The parameters do not depend solely on the dimension,
-+        # so we can not cache them efficiently.
-+        problem = dnorm_sparse_problem(dim, J_dat)
-+
-+    problem.solve(solver=solver, verbose=verbose)
-+
-+    return problem.value
-+
-+
-+def unitarity(oper):
-+    """
-+    Returns the unitarity of a quantum map, defined as the Frobenius norm
-+    of the unital block of that map's superoperator representation.
-+
-+    Parameters
-+    ----------
-+    oper : Qobj
-+        Quantum map under consideration.
-+
-+    Returns
-+    -------
-+    u : float
-+        Unitarity of ``oper``.
-+    """
-+    Eu = _to_superpauli(oper).full()[1:, 1:]
-+    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
-diff --git a/qutip/core/operators.py b/qutip/core/operators.py
-index f2921882..f3de7e22 100644
---- a/qutip/core/operators.py
-+++ b/qutip/core/operators.py
-@@ -1,1073 +1,1073 @@
--"""
--This module contains functions for generating Qobj representation of a variety
--of commonly occuring quantum operators.
--"""
--
--__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
--           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
--           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
--           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
--           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
--           'enr_identity', 'charge', 'tunneling', 'qft']
--
--import numbers
--
--import numpy as np
--import scipy.sparse
--
--from . import data as _data
--from .qobj import Qobj
--from .dimensions import flatten
--from .. import settings
--
--
--def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
--           dtype=None):
--    """
--    Constructs an operator from an array of diagonals.
--
--    Parameters
--    ----------
--    diagonals : sequence of array_like
--        Array of elements to place along the selected diagonals.
--
--    offsets : sequence of ints, optional
--        Sequence for diagonals to be set:
--            - k=0 main diagonal
--            - k>0 kth upper diagonal
--            - k<0 kth lower diagonal
--
--    dims : list, optional
--        Dimensions for operator
--
--    shape : list, tuple, optional
--        Shape of operator.  If omitted, a square operator large enough
--        to contain the diagonals is generated.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Examples
--    --------
--    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
--    Quantum object: dims = [[4], [4]], \
--shape = [4, 4], type = oper, isherm = False
--    Qobj data =
--    [[ 0.          1.          0.          0.        ]
--     [ 0.          0.          1.41421356  0.        ]
--     [ 0.          0.          0.          1.73205081]
--     [ 0.          0.          0.          0.        ]]
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    offsets = [0] if offsets is None else offsets
--    data = _data.diag[dtype](diagonals, offsets, shape)
--    return Qobj(data, dims=dims, type='oper', copy=False)
--
--
--def jmat(j, which=None, *, dtype=None):
--    """Higher-order spin operators:
--
--    Parameters
--    ----------
--    j : float
--        Spin of operator
--
--    which : str
--        Which operator to return 'x','y','z','+','-'.
--        If no args given, then output is ['x','y','z']
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    jmat : Qobj or tuple of Qobj
--        ``qobj`` for requested spin operator(s).
--
--
--    Examples
--    --------
--    >>> jmat(1) # doctest: +SKIP
--    [ Quantum object: dims = [[3], [3]], \
--shape = [3, 3], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.          0.70710678  0.        ]
--     [ 0.70710678  0.          0.70710678]
--     [ 0.          0.70710678  0.        ]]
--     Quantum object: dims = [[3], [3]], \
--shape = [3, 3], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
--     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
--     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
--     Quantum object: dims = [[3], [3]], \
--shape = [3, 3], type = oper, isHerm = True
--    Qobj data =
--    [[ 1.  0.  0.]
--     [ 0.  0.  0.]
--     [ 0.  0. -1.]]]
--
--    Notes
--    -----
--    If no 'args' input, then returns array of ['x','y','z'] operators.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    if int(2 * j) != 2 * j or j < 0:
--        raise ValueError('j must be a non-negative integer or half-integer')
--
--    if not which:
--        return (
--            jmat(j, 'x', dtype=dtype),
--            jmat(j, 'y', dtype=dtype),
--            jmat(j, 'z', dtype=dtype)
--        )
--
--    dims = [[int(2*j + 1)]]*2
--    if which == '+':
--        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
--                    isherm=False, isunitary=False, copy=False)
--    if which == '-':
--        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
--                    isherm=False, isunitary=False, copy=False)
--    if which == 'x':
--        A =  _jplus(j, dtype=dtype)
--        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
--                    isherm=True, isunitary=False, copy=False) * 0.5
--    if which == 'y':
--        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
--        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
--                    isherm=True, isunitary=False, copy=False)
--    if which == 'z':
--        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
--                    isherm=True, isunitary=False, copy=False)
--    raise ValueError('Invalid spin operator: ' + which)
--
--
--def _jplus(j, *, dtype=None):
--    """
--    Internal functions for generating the data representing the J-plus
--    operator.
--    """
--    m = np.arange(j, -j - 1, -1, dtype=complex)
--    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
--    return _data.diag[dtype](data, 1)
--
--
--def _jz(j, *, dtype=None):
--    """
--    Internal functions for generating the data representing the J-z operator.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    N = int(2*j + 1)
--    data = np.array([j-k for k in range(N)], dtype=complex)
--    return _data.diag[dtype](data, 0)
--
--
--#
--# Spin j operators:
--#
--def spin_Jx(j, *, dtype=None):
--    """Spin-j x operator
--
--    Parameters
--    ----------
--    j : float
--        Spin of operator
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    op : Qobj
--        ``qobj`` representation of the operator.
--
--    """
--    return jmat(j, 'x', dtype=dtype)
--
--
--def spin_Jy(j, *, dtype=None):
--    """Spin-j y operator
--
--    Parameters
--    ----------
--    j : float
--        Spin of operator
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    op : Qobj
--        ``qobj`` representation of the operator.
--
--    """
--    return jmat(j, 'y', dtype=dtype)
--
--
--def spin_Jz(j, *, dtype=None):
--    """Spin-j z operator
--
--    Parameters
--    ----------
--    j : float
--        Spin of operator
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    op : Qobj
--        ``qobj`` representation of the operator.
--
--    """
--    return jmat(j, 'z', dtype=dtype)
--
--
--def spin_Jm(j, *, dtype=None):
--    """Spin-j annihilation operator
--
--    Parameters
--    ----------
--    j : float
--        Spin of operator
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    op : Qobj
--        ``qobj`` representation of the operator.
--
--    """
--    return jmat(j, '-', dtype=dtype)
--
--
--def spin_Jp(j, *, dtype=None):
--    """Spin-j creation operator
--
--    Parameters
--    ----------
--    j : float
--        Spin of operator
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    op : Qobj
--        ``qobj`` representation of the operator.
--
--    """
--    return jmat(j, '+', dtype=dtype)
--
--
--def spin_J_set(j, *, dtype=None):
--    """Set of spin-j operators (x, y, z)
--
--    Parameters
--    ----------
--    j : float
--        Spin of operators
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    list : list of Qobj
--        list of ``qobj`` representating of the spin operator.
--
--    """
--    return jmat(j, dtype=dtype)
--
--
--# Pauli spin-1/2 operators.
--#
--# These are so common in quantum information that we want them to be
--# near-instantaneous to initialise, so we cache them at package import, and
--# just return copies when someone requests one.
--_SIGMAP = jmat(0.5, '+')
--_SIGMAM = jmat(0.5, '-')
--_SIGMAX = 2 * jmat(0.5, 'x')
--_SIGMAY = 2 * jmat(0.5, 'y')
--_SIGMAZ = 2 * jmat(0.5, 'z')
--
--
--def sigmap():
--    """Creation operator for Pauli spins.
--
--    Examples
--    --------
--    >>> sigmap() # doctest: +SKIP
--    Quantum object: dims = [[2], [2]], \
--shape = [2, 2], type = oper, isHerm = False
--    Qobj data =
--    [[ 0.  1.]
--     [ 0.  0.]]
--
--    """
--    return _SIGMAP.copy()
--
--
--def sigmam():
--    """Annihilation operator for Pauli spins.
--
--    Examples
--    --------
--    >>> sigmam() # doctest: +SKIP
--    Quantum object: dims = [[2], [2]], \
--shape = [2, 2], type = oper, isHerm = False
--    Qobj data =
--    [[ 0.  0.]
--     [ 1.  0.]]
--
--    """
--    return _SIGMAM.copy()
--
--
--def sigmax():
--    """Pauli spin 1/2 sigma-x operator
--
--    Examples
--    --------
--    >>> sigmax() # doctest: +SKIP
--    Quantum object: dims = [[2], [2]], \
--shape = [2, 2], type = oper, isHerm = False
--    Qobj data =
--    [[ 0.  1.]
--     [ 1.  0.]]
--
--    """
--    return _SIGMAX.copy()
--
--
--def sigmay():
--    """Pauli spin 1/2 sigma-y operator.
--
--    Examples
--    --------
--    >>> sigmay() # doctest: +SKIP
--    Quantum object: dims = [[2], [2]], \
--shape = [2, 2], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.+0.j  0.-1.j]
--     [ 0.+1.j  0.+0.j]]
--
--    """
--    return _SIGMAY.copy()
--
--
--def sigmaz():
--    """Pauli spin 1/2 sigma-z operator.
--
--    Examples
--    --------
--    >>> sigmaz() # doctest: +SKIP
--    Quantum object: dims = [[2], [2]], \
--shape = [2, 2], type = oper, isHerm = True
--    Qobj data =
--    [[ 1.  0.]
--     [ 0. -1.]]
--
--    """
--    return _SIGMAZ.copy()
--
--
--def destroy(N, offset=0, *, dtype=None):
--    """
--    Destruction (lowering) operator.
--
--    Parameters
--    ----------
--    N : int
--        Dimension of Hilbert space.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Qobj for lowering operator.
--
--    Examples
--    --------
--    >>> destroy(4) # doctest: +SKIP
--    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
--    Qobj data =
--    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
--     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
--     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
--     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
--        raise ValueError("Hilbert space dimension must be integer value")
--    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
--    return qdiags(data, 1, dtype=dtype)
--
--
--def create(N, offset=0, *, dtype=None):
--    """
--    Creation (raising) operator.
--
--    Parameters
--    ----------
--    N : int
--        Dimension of Hilbert space.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Qobj for raising operator.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    Examples
--    --------
--    >>> create(4) # doctest: +SKIP
--    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
--    Qobj data =
--    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
--     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
--     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
--     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
--        raise ValueError("Hilbert space dimension must be integer value")
--    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
--    return qdiags(data, -1, dtype=dtype)
--
--
--def _implicit_tensor_dimensions(dimensions):
--    """
--    Total flattened size and operator dimensions for operator creation routines
--    that automatically perform tensor products.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        First dimension of an operator which can create an implicit tensor
--        product.  If the type is `int`, it is promoted first to `[dimensions]`.
--        From there, it should be one of the two-elements `dims` parameter of a
--        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
--        products.
--
--    Returns
--    -------
--    size : int
--        Dimension of backing matrix required to represent operator.
--    dimensions : list
--        Dimension list in the form required by ``Qobj`` creation.
--    """
--    if not isinstance(dimensions, list):
--        dimensions = [dimensions]
--    flat = flatten(dimensions)
--    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
--        raise ValueError("All dimensions must be integers >= 0")
--    return np.prod(flat), [dimensions, dimensions]
--
--
--def qzero(dimensions, *, dtype=None):
--    """
--    Zero operator.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    qzero : qobj
--        Zero operator Qobj.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    size, dimensions = _implicit_tensor_dimensions(dimensions)
--    # A sparse matrix with no data is equal to a zero matrix.
--    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
--    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
--                isherm=True, isunitary=False, copy=False)
--
--
--def qeye(dimensions, *, dtype=None):
--    """
--    Identity operator.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Identity operator Qobj.
--
--    Examples
--    --------
--    >>> qeye(3) # doctest: +SKIP
--    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
--isherm = True
--    Qobj data =
--    [[ 1.  0.  0.]
--     [ 0.  1.  0.]
--     [ 0.  0.  1.]]
--    >>> qeye([2,2]) # doctest: +SKIP
--    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
--isherm = True
--    Qobj data =
--    [[1. 0. 0. 0.]
--     [0. 1. 0. 0.]
--     [0. 0. 1. 0.]
--     [0. 0. 0. 1.]]
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    size, dimensions = _implicit_tensor_dimensions(dimensions)
--    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
--    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
--                isherm=True, isunitary=True, copy=False)
--
--
--# Name alias.
--identity = qeye
--
--
--def position(N, offset=0, *, dtype=None):
--    """
--    Position operator x=1/sqrt(2)*(a+a.dag())
--
--    Parameters
--    ----------
--    N : int
--        Number of Fock states in Hilbert space.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Position operator as Qobj.
--    """
--    a = destroy(N, offset=offset, dtype=dtype)
--    position = np.sqrt(0.5) * (a + a.dag())
--    position.isherm = True
--    return position
--
--
--def momentum(N, offset=0, *, dtype=None):
--    """
--    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
--
--    Parameters
--    ----------
--    N : int
--        Number of Fock states in Hilbert space.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Momentum operator as Qobj.
--    """
--    a = destroy(N, offset=offset, dtype=dtype)
--    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
--    momentum.isherm = True
--    return momentum
--
--
--def num(N, offset=0, *, dtype=None):
--    """
--    Quantum object for number operator.
--
--    Parameters
--    ----------
--    N : int
--        The dimension of the Hilbert space.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper: qobj
--        Qobj for number operator.
--
--    Examples
--    --------
--    >>> num(4) # doctest: +SKIP
--    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
--    Qobj data =
--    [[0 0 0 0]
--     [0 1 0 0]
--     [0 0 2 0]
--     [0 0 0 3]]
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    data = np.arange(offset, offset + N, dtype=complex)
--    return qdiags(data, 0, dtype=dtype)
--
--
--def squeeze(N, z, offset=0, *, dtype=None):
--    """Single-mode squeezing operator.
--
--    Parameters
--    ----------
--    N : int
--        Dimension of hilbert space.
--
--    z : float/complex
--        Squeezing parameter.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : :class:`qutip.Qobj`
--        Squeezing operator.
--
--
--    Examples
--    --------
--    >>> squeeze(4, 0.25) # doctest: +SKIP
--    Quantum object: dims = [[4], [4]], \
--shape = [4, 4], type = oper, isHerm = False
--    Qobj data =
--    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
--     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
--     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
--     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
--
--    """
--    asq = destroy(N, offset=offset, dtype=dtype) ** 2
--    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
--    return op.expm(dtype=dtype)
--
--
--def squeezing(a1, a2, z):
--    """Generalized squeezing operator.
--
--    .. math::
--
--        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
--        - za_1^\\dagger a_2^\\dagger\\right)\\right)
--
--    Parameters
--    ----------
--    a1 : :class:`qutip.Qobj`
--        Operator 1.
--
--    a2 : :class:`qutip.Qobj`
--        Operator 2.
--
--    z : float/complex
--        Squeezing parameter.
--
--    Returns
--    -------
--    oper : :class:`qutip.Qobj`
--        Squeezing operator.
--
--    """
--    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
--    return b.expm()
--
--
--def displace(N, alpha, offset=0, *, dtype=None):
--    """Single-mode displacement operator.
--
--    Parameters
--    ----------
--    N : int
--        Dimension of Hilbert space.
--
--    alpha : float/complex
--        Displacement amplitude.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the operator.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Displacement operator.
--
--    Examples
--    --------
--    >>> displace(4,0.25) # doctest: +SKIP
--    Quantum object: dims = [[4], [4]], \
--shape = [4, 4], type = oper, isHerm = False
--    Qobj data =
--    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
--     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
--     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
--     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    a = destroy(N, offset=offset)
--    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
--
--
--def commutator(A, B, kind="normal"):
--    """
--    Return the commutator of kind `kind` (normal, anti) of the
--    two operators A and B.
--    """
--    if kind == 'normal':
--        return A @ B - B @ A
--
--    elif kind == 'anti':
--        return A @ B + B @ A
--
--    else:
--        raise TypeError("Unknown commutator kind '%s'" % kind)
--
--
--def qutrit_ops(*, dtype=None):
--    """
--    Operators for a three level system (qutrit).
--
--    Parameters
--    ----------
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    opers: array
--        `array` of qutrit operators.
--
--    """
--    from .states import qutrit_basis
--
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    out = np.empty((6,), dtype=object)
--    one, two, three = qutrit_basis(dtype=dtype)
--    out[0] = one * one.dag()
--    out[1] = two * two.dag()
--    out[2] = three * three.dag()
--    out[3] = one * two.dag()
--    out[4] = two * three.dag()
--    out[5] = three * one.dag()
--    return out
--
--
--def phase(N, phi0=0, *, dtype=None):
--    """
--    Single-mode Pegg-Barnett phase operator.
--
--    Parameters
--    ----------
--    N : int
--        Number of basis states in Hilbert space.
--
--    phi0 : float
--        Reference phase.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Phase operator with respect to reference phase.
--
--    Notes
--    -----
--    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
--    n = np.arange(N)[:, np.newaxis]
--    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
--                       for kk in phim])
--    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
--    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
--
--
--def enr_destroy(dims, excitations, *, dtype=None):
--    """
--    Generate annilation operators for modes in a excitation-number-restricted
--    state space. For example, consider a system consisting of 4 modes, each
--    with 5 states. The total hilbert space size is 5**4 = 625. If we are
--    only interested in states that contain up to 2 excitations, we only need
--    to include states such as
--
--        (0, 0, 0, 0)
--        (0, 0, 0, 1)
--        (0, 0, 0, 2)
--        (0, 0, 1, 0)
--        (0, 0, 1, 1)
--        (0, 0, 2, 0)
--        ...
--
--    This function creates annihilation operators for the 4 modes that act
--    within this state space:
--
--        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
--
--    From this point onwards, the annihiltion operators a1, ..., a4 can be
--    used to setup a Hamiltonian, collapse operators and expectation-value
--    operators, etc., following the usual pattern.
--
--    Parameters
--    ----------
--    dims : list
--        A list of the dimensions of each subsystem of a composite quantum
--        system.
--
--    excitations : integer
--        The maximum number of excitations that are to be included in the
--        state space.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    a_ops : list of qobj
--        A list of annihilation operators for each mode in the composite
--        quantum system described by dims.
--    """
--    from .states import enr_state_dictionaries
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--
--    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
--
--    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
--             for _ in dims]
--
--    for n1, state1 in enumerate(idx2state):
--        for idx, s in enumerate(state1):
--            # if s > 0, the annihilation operator of mode idx has a non-zero
--            # entry with one less excitation in mode idx in the final state
--            if s > 0:
--                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
--                n2 = state2idx[state2]
--                a_ops[idx][n2, n1] = np.sqrt(s)
--
--    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
--
--
--def enr_identity(dims, excitations, *, dtype=None):
--    """
--    Generate the identity operator for the excitation-number restricted
--    state space defined by the `dims` and `exciations` arguments. See the
--    docstring for enr_fock for a more detailed description of these arguments.
--
--    Parameters
--    ----------
--    dims : list
--        A list of the dimensions of each subsystem of a composite quantum
--        system.
--
--    excitations : integer
--        The maximum number of excitations that are to be included in the
--        state space.
--
--    state : list of integers
--        The state in the number basis representation.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    op : Qobj
--        A Qobj instance that represent the identity operator in the
--        exication-number-restricted state space defined by `dims` and
--        `exciations`.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    from .states import enr_state_dictionaries
--    nstates, _, _ = enr_state_dictionaries(dims, excitations)
--    return Qobj(_data.identity[dtype](nstates),
--                dims=[dims, dims],
--                type='oper',
--                isherm=True,
--                isunitary=True,
--                copy=False)
--
--
--def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
--    """
--    Generate the diagonal charge operator over charge states
--    from Nmin to Nmax.
--
--    Parameters
--    ----------
--    Nmax : int
--        Maximum charge state to consider.
--
--    Nmin : int (default = -Nmax)
--        Lowest charge state to consider.
--
--    frac : float (default = 1)
--        Specify fractional charge if needed.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    C : Qobj
--        Charge operator over [Nmin, Nmax].
--
--    Notes
--    -----
--    .. versionadded:: 3.2
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    if Nmin is None:
--        Nmin = -Nmax
--    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
--    out = qdiags(diag, 0, dtype=dtype)
--    out.isherm = True
--    return out
--
--
--def tunneling(N, m=1, *, dtype=None):
--    r"""
--    Tunneling operator with elements of the form
--    :math:`\\sum |N><N+m| + |N+m><N|`.
--
--    Parameters
--    ----------
--    N : int
--        Number of basis states in Hilbert space.
--
--    m : int (default = 1)
--        Number of excitations in tunneling event.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    T : Qobj
--        Tunneling operator.
--
--    Notes
--    -----
--    .. versionadded:: 3.2
--
--    """
--    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
--    T = qdiags(diags, [m, -m], dtype=dtype)
--    T.isherm = True
--    return T
--
--
--def qft(dimensions, *, dtype="dense"):
--    """
--    Quantum Fourier Transform operator.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.
--
--    dtype : str or type, [keyword only] [optional]
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    QFT: qobj
--        Quantum Fourier transform operator.
--
--    """
--    N2, dimensions = _implicit_tensor_dimensions(dimensions)
--
--    phase = 2.0j * np.pi / N2
--    arr = np.arange(N2)
--    L, M = np.meshgrid(arr, arr)
--    data = np.exp(phase * (L * M)) / np.sqrt(N2)
--    return Qobj(data, dims=dimensions).to(dtype)
-+"""
-+This module contains functions for generating Qobj representation of a variety
-+of commonly occuring quantum operators.
-+"""
-+
-+__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
-+           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-+           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
-+           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
-+           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
-+           'enr_identity', 'charge', 'tunneling', 'qft']
-+
-+import numbers
-+
-+import numpy as np
-+import scipy.sparse
-+
-+from . import data as _data
-+from .qobj import Qobj
-+from .dimensions import flatten
-+from .. import settings
-+
-+
-+def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
-+           dtype=None):
-+    """
-+    Constructs an operator from an array of diagonals.
-+
-+    Parameters
-+    ----------
-+    diagonals : sequence of array_like
-+        Array of elements to place along the selected diagonals.
-+
-+    offsets : sequence of ints, optional
-+        Sequence for diagonals to be set:
-+            - k=0 main diagonal
-+            - k>0 kth upper diagonal
-+            - k<0 kth lower diagonal
-+
-+    dims : list, optional
-+        Dimensions for operator
-+
-+    shape : list, tuple, optional
-+        Shape of operator.  If omitted, a square operator large enough
-+        to contain the diagonals is generated.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Examples
-+    --------
-+    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
-+    Quantum object: dims = [[4], [4]], \
-+shape = [4, 4], type = oper, isherm = False
-+    Qobj data =
-+    [[ 0.          1.          0.          0.        ]
-+     [ 0.          0.          1.41421356  0.        ]
-+     [ 0.          0.          0.          1.73205081]
-+     [ 0.          0.          0.          0.        ]]
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    offsets = [0] if offsets is None else offsets
-+    data = _data.diag[dtype](diagonals, offsets, shape)
-+    return Qobj(data, dims=dims, type='oper', copy=False)
-+
-+
-+def jmat(j, which=None, *, dtype=None):
-+    """Higher-order spin operators:
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operator
-+
-+    which : str
-+        Which operator to return 'x','y','z','+','-'.
-+        If no args given, then output is ['x','y','z']
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    jmat : Qobj or tuple of Qobj
-+        ``qobj`` for requested spin operator(s).
-+
-+
-+    Examples
-+    --------
-+    >>> jmat(1) # doctest: +SKIP
-+    [ Quantum object: dims = [[3], [3]], \
-+shape = [3, 3], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.          0.70710678  0.        ]
-+     [ 0.70710678  0.          0.70710678]
-+     [ 0.          0.70710678  0.        ]]
-+     Quantum object: dims = [[3], [3]], \
-+shape = [3, 3], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
-+     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
-+     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
-+     Quantum object: dims = [[3], [3]], \
-+shape = [3, 3], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 1.  0.  0.]
-+     [ 0.  0.  0.]
-+     [ 0.  0. -1.]]]
-+
-+    Notes
-+    -----
-+    If no 'args' input, then returns array of ['x','y','z'] operators.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    if int(2 * j) != 2 * j or j < 0:
-+        raise ValueError('j must be a non-negative integer or half-integer')
-+
-+    if not which:
-+        return (
-+            jmat(j, 'x', dtype=dtype),
-+            jmat(j, 'y', dtype=dtype),
-+            jmat(j, 'z', dtype=dtype)
-+        )
-+
-+    dims = [[int(2*j + 1)]]*2
-+    if which == '+':
-+        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
-+                    isherm=False, isunitary=False, copy=False)
-+    if which == '-':
-+        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
-+                    isherm=False, isunitary=False, copy=False)
-+    if which == 'x':
-+        A =  _jplus(j, dtype=dtype)
-+        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
-+                    isherm=True, isunitary=False, copy=False) * 0.5
-+    if which == 'y':
-+        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
-+        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
-+                    isherm=True, isunitary=False, copy=False)
-+    if which == 'z':
-+        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
-+                    isherm=True, isunitary=False, copy=False)
-+    raise ValueError('Invalid spin operator: ' + which)
-+
-+
-+def _jplus(j, *, dtype=None):
-+    """
-+    Internal functions for generating the data representing the J-plus
-+    operator.
-+    """
-+    m = np.arange(j, -j - 1, -1, dtype=complex)
-+    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
-+    return _data.diag[dtype](data, 1)
-+
-+
-+def _jz(j, *, dtype=None):
-+    """
-+    Internal functions for generating the data representing the J-z operator.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    N = int(2*j + 1)
-+    data = np.array([j-k for k in range(N)], dtype=complex)
-+    return _data.diag[dtype](data, 0)
-+
-+
-+#
-+# Spin j operators:
-+#
-+def spin_Jx(j, *, dtype=None):
-+    """Spin-j x operator
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operator
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    op : Qobj
-+        ``qobj`` representation of the operator.
-+
-+    """
-+    return jmat(j, 'x', dtype=dtype)
-+
-+
-+def spin_Jy(j, *, dtype=None):
-+    """Spin-j y operator
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operator
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    op : Qobj
-+        ``qobj`` representation of the operator.
-+
-+    """
-+    return jmat(j, 'y', dtype=dtype)
-+
-+
-+def spin_Jz(j, *, dtype=None):
-+    """Spin-j z operator
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operator
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    op : Qobj
-+        ``qobj`` representation of the operator.
-+
-+    """
-+    return jmat(j, 'z', dtype=dtype)
-+
-+
-+def spin_Jm(j, *, dtype=None):
-+    """Spin-j annihilation operator
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operator
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    op : Qobj
-+        ``qobj`` representation of the operator.
-+
-+    """
-+    return jmat(j, '-', dtype=dtype)
-+
-+
-+def spin_Jp(j, *, dtype=None):
-+    """Spin-j creation operator
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operator
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    op : Qobj
-+        ``qobj`` representation of the operator.
-+
-+    """
-+    return jmat(j, '+', dtype=dtype)
-+
-+
-+def spin_J_set(j, *, dtype=None):
-+    """Set of spin-j operators (x, y, z)
-+
-+    Parameters
-+    ----------
-+    j : float
-+        Spin of operators
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    list : list of Qobj
-+        list of ``qobj`` representating of the spin operator.
-+
-+    """
-+    return jmat(j, dtype=dtype)
-+
-+
-+# Pauli spin-1/2 operators.
-+#
-+# These are so common in quantum information that we want them to be
-+# near-instantaneous to initialise, so we cache them at package import, and
-+# just return copies when someone requests one.
-+_SIGMAP = jmat(0.5, '+')
-+_SIGMAM = jmat(0.5, '-')
-+_SIGMAX = 2 * jmat(0.5, 'x')
-+_SIGMAY = 2 * jmat(0.5, 'y')
-+_SIGMAZ = 2 * jmat(0.5, 'z')
-+
-+
-+def sigmap():
-+    """Creation operator for Pauli spins.
-+
-+    Examples
-+    --------
-+    >>> sigmap() # doctest: +SKIP
-+    Quantum object: dims = [[2], [2]], \
-+shape = [2, 2], type = oper, isHerm = False
-+    Qobj data =
-+    [[ 0.  1.]
-+     [ 0.  0.]]
-+
-+    """
-+    return _SIGMAP.copy()
-+
-+
-+def sigmam():
-+    """Annihilation operator for Pauli spins.
-+
-+    Examples
-+    --------
-+    >>> sigmam() # doctest: +SKIP
-+    Quantum object: dims = [[2], [2]], \
-+shape = [2, 2], type = oper, isHerm = False
-+    Qobj data =
-+    [[ 0.  0.]
-+     [ 1.  0.]]
-+
-+    """
-+    return _SIGMAM.copy()
-+
-+
-+def sigmax():
-+    """Pauli spin 1/2 sigma-x operator
-+
-+    Examples
-+    --------
-+    >>> sigmax() # doctest: +SKIP
-+    Quantum object: dims = [[2], [2]], \
-+shape = [2, 2], type = oper, isHerm = False
-+    Qobj data =
-+    [[ 0.  1.]
-+     [ 1.  0.]]
-+
-+    """
-+    return _SIGMAX.copy()
-+
-+
-+def sigmay():
-+    """Pauli spin 1/2 sigma-y operator.
-+
-+    Examples
-+    --------
-+    >>> sigmay() # doctest: +SKIP
-+    Quantum object: dims = [[2], [2]], \
-+shape = [2, 2], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.+0.j  0.-1.j]
-+     [ 0.+1.j  0.+0.j]]
-+
-+    """
-+    return _SIGMAY.copy()
-+
-+
-+def sigmaz():
-+    """Pauli spin 1/2 sigma-z operator.
-+
-+    Examples
-+    --------
-+    >>> sigmaz() # doctest: +SKIP
-+    Quantum object: dims = [[2], [2]], \
-+shape = [2, 2], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 1.  0.]
-+     [ 0. -1.]]
-+
-+    """
-+    return _SIGMAZ.copy()
-+
-+
-+def destroy(N, offset=0, *, dtype=None):
-+    """
-+    Destruction (lowering) operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Dimension of Hilbert space.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Qobj for lowering operator.
-+
-+    Examples
-+    --------
-+    >>> destroy(4) # doctest: +SKIP
-+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
-+    Qobj data =
-+    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-+     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
-+     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
-+     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
-+        raise ValueError("Hilbert space dimension must be integer value")
-+    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
-+    return qdiags(data, 1, dtype=dtype)
-+
-+
-+def create(N, offset=0, *, dtype=None):
-+    """
-+    Creation (raising) operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Dimension of Hilbert space.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Qobj for raising operator.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    Examples
-+    --------
-+    >>> create(4) # doctest: +SKIP
-+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
-+    Qobj data =
-+    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-+     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-+     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
-+     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
-+        raise ValueError("Hilbert space dimension must be integer value")
-+    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
-+    return qdiags(data, -1, dtype=dtype)
-+
-+
-+def _implicit_tensor_dimensions(dimensions):
-+    """
-+    Total flattened size and operator dimensions for operator creation routines
-+    that automatically perform tensor products.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        First dimension of an operator which can create an implicit tensor
-+        product.  If the type is `int`, it is promoted first to `[dimensions]`.
-+        From there, it should be one of the two-elements `dims` parameter of a
-+        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
-+        products.
-+
-+    Returns
-+    -------
-+    size : int
-+        Dimension of backing matrix required to represent operator.
-+    dimensions : list
-+        Dimension list in the form required by ``Qobj`` creation.
-+    """
-+    if not isinstance(dimensions, list):
-+        dimensions = [dimensions]
-+    flat = flatten(dimensions)
-+    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
-+        raise ValueError("All dimensions must be integers >= 0")
-+    return np.prod(flat), [dimensions, dimensions]
-+
-+
-+def qzero(dimensions, *, dtype=None):
-+    """
-+    Zero operator.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    qzero : qobj
-+        Zero operator Qobj.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    size, dimensions = _implicit_tensor_dimensions(dimensions)
-+    # A sparse matrix with no data is equal to a zero matrix.
-+    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
-+    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
-+                isherm=True, isunitary=False, copy=False)
-+
-+
-+def qeye(dimensions, *, dtype=None):
-+    """
-+    Identity operator.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Identity operator Qobj.
-+
-+    Examples
-+    --------
-+    >>> qeye(3) # doctest: +SKIP
-+    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
-+isherm = True
-+    Qobj data =
-+    [[ 1.  0.  0.]
-+     [ 0.  1.  0.]
-+     [ 0.  0.  1.]]
-+    >>> qeye([2,2]) # doctest: +SKIP
-+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
-+isherm = True
-+    Qobj data =
-+    [[1. 0. 0. 0.]
-+     [0. 1. 0. 0.]
-+     [0. 0. 1. 0.]
-+     [0. 0. 0. 1.]]
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    size, dimensions = _implicit_tensor_dimensions(dimensions)
-+    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
-+    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
-+                isherm=True, isunitary=True, copy=False)
-+
-+
-+# Name alias.
-+identity = qeye
-+
-+
-+def position(N, offset=0, *, dtype=None):
-+    """
-+    Position operator x=1/sqrt(2)*(a+a.dag())
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of Fock states in Hilbert space.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Position operator as Qobj.
-+    """
-+    a = destroy(N, offset=offset, dtype=dtype)
-+    position = np.sqrt(0.5) * (a + a.dag())
-+    position.isherm = True
-+    return position
-+
-+
-+def momentum(N, offset=0, *, dtype=None):
-+    """
-+    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of Fock states in Hilbert space.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Momentum operator as Qobj.
-+    """
-+    a = destroy(N, offset=offset, dtype=dtype)
-+    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
-+    momentum.isherm = True
-+    return momentum
-+
-+
-+def num(N, offset=0, *, dtype=None):
-+    """
-+    Quantum object for number operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        The dimension of the Hilbert space.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper: qobj
-+        Qobj for number operator.
-+
-+    Examples
-+    --------
-+    >>> num(4) # doctest: +SKIP
-+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
-+    Qobj data =
-+    [[0 0 0 0]
-+     [0 1 0 0]
-+     [0 0 2 0]
-+     [0 0 0 3]]
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    data = np.arange(offset, offset + N, dtype=complex)
-+    return qdiags(data, 0, dtype=dtype)
-+
-+
-+def squeeze(N, z, offset=0, *, dtype=None):
-+    """Single-mode squeezing operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Dimension of hilbert space.
-+
-+    z : float/complex
-+        Squeezing parameter.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : :class:`qutip.Qobj`
-+        Squeezing operator.
-+
-+
-+    Examples
-+    --------
-+    >>> squeeze(4, 0.25) # doctest: +SKIP
-+    Quantum object: dims = [[4], [4]], \
-+shape = [4, 4], type = oper, isHerm = False
-+    Qobj data =
-+    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
-+     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
-+     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
-+     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
-+
-+    """
-+    asq = destroy(N, offset=offset, dtype=dtype) ** 2
-+    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
-+    return op.expm(dtype=dtype)
-+
-+
-+def squeezing(a1, a2, z):
-+    """Generalized squeezing operator.
-+
-+    .. math::
-+
-+        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
-+        - za_1^\\dagger a_2^\\dagger\\right)\\right)
-+
-+    Parameters
-+    ----------
-+    a1 : :class:`qutip.Qobj`
-+        Operator 1.
-+
-+    a2 : :class:`qutip.Qobj`
-+        Operator 2.
-+
-+    z : float/complex
-+        Squeezing parameter.
-+
-+    Returns
-+    -------
-+    oper : :class:`qutip.Qobj`
-+        Squeezing operator.
-+
-+    """
-+    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
-+    return b.expm()
-+
-+
-+def displace(N, alpha, offset=0, *, dtype=None):
-+    """Single-mode displacement operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Dimension of Hilbert space.
-+
-+    alpha : float/complex
-+        Displacement amplitude.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the operator.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Displacement operator.
-+
-+    Examples
-+    --------
-+    >>> displace(4,0.25) # doctest: +SKIP
-+    Quantum object: dims = [[4], [4]], \
-+shape = [4, 4], type = oper, isHerm = False
-+    Qobj data =
-+    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
-+     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
-+     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
-+     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    a = destroy(N, offset=offset)
-+    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
-+
-+
-+def commutator(A, B, kind="normal"):
-+    """
-+    Return the commutator of kind `kind` (normal, anti) of the
-+    two operators A and B.
-+    """
-+    if kind == 'normal':
-+        return A @ B - B @ A
-+
-+    elif kind == 'anti':
-+        return A @ B + B @ A
-+
-+    else:
-+        raise TypeError("Unknown commutator kind '%s'" % kind)
-+
-+
-+def qutrit_ops(*, dtype=None):
-+    """
-+    Operators for a three level system (qutrit).
-+
-+    Parameters
-+    ----------
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    opers: array
-+        `array` of qutrit operators.
-+
-+    """
-+    from .states import qutrit_basis
-+
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    out = np.empty((6,), dtype=object)
-+    one, two, three = qutrit_basis(dtype=dtype)
-+    out[0] = one * one.dag()
-+    out[1] = two * two.dag()
-+    out[2] = three * three.dag()
-+    out[3] = one * two.dag()
-+    out[4] = two * three.dag()
-+    out[5] = three * one.dag()
-+    return out
-+
-+
-+def phase(N, phi0=0, *, dtype=None):
-+    """
-+    Single-mode Pegg-Barnett phase operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of basis states in Hilbert space.
-+
-+    phi0 : float
-+        Reference phase.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Phase operator with respect to reference phase.
-+
-+    Notes
-+    -----
-+    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
-+    n = np.arange(N)[:, np.newaxis]
-+    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
-+                       for kk in phim])
-+    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
-+    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
-+
-+
-+def enr_destroy(dims, excitations, *, dtype=None):
-+    """
-+    Generate annilation operators for modes in a excitation-number-restricted
-+    state space. For example, consider a system consisting of 4 modes, each
-+    with 5 states. The total hilbert space size is 5**4 = 625. If we are
-+    only interested in states that contain up to 2 excitations, we only need
-+    to include states such as
-+
-+        (0, 0, 0, 0)
-+        (0, 0, 0, 1)
-+        (0, 0, 0, 2)
-+        (0, 0, 1, 0)
-+        (0, 0, 1, 1)
-+        (0, 0, 2, 0)
-+        ...
-+
-+    This function creates annihilation operators for the 4 modes that act
-+    within this state space:
-+
-+        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
-+
-+    From this point onwards, the annihiltion operators a1, ..., a4 can be
-+    used to setup a Hamiltonian, collapse operators and expectation-value
-+    operators, etc., following the usual pattern.
-+
-+    Parameters
-+    ----------
-+    dims : list
-+        A list of the dimensions of each subsystem of a composite quantum
-+        system.
-+
-+    excitations : integer
-+        The maximum number of excitations that are to be included in the
-+        state space.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    a_ops : list of qobj
-+        A list of annihilation operators for each mode in the composite
-+        quantum system described by dims.
-+    """
-+    from .states import enr_state_dictionaries
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+
-+    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
-+
-+    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
-+             for _ in dims]
-+
-+    for n1, state1 in enumerate(idx2state):
-+        for idx, s in enumerate(state1):
-+            # if s > 0, the annihilation operator of mode idx has a non-zero
-+            # entry with one less excitation in mode idx in the final state
-+            if s > 0:
-+                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
-+                n2 = state2idx[state2]
-+                a_ops[idx][n2, n1] = np.sqrt(s)
-+
-+    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
-+
-+
-+def enr_identity(dims, excitations, *, dtype=None):
-+    """
-+    Generate the identity operator for the excitation-number restricted
-+    state space defined by the `dims` and `exciations` arguments. See the
-+    docstring for enr_fock for a more detailed description of these arguments.
-+
-+    Parameters
-+    ----------
-+    dims : list
-+        A list of the dimensions of each subsystem of a composite quantum
-+        system.
-+
-+    excitations : integer
-+        The maximum number of excitations that are to be included in the
-+        state space.
-+
-+    state : list of integers
-+        The state in the number basis representation.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    op : Qobj
-+        A Qobj instance that represent the identity operator in the
-+        exication-number-restricted state space defined by `dims` and
-+        `exciations`.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    from .states import enr_state_dictionaries
-+    nstates, _, _ = enr_state_dictionaries(dims, excitations)
-+    return Qobj(_data.identity[dtype](nstates),
-+                dims=[dims, dims],
-+                type='oper',
-+                isherm=True,
-+                isunitary=True,
-+                copy=False)
-+
-+
-+def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
-+    """
-+    Generate the diagonal charge operator over charge states
-+    from Nmin to Nmax.
-+
-+    Parameters
-+    ----------
-+    Nmax : int
-+        Maximum charge state to consider.
-+
-+    Nmin : int (default = -Nmax)
-+        Lowest charge state to consider.
-+
-+    frac : float (default = 1)
-+        Specify fractional charge if needed.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    C : Qobj
-+        Charge operator over [Nmin, Nmax].
-+
-+    Notes
-+    -----
-+    .. versionadded:: 3.2
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    if Nmin is None:
-+        Nmin = -Nmax
-+    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
-+    out = qdiags(diag, 0, dtype=dtype)
-+    out.isherm = True
-+    return out
-+
-+
-+def tunneling(N, m=1, *, dtype=None):
-+    r"""
-+    Tunneling operator with elements of the form
-+    :math:`\\sum |N><N+m| + |N+m><N|`.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of basis states in Hilbert space.
-+
-+    m : int (default = 1)
-+        Number of excitations in tunneling event.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    T : Qobj
-+        Tunneling operator.
-+
-+    Notes
-+    -----
-+    .. versionadded:: 3.2
-+
-+    """
-+    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
-+    T = qdiags(diags, [m, -m], dtype=dtype)
-+    T.isherm = True
-+    return T
-+
-+
-+def qft(dimensions, *, dtype="dense"):
-+    """
-+    Quantum Fourier Transform operator.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.
-+
-+    dtype : str or type, [keyword only] [optional]
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    QFT: qobj
-+        Quantum Fourier transform operator.
-+
-+    """
-+    N2, dimensions = _implicit_tensor_dimensions(dimensions)
-+
-+    phase = 2.0j * np.pi / N2
-+    arr = np.arange(N2)
-+    L, M = np.meshgrid(arr, arr)
-+    data = np.exp(phase * (L * M)) / np.sqrt(N2)
-+    return Qobj(data, dims=dimensions).to(dtype)
-diff --git a/qutip/core/options.py b/qutip/core/options.py
-index 1724c818..daa3db0b 100644
---- a/qutip/core/options.py
-+++ b/qutip/core/options.py
-@@ -1,123 +1,123 @@
--from ..settings import settings
--
--__all__ = ["CoreOptions"]
--
--
--class QutipOptions:
--    """
--    Class for basic functionality for qutip's options.
--
--    Define basic method to wrap an ``options`` dict.
--    Default options are in a class _options dict.
--    """
--    _options = {}
--    _settings_name = None  # Where the default is in settings
--
--    def __init__(self, **options):
--        self.options = self._options.copy()
--        for key in set(options) & set(self.options):
--            self[key] = options.pop(key)
--        if options:
--            raise KeyError(f"Options {set(options)} are not supported.")
--
--    def __contains__(self, key):
--        return key in self.options
--
--    def __getitem__(self, key):
--        # Let the dict catch the KeyError
--        return self.options[key]
--
--    def __setitem__(self, key, value):
--        # Let the dict catch the KeyError
--        self.options[key] = value
--
--    def __repr__(self, full=True):
--        out = [f"<{self.__class__.__name__}("]
--        for key, value in self.options.items():
--            if full or value != self._options[key]:
--                out += [f"    '{key}': {repr(value)},"]
--        out += [")>"]
--        if len(out)-2:
--            return "\n".join(out)
--        else:
--            return "".join(out)
--
--    def __enter__(self):
--        self._backup = getattr(settings, self._settings_name)
--        setattr(settings, self._settings_name, self)
--
--    def __exit__(self, exc_type, exc_value, exc_traceback):
--        setattr(settings, self._settings_name, self._backup)
--
--
--class CoreOptions(QutipOptions):
--    """
--    Options used by the core of qutip such as the tolerance of :class:`Qobj`
--    comparison or coefficient's format.
--
--    Values can be changed in ``qutip.settings.core`` or by using context:
--    ``with CoreOptions(atol=1e-6): ...``.
--
--    Options
--    -------
--    auto_tidyup : bool
--        Whether to tidyup during sparse operations.
--
--    auto_tidyup_dims : bool [True]
--        Use auto tidyup dims on multiplication. (Not used yet)
--
--    atol : float {1e-12}
--        General absolute tolerance
--
--    rtol : float {1e-12}
--        General relative tolerance
--        Used to choose QobjEvo.expect output type
--
--    auto_tidyup_atol : float {1e-14}
--        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
--        parameter above) and the default value of ``atol`` used in
--        :method:`Qobj.tidyup`.
--
--    function_coefficient_style : str {"auto"}
--        The signature expected by function coefficients. The options are:
--
--        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
--          is the time and the ``...`` are the remaining arguments passed
--          directly into the function. E.g. ``f(t, w, b=5)``.
--
--        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
--          the time and ``args`` is a dict containing the remaining arguments.
--          E.g. ``f(t, {"w": w, "b": 5})``.
--
--        - "auto": select automatically between the two options above based
--          on the signature of the supplied function. If the function signature
--          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
--          ``pythonic`` is used.
--
--    default_dtype : Nonetype, str, type {None}
--        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
--        :func:"rand_herm", will use the specified data type. Any data-layer
--        known to ``qutip.data.to`` is accepted. When ``None``, these functions
--        will default to a sensible data type.
--    """
--    _options = {
--        # use auto tidyup
--        "auto_tidyup": True,
--        # use auto tidyup dims on multiplication
--        "auto_tidyup_dims": True,
--        # general absolute tolerance
--        "atol": 1e-12,
--        # general relative tolerance
--        "rtol": 1e-12,
--        # use auto tidyup absolute tolerance
--        "auto_tidyup_atol": 1e-14,
--        # signature style expected by function coefficients
--        "function_coefficient_style": "auto",
--        # Default Qobj dtype for Qobj create function
--        "default_dtype": None,
--    }
--    _settings_name = "core"
--
--
--# Creating the instance of core options to use everywhere.
--settings.core = CoreOptions()
-+from ..settings import settings
-+
-+__all__ = ["CoreOptions"]
-+
-+
-+class QutipOptions:
-+    """
-+    Class for basic functionality for qutip's options.
-+
-+    Define basic method to wrap an ``options`` dict.
-+    Default options are in a class _options dict.
-+    """
-+    _options = {}
-+    _settings_name = None  # Where the default is in settings
-+
-+    def __init__(self, **options):
-+        self.options = self._options.copy()
-+        for key in set(options) & set(self.options):
-+            self[key] = options.pop(key)
-+        if options:
-+            raise KeyError(f"Options {set(options)} are not supported.")
-+
-+    def __contains__(self, key):
-+        return key in self.options
-+
-+    def __getitem__(self, key):
-+        # Let the dict catch the KeyError
-+        return self.options[key]
-+
-+    def __setitem__(self, key, value):
-+        # Let the dict catch the KeyError
-+        self.options[key] = value
-+
-+    def __repr__(self, full=True):
-+        out = [f"<{self.__class__.__name__}("]
-+        for key, value in self.options.items():
-+            if full or value != self._options[key]:
-+                out += [f"    '{key}': {repr(value)},"]
-+        out += [")>"]
-+        if len(out)-2:
-+            return "\n".join(out)
-+        else:
-+            return "".join(out)
-+
-+    def __enter__(self):
-+        self._backup = getattr(settings, self._settings_name)
-+        setattr(settings, self._settings_name, self)
-+
-+    def __exit__(self, exc_type, exc_value, exc_traceback):
-+        setattr(settings, self._settings_name, self._backup)
-+
-+
-+class CoreOptions(QutipOptions):
-+    """
-+    Options used by the core of qutip such as the tolerance of :class:`Qobj`
-+    comparison or coefficient's format.
-+
-+    Values can be changed in ``qutip.settings.core`` or by using context:
-+    ``with CoreOptions(atol=1e-6): ...``.
-+
-+    Options
-+    -------
-+    auto_tidyup : bool
-+        Whether to tidyup during sparse operations.
-+
-+    auto_tidyup_dims : bool [True]
-+        Use auto tidyup dims on multiplication. (Not used yet)
-+
-+    atol : float {1e-12}
-+        General absolute tolerance
-+
-+    rtol : float {1e-12}
-+        General relative tolerance
-+        Used to choose QobjEvo.expect output type
-+
-+    auto_tidyup_atol : float {1e-14}
-+        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
-+        parameter above) and the default value of ``atol`` used in
-+        :method:`Qobj.tidyup`.
-+
-+    function_coefficient_style : str {"auto"}
-+        The signature expected by function coefficients. The options are:
-+
-+        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
-+          is the time and the ``...`` are the remaining arguments passed
-+          directly into the function. E.g. ``f(t, w, b=5)``.
-+
-+        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
-+          the time and ``args`` is a dict containing the remaining arguments.
-+          E.g. ``f(t, {"w": w, "b": 5})``.
-+
-+        - "auto": select automatically between the two options above based
-+          on the signature of the supplied function. If the function signature
-+          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
-+          ``pythonic`` is used.
-+
-+    default_dtype : Nonetype, str, type {None}
-+        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
-+        :func:"rand_herm", will use the specified data type. Any data-layer
-+        known to ``qutip.data.to`` is accepted. When ``None``, these functions
-+        will default to a sensible data type.
-+    """
-+    _options = {
-+        # use auto tidyup
-+        "auto_tidyup": True,
-+        # use auto tidyup dims on multiplication
-+        "auto_tidyup_dims": True,
-+        # general absolute tolerance
-+        "atol": 1e-12,
-+        # general relative tolerance
-+        "rtol": 1e-12,
-+        # use auto tidyup absolute tolerance
-+        "auto_tidyup_atol": 1e-14,
-+        # signature style expected by function coefficients
-+        "function_coefficient_style": "auto",
-+        # Default Qobj dtype for Qobj create function
-+        "default_dtype": None,
-+    }
-+    _settings_name = "core"
-+
-+
-+# Creating the instance of core options to use everywhere.
-+settings.core = CoreOptions()
-diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
-index 83a778b0..b6128d55 100644
---- a/qutip/core/qobj.py
-+++ b/qutip/core/qobj.py
-@@ -1,1811 +1,1811 @@
--"""The Quantum Object (Qobj) class, for representing quantum states and
--operators, and related functions.
--"""
--
--__all__ = [
--    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
--    'isherm', 'ptrace',
--]
--
--import functools
--import numbers
--import warnings
--
--import numpy as np
--import scipy.sparse
--
--from .. import __version__
--from ..settings import settings
--from . import data as _data
--from .dimensions import (
--    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
--)
--
--
--_ADJOINT_TYPE_LOOKUP = {
--    'oper': 'oper',
--    'super': 'super',
--    'ket': 'bra',
--    'bra': 'ket',
--    'operator-ket': 'operator-bra',
--    'operator-bra': 'operator-ket',
--}
--
--_MATMUL_TYPE_LOOKUP = {
--    ('oper', 'ket'): 'ket',
--    ('oper', 'oper'): 'oper',
--    ('ket', 'bra'): 'oper',
--    ('bra', 'oper'): 'bra',
--    ('super', 'super'): 'super',
--    ('super', 'operator-ket'): 'operator-ket',
--    ('operator-bra', 'super'): 'operator-bra',
--    ('operator-ket', 'operator-bra'): 'super',
--}
--
--_NORM_FUNCTION_LOOKUP = {
--    'tr': _data.norm.trace,
--    'one': _data.norm.one,
--    'max': _data.norm.max,
--    'fro': _data.norm.frobenius,
--    'l2': _data.norm.l2,
--}
--_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
--_NORM_ALLOWED_VECTOR = {'l2', 'max'}
--
--_CALL_ALLOWED = {
--    ('super', 'oper'),
--    ('super', 'ket'),
--    ('oper', 'ket'),
--}
--
--
--def isbra(x):
--    return isinstance(x, Qobj) and x.type == 'bra'
--
--
--def isket(x):
--    return isinstance(x, Qobj) and x.type == 'ket'
--
--
--def isoper(x):
--    return isinstance(x, Qobj) and x.type == 'oper'
--
--
--def isoperbra(x):
--    return isinstance(x, Qobj) and x.type == 'operator-bra'
--
--
--def isoperket(x):
--    return isinstance(x, Qobj) and x.type == 'operator-ket'
--
--
--def issuper(x):
--    return isinstance(x, Qobj) and x.type == 'super'
--
--
--def isherm(x):
--    return isinstance(x, Qobj) and x.isherm
--
--
--def _require_equal_type(method):
--    """
--    Decorate a binary Qobj method to ensure both operands are Qobj and of the
--    same type and dimensions.  Promote numeric scalar to identity matrices of
--    the same type and shape.
--    """
--    @functools.wraps(method)
--    def out(self, other):
--        if other == 0:
--            return method(self, other)
--        if (
--            self.type in ('oper', 'super')
--            and self.dims[0] == self.dims[1]
--            and isinstance(other, numbers.Number)
--        ):
--            scale = complex(other)
--            other = Qobj(_data.identity(self.shape[0], scale,
--                                        dtype=type(self.data)),
--                         dims=self.dims,
--                         type=self.type,
--                         superrep=self.superrep,
--                         isherm=(scale.imag == 0),
--                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
--                         copy=False)
--        if not isinstance(other, Qobj):
--            try:
--                other = Qobj(other, type=self.type)
--            except TypeError:
--                return NotImplemented
--        if self.dims != other.dims:
--            msg = (
--                "incompatible dimensions "
--                + repr(self.dims) + " and " + repr(other.dims)
--            )
--            raise ValueError(msg)
--        if self.type != other.type:
--            msg = "incompatible types " + self.type + " and " + other.type
--            raise ValueError(msg)
--        if self.superrep != other.superrep:
--            msg = (
--                "incompatible superoperator representations"
--                + self.superrep + " and " + other.superrep
--            )
--            raise ValueError(msg)
--        return method(self, other)
--    return out
--
--
--def _latex_real(x):
--    if not x:
--        return "0"
--    if not 0.001 <= abs(x) < 1000:
--        base, exp = "{:.3e}".format(x).split('e')
--        return base + r"\times10^{{ {:d} }}".format(int(exp))
--    if abs(x - int(x)) < 0.001:
--        return "{:d}".format(round(x))
--    return "{:.3f}".format(x)
--
--
--def _latex_complex(x):
--    if abs(x.imag) < 0.001:
--        return _latex_real(x.real)
--    if abs(x.real) < 0.001:
--        return _latex_real(x.imag) + "j"
--    sign = "+" if x.imag > 0 else "-"
--    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
--
--
--def _latex_row(row, cols, data):
--    if row is None:
--        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
--    else:
--        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
--                for col in cols)
--    return " & ".join(bits)
--
--
--class Qobj:
--    """
--    A class for representing quantum objects, such as quantum operators and
--    states.
--
--    The Qobj class is the QuTiP representation of quantum operators and state
--    vectors. This class also implements math operations +,-,* between Qobj
--    instances (and / by a C-number), as well as a collection of common
--    operator/state operations.  The Qobj constructor optionally takes a
--    dimension ``list`` and/or shape ``list`` as arguments.
--
--    Parameters
--    ----------
--    inpt: array_like
--        Data for vector/matrix representation of the quantum object.
--    dims: list
--        Dimensions of object used for tensor products.
--    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
--        The type of quantum object to be represented.
--    shape: list
--        Shape of underlying data structure (matrix shape).
--    copy: bool
--        Flag specifying whether Qobj should get a copy of the
--        input data, or use the original.
--
--
--    Attributes
--    ----------
--    data : array_like
--        Sparse matrix characterizing the quantum object.
--    dims : list
--        List of dimensions keeping track of the tensor structure.
--    shape : list
--        Shape of the underlying `data` array.
--    type : str
--        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
--        'operator-bra', or 'super'.
--    superrep : str
--        Representation used if `type` is 'super'. One of 'super'
--        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
--    isherm : bool
--        Indicates if quantum object represents Hermitian operator.
--    isunitary : bool
--        Indictaes if quantum object represents unitary operator.
--    iscp : bool
--        Indicates if the quantum object represents a map, and if that map is
--        completely positive (CP).
--    ishp : bool
--        Indicates if the quantum object represents a map, and if that map is
--        hermicity preserving (HP).
--    istp : bool
--        Indicates if the quantum object represents a map, and if that map is
--        trace preserving (TP).
--    iscptp : bool
--        Indicates if the quantum object represents a map that is completely
--        positive and trace preserving (CPTP).
--    isket : bool
--        Indicates if the quantum object represents a ket.
--    isbra : bool
--        Indicates if the quantum object represents a bra.
--    isoper : bool
--        Indicates if the quantum object represents an operator.
--    issuper : bool
--        Indicates if the quantum object represents a superoperator.
--    isoperket : bool
--        Indicates if the quantum object represents an operator in column vector
--        form.
--    isoperbra : bool
--        Indicates if the quantum object represents an operator in row vector
--        form.
--
--    Methods
--    -------
--    copy()
--        Create copy of Qobj
--    conj()
--        Conjugate of quantum object.
--    cosm()
--        Cosine of quantum object.
--    dag()
--        Adjoint (dagger) of quantum object.
--    dnorm()
--        Diamond norm of quantum operator.
--    dual_chan()
--        Dual channel of quantum object representing a CP map.
--    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
--        Returns eigenenergies (eigenvalues) of a quantum object.
--    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
--        Returns eigenenergies and eigenstates of quantum object.
--    expm()
--        Matrix exponential of quantum object.
--    full(order='C')
--        Returns dense array of quantum object `data` attribute.
--    groundstate(sparse=False, tol=0, maxiter=100000)
--        Returns eigenvalue and eigenket for the groundstate of a quantum
--        object.
--    inv()
--        Return a Qobj corresponding to the matrix inverse of the operator.
--    matrix_element(bra, ket)
--        Returns the matrix element of operator between `bra` and `ket` vectors.
--    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
--        Returns norm of a ket or an operator.
--    permute(order)
--        Returns composite qobj with indices reordered.
--    proj()
--        Computes the projector for a ket or bra vector.
--    ptrace(sel)
--        Returns quantum object for selected dimensions after performing
--        partial trace.
--    sinm()
--        Sine of quantum object.
--    sqrtm()
--        Matrix square root of quantum object.
--    tidyup(atol=1e-12)
--        Removes small elements from quantum object.
--    tr()
--        Trace of quantum object.
--    trans()
--        Transpose of quantum object.
--    transform(inpt, inverse=False)
--        Performs a basis transformation defined by `inpt` matrix.
--    trunc_neg(method='clip')
--        Removes negative eigenvalues and returns a new Qobj that is
--        a valid density operator.
--    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
--        Returns normalized quantum object.
--
--    """
--    # Disable ufuncs from acting directly on Qobj.
--    __array_ufunc__ = None
--
--    def _initialize_data(self, arg, dims, copy):
--        if isinstance(arg, _data.Data):
--            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
--            self._data = arg.copy() if copy else arg
--        elif isinstance(arg, Qobj):
--            self.dims = dims or arg.dims.copy()
--            self._data = arg.data.copy() if copy else arg.data
--        elif arg is None or isinstance(arg, numbers.Number):
--            self.dims = dims or [[1], [1]]
--            size = np.prod(self.dims[0])
--            if arg is None:
--                self._data = _data.zeros(size, size)
--            else:
--                self._data = _data.identity(size, scale=complex(arg))
--        else:
--            self._data = _data.create(arg, copy=copy)
--            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
--
--    def __init__(self, arg=None, dims=None, type=None,
--                 copy=True, superrep=None, isherm=None, isunitary=None):
--        self._initialize_data(arg, dims, copy)
--        self.type = type or type_from_dims(self.dims)
--        self._isherm = isherm
--        self._isunitary = isunitary
--
--        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
--            if self._data.shape[0] != self._data.shape[1]:
--                raise ValueError("".join([
--                    "cannot build superoperator from nonsquare data of shape ",
--                    repr(self._data.shape),
--                ]))
--            root = int(np.sqrt(self._data.shape[0]))
--            if root * root != self._data.shape[0]:
--                raise ValueError("".join([
--                    "cannot build superoperator from nonsquare subspaces ",
--                    "of size ",
--                    repr(self._data.shape[0]),
--                ]))
--            self.dims = [[[root]]*2]*2
--        if self.type in ['super', 'operator-ket', 'operator-bra']:
--            superrep = superrep or 'super'
--        self.superrep = superrep
--
--    def copy(self):
--        """Create identical copy"""
--        return Qobj(arg=self._data,
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=True)
--
--    @property
--    def data(self):
--        return self._data
--
--    @data.setter
--    def data(self, data):
--        if not isinstance(data, _data.Data):
--            raise TypeError('Qobj data must be a data-layer format.')
--        self._data = data
--
--    def to(self, data_type):
--        """
--        Convert the underlying data store of this `Qobj` into a different
--        storage representation.
--
--        The different storage representations available are the "data-layer
--        types" which are known to `qutip.data.to`.  By default, these are
--        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
--        dense matrix store and a compressed sparse row one.  Certain algorithms
--        and operations may be faster or more accurate when using a more
--        appropriate data store.
--
--        If the data store is already in the format requested, the function
--        returns `self`.  Otherwise, it returns a copy of itself with the data
--        store in the new type.
--
--        Parameters
--        ----------
--        data_type : type
--            The data-layer type that the data of this `Qobj` should be
--            converted to.
--
--        Returns
--        -------
--        Qobj
--            A new `Qobj` if a type conversion took place with the data stored
--            in the requested format, or `self` if not.
--        """
--        try:
--            converter = _data.to[data_type]
--        except (KeyError, TypeError):
--            raise ValueError("Unknown conversion type: " + str(data_type))
--        if type(self.data) is data_type:
--            return self
--        return Qobj(converter(self._data),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=False)
--
--    @_require_equal_type
--    def __add__(self, other):
--        if other == 0:
--            return self.copy()
--        isherm = (self._isherm and other._isherm) or None
--        return Qobj(_data.add(self._data, other._data),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=isherm,
--                    copy=False)
--
--    def __radd__(self, other):
--        return self.__add__(other)
--
--    @_require_equal_type
--    def __sub__(self, other):
--        if other == 0:
--            return self.copy()
--        isherm = (self._isherm and other._isherm) or None
--        return Qobj(_data.sub(self._data, other._data),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=isherm,
--                    copy=False)
--
--    def __rsub__(self, other):
--        return self.__neg__().__add__(other)
--
--    def __mul__(self, other):
--        """
--        If other is a Qobj, we dispatch to __matmul__. If not, we
--        check that other is a valid complex scalar, i.e., we can do
--        complex(other). Otherwise, we return NotImplemented.
--        """
--
--        if isinstance(other, Qobj):
--            return self.__matmul__(other)
--
--        # We send other to mul instead of complex(other) to be more flexible.
--        # The dispatcher can then decide how to handle other and return
--        # TypeError if it does not know what to do with the type of other.
--        try:
--            out = _data.mul(self._data, other)
--        except TypeError:
--            return NotImplemented
--
--        # Infer isherm and isunitary if possible
--        try:
--            multiplier = complex(other)
--            isherm = (self._isherm and multiplier.imag == 0) or None
--            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
--                         if self._isunitary else None)
--        except TypeError:
--            isherm = None
--            isunitary = None
--
--        return Qobj(out,
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=isherm,
--                    isunitary=isunitary,
--                    copy=False)
--
--    def __rmul__(self, other):
--        # Shouldn't be here unless `other.__mul__` has already been tried, so
--        # we _shouldn't_ check that `other` is `Qobj`.
--        return self.__mul__(other)
--
--    def __matmul__(self, other):
--        if not isinstance(other, Qobj):
--            try:
--                other = Qobj(other)
--            except TypeError:
--                return NotImplemented
--        if self.dims[1] != other.dims[0]:
--            raise TypeError("".join([
--                "incompatible dimensions ",
--                repr(self.dims),
--                " and ",
--                repr(other.dims),
--            ]))
--        if self.superrep != other.superrep:
--            raise TypeError("".join([
--                "incompatible superoperator representations ",
--                repr(self.superrep),
--                " and ",
--                repr(other.superrep),
--            ]))
--        if (
--            (self.isbra and other.isket)
--            or (self.isoperbra and other.isoperket)
--        ):
--            return _data.inner(self.data, other.data)
--
--        try:
--            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
--        except KeyError:
--            raise TypeError(
--                "incompatible matmul types "
--                + repr(self.type) + " and " + repr(other.type)
--            ) from None
--        return Qobj(_data.matmul(self.data, other.data),
--                    dims=[self.dims[0], other.dims[1]],
--                    type=type_,
--                    isunitary=self._isunitary and other._isunitary,
--                    superrep=self.superrep,
--                    copy=False)
--
--    def __truediv__(self, other):
--        return self.__mul__(1 / other)
--
--    def __neg__(self):
--        return Qobj(_data.neg(self._data),
--                    dims=self.dims.copy(),
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=False)
--
--    def __getitem__(self, ind):
--        # TODO: should we require that data-layer types implement this?  This
--        # isn't the right way of handling it, for sure.
--        if isinstance(self._data, _data.CSR):
--            data = self._data.as_scipy()
--        elif isinstance(self._data, _data.Dense):
--            data = self._data.as_ndarray()
--        else:
--            data = self._data
--        try:
--            out = data[ind]
--            return out.toarray() if scipy.sparse.issparse(out) else out
--        except TypeError:
--            pass
--        return data.to_array()[ind]
--
--    def __eq__(self, other):
--        if self is other:
--            return True
--        if not isinstance(other, Qobj) or self.dims != other.dims:
--            return False
--        return _data.iszero(_data.sub(self._data, other._data),
--                            tol=settings.core['atol'])
--
--    def __pow__(self, n, m=None):  # calculates powers of Qobj
--        if (
--            self.type not in ('oper', 'super')
--            or self.dims[0] != self.dims[1]
--            or m is not None
--            or not isinstance(n, numbers.Integral)
--            or n < 0
--        ):
--            return NotImplemented
--        return Qobj(_data.pow(self._data, n),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=False)
--
--    def _str_header(self):
--        out = ", ".join([
--            "Quantum object: dims=" + str(self.dims),
--            "shape=" + str(self.data.shape),
--            "type=" + repr(self.type),
--        ])
--        if self.type in ('oper', 'super'):
--            out += ", isherm=" + str(self.isherm)
--        if self.issuper and self.superrep != 'super':
--            out += ", superrep=" + repr(self.superrep)
--        return out
--
--    def __str__(self):
--        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
--            # If the system is huge, don't attempt to convert to a dense matrix
--            # and then to string, because it is pointless and is likely going
--            # to produce memory errors. Instead print the sparse data string
--            # representation.
--            data = _data.to(_data.CSR, self.data).as_scipy()
--        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
--            data = np.real(self.full())
--        else:
--            data = self.full()
--        return self._str_header() + "\nQobj data =\n" + str(data)
--
--    def __repr__(self):
--        # give complete information on Qobj without print statement in
--        # command-line we cant realistically serialize a Qobj into a string,
--        # so we simply return the informal __str__ representation instead.)
--        return self.__str__()
--
--    def __call__(self, other):
--        """
--        Acts this Qobj on another Qobj either by left-multiplication,
--        or by vectorization and devectorization, as
--        appropriate.
--        """
--        if not isinstance(other, Qobj):
--            raise TypeError("Only defined for quantum objects.")
--        if (self.type, other.type) not in _CALL_ALLOWED:
--            raise TypeError(self.type + " cannot act on " + other.type)
--        if self.issuper:
--            if other.isket:
--                other = other.proj()
--            return vector_to_operator(self @ operator_to_vector(other))
--        return self.__matmul__(other)
--
--    def __getstate__(self):
--        # defines what happens when Qobj object gets pickled
--        self.__dict__.update({'qutip_version': __version__[:5]})
--        return self.__dict__
--
--    def __setstate__(self, state):
--        # defines what happens when loading a pickled Qobj
--        if 'qutip_version' in state.keys():
--            del state['qutip_version']
--        (self.__dict__).update(state)
--
--    def _repr_latex_(self):
--        """
--        Generate a LaTeX representation of the Qobj instance. Can be used for
--        formatted output in ipython notebook.
--        """
--        half_length = 5
--        n_rows, n_cols = self.data.shape
--        # Choose which rows and columns we're going to output, or None if that
--        # element should be truncated.
--        rows = list(range(min((half_length, n_rows))))
--        if n_rows <= half_length * 2:
--            rows += list(range(half_length, min((2*half_length, n_rows))))
--        else:
--            rows.append(None)
--            rows += list(range(n_rows - half_length, n_rows))
--        cols = list(range(min((half_length, n_cols))))
--        if n_cols <= half_length * 2:
--            cols += list(range(half_length, min((2*half_length, n_cols))))
--        else:
--            cols.append(None)
--            cols += list(range(n_cols - half_length, n_cols))
--        # Make the data array.
--        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
--        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
--                           for row in rows)
--        data += r'\end{array}\right)\end{equation*}'
--        return self._str_header() + data
--
--    def __and__(self, other):
--        """
--        Syntax shortcut for tensor:
--        A & B ==> tensor(A, B)
--        """
--        return tensor(self, other)
--
--    def dag(self):
--        """Get the Hermitian adjoint of the quantum object."""
--        if self._isherm:
--            return self.copy()
--        return Qobj(_data.adjoint(self._data),
--                    dims=[self.dims[1], self.dims[0]],
--                    type=_ADJOINT_TYPE_LOOKUP[self.type],
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=False)
--
--    def conj(self):
--        """Get the element-wise conjugation of the quantum object."""
--        return Qobj(_data.conj(self._data),
--                    dims=self.dims.copy(),
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=False)
--
--    def trans(self):
--        """Get the matrix transpose of the quantum operator.
--
--        Returns
--        -------
--        oper : :class:`.Qobj`
--            Transpose of input operator.
--        """
--        return Qobj(_data.transpose(self._data),
--                    dims=[self.dims[1], self.dims[0]],
--                    type=_ADJOINT_TYPE_LOOKUP[self.type],
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    isunitary=self._isunitary,
--                    copy=False)
--
--    def dual_chan(self):
--        """Dual channel of quantum object representing a completely positive
--        map.
--        """
--        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
--        # is only valid for completely positive maps.
--        if not self.iscp:
--            raise ValueError("Dual channels are only implemented for CP maps.")
--        J = to_choi(self)
--        tensor_idxs = enumerate_flat(J.dims)
--        J_dual = tensor_swap(J, *(
--                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
--                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
--        )).trans()
--        J_dual.superrep = 'choi'
--        return J_dual
--
--    def norm(self, norm=None, kwargs=None):
--        """
--        Norm of a quantum object.
--
--        Default norm is L2-norm for kets and trace-norm for operators.  Other
--        ket and operator norms may be specified using the `norm` parameter.
--
--        Parameters
--        ----------
--        norm : str
--            Which type of norm to use.  Allowed values for vectors are 'l2' and
--            'max'.  Allowed values for matrices are 'tr' for the trace norm,
--            'fro' for the Frobenius norm, 'one' and 'max'.
--
--        kwargs : dict
--            Additional keyword arguments to pass on to the relevant norm
--            solver.  See details for each norm function in :mod:`.data.norm`.
--
--        Returns
--        -------
--        norm : float
--            The requested norm of the operator or state quantum object.
--        """
--        if self.type in ('oper', 'super'):
--            norm = norm or 'tr'
--            if norm not in _NORM_ALLOWED_MATRIX:
--                raise ValueError(
--                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
--                )
--        else:
--            norm = norm or 'l2'
--            if norm not in _NORM_ALLOWED_VECTOR:
--                raise ValueError(
--                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
--                )
--        kwargs = kwargs or {}
--        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
--
--    def proj(self):
--        """Form the projector from a given ket or bra vector.
--
--        Parameters
--        ----------
--        Q : :class:`qutip.Qobj`
--            Input bra or ket vector
--
--        Returns
--        -------
--        P : :class:`qutip.Qobj`
--            Projection operator.
--        """
--        if not (self.isket or self.isbra):
--            raise TypeError("projection is only defined for bras and kets")
--        dims = ([self.dims[0], self.dims[0]] if self.isket
--                else [self.dims[1], self.dims[1]])
--        return Qobj(_data.project(self._data),
--                    dims=dims,
--                    type='oper',
--                    isherm=True,
--                    copy=False)
--
--    def tr(self):
--        """Trace of a quantum object.
--
--        Returns
--        -------
--        trace : float
--            Returns the trace of the quantum object.
--
--        """
--        out = _data.trace(self._data)
--        # This ensures that trace can return something that is not a number such
--        # as a `tensorflow.Tensor` in qutip-tensorflow.
--        return out.real if (self.isherm
--                        and hasattr(out, "real")
--                        ) else out
--
--    def purity(self):
--        """Calculate purity of a quantum object.
--
--        Returns
--        -------
--        state_purity : float
--            Returns the purity of a quantum object.
--            For a pure state, the purity is 1.
--            For a mixed state of dimension `d`, 1/d<=purity<1.
--
--        """
--        if self.type in ("super", "operator-ket", "operator-bra"):
--            raise TypeError('purity is only defined for states.')
--        if self.isket or self.isbra:
--            return _data.norm.l2(self.data)**2
--        return _data.trace(_data.matmul(self.data, self.data)).real
--
--    def full(self, order='C', squeeze=False):
--        """Dense array from quantum object.
--
--        Parameters
--        ----------
--        order : str {'C', 'F'}
--            Return array in C (default) or Fortran ordering.
--        squeeze : bool {False, True}
--            Squeeze output array.
--
--        Returns
--        -------
--        data : array
--            Array of complex data from quantum objects `data` attribute.
--        """
--        out = np.asarray(self.data.to_array(), order=order)
--        return out.squeeze() if squeeze else out
--
--    def diag(self):
--        """Diagonal elements of quantum object.
--
--        Returns
--        -------
--        diags : array
--            Returns array of ``real`` values if operators is Hermitian,
--            otherwise ``complex`` values are returned.
--        """
--        # TODO: add a `diagonal` method to the data layer?
--        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
--        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
--            return out
--        else:
--            return np.real(out)
--
--    def expm(self, dtype=_data.Dense):
--        """Matrix exponential of quantum operator.
--
--        Input operator must be square.
--
--        Parameters
--        ----------
--        dtype : type
--            The data-layer type that should be output.  As the matrix
--            exponential is almost dense, this defaults to outputting dense
--            matrices.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Exponentiated quantum operator.
--
--        Raises
--        ------
--        TypeError
--            Quantum operator is not square.
--        """
--        if self.dims[0] != self.dims[1]:
--            raise TypeError("expm is only valid for square operators")
--        return Qobj(_data.expm(self._data, dtype=dtype),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    copy=False)
--
--    def logm(self):
--        """Matrix logarithm of quantum operator.
--
--        Input operator must be square.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Logarithm of the quantum operator.
--
--        Raises
--        ------
--        TypeError
--            Quantum operator is not square.
--        """
--        if self.dims[0] != self.dims[1]:
--            raise TypeError("expm is only valid for square operators")
--        return Qobj(_data.logm(self._data),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    isherm=self._isherm,
--                    copy=False)
--
--    def check_herm(self):
--        """Check if the quantum object is hermitian.
--
--        Returns
--        -------
--        isherm : bool
--            Returns the new value of isherm property.
--        """
--        self._isherm = None
--        return self.isherm
--
--    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
--        """
--        Sqrt of a quantum operator.  Operator must be square.
--
--        Parameters
--        ----------
--        sparse : bool
--            Use sparse eigenvalue/vector solver.
--        tol : float
--            Tolerance used by sparse solver (0 = machine precision).
--        maxiter : int
--            Maximum number of iterations used by sparse solver.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Matrix square root of operator.
--
--        Raises
--        ------
--        TypeError
--            Quantum object is not square.
--
--        Notes
--        -----
--        The sparse eigensolver is much slower than the dense version.
--        Use sparse only if memory requirements demand it.
--        """
--        if self.dims[0] != self.dims[1]:
--            raise TypeError('sqrt only valid on square matrices')
--        if isinstance(self.data, _data.CSR) and sparse:
--            evals, evecs = _data.eigs_csr(self.data,
--                                          isherm=self._isherm,
--                                          tol=tol, maxiter=maxiter)
--        elif isinstance(self.data, _data.CSR):
--            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
--                                      isherm=self._isherm)
--        else:
--            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
--
--        numevals = len(evals)
--        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
--        if self.isherm:
--            spDv = _data.matmul(dV, evecs.conj().transpose())
--        else:
--            spDv = _data.matmul(dV, _data.inv(evecs))
--        return Qobj(_data.matmul(evecs, spDv),
--                    dims=self.dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    copy=False)
--
--    def cosm(self):
--        """Cosine of a quantum operator.
--
--        Operator must be square.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Matrix cosine of operator.
--
--        Raises
--        ------
--        TypeError
--            Quantum object is not square.
--
--        Notes
--        -----
--        Uses the Q.expm() method.
--
--        """
--        if self.dims[0] != self.dims[1]:
--            raise TypeError('invalid operand for matrix cosine')
--        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
--
--    def sinm(self):
--        """Sine of a quantum operator.
--
--        Operator must be square.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Matrix sine of operator.
--
--        Raises
--        ------
--        TypeError
--            Quantum object is not square.
--
--        Notes
--        -----
--        Uses the Q.expm() method.
--        """
--        if self.dims[0] != self.dims[1]:
--            raise TypeError('invalid operand for matrix sine')
--        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
--
--    def inv(self, sparse=False):
--        """Matrix inverse of a quantum operator
--
--        Operator must be square.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Matrix inverse of operator.
--
--        Raises
--        ------
--        TypeError
--            Quantum object is not square.
--        """
--        if self.data.shape[0] != self.data.shape[1]:
--            raise TypeError('Invalid operand for matrix inverse')
--        if isinstance(self.data, _data.CSR) and not sparse:
--            data = _data.to(_data.Dense, self.data)
--        else:
--            data = self.data
--
--        return Qobj(_data.inv(data),
--                    dims=[self.dims[1], self.dims[0]],
--                    type=self.type,
--                    superrep=self.superrep,
--                    copy=False)
--
--    def unit(self, inplace=False, norm=None, kwargs=None):
--        """
--        Operator or state normalized to unity.  Uses norm from Qobj.norm().
--
--        Parameters
--        ----------
--        inplace : bool
--            Do an in-place normalization
--        norm : str
--            Requested norm for states / operators.
--        kwargs : dict
--            Additional key-word arguments to be passed on to the relevant norm
--            function (see :meth:`.norm` for more details).
--
--        Returns
--        -------
--        obj : :class:`qutip.Qobj`
--            Normalized quantum object.  Will be the `self` object if in place.
--        """
--        norm = self.norm(norm=norm, kwargs=kwargs)
--        if inplace:
--            self.data = _data.mul(self.data, 1 / norm)
--            self._isherm = self._isherm if norm.imag == 0 else None
--            self._isunitary = (self._isunitary
--                               if abs(norm) - 1 < settings.core['atol']
--                               else None)
--            out = self
--        else:
--            out = self / norm
--        return out
--
--    def ptrace(self, sel, dtype=None):
--        """
--        Take the partial trace of the quantum object leaving the selected
--        subspaces.  In other words, trace out all subspaces which are _not_
--        passed.
--
--        This is typically a function which acts on operators; bras and kets
--        will be promoted to density matrices before the operation takes place
--        since the partial trace is inherently undefined on pure states.
--
--        For operators which are currently being represented as states in the
--        superoperator formalism (i.e. the object has type `operator-ket` or
--        `operator-bra`), the partial trace is applied as if the operator were
--        in the conventional form.  This means that for any operator `x`,
--        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
--        and similar for `operator-bra`.
--
--        The story is different for full superoperators.  In the formalism that
--        QuTiP uses, if an operator has dimensions (`dims`) of
--        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
--        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
--        operator which acts on this joint space.  This function performs the
--        partial trace on superoperators by letting the selected components
--        refer to elements of the _joint_ _space_, and then returns a regular
--        operator (of type `oper`).
--
--        Parameters
--        ----------
--        sel : int or iterable of int
--            An ``int`` or ``list`` of components to keep after partial trace.
--            The selected subspaces will _not_ be reordered, no matter order
--            they are supplied to `ptrace`.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Quantum object representing partial trace with selected components
--            remaining.
--        """
--        try:
--            sel = sorted(sel)
--        except TypeError:
--            if not isinstance(sel, numbers.Integral):
--                raise TypeError(
--                    "selection must be an integer or list of integers"
--                ) from None
--            sel = [sel]
--        if self.isoperket:
--            dims = self.dims[0]
--            data = vector_to_operator(self).data
--        elif self.isoperbra:
--            dims = self.dims[1]
--            data = vector_to_operator(self.dag()).data
--        elif self.issuper or self.isoper:
--            dims = self.dims
--            data = self.data
--        else:
--            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
--            data = _data.project(self.data)
--        if dims[0] != dims[1]:
--            raise ValueError("partial trace is not defined on non-square maps")
--        dims = flatten(dims[0])
--        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
--        new_dims = [[dims[x] for x in sel]] * 2
--        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
--        if self.isoperket:
--            return operator_to_vector(out)
--        if self.isoperbra:
--            return operator_to_vector(out).dag()
--        return out
--
--    def contract(self, inplace=False):
--        """
--        Contract subspaces of the tensor structure which are 1D.  Not defined
--        on superoperators.  If all dimensions are scalar, a Qobj of dimension
--        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
--        contracted, but one is left.
--
--        Parameters
--        ----------
--        inplace: bool, optional
--            If ``True``, modify the dimensions in place.  If ``False``, return
--            a copied object.
--
--        Returns
--        -------
--        out: :class:`.Qobj`
--            Quantum object with dimensions contracted.  Will be ``self`` if
--            ``inplace`` is ``True``.
--        """
--        if self.isket:
--            sub = [x for x in self.dims[0] if x > 1] or [1]
--            dims = [sub, [1]*len(sub)]
--        elif self.isbra:
--            sub = [x for x in self.dims[1] if x > 1] or [1]
--            dims = [[1]*len(sub), sub]
--        elif self.isoper or self.isoperket or self.isoperbra:
--            if self.isoper:
--                oper_dims = self.dims
--            elif self.isoperket:
--                oper_dims = self.dims[0]
--            else:
--                oper_dims = self.dims[1]
--            if len(oper_dims[0]) != len(oper_dims[1]):
--                raise ValueError("cannot parse Qobj dimensions: "
--                                 + repr(self.dims))
--            dims_ = [
--                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
--                if x > 1 or y > 1
--            ] or [(1, 1)]
--            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
--            if self.isoperket:
--                dims = [dims, [1]]
--            elif self.isoperbra:
--                dims = [[1], dims]
--        else:
--            raise TypeError("not defined for superoperators")
--        if inplace:
--            self.dims = dims
--            return self
--        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
--
--    def permute(self, order):
--        """
--        Permute the tensor structure of a quantum object.  For example,
--        ``qutip.tensor(x, y).permute([1, 0])``
--        will give the same result as
--        ``qutip.tensor(y, x)``
--        and
--        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
--        will be the same as
--        ``qutip.tensor(b, c, a)``
--
--        For regular objects (bras, kets and operators) we expect ``order`` to
--        be a flat list of integers, which specifies the new order of the tensor
--        product.
--
--        For superoperators, we expect ``order`` to be something like
--        ``[[0, 2], [1, 3]]``
--        which tells us to permute according to [0, 2, 1, 3], and then group
--        indices according to the length of each sublist.  As another example,
--        permuting a superoperator with dimensions of
--        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
--        by an ``order``
--        ``[[0, 3], [1, 4], [2, 5]]``
--        should give a new object with dimensions
--        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
--
--        Parameters
--        ----------
--        order : list
--            List of indices specifying the new tensor order.
--
--        Returns
--        -------
--        P : :class:`qutip.Qobj`
--            Permuted quantum object.
--        """
--        if self.type in ('bra', 'ket', 'oper'):
--            structure = self.dims[1] if self.isbra else self.dims[0]
--            new_structure = [structure[x] for x in order]
--            if self.isbra:
--                dims = [self.dims[0], new_structure]
--            elif self.isket:
--                dims = [new_structure, self.dims[1]]
--            else:
--                if self.dims[0] != self.dims[1]:
--                    raise TypeError("undefined for non-square operators")
--                dims = [new_structure, new_structure]
--            data = _data.permute.dimensions(self.data, structure, order)
--            return Qobj(data,
--                        dims=dims,
--                        type=self.type,
--                        isherm=self._isherm,
--                        isunitary=self._isunitary,
--                        copy=False)
--        # If we've got here, we're some form of superoperator, so we work with
--        # the flattened structure.
--        flat_order = flatten(order)
--        flat_structure = flatten(self.dims[1] if self.isoperbra
--                                 else self.dims[0])
--        new_structure = unflatten([flat_structure[x] for x in flat_order],
--                                  enumerate_flat(order))
--        if self.isoperbra:
--            dims = [self.dims[0], new_structure]
--        elif self.isoperket:
--            dims = [new_structure, self.dims[1]]
--        else:
--            if self.dims[0] != self.dims[1]:
--                raise TypeError("undefined for non-square operators")
--            dims = [new_structure, new_structure]
--        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
--        return Qobj(data,
--                    dims=dims,
--                    type=self.type,
--                    superrep=self.superrep,
--                    copy=False)
--
--    def tidyup(self, atol=None):
--        """
--        Removes small elements from the quantum object.
--
--        Parameters
--        ----------
--        atol : float
--            Absolute tolerance used by tidyup. Default is set
--            via qutip global settings parameters.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Quantum object with small elements removed.
--        """
--        atol = atol or settings.core['auto_tidyup_atol']
--        self.data = _data.tidyup(self.data, atol)
--        return self
--
--    def transform(self, inpt, inverse=False):
--        """Basis transform defined by input array.
--
--        Input array can be a ``matrix`` defining the transformation,
--        or a ``list`` of kets that defines the new basis.
--
--        Parameters
--        ----------
--        inpt : array_like
--            A ``matrix`` or ``list`` of kets defining the transformation.
--        inverse : bool
--            Whether to return inverse transformation.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            Operator in new basis.
--
--        Notes
--        -----
--        This function is still in development.
--        """
--        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
--                                      inpt.ndim == 1):
--            if len(inpt) != max(self.shape):
--                raise TypeError(
--                    'Invalid size of ket list for basis transformation')
--            base = np.hstack([psi.full() for psi in inpt])
--            S = _data.adjoint(_data.create(base))
--        elif isinstance(inpt, Qobj) and inpt.isoper:
--            S = inpt.data
--        elif isinstance(inpt, np.ndarray):
--            S = _data.create(inpt).conj()
--        else:
--            raise TypeError('Invalid operand for basis transformation')
--
--        # transform data
--        if inverse:
--            if self.isket:
--                data = _data.matmul(S.adjoint(), self.data)
--            elif self.isbra:
--                data = _data.matmul(self.data, S)
--            else:
--                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
--        else:
--            if self.isket:
--                data = _data.matmul(S, self.data)
--            elif self.isbra:
--                data = _data.matmul(self.data, S.adjoint())
--            else:
--                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
--        return Qobj(data,
--                    dims=self.dims,
--                    type=self.type,
--                    isherm=self._isherm,
--                    superrep=self.superrep,
--                    copy=False)
--
--    def trunc_neg(self, method="clip"):
--        """Truncates negative eigenvalues and renormalizes.
--
--        Returns a new Qobj by removing the negative eigenvalues
--        of this instance, then renormalizing to obtain a valid density
--        operator.
--
--
--        Parameters
--        ----------
--        method : str
--            Algorithm to use to remove negative eigenvalues. "clip"
--            simply discards negative eigenvalues, then renormalizes.
--            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
--            positive operator that is nearest in the Shatten 2-norm.
--
--        Returns
--        -------
--        oper : :class:`qutip.Qobj`
--            A valid density operator.
--        """
--        if not self.isherm:
--            raise ValueError("Must be a Hermitian operator to remove negative "
--                             "eigenvalues.")
--        if method not in ('clip', 'sgs'):
--            raise ValueError("Method {} not recognized.".format(method))
--
--        eigvals, eigstates = self.eigenstates()
--        if all(eigval >= 0 for eigval in eigvals):
--            # All positive, so just renormalize.
--            return self.unit()
--        idx_nonzero = eigvals != 0
--        eigvals = eigvals[idx_nonzero]
--        eigstates = eigstates[idx_nonzero]
--
--        if method == 'clip':
--            eigvals[eigvals < 0] = 0
--        elif method == 'sgs':
--            eigvals = eigvals[::-1]
--            eigstates = eigstates[::-1]
--            acc = 0.0
--            n_eigs = len(eigvals)
--            for idx in reversed(range(n_eigs)):
--                if eigvals[idx] + acc / (idx + 1) >= 0:
--                    break
--                acc += eigvals[idx]
--                eigvals[idx] = 0.0
--            eigvals[:idx+1] += acc / (idx + 1)
--        out_data = _data.zeros(*self.shape)
--        for value, state in zip(eigvals, eigstates):
--            if value:
--                # add in 3-argument form is fused-add-multiply
--                out_data = _data.add(out_data,
--                                     _data.project(state.data),
--                                     value)
--        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
--        return Qobj(out_data,
--                    dims=self.dims.copy(),
--                    type=self.type,
--                    isherm=True,
--                    copy=False)
--
--    def matrix_element(self, bra, ket):
--        """Calculates a matrix element.
--
--        Gives the matrix element for the quantum object sandwiched between a
--        `bra` and `ket` vector.
--
--        Parameters
--        ----------
--        bra : :class:`qutip.Qobj`
--            Quantum object of type 'bra' or 'ket'
--
--        ket : :class:`qutip.Qobj`
--            Quantum object of type 'ket'.
--
--        Returns
--        -------
--        elem : complex
--            Complex valued matrix element.
--
--        Notes
--        -----
--        It is slightly more computationally efficient to use a ket
--        vector for the 'bra' input.
--
--        """
--        if not self.isoper:
--            raise TypeError("Can only get matrix elements for an operator.")
--        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
--            msg = "Can only calculate matrix elements between a bra and a ket."
--            raise TypeError(msg)
--        left, op, right = bra.data, self.data, ket.data
--        if ket.isbra:
--            right = right.adjoint()
--        return _data.inner_op(left, op, right, bra.isket)
--
--    def overlap(self, other):
--        """
--        Overlap between two state vectors or two operators.
--
--        Gives the overlap (inner product) between the current bra or ket Qobj
--        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
--        when one of the Qobj is an operator/density matrix.
--
--        Parameters
--        ----------
--        other : :class:`qutip.Qobj`
--            Quantum object for a state vector of type 'ket', 'bra' or density
--            matrix.
--
--        Returns
--        -------
--        overlap : complex
--            Complex valued overlap.
--
--        Raises
--        ------
--        TypeError
--            Can only calculate overlap between a bra, ket and density matrix
--            quantum objects.
--        """
--        if not isinstance(other, Qobj):
--            raise TypeError("".join([
--                "cannot calculate overlap with non-quantum object ",
--                repr(other),
--            ]))
--        if (
--            self.type not in ('ket', 'bra', 'oper')
--            or other.type not in ('ket', 'bra', 'oper')
--        ):
--            msg = "only bras, kets and density matrices have defined overlaps"
--            raise TypeError(msg)
--        left, right = self._data.adjoint(), other.data
--        if self.isoper or other.isoper:
--            if not self.isoper:
--                left = _data.project(left)
--            if not other.isoper:
--                right = _data.project(right)
--            return _data.trace(_data.matmul(left, right))
--        if other.isbra:
--            right = right.adjoint()
--        out = _data.inner(left, right, self.isket)
--        if self.isket and other.isbra:
--            # In this particular case, we've basically doing
--            #   conj(other.overlap(self))
--            # so we take care to conjugate the output.
--            out = np.conj(out)
--        return out
--
--    def eigenstates(self, sparse=False, sort='low', eigvals=0,
--                    tol=0, maxiter=100000, phase_fix=None):
--        """Eigenstates and eigenenergies.
--
--        Eigenstates and eigenenergies are defined for operators and
--        superoperators only.
--
--        Parameters
--        ----------
--        sparse : bool
--            Use sparse Eigensolver
--
--        sort : str
--            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
--
--        eigvals : int
--            Number of requested eigenvalues. Default is all eigenvalues.
--
--        tol : float
--            Tolerance used by sparse Eigensolver (0 = machine precision).
--            The sparse solver may not converge if the tolerance is set too low.
--
--        maxiter : int
--            Maximum number of iterations performed by sparse solver (if used).
--
--        phase_fix : int, None
--            If not None, set the phase of each kets so that ket[phase_fix,0]
--            is real positive.
--
--        Returns
--        -------
--        eigvals : array
--            Array of eigenvalues for operator.
--
--        eigvecs : array
--            Array of quantum operators representing the oprator eigenkets.
--            Order of eigenkets is determined by order of eigenvalues.
--
--        Notes
--        -----
--        The sparse eigensolver is much slower than the dense version.
--        Use sparse only if memory requirements demand it.
--
--        """
--        if isinstance(self.data, _data.CSR) and sparse:
--            evals, evecs = _data.eigs_csr(self.data,
--                                          isherm=self._isherm,
--                                          sort=sort, eigvals=eigvals, tol=tol,
--                                          maxiter=maxiter)
--        elif isinstance(self.data, _data.CSR):
--            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
--                                      isherm=self._isherm,
--                                      sort=sort, eigvals=eigvals)
--        else:
--            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
--                                      sort=sort, eigvals=eigvals)
--
--        if self.type == 'super':
--            new_dims = [self.dims[0], [1]]
--            new_type = 'operator-ket'
--        else:
--            new_dims = [self.dims[0], [1]*len(self.dims[0])]
--            new_type = 'ket'
--        ekets = np.empty((evecs.shape[1],), dtype=object)
--        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
--                    for vec in _data.split_columns(evecs, False)]
--        norms = np.array([ket.norm() for ket in ekets])
--        if phase_fix is None:
--            phase = np.array([1] * len(ekets))
--        else:
--            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
--                              if ket[phase_fix, 0] else 1
--                              for ket in ekets])
--        return evals, ekets / norms * phase
--
--    def eigenenergies(self, sparse=False, sort='low',
--                      eigvals=0, tol=0, maxiter=100000):
--        """Eigenenergies of a quantum object.
--
--        Eigenenergies (eigenvalues) are defined for operators or superoperators
--        only.
--
--        Parameters
--        ----------
--        sparse : bool
--            Use sparse Eigensolver
--        sort : str
--            Sort eigenvalues 'low' to high, or 'high' to low.
--        eigvals : int
--            Number of requested eigenvalues. Default is all eigenvalues.
--        tol : float
--            Tolerance used by sparse Eigensolver (0=machine precision).
--            The sparse solver may not converge if the tolerance is set too low.
--        maxiter : int
--            Maximum number of iterations performed by sparse solver (if used).
--
--        Returns
--        -------
--        eigvals : array
--            Array of eigenvalues for operator.
--
--        Notes
--        -----
--        The sparse eigensolver is much slower than the dense version.
--        Use sparse only if memory requirements demand it.
--
--        """
--        # TODO: consider another way of handling the dispatch here.
--        if isinstance(self.data, _data.CSR) and sparse:
--            return _data.eigs_csr(self.data,
--                                  vecs=False,
--                                  isherm=self._isherm,
--                                  sort=sort, eigvals=eigvals,
--                                  tol=tol, maxiter=maxiter)
--        elif isinstance(self.data, _data.CSR):
--            return _data.eigs(_data.to(_data.Dense, self.data),
--                              vecs=False, isherm=self._isherm,
--                              sort=sort, eigvals=eigvals)
--
--        return _data.eigs(self.data,
--                          vecs=False,
--                          isherm=self._isherm, sort=sort, eigvals=eigvals)
--
--    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
--        """Ground state Eigenvalue and Eigenvector.
--
--        Defined for quantum operators or superoperators only.
--
--        Parameters
--        ----------
--        sparse : bool
--            Use sparse Eigensolver
--        tol : float
--            Tolerance used by sparse Eigensolver (0 = machine precision).
--            The sparse solver may not converge if the tolerance is set too low.
--        maxiter : int
--            Maximum number of iterations performed by sparse solver (if used).
--        safe : bool (default=True)
--            Check for degenerate ground state
--
--        Returns
--        -------
--        eigval : float
--            Eigenvalue for the ground state of quantum operator.
--        eigvec : :class:`qutip.Qobj`
--            Eigenket for the ground state of quantum operator.
--
--        Notes
--        -----
--        The sparse eigensolver is much slower than the dense version.
--        Use sparse only if memory requirements demand it.
--        """
--        eigvals = 2 if safe else 1
--        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
--                                        tol=tol, maxiter=maxiter)
--
--        if safe:
--            tol = tol or settings.core['atol']
--            # This tol should be less strick than the tol for the eigensolver
--            # so it's numerical errors are not seens as degenerate states.
--            if (evals[1]-evals[0]) <= 10 * tol:
--                warnings.warn("Ground state may be degenerate.", UserWarning)
--        return evals[0], evecs[0]
--
--    def dnorm(self, B=None):
--        """Calculates the diamond norm, or the diamond distance to another
--        operator.
--
--        Parameters
--        ----------
--        B : :class:`qutip.Qobj` or None
--            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
--            between this operator and B is returned instead of the diamond norm.
--
--        Returns
--        -------
--        d : float
--            Either the diamond norm of this operator, or the diamond distance
--            from this operator to B.
--
--        """
--        return mts.dnorm(self, B)
--
--    @property
--    def ishp(self):
--        # FIXME: this needs to be cached in the same ways as isherm.
--        if self.type in ["super", "oper"]:
--            try:
--                J = to_choi(self)
--                return J.isherm
--            except:
--                return False
--        else:
--            return False
--
--    @property
--    def iscp(self):
--        # FIXME: this needs to be cached in the same ways as isherm.
--        if self.type not in ["super", "oper"]:
--            return False
--        # We can test with either Choi or chi, since the basis
--        # transformation between them is unitary and hence preserves
--        # the CP and TP conditions.
--        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
--        # If J isn't hermitian, then that could indicate either that J is not
--        # normal, or is normal, but has complex eigenvalues.  In either case,
--        # it makes no sense to then demand that the eigenvalues be
--        # non-negative.
--        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
--
--    @property
--    def istp(self):
--        if self.type not in ['super', 'oper']:
--            return False
--        # Normalize to a super of type choi or chi.
--        # We can test with either Choi or chi, since the basis
--        # transformation between them is unitary and hence
--        # preserves the CP and TP conditions.
--        if self.issuper and self.superrep in ('choi', 'chi'):
--            qobj = self
--        else:
--            qobj = to_choi(self)
--        # Possibly collapse dims.
--        if any([len(index) > 1
--                for super_index in qobj.dims
--                for index in super_index]):
--            qobj = Qobj(qobj.data,
--                        dims=collapse_dims_super(qobj.dims),
--                        type=qobj.type,
--                        superrep=qobj.superrep,
--                        copy=False)
--        # We use the condition from John Watrous' lecture notes,
--        # Tr_1(J(Phi)) = identity_2.
--        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
--        # Theory of Quantum Information (Fall 2011), theorem 5.4.
--        tr_oper = qobj.ptrace([0])
--        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
--                           atol=settings.core['atol'])
--
--    @property
--    def iscptp(self):
--        if not (self.issuper or self.isoper):
--            return False
--        reps = ('choi', 'chi')
--        q_oper = to_choi(self) if self.superrep not in reps else self
--        return q_oper.iscp and q_oper.istp
--
--    @property
--    def isherm(self):
--        if self._isherm is not None:
--            return self._isherm
--        self._isherm = _data.isherm(self._data)
--        return self._isherm
--
--    @isherm.setter
--    def isherm(self, isherm):
--        self._isherm = isherm
--
--    def _calculate_isunitary(self):
--        """
--        Checks whether qobj is a unitary matrix
--        """
--        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
--            return False
--        cmp = _data.matmul(self._data, self._data.adjoint())
--        iden = _data.identity(self.shape[0], dtype=type(cmp))
--        return _data.iszero(_data.sub(cmp, iden),
--                            tol=settings.core['atol'])
--
--    @property
--    def isunitary(self):
--        if self._isunitary is not None:
--            return self._isunitary
--        self._isunitary = self._calculate_isunitary()
--        return self._isunitary
--
--    @property
--    def shape(self): return self.data.shape
--
--    isbra = property(isbra)
--    isket = property(isket)
--    isoper = property(isoper)
--    issuper = property(issuper)
--    isoperbra = property(isoperbra)
--    isoperket = property(isoperket)
--
--
--def ptrace(Q, sel):
--    """
--    Partial trace of the Qobj with selected components remaining.
--
--    Parameters
--    ----------
--    Q : :class:`qutip.Qobj`
--        Composite quantum object.
--    sel : int/list
--        An ``int`` or ``list`` of components to keep after partial trace.
--
--    Returns
--    -------
--    oper : :class:`qutip.Qobj`
--        Quantum object representing partial trace with selected components
--        remaining.
--
--    Notes
--    -----
--    This function is for legacy compatibility only. It is recommended to use
--    the ``ptrace()`` Qobj method.
--    """
--    if not isinstance(Q, Qobj):
--        raise TypeError("Input is not a quantum object")
--    return Q.ptrace(sel)
--
--
--# TRAILING IMPORTS
--# We do a few imports here to avoid circular dependencies.
--from qutip.core.superop_reps import to_choi
--from qutip.core.superoperator import vector_to_operator, operator_to_vector
--from qutip.core.tensor import tensor_swap, tensor
--from qutip.core import metrics as mts
-+"""The Quantum Object (Qobj) class, for representing quantum states and
-+operators, and related functions.
-+"""
-+
-+__all__ = [
-+    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
-+    'isherm', 'ptrace',
-+]
-+
-+import functools
-+import numbers
-+import warnings
-+
-+import numpy as np
-+import scipy.sparse
-+
-+from .. import __version__
-+from ..settings import settings
-+from . import data as _data
-+from .dimensions import (
-+    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
-+)
-+
-+
-+_ADJOINT_TYPE_LOOKUP = {
-+    'oper': 'oper',
-+    'super': 'super',
-+    'ket': 'bra',
-+    'bra': 'ket',
-+    'operator-ket': 'operator-bra',
-+    'operator-bra': 'operator-ket',
-+}
-+
-+_MATMUL_TYPE_LOOKUP = {
-+    ('oper', 'ket'): 'ket',
-+    ('oper', 'oper'): 'oper',
-+    ('ket', 'bra'): 'oper',
-+    ('bra', 'oper'): 'bra',
-+    ('super', 'super'): 'super',
-+    ('super', 'operator-ket'): 'operator-ket',
-+    ('operator-bra', 'super'): 'operator-bra',
-+    ('operator-ket', 'operator-bra'): 'super',
-+}
-+
-+_NORM_FUNCTION_LOOKUP = {
-+    'tr': _data.norm.trace,
-+    'one': _data.norm.one,
-+    'max': _data.norm.max,
-+    'fro': _data.norm.frobenius,
-+    'l2': _data.norm.l2,
-+}
-+_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
-+_NORM_ALLOWED_VECTOR = {'l2', 'max'}
-+
-+_CALL_ALLOWED = {
-+    ('super', 'oper'),
-+    ('super', 'ket'),
-+    ('oper', 'ket'),
-+}
-+
-+
-+def isbra(x):
-+    return isinstance(x, Qobj) and x.type == 'bra'
-+
-+
-+def isket(x):
-+    return isinstance(x, Qobj) and x.type == 'ket'
-+
-+
-+def isoper(x):
-+    return isinstance(x, Qobj) and x.type == 'oper'
-+
-+
-+def isoperbra(x):
-+    return isinstance(x, Qobj) and x.type == 'operator-bra'
-+
-+
-+def isoperket(x):
-+    return isinstance(x, Qobj) and x.type == 'operator-ket'
-+
-+
-+def issuper(x):
-+    return isinstance(x, Qobj) and x.type == 'super'
-+
-+
-+def isherm(x):
-+    return isinstance(x, Qobj) and x.isherm
-+
-+
-+def _require_equal_type(method):
-+    """
-+    Decorate a binary Qobj method to ensure both operands are Qobj and of the
-+    same type and dimensions.  Promote numeric scalar to identity matrices of
-+    the same type and shape.
-+    """
-+    @functools.wraps(method)
-+    def out(self, other):
-+        if other == 0:
-+            return method(self, other)
-+        if (
-+            self.type in ('oper', 'super')
-+            and self.dims[0] == self.dims[1]
-+            and isinstance(other, numbers.Number)
-+        ):
-+            scale = complex(other)
-+            other = Qobj(_data.identity(self.shape[0], scale,
-+                                        dtype=type(self.data)),
-+                         dims=self.dims,
-+                         type=self.type,
-+                         superrep=self.superrep,
-+                         isherm=(scale.imag == 0),
-+                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
-+                         copy=False)
-+        if not isinstance(other, Qobj):
-+            try:
-+                other = Qobj(other, type=self.type)
-+            except TypeError:
-+                return NotImplemented
-+        if self.dims != other.dims:
-+            msg = (
-+                "incompatible dimensions "
-+                + repr(self.dims) + " and " + repr(other.dims)
-+            )
-+            raise ValueError(msg)
-+        if self.type != other.type:
-+            msg = "incompatible types " + self.type + " and " + other.type
-+            raise ValueError(msg)
-+        if self.superrep != other.superrep:
-+            msg = (
-+                "incompatible superoperator representations"
-+                + self.superrep + " and " + other.superrep
-+            )
-+            raise ValueError(msg)
-+        return method(self, other)
-+    return out
-+
-+
-+def _latex_real(x):
-+    if not x:
-+        return "0"
-+    if not 0.001 <= abs(x) < 1000:
-+        base, exp = "{:.3e}".format(x).split('e')
-+        return base + r"\times10^{{ {:d} }}".format(int(exp))
-+    if abs(x - int(x)) < 0.001:
-+        return "{:d}".format(round(x))
-+    return "{:.3f}".format(x)
-+
-+
-+def _latex_complex(x):
-+    if abs(x.imag) < 0.001:
-+        return _latex_real(x.real)
-+    if abs(x.real) < 0.001:
-+        return _latex_real(x.imag) + "j"
-+    sign = "+" if x.imag > 0 else "-"
-+    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
-+
-+
-+def _latex_row(row, cols, data):
-+    if row is None:
-+        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
-+    else:
-+        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
-+                for col in cols)
-+    return " & ".join(bits)
-+
-+
-+class Qobj:
-+    """
-+    A class for representing quantum objects, such as quantum operators and
-+    states.
-+
-+    The Qobj class is the QuTiP representation of quantum operators and state
-+    vectors. This class also implements math operations +,-,* between Qobj
-+    instances (and / by a C-number), as well as a collection of common
-+    operator/state operations.  The Qobj constructor optionally takes a
-+    dimension ``list`` and/or shape ``list`` as arguments.
-+
-+    Parameters
-+    ----------
-+    inpt: array_like
-+        Data for vector/matrix representation of the quantum object.
-+    dims: list
-+        Dimensions of object used for tensor products.
-+    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
-+        The type of quantum object to be represented.
-+    shape: list
-+        Shape of underlying data structure (matrix shape).
-+    copy: bool
-+        Flag specifying whether Qobj should get a copy of the
-+        input data, or use the original.
-+
-+
-+    Attributes
-+    ----------
-+    data : array_like
-+        Sparse matrix characterizing the quantum object.
-+    dims : list
-+        List of dimensions keeping track of the tensor structure.
-+    shape : list
-+        Shape of the underlying `data` array.
-+    type : str
-+        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
-+        'operator-bra', or 'super'.
-+    superrep : str
-+        Representation used if `type` is 'super'. One of 'super'
-+        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
-+    isherm : bool
-+        Indicates if quantum object represents Hermitian operator.
-+    isunitary : bool
-+        Indictaes if quantum object represents unitary operator.
-+    iscp : bool
-+        Indicates if the quantum object represents a map, and if that map is
-+        completely positive (CP).
-+    ishp : bool
-+        Indicates if the quantum object represents a map, and if that map is
-+        hermicity preserving (HP).
-+    istp : bool
-+        Indicates if the quantum object represents a map, and if that map is
-+        trace preserving (TP).
-+    iscptp : bool
-+        Indicates if the quantum object represents a map that is completely
-+        positive and trace preserving (CPTP).
-+    isket : bool
-+        Indicates if the quantum object represents a ket.
-+    isbra : bool
-+        Indicates if the quantum object represents a bra.
-+    isoper : bool
-+        Indicates if the quantum object represents an operator.
-+    issuper : bool
-+        Indicates if the quantum object represents a superoperator.
-+    isoperket : bool
-+        Indicates if the quantum object represents an operator in column vector
-+        form.
-+    isoperbra : bool
-+        Indicates if the quantum object represents an operator in row vector
-+        form.
-+
-+    Methods
-+    -------
-+    copy()
-+        Create copy of Qobj
-+    conj()
-+        Conjugate of quantum object.
-+    cosm()
-+        Cosine of quantum object.
-+    dag()
-+        Adjoint (dagger) of quantum object.
-+    dnorm()
-+        Diamond norm of quantum operator.
-+    dual_chan()
-+        Dual channel of quantum object representing a CP map.
-+    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
-+        Returns eigenenergies (eigenvalues) of a quantum object.
-+    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
-+        Returns eigenenergies and eigenstates of quantum object.
-+    expm()
-+        Matrix exponential of quantum object.
-+    full(order='C')
-+        Returns dense array of quantum object `data` attribute.
-+    groundstate(sparse=False, tol=0, maxiter=100000)
-+        Returns eigenvalue and eigenket for the groundstate of a quantum
-+        object.
-+    inv()
-+        Return a Qobj corresponding to the matrix inverse of the operator.
-+    matrix_element(bra, ket)
-+        Returns the matrix element of operator between `bra` and `ket` vectors.
-+    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
-+        Returns norm of a ket or an operator.
-+    permute(order)
-+        Returns composite qobj with indices reordered.
-+    proj()
-+        Computes the projector for a ket or bra vector.
-+    ptrace(sel)
-+        Returns quantum object for selected dimensions after performing
-+        partial trace.
-+    sinm()
-+        Sine of quantum object.
-+    sqrtm()
-+        Matrix square root of quantum object.
-+    tidyup(atol=1e-12)
-+        Removes small elements from quantum object.
-+    tr()
-+        Trace of quantum object.
-+    trans()
-+        Transpose of quantum object.
-+    transform(inpt, inverse=False)
-+        Performs a basis transformation defined by `inpt` matrix.
-+    trunc_neg(method='clip')
-+        Removes negative eigenvalues and returns a new Qobj that is
-+        a valid density operator.
-+    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
-+        Returns normalized quantum object.
-+
-+    """
-+    # Disable ufuncs from acting directly on Qobj.
-+    __array_ufunc__ = None
-+
-+    def _initialize_data(self, arg, dims, copy):
-+        if isinstance(arg, _data.Data):
-+            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
-+            self._data = arg.copy() if copy else arg
-+        elif isinstance(arg, Qobj):
-+            self.dims = dims or arg.dims.copy()
-+            self._data = arg.data.copy() if copy else arg.data
-+        elif arg is None or isinstance(arg, numbers.Number):
-+            self.dims = dims or [[1], [1]]
-+            size = np.prod(self.dims[0])
-+            if arg is None:
-+                self._data = _data.zeros(size, size)
-+            else:
-+                self._data = _data.identity(size, scale=complex(arg))
-+        else:
-+            self._data = _data.create(arg, copy=copy)
-+            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
-+
-+    def __init__(self, arg=None, dims=None, type=None,
-+                 copy=True, superrep=None, isherm=None, isunitary=None):
-+        self._initialize_data(arg, dims, copy)
-+        self.type = type or type_from_dims(self.dims)
-+        self._isherm = isherm
-+        self._isunitary = isunitary
-+
-+        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
-+            if self._data.shape[0] != self._data.shape[1]:
-+                raise ValueError("".join([
-+                    "cannot build superoperator from nonsquare data of shape ",
-+                    repr(self._data.shape),
-+                ]))
-+            root = int(np.sqrt(self._data.shape[0]))
-+            if root * root != self._data.shape[0]:
-+                raise ValueError("".join([
-+                    "cannot build superoperator from nonsquare subspaces ",
-+                    "of size ",
-+                    repr(self._data.shape[0]),
-+                ]))
-+            self.dims = [[[root]]*2]*2
-+        if self.type in ['super', 'operator-ket', 'operator-bra']:
-+            superrep = superrep or 'super'
-+        self.superrep = superrep
-+
-+    def copy(self):
-+        """Create identical copy"""
-+        return Qobj(arg=self._data,
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=True)
-+
-+    @property
-+    def data(self):
-+        return self._data
-+
-+    @data.setter
-+    def data(self, data):
-+        if not isinstance(data, _data.Data):
-+            raise TypeError('Qobj data must be a data-layer format.')
-+        self._data = data
-+
-+    def to(self, data_type):
-+        """
-+        Convert the underlying data store of this `Qobj` into a different
-+        storage representation.
-+
-+        The different storage representations available are the "data-layer
-+        types" which are known to `qutip.data.to`.  By default, these are
-+        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
-+        dense matrix store and a compressed sparse row one.  Certain algorithms
-+        and operations may be faster or more accurate when using a more
-+        appropriate data store.
-+
-+        If the data store is already in the format requested, the function
-+        returns `self`.  Otherwise, it returns a copy of itself with the data
-+        store in the new type.
-+
-+        Parameters
-+        ----------
-+        data_type : type
-+            The data-layer type that the data of this `Qobj` should be
-+            converted to.
-+
-+        Returns
-+        -------
-+        Qobj
-+            A new `Qobj` if a type conversion took place with the data stored
-+            in the requested format, or `self` if not.
-+        """
-+        try:
-+            converter = _data.to[data_type]
-+        except (KeyError, TypeError):
-+            raise ValueError("Unknown conversion type: " + str(data_type))
-+        if type(self.data) is data_type:
-+            return self
-+        return Qobj(converter(self._data),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=False)
-+
-+    @_require_equal_type
-+    def __add__(self, other):
-+        if other == 0:
-+            return self.copy()
-+        isherm = (self._isherm and other._isherm) or None
-+        return Qobj(_data.add(self._data, other._data),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=isherm,
-+                    copy=False)
-+
-+    def __radd__(self, other):
-+        return self.__add__(other)
-+
-+    @_require_equal_type
-+    def __sub__(self, other):
-+        if other == 0:
-+            return self.copy()
-+        isherm = (self._isherm and other._isherm) or None
-+        return Qobj(_data.sub(self._data, other._data),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=isherm,
-+                    copy=False)
-+
-+    def __rsub__(self, other):
-+        return self.__neg__().__add__(other)
-+
-+    def __mul__(self, other):
-+        """
-+        If other is a Qobj, we dispatch to __matmul__. If not, we
-+        check that other is a valid complex scalar, i.e., we can do
-+        complex(other). Otherwise, we return NotImplemented.
-+        """
-+
-+        if isinstance(other, Qobj):
-+            return self.__matmul__(other)
-+
-+        # We send other to mul instead of complex(other) to be more flexible.
-+        # The dispatcher can then decide how to handle other and return
-+        # TypeError if it does not know what to do with the type of other.
-+        try:
-+            out = _data.mul(self._data, other)
-+        except TypeError:
-+            return NotImplemented
-+
-+        # Infer isherm and isunitary if possible
-+        try:
-+            multiplier = complex(other)
-+            isherm = (self._isherm and multiplier.imag == 0) or None
-+            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
-+                         if self._isunitary else None)
-+        except TypeError:
-+            isherm = None
-+            isunitary = None
-+
-+        return Qobj(out,
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=isherm,
-+                    isunitary=isunitary,
-+                    copy=False)
-+
-+    def __rmul__(self, other):
-+        # Shouldn't be here unless `other.__mul__` has already been tried, so
-+        # we _shouldn't_ check that `other` is `Qobj`.
-+        return self.__mul__(other)
-+
-+    def __matmul__(self, other):
-+        if not isinstance(other, Qobj):
-+            try:
-+                other = Qobj(other)
-+            except TypeError:
-+                return NotImplemented
-+        if self.dims[1] != other.dims[0]:
-+            raise TypeError("".join([
-+                "incompatible dimensions ",
-+                repr(self.dims),
-+                " and ",
-+                repr(other.dims),
-+            ]))
-+        if self.superrep != other.superrep:
-+            raise TypeError("".join([
-+                "incompatible superoperator representations ",
-+                repr(self.superrep),
-+                " and ",
-+                repr(other.superrep),
-+            ]))
-+        if (
-+            (self.isbra and other.isket)
-+            or (self.isoperbra and other.isoperket)
-+        ):
-+            return _data.inner(self.data, other.data)
-+
-+        try:
-+            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
-+        except KeyError:
-+            raise TypeError(
-+                "incompatible matmul types "
-+                + repr(self.type) + " and " + repr(other.type)
-+            ) from None
-+        return Qobj(_data.matmul(self.data, other.data),
-+                    dims=[self.dims[0], other.dims[1]],
-+                    type=type_,
-+                    isunitary=self._isunitary and other._isunitary,
-+                    superrep=self.superrep,
-+                    copy=False)
-+
-+    def __truediv__(self, other):
-+        return self.__mul__(1 / other)
-+
-+    def __neg__(self):
-+        return Qobj(_data.neg(self._data),
-+                    dims=self.dims.copy(),
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=False)
-+
-+    def __getitem__(self, ind):
-+        # TODO: should we require that data-layer types implement this?  This
-+        # isn't the right way of handling it, for sure.
-+        if isinstance(self._data, _data.CSR):
-+            data = self._data.as_scipy()
-+        elif isinstance(self._data, _data.Dense):
-+            data = self._data.as_ndarray()
-+        else:
-+            data = self._data
-+        try:
-+            out = data[ind]
-+            return out.toarray() if scipy.sparse.issparse(out) else out
-+        except TypeError:
-+            pass
-+        return data.to_array()[ind]
-+
-+    def __eq__(self, other):
-+        if self is other:
-+            return True
-+        if not isinstance(other, Qobj) or self.dims != other.dims:
-+            return False
-+        return _data.iszero(_data.sub(self._data, other._data),
-+                            tol=settings.core['atol'])
-+
-+    def __pow__(self, n, m=None):  # calculates powers of Qobj
-+        if (
-+            self.type not in ('oper', 'super')
-+            or self.dims[0] != self.dims[1]
-+            or m is not None
-+            or not isinstance(n, numbers.Integral)
-+            or n < 0
-+        ):
-+            return NotImplemented
-+        return Qobj(_data.pow(self._data, n),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=False)
-+
-+    def _str_header(self):
-+        out = ", ".join([
-+            "Quantum object: dims=" + str(self.dims),
-+            "shape=" + str(self.data.shape),
-+            "type=" + repr(self.type),
-+        ])
-+        if self.type in ('oper', 'super'):
-+            out += ", isherm=" + str(self.isherm)
-+        if self.issuper and self.superrep != 'super':
-+            out += ", superrep=" + repr(self.superrep)
-+        return out
-+
-+    def __str__(self):
-+        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
-+            # If the system is huge, don't attempt to convert to a dense matrix
-+            # and then to string, because it is pointless and is likely going
-+            # to produce memory errors. Instead print the sparse data string
-+            # representation.
-+            data = _data.to(_data.CSR, self.data).as_scipy()
-+        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
-+            data = np.real(self.full())
-+        else:
-+            data = self.full()
-+        return self._str_header() + "\nQobj data =\n" + str(data)
-+
-+    def __repr__(self):
-+        # give complete information on Qobj without print statement in
-+        # command-line we cant realistically serialize a Qobj into a string,
-+        # so we simply return the informal __str__ representation instead.)
-+        return self.__str__()
-+
-+    def __call__(self, other):
-+        """
-+        Acts this Qobj on another Qobj either by left-multiplication,
-+        or by vectorization and devectorization, as
-+        appropriate.
-+        """
-+        if not isinstance(other, Qobj):
-+            raise TypeError("Only defined for quantum objects.")
-+        if (self.type, other.type) not in _CALL_ALLOWED:
-+            raise TypeError(self.type + " cannot act on " + other.type)
-+        if self.issuper:
-+            if other.isket:
-+                other = other.proj()
-+            return vector_to_operator(self @ operator_to_vector(other))
-+        return self.__matmul__(other)
-+
-+    def __getstate__(self):
-+        # defines what happens when Qobj object gets pickled
-+        self.__dict__.update({'qutip_version': __version__[:5]})
-+        return self.__dict__
-+
-+    def __setstate__(self, state):
-+        # defines what happens when loading a pickled Qobj
-+        if 'qutip_version' in state.keys():
-+            del state['qutip_version']
-+        (self.__dict__).update(state)
-+
-+    def _repr_latex_(self):
-+        """
-+        Generate a LaTeX representation of the Qobj instance. Can be used for
-+        formatted output in ipython notebook.
-+        """
-+        half_length = 5
-+        n_rows, n_cols = self.data.shape
-+        # Choose which rows and columns we're going to output, or None if that
-+        # element should be truncated.
-+        rows = list(range(min((half_length, n_rows))))
-+        if n_rows <= half_length * 2:
-+            rows += list(range(half_length, min((2*half_length, n_rows))))
-+        else:
-+            rows.append(None)
-+            rows += list(range(n_rows - half_length, n_rows))
-+        cols = list(range(min((half_length, n_cols))))
-+        if n_cols <= half_length * 2:
-+            cols += list(range(half_length, min((2*half_length, n_cols))))
-+        else:
-+            cols.append(None)
-+            cols += list(range(n_cols - half_length, n_cols))
-+        # Make the data array.
-+        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
-+        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
-+                           for row in rows)
-+        data += r'\end{array}\right)\end{equation*}'
-+        return self._str_header() + data
-+
-+    def __and__(self, other):
-+        """
-+        Syntax shortcut for tensor:
-+        A & B ==> tensor(A, B)
-+        """
-+        return tensor(self, other)
-+
-+    def dag(self):
-+        """Get the Hermitian adjoint of the quantum object."""
-+        if self._isherm:
-+            return self.copy()
-+        return Qobj(_data.adjoint(self._data),
-+                    dims=[self.dims[1], self.dims[0]],
-+                    type=_ADJOINT_TYPE_LOOKUP[self.type],
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=False)
-+
-+    def conj(self):
-+        """Get the element-wise conjugation of the quantum object."""
-+        return Qobj(_data.conj(self._data),
-+                    dims=self.dims.copy(),
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=False)
-+
-+    def trans(self):
-+        """Get the matrix transpose of the quantum operator.
-+
-+        Returns
-+        -------
-+        oper : :class:`.Qobj`
-+            Transpose of input operator.
-+        """
-+        return Qobj(_data.transpose(self._data),
-+                    dims=[self.dims[1], self.dims[0]],
-+                    type=_ADJOINT_TYPE_LOOKUP[self.type],
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    isunitary=self._isunitary,
-+                    copy=False)
-+
-+    def dual_chan(self):
-+        """Dual channel of quantum object representing a completely positive
-+        map.
-+        """
-+        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
-+        # is only valid for completely positive maps.
-+        if not self.iscp:
-+            raise ValueError("Dual channels are only implemented for CP maps.")
-+        J = to_choi(self)
-+        tensor_idxs = enumerate_flat(J.dims)
-+        J_dual = tensor_swap(J, *(
-+                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
-+                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
-+        )).trans()
-+        J_dual.superrep = 'choi'
-+        return J_dual
-+
-+    def norm(self, norm=None, kwargs=None):
-+        """
-+        Norm of a quantum object.
-+
-+        Default norm is L2-norm for kets and trace-norm for operators.  Other
-+        ket and operator norms may be specified using the `norm` parameter.
-+
-+        Parameters
-+        ----------
-+        norm : str
-+            Which type of norm to use.  Allowed values for vectors are 'l2' and
-+            'max'.  Allowed values for matrices are 'tr' for the trace norm,
-+            'fro' for the Frobenius norm, 'one' and 'max'.
-+
-+        kwargs : dict
-+            Additional keyword arguments to pass on to the relevant norm
-+            solver.  See details for each norm function in :mod:`.data.norm`.
-+
-+        Returns
-+        -------
-+        norm : float
-+            The requested norm of the operator or state quantum object.
-+        """
-+        if self.type in ('oper', 'super'):
-+            norm = norm or 'tr'
-+            if norm not in _NORM_ALLOWED_MATRIX:
-+                raise ValueError(
-+                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
-+                )
-+        else:
-+            norm = norm or 'l2'
-+            if norm not in _NORM_ALLOWED_VECTOR:
-+                raise ValueError(
-+                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
-+                )
-+        kwargs = kwargs or {}
-+        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
-+
-+    def proj(self):
-+        """Form the projector from a given ket or bra vector.
-+
-+        Parameters
-+        ----------
-+        Q : :class:`qutip.Qobj`
-+            Input bra or ket vector
-+
-+        Returns
-+        -------
-+        P : :class:`qutip.Qobj`
-+            Projection operator.
-+        """
-+        if not (self.isket or self.isbra):
-+            raise TypeError("projection is only defined for bras and kets")
-+        dims = ([self.dims[0], self.dims[0]] if self.isket
-+                else [self.dims[1], self.dims[1]])
-+        return Qobj(_data.project(self._data),
-+                    dims=dims,
-+                    type='oper',
-+                    isherm=True,
-+                    copy=False)
-+
-+    def tr(self):
-+        """Trace of a quantum object.
-+
-+        Returns
-+        -------
-+        trace : float
-+            Returns the trace of the quantum object.
-+
-+        """
-+        out = _data.trace(self._data)
-+        # This ensures that trace can return something that is not a number such
-+        # as a `tensorflow.Tensor` in qutip-tensorflow.
-+        return out.real if (self.isherm
-+                        and hasattr(out, "real")
-+                        ) else out
-+
-+    def purity(self):
-+        """Calculate purity of a quantum object.
-+
-+        Returns
-+        -------
-+        state_purity : float
-+            Returns the purity of a quantum object.
-+            For a pure state, the purity is 1.
-+            For a mixed state of dimension `d`, 1/d<=purity<1.
-+
-+        """
-+        if self.type in ("super", "operator-ket", "operator-bra"):
-+            raise TypeError('purity is only defined for states.')
-+        if self.isket or self.isbra:
-+            return _data.norm.l2(self.data)**2
-+        return _data.trace(_data.matmul(self.data, self.data)).real
-+
-+    def full(self, order='C', squeeze=False):
-+        """Dense array from quantum object.
-+
-+        Parameters
-+        ----------
-+        order : str {'C', 'F'}
-+            Return array in C (default) or Fortran ordering.
-+        squeeze : bool {False, True}
-+            Squeeze output array.
-+
-+        Returns
-+        -------
-+        data : array
-+            Array of complex data from quantum objects `data` attribute.
-+        """
-+        out = np.asarray(self.data.to_array(), order=order)
-+        return out.squeeze() if squeeze else out
-+
-+    def diag(self):
-+        """Diagonal elements of quantum object.
-+
-+        Returns
-+        -------
-+        diags : array
-+            Returns array of ``real`` values if operators is Hermitian,
-+            otherwise ``complex`` values are returned.
-+        """
-+        # TODO: add a `diagonal` method to the data layer?
-+        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
-+        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
-+            return out
-+        else:
-+            return np.real(out)
-+
-+    def expm(self, dtype=_data.Dense):
-+        """Matrix exponential of quantum operator.
-+
-+        Input operator must be square.
-+
-+        Parameters
-+        ----------
-+        dtype : type
-+            The data-layer type that should be output.  As the matrix
-+            exponential is almost dense, this defaults to outputting dense
-+            matrices.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Exponentiated quantum operator.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Quantum operator is not square.
-+        """
-+        if self.dims[0] != self.dims[1]:
-+            raise TypeError("expm is only valid for square operators")
-+        return Qobj(_data.expm(self._data, dtype=dtype),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    copy=False)
-+
-+    def logm(self):
-+        """Matrix logarithm of quantum operator.
-+
-+        Input operator must be square.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Logarithm of the quantum operator.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Quantum operator is not square.
-+        """
-+        if self.dims[0] != self.dims[1]:
-+            raise TypeError("expm is only valid for square operators")
-+        return Qobj(_data.logm(self._data),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    isherm=self._isherm,
-+                    copy=False)
-+
-+    def check_herm(self):
-+        """Check if the quantum object is hermitian.
-+
-+        Returns
-+        -------
-+        isherm : bool
-+            Returns the new value of isherm property.
-+        """
-+        self._isherm = None
-+        return self.isherm
-+
-+    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
-+        """
-+        Sqrt of a quantum operator.  Operator must be square.
-+
-+        Parameters
-+        ----------
-+        sparse : bool
-+            Use sparse eigenvalue/vector solver.
-+        tol : float
-+            Tolerance used by sparse solver (0 = machine precision).
-+        maxiter : int
-+            Maximum number of iterations used by sparse solver.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Matrix square root of operator.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Quantum object is not square.
-+
-+        Notes
-+        -----
-+        The sparse eigensolver is much slower than the dense version.
-+        Use sparse only if memory requirements demand it.
-+        """
-+        if self.dims[0] != self.dims[1]:
-+            raise TypeError('sqrt only valid on square matrices')
-+        if isinstance(self.data, _data.CSR) and sparse:
-+            evals, evecs = _data.eigs_csr(self.data,
-+                                          isherm=self._isherm,
-+                                          tol=tol, maxiter=maxiter)
-+        elif isinstance(self.data, _data.CSR):
-+            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
-+                                      isherm=self._isherm)
-+        else:
-+            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
-+
-+        numevals = len(evals)
-+        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
-+        if self.isherm:
-+            spDv = _data.matmul(dV, evecs.conj().transpose())
-+        else:
-+            spDv = _data.matmul(dV, _data.inv(evecs))
-+        return Qobj(_data.matmul(evecs, spDv),
-+                    dims=self.dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    copy=False)
-+
-+    def cosm(self):
-+        """Cosine of a quantum operator.
-+
-+        Operator must be square.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Matrix cosine of operator.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Quantum object is not square.
-+
-+        Notes
-+        -----
-+        Uses the Q.expm() method.
-+
-+        """
-+        if self.dims[0] != self.dims[1]:
-+            raise TypeError('invalid operand for matrix cosine')
-+        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
-+
-+    def sinm(self):
-+        """Sine of a quantum operator.
-+
-+        Operator must be square.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Matrix sine of operator.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Quantum object is not square.
-+
-+        Notes
-+        -----
-+        Uses the Q.expm() method.
-+        """
-+        if self.dims[0] != self.dims[1]:
-+            raise TypeError('invalid operand for matrix sine')
-+        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
-+
-+    def inv(self, sparse=False):
-+        """Matrix inverse of a quantum operator
-+
-+        Operator must be square.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Matrix inverse of operator.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Quantum object is not square.
-+        """
-+        if self.data.shape[0] != self.data.shape[1]:
-+            raise TypeError('Invalid operand for matrix inverse')
-+        if isinstance(self.data, _data.CSR) and not sparse:
-+            data = _data.to(_data.Dense, self.data)
-+        else:
-+            data = self.data
-+
-+        return Qobj(_data.inv(data),
-+                    dims=[self.dims[1], self.dims[0]],
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    copy=False)
-+
-+    def unit(self, inplace=False, norm=None, kwargs=None):
-+        """
-+        Operator or state normalized to unity.  Uses norm from Qobj.norm().
-+
-+        Parameters
-+        ----------
-+        inplace : bool
-+            Do an in-place normalization
-+        norm : str
-+            Requested norm for states / operators.
-+        kwargs : dict
-+            Additional key-word arguments to be passed on to the relevant norm
-+            function (see :meth:`.norm` for more details).
-+
-+        Returns
-+        -------
-+        obj : :class:`qutip.Qobj`
-+            Normalized quantum object.  Will be the `self` object if in place.
-+        """
-+        norm = self.norm(norm=norm, kwargs=kwargs)
-+        if inplace:
-+            self.data = _data.mul(self.data, 1 / norm)
-+            self._isherm = self._isherm if norm.imag == 0 else None
-+            self._isunitary = (self._isunitary
-+                               if abs(norm) - 1 < settings.core['atol']
-+                               else None)
-+            out = self
-+        else:
-+            out = self / norm
-+        return out
-+
-+    def ptrace(self, sel, dtype=None):
-+        """
-+        Take the partial trace of the quantum object leaving the selected
-+        subspaces.  In other words, trace out all subspaces which are _not_
-+        passed.
-+
-+        This is typically a function which acts on operators; bras and kets
-+        will be promoted to density matrices before the operation takes place
-+        since the partial trace is inherently undefined on pure states.
-+
-+        For operators which are currently being represented as states in the
-+        superoperator formalism (i.e. the object has type `operator-ket` or
-+        `operator-bra`), the partial trace is applied as if the operator were
-+        in the conventional form.  This means that for any operator `x`,
-+        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
-+        and similar for `operator-bra`.
-+
-+        The story is different for full superoperators.  In the formalism that
-+        QuTiP uses, if an operator has dimensions (`dims`) of
-+        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
-+        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
-+        operator which acts on this joint space.  This function performs the
-+        partial trace on superoperators by letting the selected components
-+        refer to elements of the _joint_ _space_, and then returns a regular
-+        operator (of type `oper`).
-+
-+        Parameters
-+        ----------
-+        sel : int or iterable of int
-+            An ``int`` or ``list`` of components to keep after partial trace.
-+            The selected subspaces will _not_ be reordered, no matter order
-+            they are supplied to `ptrace`.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Quantum object representing partial trace with selected components
-+            remaining.
-+        """
-+        try:
-+            sel = sorted(sel)
-+        except TypeError:
-+            if not isinstance(sel, numbers.Integral):
-+                raise TypeError(
-+                    "selection must be an integer or list of integers"
-+                ) from None
-+            sel = [sel]
-+        if self.isoperket:
-+            dims = self.dims[0]
-+            data = vector_to_operator(self).data
-+        elif self.isoperbra:
-+            dims = self.dims[1]
-+            data = vector_to_operator(self.dag()).data
-+        elif self.issuper or self.isoper:
-+            dims = self.dims
-+            data = self.data
-+        else:
-+            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
-+            data = _data.project(self.data)
-+        if dims[0] != dims[1]:
-+            raise ValueError("partial trace is not defined on non-square maps")
-+        dims = flatten(dims[0])
-+        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
-+        new_dims = [[dims[x] for x in sel]] * 2
-+        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
-+        if self.isoperket:
-+            return operator_to_vector(out)
-+        if self.isoperbra:
-+            return operator_to_vector(out).dag()
-+        return out
-+
-+    def contract(self, inplace=False):
-+        """
-+        Contract subspaces of the tensor structure which are 1D.  Not defined
-+        on superoperators.  If all dimensions are scalar, a Qobj of dimension
-+        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
-+        contracted, but one is left.
-+
-+        Parameters
-+        ----------
-+        inplace: bool, optional
-+            If ``True``, modify the dimensions in place.  If ``False``, return
-+            a copied object.
-+
-+        Returns
-+        -------
-+        out: :class:`.Qobj`
-+            Quantum object with dimensions contracted.  Will be ``self`` if
-+            ``inplace`` is ``True``.
-+        """
-+        if self.isket:
-+            sub = [x for x in self.dims[0] if x > 1] or [1]
-+            dims = [sub, [1]*len(sub)]
-+        elif self.isbra:
-+            sub = [x for x in self.dims[1] if x > 1] or [1]
-+            dims = [[1]*len(sub), sub]
-+        elif self.isoper or self.isoperket or self.isoperbra:
-+            if self.isoper:
-+                oper_dims = self.dims
-+            elif self.isoperket:
-+                oper_dims = self.dims[0]
-+            else:
-+                oper_dims = self.dims[1]
-+            if len(oper_dims[0]) != len(oper_dims[1]):
-+                raise ValueError("cannot parse Qobj dimensions: "
-+                                 + repr(self.dims))
-+            dims_ = [
-+                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
-+                if x > 1 or y > 1
-+            ] or [(1, 1)]
-+            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
-+            if self.isoperket:
-+                dims = [dims, [1]]
-+            elif self.isoperbra:
-+                dims = [[1], dims]
-+        else:
-+            raise TypeError("not defined for superoperators")
-+        if inplace:
-+            self.dims = dims
-+            return self
-+        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
-+
-+    def permute(self, order):
-+        """
-+        Permute the tensor structure of a quantum object.  For example,
-+        ``qutip.tensor(x, y).permute([1, 0])``
-+        will give the same result as
-+        ``qutip.tensor(y, x)``
-+        and
-+        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
-+        will be the same as
-+        ``qutip.tensor(b, c, a)``
-+
-+        For regular objects (bras, kets and operators) we expect ``order`` to
-+        be a flat list of integers, which specifies the new order of the tensor
-+        product.
-+
-+        For superoperators, we expect ``order`` to be something like
-+        ``[[0, 2], [1, 3]]``
-+        which tells us to permute according to [0, 2, 1, 3], and then group
-+        indices according to the length of each sublist.  As another example,
-+        permuting a superoperator with dimensions of
-+        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
-+        by an ``order``
-+        ``[[0, 3], [1, 4], [2, 5]]``
-+        should give a new object with dimensions
-+        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
-+
-+        Parameters
-+        ----------
-+        order : list
-+            List of indices specifying the new tensor order.
-+
-+        Returns
-+        -------
-+        P : :class:`qutip.Qobj`
-+            Permuted quantum object.
-+        """
-+        if self.type in ('bra', 'ket', 'oper'):
-+            structure = self.dims[1] if self.isbra else self.dims[0]
-+            new_structure = [structure[x] for x in order]
-+            if self.isbra:
-+                dims = [self.dims[0], new_structure]
-+            elif self.isket:
-+                dims = [new_structure, self.dims[1]]
-+            else:
-+                if self.dims[0] != self.dims[1]:
-+                    raise TypeError("undefined for non-square operators")
-+                dims = [new_structure, new_structure]
-+            data = _data.permute.dimensions(self.data, structure, order)
-+            return Qobj(data,
-+                        dims=dims,
-+                        type=self.type,
-+                        isherm=self._isherm,
-+                        isunitary=self._isunitary,
-+                        copy=False)
-+        # If we've got here, we're some form of superoperator, so we work with
-+        # the flattened structure.
-+        flat_order = flatten(order)
-+        flat_structure = flatten(self.dims[1] if self.isoperbra
-+                                 else self.dims[0])
-+        new_structure = unflatten([flat_structure[x] for x in flat_order],
-+                                  enumerate_flat(order))
-+        if self.isoperbra:
-+            dims = [self.dims[0], new_structure]
-+        elif self.isoperket:
-+            dims = [new_structure, self.dims[1]]
-+        else:
-+            if self.dims[0] != self.dims[1]:
-+                raise TypeError("undefined for non-square operators")
-+            dims = [new_structure, new_structure]
-+        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
-+        return Qobj(data,
-+                    dims=dims,
-+                    type=self.type,
-+                    superrep=self.superrep,
-+                    copy=False)
-+
-+    def tidyup(self, atol=None):
-+        """
-+        Removes small elements from the quantum object.
-+
-+        Parameters
-+        ----------
-+        atol : float
-+            Absolute tolerance used by tidyup. Default is set
-+            via qutip global settings parameters.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Quantum object with small elements removed.
-+        """
-+        atol = atol or settings.core['auto_tidyup_atol']
-+        self.data = _data.tidyup(self.data, atol)
-+        return self
-+
-+    def transform(self, inpt, inverse=False):
-+        """Basis transform defined by input array.
-+
-+        Input array can be a ``matrix`` defining the transformation,
-+        or a ``list`` of kets that defines the new basis.
-+
-+        Parameters
-+        ----------
-+        inpt : array_like
-+            A ``matrix`` or ``list`` of kets defining the transformation.
-+        inverse : bool
-+            Whether to return inverse transformation.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            Operator in new basis.
-+
-+        Notes
-+        -----
-+        This function is still in development.
-+        """
-+        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
-+                                      inpt.ndim == 1):
-+            if len(inpt) != max(self.shape):
-+                raise TypeError(
-+                    'Invalid size of ket list for basis transformation')
-+            base = np.hstack([psi.full() for psi in inpt])
-+            S = _data.adjoint(_data.create(base))
-+        elif isinstance(inpt, Qobj) and inpt.isoper:
-+            S = inpt.data
-+        elif isinstance(inpt, np.ndarray):
-+            S = _data.create(inpt).conj()
-+        else:
-+            raise TypeError('Invalid operand for basis transformation')
-+
-+        # transform data
-+        if inverse:
-+            if self.isket:
-+                data = _data.matmul(S.adjoint(), self.data)
-+            elif self.isbra:
-+                data = _data.matmul(self.data, S)
-+            else:
-+                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
-+        else:
-+            if self.isket:
-+                data = _data.matmul(S, self.data)
-+            elif self.isbra:
-+                data = _data.matmul(self.data, S.adjoint())
-+            else:
-+                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
-+        return Qobj(data,
-+                    dims=self.dims,
-+                    type=self.type,
-+                    isherm=self._isherm,
-+                    superrep=self.superrep,
-+                    copy=False)
-+
-+    def trunc_neg(self, method="clip"):
-+        """Truncates negative eigenvalues and renormalizes.
-+
-+        Returns a new Qobj by removing the negative eigenvalues
-+        of this instance, then renormalizing to obtain a valid density
-+        operator.
-+
-+
-+        Parameters
-+        ----------
-+        method : str
-+            Algorithm to use to remove negative eigenvalues. "clip"
-+            simply discards negative eigenvalues, then renormalizes.
-+            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
-+            positive operator that is nearest in the Shatten 2-norm.
-+
-+        Returns
-+        -------
-+        oper : :class:`qutip.Qobj`
-+            A valid density operator.
-+        """
-+        if not self.isherm:
-+            raise ValueError("Must be a Hermitian operator to remove negative "
-+                             "eigenvalues.")
-+        if method not in ('clip', 'sgs'):
-+            raise ValueError("Method {} not recognized.".format(method))
-+
-+        eigvals, eigstates = self.eigenstates()
-+        if all(eigval >= 0 for eigval in eigvals):
-+            # All positive, so just renormalize.
-+            return self.unit()
-+        idx_nonzero = eigvals != 0
-+        eigvals = eigvals[idx_nonzero]
-+        eigstates = eigstates[idx_nonzero]
-+
-+        if method == 'clip':
-+            eigvals[eigvals < 0] = 0
-+        elif method == 'sgs':
-+            eigvals = eigvals[::-1]
-+            eigstates = eigstates[::-1]
-+            acc = 0.0
-+            n_eigs = len(eigvals)
-+            for idx in reversed(range(n_eigs)):
-+                if eigvals[idx] + acc / (idx + 1) >= 0:
-+                    break
-+                acc += eigvals[idx]
-+                eigvals[idx] = 0.0
-+            eigvals[:idx+1] += acc / (idx + 1)
-+        out_data = _data.zeros(*self.shape)
-+        for value, state in zip(eigvals, eigstates):
-+            if value:
-+                # add in 3-argument form is fused-add-multiply
-+                out_data = _data.add(out_data,
-+                                     _data.project(state.data),
-+                                     value)
-+        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
-+        return Qobj(out_data,
-+                    dims=self.dims.copy(),
-+                    type=self.type,
-+                    isherm=True,
-+                    copy=False)
-+
-+    def matrix_element(self, bra, ket):
-+        """Calculates a matrix element.
-+
-+        Gives the matrix element for the quantum object sandwiched between a
-+        `bra` and `ket` vector.
-+
-+        Parameters
-+        ----------
-+        bra : :class:`qutip.Qobj`
-+            Quantum object of type 'bra' or 'ket'
-+
-+        ket : :class:`qutip.Qobj`
-+            Quantum object of type 'ket'.
-+
-+        Returns
-+        -------
-+        elem : complex
-+            Complex valued matrix element.
-+
-+        Notes
-+        -----
-+        It is slightly more computationally efficient to use a ket
-+        vector for the 'bra' input.
-+
-+        """
-+        if not self.isoper:
-+            raise TypeError("Can only get matrix elements for an operator.")
-+        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
-+            msg = "Can only calculate matrix elements between a bra and a ket."
-+            raise TypeError(msg)
-+        left, op, right = bra.data, self.data, ket.data
-+        if ket.isbra:
-+            right = right.adjoint()
-+        return _data.inner_op(left, op, right, bra.isket)
-+
-+    def overlap(self, other):
-+        """
-+        Overlap between two state vectors or two operators.
-+
-+        Gives the overlap (inner product) between the current bra or ket Qobj
-+        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
-+        when one of the Qobj is an operator/density matrix.
-+
-+        Parameters
-+        ----------
-+        other : :class:`qutip.Qobj`
-+            Quantum object for a state vector of type 'ket', 'bra' or density
-+            matrix.
-+
-+        Returns
-+        -------
-+        overlap : complex
-+            Complex valued overlap.
-+
-+        Raises
-+        ------
-+        TypeError
-+            Can only calculate overlap between a bra, ket and density matrix
-+            quantum objects.
-+        """
-+        if not isinstance(other, Qobj):
-+            raise TypeError("".join([
-+                "cannot calculate overlap with non-quantum object ",
-+                repr(other),
-+            ]))
-+        if (
-+            self.type not in ('ket', 'bra', 'oper')
-+            or other.type not in ('ket', 'bra', 'oper')
-+        ):
-+            msg = "only bras, kets and density matrices have defined overlaps"
-+            raise TypeError(msg)
-+        left, right = self._data.adjoint(), other.data
-+        if self.isoper or other.isoper:
-+            if not self.isoper:
-+                left = _data.project(left)
-+            if not other.isoper:
-+                right = _data.project(right)
-+            return _data.trace(_data.matmul(left, right))
-+        if other.isbra:
-+            right = right.adjoint()
-+        out = _data.inner(left, right, self.isket)
-+        if self.isket and other.isbra:
-+            # In this particular case, we've basically doing
-+            #   conj(other.overlap(self))
-+            # so we take care to conjugate the output.
-+            out = np.conj(out)
-+        return out
-+
-+    def eigenstates(self, sparse=False, sort='low', eigvals=0,
-+                    tol=0, maxiter=100000, phase_fix=None):
-+        """Eigenstates and eigenenergies.
-+
-+        Eigenstates and eigenenergies are defined for operators and
-+        superoperators only.
-+
-+        Parameters
-+        ----------
-+        sparse : bool
-+            Use sparse Eigensolver
-+
-+        sort : str
-+            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
-+
-+        eigvals : int
-+            Number of requested eigenvalues. Default is all eigenvalues.
-+
-+        tol : float
-+            Tolerance used by sparse Eigensolver (0 = machine precision).
-+            The sparse solver may not converge if the tolerance is set too low.
-+
-+        maxiter : int
-+            Maximum number of iterations performed by sparse solver (if used).
-+
-+        phase_fix : int, None
-+            If not None, set the phase of each kets so that ket[phase_fix,0]
-+            is real positive.
-+
-+        Returns
-+        -------
-+        eigvals : array
-+            Array of eigenvalues for operator.
-+
-+        eigvecs : array
-+            Array of quantum operators representing the oprator eigenkets.
-+            Order of eigenkets is determined by order of eigenvalues.
-+
-+        Notes
-+        -----
-+        The sparse eigensolver is much slower than the dense version.
-+        Use sparse only if memory requirements demand it.
-+
-+        """
-+        if isinstance(self.data, _data.CSR) and sparse:
-+            evals, evecs = _data.eigs_csr(self.data,
-+                                          isherm=self._isherm,
-+                                          sort=sort, eigvals=eigvals, tol=tol,
-+                                          maxiter=maxiter)
-+        elif isinstance(self.data, _data.CSR):
-+            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
-+                                      isherm=self._isherm,
-+                                      sort=sort, eigvals=eigvals)
-+        else:
-+            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
-+                                      sort=sort, eigvals=eigvals)
-+
-+        if self.type == 'super':
-+            new_dims = [self.dims[0], [1]]
-+            new_type = 'operator-ket'
-+        else:
-+            new_dims = [self.dims[0], [1]*len(self.dims[0])]
-+            new_type = 'ket'
-+        ekets = np.empty((evecs.shape[1],), dtype=object)
-+        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
-+                    for vec in _data.split_columns(evecs, False)]
-+        norms = np.array([ket.norm() for ket in ekets])
-+        if phase_fix is None:
-+            phase = np.array([1] * len(ekets))
-+        else:
-+            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
-+                              if ket[phase_fix, 0] else 1
-+                              for ket in ekets])
-+        return evals, ekets / norms * phase
-+
-+    def eigenenergies(self, sparse=False, sort='low',
-+                      eigvals=0, tol=0, maxiter=100000):
-+        """Eigenenergies of a quantum object.
-+
-+        Eigenenergies (eigenvalues) are defined for operators or superoperators
-+        only.
-+
-+        Parameters
-+        ----------
-+        sparse : bool
-+            Use sparse Eigensolver
-+        sort : str
-+            Sort eigenvalues 'low' to high, or 'high' to low.
-+        eigvals : int
-+            Number of requested eigenvalues. Default is all eigenvalues.
-+        tol : float
-+            Tolerance used by sparse Eigensolver (0=machine precision).
-+            The sparse solver may not converge if the tolerance is set too low.
-+        maxiter : int
-+            Maximum number of iterations performed by sparse solver (if used).
-+
-+        Returns
-+        -------
-+        eigvals : array
-+            Array of eigenvalues for operator.
-+
-+        Notes
-+        -----
-+        The sparse eigensolver is much slower than the dense version.
-+        Use sparse only if memory requirements demand it.
-+
-+        """
-+        # TODO: consider another way of handling the dispatch here.
-+        if isinstance(self.data, _data.CSR) and sparse:
-+            return _data.eigs_csr(self.data,
-+                                  vecs=False,
-+                                  isherm=self._isherm,
-+                                  sort=sort, eigvals=eigvals,
-+                                  tol=tol, maxiter=maxiter)
-+        elif isinstance(self.data, _data.CSR):
-+            return _data.eigs(_data.to(_data.Dense, self.data),
-+                              vecs=False, isherm=self._isherm,
-+                              sort=sort, eigvals=eigvals)
-+
-+        return _data.eigs(self.data,
-+                          vecs=False,
-+                          isherm=self._isherm, sort=sort, eigvals=eigvals)
-+
-+    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
-+        """Ground state Eigenvalue and Eigenvector.
-+
-+        Defined for quantum operators or superoperators only.
-+
-+        Parameters
-+        ----------
-+        sparse : bool
-+            Use sparse Eigensolver
-+        tol : float
-+            Tolerance used by sparse Eigensolver (0 = machine precision).
-+            The sparse solver may not converge if the tolerance is set too low.
-+        maxiter : int
-+            Maximum number of iterations performed by sparse solver (if used).
-+        safe : bool (default=True)
-+            Check for degenerate ground state
-+
-+        Returns
-+        -------
-+        eigval : float
-+            Eigenvalue for the ground state of quantum operator.
-+        eigvec : :class:`qutip.Qobj`
-+            Eigenket for the ground state of quantum operator.
-+
-+        Notes
-+        -----
-+        The sparse eigensolver is much slower than the dense version.
-+        Use sparse only if memory requirements demand it.
-+        """
-+        eigvals = 2 if safe else 1
-+        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
-+                                        tol=tol, maxiter=maxiter)
-+
-+        if safe:
-+            tol = tol or settings.core['atol']
-+            # This tol should be less strick than the tol for the eigensolver
-+            # so it's numerical errors are not seens as degenerate states.
-+            if (evals[1]-evals[0]) <= 10 * tol:
-+                warnings.warn("Ground state may be degenerate.", UserWarning)
-+        return evals[0], evecs[0]
-+
-+    def dnorm(self, B=None):
-+        """Calculates the diamond norm, or the diamond distance to another
-+        operator.
-+
-+        Parameters
-+        ----------
-+        B : :class:`qutip.Qobj` or None
-+            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
-+            between this operator and B is returned instead of the diamond norm.
-+
-+        Returns
-+        -------
-+        d : float
-+            Either the diamond norm of this operator, or the diamond distance
-+            from this operator to B.
-+
-+        """
-+        return mts.dnorm(self, B)
-+
-+    @property
-+    def ishp(self):
-+        # FIXME: this needs to be cached in the same ways as isherm.
-+        if self.type in ["super", "oper"]:
-+            try:
-+                J = to_choi(self)
-+                return J.isherm
-+            except:
-+                return False
-+        else:
-+            return False
-+
-+    @property
-+    def iscp(self):
-+        # FIXME: this needs to be cached in the same ways as isherm.
-+        if self.type not in ["super", "oper"]:
-+            return False
-+        # We can test with either Choi or chi, since the basis
-+        # transformation between them is unitary and hence preserves
-+        # the CP and TP conditions.
-+        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
-+        # If J isn't hermitian, then that could indicate either that J is not
-+        # normal, or is normal, but has complex eigenvalues.  In either case,
-+        # it makes no sense to then demand that the eigenvalues be
-+        # non-negative.
-+        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
-+
-+    @property
-+    def istp(self):
-+        if self.type not in ['super', 'oper']:
-+            return False
-+        # Normalize to a super of type choi or chi.
-+        # We can test with either Choi or chi, since the basis
-+        # transformation between them is unitary and hence
-+        # preserves the CP and TP conditions.
-+        if self.issuper and self.superrep in ('choi', 'chi'):
-+            qobj = self
-+        else:
-+            qobj = to_choi(self)
-+        # Possibly collapse dims.
-+        if any([len(index) > 1
-+                for super_index in qobj.dims
-+                for index in super_index]):
-+            qobj = Qobj(qobj.data,
-+                        dims=collapse_dims_super(qobj.dims),
-+                        type=qobj.type,
-+                        superrep=qobj.superrep,
-+                        copy=False)
-+        # We use the condition from John Watrous' lecture notes,
-+        # Tr_1(J(Phi)) = identity_2.
-+        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
-+        # Theory of Quantum Information (Fall 2011), theorem 5.4.
-+        tr_oper = qobj.ptrace([0])
-+        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
-+                           atol=settings.core['atol'])
-+
-+    @property
-+    def iscptp(self):
-+        if not (self.issuper or self.isoper):
-+            return False
-+        reps = ('choi', 'chi')
-+        q_oper = to_choi(self) if self.superrep not in reps else self
-+        return q_oper.iscp and q_oper.istp
-+
-+    @property
-+    def isherm(self):
-+        if self._isherm is not None:
-+            return self._isherm
-+        self._isherm = _data.isherm(self._data)
-+        return self._isherm
-+
-+    @isherm.setter
-+    def isherm(self, isherm):
-+        self._isherm = isherm
-+
-+    def _calculate_isunitary(self):
-+        """
-+        Checks whether qobj is a unitary matrix
-+        """
-+        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
-+            return False
-+        cmp = _data.matmul(self._data, self._data.adjoint())
-+        iden = _data.identity(self.shape[0], dtype=type(cmp))
-+        return _data.iszero(_data.sub(cmp, iden),
-+                            tol=settings.core['atol'])
-+
-+    @property
-+    def isunitary(self):
-+        if self._isunitary is not None:
-+            return self._isunitary
-+        self._isunitary = self._calculate_isunitary()
-+        return self._isunitary
-+
-+    @property
-+    def shape(self): return self.data.shape
-+
-+    isbra = property(isbra)
-+    isket = property(isket)
-+    isoper = property(isoper)
-+    issuper = property(issuper)
-+    isoperbra = property(isoperbra)
-+    isoperket = property(isoperket)
-+
-+
-+def ptrace(Q, sel):
-+    """
-+    Partial trace of the Qobj with selected components remaining.
-+
-+    Parameters
-+    ----------
-+    Q : :class:`qutip.Qobj`
-+        Composite quantum object.
-+    sel : int/list
-+        An ``int`` or ``list`` of components to keep after partial trace.
-+
-+    Returns
-+    -------
-+    oper : :class:`qutip.Qobj`
-+        Quantum object representing partial trace with selected components
-+        remaining.
-+
-+    Notes
-+    -----
-+    This function is for legacy compatibility only. It is recommended to use
-+    the ``ptrace()`` Qobj method.
-+    """
-+    if not isinstance(Q, Qobj):
-+        raise TypeError("Input is not a quantum object")
-+    return Q.ptrace(sel)
-+
-+
-+# TRAILING IMPORTS
-+# We do a few imports here to avoid circular dependencies.
-+from qutip.core.superop_reps import to_choi
-+from qutip.core.superoperator import vector_to_operator, operator_to_vector
-+from qutip.core.tensor import tensor_swap, tensor
-+from qutip.core import metrics as mts
-diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
-index c6d3762f..6d4be82b 100644
---- a/qutip/core/semidefinite.py
-+++ b/qutip/core/semidefinite.py
-@@ -1,208 +1,208 @@
--# -*- coding: utf-8 -*-
--
--"""
--This module implements internal-use functions for semidefinite programming.
--"""
--
--__all__ = [
--    'dnorm_problem',
--    'dnorm_sparse_problem',
--]
--
--import collections
--import functools
--
--import numpy as np
--import scipy.sparse as sp
--# Conditionally import CVXPY
--try:
--    import cvxpy
--except ImportError:
--    cvxpy = None
--
--from .tensor import tensor_swap
--from .operators import qeye
--from ..logging_utils import get_logger
--logger = get_logger('qutip.core.semidefinite')
--
--Complex = collections.namedtuple('Complex', ['re', 'im'])
--
--
--def complex_var(rows=1, cols=1, name=None):
--    return Complex(
--        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
--        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
--    )
--
--
--def herm(*Xs):
--    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
--
--
--def pos_noherm(*Xs):
--    return [
--        cvxpy.bmat([
--            [X.re, -X.im],
--            [X.im, X.re]
--        ]) >> 0
--        for X in Xs
--    ]
--
--
--def pos(*Xs):
--    return pos_noherm(*Xs) + herm(*Xs)
--
--
--def dens(*rhos):
--    return pos(*rhos) + [
--        cvxpy.trace(rho.re) == 1
--        for rho in rhos
--    ]
--
--
--def _arr_to_complex(A):
--    if np.iscomplex(A).any():
--        return Complex(re=A.real, im=A.imag)
--    return Complex(re=A, im=np.zeros_like(A))
--
--
--def kron(A, B):
--    if isinstance(A, np.ndarray):
--        A = _arr_to_complex(A)
--    if isinstance(B, np.ndarray):
--        B = _arr_to_complex(B)
--
--    return Complex(
--        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
--        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
--    )
--
--
--def conj(W, A):
--    U, V = W.re, W.im
--    A, B = A.re, A.im
--    return Complex(
--        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
--        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
--    )
--
--
--def bmat(B):
--    return Complex(
--        re=cvxpy.bmat([[element.re for element in row] for row in B]),
--        im=cvxpy.bmat([[element.re for element in row] for row in B]),
--    )
--
--
--def dag(X):
--    return Complex(re=X.re.T, im=-X.im.T)
--
--
--def memoize(fn):
--    cache = {}
--
--    @functools.wraps(fn)
--    def memoized(*args):
--        if args in cache:
--            return cache[args]
--        else:
--            ret = fn(*args)
--            cache[args] = ret
--            return ret
--
--    memoized.reset_cache = cache.clear
--    return memoized
--
--
--def qudit_swap(dim):
--    # We should likely generalize this and include it in qip.gates.
--    W = qeye([dim, dim])
--    return tensor_swap(W, (0, 1))
--
--
--@memoize
--def initialize_constraints_on_dnorm_problem(dim):
--    # Start assembling constraints and variables.
--    constraints = []
--
--    # Make a complex variable for X.
--    X = complex_var(dim ** 2, dim ** 2, "X")
--
--    # Make complex variables for rho0 and rho1.
--    rho0 = complex_var(dim, dim, "rho0")
--    rho1 = complex_var(dim, dim, "rho1")
--    constraints += dens(rho0, rho1)
--
--    # Finally, add the tricky positive semidefinite constraint.
--    # Since we're using column-stacking, but Watrous used row-stacking,
--    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
--    # as CVXPY requires that the constant be the first argument. To solve this,
--    # We conjugate by SWAP.
--    W = qudit_swap(dim).full()
--    W = Complex(re=W.real, im=W.imag)
--    Rho0 = conj(W, kron(np.eye(dim), rho0))
--    Rho1 = conj(W, kron(np.eye(dim), rho1))
--
--    Y = cvxpy.bmat([
--        [Rho0.re, X.re,      -Rho0.im, -X.im],
--        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
--
--        [Rho0.im, X.im,      Rho0.re, X.re],
--        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
--    ])
--    constraints += [Y >> 0]
--
--    logger.debug("Using %d constraints.", len(constraints))
--
--    return X, constraints
--
--
--def dnorm_problem(dim):
--    X, constraints = initialize_constraints_on_dnorm_problem(dim)
--    Jr = cvxpy.Parameter((dim**2, dim**2))
--    Ji = cvxpy.Parameter((dim**2, dim**2))
--    # The objective, however, depends on J.
--    objective = cvxpy.Maximize(cvxpy.trace(
--        Jr.T @ X.re + Ji.T @ X.im
--    ))
--    problem = cvxpy.Problem(objective, constraints)
--    return problem, Jr, Ji
--
--
--def dnorm_sparse_problem(dim, J_dat):
--    X, constraints = initialize_constraints_on_dnorm_problem(dim)
--    J_val = J_dat.tocoo()
--
--    def adapt_sparse_params(A_val, dim):
--        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
--        # can not solve with parameters that aresparse matrices directly.
--        # Solutions have to be made through calling cvxpy.reshape on
--        # the original sparse matrix.
--        side_size = dim**2
--        A_nnz = cvxpy.Parameter(A_val.nnz)
--
--        A_data = np.ones(A_nnz.size)
--        A_rows = A_val.row * side_size + A_val.col
--        A_cols = np.arange(A_nnz.size)
--        # We are pushing the data on the location of the nonzero elements
--        # to the nonzero rows of A_indexer
--        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
--                                  shape=(side_size**2, A_nnz.size))
--        # We get finaly the sparse matrix A which we wanted
--        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
--        A_nnz.value = A_val.data
--        return A
--
--    Jr_val = J_val.real
--    Jr = adapt_sparse_params(Jr_val, dim)
--
--    Ji_val = J_val.imag
--    Ji = adapt_sparse_params(Ji_val, dim)
--
--    # The objective, however, depends on J.
--    objective = cvxpy.Maximize(cvxpy.trace(
--        Jr.T @ X.re + Ji.T @ X.im
--    ))
--
--    problem = cvxpy.Problem(objective, constraints)
--    return problem
-+# -*- coding: utf-8 -*-
-+
-+"""
-+This module implements internal-use functions for semidefinite programming.
-+"""
-+
-+__all__ = [
-+    'dnorm_problem',
-+    'dnorm_sparse_problem',
-+]
-+
-+import collections
-+import functools
-+
-+import numpy as np
-+import scipy.sparse as sp
-+# Conditionally import CVXPY
-+try:
-+    import cvxpy
-+except ImportError:
-+    cvxpy = None
-+
-+from .tensor import tensor_swap
-+from .operators import qeye
-+from ..logging_utils import get_logger
-+logger = get_logger('qutip.core.semidefinite')
-+
-+Complex = collections.namedtuple('Complex', ['re', 'im'])
-+
-+
-+def complex_var(rows=1, cols=1, name=None):
-+    return Complex(
-+        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
-+        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
-+    )
-+
-+
-+def herm(*Xs):
-+    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
-+
-+
-+def pos_noherm(*Xs):
-+    return [
-+        cvxpy.bmat([
-+            [X.re, -X.im],
-+            [X.im, X.re]
-+        ]) >> 0
-+        for X in Xs
-+    ]
-+
-+
-+def pos(*Xs):
-+    return pos_noherm(*Xs) + herm(*Xs)
-+
-+
-+def dens(*rhos):
-+    return pos(*rhos) + [
-+        cvxpy.trace(rho.re) == 1
-+        for rho in rhos
-+    ]
-+
-+
-+def _arr_to_complex(A):
-+    if np.iscomplex(A).any():
-+        return Complex(re=A.real, im=A.imag)
-+    return Complex(re=A, im=np.zeros_like(A))
-+
-+
-+def kron(A, B):
-+    if isinstance(A, np.ndarray):
-+        A = _arr_to_complex(A)
-+    if isinstance(B, np.ndarray):
-+        B = _arr_to_complex(B)
-+
-+    return Complex(
-+        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
-+        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
-+    )
-+
-+
-+def conj(W, A):
-+    U, V = W.re, W.im
-+    A, B = A.re, A.im
-+    return Complex(
-+        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
-+        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
-+    )
-+
-+
-+def bmat(B):
-+    return Complex(
-+        re=cvxpy.bmat([[element.re for element in row] for row in B]),
-+        im=cvxpy.bmat([[element.re for element in row] for row in B]),
-+    )
-+
-+
-+def dag(X):
-+    return Complex(re=X.re.T, im=-X.im.T)
-+
-+
-+def memoize(fn):
-+    cache = {}
-+
-+    @functools.wraps(fn)
-+    def memoized(*args):
-+        if args in cache:
-+            return cache[args]
-+        else:
-+            ret = fn(*args)
-+            cache[args] = ret
-+            return ret
-+
-+    memoized.reset_cache = cache.clear
-+    return memoized
-+
-+
-+def qudit_swap(dim):
-+    # We should likely generalize this and include it in qip.gates.
-+    W = qeye([dim, dim])
-+    return tensor_swap(W, (0, 1))
-+
-+
-+@memoize
-+def initialize_constraints_on_dnorm_problem(dim):
-+    # Start assembling constraints and variables.
-+    constraints = []
-+
-+    # Make a complex variable for X.
-+    X = complex_var(dim ** 2, dim ** 2, "X")
-+
-+    # Make complex variables for rho0 and rho1.
-+    rho0 = complex_var(dim, dim, "rho0")
-+    rho1 = complex_var(dim, dim, "rho1")
-+    constraints += dens(rho0, rho1)
-+
-+    # Finally, add the tricky positive semidefinite constraint.
-+    # Since we're using column-stacking, but Watrous used row-stacking,
-+    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
-+    # as CVXPY requires that the constant be the first argument. To solve this,
-+    # We conjugate by SWAP.
-+    W = qudit_swap(dim).full()
-+    W = Complex(re=W.real, im=W.imag)
-+    Rho0 = conj(W, kron(np.eye(dim), rho0))
-+    Rho1 = conj(W, kron(np.eye(dim), rho1))
-+
-+    Y = cvxpy.bmat([
-+        [Rho0.re, X.re,      -Rho0.im, -X.im],
-+        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
-+
-+        [Rho0.im, X.im,      Rho0.re, X.re],
-+        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
-+    ])
-+    constraints += [Y >> 0]
-+
-+    logger.debug("Using %d constraints.", len(constraints))
-+
-+    return X, constraints
-+
-+
-+def dnorm_problem(dim):
-+    X, constraints = initialize_constraints_on_dnorm_problem(dim)
-+    Jr = cvxpy.Parameter((dim**2, dim**2))
-+    Ji = cvxpy.Parameter((dim**2, dim**2))
-+    # The objective, however, depends on J.
-+    objective = cvxpy.Maximize(cvxpy.trace(
-+        Jr.T @ X.re + Ji.T @ X.im
-+    ))
-+    problem = cvxpy.Problem(objective, constraints)
-+    return problem, Jr, Ji
-+
-+
-+def dnorm_sparse_problem(dim, J_dat):
-+    X, constraints = initialize_constraints_on_dnorm_problem(dim)
-+    J_val = J_dat.tocoo()
-+
-+    def adapt_sparse_params(A_val, dim):
-+        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
-+        # can not solve with parameters that aresparse matrices directly.
-+        # Solutions have to be made through calling cvxpy.reshape on
-+        # the original sparse matrix.
-+        side_size = dim**2
-+        A_nnz = cvxpy.Parameter(A_val.nnz)
-+
-+        A_data = np.ones(A_nnz.size)
-+        A_rows = A_val.row * side_size + A_val.col
-+        A_cols = np.arange(A_nnz.size)
-+        # We are pushing the data on the location of the nonzero elements
-+        # to the nonzero rows of A_indexer
-+        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
-+                                  shape=(side_size**2, A_nnz.size))
-+        # We get finaly the sparse matrix A which we wanted
-+        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
-+        A_nnz.value = A_val.data
-+        return A
-+
-+    Jr_val = J_val.real
-+    Jr = adapt_sparse_params(Jr_val, dim)
-+
-+    Ji_val = J_val.imag
-+    Ji = adapt_sparse_params(Ji_val, dim)
-+
-+    # The objective, however, depends on J.
-+    objective = cvxpy.Maximize(cvxpy.trace(
-+        Jr.T @ X.re + Ji.T @ X.im
-+    ))
-+
-+    problem = cvxpy.Problem(objective, constraints)
-+    return problem
-diff --git a/qutip/core/states.py b/qutip/core/states.py
-index c030e33d..10d5788c 100644
---- a/qutip/core/states.py
-+++ b/qutip/core/states.py
-@@ -1,1342 +1,1342 @@
--__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
--           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
--           'qstate', 'ket', 'bra', 'state_number_enumerate',
--           'state_number_index', 'state_index_number', 'state_number_qobj',
--           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
--           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
--           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
--           'enr_thermal_dm']
--
--import itertools
--import numbers
--import warnings
--
--import numpy as np
--import scipy.sparse as sp
--import itertools
--
--from . import data as _data
--from .qobj import Qobj
--from .operators import jmat, displace, qdiags
--from .tensor import tensor
--from .. import settings
--
--def _promote_to_zero_list(arg, length):
--    """
--    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
--    to `[0]*length`.  All other inputs are checked that they match the correct
--    form.
--
--    Returns
--    -------
--    list_ : list
--        A list of integers of length `length`.
--    """
--    if arg is None:
--        arg = [0]*length
--    elif not isinstance(arg, list):
--        arg = [arg]
--    if not len(arg) == length:
--        raise ValueError("All list inputs must be the same length.")
--    if all(isinstance(x, numbers.Integral) for x in arg):
--        return arg
--    raise TypeError("Dimensions must be an integer or list of integers.")
--
--
--def basis(dimensions, n=None, offset=None, *, dtype=None):
--    """Generates the vector representation of a Fock state.
--
--    Parameters
--    ----------
--    dimensions : int or list of ints
--        Number of Fock states in Hilbert space.  If a list, then the resultant
--        object will be a tensor product over spaces with those dimensions.
--
--    n : int or list of ints, optional (default 0 for all dimensions)
--        Integer corresponding to desired number state, defaults to 0 for all
--        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
--        ``dimensions`` is a list, then ``n`` must either be omitted or a list
--        of equal length.
--
--    offset : int or list of ints, optional (default 0 for all dimensions)
--        The lowest number state that is included in the finite number state
--        representation of the state in the relevant dimension.
--
--    dtype : type or str
--        storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    state : :class:`qutip.Qobj`
--      Qobj representing the requested number state ``|n>``.
--
--    Examples
--    --------
--    >>> basis(5,2) # doctest: +SKIP
--    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
--    Qobj data =
--    [[ 0.+0.j]
--     [ 0.+0.j]
--     [ 1.+0.j]
--     [ 0.+0.j]
--     [ 0.+0.j]]
--    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
--    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
--    Qobj data =
--    [[0.]
--     [0.]
--     [1.]
--     [0.]
--     [0.]
--     [0.]
--     [0.]
--     [0.]]
--
--
--    Notes
--    -----
--    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
--
--        basis(N, 0) = ground state
--
--    but in the qotoolbox::
--
--        basis(N, 1) = ground state
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    # Promote all parameters to lists to simplify later logic.
--    if not isinstance(dimensions, list):
--        dimensions = [dimensions]
--    n_dimensions = len(dimensions)
--    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
--                                  _promote_to_zero_list(offset, n_dimensions))]
--    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
--        raise ValueError("All dimensions must be >= 0.")
--    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
--        raise ValueError("All basis indices must be "
--                         "`offset <= n < dimension+offset`.")
--    location, size = 0, 1
--    for m, dimension in zip(reversed(ns), reversed(dimensions)):
--        location += m*size
--        size *= dimension
--
--    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
--    return Qobj(data,
--                dims=[dimensions, [1]*n_dimensions],
--                type='ket',
--                isherm=False,
--                isunitary=False,
--                copy=False)
--
--
--def qutrit_basis(*, dtype=None):
--    """Basis states for a three level system (qutrit)
--
--    dtype : type or str
--        storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    qstates : array
--        Array of qutrit basis vectors
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    out = np.empty((3,), dtype=object)
--    out[:] = [
--        basis(3, 0, dtype=dtype),
--        basis(3, 1, dtype=dtype),
--        basis(3, 2, dtype=dtype),
--    ]
--    return out
--
--_COHERENT_METHODS = ('operator', 'analytic')
--
--
--def coherent(N, alpha, offset=0, method=None, *, dtype=None):
--    """Generates a coherent state with eigenvalue alpha.
--
--    Constructed using displacement operator on vacuum state.
--
--    Parameters
--    ----------
--    N : int
--        Number of Fock states in Hilbert space.
--
--    alpha : float/complex
--        Eigenvalue of coherent state.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the state. Using a non-zero offset will make the
--        default method 'analytic'.
--
--    method : string {'operator', 'analytic'}
--        Method for generating coherent state.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    state : qobj
--        Qobj quantum object for coherent state
--
--    Examples
--    --------
--    >>> coherent(5,0.25j) # doctest: +SKIP
--    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
--    Qobj data =
--    [[  9.69233235e-01+0.j        ]
--     [  0.00000000e+00+0.24230831j]
--     [ -4.28344935e-02+0.j        ]
--     [  0.00000000e+00-0.00618204j]
--     [  7.80904967e-04+0.j        ]]
--
--    Notes
--    -----
--    Select method 'operator' (default) or 'analytic'. With the
--    'operator' method, the coherent state is generated by displacing
--    the vacuum state using the displacement operator defined in the
--    truncated Hilbert space of size 'N'. This method guarantees that the
--    resulting state is normalized. With 'analytic' method the coherent state
--    is generated using the analytical formula for the coherent state
--    coefficients in the Fock basis. This method does not guarantee that the
--    state is normalized if truncated to a small number of Fock states,
--    but would in that case give more accurate coefficients.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    if offset < 0:
--        raise ValueError('Offset must be non-negative')
--
--    if method is None:
--        method = "operator" if offset == 0 else "analytic"
--
--    if method == "operator":
--        if offset != 0:
--            raise ValueError(
--                "The method 'operator' does not support offset != 0. Please"
--                " select another method or set the offset to zero."
--            )
--        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
--
--    elif method == "analytic":
--        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
--        sqrtn[0] = 1  # Get rid of divide by zero warning
--        data = alpha / sqrtn
--        if offset == 0:
--            data[0] = np.exp(-abs(alpha)**2 / 2.0)
--        else:
--            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
--            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
--        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
--        return Qobj(sqrtn,
--                    dims=[[N], [1]],
--                    type='ket',
--                    copy=False).to(dtype)
--    raise TypeError(
--        "The method option can only take values in " + repr(_COHERENT_METHODS)
--    )
--
--
--def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
--    """Density matrix representation of a coherent state.
--
--    Constructed via outer product of :func:`qutip.states.coherent`
--
--    Parameters
--    ----------
--    N : int
--        Number of Fock states in Hilbert space.
--
--    alpha : float/complex
--        Eigenvalue for coherent state.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the state.
--
--    method : string {'operator', 'analytic'}
--        Method for generating coherent density matrix.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    dm : qobj
--        Density matrix representation of coherent state.
--
--    Examples
--    --------
--    >>> coherent_dm(3,0.25j) # doctest: +SKIP
--    Quantum object: dims = [[3], [3]], \
--shape = [3, 3], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
--     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
--     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
--        ]]
--
--    Notes
--    -----
--    Select method 'operator' (default) or 'analytic'. With the
--    'operator' method, the coherent density matrix is generated by displacing
--    the vacuum state using the displacement operator defined in the
--    truncated Hilbert space of size 'N'. This method guarantees that the
--    resulting density matrix is normalized. With 'analytic' method the coherent
--    density matrix is generated using the analytical formula for the coherent
--    state coefficients in the Fock basis. This method does not guarantee that
--    the state is normalized if truncated to a small number of Fock states,
--    but would in that case give more accurate coefficients.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
--
--
--def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
--    """Density matrix representation of a Fock state
--
--    Constructed via outer product of :func:`qutip.states.fock`.
--
--    Parameters
--    ----------
--    dimensions : int or list of ints
--        Number of Fock states in Hilbert space.  If a list, then the resultant
--        object will be a tensor product over spaces with those dimensions.
--
--    n : int or list of ints, optional (default 0 for all dimensions)
--        Integer corresponding to desired number state, defaults to 0 for all
--        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
--        ``dimensions`` is a list, then ``n`` must either be omitted or a list
--        of equal length.
--
--    offset : int or list of ints, optional (default 0 for all dimensions)
--        The lowest number state that is included in the finite number state
--        representation of the state in the relevant dimension.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    dm : qobj
--        Density matrix representation of Fock state.
--
--    Examples
--    --------
--     >>> fock_dm(3,1) # doctest: +SKIP
--     Quantum object: dims = [[3], [3]], \
--shape = [3, 3], type = oper, isHerm = True
--     Qobj data =
--     [[ 0.+0.j  0.+0.j  0.+0.j]
--      [ 0.+0.j  1.+0.j  0.+0.j]
--      [ 0.+0.j  0.+0.j  0.+0.j]]
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
--
--
--def fock(dimensions, n=None, offset=None, *, dtype=None):
--    """Bosonic Fock (number) state.
--
--    Same as :func:`qutip.states.basis`.
--
--    Parameters
--    ----------
--    dimensions : int or list of ints
--        Number of Fock states in Hilbert space.  If a list, then the resultant
--        object will be a tensor product over spaces with those dimensions.
--
--    n : int or list of ints, optional (default 0 for all dimensions)
--        Integer corresponding to desired number state, defaults to 0 for all
--        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
--        ``dimensions`` is a list, then ``n`` must either be omitted or a list
--        of equal length.
--
--    offset : int or list of ints, optional (default 0 for all dimensions)
--        The lowest number state that is included in the finite number state
--        representation of the state in the relevant dimension.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--        Requested number state :math:`\\left|n\\right>`.
--
--    Examples
--    --------
--    >>> fock(4,3) # doctest: +SKIP
--    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
--    Qobj data =
--    [[ 0.+0.j]
--     [ 0.+0.j]
--     [ 0.+0.j]
--     [ 1.+0.j]]
--
--    """
--    return basis(dimensions, n, offset=offset, dtype=dtype)
--
--
--def thermal_dm(N, n, method='operator', *, dtype=None):
--    """Density matrix for a thermal state of n particles
--
--    Parameters
--    ----------
--    N : int
--        Number of basis states in Hilbert space.
--
--    n : float
--        Expectation value for number of particles in thermal state.
--
--    method : string {'operator', 'analytic'}
--        ``string`` that sets the method used to generate the
--        thermal state probabilities
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    dm : qobj
--        Thermal state density matrix.
--
--    Examples
--    --------
--    >>> thermal_dm(5, 1) # doctest: +SKIP
--    Quantum object: dims = [[5], [5]], \
--shape = [5, 5], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.51612903  0.          0.          0.          0.        ]
--     [ 0.          0.25806452  0.          0.          0.        ]
--     [ 0.          0.          0.12903226  0.          0.        ]
--     [ 0.          0.          0.          0.06451613  0.        ]
--     [ 0.          0.          0.          0.          0.03225806]]
--
--
--    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
--    Quantum object: dims = [[5], [5]], \
--shape = [5, 5], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.5      0.       0.       0.       0.     ]
--     [ 0.       0.25     0.       0.       0.     ]
--     [ 0.       0.       0.125    0.       0.     ]
--     [ 0.       0.       0.       0.0625   0.     ]
--     [ 0.       0.       0.       0.       0.03125]]
--
--    Notes
--    -----
--    The 'operator' method (default) generates
--    the thermal state using the truncated number operator ``num(N)``. This
--    is the method that should be used in computations. The
--    'analytic' method uses the analytic coefficients derived in
--    an infinite Hilbert space. The analytic form is not necessarily normalized,
--    if truncated too aggressively.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    if n == 0:
--        return fock_dm(N, 0, dtype=dtype)
--    else:
--        i = np.arange(N)
--        if method == 'operator':
--            beta = np.log(1.0 / n + 1.0)
--            diags = np.exp(-beta * i)
--            diags = diags / np.sum(diags)
--            # populates diagonal terms using truncated operator expression
--
--        elif method == 'analytic':
--            # populates diagonal terms using analytic values
--            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
--        else:
--            raise ValueError("The method option can only take "
--                             "values 'operator' or 'analytic'")
--        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
--        out._isherm = True
--        return out
--
--
--def maximally_mixed_dm(N, *, dtype=None):
--    """
--    Returns the maximally mixed density matrix for a Hilbert space of
--    dimension N.
--
--    Parameters
--    ----------
--    N : int
--        Number of basis states in Hilbert space.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    dm : qobj
--        Thermal state density matrix.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    if not isinstance(N, numbers.Integral) or N <= 0:
--        raise ValueError("N must be integer N > 0")
--    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
--                type='oper', isherm=True, isunitary=(N == 1), copy=False)
--
--
--def ket2dm(Q):
--    """
--    Takes input ket or bra vector and returns density matrix formed by outer
--    product.  This is completely identical to calling `Q.proj()`.
--
--    Parameters
--    ----------
--    Q : qobj
--        Ket or bra type quantum object.
--
--    Returns
--    -------
--    dm : qobj
--        Density matrix formed by outer product of `Q`.
--
--    Examples
--    --------
--    >>> x=basis(3,2)
--    >>> ket2dm(x) # doctest: +SKIP
--    Quantum object: dims = [[3], [3]], \
--shape = [3, 3], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.+0.j  0.+0.j  0.+0.j]
--     [ 0.+0.j  0.+0.j  0.+0.j]
--     [ 0.+0.j  0.+0.j  1.+0.j]]
--
--    """
--    if Q.isket or Q.isbra:
--        return Q.proj()
--    raise TypeError("Input is not a ket or bra vector.")
--
--
--def projection(N, n, m, offset=None, *, dtype=None):
--    r"""
--    The projection operator that projects state :math:`\lvert m\rangle` on
--    state :math:`\lvert n\rangle`.
--
--    Parameters
--    ----------
--    N : int
--        Number of basis states in Hilbert space.
--
--    n, m : float
--        The number states in the projection.
--
--    offset : int (default 0)
--        The lowest number state that is included in the finite number state
--        representation of the projector.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--         Requested projection operator.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    return basis(N, n, offset=offset, dtype=dtype) @ \
--           basis(N, m, offset=offset, dtype=dtype).dag()
--
--
--def qstate(string, *, dtype=None):
--    r"""Creates a tensor product for a set of qubits in either
--    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
--
--    Parameters
--    ----------
--    string : str
--        String containing 'u' or 'd' for each qubit (ex. 'ududd')
--
--    Returns
--    -------
--    qstate : qobj
--        Qobj for tensor product corresponding to input string.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Notes
--    -----
--    Look at ket and bra for more general functions
--    creating multiparticle states.
--
--    Examples
--    --------
--    >>> qstate('udu') # doctest: +SKIP
--    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
--    Qobj data =
--    [[ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 1.]
--     [ 0.]
--     [ 0.]]
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    n = len(string)
--    if n != (string.count('u') + string.count('d')):
--        raise TypeError('String input to QSTATE must consist ' +
--                        'of "u" and "d" elements only')
--    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
--
--
--#
--# different qubit notation dictionary
--#
--_qubit_dict = {
--    'g': 0,  # ground state
--    'e': 1,  # excited state
--    'u': 0,  # spin up
--    'd': 1,  # spin down
--    'H': 0,  # horizontal polarization
--    'V': 1,  # vertical polarization
--}
--
--
--def _character_to_qudit(x):
--    """
--    Converts a character representing a one-particle state into int.
--    """
--    return _qubit_dict[x] if x in _qubit_dict else int(x)
--
--
--def ket(seq, dim=2, *, dtype=None):
--    """
--    Produces a multiparticle ket state for a list or string,
--    where each element stands for state of the respective particle.
--
--    Parameters
--    ----------
--    seq : str / list of ints or characters
--        Each element defines state of the respective particle.
--        (e.g. [1,1,0,1] or a string "1101").
--        For qubits it is also possible to use the following conventions:
--        - 'g'/'e' (ground and excited state)
--        - 'u'/'d' (spin up and down)
--        - 'H'/'V' (horizontal and vertical polarization)
--        Note: for dimension > 9 you need to use a list.
--
--
--    dim : int (default: 2) / list of ints
--        Space dimension for each particle:
--        int if there are the same, list if they are different.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    ket : qobj
--
--    Examples
--    --------
--    >>> ket("10") # doctest: +SKIP
--    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
--    Qobj data =
--    [[ 0.]
--     [ 0.]
--     [ 1.]
--     [ 0.]]
--
--    >>> ket("Hue") # doctest: +SKIP
--    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
--    Qobj data =
--    [[ 0.]
--     [ 1.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]]
--
--    >>> ket("12", 3) # doctest: +SKIP
--    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
--    Qobj data =
--    [[ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 1.]
--     [ 0.]
--     [ 0.]
--     [ 0.]]
--
--    >>> ket("31", [5, 2]) # doctest: +SKIP
--    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
--    Qobj data =
--    [[ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 0.]
--     [ 1.]
--     [ 0.]
--     [ 0.]]
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    ns = [_character_to_qudit(x) for x in seq]
--    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
--    return basis(dim, ns, dtype=dtype)
--
--
--def bra(seq, dim=2, *, dtype=None):
--    """
--    Produces a multiparticle bra state for a list or string,
--    where each element stands for state of the respective particle.
--
--    Parameters
--    ----------
--    seq : str / list of ints or characters
--        Each element defines state of the respective particle.
--        (e.g. [1,1,0,1] or a string "1101").
--        For qubits it is also possible to use the following conventions:
--
--        - 'g'/'e' (ground and excited state)
--        - 'u'/'d' (spin up and down)
--        - 'H'/'V' (horizontal and vertical polarization)
--
--        Note: for dimension > 9 you need to use a list.
--
--
--    dim : int (default: 2) / list of ints
--        Space dimension for each particle:
--        int if there are the same, list if they are different.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    bra : qobj
--
--    Examples
--    --------
--    >>> bra("10") # doctest: +SKIP
--    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
--    Qobj data =
--    [[ 0.  0.  1.  0.]]
--
--    >>> bra("Hue") # doctest: +SKIP
--    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
--    Qobj data =
--    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
--
--    >>> bra("12", 3) # doctest: +SKIP
--    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
--    Qobj data =
--    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
--
--
--    >>> bra("31", [5, 2]) # doctest: +SKIP
--    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
--    Qobj data =
--    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    return ket(seq, dim=dim, dtype=dtype).dag()
--
--
--def state_number_enumerate(dims, excitations=None):
--    """
--    An iterator that enumerates all the state number tuples (quantum numbers of
--    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
--
--    Example:
--
--        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
--        >>>     print(state) # doctest: +SKIP
--        ( 0  0 )
--        ( 0  1 )
--        ( 1  0 )
--        ( 1  1 )
--
--    Parameters
--    ----------
--    dims : list or array
--        The quantum state dimensions array, as it would appear in a Qobj.
--
--    excitations : integer (None)
--        Restrict state space to states with excitation numbers below or
--        equal to this value.
--
--    Returns
--    -------
--    state_number : tuple
--        Successive state number tuples that can be used in loops and other
--        iterations, using standard state enumeration *by definition*.
--
--    """
--
--    if excitations is None:
--        # in this case, state numbers are a direct product
--        yield from itertools.product(*(range(d) for d in dims))
--        return
--
--    # From here on, excitations is not None
--
--    # General idea of algorithm: add excitations one by one in last mode (idx =
--    # len(dims)-1), and carry over to the next index when the limit is reached.
--    # Keep track of the number of excitations while doing so to avoid having to
--    # do explicit sums over the states.
--    state = (0,)*len(dims)
--    nexc = 0
--    while True:
--        yield state
--        idx = len(dims) - 1
--        state = state[:idx] + (state[idx]+1,)
--        nexc += 1
--        while nexc > excitations or state[idx] >= dims[idx]:
--            # remove all excitations in mode idx, add one in idx-1
--            idx -= 1
--            if idx < 0:
--                return
--            nexc -= state[idx+1] - 1
--            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
--
--
--def state_number_index(dims, state):
--    """
--    Return the index of a quantum state corresponding to state,
--    given a system with dimensions given by dims.
--
--    Example:
--
--        >>> state_number_index([2, 2, 2], [1, 1, 0])
--        6
--
--    Parameters
--    ----------
--    dims : list or array
--        The quantum state dimensions array, as it would appear in a Qobj.
--
--    state : list
--        State number array.
--
--    Returns
--    -------
--    idx : int
--        The index of the state given by `state` in standard enumeration
--        ordering.
--
--    """
--    return np.ravel_multi_index(state, dims)
--
--
--def state_index_number(dims, index):
--    """
--    Return a quantum number representation given a state index, for a system
--    of composite structure defined by dims.
--
--    Example:
--
--        >>> state_index_number([2, 2, 2], 6)
--        [1, 1, 0]
--
--    Parameters
--    ----------
--    dims : list or array
--        The quantum state dimensions array, as it would appear in a Qobj.
--
--    index : integer
--        The index of the state in standard enumeration ordering.
--
--    Returns
--    -------
--    state : tuple
--        The state number tuple corresponding to index `index` in standard
--        enumeration ordering.
--
--    """
--    return np.unravel_index(index, dims)
--
--
--def state_number_qobj(dims, state, *, dtype=None):
--    """
--    Return a Qobj representation of a quantum state specified by the state
--    array `state`.
--
--    Example:
--
--        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
--        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
--shape = [8, 1], type = ket
--        Qobj data =
--        [[ 0.]
--         [ 0.]
--         [ 0.]
--         [ 0.]
--         [ 0.]
--         [ 1.]
--         [ 0.]
--         [ 0.]]
--
--    Parameters
--    ----------
--    dims : list or array
--        The quantum state dimensions array, as it would appear in a Qobj.
--
--    state : list
--        State number array.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    state : :class:`qutip.Qobj`
--        The state as a :class:`qutip.Qobj` instance.
--
--    .. note::
--        Deprecated in QuTiP 5.0, use :func:`basis` instead.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    warnings.warn("basis() is a drop-in replacement for this",
--                  DeprecationWarning)
--    return basis(dims, state, dtype=dtype)
--
--
--# Excitation-number restricted (enr) states
--
--def enr_state_dictionaries(dims, excitations):
--    """
--    Return the number of states, and lookup-dictionaries for translating
--    a state tuple to a state index, and vice versa, for a system with a given
--    number of components and maximum number of excitations.
--
--    Parameters
--    ----------
--    dims: list
--        A list with the number of states in each sub-system.
--
--    excitations : integer
--        The maximum numbers of dimension
--
--    Returns
--    -------
--    nstates, state2idx, idx2state: integer, dict, list
--        The number of states `nstates`, a dictionary for looking up state
--        indices from a state tuple, and a list containing the state tuples
--        ordered by state indices. state2idx and idx2state are reverses of
--        each other, i.e., state2idx[idx2state[idx]] = idx and
--        idx2state[state2idx[state]] = state.
--    """
--    idx2state = list(state_number_enumerate(dims, excitations))
--    state2idx = {state: idx for idx, state in enumerate(idx2state)}
--    nstates = len(idx2state)
--
--    return nstates, state2idx, idx2state
--
--
--def enr_fock(dims, excitations, state, *, dtype=None):
--    """
--    Generate the Fock state representation in a excitation-number restricted
--    state space. The `dims` argument is a list of integers that define the
--    number of quantums states of each component of a composite quantum system,
--    and the `excitations` specifies the maximum number of excitations for
--    the basis states that are to be included in the state space. The `state`
--    argument is a tuple of integers that specifies the state (in the number
--    basis representation) for which to generate the Fock state representation.
--
--    Parameters
--    ----------
--    dims : list
--        A list of the dimensions of each subsystem of a composite quantum
--        system.
--
--    excitations : integer
--        The maximum number of excitations that are to be included in the
--        state space.
--
--    state : list of integers
--        The state in the number basis representation.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    ket : Qobj
--        A Qobj instance that represent a Fock state in the exication-number-
--        restricted state space defined by `dims` and `exciations`.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
--    try:
--        data =_data.one_element[dtype]((nstates, 1),
--                                       (state2idx[tuple(state)], 0), 1)
--    except KeyError:
--        msg = (
--            "The state tuple " + str(tuple(state))
--            + " is not in the restricted state space."
--        )
--        raise ValueError(msg) from None
--    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
--
--
--def enr_thermal_dm(dims, excitations, n, *, dtype=None):
--    """
--    Generate the density operator for a thermal state in the excitation-number-
--    restricted state space defined by the `dims` and `exciations` arguments.
--    See the documentation for enr_fock for a more detailed description of
--    these arguments. The temperature of each mode in dims is specified by
--    the average number of excitatons `n`.
--
--    Parameters
--    ----------
--    dims : list
--        A list of the dimensions of each subsystem of a composite quantum
--        system.
--
--    excitations : integer
--        The maximum number of excitations that are to be included in the
--        state space.
--
--    n : integer
--        The average number of exciations in the thermal state. `n` can be
--        a float (which then applies to each mode), or a list/array of the same
--        length as dims, in which each element corresponds specifies the
--        temperature of the corresponding mode.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    dm : Qobj
--        Thermal state density matrix.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
--    if not isinstance(n, (list, np.ndarray)):
--        n = np.ones(len(dims)) * n
--    else:
--        n = np.asarray(n)
--
--    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
--    diags /= np.sum(diags)
--    out = qdiags(diags, 0, dims=[dims, dims],
--                 shape=(nstates, nstates), dtype=dtype)
--    out._isherm = True
--    return out
--
--
--def phase_basis(N, m, phi0=0, *, dtype=None):
--    """
--    Basis vector for the mth phase of the Pegg-Barnett phase operator.
--
--    Parameters
--    ----------
--    N : int
--        Number of basis vectors in Hilbert space.
--
--    m : int
--        Integer corresponding to the mth discrete phase
--        phi_m = phi0 + 2 * pi * m / N
--
--    phi0 : float (default=0)
--        Reference phase angle.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    state : qobj
--        Ket vector for mth Pegg-Barnett phase operator basis state.
--
--    Notes
--    -----
--    The Pegg-Barnett basis states form a complete set over the truncated
--    Hilbert space.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    phim = phi0 + (2.0 * np.pi * m) / N
--    n = np.arange(N)[:, np.newaxis]
--    data = np.exp(1.0j * n * phim) / np.sqrt(N)
--    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
--
--
--def zero_ket(N, dims=None, *, dtype=None):
--    """
--    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
--
--    Parameters
--    ----------
--    N : int
--        Hilbert space dimensionality
--    dims : list
--        Optional dimensions if ket corresponds to
--        a composite Hilbert space.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    zero_ket : qobj
--        Zero ket on given Hilbert space.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
--
--
--def spin_state(j, m, type='ket', *, dtype=None):
--    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
--    eigenstate of the spin-j Sz operator with eigenvalue m.
--
--    Parameters
--    ----------
--    j : float
--        The spin of the state ().
--
--    m : int
--        Eigenvalue of the spin-j Sz operator.
--
--    type : string {'ket', 'bra', 'dm'}
--        Type of state to generate.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    state : qobj
--        Qobj quantum object for spin state
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    J = 2*j + 1
--
--    if type == 'ket':
--        return basis(int(J), int(j - m), dtype=dtype)
--    elif type == 'bra':
--        return basis(int(J), int(j - m), dtype=dtype).dag()
--    elif type == 'dm':
--        return fock_dm(int(J), int(j - m), dtype=dtype)
--    else:
--        raise ValueError(f"Invalid value keyword argument type='{type}'")
--
--
--def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
--    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
--
--    Parameters
--    ----------
--    j : float
--        The spin of the state.
--
--    theta : float
--        Angle from z axis.
--
--    phi : float
--        Angle from x axis.
--
--    type : string {'ket', 'bra', 'dm'}
--        Type of state to generate.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    state : qobj
--        Qobj quantum object for spin coherent state
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    if type not in ['ket', 'bra', 'dm']:
--        raise ValueError("Invalid value keyword argument 'type'")
--    Sp = jmat(j, '+')
--    Sm = jmat(j, '-')
--    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
--           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
--           spin_state(j, j)
--
--    if type == 'bra':
--        psi = psi.dag()
--    elif type == 'dm':
--        psi = ket2dm(psi)
--    return psi.to(dtype)
--
--
--_BELL_STATES = {
--    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
--    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
--    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
--    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
--}
--
--def bell_state(state='00', *, dtype=None):
--    r"""
--    Returns the selected Bell state:
--
--    .. math::
--
--        \begin{aligned}
--        \lvert B_{00}\rangle &=
--            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
--        \lvert B_{01}\rangle &=
--            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
--        \lvert B_{10}\rangle &=
--            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
--        \lvert B_{11}\rangle &=
--            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
--        \end{aligned}
--
--
--    Parameters
--    ----------
--    state : str ['00', '01', `10`, `11`]
--        Which bell state to return
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    Bell_state : qobj
--        Bell state
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    return _BELL_STATES[state].copy().to(dtype)
--
--
--def singlet_state(*, dtype=None):
--    r"""
--    Returns the two particle singlet-state:
--
--    .. math::
--
--        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
--
--    that is identical to the fourth bell state.
--
--    Parameters
--    ----------
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    Bell_state : qobj
--        :math:`\lvert B_{11}\rangle` Bell state
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    return bell_state('11').to(dtype)
--
--
--def triplet_states(*, dtype=None):
--    r"""
--    Returns a list of the two particle triplet-states:
--
--    .. math::
--
--        \lvert T_1\rangle = \lvert11\rangle
--        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
--        \lvert T_3\rangle = \lvert00\rangle
--
--    Parameters
--    ----------
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    trip_states : list
--        2 particle triplet states
--    """
--    return [
--        basis([2, 2], [1, 1], dtype=dtype),
--        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
--                        basis([2, 2], [1, 0], dtype=dtype)),
--        basis([2, 2], [0, 0], dtype=dtype),
--    ]
--
--
--def w_state(N=3, *, dtype=None):
--    """
--    Returns the N-qubit W-state:
--        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
--
--    Parameters
--    ----------
--    N : int (default=3)
--        Number of qubits in state
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    W : :obj:`~Qobj`
--        N-qubit W-state
--    """
--    inds = np.zeros(N, dtype=int)
--    inds[0] = 1
--    state = basis([2]*N, list(inds), dtype=dtype)
--    for kk in range(1, N):
--        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
--    return np.sqrt(1 / N) * state
--
--
--def ghz_state(N=3, *, dtype=None):
--    """
--    Returns the N-qubit GHZ-state:
--        ``[ |00...00> + |11...11> ] / sqrt(2)``
--
--    Parameters
--    ----------
--    N : int (default=3)
--        Number of qubits in state
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    G : qobj
--        N-qubit GHZ-state
--    """
--    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
--                           basis([2]*N, [1]*N, dtype=dtype))
-+__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
-+           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
-+           'qstate', 'ket', 'bra', 'state_number_enumerate',
-+           'state_number_index', 'state_index_number', 'state_number_qobj',
-+           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
-+           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
-+           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
-+           'enr_thermal_dm']
-+
-+import itertools
-+import numbers
-+import warnings
-+
-+import numpy as np
-+import scipy.sparse as sp
-+import itertools
-+
-+from . import data as _data
-+from .qobj import Qobj
-+from .operators import jmat, displace, qdiags
-+from .tensor import tensor
-+from .. import settings
-+
-+def _promote_to_zero_list(arg, length):
-+    """
-+    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
-+    to `[0]*length`.  All other inputs are checked that they match the correct
-+    form.
-+
-+    Returns
-+    -------
-+    list_ : list
-+        A list of integers of length `length`.
-+    """
-+    if arg is None:
-+        arg = [0]*length
-+    elif not isinstance(arg, list):
-+        arg = [arg]
-+    if not len(arg) == length:
-+        raise ValueError("All list inputs must be the same length.")
-+    if all(isinstance(x, numbers.Integral) for x in arg):
-+        return arg
-+    raise TypeError("Dimensions must be an integer or list of integers.")
-+
-+
-+def basis(dimensions, n=None, offset=None, *, dtype=None):
-+    """Generates the vector representation of a Fock state.
-+
-+    Parameters
-+    ----------
-+    dimensions : int or list of ints
-+        Number of Fock states in Hilbert space.  If a list, then the resultant
-+        object will be a tensor product over spaces with those dimensions.
-+
-+    n : int or list of ints, optional (default 0 for all dimensions)
-+        Integer corresponding to desired number state, defaults to 0 for all
-+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-+        of equal length.
-+
-+    offset : int or list of ints, optional (default 0 for all dimensions)
-+        The lowest number state that is included in the finite number state
-+        representation of the state in the relevant dimension.
-+
-+    dtype : type or str
-+        storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    state : :class:`qutip.Qobj`
-+      Qobj representing the requested number state ``|n>``.
-+
-+    Examples
-+    --------
-+    >>> basis(5,2) # doctest: +SKIP
-+    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
-+    Qobj data =
-+    [[ 0.+0.j]
-+     [ 0.+0.j]
-+     [ 1.+0.j]
-+     [ 0.+0.j]
-+     [ 0.+0.j]]
-+    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
-+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
-+    Qobj data =
-+    [[0.]
-+     [0.]
-+     [1.]
-+     [0.]
-+     [0.]
-+     [0.]
-+     [0.]
-+     [0.]]
-+
-+
-+    Notes
-+    -----
-+    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
-+
-+        basis(N, 0) = ground state
-+
-+    but in the qotoolbox::
-+
-+        basis(N, 1) = ground state
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    # Promote all parameters to lists to simplify later logic.
-+    if not isinstance(dimensions, list):
-+        dimensions = [dimensions]
-+    n_dimensions = len(dimensions)
-+    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
-+                                  _promote_to_zero_list(offset, n_dimensions))]
-+    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
-+        raise ValueError("All dimensions must be >= 0.")
-+    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
-+        raise ValueError("All basis indices must be "
-+                         "`offset <= n < dimension+offset`.")
-+    location, size = 0, 1
-+    for m, dimension in zip(reversed(ns), reversed(dimensions)):
-+        location += m*size
-+        size *= dimension
-+
-+    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
-+    return Qobj(data,
-+                dims=[dimensions, [1]*n_dimensions],
-+                type='ket',
-+                isherm=False,
-+                isunitary=False,
-+                copy=False)
-+
-+
-+def qutrit_basis(*, dtype=None):
-+    """Basis states for a three level system (qutrit)
-+
-+    dtype : type or str
-+        storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    qstates : array
-+        Array of qutrit basis vectors
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    out = np.empty((3,), dtype=object)
-+    out[:] = [
-+        basis(3, 0, dtype=dtype),
-+        basis(3, 1, dtype=dtype),
-+        basis(3, 2, dtype=dtype),
-+    ]
-+    return out
-+
-+_COHERENT_METHODS = ('operator', 'analytic')
-+
-+
-+def coherent(N, alpha, offset=0, method=None, *, dtype=None):
-+    """Generates a coherent state with eigenvalue alpha.
-+
-+    Constructed using displacement operator on vacuum state.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of Fock states in Hilbert space.
-+
-+    alpha : float/complex
-+        Eigenvalue of coherent state.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the state. Using a non-zero offset will make the
-+        default method 'analytic'.
-+
-+    method : string {'operator', 'analytic'}
-+        Method for generating coherent state.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    state : qobj
-+        Qobj quantum object for coherent state
-+
-+    Examples
-+    --------
-+    >>> coherent(5,0.25j) # doctest: +SKIP
-+    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
-+    Qobj data =
-+    [[  9.69233235e-01+0.j        ]
-+     [  0.00000000e+00+0.24230831j]
-+     [ -4.28344935e-02+0.j        ]
-+     [  0.00000000e+00-0.00618204j]
-+     [  7.80904967e-04+0.j        ]]
-+
-+    Notes
-+    -----
-+    Select method 'operator' (default) or 'analytic'. With the
-+    'operator' method, the coherent state is generated by displacing
-+    the vacuum state using the displacement operator defined in the
-+    truncated Hilbert space of size 'N'. This method guarantees that the
-+    resulting state is normalized. With 'analytic' method the coherent state
-+    is generated using the analytical formula for the coherent state
-+    coefficients in the Fock basis. This method does not guarantee that the
-+    state is normalized if truncated to a small number of Fock states,
-+    but would in that case give more accurate coefficients.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    if offset < 0:
-+        raise ValueError('Offset must be non-negative')
-+
-+    if method is None:
-+        method = "operator" if offset == 0 else "analytic"
-+
-+    if method == "operator":
-+        if offset != 0:
-+            raise ValueError(
-+                "The method 'operator' does not support offset != 0. Please"
-+                " select another method or set the offset to zero."
-+            )
-+        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
-+
-+    elif method == "analytic":
-+        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
-+        sqrtn[0] = 1  # Get rid of divide by zero warning
-+        data = alpha / sqrtn
-+        if offset == 0:
-+            data[0] = np.exp(-abs(alpha)**2 / 2.0)
-+        else:
-+            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
-+            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
-+        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
-+        return Qobj(sqrtn,
-+                    dims=[[N], [1]],
-+                    type='ket',
-+                    copy=False).to(dtype)
-+    raise TypeError(
-+        "The method option can only take values in " + repr(_COHERENT_METHODS)
-+    )
-+
-+
-+def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
-+    """Density matrix representation of a coherent state.
-+
-+    Constructed via outer product of :func:`qutip.states.coherent`
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of Fock states in Hilbert space.
-+
-+    alpha : float/complex
-+        Eigenvalue for coherent state.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the state.
-+
-+    method : string {'operator', 'analytic'}
-+        Method for generating coherent density matrix.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Density matrix representation of coherent state.
-+
-+    Examples
-+    --------
-+    >>> coherent_dm(3,0.25j) # doctest: +SKIP
-+    Quantum object: dims = [[3], [3]], \
-+shape = [3, 3], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
-+     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
-+     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
-+        ]]
-+
-+    Notes
-+    -----
-+    Select method 'operator' (default) or 'analytic'. With the
-+    'operator' method, the coherent density matrix is generated by displacing
-+    the vacuum state using the displacement operator defined in the
-+    truncated Hilbert space of size 'N'. This method guarantees that the
-+    resulting density matrix is normalized. With 'analytic' method the coherent
-+    density matrix is generated using the analytical formula for the coherent
-+    state coefficients in the Fock basis. This method does not guarantee that
-+    the state is normalized if truncated to a small number of Fock states,
-+    but would in that case give more accurate coefficients.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
-+
-+
-+def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
-+    """Density matrix representation of a Fock state
-+
-+    Constructed via outer product of :func:`qutip.states.fock`.
-+
-+    Parameters
-+    ----------
-+    dimensions : int or list of ints
-+        Number of Fock states in Hilbert space.  If a list, then the resultant
-+        object will be a tensor product over spaces with those dimensions.
-+
-+    n : int or list of ints, optional (default 0 for all dimensions)
-+        Integer corresponding to desired number state, defaults to 0 for all
-+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-+        of equal length.
-+
-+    offset : int or list of ints, optional (default 0 for all dimensions)
-+        The lowest number state that is included in the finite number state
-+        representation of the state in the relevant dimension.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Density matrix representation of Fock state.
-+
-+    Examples
-+    --------
-+     >>> fock_dm(3,1) # doctest: +SKIP
-+     Quantum object: dims = [[3], [3]], \
-+shape = [3, 3], type = oper, isHerm = True
-+     Qobj data =
-+     [[ 0.+0.j  0.+0.j  0.+0.j]
-+      [ 0.+0.j  1.+0.j  0.+0.j]
-+      [ 0.+0.j  0.+0.j  0.+0.j]]
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
-+
-+
-+def fock(dimensions, n=None, offset=None, *, dtype=None):
-+    """Bosonic Fock (number) state.
-+
-+    Same as :func:`qutip.states.basis`.
-+
-+    Parameters
-+    ----------
-+    dimensions : int or list of ints
-+        Number of Fock states in Hilbert space.  If a list, then the resultant
-+        object will be a tensor product over spaces with those dimensions.
-+
-+    n : int or list of ints, optional (default 0 for all dimensions)
-+        Integer corresponding to desired number state, defaults to 0 for all
-+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-+        of equal length.
-+
-+    offset : int or list of ints, optional (default 0 for all dimensions)
-+        The lowest number state that is included in the finite number state
-+        representation of the state in the relevant dimension.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+        Requested number state :math:`\\left|n\\right>`.
-+
-+    Examples
-+    --------
-+    >>> fock(4,3) # doctest: +SKIP
-+    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
-+    Qobj data =
-+    [[ 0.+0.j]
-+     [ 0.+0.j]
-+     [ 0.+0.j]
-+     [ 1.+0.j]]
-+
-+    """
-+    return basis(dimensions, n, offset=offset, dtype=dtype)
-+
-+
-+def thermal_dm(N, n, method='operator', *, dtype=None):
-+    """Density matrix for a thermal state of n particles
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of basis states in Hilbert space.
-+
-+    n : float
-+        Expectation value for number of particles in thermal state.
-+
-+    method : string {'operator', 'analytic'}
-+        ``string`` that sets the method used to generate the
-+        thermal state probabilities
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Thermal state density matrix.
-+
-+    Examples
-+    --------
-+    >>> thermal_dm(5, 1) # doctest: +SKIP
-+    Quantum object: dims = [[5], [5]], \
-+shape = [5, 5], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.51612903  0.          0.          0.          0.        ]
-+     [ 0.          0.25806452  0.          0.          0.        ]
-+     [ 0.          0.          0.12903226  0.          0.        ]
-+     [ 0.          0.          0.          0.06451613  0.        ]
-+     [ 0.          0.          0.          0.          0.03225806]]
-+
-+
-+    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
-+    Quantum object: dims = [[5], [5]], \
-+shape = [5, 5], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.5      0.       0.       0.       0.     ]
-+     [ 0.       0.25     0.       0.       0.     ]
-+     [ 0.       0.       0.125    0.       0.     ]
-+     [ 0.       0.       0.       0.0625   0.     ]
-+     [ 0.       0.       0.       0.       0.03125]]
-+
-+    Notes
-+    -----
-+    The 'operator' method (default) generates
-+    the thermal state using the truncated number operator ``num(N)``. This
-+    is the method that should be used in computations. The
-+    'analytic' method uses the analytic coefficients derived in
-+    an infinite Hilbert space. The analytic form is not necessarily normalized,
-+    if truncated too aggressively.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    if n == 0:
-+        return fock_dm(N, 0, dtype=dtype)
-+    else:
-+        i = np.arange(N)
-+        if method == 'operator':
-+            beta = np.log(1.0 / n + 1.0)
-+            diags = np.exp(-beta * i)
-+            diags = diags / np.sum(diags)
-+            # populates diagonal terms using truncated operator expression
-+
-+        elif method == 'analytic':
-+            # populates diagonal terms using analytic values
-+            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
-+        else:
-+            raise ValueError("The method option can only take "
-+                             "values 'operator' or 'analytic'")
-+        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
-+        out._isherm = True
-+        return out
-+
-+
-+def maximally_mixed_dm(N, *, dtype=None):
-+    """
-+    Returns the maximally mixed density matrix for a Hilbert space of
-+    dimension N.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of basis states in Hilbert space.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Thermal state density matrix.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    if not isinstance(N, numbers.Integral) or N <= 0:
-+        raise ValueError("N must be integer N > 0")
-+    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
-+                type='oper', isherm=True, isunitary=(N == 1), copy=False)
-+
-+
-+def ket2dm(Q):
-+    """
-+    Takes input ket or bra vector and returns density matrix formed by outer
-+    product.  This is completely identical to calling `Q.proj()`.
-+
-+    Parameters
-+    ----------
-+    Q : qobj
-+        Ket or bra type quantum object.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Density matrix formed by outer product of `Q`.
-+
-+    Examples
-+    --------
-+    >>> x=basis(3,2)
-+    >>> ket2dm(x) # doctest: +SKIP
-+    Quantum object: dims = [[3], [3]], \
-+shape = [3, 3], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.+0.j  0.+0.j  0.+0.j]
-+     [ 0.+0.j  0.+0.j  0.+0.j]
-+     [ 0.+0.j  0.+0.j  1.+0.j]]
-+
-+    """
-+    if Q.isket or Q.isbra:
-+        return Q.proj()
-+    raise TypeError("Input is not a ket or bra vector.")
-+
-+
-+def projection(N, n, m, offset=None, *, dtype=None):
-+    r"""
-+    The projection operator that projects state :math:`\lvert m\rangle` on
-+    state :math:`\lvert n\rangle`.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of basis states in Hilbert space.
-+
-+    n, m : float
-+        The number states in the projection.
-+
-+    offset : int (default 0)
-+        The lowest number state that is included in the finite number state
-+        representation of the projector.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+         Requested projection operator.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    return basis(N, n, offset=offset, dtype=dtype) @ \
-+           basis(N, m, offset=offset, dtype=dtype).dag()
-+
-+
-+def qstate(string, *, dtype=None):
-+    r"""Creates a tensor product for a set of qubits in either
-+    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
-+
-+    Parameters
-+    ----------
-+    string : str
-+        String containing 'u' or 'd' for each qubit (ex. 'ududd')
-+
-+    Returns
-+    -------
-+    qstate : qobj
-+        Qobj for tensor product corresponding to input string.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Notes
-+    -----
-+    Look at ket and bra for more general functions
-+    creating multiparticle states.
-+
-+    Examples
-+    --------
-+    >>> qstate('udu') # doctest: +SKIP
-+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
-+    Qobj data =
-+    [[ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 1.]
-+     [ 0.]
-+     [ 0.]]
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    n = len(string)
-+    if n != (string.count('u') + string.count('d')):
-+        raise TypeError('String input to QSTATE must consist ' +
-+                        'of "u" and "d" elements only')
-+    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
-+
-+
-+#
-+# different qubit notation dictionary
-+#
-+_qubit_dict = {
-+    'g': 0,  # ground state
-+    'e': 1,  # excited state
-+    'u': 0,  # spin up
-+    'd': 1,  # spin down
-+    'H': 0,  # horizontal polarization
-+    'V': 1,  # vertical polarization
-+}
-+
-+
-+def _character_to_qudit(x):
-+    """
-+    Converts a character representing a one-particle state into int.
-+    """
-+    return _qubit_dict[x] if x in _qubit_dict else int(x)
-+
-+
-+def ket(seq, dim=2, *, dtype=None):
-+    """
-+    Produces a multiparticle ket state for a list or string,
-+    where each element stands for state of the respective particle.
-+
-+    Parameters
-+    ----------
-+    seq : str / list of ints or characters
-+        Each element defines state of the respective particle.
-+        (e.g. [1,1,0,1] or a string "1101").
-+        For qubits it is also possible to use the following conventions:
-+        - 'g'/'e' (ground and excited state)
-+        - 'u'/'d' (spin up and down)
-+        - 'H'/'V' (horizontal and vertical polarization)
-+        Note: for dimension > 9 you need to use a list.
-+
-+
-+    dim : int (default: 2) / list of ints
-+        Space dimension for each particle:
-+        int if there are the same, list if they are different.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    ket : qobj
-+
-+    Examples
-+    --------
-+    >>> ket("10") # doctest: +SKIP
-+    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
-+    Qobj data =
-+    [[ 0.]
-+     [ 0.]
-+     [ 1.]
-+     [ 0.]]
-+
-+    >>> ket("Hue") # doctest: +SKIP
-+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
-+    Qobj data =
-+    [[ 0.]
-+     [ 1.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]]
-+
-+    >>> ket("12", 3) # doctest: +SKIP
-+    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
-+    Qobj data =
-+    [[ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 1.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]]
-+
-+    >>> ket("31", [5, 2]) # doctest: +SKIP
-+    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
-+    Qobj data =
-+    [[ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 0.]
-+     [ 1.]
-+     [ 0.]
-+     [ 0.]]
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    ns = [_character_to_qudit(x) for x in seq]
-+    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
-+    return basis(dim, ns, dtype=dtype)
-+
-+
-+def bra(seq, dim=2, *, dtype=None):
-+    """
-+    Produces a multiparticle bra state for a list or string,
-+    where each element stands for state of the respective particle.
-+
-+    Parameters
-+    ----------
-+    seq : str / list of ints or characters
-+        Each element defines state of the respective particle.
-+        (e.g. [1,1,0,1] or a string "1101").
-+        For qubits it is also possible to use the following conventions:
-+
-+        - 'g'/'e' (ground and excited state)
-+        - 'u'/'d' (spin up and down)
-+        - 'H'/'V' (horizontal and vertical polarization)
-+
-+        Note: for dimension > 9 you need to use a list.
-+
-+
-+    dim : int (default: 2) / list of ints
-+        Space dimension for each particle:
-+        int if there are the same, list if they are different.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    bra : qobj
-+
-+    Examples
-+    --------
-+    >>> bra("10") # doctest: +SKIP
-+    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
-+    Qobj data =
-+    [[ 0.  0.  1.  0.]]
-+
-+    >>> bra("Hue") # doctest: +SKIP
-+    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
-+    Qobj data =
-+    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
-+
-+    >>> bra("12", 3) # doctest: +SKIP
-+    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
-+    Qobj data =
-+    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
-+
-+
-+    >>> bra("31", [5, 2]) # doctest: +SKIP
-+    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
-+    Qobj data =
-+    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    return ket(seq, dim=dim, dtype=dtype).dag()
-+
-+
-+def state_number_enumerate(dims, excitations=None):
-+    """
-+    An iterator that enumerates all the state number tuples (quantum numbers of
-+    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
-+
-+    Example:
-+
-+        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
-+        >>>     print(state) # doctest: +SKIP
-+        ( 0  0 )
-+        ( 0  1 )
-+        ( 1  0 )
-+        ( 1  1 )
-+
-+    Parameters
-+    ----------
-+    dims : list or array
-+        The quantum state dimensions array, as it would appear in a Qobj.
-+
-+    excitations : integer (None)
-+        Restrict state space to states with excitation numbers below or
-+        equal to this value.
-+
-+    Returns
-+    -------
-+    state_number : tuple
-+        Successive state number tuples that can be used in loops and other
-+        iterations, using standard state enumeration *by definition*.
-+
-+    """
-+
-+    if excitations is None:
-+        # in this case, state numbers are a direct product
-+        yield from itertools.product(*(range(d) for d in dims))
-+        return
-+
-+    # From here on, excitations is not None
-+
-+    # General idea of algorithm: add excitations one by one in last mode (idx =
-+    # len(dims)-1), and carry over to the next index when the limit is reached.
-+    # Keep track of the number of excitations while doing so to avoid having to
-+    # do explicit sums over the states.
-+    state = (0,)*len(dims)
-+    nexc = 0
-+    while True:
-+        yield state
-+        idx = len(dims) - 1
-+        state = state[:idx] + (state[idx]+1,)
-+        nexc += 1
-+        while nexc > excitations or state[idx] >= dims[idx]:
-+            # remove all excitations in mode idx, add one in idx-1
-+            idx -= 1
-+            if idx < 0:
-+                return
-+            nexc -= state[idx+1] - 1
-+            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
-+
-+
-+def state_number_index(dims, state):
-+    """
-+    Return the index of a quantum state corresponding to state,
-+    given a system with dimensions given by dims.
-+
-+    Example:
-+
-+        >>> state_number_index([2, 2, 2], [1, 1, 0])
-+        6
-+
-+    Parameters
-+    ----------
-+    dims : list or array
-+        The quantum state dimensions array, as it would appear in a Qobj.
-+
-+    state : list
-+        State number array.
-+
-+    Returns
-+    -------
-+    idx : int
-+        The index of the state given by `state` in standard enumeration
-+        ordering.
-+
-+    """
-+    return np.ravel_multi_index(state, dims)
-+
-+
-+def state_index_number(dims, index):
-+    """
-+    Return a quantum number representation given a state index, for a system
-+    of composite structure defined by dims.
-+
-+    Example:
-+
-+        >>> state_index_number([2, 2, 2], 6)
-+        [1, 1, 0]
-+
-+    Parameters
-+    ----------
-+    dims : list or array
-+        The quantum state dimensions array, as it would appear in a Qobj.
-+
-+    index : integer
-+        The index of the state in standard enumeration ordering.
-+
-+    Returns
-+    -------
-+    state : tuple
-+        The state number tuple corresponding to index `index` in standard
-+        enumeration ordering.
-+
-+    """
-+    return np.unravel_index(index, dims)
-+
-+
-+def state_number_qobj(dims, state, *, dtype=None):
-+    """
-+    Return a Qobj representation of a quantum state specified by the state
-+    array `state`.
-+
-+    Example:
-+
-+        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
-+        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
-+shape = [8, 1], type = ket
-+        Qobj data =
-+        [[ 0.]
-+         [ 0.]
-+         [ 0.]
-+         [ 0.]
-+         [ 0.]
-+         [ 1.]
-+         [ 0.]
-+         [ 0.]]
-+
-+    Parameters
-+    ----------
-+    dims : list or array
-+        The quantum state dimensions array, as it would appear in a Qobj.
-+
-+    state : list
-+        State number array.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    state : :class:`qutip.Qobj`
-+        The state as a :class:`qutip.Qobj` instance.
-+
-+    .. note::
-+        Deprecated in QuTiP 5.0, use :func:`basis` instead.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    warnings.warn("basis() is a drop-in replacement for this",
-+                  DeprecationWarning)
-+    return basis(dims, state, dtype=dtype)
-+
-+
-+# Excitation-number restricted (enr) states
-+
-+def enr_state_dictionaries(dims, excitations):
-+    """
-+    Return the number of states, and lookup-dictionaries for translating
-+    a state tuple to a state index, and vice versa, for a system with a given
-+    number of components and maximum number of excitations.
-+
-+    Parameters
-+    ----------
-+    dims: list
-+        A list with the number of states in each sub-system.
-+
-+    excitations : integer
-+        The maximum numbers of dimension
-+
-+    Returns
-+    -------
-+    nstates, state2idx, idx2state: integer, dict, list
-+        The number of states `nstates`, a dictionary for looking up state
-+        indices from a state tuple, and a list containing the state tuples
-+        ordered by state indices. state2idx and idx2state are reverses of
-+        each other, i.e., state2idx[idx2state[idx]] = idx and
-+        idx2state[state2idx[state]] = state.
-+    """
-+    idx2state = list(state_number_enumerate(dims, excitations))
-+    state2idx = {state: idx for idx, state in enumerate(idx2state)}
-+    nstates = len(idx2state)
-+
-+    return nstates, state2idx, idx2state
-+
-+
-+def enr_fock(dims, excitations, state, *, dtype=None):
-+    """
-+    Generate the Fock state representation in a excitation-number restricted
-+    state space. The `dims` argument is a list of integers that define the
-+    number of quantums states of each component of a composite quantum system,
-+    and the `excitations` specifies the maximum number of excitations for
-+    the basis states that are to be included in the state space. The `state`
-+    argument is a tuple of integers that specifies the state (in the number
-+    basis representation) for which to generate the Fock state representation.
-+
-+    Parameters
-+    ----------
-+    dims : list
-+        A list of the dimensions of each subsystem of a composite quantum
-+        system.
-+
-+    excitations : integer
-+        The maximum number of excitations that are to be included in the
-+        state space.
-+
-+    state : list of integers
-+        The state in the number basis representation.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    ket : Qobj
-+        A Qobj instance that represent a Fock state in the exication-number-
-+        restricted state space defined by `dims` and `exciations`.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
-+    try:
-+        data =_data.one_element[dtype]((nstates, 1),
-+                                       (state2idx[tuple(state)], 0), 1)
-+    except KeyError:
-+        msg = (
-+            "The state tuple " + str(tuple(state))
-+            + " is not in the restricted state space."
-+        )
-+        raise ValueError(msg) from None
-+    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
-+
-+
-+def enr_thermal_dm(dims, excitations, n, *, dtype=None):
-+    """
-+    Generate the density operator for a thermal state in the excitation-number-
-+    restricted state space defined by the `dims` and `exciations` arguments.
-+    See the documentation for enr_fock for a more detailed description of
-+    these arguments. The temperature of each mode in dims is specified by
-+    the average number of excitatons `n`.
-+
-+    Parameters
-+    ----------
-+    dims : list
-+        A list of the dimensions of each subsystem of a composite quantum
-+        system.
-+
-+    excitations : integer
-+        The maximum number of excitations that are to be included in the
-+        state space.
-+
-+    n : integer
-+        The average number of exciations in the thermal state. `n` can be
-+        a float (which then applies to each mode), or a list/array of the same
-+        length as dims, in which each element corresponds specifies the
-+        temperature of the corresponding mode.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    dm : Qobj
-+        Thermal state density matrix.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
-+    if not isinstance(n, (list, np.ndarray)):
-+        n = np.ones(len(dims)) * n
-+    else:
-+        n = np.asarray(n)
-+
-+    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
-+    diags /= np.sum(diags)
-+    out = qdiags(diags, 0, dims=[dims, dims],
-+                 shape=(nstates, nstates), dtype=dtype)
-+    out._isherm = True
-+    return out
-+
-+
-+def phase_basis(N, m, phi0=0, *, dtype=None):
-+    """
-+    Basis vector for the mth phase of the Pegg-Barnett phase operator.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of basis vectors in Hilbert space.
-+
-+    m : int
-+        Integer corresponding to the mth discrete phase
-+        phi_m = phi0 + 2 * pi * m / N
-+
-+    phi0 : float (default=0)
-+        Reference phase angle.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    state : qobj
-+        Ket vector for mth Pegg-Barnett phase operator basis state.
-+
-+    Notes
-+    -----
-+    The Pegg-Barnett basis states form a complete set over the truncated
-+    Hilbert space.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    phim = phi0 + (2.0 * np.pi * m) / N
-+    n = np.arange(N)[:, np.newaxis]
-+    data = np.exp(1.0j * n * phim) / np.sqrt(N)
-+    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
-+
-+
-+def zero_ket(N, dims=None, *, dtype=None):
-+    """
-+    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Hilbert space dimensionality
-+    dims : list
-+        Optional dimensions if ket corresponds to
-+        a composite Hilbert space.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    zero_ket : qobj
-+        Zero ket on given Hilbert space.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
-+
-+
-+def spin_state(j, m, type='ket', *, dtype=None):
-+    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
-+    eigenstate of the spin-j Sz operator with eigenvalue m.
-+
-+    Parameters
-+    ----------
-+    j : float
-+        The spin of the state ().
-+
-+    m : int
-+        Eigenvalue of the spin-j Sz operator.
-+
-+    type : string {'ket', 'bra', 'dm'}
-+        Type of state to generate.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    state : qobj
-+        Qobj quantum object for spin state
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    J = 2*j + 1
-+
-+    if type == 'ket':
-+        return basis(int(J), int(j - m), dtype=dtype)
-+    elif type == 'bra':
-+        return basis(int(J), int(j - m), dtype=dtype).dag()
-+    elif type == 'dm':
-+        return fock_dm(int(J), int(j - m), dtype=dtype)
-+    else:
-+        raise ValueError(f"Invalid value keyword argument type='{type}'")
-+
-+
-+def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
-+    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
-+
-+    Parameters
-+    ----------
-+    j : float
-+        The spin of the state.
-+
-+    theta : float
-+        Angle from z axis.
-+
-+    phi : float
-+        Angle from x axis.
-+
-+    type : string {'ket', 'bra', 'dm'}
-+        Type of state to generate.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    state : qobj
-+        Qobj quantum object for spin coherent state
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    if type not in ['ket', 'bra', 'dm']:
-+        raise ValueError("Invalid value keyword argument 'type'")
-+    Sp = jmat(j, '+')
-+    Sm = jmat(j, '-')
-+    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
-+           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
-+           spin_state(j, j)
-+
-+    if type == 'bra':
-+        psi = psi.dag()
-+    elif type == 'dm':
-+        psi = ket2dm(psi)
-+    return psi.to(dtype)
-+
-+
-+_BELL_STATES = {
-+    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
-+    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
-+    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
-+    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
-+}
-+
-+def bell_state(state='00', *, dtype=None):
-+    r"""
-+    Returns the selected Bell state:
-+
-+    .. math::
-+
-+        \begin{aligned}
-+        \lvert B_{00}\rangle &=
-+            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
-+        \lvert B_{01}\rangle &=
-+            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
-+        \lvert B_{10}\rangle &=
-+            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
-+        \lvert B_{11}\rangle &=
-+            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
-+        \end{aligned}
-+
-+
-+    Parameters
-+    ----------
-+    state : str ['00', '01', `10`, `11`]
-+        Which bell state to return
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    Bell_state : qobj
-+        Bell state
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    return _BELL_STATES[state].copy().to(dtype)
-+
-+
-+def singlet_state(*, dtype=None):
-+    r"""
-+    Returns the two particle singlet-state:
-+
-+    .. math::
-+
-+        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
-+
-+    that is identical to the fourth bell state.
-+
-+    Parameters
-+    ----------
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    Bell_state : qobj
-+        :math:`\lvert B_{11}\rangle` Bell state
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    return bell_state('11').to(dtype)
-+
-+
-+def triplet_states(*, dtype=None):
-+    r"""
-+    Returns a list of the two particle triplet-states:
-+
-+    .. math::
-+
-+        \lvert T_1\rangle = \lvert11\rangle
-+        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
-+        \lvert T_3\rangle = \lvert00\rangle
-+
-+    Parameters
-+    ----------
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    trip_states : list
-+        2 particle triplet states
-+    """
-+    return [
-+        basis([2, 2], [1, 1], dtype=dtype),
-+        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
-+                        basis([2, 2], [1, 0], dtype=dtype)),
-+        basis([2, 2], [0, 0], dtype=dtype),
-+    ]
-+
-+
-+def w_state(N=3, *, dtype=None):
-+    """
-+    Returns the N-qubit W-state:
-+        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
-+
-+    Parameters
-+    ----------
-+    N : int (default=3)
-+        Number of qubits in state
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    W : :obj:`~Qobj`
-+        N-qubit W-state
-+    """
-+    inds = np.zeros(N, dtype=int)
-+    inds[0] = 1
-+    state = basis([2]*N, list(inds), dtype=dtype)
-+    for kk in range(1, N):
-+        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
-+    return np.sqrt(1 / N) * state
-+
-+
-+def ghz_state(N=3, *, dtype=None):
-+    """
-+    Returns the N-qubit GHZ-state:
-+        ``[ |00...00> + |11...11> ] / sqrt(2)``
-+
-+    Parameters
-+    ----------
-+    N : int (default=3)
-+        Number of qubits in state
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    G : qobj
-+        N-qubit GHZ-state
-+    """
-+    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
-+                           basis([2]*N, [1]*N, dtype=dtype))
-diff --git a/qutip/core/subsystem_apply.py b/qutip/core/subsystem_apply.py
-index 013bcbc7..ecc237dd 100644
---- a/qutip/core/subsystem_apply.py
-+++ b/qutip/core/subsystem_apply.py
-@@ -1,210 +1,210 @@
--#
--# This code was contributed by Ben Criger. Resemblance to
--# partial_transpose is intentional, and meant to enhance legibility.
--#
--
--__all__ = ['subsystem_apply']
--
--import itertools
--
--import numpy as np
--
--from . import Qobj, qeye, to_kraus, tensor
--from . import data as _data
--
--
--def subsystem_apply(state, channel, mask, reference=False):
--    """
--    Returns the result of applying the propagator `channel` to the
--    subsystems indicated in `mask`, which comprise the density operator
--    `state`.
--
--    Parameters
--    ----------
--    state : :class:`qutip.qobj`
--        A density matrix or ket.
--
--    channel : :class:`qutip.qobj`
--        A propagator, either an `oper` or `super`.
--
--    mask : *list* / *array*
--        A mask that selects which subsystems should be subjected to the
--        channel.
--
--    reference : bool
--        Decides whether explicit Kraus map should be used to evaluate action
--        of channel.
--
--    Returns
--    -------
--    rho_out: :class:`qutip.qobj`
--        A density matrix with the selected subsystems transformed
--        according to the specified channel.
--    """
--    # TODO: Include sparse/dense methods a la partial_transpose.
--    if not (state.isket or state.isoper):
--        raise ValueError("input state must be a ket or oper")
--    if not (channel.issuper or channel.isoper):
--        raise ValueError("input channel must be a super or oper")
--    # Since there's only one channel, all affected subsystems must have
--    # the same dimensions:
--    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
--    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
--           for j in range(len(aff_subs_dim_ar))):
--        raise ValueError("affected subsystems must have the same dimension")
--    # If the map is on the Hilbert space, it must have the same dimension
--    # as the affected subsystem. If it is on the Liouville space, it must
--    # exist on a space as large as the square of the Hilbert dimension.
--    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
--                      else aff_subs_dim_ar[0])
--    if tuple(required_shape) != channel.shape:
--        raise ValueError(
--            "superoperator dimension must be the subsystem dimension squared"
--        )
--    mask = np.asarray(mask)
--    if reference:
--        return _subsystem_apply_reference(state, channel, mask)
--    if state.isoper:
--        return _subsystem_apply_dm(state, channel, mask)
--    return _subsystem_apply_ket(state, channel, mask)
--
--
--def _subsystem_apply_ket(state, channel, mask):
--    # TODO Write more efficient code for single-matrix map on pure states
--    # TODO Write more efficient code for single-subsystem map . . .
--    return _subsystem_apply_dm(state.proj(), channel, mask)
--
--
--def _subsystem_apply_dm(state, channel, mask):
--    """
--    Applies a channel to every subsystem indicated by a mask, by
--    repeatedly applying the channel to each affected subsystem.
--    """
--    # Initialize Output Matrix
--    rho_out = state
--    # checked affected subsystems print arange(len(state.dims[0]))[mask]
--    for subsystem in np.arange(len(state.dims[0]))[mask]:
--        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
--    return rho_out
--
--
--def _one_subsystem_apply(state, channel, idx):
--    """
--    Applies a channel to a state on one subsystem, by breaking it into
--    blocks and applying a reduced channel to each block.
--    """
--    subs_dim_ar = np.array(state.dims).T
--
--    # Calculate number of blocks
--    n_blks = 1
--    for mul_idx in range(idx):
--        n_blks = n_blks * subs_dim_ar[mul_idx][0]
--    blk_sz = state.shape[0] // n_blks
--
--    # Apply channel to top subsystem of each block in matrix
--    full_data_matrix = state.full()
--    for blk_r in range(n_blks):
--        for blk_c in range(n_blks):
--            # Apply channel to high-level blocks of matrix:
--            blk_rx = blk_r * blk_sz
--            blk_cx = blk_c * blk_sz
--
--            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
--                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
--                                              blk_cx : blk_cx+blk_sz],
--                             channel)
--    return Qobj(full_data_matrix, dims=state.dims)
--
--
--def _block_apply(block, channel):
--    return (_top_apply_U(block, channel) if channel.isoper
--            else _top_apply_S(block, channel))
--
--
--def _top_apply_U(block, channel):
--    """
--    Uses scalar-matrix multiplication to efficiently apply a channel to
--    the leftmost register in the tensor product, given a unitary matrix
--    for a channel.
--    """
--    split_mat = _block_split(block, *channel.shape)
--    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
--    for dm_row_idx in range(channel.shape[0]):
--        for dm_col_idx in range(channel.shape[1]):
--            for op_row_idx in range(channel.shape[0]):
--                for op_col_idx in range(channel.shape[1]):
--                    temp_split_mat[dm_row_idx][dm_col_idx] += (
--                        channel[dm_row_idx, op_col_idx]
--                        * channel[dm_col_idx, op_row_idx].conjugate()
--                        * split_mat[op_col_idx][op_row_idx]
--                    )
--    return _block_join(temp_split_mat)
--
--
--def _top_apply_S(block, channel):
--    # If the channel is a super-operator, perform second block decomposition;
--    # block-size matches Hilbert space of affected subsystem:
--    # FIXME use state shape?
--    n_v = int(np.sqrt(channel.shape[0]))
--    n_h = int(np.sqrt(channel.shape[1]))
--    column = _block_col(block, n_v, n_h)
--    chan_mat = channel.full()
--    temp_col = np.zeros(np.shape(column)).astype(complex)
--    for i, row in enumerate(chan_mat):
--        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
--    return _block_stack(temp_col, n_v, n_h)
--
--
--def _block_split(mat_in, n_v, n_h):
--    """
--    Returns a 4D array of matrices, splitting mat_in into
--    n_v * n_h square sub-arrays.
--    """
--    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
--
--
--def _block_join(mat_in):
--    return np.hstack(np.hstack(mat_in))
--
--
--def _block_col(mat_in, n_v, n_h):
--    """
--    Returns a 3D array of matrices, splitting mat_in into
--    n_v * n_h square sub-arrays.
--    """
--    rows, cols = np.shape(mat_in)
--    return np.reshape(
--        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
--        (n_v * n_h, rows // n_v, cols // n_h)
--    )
--
--
--def _block_stack(arr_in, n_v, n_h):
--    """
--    Inverse of _block_split
--    """
--    rs, cs = np.shape(arr_in)[-2:]
--    temp = list(map(np.transpose, arr_in))
--    # print shape(arr_in)
--    temp = np.reshape(temp, (n_v, n_h, rs, cs))
--    return np.hstack(np.hstack(temp)).T
--
--
--def _subsystem_apply_reference(state, channel, mask):
--    state = state.proj() if state.isket else state
--    if channel.isoper:
--        full_oper = tensor([channel if mask_ else qeye(size)
--                            for size, mask_ in zip(state.dims[0], mask)])
--        return full_oper @ state @ full_oper.dag()
--    kraus_list = to_kraus(channel)
--    # Kraus operators to be padded with identities:
--    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
--    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
--    for operator_iter in k_qubit_kraus_list:
--        operator_iter = iter(operator_iter)
--        op_iter_list = [next(operator_iter) if mask[j]
--                        else qeye(state.dims[0][j])
--                        for j in range(len(state.dims[0]))]
--        full_oper = tensor(list(map(Qobj, op_iter_list)))
--        rho_out = rho_out + full_oper * state * full_oper.dag()
--    return rho_out
-+#
-+# This code was contributed by Ben Criger. Resemblance to
-+# partial_transpose is intentional, and meant to enhance legibility.
-+#
-+
-+__all__ = ['subsystem_apply']
-+
-+import itertools
-+
-+import numpy as np
-+
-+from . import Qobj, qeye, to_kraus, tensor
-+from . import data as _data
-+
-+
-+def subsystem_apply(state, channel, mask, reference=False):
-+    """
-+    Returns the result of applying the propagator `channel` to the
-+    subsystems indicated in `mask`, which comprise the density operator
-+    `state`.
-+
-+    Parameters
-+    ----------
-+    state : :class:`qutip.qobj`
-+        A density matrix or ket.
-+
-+    channel : :class:`qutip.qobj`
-+        A propagator, either an `oper` or `super`.
-+
-+    mask : *list* / *array*
-+        A mask that selects which subsystems should be subjected to the
-+        channel.
-+
-+    reference : bool
-+        Decides whether explicit Kraus map should be used to evaluate action
-+        of channel.
-+
-+    Returns
-+    -------
-+    rho_out: :class:`qutip.qobj`
-+        A density matrix with the selected subsystems transformed
-+        according to the specified channel.
-+    """
-+    # TODO: Include sparse/dense methods a la partial_transpose.
-+    if not (state.isket or state.isoper):
-+        raise ValueError("input state must be a ket or oper")
-+    if not (channel.issuper or channel.isoper):
-+        raise ValueError("input channel must be a super or oper")
-+    # Since there's only one channel, all affected subsystems must have
-+    # the same dimensions:
-+    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
-+    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
-+           for j in range(len(aff_subs_dim_ar))):
-+        raise ValueError("affected subsystems must have the same dimension")
-+    # If the map is on the Hilbert space, it must have the same dimension
-+    # as the affected subsystem. If it is on the Liouville space, it must
-+    # exist on a space as large as the square of the Hilbert dimension.
-+    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
-+                      else aff_subs_dim_ar[0])
-+    if tuple(required_shape) != channel.shape:
-+        raise ValueError(
-+            "superoperator dimension must be the subsystem dimension squared"
-+        )
-+    mask = np.asarray(mask)
-+    if reference:
-+        return _subsystem_apply_reference(state, channel, mask)
-+    if state.isoper:
-+        return _subsystem_apply_dm(state, channel, mask)
-+    return _subsystem_apply_ket(state, channel, mask)
-+
-+
-+def _subsystem_apply_ket(state, channel, mask):
-+    # TODO Write more efficient code for single-matrix map on pure states
-+    # TODO Write more efficient code for single-subsystem map . . .
-+    return _subsystem_apply_dm(state.proj(), channel, mask)
-+
-+
-+def _subsystem_apply_dm(state, channel, mask):
-+    """
-+    Applies a channel to every subsystem indicated by a mask, by
-+    repeatedly applying the channel to each affected subsystem.
-+    """
-+    # Initialize Output Matrix
-+    rho_out = state
-+    # checked affected subsystems print arange(len(state.dims[0]))[mask]
-+    for subsystem in np.arange(len(state.dims[0]))[mask]:
-+        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
-+    return rho_out
-+
-+
-+def _one_subsystem_apply(state, channel, idx):
-+    """
-+    Applies a channel to a state on one subsystem, by breaking it into
-+    blocks and applying a reduced channel to each block.
-+    """
-+    subs_dim_ar = np.array(state.dims).T
-+
-+    # Calculate number of blocks
-+    n_blks = 1
-+    for mul_idx in range(idx):
-+        n_blks = n_blks * subs_dim_ar[mul_idx][0]
-+    blk_sz = state.shape[0] // n_blks
-+
-+    # Apply channel to top subsystem of each block in matrix
-+    full_data_matrix = state.full()
-+    for blk_r in range(n_blks):
-+        for blk_c in range(n_blks):
-+            # Apply channel to high-level blocks of matrix:
-+            blk_rx = blk_r * blk_sz
-+            blk_cx = blk_c * blk_sz
-+
-+            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
-+                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
-+                                              blk_cx : blk_cx+blk_sz],
-+                             channel)
-+    return Qobj(full_data_matrix, dims=state.dims)
-+
-+
-+def _block_apply(block, channel):
-+    return (_top_apply_U(block, channel) if channel.isoper
-+            else _top_apply_S(block, channel))
-+
-+
-+def _top_apply_U(block, channel):
-+    """
-+    Uses scalar-matrix multiplication to efficiently apply a channel to
-+    the leftmost register in the tensor product, given a unitary matrix
-+    for a channel.
-+    """
-+    split_mat = _block_split(block, *channel.shape)
-+    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
-+    for dm_row_idx in range(channel.shape[0]):
-+        for dm_col_idx in range(channel.shape[1]):
-+            for op_row_idx in range(channel.shape[0]):
-+                for op_col_idx in range(channel.shape[1]):
-+                    temp_split_mat[dm_row_idx][dm_col_idx] += (
-+                        channel[dm_row_idx, op_col_idx]
-+                        * channel[dm_col_idx, op_row_idx].conjugate()
-+                        * split_mat[op_col_idx][op_row_idx]
-+                    )
-+    return _block_join(temp_split_mat)
-+
-+
-+def _top_apply_S(block, channel):
-+    # If the channel is a super-operator, perform second block decomposition;
-+    # block-size matches Hilbert space of affected subsystem:
-+    # FIXME use state shape?
-+    n_v = int(np.sqrt(channel.shape[0]))
-+    n_h = int(np.sqrt(channel.shape[1]))
-+    column = _block_col(block, n_v, n_h)
-+    chan_mat = channel.full()
-+    temp_col = np.zeros(np.shape(column)).astype(complex)
-+    for i, row in enumerate(chan_mat):
-+        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
-+    return _block_stack(temp_col, n_v, n_h)
-+
-+
-+def _block_split(mat_in, n_v, n_h):
-+    """
-+    Returns a 4D array of matrices, splitting mat_in into
-+    n_v * n_h square sub-arrays.
-+    """
-+    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
-+
-+
-+def _block_join(mat_in):
-+    return np.hstack(np.hstack(mat_in))
-+
-+
-+def _block_col(mat_in, n_v, n_h):
-+    """
-+    Returns a 3D array of matrices, splitting mat_in into
-+    n_v * n_h square sub-arrays.
-+    """
-+    rows, cols = np.shape(mat_in)
-+    return np.reshape(
-+        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
-+        (n_v * n_h, rows // n_v, cols // n_h)
-+    )
-+
-+
-+def _block_stack(arr_in, n_v, n_h):
-+    """
-+    Inverse of _block_split
-+    """
-+    rs, cs = np.shape(arr_in)[-2:]
-+    temp = list(map(np.transpose, arr_in))
-+    # print shape(arr_in)
-+    temp = np.reshape(temp, (n_v, n_h, rs, cs))
-+    return np.hstack(np.hstack(temp)).T
-+
-+
-+def _subsystem_apply_reference(state, channel, mask):
-+    state = state.proj() if state.isket else state
-+    if channel.isoper:
-+        full_oper = tensor([channel if mask_ else qeye(size)
-+                            for size, mask_ in zip(state.dims[0], mask)])
-+        return full_oper @ state @ full_oper.dag()
-+    kraus_list = to_kraus(channel)
-+    # Kraus operators to be padded with identities:
-+    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
-+    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
-+    for operator_iter in k_qubit_kraus_list:
-+        operator_iter = iter(operator_iter)
-+        op_iter_list = [next(operator_iter) if mask[j]
-+                        else qeye(state.dims[0][j])
-+                        for j in range(len(state.dims[0]))]
-+        full_oper = tensor(list(map(Qobj, op_iter_list)))
-+        rho_out = rho_out + full_oper * state * full_oper.dag()
-+    return rho_out
-diff --git a/qutip/core/superop_reps.py b/qutip/core/superop_reps.py
-index c48f05fd..10fdda0f 100644
---- a/qutip/core/superop_reps.py
-+++ b/qutip/core/superop_reps.py
-@@ -1,522 +1,522 @@
--# -*- coding: utf-8 -*-
--#
--# This module was initially contributed by Ben Criger.
--#
--"""
--This module implements transformations between superoperator representations,
--including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
--"""
--
--__all__ = [
--    'kraus_to_choi', 'kraus_to_super',
--    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
--]
--
--import itertools
--import numbers
--
--import numpy as np
--import scipy.linalg
--
--from . import data as _data
--from .superoperator import stack_columns, unstack_columns, sprepost
--from .tensor import tensor
--from .dimensions import flatten
--from .qobj import Qobj
--from .operators import identity, sigmax, sigmay, sigmaz
--from .states import basis
--
--
--# TODO: revisit when creation routines have dispatching.
--_SINGLE_QUBIT_PAULI_BASIS = (
--    identity(2).to(_data.CSR),
--    sigmax().to(_data.CSR),
--    sigmay().to(_data.CSR),
--    sigmaz().to(_data.CSR),
--)
--
--
--def _superpauli_basis(nq=1):
--    dims = [[[2] * nq] * 2] * 2
--    nnz = 8**nq
--    data = _data.csr.empty(4**nq, 4**nq, nnz)
--    sci = data.as_scipy(full=True)
--    ptr, ptr_inc = 0, 2**nq
--    # Construct the Pauli basis by vertically stacking rows in sparse format.
--    # The CSR format is much more efficient at handling row-stacking, so we
--    # actually have to do a little dance through adjoint/transpose to get it
--    # into the right format.
--    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
--                                                 repeat=nq)):
--        basis = paulis[0].data
--        for pauli in paulis[1:]:
--            basis = _data.kron_csr(basis, pauli.data)
--        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
--        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
--        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
--        sci.indptr[i] = ptr
--        ptr += ptr_inc
--    sci.indptr[-1] = nnz
--    return Qobj(data.adjoint(),
--                dims=dims,
--                type='super',
--                superrep='super',
--                isherm=False,
--                isunitary=False,
--                copy=False)
--
--
--def _int_log_two(x):
--    return int(x).bit_length() - 1
--
--
--def _is_power_of_two(x):
--    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
--
--
--def _nq(dims):
--    dim = np.prod(dims[0][0])
--    nq = _int_log_two(dim)
--    if 2 ** nq != dim:
--        raise ValueError("{} is not an integer power of 2.".format(dim))
--    return nq
--
--
--def isqubitdims(dims):
--    """
--    Checks whether all entries in a dims list are integer powers of 2.
--
--    Parameters
--    ----------
--    dims : nested list of ints
--        Dimensions to be checked.
--
--    Returns
--    -------
--    isqubitdims : bool
--        True if and only if every member of the flattened dims
--        list is an integer power of 2.
--    """
--    return all(_is_power_of_two(dim) for dim in flatten(dims))
--
--
--def _to_superpauli(q_oper):
--    """
--    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
--
--    This is an internal function, as QuTiP does not currently have
--    a way to mark that superoperators are represented in the Pauli
--    basis as opposed to the column-stacking basis; a Pauli-basis
--    ``type='super'`` would thus break other conversion functions.
--    """
--    # Ensure we start with a column-stacking-basis superoperator.
--    sqobj = to_super(q_oper)
--    if not isqubitdims(sqobj.dims):
--        raise ValueError("Pauli basis is only defined for qubits.")
--    nq = _int_log_two(sqobj.shape[0]) // 2
--    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
--    # To do this, we have to hack a bit and force the dims to match,
--    # since the superpauli_basis function makes different assumptions
--    # about indices than we need here.
--    B.dims = sqobj.dims
--    return B.dag() @ sqobj @ B
--
--
--def _choi_to_kraus(q_oper, tol=1e-9):
--    """
--    Takes a Choi matrix and returns a list of Kraus operators.
--    TODO: Create a new class structure for quantum channels, perhaps as a
--    strict sub-class of Qobj.
--    """
--    vals, vecs = q_oper.eigenstates()
--    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
--    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
--    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
--                 dims=dims, type='oper', copy='False')
--            for val, vec in zip(vals, vecs) if abs(val) >= tol]
--
--
--# Individual conversions from Kraus operators are public because the output
--# list of Kraus operators is not itself a quantum object.
--
--def kraus_to_choi(kraus_list):
--    """
--    Take a list of Kraus operators and returns the Choi matrix for the channel
--    represented by the Kraus operators in `kraus_list`
--    """
--    kraus_mat_list = [k.full() for k in kraus_list]
--    op_rng = list(range(kraus_mat_list[0].shape[1]))
--    choi_blocks = np.array(
--        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
--              for op in kraus_mat_list)
--          for r_ix in op_rng]
--         for c_ix in op_rng]
--    )
--    return Qobj(np.hstack(np.hstack(choi_blocks)),
--                dims=[kraus_list[0].dims[::-1]]*2,
--                type='super',
--                superrep='choi',
--                copy=False)
--
--
--def kraus_to_super(kraus_list):
--    """
--    Convert a list of Kraus operators to a superoperator.
--    """
--    return to_super(kraus_to_choi(kraus_list))
--
--
--def _super_tofrom_choi(q_oper):
--    """
--    We exploit that the basis transformation between Choi and supermatrix
--    representations squares to the identity, so that if we munge Qobj.type,
--    we can use the same function.
--    """
--    if not q_oper.issuper:
--        raise ValueError("needs to be a superoperator")
--    if q_oper.superrep not in ('super', 'choi'):
--        raise ValueError("operator is not in super or choi format")
--    data = q_oper.data.to_array()
--    dims = q_oper.dims
--    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
--    d0 = np.prod(flatten(new_dims[0]))
--    d1 = np.prod(flatten(new_dims[1]))
--    s0 = np.prod(dims[0][0])
--    s1 = np.prod(dims[1][1])
--    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
--    return Qobj(data,
--                dims=new_dims,
--                type='super',
--                superrep='super' if q_oper.superrep == 'choi' else 'choi',
--                copy=False)
--
--
--def _choi_to_chi(q_oper):
--    """
--    Converts a Choi matrix to a Chi matrix in the Pauli basis.
--
--    NOTE: this is only supported for qubits right now. Need to extend to
--    Heisenberg-Weyl for other subsystem dimensions.
--    """
--    nq = _nq(q_oper.dims)
--    B = _superpauli_basis(nq).data
--    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
--                dims=q_oper.dims,
--                type='super',
--                superrep='chi',
--                copy=False)
--
--
--def _chi_to_choi(q_oper):
--    """
--    Converts a Chi matrix to a Choi matrix.
--
--    NOTE: this is only supported for qubits right now. Need to extend to
--    Heisenberg-Weyl for other subsystem dimensions.
--    """
--    nq = _nq(q_oper.dims)
--    B = _superpauli_basis(nq).data
--    # The Chi matrix has tr(chi) == d², so we need to divide out
--    # by that to get back to the Choi form.
--    return Qobj(_data.mul(
--                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
--                    1 / q_oper.shape[0]
--                ),
--                dims=q_oper.dims,
--                type='super',
--                superrep='choi',
--                copy=False)
--
--
--def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
--    """
--    Given a partial isometry U and a vector of square-roots of singular values
--    S obtained from a SVD, produces the Kraus operators represented by U.
--
--    Returns
--    -------
--    Ks : list of Qobj
--        Quantum objects represnting each of the Kraus operators.
--    """
--    # We use U * S since S is 1-index, such that this is equivalent to
--    # U . diag(S), but easier to write down.
--    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
--    return [
--        Qobj(x,
--             dims=[outdims, indims],
--             type='oper',
--             copy=False)
--        for x in data
--    ]
--
--
--def _generalized_kraus(q_oper, threshold=1e-10):
--    # TODO: document!
--    # TODO: use this to generalize to_kraus to the case where U != V.
--    #       This is critical for non-CP maps, as appear in (for example)
--    #       diamond norm differences between two CP maps.
--    if not q_oper.issuper or q_oper.superrep != "choi":
--        raise ValueError("".join([
--            "Expected a Choi matrix, got a ", repr(q_oper.type),
--            " (superrep ", repr(q_oper.superrep), ")."
--        ]))
--
--    # Remember the shape of the underlying space,
--    # as we'll need this to make Kraus operators later.
--    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
--    # Also remember the dims breakout.
--    out_dims, in_dims = q_oper.dims
--    out_left, out_right = out_dims
--    in_left, in_right = in_dims
--
--    # Find the SVD.
--    U, S, V = scipy.linalg.svd(q_oper.full())
--
--    # Truncate away the zero singular values, up to a threshold.
--    nonzero_idxs = S > threshold
--    dK = nonzero_idxs.sum()
--    U = np.array(U)[:, nonzero_idxs]
--    # We also want S to be a single index array, which np.matrix
--    # doesn't allow for. This is stripped by calling array() on it.
--    S = np.sqrt(np.array(S)[nonzero_idxs])
--    # Since NumPy returns V and not V+, we need to take the dagger
--    # to get back to quantum info notation for Stinespring pairs.
--    V = np.array(V.conj().T)[:, nonzero_idxs]
--
--    # Next, we convert each of U and V into Kraus operators.
--    # Finally, we want the Kraus index to be left-most so that we
--    # can map over it when making Qobjs.
--    # FIXME: does not preserve dims!
--    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
--    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
--
--    return kU, kV
--
--
--def _choi_to_stinespring(q_oper, threshold=1e-10):
--    # TODO: document!
--    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
--
--    assert len(kU) == len(kV)
--    dK = len(kU)
--    dL = kU[0].shape[0]
--    dR = kV[0].shape[1]
--    # Also remember the dims breakout.
--    out_dims, in_dims = q_oper.dims
--    out_left, out_right = out_dims
--    in_left, in_right = in_dims
--
--    A = Qobj(_data.zeros(dK * dL, dL),
--             dims=[out_left + [dK], out_right + [1]],
--             type='oper',
--             isherm=True,
--             isunitary=False,
--             copy=False)
--    B = Qobj(_data.zeros(dK * dR, dR),
--             dims=[in_left + [dK], in_right + [1]],
--             type='oper',
--             isherm=True,
--             isunitary=False,
--             copy=False)
--
--    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
--        A += tensor(KL, basis(dK, idx_kraus))
--        B += tensor(KR, basis(dK, idx_kraus))
--
--    # There is no input (right) Kraus index, so strip that off.
--    del A.dims[1][-1]
--    del B.dims[1][-1]
--
--    return A, B
--
--
--def to_choi(q_oper):
--    """
--    Converts a Qobj representing a quantum map to the Choi representation,
--    such that the trace of the returned operator is equal to the dimension
--    of the system.
--
--    Parameters
--    ----------
--    q_oper : Qobj
--        Superoperator to be converted to Choi representation. If
--        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
--        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
--
--    Returns
--    -------
--    choi : Qobj
--        A quantum object representing the same map as ``q_oper``, such that
--        ``choi.superrep == "choi"``.
--
--    Raises
--    ------
--    TypeError: if the given quantum object is not a map, or cannot be converted
--        to Choi representation.
--    """
--    if q_oper.type == 'super':
--        if q_oper.superrep == 'choi':
--            return q_oper
--        if q_oper.superrep == 'super':
--            return _super_tofrom_choi(q_oper)
--        if q_oper.superrep == 'chi':
--            return _chi_to_choi(q_oper)
--        else:
--            raise TypeError(q_oper.superrep)
--    elif q_oper.type == 'oper':
--        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
--    else:
--        raise TypeError(
--            "Conversion of Qobj with type = {0.type} "
--            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
--        )
--
--
--def to_chi(q_oper):
--    """
--    Converts a Qobj representing a quantum map to a representation as a chi
--    (process) matrix in the Pauli basis, such that the trace of the returned
--    operator is equal to the dimension of the system.
--
--    Parameters
--    ----------
--    q_oper : Qobj
--        Superoperator to be converted to Chi representation. If
--        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
--        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
--
--    Returns
--    -------
--    chi : Qobj
--        A quantum object representing the same map as ``q_oper``, such that
--        ``chi.superrep == "chi"``.
--
--    Raises
--    ------
--    TypeError: if the given quantum object is not a map, or cannot be converted
--        to Chi representation.
--    """
--    if q_oper.type == 'super':
--        if q_oper.superrep == 'chi':
--            return q_oper
--        elif q_oper.superrep == 'choi':
--            return _choi_to_chi(q_oper)
--        elif q_oper.superrep == 'super':
--            return _choi_to_chi(to_choi(q_oper))
--        else:
--            raise TypeError(q_oper.superrep)
--    elif q_oper.type == 'oper':
--        return to_chi(sprepost(q_oper, q_oper.dag()))
--    else:
--        raise TypeError(
--            "Conversion of Qobj with type = {0.type} "
--            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
--        )
--
--
--def to_super(q_oper):
--    """
--    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
--    representation.
--
--    Parameters
--    ----------
--    q_oper : Qobj
--        Superoperator to be converted to supermatrix representation. If
--        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
--        such that ``to_super(A) == sprepost(A, A.dag())``.
--
--    Returns
--    -------
--    superop : Qobj
--        A quantum object representing the same map as ``q_oper``, such that
--        ``superop.superrep == "super"``.
--
--    Raises
--    ------
--    TypeError
--        If the given quantum object is not a map, or cannot be converted
--        to supermatrix representation.
--    """
--    if q_oper.type == 'super':
--        if q_oper.superrep == "super":
--            return q_oper
--        elif q_oper.superrep == 'choi':
--            return _super_tofrom_choi(q_oper)
--        elif q_oper.superrep == 'chi':
--            return to_super(to_choi(q_oper))
--        else:
--            raise ValueError(
--                "Unrecognized superrep '{}'.".format(q_oper.superrep))
--    elif q_oper.type == 'oper':  # Assume unitary
--        return sprepost(q_oper, q_oper.dag())
--    else:
--        raise TypeError(
--            "Conversion of Qobj with type = {0.type} "
--            "and superrep = {0.superrep} to supermatrix not "
--            "supported.".format(q_oper)
--        )
--
--
--def to_kraus(q_oper, tol=1e-9):
--    """
--    Converts a Qobj representing a quantum map to a list of quantum objects,
--    each representing an operator in the Kraus decomposition of the given map.
--
--    Parameters
--    ----------
--    q_oper : Qobj
--        Superoperator to be converted to Kraus representation. If
--        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
--        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
--
--    tol : Float
--        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
--        The default is to=1e-9.
--
--    Returns
--    -------
--    kraus_ops : list of Qobj
--        A list of quantum objects, each representing a Kraus operator in the
--        decomposition of ``q_oper``.
--
--    Raises
--    ------
--    TypeError: if the given quantum object is not a map, or cannot be
--        decomposed into Kraus operators.
--    """
--    if q_oper.issuper:
--        if q_oper.superrep != 'choi':
--            q_oper = to_choi(q_oper)
--        return _choi_to_kraus(q_oper, tol)
--    elif q_oper.isoper:  # Assume unitary
--        return [q_oper]
--    raise TypeError(
--        "Conversion of Qobj with type={0.type} "
--        "and superrep={0.superrep} to Kraus decomposition not "
--        "supported.".format(q_oper)
--    )
--
--
--def to_stinespring(q_oper, threshold=1e-10):
--    r"""
--    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
--    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
--    all inputs $X$, where the partial trace is taken over a a new index on the
--    output dimensions of $A$ and $B$.
--
--    For completely positive inputs, $A$ will always equal $B$ up to precision
--    errors.
--
--    Parameters
--    ----------
--    q_oper : Qobj
--        Superoperator to be converted to a Stinespring pair.
--
--    Returns
--    -------
--    A, B : Qobj
--        Quantum objects representing each of the Stinespring matrices for the
--        input Qobj.
--    """
--    return _choi_to_stinespring(to_choi(q_oper), threshold)
-+# -*- coding: utf-8 -*-
-+#
-+# This module was initially contributed by Ben Criger.
-+#
-+"""
-+This module implements transformations between superoperator representations,
-+including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
-+"""
-+
-+__all__ = [
-+    'kraus_to_choi', 'kraus_to_super',
-+    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
-+]
-+
-+import itertools
-+import numbers
-+
-+import numpy as np
-+import scipy.linalg
-+
-+from . import data as _data
-+from .superoperator import stack_columns, unstack_columns, sprepost
-+from .tensor import tensor
-+from .dimensions import flatten
-+from .qobj import Qobj
-+from .operators import identity, sigmax, sigmay, sigmaz
-+from .states import basis
-+
-+
-+# TODO: revisit when creation routines have dispatching.
-+_SINGLE_QUBIT_PAULI_BASIS = (
-+    identity(2).to(_data.CSR),
-+    sigmax().to(_data.CSR),
-+    sigmay().to(_data.CSR),
-+    sigmaz().to(_data.CSR),
-+)
-+
-+
-+def _superpauli_basis(nq=1):
-+    dims = [[[2] * nq] * 2] * 2
-+    nnz = 8**nq
-+    data = _data.csr.empty(4**nq, 4**nq, nnz)
-+    sci = data.as_scipy(full=True)
-+    ptr, ptr_inc = 0, 2**nq
-+    # Construct the Pauli basis by vertically stacking rows in sparse format.
-+    # The CSR format is much more efficient at handling row-stacking, so we
-+    # actually have to do a little dance through adjoint/transpose to get it
-+    # into the right format.
-+    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
-+                                                 repeat=nq)):
-+        basis = paulis[0].data
-+        for pauli in paulis[1:]:
-+            basis = _data.kron_csr(basis, pauli.data)
-+        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
-+        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
-+        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
-+        sci.indptr[i] = ptr
-+        ptr += ptr_inc
-+    sci.indptr[-1] = nnz
-+    return Qobj(data.adjoint(),
-+                dims=dims,
-+                type='super',
-+                superrep='super',
-+                isherm=False,
-+                isunitary=False,
-+                copy=False)
-+
-+
-+def _int_log_two(x):
-+    return int(x).bit_length() - 1
-+
-+
-+def _is_power_of_two(x):
-+    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
-+
-+
-+def _nq(dims):
-+    dim = np.prod(dims[0][0])
-+    nq = _int_log_two(dim)
-+    if 2 ** nq != dim:
-+        raise ValueError("{} is not an integer power of 2.".format(dim))
-+    return nq
-+
-+
-+def isqubitdims(dims):
-+    """
-+    Checks whether all entries in a dims list are integer powers of 2.
-+
-+    Parameters
-+    ----------
-+    dims : nested list of ints
-+        Dimensions to be checked.
-+
-+    Returns
-+    -------
-+    isqubitdims : bool
-+        True if and only if every member of the flattened dims
-+        list is an integer power of 2.
-+    """
-+    return all(_is_power_of_two(dim) for dim in flatten(dims))
-+
-+
-+def _to_superpauli(q_oper):
-+    """
-+    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
-+
-+    This is an internal function, as QuTiP does not currently have
-+    a way to mark that superoperators are represented in the Pauli
-+    basis as opposed to the column-stacking basis; a Pauli-basis
-+    ``type='super'`` would thus break other conversion functions.
-+    """
-+    # Ensure we start with a column-stacking-basis superoperator.
-+    sqobj = to_super(q_oper)
-+    if not isqubitdims(sqobj.dims):
-+        raise ValueError("Pauli basis is only defined for qubits.")
-+    nq = _int_log_two(sqobj.shape[0]) // 2
-+    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
-+    # To do this, we have to hack a bit and force the dims to match,
-+    # since the superpauli_basis function makes different assumptions
-+    # about indices than we need here.
-+    B.dims = sqobj.dims
-+    return B.dag() @ sqobj @ B
-+
-+
-+def _choi_to_kraus(q_oper, tol=1e-9):
-+    """
-+    Takes a Choi matrix and returns a list of Kraus operators.
-+    TODO: Create a new class structure for quantum channels, perhaps as a
-+    strict sub-class of Qobj.
-+    """
-+    vals, vecs = q_oper.eigenstates()
-+    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
-+    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
-+    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
-+                 dims=dims, type='oper', copy='False')
-+            for val, vec in zip(vals, vecs) if abs(val) >= tol]
-+
-+
-+# Individual conversions from Kraus operators are public because the output
-+# list of Kraus operators is not itself a quantum object.
-+
-+def kraus_to_choi(kraus_list):
-+    """
-+    Take a list of Kraus operators and returns the Choi matrix for the channel
-+    represented by the Kraus operators in `kraus_list`
-+    """
-+    kraus_mat_list = [k.full() for k in kraus_list]
-+    op_rng = list(range(kraus_mat_list[0].shape[1]))
-+    choi_blocks = np.array(
-+        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
-+              for op in kraus_mat_list)
-+          for r_ix in op_rng]
-+         for c_ix in op_rng]
-+    )
-+    return Qobj(np.hstack(np.hstack(choi_blocks)),
-+                dims=[kraus_list[0].dims[::-1]]*2,
-+                type='super',
-+                superrep='choi',
-+                copy=False)
-+
-+
-+def kraus_to_super(kraus_list):
-+    """
-+    Convert a list of Kraus operators to a superoperator.
-+    """
-+    return to_super(kraus_to_choi(kraus_list))
-+
-+
-+def _super_tofrom_choi(q_oper):
-+    """
-+    We exploit that the basis transformation between Choi and supermatrix
-+    representations squares to the identity, so that if we munge Qobj.type,
-+    we can use the same function.
-+    """
-+    if not q_oper.issuper:
-+        raise ValueError("needs to be a superoperator")
-+    if q_oper.superrep not in ('super', 'choi'):
-+        raise ValueError("operator is not in super or choi format")
-+    data = q_oper.data.to_array()
-+    dims = q_oper.dims
-+    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
-+    d0 = np.prod(flatten(new_dims[0]))
-+    d1 = np.prod(flatten(new_dims[1]))
-+    s0 = np.prod(dims[0][0])
-+    s1 = np.prod(dims[1][1])
-+    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
-+    return Qobj(data,
-+                dims=new_dims,
-+                type='super',
-+                superrep='super' if q_oper.superrep == 'choi' else 'choi',
-+                copy=False)
-+
-+
-+def _choi_to_chi(q_oper):
-+    """
-+    Converts a Choi matrix to a Chi matrix in the Pauli basis.
-+
-+    NOTE: this is only supported for qubits right now. Need to extend to
-+    Heisenberg-Weyl for other subsystem dimensions.
-+    """
-+    nq = _nq(q_oper.dims)
-+    B = _superpauli_basis(nq).data
-+    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
-+                dims=q_oper.dims,
-+                type='super',
-+                superrep='chi',
-+                copy=False)
-+
-+
-+def _chi_to_choi(q_oper):
-+    """
-+    Converts a Chi matrix to a Choi matrix.
-+
-+    NOTE: this is only supported for qubits right now. Need to extend to
-+    Heisenberg-Weyl for other subsystem dimensions.
-+    """
-+    nq = _nq(q_oper.dims)
-+    B = _superpauli_basis(nq).data
-+    # The Chi matrix has tr(chi) == d², so we need to divide out
-+    # by that to get back to the Choi form.
-+    return Qobj(_data.mul(
-+                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
-+                    1 / q_oper.shape[0]
-+                ),
-+                dims=q_oper.dims,
-+                type='super',
-+                superrep='choi',
-+                copy=False)
-+
-+
-+def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
-+    """
-+    Given a partial isometry U and a vector of square-roots of singular values
-+    S obtained from a SVD, produces the Kraus operators represented by U.
-+
-+    Returns
-+    -------
-+    Ks : list of Qobj
-+        Quantum objects represnting each of the Kraus operators.
-+    """
-+    # We use U * S since S is 1-index, such that this is equivalent to
-+    # U . diag(S), but easier to write down.
-+    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
-+    return [
-+        Qobj(x,
-+             dims=[outdims, indims],
-+             type='oper',
-+             copy=False)
-+        for x in data
-+    ]
-+
-+
-+def _generalized_kraus(q_oper, threshold=1e-10):
-+    # TODO: document!
-+    # TODO: use this to generalize to_kraus to the case where U != V.
-+    #       This is critical for non-CP maps, as appear in (for example)
-+    #       diamond norm differences between two CP maps.
-+    if not q_oper.issuper or q_oper.superrep != "choi":
-+        raise ValueError("".join([
-+            "Expected a Choi matrix, got a ", repr(q_oper.type),
-+            " (superrep ", repr(q_oper.superrep), ")."
-+        ]))
-+
-+    # Remember the shape of the underlying space,
-+    # as we'll need this to make Kraus operators later.
-+    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
-+    # Also remember the dims breakout.
-+    out_dims, in_dims = q_oper.dims
-+    out_left, out_right = out_dims
-+    in_left, in_right = in_dims
-+
-+    # Find the SVD.
-+    U, S, V = scipy.linalg.svd(q_oper.full())
-+
-+    # Truncate away the zero singular values, up to a threshold.
-+    nonzero_idxs = S > threshold
-+    dK = nonzero_idxs.sum()
-+    U = np.array(U)[:, nonzero_idxs]
-+    # We also want S to be a single index array, which np.matrix
-+    # doesn't allow for. This is stripped by calling array() on it.
-+    S = np.sqrt(np.array(S)[nonzero_idxs])
-+    # Since NumPy returns V and not V+, we need to take the dagger
-+    # to get back to quantum info notation for Stinespring pairs.
-+    V = np.array(V.conj().T)[:, nonzero_idxs]
-+
-+    # Next, we convert each of U and V into Kraus operators.
-+    # Finally, we want the Kraus index to be left-most so that we
-+    # can map over it when making Qobjs.
-+    # FIXME: does not preserve dims!
-+    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
-+    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
-+
-+    return kU, kV
-+
-+
-+def _choi_to_stinespring(q_oper, threshold=1e-10):
-+    # TODO: document!
-+    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
-+
-+    assert len(kU) == len(kV)
-+    dK = len(kU)
-+    dL = kU[0].shape[0]
-+    dR = kV[0].shape[1]
-+    # Also remember the dims breakout.
-+    out_dims, in_dims = q_oper.dims
-+    out_left, out_right = out_dims
-+    in_left, in_right = in_dims
-+
-+    A = Qobj(_data.zeros(dK * dL, dL),
-+             dims=[out_left + [dK], out_right + [1]],
-+             type='oper',
-+             isherm=True,
-+             isunitary=False,
-+             copy=False)
-+    B = Qobj(_data.zeros(dK * dR, dR),
-+             dims=[in_left + [dK], in_right + [1]],
-+             type='oper',
-+             isherm=True,
-+             isunitary=False,
-+             copy=False)
-+
-+    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
-+        A += tensor(KL, basis(dK, idx_kraus))
-+        B += tensor(KR, basis(dK, idx_kraus))
-+
-+    # There is no input (right) Kraus index, so strip that off.
-+    del A.dims[1][-1]
-+    del B.dims[1][-1]
-+
-+    return A, B
-+
-+
-+def to_choi(q_oper):
-+    """
-+    Converts a Qobj representing a quantum map to the Choi representation,
-+    such that the trace of the returned operator is equal to the dimension
-+    of the system.
-+
-+    Parameters
-+    ----------
-+    q_oper : Qobj
-+        Superoperator to be converted to Choi representation. If
-+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-+        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
-+
-+    Returns
-+    -------
-+    choi : Qobj
-+        A quantum object representing the same map as ``q_oper``, such that
-+        ``choi.superrep == "choi"``.
-+
-+    Raises
-+    ------
-+    TypeError: if the given quantum object is not a map, or cannot be converted
-+        to Choi representation.
-+    """
-+    if q_oper.type == 'super':
-+        if q_oper.superrep == 'choi':
-+            return q_oper
-+        if q_oper.superrep == 'super':
-+            return _super_tofrom_choi(q_oper)
-+        if q_oper.superrep == 'chi':
-+            return _chi_to_choi(q_oper)
-+        else:
-+            raise TypeError(q_oper.superrep)
-+    elif q_oper.type == 'oper':
-+        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
-+    else:
-+        raise TypeError(
-+            "Conversion of Qobj with type = {0.type} "
-+            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
-+        )
-+
-+
-+def to_chi(q_oper):
-+    """
-+    Converts a Qobj representing a quantum map to a representation as a chi
-+    (process) matrix in the Pauli basis, such that the trace of the returned
-+    operator is equal to the dimension of the system.
-+
-+    Parameters
-+    ----------
-+    q_oper : Qobj
-+        Superoperator to be converted to Chi representation. If
-+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-+        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
-+
-+    Returns
-+    -------
-+    chi : Qobj
-+        A quantum object representing the same map as ``q_oper``, such that
-+        ``chi.superrep == "chi"``.
-+
-+    Raises
-+    ------
-+    TypeError: if the given quantum object is not a map, or cannot be converted
-+        to Chi representation.
-+    """
-+    if q_oper.type == 'super':
-+        if q_oper.superrep == 'chi':
-+            return q_oper
-+        elif q_oper.superrep == 'choi':
-+            return _choi_to_chi(q_oper)
-+        elif q_oper.superrep == 'super':
-+            return _choi_to_chi(to_choi(q_oper))
-+        else:
-+            raise TypeError(q_oper.superrep)
-+    elif q_oper.type == 'oper':
-+        return to_chi(sprepost(q_oper, q_oper.dag()))
-+    else:
-+        raise TypeError(
-+            "Conversion of Qobj with type = {0.type} "
-+            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
-+        )
-+
-+
-+def to_super(q_oper):
-+    """
-+    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
-+    representation.
-+
-+    Parameters
-+    ----------
-+    q_oper : Qobj
-+        Superoperator to be converted to supermatrix representation. If
-+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-+        such that ``to_super(A) == sprepost(A, A.dag())``.
-+
-+    Returns
-+    -------
-+    superop : Qobj
-+        A quantum object representing the same map as ``q_oper``, such that
-+        ``superop.superrep == "super"``.
-+
-+    Raises
-+    ------
-+    TypeError
-+        If the given quantum object is not a map, or cannot be converted
-+        to supermatrix representation.
-+    """
-+    if q_oper.type == 'super':
-+        if q_oper.superrep == "super":
-+            return q_oper
-+        elif q_oper.superrep == 'choi':
-+            return _super_tofrom_choi(q_oper)
-+        elif q_oper.superrep == 'chi':
-+            return to_super(to_choi(q_oper))
-+        else:
-+            raise ValueError(
-+                "Unrecognized superrep '{}'.".format(q_oper.superrep))
-+    elif q_oper.type == 'oper':  # Assume unitary
-+        return sprepost(q_oper, q_oper.dag())
-+    else:
-+        raise TypeError(
-+            "Conversion of Qobj with type = {0.type} "
-+            "and superrep = {0.superrep} to supermatrix not "
-+            "supported.".format(q_oper)
-+        )
-+
-+
-+def to_kraus(q_oper, tol=1e-9):
-+    """
-+    Converts a Qobj representing a quantum map to a list of quantum objects,
-+    each representing an operator in the Kraus decomposition of the given map.
-+
-+    Parameters
-+    ----------
-+    q_oper : Qobj
-+        Superoperator to be converted to Kraus representation. If
-+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-+        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
-+
-+    tol : Float
-+        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
-+        The default is to=1e-9.
-+
-+    Returns
-+    -------
-+    kraus_ops : list of Qobj
-+        A list of quantum objects, each representing a Kraus operator in the
-+        decomposition of ``q_oper``.
-+
-+    Raises
-+    ------
-+    TypeError: if the given quantum object is not a map, or cannot be
-+        decomposed into Kraus operators.
-+    """
-+    if q_oper.issuper:
-+        if q_oper.superrep != 'choi':
-+            q_oper = to_choi(q_oper)
-+        return _choi_to_kraus(q_oper, tol)
-+    elif q_oper.isoper:  # Assume unitary
-+        return [q_oper]
-+    raise TypeError(
-+        "Conversion of Qobj with type={0.type} "
-+        "and superrep={0.superrep} to Kraus decomposition not "
-+        "supported.".format(q_oper)
-+    )
-+
-+
-+def to_stinespring(q_oper, threshold=1e-10):
-+    r"""
-+    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
-+    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
-+    all inputs $X$, where the partial trace is taken over a a new index on the
-+    output dimensions of $A$ and $B$.
-+
-+    For completely positive inputs, $A$ will always equal $B$ up to precision
-+    errors.
-+
-+    Parameters
-+    ----------
-+    q_oper : Qobj
-+        Superoperator to be converted to a Stinespring pair.
-+
-+    Returns
-+    -------
-+    A, B : Qobj
-+        Quantum objects representing each of the Stinespring matrices for the
-+        input Qobj.
-+    """
-+    return _choi_to_stinespring(to_choi(q_oper), threshold)
-diff --git a/qutip/core/superoperator.py b/qutip/core/superoperator.py
-index 328862b8..2a990868 100644
---- a/qutip/core/superoperator.py
-+++ b/qutip/core/superoperator.py
-@@ -1,412 +1,412 @@
--__all__ = [
--    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
--    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
--    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
--]
--
--import functools
--
--import numpy as np
--
--from .qobj import Qobj
--from . import data as _data
--
--def _map_over_compound_operators(f):
--    """
--    Convert a function which takes Qobj into one that can also take compound
--    operators like QobjEvo, and applies itself over all the components.
--    """
--    @functools.wraps(f)
--    def out(qobj):
--        # To avoid circular dependencies
--        from .cy.qobjevo import QobjEvo
--        if isinstance(qobj, QobjEvo):
--            return qobj.linear_map(f, _skip_check=True)
--        if not isinstance(qobj, Qobj):
--            raise TypeError("expected a quantum object")
--        return f(qobj)
--    return out
--
--
--def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
--    """Assembles the Liouvillian superoperator from a Hamiltonian
--    and a ``list`` of collapse operators.
--
--    Parameters
--    ----------
--    H : Qobj or QobjEvo (optional)
--        System Hamiltonian or Hamiltonian component of a Liouvillian.
--        Considered `0` if not given.
--
--    c_ops : array_like of Qobj or QobjEvo
--        A ``list`` or ``array`` of collapse operators.
--
--    data_only :  bool [False]
--        Return the data object instead of a Qobj
--
--    chi : array_like of float [None]
--        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
--        probability distributions of occupation of various states by numerically evaluating the derivatives
--        of the steady state occupation probability as a function of artificial phase parameters ``chi``
--        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
--        the documentation of :func:`lindblad_dissipator` for references and further details.
--        This parameter is deprecated and may be removed in QuTiP 5.
--
--    Returns
--    -------
--    L : Qobj or QobjEvo
--        Liouvillian superoperator.
--
--    """
--    # To avoid circular dependencies
--    from .cy.qobjevo import QobjEvo
--    if (
--        data_only
--        and (isinstance(H, QobjEvo)
--             or any(isinstance(op, QobjEvo) for op in c_ops))
--    ):
--        raise ValueError("Cannot return the data object when computing the"
--                         " liouvillian with QobjEvo")
--
--    c_ops = c_ops or []
--    if isinstance(c_ops, (Qobj, QobjEvo)):
--        c_ops = [c_ops]
--    if chi and len(chi) != len(c_ops):
--        raise ValueError('chi must be a list with same length as c_ops')
--    chi = chi or [0] * len(c_ops)
--
--    if H is None:
--        # No Hamiltonian, add the lindblad_dissipator of c_ops:
--        if not c_ops:
--            raise ValueError("The liouvillian need an Hamiltonian"
--                             " and/or c_ops")
--        out = sum(lindblad_dissipator(c_op, chi=chi_)
--                  for c_op, chi_ in zip(c_ops, chi))
--        return out.data if data_only else out
--    elif not H.isoper:
--        raise TypeError("Invalid type for Hamiltonian.")
--
--    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
--        # With QobjEvo, faster computation using Data is not used
--        L = -1.0j * (spre(H) - spost(H))
--        L += sum(lindblad_dissipator(c_op, chi=chi_)
--                 for c_op, chi_ in zip(c_ops, chi))
--        return L
--
--    op_dims = H.dims
--    op_shape = H.shape
--    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
--    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
--    spI = _data.identity(op_shape[0], dtype=type(H.data))
--
--    data = _data.mul(_data.kron(spI, H.data), -1j)
--    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
--
--    for c_op, chi_ in zip(c_ops, chi):
--        c = c_op.data
--        cd = c.adjoint()
--        cdc = _data.matmul(cd, c)
--        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
--        data = _data.add(data, _data.kron(spI, cdc), -0.5)
--        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
--
--    if data_only:
--        return data
--    else:
--        return Qobj(data,
--                    dims=sop_dims,
--                    type='super',
--                    superrep='super',
--                    copy=False)
--
--
--def lindblad_dissipator(a, b=None, data_only=False, chi=None):
--    """
--    Lindblad dissipator (generalized) for a single pair of collapse operators
--    (a, b), or for a single collapse operator (a) when b is not specified:
--
--    .. math::
--
--        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
--        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
--
--    Parameters
--    ----------
--    a : Qobj or QobjEvo
--        Left part of collapse operator.
--
--    b : Qobj or QobjEvo (optional)
--        Right part of collapse operator. If not specified, b defaults to a.
--
--    chi : float [None]
--        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
--        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
--        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
--        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
--        is introduced via the generating function of the statistical moments. For examples of the technique,
--        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
--        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
--        This parameter is deprecated and may be removed in QuTiP 5.
--
--    data_only :  bool [False]
--        Return the data object instead of a Qobj
--
--    Returns
--    -------
--    D : qobj, QobjEvo
--        Lindblad dissipator superoperator.
--    """
--    # To avoid circular dependencies
--    from .cy.qobjevo import QobjEvo
--    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
--        raise ValueError("Cannot return the data object when computing the"
--                         " collapse of a QobjEvo")
--    if b is None:
--        b = a
--    ad_b = a.dag() * b
--    if chi:
--        D = (
--            spre(a) * spost(b.dag()) * np.exp(1j * chi)
--            - 0.5 * spre(ad_b)
--            - 0.5 * spost(ad_b)
--        )
--    else:
--        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
--
--    return D.data if data_only else D
--
--
--@_map_over_compound_operators
--def operator_to_vector(op):
--    """
--    Create a vector representation given a quantum operator in matrix form.
--    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
--    function is not designed for general-purpose matrix reshaping.
--
--    Parameters
--    ----------
--    op : Qobj or QobjEvo
--        Quantum operator in matrix form.  This must have a type of 'oper' or
--        'super'.
--
--    Returns
--    -------
--    Qobj or QobjEvo
--        The same object, but re-cast into a column-stacked-vector form of type
--        'operator-ket'.  The output is the same type as the passed object.
--    """
--    if op.type in ['super', 'operator-ket', 'operator-bra']:
--        raise TypeError("Cannot convert object already "
--                        "in super representation")
--    return Qobj(stack_columns(op.data),
--                dims=[op.dims, [1]],
--                type='operator-ket',
--                superrep="super",
--                copy=False)
--
--
--@_map_over_compound_operators
--def vector_to_operator(op):
--    """
--    Create a matrix representation given a quantum operator in vector form.
--    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
--    function is not designed for general-purpose matrix reshaping.
--
--    Parameters
--    ----------
--    op : Qobj or QobjEvo
--        Quantum operator in column-stacked-vector form.  This must have a type
--        of 'operator-ket'.
--
--    Returns
--    -------
--    Qobj or QobjEvo
--        The same object, but re-cast into "standard" operator form.  The output
--        is the same type as the passed object.
--    """
--    if not op.isoperket:
--        raise TypeError("only defined for operator-kets")
--    if op.superrep != "super":
--        raise TypeError("only defined for operator-kets in super format")
--    dims = op.dims[0]
--    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
--                dims=dims,
--                copy=False)
--
--
--def stack_columns(matrix):
--    """
--    Stack the columns in a data-layer type, useful for converting an operator
--    into a superoperator representation.
--    """
--    if not isinstance(matrix, (_data.Data, np.ndarray)):
--        raise TypeError(
--            "input " + repr(type(matrix)) + " is not data-layer type"
--        )
--    if isinstance(matrix, np.ndarray):
--        return matrix.ravel('F')[:, None]
--    return _data.column_stack(matrix)
--
--
--def unstack_columns(vector, shape=None):
--    """
--    Unstack the columns in a data-layer type back into a 2D shape, useful for
--    converting an operator in vector form back into a regular operator.  If
--    `shape` is not passed, the output operator will be assumed to be square.
--    """
--    if not isinstance(vector, (_data.Data, np.ndarray)):
--        raise TypeError(
--            "input " + repr(type(vector)) + " is not data-layer type"
--        )
--    if (
--        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
--        or (isinstance(vector, np.ndarray)
--            and ((vector.ndim == 2 and vector.shape[1] != 1)
--                 or vector.ndim > 2))
--    ):
--        raise TypeError("input is not a single column")
--    if shape is None:
--        n = int(np.sqrt(vector.shape[0]))
--        if n * n != vector.shape[0]:
--            raise ValueError(
--                "input cannot be made square, but no specific shape given"
--            )
--        shape = (n, n)
--    if isinstance(vector, np.ndarray):
--        return vector.reshape(shape, order='F')
--    return _data.column_unstack(vector, shape[0])
--
--
--def unstacked_index(size, index):
--    """
--    Convert an index into a column-stacked square operator with `size` rows and
--    columns, into a pair of indices into the unstacked operator.
--    """
--    return index % size, index // size
--
--
--def stacked_index(size, row, col):
--    """
--    Convert a pair of indices into a square operator of `size` into a single
--    index into the column-stacked version of the operator.
--    """
--    return row + size*col
--
--
--@_map_over_compound_operators
--def spost(A):
--    """
--    Superoperator formed from post-multiplication by operator A
--
--    Parameters
--    ----------
--    A : Qobj or QobjEvo
--        Quantum operator for post multiplication.
--
--    Returns
--    -------
--    super : Qobj or QobjEvo
--        Superoperator formed from input qauntum object.
--    """
--    if not A.isoper:
--        raise TypeError('Input is not a quantum operator')
--    data = _data.kron(A.data.transpose(),
--                      _data.identity(A.shape[0], dtype=type(A.data)))
--    return Qobj(data,
--                dims=[A.dims, A.dims],
--                type='super',
--                superrep='super',
--                isherm=A._isherm,
--                copy=False)
--
--
--@_map_over_compound_operators
--def spre(A):
--    """Superoperator formed from pre-multiplication by operator A.
--
--    Parameters
--    ----------
--    A : Qobj or QobjEvo
--        Quantum operator for pre-multiplication.
--
--    Returns
--    -------
--    super :Qobj or QobjEvo
--        Superoperator formed from input quantum object.
--    """
--    if not A.isoper:
--        raise TypeError('Input is not a quantum operator')
--    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
--    return Qobj(data,
--                dims=[A.dims, A.dims],
--                type='super',
--                superrep='super',
--                isherm=A._isherm,
--                copy=False)
--
--
--def _drop_projected_dims(dims):
--    """
--    Eliminate subsystems that has been collapsed to only one state due to
--    a projection.
--    """
--    return [d for d in dims if d != 1]
--
--
--def sprepost(A, B):
--    """
--    Superoperator formed from pre-multiplication by A and post-multiplication
--    by B.
--
--    Parameters
--    ----------
--    A : Qobj or QobjEvo
--        Quantum operator for pre-multiplication.
--
--    B : Qobj or QobjEvo
--        Quantum operator for post-multiplication.
--
--    Returns
--    -------
--    super : Qobj or QobjEvo
--        Superoperator formed from input quantum objects.
--    """
--    # To avoid circular dependencies
--    from .cy.qobjevo import QobjEvo
--    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
--        return spre(A) * spost(B)
--    dims = [[_drop_projected_dims(A.dims[0]),
--             _drop_projected_dims(B.dims[1])],
--            [_drop_projected_dims(A.dims[1]),
--             _drop_projected_dims(B.dims[0])]]
--    return Qobj(_data.kron(B.data.transpose(), A.data),
--                dims=dims,
--                type='super',
--                superrep='super',
--                isherm=A._isherm and B._isherm,
--                copy=False)
--
--
--def reshuffle(q_oper):
--    """
--    Column-reshuffles a ``type="super"`` Qobj.
--    """
--    if q_oper.type not in ('super', 'operator-ket'):
--        raise TypeError("Reshuffling is only supported on type='super' "
--                        "or type='operator-ket'.")
--    # How many indices are there, and how many subsystems can we decompose
--    # each index into?
--    n_indices = len(q_oper.dims[0])
--    n_subsystems = len(q_oper.dims[0][0])
--    # Generate a list of lists (lol) that represents the permutation order we
--    # need. It's easiest to do so if we make an array, then turn it into a lol
--    # by using map(list, ...). That array is generated by using reshape and
--    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
--    # [a, a, ..., a, b, b, ..., b].
--    perm_idxs = map(list,
--                    np.arange(n_subsystems * n_indices)[
--                        np.arange(n_subsystems * n_indices).reshape(
--                            (n_indices, n_subsystems)).T.flatten()
--                    ].reshape((n_subsystems, n_indices))
--                    )
--    return q_oper.permute(list(perm_idxs))
-+__all__ = [
-+    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
-+    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
-+    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
-+]
-+
-+import functools
-+
-+import numpy as np
-+
-+from .qobj import Qobj
-+from . import data as _data
-+
-+def _map_over_compound_operators(f):
-+    """
-+    Convert a function which takes Qobj into one that can also take compound
-+    operators like QobjEvo, and applies itself over all the components.
-+    """
-+    @functools.wraps(f)
-+    def out(qobj):
-+        # To avoid circular dependencies
-+        from .cy.qobjevo import QobjEvo
-+        if isinstance(qobj, QobjEvo):
-+            return qobj.linear_map(f, _skip_check=True)
-+        if not isinstance(qobj, Qobj):
-+            raise TypeError("expected a quantum object")
-+        return f(qobj)
-+    return out
-+
-+
-+def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
-+    """Assembles the Liouvillian superoperator from a Hamiltonian
-+    and a ``list`` of collapse operators.
-+
-+    Parameters
-+    ----------
-+    H : Qobj or QobjEvo (optional)
-+        System Hamiltonian or Hamiltonian component of a Liouvillian.
-+        Considered `0` if not given.
-+
-+    c_ops : array_like of Qobj or QobjEvo
-+        A ``list`` or ``array`` of collapse operators.
-+
-+    data_only :  bool [False]
-+        Return the data object instead of a Qobj
-+
-+    chi : array_like of float [None]
-+        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
-+        probability distributions of occupation of various states by numerically evaluating the derivatives
-+        of the steady state occupation probability as a function of artificial phase parameters ``chi``
-+        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
-+        the documentation of :func:`lindblad_dissipator` for references and further details.
-+        This parameter is deprecated and may be removed in QuTiP 5.
-+
-+    Returns
-+    -------
-+    L : Qobj or QobjEvo
-+        Liouvillian superoperator.
-+
-+    """
-+    # To avoid circular dependencies
-+    from .cy.qobjevo import QobjEvo
-+    if (
-+        data_only
-+        and (isinstance(H, QobjEvo)
-+             or any(isinstance(op, QobjEvo) for op in c_ops))
-+    ):
-+        raise ValueError("Cannot return the data object when computing the"
-+                         " liouvillian with QobjEvo")
-+
-+    c_ops = c_ops or []
-+    if isinstance(c_ops, (Qobj, QobjEvo)):
-+        c_ops = [c_ops]
-+    if chi and len(chi) != len(c_ops):
-+        raise ValueError('chi must be a list with same length as c_ops')
-+    chi = chi or [0] * len(c_ops)
-+
-+    if H is None:
-+        # No Hamiltonian, add the lindblad_dissipator of c_ops:
-+        if not c_ops:
-+            raise ValueError("The liouvillian need an Hamiltonian"
-+                             " and/or c_ops")
-+        out = sum(lindblad_dissipator(c_op, chi=chi_)
-+                  for c_op, chi_ in zip(c_ops, chi))
-+        return out.data if data_only else out
-+    elif not H.isoper:
-+        raise TypeError("Invalid type for Hamiltonian.")
-+
-+    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
-+        # With QobjEvo, faster computation using Data is not used
-+        L = -1.0j * (spre(H) - spost(H))
-+        L += sum(lindblad_dissipator(c_op, chi=chi_)
-+                 for c_op, chi_ in zip(c_ops, chi))
-+        return L
-+
-+    op_dims = H.dims
-+    op_shape = H.shape
-+    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
-+    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
-+    spI = _data.identity(op_shape[0], dtype=type(H.data))
-+
-+    data = _data.mul(_data.kron(spI, H.data), -1j)
-+    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
-+
-+    for c_op, chi_ in zip(c_ops, chi):
-+        c = c_op.data
-+        cd = c.adjoint()
-+        cdc = _data.matmul(cd, c)
-+        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
-+        data = _data.add(data, _data.kron(spI, cdc), -0.5)
-+        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
-+
-+    if data_only:
-+        return data
-+    else:
-+        return Qobj(data,
-+                    dims=sop_dims,
-+                    type='super',
-+                    superrep='super',
-+                    copy=False)
-+
-+
-+def lindblad_dissipator(a, b=None, data_only=False, chi=None):
-+    """
-+    Lindblad dissipator (generalized) for a single pair of collapse operators
-+    (a, b), or for a single collapse operator (a) when b is not specified:
-+
-+    .. math::
-+
-+        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
-+        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
-+
-+    Parameters
-+    ----------
-+    a : Qobj or QobjEvo
-+        Left part of collapse operator.
-+
-+    b : Qobj or QobjEvo (optional)
-+        Right part of collapse operator. If not specified, b defaults to a.
-+
-+    chi : float [None]
-+        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
-+        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
-+        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
-+        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
-+        is introduced via the generating function of the statistical moments. For examples of the technique,
-+        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
-+        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
-+        This parameter is deprecated and may be removed in QuTiP 5.
-+
-+    data_only :  bool [False]
-+        Return the data object instead of a Qobj
-+
-+    Returns
-+    -------
-+    D : qobj, QobjEvo
-+        Lindblad dissipator superoperator.
-+    """
-+    # To avoid circular dependencies
-+    from .cy.qobjevo import QobjEvo
-+    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
-+        raise ValueError("Cannot return the data object when computing the"
-+                         " collapse of a QobjEvo")
-+    if b is None:
-+        b = a
-+    ad_b = a.dag() * b
-+    if chi:
-+        D = (
-+            spre(a) * spost(b.dag()) * np.exp(1j * chi)
-+            - 0.5 * spre(ad_b)
-+            - 0.5 * spost(ad_b)
-+        )
-+    else:
-+        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
-+
-+    return D.data if data_only else D
-+
-+
-+@_map_over_compound_operators
-+def operator_to_vector(op):
-+    """
-+    Create a vector representation given a quantum operator in matrix form.
-+    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
-+    function is not designed for general-purpose matrix reshaping.
-+
-+    Parameters
-+    ----------
-+    op : Qobj or QobjEvo
-+        Quantum operator in matrix form.  This must have a type of 'oper' or
-+        'super'.
-+
-+    Returns
-+    -------
-+    Qobj or QobjEvo
-+        The same object, but re-cast into a column-stacked-vector form of type
-+        'operator-ket'.  The output is the same type as the passed object.
-+    """
-+    if op.type in ['super', 'operator-ket', 'operator-bra']:
-+        raise TypeError("Cannot convert object already "
-+                        "in super representation")
-+    return Qobj(stack_columns(op.data),
-+                dims=[op.dims, [1]],
-+                type='operator-ket',
-+                superrep="super",
-+                copy=False)
-+
-+
-+@_map_over_compound_operators
-+def vector_to_operator(op):
-+    """
-+    Create a matrix representation given a quantum operator in vector form.
-+    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
-+    function is not designed for general-purpose matrix reshaping.
-+
-+    Parameters
-+    ----------
-+    op : Qobj or QobjEvo
-+        Quantum operator in column-stacked-vector form.  This must have a type
-+        of 'operator-ket'.
-+
-+    Returns
-+    -------
-+    Qobj or QobjEvo
-+        The same object, but re-cast into "standard" operator form.  The output
-+        is the same type as the passed object.
-+    """
-+    if not op.isoperket:
-+        raise TypeError("only defined for operator-kets")
-+    if op.superrep != "super":
-+        raise TypeError("only defined for operator-kets in super format")
-+    dims = op.dims[0]
-+    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
-+                dims=dims,
-+                copy=False)
-+
-+
-+def stack_columns(matrix):
-+    """
-+    Stack the columns in a data-layer type, useful for converting an operator
-+    into a superoperator representation.
-+    """
-+    if not isinstance(matrix, (_data.Data, np.ndarray)):
-+        raise TypeError(
-+            "input " + repr(type(matrix)) + " is not data-layer type"
-+        )
-+    if isinstance(matrix, np.ndarray):
-+        return matrix.ravel('F')[:, None]
-+    return _data.column_stack(matrix)
-+
-+
-+def unstack_columns(vector, shape=None):
-+    """
-+    Unstack the columns in a data-layer type back into a 2D shape, useful for
-+    converting an operator in vector form back into a regular operator.  If
-+    `shape` is not passed, the output operator will be assumed to be square.
-+    """
-+    if not isinstance(vector, (_data.Data, np.ndarray)):
-+        raise TypeError(
-+            "input " + repr(type(vector)) + " is not data-layer type"
-+        )
-+    if (
-+        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
-+        or (isinstance(vector, np.ndarray)
-+            and ((vector.ndim == 2 and vector.shape[1] != 1)
-+                 or vector.ndim > 2))
-+    ):
-+        raise TypeError("input is not a single column")
-+    if shape is None:
-+        n = int(np.sqrt(vector.shape[0]))
-+        if n * n != vector.shape[0]:
-+            raise ValueError(
-+                "input cannot be made square, but no specific shape given"
-+            )
-+        shape = (n, n)
-+    if isinstance(vector, np.ndarray):
-+        return vector.reshape(shape, order='F')
-+    return _data.column_unstack(vector, shape[0])
-+
-+
-+def unstacked_index(size, index):
-+    """
-+    Convert an index into a column-stacked square operator with `size` rows and
-+    columns, into a pair of indices into the unstacked operator.
-+    """
-+    return index % size, index // size
-+
-+
-+def stacked_index(size, row, col):
-+    """
-+    Convert a pair of indices into a square operator of `size` into a single
-+    index into the column-stacked version of the operator.
-+    """
-+    return row + size*col
-+
-+
-+@_map_over_compound_operators
-+def spost(A):
-+    """
-+    Superoperator formed from post-multiplication by operator A
-+
-+    Parameters
-+    ----------
-+    A : Qobj or QobjEvo
-+        Quantum operator for post multiplication.
-+
-+    Returns
-+    -------
-+    super : Qobj or QobjEvo
-+        Superoperator formed from input qauntum object.
-+    """
-+    if not A.isoper:
-+        raise TypeError('Input is not a quantum operator')
-+    data = _data.kron(A.data.transpose(),
-+                      _data.identity(A.shape[0], dtype=type(A.data)))
-+    return Qobj(data,
-+                dims=[A.dims, A.dims],
-+                type='super',
-+                superrep='super',
-+                isherm=A._isherm,
-+                copy=False)
-+
-+
-+@_map_over_compound_operators
-+def spre(A):
-+    """Superoperator formed from pre-multiplication by operator A.
-+
-+    Parameters
-+    ----------
-+    A : Qobj or QobjEvo
-+        Quantum operator for pre-multiplication.
-+
-+    Returns
-+    -------
-+    super :Qobj or QobjEvo
-+        Superoperator formed from input quantum object.
-+    """
-+    if not A.isoper:
-+        raise TypeError('Input is not a quantum operator')
-+    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
-+    return Qobj(data,
-+                dims=[A.dims, A.dims],
-+                type='super',
-+                superrep='super',
-+                isherm=A._isherm,
-+                copy=False)
-+
-+
-+def _drop_projected_dims(dims):
-+    """
-+    Eliminate subsystems that has been collapsed to only one state due to
-+    a projection.
-+    """
-+    return [d for d in dims if d != 1]
-+
-+
-+def sprepost(A, B):
-+    """
-+    Superoperator formed from pre-multiplication by A and post-multiplication
-+    by B.
-+
-+    Parameters
-+    ----------
-+    A : Qobj or QobjEvo
-+        Quantum operator for pre-multiplication.
-+
-+    B : Qobj or QobjEvo
-+        Quantum operator for post-multiplication.
-+
-+    Returns
-+    -------
-+    super : Qobj or QobjEvo
-+        Superoperator formed from input quantum objects.
-+    """
-+    # To avoid circular dependencies
-+    from .cy.qobjevo import QobjEvo
-+    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
-+        return spre(A) * spost(B)
-+    dims = [[_drop_projected_dims(A.dims[0]),
-+             _drop_projected_dims(B.dims[1])],
-+            [_drop_projected_dims(A.dims[1]),
-+             _drop_projected_dims(B.dims[0])]]
-+    return Qobj(_data.kron(B.data.transpose(), A.data),
-+                dims=dims,
-+                type='super',
-+                superrep='super',
-+                isherm=A._isherm and B._isherm,
-+                copy=False)
-+
-+
-+def reshuffle(q_oper):
-+    """
-+    Column-reshuffles a ``type="super"`` Qobj.
-+    """
-+    if q_oper.type not in ('super', 'operator-ket'):
-+        raise TypeError("Reshuffling is only supported on type='super' "
-+                        "or type='operator-ket'.")
-+    # How many indices are there, and how many subsystems can we decompose
-+    # each index into?
-+    n_indices = len(q_oper.dims[0])
-+    n_subsystems = len(q_oper.dims[0][0])
-+    # Generate a list of lists (lol) that represents the permutation order we
-+    # need. It's easiest to do so if we make an array, then turn it into a lol
-+    # by using map(list, ...). That array is generated by using reshape and
-+    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
-+    # [a, a, ..., a, b, b, ..., b].
-+    perm_idxs = map(list,
-+                    np.arange(n_subsystems * n_indices)[
-+                        np.arange(n_subsystems * n_indices).reshape(
-+                            (n_indices, n_subsystems)).T.flatten()
-+                    ].reshape((n_subsystems, n_indices))
-+                    )
-+    return q_oper.permute(list(perm_idxs))
-diff --git a/qutip/core/tensor.py b/qutip/core/tensor.py
-index 969d2ad8..7947b3ab 100644
---- a/qutip/core/tensor.py
-+++ b/qutip/core/tensor.py
-@@ -1,462 +1,462 @@
--"""
--Module for the creation of composite quantum objects via the tensor product.
--"""
--
--__all__ = [
--    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
--    'expand_operator'
--]
--
--import numpy as np
--from functools import partial
--from .operators import qeye
--from .qobj import Qobj
--from .superoperator import operator_to_vector, reshuffle
--from .dimensions import (
--    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
--    dims_idxs_to_tensor_idxs
--)
--from . import data as _data
--
--
--class _reverse_partial_tensor:
--    """ Picklable lambda op: tensor(op, right) """
--    def __init__(self, right):
--        self.right = right
--
--    def __call__(self, op):
--        return tensor(op, self.right)
--
--
--def tensor(*args):
--    """Calculates the tensor product of input operators.
--
--    Parameters
--    ----------
--    args : array_like
--        ``list`` or ``array`` of quantum objects for tensor product.
--
--    Returns
--    -------
--    obj : qobj
--        A composite quantum object.
--
--    Examples
--    --------
--    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
--    Quantum object: dims = [[2, 2], [2, 2]], \
--shape = [4, 4], type = oper, isHerm = True
--    Qobj data =
--    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
--     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
--     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
--     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
--    """
--    from .cy.qobjevo import QobjEvo
--    if not args:
--        raise TypeError("Requires at least one input argument")
--    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
--        return args[0].copy()
--    if len(args) == 1:
--        try:
--            args = tuple(args[0])
--        except TypeError:
--            raise TypeError("requires Qobj or QobjEvo operands") from None
--    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
--        raise TypeError("requires Qobj or QobjEvo operands")
--    if any(isinstance(q, QobjEvo) for q in args):
--        # First make tensor from pairs only
--        if len(args) >= 3:
--            return tensor(args[0], tensor(args[1:]))
--
--        left, right = args
--        if isinstance(left, Qobj):
--            return right.linear_map(partial(tensor, left))
--        if isinstance(right, Qobj):
--            return left.linear_map(_reverse_partial_tensor(right))
--        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
--        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
--        return left_t @ right_t
--
--    if not all(q.superrep == args[0].superrep for q in args[1:]):
--        raise TypeError("".join([
--            "In tensor products of superroperators,",
--            " all must have the same representation"
--        ]))
--    type = args[0].type
--    isherm = args[0]._isherm
--    isunitary = args[0]._isunitary
--    out_data = args[0].data
--    dims_l = [d for arg in args for d in arg.dims[0]]
--    dims_r = [d for arg in args for d in arg.dims[1]]
--    for arg in args[1:]:
--        out_data = _data.kron(out_data, arg.data)
--        # If both _are_ Hermitian and/or unitary, then so is the output, but if
--        # both _aren't_, then output still can be.
--        isherm = (isherm and arg._isherm) or None
--        isunitary = (isunitary and arg._isunitary) or None
--        if arg.type != type:
--            type = None
--    return Qobj(out_data,
--                dims=[dims_l, dims_r],
--                type=type,
--                isherm=isherm,
--                isunitary=isunitary,
--                superrep=args[0].superrep,
--                copy=False)
--
--
--def super_tensor(*args):
--    """
--    Calculate the tensor product of input superoperators, by tensoring together
--    the underlying Hilbert spaces on which each vectorized operator acts.
--
--    Parameters
--    ----------
--    args : array_like
--        ``list`` or ``array`` of quantum objects with ``type="super"``.
--
--    Returns
--    -------
--    obj : qobj
--        A composite quantum object.
--    """
--    if isinstance(args[0], list):
--        args = args[0]
--
--    # Check if we're tensoring vectors or superoperators.
--    if all(arg.issuper for arg in args):
--        if not all(arg.superrep == "super" for arg in args):
--            raise TypeError(
--                "super_tensor on type='super' is only implemented for "
--                "superrep='super'."
--            )
--
--        # Reshuffle the superoperators.
--        shuffled_ops = list(map(reshuffle, args))
--
--        # Tensor the result.
--        shuffled_tensor = tensor(shuffled_ops)
--
--        # Unshuffle and return.
--        out = reshuffle(shuffled_tensor)
--        out.superrep = args[0].superrep
--        return out
--    if all(arg.isoperket for arg in args):
--
--        # Reshuffle the superoperators.
--        shuffled_ops = list(map(reshuffle, args))
--
--        # Tensor the result.
--        shuffled_tensor = tensor(shuffled_ops)
--
--        # Unshuffle and return.
--        out = reshuffle(shuffled_tensor)
--        return out
--
--    if all(arg.isoperbra for arg in args):
--        return super_tensor(*(arg.dag() for arg in args)).dag()
--    raise TypeError(
--        "All arguments must be the same type, "
--        "either super, operator-ket or operator-bra."
--    )
--
--
--def _isoperlike(q):
--    return q.isoper or q.issuper
--
--
--def _isketlike(q):
--    return q.isket or q.isoperket
--
--
--def _isbralike(q):
--    return q.isbra or q.isoperbra
--
--
--def composite(*args):
--    """
--    Given two or more operators, kets or bras, returns the Qobj
--    corresponding to a composite system over each argument.
--    For ordinary operators and vectors, this is the tensor product,
--    while for superoperators and vectorized operators, this is
--    the column-reshuffled tensor product.
--
--    If a mix of Qobjs supported on Hilbert and Liouville spaces
--    are passed in, the former are promoted. Ordinary operators
--    are assumed to be unitaries, and are promoted using ``to_super``,
--    while kets and bras are promoted by taking their projectors and
--    using ``operator_to_vector(ket2dm(arg))``.
--    """
--    import qutip.core.superop_reps
--    # First step will be to ensure everything is a Qobj at all.
--    if not all(isinstance(arg, Qobj) for arg in args):
--        raise TypeError("All arguments must be Qobjs.")
--
--    # Next, figure out if we have something oper-like (isoper or issuper),
--    # or something ket-like (isket or isoperket). Bra-like we'll deal with
--    # by turning things into ket-likes and back.
--    if all(map(_isoperlike, args)):
--        if any(arg.issuper for arg in args):
--            # to_super will promote 'oper' and leave 'super' untouched
--            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
--        return tensor(*args)
--    if all(map(_isketlike, args)):
--        if any(arg.isoperket for arg in args):
--            return super_tensor(*(
--                arg if arg.isoperket else operator_to_vector(arg.proj())
--                for arg in args
--            ))
--        return tensor(*args)
--    if all(map(_isbralike, args)):
--        # Turn into ket-likes and recurse.
--        return composite(*(arg.dag() for arg in args)).dag()
--    raise TypeError("Unsupported Qobj types [{}].".format(
--        ", ".join(arg.type for arg in args)
--    ))
--
--
--def _tensor_contract_single(arr, i, j):
--    """
--    Contracts a dense tensor along a single index pair.
--    """
--    if arr.shape[i] != arr.shape[j]:
--        raise ValueError("Cannot contract over indices of different length.")
--    idxs = np.arange(arr.shape[i])
--    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
--               for idx in range(arr.ndim))
--    contract_at = i if j == i + 1 else 0
--    return np.sum(arr[sl], axis=contract_at)
--
--
--def _tensor_contract_dense(arr, *pairs):
--    """
--    Contracts a dense tensor along one or more index pairs,
--    keeping track of how the indices are relabeled by the removal
--    of other indices.
--    """
--    axis_idxs = list(range(arr.ndim))
--    for pair in pairs:
--        # axis_idxs.index effectively evaluates the mapping from original index
--        # labels to the labels after contraction.
--        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
--        axis_idxs.remove(pair[0])
--        axis_idxs.remove(pair[1])
--    return arr
--
--
--def tensor_swap(q_oper, *pairs):
--    """Transposes one or more pairs of indices of a Qobj.
--    Note that this uses dense representations and thus
--    should *not* be used for very large Qobjs.
--
--    Parameters
--    ----------
--
--    pairs : tuple
--        One or more tuples ``(i, j)`` indicating that the
--        ``i`` and ``j`` dimensions of the original qobj
--        should be swapped.
--
--    Returns
--    -------
--
--    sqobj : Qobj
--        The original Qobj with all named index pairs swapped with each other
--    """
--    dims = q_oper.dims
--    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
--    data = q_oper.full()
--    # Reshape into tensor indices
--    data = data.reshape(dims_to_tensor_shape(dims))
--    # Now permute the dims list so we know how to get back.
--    flat_dims = flatten(dims)
--    perm = list(range(len(flat_dims)))
--    for i, j in pairs:
--        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
--    for i, j in tensor_pairs:
--        perm[i], perm[j] = perm[j], perm[i]
--    dims = unflatten(flat_dims, enumerate_flat(dims))
--    # Next, permute the actual indices of the dense tensor.
--    data = data.transpose(perm)
--    # Reshape back, using the left and right of dims.
--    data = data.reshape(list(map(np.prod, dims)))
--    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
--
--
--def tensor_contract(qobj, *pairs):
--    """Contracts a qobj along one or more index pairs.
--    Note that this uses dense representations and thus
--    should *not* be used for very large Qobjs.
--
--    Parameters
--    ----------
--
--    pairs : tuple
--        One or more tuples ``(i, j)`` indicating that the
--        ``i`` and ``j`` dimensions of the original qobj
--        should be contracted.
--
--    Returns
--    -------
--
--    cqobj : Qobj
--        The original Qobj with all named index pairs contracted
--        away.
--
--    """
--    # Record and label the original dims.
--    dims = qobj.dims
--    dims_idxs = enumerate_flat(dims)
--    tensor_dims = dims_to_tensor_shape(dims)
--
--    # Convert to dense first, since sparse won't support the reshaping we need.
--    qtens = qobj.data.to_array()
--
--    # Reshape by the flattened dims.
--    qtens = qtens.reshape(tensor_dims)
--
--    # Contract out the indices from the flattened object.
--    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
--    # to ensure that we are contracting the right indices.
--    qtens = _tensor_contract_dense(qtens,
--                                   *dims_idxs_to_tensor_idxs(dims, pairs))
--
--    # Remove the contracted indexes from dims so we know how to
--    # reshape back.
--    # This concerns dims, and not the tensor indices, so we need
--    # to make sure to use the original dims indices and not the ones
--    # generated by dims_to_* functions.
--    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
--    contracted_dims = unflatten(flatten(dims), contracted_idxs)
--
--    # We don't need to check for tensor idxs versus dims idxs here,
--    # as column- versus row-stacking will never move an index for the
--    # vectorized operator spaces all the way from the left to the right.
--    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
--
--    # Reshape back into a 2D matrix.
--    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
--
--    # Return back as a qobj.
--    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
--
--
--def _check_oper_dims(oper, dims=None, targets=None):
--    """
--    Check if the given operator is valid.
--
--    Parameters
--    ----------
--    oper : :class:`qutip.Qobj`
--        The quantum object to be checked.
--    dims : list, optional
--        A list of integer for the dimension of each composite system.
--        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
--    targets : int or list of int, optional
--        The indices of subspace that are acted on.
--    """
--    # if operator matches N
--    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
--        raise ValueError(
--            "The operator is not an "
--            "Qobj with the same input and output dimensions.")
--    # if operator dims matches the target dims
--    if dims is not None and targets is not None:
--        targ_dims = [dims[t] for t in targets]
--        if oper.dims[0] != targ_dims:
--            raise ValueError(
--                "The operator dims {} do not match "
--                "the target dims {}.".format(
--                    oper.dims[0], targ_dims))
--
--
--def _targets_to_list(targets, oper=None, N=None):
--    """
--    transform targets to a list and check validity.
--
--    Parameters
--    ----------
--    targets : int or list of int
--        The indices of subspace that are acted on.
--    oper : :class:`qutip.Qobj`, optional
--        An operator, the type of the :class:`qutip.Qobj`
--        has to be an operator
--        and the dimension matches the tensored qubit Hilbert space
--        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
--    N : int, optional
--        The number of subspace in the system.
--    """
--    # if targets is a list of integer
--    if targets is None:
--        targets = list(range(len(oper.dims[0])))
--    if not hasattr(targets, '__iter__'):
--        targets = [targets]
--    if not all([isinstance(t, int) for t in targets]):
--        raise TypeError(
--            "targets should be "
--            "an integer or a list of integer")
--    # if targets has correct length
--    if oper is not None:
--        req_num = len(oper.dims[0])
--        if len(targets) != req_num:
--            raise ValueError(
--                "The given operator needs {} "
--                "target qutbis, "
--                "but {} given.".format(
--                    req_num, len(targets)))
--    # if targets is smaller than N
--    if N is not None:
--        if not all([t < N for t in targets]):
--            raise ValueError("Targets must be smaller than N={}.".format(N))
--    return targets
--
--
--def expand_operator(oper, dims, targets):
--    """
--    Expand an operator to one that acts on a system with desired dimensions.
--    e.g.
--    ```
--    expand_operator(oper, [2, 3, 4, 5], 2) ==
--        tensor(qeye(2), qeye(3), oper, qeye(5))
--    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
--        tensor(oper2, qeye(3), oper1, qeye(5))
--    ```
--
--    Parameters
--    ----------
--    oper : :class:`qutip.Qobj`
--        An operator that act on the subsystem, has to be an operator and the
--        dimension matches the tensored dims Hilbert space
--        e.g. oper.dims = ``[[2, 3], [2, 3]]``
--    dims : list
--        A list of integer for the dimension of each composite system.
--        E.g ``[2, 3, 2, 3, 4]``.
--    targets : int or list of int
--        The indices of subspace that are acted on.
--
--    Returns
--    -------
--    expanded_oper : :class:`qutip.Qobj`
--        The expanded operator acting on a system with desired dimension.
--    """
--    from .operators import identity
--    N = len(dims)
--    targets = _targets_to_list(targets, oper=oper, N=N)
--    _check_oper_dims(oper, dims=dims, targets=targets)
--
--    # Generate the correct order for permutation,
--    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
--    # If the operator is cnot,
--    # this order means that the 3rd qubit controls the 0th qubit.
--    new_order = [0] * N
--    for i, t in enumerate(targets):
--        new_order[t] = i
--    # allocate the rest qutbits (not targets) to the empty
--    # position in new_order
--    rest_pos = [q for q in list(range(N)) if q not in targets]
--    rest_qubits = list(range(len(targets), N))
--    for i, ind in enumerate(rest_pos):
--        new_order[ind] = rest_qubits[i]
--    id_list = [identity(dims[i]) for i in rest_pos]
--    return tensor([oper] + id_list).permute(new_order)
-+"""
-+Module for the creation of composite quantum objects via the tensor product.
-+"""
-+
-+__all__ = [
-+    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
-+    'expand_operator'
-+]
-+
-+import numpy as np
-+from functools import partial
-+from .operators import qeye
-+from .qobj import Qobj
-+from .superoperator import operator_to_vector, reshuffle
-+from .dimensions import (
-+    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
-+    dims_idxs_to_tensor_idxs
-+)
-+from . import data as _data
-+
-+
-+class _reverse_partial_tensor:
-+    """ Picklable lambda op: tensor(op, right) """
-+    def __init__(self, right):
-+        self.right = right
-+
-+    def __call__(self, op):
-+        return tensor(op, self.right)
-+
-+
-+def tensor(*args):
-+    """Calculates the tensor product of input operators.
-+
-+    Parameters
-+    ----------
-+    args : array_like
-+        ``list`` or ``array`` of quantum objects for tensor product.
-+
-+    Returns
-+    -------
-+    obj : qobj
-+        A composite quantum object.
-+
-+    Examples
-+    --------
-+    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
-+    Quantum object: dims = [[2, 2], [2, 2]], \
-+shape = [4, 4], type = oper, isHerm = True
-+    Qobj data =
-+    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
-+     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
-+     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
-+     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
-+    """
-+    from .cy.qobjevo import QobjEvo
-+    if not args:
-+        raise TypeError("Requires at least one input argument")
-+    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
-+        return args[0].copy()
-+    if len(args) == 1:
-+        try:
-+            args = tuple(args[0])
-+        except TypeError:
-+            raise TypeError("requires Qobj or QobjEvo operands") from None
-+    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
-+        raise TypeError("requires Qobj or QobjEvo operands")
-+    if any(isinstance(q, QobjEvo) for q in args):
-+        # First make tensor from pairs only
-+        if len(args) >= 3:
-+            return tensor(args[0], tensor(args[1:]))
-+
-+        left, right = args
-+        if isinstance(left, Qobj):
-+            return right.linear_map(partial(tensor, left))
-+        if isinstance(right, Qobj):
-+            return left.linear_map(_reverse_partial_tensor(right))
-+        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
-+        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
-+        return left_t @ right_t
-+
-+    if not all(q.superrep == args[0].superrep for q in args[1:]):
-+        raise TypeError("".join([
-+            "In tensor products of superroperators,",
-+            " all must have the same representation"
-+        ]))
-+    type = args[0].type
-+    isherm = args[0]._isherm
-+    isunitary = args[0]._isunitary
-+    out_data = args[0].data
-+    dims_l = [d for arg in args for d in arg.dims[0]]
-+    dims_r = [d for arg in args for d in arg.dims[1]]
-+    for arg in args[1:]:
-+        out_data = _data.kron(out_data, arg.data)
-+        # If both _are_ Hermitian and/or unitary, then so is the output, but if
-+        # both _aren't_, then output still can be.
-+        isherm = (isherm and arg._isherm) or None
-+        isunitary = (isunitary and arg._isunitary) or None
-+        if arg.type != type:
-+            type = None
-+    return Qobj(out_data,
-+                dims=[dims_l, dims_r],
-+                type=type,
-+                isherm=isherm,
-+                isunitary=isunitary,
-+                superrep=args[0].superrep,
-+                copy=False)
-+
-+
-+def super_tensor(*args):
-+    """
-+    Calculate the tensor product of input superoperators, by tensoring together
-+    the underlying Hilbert spaces on which each vectorized operator acts.
-+
-+    Parameters
-+    ----------
-+    args : array_like
-+        ``list`` or ``array`` of quantum objects with ``type="super"``.
-+
-+    Returns
-+    -------
-+    obj : qobj
-+        A composite quantum object.
-+    """
-+    if isinstance(args[0], list):
-+        args = args[0]
-+
-+    # Check if we're tensoring vectors or superoperators.
-+    if all(arg.issuper for arg in args):
-+        if not all(arg.superrep == "super" for arg in args):
-+            raise TypeError(
-+                "super_tensor on type='super' is only implemented for "
-+                "superrep='super'."
-+            )
-+
-+        # Reshuffle the superoperators.
-+        shuffled_ops = list(map(reshuffle, args))
-+
-+        # Tensor the result.
-+        shuffled_tensor = tensor(shuffled_ops)
-+
-+        # Unshuffle and return.
-+        out = reshuffle(shuffled_tensor)
-+        out.superrep = args[0].superrep
-+        return out
-+    if all(arg.isoperket for arg in args):
-+
-+        # Reshuffle the superoperators.
-+        shuffled_ops = list(map(reshuffle, args))
-+
-+        # Tensor the result.
-+        shuffled_tensor = tensor(shuffled_ops)
-+
-+        # Unshuffle and return.
-+        out = reshuffle(shuffled_tensor)
-+        return out
-+
-+    if all(arg.isoperbra for arg in args):
-+        return super_tensor(*(arg.dag() for arg in args)).dag()
-+    raise TypeError(
-+        "All arguments must be the same type, "
-+        "either super, operator-ket or operator-bra."
-+    )
-+
-+
-+def _isoperlike(q):
-+    return q.isoper or q.issuper
-+
-+
-+def _isketlike(q):
-+    return q.isket or q.isoperket
-+
-+
-+def _isbralike(q):
-+    return q.isbra or q.isoperbra
-+
-+
-+def composite(*args):
-+    """
-+    Given two or more operators, kets or bras, returns the Qobj
-+    corresponding to a composite system over each argument.
-+    For ordinary operators and vectors, this is the tensor product,
-+    while for superoperators and vectorized operators, this is
-+    the column-reshuffled tensor product.
-+
-+    If a mix of Qobjs supported on Hilbert and Liouville spaces
-+    are passed in, the former are promoted. Ordinary operators
-+    are assumed to be unitaries, and are promoted using ``to_super``,
-+    while kets and bras are promoted by taking their projectors and
-+    using ``operator_to_vector(ket2dm(arg))``.
-+    """
-+    import qutip.core.superop_reps
-+    # First step will be to ensure everything is a Qobj at all.
-+    if not all(isinstance(arg, Qobj) for arg in args):
-+        raise TypeError("All arguments must be Qobjs.")
-+
-+    # Next, figure out if we have something oper-like (isoper or issuper),
-+    # or something ket-like (isket or isoperket). Bra-like we'll deal with
-+    # by turning things into ket-likes and back.
-+    if all(map(_isoperlike, args)):
-+        if any(arg.issuper for arg in args):
-+            # to_super will promote 'oper' and leave 'super' untouched
-+            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
-+        return tensor(*args)
-+    if all(map(_isketlike, args)):
-+        if any(arg.isoperket for arg in args):
-+            return super_tensor(*(
-+                arg if arg.isoperket else operator_to_vector(arg.proj())
-+                for arg in args
-+            ))
-+        return tensor(*args)
-+    if all(map(_isbralike, args)):
-+        # Turn into ket-likes and recurse.
-+        return composite(*(arg.dag() for arg in args)).dag()
-+    raise TypeError("Unsupported Qobj types [{}].".format(
-+        ", ".join(arg.type for arg in args)
-+    ))
-+
-+
-+def _tensor_contract_single(arr, i, j):
-+    """
-+    Contracts a dense tensor along a single index pair.
-+    """
-+    if arr.shape[i] != arr.shape[j]:
-+        raise ValueError("Cannot contract over indices of different length.")
-+    idxs = np.arange(arr.shape[i])
-+    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
-+               for idx in range(arr.ndim))
-+    contract_at = i if j == i + 1 else 0
-+    return np.sum(arr[sl], axis=contract_at)
-+
-+
-+def _tensor_contract_dense(arr, *pairs):
-+    """
-+    Contracts a dense tensor along one or more index pairs,
-+    keeping track of how the indices are relabeled by the removal
-+    of other indices.
-+    """
-+    axis_idxs = list(range(arr.ndim))
-+    for pair in pairs:
-+        # axis_idxs.index effectively evaluates the mapping from original index
-+        # labels to the labels after contraction.
-+        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
-+        axis_idxs.remove(pair[0])
-+        axis_idxs.remove(pair[1])
-+    return arr
-+
-+
-+def tensor_swap(q_oper, *pairs):
-+    """Transposes one or more pairs of indices of a Qobj.
-+    Note that this uses dense representations and thus
-+    should *not* be used for very large Qobjs.
-+
-+    Parameters
-+    ----------
-+
-+    pairs : tuple
-+        One or more tuples ``(i, j)`` indicating that the
-+        ``i`` and ``j`` dimensions of the original qobj
-+        should be swapped.
-+
-+    Returns
-+    -------
-+
-+    sqobj : Qobj
-+        The original Qobj with all named index pairs swapped with each other
-+    """
-+    dims = q_oper.dims
-+    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
-+    data = q_oper.full()
-+    # Reshape into tensor indices
-+    data = data.reshape(dims_to_tensor_shape(dims))
-+    # Now permute the dims list so we know how to get back.
-+    flat_dims = flatten(dims)
-+    perm = list(range(len(flat_dims)))
-+    for i, j in pairs:
-+        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
-+    for i, j in tensor_pairs:
-+        perm[i], perm[j] = perm[j], perm[i]
-+    dims = unflatten(flat_dims, enumerate_flat(dims))
-+    # Next, permute the actual indices of the dense tensor.
-+    data = data.transpose(perm)
-+    # Reshape back, using the left and right of dims.
-+    data = data.reshape(list(map(np.prod, dims)))
-+    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
-+
-+
-+def tensor_contract(qobj, *pairs):
-+    """Contracts a qobj along one or more index pairs.
-+    Note that this uses dense representations and thus
-+    should *not* be used for very large Qobjs.
-+
-+    Parameters
-+    ----------
-+
-+    pairs : tuple
-+        One or more tuples ``(i, j)`` indicating that the
-+        ``i`` and ``j`` dimensions of the original qobj
-+        should be contracted.
-+
-+    Returns
-+    -------
-+
-+    cqobj : Qobj
-+        The original Qobj with all named index pairs contracted
-+        away.
-+
-+    """
-+    # Record and label the original dims.
-+    dims = qobj.dims
-+    dims_idxs = enumerate_flat(dims)
-+    tensor_dims = dims_to_tensor_shape(dims)
-+
-+    # Convert to dense first, since sparse won't support the reshaping we need.
-+    qtens = qobj.data.to_array()
-+
-+    # Reshape by the flattened dims.
-+    qtens = qtens.reshape(tensor_dims)
-+
-+    # Contract out the indices from the flattened object.
-+    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
-+    # to ensure that we are contracting the right indices.
-+    qtens = _tensor_contract_dense(qtens,
-+                                   *dims_idxs_to_tensor_idxs(dims, pairs))
-+
-+    # Remove the contracted indexes from dims so we know how to
-+    # reshape back.
-+    # This concerns dims, and not the tensor indices, so we need
-+    # to make sure to use the original dims indices and not the ones
-+    # generated by dims_to_* functions.
-+    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
-+    contracted_dims = unflatten(flatten(dims), contracted_idxs)
-+
-+    # We don't need to check for tensor idxs versus dims idxs here,
-+    # as column- versus row-stacking will never move an index for the
-+    # vectorized operator spaces all the way from the left to the right.
-+    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
-+
-+    # Reshape back into a 2D matrix.
-+    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
-+
-+    # Return back as a qobj.
-+    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
-+
-+
-+def _check_oper_dims(oper, dims=None, targets=None):
-+    """
-+    Check if the given operator is valid.
-+
-+    Parameters
-+    ----------
-+    oper : :class:`qutip.Qobj`
-+        The quantum object to be checked.
-+    dims : list, optional
-+        A list of integer for the dimension of each composite system.
-+        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
-+    targets : int or list of int, optional
-+        The indices of subspace that are acted on.
-+    """
-+    # if operator matches N
-+    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
-+        raise ValueError(
-+            "The operator is not an "
-+            "Qobj with the same input and output dimensions.")
-+    # if operator dims matches the target dims
-+    if dims is not None and targets is not None:
-+        targ_dims = [dims[t] for t in targets]
-+        if oper.dims[0] != targ_dims:
-+            raise ValueError(
-+                "The operator dims {} do not match "
-+                "the target dims {}.".format(
-+                    oper.dims[0], targ_dims))
-+
-+
-+def _targets_to_list(targets, oper=None, N=None):
-+    """
-+    transform targets to a list and check validity.
-+
-+    Parameters
-+    ----------
-+    targets : int or list of int
-+        The indices of subspace that are acted on.
-+    oper : :class:`qutip.Qobj`, optional
-+        An operator, the type of the :class:`qutip.Qobj`
-+        has to be an operator
-+        and the dimension matches the tensored qubit Hilbert space
-+        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
-+    N : int, optional
-+        The number of subspace in the system.
-+    """
-+    # if targets is a list of integer
-+    if targets is None:
-+        targets = list(range(len(oper.dims[0])))
-+    if not hasattr(targets, '__iter__'):
-+        targets = [targets]
-+    if not all([isinstance(t, int) for t in targets]):
-+        raise TypeError(
-+            "targets should be "
-+            "an integer or a list of integer")
-+    # if targets has correct length
-+    if oper is not None:
-+        req_num = len(oper.dims[0])
-+        if len(targets) != req_num:
-+            raise ValueError(
-+                "The given operator needs {} "
-+                "target qutbis, "
-+                "but {} given.".format(
-+                    req_num, len(targets)))
-+    # if targets is smaller than N
-+    if N is not None:
-+        if not all([t < N for t in targets]):
-+            raise ValueError("Targets must be smaller than N={}.".format(N))
-+    return targets
-+
-+
-+def expand_operator(oper, dims, targets):
-+    """
-+    Expand an operator to one that acts on a system with desired dimensions.
-+    e.g.
-+    ```
-+    expand_operator(oper, [2, 3, 4, 5], 2) ==
-+        tensor(qeye(2), qeye(3), oper, qeye(5))
-+    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
-+        tensor(oper2, qeye(3), oper1, qeye(5))
-+    ```
-+
-+    Parameters
-+    ----------
-+    oper : :class:`qutip.Qobj`
-+        An operator that act on the subsystem, has to be an operator and the
-+        dimension matches the tensored dims Hilbert space
-+        e.g. oper.dims = ``[[2, 3], [2, 3]]``
-+    dims : list
-+        A list of integer for the dimension of each composite system.
-+        E.g ``[2, 3, 2, 3, 4]``.
-+    targets : int or list of int
-+        The indices of subspace that are acted on.
-+
-+    Returns
-+    -------
-+    expanded_oper : :class:`qutip.Qobj`
-+        The expanded operator acting on a system with desired dimension.
-+    """
-+    from .operators import identity
-+    N = len(dims)
-+    targets = _targets_to_list(targets, oper=oper, N=N)
-+    _check_oper_dims(oper, dims=dims, targets=targets)
-+
-+    # Generate the correct order for permutation,
-+    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
-+    # If the operator is cnot,
-+    # this order means that the 3rd qubit controls the 0th qubit.
-+    new_order = [0] * N
-+    for i, t in enumerate(targets):
-+        new_order[t] = i
-+    # allocate the rest qutbits (not targets) to the empty
-+    # position in new_order
-+    rest_pos = [q for q in list(range(N)) if q not in targets]
-+    rest_qubits = list(range(len(targets), N))
-+    for i, ind in enumerate(rest_pos):
-+        new_order[ind] = rest_qubits[i]
-+    id_list = [identity(dims[i]) for i in rest_pos]
-+    return tensor([oper] + id_list).permute(new_order)
-diff --git a/qutip/distributions.py b/qutip/distributions.py
-index b291d51c..e85b0b00 100644
---- a/qutip/distributions.py
-+++ b/qutip/distributions.py
-@@ -1,422 +1,422 @@
--"""
--This module provides classes and functions for working with spatial
--distributions, such as Wigner distributions, etc.
--
--.. note::
--
--    Experimental.
--
--"""
--
--__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
--           'TwoModeQuadratureCorrelation',
--           'HarmonicOscillatorWaveFunction',
--           'HarmonicOscillatorProbabilityFunction']
--
--import numpy as np
--from numpy import pi, exp, sqrt
--
--from scipy.special import hermite, factorial
--
--from . import isket, ket2dm, state_number_index
--from .wigner import wigner, qfunc
--
--try:
--    import matplotlib as mpl
--    import matplotlib.pyplot as plt
--    from mpl_toolkits.mplot3d import Axes3D
--except:
--    pass
--
--
--class Distribution:
--    """A class for representation spatial distribution functions.
--
--    The Distribution class can be used to prepresent spatial distribution
--    functions of arbitray dimension (although only 1D and 2D distributions
--    are used so far).
--
--    It is indented as a base class for specific distribution function, and
--    provide implementation of basic functions that are shared among all
--    Distribution functions, such as visualization, calculating marginal
--    distributions, etc.
--
--    Parameters
--    ----------
--    data : array_like
--        Data for the distribution. The dimensions must match the lengths of
--        the coordinate arrays in xvecs.
--    xvecs : list
--        List of arrays that spans the space for each coordinate.
--    xlabels : list
--        List of labels for each coordinate.
--
--    """
--
--    def __init__(self, data=None, xvecs=[], xlabels=[]):
--        self.data = data
--        self.xvecs = xvecs
--        self.xlabels = xlabels
--
--    def visualize(self, fig=None, ax=None, figsize=(8, 6),
--                  colorbar=True, cmap=None, style="colormap",
--                  show_xlabel=True, show_ylabel=True):
--        """
--        Visualize the data of the distribution in 1D or 2D, depending
--        on the dimensionality of the underlaying distribution.
--
--        Parameters:
--
--        fig : matplotlib Figure instance
--            If given, use this figure instance for the visualization,
--
--        ax : matplotlib Axes instance
--            If given, render the visualization using this axis instance.
--
--        figsize : tuple
--            Size of the new Figure instance, if one needs to be created.
--
--        colorbar: Bool
--            Whether or not the colorbar (in 2D visualization) should be used.
--
--        cmap: matplotlib colormap instance
--            If given, use this colormap for 2D visualizations.
--
--        style : string
--            Type of visualization: 'colormap' (default) or 'surface'.
--
--        Returns
--        -------
--
--        fig, ax : tuple
--            A tuple of matplotlib figure and axes instances.
--
--        """
--        n = len(self.xvecs)
--        if n == 2:
--            if style == "colormap":
--                return self.visualize_2d_colormap(fig=fig, ax=ax,
--                                                  figsize=figsize,
--                                                  colorbar=colorbar,
--                                                  cmap=cmap,
--                                                  show_xlabel=show_xlabel,
--                                                  show_ylabel=show_ylabel)
--            else:
--                return self.visualize_2d_surface(fig=fig, ax=ax,
--                                                 figsize=figsize,
--                                                 colorbar=colorbar,
--                                                 cmap=cmap,
--                                                 show_xlabel=show_xlabel,
--                                                 show_ylabel=show_ylabel)
--
--        elif n == 1:
--            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
--                                     show_xlabel=show_xlabel,
--                                     show_ylabel=show_ylabel)
--        else:
--            raise NotImplementedError("Distribution visualization in " +
--                                      "%d dimensions is not implemented." % n)
--
--    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
--                              colorbar=True, cmap=None,
--                              show_xlabel=True, show_ylabel=True):
--
--        if not fig and not ax:
--            fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--        if cmap is None:
--            cmap = mpl.cm.get_cmap('RdBu')
--
--        lim = abs(self.data).max()
--
--        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
--                         norm=mpl.colors.Normalize(-lim, lim),
--                         cmap=cmap)
--
--        if show_xlabel:
--            ax.set_xlabel(self.xlabels[0], fontsize=12)
--        if show_ylabel:
--            ax.set_ylabel(self.xlabels[1], fontsize=12)
--
--        if colorbar:
--            cb = fig.colorbar(cf, ax=ax)
--
--        return fig, ax
--
--    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
--                             colorbar=True, cmap=None,
--                             show_xlabel=True, show_ylabel=True):
--
--        if not fig and not ax:
--            fig = plt.figure(figsize=figsize)
--            ax = Axes3D(fig, azim=-62, elev=25)
--
--        if cmap is None:
--            cmap = mpl.cm.get_cmap('RdBu')
--
--        lim = abs(self.data).max()
--
--        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
--        s = ax.plot_surface(X, Y, self.data,
--                            norm=mpl.colors.Normalize(-lim, lim),
--                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
--
--        if show_xlabel:
--            ax.set_xlabel(self.xlabels[0], fontsize=12)
--        if show_ylabel:
--            ax.set_ylabel(self.xlabels[1], fontsize=12)
--
--        if colorbar:
--            cb = fig.colorbar(s, ax=ax, shrink=0.5)
--
--        return fig, ax
--
--    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
--                     show_xlabel=True, show_ylabel=True):
--
--        if not fig and not ax:
--            fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--        p = ax.plot(self.xvecs[0], self.data)
--
--        if show_xlabel:
--            ax.set_xlabel(self.xlabels[0], fontsize=12)
--        if show_ylabel:
--            ax.set_ylabel("Marginal distribution", fontsize=12)
--
--        return fig, ax
--
--    def marginal(self, dim=0):
--        """
--        Calculate the marginal distribution function along the dimension
--        `dim`. Return a new Distribution instance describing this reduced-
--        dimensionality distribution.
--
--        Parameters
--        ----------
--        dim : int
--            The dimension (coordinate index) along which to obtain the
--            marginal distribution.
--
--        Returns
--        -------
--
--        d : Distributions
--            A new instances of Distribution that describes the marginal
--            distribution.
--
--        """
--        return Distribution(data=self.data.mean(axis=dim),
--                            xvecs=[self.xvecs[dim]],
--                            xlabels=[self.xlabels[dim]])
--
--    def project(self, dim=0):
--        """
--        Calculate the projection (max value) distribution function along the
--        dimension `dim`. Return a new Distribution instance describing this
--        reduced-dimensionality distribution.
--
--        Parameters
--        ----------
--        dim : int
--            The dimension (coordinate index) along which to obtain the
--            projected distribution.
--
--        Returns
--        -------
--        d : Distributions
--            A new instances of Distribution that describes the projection.
--
--        """
--        return Distribution(data=self.data.max(axis=dim),
--                            xvecs=[self.xvecs[dim]],
--                            xlabels=[self.xlabels[dim]])
--
--
--class WignerDistribution(Distribution):
--
--    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
--
--        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
--                      np.linspace(extent[1][0], extent[1][1], steps)]
--
--        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
--
--        if rho:
--            self.update(rho)
--
--    def update(self, rho):
--
--        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
--
--
--class QDistribution(Distribution):
--
--    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
--
--        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
--                      np.linspace(extent[1][0], extent[1][1], steps)]
--
--        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
--
--        if rho:
--            self.update(rho)
--
--    def update(self, rho):
--
--        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
--
--
--class TwoModeQuadratureCorrelation(Distribution):
--
--    def __init__(self, state=None, theta1=0.0, theta2=0.0,
--                 extent=[[-5, 5], [-5, 5]], steps=250):
--
--        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
--                      np.linspace(extent[1][0], extent[1][1], steps)]
--
--        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
--
--        self.theta1 = theta1
--        self.theta2 = theta2
--
--        self.update(state)
--
--    def update(self, state):
--        """
--        calculate probability distribution for quadrature measurement
--        outcomes given a two-mode wavefunction or density matrix
--        """
--        if isket(state):
--            self.update_psi(state)
--        else:
--            self.update_rho(state)
--
--    def update_psi(self, psi):
--        """
--        calculate probability distribution for quadrature measurement
--        outcomes given a two-mode wavefunction
--        """
--
--        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
--
--        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
--        N = psi.dims[0][0]
--
--        for n1 in range(N):
--            kn1 = exp(-1j * self.theta1 * n1) / \
--                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
--                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
--
--            for n2 in range(N):
--                kn2 = exp(-1j * self.theta2 * n2) / \
--                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
--                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
--                i = state_number_index([N, N], [n1, n2])
--                p += kn1 * kn2 * psi.data[i, 0]
--
--        self.data = abs(p) ** 2
--
--    def update_rho(self, rho):
--        """
--        calculate probability distribution for quadrature measurement
--        outcomes given a two-mode density matrix
--        """
--
--        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
--
--        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
--        N = rho.dims[0][0]
--
--        M1 = np.zeros(
--            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
--        M2 = np.zeros(
--            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
--
--        for m in range(N):
--            for n in range(N):
--                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
--                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
--                    exp(-X1 ** 2) * np.polyval(
--                        hermite(m), X1) * np.polyval(hermite(n), X1)
--                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
--                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
--                    exp(-X2 ** 2) * np.polyval(
--                        hermite(m), X2) * np.polyval(hermite(n), X2)
--
--        for n1 in range(N):
--            for n2 in range(N):
--                i = state_number_index([N, N], [n1, n2])
--                for p1 in range(N):
--                    for p2 in range(N):
--                        j = state_number_index([N, N], [p1, p2])
--                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
--
--        self.data = p
--
--
--class HarmonicOscillatorWaveFunction(Distribution):
--
--    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
--
--        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
--        self.xlabels = [r'$x$']
--        self.omega = omega
--
--        if psi:
--            self.update(psi)
--
--    def update(self, psi):
--        """
--        Calculate the wavefunction for the given state of an harmonic
--        oscillator
--        """
--
--        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
--        N = psi.shape[0]
--
--        for n in range(N):
--            k = pow(self.omega / pi, 0.25) / \
--                sqrt(2 ** n * factorial(n)) * \
--                exp(-self.xvecs[0] ** 2 / 2.0) * \
--                np.polyval(hermite(n), self.xvecs[0])
--
--            self.data += k * psi.data[n, 0]
--
--
--class HarmonicOscillatorProbabilityFunction(Distribution):
--
--    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
--
--        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
--        self.xlabels = [r'$x$']
--        self.omega = omega
--
--        if rho:
--            self.update(rho)
--
--    def update(self, rho):
--        """
--        Calculate the probability function for the given state of an harmonic
--        oscillator (as density matrix)
--        """
--
--        if isket(rho):
--            rho = ket2dm(rho)
--
--        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
--        M, N = rho.shape
--
--        for m in range(M):
--            k_m = pow(self.omega / pi, 0.25) / \
--                sqrt(2 ** m * factorial(m)) * \
--                exp(-self.xvecs[0] ** 2 / 2.0) * \
--                np.polyval(hermite(m), self.xvecs[0])
--
--            for n in range(N):
--                k_n = pow(self.omega / pi, 0.25) / \
--                    sqrt(2 ** n * factorial(n)) * \
--                    exp(-self.xvecs[0] ** 2 / 2.0) * \
--                    np.polyval(hermite(n), self.xvecs[0])
--
--                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
-+"""
-+This module provides classes and functions for working with spatial
-+distributions, such as Wigner distributions, etc.
-+
-+.. note::
-+
-+    Experimental.
-+
-+"""
-+
-+__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
-+           'TwoModeQuadratureCorrelation',
-+           'HarmonicOscillatorWaveFunction',
-+           'HarmonicOscillatorProbabilityFunction']
-+
-+import numpy as np
-+from numpy import pi, exp, sqrt
-+
-+from scipy.special import hermite, factorial
-+
-+from . import isket, ket2dm, state_number_index
-+from .wigner import wigner, qfunc
-+
-+try:
-+    import matplotlib as mpl
-+    import matplotlib.pyplot as plt
-+    from mpl_toolkits.mplot3d import Axes3D
-+except:
-+    pass
-+
-+
-+class Distribution:
-+    """A class for representation spatial distribution functions.
-+
-+    The Distribution class can be used to prepresent spatial distribution
-+    functions of arbitray dimension (although only 1D and 2D distributions
-+    are used so far).
-+
-+    It is indented as a base class for specific distribution function, and
-+    provide implementation of basic functions that are shared among all
-+    Distribution functions, such as visualization, calculating marginal
-+    distributions, etc.
-+
-+    Parameters
-+    ----------
-+    data : array_like
-+        Data for the distribution. The dimensions must match the lengths of
-+        the coordinate arrays in xvecs.
-+    xvecs : list
-+        List of arrays that spans the space for each coordinate.
-+    xlabels : list
-+        List of labels for each coordinate.
-+
-+    """
-+
-+    def __init__(self, data=None, xvecs=[], xlabels=[]):
-+        self.data = data
-+        self.xvecs = xvecs
-+        self.xlabels = xlabels
-+
-+    def visualize(self, fig=None, ax=None, figsize=(8, 6),
-+                  colorbar=True, cmap=None, style="colormap",
-+                  show_xlabel=True, show_ylabel=True):
-+        """
-+        Visualize the data of the distribution in 1D or 2D, depending
-+        on the dimensionality of the underlaying distribution.
-+
-+        Parameters:
-+
-+        fig : matplotlib Figure instance
-+            If given, use this figure instance for the visualization,
-+
-+        ax : matplotlib Axes instance
-+            If given, render the visualization using this axis instance.
-+
-+        figsize : tuple
-+            Size of the new Figure instance, if one needs to be created.
-+
-+        colorbar: Bool
-+            Whether or not the colorbar (in 2D visualization) should be used.
-+
-+        cmap: matplotlib colormap instance
-+            If given, use this colormap for 2D visualizations.
-+
-+        style : string
-+            Type of visualization: 'colormap' (default) or 'surface'.
-+
-+        Returns
-+        -------
-+
-+        fig, ax : tuple
-+            A tuple of matplotlib figure and axes instances.
-+
-+        """
-+        n = len(self.xvecs)
-+        if n == 2:
-+            if style == "colormap":
-+                return self.visualize_2d_colormap(fig=fig, ax=ax,
-+                                                  figsize=figsize,
-+                                                  colorbar=colorbar,
-+                                                  cmap=cmap,
-+                                                  show_xlabel=show_xlabel,
-+                                                  show_ylabel=show_ylabel)
-+            else:
-+                return self.visualize_2d_surface(fig=fig, ax=ax,
-+                                                 figsize=figsize,
-+                                                 colorbar=colorbar,
-+                                                 cmap=cmap,
-+                                                 show_xlabel=show_xlabel,
-+                                                 show_ylabel=show_ylabel)
-+
-+        elif n == 1:
-+            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
-+                                     show_xlabel=show_xlabel,
-+                                     show_ylabel=show_ylabel)
-+        else:
-+            raise NotImplementedError("Distribution visualization in " +
-+                                      "%d dimensions is not implemented." % n)
-+
-+    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
-+                              colorbar=True, cmap=None,
-+                              show_xlabel=True, show_ylabel=True):
-+
-+        if not fig and not ax:
-+            fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+        if cmap is None:
-+            cmap = mpl.cm.get_cmap('RdBu')
-+
-+        lim = abs(self.data).max()
-+
-+        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
-+                         norm=mpl.colors.Normalize(-lim, lim),
-+                         cmap=cmap)
-+
-+        if show_xlabel:
-+            ax.set_xlabel(self.xlabels[0], fontsize=12)
-+        if show_ylabel:
-+            ax.set_ylabel(self.xlabels[1], fontsize=12)
-+
-+        if colorbar:
-+            cb = fig.colorbar(cf, ax=ax)
-+
-+        return fig, ax
-+
-+    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
-+                             colorbar=True, cmap=None,
-+                             show_xlabel=True, show_ylabel=True):
-+
-+        if not fig and not ax:
-+            fig = plt.figure(figsize=figsize)
-+            ax = Axes3D(fig, azim=-62, elev=25)
-+
-+        if cmap is None:
-+            cmap = mpl.cm.get_cmap('RdBu')
-+
-+        lim = abs(self.data).max()
-+
-+        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
-+        s = ax.plot_surface(X, Y, self.data,
-+                            norm=mpl.colors.Normalize(-lim, lim),
-+                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
-+
-+        if show_xlabel:
-+            ax.set_xlabel(self.xlabels[0], fontsize=12)
-+        if show_ylabel:
-+            ax.set_ylabel(self.xlabels[1], fontsize=12)
-+
-+        if colorbar:
-+            cb = fig.colorbar(s, ax=ax, shrink=0.5)
-+
-+        return fig, ax
-+
-+    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
-+                     show_xlabel=True, show_ylabel=True):
-+
-+        if not fig and not ax:
-+            fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+        p = ax.plot(self.xvecs[0], self.data)
-+
-+        if show_xlabel:
-+            ax.set_xlabel(self.xlabels[0], fontsize=12)
-+        if show_ylabel:
-+            ax.set_ylabel("Marginal distribution", fontsize=12)
-+
-+        return fig, ax
-+
-+    def marginal(self, dim=0):
-+        """
-+        Calculate the marginal distribution function along the dimension
-+        `dim`. Return a new Distribution instance describing this reduced-
-+        dimensionality distribution.
-+
-+        Parameters
-+        ----------
-+        dim : int
-+            The dimension (coordinate index) along which to obtain the
-+            marginal distribution.
-+
-+        Returns
-+        -------
-+
-+        d : Distributions
-+            A new instances of Distribution that describes the marginal
-+            distribution.
-+
-+        """
-+        return Distribution(data=self.data.mean(axis=dim),
-+                            xvecs=[self.xvecs[dim]],
-+                            xlabels=[self.xlabels[dim]])
-+
-+    def project(self, dim=0):
-+        """
-+        Calculate the projection (max value) distribution function along the
-+        dimension `dim`. Return a new Distribution instance describing this
-+        reduced-dimensionality distribution.
-+
-+        Parameters
-+        ----------
-+        dim : int
-+            The dimension (coordinate index) along which to obtain the
-+            projected distribution.
-+
-+        Returns
-+        -------
-+        d : Distributions
-+            A new instances of Distribution that describes the projection.
-+
-+        """
-+        return Distribution(data=self.data.max(axis=dim),
-+                            xvecs=[self.xvecs[dim]],
-+                            xlabels=[self.xlabels[dim]])
-+
-+
-+class WignerDistribution(Distribution):
-+
-+    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
-+
-+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-+                      np.linspace(extent[1][0], extent[1][1], steps)]
-+
-+        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
-+
-+        if rho:
-+            self.update(rho)
-+
-+    def update(self, rho):
-+
-+        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
-+
-+
-+class QDistribution(Distribution):
-+
-+    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
-+
-+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-+                      np.linspace(extent[1][0], extent[1][1], steps)]
-+
-+        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
-+
-+        if rho:
-+            self.update(rho)
-+
-+    def update(self, rho):
-+
-+        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
-+
-+
-+class TwoModeQuadratureCorrelation(Distribution):
-+
-+    def __init__(self, state=None, theta1=0.0, theta2=0.0,
-+                 extent=[[-5, 5], [-5, 5]], steps=250):
-+
-+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-+                      np.linspace(extent[1][0], extent[1][1], steps)]
-+
-+        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
-+
-+        self.theta1 = theta1
-+        self.theta2 = theta2
-+
-+        self.update(state)
-+
-+    def update(self, state):
-+        """
-+        calculate probability distribution for quadrature measurement
-+        outcomes given a two-mode wavefunction or density matrix
-+        """
-+        if isket(state):
-+            self.update_psi(state)
-+        else:
-+            self.update_rho(state)
-+
-+    def update_psi(self, psi):
-+        """
-+        calculate probability distribution for quadrature measurement
-+        outcomes given a two-mode wavefunction
-+        """
-+
-+        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
-+
-+        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-+        N = psi.dims[0][0]
-+
-+        for n1 in range(N):
-+            kn1 = exp(-1j * self.theta1 * n1) / \
-+                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
-+                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
-+
-+            for n2 in range(N):
-+                kn2 = exp(-1j * self.theta2 * n2) / \
-+                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
-+                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
-+                i = state_number_index([N, N], [n1, n2])
-+                p += kn1 * kn2 * psi.data[i, 0]
-+
-+        self.data = abs(p) ** 2
-+
-+    def update_rho(self, rho):
-+        """
-+        calculate probability distribution for quadrature measurement
-+        outcomes given a two-mode density matrix
-+        """
-+
-+        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
-+
-+        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-+        N = rho.dims[0][0]
-+
-+        M1 = np.zeros(
-+            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-+        M2 = np.zeros(
-+            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-+
-+        for m in range(N):
-+            for n in range(N):
-+                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
-+                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
-+                    exp(-X1 ** 2) * np.polyval(
-+                        hermite(m), X1) * np.polyval(hermite(n), X1)
-+                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
-+                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
-+                    exp(-X2 ** 2) * np.polyval(
-+                        hermite(m), X2) * np.polyval(hermite(n), X2)
-+
-+        for n1 in range(N):
-+            for n2 in range(N):
-+                i = state_number_index([N, N], [n1, n2])
-+                for p1 in range(N):
-+                    for p2 in range(N):
-+                        j = state_number_index([N, N], [p1, p2])
-+                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
-+
-+        self.data = p
-+
-+
-+class HarmonicOscillatorWaveFunction(Distribution):
-+
-+    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
-+
-+        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
-+        self.xlabels = [r'$x$']
-+        self.omega = omega
-+
-+        if psi:
-+            self.update(psi)
-+
-+    def update(self, psi):
-+        """
-+        Calculate the wavefunction for the given state of an harmonic
-+        oscillator
-+        """
-+
-+        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
-+        N = psi.shape[0]
-+
-+        for n in range(N):
-+            k = pow(self.omega / pi, 0.25) / \
-+                sqrt(2 ** n * factorial(n)) * \
-+                exp(-self.xvecs[0] ** 2 / 2.0) * \
-+                np.polyval(hermite(n), self.xvecs[0])
-+
-+            self.data += k * psi.data[n, 0]
-+
-+
-+class HarmonicOscillatorProbabilityFunction(Distribution):
-+
-+    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
-+
-+        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
-+        self.xlabels = [r'$x$']
-+        self.omega = omega
-+
-+        if rho:
-+            self.update(rho)
-+
-+    def update(self, rho):
-+        """
-+        Calculate the probability function for the given state of an harmonic
-+        oscillator (as density matrix)
-+        """
-+
-+        if isket(rho):
-+            rho = ket2dm(rho)
-+
-+        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
-+        M, N = rho.shape
-+
-+        for m in range(M):
-+            k_m = pow(self.omega / pi, 0.25) / \
-+                sqrt(2 ** m * factorial(m)) * \
-+                exp(-self.xvecs[0] ** 2 / 2.0) * \
-+                np.polyval(hermite(m), self.xvecs[0])
-+
-+            for n in range(N):
-+                k_n = pow(self.omega / pi, 0.25) / \
-+                    sqrt(2 ** n * factorial(n)) * \
-+                    exp(-self.xvecs[0] ** 2 / 2.0) * \
-+                    np.polyval(hermite(n), self.xvecs[0])
-+
-+                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
-diff --git a/qutip/entropy.py b/qutip/entropy.py
-index cd62a69b..28ff606a 100644
---- a/qutip/entropy.py
-+++ b/qutip/entropy.py
-@@ -1,376 +1,376 @@
--__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
--           'concurrence', 'entropy_conditional', 'entangling_power',
--           'entropy_relative']
--
--from numpy import conj, e, inf, imag, inner, real, sort, sqrt
--from numpy.lib.scimath import log, log2
--from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
--               expand_operator)
--from .core import data as _data
--
--
--def entropy_vn(rho, base=e, sparse=False):
--    """
--    Von-Neumann entropy of density matrix
--
--    Parameters
--    ----------
--    rho : qobj
--        Density matrix.
--    base : {e,2}
--        Base of logarithm.
--    sparse : {False,True}
--        Use sparse eigensolver.
--
--    Returns
--    -------
--    entropy : float
--        Von-Neumann entropy of `rho`.
--
--    Examples
--    --------
--    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
--    >>> entropy_vn(rho,2)
--    1.0
--
--    """
--    if rho.type == 'ket' or rho.type == 'bra':
--        rho = ket2dm(rho)
--    vals = rho.eigenenergies(sparse=sparse)
--    nzvals = vals[vals != 0]
--    if base == 2:
--        logvals = log2(nzvals)
--    elif base == e:
--        logvals = log(nzvals)
--    else:
--        raise ValueError("Base must be 2 or e.")
--    return float(real(-sum(nzvals * logvals)))
--
--
--def entropy_linear(rho):
--    """
--    Linear entropy of a density matrix.
--
--    Parameters
--    ----------
--    rho : qobj
--        sensity matrix or ket/bra vector.
--
--    Returns
--    -------
--    entropy : float
--        Linear entropy of rho.
--
--    Examples
--    --------
--    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
--    >>> entropy_linear(rho)
--    0.5
--
--    """
--    if rho.type == 'ket' or rho.type == 'bra':
--        rho = ket2dm(rho)
--    return float(real(1.0 - (rho ** 2).tr()))
--
--
--def concurrence(rho):
--    """
--    Calculate the concurrence entanglement measure for a two-qubit state.
--
--    Parameters
--    ----------
--    state : qobj
--        Ket, bra, or density matrix for a two-qubit state.
--
--    Returns
--    -------
--    concur : float
--        Concurrence
--
--    References
--    ----------
--
--    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
--
--    """
--    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
--        raise Exception("Ket must be tensor product of two qubits.")
--
--    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
--        raise Exception("Bra must be tensor product of two qubits.")
--
--    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
--        raise Exception("Density matrix must be tensor product of two qubits.")
--
--    if rho.isket or rho.isbra:
--        rho = ket2dm(rho)
--
--    sysy = tensor(sigmay(), sigmay())
--
--    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
--
--    evals = rho_tilde.eigenenergies()
--
--    # abs to avoid problems with sqrt for very small negative numbers
--    evals = abs(sort(real(evals)))
--
--    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
--
--    return max(0, lsum)
--
--
--def negativity(rho, subsys, method='tracenorm', logarithmic=False):
--    """
--    Compute the negativity for a multipartite quantum system described
--    by the density matrix rho. The subsys argument is an index that
--    indicates which system to compute the negativity for.
--
--    .. note::
--
--        Experimental.
--    """
--    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
--    rho_pt = partial_transpose(rho, mask)
--
--    if method == 'tracenorm':
--        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
--    elif method == 'eigenvalues':
--        l = rho_pt.eigenenergies()
--        N = ((abs(l)-l)/2).sum()
--    else:
--        raise ValueError("Unknown method %s" % method)
--
--    if logarithmic:
--        return log2(2 * N + 1)
--    else:
--        return N
--
--
--def entropy_mutual(rho, selA, selB, base=e, sparse=False):
--    """
--    Calculates the mutual information S(A:B) between selection
--    components of a system density matrix.
--
--    Parameters
--    ----------
--    rho : qobj
--        Density matrix for composite quantum systems
--    selA : int/list
--        `int` or `list` of first selected density matrix components.
--    selB : int/list
--        `int` or `list` of second selected density matrix components.
--    base : {e,2}
--        Base of logarithm.
--    sparse : {False,True}
--        Use sparse eigensolver.
--
--    Returns
--    -------
--    ent_mut : float
--       Mutual information between selected components.
--
--    """
--    if isinstance(selA, int):
--        selA = [selA]
--    if isinstance(selB, int):
--        selB = [selB]
--    if rho.type != 'oper':
--        raise TypeError("Input must be a density matrix.")
--    if (len(selA) + len(selB)) != len(rho.dims[0]):
--        raise TypeError("Number of selected components must match " +
--                        "total number.")
--
--    rhoA = ptrace(rho, selA)
--    rhoB = ptrace(rho, selB)
--    out = (entropy_vn(rhoA, base, sparse=sparse) +
--           entropy_vn(rhoB, base, sparse=sparse) -
--           entropy_vn(rho, base, sparse=sparse))
--    return out
--
--
--def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
--    """
--    Calculates the relative entropy S(rho||sigma) between two density
--    matrices.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        First density matrix (or ket which will be converted to a density
--        matrix).
--    sigma : :class:`qutip.Qobj`
--        Second density matrix (or ket which will be converted to a density
--        matrix).
--    base : {e,2}
--        Base of logarithm. Defaults to e.
--    sparse : bool
--        Flag to use sparse solver when determining the eigenvectors
--        of the density matrices. Defaults to False.
--    tol : float
--        Tolerance to use to detect 0 eigenvalues or dot producted between
--        eigenvectors. Defaults to 1e-12.
--
--    Returns
--    -------
--    rel_ent : float
--        Value of relative entropy. Guaranteed to be greater than zero
--        and should equal zero only when rho and sigma are identical.
--
--    Examples
--    --------
--
--    First we define two density matrices:
--
--    >>> rho = qutip.ket2dm(qutip.ket("00"))
--    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
--    >>> sigma = sigma.unit()
--
--    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
--    and base e (i.e. ``log``).
--
--    >>> qutip.entropy_relative(rho, sigma, base=2)
--    1.0
--    >>> qutip.entropy_relative(rho, sigma)
--    0.6931471805599453
--
--    References
--    ----------
--
--    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
--    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
--    entropy.
--    """
--    if rho.isket:
--        rho = ket2dm(rho)
--    if sigma.isket:
--        sigma = ket2dm(sigma)
--    if not rho.isoper or not sigma.isoper:
--        raise TypeError("Inputs must be density matrices.")
--    if rho.dims != sigma.dims:
--        raise ValueError("Inputs must have the same shape and dims.")
--    if base == 2:
--        log_base = log2
--    elif base == e:
--        log_base = log
--    else:
--        raise ValueError("Base must be 2 or e.")
--    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
--    #
--    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
--    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
--    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
--    rvecs = rvecs.to_array().T
--    if any(abs(imag(rvals)) >= tol):
--        raise ValueError("Input rho has non-real eigenvalues.")
--    rvals = real(rvals)
--    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
--    svecs = svecs.to_array().T
--    if any(abs(imag(svals)) >= tol):
--        raise ValueError("Input sigma has non-real eigenvalues.")
--    svals = real(svals)
--    # Calculate inner products of eigenvectors and return +inf if kernel
--    # of sigma overlaps with support of rho.
--    P = abs(inner(rvecs, conj(svecs))) ** 2
--    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
--        return inf
--    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
--    # anyway
--    svals[abs(svals) < tol] = 1
--    nzrvals = rvals[abs(rvals) >= tol]
--    # Calculate S
--    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
--    # the relative entropy is guaranteed to be >= 0, so we clamp the
--    # calculated value to 0 to avoid small violations of the lower bound.
--    return max(0, S)
--
--
--def entropy_conditional(rho, selB, base=e, sparse=False):
--    """
--    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
--    of a selected density matrix component.
--
--    Parameters
--    ----------
--    rho : qobj
--        Density matrix of composite object
--    selB : int/list
--        Selected components for density matrix B
--    base : {e,2}
--        Base of logarithm.
--    sparse : {False,True}
--        Use sparse eigensolver.
--
--    Returns
--    -------
--    ent_cond : float
--        Value of conditional entropy
--
--    """
--    if rho.type != 'oper':
--        raise TypeError("Input must be density matrix.")
--    if isinstance(selB, int):
--        selB = [selB]
--    B = ptrace(rho, selB)
--    out = (entropy_vn(rho, base, sparse=sparse) -
--           entropy_vn(B, base, sparse=sparse))
--    return out
--
--
--def participation_ratio(rho):
--    """
--    Returns the effective number of states for a density matrix.
--
--    The participation is unity for pure states, and maximally N,
--    where N is the Hilbert space dimensionality, for completely
--    mixed states.
--
--    Parameters
--    ----------
--    rho : qobj
--        Density matrix
--
--    Returns
--    -------
--    pr : float
--        Effective number of states in the density matrix
--
--    """
--    if rho.type == 'ket' or rho.type == 'bra':
--        return 1.0
--    else:
--        return 1.0 / (rho ** 2).tr()
--
--
--def entangling_power(U):
--    """
--    Calculate the entangling power of a two-qubit gate U, which
--    is zero of nonentangling gates and 2/9 for maximally entangling gates.
--
--    Parameters
--    ----------
--    U : qobj
--        Qobj instance representing a two-qubit gate.
--
--    Returns
--    -------
--    ep : float
--        The entanglement power of U (real number between 0 and 2/9)
--
--    References:
--
--        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
--    """
--
--    if not U.isoper:
--        raise Exception("U must be an operator.")
--
--    if U.dims != [[2, 2], [2, 2]]:
--        raise Exception("U must be a two-qubit gate.")
--
--    from qutip.core.gates import swap
--    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
--    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
--    Uswap = swap() * U
--    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
--
--    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
-+__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
-+           'concurrence', 'entropy_conditional', 'entangling_power',
-+           'entropy_relative']
-+
-+from numpy import conj, e, inf, imag, inner, real, sort, sqrt
-+from numpy.lib.scimath import log, log2
-+from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
-+               expand_operator)
-+from .core import data as _data
-+
-+
-+def entropy_vn(rho, base=e, sparse=False):
-+    """
-+    Von-Neumann entropy of density matrix
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        Density matrix.
-+    base : {e,2}
-+        Base of logarithm.
-+    sparse : {False,True}
-+        Use sparse eigensolver.
-+
-+    Returns
-+    -------
-+    entropy : float
-+        Von-Neumann entropy of `rho`.
-+
-+    Examples
-+    --------
-+    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
-+    >>> entropy_vn(rho,2)
-+    1.0
-+
-+    """
-+    if rho.type == 'ket' or rho.type == 'bra':
-+        rho = ket2dm(rho)
-+    vals = rho.eigenenergies(sparse=sparse)
-+    nzvals = vals[vals != 0]
-+    if base == 2:
-+        logvals = log2(nzvals)
-+    elif base == e:
-+        logvals = log(nzvals)
-+    else:
-+        raise ValueError("Base must be 2 or e.")
-+    return float(real(-sum(nzvals * logvals)))
-+
-+
-+def entropy_linear(rho):
-+    """
-+    Linear entropy of a density matrix.
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        sensity matrix or ket/bra vector.
-+
-+    Returns
-+    -------
-+    entropy : float
-+        Linear entropy of rho.
-+
-+    Examples
-+    --------
-+    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
-+    >>> entropy_linear(rho)
-+    0.5
-+
-+    """
-+    if rho.type == 'ket' or rho.type == 'bra':
-+        rho = ket2dm(rho)
-+    return float(real(1.0 - (rho ** 2).tr()))
-+
-+
-+def concurrence(rho):
-+    """
-+    Calculate the concurrence entanglement measure for a two-qubit state.
-+
-+    Parameters
-+    ----------
-+    state : qobj
-+        Ket, bra, or density matrix for a two-qubit state.
-+
-+    Returns
-+    -------
-+    concur : float
-+        Concurrence
-+
-+    References
-+    ----------
-+
-+    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
-+
-+    """
-+    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
-+        raise Exception("Ket must be tensor product of two qubits.")
-+
-+    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
-+        raise Exception("Bra must be tensor product of two qubits.")
-+
-+    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
-+        raise Exception("Density matrix must be tensor product of two qubits.")
-+
-+    if rho.isket or rho.isbra:
-+        rho = ket2dm(rho)
-+
-+    sysy = tensor(sigmay(), sigmay())
-+
-+    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
-+
-+    evals = rho_tilde.eigenenergies()
-+
-+    # abs to avoid problems with sqrt for very small negative numbers
-+    evals = abs(sort(real(evals)))
-+
-+    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
-+
-+    return max(0, lsum)
-+
-+
-+def negativity(rho, subsys, method='tracenorm', logarithmic=False):
-+    """
-+    Compute the negativity for a multipartite quantum system described
-+    by the density matrix rho. The subsys argument is an index that
-+    indicates which system to compute the negativity for.
-+
-+    .. note::
-+
-+        Experimental.
-+    """
-+    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
-+    rho_pt = partial_transpose(rho, mask)
-+
-+    if method == 'tracenorm':
-+        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
-+    elif method == 'eigenvalues':
-+        l = rho_pt.eigenenergies()
-+        N = ((abs(l)-l)/2).sum()
-+    else:
-+        raise ValueError("Unknown method %s" % method)
-+
-+    if logarithmic:
-+        return log2(2 * N + 1)
-+    else:
-+        return N
-+
-+
-+def entropy_mutual(rho, selA, selB, base=e, sparse=False):
-+    """
-+    Calculates the mutual information S(A:B) between selection
-+    components of a system density matrix.
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        Density matrix for composite quantum systems
-+    selA : int/list
-+        `int` or `list` of first selected density matrix components.
-+    selB : int/list
-+        `int` or `list` of second selected density matrix components.
-+    base : {e,2}
-+        Base of logarithm.
-+    sparse : {False,True}
-+        Use sparse eigensolver.
-+
-+    Returns
-+    -------
-+    ent_mut : float
-+       Mutual information between selected components.
-+
-+    """
-+    if isinstance(selA, int):
-+        selA = [selA]
-+    if isinstance(selB, int):
-+        selB = [selB]
-+    if rho.type != 'oper':
-+        raise TypeError("Input must be a density matrix.")
-+    if (len(selA) + len(selB)) != len(rho.dims[0]):
-+        raise TypeError("Number of selected components must match " +
-+                        "total number.")
-+
-+    rhoA = ptrace(rho, selA)
-+    rhoB = ptrace(rho, selB)
-+    out = (entropy_vn(rhoA, base, sparse=sparse) +
-+           entropy_vn(rhoB, base, sparse=sparse) -
-+           entropy_vn(rho, base, sparse=sparse))
-+    return out
-+
-+
-+def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
-+    """
-+    Calculates the relative entropy S(rho||sigma) between two density
-+    matrices.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        First density matrix (or ket which will be converted to a density
-+        matrix).
-+    sigma : :class:`qutip.Qobj`
-+        Second density matrix (or ket which will be converted to a density
-+        matrix).
-+    base : {e,2}
-+        Base of logarithm. Defaults to e.
-+    sparse : bool
-+        Flag to use sparse solver when determining the eigenvectors
-+        of the density matrices. Defaults to False.
-+    tol : float
-+        Tolerance to use to detect 0 eigenvalues or dot producted between
-+        eigenvectors. Defaults to 1e-12.
-+
-+    Returns
-+    -------
-+    rel_ent : float
-+        Value of relative entropy. Guaranteed to be greater than zero
-+        and should equal zero only when rho and sigma are identical.
-+
-+    Examples
-+    --------
-+
-+    First we define two density matrices:
-+
-+    >>> rho = qutip.ket2dm(qutip.ket("00"))
-+    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
-+    >>> sigma = sigma.unit()
-+
-+    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
-+    and base e (i.e. ``log``).
-+
-+    >>> qutip.entropy_relative(rho, sigma, base=2)
-+    1.0
-+    >>> qutip.entropy_relative(rho, sigma)
-+    0.6931471805599453
-+
-+    References
-+    ----------
-+
-+    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
-+    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
-+    entropy.
-+    """
-+    if rho.isket:
-+        rho = ket2dm(rho)
-+    if sigma.isket:
-+        sigma = ket2dm(sigma)
-+    if not rho.isoper or not sigma.isoper:
-+        raise TypeError("Inputs must be density matrices.")
-+    if rho.dims != sigma.dims:
-+        raise ValueError("Inputs must have the same shape and dims.")
-+    if base == 2:
-+        log_base = log2
-+    elif base == e:
-+        log_base = log
-+    else:
-+        raise ValueError("Base must be 2 or e.")
-+    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
-+    #
-+    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
-+    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
-+    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
-+    rvecs = rvecs.to_array().T
-+    if any(abs(imag(rvals)) >= tol):
-+        raise ValueError("Input rho has non-real eigenvalues.")
-+    rvals = real(rvals)
-+    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
-+    svecs = svecs.to_array().T
-+    if any(abs(imag(svals)) >= tol):
-+        raise ValueError("Input sigma has non-real eigenvalues.")
-+    svals = real(svals)
-+    # Calculate inner products of eigenvectors and return +inf if kernel
-+    # of sigma overlaps with support of rho.
-+    P = abs(inner(rvecs, conj(svecs))) ** 2
-+    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
-+        return inf
-+    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
-+    # anyway
-+    svals[abs(svals) < tol] = 1
-+    nzrvals = rvals[abs(rvals) >= tol]
-+    # Calculate S
-+    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
-+    # the relative entropy is guaranteed to be >= 0, so we clamp the
-+    # calculated value to 0 to avoid small violations of the lower bound.
-+    return max(0, S)
-+
-+
-+def entropy_conditional(rho, selB, base=e, sparse=False):
-+    """
-+    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
-+    of a selected density matrix component.
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        Density matrix of composite object
-+    selB : int/list
-+        Selected components for density matrix B
-+    base : {e,2}
-+        Base of logarithm.
-+    sparse : {False,True}
-+        Use sparse eigensolver.
-+
-+    Returns
-+    -------
-+    ent_cond : float
-+        Value of conditional entropy
-+
-+    """
-+    if rho.type != 'oper':
-+        raise TypeError("Input must be density matrix.")
-+    if isinstance(selB, int):
-+        selB = [selB]
-+    B = ptrace(rho, selB)
-+    out = (entropy_vn(rho, base, sparse=sparse) -
-+           entropy_vn(B, base, sparse=sparse))
-+    return out
-+
-+
-+def participation_ratio(rho):
-+    """
-+    Returns the effective number of states for a density matrix.
-+
-+    The participation is unity for pure states, and maximally N,
-+    where N is the Hilbert space dimensionality, for completely
-+    mixed states.
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        Density matrix
-+
-+    Returns
-+    -------
-+    pr : float
-+        Effective number of states in the density matrix
-+
-+    """
-+    if rho.type == 'ket' or rho.type == 'bra':
-+        return 1.0
-+    else:
-+        return 1.0 / (rho ** 2).tr()
-+
-+
-+def entangling_power(U):
-+    """
-+    Calculate the entangling power of a two-qubit gate U, which
-+    is zero of nonentangling gates and 2/9 for maximally entangling gates.
-+
-+    Parameters
-+    ----------
-+    U : qobj
-+        Qobj instance representing a two-qubit gate.
-+
-+    Returns
-+    -------
-+    ep : float
-+        The entanglement power of U (real number between 0 and 2/9)
-+
-+    References:
-+
-+        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
-+    """
-+
-+    if not U.isoper:
-+        raise Exception("U must be an operator.")
-+
-+    if U.dims != [[2, 2], [2, 2]]:
-+        raise Exception("U must be a two-qubit gate.")
-+
-+    from qutip.core.gates import swap
-+    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
-+    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
-+    Uswap = swap() * U
-+    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
-+
-+    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
-diff --git a/qutip/fileio.py b/qutip/fileio.py
-index ac94dd41..36bb1a5c 100644
---- a/qutip/fileio.py
-+++ b/qutip/fileio.py
-@@ -1,257 +1,257 @@
--__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
--
--import pickle
--import numpy as np
--import sys
--from .core import Qobj
--from pathlib import Path
--
--
--# -----------------------------------------------------------------------------
--# Write matrix data to a file
--#
--def file_data_store(filename, data, numtype="complex", numformat="decimal",
--                    sep=","):
--    """Stores a matrix of data to a file to be read by an external program.
--
--    Parameters
--    ----------
--    filename : str or pathlib.Path
--        Name of data file to be stored, including extension.
--    data: array_like
--        Data to be written to file.
--    numtype : str {'complex, 'real'}
--        Type of numerical data.
--    numformat : str {'decimal','exp'}
--        Format for written data.
--    sep : str
--        Single-character field seperator.  Usually a tab, space, comma,
--        or semicolon.
--
--    """
--    if filename is None or data is None:
--        raise ValueError("filename or data is unspecified")
--
--    M, N = np.shape(data)
--
--    f = open(filename, "w")
--
--    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
--            "in %s format ['%s' separated values].\n" % (numformat, sep))
--
--    if numtype == "complex":
--
--        if numformat == "exp":
--
--            for m in range(M):
--                for n in range(N):
--                    if np.imag(data[m, n]) >= 0.0:
--                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
--                                                  np.imag(data[m, n])))
--                    else:
--                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
--                                                 np.imag(data[m, n])))
--                    if n != N - 1:
--                        f.write(sep)
--                f.write("\n")
--
--        elif numformat == "decimal":
--
--            for m in range(M):
--                for n in range(N):
--                    if np.imag(data[m, n]) >= 0.0:
--                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
--                                                  np.imag(data[m, n])))
--                    else:
--                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
--                                                 np.imag(data[m, n])))
--                    if n != N - 1:
--                        f.write(sep)
--                f.write("\n")
--
--        else:
--            raise ValueError("Illegal numformat value (should be " +
--                             "'exp' or 'decimal')")
--
--    elif numtype == "real":
--
--        if numformat == "exp":
--
--            for m in range(M):
--                for n in range(N):
--                    f.write("%.10e" % (np.real(data[m, n])))
--                    if n != N - 1:
--                        f.write(sep)
--                f.write("\n")
--
--        elif numformat == "decimal":
--
--            for m in range(M):
--                for n in range(N):
--                    f.write("%.10f" % (np.real(data[m, n])))
--                    if n != N - 1:
--                        f.write(sep)
--                f.write("\n")
--
--        else:
--            raise ValueError("Illegal numformat value (should be " +
--                             "'exp' or 'decimal')")
--
--    else:
--        raise ValueError("Illegal numtype value (should be " +
--                         "'complex' or 'real')")
--
--    f.close()
--
--
--# -----------------------------------------------------------------------------
--# Read matrix data from a file
--#
--def file_data_read(filename, sep=None):
--    """Retrieves an array of data from the requested file.
--
--    Parameters
--    ----------
--    filename : str or pathlib.Path
--        Name of file containing reqested data.
--    sep : str
--        Seperator used to store data.
--
--    Returns
--    -------
--    data : array_like
--        Data from selected file.
--
--    """
--    if filename is None:
--        raise ValueError("filename is unspecified")
--
--    f = open(filename, "r")
--
--    #
--    # first count lines and numbers of
--    #
--    M = N = 0
--    for line in f:
--        # skip comment lines
--        if line[0] == '#' or line[0] == '%':
--            continue
--        # find delim
--        if N == 0 and sep is None:
--            if len(line.rstrip().split(",")) > 1:
--                sep = ","
--            elif len(line.rstrip().split(";")) > 1:
--                sep = ";"
--            elif len(line.rstrip().split(":")) > 1:
--                sep = ":"
--            elif len(line.rstrip().split("|")) > 1:
--                sep = "|"
--            elif len(line.rstrip().split()) > 1:
--                # sepical case for a mix of white space deliminators
--                sep = None
--            else:
--                raise ValueError("Unrecognized column deliminator")
--        # split the line
--        line_vec = line.split(sep)
--        n = len(line_vec)
--        if N == 0 and n > 0:
--            N = n
--            # check type
--            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
--                numtype = "complex"
--            else:
--                numtype = "np.real"
--
--            # check format
--            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
--                numformat = "exp"
--            else:
--                numformat = "decimal"
--
--        elif N != n:
--            raise ValueError("Badly formatted data file: " +
--                             "unequal number of columns")
--        M += 1
--
--    #
--    # read data and store in a matrix
--    #
--    f.seek(0)
--
--    if numtype == "complex":
--        data = np.zeros((M, N), dtype="complex")
--        m = n = 0
--        for line in f:
--            # skip comment lines
--            if line[0] == '#' or line[0] == '%':
--                continue
--            n = 0
--            for item in line.rstrip().split(sep):
--                data[m, n] = complex(item)
--                n += 1
--            m += 1
--
--    else:
--        data = np.zeros((M, N), dtype="float")
--        m = n = 0
--        for line in f:
--            # skip comment lines
--            if line[0] == '#' or line[0] == '%':
--                continue
--            n = 0
--            for item in line.rstrip().split(sep):
--                data[m, n] = float(item)
--                n += 1
--            m += 1
--
--    f.close()
--
--    return data
--
--
--def qsave(data, name='qutip_data'):
--    """
--    Saves given data to file named 'filename.qu' in current directory.
--
--    Parameters
--    ----------
--    data : instance/array_like
--        Input Python object to be stored.
--    filename : str or pathlib.Path
--        Name of output data file.
--
--    """
--    # open the file for writing
--    path = Path(name)
--    path = path.with_suffix(path.suffix + ".qu")
--
--    with open(path, "wb") as fileObject:
--        # this writes the object a to the file named 'filename.qu'
--        pickle.dump(data, fileObject)
--
--
--def qload(name):
--    """
--    Loads data file from file named 'filename.qu' in current directory.
--
--    Parameters
--    ----------
--    name : str or pathlib.Path
--        Name of data file to be loaded.
--
--    Returns
--    -------
--    qobject : instance / array_like
--        Object retrieved from requested file.
--
--    """
--    path = Path(name)
--    path = path.with_suffix(path.suffix + ".qu")
--
--    with open(path, "rb") as fileObject:
--        if sys.version_info >= (3, 0):
--            out = pickle.load(fileObject, encoding='latin1')
--        else:
--            out = pickle.load(fileObject)
--
--    return out
-+__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
-+
-+import pickle
-+import numpy as np
-+import sys
-+from .core import Qobj
-+from pathlib import Path
-+
-+
-+# -----------------------------------------------------------------------------
-+# Write matrix data to a file
-+#
-+def file_data_store(filename, data, numtype="complex", numformat="decimal",
-+                    sep=","):
-+    """Stores a matrix of data to a file to be read by an external program.
-+
-+    Parameters
-+    ----------
-+    filename : str or pathlib.Path
-+        Name of data file to be stored, including extension.
-+    data: array_like
-+        Data to be written to file.
-+    numtype : str {'complex, 'real'}
-+        Type of numerical data.
-+    numformat : str {'decimal','exp'}
-+        Format for written data.
-+    sep : str
-+        Single-character field seperator.  Usually a tab, space, comma,
-+        or semicolon.
-+
-+    """
-+    if filename is None or data is None:
-+        raise ValueError("filename or data is unspecified")
-+
-+    M, N = np.shape(data)
-+
-+    f = open(filename, "w")
-+
-+    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
-+            "in %s format ['%s' separated values].\n" % (numformat, sep))
-+
-+    if numtype == "complex":
-+
-+        if numformat == "exp":
-+
-+            for m in range(M):
-+                for n in range(N):
-+                    if np.imag(data[m, n]) >= 0.0:
-+                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
-+                                                  np.imag(data[m, n])))
-+                    else:
-+                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
-+                                                 np.imag(data[m, n])))
-+                    if n != N - 1:
-+                        f.write(sep)
-+                f.write("\n")
-+
-+        elif numformat == "decimal":
-+
-+            for m in range(M):
-+                for n in range(N):
-+                    if np.imag(data[m, n]) >= 0.0:
-+                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
-+                                                  np.imag(data[m, n])))
-+                    else:
-+                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
-+                                                 np.imag(data[m, n])))
-+                    if n != N - 1:
-+                        f.write(sep)
-+                f.write("\n")
-+
-+        else:
-+            raise ValueError("Illegal numformat value (should be " +
-+                             "'exp' or 'decimal')")
-+
-+    elif numtype == "real":
-+
-+        if numformat == "exp":
-+
-+            for m in range(M):
-+                for n in range(N):
-+                    f.write("%.10e" % (np.real(data[m, n])))
-+                    if n != N - 1:
-+                        f.write(sep)
-+                f.write("\n")
-+
-+        elif numformat == "decimal":
-+
-+            for m in range(M):
-+                for n in range(N):
-+                    f.write("%.10f" % (np.real(data[m, n])))
-+                    if n != N - 1:
-+                        f.write(sep)
-+                f.write("\n")
-+
-+        else:
-+            raise ValueError("Illegal numformat value (should be " +
-+                             "'exp' or 'decimal')")
-+
-+    else:
-+        raise ValueError("Illegal numtype value (should be " +
-+                         "'complex' or 'real')")
-+
-+    f.close()
-+
-+
-+# -----------------------------------------------------------------------------
-+# Read matrix data from a file
-+#
-+def file_data_read(filename, sep=None):
-+    """Retrieves an array of data from the requested file.
-+
-+    Parameters
-+    ----------
-+    filename : str or pathlib.Path
-+        Name of file containing reqested data.
-+    sep : str
-+        Seperator used to store data.
-+
-+    Returns
-+    -------
-+    data : array_like
-+        Data from selected file.
-+
-+    """
-+    if filename is None:
-+        raise ValueError("filename is unspecified")
-+
-+    f = open(filename, "r")
-+
-+    #
-+    # first count lines and numbers of
-+    #
-+    M = N = 0
-+    for line in f:
-+        # skip comment lines
-+        if line[0] == '#' or line[0] == '%':
-+            continue
-+        # find delim
-+        if N == 0 and sep is None:
-+            if len(line.rstrip().split(",")) > 1:
-+                sep = ","
-+            elif len(line.rstrip().split(";")) > 1:
-+                sep = ";"
-+            elif len(line.rstrip().split(":")) > 1:
-+                sep = ":"
-+            elif len(line.rstrip().split("|")) > 1:
-+                sep = "|"
-+            elif len(line.rstrip().split()) > 1:
-+                # sepical case for a mix of white space deliminators
-+                sep = None
-+            else:
-+                raise ValueError("Unrecognized column deliminator")
-+        # split the line
-+        line_vec = line.split(sep)
-+        n = len(line_vec)
-+        if N == 0 and n > 0:
-+            N = n
-+            # check type
-+            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
-+                numtype = "complex"
-+            else:
-+                numtype = "np.real"
-+
-+            # check format
-+            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
-+                numformat = "exp"
-+            else:
-+                numformat = "decimal"
-+
-+        elif N != n:
-+            raise ValueError("Badly formatted data file: " +
-+                             "unequal number of columns")
-+        M += 1
-+
-+    #
-+    # read data and store in a matrix
-+    #
-+    f.seek(0)
-+
-+    if numtype == "complex":
-+        data = np.zeros((M, N), dtype="complex")
-+        m = n = 0
-+        for line in f:
-+            # skip comment lines
-+            if line[0] == '#' or line[0] == '%':
-+                continue
-+            n = 0
-+            for item in line.rstrip().split(sep):
-+                data[m, n] = complex(item)
-+                n += 1
-+            m += 1
-+
-+    else:
-+        data = np.zeros((M, N), dtype="float")
-+        m = n = 0
-+        for line in f:
-+            # skip comment lines
-+            if line[0] == '#' or line[0] == '%':
-+                continue
-+            n = 0
-+            for item in line.rstrip().split(sep):
-+                data[m, n] = float(item)
-+                n += 1
-+            m += 1
-+
-+    f.close()
-+
-+    return data
-+
-+
-+def qsave(data, name='qutip_data'):
-+    """
-+    Saves given data to file named 'filename.qu' in current directory.
-+
-+    Parameters
-+    ----------
-+    data : instance/array_like
-+        Input Python object to be stored.
-+    filename : str or pathlib.Path
-+        Name of output data file.
-+
-+    """
-+    # open the file for writing
-+    path = Path(name)
-+    path = path.with_suffix(path.suffix + ".qu")
-+
-+    with open(path, "wb") as fileObject:
-+        # this writes the object a to the file named 'filename.qu'
-+        pickle.dump(data, fileObject)
-+
-+
-+def qload(name):
-+    """
-+    Loads data file from file named 'filename.qu' in current directory.
-+
-+    Parameters
-+    ----------
-+    name : str or pathlib.Path
-+        Name of data file to be loaded.
-+
-+    Returns
-+    -------
-+    qobject : instance / array_like
-+        Object retrieved from requested file.
-+
-+    """
-+    path = Path(name)
-+    path = path.with_suffix(path.suffix + ".qu")
-+
-+    with open(path, "rb") as fileObject:
-+        if sys.version_info >= (3, 0):
-+            out = pickle.load(fileObject, encoding='latin1')
-+        else:
-+            out = pickle.load(fileObject)
-+
-+    return out
-diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
-index 143a3b1c..0cf9d3b4 100644
---- a/qutip/ipynbtools.py
-+++ b/qutip/ipynbtools.py
-@@ -1,326 +1,326 @@
--"""
--This module contains utility functions for using QuTiP with IPython notebooks.
--"""
--from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
--from .settings import _blas_info, available_cpu_count
--import IPython
--
--#IPython parallel routines moved to ipyparallel in V4
--#IPython parallel routines not in Anaconda by default
--if IPython.version_info[0] >= 4:
--    try:
--        from ipyparallel import Client
--        __all__ = ['version_table', 'plot_animation',
--                    'parallel_map']
--    except:
--         __all__ = ['version_table', 'plot_animation']
--else:
--    try:
--        from IPython.parallel import Client
--        __all__ = ['version_table', 'plot_animation',
--                    'parallel_map']
--    except:
--         __all__ = ['version_table', 'plot_animation']
--
--
--from IPython.display import HTML, Javascript, display
--
--import matplotlib.pyplot as plt
--from matplotlib import animation
--from base64 import b64encode
--
--import datetime
--import uuid
--import sys
--import os
--import time
--import inspect
--
--import qutip
--import numpy
--import scipy
--import matplotlib
--import IPython
--
--try:
--    import Cython
--    _cython_available = True
--except ImportError:
--    _cython_available = False
--
--
--def version_table(verbose=False):
--    """
--    Print an HTML-formatted table with version numbers for QuTiP and its
--    dependencies. Use it in a IPython notebook to show which versions of
--    different packages that were used to run the notebook. This should make it
--    possible to reproduce the environment and the calculation later on.
--
--
--    Returns
--    -------
--    version_table: string
--        Return an HTML-formatted string containing version information for
--        QuTiP dependencies.
--
--    """
--
--    html = "<table>"
--    html += "<tr><th>Software</th><th>Version</th></tr>"
--
--    packages = [("QuTiP", qutip.__version__),
--                ("Numpy", numpy.__version__),
--                ("SciPy", scipy.__version__),
--                ("matplotlib", matplotlib.__version__),
--                ("Number of CPUs", available_cpu_count()),
--                ("BLAS Info", _blas_info()),
--                ("IPython", IPython.__version__),
--                ("Python", sys.version),
--                ("OS", "%s [%s]" % (os.name, sys.platform))
--                ]
--    if _cython_available:
--        packages.append(("Cython", Cython.__version__))
--
--    for name, version in packages:
--        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
--
--    if verbose:
--        html += "<tr><th colspan='2'>Additional information</th></tr>"
--        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
--        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
--                 qutip_install_path)
--        try:
--            import getpass
--            html += ("<tr><td>User</td><td>%s</td></tr>" %
--                     getpass.getuser())
--        except:
--            pass
--
--    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
--        '%a %b %d %H:%M:%S %Y %Z')
--    html += "</table>"
--
--    return HTML(html)
--
--
--def _visualize_parfor_data(metadata):
--    """
--    Visualizing the task scheduling meta data collected from AsyncResults.
--    """
--    res = numpy.array(metadata)
--    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
--
--    yticks = []
--    yticklabels = []
--    tmin = min(res[:, 1])
--    for n, pid in enumerate(numpy.unique(res[:, 0])):
--        yticks.append(n)
--        yticklabels.append("%d" % pid)
--        for m in numpy.where(res[:, 0] == pid)[0]:
--            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
--                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
--
--    ax.set_ylim(-.5, n + .5)
--    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
--    ax.set_yticks(yticks)
--    ax.set_yticklabels(yticklabels)
--    ax.set_ylabel("Engine")
--    ax.set_xlabel("seconds")
--    ax.set_title("Task schedule")
--
--
--def parfor(task, task_vec, args=None, client=None, view=None,
--           show_scheduling=False, show_progressbar=False):
--    """
--    Call the function ``tast`` for each value in ``task_vec`` using a cluster
--    of IPython engines. The function ``task`` should have the signature
--    ``task(value, args)`` or ``task(value)`` if ``args=None``.
--
--    The ``client`` and ``view`` are the IPython.parallel client and
--    load-balanced view that will be used in the parfor execution. If these
--    are ``None``, new instances will be created.
--
--    Parameters
--    ----------
--
--    task: a Python function
--        The function that is to be called for each value in ``task_vec``.
--
--    task_vec: array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--
--    args: list / dictionary
--        The optional additional argument to the ``task`` function. For example
--        a dictionary with parameter values.
--
--    client: IPython.parallel.Client
--        The IPython.parallel Client instance that will be used in the
--        parfor execution.
--
--    view: a IPython.parallel.Client view
--        The view that is to be used in scheduling the tasks on the IPython
--        cluster. Preferably a load-balanced view, which is obtained from the
--        IPython.parallel.Client instance client by calling,
--        view = client.load_balanced_view().
--
--    show_scheduling: bool {False, True}, default False
--        Display a graph showing how the tasks (the evaluation of ``task`` for
--        for the value in ``task_vec1``) was scheduled on the IPython engine
--        cluster.
--
--    show_progressbar: bool {False, True}, default False
--        Display a HTML-based progress bar duing the execution of the parfor
--        loop.
--
--    Returns
--    -------
--    result : list
--        The result list contains the value of ``task(value, args)`` for each
--        value in ``task_vec``, that is, it should be equivalent to
--        ``[task(v, args) for v in task_vec]``.
--    """
--
--    if show_progressbar:
--        progress_bar = HTMLProgressBar()
--    else:
--        progress_bar = None
--
--    return parallel_map(task, task_vec, task_args=args,
--                        client=client, view=view, progress_bar=progress_bar,
--                        show_scheduling=show_scheduling)
--
--
--def parallel_map(task, values, task_args=None, task_kwargs=None,
--                 client=None, view=None, progress_bar=None,
--                 show_scheduling=False, **kwargs):
--    """
--    Call the function ``task`` for each value in ``values`` using a cluster
--    of IPython engines. The function ``task`` should have the signature
--    ``task(value, *args, **kwargs)``.
--
--    The ``client`` and ``view`` are the IPython.parallel client and
--    load-balanced view that will be used in the parfor execution. If these
--    are ``None``, new instances will be created.
--
--    Parameters
--    ----------
--
--    task: a Python function
--        The function that is to be called for each value in ``task_vec``.
--
--    values: array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--
--    task_args: list / dictionary
--        The optional additional argument to the ``task`` function.
--
--    task_kwargs: list / dictionary
--        The optional additional keyword argument to the ``task`` function.
--
--    client: IPython.parallel.Client
--        The IPython.parallel Client instance that will be used in the
--        parfor execution.
--
--    view: a IPython.parallel.Client view
--        The view that is to be used in scheduling the tasks on the IPython
--        cluster. Preferably a load-balanced view, which is obtained from the
--        IPython.parallel.Client instance client by calling,
--        view = client.load_balanced_view().
--
--    show_scheduling: bool {False, True}, default False
--        Display a graph showing how the tasks (the evaluation of ``task`` for
--        for the value in ``task_vec1``) was scheduled on the IPython engine
--        cluster.
--
--    show_progressbar: bool {False, True}, default False
--        Display a HTML-based progress bar during the execution of the parfor
--        loop.
--
--    Returns
--    -------
--    result : list
--        The result list contains the value of
--        ``task(value, task_args, task_kwargs)`` for each
--        value in ``values``.
--
--    """
--    submitted = datetime.datetime.now()
--
--    if task_args is None:
--        task_args = tuple()
--
--    if task_kwargs is None:
--        task_kwargs = {}
--
--    if client is None:
--        client = Client()
--
--        # make sure qutip is available at engines
--        dview = client[:]
--        dview.block = True
--        dview.execute("from qutip import *")
--
--    if view is None:
--        view = client.load_balanced_view()
--
--    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
--               for value in values]
--
--    if progress_bar is None:
--        view.wait(ar_list)
--    else:
--        if progress_bar is True:
--            progress_bar = HTMLProgressBar()
--
--        n = len(ar_list)
--        progress_bar.start(n)
--        while True:
--            n_finished = sum([ar.progress for ar in ar_list])
--            progress_bar.update(n_finished)
--
--            if view.wait(ar_list, timeout=0.5):
--                progress_bar.update(n)
--                break
--        progress_bar.finished()
--
--    if show_scheduling:
--        metadata = [[ar.engine_id,
--                     (ar.started - submitted).total_seconds(),
--                     (ar.completed - submitted).total_seconds()]
--                    for ar in ar_list]
--        _visualize_parfor_data(metadata)
--
--    return [ar.get() for ar in ar_list]
--
--
--def plot_animation(plot_setup_func, plot_func, result, name="movie",
--                   writer="avconv", codec="libx264", verbose=False):
--    """
--    Create an animated plot of a Result object, as returned by one of
--    the qutip evolution solvers.
--
--    .. note :: experimental
--    """
--
--    fig, axes = plot_setup_func(result)
--
--    def update(n):
--        return plot_func(result, n, fig=fig, axes=axes)
--
--    anim = animation.FuncAnimation(
--        fig, update, frames=len(result.times), blit=True)
--
--    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
--
--    plt.close(fig)
--
--    if verbose:
--        print("Created %s.m4v" % name)
--
--    video = open(name + '.mp4', "rb").read()
--    video_encoded = b64encode(video).decode("ascii")
--    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
--        video_encoded)
--    return HTML(video_tag)
-+"""
-+This module contains utility functions for using QuTiP with IPython notebooks.
-+"""
-+from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
-+from .settings import _blas_info, available_cpu_count
-+import IPython
-+
-+#IPython parallel routines moved to ipyparallel in V4
-+#IPython parallel routines not in Anaconda by default
-+if IPython.version_info[0] >= 4:
-+    try:
-+        from ipyparallel import Client
-+        __all__ = ['version_table', 'plot_animation',
-+                    'parallel_map']
-+    except:
-+         __all__ = ['version_table', 'plot_animation']
-+else:
-+    try:
-+        from IPython.parallel import Client
-+        __all__ = ['version_table', 'plot_animation',
-+                    'parallel_map']
-+    except:
-+         __all__ = ['version_table', 'plot_animation']
-+
-+
-+from IPython.display import HTML, Javascript, display
-+
-+import matplotlib.pyplot as plt
-+from matplotlib import animation
-+from base64 import b64encode
-+
-+import datetime
-+import uuid
-+import sys
-+import os
-+import time
-+import inspect
-+
-+import qutip
-+import numpy
-+import scipy
-+import matplotlib
-+import IPython
-+
-+try:
-+    import Cython
-+    _cython_available = True
-+except ImportError:
-+    _cython_available = False
-+
-+
-+def version_table(verbose=False):
-+    """
-+    Print an HTML-formatted table with version numbers for QuTiP and its
-+    dependencies. Use it in a IPython notebook to show which versions of
-+    different packages that were used to run the notebook. This should make it
-+    possible to reproduce the environment and the calculation later on.
-+
-+
-+    Returns
-+    -------
-+    version_table: string
-+        Return an HTML-formatted string containing version information for
-+        QuTiP dependencies.
-+
-+    """
-+
-+    html = "<table>"
-+    html += "<tr><th>Software</th><th>Version</th></tr>"
-+
-+    packages = [("QuTiP", qutip.__version__),
-+                ("Numpy", numpy.__version__),
-+                ("SciPy", scipy.__version__),
-+                ("matplotlib", matplotlib.__version__),
-+                ("Number of CPUs", available_cpu_count()),
-+                ("BLAS Info", _blas_info()),
-+                ("IPython", IPython.__version__),
-+                ("Python", sys.version),
-+                ("OS", "%s [%s]" % (os.name, sys.platform))
-+                ]
-+    if _cython_available:
-+        packages.append(("Cython", Cython.__version__))
-+
-+    for name, version in packages:
-+        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
-+
-+    if verbose:
-+        html += "<tr><th colspan='2'>Additional information</th></tr>"
-+        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
-+        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
-+                 qutip_install_path)
-+        try:
-+            import getpass
-+            html += ("<tr><td>User</td><td>%s</td></tr>" %
-+                     getpass.getuser())
-+        except:
-+            pass
-+
-+    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
-+        '%a %b %d %H:%M:%S %Y %Z')
-+    html += "</table>"
-+
-+    return HTML(html)
-+
-+
-+def _visualize_parfor_data(metadata):
-+    """
-+    Visualizing the task scheduling meta data collected from AsyncResults.
-+    """
-+    res = numpy.array(metadata)
-+    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
-+
-+    yticks = []
-+    yticklabels = []
-+    tmin = min(res[:, 1])
-+    for n, pid in enumerate(numpy.unique(res[:, 0])):
-+        yticks.append(n)
-+        yticklabels.append("%d" % pid)
-+        for m in numpy.where(res[:, 0] == pid)[0]:
-+            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
-+                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
-+
-+    ax.set_ylim(-.5, n + .5)
-+    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
-+    ax.set_yticks(yticks)
-+    ax.set_yticklabels(yticklabels)
-+    ax.set_ylabel("Engine")
-+    ax.set_xlabel("seconds")
-+    ax.set_title("Task schedule")
-+
-+
-+def parfor(task, task_vec, args=None, client=None, view=None,
-+           show_scheduling=False, show_progressbar=False):
-+    """
-+    Call the function ``tast`` for each value in ``task_vec`` using a cluster
-+    of IPython engines. The function ``task`` should have the signature
-+    ``task(value, args)`` or ``task(value)`` if ``args=None``.
-+
-+    The ``client`` and ``view`` are the IPython.parallel client and
-+    load-balanced view that will be used in the parfor execution. If these
-+    are ``None``, new instances will be created.
-+
-+    Parameters
-+    ----------
-+
-+    task: a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+
-+    task_vec: array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+
-+    args: list / dictionary
-+        The optional additional argument to the ``task`` function. For example
-+        a dictionary with parameter values.
-+
-+    client: IPython.parallel.Client
-+        The IPython.parallel Client instance that will be used in the
-+        parfor execution.
-+
-+    view: a IPython.parallel.Client view
-+        The view that is to be used in scheduling the tasks on the IPython
-+        cluster. Preferably a load-balanced view, which is obtained from the
-+        IPython.parallel.Client instance client by calling,
-+        view = client.load_balanced_view().
-+
-+    show_scheduling: bool {False, True}, default False
-+        Display a graph showing how the tasks (the evaluation of ``task`` for
-+        for the value in ``task_vec1``) was scheduled on the IPython engine
-+        cluster.
-+
-+    show_progressbar: bool {False, True}, default False
-+        Display a HTML-based progress bar duing the execution of the parfor
-+        loop.
-+
-+    Returns
-+    -------
-+    result : list
-+        The result list contains the value of ``task(value, args)`` for each
-+        value in ``task_vec``, that is, it should be equivalent to
-+        ``[task(v, args) for v in task_vec]``.
-+    """
-+
-+    if show_progressbar:
-+        progress_bar = HTMLProgressBar()
-+    else:
-+        progress_bar = None
-+
-+    return parallel_map(task, task_vec, task_args=args,
-+                        client=client, view=view, progress_bar=progress_bar,
-+                        show_scheduling=show_scheduling)
-+
-+
-+def parallel_map(task, values, task_args=None, task_kwargs=None,
-+                 client=None, view=None, progress_bar=None,
-+                 show_scheduling=False, **kwargs):
-+    """
-+    Call the function ``task`` for each value in ``values`` using a cluster
-+    of IPython engines. The function ``task`` should have the signature
-+    ``task(value, *args, **kwargs)``.
-+
-+    The ``client`` and ``view`` are the IPython.parallel client and
-+    load-balanced view that will be used in the parfor execution. If these
-+    are ``None``, new instances will be created.
-+
-+    Parameters
-+    ----------
-+
-+    task: a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+
-+    values: array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+
-+    task_args: list / dictionary
-+        The optional additional argument to the ``task`` function.
-+
-+    task_kwargs: list / dictionary
-+        The optional additional keyword argument to the ``task`` function.
-+
-+    client: IPython.parallel.Client
-+        The IPython.parallel Client instance that will be used in the
-+        parfor execution.
-+
-+    view: a IPython.parallel.Client view
-+        The view that is to be used in scheduling the tasks on the IPython
-+        cluster. Preferably a load-balanced view, which is obtained from the
-+        IPython.parallel.Client instance client by calling,
-+        view = client.load_balanced_view().
-+
-+    show_scheduling: bool {False, True}, default False
-+        Display a graph showing how the tasks (the evaluation of ``task`` for
-+        for the value in ``task_vec1``) was scheduled on the IPython engine
-+        cluster.
-+
-+    show_progressbar: bool {False, True}, default False
-+        Display a HTML-based progress bar during the execution of the parfor
-+        loop.
-+
-+    Returns
-+    -------
-+    result : list
-+        The result list contains the value of
-+        ``task(value, task_args, task_kwargs)`` for each
-+        value in ``values``.
-+
-+    """
-+    submitted = datetime.datetime.now()
-+
-+    if task_args is None:
-+        task_args = tuple()
-+
-+    if task_kwargs is None:
-+        task_kwargs = {}
-+
-+    if client is None:
-+        client = Client()
-+
-+        # make sure qutip is available at engines
-+        dview = client[:]
-+        dview.block = True
-+        dview.execute("from qutip import *")
-+
-+    if view is None:
-+        view = client.load_balanced_view()
-+
-+    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
-+               for value in values]
-+
-+    if progress_bar is None:
-+        view.wait(ar_list)
-+    else:
-+        if progress_bar is True:
-+            progress_bar = HTMLProgressBar()
-+
-+        n = len(ar_list)
-+        progress_bar.start(n)
-+        while True:
-+            n_finished = sum([ar.progress for ar in ar_list])
-+            progress_bar.update(n_finished)
-+
-+            if view.wait(ar_list, timeout=0.5):
-+                progress_bar.update(n)
-+                break
-+        progress_bar.finished()
-+
-+    if show_scheduling:
-+        metadata = [[ar.engine_id,
-+                     (ar.started - submitted).total_seconds(),
-+                     (ar.completed - submitted).total_seconds()]
-+                    for ar in ar_list]
-+        _visualize_parfor_data(metadata)
-+
-+    return [ar.get() for ar in ar_list]
-+
-+
-+def plot_animation(plot_setup_func, plot_func, result, name="movie",
-+                   writer="avconv", codec="libx264", verbose=False):
-+    """
-+    Create an animated plot of a Result object, as returned by one of
-+    the qutip evolution solvers.
-+
-+    .. note :: experimental
-+    """
-+
-+    fig, axes = plot_setup_func(result)
-+
-+    def update(n):
-+        return plot_func(result, n, fig=fig, axes=axes)
-+
-+    anim = animation.FuncAnimation(
-+        fig, update, frames=len(result.times), blit=True)
-+
-+    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
-+
-+    plt.close(fig)
-+
-+    if verbose:
-+        print("Created %s.m4v" % name)
-+
-+    video = open(name + '.mp4', "rb").read()
-+    video_encoded = b64encode(video).decode("ascii")
-+    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
-+        video_encoded)
-+    return HTML(video_tag)
-diff --git a/qutip/logging_utils.py b/qutip/logging_utils.py
-index c91b380b..915049d9 100644
---- a/qutip/logging_utils.py
-+++ b/qutip/logging_utils.py
-@@ -1,109 +1,109 @@
--"""
--This module contains internal-use functions for configuring and writing to
--debug logs, using Python's internal logging functionality by default.
--"""
--
--# IMPORTS
--from __future__ import absolute_import
--import inspect
--import logging
--
--from qutip.settings import settings
--
--# EXPORTS
--NOTSET = logging.NOTSET
--DEBUG_INTENSE = logging.DEBUG - 4
--DEBUG_VERBOSE = logging.DEBUG - 2
--DEBUG = logging.DEBUG
--INFO = logging.INFO
--WARN = logging.WARN
--ERROR = logging.ERROR
--CRITICAL = logging.CRITICAL
--
--__all__ = ['get_logger']
--
--# META-LOGGING
--
--metalogger = logging.getLogger(__name__)
--metalogger.addHandler(logging.NullHandler())
--
--
--# FUNCTIONS
--
--def get_logger(name=None):
--    """
--    Returns a Python logging object with handlers configured
--    in accordance with ~/.qutiprc. By default, this will do
--    something sensible to integrate with IPython when running
--    in that environment, and will print to stdout otherwise.
--
--    Note that this function uses a bit of magic, and thus should
--    not be considered part of the QuTiP API. Rather, this function
--    is for internal use only.
--
--    Parameters
--    ----------
--
--    name : str
--        Name of the logger to be created. If not passed,
--        the name will automatically be set to the name of the
--        calling module.
--    """
--    if name is None:
--        try:
--            calling_frame = inspect.stack()[1][0]
--            calling_module = inspect.getmodule(calling_frame)
--            name = (calling_module.__name__
--                    if calling_module is not None else '<none>')
--
--        except Exception:
--            metalogger.warn('Error creating logger.', exc_info=1)
--            name = '<unknown>'
--
--    logger = logging.getLogger(name)
--
--    policy = settings.log_handler
--
--    if policy == 'default':
--        # Let's try to see if we're in IPython mode.
--        policy = 'basic' if settings.ipython else 'stream'
--
--    metalogger.debug("Creating logger for {} with policy {}.".format(
--        name, policy
--    ))
--
--    if policy == 'basic':
--        # Add no handlers, just let basicConfig do it all.
--        # This is nice for working with IPython, since
--        # it will use its own handlers instead of our StreamHandler
--        # below.
--        if settings.debug:
--            logging.basicConfig(level=logging.DEBUG)
--        else:
--            logging.basicConfig()
--
--    elif policy == 'stream':
--        formatter = logging.Formatter(
--            '[%(asctime)s] %(name)s[%(process)s]: '
--            '%(funcName)s: %(levelname)s: %(message)s',
--            '%Y-%m-%d %H:%M:%S')
--        handler = logging.StreamHandler()
--        handler.setFormatter(formatter)
--        logger.addHandler(handler)
--
--        # We're handling things here, so no propagation out.
--        logger.propagate = False
--
--    elif policy == 'null':
--        # We need to add a NullHandler so that debugging works
--        # at all, but this policy leaves it to the user to
--        # make their own handlers. This is particularly useful
--        # for capturing to logfiles.
--        logger.addHandler(logging.NullHandler())
--
--    if settings.debug:
--        logger.setLevel(logging.DEBUG)
--    else:
--        logger.setLevel(logging.WARN)
--
--    return logger
-+"""
-+This module contains internal-use functions for configuring and writing to
-+debug logs, using Python's internal logging functionality by default.
-+"""
-+
-+# IMPORTS
-+from __future__ import absolute_import
-+import inspect
-+import logging
-+
-+from qutip.settings import settings
-+
-+# EXPORTS
-+NOTSET = logging.NOTSET
-+DEBUG_INTENSE = logging.DEBUG - 4
-+DEBUG_VERBOSE = logging.DEBUG - 2
-+DEBUG = logging.DEBUG
-+INFO = logging.INFO
-+WARN = logging.WARN
-+ERROR = logging.ERROR
-+CRITICAL = logging.CRITICAL
-+
-+__all__ = ['get_logger']
-+
-+# META-LOGGING
-+
-+metalogger = logging.getLogger(__name__)
-+metalogger.addHandler(logging.NullHandler())
-+
-+
-+# FUNCTIONS
-+
-+def get_logger(name=None):
-+    """
-+    Returns a Python logging object with handlers configured
-+    in accordance with ~/.qutiprc. By default, this will do
-+    something sensible to integrate with IPython when running
-+    in that environment, and will print to stdout otherwise.
-+
-+    Note that this function uses a bit of magic, and thus should
-+    not be considered part of the QuTiP API. Rather, this function
-+    is for internal use only.
-+
-+    Parameters
-+    ----------
-+
-+    name : str
-+        Name of the logger to be created. If not passed,
-+        the name will automatically be set to the name of the
-+        calling module.
-+    """
-+    if name is None:
-+        try:
-+            calling_frame = inspect.stack()[1][0]
-+            calling_module = inspect.getmodule(calling_frame)
-+            name = (calling_module.__name__
-+                    if calling_module is not None else '<none>')
-+
-+        except Exception:
-+            metalogger.warn('Error creating logger.', exc_info=1)
-+            name = '<unknown>'
-+
-+    logger = logging.getLogger(name)
-+
-+    policy = settings.log_handler
-+
-+    if policy == 'default':
-+        # Let's try to see if we're in IPython mode.
-+        policy = 'basic' if settings.ipython else 'stream'
-+
-+    metalogger.debug("Creating logger for {} with policy {}.".format(
-+        name, policy
-+    ))
-+
-+    if policy == 'basic':
-+        # Add no handlers, just let basicConfig do it all.
-+        # This is nice for working with IPython, since
-+        # it will use its own handlers instead of our StreamHandler
-+        # below.
-+        if settings.debug:
-+            logging.basicConfig(level=logging.DEBUG)
-+        else:
-+            logging.basicConfig()
-+
-+    elif policy == 'stream':
-+        formatter = logging.Formatter(
-+            '[%(asctime)s] %(name)s[%(process)s]: '
-+            '%(funcName)s: %(levelname)s: %(message)s',
-+            '%Y-%m-%d %H:%M:%S')
-+        handler = logging.StreamHandler()
-+        handler.setFormatter(formatter)
-+        logger.addHandler(handler)
-+
-+        # We're handling things here, so no propagation out.
-+        logger.propagate = False
-+
-+    elif policy == 'null':
-+        # We need to add a NullHandler so that debugging works
-+        # at all, but this policy leaves it to the user to
-+        # make their own handlers. This is particularly useful
-+        # for capturing to logfiles.
-+        logger.addHandler(logging.NullHandler())
-+
-+    if settings.debug:
-+        logger.setLevel(logging.DEBUG)
-+    else:
-+        logger.setLevel(logging.WARN)
-+
-+    return logger
-diff --git a/qutip/matplotlib_utilities.py b/qutip/matplotlib_utilities.py
-index 3181b291..816a4eb1 100644
---- a/qutip/matplotlib_utilities.py
-+++ b/qutip/matplotlib_utilities.py
-@@ -1,154 +1,154 @@
--"""
--This module contains utility functions that enhance Matplotlib
--in one way or another.
--"""
--
--__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
--
--import numpy as np
--
--try:
--    import matplotlib as mpl
--    from matplotlib import cm
--    from matplotlib.colors import (Normalize, ColorConverter)
--except:
--    class Normalize(object):
--        def __init__(self, vmin=None, vmax=None, clip=False):
--            pass
--
--
--def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
--                mid_color='#FFFFFF', min_color='#530017',
--                neg_color='#FF97D4', invert=False):
--    """A custom colormap that emphasizes negative values by creating a
--    nonlinear colormap.
--
--    Parameters
--    ----------
--    W : array
--        Wigner function array, or any array.
--    levels : int
--        Number of color levels to create.
--    shift : float
--        Shifts the value at which Wigner elements are emphasized.
--        This parameter should typically be negative and small (i.e -1e-5).
--    max_color : str
--        String for color corresponding to maximum value of data.  Accepts
--        any string format compatible with the Matplotlib.colors.ColorConverter.
--    mid_color : str
--        Color corresponding to zero values.  Accepts any string format
--        compatible with the Matplotlib.colors.ColorConverter.
--    min_color : str
--        Color corresponding to minimum data values.  Accepts any string format
--        compatible with the Matplotlib.colors.ColorConverter.
--    neg_color : str
--        Color that starts highlighting negative values.  Accepts any string
--        format compatible with the Matplotlib.colors.ColorConverter.
--    invert : bool
--        Invert the color scheme for negative values so that smaller negative
--        values have darker color.
--
--    Returns
--    -------
--    Returns a Matplotlib colormap instance for use in plotting.
--
--    Notes
--    -----
--    The 'shift' parameter allows you to vary where the colormap begins
--    to highlight negative colors. This is beneficial in cases where there
--    are small negative Wigner elements due to numerical round-off and/or
--    truncation.
--
--    """
--    cc = ColorConverter()
--    max_color = np.array(cc.to_rgba(max_color), dtype=float)
--    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
--    if invert:
--        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
--        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
--    else:
--        min_color = np.array(cc.to_rgba(min_color), dtype=float)
--        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
--    # get min and max values from Wigner function
--    bounds = [W.min(), W.max()]
--    # create empty array for RGBA colors
--    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
--    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
--                        / (bounds[1] - bounds[0])))
--    num_pos = levels - zero_pos
--    num_neg = zero_pos - 1
--    # set zero values to mid_color
--    adjust_RGBA[zero_pos] = mid_color
--    # interpolate colors
--    for k in range(0, levels):
--        if k < zero_pos:
--            interp = k / (num_neg + 1.0)
--            adjust_RGBA[k][0:3] = (1.0 - interp) * \
--                min_color[0:3] + interp * neg_color[0:3]
--        elif k > zero_pos:
--            interp = (k - zero_pos) / (num_pos + 1.0)
--            adjust_RGBA[k][0:3] = (1.0 - interp) * \
--                mid_color[0:3] + interp * max_color[0:3]
--    # create colormap
--    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
--                                                            adjust_RGBA,
--                                                            N=levels)
--    return wig_cmap
--
--
--def complex_phase_cmap():
--    """
--    Create a cyclic colormap for representing the phase of complex variables
--
--    Returns
--    -------
--    cmap :
--        A matplotlib linear segmented colormap.
--    """
--    cdict = {'blue': ((0.00, 0.0, 0.0),
--                      (0.25, 0.0, 0.0),
--                      (0.50, 1.0, 1.0),
--                      (0.75, 1.0, 1.0),
--                      (1.00, 0.0, 0.0)),
--             'green': ((0.00, 0.0, 0.0),
--                       (0.25, 1.0, 1.0),
--                       (0.50, 0.0, 0.0),
--                       (0.75, 1.0, 1.0),
--                       (1.00, 0.0, 0.0)),
--             'red': ((0.00, 1.0, 1.0),
--                     (0.25, 0.5, 0.5),
--                     (0.50, 0.0, 0.0),
--                     (0.75, 0.0, 0.0),
--                     (1.00, 1.0, 1.0))}
--
--    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
--
--    return cmap
--
--
--class MidpointNorm(Normalize):
--    """Normalization for a colormap centered about a given midpoint.
--
--    Parameters
--    ----------
--    midpoint : float (optional, default=0)
--        Midpoint about which colormap is centered.
--    vmin: float (optional)
--        Minimal value for colormap. Calculated from data by default.
--    vmax: float (optional)
--        Maximal value for colormap. Calculated from data by default.
--
--    Returns
--    -------
--    Returns a Matplotlib colormap normalization that can be used
--    with any colormap.
--
--    """
--
--    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
--        self.midpoint = midpoint
--        Normalize.__init__(self, vmin, vmax, clip)
--
--    def __call__(self, value, clip=None):
--        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
--        return np.ma.masked_array(np.interp(value, x, y))
-+"""
-+This module contains utility functions that enhance Matplotlib
-+in one way or another.
-+"""
-+
-+__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
-+
-+import numpy as np
-+
-+try:
-+    import matplotlib as mpl
-+    from matplotlib import cm
-+    from matplotlib.colors import (Normalize, ColorConverter)
-+except:
-+    class Normalize(object):
-+        def __init__(self, vmin=None, vmax=None, clip=False):
-+            pass
-+
-+
-+def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
-+                mid_color='#FFFFFF', min_color='#530017',
-+                neg_color='#FF97D4', invert=False):
-+    """A custom colormap that emphasizes negative values by creating a
-+    nonlinear colormap.
-+
-+    Parameters
-+    ----------
-+    W : array
-+        Wigner function array, or any array.
-+    levels : int
-+        Number of color levels to create.
-+    shift : float
-+        Shifts the value at which Wigner elements are emphasized.
-+        This parameter should typically be negative and small (i.e -1e-5).
-+    max_color : str
-+        String for color corresponding to maximum value of data.  Accepts
-+        any string format compatible with the Matplotlib.colors.ColorConverter.
-+    mid_color : str
-+        Color corresponding to zero values.  Accepts any string format
-+        compatible with the Matplotlib.colors.ColorConverter.
-+    min_color : str
-+        Color corresponding to minimum data values.  Accepts any string format
-+        compatible with the Matplotlib.colors.ColorConverter.
-+    neg_color : str
-+        Color that starts highlighting negative values.  Accepts any string
-+        format compatible with the Matplotlib.colors.ColorConverter.
-+    invert : bool
-+        Invert the color scheme for negative values so that smaller negative
-+        values have darker color.
-+
-+    Returns
-+    -------
-+    Returns a Matplotlib colormap instance for use in plotting.
-+
-+    Notes
-+    -----
-+    The 'shift' parameter allows you to vary where the colormap begins
-+    to highlight negative colors. This is beneficial in cases where there
-+    are small negative Wigner elements due to numerical round-off and/or
-+    truncation.
-+
-+    """
-+    cc = ColorConverter()
-+    max_color = np.array(cc.to_rgba(max_color), dtype=float)
-+    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
-+    if invert:
-+        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
-+        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
-+    else:
-+        min_color = np.array(cc.to_rgba(min_color), dtype=float)
-+        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
-+    # get min and max values from Wigner function
-+    bounds = [W.min(), W.max()]
-+    # create empty array for RGBA colors
-+    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
-+    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
-+                        / (bounds[1] - bounds[0])))
-+    num_pos = levels - zero_pos
-+    num_neg = zero_pos - 1
-+    # set zero values to mid_color
-+    adjust_RGBA[zero_pos] = mid_color
-+    # interpolate colors
-+    for k in range(0, levels):
-+        if k < zero_pos:
-+            interp = k / (num_neg + 1.0)
-+            adjust_RGBA[k][0:3] = (1.0 - interp) * \
-+                min_color[0:3] + interp * neg_color[0:3]
-+        elif k > zero_pos:
-+            interp = (k - zero_pos) / (num_pos + 1.0)
-+            adjust_RGBA[k][0:3] = (1.0 - interp) * \
-+                mid_color[0:3] + interp * max_color[0:3]
-+    # create colormap
-+    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
-+                                                            adjust_RGBA,
-+                                                            N=levels)
-+    return wig_cmap
-+
-+
-+def complex_phase_cmap():
-+    """
-+    Create a cyclic colormap for representing the phase of complex variables
-+
-+    Returns
-+    -------
-+    cmap :
-+        A matplotlib linear segmented colormap.
-+    """
-+    cdict = {'blue': ((0.00, 0.0, 0.0),
-+                      (0.25, 0.0, 0.0),
-+                      (0.50, 1.0, 1.0),
-+                      (0.75, 1.0, 1.0),
-+                      (1.00, 0.0, 0.0)),
-+             'green': ((0.00, 0.0, 0.0),
-+                       (0.25, 1.0, 1.0),
-+                       (0.50, 0.0, 0.0),
-+                       (0.75, 1.0, 1.0),
-+                       (1.00, 0.0, 0.0)),
-+             'red': ((0.00, 1.0, 1.0),
-+                     (0.25, 0.5, 0.5),
-+                     (0.50, 0.0, 0.0),
-+                     (0.75, 0.0, 0.0),
-+                     (1.00, 1.0, 1.0))}
-+
-+    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
-+
-+    return cmap
-+
-+
-+class MidpointNorm(Normalize):
-+    """Normalization for a colormap centered about a given midpoint.
-+
-+    Parameters
-+    ----------
-+    midpoint : float (optional, default=0)
-+        Midpoint about which colormap is centered.
-+    vmin: float (optional)
-+        Minimal value for colormap. Calculated from data by default.
-+    vmax: float (optional)
-+        Maximal value for colormap. Calculated from data by default.
-+
-+    Returns
-+    -------
-+    Returns a Matplotlib colormap normalization that can be used
-+    with any colormap.
-+
-+    """
-+
-+    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
-+        self.midpoint = midpoint
-+        Normalize.__init__(self, vmin, vmax, clip)
-+
-+    def __call__(self, value, clip=None):
-+        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
-+        return np.ma.masked_array(np.interp(value, x, y))
-diff --git a/qutip/measurement.py b/qutip/measurement.py
-index da90387d..65e2f1ca 100644
---- a/qutip/measurement.py
-+++ b/qutip/measurement.py
-@@ -1,381 +1,381 @@
--"""
--Module for measuring quantum objects.
--"""
--
--__all__ = [
--    'measurement_statistics_povm',
--    'measurement_statistics_observable',
--    'measure_observable',
--    'measure_povm',
--    'measurement_statistics',
--    'measure'
--]
--
--import numpy as np
--
--from . import Qobj, expect, identity, tensor
--
--
--def _verify_input(op, state):
--    if not isinstance(op, Qobj):
--        raise TypeError("op must be a Qobj")
--    if not op.isoper:
--        raise ValueError("op must be all operators or all kets")
--    if not isinstance(state, Qobj):
--        raise TypeError("state must be a Qobj")
--    if state.isket:
--        if op.dims[-1] != state.dims[0]:
--            raise ValueError(
--                "op and state dims should be compatible when state is a ket")
--    elif state.isoper:
--        if op.dims != state.dims:
--            raise ValueError(
--                "op and state dims should match"
--                " when state is a density matrix")
--    else:
--        raise ValueError("state must be a ket or a density matrix")
--
--
--def _measurement_statistics_povm_ket(state, ops):
--    r"""
--    Returns measurement statistics (resultant states and probabilities)
--    for a measurements specified by a set of positive operator valued
--    measurements on a specified ket.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj` (ket)
--            The ket specifying the state to measure.
--
--    ops : list of :class:`.Qobj`
--      List of measurement operators :math:`M_i` (specifying a POVM such that
--      :math:`E_i = M_i^\dagger M_i`).
--
--
--    Returns
--    -------
--    collapsed_states : list of :class:`.Qobj` (kets)
--        The collapsed states (kets) obtained after measuring the qubits and
--        obtaining the qubit specified by the target in the state specified by
--        the index.
--
--    probabilities : list of floats
--        The probability of measuring a state in a the state specified by the
--        index.
--    """
--    probabilities = []
--    collapsed_states = []
--
--    for i, op in enumerate(ops):
--        p = np.absolute((state.dag() * op.dag() * op * state))
--        probabilities.append(p)
--        if p != 0:
--            collapsed_states.append((op * state) / np.sqrt(p))
--        else:
--            collapsed_states.append(None)
--
--    return collapsed_states, probabilities
--
--
--def _measurement_statistics_povm_dm(density_mat, ops):
--    r"""
--    Returns measurement statistics (resultant states and probabilities)
--    for a measurements specified by a set of positive operator valued
--    measurements on a specified ket or density matrix.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj` (density matrix)
--        The ket or density matrix specifying the state to measure.
--
--    ops : list of :class:`.Qobj`
--        List of measurement operators :math:`M_i` (specifying a POVM s.t.
--        :mathm:`E_i = M_i^\dagger M_i`)
--
--    Returns
--    -------
--    collapsed_states : list of :class:`.Qobj`
--        The collapsed states (density matrices) obtained after measuring the
--        qubits and obtaining the qubit specified by the target in the state
--        specified by the index.
--
--    probabilities : list of float
--        The probability of measuring a state in a the state specified by the
--        index.
--    """
--    probabilities = []
--    collapsed_states = []
--
--    for i, op in enumerate(ops):
--        st = op * density_mat * op.dag()
--        p = st.tr()
--        probabilities.append(p)
--        if p != 0:
--            collapsed_states.append(st/p)
--        else:
--            collapsed_states.append(None)
--
--    return collapsed_states, probabilities
--
--
--def measurement_statistics_povm(state, ops):
--    r"""
--    Returns measurement statistics (resultant states and probabilities) for a
--    measurement specified by a set of positive operator valued measurements on
--    a specified ket or density matrix.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj`
--        The ket or density matrix specifying the state to measure.
--
--    ops : list of :class:`.Qobj`
--        List of measurement operators :math:`M_i` or kets.  Either:
--
--        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
--        2. projection operators if ops correspond to
--           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
--        3. kets (transformed to projectors)
--
--    Returns
--    -------
--    collapsed_states : list of :class:`.Qobj`
--        The collapsed states obtained after measuring the qubits and obtaining
--        the qubit specified by the target in the state specified by the index.
--
--    probabilities : list of floats
--        The probability of measuring a state in a the state specified by the
--        index.
--    """
--    if all(map(lambda x: x.isket, ops)):
--        ops = [op * op.dag() for op in ops]
--
--    for op in ops:
--        _verify_input(op, state)
--
--    E = [op.dag() * op for op in ops]
--
--    is_ID = sum(E)
--    if not is_ID == identity(is_ID.dims[0]):
--        raise ValueError("measurement operators must sum to identity")
--
--    if state.isket:
--        return _measurement_statistics_povm_ket(state, ops)
--    else:
--        return _measurement_statistics_povm_dm(state, ops)
--
--
--def measurement_statistics_observable(state, op):
--    """
--    Return the measurement eigenvalues, eigenstates (or projectors) and
--    measurement probabilities for the given state and measurement operator.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj`
--        The ket or density matrix specifying the state to measure.
--
--    op : :class:`.Qobj`
--        The measurement operator.
--
--    Returns
--    -------
--    eigenvalues: list of float
--        The list of eigenvalues of the measurement operator.
--
--    eigenstates_or_projectors: list of :class:`.Qobj`
--        If the state was a ket, return the eigenstates of the measurement
--        operator. Otherwise return the projectors onto the eigenstates.
--
--    probabilities: list of float
--        The probability of measuring the state as being in the corresponding
--        eigenstate (and the measurement result being the corresponding
--        eigenvalue).
--    """
--    _verify_input(op, state)
--
--    eigenvalues, eigenstates = op.eigenstates()
--    if state.isket:
--        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
--        return eigenvalues, eigenstates, probabilities
--    else:
--        projectors = [e.proj() for e in eigenstates]
--        probabilities = [expect(v, state) for v in projectors]
--        return eigenvalues, projectors, probabilities
--
--
--def measure_observable(state, op):
--    """
--    Perform a measurement specified by an operator on the given state.
--
--    This function simulates the classic quantum measurement described in many
--    introductory texts on quantum mechanics. The measurement collapses the
--    state to one of the eigenstates of the given operator and the result of the
--    measurement is the corresponding eigenvalue.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj`
--        The ket or density matrix specifying the state to measure.
--
--    op : :class:`.Qobj`
--        The measurement operator.
--
--    Returns
--    -------
--    measured_value : float
--        The result of the measurement (one of the eigenvalues of op).
--
--    state : :class:`.Qobj`
--        The new state (a ket if a ket was given, otherwise a density matrix).
--
--    Examples
--    --------
--
--    Measure the z-component of the spin of the spin-up basis state:
--
--    >>> measure_observable(basis(2, 0), sigmaz())
--    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
--    Qobj data =
--    [[-1.]
--     [ 0.]])
--
--    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
--    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
--    and the original state (up to a global phase).
--
--    Measure the x-component of the spin of the spin-down basis state:
--
--    >>> measure_observable(basis(2, 1), sigmax())
--    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
--    Qobj data =
--    [[-0.70710678]
--     [ 0.70710678]])
--
--    This measurement returns 1 fifty percent of the time and -1 the other fifty
--    percent of the time. The new state returned is the corresponding eigenstate
--    of sigmax.
--
--    One may also perform a measurement on a density matrix. Below we perform
--    the same measurement as above, but on the density matrix representing the
--    pure spin-down state:
--
--    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
--    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
--    Qobj data =
--    [[ 0.5 -0.5]
--     [-0.5  0.5]])
--
--    The measurement result is the same, but the new state is returned as a
--    density matrix.
--    """
--    eigenvalues, eigenstates_or_projectors, probabilities = (
--        measurement_statistics_observable(state, op))
--    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
--    if state.isket:
--        eigenstates = eigenstates_or_projectors
--        state = eigenstates[i]
--    else:
--        projectors = eigenstates_or_projectors
--        state = (projectors[i] * state * projectors[i]) / probabilities[i]
--    return eigenvalues[i], state
--
--
--def measure_povm(state, ops):
--    r"""
--    Perform a measurement specified by list of POVMs.
--
--    This function simulates a POVM measurement. The measurement collapses the
--    state to one of the resultant states of the measurement and returns the
--    index of the operator corresponding to the collapsed state as well as the
--    collapsed state.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj`
--        The ket or density matrix specifying the state to measure.
--
--    ops : list of :class:`.Qobj`
--        List of measurement operators :math:`M_i` or kets.  Either:
--
--        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
--        2. projection operators if ops correspond to projectors (s.t.
--           :math:`E_i = M_i^\dagger = M_i`)
--        3. kets (transformed to projectors)
--
--    Returns
--    -------
--    index : float
--        The resultant index of the measurement.
--
--    state : :class:`.Qobj`
--        The new state (a ket if a ket was given, otherwise a density matrix).
--    """
--    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
--    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
--    state = collapsed_states[index]
--    return index, state
--
--
--def measurement_statistics(state, ops):
--    r"""
--    A dispatch method that provides measurement statistics handling both
--    observable style measurements and projector style measurements(POVMs and
--    PVMs).
--
--    For return signatures, please check:
--
--    - :func:`~measurement_statistics_observable` for observable measurements.
--    - :func:`~measurement_statistics_povm` for POVM measurements.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj`
--        The ket or density matrix specifying the state to measure.
--
--    ops : :class:`.Qobj` or list of :class:`.Qobj`
--        - measurement observable (:class:.Qobj); or
--        - list of measurement operators :math:`M_i` or kets (list of
--          :class:`.Qobj`) Either:
--
--          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
--          2. projection operators if ops correspond to projectors (s.t.
--             :math:`E_i = M_i^\dagger = M_i`)
--          3. kets (transformed to projectors)
--    """
--    if isinstance(ops, list):
--        return measurement_statistics_povm(state, ops)
--    else:
--        return measurement_statistics_observable(state, ops)
--
--
--def measure(state, ops):
--    r"""
--    A dispatch method that provides measurement results handling both
--    observable style measurements and projector style measurements (POVMs and
--    PVMs).
--
--    For return signatures, please check:
--
--    - :func:`~measure_observable` for observable measurements.
--    - :func:`~measure_povm` for POVM measurements.
--
--    Parameters
--    ----------
--    state : :class:`.Qobj`
--        The ket or density matrix specifying the state to measure.
--
--    ops : :class:`.Qobj` or list of :class:`.Qobj`
--        - measurement observable (:class:`.Qobj`); or
--        - list of measurement operators :math:`M_i` or kets (list of
--          :class:`.Qobj`) Either:
--
--          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
--          2. projection operators if ops correspond to projectors (s.t.
--             :math:`E_i = M_i^\dagger = M_i`)
--          3. kets (transformed to projectors)
--    """
--    if isinstance(ops, list):
--        return measure_povm(state, ops)
--    else:
--        return measure_observable(state, ops)
-+"""
-+Module for measuring quantum objects.
-+"""
-+
-+__all__ = [
-+    'measurement_statistics_povm',
-+    'measurement_statistics_observable',
-+    'measure_observable',
-+    'measure_povm',
-+    'measurement_statistics',
-+    'measure'
-+]
-+
-+import numpy as np
-+
-+from . import Qobj, expect, identity, tensor
-+
-+
-+def _verify_input(op, state):
-+    if not isinstance(op, Qobj):
-+        raise TypeError("op must be a Qobj")
-+    if not op.isoper:
-+        raise ValueError("op must be all operators or all kets")
-+    if not isinstance(state, Qobj):
-+        raise TypeError("state must be a Qobj")
-+    if state.isket:
-+        if op.dims[-1] != state.dims[0]:
-+            raise ValueError(
-+                "op and state dims should be compatible when state is a ket")
-+    elif state.isoper:
-+        if op.dims != state.dims:
-+            raise ValueError(
-+                "op and state dims should match"
-+                " when state is a density matrix")
-+    else:
-+        raise ValueError("state must be a ket or a density matrix")
-+
-+
-+def _measurement_statistics_povm_ket(state, ops):
-+    r"""
-+    Returns measurement statistics (resultant states and probabilities)
-+    for a measurements specified by a set of positive operator valued
-+    measurements on a specified ket.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj` (ket)
-+            The ket specifying the state to measure.
-+
-+    ops : list of :class:`.Qobj`
-+      List of measurement operators :math:`M_i` (specifying a POVM such that
-+      :math:`E_i = M_i^\dagger M_i`).
-+
-+
-+    Returns
-+    -------
-+    collapsed_states : list of :class:`.Qobj` (kets)
-+        The collapsed states (kets) obtained after measuring the qubits and
-+        obtaining the qubit specified by the target in the state specified by
-+        the index.
-+
-+    probabilities : list of floats
-+        The probability of measuring a state in a the state specified by the
-+        index.
-+    """
-+    probabilities = []
-+    collapsed_states = []
-+
-+    for i, op in enumerate(ops):
-+        p = np.absolute((state.dag() * op.dag() * op * state))
-+        probabilities.append(p)
-+        if p != 0:
-+            collapsed_states.append((op * state) / np.sqrt(p))
-+        else:
-+            collapsed_states.append(None)
-+
-+    return collapsed_states, probabilities
-+
-+
-+def _measurement_statistics_povm_dm(density_mat, ops):
-+    r"""
-+    Returns measurement statistics (resultant states and probabilities)
-+    for a measurements specified by a set of positive operator valued
-+    measurements on a specified ket or density matrix.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj` (density matrix)
-+        The ket or density matrix specifying the state to measure.
-+
-+    ops : list of :class:`.Qobj`
-+        List of measurement operators :math:`M_i` (specifying a POVM s.t.
-+        :mathm:`E_i = M_i^\dagger M_i`)
-+
-+    Returns
-+    -------
-+    collapsed_states : list of :class:`.Qobj`
-+        The collapsed states (density matrices) obtained after measuring the
-+        qubits and obtaining the qubit specified by the target in the state
-+        specified by the index.
-+
-+    probabilities : list of float
-+        The probability of measuring a state in a the state specified by the
-+        index.
-+    """
-+    probabilities = []
-+    collapsed_states = []
-+
-+    for i, op in enumerate(ops):
-+        st = op * density_mat * op.dag()
-+        p = st.tr()
-+        probabilities.append(p)
-+        if p != 0:
-+            collapsed_states.append(st/p)
-+        else:
-+            collapsed_states.append(None)
-+
-+    return collapsed_states, probabilities
-+
-+
-+def measurement_statistics_povm(state, ops):
-+    r"""
-+    Returns measurement statistics (resultant states and probabilities) for a
-+    measurement specified by a set of positive operator valued measurements on
-+    a specified ket or density matrix.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj`
-+        The ket or density matrix specifying the state to measure.
-+
-+    ops : list of :class:`.Qobj`
-+        List of measurement operators :math:`M_i` or kets.  Either:
-+
-+        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-+        2. projection operators if ops correspond to
-+           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
-+        3. kets (transformed to projectors)
-+
-+    Returns
-+    -------
-+    collapsed_states : list of :class:`.Qobj`
-+        The collapsed states obtained after measuring the qubits and obtaining
-+        the qubit specified by the target in the state specified by the index.
-+
-+    probabilities : list of floats
-+        The probability of measuring a state in a the state specified by the
-+        index.
-+    """
-+    if all(map(lambda x: x.isket, ops)):
-+        ops = [op * op.dag() for op in ops]
-+
-+    for op in ops:
-+        _verify_input(op, state)
-+
-+    E = [op.dag() * op for op in ops]
-+
-+    is_ID = sum(E)
-+    if not is_ID == identity(is_ID.dims[0]):
-+        raise ValueError("measurement operators must sum to identity")
-+
-+    if state.isket:
-+        return _measurement_statistics_povm_ket(state, ops)
-+    else:
-+        return _measurement_statistics_povm_dm(state, ops)
-+
-+
-+def measurement_statistics_observable(state, op):
-+    """
-+    Return the measurement eigenvalues, eigenstates (or projectors) and
-+    measurement probabilities for the given state and measurement operator.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj`
-+        The ket or density matrix specifying the state to measure.
-+
-+    op : :class:`.Qobj`
-+        The measurement operator.
-+
-+    Returns
-+    -------
-+    eigenvalues: list of float
-+        The list of eigenvalues of the measurement operator.
-+
-+    eigenstates_or_projectors: list of :class:`.Qobj`
-+        If the state was a ket, return the eigenstates of the measurement
-+        operator. Otherwise return the projectors onto the eigenstates.
-+
-+    probabilities: list of float
-+        The probability of measuring the state as being in the corresponding
-+        eigenstate (and the measurement result being the corresponding
-+        eigenvalue).
-+    """
-+    _verify_input(op, state)
-+
-+    eigenvalues, eigenstates = op.eigenstates()
-+    if state.isket:
-+        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
-+        return eigenvalues, eigenstates, probabilities
-+    else:
-+        projectors = [e.proj() for e in eigenstates]
-+        probabilities = [expect(v, state) for v in projectors]
-+        return eigenvalues, projectors, probabilities
-+
-+
-+def measure_observable(state, op):
-+    """
-+    Perform a measurement specified by an operator on the given state.
-+
-+    This function simulates the classic quantum measurement described in many
-+    introductory texts on quantum mechanics. The measurement collapses the
-+    state to one of the eigenstates of the given operator and the result of the
-+    measurement is the corresponding eigenvalue.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj`
-+        The ket or density matrix specifying the state to measure.
-+
-+    op : :class:`.Qobj`
-+        The measurement operator.
-+
-+    Returns
-+    -------
-+    measured_value : float
-+        The result of the measurement (one of the eigenvalues of op).
-+
-+    state : :class:`.Qobj`
-+        The new state (a ket if a ket was given, otherwise a density matrix).
-+
-+    Examples
-+    --------
-+
-+    Measure the z-component of the spin of the spin-up basis state:
-+
-+    >>> measure_observable(basis(2, 0), sigmaz())
-+    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
-+    Qobj data =
-+    [[-1.]
-+     [ 0.]])
-+
-+    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
-+    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
-+    and the original state (up to a global phase).
-+
-+    Measure the x-component of the spin of the spin-down basis state:
-+
-+    >>> measure_observable(basis(2, 1), sigmax())
-+    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
-+    Qobj data =
-+    [[-0.70710678]
-+     [ 0.70710678]])
-+
-+    This measurement returns 1 fifty percent of the time and -1 the other fifty
-+    percent of the time. The new state returned is the corresponding eigenstate
-+    of sigmax.
-+
-+    One may also perform a measurement on a density matrix. Below we perform
-+    the same measurement as above, but on the density matrix representing the
-+    pure spin-down state:
-+
-+    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
-+    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
-+    Qobj data =
-+    [[ 0.5 -0.5]
-+     [-0.5  0.5]])
-+
-+    The measurement result is the same, but the new state is returned as a
-+    density matrix.
-+    """
-+    eigenvalues, eigenstates_or_projectors, probabilities = (
-+        measurement_statistics_observable(state, op))
-+    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
-+    if state.isket:
-+        eigenstates = eigenstates_or_projectors
-+        state = eigenstates[i]
-+    else:
-+        projectors = eigenstates_or_projectors
-+        state = (projectors[i] * state * projectors[i]) / probabilities[i]
-+    return eigenvalues[i], state
-+
-+
-+def measure_povm(state, ops):
-+    r"""
-+    Perform a measurement specified by list of POVMs.
-+
-+    This function simulates a POVM measurement. The measurement collapses the
-+    state to one of the resultant states of the measurement and returns the
-+    index of the operator corresponding to the collapsed state as well as the
-+    collapsed state.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj`
-+        The ket or density matrix specifying the state to measure.
-+
-+    ops : list of :class:`.Qobj`
-+        List of measurement operators :math:`M_i` or kets.  Either:
-+
-+        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-+        2. projection operators if ops correspond to projectors (s.t.
-+           :math:`E_i = M_i^\dagger = M_i`)
-+        3. kets (transformed to projectors)
-+
-+    Returns
-+    -------
-+    index : float
-+        The resultant index of the measurement.
-+
-+    state : :class:`.Qobj`
-+        The new state (a ket if a ket was given, otherwise a density matrix).
-+    """
-+    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
-+    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
-+    state = collapsed_states[index]
-+    return index, state
-+
-+
-+def measurement_statistics(state, ops):
-+    r"""
-+    A dispatch method that provides measurement statistics handling both
-+    observable style measurements and projector style measurements(POVMs and
-+    PVMs).
-+
-+    For return signatures, please check:
-+
-+    - :func:`~measurement_statistics_observable` for observable measurements.
-+    - :func:`~measurement_statistics_povm` for POVM measurements.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj`
-+        The ket or density matrix specifying the state to measure.
-+
-+    ops : :class:`.Qobj` or list of :class:`.Qobj`
-+        - measurement observable (:class:.Qobj); or
-+        - list of measurement operators :math:`M_i` or kets (list of
-+          :class:`.Qobj`) Either:
-+
-+          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
-+          2. projection operators if ops correspond to projectors (s.t.
-+             :math:`E_i = M_i^\dagger = M_i`)
-+          3. kets (transformed to projectors)
-+    """
-+    if isinstance(ops, list):
-+        return measurement_statistics_povm(state, ops)
-+    else:
-+        return measurement_statistics_observable(state, ops)
-+
-+
-+def measure(state, ops):
-+    r"""
-+    A dispatch method that provides measurement results handling both
-+    observable style measurements and projector style measurements (POVMs and
-+    PVMs).
-+
-+    For return signatures, please check:
-+
-+    - :func:`~measure_observable` for observable measurements.
-+    - :func:`~measure_povm` for POVM measurements.
-+
-+    Parameters
-+    ----------
-+    state : :class:`.Qobj`
-+        The ket or density matrix specifying the state to measure.
-+
-+    ops : :class:`.Qobj` or list of :class:`.Qobj`
-+        - measurement observable (:class:`.Qobj`); or
-+        - list of measurement operators :math:`M_i` or kets (list of
-+          :class:`.Qobj`) Either:
-+
-+          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-+          2. projection operators if ops correspond to projectors (s.t.
-+             :math:`E_i = M_i^\dagger = M_i`)
-+          3. kets (transformed to projectors)
-+    """
-+    if isinstance(ops, list):
-+        return measure_povm(state, ops)
-+    else:
-+        return measure_observable(state, ops)
-diff --git a/qutip/orbital.py b/qutip/orbital.py
-index 209b65b4..6d171d88 100644
---- a/qutip/orbital.py
-+++ b/qutip/orbital.py
-@@ -1,81 +1,81 @@
--__all__ = ['orbital']
--
--import numpy as np
--from scipy.special import sph_harm
--
--
--def orbital(theta, phi, *args):
--    r"""Calculates an angular wave function on a sphere.
--    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
--    the angular wave function on a sphere at the mesh of points
--    defined by theta and phi which is
--    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
--    coefficients specified by the list of kets. Each ket has 2l+1 components
--    for some integer l. The first entry of the ket defines the coefficient
--    c_{l,-l}, while the last entry of the ket defines the
--    coefficient c_{l, l}.
--
--    Parameters
--    ----------
--    theta : int/float/list/array
--        Polar angles in [0, pi]
--
--    phi : int/float/list/array
--        Azimuthal angles in [0, 2*pi]
--
--    args : list/array
--        ``list`` of ket vectors.
--
--    Returns
--    -------
--    ``array`` for angular wave function evaluated at all
--              possible combinations of theta and phi
--
--    """
--    if isinstance(args[0], list):
--        # use the list in args[0]
--        args = args[0]
--
--    # convert to numpy array
--    theta = np.atleast_1d(theta)
--    phi = np.atleast_1d(phi)
--    # check that arrays are only 1D
--    if len(theta.shape) != 1:
--        raise ValueError('Polar angles theta must be 1D list')
--    if len(phi.shape) != 1:
--        raise ValueError('Azimuthal angles phi must be 1D list')
--
--    # make meshgrid
--    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
--    # setup empty wavefunction
--    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
--    # iterate through provided kets
--    for k in range(len(args)):
--        ket = args[k]
--        if ket.type == 'bra':
--            ket = ket.conj()
--        elif not ket.type == 'ket':
--            raise TypeError('Invalid type for input ket in orbital')
--        # Extract l value from the state
--        l = (ket.shape[0] - 1) / 2.0
--        if l != np.floor(l):
--            raise ValueError(
--                'Kets must have odd number of components in orbital')
--        l = int(l)
--        # get factors from ket
--        factors = ket.full()
--        # iterate through the possible m
--
--        for i in range(len(factors)):
--            # set correct m
--            m = i - l
--            # calculate spherical harmonics
--            # note that theta and phi are interchanged in scipy implementation
--            res = sph_harm(m, l, phi_mesh, theta_mesh)
--            psi += factors[i] * res
--
--    # flatten output if only one row
--    if psi.shape[1] == 1:
--        psi = psi.flatten()
--
--    return psi
-+__all__ = ['orbital']
-+
-+import numpy as np
-+from scipy.special import sph_harm
-+
-+
-+def orbital(theta, phi, *args):
-+    r"""Calculates an angular wave function on a sphere.
-+    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
-+    the angular wave function on a sphere at the mesh of points
-+    defined by theta and phi which is
-+    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
-+    coefficients specified by the list of kets. Each ket has 2l+1 components
-+    for some integer l. The first entry of the ket defines the coefficient
-+    c_{l,-l}, while the last entry of the ket defines the
-+    coefficient c_{l, l}.
-+
-+    Parameters
-+    ----------
-+    theta : int/float/list/array
-+        Polar angles in [0, pi]
-+
-+    phi : int/float/list/array
-+        Azimuthal angles in [0, 2*pi]
-+
-+    args : list/array
-+        ``list`` of ket vectors.
-+
-+    Returns
-+    -------
-+    ``array`` for angular wave function evaluated at all
-+              possible combinations of theta and phi
-+
-+    """
-+    if isinstance(args[0], list):
-+        # use the list in args[0]
-+        args = args[0]
-+
-+    # convert to numpy array
-+    theta = np.atleast_1d(theta)
-+    phi = np.atleast_1d(phi)
-+    # check that arrays are only 1D
-+    if len(theta.shape) != 1:
-+        raise ValueError('Polar angles theta must be 1D list')
-+    if len(phi.shape) != 1:
-+        raise ValueError('Azimuthal angles phi must be 1D list')
-+
-+    # make meshgrid
-+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
-+    # setup empty wavefunction
-+    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
-+    # iterate through provided kets
-+    for k in range(len(args)):
-+        ket = args[k]
-+        if ket.type == 'bra':
-+            ket = ket.conj()
-+        elif not ket.type == 'ket':
-+            raise TypeError('Invalid type for input ket in orbital')
-+        # Extract l value from the state
-+        l = (ket.shape[0] - 1) / 2.0
-+        if l != np.floor(l):
-+            raise ValueError(
-+                'Kets must have odd number of components in orbital')
-+        l = int(l)
-+        # get factors from ket
-+        factors = ket.full()
-+        # iterate through the possible m
-+
-+        for i in range(len(factors)):
-+            # set correct m
-+            m = i - l
-+            # calculate spherical harmonics
-+            # note that theta and phi are interchanged in scipy implementation
-+            res = sph_harm(m, l, phi_mesh, theta_mesh)
-+            psi += factors[i] * res
-+
-+    # flatten output if only one row
-+    if psi.shape[1] == 1:
-+        psi = psi.flatten()
-+
-+    return psi
-diff --git a/qutip/partial_transpose.py b/qutip/partial_transpose.py
-index 61871369..4a0b2595 100644
---- a/qutip/partial_transpose.py
-+++ b/qutip/partial_transpose.py
-@@ -1,122 +1,122 @@
--__all__ = ['partial_transpose']
--
--import numpy as np
--import scipy.sparse as sp
--
--from . import (
--    Qobj, state_index_number, state_number_index, state_number_enumerate,
--)
--from .core.dimensions import flatten
--
--
--def partial_transpose(rho, mask, method='dense'):
--    """
--    Return the partial transpose of a Qobj instance `rho`,
--    where `mask` is an array/list with length that equals
--    the number of components of `rho` (that is, the length of
--    `rho.dims[0]`), and the values in `mask` indicates whether
--    or not the corresponding subsystem is to be transposed.
--    The elements in `mask` can be boolean or integers `0` or `1`,
--    where `True`/`1` indicates that the corresponding subsystem
--    should be tranposed.
--
--    Parameters
--    ----------
--
--    rho : :class:`qutip.qobj`
--        A density matrix.
--
--    mask : *list* / *array*
--        A mask that selects which subsystems should be transposed.
--
--    method : str
--        choice of method, `dense` or `sparse`. The default method
--        is `dense`. The `sparse` implementation can be faster for
--        large and sparse systems (hundreds of quantum states).
--
--    Returns
--    -------
--
--    rho_pr: :class:`qutip.qobj`
--
--        A density matrix with the selected subsystems transposed.
--
--    """
--
--    mask = [int(i) for i in mask]
--
--    if method == 'sparse':
--        return _partial_transpose_sparse(rho, mask)
--    else:
--        return _partial_transpose_dense(rho, mask)
--
--
--def _partial_transpose_dense(rho, mask):
--    """
--    Based on Jonas' implementation using numpy.
--    Very fast for dense problems.
--    """
--    nsys = len(mask)
--    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
--    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
--                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
--
--    data = (rho.full()
--            .reshape(flatten(rho.dims))
--            .transpose(pt_idx)
--            .reshape(rho.shape))
--    return Qobj(data, dims=rho.dims)
--
--
--def _partial_transpose_sparse(rho, mask):
--    """
--    Implement the partial transpose using the CSR sparse matrix.
--    """
--
--    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
--    rho_data = rho.to("CSR").data.as_scipy()
--
--    for m in range(len(rho_data.indptr) - 1):
--
--        n1 = rho_data.indptr[m]
--        n2 = rho_data.indptr[m + 1]
--
--        psi_A = state_index_number(rho.dims[0], m)
--
--        for idx, n in enumerate(rho_data.indices[n1:n2]):
--
--            psi_B = state_index_number(rho.dims[1], n)
--
--            m_pt = state_number_index(
--                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
--            n_pt = state_number_index(
--                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
--
--            data[m_pt, n_pt] = rho_data.data[n1 + idx]
--
--    return Qobj(data.tocsr(), dims=rho.dims)
--
--
--def _partial_transpose_reference(rho, mask):
--    """
--    This is a reference implementation that explicitly loops over
--    all states and performs the transpose. It's slow but easy to
--    understand and useful for testing.
--    """
--
--    A_pt = np.zeros(rho.shape, dtype=complex)
--
--    for psi_A in state_number_enumerate(rho.dims[0]):
--        m = state_number_index(rho.dims[0], psi_A)
--
--        for psi_B in state_number_enumerate(rho.dims[1]):
--            n = state_number_index(rho.dims[1], psi_B)
--
--            m_pt = state_number_index(
--                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
--            n_pt = state_number_index(
--                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
--
--            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
--
--    return Qobj(A_pt, dims=rho.dims)
-+__all__ = ['partial_transpose']
-+
-+import numpy as np
-+import scipy.sparse as sp
-+
-+from . import (
-+    Qobj, state_index_number, state_number_index, state_number_enumerate,
-+)
-+from .core.dimensions import flatten
-+
-+
-+def partial_transpose(rho, mask, method='dense'):
-+    """
-+    Return the partial transpose of a Qobj instance `rho`,
-+    where `mask` is an array/list with length that equals
-+    the number of components of `rho` (that is, the length of
-+    `rho.dims[0]`), and the values in `mask` indicates whether
-+    or not the corresponding subsystem is to be transposed.
-+    The elements in `mask` can be boolean or integers `0` or `1`,
-+    where `True`/`1` indicates that the corresponding subsystem
-+    should be tranposed.
-+
-+    Parameters
-+    ----------
-+
-+    rho : :class:`qutip.qobj`
-+        A density matrix.
-+
-+    mask : *list* / *array*
-+        A mask that selects which subsystems should be transposed.
-+
-+    method : str
-+        choice of method, `dense` or `sparse`. The default method
-+        is `dense`. The `sparse` implementation can be faster for
-+        large and sparse systems (hundreds of quantum states).
-+
-+    Returns
-+    -------
-+
-+    rho_pr: :class:`qutip.qobj`
-+
-+        A density matrix with the selected subsystems transposed.
-+
-+    """
-+
-+    mask = [int(i) for i in mask]
-+
-+    if method == 'sparse':
-+        return _partial_transpose_sparse(rho, mask)
-+    else:
-+        return _partial_transpose_dense(rho, mask)
-+
-+
-+def _partial_transpose_dense(rho, mask):
-+    """
-+    Based on Jonas' implementation using numpy.
-+    Very fast for dense problems.
-+    """
-+    nsys = len(mask)
-+    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
-+    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
-+                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
-+
-+    data = (rho.full()
-+            .reshape(flatten(rho.dims))
-+            .transpose(pt_idx)
-+            .reshape(rho.shape))
-+    return Qobj(data, dims=rho.dims)
-+
-+
-+def _partial_transpose_sparse(rho, mask):
-+    """
-+    Implement the partial transpose using the CSR sparse matrix.
-+    """
-+
-+    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
-+    rho_data = rho.to("CSR").data.as_scipy()
-+
-+    for m in range(len(rho_data.indptr) - 1):
-+
-+        n1 = rho_data.indptr[m]
-+        n2 = rho_data.indptr[m + 1]
-+
-+        psi_A = state_index_number(rho.dims[0], m)
-+
-+        for idx, n in enumerate(rho_data.indices[n1:n2]):
-+
-+            psi_B = state_index_number(rho.dims[1], n)
-+
-+            m_pt = state_number_index(
-+                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
-+            n_pt = state_number_index(
-+                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
-+
-+            data[m_pt, n_pt] = rho_data.data[n1 + idx]
-+
-+    return Qobj(data.tocsr(), dims=rho.dims)
-+
-+
-+def _partial_transpose_reference(rho, mask):
-+    """
-+    This is a reference implementation that explicitly loops over
-+    all states and performs the transpose. It's slow but easy to
-+    understand and useful for testing.
-+    """
-+
-+    A_pt = np.zeros(rho.shape, dtype=complex)
-+
-+    for psi_A in state_number_enumerate(rho.dims[0]):
-+        m = state_number_index(rho.dims[0], psi_A)
-+
-+        for psi_B in state_number_enumerate(rho.dims[1]):
-+            n = state_number_index(rho.dims[1], psi_B)
-+
-+            m_pt = state_number_index(
-+                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
-+            n_pt = state_number_index(
-+                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
-+
-+            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
-+
-+    return Qobj(A_pt, dims=rho.dims)
-diff --git a/qutip/qip.py b/qutip/qip.py
-index 392b835a..69cfc856 100644
---- a/qutip/qip.py
-+++ b/qutip/qip.py
-@@ -1,13 +1,13 @@
--"""Module replicating the qutip_qip package from within qutip."""
--import sys
--
--try:
--    import qutip_qip
--    del qutip_qip
--    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
--except ImportError:
--    raise ImportError(
--        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
--        "with `pip install qutip-qip` (for more details, go to "
--        "https://qutip-qip.readthedocs.io/)."
--    )
-+"""Module replicating the qutip_qip package from within qutip."""
-+import sys
-+
-+try:
-+    import qutip_qip
-+    del qutip_qip
-+    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
-+except ImportError:
-+    raise ImportError(
-+        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
-+        "with `pip install qutip-qip` (for more details, go to "
-+        "https://qutip-qip.readthedocs.io/)."
-+    )
-diff --git a/qutip/random_objects.py b/qutip/random_objects.py
-index be759ae9..5e8f010b 100644
---- a/qutip/random_objects.py
-+++ b/qutip/random_objects.py
-@@ -1,868 +1,868 @@
--"""
--This module is a collection of random state and operator generators.
--"""
--
--__all__ = [
--    'rand_herm',
--    'rand_unitary',
--    'rand_dm',
--    'rand_stochastic',
--    'rand_ket',
--    'rand_kraus_map',
--    'rand_super',
--    "rand_super_bcsz",
--]
--
--import numbers
--
--import numpy as np
--from numpy.random import Generator, SeedSequence, default_rng
--import scipy.linalg
--import scipy.sparse as sp
--
--from . import (Qobj, create, destroy, jmat, basis,
--               to_super, to_choi, to_chi, to_kraus, to_stinespring)
--from .core import data as _data
--from .core.dimensions import flatten
--from . import settings
--
--
--_RAND = default_rng()
--_UNITS = np.array([1, 1j])
--
--
--def _implicit_tensor_dimensions(dimensions, superoper=False):
--    """
--    Total flattened size and operator dimensions for operator creation routines
--    that automatically perform tensor products.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        First dimension of an operator which can create an implicit tensor
--        product.  If the type is `int`, it is promoted first to `[dimensions]`.
--        From there, it should be one of the two-elements `dims` parameter of a
--        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
--        products.
--
--    Returns
--    -------
--    size : int
--        Dimension of backing matrix required to represent operator.
--    dimensions : list
--        Dimension list in the form required by ``Qobj`` creation.
--    """
--    if not isinstance(dimensions, list):
--        dimensions = [dimensions]
--    flat = flatten(dimensions)
--    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
--        raise ValueError("All dimensions must be integers >= 0")
--    N = np.prod(flat)
--    if superoper:
--        if isinstance(dimensions[0], numbers.Integral):
--            dimensions = [dimensions, dimensions]
--        else:
--            N = int(N**0.5)
--    return N, [dimensions, dimensions]
--
--
--def _get_generator(seed):
--    """
--    Obtain a random generator from a seed or generator.
--
--    Parameters
--    ----------
--    seed: int, SeedSequence, Generator, NoneType
--        Seed to create the generator. If it's already a generator return it.
--        When ``None`` is suplied, a default generator is provided.
--    """
--    if seed is None:
--        gen = _RAND
--    elif isinstance(seed, Generator):
--        gen = seed
--    else:
--        gen = default_rng(seed)
--    return gen
--
--
--def _randnz(shape, generator, norm=np.sqrt(0.5)):
--    """
--    Returns an array of standard normal complex random variates.
--    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
--
--    Parameters
--    ----------
--    shape : tuple
--        Shape of the returned array of random variates.
--
--    generator : Generator
--        Random number generator.
--
--    norm : float
--        Scale of the returned random variates, or 'ginibre' to draw
--        from the Ginibre ensemble.
--    """
--    # This function is intended for internal use.
--    if norm == 'ginibre':
--        norm = 1
--    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
--
--
--def _rand_jacobi_rotation(A, generator):
--    """Random Jacobi rotation of a matrix.
--
--    Parameters
--    ----------
--    A : qutip.data.Data
--        Matrix to rotate as a data layer object.
--
--    generator : numpy.random.generator
--        Random number generator.
--
--    Returns
--    -------
--    qutip.data.Data
--        Rotated sparse matrix.
--    """
--    if A.shape[0] != A.shape[1]:
--        raise ValueError('Input matrix must be square.')
--    n = A.shape[0]
--    angle = 2 * generator.random() * np.pi
--    a = np.sqrt(0.5) * np.exp(-1j * angle)
--    b = np.conj(a)
--    i = generator.integers(n)
--    j = i
--    while i == j:
--        j = generator.integers(n)
--    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
--                      np.ones(n - 2, dtype=complex)))
--    diag = np.delete(np.arange(n), [i, j])
--    rows = np.hstack(([i, i, j, j], diag))
--    cols = np.hstack(([i, j, i, j], diag))
--    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
--    R = _data.create(R.tocsr())
--    return _data.matmul(_data.matmul(R, A), R.adjoint())
--
--
--def _get_block_sizes(N, density, generator):
--    """
--    Obtain a list of matrix block sizes in such a way that an NxN matrix
--    composed of full matrices of these sizes along the diagonal would be of
--    desired density.
--    """
--    if density <= 0:
--        return [1] * N
--    elif density >= 1:
--        return [N]
--    max_block_size = int((N**2 * density)**0.5)
--    min_block_size = 1
--    if density >= 0.5:
--        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
--
--    if min_block_size >= max_block_size:
--        M = min(min_block_size, max_block_size)
--    else:
--        M = generator.integers(min_block_size, max_block_size) + 1
--    M += generator.integers(-1, 2)
--    M = min(max(M, 1), N)
--
--    other_blocks = []
--    if M < N:
--        other_N = N - M
--        other_density = (density * N**2 - M**2) / other_N**2
--        other_blocks = _get_block_sizes(other_N, other_density, generator)
--
--    return [M] + other_blocks
--
--
--def _merge_shuffle_blocks(blocks, generator):
--    """
--    For a list of block, merge them in one matrix along the diagonal and
--    shuffle the rows and columns.
--    """
--    N = sum(block.shape[0] for block in blocks)
--    D = sum(block.shape[0]**2 for block in blocks) / N**2
--    idx = generator.permutation(N)
--    end = 0
--    if D < 0.1:
--        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
--        row = []
--        col = []
--        data = []
--        for block in blocks:
--            start = end
--            end = end + block.shape[0]
--            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
--            row.append(brow.ravel())
--            col.append(bcol.ravel())
--            data.append(block.ravel())
--        data = np.hstack(data)
--        row = np.hstack(row)
--        col = np.hstack(col)
--        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
--    else:
--        matrix = np.zeros((N,N), dtype=complex)
--        for block in blocks:
--            start = end
--            end = end + block.shape[0]
--            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
--            matrix[brow, bcol] = block
--    return _data.create(matrix, copy=False)
--
--
--def rand_herm(dimensions, density=0.30, distribution="fill", *,
--              eigenvalues=(), seed=None, dtype=None):
--    """Creates a random sparse Hermitian quantum object.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    density : float, [0.30]
--        Density between [0,1] of output Hermitian operator.
--
--    distribution : str {"fill", "pos_def", "eigen"}
--        Method used to obtain the density matrices.
--
--        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
--          generated quantum operator with elements uniformly distributed
--          between ``[-1, 1] + [-1j, 1j]``.
--        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
--          random complex Jacobi rotations to shuffle the operator.
--        - "pos_def" : Return a positive semi-definite matrix by diagonal
--          dominance.
--
--    eigenvalues : array_like, optional
--        Eigenvalues of the output Hermitian matrix. The len must match the
--        shape of the matrix.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : :class:`qobj`
--        Hermitian quantum operator.
--
--    Notes
--    -----
--    If given a list of eigenvalues the object is created using complex Jacobi
--    rotations.  While this method is fast for small matrices, it should not be
--    repeatedly used for generating matrices larger than ~1000x1000.
--    """
--    N, dims = _implicit_tensor_dimensions(dimensions)
--    generator = _get_generator(seed)
--    if distribution not in ["eigen", "fill", "pos_def"]:
--        raise ValueError("distribution must be one of {'eigen', 'fill', "
--                         "'pos_def'}")
--
--    if distribution == "eigen":
--        if N != len(eigenvalues):
--            raise ValueError("The number of eigenvalues does not match the "
--                             "desired shape.")
--        out = _data.diag[_data.CSR](eigenvalues, 0)
--        nvals = max([N**2 * density, 1])
--        out = _rand_jacobi_rotation(out, generator)
--        while _data.csr.nnz(out) < 0.95 * nvals:
--            out = _rand_jacobi_rotation(out, generator)
--        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
--        dtype = dtype or settings.core["default_dtype"] or _data.CSR
--
--    else:
--        pos_def = distribution == "pos_def"
--        if density < 0.5:
--            M = _rand_herm_sparse(N, density, pos_def, generator)
--            dtype = dtype or settings.core["default_dtype"] or _data.CSR
--        else:
--            M = _rand_herm_dense(N, density, pos_def, generator)
--            dtype = dtype or settings.core["default_dtype"] or _data.Dense
--
--        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
--
--    return out.to(dtype)
--
--
--def _rand_herm_sparse(N, density, pos_def, generator):
--    target = (1 - (1 - density)**0.5)
--    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
--    num_elems = max([num_elems, 1])
--    num_elems = int(num_elems)
--    data = (2 * generator.random(num_elems) - 1) + \
--           (2 * generator.random(num_elems) - 1) * 1j
--    row_idx, col_idx = zip(*[
--        divmod(index, N)
--        for index in generator.choice(N*N, num_elems, replace=False)
--    ])
--    M = sp.coo_matrix((data, (row_idx, col_idx)),
--                      dtype=complex, shape=(N, N))
--    M = 0.5 * (M + M.conj().transpose())
--    M.sort_indices()
--    rand_mat = _data.create(M)
--    if pos_def:
--        rand_mat = _data.add(
--            rand_mat,
--            _data.diag(np.ones(N, dtype=complex)),
--            np.sqrt(2) * N + 1
--        )
--    return rand_mat
--
--
--def _rand_herm_dense(N, density, pos_def, generator):
--    M = (
--        (2*generator.random((N, N)) - 1)
--        + 1j*(2*generator.random((N, N)) - 1)
--    )
--    M = 0.5 * (M + M.conj().transpose())
--    target = 1 - density**0.5
--    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
--    num_remove = max([num_remove, 1])
--    num_remove = int(num_remove)
--    for index in generator.choice(N*N, num_remove, replace=False):
--        row, col = divmod(index, N)
--        M[col, row] = 0
--        M[row, col] = 0
--    if pos_def:
--        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
--    return _data.create(M)
--
--
--def rand_unitary(dimensions, density=1, distribution="haar", *,
--                 seed=None, dtype=None):
--    r"""Creates a random sparse unitary quantum object.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    density : float, [1]
--        Density between [0,1] of output unitary operator.
--
--    distribution : ["haar", "exp"]
--        Method used to obtain the unitary matrices.
--
--        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
--        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
--          Hermitian operator.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Unitary quantum operator.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    N, dims = _implicit_tensor_dimensions(dimensions)
--    if distribution not in ["haar", "exp"]:
--        raise ValueError("distribution must be one of {'haar', 'exp'}")
--    generator = _get_generator(seed)
--    block_sizes = _get_block_sizes(N, density, generator)
--
--    blocks = []
--    for block in block_sizes:
--        if distribution == "haar":
--            mat = _rand_unitary_haar(block, generator)
--        elif distribution == "exp":
--            mat = scipy.linalg.expm(
--                -1.0j *
--                _rand_herm_dense(block, 1, False, generator).as_ndarray()
--            )
--        blocks.append(mat)
--
--    merged = _merge_shuffle_blocks(blocks, generator)
--
--    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
--    return mat.to(dtype)
--
--
--def _rand_unitary_haar(N, generator):
--    """
--    Returns a Haar random unitary matrix of dimension
--    ``dim``, using the algorithm of [Mez07]_.
--
--    Parameters
--    ----------
--    N : int
--        Dimension of the unitary to be returned.
--
--    generator : numpy.random.generator
--        Random number generator.
--
--    Returns
--    -------
--    U : qutip.core.data.Dense
--        Unitary of shape ``(N, N)`` drawn from the Haar measure.
--    """
--    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
--    #               normal random variates.
--    Z = _randnz((N, N), generator)
--
--    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
--    Q, R = scipy.linalg.qr(Z)
--
--    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
--    #               the diagonal elements of R.
--    Lambda = np.diag(R).copy()
--    Lambda /= np.abs(Lambda)
--
--    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
--    #               strictly positive elements, such that
--    #               Q' = Q · Λ is Haar distributed.
--    # NOTE: Λ is a diagonal matrix, represented as a vector
--    #       of the diagonal entries. Thus, the matrix dot product
--    #       is represented nicely by the NumPy broadcasting of
--    #       the *scalar* multiplication. In particular,
--    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
--    #       As NumPy arrays, Q has shape (N, N) and
--    #       Lambda has shape (N, ), such that the broadcasting
--    #       represents precisely Q_ij λ_j.
--    return Q * Lambda
--
--
--def rand_ket(dimensions, density=1, distribution="haar", *,
--             seed=None, dtype=None):
--    """Creates a random ket vector.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    density : float, [1]
--        Density between [0,1] of output ket state when using the ``fill``
--        method.
--
--    distribution : str {"haar", "fill"}
--        Method used to obtain the kets.
--
--        - haar : Haar random pure state obtained by applying a Haar random
--          unitary to a fixed pure state.
--        - fill : Fill the ket with uniformly distributed random complex number.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Ket quantum state vector.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    generator = _get_generator(seed)
--    N, dims = _implicit_tensor_dimensions(dimensions)
--    if distribution not in ["haar", "fill"]:
--        raise ValueError("distribution must be one of {'haar', 'fill'}")
--
--    if distribution == "haar":
--        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
--    else:
--        X = scipy.sparse.rand(N, 1, density, format='csr',
--                              random_state=generator)
--        while X.nnz == 0:
--            # ensure that the ket is not all zeros.
--            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
--                                  random_state=generator)
--        X.data = X.data - 0.5
--        Y = X.copy()
--        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
--        X = _data.csr.CSR(X + Y)
--        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
--                   copy=False, type="ket", isherm=False, isunitary=False)
--    ket.dims = [dims[0], [1]]
--    return ket.to(dtype)
--
--
--def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
--            eigenvalues=(), rank=None, seed=None,
--            dtype=None):
--    r"""Creates a random density matrix of the desired dimensions.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either ``oper`` or
--        ``super`` depending on the passed ``dimensions``.
--
--    density : float
--        Density between [0,1] of output density matrix. Used by the "pure",
--        "eigen" and "herm".
--
--    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
--        Method used to obtain the density matrices.
--
--        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
--          the algorithm of [BCSZ08]_.
--        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
--          operator.
--        - "pure" : Density matrix created from a random ket.
--        - "eigen" : A density matrix with the given ``eigenvalues``.
--        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
--
--    eigenvalues : array_like, optional
--        Eigenvalues of the output Hermitian matrix. The len must match the
--        shape of the matrix.
--
--    rank : int, optional
--        When using the "ginibre" distribution, rank of the density matrix.
--        Will default to a full rank operator when not provided.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Density matrix quantum operator.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    generator = _get_generator(seed)
--    N, dims = _implicit_tensor_dimensions(dimensions)
--    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
--    if distribution not in distributions:
--        raise ValueError(f"distribution must be one of {distributions}")
--
--    if distribution == "eigen":
--        if len(eigenvalues) != N:
--            raise ValueError("Number of eigenvalues does not match the shape.")
--        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
--            raise ValueError('Eigenvalues of a density matrix '
--                             f'must sum to one, not {np.sum(eigenvalues)}')
--        H = _data.diag(eigenvalues, 0)
--        nvals = N**2 * density
--        H = _rand_jacobi_rotation(H, generator)
--        while _data.csr.nnz(H) < 0.95*nvals:
--            H = _rand_jacobi_rotation(H, generator)
--    elif distribution == "ginibre":
--        H = _rand_dm_ginibre(N, rank, generator)
--    elif distribution == "hs":
--        H = _rand_dm_ginibre(N, N, generator)
--    elif distribution == "pure":
--        dm_density = np.sqrt(density)
--        psi = rand_ket(N, density=dm_density,
--                       distribution="fill", seed=generator)
--        H = psi.proj().data
--    elif distribution == "herm":
--        block_sizes = _get_block_sizes(N, density, generator)
--        blocks = []
--        first = True
--        for block in block_sizes:
--            if block != 1:
--                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
--            else:
--                mat = np.ones((1,1))
--                if not first:
--                    mat *= max(generator.random() - 0.5, 0)
--                first = False
--            blocks.append(mat.T.conj() @ mat)
--        H = _merge_shuffle_blocks(blocks, generator)
--        H /= H.trace()
--
--    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
--
--
--def _rand_dm_ginibre(N, rank, generator):
--    """
--    Returns a Ginibre random density operator of  rank ``rank`` by using the
--    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
--    (Hilbert-Schmidt ensemble) random density operator will be
--    returned.
--
--    Parameters
--    ----------
--    N : int
--        Dimension of the density operator to be returned.
--
--    rank : int or None
--        Rank of the sampled density operator. If None, a full-rank
--        density operator is generated.
--
--    Returns
--    -------
--    rho : Qobj
--        An N × N density operator sampled from the Ginibre
--        or Hilbert-Schmidt distribution.
--    """
--    if not rank:
--        rank = N
--    if rank > N:
--        raise ValueError("Rank cannot exceed dimension.")
--
--    X = _randnz((N, rank), generator, norm='ginibre')
--    rho = np.dot(X, X.T.conj())
--    rho /= np.trace(rho)
--
--    return rho
--
--
--def rand_kraus_map(dimensions, *, seed=None,
--                   dtype=None):
--    """
--    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
--    form.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper_list : list of qobj
--        N^2 x N x N qobj operators.
--
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    N, dims = _implicit_tensor_dimensions(dimensions)
--
--    # Random unitary (Stinespring Dilation)
--    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
--    orthog_cols = np.array(big_unitary[:, :N])
--    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
--    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
--            for x in oper_list]
--
--
--def rand_super(dimensions, *, superrep="super", seed=None,
--               dtype=None):
--    """
--    Returns a randomly drawn superoperator acting on operators acting on
--    N dimensions.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    superrop : str, optional, {"super"}
--        Representation of the super operator
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    generator = _get_generator(seed)
--    from .solver.propagator import propagator
--    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
--    H = rand_herm(N, seed=generator, dtype=dtype)
--    S = propagator(H, generator.random(), [
--        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
--    ])
--    S.dims = dims
--    out = {
--            "choi" : to_choi,
--            "chi" : to_chi,
--            "super": to_super,
--        }[superrep](S).to(dtype)
--    return out
--
--
--def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
--                    superrep="super", seed=None,
--                    dtype=None):
--    """
--    Returns a random superoperator drawn from the Bruzda
--    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
--    finite numerical precision, for ranks less than full-rank,
--    zero eigenvalues may become slightly negative, such that the
--    returned operator is not actually completely positive.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If an int is provided, it is understood as
--        the Square root of the dimension of the superoperator to be returned,
--        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
--        as a list of ints, then the dimensions is understood as the space of
--        density matrices this superoperator is applied to: ``dimensions=[2,2]``
--        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
--
--    enforce_tp : bool
--        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
--        otherwise only complete positivity is enforced.
--
--    rank : int or None
--        Rank of the sampled superoperator. If None, a full-rank
--        superoperator is generated.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    superrop : str, optional, {"super"}
--        representation of the
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    rho : Qobj
--        A superoperator acting on vectorized dim × dim density operators,
--        sampled from the BCSZ distribution.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.CSR
--    generator = _get_generator(seed)
--    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
--
--    if rank is None:
--        rank = N**2
--    if rank > N**2:
--        raise ValueError("Rank cannot exceed superoperator dimension.")
--
--    # We use mainly dense matrices here for speed in low
--    # dimensions. In the future, it would likely be better to switch off
--    # between sparse and dense matrices as the dimension grows.
--
--    # We start with a Ginibre uniform matrix X of the appropriate rank,
--    # and use it to construct a positive semidefinite matrix X X⁺.
--    X = _randnz((N**2, rank), generator, norm='ginibre')
--
--    # Precompute X X⁺, as we'll need it in two different places.
--    XXdag = np.dot(X, X.T.conj())
--    tmp_dims = [[[N], [N]], [[N], [N]]]
--
--    if enforce_tp:
--        # We do the partial trace over the first index by using dense reshape
--        # operations, so that we can avoid bouncing to a sparse representation
--        # and back.
--        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
--
--        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
--        # the square root and the inverse separately. As a possible
--        # improvement, iterative methods exist to find inverse square root
--        # matrices directly, as this is important in statistics.
--        Z = np.kron(
--            np.eye(N),
--            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
--        )
--
--        # Finally, we dot everything together and pack it into a Qobj,
--        # marking the dimensions as that of a type=super (that is,
--        # with left and right compound indices, each representing
--        # left and right indices on the underlying Hilbert space).
--        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
--    else:
--        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
--
--    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
--    # expects a column-stacking Choi matrix, we must permute the indices.
--    D = D.permute([[1], [0]])
--
--    # Mark that we've made a Choi matrix.
--    D.superrep = 'choi'
--    D.dims = dims
--    out = {
--            "choi" : to_choi,
--            "chi" : to_chi,
--            "super": to_super,
--        }[superrep](D).to(dtype)
--    return out
--
--
--def rand_stochastic(dimensions, density=0.75, kind='left',
--                    *, seed=None, dtype=None):
--    """Generates a random stochastic matrix.
--
--    Parameters
--    ----------
--    dimensions : (int) or (list of int) or (list of list of int)
--        Dimension of Hilbert space. If provided as a list of ints, then the
--        dimension is the product over this list, but the ``dims`` property of
--        the new Qobj are set to this list.  This can produce either `oper` or
--        `super` depending on the passed `dimensions`.
--
--    density : float, [0.75]
--        Density between [0,1] of output density matrix.
--
--    kind : str (Default = 'left')
--        Generate 'left' or 'right' stochastic matrix.
--
--    seed : int, SeedSequence, Generator, optional
--        Seed to create the random number generator or a pre prepared
--        generator. When none is suplied, a default generator is used.
--
--    dtype : type or str
--        Storage representation. Any data-layer known to `qutip.data.to` is
--        accepted.
--
--    Returns
--    -------
--    oper : qobj
--        Quantum operator form of stochastic matrix.
--    """
--    dtype = dtype or settings.core["default_dtype"] or _data.Dense
--    generator = _get_generator(seed)
--    N, dims = _implicit_tensor_dimensions(dimensions)
--    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
--    data = generator.random(num_elems)
--    # Ensure an element on every row and column
--    row_idx = np.hstack([generator.permutation(N),
--                         generator.choice(N, num_elems-N)])
--    col_idx = np.hstack([generator.permutation(N),
--                         generator.choice(N, num_elems-N)])
--    M = sp.coo_matrix((data, (row_idx, col_idx)),
--                      dtype=np.complex128, shape=(N, N)).tocsr()
--    M = 0.5 * (M + M.conj().transpose())
--    num_rows = M.indptr.shape[0] - 1
--    for row in range(num_rows):
--        row_start = M.indptr[row]
--        row_end = M.indptr[row+1]
--        row_sum = np.sum(M.data[row_start:row_end])
--        M.data[row_start:row_end] /= row_sum
--    if kind == 'left':
--        M = M.transpose()
--    return Qobj(M, dims=dims).to(dtype)
-+"""
-+This module is a collection of random state and operator generators.
-+"""
-+
-+__all__ = [
-+    'rand_herm',
-+    'rand_unitary',
-+    'rand_dm',
-+    'rand_stochastic',
-+    'rand_ket',
-+    'rand_kraus_map',
-+    'rand_super',
-+    "rand_super_bcsz",
-+]
-+
-+import numbers
-+
-+import numpy as np
-+from numpy.random import Generator, SeedSequence, default_rng
-+import scipy.linalg
-+import scipy.sparse as sp
-+
-+from . import (Qobj, create, destroy, jmat, basis,
-+               to_super, to_choi, to_chi, to_kraus, to_stinespring)
-+from .core import data as _data
-+from .core.dimensions import flatten
-+from . import settings
-+
-+
-+_RAND = default_rng()
-+_UNITS = np.array([1, 1j])
-+
-+
-+def _implicit_tensor_dimensions(dimensions, superoper=False):
-+    """
-+    Total flattened size and operator dimensions for operator creation routines
-+    that automatically perform tensor products.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        First dimension of an operator which can create an implicit tensor
-+        product.  If the type is `int`, it is promoted first to `[dimensions]`.
-+        From there, it should be one of the two-elements `dims` parameter of a
-+        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
-+        products.
-+
-+    Returns
-+    -------
-+    size : int
-+        Dimension of backing matrix required to represent operator.
-+    dimensions : list
-+        Dimension list in the form required by ``Qobj`` creation.
-+    """
-+    if not isinstance(dimensions, list):
-+        dimensions = [dimensions]
-+    flat = flatten(dimensions)
-+    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
-+        raise ValueError("All dimensions must be integers >= 0")
-+    N = np.prod(flat)
-+    if superoper:
-+        if isinstance(dimensions[0], numbers.Integral):
-+            dimensions = [dimensions, dimensions]
-+        else:
-+            N = int(N**0.5)
-+    return N, [dimensions, dimensions]
-+
-+
-+def _get_generator(seed):
-+    """
-+    Obtain a random generator from a seed or generator.
-+
-+    Parameters
-+    ----------
-+    seed: int, SeedSequence, Generator, NoneType
-+        Seed to create the generator. If it's already a generator return it.
-+        When ``None`` is suplied, a default generator is provided.
-+    """
-+    if seed is None:
-+        gen = _RAND
-+    elif isinstance(seed, Generator):
-+        gen = seed
-+    else:
-+        gen = default_rng(seed)
-+    return gen
-+
-+
-+def _randnz(shape, generator, norm=np.sqrt(0.5)):
-+    """
-+    Returns an array of standard normal complex random variates.
-+    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
-+
-+    Parameters
-+    ----------
-+    shape : tuple
-+        Shape of the returned array of random variates.
-+
-+    generator : Generator
-+        Random number generator.
-+
-+    norm : float
-+        Scale of the returned random variates, or 'ginibre' to draw
-+        from the Ginibre ensemble.
-+    """
-+    # This function is intended for internal use.
-+    if norm == 'ginibre':
-+        norm = 1
-+    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
-+
-+
-+def _rand_jacobi_rotation(A, generator):
-+    """Random Jacobi rotation of a matrix.
-+
-+    Parameters
-+    ----------
-+    A : qutip.data.Data
-+        Matrix to rotate as a data layer object.
-+
-+    generator : numpy.random.generator
-+        Random number generator.
-+
-+    Returns
-+    -------
-+    qutip.data.Data
-+        Rotated sparse matrix.
-+    """
-+    if A.shape[0] != A.shape[1]:
-+        raise ValueError('Input matrix must be square.')
-+    n = A.shape[0]
-+    angle = 2 * generator.random() * np.pi
-+    a = np.sqrt(0.5) * np.exp(-1j * angle)
-+    b = np.conj(a)
-+    i = generator.integers(n)
-+    j = i
-+    while i == j:
-+        j = generator.integers(n)
-+    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
-+                      np.ones(n - 2, dtype=complex)))
-+    diag = np.delete(np.arange(n), [i, j])
-+    rows = np.hstack(([i, i, j, j], diag))
-+    cols = np.hstack(([i, j, i, j], diag))
-+    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
-+    R = _data.create(R.tocsr())
-+    return _data.matmul(_data.matmul(R, A), R.adjoint())
-+
-+
-+def _get_block_sizes(N, density, generator):
-+    """
-+    Obtain a list of matrix block sizes in such a way that an NxN matrix
-+    composed of full matrices of these sizes along the diagonal would be of
-+    desired density.
-+    """
-+    if density <= 0:
-+        return [1] * N
-+    elif density >= 1:
-+        return [N]
-+    max_block_size = int((N**2 * density)**0.5)
-+    min_block_size = 1
-+    if density >= 0.5:
-+        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
-+
-+    if min_block_size >= max_block_size:
-+        M = min(min_block_size, max_block_size)
-+    else:
-+        M = generator.integers(min_block_size, max_block_size) + 1
-+    M += generator.integers(-1, 2)
-+    M = min(max(M, 1), N)
-+
-+    other_blocks = []
-+    if M < N:
-+        other_N = N - M
-+        other_density = (density * N**2 - M**2) / other_N**2
-+        other_blocks = _get_block_sizes(other_N, other_density, generator)
-+
-+    return [M] + other_blocks
-+
-+
-+def _merge_shuffle_blocks(blocks, generator):
-+    """
-+    For a list of block, merge them in one matrix along the diagonal and
-+    shuffle the rows and columns.
-+    """
-+    N = sum(block.shape[0] for block in blocks)
-+    D = sum(block.shape[0]**2 for block in blocks) / N**2
-+    idx = generator.permutation(N)
-+    end = 0
-+    if D < 0.1:
-+        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
-+        row = []
-+        col = []
-+        data = []
-+        for block in blocks:
-+            start = end
-+            end = end + block.shape[0]
-+            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
-+            row.append(brow.ravel())
-+            col.append(bcol.ravel())
-+            data.append(block.ravel())
-+        data = np.hstack(data)
-+        row = np.hstack(row)
-+        col = np.hstack(col)
-+        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
-+    else:
-+        matrix = np.zeros((N,N), dtype=complex)
-+        for block in blocks:
-+            start = end
-+            end = end + block.shape[0]
-+            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
-+            matrix[brow, bcol] = block
-+    return _data.create(matrix, copy=False)
-+
-+
-+def rand_herm(dimensions, density=0.30, distribution="fill", *,
-+              eigenvalues=(), seed=None, dtype=None):
-+    """Creates a random sparse Hermitian quantum object.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    density : float, [0.30]
-+        Density between [0,1] of output Hermitian operator.
-+
-+    distribution : str {"fill", "pos_def", "eigen"}
-+        Method used to obtain the density matrices.
-+
-+        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
-+          generated quantum operator with elements uniformly distributed
-+          between ``[-1, 1] + [-1j, 1j]``.
-+        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
-+          random complex Jacobi rotations to shuffle the operator.
-+        - "pos_def" : Return a positive semi-definite matrix by diagonal
-+          dominance.
-+
-+    eigenvalues : array_like, optional
-+        Eigenvalues of the output Hermitian matrix. The len must match the
-+        shape of the matrix.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : :class:`qobj`
-+        Hermitian quantum operator.
-+
-+    Notes
-+    -----
-+    If given a list of eigenvalues the object is created using complex Jacobi
-+    rotations.  While this method is fast for small matrices, it should not be
-+    repeatedly used for generating matrices larger than ~1000x1000.
-+    """
-+    N, dims = _implicit_tensor_dimensions(dimensions)
-+    generator = _get_generator(seed)
-+    if distribution not in ["eigen", "fill", "pos_def"]:
-+        raise ValueError("distribution must be one of {'eigen', 'fill', "
-+                         "'pos_def'}")
-+
-+    if distribution == "eigen":
-+        if N != len(eigenvalues):
-+            raise ValueError("The number of eigenvalues does not match the "
-+                             "desired shape.")
-+        out = _data.diag[_data.CSR](eigenvalues, 0)
-+        nvals = max([N**2 * density, 1])
-+        out = _rand_jacobi_rotation(out, generator)
-+        while _data.csr.nnz(out) < 0.95 * nvals:
-+            out = _rand_jacobi_rotation(out, generator)
-+        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
-+        dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+
-+    else:
-+        pos_def = distribution == "pos_def"
-+        if density < 0.5:
-+            M = _rand_herm_sparse(N, density, pos_def, generator)
-+            dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+        else:
-+            M = _rand_herm_dense(N, density, pos_def, generator)
-+            dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+
-+        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
-+
-+    return out.to(dtype)
-+
-+
-+def _rand_herm_sparse(N, density, pos_def, generator):
-+    target = (1 - (1 - density)**0.5)
-+    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
-+    num_elems = max([num_elems, 1])
-+    num_elems = int(num_elems)
-+    data = (2 * generator.random(num_elems) - 1) + \
-+           (2 * generator.random(num_elems) - 1) * 1j
-+    row_idx, col_idx = zip(*[
-+        divmod(index, N)
-+        for index in generator.choice(N*N, num_elems, replace=False)
-+    ])
-+    M = sp.coo_matrix((data, (row_idx, col_idx)),
-+                      dtype=complex, shape=(N, N))
-+    M = 0.5 * (M + M.conj().transpose())
-+    M.sort_indices()
-+    rand_mat = _data.create(M)
-+    if pos_def:
-+        rand_mat = _data.add(
-+            rand_mat,
-+            _data.diag(np.ones(N, dtype=complex)),
-+            np.sqrt(2) * N + 1
-+        )
-+    return rand_mat
-+
-+
-+def _rand_herm_dense(N, density, pos_def, generator):
-+    M = (
-+        (2*generator.random((N, N)) - 1)
-+        + 1j*(2*generator.random((N, N)) - 1)
-+    )
-+    M = 0.5 * (M + M.conj().transpose())
-+    target = 1 - density**0.5
-+    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
-+    num_remove = max([num_remove, 1])
-+    num_remove = int(num_remove)
-+    for index in generator.choice(N*N, num_remove, replace=False):
-+        row, col = divmod(index, N)
-+        M[col, row] = 0
-+        M[row, col] = 0
-+    if pos_def:
-+        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
-+    return _data.create(M)
-+
-+
-+def rand_unitary(dimensions, density=1, distribution="haar", *,
-+                 seed=None, dtype=None):
-+    r"""Creates a random sparse unitary quantum object.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    density : float, [1]
-+        Density between [0,1] of output unitary operator.
-+
-+    distribution : ["haar", "exp"]
-+        Method used to obtain the unitary matrices.
-+
-+        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
-+        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
-+          Hermitian operator.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Unitary quantum operator.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    N, dims = _implicit_tensor_dimensions(dimensions)
-+    if distribution not in ["haar", "exp"]:
-+        raise ValueError("distribution must be one of {'haar', 'exp'}")
-+    generator = _get_generator(seed)
-+    block_sizes = _get_block_sizes(N, density, generator)
-+
-+    blocks = []
-+    for block in block_sizes:
-+        if distribution == "haar":
-+            mat = _rand_unitary_haar(block, generator)
-+        elif distribution == "exp":
-+            mat = scipy.linalg.expm(
-+                -1.0j *
-+                _rand_herm_dense(block, 1, False, generator).as_ndarray()
-+            )
-+        blocks.append(mat)
-+
-+    merged = _merge_shuffle_blocks(blocks, generator)
-+
-+    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
-+    return mat.to(dtype)
-+
-+
-+def _rand_unitary_haar(N, generator):
-+    """
-+    Returns a Haar random unitary matrix of dimension
-+    ``dim``, using the algorithm of [Mez07]_.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Dimension of the unitary to be returned.
-+
-+    generator : numpy.random.generator
-+        Random number generator.
-+
-+    Returns
-+    -------
-+    U : qutip.core.data.Dense
-+        Unitary of shape ``(N, N)`` drawn from the Haar measure.
-+    """
-+    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
-+    #               normal random variates.
-+    Z = _randnz((N, N), generator)
-+
-+    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
-+    Q, R = scipy.linalg.qr(Z)
-+
-+    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
-+    #               the diagonal elements of R.
-+    Lambda = np.diag(R).copy()
-+    Lambda /= np.abs(Lambda)
-+
-+    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
-+    #               strictly positive elements, such that
-+    #               Q' = Q · Λ is Haar distributed.
-+    # NOTE: Λ is a diagonal matrix, represented as a vector
-+    #       of the diagonal entries. Thus, the matrix dot product
-+    #       is represented nicely by the NumPy broadcasting of
-+    #       the *scalar* multiplication. In particular,
-+    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
-+    #       As NumPy arrays, Q has shape (N, N) and
-+    #       Lambda has shape (N, ), such that the broadcasting
-+    #       represents precisely Q_ij λ_j.
-+    return Q * Lambda
-+
-+
-+def rand_ket(dimensions, density=1, distribution="haar", *,
-+             seed=None, dtype=None):
-+    """Creates a random ket vector.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    density : float, [1]
-+        Density between [0,1] of output ket state when using the ``fill``
-+        method.
-+
-+    distribution : str {"haar", "fill"}
-+        Method used to obtain the kets.
-+
-+        - haar : Haar random pure state obtained by applying a Haar random
-+          unitary to a fixed pure state.
-+        - fill : Fill the ket with uniformly distributed random complex number.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Ket quantum state vector.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    generator = _get_generator(seed)
-+    N, dims = _implicit_tensor_dimensions(dimensions)
-+    if distribution not in ["haar", "fill"]:
-+        raise ValueError("distribution must be one of {'haar', 'fill'}")
-+
-+    if distribution == "haar":
-+        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
-+    else:
-+        X = scipy.sparse.rand(N, 1, density, format='csr',
-+                              random_state=generator)
-+        while X.nnz == 0:
-+            # ensure that the ket is not all zeros.
-+            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
-+                                  random_state=generator)
-+        X.data = X.data - 0.5
-+        Y = X.copy()
-+        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
-+        X = _data.csr.CSR(X + Y)
-+        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
-+                   copy=False, type="ket", isherm=False, isunitary=False)
-+    ket.dims = [dims[0], [1]]
-+    return ket.to(dtype)
-+
-+
-+def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
-+            eigenvalues=(), rank=None, seed=None,
-+            dtype=None):
-+    r"""Creates a random density matrix of the desired dimensions.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either ``oper`` or
-+        ``super`` depending on the passed ``dimensions``.
-+
-+    density : float
-+        Density between [0,1] of output density matrix. Used by the "pure",
-+        "eigen" and "herm".
-+
-+    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
-+        Method used to obtain the density matrices.
-+
-+        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
-+          the algorithm of [BCSZ08]_.
-+        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
-+          operator.
-+        - "pure" : Density matrix created from a random ket.
-+        - "eigen" : A density matrix with the given ``eigenvalues``.
-+        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
-+
-+    eigenvalues : array_like, optional
-+        Eigenvalues of the output Hermitian matrix. The len must match the
-+        shape of the matrix.
-+
-+    rank : int, optional
-+        When using the "ginibre" distribution, rank of the density matrix.
-+        Will default to a full rank operator when not provided.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Density matrix quantum operator.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    generator = _get_generator(seed)
-+    N, dims = _implicit_tensor_dimensions(dimensions)
-+    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
-+    if distribution not in distributions:
-+        raise ValueError(f"distribution must be one of {distributions}")
-+
-+    if distribution == "eigen":
-+        if len(eigenvalues) != N:
-+            raise ValueError("Number of eigenvalues does not match the shape.")
-+        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
-+            raise ValueError('Eigenvalues of a density matrix '
-+                             f'must sum to one, not {np.sum(eigenvalues)}')
-+        H = _data.diag(eigenvalues, 0)
-+        nvals = N**2 * density
-+        H = _rand_jacobi_rotation(H, generator)
-+        while _data.csr.nnz(H) < 0.95*nvals:
-+            H = _rand_jacobi_rotation(H, generator)
-+    elif distribution == "ginibre":
-+        H = _rand_dm_ginibre(N, rank, generator)
-+    elif distribution == "hs":
-+        H = _rand_dm_ginibre(N, N, generator)
-+    elif distribution == "pure":
-+        dm_density = np.sqrt(density)
-+        psi = rand_ket(N, density=dm_density,
-+                       distribution="fill", seed=generator)
-+        H = psi.proj().data
-+    elif distribution == "herm":
-+        block_sizes = _get_block_sizes(N, density, generator)
-+        blocks = []
-+        first = True
-+        for block in block_sizes:
-+            if block != 1:
-+                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
-+            else:
-+                mat = np.ones((1,1))
-+                if not first:
-+                    mat *= max(generator.random() - 0.5, 0)
-+                first = False
-+            blocks.append(mat.T.conj() @ mat)
-+        H = _merge_shuffle_blocks(blocks, generator)
-+        H /= H.trace()
-+
-+    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
-+
-+
-+def _rand_dm_ginibre(N, rank, generator):
-+    """
-+    Returns a Ginibre random density operator of  rank ``rank`` by using the
-+    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
-+    (Hilbert-Schmidt ensemble) random density operator will be
-+    returned.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Dimension of the density operator to be returned.
-+
-+    rank : int or None
-+        Rank of the sampled density operator. If None, a full-rank
-+        density operator is generated.
-+
-+    Returns
-+    -------
-+    rho : Qobj
-+        An N × N density operator sampled from the Ginibre
-+        or Hilbert-Schmidt distribution.
-+    """
-+    if not rank:
-+        rank = N
-+    if rank > N:
-+        raise ValueError("Rank cannot exceed dimension.")
-+
-+    X = _randnz((N, rank), generator, norm='ginibre')
-+    rho = np.dot(X, X.T.conj())
-+    rho /= np.trace(rho)
-+
-+    return rho
-+
-+
-+def rand_kraus_map(dimensions, *, seed=None,
-+                   dtype=None):
-+    """
-+    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
-+    form.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper_list : list of qobj
-+        N^2 x N x N qobj operators.
-+
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    N, dims = _implicit_tensor_dimensions(dimensions)
-+
-+    # Random unitary (Stinespring Dilation)
-+    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
-+    orthog_cols = np.array(big_unitary[:, :N])
-+    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
-+    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
-+            for x in oper_list]
-+
-+
-+def rand_super(dimensions, *, superrep="super", seed=None,
-+               dtype=None):
-+    """
-+    Returns a randomly drawn superoperator acting on operators acting on
-+    N dimensions.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    superrop : str, optional, {"super"}
-+        Representation of the super operator
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    generator = _get_generator(seed)
-+    from .solver.propagator import propagator
-+    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
-+    H = rand_herm(N, seed=generator, dtype=dtype)
-+    S = propagator(H, generator.random(), [
-+        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
-+    ])
-+    S.dims = dims
-+    out = {
-+            "choi" : to_choi,
-+            "chi" : to_chi,
-+            "super": to_super,
-+        }[superrep](S).to(dtype)
-+    return out
-+
-+
-+def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
-+                    superrep="super", seed=None,
-+                    dtype=None):
-+    """
-+    Returns a random superoperator drawn from the Bruzda
-+    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
-+    finite numerical precision, for ranks less than full-rank,
-+    zero eigenvalues may become slightly negative, such that the
-+    returned operator is not actually completely positive.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If an int is provided, it is understood as
-+        the Square root of the dimension of the superoperator to be returned,
-+        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
-+        as a list of ints, then the dimensions is understood as the space of
-+        density matrices this superoperator is applied to: ``dimensions=[2,2]``
-+        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
-+
-+    enforce_tp : bool
-+        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
-+        otherwise only complete positivity is enforced.
-+
-+    rank : int or None
-+        Rank of the sampled superoperator. If None, a full-rank
-+        superoperator is generated.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    superrop : str, optional, {"super"}
-+        representation of the
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    rho : Qobj
-+        A superoperator acting on vectorized dim × dim density operators,
-+        sampled from the BCSZ distribution.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-+    generator = _get_generator(seed)
-+    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
-+
-+    if rank is None:
-+        rank = N**2
-+    if rank > N**2:
-+        raise ValueError("Rank cannot exceed superoperator dimension.")
-+
-+    # We use mainly dense matrices here for speed in low
-+    # dimensions. In the future, it would likely be better to switch off
-+    # between sparse and dense matrices as the dimension grows.
-+
-+    # We start with a Ginibre uniform matrix X of the appropriate rank,
-+    # and use it to construct a positive semidefinite matrix X X⁺.
-+    X = _randnz((N**2, rank), generator, norm='ginibre')
-+
-+    # Precompute X X⁺, as we'll need it in two different places.
-+    XXdag = np.dot(X, X.T.conj())
-+    tmp_dims = [[[N], [N]], [[N], [N]]]
-+
-+    if enforce_tp:
-+        # We do the partial trace over the first index by using dense reshape
-+        # operations, so that we can avoid bouncing to a sparse representation
-+        # and back.
-+        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
-+
-+        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
-+        # the square root and the inverse separately. As a possible
-+        # improvement, iterative methods exist to find inverse square root
-+        # matrices directly, as this is important in statistics.
-+        Z = np.kron(
-+            np.eye(N),
-+            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
-+        )
-+
-+        # Finally, we dot everything together and pack it into a Qobj,
-+        # marking the dimensions as that of a type=super (that is,
-+        # with left and right compound indices, each representing
-+        # left and right indices on the underlying Hilbert space).
-+        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
-+    else:
-+        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
-+
-+    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
-+    # expects a column-stacking Choi matrix, we must permute the indices.
-+    D = D.permute([[1], [0]])
-+
-+    # Mark that we've made a Choi matrix.
-+    D.superrep = 'choi'
-+    D.dims = dims
-+    out = {
-+            "choi" : to_choi,
-+            "chi" : to_chi,
-+            "super": to_super,
-+        }[superrep](D).to(dtype)
-+    return out
-+
-+
-+def rand_stochastic(dimensions, density=0.75, kind='left',
-+                    *, seed=None, dtype=None):
-+    """Generates a random stochastic matrix.
-+
-+    Parameters
-+    ----------
-+    dimensions : (int) or (list of int) or (list of list of int)
-+        Dimension of Hilbert space. If provided as a list of ints, then the
-+        dimension is the product over this list, but the ``dims`` property of
-+        the new Qobj are set to this list.  This can produce either `oper` or
-+        `super` depending on the passed `dimensions`.
-+
-+    density : float, [0.75]
-+        Density between [0,1] of output density matrix.
-+
-+    kind : str (Default = 'left')
-+        Generate 'left' or 'right' stochastic matrix.
-+
-+    seed : int, SeedSequence, Generator, optional
-+        Seed to create the random number generator or a pre prepared
-+        generator. When none is suplied, a default generator is used.
-+
-+    dtype : type or str
-+        Storage representation. Any data-layer known to `qutip.data.to` is
-+        accepted.
-+
-+    Returns
-+    -------
-+    oper : qobj
-+        Quantum operator form of stochastic matrix.
-+    """
-+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-+    generator = _get_generator(seed)
-+    N, dims = _implicit_tensor_dimensions(dimensions)
-+    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
-+    data = generator.random(num_elems)
-+    # Ensure an element on every row and column
-+    row_idx = np.hstack([generator.permutation(N),
-+                         generator.choice(N, num_elems-N)])
-+    col_idx = np.hstack([generator.permutation(N),
-+                         generator.choice(N, num_elems-N)])
-+    M = sp.coo_matrix((data, (row_idx, col_idx)),
-+                      dtype=np.complex128, shape=(N, N)).tocsr()
-+    M = 0.5 * (M + M.conj().transpose())
-+    num_rows = M.indptr.shape[0] - 1
-+    for row in range(num_rows):
-+        row_start = M.indptr[row]
-+        row_end = M.indptr[row+1]
-+        row_sum = np.sum(M.data[row_start:row_end])
-+        M.data[row_start:row_end] /= row_sum
-+    if kind == 'left':
-+        M = M.transpose()
-+    return Qobj(M, dims=dims).to(dtype)
-diff --git a/qutip/settings.py b/qutip/settings.py
-index 29ee053b..ccf30371 100644
---- a/qutip/settings.py
-+++ b/qutip/settings.py
-@@ -1,293 +1,293 @@
--"""
--This module contains settings for the QuTiP graphics, multiprocessing, and
--tidyup functionality, etc.
--"""
--import os
--import sys
--from ctypes import cdll
--import platform
--import numpy as np
--
--__all__ = ['settings']
--
--
--def _blas_info():
--    config = np.__config__
--    if hasattr(config, 'blas_ilp64_opt_info'):
--        blas_info = config.blas_ilp64_opt_info
--    elif hasattr(config, 'blas_opt_info'):
--        blas_info = config.blas_opt_info
--    else:
--        blas_info = {}
--
--    def _in_libaries(name):
--        return any(name in lib for lib in blas_info.get('libraries', []))
--
--    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
--        blas = 'INTEL MKL'
--    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
--        blas = 'OPENBLAS'
--    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
--        blas = 'Accelerate'
--    else:
--        blas = 'Generic'
--    return blas
--
--
--def available_cpu_count():
--    """
--    Get the number of cpus.
--    It tries to only get the number available to qutip.
--    """
--    import os
--    import multiprocessing
--    try:
--        import psutil
--    except ImportError:
--        psutil = None
--    num_cpu = 0
--
--    if 'QUTIP_NUM_PROCESSES' in os.environ:
--        # We consider QUTIP_NUM_PROCESSES=0 as unset.
--        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
--
--    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
--        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
--
--    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
--        num_cpu = len(os.sched_getaffinity(0))
--
--    if (
--        num_cpu == 0
--        and psutil is not None
--        and hasattr(psutil.Process(), "cpu_affinity")
--    ):
--        num_cpu = len(psutil.Process().cpu_affinity())
--
--    if num_cpu == 0:
--        try:
--            num_cpu = multiprocessing.cpu_count()
--        except NotImplementedError:
--            pass
--
--    return num_cpu or 1
--
--
--def _find_mkl():
--    """
--    Finds the MKL runtime library for the Anaconda and Intel Python
--    distributions.
--    """
--    mkl_lib = None
--    if _blas_info() == 'INTEL MKL':
--        plat = sys.platform
--        python_dir = os.path.dirname(sys.executable)
--        if plat in ['darwin', 'linux2', 'linux']:
--            python_dir = os.path.dirname(python_dir)
--
--        if plat == 'darwin':
--            lib = '/libmkl_rt.dylib'
--        elif plat == 'win32':
--            lib = r'\mkl_rt.dll'
--        elif plat in ['linux2', 'linux']:
--            lib = '/libmkl_rt.so'
--        else:
--            raise Exception('Unknown platfrom.')
--
--        if plat in ['darwin', 'linux2', 'linux']:
--            lib_dir = '/lib'
--        else:
--            lib_dir = r'\Library\bin'
--        # Try in default Anaconda location first
--        try:
--            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
--        except Exception:
--            pass
--
--        # Look in Intel Python distro location
--        if mkl_lib is None:
--            if plat in ['darwin', 'linux2', 'linux']:
--                lib_dir = '/ext/lib'
--            else:
--                lib_dir = r'\ext\lib'
--            try:
--                mkl_lib = \
--                    cdll.LoadLibrary(python_dir + lib_dir + lib)
--            except Exception:
--                pass
--    return mkl_lib
--
--
--class Settings:
--    """
--    Qutip's settings and options.
--    """
--    def __init__(self):
--        self._mkl_lib = ""
--        try:
--            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
--        except OSError:
--            self._tmproot = "."
--        self.core = None  # set in qutip.core.options
--        self.compile = None  # set in qutip.core.coefficient
--        self._debug = False
--        self._log_handler = "default"
--        self._colorblind_safe = False
--
--    @property
--    def has_mkl(self):
--        """ Whether qutip found an mkl installation. """
--        return self.mkl_lib is not None
--
--    @property
--    def mkl_lib(self):
--        """ Location of the mkl installation. """
--        if self._mkl_lib == "":
--            self._mkl_lib = _find_mkl()
--        return _find_mkl()
--
--    @property
--    def ipython(self):
--        """ Whether qutip is running in ipython. """
--        try:
--            __IPYTHON__
--            return True
--        except NameError:
--            return False
--
--    @property
--    def eigh_unsafe(self):
--        """
--        Whether `eigh` call is reliable.
--        Some implementation of blas have some issues on some OS.
--        """
--        from packaging import version as pac_version
--        import scipy
--        is_old_scipy = (
--            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
--        )
--        return (
--            # macOS OpenBLAS eigh is unstable, see #1288
--            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
--            # The combination of scipy<1.5 and MKL causes wrong results when
--            # calling eigh for big matrices.  See #1495, #1491 and #1498.
--            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
--        )
--
--    @property
--    def tmproot(self):
--        """
--        Location in which qutip place cython string coefficient folders.
--        The default is "$HOME/.qutip".
--        Can be updated.
--        """
--        return self._tmproot
--
--    @tmproot.setter
--    def tmproot(self, root):
--        if not os.path.exists(root):
--            os.mkdir(root)
--        self._tmproot = root
--
--    @property
--    def coeffroot(self):
--        """
--        Location in which qutip save cython string coefficient files.
--        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
--        Can be updated.
--        """
--        return self._coeffroot
--
--    @coeffroot.setter
--    def coeffroot(self, root):
--        if not os.path.exists(root):
--            os.mkdir(root)
--        if root not in sys.path:
--            sys.path.insert(0, root)
--        self._coeffroot = root
--
--    @property
--    def coeff_write_ok(self):
--        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
--        return os.access(self.coeffroot, os.W_OK)
--
--    @property
--    def has_openmp(self):
--        return False
--        # We keep this as a reminder for when openmp is restored: see Pull #652
--        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
--
--    @property
--    def idxint_size(self):
--        """
--        Integer type used by ``CSR`` data.
--        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
--        non-zeros elements.
--        """
--        from .core import data
--        return data.base.idxint_size
--
--    @property
--    def num_cpus(self):
--        """
--        Number of cpu detected.
--        Use the solver options to control the number of cpus used.
--        """
--        if 'QUTIP_NUM_PROCESSES' in os.environ:
--            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
--        else:
--            num_cpus = available_cpu_count()
--            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
--        return num_cpus
--
--    @property
--    def debug(self):
--        """
--        Debug mode for development.
--        """
--        return self._debug
--
--    @debug.setter
--    def debug(self, value):
--        self._debug = value
--
--    @property
--    def log_handler(self):
--        """
--        Define whether log handler should be:
--        - default: switch based on IPython detection
--        - stream: set up non-propagating StreamHandler
--        - basic: call basicConfig
--        - null: leave logging to the user
--        """
--        return self._log_handler
--
--    @log_handler.setter
--    def log_handler(self, value):
--        self._log_handler = value
--
--    @property
--    def colorblind_safe(self):
--        """
--        Allow for a colorblind mode that uses different colormaps
--        and plotting options by default.
--        """
--        return self._colorblind_safe
--
--    @colorblind_safe.setter
--    def colorblind_safe(self, value):
--        self._colorblind_safe = value
--
--    def __str__(self):
--        lines = ["Qutip settings:"]
--        for attr in self.__dir__():
--            if not attr.startswith('_') and attr not in ["core", "compile"]:
--                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
--        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
--        return '\n'.join(lines)
--
--    def __repr__(self):
--        return self.__str__()
--
--
--settings = Settings()
-+"""
-+This module contains settings for the QuTiP graphics, multiprocessing, and
-+tidyup functionality, etc.
-+"""
-+import os
-+import sys
-+from ctypes import cdll
-+import platform
-+import numpy as np
-+
-+__all__ = ['settings']
-+
-+
-+def _blas_info():
-+    config = np.__config__
-+    if hasattr(config, 'blas_ilp64_opt_info'):
-+        blas_info = config.blas_ilp64_opt_info
-+    elif hasattr(config, 'blas_opt_info'):
-+        blas_info = config.blas_opt_info
-+    else:
-+        blas_info = {}
-+
-+    def _in_libaries(name):
-+        return any(name in lib for lib in blas_info.get('libraries', []))
-+
-+    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
-+        blas = 'INTEL MKL'
-+    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
-+        blas = 'OPENBLAS'
-+    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
-+        blas = 'Accelerate'
-+    else:
-+        blas = 'Generic'
-+    return blas
-+
-+
-+def available_cpu_count():
-+    """
-+    Get the number of cpus.
-+    It tries to only get the number available to qutip.
-+    """
-+    import os
-+    import multiprocessing
-+    try:
-+        import psutil
-+    except ImportError:
-+        psutil = None
-+    num_cpu = 0
-+
-+    if 'QUTIP_NUM_PROCESSES' in os.environ:
-+        # We consider QUTIP_NUM_PROCESSES=0 as unset.
-+        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
-+
-+    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
-+        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
-+
-+    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
-+        num_cpu = len(os.sched_getaffinity(0))
-+
-+    if (
-+        num_cpu == 0
-+        and psutil is not None
-+        and hasattr(psutil.Process(), "cpu_affinity")
-+    ):
-+        num_cpu = len(psutil.Process().cpu_affinity())
-+
-+    if num_cpu == 0:
-+        try:
-+            num_cpu = multiprocessing.cpu_count()
-+        except NotImplementedError:
-+            pass
-+
-+    return num_cpu or 1
-+
-+
-+def _find_mkl():
-+    """
-+    Finds the MKL runtime library for the Anaconda and Intel Python
-+    distributions.
-+    """
-+    mkl_lib = None
-+    if _blas_info() == 'INTEL MKL':
-+        plat = sys.platform
-+        python_dir = os.path.dirname(sys.executable)
-+        if plat in ['darwin', 'linux2', 'linux']:
-+            python_dir = os.path.dirname(python_dir)
-+
-+        if plat == 'darwin':
-+            lib = '/libmkl_rt.dylib'
-+        elif plat == 'win32':
-+            lib = r'\mkl_rt.dll'
-+        elif plat in ['linux2', 'linux']:
-+            lib = '/libmkl_rt.so'
-+        else:
-+            raise Exception('Unknown platfrom.')
-+
-+        if plat in ['darwin', 'linux2', 'linux']:
-+            lib_dir = '/lib'
-+        else:
-+            lib_dir = r'\Library\bin'
-+        # Try in default Anaconda location first
-+        try:
-+            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
-+        except Exception:
-+            pass
-+
-+        # Look in Intel Python distro location
-+        if mkl_lib is None:
-+            if plat in ['darwin', 'linux2', 'linux']:
-+                lib_dir = '/ext/lib'
-+            else:
-+                lib_dir = r'\ext\lib'
-+            try:
-+                mkl_lib = \
-+                    cdll.LoadLibrary(python_dir + lib_dir + lib)
-+            except Exception:
-+                pass
-+    return mkl_lib
-+
-+
-+class Settings:
-+    """
-+    Qutip's settings and options.
-+    """
-+    def __init__(self):
-+        self._mkl_lib = ""
-+        try:
-+            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
-+        except OSError:
-+            self._tmproot = "."
-+        self.core = None  # set in qutip.core.options
-+        self.compile = None  # set in qutip.core.coefficient
-+        self._debug = False
-+        self._log_handler = "default"
-+        self._colorblind_safe = False
-+
-+    @property
-+    def has_mkl(self):
-+        """ Whether qutip found an mkl installation. """
-+        return self.mkl_lib is not None
-+
-+    @property
-+    def mkl_lib(self):
-+        """ Location of the mkl installation. """
-+        if self._mkl_lib == "":
-+            self._mkl_lib = _find_mkl()
-+        return _find_mkl()
-+
-+    @property
-+    def ipython(self):
-+        """ Whether qutip is running in ipython. """
-+        try:
-+            __IPYTHON__
-+            return True
-+        except NameError:
-+            return False
-+
-+    @property
-+    def eigh_unsafe(self):
-+        """
-+        Whether `eigh` call is reliable.
-+        Some implementation of blas have some issues on some OS.
-+        """
-+        from packaging import version as pac_version
-+        import scipy
-+        is_old_scipy = (
-+            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
-+        )
-+        return (
-+            # macOS OpenBLAS eigh is unstable, see #1288
-+            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
-+            # The combination of scipy<1.5 and MKL causes wrong results when
-+            # calling eigh for big matrices.  See #1495, #1491 and #1498.
-+            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
-+        )
-+
-+    @property
-+    def tmproot(self):
-+        """
-+        Location in which qutip place cython string coefficient folders.
-+        The default is "$HOME/.qutip".
-+        Can be updated.
-+        """
-+        return self._tmproot
-+
-+    @tmproot.setter
-+    def tmproot(self, root):
-+        if not os.path.exists(root):
-+            os.mkdir(root)
-+        self._tmproot = root
-+
-+    @property
-+    def coeffroot(self):
-+        """
-+        Location in which qutip save cython string coefficient files.
-+        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
-+        Can be updated.
-+        """
-+        return self._coeffroot
-+
-+    @coeffroot.setter
-+    def coeffroot(self, root):
-+        if not os.path.exists(root):
-+            os.mkdir(root)
-+        if root not in sys.path:
-+            sys.path.insert(0, root)
-+        self._coeffroot = root
-+
-+    @property
-+    def coeff_write_ok(self):
-+        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
-+        return os.access(self.coeffroot, os.W_OK)
-+
-+    @property
-+    def has_openmp(self):
-+        return False
-+        # We keep this as a reminder for when openmp is restored: see Pull #652
-+        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-+
-+    @property
-+    def idxint_size(self):
-+        """
-+        Integer type used by ``CSR`` data.
-+        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
-+        non-zeros elements.
-+        """
-+        from .core import data
-+        return data.base.idxint_size
-+
-+    @property
-+    def num_cpus(self):
-+        """
-+        Number of cpu detected.
-+        Use the solver options to control the number of cpus used.
-+        """
-+        if 'QUTIP_NUM_PROCESSES' in os.environ:
-+            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
-+        else:
-+            num_cpus = available_cpu_count()
-+            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
-+        return num_cpus
-+
-+    @property
-+    def debug(self):
-+        """
-+        Debug mode for development.
-+        """
-+        return self._debug
-+
-+    @debug.setter
-+    def debug(self, value):
-+        self._debug = value
-+
-+    @property
-+    def log_handler(self):
-+        """
-+        Define whether log handler should be:
-+        - default: switch based on IPython detection
-+        - stream: set up non-propagating StreamHandler
-+        - basic: call basicConfig
-+        - null: leave logging to the user
-+        """
-+        return self._log_handler
-+
-+    @log_handler.setter
-+    def log_handler(self, value):
-+        self._log_handler = value
-+
-+    @property
-+    def colorblind_safe(self):
-+        """
-+        Allow for a colorblind mode that uses different colormaps
-+        and plotting options by default.
-+        """
-+        return self._colorblind_safe
-+
-+    @colorblind_safe.setter
-+    def colorblind_safe(self, value):
-+        self._colorblind_safe = value
-+
-+    def __str__(self):
-+        lines = ["Qutip settings:"]
-+        for attr in self.__dir__():
-+            if not attr.startswith('_') and attr not in ["core", "compile"]:
-+                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
-+        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
-+        return '\n'.join(lines)
-+
-+    def __repr__(self):
-+        return self.__str__()
-+
-+
-+settings = Settings()
-diff --git a/qutip/simdiag.py b/qutip/simdiag.py
-index 370ade65..a0105eee 100644
---- a/qutip/simdiag.py
-+++ b/qutip/simdiag.py
-@@ -1,120 +1,120 @@
--__all__ = ['simdiag']
--
--import numpy as np
--import scipy.linalg as la
--from . import Qobj
--from .core import data as _data
--
--
--def _degen(tol, vecs, ops, i=0):
--    """
--    Private function that finds eigen vals and vecs for degenerate matrices..
--    """
--    if len(ops) == i:
--        return vecs
--
--    # New eigenvectors are sometime not orthogonal.
--    for j in range(1, vecs.shape[1]):
--        for k in range(j):
--            dot = vecs[:, j].dot(vecs[:, k].conj())
--            if np.abs(dot) > tol:
--                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
--                              / (1 - np.abs(dot)**2)**0.5)
--
--    subspace = vecs.conj().T @ ops[i].full() @ vecs
--    eigvals, eigvecs = la.eig(subspace)
--
--    perm = np.argsort(eigvals)
--    eigvals = eigvals[perm]
--
--    vecs_new = vecs @ eigvecs[:, perm]
--    for k in range(len(eigvals)):
--        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
--
--    k = 0
--    while k < len(eigvals):
--        ttol = max(tol, tol * abs(eigvals[k]))
--        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
--        if len(inds) > 1:  # if at least 2 eigvals are degenerate
--            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
--        k = inds[-1] + 1
--    return vecs_new
--
--
--def simdiag(ops, evals: bool = True, *,
--            tol: float = 1e-14, safe_mode: bool = True):
--    """Simultaneous diagonalization of commuting Hermitian matrices.
--
--    Parameters
--    ----------
--    ops : list/array
--        ``list`` or ``array`` of qobjs representing commuting Hermitian
--        operators.
--
--    evals : bool [True]
--        Whether to return the eigenvalues for each ops and eigenvectors or just
--        the eigenvectors.
--
--    tol : float [1e-14]
--        Tolerance for detecting degenerate eigenstates.
--
--    safe_mode : bool [True]
--        Whether to check that all ops are Hermitian and commuting. If set to
--        ``False`` and operators are not commuting, the eigenvectors returned
--        will often be eigenvectors of only the first operator.
--
--    Returns
--    --------
--    eigs : tuple
--        Tuple of arrays representing eigvecs and eigvals of quantum objects
--        corresponding to simultaneous eigenvectors and eigenvalues for each
--        operator.
--
--    """
--    if not ops:
--        raise ValueError("No input matrices.")
--    N = ops[0].shape[0]
--    num_ops = len(ops) if safe_mode else 0
--    for jj in range(num_ops):
--        A = ops[jj]
--        shape = A.shape
--        if shape[0] != shape[1]:
--            raise TypeError('Matricies must be square.')
--        if shape[0] != N:
--            raise TypeError('All matrices. must be the same shape')
--        if not A.isherm:
--            raise TypeError('Matricies must be Hermitian')
--        for kk in range(jj):
--            B = ops[kk]
--            if (A * B - B * A).norm() / (A * B).norm() > tol:
--                raise TypeError('Matricies must commute.')
--
--    # TODO: rewrite using Data object
--    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
--    eigvecs = eigvecs.to_array()
--
--    k = 0
--    while k < N:
--        # find degenerate eigenvalues, get indicies of degenerate eigvals
--        ttol = max(tol, tol * abs(eigvals[k]))
--        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
--        if len(inds) > 1:  # if at least 2 eigvals are degenerate
--            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
--        k = inds[-1] + 1
--
--    for k in range(N):
--        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
--
--    kets_out = [
--        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
--        for j in range(N)
--    ]
--    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
--    if not evals:
--        return kets_out
--    else:
--        for kk in range(len(ops)):
--            for j in range(N):
--                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
--                                                            kets_out[j]).real
--        return eigvals_out, kets_out
-+__all__ = ['simdiag']
-+
-+import numpy as np
-+import scipy.linalg as la
-+from . import Qobj
-+from .core import data as _data
-+
-+
-+def _degen(tol, vecs, ops, i=0):
-+    """
-+    Private function that finds eigen vals and vecs for degenerate matrices..
-+    """
-+    if len(ops) == i:
-+        return vecs
-+
-+    # New eigenvectors are sometime not orthogonal.
-+    for j in range(1, vecs.shape[1]):
-+        for k in range(j):
-+            dot = vecs[:, j].dot(vecs[:, k].conj())
-+            if np.abs(dot) > tol:
-+                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
-+                              / (1 - np.abs(dot)**2)**0.5)
-+
-+    subspace = vecs.conj().T @ ops[i].full() @ vecs
-+    eigvals, eigvecs = la.eig(subspace)
-+
-+    perm = np.argsort(eigvals)
-+    eigvals = eigvals[perm]
-+
-+    vecs_new = vecs @ eigvecs[:, perm]
-+    for k in range(len(eigvals)):
-+        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
-+
-+    k = 0
-+    while k < len(eigvals):
-+        ttol = max(tol, tol * abs(eigvals[k]))
-+        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
-+        if len(inds) > 1:  # if at least 2 eigvals are degenerate
-+            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
-+        k = inds[-1] + 1
-+    return vecs_new
-+
-+
-+def simdiag(ops, evals: bool = True, *,
-+            tol: float = 1e-14, safe_mode: bool = True):
-+    """Simultaneous diagonalization of commuting Hermitian matrices.
-+
-+    Parameters
-+    ----------
-+    ops : list/array
-+        ``list`` or ``array`` of qobjs representing commuting Hermitian
-+        operators.
-+
-+    evals : bool [True]
-+        Whether to return the eigenvalues for each ops and eigenvectors or just
-+        the eigenvectors.
-+
-+    tol : float [1e-14]
-+        Tolerance for detecting degenerate eigenstates.
-+
-+    safe_mode : bool [True]
-+        Whether to check that all ops are Hermitian and commuting. If set to
-+        ``False`` and operators are not commuting, the eigenvectors returned
-+        will often be eigenvectors of only the first operator.
-+
-+    Returns
-+    --------
-+    eigs : tuple
-+        Tuple of arrays representing eigvecs and eigvals of quantum objects
-+        corresponding to simultaneous eigenvectors and eigenvalues for each
-+        operator.
-+
-+    """
-+    if not ops:
-+        raise ValueError("No input matrices.")
-+    N = ops[0].shape[0]
-+    num_ops = len(ops) if safe_mode else 0
-+    for jj in range(num_ops):
-+        A = ops[jj]
-+        shape = A.shape
-+        if shape[0] != shape[1]:
-+            raise TypeError('Matricies must be square.')
-+        if shape[0] != N:
-+            raise TypeError('All matrices. must be the same shape')
-+        if not A.isherm:
-+            raise TypeError('Matricies must be Hermitian')
-+        for kk in range(jj):
-+            B = ops[kk]
-+            if (A * B - B * A).norm() / (A * B).norm() > tol:
-+                raise TypeError('Matricies must commute.')
-+
-+    # TODO: rewrite using Data object
-+    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
-+    eigvecs = eigvecs.to_array()
-+
-+    k = 0
-+    while k < N:
-+        # find degenerate eigenvalues, get indicies of degenerate eigvals
-+        ttol = max(tol, tol * abs(eigvals[k]))
-+        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
-+        if len(inds) > 1:  # if at least 2 eigvals are degenerate
-+            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
-+        k = inds[-1] + 1
-+
-+    for k in range(N):
-+        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
-+
-+    kets_out = [
-+        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
-+        for j in range(N)
-+    ]
-+    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
-+    if not evals:
-+        return kets_out
-+    else:
-+        for kk in range(len(ops)):
-+            for j in range(N):
-+                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
-+                                                            kets_out[j]).real
-+        return eigvals_out, kets_out
-diff --git a/qutip/solve/_piqs.pyx b/qutip/solve/_piqs.pyx
-index fcb614dc..48362373 100644
---- a/qutip/solve/_piqs.pyx
-+++ b/qutip/solve/_piqs.pyx
-@@ -1,641 +1,641 @@
--#cython: language_level=3
--
--"""
--Cythonized code for permutationally invariant Lindbladian generation
--"""
--import numpy as np
--
--from scipy.sparse import csr_matrix, dok_matrix
--from qutip.core import Qobj
--
--cimport numpy as cnp
--cimport cython
--
--
--def _num_dicke_states(N):
--    """
--    Calculate the number of Dicke states.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    nds: int
--        The number of Dicke states.
--    """
--    if (not float(N).is_integer()):
--        raise ValueError("Number of TLS should be an integer")
--
--    if (N < 1):
--        raise ValueError("Number of TLS should be non-negative")
--
--    nds = (N/2 + 1)**2 - (N % 2)/4
--    return int(nds)
--
--def _num_dicke_ladders(N):
--    """
--    Calculate the total number of Dicke ladders in the Dicke space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    Nj: int
--        The number of Dicke ladders.
--    """
--    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
--    return int(Nj)
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cpdef list get_blocks(int N):
--    """
--    Calculate the number of cumulative elements at each block boundary.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    blocks: np.ndarray
--        An array with the number of cumulative elements at the boundary of
--        each block.
--    """
--    cdef int num_blocks = _num_dicke_ladders(N)
--    cdef list blocks
--    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
--    return blocks
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cpdef float j_min(N):
--    """
--    Calculate the minimum value of j for given N.
--
--    Parameters
--    ----------
--    N: int
--        Number of two-level systems.
--
--    Returns
--    -------
--    jmin: float
--        The minimum value of j for odd or even number of two
--        level systems.
--    """
--    if N % 2 == 0:
--        return 0
--    else:
--        return 0.5
--
--def j_vals(N):
--    """
--    Get the valid values of j for given N.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    jvals: np.ndarray
--        The j values for given N as a 1D array.
--    """
--    j = np.arange(j_min(N), N/2 + 1, 1)
--    return j
--
--def m_vals(j):
--    """
--    Get all the possible values of m or m1 for given j.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    mvals: np.ndarray
--        The m values for given j as a 1D array.
--    """
--    return np.arange(-j, j+1, 1)
--
--def get_index(N, j, m, m1, blocks):
--    """
--    Get the index in the density matrix for this j, m, m1 value.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    j, m, m1: float
--        The j, m, m1 values.
--
--    blocks: np.ndarray
--        An 1D array with the number of cumulative elements at the boundary of
--        each block.
--
--    Returns
--    -------
--    mvals: array
--        The m values for given j.
--    """
--    _k = int(j-m1)
--    _k_prime = int(j-m)
--    block_number = int(N/2 - j)
--    offset = 0
--    if block_number > 0:
--        offset = blocks[block_number-1]
--    i = _k_prime + offset
--    k = _k + offset
--    return (i, k)
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cpdef list jmm1_dictionary(int N):
--    """
--    Get the index in the density matrix for this j, m, m1 value.
--
--    The (j, m, m1) values are mapped to the (i, k) index of a block
--    diagonal matrix which has the structure to capture the permutationally
--    symmetric part of the density matrix. For each (j, m, m1) value, first
--    we get the block by using the "j" value and then the addition in the
--    row/column due to the m and m1 is determined. Four dictionaries are
--    returned giving a map from the (j, m, m1) values to (i, k), the inverse
--    map, a flattened map and the inverse of the flattened map.
--    """
--    cdef long i
--    cdef long k
--    cdef dict jmm1_dict = {}
--    cdef dict jmm1_inv = {}
--    cdef dict jmm1_flat = {}
--    cdef dict jmm1_flat_inv = {}
--    cdef int l
--    cdef int nds = _num_dicke_states(N)
--    cdef list blocks = get_blocks(N)
--
--    jvalues = j_vals(N)
--    for j in jvalues:
--        mvalues = m_vals(j)
--        for m in mvalues:
--            for m1 in mvalues:
--                i, k = get_index(N, j, m, m1, blocks)
--                jmm1_dict[(i, k)] = (j, m, m1)
--                jmm1_inv[(j, m, m1)] = (i, k)
--                l = nds * i+k
--                jmm1_flat[l] = (j, m, m1)
--                jmm1_flat_inv[(j, m, m1)] = l
--    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
--
--
--@cython.boundscheck(False)
--@cython.wraparound(False)
--cdef class Dicke(object):
--    """
--    A faster Cythonized Dicke state class to build the Lindbladian.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--
--    Attributes
--    ----------
--    N: int
--        The number of two-level systems.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--    """
--    cdef int N
--    cdef float emission, dephasing, pumping
--    cdef float collective_emission, collective_dephasing, collective_pumping
--
--    def __init__(self, int N, float emission=0., float dephasing=0.,
--                 float pumping=0., float collective_emission=0.,
--                 collective_dephasing=0., collective_pumping=0.):
--        self.N = N
--        self.emission = emission
--        self.dephasing = dephasing
--        self.pumping = pumping
--        self.collective_emission = collective_emission
--        self.collective_dephasing = collective_dephasing
--        self.collective_pumping = collective_pumping
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef object lindbladian(self):
--        """
--        Build the Lindbladian superoperator of the dissipative dynamics as a
--        sparse matrix.
--
--        Returns
--        ----------
--        lindblad_qobj: :class: qutip.Qobj
--            The matrix size is (nds**2, nds**2) where nds is the number of
--            Dicke states.
--        """
--        N = self.N
--        cdef int nds = _num_dicke_states(N)
--        cdef int num_ladders = _num_dicke_ladders(N)
--
--        cdef list lindblad_row = []
--        cdef list lindblad_col = []
--        cdef list lindblad_data = []
--        cdef tuple jmm1_1
--        cdef tuple jmm1_2
--        cdef tuple jmm1_3
--        cdef tuple jmm1_4
--        cdef tuple jmm1_5
--        cdef tuple jmm1_6
--        cdef tuple jmm1_7
--        cdef tuple jmm1_8
--        cdef tuple jmm1_9
--
--        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
--
--        # perform loop in each row of matrix
--        for r in jmm1_row:
--            j, m, m1 = jmm1_row[r]
--            jmm1_1 = (j, m, m1)
--            jmm1_2 = (j, m+1, m1+1)
--            jmm1_3 = (j+1, m+1, m1+1)
--            jmm1_4 = (j-1, m+1, m1+1)
--            jmm1_5 = (j+1, m, m1)
--            jmm1_6 = (j-1, m, m1)
--            jmm1_7 = (j+1, m-1, m1-1)
--            jmm1_8 = (j, m-1, m1-1)
--            jmm1_9 = (j-1, m-1, m1-1)
--
--            g1 = self.gamma1(jmm1_1)
--            c1 = jmm1_inv[jmm1_1]
--
--            lindblad_row.append(int(r))
--            lindblad_col.append(int(c1))
--            lindblad_data.append(g1)
--
--            # generate gammas in the given row
--            # check if the gammas exist
--            # load gammas in the lindbladian in the correct position
--
--            if jmm1_2 in jmm1_inv:
--                g2 = self.gamma2(jmm1_2)
--                c2 = jmm1_inv[jmm1_2]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c2))
--                lindblad_data.append(g2)
--
--            if jmm1_3 in jmm1_inv:
--                g3 = self.gamma3(jmm1_3)
--                c3 = jmm1_inv[jmm1_3]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c3))
--                lindblad_data.append(g3)
--
--            if jmm1_4 in jmm1_inv:
--                g4 = self.gamma4(jmm1_4)
--                c4 = jmm1_inv[jmm1_4]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c4))
--                lindblad_data.append(g4)
--
--            if jmm1_5 in jmm1_inv:
--                g5 = self.gamma5(jmm1_5)
--                c5 = jmm1_inv[jmm1_5]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c5))
--                lindblad_data.append(g5)
--
--            if jmm1_6 in jmm1_inv:
--                g6 = self.gamma6(jmm1_6)
--                c6 = jmm1_inv[jmm1_6]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c6))
--                lindblad_data.append(g6)
--
--            if jmm1_7 in jmm1_inv:
--                g7 = self.gamma7(jmm1_7)
--                c7 = jmm1_inv[jmm1_7]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c7))
--                lindblad_data.append(g7)
--
--            if jmm1_8 in jmm1_inv:
--                g8 = self.gamma8(jmm1_8)
--                c8 = jmm1_inv[jmm1_8]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c8))
--                lindblad_data.append(g8)
--
--            if jmm1_9 in jmm1_inv:
--                g9 = self.gamma9(jmm1_9)
--                c9 = jmm1_inv[jmm1_9]
--
--                lindblad_row.append(int(r))
--                lindblad_col.append(int(c9))
--                lindblad_data.append(g9)
--
--        cdef lindblad_matrix = csr_matrix((lindblad_data,
--                                          (lindblad_row, lindblad_col)),
--                                          shape=(nds**2, nds**2),
--                                          dtype=np.complex128)
--
--        # make matrix a Qobj superoperator with expected dims
--        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
--        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
--        return lindblad_qobj
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma1(self, tuple jmm1):
--        """
--        Calculate gamma1 for value of j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yCE, yE, yD, yP, yCP, yCD
--        cdef float N
--        cdef float spontaneous, losses, pump, collective_pump
--        cdef float dephase, collective_dephase, g1
--
--        j, m, m1 = jmm1
--        N = float(self.N)
--
--        yE = self.emission
--        yD = self.dephasing
--        yP = self.pumping
--        yCE = self.collective_emission
--        yCP = self.collective_pumping
--        yCD = self.collective_dephasing
--
--        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
--        losses = (yE/2) * (N+m+m1)
--        pump = yP/2 * (N-m-m1)
--        collective_pump = yCP/2 * \
--            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
--        collective_dephase = yCD/2 * (m-m1)**2
--
--        if j <= 0:
--            dephase = yD*N/4
--        else:
--            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
--
--        g1 = spontaneous + losses + pump + dephase + \
--            collective_pump + collective_dephase
--
--        return -g1
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma2(self, tuple jmm1):
--        """
--        Calculate gamma2 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yCE, yE, yD, yP, yCP, yCD, g2
--        cdef float N
--        cdef float spontaneous, losses, pump, collective_pump
--        cdef float dephase, collective_dephase
--
--        j, m, m1 = jmm1
--        N = float(self.N)
--        yCE = self.collective_emission
--        yE = self.emission
--
--        if yCE == 0:
--            spontaneous = 0.0
--        else:
--            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
--
--        if (yE == 0) or (j <= 0):
--            losses = 0.0
--        else:
--            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
--                                                      (N/2 + 1)/(j*(j+1))
--        g2 = spontaneous + losses
--        return g2
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma3(self, tuple jmm1):
--        """
--        Calculate gamma3 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yE
--        cdef float N
--        cdef float spontaneous, losses, pump, collective_pump
--        cdef float dephase, collective_dephase
--
--        cdef complex g3
--        j, m, m1 = jmm1
--        N = float(self.N)
--        yE = self.emission
--
--        if (yE == 0) or (j <= 0):
--            g3 = 0.0
--        else:
--            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
--                 (N/2 + j+1)/(j*(2*j + 1))
--        return g3
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma4(self, tuple jmm1):
--        """
--        Calculate gamma4 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef complex g4
--        cdef float yE
--        cdef float N
--
--        N = float(self.N)
--        j, m, m1 = jmm1
--        yE = self.emission
--        if (yE == 0) or ((j+1) <= 0):
--            g4 = 0.0
--        else:
--            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
--                                (j-m1+2)) * (N/2 - j)/((j+1) *
--                                                       (2*j + 1))
--        return g4
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma5(self, tuple jmm1):
--        """
--        Calculate gamma5 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef complex g5
--        j, m, m1 = jmm1
--        cdef float yD
--        cdef float N
--
--        N = float(self.N)
--        yD = self.dephasing
--
--        if (yD == 0) or (j <= 0):
--            g5 = 0.0
--        else:
--            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
--                (N/2 + j + 1)/(j*(2*j + 1))
--
--        return g5
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma6(self, tuple jmm1):
--        """
--        Calculate gamma6 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yD
--        cdef float N
--        cdef complex g6
--
--        j, m, m1 = jmm1
--        N = float(self.N)
--
--        yD = self.dephasing
--        if yD == 0:
--            g6 = 0.0
--        else:
--            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
--                                                   2-m1**2)) * \
--                                                   (N/2 - j)/((j+1) * (2*j+1))
--        return g6
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma7(self, tuple jmm1):
--        """
--        Calculate gamma7 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yP
--        cdef float N
--        cdef complex g7
--
--        j, m, m1 = jmm1
--        N = float(self.N)
--        yP = self.pumping
--
--        if (yP == 0) or (j <= 0):
--            g7 = 0.0
--        else:
--            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
--                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
--        return g7
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma8(self, tuple jmm1):
--        """
--        Calculate gamma8 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yP, yCP
--        cdef float N
--        cdef complex g8
--
--        j, m, m1 = jmm1
--        N = float(self.N)
--        yP = self.pumping
--        yCP = self.collective_pumping
--        if (yP == 0) or (j <= 0):
--            pump = 0.0
--        else:
--            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
--                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
--        if yCP == 0:
--            collective_pump = 0.0
--        else:
--            collective_pump = yCP * \
--                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
--        g8 = pump + collective_pump
--        return g8
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cpdef complex gamma9(self, tuple jmm1):
--        """
--        Calculate gamma9 for given j, m, m'.
--        """
--        cdef float j, m, m1
--        cdef float yP
--        cdef float N
--        cdef complex g9
--
--        j, m, m1 = jmm1
--        N = float(self.N)
--        yP = self.pumping
--
--        if (yP == 0):
--            g9 = 0.0
--        else:
--            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
--                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
--        return g9
-+#cython: language_level=3
-+
-+"""
-+Cythonized code for permutationally invariant Lindbladian generation
-+"""
-+import numpy as np
-+
-+from scipy.sparse import csr_matrix, dok_matrix
-+from qutip.core import Qobj
-+
-+cimport numpy as cnp
-+cimport cython
-+
-+
-+def _num_dicke_states(N):
-+    """
-+    Calculate the number of Dicke states.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    nds: int
-+        The number of Dicke states.
-+    """
-+    if (not float(N).is_integer()):
-+        raise ValueError("Number of TLS should be an integer")
-+
-+    if (N < 1):
-+        raise ValueError("Number of TLS should be non-negative")
-+
-+    nds = (N/2 + 1)**2 - (N % 2)/4
-+    return int(nds)
-+
-+def _num_dicke_ladders(N):
-+    """
-+    Calculate the total number of Dicke ladders in the Dicke space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    Nj: int
-+        The number of Dicke ladders.
-+    """
-+    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
-+    return int(Nj)
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cpdef list get_blocks(int N):
-+    """
-+    Calculate the number of cumulative elements at each block boundary.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    blocks: np.ndarray
-+        An array with the number of cumulative elements at the boundary of
-+        each block.
-+    """
-+    cdef int num_blocks = _num_dicke_ladders(N)
-+    cdef list blocks
-+    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
-+    return blocks
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cpdef float j_min(N):
-+    """
-+    Calculate the minimum value of j for given N.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        Number of two-level systems.
-+
-+    Returns
-+    -------
-+    jmin: float
-+        The minimum value of j for odd or even number of two
-+        level systems.
-+    """
-+    if N % 2 == 0:
-+        return 0
-+    else:
-+        return 0.5
-+
-+def j_vals(N):
-+    """
-+    Get the valid values of j for given N.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    jvals: np.ndarray
-+        The j values for given N as a 1D array.
-+    """
-+    j = np.arange(j_min(N), N/2 + 1, 1)
-+    return j
-+
-+def m_vals(j):
-+    """
-+    Get all the possible values of m or m1 for given j.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    mvals: np.ndarray
-+        The m values for given j as a 1D array.
-+    """
-+    return np.arange(-j, j+1, 1)
-+
-+def get_index(N, j, m, m1, blocks):
-+    """
-+    Get the index in the density matrix for this j, m, m1 value.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    j, m, m1: float
-+        The j, m, m1 values.
-+
-+    blocks: np.ndarray
-+        An 1D array with the number of cumulative elements at the boundary of
-+        each block.
-+
-+    Returns
-+    -------
-+    mvals: array
-+        The m values for given j.
-+    """
-+    _k = int(j-m1)
-+    _k_prime = int(j-m)
-+    block_number = int(N/2 - j)
-+    offset = 0
-+    if block_number > 0:
-+        offset = blocks[block_number-1]
-+    i = _k_prime + offset
-+    k = _k + offset
-+    return (i, k)
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cpdef list jmm1_dictionary(int N):
-+    """
-+    Get the index in the density matrix for this j, m, m1 value.
-+
-+    The (j, m, m1) values are mapped to the (i, k) index of a block
-+    diagonal matrix which has the structure to capture the permutationally
-+    symmetric part of the density matrix. For each (j, m, m1) value, first
-+    we get the block by using the "j" value and then the addition in the
-+    row/column due to the m and m1 is determined. Four dictionaries are
-+    returned giving a map from the (j, m, m1) values to (i, k), the inverse
-+    map, a flattened map and the inverse of the flattened map.
-+    """
-+    cdef long i
-+    cdef long k
-+    cdef dict jmm1_dict = {}
-+    cdef dict jmm1_inv = {}
-+    cdef dict jmm1_flat = {}
-+    cdef dict jmm1_flat_inv = {}
-+    cdef int l
-+    cdef int nds = _num_dicke_states(N)
-+    cdef list blocks = get_blocks(N)
-+
-+    jvalues = j_vals(N)
-+    for j in jvalues:
-+        mvalues = m_vals(j)
-+        for m in mvalues:
-+            for m1 in mvalues:
-+                i, k = get_index(N, j, m, m1, blocks)
-+                jmm1_dict[(i, k)] = (j, m, m1)
-+                jmm1_inv[(j, m, m1)] = (i, k)
-+                l = nds * i+k
-+                jmm1_flat[l] = (j, m, m1)
-+                jmm1_flat_inv[(j, m, m1)] = l
-+    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
-+
-+
-+@cython.boundscheck(False)
-+@cython.wraparound(False)
-+cdef class Dicke(object):
-+    """
-+    A faster Cythonized Dicke state class to build the Lindbladian.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+
-+    Attributes
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+    """
-+    cdef int N
-+    cdef float emission, dephasing, pumping
-+    cdef float collective_emission, collective_dephasing, collective_pumping
-+
-+    def __init__(self, int N, float emission=0., float dephasing=0.,
-+                 float pumping=0., float collective_emission=0.,
-+                 collective_dephasing=0., collective_pumping=0.):
-+        self.N = N
-+        self.emission = emission
-+        self.dephasing = dephasing
-+        self.pumping = pumping
-+        self.collective_emission = collective_emission
-+        self.collective_dephasing = collective_dephasing
-+        self.collective_pumping = collective_pumping
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef object lindbladian(self):
-+        """
-+        Build the Lindbladian superoperator of the dissipative dynamics as a
-+        sparse matrix.
-+
-+        Returns
-+        ----------
-+        lindblad_qobj: :class: qutip.Qobj
-+            The matrix size is (nds**2, nds**2) where nds is the number of
-+            Dicke states.
-+        """
-+        N = self.N
-+        cdef int nds = _num_dicke_states(N)
-+        cdef int num_ladders = _num_dicke_ladders(N)
-+
-+        cdef list lindblad_row = []
-+        cdef list lindblad_col = []
-+        cdef list lindblad_data = []
-+        cdef tuple jmm1_1
-+        cdef tuple jmm1_2
-+        cdef tuple jmm1_3
-+        cdef tuple jmm1_4
-+        cdef tuple jmm1_5
-+        cdef tuple jmm1_6
-+        cdef tuple jmm1_7
-+        cdef tuple jmm1_8
-+        cdef tuple jmm1_9
-+
-+        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
-+
-+        # perform loop in each row of matrix
-+        for r in jmm1_row:
-+            j, m, m1 = jmm1_row[r]
-+            jmm1_1 = (j, m, m1)
-+            jmm1_2 = (j, m+1, m1+1)
-+            jmm1_3 = (j+1, m+1, m1+1)
-+            jmm1_4 = (j-1, m+1, m1+1)
-+            jmm1_5 = (j+1, m, m1)
-+            jmm1_6 = (j-1, m, m1)
-+            jmm1_7 = (j+1, m-1, m1-1)
-+            jmm1_8 = (j, m-1, m1-1)
-+            jmm1_9 = (j-1, m-1, m1-1)
-+
-+            g1 = self.gamma1(jmm1_1)
-+            c1 = jmm1_inv[jmm1_1]
-+
-+            lindblad_row.append(int(r))
-+            lindblad_col.append(int(c1))
-+            lindblad_data.append(g1)
-+
-+            # generate gammas in the given row
-+            # check if the gammas exist
-+            # load gammas in the lindbladian in the correct position
-+
-+            if jmm1_2 in jmm1_inv:
-+                g2 = self.gamma2(jmm1_2)
-+                c2 = jmm1_inv[jmm1_2]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c2))
-+                lindblad_data.append(g2)
-+
-+            if jmm1_3 in jmm1_inv:
-+                g3 = self.gamma3(jmm1_3)
-+                c3 = jmm1_inv[jmm1_3]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c3))
-+                lindblad_data.append(g3)
-+
-+            if jmm1_4 in jmm1_inv:
-+                g4 = self.gamma4(jmm1_4)
-+                c4 = jmm1_inv[jmm1_4]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c4))
-+                lindblad_data.append(g4)
-+
-+            if jmm1_5 in jmm1_inv:
-+                g5 = self.gamma5(jmm1_5)
-+                c5 = jmm1_inv[jmm1_5]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c5))
-+                lindblad_data.append(g5)
-+
-+            if jmm1_6 in jmm1_inv:
-+                g6 = self.gamma6(jmm1_6)
-+                c6 = jmm1_inv[jmm1_6]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c6))
-+                lindblad_data.append(g6)
-+
-+            if jmm1_7 in jmm1_inv:
-+                g7 = self.gamma7(jmm1_7)
-+                c7 = jmm1_inv[jmm1_7]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c7))
-+                lindblad_data.append(g7)
-+
-+            if jmm1_8 in jmm1_inv:
-+                g8 = self.gamma8(jmm1_8)
-+                c8 = jmm1_inv[jmm1_8]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c8))
-+                lindblad_data.append(g8)
-+
-+            if jmm1_9 in jmm1_inv:
-+                g9 = self.gamma9(jmm1_9)
-+                c9 = jmm1_inv[jmm1_9]
-+
-+                lindblad_row.append(int(r))
-+                lindblad_col.append(int(c9))
-+                lindblad_data.append(g9)
-+
-+        cdef lindblad_matrix = csr_matrix((lindblad_data,
-+                                          (lindblad_row, lindblad_col)),
-+                                          shape=(nds**2, nds**2),
-+                                          dtype=np.complex128)
-+
-+        # make matrix a Qobj superoperator with expected dims
-+        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
-+        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
-+        return lindblad_qobj
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma1(self, tuple jmm1):
-+        """
-+        Calculate gamma1 for value of j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yCE, yE, yD, yP, yCP, yCD
-+        cdef float N
-+        cdef float spontaneous, losses, pump, collective_pump
-+        cdef float dephase, collective_dephase, g1
-+
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+
-+        yE = self.emission
-+        yD = self.dephasing
-+        yP = self.pumping
-+        yCE = self.collective_emission
-+        yCP = self.collective_pumping
-+        yCD = self.collective_dephasing
-+
-+        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
-+        losses = (yE/2) * (N+m+m1)
-+        pump = yP/2 * (N-m-m1)
-+        collective_pump = yCP/2 * \
-+            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
-+        collective_dephase = yCD/2 * (m-m1)**2
-+
-+        if j <= 0:
-+            dephase = yD*N/4
-+        else:
-+            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
-+
-+        g1 = spontaneous + losses + pump + dephase + \
-+            collective_pump + collective_dephase
-+
-+        return -g1
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma2(self, tuple jmm1):
-+        """
-+        Calculate gamma2 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yCE, yE, yD, yP, yCP, yCD, g2
-+        cdef float N
-+        cdef float spontaneous, losses, pump, collective_pump
-+        cdef float dephase, collective_dephase
-+
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+        yCE = self.collective_emission
-+        yE = self.emission
-+
-+        if yCE == 0:
-+            spontaneous = 0.0
-+        else:
-+            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
-+
-+        if (yE == 0) or (j <= 0):
-+            losses = 0.0
-+        else:
-+            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
-+                                                      (N/2 + 1)/(j*(j+1))
-+        g2 = spontaneous + losses
-+        return g2
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma3(self, tuple jmm1):
-+        """
-+        Calculate gamma3 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yE
-+        cdef float N
-+        cdef float spontaneous, losses, pump, collective_pump
-+        cdef float dephase, collective_dephase
-+
-+        cdef complex g3
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+        yE = self.emission
-+
-+        if (yE == 0) or (j <= 0):
-+            g3 = 0.0
-+        else:
-+            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
-+                 (N/2 + j+1)/(j*(2*j + 1))
-+        return g3
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma4(self, tuple jmm1):
-+        """
-+        Calculate gamma4 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef complex g4
-+        cdef float yE
-+        cdef float N
-+
-+        N = float(self.N)
-+        j, m, m1 = jmm1
-+        yE = self.emission
-+        if (yE == 0) or ((j+1) <= 0):
-+            g4 = 0.0
-+        else:
-+            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
-+                                (j-m1+2)) * (N/2 - j)/((j+1) *
-+                                                       (2*j + 1))
-+        return g4
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma5(self, tuple jmm1):
-+        """
-+        Calculate gamma5 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef complex g5
-+        j, m, m1 = jmm1
-+        cdef float yD
-+        cdef float N
-+
-+        N = float(self.N)
-+        yD = self.dephasing
-+
-+        if (yD == 0) or (j <= 0):
-+            g5 = 0.0
-+        else:
-+            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
-+                (N/2 + j + 1)/(j*(2*j + 1))
-+
-+        return g5
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma6(self, tuple jmm1):
-+        """
-+        Calculate gamma6 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yD
-+        cdef float N
-+        cdef complex g6
-+
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+
-+        yD = self.dephasing
-+        if yD == 0:
-+            g6 = 0.0
-+        else:
-+            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
-+                                                   2-m1**2)) * \
-+                                                   (N/2 - j)/((j+1) * (2*j+1))
-+        return g6
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma7(self, tuple jmm1):
-+        """
-+        Calculate gamma7 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yP
-+        cdef float N
-+        cdef complex g7
-+
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+        yP = self.pumping
-+
-+        if (yP == 0) or (j <= 0):
-+            g7 = 0.0
-+        else:
-+            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
-+                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
-+        return g7
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma8(self, tuple jmm1):
-+        """
-+        Calculate gamma8 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yP, yCP
-+        cdef float N
-+        cdef complex g8
-+
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+        yP = self.pumping
-+        yCP = self.collective_pumping
-+        if (yP == 0) or (j <= 0):
-+            pump = 0.0
-+        else:
-+            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
-+                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
-+        if yCP == 0:
-+            collective_pump = 0.0
-+        else:
-+            collective_pump = yCP * \
-+                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
-+        g8 = pump + collective_pump
-+        return g8
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cpdef complex gamma9(self, tuple jmm1):
-+        """
-+        Calculate gamma9 for given j, m, m'.
-+        """
-+        cdef float j, m, m1
-+        cdef float yP
-+        cdef float N
-+        cdef complex g9
-+
-+        j, m, m1 = jmm1
-+        N = float(self.N)
-+        yP = self.pumping
-+
-+        if (yP == 0):
-+            g9 = 0.0
-+        else:
-+            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
-+                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
-+        return g9
-diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
-index 91799251..4257fb2b 100644
---- a/qutip/solve/_stochastic.pyx
-+++ b/qutip/solve/_stochastic.pyx
-@@ -1,2345 +1,2345 @@
--#cython: language_level=3
--
--import numpy as np
--cimport numpy as np
--cimport cython
--from cpython.exc cimport PyErr_CheckSignals
--from libc.math cimport fabs
--from qutip.core.cy.qobjevo cimport QobjEvo
--from .. import Qobj, unstack_columns
--import scipy.sparse as sp
--from scipy.sparse.linalg import LinearOperator
--from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
--from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
--
--from qutip.core.data cimport dense, Dense
--import qutip.core.data as _data
--
--cdef extern from "<complex>" namespace "std" nogil:
--    double complex conj(double complex x)
--
--cdef int ZERO=0
--cdef double DZERO=0
--cdef complex ZZERO=0j
--cdef int ONE=1
--
--"""Some of blas wrapper"""
--@cython.boundscheck(False)
--cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
--    """ y += a*x"""
--    cdef int l = x.shape[0]
--    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
--
--@cython.boundscheck(False)
--cdef void copy(complex[::1] x, complex[::1] y):
--    """ y = x """
--    cdef int l = x.shape[0]
--    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
--
--@cython.boundscheck(False)
--cdef complex _dot(complex[::1] x, complex[::1] y):
--    """ = x_i * y_i """
--    cdef int l = x.shape[0]
--    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
--
--@cython.boundscheck(False)
--cdef complex _dotc(complex[::1] x, complex[::1] y):
--    """ = conj(x_i) * y_i """
--    cdef int l = x.shape[0]
--    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
--
--@cython.boundscheck(False)
--cdef double _dznrm2(complex[::1] vec):
--    """ = sqrt( x_i**2 ) """
--    cdef int l = vec.shape[0]
--    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
--
--@cython.boundscheck(False)
--cdef void _scale(double a, complex[::1] x):
--    """ x *= a """
--    cdef int l = x.shape[0]
--    zdscal(&l, &a, <complex*>&x[0], &ONE)
--
--@cython.boundscheck(False)
--cdef void _zscale(complex a, complex[::1] x):
--    """ x *= a """
--    cdef int l = x.shape[0]
--    zscal(&l, &a, <complex*>&x[0], &ONE)
--
--@cython.boundscheck(False)
--cdef void _zero(complex[::1] x):
--    """ x *= 0 """
--    cdef int l = x.shape[0]
--    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
--
--@cython.boundscheck(False)
--cdef void _zero_2d(complex[:,::1] x):
--    """ x *= 0 """
--    cdef int l = x.shape[0]*x.shape[1]
--    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
--
--@cython.boundscheck(False)
--cdef void _zero_3d(complex[:,:,::1] x):
--    """ x *= 0 """
--    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
--    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
--
--@cython.boundscheck(False)
--cdef void _zero_4d(complex[:,:,:,::1] x):
--    """ x *= 0 """
--    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
--    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
--
--@cython.boundscheck(False)
--@cython.initializedcheck(False)
--cdef Dense _dense_wrap(double complex [::1] x):
--    return dense.wrap(&x[0], x.shape[0], 1)
--
--# %%%%%%%%%%%%%%%%%%%%%%%%%
--# functions for ensuring that the states stay physical
--@cython.cdivision(True)
--@cython.boundscheck(False)
--cdef void _normalize_inplace(complex[::1] vec):
--    """ make norm of vec equal to 1"""
--    cdef int l = vec.shape[0]
--    cdef double norm = 1.0/_dznrm2(vec)
--    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
--
--# to move eventually, 10x faster than scipy's norm.
--@cython.cdivision(True)
--@cython.boundscheck(False)
--def normalize_inplace(complex[::1] vec):
--    """ make norm of vec equal to 1"""
--    cdef int l = vec.shape[0]
--    cdef double norm = 1.0/_dznrm2(vec)
--    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
--    return fabs(norm-1)
--
--@cython.cdivision(True)
--@cython.boundscheck(False)
--cdef void _normalize_rho(complex[::1] rho):
--    """ Ensure that the density matrix trace is one and
--    that the composing states are normalized.
--    """
--    cdef int l = rho.shape[0]
--    cdef int N = np.sqrt(l)
--    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
--    cdef complex[::1,:] eivec
--    cdef double[::1] eival = np.zeros(N)
--    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
--
--    _zero(rho)
--    cdef int i, j, k
--    cdef double sum
--
--    sum = 0.
--    for i in range(N):
--        _normalize_inplace(eivec[:,i])
--        if eival[i] < 0:
--            eival[i] = 0.
--        sum += eival[i]
--    if sum != 1.:
--        for i in range(N):
--            eival[i] /= sum
--
--    for i in range(N):
--        for j in range(N):
--            for k in range(N):
--                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
--
--# Available solvers:
--cpdef enum Solvers:
--  # order 0.5
--  EULER_SOLVER           =  50
--  # order 0.5 strong, 1.0 weak?
--  PC_SOLVER              = 101
--  PC_2_SOLVER            = 104
--  # order 1.0
--  PLATEN_SOLVER          = 100
--  MILSTEIN_SOLVER        = 102
--  MILSTEIN_IMP_SOLVER    = 103
--  # order 1.5
--  EXPLICIT1_5_SOLVER     = 150
--  TAYLOR1_5_SOLVER       = 152
--  TAYLOR1_5_IMP_SOLVER   = 153
--  # order 2.0
--  TAYLOR2_0_SOLVER       = 202
--
--  # Special solvers
--  PHOTOCURRENT_SOLVER    =  60
--  PHOTOCURRENT_PC_SOLVER = 110
--  ROUCHON_SOLVER         = 120
--
--  # For initialisation
--  SOLVER_NOT_SET         =   0
--
--
--cdef class TaylorNoise:
--    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
--    Complex enough that I fell it should be kept separated from the main solver.
--    """
--    cdef:
--      int p
--      double rho, alpha
--      double aFactor, bFactor
--      double BFactor, CFactor
--      double dt, dt_sqrt
--
--    @cython.cdivision(True)
--    def __init__(self, int p, double dt):
--        self.p = p
--        self.dt = dt
--        self.dt_sqrt = dt**.5
--        cdef double pi = np.pi
--        cdef int i
--
--        cdef double rho = 0.
--        for i in range(1,p+1):
--            rho += (i+0.)**-2
--        rho = 1./3.-2*rho/(pi**2)
--        self.rho = (rho)**.5
--        self.aFactor = -(2)**.5/pi
--
--        cdef double alpha = 0.
--        for i in range(1,p+1):
--            alpha += (i+0.)**-4
--        alpha = pi/180-alpha/(2*pi**2)/pi
--        self.alpha = (alpha)**.5
--        self.bFactor = (0.5)**.5/pi**2
--
--        self.BFactor = 1/(4*pi**2)
--        self.CFactor = -1/(2*pi**2)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cpdef void order2(self, double[::1] noise, double[::1] dws):
--        cdef int p = self.p
--        cdef int r, l
--        cdef double s = 1/6.
--        cdef double a = 0
--        cdef double b = 0
--        cdef double AA = 0
--        cdef double BB = 0
--        cdef double CC = 0
--
--        for r in range(p):
--            a += noise[3+r]/(r+1.)
--            b += noise[3+r+p]/(r+1.)/(r+1.)
--            BB += (1/(r+1.)/(r+1.)) *\
--                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
--            for l in range(p):
--                if r != l:
--                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
--                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
--                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
--
--        a = self.aFactor * a + self.rho * noise[1]
--        b = self.bFactor * b + self.alpha * noise[2]
--        AA = 0.25*a*a
--        BB *= self.BFactor
--        CC *= self.CFactor
--
--        dws[0] = noise[0]                       # dw
--        dws[1] = 0.5*(noise[0]+a)               # dz
--        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
--        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
--        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
--
--
--cdef class StochasticSolver:
--    """ stochastic solver class base
--    Does most of the initialisation, drive the simulation and contain the
--    stochastic integration algorythm that do not depend on the physics.
--
--    This class is not to be used as is, the function computing the evolution's
--    derivative are specified in it's child class which define the deterministic
--    and stochastic contributions.
--
--    PYTHON METHODS:
--    set_solver:
--      Receive the data for the integration.
--      Prepare buffers
--
--    cy_sesolve_single_trajectory:
--      Run one trajectory.
--
--
--    INTERNAL METHODS
--    make_noise:
--      create the stochastic noise
--    run:
--      evolution between timestep (substep)
--    solver's method:
--      stochastic integration algorithm
--        euler
--        milstein
--        taylor
--        ...
--
--    CHILD:
--    SSESolver: stochastic schrodinger evolution
--    SMESolver: stochastic master evolution
--    PcSSESolver: photocurrent stochastic schrodinger evolution
--    PcSMESolver: photocurrent stochastic master evolution
--    PmSMESolver: positive map stochastic master evolution
--    GenericSSolver: general (user defined) stochastic evolution
--
--    CHILD METHODS:
--    set_data:
--      Read data about the system
--    d1:
--      deterministic part
--    d2:
--      non-deterministic part
--    derivatives:
--      d1, d2 and their derivatives up to dt**1.5
--      multiple sc_ops
--    derivativesO2:
--      d1, d2 and there derivatives up to dt**2.0
--      one sc_ops
--    """
--    cdef int l_vec, num_ops
--    cdef Solvers solver
--    cdef int num_step, num_substeps, num_dw
--    cdef int normalize
--    cdef double dt
--    cdef int noise_type
--    cdef object custom_noise
--    cdef double[::1] dW_factor
--    cdef unsigned int[::1] seed
--    cdef object sso
--
--    # buffer to not redo the initialisation at each substep
--    cdef complex[:, ::1] buffer_1d
--    cdef complex[:, :, ::1] buffer_2d
--    cdef complex[:, :, :, ::1] buffer_3d
--    cdef complex[:, :, :, ::1] buffer_4d
--    cdef complex[:, ::1] expect_buffer_1d
--    cdef complex[:, ::1] expect_buffer_2d
--    cdef complex[:, :, ::1] expect_buffer_3d
--    cdef complex[:, ::1] func_buffer_1d
--    cdef complex[:, ::1] func_buffer_2d
--    cdef complex[:, :, ::1] func_buffer_3d
--
--    cdef TaylorNoise order2noise
--
--    def __init__(self):
--        self.l_vec = 0
--        self.num_ops = 0
--        self.solver = SOLVER_NOT_SET
--
--    def set_solver(self, sso):
--        """ Prepare the solver from the info in StochasticSolverOptions
--
--        Parameters
--        ----------
--        sso : StochasticSolverOptions
--            Data of the stochastic system
--        """
--        self.set_data(sso)
--        self.sso = sso
--
--        self.solver = sso.solver_code
--        self.dt = sso.dt
--        self.num_substeps = sso.nsubsteps
--        self.normalize = sso.normalize
--        self.num_step = len(sso.times)
--        self.num_dw = len(sso.sops)
--        if self.solver in [EXPLICIT1_5_SOLVER,
--                           TAYLOR1_5_SOLVER,
--                           TAYLOR1_5_IMP_SOLVER]:
--            self.num_dw *= 2
--        if self.solver in [TAYLOR2_0_SOLVER]:
--            self.num_dw *= 3 + 2*sso.p
--            self.order2noise = TaylorNoise(sso.p, self.dt)
--        # prepare buffers for the solvers
--        nb_solver = [0,0,0,0]
--        nb_func = [0,0,0]
--        nb_expect = [0,0,0]
--
--        # %%%%%%%%%%%%%%%%%%%%%%%%%
--        # Depending on the solver, determine the numbers of buffers of each
--        # shape to prepare. (~30% slower when not preallocating buffer)
--        # nb_solver : buffer to contain the states used by solver
--        # nb_func : buffer for states used used by d1, d2 and derivative functions
--        # nb_expect : buffer to store expectation values.
--        if self.solver is EULER_SOLVER:
--            nb_solver = [0,1,0,0]
--        elif self.solver is PHOTOCURRENT_SOLVER:
--            nb_solver = [1,0,0,0]
--            nb_func = [1,0,0]
--        elif self.solver is PLATEN_SOLVER:
--            nb_solver = [2,5,0,0]
--        elif self.solver is PC_SOLVER:
--            nb_solver = [4,1,1,0]
--        elif self.solver is MILSTEIN_SOLVER:
--            nb_solver = [0,1,1,0]
--        elif self.solver is MILSTEIN_IMP_SOLVER:
--            nb_solver = [1,1,1,0]
--        elif self.solver is PC_2_SOLVER:
--            nb_solver = [5,1,1,0]
--        elif self.solver is PHOTOCURRENT_PC_SOLVER:
--            nb_solver = [1,1,0,0]
--            nb_func = [1,0,0]
--        elif self.solver is ROUCHON_SOLVER:
--            nb_solver = [2,0,0,0]
--        elif self.solver is EXPLICIT1_5_SOLVER:
--            nb_solver = [5,8,3,0]
--        elif self.solver is TAYLOR1_5_SOLVER:
--            nb_solver = [2,3,1,1]
--        elif self.solver is TAYLOR1_5_IMP_SOLVER:
--            nb_solver = [2,3,1,1]
--        elif self.solver is TAYLOR2_0_SOLVER:
--            nb_solver = [11,0,0,0]
--
--        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
--                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
--          if sso.me:
--            nb_func = [1,0,0]
--            nb_expect = [1,1,0]
--          else:
--            nb_func = [2,1,1]
--            nb_expect = [2,1,1]
--        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
--            nb_expect = [1,0,0]
--        elif self.solver is TAYLOR2_0_SOLVER:
--          if sso.me:
--            nb_func = [2,0,0]
--            nb_expect = [2,0,0]
--          else:
--            nb_func = [14,0,0]
--            nb_expect = [0,0,0]
--        elif self.solver is ROUCHON_SOLVER:
--            nb_expect = [1,0,0]
--        else:
--          if not sso.me:
--            nb_func = [1,0,0]
--
--        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
--        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
--                                  dtype=complex)
--        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
--                                        dtype=complex)
--        if nb_solver[3]:
--          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
--                                        dtype=complex)
--
--        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
--        if nb_expect[1]:
--          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
--        if nb_expect[2]:
--          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
--
--        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
--        if nb_func[1]:
--          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
--        if nb_func[2]:
--          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
--
--        self.noise_type = sso.noise_type
--        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
--        if self.noise_type == 1:
--            self.custom_noise = sso.noise
--        elif self.noise_type == 0:
--            self.seed = sso.noise
--
--    def set_data(self, sso):
--        """Set solver specific operator"""
--        pass
--
--    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
--        """Create the random numbers for the stochastic process"""
--        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
--            # photocurrent, just seed,
--            np.random.seed(self.seed[n])
--            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
--        if self.noise_type == 0:
--            np.random.seed(self.seed[n])
--            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
--                                   np.sqrt(self.dt)
--        elif self.noise_type == 1:
--            return self.custom_noise[n,:,:,:]
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    def cy_sesolve_single_trajectory(self, int n):
--        """ Run the one of the trajectories of the stochastic system.
--
--        Parameters
--        ----------
--        n : int
--            Number of the iterations
--
--        sso : StochasticSolverOptions
--            Data of the stochastic system
--
--        Returns
--        -------
--        states_list : list of qobj
--            State of the system at each time
--
--        noise : array
--            noise at each step of the solver
--
--        measurements : array
--            measurements value at each timestep for each m_ops
--
--        expect : array
--            expectation value at each timestep for each e_ops
--
--        """
--        sso = self.sso
--        cdef double[::1] times = sso.times
--        cdef complex[::1] rho_t
--        cdef double t
--        cdef int m_idx, t_idx, e_idx
--        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
--        cdef int tlast = times.shape[0]
--
--        rho_t = sso.rho0.copy()
--        dims = sso.state0.dims
--
--        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
--        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
--        states_list = []
--        for t_idx, t in enumerate(times):
--            PyErr_CheckSignals()
--            if sso.ce_ops:
--                for e_idx, e in enumerate(sso.ce_ops):
--                    s = e.expect_data(t, _dense_wrap(rho_t))
--                    expect[e_idx, t_idx] = s
--            if sso.store_states or not sso.ce_ops:
--                if sso.me:
--                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
--                        dims=dims))
--                else:
--                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
--
--            if t_idx != tlast-1:
--                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
--                                 rho_t, self.num_substeps)
--
--            if sso.store_measurement:
--                for m_idx, m in enumerate(sso.cm_ops):
--                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
--                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
--                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
--
--        if sso.method == 'heterodyne':
--            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
--
--        return states_list, noise, measurements, expect
--
--    @cython.boundscheck(False)
--    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
--                          complex[::1] vec, int num_substeps):
--        """ Do one time full step"""
--        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
--        cdef int i
--        if self.solver is EULER_SOLVER:
--            for i in range(num_substeps):
--                self.euler(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is PHOTOCURRENT_SOLVER:
--            for i in range(num_substeps):
--                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is PLATEN_SOLVER:
--            for i in range(num_substeps):
--                self.platen(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is PC_SOLVER:
--            for i in range(num_substeps):
--                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is MILSTEIN_SOLVER:
--            for i in range(num_substeps):
--                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is MILSTEIN_IMP_SOLVER:
--            for i in range(num_substeps):
--                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is PC_2_SOLVER:
--            for i in range(num_substeps):
--                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is PHOTOCURRENT_PC_SOLVER:
--            for i in range(num_substeps):
--                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is ROUCHON_SOLVER:
--            for i in range(num_substeps):
--                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is EXPLICIT1_5_SOLVER:
--            for i in range(num_substeps):
--                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is TAYLOR1_5_SOLVER:
--            for i in range(num_substeps):
--                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is TAYLOR1_5_IMP_SOLVER:
--            for i in range(num_substeps):
--                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        elif self.solver is TAYLOR2_0_SOLVER:
--            for i in range(num_substeps):
--                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
--                out, vec = vec, out
--
--        if self.normalize:
--            self._normalize_inplace(vec)
--        return vec
--
--    cdef void _normalize_inplace(self, complex[::1] vec):
--        _normalize_inplace(vec)
--
--    # Dummy functions
--    # Needed for compilation since ssesolve is not stand-alone
--    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
--        """ deterministic part of the evolution
--        depend on schrodinger vs master vs photocurrent
--        """
--        pass
--
--    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
--        """ stochastic part of the evolution
--        depend on schrodinger vs master vs photocurrent
--        """
--        pass
--
--    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
--                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
--        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
--        pass
--
--    cdef void derivatives(self, double t, int deg, complex[::1] rho,
--                              complex[::1] a, complex[:, ::1] b,
--                              complex[:, :, ::1] Lb, complex[:,::1] La,
--                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
--                              complex[::1] L0a):
--        """ Obtain the multiple terms for stochastic taylor expension
--        Up to order 1.5
--        multiple sc_ops
--        """
--        pass
--
--    cdef void derivativesO2(self, double t, complex[::1] rho,
--                            complex[::1] a, complex[::1] b, complex[::1] Lb,
--                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
--                            complex[::1] L0a,
--                            complex[::1] LLa, complex[::1] LL0b,
--                            complex[::1] L0Lb, complex[::1] LLLb):
--        """ Obtain the multiple terms for stochastic taylor expension
--        Up to order 2.0
--        One sc_ops
--        """
--        pass
--
--    cdef void photocurrent(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        """Special integration scheme:
--        photocurrent collapse + euler evolution
--        """
--        pass
--
--    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        """Special integration scheme:
--        photocurrent collapse + predictor-corrector evolution
--        """
--        pass
--
--    cdef void rouchon(self, double t, double dt, double[:] noise,
--                      complex[::1] vec, complex[::1] out):
--        """Special integration scheme:
--        Force valid density matrix using positive map
--        Pierre Rouchon, Jason F. Ralph
--        arXiv:1410.5345 [quant-ph]
--        """
--        pass
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void euler(self, double t, double dt, double[:] noise,
--                    complex[::1] vec, complex[::1] out):
--        """Integration scheme:
--        Basic Euler order 0.5
--        dV = d1 dt + d2_i dW_i
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        cdef int i, j
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        _zero_2d(d2)
--        copy(vec, out)
--        self.d1(t, vec, out)
--        self.d2(t, vec, d2)
--        for i in range(self.num_ops):
--            _axpy(noise[i], d2[i,:], out)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void platen(self, double t, double dt, double[:] noise,
--                       complex[::1] vec, complex[::1] out):
--        """
--        Platen rhs function for both master eq and schrodinger eq.
--        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
--             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
--             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
--
--        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
--        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
--        The Theory of Open Quantum Systems
--        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
--        """
--        cdef int i, j, k
--        cdef double sqrt_dt = np.sqrt(dt)
--        cdef double sqrt_dt_inv = 0.25/sqrt_dt
--        cdef double dw, dw2
--        cdef complex[::1] d1 = self.buffer_1d[0,:]
--        cdef complex[::1] Vt = self.buffer_1d[1,:]
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
--        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
--        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
--        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
--        _zero(d1)
--        _zero_2d(d2)
--
--        self.d1(t, vec, d1)
--        self.d2(t, vec, d2)
--        _axpy(1.0,vec,d1)
--        copy(d1,Vt)
--        copy(d1,out)
--        _scale(0.5,out)
--        for i in range(self.num_ops):
--            copy(d1,Vp[i,:])
--            copy(d1,Vm[i,:])
--            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
--            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
--            _axpy(noise[i],d2[i,:],Vt)
--        _zero(d1)
--        self.d1(t, Vt, d1)
--        _axpy(0.5,d1,out)
--        _axpy(0.5,vec,out)
--        for i in range(self.num_ops):
--            _zero_2d(d2p)
--            _zero_2d(d2m)
--            self.d2(t, Vp[i,:], d2p)
--            self.d2(t, Vm[i,:], d2m)
--            dw = noise[i] * 0.25
--            _axpy(dw,d2m[i,:],out)
--            _axpy(2*dw,d2[i,:],out)
--            _axpy(dw,d2p[i,:],out)
--            for j in range(self.num_ops):
--                if i == j:
--                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
--                else:
--                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
--                _axpy(dw2,d2p[j,:],out)
--                _axpy(-dw2,d2m[j,:],out)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void pred_corr(self, double t, double dt, double[:] noise,
--                    complex[::1] vec, complex[::1] out):
--        """
--        Chapter 15.5 Eq. (5.4)
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        # a=0. b=0.5
--        cdef double dt_2 = dt*0.5
--        cdef complex[::1] euler = self.buffer_1d[0,:]
--        cdef complex[::1] a_pred = self.buffer_1d[1,:]
--        cdef complex[::1] b_pred = self.buffer_1d[2,:]
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
--        _zero(a_pred)
--        _zero(b_pred)
--        _zero_2d(d2)
--        _zero_3d(dd2)
--        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
--        copy(vec, euler)
--        copy(vec, out)
--        _axpy(1.0, a_pred, euler)
--        for i in range(self.num_ops):
--            _axpy(noise[i], d2[i,:], b_pred)
--            _axpy(-dt_2, dd2[i,i,:], a_pred)
--        _axpy(1.0, a_pred, out)
--        _axpy(1.0, b_pred, euler)
--        _axpy(0.5, b_pred, out)
--        _zero_2d(d2)
--        self.d2(t + dt, euler, d2)
--        for i in range(self.num_ops):
--            _axpy(noise[i]*0.5, d2[i,:], out)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
--                    complex[::1] vec, complex[::1] out):
--        """
--        Chapter 15.5 Eq. (5.4)
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        # a=0.5, b=0.5
--        cdef int i, j, k
--        cdef complex[::1] euler = self.buffer_1d[0,:]
--        cdef complex[::1] a_pred = self.buffer_1d[1,:]
--        _zero(a_pred)
--        cdef complex[::1] a_corr = self.buffer_1d[2,:]
--        _zero(a_corr)
--        cdef complex[::1] b_pred = self.buffer_1d[3,:]
--        _zero(b_pred)
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        _zero_2d(d2)
--        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
--        _zero_3d(dd2)
--
--        cdef double dt_2 = dt*0.5
--        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
--        copy(vec, euler)
--        _axpy(1.0, a_pred, euler)
--        for i in range(self.num_ops):
--            _axpy(noise[i], d2[i,:], b_pred)
--            _axpy(-dt_2, dd2[i,i,:], a_pred)
--        _axpy(1.0, b_pred, euler)
--        copy(vec, out)
--        _axpy(0.5, a_pred, out)
--        _axpy(0.5, b_pred, out)
--        _zero_2d(d2)
--        _zero_3d(dd2)
--        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
--        for i in range(self.num_ops):
--            _axpy(noise[i]*0.5, d2[i,:], out)
--            _axpy(-dt_2, dd2[i,i,:], a_corr)
--        _axpy(0.5, a_corr, out)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void milstein(self, double t, double dt, double[:] noise,
--                    complex[::1] vec, complex[::1] out):
--        """
--        Chapter 10.3 Eq. (3.1)
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--
--        dV = -iH*V*dt + d1*dt + d2_i*dW_i
--             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
--        """
--        cdef int i, j, k
--        cdef double dw
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
--        _zero_2d(d2)
--        _zero_3d(dd2)
--        copy(vec,out)
--        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
--        for i in range(self.num_ops):
--            _axpy(noise[i],d2[i,:],out)
--        for i in range(self.num_ops):
--            for j in range(i, self.num_ops):
--                if (i == j):
--                    dw = (noise[i] * noise[i] - dt) * 0.5
--                else:
--                    dw = (noise[i] * noise[j])
--                _axpy(dw,dd2[i,j,:],out)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void milstein_imp(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out) except *:
--        """
--        Chapter 12.2 Eq. (2.9)
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        cdef int i, j, k
--        cdef double dw
--        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
--                                                          dtype=complex)
--        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
--                                                         dtype=complex)
--        cdef complex[::1] a = self.buffer_1d[0,:]
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
--        _zero(a)
--        _zero_2d(d2)
--        _zero_3d(dd2)
--        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
--        copy(vec, dvec)
--        _axpy(0.5, a, dvec)
--        for i in range(self.num_ops):
--            _axpy(noise[i], d2[i,:], dvec)
--        for i in range(self.num_ops):
--            for j in range(i, self.num_ops):
--                if (i == j):
--                    dw = (noise[i] * noise[i] - dt) * 0.5
--                else:
--                    dw = (noise[i] * noise[j])
--                _axpy(dw, dd2[i,j,:], dvec)
--        copy(dvec, guess)
--        _axpy(0.5, a, guess)
--        self.implicit(t+dt, dvec, out, guess)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void taylor15(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        """
--        Chapter 12.2 Eq. (2.18),
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        cdef complex[::1] a = self.buffer_1d[0, :]
--        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
--        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
--        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
--        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
--        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
--        cdef complex[::1] L0a = self.buffer_1d[1, :]
--        _zero(a)
--        _zero_2d(b)
--        _zero_3d(Lb)
--        _zero_2d(L0b)
--        _zero_2d(La)
--        _zero_4d(LLb)
--        _zero(L0a)
--        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
--
--        cdef int i,j,k
--        cdef double[::1] dz, dw
--        dw = np.empty(self.num_ops)
--        dz = np.empty(self.num_ops)
--        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
--        for i in range(self.num_ops):
--            dw[i] = noise[i]
--            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
--        copy(vec,out)
--        _axpy(1.0, a, out)
--        _axpy(0.5, L0a, out)
--
--        for i in range(self.num_ops):
--            _axpy(dw[i], b[i,:], out)
--            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
--            _axpy(dz[i], La[i,:], out)
--            _axpy(dw[i]-dz[i], L0b[i,:], out)
--            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
--                        LLb[i,i,i,:], out)
--            for j in range(i+1,self.num_ops):
--                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
--                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
--                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
--                for k in range(j+1,self.num_ops):
--                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out) except *:
--        """
--        Chapter 12.2 Eq. (2.18),
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        cdef complex[::1] a = self.buffer_1d[0, :]
--        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
--        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
--        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
--        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
--        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
--        cdef complex[::1] L0a = self.buffer_1d[1, :]
--        _zero(a)
--        _zero_2d(b)
--        _zero_3d(Lb)
--        _zero_2d(L0b)
--        _zero_2d(La)
--        _zero_4d(LLb)
--        _zero(L0a)
--        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
--                   dtype=complex)
--        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
--                  dtype=complex)
--        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
--
--        cdef int i,j,k
--        cdef double[::1] dz, dw
--        dw = np.empty(self.num_ops)
--        dz = np.empty(self.num_ops)
--        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
--        for i in range(self.num_ops):
--            dw[i] = noise[i]
--            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
--        copy(vec, vec_t)
--        _axpy(0.5, a, vec_t)
--        for i in range(self.num_ops):
--            _axpy(dw[i], b[i,:], vec_t)
--            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
--            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
--            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
--            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
--                        LLb[i,i,i,:], vec_t)
--            for j in range(i+1,self.num_ops):
--                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
--                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
--                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
--                for k in range(j+1,self.num_ops):
--                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
--        copy(vec_t, guess)
--        _axpy(0.5, a, guess)
--
--        self.implicit(t+dt, vec_t, out, guess)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void platen15(self, double t, double dt, double[:] noise,
--                    complex[::1] vec, complex[::1] out):
--        """
--        Chapter 11.2 Eq. (2.13)
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        cdef int i, j, k
--        cdef double sqrt_dt = np.sqrt(dt)
--        cdef double sqrt_dt_inv = 1./sqrt_dt
--        cdef double ddz, ddw, ddd
--        cdef double[::1] dz, dw
--        dw = np.empty(self.num_ops)
--        dz = np.empty(self.num_ops)
--        for i in range(self.num_ops):
--            dw[i] = noise[i]
--            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
--
--        cdef complex[::1] d1 = self.buffer_1d[0,:]
--        cdef complex[::1] d1p = self.buffer_1d[1,:]
--        cdef complex[::1] d1m = self.buffer_1d[2,:]
--        cdef complex[::1] V = self.buffer_1d[3,:]
--        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
--        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
--        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
--        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
--        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
--        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
--        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
--        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
--        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
--        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
--
--        _zero(d1)
--        _zero_2d(d2)
--        _zero_2d(dd2)
--        self.d1(t, vec, d1)
--        self.d2(t, vec, d2)
--        self.d2(t + dt, vec, dd2)
--        # Euler part
--        copy(vec,out)
--        _axpy(1., d1, out)
--        for i in range(self.num_ops):
--            _axpy(dw[i], d2[i,:], out)
--
--        _zero(V)
--        _axpy(1., vec, V)
--        _axpy(1./self.num_ops, d1, V)
--
--        _zero_2d(v2p)
--        _zero_2d(v2m)
--        for i in range(self.num_ops):
--            _axpy(1., V, v2p[i,:])
--            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
--            _axpy(1., V, v2m[i,:])
--            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
--
--        _zero_3d(p2p)
--        _zero_3d(p2m)
--        for i in range(self.num_ops):
--            _zero_2d(d2p)
--            _zero_2d(d2m)
--            self.d2(t, v2p[i,:], d2p)
--            self.d2(t, v2m[i,:], d2m)
--            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
--            _axpy( ddw, d2p[i,:], out)
--            _axpy(-ddw, d2m[i,:], out)
--            for j in range(self.num_ops):
--                _axpy(      1., v2p[i,:], p2p[i,j,:])
--                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
--                _axpy(      1., v2p[i,:], p2m[i,j,:])
--                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
--
--        _axpy(-0.5*(self.num_ops), d1, out)
--        for i in range(self.num_ops):
--            ddz = dz[i]*0.5/sqrt_dt  # 1.5
--            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
--            _zero(d1p)
--            _zero(d1m)
--            _zero_2d(d2m)
--            _zero_2d(d2p)
--            _zero_2d(d2pp)
--            _zero_2d(d2mm)
--            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
--            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
--            self.d2(t, v2p[i,:], d2p)
--            self.d2(t, v2m[i,:], d2m)
--            self.d2(t, p2p[i,i,:], d2pp)
--            self.d2(t, p2m[i,i,:], d2mm)
--
--            _axpy( ddz+0.25, d1p, out)
--            _axpy(-ddz+0.25, d1m, out)
--
--            _axpy((dw[i]-dz[i]), dd2[i,:], out)
--            _axpy((dz[i]-dw[i]), d2[i,:], out)
--
--            _axpy( ddd, d2pp[i,:], out)
--            _axpy(-ddd, d2mm[i,:], out)
--            _axpy(-ddd, d2p[i,:], out)
--            _axpy( ddd, d2m[i,:], out)
--
--            for j in range(self.num_ops):
--              ddw = 0.5*(dw[j]-dz[j]) # 1.5
--              _axpy(ddw, d2p[j,:], out)
--              _axpy(-2*ddw, d2[j,:], out)
--              _axpy(ddw, d2m[j,:], out)
--
--              if j>i:
--                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
--                _axpy( ddw, d2p[j,:], out)
--                _axpy(-ddw, d2m[j,:], out)
--
--                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
--                _zero_2d(d2pp)
--                _zero_2d(d2mm)
--                self.d2(t, p2p[j,i,:], d2pp)
--                self.d2(t, p2m[j,i,:], d2mm)
--                _axpy( ddw, d2pp[j,:], out)
--                _axpy(-ddw, d2mm[j,:], out)
--                _axpy(-ddw, d2p[j,:], out)
--                _axpy( ddw, d2m[j,:], out)
--
--                for k in range(j+1,self.num_ops):
--                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
--                    _axpy( ddw, d2pp[k,:], out)
--                    _axpy(-ddw, d2mm[k,:], out)
--                    _axpy(-ddw, d2p[k,:], out)
--                    _axpy( ddw, d2m[k,:], out)
--
--              if j<i:
--                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
--                _zero_2d(d2pp)
--                _zero_2d(d2mm)
--                self.d2(t, p2p[j,i,:], d2pp)
--                self.d2(t, p2m[j,i,:], d2mm)
--                _axpy( ddw, d2pp[j,:], out)
--                _axpy(-ddw, d2mm[j,:], out)
--                _axpy(-ddw, d2p[j,:], out)
--                _axpy( ddw, d2m[j,:], out)
--
--    @cython.wraparound(False)
--    @cython.boundscheck(False)
--    @cython.cdivision(True)
--    cdef void taylor20(self, double t, double dt, double[::1] noise,
--                           complex[::1] vec, complex[::1] out):
--        """
--        Chapter 10.5 Eq. (5.1),
--        Numerical Solution of Stochastic Differential Equations
--        By Peter E. Kloeden, Eckhard Platen
--        """
--        cdef double[::1] noises = np.empty(5)
--        cdef double dwn
--        self.order2noise.order2(noise,noises)
--        cdef complex[::1] a = self.buffer_1d[0, :]
--        cdef complex[::1] b = self.buffer_1d[1, :]
--        cdef complex[::1] Lb = self.buffer_1d[2, :]
--        cdef complex[::1] La = self.buffer_1d[3, :]
--        cdef complex[::1] L0b = self.buffer_1d[4, :]
--        cdef complex[::1] LLb = self.buffer_1d[5, :]
--        cdef complex[::1] L0a = self.buffer_1d[6, :]
--        cdef complex[::1] LLa = self.buffer_1d[7, :]
--        cdef complex[::1] LL0b = self.buffer_1d[8, :]
--        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
--        cdef complex[::1] LLLb = self.buffer_1d[10, :]
--        _zero(a)
--        _zero(b)
--        _zero(Lb)
--        _zero(La)
--        _zero(L0b)
--        _zero(LLb)
--        _zero(L0a)
--        _zero(LLa)
--        _zero(LL0b)
--        _zero(L0Lb)
--        _zero(LLLb)
--        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
--                           L0a, LLa, LL0b, L0Lb, LLLb)
--
--        copy(vec,out)
--        _axpy(1.0, a, out)
--
--        _axpy(noises[0], b, out)
--        dwn = noises[0]*noises[0]*0.5
--        _axpy(dwn, Lb, out)
--
--        _axpy(noises[1], La, out)
--        _axpy(noises[0]-noises[1], L0b, out)
--        dwn *= noises[0]*(1/3.)
--        _axpy(dwn, LLb, out)
--        _axpy(0.5, L0a, out)
--
--        _axpy(noises[2], L0Lb, out)
--        _axpy(noises[3], LL0b, out)
--        _axpy(noises[4], LLa, out)
--        dwn *= noises[0]*0.25
--        _axpy(dwn, LLLb, out)
--
--
--cdef class SSESolver(StochasticSolver):
--    """stochastic Schrodinger system"""
--    cdef QobjEvo L
--    cdef object c_ops
--    cdef object cpcd_ops
--    cdef object imp
--    cdef double tol, imp_t
--
--    def set_data(self, sso):
--        L = sso.LH
--        c_ops = sso.sops
--        self.l_vec = L.shape[0]
--        self.num_ops = len(c_ops)
--        self.L = L
--        self.c_ops = []
--        self.cpcd_ops = []
--        for i, op in enumerate(c_ops):
--            self.c_ops.append(op[0])
--            self.cpcd_ops.append(op[1])
--        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
--            self.tol = sso.tol
--            self.imp = LinearOperator( (self.l_vec,self.l_vec),
--                                      matvec=self.implicit_op, dtype=complex)
--
--    def implicit_op(self, vec):
--        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
--        self.d1(self.imp_t, vec, out)
--        cdef int i
--        _scale(-0.5,out)
--        _axpy(1.,vec,out)
--        return out
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
--        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
--        cdef int i
--        cdef complex e
--        cdef QobjEvo c_op
--        cdef complex[::1] temp = self.func_buffer_1d[0,:]
--        _zero(temp)
--        for i in range(self.num_ops):
--            c_op = self.cpcd_ops[i]
--            e = c_op.expect_data(t, _dense_wrap(vec))
--            _zero(temp)
--            c_op = self.c_ops[i]
--            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
--            _axpy(-0.125 * e * e * self.dt, vec, out)
--            _axpy(0.5 * e * self.dt, temp, out)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
--        cdef int i, k
--        cdef QobjEvo c_op
--        cdef complex expect
--        for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
--            c_op = self.cpcd_ops[i]
--            expect = c_op.expect_data(t, _dense_wrap(vec))
--            _axpy(-0.5*expect,vec,out[i,:])
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void derivatives(self, double t, int deg, complex[::1] vec,
--                          complex[::1] a, complex[:, ::1] b,
--                          complex[:, :, ::1] Lb, complex[:,::1] La,
--                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
--                          complex[::1] L0a):
--        """
--        combinaisons of a and b derivatives for taylor order 1.5
--        dY ~ a dt + bi dwi
--                                         deg   use        noise
--        b[i.:]       bi                   >=0   d2 euler   dwi
--        a[:]         a                    >=0   d1 euler   dt
--        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
--        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
--
--        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
--        La[i,:]      ba'                  >=2   taylor15   dzi
--        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
--        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
--        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
--        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
--        """
--        cdef int i, j, k, l
--        cdef double dt = self.dt
--        cdef QobjEvo c_op
--        cdef complex e, de_bb
--
--        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
--        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
--        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
--        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
--        _zero_3d(dde_bb)
--        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
--        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
--        cdef complex[::1] temp = self.func_buffer_1d[0,:]
--        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
--        _zero(temp)
--        _zero(temp2)
--        _zero_2d(Cvec)
--        _zero_3d(Cb)
--
--        # a b
--        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
--        for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
--            e = _dotc(vec,Cvec[i,:])
--            e_real[i] = e.real
--            _axpy(1., Cvec[i,:], b[i,:])
--            _axpy(-e_real[i], vec, b[i,:])
--            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
--            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
--
--        #Lb bb'
--        if deg >= 1:
--          for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            for j in range(self.num_ops):
--              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
--              for k in range(self.l_vec):
--                  temp[k] = conj(b[j,k])
--                  temp2[k] = 0.
--              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
--              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
--                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
--              _axpy(1., Cb[i,j,:], Lb[i,j,:])
--              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
--              _axpy(-de_b[i,j], vec, Lb[i,j,:])
--
--              for k in range(self.num_ops):
--                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
--                                  _dot(b[k,:], Cb[i,j,:]) + \
--                                  conj(_dotc(b[k,:], temp2)))*.5
--                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
--
--        #L0b La LLb
--        if deg >= 2:
--          for i in range(self.num_ops):
--              #ba'
--              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
--              for j in range(self.num_ops):
--                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
--                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
--                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
--                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
--
--              #ab' + db/dt + bbb"/2
--              c_op = self.c_ops[i]
--              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
--              for k in range(self.l_vec):
--                  temp[k] = conj(a[k])
--                  temp2[k] = 0.
--              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
--              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
--                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
--              _axpy(-e_real[i], a, L0b[i,:])
--              _axpy(-de_a[i], vec, L0b[i,:])
--
--              temp = np.zeros(self.l_vec, dtype=complex)
--              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
--              e = _dotc(vec,temp)
--              _axpy(1., temp, L0b[i,:])
--              _axpy(-e.real, vec, L0b[i,:])
--              _axpy(-1., b[i,:], L0b[i,:])
--
--              for j in range(self.num_ops):
--                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
--                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
--
--              #b(bb"+b'b')
--              for j in range(i,self.num_ops):
--                  for k in range(j, self.num_ops):
--                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
--                                  _dense_wrap(LLb[i,j,k,:]))
--                      for l in range(self.l_vec):
--                          temp[l] = conj(Lb[j,k,l])
--                          temp2[l] = 0.
--                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
--                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
--                               _dot(Lb[j,k,:], Cvec[i,:]) + \
--                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
--                               _dotc(vec, temp2)))*0.5
--                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
--                      _axpy(-de_bb, vec, LLb[i,j,k,:])
--                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
--                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
--                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
--
--        #da/dt + aa' + bba"
--        if deg == 2:
--          self.d1(t + dt, vec, L0a)
--          _axpy(-1.0, a, L0a)
--          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
--          for j in range(self.num_ops):
--              c_op = self.c_ops[j]
--              temp = np.zeros(self.l_vec, dtype=complex)
--              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
--              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
--              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
--              _axpy(e_real[j] * dt, temp, L0a[:])
--              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
--              for i in range(self.num_ops):
--                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
--                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
--                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
--                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
--                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
--                         complex[::1] vec, complex[::1] out):
--        cdef int k
--        cdef complex[::1] temp = self.func_buffer_1d[13,:]
--        for k in range(self.l_vec):
--            temp[k] = conj(vec[k])
--            out[k] = 0.
--        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void derivativesO2(self, double t, complex[::1] psi,
--                            complex[::1] a, complex[::1] b, complex[::1] Lb,
--                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
--                            complex[::1] L0a,
--                            complex[::1] LLa, complex[::1] LL0b,
--                            complex[::1] L0Lb, complex[::1] LLLb):
--        """
--        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
--        Use Stratonovich-Taylor expansion.
--        One one sc_ops
--        dY ~ a dt + bi dwi
--
--        b[:]     b                        d2 euler    dw
--        a[:]     a- Lb/2                  d1 euler    dt
--        Lb[:]    b'b                      milstein    dw^2/2
--        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
--        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
--        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
--        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
--
--        LLa[:]   ...                      taylor2.0   dwdt-dz
--        LL0b[:]  ...                      taylor2.0   dz
--        L0Lb[:]  ...                      taylor2.0   dw^3/6
--        LLLb[:]  ...                      taylor2.0   dt^2/2
--        """
--        cdef double dt = self.dt
--        cdef QobjEvo c_op = self.c_ops[0]
--        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
--        cdef complex de_a, dde_ba, de_La, de_L0b
--
--        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
--        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
--        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
--        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
--        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
--        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
--        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
--        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
--        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
--        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
--        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
--        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
--        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
--        _zero(Cpsi)
--        _zero(Cb)
--        _zero(CLb)
--        _zero(CLLb)
--        _zero(Ca)
--        _zero(CLa)
--        _zero(CL0b)
--
--        # b
--        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
--        e = _dotc(psi, Cpsi).real
--        _axpy(1., Cpsi, b)
--        _axpy(-e, psi, b)
--
--        # Lb
--        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
--        self._c_vec_conj(t, c_op, b, Cbc)
--        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
--                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
--        _axpy(1., Cb, Lb)
--        _axpy(-e, b, Lb)
--        _axpy(-de_b, psi, Lb)
--
--        # LLb = b'b'b + b"bb
--        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
--        self._c_vec_conj(t, c_op, Lb, CLbc)
--        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
--                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
--        _axpy(1, CLb, LLb)      # b'b'b
--        _axpy(-e, Lb, LLb)      # b'b'b
--        _axpy(-de_Lb, psi, LLb) # b'b'b
--        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
--        _axpy(-dde_bb, psi, LLb) # b"bb
--        _axpy(-de_b*2, b, LLb)   # b"bb
--
--        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
--        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
--        self._c_vec_conj(t, c_op, LLb, CLLbc)
--        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
--                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
--        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
--                    conj(_dotc(b, CLbc)))*.5
--        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
--        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
--        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
--        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
--        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
--        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
--        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
--
--        # a
--        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
--        _axpy(-0.5 * e * e * dt, psi, a)
--        _axpy(e * dt, Cpsi, a)
--        _axpy(-0.5 * dt, Lb, a)
--
--        #La
--        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
--        _axpy(-0.5 * e * e * dt, b, La)
--        _axpy(-e * de_b * dt, psi, La)
--        _axpy(e * dt, Cb, La)
--        _axpy(de_b * dt, Cpsi, La)
--        _axpy(-0.5 * dt, LLb, La)
--
--        #LLa
--        _axpy(-2 * e * de_b * dt, b, LLa)
--        _axpy(-de_b * de_b * dt, psi, LLa)
--        _axpy(-e * dde_bb * dt, psi, LLa)
--        _axpy( 2 * de_b * dt, Cb, LLa)
--        _axpy( dde_bb * dt, Cpsi, LLa)
--
--        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
--        _axpy(-de_Lb * e * dt, psi, LLa)
--        _axpy(-0.5 * e * e * dt, Lb, LLa)
--        _axpy( de_Lb * dt, Cpsi, LLa)
--        _axpy( e * dt, CLb, LLa)
--
--        _axpy(-0.5 * dt, LLLb, LLa)
--
--        # L0b = b'a
--        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
--        self._c_vec_conj(t, c_op, a, Cac)
--        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
--                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
--        _axpy(1.0, Ca, L0b)
--        _axpy(-e, a, L0b)
--        _axpy(-de_a, psi, L0b)
--
--        # LL0b = b"ba + b'La
--        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
--                    conj(_dotc(b, Cac)))*.5
--        _axpy(-dde_ba, psi, LL0b)
--        _axpy(-de_a, b, LL0b)
--        _axpy(-de_b, a, LL0b)
--        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
--        self._c_vec_conj(t, c_op, La, CLac)
--        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
--                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
--        _axpy(1., CLa, LL0b)
--        _axpy(-e, La, LL0b)
--        _axpy(-de_La, psi, LL0b)
--
--        # L0Lb = b"ba + b'L0b
--        _axpy(-dde_ba, psi, L0Lb)
--        _axpy(-de_a, b, L0Lb)
--        _axpy(-de_b, a, L0Lb)
--        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
--        self._c_vec_conj(t, c_op, L0b, CL0bc)
--        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
--                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
--        _axpy(1., CL0b, L0Lb)
--        _axpy(-e, L0b, L0Lb)
--        _axpy(-de_L0b, psi, L0Lb)
--
--        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
--        self.d1(t + dt, psi, L0a) # da/dt
--        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
--        _axpy(-1.0, a, L0a)        # da/dt
--        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
--        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
--        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
--        _axpy(e * dt, Ca, L0a)              # a'_a_
--        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
--        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
--
--    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
--                                        complex[::1] out,
--                                        np.ndarray[complex, ndim=1] guess) except *:
--        # np.ndarray to memoryview is OK but not the reverse
--        # scipy function only take np array, not memoryview
--        self.imp_t = t
--        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
--                                          tol=self.tol, atol=1e-12)
--        cdef int i
--        copy(spout, out)
--
--
--cdef class SMESolver(StochasticSolver):
--    """stochastic master equation system"""
--    cdef QobjEvo L
--    cdef object imp
--    cdef object c_ops
--    cdef int N_root
--    cdef double tol
--
--    def set_data(self, sso):
--        L = sso.LH
--        c_ops = sso.sops
--        self.l_vec = L.shape[0]
--        self.num_ops = len(c_ops)
--        self.L = L
--        self.c_ops = []
--        self.N_root = np.sqrt(self.l_vec)
--        for i, op in enumerate(c_ops):
--            self.c_ops.append(op)
--        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
--            self.tol = sso.tol
--            self.imp = sso.imp
--
--    cdef void _normalize_inplace(self, complex[::1] vec):
--        _normalize_rho(vec)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef complex expect(self, complex[::1] rho):
--        cdef complex e = 0.
--        cdef int k
--        for k in range(self.N_root):
--            e += rho[k*(self.N_root+1)]
--        return e
--
--    @cython.boundscheck(False)
--    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
--        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
--        cdef int i, k
--        cdef QobjEvo c_op
--        cdef complex expect
--        for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
--            expect = self.expect(out[i,:])
--            _axpy(-expect, rho, out[i,:])
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void derivatives(self, double t, int deg, complex[::1] rho,
--                          complex[::1] a, complex[:, ::1] b,
--                          complex[:, :, ::1] Lb, complex[:,::1] La,
--                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
--                          complex[::1] L0a):
--        """
--        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
--        dY ~ a dt + bi dwi
--                                         deg   use        noise
--        b[i.:]       bi                   >=0   d2 euler   dwi
--        a[:]         a                    >=0   d1 euler   dt
--        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
--        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
--        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
--        La[i,:]      ba'                  >=2   taylor15   dzi
--        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
--        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
--        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
--        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
--        """
--        cdef int i, j, k
--        cdef QobjEvo c_op
--        cdef QobjEvo c_opj
--        cdef complex trApp, trAbb, trAa
--        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
--        cdef complex[:, ::1] trAb = self.expect_buffer_2d
--        cdef complex[::1] temp = self.func_buffer_1d[0,:]
--        #_zero(temp)
--
--        # a
--        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
--
--        # b
--        for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            # bi
--            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
--            trAp[i] = self.expect(b[i,:])
--            _axpy(-trAp[i], rho, b[i,:])
--
--        # Libj = bibj', i<=j
--        # sc_ops must commute (Libj = Ljbi)
--        if deg >= 1:
--          for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            for j in range(i, self.num_ops):
--                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
--                trAb[i,j] = self.expect(Lb[i,j,:])
--                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
--                _axpy(-trAb[i,j], rho, Lb[i,j,:])
--
--        # L0b La LLb
--        if deg >= 2:
--          for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            # Lia = bia'
--            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
--
--            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
--            # db/dt
--            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
--            trApp = self.expect(L0b[i,:])
--            _axpy(-trApp, rho, L0b[i,:])
--            _axpy(-1, b[i,:], L0b[i,:])
--            # ab'
--            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
--            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
--            trAa = self.expect(temp)
--            _axpy(1., temp, L0b[i,:])
--            _axpy(-trAp[i], a[:], L0b[i,:])
--            _axpy(-trAa, rho, L0b[i,:])
--            # bbb" : trAb[i,j] only defined for j>=i
--            for j in range(i):
--                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
--            for j in range(i,self.num_ops):
--                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
--
--            # LLb
--            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
--            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
--            for j in range(i,self.num_ops):
--              for k in range(j,self.num_ops):
--                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
--                trAbb = self.expect(LLb[i,j,k,:])
--                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
--                _axpy(-trAbb, rho, LLb[i,j,k,:])
--                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
--                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
--
--        # L0a = a'a + da/dt + bba"/2  (a" = 0)
--        if deg == 2:
--            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
--            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
--            _axpy(-1, a, L0a)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void derivativesO2(self, double t, complex[::1] rho,
--                            complex[::1] a, complex[::1] b, complex[::1] Lb,
--                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
--                            complex[::1] L0a,
--                            complex[::1] LLa, complex[::1] LL0b,
--                            complex[::1] L0Lb, complex[::1] LLLb):
--        """
--        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
--        Use Stratonovich-Taylor expansion.
--        One one sc_ops
--        dY ~ a dt + bi dwi
--
--        b[:]     b                        d2 euler    dw
--        a[:]     a- Lb/2                  d1 euler    dt
--        Lb[:]    b'b                      milstein    dw^2/2
--        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
--        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
--        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
--        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
--
--        LLa[:]   ...                      taylor2.0   dwdt-dz
--        LL0b[:]  ...                      taylor2.0   dz
--        L0Lb[:]  ...                      taylor2.0   dw^3/6
--        LLLb[:]  ...                      taylor2.0   dt^2/2
--        """
--        cdef int i, j, k
--        cdef QobjEvo c_op = self.c_ops[0]
--        cdef QobjEvo c_opj
--        cdef complex trAp, trApt
--        cdef complex trAb, trALb, trALLb
--        cdef complex trAa, trALa
--        cdef complex trAL0b
--
--        cdef complex[::1] temp = self.func_buffer_1d[0,:]
--        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
--
--        # b
--        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
--        trAp = self.expect(b)
--        _axpy(-trAp, rho, b)
--
--        # Lb = b'b
--        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
--        trAb = self.expect(Lb)
--        _axpy(-trAp, b, Lb)
--        _axpy(-trAb, rho, Lb)
--
--        # LLb = b'Lb+b"bb
--        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
--        trALb = self.expect(LLb)
--        _axpy(-trAp, Lb, LLb)
--        _axpy(-trALb, rho, LLb)
--        _axpy(-trAb*2, b, LLb)
--
--        # LLLb = b'LLb + 3 b"bLb + b"'bbb
--        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
--        trALLb = self.expect(LLLb)
--        _axpy(-trAp, LLb, LLLb)
--        _axpy(-trALLb, rho, LLLb)
--        _axpy(-trALb*3, b, LLLb)
--        _axpy(-trAb*3, Lb, LLLb)
--
--        # _a_ = a - Lb/2
--        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
--        _axpy(-0.5*self.dt, Lb, a)
--
--        # L_a_ = ba' - LLb/2
--        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
--        _axpy(-0.5*self.dt, LLb, La)
--
--        # LL_a_ = b(La)' - LLLb/2
--        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
--        _axpy(-0.5*self.dt, LLLb, LLa)
--
--        # _L0_b = b'(_a_)
--        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
--        trAa = self.expect(L0b)
--        _axpy(-trAp, a, L0b)
--        _axpy(-trAa, rho, L0b)
--
--        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
--        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
--        trAL0b = self.expect(L0Lb)
--        _axpy(-trAp, L0b, L0Lb)
--        _axpy(-trAL0b, rho, L0Lb)
--        _axpy(-trAa, b, L0Lb)
--        _axpy(-trAb, a, L0Lb)
--
--        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
--        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
--        trAL0b = self.expect(LL0b)
--        _axpy(-trAp, La, LL0b)
--        _axpy(-trAL0b, rho, LL0b)
--        _axpy(-trAa, b, LL0b)
--        _axpy(-trAb, a, LL0b)
--
--        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
--        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
--        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
--        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
--        _axpy(-1, a, L0a)
--        _axpy(-self.dt*0.5, L0Lb, L0a)
--
--
--    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
--                                        complex[::1] out,
--                                        np.ndarray[complex, ndim=1] guess) except *:
--        # np.ndarray to memoryview is OK but not the reverse
--        # scipy function only take np array, not memoryview
--        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
--                                          dvec, x0=guess,
--                                          tol=self.tol, atol=1e-12)
--        cdef int i
--        copy(spout,out)
--
--
--cdef class PcSSESolver(StochasticSolver):
--    """photocurrent for Schrodinger equation"""
--    cdef QobjEvo L
--    cdef object c_ops
--    cdef object cdc_ops
--
--    def set_data(self, sso):
--        L = sso.LH
--        c_ops = sso.sops
--        self.l_vec = L.shape[0]
--        self.num_ops = len(c_ops)
--        self.L = L
--        self.c_ops = []
--        self.cdc_ops = []
--        for i, op in enumerate(c_ops):
--            self.c_ops.append(op[0])
--            self.cdc_ops.append(op[1])
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void photocurrent(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        cdef QobjEvo c_op
--        cdef double rand
--        cdef int i, which = -1
--        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
--        cdef complex[::1] d2 = self.buffer_1d[0,:]
--
--        copy(vec, out)
--        self.d1(t, vec, out)
--        rand = np.random.rand()
--        for i in range(self.num_ops):
--            c_op = self.cdc_ops[i]
--            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
--            if expects[i].real * dt >= 1e-15:
--                rand -= expects[i].real *dt
--            if rand < 0:
--                which = i
--                noise[i] = 1.
--                break
--
--        if which >= 0:
--            self.collapse(t, which, expects[which].real, vec, d2)
--            _axpy(1, d2, out)
--            _axpy(-1, vec, out)
--
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        cdef QobjEvo c_op
--        cdef double expect
--        cdef int i, which=0, num_coll=0, did_collapse=0
--        cdef complex[::1] tmp = self.buffer_1d[0,:]
--        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
--        cdef np.ndarray[int, ndim=1] colls
--
--        # Collapses are computed first
--        for i in range(self.num_ops):
--            c_op = self.cdc_ops[i]
--            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
--            if expects[i].real > 0:
--                did_collapse = np.random.poisson(expects[i].real * dt)
--                num_coll += did_collapse
--                if did_collapse:
--                    which = i
--                noise[i] = did_collapse * 1.
--            else:
--                noise[i] = 0.
--
--        if num_coll == 0:
--            pass
--        elif num_coll == 1:
--            # Do one collapse
--            self.collapse(t, which, expects[which].real, vec, out)
--            copy(out, vec)
--        elif num_coll and noise[which] == num_coll:
--            # Do many collapse of one sc_ops.
--            # Recompute the expectation value, but only to check for zero.
--            c_op = self.cdc_ops[which]
--            for i in range(num_coll):
--                expect = c_op.expect_data(t, _dense_wrap(vec)).real
--                if expect * dt >= 1e-15:
--                    self.collapse(t, which, expect, vec, out)
--                    copy(out,vec)
--        elif num_coll >= 2:
--            # 2 or more collapses of different operators
--            # Ineficient, should be rare
--            coll = []
--            for i in range(self.num_ops):
--                coll += [i]*int(noise[i])
--            np.random.shuffle(coll)
--            for i in coll:
--                c_op = self.cdc_ops[i]
--                expect = c_op.expect_data(t, _dense_wrap(vec)).real
--                if expect * dt >= 1e-15:
--                    self.collapse(t, i, expect, vec, out)
--                    copy(out,vec)
--        copy(vec,tmp)
--        copy(vec,out)
--        self.d1(t, vec, tmp)
--        self.d1(t+dt, tmp, out)
--        _scale(0.5, out)
--        _axpy(0.5, tmp, out)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
--        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
--        cdef int i
--        cdef complex e
--        cdef QobjEvo c_op
--        cdef complex[::1] temp = self.func_buffer_1d[0,:]
--        for i in range(self.num_ops):
--            _zero(temp)
--            c_op = self.c_ops[i]
--            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
--            e = _dznrm2(temp)
--            _axpy(0.5 * e * e * self.dt, vec, out)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
--        cdef int i
--        cdef QobjEvo c_op
--        cdef complex expect
--        for i in range(self.num_ops):
--            c_op = self.c_ops[i]
--            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
--            expect = _dznrm2(out[i,:])
--            if expect.real >= 1e-15:
--                _zscale(1/expect, out[i,:])
--            else:
--                _zero(out[i,:])
--            _axpy(-1, vec, out[i,:])
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void collapse(self, double t, int which, double expect,
--                       complex[::1] vec, complex[::1] out):
--        cdef QobjEvo c_op
--        c_op = self.c_ops[which]
--        _zero(out)
--        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
--        _zscale(1/expect, out)
--
--
--cdef class PcSMESolver(StochasticSolver):
--    """photocurrent for master equation"""
--    cdef QobjEvo L
--    cdef object cdcr_cdcl_ops
--    cdef object cdcl_ops
--    cdef object clcdr_ops
--    cdef int N_root
--
--    def set_data(self, sso):
--        L = sso.LH
--        c_ops = sso.sops
--        self.l_vec = L.shape[0]
--        self.num_ops = len(c_ops)
--        self.L = L
--        self.cdcr_cdcl_ops = []
--        self.cdcl_ops = []
--        self.clcdr_ops = []
--        self.N_root = np.sqrt(self.l_vec)
--        for i, op in enumerate(c_ops):
--            self.cdcr_cdcl_ops.append(op[0])
--            self.cdcl_ops.append(op[1])
--            self.clcdr_ops.append(op[2])
--
--    cdef void _normalize_inplace(self, complex[::1] vec):
--        _normalize_rho(vec)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void photocurrent(self, double t, double dt,  double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        cdef QobjEvo c_op
--        cdef double rand
--        cdef int i, which = -1
--        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
--        cdef complex[::1] d2 = self.buffer_1d[0,:]
--
--        copy(vec, out)
--        self.d1(t, vec, out)
--        rand = np.random.rand()
--        for i in range(self.num_ops):
--            c_op = self.clcdr_ops[i]
--            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
--            if expects[i].real * dt >= 1e-15:
--                rand -= expects[i].real *dt
--            if rand < 0:
--                which = i
--                noise[i] = 1.
--                break
--
--        if which >= 0:
--            self.collapse(t, which, expects[which].real, vec, d2)
--            _axpy(1, d2, out)
--            _axpy(-1, vec, out)
--
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        cdef QobjEvo c_op
--        cdef int i, which, num_coll=0, did_collapse
--        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
--        cdef complex[::1] tmp = self.buffer_1d[0,:]
--        cdef double expect
--        cdef np.ndarray[int, ndim=1] colls
--
--        # Collapses are computed first
--        for i in range(self.num_ops):
--            c_op = self.clcdr_ops[i]
--            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
--            if expects[i].real > 0:
--                did_collapse = np.random.poisson(expects[i].real* dt)
--                num_coll += did_collapse
--                if did_collapse:
--                    which = i
--                noise[i] = did_collapse * 1.
--            else:
--                noise[i] = 0.
--
--        if num_coll == 0:
--            pass
--        elif num_coll == 1:
--            # Do one collapse
--            self.collapse(t, which, expects[which].real, vec, out)
--            copy(out,vec)
--        elif noise[which] == num_coll:
--            # Do many collapse of one sc_ops.
--            # Recompute the expectation value, but only to check for zero.
--            c_op = self.clcdr_ops[which]
--            for i in range(num_coll):
--                expect = c_op.expect_data(t, _dense_wrap(vec)).real
--                if expect * dt >= 1e-15:
--                    self.collapse(t, which, expect, vec, out)
--                    copy(out,vec)
--        elif num_coll >= 2:
--            # 2 or more collapses of different operators
--            # Ineficient, should be rare
--            coll = []
--            for i in range(self.num_ops):
--                coll += [i] * int(noise[i])
--            np.random.shuffle(coll)
--            for i in coll:
--                c_op = self.clcdr_ops[i]
--                expect = c_op.expect_data(t, _dense_wrap(vec)).real
--                if expect * dt >= 1e-15:
--                    self.collapse(t, i, expect, vec, out)
--                    copy(out,vec)
--
--        copy(vec,tmp)
--        copy(vec,out)
--        self.d1(t, vec, tmp)
--        self.d1(t+dt, tmp, out)
--        _scale(0.5, out)
--        _axpy(0.5, tmp, out)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef complex expect(self, complex[::1] rho):
--        cdef complex e = 0.
--        cdef int k
--        for k in range(self.N_root):
--            e += rho[k*(self.N_root+1)]
--        return e
--
--    @cython.boundscheck(False)
--    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
--        cdef int i
--        cdef QobjEvo c_op
--        cdef complex[::1] crho = self.func_buffer_1d[0,:]
--        cdef complex expect
--        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
--        for i in range(self.num_ops):
--            c_op = self.cdcr_cdcl_ops[i]
--            _zero(crho)
--            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
--            expect = self.expect(crho)
--            _axpy(0.5*expect* self.dt, rho, out)
--            _axpy(-0.5* self.dt, crho, out)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
--        cdef int i
--        cdef QobjEvo c_op
--        cdef complex expect
--        for i in range(self.num_ops):
--            c_op = self.clcdr_ops[i]
--            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
--            expect = self.expect(out[i,:])
--            if expect.real >= 1e-15:
--                _zscale((1.+0j)/expect, out[i,:])
--            else:
--                _zero(out[i,:])
--            _axpy(-1, rho, out[i,:])
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef void collapse(self, double t, int which, double expect,
--                       complex[::1] vec, complex[::1] out):
--        cdef QobjEvo c_op
--        c_op = self.clcdr_ops[which]
--        _zero(out)
--        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
--        _zscale(1./expect, out)
--
--cdef class PmSMESolver(StochasticSolver):
--    """positive map for master equation"""
--    cdef object L
--    cdef QobjEvo pp_ops
--    cdef QobjEvo preLH
--    cdef QobjEvo postLH
--    cdef object sops
--    cdef object preops
--    cdef object postops
--    cdef object preops2
--    cdef object postops2
--    cdef int N_root
--
--    def set_data(self, sso):
--        c_ops = sso.sops
--        self.l_vec = sso.pp.shape[0]
--        self.num_ops = len(c_ops)
--        self.preLH = sso.preLH
--        self.postLH = sso.postLH
--        self.pp_ops = sso.pp
--        self.sops = [op for op in sso.sops]
--        self.preops = [op for op in sso.preops]
--        self.postops = [op for op in sso.postops]
--        self.preops2 = [op for op in sso.preops2]
--        self.postops2 = [op for op in sso.postops2]
--        self.N_root = np.sqrt(self.l_vec)
--
--    cdef void _normalize_inplace(self, complex[::1] vec):
--        _normalize_rho(vec)
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    cdef void rouchon(self, double t, double dt, double[:] noise,
--                           complex[::1] vec, complex[::1] out):
--        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
--        cdef complex[::1] temp = self.buffer_1d[0,:]
--        cdef complex[::1] temp2 = self.buffer_1d[1,:]
--        cdef int i, j, k
--        cdef QobjEvo c_op, c_opj
--        cdef complex ddw, tr
--        _zero(out)
--        _zero(temp)
--        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
--        for i in range(self.num_ops):
--            c_op = self.sops[i]
--            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
--            c_op = self.preops[i]
--            _zero(temp2)
--            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
--            _axpy(dy[i], temp2, temp)
--
--        k = 0
--        for i in range(self.num_ops):
--            for j in range(i, self.num_ops):
--                c_op = self.preops2[k]
--                if i == j:
--                    ddw = (dy[i]*dy[j] - dt) *0.5
--                else:
--                    ddw = (dy[i]*dy[j])
--
--                _zero(temp2)
--                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
--                _axpy(ddw, temp2, temp)
--                k += 1
--
--        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
--        for i in range(self.num_ops):
--            dy[i] = conj(dy[i])
--            c_op = self.postops[i]
--            _zero(temp2)
--            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
--            _axpy(dy[i], temp2, out)
--
--        k = 0
--        for i in range(self.num_ops):
--            for j in range(i, self.num_ops):
--                c_op = self.postops2[k]
--                if i == j:
--                    ddw = (dy[i]*dy[j] - dt) *0.5
--                else:
--                    ddw = (dy[i]*dy[j])
--                _zero(temp2)
--                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
--                _axpy(ddw, temp2, out)
--                k += 1
--
--        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
--        tr = self.expect(out)
--        _zscale(1./tr, out)
--
--
--    @cython.boundscheck(False)
--    @cython.wraparound(False)
--    @cython.cdivision(True)
--    cdef complex expect(self, complex[::1] rho):
--        cdef complex e = 0.
--        cdef int k
--        for k in range(self.N_root):
--            e += rho[k*(self.N_root+1)]
--        return e
--
--
--cdef class GenericSSolver(StochasticSolver):
--    """support for user defined system"""
--    cdef object d1_func, d2_func
--
--    def set_data(self, sso):
--        self.l_vec = sso.rho0.shape[0]
--        self.num_ops = len(sso.sops)
--        self.d1_func = sso.d1
--        self.d2_func = sso.d2
--
--
--    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
--        cdef np.ndarray[complex, ndim=1] in_np
--        cdef np.ndarray[complex, ndim=1] out_np
--        in_np = np.zeros((self.l_vec, ), dtype=complex)
--        copy(rho, in_np)
--        out_np = self.d1_func(t, in_np)
--        _axpy(self.dt, out_np, out) # d1 is += and * dt
--
--    @cython.boundscheck(False)
--    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
--        cdef np.ndarray[complex, ndim=1] in_np
--        cdef np.ndarray[complex, ndim=2] out_np
--        cdef int i
--        in_np = np.zeros((self.l_vec, ), dtype=complex)
--        copy(rho, in_np)
--        out_np = self.d2_func(t, in_np)
--        for i in range(self.num_ops):
--            copy(out_np[i,:], out[i,:])
-+#cython: language_level=3
-+
-+import numpy as np
-+cimport numpy as np
-+cimport cython
-+from cpython.exc cimport PyErr_CheckSignals
-+from libc.math cimport fabs
-+from qutip.core.cy.qobjevo cimport QobjEvo
-+from .. import Qobj, unstack_columns
-+import scipy.sparse as sp
-+from scipy.sparse.linalg import LinearOperator
-+from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
-+from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
-+
-+from qutip.core.data cimport dense, Dense
-+import qutip.core.data as _data
-+
-+cdef extern from "<complex>" namespace "std" nogil:
-+    double complex conj(double complex x)
-+
-+cdef int ZERO=0
-+cdef double DZERO=0
-+cdef complex ZZERO=0j
-+cdef int ONE=1
-+
-+"""Some of blas wrapper"""
-+@cython.boundscheck(False)
-+cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
-+    """ y += a*x"""
-+    cdef int l = x.shape[0]
-+    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void copy(complex[::1] x, complex[::1] y):
-+    """ y = x """
-+    cdef int l = x.shape[0]
-+    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef complex _dot(complex[::1] x, complex[::1] y):
-+    """ = x_i * y_i """
-+    cdef int l = x.shape[0]
-+    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef complex _dotc(complex[::1] x, complex[::1] y):
-+    """ = conj(x_i) * y_i """
-+    cdef int l = x.shape[0]
-+    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef double _dznrm2(complex[::1] vec):
-+    """ = sqrt( x_i**2 ) """
-+    cdef int l = vec.shape[0]
-+    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void _scale(double a, complex[::1] x):
-+    """ x *= a """
-+    cdef int l = x.shape[0]
-+    zdscal(&l, &a, <complex*>&x[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void _zscale(complex a, complex[::1] x):
-+    """ x *= a """
-+    cdef int l = x.shape[0]
-+    zscal(&l, &a, <complex*>&x[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void _zero(complex[::1] x):
-+    """ x *= 0 """
-+    cdef int l = x.shape[0]
-+    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void _zero_2d(complex[:,::1] x):
-+    """ x *= 0 """
-+    cdef int l = x.shape[0]*x.shape[1]
-+    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void _zero_3d(complex[:,:,::1] x):
-+    """ x *= 0 """
-+    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
-+    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
-+
-+@cython.boundscheck(False)
-+cdef void _zero_4d(complex[:,:,:,::1] x):
-+    """ x *= 0 """
-+    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
-+    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
-+
-+@cython.boundscheck(False)
-+@cython.initializedcheck(False)
-+cdef Dense _dense_wrap(double complex [::1] x):
-+    return dense.wrap(&x[0], x.shape[0], 1)
-+
-+# %%%%%%%%%%%%%%%%%%%%%%%%%
-+# functions for ensuring that the states stay physical
-+@cython.cdivision(True)
-+@cython.boundscheck(False)
-+cdef void _normalize_inplace(complex[::1] vec):
-+    """ make norm of vec equal to 1"""
-+    cdef int l = vec.shape[0]
-+    cdef double norm = 1.0/_dznrm2(vec)
-+    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-+
-+# to move eventually, 10x faster than scipy's norm.
-+@cython.cdivision(True)
-+@cython.boundscheck(False)
-+def normalize_inplace(complex[::1] vec):
-+    """ make norm of vec equal to 1"""
-+    cdef int l = vec.shape[0]
-+    cdef double norm = 1.0/_dznrm2(vec)
-+    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-+    return fabs(norm-1)
-+
-+@cython.cdivision(True)
-+@cython.boundscheck(False)
-+cdef void _normalize_rho(complex[::1] rho):
-+    """ Ensure that the density matrix trace is one and
-+    that the composing states are normalized.
-+    """
-+    cdef int l = rho.shape[0]
-+    cdef int N = np.sqrt(l)
-+    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
-+    cdef complex[::1,:] eivec
-+    cdef double[::1] eival = np.zeros(N)
-+    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
-+
-+    _zero(rho)
-+    cdef int i, j, k
-+    cdef double sum
-+
-+    sum = 0.
-+    for i in range(N):
-+        _normalize_inplace(eivec[:,i])
-+        if eival[i] < 0:
-+            eival[i] = 0.
-+        sum += eival[i]
-+    if sum != 1.:
-+        for i in range(N):
-+            eival[i] /= sum
-+
-+    for i in range(N):
-+        for j in range(N):
-+            for k in range(N):
-+                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
-+
-+# Available solvers:
-+cpdef enum Solvers:
-+  # order 0.5
-+  EULER_SOLVER           =  50
-+  # order 0.5 strong, 1.0 weak?
-+  PC_SOLVER              = 101
-+  PC_2_SOLVER            = 104
-+  # order 1.0
-+  PLATEN_SOLVER          = 100
-+  MILSTEIN_SOLVER        = 102
-+  MILSTEIN_IMP_SOLVER    = 103
-+  # order 1.5
-+  EXPLICIT1_5_SOLVER     = 150
-+  TAYLOR1_5_SOLVER       = 152
-+  TAYLOR1_5_IMP_SOLVER   = 153
-+  # order 2.0
-+  TAYLOR2_0_SOLVER       = 202
-+
-+  # Special solvers
-+  PHOTOCURRENT_SOLVER    =  60
-+  PHOTOCURRENT_PC_SOLVER = 110
-+  ROUCHON_SOLVER         = 120
-+
-+  # For initialisation
-+  SOLVER_NOT_SET         =   0
-+
-+
-+cdef class TaylorNoise:
-+    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
-+    Complex enough that I fell it should be kept separated from the main solver.
-+    """
-+    cdef:
-+      int p
-+      double rho, alpha
-+      double aFactor, bFactor
-+      double BFactor, CFactor
-+      double dt, dt_sqrt
-+
-+    @cython.cdivision(True)
-+    def __init__(self, int p, double dt):
-+        self.p = p
-+        self.dt = dt
-+        self.dt_sqrt = dt**.5
-+        cdef double pi = np.pi
-+        cdef int i
-+
-+        cdef double rho = 0.
-+        for i in range(1,p+1):
-+            rho += (i+0.)**-2
-+        rho = 1./3.-2*rho/(pi**2)
-+        self.rho = (rho)**.5
-+        self.aFactor = -(2)**.5/pi
-+
-+        cdef double alpha = 0.
-+        for i in range(1,p+1):
-+            alpha += (i+0.)**-4
-+        alpha = pi/180-alpha/(2*pi**2)/pi
-+        self.alpha = (alpha)**.5
-+        self.bFactor = (0.5)**.5/pi**2
-+
-+        self.BFactor = 1/(4*pi**2)
-+        self.CFactor = -1/(2*pi**2)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cpdef void order2(self, double[::1] noise, double[::1] dws):
-+        cdef int p = self.p
-+        cdef int r, l
-+        cdef double s = 1/6.
-+        cdef double a = 0
-+        cdef double b = 0
-+        cdef double AA = 0
-+        cdef double BB = 0
-+        cdef double CC = 0
-+
-+        for r in range(p):
-+            a += noise[3+r]/(r+1.)
-+            b += noise[3+r+p]/(r+1.)/(r+1.)
-+            BB += (1/(r+1.)/(r+1.)) *\
-+                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
-+            for l in range(p):
-+                if r != l:
-+                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
-+                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
-+                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
-+
-+        a = self.aFactor * a + self.rho * noise[1]
-+        b = self.bFactor * b + self.alpha * noise[2]
-+        AA = 0.25*a*a
-+        BB *= self.BFactor
-+        CC *= self.CFactor
-+
-+        dws[0] = noise[0]                       # dw
-+        dws[1] = 0.5*(noise[0]+a)               # dz
-+        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
-+        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
-+        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
-+
-+
-+cdef class StochasticSolver:
-+    """ stochastic solver class base
-+    Does most of the initialisation, drive the simulation and contain the
-+    stochastic integration algorythm that do not depend on the physics.
-+
-+    This class is not to be used as is, the function computing the evolution's
-+    derivative are specified in it's child class which define the deterministic
-+    and stochastic contributions.
-+
-+    PYTHON METHODS:
-+    set_solver:
-+      Receive the data for the integration.
-+      Prepare buffers
-+
-+    cy_sesolve_single_trajectory:
-+      Run one trajectory.
-+
-+
-+    INTERNAL METHODS
-+    make_noise:
-+      create the stochastic noise
-+    run:
-+      evolution between timestep (substep)
-+    solver's method:
-+      stochastic integration algorithm
-+        euler
-+        milstein
-+        taylor
-+        ...
-+
-+    CHILD:
-+    SSESolver: stochastic schrodinger evolution
-+    SMESolver: stochastic master evolution
-+    PcSSESolver: photocurrent stochastic schrodinger evolution
-+    PcSMESolver: photocurrent stochastic master evolution
-+    PmSMESolver: positive map stochastic master evolution
-+    GenericSSolver: general (user defined) stochastic evolution
-+
-+    CHILD METHODS:
-+    set_data:
-+      Read data about the system
-+    d1:
-+      deterministic part
-+    d2:
-+      non-deterministic part
-+    derivatives:
-+      d1, d2 and their derivatives up to dt**1.5
-+      multiple sc_ops
-+    derivativesO2:
-+      d1, d2 and there derivatives up to dt**2.0
-+      one sc_ops
-+    """
-+    cdef int l_vec, num_ops
-+    cdef Solvers solver
-+    cdef int num_step, num_substeps, num_dw
-+    cdef int normalize
-+    cdef double dt
-+    cdef int noise_type
-+    cdef object custom_noise
-+    cdef double[::1] dW_factor
-+    cdef unsigned int[::1] seed
-+    cdef object sso
-+
-+    # buffer to not redo the initialisation at each substep
-+    cdef complex[:, ::1] buffer_1d
-+    cdef complex[:, :, ::1] buffer_2d
-+    cdef complex[:, :, :, ::1] buffer_3d
-+    cdef complex[:, :, :, ::1] buffer_4d
-+    cdef complex[:, ::1] expect_buffer_1d
-+    cdef complex[:, ::1] expect_buffer_2d
-+    cdef complex[:, :, ::1] expect_buffer_3d
-+    cdef complex[:, ::1] func_buffer_1d
-+    cdef complex[:, ::1] func_buffer_2d
-+    cdef complex[:, :, ::1] func_buffer_3d
-+
-+    cdef TaylorNoise order2noise
-+
-+    def __init__(self):
-+        self.l_vec = 0
-+        self.num_ops = 0
-+        self.solver = SOLVER_NOT_SET
-+
-+    def set_solver(self, sso):
-+        """ Prepare the solver from the info in StochasticSolverOptions
-+
-+        Parameters
-+        ----------
-+        sso : StochasticSolverOptions
-+            Data of the stochastic system
-+        """
-+        self.set_data(sso)
-+        self.sso = sso
-+
-+        self.solver = sso.solver_code
-+        self.dt = sso.dt
-+        self.num_substeps = sso.nsubsteps
-+        self.normalize = sso.normalize
-+        self.num_step = len(sso.times)
-+        self.num_dw = len(sso.sops)
-+        if self.solver in [EXPLICIT1_5_SOLVER,
-+                           TAYLOR1_5_SOLVER,
-+                           TAYLOR1_5_IMP_SOLVER]:
-+            self.num_dw *= 2
-+        if self.solver in [TAYLOR2_0_SOLVER]:
-+            self.num_dw *= 3 + 2*sso.p
-+            self.order2noise = TaylorNoise(sso.p, self.dt)
-+        # prepare buffers for the solvers
-+        nb_solver = [0,0,0,0]
-+        nb_func = [0,0,0]
-+        nb_expect = [0,0,0]
-+
-+        # %%%%%%%%%%%%%%%%%%%%%%%%%
-+        # Depending on the solver, determine the numbers of buffers of each
-+        # shape to prepare. (~30% slower when not preallocating buffer)
-+        # nb_solver : buffer to contain the states used by solver
-+        # nb_func : buffer for states used used by d1, d2 and derivative functions
-+        # nb_expect : buffer to store expectation values.
-+        if self.solver is EULER_SOLVER:
-+            nb_solver = [0,1,0,0]
-+        elif self.solver is PHOTOCURRENT_SOLVER:
-+            nb_solver = [1,0,0,0]
-+            nb_func = [1,0,0]
-+        elif self.solver is PLATEN_SOLVER:
-+            nb_solver = [2,5,0,0]
-+        elif self.solver is PC_SOLVER:
-+            nb_solver = [4,1,1,0]
-+        elif self.solver is MILSTEIN_SOLVER:
-+            nb_solver = [0,1,1,0]
-+        elif self.solver is MILSTEIN_IMP_SOLVER:
-+            nb_solver = [1,1,1,0]
-+        elif self.solver is PC_2_SOLVER:
-+            nb_solver = [5,1,1,0]
-+        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-+            nb_solver = [1,1,0,0]
-+            nb_func = [1,0,0]
-+        elif self.solver is ROUCHON_SOLVER:
-+            nb_solver = [2,0,0,0]
-+        elif self.solver is EXPLICIT1_5_SOLVER:
-+            nb_solver = [5,8,3,0]
-+        elif self.solver is TAYLOR1_5_SOLVER:
-+            nb_solver = [2,3,1,1]
-+        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-+            nb_solver = [2,3,1,1]
-+        elif self.solver is TAYLOR2_0_SOLVER:
-+            nb_solver = [11,0,0,0]
-+
-+        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
-+                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-+          if sso.me:
-+            nb_func = [1,0,0]
-+            nb_expect = [1,1,0]
-+          else:
-+            nb_func = [2,1,1]
-+            nb_expect = [2,1,1]
-+        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
-+            nb_expect = [1,0,0]
-+        elif self.solver is TAYLOR2_0_SOLVER:
-+          if sso.me:
-+            nb_func = [2,0,0]
-+            nb_expect = [2,0,0]
-+          else:
-+            nb_func = [14,0,0]
-+            nb_expect = [0,0,0]
-+        elif self.solver is ROUCHON_SOLVER:
-+            nb_expect = [1,0,0]
-+        else:
-+          if not sso.me:
-+            nb_func = [1,0,0]
-+
-+        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
-+        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
-+                                  dtype=complex)
-+        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
-+                                        dtype=complex)
-+        if nb_solver[3]:
-+          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
-+                                        dtype=complex)
-+
-+        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
-+        if nb_expect[1]:
-+          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
-+        if nb_expect[2]:
-+          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
-+
-+        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
-+        if nb_func[1]:
-+          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
-+        if nb_func[2]:
-+          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
-+
-+        self.noise_type = sso.noise_type
-+        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
-+        if self.noise_type == 1:
-+            self.custom_noise = sso.noise
-+        elif self.noise_type == 0:
-+            self.seed = sso.noise
-+
-+    def set_data(self, sso):
-+        """Set solver specific operator"""
-+        pass
-+
-+    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
-+        """Create the random numbers for the stochastic process"""
-+        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
-+            # photocurrent, just seed,
-+            np.random.seed(self.seed[n])
-+            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
-+        if self.noise_type == 0:
-+            np.random.seed(self.seed[n])
-+            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
-+                                   np.sqrt(self.dt)
-+        elif self.noise_type == 1:
-+            return self.custom_noise[n,:,:,:]
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    def cy_sesolve_single_trajectory(self, int n):
-+        """ Run the one of the trajectories of the stochastic system.
-+
-+        Parameters
-+        ----------
-+        n : int
-+            Number of the iterations
-+
-+        sso : StochasticSolverOptions
-+            Data of the stochastic system
-+
-+        Returns
-+        -------
-+        states_list : list of qobj
-+            State of the system at each time
-+
-+        noise : array
-+            noise at each step of the solver
-+
-+        measurements : array
-+            measurements value at each timestep for each m_ops
-+
-+        expect : array
-+            expectation value at each timestep for each e_ops
-+
-+        """
-+        sso = self.sso
-+        cdef double[::1] times = sso.times
-+        cdef complex[::1] rho_t
-+        cdef double t
-+        cdef int m_idx, t_idx, e_idx
-+        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
-+        cdef int tlast = times.shape[0]
-+
-+        rho_t = sso.rho0.copy()
-+        dims = sso.state0.dims
-+
-+        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
-+        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
-+        states_list = []
-+        for t_idx, t in enumerate(times):
-+            PyErr_CheckSignals()
-+            if sso.ce_ops:
-+                for e_idx, e in enumerate(sso.ce_ops):
-+                    s = e.expect_data(t, _dense_wrap(rho_t))
-+                    expect[e_idx, t_idx] = s
-+            if sso.store_states or not sso.ce_ops:
-+                if sso.me:
-+                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
-+                        dims=dims))
-+                else:
-+                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
-+
-+            if t_idx != tlast-1:
-+                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
-+                                 rho_t, self.num_substeps)
-+
-+            if sso.store_measurement:
-+                for m_idx, m in enumerate(sso.cm_ops):
-+                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
-+                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
-+                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
-+
-+        if sso.method == 'heterodyne':
-+            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
-+
-+        return states_list, noise, measurements, expect
-+
-+    @cython.boundscheck(False)
-+    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
-+                          complex[::1] vec, int num_substeps):
-+        """ Do one time full step"""
-+        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
-+        cdef int i
-+        if self.solver is EULER_SOLVER:
-+            for i in range(num_substeps):
-+                self.euler(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is PHOTOCURRENT_SOLVER:
-+            for i in range(num_substeps):
-+                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is PLATEN_SOLVER:
-+            for i in range(num_substeps):
-+                self.platen(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is PC_SOLVER:
-+            for i in range(num_substeps):
-+                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is MILSTEIN_SOLVER:
-+            for i in range(num_substeps):
-+                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is MILSTEIN_IMP_SOLVER:
-+            for i in range(num_substeps):
-+                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is PC_2_SOLVER:
-+            for i in range(num_substeps):
-+                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-+            for i in range(num_substeps):
-+                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is ROUCHON_SOLVER:
-+            for i in range(num_substeps):
-+                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is EXPLICIT1_5_SOLVER:
-+            for i in range(num_substeps):
-+                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is TAYLOR1_5_SOLVER:
-+            for i in range(num_substeps):
-+                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-+            for i in range(num_substeps):
-+                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        elif self.solver is TAYLOR2_0_SOLVER:
-+            for i in range(num_substeps):
-+                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
-+                out, vec = vec, out
-+
-+        if self.normalize:
-+            self._normalize_inplace(vec)
-+        return vec
-+
-+    cdef void _normalize_inplace(self, complex[::1] vec):
-+        _normalize_inplace(vec)
-+
-+    # Dummy functions
-+    # Needed for compilation since ssesolve is not stand-alone
-+    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
-+        """ deterministic part of the evolution
-+        depend on schrodinger vs master vs photocurrent
-+        """
-+        pass
-+
-+    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
-+        """ stochastic part of the evolution
-+        depend on schrodinger vs master vs photocurrent
-+        """
-+        pass
-+
-+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-+                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
-+        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
-+        pass
-+
-+    cdef void derivatives(self, double t, int deg, complex[::1] rho,
-+                              complex[::1] a, complex[:, ::1] b,
-+                              complex[:, :, ::1] Lb, complex[:,::1] La,
-+                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-+                              complex[::1] L0a):
-+        """ Obtain the multiple terms for stochastic taylor expension
-+        Up to order 1.5
-+        multiple sc_ops
-+        """
-+        pass
-+
-+    cdef void derivativesO2(self, double t, complex[::1] rho,
-+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-+                            complex[::1] L0a,
-+                            complex[::1] LLa, complex[::1] LL0b,
-+                            complex[::1] L0Lb, complex[::1] LLLb):
-+        """ Obtain the multiple terms for stochastic taylor expension
-+        Up to order 2.0
-+        One sc_ops
-+        """
-+        pass
-+
-+    cdef void photocurrent(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        """Special integration scheme:
-+        photocurrent collapse + euler evolution
-+        """
-+        pass
-+
-+    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        """Special integration scheme:
-+        photocurrent collapse + predictor-corrector evolution
-+        """
-+        pass
-+
-+    cdef void rouchon(self, double t, double dt, double[:] noise,
-+                      complex[::1] vec, complex[::1] out):
-+        """Special integration scheme:
-+        Force valid density matrix using positive map
-+        Pierre Rouchon, Jason F. Ralph
-+        arXiv:1410.5345 [quant-ph]
-+        """
-+        pass
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void euler(self, double t, double dt, double[:] noise,
-+                    complex[::1] vec, complex[::1] out):
-+        """Integration scheme:
-+        Basic Euler order 0.5
-+        dV = d1 dt + d2_i dW_i
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        cdef int i, j
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        _zero_2d(d2)
-+        copy(vec, out)
-+        self.d1(t, vec, out)
-+        self.d2(t, vec, d2)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i], d2[i,:], out)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void platen(self, double t, double dt, double[:] noise,
-+                       complex[::1] vec, complex[::1] out):
-+        """
-+        Platen rhs function for both master eq and schrodinger eq.
-+        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
-+             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
-+             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
-+
-+        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
-+        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
-+        The Theory of Open Quantum Systems
-+        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
-+        """
-+        cdef int i, j, k
-+        cdef double sqrt_dt = np.sqrt(dt)
-+        cdef double sqrt_dt_inv = 0.25/sqrt_dt
-+        cdef double dw, dw2
-+        cdef complex[::1] d1 = self.buffer_1d[0,:]
-+        cdef complex[::1] Vt = self.buffer_1d[1,:]
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
-+        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
-+        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
-+        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
-+        _zero(d1)
-+        _zero_2d(d2)
-+
-+        self.d1(t, vec, d1)
-+        self.d2(t, vec, d2)
-+        _axpy(1.0,vec,d1)
-+        copy(d1,Vt)
-+        copy(d1,out)
-+        _scale(0.5,out)
-+        for i in range(self.num_ops):
-+            copy(d1,Vp[i,:])
-+            copy(d1,Vm[i,:])
-+            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
-+            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
-+            _axpy(noise[i],d2[i,:],Vt)
-+        _zero(d1)
-+        self.d1(t, Vt, d1)
-+        _axpy(0.5,d1,out)
-+        _axpy(0.5,vec,out)
-+        for i in range(self.num_ops):
-+            _zero_2d(d2p)
-+            _zero_2d(d2m)
-+            self.d2(t, Vp[i,:], d2p)
-+            self.d2(t, Vm[i,:], d2m)
-+            dw = noise[i] * 0.25
-+            _axpy(dw,d2m[i,:],out)
-+            _axpy(2*dw,d2[i,:],out)
-+            _axpy(dw,d2p[i,:],out)
-+            for j in range(self.num_ops):
-+                if i == j:
-+                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
-+                else:
-+                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
-+                _axpy(dw2,d2p[j,:],out)
-+                _axpy(-dw2,d2m[j,:],out)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void pred_corr(self, double t, double dt, double[:] noise,
-+                    complex[::1] vec, complex[::1] out):
-+        """
-+        Chapter 15.5 Eq. (5.4)
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        # a=0. b=0.5
-+        cdef double dt_2 = dt*0.5
-+        cdef complex[::1] euler = self.buffer_1d[0,:]
-+        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-+        cdef complex[::1] b_pred = self.buffer_1d[2,:]
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-+        _zero(a_pred)
-+        _zero(b_pred)
-+        _zero_2d(d2)
-+        _zero_3d(dd2)
-+        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-+        copy(vec, euler)
-+        copy(vec, out)
-+        _axpy(1.0, a_pred, euler)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i], d2[i,:], b_pred)
-+            _axpy(-dt_2, dd2[i,i,:], a_pred)
-+        _axpy(1.0, a_pred, out)
-+        _axpy(1.0, b_pred, euler)
-+        _axpy(0.5, b_pred, out)
-+        _zero_2d(d2)
-+        self.d2(t + dt, euler, d2)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i]*0.5, d2[i,:], out)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
-+                    complex[::1] vec, complex[::1] out):
-+        """
-+        Chapter 15.5 Eq. (5.4)
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        # a=0.5, b=0.5
-+        cdef int i, j, k
-+        cdef complex[::1] euler = self.buffer_1d[0,:]
-+        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-+        _zero(a_pred)
-+        cdef complex[::1] a_corr = self.buffer_1d[2,:]
-+        _zero(a_corr)
-+        cdef complex[::1] b_pred = self.buffer_1d[3,:]
-+        _zero(b_pred)
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        _zero_2d(d2)
-+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-+        _zero_3d(dd2)
-+
-+        cdef double dt_2 = dt*0.5
-+        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-+        copy(vec, euler)
-+        _axpy(1.0, a_pred, euler)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i], d2[i,:], b_pred)
-+            _axpy(-dt_2, dd2[i,i,:], a_pred)
-+        _axpy(1.0, b_pred, euler)
-+        copy(vec, out)
-+        _axpy(0.5, a_pred, out)
-+        _axpy(0.5, b_pred, out)
-+        _zero_2d(d2)
-+        _zero_3d(dd2)
-+        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i]*0.5, d2[i,:], out)
-+            _axpy(-dt_2, dd2[i,i,:], a_corr)
-+        _axpy(0.5, a_corr, out)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void milstein(self, double t, double dt, double[:] noise,
-+                    complex[::1] vec, complex[::1] out):
-+        """
-+        Chapter 10.3 Eq. (3.1)
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+
-+        dV = -iH*V*dt + d1*dt + d2_i*dW_i
-+             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
-+        """
-+        cdef int i, j, k
-+        cdef double dw
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-+        _zero_2d(d2)
-+        _zero_3d(dd2)
-+        copy(vec,out)
-+        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i],d2[i,:],out)
-+        for i in range(self.num_ops):
-+            for j in range(i, self.num_ops):
-+                if (i == j):
-+                    dw = (noise[i] * noise[i] - dt) * 0.5
-+                else:
-+                    dw = (noise[i] * noise[j])
-+                _axpy(dw,dd2[i,j,:],out)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void milstein_imp(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out) except *:
-+        """
-+        Chapter 12.2 Eq. (2.9)
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        cdef int i, j, k
-+        cdef double dw
-+        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-+                                                          dtype=complex)
-+        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
-+                                                         dtype=complex)
-+        cdef complex[::1] a = self.buffer_1d[0,:]
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-+        _zero(a)
-+        _zero_2d(d2)
-+        _zero_3d(dd2)
-+        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
-+        copy(vec, dvec)
-+        _axpy(0.5, a, dvec)
-+        for i in range(self.num_ops):
-+            _axpy(noise[i], d2[i,:], dvec)
-+        for i in range(self.num_ops):
-+            for j in range(i, self.num_ops):
-+                if (i == j):
-+                    dw = (noise[i] * noise[i] - dt) * 0.5
-+                else:
-+                    dw = (noise[i] * noise[j])
-+                _axpy(dw, dd2[i,j,:], dvec)
-+        copy(dvec, guess)
-+        _axpy(0.5, a, guess)
-+        self.implicit(t+dt, dvec, out, guess)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void taylor15(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        """
-+        Chapter 12.2 Eq. (2.18),
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        cdef complex[::1] a = self.buffer_1d[0, :]
-+        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-+        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-+        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-+        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-+        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-+        cdef complex[::1] L0a = self.buffer_1d[1, :]
-+        _zero(a)
-+        _zero_2d(b)
-+        _zero_3d(Lb)
-+        _zero_2d(L0b)
-+        _zero_2d(La)
-+        _zero_4d(LLb)
-+        _zero(L0a)
-+        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
-+
-+        cdef int i,j,k
-+        cdef double[::1] dz, dw
-+        dw = np.empty(self.num_ops)
-+        dz = np.empty(self.num_ops)
-+        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-+        for i in range(self.num_ops):
-+            dw[i] = noise[i]
-+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-+        copy(vec,out)
-+        _axpy(1.0, a, out)
-+        _axpy(0.5, L0a, out)
-+
-+        for i in range(self.num_ops):
-+            _axpy(dw[i], b[i,:], out)
-+            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
-+            _axpy(dz[i], La[i,:], out)
-+            _axpy(dw[i]-dz[i], L0b[i,:], out)
-+            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-+                        LLb[i,i,i,:], out)
-+            for j in range(i+1,self.num_ops):
-+                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
-+                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
-+                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
-+                for k in range(j+1,self.num_ops):
-+                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out) except *:
-+        """
-+        Chapter 12.2 Eq. (2.18),
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        cdef complex[::1] a = self.buffer_1d[0, :]
-+        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-+        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-+        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-+        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-+        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-+        cdef complex[::1] L0a = self.buffer_1d[1, :]
-+        _zero(a)
-+        _zero_2d(b)
-+        _zero_3d(Lb)
-+        _zero_2d(L0b)
-+        _zero_2d(La)
-+        _zero_4d(LLb)
-+        _zero(L0a)
-+        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-+                   dtype=complex)
-+        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
-+                  dtype=complex)
-+        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
-+
-+        cdef int i,j,k
-+        cdef double[::1] dz, dw
-+        dw = np.empty(self.num_ops)
-+        dz = np.empty(self.num_ops)
-+        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-+        for i in range(self.num_ops):
-+            dw[i] = noise[i]
-+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-+        copy(vec, vec_t)
-+        _axpy(0.5, a, vec_t)
-+        for i in range(self.num_ops):
-+            _axpy(dw[i], b[i,:], vec_t)
-+            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
-+            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
-+            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
-+            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-+                        LLb[i,i,i,:], vec_t)
-+            for j in range(i+1,self.num_ops):
-+                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
-+                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
-+                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
-+                for k in range(j+1,self.num_ops):
-+                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
-+        copy(vec_t, guess)
-+        _axpy(0.5, a, guess)
-+
-+        self.implicit(t+dt, vec_t, out, guess)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void platen15(self, double t, double dt, double[:] noise,
-+                    complex[::1] vec, complex[::1] out):
-+        """
-+        Chapter 11.2 Eq. (2.13)
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        cdef int i, j, k
-+        cdef double sqrt_dt = np.sqrt(dt)
-+        cdef double sqrt_dt_inv = 1./sqrt_dt
-+        cdef double ddz, ddw, ddd
-+        cdef double[::1] dz, dw
-+        dw = np.empty(self.num_ops)
-+        dz = np.empty(self.num_ops)
-+        for i in range(self.num_ops):
-+            dw[i] = noise[i]
-+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-+
-+        cdef complex[::1] d1 = self.buffer_1d[0,:]
-+        cdef complex[::1] d1p = self.buffer_1d[1,:]
-+        cdef complex[::1] d1m = self.buffer_1d[2,:]
-+        cdef complex[::1] V = self.buffer_1d[3,:]
-+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-+        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
-+        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
-+        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
-+        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
-+        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
-+        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
-+        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
-+        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
-+        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
-+
-+        _zero(d1)
-+        _zero_2d(d2)
-+        _zero_2d(dd2)
-+        self.d1(t, vec, d1)
-+        self.d2(t, vec, d2)
-+        self.d2(t + dt, vec, dd2)
-+        # Euler part
-+        copy(vec,out)
-+        _axpy(1., d1, out)
-+        for i in range(self.num_ops):
-+            _axpy(dw[i], d2[i,:], out)
-+
-+        _zero(V)
-+        _axpy(1., vec, V)
-+        _axpy(1./self.num_ops, d1, V)
-+
-+        _zero_2d(v2p)
-+        _zero_2d(v2m)
-+        for i in range(self.num_ops):
-+            _axpy(1., V, v2p[i,:])
-+            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
-+            _axpy(1., V, v2m[i,:])
-+            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
-+
-+        _zero_3d(p2p)
-+        _zero_3d(p2m)
-+        for i in range(self.num_ops):
-+            _zero_2d(d2p)
-+            _zero_2d(d2m)
-+            self.d2(t, v2p[i,:], d2p)
-+            self.d2(t, v2m[i,:], d2m)
-+            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
-+            _axpy( ddw, d2p[i,:], out)
-+            _axpy(-ddw, d2m[i,:], out)
-+            for j in range(self.num_ops):
-+                _axpy(      1., v2p[i,:], p2p[i,j,:])
-+                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
-+                _axpy(      1., v2p[i,:], p2m[i,j,:])
-+                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
-+
-+        _axpy(-0.5*(self.num_ops), d1, out)
-+        for i in range(self.num_ops):
-+            ddz = dz[i]*0.5/sqrt_dt  # 1.5
-+            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
-+            _zero(d1p)
-+            _zero(d1m)
-+            _zero_2d(d2m)
-+            _zero_2d(d2p)
-+            _zero_2d(d2pp)
-+            _zero_2d(d2mm)
-+            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
-+            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
-+            self.d2(t, v2p[i,:], d2p)
-+            self.d2(t, v2m[i,:], d2m)
-+            self.d2(t, p2p[i,i,:], d2pp)
-+            self.d2(t, p2m[i,i,:], d2mm)
-+
-+            _axpy( ddz+0.25, d1p, out)
-+            _axpy(-ddz+0.25, d1m, out)
-+
-+            _axpy((dw[i]-dz[i]), dd2[i,:], out)
-+            _axpy((dz[i]-dw[i]), d2[i,:], out)
-+
-+            _axpy( ddd, d2pp[i,:], out)
-+            _axpy(-ddd, d2mm[i,:], out)
-+            _axpy(-ddd, d2p[i,:], out)
-+            _axpy( ddd, d2m[i,:], out)
-+
-+            for j in range(self.num_ops):
-+              ddw = 0.5*(dw[j]-dz[j]) # 1.5
-+              _axpy(ddw, d2p[j,:], out)
-+              _axpy(-2*ddw, d2[j,:], out)
-+              _axpy(ddw, d2m[j,:], out)
-+
-+              if j>i:
-+                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
-+                _axpy( ddw, d2p[j,:], out)
-+                _axpy(-ddw, d2m[j,:], out)
-+
-+                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-+                _zero_2d(d2pp)
-+                _zero_2d(d2mm)
-+                self.d2(t, p2p[j,i,:], d2pp)
-+                self.d2(t, p2m[j,i,:], d2mm)
-+                _axpy( ddw, d2pp[j,:], out)
-+                _axpy(-ddw, d2mm[j,:], out)
-+                _axpy(-ddw, d2p[j,:], out)
-+                _axpy( ddw, d2m[j,:], out)
-+
-+                for k in range(j+1,self.num_ops):
-+                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
-+                    _axpy( ddw, d2pp[k,:], out)
-+                    _axpy(-ddw, d2mm[k,:], out)
-+                    _axpy(-ddw, d2p[k,:], out)
-+                    _axpy( ddw, d2m[k,:], out)
-+
-+              if j<i:
-+                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-+                _zero_2d(d2pp)
-+                _zero_2d(d2mm)
-+                self.d2(t, p2p[j,i,:], d2pp)
-+                self.d2(t, p2m[j,i,:], d2mm)
-+                _axpy( ddw, d2pp[j,:], out)
-+                _axpy(-ddw, d2mm[j,:], out)
-+                _axpy(-ddw, d2p[j,:], out)
-+                _axpy( ddw, d2m[j,:], out)
-+
-+    @cython.wraparound(False)
-+    @cython.boundscheck(False)
-+    @cython.cdivision(True)
-+    cdef void taylor20(self, double t, double dt, double[::1] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        """
-+        Chapter 10.5 Eq. (5.1),
-+        Numerical Solution of Stochastic Differential Equations
-+        By Peter E. Kloeden, Eckhard Platen
-+        """
-+        cdef double[::1] noises = np.empty(5)
-+        cdef double dwn
-+        self.order2noise.order2(noise,noises)
-+        cdef complex[::1] a = self.buffer_1d[0, :]
-+        cdef complex[::1] b = self.buffer_1d[1, :]
-+        cdef complex[::1] Lb = self.buffer_1d[2, :]
-+        cdef complex[::1] La = self.buffer_1d[3, :]
-+        cdef complex[::1] L0b = self.buffer_1d[4, :]
-+        cdef complex[::1] LLb = self.buffer_1d[5, :]
-+        cdef complex[::1] L0a = self.buffer_1d[6, :]
-+        cdef complex[::1] LLa = self.buffer_1d[7, :]
-+        cdef complex[::1] LL0b = self.buffer_1d[8, :]
-+        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
-+        cdef complex[::1] LLLb = self.buffer_1d[10, :]
-+        _zero(a)
-+        _zero(b)
-+        _zero(Lb)
-+        _zero(La)
-+        _zero(L0b)
-+        _zero(LLb)
-+        _zero(L0a)
-+        _zero(LLa)
-+        _zero(LL0b)
-+        _zero(L0Lb)
-+        _zero(LLLb)
-+        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
-+                           L0a, LLa, LL0b, L0Lb, LLLb)
-+
-+        copy(vec,out)
-+        _axpy(1.0, a, out)
-+
-+        _axpy(noises[0], b, out)
-+        dwn = noises[0]*noises[0]*0.5
-+        _axpy(dwn, Lb, out)
-+
-+        _axpy(noises[1], La, out)
-+        _axpy(noises[0]-noises[1], L0b, out)
-+        dwn *= noises[0]*(1/3.)
-+        _axpy(dwn, LLb, out)
-+        _axpy(0.5, L0a, out)
-+
-+        _axpy(noises[2], L0Lb, out)
-+        _axpy(noises[3], LL0b, out)
-+        _axpy(noises[4], LLa, out)
-+        dwn *= noises[0]*0.25
-+        _axpy(dwn, LLLb, out)
-+
-+
-+cdef class SSESolver(StochasticSolver):
-+    """stochastic Schrodinger system"""
-+    cdef QobjEvo L
-+    cdef object c_ops
-+    cdef object cpcd_ops
-+    cdef object imp
-+    cdef double tol, imp_t
-+
-+    def set_data(self, sso):
-+        L = sso.LH
-+        c_ops = sso.sops
-+        self.l_vec = L.shape[0]
-+        self.num_ops = len(c_ops)
-+        self.L = L
-+        self.c_ops = []
-+        self.cpcd_ops = []
-+        for i, op in enumerate(c_ops):
-+            self.c_ops.append(op[0])
-+            self.cpcd_ops.append(op[1])
-+        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-+            self.tol = sso.tol
-+            self.imp = LinearOperator( (self.l_vec,self.l_vec),
-+                                      matvec=self.implicit_op, dtype=complex)
-+
-+    def implicit_op(self, vec):
-+        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
-+        self.d1(self.imp_t, vec, out)
-+        cdef int i
-+        _scale(-0.5,out)
-+        _axpy(1.,vec,out)
-+        return out
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-+        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
-+        cdef int i
-+        cdef complex e
-+        cdef QobjEvo c_op
-+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-+        _zero(temp)
-+        for i in range(self.num_ops):
-+            c_op = self.cpcd_ops[i]
-+            e = c_op.expect_data(t, _dense_wrap(vec))
-+            _zero(temp)
-+            c_op = self.c_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
-+            _axpy(-0.125 * e * e * self.dt, vec, out)
-+            _axpy(0.5 * e * self.dt, temp, out)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-+        cdef int i, k
-+        cdef QobjEvo c_op
-+        cdef complex expect
-+        for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
-+            c_op = self.cpcd_ops[i]
-+            expect = c_op.expect_data(t, _dense_wrap(vec))
-+            _axpy(-0.5*expect,vec,out[i,:])
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void derivatives(self, double t, int deg, complex[::1] vec,
-+                          complex[::1] a, complex[:, ::1] b,
-+                          complex[:, :, ::1] Lb, complex[:,::1] La,
-+                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-+                          complex[::1] L0a):
-+        """
-+        combinaisons of a and b derivatives for taylor order 1.5
-+        dY ~ a dt + bi dwi
-+                                         deg   use        noise
-+        b[i.:]       bi                   >=0   d2 euler   dwi
-+        a[:]         a                    >=0   d1 euler   dt
-+        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-+        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-+
-+        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-+        La[i,:]      ba'                  >=2   taylor15   dzi
-+        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-+        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-+        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-+        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-+        """
-+        cdef int i, j, k, l
-+        cdef double dt = self.dt
-+        cdef QobjEvo c_op
-+        cdef complex e, de_bb
-+
-+        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
-+        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
-+        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
-+        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
-+        _zero_3d(dde_bb)
-+        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
-+        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
-+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-+        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-+        _zero(temp)
-+        _zero(temp2)
-+        _zero_2d(Cvec)
-+        _zero_3d(Cb)
-+
-+        # a b
-+        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
-+        for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
-+            e = _dotc(vec,Cvec[i,:])
-+            e_real[i] = e.real
-+            _axpy(1., Cvec[i,:], b[i,:])
-+            _axpy(-e_real[i], vec, b[i,:])
-+            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
-+            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
-+
-+        #Lb bb'
-+        if deg >= 1:
-+          for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            for j in range(self.num_ops):
-+              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
-+              for k in range(self.l_vec):
-+                  temp[k] = conj(b[j,k])
-+                  temp2[k] = 0.
-+              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-+              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
-+                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-+              _axpy(1., Cb[i,j,:], Lb[i,j,:])
-+              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
-+              _axpy(-de_b[i,j], vec, Lb[i,j,:])
-+
-+              for k in range(self.num_ops):
-+                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
-+                                  _dot(b[k,:], Cb[i,j,:]) + \
-+                                  conj(_dotc(b[k,:], temp2)))*.5
-+                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
-+
-+        #L0b La LLb
-+        if deg >= 2:
-+          for i in range(self.num_ops):
-+              #ba'
-+              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-+              for j in range(self.num_ops):
-+                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
-+                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
-+                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
-+                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
-+
-+              #ab' + db/dt + bbb"/2
-+              c_op = self.c_ops[i]
-+              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
-+              for k in range(self.l_vec):
-+                  temp[k] = conj(a[k])
-+                  temp2[k] = 0.
-+              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-+              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
-+                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-+              _axpy(-e_real[i], a, L0b[i,:])
-+              _axpy(-de_a[i], vec, L0b[i,:])
-+
-+              temp = np.zeros(self.l_vec, dtype=complex)
-+              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
-+              e = _dotc(vec,temp)
-+              _axpy(1., temp, L0b[i,:])
-+              _axpy(-e.real, vec, L0b[i,:])
-+              _axpy(-1., b[i,:], L0b[i,:])
-+
-+              for j in range(self.num_ops):
-+                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
-+                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
-+
-+              #b(bb"+b'b')
-+              for j in range(i,self.num_ops):
-+                  for k in range(j, self.num_ops):
-+                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
-+                                  _dense_wrap(LLb[i,j,k,:]))
-+                      for l in range(self.l_vec):
-+                          temp[l] = conj(Lb[j,k,l])
-+                          temp2[l] = 0.
-+                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-+                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
-+                               _dot(Lb[j,k,:], Cvec[i,:]) + \
-+                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
-+                               _dotc(vec, temp2)))*0.5
-+                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
-+                      _axpy(-de_bb, vec, LLb[i,j,k,:])
-+                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
-+                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
-+                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
-+
-+        #da/dt + aa' + bba"
-+        if deg == 2:
-+          self.d1(t + dt, vec, L0a)
-+          _axpy(-1.0, a, L0a)
-+          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-+          for j in range(self.num_ops):
-+              c_op = self.c_ops[j]
-+              temp = np.zeros(self.l_vec, dtype=complex)
-+              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-+              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
-+              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
-+              _axpy(e_real[j] * dt, temp, L0a[:])
-+              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
-+              for i in range(self.num_ops):
-+                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
-+                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
-+                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
-+                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
-+                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
-+                         complex[::1] vec, complex[::1] out):
-+        cdef int k
-+        cdef complex[::1] temp = self.func_buffer_1d[13,:]
-+        for k in range(self.l_vec):
-+            temp[k] = conj(vec[k])
-+            out[k] = 0.
-+        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void derivativesO2(self, double t, complex[::1] psi,
-+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-+                            complex[::1] L0a,
-+                            complex[::1] LLa, complex[::1] LL0b,
-+                            complex[::1] L0Lb, complex[::1] LLLb):
-+        """
-+        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-+        Use Stratonovich-Taylor expansion.
-+        One one sc_ops
-+        dY ~ a dt + bi dwi
-+
-+        b[:]     b                        d2 euler    dw
-+        a[:]     a- Lb/2                  d1 euler    dt
-+        Lb[:]    b'b                      milstein    dw^2/2
-+        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-+        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-+        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-+        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-+
-+        LLa[:]   ...                      taylor2.0   dwdt-dz
-+        LL0b[:]  ...                      taylor2.0   dz
-+        L0Lb[:]  ...                      taylor2.0   dw^3/6
-+        LLLb[:]  ...                      taylor2.0   dt^2/2
-+        """
-+        cdef double dt = self.dt
-+        cdef QobjEvo c_op = self.c_ops[0]
-+        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
-+        cdef complex de_a, dde_ba, de_La, de_L0b
-+
-+        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
-+        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
-+        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
-+        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
-+        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
-+        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
-+        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
-+        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
-+        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
-+        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
-+        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
-+        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
-+        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
-+        _zero(Cpsi)
-+        _zero(Cb)
-+        _zero(CLb)
-+        _zero(CLLb)
-+        _zero(Ca)
-+        _zero(CLa)
-+        _zero(CL0b)
-+
-+        # b
-+        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
-+        e = _dotc(psi, Cpsi).real
-+        _axpy(1., Cpsi, b)
-+        _axpy(-e, psi, b)
-+
-+        # Lb
-+        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
-+        self._c_vec_conj(t, c_op, b, Cbc)
-+        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
-+                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
-+        _axpy(1., Cb, Lb)
-+        _axpy(-e, b, Lb)
-+        _axpy(-de_b, psi, Lb)
-+
-+        # LLb = b'b'b + b"bb
-+        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
-+        self._c_vec_conj(t, c_op, Lb, CLbc)
-+        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
-+                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
-+        _axpy(1, CLb, LLb)      # b'b'b
-+        _axpy(-e, Lb, LLb)      # b'b'b
-+        _axpy(-de_Lb, psi, LLb) # b'b'b
-+        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
-+        _axpy(-dde_bb, psi, LLb) # b"bb
-+        _axpy(-de_b*2, b, LLb)   # b"bb
-+
-+        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
-+        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
-+        self._c_vec_conj(t, c_op, LLb, CLLbc)
-+        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
-+                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
-+        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
-+                    conj(_dotc(b, CLbc)))*.5
-+        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
-+        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
-+        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
-+        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
-+        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
-+        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
-+        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
-+
-+        # a
-+        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
-+        _axpy(-0.5 * e * e * dt, psi, a)
-+        _axpy(e * dt, Cpsi, a)
-+        _axpy(-0.5 * dt, Lb, a)
-+
-+        #La
-+        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-+        _axpy(-0.5 * e * e * dt, b, La)
-+        _axpy(-e * de_b * dt, psi, La)
-+        _axpy(e * dt, Cb, La)
-+        _axpy(de_b * dt, Cpsi, La)
-+        _axpy(-0.5 * dt, LLb, La)
-+
-+        #LLa
-+        _axpy(-2 * e * de_b * dt, b, LLa)
-+        _axpy(-de_b * de_b * dt, psi, LLa)
-+        _axpy(-e * dde_bb * dt, psi, LLa)
-+        _axpy( 2 * de_b * dt, Cb, LLa)
-+        _axpy( dde_bb * dt, Cpsi, LLa)
-+
-+        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-+        _axpy(-de_Lb * e * dt, psi, LLa)
-+        _axpy(-0.5 * e * e * dt, Lb, LLa)
-+        _axpy( de_Lb * dt, Cpsi, LLa)
-+        _axpy( e * dt, CLb, LLa)
-+
-+        _axpy(-0.5 * dt, LLLb, LLa)
-+
-+        # L0b = b'a
-+        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
-+        self._c_vec_conj(t, c_op, a, Cac)
-+        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
-+                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
-+        _axpy(1.0, Ca, L0b)
-+        _axpy(-e, a, L0b)
-+        _axpy(-de_a, psi, L0b)
-+
-+        # LL0b = b"ba + b'La
-+        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
-+                    conj(_dotc(b, Cac)))*.5
-+        _axpy(-dde_ba, psi, LL0b)
-+        _axpy(-de_a, b, LL0b)
-+        _axpy(-de_b, a, LL0b)
-+        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
-+        self._c_vec_conj(t, c_op, La, CLac)
-+        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
-+                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
-+        _axpy(1., CLa, LL0b)
-+        _axpy(-e, La, LL0b)
-+        _axpy(-de_La, psi, LL0b)
-+
-+        # L0Lb = b"ba + b'L0b
-+        _axpy(-dde_ba, psi, L0Lb)
-+        _axpy(-de_a, b, L0Lb)
-+        _axpy(-de_b, a, L0Lb)
-+        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
-+        self._c_vec_conj(t, c_op, L0b, CL0bc)
-+        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
-+                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
-+        _axpy(1., CL0b, L0Lb)
-+        _axpy(-e, L0b, L0Lb)
-+        _axpy(-de_L0b, psi, L0Lb)
-+
-+        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
-+        self.d1(t + dt, psi, L0a) # da/dt
-+        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
-+        _axpy(-1.0, a, L0a)        # da/dt
-+        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
-+        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
-+        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
-+        _axpy(e * dt, Ca, L0a)              # a'_a_
-+        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
-+        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
-+
-+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-+                                        complex[::1] out,
-+                                        np.ndarray[complex, ndim=1] guess) except *:
-+        # np.ndarray to memoryview is OK but not the reverse
-+        # scipy function only take np array, not memoryview
-+        self.imp_t = t
-+        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
-+                                          tol=self.tol, atol=1e-12)
-+        cdef int i
-+        copy(spout, out)
-+
-+
-+cdef class SMESolver(StochasticSolver):
-+    """stochastic master equation system"""
-+    cdef QobjEvo L
-+    cdef object imp
-+    cdef object c_ops
-+    cdef int N_root
-+    cdef double tol
-+
-+    def set_data(self, sso):
-+        L = sso.LH
-+        c_ops = sso.sops
-+        self.l_vec = L.shape[0]
-+        self.num_ops = len(c_ops)
-+        self.L = L
-+        self.c_ops = []
-+        self.N_root = np.sqrt(self.l_vec)
-+        for i, op in enumerate(c_ops):
-+            self.c_ops.append(op)
-+        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-+            self.tol = sso.tol
-+            self.imp = sso.imp
-+
-+    cdef void _normalize_inplace(self, complex[::1] vec):
-+        _normalize_rho(vec)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef complex expect(self, complex[::1] rho):
-+        cdef complex e = 0.
-+        cdef int k
-+        for k in range(self.N_root):
-+            e += rho[k*(self.N_root+1)]
-+        return e
-+
-+    @cython.boundscheck(False)
-+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-+        cdef int i, k
-+        cdef QobjEvo c_op
-+        cdef complex expect
-+        for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-+            expect = self.expect(out[i,:])
-+            _axpy(-expect, rho, out[i,:])
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void derivatives(self, double t, int deg, complex[::1] rho,
-+                          complex[::1] a, complex[:, ::1] b,
-+                          complex[:, :, ::1] Lb, complex[:,::1] La,
-+                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-+                          complex[::1] L0a):
-+        """
-+        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
-+        dY ~ a dt + bi dwi
-+                                         deg   use        noise
-+        b[i.:]       bi                   >=0   d2 euler   dwi
-+        a[:]         a                    >=0   d1 euler   dt
-+        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-+        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-+        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-+        La[i,:]      ba'                  >=2   taylor15   dzi
-+        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-+        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-+        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-+        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-+        """
-+        cdef int i, j, k
-+        cdef QobjEvo c_op
-+        cdef QobjEvo c_opj
-+        cdef complex trApp, trAbb, trAa
-+        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
-+        cdef complex[:, ::1] trAb = self.expect_buffer_2d
-+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-+        #_zero(temp)
-+
-+        # a
-+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-+
-+        # b
-+        for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            # bi
-+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
-+            trAp[i] = self.expect(b[i,:])
-+            _axpy(-trAp[i], rho, b[i,:])
-+
-+        # Libj = bibj', i<=j
-+        # sc_ops must commute (Libj = Ljbi)
-+        if deg >= 1:
-+          for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            for j in range(i, self.num_ops):
-+                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
-+                trAb[i,j] = self.expect(Lb[i,j,:])
-+                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
-+                _axpy(-trAb[i,j], rho, Lb[i,j,:])
-+
-+        # L0b La LLb
-+        if deg >= 2:
-+          for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            # Lia = bia'
-+            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-+
-+            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
-+            # db/dt
-+            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
-+            trApp = self.expect(L0b[i,:])
-+            _axpy(-trApp, rho, L0b[i,:])
-+            _axpy(-1, b[i,:], L0b[i,:])
-+            # ab'
-+            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
-+            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-+            trAa = self.expect(temp)
-+            _axpy(1., temp, L0b[i,:])
-+            _axpy(-trAp[i], a[:], L0b[i,:])
-+            _axpy(-trAa, rho, L0b[i,:])
-+            # bbb" : trAb[i,j] only defined for j>=i
-+            for j in range(i):
-+                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-+            for j in range(i,self.num_ops):
-+                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-+
-+            # LLb
-+            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
-+            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
-+            for j in range(i,self.num_ops):
-+              for k in range(j,self.num_ops):
-+                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
-+                trAbb = self.expect(LLb[i,j,k,:])
-+                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
-+                _axpy(-trAbb, rho, LLb[i,j,k,:])
-+                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
-+                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
-+
-+        # L0a = a'a + da/dt + bba"/2  (a" = 0)
-+        if deg == 2:
-+            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-+            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-+            _axpy(-1, a, L0a)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void derivativesO2(self, double t, complex[::1] rho,
-+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-+                            complex[::1] L0a,
-+                            complex[::1] LLa, complex[::1] LL0b,
-+                            complex[::1] L0Lb, complex[::1] LLLb):
-+        """
-+        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-+        Use Stratonovich-Taylor expansion.
-+        One one sc_ops
-+        dY ~ a dt + bi dwi
-+
-+        b[:]     b                        d2 euler    dw
-+        a[:]     a- Lb/2                  d1 euler    dt
-+        Lb[:]    b'b                      milstein    dw^2/2
-+        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-+        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-+        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-+        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-+
-+        LLa[:]   ...                      taylor2.0   dwdt-dz
-+        LL0b[:]  ...                      taylor2.0   dz
-+        L0Lb[:]  ...                      taylor2.0   dw^3/6
-+        LLLb[:]  ...                      taylor2.0   dt^2/2
-+        """
-+        cdef int i, j, k
-+        cdef QobjEvo c_op = self.c_ops[0]
-+        cdef QobjEvo c_opj
-+        cdef complex trAp, trApt
-+        cdef complex trAb, trALb, trALLb
-+        cdef complex trAa, trALa
-+        cdef complex trAL0b
-+
-+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-+        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-+
-+        # b
-+        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
-+        trAp = self.expect(b)
-+        _axpy(-trAp, rho, b)
-+
-+        # Lb = b'b
-+        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
-+        trAb = self.expect(Lb)
-+        _axpy(-trAp, b, Lb)
-+        _axpy(-trAb, rho, Lb)
-+
-+        # LLb = b'Lb+b"bb
-+        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
-+        trALb = self.expect(LLb)
-+        _axpy(-trAp, Lb, LLb)
-+        _axpy(-trALb, rho, LLb)
-+        _axpy(-trAb*2, b, LLb)
-+
-+        # LLLb = b'LLb + 3 b"bLb + b"'bbb
-+        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
-+        trALLb = self.expect(LLLb)
-+        _axpy(-trAp, LLb, LLLb)
-+        _axpy(-trALLb, rho, LLLb)
-+        _axpy(-trALb*3, b, LLLb)
-+        _axpy(-trAb*3, Lb, LLLb)
-+
-+        # _a_ = a - Lb/2
-+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-+        _axpy(-0.5*self.dt, Lb, a)
-+
-+        # L_a_ = ba' - LLb/2
-+        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-+        _axpy(-0.5*self.dt, LLb, La)
-+
-+        # LL_a_ = b(La)' - LLLb/2
-+        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-+        _axpy(-0.5*self.dt, LLLb, LLa)
-+
-+        # _L0_b = b'(_a_)
-+        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
-+        trAa = self.expect(L0b)
-+        _axpy(-trAp, a, L0b)
-+        _axpy(-trAa, rho, L0b)
-+
-+        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
-+        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
-+        trAL0b = self.expect(L0Lb)
-+        _axpy(-trAp, L0b, L0Lb)
-+        _axpy(-trAL0b, rho, L0Lb)
-+        _axpy(-trAa, b, L0Lb)
-+        _axpy(-trAb, a, L0Lb)
-+
-+        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
-+        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
-+        trAL0b = self.expect(LL0b)
-+        _axpy(-trAp, La, LL0b)
-+        _axpy(-trAL0b, rho, LL0b)
-+        _axpy(-trAa, b, LL0b)
-+        _axpy(-trAb, a, LL0b)
-+
-+        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
-+        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-+        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-+        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
-+        _axpy(-1, a, L0a)
-+        _axpy(-self.dt*0.5, L0Lb, L0a)
-+
-+
-+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-+                                        complex[::1] out,
-+                                        np.ndarray[complex, ndim=1] guess) except *:
-+        # np.ndarray to memoryview is OK but not the reverse
-+        # scipy function only take np array, not memoryview
-+        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
-+                                          dvec, x0=guess,
-+                                          tol=self.tol, atol=1e-12)
-+        cdef int i
-+        copy(spout,out)
-+
-+
-+cdef class PcSSESolver(StochasticSolver):
-+    """photocurrent for Schrodinger equation"""
-+    cdef QobjEvo L
-+    cdef object c_ops
-+    cdef object cdc_ops
-+
-+    def set_data(self, sso):
-+        L = sso.LH
-+        c_ops = sso.sops
-+        self.l_vec = L.shape[0]
-+        self.num_ops = len(c_ops)
-+        self.L = L
-+        self.c_ops = []
-+        self.cdc_ops = []
-+        for i, op in enumerate(c_ops):
-+            self.c_ops.append(op[0])
-+            self.cdc_ops.append(op[1])
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void photocurrent(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        cdef QobjEvo c_op
-+        cdef double rand
-+        cdef int i, which = -1
-+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-+        cdef complex[::1] d2 = self.buffer_1d[0,:]
-+
-+        copy(vec, out)
-+        self.d1(t, vec, out)
-+        rand = np.random.rand()
-+        for i in range(self.num_ops):
-+            c_op = self.cdc_ops[i]
-+            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-+            if expects[i].real * dt >= 1e-15:
-+                rand -= expects[i].real *dt
-+            if rand < 0:
-+                which = i
-+                noise[i] = 1.
-+                break
-+
-+        if which >= 0:
-+            self.collapse(t, which, expects[which].real, vec, d2)
-+            _axpy(1, d2, out)
-+            _axpy(-1, vec, out)
-+
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        cdef QobjEvo c_op
-+        cdef double expect
-+        cdef int i, which=0, num_coll=0, did_collapse=0
-+        cdef complex[::1] tmp = self.buffer_1d[0,:]
-+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-+        cdef np.ndarray[int, ndim=1] colls
-+
-+        # Collapses are computed first
-+        for i in range(self.num_ops):
-+            c_op = self.cdc_ops[i]
-+            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-+            if expects[i].real > 0:
-+                did_collapse = np.random.poisson(expects[i].real * dt)
-+                num_coll += did_collapse
-+                if did_collapse:
-+                    which = i
-+                noise[i] = did_collapse * 1.
-+            else:
-+                noise[i] = 0.
-+
-+        if num_coll == 0:
-+            pass
-+        elif num_coll == 1:
-+            # Do one collapse
-+            self.collapse(t, which, expects[which].real, vec, out)
-+            copy(out, vec)
-+        elif num_coll and noise[which] == num_coll:
-+            # Do many collapse of one sc_ops.
-+            # Recompute the expectation value, but only to check for zero.
-+            c_op = self.cdc_ops[which]
-+            for i in range(num_coll):
-+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-+                if expect * dt >= 1e-15:
-+                    self.collapse(t, which, expect, vec, out)
-+                    copy(out,vec)
-+        elif num_coll >= 2:
-+            # 2 or more collapses of different operators
-+            # Ineficient, should be rare
-+            coll = []
-+            for i in range(self.num_ops):
-+                coll += [i]*int(noise[i])
-+            np.random.shuffle(coll)
-+            for i in coll:
-+                c_op = self.cdc_ops[i]
-+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-+                if expect * dt >= 1e-15:
-+                    self.collapse(t, i, expect, vec, out)
-+                    copy(out,vec)
-+        copy(vec,tmp)
-+        copy(vec,out)
-+        self.d1(t, vec, tmp)
-+        self.d1(t+dt, tmp, out)
-+        _scale(0.5, out)
-+        _axpy(0.5, tmp, out)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-+        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-+        cdef int i
-+        cdef complex e
-+        cdef QobjEvo c_op
-+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-+        for i in range(self.num_ops):
-+            _zero(temp)
-+            c_op = self.c_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-+            e = _dznrm2(temp)
-+            _axpy(0.5 * e * e * self.dt, vec, out)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-+        cdef int i
-+        cdef QobjEvo c_op
-+        cdef complex expect
-+        for i in range(self.num_ops):
-+            c_op = self.c_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
-+            expect = _dznrm2(out[i,:])
-+            if expect.real >= 1e-15:
-+                _zscale(1/expect, out[i,:])
-+            else:
-+                _zero(out[i,:])
-+            _axpy(-1, vec, out[i,:])
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void collapse(self, double t, int which, double expect,
-+                       complex[::1] vec, complex[::1] out):
-+        cdef QobjEvo c_op
-+        c_op = self.c_ops[which]
-+        _zero(out)
-+        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-+        _zscale(1/expect, out)
-+
-+
-+cdef class PcSMESolver(StochasticSolver):
-+    """photocurrent for master equation"""
-+    cdef QobjEvo L
-+    cdef object cdcr_cdcl_ops
-+    cdef object cdcl_ops
-+    cdef object clcdr_ops
-+    cdef int N_root
-+
-+    def set_data(self, sso):
-+        L = sso.LH
-+        c_ops = sso.sops
-+        self.l_vec = L.shape[0]
-+        self.num_ops = len(c_ops)
-+        self.L = L
-+        self.cdcr_cdcl_ops = []
-+        self.cdcl_ops = []
-+        self.clcdr_ops = []
-+        self.N_root = np.sqrt(self.l_vec)
-+        for i, op in enumerate(c_ops):
-+            self.cdcr_cdcl_ops.append(op[0])
-+            self.cdcl_ops.append(op[1])
-+            self.clcdr_ops.append(op[2])
-+
-+    cdef void _normalize_inplace(self, complex[::1] vec):
-+        _normalize_rho(vec)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void photocurrent(self, double t, double dt,  double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        cdef QobjEvo c_op
-+        cdef double rand
-+        cdef int i, which = -1
-+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-+        cdef complex[::1] d2 = self.buffer_1d[0,:]
-+
-+        copy(vec, out)
-+        self.d1(t, vec, out)
-+        rand = np.random.rand()
-+        for i in range(self.num_ops):
-+            c_op = self.clcdr_ops[i]
-+            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-+            if expects[i].real * dt >= 1e-15:
-+                rand -= expects[i].real *dt
-+            if rand < 0:
-+                which = i
-+                noise[i] = 1.
-+                break
-+
-+        if which >= 0:
-+            self.collapse(t, which, expects[which].real, vec, d2)
-+            _axpy(1, d2, out)
-+            _axpy(-1, vec, out)
-+
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        cdef QobjEvo c_op
-+        cdef int i, which, num_coll=0, did_collapse
-+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-+        cdef complex[::1] tmp = self.buffer_1d[0,:]
-+        cdef double expect
-+        cdef np.ndarray[int, ndim=1] colls
-+
-+        # Collapses are computed first
-+        for i in range(self.num_ops):
-+            c_op = self.clcdr_ops[i]
-+            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-+            if expects[i].real > 0:
-+                did_collapse = np.random.poisson(expects[i].real* dt)
-+                num_coll += did_collapse
-+                if did_collapse:
-+                    which = i
-+                noise[i] = did_collapse * 1.
-+            else:
-+                noise[i] = 0.
-+
-+        if num_coll == 0:
-+            pass
-+        elif num_coll == 1:
-+            # Do one collapse
-+            self.collapse(t, which, expects[which].real, vec, out)
-+            copy(out,vec)
-+        elif noise[which] == num_coll:
-+            # Do many collapse of one sc_ops.
-+            # Recompute the expectation value, but only to check for zero.
-+            c_op = self.clcdr_ops[which]
-+            for i in range(num_coll):
-+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-+                if expect * dt >= 1e-15:
-+                    self.collapse(t, which, expect, vec, out)
-+                    copy(out,vec)
-+        elif num_coll >= 2:
-+            # 2 or more collapses of different operators
-+            # Ineficient, should be rare
-+            coll = []
-+            for i in range(self.num_ops):
-+                coll += [i] * int(noise[i])
-+            np.random.shuffle(coll)
-+            for i in coll:
-+                c_op = self.clcdr_ops[i]
-+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-+                if expect * dt >= 1e-15:
-+                    self.collapse(t, i, expect, vec, out)
-+                    copy(out,vec)
-+
-+        copy(vec,tmp)
-+        copy(vec,out)
-+        self.d1(t, vec, tmp)
-+        self.d1(t+dt, tmp, out)
-+        _scale(0.5, out)
-+        _axpy(0.5, tmp, out)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef complex expect(self, complex[::1] rho):
-+        cdef complex e = 0.
-+        cdef int k
-+        for k in range(self.N_root):
-+            e += rho[k*(self.N_root+1)]
-+        return e
-+
-+    @cython.boundscheck(False)
-+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-+        cdef int i
-+        cdef QobjEvo c_op
-+        cdef complex[::1] crho = self.func_buffer_1d[0,:]
-+        cdef complex expect
-+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-+        for i in range(self.num_ops):
-+            c_op = self.cdcr_cdcl_ops[i]
-+            _zero(crho)
-+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
-+            expect = self.expect(crho)
-+            _axpy(0.5*expect* self.dt, rho, out)
-+            _axpy(-0.5* self.dt, crho, out)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-+        cdef int i
-+        cdef QobjEvo c_op
-+        cdef complex expect
-+        for i in range(self.num_ops):
-+            c_op = self.clcdr_ops[i]
-+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-+            expect = self.expect(out[i,:])
-+            if expect.real >= 1e-15:
-+                _zscale((1.+0j)/expect, out[i,:])
-+            else:
-+                _zero(out[i,:])
-+            _axpy(-1, rho, out[i,:])
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef void collapse(self, double t, int which, double expect,
-+                       complex[::1] vec, complex[::1] out):
-+        cdef QobjEvo c_op
-+        c_op = self.clcdr_ops[which]
-+        _zero(out)
-+        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-+        _zscale(1./expect, out)
-+
-+cdef class PmSMESolver(StochasticSolver):
-+    """positive map for master equation"""
-+    cdef object L
-+    cdef QobjEvo pp_ops
-+    cdef QobjEvo preLH
-+    cdef QobjEvo postLH
-+    cdef object sops
-+    cdef object preops
-+    cdef object postops
-+    cdef object preops2
-+    cdef object postops2
-+    cdef int N_root
-+
-+    def set_data(self, sso):
-+        c_ops = sso.sops
-+        self.l_vec = sso.pp.shape[0]
-+        self.num_ops = len(c_ops)
-+        self.preLH = sso.preLH
-+        self.postLH = sso.postLH
-+        self.pp_ops = sso.pp
-+        self.sops = [op for op in sso.sops]
-+        self.preops = [op for op in sso.preops]
-+        self.postops = [op for op in sso.postops]
-+        self.preops2 = [op for op in sso.preops2]
-+        self.postops2 = [op for op in sso.postops2]
-+        self.N_root = np.sqrt(self.l_vec)
-+
-+    cdef void _normalize_inplace(self, complex[::1] vec):
-+        _normalize_rho(vec)
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    cdef void rouchon(self, double t, double dt, double[:] noise,
-+                           complex[::1] vec, complex[::1] out):
-+        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
-+        cdef complex[::1] temp = self.buffer_1d[0,:]
-+        cdef complex[::1] temp2 = self.buffer_1d[1,:]
-+        cdef int i, j, k
-+        cdef QobjEvo c_op, c_opj
-+        cdef complex ddw, tr
-+        _zero(out)
-+        _zero(temp)
-+        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-+        for i in range(self.num_ops):
-+            c_op = self.sops[i]
-+            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
-+            c_op = self.preops[i]
-+            _zero(temp2)
-+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-+            _axpy(dy[i], temp2, temp)
-+
-+        k = 0
-+        for i in range(self.num_ops):
-+            for j in range(i, self.num_ops):
-+                c_op = self.preops2[k]
-+                if i == j:
-+                    ddw = (dy[i]*dy[j] - dt) *0.5
-+                else:
-+                    ddw = (dy[i]*dy[j])
-+
-+                _zero(temp2)
-+                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-+                _axpy(ddw, temp2, temp)
-+                k += 1
-+
-+        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-+        for i in range(self.num_ops):
-+            dy[i] = conj(dy[i])
-+            c_op = self.postops[i]
-+            _zero(temp2)
-+            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-+            _axpy(dy[i], temp2, out)
-+
-+        k = 0
-+        for i in range(self.num_ops):
-+            for j in range(i, self.num_ops):
-+                c_op = self.postops2[k]
-+                if i == j:
-+                    ddw = (dy[i]*dy[j] - dt) *0.5
-+                else:
-+                    ddw = (dy[i]*dy[j])
-+                _zero(temp2)
-+                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-+                _axpy(ddw, temp2, out)
-+                k += 1
-+
-+        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-+        tr = self.expect(out)
-+        _zscale(1./tr, out)
-+
-+
-+    @cython.boundscheck(False)
-+    @cython.wraparound(False)
-+    @cython.cdivision(True)
-+    cdef complex expect(self, complex[::1] rho):
-+        cdef complex e = 0.
-+        cdef int k
-+        for k in range(self.N_root):
-+            e += rho[k*(self.N_root+1)]
-+        return e
-+
-+
-+cdef class GenericSSolver(StochasticSolver):
-+    """support for user defined system"""
-+    cdef object d1_func, d2_func
-+
-+    def set_data(self, sso):
-+        self.l_vec = sso.rho0.shape[0]
-+        self.num_ops = len(sso.sops)
-+        self.d1_func = sso.d1
-+        self.d2_func = sso.d2
-+
-+
-+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-+        cdef np.ndarray[complex, ndim=1] in_np
-+        cdef np.ndarray[complex, ndim=1] out_np
-+        in_np = np.zeros((self.l_vec, ), dtype=complex)
-+        copy(rho, in_np)
-+        out_np = self.d1_func(t, in_np)
-+        _axpy(self.dt, out_np, out) # d1 is += and * dt
-+
-+    @cython.boundscheck(False)
-+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-+        cdef np.ndarray[complex, ndim=1] in_np
-+        cdef np.ndarray[complex, ndim=2] out_np
-+        cdef int i
-+        in_np = np.zeros((self.l_vec, ), dtype=complex)
-+        copy(rho, in_np)
-+        out_np = self.d2_func(t, in_np)
-+        for i in range(self.num_ops):
-+            copy(out_np[i,:], out[i,:])
-diff --git a/qutip/solve/nonmarkov/memorycascade.py b/qutip/solve/nonmarkov/memorycascade.py
-index 35996d21..488b2515 100644
---- a/qutip/solve/nonmarkov/memorycascade.py
-+++ b/qutip/solve/nonmarkov/memorycascade.py
-@@ -1,405 +1,405 @@
--# -*- coding: utf-8 -*-
--
--# @author: Arne L. Grimsmo
--# @email1: arne.grimsmo@gmail.com
--# @organization: University of Sherbrooke
--
--"""
--This module is an implementation of the method introduced in [1], for
--solving open quantum systems subject to coherent feedback with a single
--discrete time-delay. This method is referred to as the ``memory cascade''
--method in qutip.
--
--[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
--"""
--
--import numpy as np
--import warnings
--
--import qutip as qt
--
--
--class MemoryCascade:
--    """Class for running memory cascade simulations of open quantum systems
--    with time-delayed coherent feedback.
--
--    Attributes
--    ----------
--    H_S : :class:`qutip.Qobj`
--        System Hamiltonian (can also be a Liouvillian)
--
--    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
--        System operators coupling into the feedback loop. Can be a single
--        operator or a list of operators.
--
--    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
--        System operators coupling out of the feedback loop. Can be a single
--        operator or a list of operators. L2 must have the same length as L1.
--
--    S_matrix: *array*
--        S matrix describing which operators in L1 are coupled to which
--        operators in L2 by the feedback channel. Defaults to an n by n identity
--        matrix where n is the number of elements in L1/L2.
--
--    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
--        Decay operators describing conventional Markovian decay channels.
--        Can be a single operator or a list of operators.
--
--    integrator : str {'propagator', 'mesolve'}
--        Integrator method to use. Defaults to 'propagator' which tends to be
--        faster for long times (i.e., large Hilbert space).
--
--    parallel : bool
--        Run integrator in parallel if True. Only implemented for 'propagator'
--        as the integrator method.
--
--    options : dict
--        Generic solver options.
--    """
--
--    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
--                 integrator='propagator', parallel=False, options=None):
--
--        if options is None:
--            self.options = {}
--        else:
--            self.options = options
--
--        self.H_S = H_S
--        self.sysdims = H_S.dims
--        if isinstance(L1, qt.Qobj):
--            self.L1 = [L1]
--        else:
--            self.L1 = L1
--        if isinstance(L2, qt.Qobj):
--            self.L2 = [L2]
--        else:
--            self.L2 = L2
--        if not len(self.L1) == len(self.L2):
--            raise ValueError('L1 and L2 has to be of equal length.')
--        if isinstance(c_ops_markov, qt.Qobj):
--            self.c_ops_markov = [c_ops_markov]
--        else:
--            self.c_ops_markov = c_ops_markov
--
--        if S_matrix is None:
--            self.S_matrix = np.identity(len(self.L1))
--        else:
--            self.S_matrix = S_matrix
--        # create system identity superoperator
--        self.Id = qt.qeye(H_S.shape[0])
--        self.Id.dims = self.sysdims
--        self.Id = qt.sprepost(self.Id, self.Id)
--        self.store_states = self.options['store_states']
--        self.integrator = integrator
--        self.parallel = parallel
--
--    def propagator(self, t, tau, notrace=False):
--        """
--        Compute propagator for time t and time-delay tau
--
--        Parameters
--        ----------
--        t : *float*
--            current time
--
--        tau : *float*
--            time-delay
--
--        notrace : *bool* {False}
--            If this optional is set to True, a propagator is returned for a
--            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
--            If set to False (default), a generalized partial trace is performed
--            and a propagator for a single system is returned.
--        Returns
--        -------
--        : :class:`qutip.Qobj`
--            time-propagator for reduced system dynamics
--        """
--        k = int(t/tau)+1
--        s = t-(k-1)*tau
--        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
--                            self.c_ops_markov)
--        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
--                       parallel=self.parallel, opt=self.options)
--        if k > 1:
--            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
--                                  self.S_matrix, self.c_ops_markov)
--            G2 = qt.composite(G2, self.Id)
--            E = _integrate(G2, E, s, tau, integrator=self.integrator,
--                    parallel=self.parallel, opt=self.options)
--        E.dims = E0.dims
--        if not notrace:
--            E = _genptrace(E, k)
--        return E
--
--    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
--                           notrace=False):
--        r"""
--        Compute propagator for computing output field expectation values
--        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
--        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
--
--        Parameters
--        ----------
--        blist : array_like
--            List of integers specifying the field operators:
--            0: I (nothing)
--            1: b_out
--            2: b_out^\dagger
--            3: b_loop
--            4: b_loop^\dagger
--
--        tlist : array_like
--            list of corresponding times t1,..,tn at which to evaluate the field
--            operators
--
--        tau : float
--            time-delay
--
--        c1 : :class:`qutip.Qobj`
--            system collapse operator that couples to the in-loop field in
--            question (only needs to be specified if self.L1 has more than one
--            element)
--
--        c2 : :class:`qutip.Qobj`
--            system collapse operator that couples to the output field in
--            question (only needs to be specified if self.L2 has more than one
--            element)
--
--        notrace : bool {False}
--            If this optional is set to True, a propagator is returned for a
--            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
--            If set to False (default), a generalized partial trace is performed
--            and a propagator for a single system is returned.
--
--        Returns
--        -------
--        : :class:`qutip.Qobj`
--            time-propagator for computing field correlation function
--        """
--        if c1 is None and len(self.L1) == 1:
--            c1 = self.L1[0]
--        else:
--            raise ValueError('Argument c1 has to be specified when more than' +
--                             'one collapse operator couples to the feedback' +
--                             'loop.')
--        if c2 is None and len(self.L2) == 1:
--            c2 = self.L2[0]
--        else:
--            raise ValueError('Argument c1 has to be specified when more than' +
--                             'one collapse operator couples to the feedback' +
--                             'loop.')
--        klist = []
--        slist = []
--        for t in tlist:
--            klist.append(int(t/tau)+1)
--            slist.append(t-(klist[-1]-1)*tau)
--        kmax = max(klist)
--        zipped = sorted(zip(slist, klist, blist))
--        slist = [s for (s, k, b) in zipped]
--        klist = [k for (s, k, b) in zipped]
--        blist = [b for (s, k, b) in zipped]
--
--        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
--                            self.c_ops_markov)
--        sprev = 0.
--        E = E0
--        for i, s in enumerate(slist):
--            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
--                    parallel=self.parallel, opt=self.options)
--            if klist[i] == 1:
--                l1 = 0.*qt.Qobj()
--            else:
--                l1 = _localop(c1, klist[i]-1, kmax)
--            l2 = _localop(c2, klist[i], kmax)
--            if blist[i] == 0:
--                superop = self.Id
--            elif blist[i] == 1:
--                superop = qt.spre(l1+l2)
--            elif blist[i] == 2:
--                superop = qt.spost(l1.dag()+l2.dag())
--            elif blist[i] == 3:
--                superop = qt.spre(l1)
--            elif blist[i] == 4:
--                superop = qt.spost(l1.dag())
--            else:
--                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
--                                 'and 4.')
--            superop.dims = E.dims
--            E = superop*E
--            sprev = s
--        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
--                parallel=self.parallel, opt=self.options)
--
--        E.dims = E0.dims
--        if not notrace:
--            E = _genptrace(E, kmax)
--        return E
--
--    def rhot(self, rho0, t, tau):
--        """
--        Compute the reduced system density matrix :math:`\\rho(t)`
--
--        Parameters
--        ----------
--        rho0 : :class:`qutip.Qobj`
--            initial density matrix or state vector (ket)
--
--        t : float
--            current time
--
--        tau : float
--            time-delay
--
--        Returns
--        -------
--        : :class:`qutip.Qobj`
--            density matrix at time :math:`t`
--        """
--        if qt.isket(rho0):
--            rho0 = qt.ket2dm(rho0)
--
--        E = self.propagator(t, tau)
--        rhovec = qt.operator_to_vector(rho0)
--        return qt.vector_to_operator(E*rhovec)
--
--    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
--        r"""
--        Compute output field expectation value
--        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
--        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
--
--
--        Parameters
--        ----------
--        rho0 : :class:`qutip.Qobj`
--            initial density matrix or state vector (ket).
--
--        blist : array_like
--            List of integers specifying the field operators:
--            0: I (nothing)
--            1: b_out
--            2: b_out^\dagger
--            3: b_loop
--            4: b_loop^\dagger
--
--        tlist : array_like
--            list of corresponding times t1,..,tn at which to evaluate the field
--            operators
--
--        tau : float
--            time-delay
--
--        c1 : :class:`qutip.Qobj`
--            system collapse operator that couples to the in-loop field in
--            question (only needs to be specified if self.L1 has more than one
--            element)
--
--        c2 : :class:`qutip.Qobj`
--            system collapse operator that couples to the output field in
--            question (only needs to be specified if self.L2 has more than one
--            element)
--
--        Returns
--        -------
--        : complex
--            expectation value of field correlation function
--        """
--        E = self.outfieldpropagator(blist, tlist, tau)
--        rhovec = qt.operator_to_vector(rho0)
--        return (qt.vector_to_operator(E*rhovec)).tr()
--
--
--def _localop(op, l, k):
--    """
--    Create a local operator on the l'th system by tensoring
--    with identity operators on all the other k-1 systems
--    """
--    if l < 1 or l > k:
--        raise IndexError('index l out of range')
--    h = op
--    I = qt.qeye(op.shape[0])
--    I.dims = op.dims
--    for i in range(1, l):
--        h = qt.tensor(I, h)
--    for i in range(l+1, k+1):
--        h = qt.tensor(h, I)
--    return h
--
--
--def _genptrace(E, k):
--    """
--    Perform a gneralized partial trace on a superoperator E, tracing out all
--    subsystems but one.
--    """
--    for l in range(k-1):
--        nsys = len(E.dims[0][0])
--        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
--    return E
--
--
--def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
--    """
--    Create a Liouvillian for a cascaded chain of k system copies
--    """
--    id = qt.qeye(H.dims[0][0])
--    Id = qt.sprepost(id, id)
--    if S is None:
--        S = np.identity(len(L1))
--    # create Lindbladian
--    L = qt.Qobj()
--    E0 = Id
--    # first system
--    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
--    for l in range(1, k):
--        # Identiy superoperator
--        E0 = qt.composite(E0, Id)
--        # Bare Hamiltonian
--        Hl = _localop(H, l, k)
--        L += qt.liouvillian(Hl, [])
--        # Markovian Decay channels
--        if c_ops_markov is not None:
--            for c in c_ops_markov:
--                cl = _localop(c, l, k)
--                L += qt.liouvillian(None, [cl])
--        # Cascade coupling
--        c1 = np.array([_localop(c, l, k) for c in L1])
--        c2 = np.array([_localop(c, l+1, k) for c in L2])
--        c2dag = np.array([c.dag() for c in c2])
--        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
--        Hcasc += Hcasc.dag()
--        Lvec = c2 + np.dot(S, c1)
--        L += qt.liouvillian(Hcasc, [c for c in Lvec])
--    # last system
--    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
--    if c_ops_markov is not None:
--        for c in c_ops_markov:
--            cl = _localop(c, k, k)
--            L += qt.liouvillian(None, [cl])
--    E0.dims = L.dims
--    # return generator and identity superop E0
--    return L, E0
--
--
--def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
--        opt=None):
--    """
--    Basic ode integrator
--    """
--    opt = opt or {}
--    if tf > ti:
--        if integrator == 'mesolve':
--            if parallel:
--                warnings.warn('parallelization not implemented for "mesolve"')
--            opt.store_final_state = True
--            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
--            return sol.final_state
--        elif integrator == 'propagator':
--            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
--                                 options=opt)*E0
--        else:
--            raise ValueError('integrator keyword must be either "propagator"' +
--                              'or "mesolve"')
--    else:
--        return E0
-+# -*- coding: utf-8 -*-
-+
-+# @author: Arne L. Grimsmo
-+# @email1: arne.grimsmo@gmail.com
-+# @organization: University of Sherbrooke
-+
-+"""
-+This module is an implementation of the method introduced in [1], for
-+solving open quantum systems subject to coherent feedback with a single
-+discrete time-delay. This method is referred to as the ``memory cascade''
-+method in qutip.
-+
-+[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
-+"""
-+
-+import numpy as np
-+import warnings
-+
-+import qutip as qt
-+
-+
-+class MemoryCascade:
-+    """Class for running memory cascade simulations of open quantum systems
-+    with time-delayed coherent feedback.
-+
-+    Attributes
-+    ----------
-+    H_S : :class:`qutip.Qobj`
-+        System Hamiltonian (can also be a Liouvillian)
-+
-+    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-+        System operators coupling into the feedback loop. Can be a single
-+        operator or a list of operators.
-+
-+    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-+        System operators coupling out of the feedback loop. Can be a single
-+        operator or a list of operators. L2 must have the same length as L1.
-+
-+    S_matrix: *array*
-+        S matrix describing which operators in L1 are coupled to which
-+        operators in L2 by the feedback channel. Defaults to an n by n identity
-+        matrix where n is the number of elements in L1/L2.
-+
-+    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-+        Decay operators describing conventional Markovian decay channels.
-+        Can be a single operator or a list of operators.
-+
-+    integrator : str {'propagator', 'mesolve'}
-+        Integrator method to use. Defaults to 'propagator' which tends to be
-+        faster for long times (i.e., large Hilbert space).
-+
-+    parallel : bool
-+        Run integrator in parallel if True. Only implemented for 'propagator'
-+        as the integrator method.
-+
-+    options : dict
-+        Generic solver options.
-+    """
-+
-+    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
-+                 integrator='propagator', parallel=False, options=None):
-+
-+        if options is None:
-+            self.options = {}
-+        else:
-+            self.options = options
-+
-+        self.H_S = H_S
-+        self.sysdims = H_S.dims
-+        if isinstance(L1, qt.Qobj):
-+            self.L1 = [L1]
-+        else:
-+            self.L1 = L1
-+        if isinstance(L2, qt.Qobj):
-+            self.L2 = [L2]
-+        else:
-+            self.L2 = L2
-+        if not len(self.L1) == len(self.L2):
-+            raise ValueError('L1 and L2 has to be of equal length.')
-+        if isinstance(c_ops_markov, qt.Qobj):
-+            self.c_ops_markov = [c_ops_markov]
-+        else:
-+            self.c_ops_markov = c_ops_markov
-+
-+        if S_matrix is None:
-+            self.S_matrix = np.identity(len(self.L1))
-+        else:
-+            self.S_matrix = S_matrix
-+        # create system identity superoperator
-+        self.Id = qt.qeye(H_S.shape[0])
-+        self.Id.dims = self.sysdims
-+        self.Id = qt.sprepost(self.Id, self.Id)
-+        self.store_states = self.options['store_states']
-+        self.integrator = integrator
-+        self.parallel = parallel
-+
-+    def propagator(self, t, tau, notrace=False):
-+        """
-+        Compute propagator for time t and time-delay tau
-+
-+        Parameters
-+        ----------
-+        t : *float*
-+            current time
-+
-+        tau : *float*
-+            time-delay
-+
-+        notrace : *bool* {False}
-+            If this optional is set to True, a propagator is returned for a
-+            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
-+            If set to False (default), a generalized partial trace is performed
-+            and a propagator for a single system is returned.
-+        Returns
-+        -------
-+        : :class:`qutip.Qobj`
-+            time-propagator for reduced system dynamics
-+        """
-+        k = int(t/tau)+1
-+        s = t-(k-1)*tau
-+        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
-+                            self.c_ops_markov)
-+        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
-+                       parallel=self.parallel, opt=self.options)
-+        if k > 1:
-+            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
-+                                  self.S_matrix, self.c_ops_markov)
-+            G2 = qt.composite(G2, self.Id)
-+            E = _integrate(G2, E, s, tau, integrator=self.integrator,
-+                    parallel=self.parallel, opt=self.options)
-+        E.dims = E0.dims
-+        if not notrace:
-+            E = _genptrace(E, k)
-+        return E
-+
-+    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
-+                           notrace=False):
-+        r"""
-+        Compute propagator for computing output field expectation values
-+        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
-+        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
-+
-+        Parameters
-+        ----------
-+        blist : array_like
-+            List of integers specifying the field operators:
-+            0: I (nothing)
-+            1: b_out
-+            2: b_out^\dagger
-+            3: b_loop
-+            4: b_loop^\dagger
-+
-+        tlist : array_like
-+            list of corresponding times t1,..,tn at which to evaluate the field
-+            operators
-+
-+        tau : float
-+            time-delay
-+
-+        c1 : :class:`qutip.Qobj`
-+            system collapse operator that couples to the in-loop field in
-+            question (only needs to be specified if self.L1 has more than one
-+            element)
-+
-+        c2 : :class:`qutip.Qobj`
-+            system collapse operator that couples to the output field in
-+            question (only needs to be specified if self.L2 has more than one
-+            element)
-+
-+        notrace : bool {False}
-+            If this optional is set to True, a propagator is returned for a
-+            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
-+            If set to False (default), a generalized partial trace is performed
-+            and a propagator for a single system is returned.
-+
-+        Returns
-+        -------
-+        : :class:`qutip.Qobj`
-+            time-propagator for computing field correlation function
-+        """
-+        if c1 is None and len(self.L1) == 1:
-+            c1 = self.L1[0]
-+        else:
-+            raise ValueError('Argument c1 has to be specified when more than' +
-+                             'one collapse operator couples to the feedback' +
-+                             'loop.')
-+        if c2 is None and len(self.L2) == 1:
-+            c2 = self.L2[0]
-+        else:
-+            raise ValueError('Argument c1 has to be specified when more than' +
-+                             'one collapse operator couples to the feedback' +
-+                             'loop.')
-+        klist = []
-+        slist = []
-+        for t in tlist:
-+            klist.append(int(t/tau)+1)
-+            slist.append(t-(klist[-1]-1)*tau)
-+        kmax = max(klist)
-+        zipped = sorted(zip(slist, klist, blist))
-+        slist = [s for (s, k, b) in zipped]
-+        klist = [k for (s, k, b) in zipped]
-+        blist = [b for (s, k, b) in zipped]
-+
-+        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
-+                            self.c_ops_markov)
-+        sprev = 0.
-+        E = E0
-+        for i, s in enumerate(slist):
-+            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
-+                    parallel=self.parallel, opt=self.options)
-+            if klist[i] == 1:
-+                l1 = 0.*qt.Qobj()
-+            else:
-+                l1 = _localop(c1, klist[i]-1, kmax)
-+            l2 = _localop(c2, klist[i], kmax)
-+            if blist[i] == 0:
-+                superop = self.Id
-+            elif blist[i] == 1:
-+                superop = qt.spre(l1+l2)
-+            elif blist[i] == 2:
-+                superop = qt.spost(l1.dag()+l2.dag())
-+            elif blist[i] == 3:
-+                superop = qt.spre(l1)
-+            elif blist[i] == 4:
-+                superop = qt.spost(l1.dag())
-+            else:
-+                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
-+                                 'and 4.')
-+            superop.dims = E.dims
-+            E = superop*E
-+            sprev = s
-+        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
-+                parallel=self.parallel, opt=self.options)
-+
-+        E.dims = E0.dims
-+        if not notrace:
-+            E = _genptrace(E, kmax)
-+        return E
-+
-+    def rhot(self, rho0, t, tau):
-+        """
-+        Compute the reduced system density matrix :math:`\\rho(t)`
-+
-+        Parameters
-+        ----------
-+        rho0 : :class:`qutip.Qobj`
-+            initial density matrix or state vector (ket)
-+
-+        t : float
-+            current time
-+
-+        tau : float
-+            time-delay
-+
-+        Returns
-+        -------
-+        : :class:`qutip.Qobj`
-+            density matrix at time :math:`t`
-+        """
-+        if qt.isket(rho0):
-+            rho0 = qt.ket2dm(rho0)
-+
-+        E = self.propagator(t, tau)
-+        rhovec = qt.operator_to_vector(rho0)
-+        return qt.vector_to_operator(E*rhovec)
-+
-+    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
-+        r"""
-+        Compute output field expectation value
-+        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
-+        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
-+
-+
-+        Parameters
-+        ----------
-+        rho0 : :class:`qutip.Qobj`
-+            initial density matrix or state vector (ket).
-+
-+        blist : array_like
-+            List of integers specifying the field operators:
-+            0: I (nothing)
-+            1: b_out
-+            2: b_out^\dagger
-+            3: b_loop
-+            4: b_loop^\dagger
-+
-+        tlist : array_like
-+            list of corresponding times t1,..,tn at which to evaluate the field
-+            operators
-+
-+        tau : float
-+            time-delay
-+
-+        c1 : :class:`qutip.Qobj`
-+            system collapse operator that couples to the in-loop field in
-+            question (only needs to be specified if self.L1 has more than one
-+            element)
-+
-+        c2 : :class:`qutip.Qobj`
-+            system collapse operator that couples to the output field in
-+            question (only needs to be specified if self.L2 has more than one
-+            element)
-+
-+        Returns
-+        -------
-+        : complex
-+            expectation value of field correlation function
-+        """
-+        E = self.outfieldpropagator(blist, tlist, tau)
-+        rhovec = qt.operator_to_vector(rho0)
-+        return (qt.vector_to_operator(E*rhovec)).tr()
-+
-+
-+def _localop(op, l, k):
-+    """
-+    Create a local operator on the l'th system by tensoring
-+    with identity operators on all the other k-1 systems
-+    """
-+    if l < 1 or l > k:
-+        raise IndexError('index l out of range')
-+    h = op
-+    I = qt.qeye(op.shape[0])
-+    I.dims = op.dims
-+    for i in range(1, l):
-+        h = qt.tensor(I, h)
-+    for i in range(l+1, k+1):
-+        h = qt.tensor(h, I)
-+    return h
-+
-+
-+def _genptrace(E, k):
-+    """
-+    Perform a gneralized partial trace on a superoperator E, tracing out all
-+    subsystems but one.
-+    """
-+    for l in range(k-1):
-+        nsys = len(E.dims[0][0])
-+        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
-+    return E
-+
-+
-+def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
-+    """
-+    Create a Liouvillian for a cascaded chain of k system copies
-+    """
-+    id = qt.qeye(H.dims[0][0])
-+    Id = qt.sprepost(id, id)
-+    if S is None:
-+        S = np.identity(len(L1))
-+    # create Lindbladian
-+    L = qt.Qobj()
-+    E0 = Id
-+    # first system
-+    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
-+    for l in range(1, k):
-+        # Identiy superoperator
-+        E0 = qt.composite(E0, Id)
-+        # Bare Hamiltonian
-+        Hl = _localop(H, l, k)
-+        L += qt.liouvillian(Hl, [])
-+        # Markovian Decay channels
-+        if c_ops_markov is not None:
-+            for c in c_ops_markov:
-+                cl = _localop(c, l, k)
-+                L += qt.liouvillian(None, [cl])
-+        # Cascade coupling
-+        c1 = np.array([_localop(c, l, k) for c in L1])
-+        c2 = np.array([_localop(c, l+1, k) for c in L2])
-+        c2dag = np.array([c.dag() for c in c2])
-+        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
-+        Hcasc += Hcasc.dag()
-+        Lvec = c2 + np.dot(S, c1)
-+        L += qt.liouvillian(Hcasc, [c for c in Lvec])
-+    # last system
-+    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
-+    if c_ops_markov is not None:
-+        for c in c_ops_markov:
-+            cl = _localop(c, k, k)
-+            L += qt.liouvillian(None, [cl])
-+    E0.dims = L.dims
-+    # return generator and identity superop E0
-+    return L, E0
-+
-+
-+def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
-+        opt=None):
-+    """
-+    Basic ode integrator
-+    """
-+    opt = opt or {}
-+    if tf > ti:
-+        if integrator == 'mesolve':
-+            if parallel:
-+                warnings.warn('parallelization not implemented for "mesolve"')
-+            opt.store_final_state = True
-+            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
-+            return sol.final_state
-+        elif integrator == 'propagator':
-+            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
-+                                 options=opt)*E0
-+        else:
-+            raise ValueError('integrator keyword must be either "propagator"' +
-+                              'or "mesolve"')
-+    else:
-+        return E0
-diff --git a/qutip/solve/nonmarkov/transfertensor.py b/qutip/solve/nonmarkov/transfertensor.py
-index 561b7554..ccd1ada8 100644
---- a/qutip/solve/nonmarkov/transfertensor.py
-+++ b/qutip/solve/nonmarkov/transfertensor.py
-@@ -1,254 +1,254 @@
--# -*- coding: utf-8 -*-
--# @author: Arne L. Grimsmo
--# @email1: arne.grimsmo@gmail.com
--# @organization: University of Sherbrooke
--
--"""
--This module contains an implementation of the non-Markovian transfer tensor
--method (TTM), introduced in [1].
--
--[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
--"""
--
--import numpy as np
--
--
--from qutip import spre, vector_to_operator, operator_to_vector
--from qutip.core import data as _data
--from ..solver import Result, SolverOptions
--
--
--class TTMSolverOptions:
--    """Class of options for the Transfer Tensor Method solver.
--
--    Attributes
--    ----------
--    dynmaps : list of :class:`qutip.Qobj`
--        List of precomputed dynamical maps (superoperators),
--        or a callback function that returns the
--        superoperator at a given time.
--
--    times : array_like
--        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
--
--    learningtimes : array_like
--        List of times :math:`t_k` to use as learning times if argument
--        `dynmaps` is a callback function.
--
--    thres : float
--        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
--        treshold.
--
--    options : :class:`qutip.solver.SolverOptions`
--        Generic solver options.
--    """
--
--    def __init__(self, dynmaps=None, times=[], learningtimes=[],
--                 thres=0.0, options=None):
--        if options is None:
--            options = SolverOptions()
--
--        self.dynmaps = dynmaps
--        self.times = times
--        self.learningtimes = learningtimes
--        self.thres = thres
--        self.store_states = options['store_states']
--
--
--def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
--             **kwargs):
--    """
--    Solve time-evolution using the Transfer Tensor Method, based on a set of
--    precomputed dynamical maps.
--
--    Parameters
--    ----------
--    dynmaps : list of :class:`qutip.Qobj`
--        List of precomputed dynamical maps (superoperators),
--        or a callback function that returns the
--        superoperator at a given time.
--
--    rho0 : :class:`qutip.Qobj`
--        Initial density matrix or state vector (ket).
--
--    times : array_like
--        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
--        Must be uniformily spaced.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    learningtimes : array_like
--        list of times :math:`t_k` for which we have knowledge of the dynamical
--        maps :math:`E(t_k)`.
--
--    tensors : array_like
--        optional list of precomputed tensors :math:`T_k`
--
--    kwargs : dictionary
--        Optional keyword arguments. See
--        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
--
--    Returns
--    -------
--    output: :class:`qutip.solver.Result`
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--
--    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
--                           learningtimes=learningtimes, **kwargs)
--
--    diff = None
--
--    if rho0.isket:
--        rho0 = rho0.proj()
--
--    output = Result()
--    e_sops_data = []
--
--    if callable(e_ops):
--        n_expt_op = 0
--        expt_callback = True
--
--    else:
--        try:
--            tmp = e_ops[:]
--            del tmp
--
--            n_expt_op = len(e_ops)
--            expt_callback = False
--
--            if n_expt_op == 0:
--                # fall back on storing states
--                opt.store_states = True
--
--            for op in e_ops:
--                e_sops_data.append(spre(op).data)
--                if op.isherm and rho0.isherm:
--                    output.expect.append(np.zeros(len(times)))
--                else:
--                    output.expect.append(np.zeros(len(times), dtype=complex))
--        except TypeError:
--            raise TypeError("Argument 'e_ops' should be a callable or" +
--                            "list-like.")
--
--    if tensors is None:
--        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
--
--    if rho0.isoper:
--        # vectorize density matrix
--        rho0vec = operator_to_vector(rho0)
--    else:
--        # rho0 might be a super in which case we should not vectorize
--        rho0vec = rho0
--
--    K = len(tensors)
--    states = [rho0vec]
--    for n in range(1, len(times)):
--        # Set current state
--        state = None
--        for j in range(1, min(K, n + 1)):
--            tmp = tensors[j] * states[n - j]
--            state = tmp if state is None else tmp + state
--        # Append state to all states
--        states.append(state)
--    for i, r in enumerate(states):
--        if opt.store_states or expt_callback:
--            if r.type == 'operator-ket':
--                states[i] = vector_to_operator(r)
--            else:
--                states[i] = r
--            if expt_callback:
--                # use callback method
--                e_ops(times[i], states[i])
--        rdata = _data.column_stack(r.data)
--        for m in range(n_expt_op):
--            if output.expect[m].dtype == complex:
--                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
--            else:
--                output.expect[m][i] =\
--                    _data.expect_super(e_sops_data[m], rdata).real
--
--    output.solver = "ttmsolve"
--    output.times = times
--
--    output.ttmconvergence = diff
--
--    if opt.store_states:
--        output.states = states
--
--    return output
--
--
--def _generatetensors(dynmaps, learningtimes=None, **kwargs):
--    r"""
--    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
--    :math:`E(t_k)`.
--
--    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
--
--    Parameters
--    ----------
--    dynmaps : list of :class:`qutip.Qobj`
--        List of precomputed dynamical maps (superoperators) at the times
--        specified in `learningtimes`, or a callback function that returns the
--        superoperator at a given time.
--
--    learningtimes : array_like
--        list of times :math:`t_k` to use if argument `dynmaps` is a callback
--        function.
--
--    kwargs : dictionary
--        Optional keyword arguments. See
--        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
--
--    Returns
--    -------
--    Tlist: list of :class:`qutip.Qobj.`
--        A list of transfer tensors :math:`T_1,\dots,T_K`
--    """
--
--    # Determine if dynmaps is callable or list-like
--    if callable(dynmaps):
--        if learningtimes is None:
--            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
--                            "is a callback function.")
--
--        def dynmapfunc(n):
--            return dynmaps(learningtimes[n])
--
--        Kmax = len(learningtimes)
--    else:
--        try:
--            tmp = dynmaps[:]
--            del tmp
--
--            def dynmapfunc(n):
--                return dynmaps[n]
--
--            Kmax = len(dynmaps)
--        except TypeError:
--            raise TypeError("Argument 'dynmaps' should be a callable or" +
--                            "list-like.")
--
--    if "opt" not in kwargs:
--        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
--                               **kwargs)
--    else:
--        opt = kwargs['opt']
--
--    Tlist = []
--    diff = [0.0]
--    for n in range(Kmax):
--        T = dynmapfunc(n)
--        for m in range(1, n):
--            T -= Tlist[n - m] * dynmapfunc(m)
--        Tlist.append(T)
--        if n > 1:
--            diff.append((Tlist[-1] - Tlist[-2]).norm())
--            if diff[-1] < opt.thres:
--                # Below threshold for truncation
--                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
--                break
--    return Tlist, diff
-+# -*- coding: utf-8 -*-
-+# @author: Arne L. Grimsmo
-+# @email1: arne.grimsmo@gmail.com
-+# @organization: University of Sherbrooke
-+
-+"""
-+This module contains an implementation of the non-Markovian transfer tensor
-+method (TTM), introduced in [1].
-+
-+[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
-+"""
-+
-+import numpy as np
-+
-+
-+from qutip import spre, vector_to_operator, operator_to_vector
-+from qutip.core import data as _data
-+from ..solver import Result, SolverOptions
-+
-+
-+class TTMSolverOptions:
-+    """Class of options for the Transfer Tensor Method solver.
-+
-+    Attributes
-+    ----------
-+    dynmaps : list of :class:`qutip.Qobj`
-+        List of precomputed dynamical maps (superoperators),
-+        or a callback function that returns the
-+        superoperator at a given time.
-+
-+    times : array_like
-+        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
-+
-+    learningtimes : array_like
-+        List of times :math:`t_k` to use as learning times if argument
-+        `dynmaps` is a callback function.
-+
-+    thres : float
-+        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
-+        treshold.
-+
-+    options : :class:`qutip.solver.SolverOptions`
-+        Generic solver options.
-+    """
-+
-+    def __init__(self, dynmaps=None, times=[], learningtimes=[],
-+                 thres=0.0, options=None):
-+        if options is None:
-+            options = SolverOptions()
-+
-+        self.dynmaps = dynmaps
-+        self.times = times
-+        self.learningtimes = learningtimes
-+        self.thres = thres
-+        self.store_states = options['store_states']
-+
-+
-+def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
-+             **kwargs):
-+    """
-+    Solve time-evolution using the Transfer Tensor Method, based on a set of
-+    precomputed dynamical maps.
-+
-+    Parameters
-+    ----------
-+    dynmaps : list of :class:`qutip.Qobj`
-+        List of precomputed dynamical maps (superoperators),
-+        or a callback function that returns the
-+        superoperator at a given time.
-+
-+    rho0 : :class:`qutip.Qobj`
-+        Initial density matrix or state vector (ket).
-+
-+    times : array_like
-+        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
-+        Must be uniformily spaced.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    learningtimes : array_like
-+        list of times :math:`t_k` for which we have knowledge of the dynamical
-+        maps :math:`E(t_k)`.
-+
-+    tensors : array_like
-+        optional list of precomputed tensors :math:`T_k`
-+
-+    kwargs : dictionary
-+        Optional keyword arguments. See
-+        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
-+
-+    Returns
-+    -------
-+    output: :class:`qutip.solver.Result`
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+
-+    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
-+                           learningtimes=learningtimes, **kwargs)
-+
-+    diff = None
-+
-+    if rho0.isket:
-+        rho0 = rho0.proj()
-+
-+    output = Result()
-+    e_sops_data = []
-+
-+    if callable(e_ops):
-+        n_expt_op = 0
-+        expt_callback = True
-+
-+    else:
-+        try:
-+            tmp = e_ops[:]
-+            del tmp
-+
-+            n_expt_op = len(e_ops)
-+            expt_callback = False
-+
-+            if n_expt_op == 0:
-+                # fall back on storing states
-+                opt.store_states = True
-+
-+            for op in e_ops:
-+                e_sops_data.append(spre(op).data)
-+                if op.isherm and rho0.isherm:
-+                    output.expect.append(np.zeros(len(times)))
-+                else:
-+                    output.expect.append(np.zeros(len(times), dtype=complex))
-+        except TypeError:
-+            raise TypeError("Argument 'e_ops' should be a callable or" +
-+                            "list-like.")
-+
-+    if tensors is None:
-+        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
-+
-+    if rho0.isoper:
-+        # vectorize density matrix
-+        rho0vec = operator_to_vector(rho0)
-+    else:
-+        # rho0 might be a super in which case we should not vectorize
-+        rho0vec = rho0
-+
-+    K = len(tensors)
-+    states = [rho0vec]
-+    for n in range(1, len(times)):
-+        # Set current state
-+        state = None
-+        for j in range(1, min(K, n + 1)):
-+            tmp = tensors[j] * states[n - j]
-+            state = tmp if state is None else tmp + state
-+        # Append state to all states
-+        states.append(state)
-+    for i, r in enumerate(states):
-+        if opt.store_states or expt_callback:
-+            if r.type == 'operator-ket':
-+                states[i] = vector_to_operator(r)
-+            else:
-+                states[i] = r
-+            if expt_callback:
-+                # use callback method
-+                e_ops(times[i], states[i])
-+        rdata = _data.column_stack(r.data)
-+        for m in range(n_expt_op):
-+            if output.expect[m].dtype == complex:
-+                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
-+            else:
-+                output.expect[m][i] =\
-+                    _data.expect_super(e_sops_data[m], rdata).real
-+
-+    output.solver = "ttmsolve"
-+    output.times = times
-+
-+    output.ttmconvergence = diff
-+
-+    if opt.store_states:
-+        output.states = states
-+
-+    return output
-+
-+
-+def _generatetensors(dynmaps, learningtimes=None, **kwargs):
-+    r"""
-+    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
-+    :math:`E(t_k)`.
-+
-+    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
-+
-+    Parameters
-+    ----------
-+    dynmaps : list of :class:`qutip.Qobj`
-+        List of precomputed dynamical maps (superoperators) at the times
-+        specified in `learningtimes`, or a callback function that returns the
-+        superoperator at a given time.
-+
-+    learningtimes : array_like
-+        list of times :math:`t_k` to use if argument `dynmaps` is a callback
-+        function.
-+
-+    kwargs : dictionary
-+        Optional keyword arguments. See
-+        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
-+
-+    Returns
-+    -------
-+    Tlist: list of :class:`qutip.Qobj.`
-+        A list of transfer tensors :math:`T_1,\dots,T_K`
-+    """
-+
-+    # Determine if dynmaps is callable or list-like
-+    if callable(dynmaps):
-+        if learningtimes is None:
-+            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
-+                            "is a callback function.")
-+
-+        def dynmapfunc(n):
-+            return dynmaps(learningtimes[n])
-+
-+        Kmax = len(learningtimes)
-+    else:
-+        try:
-+            tmp = dynmaps[:]
-+            del tmp
-+
-+            def dynmapfunc(n):
-+                return dynmaps[n]
-+
-+            Kmax = len(dynmaps)
-+        except TypeError:
-+            raise TypeError("Argument 'dynmaps' should be a callable or" +
-+                            "list-like.")
-+
-+    if "opt" not in kwargs:
-+        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
-+                               **kwargs)
-+    else:
-+        opt = kwargs['opt']
-+
-+    Tlist = []
-+    diff = [0.0]
-+    for n in range(Kmax):
-+        T = dynmapfunc(n)
-+        for m in range(1, n):
-+            T -= Tlist[n - m] * dynmapfunc(m)
-+        Tlist.append(T)
-+        if n > 1:
-+            diff.append((Tlist[-1] - Tlist[-2]).norm())
-+            if diff[-1] < opt.thres:
-+                # Below threshold for truncation
-+                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
-+                break
-+    return Tlist, diff
-diff --git a/qutip/solve/optionsclass.py b/qutip/solve/optionsclass.py
-index b82de812..73c0e709 100644
---- a/qutip/solve/optionsclass.py
-+++ b/qutip/solve/optionsclass.py
-@@ -1,263 +1,263 @@
--
--
--class AllOptions:
--    """
--    Class that serve as the parent of all other options class.
--    """
--    # Temporary patch to make changes in solver's options minimal.
--    # TODO: Follow up PR based on #1812 should replace this.
--    def __init__(self):
--        self._isDefault = True
--        self._children = []
--        self._fullname = "qutip.settings"
--        self._defaultInstance = self
--
--    def _all_children(self):
--        optcls = []
--        for child in self._children:
--            optcls += child._all_children()
--        return optcls
--
--
--alloptions = AllOptions()
--
--
--def optionsclass(name, parent=alloptions):
--    """
--    Use as a decorator to register the options class to `qutip.settings`.
--    The default will be in added to qutip.setting.[parent].name.
--
--    The options class should contain an `options` dictionary containing the
--    option and their default value. Readonly settings can be defined in
--    `read_only_options` dict.
--
--    ```
--    >>> import qutip
--    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
--    >>> class MyOpt():
--    >>>     options = {"opt1": True}
--    >>>     read_only_options = {"hidden": 1}
--
--    >>> qutip.settings.solver.myopt['opt1'] = False
--    >>> qutip.settings.solver.myopt['hidden']
--    1
--
--    >>> qutip.settings.solver.myopt['hidden'] = 2
--    KeyError: "'hidden': Read-only value"
--
--    >>> print(qutip.settings.solver.myopt)
--    qutip.settings.solver.myopt:
--    opt1   : False
--    hidden : 1
--
--    print(MyOpt(opt1=2))
--    qutip.settings.solver.myopt:
--    opt1   : 2
--    hidden : 1
--    ```
--
--    It add the methods:
--        __init__(file=None, *, option=None... )
--            Allow to create from data in files or from defaults with attributes
--            overwritten by keywords.
--        __repr__():
--            Make a clean print for all 'options' and 'read_only_options'.
--        __getitem__(), __setitem__():
--            Pass through to 'self.options' and 'self.read_only_options'.
--            Option in 'self.read_only_options' can not be set.
--        save(file='qutiprc'):
--            Save the object in a file. 'qutiprc' file is loaded as default when
--            loading qutip.
--        load(file):
--            Overwrite with options previously saved.
--            Loaded options will have the same type as the default from one of:
--                (bool, int, float, complex, str, object)
--        reset():
--            If used on an instance, reset to the default in qutip.settings.
--            If used from qutip.settings..., go back to qutip's defaults.
--
--    """
--    # The real work is in _QtOptionsMaker
--    if isinstance(name, str):
--        # Called as
--        # @QtOptionsClass(name)
--        # class Options:
--        return _QtOptionsMaker(name, parent)
--    else:
--        # Called as
--        # @QtOptionsClass
--        # class Options:
--        return _QtOptionsMaker(name.__name__, parent)(name)
--
--
--class _QtOptionsMaker:
--    """
--    Apply the `optionsclass` decorator.
--    """
--    def __init__(self, name, parent):
--        self.name = name
--        self.parent = parent
--
--    def __call__(self, cls):
--        if hasattr(cls, "_isDefault"):
--            # Already a QtOptionsClass
--            return
--
--        if not hasattr(cls, "read_only_options"):
--            cls.read_only_options = {}
--        # type to used when loading from file.
--        cls._types = {key: type(val) for key, val in cls.options.items()}
--        # Name in settings and in files
--        cls._name = self.name
--        # Name when printing
--        cls._fullname = ".".join([self.parent._fullname, self.name])
--        # Is this instance the default for the other.
--        cls._isDefault = False
--        # Children in the settings tree
--        cls._children = []
--        # Build the default instance
--        # Do it before setting __init__ since it use this default
--        self._make_default(cls)
--
--        cls.__init__ = _make_init(cls.options)
--        cls.__repr__ = _repr
--        cls.__getitem__ = _getitem
--        cls.__setitem__ = _setitem
--        cls.__contains__ = _contains
--        cls.reset = _reset
--        cls.save = _save
--        cls.load = _load
--        cls._all_children = _all_children
--
--        return cls
--
--    def _make_default(self, cls):
--        """ Create the default and add it to the parent.
--        """
--        default = cls()
--        default.options = cls.options.copy()
--        default._isDefault = True
--        default._children = []
--        # The parent has the child twice: attribute and in a list.
--        self.parent._defaultInstance._children.append(default)
--        setattr(self.parent._defaultInstance, self.name, default)
--        cls._defaultInstance = default
--
--
--def _make_init(all_set):
--    attributes_kw = ",\n             ".join(["{}=None".format(key)
--                    for key in all_set])
--    attributes_set = "".join(["    if {0} is not None:\n"
--                              "        self.options['{0}'] = {0}\n".format(key)
--                     for key in all_set])
--    code = f"""
--def __init__(self, file='', *,
--             {attributes_kw},
--             _child_instance=False,
--             **kwargs):
--    self.options = self._defaultInstance.options.copy()
--{attributes_set}
--    if file:
--        self.load(file)
--    if hasattr(self, "extra_options"):
--        other_kw = dict()
--        for kw in kwargs:
--            if kw in self.extra_options:
--                self.options[kw] = kwargs[kw]
--            else:
--                other_kw[kw] = kwargs[kw]
--        kwargs = other_kw
--    self._children = []
--    for child in self._defaultInstance._children:
--        self._children.append(child.__class__(file, _child_instance=True,
--                                              **kwargs))
--        setattr(self, child._name, self._children[-1])
--        kwargs = self._children[-1].left_over_kwargs
--    if _child_instance:
--        self.left_over_kwargs = kwargs
--    elif kwargs:
--        raise KeyError("Unknown options: " +
--                       " ,".join(str(key) for key in kwargs))
--"""
--    ns = {}
--    exec(code, globals(), ns)
--    return ns["__init__"]
--
--
--def _repr(self, _recursive=True):
--    out = self._fullname + ":\n"
--    longest = max(len(key) for key in self.options)
--    if self.read_only_options:
--        longest_readonly = max(len(key) for key in self.read_only_options)
--        longest = max((longest, longest_readonly))
--    for key, val in self.options.items():
--        if isinstance(val, str):
--            out += "{:{width}} : '{}'\n".format(key, val,
--                                                width=longest)
--        else:
--            out += "{:{width}} : {}\n".format(key, val,
--                                              width=longest)
--    for key, val in self.read_only_options.items():
--        out += "{:{width}} : {}\n".format(key, val,
--                                          width=longest)
--    out += "\n"
--    if _recursive:
--         out += "".join([child.__repr__(_recursive)
--                         for child in self._children])
--    return out
--
--
--def _reset(self, _recursive=False):
--    """Reset instance to the default value or the default to Qutip's default"""
--    if self._isDefault:
--        self.options = self.__class__.options.copy()
--        if _recursive:
--            for child in self._children:
--                child.reset()
--    else:
--        self.options = self._defaultInstance.options.copy()
--
--
--def _all_children(self):
--    optcls = [self]
--    for child in self._children:
--         optcls += child._all_children()
--    return optcls
--
--
--def _save(self, file="qutiprc", _recursive=False):
--    """Save to desired file. 'qutiprc' if not specified"""
--    import qutip.configrc as qrc
--    if _recursive:
--        optcls = self._all_children()
--    else:
--        optcls = [self]
--    qrc.write_rc_object(file, optcls)
--
--
--def _load(self, file="qutiprc", _recursive=False):
--    """Load from desired file. 'qutiprc' if not specified"""
--    import qutip.configrc as qrc
--    if _recursive:
--        optcls = self._all_children()
--    else:
--        optcls = [self]
--    qrc.load_rc_object(file, optcls)
--
--
--def _contains(self, key):
--    return key in self.read_only_options or key in self.options
--
--
--def _getitem(self, key):
--    # Let the dict catch the KeyError
--    if key in self.read_only_options:
--        return self.read_only_options[key]
--    return self.options[key]
--
--
--def _setitem(self, key, value):
--    # Let the dict catch the KeyError
--    if key in self.read_only_options:
--        raise KeyError(f"'{key}': Read-only value")
--    self.options[key] = value
-+
-+
-+class AllOptions:
-+    """
-+    Class that serve as the parent of all other options class.
-+    """
-+    # Temporary patch to make changes in solver's options minimal.
-+    # TODO: Follow up PR based on #1812 should replace this.
-+    def __init__(self):
-+        self._isDefault = True
-+        self._children = []
-+        self._fullname = "qutip.settings"
-+        self._defaultInstance = self
-+
-+    def _all_children(self):
-+        optcls = []
-+        for child in self._children:
-+            optcls += child._all_children()
-+        return optcls
-+
-+
-+alloptions = AllOptions()
-+
-+
-+def optionsclass(name, parent=alloptions):
-+    """
-+    Use as a decorator to register the options class to `qutip.settings`.
-+    The default will be in added to qutip.setting.[parent].name.
-+
-+    The options class should contain an `options` dictionary containing the
-+    option and their default value. Readonly settings can be defined in
-+    `read_only_options` dict.
-+
-+    ```
-+    >>> import qutip
-+    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
-+    >>> class MyOpt():
-+    >>>     options = {"opt1": True}
-+    >>>     read_only_options = {"hidden": 1}
-+
-+    >>> qutip.settings.solver.myopt['opt1'] = False
-+    >>> qutip.settings.solver.myopt['hidden']
-+    1
-+
-+    >>> qutip.settings.solver.myopt['hidden'] = 2
-+    KeyError: "'hidden': Read-only value"
-+
-+    >>> print(qutip.settings.solver.myopt)
-+    qutip.settings.solver.myopt:
-+    opt1   : False
-+    hidden : 1
-+
-+    print(MyOpt(opt1=2))
-+    qutip.settings.solver.myopt:
-+    opt1   : 2
-+    hidden : 1
-+    ```
-+
-+    It add the methods:
-+        __init__(file=None, *, option=None... )
-+            Allow to create from data in files or from defaults with attributes
-+            overwritten by keywords.
-+        __repr__():
-+            Make a clean print for all 'options' and 'read_only_options'.
-+        __getitem__(), __setitem__():
-+            Pass through to 'self.options' and 'self.read_only_options'.
-+            Option in 'self.read_only_options' can not be set.
-+        save(file='qutiprc'):
-+            Save the object in a file. 'qutiprc' file is loaded as default when
-+            loading qutip.
-+        load(file):
-+            Overwrite with options previously saved.
-+            Loaded options will have the same type as the default from one of:
-+                (bool, int, float, complex, str, object)
-+        reset():
-+            If used on an instance, reset to the default in qutip.settings.
-+            If used from qutip.settings..., go back to qutip's defaults.
-+
-+    """
-+    # The real work is in _QtOptionsMaker
-+    if isinstance(name, str):
-+        # Called as
-+        # @QtOptionsClass(name)
-+        # class Options:
-+        return _QtOptionsMaker(name, parent)
-+    else:
-+        # Called as
-+        # @QtOptionsClass
-+        # class Options:
-+        return _QtOptionsMaker(name.__name__, parent)(name)
-+
-+
-+class _QtOptionsMaker:
-+    """
-+    Apply the `optionsclass` decorator.
-+    """
-+    def __init__(self, name, parent):
-+        self.name = name
-+        self.parent = parent
-+
-+    def __call__(self, cls):
-+        if hasattr(cls, "_isDefault"):
-+            # Already a QtOptionsClass
-+            return
-+
-+        if not hasattr(cls, "read_only_options"):
-+            cls.read_only_options = {}
-+        # type to used when loading from file.
-+        cls._types = {key: type(val) for key, val in cls.options.items()}
-+        # Name in settings and in files
-+        cls._name = self.name
-+        # Name when printing
-+        cls._fullname = ".".join([self.parent._fullname, self.name])
-+        # Is this instance the default for the other.
-+        cls._isDefault = False
-+        # Children in the settings tree
-+        cls._children = []
-+        # Build the default instance
-+        # Do it before setting __init__ since it use this default
-+        self._make_default(cls)
-+
-+        cls.__init__ = _make_init(cls.options)
-+        cls.__repr__ = _repr
-+        cls.__getitem__ = _getitem
-+        cls.__setitem__ = _setitem
-+        cls.__contains__ = _contains
-+        cls.reset = _reset
-+        cls.save = _save
-+        cls.load = _load
-+        cls._all_children = _all_children
-+
-+        return cls
-+
-+    def _make_default(self, cls):
-+        """ Create the default and add it to the parent.
-+        """
-+        default = cls()
-+        default.options = cls.options.copy()
-+        default._isDefault = True
-+        default._children = []
-+        # The parent has the child twice: attribute and in a list.
-+        self.parent._defaultInstance._children.append(default)
-+        setattr(self.parent._defaultInstance, self.name, default)
-+        cls._defaultInstance = default
-+
-+
-+def _make_init(all_set):
-+    attributes_kw = ",\n             ".join(["{}=None".format(key)
-+                    for key in all_set])
-+    attributes_set = "".join(["    if {0} is not None:\n"
-+                              "        self.options['{0}'] = {0}\n".format(key)
-+                     for key in all_set])
-+    code = f"""
-+def __init__(self, file='', *,
-+             {attributes_kw},
-+             _child_instance=False,
-+             **kwargs):
-+    self.options = self._defaultInstance.options.copy()
-+{attributes_set}
-+    if file:
-+        self.load(file)
-+    if hasattr(self, "extra_options"):
-+        other_kw = dict()
-+        for kw in kwargs:
-+            if kw in self.extra_options:
-+                self.options[kw] = kwargs[kw]
-+            else:
-+                other_kw[kw] = kwargs[kw]
-+        kwargs = other_kw
-+    self._children = []
-+    for child in self._defaultInstance._children:
-+        self._children.append(child.__class__(file, _child_instance=True,
-+                                              **kwargs))
-+        setattr(self, child._name, self._children[-1])
-+        kwargs = self._children[-1].left_over_kwargs
-+    if _child_instance:
-+        self.left_over_kwargs = kwargs
-+    elif kwargs:
-+        raise KeyError("Unknown options: " +
-+                       " ,".join(str(key) for key in kwargs))
-+"""
-+    ns = {}
-+    exec(code, globals(), ns)
-+    return ns["__init__"]
-+
-+
-+def _repr(self, _recursive=True):
-+    out = self._fullname + ":\n"
-+    longest = max(len(key) for key in self.options)
-+    if self.read_only_options:
-+        longest_readonly = max(len(key) for key in self.read_only_options)
-+        longest = max((longest, longest_readonly))
-+    for key, val in self.options.items():
-+        if isinstance(val, str):
-+            out += "{:{width}} : '{}'\n".format(key, val,
-+                                                width=longest)
-+        else:
-+            out += "{:{width}} : {}\n".format(key, val,
-+                                              width=longest)
-+    for key, val in self.read_only_options.items():
-+        out += "{:{width}} : {}\n".format(key, val,
-+                                          width=longest)
-+    out += "\n"
-+    if _recursive:
-+         out += "".join([child.__repr__(_recursive)
-+                         for child in self._children])
-+    return out
-+
-+
-+def _reset(self, _recursive=False):
-+    """Reset instance to the default value or the default to Qutip's default"""
-+    if self._isDefault:
-+        self.options = self.__class__.options.copy()
-+        if _recursive:
-+            for child in self._children:
-+                child.reset()
-+    else:
-+        self.options = self._defaultInstance.options.copy()
-+
-+
-+def _all_children(self):
-+    optcls = [self]
-+    for child in self._children:
-+         optcls += child._all_children()
-+    return optcls
-+
-+
-+def _save(self, file="qutiprc", _recursive=False):
-+    """Save to desired file. 'qutiprc' if not specified"""
-+    import qutip.configrc as qrc
-+    if _recursive:
-+        optcls = self._all_children()
-+    else:
-+        optcls = [self]
-+    qrc.write_rc_object(file, optcls)
-+
-+
-+def _load(self, file="qutiprc", _recursive=False):
-+    """Load from desired file. 'qutiprc' if not specified"""
-+    import qutip.configrc as qrc
-+    if _recursive:
-+        optcls = self._all_children()
-+    else:
-+        optcls = [self]
-+    qrc.load_rc_object(file, optcls)
-+
-+
-+def _contains(self, key):
-+    return key in self.read_only_options or key in self.options
-+
-+
-+def _getitem(self, key):
-+    # Let the dict catch the KeyError
-+    if key in self.read_only_options:
-+        return self.read_only_options[key]
-+    return self.options[key]
-+
-+
-+def _setitem(self, key, value):
-+    # Let the dict catch the KeyError
-+    if key in self.read_only_options:
-+        raise KeyError(f"'{key}': Read-only value")
-+    self.options[key] = value
-diff --git a/qutip/solve/parallel.py b/qutip/solve/parallel.py
-index 36e35b85..02f0d8f7 100644
---- a/qutip/solve/parallel.py
-+++ b/qutip/solve/parallel.py
-@@ -1,241 +1,241 @@
--"""
--This function provides functions for parallel execution of loops and function
--mappings, using the builtin Python module multiprocessing.
--"""
--__all__ = ['parallel_map', 'serial_map']
--
--from scipy import array
--import multiprocessing
--from functools import partial
--import os
--import sys
--import signal
--from qutip.settings import settings as qset
--from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
--
--
--if sys.platform == 'darwin':
--    Pool = multiprocessing.get_context('fork').Pool
--else:
--    Pool = multiprocessing.Pool
--
--
--def _task_wrapper(args):
--    try:
--        return args[0](*args[1])
--    except KeyboardInterrupt:
--        os.kill(args[2], signal.SIGINT)
--        sys.exit(1)
--
--
--def _task_wrapper_with_args(args, user_args):
--    try:
--        return args[0](*args[1], **user_args)
--    except KeyboardInterrupt:
--        os.kill(args[2], signal.SIGINT)
--        sys.exit(1)
--
--
--def parfor(func, *args, **kwargs):
--    """Executes a multi-variable function in parallel on the local machine.
--
--    Parallel execution of a for-loop over function `func` for multiple input
--    arguments and keyword arguments.
--
--    .. note::
--
--        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
--        instead of this function.
--
--    Parameters
--    ----------
--    func : function_type
--        A function to run in parallel on the local machine. The function 'func'
--        accepts a series of arguments that are passed to the function as
--        variables. In general, the function can have multiple input variables,
--        and these arguments must be passed in the same order as they are
--        defined in the function definition.  In addition, the user can pass
--        multiple keyword arguments to the function.
--
--    The following keyword argument is reserved:
--
--    num_cpus : int
--        Number of CPU's to use.  Default uses maximum number of CPU's.
--        Performance degrades if num_cpus is larger than the physical CPU
--        count of your machine.
--
--    Returns
--    -------
--    result : list
--        A ``list`` with length equal to number of input parameters
--        containing the output from `func`.
--
--    """
--    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
--    kw = _default_kwargs()
--    if 'num_cpus' in kwargs.keys():
--        kw['num_cpus'] = kwargs['num_cpus']
--        del kwargs['num_cpus']
--    if len(kwargs) != 0:
--        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
--    else:
--        task_func = _task_wrapper
--
--    # if kw['num_cpus'] > qset.num_cpus:
--    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
--    #          "is larger than physical number (%s)." % qset.num_cpus)
--    #    print("Reduce 'num_cpus' for greater performance.")
--
--    pool = Pool(processes=kw['num_cpus'])
--    args = [list(arg) for arg in args]
--    var = [[args[j][i] for j in range(len(args))]
--           for i in range(len(list(args[0])))]
--    try:
--        map_args = ((func, v, os.getpid()) for v in var)
--        par_return = list(pool.map(task_func, map_args))
--
--        pool.terminate()
--        pool.join()
--        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--        if isinstance(par_return[0], tuple):
--            par_return = [elem for elem in par_return]
--            num_elems = len(par_return[0])
--            dt = [type(ii) for ii in par_return[0]]
--            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
--                    for ii in range(num_elems)]
--        else:
--            return par_return
--
--    except KeyboardInterrupt:
--        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--        pool.terminate()
--
--
--def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
--    """
--    Serial mapping function with the same call signature as parallel_map, for
--    easy switching between serial and parallel execution. This
--    is functionally equivalent to::
--
--        result = [task(value, *task_args, **task_kwargs) for value in values]
--
--    This function work as a drop-in replacement of
--    :func:`qutip.parallel.parallel_map`.
--
--    Parameters
--    ----------
--    task : a Python function
--        The function that is to be called for each value in ``task_vec``.
--    values : array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--    task_args : list / dictionary
--        The optional additional argument to the ``task`` function.
--    task_kwargs : list / dictionary
--        The optional additional keyword argument to the ``task`` function.
--    progress_bar : ProgressBar
--        Progress bar class instance for showing progress.
--
--    Returns
--    --------
--    result : list
--        The result list contains the value of
--        ``task(value, *task_args, **task_kwargs)`` for each
--        value in ``values``.
--
--    """
--    try:
--        progress_bar = kwargs['progress_bar']
--        if progress_bar is True:
--            progress_bar = TextProgressBar()
--    except:
--        progress_bar = BaseProgressBar()
--
--    progress_bar.start(len(values))
--    results = []
--    for n, value in enumerate(values):
--        progress_bar.update(n)
--        result = task(value, *task_args, **task_kwargs)
--        results.append(result)
--    progress_bar.finished()
--
--    return results
--
--
--def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
--    """
--    Parallel execution of a mapping of `values` to the function `task`. This
--    is functionally equivalent to::
--
--        result = [task(value, *task_args, **task_kwargs) for value in values]
--
--    Parameters
--    ----------
--    task : a Python function
--        The function that is to be called for each value in ``task_vec``.
--    values : array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--    task_args : list / dictionary
--        The optional additional argument to the ``task`` function.
--    task_kwargs : list / dictionary
--        The optional additional keyword argument to the ``task`` function.
--    progress_bar : ProgressBar
--        Progress bar class instance for showing progress.
--
--    Returns
--    --------
--    result : list
--        The result list contains the value of
--        ``task(value, *task_args, **task_kwargs)`` for
--        each value in ``values``.
--
--    """
--    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
--    kw = _default_kwargs()
--    if 'num_cpus' in kwargs:
--        kw['num_cpus'] = kwargs['num_cpus']
--
--    try:
--        progress_bar = kwargs['progress_bar']
--        if progress_bar is True:
--            progress_bar = TextProgressBar()
--    except:
--        progress_bar = BaseProgressBar()
--
--    progress_bar.start(len(values))
--    nfinished = [0]
--
--    def _update_progress_bar(x):
--        nfinished[0] += 1
--        progress_bar.update(nfinished[0])
--
--    try:
--        pool = Pool(processes=kw['num_cpus'])
--
--        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
--                                      _update_progress_bar)
--                     for value in values]
--
--        while not all([ar.ready() for ar in async_res]):
--            for ar in async_res:
--                ar.wait(timeout=0.1)
--
--        pool.terminate()
--        pool.join()
--
--    except KeyboardInterrupt as e:
--        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--        pool.terminate()
--        pool.join()
--        raise e
--
--    progress_bar.finished()
--    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--    return [ar.get() for ar in async_res]
--
--
--def _default_kwargs():
--
--    settings = {'num_cpus': multiprocessing.cpu_count()}
--    return settings
-+"""
-+This function provides functions for parallel execution of loops and function
-+mappings, using the builtin Python module multiprocessing.
-+"""
-+__all__ = ['parallel_map', 'serial_map']
-+
-+from scipy import array
-+import multiprocessing
-+from functools import partial
-+import os
-+import sys
-+import signal
-+from qutip.settings import settings as qset
-+from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
-+
-+
-+if sys.platform == 'darwin':
-+    Pool = multiprocessing.get_context('fork').Pool
-+else:
-+    Pool = multiprocessing.Pool
-+
-+
-+def _task_wrapper(args):
-+    try:
-+        return args[0](*args[1])
-+    except KeyboardInterrupt:
-+        os.kill(args[2], signal.SIGINT)
-+        sys.exit(1)
-+
-+
-+def _task_wrapper_with_args(args, user_args):
-+    try:
-+        return args[0](*args[1], **user_args)
-+    except KeyboardInterrupt:
-+        os.kill(args[2], signal.SIGINT)
-+        sys.exit(1)
-+
-+
-+def parfor(func, *args, **kwargs):
-+    """Executes a multi-variable function in parallel on the local machine.
-+
-+    Parallel execution of a for-loop over function `func` for multiple input
-+    arguments and keyword arguments.
-+
-+    .. note::
-+
-+        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
-+        instead of this function.
-+
-+    Parameters
-+    ----------
-+    func : function_type
-+        A function to run in parallel on the local machine. The function 'func'
-+        accepts a series of arguments that are passed to the function as
-+        variables. In general, the function can have multiple input variables,
-+        and these arguments must be passed in the same order as they are
-+        defined in the function definition.  In addition, the user can pass
-+        multiple keyword arguments to the function.
-+
-+    The following keyword argument is reserved:
-+
-+    num_cpus : int
-+        Number of CPU's to use.  Default uses maximum number of CPU's.
-+        Performance degrades if num_cpus is larger than the physical CPU
-+        count of your machine.
-+
-+    Returns
-+    -------
-+    result : list
-+        A ``list`` with length equal to number of input parameters
-+        containing the output from `func`.
-+
-+    """
-+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-+    kw = _default_kwargs()
-+    if 'num_cpus' in kwargs.keys():
-+        kw['num_cpus'] = kwargs['num_cpus']
-+        del kwargs['num_cpus']
-+    if len(kwargs) != 0:
-+        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
-+    else:
-+        task_func = _task_wrapper
-+
-+    # if kw['num_cpus'] > qset.num_cpus:
-+    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
-+    #          "is larger than physical number (%s)." % qset.num_cpus)
-+    #    print("Reduce 'num_cpus' for greater performance.")
-+
-+    pool = Pool(processes=kw['num_cpus'])
-+    args = [list(arg) for arg in args]
-+    var = [[args[j][i] for j in range(len(args))]
-+           for i in range(len(list(args[0])))]
-+    try:
-+        map_args = ((func, v, os.getpid()) for v in var)
-+        par_return = list(pool.map(task_func, map_args))
-+
-+        pool.terminate()
-+        pool.join()
-+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+        if isinstance(par_return[0], tuple):
-+            par_return = [elem for elem in par_return]
-+            num_elems = len(par_return[0])
-+            dt = [type(ii) for ii in par_return[0]]
-+            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
-+                    for ii in range(num_elems)]
-+        else:
-+            return par_return
-+
-+    except KeyboardInterrupt:
-+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+        pool.terminate()
-+
-+
-+def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-+    """
-+    Serial mapping function with the same call signature as parallel_map, for
-+    easy switching between serial and parallel execution. This
-+    is functionally equivalent to::
-+
-+        result = [task(value, *task_args, **task_kwargs) for value in values]
-+
-+    This function work as a drop-in replacement of
-+    :func:`qutip.parallel.parallel_map`.
-+
-+    Parameters
-+    ----------
-+    task : a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+    values : array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+    task_args : list / dictionary
-+        The optional additional argument to the ``task`` function.
-+    task_kwargs : list / dictionary
-+        The optional additional keyword argument to the ``task`` function.
-+    progress_bar : ProgressBar
-+        Progress bar class instance for showing progress.
-+
-+    Returns
-+    --------
-+    result : list
-+        The result list contains the value of
-+        ``task(value, *task_args, **task_kwargs)`` for each
-+        value in ``values``.
-+
-+    """
-+    try:
-+        progress_bar = kwargs['progress_bar']
-+        if progress_bar is True:
-+            progress_bar = TextProgressBar()
-+    except:
-+        progress_bar = BaseProgressBar()
-+
-+    progress_bar.start(len(values))
-+    results = []
-+    for n, value in enumerate(values):
-+        progress_bar.update(n)
-+        result = task(value, *task_args, **task_kwargs)
-+        results.append(result)
-+    progress_bar.finished()
-+
-+    return results
-+
-+
-+def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-+    """
-+    Parallel execution of a mapping of `values` to the function `task`. This
-+    is functionally equivalent to::
-+
-+        result = [task(value, *task_args, **task_kwargs) for value in values]
-+
-+    Parameters
-+    ----------
-+    task : a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+    values : array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+    task_args : list / dictionary
-+        The optional additional argument to the ``task`` function.
-+    task_kwargs : list / dictionary
-+        The optional additional keyword argument to the ``task`` function.
-+    progress_bar : ProgressBar
-+        Progress bar class instance for showing progress.
-+
-+    Returns
-+    --------
-+    result : list
-+        The result list contains the value of
-+        ``task(value, *task_args, **task_kwargs)`` for
-+        each value in ``values``.
-+
-+    """
-+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-+    kw = _default_kwargs()
-+    if 'num_cpus' in kwargs:
-+        kw['num_cpus'] = kwargs['num_cpus']
-+
-+    try:
-+        progress_bar = kwargs['progress_bar']
-+        if progress_bar is True:
-+            progress_bar = TextProgressBar()
-+    except:
-+        progress_bar = BaseProgressBar()
-+
-+    progress_bar.start(len(values))
-+    nfinished = [0]
-+
-+    def _update_progress_bar(x):
-+        nfinished[0] += 1
-+        progress_bar.update(nfinished[0])
-+
-+    try:
-+        pool = Pool(processes=kw['num_cpus'])
-+
-+        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
-+                                      _update_progress_bar)
-+                     for value in values]
-+
-+        while not all([ar.ready() for ar in async_res]):
-+            for ar in async_res:
-+                ar.wait(timeout=0.1)
-+
-+        pool.terminate()
-+        pool.join()
-+
-+    except KeyboardInterrupt as e:
-+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+        pool.terminate()
-+        pool.join()
-+        raise e
-+
-+    progress_bar.finished()
-+    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+    return [ar.get() for ar in async_res]
-+
-+
-+def _default_kwargs():
-+
-+    settings = {'num_cpus': multiprocessing.cpu_count()}
-+    return settings
-diff --git a/qutip/solve/pdpsolve.py b/qutip/solve/pdpsolve.py
-index 1a1d2964..e295b237 100644
---- a/qutip/solve/pdpsolve.py
-+++ b/qutip/solve/pdpsolve.py
-@@ -1,575 +1,575 @@
--# -*- coding: utf-8 -*-
--
--import numpy as np
--from numpy.random import RandomState
--
--from .. import (
--    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
--)
--from ..core import data as _data
--from .solver import Result, SolverOptions
--from .parallel import serial_map
--from ..ui.progressbar import TextProgressBar
--from ..settings import settings
--debug = settings.debug
--
--
--class StochasticSolverOptions:
--    """
--    Class of options for stochastic (piecewse deterministic process) PDP
--    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
--    :func:`qutip.pdpsolve.smepdpsolve`.
--    Options can be specified either as arguments to the constructor::
--
--        sso = StochasticSolverOptions(nsubsteps=100, ...)
--
--    or by changing the class attributes after creation::
--
--        sso = StochasticSolverOptions()
--        sso.nsubsteps = 1000
--
--    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
--    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
--    the constructor of these class, and internally they use these arguments to
--    construct an instance of this class, so it is rarely needed to explicitly
--    create an instance of this class.
--
--    Attributes
--    ----------
--
--    H : :class:`qutip.Qobj`
--        System Hamiltonian.
--
--    state0 : :class:`qutip.Qobj`
--        Initial state vector (ket) or density matrix.
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`
--        List of deterministic collapse operators.
--
--    sc_ops : list of :class:`qutip.Qobj`
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the equation of motion according to how the d1 and d2 functions
--        are defined.
--
--    e_ops : list of :class:`qutip.Qobj`
--        Single operator or list of operators for which to evaluate
--        expectation values.
--
--    m_ops : list of :class:`qutip.Qobj`
--        List of operators representing the measurement operators. The expected
--        format is a nested list with one measurement operator for each
--        stochastic increament, for each stochastic collapse operator.
--
--    args : dict / list
--        List of dictionary of additional problem-specific parameters.
--        Implicit methods can adjust tolerance via args = {'tol':value}
--
--    ntraj : int
--        Number of trajectors.
--
--    nsubsteps : int
--        Number of sub steps between each time-spep given in `times`.
--
--    d1 : function
--        Function for calculating the operator-valued coefficient to the
--        deterministic increment dt.
--
--    d2 : function
--        Function for calculating the operator-valued coefficient to the
--        stochastic increment(s) dW_n, where n is in [0, d2_len[.
--
--    d2_len : int (default 1)
--        The number of stochastic increments in the process.
--
--    dW_factors : array
--        Array of length d2_len, containing scaling factors for each
--        measurement operator in m_ops.
--
--    rhs : function
--        Function for calculating the deterministic and stochastic contributions
--        to the right-hand side of the stochastic differential equation. This
--        only needs to be specified when implementing a custom SDE solver.
--
--    generate_A_ops : function
--        Function that generates a list of pre-computed operators or super-
--        operators. These precomputed operators are used in some d1 and d2
--        functions.
--
--    generate_noise : function
--        Function for generate an array of pre-computed noise signal.
--
--    homogeneous : bool (True)
--        Wheter or not the stochastic process is homogenous. Inhomogenous
--        processes are only supported for poisson distributions.
--
--    solver : string
--        Name of the solver method to use for solving the stochastic
--        equations. Valid values are:
--        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
--        'pc-euler' is a predictor-corrector method which is more
--        stable than explicit methods,
--        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
--        'milstein-imp' is semi-implicit Milstein method,
--        3/2 order algorithms: 'taylor15',
--        'taylor15-imp' is semi-implicit Taylor 1.5 method.
--        Implicit methods can adjust tolerance via args = {'tol':value},
--        default is {'tol':1e-6}
--
--    method : string ('homodyne', 'heterodyne', 'photocurrent')
--        The name of the type of measurement process that give rise to the
--        stochastic equation to solve. Specifying a method with this keyword
--        argument is a short-hand notation for using pre-defined d1 and d2
--        functions for the corresponding stochastic processes.
--
--    distribution : string ('normal', 'poisson')
--        The name of the distribution used for the stochastic increments.
--
--    store_measurements : bool (default False)
--        Whether or not to store the measurement results in the
--        :class:`qutip.solver.Result` instance returned by the solver.
--
--    noise : array
--        Vector specifying the noise.
--
--    normalize : bool (default True)
--        Whether or not to normalize the wave function during the evolution.
--
--    options : :class:`qutip.solver.SolverOptions`
--        Generic solver options.
--
--    map_func: function
--        A map function or managing the calls to single-trajactory solvers.
--
--    map_kwargs: dictionary
--        Optional keyword arguments to the map_func function function.
--
--    progress_bar : :class:`qutip.ui.BaseProgressBar`
--        Optional progress bar class instance.
--    """
--    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
--                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
--                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
--                 generate_A_ops=None, generate_noise=None, homogeneous=True,
--                 solver=None, method=None, distribution='normal',
--                 store_measurement=False, noise=None, normalize=True,
--                 options=None, progress_bar=None, map_func=None,
--                 map_kwargs=None):
--
--        if options is None:
--            options = SolverOptions()
--
--        if progress_bar is None:
--            progress_bar = TextProgressBar()
--
--        self.H = H
--        self.d1 = d1
--        self.d2 = d2
--        self.d2_len = d2_len
--        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
--        self.state0 = state0
--        self.times = times
--        self.c_ops = c_ops
--        self.sc_ops = sc_ops
--        self.e_ops = e_ops
--        self.m_ops = m_ops
--
--        self.ntraj = ntraj
--        self.nsubsteps = nsubsteps
--        self.solver = solver
--        self.method = method
--        self.distribution = distribution
--        self.homogeneous = homogeneous
--        self.rhs = rhs
--        self.options = options
--        self.progress_bar = progress_bar
--        self.store_measurement = store_measurement
--        self.store_states = options['store_states']
--        self.noise = noise
--        self.args = args
--        self.normalize = normalize
--
--        self.generate_noise = generate_noise
--        self.generate_A_ops = generate_A_ops
--
--        if self.ntraj > 1 and map_func:
--            self.map_func = map_func
--        else:
--            self.map_func = serial_map
--
--        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
--
--        # Does any operator depend on time?
--        self.td = False
--        if not isinstance(H, Qobj):
--            self.td = True
--        for ops in c_ops:
--            if not isinstance(ops, Qobj):
--                self.td = True
--        for ops in sc_ops:
--            if not isinstance(ops, Qobj):
--                self.td = True
--
--
--def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
--    """
--    A stochastic (piecewse deterministic process) PDP solver for wavefunction
--    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
--    trajectory simulations.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`
--        System Hamiltonian.
--
--    psi0 : :class:`qutip.Qobj`
--        Initial state vector (ket).
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`
--        Deterministic collapse operator which will contribute with a standard
--        Lindblad type of dissipation.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function single
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = [e for e in e_ops.values()]
--    else:
--        e_ops_dict = None
--
--    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
--                                  e_ops=e_ops, **kwargs)
--
--    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--    return res
--
--
--def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
--    """
--    A stochastic (piecewse deterministic process) PDP solver for density matrix
--    evolution.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`
--        System Hamiltonian.
--
--    rho0 : :class:`qutip.Qobj`
--        Initial density matrix.
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`
--        Deterministic collapse operator which will contribute with a standard
--        Lindblad type of dissipation.
--
--    sc_ops : list of :class:`qutip.Qobj`
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the equation of motion according to how the d1 and d2 functions
--        are defined.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function single
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = [e for e in e_ops.values()]
--    else:
--        e_ops_dict = None
--
--    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
--                                  e_ops=e_ops, **kwargs)
--
--    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--    return res
--
--
--# -----------------------------------------------------------------------------
--# Generic parameterized stochastic SE PDP solver
--#
--def _ssepdpsolve_generic(sso, options, progress_bar):
--    """
--    For internal use. See ssepdpsolve.
--    """
--    N_store = len(sso.times)
--    N_substeps = sso.nsubsteps
--    dt = (sso.times[1] - sso.times[0]) / N_substeps
--    nt = sso.ntraj
--
--    data = Result()
--    data.solver = "sepdpsolve"
--    data.times = sso.tlist
--    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
--    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
--    data.jump_times = []
--    data.jump_op_idx = []
--
--    # effective hamiltonian for deterministic part
--    Heff = sso.H
--    for c in sso.c_ops:
--        Heff += -0.5j * c.dag() * c
--
--    progress_bar.start(sso.ntraj)
--    for n in range(sso.ntraj):
--        progress_bar.update(n)
--        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
--
--        states_list, jump_times, jump_op_idx = \
--            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
--                                           N_store, N_substeps,
--                                           psi_t, sso.state0.dims,
--                                           sso.c_ops, sso.e_ops)
--
--        data.states.append(states_list)
--        data.jump_times.append(jump_times)
--        data.jump_op_idx.append(jump_op_idx)
--
--    progress_bar.finished()
--
--    # average density matrices
--    if options['average_states'] and np.any(data.states):
--        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
--                       for n in range(len(data.times))]
--
--    # average
--    data.expect = data.expect / nt
--
--    # standard error
--    if nt > 1:
--        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
--    else:
--        data.se = None
--
--    # convert complex data to real if hermitian
--    data.expect = [np.real(data.expect[n, :])
--                   if e.isherm else data.expect[n, :]
--                   for n, e in enumerate(sso.e_ops)]
--
--    return data
--
--
--def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
--    """
--    Internal function. See ssepdpsolve.
--    """
--    states_list = []
--
--    phi_t = psi_t.copy()
--
--    prng = RandomState()  # todo: seed it
--    r_jump, r_op = prng.rand(2)
--
--    jump_times = []
--    jump_op_idx = []
--
--    for t_idx, t in enumerate(times):
--
--        if e_ops:
--            for e_idx, e in enumerate(e_ops):
--                s = _data.expect(e, psi_t)
--                data.expect[e_idx, t_idx] += s
--                data.ss[e_idx, t_idx] += s ** 2
--        else:
--            states_list.append(Qobj(psi_t.to_array(), dims=dims))
--
--        for j in range(N_substeps):
--
--            if _data.norm.l2(phi_t) ** 2 < r_jump:
--                # jump occurs
--                p = np.array([
--                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
--                    for c in c_ops
--                ])
--                p = np.cumsum(p / np.sum(p))
--                n = np.where(p >= r_op)[0][0]
--
--                # apply jump
--                psi_t = _data.matmul(c_ops[n].data, psi_t)
--                psi_t /= _data.norm.l2(psi_t)
--                phi_t = psi_t.copy()
--
--                # store info about jump
--                jump_times.append(times[t_idx] + dt * j)
--                jump_op_idx.append(n)
--
--                # get new random numbers for next jump
--                r_jump, r_op = prng.rand(2)
--
--            # deterministic evolution wihtout correction for norm decay
--            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
--
--            # deterministic evolution with correction for norm decay
--            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
--            A = 0.5 * np.sum([
--                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
--                for c in c_ops
--            ])
--            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
--
--            # increment wavefunctions
--            phi_t = _data.add(phi_t, dphi_t)
--            psi_t = _data.add(psi_t, dpsi_t)
--
--            # ensure that normalized wavefunction remains normalized
--            # this allows larger time step than otherwise would be possible
--            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
--
--    return states_list, jump_times, jump_op_idx
--
--
--# -----------------------------------------------------------------------------
--# Generic parameterized stochastic ME PDP solver
--#
--def _smepdpsolve_generic(sso, options, progress_bar):
--    """
--    For internal use. See smepdpsolve.
--    """
--    N_store = len(sso.times)
--    N_substeps = sso.nsubsteps
--    dt = (sso.times[1] - sso.times[0]) / N_substeps
--    nt = sso.ntraj
--
--    data = Result()
--    data.solver = "smepdpsolve"
--    data.times = sso.times
--    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
--    data.jump_times = []
--    data.jump_op_idx = []
--
--    # Liouvillian for the deterministic part.
--    # needs to be modified for TD systems
--    L = liouvillian(sso.H, sso.c_ops)
--
--    progress_bar.start(sso.ntraj)
--
--    for n in range(sso.ntraj):
--        progress_bar.update(n)
--        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
--        rho_t = _data.column_stack_dense(rho_t)
--
--        states_list, jump_times, jump_op_idx = \
--            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
--                                           N_store, N_substeps,
--                                           rho_t, sso.rho0.dims,
--                                           sso.c_ops, sso.e_ops)
--
--        data.states.append(states_list)
--        data.jump_times.append(jump_times)
--        data.jump_op_idx.append(jump_op_idx)
--
--    progress_bar.finished()
--
--    # average density matrices
--    if options['average_states'] and np.any(data.states):
--        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
--                       for n in range(len(data.times))]
--
--    # average
--    data.expect = data.expect / sso.ntraj
--
--    # standard error
--    if nt > 1:
--        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
--    else:
--        data.se = None
--
--    return data
--
--def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
--    """
--    Internal function. See smepdpsolve.
--    """
--    states_list = []
--
--    rho_t = np.copy(rho_t)
--    sigma_t = np.copy(rho_t)
--
--    prng = RandomState()  # todo: seed it
--    r_jump, r_op = prng.rand(2)
--
--    jump_times = []
--    jump_op_idx = []
--
--    for t_idx, t in enumerate(times):
--
--        if e_ops:
--            for e_idx, e in enumerate(e_ops):
--                data.expect[e_idx, t_idx] +=\
--                    _data.expect_super(e, rho_t)
--        else:
--            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
--
--        for j in range(N_substeps):
--
--            if sigma_t.norm() < r_jump:
--                # jump occurs
--                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
--                p = np.cumsum(p / np.sum(p))
--                n = np.where(p >= r_op)[0][0]
--
--                # apply jump
--                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
--                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
--                sigma_t = np.copy(rho_t)
--
--                # store info about jump
--                jump_times.append(times[t_idx] + dt * j)
--                jump_op_idx.append(n)
--
--                # get new random numbers for next jump
--                r_jump, r_op = prng.rand(2)
--
--            # deterministic evolution wihtout correction for norm decay
--            dsigma_t = _data.matmul(L.data, sigma_t) * dt
--
--            # deterministic evolution with correction for norm decay
--            drho_t = _data.matmul(L.data, rho_t) * dt
--
--            # increment density matrices
--            sigma_t = _data.add(sigma_t, dsigma_t)
--            rho_t = _data.add(rho_t, drho_t)
--
--    return states_list, jump_times, jump_op_idx
-+# -*- coding: utf-8 -*-
-+
-+import numpy as np
-+from numpy.random import RandomState
-+
-+from .. import (
-+    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
-+)
-+from ..core import data as _data
-+from .solver import Result, SolverOptions
-+from .parallel import serial_map
-+from ..ui.progressbar import TextProgressBar
-+from ..settings import settings
-+debug = settings.debug
-+
-+
-+class StochasticSolverOptions:
-+    """
-+    Class of options for stochastic (piecewse deterministic process) PDP
-+    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
-+    :func:`qutip.pdpsolve.smepdpsolve`.
-+    Options can be specified either as arguments to the constructor::
-+
-+        sso = StochasticSolverOptions(nsubsteps=100, ...)
-+
-+    or by changing the class attributes after creation::
-+
-+        sso = StochasticSolverOptions()
-+        sso.nsubsteps = 1000
-+
-+    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
-+    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
-+    the constructor of these class, and internally they use these arguments to
-+    construct an instance of this class, so it is rarely needed to explicitly
-+    create an instance of this class.
-+
-+    Attributes
-+    ----------
-+
-+    H : :class:`qutip.Qobj`
-+        System Hamiltonian.
-+
-+    state0 : :class:`qutip.Qobj`
-+        Initial state vector (ket) or density matrix.
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`
-+        List of deterministic collapse operators.
-+
-+    sc_ops : list of :class:`qutip.Qobj`
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the equation of motion according to how the d1 and d2 functions
-+        are defined.
-+
-+    e_ops : list of :class:`qutip.Qobj`
-+        Single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    m_ops : list of :class:`qutip.Qobj`
-+        List of operators representing the measurement operators. The expected
-+        format is a nested list with one measurement operator for each
-+        stochastic increament, for each stochastic collapse operator.
-+
-+    args : dict / list
-+        List of dictionary of additional problem-specific parameters.
-+        Implicit methods can adjust tolerance via args = {'tol':value}
-+
-+    ntraj : int
-+        Number of trajectors.
-+
-+    nsubsteps : int
-+        Number of sub steps between each time-spep given in `times`.
-+
-+    d1 : function
-+        Function for calculating the operator-valued coefficient to the
-+        deterministic increment dt.
-+
-+    d2 : function
-+        Function for calculating the operator-valued coefficient to the
-+        stochastic increment(s) dW_n, where n is in [0, d2_len[.
-+
-+    d2_len : int (default 1)
-+        The number of stochastic increments in the process.
-+
-+    dW_factors : array
-+        Array of length d2_len, containing scaling factors for each
-+        measurement operator in m_ops.
-+
-+    rhs : function
-+        Function for calculating the deterministic and stochastic contributions
-+        to the right-hand side of the stochastic differential equation. This
-+        only needs to be specified when implementing a custom SDE solver.
-+
-+    generate_A_ops : function
-+        Function that generates a list of pre-computed operators or super-
-+        operators. These precomputed operators are used in some d1 and d2
-+        functions.
-+
-+    generate_noise : function
-+        Function for generate an array of pre-computed noise signal.
-+
-+    homogeneous : bool (True)
-+        Wheter or not the stochastic process is homogenous. Inhomogenous
-+        processes are only supported for poisson distributions.
-+
-+    solver : string
-+        Name of the solver method to use for solving the stochastic
-+        equations. Valid values are:
-+        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
-+        'pc-euler' is a predictor-corrector method which is more
-+        stable than explicit methods,
-+        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
-+        'milstein-imp' is semi-implicit Milstein method,
-+        3/2 order algorithms: 'taylor15',
-+        'taylor15-imp' is semi-implicit Taylor 1.5 method.
-+        Implicit methods can adjust tolerance via args = {'tol':value},
-+        default is {'tol':1e-6}
-+
-+    method : string ('homodyne', 'heterodyne', 'photocurrent')
-+        The name of the type of measurement process that give rise to the
-+        stochastic equation to solve. Specifying a method with this keyword
-+        argument is a short-hand notation for using pre-defined d1 and d2
-+        functions for the corresponding stochastic processes.
-+
-+    distribution : string ('normal', 'poisson')
-+        The name of the distribution used for the stochastic increments.
-+
-+    store_measurements : bool (default False)
-+        Whether or not to store the measurement results in the
-+        :class:`qutip.solver.Result` instance returned by the solver.
-+
-+    noise : array
-+        Vector specifying the noise.
-+
-+    normalize : bool (default True)
-+        Whether or not to normalize the wave function during the evolution.
-+
-+    options : :class:`qutip.solver.SolverOptions`
-+        Generic solver options.
-+
-+    map_func: function
-+        A map function or managing the calls to single-trajactory solvers.
-+
-+    map_kwargs: dictionary
-+        Optional keyword arguments to the map_func function function.
-+
-+    progress_bar : :class:`qutip.ui.BaseProgressBar`
-+        Optional progress bar class instance.
-+    """
-+    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
-+                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
-+                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
-+                 generate_A_ops=None, generate_noise=None, homogeneous=True,
-+                 solver=None, method=None, distribution='normal',
-+                 store_measurement=False, noise=None, normalize=True,
-+                 options=None, progress_bar=None, map_func=None,
-+                 map_kwargs=None):
-+
-+        if options is None:
-+            options = SolverOptions()
-+
-+        if progress_bar is None:
-+            progress_bar = TextProgressBar()
-+
-+        self.H = H
-+        self.d1 = d1
-+        self.d2 = d2
-+        self.d2_len = d2_len
-+        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
-+        self.state0 = state0
-+        self.times = times
-+        self.c_ops = c_ops
-+        self.sc_ops = sc_ops
-+        self.e_ops = e_ops
-+        self.m_ops = m_ops
-+
-+        self.ntraj = ntraj
-+        self.nsubsteps = nsubsteps
-+        self.solver = solver
-+        self.method = method
-+        self.distribution = distribution
-+        self.homogeneous = homogeneous
-+        self.rhs = rhs
-+        self.options = options
-+        self.progress_bar = progress_bar
-+        self.store_measurement = store_measurement
-+        self.store_states = options['store_states']
-+        self.noise = noise
-+        self.args = args
-+        self.normalize = normalize
-+
-+        self.generate_noise = generate_noise
-+        self.generate_A_ops = generate_A_ops
-+
-+        if self.ntraj > 1 and map_func:
-+            self.map_func = map_func
-+        else:
-+            self.map_func = serial_map
-+
-+        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-+
-+        # Does any operator depend on time?
-+        self.td = False
-+        if not isinstance(H, Qobj):
-+            self.td = True
-+        for ops in c_ops:
-+            if not isinstance(ops, Qobj):
-+                self.td = True
-+        for ops in sc_ops:
-+            if not isinstance(ops, Qobj):
-+                self.td = True
-+
-+
-+def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-+    """
-+    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-+    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-+    trajectory simulations.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`
-+        System Hamiltonian.
-+
-+    psi0 : :class:`qutip.Qobj`
-+        Initial state vector (ket).
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`
-+        Deterministic collapse operator which will contribute with a standard
-+        Lindblad type of dissipation.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function single
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = [e for e in e_ops.values()]
-+    else:
-+        e_ops_dict = None
-+
-+    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
-+                                  e_ops=e_ops, **kwargs)
-+
-+    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+    return res
-+
-+
-+def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-+    """
-+    A stochastic (piecewse deterministic process) PDP solver for density matrix
-+    evolution.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`
-+        System Hamiltonian.
-+
-+    rho0 : :class:`qutip.Qobj`
-+        Initial density matrix.
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`
-+        Deterministic collapse operator which will contribute with a standard
-+        Lindblad type of dissipation.
-+
-+    sc_ops : list of :class:`qutip.Qobj`
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the equation of motion according to how the d1 and d2 functions
-+        are defined.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function single
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = [e for e in e_ops.values()]
-+    else:
-+        e_ops_dict = None
-+
-+    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
-+                                  e_ops=e_ops, **kwargs)
-+
-+    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+    return res
-+
-+
-+# -----------------------------------------------------------------------------
-+# Generic parameterized stochastic SE PDP solver
-+#
-+def _ssepdpsolve_generic(sso, options, progress_bar):
-+    """
-+    For internal use. See ssepdpsolve.
-+    """
-+    N_store = len(sso.times)
-+    N_substeps = sso.nsubsteps
-+    dt = (sso.times[1] - sso.times[0]) / N_substeps
-+    nt = sso.ntraj
-+
-+    data = Result()
-+    data.solver = "sepdpsolve"
-+    data.times = sso.tlist
-+    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-+    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-+    data.jump_times = []
-+    data.jump_op_idx = []
-+
-+    # effective hamiltonian for deterministic part
-+    Heff = sso.H
-+    for c in sso.c_ops:
-+        Heff += -0.5j * c.dag() * c
-+
-+    progress_bar.start(sso.ntraj)
-+    for n in range(sso.ntraj):
-+        progress_bar.update(n)
-+        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
-+
-+        states_list, jump_times, jump_op_idx = \
-+            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
-+                                           N_store, N_substeps,
-+                                           psi_t, sso.state0.dims,
-+                                           sso.c_ops, sso.e_ops)
-+
-+        data.states.append(states_list)
-+        data.jump_times.append(jump_times)
-+        data.jump_op_idx.append(jump_op_idx)
-+
-+    progress_bar.finished()
-+
-+    # average density matrices
-+    if options['average_states'] and np.any(data.states):
-+        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-+                       for n in range(len(data.times))]
-+
-+    # average
-+    data.expect = data.expect / nt
-+
-+    # standard error
-+    if nt > 1:
-+        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-+    else:
-+        data.se = None
-+
-+    # convert complex data to real if hermitian
-+    data.expect = [np.real(data.expect[n, :])
-+                   if e.isherm else data.expect[n, :]
-+                   for n, e in enumerate(sso.e_ops)]
-+
-+    return data
-+
-+
-+def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
-+    """
-+    Internal function. See ssepdpsolve.
-+    """
-+    states_list = []
-+
-+    phi_t = psi_t.copy()
-+
-+    prng = RandomState()  # todo: seed it
-+    r_jump, r_op = prng.rand(2)
-+
-+    jump_times = []
-+    jump_op_idx = []
-+
-+    for t_idx, t in enumerate(times):
-+
-+        if e_ops:
-+            for e_idx, e in enumerate(e_ops):
-+                s = _data.expect(e, psi_t)
-+                data.expect[e_idx, t_idx] += s
-+                data.ss[e_idx, t_idx] += s ** 2
-+        else:
-+            states_list.append(Qobj(psi_t.to_array(), dims=dims))
-+
-+        for j in range(N_substeps):
-+
-+            if _data.norm.l2(phi_t) ** 2 < r_jump:
-+                # jump occurs
-+                p = np.array([
-+                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-+                    for c in c_ops
-+                ])
-+                p = np.cumsum(p / np.sum(p))
-+                n = np.where(p >= r_op)[0][0]
-+
-+                # apply jump
-+                psi_t = _data.matmul(c_ops[n].data, psi_t)
-+                psi_t /= _data.norm.l2(psi_t)
-+                phi_t = psi_t.copy()
-+
-+                # store info about jump
-+                jump_times.append(times[t_idx] + dt * j)
-+                jump_op_idx.append(n)
-+
-+                # get new random numbers for next jump
-+                r_jump, r_op = prng.rand(2)
-+
-+            # deterministic evolution wihtout correction for norm decay
-+            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
-+
-+            # deterministic evolution with correction for norm decay
-+            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
-+            A = 0.5 * np.sum([
-+                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-+                for c in c_ops
-+            ])
-+            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
-+
-+            # increment wavefunctions
-+            phi_t = _data.add(phi_t, dphi_t)
-+            psi_t = _data.add(psi_t, dpsi_t)
-+
-+            # ensure that normalized wavefunction remains normalized
-+            # this allows larger time step than otherwise would be possible
-+            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
-+
-+    return states_list, jump_times, jump_op_idx
-+
-+
-+# -----------------------------------------------------------------------------
-+# Generic parameterized stochastic ME PDP solver
-+#
-+def _smepdpsolve_generic(sso, options, progress_bar):
-+    """
-+    For internal use. See smepdpsolve.
-+    """
-+    N_store = len(sso.times)
-+    N_substeps = sso.nsubsteps
-+    dt = (sso.times[1] - sso.times[0]) / N_substeps
-+    nt = sso.ntraj
-+
-+    data = Result()
-+    data.solver = "smepdpsolve"
-+    data.times = sso.times
-+    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-+    data.jump_times = []
-+    data.jump_op_idx = []
-+
-+    # Liouvillian for the deterministic part.
-+    # needs to be modified for TD systems
-+    L = liouvillian(sso.H, sso.c_ops)
-+
-+    progress_bar.start(sso.ntraj)
-+
-+    for n in range(sso.ntraj):
-+        progress_bar.update(n)
-+        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
-+        rho_t = _data.column_stack_dense(rho_t)
-+
-+        states_list, jump_times, jump_op_idx = \
-+            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
-+                                           N_store, N_substeps,
-+                                           rho_t, sso.rho0.dims,
-+                                           sso.c_ops, sso.e_ops)
-+
-+        data.states.append(states_list)
-+        data.jump_times.append(jump_times)
-+        data.jump_op_idx.append(jump_op_idx)
-+
-+    progress_bar.finished()
-+
-+    # average density matrices
-+    if options['average_states'] and np.any(data.states):
-+        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-+                       for n in range(len(data.times))]
-+
-+    # average
-+    data.expect = data.expect / sso.ntraj
-+
-+    # standard error
-+    if nt > 1:
-+        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-+    else:
-+        data.se = None
-+
-+    return data
-+
-+def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
-+    """
-+    Internal function. See smepdpsolve.
-+    """
-+    states_list = []
-+
-+    rho_t = np.copy(rho_t)
-+    sigma_t = np.copy(rho_t)
-+
-+    prng = RandomState()  # todo: seed it
-+    r_jump, r_op = prng.rand(2)
-+
-+    jump_times = []
-+    jump_op_idx = []
-+
-+    for t_idx, t in enumerate(times):
-+
-+        if e_ops:
-+            for e_idx, e in enumerate(e_ops):
-+                data.expect[e_idx, t_idx] +=\
-+                    _data.expect_super(e, rho_t)
-+        else:
-+            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
-+
-+        for j in range(N_substeps):
-+
-+            if sigma_t.norm() < r_jump:
-+                # jump occurs
-+                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
-+                p = np.cumsum(p / np.sum(p))
-+                n = np.where(p >= r_op)[0][0]
-+
-+                # apply jump
-+                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
-+                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
-+                sigma_t = np.copy(rho_t)
-+
-+                # store info about jump
-+                jump_times.append(times[t_idx] + dt * j)
-+                jump_op_idx.append(n)
-+
-+                # get new random numbers for next jump
-+                r_jump, r_op = prng.rand(2)
-+
-+            # deterministic evolution wihtout correction for norm decay
-+            dsigma_t = _data.matmul(L.data, sigma_t) * dt
-+
-+            # deterministic evolution with correction for norm decay
-+            drho_t = _data.matmul(L.data, rho_t) * dt
-+
-+            # increment density matrices
-+            sigma_t = _data.add(sigma_t, dsigma_t)
-+            rho_t = _data.add(rho_t, drho_t)
-+
-+    return states_list, jump_times, jump_op_idx
-diff --git a/qutip/solve/piqs.py b/qutip/solve/piqs.py
-index 2784e986..b475d7d9 100644
---- a/qutip/solve/piqs.py
-+++ b/qutip/solve/piqs.py
-@@ -1,1926 +1,1926 @@
--"""Permutational Invariant Quantum Solver (PIQS)
--
--This module calculates the Liouvillian for the dynamics of ensembles of
--identical two-level systems (TLS) in the presence of local and collective
--processes by exploiting permutational symmetry and using the Dicke basis.
--It also allows to characterize nonlinear functions of the density matrix.
--"""
--
--# Authors: Nathan Shammah, Shahnawaz Ahmed
--# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
--
--from math import factorial
--from decimal import Decimal
--
--import numpy as np
--from scipy.integrate import odeint
--from scipy.linalg import eigvalsh
--from scipy.special import entr
--from scipy.sparse import dok_matrix, block_diag, lil_matrix
--from .. import (
--    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
--    sigmap, sigmam,
--)
--from ..entropy import entropy_vn
--from .solver import SolverOptions, Result
--from ._piqs import Dicke as _Dicke
--from ._piqs import (
--    jmm1_dictionary,
--    _num_dicke_states,
--    _num_dicke_ladders,
--    get_blocks,
--    j_min,
--    j_vals,
--)
--
--__all__ = [
--    "num_dicke_states",
--    "num_dicke_ladders",
--    "num_tls",
--    "isdiagonal",
--    "dicke_blocks",
--    "dicke_blocks_full",
--    "dicke_function_trace",
--    "purity_dicke",
--    "entropy_vn_dicke",
--    "Dicke",
--    "state_degeneracy",
--    "m_degeneracy",
--    "energy_degeneracy",
--    "ap",
--    "am",
--    "spin_algebra",
--    "jspin",
--    "collapse_uncoupled",
--    "dicke_basis",
--    "dicke",
--    "excited",
--    "superradiant",
--    "css",
--    "ghz",
--    "ground",
--    "identity_uncoupled",
--    "block_matrix",
--    "tau_column",
--    "Pim",
--]
--
--
--def _ensure_int(x):
--    """
--    Ensure that a floating-point value `x` is exactly an integer, and return it
--    as an int.
--    """
--    out = int(x)
--    if out != x:
--        raise ValueError(f"{x} is not an integral value")
--    return out
--
--
--# Functions necessary to generate the Lindbladian/Liouvillian
--def num_dicke_states(N):
--    """Calculate the number of Dicke states.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    nds: int
--        The number of Dicke states.
--    """
--    return _num_dicke_states(N)
--
--
--def num_dicke_ladders(N):
--    """Calculate the total number of ladders in the Dicke space.
--
--    For a collection of N two-level systems it counts how many different
--    "j" exist or the number of blocks in the block-diagonal matrix.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    Nj: int
--        The number of Dicke ladders.
--    """
--    return _num_dicke_ladders(N)
--
--
--def num_tls(nds):
--    """Calculate the number of two-level systems.
--
--    Parameters
--    ----------
--    nds: int
--         The number of Dicke states.
--
--    Returns
--    -------
--    N: int
--        The number of two-level systems.
--    """
--    if np.sqrt(nds).is_integer():
--        # N is even
--        N = 2 * (np.sqrt(nds) - 1)
--    else:
--        # N is odd
--        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
--    return int(N)
--
--
--def isdiagonal(mat):
--    """
--    Check if the input matrix is diagonal.
--
--    Parameters
--    ==========
--    mat: ndarray/Qobj
--        A 2D numpy array
--
--    Returns
--    =======
--    diag: bool
--        True/False depending on whether the input matrix is diagonal.
--    """
--    if isinstance(mat, Qobj):
--        mat = mat.full()
--
--    return np.all(mat == np.diag(np.diagonal(mat)))
--
--
--# nonlinear functions of the density matrix
--def dicke_blocks(rho):
--    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        A 2D block-diagonal matrix of ones with dimension (nds,nds),
--        where nds is the number of Dicke states for N two-level
--        systems.
--
--    Returns
--    -------
--    square_blocks: list of np.array
--        Give back the blocks list.
--
--    """
--    shape_dimension = rho.shape[0]
--    N = num_tls(shape_dimension)
--    ladders = num_dicke_ladders(N)
--    # create a list with the sizes of the blocks, in order
--    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
--    blocks_list = [
--        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
--        for i in range(blocks_dimensions)
--    ]
--    blocks_list = np.flip(blocks_list, 0)
--    # create a list with each block matrix as element
--    square_blocks = []
--    block_position = 0
--    for block_size in blocks_list:
--        start_m = block_position
--        end_m = block_position + block_size
--        square_block = rho[start_m:end_m, start_m:end_m]
--        block_position = block_position + block_size
--        square_blocks.append(square_block)
--
--    return square_blocks
--
--
--def dicke_blocks_full(rho):
--    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        A 2D block-diagonal matrix of ones with dimension (nds,nds),
--        where nds is the number of Dicke states for N two-level
--        systems.
--
--    Returns
--    -------
--    full_blocks : list
--        The list of blocks expanded in the 2^N space for N qubits.
--
--    """
--    shape_dimension = rho.shape[0]
--    N = num_tls(shape_dimension)
--    ladders = num_dicke_ladders(N)
--    # create a list with the sizes of the blocks, in order
--    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
--    blocks_list = [
--        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
--        for i in range(blocks_dimensions)
--    ]
--    blocks_list = np.flip(blocks_list, 0)
--    # create a list with each block matrix as element
--    full_blocks = []
--    k = 0
--    block_position = 0
--    for block_size in blocks_list:
--        start_m = block_position
--        end_m = block_position + block_size
--        square_block = rho[start_m:end_m, start_m:end_m]
--        block_position = block_position + block_size
--        j = N / 2 - k
--        djn = state_degeneracy(N, j)
--        for block_counter in range(0, djn):
--            full_blocks.append(square_block / djn)  # preserve trace
--        k = k + 1
--    return full_blocks
--
--
--def dicke_function_trace(f, rho):
--    """Calculate the trace of a function on a Dicke density matrix.
--    Parameters
--    ----------
--    f : function
--        A Taylor-expandable function of `rho`.
--
--    rho : :class:`qutip.Qobj`
--        A density matrix in the Dicke basis.
--
--    Returns
--    -------
--    res : float
--        Trace of a nonlinear function on `rho`.
--    """
--    N = num_tls(rho.shape[0])
--    blocks = dicke_blocks(rho)
--    block_f = []
--    degen_blocks = np.flip(j_vals(N))
--    state_degeneracies = []
--    for j in degen_blocks:
--        dj = state_degeneracy(N, j)
--        state_degeneracies.append(dj)
--    eigenvals_degeneracy = []
--    deg = []
--    for i, block in enumerate(blocks):
--        dj = state_degeneracies[i]
--        normalized_block = block / dj
--        eigenvals_block = eigvalsh(normalized_block)
--        for val in eigenvals_block:
--            eigenvals_degeneracy.append(val)
--            deg.append(dj)
--
--    eigenvalue = np.array(eigenvals_degeneracy)
--    function_array = f(eigenvalue) * deg
--    return sum(function_array)
--
--
--def entropy_vn_dicke(rho):
--    """Von Neumann Entropy of a Dicke-basis density matrix.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        A 2D block-diagonal matrix of ones with dimension (nds,nds),
--        where nds is the number of Dicke states for N two-level
--        systems.
--
--    Returns
--    -------
--    entropy_dm: float
--        Entropy. Use degeneracy to multiply each block.
--
--    """
--    return dicke_function_trace(entr, rho)
--
--
--def purity_dicke(rho):
--    """Calculate purity of a density matrix in the Dicke basis.
--    It accounts for the degenerate blocks in the density matrix.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
--
--    Returns
--    -------
--    purity : float
--        The purity of the quantum state.
--        It's 1 for pure states, 0<=purity<1 for mixed states.
--    """
--    f = lambda x: x * x
--    return dicke_function_trace(f, rho)
--
--
--class Dicke(object):
--    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
--
--    Examples
--    --------
--    >>> from piqs import Dicke, jspin
--    >>> N = 2
--    >>> jx, jy, jz = jspin(N)
--    >>> jp = jspin(N, "+")
--    >>> jm = jspin(N, "-")
--    >>> ensemble = Dicke(N, emission=1.)
--    >>> L = ensemble.liouvillian()
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    hamiltonian : :class:`qutip.Qobj`
--        A Hamiltonian in the Dicke basis.
--
--        The matrix dimensions are (nds, nds),
--        with nds being the number of Dicke states.
--        The Hamiltonian can be built with the operators
--        given by the `jspin` functions.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--
--    Attributes
--    ----------
--    N: int
--        The number of two-level systems.
--
--    hamiltonian : :class:`qutip.Qobj`
--        A Hamiltonian in the Dicke basis.
--
--        The matrix dimensions are (nds, nds),
--        with nds being the number of Dicke states.
--        The Hamiltonian can be built with the operators given
--        by the `jspin` function in the "dicke" basis.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    nds: int
--        The number of Dicke states.
--
--    dshape: tuple
--        The shape of the Hilbert space in the Dicke or uncoupled basis.
--        default: (nds, nds).
--    """
--
--    def __init__(
--        self,
--        N,
--        hamiltonian=None,
--        emission=0.0,
--        dephasing=0.0,
--        pumping=0.0,
--        collective_emission=0.0,
--        collective_dephasing=0.0,
--        collective_pumping=0.0,
--    ):
--        self.N = N
--        self.hamiltonian = hamiltonian
--        self.emission = emission
--        self.dephasing = dephasing
--        self.pumping = pumping
--        self.collective_emission = collective_emission
--        self.collective_dephasing = collective_dephasing
--        self.collective_pumping = collective_pumping
--        self.nds = num_dicke_states(self.N)
--        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
--
--    def __repr__(self):
--        """Print the current parameters of the system."""
--        string = []
--        string.append("N = {}".format(self.N))
--        string.append("Hilbert space dim = {}".format(self.dshape))
--        string.append("Number of Dicke states = {}".format(self.nds))
--        string.append(
--            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
--        )
--        if self.emission != 0:
--            string.append("emission = {}".format(self.emission))
--        if self.dephasing != 0:
--            string.append("dephasing = {}".format(self.dephasing))
--        if self.pumping != 0:
--            string.append("pumping = {}".format(self.pumping))
--        if self.collective_emission != 0:
--            string.append(
--                "collective_emission = {}".format(self.collective_emission)
--            )
--        if self.collective_dephasing != 0:
--            string.append(
--                "collective_dephasing = {}".format(self.collective_dephasing)
--            )
--        if self.collective_pumping != 0:
--            string.append(
--                "collective_pumping = {}".format(self.collective_pumping)
--            )
--        return "\n".join(string)
--
--    def lindbladian(self):
--        """Build the Lindbladian superoperator of the dissipative dynamics.
--
--        Returns
--        -------
--        lindbladian : :class:`qutip.Qobj`
--            The Lindbladian matrix as a `qutip.Qobj`.
--        """
--        cythonized_dicke = _Dicke(
--            int(self.N),
--            float(self.emission),
--            float(self.dephasing),
--            float(self.pumping),
--            float(self.collective_emission),
--            float(self.collective_dephasing),
--            float(self.collective_pumping),
--        )
--        return cythonized_dicke.lindbladian()
--
--    def liouvillian(self):
--        """Build the total Liouvillian using the Dicke basis.
--
--        Returns
--        -------
--        liouv : :class:`qutip.Qobj`
--            The Liouvillian matrix for the system.
--        """
--        lindblad = self.lindbladian()
--        if self.hamiltonian is None:
--            liouv = lindblad
--
--        else:
--            hamiltonian = self.hamiltonian
--            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
--                hamiltonian
--            )
--            liouv = lindblad + hamiltonian_superoperator
--        return liouv
--
--    def pisolve(self, initial_state, tlist, options=None):
--        """
--        Solve for diagonal Hamiltonians and initial states faster.
--
--        Parameters
--        ==========
--        initial_state : :class:`qutip.Qobj`
--            An initial state specified as a density matrix of
--            `qutip.Qbj` type.
--
--        tlist: ndarray
--            A 1D numpy array of list of timesteps to integrate
--
--        options : :class:`qutip.solver.SolverOptions`
--            The options for the solver.
--
--        Returns
--        =======
--        result: list
--            A dictionary of the type `qutip.solver.Result` which holds the
--            results of the evolution.
--        """
--        if isdiagonal(initial_state) == False:
--            msg = "`pisolve` requires a diagonal initial density matrix. "
--            msg += "In general construct the Liouvillian using "
--            msg += "`piqs.liouvillian` and use qutip.mesolve."
--            raise ValueError(msg)
--
--        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
--            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
--            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
--            msg += "  use `qutip.mesolve`."
--            raise ValueError(msg)
--
--        if initial_state.full().shape != self.dshape:
--            msg = "Initial density matrix should be diagonal."
--            raise ValueError(msg)
--
--        pim = Pim(
--            self.N,
--            self.emission,
--            self.dephasing,
--            self.pumping,
--            self.collective_emission,
--            self.collective_pumping,
--            self.collective_dephasing,
--        )
--        result = pim.solve(initial_state, tlist, options=None)
--        return result
--
--    def c_ops(self):
--        """Build collapse operators in the full Hilbert space 2^N.
--
--        Returns
--        -------
--        c_ops_list: list
--            The list with the collapse operators in the 2^N Hilbert space.
--        """
--        ce = self.collective_emission
--        cd = self.collective_dephasing
--        cp = self.collective_pumping
--        c_ops_list = collapse_uncoupled(
--            N=self.N,
--            emission=self.emission,
--            dephasing=self.dephasing,
--            pumping=self.pumping,
--            collective_emission=ce,
--            collective_dephasing=cd,
--            collective_pumping=cp,
--        )
--        return c_ops_list
--
--    def coefficient_matrix(self):
--        """Build coefficient matrix for ODE for a diagonal problem.
--
--        Returns
--        -------
--        M: ndarray
--            The matrix M of the coefficients for the ODE dp/dt = Mp.
--            p is the vector of the diagonal matrix elements
--            of the density matrix rho in the Dicke basis.
--        """
--        diagonal_system = Pim(
--            N=self.N,
--            emission=self.emission,
--            dephasing=self.dephasing,
--            pumping=self.pumping,
--            collective_emission=self.collective_emission,
--            collective_dephasing=self.collective_dephasing,
--            collective_pumping=self.collective_pumping,
--        )
--        coef_matrix = diagonal_system.coefficient_matrix()
--        return coef_matrix
--
--
--# Utility functions for properties of the Dicke space
--def energy_degeneracy(N, m):
--    """Calculate the number of Dicke states with same energy.
--
--    The use of the `Decimals` class allows to explore N > 1000,
--    unlike the built-in function `scipy.special.binom`
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    m: float
--        Total spin z-axis projection eigenvalue.
--        This is proportional to the total energy.
--
--    Returns
--    -------
--    degeneracy: int
--        The energy degeneracy
--    """
--    numerator = Decimal(factorial(N))
--    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
--    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
--    degeneracy = numerator / (d1 * d2)
--    return int(degeneracy)
--
--
--def state_degeneracy(N, j):
--    r"""Calculate the degeneracy of the Dicke state.
--
--    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
--    representations :math:`\lvert j, m, \alpha\rangle`.
--
--    Uses Decimals to calculate higher numerator and denominators numbers.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    j: float
--        Total spin eigenvalue (cooperativity).
--
--    Returns
--    -------
--    degeneracy: int
--        The state degeneracy.
--    """
--    if j < 0:
--        raise ValueError("j value should be >= 0")
--    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
--    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
--    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
--    degeneracy = numerator / (denominator_1 * denominator_2)
--    degeneracy = int(np.round(float(degeneracy)))
--    return degeneracy
--
--
--def m_degeneracy(N, m):
--    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
--    same energy.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    m: float
--        Total spin z-axis projection eigenvalue (proportional to the total
--        energy).
--
--    Returns
--    -------
--    degeneracy: int
--        The m-degeneracy.
--    """
--    jvals = j_vals(N)
--    maxj = np.max(jvals)
--    if m < -maxj:
--        e = "m value is incorrect for this N."
--        e += " Minimum m value can be {}".format(-maxj)
--        raise ValueError(e)
--    degeneracy = N / 2 + 1 - abs(m)
--    return int(degeneracy)
--
--
--def ap(j, m):
--    r"""
--    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
--
--    The action of ap is given by:
--    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
--
--    Parameters
--    ----------
--    j, m: float
--        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
--
--    Returns
--    -------
--    a_plus: float
--        The value of :math:`a_{+}`.
--    """
--    a_plus = np.sqrt((j - m) * (j + m + 1))
--    return a_plus
--
--
--def am(j, m):
--    r"""Calculate the operator ``am`` used later.
--
--    The action of ``ap`` is given by:
--    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
--
--    Parameters
--    ----------
--    j: float
--        The value for j.
--
--    m: float
--        The value for m.
--
--    Returns
--    -------
--    a_minus: float
--        The value of :math:`a_{-}`.
--    """
--    a_minus = np.sqrt((j + m) * (j - m + 1))
--    return a_minus
--
--
--def spin_algebra(N, op=None):
--    """Create the list [sx, sy, sz] with the spin operators.
--
--    The operators are constructed for a collection of N two-level systems
--    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
--    objects (spin matrices), as it cointains the list of the SU(2) Pauli
--    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
--    is placed in a :math:`2^N`-dimensional Hilbert space.
--
--    Notes
--    -----
--    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    spin_operators: list or :class: qutip.Qobj
--        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
--        requested operator.
--    """
--    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
--    N = int(N)
--    sx = [0 for i in range(N)]
--    sy = [0 for i in range(N)]
--    sz = [0 for i in range(N)]
--    sp = [0 for i in range(N)]
--    sm = [0 for i in range(N)]
--
--    sx[0] = 0.5 * sigmax()
--    sy[0] = 0.5 * sigmay()
--    sz[0] = 0.5 * sigmaz()
--    sp[0] = sigmap()
--    sm[0] = sigmam()
--
--    # 2. Place operators in total Hilbert space
--    for k in range(N - 1):
--        sx[0] = tensor(sx[0], identity(2))
--        sy[0] = tensor(sy[0], identity(2))
--        sz[0] = tensor(sz[0], identity(2))
--        sp[0] = tensor(sp[0], identity(2))
--        sm[0] = tensor(sm[0], identity(2))
--
--    # 3. Cyclic sequence to create all N operators
--    a = [i for i in range(N)]
--    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
--
--    # 4. Create N operators
--    for i in range(1, N):
--        sx[i] = sx[0].permute(b[i])
--        sy[i] = sy[0].permute(b[i])
--        sz[i] = sz[0].permute(b[i])
--        sp[i] = sp[0].permute(b[i])
--        sm[i] = sm[0].permute(b[i])
--
--    spin_operators = [sx, sy, sz]
--
--    if not op:
--        return spin_operators
--    elif op == "x":
--        return sx
--    elif op == "y":
--        return sy
--    elif op == "z":
--        return sz
--    elif op == "+":
--        return sp
--    elif op == "-":
--        return sm
--    else:
--        raise TypeError("Invalid type")
--
--
--def _jspin_uncoupled(N, op=None):
--    """Construct the the collective spin algebra in the uncoupled basis.
--
--    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
--    two-level system (TLS). Each collective operator is placed in a
--    Hilbert space of dimension 2^N.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    op: str
--        The operator to return 'x','y','z','+','-'.
--        If no operator given, then output is the list of operators
--        for ['x','y','z',].
--
--    Returns
--    -------
--    collective_operators: list or :class: qutip.Qobj
--        A list of `qutip.Qobj` representing all the operators in
--        uncoupled" basis or a single operator requested.
--    """
--    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
--    N = int(N)
--
--    sx, sy, sz = spin_algebra(N)
--    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
--
--    jx = sum(sx)
--    jy = sum(sy)
--    jz = sum(sz)
--    jp = sum(sp)
--    jm = sum(sm)
--
--    collective_operators = [jx, jy, jz]
--
--    if not op:
--        return collective_operators
--    elif op == "x":
--        return jx
--    elif op == "y":
--        return jy
--    elif op == "z":
--        return jz
--    elif op == "+":
--        return jp
--    elif op == "-":
--        return jm
--    else:
--        raise TypeError("Invalid type")
--
--
--def jspin(N, op=None, basis="dicke"):
--    r"""
--    Calculate the list of collective operators of the total algebra.
--
--    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
--    default. Otherwise with "uncoupled" the operators are in a
--    :math:`2^N` space.
--
--    Parameters
--    ----------
--    N: int
--        Number of two-level systems.
--
--    op: str
--        The operator to return 'x','y','z','+','-'.
--        If no operator given, then output is the list of operators
--        for ['x','y','z'].
--
--    basis: str
--        The basis of the operators - "dicke" or "uncoupled"
--        default: "dicke".
--
--    Returns
--    -------
--    j_alg: list or :class: qutip.Qobj
--        A list of `qutip.Qobj` representing all the operators in
--        the "dicke" or "uncoupled" basis or a single operator requested.
--    """
--    if basis == "uncoupled":
--        return _jspin_uncoupled(N, op)
--
--    nds = num_dicke_states(N)
--    num_ladders = num_dicke_ladders(N)
--    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
--    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
--    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
--    s = 0
--
--    for k in range(0, num_ladders):
--        j = 0.5 * N - k
--        mmax = int(2 * j + 1)
--        for i in range(0, mmax):
--            m = j - i
--            jz_operator[s, s] = m
--            if (s + 1) in range(0, nds):
--                jp_operator[s, s + 1] = ap(j, m - 1)
--            if (s - 1) in range(0, nds):
--                jm_operator[s, s - 1] = am(j, m + 1)
--            s = s + 1
--
--    jx_operator = 1 / 2 * (jp_operator + jm_operator)
--    jy_operator = 1j / 2 * (jm_operator - jp_operator)
--    jx = Qobj(jx_operator)
--    jy = Qobj(jy_operator)
--    jz = Qobj(jz_operator)
--    jp = Qobj(jp_operator)
--    jm = Qobj(jm_operator)
--
--    if not op:
--        return [jx, jy, jz]
--    if op == "+":
--        return jp
--    elif op == "-":
--        return jm
--    elif op == "x":
--        return jx
--    elif op == "y":
--        return jy
--    elif op == "z":
--        return jz
--    else:
--        raise TypeError("Invalid type")
--
--
--def collapse_uncoupled(
--    N,
--    emission=0.0,
--    dephasing=0.0,
--    pumping=0.0,
--    collective_emission=0.0,
--    collective_dephasing=0.0,
--    collective_pumping=0.0,
--):
--    """
--    Create the collapse operators (c_ops) of the Lindbladian in the
--    uncoupled basis
--
--    These operators are in the uncoupled basis of the two-level
--    system (TLS) SU(2) Pauli matrices.
--
--    Notes
--    -----
--    The collapse operator list can be given to `qutip.mesolve`.
--    Notice that the operators are placed in a Hilbert space of
--    dimension :math:`2^N`. Thus the method is suitable only for
--    small N (of the order of 10).
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--
--    Returns
--    -------
--    c_ops: list
--        The list of collapse operators as `qutip.Qobj` for the system.
--    """
--    N = int(N)
--
--    if N > 10:
--        msg = "N > 10. dim(H) = 2^N. "
--        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
--        msg += "dimension and exploit permutational symmetry."
--        raise Warning(msg)
--
--    [sx, sy, sz] = spin_algebra(N)
--    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
--    [jx, jy, jz] = jspin(N, basis="uncoupled")
--    jp, jm = (
--        jspin(N, "+", basis="uncoupled"),
--        jspin(N, "-", basis="uncoupled"),
--    )
--
--    c_ops = []
--
--    if emission != 0:
--        for i in range(0, N):
--            c_ops.append(np.sqrt(emission) * sm[i])
--
--    if dephasing != 0:
--        for i in range(0, N):
--            c_ops.append(np.sqrt(dephasing) * sz[i])
--
--    if pumping != 0:
--        for i in range(0, N):
--            c_ops.append(np.sqrt(pumping) * sp[i])
--
--    if collective_emission != 0:
--        c_ops.append(np.sqrt(collective_emission) * jm)
--
--    if collective_dephasing != 0:
--        c_ops.append(np.sqrt(collective_dephasing) * jz)
--
--    if collective_pumping != 0:
--        c_ops.append(np.sqrt(collective_pumping) * jp)
--
--    return c_ops
--
--
--# State definitions in the Dicke basis with an option for basis transformation
--def dicke_basis(N, jmm1=None):
--    r"""
--    Initialize the density matrix of a Dicke state for several (j, m, m1).
--
--    This function can be used to build arbitrary states in the Dicke basis
--    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
--    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
--    index of the density matrix to the :math:`\lvert j, m\rangle` values is
--    given by the cythonized function `jmm1_dictionary`. A density matrix is
--    created from the given dictionary of coefficients for each (j, m, m1).
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    jmm1: dict
--        A dictionary of {(j, m, m1): p} that gives a density p for the
--        (j, m, m1) matrix element.
--
--    Returns
--    -------
--    rho: :class: qutip.Qobj
--        The density matrix in the Dicke basis.
--    """
--    if jmm1 is None:
--        msg = "Please specify the jmm1 values as a dictionary"
--        msg += "or use the `excited(N)` function to create an"
--        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
--        raise AttributeError(msg)
--
--    nds = _num_dicke_states(N)
--    rho = np.zeros((nds, nds))
--    jmm1_dict = jmm1_dictionary(N)[1]
--    for key in jmm1:
--        i, k = jmm1_dict[key]
--        rho[i, k] = jmm1[key]
--    return Qobj(rho)
--
--
--def dicke(N, j, m):
--    r"""
--    Generate a Dicke state as a pure density matrix in the Dicke basis.
--
--    For instance, the superradiant state given by
--    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
--    and the state is represented as a density matrix of size (nds, nds) or
--    (4, 4), with the (1, 1) element set to 1.
--
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    j: float
--        The eigenvalue j of the Dicke state (j, m).
--
--    m: float
--        The eigenvalue m of the Dicke state (j, m).
--
--    Returns
--    -------
--    rho: :class: qutip.Qobj
--        The density matrix.
--    """
--    nds = num_dicke_states(N)
--    rho = np.zeros((nds, nds))
--
--    jmm1_dict = jmm1_dictionary(N)[1]
--
--    i, k = jmm1_dict[(j, m, m)]
--    rho[i, k] = 1.0
--    return Qobj(rho)
--
--
--# Uncoupled states in the full Hilbert space. These are returned with the
--# choice of the keyword argument `basis="uncoupled"` in the state functions.
--def _uncoupled_excited(N):
--    """
--    Generate the density matrix of the excited Dicke state in the full
--    :math:`2^N` dimensional Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    psi0: :class: qutip.Qobj
--        The density matrix for the excited state in the uncoupled basis.
--    """
--    N = int(N)
--    jz = jspin(N, "z", basis="uncoupled")
--    en, vn = jz.eigenstates()
--    psi0 = vn[2 ** N - 1]
--    return ket2dm(psi0)
--
--
--def _uncoupled_superradiant(N):
--    """
--    Generate the density matrix of a superradiant state in the full
--    :math:`2^N`-dimensional Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    psi0: :class: qutip.Qobj
--        The density matrix for the superradiant state in the full Hilbert
--        space.
--    """
--    N = int(N)
--    jz = jspin(N, "z", basis="uncoupled")
--    en, vn = jz.eigenstates()
--    psi0 = vn[2 ** N - (N + 1)]
--    return ket2dm(psi0)
--
--
--def _uncoupled_ground(N):
--    """
--    Generate the density matrix of the ground state in the full\
--    :math:`2^N`-dimensional Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    psi0: :class: qutip.Qobj
--        The density matrix for the ground state in the full Hilbert space.
--    """
--    N = int(N)
--    jz = jspin(N, "z", basis="uncoupled")
--    en, vn = jz.eigenstates()
--    psi0 = vn[0]
--    return ket2dm(psi0)
--
--
--def _uncoupled_ghz(N):
--    """
--    Generate the density matrix of the GHZ state in the full 2^N
--    dimensional Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    ghz: :class: qutip.Qobj
--        The density matrix for the GHZ state in the full Hilbert space.
--    """
--    N = int(N)
--    rho = np.zeros((2 ** N, 2 ** N))
--    rho[0, 0] = 1 / 2
--    rho[2 ** N - 1, 0] = 1 / 2
--    rho[0, 2 ** N - 1] = 1 / 2
--    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
--    spin_dim = [2 for i in range(0, N)]
--    spins_dims = list((spin_dim, spin_dim))
--    rho = Qobj(rho, dims=spins_dims)
--    return rho
--
--
--def _uncoupled_css(N, a, b):
--    r"""
--    Generate the density matrix of the CSS state in the full 2^N
--    dimensional Hilbert space.
--
--    The CSS states are non-entangled states given by
--    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    a: complex
--        The coefficient of the :math:`\lvert1_i\rangle` state.
--
--    b: complex
--        The coefficient of the :math:`\lvert0_i\rangle` state.
--
--    Returns
--    -------
--    css: :class: qutip.Qobj
--        The density matrix for the CSS state in the full Hilbert space.
--    """
--    N = int(N)
--    # 1. Define i_th factorized density matrix in the uncoupled basis
--    rho_i = np.zeros((2, 2), dtype=complex)
--    rho_i[0, 0] = a * np.conj(a)
--    rho_i[1, 1] = b * np.conj(b)
--    rho_i[0, 1] = a * np.conj(b)
--    rho_i[1, 0] = b * np.conj(a)
--    rho_i = Qobj(rho_i)
--    rho = [0 for i in range(N)]
--    rho[0] = rho_i
--    # 2. Place single-two-level-system density matrices in total Hilbert space
--    for k in range(N - 1):
--        rho[0] = tensor(rho[0], identity(2))
--    # 3. Cyclic sequence to create all N factorized density matrices
--    # |CSS>_i<CSS|_i
--    a = [i for i in range(N)]
--    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
--    # 4. Create all other N-1 factorized density matrices
--    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
--    for i in range(1, N):
--        rho[i] = rho[0].permute(b[i])
--    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
--    rho_tot = identity_i
--    for i in range(0, N):
--        rho_tot = rho_tot * rho[i]
--    return rho_tot
--
--
--def excited(N, basis="dicke"):
--    """
--    Generate the density matrix for the excited state.
--
--    This state is given by (N/2, N/2) in the default Dicke basis. If the
--    argument `basis` is "uncoupled" then it generates the state in a
--    2**N dim Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    basis: str
--        The basis to use. Either "dicke" or "uncoupled".
--
--    Returns
--    -------
--    state: :class: qutip.Qobj
--        The excited state density matrix in the requested basis.
--    """
--    if basis == "uncoupled":
--        state = _uncoupled_excited(N)
--        return state
--
--    jmm1 = {(N / 2, N / 2, N / 2): 1}
--    return dicke_basis(N, jmm1)
--
--
--def superradiant(N, basis="dicke"):
--    """
--    Generate the density matrix of the superradiant state.
--
--    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
--    If the argument `basis` is "uncoupled" then it generates the state
--    in a 2**N dim Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    basis: str
--        The basis to use. Either "dicke" or "uncoupled".
--
--    Returns
--    -------
--    state: :class: qutip.Qobj
--        The superradiant state density matrix in the requested basis.
--    """
--    if basis == "uncoupled":
--        state = _uncoupled_superradiant(N)
--        return state
--
--    if N % 2 == 0:
--        jmm1 = {(N / 2, 0, 0): 1.0}
--        return dicke_basis(N, jmm1)
--    else:
--        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
--    return dicke_basis(N, jmm1)
--
--
--def css(
--    N,
--    x=1 / np.sqrt(2),
--    y=1 / np.sqrt(2),
--    basis="dicke",
--    coordinates="cartesian",
--):
--    r"""
--    Generate the density matrix of the Coherent Spin State (CSS).
--
--    It can be defined as,
--    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
--    with :math:`a = sin(\frac{\theta}{2})`,
--    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
--    The default basis is that of Dicke space
--    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
--    The default state is the symmetric CSS,
--    :math:`\lvert CSS\rangle = \lvert+\rangle`.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    x, y: float
--        The coefficients of the CSS state.
--
--    basis: str
--        The basis to use. Either "dicke" or "uncoupled".
--
--    coordinates: str
--        Either "cartesian" or "polar". If polar then the coefficients
--        are constructed as sin(x/2), cos(x/2)e^(iy).
--
--    Returns
--    -------
--    rho: :class: qutip.Qobj
--        The CSS state density matrix.
--    """
--    if coordinates == "polar":
--        a = np.cos(0.5 * x) * np.exp(1j * y)
--        b = np.sin(0.5 * x)
--    else:
--        a = x
--        b = y
--    if basis == "uncoupled":
--        return _uncoupled_css(N, a, b)
--    nds = num_dicke_states(N)
--    num_ladders = num_dicke_ladders(N)
--    rho = dok_matrix((nds, nds), dtype=np.complex128)
--
--    # loop in the allowed matrix elements
--    jmm1_dict = jmm1_dictionary(N)[1]
--
--    j = 0.5 * N
--    mmax = int(2 * j + 1)
--    for i in range(0, mmax):
--        m = j - i
--        psi_m = (
--            np.sqrt(float(energy_degeneracy(N, m)))
--            * a ** (N * 0.5 + m)
--            * b ** (N * 0.5 - m)
--        )
--        for i1 in range(0, mmax):
--            m1 = j - i1
--            row_column = jmm1_dict[(j, m, m1)]
--            psi_m1 = (
--                np.sqrt(float(energy_degeneracy(N, m1)))
--                * np.conj(a) ** (N * 0.5 + m1)
--                * np.conj(b) ** (N * 0.5 - m1)
--            )
--            rho[row_column] = psi_m * psi_m1
--    return Qobj(rho)
--
--
--def ghz(N, basis="dicke"):
--    """
--    Generate the density matrix of the GHZ state.
--
--    If the argument `basis` is "uncoupled" then it generates the state
--    in a :math:`2^N`-dimensional Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    basis: str
--        The basis to use. Either "dicke" or "uncoupled".
--
--    Returns
--    -------
--    state: :class: qutip.Qobj
--        The GHZ state density matrix in the requested basis.
--    """
--    if basis == "uncoupled":
--        return _uncoupled_ghz(N)
--    nds = _num_dicke_states(N)
--    rho = dok_matrix((nds, nds), dtype=np.complex128)
--    rho[0, 0] = 1 / 2
--    rho[N, N] = 1 / 2
--    rho[N, 0] = 1 / 2
--    rho[0, N] = 1 / 2
--    return Qobj(rho)
--
--
--def ground(N, basis="dicke"):
--    """
--    Generate the density matrix of the ground state.
--
--    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
--    `basis` is "uncoupled" then it generates the state in a
--    :math:`2^N`-dimensional Hilbert space.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    basis: str
--        The basis to use. Either "dicke" or "uncoupled"
--
--    Returns
--    -------
--    state: :class: qutip.Qobj
--        The ground state density matrix in the requested basis.
--    """
--    if basis == "uncoupled":
--        state = _uncoupled_ground(N)
--        return state
--    nds = _num_dicke_states(N)
--    rho = dok_matrix((nds, nds), dtype=np.complex128)
--    rho[N, N] = 1
--    return Qobj(rho)
--
--
--def identity_uncoupled(N):
--    """
--    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
--
--    The identity matrix is formed from the tensor product of N TLSs.
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    Returns
--    -------
--    identity: :class: qutip.Qobj
--        The identity matrix.
--    """
--    N = int(N)
--    rho = np.zeros((2 ** N, 2 ** N))
--    for i in range(0, 2 ** N):
--        rho[i, i] = 1
--    spin_dim = [2 for i in range(0, N)]
--    spins_dims = list((spin_dim, spin_dim))
--    identity = Qobj(rho, dims=spins_dims)
--    return identity
--
--
--def block_matrix(N, elements="ones"):
--    """Construct the block-diagonal matrix for the Dicke basis.
--
--    Parameters
--    ----------
--    N : int
--        Number of two-level systems.
--    elements : str {'ones' (default),'degeneracy'}
--
--    Returns
--    -------
--    block_matr : ndarray
--        A 2D block-diagonal matrix with dimension (nds,nds),
--        where nds is the number of Dicke states for N two-level
--        systems. Filled with ones or the value of degeneracy
--        at each matrix element.
--    """
--    # create a list with the sizes of the blocks, in order
--    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
--    blocks_list = [
--        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
--        for i in range(blocks_dimensions)
--    ]
--    blocks_list = np.flip(blocks_list, 0)
--    # create a list with each block matrix as element
--    square_blocks = []
--    k = 0
--    for i in blocks_list:
--        if elements == "ones":
--            square_blocks.append(np.ones((i, i)))
--        elif elements == "degeneracy":
--            j = N / 2 - k
--            dj = state_degeneracy(N, j)
--            square_blocks.append(dj * np.ones((i, i)))
--        k = k + 1
--    return block_diag(square_blocks)
--
--
--# ============================================================================
--# Adding a faster version to make a Permutational Invariant matrix
--# ============================================================================
--def tau_column(tau, k, j):
--    """
--    Determine the column index for the non-zero elements of the matrix for a
--    particular row `k` and the value of `j` from the Dicke space.
--
--    Parameters
--    ----------
--    tau: str
--        The tau function to check for this `k` and `j`.
--
--    k: int
--        The row of the matrix M for which the non zero elements have
--        to be calculated.
--
--    j: float
--        The value of `j` for this row.
--    """
--    # In the notes, we indexed from k = 1, here we do it from k = 0
--    k = k + 1
--    mapping = {
--        "tau3": k - (2 * j + 3),
--        "tau2": k - 1,
--        "tau4": k + (2 * j - 1),
--        "tau5": k - (2 * j + 2),
--        "tau1": k,
--        "tau6": k + (2 * j),
--        "tau7": k - (2 * j + 1),
--        "tau8": k + 1,
--        "tau9": k + (2 * j + 1),
--    }
--    # we need to decrement k again as indexing is from 0
--    return int(mapping[tau] - 1)
--
--
--class Pim(object):
--    """
--    The Permutation Invariant Matrix class.
--
--    Initialize the class with the parameters for generating a Permutation
--    Invariant matrix which evolves a given diagonal initial state `p` as:
--
--                                dp/dt = Mp
--
--    Parameters
--    ----------
--    N: int
--        The number of two-level systems.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--
--    Attributes
--    ----------
--    N: int
--        The number of two-level systems.
--
--    emission: float
--        Incoherent emission coefficient (also nonradiative emission).
--        default: 0.0
--
--    dephasing: float
--        Local dephasing coefficient.
--        default: 0.0
--
--    pumping: float
--        Incoherent pumping coefficient.
--        default: 0.0
--
--    collective_emission: float
--        Collective (superradiant) emmission coefficient.
--        default: 0.0
--
--    collective_dephasing: float
--        Collective dephasing coefficient.
--        default: 0.0
--
--    collective_pumping: float
--        Collective pumping coefficient.
--        default: 0.0
--
--    M: dict
--        A nested dictionary of the structure {row: {col: val}} which holds
--        non zero elements of the matrix M
--    """
--
--    def __init__(
--        self,
--        N,
--        emission=0.0,
--        dephasing=0,
--        pumping=0,
--        collective_emission=0,
--        collective_pumping=0,
--        collective_dephasing=0,
--    ):
--        self.N = N
--        self.emission = emission
--        self.dephasing = dephasing
--        self.pumping = pumping
--        self.collective_pumping = collective_pumping
--        self.collective_dephasing = collective_dephasing
--        self.collective_emission = collective_emission
--        self.M = {}
--
--    def isdicke(self, dicke_row, dicke_col):
--        """
--        Check if an element in a matrix is a valid element in the Dicke space.
--        Dicke row: j value index. Dicke column: m value index.
--        The function returns True if the element exists in the Dicke space and
--        False otherwise.
--
--        Parameters
--        ----------
--        dicke_row, dicke_col : int
--            Index of the element in Dicke space which needs to be checked
--        """
--        rows = self.N + 1
--        cols = 0
--
--        if (self.N % 2) == 0:
--            cols = int(self.N / 2 + 1)
--        else:
--            cols = int(self.N / 2 + 1 / 2)
--        if (dicke_row > rows) or (dicke_row < 0):
--            return False
--        if (dicke_col > cols) or (dicke_col < 0):
--            return False
--        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
--            return False
--        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
--            return False
--        else:
--            return True
--
--    def tau_valid(self, dicke_row, dicke_col):
--        """
--        Find the Tau functions which are valid for this value of (dicke_row,
--        dicke_col) given the number of TLS. This calculates the valid tau
--        values and reurns a dictionary specifying the tau function name and
--        the value.
--
--        Parameters
--        ----------
--        dicke_row, dicke_col : int
--            Index of the element in Dicke space which needs to be checked.
--
--        Returns
--        -------
--        taus: dict
--            A dictionary of key, val as {tau: value} consisting of the valid
--            taus for this row and column of the Dicke space element.
--        """
--        tau_functions = [
--            self.tau3,
--            self.tau2,
--            self.tau4,
--            self.tau5,
--            self.tau1,
--            self.tau6,
--            self.tau7,
--            self.tau8,
--            self.tau9,
--        ]
--        N = self.N
--        if self.isdicke(dicke_row, dicke_col) is False:
--            return False
--        # The 3x3 sub matrix surrounding the Dicke space element to
--        # run the tau functions
--        indices = [
--            (dicke_row + x, dicke_col + y)
--            for x in range(-1, 2)
--            for y in range(-1, 2)
--        ]
--        taus = {}
--        for idx, tau in zip(indices, tau_functions):
--            if self.isdicke(idx[0], idx[1]):
--                j, m = self.calculate_j_m(idx[0], idx[1])
--                taus[tau.__name__] = tau(j, m)
--        return taus
--
--    def calculate_j_m(self, dicke_row, dicke_col):
--        """
--        Get the value of j and m for the particular Dicke space element.
--
--        Parameters
--        ----------
--        dicke_row, dicke_col: int
--            The row and column from the Dicke space matrix
--
--        Returns
--        -------
--        j, m: float
--            The j and m values.
--        """
--        N = self.N
--        j = N / 2 - dicke_col
--        m = N / 2 - dicke_row
--        return (j, m)
--
--    def calculate_k(self, dicke_row, dicke_col):
--        """
--        Get k value from the current row and column element in the Dicke space.
--
--        Parameters
--        ----------
--        dicke_row, dicke_col: int
--            The row and column from the Dicke space matrix.
--        Returns
--        -------
--        k: int
--            The row index for the matrix M for given Dicke space
--            element.
--        """
--        N = self.N
--        if dicke_row == 0:
--            k = dicke_col
--        else:
--            k = int(
--                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
--                + (dicke_row - (dicke_col))
--            )
--        return k
--
--    def coefficient_matrix(self):
--        """
--        Generate the matrix M governing the dynamics for diagonal cases.
--
--        If the initial density matrix and the Hamiltonian is diagonal, the
--        evolution of the system is given by the simple ODE: dp/dt = Mp.
--        """
--        N = self.N
--        nds = num_dicke_states(N)
--        rows = self.N + 1
--        cols = 0
--
--        sparse_M = lil_matrix((nds, nds), dtype=float)
--        if (self.N % 2) == 0:
--            cols = int(self.N / 2 + 1)
--        else:
--            cols = int(self.N / 2 + 1 / 2)
--        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
--            if self.isdicke(dicke_row, dicke_col):
--                k = int(self.calculate_k(dicke_row, dicke_col))
--                row = {}
--                taus = self.tau_valid(dicke_row, dicke_col)
--                for tau in taus:
--                    j, m = self.calculate_j_m(dicke_row, dicke_col)
--                    current_col = tau_column(tau, k, j)
--                    sparse_M[k, int(current_col)] = taus[tau]
--        return sparse_M.tocsr()
--
--    def solve(self, rho0, tlist, options=None):
--        """
--        Solve the ODE for the evolution of diagonal states and Hamiltonians.
--        """
--        if options is None:
--            options = SolverOptions()
--        output = Result()
--        output.solver = "pisolve"
--        output.times = tlist
--        output.states = []
--        output.states.append(Qobj(rho0))
--        rhs_generate = lambda y, tt, M: M.dot(y)
--        rho0_flat = np.diag(np.real(rho0.full()))
--        L = self.coefficient_matrix()
--        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
--        for r in rho_t[1:]:
--            diag = np.diag(r)
--            output.states.append(Qobj(diag))
--        return output
--
--    def tau1(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j, m, m).
--        """
--        yS = self.collective_emission
--        yL = self.emission
--        yD = self.dephasing
--        yP = self.pumping
--        yCP = self.collective_pumping
--        N = float(self.N)
--        spontaneous = yS * (1 + j - m) * (j + m)
--        losses = yL * (N / 2 + m)
--        pump = yP * (N / 2 - m)
--        collective_pump = yCP * (1 + j + m) * (j - m)
--        if j == 0:
--            dephase = yD * N / 4
--        else:
--            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
--        t1 = spontaneous + losses + pump + dephase + collective_pump
--        return -t1
--
--    def tau2(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j, m+1, m+1).
--        """
--        yS = self.collective_emission
--        yL = self.emission
--        N = float(self.N)
--        spontaneous = yS * (1 + j - m) * (j + m)
--        losses = yL * (
--            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
--        )
--        t2 = spontaneous + losses
--        return t2
--
--    def tau3(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
--        """
--        yL = self.emission
--        N = float(self.N)
--        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
--        den = 2 * j * (2 * j + 1)
--        t3 = yL * (num / den)
--        return t3
--
--    def tau4(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
--        """
--        yL = self.emission
--        N = float(self.N)
--        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
--        den = 2 * (j + 1) * (2 * j + 1)
--        t4 = yL * (num / den)
--        return t4
--
--    def tau5(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j+1, m, m).
--        """
--        yD = self.dephasing
--        N = float(self.N)
--        num = (j - m) * (j + m) * (j + 1 + N / 2)
--        den = 2 * j * (2 * j + 1)
--        t5 = yD * (num / den)
--        return t5
--
--    def tau6(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j-1, m, m).
--        """
--        yD = self.dephasing
--        N = float(self.N)
--        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
--        den = 2 * (j + 1) * (2 * j + 1)
--        t6 = yD * (num / den)
--        return t6
--
--    def tau7(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
--        """
--        yP = self.pumping
--        N = float(self.N)
--        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
--        den = 2 * j * (2 * j + 1)
--        t7 = yP * (float(num) / den)
--        return t7
--
--    def tau8(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j, m-1, m-1).
--        """
--        yP = self.pumping
--        yCP = self.collective_pumping
--        N = float(self.N)
--
--        num = (1 + N / 2) * (j - m) * (j + m + 1)
--        den = 2 * j * (j + 1)
--        pump = yP * (float(num) / den)
--        collective_pump = yCP * (j - m) * (j + m + 1)
--        t8 = pump + collective_pump
--        return t8
--
--    def tau9(self, j, m):
--        """
--        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
--        """
--        yP = self.pumping
--        N = float(self.N)
--        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
--        den = 2 * (j + 1) * (2 * j + 1)
--        t9 = yP * (float(num) / den)
--        return t9
-+"""Permutational Invariant Quantum Solver (PIQS)
-+
-+This module calculates the Liouvillian for the dynamics of ensembles of
-+identical two-level systems (TLS) in the presence of local and collective
-+processes by exploiting permutational symmetry and using the Dicke basis.
-+It also allows to characterize nonlinear functions of the density matrix.
-+"""
-+
-+# Authors: Nathan Shammah, Shahnawaz Ahmed
-+# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
-+
-+from math import factorial
-+from decimal import Decimal
-+
-+import numpy as np
-+from scipy.integrate import odeint
-+from scipy.linalg import eigvalsh
-+from scipy.special import entr
-+from scipy.sparse import dok_matrix, block_diag, lil_matrix
-+from .. import (
-+    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
-+    sigmap, sigmam,
-+)
-+from ..entropy import entropy_vn
-+from .solver import SolverOptions, Result
-+from ._piqs import Dicke as _Dicke
-+from ._piqs import (
-+    jmm1_dictionary,
-+    _num_dicke_states,
-+    _num_dicke_ladders,
-+    get_blocks,
-+    j_min,
-+    j_vals,
-+)
-+
-+__all__ = [
-+    "num_dicke_states",
-+    "num_dicke_ladders",
-+    "num_tls",
-+    "isdiagonal",
-+    "dicke_blocks",
-+    "dicke_blocks_full",
-+    "dicke_function_trace",
-+    "purity_dicke",
-+    "entropy_vn_dicke",
-+    "Dicke",
-+    "state_degeneracy",
-+    "m_degeneracy",
-+    "energy_degeneracy",
-+    "ap",
-+    "am",
-+    "spin_algebra",
-+    "jspin",
-+    "collapse_uncoupled",
-+    "dicke_basis",
-+    "dicke",
-+    "excited",
-+    "superradiant",
-+    "css",
-+    "ghz",
-+    "ground",
-+    "identity_uncoupled",
-+    "block_matrix",
-+    "tau_column",
-+    "Pim",
-+]
-+
-+
-+def _ensure_int(x):
-+    """
-+    Ensure that a floating-point value `x` is exactly an integer, and return it
-+    as an int.
-+    """
-+    out = int(x)
-+    if out != x:
-+        raise ValueError(f"{x} is not an integral value")
-+    return out
-+
-+
-+# Functions necessary to generate the Lindbladian/Liouvillian
-+def num_dicke_states(N):
-+    """Calculate the number of Dicke states.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    nds: int
-+        The number of Dicke states.
-+    """
-+    return _num_dicke_states(N)
-+
-+
-+def num_dicke_ladders(N):
-+    """Calculate the total number of ladders in the Dicke space.
-+
-+    For a collection of N two-level systems it counts how many different
-+    "j" exist or the number of blocks in the block-diagonal matrix.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    Nj: int
-+        The number of Dicke ladders.
-+    """
-+    return _num_dicke_ladders(N)
-+
-+
-+def num_tls(nds):
-+    """Calculate the number of two-level systems.
-+
-+    Parameters
-+    ----------
-+    nds: int
-+         The number of Dicke states.
-+
-+    Returns
-+    -------
-+    N: int
-+        The number of two-level systems.
-+    """
-+    if np.sqrt(nds).is_integer():
-+        # N is even
-+        N = 2 * (np.sqrt(nds) - 1)
-+    else:
-+        # N is odd
-+        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
-+    return int(N)
-+
-+
-+def isdiagonal(mat):
-+    """
-+    Check if the input matrix is diagonal.
-+
-+    Parameters
-+    ==========
-+    mat: ndarray/Qobj
-+        A 2D numpy array
-+
-+    Returns
-+    =======
-+    diag: bool
-+        True/False depending on whether the input matrix is diagonal.
-+    """
-+    if isinstance(mat, Qobj):
-+        mat = mat.full()
-+
-+    return np.all(mat == np.diag(np.diagonal(mat)))
-+
-+
-+# nonlinear functions of the density matrix
-+def dicke_blocks(rho):
-+    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-+        where nds is the number of Dicke states for N two-level
-+        systems.
-+
-+    Returns
-+    -------
-+    square_blocks: list of np.array
-+        Give back the blocks list.
-+
-+    """
-+    shape_dimension = rho.shape[0]
-+    N = num_tls(shape_dimension)
-+    ladders = num_dicke_ladders(N)
-+    # create a list with the sizes of the blocks, in order
-+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-+    blocks_list = [
-+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-+        for i in range(blocks_dimensions)
-+    ]
-+    blocks_list = np.flip(blocks_list, 0)
-+    # create a list with each block matrix as element
-+    square_blocks = []
-+    block_position = 0
-+    for block_size in blocks_list:
-+        start_m = block_position
-+        end_m = block_position + block_size
-+        square_block = rho[start_m:end_m, start_m:end_m]
-+        block_position = block_position + block_size
-+        square_blocks.append(square_block)
-+
-+    return square_blocks
-+
-+
-+def dicke_blocks_full(rho):
-+    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-+        where nds is the number of Dicke states for N two-level
-+        systems.
-+
-+    Returns
-+    -------
-+    full_blocks : list
-+        The list of blocks expanded in the 2^N space for N qubits.
-+
-+    """
-+    shape_dimension = rho.shape[0]
-+    N = num_tls(shape_dimension)
-+    ladders = num_dicke_ladders(N)
-+    # create a list with the sizes of the blocks, in order
-+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-+    blocks_list = [
-+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-+        for i in range(blocks_dimensions)
-+    ]
-+    blocks_list = np.flip(blocks_list, 0)
-+    # create a list with each block matrix as element
-+    full_blocks = []
-+    k = 0
-+    block_position = 0
-+    for block_size in blocks_list:
-+        start_m = block_position
-+        end_m = block_position + block_size
-+        square_block = rho[start_m:end_m, start_m:end_m]
-+        block_position = block_position + block_size
-+        j = N / 2 - k
-+        djn = state_degeneracy(N, j)
-+        for block_counter in range(0, djn):
-+            full_blocks.append(square_block / djn)  # preserve trace
-+        k = k + 1
-+    return full_blocks
-+
-+
-+def dicke_function_trace(f, rho):
-+    """Calculate the trace of a function on a Dicke density matrix.
-+    Parameters
-+    ----------
-+    f : function
-+        A Taylor-expandable function of `rho`.
-+
-+    rho : :class:`qutip.Qobj`
-+        A density matrix in the Dicke basis.
-+
-+    Returns
-+    -------
-+    res : float
-+        Trace of a nonlinear function on `rho`.
-+    """
-+    N = num_tls(rho.shape[0])
-+    blocks = dicke_blocks(rho)
-+    block_f = []
-+    degen_blocks = np.flip(j_vals(N))
-+    state_degeneracies = []
-+    for j in degen_blocks:
-+        dj = state_degeneracy(N, j)
-+        state_degeneracies.append(dj)
-+    eigenvals_degeneracy = []
-+    deg = []
-+    for i, block in enumerate(blocks):
-+        dj = state_degeneracies[i]
-+        normalized_block = block / dj
-+        eigenvals_block = eigvalsh(normalized_block)
-+        for val in eigenvals_block:
-+            eigenvals_degeneracy.append(val)
-+            deg.append(dj)
-+
-+    eigenvalue = np.array(eigenvals_degeneracy)
-+    function_array = f(eigenvalue) * deg
-+    return sum(function_array)
-+
-+
-+def entropy_vn_dicke(rho):
-+    """Von Neumann Entropy of a Dicke-basis density matrix.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-+        where nds is the number of Dicke states for N two-level
-+        systems.
-+
-+    Returns
-+    -------
-+    entropy_dm: float
-+        Entropy. Use degeneracy to multiply each block.
-+
-+    """
-+    return dicke_function_trace(entr, rho)
-+
-+
-+def purity_dicke(rho):
-+    """Calculate purity of a density matrix in the Dicke basis.
-+    It accounts for the degenerate blocks in the density matrix.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
-+
-+    Returns
-+    -------
-+    purity : float
-+        The purity of the quantum state.
-+        It's 1 for pure states, 0<=purity<1 for mixed states.
-+    """
-+    f = lambda x: x * x
-+    return dicke_function_trace(f, rho)
-+
-+
-+class Dicke(object):
-+    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
-+
-+    Examples
-+    --------
-+    >>> from piqs import Dicke, jspin
-+    >>> N = 2
-+    >>> jx, jy, jz = jspin(N)
-+    >>> jp = jspin(N, "+")
-+    >>> jm = jspin(N, "-")
-+    >>> ensemble = Dicke(N, emission=1.)
-+    >>> L = ensemble.liouvillian()
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    hamiltonian : :class:`qutip.Qobj`
-+        A Hamiltonian in the Dicke basis.
-+
-+        The matrix dimensions are (nds, nds),
-+        with nds being the number of Dicke states.
-+        The Hamiltonian can be built with the operators
-+        given by the `jspin` functions.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+
-+    Attributes
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    hamiltonian : :class:`qutip.Qobj`
-+        A Hamiltonian in the Dicke basis.
-+
-+        The matrix dimensions are (nds, nds),
-+        with nds being the number of Dicke states.
-+        The Hamiltonian can be built with the operators given
-+        by the `jspin` function in the "dicke" basis.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    nds: int
-+        The number of Dicke states.
-+
-+    dshape: tuple
-+        The shape of the Hilbert space in the Dicke or uncoupled basis.
-+        default: (nds, nds).
-+    """
-+
-+    def __init__(
-+        self,
-+        N,
-+        hamiltonian=None,
-+        emission=0.0,
-+        dephasing=0.0,
-+        pumping=0.0,
-+        collective_emission=0.0,
-+        collective_dephasing=0.0,
-+        collective_pumping=0.0,
-+    ):
-+        self.N = N
-+        self.hamiltonian = hamiltonian
-+        self.emission = emission
-+        self.dephasing = dephasing
-+        self.pumping = pumping
-+        self.collective_emission = collective_emission
-+        self.collective_dephasing = collective_dephasing
-+        self.collective_pumping = collective_pumping
-+        self.nds = num_dicke_states(self.N)
-+        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
-+
-+    def __repr__(self):
-+        """Print the current parameters of the system."""
-+        string = []
-+        string.append("N = {}".format(self.N))
-+        string.append("Hilbert space dim = {}".format(self.dshape))
-+        string.append("Number of Dicke states = {}".format(self.nds))
-+        string.append(
-+            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
-+        )
-+        if self.emission != 0:
-+            string.append("emission = {}".format(self.emission))
-+        if self.dephasing != 0:
-+            string.append("dephasing = {}".format(self.dephasing))
-+        if self.pumping != 0:
-+            string.append("pumping = {}".format(self.pumping))
-+        if self.collective_emission != 0:
-+            string.append(
-+                "collective_emission = {}".format(self.collective_emission)
-+            )
-+        if self.collective_dephasing != 0:
-+            string.append(
-+                "collective_dephasing = {}".format(self.collective_dephasing)
-+            )
-+        if self.collective_pumping != 0:
-+            string.append(
-+                "collective_pumping = {}".format(self.collective_pumping)
-+            )
-+        return "\n".join(string)
-+
-+    def lindbladian(self):
-+        """Build the Lindbladian superoperator of the dissipative dynamics.
-+
-+        Returns
-+        -------
-+        lindbladian : :class:`qutip.Qobj`
-+            The Lindbladian matrix as a `qutip.Qobj`.
-+        """
-+        cythonized_dicke = _Dicke(
-+            int(self.N),
-+            float(self.emission),
-+            float(self.dephasing),
-+            float(self.pumping),
-+            float(self.collective_emission),
-+            float(self.collective_dephasing),
-+            float(self.collective_pumping),
-+        )
-+        return cythonized_dicke.lindbladian()
-+
-+    def liouvillian(self):
-+        """Build the total Liouvillian using the Dicke basis.
-+
-+        Returns
-+        -------
-+        liouv : :class:`qutip.Qobj`
-+            The Liouvillian matrix for the system.
-+        """
-+        lindblad = self.lindbladian()
-+        if self.hamiltonian is None:
-+            liouv = lindblad
-+
-+        else:
-+            hamiltonian = self.hamiltonian
-+            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
-+                hamiltonian
-+            )
-+            liouv = lindblad + hamiltonian_superoperator
-+        return liouv
-+
-+    def pisolve(self, initial_state, tlist, options=None):
-+        """
-+        Solve for diagonal Hamiltonians and initial states faster.
-+
-+        Parameters
-+        ==========
-+        initial_state : :class:`qutip.Qobj`
-+            An initial state specified as a density matrix of
-+            `qutip.Qbj` type.
-+
-+        tlist: ndarray
-+            A 1D numpy array of list of timesteps to integrate
-+
-+        options : :class:`qutip.solver.SolverOptions`
-+            The options for the solver.
-+
-+        Returns
-+        =======
-+        result: list
-+            A dictionary of the type `qutip.solver.Result` which holds the
-+            results of the evolution.
-+        """
-+        if isdiagonal(initial_state) == False:
-+            msg = "`pisolve` requires a diagonal initial density matrix. "
-+            msg += "In general construct the Liouvillian using "
-+            msg += "`piqs.liouvillian` and use qutip.mesolve."
-+            raise ValueError(msg)
-+
-+        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
-+            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
-+            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
-+            msg += "  use `qutip.mesolve`."
-+            raise ValueError(msg)
-+
-+        if initial_state.full().shape != self.dshape:
-+            msg = "Initial density matrix should be diagonal."
-+            raise ValueError(msg)
-+
-+        pim = Pim(
-+            self.N,
-+            self.emission,
-+            self.dephasing,
-+            self.pumping,
-+            self.collective_emission,
-+            self.collective_pumping,
-+            self.collective_dephasing,
-+        )
-+        result = pim.solve(initial_state, tlist, options=None)
-+        return result
-+
-+    def c_ops(self):
-+        """Build collapse operators in the full Hilbert space 2^N.
-+
-+        Returns
-+        -------
-+        c_ops_list: list
-+            The list with the collapse operators in the 2^N Hilbert space.
-+        """
-+        ce = self.collective_emission
-+        cd = self.collective_dephasing
-+        cp = self.collective_pumping
-+        c_ops_list = collapse_uncoupled(
-+            N=self.N,
-+            emission=self.emission,
-+            dephasing=self.dephasing,
-+            pumping=self.pumping,
-+            collective_emission=ce,
-+            collective_dephasing=cd,
-+            collective_pumping=cp,
-+        )
-+        return c_ops_list
-+
-+    def coefficient_matrix(self):
-+        """Build coefficient matrix for ODE for a diagonal problem.
-+
-+        Returns
-+        -------
-+        M: ndarray
-+            The matrix M of the coefficients for the ODE dp/dt = Mp.
-+            p is the vector of the diagonal matrix elements
-+            of the density matrix rho in the Dicke basis.
-+        """
-+        diagonal_system = Pim(
-+            N=self.N,
-+            emission=self.emission,
-+            dephasing=self.dephasing,
-+            pumping=self.pumping,
-+            collective_emission=self.collective_emission,
-+            collective_dephasing=self.collective_dephasing,
-+            collective_pumping=self.collective_pumping,
-+        )
-+        coef_matrix = diagonal_system.coefficient_matrix()
-+        return coef_matrix
-+
-+
-+# Utility functions for properties of the Dicke space
-+def energy_degeneracy(N, m):
-+    """Calculate the number of Dicke states with same energy.
-+
-+    The use of the `Decimals` class allows to explore N > 1000,
-+    unlike the built-in function `scipy.special.binom`
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    m: float
-+        Total spin z-axis projection eigenvalue.
-+        This is proportional to the total energy.
-+
-+    Returns
-+    -------
-+    degeneracy: int
-+        The energy degeneracy
-+    """
-+    numerator = Decimal(factorial(N))
-+    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
-+    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
-+    degeneracy = numerator / (d1 * d2)
-+    return int(degeneracy)
-+
-+
-+def state_degeneracy(N, j):
-+    r"""Calculate the degeneracy of the Dicke state.
-+
-+    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
-+    representations :math:`\lvert j, m, \alpha\rangle`.
-+
-+    Uses Decimals to calculate higher numerator and denominators numbers.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    j: float
-+        Total spin eigenvalue (cooperativity).
-+
-+    Returns
-+    -------
-+    degeneracy: int
-+        The state degeneracy.
-+    """
-+    if j < 0:
-+        raise ValueError("j value should be >= 0")
-+    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
-+    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
-+    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
-+    degeneracy = numerator / (denominator_1 * denominator_2)
-+    degeneracy = int(np.round(float(degeneracy)))
-+    return degeneracy
-+
-+
-+def m_degeneracy(N, m):
-+    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
-+    same energy.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    m: float
-+        Total spin z-axis projection eigenvalue (proportional to the total
-+        energy).
-+
-+    Returns
-+    -------
-+    degeneracy: int
-+        The m-degeneracy.
-+    """
-+    jvals = j_vals(N)
-+    maxj = np.max(jvals)
-+    if m < -maxj:
-+        e = "m value is incorrect for this N."
-+        e += " Minimum m value can be {}".format(-maxj)
-+        raise ValueError(e)
-+    degeneracy = N / 2 + 1 - abs(m)
-+    return int(degeneracy)
-+
-+
-+def ap(j, m):
-+    r"""
-+    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
-+
-+    The action of ap is given by:
-+    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
-+
-+    Parameters
-+    ----------
-+    j, m: float
-+        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
-+
-+    Returns
-+    -------
-+    a_plus: float
-+        The value of :math:`a_{+}`.
-+    """
-+    a_plus = np.sqrt((j - m) * (j + m + 1))
-+    return a_plus
-+
-+
-+def am(j, m):
-+    r"""Calculate the operator ``am`` used later.
-+
-+    The action of ``ap`` is given by:
-+    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
-+
-+    Parameters
-+    ----------
-+    j: float
-+        The value for j.
-+
-+    m: float
-+        The value for m.
-+
-+    Returns
-+    -------
-+    a_minus: float
-+        The value of :math:`a_{-}`.
-+    """
-+    a_minus = np.sqrt((j + m) * (j - m + 1))
-+    return a_minus
-+
-+
-+def spin_algebra(N, op=None):
-+    """Create the list [sx, sy, sz] with the spin operators.
-+
-+    The operators are constructed for a collection of N two-level systems
-+    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
-+    objects (spin matrices), as it cointains the list of the SU(2) Pauli
-+    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
-+    is placed in a :math:`2^N`-dimensional Hilbert space.
-+
-+    Notes
-+    -----
-+    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    spin_operators: list or :class: qutip.Qobj
-+        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
-+        requested operator.
-+    """
-+    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
-+    N = int(N)
-+    sx = [0 for i in range(N)]
-+    sy = [0 for i in range(N)]
-+    sz = [0 for i in range(N)]
-+    sp = [0 for i in range(N)]
-+    sm = [0 for i in range(N)]
-+
-+    sx[0] = 0.5 * sigmax()
-+    sy[0] = 0.5 * sigmay()
-+    sz[0] = 0.5 * sigmaz()
-+    sp[0] = sigmap()
-+    sm[0] = sigmam()
-+
-+    # 2. Place operators in total Hilbert space
-+    for k in range(N - 1):
-+        sx[0] = tensor(sx[0], identity(2))
-+        sy[0] = tensor(sy[0], identity(2))
-+        sz[0] = tensor(sz[0], identity(2))
-+        sp[0] = tensor(sp[0], identity(2))
-+        sm[0] = tensor(sm[0], identity(2))
-+
-+    # 3. Cyclic sequence to create all N operators
-+    a = [i for i in range(N)]
-+    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
-+
-+    # 4. Create N operators
-+    for i in range(1, N):
-+        sx[i] = sx[0].permute(b[i])
-+        sy[i] = sy[0].permute(b[i])
-+        sz[i] = sz[0].permute(b[i])
-+        sp[i] = sp[0].permute(b[i])
-+        sm[i] = sm[0].permute(b[i])
-+
-+    spin_operators = [sx, sy, sz]
-+
-+    if not op:
-+        return spin_operators
-+    elif op == "x":
-+        return sx
-+    elif op == "y":
-+        return sy
-+    elif op == "z":
-+        return sz
-+    elif op == "+":
-+        return sp
-+    elif op == "-":
-+        return sm
-+    else:
-+        raise TypeError("Invalid type")
-+
-+
-+def _jspin_uncoupled(N, op=None):
-+    """Construct the the collective spin algebra in the uncoupled basis.
-+
-+    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
-+    two-level system (TLS). Each collective operator is placed in a
-+    Hilbert space of dimension 2^N.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    op: str
-+        The operator to return 'x','y','z','+','-'.
-+        If no operator given, then output is the list of operators
-+        for ['x','y','z',].
-+
-+    Returns
-+    -------
-+    collective_operators: list or :class: qutip.Qobj
-+        A list of `qutip.Qobj` representing all the operators in
-+        uncoupled" basis or a single operator requested.
-+    """
-+    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
-+    N = int(N)
-+
-+    sx, sy, sz = spin_algebra(N)
-+    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
-+
-+    jx = sum(sx)
-+    jy = sum(sy)
-+    jz = sum(sz)
-+    jp = sum(sp)
-+    jm = sum(sm)
-+
-+    collective_operators = [jx, jy, jz]
-+
-+    if not op:
-+        return collective_operators
-+    elif op == "x":
-+        return jx
-+    elif op == "y":
-+        return jy
-+    elif op == "z":
-+        return jz
-+    elif op == "+":
-+        return jp
-+    elif op == "-":
-+        return jm
-+    else:
-+        raise TypeError("Invalid type")
-+
-+
-+def jspin(N, op=None, basis="dicke"):
-+    r"""
-+    Calculate the list of collective operators of the total algebra.
-+
-+    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
-+    default. Otherwise with "uncoupled" the operators are in a
-+    :math:`2^N` space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        Number of two-level systems.
-+
-+    op: str
-+        The operator to return 'x','y','z','+','-'.
-+        If no operator given, then output is the list of operators
-+        for ['x','y','z'].
-+
-+    basis: str
-+        The basis of the operators - "dicke" or "uncoupled"
-+        default: "dicke".
-+
-+    Returns
-+    -------
-+    j_alg: list or :class: qutip.Qobj
-+        A list of `qutip.Qobj` representing all the operators in
-+        the "dicke" or "uncoupled" basis or a single operator requested.
-+    """
-+    if basis == "uncoupled":
-+        return _jspin_uncoupled(N, op)
-+
-+    nds = num_dicke_states(N)
-+    num_ladders = num_dicke_ladders(N)
-+    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
-+    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
-+    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
-+    s = 0
-+
-+    for k in range(0, num_ladders):
-+        j = 0.5 * N - k
-+        mmax = int(2 * j + 1)
-+        for i in range(0, mmax):
-+            m = j - i
-+            jz_operator[s, s] = m
-+            if (s + 1) in range(0, nds):
-+                jp_operator[s, s + 1] = ap(j, m - 1)
-+            if (s - 1) in range(0, nds):
-+                jm_operator[s, s - 1] = am(j, m + 1)
-+            s = s + 1
-+
-+    jx_operator = 1 / 2 * (jp_operator + jm_operator)
-+    jy_operator = 1j / 2 * (jm_operator - jp_operator)
-+    jx = Qobj(jx_operator)
-+    jy = Qobj(jy_operator)
-+    jz = Qobj(jz_operator)
-+    jp = Qobj(jp_operator)
-+    jm = Qobj(jm_operator)
-+
-+    if not op:
-+        return [jx, jy, jz]
-+    if op == "+":
-+        return jp
-+    elif op == "-":
-+        return jm
-+    elif op == "x":
-+        return jx
-+    elif op == "y":
-+        return jy
-+    elif op == "z":
-+        return jz
-+    else:
-+        raise TypeError("Invalid type")
-+
-+
-+def collapse_uncoupled(
-+    N,
-+    emission=0.0,
-+    dephasing=0.0,
-+    pumping=0.0,
-+    collective_emission=0.0,
-+    collective_dephasing=0.0,
-+    collective_pumping=0.0,
-+):
-+    """
-+    Create the collapse operators (c_ops) of the Lindbladian in the
-+    uncoupled basis
-+
-+    These operators are in the uncoupled basis of the two-level
-+    system (TLS) SU(2) Pauli matrices.
-+
-+    Notes
-+    -----
-+    The collapse operator list can be given to `qutip.mesolve`.
-+    Notice that the operators are placed in a Hilbert space of
-+    dimension :math:`2^N`. Thus the method is suitable only for
-+    small N (of the order of 10).
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+
-+    Returns
-+    -------
-+    c_ops: list
-+        The list of collapse operators as `qutip.Qobj` for the system.
-+    """
-+    N = int(N)
-+
-+    if N > 10:
-+        msg = "N > 10. dim(H) = 2^N. "
-+        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
-+        msg += "dimension and exploit permutational symmetry."
-+        raise Warning(msg)
-+
-+    [sx, sy, sz] = spin_algebra(N)
-+    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
-+    [jx, jy, jz] = jspin(N, basis="uncoupled")
-+    jp, jm = (
-+        jspin(N, "+", basis="uncoupled"),
-+        jspin(N, "-", basis="uncoupled"),
-+    )
-+
-+    c_ops = []
-+
-+    if emission != 0:
-+        for i in range(0, N):
-+            c_ops.append(np.sqrt(emission) * sm[i])
-+
-+    if dephasing != 0:
-+        for i in range(0, N):
-+            c_ops.append(np.sqrt(dephasing) * sz[i])
-+
-+    if pumping != 0:
-+        for i in range(0, N):
-+            c_ops.append(np.sqrt(pumping) * sp[i])
-+
-+    if collective_emission != 0:
-+        c_ops.append(np.sqrt(collective_emission) * jm)
-+
-+    if collective_dephasing != 0:
-+        c_ops.append(np.sqrt(collective_dephasing) * jz)
-+
-+    if collective_pumping != 0:
-+        c_ops.append(np.sqrt(collective_pumping) * jp)
-+
-+    return c_ops
-+
-+
-+# State definitions in the Dicke basis with an option for basis transformation
-+def dicke_basis(N, jmm1=None):
-+    r"""
-+    Initialize the density matrix of a Dicke state for several (j, m, m1).
-+
-+    This function can be used to build arbitrary states in the Dicke basis
-+    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
-+    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
-+    index of the density matrix to the :math:`\lvert j, m\rangle` values is
-+    given by the cythonized function `jmm1_dictionary`. A density matrix is
-+    created from the given dictionary of coefficients for each (j, m, m1).
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    jmm1: dict
-+        A dictionary of {(j, m, m1): p} that gives a density p for the
-+        (j, m, m1) matrix element.
-+
-+    Returns
-+    -------
-+    rho: :class: qutip.Qobj
-+        The density matrix in the Dicke basis.
-+    """
-+    if jmm1 is None:
-+        msg = "Please specify the jmm1 values as a dictionary"
-+        msg += "or use the `excited(N)` function to create an"
-+        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
-+        raise AttributeError(msg)
-+
-+    nds = _num_dicke_states(N)
-+    rho = np.zeros((nds, nds))
-+    jmm1_dict = jmm1_dictionary(N)[1]
-+    for key in jmm1:
-+        i, k = jmm1_dict[key]
-+        rho[i, k] = jmm1[key]
-+    return Qobj(rho)
-+
-+
-+def dicke(N, j, m):
-+    r"""
-+    Generate a Dicke state as a pure density matrix in the Dicke basis.
-+
-+    For instance, the superradiant state given by
-+    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
-+    and the state is represented as a density matrix of size (nds, nds) or
-+    (4, 4), with the (1, 1) element set to 1.
-+
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    j: float
-+        The eigenvalue j of the Dicke state (j, m).
-+
-+    m: float
-+        The eigenvalue m of the Dicke state (j, m).
-+
-+    Returns
-+    -------
-+    rho: :class: qutip.Qobj
-+        The density matrix.
-+    """
-+    nds = num_dicke_states(N)
-+    rho = np.zeros((nds, nds))
-+
-+    jmm1_dict = jmm1_dictionary(N)[1]
-+
-+    i, k = jmm1_dict[(j, m, m)]
-+    rho[i, k] = 1.0
-+    return Qobj(rho)
-+
-+
-+# Uncoupled states in the full Hilbert space. These are returned with the
-+# choice of the keyword argument `basis="uncoupled"` in the state functions.
-+def _uncoupled_excited(N):
-+    """
-+    Generate the density matrix of the excited Dicke state in the full
-+    :math:`2^N` dimensional Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    psi0: :class: qutip.Qobj
-+        The density matrix for the excited state in the uncoupled basis.
-+    """
-+    N = int(N)
-+    jz = jspin(N, "z", basis="uncoupled")
-+    en, vn = jz.eigenstates()
-+    psi0 = vn[2 ** N - 1]
-+    return ket2dm(psi0)
-+
-+
-+def _uncoupled_superradiant(N):
-+    """
-+    Generate the density matrix of a superradiant state in the full
-+    :math:`2^N`-dimensional Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    psi0: :class: qutip.Qobj
-+        The density matrix for the superradiant state in the full Hilbert
-+        space.
-+    """
-+    N = int(N)
-+    jz = jspin(N, "z", basis="uncoupled")
-+    en, vn = jz.eigenstates()
-+    psi0 = vn[2 ** N - (N + 1)]
-+    return ket2dm(psi0)
-+
-+
-+def _uncoupled_ground(N):
-+    """
-+    Generate the density matrix of the ground state in the full\
-+    :math:`2^N`-dimensional Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    psi0: :class: qutip.Qobj
-+        The density matrix for the ground state in the full Hilbert space.
-+    """
-+    N = int(N)
-+    jz = jspin(N, "z", basis="uncoupled")
-+    en, vn = jz.eigenstates()
-+    psi0 = vn[0]
-+    return ket2dm(psi0)
-+
-+
-+def _uncoupled_ghz(N):
-+    """
-+    Generate the density matrix of the GHZ state in the full 2^N
-+    dimensional Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    ghz: :class: qutip.Qobj
-+        The density matrix for the GHZ state in the full Hilbert space.
-+    """
-+    N = int(N)
-+    rho = np.zeros((2 ** N, 2 ** N))
-+    rho[0, 0] = 1 / 2
-+    rho[2 ** N - 1, 0] = 1 / 2
-+    rho[0, 2 ** N - 1] = 1 / 2
-+    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
-+    spin_dim = [2 for i in range(0, N)]
-+    spins_dims = list((spin_dim, spin_dim))
-+    rho = Qobj(rho, dims=spins_dims)
-+    return rho
-+
-+
-+def _uncoupled_css(N, a, b):
-+    r"""
-+    Generate the density matrix of the CSS state in the full 2^N
-+    dimensional Hilbert space.
-+
-+    The CSS states are non-entangled states given by
-+    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    a: complex
-+        The coefficient of the :math:`\lvert1_i\rangle` state.
-+
-+    b: complex
-+        The coefficient of the :math:`\lvert0_i\rangle` state.
-+
-+    Returns
-+    -------
-+    css: :class: qutip.Qobj
-+        The density matrix for the CSS state in the full Hilbert space.
-+    """
-+    N = int(N)
-+    # 1. Define i_th factorized density matrix in the uncoupled basis
-+    rho_i = np.zeros((2, 2), dtype=complex)
-+    rho_i[0, 0] = a * np.conj(a)
-+    rho_i[1, 1] = b * np.conj(b)
-+    rho_i[0, 1] = a * np.conj(b)
-+    rho_i[1, 0] = b * np.conj(a)
-+    rho_i = Qobj(rho_i)
-+    rho = [0 for i in range(N)]
-+    rho[0] = rho_i
-+    # 2. Place single-two-level-system density matrices in total Hilbert space
-+    for k in range(N - 1):
-+        rho[0] = tensor(rho[0], identity(2))
-+    # 3. Cyclic sequence to create all N factorized density matrices
-+    # |CSS>_i<CSS|_i
-+    a = [i for i in range(N)]
-+    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
-+    # 4. Create all other N-1 factorized density matrices
-+    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
-+    for i in range(1, N):
-+        rho[i] = rho[0].permute(b[i])
-+    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
-+    rho_tot = identity_i
-+    for i in range(0, N):
-+        rho_tot = rho_tot * rho[i]
-+    return rho_tot
-+
-+
-+def excited(N, basis="dicke"):
-+    """
-+    Generate the density matrix for the excited state.
-+
-+    This state is given by (N/2, N/2) in the default Dicke basis. If the
-+    argument `basis` is "uncoupled" then it generates the state in a
-+    2**N dim Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    basis: str
-+        The basis to use. Either "dicke" or "uncoupled".
-+
-+    Returns
-+    -------
-+    state: :class: qutip.Qobj
-+        The excited state density matrix in the requested basis.
-+    """
-+    if basis == "uncoupled":
-+        state = _uncoupled_excited(N)
-+        return state
-+
-+    jmm1 = {(N / 2, N / 2, N / 2): 1}
-+    return dicke_basis(N, jmm1)
-+
-+
-+def superradiant(N, basis="dicke"):
-+    """
-+    Generate the density matrix of the superradiant state.
-+
-+    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
-+    If the argument `basis` is "uncoupled" then it generates the state
-+    in a 2**N dim Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    basis: str
-+        The basis to use. Either "dicke" or "uncoupled".
-+
-+    Returns
-+    -------
-+    state: :class: qutip.Qobj
-+        The superradiant state density matrix in the requested basis.
-+    """
-+    if basis == "uncoupled":
-+        state = _uncoupled_superradiant(N)
-+        return state
-+
-+    if N % 2 == 0:
-+        jmm1 = {(N / 2, 0, 0): 1.0}
-+        return dicke_basis(N, jmm1)
-+    else:
-+        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
-+    return dicke_basis(N, jmm1)
-+
-+
-+def css(
-+    N,
-+    x=1 / np.sqrt(2),
-+    y=1 / np.sqrt(2),
-+    basis="dicke",
-+    coordinates="cartesian",
-+):
-+    r"""
-+    Generate the density matrix of the Coherent Spin State (CSS).
-+
-+    It can be defined as,
-+    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
-+    with :math:`a = sin(\frac{\theta}{2})`,
-+    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
-+    The default basis is that of Dicke space
-+    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
-+    The default state is the symmetric CSS,
-+    :math:`\lvert CSS\rangle = \lvert+\rangle`.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    x, y: float
-+        The coefficients of the CSS state.
-+
-+    basis: str
-+        The basis to use. Either "dicke" or "uncoupled".
-+
-+    coordinates: str
-+        Either "cartesian" or "polar". If polar then the coefficients
-+        are constructed as sin(x/2), cos(x/2)e^(iy).
-+
-+    Returns
-+    -------
-+    rho: :class: qutip.Qobj
-+        The CSS state density matrix.
-+    """
-+    if coordinates == "polar":
-+        a = np.cos(0.5 * x) * np.exp(1j * y)
-+        b = np.sin(0.5 * x)
-+    else:
-+        a = x
-+        b = y
-+    if basis == "uncoupled":
-+        return _uncoupled_css(N, a, b)
-+    nds = num_dicke_states(N)
-+    num_ladders = num_dicke_ladders(N)
-+    rho = dok_matrix((nds, nds), dtype=np.complex128)
-+
-+    # loop in the allowed matrix elements
-+    jmm1_dict = jmm1_dictionary(N)[1]
-+
-+    j = 0.5 * N
-+    mmax = int(2 * j + 1)
-+    for i in range(0, mmax):
-+        m = j - i
-+        psi_m = (
-+            np.sqrt(float(energy_degeneracy(N, m)))
-+            * a ** (N * 0.5 + m)
-+            * b ** (N * 0.5 - m)
-+        )
-+        for i1 in range(0, mmax):
-+            m1 = j - i1
-+            row_column = jmm1_dict[(j, m, m1)]
-+            psi_m1 = (
-+                np.sqrt(float(energy_degeneracy(N, m1)))
-+                * np.conj(a) ** (N * 0.5 + m1)
-+                * np.conj(b) ** (N * 0.5 - m1)
-+            )
-+            rho[row_column] = psi_m * psi_m1
-+    return Qobj(rho)
-+
-+
-+def ghz(N, basis="dicke"):
-+    """
-+    Generate the density matrix of the GHZ state.
-+
-+    If the argument `basis` is "uncoupled" then it generates the state
-+    in a :math:`2^N`-dimensional Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    basis: str
-+        The basis to use. Either "dicke" or "uncoupled".
-+
-+    Returns
-+    -------
-+    state: :class: qutip.Qobj
-+        The GHZ state density matrix in the requested basis.
-+    """
-+    if basis == "uncoupled":
-+        return _uncoupled_ghz(N)
-+    nds = _num_dicke_states(N)
-+    rho = dok_matrix((nds, nds), dtype=np.complex128)
-+    rho[0, 0] = 1 / 2
-+    rho[N, N] = 1 / 2
-+    rho[N, 0] = 1 / 2
-+    rho[0, N] = 1 / 2
-+    return Qobj(rho)
-+
-+
-+def ground(N, basis="dicke"):
-+    """
-+    Generate the density matrix of the ground state.
-+
-+    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
-+    `basis` is "uncoupled" then it generates the state in a
-+    :math:`2^N`-dimensional Hilbert space.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    basis: str
-+        The basis to use. Either "dicke" or "uncoupled"
-+
-+    Returns
-+    -------
-+    state: :class: qutip.Qobj
-+        The ground state density matrix in the requested basis.
-+    """
-+    if basis == "uncoupled":
-+        state = _uncoupled_ground(N)
-+        return state
-+    nds = _num_dicke_states(N)
-+    rho = dok_matrix((nds, nds), dtype=np.complex128)
-+    rho[N, N] = 1
-+    return Qobj(rho)
-+
-+
-+def identity_uncoupled(N):
-+    """
-+    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
-+
-+    The identity matrix is formed from the tensor product of N TLSs.
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    Returns
-+    -------
-+    identity: :class: qutip.Qobj
-+        The identity matrix.
-+    """
-+    N = int(N)
-+    rho = np.zeros((2 ** N, 2 ** N))
-+    for i in range(0, 2 ** N):
-+        rho[i, i] = 1
-+    spin_dim = [2 for i in range(0, N)]
-+    spins_dims = list((spin_dim, spin_dim))
-+    identity = Qobj(rho, dims=spins_dims)
-+    return identity
-+
-+
-+def block_matrix(N, elements="ones"):
-+    """Construct the block-diagonal matrix for the Dicke basis.
-+
-+    Parameters
-+    ----------
-+    N : int
-+        Number of two-level systems.
-+    elements : str {'ones' (default),'degeneracy'}
-+
-+    Returns
-+    -------
-+    block_matr : ndarray
-+        A 2D block-diagonal matrix with dimension (nds,nds),
-+        where nds is the number of Dicke states for N two-level
-+        systems. Filled with ones or the value of degeneracy
-+        at each matrix element.
-+    """
-+    # create a list with the sizes of the blocks, in order
-+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-+    blocks_list = [
-+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-+        for i in range(blocks_dimensions)
-+    ]
-+    blocks_list = np.flip(blocks_list, 0)
-+    # create a list with each block matrix as element
-+    square_blocks = []
-+    k = 0
-+    for i in blocks_list:
-+        if elements == "ones":
-+            square_blocks.append(np.ones((i, i)))
-+        elif elements == "degeneracy":
-+            j = N / 2 - k
-+            dj = state_degeneracy(N, j)
-+            square_blocks.append(dj * np.ones((i, i)))
-+        k = k + 1
-+    return block_diag(square_blocks)
-+
-+
-+# ============================================================================
-+# Adding a faster version to make a Permutational Invariant matrix
-+# ============================================================================
-+def tau_column(tau, k, j):
-+    """
-+    Determine the column index for the non-zero elements of the matrix for a
-+    particular row `k` and the value of `j` from the Dicke space.
-+
-+    Parameters
-+    ----------
-+    tau: str
-+        The tau function to check for this `k` and `j`.
-+
-+    k: int
-+        The row of the matrix M for which the non zero elements have
-+        to be calculated.
-+
-+    j: float
-+        The value of `j` for this row.
-+    """
-+    # In the notes, we indexed from k = 1, here we do it from k = 0
-+    k = k + 1
-+    mapping = {
-+        "tau3": k - (2 * j + 3),
-+        "tau2": k - 1,
-+        "tau4": k + (2 * j - 1),
-+        "tau5": k - (2 * j + 2),
-+        "tau1": k,
-+        "tau6": k + (2 * j),
-+        "tau7": k - (2 * j + 1),
-+        "tau8": k + 1,
-+        "tau9": k + (2 * j + 1),
-+    }
-+    # we need to decrement k again as indexing is from 0
-+    return int(mapping[tau] - 1)
-+
-+
-+class Pim(object):
-+    """
-+    The Permutation Invariant Matrix class.
-+
-+    Initialize the class with the parameters for generating a Permutation
-+    Invariant matrix which evolves a given diagonal initial state `p` as:
-+
-+                                dp/dt = Mp
-+
-+    Parameters
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+
-+    Attributes
-+    ----------
-+    N: int
-+        The number of two-level systems.
-+
-+    emission: float
-+        Incoherent emission coefficient (also nonradiative emission).
-+        default: 0.0
-+
-+    dephasing: float
-+        Local dephasing coefficient.
-+        default: 0.0
-+
-+    pumping: float
-+        Incoherent pumping coefficient.
-+        default: 0.0
-+
-+    collective_emission: float
-+        Collective (superradiant) emmission coefficient.
-+        default: 0.0
-+
-+    collective_dephasing: float
-+        Collective dephasing coefficient.
-+        default: 0.0
-+
-+    collective_pumping: float
-+        Collective pumping coefficient.
-+        default: 0.0
-+
-+    M: dict
-+        A nested dictionary of the structure {row: {col: val}} which holds
-+        non zero elements of the matrix M
-+    """
-+
-+    def __init__(
-+        self,
-+        N,
-+        emission=0.0,
-+        dephasing=0,
-+        pumping=0,
-+        collective_emission=0,
-+        collective_pumping=0,
-+        collective_dephasing=0,
-+    ):
-+        self.N = N
-+        self.emission = emission
-+        self.dephasing = dephasing
-+        self.pumping = pumping
-+        self.collective_pumping = collective_pumping
-+        self.collective_dephasing = collective_dephasing
-+        self.collective_emission = collective_emission
-+        self.M = {}
-+
-+    def isdicke(self, dicke_row, dicke_col):
-+        """
-+        Check if an element in a matrix is a valid element in the Dicke space.
-+        Dicke row: j value index. Dicke column: m value index.
-+        The function returns True if the element exists in the Dicke space and
-+        False otherwise.
-+
-+        Parameters
-+        ----------
-+        dicke_row, dicke_col : int
-+            Index of the element in Dicke space which needs to be checked
-+        """
-+        rows = self.N + 1
-+        cols = 0
-+
-+        if (self.N % 2) == 0:
-+            cols = int(self.N / 2 + 1)
-+        else:
-+            cols = int(self.N / 2 + 1 / 2)
-+        if (dicke_row > rows) or (dicke_row < 0):
-+            return False
-+        if (dicke_col > cols) or (dicke_col < 0):
-+            return False
-+        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
-+            return False
-+        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
-+            return False
-+        else:
-+            return True
-+
-+    def tau_valid(self, dicke_row, dicke_col):
-+        """
-+        Find the Tau functions which are valid for this value of (dicke_row,
-+        dicke_col) given the number of TLS. This calculates the valid tau
-+        values and reurns a dictionary specifying the tau function name and
-+        the value.
-+
-+        Parameters
-+        ----------
-+        dicke_row, dicke_col : int
-+            Index of the element in Dicke space which needs to be checked.
-+
-+        Returns
-+        -------
-+        taus: dict
-+            A dictionary of key, val as {tau: value} consisting of the valid
-+            taus for this row and column of the Dicke space element.
-+        """
-+        tau_functions = [
-+            self.tau3,
-+            self.tau2,
-+            self.tau4,
-+            self.tau5,
-+            self.tau1,
-+            self.tau6,
-+            self.tau7,
-+            self.tau8,
-+            self.tau9,
-+        ]
-+        N = self.N
-+        if self.isdicke(dicke_row, dicke_col) is False:
-+            return False
-+        # The 3x3 sub matrix surrounding the Dicke space element to
-+        # run the tau functions
-+        indices = [
-+            (dicke_row + x, dicke_col + y)
-+            for x in range(-1, 2)
-+            for y in range(-1, 2)
-+        ]
-+        taus = {}
-+        for idx, tau in zip(indices, tau_functions):
-+            if self.isdicke(idx[0], idx[1]):
-+                j, m = self.calculate_j_m(idx[0], idx[1])
-+                taus[tau.__name__] = tau(j, m)
-+        return taus
-+
-+    def calculate_j_m(self, dicke_row, dicke_col):
-+        """
-+        Get the value of j and m for the particular Dicke space element.
-+
-+        Parameters
-+        ----------
-+        dicke_row, dicke_col: int
-+            The row and column from the Dicke space matrix
-+
-+        Returns
-+        -------
-+        j, m: float
-+            The j and m values.
-+        """
-+        N = self.N
-+        j = N / 2 - dicke_col
-+        m = N / 2 - dicke_row
-+        return (j, m)
-+
-+    def calculate_k(self, dicke_row, dicke_col):
-+        """
-+        Get k value from the current row and column element in the Dicke space.
-+
-+        Parameters
-+        ----------
-+        dicke_row, dicke_col: int
-+            The row and column from the Dicke space matrix.
-+        Returns
-+        -------
-+        k: int
-+            The row index for the matrix M for given Dicke space
-+            element.
-+        """
-+        N = self.N
-+        if dicke_row == 0:
-+            k = dicke_col
-+        else:
-+            k = int(
-+                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
-+                + (dicke_row - (dicke_col))
-+            )
-+        return k
-+
-+    def coefficient_matrix(self):
-+        """
-+        Generate the matrix M governing the dynamics for diagonal cases.
-+
-+        If the initial density matrix and the Hamiltonian is diagonal, the
-+        evolution of the system is given by the simple ODE: dp/dt = Mp.
-+        """
-+        N = self.N
-+        nds = num_dicke_states(N)
-+        rows = self.N + 1
-+        cols = 0
-+
-+        sparse_M = lil_matrix((nds, nds), dtype=float)
-+        if (self.N % 2) == 0:
-+            cols = int(self.N / 2 + 1)
-+        else:
-+            cols = int(self.N / 2 + 1 / 2)
-+        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
-+            if self.isdicke(dicke_row, dicke_col):
-+                k = int(self.calculate_k(dicke_row, dicke_col))
-+                row = {}
-+                taus = self.tau_valid(dicke_row, dicke_col)
-+                for tau in taus:
-+                    j, m = self.calculate_j_m(dicke_row, dicke_col)
-+                    current_col = tau_column(tau, k, j)
-+                    sparse_M[k, int(current_col)] = taus[tau]
-+        return sparse_M.tocsr()
-+
-+    def solve(self, rho0, tlist, options=None):
-+        """
-+        Solve the ODE for the evolution of diagonal states and Hamiltonians.
-+        """
-+        if options is None:
-+            options = SolverOptions()
-+        output = Result()
-+        output.solver = "pisolve"
-+        output.times = tlist
-+        output.states = []
-+        output.states.append(Qobj(rho0))
-+        rhs_generate = lambda y, tt, M: M.dot(y)
-+        rho0_flat = np.diag(np.real(rho0.full()))
-+        L = self.coefficient_matrix()
-+        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
-+        for r in rho_t[1:]:
-+            diag = np.diag(r)
-+            output.states.append(Qobj(diag))
-+        return output
-+
-+    def tau1(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j, m, m).
-+        """
-+        yS = self.collective_emission
-+        yL = self.emission
-+        yD = self.dephasing
-+        yP = self.pumping
-+        yCP = self.collective_pumping
-+        N = float(self.N)
-+        spontaneous = yS * (1 + j - m) * (j + m)
-+        losses = yL * (N / 2 + m)
-+        pump = yP * (N / 2 - m)
-+        collective_pump = yCP * (1 + j + m) * (j - m)
-+        if j == 0:
-+            dephase = yD * N / 4
-+        else:
-+            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
-+        t1 = spontaneous + losses + pump + dephase + collective_pump
-+        return -t1
-+
-+    def tau2(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j, m+1, m+1).
-+        """
-+        yS = self.collective_emission
-+        yL = self.emission
-+        N = float(self.N)
-+        spontaneous = yS * (1 + j - m) * (j + m)
-+        losses = yL * (
-+            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
-+        )
-+        t2 = spontaneous + losses
-+        return t2
-+
-+    def tau3(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
-+        """
-+        yL = self.emission
-+        N = float(self.N)
-+        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
-+        den = 2 * j * (2 * j + 1)
-+        t3 = yL * (num / den)
-+        return t3
-+
-+    def tau4(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
-+        """
-+        yL = self.emission
-+        N = float(self.N)
-+        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
-+        den = 2 * (j + 1) * (2 * j + 1)
-+        t4 = yL * (num / den)
-+        return t4
-+
-+    def tau5(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j+1, m, m).
-+        """
-+        yD = self.dephasing
-+        N = float(self.N)
-+        num = (j - m) * (j + m) * (j + 1 + N / 2)
-+        den = 2 * j * (2 * j + 1)
-+        t5 = yD * (num / den)
-+        return t5
-+
-+    def tau6(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j-1, m, m).
-+        """
-+        yD = self.dephasing
-+        N = float(self.N)
-+        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
-+        den = 2 * (j + 1) * (2 * j + 1)
-+        t6 = yD * (num / den)
-+        return t6
-+
-+    def tau7(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
-+        """
-+        yP = self.pumping
-+        N = float(self.N)
-+        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
-+        den = 2 * j * (2 * j + 1)
-+        t7 = yP * (float(num) / den)
-+        return t7
-+
-+    def tau8(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j, m-1, m-1).
-+        """
-+        yP = self.pumping
-+        yCP = self.collective_pumping
-+        N = float(self.N)
-+
-+        num = (1 + N / 2) * (j - m) * (j + m + 1)
-+        den = 2 * j * (j + 1)
-+        pump = yP * (float(num) / den)
-+        collective_pump = yCP * (j - m) * (j + m + 1)
-+        t8 = pump + collective_pump
-+        return t8
-+
-+    def tau9(self, j, m):
-+        """
-+        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
-+        """
-+        yP = self.pumping
-+        N = float(self.N)
-+        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
-+        den = 2 * (j + 1) * (2 * j + 1)
-+        t9 = yP * (float(num) / den)
-+        return t9
-diff --git a/qutip/solve/rcsolve.py b/qutip/solve/rcsolve.py
-index b357bc6e..7352b978 100644
---- a/qutip/solve/rcsolve.py
-+++ b/qutip/solve/rcsolve.py
-@@ -1,127 +1,127 @@
--"""
--This module provides exact solvers for a system-bath setup using the
--reaction coordinate method.
--"""
--
--# Author: Neill Lambert, Anubhav Vardhan
--# Contact: nwlambert@gmail.com
--
--__all__ = ['rcsolve']
--
--import warnings
--import numpy as np
--import scipy.sparse as sp
--from numpy import matrix
--from numpy import linalg
--from .. import (
--    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
--    sigmaz, basis, qeye, mesolve
--)
--
--
--def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
--            options=None):
--    """
--    Function to solve for an open quantum system using the
--    reaction coordinate (RC) model.
--
--    Parameters
--    ----------
--    Hsys: Qobj
--        The system hamiltonian.
--    psi0: Qobj
--        Initial state of the system.
--    tlist: List.
--        Time over which system evolves.
--    e_ops: list of :class:`qutip.Qobj` / callback function single
--        Single operator or list of operators for which to evaluate
--        expectation values.
--    Q: Qobj
--        The coupling between system and bath.
--    wc: Float
--        Cutoff frequency.
--    alpha: Float
--        Coupling strength.
--    N: Integer
--        Number of cavity fock states.
--    w_th: Float
--        Temperature.
--    sparse: Boolean
--        Optional argument to call the sparse eigenstates solver if needed.
--    options : dict
--        Options for the solver.
--
--    Returns
--    -------
--    output: Result
--        System evolution.
--    """
--    if options is None:
--        options = {}
--
--    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
--    deltaE = dot_energy[1] - dot_energy[0]
--    if (w_th < deltaE/2):
--        warnings.warn("Given w_th might not provide accurate results")
--    gamma = deltaE / (2 * np.pi * wc)
--    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
--    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
--    nb = (1 / (np.exp(wa/w_th) - 1))
--
--    # Reaction coordinate hamiltonian/operators
--
--    dimensions = Q.dims
--    a = tensor(destroy(N), qeye(dimensions[1]))
--    unit = tensor(qeye(N), qeye(dimensions[1]))
--    Nmax = N * dimensions[1][0]
--    Q_exp = tensor(qeye(N), Q)
--    Hsys_exp = tensor(qeye(N), Hsys)
--    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
--
--    na = a.dag() * a
--    xa = a.dag() + a
--
--    # decoupled Hamiltonian
--    H0 = wa * a.dag() * a + Hsys_exp
--    # interaction
--    H1 = (g * (a.dag() + a) * Q_exp)
--    H = H0 + H1
--    L = 0
--    PsipreEta = 0
--    PsipreX = 0
--
--    all_energy, all_state = H.eigenstates(sparse=sparse)
--    Apre = spre((a + a.dag()))
--    Apost = spost(a + a.dag())
--    for j in range(Nmax):
--        for k in range(Nmax):
--            A = xa.matrix_element(all_state[j].dag(), all_state[k])
--            delE = (all_energy[j] - all_energy[k])
--            if abs(A) > 0.0:
--                if abs(delE) > 0.0:
--                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
--                         * (np.cosh((all_energy[j] - all_energy[k]) /
--                            (2 * w_th))
--                         / (np.sinh((all_energy[j] - all_energy[k]) /
--                            (2 * w_th)))) * A)
--                    eta = (0.5 * np.pi * gamma *
--                           (all_energy[j] - all_energy[k]) * A)
--                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
--                    PsipreEta = PsipreEta + (eta * all_state[j]
--                                             * all_state[k].dag())
--                else:
--                    X = 0.5 * np.pi * gamma * A * 2 * w_th
--                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
--
--    A = a + a.dag()
--    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
--         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
--         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
--         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
--
--    # Setup the operators and the Hamiltonian and the master equation
--    # and solve for time steps in tlist
--    rho0 = (tensor(thermal_dm(N, nb), psi0))
--    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
--
--    return output
-+"""
-+This module provides exact solvers for a system-bath setup using the
-+reaction coordinate method.
-+"""
-+
-+# Author: Neill Lambert, Anubhav Vardhan
-+# Contact: nwlambert@gmail.com
-+
-+__all__ = ['rcsolve']
-+
-+import warnings
-+import numpy as np
-+import scipy.sparse as sp
-+from numpy import matrix
-+from numpy import linalg
-+from .. import (
-+    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
-+    sigmaz, basis, qeye, mesolve
-+)
-+
-+
-+def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
-+            options=None):
-+    """
-+    Function to solve for an open quantum system using the
-+    reaction coordinate (RC) model.
-+
-+    Parameters
-+    ----------
-+    Hsys: Qobj
-+        The system hamiltonian.
-+    psi0: Qobj
-+        Initial state of the system.
-+    tlist: List.
-+        Time over which system evolves.
-+    e_ops: list of :class:`qutip.Qobj` / callback function single
-+        Single operator or list of operators for which to evaluate
-+        expectation values.
-+    Q: Qobj
-+        The coupling between system and bath.
-+    wc: Float
-+        Cutoff frequency.
-+    alpha: Float
-+        Coupling strength.
-+    N: Integer
-+        Number of cavity fock states.
-+    w_th: Float
-+        Temperature.
-+    sparse: Boolean
-+        Optional argument to call the sparse eigenstates solver if needed.
-+    options : dict
-+        Options for the solver.
-+
-+    Returns
-+    -------
-+    output: Result
-+        System evolution.
-+    """
-+    if options is None:
-+        options = {}
-+
-+    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
-+    deltaE = dot_energy[1] - dot_energy[0]
-+    if (w_th < deltaE/2):
-+        warnings.warn("Given w_th might not provide accurate results")
-+    gamma = deltaE / (2 * np.pi * wc)
-+    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
-+    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
-+    nb = (1 / (np.exp(wa/w_th) - 1))
-+
-+    # Reaction coordinate hamiltonian/operators
-+
-+    dimensions = Q.dims
-+    a = tensor(destroy(N), qeye(dimensions[1]))
-+    unit = tensor(qeye(N), qeye(dimensions[1]))
-+    Nmax = N * dimensions[1][0]
-+    Q_exp = tensor(qeye(N), Q)
-+    Hsys_exp = tensor(qeye(N), Hsys)
-+    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
-+
-+    na = a.dag() * a
-+    xa = a.dag() + a
-+
-+    # decoupled Hamiltonian
-+    H0 = wa * a.dag() * a + Hsys_exp
-+    # interaction
-+    H1 = (g * (a.dag() + a) * Q_exp)
-+    H = H0 + H1
-+    L = 0
-+    PsipreEta = 0
-+    PsipreX = 0
-+
-+    all_energy, all_state = H.eigenstates(sparse=sparse)
-+    Apre = spre((a + a.dag()))
-+    Apost = spost(a + a.dag())
-+    for j in range(Nmax):
-+        for k in range(Nmax):
-+            A = xa.matrix_element(all_state[j].dag(), all_state[k])
-+            delE = (all_energy[j] - all_energy[k])
-+            if abs(A) > 0.0:
-+                if abs(delE) > 0.0:
-+                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
-+                         * (np.cosh((all_energy[j] - all_energy[k]) /
-+                            (2 * w_th))
-+                         / (np.sinh((all_energy[j] - all_energy[k]) /
-+                            (2 * w_th)))) * A)
-+                    eta = (0.5 * np.pi * gamma *
-+                           (all_energy[j] - all_energy[k]) * A)
-+                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-+                    PsipreEta = PsipreEta + (eta * all_state[j]
-+                                             * all_state[k].dag())
-+                else:
-+                    X = 0.5 * np.pi * gamma * A * 2 * w_th
-+                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-+
-+    A = a + a.dag()
-+    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
-+         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
-+         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
-+         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
-+
-+    # Setup the operators and the Hamiltonian and the master equation
-+    # and solve for time steps in tlist
-+    rho0 = (tensor(thermal_dm(N, nb), psi0))
-+    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
-+
-+    return output
-diff --git a/qutip/solve/solver.py b/qutip/solve/solver.py
-index 08a53fb6..e466beb9 100644
---- a/qutip/solve/solver.py
-+++ b/qutip/solve/solver.py
-@@ -1,922 +1,922 @@
--from __future__ import print_function
--
--__all__ = ['SolverOptions', 'ExpectOps']
--
--import os
--import sys
--import warnings
--import datetime
--import numpy as np
--from collections import OrderedDict
--from types import FunctionType, BuiltinFunctionType
--
--from .. import __version__, Qobj, QobjEvo
--from .optionsclass import optionsclass
--from ..core import data as _data
--
--solver_safe = {}
--
--
--class SolverSystem():
--    pass
--
--
--class ExpectOps:
--    """
--        Contain and compute expectation values
--    """
--    def __init__(self, e_ops=[], super_=False):
--        # take care of expectation values, if any
--        self.isfunc = False
--        self.e_ops_dict = False
--        self.raw_e_ops = e_ops
--        self.e_ops_qoevo = []
--        self.e_num = 0
--        self.e_ops_isherm = []
--
--        if isinstance(e_ops, (Qobj, QobjEvo)):
--            e_ops = [e_ops]
--        elif isinstance(e_ops, dict):
--            self.e_ops_dict = e_ops
--            e_ops = [e for e in e_ops.values()]
--
--        self.e_ops = e_ops
--        if isinstance(e_ops, list):
--            self.e_num = len(e_ops)
--            self.e_ops_isherm = [e.isherm for e in e_ops]
--            if not super_:
--                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
--                                            dtype=object)
--            else:
--                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
--                                            dtype=object)
--        elif callable(e_ops):
--            self.isfunc = True
--            self.e_num = 1
--
--    def init(self, tlist):
--        self.tlist = tlist
--        if self.isfunc:
--            self.raw_out = []
--        else:
--            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
--
--    def check_dims(self, dims):
--        if not self.isfunc:
--            for op in self.e_ops_qoevo:
--                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
--                    raise TypeError(f"e_ops dims ({op.dims}) are not "
--                                    f"compatible with the system's ({dims})")
--
--    def copy(self):
--        out = ExpectOps.__new__(ExpectOps)
--        out.isfunc = self.isfunc
--        out.e_ops_dict = self.e_ops_dict
--        out.raw_e_ops = self.raw_e_ops
--        out.e_ops = self.e_ops
--        out.e_num = self.e_num
--        out.e_ops_isherm = self.e_ops_isherm
--        out.e_ops_qoevo = self.e_ops_qoevo
--        return out
--
--    def step(self, iter_, state):
--        if self.isfunc:
--            self.raw_out.append(self.e_ops(t, state))
--        else:
--            state = _data.dense.fast_from_numpy(state)
--            t = self.tlist[iter_]
--            for ii in range(self.e_num):
--                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
--                    self.raw_out[ii, iter_] = \
--                        self.e_ops_qoevo[ii].expect_data(t, state)
--                elif callable(self.e_ops_qoevo[ii]):
--                    self.raw_out[ii, iter_] = \
--                        self.e_ops_qoevo[ii](t, state)
--
--    def finish(self):
--        if self.isfunc:
--            result = self.raw_out
--        else:
--            result = []
--            for ii in range(self.e_num):
--                if self.e_ops_isherm[ii]:
--                    result.append(np.real(self.raw_out[ii, :]))
--                else:
--                    result.append(self.raw_out[ii, :])
--            if self.e_ops_dict:
--                result = {e: result[n]
--                          for n, e in enumerate(self.e_ops_dict.keys())}
--        return result
--
--    def __eq__(self, other):
--        if isinstance(other, ExpectOps):
--            other = other.raw_e_ops
--        return self.raw_e_ops == other
--
--    def __ne__(self, other):
--        return not (self == other)
--
--    def __bool__(self):
--        return bool(self.e_num)
--
--
--@optionsclass("solver")
--class SolverOptions:
--    """
--    Class of options for evolution solvers such as :func:`qutip.mesolve` and
--    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
--    constructor::
--
--        opts = SolverOptions(order=10, ...)
--
--    or by changing the class attributes after creation::
--
--        opts = SolverOptions()
--        opts.order = 10
--
--    Returns options class to be used as options in evolution solvers.
--
--    The default can be changed by::
--
--        qutip.settings.solver['order'] = 10
--
--    Supported options:
--
--        atol : float {1e-8}
--            Absolute tolerance.
--        rtol : float {1e-6}
--            Relative tolerance.
--        method : str {'adams','bdf'}
--            Integration method.
--        order : int {12}
--            Order of integrator (<=12 'adams', <=5 'bdf')
--        nsteps : int {2500}
--            Max. number of internal steps/call.
--        first_step : float {0}
--            Size of initial step (0 = automatic).
--        min_step : float {0}
--            Minimum step size (0 = automatic).
--        max_step : float {0}
--            Maximum step size (0 = automatic)
--        tidy : bool {True,False}
--            Tidyup Hamiltonian and initial state by removing small terms.
--        average_states : bool {False}
--            Average states values over trajectories in stochastic solvers.
--        average_expect : bool {True}
--            Average expectation values over trajectories for stochastic solvers.
--        ntraj : int {500}
--            Number of trajectories in stochastic solvers.
--        store_final_state : bool {False, True}
--            Whether or not to store the final state of the evolution in the
--            result class.
--        store_states : bool {False, True}
--            Whether or not to store the state vectors or density matrices in the
--            result class, even if expectation values operators are given. If no
--            expectation are provided, then states are stored by default and this
--            option has no effect.
--    """
--    options = {
--        # Absolute tolerance (default = 1e-8)
--        "atol": 1e-8,
--        # Relative tolerance (default = 1e-6)
--        "rtol": 1e-6,
--        # Integration method (default = 'adams', for stiff 'bdf')
--        "method": 'adams',
--        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
--        "order": 12,
--        # Max. number of internal steps/call
--        "nsteps": 1000,
--        # Size of initial step (0 = determined by solver)
--        "first_step": 0,
--        # Max step size (0 = determined by solver)
--        "max_step": 0,
--        # Minimal step size (0 = determined by solver)
--        "min_step": 0,
--        # Average expectation values over trajectories (default = True)
--        "average_expect": True,
--        # average expectation values
--        "average_states": False,
--        # tidyup Hamiltonian before calculation (default = True)
--        "tidy": True,
--        # Number of trajectories (default = 500)
--        "ntraj": 500,
--        "gui": False,
--        # store final state?
--        "store_final_state": False,
--        # store states even if expectation operators are given?
--        "store_states": False,
--        # average mcsolver density matricies assuming steady state evolution
--        "steady_state_average": False,
--        # Normalize output of solvers
--        # (turned off for batch unitary propagator mode)
--        "normalize_output": True
--    }
--
--
--@optionsclass("mcsolve", SolverOptions)
--class McOptions:
--    """
--    Class of options for evolution solvers such as :func:`qutip.mesolve` and
--    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
--    constructor::
--
--        opts = SolverOptions(norm_tol=1e-3, ...)
--
--    or by changing the class attributes after creation::
--
--        opts = SolverOptions()
--        opts.['norm_tol'] = 1e-3
--
--    Returns options class to be used as options in evolution solvers.
--
--    The default can be changed by::
--
--        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
--
--    Options
--    -------
--
--    norm_tol : float {1e-4}
--        Tolerance used when finding wavefunction norm in mcsolve.
--    norm_t_tol : float {1e-6}
--        Tolerance used when finding wavefunction time in mcsolve.
--    norm_steps : int {5}
--        Max. number of steps used to find wavefunction norm to within norm_tol
--        in mcsolve.
--    mc_corr_eps : float {1e-10}
--        Arbitrarily small value for eliminating any divide-by-zero errors in
--        correlation calculations when using mcsolve.
--    """
--    options = {
--        # Tolerance for wavefunction norm (mcsolve only)
--        "norm_tol": 1e-4,
--        # Tolerance for collapse time precision (mcsolve only)
--        "norm_t_tol": 1e-6,
--        # Max. number of steps taken to find wavefunction norm to within
--        # norm_tol (mcsolve only)
--        "norm_steps": 5,
--        # small value in mc solver for computing correlations
--        "mc_corr_eps": 1e-10,
--    }
--
--
--class Result():
--    """Class for storing simulation results from any of the dynamics solvers.
--
--    Attributes
--    ----------
--
--    solver : str
--        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
--    times : list/array
--        Times at which simulation data was collected.
--    expect : list/array
--        Expectation values (if requested) for simulation.
--    states : array
--        State of the simulation (density matrix or ket) evaluated at ``times``.
--    num_expect : int
--        Number of expectation value operators in simulation.
--    num_collapse : int
--        Number of collapse operators in simualation.
--    ntraj : int/list
--        Number of trajectories (for stochastic solvers). A list indicates
--        that averaging of expectation values was done over a subset of total
--        number of trajectories.
--    col_times : list
--        Times at which state collpase occurred. Only for Monte Carlo solver.
--    col_which : list
--        Which collapse operator was responsible for each collapse in
--        ``col_times``. Only for Monte Carlo solver.
--
--    """
--    def __init__(self):
--        self.solver = None
--        self.times = None
--        self.states = []
--        self.expect = []
--        self.num_expect = 0
--        self.num_collapse = 0
--        self.ntraj = None
--        self.seeds = None
--        self.col_times = None
--        self.col_which = None
--
--    def __str__(self):
--        s = "Result object "
--        if self.solver:
--            s += "with " + self.solver + " data.\n"
--        else:
--            s += "missing solver information.\n"
--        s += "-" * (len(s) - 1) + "\n"
--        if self.states is not None and len(self.states) > 0:
--            s += "states = True\n"
--        elif self.expect is not None and len(self.expect) > 0:
--            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
--        else:
--            s += "states = True, expect = True\n" + \
--                "num_expect = " + str(self.num_expect) + ", "
--        s += "num_collapse = " + str(self.num_collapse)
--        if self.solver == 'mcsolve':
--            s += ", ntraj = " + str(self.ntraj)
--        return s
--
--    def __repr__(self):
--        return self.__str__()
--
--    def __getstate__(self):
--        # defines what happens when Qobj object gets pickled
--        self.__dict__.update({'qutip_version': __version__[:5]})
--        return self.__dict__
--
--    def __setstate__(self, state):
--        # defines what happens when loading a pickled Qobj
--        if 'qutip_version' in state.keys():
--            del state['qutip_version']
--        (self.__dict__).update(state)
--
--
--# %%%%%%%%%%% remove ?
--class SolverConfiguration():
--    def __init__(self):
--
--        self.cgen_num = 0
--
--        self.reset()
--
--    def reset(self):
--        # General stuff
--        self.tlist = None       # evaluations times
--        self.ntraj = None       # number / list of trajectories
--        self.options = None     # options for solvers
--        self.norm_tol = None    # tolerance for wavefunction norm
--        self.norm_steps = None  # max. number of steps to take in finding
--        # Initial state stuff
--        self.psi0 = None        # initial state
--        self.psi0_dims = None   # initial state dims
--        self.psi0_shape = None  # initial state shape
--
--        # flags for setting time-dependence, collapse ops, and number of times
--        # codegen has been run
--        self.cflag = 0     # Flag signaling collapse operators
--        self.tflag = 0     # Flag signaling time-dependent problem
--
--        self.soft_reset()
--
--    def soft_reset(self):
--        # Hamiltonian stuff
--        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
--        self.h_tdterms = []  # List of td strs and funcs
--        self.h_data = None   # List of sparse matrix data
--        self.h_ind = None    # List of sparse matrix indices
--        self.h_ptr = None    # List of sparse matrix ptrs
--
--        # Expectation operator stuff
--        self.e_num = 0        # number of expect ops
--        self.e_ops_data = []  # expect op data
--        self.e_ops_ind = []   # expect op indices
--        self.e_ops_ptr = []   # expect op indptrs
--        self.e_ops_isherm = []  # expect op isherm
--
--        # Collapse operator stuff
--        self.c_num = 0          # number of collapse ops
--        self.c_const_inds = []  # indicies of constant collapse operators
--        self.c_td_inds = []     # indicies of time-dependent collapse operators
--        self.c_ops_data = []    # collapse op data
--        self.c_ops_ind = []     # collapse op indices
--        self.c_ops_ptr = []     # collapse op indptrs
--        self.c_args = []        # store args for time-dependent collapse func.
--
--        # Norm collapse operator stuff
--        self.n_ops_data = []  # norm collapse op data
--        self.n_ops_ind = []   # norm collapse op indices
--        self.n_ops_ptr = []   # norm collapse op indptrs
--
--        # holds executable strings for time-dependent collapse evaluation
--        self.col_expect_code = None
--        self.col_spmv_code = None
--
--        # hold stuff for function list based time dependence
--        self.h_td_inds = []
--        self.h_td_data = []
--        self.h_td_ind = []
--        self.h_td_ptr = []
--        self.h_funcs = None
--        self.h_func_args = None
--        self.c_funcs = None
--        self.c_func_args = None
--
--        # time-dependent (TD) function stuff
--        self.tdfunc = None     # Placeholder for TD RHS function.
--        self.tdname = None     # Name of td .pyx file
--        self.colspmv = None    # Placeholder for TD col-spmv function.
--        self.colexpect = None  # Placeholder for TD col_expect function.
--        self.string = None     # Holds string of variables passed to td solver
--
--
--def _format_time(t, tt=None, ttt=None):
--    time_str = str(datetime.timedelta(seconds=t))
--    if tt is not None and ttt is not None:
--        sect_percent = 100*t/tt
--        solve_percent = 100*t/ttt
--        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
--                                            sect_percent, solve_percent)
--    elif tt is not None:
--        sect_percent = 100*t/tt
--        time_str += " ({:03.2f}% section)".format(sect_percent)
--
--    elif ttt is not None:
--        solve_percent = 100*t/ttt
--        time_str += " ({:03.2f}% total)".format(solve_percent)
--
--    return time_str
--
--
--class Stats:
--    """
--    Statistical information on the solver performance
--    Statistics can be grouped into sections.
--    If no section names are given in the the contructor, then all statistics
--    will be added to one section 'main'
--
--    Parameters
--    ----------
--    section_names : list
--        list of keys that will be used as keys for the sections
--        These keys will also be used as names for the sections
--        The text in the output can be overidden by setting the header property
--        of the section
--        If no names are given then one section called 'main' is created
--
--    Attributes
--    ----------
--    sections : OrderedDict of _StatsSection
--        These are the sections that are created automatically on instantiation
--        or added using add_section
--
--    header : string
--        Some text that will be used as the heading in the report
--        By default there is None
--
--    total_time : float
--        Time in seconds for the solver to complete processing
--        Can be None, meaning that total timing percentages will be reported
--    """
--
--    def __init__(self, section_names=None):
--        self._def_section_name = 'main'
--        self.sections = OrderedDict()
--        self.total_time = None
--        self.header = None
--        if isinstance(section_names, list):
--            c = 0
--            for name in section_names:
--                self.sections[name] = _StatsSection(name, self)
--                if c == 0:
--                    self._def_section_name = name
--                c += 1
--
--        else:
--            self.sections[self._def_section_name] = \
--                        _StatsSection(self._def_section_name)
--
--    def _get_section(self, section):
--        if section is None:
--            return self.sections[self._def_section_name]
--        elif isinstance(section, _StatsSection):
--            return section
--        else:
--            sect = self.sections.get(section, None)
--            if sect is None:
--                raise ValueError("Unknown section {}".format(section))
--            else:
--                return sect
--
--    def add_section(self, name):
--        """
--        Add another section with the given name
--
--        Parameters
--        ----------
--        name : string
--            will be used as key for sections dict
--            will also be the header for the section
--
--        Returns
--        -------
--        section : :class:`_StatsSection`
--            The new section
--        """
--        sect = _StatsSection(name, self)
--        self.sections[name] = sect
--        return sect
--
--    def add_count(self, key, value, section=None):
--        """
--        Add value to count. If key does not already exist in section then
--        it is created with this value.
--        If key already exists it is increased by the give value
--        value is expected to be an integer
--
--        Parameters
--        ----------
--        key : string
--            key for the section.counts dictionary
--            reusing a key will result in numerical addition of value
--
--        value : int
--            Initial value of the count, or added to an existing count
--
--        section : string or :class:`_StatsSection`
--            Section which to add the count to.
--            If None given, the default (first) section will be used
--        """
--
--        self._get_section(section).add_count(key, value)
--
--    def add_timing(self, key, value, section=None):
--        """
--        Add value to timing. If key does not already exist in section then
--        it is created with this value.
--        If key already exists it is increased by the give value
--        value is expected to be a float, and given in seconds.
--
--        Parameters
--        ----------
--        key : string
--            key for the section.timings dictionary
--            reusing a key will result in numerical addition of value
--
--        value : int
--            Initial value of the timing, or added to an existing timing
--
--        section: string or `class` : _StatsSection
--            Section which to add the timing to.
--            If None given, the default (first) section will be used
--        """
--        self._get_section(section).add_timing(key, value)
--
--    def add_message(self, key, value, section=None, sep=";"):
--        """
--        Add value to message. If key does not already exist in section then
--        it is created with this value.
--        If key already exists the value is added to the message
--        The value will be converted to a string
--
--        Parameters
--        ----------
--        key : string
--            key for the section.messages dictionary
--            reusing a key will result in concatenation of value
--
--        value : int
--            Initial value of the message, or added to an existing message
--
--        sep : string
--            Message will be prefixed with this string when concatenating
--
--        section: string or `class` : _StatsSection
--            Section which to add the message to.
--            If None given, the default (first) section will be used
--        """
--        self._get_section(section).add_message(key, value, sep=sep)
--
--    def set_total_time(self, value, section=None):
--        """
--        Sets the total time for the complete solve or for a specific section
--        value is expected to be a float, and given in seconds
--
--        Parameters
--        ----------
--        value : float
--            Time in seconds to complete the solver section
--
--        section : string or `class` : _StatsSection
--            Section which to set the total_time for
--            If None given, the total_time for complete solve is set
--        """
--        if not isinstance(value, float):
--            try:
--                value = float(value)
--            except:
--                raise TypeError("value is expected to be a float")
--
--        if section is None:
--            self.total_time = value
--        else:
--            sect = self._get_section(section)
--            sect.total_time = value
--
--    def report(self, output=sys.stdout):
--        """
--        Report the counts, timings and messages from the sections.
--        Sections are reported in the order that the names were supplied
--        in the constructor.
--        The counts, timings and messages are reported in the order that they
--        are added to the sections
--        The output can be written to anything that supports a write method,
--        e.g. a file or the console (default)
--        The output is intended to in markdown format
--
--        Parameters
--        ----------
--        output : stream
--            file or console stream - anything that support write - where
--            the output will be written
--        """
--
--        if not hasattr(output, 'write'):
--            raise TypeError("output must have a write method")
--
--        if self.header:
--            output.write("{}\n{}\n".format(self.header,
--                                     ("="*len(self.header))))
--        for name, sect in self.sections.items():
--            sect.report(output)
--
--        if self.total_time is not None:
--            output.write("\nSummary\n-------\n")
--            output.write("{}\t solver total time\n".format(
--                                            _format_time(self.total_time)))
--
--    def clear(self):
--        """
--        Clear counts, timings and messages from all sections
--        """
--        for sect in self.sections.values():
--            sect.clear()
--        self.total_time = None
--
--
--class _StatsSection(object):
--    """
--    Not intended to be directly instantiated
--    This is the type for the SolverStats.sections values
--
--    The method parameter descriptions are the same as for those the parent
--    with the same method name
--
--    Parameters
--    ----------
--    name : string
--        key for the parent sections dictionary
--        will also be used as the header
--
--    parent : `class` :  SolverStats
--        The container for all the sections
--
--    Attributes
--    ----------
--    name : string
--        key for the parent sections dictionary
--        will also be used as the header
--
--    parent : `class` :  SolverStats
--        The container for all the sections
--
--    header : string
--        Used as heading for section in report
--
--    counts : OrderedDict
--        The integer type statistics for the stats section
--
--    timings : OrderedDict
--        The timing type statistics for the stats section
--        Expected to contain float values representing values in seconds
--
--    messages : OrderedDict
--        Text type output to be reported
--
--    total_time : float
--        Total time for processing in the section
--        Can be None, meaning that section timing percentages will be reported
--    """
--    def __init__(self, name, parent):
--        self.parent = parent
--        self.header = str(name)
--        self.name = name
--        self.counts = OrderedDict()
--        self.timings = OrderedDict()
--        self.messages = OrderedDict()
--        self.total_time = None
--
--    def add_count(self, key, value):
--        """
--        Add value to count. If key does not already exist in section then
--        it is created with this value.
--        If key already exists it is increased by the given value
--        value is expected to be an integer
--        """
--        if not isinstance(value, int):
--            try:
--                value = int(value)
--            except:
--                raise TypeError("value is expected to be an integer")
--
--        if key in self.counts:
--            self.counts[key] += value
--        else:
--            self.counts[key] = value
--
--    def add_timing(self, key, value):
--        """
--        Add value to timing. If key does not already exist in section then
--        it is created with this value.
--        If key already exists it is increased by the give value
--        value is expected to be a float, and given in seconds.
--        """
--        if not isinstance(value, float):
--            try:
--                value = float(value)
--            except:
--                raise TypeError("value is expected to be a float")
--
--        if key in self.timings:
--            self.timings[key] += value
--        else:
--            self.timings[key] = value
--
--    def add_message(self, key, value, sep=";"):
--        """
--        Add value to message. If key does not already exist in section then
--        it is created with this value.
--        If key already exists the value is added to the message
--        The value will be converted to a string
--        """
--        value = str(value)
--
--        if key in self.messages:
--            if sep is not None:
--                try:
--                    value = sep + value
--                except:
--                    TypeError("It is not possible to concatenate the value "
--                              "with the given seperator")
--            self.messages[key] += value
--        else:
--            self.messages[key] = value
--
--    def report(self, output=sys.stdout):
--        """
--        Report the counts, timings and messages for this section.
--        Note the percentage of the section and solver total times will be
--        given if the parent and or section total_time is set
--        """
--        if self.header:
--            output.write("\n{}\n{}\n".format(self.header,
--                                     ("-"*len(self.header))))
--
--        # TODO: Make the timings and counts ouput in a table format
--        #       Generally make more pretty
--
--        # Report timings
--        try:
--            ttt = self.parent.total_time
--        except:
--            ttt = None
--
--        tt = self.total_time
--
--        output.write("### Timings:\n")
--        for key, value in self.timings.items():
--            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
--            output.write(l)
--        if tt is not None:
--            output.write(" - {}\t{} total time\n".format(_format_time(tt),
--                                                     self.name))
--
--        # Report counts
--        output.write("### Counts:\n")
--        for key, value in self.counts.items():
--            l = " - {}\t{}\n".format(value, key)
--            output.write(l)
--
--        # Report messages
--        output.write("### Messages:\n")
--        for key, value in self.messages.items():
--            l = " - {}:\t{}\n".format(key, value)
--            output.write(l)
--
--
--    def clear(self):
--        """
--        Clear counts, timings and messages from this section
--        """
--        self.counts.clear()
--        self.timings.clear()
--        self.messages.clear()
--        self.total_time = None
--
--
--def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
--    # Input is std Qobj (Hamiltonian or Liouvillian)
--    if isinstance(H, Qobj):
--        Hdims = H.dims
--        Htype = H.type
--        _structure_check(Hdims, Htype, state)
--    # Input H is function
--    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
--        Hdims = H(0,args).dims
--        Htype = H(0,args).type
--        _structure_check(Hdims, Htype, state)
--    # Input is td-list
--    elif isinstance(H, list):
--        if isinstance(H[0], Qobj):
--            Hdims = H[0].dims
--            Htype = H[0].type
--        elif isinstance(H[0], list):
--            Hdims = H[0][0].dims
--            Htype = H[0][0].type
--        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
--            Hdims = H[0](0,args).dims
--            Htype = H[0](0,args).type
--        else:
--            raise Exception('Invalid td-list element.')
--        # Check all operators in list
--        for ii in range(len(H)):
--            if isinstance(H[ii], Qobj):
--                _temp_dims = H[ii].dims
--                _temp_type = H[ii].type
--            elif isinstance(H[ii], list):
--                _temp_dims = H[ii][0].dims
--                _temp_type = H[ii][0].type
--            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
--                _temp_dims = H[ii](0,args).dims
--                _temp_type = H[ii](0,args).type
--            else:
--                raise Exception('Invalid td-list element.')
--            _structure_check(_temp_dims,_temp_type,state)
--
--    else:
--        raise Exception('Invalid time-dependent format.')
--
--
--    for ii in range(len(c_ops)):
--        do_tests = True
--        if isinstance(c_ops[ii], Qobj):
--            _temp_state = c_ops[ii]
--        elif isinstance(c_ops[ii], list):
--            if isinstance(c_ops[ii][0], Qobj):
--                _temp_state = c_ops[ii][0]
--            elif isinstance(c_ops[ii][0], tuple):
--                do_tests = False
--                for kk in range(len(c_ops[ii][0])):
--                    _temp_state = c_ops[ii][0][kk]
--                    _structure_check(Hdims, Htype, _temp_state)
--        else:
--            raise Exception('Invalid td-list element.')
--        if do_tests:
--            _structure_check(Hdims, Htype, _temp_state)
--
--    if isinstance(e_ops, list):
--        for ii in range(len(e_ops)):
--            if isinstance(e_ops[ii], Qobj):
--                _temp_state = e_ops[ii]
--            elif isinstance(e_ops[ii], list):
--                _temp_state = e_ops[ii][0]
--            else:
--                raise Exception('Invalid td-list element.')
--            _structure_check(Hdims,Htype,_temp_state)
--    elif isinstance(e_ops, FunctionType):
--        pass
--    else:
--        raise Exception('Invalid e_ops specification.')
--
--
--def _structure_check(Hdims, Htype, state):
--    if state is not None:
--        # Input state is a ket vector
--        if state.type == 'ket':
--            # Input is Hamiltonian
--            if Htype == 'oper':
--                if Hdims[1] != state.dims[0]:
--                    raise Exception('Input operator and ket do not '
--                                    'share same structure.')
--            # Input is super and state is ket
--            elif Htype == 'super':
--                if Hdims[1][1] != state.dims[0]:
--                    raise Exception('Input operator and ket do not '
--                                    'share same structure.')
--            else:
--                raise Exception('Invalid input operator.')
--        # Input state is a density matrix
--        elif state.type == 'oper':
--            # Input is Hamiltonian and state is density matrix
--            if Htype == 'oper':
--                if Hdims[1] != state.dims[0]:
--                    raise Exception('Input operators do not '
--                                    'share same structure.')
--            # Input is super op. and state is density matrix
--            elif Htype == 'super':
--                if Hdims[1] != state.dims:
--                    raise Exception('Input operators do not '
--                                    'share same structure.')
--
--
--#
--# create a global instance of the SolverConfiguration class
--#
--config = SolverConfiguration()
--
--# for backwards compatibility
--# Odeoptions = Options
--# Odedata = Result
-+from __future__ import print_function
-+
-+__all__ = ['SolverOptions', 'ExpectOps']
-+
-+import os
-+import sys
-+import warnings
-+import datetime
-+import numpy as np
-+from collections import OrderedDict
-+from types import FunctionType, BuiltinFunctionType
-+
-+from .. import __version__, Qobj, QobjEvo
-+from .optionsclass import optionsclass
-+from ..core import data as _data
-+
-+solver_safe = {}
-+
-+
-+class SolverSystem():
-+    pass
-+
-+
-+class ExpectOps:
-+    """
-+        Contain and compute expectation values
-+    """
-+    def __init__(self, e_ops=[], super_=False):
-+        # take care of expectation values, if any
-+        self.isfunc = False
-+        self.e_ops_dict = False
-+        self.raw_e_ops = e_ops
-+        self.e_ops_qoevo = []
-+        self.e_num = 0
-+        self.e_ops_isherm = []
-+
-+        if isinstance(e_ops, (Qobj, QobjEvo)):
-+            e_ops = [e_ops]
-+        elif isinstance(e_ops, dict):
-+            self.e_ops_dict = e_ops
-+            e_ops = [e for e in e_ops.values()]
-+
-+        self.e_ops = e_ops
-+        if isinstance(e_ops, list):
-+            self.e_num = len(e_ops)
-+            self.e_ops_isherm = [e.isherm for e in e_ops]
-+            if not super_:
-+                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
-+                                            dtype=object)
-+            else:
-+                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
-+                                            dtype=object)
-+        elif callable(e_ops):
-+            self.isfunc = True
-+            self.e_num = 1
-+
-+    def init(self, tlist):
-+        self.tlist = tlist
-+        if self.isfunc:
-+            self.raw_out = []
-+        else:
-+            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
-+
-+    def check_dims(self, dims):
-+        if not self.isfunc:
-+            for op in self.e_ops_qoevo:
-+                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
-+                    raise TypeError(f"e_ops dims ({op.dims}) are not "
-+                                    f"compatible with the system's ({dims})")
-+
-+    def copy(self):
-+        out = ExpectOps.__new__(ExpectOps)
-+        out.isfunc = self.isfunc
-+        out.e_ops_dict = self.e_ops_dict
-+        out.raw_e_ops = self.raw_e_ops
-+        out.e_ops = self.e_ops
-+        out.e_num = self.e_num
-+        out.e_ops_isherm = self.e_ops_isherm
-+        out.e_ops_qoevo = self.e_ops_qoevo
-+        return out
-+
-+    def step(self, iter_, state):
-+        if self.isfunc:
-+            self.raw_out.append(self.e_ops(t, state))
-+        else:
-+            state = _data.dense.fast_from_numpy(state)
-+            t = self.tlist[iter_]
-+            for ii in range(self.e_num):
-+                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
-+                    self.raw_out[ii, iter_] = \
-+                        self.e_ops_qoevo[ii].expect_data(t, state)
-+                elif callable(self.e_ops_qoevo[ii]):
-+                    self.raw_out[ii, iter_] = \
-+                        self.e_ops_qoevo[ii](t, state)
-+
-+    def finish(self):
-+        if self.isfunc:
-+            result = self.raw_out
-+        else:
-+            result = []
-+            for ii in range(self.e_num):
-+                if self.e_ops_isherm[ii]:
-+                    result.append(np.real(self.raw_out[ii, :]))
-+                else:
-+                    result.append(self.raw_out[ii, :])
-+            if self.e_ops_dict:
-+                result = {e: result[n]
-+                          for n, e in enumerate(self.e_ops_dict.keys())}
-+        return result
-+
-+    def __eq__(self, other):
-+        if isinstance(other, ExpectOps):
-+            other = other.raw_e_ops
-+        return self.raw_e_ops == other
-+
-+    def __ne__(self, other):
-+        return not (self == other)
-+
-+    def __bool__(self):
-+        return bool(self.e_num)
-+
-+
-+@optionsclass("solver")
-+class SolverOptions:
-+    """
-+    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-+    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-+    constructor::
-+
-+        opts = SolverOptions(order=10, ...)
-+
-+    or by changing the class attributes after creation::
-+
-+        opts = SolverOptions()
-+        opts.order = 10
-+
-+    Returns options class to be used as options in evolution solvers.
-+
-+    The default can be changed by::
-+
-+        qutip.settings.solver['order'] = 10
-+
-+    Supported options:
-+
-+        atol : float {1e-8}
-+            Absolute tolerance.
-+        rtol : float {1e-6}
-+            Relative tolerance.
-+        method : str {'adams','bdf'}
-+            Integration method.
-+        order : int {12}
-+            Order of integrator (<=12 'adams', <=5 'bdf')
-+        nsteps : int {2500}
-+            Max. number of internal steps/call.
-+        first_step : float {0}
-+            Size of initial step (0 = automatic).
-+        min_step : float {0}
-+            Minimum step size (0 = automatic).
-+        max_step : float {0}
-+            Maximum step size (0 = automatic)
-+        tidy : bool {True,False}
-+            Tidyup Hamiltonian and initial state by removing small terms.
-+        average_states : bool {False}
-+            Average states values over trajectories in stochastic solvers.
-+        average_expect : bool {True}
-+            Average expectation values over trajectories for stochastic solvers.
-+        ntraj : int {500}
-+            Number of trajectories in stochastic solvers.
-+        store_final_state : bool {False, True}
-+            Whether or not to store the final state of the evolution in the
-+            result class.
-+        store_states : bool {False, True}
-+            Whether or not to store the state vectors or density matrices in the
-+            result class, even if expectation values operators are given. If no
-+            expectation are provided, then states are stored by default and this
-+            option has no effect.
-+    """
-+    options = {
-+        # Absolute tolerance (default = 1e-8)
-+        "atol": 1e-8,
-+        # Relative tolerance (default = 1e-6)
-+        "rtol": 1e-6,
-+        # Integration method (default = 'adams', for stiff 'bdf')
-+        "method": 'adams',
-+        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
-+        "order": 12,
-+        # Max. number of internal steps/call
-+        "nsteps": 1000,
-+        # Size of initial step (0 = determined by solver)
-+        "first_step": 0,
-+        # Max step size (0 = determined by solver)
-+        "max_step": 0,
-+        # Minimal step size (0 = determined by solver)
-+        "min_step": 0,
-+        # Average expectation values over trajectories (default = True)
-+        "average_expect": True,
-+        # average expectation values
-+        "average_states": False,
-+        # tidyup Hamiltonian before calculation (default = True)
-+        "tidy": True,
-+        # Number of trajectories (default = 500)
-+        "ntraj": 500,
-+        "gui": False,
-+        # store final state?
-+        "store_final_state": False,
-+        # store states even if expectation operators are given?
-+        "store_states": False,
-+        # average mcsolver density matricies assuming steady state evolution
-+        "steady_state_average": False,
-+        # Normalize output of solvers
-+        # (turned off for batch unitary propagator mode)
-+        "normalize_output": True
-+    }
-+
-+
-+@optionsclass("mcsolve", SolverOptions)
-+class McOptions:
-+    """
-+    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-+    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-+    constructor::
-+
-+        opts = SolverOptions(norm_tol=1e-3, ...)
-+
-+    or by changing the class attributes after creation::
-+
-+        opts = SolverOptions()
-+        opts.['norm_tol'] = 1e-3
-+
-+    Returns options class to be used as options in evolution solvers.
-+
-+    The default can be changed by::
-+
-+        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
-+
-+    Options
-+    -------
-+
-+    norm_tol : float {1e-4}
-+        Tolerance used when finding wavefunction norm in mcsolve.
-+    norm_t_tol : float {1e-6}
-+        Tolerance used when finding wavefunction time in mcsolve.
-+    norm_steps : int {5}
-+        Max. number of steps used to find wavefunction norm to within norm_tol
-+        in mcsolve.
-+    mc_corr_eps : float {1e-10}
-+        Arbitrarily small value for eliminating any divide-by-zero errors in
-+        correlation calculations when using mcsolve.
-+    """
-+    options = {
-+        # Tolerance for wavefunction norm (mcsolve only)
-+        "norm_tol": 1e-4,
-+        # Tolerance for collapse time precision (mcsolve only)
-+        "norm_t_tol": 1e-6,
-+        # Max. number of steps taken to find wavefunction norm to within
-+        # norm_tol (mcsolve only)
-+        "norm_steps": 5,
-+        # small value in mc solver for computing correlations
-+        "mc_corr_eps": 1e-10,
-+    }
-+
-+
-+class Result():
-+    """Class for storing simulation results from any of the dynamics solvers.
-+
-+    Attributes
-+    ----------
-+
-+    solver : str
-+        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
-+    times : list/array
-+        Times at which simulation data was collected.
-+    expect : list/array
-+        Expectation values (if requested) for simulation.
-+    states : array
-+        State of the simulation (density matrix or ket) evaluated at ``times``.
-+    num_expect : int
-+        Number of expectation value operators in simulation.
-+    num_collapse : int
-+        Number of collapse operators in simualation.
-+    ntraj : int/list
-+        Number of trajectories (for stochastic solvers). A list indicates
-+        that averaging of expectation values was done over a subset of total
-+        number of trajectories.
-+    col_times : list
-+        Times at which state collpase occurred. Only for Monte Carlo solver.
-+    col_which : list
-+        Which collapse operator was responsible for each collapse in
-+        ``col_times``. Only for Monte Carlo solver.
-+
-+    """
-+    def __init__(self):
-+        self.solver = None
-+        self.times = None
-+        self.states = []
-+        self.expect = []
-+        self.num_expect = 0
-+        self.num_collapse = 0
-+        self.ntraj = None
-+        self.seeds = None
-+        self.col_times = None
-+        self.col_which = None
-+
-+    def __str__(self):
-+        s = "Result object "
-+        if self.solver:
-+            s += "with " + self.solver + " data.\n"
-+        else:
-+            s += "missing solver information.\n"
-+        s += "-" * (len(s) - 1) + "\n"
-+        if self.states is not None and len(self.states) > 0:
-+            s += "states = True\n"
-+        elif self.expect is not None and len(self.expect) > 0:
-+            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
-+        else:
-+            s += "states = True, expect = True\n" + \
-+                "num_expect = " + str(self.num_expect) + ", "
-+        s += "num_collapse = " + str(self.num_collapse)
-+        if self.solver == 'mcsolve':
-+            s += ", ntraj = " + str(self.ntraj)
-+        return s
-+
-+    def __repr__(self):
-+        return self.__str__()
-+
-+    def __getstate__(self):
-+        # defines what happens when Qobj object gets pickled
-+        self.__dict__.update({'qutip_version': __version__[:5]})
-+        return self.__dict__
-+
-+    def __setstate__(self, state):
-+        # defines what happens when loading a pickled Qobj
-+        if 'qutip_version' in state.keys():
-+            del state['qutip_version']
-+        (self.__dict__).update(state)
-+
-+
-+# %%%%%%%%%%% remove ?
-+class SolverConfiguration():
-+    def __init__(self):
-+
-+        self.cgen_num = 0
-+
-+        self.reset()
-+
-+    def reset(self):
-+        # General stuff
-+        self.tlist = None       # evaluations times
-+        self.ntraj = None       # number / list of trajectories
-+        self.options = None     # options for solvers
-+        self.norm_tol = None    # tolerance for wavefunction norm
-+        self.norm_steps = None  # max. number of steps to take in finding
-+        # Initial state stuff
-+        self.psi0 = None        # initial state
-+        self.psi0_dims = None   # initial state dims
-+        self.psi0_shape = None  # initial state shape
-+
-+        # flags for setting time-dependence, collapse ops, and number of times
-+        # codegen has been run
-+        self.cflag = 0     # Flag signaling collapse operators
-+        self.tflag = 0     # Flag signaling time-dependent problem
-+
-+        self.soft_reset()
-+
-+    def soft_reset(self):
-+        # Hamiltonian stuff
-+        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
-+        self.h_tdterms = []  # List of td strs and funcs
-+        self.h_data = None   # List of sparse matrix data
-+        self.h_ind = None    # List of sparse matrix indices
-+        self.h_ptr = None    # List of sparse matrix ptrs
-+
-+        # Expectation operator stuff
-+        self.e_num = 0        # number of expect ops
-+        self.e_ops_data = []  # expect op data
-+        self.e_ops_ind = []   # expect op indices
-+        self.e_ops_ptr = []   # expect op indptrs
-+        self.e_ops_isherm = []  # expect op isherm
-+
-+        # Collapse operator stuff
-+        self.c_num = 0          # number of collapse ops
-+        self.c_const_inds = []  # indicies of constant collapse operators
-+        self.c_td_inds = []     # indicies of time-dependent collapse operators
-+        self.c_ops_data = []    # collapse op data
-+        self.c_ops_ind = []     # collapse op indices
-+        self.c_ops_ptr = []     # collapse op indptrs
-+        self.c_args = []        # store args for time-dependent collapse func.
-+
-+        # Norm collapse operator stuff
-+        self.n_ops_data = []  # norm collapse op data
-+        self.n_ops_ind = []   # norm collapse op indices
-+        self.n_ops_ptr = []   # norm collapse op indptrs
-+
-+        # holds executable strings for time-dependent collapse evaluation
-+        self.col_expect_code = None
-+        self.col_spmv_code = None
-+
-+        # hold stuff for function list based time dependence
-+        self.h_td_inds = []
-+        self.h_td_data = []
-+        self.h_td_ind = []
-+        self.h_td_ptr = []
-+        self.h_funcs = None
-+        self.h_func_args = None
-+        self.c_funcs = None
-+        self.c_func_args = None
-+
-+        # time-dependent (TD) function stuff
-+        self.tdfunc = None     # Placeholder for TD RHS function.
-+        self.tdname = None     # Name of td .pyx file
-+        self.colspmv = None    # Placeholder for TD col-spmv function.
-+        self.colexpect = None  # Placeholder for TD col_expect function.
-+        self.string = None     # Holds string of variables passed to td solver
-+
-+
-+def _format_time(t, tt=None, ttt=None):
-+    time_str = str(datetime.timedelta(seconds=t))
-+    if tt is not None and ttt is not None:
-+        sect_percent = 100*t/tt
-+        solve_percent = 100*t/ttt
-+        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
-+                                            sect_percent, solve_percent)
-+    elif tt is not None:
-+        sect_percent = 100*t/tt
-+        time_str += " ({:03.2f}% section)".format(sect_percent)
-+
-+    elif ttt is not None:
-+        solve_percent = 100*t/ttt
-+        time_str += " ({:03.2f}% total)".format(solve_percent)
-+
-+    return time_str
-+
-+
-+class Stats:
-+    """
-+    Statistical information on the solver performance
-+    Statistics can be grouped into sections.
-+    If no section names are given in the the contructor, then all statistics
-+    will be added to one section 'main'
-+
-+    Parameters
-+    ----------
-+    section_names : list
-+        list of keys that will be used as keys for the sections
-+        These keys will also be used as names for the sections
-+        The text in the output can be overidden by setting the header property
-+        of the section
-+        If no names are given then one section called 'main' is created
-+
-+    Attributes
-+    ----------
-+    sections : OrderedDict of _StatsSection
-+        These are the sections that are created automatically on instantiation
-+        or added using add_section
-+
-+    header : string
-+        Some text that will be used as the heading in the report
-+        By default there is None
-+
-+    total_time : float
-+        Time in seconds for the solver to complete processing
-+        Can be None, meaning that total timing percentages will be reported
-+    """
-+
-+    def __init__(self, section_names=None):
-+        self._def_section_name = 'main'
-+        self.sections = OrderedDict()
-+        self.total_time = None
-+        self.header = None
-+        if isinstance(section_names, list):
-+            c = 0
-+            for name in section_names:
-+                self.sections[name] = _StatsSection(name, self)
-+                if c == 0:
-+                    self._def_section_name = name
-+                c += 1
-+
-+        else:
-+            self.sections[self._def_section_name] = \
-+                        _StatsSection(self._def_section_name)
-+
-+    def _get_section(self, section):
-+        if section is None:
-+            return self.sections[self._def_section_name]
-+        elif isinstance(section, _StatsSection):
-+            return section
-+        else:
-+            sect = self.sections.get(section, None)
-+            if sect is None:
-+                raise ValueError("Unknown section {}".format(section))
-+            else:
-+                return sect
-+
-+    def add_section(self, name):
-+        """
-+        Add another section with the given name
-+
-+        Parameters
-+        ----------
-+        name : string
-+            will be used as key for sections dict
-+            will also be the header for the section
-+
-+        Returns
-+        -------
-+        section : :class:`_StatsSection`
-+            The new section
-+        """
-+        sect = _StatsSection(name, self)
-+        self.sections[name] = sect
-+        return sect
-+
-+    def add_count(self, key, value, section=None):
-+        """
-+        Add value to count. If key does not already exist in section then
-+        it is created with this value.
-+        If key already exists it is increased by the give value
-+        value is expected to be an integer
-+
-+        Parameters
-+        ----------
-+        key : string
-+            key for the section.counts dictionary
-+            reusing a key will result in numerical addition of value
-+
-+        value : int
-+            Initial value of the count, or added to an existing count
-+
-+        section : string or :class:`_StatsSection`
-+            Section which to add the count to.
-+            If None given, the default (first) section will be used
-+        """
-+
-+        self._get_section(section).add_count(key, value)
-+
-+    def add_timing(self, key, value, section=None):
-+        """
-+        Add value to timing. If key does not already exist in section then
-+        it is created with this value.
-+        If key already exists it is increased by the give value
-+        value is expected to be a float, and given in seconds.
-+
-+        Parameters
-+        ----------
-+        key : string
-+            key for the section.timings dictionary
-+            reusing a key will result in numerical addition of value
-+
-+        value : int
-+            Initial value of the timing, or added to an existing timing
-+
-+        section: string or `class` : _StatsSection
-+            Section which to add the timing to.
-+            If None given, the default (first) section will be used
-+        """
-+        self._get_section(section).add_timing(key, value)
-+
-+    def add_message(self, key, value, section=None, sep=";"):
-+        """
-+        Add value to message. If key does not already exist in section then
-+        it is created with this value.
-+        If key already exists the value is added to the message
-+        The value will be converted to a string
-+
-+        Parameters
-+        ----------
-+        key : string
-+            key for the section.messages dictionary
-+            reusing a key will result in concatenation of value
-+
-+        value : int
-+            Initial value of the message, or added to an existing message
-+
-+        sep : string
-+            Message will be prefixed with this string when concatenating
-+
-+        section: string or `class` : _StatsSection
-+            Section which to add the message to.
-+            If None given, the default (first) section will be used
-+        """
-+        self._get_section(section).add_message(key, value, sep=sep)
-+
-+    def set_total_time(self, value, section=None):
-+        """
-+        Sets the total time for the complete solve or for a specific section
-+        value is expected to be a float, and given in seconds
-+
-+        Parameters
-+        ----------
-+        value : float
-+            Time in seconds to complete the solver section
-+
-+        section : string or `class` : _StatsSection
-+            Section which to set the total_time for
-+            If None given, the total_time for complete solve is set
-+        """
-+        if not isinstance(value, float):
-+            try:
-+                value = float(value)
-+            except:
-+                raise TypeError("value is expected to be a float")
-+
-+        if section is None:
-+            self.total_time = value
-+        else:
-+            sect = self._get_section(section)
-+            sect.total_time = value
-+
-+    def report(self, output=sys.stdout):
-+        """
-+        Report the counts, timings and messages from the sections.
-+        Sections are reported in the order that the names were supplied
-+        in the constructor.
-+        The counts, timings and messages are reported in the order that they
-+        are added to the sections
-+        The output can be written to anything that supports a write method,
-+        e.g. a file or the console (default)
-+        The output is intended to in markdown format
-+
-+        Parameters
-+        ----------
-+        output : stream
-+            file or console stream - anything that support write - where
-+            the output will be written
-+        """
-+
-+        if not hasattr(output, 'write'):
-+            raise TypeError("output must have a write method")
-+
-+        if self.header:
-+            output.write("{}\n{}\n".format(self.header,
-+                                     ("="*len(self.header))))
-+        for name, sect in self.sections.items():
-+            sect.report(output)
-+
-+        if self.total_time is not None:
-+            output.write("\nSummary\n-------\n")
-+            output.write("{}\t solver total time\n".format(
-+                                            _format_time(self.total_time)))
-+
-+    def clear(self):
-+        """
-+        Clear counts, timings and messages from all sections
-+        """
-+        for sect in self.sections.values():
-+            sect.clear()
-+        self.total_time = None
-+
-+
-+class _StatsSection(object):
-+    """
-+    Not intended to be directly instantiated
-+    This is the type for the SolverStats.sections values
-+
-+    The method parameter descriptions are the same as for those the parent
-+    with the same method name
-+
-+    Parameters
-+    ----------
-+    name : string
-+        key for the parent sections dictionary
-+        will also be used as the header
-+
-+    parent : `class` :  SolverStats
-+        The container for all the sections
-+
-+    Attributes
-+    ----------
-+    name : string
-+        key for the parent sections dictionary
-+        will also be used as the header
-+
-+    parent : `class` :  SolverStats
-+        The container for all the sections
-+
-+    header : string
-+        Used as heading for section in report
-+
-+    counts : OrderedDict
-+        The integer type statistics for the stats section
-+
-+    timings : OrderedDict
-+        The timing type statistics for the stats section
-+        Expected to contain float values representing values in seconds
-+
-+    messages : OrderedDict
-+        Text type output to be reported
-+
-+    total_time : float
-+        Total time for processing in the section
-+        Can be None, meaning that section timing percentages will be reported
-+    """
-+    def __init__(self, name, parent):
-+        self.parent = parent
-+        self.header = str(name)
-+        self.name = name
-+        self.counts = OrderedDict()
-+        self.timings = OrderedDict()
-+        self.messages = OrderedDict()
-+        self.total_time = None
-+
-+    def add_count(self, key, value):
-+        """
-+        Add value to count. If key does not already exist in section then
-+        it is created with this value.
-+        If key already exists it is increased by the given value
-+        value is expected to be an integer
-+        """
-+        if not isinstance(value, int):
-+            try:
-+                value = int(value)
-+            except:
-+                raise TypeError("value is expected to be an integer")
-+
-+        if key in self.counts:
-+            self.counts[key] += value
-+        else:
-+            self.counts[key] = value
-+
-+    def add_timing(self, key, value):
-+        """
-+        Add value to timing. If key does not already exist in section then
-+        it is created with this value.
-+        If key already exists it is increased by the give value
-+        value is expected to be a float, and given in seconds.
-+        """
-+        if not isinstance(value, float):
-+            try:
-+                value = float(value)
-+            except:
-+                raise TypeError("value is expected to be a float")
-+
-+        if key in self.timings:
-+            self.timings[key] += value
-+        else:
-+            self.timings[key] = value
-+
-+    def add_message(self, key, value, sep=";"):
-+        """
-+        Add value to message. If key does not already exist in section then
-+        it is created with this value.
-+        If key already exists the value is added to the message
-+        The value will be converted to a string
-+        """
-+        value = str(value)
-+
-+        if key in self.messages:
-+            if sep is not None:
-+                try:
-+                    value = sep + value
-+                except:
-+                    TypeError("It is not possible to concatenate the value "
-+                              "with the given seperator")
-+            self.messages[key] += value
-+        else:
-+            self.messages[key] = value
-+
-+    def report(self, output=sys.stdout):
-+        """
-+        Report the counts, timings and messages for this section.
-+        Note the percentage of the section and solver total times will be
-+        given if the parent and or section total_time is set
-+        """
-+        if self.header:
-+            output.write("\n{}\n{}\n".format(self.header,
-+                                     ("-"*len(self.header))))
-+
-+        # TODO: Make the timings and counts ouput in a table format
-+        #       Generally make more pretty
-+
-+        # Report timings
-+        try:
-+            ttt = self.parent.total_time
-+        except:
-+            ttt = None
-+
-+        tt = self.total_time
-+
-+        output.write("### Timings:\n")
-+        for key, value in self.timings.items():
-+            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
-+            output.write(l)
-+        if tt is not None:
-+            output.write(" - {}\t{} total time\n".format(_format_time(tt),
-+                                                     self.name))
-+
-+        # Report counts
-+        output.write("### Counts:\n")
-+        for key, value in self.counts.items():
-+            l = " - {}\t{}\n".format(value, key)
-+            output.write(l)
-+
-+        # Report messages
-+        output.write("### Messages:\n")
-+        for key, value in self.messages.items():
-+            l = " - {}:\t{}\n".format(key, value)
-+            output.write(l)
-+
-+
-+    def clear(self):
-+        """
-+        Clear counts, timings and messages from this section
-+        """
-+        self.counts.clear()
-+        self.timings.clear()
-+        self.messages.clear()
-+        self.total_time = None
-+
-+
-+def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
-+    # Input is std Qobj (Hamiltonian or Liouvillian)
-+    if isinstance(H, Qobj):
-+        Hdims = H.dims
-+        Htype = H.type
-+        _structure_check(Hdims, Htype, state)
-+    # Input H is function
-+    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
-+        Hdims = H(0,args).dims
-+        Htype = H(0,args).type
-+        _structure_check(Hdims, Htype, state)
-+    # Input is td-list
-+    elif isinstance(H, list):
-+        if isinstance(H[0], Qobj):
-+            Hdims = H[0].dims
-+            Htype = H[0].type
-+        elif isinstance(H[0], list):
-+            Hdims = H[0][0].dims
-+            Htype = H[0][0].type
-+        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
-+            Hdims = H[0](0,args).dims
-+            Htype = H[0](0,args).type
-+        else:
-+            raise Exception('Invalid td-list element.')
-+        # Check all operators in list
-+        for ii in range(len(H)):
-+            if isinstance(H[ii], Qobj):
-+                _temp_dims = H[ii].dims
-+                _temp_type = H[ii].type
-+            elif isinstance(H[ii], list):
-+                _temp_dims = H[ii][0].dims
-+                _temp_type = H[ii][0].type
-+            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
-+                _temp_dims = H[ii](0,args).dims
-+                _temp_type = H[ii](0,args).type
-+            else:
-+                raise Exception('Invalid td-list element.')
-+            _structure_check(_temp_dims,_temp_type,state)
-+
-+    else:
-+        raise Exception('Invalid time-dependent format.')
-+
-+
-+    for ii in range(len(c_ops)):
-+        do_tests = True
-+        if isinstance(c_ops[ii], Qobj):
-+            _temp_state = c_ops[ii]
-+        elif isinstance(c_ops[ii], list):
-+            if isinstance(c_ops[ii][0], Qobj):
-+                _temp_state = c_ops[ii][0]
-+            elif isinstance(c_ops[ii][0], tuple):
-+                do_tests = False
-+                for kk in range(len(c_ops[ii][0])):
-+                    _temp_state = c_ops[ii][0][kk]
-+                    _structure_check(Hdims, Htype, _temp_state)
-+        else:
-+            raise Exception('Invalid td-list element.')
-+        if do_tests:
-+            _structure_check(Hdims, Htype, _temp_state)
-+
-+    if isinstance(e_ops, list):
-+        for ii in range(len(e_ops)):
-+            if isinstance(e_ops[ii], Qobj):
-+                _temp_state = e_ops[ii]
-+            elif isinstance(e_ops[ii], list):
-+                _temp_state = e_ops[ii][0]
-+            else:
-+                raise Exception('Invalid td-list element.')
-+            _structure_check(Hdims,Htype,_temp_state)
-+    elif isinstance(e_ops, FunctionType):
-+        pass
-+    else:
-+        raise Exception('Invalid e_ops specification.')
-+
-+
-+def _structure_check(Hdims, Htype, state):
-+    if state is not None:
-+        # Input state is a ket vector
-+        if state.type == 'ket':
-+            # Input is Hamiltonian
-+            if Htype == 'oper':
-+                if Hdims[1] != state.dims[0]:
-+                    raise Exception('Input operator and ket do not '
-+                                    'share same structure.')
-+            # Input is super and state is ket
-+            elif Htype == 'super':
-+                if Hdims[1][1] != state.dims[0]:
-+                    raise Exception('Input operator and ket do not '
-+                                    'share same structure.')
-+            else:
-+                raise Exception('Invalid input operator.')
-+        # Input state is a density matrix
-+        elif state.type == 'oper':
-+            # Input is Hamiltonian and state is density matrix
-+            if Htype == 'oper':
-+                if Hdims[1] != state.dims[0]:
-+                    raise Exception('Input operators do not '
-+                                    'share same structure.')
-+            # Input is super op. and state is density matrix
-+            elif Htype == 'super':
-+                if Hdims[1] != state.dims:
-+                    raise Exception('Input operators do not '
-+                                    'share same structure.')
-+
-+
-+#
-+# create a global instance of the SolverConfiguration class
-+#
-+config = SolverConfiguration()
-+
-+# for backwards compatibility
-+# Odeoptions = Options
-+# Odedata = Result
-diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
-index 99829ae8..63df5c46 100644
---- a/qutip/solve/stochastic.py
-+++ b/qutip/solve/stochastic.py
-@@ -1,1405 +1,1405 @@
--# -*- coding: utf-8 -*-
--
--import numpy as np
--import scipy.sparse as sp
--from .. import (
--    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
--    unstack_columns, liouvillian, lindblad_dissipator,
--)
--from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
--from ._stochastic import (
--    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
--    GenericSSolver, Solvers
--)
--from .solver import Result, SolverOptions, _solver_safety_check
--from .parallel import serial_map
--from ..ui.progressbar import TextProgressBar
--from qutip.core import data as _data
--
--__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
--           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
--           'stochastic_solvers', 'general_stochastic']
--
--
--def stochastic_solvers():
--    # This docstring contains several literal backslash characters inside LaTeX
--    # blocks, but it cannot be declared as a raw string because we also need to
--    # use a line continuation.  At one point we need a restructured text
--    # "definition list", where the heading _must_ be entirely on one line,
--    # however it will violate our line-length reporting if we do that.
--    """
--    This function is purely a reference point for documenting the available
--    stochastic solver methods, and takes no actions.
--
--    Notes
--    -----
--    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
--        euler-maruyama
--            A simple generalization of the Euler method for ordinary
--            differential equations to stochastic differential equations.  Only
--            solver which could take non-commuting ``sc_ops``. *not tested*
--
--            - Order 0.5
--            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
--
--        milstein
--            An order 1.0 strong Taylor scheme.  Better approximate numerical
--            solution to stochastic differential equations.  See eq. (2.9) of
--            chapter 12.2 of [1]_.
--
--            - Order strong 1.0
--            - Code: ``'milstein'`` or ``1.0``
--
--        milstein-imp
--            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
--            scheme for the numerical simulation of stiff stochastic
--            differential equations.
--
--            - Order strong 1.0
--            - Code: ``'milstein-imp'``
--
--        predictor-corrector
--            Generalization of the trapezoidal method to stochastic differential
--            equations. More stable than explicit methods.  See eq. (5.4) of
--            chapter 15.5 of [1]_.
--
--            - Order strong 0.5, weak 1.0
--            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
--              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
--              ``'pc-euler'``
--            - Codes to correct both the stochastic and deterministic parts
--              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
--              ``'pc-euler-2'`` or ``'pred-corr-2'``
--
--        platen
--            Explicit scheme, creates the Milstein using finite differences
--            instead of analytic derivatives. Also contains some higher order
--            terms, thus converges better than Milstein while staying strong
--            order 1.0.  Does not require derivatives, therefore usable by
--            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
--
--            - Order strong 1.0, weak 2.0
--            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
--
--        rouchon
--            Scheme keeping the positivity of the density matrix
--            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
--
--            - Order strong 1.0?
--            - Code: ``'rouchon'`` or ``'Rouchon'``
--
--        taylor1.5
--            Order 1.5 strong Taylor scheme.  Solver with more terms of the
--            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
--            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
--
--            - Order strong 1.5
--            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
--
--        taylor1.5-imp
--            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
--            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
--            (2.18) of chapter 12.2 of [1]_.
--
--            - Order strong 1.5
--            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
--
--        explicit1.5
--            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
--            Taylor scheme using finite difference instead of derivatives.
--            Slower than ``taylor15`` but usable by
--            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
--            [1]_.
--
--            - Order strong 1.5
--            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
--
--        taylor2.0
--            Order 2 strong Taylor scheme.  Solver with more terms of the
--            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
--
--            - Order strong 2.0
--            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
--
--        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
--        and for both heterodyne and homodyne. taylor2.0 only works for 1
--        stochastic operator independent of time with the homodyne method.
--        :func:`~general_stochastic` only accepts the derivative-free
--        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
--
--    Available solvers for :obj:`~photocurrent_sesolve` and \
--:obj:`~photocurrent_mesolve`
--        Photocurrent use ordinary differential equations between
--        stochastic "jump/collapse".
--
--        euler
--            Euler method for ordinary differential equations between jumps.
--            Only one jump per time interval.  Default solver.  See eqs. (4.19)
--            and (4.4) of chapter 4 of [4]_.
--
--            - Order 1.0
--            - Code: ``'euler'``
--
--        predictor–corrector
--            predictor–corrector method (PECE) for ordinary differential
--            equations.  Uses the Poisson distribution to obtain the number of
--            jumps at each timestep.
--
--            - Order 2.0
--            - Code: ``'pred-corr'``
--
--    References
--    ----------
--    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
--       Stochastic Differential Equations*.
--    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
--       Systems*.
--    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
--       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
--       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
--       (2015).
--    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
--       control*.
--    """
--
--
--class StochasticSolverOptions:
--    """Class of options for stochastic solvers such as
--    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
--
--    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
--    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
--    :func:`qutip.stochastic.photocurrent_sesolve` and
--    :func:`qutip.stochastic.photocurrent_mesolve`
--    all take the same keyword arguments as
--    the constructor of these class, and internally they use these arguments to
--    construct an instance of this class, so it is rarely needed to explicitly
--    create an instance of this class.
--
--    Within the attribute list, a ``time_dependent_object`` is either
--
--    - :class:`~qutip.Qobj`: a constant term
--    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
--      where the ``Qobj`` will be multiplied by the time-dependent scalar.
--
--    For more details on all allowed time-dependent objects, see the
--    documentation for :class:`~qutip.QobjEvo`.
--
--    Attributes
--    ----------
--    H : time_dependent_object or list of time_dependent_object
--        System Hamiltonian in standard time-dependent list format.  This is the
--        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
--        If this is a list of elements, they are summed.
--
--    state0 : :class:`qutip.Qobj`
--        Initial state vector (ket) or density matrix.
--
--    times : array_like of float
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of time_dependent_object
--        List of deterministic collapse operators.  Each element of the list is
--        a separate operator; unlike the Hamiltonian, there is no implicit
--        summation over the terms.
--
--    sc_ops : list of time_dependent_object
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the equation of motion according to how the d1 and d2 functions
--        are defined.  Each element of the list is a separate operator, like
--        ``c_ops``.
--
--    e_ops : list of :class:`qutip.Qobj`
--        Single operator or list of operators for which to evaluate
--        expectation values.
--
--    m_ops : list of :class:`qutip.Qobj`
--        List of operators representing the measurement operators. The expected
--        format is a nested list with one measurement operator for each
--        stochastic increament, for each stochastic collapse operator.
--
--    args : dict
--        Dictionary of parameters for time dependent systems.
--
--    tol : float
--        Tolerance of the solver for implicit methods.
--
--    ntraj : int
--        Number of trajectors.
--
--    nsubsteps : int
--        Number of sub steps between each time-spep given in `times`.
--
--    dW_factors : array
--        Array of length len(sc_ops), containing scaling factors for each
--        measurement operator in m_ops.
--
--    solver : string
--        Name of the solver method to use for solving the stochastic
--        equations. Valid values are:
--
--        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
--        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
--        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
--        - order 2 algorithms: 'taylor2.0'
--
--        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
--        for a description of the solvers.  Implicit methods can adjust
--        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
--
--    method : string ('homodyne', 'heterodyne')
--        The name of the type of measurement process that give rise to the
--        stochastic equation to solve.
--
--    store_all_expect : bool (default False)
--        Whether or not to store the e_ops expect values for all paths.
--
--    store_measurement : bool (default False)
--        Whether or not to store the measurement results in the
--        :class:`qutip.solver.Result` instance returned by the solver.
--
--    noise : int, or 1D array of int, or 4D array of float
--        - int : seed of the noise
--        - 1D array : length = ntraj, seeds for each trajectories.
--        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
--          Vector for the noise, the len of the last dimensions is doubled for
--          solvers of order 1.5. This corresponds to results.noise.
--
--    noiseDepth : int
--        Number of terms kept of the truncated series used to create the
--        noise used by taylor2.0 solver.
--
--    normalize : bool
--        (default True for (photo)ssesolve, False for (photo)smesolve)
--        Whether or not to normalize the wave function during the evolution.
--        Normalizing density matrices introduce numerical errors.
--
--    options : :class:`qutip.solver.SolverOptions`
--        Generic solver options. Only options['average_states'] and
--        options['store_states'] are used.
--
--    map_func: function
--        A map function or managing the calls to single-trajactory solvers.
--
--    map_kwargs: dictionary
--        Optional keyword arguments to the map_func function function.
--
--    progress_bar : :class:`qutip.ui.BaseProgressBar`
--        Optional progress bar class instance.
--    """
--    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
--                 e_ops=[], m_ops=None, store_all_expect=False,
--                 store_measurement=False, dW_factors=None,
--                 solver=None, method="homodyne", normalize=None,
--                 times=None, nsubsteps=1, ntraj=1, tol=None,
--                 generate_noise=None, noise=None,
--                 progress_bar=None, map_func=None, map_kwargs=None,
--                 args={}, options=None, noiseDepth=20):
--
--        if options is None:
--            options = SolverOptions()
--
--        if progress_bar is None:
--            progress_bar = TextProgressBar()
--
--        # System
--        # Cast to QobjEvo so the code has only one version for both the
--        # constant and time-dependent case.
--        self.me = me
--
--        if H is not None:
--            msg = "The Hamiltonian format is not valid. "
--            try:
--                self.H = QobjEvo(H, args=args, tlist=times)
--            except Exception as e:
--                raise ValueError(msg + str(e)) from e
--        else:
--            self.H = H
--
--        if sc_ops:
--            msg = ("The sc_ops format is not valid. Options are "
--                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
--            try:
--                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
--                               for op in sc_ops]
--            except Exception as e:
--                raise ValueError(msg + str(e)) from e
--        else:
--            self.sc_ops = sc_ops
--
--        if c_ops:
--            msg = ("The c_ops format is not valid. Options are "
--                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
--            try:
--                self.c_ops = [QobjEvo(op, args=args, tlist=times)
--                              for op in c_ops]
--            except Exception as e:
--                raise ValueError(msg + str(e)) from e
--        else:
--            self.c_ops = c_ops
--
--        self.state0 = state0
--        self.rho0 = stack_columns(state0.full()).ravel()
--
--        # Observation
--
--        for e_op in e_ops:
--            if (
--                isinstance(e_op, Qobj)
--                and self.H is not None
--                and e_op.dims[1] != self.H.dims[0]
--            ):
--                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
--                                f"with the system's ({self.H.dims})")
--        self.e_ops = e_ops
--        self.m_ops = m_ops
--        self.store_measurement = store_measurement
--        self.store_all_expect = store_all_expect
--        self.store_states = options['store_states']
--        self.dW_factors = dW_factors
--
--        # Solver
--        self.solver = solver
--        self.method = method
--        if normalize is None and me:
--            self.normalize = 0
--        elif normalize is None and not me:
--            self.normalize = 1
--        elif normalize:
--            self.normalize = 1
--        else:
--            self.normalize = 0
--
--        self.times = times
--        self.nsubsteps = nsubsteps
--        self.dt = (times[1] - times[0]) / self.nsubsteps
--        self.ntraj = ntraj
--        if tol is not None:
--            self.tol = tol
--        elif "tol" in args:
--            self.tol = args["tol"]
--        else:
--            self.tol = 1e-7
--
--        # Noise
--        if noise is not None:
--            if isinstance(noise, int):
--                # noise contain a seed
--                np.random.seed(noise)
--                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
--            noise = np.array(noise)
--            if len(noise.shape) == 1:
--                if noise.shape[0] < ntraj:
--                    raise ValueError("'noise' does not have enought seeds " +
--                                     "len(noise) >= ntraj")
--                # numpy seed must be between 0 and 2**32-1
--                # 'u4': unsigned 32bit int
--                self.noise = noise.astype("u4")
--                self.noise_type = 0
--
--            elif len(noise.shape) == 4:
--                # taylor case not included
--                dw_len = (2 if method == "heterodyne" else 1)
--                dw_len_str = (" * 2" if method == "heterodyne" else "")
--                msg = "Incorrect shape for 'noise': "
--                if noise.shape[0] < ntraj:
--                    raise ValueError(msg + "shape[0] >= ntraj")
--                if noise.shape[1] < len(times):
--                    raise ValueError(msg + "shape[1] >= len(times)")
--                if noise.shape[2] < nsubsteps:
--                    raise ValueError(msg + "shape[2] >= nsubsteps")
--                if noise.shape[3] < len(self.sc_ops) * dw_len:
--                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
--                                     dw_len_str)
--                self.noise_type = 1
--                self.noise = noise
--
--        else:
--            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
--            self.noise_type = 0
--
--        # Map
--        self.progress_bar = progress_bar
--        if self.ntraj > 1 and map_func:
--            self.map_func = map_func
--        else:
--            self.map_func = serial_map
--        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
--
--        # Other
--        self.options = options
--        self.args = args
--        self.set_solver()
--        self.p = noiseDepth
--
--    def set_solver(self):
--        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
--            self.solver_code = 50
--            self.solver = 'euler-maruyama'
--        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
--            self.solver_code = 100
--            self.solver = 'platen'
--        elif self.solver in ['pred-corr', 'predictor-corrector',
--                             'pc-euler', 101]:
--            self.solver_code = 101
--            self.solver = 'pred-corr'
--        elif self.solver in ['milstein', 102, 1.0]:
--            self.solver_code = 102
--            self.solver = 'milstein'
--        elif self.solver in ['milstein-imp', 103]:
--            self.solver_code = 103
--            self.solver = 'milstein-imp'
--        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
--            self.solver_code = 104
--            self.solver = 'pred-corr-2'
--        elif self.solver in ['Rouchon', 'rouchon', 120]:
--            self.solver_code = 120
--            self.solver = 'rouchon'
--            if not all((op.isconstant for op in self.sc_ops)):
--                raise ValueError("Rouchon only works with constant sc_ops")
--        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
--            self.solver_code = 150
--            self.solver = 'explicit1.5'
--        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
--            self.solver_code = 152
--            self.solver = 'taylor1.5'
--        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
--            self.solver_code = 153
--            self.solver = 'taylor1.5-imp'
--        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
--            self.solver_code = 202
--            self.solver = 'taylor2.0'
--            if not len(self.sc_ops) == 1 or \
--                    not self.sc_ops[0].isconstant or \
--                    not self.method == "homodyne":
--                raise ValueError(
--                    "Taylor2.0 only works with 1 constant sc_ops and for"
--                    " homodyne method"
--                )
--        else:
--            known = [
--                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
--                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
--                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
--            ]
--            raise ValueError("The solver should be one of {!r}".format(known))
--
--
--class StochasticSolverOptionsPhoto(StochasticSolverOptions):
--    """
--    Attributes
--    ----------
--
--    solver : string
--        Name of the solver method to use for solving the evolution
--        of the system.*
--        order 1 algorithms: 'euler'
--        order 2 algorithms: 'pred-corr'
--        In photocurrent evolution
--    """
--    def set_solver(self):
--        if self.solver in [None, 'euler', 1, 60]:
--            self.solver_code = 60
--            self.solver = 'euler'
--        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
--            self.solver_code = 110
--            self.solver = 'pred-corr'
--        else:
--            raise Exception("The solver should be one of " +
--                            "[None, 'euler', 'predictor-corrector']")
--
--
--def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
--             _safe_mode=True, args={}, **kwargs):
--    """
--    Solve stochastic master equation. Dispatch to specific solvers
--    depending on the value of the `solver` keyword argument.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`, or time dependent system.
--        System Hamiltonian.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    rho0 : :class:`qutip.Qobj`
--        Initial density matrix or state vector (ket).
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
--        Deterministic collapse operator which will contribute with a standard
--        Lindblad type of dissipation.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the eqaution of motion according to how the d1 and d2 functions
--        are defined.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    e_ops : list of :class:`qutip.Qobj`
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--
--    """
--    if "method" in kwargs and kwargs["method"] == "photocurrent":
--        print("stochastic solver with photocurrent method has been moved to "
--              "it's own function: photocurrent_mesolve")
--        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
--                                    e_ops=e_ops, _safe_mode=_safe_mode,
--                                    args=args, **kwargs)
--    if isket(rho0):
--        rho0 = ket2dm(rho0)
--
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = [e for e in e_ops.values()]
--    else:
--        e_ops_dict = None
--
--    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
--                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
--                                  args=args, **kwargs)
--
--    if _safe_mode:
--        _safety_checks(sso)
--
--    if sso.solver_code == 120:
--        return _positive_map(sso, e_ops_dict)
--
--    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
--    if sso.method == 'homodyne' or sso.method is None:
--        if sso.m_ops is None:
--            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
--        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
--        if not isinstance(sso.dW_factors, list):
--            sso.dW_factors = [1] * len(sso.m_ops)
--        elif len(sso.dW_factors) != len(sso.m_ops):
--            raise Exception("The len of dW_factors is not the same as m_ops")
--
--    elif sso.method == 'heterodyne':
--        if sso.m_ops is None:
--            m_ops = []
--        sso.sops = []
--        for c in sso.sc_ops:
--            if sso.m_ops is None:
--                m_ops += [c + c.dag(), -1j * (c - c.dag())]
--            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
--                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
--        sso.m_ops = m_ops
--        if not isinstance(sso.dW_factors, list):
--            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
--        elif len(sso.dW_factors) == len(sso.m_ops):
--            pass
--        elif len(sso.dW_factors) == len(sso.sc_ops):
--            dW_factors = []
--            for fact in sso.dW_factors:
--                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
--            sso.dW_factors = dW_factors
--        elif len(sso.dW_factors) != len(sso.m_ops):
--            raise Exception("The len of dW_factors is not the same as sc_ops")
--
--    elif sso.method == "photocurrent":
--        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
--
--    else:
--        raise Exception("The method must be one of None, homodyne, heterodyne")
--
--    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
--    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
--
--    if sso.solver_code in [103, 153]:
--        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
--
--    sso.solver_obj = SMESolver
--    sso.solver_name = "smesolve_" + sso.solver
--
--    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--    return res
--
--
--def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
--             _safe_mode=True, args={}, **kwargs):
--    """
--    Solve stochastic schrodinger equation. Dispatch to specific solvers
--    depending on the value of the `solver` keyword argument.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`, or time dependent system.
--        System Hamiltonian.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    psi0 : :class:`qutip.Qobj`
--        State vector (ket).
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the eqaution of motion according to how the d1 and d2 functions
--        are defined.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    e_ops : list of :class:`qutip.Qobj`
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--    if "method" in kwargs and kwargs["method"] == "photocurrent":
--        print("stochastic solver with photocurrent method has been moved to "
--              "it's own function: photocurrent_sesolve")
--        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
--                                    e_ops=e_ops, _safe_mode=_safe_mode,
--                                    args=args, **kwargs)
--
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = [e for e in e_ops.values()]
--    else:
--        e_ops_dict = None
--
--    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
--                                  sc_ops=sc_ops, e_ops=e_ops,
--                                  args=args, **kwargs)
--
--    if _safe_mode:
--        _safety_checks(sso)
--
--    if sso.solver_code == 120:
--        raise Exception("rouchon only work with smesolve")
--
--    if sso.method == 'homodyne' or sso.method is None:
--        if sso.m_ops is None:
--            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
--        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
--        if not isinstance(sso.dW_factors, list):
--            sso.dW_factors = [1] * len(sso.sops)
--        elif len(sso.dW_factors) != len(sso.sops):
--            raise Exception("The len of dW_factors is not the same as sc_ops")
--
--    elif sso.method == 'heterodyne':
--        if sso.m_ops is None:
--            m_ops = []
--        sso.sops = []
--        for c in sso.sc_ops:
--            if sso.m_ops is None:
--                m_ops += [c + c.dag(), -1j * (c - c.dag())]
--            c1 = c / np.sqrt(2)
--            c2 = c * (-1j / np.sqrt(2))
--            sso.sops += [[c1, c1 + c1.dag()],
--                         [c2, c2 + c2.dag()]]
--        sso.m_ops = m_ops
--        if not isinstance(sso.dW_factors, list):
--            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
--        elif len(sso.dW_factors) == len(sso.sc_ops):
--            dW_factors = []
--            for fact in sso.dW_factors:
--                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
--            sso.dW_factors = dW_factors
--        elif len(sso.dW_factors) != len(sso.sops):
--            raise Exception("The len of dW_factors is not the same as sc_ops")
--
--    elif sso.method == "photocurrent":
--        NotImplementedError("Moved to 'photocurrent_sesolve'")
--
--    else:
--        raise Exception("The method must be one of None, homodyne, heterodyne")
--
--    sso.LH = sso.H * (-1j * sso.dt)
--    for ops in sso.sops:
--        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
--
--    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
--    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
--
--    sso.solver_obj = SSESolver
--    sso.solver_name = "ssesolve_" + sso.solver
--
--    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--
--    return res
--
--
--def _positive_map(sso, e_ops_dict):
--    if sso.method == 'homodyne' or sso.method is None:
--        sops = sso.sc_ops
--        if sso.m_ops is None:
--            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
--        if not isinstance(sso.dW_factors, list):
--            sso.dW_factors = [1] * len(sops)
--        elif len(sso.dW_factors) != len(sops):
--            raise Exception("The len of dW_factors is not the same as sc_ops")
--
--    elif sso.method == 'heterodyne':
--        if sso.m_ops is None:
--            m_ops = []
--        sops = []
--        for c in sso.sc_ops:
--            if sso.m_ops is None:
--                m_ops += [c + c.dag(), -1j * (c - c.dag())]
--            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
--        sso.m_ops = m_ops
--        if not isinstance(sso.dW_factors, list):
--            sso.dW_factors = [np.sqrt(2)] * len(sops)
--        elif len(sso.dW_factors) == len(sso.sc_ops):
--            dW_factors = []
--            for fact in sso.dW_factors:
--                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
--            sso.dW_factors = dW_factors
--        elif len(sso.dW_factors) != len(sops):
--            raise Exception("The len of dW_factors is not the same as sc_ops")
--    else:
--        raise Exception("The method must be one of homodyne or heterodyne")
--
--    LH = 1 - (sso.H * 1j * sso.dt)
--    sso.pp = spre(sso.H) * 0
--    sso.sops = []
--    sso.preops = []
--    sso.postops = []
--    sso.preops2 = []
--    sso.postops2 = []
--
--    def _prespostdag(op):
--        return spre(op) * spost(op.dag())
--
--    for op in sso.c_ops:
--        LH += op.dag() @ op * (-sso.dt * 0.5)
--        sso.pp += spre(op) * spost(op.dag()) * sso.dt
--
--    for i, op in enumerate(sops):
--        LH += (-sso.dt * 0.5) * op.dag() @ op
--        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
--        sso.preops += [spre(op)]
--        sso.postops += [spost(op.dag())]
--        for op2 in sops[i:]:
--            sso.preops2 += [spre(op * op2)]
--            sso.postops2 += [spost(op.dag() * op2.dag())]
--
--    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
--    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
--    sso.preLH = spre(LH)
--    sso.postLH = spost(LH.dag())
--
--    sso.solver_obj = PmSMESolver
--    sso.solver_name = "smesolve_" + sso.solver
--    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--
--    return res
--
--
--def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
--                         _safe_mode=True, args={}, **kwargs):
--    """
--    Solve stochastic master equation using the photocurrent method.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`, or time dependent system.
--        System Hamiltonian.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    rho0 : :class:`qutip.Qobj`
--        Initial density matrix or state vector (ket).
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
--        Deterministic collapse operator which will contribute with a standard
--        Lindblad type of dissipation.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the eqaution of motion according to how the d1 and d2 functions
--        are defined.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function single
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--    if isket(rho0):
--        rho0 = ket2dm(rho0)
--
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = [e for e in e_ops.values()]
--    else:
--        e_ops_dict = None
--
--    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
--                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
--                                       args=args, **kwargs)
--
--    if _safe_mode:
--        _safety_checks(sso)
--
--    if sso.m_ops is None:
--        sso.m_ops = [op * 0 for op in sso.sc_ops]
--    if not isinstance(sso.dW_factors, list):
--        sso.dW_factors = [1] * len(sso.sc_ops)
--    elif len(sso.dW_factors) != len(sso.sc_ops):
--        raise Exception("The len of dW_factors is not the same as sc_ops")
--
--    sso.solver_obj = PcSMESolver
--    sso.solver_name = "photocurrent_mesolve"
--    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
--
--    def _prespostdag(op):
--        return spre(op) * spost(op.dag())
--
--    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
--                 spre(op.dag() @ op),
--                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
--    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
--    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
--
--    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
--    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--
--    return res
--
--
--def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
--                         _safe_mode=True, args={}, **kwargs):
--    """
--    Solve stochastic schrodinger equation using the photocurrent method.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`, or time dependent system.
--        System Hamiltonian.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    psi0 : :class:`qutip.Qobj`
--        Initial state vector (ket).
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the eqaution of motion according to how the d1 and d2 functions
--        are defined.
--        Can depend on time, see StochasticSolverOptions help for format.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function single
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = list(e_ops.values())
--    else:
--        e_ops_dict = None
--
--    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
--                                       sc_ops=sc_ops, e_ops=e_ops,
--                                       args=args, **kwargs)
--
--    if _safe_mode:
--        _safety_checks(sso)
--
--    if sso.m_ops is None:
--        sso.m_ops = [op * 0 for op in sso.sc_ops]
--    if not isinstance(sso.dW_factors, list):
--        sso.dW_factors = [1] * len(sso.sc_ops)
--    elif len(sso.dW_factors) != len(sso.sc_ops):
--        raise Exception("The len of dW_factors is not the same as sc_ops")
--
--    sso.solver_obj = PcSSESolver
--    sso.solver_name = "photocurrent_sesolve"
--    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
--    sso.LH = sso.H * (-1j*sso.dt)
--    for ops in sso.sops:
--        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
--    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
--    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
--
--    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
--    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--
--    return res
--
--
--def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
--                       _safe_mode=True, len_d2=1, args={}, **kwargs):
--    """
--    Solve stochastic general equation. Dispatch to specific solvers
--    depending on the value of the `solver` keyword argument.
--
--
--    Parameters
--    ----------
--
--    state0 : :class:`qutip.Qobj`
--        Initial state vector (ket) or density matrix as a vector.
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    d1 : function, callable class
--        Function representing the deterministic evolution of the system.
--
--        def d1(time (double), state (as a np.array vector)):
--            return 1d np.array
--
--    d2 : function, callable class
--        Function representing the stochastic evolution of the system.
--
--        def d2(time (double), state (as a np.array vector)):
--            return 2d np.array (N_sc_ops, len(state0))
--
--    len_d2 : int
--        Number of output vector produced by d2
--
--    e_ops : list of :class:`qutip.Qobj`
--        single operator or list of operators for which to evaluate
--        expectation values.
--        Must be a superoperator if the state vector is a density matrix.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--        An instance of the class :class:`qutip.solver.Result`.
--    """
--
--    if isinstance(e_ops, dict):
--        e_ops_dict = e_ops
--        e_ops = [e for e in e_ops.values()]
--    else:
--        e_ops_dict = None
--
--    if "solver" not in kwargs:
--        kwargs["solver"] = 50
--
--    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
--                                  e_ops=e_ops, args=args, **kwargs)
--    if sso.solver_code not in [50, 100, 150]:
--        raise ValueError("Only Euler, platen, platen15 can be " +
--                         "used for the general stochastic solver.")
--
--    sso.d1 = d1
--    sso.d2 = d2
--    if _safe_mode:
--        # This state0_vec is computed as stack_columns(state0.full()).ravel()
--        # in the sso init.
--        state0_vec = sso.rho0
--        l_vec = state0_vec.shape[0]
--        try:
--            out_d1 = d1(0., sso.rho0)
--        except Exception as e:
--            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
--                               str(e)) from e
--        try:
--            out_d2 = d2(0., sso.rho0)
--        except Exception as e:
--            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
--                               str(e)) from e
--
--        msg_d1 = ("d1 must return an 1d numpy array with the same number "
--                  "of elements as the initial state as a vector.")
--        if not isinstance(out_d1, np.ndarray):
--            raise TypeError(msg_d1)
--        if (out_d1.ndim != 1
--                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
--            raise ValueError(msg_d1)
--
--        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
--                  "with the shape (len_d2, len(state0_vec) ).")
--        if not isinstance(out_d2, np.ndarray):
--            raise TypeError(msg_d2)
--        if (out_d2.ndim != 2
--                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
--            raise ValueError(msg_d2)
--        if out_d1.dtype != np.dtype('complex128') or \
--           out_d2.dtype != np.dtype('complex128'):
--            raise ValueError("Safety check: d1 and d2 must return " +
--                             "complex numpy array.")
--        msg_e_ops = ("Safety check: The shape of the e_ops "
--                     "does not fit the intial state.")
--        for op in sso.e_ops:
--            shape_op = op.shape
--            if sso.me:
--                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
--                    raise ValueError(msg_e_ops)
--            else:
--                if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                    raise ValueError(msg_e_ops +
--                                     " Expecting e_ops as superoperators.")
--
--    sso.m_ops = []
--    sso.cm_ops = []
--    if sso.store_measurement:
--        if not m_ops:
--            raise ValueError("General stochastic needs explicit " +
--                             "m_ops to store measurement.")
--        sso.m_ops = m_ops
--        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
--        if sso.dW_factors is None:
--            sso.dW_factors = [1.] * len(sso.m_ops)
--        elif len(sso.dW_factors) == 1:
--            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
--        elif len(sso.dW_factors) != len(sso.m_ops):
--            raise ValueError("The number of dW_factors must fit" +
--                             " the number of m_ops.")
--
--    if sso.dW_factors is None:
--        sso.dW_factors = [1.] * len_d2
--    sso.sops = [None] * len_d2
--    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
--
--    sso.solver_obj = GenericSSolver
--    sso.solver_name = "general_stochastic_solver_" + sso.solver
--
--    ssolver = GenericSSolver()
--    # ssolver.set_data(sso)
--    ssolver.set_solver(sso)
--
--    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
--
--    if e_ops_dict:
--        res.expect = {e: res.expect[n]
--                      for n, e in enumerate(e_ops_dict.keys())}
--
--    return res
--
--
--def _safety_checks(sso):
--    l_vec = sso.rho0.shape[0]
--    if sso.H.issuper:
--        if not sso.me:
--            raise ValueError(
--                "Given a Liouvillian for a Schrödinger equation problem."
--            )
--        shape_op = sso.H.shape
--        if shape_op[0] != l_vec or shape_op[1] != l_vec:
--            raise Exception("The size of the hamiltonian does "
--                            "not fit the intial state")
--    else:
--        shape_op = sso.H.shape
--        if sso.me:
--            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
--                raise Exception("The size of the hamiltonian does "
--                                "not fit the intial state")
--        else:
--            if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                raise Exception("The size of the hamiltonian does "
--                                "not fit the intial state")
--
--    for op in sso.sc_ops:
--        if op.issuper:
--            if not sso.me:
--                raise ValueError(
--                    "Given a Liouvillian for a Schrödinger equation problem."
--                )
--            shape_op = op.shape
--            if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                raise Exception("The size of the sc_ops does "
--                                "not fit the intial state")
--        else:
--            shape_op = op.shape
--            if sso.me:
--                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
--                    raise Exception("The size of the sc_ops does "
--                                    "not fit the intial state")
--            else:
--                if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                    raise Exception("The size of the sc_ops does "
--                                    "not fit the intial state")
--
--    for op in sso.c_ops:
--        if op.issuper:
--            if not sso.me:
--                raise ValueError(
--                    "Given a Liouvillian for a Schrödinger equation problem."
--                )
--            shape_op = op.shape
--            if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                raise Exception("The size of the c_ops does "
--                                "not fit the intial state")
--        else:
--            shape_op = op.shape
--            if sso.me:
--                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
--                    raise Exception("The size of the c_ops does "
--                                    "not fit the intial state")
--            else:
--                if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                    raise Exception("The size of the c_ops does "
--                                    "not fit the intial state")
--
--    for op in sso.e_ops:
--        shape_op = op.shape
--        if sso.me:
--            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
--                raise Exception("The size of the e_ops does "
--                                "not fit the intial state")
--        else:
--            if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                raise Exception("The size of the e_ops does "
--                                "not fit the intial state")
--
--    if sso.m_ops is not None:
--        for op in sso.m_ops:
--            shape_op = op.shape
--            if sso.me:
--                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
--                    raise Exception("The size of the m_ops does "
--                                    "not fit the intial state")
--            else:
--                if shape_op[0] != l_vec or shape_op[1] != l_vec:
--                    raise Exception("The size of the m_ops does "
--                                    "not fit the intial state")
--
--
--def _sesolve_generic(sso, options, progress_bar):
--    """
--    Internal function. See smesolve.
--    """
--    res = Result()
--    res.times = sso.times
--    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
--    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
--    res.measurement = []
--    res.solver = sso.solver_name
--    res.ntraj = sso.ntraj
--    res.num_expect = len(sso.e_ops)
--
--    nt = sso.ntraj
--    task = _single_trajectory
--    map_kwargs = {'progress_bar': sso.progress_bar}
--    map_kwargs.update(sso.map_kwargs)
--    task_args = (sso,)
--    task_kwargs = {}
--
--    results = sso.map_func(task, list(range(sso.ntraj)),
--                           task_args, task_kwargs, **map_kwargs)
--    noise = []
--    for result in results:
--        states_list, dW, m, expect = result
--        res.states.append(states_list)
--        noise.append(dW)
--        res.measurement.append(m)
--        res.expect += expect
--        res.ss += expect * expect
--    res.noise = np.stack(noise)
--
--    if sso.store_all_expect:
--        paths_expect = []
--        for result in results:
--            paths_expect.append(result[3])
--        res.runs_expect = np.stack(paths_expect)
--
--    # average density matrices (vectorized maybe)
--    # ajgpitch 2019-10-25: np.any(res.states) seems to error
--    # I guess there may be a potential exception if there are no states?
--    # store individual trajectory states
--    res.traj_states = res.states
--    res.avg_states = None
--    if options['average_states'] and options['store_states']:
--        avg_states_list = []
--        for n in range(len(res.times)):
--            tslot_states = [res.states[mm][n].data for mm in range(nt)]
--            if len(tslot_states) > 0:
--                state = Qobj(np.sum(tslot_states),
--                             dims=res.states[0][n].dims).unit()
--                avg_states_list.append(state)
--        # store average states
--        res.states = res.avg_states = avg_states_list
--
--    # average
--    res.expect = res.expect / nt
--
--    # standard error
--    if nt > 1:
--        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
--    else:
--        res.se = None
--
--    # convert complex data to real if hermitian
--    res.expect = [np.real(res.expect[n, :])
--                  if e.isherm else res.expect[n, :]
--                  for n, e in enumerate(sso.e_ops)]
--
--    return res
--
--
--def _single_trajectory(i, sso):
--    # Only one step?
--    ssolver = sso.solver_obj()
--    ssolver.set_solver(sso)
--    result = ssolver.cy_sesolve_single_trajectory(i)
--    return result
--
--
--# The code for ssepdpsolve have been moved to the file pdpsolve.
--# The call is still in stochastic for consistance.
--def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
--    """
--    A stochastic (piecewse deterministic process) PDP solver for wavefunction
--    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
--    trajectory simulations.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`
--        System Hamiltonian.
--
--    psi0 : :class:`qutip.Qobj`
--        Initial state vector (ket).
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`
--        Deterministic collapse operator which will contribute with a standard
--        Lindblad type of dissipation.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function single
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--
--    """
--    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
--
--
--# The code for smepdpsolve have been moved to the file pdpsolve.
--# The call is still in stochastic for consistance.
--def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
--    """
--    A stochastic (piecewse deterministic process) PDP solver for density matrix
--    evolution.
--
--    Parameters
--    ----------
--
--    H : :class:`qutip.Qobj`
--        System Hamiltonian.
--
--    rho0 : :class:`qutip.Qobj`
--        Initial density matrix.
--
--    times : *list* / *array*
--        List of times for :math:`t`. Must be uniformly spaced.
--
--    c_ops : list of :class:`qutip.Qobj`
--        Deterministic collapse operator which will contribute with a standard
--        Lindblad type of dissipation.
--
--    sc_ops : list of :class:`qutip.Qobj`
--        List of stochastic collapse operators. Each stochastic collapse
--        operator will give a deterministic and stochastic contribution
--        to the eqaution of motion according to how the d1 and d2 functions
--        are defined.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function single
--        single operator or list of operators for which to evaluate
--        expectation values.
--
--    kwargs : *dictionary*
--        Optional keyword arguments. See
--        :class:`qutip.stochastic.StochasticSolverOptions`.
--
--    Returns
--    -------
--
--    output: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`.
--
--    """
--    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
-+# -*- coding: utf-8 -*-
-+
-+import numpy as np
-+import scipy.sparse as sp
-+from .. import (
-+    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
-+    unstack_columns, liouvillian, lindblad_dissipator,
-+)
-+from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
-+from ._stochastic import (
-+    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
-+    GenericSSolver, Solvers
-+)
-+from .solver import Result, SolverOptions, _solver_safety_check
-+from .parallel import serial_map
-+from ..ui.progressbar import TextProgressBar
-+from qutip.core import data as _data
-+
-+__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
-+           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
-+           'stochastic_solvers', 'general_stochastic']
-+
-+
-+def stochastic_solvers():
-+    # This docstring contains several literal backslash characters inside LaTeX
-+    # blocks, but it cannot be declared as a raw string because we also need to
-+    # use a line continuation.  At one point we need a restructured text
-+    # "definition list", where the heading _must_ be entirely on one line,
-+    # however it will violate our line-length reporting if we do that.
-+    """
-+    This function is purely a reference point for documenting the available
-+    stochastic solver methods, and takes no actions.
-+
-+    Notes
-+    -----
-+    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
-+        euler-maruyama
-+            A simple generalization of the Euler method for ordinary
-+            differential equations to stochastic differential equations.  Only
-+            solver which could take non-commuting ``sc_ops``. *not tested*
-+
-+            - Order 0.5
-+            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
-+
-+        milstein
-+            An order 1.0 strong Taylor scheme.  Better approximate numerical
-+            solution to stochastic differential equations.  See eq. (2.9) of
-+            chapter 12.2 of [1]_.
-+
-+            - Order strong 1.0
-+            - Code: ``'milstein'`` or ``1.0``
-+
-+        milstein-imp
-+            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
-+            scheme for the numerical simulation of stiff stochastic
-+            differential equations.
-+
-+            - Order strong 1.0
-+            - Code: ``'milstein-imp'``
-+
-+        predictor-corrector
-+            Generalization of the trapezoidal method to stochastic differential
-+            equations. More stable than explicit methods.  See eq. (5.4) of
-+            chapter 15.5 of [1]_.
-+
-+            - Order strong 0.5, weak 1.0
-+            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
-+              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
-+              ``'pc-euler'``
-+            - Codes to correct both the stochastic and deterministic parts
-+              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
-+              ``'pc-euler-2'`` or ``'pred-corr-2'``
-+
-+        platen
-+            Explicit scheme, creates the Milstein using finite differences
-+            instead of analytic derivatives. Also contains some higher order
-+            terms, thus converges better than Milstein while staying strong
-+            order 1.0.  Does not require derivatives, therefore usable by
-+            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
-+
-+            - Order strong 1.0, weak 2.0
-+            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
-+
-+        rouchon
-+            Scheme keeping the positivity of the density matrix
-+            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
-+
-+            - Order strong 1.0?
-+            - Code: ``'rouchon'`` or ``'Rouchon'``
-+
-+        taylor1.5
-+            Order 1.5 strong Taylor scheme.  Solver with more terms of the
-+            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-+            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
-+
-+            - Order strong 1.5
-+            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
-+
-+        taylor1.5-imp
-+            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
-+            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
-+            (2.18) of chapter 12.2 of [1]_.
-+
-+            - Order strong 1.5
-+            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
-+
-+        explicit1.5
-+            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
-+            Taylor scheme using finite difference instead of derivatives.
-+            Slower than ``taylor15`` but usable by
-+            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
-+            [1]_.
-+
-+            - Order strong 1.5
-+            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
-+
-+        taylor2.0
-+            Order 2 strong Taylor scheme.  Solver with more terms of the
-+            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
-+
-+            - Order strong 2.0
-+            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
-+
-+        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
-+        and for both heterodyne and homodyne. taylor2.0 only works for 1
-+        stochastic operator independent of time with the homodyne method.
-+        :func:`~general_stochastic` only accepts the derivative-free
-+        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
-+
-+    Available solvers for :obj:`~photocurrent_sesolve` and \
-+:obj:`~photocurrent_mesolve`
-+        Photocurrent use ordinary differential equations between
-+        stochastic "jump/collapse".
-+
-+        euler
-+            Euler method for ordinary differential equations between jumps.
-+            Only one jump per time interval.  Default solver.  See eqs. (4.19)
-+            and (4.4) of chapter 4 of [4]_.
-+
-+            - Order 1.0
-+            - Code: ``'euler'``
-+
-+        predictor–corrector
-+            predictor–corrector method (PECE) for ordinary differential
-+            equations.  Uses the Poisson distribution to obtain the number of
-+            jumps at each timestep.
-+
-+            - Order 2.0
-+            - Code: ``'pred-corr'``
-+
-+    References
-+    ----------
-+    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
-+       Stochastic Differential Equations*.
-+    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
-+       Systems*.
-+    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
-+       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
-+       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
-+       (2015).
-+    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
-+       control*.
-+    """
-+
-+
-+class StochasticSolverOptions:
-+    """Class of options for stochastic solvers such as
-+    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
-+
-+    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
-+    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
-+    :func:`qutip.stochastic.photocurrent_sesolve` and
-+    :func:`qutip.stochastic.photocurrent_mesolve`
-+    all take the same keyword arguments as
-+    the constructor of these class, and internally they use these arguments to
-+    construct an instance of this class, so it is rarely needed to explicitly
-+    create an instance of this class.
-+
-+    Within the attribute list, a ``time_dependent_object`` is either
-+
-+    - :class:`~qutip.Qobj`: a constant term
-+    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
-+      where the ``Qobj`` will be multiplied by the time-dependent scalar.
-+
-+    For more details on all allowed time-dependent objects, see the
-+    documentation for :class:`~qutip.QobjEvo`.
-+
-+    Attributes
-+    ----------
-+    H : time_dependent_object or list of time_dependent_object
-+        System Hamiltonian in standard time-dependent list format.  This is the
-+        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
-+        If this is a list of elements, they are summed.
-+
-+    state0 : :class:`qutip.Qobj`
-+        Initial state vector (ket) or density matrix.
-+
-+    times : array_like of float
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of time_dependent_object
-+        List of deterministic collapse operators.  Each element of the list is
-+        a separate operator; unlike the Hamiltonian, there is no implicit
-+        summation over the terms.
-+
-+    sc_ops : list of time_dependent_object
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the equation of motion according to how the d1 and d2 functions
-+        are defined.  Each element of the list is a separate operator, like
-+        ``c_ops``.
-+
-+    e_ops : list of :class:`qutip.Qobj`
-+        Single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    m_ops : list of :class:`qutip.Qobj`
-+        List of operators representing the measurement operators. The expected
-+        format is a nested list with one measurement operator for each
-+        stochastic increament, for each stochastic collapse operator.
-+
-+    args : dict
-+        Dictionary of parameters for time dependent systems.
-+
-+    tol : float
-+        Tolerance of the solver for implicit methods.
-+
-+    ntraj : int
-+        Number of trajectors.
-+
-+    nsubsteps : int
-+        Number of sub steps between each time-spep given in `times`.
-+
-+    dW_factors : array
-+        Array of length len(sc_ops), containing scaling factors for each
-+        measurement operator in m_ops.
-+
-+    solver : string
-+        Name of the solver method to use for solving the stochastic
-+        equations. Valid values are:
-+
-+        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
-+        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
-+        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
-+        - order 2 algorithms: 'taylor2.0'
-+
-+        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
-+        for a description of the solvers.  Implicit methods can adjust
-+        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
-+
-+    method : string ('homodyne', 'heterodyne')
-+        The name of the type of measurement process that give rise to the
-+        stochastic equation to solve.
-+
-+    store_all_expect : bool (default False)
-+        Whether or not to store the e_ops expect values for all paths.
-+
-+    store_measurement : bool (default False)
-+        Whether or not to store the measurement results in the
-+        :class:`qutip.solver.Result` instance returned by the solver.
-+
-+    noise : int, or 1D array of int, or 4D array of float
-+        - int : seed of the noise
-+        - 1D array : length = ntraj, seeds for each trajectories.
-+        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
-+          Vector for the noise, the len of the last dimensions is doubled for
-+          solvers of order 1.5. This corresponds to results.noise.
-+
-+    noiseDepth : int
-+        Number of terms kept of the truncated series used to create the
-+        noise used by taylor2.0 solver.
-+
-+    normalize : bool
-+        (default True for (photo)ssesolve, False for (photo)smesolve)
-+        Whether or not to normalize the wave function during the evolution.
-+        Normalizing density matrices introduce numerical errors.
-+
-+    options : :class:`qutip.solver.SolverOptions`
-+        Generic solver options. Only options['average_states'] and
-+        options['store_states'] are used.
-+
-+    map_func: function
-+        A map function or managing the calls to single-trajactory solvers.
-+
-+    map_kwargs: dictionary
-+        Optional keyword arguments to the map_func function function.
-+
-+    progress_bar : :class:`qutip.ui.BaseProgressBar`
-+        Optional progress bar class instance.
-+    """
-+    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
-+                 e_ops=[], m_ops=None, store_all_expect=False,
-+                 store_measurement=False, dW_factors=None,
-+                 solver=None, method="homodyne", normalize=None,
-+                 times=None, nsubsteps=1, ntraj=1, tol=None,
-+                 generate_noise=None, noise=None,
-+                 progress_bar=None, map_func=None, map_kwargs=None,
-+                 args={}, options=None, noiseDepth=20):
-+
-+        if options is None:
-+            options = SolverOptions()
-+
-+        if progress_bar is None:
-+            progress_bar = TextProgressBar()
-+
-+        # System
-+        # Cast to QobjEvo so the code has only one version for both the
-+        # constant and time-dependent case.
-+        self.me = me
-+
-+        if H is not None:
-+            msg = "The Hamiltonian format is not valid. "
-+            try:
-+                self.H = QobjEvo(H, args=args, tlist=times)
-+            except Exception as e:
-+                raise ValueError(msg + str(e)) from e
-+        else:
-+            self.H = H
-+
-+        if sc_ops:
-+            msg = ("The sc_ops format is not valid. Options are "
-+                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-+            try:
-+                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
-+                               for op in sc_ops]
-+            except Exception as e:
-+                raise ValueError(msg + str(e)) from e
-+        else:
-+            self.sc_ops = sc_ops
-+
-+        if c_ops:
-+            msg = ("The c_ops format is not valid. Options are "
-+                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-+            try:
-+                self.c_ops = [QobjEvo(op, args=args, tlist=times)
-+                              for op in c_ops]
-+            except Exception as e:
-+                raise ValueError(msg + str(e)) from e
-+        else:
-+            self.c_ops = c_ops
-+
-+        self.state0 = state0
-+        self.rho0 = stack_columns(state0.full()).ravel()
-+
-+        # Observation
-+
-+        for e_op in e_ops:
-+            if (
-+                isinstance(e_op, Qobj)
-+                and self.H is not None
-+                and e_op.dims[1] != self.H.dims[0]
-+            ):
-+                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
-+                                f"with the system's ({self.H.dims})")
-+        self.e_ops = e_ops
-+        self.m_ops = m_ops
-+        self.store_measurement = store_measurement
-+        self.store_all_expect = store_all_expect
-+        self.store_states = options['store_states']
-+        self.dW_factors = dW_factors
-+
-+        # Solver
-+        self.solver = solver
-+        self.method = method
-+        if normalize is None and me:
-+            self.normalize = 0
-+        elif normalize is None and not me:
-+            self.normalize = 1
-+        elif normalize:
-+            self.normalize = 1
-+        else:
-+            self.normalize = 0
-+
-+        self.times = times
-+        self.nsubsteps = nsubsteps
-+        self.dt = (times[1] - times[0]) / self.nsubsteps
-+        self.ntraj = ntraj
-+        if tol is not None:
-+            self.tol = tol
-+        elif "tol" in args:
-+            self.tol = args["tol"]
-+        else:
-+            self.tol = 1e-7
-+
-+        # Noise
-+        if noise is not None:
-+            if isinstance(noise, int):
-+                # noise contain a seed
-+                np.random.seed(noise)
-+                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-+            noise = np.array(noise)
-+            if len(noise.shape) == 1:
-+                if noise.shape[0] < ntraj:
-+                    raise ValueError("'noise' does not have enought seeds " +
-+                                     "len(noise) >= ntraj")
-+                # numpy seed must be between 0 and 2**32-1
-+                # 'u4': unsigned 32bit int
-+                self.noise = noise.astype("u4")
-+                self.noise_type = 0
-+
-+            elif len(noise.shape) == 4:
-+                # taylor case not included
-+                dw_len = (2 if method == "heterodyne" else 1)
-+                dw_len_str = (" * 2" if method == "heterodyne" else "")
-+                msg = "Incorrect shape for 'noise': "
-+                if noise.shape[0] < ntraj:
-+                    raise ValueError(msg + "shape[0] >= ntraj")
-+                if noise.shape[1] < len(times):
-+                    raise ValueError(msg + "shape[1] >= len(times)")
-+                if noise.shape[2] < nsubsteps:
-+                    raise ValueError(msg + "shape[2] >= nsubsteps")
-+                if noise.shape[3] < len(self.sc_ops) * dw_len:
-+                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
-+                                     dw_len_str)
-+                self.noise_type = 1
-+                self.noise = noise
-+
-+        else:
-+            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-+            self.noise_type = 0
-+
-+        # Map
-+        self.progress_bar = progress_bar
-+        if self.ntraj > 1 and map_func:
-+            self.map_func = map_func
-+        else:
-+            self.map_func = serial_map
-+        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-+
-+        # Other
-+        self.options = options
-+        self.args = args
-+        self.set_solver()
-+        self.p = noiseDepth
-+
-+    def set_solver(self):
-+        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
-+            self.solver_code = 50
-+            self.solver = 'euler-maruyama'
-+        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
-+            self.solver_code = 100
-+            self.solver = 'platen'
-+        elif self.solver in ['pred-corr', 'predictor-corrector',
-+                             'pc-euler', 101]:
-+            self.solver_code = 101
-+            self.solver = 'pred-corr'
-+        elif self.solver in ['milstein', 102, 1.0]:
-+            self.solver_code = 102
-+            self.solver = 'milstein'
-+        elif self.solver in ['milstein-imp', 103]:
-+            self.solver_code = 103
-+            self.solver = 'milstein-imp'
-+        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
-+            self.solver_code = 104
-+            self.solver = 'pred-corr-2'
-+        elif self.solver in ['Rouchon', 'rouchon', 120]:
-+            self.solver_code = 120
-+            self.solver = 'rouchon'
-+            if not all((op.isconstant for op in self.sc_ops)):
-+                raise ValueError("Rouchon only works with constant sc_ops")
-+        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
-+            self.solver_code = 150
-+            self.solver = 'explicit1.5'
-+        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
-+            self.solver_code = 152
-+            self.solver = 'taylor1.5'
-+        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
-+            self.solver_code = 153
-+            self.solver = 'taylor1.5-imp'
-+        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
-+            self.solver_code = 202
-+            self.solver = 'taylor2.0'
-+            if not len(self.sc_ops) == 1 or \
-+                    not self.sc_ops[0].isconstant or \
-+                    not self.method == "homodyne":
-+                raise ValueError(
-+                    "Taylor2.0 only works with 1 constant sc_ops and for"
-+                    " homodyne method"
-+                )
-+        else:
-+            known = [
-+                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
-+                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
-+                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
-+            ]
-+            raise ValueError("The solver should be one of {!r}".format(known))
-+
-+
-+class StochasticSolverOptionsPhoto(StochasticSolverOptions):
-+    """
-+    Attributes
-+    ----------
-+
-+    solver : string
-+        Name of the solver method to use for solving the evolution
-+        of the system.*
-+        order 1 algorithms: 'euler'
-+        order 2 algorithms: 'pred-corr'
-+        In photocurrent evolution
-+    """
-+    def set_solver(self):
-+        if self.solver in [None, 'euler', 1, 60]:
-+            self.solver_code = 60
-+            self.solver = 'euler'
-+        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
-+            self.solver_code = 110
-+            self.solver = 'pred-corr'
-+        else:
-+            raise Exception("The solver should be one of " +
-+                            "[None, 'euler', 'predictor-corrector']")
-+
-+
-+def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-+             _safe_mode=True, args={}, **kwargs):
-+    """
-+    Solve stochastic master equation. Dispatch to specific solvers
-+    depending on the value of the `solver` keyword argument.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`, or time dependent system.
-+        System Hamiltonian.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    rho0 : :class:`qutip.Qobj`
-+        Initial density matrix or state vector (ket).
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-+        Deterministic collapse operator which will contribute with a standard
-+        Lindblad type of dissipation.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the eqaution of motion according to how the d1 and d2 functions
-+        are defined.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    e_ops : list of :class:`qutip.Qobj`
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+
-+    """
-+    if "method" in kwargs and kwargs["method"] == "photocurrent":
-+        print("stochastic solver with photocurrent method has been moved to "
-+              "it's own function: photocurrent_mesolve")
-+        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
-+                                    e_ops=e_ops, _safe_mode=_safe_mode,
-+                                    args=args, **kwargs)
-+    if isket(rho0):
-+        rho0 = ket2dm(rho0)
-+
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = [e for e in e_ops.values()]
-+    else:
-+        e_ops_dict = None
-+
-+    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
-+                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-+                                  args=args, **kwargs)
-+
-+    if _safe_mode:
-+        _safety_checks(sso)
-+
-+    if sso.solver_code == 120:
-+        return _positive_map(sso, e_ops_dict)
-+
-+    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
-+    if sso.method == 'homodyne' or sso.method is None:
-+        if sso.m_ops is None:
-+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-+        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
-+        if not isinstance(sso.dW_factors, list):
-+            sso.dW_factors = [1] * len(sso.m_ops)
-+        elif len(sso.dW_factors) != len(sso.m_ops):
-+            raise Exception("The len of dW_factors is not the same as m_ops")
-+
-+    elif sso.method == 'heterodyne':
-+        if sso.m_ops is None:
-+            m_ops = []
-+        sso.sops = []
-+        for c in sso.sc_ops:
-+            if sso.m_ops is None:
-+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-+            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
-+                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
-+        sso.m_ops = m_ops
-+        if not isinstance(sso.dW_factors, list):
-+            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-+        elif len(sso.dW_factors) == len(sso.m_ops):
-+            pass
-+        elif len(sso.dW_factors) == len(sso.sc_ops):
-+            dW_factors = []
-+            for fact in sso.dW_factors:
-+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-+            sso.dW_factors = dW_factors
-+        elif len(sso.dW_factors) != len(sso.m_ops):
-+            raise Exception("The len of dW_factors is not the same as sc_ops")
-+
-+    elif sso.method == "photocurrent":
-+        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
-+
-+    else:
-+        raise Exception("The method must be one of None, homodyne, heterodyne")
-+
-+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-+
-+    if sso.solver_code in [103, 153]:
-+        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
-+
-+    sso.solver_obj = SMESolver
-+    sso.solver_name = "smesolve_" + sso.solver
-+
-+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+    return res
-+
-+
-+def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
-+             _safe_mode=True, args={}, **kwargs):
-+    """
-+    Solve stochastic schrodinger equation. Dispatch to specific solvers
-+    depending on the value of the `solver` keyword argument.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`, or time dependent system.
-+        System Hamiltonian.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    psi0 : :class:`qutip.Qobj`
-+        State vector (ket).
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the eqaution of motion according to how the d1 and d2 functions
-+        are defined.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    e_ops : list of :class:`qutip.Qobj`
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+    if "method" in kwargs and kwargs["method"] == "photocurrent":
-+        print("stochastic solver with photocurrent method has been moved to "
-+              "it's own function: photocurrent_sesolve")
-+        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
-+                                    e_ops=e_ops, _safe_mode=_safe_mode,
-+                                    args=args, **kwargs)
-+
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = [e for e in e_ops.values()]
-+    else:
-+        e_ops_dict = None
-+
-+    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
-+                                  sc_ops=sc_ops, e_ops=e_ops,
-+                                  args=args, **kwargs)
-+
-+    if _safe_mode:
-+        _safety_checks(sso)
-+
-+    if sso.solver_code == 120:
-+        raise Exception("rouchon only work with smesolve")
-+
-+    if sso.method == 'homodyne' or sso.method is None:
-+        if sso.m_ops is None:
-+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-+        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
-+        if not isinstance(sso.dW_factors, list):
-+            sso.dW_factors = [1] * len(sso.sops)
-+        elif len(sso.dW_factors) != len(sso.sops):
-+            raise Exception("The len of dW_factors is not the same as sc_ops")
-+
-+    elif sso.method == 'heterodyne':
-+        if sso.m_ops is None:
-+            m_ops = []
-+        sso.sops = []
-+        for c in sso.sc_ops:
-+            if sso.m_ops is None:
-+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-+            c1 = c / np.sqrt(2)
-+            c2 = c * (-1j / np.sqrt(2))
-+            sso.sops += [[c1, c1 + c1.dag()],
-+                         [c2, c2 + c2.dag()]]
-+        sso.m_ops = m_ops
-+        if not isinstance(sso.dW_factors, list):
-+            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-+        elif len(sso.dW_factors) == len(sso.sc_ops):
-+            dW_factors = []
-+            for fact in sso.dW_factors:
-+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-+            sso.dW_factors = dW_factors
-+        elif len(sso.dW_factors) != len(sso.sops):
-+            raise Exception("The len of dW_factors is not the same as sc_ops")
-+
-+    elif sso.method == "photocurrent":
-+        NotImplementedError("Moved to 'photocurrent_sesolve'")
-+
-+    else:
-+        raise Exception("The method must be one of None, homodyne, heterodyne")
-+
-+    sso.LH = sso.H * (-1j * sso.dt)
-+    for ops in sso.sops:
-+        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
-+
-+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-+    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-+
-+    sso.solver_obj = SSESolver
-+    sso.solver_name = "ssesolve_" + sso.solver
-+
-+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+
-+    return res
-+
-+
-+def _positive_map(sso, e_ops_dict):
-+    if sso.method == 'homodyne' or sso.method is None:
-+        sops = sso.sc_ops
-+        if sso.m_ops is None:
-+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-+        if not isinstance(sso.dW_factors, list):
-+            sso.dW_factors = [1] * len(sops)
-+        elif len(sso.dW_factors) != len(sops):
-+            raise Exception("The len of dW_factors is not the same as sc_ops")
-+
-+    elif sso.method == 'heterodyne':
-+        if sso.m_ops is None:
-+            m_ops = []
-+        sops = []
-+        for c in sso.sc_ops:
-+            if sso.m_ops is None:
-+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-+            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
-+        sso.m_ops = m_ops
-+        if not isinstance(sso.dW_factors, list):
-+            sso.dW_factors = [np.sqrt(2)] * len(sops)
-+        elif len(sso.dW_factors) == len(sso.sc_ops):
-+            dW_factors = []
-+            for fact in sso.dW_factors:
-+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-+            sso.dW_factors = dW_factors
-+        elif len(sso.dW_factors) != len(sops):
-+            raise Exception("The len of dW_factors is not the same as sc_ops")
-+    else:
-+        raise Exception("The method must be one of homodyne or heterodyne")
-+
-+    LH = 1 - (sso.H * 1j * sso.dt)
-+    sso.pp = spre(sso.H) * 0
-+    sso.sops = []
-+    sso.preops = []
-+    sso.postops = []
-+    sso.preops2 = []
-+    sso.postops2 = []
-+
-+    def _prespostdag(op):
-+        return spre(op) * spost(op.dag())
-+
-+    for op in sso.c_ops:
-+        LH += op.dag() @ op * (-sso.dt * 0.5)
-+        sso.pp += spre(op) * spost(op.dag()) * sso.dt
-+
-+    for i, op in enumerate(sops):
-+        LH += (-sso.dt * 0.5) * op.dag() @ op
-+        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
-+        sso.preops += [spre(op)]
-+        sso.postops += [spost(op.dag())]
-+        for op2 in sops[i:]:
-+            sso.preops2 += [spre(op * op2)]
-+            sso.postops2 += [spost(op.dag() * op2.dag())]
-+
-+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-+    sso.preLH = spre(LH)
-+    sso.postLH = spost(LH.dag())
-+
-+    sso.solver_obj = PmSMESolver
-+    sso.solver_name = "smesolve_" + sso.solver
-+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+
-+    return res
-+
-+
-+def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-+                         _safe_mode=True, args={}, **kwargs):
-+    """
-+    Solve stochastic master equation using the photocurrent method.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`, or time dependent system.
-+        System Hamiltonian.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    rho0 : :class:`qutip.Qobj`
-+        Initial density matrix or state vector (ket).
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-+        Deterministic collapse operator which will contribute with a standard
-+        Lindblad type of dissipation.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the eqaution of motion according to how the d1 and d2 functions
-+        are defined.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function single
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+    if isket(rho0):
-+        rho0 = ket2dm(rho0)
-+
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = [e for e in e_ops.values()]
-+    else:
-+        e_ops_dict = None
-+
-+    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
-+                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-+                                       args=args, **kwargs)
-+
-+    if _safe_mode:
-+        _safety_checks(sso)
-+
-+    if sso.m_ops is None:
-+        sso.m_ops = [op * 0 for op in sso.sc_ops]
-+    if not isinstance(sso.dW_factors, list):
-+        sso.dW_factors = [1] * len(sso.sc_ops)
-+    elif len(sso.dW_factors) != len(sso.sc_ops):
-+        raise Exception("The len of dW_factors is not the same as sc_ops")
-+
-+    sso.solver_obj = PcSMESolver
-+    sso.solver_name = "photocurrent_mesolve"
-+    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
-+
-+    def _prespostdag(op):
-+        return spre(op) * spost(op.dag())
-+
-+    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
-+                 spre(op.dag() @ op),
-+                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
-+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-+
-+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-+    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+
-+    return res
-+
-+
-+def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
-+                         _safe_mode=True, args={}, **kwargs):
-+    """
-+    Solve stochastic schrodinger equation using the photocurrent method.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`, or time dependent system.
-+        System Hamiltonian.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    psi0 : :class:`qutip.Qobj`
-+        Initial state vector (ket).
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the eqaution of motion according to how the d1 and d2 functions
-+        are defined.
-+        Can depend on time, see StochasticSolverOptions help for format.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function single
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = list(e_ops.values())
-+    else:
-+        e_ops_dict = None
-+
-+    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
-+                                       sc_ops=sc_ops, e_ops=e_ops,
-+                                       args=args, **kwargs)
-+
-+    if _safe_mode:
-+        _safety_checks(sso)
-+
-+    if sso.m_ops is None:
-+        sso.m_ops = [op * 0 for op in sso.sc_ops]
-+    if not isinstance(sso.dW_factors, list):
-+        sso.dW_factors = [1] * len(sso.sc_ops)
-+    elif len(sso.dW_factors) != len(sso.sc_ops):
-+        raise Exception("The len of dW_factors is not the same as sc_ops")
-+
-+    sso.solver_obj = PcSSESolver
-+    sso.solver_name = "photocurrent_sesolve"
-+    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
-+    sso.LH = sso.H * (-1j*sso.dt)
-+    for ops in sso.sops:
-+        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
-+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-+    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-+
-+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-+    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+
-+    return res
-+
-+
-+def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
-+                       _safe_mode=True, len_d2=1, args={}, **kwargs):
-+    """
-+    Solve stochastic general equation. Dispatch to specific solvers
-+    depending on the value of the `solver` keyword argument.
-+
-+
-+    Parameters
-+    ----------
-+
-+    state0 : :class:`qutip.Qobj`
-+        Initial state vector (ket) or density matrix as a vector.
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    d1 : function, callable class
-+        Function representing the deterministic evolution of the system.
-+
-+        def d1(time (double), state (as a np.array vector)):
-+            return 1d np.array
-+
-+    d2 : function, callable class
-+        Function representing the stochastic evolution of the system.
-+
-+        def d2(time (double), state (as a np.array vector)):
-+            return 2d np.array (N_sc_ops, len(state0))
-+
-+    len_d2 : int
-+        Number of output vector produced by d2
-+
-+    e_ops : list of :class:`qutip.Qobj`
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+        Must be a superoperator if the state vector is a density matrix.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+        An instance of the class :class:`qutip.solver.Result`.
-+    """
-+
-+    if isinstance(e_ops, dict):
-+        e_ops_dict = e_ops
-+        e_ops = [e for e in e_ops.values()]
-+    else:
-+        e_ops_dict = None
-+
-+    if "solver" not in kwargs:
-+        kwargs["solver"] = 50
-+
-+    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
-+                                  e_ops=e_ops, args=args, **kwargs)
-+    if sso.solver_code not in [50, 100, 150]:
-+        raise ValueError("Only Euler, platen, platen15 can be " +
-+                         "used for the general stochastic solver.")
-+
-+    sso.d1 = d1
-+    sso.d2 = d2
-+    if _safe_mode:
-+        # This state0_vec is computed as stack_columns(state0.full()).ravel()
-+        # in the sso init.
-+        state0_vec = sso.rho0
-+        l_vec = state0_vec.shape[0]
-+        try:
-+            out_d1 = d1(0., sso.rho0)
-+        except Exception as e:
-+            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
-+                               str(e)) from e
-+        try:
-+            out_d2 = d2(0., sso.rho0)
-+        except Exception as e:
-+            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
-+                               str(e)) from e
-+
-+        msg_d1 = ("d1 must return an 1d numpy array with the same number "
-+                  "of elements as the initial state as a vector.")
-+        if not isinstance(out_d1, np.ndarray):
-+            raise TypeError(msg_d1)
-+        if (out_d1.ndim != 1
-+                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
-+            raise ValueError(msg_d1)
-+
-+        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
-+                  "with the shape (len_d2, len(state0_vec) ).")
-+        if not isinstance(out_d2, np.ndarray):
-+            raise TypeError(msg_d2)
-+        if (out_d2.ndim != 2
-+                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
-+            raise ValueError(msg_d2)
-+        if out_d1.dtype != np.dtype('complex128') or \
-+           out_d2.dtype != np.dtype('complex128'):
-+            raise ValueError("Safety check: d1 and d2 must return " +
-+                             "complex numpy array.")
-+        msg_e_ops = ("Safety check: The shape of the e_ops "
-+                     "does not fit the intial state.")
-+        for op in sso.e_ops:
-+            shape_op = op.shape
-+            if sso.me:
-+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-+                    raise ValueError(msg_e_ops)
-+            else:
-+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                    raise ValueError(msg_e_ops +
-+                                     " Expecting e_ops as superoperators.")
-+
-+    sso.m_ops = []
-+    sso.cm_ops = []
-+    if sso.store_measurement:
-+        if not m_ops:
-+            raise ValueError("General stochastic needs explicit " +
-+                             "m_ops to store measurement.")
-+        sso.m_ops = m_ops
-+        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-+        if sso.dW_factors is None:
-+            sso.dW_factors = [1.] * len(sso.m_ops)
-+        elif len(sso.dW_factors) == 1:
-+            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
-+        elif len(sso.dW_factors) != len(sso.m_ops):
-+            raise ValueError("The number of dW_factors must fit" +
-+                             " the number of m_ops.")
-+
-+    if sso.dW_factors is None:
-+        sso.dW_factors = [1.] * len_d2
-+    sso.sops = [None] * len_d2
-+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-+
-+    sso.solver_obj = GenericSSolver
-+    sso.solver_name = "general_stochastic_solver_" + sso.solver
-+
-+    ssolver = GenericSSolver()
-+    # ssolver.set_data(sso)
-+    ssolver.set_solver(sso)
-+
-+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-+
-+    if e_ops_dict:
-+        res.expect = {e: res.expect[n]
-+                      for n, e in enumerate(e_ops_dict.keys())}
-+
-+    return res
-+
-+
-+def _safety_checks(sso):
-+    l_vec = sso.rho0.shape[0]
-+    if sso.H.issuper:
-+        if not sso.me:
-+            raise ValueError(
-+                "Given a Liouvillian for a Schrödinger equation problem."
-+            )
-+        shape_op = sso.H.shape
-+        if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+            raise Exception("The size of the hamiltonian does "
-+                            "not fit the intial state")
-+    else:
-+        shape_op = sso.H.shape
-+        if sso.me:
-+            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-+                raise Exception("The size of the hamiltonian does "
-+                                "not fit the intial state")
-+        else:
-+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                raise Exception("The size of the hamiltonian does "
-+                                "not fit the intial state")
-+
-+    for op in sso.sc_ops:
-+        if op.issuper:
-+            if not sso.me:
-+                raise ValueError(
-+                    "Given a Liouvillian for a Schrödinger equation problem."
-+                )
-+            shape_op = op.shape
-+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                raise Exception("The size of the sc_ops does "
-+                                "not fit the intial state")
-+        else:
-+            shape_op = op.shape
-+            if sso.me:
-+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-+                    raise Exception("The size of the sc_ops does "
-+                                    "not fit the intial state")
-+            else:
-+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                    raise Exception("The size of the sc_ops does "
-+                                    "not fit the intial state")
-+
-+    for op in sso.c_ops:
-+        if op.issuper:
-+            if not sso.me:
-+                raise ValueError(
-+                    "Given a Liouvillian for a Schrödinger equation problem."
-+                )
-+            shape_op = op.shape
-+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                raise Exception("The size of the c_ops does "
-+                                "not fit the intial state")
-+        else:
-+            shape_op = op.shape
-+            if sso.me:
-+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-+                    raise Exception("The size of the c_ops does "
-+                                    "not fit the intial state")
-+            else:
-+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                    raise Exception("The size of the c_ops does "
-+                                    "not fit the intial state")
-+
-+    for op in sso.e_ops:
-+        shape_op = op.shape
-+        if sso.me:
-+            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-+                raise Exception("The size of the e_ops does "
-+                                "not fit the intial state")
-+        else:
-+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                raise Exception("The size of the e_ops does "
-+                                "not fit the intial state")
-+
-+    if sso.m_ops is not None:
-+        for op in sso.m_ops:
-+            shape_op = op.shape
-+            if sso.me:
-+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-+                    raise Exception("The size of the m_ops does "
-+                                    "not fit the intial state")
-+            else:
-+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-+                    raise Exception("The size of the m_ops does "
-+                                    "not fit the intial state")
-+
-+
-+def _sesolve_generic(sso, options, progress_bar):
-+    """
-+    Internal function. See smesolve.
-+    """
-+    res = Result()
-+    res.times = sso.times
-+    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-+    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-+    res.measurement = []
-+    res.solver = sso.solver_name
-+    res.ntraj = sso.ntraj
-+    res.num_expect = len(sso.e_ops)
-+
-+    nt = sso.ntraj
-+    task = _single_trajectory
-+    map_kwargs = {'progress_bar': sso.progress_bar}
-+    map_kwargs.update(sso.map_kwargs)
-+    task_args = (sso,)
-+    task_kwargs = {}
-+
-+    results = sso.map_func(task, list(range(sso.ntraj)),
-+                           task_args, task_kwargs, **map_kwargs)
-+    noise = []
-+    for result in results:
-+        states_list, dW, m, expect = result
-+        res.states.append(states_list)
-+        noise.append(dW)
-+        res.measurement.append(m)
-+        res.expect += expect
-+        res.ss += expect * expect
-+    res.noise = np.stack(noise)
-+
-+    if sso.store_all_expect:
-+        paths_expect = []
-+        for result in results:
-+            paths_expect.append(result[3])
-+        res.runs_expect = np.stack(paths_expect)
-+
-+    # average density matrices (vectorized maybe)
-+    # ajgpitch 2019-10-25: np.any(res.states) seems to error
-+    # I guess there may be a potential exception if there are no states?
-+    # store individual trajectory states
-+    res.traj_states = res.states
-+    res.avg_states = None
-+    if options['average_states'] and options['store_states']:
-+        avg_states_list = []
-+        for n in range(len(res.times)):
-+            tslot_states = [res.states[mm][n].data for mm in range(nt)]
-+            if len(tslot_states) > 0:
-+                state = Qobj(np.sum(tslot_states),
-+                             dims=res.states[0][n].dims).unit()
-+                avg_states_list.append(state)
-+        # store average states
-+        res.states = res.avg_states = avg_states_list
-+
-+    # average
-+    res.expect = res.expect / nt
-+
-+    # standard error
-+    if nt > 1:
-+        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
-+    else:
-+        res.se = None
-+
-+    # convert complex data to real if hermitian
-+    res.expect = [np.real(res.expect[n, :])
-+                  if e.isherm else res.expect[n, :]
-+                  for n, e in enumerate(sso.e_ops)]
-+
-+    return res
-+
-+
-+def _single_trajectory(i, sso):
-+    # Only one step?
-+    ssolver = sso.solver_obj()
-+    ssolver.set_solver(sso)
-+    result = ssolver.cy_sesolve_single_trajectory(i)
-+    return result
-+
-+
-+# The code for ssepdpsolve have been moved to the file pdpsolve.
-+# The call is still in stochastic for consistance.
-+def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-+    """
-+    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-+    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-+    trajectory simulations.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`
-+        System Hamiltonian.
-+
-+    psi0 : :class:`qutip.Qobj`
-+        Initial state vector (ket).
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`
-+        Deterministic collapse operator which will contribute with a standard
-+        Lindblad type of dissipation.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function single
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+
-+    """
-+    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
-+
-+
-+# The code for smepdpsolve have been moved to the file pdpsolve.
-+# The call is still in stochastic for consistance.
-+def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-+    """
-+    A stochastic (piecewse deterministic process) PDP solver for density matrix
-+    evolution.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`qutip.Qobj`
-+        System Hamiltonian.
-+
-+    rho0 : :class:`qutip.Qobj`
-+        Initial density matrix.
-+
-+    times : *list* / *array*
-+        List of times for :math:`t`. Must be uniformly spaced.
-+
-+    c_ops : list of :class:`qutip.Qobj`
-+        Deterministic collapse operator which will contribute with a standard
-+        Lindblad type of dissipation.
-+
-+    sc_ops : list of :class:`qutip.Qobj`
-+        List of stochastic collapse operators. Each stochastic collapse
-+        operator will give a deterministic and stochastic contribution
-+        to the eqaution of motion according to how the d1 and d2 functions
-+        are defined.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function single
-+        single operator or list of operators for which to evaluate
-+        expectation values.
-+
-+    kwargs : *dictionary*
-+        Optional keyword arguments. See
-+        :class:`qutip.stochastic.StochasticSolverOptions`.
-+
-+    Returns
-+    -------
-+
-+    output: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`.
-+
-+    """
-+    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
-diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
-index 99d84ccd..0512198f 100644
---- a/qutip/solver/__init__.py
-+++ b/qutip/solver/__init__.py
-@@ -1,18 +1,18 @@
--from .result import *
--from .options import *
--import qutip.solver.integrator
--from .integrator import IntegratorException
--from .sesolve import *
--from .mesolve import *
--from .mcsolve import *
--from .propagator import *
--from .scattering import *
--from .correlation import *
--from .spectrum import *
--from .floquet import *
--from .floquet_bwcomp import *
--from .steadystate import *
--from .countstat import *
--from .brmesolve import *
--from .krylovsolve import *
--from .parallel import *
-+from .result import *
-+from .options import *
-+import qutip.solver.integrator
-+from .integrator import IntegratorException
-+from .sesolve import *
-+from .mesolve import *
-+from .mcsolve import *
-+from .propagator import *
-+from .scattering import *
-+from .correlation import *
-+from .spectrum import *
-+from .floquet import *
-+from .floquet_bwcomp import *
-+from .steadystate import *
-+from .countstat import *
-+from .brmesolve import *
-+from .krylovsolve import *
-+from .parallel import *
-diff --git a/qutip/solver/brmesolve.py b/qutip/solver/brmesolve.py
-index 7bfc8b27..8da77494 100644
---- a/qutip/solver/brmesolve.py
-+++ b/qutip/solver/brmesolve.py
-@@ -1,362 +1,362 @@
--"""
--This module provides solvers for the Lindblad master equation and von Neumann
--equation.
--"""
--
--__all__ = ['brmesolve', 'BRSolver']
--
--import numpy as np
--import inspect
--from time import time
--from .. import Qobj, QobjEvo, coefficient, Coefficient
--from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
--from ..core.cy.coefficient import InterCoefficient
--from ..core import data as _data
--from .solver_base import Solver
--from .options import _SolverOptions
--
--
--def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
--              args={}, sec_cutoff=0.1, options=None):
--    """
--    Solves for the dynamics of a system using the Bloch-Redfield master
--    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
--    their associated spectral functions, as well as possible Lindblad collapse
--    operators.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    psi0: Qobj
--        Initial density matrix or state vector (ket).
--
--    tlist : array_like
--        List of times for evaluating evolution
--
--    a_ops : list of (a_op, spectra)
--        Nested list of system operators that couple to the environment,
--        and the corresponding bath spectra.
--
--        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
--            The operator coupling to the environment. Must be hermitian.
--
--        spectra : :class:`Coefficient`, str, func
--            The corresponding bath spectral responce.
--            Can be a `Coefficient` using an 'w' args, a function of the
--            frequence or a string. Coefficient build from a numpy array are
--            understood as a function of ``w`` instead of ``t``. Function are
--            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
--
--            The spectra function can depend on ``t`` if the corresponding
--            ``a_op`` is a :class:`QobjEvo`.
--
--        Example:
--
--        .. code-block::
--
--            a_ops = [
--                (a+a.dag(), ('w>0', args={"w": 0})),
--                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
--                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
--                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
--            ]
--
--        .. note:
--            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
--                ``spline = qutip.coefficient(array, tlist=times)``
--
--            Whether the ``a_ops`` is time dependent is decided by the type of
--            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
--            of the spectra.
--
--    e_ops : list of :class:`Qobj` / callback function
--        Single operator or list of operators for which to evaluate
--        expectation values or callable or list of callable.
--        Callable signature must be, `f(t: float, state: Qobj)`.
--        See :func:`expect` for more detail of operator expectation
--
--    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
--        List of collapse operators.
--
--    args : dict
--        Dictionary of parameters for time-dependent Hamiltonians and
--        collapse operators. The key ``w`` is reserved for the spectra function.
--
--    sec_cutoff : float {0.1}
--        Cutoff for secular approximation. Use ``-1`` if secular approximation
--        is not used when evaluating bath-coupling terms.
--
--    options : None / dict
--        Dictionary of options for the solver.
--
--        - store_final_state : bool
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, None
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - normalize_output : bool
--          Normalize output state to hide ODE numerical errors.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - tensor_type : str ['sparse', 'dense', 'data']
--          Which data type to use when computing the brtensor.
--          With a cutoff 'sparse' is usually the most efficient.
--        - sparse_eigensolver : bool {False}
--          Whether to use the sparse eigensolver
--        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
--          Which differential equation integration method to use.
--        - atol, rtol : float
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps :
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - max_step : float, 0
--          Maximum lenght of one internal step. When using pulses, it should be
--          less than half the width of the thinnest pulse.
--
--        Other options could be supported depending on the integration method,
--        see `Integrator <./classes.html#classes-ode>`_.
--
--    Returns
--    -------
--    result: :class:`qutip.solver.Result`
--
--        An instance of the class :class:`qutip.solver.Result`, which contains
--        either an array of expectation values, for operators given in e_ops,
--        or a list of states for the times specified by `tlist`.
--
--    .. note:
--        The option ``operator_data_type`` is used to determine in which format
--        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
--        for dense array. With 'data', it will try to use the same data type as
--        the ``a_ops``, but it is usually less efficient than manually choosing
--        it.
--    """
--    H = QobjEvo(H, args=args, tlist=tlist)
--
--    c_ops = c_ops if c_ops is not None else []
--    if not isinstance(c_ops, (list, tuple)):
--        c_ops = [c_ops]
--    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
--
--    new_a_ops = []
--    for (a_op, spectra) in a_ops:
--        aop = QobjEvo(a_op, args=args, tlist=tlist)
--        if isinstance(spectra, str):
--            new_a_ops.append(
--                (aop, coefficient(spectra, args={**args, 'w':0})))
--        elif isinstance(spectra, InterCoefficient):
--            new_a_ops.append((aop, SpectraCoefficient(spectra)))
--        elif isinstance(spectra, Coefficient):
--            new_a_ops.append((aop, spectra))
--        elif callable(spectra):
--            sig = inspect.signature(spectra)
--            if tuple(sig.parameters.keys()) == ("w",):
--                spec = SpectraCoefficient(coefficient(spectra))
--            else:
--                spec = coefficient(spectra, args={**args, 'w':0})
--            new_a_ops.append((aop, spec))
--        else:
--            raise TypeError("a_ops's spectra not known")
--
--    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
--
--    return solver.run(psi0, tlist, e_ops=e_ops)
--
--
--class BRSolver(Solver):
--    """
--    Bloch Redfield equation evolution of a density matrix for a given
--    Hamiltonian and set of bath coupling operators.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    a_ops : list of (a_op, spectra)
--        Nested list of system operators that couple to the environment,
--        and the corresponding bath spectra.
--
--        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
--            The operator coupling to the environment. Must be hermitian.
--
--        spectra : :class:`Coefficient`
--            The corresponding bath spectra. As a `Coefficient` using an 'w'
--            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
--            :class:`SpectraCoefficient` can be used to conver a coefficient
--            depending on ``t`` to one depending on ``w``.
--
--        Example:
--
--        .. code-block::
--
--            a_ops = [
--                (a+a.dag(), coefficient('w>0', args={'w':0})),
--                (QobjEvo([b+b.dag(), lambda t: ...]),
--                 coefficient(lambda t, w: ...), args={"w": 0}),
--                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
--            ]
--
--    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
--        Single collapse operator, or list of collapse operators, or a list
--        of Lindblad dissipator. None is equivalent to an empty list.
--
--    options : dict, optional
--        Options for the solver, see :obj:`BRSolver.options` and
--        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
--
--    sec_cutoff : float {0.1}
--        Cutoff for secular approximation. Use ``-1`` if secular approximation
--        is not used when evaluating bath-coupling terms.
--
--    attributes
--    ----------
--    stats: dict
--        Diverse diagnostic statistics of the evolution.
--    """
--    name = "brmesolve"
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size":10},
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": False,
--        'method': 'adams',
--        'tensor_type': 'sparse',
--        'sparse_eigensolver': False,
--    }
--    _avail_integrators = {}
--
--    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
--        _time_start = time()
--
--        self.rhs = None
--        self.sec_cutoff = sec_cutoff
--        self.options = options
--
--        if not isinstance(H, (Qobj, QobjEvo)):
--            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
--        H = QobjEvo(H)
--
--        c_ops = c_ops or []
--        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
--        for c_op in c_ops:
--            if not isinstance(c_op, (Qobj, QobjEvo)):
--                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
--
--        a_ops = a_ops or []
--        if not hasattr(a_ops, "__iter__"):
--            TypeError("`a_ops` must be a list of (operator, spectra)")
--        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
--            a_ops = [a_ops]
--        for oper, spectra in a_ops:
--            if not isinstance(oper, (Qobj, QobjEvo)):
--                raise TypeError("All `a_ops` operators "
--                                "must be a Qobj or QobjEvo")
--            if not isinstance(spectra, Coefficient):
--                raise TypeError("All `a_ops` spectra "
--                                "must be a Coefficient.")
--
--        self._system = H, a_ops, c_ops
--        self._num_collapse = len(c_ops)
--        self._num_a_ops = len(a_ops)
--        self.rhs = self._prepare_rhs()
--        self._integrator = self._get_integrator()
--        self._state_metadata = {}
--        self.stats = self._initialize_stats()
--
--
--    def _initialize_stats(self):
--        stats = super()._initialize_stats()
--        stats.update({
--            "solver": "Bloch Redfield Equation Evolution",
--            "init time": stats["init time"] + self._init_rhs_time,
--            "num_collapse": self._num_collapse,
--            "num_a_ops": self._num_a_ops,
--        })
--        return stats
--
--    def _prepare_rhs(self):
--        _time_start = time()
--        rhs = bloch_redfield_tensor(
--            *self._system,
--            fock_basis=True,
--            sec_cutoff=self.sec_cutoff,
--            sparse_eigensolver=self.options['sparse_eigensolver'],
--            br_dtype=self.options['tensor_type']
--        )
--        self._init_rhs_time = time() - _time_start
--        return rhs
--
--    @property
--    def options(self):
--        """
--        Options for bloch redfield solver:
--
--        store_final_state: bool, default=False
--            Whether or not to store the final state of the evolution in the
--            result class.
--
--        store_states: bool, default=None
--            Whether or not to store the state vectors or density matrices.
--            On `None` the states will be saved if no expectation operators are
--            given.
--
--        normalize_output: bool, default=False
--            Normalize output state to hide ODE numerical errors.
--
--        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
--            How to present the solver progress.
--            'tqdm' uses the python module of the same name and raise an error if
--            not installed. Empty string or False will disable the bar.
--
--        progress_kwargs: dict, default={"chunk_size":10}
--            Arguments to pass to the progress_bar. Qutip's bars use
--            ``chunk_size``.
--
--        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
--            Which data type to use when computing the brtensor.
--            With a cutoff 'sparse' is usually the most efficient.
--
--        sparse_eigensolver: bool, default=False
--            Whether to use the sparse eigensolver
--
--        method: str, default="adams"
--            Which ODE integrator methods are supported.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Solver.options.fset(self, new_options)
--
--    def _apply_options(self, keys):
--        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
--        need_new_rhs &= (
--            'sparse_eigensolver' in keys or 'tensor_type' in keys
--        )
--        if need_new_rhs:
--            self.rhs = self._prepare_rhs()
--
--        if self._integrator is None or not keys:
--            pass
--        elif 'method' in keys or need_new_rhs:
--            state = self._integrator.get_state()
--            self._integrator = self._get_integrator()
--            self._integrator.set_state(*state)
--        else:
--            self._integrator.options = self._options
--            self._integrator.reset(hard=True)
-+"""
-+This module provides solvers for the Lindblad master equation and von Neumann
-+equation.
-+"""
-+
-+__all__ = ['brmesolve', 'BRSolver']
-+
-+import numpy as np
-+import inspect
-+from time import time
-+from .. import Qobj, QobjEvo, coefficient, Coefficient
-+from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
-+from ..core.cy.coefficient import InterCoefficient
-+from ..core import data as _data
-+from .solver_base import Solver
-+from .options import _SolverOptions
-+
-+
-+def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
-+              args={}, sec_cutoff=0.1, options=None):
-+    """
-+    Solves for the dynamics of a system using the Bloch-Redfield master
-+    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
-+    their associated spectral functions, as well as possible Lindblad collapse
-+    operators.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    psi0: Qobj
-+        Initial density matrix or state vector (ket).
-+
-+    tlist : array_like
-+        List of times for evaluating evolution
-+
-+    a_ops : list of (a_op, spectra)
-+        Nested list of system operators that couple to the environment,
-+        and the corresponding bath spectra.
-+
-+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-+            The operator coupling to the environment. Must be hermitian.
-+
-+        spectra : :class:`Coefficient`, str, func
-+            The corresponding bath spectral responce.
-+            Can be a `Coefficient` using an 'w' args, a function of the
-+            frequence or a string. Coefficient build from a numpy array are
-+            understood as a function of ``w`` instead of ``t``. Function are
-+            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
-+
-+            The spectra function can depend on ``t`` if the corresponding
-+            ``a_op`` is a :class:`QobjEvo`.
-+
-+        Example:
-+
-+        .. code-block::
-+
-+            a_ops = [
-+                (a+a.dag(), ('w>0', args={"w": 0})),
-+                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
-+                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
-+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-+            ]
-+
-+        .. note:
-+            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
-+                ``spline = qutip.coefficient(array, tlist=times)``
-+
-+            Whether the ``a_ops`` is time dependent is decided by the type of
-+            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
-+            of the spectra.
-+
-+    e_ops : list of :class:`Qobj` / callback function
-+        Single operator or list of operators for which to evaluate
-+        expectation values or callable or list of callable.
-+        Callable signature must be, `f(t: float, state: Qobj)`.
-+        See :func:`expect` for more detail of operator expectation
-+
-+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
-+        List of collapse operators.
-+
-+    args : dict
-+        Dictionary of parameters for time-dependent Hamiltonians and
-+        collapse operators. The key ``w`` is reserved for the spectra function.
-+
-+    sec_cutoff : float {0.1}
-+        Cutoff for secular approximation. Use ``-1`` if secular approximation
-+        is not used when evaluating bath-coupling terms.
-+
-+    options : None / dict
-+        Dictionary of options for the solver.
-+
-+        - store_final_state : bool
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, None
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - normalize_output : bool
-+          Normalize output state to hide ODE numerical errors.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - tensor_type : str ['sparse', 'dense', 'data']
-+          Which data type to use when computing the brtensor.
-+          With a cutoff 'sparse' is usually the most efficient.
-+        - sparse_eigensolver : bool {False}
-+          Whether to use the sparse eigensolver
-+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-+          Which differential equation integration method to use.
-+        - atol, rtol : float
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps :
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - max_step : float, 0
-+          Maximum lenght of one internal step. When using pulses, it should be
-+          less than half the width of the thinnest pulse.
-+
-+        Other options could be supported depending on the integration method,
-+        see `Integrator <./classes.html#classes-ode>`_.
-+
-+    Returns
-+    -------
-+    result: :class:`qutip.solver.Result`
-+
-+        An instance of the class :class:`qutip.solver.Result`, which contains
-+        either an array of expectation values, for operators given in e_ops,
-+        or a list of states for the times specified by `tlist`.
-+
-+    .. note:
-+        The option ``operator_data_type`` is used to determine in which format
-+        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
-+        for dense array. With 'data', it will try to use the same data type as
-+        the ``a_ops``, but it is usually less efficient than manually choosing
-+        it.
-+    """
-+    H = QobjEvo(H, args=args, tlist=tlist)
-+
-+    c_ops = c_ops if c_ops is not None else []
-+    if not isinstance(c_ops, (list, tuple)):
-+        c_ops = [c_ops]
-+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-+
-+    new_a_ops = []
-+    for (a_op, spectra) in a_ops:
-+        aop = QobjEvo(a_op, args=args, tlist=tlist)
-+        if isinstance(spectra, str):
-+            new_a_ops.append(
-+                (aop, coefficient(spectra, args={**args, 'w':0})))
-+        elif isinstance(spectra, InterCoefficient):
-+            new_a_ops.append((aop, SpectraCoefficient(spectra)))
-+        elif isinstance(spectra, Coefficient):
-+            new_a_ops.append((aop, spectra))
-+        elif callable(spectra):
-+            sig = inspect.signature(spectra)
-+            if tuple(sig.parameters.keys()) == ("w",):
-+                spec = SpectraCoefficient(coefficient(spectra))
-+            else:
-+                spec = coefficient(spectra, args={**args, 'w':0})
-+            new_a_ops.append((aop, spec))
-+        else:
-+            raise TypeError("a_ops's spectra not known")
-+
-+    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
-+
-+    return solver.run(psi0, tlist, e_ops=e_ops)
-+
-+
-+class BRSolver(Solver):
-+    """
-+    Bloch Redfield equation evolution of a density matrix for a given
-+    Hamiltonian and set of bath coupling operators.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    a_ops : list of (a_op, spectra)
-+        Nested list of system operators that couple to the environment,
-+        and the corresponding bath spectra.
-+
-+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-+            The operator coupling to the environment. Must be hermitian.
-+
-+        spectra : :class:`Coefficient`
-+            The corresponding bath spectra. As a `Coefficient` using an 'w'
-+            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
-+            :class:`SpectraCoefficient` can be used to conver a coefficient
-+            depending on ``t`` to one depending on ``w``.
-+
-+        Example:
-+
-+        .. code-block::
-+
-+            a_ops = [
-+                (a+a.dag(), coefficient('w>0', args={'w':0})),
-+                (QobjEvo([b+b.dag(), lambda t: ...]),
-+                 coefficient(lambda t, w: ...), args={"w": 0}),
-+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-+            ]
-+
-+    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
-+        Single collapse operator, or list of collapse operators, or a list
-+        of Lindblad dissipator. None is equivalent to an empty list.
-+
-+    options : dict, optional
-+        Options for the solver, see :obj:`BRSolver.options` and
-+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-+
-+    sec_cutoff : float {0.1}
-+        Cutoff for secular approximation. Use ``-1`` if secular approximation
-+        is not used when evaluating bath-coupling terms.
-+
-+    attributes
-+    ----------
-+    stats: dict
-+        Diverse diagnostic statistics of the evolution.
-+    """
-+    name = "brmesolve"
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size":10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": False,
-+        'method': 'adams',
-+        'tensor_type': 'sparse',
-+        'sparse_eigensolver': False,
-+    }
-+    _avail_integrators = {}
-+
-+    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
-+        _time_start = time()
-+
-+        self.rhs = None
-+        self.sec_cutoff = sec_cutoff
-+        self.options = options
-+
-+        if not isinstance(H, (Qobj, QobjEvo)):
-+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-+        H = QobjEvo(H)
-+
-+        c_ops = c_ops or []
-+        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
-+        for c_op in c_ops:
-+            if not isinstance(c_op, (Qobj, QobjEvo)):
-+                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
-+
-+        a_ops = a_ops or []
-+        if not hasattr(a_ops, "__iter__"):
-+            TypeError("`a_ops` must be a list of (operator, spectra)")
-+        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
-+            a_ops = [a_ops]
-+        for oper, spectra in a_ops:
-+            if not isinstance(oper, (Qobj, QobjEvo)):
-+                raise TypeError("All `a_ops` operators "
-+                                "must be a Qobj or QobjEvo")
-+            if not isinstance(spectra, Coefficient):
-+                raise TypeError("All `a_ops` spectra "
-+                                "must be a Coefficient.")
-+
-+        self._system = H, a_ops, c_ops
-+        self._num_collapse = len(c_ops)
-+        self._num_a_ops = len(a_ops)
-+        self.rhs = self._prepare_rhs()
-+        self._integrator = self._get_integrator()
-+        self._state_metadata = {}
-+        self.stats = self._initialize_stats()
-+
-+
-+    def _initialize_stats(self):
-+        stats = super()._initialize_stats()
-+        stats.update({
-+            "solver": "Bloch Redfield Equation Evolution",
-+            "init time": stats["init time"] + self._init_rhs_time,
-+            "num_collapse": self._num_collapse,
-+            "num_a_ops": self._num_a_ops,
-+        })
-+        return stats
-+
-+    def _prepare_rhs(self):
-+        _time_start = time()
-+        rhs = bloch_redfield_tensor(
-+            *self._system,
-+            fock_basis=True,
-+            sec_cutoff=self.sec_cutoff,
-+            sparse_eigensolver=self.options['sparse_eigensolver'],
-+            br_dtype=self.options['tensor_type']
-+        )
-+        self._init_rhs_time = time() - _time_start
-+        return rhs
-+
-+    @property
-+    def options(self):
-+        """
-+        Options for bloch redfield solver:
-+
-+        store_final_state: bool, default=False
-+            Whether or not to store the final state of the evolution in the
-+            result class.
-+
-+        store_states: bool, default=None
-+            Whether or not to store the state vectors or density matrices.
-+            On `None` the states will be saved if no expectation operators are
-+            given.
-+
-+        normalize_output: bool, default=False
-+            Normalize output state to hide ODE numerical errors.
-+
-+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-+            How to present the solver progress.
-+            'tqdm' uses the python module of the same name and raise an error if
-+            not installed. Empty string or False will disable the bar.
-+
-+        progress_kwargs: dict, default={"chunk_size":10}
-+            Arguments to pass to the progress_bar. Qutip's bars use
-+            ``chunk_size``.
-+
-+        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
-+            Which data type to use when computing the brtensor.
-+            With a cutoff 'sparse' is usually the most efficient.
-+
-+        sparse_eigensolver: bool, default=False
-+            Whether to use the sparse eigensolver
-+
-+        method: str, default="adams"
-+            Which ODE integrator methods are supported.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Solver.options.fset(self, new_options)
-+
-+    def _apply_options(self, keys):
-+        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
-+        need_new_rhs &= (
-+            'sparse_eigensolver' in keys or 'tensor_type' in keys
-+        )
-+        if need_new_rhs:
-+            self.rhs = self._prepare_rhs()
-+
-+        if self._integrator is None or not keys:
-+            pass
-+        elif 'method' in keys or need_new_rhs:
-+            state = self._integrator.get_state()
-+            self._integrator = self._get_integrator()
-+            self._integrator.set_state(*state)
-+        else:
-+            self._integrator.options = self._options
-+            self._integrator.reset(hard=True)
-diff --git a/qutip/solver/correlation.py b/qutip/solver/correlation.py
-index b05514c5..e3be789f 100644
---- a/qutip/solver/correlation.py
-+++ b/qutip/solver/correlation.py
-@@ -1,517 +1,517 @@
--__all__ = [
--    'correlation_3op',
--    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
--    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
--]
--
--import numpy as np
--import scipy.fftpack
--
--from ..core import (
--    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
--    tensor, qzero, expect
--)
--from .mesolve import MESolver
--from .mcsolve import MCSolver
--from .brmesolve import BRSolver
--from .heom.bofin_solvers import HEOMSolver
--
--from .steadystate import steadystate
--from ..ui.progressbar import progess_bars
--
--# -----------------------------------------------------------------------------
--# PUBLIC API
--# -----------------------------------------------------------------------------
--
--# low level correlation
--
--
--def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
--                       solver="me", reverse=False, args={},
--                       options={}):
--    r"""
--    Calculate the two-operator one-time correlation function:
--    :math:`\left<A(\tau)B(0)\right>`
--    along one time axis using the quantum regression theorem and the evolution
--    solver indicated by the `solver` parameter.
--
--    Parameters
--    ----------
--
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian, may be time-dependent for solver choice of `me`.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
--        be used as the initial state. The 'steady-state' is only implemented
--        if ``c_ops`` are provided and the Hamiltonian is constant.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
--        List of collapse operators
--    a_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator A.
--    b_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator B.
--    reverse : bool {False}
--        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
--        :math:`\left<A(t+\tau)B(t)\right>`.
--    solver : str {'me', 'es'}
--        Choice of solver, `me` for master-equation, and `es` for exponential
--        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
--    options : dict, optional
--        Options for the solver. Only used with `me` solver.
--
--    Returns
--    -------
--    corr_vec : ndarray
--        An array of correlation values for the times specified by `taulist`.
--
--    See Also
--    --------
--    :func:`correlation_3op` :
--        Similar function supporting various solver types.
--
--    References
--    ----------
--    See, Gardiner, Quantum Noise, Section 5.2.
--
--    """
--    solver = _make_solver(H, c_ops, args, options, solver)
--
--    if reverse:
--        A_op, B_op, C_op = a_op, b_op, 1
--    else:
--        A_op, B_op, C_op = 1, a_op, b_op
--    if state0 is None:
--        state0 = steadystate(H, c_ops)
--
--    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
--
--
--def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
--                       solver="me", reverse=False, args={},
--                       options={}):
--    r"""
--    Calculate the two-operator two-time correlation function:
--    :math:`\left<A(t+\tau)B(t)\right>`
--    along two time axes using the quantum regression theorem and the
--    evolution solver indicated by the ``solver`` parameter.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian, may be time-dependent for solver choice of `me`.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
--        be used as the initial state. The 'steady-state' is only implemented
--        if ``c_ops`` are provided and the Hamiltonian is constant.
--    tlist : array_like
--        List of times for :math:`t`. tlist must be positive and contain the
--        element `0`. When taking steady-steady correlations only one ``tlist``
--        value is necessary, i.e. when :math:`t \rightarrow \infty`.
--        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
--        List of collapse operators
--    a_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator A.
--    b_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator B.
--    reverse : bool {False}
--        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
--        :math:`\left<A(t+\tau)B(t)\right>`.
--    solver : str {'me', 'es'}
--        Choice of solver, `me` for master-equation, and `es` for exponential
--        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
--    options : dict, optional
--        Options for the solver. Only used with `me` solver.
--
--    Returns
--    -------
--    corr_mat : ndarray
--        An 2-dimensional array (matrix) of correlation values for the times
--        specified by `tlist` (first index) and `taulist` (second index).
--
--    See Also
--    --------
--    :func:`correlation_3op` :
--        Similar function supporting various solver types.
--
--    References
--    ----------
--    See, Gardiner, Quantum Noise, Section 5.2.
--
--    """
--    solver = _make_solver(H, c_ops, args, options, solver)
--    if tlist is None:
--        tlist = [0]
--    if state0 is None:
--        state0 = steadystate(H, c_ops)
--
--    if reverse:
--        A_op, B_op, C_op = a_op, b_op, 1
--    else:
--        A_op, B_op, C_op = 1, a_op, b_op
--
--    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
--
--
--def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
--                       solver="me", args={},
--                       options={}):
--    r"""
--    Calculate the three-operator two-time correlation function:
--    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
--    quantum regression theorem and the evolution solver indicated by the
--    `solver` parameter.
--
--    Note: it is not possibly to calculate a physically meaningful correlation
--    of this form where :math:`\tau<0`.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian, may be time-dependent for solver choice of `me`.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
--        be used as the initial state. The 'steady-state' is only implemented
--        if ``c_ops`` are provided and the Hamiltonian is constant.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
--        List of collapse operators
--    a_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator A.
--    b_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator B.
--    c_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator C.
--    solver : str {'me', 'es'}
--        Choice of solver, `me` for master-equation, and `es` for exponential
--        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
--    options : dict, optional
--        Options for the solver. Only used with `me` solver.
--
--    Returns
--    -------
--    corr_vec : array
--        An array of correlation values for the times specified by `taulist`.
--
--    See Also
--    --------
--    :func:`correlation_3op` :
--        Similar function supporting various solver types.
--
--    References
--    ----------
--    See, Gardiner, Quantum Noise, Section 5.2.
--
--    """
--    solver = _make_solver(H, c_ops, args, options, solver)
--    if state0 is None:
--        state0 = steadystate(H, c_ops)
--    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
--
--
--def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
--                       solver="me", args={},
--                       options={}):
--    r"""
--    Calculate the three-operator two-time correlation function:
--    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
--    quantum regression theorem and the evolution solver indicated by the
--    `solver` parameter.
--
--    Note: it is not possibly to calculate a physically meaningful correlation
--    of this form where :math:`\tau<0`.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian, may be time-dependent for solver choice of `me`.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
--        be used as the initial state. The 'steady-state' is only implemented
--        if ``c_ops`` are provided and the Hamiltonian is constant.
--    tlist : array_like
--        List of times for :math:`t`. tlist must be positive and contain the
--        element `0`. When taking steady-steady correlations only one tlist
--        value is necessary, i.e. when :math:`t \rightarrow \infty`.
--        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
--        List of collapse operators
--    a_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator A.
--    b_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator B.
--    c_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator C.
--    solver : str {'me', 'es'}
--        Choice of solver, `me` for master-equation, and `es` for exponential
--        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
--    options : dict, optional
--        Options for the solver. Only used with `me` solver.
--
--    Returns
--    -------
--    corr_mat : array
--        An 2-dimensional array (matrix) of correlation values for the times
--        specified by `tlist` (first index) and `taulist` (second index).
--
--    See Also
--    --------
--    :func:`correlation_3op` :
--        Similar function supporting various solver types.
--
--    References
--    ----------
--
--    See, Gardiner, Quantum Noise, Section 5.2.
--
--    """
--    solver = _make_solver(H, c_ops, args, options, solver)
--
--    if tlist is None:
--        tlist = [0]
--    if state0 is None:
--        state0 = steadystate(H, c_ops)
--
--    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
--
--
--# high level correlation
--
--def coherence_function_g1(
--    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
--):
--    r"""
--    Calculate the normalized first-order quantum coherence function:
--
--    .. math::
--
--        g^{(1)}(\tau) =
--        \frac{\langle A^\dagger(\tau)A(0)\rangle}
--        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
--                \langle A^\dagger(0)A(0)\rangle}}
--
--    using the quantum regression theorem and the evolution solver indicated by
--    the `solver` parameter.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian, may be time-dependent for solver choice of `me`.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
--        be used as the initial state. The 'steady-state' is only implemented
--        if ``c_ops`` are provided and the Hamiltonian is constant.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
--        List of collapse operators
--    a_op : :class:`Qobj`, :class:`QobjEvo`
--        Operator A.
--    solver : str {'me', 'es'}
--        Choice of solver, `me` for master-equation, and `es` for exponential
--        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
--    options : dict, optional
--        Options for the solver. Only used with `me` solver.
--
--    Returns
--    -------
--    g1, G1 : tuple
--        The normalized and unnormalized second-order coherence function.
--
--    """
--    solver = _make_solver(H, c_ops, args, options, solver)
--
--    # first calculate the photon number
--    if state0 is None:
--        state0 = steadystate(H, c_ops)
--        n = np.array([expect(state0, a_op.dag() * a_op)])
--    else:
--        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
--
--    # calculate the correlation function G1 and normalize with n to obtain g1
--    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
--
--    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
--    return g1, G1
--
--
--def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
--                          args={}, options={}):
--    r"""
--    Calculate the normalized second-order quantum coherence function:
--
--    .. math::
--
--         g^{(2)}(\tau) =
--        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
--        {\langle A^\dagger(\tau)A(\tau)\rangle
--         \langle A^\dagger(0)A(0)\rangle}
--
--    using the quantum regression theorem and the evolution solver indicated by
--    the `solver` parameter.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian, may be time-dependent for solver choice of `me`.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
--        be used as the initial state. The 'steady-state' is only implemented
--        if ``c_ops`` are provided and the Hamiltonian is constant.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    c_ops : list
--        List of collapse operators, may be time-dependent for solver choice of
--        `me`.
--    a_op : :class:`Qobj`
--        Operator A.
--    args : dict
--        Dictionary of arguments to be passed to solver.
--    solver : str {'me', 'es'}
--        Choice of solver, `me` for master-equation, and `es` for exponential
--        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
--    options : dict, optional
--        Options for the solver. Only used with `me` solver.
--
--    Returns
--    -------
--    g2, G2 : tuple
--        The normalized and unnormalized second-order coherence function.
--
--    """
--    solver = _make_solver(H, c_ops, args, options, solver)
--
--    # first calculate the photon number
--    if state0 is None:
--        state0 = steadystate(H, c_ops)
--        n = np.array([expect(state0, a_op.dag() * a_op)])
--    else:
--        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
--
--    # calculate the correlation function G2 and normalize with n to obtain g2
--    G2 = correlation_3op(solver, state0, [0], taulist,
--                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
--
--    g2 = G2 / (n[0] * np.array(n))
--    return g2, G2
--
--
--def _make_solver(H, c_ops, args, options, solver):
--    H = QobjEvo(H, args=args)
--    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
--    if solver == "me":
--        solver_instance = MESolver(H, c_ops, options=options)
--    elif solver == "es":
--        options = {"method": "diag"}
--        solver_instance = MESolver(H, c_ops, options=options)
--    elif solver == "mc":
--        raise ValueError("MC solver for correlation has been removed")
--    return solver_instance
--
--
--def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
--    r"""
--    Calculate the three-operator two-time correlation function:
--
--        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
--
--    from a open system :class:`Solver`.
--
--    Note: it is not possible to calculate a physically meaningful correlation
--    where :math:`\tau<0`.
--
--    Parameters
--    ----------
--    solver : :class:`MESolver`, :class:`BRSolver`
--        Qutip solver for an open system.
--    state0 : :class:`Qobj`
--        Initial state density matrix :math:`\rho(t_0)` or state vector
--        :math:`\psi(t_0)`.
--    tlist : array_like
--        List of times for :math:`t`. tlist must be positive and contain the
--        element `0`.
--    taulist : array_like
--        List of times for :math:`\tau`. taulist must be positive and contain
--        the element `0`.
--    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
--        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
--        in the Schrodinger picture. They do not need to be all provided. For
--        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
--
--    Returns
--    -------
--    corr_mat : array
--        An 2-dimensional array (matrix) of correlation values for the times
--        specified by `tlist` (first index) and `taulist` (second index). If
--        `tlist` is `None`, then a 1-dimensional array of correlation values
--        is returned instead.
--    """
--    taulist = np.asarray(taulist)
--
--    dims = state0.dims[0]
--    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
--    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
--    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
--
--    if isinstance(solver, (MESolver, BRSolver)):
--        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
--    elif isinstance(solver, MCSolver):
--        raise TypeError("Monte Carlo support for correlation was removed. "
--                        "Please, tell us on GitHub issues if you need it!")
--    elif isinstance(solver, HEOMSolver):
--        raise TypeError("HEOM is not supported by correlation. "
--                        "Please, tell us on GitHub issues if you need it!")
--    else:
--        raise TypeError("Only solvers able to evolve density matrices"
--                        " are supported.")
--
--    return out
--
--
--def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
--    old_opt = solver.options.copy()
--    try:
--        # We don't want to modify the solver
--        # TODO: Solver could have a ``with`` or ``copy``.
--        solver.options["normalize_output"] = False
--        solver.options["progress_bar"] = False
--
--        progress_bar = progess_bars[old_opt['progress_bar']]()
--        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
--        rho_t = solver.run(state0, tlist).states
--        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
--        progress_bar.update()
--
--        for t_idx, rho in enumerate(rho_t):
--            t = tlist[t_idx]
--            corr_mat[t_idx, :] = solver.run(
--                C(t) @ rho @ A(t),
--                taulist + t,
--                e_ops=B
--            ).expect[0]
--            progress_bar.update()
--        progress_bar.finished()
--
--    finally:
--        solver.options = old_opt
--
--    return corr_mat
-+__all__ = [
-+    'correlation_3op',
-+    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
-+    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
-+]
-+
-+import numpy as np
-+import scipy.fftpack
-+
-+from ..core import (
-+    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
-+    tensor, qzero, expect
-+)
-+from .mesolve import MESolver
-+from .mcsolve import MCSolver
-+from .brmesolve import BRSolver
-+from .heom.bofin_solvers import HEOMSolver
-+
-+from .steadystate import steadystate
-+from ..ui.progressbar import progess_bars
-+
-+# -----------------------------------------------------------------------------
-+# PUBLIC API
-+# -----------------------------------------------------------------------------
-+
-+# low level correlation
-+
-+
-+def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
-+                       solver="me", reverse=False, args={},
-+                       options={}):
-+    r"""
-+    Calculate the two-operator one-time correlation function:
-+    :math:`\left<A(\tau)B(0)\right>`
-+    along one time axis using the quantum regression theorem and the evolution
-+    solver indicated by the `solver` parameter.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian, may be time-dependent for solver choice of `me`.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-+        be used as the initial state. The 'steady-state' is only implemented
-+        if ``c_ops`` are provided and the Hamiltonian is constant.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-+        List of collapse operators
-+    a_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator A.
-+    b_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator B.
-+    reverse : bool {False}
-+        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
-+        :math:`\left<A(t+\tau)B(t)\right>`.
-+    solver : str {'me', 'es'}
-+        Choice of solver, `me` for master-equation, and `es` for exponential
-+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-+    options : dict, optional
-+        Options for the solver. Only used with `me` solver.
-+
-+    Returns
-+    -------
-+    corr_vec : ndarray
-+        An array of correlation values for the times specified by `taulist`.
-+
-+    See Also
-+    --------
-+    :func:`correlation_3op` :
-+        Similar function supporting various solver types.
-+
-+    References
-+    ----------
-+    See, Gardiner, Quantum Noise, Section 5.2.
-+
-+    """
-+    solver = _make_solver(H, c_ops, args, options, solver)
-+
-+    if reverse:
-+        A_op, B_op, C_op = a_op, b_op, 1
-+    else:
-+        A_op, B_op, C_op = 1, a_op, b_op
-+    if state0 is None:
-+        state0 = steadystate(H, c_ops)
-+
-+    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
-+
-+
-+def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
-+                       solver="me", reverse=False, args={},
-+                       options={}):
-+    r"""
-+    Calculate the two-operator two-time correlation function:
-+    :math:`\left<A(t+\tau)B(t)\right>`
-+    along two time axes using the quantum regression theorem and the
-+    evolution solver indicated by the ``solver`` parameter.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian, may be time-dependent for solver choice of `me`.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-+        be used as the initial state. The 'steady-state' is only implemented
-+        if ``c_ops`` are provided and the Hamiltonian is constant.
-+    tlist : array_like
-+        List of times for :math:`t`. tlist must be positive and contain the
-+        element `0`. When taking steady-steady correlations only one ``tlist``
-+        value is necessary, i.e. when :math:`t \rightarrow \infty`.
-+        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-+        List of collapse operators
-+    a_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator A.
-+    b_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator B.
-+    reverse : bool {False}
-+        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
-+        :math:`\left<A(t+\tau)B(t)\right>`.
-+    solver : str {'me', 'es'}
-+        Choice of solver, `me` for master-equation, and `es` for exponential
-+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-+    options : dict, optional
-+        Options for the solver. Only used with `me` solver.
-+
-+    Returns
-+    -------
-+    corr_mat : ndarray
-+        An 2-dimensional array (matrix) of correlation values for the times
-+        specified by `tlist` (first index) and `taulist` (second index).
-+
-+    See Also
-+    --------
-+    :func:`correlation_3op` :
-+        Similar function supporting various solver types.
-+
-+    References
-+    ----------
-+    See, Gardiner, Quantum Noise, Section 5.2.
-+
-+    """
-+    solver = _make_solver(H, c_ops, args, options, solver)
-+    if tlist is None:
-+        tlist = [0]
-+    if state0 is None:
-+        state0 = steadystate(H, c_ops)
-+
-+    if reverse:
-+        A_op, B_op, C_op = a_op, b_op, 1
-+    else:
-+        A_op, B_op, C_op = 1, a_op, b_op
-+
-+    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
-+
-+
-+def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
-+                       solver="me", args={},
-+                       options={}):
-+    r"""
-+    Calculate the three-operator two-time correlation function:
-+    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
-+    quantum regression theorem and the evolution solver indicated by the
-+    `solver` parameter.
-+
-+    Note: it is not possibly to calculate a physically meaningful correlation
-+    of this form where :math:`\tau<0`.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian, may be time-dependent for solver choice of `me`.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-+        be used as the initial state. The 'steady-state' is only implemented
-+        if ``c_ops`` are provided and the Hamiltonian is constant.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-+        List of collapse operators
-+    a_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator A.
-+    b_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator B.
-+    c_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator C.
-+    solver : str {'me', 'es'}
-+        Choice of solver, `me` for master-equation, and `es` for exponential
-+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-+    options : dict, optional
-+        Options for the solver. Only used with `me` solver.
-+
-+    Returns
-+    -------
-+    corr_vec : array
-+        An array of correlation values for the times specified by `taulist`.
-+
-+    See Also
-+    --------
-+    :func:`correlation_3op` :
-+        Similar function supporting various solver types.
-+
-+    References
-+    ----------
-+    See, Gardiner, Quantum Noise, Section 5.2.
-+
-+    """
-+    solver = _make_solver(H, c_ops, args, options, solver)
-+    if state0 is None:
-+        state0 = steadystate(H, c_ops)
-+    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
-+
-+
-+def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
-+                       solver="me", args={},
-+                       options={}):
-+    r"""
-+    Calculate the three-operator two-time correlation function:
-+    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
-+    quantum regression theorem and the evolution solver indicated by the
-+    `solver` parameter.
-+
-+    Note: it is not possibly to calculate a physically meaningful correlation
-+    of this form where :math:`\tau<0`.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian, may be time-dependent for solver choice of `me`.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-+        be used as the initial state. The 'steady-state' is only implemented
-+        if ``c_ops`` are provided and the Hamiltonian is constant.
-+    tlist : array_like
-+        List of times for :math:`t`. tlist must be positive and contain the
-+        element `0`. When taking steady-steady correlations only one tlist
-+        value is necessary, i.e. when :math:`t \rightarrow \infty`.
-+        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-+        List of collapse operators
-+    a_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator A.
-+    b_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator B.
-+    c_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator C.
-+    solver : str {'me', 'es'}
-+        Choice of solver, `me` for master-equation, and `es` for exponential
-+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-+    options : dict, optional
-+        Options for the solver. Only used with `me` solver.
-+
-+    Returns
-+    -------
-+    corr_mat : array
-+        An 2-dimensional array (matrix) of correlation values for the times
-+        specified by `tlist` (first index) and `taulist` (second index).
-+
-+    See Also
-+    --------
-+    :func:`correlation_3op` :
-+        Similar function supporting various solver types.
-+
-+    References
-+    ----------
-+
-+    See, Gardiner, Quantum Noise, Section 5.2.
-+
-+    """
-+    solver = _make_solver(H, c_ops, args, options, solver)
-+
-+    if tlist is None:
-+        tlist = [0]
-+    if state0 is None:
-+        state0 = steadystate(H, c_ops)
-+
-+    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
-+
-+
-+# high level correlation
-+
-+def coherence_function_g1(
-+    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
-+):
-+    r"""
-+    Calculate the normalized first-order quantum coherence function:
-+
-+    .. math::
-+
-+        g^{(1)}(\tau) =
-+        \frac{\langle A^\dagger(\tau)A(0)\rangle}
-+        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
-+                \langle A^\dagger(0)A(0)\rangle}}
-+
-+    using the quantum regression theorem and the evolution solver indicated by
-+    the `solver` parameter.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian, may be time-dependent for solver choice of `me`.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-+        be used as the initial state. The 'steady-state' is only implemented
-+        if ``c_ops`` are provided and the Hamiltonian is constant.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-+        List of collapse operators
-+    a_op : :class:`Qobj`, :class:`QobjEvo`
-+        Operator A.
-+    solver : str {'me', 'es'}
-+        Choice of solver, `me` for master-equation, and `es` for exponential
-+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-+    options : dict, optional
-+        Options for the solver. Only used with `me` solver.
-+
-+    Returns
-+    -------
-+    g1, G1 : tuple
-+        The normalized and unnormalized second-order coherence function.
-+
-+    """
-+    solver = _make_solver(H, c_ops, args, options, solver)
-+
-+    # first calculate the photon number
-+    if state0 is None:
-+        state0 = steadystate(H, c_ops)
-+        n = np.array([expect(state0, a_op.dag() * a_op)])
-+    else:
-+        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
-+
-+    # calculate the correlation function G1 and normalize with n to obtain g1
-+    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
-+
-+    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
-+    return g1, G1
-+
-+
-+def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
-+                          args={}, options={}):
-+    r"""
-+    Calculate the normalized second-order quantum coherence function:
-+
-+    .. math::
-+
-+         g^{(2)}(\tau) =
-+        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
-+        {\langle A^\dagger(\tau)A(\tau)\rangle
-+         \langle A^\dagger(0)A(0)\rangle}
-+
-+    using the quantum regression theorem and the evolution solver indicated by
-+    the `solver` parameter.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian, may be time-dependent for solver choice of `me`.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-+        be used as the initial state. The 'steady-state' is only implemented
-+        if ``c_ops`` are provided and the Hamiltonian is constant.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    c_ops : list
-+        List of collapse operators, may be time-dependent for solver choice of
-+        `me`.
-+    a_op : :class:`Qobj`
-+        Operator A.
-+    args : dict
-+        Dictionary of arguments to be passed to solver.
-+    solver : str {'me', 'es'}
-+        Choice of solver, `me` for master-equation, and `es` for exponential
-+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-+    options : dict, optional
-+        Options for the solver. Only used with `me` solver.
-+
-+    Returns
-+    -------
-+    g2, G2 : tuple
-+        The normalized and unnormalized second-order coherence function.
-+
-+    """
-+    solver = _make_solver(H, c_ops, args, options, solver)
-+
-+    # first calculate the photon number
-+    if state0 is None:
-+        state0 = steadystate(H, c_ops)
-+        n = np.array([expect(state0, a_op.dag() * a_op)])
-+    else:
-+        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
-+
-+    # calculate the correlation function G2 and normalize with n to obtain g2
-+    G2 = correlation_3op(solver, state0, [0], taulist,
-+                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
-+
-+    g2 = G2 / (n[0] * np.array(n))
-+    return g2, G2
-+
-+
-+def _make_solver(H, c_ops, args, options, solver):
-+    H = QobjEvo(H, args=args)
-+    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
-+    if solver == "me":
-+        solver_instance = MESolver(H, c_ops, options=options)
-+    elif solver == "es":
-+        options = {"method": "diag"}
-+        solver_instance = MESolver(H, c_ops, options=options)
-+    elif solver == "mc":
-+        raise ValueError("MC solver for correlation has been removed")
-+    return solver_instance
-+
-+
-+def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
-+    r"""
-+    Calculate the three-operator two-time correlation function:
-+
-+        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
-+
-+    from a open system :class:`Solver`.
-+
-+    Note: it is not possible to calculate a physically meaningful correlation
-+    where :math:`\tau<0`.
-+
-+    Parameters
-+    ----------
-+    solver : :class:`MESolver`, :class:`BRSolver`
-+        Qutip solver for an open system.
-+    state0 : :class:`Qobj`
-+        Initial state density matrix :math:`\rho(t_0)` or state vector
-+        :math:`\psi(t_0)`.
-+    tlist : array_like
-+        List of times for :math:`t`. tlist must be positive and contain the
-+        element `0`.
-+    taulist : array_like
-+        List of times for :math:`\tau`. taulist must be positive and contain
-+        the element `0`.
-+    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
-+        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
-+        in the Schrodinger picture. They do not need to be all provided. For
-+        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
-+
-+    Returns
-+    -------
-+    corr_mat : array
-+        An 2-dimensional array (matrix) of correlation values for the times
-+        specified by `tlist` (first index) and `taulist` (second index). If
-+        `tlist` is `None`, then a 1-dimensional array of correlation values
-+        is returned instead.
-+    """
-+    taulist = np.asarray(taulist)
-+
-+    dims = state0.dims[0]
-+    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
-+    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
-+    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
-+
-+    if isinstance(solver, (MESolver, BRSolver)):
-+        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
-+    elif isinstance(solver, MCSolver):
-+        raise TypeError("Monte Carlo support for correlation was removed. "
-+                        "Please, tell us on GitHub issues if you need it!")
-+    elif isinstance(solver, HEOMSolver):
-+        raise TypeError("HEOM is not supported by correlation. "
-+                        "Please, tell us on GitHub issues if you need it!")
-+    else:
-+        raise TypeError("Only solvers able to evolve density matrices"
-+                        " are supported.")
-+
-+    return out
-+
-+
-+def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
-+    old_opt = solver.options.copy()
-+    try:
-+        # We don't want to modify the solver
-+        # TODO: Solver could have a ``with`` or ``copy``.
-+        solver.options["normalize_output"] = False
-+        solver.options["progress_bar"] = False
-+
-+        progress_bar = progess_bars[old_opt['progress_bar']]()
-+        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
-+        rho_t = solver.run(state0, tlist).states
-+        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
-+        progress_bar.update()
-+
-+        for t_idx, rho in enumerate(rho_t):
-+            t = tlist[t_idx]
-+            corr_mat[t_idx, :] = solver.run(
-+                C(t) @ rho @ A(t),
-+                taulist + t,
-+                e_ops=B
-+            ).expect[0]
-+            progress_bar.update()
-+        progress_bar.finished()
-+
-+    finally:
-+        solver.options = old_opt
-+
-+    return corr_mat
-diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
-index 4d4c60af..2237957d 100644
---- a/qutip/solver/countstat.py
-+++ b/qutip/solver/countstat.py
-@@ -1,217 +1,217 @@
--"""
--This module contains functions for calculating current and current noise using
--the counting statistics formalism.
--"""
--__all__ = ['countstat_current', 'countstat_current_noise']
--
--import numpy as np
--import scipy.sparse as sp
--
--from itertools import product
--from ..core import (
--    sprepost, spre, qeye, tensor, expect, Qobj,
--    operator_to_vector, vector_to_operator
--)
--from ..core import data as _data
--from .steadystate import pseudo_inverse, steadystate
--from ..settings import settings
--
--# Load MKL spsolve if avaiable
--if settings.has_mkl:
--    from qutip._mkl.spsolve import mkl_spsolve
--
--
--def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
--    """
--    Calculate the current corresponding to a system Liouvillian ``L`` and a
--    list of current collapse operators ``c_ops`` or current superoperators
--    ``J_ops``.
--
--    Parameters
--    ----------
--
--    L : :class:`qutip.Qobj`
--        Qobj representing the system Liouvillian.
--
--    c_ops : array / list (optional)
--        List of current collapse operators. Required if either ``rhoss`` or
--        ``J_ops`` is not given.
--
--    rhoss : :class:`qutip.Qobj` (optional)
--        The steadystate density matrix for the given system Liouvillian ``L``
--        and collapse operators. If not given, it defaults to
--        ``steadystate(L, c_ops)``.
--
--    J_ops : array / list (optional)
--        List of current superoperators. If not given, they default to
--        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
--
--    Returns
--    --------
--    I : array
--        The currents ``I`` corresponding to each current collapse operator
--        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
--    """
--
--    if J_ops is None:
--        if c_ops is None:
--            raise ValueError("c_ops must be given if J_ops is not")
--        J_ops = [sprepost(c, c.dag()) for c in c_ops]
--
--    if rhoss is None:
--        if c_ops is None:
--            raise ValueError("c_ops must be given if rhoss is not")
--        rhoss = steadystate(L, c_ops)
--
--    rhoss_vec = _data.column_stack(rhoss.data.copy())
--
--    N = len(J_ops)
--    current = np.zeros(N)
--
--    for i, Ji in enumerate(J_ops):
--        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
--
--    return current
--
--
--def _solve(A, V):
--    try:
--        return _data.solve(A, V)
--    except Exception:
--        return _data.solve(A, V, "lsqr")
--
--
--def _noise_direct(L, wlist, rhoss, J_ops):
--    J_ops = [op.data for op in J_ops]
--    rhoss_vec = operator_to_vector(rhoss).data
--
--    N_j_ops = len(J_ops)
--    current = np.zeros(N_j_ops)
--    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
--
--    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
--    tr_op_vec = operator_to_vector(tr_op)
--
--    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
--    Iop = _data.identity(np.prod(L.dims[0][0])**2)
--    Q = _data.sub(Iop, Pop)
--    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
--
--    for k, w in enumerate(wlist):
--        if w != 0.0:
--            L_temp = 1.0j * w * spre(tr_op) + L
--        else:
--            # At zero frequency some solvers fail for small systems.
--            # Adding a small finite frequency of order 1e-15
--            # helps prevent the solvers from throwing an exception.
--            L_temp = 1e-15j * spre(tr_op) + L
--
--        A = _data.to(_data.CSR, L_temp.data)
--        X_rho = [_solve(A, op) for op in Q_ops]
--
--        for i, j in product(range(N_j_ops), repeat=2):
--            if i == j:
--                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
--                noise[j, i, k] = current[i]
--            noise[j, i, k] -= (
--                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
--                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
--            ).real
--
--    return current, noise
--
--
--def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
--    N_j_ops = len(J_ops)
--    current = np.zeros(N_j_ops)
--    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
--    rhoss_vec = operator_to_vector(rhoss)
--    for k, w in enumerate(wlist):
--        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
--        for i, j in product(range(N_j_ops), repeat=2):
--            if i == j:
--                current[i] = J_ops[i](rhoss).tr().real
--                noise[i, j, k] = current[i]
--            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
--            noise[i, j, k] -= op(rhoss).tr().real
--    return current, noise
--
--
--def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
--                            sparse=True, method='direct'):
--    """
--    Compute the cross-current noise spectrum for a list of collapse operators
--    `c_ops` corresponding to monitored currents, given the system
--    Liouvillian `L`. The current collapse operators `c_ops` should be part
--    of the dissipative processes in `L`, but the `c_ops` given here does not
--    necessarily need to be all collapse operators contributing to dissipation
--    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
--    and the current operators `J_ops` correpsonding to the current collapse
--    operators `c_ops` can also be specified. If either of
--    `rhoss` and `J_ops` are omitted, they will be computed internally.
--    'wlist' is an optional list of frequencies at which to evaluate the noise
--    spectrum.
--
--    Parameters
--    ----------
--
--    L : :class:`qutip.Qobj`
--        Qobj representing the system Liouvillian.
--
--    c_ops : array / list
--        List of current collapse operators.
--
--    rhoss : :class:`qutip.Qobj` (optional)
--        The steadystate density matrix corresponding the system Liouvillian
--        `L`.
--
--    wlist : array / list (optional)
--        List of frequencies at which to evaluate (if none are given, evaluates
--        at zero frequency)
--
--    J_ops : array / list (optional)
--        List of current superoperators.
--
--    sparse : bool [True]
--        Flag that indicates whether to use sparse or dense matrix methods when
--        computing the pseudo inverse. Default is false, as sparse solvers
--        can fail for small systems. For larger systems the sparse solvers
--        are recommended.
--
--    method : str, ['direct']
--        Method used to compute the noise. The default, 'direct' with
--        ``sparse=True``, compute the noise directly. It is the recommended
--        method for larger systems. Otherwise, the pseudo inverse is computed
--        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
--        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
--        ``sparse=False``.
--
--    .. note::
--        The algoryth is described in page 67 of "Electrons in nanostructures"
--        C. Flindt, PhD Thesis, available online:
--        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
--
--    Returns
--    --------
--    I, S : tuple of arrays
--        The currents `I` corresponding to each current collapse operator
--        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
--        zero-frequency cross-current correlation `S`.
--    """
--    if rhoss is None:
--        rhoss = steadystate(L, c_ops)
--
--    if J_ops is None:
--        J_ops = [sprepost(c, c.dag()) for c in c_ops]
--
--    if wlist is None:
--        wlist = [0.]
--
--    if sparse and method == 'direct':
--        # rhoss_vec = operator_to_vector(rhoss).data
--        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
--    else:
--        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
--                                          sparse, method)
--
--    return current, noise
-+"""
-+This module contains functions for calculating current and current noise using
-+the counting statistics formalism.
-+"""
-+__all__ = ['countstat_current', 'countstat_current_noise']
-+
-+import numpy as np
-+import scipy.sparse as sp
-+
-+from itertools import product
-+from ..core import (
-+    sprepost, spre, qeye, tensor, expect, Qobj,
-+    operator_to_vector, vector_to_operator
-+)
-+from ..core import data as _data
-+from .steadystate import pseudo_inverse, steadystate
-+from ..settings import settings
-+
-+# Load MKL spsolve if avaiable
-+if settings.has_mkl:
-+    from qutip._mkl.spsolve import mkl_spsolve
-+
-+
-+def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
-+    """
-+    Calculate the current corresponding to a system Liouvillian ``L`` and a
-+    list of current collapse operators ``c_ops`` or current superoperators
-+    ``J_ops``.
-+
-+    Parameters
-+    ----------
-+
-+    L : :class:`qutip.Qobj`
-+        Qobj representing the system Liouvillian.
-+
-+    c_ops : array / list (optional)
-+        List of current collapse operators. Required if either ``rhoss`` or
-+        ``J_ops`` is not given.
-+
-+    rhoss : :class:`qutip.Qobj` (optional)
-+        The steadystate density matrix for the given system Liouvillian ``L``
-+        and collapse operators. If not given, it defaults to
-+        ``steadystate(L, c_ops)``.
-+
-+    J_ops : array / list (optional)
-+        List of current superoperators. If not given, they default to
-+        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
-+
-+    Returns
-+    --------
-+    I : array
-+        The currents ``I`` corresponding to each current collapse operator
-+        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
-+    """
-+
-+    if J_ops is None:
-+        if c_ops is None:
-+            raise ValueError("c_ops must be given if J_ops is not")
-+        J_ops = [sprepost(c, c.dag()) for c in c_ops]
-+
-+    if rhoss is None:
-+        if c_ops is None:
-+            raise ValueError("c_ops must be given if rhoss is not")
-+        rhoss = steadystate(L, c_ops)
-+
-+    rhoss_vec = _data.column_stack(rhoss.data.copy())
-+
-+    N = len(J_ops)
-+    current = np.zeros(N)
-+
-+    for i, Ji in enumerate(J_ops):
-+        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
-+
-+    return current
-+
-+
-+def _solve(A, V):
-+    try:
-+        return _data.solve(A, V)
-+    except Exception:
-+        return _data.solve(A, V, "lsqr")
-+
-+
-+def _noise_direct(L, wlist, rhoss, J_ops):
-+    J_ops = [op.data for op in J_ops]
-+    rhoss_vec = operator_to_vector(rhoss).data
-+
-+    N_j_ops = len(J_ops)
-+    current = np.zeros(N_j_ops)
-+    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
-+
-+    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
-+    tr_op_vec = operator_to_vector(tr_op)
-+
-+    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
-+    Iop = _data.identity(np.prod(L.dims[0][0])**2)
-+    Q = _data.sub(Iop, Pop)
-+    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
-+
-+    for k, w in enumerate(wlist):
-+        if w != 0.0:
-+            L_temp = 1.0j * w * spre(tr_op) + L
-+        else:
-+            # At zero frequency some solvers fail for small systems.
-+            # Adding a small finite frequency of order 1e-15
-+            # helps prevent the solvers from throwing an exception.
-+            L_temp = 1e-15j * spre(tr_op) + L
-+
-+        A = _data.to(_data.CSR, L_temp.data)
-+        X_rho = [_solve(A, op) for op in Q_ops]
-+
-+        for i, j in product(range(N_j_ops), repeat=2):
-+            if i == j:
-+                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
-+                noise[j, i, k] = current[i]
-+            noise[j, i, k] -= (
-+                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
-+                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
-+            ).real
-+
-+    return current, noise
-+
-+
-+def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
-+    N_j_ops = len(J_ops)
-+    current = np.zeros(N_j_ops)
-+    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
-+    rhoss_vec = operator_to_vector(rhoss)
-+    for k, w in enumerate(wlist):
-+        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
-+        for i, j in product(range(N_j_ops), repeat=2):
-+            if i == j:
-+                current[i] = J_ops[i](rhoss).tr().real
-+                noise[i, j, k] = current[i]
-+            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
-+            noise[i, j, k] -= op(rhoss).tr().real
-+    return current, noise
-+
-+
-+def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
-+                            sparse=True, method='direct'):
-+    """
-+    Compute the cross-current noise spectrum for a list of collapse operators
-+    `c_ops` corresponding to monitored currents, given the system
-+    Liouvillian `L`. The current collapse operators `c_ops` should be part
-+    of the dissipative processes in `L`, but the `c_ops` given here does not
-+    necessarily need to be all collapse operators contributing to dissipation
-+    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
-+    and the current operators `J_ops` correpsonding to the current collapse
-+    operators `c_ops` can also be specified. If either of
-+    `rhoss` and `J_ops` are omitted, they will be computed internally.
-+    'wlist' is an optional list of frequencies at which to evaluate the noise
-+    spectrum.
-+
-+    Parameters
-+    ----------
-+
-+    L : :class:`qutip.Qobj`
-+        Qobj representing the system Liouvillian.
-+
-+    c_ops : array / list
-+        List of current collapse operators.
-+
-+    rhoss : :class:`qutip.Qobj` (optional)
-+        The steadystate density matrix corresponding the system Liouvillian
-+        `L`.
-+
-+    wlist : array / list (optional)
-+        List of frequencies at which to evaluate (if none are given, evaluates
-+        at zero frequency)
-+
-+    J_ops : array / list (optional)
-+        List of current superoperators.
-+
-+    sparse : bool [True]
-+        Flag that indicates whether to use sparse or dense matrix methods when
-+        computing the pseudo inverse. Default is false, as sparse solvers
-+        can fail for small systems. For larger systems the sparse solvers
-+        are recommended.
-+
-+    method : str, ['direct']
-+        Method used to compute the noise. The default, 'direct' with
-+        ``sparse=True``, compute the noise directly. It is the recommended
-+        method for larger systems. Otherwise, the pseudo inverse is computed
-+        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
-+        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
-+        ``sparse=False``.
-+
-+    .. note::
-+        The algoryth is described in page 67 of "Electrons in nanostructures"
-+        C. Flindt, PhD Thesis, available online:
-+        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
-+
-+    Returns
-+    --------
-+    I, S : tuple of arrays
-+        The currents `I` corresponding to each current collapse operator
-+        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
-+        zero-frequency cross-current correlation `S`.
-+    """
-+    if rhoss is None:
-+        rhoss = steadystate(L, c_ops)
-+
-+    if J_ops is None:
-+        J_ops = [sprepost(c, c.dag()) for c in c_ops]
-+
-+    if wlist is None:
-+        wlist = [0.]
-+
-+    if sparse and method == 'direct':
-+        # rhoss_vec = operator_to_vector(rhoss).data
-+        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
-+    else:
-+        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
-+                                          sparse, method)
-+
-+    return current, noise
-diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
-index 7ce6cc4f..9eea49b9 100644
---- a/qutip/solver/floquet.py
-+++ b/qutip/solver/floquet.py
-@@ -1,931 +1,931 @@
--__all__ = [
--    "FloquetBasis",
--    "floquet_tensor",
--    "fsesolve",
--    "fmmesolve",
--    "FMESolver",
--]
--
--import numpy as np
--from qutip.core import data as _data
--from qutip import Qobj, QobjEvo
--from .propagator import Propagator
--from .mesolve import MESolver
--from .solver_base import Solver
--from .integrator import Integrator
--from .result import Result
--from time import time
--from ..ui.progressbar import progess_bars
--
--
--class FloquetBasis:
--    """
--    Utility to compute floquet modes and states.
--
--    Attributes
--    ----------
--    U : :class:`Propagator`
--        The propagator of the Hamiltonian over one period.
--
--    evecs : :class:`qutip.data.Data`
--        Matrix where each column is an initial Floquet mode.
--
--    e_quasi : np.ndarray[float]
--        The quasi energies of the Hamiltonian.
--    """
--
--    def __init__(
--        self,
--        H,
--        T,
--        args=None,
--        options=None,
--        sparse=False,
--        sort=True,
--        precompute=None,
--    ):
--        """
--        Parameters
--        ----------
--        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
--            System Hamiltonian, with period `T`.
--
--        T : float
--            Period of the Hamiltonian.
--
--        args : None / *dictionary*
--            dictionary of parameters for time-dependent Hamiltonians and
--            collapse operators.
--
--        options : dict [None]
--            Options used by sesolve to compute the floquet modes.
--
--        sparse : bool [False]
--            Whether to use the sparse eigen solver when computing the
--            quasi-energies.
--
--        sort : bool [True]
--            Whether to sort the quasi-energies.
--
--        precompute : list [None]
--            If provided, a list of time at which to store the propagators
--            for later use when computing modes and states. Default is
--            ``linspace(0, T, 101)`` corresponding to the default integration
--            steps used for the floquet tensor computation.
--        """
--        if not T > 0:
--            raise ValueError("The period need to be a positive number.")
--        self.T = T
--        if precompute is not None:
--            tlist = np.unique(np.atleast_1d(precompute) % self.T)
--            memoize = len(tlist)
--            if tlist[0] != 0:
--                memoize += 1
--            if tlist[-1] != T:
--                memoize += 1
--        else:
--            # Default computation
--            tlist = np.linspace(0, T, 101)
--            memoize = 101
--        self.U = Propagator(H, args=args, options=options, memoize=memoize)
--        for t in tlist:
--            # Do the evolution by steps to save the intermediate results.
--            self.U(t)
--        U_T = self.U(self.T)
--        if not sparse and isinstance(U_T.data, _data.CSR):
--            U_T = U_T.to("Dense")
--        evals, evecs = _data.eigs(U_T.data)
--        e_quasi = -np.angle(evals) / T
--        if sort:
--            perm = np.argsort(e_quasi)
--            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
--            self.e_quasi = e_quasi[perm]
--        else:
--            self.evecs = evecs
--            self.e_quasi = e_quasi
--
--    def _as_ketlist(self, kets_mat):
--        """
--        Split the Data array in a list of kets.
--        """
--        dims = [self.U(0).dims[0], [1]]
--        return [
--            Qobj(ket, dims=dims, type="ket")
--            for ket in _data.split_columns(kets_mat)
--        ]
--
--    def mode(self, t, data=False):
--        """
--        Calculate the Floquet modes at time ``t``.
--
--        Parameters
--        ----------
--        t : float
--            The time for which to evaluate the Floquet mode.
--
--        data : bool [False]
--            Whether to return the states as a single data matrix or a list of
--            ket states.
--
--        Returns
--        -------
--        output : list[:class:`Qobj`], :class:`qutip.data.Data`
--            A list of Floquet states for the time ``t`` or the states as column
--            in a single matrix.
--        """
--        t = t % self.T
--        if t == 0.0:
--            kets_mat = self.evecs
--        else:
--            U = self.U(t).data
--            phases = _data.diag(np.exp(1j * t * self.e_quasi))
--            kets_mat = U @ self.evecs @ phases
--        if data:
--            return kets_mat
--        else:
--            return self._as_ketlist(kets_mat)
--
--    def state(self, t, data=False):
--        """
--        Evaluate the floquet states at time t.
--
--        Parameters
--        ----------
--        t : float
--            The time for which to evaluate the Floquet states.
--
--        data : bool [False]
--            Whether to return the states as a single data matrix or a list of
--            ket states.
--
--        Returns
--        -------
--        output : list[:class:`Qobj`], :class:`qutip.data.Data`
--            A list of Floquet states for the time ``t`` or the states as column
--            in a single matrix.
--        """
--        if t:
--            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
--            states_mat = self.mode(t, True) @ phases
--        else:
--            states_mat = self.evecs
--        if data:
--            return states_mat
--        else:
--            return self._as_ketlist(states_mat)
--
--    def from_floquet_basis(self, floquet_basis, t=0):
--        """
--        Transform a ket or density matrix from the Floquet basis at time ``t``
--        to the lab basis.
--
--        Parameters
--        ----------
--        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
--            Initial state in the Floquet basis at time ``t``. May be either a
--            ket or density matrix.
--
--        t : float [0]
--            The time at which to evaluate the Floquet states.
--
--        Returns
--        -------
--        output : :class:`Qobj`, :class:`qutip.data.Data`
--            The state in the lab basis. The return type is the same as the type
--            of the input state.
--        """
--        is_Qobj = isinstance(floquet_basis, Qobj)
--        if is_Qobj:
--            dims = floquet_basis.dims
--            floquet_basis = floquet_basis.data
--            if dims[0] != self.U(0).dims[1]:
--                raise ValueError(
--                    "Dimensions of the state do not match the Hamiltonian"
--                )
--
--        state_mat = self.state(t, True)
--        lab_basis = state_mat @ floquet_basis
--        if floquet_basis.shape[1] != 1:
--            lab_basis = lab_basis @ state_mat.adjoint()
--
--        if is_Qobj:
--            return Qobj(lab_basis, dims=dims)
--        return lab_basis
--
--    def to_floquet_basis(self, lab_basis, t=0):
--        """
--        Transform a ket or density matrix in the lab basis
--        to the Floquet basis at time ``t``.
--
--        Parameters
--        ----------
--        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
--            Initial state in the lab basis.
--
--        t : float [0]
--            The time at which to evaluate the Floquet states.
--
--        Returns
--        -------
--        output : :class:`Qobj`, :class:`qutip.data.Data`
--            The state in the Floquet basis. The return type is the same as the
--            type of the input state.
--        """
--        is_Qobj = isinstance(lab_basis, Qobj)
--        if is_Qobj:
--            dims = lab_basis.dims
--            lab_basis = lab_basis.data
--            if dims[0] != self.U(0).dims[1]:
--                raise ValueError(
--                    "Dimensions of the state do not match the Hamiltonian"
--                )
--
--        state_mat = self.state(t, True)
--        floquet_basis = state_mat.adjoint() @ lab_basis
--        if lab_basis.shape[1] != 1:
--            floquet_basis = floquet_basis @ state_mat
--
--        if is_Qobj:
--            return Qobj(floquet_basis, dims=dims)
--        return floquet_basis
--
--
--def _floquet_delta_tensor(f_energies, kmax, T):
--    """
--    Floquet-Markov master equation X matrices.
--
--    Parameters
--    ----------
--    f_energies : np.ndarray
--        The Floquet energies.
--
--    kmax : int
--        The truncation of the number of sidebands (default 5).
--
--    T : float
--        The period of the time-dependence of the Hamiltonian.
--
--    Returns
--    -------
--    delta : np.ndarray
--        Floquet delta tensor.
--    """
--    delta = np.subtract.outer(f_energies, f_energies)
--    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
--
--
--def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
--    """
--    Floquet-Markov master equation X matrices.
--
--    Parameters
--    ----------
--    floquet_basis : :class:`FloquetBasis`
--        The system Hamiltonian wrapped in a FloquetBasis object.
--
--    c_ops : list of :class:`Qobj`
--        The collapse operators describing the dissipation.
--
--    kmax : int
--        The truncation of the number of sidebands (default 5).
--
--    ntimes : int [100]
--        The number of integration steps (for calculating X) within one period.
--
--    Returns
--    -------
--    X : list of dict of :class:`qutip.data.Data`
--        A dict of the sidebands ``k`` for the X matrices of each c_ops
--    """
--    T = floquet_basis.T
--    N = floquet_basis.U(0).shape[0]
--    omega = (2 * np.pi) / T
--    tlist = np.linspace(T / ntimes, T, ntimes)
--    ks = np.arange(-kmax, kmax + 1)
--    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
--
--    for t in tlist:
--        mode = floquet_basis.mode(t, data=True)
--        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
--        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
--            out[k] = [
--                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
--            ]
--
--    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
--
--
--def _floquet_gamma_matrices(X, delta, J_cb):
--    """
--    Floquet-Markov master equation gamma matrices.
--
--    Parameters
--    ----------
--    X : list of dict of :class:`qutip.data.Data`
--        Floquet X matrices created by :func:`_floquet_X_matrices`.
--
--    delta : np.ndarray
--        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
--
--    J_cb : list of callables
--        A list callback functions that compute the noise power spectrum as
--        a function of frequency. The list should contain one callable for each
--        collapse operator `c_op`, in the same order as the elements of `X`.
--        Each callable should accept a numpy array of frequencies and return a
--        numpy array of corresponding noise power.
--
--    Returns
--    -------
--    gammas : dict of :class:`qutip.data.Data`
--        A dict mapping the sidebands ``k`` to their gamma matrices.
--    """
--    N = delta.shape[0]
--    kmax = (delta.shape[2] - 1) // 2
--    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
--
--    for X_c_op, sp in zip(X, J_cb):
--        response = sp(delta) * ((2 + 0j) * np.pi)
--        response = [
--            _data.Dense(response[:, :, k], copy=False)
--            for k in range(2 * kmax + 1)
--        ]
--        for k in range(-kmax, kmax + 1, 1):
--            gamma[k] = _data.add(
--                gamma[k],
--                _data.multiply(
--                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
--                    response[k + kmax],
--                ),
--            )
--    return gamma
--
--
--def _floquet_A_matrix(delta, gamma, w_th):
--    """
--    Floquet-Markov master equation rate matrix.
--
--    Parameters
--    ----------
--    delta : np.ndarray
--        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
--
--    gamma : dict of :class:`qutip.data.Data`
--        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
--
--    w_th : float
--        The temperature in units of frequency.
--    """
--    kmax = (delta.shape[2] - 1) // 2
--
--    if w_th > 0.0:
--        deltap = np.copy(delta)
--        deltap[deltap == 0.0] = np.inf
--        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
--        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
--
--        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
--        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
--
--        for k in range(1, kmax + 1):
--            g_kk = _data.add(gamma[k], gamma[-k].transpose())
--            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
--            A = _data.add(A, _data.add(gamma[k], thermal_kk))
--            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
--            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
--    else:
--        # w_th is 0, thermal = 0s
--        A = gamma[0]
--        for k in range(1, kmax + 1):
--            A = _data.add(gamma[k], A)
--            A = _data.add(gamma[-k], A)
--
--    return A
--
--
--def _floquet_master_equation_tensor(A):
--    """
--    Construct a tensor that represents the master equation in the floquet
--    basis (with constant Hamiltonian and collapse operators?).
--
--    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
--
--    Parameters
--    ----------
--    A : :class:`qutip.data.Data`
--        Floquet-Markov master equation rate matrix.
--
--    Returns
--    -------
--    output : array
--        The Floquet-Markov master equation tensor `R`.
--    """
--    N = A.shape[0]
--
--    # R[i+N*i, j+N*j] = A[j, i]
--    cols = np.arange(N, dtype=np.int32)
--    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
--    data = np.ones(N, dtype=complex)
--    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
--
--    R = expand @ A.transpose() @ expand.transpose()
--
--    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
--    ket_1 = _data.Dense(np.ones(N, dtype=complex))
--    Asum = A @ ket_1
--    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
--    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
--
--    return _data.add(R, S)
--
--
--def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
--    """
--    Construct a tensor that represents the master equation in the floquet
--    basis.
--
--    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
--
--    Parameters
--    ----------
--    H : :class:`QobjEvo`
--        Periodic Hamiltonian
--
--    T : float
--        The period of the time-dependence of the hamiltonian.
--
--    c_ops : list of :class:`qutip.qobj`
--        list of collapse operators.
--
--    spectra_cb : list callback functions
--        List of callback functions that compute the noise power spectrum as
--        a function of frequency for the collapse operators in `c_ops`.
--
--    w_th : float
--        The temperature in units of frequency.
--
--    kmax : int
--        The truncation of the number of sidebands (default 5).
--
--    Returns
--    -------
--    output : array
--        The Floquet-Markov master equation tensor `R`.
--    """
--    if isinstance(H, FloquetBasis):
--        floquet_basis = H
--        T = H.T
--    else:
--        floquet_basis = FloquetBasis(H, T)
--    energy = floquet_basis.e_quasi
--    delta = _floquet_delta_tensor(energy, kmax, T)
--    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
--    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
--    a = _floquet_A_matrix(delta, gamma, w_th)
--    r = _floquet_master_equation_tensor(a)
--    dims = floquet_basis.U(0).dims
--    return Qobj(
--        r, dims=[dims, dims], type="super", superrep="super", copy=False
--    )
--
--
--def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
--    """
--    Solve the Schrodinger equation using the Floquet formalism.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
--        Periodic system Hamiltonian as :class:`QobjEvo`. List of
--        [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    psi0 : :class:`qutip.qobj`
--        Initial state vector (ket). If an operator is provided,
--
--    tlist : *list* / *array*
--        List of times for :math:`t`.
--
--    e_ops : list of :class:`qutip.qobj` / callback function, optional
--        List of operators for which to evaluate expectation values. If this
--        list is empty, the state vectors for each time in `tlist` will be
--        returned instead of expectation values.
--
--    T : float, default=tlist[-1]
--        The period of the time-dependence of the hamiltonian.
--
--    args : dictionary, optional
--        Dictionary with variables required to evaluate H.
--
--    options : dict, optional
--        Options for the results.
--
--        - store_final_state : bool
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, None
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - normalize_output : bool
--          Normalize output state to hide ODE numerical errors.
--
--    Returns
--    -------
--    output : :class:`qutip.solver.Result`
--        An instance of the class :class:`qutip.solver.Result`, which
--        contains either an *array* of expectation values or an array of
--        state vectors, for the times specified by `tlist`.
--    """
--    if isinstance(H, FloquetBasis):
--        floquet_basis = H
--    else:
--        T = T or tlist[-1]
--        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
--        # are for the open system evolution.
--        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
--
--    f_coeff = floquet_basis.to_floquet_basis(psi0)
--    result_options = {
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": True,
--    }
--    result_options.update(options or {})
--    result = Result(e_ops, result_options, solver="fsesolve")
--    for t in tlist:
--        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
--        result.add(t, state_t)
--
--    return result
--
--
--def fmmesolve(
--    H,
--    rho0,
--    tlist,
--    c_ops=None,
--    e_ops=None,
--    spectra_cb=None,
--    T=0,
--    w_th=0.0,
--    args=None,
--    options=None,
--):
--    """
--    Solve the dynamics for the system using the Floquet-Markov master equation.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
--        Periodic system Hamiltonian as :class:`QobjEvo`. List of
--        [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    rho0 / psi0 : :class:`qutip.Qobj`
--        Initial density matrix or state vector (ket).
--
--    tlist : *list* / *array*
--        List of times for :math:`t`.
--
--    c_ops : list of :class:`qutip.Qobj`
--        List of collapse operators. Time dependent collapse operators are not
--        supported.
--
--    e_ops : list of :class:`qutip.Qobj` / callback function
--        List of operators for which to evaluate expectation values.
--        The states are reverted to the lab basis before applying the
--
--    spectra_cb : list callback functions
--        List of callback functions that compute the noise power spectrum as
--        a function of frequency for the collapse operators in `c_ops`.
--
--    T : float
--        The period of the time-dependence of the hamiltonian. The default value
--        'None' indicates that the 'tlist' spans a single period of the driving.
--
--    w_th : float
--        The temperature of the environment in units of frequency.
--        For example, if the Hamiltonian written in units of 2pi GHz, and the
--        temperature is given in K, use the following conversion:
--
--            temperature = 25e-3 # unit K
--            h = 6.626e-34
--            kB = 1.38e-23
--            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
--
--    args : *dictionary*
--        Dictionary of parameters for time-dependent Hamiltonian
--
--    options : None / dict
--        Dictionary of options for the solver.
--
--        - store_final_state : bool
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, None
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - store_floquet_states : bool
--          Whether or not to store the density matrices in the floquet basis in
--          ``result.floquet_states``.
--        - normalize_output : bool
--          Normalize output state to hide ODE numerical errors.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
--          Which differential equation integration method to use.
--        - atol, rtol : float
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps :
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - max_step : float, 0
--          Maximum lenght of one internal step. When using pulses, it should be
--          less than half the width of the thinnest pulse.
--
--        Other options could be supported depending on the integration method,
--        see `Integrator <./classes.html#classes-ode>`_.
--
--    Returns
--    -------
--    result: :class:`qutip.Result`
--
--        An instance of the class :class:`qutip.Result`, which contains
--        the expectation values for the times specified by `tlist`, and/or the
--        state density matrices corresponding to the times.
--    """
--    if c_ops is None:
--        return fsesolve(
--            H,
--            rho0,
--            tlist,
--            e_ops=e_ops,
--            T=T,
--            w_th=w_th,
--            args=args,
--            options=options,
--        )
--
--    if isinstance(H, FloquetBasis):
--        floquet_basis = H
--    else:
--        T = T or tlist[-1]
--        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
--        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
--        # are for the open system evolution.
--        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
--
--    if not w_th and args:
--        w_th = args.get("w_th", 0.0)
--
--    if isinstance(c_ops, Qobj):
--        c_ops = [c_ops]
--
--    if spectra_cb is None:
--        spectra_cb = [lambda w: (w > 0)]
--    elif callable(spectra_cb):
--        spectra_cb = [spectra_cb]
--    if len(spectra_cb) == 1:
--        spectra_cb = spectra_cb * len(c_ops)
--
--    a_ops = list(zip(c_ops, spectra_cb))
--
--    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
--    return solver.run(rho0, tlist, e_ops=e_ops)
--
--
--class FloquetResult(Result):
--    def _post_init(self, floquet_basis):
--        self.floquet_basis = floquet_basis
--        if self.options["store_floquet_states"]:
--            self.floquet_states = []
--        else:
--            self.floquet_states = None
--        super()._post_init()
--
--    def add(self, t, state):
--        if self.options["store_floquet_states"]:
--            self.floquet_states.append(state)
--
--        state = self.floquet_basis.from_floquet_basis(state, t)
--        super().add(t, state)
--
--
--class FMESolver(MESolver):
--    """
--    Solver for the Floquet-Markov master equation.
--
--    .. note ::
--        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
--
--    Parameters
--    ----------
--    floquet_basis : :class:`qutip.FloquetBasis`
--        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
--        different integrator for the ``floquet_basis`` than for the evolution
--        of the floquet state can improve the performance.
--
--    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
--        List of collapse operators and the corresponding function for the noise
--        power spectrum. The collapse operator must be a :class:`Qobj` and
--        cannot be time dependent. The spectrum function must take and return
--        an numpy array.
--
--    w_th : float
--        The temperature of the environment in units of Hamiltonian frequency.
--
--    kmax : int [5]
--        The truncation of the number of sidebands..
--
--    nT : int [20*kmax]
--        The number of integration steps (for calculating X) within one period.
--
--    options : dict, optional
--        Options for the solver, see :obj:`FMESolver.options` and
--        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
--    """
--
--    name = "fmmesolve"
--    _avail_integrators = {}
--    resultclass = FloquetResult
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size": 10},
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": True,
--        "method": "adams",
--        "store_floquet_states": False,
--    }
--
--    def __init__(
--        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
--    ):
--        self.options = options
--        if isinstance(floquet_basis, FloquetBasis):
--            self.floquet_basis = floquet_basis
--        else:
--            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
--
--        nT = nT or max(100, 20 * kmax)
--        self._num_collapse = len(a_ops)
--        c_ops, spectra_cb = zip(*a_ops)
--        if not all(
--            isinstance(c_op, Qobj) and callable(spectrum)
--            for c_op, spectrum in a_ops
--        ):
--            raise TypeError("a_ops must be tuple of (Qobj, callable)")
--        self.rhs = QobjEvo(
--            floquet_tensor(
--                self.floquet_basis,
--                c_ops,
--                spectra_cb,
--                w_th=w_th,
--                kmax=kmax,
--                nT=nT,
--            )
--        )
--
--        self._integrator = self._get_integrator()
--        self._state_metadata = {}
--        self.stats = self._initialize_stats()
--
--    def _initialize_stats(self):
--        stats = Solver._initialize_stats(self)
--        stats.update(
--            {
--                "solver": "Floquet-Markov master equation",
--                "num_collapse": self._num_collapse,
--            }
--        )
--        return stats
--
--    def _argument(self, args):
--        if args:
--            raise ValueError("FMESolver cannot update arguments")
--
--    def start(self, state0, t0, *, floquet=False):
--        """
--        Set the initial state and time for a step evolution.
--        ``options`` for the evolutions are read at this step.
--
--        Parameters
--        ----------
--        state0 : :class:`Qobj`
--            Initial state of the evolution.
--
--        t0 : double
--            Initial time of the evolution.
--
--        floquet : bool, optional {False}
--            Whether the initial state is in the floquet basis or laboratory
--            basis.
--        """
--        if not floquet:
--            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
--        super().start(state0, t0)
--
--    def step(self, t, *, args=None, copy=True, floquet=False):
--        """
--        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
--
--        Parameters
--        ----------
--        t : double
--            Time to evolve to, must be higher than the last call.
--
--        copy : bool, optional {True}
--            Whether to return a copy of the data or the data in the ODE solver.
--
--        floquet : bool, optional {False}
--            Whether to return the state in the floquet basis or laboratory
--            basis.
--
--        args : dict, optional {None}
--            Not supported
--
--        .. note::
--            The state must be initialized first by calling ``start`` or
--            ``run``. If ``run`` is called, ``step`` will continue from the last
--            time and state obtained.
--        """
--        if args:
--            raise ValueError("FMESolver cannot update arguments")
--        state = super().step(t)
--        if not floquet:
--            state = self.floquet_basis.from_floquet_basis(state, t)
--        elif copy:
--            state = state.copy()
--        return state
--
--    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
--        """
--        Calculate the evolution of the quantum system.
--
--        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
--        ``rhs`` and for each time in ``tlist`` store the state and/or
--        expectation values in a :class:`Result`. The evolution method and
--        stored results are determined by ``options``.
--
--        Parameters
--        ----------
--        state0 : :class:`Qobj`
--            Initial state of the evolution.
--
--        tlist : list of double
--            Time for which to save the results (state and/or expect) of the
--            evolution. The first element of the list is the initial time of the
--            evolution. Each times of the list must be increasing, but does not
--            need to be uniformy distributed.
--
--        floquet : bool, optional {False}
--            Whether the initial state in the floquet basis or laboratory basis.
--
--        args : dict, optional {None}
--            Not supported
--
--        e_ops : list {None}
--            List of Qobj, QobjEvo or callable to compute the expectation
--            values. Function[s] must have the signature
--            f(t : float, state : Qobj) -> expect.
--
--        Returns
--        -------
--        results : :class:`qutip.solver.FloquetResult`
--            Results of the evolution. States and/or expect will be saved. You
--            can control the saved data in the options.
--        """
--        if args:
--            raise ValueError("FMESolver cannot update arguments")
--        if not floquet:
--            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
--        _time_start = time()
--        _data0 = self._prepare_state(state0)
--        self._integrator.set_state(tlist[0], _data0)
--        stats = self._initialize_stats()
--        results = self.resultclass(
--            e_ops,
--            self.options,
--            solver=self.name,
--            stats=stats,
--            floquet_basis=self.floquet_basis,
--        )
--        results.add(tlist[0], self._restore_state(_data0, copy=False))
--        stats["preparation time"] += time() - _time_start
--
--        progress_bar = progess_bars[self.options["progress_bar"]]()
--        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
--        for t, state in self._integrator.run(tlist):
--            progress_bar.update()
--            results.add(t, self._restore_state(state, copy=False))
--        progress_bar.finished()
--
--        stats["run time"] = progress_bar.total_time()
--        # TODO: It would be nice if integrator could give evolution statistics
--        # stats.update(_integrator.stats)
--        return results
-+__all__ = [
-+    "FloquetBasis",
-+    "floquet_tensor",
-+    "fsesolve",
-+    "fmmesolve",
-+    "FMESolver",
-+]
-+
-+import numpy as np
-+from qutip.core import data as _data
-+from qutip import Qobj, QobjEvo
-+from .propagator import Propagator
-+from .mesolve import MESolver
-+from .solver_base import Solver
-+from .integrator import Integrator
-+from .result import Result
-+from time import time
-+from ..ui.progressbar import progess_bars
-+
-+
-+class FloquetBasis:
-+    """
-+    Utility to compute floquet modes and states.
-+
-+    Attributes
-+    ----------
-+    U : :class:`Propagator`
-+        The propagator of the Hamiltonian over one period.
-+
-+    evecs : :class:`qutip.data.Data`
-+        Matrix where each column is an initial Floquet mode.
-+
-+    e_quasi : np.ndarray[float]
-+        The quasi energies of the Hamiltonian.
-+    """
-+
-+    def __init__(
-+        self,
-+        H,
-+        T,
-+        args=None,
-+        options=None,
-+        sparse=False,
-+        sort=True,
-+        precompute=None,
-+    ):
-+        """
-+        Parameters
-+        ----------
-+        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
-+            System Hamiltonian, with period `T`.
-+
-+        T : float
-+            Period of the Hamiltonian.
-+
-+        args : None / *dictionary*
-+            dictionary of parameters for time-dependent Hamiltonians and
-+            collapse operators.
-+
-+        options : dict [None]
-+            Options used by sesolve to compute the floquet modes.
-+
-+        sparse : bool [False]
-+            Whether to use the sparse eigen solver when computing the
-+            quasi-energies.
-+
-+        sort : bool [True]
-+            Whether to sort the quasi-energies.
-+
-+        precompute : list [None]
-+            If provided, a list of time at which to store the propagators
-+            for later use when computing modes and states. Default is
-+            ``linspace(0, T, 101)`` corresponding to the default integration
-+            steps used for the floquet tensor computation.
-+        """
-+        if not T > 0:
-+            raise ValueError("The period need to be a positive number.")
-+        self.T = T
-+        if precompute is not None:
-+            tlist = np.unique(np.atleast_1d(precompute) % self.T)
-+            memoize = len(tlist)
-+            if tlist[0] != 0:
-+                memoize += 1
-+            if tlist[-1] != T:
-+                memoize += 1
-+        else:
-+            # Default computation
-+            tlist = np.linspace(0, T, 101)
-+            memoize = 101
-+        self.U = Propagator(H, args=args, options=options, memoize=memoize)
-+        for t in tlist:
-+            # Do the evolution by steps to save the intermediate results.
-+            self.U(t)
-+        U_T = self.U(self.T)
-+        if not sparse and isinstance(U_T.data, _data.CSR):
-+            U_T = U_T.to("Dense")
-+        evals, evecs = _data.eigs(U_T.data)
-+        e_quasi = -np.angle(evals) / T
-+        if sort:
-+            perm = np.argsort(e_quasi)
-+            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
-+            self.e_quasi = e_quasi[perm]
-+        else:
-+            self.evecs = evecs
-+            self.e_quasi = e_quasi
-+
-+    def _as_ketlist(self, kets_mat):
-+        """
-+        Split the Data array in a list of kets.
-+        """
-+        dims = [self.U(0).dims[0], [1]]
-+        return [
-+            Qobj(ket, dims=dims, type="ket")
-+            for ket in _data.split_columns(kets_mat)
-+        ]
-+
-+    def mode(self, t, data=False):
-+        """
-+        Calculate the Floquet modes at time ``t``.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            The time for which to evaluate the Floquet mode.
-+
-+        data : bool [False]
-+            Whether to return the states as a single data matrix or a list of
-+            ket states.
-+
-+        Returns
-+        -------
-+        output : list[:class:`Qobj`], :class:`qutip.data.Data`
-+            A list of Floquet states for the time ``t`` or the states as column
-+            in a single matrix.
-+        """
-+        t = t % self.T
-+        if t == 0.0:
-+            kets_mat = self.evecs
-+        else:
-+            U = self.U(t).data
-+            phases = _data.diag(np.exp(1j * t * self.e_quasi))
-+            kets_mat = U @ self.evecs @ phases
-+        if data:
-+            return kets_mat
-+        else:
-+            return self._as_ketlist(kets_mat)
-+
-+    def state(self, t, data=False):
-+        """
-+        Evaluate the floquet states at time t.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            The time for which to evaluate the Floquet states.
-+
-+        data : bool [False]
-+            Whether to return the states as a single data matrix or a list of
-+            ket states.
-+
-+        Returns
-+        -------
-+        output : list[:class:`Qobj`], :class:`qutip.data.Data`
-+            A list of Floquet states for the time ``t`` or the states as column
-+            in a single matrix.
-+        """
-+        if t:
-+            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
-+            states_mat = self.mode(t, True) @ phases
-+        else:
-+            states_mat = self.evecs
-+        if data:
-+            return states_mat
-+        else:
-+            return self._as_ketlist(states_mat)
-+
-+    def from_floquet_basis(self, floquet_basis, t=0):
-+        """
-+        Transform a ket or density matrix from the Floquet basis at time ``t``
-+        to the lab basis.
-+
-+        Parameters
-+        ----------
-+        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
-+            Initial state in the Floquet basis at time ``t``. May be either a
-+            ket or density matrix.
-+
-+        t : float [0]
-+            The time at which to evaluate the Floquet states.
-+
-+        Returns
-+        -------
-+        output : :class:`Qobj`, :class:`qutip.data.Data`
-+            The state in the lab basis. The return type is the same as the type
-+            of the input state.
-+        """
-+        is_Qobj = isinstance(floquet_basis, Qobj)
-+        if is_Qobj:
-+            dims = floquet_basis.dims
-+            floquet_basis = floquet_basis.data
-+            if dims[0] != self.U(0).dims[1]:
-+                raise ValueError(
-+                    "Dimensions of the state do not match the Hamiltonian"
-+                )
-+
-+        state_mat = self.state(t, True)
-+        lab_basis = state_mat @ floquet_basis
-+        if floquet_basis.shape[1] != 1:
-+            lab_basis = lab_basis @ state_mat.adjoint()
-+
-+        if is_Qobj:
-+            return Qobj(lab_basis, dims=dims)
-+        return lab_basis
-+
-+    def to_floquet_basis(self, lab_basis, t=0):
-+        """
-+        Transform a ket or density matrix in the lab basis
-+        to the Floquet basis at time ``t``.
-+
-+        Parameters
-+        ----------
-+        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
-+            Initial state in the lab basis.
-+
-+        t : float [0]
-+            The time at which to evaluate the Floquet states.
-+
-+        Returns
-+        -------
-+        output : :class:`Qobj`, :class:`qutip.data.Data`
-+            The state in the Floquet basis. The return type is the same as the
-+            type of the input state.
-+        """
-+        is_Qobj = isinstance(lab_basis, Qobj)
-+        if is_Qobj:
-+            dims = lab_basis.dims
-+            lab_basis = lab_basis.data
-+            if dims[0] != self.U(0).dims[1]:
-+                raise ValueError(
-+                    "Dimensions of the state do not match the Hamiltonian"
-+                )
-+
-+        state_mat = self.state(t, True)
-+        floquet_basis = state_mat.adjoint() @ lab_basis
-+        if lab_basis.shape[1] != 1:
-+            floquet_basis = floquet_basis @ state_mat
-+
-+        if is_Qobj:
-+            return Qobj(floquet_basis, dims=dims)
-+        return floquet_basis
-+
-+
-+def _floquet_delta_tensor(f_energies, kmax, T):
-+    """
-+    Floquet-Markov master equation X matrices.
-+
-+    Parameters
-+    ----------
-+    f_energies : np.ndarray
-+        The Floquet energies.
-+
-+    kmax : int
-+        The truncation of the number of sidebands (default 5).
-+
-+    T : float
-+        The period of the time-dependence of the Hamiltonian.
-+
-+    Returns
-+    -------
-+    delta : np.ndarray
-+        Floquet delta tensor.
-+    """
-+    delta = np.subtract.outer(f_energies, f_energies)
-+    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
-+
-+
-+def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
-+    """
-+    Floquet-Markov master equation X matrices.
-+
-+    Parameters
-+    ----------
-+    floquet_basis : :class:`FloquetBasis`
-+        The system Hamiltonian wrapped in a FloquetBasis object.
-+
-+    c_ops : list of :class:`Qobj`
-+        The collapse operators describing the dissipation.
-+
-+    kmax : int
-+        The truncation of the number of sidebands (default 5).
-+
-+    ntimes : int [100]
-+        The number of integration steps (for calculating X) within one period.
-+
-+    Returns
-+    -------
-+    X : list of dict of :class:`qutip.data.Data`
-+        A dict of the sidebands ``k`` for the X matrices of each c_ops
-+    """
-+    T = floquet_basis.T
-+    N = floquet_basis.U(0).shape[0]
-+    omega = (2 * np.pi) / T
-+    tlist = np.linspace(T / ntimes, T, ntimes)
-+    ks = np.arange(-kmax, kmax + 1)
-+    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
-+
-+    for t in tlist:
-+        mode = floquet_basis.mode(t, data=True)
-+        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
-+        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
-+            out[k] = [
-+                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
-+            ]
-+
-+    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
-+
-+
-+def _floquet_gamma_matrices(X, delta, J_cb):
-+    """
-+    Floquet-Markov master equation gamma matrices.
-+
-+    Parameters
-+    ----------
-+    X : list of dict of :class:`qutip.data.Data`
-+        Floquet X matrices created by :func:`_floquet_X_matrices`.
-+
-+    delta : np.ndarray
-+        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
-+
-+    J_cb : list of callables
-+        A list callback functions that compute the noise power spectrum as
-+        a function of frequency. The list should contain one callable for each
-+        collapse operator `c_op`, in the same order as the elements of `X`.
-+        Each callable should accept a numpy array of frequencies and return a
-+        numpy array of corresponding noise power.
-+
-+    Returns
-+    -------
-+    gammas : dict of :class:`qutip.data.Data`
-+        A dict mapping the sidebands ``k`` to their gamma matrices.
-+    """
-+    N = delta.shape[0]
-+    kmax = (delta.shape[2] - 1) // 2
-+    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
-+
-+    for X_c_op, sp in zip(X, J_cb):
-+        response = sp(delta) * ((2 + 0j) * np.pi)
-+        response = [
-+            _data.Dense(response[:, :, k], copy=False)
-+            for k in range(2 * kmax + 1)
-+        ]
-+        for k in range(-kmax, kmax + 1, 1):
-+            gamma[k] = _data.add(
-+                gamma[k],
-+                _data.multiply(
-+                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
-+                    response[k + kmax],
-+                ),
-+            )
-+    return gamma
-+
-+
-+def _floquet_A_matrix(delta, gamma, w_th):
-+    """
-+    Floquet-Markov master equation rate matrix.
-+
-+    Parameters
-+    ----------
-+    delta : np.ndarray
-+        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
-+
-+    gamma : dict of :class:`qutip.data.Data`
-+        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
-+
-+    w_th : float
-+        The temperature in units of frequency.
-+    """
-+    kmax = (delta.shape[2] - 1) // 2
-+
-+    if w_th > 0.0:
-+        deltap = np.copy(delta)
-+        deltap[deltap == 0.0] = np.inf
-+        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
-+        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
-+
-+        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
-+        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
-+
-+        for k in range(1, kmax + 1):
-+            g_kk = _data.add(gamma[k], gamma[-k].transpose())
-+            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
-+            A = _data.add(A, _data.add(gamma[k], thermal_kk))
-+            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
-+            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
-+    else:
-+        # w_th is 0, thermal = 0s
-+        A = gamma[0]
-+        for k in range(1, kmax + 1):
-+            A = _data.add(gamma[k], A)
-+            A = _data.add(gamma[-k], A)
-+
-+    return A
-+
-+
-+def _floquet_master_equation_tensor(A):
-+    """
-+    Construct a tensor that represents the master equation in the floquet
-+    basis (with constant Hamiltonian and collapse operators?).
-+
-+    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
-+
-+    Parameters
-+    ----------
-+    A : :class:`qutip.data.Data`
-+        Floquet-Markov master equation rate matrix.
-+
-+    Returns
-+    -------
-+    output : array
-+        The Floquet-Markov master equation tensor `R`.
-+    """
-+    N = A.shape[0]
-+
-+    # R[i+N*i, j+N*j] = A[j, i]
-+    cols = np.arange(N, dtype=np.int32)
-+    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
-+    data = np.ones(N, dtype=complex)
-+    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
-+
-+    R = expand @ A.transpose() @ expand.transpose()
-+
-+    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
-+    ket_1 = _data.Dense(np.ones(N, dtype=complex))
-+    Asum = A @ ket_1
-+    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
-+    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
-+
-+    return _data.add(R, S)
-+
-+
-+def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
-+    """
-+    Construct a tensor that represents the master equation in the floquet
-+    basis.
-+
-+    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
-+
-+    Parameters
-+    ----------
-+    H : :class:`QobjEvo`
-+        Periodic Hamiltonian
-+
-+    T : float
-+        The period of the time-dependence of the hamiltonian.
-+
-+    c_ops : list of :class:`qutip.qobj`
-+        list of collapse operators.
-+
-+    spectra_cb : list callback functions
-+        List of callback functions that compute the noise power spectrum as
-+        a function of frequency for the collapse operators in `c_ops`.
-+
-+    w_th : float
-+        The temperature in units of frequency.
-+
-+    kmax : int
-+        The truncation of the number of sidebands (default 5).
-+
-+    Returns
-+    -------
-+    output : array
-+        The Floquet-Markov master equation tensor `R`.
-+    """
-+    if isinstance(H, FloquetBasis):
-+        floquet_basis = H
-+        T = H.T
-+    else:
-+        floquet_basis = FloquetBasis(H, T)
-+    energy = floquet_basis.e_quasi
-+    delta = _floquet_delta_tensor(energy, kmax, T)
-+    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
-+    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
-+    a = _floquet_A_matrix(delta, gamma, w_th)
-+    r = _floquet_master_equation_tensor(a)
-+    dims = floquet_basis.U(0).dims
-+    return Qobj(
-+        r, dims=[dims, dims], type="super", superrep="super", copy=False
-+    )
-+
-+
-+def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
-+    """
-+    Solve the Schrodinger equation using the Floquet formalism.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-+        Periodic system Hamiltonian as :class:`QobjEvo`. List of
-+        [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    psi0 : :class:`qutip.qobj`
-+        Initial state vector (ket). If an operator is provided,
-+
-+    tlist : *list* / *array*
-+        List of times for :math:`t`.
-+
-+    e_ops : list of :class:`qutip.qobj` / callback function, optional
-+        List of operators for which to evaluate expectation values. If this
-+        list is empty, the state vectors for each time in `tlist` will be
-+        returned instead of expectation values.
-+
-+    T : float, default=tlist[-1]
-+        The period of the time-dependence of the hamiltonian.
-+
-+    args : dictionary, optional
-+        Dictionary with variables required to evaluate H.
-+
-+    options : dict, optional
-+        Options for the results.
-+
-+        - store_final_state : bool
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, None
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - normalize_output : bool
-+          Normalize output state to hide ODE numerical errors.
-+
-+    Returns
-+    -------
-+    output : :class:`qutip.solver.Result`
-+        An instance of the class :class:`qutip.solver.Result`, which
-+        contains either an *array* of expectation values or an array of
-+        state vectors, for the times specified by `tlist`.
-+    """
-+    if isinstance(H, FloquetBasis):
-+        floquet_basis = H
-+    else:
-+        T = T or tlist[-1]
-+        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
-+        # are for the open system evolution.
-+        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
-+
-+    f_coeff = floquet_basis.to_floquet_basis(psi0)
-+    result_options = {
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": True,
-+    }
-+    result_options.update(options or {})
-+    result = Result(e_ops, result_options, solver="fsesolve")
-+    for t in tlist:
-+        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
-+        result.add(t, state_t)
-+
-+    return result
-+
-+
-+def fmmesolve(
-+    H,
-+    rho0,
-+    tlist,
-+    c_ops=None,
-+    e_ops=None,
-+    spectra_cb=None,
-+    T=0,
-+    w_th=0.0,
-+    args=None,
-+    options=None,
-+):
-+    """
-+    Solve the dynamics for the system using the Floquet-Markov master equation.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-+        Periodic system Hamiltonian as :class:`QobjEvo`. List of
-+        [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    rho0 / psi0 : :class:`qutip.Qobj`
-+        Initial density matrix or state vector (ket).
-+
-+    tlist : *list* / *array*
-+        List of times for :math:`t`.
-+
-+    c_ops : list of :class:`qutip.Qobj`
-+        List of collapse operators. Time dependent collapse operators are not
-+        supported.
-+
-+    e_ops : list of :class:`qutip.Qobj` / callback function
-+        List of operators for which to evaluate expectation values.
-+        The states are reverted to the lab basis before applying the
-+
-+    spectra_cb : list callback functions
-+        List of callback functions that compute the noise power spectrum as
-+        a function of frequency for the collapse operators in `c_ops`.
-+
-+    T : float
-+        The period of the time-dependence of the hamiltonian. The default value
-+        'None' indicates that the 'tlist' spans a single period of the driving.
-+
-+    w_th : float
-+        The temperature of the environment in units of frequency.
-+        For example, if the Hamiltonian written in units of 2pi GHz, and the
-+        temperature is given in K, use the following conversion:
-+
-+            temperature = 25e-3 # unit K
-+            h = 6.626e-34
-+            kB = 1.38e-23
-+            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
-+
-+    args : *dictionary*
-+        Dictionary of parameters for time-dependent Hamiltonian
-+
-+    options : None / dict
-+        Dictionary of options for the solver.
-+
-+        - store_final_state : bool
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, None
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - store_floquet_states : bool
-+          Whether or not to store the density matrices in the floquet basis in
-+          ``result.floquet_states``.
-+        - normalize_output : bool
-+          Normalize output state to hide ODE numerical errors.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-+          Which differential equation integration method to use.
-+        - atol, rtol : float
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps :
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - max_step : float, 0
-+          Maximum lenght of one internal step. When using pulses, it should be
-+          less than half the width of the thinnest pulse.
-+
-+        Other options could be supported depending on the integration method,
-+        see `Integrator <./classes.html#classes-ode>`_.
-+
-+    Returns
-+    -------
-+    result: :class:`qutip.Result`
-+
-+        An instance of the class :class:`qutip.Result`, which contains
-+        the expectation values for the times specified by `tlist`, and/or the
-+        state density matrices corresponding to the times.
-+    """
-+    if c_ops is None:
-+        return fsesolve(
-+            H,
-+            rho0,
-+            tlist,
-+            e_ops=e_ops,
-+            T=T,
-+            w_th=w_th,
-+            args=args,
-+            options=options,
-+        )
-+
-+    if isinstance(H, FloquetBasis):
-+        floquet_basis = H
-+    else:
-+        T = T or tlist[-1]
-+        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
-+        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
-+        # are for the open system evolution.
-+        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
-+
-+    if not w_th and args:
-+        w_th = args.get("w_th", 0.0)
-+
-+    if isinstance(c_ops, Qobj):
-+        c_ops = [c_ops]
-+
-+    if spectra_cb is None:
-+        spectra_cb = [lambda w: (w > 0)]
-+    elif callable(spectra_cb):
-+        spectra_cb = [spectra_cb]
-+    if len(spectra_cb) == 1:
-+        spectra_cb = spectra_cb * len(c_ops)
-+
-+    a_ops = list(zip(c_ops, spectra_cb))
-+
-+    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
-+    return solver.run(rho0, tlist, e_ops=e_ops)
-+
-+
-+class FloquetResult(Result):
-+    def _post_init(self, floquet_basis):
-+        self.floquet_basis = floquet_basis
-+        if self.options["store_floquet_states"]:
-+            self.floquet_states = []
-+        else:
-+            self.floquet_states = None
-+        super()._post_init()
-+
-+    def add(self, t, state):
-+        if self.options["store_floquet_states"]:
-+            self.floquet_states.append(state)
-+
-+        state = self.floquet_basis.from_floquet_basis(state, t)
-+        super().add(t, state)
-+
-+
-+class FMESolver(MESolver):
-+    """
-+    Solver for the Floquet-Markov master equation.
-+
-+    .. note ::
-+        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
-+
-+    Parameters
-+    ----------
-+    floquet_basis : :class:`qutip.FloquetBasis`
-+        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
-+        different integrator for the ``floquet_basis`` than for the evolution
-+        of the floquet state can improve the performance.
-+
-+    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
-+        List of collapse operators and the corresponding function for the noise
-+        power spectrum. The collapse operator must be a :class:`Qobj` and
-+        cannot be time dependent. The spectrum function must take and return
-+        an numpy array.
-+
-+    w_th : float
-+        The temperature of the environment in units of Hamiltonian frequency.
-+
-+    kmax : int [5]
-+        The truncation of the number of sidebands..
-+
-+    nT : int [20*kmax]
-+        The number of integration steps (for calculating X) within one period.
-+
-+    options : dict, optional
-+        Options for the solver, see :obj:`FMESolver.options` and
-+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-+    """
-+
-+    name = "fmmesolve"
-+    _avail_integrators = {}
-+    resultclass = FloquetResult
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size": 10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": True,
-+        "method": "adams",
-+        "store_floquet_states": False,
-+    }
-+
-+    def __init__(
-+        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
-+    ):
-+        self.options = options
-+        if isinstance(floquet_basis, FloquetBasis):
-+            self.floquet_basis = floquet_basis
-+        else:
-+            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
-+
-+        nT = nT or max(100, 20 * kmax)
-+        self._num_collapse = len(a_ops)
-+        c_ops, spectra_cb = zip(*a_ops)
-+        if not all(
-+            isinstance(c_op, Qobj) and callable(spectrum)
-+            for c_op, spectrum in a_ops
-+        ):
-+            raise TypeError("a_ops must be tuple of (Qobj, callable)")
-+        self.rhs = QobjEvo(
-+            floquet_tensor(
-+                self.floquet_basis,
-+                c_ops,
-+                spectra_cb,
-+                w_th=w_th,
-+                kmax=kmax,
-+                nT=nT,
-+            )
-+        )
-+
-+        self._integrator = self._get_integrator()
-+        self._state_metadata = {}
-+        self.stats = self._initialize_stats()
-+
-+    def _initialize_stats(self):
-+        stats = Solver._initialize_stats(self)
-+        stats.update(
-+            {
-+                "solver": "Floquet-Markov master equation",
-+                "num_collapse": self._num_collapse,
-+            }
-+        )
-+        return stats
-+
-+    def _argument(self, args):
-+        if args:
-+            raise ValueError("FMESolver cannot update arguments")
-+
-+    def start(self, state0, t0, *, floquet=False):
-+        """
-+        Set the initial state and time for a step evolution.
-+        ``options`` for the evolutions are read at this step.
-+
-+        Parameters
-+        ----------
-+        state0 : :class:`Qobj`
-+            Initial state of the evolution.
-+
-+        t0 : double
-+            Initial time of the evolution.
-+
-+        floquet : bool, optional {False}
-+            Whether the initial state is in the floquet basis or laboratory
-+            basis.
-+        """
-+        if not floquet:
-+            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
-+        super().start(state0, t0)
-+
-+    def step(self, t, *, args=None, copy=True, floquet=False):
-+        """
-+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-+
-+        Parameters
-+        ----------
-+        t : double
-+            Time to evolve to, must be higher than the last call.
-+
-+        copy : bool, optional {True}
-+            Whether to return a copy of the data or the data in the ODE solver.
-+
-+        floquet : bool, optional {False}
-+            Whether to return the state in the floquet basis or laboratory
-+            basis.
-+
-+        args : dict, optional {None}
-+            Not supported
-+
-+        .. note::
-+            The state must be initialized first by calling ``start`` or
-+            ``run``. If ``run`` is called, ``step`` will continue from the last
-+            time and state obtained.
-+        """
-+        if args:
-+            raise ValueError("FMESolver cannot update arguments")
-+        state = super().step(t)
-+        if not floquet:
-+            state = self.floquet_basis.from_floquet_basis(state, t)
-+        elif copy:
-+            state = state.copy()
-+        return state
-+
-+    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
-+        """
-+        Calculate the evolution of the quantum system.
-+
-+        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
-+        ``rhs`` and for each time in ``tlist`` store the state and/or
-+        expectation values in a :class:`Result`. The evolution method and
-+        stored results are determined by ``options``.
-+
-+        Parameters
-+        ----------
-+        state0 : :class:`Qobj`
-+            Initial state of the evolution.
-+
-+        tlist : list of double
-+            Time for which to save the results (state and/or expect) of the
-+            evolution. The first element of the list is the initial time of the
-+            evolution. Each times of the list must be increasing, but does not
-+            need to be uniformy distributed.
-+
-+        floquet : bool, optional {False}
-+            Whether the initial state in the floquet basis or laboratory basis.
-+
-+        args : dict, optional {None}
-+            Not supported
-+
-+        e_ops : list {None}
-+            List of Qobj, QobjEvo or callable to compute the expectation
-+            values. Function[s] must have the signature
-+            f(t : float, state : Qobj) -> expect.
-+
-+        Returns
-+        -------
-+        results : :class:`qutip.solver.FloquetResult`
-+            Results of the evolution. States and/or expect will be saved. You
-+            can control the saved data in the options.
-+        """
-+        if args:
-+            raise ValueError("FMESolver cannot update arguments")
-+        if not floquet:
-+            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
-+        _time_start = time()
-+        _data0 = self._prepare_state(state0)
-+        self._integrator.set_state(tlist[0], _data0)
-+        stats = self._initialize_stats()
-+        results = self.resultclass(
-+            e_ops,
-+            self.options,
-+            solver=self.name,
-+            stats=stats,
-+            floquet_basis=self.floquet_basis,
-+        )
-+        results.add(tlist[0], self._restore_state(_data0, copy=False))
-+        stats["preparation time"] += time() - _time_start
-+
-+        progress_bar = progess_bars[self.options["progress_bar"]]()
-+        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
-+        for t, state in self._integrator.run(tlist):
-+            progress_bar.update()
-+            results.add(t, self._restore_state(state, copy=False))
-+        progress_bar.finished()
-+
-+        stats["run time"] = progress_bar.total_time()
-+        # TODO: It would be nice if integrator could give evolution statistics
-+        # stats.update(_integrator.stats)
-+        return results
-diff --git a/qutip/solver/floquet_bwcomp.py b/qutip/solver/floquet_bwcomp.py
-index 8ee683ff..6937240f 100644
---- a/qutip/solver/floquet_bwcomp.py
-+++ b/qutip/solver/floquet_bwcomp.py
-@@ -1,244 +1,244 @@
--""" Floquet solver compatibility functions that behave like the corresponding
--functions from QuTiP 4.7.
--
--These functions are indented to be used when porting code from QuTiP 4.7 to
--QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
--"""
--
--__all__ = [
--    "floquet_modes",
--    "floquet_modes_t",
--    "floquet_modes_table",
--    "floquet_modes_t_lookup",
--    "floquet_states",
--    "floquet_states_t",
--    "floquet_wavefunction",
--    "floquet_wavefunction_t",
--    "floquet_state_decomposition",
--    "floquet_master_equation_rates",
--]
--
--from .floquet import *
--import numpy as np
--import warnings
--
--
--def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
--    """
--    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
--    period T.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
--    f_mode_0 = fbasis.mode(0)
--    f_energies = fbasis.e_quasi
--    """
--    warnings.warn(FutureWarning(
--        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
--    ))
--    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
--    f_mode_0 = fbasis.mode(0)
--    f_energies = fbasis.e_quasi
--    return f_mode_0, f_energies
--
--
--def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
--    """
--    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
--    initial Floquet modes Phi_alpha(0).
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    f_mode_t = fbasis.mode(t)
--    """
--    warnings.warn(FutureWarning(
--        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
--    ))
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    return fbasis.mode(t)
--
--
--def floquet_modes_table(
--    f_modes_0, f_energies, tlist, H, T, args=None, options=None
--):
--    """
--    Pre-calculate the Floquet modes for a range of times spanning the floquet
--    period. Can later be used as a table to look up the floquet modes for
--    any time.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
--    """
--    raise NotImplementedError("`floquet_modes_table` is deprecated.")
--
--
--def floquet_modes_t_lookup(f_modes_table_t, t, T):
--    """
--    Lookup the floquet mode at time t in the pre-calculated table of floquet
--    modes in the first period of the time-dependence.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    f_modes_table_t = fbasis = FloquetBasis(...)
--    f_mode_t = f_modes_table_t.mode(t)
--    """
--    raise NotImplementedError(
--        "`floquet_modes_t_lookup` is no longer provided. "
--        "Use `FloquetBasis` instead."
--    )
--
--
--def floquet_states(f_modes_t, f_energies, t):
--    """
--    Evaluate the floquet states at time t given the Floquet modes at that time.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    f_state_t = fbasis.state(t)
--    """
--    warnings.warn(FutureWarning(
--        "`floquet_states` is deprecated. "
--        "Use `FloquetBasis.state` instead."
--    ))
--    return [
--        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
--        for i in np.arange(len(f_energies))
--    ]
--
--
--def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
--    """
--    Evaluate the floquet states at time t given the initial Floquet modes.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    f_state_t = fbasis.state(t)
--    """
--    warnings.warn(FutureWarning(
--        "`floquet_states_t` is deprecated. "
--        "Use `FloquetBasis.state` instead."
--    ))
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    return fbasis.state(t)
--
--
--def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
--    """
--    Evaluate the wavefunction for a time t using the Floquet state
--    decompositon, given the Floquet modes at time `t`.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    psi_t = fbasis.from_floquet_basis(f_coeff, t)
--    """
--    raise NotImplementedError(
--        "`floquet_wavefunction` is not longer provided. "
--        "Use `FloquetBasis.from_floquet_basis` instead."
--    )
--
--
--def floquet_wavefunction_t(
--    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
--):
--    """
--    Evaluate the wavefunction for a time t using the Floquet state
--    decompositon, given the initial Floquet modes.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    psi_t = fbasis.from_floquet_basis(f_coeff, t)
--    """
--    warnings.warn(FutureWarning(
--        "`floquet_wavefunction_t` is deprecated. "
--        "Use `FloquetBasis.from_floquet_basis` instead."
--    ))
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    return fbasis.from_floquet_basis(f_coeff, t)
--
--
--def floquet_state_decomposition(f_states, f_energies, psi):
--    r"""
--    Decompose the wavefunction `psi` (typically an initial state) in terms of
--    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
--
--    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
--
--    fbasis = FloquetBasis(H, T, args=args, options=options)
--    f_coeff = fbasis.to_floquet_basis(psi)
--    """
--    raise NotImplementedError(
--        "`floquet_state_decomposition` is deprecated. "
--        "Use `FloquetBasis.to_floquet_basis` instead."
--    )
--
--
--def floquet_master_equation_rates(
--    f_modes_0,
--    f_energies,
--    c_op,
--    H,
--    T,
--    args,
--    J_cb,
--    w_th,
--    kmax=5,
--    f_modes_table_t=None,
--):
--    """
--    Calculate the rates and matrix elements for the Floquet-Markov master
--    equation.
--
--    .. note ::
--
--        Deprecated. For the Floquet-Markov master equation's tensor, use
--        :func:`floquet_tensor`. For the rates matrices, use
--        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
--        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
--
--    Parameters
--    ----------
--    f_modes_0 : Any
--        No longer used.
--    f_energies : Any
--        No longer used.
--    c_op : :class:`qutip.qobj`
--        The collapse operators describing the dissipation.
--    H : :class:`qutip.qobj`
--        System Hamiltonian, time-dependent with period `T`.
--    T : float
--        The period of the time-dependence of the hamiltonian.
--    args : dictionary
--        Dictionary with variables required to evaluate H.
--    J_cb : callback functions
--        A callback function that computes the noise power spectrum, as
--        a function of frequency, associated with the collapse operator `c_op`.
--    w_th : float
--        The temperature in units of frequency.
--    kmax : int, default=5
--        The truncation of the number of sidebands.
--    f_modes_table_t : Any
--        No longer used.
--
--    Returns
--    -------
--    output : list
--        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
--        and A used in the construction of the Floquet-Markov master equation.
--    """
--    warnings.warn(
--        FutureWarning("`floquet_master_equation_rates` is deprecated.")
--    )
--    floquet_basis = FloquetBasis(H, T, args=args)
--    energy = floquet_basis.e_quasi
--    delta = floquet_delta_tensor(energy, kmax, T)
--    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
--    gamma = floquet_gamma_matrices(x, delta, [J_cb])
--    a = floquet_A_matrix(delta, gamma, w_th)
--    return delta, x[0], gamma, a
-+""" Floquet solver compatibility functions that behave like the corresponding
-+functions from QuTiP 4.7.
-+
-+These functions are indented to be used when porting code from QuTiP 4.7 to
-+QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
-+"""
-+
-+__all__ = [
-+    "floquet_modes",
-+    "floquet_modes_t",
-+    "floquet_modes_table",
-+    "floquet_modes_t_lookup",
-+    "floquet_states",
-+    "floquet_states_t",
-+    "floquet_wavefunction",
-+    "floquet_wavefunction_t",
-+    "floquet_state_decomposition",
-+    "floquet_master_equation_rates",
-+]
-+
-+from .floquet import *
-+import numpy as np
-+import warnings
-+
-+
-+def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
-+    """
-+    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
-+    period T.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
-+    f_mode_0 = fbasis.mode(0)
-+    f_energies = fbasis.e_quasi
-+    """
-+    warnings.warn(FutureWarning(
-+        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
-+    ))
-+    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
-+    f_mode_0 = fbasis.mode(0)
-+    f_energies = fbasis.e_quasi
-+    return f_mode_0, f_energies
-+
-+
-+def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
-+    """
-+    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
-+    initial Floquet modes Phi_alpha(0).
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    f_mode_t = fbasis.mode(t)
-+    """
-+    warnings.warn(FutureWarning(
-+        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
-+    ))
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    return fbasis.mode(t)
-+
-+
-+def floquet_modes_table(
-+    f_modes_0, f_energies, tlist, H, T, args=None, options=None
-+):
-+    """
-+    Pre-calculate the Floquet modes for a range of times spanning the floquet
-+    period. Can later be used as a table to look up the floquet modes for
-+    any time.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
-+    """
-+    raise NotImplementedError("`floquet_modes_table` is deprecated.")
-+
-+
-+def floquet_modes_t_lookup(f_modes_table_t, t, T):
-+    """
-+    Lookup the floquet mode at time t in the pre-calculated table of floquet
-+    modes in the first period of the time-dependence.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    f_modes_table_t = fbasis = FloquetBasis(...)
-+    f_mode_t = f_modes_table_t.mode(t)
-+    """
-+    raise NotImplementedError(
-+        "`floquet_modes_t_lookup` is no longer provided. "
-+        "Use `FloquetBasis` instead."
-+    )
-+
-+
-+def floquet_states(f_modes_t, f_energies, t):
-+    """
-+    Evaluate the floquet states at time t given the Floquet modes at that time.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    f_state_t = fbasis.state(t)
-+    """
-+    warnings.warn(FutureWarning(
-+        "`floquet_states` is deprecated. "
-+        "Use `FloquetBasis.state` instead."
-+    ))
-+    return [
-+        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
-+        for i in np.arange(len(f_energies))
-+    ]
-+
-+
-+def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
-+    """
-+    Evaluate the floquet states at time t given the initial Floquet modes.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    f_state_t = fbasis.state(t)
-+    """
-+    warnings.warn(FutureWarning(
-+        "`floquet_states_t` is deprecated. "
-+        "Use `FloquetBasis.state` instead."
-+    ))
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    return fbasis.state(t)
-+
-+
-+def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
-+    """
-+    Evaluate the wavefunction for a time t using the Floquet state
-+    decompositon, given the Floquet modes at time `t`.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    psi_t = fbasis.from_floquet_basis(f_coeff, t)
-+    """
-+    raise NotImplementedError(
-+        "`floquet_wavefunction` is not longer provided. "
-+        "Use `FloquetBasis.from_floquet_basis` instead."
-+    )
-+
-+
-+def floquet_wavefunction_t(
-+    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
-+):
-+    """
-+    Evaluate the wavefunction for a time t using the Floquet state
-+    decompositon, given the initial Floquet modes.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    psi_t = fbasis.from_floquet_basis(f_coeff, t)
-+    """
-+    warnings.warn(FutureWarning(
-+        "`floquet_wavefunction_t` is deprecated. "
-+        "Use `FloquetBasis.from_floquet_basis` instead."
-+    ))
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    return fbasis.from_floquet_basis(f_coeff, t)
-+
-+
-+def floquet_state_decomposition(f_states, f_energies, psi):
-+    r"""
-+    Decompose the wavefunction `psi` (typically an initial state) in terms of
-+    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
-+
-+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-+
-+    fbasis = FloquetBasis(H, T, args=args, options=options)
-+    f_coeff = fbasis.to_floquet_basis(psi)
-+    """
-+    raise NotImplementedError(
-+        "`floquet_state_decomposition` is deprecated. "
-+        "Use `FloquetBasis.to_floquet_basis` instead."
-+    )
-+
-+
-+def floquet_master_equation_rates(
-+    f_modes_0,
-+    f_energies,
-+    c_op,
-+    H,
-+    T,
-+    args,
-+    J_cb,
-+    w_th,
-+    kmax=5,
-+    f_modes_table_t=None,
-+):
-+    """
-+    Calculate the rates and matrix elements for the Floquet-Markov master
-+    equation.
-+
-+    .. note ::
-+
-+        Deprecated. For the Floquet-Markov master equation's tensor, use
-+        :func:`floquet_tensor`. For the rates matrices, use
-+        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
-+        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
-+
-+    Parameters
-+    ----------
-+    f_modes_0 : Any
-+        No longer used.
-+    f_energies : Any
-+        No longer used.
-+    c_op : :class:`qutip.qobj`
-+        The collapse operators describing the dissipation.
-+    H : :class:`qutip.qobj`
-+        System Hamiltonian, time-dependent with period `T`.
-+    T : float
-+        The period of the time-dependence of the hamiltonian.
-+    args : dictionary
-+        Dictionary with variables required to evaluate H.
-+    J_cb : callback functions
-+        A callback function that computes the noise power spectrum, as
-+        a function of frequency, associated with the collapse operator `c_op`.
-+    w_th : float
-+        The temperature in units of frequency.
-+    kmax : int, default=5
-+        The truncation of the number of sidebands.
-+    f_modes_table_t : Any
-+        No longer used.
-+
-+    Returns
-+    -------
-+    output : list
-+        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
-+        and A used in the construction of the Floquet-Markov master equation.
-+    """
-+    warnings.warn(
-+        FutureWarning("`floquet_master_equation_rates` is deprecated.")
-+    )
-+    floquet_basis = FloquetBasis(H, T, args=args)
-+    energy = floquet_basis.e_quasi
-+    delta = floquet_delta_tensor(energy, kmax, T)
-+    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
-+    gamma = floquet_gamma_matrices(x, delta, [J_cb])
-+    a = floquet_A_matrix(delta, gamma, w_th)
-+    return delta, x[0], gamma, a
-diff --git a/qutip/solver/heom/__init__.py b/qutip/solver/heom/__init__.py
-index 9a8264b0..2ae10e1b 100644
---- a/qutip/solver/heom/__init__.py
-+++ b/qutip/solver/heom/__init__.py
-@@ -1,55 +1,55 @@
--"""
--This module provides solvers for system-bath evoluation using the
--HEOM (hierarchy equations of motion).
--
--See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
--basic introduction to the technique.
--
--The implementation is derived from the BoFiN library (see
--https://github.com/tehruhn/bofin) which was itself derived from an earlier
--implementation in QuTiP itself.
--
--For backwards compatibility with QuTiP 4.6 and below, a new version of
--HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
--implemented on top of the new HEOMSolver but should largely be a drop-in
--replacement for the old HSolverDL.
--"""
--
--__all__ = [
--    "BathExponent",
--    "Bath",
--    "BosonicBath",
--    "DrudeLorentzBath",
--    "DrudeLorentzPadeBath",
--    "UnderDampedBath",
--    "FermionicBath",
--    "LorentzianBath",
--    "LorentzianPadeBath",
--    "heomsolve",
--    "HEOMSolver",
--    "HEOMResult",
--    "HSolverDL",
--    "HierarchyADOs",
--    "HierarchyADOsState",
--]
--
--from .bofin_baths import (
--    BathExponent,
--    Bath,
--    BosonicBath,
--    DrudeLorentzBath,
--    DrudeLorentzPadeBath,
--    UnderDampedBath,
--    FermionicBath,
--    LorentzianBath,
--    LorentzianPadeBath,
--)
--
--from .bofin_solvers import (
--    heomsolve,
--    HEOMSolver,
--    HEOMResult,
--    HSolverDL,
--    HierarchyADOs,
--    HierarchyADOsState,
--)
-+"""
-+This module provides solvers for system-bath evoluation using the
-+HEOM (hierarchy equations of motion).
-+
-+See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
-+basic introduction to the technique.
-+
-+The implementation is derived from the BoFiN library (see
-+https://github.com/tehruhn/bofin) which was itself derived from an earlier
-+implementation in QuTiP itself.
-+
-+For backwards compatibility with QuTiP 4.6 and below, a new version of
-+HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
-+implemented on top of the new HEOMSolver but should largely be a drop-in
-+replacement for the old HSolverDL.
-+"""
-+
-+__all__ = [
-+    "BathExponent",
-+    "Bath",
-+    "BosonicBath",
-+    "DrudeLorentzBath",
-+    "DrudeLorentzPadeBath",
-+    "UnderDampedBath",
-+    "FermionicBath",
-+    "LorentzianBath",
-+    "LorentzianPadeBath",
-+    "heomsolve",
-+    "HEOMSolver",
-+    "HEOMResult",
-+    "HSolverDL",
-+    "HierarchyADOs",
-+    "HierarchyADOsState",
-+]
-+
-+from .bofin_baths import (
-+    BathExponent,
-+    Bath,
-+    BosonicBath,
-+    DrudeLorentzBath,
-+    DrudeLorentzPadeBath,
-+    UnderDampedBath,
-+    FermionicBath,
-+    LorentzianBath,
-+    LorentzianPadeBath,
-+)
-+
-+from .bofin_solvers import (
-+    heomsolve,
-+    HEOMSolver,
-+    HEOMResult,
-+    HSolverDL,
-+    HierarchyADOs,
-+    HierarchyADOsState,
-+)
-diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
-index ff64dfc6..0b7f2c2b 100644
---- a/qutip/solver/heom/bofin_baths.py
-+++ b/qutip/solver/heom/bofin_baths.py
-@@ -1,982 +1,982 @@
--"""
--This module provides utilities for describing baths when using the
--HEOM (hierarchy equations of motion) to model system-bath interactions.
--
--See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
--
--The implementation is derived from the BoFiN library (see
--https://github.com/tehruhn/bofin) which was itself derived from an earlier
--implementation in QuTiP itself.
--"""
--
--import enum
--
--import numpy as np
--from scipy.linalg import eigvalsh
--
--from qutip.core import data as _data
--from qutip.core.qobj import Qobj
--from qutip.core.superoperator import spre, spost
--
--__all__ = [
--    "BathExponent",
--    "Bath",
--    "BosonicBath",
--    "DrudeLorentzBath",
--    "DrudeLorentzPadeBath",
--    "UnderDampedBath",
--    "FermionicBath",
--    "LorentzianBath",
--    "LorentzianPadeBath",
--]
--
--
--def _isequal(Q1, Q2, tol):
--    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
--    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
--
--
--class BathExponent:
--    """
--    Represents a single exponent (naively, an excitation mode) within the
--    decomposition of the correlation functions of a bath.
--
--    Parameters
--    ----------
--    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
--        The type of bath exponent.
--
--        "R" and "I" are bosonic bath exponents that appear in the real and
--        imaginary parts of the correlation expansion.
--
--        "RI" is combined bosonic bath exponent that appears in both the real
--        and imaginary parts of the correlation expansion. The combined exponent
--        has a single ``vk``. The ``ck`` is the coefficient in the real
--        expansion and ``ck2`` is the coefficient in the imaginary expansion.
--
--        "+" and "-" are fermionic bath exponents. These fermionic bath
--        exponents must specify ``sigma_bar_k_offset`` which specifies
--        the amount to add to ``k`` (the exponent index within the bath of this
--        exponent) to determine the ``k`` of the corresponding exponent with
--        the opposite sign (i.e. "-" or "+").
--
--    dim : int or None
--        The dimension (i.e. maximum number of excitations for this exponent).
--        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
--        bosonic exponents.
--
--    Q : Qobj
--        The coupling operator for this excitation mode.
--
--    vk : complex
--        The frequency of the exponent of the excitation term.
--
--    ck : complex
--        The coefficient of the excitation term.
--
--    ck2 : optional, complex
--        For exponents of type "RI" this is the coefficient of the term in the
--        imaginary expansion (and ``ck`` is the coefficient in the real
--        expansion).
--
--    sigma_bar_k_offset : optional, int
--        For exponents of type "+" this gives the offset (within the list of
--        exponents within the bath) of the corresponding "-" bath exponent.
--        For exponents of type "-" it gives the offset of the corresponding
--        "+" exponent.
--
--    tag : optional, str, tuple or any other object
--        A label for the exponent (often the name of the bath). It
--        defaults to None.
--
--    Attributes
--    ----------
--    fermionic : bool
--        True if the type of the exponent is a Fermionic type (i.e. either
--        "+" or "-") and False otherwise.
--
--    All of the parameters are also available as attributes.
--    """
--    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
--
--    def _check_ck2(self, type, ck2):
--        if type == self.types["RI"]:
--            if ck2 is None:
--                raise ValueError("RI bath exponents require ck2")
--        else:
--            if ck2 is not None:
--                raise ValueError(
--                    "Second co-efficient (ck2) should only be specified for RI"
--                    " bath exponents"
--                )
--
--    def _check_sigma_bar_k_offset(self, type, offset):
--        if type in (self.types["+"], self.types["-"]):
--            if offset is None:
--                raise ValueError(
--                    "+ and - bath exponents require sigma_bar_k_offset"
--                )
--        else:
--            if offset is not None:
--                raise ValueError(
--                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
--                    " specified for + and - bath exponents"
--                )
--
--    def _type_is_fermionic(self, type):
--        return type in (self.types["+"], self.types["-"])
--
--    def __init__(
--            self, type, dim, Q, ck, vk, ck2=None,
--            sigma_bar_k_offset=None, tag=None,
--    ):
--        if not isinstance(type, self.types):
--            type = self.types[type]
--        self._check_ck2(type, ck2)
--        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
--        self.type = type
--        self.fermionic = self._type_is_fermionic(type)
--        self.dim = dim
--        self.Q = Q
--        self.ck = ck
--        self.vk = vk
--        self.ck2 = ck2
--        self.sigma_bar_k_offset = sigma_bar_k_offset
--        self.tag = tag
--
--    def __repr__(self):
--        dims = getattr(self.Q, "dims", None)
--        return (
--            f"<{self.__class__.__name__} type={self.type.name}"
--            f" dim={self.dim!r}"
--            f" Q.dims={dims!r}"
--            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
--            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
--            f" fermionic={self.fermionic!r}"
--            f" tag={self.tag!r}>"
--        )
--
--
--class Bath:
--    """
--    Represents a list of bath expansion exponents.
--
--    Parameters
--    ----------
--    exponents : list of BathExponent
--        The exponents of the correlation function describing the bath.
--
--    Attributes
--    ----------
--
--    All of the parameters are available as attributes.
--    """
--    def __init__(self, exponents):
--        self.exponents = exponents
--
--
--class BosonicBath(Bath):
--    """
--    A helper class for constructing a bosonic bath from the expansion
--    coefficients and frequencies for the real and imaginary parts of
--    the bath correlation function.
--
--    If the correlation functions ``C(t)`` is split into real and imaginary
--    parts::
--
--        C(t) = C_real(t) + i * C_imag(t)
--
--    then::
--
--        C_real(t) = sum(ck_real * exp(- vk_real * t))
--        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
--
--    Defines the coefficients ``ck`` and the frequencies ``vk``.
--
--    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
--    and ``C_imag(t)`` (i.e. the sum) is real.
--
--    Parameters
--    ----------
--    Q : Qobj
--        The coupling operator for the bath.
--
--    ck_real : list of complex
--        The coefficients of the expansion terms for the real part of the
--        correlation function. The corresponding frequencies are passed as
--        vk_real.
--
--    vk_real : list of complex
--        The frequencies (exponents) of the expansion terms for the real part of
--        the correlation function. The corresponding ceofficients are passed as
--        ck_real.
--
--    ck_imag : list of complex
--        The coefficients of the expansion terms in the imaginary part of the
--        correlation function. The corresponding frequencies are passed as
--        vk_imag.
--
--    vk_imag : list of complex
--        The frequencies (exponents) of the expansion terms for the imaginary
--        part of the correlation function. The corresponding ceofficients are
--        passed as ck_imag.
--
--    combine : bool, default True
--        Whether to combine exponents with the same frequency (and coupling
--        operator). See :meth:`combine` for details.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
--        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
--            raise ValueError(
--                "The bath exponent lists ck_real and vk_real, and ck_imag and"
--                " vk_imag must be the same length."
--            )
--
--    def _check_coup_op(self, Q):
--        if not isinstance(Q, Qobj):
--            raise ValueError("The coupling operator Q must be a Qobj.")
--
--    def __init__(
--            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
--            tag=None,
--    ):
--        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
--        self._check_coup_op(Q)
--
--        exponents = []
--        exponents.extend(
--            BathExponent("R", None, Q, ck, vk, tag=tag)
--            for ck, vk in zip(ck_real, vk_real)
--        )
--        exponents.extend(
--            BathExponent("I", None, Q, ck, vk, tag=tag)
--            for ck, vk in zip(ck_imag, vk_imag)
--        )
--
--        if combine:
--            exponents = self.combine(exponents)
--
--        super().__init__(exponents)
--
--    @classmethod
--    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
--        """
--        Group bosonic exponents with the same frequency and return a
--        single exponent for each frequency present.
--
--        Exponents with the same frequency are only combined if they share the
--        same coupling operator ``.Q``.
--
--        Note that combined exponents take their tag from the first
--        exponent in the group being combined (i.e. the one that occurs first
--        in the given exponents list).
--
--        Parameters
--        ----------
--        exponents : list of BathExponent
--            The list of exponents to combine.
--
--        rtol : float, default 1e-5
--            The relative tolerance to use to when comparing frequencies and
--            coupling operators.
--
--        atol : float, default 1e-7
--            The absolute tolerance to use to when comparing frequencies and
--            coupling operators.
--
--        Returns
--        -------
--        list of BathExponent
--            The new reduced list of exponents.
--        """
--        groups = []
--        remaining = exponents[:]
--
--        while remaining:
--            e1 = remaining.pop(0)
--            group = [e1]
--            for e2 in remaining[:]:
--                if (
--                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
--                    _isequal(e1.Q, e2.Q, tol=atol)
--                ):
--                    group.append(e2)
--                    remaining.remove(e2)
--            groups.append(group)
--
--        new_exponents = []
--        for combine in groups:
--            exp1 = combine[0]
--            if (exp1.type != exp1.types.RI) and all(
--                exp2.type == exp1.type for exp2 in combine
--            ):
--                # the group is either type I or R
--                ck = sum(exp.ck for exp in combine)
--                new_exponents.append(BathExponent(
--                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
--                ))
--            else:
--                # the group includes both type I and R exponents
--                ck_R = (
--                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
--                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
--                )
--                ck_I = (
--                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
--                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
--                )
--                new_exponents.append(BathExponent(
--                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
--                    tag=exp1.tag,
--                ))
--
--        return new_exponents
--
--
--class DrudeLorentzBath(BosonicBath):
--    """
--    A helper class for constructing a Drude-Lorentz bosonic bath from the
--    bath parameters (see parameters below).
--
--    Parameters
--    ----------
--    Q : Qobj
--        Operator describing the coupling between system and bath.
--
--    lam : float
--        Coupling strength.
--
--    gamma : float
--        Bath spectral density cutoff frequency.
--
--    T : float
--        Bath temperature.
--
--    Nk : int
--        Number of exponential terms used to approximate the bath correlation
--        functions.
--
--    combine : bool, default True
--        Whether to combine exponents with the same frequency (and coupling
--        operator). See :meth:`BosonicBath.combine` for details.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--    def __init__(
--        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
--    ):
--        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
--            lam=lam,
--            gamma=gamma,
--            T=T,
--            Nk=Nk,
--        )
--
--        super().__init__(
--            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
--        )
--
--        self._dl_terminator = _DrudeLorentzTerminator(
--            Q=Q, lam=lam, gamma=gamma, T=T,
--        )
--
--    def terminator(self):
--        """
--        Return the Matsubara terminator for the bath and the calculated
--        approximation discrepancy.
--
--        Returns
--        -------
--        delta: float
--
--            The approximation discrepancy. That is, the difference between the
--            true correlation function of the Drude-Lorentz bath and the sum of
--            the ``Nk`` exponential terms is approximately ``2 * delta *
--            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
--
--        terminator : Qobj
--
--            The Matsubara terminator -- i.e. a liouvillian term representing
--            the contribution to the system-bath dynamics of all exponential
--            expansion terms beyond ``Nk``. It should be used by adding it to
--            the system liouvillian (i.e. ``liouvillian(H_sys)``).
--        """
--        delta, L = self._dl_terminator.terminator(self.exponents)
--        return delta, L
--
--    def _matsubara_params(self, lam, gamma, T, Nk):
--        """ Calculate the Matsubara coefficents and frequencies. """
--        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
--        ck_real.extend([
--            (8 * lam * gamma * T * np.pi * k * T /
--                ((2 * np.pi * k * T)**2 - gamma**2))
--            for k in range(1, Nk + 1)
--        ])
--        vk_real = [gamma]
--        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
--
--        ck_imag = [lam * gamma * (-1.0)]
--        vk_imag = [gamma]
--
--        return ck_real, vk_real, ck_imag, vk_imag
--
--
--class DrudeLorentzPadeBath(BosonicBath):
--    """
--    A helper class for constructing a Padé expansion for a Drude-Lorentz
--    bosonic bath from the bath parameters (see parameters below).
--
--    A Padé approximant is a sum-over-poles expansion (
--    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
--
--    The application of the Padé method to spectrum decompoisitions is described
--    in "Padé spectrum decompositions of quantum distribution functions and
--    optimal hierarchical equations of motion construction for quantum open
--    systems" [1].
--
--    The implementation here follows the approach in the paper.
--
--    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
--
--    This is an alternative to the :class:`DrudeLorentzBath` which constructs
--    a simpler exponential expansion.
--
--    Parameters
--    ----------
--    Q : Qobj
--        Operator describing the coupling between system and bath.
--
--    lam : float
--        Coupling strength.
--
--    gamma : float
--        Bath spectral density cutoff frequency.
--
--    T : float
--        Bath temperature.
--
--    Nk : int
--        Number of Padé exponentials terms used to approximate the bath
--        correlation functions.
--
--    combine : bool, default True
--        Whether to combine exponents with the same frequency (and coupling
--        operator). See :meth:`BosonicBath.combine` for details.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--    def __init__(
--        self, Q, lam, gamma, T, Nk, combine=True, tag=None
--    ):
--        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
--
--        ck_real = [np.real(eta) for eta in eta_p]
--        vk_real = [gam for gam in gamma_p]
--        # There is only one term in the expansion of the imaginary part of the
--        # Drude-Lorentz correlation function.
--        ck_imag = [np.imag(eta_p[0])]
--        vk_imag = [gamma_p[0]]
--
--        super().__init__(
--            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
--        )
--
--        self._dl_terminator = _DrudeLorentzTerminator(
--            Q=Q, lam=lam, gamma=gamma, T=T,
--        )
--
--    def terminator(self):
--        """
--        Return the Padé terminator for the bath and the calculated
--        approximation discrepancy.
--
--        Returns
--        -------
--        delta: float
--
--            The approximation discrepancy. That is, the difference between the
--            true correlation function of the Drude-Lorentz bath and the sum of
--            the ``Nk`` exponential terms is approximately ``2 * delta *
--            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
--
--        terminator : Qobj
--
--            The Padé terminator -- i.e. a liouvillian term representing
--            the contribution to the system-bath dynamics of all exponential
--            expansion terms beyond ``Nk``. It should be used by adding it to
--            the system liouvillian (i.e. ``liouvillian(H_sys)``).
--        """
--        delta, L = self._dl_terminator.terminator(self.exponents)
--        return delta, L
--
--    def _corr(self, lam, gamma, T, Nk):
--        beta = 1. / T
--        kappa, epsilon = self._kappa_epsilon(Nk)
--
--        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
--        gamma_p = [gamma]
--
--        for ll in range(1, Nk + 1):
--            eta_p.append(
--                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
--                / ((epsilon[ll]**2 / beta**2) - gamma**2)
--            )
--            gamma_p.append(epsilon[ll] / beta)
--
--        return eta_p, gamma_p
--
--    def _cot(self, x):
--        return 1. / np.tan(x)
--
--    def _kappa_epsilon(self, Nk):
--        eps = self._calc_eps(Nk)
--        chi = self._calc_chi(Nk)
--
--        kappa = [0]
--        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
--        for j in range(Nk):
--            term = prefactor
--            for k in range(Nk - 1):
--                term *= (
--                    (chi[k]**2 - eps[j]**2) /
--                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
--                )
--            for k in [Nk - 1]:
--                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
--            kappa.append(term)
--
--        epsilon = [0] + eps
--
--        return kappa, epsilon
--
--    def _delta(self, i, j):
--        return 1.0 if i == j else 0.0
--
--    def _calc_eps(self, Nk):
--        alpha = np.diag([
--                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
--                for k in range(2 * Nk - 1)
--        ], k=1)
--        alpha += alpha.transpose()
--        evals = eigvalsh(alpha)
--        eps = [-2. / val for val in evals[0: Nk]]
--        return eps
--
--    def _calc_chi(self, Nk):
--        alpha_p = np.diag([
--                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
--                for k in range(2 * Nk - 2)
--        ], k=1)
--        alpha_p += alpha_p.transpose()
--        evals = eigvalsh(alpha_p)
--        chi = [-2. / val for val in evals[0: Nk - 1]]
--        return chi
--
--
--class _DrudeLorentzTerminator:
--    """ A class for calculating the terminator of a Drude-Lorentz bath
--        expansion.
--    """
--    def __init__(self, Q, lam, gamma, T):
--        self.Q = Q
--        self.lam = lam
--        self.gamma = gamma
--        self.T = T
--
--    def terminator(self, exponents):
--        """ Calculate the terminator for a Drude-Lorentz bath. """
--        Q = self.Q
--        lam = self.lam
--        gamma = self.gamma
--        beta = 1 / self.T
--
--        delta = 2 * lam / (beta * gamma) - 1j * lam
--
--        for exp in exponents:
--            if exp.type == BathExponent.types["R"]:
--                delta -= exp.ck / exp.vk
--            elif exp.type == BathExponent.types["RI"]:
--                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
--            else:
--                delta -= 1j * exp.ck / exp.vk
--
--        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
--        L_bnd = -delta * op
--
--        return delta, L_bnd
--
--
--class UnderDampedBath(BosonicBath):
--    """
--    A helper class for constructing an under-damped bosonic bath from the
--    bath parameters (see parameters below).
--
--    Parameters
--    ----------
--    Q : Qobj
--        Operator describing the coupling between system and bath.
--
--    lam : float
--        Coupling strength.
--
--    gamma : float
--        Bath spectral density cutoff frequency.
--
--    w0 : float
--        Bath spectral density resonance frequency.
--
--    T : float
--        Bath temperature.
--
--    Nk : int
--        Number of exponential terms used to approximate the bath correlation
--        functions.
--
--    combine : bool, default True
--        Whether to combine exponents with the same frequency (and coupling
--        operator). See :meth:`BosonicBath.combine` for details.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--    def __init__(
--        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
--    ):
--        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
--            lam=lam,
--            gamma=gamma,
--            w0=w0,
--            T=T,
--            Nk=Nk,
--        )
--
--        super().__init__(
--            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
--        )
--
--    def _matsubara_params(self, lam, gamma, w0, T, Nk):
--        """ Calculate the Matsubara coefficents and frequencies. """
--        beta = 1/T
--        Om = np.sqrt(w0**2 - (gamma/2)**2)
--        Gamma = gamma/2.
--
--        ck_real = ([
--            (lam**2 / (4 * Om))
--            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
--            (lam**2 / (4*Om))
--            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
--        ])
--
--        ck_real.extend([
--            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
--            / (
--                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
--                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
--            )
--            for k in range(1, Nk + 1)
--        ])
--
--        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
--        vk_real.extend([
--            2 * np.pi * k * T
--            for k in range(1, Nk + 1)
--        ])
--
--        ck_imag = [
--            1.0j * lam**2 / (4 * Om),
--            -1.0j * lam**2 / (4 * Om),
--        ]
--
--        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
--
--        return ck_real, vk_real, ck_imag, vk_imag
--
--
--class FermionicBath(Bath):
--    """
--    A helper class for constructing a fermionic bath from the expansion
--    coefficients and frequencies for the ``+`` and ``-`` modes of
--    the bath correlation function.
--
--    There must be the same number of ``+`` and ``-`` modes and their
--    coefficients must be specified in the same order so that ``ck_plus[i],
--    vk_plus[i]`` are the plus coefficient and frequency corresponding
--    to the minus mode ``ck_minus[i], vk_minus[i]``.
--
--    In the fermionic case the order in which excitations are created or
--    destroyed is important, resulting in two different correlation functions
--    labelled ``C_plus(t)`` and ``C_plus(t)``::
--
--        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
--        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
--
--    where the expansions above define the coeffiients ``ck`` and the
--    frequencies ``vk``.
--
--    Parameters
--    ----------
--    Q : Qobj
--        The coupling operator for the bath.
--
--    ck_plus : list of complex
--        The coefficients of the expansion terms for the ``+`` part of the
--        correlation function. The corresponding frequencies are passed as
--        vk_plus.
--
--    vk_plus : list of complex
--        The frequencies (exponents) of the expansion terms for the ``+`` part
--        of the correlation function. The corresponding ceofficients are passed
--        as ck_plus.
--
--    ck_minus : list of complex
--        The coefficients of the expansion terms for the ``-`` part of the
--        correlation function. The corresponding frequencies are passed as
--        vk_minus.
--
--    vk_minus : list of complex
--        The frequencies (exponents) of the expansion terms for the ``-`` part
--        of the correlation function. The corresponding ceofficients are passed
--        as ck_minus.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--
--    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
--        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
--            raise ValueError(
--                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
--                " vk_minus must be the same length."
--            )
--        if len(ck_plus) != len(ck_minus):
--            raise ValueError(
--                "The must be the same number of plus and minus exponents"
--                " in the bath, and elements of plus and minus arrays"
--                " should be arranged so that ck_plus[i] is the plus mode"
--                " corresponding to ck_minus[i]."
--            )
--
--    def _check_coup_op(self, Q):
--        if not isinstance(Q, Qobj):
--            raise ValueError("The coupling operator Q must be a Qobj.")
--
--    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
--        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
--        self._check_coup_op(Q)
--
--        exponents = []
--        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
--            exponents.append(BathExponent(
--                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
--            ))
--            exponents.append(BathExponent(
--                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
--            ))
--        super().__init__(exponents)
--
--
--class LorentzianBath(FermionicBath):
--    """
--    A helper class for constructing a Lorentzian fermionic bath from the
--    bath parameters (see parameters below).
--
--    .. note::
--
--        This Matsubara expansion used in this bath converges very slowly
--        and ``Nk > 20`` may be required to get good convergence. The
--        Padé expansion used by :class:`LorentzianPadeBath` converges much
--        more quickly.
--
--    Parameters
--    ----------
--    Q : Qobj
--        Operator describing the coupling between system and bath.
--
--    gamma : float
--        The coupling strength between the system and the bath.
--
--    w : float
--        The width of the environment.
--
--    mu : float
--        The chemical potential of the bath.
--
--    T : float
--        Bath temperature.
--
--    Nk : int
--        Number of exponential terms used to approximate the bath correlation
--        functions.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
--        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
--        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
--
--        super().__init__(
--            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
--        )
--
--    def _corr(self, gamma, w, mu, T, Nk, sigma):
--        beta = 1. / T
--        kappa = [0.]
--        kappa.extend([1. for _ in range(1, Nk + 1)])
--        epsilon = [0]
--        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
--
--        def f(x):
--            return 1 / (np.exp(x) + 1)
--
--        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
--        gamma_list = [w - sigma * 1.0j * mu]
--
--        for ll in range(1, Nk + 1):
--            eta_list.append(
--                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
--                (-(epsilon[ll]**2 / beta**2) + w**2)
--            )
--            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
--
--        return eta_list, gamma_list
--
--
--class LorentzianPadeBath(FermionicBath):
--    """
--    A helper class for constructing a Padé expansion for Lorentzian fermionic
--    bath from the bath parameters (see parameters below).
--
--    A Padé approximant is a sum-over-poles expansion (
--    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
--
--    The application of the Padé method to spectrum decompoisitions is described
--    in "Padé spectrum decompositions of quantum distribution functions and
--    optimal hierarchical equations of motion construction for quantum open
--    systems" [1].
--
--    The implementation here follows the approach in the paper.
--
--    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
--
--    This is an alternative to the :class:`LorentzianBath` which constructs
--    a simpler exponential expansion that converges much more slowly in
--    this particular case.
--
--    Parameters
--    ----------
--    Q : Qobj
--        Operator describing the coupling between system and bath.
--
--    gamma : float
--        The coupling strength between the system and the bath.
--
--    w : float
--        The width of the environment.
--
--    mu : float
--        The chemical potential of the bath.
--
--    T : float
--        Bath temperature.
--
--    Nk : int
--        Number of exponential terms used to approximate the bath correlation
--        functions.
--
--    tag : optional, str, tuple or any other object
--        A label for the bath exponents (for example, the name of the
--        bath). It defaults to None but can be set to help identify which
--        bath an exponent is from.
--    """
--    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
--        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
--        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
--
--        super().__init__(
--            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
--        )
--
--    def _corr(self, gamma, w, mu, T, Nk, sigma):
--        beta = 1. / T
--        kappa, epsilon = self._kappa_epsilon(Nk)
--
--        def f_approx(x):
--            f = 0.5
--            for ll in range(1, Nk + 1):
--                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
--            return f
--
--        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
--        gamma_list = [w - sigma * 1.0j * mu]
--
--        for ll in range(1, Nk + 1):
--            eta_list.append(
--                -1.0j * (kappa[ll] / beta) * gamma * w**2
--                / (-(epsilon[ll]**2 / beta**2) + w**2)
--            )
--            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
--
--        return eta_list, gamma_list
--
--    def _kappa_epsilon(self, Nk):
--        eps = self._calc_eps(Nk)
--        chi = self._calc_chi(Nk)
--
--        kappa = [0]
--        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
--        for j in range(Nk):
--            term = prefactor
--            for k in range(Nk - 1):
--                term *= (
--                    (chi[k]**2 - eps[j]**2) /
--                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
--                )
--            for k in [Nk - 1]:
--                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
--            kappa.append(term)
--
--        epsilon = [0] + eps
--
--        return kappa, epsilon
--
--    def _delta(self, i, j):
--        return 1.0 if i == j else 0.0
--
--    def _calc_eps(self, Nk):
--        alpha = np.diag([
--                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
--                for k in range(2 * Nk - 1)
--        ], k=1)
--        alpha += alpha.transpose()
--
--        evals = eigvalsh(alpha)
--        eps = [-2. / val for val in evals[0: Nk]]
--        return eps
--
--    def _calc_chi(self, Nk):
--        alpha_p = np.diag([
--                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
--                for k in range(2 * Nk - 2)
--        ], k=1)
--        alpha_p += alpha_p.transpose()
--        evals = eigvalsh(alpha_p)
--        chi = [-2. / val for val in evals[0: Nk - 1]]
--        return chi
-+"""
-+This module provides utilities for describing baths when using the
-+HEOM (hierarchy equations of motion) to model system-bath interactions.
-+
-+See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
-+
-+The implementation is derived from the BoFiN library (see
-+https://github.com/tehruhn/bofin) which was itself derived from an earlier
-+implementation in QuTiP itself.
-+"""
-+
-+import enum
-+
-+import numpy as np
-+from scipy.linalg import eigvalsh
-+
-+from qutip.core import data as _data
-+from qutip.core.qobj import Qobj
-+from qutip.core.superoperator import spre, spost
-+
-+__all__ = [
-+    "BathExponent",
-+    "Bath",
-+    "BosonicBath",
-+    "DrudeLorentzBath",
-+    "DrudeLorentzPadeBath",
-+    "UnderDampedBath",
-+    "FermionicBath",
-+    "LorentzianBath",
-+    "LorentzianPadeBath",
-+]
-+
-+
-+def _isequal(Q1, Q2, tol):
-+    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
-+    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
-+
-+
-+class BathExponent:
-+    """
-+    Represents a single exponent (naively, an excitation mode) within the
-+    decomposition of the correlation functions of a bath.
-+
-+    Parameters
-+    ----------
-+    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
-+        The type of bath exponent.
-+
-+        "R" and "I" are bosonic bath exponents that appear in the real and
-+        imaginary parts of the correlation expansion.
-+
-+        "RI" is combined bosonic bath exponent that appears in both the real
-+        and imaginary parts of the correlation expansion. The combined exponent
-+        has a single ``vk``. The ``ck`` is the coefficient in the real
-+        expansion and ``ck2`` is the coefficient in the imaginary expansion.
-+
-+        "+" and "-" are fermionic bath exponents. These fermionic bath
-+        exponents must specify ``sigma_bar_k_offset`` which specifies
-+        the amount to add to ``k`` (the exponent index within the bath of this
-+        exponent) to determine the ``k`` of the corresponding exponent with
-+        the opposite sign (i.e. "-" or "+").
-+
-+    dim : int or None
-+        The dimension (i.e. maximum number of excitations for this exponent).
-+        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
-+        bosonic exponents.
-+
-+    Q : Qobj
-+        The coupling operator for this excitation mode.
-+
-+    vk : complex
-+        The frequency of the exponent of the excitation term.
-+
-+    ck : complex
-+        The coefficient of the excitation term.
-+
-+    ck2 : optional, complex
-+        For exponents of type "RI" this is the coefficient of the term in the
-+        imaginary expansion (and ``ck`` is the coefficient in the real
-+        expansion).
-+
-+    sigma_bar_k_offset : optional, int
-+        For exponents of type "+" this gives the offset (within the list of
-+        exponents within the bath) of the corresponding "-" bath exponent.
-+        For exponents of type "-" it gives the offset of the corresponding
-+        "+" exponent.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the exponent (often the name of the bath). It
-+        defaults to None.
-+
-+    Attributes
-+    ----------
-+    fermionic : bool
-+        True if the type of the exponent is a Fermionic type (i.e. either
-+        "+" or "-") and False otherwise.
-+
-+    All of the parameters are also available as attributes.
-+    """
-+    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
-+
-+    def _check_ck2(self, type, ck2):
-+        if type == self.types["RI"]:
-+            if ck2 is None:
-+                raise ValueError("RI bath exponents require ck2")
-+        else:
-+            if ck2 is not None:
-+                raise ValueError(
-+                    "Second co-efficient (ck2) should only be specified for RI"
-+                    " bath exponents"
-+                )
-+
-+    def _check_sigma_bar_k_offset(self, type, offset):
-+        if type in (self.types["+"], self.types["-"]):
-+            if offset is None:
-+                raise ValueError(
-+                    "+ and - bath exponents require sigma_bar_k_offset"
-+                )
-+        else:
-+            if offset is not None:
-+                raise ValueError(
-+                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
-+                    " specified for + and - bath exponents"
-+                )
-+
-+    def _type_is_fermionic(self, type):
-+        return type in (self.types["+"], self.types["-"])
-+
-+    def __init__(
-+            self, type, dim, Q, ck, vk, ck2=None,
-+            sigma_bar_k_offset=None, tag=None,
-+    ):
-+        if not isinstance(type, self.types):
-+            type = self.types[type]
-+        self._check_ck2(type, ck2)
-+        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
-+        self.type = type
-+        self.fermionic = self._type_is_fermionic(type)
-+        self.dim = dim
-+        self.Q = Q
-+        self.ck = ck
-+        self.vk = vk
-+        self.ck2 = ck2
-+        self.sigma_bar_k_offset = sigma_bar_k_offset
-+        self.tag = tag
-+
-+    def __repr__(self):
-+        dims = getattr(self.Q, "dims", None)
-+        return (
-+            f"<{self.__class__.__name__} type={self.type.name}"
-+            f" dim={self.dim!r}"
-+            f" Q.dims={dims!r}"
-+            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
-+            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
-+            f" fermionic={self.fermionic!r}"
-+            f" tag={self.tag!r}>"
-+        )
-+
-+
-+class Bath:
-+    """
-+    Represents a list of bath expansion exponents.
-+
-+    Parameters
-+    ----------
-+    exponents : list of BathExponent
-+        The exponents of the correlation function describing the bath.
-+
-+    Attributes
-+    ----------
-+
-+    All of the parameters are available as attributes.
-+    """
-+    def __init__(self, exponents):
-+        self.exponents = exponents
-+
-+
-+class BosonicBath(Bath):
-+    """
-+    A helper class for constructing a bosonic bath from the expansion
-+    coefficients and frequencies for the real and imaginary parts of
-+    the bath correlation function.
-+
-+    If the correlation functions ``C(t)`` is split into real and imaginary
-+    parts::
-+
-+        C(t) = C_real(t) + i * C_imag(t)
-+
-+    then::
-+
-+        C_real(t) = sum(ck_real * exp(- vk_real * t))
-+        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
-+
-+    Defines the coefficients ``ck`` and the frequencies ``vk``.
-+
-+    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
-+    and ``C_imag(t)`` (i.e. the sum) is real.
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        The coupling operator for the bath.
-+
-+    ck_real : list of complex
-+        The coefficients of the expansion terms for the real part of the
-+        correlation function. The corresponding frequencies are passed as
-+        vk_real.
-+
-+    vk_real : list of complex
-+        The frequencies (exponents) of the expansion terms for the real part of
-+        the correlation function. The corresponding ceofficients are passed as
-+        ck_real.
-+
-+    ck_imag : list of complex
-+        The coefficients of the expansion terms in the imaginary part of the
-+        correlation function. The corresponding frequencies are passed as
-+        vk_imag.
-+
-+    vk_imag : list of complex
-+        The frequencies (exponents) of the expansion terms for the imaginary
-+        part of the correlation function. The corresponding ceofficients are
-+        passed as ck_imag.
-+
-+    combine : bool, default True
-+        Whether to combine exponents with the same frequency (and coupling
-+        operator). See :meth:`combine` for details.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
-+        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
-+            raise ValueError(
-+                "The bath exponent lists ck_real and vk_real, and ck_imag and"
-+                " vk_imag must be the same length."
-+            )
-+
-+    def _check_coup_op(self, Q):
-+        if not isinstance(Q, Qobj):
-+            raise ValueError("The coupling operator Q must be a Qobj.")
-+
-+    def __init__(
-+            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
-+            tag=None,
-+    ):
-+        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
-+        self._check_coup_op(Q)
-+
-+        exponents = []
-+        exponents.extend(
-+            BathExponent("R", None, Q, ck, vk, tag=tag)
-+            for ck, vk in zip(ck_real, vk_real)
-+        )
-+        exponents.extend(
-+            BathExponent("I", None, Q, ck, vk, tag=tag)
-+            for ck, vk in zip(ck_imag, vk_imag)
-+        )
-+
-+        if combine:
-+            exponents = self.combine(exponents)
-+
-+        super().__init__(exponents)
-+
-+    @classmethod
-+    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
-+        """
-+        Group bosonic exponents with the same frequency and return a
-+        single exponent for each frequency present.
-+
-+        Exponents with the same frequency are only combined if they share the
-+        same coupling operator ``.Q``.
-+
-+        Note that combined exponents take their tag from the first
-+        exponent in the group being combined (i.e. the one that occurs first
-+        in the given exponents list).
-+
-+        Parameters
-+        ----------
-+        exponents : list of BathExponent
-+            The list of exponents to combine.
-+
-+        rtol : float, default 1e-5
-+            The relative tolerance to use to when comparing frequencies and
-+            coupling operators.
-+
-+        atol : float, default 1e-7
-+            The absolute tolerance to use to when comparing frequencies and
-+            coupling operators.
-+
-+        Returns
-+        -------
-+        list of BathExponent
-+            The new reduced list of exponents.
-+        """
-+        groups = []
-+        remaining = exponents[:]
-+
-+        while remaining:
-+            e1 = remaining.pop(0)
-+            group = [e1]
-+            for e2 in remaining[:]:
-+                if (
-+                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
-+                    _isequal(e1.Q, e2.Q, tol=atol)
-+                ):
-+                    group.append(e2)
-+                    remaining.remove(e2)
-+            groups.append(group)
-+
-+        new_exponents = []
-+        for combine in groups:
-+            exp1 = combine[0]
-+            if (exp1.type != exp1.types.RI) and all(
-+                exp2.type == exp1.type for exp2 in combine
-+            ):
-+                # the group is either type I or R
-+                ck = sum(exp.ck for exp in combine)
-+                new_exponents.append(BathExponent(
-+                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
-+                ))
-+            else:
-+                # the group includes both type I and R exponents
-+                ck_R = (
-+                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
-+                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
-+                )
-+                ck_I = (
-+                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
-+                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
-+                )
-+                new_exponents.append(BathExponent(
-+                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
-+                    tag=exp1.tag,
-+                ))
-+
-+        return new_exponents
-+
-+
-+class DrudeLorentzBath(BosonicBath):
-+    """
-+    A helper class for constructing a Drude-Lorentz bosonic bath from the
-+    bath parameters (see parameters below).
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        Operator describing the coupling between system and bath.
-+
-+    lam : float
-+        Coupling strength.
-+
-+    gamma : float
-+        Bath spectral density cutoff frequency.
-+
-+    T : float
-+        Bath temperature.
-+
-+    Nk : int
-+        Number of exponential terms used to approximate the bath correlation
-+        functions.
-+
-+    combine : bool, default True
-+        Whether to combine exponents with the same frequency (and coupling
-+        operator). See :meth:`BosonicBath.combine` for details.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+    def __init__(
-+        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
-+    ):
-+        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
-+            lam=lam,
-+            gamma=gamma,
-+            T=T,
-+            Nk=Nk,
-+        )
-+
-+        super().__init__(
-+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-+        )
-+
-+        self._dl_terminator = _DrudeLorentzTerminator(
-+            Q=Q, lam=lam, gamma=gamma, T=T,
-+        )
-+
-+    def terminator(self):
-+        """
-+        Return the Matsubara terminator for the bath and the calculated
-+        approximation discrepancy.
-+
-+        Returns
-+        -------
-+        delta: float
-+
-+            The approximation discrepancy. That is, the difference between the
-+            true correlation function of the Drude-Lorentz bath and the sum of
-+            the ``Nk`` exponential terms is approximately ``2 * delta *
-+            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
-+
-+        terminator : Qobj
-+
-+            The Matsubara terminator -- i.e. a liouvillian term representing
-+            the contribution to the system-bath dynamics of all exponential
-+            expansion terms beyond ``Nk``. It should be used by adding it to
-+            the system liouvillian (i.e. ``liouvillian(H_sys)``).
-+        """
-+        delta, L = self._dl_terminator.terminator(self.exponents)
-+        return delta, L
-+
-+    def _matsubara_params(self, lam, gamma, T, Nk):
-+        """ Calculate the Matsubara coefficents and frequencies. """
-+        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
-+        ck_real.extend([
-+            (8 * lam * gamma * T * np.pi * k * T /
-+                ((2 * np.pi * k * T)**2 - gamma**2))
-+            for k in range(1, Nk + 1)
-+        ])
-+        vk_real = [gamma]
-+        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
-+
-+        ck_imag = [lam * gamma * (-1.0)]
-+        vk_imag = [gamma]
-+
-+        return ck_real, vk_real, ck_imag, vk_imag
-+
-+
-+class DrudeLorentzPadeBath(BosonicBath):
-+    """
-+    A helper class for constructing a Padé expansion for a Drude-Lorentz
-+    bosonic bath from the bath parameters (see parameters below).
-+
-+    A Padé approximant is a sum-over-poles expansion (
-+    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
-+
-+    The application of the Padé method to spectrum decompoisitions is described
-+    in "Padé spectrum decompositions of quantum distribution functions and
-+    optimal hierarchical equations of motion construction for quantum open
-+    systems" [1].
-+
-+    The implementation here follows the approach in the paper.
-+
-+    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
-+
-+    This is an alternative to the :class:`DrudeLorentzBath` which constructs
-+    a simpler exponential expansion.
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        Operator describing the coupling between system and bath.
-+
-+    lam : float
-+        Coupling strength.
-+
-+    gamma : float
-+        Bath spectral density cutoff frequency.
-+
-+    T : float
-+        Bath temperature.
-+
-+    Nk : int
-+        Number of Padé exponentials terms used to approximate the bath
-+        correlation functions.
-+
-+    combine : bool, default True
-+        Whether to combine exponents with the same frequency (and coupling
-+        operator). See :meth:`BosonicBath.combine` for details.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+    def __init__(
-+        self, Q, lam, gamma, T, Nk, combine=True, tag=None
-+    ):
-+        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
-+
-+        ck_real = [np.real(eta) for eta in eta_p]
-+        vk_real = [gam for gam in gamma_p]
-+        # There is only one term in the expansion of the imaginary part of the
-+        # Drude-Lorentz correlation function.
-+        ck_imag = [np.imag(eta_p[0])]
-+        vk_imag = [gamma_p[0]]
-+
-+        super().__init__(
-+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-+        )
-+
-+        self._dl_terminator = _DrudeLorentzTerminator(
-+            Q=Q, lam=lam, gamma=gamma, T=T,
-+        )
-+
-+    def terminator(self):
-+        """
-+        Return the Padé terminator for the bath and the calculated
-+        approximation discrepancy.
-+
-+        Returns
-+        -------
-+        delta: float
-+
-+            The approximation discrepancy. That is, the difference between the
-+            true correlation function of the Drude-Lorentz bath and the sum of
-+            the ``Nk`` exponential terms is approximately ``2 * delta *
-+            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
-+
-+        terminator : Qobj
-+
-+            The Padé terminator -- i.e. a liouvillian term representing
-+            the contribution to the system-bath dynamics of all exponential
-+            expansion terms beyond ``Nk``. It should be used by adding it to
-+            the system liouvillian (i.e. ``liouvillian(H_sys)``).
-+        """
-+        delta, L = self._dl_terminator.terminator(self.exponents)
-+        return delta, L
-+
-+    def _corr(self, lam, gamma, T, Nk):
-+        beta = 1. / T
-+        kappa, epsilon = self._kappa_epsilon(Nk)
-+
-+        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
-+        gamma_p = [gamma]
-+
-+        for ll in range(1, Nk + 1):
-+            eta_p.append(
-+                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
-+                / ((epsilon[ll]**2 / beta**2) - gamma**2)
-+            )
-+            gamma_p.append(epsilon[ll] / beta)
-+
-+        return eta_p, gamma_p
-+
-+    def _cot(self, x):
-+        return 1. / np.tan(x)
-+
-+    def _kappa_epsilon(self, Nk):
-+        eps = self._calc_eps(Nk)
-+        chi = self._calc_chi(Nk)
-+
-+        kappa = [0]
-+        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
-+        for j in range(Nk):
-+            term = prefactor
-+            for k in range(Nk - 1):
-+                term *= (
-+                    (chi[k]**2 - eps[j]**2) /
-+                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-+                )
-+            for k in [Nk - 1]:
-+                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-+            kappa.append(term)
-+
-+        epsilon = [0] + eps
-+
-+        return kappa, epsilon
-+
-+    def _delta(self, i, j):
-+        return 1.0 if i == j else 0.0
-+
-+    def _calc_eps(self, Nk):
-+        alpha = np.diag([
-+                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
-+                for k in range(2 * Nk - 1)
-+        ], k=1)
-+        alpha += alpha.transpose()
-+        evals = eigvalsh(alpha)
-+        eps = [-2. / val for val in evals[0: Nk]]
-+        return eps
-+
-+    def _calc_chi(self, Nk):
-+        alpha_p = np.diag([
-+                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
-+                for k in range(2 * Nk - 2)
-+        ], k=1)
-+        alpha_p += alpha_p.transpose()
-+        evals = eigvalsh(alpha_p)
-+        chi = [-2. / val for val in evals[0: Nk - 1]]
-+        return chi
-+
-+
-+class _DrudeLorentzTerminator:
-+    """ A class for calculating the terminator of a Drude-Lorentz bath
-+        expansion.
-+    """
-+    def __init__(self, Q, lam, gamma, T):
-+        self.Q = Q
-+        self.lam = lam
-+        self.gamma = gamma
-+        self.T = T
-+
-+    def terminator(self, exponents):
-+        """ Calculate the terminator for a Drude-Lorentz bath. """
-+        Q = self.Q
-+        lam = self.lam
-+        gamma = self.gamma
-+        beta = 1 / self.T
-+
-+        delta = 2 * lam / (beta * gamma) - 1j * lam
-+
-+        for exp in exponents:
-+            if exp.type == BathExponent.types["R"]:
-+                delta -= exp.ck / exp.vk
-+            elif exp.type == BathExponent.types["RI"]:
-+                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
-+            else:
-+                delta -= 1j * exp.ck / exp.vk
-+
-+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-+        L_bnd = -delta * op
-+
-+        return delta, L_bnd
-+
-+
-+class UnderDampedBath(BosonicBath):
-+    """
-+    A helper class for constructing an under-damped bosonic bath from the
-+    bath parameters (see parameters below).
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        Operator describing the coupling between system and bath.
-+
-+    lam : float
-+        Coupling strength.
-+
-+    gamma : float
-+        Bath spectral density cutoff frequency.
-+
-+    w0 : float
-+        Bath spectral density resonance frequency.
-+
-+    T : float
-+        Bath temperature.
-+
-+    Nk : int
-+        Number of exponential terms used to approximate the bath correlation
-+        functions.
-+
-+    combine : bool, default True
-+        Whether to combine exponents with the same frequency (and coupling
-+        operator). See :meth:`BosonicBath.combine` for details.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+    def __init__(
-+        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
-+    ):
-+        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
-+            lam=lam,
-+            gamma=gamma,
-+            w0=w0,
-+            T=T,
-+            Nk=Nk,
-+        )
-+
-+        super().__init__(
-+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-+        )
-+
-+    def _matsubara_params(self, lam, gamma, w0, T, Nk):
-+        """ Calculate the Matsubara coefficents and frequencies. """
-+        beta = 1/T
-+        Om = np.sqrt(w0**2 - (gamma/2)**2)
-+        Gamma = gamma/2.
-+
-+        ck_real = ([
-+            (lam**2 / (4 * Om))
-+            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
-+            (lam**2 / (4*Om))
-+            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
-+        ])
-+
-+        ck_real.extend([
-+            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
-+            / (
-+                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
-+                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
-+            )
-+            for k in range(1, Nk + 1)
-+        ])
-+
-+        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
-+        vk_real.extend([
-+            2 * np.pi * k * T
-+            for k in range(1, Nk + 1)
-+        ])
-+
-+        ck_imag = [
-+            1.0j * lam**2 / (4 * Om),
-+            -1.0j * lam**2 / (4 * Om),
-+        ]
-+
-+        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
-+
-+        return ck_real, vk_real, ck_imag, vk_imag
-+
-+
-+class FermionicBath(Bath):
-+    """
-+    A helper class for constructing a fermionic bath from the expansion
-+    coefficients and frequencies for the ``+`` and ``-`` modes of
-+    the bath correlation function.
-+
-+    There must be the same number of ``+`` and ``-`` modes and their
-+    coefficients must be specified in the same order so that ``ck_plus[i],
-+    vk_plus[i]`` are the plus coefficient and frequency corresponding
-+    to the minus mode ``ck_minus[i], vk_minus[i]``.
-+
-+    In the fermionic case the order in which excitations are created or
-+    destroyed is important, resulting in two different correlation functions
-+    labelled ``C_plus(t)`` and ``C_plus(t)``::
-+
-+        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
-+        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
-+
-+    where the expansions above define the coeffiients ``ck`` and the
-+    frequencies ``vk``.
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        The coupling operator for the bath.
-+
-+    ck_plus : list of complex
-+        The coefficients of the expansion terms for the ``+`` part of the
-+        correlation function. The corresponding frequencies are passed as
-+        vk_plus.
-+
-+    vk_plus : list of complex
-+        The frequencies (exponents) of the expansion terms for the ``+`` part
-+        of the correlation function. The corresponding ceofficients are passed
-+        as ck_plus.
-+
-+    ck_minus : list of complex
-+        The coefficients of the expansion terms for the ``-`` part of the
-+        correlation function. The corresponding frequencies are passed as
-+        vk_minus.
-+
-+    vk_minus : list of complex
-+        The frequencies (exponents) of the expansion terms for the ``-`` part
-+        of the correlation function. The corresponding ceofficients are passed
-+        as ck_minus.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+
-+    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
-+        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
-+            raise ValueError(
-+                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-+                " vk_minus must be the same length."
-+            )
-+        if len(ck_plus) != len(ck_minus):
-+            raise ValueError(
-+                "The must be the same number of plus and minus exponents"
-+                " in the bath, and elements of plus and minus arrays"
-+                " should be arranged so that ck_plus[i] is the plus mode"
-+                " corresponding to ck_minus[i]."
-+            )
-+
-+    def _check_coup_op(self, Q):
-+        if not isinstance(Q, Qobj):
-+            raise ValueError("The coupling operator Q must be a Qobj.")
-+
-+    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
-+        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
-+        self._check_coup_op(Q)
-+
-+        exponents = []
-+        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
-+            exponents.append(BathExponent(
-+                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
-+            ))
-+            exponents.append(BathExponent(
-+                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
-+            ))
-+        super().__init__(exponents)
-+
-+
-+class LorentzianBath(FermionicBath):
-+    """
-+    A helper class for constructing a Lorentzian fermionic bath from the
-+    bath parameters (see parameters below).
-+
-+    .. note::
-+
-+        This Matsubara expansion used in this bath converges very slowly
-+        and ``Nk > 20`` may be required to get good convergence. The
-+        Padé expansion used by :class:`LorentzianPadeBath` converges much
-+        more quickly.
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        Operator describing the coupling between system and bath.
-+
-+    gamma : float
-+        The coupling strength between the system and the bath.
-+
-+    w : float
-+        The width of the environment.
-+
-+    mu : float
-+        The chemical potential of the bath.
-+
-+    T : float
-+        Bath temperature.
-+
-+    Nk : int
-+        Number of exponential terms used to approximate the bath correlation
-+        functions.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
-+        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
-+        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
-+
-+        super().__init__(
-+            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
-+        )
-+
-+    def _corr(self, gamma, w, mu, T, Nk, sigma):
-+        beta = 1. / T
-+        kappa = [0.]
-+        kappa.extend([1. for _ in range(1, Nk + 1)])
-+        epsilon = [0]
-+        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
-+
-+        def f(x):
-+            return 1 / (np.exp(x) + 1)
-+
-+        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
-+        gamma_list = [w - sigma * 1.0j * mu]
-+
-+        for ll in range(1, Nk + 1):
-+            eta_list.append(
-+                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
-+                (-(epsilon[ll]**2 / beta**2) + w**2)
-+            )
-+            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
-+
-+        return eta_list, gamma_list
-+
-+
-+class LorentzianPadeBath(FermionicBath):
-+    """
-+    A helper class for constructing a Padé expansion for Lorentzian fermionic
-+    bath from the bath parameters (see parameters below).
-+
-+    A Padé approximant is a sum-over-poles expansion (
-+    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
-+
-+    The application of the Padé method to spectrum decompoisitions is described
-+    in "Padé spectrum decompositions of quantum distribution functions and
-+    optimal hierarchical equations of motion construction for quantum open
-+    systems" [1].
-+
-+    The implementation here follows the approach in the paper.
-+
-+    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
-+
-+    This is an alternative to the :class:`LorentzianBath` which constructs
-+    a simpler exponential expansion that converges much more slowly in
-+    this particular case.
-+
-+    Parameters
-+    ----------
-+    Q : Qobj
-+        Operator describing the coupling between system and bath.
-+
-+    gamma : float
-+        The coupling strength between the system and the bath.
-+
-+    w : float
-+        The width of the environment.
-+
-+    mu : float
-+        The chemical potential of the bath.
-+
-+    T : float
-+        Bath temperature.
-+
-+    Nk : int
-+        Number of exponential terms used to approximate the bath correlation
-+        functions.
-+
-+    tag : optional, str, tuple or any other object
-+        A label for the bath exponents (for example, the name of the
-+        bath). It defaults to None but can be set to help identify which
-+        bath an exponent is from.
-+    """
-+    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
-+        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
-+        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
-+
-+        super().__init__(
-+            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
-+        )
-+
-+    def _corr(self, gamma, w, mu, T, Nk, sigma):
-+        beta = 1. / T
-+        kappa, epsilon = self._kappa_epsilon(Nk)
-+
-+        def f_approx(x):
-+            f = 0.5
-+            for ll in range(1, Nk + 1):
-+                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
-+            return f
-+
-+        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
-+        gamma_list = [w - sigma * 1.0j * mu]
-+
-+        for ll in range(1, Nk + 1):
-+            eta_list.append(
-+                -1.0j * (kappa[ll] / beta) * gamma * w**2
-+                / (-(epsilon[ll]**2 / beta**2) + w**2)
-+            )
-+            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
-+
-+        return eta_list, gamma_list
-+
-+    def _kappa_epsilon(self, Nk):
-+        eps = self._calc_eps(Nk)
-+        chi = self._calc_chi(Nk)
-+
-+        kappa = [0]
-+        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
-+        for j in range(Nk):
-+            term = prefactor
-+            for k in range(Nk - 1):
-+                term *= (
-+                    (chi[k]**2 - eps[j]**2) /
-+                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-+                )
-+            for k in [Nk - 1]:
-+                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-+            kappa.append(term)
-+
-+        epsilon = [0] + eps
-+
-+        return kappa, epsilon
-+
-+    def _delta(self, i, j):
-+        return 1.0 if i == j else 0.0
-+
-+    def _calc_eps(self, Nk):
-+        alpha = np.diag([
-+                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
-+                for k in range(2 * Nk - 1)
-+        ], k=1)
-+        alpha += alpha.transpose()
-+
-+        evals = eigvalsh(alpha)
-+        eps = [-2. / val for val in evals[0: Nk]]
-+        return eps
-+
-+    def _calc_chi(self, Nk):
-+        alpha_p = np.diag([
-+                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
-+                for k in range(2 * Nk - 2)
-+        ], k=1)
-+        alpha_p += alpha_p.transpose()
-+        evals = eigvalsh(alpha_p)
-+        chi = [-2. / val for val in evals[0: Nk - 1]]
-+        return chi
-diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
-index 740c2d5d..42cc98d1 100644
---- a/qutip/solver/heom/bofin_solvers.py
-+++ b/qutip/solver/heom/bofin_solvers.py
-@@ -1,1322 +1,1322 @@
--"""
--This module provides solvers for system-bath evoluation using the
--HEOM (hierarchy equations of motion).
--
--See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
--basic introduction to the technique.
--
--The implementation is derived from the BoFiN library (see
--https://github.com/tehruhn/bofin) which was itself derived from an earlier
--implementation in QuTiP itself.
--"""
--
--from time import time
--
--import numpy as np
--import scipy.sparse as sp
--from scipy.sparse.linalg import spsolve
--
--from qutip.settings import settings
--from qutip import state_number_enumerate
--from qutip.core import data as _data
--from qutip.core.data import csr as _csr
--from qutip.core import Qobj, QobjEvo
--from qutip.core.superoperator import liouvillian, spre, spost
--from .bofin_baths import (
--    BathExponent, DrudeLorentzBath,
--)
--from ..solver_base import Solver
--from .. import Result
--
--# Load MKL spsolve if avaiable
--if settings.has_mkl:
--    from qutip._mkl.spsolve import mkl_spsolve
--else:
--    mkl_spsolve = None
--
--__all__ = [
--    "heomsolve",
--    "HierarchyADOs",
--    "HierarchyADOsState",
--    "HEOMResult",
--    "HEOMSolver",
--    "HSolverDL",
--]
--
--
--class HierarchyADOs:
--    """
--    A description of ADOs (auxilliary density operators) with the
--    hierarchical equations of motion.
--
--    The list of ADOs is constructed from a list of bath exponents
--    (corresponding to one or more baths). Each ADO is referred to by a label
--    that lists the number of "excitations" of each bath exponent. The
--    level of a label within the hierarchy is the sum of the "excitations"
--    within the label.
--
--    For example the label ``(0, 0, ..., 0)`` represents the density matrix
--    of the system being solved and is the only 0th level label.
--
--    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
--    etc. are the 1st level labels.
--
--    The second level labels all have either two 1s or a single 2, and so on
--    for the third and higher levels of the hierarchy.
--
--    Parameters
--    ----------
--    exponents : list of BathExponent
--        The exponents of the correlation function describing the bath or
--        baths.
--
--    max_depth : int
--        The maximum depth of the hierarchy (i.e. the maximum sum of
--        "excitations" in the hierarchy ADO labels or maximum ADO level).
--
--    Attributes
--    ----------
--    exponents : list of BathExponent
--        The exponents of the correlation function describing the bath or
--        baths.
--
--    max_depth : int
--        The maximum depth of the hierarchy (i.e. the maximum sum of
--        "excitations" in the hierarchy ADO labels).
--
--    dims : list of int
--        The dimensions of each exponent within the bath(s).
--
--    vk : list of complex
--        The frequency of each exponent within the bath(s).
--
--    ck : list of complex
--        The coefficient of each exponent within the bath(s).
--
--    ck2: list of complex
--        For exponents of type "RI", the coefficient of the exponent within
--        the imaginary expansion. For other exponent types, the entry is None.
--
--    sigma_bar_k_offset: list of int
--        For exponents of type "+" or "-" the offset within the list of modes
--        of the corresponding "-" or "+" exponent. For other exponent types,
--        the entry is None.
--
--    labels: list of tuples
--        A list of the ADO labels within the hierarchy.
--    """
--    def __init__(self, exponents, max_depth):
--        self.exponents = exponents
--        self.max_depth = max_depth
--
--        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
--        self.vk = [exp.vk for exp in self.exponents]
--        self.ck = [exp.ck for exp in self.exponents]
--        self.ck2 = [exp.ck2 for exp in self.exponents]
--        self.sigma_bar_k_offset = [
--            exp.sigma_bar_k_offset for exp in self.exponents
--        ]
--
--        self.labels = list(state_number_enumerate(self.dims, max_depth))
--        self._label_idx = {s: i for i, s in enumerate(self.labels)}
--        self.idx = self._label_idx.__getitem__
--
--    def idx(self, label):
--        """
--        Return the index of the ADO label within the list of labels,
--        i.e. within ``self.labels``.
--
--        Parameters
--        ----------
--        label : tuple
--            The label to look up.
--
--        Returns
--        -------
--        int
--            The index of the label within the list of ADO labels.
--
--        Note
--        ----
--        This implementation of the ``.idx(...)`` method is just for
--        reference and documentation. To avoid the cost of a Python
--        function call, it is replaced with
--        ``self._label_idx.__getitem__`` when the instance is created.
--        """
--        return self._label_idx[label]
--
--    def next(self, label, k):
--        """
--        Return the ADO label with one more excitation in the k'th exponent
--        dimension or ``None`` if adding the excitation would exceed the
--        dimension or maximum depth of the hierarchy.
--
--        Parameters
--        ----------
--        label : tuple
--            The ADO label to add an excitation to.
--        k : int
--            The exponent to add the excitation to.
--
--        Returns
--        -------
--        tuple or None
--            The next label.
--        """
--        if label[k] >= self.dims[k] - 1:
--            return None
--        if sum(label) >= self.max_depth:
--            return None
--        return label[:k] + (label[k] + 1,) + label[k + 1:]
--
--    def prev(self, label, k):
--        """
--        Return the ADO label with one fewer excitation in the k'th
--        exponent dimension or ``None`` if the label has no exciations in the
--        k'th exponent.
--
--        Parameters
--        ----------
--        label : tuple
--            The ADO label to remove the excitation from.
--        k : int
--            The exponent to remove the excitation from.
--
--        Returns
--        -------
--        tuple or None
--            The previous label.
--        """
--        if label[k] <= 0:
--            return None
--        return label[:k] + (label[k] - 1,) + label[k + 1:]
--
--    def exps(self, label):
--        """
--        Converts an ADO label into a tuple of exponents, with one exponent
--        for each "excitation" within the label.
--
--        The number of exponents returned is always equal to the level of the
--        label within the hierarchy (i.e. the sum of the indices within the
--        label).
--
--        Parameters
--        ----------
--        label : tuple
--            The ADO label to convert to a list of exponents.
--
--        Returns
--        -------
--        tuple of BathExponent
--            A tuple of BathExponents.
--
--        Examples
--        --------
--
--        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
--
--        ``ados.exps((2, 0, 0))`` would return
--        ``[ados.exponents[0], ados.exponents[0]]``.
--
--        ``ados.exps((1, 2, 1))`` would return
--        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
--           ados.exponents[2]]``.
--        """
--        return sum(
--            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
--            (),
--        )
--
--    def filter(self, level=None, tags=None, dims=None, types=None):
--        """
--        Return a list of ADO labels for ADOs whose "excitations"
--        match the given patterns.
--
--        Each of the filter parameters (tags, dims, types) may be either
--        unspecified (None) or a list. Unspecified parameters are excluded
--        from the filtering.
--
--        All specified filter parameters must be lists of the same length.
--        Each position in the lists describes a particular excitation and
--        any exponent that matches the filters may supply that excitation.
--        The level of all labels returned is thus equal to the length of
--        the filter parameter lists.
--
--        Within a filter parameter list, items that are None represent
--        wildcards and match any value of that exponent attribute
--
--        Parameters
--        ----------
--        level : int
--            The hierarchy depth to return ADOs from.
--
--        tags : list of object or None
--            Filter parameter that matches the ``.tag`` attribute of
--            exponents.
--
--        dims : list of int
--            Filter parameter that matches the ``.dim`` attribute of
--            exponents.
--
--        types : list of BathExponent types or list of str
--            Filter parameter that matches the ``.type`` attribute
--            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
--            instead of by the actual type (e.g. ``BathExponent.types.R``).
--
--        Returns
--        -------
--        list of tuple
--            The ADO label for each ADO whose exponent excitations
--            (i.e. label) match the given filters or level.
--        """
--        if types is not None:
--            types = [
--                t if t is None or isinstance(t, BathExponent.types)
--                else BathExponent.types[t]
--                for t in types
--            ]
--        filters = [("tag", tags), ("type", types), ("dim", dims)]
--        filters = [(attr, f) for attr, f in filters if f is not None]
--        n = max((len(f) for _, f in filters), default=0)
--        if any(len(f) != n for _, f in filters):
--            raise ValueError(
--                "The tags, dims and types filters must all be the same length."
--            )
--        if n > self.max_depth:
--            raise ValueError(
--                f"The maximum depth for the hierarchy is {self.max_depth} but"
--                f" {n} levels of excitation filters were given."
--            )
--        if level is None:
--            if not filters:
--                # fast path for when there are no excitation filters
--                return self.labels[:]
--        else:
--            if not filters:
--                # fast path for when there are no excitation filters
--                return [label for label in self.labels if sum(label) == level]
--            if level != n:
--                raise ValueError(
--                    f"The level parameter is {level} but {n} levels of"
--                    " excitation filters were given."
--                )
--
--        filtered_dims = [1] * len(self.exponents)
--        for lvl in range(n):
--            level_filters = [
--                (attr, f[lvl]) for attr, f in filters
--                if f[lvl] is not None
--            ]
--            for j, exp in enumerate(self.exponents):
--                if any(getattr(exp, attr) != f for attr, f in level_filters):
--                    continue
--                filtered_dims[j] += 1
--                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
--
--        return [
--            label for label in state_number_enumerate(filtered_dims, n)
--            if sum(label) == n
--        ]
--
--
--class HierarchyADOsState:
--    """
--    Provides convenient access to the full hierarchy ADO state at a particular
--    point in time, ``t``.
--
--    Parameters
--    ----------
--    rho : :class:`~qutip.Qobj`
--        The current state of the system (i.e. the 0th component of the
--        hierarchy).
--    ados : :class:`HierarchyADOs`
--        The description of the hierarchy.
--    ado_state : numpy.array
--        The full state of the hierarchy.
--
--    Attributes
--    ----------
--    rho : Qobj
--        The system state.
--
--    In addition, all of the attributes of the hierarchy description,
--    i.e. ``HierarchyADOs``, are provided directly on this class for
--    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
--    call ``.idx(label)`` directly.
--
--    See :class:`HierarchyADOs` for a full list of the available attributes
--    and methods.
--    """
--    def __init__(self, rho, ados, ado_state):
--        self.rho = rho
--        self._ado_state = ado_state
--        self._ados = ados
--
--    def __getattr__(self, name):
--        return getattr(self._ados, name)
--
--    def extract(self, idx_or_label):
--        """
--        Extract a Qobj representing the specified ADO from a full
--        representation of the ADO states.
--
--        Parameters
--        ----------
--        idx : int or label
--            The index of the ADO to extract. If an ADO label, e.g.
--            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
--            is extracted by label instead.
--
--        Returns
--        -------
--        Qobj
--            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
--        """
--        if isinstance(idx_or_label, int):
--            idx = idx_or_label
--        else:
--            idx = self._ados.idx(idx_or_label)
--        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
--
--
--class HEOMResult(Result):
--    def _post_init(self):
--        super()._post_init()
--
--        self.store_ados = self.options["store_ados"]
--        if self.store_ados:
--            self.final_ado_state = None
--            self.ado_states = []
--
--    def _e_op_func(self, e_op):
--        """ Convert an e_op into a function ``f(t, ado_state)``. """
--        if isinstance(e_op, Qobj):
--            return lambda t, ado_state: (ado_state.rho * e_op).tr()
--        elif isinstance(e_op, QobjEvo):
--            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
--        elif callable(e_op):
--            return e_op
--        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
--
--    def _pre_copy(self, state):
--        return state
--
--    def _store_state(self, t, ado_state):
--        self.states.append(ado_state.rho)
--        if self.store_ados:
--            self.ado_states.append(ado_state)
--
--    def _store_final_state(self, t, ado_state):
--        self.final_state = ado_state.rho
--        if self.store_ados:
--            self.final_ado_state = ado_state
--
--
--def heomsolve(
--    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
--):
--    """
--    Hierarchical Equations of Motion (HEOM) solver that supports multiple
--    baths.
--
--    The baths must be all either bosonic or fermionic baths.
--
--    If you need to run many evolutions of the same system and bath, consider
--    using :class:`HEOMSolver` directly to avoid having to continually
--    reconstruct the equation hierarchy for every evolution.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    bath : Bath or list of Bath
--        A :obj:`Bath` containing the exponents of the expansion of the
--        bath correlation funcion and their associated coefficients
--        and coupling operators, or a list of baths.
--
--        If multiple baths are given, they must all be either fermionic
--        or bosonic baths.
--
--    max_depth : int
--        The maximum depth of the heirarchy (i.e. the maximum number of bath
--        exponent "excitations" to retain).
--
--    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
--        If ``rho0`` is a :class:`~Qobj` the it is the initial state
--        of the system (i.e. a :obj:`~Qobj` density matrix).
--
--        If it is a :class:`~HierarchyADOsState` or array-like, then
--        ``rho0`` gives the initial state of all ADOs.
--
--        Usually the state of the ADOs would be determine from a previous
--        call to ``.run(...)`` with the solver results option ``store_ados``
--        set to True. For example, ``result = solver.run(...)`` could be
--        followed by ``solver.run(result.ado_states[-1], tlist)``.
--
--        If a numpy array-like is passed its shape must be
--        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
--        (i.e. shape of the system density matrix) and the ADOs must
--        be in the same order as in ``.ados.labels``.
--
--    tlist : list
--        An ordered list of times at which to return the value of the state.
--
--    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
--        A list or dictionary of operators as :class:`~Qobj`,
--        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
--        a single operator or callable function. For an operator ``op``, the
--        result will be computed using ``(state * op).tr()`` and the state
--        at each time ``t``. For callable functions, ``f``, the result is
--        computed using ``f(t, ado_state)``. The values are stored in the
--        ``expect`` and ``e_data`` attributes of the result (see the return
--        section below).
--
--    args : dict, optional {None}
--        Change the ``args`` of the RHS for the evolution.
--
--    options : dict, optional {None}
--        Generic solver options.
--
--        - store_final_state : bool
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, None
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - store_ados : bool {False, True}
--          Whether or not to store the HEOM ADOs.
--        - normalize_output : bool
--          Normalize output state to hide ODE numerical errors.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - state_data_type: str {'dense'}
--          Name of the data type of the state used during the ODE evolution.
--          Use an empty string to keep the input state type. Many integrator can
--          only work with `Dense`.
--        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
--          Which differential equation integration method to use.
--        - atol, rtol : float
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps :
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - max_step : float, 0
--          Maximum lenght of one internal step. When using pulses, it should be
--          less than half the width of the thinnest pulse.
--
--    Returns
--    -------
--    :class:`~HEOMResult`
--        The results of the simulation run, with the following important
--        attributes:
--
--        * ``times``: the times ``t`` (i.e. the ``tlist``).
--
--        * ``states``: the system state at each time ``t`` (only available
--          if ``e_ops`` was ``None`` or if the solver option
--          ``store_states`` was set to ``True``).
--
--        * ``ado_states``: the full ADO state at each time (only available
--          if the results option ``ado_return`` was set to ``True``).
--          Each element is an instance of :class:`HierarchyADOsState`.
--          The state of a particular ADO may be extracted from
--          ``result.ado_states[i]`` by calling :meth:`.extract`.
--
--        * ``expect``: a list containing the values of each ``e_ops`` at
--          time ``t``.
--
--        * ``e_data``: a dictionary containing the values of each ``e_ops``
--          at tme ``t``. The keys are those given by ``e_ops`` if it was
--          a dict, otherwise they are the indexes of the supplied ``e_ops``.
--
--        See :class:`~HEOMResult` and :class:`~Result` for the complete
--        list of attributes.
--    """
--    H = QobjEvo(H, args=args, tlist=tlist)
--    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
--    return solver.run(state0, tlist, e_ops=e_ops)
--
--
--class HEOMSolver(Solver):
--    """
--    HEOM solver that supports multiple baths.
--
--    The baths must be all either bosonic or fermionic baths.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    bath : Bath or list of Bath
--        A :obj:`Bath` containing the exponents of the expansion of the
--        bath correlation funcion and their associated coefficients
--        and coupling operators, or a list of baths.
--
--        If multiple baths are given, they must all be either fermionic
--        or bosonic baths.
--
--    max_depth : int
--        The maximum depth of the heirarchy (i.e. the maximum number of bath
--        exponent "excitations" to retain).
--
--    options : dict, optional
--        Generic solver options.
--        If set to None the default options will be used. Keyword only.
--        Default: None.
--
--    Attributes
--    ----------
--    ados : :obj:`HierarchyADOs`
--        The description of the hierarchy constructed from the given bath
--        and maximum depth.
--
--    rhs : :obj:`QobjEvo`
--        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
--        the system and bath coupling operators are converted to
--        :class:`qutip.data.CSR` instances during construction of the RHS,
--        so the operators in the ``rhs`` will all be sparse.
--    """
--
--    name = "heomsolver"
--    resultclass = HEOMResult
--    _avail_integrators = {}
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size": 10},
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": False,
--        "method": "adams",
--        "store_ados": False,
--        "state_data_type": "dense",
--    }
--
--    def __init__(self, H, bath, max_depth, *, options=None):
--        _time_start = time()
--
--        if not isinstance(H, (Qobj, QobjEvo)):
--            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
--
--        H = QobjEvo(H)
--        self.L_sys = (
--            liouvillian(H) if H.type == "oper"  # hamiltonian
--            else H  # already a liouvillian
--        )
--
--        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
--        self._sup_shape = self.L_sys.shape[0]
--        self._sys_dims = self.L_sys.dims[0]
--
--        self.ados = HierarchyADOs(
--            self._combine_bath_exponents(bath), max_depth,
--        )
--        self._n_ados = len(self.ados.labels)
--        self._n_exponents = len(self.ados.exponents)
--
--        self._init_ados_time = time() - _time_start
--        _time_start = time()
--
--        # pre-calculate identity matrix required by _grad_n
--        self._sId = _data.identity(self._sup_shape, dtype="csr")
--
--        # pre-calculate superoperators required by _grad_prev and _grad_next:
--        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
--        self._spreQ = [spre(op).data for op in Qs]
--        self._spostQ = [spost(op).data for op in Qs]
--        self._s_pre_minus_post_Q = [
--            _data.sub(self._spreQ[k], self._spostQ[k])
--            for k in range(self._n_exponents)
--        ]
--        self._s_pre_plus_post_Q = [
--            _data.add(self._spreQ[k], self._spostQ[k])
--            for k in range(self._n_exponents)
--        ]
--        self._spreQdag = [spre(op.dag()).data for op in Qs]
--        self._spostQdag = [spost(op.dag()).data for op in Qs]
--        self._s_pre_minus_post_Qdag = [
--            _data.sub(self._spreQdag[k], self._spostQdag[k])
--            for k in range(self._n_exponents)
--        ]
--        self._s_pre_plus_post_Qdag = [
--            _data.add(self._spreQdag[k], self._spostQdag[k])
--            for k in range(self._n_exponents)
--        ]
--
--        self._init_superop_cache_time = time() - _time_start
--        _time_start = time()
--
--        rhs = self._calculate_rhs()
--
--        self._init_rhs_time = time() - _time_start
--
--        super().__init__(rhs, options=options)
--
--    @property
--    def sys_dims(self):
--        """
--        Dimensions of the space that the system use, excluding any environment:
--
--        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
--        for this solver.
--        """
--        return self._sys_dims
--
--    def _initialize_stats(self):
--        stats = super()._initialize_stats()
--        stats.update({
--            "init time": sum([
--                stats["init time"], self._init_ados_time,
--                self._init_superop_cache_time, self._init_rhs_time,
--            ]),
--            "init ados time": self._init_ados_time,
--            "init superop cache time": self._init_superop_cache_time,
--            "init rhs time": self._init_rhs_time,
--            "solver": "Hierarchical Equations of Motion Solver",
--            "max_depth": self.ados.max_depth,
--        })
--        return stats
--
--    def _combine_bath_exponents(self, bath):
--        """ Combine the exponents for the specified baths. """
--        if not isinstance(bath, (list, tuple)):
--            exponents = bath.exponents
--        else:
--            exponents = []
--            for b in bath:
--                exponents.extend(b.exponents)
--        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
--            raise ValueError(
--                "All bath exponents must have system coupling operators"
--                " with the same dimensions but a mixture of dimensions"
--                " was given."
--            )
--        return exponents
--
--    def _grad_n(self, he_n):
--        """ Get the gradient for the hierarchy ADO at level n. """
--        vk = self.ados.vk
--        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
--        op = _data.mul(self._sId, -vk_sum)
--        return op
--
--    def _grad_prev(self, he_n, k):
--        """ Get the previous gradient. """
--        if self.ados.exponents[k].fermionic:
--            return self._grad_prev_fermionic(he_n, k)
--        else:
--            return self._grad_prev_bosonic(he_n, k)
--
--    def _grad_prev_bosonic(self, he_n, k):
--        if self.ados.exponents[k].type == BathExponent.types.R:
--            op = _data.mul(
--                self._s_pre_minus_post_Q[k],
--                -1j * he_n[k] * self.ados.ck[k],
--            )
--        elif self.ados.exponents[k].type == BathExponent.types.I:
--            op = _data.mul(
--                self._s_pre_plus_post_Q[k],
--                -1j * he_n[k] * 1j * self.ados.ck[k],
--            )
--        elif self.ados.exponents[k].type == BathExponent.types.RI:
--            term1 = _data.mul(
--                self._s_pre_minus_post_Q[k],
--                he_n[k] * -1j * self.ados.ck[k],
--            )
--            term2 = _data.mul(
--                self._s_pre_plus_post_Q[k],
--                he_n[k] * self.ados.ck2[k],
--            )
--            op = _data.add(term1, term2)
--        else:
--            raise ValueError(
--                f"Unsupported type {self.ados.exponents[k].type}"
--                f" for exponent {k}"
--            )
--        return op
--
--    def _grad_prev_fermionic(self, he_n, k):
--        ck = self.ados.ck
--        he_fermionic_n = [
--            i * int(exp.fermionic)
--            for i, exp in zip(he_n, self.ados.exponents)
--        ]
--
--        n_excite = sum(he_fermionic_n)
--        sign1 = (-1) ** (n_excite + 1)
--
--        n_excite_before_m = sum(he_fermionic_n[:k])
--        sign2 = (-1) ** (n_excite_before_m)
--
--        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
--
--        if self.ados.exponents[k].type == BathExponent.types["+"]:
--            op = _data.sub(
--                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
--                _data.mul(
--                    self._spostQdag[k],
--                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
--                ),
--            )
--        elif self.ados.exponents[k].type == BathExponent.types["-"]:
--            op = _data.sub(
--                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
--                _data.mul(
--                    self._spostQ[k],
--                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
--                ),
--            )
--        else:
--            raise ValueError(
--                f"Unsupported type {self.ados.exponents[k].type}"
--                f" for exponent {k}"
--            )
--        return op
--
--    def _grad_next(self, he_n, k):
--        """ Get the previous gradient. """
--        if self.ados.exponents[k].fermionic:
--            return self._grad_next_fermionic(he_n, k)
--        else:
--            return self._grad_next_bosonic(he_n, k)
--
--    def _grad_next_bosonic(self, he_n, k):
--        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
--        return op
--
--    def _grad_next_fermionic(self, he_n, k):
--        he_fermionic_n = [
--            i * int(exp.fermionic)
--            for i, exp in zip(he_n, self.ados.exponents)
--        ]
--        n_excite = sum(he_fermionic_n)
--        sign1 = (-1) ** (n_excite + 1)
--
--        n_excite_before_m = sum(he_fermionic_n[:k])
--        sign2 = (-1) ** (n_excite_before_m)
--
--        if self.ados.exponents[k].type == BathExponent.types["+"]:
--            if sign1 == -1:
--                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
--            else:
--                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
--        elif self.ados.exponents[k].type == BathExponent.types["-"]:
--            if sign1 == -1:
--                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
--            else:
--                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
--        else:
--            raise ValueError(
--                f"Unsupported type {self.ados.exponents[k].type}"
--                f" for exponent {k}"
--            )
--        return op
--
--    def _rhs(self):
--        """ Make the RHS for the HEOM. """
--        ops = _GatherHEOMRHS(
--            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
--        )
--
--        for he_n in self.ados.labels:
--            op = self._grad_n(he_n)
--            ops.add_op(he_n, he_n, op)
--            for k in range(len(self.ados.dims)):
--                next_he = self.ados.next(he_n, k)
--                if next_he is not None:
--                    op = self._grad_next(he_n, k)
--                    ops.add_op(he_n, next_he, op)
--                prev_he = self.ados.prev(he_n, k)
--                if prev_he is not None:
--                    op = self._grad_prev(he_n, k)
--                    ops.add_op(he_n, prev_he, op)
--
--        return ops.gather()
--
--    def _calculate_rhs(self):
--        """ Make the full RHS required by the solver. """
--        rhs_mat = self._rhs()
--        rhs_dims = [
--            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
--        ]
--        h_identity = _data.identity(self._n_ados, dtype="csr")
--
--        if self.L_sys.isconstant:
--            # For the constant case, we just add the Liouvillian to the
--            # diagonal blocks of the RHS matrix.
--            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
--            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
--        else:
--            # In the time dependent case, we construct the parameters
--            # for the ODE gradient function under the assumption that
--            #
--            # RHSmat(t) = RHSmat + time dependent terms that only affect the
--            # diagonal blocks of the RHS matrix.
--            #
--            # This assumption holds because only _grad_n dependents on
--            # the system Liouvillian (and not _grad_prev or _grad_next) and
--            # the bath coupling operators are not time-dependent.
--            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
--
--            def _kron(x):
--                return Qobj(
--                    _data.kron(h_identity, x.data),
--                    dims=rhs_dims,
--                ).to("csr")
--
--            rhs += self.L_sys.linear_map(_kron)
--
--        # The assertion that rhs_mat has data type CSR is just a sanity
--        # check on the RHS creation. The base solver class will still
--        # convert the RHS to the type required by the ODE integrator if
--        # needed.
--        assert isinstance(rhs_mat, _csr.CSR)
--        assert isinstance(rhs, QobjEvo)
--        assert rhs.dims == rhs_dims
--
--        return rhs
--
--    def steady_state(
--        self,
--        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
--    ):
--        """
--        Compute the steady state of the system.
--
--        Parameters
--        ----------
--        use_mkl : bool, default=False
--            Whether to use mkl or not. If mkl is not installed or if
--            this is false, use the scipy splu solver instead.
--
--        mkl_max_iter_refine : int
--            Specifies the the maximum number of iterative refinement steps that
--            the MKL PARDISO solver performs.
--
--            For a complete description, see iparm(8) in
--            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
--
--        mkl_weighted_matching : bool
--            MKL PARDISO can use a maximum weighted matching algorithm to
--            permute large elements close the diagonal. This strategy adds an
--            additional level of reliability to the factorization methods.
--
--            For a complete description, see iparm(13) in
--            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
--
--        Returns
--        -------
--        steady_state : Qobj
--            The steady state density matrix of the system.
--
--        steady_ados : :class:`HierarchyADOsState`
--            The steady state of the full ADO hierarchy. A particular ADO may be
--            extracted from the full state by calling :meth:`.extract`.
--        """
--        if not self.L_sys.isconstant:
--            raise ValueError(
--                "A steady state cannot be determined for a time-dependent"
--                " system"
--            )
--        n = self._sys_shape
--
--        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
--        b_mat[0] = 1.0
--
--        L = self.rhs(0).data.copy().as_scipy()
--        L = L.tolil()
--        L[0, 0: n ** 2 * self._n_ados] = 0.0
--        L = L.tocsr()
--        L += sp.csr_matrix((
--            np.ones(n),
--            (np.zeros(n), [num * (n + 1) for num in range(n)])
--        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
--
--        if mkl_spsolve is not None and use_mkl:
--            L.sort_indices()
--            solution = mkl_spsolve(
--                L,
--                b_mat,
--                perm=None,
--                verbose=False,
--                max_iter_refine=mkl_max_iter_refine,
--                scaling_vectors=True,
--                weighted_matching=mkl_weighted_matching,
--            )
--        else:
--            L = L.tocsc()
--            solution = spsolve(L, b_mat)
--
--        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
--        data = _data.mul(_data.add(data, data.conj()), 0.5)
--        steady_state = Qobj(data, dims=self._sys_dims)
--
--        solution = solution.reshape((self._n_ados, n, n))
--        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
--
--        return steady_state, steady_ados
--
--    def run(self, state0, tlist, *, args=None, e_ops=None):
--        """
--        Solve for the time evolution of the system.
--
--        Parameters
--        ----------
--        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
--            If ``rho0`` is a :class:`~Qobj` the it is the initial state
--            of the system (i.e. a :obj:`~Qobj` density matrix).
--
--            If it is a :class:`~HierarchyADOsState` or array-like, then
--            ``rho0`` gives the initial state of all ADOs.
--
--            Usually the state of the ADOs would be determine from a previous
--            call to ``.run(...)`` with the solver results option ``store_ados``
--            set to True. For example, ``result = solver.run(...)`` could be
--            followed by ``solver.run(result.ado_states[-1], tlist)``.
--
--            If a numpy array-like is passed its shape must be
--            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
--            (i.e. shape of the system density matrix) and the ADOs must
--            be in the same order as in ``.ados.labels``.
--
--        tlist : list
--            An ordered list of times at which to return the value of the state.
--
--        args : dict, optional {None}
--            Change the ``args`` of the RHS for the evolution.
--
--        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
--            A list or dictionary of operators as :class:`~Qobj`,
--            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
--            a single operator or callable function. For an operator ``op``, the
--            result will be computed using ``(state * op).tr()`` and the state
--            at each time ``t``. For callable functions, ``f``, the result is
--            computed using ``f(t, ado_state)``. The values are stored in the
--            ``expect`` and ``e_data`` attributes of the result (see the return
--            section below).
--
--        Returns
--        -------
--        :class:`~HEOMResult`
--            The results of the simulation run, with the following important
--            attributes:
--
--            * ``times``: the times ``t`` (i.e. the ``tlist``).
--
--            * ``states``: the system state at each time ``t`` (only available
--              if ``e_ops`` was ``None`` or if the solver option
--              ``store_states`` was set to ``True``).
--
--            * ``ado_states``: the full ADO state at each time (only available
--              if the results option ``ado_return`` was set to ``True``).
--              Each element is an instance of :class:`HierarchyADOsState`.
--              The state of a particular ADO may be extracted from
--              ``result.ado_states[i]`` by calling :meth:`.extract`.
--
--            * ``expect``: a list containing the values of each ``e_ops`` at
--              time ``t``.
--
--            * ``e_data``: a dictionary containing the values of each ``e_ops``
--              at tme ``t``. The keys are those given by ``e_ops`` if it was
--              a dict, otherwise they are the indexes of the supplied ``e_ops``.
--
--            See :class:`~HEOMResult` and :class:`~Result` for the complete
--            list of attributes.
--        """
--        return super().run(state0, tlist, args=args, e_ops=e_ops)
--
--    def _prepare_state(self, state):
--        n = self._sys_shape
--        rho_dims = self._sys_dims
--        hierarchy_shape = (self._n_ados, n, n)
--
--        rho0 = state
--        ado_init = not isinstance(rho0, Qobj)
--
--        if ado_init:
--            if isinstance(rho0, HierarchyADOsState):
--                rho0_he = rho0._ado_state
--            elif hasattr(rho0, "shape"):  # array-like
--                rho0_he = rho0
--            else:
--                raise TypeError(
--                    f"Initial ADOs passed have type {type(rho0)}"
--                    " but a HierarchyADOsState or a numpy array-like instance"
--                    " was expected"
--                )
--            if rho0_he.shape != hierarchy_shape:
--                raise ValueError(
--                    f"Initial ADOs passed have shape {rho0_he.shape}"
--                    f" but the solver hierarchy shape is {hierarchy_shape}"
--                )
--            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
--            rho0_he = _data.create(rho0_he)
--        else:
--            if rho0.dims != rho_dims:
--                raise ValueError(
--                    f"Initial state rho has dims {rho0.dims}"
--                    f" but the system dims are {rho_dims}"
--                )
--            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
--            rho0_he[:n ** 2] = rho0.full().ravel('F')
--            rho0_he = _data.create(rho0_he)
--
--        if self.options["state_data_type"]:
--            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
--
--        return rho0_he
--
--    def _restore_state(self, state, *, copy=True):
--        n = self._sys_shape
--        rho_shape = (n, n)
--        rho_dims = self._sys_dims
--        hierarchy_shape = (self._n_ados, n, n)
--
--        rho = Qobj(
--            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
--            dims=rho_dims,
--        )
--        ado_state = HierarchyADOsState(
--            rho, self.ados, state.to_array().reshape(hierarchy_shape)
--        )
--        return ado_state
--
--    def start(self, state0, t0):
--        """
--        Set the initial state and time for a step evolution.
--
--        Parameters
--        ----------
--        state0 : :class:`Qobj`
--            Initial state of the evolution. This may provide either just the
--            initial density matrix of the system, or the full set of ADOs
--            for the hierarchy. See the documentation for ``rho0`` in the
--            ``.run(...)`` method for details.
--
--        t0 : double
--            Initial time of the evolution.
--        """
--        super().start(state0, t0)
--
--    @property
--    def options(self):
--        """
--        Options for HEOMSolver:
--
--        store_final_state: bool, default=False
--            Whether or not to store the final state of the evolution in the
--            result class.
--
--        store_states: bool, default=None
--            Whether or not to store the state vectors or density matrices.
--            On `None` the states will be saved if no expectation operators are
--            given.
--
--        normalize_output: bool, default=False
--            Normalize output state to hide ODE numerical errors.
--
--        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
--            How to present the solver progress.
--            'tqdm' uses the python module of the same name and raise an error
--            if not installed. Empty string or False will disable the bar.
--
--        progress_kwargs: dict, default={"chunk_size": 10}
--            Arguments to pass to the progress_bar. Qutip's bars use
--            ``chunk_size``.
--
--        method: str, default="adams"
--            Which ordinary differential equation integration method to use.
--
--        state_data_type: str, default="dense"
--            Name of the data type of the state used during the ODE evolution.
--            Use an empty string to keep the input state type. Many integrators
--            support only work with `Dense`.
--
--        store_ados : bool, default=False
--            Whether or not to store the HEOM ADOs. Only relevant when using
--            the HEOM solver.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Solver.options.fset(self, new_options)
--
--
--class HSolverDL(HEOMSolver):
--    """
--    A helper class for creating an :class:`HEOMSolver` that is backwards
--    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
--    in QuTiP 4.6 and below.
--
--    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
--    descriptions of the underlying solver and bath construction.
--
--    An exact copy of the QuTiP 4.6 HSolverDL is provided in
--    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
--    the older solver is required. The older solver will be completely
--    removed in QuTiP 5.
--
--    .. note::
--
--        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
--        supports supplying a time-dependent or Liouvillian ``H_sys``.
--
--    .. note::
--
--        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
--        parameter ``N_exp`` specifying the number of exponents to keep in
--        the expansion of the bath correlation function is one more than
--        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
--        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
--        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
--        order to better match common usage in the literature.
--
--    .. note::
--
--        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
--        are no longer supported.
--
--    Parameters
--    ----------
--    H_sys : Qobj or QobjEvo or list
--        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
--        a complete description.
--
--    coup_op : Qobj
--        Operator describing the coupling between system and bath.
--        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
--
--    coup_strength : float
--        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
--
--    temperature : float
--        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
--
--    N_cut : int
--        The maximum depth of the hierarchy. See ``max_depth`` in
--        :class:`HEOMSolver` for a full description.
--
--    N_exp : int
--        Number of exponential terms used to approximate the bath correlation
--        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
--        less than ``N_exp`` (see note above).
--
--    cut_freq : float
--        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
--        :class:`DrudeLorentzBath`.
--
--    bnd_cut_approx : bool
--        Use boundary cut off approximation. If true, the Matsubara
--        terminator is added to the system Liouvillian (and H_sys is
--        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
--        Default: False.
--
--    options : dict, optional
--        Generic solver options.
--        If set to None the default options will be used. Keyword only.
--        Default: None.
--
--    combine : bool, default True
--        Whether to combine exponents with the same frequency (and coupling
--        operator). See :meth:`BosonicBath.combine` for details.
--        Keyword only. Default: True.
--    """
--    def __init__(
--        self, H_sys, coup_op, coup_strength, temperature,
--        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
--        combine=True,
--    ):
--        H_sys = QobjEvo(H_sys)
--        bath = DrudeLorentzBath(
--            Q=coup_op,
--            lam=coup_strength,
--            gamma=cut_freq,
--            Nk=N_exp - 1,
--            T=temperature,
--            combine=combine,
--        )
--
--        if bnd_cut_approx:
--            # upgrade H_sys to a Liouvillian if needed and add the
--            # bath terminator
--            if H_sys.type == "oper":  # H_sys is a Hamiltonian
--                H_sys = liouvillian(H_sys)
--            _, terminator = bath.terminator()
--            H_sys = H_sys + terminator
--
--        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
--
--        # store input parameters as attributes for politeness and compatibility
--        # with HSolverDL in QuTiP 4.6 and below.
--        self.coup_strength = coup_strength
--        self.cut_freq = cut_freq
--        self.temperature = temperature
--        self.N_exp = N_exp
--        self.bnd_cut_approx = bnd_cut_approx
--
--
--class _GatherHEOMRHS:
--    """ A class for collecting elements of the right-hand side matrix
--        of the HEOM.
--
--        Parameters
--        ----------
--        f_idx: function(he_state) -> he_idx
--            A function that returns the index of a hierarchy state
--            (i.e. an ADO label).
--        block : int
--            The size of a single ADO Liovillian operator in the hierarchy.
--        nhe : int
--            The number of ADOs in the hierarchy.
--    """
--    def __init__(self, f_idx, block, nhe):
--        self._block_size = block
--        self._n_blocks = nhe
--        self._f_idx = f_idx
--        self._ops = []
--
--    def add_op(self, row_he, col_he, op):
--        """ Add an block operator to the list. """
--        self._ops.append(
--            (self._f_idx(row_he), self._f_idx(col_he), op)
--        )
--
--    def gather(self):
--        """ Create the HEOM liouvillian from a sorted list of smaller sparse
--            matrices.
--
--            .. note::
--
--                The list of operators contains tuples of the form
--                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
--                *block* row and column for each op. An operator with
--                block indices ``(N, M)`` is placed at position
--                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
--                in the output matrix.
--
--            Returns
--            -------
--            rhs : :obj:`Data`
--                A combined matrix of shape ``(block * nhe, block * ne)``.
--        """
--        self._ops.sort()
--        ops = np.array(self._ops, dtype=[
--            ("row", _data.base.idxint_dtype),
--            ("col", _data.base.idxint_dtype),
--            ("op", _data.CSR),
--        ])
--        return _csr._from_csr_blocks(
--            ops["row"], ops["col"], ops["op"],
--            self._n_blocks, self._block_size,
--        )
-+"""
-+This module provides solvers for system-bath evoluation using the
-+HEOM (hierarchy equations of motion).
-+
-+See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
-+basic introduction to the technique.
-+
-+The implementation is derived from the BoFiN library (see
-+https://github.com/tehruhn/bofin) which was itself derived from an earlier
-+implementation in QuTiP itself.
-+"""
-+
-+from time import time
-+
-+import numpy as np
-+import scipy.sparse as sp
-+from scipy.sparse.linalg import spsolve
-+
-+from qutip.settings import settings
-+from qutip import state_number_enumerate
-+from qutip.core import data as _data
-+from qutip.core.data import csr as _csr
-+from qutip.core import Qobj, QobjEvo
-+from qutip.core.superoperator import liouvillian, spre, spost
-+from .bofin_baths import (
-+    BathExponent, DrudeLorentzBath,
-+)
-+from ..solver_base import Solver
-+from .. import Result
-+
-+# Load MKL spsolve if avaiable
-+if settings.has_mkl:
-+    from qutip._mkl.spsolve import mkl_spsolve
-+else:
-+    mkl_spsolve = None
-+
-+__all__ = [
-+    "heomsolve",
-+    "HierarchyADOs",
-+    "HierarchyADOsState",
-+    "HEOMResult",
-+    "HEOMSolver",
-+    "HSolverDL",
-+]
-+
-+
-+class HierarchyADOs:
-+    """
-+    A description of ADOs (auxilliary density operators) with the
-+    hierarchical equations of motion.
-+
-+    The list of ADOs is constructed from a list of bath exponents
-+    (corresponding to one or more baths). Each ADO is referred to by a label
-+    that lists the number of "excitations" of each bath exponent. The
-+    level of a label within the hierarchy is the sum of the "excitations"
-+    within the label.
-+
-+    For example the label ``(0, 0, ..., 0)`` represents the density matrix
-+    of the system being solved and is the only 0th level label.
-+
-+    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
-+    etc. are the 1st level labels.
-+
-+    The second level labels all have either two 1s or a single 2, and so on
-+    for the third and higher levels of the hierarchy.
-+
-+    Parameters
-+    ----------
-+    exponents : list of BathExponent
-+        The exponents of the correlation function describing the bath or
-+        baths.
-+
-+    max_depth : int
-+        The maximum depth of the hierarchy (i.e. the maximum sum of
-+        "excitations" in the hierarchy ADO labels or maximum ADO level).
-+
-+    Attributes
-+    ----------
-+    exponents : list of BathExponent
-+        The exponents of the correlation function describing the bath or
-+        baths.
-+
-+    max_depth : int
-+        The maximum depth of the hierarchy (i.e. the maximum sum of
-+        "excitations" in the hierarchy ADO labels).
-+
-+    dims : list of int
-+        The dimensions of each exponent within the bath(s).
-+
-+    vk : list of complex
-+        The frequency of each exponent within the bath(s).
-+
-+    ck : list of complex
-+        The coefficient of each exponent within the bath(s).
-+
-+    ck2: list of complex
-+        For exponents of type "RI", the coefficient of the exponent within
-+        the imaginary expansion. For other exponent types, the entry is None.
-+
-+    sigma_bar_k_offset: list of int
-+        For exponents of type "+" or "-" the offset within the list of modes
-+        of the corresponding "-" or "+" exponent. For other exponent types,
-+        the entry is None.
-+
-+    labels: list of tuples
-+        A list of the ADO labels within the hierarchy.
-+    """
-+    def __init__(self, exponents, max_depth):
-+        self.exponents = exponents
-+        self.max_depth = max_depth
-+
-+        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
-+        self.vk = [exp.vk for exp in self.exponents]
-+        self.ck = [exp.ck for exp in self.exponents]
-+        self.ck2 = [exp.ck2 for exp in self.exponents]
-+        self.sigma_bar_k_offset = [
-+            exp.sigma_bar_k_offset for exp in self.exponents
-+        ]
-+
-+        self.labels = list(state_number_enumerate(self.dims, max_depth))
-+        self._label_idx = {s: i for i, s in enumerate(self.labels)}
-+        self.idx = self._label_idx.__getitem__
-+
-+    def idx(self, label):
-+        """
-+        Return the index of the ADO label within the list of labels,
-+        i.e. within ``self.labels``.
-+
-+        Parameters
-+        ----------
-+        label : tuple
-+            The label to look up.
-+
-+        Returns
-+        -------
-+        int
-+            The index of the label within the list of ADO labels.
-+
-+        Note
-+        ----
-+        This implementation of the ``.idx(...)`` method is just for
-+        reference and documentation. To avoid the cost of a Python
-+        function call, it is replaced with
-+        ``self._label_idx.__getitem__`` when the instance is created.
-+        """
-+        return self._label_idx[label]
-+
-+    def next(self, label, k):
-+        """
-+        Return the ADO label with one more excitation in the k'th exponent
-+        dimension or ``None`` if adding the excitation would exceed the
-+        dimension or maximum depth of the hierarchy.
-+
-+        Parameters
-+        ----------
-+        label : tuple
-+            The ADO label to add an excitation to.
-+        k : int
-+            The exponent to add the excitation to.
-+
-+        Returns
-+        -------
-+        tuple or None
-+            The next label.
-+        """
-+        if label[k] >= self.dims[k] - 1:
-+            return None
-+        if sum(label) >= self.max_depth:
-+            return None
-+        return label[:k] + (label[k] + 1,) + label[k + 1:]
-+
-+    def prev(self, label, k):
-+        """
-+        Return the ADO label with one fewer excitation in the k'th
-+        exponent dimension or ``None`` if the label has no exciations in the
-+        k'th exponent.
-+
-+        Parameters
-+        ----------
-+        label : tuple
-+            The ADO label to remove the excitation from.
-+        k : int
-+            The exponent to remove the excitation from.
-+
-+        Returns
-+        -------
-+        tuple or None
-+            The previous label.
-+        """
-+        if label[k] <= 0:
-+            return None
-+        return label[:k] + (label[k] - 1,) + label[k + 1:]
-+
-+    def exps(self, label):
-+        """
-+        Converts an ADO label into a tuple of exponents, with one exponent
-+        for each "excitation" within the label.
-+
-+        The number of exponents returned is always equal to the level of the
-+        label within the hierarchy (i.e. the sum of the indices within the
-+        label).
-+
-+        Parameters
-+        ----------
-+        label : tuple
-+            The ADO label to convert to a list of exponents.
-+
-+        Returns
-+        -------
-+        tuple of BathExponent
-+            A tuple of BathExponents.
-+
-+        Examples
-+        --------
-+
-+        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
-+
-+        ``ados.exps((2, 0, 0))`` would return
-+        ``[ados.exponents[0], ados.exponents[0]]``.
-+
-+        ``ados.exps((1, 2, 1))`` would return
-+        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
-+           ados.exponents[2]]``.
-+        """
-+        return sum(
-+            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
-+            (),
-+        )
-+
-+    def filter(self, level=None, tags=None, dims=None, types=None):
-+        """
-+        Return a list of ADO labels for ADOs whose "excitations"
-+        match the given patterns.
-+
-+        Each of the filter parameters (tags, dims, types) may be either
-+        unspecified (None) or a list. Unspecified parameters are excluded
-+        from the filtering.
-+
-+        All specified filter parameters must be lists of the same length.
-+        Each position in the lists describes a particular excitation and
-+        any exponent that matches the filters may supply that excitation.
-+        The level of all labels returned is thus equal to the length of
-+        the filter parameter lists.
-+
-+        Within a filter parameter list, items that are None represent
-+        wildcards and match any value of that exponent attribute
-+
-+        Parameters
-+        ----------
-+        level : int
-+            The hierarchy depth to return ADOs from.
-+
-+        tags : list of object or None
-+            Filter parameter that matches the ``.tag`` attribute of
-+            exponents.
-+
-+        dims : list of int
-+            Filter parameter that matches the ``.dim`` attribute of
-+            exponents.
-+
-+        types : list of BathExponent types or list of str
-+            Filter parameter that matches the ``.type`` attribute
-+            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
-+            instead of by the actual type (e.g. ``BathExponent.types.R``).
-+
-+        Returns
-+        -------
-+        list of tuple
-+            The ADO label for each ADO whose exponent excitations
-+            (i.e. label) match the given filters or level.
-+        """
-+        if types is not None:
-+            types = [
-+                t if t is None or isinstance(t, BathExponent.types)
-+                else BathExponent.types[t]
-+                for t in types
-+            ]
-+        filters = [("tag", tags), ("type", types), ("dim", dims)]
-+        filters = [(attr, f) for attr, f in filters if f is not None]
-+        n = max((len(f) for _, f in filters), default=0)
-+        if any(len(f) != n for _, f in filters):
-+            raise ValueError(
-+                "The tags, dims and types filters must all be the same length."
-+            )
-+        if n > self.max_depth:
-+            raise ValueError(
-+                f"The maximum depth for the hierarchy is {self.max_depth} but"
-+                f" {n} levels of excitation filters were given."
-+            )
-+        if level is None:
-+            if not filters:
-+                # fast path for when there are no excitation filters
-+                return self.labels[:]
-+        else:
-+            if not filters:
-+                # fast path for when there are no excitation filters
-+                return [label for label in self.labels if sum(label) == level]
-+            if level != n:
-+                raise ValueError(
-+                    f"The level parameter is {level} but {n} levels of"
-+                    " excitation filters were given."
-+                )
-+
-+        filtered_dims = [1] * len(self.exponents)
-+        for lvl in range(n):
-+            level_filters = [
-+                (attr, f[lvl]) for attr, f in filters
-+                if f[lvl] is not None
-+            ]
-+            for j, exp in enumerate(self.exponents):
-+                if any(getattr(exp, attr) != f for attr, f in level_filters):
-+                    continue
-+                filtered_dims[j] += 1
-+                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
-+
-+        return [
-+            label for label in state_number_enumerate(filtered_dims, n)
-+            if sum(label) == n
-+        ]
-+
-+
-+class HierarchyADOsState:
-+    """
-+    Provides convenient access to the full hierarchy ADO state at a particular
-+    point in time, ``t``.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`~qutip.Qobj`
-+        The current state of the system (i.e. the 0th component of the
-+        hierarchy).
-+    ados : :class:`HierarchyADOs`
-+        The description of the hierarchy.
-+    ado_state : numpy.array
-+        The full state of the hierarchy.
-+
-+    Attributes
-+    ----------
-+    rho : Qobj
-+        The system state.
-+
-+    In addition, all of the attributes of the hierarchy description,
-+    i.e. ``HierarchyADOs``, are provided directly on this class for
-+    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
-+    call ``.idx(label)`` directly.
-+
-+    See :class:`HierarchyADOs` for a full list of the available attributes
-+    and methods.
-+    """
-+    def __init__(self, rho, ados, ado_state):
-+        self.rho = rho
-+        self._ado_state = ado_state
-+        self._ados = ados
-+
-+    def __getattr__(self, name):
-+        return getattr(self._ados, name)
-+
-+    def extract(self, idx_or_label):
-+        """
-+        Extract a Qobj representing the specified ADO from a full
-+        representation of the ADO states.
-+
-+        Parameters
-+        ----------
-+        idx : int or label
-+            The index of the ADO to extract. If an ADO label, e.g.
-+            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
-+            is extracted by label instead.
-+
-+        Returns
-+        -------
-+        Qobj
-+            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
-+        """
-+        if isinstance(idx_or_label, int):
-+            idx = idx_or_label
-+        else:
-+            idx = self._ados.idx(idx_or_label)
-+        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
-+
-+
-+class HEOMResult(Result):
-+    def _post_init(self):
-+        super()._post_init()
-+
-+        self.store_ados = self.options["store_ados"]
-+        if self.store_ados:
-+            self.final_ado_state = None
-+            self.ado_states = []
-+
-+    def _e_op_func(self, e_op):
-+        """ Convert an e_op into a function ``f(t, ado_state)``. """
-+        if isinstance(e_op, Qobj):
-+            return lambda t, ado_state: (ado_state.rho * e_op).tr()
-+        elif isinstance(e_op, QobjEvo):
-+            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
-+        elif callable(e_op):
-+            return e_op
-+        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
-+
-+    def _pre_copy(self, state):
-+        return state
-+
-+    def _store_state(self, t, ado_state):
-+        self.states.append(ado_state.rho)
-+        if self.store_ados:
-+            self.ado_states.append(ado_state)
-+
-+    def _store_final_state(self, t, ado_state):
-+        self.final_state = ado_state.rho
-+        if self.store_ados:
-+            self.final_ado_state = ado_state
-+
-+
-+def heomsolve(
-+    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
-+):
-+    """
-+    Hierarchical Equations of Motion (HEOM) solver that supports multiple
-+    baths.
-+
-+    The baths must be all either bosonic or fermionic baths.
-+
-+    If you need to run many evolutions of the same system and bath, consider
-+    using :class:`HEOMSolver` directly to avoid having to continually
-+    reconstruct the equation hierarchy for every evolution.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    bath : Bath or list of Bath
-+        A :obj:`Bath` containing the exponents of the expansion of the
-+        bath correlation funcion and their associated coefficients
-+        and coupling operators, or a list of baths.
-+
-+        If multiple baths are given, they must all be either fermionic
-+        or bosonic baths.
-+
-+    max_depth : int
-+        The maximum depth of the heirarchy (i.e. the maximum number of bath
-+        exponent "excitations" to retain).
-+
-+    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
-+        If ``rho0`` is a :class:`~Qobj` the it is the initial state
-+        of the system (i.e. a :obj:`~Qobj` density matrix).
-+
-+        If it is a :class:`~HierarchyADOsState` or array-like, then
-+        ``rho0`` gives the initial state of all ADOs.
-+
-+        Usually the state of the ADOs would be determine from a previous
-+        call to ``.run(...)`` with the solver results option ``store_ados``
-+        set to True. For example, ``result = solver.run(...)`` could be
-+        followed by ``solver.run(result.ado_states[-1], tlist)``.
-+
-+        If a numpy array-like is passed its shape must be
-+        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
-+        (i.e. shape of the system density matrix) and the ADOs must
-+        be in the same order as in ``.ados.labels``.
-+
-+    tlist : list
-+        An ordered list of times at which to return the value of the state.
-+
-+    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
-+        A list or dictionary of operators as :class:`~Qobj`,
-+        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
-+        a single operator or callable function. For an operator ``op``, the
-+        result will be computed using ``(state * op).tr()`` and the state
-+        at each time ``t``. For callable functions, ``f``, the result is
-+        computed using ``f(t, ado_state)``. The values are stored in the
-+        ``expect`` and ``e_data`` attributes of the result (see the return
-+        section below).
-+
-+    args : dict, optional {None}
-+        Change the ``args`` of the RHS for the evolution.
-+
-+    options : dict, optional {None}
-+        Generic solver options.
-+
-+        - store_final_state : bool
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, None
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - store_ados : bool {False, True}
-+          Whether or not to store the HEOM ADOs.
-+        - normalize_output : bool
-+          Normalize output state to hide ODE numerical errors.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - state_data_type: str {'dense'}
-+          Name of the data type of the state used during the ODE evolution.
-+          Use an empty string to keep the input state type. Many integrator can
-+          only work with `Dense`.
-+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-+          Which differential equation integration method to use.
-+        - atol, rtol : float
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps :
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - max_step : float, 0
-+          Maximum lenght of one internal step. When using pulses, it should be
-+          less than half the width of the thinnest pulse.
-+
-+    Returns
-+    -------
-+    :class:`~HEOMResult`
-+        The results of the simulation run, with the following important
-+        attributes:
-+
-+        * ``times``: the times ``t`` (i.e. the ``tlist``).
-+
-+        * ``states``: the system state at each time ``t`` (only available
-+          if ``e_ops`` was ``None`` or if the solver option
-+          ``store_states`` was set to ``True``).
-+
-+        * ``ado_states``: the full ADO state at each time (only available
-+          if the results option ``ado_return`` was set to ``True``).
-+          Each element is an instance of :class:`HierarchyADOsState`.
-+          The state of a particular ADO may be extracted from
-+          ``result.ado_states[i]`` by calling :meth:`.extract`.
-+
-+        * ``expect``: a list containing the values of each ``e_ops`` at
-+          time ``t``.
-+
-+        * ``e_data``: a dictionary containing the values of each ``e_ops``
-+          at tme ``t``. The keys are those given by ``e_ops`` if it was
-+          a dict, otherwise they are the indexes of the supplied ``e_ops``.
-+
-+        See :class:`~HEOMResult` and :class:`~Result` for the complete
-+        list of attributes.
-+    """
-+    H = QobjEvo(H, args=args, tlist=tlist)
-+    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
-+    return solver.run(state0, tlist, e_ops=e_ops)
-+
-+
-+class HEOMSolver(Solver):
-+    """
-+    HEOM solver that supports multiple baths.
-+
-+    The baths must be all either bosonic or fermionic baths.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    bath : Bath or list of Bath
-+        A :obj:`Bath` containing the exponents of the expansion of the
-+        bath correlation funcion and their associated coefficients
-+        and coupling operators, or a list of baths.
-+
-+        If multiple baths are given, they must all be either fermionic
-+        or bosonic baths.
-+
-+    max_depth : int
-+        The maximum depth of the heirarchy (i.e. the maximum number of bath
-+        exponent "excitations" to retain).
-+
-+    options : dict, optional
-+        Generic solver options.
-+        If set to None the default options will be used. Keyword only.
-+        Default: None.
-+
-+    Attributes
-+    ----------
-+    ados : :obj:`HierarchyADOs`
-+        The description of the hierarchy constructed from the given bath
-+        and maximum depth.
-+
-+    rhs : :obj:`QobjEvo`
-+        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
-+        the system and bath coupling operators are converted to
-+        :class:`qutip.data.CSR` instances during construction of the RHS,
-+        so the operators in the ``rhs`` will all be sparse.
-+    """
-+
-+    name = "heomsolver"
-+    resultclass = HEOMResult
-+    _avail_integrators = {}
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size": 10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": False,
-+        "method": "adams",
-+        "store_ados": False,
-+        "state_data_type": "dense",
-+    }
-+
-+    def __init__(self, H, bath, max_depth, *, options=None):
-+        _time_start = time()
-+
-+        if not isinstance(H, (Qobj, QobjEvo)):
-+            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
-+
-+        H = QobjEvo(H)
-+        self.L_sys = (
-+            liouvillian(H) if H.type == "oper"  # hamiltonian
-+            else H  # already a liouvillian
-+        )
-+
-+        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
-+        self._sup_shape = self.L_sys.shape[0]
-+        self._sys_dims = self.L_sys.dims[0]
-+
-+        self.ados = HierarchyADOs(
-+            self._combine_bath_exponents(bath), max_depth,
-+        )
-+        self._n_ados = len(self.ados.labels)
-+        self._n_exponents = len(self.ados.exponents)
-+
-+        self._init_ados_time = time() - _time_start
-+        _time_start = time()
-+
-+        # pre-calculate identity matrix required by _grad_n
-+        self._sId = _data.identity(self._sup_shape, dtype="csr")
-+
-+        # pre-calculate superoperators required by _grad_prev and _grad_next:
-+        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
-+        self._spreQ = [spre(op).data for op in Qs]
-+        self._spostQ = [spost(op).data for op in Qs]
-+        self._s_pre_minus_post_Q = [
-+            _data.sub(self._spreQ[k], self._spostQ[k])
-+            for k in range(self._n_exponents)
-+        ]
-+        self._s_pre_plus_post_Q = [
-+            _data.add(self._spreQ[k], self._spostQ[k])
-+            for k in range(self._n_exponents)
-+        ]
-+        self._spreQdag = [spre(op.dag()).data for op in Qs]
-+        self._spostQdag = [spost(op.dag()).data for op in Qs]
-+        self._s_pre_minus_post_Qdag = [
-+            _data.sub(self._spreQdag[k], self._spostQdag[k])
-+            for k in range(self._n_exponents)
-+        ]
-+        self._s_pre_plus_post_Qdag = [
-+            _data.add(self._spreQdag[k], self._spostQdag[k])
-+            for k in range(self._n_exponents)
-+        ]
-+
-+        self._init_superop_cache_time = time() - _time_start
-+        _time_start = time()
-+
-+        rhs = self._calculate_rhs()
-+
-+        self._init_rhs_time = time() - _time_start
-+
-+        super().__init__(rhs, options=options)
-+
-+    @property
-+    def sys_dims(self):
-+        """
-+        Dimensions of the space that the system use, excluding any environment:
-+
-+        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
-+        for this solver.
-+        """
-+        return self._sys_dims
-+
-+    def _initialize_stats(self):
-+        stats = super()._initialize_stats()
-+        stats.update({
-+            "init time": sum([
-+                stats["init time"], self._init_ados_time,
-+                self._init_superop_cache_time, self._init_rhs_time,
-+            ]),
-+            "init ados time": self._init_ados_time,
-+            "init superop cache time": self._init_superop_cache_time,
-+            "init rhs time": self._init_rhs_time,
-+            "solver": "Hierarchical Equations of Motion Solver",
-+            "max_depth": self.ados.max_depth,
-+        })
-+        return stats
-+
-+    def _combine_bath_exponents(self, bath):
-+        """ Combine the exponents for the specified baths. """
-+        if not isinstance(bath, (list, tuple)):
-+            exponents = bath.exponents
-+        else:
-+            exponents = []
-+            for b in bath:
-+                exponents.extend(b.exponents)
-+        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
-+            raise ValueError(
-+                "All bath exponents must have system coupling operators"
-+                " with the same dimensions but a mixture of dimensions"
-+                " was given."
-+            )
-+        return exponents
-+
-+    def _grad_n(self, he_n):
-+        """ Get the gradient for the hierarchy ADO at level n. """
-+        vk = self.ados.vk
-+        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
-+        op = _data.mul(self._sId, -vk_sum)
-+        return op
-+
-+    def _grad_prev(self, he_n, k):
-+        """ Get the previous gradient. """
-+        if self.ados.exponents[k].fermionic:
-+            return self._grad_prev_fermionic(he_n, k)
-+        else:
-+            return self._grad_prev_bosonic(he_n, k)
-+
-+    def _grad_prev_bosonic(self, he_n, k):
-+        if self.ados.exponents[k].type == BathExponent.types.R:
-+            op = _data.mul(
-+                self._s_pre_minus_post_Q[k],
-+                -1j * he_n[k] * self.ados.ck[k],
-+            )
-+        elif self.ados.exponents[k].type == BathExponent.types.I:
-+            op = _data.mul(
-+                self._s_pre_plus_post_Q[k],
-+                -1j * he_n[k] * 1j * self.ados.ck[k],
-+            )
-+        elif self.ados.exponents[k].type == BathExponent.types.RI:
-+            term1 = _data.mul(
-+                self._s_pre_minus_post_Q[k],
-+                he_n[k] * -1j * self.ados.ck[k],
-+            )
-+            term2 = _data.mul(
-+                self._s_pre_plus_post_Q[k],
-+                he_n[k] * self.ados.ck2[k],
-+            )
-+            op = _data.add(term1, term2)
-+        else:
-+            raise ValueError(
-+                f"Unsupported type {self.ados.exponents[k].type}"
-+                f" for exponent {k}"
-+            )
-+        return op
-+
-+    def _grad_prev_fermionic(self, he_n, k):
-+        ck = self.ados.ck
-+        he_fermionic_n = [
-+            i * int(exp.fermionic)
-+            for i, exp in zip(he_n, self.ados.exponents)
-+        ]
-+
-+        n_excite = sum(he_fermionic_n)
-+        sign1 = (-1) ** (n_excite + 1)
-+
-+        n_excite_before_m = sum(he_fermionic_n[:k])
-+        sign2 = (-1) ** (n_excite_before_m)
-+
-+        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
-+
-+        if self.ados.exponents[k].type == BathExponent.types["+"]:
-+            op = _data.sub(
-+                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
-+                _data.mul(
-+                    self._spostQdag[k],
-+                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
-+                ),
-+            )
-+        elif self.ados.exponents[k].type == BathExponent.types["-"]:
-+            op = _data.sub(
-+                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
-+                _data.mul(
-+                    self._spostQ[k],
-+                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
-+                ),
-+            )
-+        else:
-+            raise ValueError(
-+                f"Unsupported type {self.ados.exponents[k].type}"
-+                f" for exponent {k}"
-+            )
-+        return op
-+
-+    def _grad_next(self, he_n, k):
-+        """ Get the previous gradient. """
-+        if self.ados.exponents[k].fermionic:
-+            return self._grad_next_fermionic(he_n, k)
-+        else:
-+            return self._grad_next_bosonic(he_n, k)
-+
-+    def _grad_next_bosonic(self, he_n, k):
-+        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
-+        return op
-+
-+    def _grad_next_fermionic(self, he_n, k):
-+        he_fermionic_n = [
-+            i * int(exp.fermionic)
-+            for i, exp in zip(he_n, self.ados.exponents)
-+        ]
-+        n_excite = sum(he_fermionic_n)
-+        sign1 = (-1) ** (n_excite + 1)
-+
-+        n_excite_before_m = sum(he_fermionic_n[:k])
-+        sign2 = (-1) ** (n_excite_before_m)
-+
-+        if self.ados.exponents[k].type == BathExponent.types["+"]:
-+            if sign1 == -1:
-+                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
-+            else:
-+                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
-+        elif self.ados.exponents[k].type == BathExponent.types["-"]:
-+            if sign1 == -1:
-+                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
-+            else:
-+                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
-+        else:
-+            raise ValueError(
-+                f"Unsupported type {self.ados.exponents[k].type}"
-+                f" for exponent {k}"
-+            )
-+        return op
-+
-+    def _rhs(self):
-+        """ Make the RHS for the HEOM. """
-+        ops = _GatherHEOMRHS(
-+            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
-+        )
-+
-+        for he_n in self.ados.labels:
-+            op = self._grad_n(he_n)
-+            ops.add_op(he_n, he_n, op)
-+            for k in range(len(self.ados.dims)):
-+                next_he = self.ados.next(he_n, k)
-+                if next_he is not None:
-+                    op = self._grad_next(he_n, k)
-+                    ops.add_op(he_n, next_he, op)
-+                prev_he = self.ados.prev(he_n, k)
-+                if prev_he is not None:
-+                    op = self._grad_prev(he_n, k)
-+                    ops.add_op(he_n, prev_he, op)
-+
-+        return ops.gather()
-+
-+    def _calculate_rhs(self):
-+        """ Make the full RHS required by the solver. """
-+        rhs_mat = self._rhs()
-+        rhs_dims = [
-+            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
-+        ]
-+        h_identity = _data.identity(self._n_ados, dtype="csr")
-+
-+        if self.L_sys.isconstant:
-+            # For the constant case, we just add the Liouvillian to the
-+            # diagonal blocks of the RHS matrix.
-+            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
-+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
-+        else:
-+            # In the time dependent case, we construct the parameters
-+            # for the ODE gradient function under the assumption that
-+            #
-+            # RHSmat(t) = RHSmat + time dependent terms that only affect the
-+            # diagonal blocks of the RHS matrix.
-+            #
-+            # This assumption holds because only _grad_n dependents on
-+            # the system Liouvillian (and not _grad_prev or _grad_next) and
-+            # the bath coupling operators are not time-dependent.
-+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
-+
-+            def _kron(x):
-+                return Qobj(
-+                    _data.kron(h_identity, x.data),
-+                    dims=rhs_dims,
-+                ).to("csr")
-+
-+            rhs += self.L_sys.linear_map(_kron)
-+
-+        # The assertion that rhs_mat has data type CSR is just a sanity
-+        # check on the RHS creation. The base solver class will still
-+        # convert the RHS to the type required by the ODE integrator if
-+        # needed.
-+        assert isinstance(rhs_mat, _csr.CSR)
-+        assert isinstance(rhs, QobjEvo)
-+        assert rhs.dims == rhs_dims
-+
-+        return rhs
-+
-+    def steady_state(
-+        self,
-+        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
-+    ):
-+        """
-+        Compute the steady state of the system.
-+
-+        Parameters
-+        ----------
-+        use_mkl : bool, default=False
-+            Whether to use mkl or not. If mkl is not installed or if
-+            this is false, use the scipy splu solver instead.
-+
-+        mkl_max_iter_refine : int
-+            Specifies the the maximum number of iterative refinement steps that
-+            the MKL PARDISO solver performs.
-+
-+            For a complete description, see iparm(8) in
-+            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
-+
-+        mkl_weighted_matching : bool
-+            MKL PARDISO can use a maximum weighted matching algorithm to
-+            permute large elements close the diagonal. This strategy adds an
-+            additional level of reliability to the factorization methods.
-+
-+            For a complete description, see iparm(13) in
-+            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
-+
-+        Returns
-+        -------
-+        steady_state : Qobj
-+            The steady state density matrix of the system.
-+
-+        steady_ados : :class:`HierarchyADOsState`
-+            The steady state of the full ADO hierarchy. A particular ADO may be
-+            extracted from the full state by calling :meth:`.extract`.
-+        """
-+        if not self.L_sys.isconstant:
-+            raise ValueError(
-+                "A steady state cannot be determined for a time-dependent"
-+                " system"
-+            )
-+        n = self._sys_shape
-+
-+        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
-+        b_mat[0] = 1.0
-+
-+        L = self.rhs(0).data.copy().as_scipy()
-+        L = L.tolil()
-+        L[0, 0: n ** 2 * self._n_ados] = 0.0
-+        L = L.tocsr()
-+        L += sp.csr_matrix((
-+            np.ones(n),
-+            (np.zeros(n), [num * (n + 1) for num in range(n)])
-+        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
-+
-+        if mkl_spsolve is not None and use_mkl:
-+            L.sort_indices()
-+            solution = mkl_spsolve(
-+                L,
-+                b_mat,
-+                perm=None,
-+                verbose=False,
-+                max_iter_refine=mkl_max_iter_refine,
-+                scaling_vectors=True,
-+                weighted_matching=mkl_weighted_matching,
-+            )
-+        else:
-+            L = L.tocsc()
-+            solution = spsolve(L, b_mat)
-+
-+        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
-+        data = _data.mul(_data.add(data, data.conj()), 0.5)
-+        steady_state = Qobj(data, dims=self._sys_dims)
-+
-+        solution = solution.reshape((self._n_ados, n, n))
-+        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
-+
-+        return steady_state, steady_ados
-+
-+    def run(self, state0, tlist, *, args=None, e_ops=None):
-+        """
-+        Solve for the time evolution of the system.
-+
-+        Parameters
-+        ----------
-+        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
-+            If ``rho0`` is a :class:`~Qobj` the it is the initial state
-+            of the system (i.e. a :obj:`~Qobj` density matrix).
-+
-+            If it is a :class:`~HierarchyADOsState` or array-like, then
-+            ``rho0`` gives the initial state of all ADOs.
-+
-+            Usually the state of the ADOs would be determine from a previous
-+            call to ``.run(...)`` with the solver results option ``store_ados``
-+            set to True. For example, ``result = solver.run(...)`` could be
-+            followed by ``solver.run(result.ado_states[-1], tlist)``.
-+
-+            If a numpy array-like is passed its shape must be
-+            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
-+            (i.e. shape of the system density matrix) and the ADOs must
-+            be in the same order as in ``.ados.labels``.
-+
-+        tlist : list
-+            An ordered list of times at which to return the value of the state.
-+
-+        args : dict, optional {None}
-+            Change the ``args`` of the RHS for the evolution.
-+
-+        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
-+            A list or dictionary of operators as :class:`~Qobj`,
-+            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
-+            a single operator or callable function. For an operator ``op``, the
-+            result will be computed using ``(state * op).tr()`` and the state
-+            at each time ``t``. For callable functions, ``f``, the result is
-+            computed using ``f(t, ado_state)``. The values are stored in the
-+            ``expect`` and ``e_data`` attributes of the result (see the return
-+            section below).
-+
-+        Returns
-+        -------
-+        :class:`~HEOMResult`
-+            The results of the simulation run, with the following important
-+            attributes:
-+
-+            * ``times``: the times ``t`` (i.e. the ``tlist``).
-+
-+            * ``states``: the system state at each time ``t`` (only available
-+              if ``e_ops`` was ``None`` or if the solver option
-+              ``store_states`` was set to ``True``).
-+
-+            * ``ado_states``: the full ADO state at each time (only available
-+              if the results option ``ado_return`` was set to ``True``).
-+              Each element is an instance of :class:`HierarchyADOsState`.
-+              The state of a particular ADO may be extracted from
-+              ``result.ado_states[i]`` by calling :meth:`.extract`.
-+
-+            * ``expect``: a list containing the values of each ``e_ops`` at
-+              time ``t``.
-+
-+            * ``e_data``: a dictionary containing the values of each ``e_ops``
-+              at tme ``t``. The keys are those given by ``e_ops`` if it was
-+              a dict, otherwise they are the indexes of the supplied ``e_ops``.
-+
-+            See :class:`~HEOMResult` and :class:`~Result` for the complete
-+            list of attributes.
-+        """
-+        return super().run(state0, tlist, args=args, e_ops=e_ops)
-+
-+    def _prepare_state(self, state):
-+        n = self._sys_shape
-+        rho_dims = self._sys_dims
-+        hierarchy_shape = (self._n_ados, n, n)
-+
-+        rho0 = state
-+        ado_init = not isinstance(rho0, Qobj)
-+
-+        if ado_init:
-+            if isinstance(rho0, HierarchyADOsState):
-+                rho0_he = rho0._ado_state
-+            elif hasattr(rho0, "shape"):  # array-like
-+                rho0_he = rho0
-+            else:
-+                raise TypeError(
-+                    f"Initial ADOs passed have type {type(rho0)}"
-+                    " but a HierarchyADOsState or a numpy array-like instance"
-+                    " was expected"
-+                )
-+            if rho0_he.shape != hierarchy_shape:
-+                raise ValueError(
-+                    f"Initial ADOs passed have shape {rho0_he.shape}"
-+                    f" but the solver hierarchy shape is {hierarchy_shape}"
-+                )
-+            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
-+            rho0_he = _data.create(rho0_he)
-+        else:
-+            if rho0.dims != rho_dims:
-+                raise ValueError(
-+                    f"Initial state rho has dims {rho0.dims}"
-+                    f" but the system dims are {rho_dims}"
-+                )
-+            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
-+            rho0_he[:n ** 2] = rho0.full().ravel('F')
-+            rho0_he = _data.create(rho0_he)
-+
-+        if self.options["state_data_type"]:
-+            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
-+
-+        return rho0_he
-+
-+    def _restore_state(self, state, *, copy=True):
-+        n = self._sys_shape
-+        rho_shape = (n, n)
-+        rho_dims = self._sys_dims
-+        hierarchy_shape = (self._n_ados, n, n)
-+
-+        rho = Qobj(
-+            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
-+            dims=rho_dims,
-+        )
-+        ado_state = HierarchyADOsState(
-+            rho, self.ados, state.to_array().reshape(hierarchy_shape)
-+        )
-+        return ado_state
-+
-+    def start(self, state0, t0):
-+        """
-+        Set the initial state and time for a step evolution.
-+
-+        Parameters
-+        ----------
-+        state0 : :class:`Qobj`
-+            Initial state of the evolution. This may provide either just the
-+            initial density matrix of the system, or the full set of ADOs
-+            for the hierarchy. See the documentation for ``rho0`` in the
-+            ``.run(...)`` method for details.
-+
-+        t0 : double
-+            Initial time of the evolution.
-+        """
-+        super().start(state0, t0)
-+
-+    @property
-+    def options(self):
-+        """
-+        Options for HEOMSolver:
-+
-+        store_final_state: bool, default=False
-+            Whether or not to store the final state of the evolution in the
-+            result class.
-+
-+        store_states: bool, default=None
-+            Whether or not to store the state vectors or density matrices.
-+            On `None` the states will be saved if no expectation operators are
-+            given.
-+
-+        normalize_output: bool, default=False
-+            Normalize output state to hide ODE numerical errors.
-+
-+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-+            How to present the solver progress.
-+            'tqdm' uses the python module of the same name and raise an error
-+            if not installed. Empty string or False will disable the bar.
-+
-+        progress_kwargs: dict, default={"chunk_size": 10}
-+            Arguments to pass to the progress_bar. Qutip's bars use
-+            ``chunk_size``.
-+
-+        method: str, default="adams"
-+            Which ordinary differential equation integration method to use.
-+
-+        state_data_type: str, default="dense"
-+            Name of the data type of the state used during the ODE evolution.
-+            Use an empty string to keep the input state type. Many integrators
-+            support only work with `Dense`.
-+
-+        store_ados : bool, default=False
-+            Whether or not to store the HEOM ADOs. Only relevant when using
-+            the HEOM solver.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Solver.options.fset(self, new_options)
-+
-+
-+class HSolverDL(HEOMSolver):
-+    """
-+    A helper class for creating an :class:`HEOMSolver` that is backwards
-+    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
-+    in QuTiP 4.6 and below.
-+
-+    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
-+    descriptions of the underlying solver and bath construction.
-+
-+    An exact copy of the QuTiP 4.6 HSolverDL is provided in
-+    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
-+    the older solver is required. The older solver will be completely
-+    removed in QuTiP 5.
-+
-+    .. note::
-+
-+        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
-+        supports supplying a time-dependent or Liouvillian ``H_sys``.
-+
-+    .. note::
-+
-+        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
-+        parameter ``N_exp`` specifying the number of exponents to keep in
-+        the expansion of the bath correlation function is one more than
-+        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
-+        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
-+        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
-+        order to better match common usage in the literature.
-+
-+    .. note::
-+
-+        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
-+        are no longer supported.
-+
-+    Parameters
-+    ----------
-+    H_sys : Qobj or QobjEvo or list
-+        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
-+        a complete description.
-+
-+    coup_op : Qobj
-+        Operator describing the coupling between system and bath.
-+        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
-+
-+    coup_strength : float
-+        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
-+
-+    temperature : float
-+        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
-+
-+    N_cut : int
-+        The maximum depth of the hierarchy. See ``max_depth`` in
-+        :class:`HEOMSolver` for a full description.
-+
-+    N_exp : int
-+        Number of exponential terms used to approximate the bath correlation
-+        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
-+        less than ``N_exp`` (see note above).
-+
-+    cut_freq : float
-+        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
-+        :class:`DrudeLorentzBath`.
-+
-+    bnd_cut_approx : bool
-+        Use boundary cut off approximation. If true, the Matsubara
-+        terminator is added to the system Liouvillian (and H_sys is
-+        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
-+        Default: False.
-+
-+    options : dict, optional
-+        Generic solver options.
-+        If set to None the default options will be used. Keyword only.
-+        Default: None.
-+
-+    combine : bool, default True
-+        Whether to combine exponents with the same frequency (and coupling
-+        operator). See :meth:`BosonicBath.combine` for details.
-+        Keyword only. Default: True.
-+    """
-+    def __init__(
-+        self, H_sys, coup_op, coup_strength, temperature,
-+        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
-+        combine=True,
-+    ):
-+        H_sys = QobjEvo(H_sys)
-+        bath = DrudeLorentzBath(
-+            Q=coup_op,
-+            lam=coup_strength,
-+            gamma=cut_freq,
-+            Nk=N_exp - 1,
-+            T=temperature,
-+            combine=combine,
-+        )
-+
-+        if bnd_cut_approx:
-+            # upgrade H_sys to a Liouvillian if needed and add the
-+            # bath terminator
-+            if H_sys.type == "oper":  # H_sys is a Hamiltonian
-+                H_sys = liouvillian(H_sys)
-+            _, terminator = bath.terminator()
-+            H_sys = H_sys + terminator
-+
-+        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
-+
-+        # store input parameters as attributes for politeness and compatibility
-+        # with HSolverDL in QuTiP 4.6 and below.
-+        self.coup_strength = coup_strength
-+        self.cut_freq = cut_freq
-+        self.temperature = temperature
-+        self.N_exp = N_exp
-+        self.bnd_cut_approx = bnd_cut_approx
-+
-+
-+class _GatherHEOMRHS:
-+    """ A class for collecting elements of the right-hand side matrix
-+        of the HEOM.
-+
-+        Parameters
-+        ----------
-+        f_idx: function(he_state) -> he_idx
-+            A function that returns the index of a hierarchy state
-+            (i.e. an ADO label).
-+        block : int
-+            The size of a single ADO Liovillian operator in the hierarchy.
-+        nhe : int
-+            The number of ADOs in the hierarchy.
-+    """
-+    def __init__(self, f_idx, block, nhe):
-+        self._block_size = block
-+        self._n_blocks = nhe
-+        self._f_idx = f_idx
-+        self._ops = []
-+
-+    def add_op(self, row_he, col_he, op):
-+        """ Add an block operator to the list. """
-+        self._ops.append(
-+            (self._f_idx(row_he), self._f_idx(col_he), op)
-+        )
-+
-+    def gather(self):
-+        """ Create the HEOM liouvillian from a sorted list of smaller sparse
-+            matrices.
-+
-+            .. note::
-+
-+                The list of operators contains tuples of the form
-+                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
-+                *block* row and column for each op. An operator with
-+                block indices ``(N, M)`` is placed at position
-+                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
-+                in the output matrix.
-+
-+            Returns
-+            -------
-+            rhs : :obj:`Data`
-+                A combined matrix of shape ``(block * nhe, block * ne)``.
-+        """
-+        self._ops.sort()
-+        ops = np.array(self._ops, dtype=[
-+            ("row", _data.base.idxint_dtype),
-+            ("col", _data.base.idxint_dtype),
-+            ("op", _data.CSR),
-+        ])
-+        return _csr._from_csr_blocks(
-+            ops["row"], ops["col"], ops["op"],
-+            self._n_blocks, self._block_size,
-+        )
-diff --git a/qutip/solver/integrator/__init__.py b/qutip/solver/integrator/__init__.py
-index 987cfcd5..8e404a99 100644
---- a/qutip/solver/integrator/__init__.py
-+++ b/qutip/solver/integrator/__init__.py
-@@ -1,4 +1,4 @@
--from .integrator import *
--from .scipy_integrator import *
--from .qutip_integrator import *
--from .krylov import *
-+from .integrator import *
-+from .scipy_integrator import *
-+from .qutip_integrator import *
-+from .krylov import *
-diff --git a/qutip/solver/integrator/explicit_rk.pxd b/qutip/solver/integrator/explicit_rk.pxd
-index 46bbcf97..c149c6c0 100644
---- a/qutip/solver/integrator/explicit_rk.pxd
-+++ b/qutip/solver/integrator/explicit_rk.pxd
-@@ -1,63 +1,63 @@
--#cython: language_level=3
--from qutip.core.data cimport Data
--from qutip.core.cy.qobjevo cimport QobjEvo
--
--cpdef enum Status:
--    AT_FRONT = 2
--    INTERPOLATED = 1
--    NORMAL = 0
--    TOO_MUCH_WORK = -1
--    DT_UNDERFLOW = -2
--    OUTSIDE_RANGE = -3
--    NOT_INITIATED = -4
--
--cdef class Explicit_RungeKutta:
--    cdef QobjEvo qevo
--
--    # Ode state data, set in set_initial_value
--    cdef list k
--    cdef Data _y_temp, _y, _y_prev, _y_front
--    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
--    cdef double _t, _t_prev, _t_front
--    cdef Status _status
--    cdef dict status_messages
--
--    # options: set in init
--    cdef readonly double rtol, atol, first_step, min_step, max_step
--    cdef readonly int max_numsteps
--    cdef readonly bint interpolate
--    cdef readonly object method
--
--    # Runge Kutta tableau and info
--    cdef int rk_step, rk_extra_step, order, denseout_order
--    cdef bint adaptative_step, can_interpolate
--    cdef object b_factor_np
--    cdef double [:] b
--    cdef double [:] b_factor
--    cdef double [:] c
--    cdef double [:] e
--    cdef double [:, ::1] a
--    cdef double [:, ::1] bi
--
--    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
--
--    cpdef void set_initial_value(self, Data y0, double t)
--
--    cdef int _step_in_err(self, double t, int max_step)
--
--    cdef double _compute_step(self, double dt)
--
--    cdef double _error(self, Data y_new, double dt)
--
--    cdef void _prep_dense_out(self)
--
--    cdef Data _interpolate_step(self, double t, Data out)
--
--    cdef inline Data _accumulate(self, Data target, double[:] factors,
--                                 double dt, int size)
--
--    cdef double _estimate_first_step(self, double t, Data y0)
--
--    cdef double _get_timestep(self, double t)
--
--    cdef void _recompute_safe_step(self, double err, double dt)
-+#cython: language_level=3
-+from qutip.core.data cimport Data
-+from qutip.core.cy.qobjevo cimport QobjEvo
-+
-+cpdef enum Status:
-+    AT_FRONT = 2
-+    INTERPOLATED = 1
-+    NORMAL = 0
-+    TOO_MUCH_WORK = -1
-+    DT_UNDERFLOW = -2
-+    OUTSIDE_RANGE = -3
-+    NOT_INITIATED = -4
-+
-+cdef class Explicit_RungeKutta:
-+    cdef QobjEvo qevo
-+
-+    # Ode state data, set in set_initial_value
-+    cdef list k
-+    cdef Data _y_temp, _y, _y_prev, _y_front
-+    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
-+    cdef double _t, _t_prev, _t_front
-+    cdef Status _status
-+    cdef dict status_messages
-+
-+    # options: set in init
-+    cdef readonly double rtol, atol, first_step, min_step, max_step
-+    cdef readonly int max_numsteps
-+    cdef readonly bint interpolate
-+    cdef readonly object method
-+
-+    # Runge Kutta tableau and info
-+    cdef int rk_step, rk_extra_step, order, denseout_order
-+    cdef bint adaptative_step, can_interpolate
-+    cdef object b_factor_np
-+    cdef double [:] b
-+    cdef double [:] b_factor
-+    cdef double [:] c
-+    cdef double [:] e
-+    cdef double [:, ::1] a
-+    cdef double [:, ::1] bi
-+
-+    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
-+
-+    cpdef void set_initial_value(self, Data y0, double t)
-+
-+    cdef int _step_in_err(self, double t, int max_step)
-+
-+    cdef double _compute_step(self, double dt)
-+
-+    cdef double _error(self, Data y_new, double dt)
-+
-+    cdef void _prep_dense_out(self)
-+
-+    cdef Data _interpolate_step(self, double t, Data out)
-+
-+    cdef inline Data _accumulate(self, Data target, double[:] factors,
-+                                 double dt, int size)
-+
-+    cdef double _estimate_first_step(self, double t, Data y0)
-+
-+    cdef double _get_timestep(self, double t)
-+
-+    cdef void _recompute_safe_step(self, double err, double dt)
-diff --git a/qutip/solver/integrator/explicit_rk.pyx b/qutip/solver/integrator/explicit_rk.pyx
-index 17220ea2..37dd384d 100644
---- a/qutip/solver/integrator/explicit_rk.pyx
-+++ b/qutip/solver/integrator/explicit_rk.pyx
-@@ -1,510 +1,510 @@
--#cython: language_level=3
--#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
--"""
--Provide a cython implimentation for a general Explicit runge-Kutta method.
--"""
--from qutip.core.data cimport Data, Dense, CSR, dense
--from qutip.core.data.add cimport iadd_dense
--from qutip.core.data.add import add
--from qutip.core.data.mul import imul_data
--from qutip.core.data.tidyup import tidyup_csr
--from qutip.core.data.norm import frobenius_data
--from .verner7efficient import vern7_coeff
--from .verner9efficient import vern9_coeff
--cimport cython
--import numpy as np
--
--euler_coeff = {
--    'order': 1,
--    'a': np.array([[0.]], dtype=np.float64),
--    'b': np.array([1.], dtype=np.float64),
--    'c': np.array([0.], dtype=np.float64)
--}
--
--rk4_coeff = {
--    'order': 4,
--    'a': np.array([[0., 0., 0., 0.],
--                   [.5, 0., 0., 0.],
--                   [0., .5, 0., 0.],
--                   [0., 0., 1., 0.]], dtype=np.float64),
--    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
--    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
--}
--
--
--cdef Data copy_to(Data in_, Data out):
--    # Copy while reusing allocated buffer if possible.
--    # Does not check the shape, etc.
--    cdef size_t ptr
--    if type(in_) is Dense:
--        for ptr in range(in_.shape[0] * in_.shape[1]):
--            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
--        return out
--    else:
--        return in_.copy()
--
--
--cdef Data iadd_data(Data left, Data right, double complex factor):
--    # left += right * factor
--    # reusing `left' allocated buffer if possible.
--    # TODO: when/if iadd_csr is added: move to data/add.pyx.
--    if factor == 0:
--        return left
--    if type(left) is Dense:
--        iadd_dense(left, right, factor)
--        return left
--    else:
--        return add(left, right, factor)
--
--
--cdef class Explicit_RungeKutta:
--    """
--    Qutip implementation of Runge Kutta ODE.
--    Works in :class:`Data` allowing solving using sparse and gpu data.
--
--    Parameters
--    ----------
--    qevo : QobjEvo
--        The system to integrate: ```dX = qevo.matmul_data(t, X)``
--
--    rtol, atol : double
--        Relative and absolute tolerance of the integration error respectively.
--
--    nsteps : int
--        Maximum number of steps done during one call of integrate.
--
--    first_step : double
--        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
--        be determined automaticaly.
--
--    min_step, max_step : double
--        Bounds of the step lenght in ``t``. ``0`` means no bounds.
--
--    interpolate : bool
--        Whether to do longer step and interpolate back when the method support
--        it.
--        Example:
--            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
--            safely integrate up to ``t=3``. If ``interpolate=True``, it will
--            integrate up to ``t=3`` and then use interpolation to get the state
--            at ``t=2``. With ``interpolate=False``, it will integrate to
--            ``t=2``.
--
--    method : ['euler', 'rk4', 'vern7', 'vern9']
--        The integration method to use.
--        * It also accept a tuple of runge-kutta coefficients.
--        (See `Explicit_RungeKutta._init_coeff`)
--    """
--    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
--                 int nsteps=1000, double first_step=0, double min_step=0,
--                 double max_step=0, bint interpolate=True, method="euler"):
--        # Function to integrate.
--        self.qevo = qevo
--        # tolerances
--        self.atol = atol
--        self.rtol = rtol
--        self._dt_safe = atol
--        # Number of step to do before giving up
--        self.max_numsteps = nsteps
--
--        # contrain on the step times
--        self.first_step = first_step
--        self.min_step = min_step or 1e-15
--        self.max_step = max_step
--
--        # If True, will do the steps longer that the target and use
--        # interpolation to get the state at the wanted time.
--        self.interpolate = interpolate
--
--        self.k = []
--        if isinstance(method, dict):
--            self._init_coeff(**method)
--        elif "vern7" == method:
--            self._init_coeff(**vern7_coeff)
--        elif "vern9" == method:
--            self._init_coeff(**vern9_coeff)
--        elif "rk4" == method:
--            self._init_coeff(**rk4_coeff)
--        else:
--            self._init_coeff(**euler_coeff)
--        self.method = method
--        self._y_prev = None
--
--    def _init_coeff(self, order, a, b, c, e=None, bi=None):
--        """
--        Read the Butcher tableau.
--
--        Parameters
--        ----------
--        order : int
--            Order of the method
--
--        a, b, c : numpy.ndarray
--            The Butcher tableau:
--            c_0 | a_00 a_01
--            c_1 | a_10 a_11
--            ---------------
--                  b_0  b_1
--            The ``c`` vector should start with `0` and the first line of ``a``
--            is also expected to be zeros.
--            The ``a`` and ``c`` part of the tableau can be larger than the
--            number of step if dense output is available.
--
--        e : numpy.ndarray (optional)
--            The error coefficients. If given, adaptative step length will be
--            used to stay within the given tolerance.
--            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
--
--        bi : numpy.ndarray (optional)
--            The coefficients for the dense output.
--            The dense output is computed as:
--                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
--            with ``k[i]`` the derivative computed from ``a`` and ``c``.
--        """
--        self.order = order
--        self.rk_step = b.shape[0]
--        self.rk_extra_step = c.shape[0]
--        if (
--            self.rk_step > self.rk_extra_step or
--            a.shape[1] != self.rk_extra_step or
--            a.shape[0] != self.rk_extra_step
--        ):
--            raise ValueError("Inconsistant shape between the Butcher tableau "
--                             "parts.")
--
--        self.adaptative_step = e is not None
--        if self.adaptative_step and e.shape[0] != self.rk_step:
--            raise ValueError("The length of the error coefficients must be the"
--                             " same as the number of steps in the Butcher "
--                             f"tableau. Got {e.shape[0]} but expected "
--                             f"{self.rk_step}")
--
--        self.interpolate = bi is not None and self.interpolate
--        if self.interpolate:
--            self.denseout_order = bi.shape[1]
--            if bi.shape[0] != self.rk_extra_step:
--                raise ValueError("The interpolation coefficient's shape must "
--                                 "be (a.shape[0], dense output order)")
--
--        self.a = a
--        self.b = b
--        self.c = c
--        self.e = e
--        self.bi = bi
--        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
--        self.b_factor = self.b_factor_np
--
--    cpdef void set_initial_value(self, Data y0, double t):
--        """
--        Set the initial state and time of the integration.
--        """
--        self._t = t
--        self._t_prev = t
--        self._t_front = t
--        self._dt_int = 0
--        self._y = y0
--        self._norm_prev = frobenius_data(self._y)
--        self._norm_front = self._norm_prev
--
--        #prepare the buffers
--        for i in range(self.rk_extra_step):
--            self.k.append(self._y.copy())
--        self._y_temp = self._y.copy()
--        self._y_front = self._y.copy()
--        self._y_prev = self._y.copy()
--
--        if not self.first_step:
--            self._dt_safe = self._estimate_first_step(t, self._y)
--        else:
--            self._dt_safe = self.first_step
--
--    cdef double _estimate_first_step(self, double t, Data y0):
--        if not self.adaptative_step:
--            return 0.
--
--        cdef double dt1, dt2, dt, factorial = 1, t1
--        cdef double norm = frobenius_data(y0), tmp_norm
--        cdef double tol = self.atol + norm * self.rtol
--        cdef int i
--        self.k[0] = imul_data(<Data> self.k[0], 0)
--        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
--
--        # Ok approximation for linear system. But not in a general case.
--        if norm <= self.atol:
--            norm = 1
--        tmp_norm = frobenius_data(<Data> self.k[0])
--        for i in range(1, self.order+1):
--            factorial *= i
--        if tmp_norm >= (self.atol * 1e-6):
--            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
--                   / tmp_norm)
--        else:
--            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
--
--        t1 = t + dt1 / 100
--        self._y_temp = copy_to(y0, self._y_temp)
--        # below dt1 / 100 is an arbitrary small fraction of dt1:
--        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
--        self.k[1] = imul_data(<Data> self.k[1], 0)
--        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
--        tmp_norm = frobenius_data(<Data> self.k[1])
--        if tmp_norm >= (self.atol * 1e-6):
--            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
--                   / tmp_norm)
--        else:
--            dt2 = dt1
--
--        dt = min(dt1, dt2)
--        if self.max_step:
--            dt = min(self.max_step, dt)
--        if self.min_step:
--            dt = max(self.min_step, dt)
--        return dt
--
--    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
--        """
--        Do the integration to t.
--        If ``step`` is True, it will make a maximum 1 step and may not reach
--        ``t``.
--        """
--        cdef int nsteps_left = self.max_numsteps
--        cdef double err = 0
--
--        if self._y_prev is None:
--            self._status = Status.NOT_INITIATED
--            return
--
--        self._status = Status.NORMAL
--
--        if t == self._t:
--            return
--
--        if t < self._t_prev:
--            self._status = Status.OUTSIDE_RANGE
--            return
--
--        if self.interpolate and t < self._t_front:
--             self._y = self._interpolate_step(t, self._y)
--             self._t = t
--
--        if step and self._t < self._t_front and t > self._t_front:
--            # To ensure that the self._t ... t_out interval can be covered.
--            t = self._t_front
--
--        while self._t_front < t:
--            self._y_prev = copy_to(self._y_front, self._y_prev)
--            self._t_prev = self._t_front
--            self._norm_prev = self._norm_front
--            nsteps_left -= self._step_in_err(t, nsteps_left)
--            if step:
--                break
--
--        if self._status < 0:
--            return
--
--        if self._t_front > t:
--            self._prep_dense_out()
--            self._status = Status.INTERPOLATED
--            self._t = t
--            self._y = self._interpolate_step(t, self._y)
--        else:
--            self._status = Status.AT_FRONT
--            self._t = self._t_front
--            self._y = copy_to(self._y_front, self._y)
--
--    cdef int _step_in_err(self, double t, int max_step):
--        """
--        Do compute one step, repeating until the error is within tolerance.
--        """
--        cdef double error = 1
--        cdef int nsteps = 0
--        while error >= 1:
--            dt = self._get_timestep(t)
--            error = self._compute_step(dt)
--            self._dt_int = dt
--            self._recompute_safe_step(error, dt)
--
--            if dt == self.min_step and error > 1:
--                # The tolerance was not reached but the dt is at the minimum.
--                self._status = Status.DT_UNDERFLOW
--                break
--            nsteps += 1
--            if nsteps > max_step:
--                self._status = Status.TOO_MUCH_WORK
--                break
--        return nsteps
--
--    cdef double _compute_step(self, double dt):
--        """
--        Do compute one step with fixed ``dt``, return the error.
--        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
--        """
--        cdef int i
--        for i in range(self.rk_step):
--            self.k[i] = imul_data(<Data> self.k[i], 0.)
--
--        # Compute the derivatives
--        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
--                                          <Data> self.k[0])
--        for i in range(1, self.rk_step):
--            self._y_temp = copy_to(self._y_prev, self._y_temp)
--            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
--            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
--                                              self._y_temp, <Data> self.k[i])
--
--        # Compute the state
--        self._y_front = copy_to(self._y_prev, self._y_front)
--        self._y_front = self._accumulate(self._y_front, self.b, dt,
--                                         self.rk_step)
--        self._t_front = self._t_prev + dt
--
--        if type(self._y_front) is CSR:
--            # issparse() test would be better.
--            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
--
--        return self._error(self._y_front, dt)
--
--    cdef double _error(self, Data y_new, double dt):
--        """ Compute the normalized error. (error/tol) """
--        if not self.adaptative_step:
--            return 0.
--        self._y_temp = imul_data(self._y_temp, 0.)
--        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
--        self._norm_front = frobenius_data(y_new)
--        return frobenius_data(self._y_temp) / (self.atol +
--                max(self._norm_prev, self._norm_front) * self.rtol)
--
--    cdef void _prep_dense_out(self):
--        """
--        Compute derivative for the interpolation step.
--        """
--        cdef double dt = self._dt_int
--
--        for i in range(self.rk_step, self.rk_extra_step):
--            self.k[i] = imul_data(<Data> self.k[i], 0.)
--            self._y_temp = copy_to(self._y_prev, self._y_temp)
--            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
--            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
--                                              self._y_temp, <Data> self.k[i])
--
--    cdef Data _interpolate_step(self, double t, Data out):
--        """
--        Compute the state at any points between _t_prev and _t_front
--        with an error of ~dt**denseout_order.
--        """
--        cdef:
--            int i, j
--            double t0 = self._t_prev
--            double dt = self._dt_int
--            double tau = (t - t0) / dt
--        for i in range(self.rk_extra_step):
--            self.b_factor[i] = 0.
--            for j in range(self.denseout_order-1, -1, -1):
--                self.b_factor[i] += self.bi[i,j]
--                self.b_factor[i] *= tau
--
--        out = copy_to(self._y_prev, out)
--        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
--        return out
--
--    cdef inline Data _accumulate(self, Data target, double[:] factors,
--                         double dt, int size):
--        cdef int i
--        for i in range(size):
--            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
--        return target
--
--    @cython.cdivision(True)
--    cdef double _get_timestep(self, double t):
--        """ Get the dt for the step. """
--        cdef double dt_needed = t - self._t_front
--        if not self.adaptative_step:
--            return dt_needed
--        if self.interpolate:
--            return self._dt_safe
--        if dt_needed <= self._dt_safe:
--            return dt_needed
--        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
--
--    cdef void _recompute_safe_step(self, double err, double dt):
--        """ Get maximum safe step in function of the error."""
--        cdef double factor
--        if not self.adaptative_step:
--            return
--        elif err == 0:
--            factor = 10
--        else:
--            factor = 0.9*err**(-1/(self.order+1))
--            factor = min(10, factor)
--            factor = max(0.2, factor)
--
--        self._dt_safe = dt * factor
--        if self.max_step:
--            self._dt_safe = min(self.max_step, self._dt_safe)
--        if self.min_step:
--            self._dt_safe = max(self.min_step, self._dt_safe)
--
--    def successful(self):
--        return self._status >= 0
--
--    @property
--    def status(self):
--        return self._status
--
--    def status_message(self):
--        "Status of the last step in a human readable format."
--        return {
--            AT_FRONT: "Internal state at the desired time.",
--            INTERPOLATED: (
--                "Internal state past the desired time and "
--                "interpolation to step done."),
--            NORMAL: 'No work done.',
--            TOO_MUCH_WORK: (
--                'Too much work done in one call. Try to increase '
--                'the nsteps parameter or increasing the tolerance.'
--            ),
--            DT_UNDERFLOW:
--                'Step size becomes too small. Try increasing tolerance.',
--            OUTSIDE_RANGE: 'Step outside available range.',
--            NOT_INITIATED: 'Not initialized.'
--        }[self._status]
--
--    @property
--    def y(self):
--        return self._y
--
--    @property
--    def y_prev(self):
--        return self._y_prev
--
--    @property
--    def y_front(self):
--        return self._y_front
--
--    @property
--    def t_front(self):
--        return self._t_front
--
--    @property
--    def t_prev(self):
--        return self._t_prev
--
--    @property
--    def t(self):
--        return self._t
--
--    def _debug_state(self):
--        print("t, y: ", self._t,
--              'None' if self._y is None else self._y.to_array())
--        print("t_prev, y_prev, |y_prev|", self._t_prev,
--              'None' if self._y_prev is None else self._y_prev.to_array(),
--              self._norm_prev)
--        print("t_front, y_front, |y_front|", self._t_front,
--              'None' if self._y_front is None else self._y_front.to_array(),
--              self._norm_front)
--        print("y_temp",
--              'None' if self._y_temp is None else self._y_temp.to_array())
--        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
--        for i in range(self.rk_extra_step):
--            print(f'k[{i}]',
--                  'None' if self.k[i] is None else self.k[i].to_array())
-+#cython: language_level=3
-+#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
-+"""
-+Provide a cython implimentation for a general Explicit runge-Kutta method.
-+"""
-+from qutip.core.data cimport Data, Dense, CSR, dense
-+from qutip.core.data.add cimport iadd_dense
-+from qutip.core.data.add import add
-+from qutip.core.data.mul import imul_data
-+from qutip.core.data.tidyup import tidyup_csr
-+from qutip.core.data.norm import frobenius_data
-+from .verner7efficient import vern7_coeff
-+from .verner9efficient import vern9_coeff
-+cimport cython
-+import numpy as np
-+
-+euler_coeff = {
-+    'order': 1,
-+    'a': np.array([[0.]], dtype=np.float64),
-+    'b': np.array([1.], dtype=np.float64),
-+    'c': np.array([0.], dtype=np.float64)
-+}
-+
-+rk4_coeff = {
-+    'order': 4,
-+    'a': np.array([[0., 0., 0., 0.],
-+                   [.5, 0., 0., 0.],
-+                   [0., .5, 0., 0.],
-+                   [0., 0., 1., 0.]], dtype=np.float64),
-+    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
-+    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
-+}
-+
-+
-+cdef Data copy_to(Data in_, Data out):
-+    # Copy while reusing allocated buffer if possible.
-+    # Does not check the shape, etc.
-+    cdef size_t ptr
-+    if type(in_) is Dense:
-+        for ptr in range(in_.shape[0] * in_.shape[1]):
-+            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
-+        return out
-+    else:
-+        return in_.copy()
-+
-+
-+cdef Data iadd_data(Data left, Data right, double complex factor):
-+    # left += right * factor
-+    # reusing `left' allocated buffer if possible.
-+    # TODO: when/if iadd_csr is added: move to data/add.pyx.
-+    if factor == 0:
-+        return left
-+    if type(left) is Dense:
-+        iadd_dense(left, right, factor)
-+        return left
-+    else:
-+        return add(left, right, factor)
-+
-+
-+cdef class Explicit_RungeKutta:
-+    """
-+    Qutip implementation of Runge Kutta ODE.
-+    Works in :class:`Data` allowing solving using sparse and gpu data.
-+
-+    Parameters
-+    ----------
-+    qevo : QobjEvo
-+        The system to integrate: ```dX = qevo.matmul_data(t, X)``
-+
-+    rtol, atol : double
-+        Relative and absolute tolerance of the integration error respectively.
-+
-+    nsteps : int
-+        Maximum number of steps done during one call of integrate.
-+
-+    first_step : double
-+        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
-+        be determined automaticaly.
-+
-+    min_step, max_step : double
-+        Bounds of the step lenght in ``t``. ``0`` means no bounds.
-+
-+    interpolate : bool
-+        Whether to do longer step and interpolate back when the method support
-+        it.
-+        Example:
-+            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
-+            safely integrate up to ``t=3``. If ``interpolate=True``, it will
-+            integrate up to ``t=3`` and then use interpolation to get the state
-+            at ``t=2``. With ``interpolate=False``, it will integrate to
-+            ``t=2``.
-+
-+    method : ['euler', 'rk4', 'vern7', 'vern9']
-+        The integration method to use.
-+        * It also accept a tuple of runge-kutta coefficients.
-+        (See `Explicit_RungeKutta._init_coeff`)
-+    """
-+    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
-+                 int nsteps=1000, double first_step=0, double min_step=0,
-+                 double max_step=0, bint interpolate=True, method="euler"):
-+        # Function to integrate.
-+        self.qevo = qevo
-+        # tolerances
-+        self.atol = atol
-+        self.rtol = rtol
-+        self._dt_safe = atol
-+        # Number of step to do before giving up
-+        self.max_numsteps = nsteps
-+
-+        # contrain on the step times
-+        self.first_step = first_step
-+        self.min_step = min_step or 1e-15
-+        self.max_step = max_step
-+
-+        # If True, will do the steps longer that the target and use
-+        # interpolation to get the state at the wanted time.
-+        self.interpolate = interpolate
-+
-+        self.k = []
-+        if isinstance(method, dict):
-+            self._init_coeff(**method)
-+        elif "vern7" == method:
-+            self._init_coeff(**vern7_coeff)
-+        elif "vern9" == method:
-+            self._init_coeff(**vern9_coeff)
-+        elif "rk4" == method:
-+            self._init_coeff(**rk4_coeff)
-+        else:
-+            self._init_coeff(**euler_coeff)
-+        self.method = method
-+        self._y_prev = None
-+
-+    def _init_coeff(self, order, a, b, c, e=None, bi=None):
-+        """
-+        Read the Butcher tableau.
-+
-+        Parameters
-+        ----------
-+        order : int
-+            Order of the method
-+
-+        a, b, c : numpy.ndarray
-+            The Butcher tableau:
-+            c_0 | a_00 a_01
-+            c_1 | a_10 a_11
-+            ---------------
-+                  b_0  b_1
-+            The ``c`` vector should start with `0` and the first line of ``a``
-+            is also expected to be zeros.
-+            The ``a`` and ``c`` part of the tableau can be larger than the
-+            number of step if dense output is available.
-+
-+        e : numpy.ndarray (optional)
-+            The error coefficients. If given, adaptative step length will be
-+            used to stay within the given tolerance.
-+            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
-+
-+        bi : numpy.ndarray (optional)
-+            The coefficients for the dense output.
-+            The dense output is computed as:
-+                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
-+            with ``k[i]`` the derivative computed from ``a`` and ``c``.
-+        """
-+        self.order = order
-+        self.rk_step = b.shape[0]
-+        self.rk_extra_step = c.shape[0]
-+        if (
-+            self.rk_step > self.rk_extra_step or
-+            a.shape[1] != self.rk_extra_step or
-+            a.shape[0] != self.rk_extra_step
-+        ):
-+            raise ValueError("Inconsistant shape between the Butcher tableau "
-+                             "parts.")
-+
-+        self.adaptative_step = e is not None
-+        if self.adaptative_step and e.shape[0] != self.rk_step:
-+            raise ValueError("The length of the error coefficients must be the"
-+                             " same as the number of steps in the Butcher "
-+                             f"tableau. Got {e.shape[0]} but expected "
-+                             f"{self.rk_step}")
-+
-+        self.interpolate = bi is not None and self.interpolate
-+        if self.interpolate:
-+            self.denseout_order = bi.shape[1]
-+            if bi.shape[0] != self.rk_extra_step:
-+                raise ValueError("The interpolation coefficient's shape must "
-+                                 "be (a.shape[0], dense output order)")
-+
-+        self.a = a
-+        self.b = b
-+        self.c = c
-+        self.e = e
-+        self.bi = bi
-+        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
-+        self.b_factor = self.b_factor_np
-+
-+    cpdef void set_initial_value(self, Data y0, double t):
-+        """
-+        Set the initial state and time of the integration.
-+        """
-+        self._t = t
-+        self._t_prev = t
-+        self._t_front = t
-+        self._dt_int = 0
-+        self._y = y0
-+        self._norm_prev = frobenius_data(self._y)
-+        self._norm_front = self._norm_prev
-+
-+        #prepare the buffers
-+        for i in range(self.rk_extra_step):
-+            self.k.append(self._y.copy())
-+        self._y_temp = self._y.copy()
-+        self._y_front = self._y.copy()
-+        self._y_prev = self._y.copy()
-+
-+        if not self.first_step:
-+            self._dt_safe = self._estimate_first_step(t, self._y)
-+        else:
-+            self._dt_safe = self.first_step
-+
-+    cdef double _estimate_first_step(self, double t, Data y0):
-+        if not self.adaptative_step:
-+            return 0.
-+
-+        cdef double dt1, dt2, dt, factorial = 1, t1
-+        cdef double norm = frobenius_data(y0), tmp_norm
-+        cdef double tol = self.atol + norm * self.rtol
-+        cdef int i
-+        self.k[0] = imul_data(<Data> self.k[0], 0)
-+        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
-+
-+        # Ok approximation for linear system. But not in a general case.
-+        if norm <= self.atol:
-+            norm = 1
-+        tmp_norm = frobenius_data(<Data> self.k[0])
-+        for i in range(1, self.order+1):
-+            factorial *= i
-+        if tmp_norm >= (self.atol * 1e-6):
-+            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
-+                   / tmp_norm)
-+        else:
-+            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
-+
-+        t1 = t + dt1 / 100
-+        self._y_temp = copy_to(y0, self._y_temp)
-+        # below dt1 / 100 is an arbitrary small fraction of dt1:
-+        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
-+        self.k[1] = imul_data(<Data> self.k[1], 0)
-+        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
-+        tmp_norm = frobenius_data(<Data> self.k[1])
-+        if tmp_norm >= (self.atol * 1e-6):
-+            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
-+                   / tmp_norm)
-+        else:
-+            dt2 = dt1
-+
-+        dt = min(dt1, dt2)
-+        if self.max_step:
-+            dt = min(self.max_step, dt)
-+        if self.min_step:
-+            dt = max(self.min_step, dt)
-+        return dt
-+
-+    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
-+        """
-+        Do the integration to t.
-+        If ``step`` is True, it will make a maximum 1 step and may not reach
-+        ``t``.
-+        """
-+        cdef int nsteps_left = self.max_numsteps
-+        cdef double err = 0
-+
-+        if self._y_prev is None:
-+            self._status = Status.NOT_INITIATED
-+            return
-+
-+        self._status = Status.NORMAL
-+
-+        if t == self._t:
-+            return
-+
-+        if t < self._t_prev:
-+            self._status = Status.OUTSIDE_RANGE
-+            return
-+
-+        if self.interpolate and t < self._t_front:
-+             self._y = self._interpolate_step(t, self._y)
-+             self._t = t
-+
-+        if step and self._t < self._t_front and t > self._t_front:
-+            # To ensure that the self._t ... t_out interval can be covered.
-+            t = self._t_front
-+
-+        while self._t_front < t:
-+            self._y_prev = copy_to(self._y_front, self._y_prev)
-+            self._t_prev = self._t_front
-+            self._norm_prev = self._norm_front
-+            nsteps_left -= self._step_in_err(t, nsteps_left)
-+            if step:
-+                break
-+
-+        if self._status < 0:
-+            return
-+
-+        if self._t_front > t:
-+            self._prep_dense_out()
-+            self._status = Status.INTERPOLATED
-+            self._t = t
-+            self._y = self._interpolate_step(t, self._y)
-+        else:
-+            self._status = Status.AT_FRONT
-+            self._t = self._t_front
-+            self._y = copy_to(self._y_front, self._y)
-+
-+    cdef int _step_in_err(self, double t, int max_step):
-+        """
-+        Do compute one step, repeating until the error is within tolerance.
-+        """
-+        cdef double error = 1
-+        cdef int nsteps = 0
-+        while error >= 1:
-+            dt = self._get_timestep(t)
-+            error = self._compute_step(dt)
-+            self._dt_int = dt
-+            self._recompute_safe_step(error, dt)
-+
-+            if dt == self.min_step and error > 1:
-+                # The tolerance was not reached but the dt is at the minimum.
-+                self._status = Status.DT_UNDERFLOW
-+                break
-+            nsteps += 1
-+            if nsteps > max_step:
-+                self._status = Status.TOO_MUCH_WORK
-+                break
-+        return nsteps
-+
-+    cdef double _compute_step(self, double dt):
-+        """
-+        Do compute one step with fixed ``dt``, return the error.
-+        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
-+        """
-+        cdef int i
-+        for i in range(self.rk_step):
-+            self.k[i] = imul_data(<Data> self.k[i], 0.)
-+
-+        # Compute the derivatives
-+        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
-+                                          <Data> self.k[0])
-+        for i in range(1, self.rk_step):
-+            self._y_temp = copy_to(self._y_prev, self._y_temp)
-+            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
-+            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
-+                                              self._y_temp, <Data> self.k[i])
-+
-+        # Compute the state
-+        self._y_front = copy_to(self._y_prev, self._y_front)
-+        self._y_front = self._accumulate(self._y_front, self.b, dt,
-+                                         self.rk_step)
-+        self._t_front = self._t_prev + dt
-+
-+        if type(self._y_front) is CSR:
-+            # issparse() test would be better.
-+            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
-+
-+        return self._error(self._y_front, dt)
-+
-+    cdef double _error(self, Data y_new, double dt):
-+        """ Compute the normalized error. (error/tol) """
-+        if not self.adaptative_step:
-+            return 0.
-+        self._y_temp = imul_data(self._y_temp, 0.)
-+        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
-+        self._norm_front = frobenius_data(y_new)
-+        return frobenius_data(self._y_temp) / (self.atol +
-+                max(self._norm_prev, self._norm_front) * self.rtol)
-+
-+    cdef void _prep_dense_out(self):
-+        """
-+        Compute derivative for the interpolation step.
-+        """
-+        cdef double dt = self._dt_int
-+
-+        for i in range(self.rk_step, self.rk_extra_step):
-+            self.k[i] = imul_data(<Data> self.k[i], 0.)
-+            self._y_temp = copy_to(self._y_prev, self._y_temp)
-+            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
-+            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
-+                                              self._y_temp, <Data> self.k[i])
-+
-+    cdef Data _interpolate_step(self, double t, Data out):
-+        """
-+        Compute the state at any points between _t_prev and _t_front
-+        with an error of ~dt**denseout_order.
-+        """
-+        cdef:
-+            int i, j
-+            double t0 = self._t_prev
-+            double dt = self._dt_int
-+            double tau = (t - t0) / dt
-+        for i in range(self.rk_extra_step):
-+            self.b_factor[i] = 0.
-+            for j in range(self.denseout_order-1, -1, -1):
-+                self.b_factor[i] += self.bi[i,j]
-+                self.b_factor[i] *= tau
-+
-+        out = copy_to(self._y_prev, out)
-+        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
-+        return out
-+
-+    cdef inline Data _accumulate(self, Data target, double[:] factors,
-+                         double dt, int size):
-+        cdef int i
-+        for i in range(size):
-+            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
-+        return target
-+
-+    @cython.cdivision(True)
-+    cdef double _get_timestep(self, double t):
-+        """ Get the dt for the step. """
-+        cdef double dt_needed = t - self._t_front
-+        if not self.adaptative_step:
-+            return dt_needed
-+        if self.interpolate:
-+            return self._dt_safe
-+        if dt_needed <= self._dt_safe:
-+            return dt_needed
-+        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
-+
-+    cdef void _recompute_safe_step(self, double err, double dt):
-+        """ Get maximum safe step in function of the error."""
-+        cdef double factor
-+        if not self.adaptative_step:
-+            return
-+        elif err == 0:
-+            factor = 10
-+        else:
-+            factor = 0.9*err**(-1/(self.order+1))
-+            factor = min(10, factor)
-+            factor = max(0.2, factor)
-+
-+        self._dt_safe = dt * factor
-+        if self.max_step:
-+            self._dt_safe = min(self.max_step, self._dt_safe)
-+        if self.min_step:
-+            self._dt_safe = max(self.min_step, self._dt_safe)
-+
-+    def successful(self):
-+        return self._status >= 0
-+
-+    @property
-+    def status(self):
-+        return self._status
-+
-+    def status_message(self):
-+        "Status of the last step in a human readable format."
-+        return {
-+            AT_FRONT: "Internal state at the desired time.",
-+            INTERPOLATED: (
-+                "Internal state past the desired time and "
-+                "interpolation to step done."),
-+            NORMAL: 'No work done.',
-+            TOO_MUCH_WORK: (
-+                'Too much work done in one call. Try to increase '
-+                'the nsteps parameter or increasing the tolerance.'
-+            ),
-+            DT_UNDERFLOW:
-+                'Step size becomes too small. Try increasing tolerance.',
-+            OUTSIDE_RANGE: 'Step outside available range.',
-+            NOT_INITIATED: 'Not initialized.'
-+        }[self._status]
-+
-+    @property
-+    def y(self):
-+        return self._y
-+
-+    @property
-+    def y_prev(self):
-+        return self._y_prev
-+
-+    @property
-+    def y_front(self):
-+        return self._y_front
-+
-+    @property
-+    def t_front(self):
-+        return self._t_front
-+
-+    @property
-+    def t_prev(self):
-+        return self._t_prev
-+
-+    @property
-+    def t(self):
-+        return self._t
-+
-+    def _debug_state(self):
-+        print("t, y: ", self._t,
-+              'None' if self._y is None else self._y.to_array())
-+        print("t_prev, y_prev, |y_prev|", self._t_prev,
-+              'None' if self._y_prev is None else self._y_prev.to_array(),
-+              self._norm_prev)
-+        print("t_front, y_front, |y_front|", self._t_front,
-+              'None' if self._y_front is None else self._y_front.to_array(),
-+              self._norm_front)
-+        print("y_temp",
-+              'None' if self._y_temp is None else self._y_temp.to_array())
-+        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
-+        for i in range(self.rk_extra_step):
-+            print(f'k[{i}]',
-+                  'None' if self.k[i] is None else self.k[i].to_array())
-diff --git a/qutip/solver/integrator/integrator.py b/qutip/solver/integrator/integrator.py
-index 44df5546..4268621f 100644
---- a/qutip/solver/integrator/integrator.py
-+++ b/qutip/solver/integrator/integrator.py
-@@ -1,240 +1,240 @@
--""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
--import numpy as np
--
--__all__ = ['Integrator', 'IntegratorException']
--
--
--class IntegratorException(Exception):
--    """Error from the ODE solver being unable to integrate with the given
--    parameters.
--
--    Example
--    -------
--    - The solver cannot reach the desired tolerance within the maximum number
--    of steps.
--    - The step needed to be within desired tolerance is too small.
--    """
--
--
--class Integrator:
--    """
--    A wrapper around ODE solvers.
--    It ensures a common interface for Solver usage.
--    It takes and return states as :class:`qutip.core.data.Data`, it may return
--    a different data-type than the input type.
--
--    Parameters
--    ----------
--    system: qutip.QobjEvo
--        Quantum system in which states evolve.
--
--    options: dict
--        Options for the integrator.
--
--    Class Attributes
--    ----------------
--    name : str
--        The name of the integrator.
--
--    supports_blackbox : bool
--        If True, then the integrator calls only ``system.matmul``,
--        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
--        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
--        the integrator to modify the system in creative ways. In particular,
--        the solver may modify the system depending on *both* the time ``t``
--        *and* the current ``state`` the system is being applied to.
--
--        If the integrator calls any other methods, set to False.
--
--    supports_time_dependent : bool
--        If True, then the integrator supports time dependent systems. If False,
--        ``supports_blackbox`` should usually be ``False`` too.
--
--    integrator_options : dict
--        A dictionary of options used by the integrator and their default
--        values. Once initiated, ``self.options`` will be a dict with the same
--        keys, not the full options object passed to the solver. Options' keys
--        included here will be supported by the :cls:SolverOdeOptions.
--    """
--    # Dict of used options and their default values
--    integrator_options = {}
--    _options = None
--    # Can evolve time dependent system
--    support_time_dependant = None
--    # Whether the integrator used the system QobjEvo as a blackbox
--    supports_blackbox = None
--    # The name of the integrator
--    name = None
--    method = ""
--
--    def __init__(self, system, options):
--        self.system = system
--        self._is_set = False  # get_state can be used and return a valid state.
--        self._back = (np.inf, None)
--        self._options = self.integrator_options.copy()
--        self.options = options
--        self._prepare()
--
--    def _prepare(self):
--        """
--        Initialize the solver
--        It should also set the name of the solver to be displayed in Result.
--        """
--        raise NotImplementedError
--
--    def set_state(self, t, state0):
--        """
--        Set the state of the ODE solver.
--
--        Parameters
--        ----------
--        t : float
--            Initial time
--
--        state0 : qutip.Data
--            Initial state.
--
--        .. note:
--            It should set the flags `_is_set` to True.
--        """
--        raise NotImplementedError
--
--    def integrate(self, t, copy=True):
--        """
--        Evolve to t.
--
--        Before calling `integrate` for the first time, the initial state should
--        be set with `set_state`.
--
--        Parameters
--        ----------
--        t : float
--            Time to integrate to, should be larger than the previous time.
--
--        copy : bool [True]
--            Whether to return a copy of the state or the state itself.
--
--        Returns
--        -------
--        (t, state) : (float, qutip.Data)
--            The state of the solver at ``t``.
--        """
--        raise NotImplementedError
--
--    def mcstep(self, t, copy=True):
--        """
--        Evolve toward the time ``t``.
--
--        If ``t`` is larger than the present state's ``t``, advance the internal
--        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
--        larger than the previous one, it does an interpolation step and returns
--        the state at that time. When advancing the state, it may return it at a
--        time between present time and the asked ``t`` if more efficent for
--        subsequent interpolation step.
--
--        Before calling `mcstep` for the first time, the initial state should
--        be set with `set_state`.
--
--        Parameters
--        ----------
--        t : float
--            Time to integrate to, should be larger than the previous time. If
--            the last integrate call was use with ``step=True``, the time can be
--            between the time at the start of the last call and now.
--
--        copy : bool [True]
--            Whether to return a copy of the state or the state itself.
--
--        Returns
--        -------
--        (t, state) : (float, qutip.Data)
--            The state of the solver at ``t``. The returned time ``t`` can
--            differ from the input time only when ``step=True``.
--
--        .. note:
--            The default implementation may be overridden by integrators that
--            can provide a more efficient one.
--        """
--        t_last, state = self.get_state()
--        if t > t_last:
--            self._back = t_last, state
--        elif t > self._back[0]:
--            self.set_state(*self._back)
--        else:
--            raise IntegratorException(
--                "`t` is outside the integration range: "
--                f"{self._back[0]}..{t_last}."
--            )
--        return self.integrate(t, copy)
--
--    def get_state(self, copy=True):
--        """
--        Obtain the state of the solver as a pair (t, state).
--
--        Parameters
--        ----------
--        copy : bool (True)
--            Whether to return the data stored in the Integrator or a copy.
--
--        Returns
--        -------
--        (t, state) : (float, qutip.Data)
--            The state of the solver at ``t``.
--        """
--        raise NotImplementedError
--
--    def run(self, tlist):
--        """
--        Integrate the system yielding the state for each times in tlist.
--
--        Parameters
--        ----------
--        tlist : *list* / *array*
--            List of times to yield the state.
--
--        Yields
--        ------
--        (t, state) : (float, qutip.Data)
--            The state of the solver at each ``t`` of tlist.
--        """
--        for t in tlist[1:]:
--            yield self.integrate(t, False)
--
--    def reset(self, hard=False):
--        """Reset internal state of the ODE solver."""
--        if self._is_set:
--            state = self.get_state()
--        if hard:
--            self._prepare()
--        if self._is_set:
--            self.set_state(*state)
--
--    def arguments(self, args):
--        """
--        Change the argument of the system.
--        Reset the ODE solver to ensure numerical validity.
--
--        Parameters
--        ----------
--        args : dict
--            New arguments
--        """
--        self.system.arguments(args)
--        self.reset()
--
--    @property
--    def options(self):
--        # Options should be overwritten by each integrators.
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        # This does not apply the new options.
--        self._options = {
--            **self._options,
--            **{
--               key: new_options[key]
--               for key in self.integrator_options.keys()
--               if key in new_options and new_options[key] is not None
--            }
--        }
-+""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
-+import numpy as np
-+
-+__all__ = ['Integrator', 'IntegratorException']
-+
-+
-+class IntegratorException(Exception):
-+    """Error from the ODE solver being unable to integrate with the given
-+    parameters.
-+
-+    Example
-+    -------
-+    - The solver cannot reach the desired tolerance within the maximum number
-+    of steps.
-+    - The step needed to be within desired tolerance is too small.
-+    """
-+
-+
-+class Integrator:
-+    """
-+    A wrapper around ODE solvers.
-+    It ensures a common interface for Solver usage.
-+    It takes and return states as :class:`qutip.core.data.Data`, it may return
-+    a different data-type than the input type.
-+
-+    Parameters
-+    ----------
-+    system: qutip.QobjEvo
-+        Quantum system in which states evolve.
-+
-+    options: dict
-+        Options for the integrator.
-+
-+    Class Attributes
-+    ----------------
-+    name : str
-+        The name of the integrator.
-+
-+    supports_blackbox : bool
-+        If True, then the integrator calls only ``system.matmul``,
-+        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
-+        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
-+        the integrator to modify the system in creative ways. In particular,
-+        the solver may modify the system depending on *both* the time ``t``
-+        *and* the current ``state`` the system is being applied to.
-+
-+        If the integrator calls any other methods, set to False.
-+
-+    supports_time_dependent : bool
-+        If True, then the integrator supports time dependent systems. If False,
-+        ``supports_blackbox`` should usually be ``False`` too.
-+
-+    integrator_options : dict
-+        A dictionary of options used by the integrator and their default
-+        values. Once initiated, ``self.options`` will be a dict with the same
-+        keys, not the full options object passed to the solver. Options' keys
-+        included here will be supported by the :cls:SolverOdeOptions.
-+    """
-+    # Dict of used options and their default values
-+    integrator_options = {}
-+    _options = None
-+    # Can evolve time dependent system
-+    support_time_dependant = None
-+    # Whether the integrator used the system QobjEvo as a blackbox
-+    supports_blackbox = None
-+    # The name of the integrator
-+    name = None
-+    method = ""
-+
-+    def __init__(self, system, options):
-+        self.system = system
-+        self._is_set = False  # get_state can be used and return a valid state.
-+        self._back = (np.inf, None)
-+        self._options = self.integrator_options.copy()
-+        self.options = options
-+        self._prepare()
-+
-+    def _prepare(self):
-+        """
-+        Initialize the solver
-+        It should also set the name of the solver to be displayed in Result.
-+        """
-+        raise NotImplementedError
-+
-+    def set_state(self, t, state0):
-+        """
-+        Set the state of the ODE solver.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Initial time
-+
-+        state0 : qutip.Data
-+            Initial state.
-+
-+        .. note:
-+            It should set the flags `_is_set` to True.
-+        """
-+        raise NotImplementedError
-+
-+    def integrate(self, t, copy=True):
-+        """
-+        Evolve to t.
-+
-+        Before calling `integrate` for the first time, the initial state should
-+        be set with `set_state`.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time to integrate to, should be larger than the previous time.
-+
-+        copy : bool [True]
-+            Whether to return a copy of the state or the state itself.
-+
-+        Returns
-+        -------
-+        (t, state) : (float, qutip.Data)
-+            The state of the solver at ``t``.
-+        """
-+        raise NotImplementedError
-+
-+    def mcstep(self, t, copy=True):
-+        """
-+        Evolve toward the time ``t``.
-+
-+        If ``t`` is larger than the present state's ``t``, advance the internal
-+        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
-+        larger than the previous one, it does an interpolation step and returns
-+        the state at that time. When advancing the state, it may return it at a
-+        time between present time and the asked ``t`` if more efficent for
-+        subsequent interpolation step.
-+
-+        Before calling `mcstep` for the first time, the initial state should
-+        be set with `set_state`.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time to integrate to, should be larger than the previous time. If
-+            the last integrate call was use with ``step=True``, the time can be
-+            between the time at the start of the last call and now.
-+
-+        copy : bool [True]
-+            Whether to return a copy of the state or the state itself.
-+
-+        Returns
-+        -------
-+        (t, state) : (float, qutip.Data)
-+            The state of the solver at ``t``. The returned time ``t`` can
-+            differ from the input time only when ``step=True``.
-+
-+        .. note:
-+            The default implementation may be overridden by integrators that
-+            can provide a more efficient one.
-+        """
-+        t_last, state = self.get_state()
-+        if t > t_last:
-+            self._back = t_last, state
-+        elif t > self._back[0]:
-+            self.set_state(*self._back)
-+        else:
-+            raise IntegratorException(
-+                "`t` is outside the integration range: "
-+                f"{self._back[0]}..{t_last}."
-+            )
-+        return self.integrate(t, copy)
-+
-+    def get_state(self, copy=True):
-+        """
-+        Obtain the state of the solver as a pair (t, state).
-+
-+        Parameters
-+        ----------
-+        copy : bool (True)
-+            Whether to return the data stored in the Integrator or a copy.
-+
-+        Returns
-+        -------
-+        (t, state) : (float, qutip.Data)
-+            The state of the solver at ``t``.
-+        """
-+        raise NotImplementedError
-+
-+    def run(self, tlist):
-+        """
-+        Integrate the system yielding the state for each times in tlist.
-+
-+        Parameters
-+        ----------
-+        tlist : *list* / *array*
-+            List of times to yield the state.
-+
-+        Yields
-+        ------
-+        (t, state) : (float, qutip.Data)
-+            The state of the solver at each ``t`` of tlist.
-+        """
-+        for t in tlist[1:]:
-+            yield self.integrate(t, False)
-+
-+    def reset(self, hard=False):
-+        """Reset internal state of the ODE solver."""
-+        if self._is_set:
-+            state = self.get_state()
-+        if hard:
-+            self._prepare()
-+        if self._is_set:
-+            self.set_state(*state)
-+
-+    def arguments(self, args):
-+        """
-+        Change the argument of the system.
-+        Reset the ODE solver to ensure numerical validity.
-+
-+        Parameters
-+        ----------
-+        args : dict
-+            New arguments
-+        """
-+        self.system.arguments(args)
-+        self.reset()
-+
-+    @property
-+    def options(self):
-+        # Options should be overwritten by each integrators.
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        # This does not apply the new options.
-+        self._options = {
-+            **self._options,
-+            **{
-+               key: new_options[key]
-+               for key in self.integrator_options.keys()
-+               if key in new_options and new_options[key] is not None
-+            }
-+        }
-diff --git a/qutip/solver/integrator/krylov.py b/qutip/solver/integrator/krylov.py
-index d9cf5757..a05d198b 100644
---- a/qutip/solver/integrator/krylov.py
-+++ b/qutip/solver/integrator/krylov.py
-@@ -1,238 +1,238 @@
--from ..integrator import IntegratorException, Integrator
--import numpy as np
--from qutip.core import data as _data
--from scipy.optimize import root_scalar
--from ..sesolve import SESolver
--
--
--__all__ = ["IntegratorKrylov"]
--
--
--class IntegratorKrylov(Integrator):
--    """
--    Evolve the state vector ("psi0") finding an approximation for the time
--    evolution operator of Hamiltonian ("H") by obtaining the projection of
--    the time evolution operator on a set of small dimensional Krylov
--    subspaces (m << dim(H)).
--    """
--    integrator_options = {
--        'atol': 1e-7,
--        'nsteps': 100,
--        'min_step': 1e-5,
--        'max_step': 1e5,
--        'krylov_dim': 0,
--        'sub_system_tol': 1e-7,
--        'always_compute_step': False,
--    }
--    support_time_dependant = False
--    supports_blackbox = False
--    method = 'krylov'
--
--    def _prepare(self):
--        if not self.system.isconstant:
--            raise ValueError("krylov method only support constant system.")
--        self._max_step = -np.inf
--        krylov_dim = self.options["krylov_dim"]
--        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
--            raise ValueError("The options 'krylov_dim', must be a positive "
--                             "integer smaller that the system size")
--
--        if krylov_dim == 0:
--            # TODO: krylov_dim, max_step and error (atol) are related by
--            # err ~= exp(-krylov_dim / dt**(1~2))
--            # We could ask for 2 and determine the third one.
--            N = self.system.shape[0]
--            krylov_dim = min(int((N + 100)**0.5), N-1)
--            self.options["krylov_dim"]  = krylov_dim
--
--        if not self.options["always_compute_step"]:
--            from qutip import rand_ket
--            N = self.system.shape[0]
--            krylov_tridiag, krylov_basis = \
--                self._lanczos_algorithm(rand_ket(N).data)
--            if (
--                krylov_tridiag.shape[0] < self.options["krylov_dim"]
--                or krylov_tridiag.shape[0] == N
--            ):
--                self._max_step = np.inf
--            else:
--                self._max_step = self._compute_max_step(krylov_tridiag,
--                                                        krylov_basis)
--
--    def _lanczos_algorithm(self, psi):
--        """
--        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
--        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
--        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
--
--        Parameters
--        ------------
--        psi: np.ndarray
--            State used to calculate Krylov subspace.
--        """
--        krylov_dim = self.options['krylov_dim']
--        H = (1j * self.system(0)).data
--
--        v = []
--        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
--        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
--
--        w_prime = _data.matmul(H, psi)
--        T_diag[0] = _data.inner(w_prime, psi)
--        v.append(psi)
--        w = _data.add(w_prime, v[-1], -T_diag[0])
--        T_subdiag[0] = _data.norm.l2(w)
--        j = 0
--
--        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
--            j += 1
--            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
--            w_prime = _data.matmul(H, v[-1])
--            T_diag[j] = _data.inner(w_prime, v[-1])
--            w = _data.add(w_prime, v[-1], -T_diag[j])
--            w = _data.add(w, v[-2], -T_subdiag[j-1])
--            T_subdiag[j] = _data.norm.l2(w)
--
--        krylov_tridiag = _data.diag["dense"](
--            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
--            [-1, 0, 1]
--        )
--        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
--
--        return krylov_tridiag, krylov_basis
--
--    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
--        """
--        Compute the eigen energies, basis transformation operator (U) and e0.
--        """
--        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
--        N = eigenvalues.shape[0]
--        U = _data.matmul(krylov_basis, eigenvectors)
--        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
--        return eigenvalues, U, e0
--
--    def _compute_psi(self, dt, eigenvalues, U, e0):
--        """
--        compute the state at time ``t``.
--        """
--        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
--        aux = _data.multiply(phases, e0)
--        return _data.matmul(U, aux)
--
--    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
--        """
--        Compute the maximum step length to stay under the desired tolerance.
--        """
--        if not krylov_state:
--            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
--
--        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
--        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
--        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
--
--        def krylov_error(t):
--            # we divide by atol and take the log so that the error returned is 0
--            # at atol, which is convenient for calling root_scalar with.
--            return np.log(_data.norm.l2(
--                self._compute_psi(t, *krylov_state) -
--                self._compute_psi(t, *reduced_state)
--            ) / self.options["atol"])
--
--        dt = self.options["min_step"]
--        err = krylov_error(dt)
--        if err > 0:
--            ValueError(
--                f"With the krylov dim of {self.options['krylov_dim']}, the "
--                f"error with the minimum step {dt} is {err}, higher than the "
--                f"desired tolerance of {self.options['atol']}."
--            )
--
--        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
--            dt *= 10
--
--        if dt > self.options["max_step"]:
--            return self.options["max_step"]
--
--        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
--                          method="brentq", xtol=self.options['atol'])
--        if sol.converged:
--            return sol.root
--        else:
--            return dt
--
--    def set_state(self, t, state0):
--        self._t_0 = t
--        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
--        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
--
--        if (
--            krylov_tridiag.shape[0] <= self.options['krylov_dim']
--            or krylov_tridiag.shape == self.system.shape
--        ):
--            # happy_breakdown
--            self._max_step = np.inf
--            return
--
--        if (
--            not np.isfinite(self._max_step)
--            or self.options["always_compute_step"]
--        ):
--            self._max_step = self._compute_max_step(
--                krylov_tridiag, krylov_basis, self._krylov_state,
--            )
--
--    def get_state(self, copy=True):
--        return self._t_0, self._compute_psi(0, *self._krylov_state)
--
--    def integrate(self, t, copy=True):
--        step = 0
--        while t > self._t_0 + self._max_step:
--            # The approximation in only valid in the range t_0, t_0 + max step
--            # If outside, advance the range
--            step += 1
--            if step >= self.options["nsteps"]:
--                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
--            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
--            self.set_state(self._t_0 + self._max_step, new_psi)
--
--        delta_t = t - self._t_0
--        out = self._compute_psi(delta_t, *self._krylov_state)
--        return t, out
--
--    @property
--    def options(self):
--        """
--        Supported options by krylov method:
--
--        atol : float, default=1e-7
--            Absolute tolerance.
--
--        nsteps : int, default=100
--            Max. number of internal steps/call.
--
--        min_step, max_step : float, default=(1e-5, 1e5)
--            Minimum and maximum step size.
--
--        krylov_dim: int, default=0
--            Dimension of Krylov approximation subspaces used for the time
--            evolution approximation. If the defaut 0 is given, the dimension is calculated
--            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
--
--        sub_system_tol: float, default=1e-7
--            Tolerance to detect a happy breakdown. A happy breakdown occurs
--            when the initial ket is in a subspace of the Hamiltonian smaller
--            than ``krylov_dim``.
--
--        always_compute_step: bool, default=False
--            If True, the step length is computed each time a new Krylov
--            subspace is computed. Otherwise it is computed only once when
--            creating the integrator.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Integrator.options.fset(self, new_options)
--
--
--SESolver.add_integrator(IntegratorKrylov, 'krylov')
-+from ..integrator import IntegratorException, Integrator
-+import numpy as np
-+from qutip.core import data as _data
-+from scipy.optimize import root_scalar
-+from ..sesolve import SESolver
-+
-+
-+__all__ = ["IntegratorKrylov"]
-+
-+
-+class IntegratorKrylov(Integrator):
-+    """
-+    Evolve the state vector ("psi0") finding an approximation for the time
-+    evolution operator of Hamiltonian ("H") by obtaining the projection of
-+    the time evolution operator on a set of small dimensional Krylov
-+    subspaces (m << dim(H)).
-+    """
-+    integrator_options = {
-+        'atol': 1e-7,
-+        'nsteps': 100,
-+        'min_step': 1e-5,
-+        'max_step': 1e5,
-+        'krylov_dim': 0,
-+        'sub_system_tol': 1e-7,
-+        'always_compute_step': False,
-+    }
-+    support_time_dependant = False
-+    supports_blackbox = False
-+    method = 'krylov'
-+
-+    def _prepare(self):
-+        if not self.system.isconstant:
-+            raise ValueError("krylov method only support constant system.")
-+        self._max_step = -np.inf
-+        krylov_dim = self.options["krylov_dim"]
-+        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
-+            raise ValueError("The options 'krylov_dim', must be a positive "
-+                             "integer smaller that the system size")
-+
-+        if krylov_dim == 0:
-+            # TODO: krylov_dim, max_step and error (atol) are related by
-+            # err ~= exp(-krylov_dim / dt**(1~2))
-+            # We could ask for 2 and determine the third one.
-+            N = self.system.shape[0]
-+            krylov_dim = min(int((N + 100)**0.5), N-1)
-+            self.options["krylov_dim"]  = krylov_dim
-+
-+        if not self.options["always_compute_step"]:
-+            from qutip import rand_ket
-+            N = self.system.shape[0]
-+            krylov_tridiag, krylov_basis = \
-+                self._lanczos_algorithm(rand_ket(N).data)
-+            if (
-+                krylov_tridiag.shape[0] < self.options["krylov_dim"]
-+                or krylov_tridiag.shape[0] == N
-+            ):
-+                self._max_step = np.inf
-+            else:
-+                self._max_step = self._compute_max_step(krylov_tridiag,
-+                                                        krylov_basis)
-+
-+    def _lanczos_algorithm(self, psi):
-+        """
-+        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
-+        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
-+        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
-+
-+        Parameters
-+        ------------
-+        psi: np.ndarray
-+            State used to calculate Krylov subspace.
-+        """
-+        krylov_dim = self.options['krylov_dim']
-+        H = (1j * self.system(0)).data
-+
-+        v = []
-+        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
-+        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
-+
-+        w_prime = _data.matmul(H, psi)
-+        T_diag[0] = _data.inner(w_prime, psi)
-+        v.append(psi)
-+        w = _data.add(w_prime, v[-1], -T_diag[0])
-+        T_subdiag[0] = _data.norm.l2(w)
-+        j = 0
-+
-+        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
-+            j += 1
-+            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
-+            w_prime = _data.matmul(H, v[-1])
-+            T_diag[j] = _data.inner(w_prime, v[-1])
-+            w = _data.add(w_prime, v[-1], -T_diag[j])
-+            w = _data.add(w, v[-2], -T_subdiag[j-1])
-+            T_subdiag[j] = _data.norm.l2(w)
-+
-+        krylov_tridiag = _data.diag["dense"](
-+            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
-+            [-1, 0, 1]
-+        )
-+        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
-+
-+        return krylov_tridiag, krylov_basis
-+
-+    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
-+        """
-+        Compute the eigen energies, basis transformation operator (U) and e0.
-+        """
-+        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
-+        N = eigenvalues.shape[0]
-+        U = _data.matmul(krylov_basis, eigenvectors)
-+        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
-+        return eigenvalues, U, e0
-+
-+    def _compute_psi(self, dt, eigenvalues, U, e0):
-+        """
-+        compute the state at time ``t``.
-+        """
-+        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
-+        aux = _data.multiply(phases, e0)
-+        return _data.matmul(U, aux)
-+
-+    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
-+        """
-+        Compute the maximum step length to stay under the desired tolerance.
-+        """
-+        if not krylov_state:
-+            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
-+
-+        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
-+        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
-+        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
-+
-+        def krylov_error(t):
-+            # we divide by atol and take the log so that the error returned is 0
-+            # at atol, which is convenient for calling root_scalar with.
-+            return np.log(_data.norm.l2(
-+                self._compute_psi(t, *krylov_state) -
-+                self._compute_psi(t, *reduced_state)
-+            ) / self.options["atol"])
-+
-+        dt = self.options["min_step"]
-+        err = krylov_error(dt)
-+        if err > 0:
-+            ValueError(
-+                f"With the krylov dim of {self.options['krylov_dim']}, the "
-+                f"error with the minimum step {dt} is {err}, higher than the "
-+                f"desired tolerance of {self.options['atol']}."
-+            )
-+
-+        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
-+            dt *= 10
-+
-+        if dt > self.options["max_step"]:
-+            return self.options["max_step"]
-+
-+        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
-+                          method="brentq", xtol=self.options['atol'])
-+        if sol.converged:
-+            return sol.root
-+        else:
-+            return dt
-+
-+    def set_state(self, t, state0):
-+        self._t_0 = t
-+        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
-+        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
-+
-+        if (
-+            krylov_tridiag.shape[0] <= self.options['krylov_dim']
-+            or krylov_tridiag.shape == self.system.shape
-+        ):
-+            # happy_breakdown
-+            self._max_step = np.inf
-+            return
-+
-+        if (
-+            not np.isfinite(self._max_step)
-+            or self.options["always_compute_step"]
-+        ):
-+            self._max_step = self._compute_max_step(
-+                krylov_tridiag, krylov_basis, self._krylov_state,
-+            )
-+
-+    def get_state(self, copy=True):
-+        return self._t_0, self._compute_psi(0, *self._krylov_state)
-+
-+    def integrate(self, t, copy=True):
-+        step = 0
-+        while t > self._t_0 + self._max_step:
-+            # The approximation in only valid in the range t_0, t_0 + max step
-+            # If outside, advance the range
-+            step += 1
-+            if step >= self.options["nsteps"]:
-+                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
-+            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
-+            self.set_state(self._t_0 + self._max_step, new_psi)
-+
-+        delta_t = t - self._t_0
-+        out = self._compute_psi(delta_t, *self._krylov_state)
-+        return t, out
-+
-+    @property
-+    def options(self):
-+        """
-+        Supported options by krylov method:
-+
-+        atol : float, default=1e-7
-+            Absolute tolerance.
-+
-+        nsteps : int, default=100
-+            Max. number of internal steps/call.
-+
-+        min_step, max_step : float, default=(1e-5, 1e5)
-+            Minimum and maximum step size.
-+
-+        krylov_dim: int, default=0
-+            Dimension of Krylov approximation subspaces used for the time
-+            evolution approximation. If the defaut 0 is given, the dimension is calculated
-+            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
-+
-+        sub_system_tol: float, default=1e-7
-+            Tolerance to detect a happy breakdown. A happy breakdown occurs
-+            when the initial ket is in a subspace of the Hamiltonian smaller
-+            than ``krylov_dim``.
-+
-+        always_compute_step: bool, default=False
-+            If True, the step length is computed each time a new Krylov
-+            subspace is computed. Otherwise it is computed only once when
-+            creating the integrator.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Integrator.options.fset(self, new_options)
-+
-+
-+SESolver.add_integrator(IntegratorKrylov, 'krylov')
-diff --git a/qutip/solver/integrator/qutip_integrator.py b/qutip/solver/integrator/qutip_integrator.py
-index 03749a57..eca2da63 100644
---- a/qutip/solver/integrator/qutip_integrator.py
-+++ b/qutip/solver/integrator/qutip_integrator.py
-@@ -1,200 +1,200 @@
--from ..integrator import IntegratorException, Integrator
--from ..solver_base import Solver
--from .explicit_rk import Explicit_RungeKutta
--import numpy as np
--from qutip import data as _data
--
--
--__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
--
--
--class IntegratorVern7(Integrator):
--    """
--    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
--    of order 7. These are Runge-Kutta methods with variable steps and dense
--    output.
--
--    The implementation uses QuTiP's Data objects for the state, allowing
--    sparse, GPU or other data layer objects to be used efficiently by the
--    solver in their native formats.
--
--    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
--    methods.
--
--    Usable with ``method="vern7"``
--    """
--    integrator_options = {
--        'atol': 1e-8,
--        'rtol': 1e-6,
--        'nsteps': 1000,
--        'first_step': 0,
--        'max_step': 0,
--        'min_step': 0,
--        'interpolate': True,
--    }
--    support_time_dependant = True
--    supports_blackbox = True
--    method = 'vern7'
--
--    def _prepare(self):
--        self._ode_solver = Explicit_RungeKutta(
--            self.system, method=self.method,
--            **self.options
--        )
--        self.name = self.method
--
--    def get_state(self, copy=True):
--        state = self._ode_solver.y
--        return self._ode_solver.t, state.copy() if copy else state
--
--    def set_state(self, t, state):
--        self._ode_solver.set_initial_value(state.copy(), t)
--        self._is_set = True
--
--    def integrate(self, t, copy=True):
--        self._ode_solver.integrate(t, step=False)
--        self._check_failed_integration()
--        return self.get_state(copy)
--
--    def mcstep(self, t, copy=True):
--        self._ode_solver.integrate(t, step=True)
--        self._check_failed_integration()
--        return self.get_state(copy)
--
--    def _check_failed_integration(self):
--        if self._ode_solver.successful():
--            return
--        raise IntegratorException(self._ode_solver.status_message())
--
--    @property
--    def options(self):
--        """
--        Supported options by verner method:
--
--        atol : float, default=1e-8
--            Absolute tolerance.
--
--        rtol : float, default=1e-6
--            Relative tolerance.
--
--        nsteps : int, default=1000
--            Max. number of internal steps/call.
--
--        first_step : float, default=0
--            Size of initial step (0 = automatic).
--
--        min_step : float, default=0
--            Minimum step size (0 = automatic).
--
--        max_step : float, default=0
--            Maximum step size (0 = automatic)
--            When using pulses, change to half the thinest pulse otherwise it
--            may be skipped.
--
--        interpolate : bool, default=True
--            Whether to use interpolation step, faster most of the time.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Integrator.options.fset(self, new_options)
--
--
--class IntegratorVern9(IntegratorVern7):
--    """
--    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
--    of order 9. These are Runge-Kutta methods with variable steps and dense
--    output.
--
--    The implementation uses QuTiP's Data objects for the state, allowing
--    sparse, GPU or other data layer objects to be used efficiently by the
--    solver in their native formats.
--
--    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
--    methods.
--
--    Usable with ``method="vern9"``
--    """
--    integrator_options = {
--        'atol': 1e-8,
--        'rtol': 1e-6,
--        'nsteps': 1000,
--        'first_step': 0,
--        'max_step': 0,
--        'min_step': 0,
--        'interpolate': True,
--    }
--    method = 'vern9'
--
--
--class IntegratorDiag(Integrator):
--    """
--    Integrator solving the ODE by diagonalizing the system and solving
--    analytically. It can only solve constant system and has a long preparation
--    time, but the integration is fast.
--
--    Usable with ``method="diag"``
--    """
--    integrator_options = {"eigensolver_dtype": "dense"}
--    support_time_dependant = False
--    supports_blackbox = False
--    method = 'diag'
--
--    def __init__(self, system, options):
--        if not system.isconstant:
--            raise ValueError("Hamiltonian system must be constant to use "
--                             "diagonalized method")
--        super().__init__(system, options)
--
--    def _prepare(self):
--        self._dt = 0.
--        self._expH = None
--        H0 = self.system(0).to(self.options["eigensolver_dtype"])
--        self.diag, self.U = _data.eigs(H0.data, False)
--        self.diag = self.diag.reshape((-1, 1))
--        self.Uinv = _data.inv(self.U)
--        self.name = "qutip diagonalized"
--
--    def integrate(self, t, copy=True):
--        dt = t - self._t
--        if dt == 0:
--            return self.get_state()
--        elif self._dt != dt:
--            self._expH = np.exp(self.diag * dt)
--            self._dt = dt
--        self._y *= self._expH
--        self._t = t
--        return self.get_state(copy)
--
--    def mcstep(self, t, copy=True):
--        return self.integrate(t, copy=copy)
--
--    def get_state(self, copy=True):
--        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
--
--    def set_state(self, t, state0):
--        self._t = t
--        self._y = _data.matmul(self.Uinv, state0).to_array()
--        self._is_set = True
--
--    @property
--    def options(self):
--        """
--        Supported options by "diag" method:
--
--        eigensolver_dtype : str, default="dense"
--            Qutip data type {"dense", "csr", etc.} to use when computing the
--            eigenstates. The dense eigen solver is usually faster and more
--            stable.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Integrator.options.fset(self, new_options)
--
--
--Solver.add_integrator(IntegratorVern7, 'vern7')
--Solver.add_integrator(IntegratorVern9, 'vern9')
--Solver.add_integrator(IntegratorDiag, 'diag')
-+from ..integrator import IntegratorException, Integrator
-+from ..solver_base import Solver
-+from .explicit_rk import Explicit_RungeKutta
-+import numpy as np
-+from qutip import data as _data
-+
-+
-+__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
-+
-+
-+class IntegratorVern7(Integrator):
-+    """
-+    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
-+    of order 7. These are Runge-Kutta methods with variable steps and dense
-+    output.
-+
-+    The implementation uses QuTiP's Data objects for the state, allowing
-+    sparse, GPU or other data layer objects to be used efficiently by the
-+    solver in their native formats.
-+
-+    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
-+    methods.
-+
-+    Usable with ``method="vern7"``
-+    """
-+    integrator_options = {
-+        'atol': 1e-8,
-+        'rtol': 1e-6,
-+        'nsteps': 1000,
-+        'first_step': 0,
-+        'max_step': 0,
-+        'min_step': 0,
-+        'interpolate': True,
-+    }
-+    support_time_dependant = True
-+    supports_blackbox = True
-+    method = 'vern7'
-+
-+    def _prepare(self):
-+        self._ode_solver = Explicit_RungeKutta(
-+            self.system, method=self.method,
-+            **self.options
-+        )
-+        self.name = self.method
-+
-+    def get_state(self, copy=True):
-+        state = self._ode_solver.y
-+        return self._ode_solver.t, state.copy() if copy else state
-+
-+    def set_state(self, t, state):
-+        self._ode_solver.set_initial_value(state.copy(), t)
-+        self._is_set = True
-+
-+    def integrate(self, t, copy=True):
-+        self._ode_solver.integrate(t, step=False)
-+        self._check_failed_integration()
-+        return self.get_state(copy)
-+
-+    def mcstep(self, t, copy=True):
-+        self._ode_solver.integrate(t, step=True)
-+        self._check_failed_integration()
-+        return self.get_state(copy)
-+
-+    def _check_failed_integration(self):
-+        if self._ode_solver.successful():
-+            return
-+        raise IntegratorException(self._ode_solver.status_message())
-+
-+    @property
-+    def options(self):
-+        """
-+        Supported options by verner method:
-+
-+        atol : float, default=1e-8
-+            Absolute tolerance.
-+
-+        rtol : float, default=1e-6
-+            Relative tolerance.
-+
-+        nsteps : int, default=1000
-+            Max. number of internal steps/call.
-+
-+        first_step : float, default=0
-+            Size of initial step (0 = automatic).
-+
-+        min_step : float, default=0
-+            Minimum step size (0 = automatic).
-+
-+        max_step : float, default=0
-+            Maximum step size (0 = automatic)
-+            When using pulses, change to half the thinest pulse otherwise it
-+            may be skipped.
-+
-+        interpolate : bool, default=True
-+            Whether to use interpolation step, faster most of the time.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Integrator.options.fset(self, new_options)
-+
-+
-+class IntegratorVern9(IntegratorVern7):
-+    """
-+    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
-+    of order 9. These are Runge-Kutta methods with variable steps and dense
-+    output.
-+
-+    The implementation uses QuTiP's Data objects for the state, allowing
-+    sparse, GPU or other data layer objects to be used efficiently by the
-+    solver in their native formats.
-+
-+    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
-+    methods.
-+
-+    Usable with ``method="vern9"``
-+    """
-+    integrator_options = {
-+        'atol': 1e-8,
-+        'rtol': 1e-6,
-+        'nsteps': 1000,
-+        'first_step': 0,
-+        'max_step': 0,
-+        'min_step': 0,
-+        'interpolate': True,
-+    }
-+    method = 'vern9'
-+
-+
-+class IntegratorDiag(Integrator):
-+    """
-+    Integrator solving the ODE by diagonalizing the system and solving
-+    analytically. It can only solve constant system and has a long preparation
-+    time, but the integration is fast.
-+
-+    Usable with ``method="diag"``
-+    """
-+    integrator_options = {"eigensolver_dtype": "dense"}
-+    support_time_dependant = False
-+    supports_blackbox = False
-+    method = 'diag'
-+
-+    def __init__(self, system, options):
-+        if not system.isconstant:
-+            raise ValueError("Hamiltonian system must be constant to use "
-+                             "diagonalized method")
-+        super().__init__(system, options)
-+
-+    def _prepare(self):
-+        self._dt = 0.
-+        self._expH = None
-+        H0 = self.system(0).to(self.options["eigensolver_dtype"])
-+        self.diag, self.U = _data.eigs(H0.data, False)
-+        self.diag = self.diag.reshape((-1, 1))
-+        self.Uinv = _data.inv(self.U)
-+        self.name = "qutip diagonalized"
-+
-+    def integrate(self, t, copy=True):
-+        dt = t - self._t
-+        if dt == 0:
-+            return self.get_state()
-+        elif self._dt != dt:
-+            self._expH = np.exp(self.diag * dt)
-+            self._dt = dt
-+        self._y *= self._expH
-+        self._t = t
-+        return self.get_state(copy)
-+
-+    def mcstep(self, t, copy=True):
-+        return self.integrate(t, copy=copy)
-+
-+    def get_state(self, copy=True):
-+        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
-+
-+    def set_state(self, t, state0):
-+        self._t = t
-+        self._y = _data.matmul(self.Uinv, state0).to_array()
-+        self._is_set = True
-+
-+    @property
-+    def options(self):
-+        """
-+        Supported options by "diag" method:
-+
-+        eigensolver_dtype : str, default="dense"
-+            Qutip data type {"dense", "csr", etc.} to use when computing the
-+            eigenstates. The dense eigen solver is usually faster and more
-+            stable.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Integrator.options.fset(self, new_options)
-+
-+
-+Solver.add_integrator(IntegratorVern7, 'vern7')
-+Solver.add_integrator(IntegratorVern9, 'vern9')
-+Solver.add_integrator(IntegratorDiag, 'diag')
-diff --git a/qutip/solver/integrator/scipy_integrator.py b/qutip/solver/integrator/scipy_integrator.py
-index dac1028a..7c71185f 100644
---- a/qutip/solver/integrator/scipy_integrator.py
-+++ b/qutip/solver/integrator/scipy_integrator.py
-@@ -1,527 +1,527 @@
--"""ODE integrator from scipy."""
--
--__all__ = [
--    'IntegratorScipyAdams',
--    'IntegratorScipyBDF',
--    'IntegratorScipyDop853',
--    'IntegratorScipylsoda',
--]
--
--import numpy as np
--from scipy.integrate import ode
--from scipy.integrate._ode import zvode
--from qutip.core import data as _data
--from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
--from ..integrator import IntegratorException, Integrator
--from ..solver_base import Solver
--import warnings
--
--
--class IntegratorScipyAdams(Integrator):
--    """
--    Integrator using Scipy `ode` with zvode integrator using adams method.
--    Ordinary Differential Equation solver by netlib
--    (http://www.netlib.org/odepack).
--
--    Usable with ``method="adams"``
--    """
--    integrator_options = {
--        'atol': 1e-8,
--        'rtol': 1e-6,
--        'nsteps': 2500,
--        'order': 12,
--        'first_step': 0,
--        'max_step': 0,
--        'min_step': 0,
--    }
--    support_time_dependant = True
--    supports_blackbox = True
--    method = 'adams'
--
--    class _zvode(zvode):
--        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
--        def step(self, *args):
--            itask = self.call_args[2]
--            self.rwork[0] = args[4]
--            self.call_args[2] = 5
--            r = self.run(*args)
--            self.call_args[2] = itask
--            return r
--
--    def _prepare(self):
--        """
--        Initialize the solver
--        """
--        self._ode_solver = ode(self._mul_np_vec)
--        self._ode_solver.set_integrator('zvode')
--        self._ode_solver._integrator = self._zvode(
--            method=self.method,
--            **self.options,
--        )
--        self.name = "scipy zvode " + self.method
--
--    def _mul_np_vec(self, t, vec):
--        """
--        Interface between scipy which use numpy and the driver, which use data.
--        """
--        state = _data.dense.fast_from_numpy(vec)
--        column_unstack_dense(state, self._size, inplace=True)
--        out = self.system.matmul_data(t, state)
--        column_stack_dense(out, inplace=True)
--        return out.as_ndarray().ravel()
--
--    def set_state(self, t, state0):
--        self._is_set = True
--        self._back = t
--        self._front = t
--        self._mat_state = state0.shape[1] > 1
--        self._size = state0.shape[0]
--        if self._mat_state:
--            state0 = _data.column_stack(state0)
--        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
--
--    def get_state(self, copy=True):
--        if not self._is_set:
--            raise IntegratorException("The state is not initialted")
--        self._check_failed_integration()
--        t = self._ode_solver.t
--        if self._mat_state:
--            state = _data.column_unstack_dense(
--                _data.dense.Dense(self._ode_solver._y, copy=copy),
--                self._size,
--                inplace=True)
--        else:
--            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
--        return t, state
--
--    def _check_handle(self):
--        """
--        Do the check for concurrent use of the integrator and reset if used
--        elsewhere.
--        """
--        integrator = self._ode_solver._integrator
--        if integrator.initialized:
--            if integrator.handle != integrator.__class__.active_global_handle:
--                integrator.reset(len(self._ode_solver._y), False)
--
--    def integrate(self, t, copy=True):
--        self._check_handle()
--        if t != self._ode_solver.t:
--            self._ode_solver.integrate(t)
--        return self.get_state(copy)
--
--    def mcstep(self, t, copy=True):
--        # When working with mcstep, we use the dense output feature:
--        # a range in which the state at any time can be computed with
--        # minimal work. We keep track of the range with _back and _front.
--        self._check_handle()
--        if self._ode_solver.t == t:
--            # Exact same `t` as the last call, nothing to do.
--            pass
--        elif self._back > t:
--            # `t` before the range: not supported.
--            raise IntegratorException(
--                f"`t`={t} is behind the integration limit: "
--                f"{t} < {self._back}."
--            )
--        elif t <= self._front:
--            # In the range, ask for the new state.
--            self._ode_solver.integrate(t)
--        elif self._ode_solver.t < self._front:
--            # `t` after the range but last call (`t_prev`) not at the front.
--            # Advancing the range would make the interval `t_prev`..`_front`
--            # unreachable. Thus advance to _front.
--            self._ode_solver.integrate(self._front)
--        else:
--            # Advance the range.
--            self._back = self._front
--            self._ode_solver.integrate(t, step=True)
--            self._front = self._ode_solver._integrator.rwork[12]
--
--        return self.get_state(copy)
--
--    def _check_failed_integration(self):
--        if self._ode_solver.successful():
--            return
--        messages = {
--            -1: 'Excess work done on this call. Try to increasing '
--                'the nsteps parameter in the Options class',
--            -2: 'Excess accuracy requested. (Tolerances too small.)',
--            -3: 'Illegal input detected.',
--            -4: 'Repeated error test failures. (Check all input.)',
--            -5: 'Repeated convergence failures. (Perhaps bad'
--                ' Jacobian supplied or wrong choice of MF or tolerances.)',
--            -6: 'Error weight became zero during problem. (Solution'
--                ' component i vanished, and ATOL or ATOL(i) = 0.)'
--        }
--        raise IntegratorException(
--            messages[self._ode_solver._integrator.istate]
--        )
--
--    @property
--    def options(self):
--        """
--        Supported options by zvode integrator:
--
--        atol : float, default=1e-8
--            Absolute tolerance.
--
--        rtol : float, default=1e-6
--            Relative tolerance.
--
--        order : int, default=12, 'adams' or 5, 'bdf'
--            Order of integrator <=12 'adams', <=5 'bdf'
--
--        nsteps : int, default=2500
--            Max. number of internal steps/call.
--
--        first_step : float, default=0
--            Size of initial step (0 = automatic).
--
--        min_step : float, default=0
--            Minimum step size (0 = automatic).
--
--        max_step : float, default=0
--            Maximum step size (0 = automatic)
--            When using pulses, change to half the thinest pulse otherwise it
--            may be skipped.
--    """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Integrator.options.fset(self, new_options)
--
--
--class IntegratorScipyBDF(IntegratorScipyAdams):
--    """
--    Integrator using Scipy `ode` with zvode integrator using bdf method.
--    Ordinary Differential Equation solver by netlib
--    (http://www.netlib.org/odepack).
--
--    Usable with ``method="bdf"``
--    """
--    method = 'bdf'
--    integrator_options = {
--        'atol': 1e-8,
--        'rtol': 1e-6,
--        'nsteps': 2500,
--        'order': 5,
--        'first_step': 0,
--        'max_step': 0,
--        'min_step': 0,
--    }
--
--
--class IntegratorScipyDop853(Integrator):
--    """
--    Integrator using Scipy `ode` with dop853 integrator. Eight order
--    runge-kutta method by Dormand & Prince. Use fortran implementation
--    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
--    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
--    Computational Mathematics, Springer-Verlag (1993)].
--
--    Usable with ``method="dop853"``
--    """
--    integrator_options = {
--        'atol': 1e-8,
--        'rtol': 1e-6,
--        'nsteps': 2500,
--        'first_step': 0,
--        'max_step': 0,
--        'ifactor': 6.0,
--        'dfactor': 0.3,
--        'beta': 0.0,
--    }
--    support_time_dependant = True
--    supports_blackbox = True
--    method = 'dop853'
--
--    def _prepare(self):
--        """
--        Initialize the solver
--        """
--        self._ode_solver = ode(self._mul_np_vec)
--        self._ode_solver.set_integrator('dop853', **self.options)
--        self.name = "scipy ode dop853"
--
--    def _mul_np_vec(self, t, vec):
--        """
--        Interface between scipy which use numpy and the driver, which use data.
--        """
--        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
--        column_unstack_dense(state, self._size, inplace=True)
--        out = self.system.matmul_data(t, state)
--        column_stack_dense(out, inplace=True)
--        return out.as_ndarray().ravel().view(np.float64)
--
--    def integrate(self, t, copy=True):
--        if t != self._ode_solver.t:
--            self._ode_solver.integrate(t)
--        return self.get_state(copy)
--
--    def mcstep(self, t, copy=True):
--        if self._ode_solver.t <= t:
--            # Scipy's DOP853 does not have a step function.
--            # It has a safe step length, but can be 0 if unknown.
--            dt = self._ode_solver._integrator.work[6]
--            if dt:
--                t = min(self._ode_solver.t + dt, t)
--            self._ode_solver.integrate(t)
--        else:
--            # While DOP853 support changing the direction of the integration,
--            # it does not do so efficiently. We do it manually.
--            self._ode_solver._integrator.work[6] *= -1
--            self._ode_solver.integrate(t)
--            self._ode_solver._integrator.work[6] *= -1
--        return self.get_state(copy)
--
--    def get_state(self, copy=True):
--        if not self._is_set:
--            raise IntegratorException("The state is not initialted")
--        self._check_failed_integration()
--        t = self._ode_solver.t
--        if self._mat_state:
--            state = _data.column_unstack_dense(
--                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
--                                  copy=copy),
--                self._size,
--                inplace=True)
--        else:
--            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
--                                      copy=copy)
--        return t, state
--
--    def set_state(self, t, state0):
--        self._is_set = True
--        self._mat_state = state0.shape[1] > 1
--        self._size = state0.shape[0]
--        if self._mat_state:
--            state0 = _data.column_stack(state0)
--        self._ode_solver.set_initial_value(
--            state0.to_array().ravel().view(np.float64),
--            t
--        )
--
--    def _check_failed_integration(self):
--        if self._ode_solver.successful():
--            return
--        messages = {
--            -1: 'input is not consistent',
--            -2: 'larger nsteps is needed, Try to increase the nsteps '
--                'parameter in the Options class.',
--            -3: 'step size becomes too small. Try increasing tolerance',
--            -4: 'problem is probably stiff (interrupted), try "bdf" '
--                'method instead',
--        }
--        raise IntegratorException(
--            messages[self._ode_solver._integrator.istate]
--        )
--
--    @property
--    def options(self):
--        """
--        Supported options by dop853 integrator:
--
--        atol : float, default=1e-8
--            Absolute tolerance.
--
--        rtol : float, default=1e-6
--            Relative tolerance.
--
--        nsteps : int, default=2500
--            Max. number of internal steps/call.
--
--        first_step : float, default=0
--            Size of initial step (0 = automatic).
--
--        max_step : float, default=0
--            Maximum step size (0 = automatic)
--
--        ifactor, dfactor : float, default=6., 0.3
--            Maximum factor to increase/decrease step size by in one step
--
--        beta : float, default=0
--            Beta parameter for stabilised step size control.
--
--        See scipy.integrate.ode ode for more detail
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Integrator.options.fset(self, new_options)
--
--
--class IntegratorScipylsoda(IntegratorScipyDop853):
--    """
--    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
--    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
--    'BDF' methods to solve both stiff and non-stiff systems.
--
--    Usable with ``method="lsoda"``
--    """
--    integrator_options = {
--        'atol': 1e-8,
--        'rtol': 1e-6,
--        'nsteps': 2500,
--        'max_order_ns': 12,
--        'max_order_s': 5,
--        'first_step': 0.0,
--        'max_step': 0.0,
--        'min_step': 0.0,
--    }
--    support_time_dependant = True
--    supports_blackbox = True
--    method = 'lsoda'
--
--    def _prepare(self):
--        """
--        Initialize the solver
--        """
--        self._ode_solver = ode(self._mul_np_vec)
--        self._ode_solver.set_integrator('lsoda', **self.options)
--        self.name = "scipy lsoda"
--
--    def _check_handle(self):
--        """
--        Do the check for concurrent use of the integrator and reset if used
--        elsewhere.
--        """
--        integrator = self._ode_solver._integrator
--        if integrator.initialized:
--            if integrator.handle != integrator.__class__.active_global_handle:
--                integrator.reset(len(self._ode_solver._y), False)
--
--    def integrate(self, t, copy=True):
--        self._check_handle()
--        return super().integrate(t, copy)
--
--    def set_state(self, t, state0):
--        self._front = t
--        super().set_state(t, state0)
--        self._back = self.get_state()
--
--    def mcstep(self, t, copy=True):
--        # This solver support dense output:
--        # a range in which the state at any time can be computed with
--        # minimal work. We keep track of the range with _back[0] and _front.
--        self._check_handle()
--        if self._ode_solver.t == t:
--            # Exact same `t` as the last call, nothing to do.
--            pass
--        elif self._back[0] <= t <= self._front:
--            # In the range, ask for the new state.
--            self._backstep(t)
--        elif self._front < t:
--            # Advance the range.
--            self._one_step(t)
--        else:
--            raise IntegratorException(
--                f"`t`={t} is behind the integration limit: "
--                f"{t} < {self._back[0]}."
--            )
--        return self.get_state(copy)
--
--    def _one_step(self, t):
--        """
--        Advance up to t by one internal solver step.
--        Should be able to retreive the state at any time between the present
--        time and the resulting time using `backstep`.
--        """
--        # Here we want to advance up to t doing maximum one step.
--        # lsoda officially support step, but sometime it does more work than
--        # needed, so we ask it to advance a fraction of the last step, where it
--        # will advance one internal step of length allowed by the tolerance and
--        # interpolate back to the asked time, effictively getting the single
--        # integration step we want. The first step and abrupt changes in the
--        # `rhs` can cause exceptions to this, but _backstep catch those cases.
--        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
--        t_ode = self._ode_solver.t
--
--        if t > self._front and t_ode >= self._front:
--            # The state is at self._front, do a step
--            self._back = self.get_state()
--            self._ode_solver.integrate(min(self._front + safe_delta, t))
--            self._front = self._ode_solver._integrator.rwork[12]
--            # We asked for a fraction of a step, now complete it.
--            self._ode_solver.integrate(min(self._front, t))
--        elif t > self._front:
--            # The state is at a time before t_front, advance to t_front
--            self._ode_solver.integrate(self._front)
--
--    def _backstep(self, t):
--        """
--        Retreive the state at time t, with t smaller than present ODE time.
--        The time t will always be between the last calls of `one_step`.
--        return the pair t, state.
--        """
--        delta = self._ode_solver._integrator.rwork[11]
--        if t == self._ode_solver.t:
--            pass
--        elif self._front - delta <= t:
--            self._ode_solver.integrate(t)
--        else:
--            self.set_state(*self._back)
--            self._ode_solver.integrate(t)
--
--    def _check_failed_integration(self):
--        if self._ode_solver.successful():
--            return
--        messages = {
--            -1: "Excess work done on this call."
--                "Try to increase the nsteps parameter in the Options class.",
--            -2: "Excess accuracy requested (tolerances too small).",
--            -3: "Illegal input detected (internal error).",
--            -4: "Repeated error test failures (internal error).",
--            -5: "Repeated convergence failures "
--                "(perhaps bad Jacobian or tolerances).",
--            -6: "Error weight became zero during problem.",
--            -7: "Internal workspace insufficient to finish (internal error)."
--        }
--        raise IntegratorException(
--            messages[self._ode_solver._integrator.istate]
--        )
--
--    @property
--    def options(self):
--        """
--        Supported options by lsoda integrator:
--
--        atol : float, default=1e-8
--            Absolute tolerance.
--
--        rtol : float, default=1e-6
--            Relative tolerance.
--
--        nsteps : int, default=2500
--            Max. number of internal steps/call.
--
--        max_order_ns : int, default=12
--            Maximum order used in the nonstiff case (<= 12).
--
--        max_order_s : int, default=5
--            Maximum order used in the stiff case (<= 5).
--
--        first_step : float, default=0
--            Size of initial step (0 = automatic).
--
--        max_step : float, default=0
--            Maximum step size (0 = automatic)
--            When using pulses, change to half the thinest pulse otherwise it
--            may be skipped.
--
--        min_step : float, default=0
--            Minimum step size (0 = automatic)
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Integrator.options.fset(self, new_options)
--
--
--Solver.add_integrator(IntegratorScipyBDF, 'bdf')
--Solver.add_integrator(IntegratorScipyAdams, 'adams')
--Solver.add_integrator(IntegratorScipyDop853, 'dop853')
--Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
-+"""ODE integrator from scipy."""
-+
-+__all__ = [
-+    'IntegratorScipyAdams',
-+    'IntegratorScipyBDF',
-+    'IntegratorScipyDop853',
-+    'IntegratorScipylsoda',
-+]
-+
-+import numpy as np
-+from scipy.integrate import ode
-+from scipy.integrate._ode import zvode
-+from qutip.core import data as _data
-+from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
-+from ..integrator import IntegratorException, Integrator
-+from ..solver_base import Solver
-+import warnings
-+
-+
-+class IntegratorScipyAdams(Integrator):
-+    """
-+    Integrator using Scipy `ode` with zvode integrator using adams method.
-+    Ordinary Differential Equation solver by netlib
-+    (http://www.netlib.org/odepack).
-+
-+    Usable with ``method="adams"``
-+    """
-+    integrator_options = {
-+        'atol': 1e-8,
-+        'rtol': 1e-6,
-+        'nsteps': 2500,
-+        'order': 12,
-+        'first_step': 0,
-+        'max_step': 0,
-+        'min_step': 0,
-+    }
-+    support_time_dependant = True
-+    supports_blackbox = True
-+    method = 'adams'
-+
-+    class _zvode(zvode):
-+        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
-+        def step(self, *args):
-+            itask = self.call_args[2]
-+            self.rwork[0] = args[4]
-+            self.call_args[2] = 5
-+            r = self.run(*args)
-+            self.call_args[2] = itask
-+            return r
-+
-+    def _prepare(self):
-+        """
-+        Initialize the solver
-+        """
-+        self._ode_solver = ode(self._mul_np_vec)
-+        self._ode_solver.set_integrator('zvode')
-+        self._ode_solver._integrator = self._zvode(
-+            method=self.method,
-+            **self.options,
-+        )
-+        self.name = "scipy zvode " + self.method
-+
-+    def _mul_np_vec(self, t, vec):
-+        """
-+        Interface between scipy which use numpy and the driver, which use data.
-+        """
-+        state = _data.dense.fast_from_numpy(vec)
-+        column_unstack_dense(state, self._size, inplace=True)
-+        out = self.system.matmul_data(t, state)
-+        column_stack_dense(out, inplace=True)
-+        return out.as_ndarray().ravel()
-+
-+    def set_state(self, t, state0):
-+        self._is_set = True
-+        self._back = t
-+        self._front = t
-+        self._mat_state = state0.shape[1] > 1
-+        self._size = state0.shape[0]
-+        if self._mat_state:
-+            state0 = _data.column_stack(state0)
-+        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
-+
-+    def get_state(self, copy=True):
-+        if not self._is_set:
-+            raise IntegratorException("The state is not initialted")
-+        self._check_failed_integration()
-+        t = self._ode_solver.t
-+        if self._mat_state:
-+            state = _data.column_unstack_dense(
-+                _data.dense.Dense(self._ode_solver._y, copy=copy),
-+                self._size,
-+                inplace=True)
-+        else:
-+            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
-+        return t, state
-+
-+    def _check_handle(self):
-+        """
-+        Do the check for concurrent use of the integrator and reset if used
-+        elsewhere.
-+        """
-+        integrator = self._ode_solver._integrator
-+        if integrator.initialized:
-+            if integrator.handle != integrator.__class__.active_global_handle:
-+                integrator.reset(len(self._ode_solver._y), False)
-+
-+    def integrate(self, t, copy=True):
-+        self._check_handle()
-+        if t != self._ode_solver.t:
-+            self._ode_solver.integrate(t)
-+        return self.get_state(copy)
-+
-+    def mcstep(self, t, copy=True):
-+        # When working with mcstep, we use the dense output feature:
-+        # a range in which the state at any time can be computed with
-+        # minimal work. We keep track of the range with _back and _front.
-+        self._check_handle()
-+        if self._ode_solver.t == t:
-+            # Exact same `t` as the last call, nothing to do.
-+            pass
-+        elif self._back > t:
-+            # `t` before the range: not supported.
-+            raise IntegratorException(
-+                f"`t`={t} is behind the integration limit: "
-+                f"{t} < {self._back}."
-+            )
-+        elif t <= self._front:
-+            # In the range, ask for the new state.
-+            self._ode_solver.integrate(t)
-+        elif self._ode_solver.t < self._front:
-+            # `t` after the range but last call (`t_prev`) not at the front.
-+            # Advancing the range would make the interval `t_prev`..`_front`
-+            # unreachable. Thus advance to _front.
-+            self._ode_solver.integrate(self._front)
-+        else:
-+            # Advance the range.
-+            self._back = self._front
-+            self._ode_solver.integrate(t, step=True)
-+            self._front = self._ode_solver._integrator.rwork[12]
-+
-+        return self.get_state(copy)
-+
-+    def _check_failed_integration(self):
-+        if self._ode_solver.successful():
-+            return
-+        messages = {
-+            -1: 'Excess work done on this call. Try to increasing '
-+                'the nsteps parameter in the Options class',
-+            -2: 'Excess accuracy requested. (Tolerances too small.)',
-+            -3: 'Illegal input detected.',
-+            -4: 'Repeated error test failures. (Check all input.)',
-+            -5: 'Repeated convergence failures. (Perhaps bad'
-+                ' Jacobian supplied or wrong choice of MF or tolerances.)',
-+            -6: 'Error weight became zero during problem. (Solution'
-+                ' component i vanished, and ATOL or ATOL(i) = 0.)'
-+        }
-+        raise IntegratorException(
-+            messages[self._ode_solver._integrator.istate]
-+        )
-+
-+    @property
-+    def options(self):
-+        """
-+        Supported options by zvode integrator:
-+
-+        atol : float, default=1e-8
-+            Absolute tolerance.
-+
-+        rtol : float, default=1e-6
-+            Relative tolerance.
-+
-+        order : int, default=12, 'adams' or 5, 'bdf'
-+            Order of integrator <=12 'adams', <=5 'bdf'
-+
-+        nsteps : int, default=2500
-+            Max. number of internal steps/call.
-+
-+        first_step : float, default=0
-+            Size of initial step (0 = automatic).
-+
-+        min_step : float, default=0
-+            Minimum step size (0 = automatic).
-+
-+        max_step : float, default=0
-+            Maximum step size (0 = automatic)
-+            When using pulses, change to half the thinest pulse otherwise it
-+            may be skipped.
-+    """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Integrator.options.fset(self, new_options)
-+
-+
-+class IntegratorScipyBDF(IntegratorScipyAdams):
-+    """
-+    Integrator using Scipy `ode` with zvode integrator using bdf method.
-+    Ordinary Differential Equation solver by netlib
-+    (http://www.netlib.org/odepack).
-+
-+    Usable with ``method="bdf"``
-+    """
-+    method = 'bdf'
-+    integrator_options = {
-+        'atol': 1e-8,
-+        'rtol': 1e-6,
-+        'nsteps': 2500,
-+        'order': 5,
-+        'first_step': 0,
-+        'max_step': 0,
-+        'min_step': 0,
-+    }
-+
-+
-+class IntegratorScipyDop853(Integrator):
-+    """
-+    Integrator using Scipy `ode` with dop853 integrator. Eight order
-+    runge-kutta method by Dormand & Prince. Use fortran implementation
-+    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
-+    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
-+    Computational Mathematics, Springer-Verlag (1993)].
-+
-+    Usable with ``method="dop853"``
-+    """
-+    integrator_options = {
-+        'atol': 1e-8,
-+        'rtol': 1e-6,
-+        'nsteps': 2500,
-+        'first_step': 0,
-+        'max_step': 0,
-+        'ifactor': 6.0,
-+        'dfactor': 0.3,
-+        'beta': 0.0,
-+    }
-+    support_time_dependant = True
-+    supports_blackbox = True
-+    method = 'dop853'
-+
-+    def _prepare(self):
-+        """
-+        Initialize the solver
-+        """
-+        self._ode_solver = ode(self._mul_np_vec)
-+        self._ode_solver.set_integrator('dop853', **self.options)
-+        self.name = "scipy ode dop853"
-+
-+    def _mul_np_vec(self, t, vec):
-+        """
-+        Interface between scipy which use numpy and the driver, which use data.
-+        """
-+        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
-+        column_unstack_dense(state, self._size, inplace=True)
-+        out = self.system.matmul_data(t, state)
-+        column_stack_dense(out, inplace=True)
-+        return out.as_ndarray().ravel().view(np.float64)
-+
-+    def integrate(self, t, copy=True):
-+        if t != self._ode_solver.t:
-+            self._ode_solver.integrate(t)
-+        return self.get_state(copy)
-+
-+    def mcstep(self, t, copy=True):
-+        if self._ode_solver.t <= t:
-+            # Scipy's DOP853 does not have a step function.
-+            # It has a safe step length, but can be 0 if unknown.
-+            dt = self._ode_solver._integrator.work[6]
-+            if dt:
-+                t = min(self._ode_solver.t + dt, t)
-+            self._ode_solver.integrate(t)
-+        else:
-+            # While DOP853 support changing the direction of the integration,
-+            # it does not do so efficiently. We do it manually.
-+            self._ode_solver._integrator.work[6] *= -1
-+            self._ode_solver.integrate(t)
-+            self._ode_solver._integrator.work[6] *= -1
-+        return self.get_state(copy)
-+
-+    def get_state(self, copy=True):
-+        if not self._is_set:
-+            raise IntegratorException("The state is not initialted")
-+        self._check_failed_integration()
-+        t = self._ode_solver.t
-+        if self._mat_state:
-+            state = _data.column_unstack_dense(
-+                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
-+                                  copy=copy),
-+                self._size,
-+                inplace=True)
-+        else:
-+            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
-+                                      copy=copy)
-+        return t, state
-+
-+    def set_state(self, t, state0):
-+        self._is_set = True
-+        self._mat_state = state0.shape[1] > 1
-+        self._size = state0.shape[0]
-+        if self._mat_state:
-+            state0 = _data.column_stack(state0)
-+        self._ode_solver.set_initial_value(
-+            state0.to_array().ravel().view(np.float64),
-+            t
-+        )
-+
-+    def _check_failed_integration(self):
-+        if self._ode_solver.successful():
-+            return
-+        messages = {
-+            -1: 'input is not consistent',
-+            -2: 'larger nsteps is needed, Try to increase the nsteps '
-+                'parameter in the Options class.',
-+            -3: 'step size becomes too small. Try increasing tolerance',
-+            -4: 'problem is probably stiff (interrupted), try "bdf" '
-+                'method instead',
-+        }
-+        raise IntegratorException(
-+            messages[self._ode_solver._integrator.istate]
-+        )
-+
-+    @property
-+    def options(self):
-+        """
-+        Supported options by dop853 integrator:
-+
-+        atol : float, default=1e-8
-+            Absolute tolerance.
-+
-+        rtol : float, default=1e-6
-+            Relative tolerance.
-+
-+        nsteps : int, default=2500
-+            Max. number of internal steps/call.
-+
-+        first_step : float, default=0
-+            Size of initial step (0 = automatic).
-+
-+        max_step : float, default=0
-+            Maximum step size (0 = automatic)
-+
-+        ifactor, dfactor : float, default=6., 0.3
-+            Maximum factor to increase/decrease step size by in one step
-+
-+        beta : float, default=0
-+            Beta parameter for stabilised step size control.
-+
-+        See scipy.integrate.ode ode for more detail
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Integrator.options.fset(self, new_options)
-+
-+
-+class IntegratorScipylsoda(IntegratorScipyDop853):
-+    """
-+    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
-+    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
-+    'BDF' methods to solve both stiff and non-stiff systems.
-+
-+    Usable with ``method="lsoda"``
-+    """
-+    integrator_options = {
-+        'atol': 1e-8,
-+        'rtol': 1e-6,
-+        'nsteps': 2500,
-+        'max_order_ns': 12,
-+        'max_order_s': 5,
-+        'first_step': 0.0,
-+        'max_step': 0.0,
-+        'min_step': 0.0,
-+    }
-+    support_time_dependant = True
-+    supports_blackbox = True
-+    method = 'lsoda'
-+
-+    def _prepare(self):
-+        """
-+        Initialize the solver
-+        """
-+        self._ode_solver = ode(self._mul_np_vec)
-+        self._ode_solver.set_integrator('lsoda', **self.options)
-+        self.name = "scipy lsoda"
-+
-+    def _check_handle(self):
-+        """
-+        Do the check for concurrent use of the integrator and reset if used
-+        elsewhere.
-+        """
-+        integrator = self._ode_solver._integrator
-+        if integrator.initialized:
-+            if integrator.handle != integrator.__class__.active_global_handle:
-+                integrator.reset(len(self._ode_solver._y), False)
-+
-+    def integrate(self, t, copy=True):
-+        self._check_handle()
-+        return super().integrate(t, copy)
-+
-+    def set_state(self, t, state0):
-+        self._front = t
-+        super().set_state(t, state0)
-+        self._back = self.get_state()
-+
-+    def mcstep(self, t, copy=True):
-+        # This solver support dense output:
-+        # a range in which the state at any time can be computed with
-+        # minimal work. We keep track of the range with _back[0] and _front.
-+        self._check_handle()
-+        if self._ode_solver.t == t:
-+            # Exact same `t` as the last call, nothing to do.
-+            pass
-+        elif self._back[0] <= t <= self._front:
-+            # In the range, ask for the new state.
-+            self._backstep(t)
-+        elif self._front < t:
-+            # Advance the range.
-+            self._one_step(t)
-+        else:
-+            raise IntegratorException(
-+                f"`t`={t} is behind the integration limit: "
-+                f"{t} < {self._back[0]}."
-+            )
-+        return self.get_state(copy)
-+
-+    def _one_step(self, t):
-+        """
-+        Advance up to t by one internal solver step.
-+        Should be able to retreive the state at any time between the present
-+        time and the resulting time using `backstep`.
-+        """
-+        # Here we want to advance up to t doing maximum one step.
-+        # lsoda officially support step, but sometime it does more work than
-+        # needed, so we ask it to advance a fraction of the last step, where it
-+        # will advance one internal step of length allowed by the tolerance and
-+        # interpolate back to the asked time, effictively getting the single
-+        # integration step we want. The first step and abrupt changes in the
-+        # `rhs` can cause exceptions to this, but _backstep catch those cases.
-+        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
-+        t_ode = self._ode_solver.t
-+
-+        if t > self._front and t_ode >= self._front:
-+            # The state is at self._front, do a step
-+            self._back = self.get_state()
-+            self._ode_solver.integrate(min(self._front + safe_delta, t))
-+            self._front = self._ode_solver._integrator.rwork[12]
-+            # We asked for a fraction of a step, now complete it.
-+            self._ode_solver.integrate(min(self._front, t))
-+        elif t > self._front:
-+            # The state is at a time before t_front, advance to t_front
-+            self._ode_solver.integrate(self._front)
-+
-+    def _backstep(self, t):
-+        """
-+        Retreive the state at time t, with t smaller than present ODE time.
-+        The time t will always be between the last calls of `one_step`.
-+        return the pair t, state.
-+        """
-+        delta = self._ode_solver._integrator.rwork[11]
-+        if t == self._ode_solver.t:
-+            pass
-+        elif self._front - delta <= t:
-+            self._ode_solver.integrate(t)
-+        else:
-+            self.set_state(*self._back)
-+            self._ode_solver.integrate(t)
-+
-+    def _check_failed_integration(self):
-+        if self._ode_solver.successful():
-+            return
-+        messages = {
-+            -1: "Excess work done on this call."
-+                "Try to increase the nsteps parameter in the Options class.",
-+            -2: "Excess accuracy requested (tolerances too small).",
-+            -3: "Illegal input detected (internal error).",
-+            -4: "Repeated error test failures (internal error).",
-+            -5: "Repeated convergence failures "
-+                "(perhaps bad Jacobian or tolerances).",
-+            -6: "Error weight became zero during problem.",
-+            -7: "Internal workspace insufficient to finish (internal error)."
-+        }
-+        raise IntegratorException(
-+            messages[self._ode_solver._integrator.istate]
-+        )
-+
-+    @property
-+    def options(self):
-+        """
-+        Supported options by lsoda integrator:
-+
-+        atol : float, default=1e-8
-+            Absolute tolerance.
-+
-+        rtol : float, default=1e-6
-+            Relative tolerance.
-+
-+        nsteps : int, default=2500
-+            Max. number of internal steps/call.
-+
-+        max_order_ns : int, default=12
-+            Maximum order used in the nonstiff case (<= 12).
-+
-+        max_order_s : int, default=5
-+            Maximum order used in the stiff case (<= 5).
-+
-+        first_step : float, default=0
-+            Size of initial step (0 = automatic).
-+
-+        max_step : float, default=0
-+            Maximum step size (0 = automatic)
-+            When using pulses, change to half the thinest pulse otherwise it
-+            may be skipped.
-+
-+        min_step : float, default=0
-+            Minimum step size (0 = automatic)
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Integrator.options.fset(self, new_options)
-+
-+
-+Solver.add_integrator(IntegratorScipyBDF, 'bdf')
-+Solver.add_integrator(IntegratorScipyAdams, 'adams')
-+Solver.add_integrator(IntegratorScipyDop853, 'dop853')
-+Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
-diff --git a/qutip/solver/integrator/verner7efficient.py b/qutip/solver/integrator/verner7efficient.py
-index c49882a2..3bda6a91 100644
---- a/qutip/solver/integrator/verner7efficient.py
-+++ b/qutip/solver/integrator/verner7efficient.py
-@@ -1,333 +1,333 @@
--"""
--Provide a cython implimentation verner 'most-efficient'
--order 7 runge-Kutta method.
--See http://people.math.sfu.ca/~jverner/
--"""
--# Verner 7 Efficient
--# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
--__all__ = ["vern7_coeff"]
--import numpy as np
--order = 7
--rk_step = 10
--rk_extra_step = 16
--denseout_order = 7
--
--bh = np.zeros(rk_step, dtype=np.float64)
--a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
--b = np.zeros(rk_step, dtype=np.float64)
--c = np.zeros(rk_extra_step, dtype=np.float64)
--e = np.zeros(rk_step, dtype=np.float64)
--bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
--
--c[0] = 0.
--c[1] = .5000000000000000000000000000000000000000e-2
--c[2] = .1088888888888888888888888888888888888889
--c[3] = .1633333333333333333333333333333333333333
--c[4] = .4555000000000000000000000000000000000000
--c[5] = .6095094489978381317087004421486024949638
--c[6] = .8840000000000000000000000000000000000000
--c[7] = .9250000000000000000000000000000000000000
--c[8] = 1.
--c[9] = 1.
--
--a[1, 0] = .5000000000000000000000000000000000000000e-2
--
--a[2, 0] = -1.076790123456790123456790123456790123457
--a[2, 1] = 1.185679012345679012345679012345679012346
--
--a[3, 0] = .4083333333333333333333333333333333333333e-1
--a[3, 1] = 0.
--a[3, 2] = .1225000000000000000000000000000000000000
--
--a[4, 0] = .6389139236255726780508121615993336109954
--a[4, 1] = 0.
--a[4, 2] = -2.455672638223656809662640566430653894211
--a[4, 3] = 2.272258714598084131611828404831320283215
--
--a[5, 0] = -2.661577375018757131119259297861818119279
--a[5, 1] = 0.
--a[5, 2] = 10.80451388645613769565396655365532838482
--a[5, 3] = -8.353914657396199411968048547819291691541
--a[5, 4] = .8204875949566569791420417341743839209619
--
--a[6, 0] = 6.067741434696770992718360183877276714679
--a[6, 1] = 0.
--a[6, 2] = -24.71127363591108579734203485290746001803
--a[6, 3] = 20.42751793078889394045773111748346612697
--a[6, 4] = -1.906157978816647150624096784352757010879
--a[6, 5] = 1.006172249242068014790040335899474187268
--
--a[7, 0] = 12.05467007625320299509109452892778311648
--a[7, 1] = 0.
--a[7, 2] = -49.75478495046898932807257615331444758322
--a[7, 3] = 41.14288863860467663259698416710157354209
--a[7, 4] = -4.461760149974004185641911603484815375051
--a[7, 5] = 2.042334822239174959821717077708608543738
--a[7, 6] = -0.9834843665406107379530801693870224403537e-1
--
--a[8, 0] = 10.13814652288180787641845141981689030769
--a[8, 1] = 0.
--a[8, 2] = -42.64113603171750214622846006736635730625
--a[8, 3] = 35.76384003992257007135021178023160054034
--a[8, 4] = -4.348022840392907653340370296908245943710
--a[8, 5] = 2.009862268377035895441943593011827554771
--a[8, 6] = .3487490460338272405953822853053145879140
--a[8, 7] = -.2714390051048312842371587140910297407572
--
--a[9, 0] = -45.03007203429867712435322405073769635151
--a[9, 1] = 0.
--a[9, 2] = 187.3272437654588840752418206154201997384
--a[9, 3] = -154.0288236935018690596728621034510402582
--a[9, 4] = 18.56465306347536233859492332958439136765
--a[9, 5] = -7.141809679295078854925420496823551192821
--a[9, 6] = 1.308808578161378625114762706007696696508
--a[9, 7] = 0.
--a[9, 8] = 0.
--
--b[0] = .4715561848627222170431765108838175679569e-1
--b[1] = 0.
--b[2] = 0.
--b[3] = .2575056429843415189596436101037687580986
--b[4] = .2621665397741262047713863095764527711129
--b[5] = .1521609265673855740323133199165117535523
--b[6] = .4939969170032484246907175893227876844296
--b[7] = -.2943031171403250441557244744092703429139
--b[8] = .8131747232495109999734599440136761892478e-1
--b[9] = 0.
--
--bh[0] = .4460860660634117628731817597479197781432e-1
--bh[1] = 0.
--bh[2] = 0.
--bh[3] = .2671640378571372680509102260943837899738
--bh[4] = .2201018300177293019979715776650753096323
--bh[5] = .2188431703143156830983120833512893824578
--bh[6] = .2289871705411202883378173889763552365362
--bh[7] = 0.
--bh[8] = 0.
--bh[9] = .2029518466335628222767054793810430358554e-1
--
--for i in range(10):
--    e[i] = b[i] - bh[i]
--
--c[10] = 1
--
--a[10, 0] = .4715561848627222170431765108838175679569e-1
--a[10, 1] = 0.
--a[10, 2] = 0.
--a[10, 3] = .2575056429843415189596436101037687580986
--a[10, 4] = .2621665397741262047713863095764527711129
--a[10, 5] = .1521609265673855740323133199165117535523
--a[10, 6] = .4939969170032484246907175893227876844296
--a[10, 7] = -.2943031171403250441557244744092703429139
--a[10, 8] = .8131747232495109999734599440136761892478e-1
--a[10, 9] = 0.
--
--c[11] = 29/100
--
--a[11, 0] = .5232227691599689815470932256735029887614e-1
--a[11, 1] = 0.
--a[11, 2] = 0.
--a[11, 3] = .2249586182670571550244187743667190903405
--a[11, 4] = .1744370924877637539031751304611402542578e-1
--a[11, 5] = -.7669379876829393188009028209348812321417e-2
--a[11, 6] = .3435896044073284645684381456417912794447e-1
--a[11, 7] = -.4102097230093949839125144540100346681769e-1
--a[11, 8] = .2565113300520561655297104906598973655221e-1
--a[11, 9] = 0.
--a[11, 10] = -.1604434570000000000000000000000000000000e-1
--
--c[12] = 1/8
--
--a[12, 0] = .5305334125785908638834747243817578898946e-1
--a[12, 1] = 0.
--a[12, 2] = 0.
--a[12, 3] = .1219530101140188607092225622195251463666
--a[12, 4] = .1774684073760249704011573985936092552347e-1
--a[12, 5] = -.5928372667681494328907467430302313286925e-3
--a[12, 6] = .8381833970853750873624781948796072714855e-2
--a[12, 7] = -.1293369259698611956700998079778496462996e-1
--a[12, 8] = .9412056815253860804791356641605087829772e-2
--a[12, 9] = 0.
--a[12, 10] = -.5353253107275676032399320754008272222345e-2
--a[12, 11] = -.6666729992455811078380186481263955324311e-1
--
--c[13] = 1/4
--
--a[13, 0] = .3887903257436303686399931060834951327899e-1
--a[13, 1] = 0.
--a[13, 2] = 0.
--a[13, 3] = -.2440320330830131517910045090190069290791e-2
--a[13, 4] = -.1392891721467262281273220992320214734208e-2
--a[13, 5] = -.4744629155868013465038358934145339168472e-3
--a[13, 6] = .3920793241315951369383517310870803393356e-3
--a[13, 7] = -.4055473328512800136385880031750264996936e-3
--a[13, 8] = .1989709314771672628794304728258886009267e-3
--a[13, 9] = 0.
--a[13, 10] = -.1027819879317916884712606136811051029682e-3
--a[13, 11] = .3385661513870266715302548402957613704604e-1
--a[13, 12] = .1814893063199928004309543737509423302792
--
--c[14] = 53/100
--
--a[14, 0] = .5723681204690012909606837582140921695189e-1
--a[14, 1] = 0.
--a[14, 2] = 0.
--a[14, 3] = .2226594806676118099285816235023183680020
--a[14, 4] = .1234486420018689904911221497830317287757
--a[14, 5] = .4006332526666490875113688731927762275433e-1
--a[14, 6] = -.5269894848581452066926326838943832327366e-1
--a[14, 7] = .4765971214244522856887315416093212596338e-1
--a[14, 8] = -.2138895885042213036387863538386958914368e-1
--a[14, 9] = 0.
--a[14, 10] = .1519389106403640165459624646184297766866e-1
--a[14, 11] = .1206054671628965554251364472502413614358
--a[14, 12] = -.2277942301618737288237298052574548913451e-1
--a[14, 13] = 0.
--
--c[15] = 79/100
--
--a[15, 0] = .5137203880275681426595607279552927584506e-1
--a[15, 1] = 0.
--a[15, 2] = 0.
--a[15, 3] = .5414214473439405582401399378307410450482
--a[15, 4] = .3503998066921840081154745647747846804810
--a[15, 5] = .1419311226969218216861835872156617148040
--a[15, 6] = .1052737747842942254816302629823570359198
--a[15, 7] = -.3108184780587401700842726199589213259835e-1
--a[15, 8] = -.7401883149519145061791854716430279714483e-2
--a[15, 9] = 0.
--a[15, 10] = -.6377932504865363437569726480040013149706e-2
--a[15, 11] = -.1732549590836186403386348310205265959935
--a[15, 12] = -.1822815677762202619429607513861847306420
--a[15, 13] = 0.
--a[15, 14] = 0.
--
--bi[0, 0] = 1.
--bi[0, 1] = -8.413387198332767469319987751201351965810
--bi[0, 2] = 33.67550888449089654479469983556967202215
--bi[0, 3] = -70.80159089484886164618905961010838757357
--bi[0, 4] = 80.64695108301297872968868805293298389704
--bi[0, 5] = -47.19413969837521580145883430419406103536
--bi[0, 6] = 11.13381344253924186418881142808952641234
--
--bi[1, 0] = 0.
--bi[1, 1] = 0.
--bi[1, 2] = 0.
--bi[1, 3] = 0.
--bi[1, 4] = 0.
--bi[1, 5] = 0.
--bi[1, 6] = 0.
--
--bi[2, 0] = 0.
--bi[2, 1] = 0.
--bi[2, 2] = 0.
--bi[2, 3] = 0.
--bi[2, 4] = 0.
--bi[2, 5] = 0.
--bi[2, 6] = 0.
--
--bi[3, 0] = 0.
--bi[3, 1] = 8.754921980674397160629587282876763437696
--bi[3, 2] = -88.45968286997709426134300934922618655402
--bi[3, 3] = 346.9017638429916309499891288356321692825
--bi[3, 4] = -629.2580030059837046812187141184986252218
--bi[3, 5] = 529.6773755604192983874116479833480529304
--bi[3, 6] = -167.3588698651401860365089970240284051167
--
--bi[4, 0] = 0.
--bi[4, 1] = 8.913387586637921662996190126913331844214
--bi[4, 2] = -90.06081846893217794712014609702916991513
--bi[4, 3] = 353.1807459217057824951538014683541349020
--bi[4, 4] = -640.6476819744374433668701027882567716886
--bi[4, 5] = 539.2646279047155261551781390920363285084
--bi[4, 6] = -170.3880944299154827945664954924414008798
--
--bi[5, 0] = 0.
--bi[5, 1] = 5.173312029847800338889849068990984974299
--bi[5, 2] = -52.27111590005538823385270070373176751689
--bi[5, 3] = 204.9853867374073094711024260808085419491
--bi[5, 4] = -371.8306118563602890875634623992262437796
--bi[5, 5] = 312.9880934374529000210073972654145891826
--bi[5, 6] = -98.89290352172494693555119599233959305606
--
--bi[6, 0] = 0.
--bi[6, 1] = 16.79537744079695986364946329034055578253
--bi[6, 2] = -169.7004000005972744435739149730966805754
--bi[6, 3] = 665.4937727009246303131700313781960584913
--bi[6, 4] = -1207.163889233600728395392916633015853882
--bi[6, 5] = 1016.129151581854603280159105697386989470
--bi[6, 6] = -321.0600155723749421933210511704882816019
--
--bi[7, 0] = 0.
--bi[7, 1] = -10.00599753609866476866352971232058330270
--bi[7, 2] = 101.1005433052275068199636113246449312792
--bi[7, 3] = -396.4739151237843754958939772727577263768
--bi[7, 4] = 719.1787707014182914108130834128646525498
--bi[7, 5] = -605.3681033918824350795711030652978269725
--bi[7, 6] = 191.2743989279793520691961908384572824802
--
--bi[8, 0] = 0.
--bi[8, 1] = 2.764708833638599139713222853969606774131
--bi[8, 2] = -27.93460263739046178114640484830267988046
--bi[8, 3] = 109.5477918613789217803046856340175757800
--bi[8, 4] = -198.7128113064482116421691972646370773711
--bi[8, 5] = 167.2663357164031670694252647113936863857
--bi[8, 6] = -52.85010499525706346613022509203974406942
--
--bi[9, 0] = 0.
--bi[9, 1] = 0.
--bi[9, 2] = 0.
--bi[9, 3] = 0.
--bi[9, 4] = 0.
--bi[9, 5] = 0.
--bi[9, 6] = 0.
--
--bi[10, 0] = 0.
--bi[10, 1] = -2.169632028016350481156919876642428429100
--bi[10, 2] = 22.01669603756987625585768587320929912766
--bi[10, 3] = -86.90152427798948350846176288615482496306
--bi[10, 4] = 159.2238897386147443720253338471077193471
--bi[10, 5] = -135.9618306534587908363115231453760181702
--bi[10, 6] = 43.79240118328000419804718618785625308759
--
--bi[11, 0] = 0.
--bi[11, 1] = -4.890070188793803933769786966428026149549
--bi[11, 2] = 22.75407737425176120799532459991506803585
--bi[11, 3] = -30.78034218537730965082079824005797506535
--bi[11, 4] = -2.797194317207249021142015125037024035537
--bi[11, 5] = 31.36945663750840183161406140272783187147
--bi[11, 6] = -15.65592732038180043387678567111987465689
--
--bi[12, 0] = 0.
--bi[12, 1] = 10.86217092955196715517224349929627754387
--bi[12, 2] = -50.54297141782710697188187875653305700081
--bi[12, 3] = 68.37148040407511827604242008548181691494
--bi[12, 4] = 6.213326521632409162585500428935637861213
--bi[12, 5] = -69.68006323194158104163196358466588618336
--bi[12, 6] = 34.77605679450919341971367832748521086414
--
--bi[13, 0] = 0.
--bi[13, 1] = -11.37286691922922915922346687401389055763
--bi[13, 2] = 130.7905807824671644130452602841032046030
--bi[13, 3] = -488.6511367778560207543260583489312609826
--bi[13, 4] = 832.2148793276440873476229585070779183432
--bi[13, 5] = -664.7743368554426242883314487337054193624
--bi[13, 6] = 201.7928804424166224412127551654694479565
--
--bi[14, 0] = 0.
--bi[14, 1] = -5.919778732715006698693070786679427540601
--bi[14, 2] = 63.27679965889218829298274978013773800731
--bi[14, 3] = -265.4326820887379575820873554556433306580
--bi[14, 4] = 520.1009254140610824835871087519714692468
--bi[14, 5] = -467.4121095339020118993777963241667608460
--bi[14, 6] = 155.3868452824017054035883640343803117904
--
--bi[15, 0] = 0.
--bi[15, 1] = -10.49214619796182281022379415510181241136
--bi[15, 2] = 105.3553852518801101042787230303396283676
--bi[15, 3] = -409.4397501198893846479834816688367917005
--bi[15, 4] = 732.8314489076540326880337353277812147333
--bi[15, 5] = -606.3044574733512377981129469949015057785
--bi[15, 6] = 188.0495196316683024640077644607192667895
--
--vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
-+"""
-+Provide a cython implimentation verner 'most-efficient'
-+order 7 runge-Kutta method.
-+See http://people.math.sfu.ca/~jverner/
-+"""
-+# Verner 7 Efficient
-+# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
-+__all__ = ["vern7_coeff"]
-+import numpy as np
-+order = 7
-+rk_step = 10
-+rk_extra_step = 16
-+denseout_order = 7
-+
-+bh = np.zeros(rk_step, dtype=np.float64)
-+a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
-+b = np.zeros(rk_step, dtype=np.float64)
-+c = np.zeros(rk_extra_step, dtype=np.float64)
-+e = np.zeros(rk_step, dtype=np.float64)
-+bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
-+
-+c[0] = 0.
-+c[1] = .5000000000000000000000000000000000000000e-2
-+c[2] = .1088888888888888888888888888888888888889
-+c[3] = .1633333333333333333333333333333333333333
-+c[4] = .4555000000000000000000000000000000000000
-+c[5] = .6095094489978381317087004421486024949638
-+c[6] = .8840000000000000000000000000000000000000
-+c[7] = .9250000000000000000000000000000000000000
-+c[8] = 1.
-+c[9] = 1.
-+
-+a[1, 0] = .5000000000000000000000000000000000000000e-2
-+
-+a[2, 0] = -1.076790123456790123456790123456790123457
-+a[2, 1] = 1.185679012345679012345679012345679012346
-+
-+a[3, 0] = .4083333333333333333333333333333333333333e-1
-+a[3, 1] = 0.
-+a[3, 2] = .1225000000000000000000000000000000000000
-+
-+a[4, 0] = .6389139236255726780508121615993336109954
-+a[4, 1] = 0.
-+a[4, 2] = -2.455672638223656809662640566430653894211
-+a[4, 3] = 2.272258714598084131611828404831320283215
-+
-+a[5, 0] = -2.661577375018757131119259297861818119279
-+a[5, 1] = 0.
-+a[5, 2] = 10.80451388645613769565396655365532838482
-+a[5, 3] = -8.353914657396199411968048547819291691541
-+a[5, 4] = .8204875949566569791420417341743839209619
-+
-+a[6, 0] = 6.067741434696770992718360183877276714679
-+a[6, 1] = 0.
-+a[6, 2] = -24.71127363591108579734203485290746001803
-+a[6, 3] = 20.42751793078889394045773111748346612697
-+a[6, 4] = -1.906157978816647150624096784352757010879
-+a[6, 5] = 1.006172249242068014790040335899474187268
-+
-+a[7, 0] = 12.05467007625320299509109452892778311648
-+a[7, 1] = 0.
-+a[7, 2] = -49.75478495046898932807257615331444758322
-+a[7, 3] = 41.14288863860467663259698416710157354209
-+a[7, 4] = -4.461760149974004185641911603484815375051
-+a[7, 5] = 2.042334822239174959821717077708608543738
-+a[7, 6] = -0.9834843665406107379530801693870224403537e-1
-+
-+a[8, 0] = 10.13814652288180787641845141981689030769
-+a[8, 1] = 0.
-+a[8, 2] = -42.64113603171750214622846006736635730625
-+a[8, 3] = 35.76384003992257007135021178023160054034
-+a[8, 4] = -4.348022840392907653340370296908245943710
-+a[8, 5] = 2.009862268377035895441943593011827554771
-+a[8, 6] = .3487490460338272405953822853053145879140
-+a[8, 7] = -.2714390051048312842371587140910297407572
-+
-+a[9, 0] = -45.03007203429867712435322405073769635151
-+a[9, 1] = 0.
-+a[9, 2] = 187.3272437654588840752418206154201997384
-+a[9, 3] = -154.0288236935018690596728621034510402582
-+a[9, 4] = 18.56465306347536233859492332958439136765
-+a[9, 5] = -7.141809679295078854925420496823551192821
-+a[9, 6] = 1.308808578161378625114762706007696696508
-+a[9, 7] = 0.
-+a[9, 8] = 0.
-+
-+b[0] = .4715561848627222170431765108838175679569e-1
-+b[1] = 0.
-+b[2] = 0.
-+b[3] = .2575056429843415189596436101037687580986
-+b[4] = .2621665397741262047713863095764527711129
-+b[5] = .1521609265673855740323133199165117535523
-+b[6] = .4939969170032484246907175893227876844296
-+b[7] = -.2943031171403250441557244744092703429139
-+b[8] = .8131747232495109999734599440136761892478e-1
-+b[9] = 0.
-+
-+bh[0] = .4460860660634117628731817597479197781432e-1
-+bh[1] = 0.
-+bh[2] = 0.
-+bh[3] = .2671640378571372680509102260943837899738
-+bh[4] = .2201018300177293019979715776650753096323
-+bh[5] = .2188431703143156830983120833512893824578
-+bh[6] = .2289871705411202883378173889763552365362
-+bh[7] = 0.
-+bh[8] = 0.
-+bh[9] = .2029518466335628222767054793810430358554e-1
-+
-+for i in range(10):
-+    e[i] = b[i] - bh[i]
-+
-+c[10] = 1
-+
-+a[10, 0] = .4715561848627222170431765108838175679569e-1
-+a[10, 1] = 0.
-+a[10, 2] = 0.
-+a[10, 3] = .2575056429843415189596436101037687580986
-+a[10, 4] = .2621665397741262047713863095764527711129
-+a[10, 5] = .1521609265673855740323133199165117535523
-+a[10, 6] = .4939969170032484246907175893227876844296
-+a[10, 7] = -.2943031171403250441557244744092703429139
-+a[10, 8] = .8131747232495109999734599440136761892478e-1
-+a[10, 9] = 0.
-+
-+c[11] = 29/100
-+
-+a[11, 0] = .5232227691599689815470932256735029887614e-1
-+a[11, 1] = 0.
-+a[11, 2] = 0.
-+a[11, 3] = .2249586182670571550244187743667190903405
-+a[11, 4] = .1744370924877637539031751304611402542578e-1
-+a[11, 5] = -.7669379876829393188009028209348812321417e-2
-+a[11, 6] = .3435896044073284645684381456417912794447e-1
-+a[11, 7] = -.4102097230093949839125144540100346681769e-1
-+a[11, 8] = .2565113300520561655297104906598973655221e-1
-+a[11, 9] = 0.
-+a[11, 10] = -.1604434570000000000000000000000000000000e-1
-+
-+c[12] = 1/8
-+
-+a[12, 0] = .5305334125785908638834747243817578898946e-1
-+a[12, 1] = 0.
-+a[12, 2] = 0.
-+a[12, 3] = .1219530101140188607092225622195251463666
-+a[12, 4] = .1774684073760249704011573985936092552347e-1
-+a[12, 5] = -.5928372667681494328907467430302313286925e-3
-+a[12, 6] = .8381833970853750873624781948796072714855e-2
-+a[12, 7] = -.1293369259698611956700998079778496462996e-1
-+a[12, 8] = .9412056815253860804791356641605087829772e-2
-+a[12, 9] = 0.
-+a[12, 10] = -.5353253107275676032399320754008272222345e-2
-+a[12, 11] = -.6666729992455811078380186481263955324311e-1
-+
-+c[13] = 1/4
-+
-+a[13, 0] = .3887903257436303686399931060834951327899e-1
-+a[13, 1] = 0.
-+a[13, 2] = 0.
-+a[13, 3] = -.2440320330830131517910045090190069290791e-2
-+a[13, 4] = -.1392891721467262281273220992320214734208e-2
-+a[13, 5] = -.4744629155868013465038358934145339168472e-3
-+a[13, 6] = .3920793241315951369383517310870803393356e-3
-+a[13, 7] = -.4055473328512800136385880031750264996936e-3
-+a[13, 8] = .1989709314771672628794304728258886009267e-3
-+a[13, 9] = 0.
-+a[13, 10] = -.1027819879317916884712606136811051029682e-3
-+a[13, 11] = .3385661513870266715302548402957613704604e-1
-+a[13, 12] = .1814893063199928004309543737509423302792
-+
-+c[14] = 53/100
-+
-+a[14, 0] = .5723681204690012909606837582140921695189e-1
-+a[14, 1] = 0.
-+a[14, 2] = 0.
-+a[14, 3] = .2226594806676118099285816235023183680020
-+a[14, 4] = .1234486420018689904911221497830317287757
-+a[14, 5] = .4006332526666490875113688731927762275433e-1
-+a[14, 6] = -.5269894848581452066926326838943832327366e-1
-+a[14, 7] = .4765971214244522856887315416093212596338e-1
-+a[14, 8] = -.2138895885042213036387863538386958914368e-1
-+a[14, 9] = 0.
-+a[14, 10] = .1519389106403640165459624646184297766866e-1
-+a[14, 11] = .1206054671628965554251364472502413614358
-+a[14, 12] = -.2277942301618737288237298052574548913451e-1
-+a[14, 13] = 0.
-+
-+c[15] = 79/100
-+
-+a[15, 0] = .5137203880275681426595607279552927584506e-1
-+a[15, 1] = 0.
-+a[15, 2] = 0.
-+a[15, 3] = .5414214473439405582401399378307410450482
-+a[15, 4] = .3503998066921840081154745647747846804810
-+a[15, 5] = .1419311226969218216861835872156617148040
-+a[15, 6] = .1052737747842942254816302629823570359198
-+a[15, 7] = -.3108184780587401700842726199589213259835e-1
-+a[15, 8] = -.7401883149519145061791854716430279714483e-2
-+a[15, 9] = 0.
-+a[15, 10] = -.6377932504865363437569726480040013149706e-2
-+a[15, 11] = -.1732549590836186403386348310205265959935
-+a[15, 12] = -.1822815677762202619429607513861847306420
-+a[15, 13] = 0.
-+a[15, 14] = 0.
-+
-+bi[0, 0] = 1.
-+bi[0, 1] = -8.413387198332767469319987751201351965810
-+bi[0, 2] = 33.67550888449089654479469983556967202215
-+bi[0, 3] = -70.80159089484886164618905961010838757357
-+bi[0, 4] = 80.64695108301297872968868805293298389704
-+bi[0, 5] = -47.19413969837521580145883430419406103536
-+bi[0, 6] = 11.13381344253924186418881142808952641234
-+
-+bi[1, 0] = 0.
-+bi[1, 1] = 0.
-+bi[1, 2] = 0.
-+bi[1, 3] = 0.
-+bi[1, 4] = 0.
-+bi[1, 5] = 0.
-+bi[1, 6] = 0.
-+
-+bi[2, 0] = 0.
-+bi[2, 1] = 0.
-+bi[2, 2] = 0.
-+bi[2, 3] = 0.
-+bi[2, 4] = 0.
-+bi[2, 5] = 0.
-+bi[2, 6] = 0.
-+
-+bi[3, 0] = 0.
-+bi[3, 1] = 8.754921980674397160629587282876763437696
-+bi[3, 2] = -88.45968286997709426134300934922618655402
-+bi[3, 3] = 346.9017638429916309499891288356321692825
-+bi[3, 4] = -629.2580030059837046812187141184986252218
-+bi[3, 5] = 529.6773755604192983874116479833480529304
-+bi[3, 6] = -167.3588698651401860365089970240284051167
-+
-+bi[4, 0] = 0.
-+bi[4, 1] = 8.913387586637921662996190126913331844214
-+bi[4, 2] = -90.06081846893217794712014609702916991513
-+bi[4, 3] = 353.1807459217057824951538014683541349020
-+bi[4, 4] = -640.6476819744374433668701027882567716886
-+bi[4, 5] = 539.2646279047155261551781390920363285084
-+bi[4, 6] = -170.3880944299154827945664954924414008798
-+
-+bi[5, 0] = 0.
-+bi[5, 1] = 5.173312029847800338889849068990984974299
-+bi[5, 2] = -52.27111590005538823385270070373176751689
-+bi[5, 3] = 204.9853867374073094711024260808085419491
-+bi[5, 4] = -371.8306118563602890875634623992262437796
-+bi[5, 5] = 312.9880934374529000210073972654145891826
-+bi[5, 6] = -98.89290352172494693555119599233959305606
-+
-+bi[6, 0] = 0.
-+bi[6, 1] = 16.79537744079695986364946329034055578253
-+bi[6, 2] = -169.7004000005972744435739149730966805754
-+bi[6, 3] = 665.4937727009246303131700313781960584913
-+bi[6, 4] = -1207.163889233600728395392916633015853882
-+bi[6, 5] = 1016.129151581854603280159105697386989470
-+bi[6, 6] = -321.0600155723749421933210511704882816019
-+
-+bi[7, 0] = 0.
-+bi[7, 1] = -10.00599753609866476866352971232058330270
-+bi[7, 2] = 101.1005433052275068199636113246449312792
-+bi[7, 3] = -396.4739151237843754958939772727577263768
-+bi[7, 4] = 719.1787707014182914108130834128646525498
-+bi[7, 5] = -605.3681033918824350795711030652978269725
-+bi[7, 6] = 191.2743989279793520691961908384572824802
-+
-+bi[8, 0] = 0.
-+bi[8, 1] = 2.764708833638599139713222853969606774131
-+bi[8, 2] = -27.93460263739046178114640484830267988046
-+bi[8, 3] = 109.5477918613789217803046856340175757800
-+bi[8, 4] = -198.7128113064482116421691972646370773711
-+bi[8, 5] = 167.2663357164031670694252647113936863857
-+bi[8, 6] = -52.85010499525706346613022509203974406942
-+
-+bi[9, 0] = 0.
-+bi[9, 1] = 0.
-+bi[9, 2] = 0.
-+bi[9, 3] = 0.
-+bi[9, 4] = 0.
-+bi[9, 5] = 0.
-+bi[9, 6] = 0.
-+
-+bi[10, 0] = 0.
-+bi[10, 1] = -2.169632028016350481156919876642428429100
-+bi[10, 2] = 22.01669603756987625585768587320929912766
-+bi[10, 3] = -86.90152427798948350846176288615482496306
-+bi[10, 4] = 159.2238897386147443720253338471077193471
-+bi[10, 5] = -135.9618306534587908363115231453760181702
-+bi[10, 6] = 43.79240118328000419804718618785625308759
-+
-+bi[11, 0] = 0.
-+bi[11, 1] = -4.890070188793803933769786966428026149549
-+bi[11, 2] = 22.75407737425176120799532459991506803585
-+bi[11, 3] = -30.78034218537730965082079824005797506535
-+bi[11, 4] = -2.797194317207249021142015125037024035537
-+bi[11, 5] = 31.36945663750840183161406140272783187147
-+bi[11, 6] = -15.65592732038180043387678567111987465689
-+
-+bi[12, 0] = 0.
-+bi[12, 1] = 10.86217092955196715517224349929627754387
-+bi[12, 2] = -50.54297141782710697188187875653305700081
-+bi[12, 3] = 68.37148040407511827604242008548181691494
-+bi[12, 4] = 6.213326521632409162585500428935637861213
-+bi[12, 5] = -69.68006323194158104163196358466588618336
-+bi[12, 6] = 34.77605679450919341971367832748521086414
-+
-+bi[13, 0] = 0.
-+bi[13, 1] = -11.37286691922922915922346687401389055763
-+bi[13, 2] = 130.7905807824671644130452602841032046030
-+bi[13, 3] = -488.6511367778560207543260583489312609826
-+bi[13, 4] = 832.2148793276440873476229585070779183432
-+bi[13, 5] = -664.7743368554426242883314487337054193624
-+bi[13, 6] = 201.7928804424166224412127551654694479565
-+
-+bi[14, 0] = 0.
-+bi[14, 1] = -5.919778732715006698693070786679427540601
-+bi[14, 2] = 63.27679965889218829298274978013773800731
-+bi[14, 3] = -265.4326820887379575820873554556433306580
-+bi[14, 4] = 520.1009254140610824835871087519714692468
-+bi[14, 5] = -467.4121095339020118993777963241667608460
-+bi[14, 6] = 155.3868452824017054035883640343803117904
-+
-+bi[15, 0] = 0.
-+bi[15, 1] = -10.49214619796182281022379415510181241136
-+bi[15, 2] = 105.3553852518801101042787230303396283676
-+bi[15, 3] = -409.4397501198893846479834816688367917005
-+bi[15, 4] = 732.8314489076540326880337353277812147333
-+bi[15, 5] = -606.3044574733512377981129469949015057785
-+bi[15, 6] = 188.0495196316683024640077644607192667895
-+
-+vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
-diff --git a/qutip/solver/integrator/verner9efficient.py b/qutip/solver/integrator/verner9efficient.py
-index 02b1d926..aa331a91 100644
---- a/qutip/solver/integrator/verner9efficient.py
-+++ b/qutip/solver/integrator/verner9efficient.py
-@@ -1,706 +1,706 @@
--"""
--Provide a cython implimentation verner 'most-efficient'
--order 9 runge-Kutta method.
--See http://people.math.sfu.ca/~jverner/
--"""
--# Verner 9 Efficient
--# http://people.math.sfu.ca/~jverner/
--
--__all__ = ["vern9_coeff"]
--import numpy as np
--order = 9
--rk_step = 16
--rk_extra_step = 26
--denseout_order = 9
--
--bh = np.zeros(rk_step, dtype=np.float64)
--a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
--b = np.zeros(rk_step, dtype=np.float64)
--c = np.zeros(rk_extra_step, dtype=np.float64)
--e = np.zeros(rk_step, dtype=np.float64)
--bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
--
--c[0] = 0.
--c[1] = .3462e-1
--c[2] = .9702435063878044594828361677100617517633e-1
--c[3] = .1455365259581706689224254251565092627645
--c[4] = .561
--c[5] = .2290079115904850126662751771814700052182
--c[6] = .5449920884095149873337248228185299947818
--c[7] = .645
--c[8] = .4837500000000000000000000000000000000000
--c[9] = .6757e-1
--c[10] = .2500
--c[11] = .6590650618730998549405331618649220295334
--c[12] = .8206
--c[13] = .9012
--c[14] = 1.
--c[15] = 1.
--
--a[1, 0] = .3462e-1
--
--a[2, 0] = -.389335438857287327017042687229284478532e-1
--a[2, 1] = .1359578945245091786499878854939346230295
--
--a[3, 0] = .3638413148954266723060635628912731569111e-1
--a[3, 1] = 0.
--a[3, 2] = .1091523944686280016918190688673819470733
--
--a[4, 0] = 2.025763914393969636805657604282571047511
--a[4, 1] = 0.
--a[4, 2] = -7.638023836496292020387602153091964592952
--a[4, 3] = 6.173259922102322383581944548809393545442
--
--a[5, 0] = .5112275589406060872792270881648288397197e-1
--a[5, 1] = 0.
--a[5, 2] = 0.
--a[5, 3] = .1770823794555021537929910813839068684087
--a[5, 4] = .80277624092225014536138698108025283759e-3
--
--a[6, 0] = .1316006357975216279279871693164256985334
--a[6, 1] = 0.
--a[6, 2] = 0.
--a[6, 3] = -.2957276252669636417685183174672273730699
--a[6, 4] = .878137803564295237421124704053886667082e-1
--a[6, 5] = .6213052975225274774321435005639430026100
--
--a[7, 0] = .7166666666666666666666666666666666666667e-1
--a[7, 1] = 0.
--a[7, 2] = 0.
--a[7, 3] = 0.
--a[7, 4] = 0.
--a[7, 5] = .3305533578915319409260346730051472207728
--a[7, 6] = .2427799754418013924072986603281861125606
--
--a[8, 0] = .7180664062500000000000000000000000000000e-1
--a[8, 1] = 0.
--a[8, 2] = 0.
--a[8, 3] = 0.
--a[8, 4] = 0.
--a[8, 5] = .3294380283228177160744825466257672816401
--a[8, 6] = .1165190029271822839255174533742327183599
--a[8, 7] = -.3401367187500000000000000000000000000000e-1
--
--a[9, 0] = .4836757646340646986611287718844085773549e-1
--a[9, 1] = 0.
--a[9, 2] = 0.
--a[9, 3] = 0.
--a[9, 4] = 0.
--a[9, 5] = .3928989925676163974333190042057047002852e-1
--a[9, 6] = .1054740945890344608263649267140088017604
--a[9, 7] = -.2143865284648312665982642293830533996214e-1
--a[9, 8] = -.1041229174627194437759832813847147895623
--
--a[10, 0] = -.2664561487201478635337289243849737340534e-1
--a[10, 1] = 0.
--a[10, 2] = 0.
--a[10, 3] = 0.
--a[10, 4] = 0.
--a[10, 5] = .3333333333333333333333333333333333333333e-1
--a[10, 6] = -.1631072244872467239162704487554706387141
--a[10, 7] = .3396081684127761199487954930015522928244e-1
--a[10, 8] = .1572319413814626097110769806810024118077
--a[10, 9] = .2152267478031879552303534778794770376960
--
--a[11, 0] = .3689009248708622334786359863227633989718e-1
--a[11, 1] = 0.
--a[11, 2] = 0.
--a[11, 3] = 0.
--a[11, 4] = 0.
--a[11, 5] = -.1465181576725542928653609891758501156785
--a[11, 6] = .2242577768172024345345469822625833796001
--a[11, 7] = .2294405717066072637090897902753790803034e-1
--a[11, 8] = -.35850052905728761357394424889330334334e-2
--a[11, 9] = .8669223316444385506869203619044453906053e-1
--a[11, 10] = .4383840651968337846196219974168630120572
--
--a[12, 0] = -.4866012215113340846662212357570395295088
--a[12, 1] = 0.
--a[12, 2] = 0.
--a[12, 3] = 0.
--a[12, 4] = 0.
--a[12, 5] = -6.304602650282852990657772792012007122988
--a[12, 6] = -.281245618289472564778284183790118418111
--a[12, 7] = -2.679019236219849057687906597489223155566
--a[12, 8] = .518815663924157511565311164615012522024
--a[12, 9] = 1.365353187603341710683633635235238678626
--a[12, 10] = 5.885091088503946585721274891680604830712
--a[12, 11] = 2.802808786272062889819965117517532194812
--
--a[13, 0] = .4185367457753471441471025246471931649633
--a[13, 1] = 0.
--a[13, 2] = 0.
--a[13, 3] = 0.
--a[13, 4] = 0.
--a[13, 5] = 6.724547581906459363100870806514855026676
--a[13, 6] = -.425444280164611790606983409697113064616
--a[13, 7] = 3.343279153001265577811816947557982637749
--a[13, 8] = .617081663117537759528421117507709784737
--a[13, 9] = -.929966123939932833937749523988800852013
--a[13, 10] = -6.099948804751010722472962837945508844846
--a[13, 11] = -3.002206187889399044804158084895173690015
--a[13, 12] = .2553202529443445472336424602988558373637
--
--a[14, 0] = -.779374086122884664644623040843840506343
--a[14, 1] = 0.
--a[14, 2] = 0.
--a[14, 3] = 0.
--a[14, 4] = 0.
--a[14, 5] = -13.93734253810777678786523664804936051203
--a[14, 6] = 1.252048853379357320949735183924200895136
--a[14, 7] = -14.69150040801686878191527989293072091588
--a[14, 8] = -.494705058533141685655191992136962873577
--a[14, 9] = 2.242974909146236657906984549543692874755
--a[14, 10] = 13.36789380382864375813864978592679139881
--a[14, 11] = 14.39665048665068644512236935340272139005
--a[14, 12] = -.7975813331776800379127866056663258667437
--a[14, 13] = .4409353709534277758753793068298041158235
--
--a[15, 0] = 2.058051337466886442151242368989994043993
--a[15, 1] = 0.
--a[15, 2] = 0.
--a[15, 3] = 0.
--a[15, 4] = 0.
--a[15, 5] = 22.35793772796803295519317565842520212899
--a[15, 6] = .90949810997556332745009198137971890783
--a[15, 7] = 35.89110098240264104710550686568482456493
--a[15, 8] = -3.442515027624453437985000403608480262211
--a[15, 9] = -4.865481358036368826566013387928704014496
--a[15, 10] = -18.90980381354342625688427480879773032857
--a[15, 11] = -34.26354448030451782929251177395134170515
--a[15, 12] = 1.264756521695642578827783499806516664686
--a[15, 13] = 0.
--a[15, 14] = 0.
--
--b[0] = .1461197685842315252051541915018784713459e-1
--b[1] = 0.
--b[2] = 0.
--b[3] = 0.
--b[4] = 0.
--b[5] = 0.
--b[6] = 0.
--b[7] = -.3915211862331339089410228267288242030810
--b[8] = .2310932500289506415909675644868993669908
--b[9] = .1274766769992852382560589467488989175618
--b[10] = .2246434176204157731566981937082069688984
--b[11] = .5684352689748512932705226972873692126743
--b[12] = .5825871557215827200814768021863420902155e-1
--b[13] = .1364317403482215641609022744494239843327
--b[14] = .3057013983082797397721005067920369646664e-1
--b[15] = 0.
--
--bh[0] = .1996996514886773085518508418098868756464e-1
--bh[1] = 0.
--bh[2] = 0.
--bh[3] = 0.
--bh[4] = 0.
--bh[5] = 0.
--bh[6] = 0.
--bh[7] = 2.191499304949330054530747099310837524864
--bh[8] = .8857071848208438030833722031786358862953e-1
--bh[9] = .1140560234865965622484956605091432032674
--bh[10] = .2533163805345107065564577734569651977347
--bh[11] = -2.056564386240941011158999594595981300493
--bh[12] = .3408096799013119935160094894224543812830
--bh[13] = 0.
--bh[14] = 0.
--bh[15] = .4834231373823958314376726739772871714902e-1
--
--for i in range(16):
--    e[i] = b[i] - bh[i]
--
--c[16] = 1.0
--
--a[16, 0] = .1461197685842315252051541915018784713459e-1
--a[16, 1] = 0.
--a[16, 2] = 0.
--a[16, 3] = 0.
--a[16, 4] = 0.
--a[16, 5] = 0.
--a[16, 6] = 0.
--a[16, 7] = -.3915211862331339089410228267288242030810
--a[16, 8] = .2310932500289506415909675644868993669908
--a[16, 9] = .1274766769992852382560589467488989175618
--a[16, 10] = .2246434176204157731566981937082069688984
--a[16, 11] = .5684352689748512932705226972873692126743
--a[16, 12] = .5825871557215827200814768021863420902155e-1
--a[16, 13] = .1364317403482215641609022744494239843327
--a[16, 14] = .3057013983082797397721005067920369646664e-1
--a[16, 15] = 0.
--
--c[17] = .7404185470631561083004100761798676215811
--
--a[17, 0] = .1549973668189559302279946863304789372788e-1
--a[17, 1] = 0.
--a[17, 2] = 0.
--a[17, 3] = 0.
--a[17, 4] = 0.
--a[17, 5] = 0.
--a[17, 6] = 0.
--a[17, 7] = .3355153219059635054403439303177105512242
--a[17, 8] = .2003613944191860651552622660712101217322
--a[17, 9] = .1252060659283549312946162355194540994211
--a[17, 10] = .2298676393184206750544046308957155868736
--a[17, 11] = -.2020250653476181447824906889122391003637
--a[17, 12] = .5917103230665456601422111997583025339897e-1
--a[17, 13] = -.2651834783047638681693835956996437528251e-1
--a[17, 14] = -.2384094602130971415278110567256446033405e-1
--a[17, 15] = 0.
--a[17, 16] = .2718171570208501807097257892166705118335e-1
--
--c[18] = .888
--
--a[18, 0] = .1302453943114338366054520296881099431474e-1
--a[18, 1] = 0.
--a[18, 2] = 0.
--a[18, 3] = 0.
--a[18, 4] = 0.
--a[18, 5] = 0.
--a[18, 6] = 0.
--a[18, 7] = -.7452850902413112085299330666038981625179
--a[18, 8] = .2643867896429300961465132150322749722129
--a[18, 9] = .1313961758372753932588328082078842388890
--a[18, 10] = .2167253815122927263092467187957410643315
--a[18, 11] = .8734117564076052559016338094938888451419
--a[18, 12] = .1185905643935776688228545787724340848142e-1
--a[18, 13] = .5876002941689550612992712203494447529933e-1
--a[18, 14] = .3266518630202087866399279690939423159022e-2
--a[18, 15] = 0.
--a[18, 16] = -.8959308648417929824525368306101792182274e-2
--a[18, 17] = .6941415157202692219907482080827253287034e-1
--
--c[19] = .696
--
--a[19, 0] = .1397089996925942721283716334050740168797e-1
--a[19, 1] = 0.
--a[19, 2] = 0.
--a[19, 3] = 0.
--a[19, 4] = 0.
--a[19, 5] = 0.
--a[19, 6] = 0.
--a[19, 7] = -.4665765335957674596054673402956853940520
--a[19, 8] = .2416372787216257077935214889875485248580
--a[19, 9] = .1290363341345674735721677437066933999929
--a[19, 10] = .2216700671735105311080225734522323922813
--a[19, 11] = .6257275123364644931771253383573999863003
--a[19, 12] = .4355312415679284117869124964829805160429e-1
--a[19, 13] = .1011962491667290833450024852274278874501
--a[19, 14] = .1808582254679721049279369742685497400353e-1
--a[19, 15] = 0.
--a[19, 16] = -.2079875587689169691156509689282083267654e-1
--a[19, 17] = -.9022232517086218976198252891464664868640e-1
--a[19, 18] = -.1212796735622254216011467740438097427634
--
--c[20] = .487
--
--a[20, 0] = .1604638888318112738641232352800290501904e-1
--a[20, 1] = 0.
--a[20, 2] = 0.
--a[20, 3] = 0.
--a[20, 4] = 0.
--a[20, 5] = 0.
--a[20, 6] = 0.
--a[20, 7] = .9517712399458336651642257453589397190702e-1
--a[20, 8] = .1359187264655317806136927180199100622471
--a[20, 9] = .1237765280959854006935081364365637515893
--a[20, 10] = .2335656264102966047058755123098072346246
--a[20, 11] = -.9051508172625873314662090873741762206189e-1
--a[20, 12] = -.2537574270006131028513276914038326155331e-1
--a[20, 13] = -.1359631696887162048002744757083947500478
--a[20, 14] = -.4679214284145113075088049469061349990847e-1
--a[20, 15] = 0.
--a[20, 16] = .5177958859391748239949773879090325427473e-1
--a[20, 17] = .9672595677476773313884172931875718705561e-1
--a[20, 18] = .1477312690340742769720989417101989769314
--a[20, 19] = -.1150750712958503934434410263732282100773
--c[21] = .25e-1
--
--a[21, 0] = .1802918623893620731908165792176564180038e-1
--a[21, 1] = 0.
--a[21, 2] = 0.
--a[21, 3] = 0.
--a[21, 4] = 0.
--a[21, 5] = 0.
--a[21, 6] = 0.
--a[21, 7] = .6983601042028873702545973390560096201728e-1
--a[21, 8] = -.2541247660791663512384395986842781657182e-1
--a[21, 9] = .8487827035463274491721441398893680307535e-2
--a[21, 10] = -.2427525516089801645451101966852425715128e-2
--a[21, 11] = -.1047839752893819879012607694745789515746
--a[21, 12] = -.1473147795248041942353840372690095884761e-1
--a[21, 13] = -.3916338390816177165706892282751065537530e-1
--a[21, 14] = -.1005657343293959419073236542225421561652e-1
--a[21, 15] = 0.
--a[21, 16] = .1102510392204834322538452331445716455061e-1
--a[21, 17] = .5092830749095398308703438556315975226108e-2
--a[21, 18] = .4759715599420644505591133410826632557391e-1
--a[21, 19] = .3386307003288382751110965442296681690349e-1
--a[21, 20] = .2764422831404797700452373965825845732168e-1
--
--c[22] = .15
--
--a[22, 0] = .1677431640522778042988664067637191163626e-1
--a[22, 1] = 0.
--a[22, 2] = 0.
--a[22, 3] = 0.
--a[22, 4] = 0.
--a[22, 5] = 0.
--a[22, 6] = 0.
--a[22, 7] = .6220437408820475326702539861577894278533
--a[22, 8] = -.2060859809768841878234097076241307428139
--a[22, 9] = .1156394989766058889629372195583391792474
--a[22, 10] = .2664101793378358946544219293685167025971e-1
--a[22, 11] = -.9376810793418770527505892794460093668860
--a[22, 12] = -.1367806466702160302637074581619101741312
--a[22, 13] = -.3678480995268296672182605288991379118419
--a[22, 14] = -.9547871314402478902820445838193201497337e-1
--a[22, 15] = 0.
--a[22, 16] = .1013492018422369748729008873270013785313
--a[22, 17] = -.8911323084568593396468400926074881389560e-1
--a[22, 18] = .4664140988974760478895528270623735057521
--a[22, 19] = .4502736292354579812232681662308722738519
--a[22, 20] = .1838522463326818655346135218242696774099
--a[22, 21] = 0.
--
--c[23] = .32
--
--a[23, 0] = .1071149731491444187554380927165768658192e-1
--a[23, 1] = 0.
--a[23, 2] = 0.
--a[23, 3] = 0.
--a[23, 4] = 0.
--a[23, 5] = 0.
--a[23, 6] = 0.
--a[23, 7] = -.7094336118221108191937165464264324417735e-1
--a[23, 8] = .1002164900340091596740582334112699697590
--a[23, 9] = .1383453980468025108839271214703390659581
--a[23, 10] = .1796330633578163411338104055485109917477
--a[23, 11] = .9048246545576180974879274948815422276563e-1
--a[23, 12] = -.5460662294523338383345981122023862069115e-2
--a[23, 13] = -.3000457905119619782973021046143166498567e-1
--a[23, 14] = -.1145192026962799093665613252151017277867e-1
--a[23, 15] = 0.
--a[23, 16] = .1003394686109385076849515422360600302176e-1
--a[23, 17] = -.9506485282809046129031027932806241113157e-1
--a[23, 18] = .4853358804093591445756711642658478691640e-1
--a[23, 19] = .8013325919783924638483373011297347396327e-1
--a[23, 20] = -.1251643326835242045676140618774248455713
--a[23, 21] = 0.
--a[23, 22] = 0.
--
--c[24] = .78
--
--a[24, 0] = .1410172088869221367153586187761994182069e-1
--a[24, 1] = 0.
--a[24, 2] = 0.
--a[24, 3] = 0.
--a[24, 4] = 0.
--a[24, 5] = 0.
--a[24, 6] = 0.
--a[24, 7] = -.3713379753704491105936205420001801316029
--a[24, 8] = .2231265548117180273161442520179150684520
--a[24, 9] = .1287005345918120122888629169443916280865
--a[24, 10] = .2224600659675494761192249831098918110654
--a[24, 11] = .5382853042550701952740528638168708946100
--a[24, 12] = .5417202616988763101781128062036252796548e-1
--a[24, 13] = .1256968791308743925752109039299467082975
--a[24, 14] = .2784492789002054061504430663197543089132e-1
--a[24, 15] = 0.
--a[24, 16] = -.3077409246205059733390460511525401688205e-1
--a[24, 17] = .8569805293689777608077303071761466118035e-2
--a[24, 18] = -.1535174690587044615794997685221990516897
--a[24, 19] = -.2179957030548196497189489878038029238243e-1
--a[24, 20] = .1447128819737186799295514239727801525027e-1
--a[24, 21] = 0.
--a[24, 22] = 0.
--a[24, 23] = 0.
--
--c[25] = .96
--
--a[25, 0] = .1424600411735646609296566581447532773183e-1
--a[25, 1] = 0.
--a[25, 2] = 0.
--a[25, 3] = 0.
--a[25, 4] = 0.
--a[25, 5] = 0.
--a[25, 6] = 0.
--a[25, 7] = -.3767107393295407091303982522049390741260
--a[25, 8] = .2252399780730421480874737297000189000070
--a[25, 9] = .1283603076292529988314451246143633426068
--a[25, 10] = .2230238705261692544876826347415151339678
--a[25, 11] = .5463127827750747224899202176094949607118
--a[25, 12] = .5526190791375779994553849469706124289752e-1
--a[25, 13] = .1285613508749982456581494397108686240388
--a[25, 14] = .2857250681296406482698934635829147899039e-1
--a[25, 15] = 0.
--a[25, 16] = -.2398761886357108720930416967644499057175e-1
--a[25, 17] = .5556224458910509454379297181908734648749e-1
--a[25, 18] = -.1740675650762838674257930398070760254668e-1
--a[25, 19] = -.3815462365996979065575121886854199471011e-1
--a[25, 20] = .1111878504898917877407531966545730451506e-1
--a[25, 21] = 0.
--a[25, 22] = 0.
--a[25, 23] = 0.
--a[25, 24] = 0.
--
--bi[0, 0] = 1.
--bi[0, 1] = -28.33048870061739823290767301658881994700
--bi[0, 2] = 257.6535452078577977252092979905248156497
--bi[0, 3] = -1152.154455743457311528752964691951881858
--bi[0, 4] = 2909.390878345408890936564599116550031880
--bi[0, 5] = -4355.005172868188498048946108887283528629
--bi[0, 6] = 3834.083497036262189455855371796461857871
--bi[0, 7] = -1835.419052683407081215583427992189311730
--bi[0, 8] = 368.7958613829998340610814211036270246107
--
--bi[1, 0] = 0.
--bi[1, 1] = 0.
--bi[1, 2] = 0.
--bi[1, 3] = 0.
--bi[1, 4] = 0.
--bi[1, 5] = 0.
--bi[1, 6] = 0.
--bi[1, 7] = 0.
--bi[1, 8] = 0.
--
--bi[2, 0] = 0.
--bi[2, 1] = 0.
--bi[2, 2] = 0.
--bi[2, 3] = 0.
--bi[2, 4] = 0.
--bi[2, 5] = 0.
--bi[2, 6] = 0.
--bi[2, 7] = 0.
--bi[2, 8] = 0.
--
--bi[3, 0] = 0.
--bi[3, 1] = 0.
--bi[3, 2] = 0.
--bi[3, 3] = 0.
--bi[3, 4] = 0.
--bi[3, 5] = 0.
--bi[3, 6] = 0.
--bi[3, 7] = 0.
--bi[3, 8] = 0.
--
--bi[4, 0] = 0.
--bi[4, 1] = 0.
--bi[4, 2] = 0.
--bi[4, 3] = 0.
--bi[4, 4] = 0.
--bi[4, 5] = 0.
--bi[4, 6] = 0.
--bi[4, 7] = 0.
--bi[4, 8] = 0.
--
--bi[5, 0] = 0.
--bi[5, 1] = 0.
--bi[5, 2] = 0.
--bi[5, 3] = 0.
--bi[5, 4] = 0.
--bi[5, 5] = 0.
--bi[5, 6] = 0.
--bi[5, 7] = 0.
--bi[5, 8] = 0.
--
--bi[6, 0] = 0.
--bi[6, 1] = 0.
--bi[6, 2] = 0.
--bi[6, 3] = 0.
--bi[6, 4] = 0.
--bi[6, 5] = 0.
--bi[6, 6] = 0.
--bi[6, 7] = 0.
--bi[6, 8] = 0.
--
--bi[7, 0] = 0.
--bi[7, 1] = 2.649656243770091212685381903551424676261
--bi[7, 2] = -96.30312807816005963630382777245983513008
--bi[7, 3] = 869.3095462492795755338599928089438369769
--bi[7, 4] = -3395.688567551074115525201961265641584358
--bi[7, 5] = 6796.933987158715680563278170147156885480
--bi[7, 6] = -7340.848417712071304684606060804637321789
--bi[7, 7] = 4082.848896992365666259441580054990759905
--bi[7, 8] = -919.2934944890586676320942978986329899642
--
--bi[8, 0] = 0.
--bi[8, 1] = -1.563945181928732780647121505551017046606
--bi[8, 2] = 56.84239739272860000194549791973820565214
--bi[8, 3] = -513.1052300304284642178552372517916694426
--bi[8, 4] = 2004.286702110323162741493515173880535381
--bi[8, 5] = -4011.853305913929339500285683507736138334
--bi[8, 6] = 4332.895839278586189971336003691596594090
--bi[8, 7] = -2409.879347937144606091337260195738587773
--bi[8, 8] = 542.6079835318221405169412532400889768401
--
--bi[9, 0] = 0.
--bi[9, 1] = -.8627103334967223830653368770735555216700
--bi[9, 2] = 31.35565375185173442495465167501846267906
--bi[9, 3] = -283.0413682227354209126847112083546012674
--bi[9, 4] = 1105.613463426006937052739159664962261462
--bi[9, 5] = -2213.036200678452629288185991597653042989
--bi[9, 6] = 2390.131097754120588994847482867886207858
--bi[9, 7] = -1329.348266146873716496636094950745123424
--bi[9, 8] = 299.3158071265785138462868993727082901209
--
--bi[10, 0] = 0.
--bi[10, 1] = -1.520295337901214839055193576160469820911
--bi[10, 2] = 55.25592121120227100440616045452813504748
--bi[10, 3] = -498.7844190970740738969945498750124435385
--bi[10, 4] = 1948.346888525776056658403461666308795237
--bi[10, 5] = -3899.882136407551390287649940376076923682
--bi[10, 6] = 4211.964345158858030803618536151121927765
--bi[10, 7] = -2342.619408856117128087568672414857706561
--bi[10, 8] = 527.4637482204278644179968961638568925209
--
--bi[11, 0] = 0.
--bi[11, 1] = -3.846938844125523400516071820264700141179
--bi[11, 2] = 139.8189840986840520353362018994734906611
--bi[11, 3] = -1262.118687621600386514715930156791825893
--bi[11, 4] = 4930.075848057311658057235318456802793199
--bi[11, 5] = -9868.219486069539059368988308801366826185
--bi[11, 6] = 10657.90892434886730229746304583865145121
--bi[11, 7] = -5927.738759872814112912292792695856187255
--bi[11, 8] = 1334.688551172190921099749059976639173619
--
--bi[12, 0] = 0.
--bi[12, 1] = -.3942713061200141454309326713125653612517
--bi[12, 2] = 14.32999476067649707020689155180345562459
--bi[12, 3] = -129.3540665994558117853022852051786116929
--bi[12, 4] = 505.2816077002517600897861155496606850457
--bi[12, 5] = -1011.390080139433268878243655218566636574
--bi[12, 6] = 1092.325051781891697669369143688906543465
--bi[12, 7] = -607.5317019302810290917918493845279272648
--bi[12, 8] = 136.7917244480423273434147193694336909663
--
--bi[13, 0] = 0.
--bi[13, 1] = -.9233145622082101394378429409444333268499
--bi[13, 2] = 33.55834582309798808260613735851232640640
--bi[13, 3] = -302.9246397549735936661321348695774835448
--bi[13, 4] = 1183.281306967867553342903125095128753568
--bi[13, 5] = -2368.498986790111516106072390247333149007
--bi[13, 6] = 2558.034559755808027369106332027405169828
--bi[13, 7] = -1422.733175577880214903071122439856598476
--bi[13, 8] = 320.3423358787481875842587982911148385364
--
--bi[14, 0] = 0.
--bi[14, 1] = -.2068862802930053801253649628830330891017
--bi[14, 2] = 7.519388975651662772174695012120581518594
--bi[14, 3] = -67.87605708082904058354114755731111898667
--bi[14, 4] = 265.1367996984150421661637988925923843021
--bi[14, 5] = -530.7074807559025368587558119659212235622
--bi[14, 6] = 573.1765495641490277116961329189087439579
--bi[14, 7] = -318.7905688834868978004500126002971837241
--bi[14, 8] = 71.77882490212657594681492031347005327988
--
--bi[15, 0] = 0.
--bi[15, 1] = 0.
--bi[15, 2] = 0.
--bi[15, 3] = 0.
--bi[15, 4] = 0.
--bi[15, 5] = 0.
--bi[15, 6] = 0.
--bi[15, 7] = 0.
--bi[15, 8] = 0.
--
--bi[16, 0] = 0.
--bi[16, 1] = -.4472441906744099441704338175964823026105
--bi[16, 2] = 16.44684676010503791623763886833381020592
--bi[16, 3] = -154.4086105921295528355180056633078150675
--bi[16, 4] = 641.8986298540248497333509289273669726482
--bi[16, 5] = -1391.939225687982391028602609567895699003
--bi[16, 6] = 1643.890568302952013019278202625162156841
--bi[16, 7] = -1004.065297223317845596795060426393517046
--bi[16, 8] = 248.6243327770222987362193390543305737239
--
--bi[17, 0] = 0.
--bi[17, 1] = -.1507876007899797948720901584434839156279
--bi[17, 2] = 5.527328824824632235316362126620825363280
--bi[17, 3] = -51.33833743084618751433903968701557585387
--bi[17, 4] = 209.6022002703280347991393999433060881829
--bi[17, 5] = -442.7692650421825928714839983614217797969
--bi[17, 6] = 505.0579312588052893780948070449787925777
--bi[17, 7] = -295.6336410615619366143935619944592839974
--bi[17, 8] = 69.70457078142274038253812108643441743987
--
--bi[18, 0] = 0.
--bi[18, 1] = -.6413652207435296452288504944964177537185
--bi[18, 2] = 23.51013248624684600263471193689787394701
--bi[18, 3] = -218.3642683246972281497485359238725613162
--bi[18, 4] = 891.5292818535365634586829868055833114383
--bi[18, 5] = -1883.290177206007885518558760085145850658
--bi[18, 6] = 2148.230954488399755970660772306573864434
--bi[18, 7] = -1257.458401521712336970840850120592935471
--bi[18, 8] = 296.4838434449778148523985255750527153802
--
--bi[19, 0] = 0.
--bi[19, 1] = 1.810729313444845732964058528284532356045
--bi[19, 2] = -66.37479657295337371220255196726289169374
--bi[19, 3] = 616.4952025401106511929691356878863855003
--bi[19, 4] = -2517.003030777322559684753470471663859295
--bi[19, 5] = 5316.984175781033401491488704359579721604
--bi[19, 6] = -6064.976140789574108556866601189158423779
--bi[19, 7] = 3550.109538888391317555902194852386816092
--bi[19, 8] = -837.0456783831301740195014698000522807852
--
--bi[20, 0] = 0.
--bi[20, 1] = .5176008760353717918864555990277480363987e-1
--bi[20, 2] = -1.897337862580348756406065418550014243949
--bi[20, 3] = 17.62264820793629244181715147639285955422
--bi[20, 4] = -71.94907400242465946110661282550878163878
--bi[20, 5] = 151.9871383765666045085018751235590550206
--bi[20, 6] = -173.3686498747860565970136435029707518663
--bi[20, 7] = 101.4806461521468075879782291473158292931
--bi[20, 8] = -23.92713108446217690295957956014097092250
--
--bi[21, 0] = 0.
--bi[21, 1] = 31.32178255668799909977422939838912846070
--bi[21, 2] = -355.6570858339106059687054319211280026146
--bi[21, 3] = 1752.685282489515979253875884672206842255
--bi[21, 4] = -4708.092293138363367969732154806019707156
--bi[21, 5] = 7370.900776193488713149861391844801840850
--bi[21, 6] = -6716.504964764565347011489385051202629762
--bi[21, 7] = 3303.940398161185772296756776169088470785
--bi[21, 8] = -678.5938956640391428503413103061359428182
--
--bi[22, 0] = 0.
--bi[22, 1] = -2.719607334185924760747802644504744092917
--bi[22, 2] = 86.64045615858264001154848875638486632034
--bi[22, 3] = -454.1926030939030807863651114984001402596
--bi[22, 4] = 1014.749221100543425314268817989377200147
--bi[22, 5] = -1133.583456714543865890388885909333783663
--bi[22, 6] = 610.4671827718666569168001429679645990946
--bi[22, 7] = -109.0233499449543802317396567002119357593
--bi[22, 8] = -12.33784294340547057337599296127606178639
--
--bi[23, 0] = 0.
--bi[23, 1] = 3.177214801432923432265738869490200556403
--bi[23, 2] = -113.8098697715142983214434051918276259885
--bi[23, 3] = 978.0935981825675014833003847211971070224
--bi[23, 4] = -3575.129377623670076451027372711378100786
--bi[23, 5] = 6764.361519838450570830405988615992045681
--bi[23, 6] = -6987.161043852012362644872233028628887679
--bi[23, 7] = 3751.905762789571137088934326513342858381
--bi[23, 8] = -821.4378043648253954175634277881875971878
--
--bi[24, 0] = 0.
--bi[24, 1] = .8772843083465530069477626269697233842708
--bi[24, 2] = -31.51810423988375104361582759389916060143
--bi[24, 3] = 273.1229151353221133842213845530391043248
--bi[24, 4] = -993.2198643101781966584366870874238565290
--bi[24, 5] = 1787.888078312663987193988385659681964836
--bi[24, 6] = -1677.394835799640950953367739332661886275
--bi[24, 7] = 781.3579535062687952504707744453846824540
--bi[24, 8] = -141.1134269128985501802080532710905715931
--
--bi[25, 0] = 0.
--bi[25, 1] = 1.719427581798715782378897599231938082126
--bi[25, 2] = -62.89867309250732184389962568482931880335
--bi[25, 3] = 580.3335507873980391019057196688995930872
--bi[25, 4] = -2348.110620506760958600472968113883922730
--bi[25, 5] = 4921.119298612906015908637628774963068611
--bi[25, 6] = -5597.912448707916639109910311016358007839
--bi[25, 7] = 3288.597775149621789973016480733216881572
--bi[25, 8] = -782.8483098245396412116558219612402319811
--
--vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
-+"""
-+Provide a cython implimentation verner 'most-efficient'
-+order 9 runge-Kutta method.
-+See http://people.math.sfu.ca/~jverner/
-+"""
-+# Verner 9 Efficient
-+# http://people.math.sfu.ca/~jverner/
-+
-+__all__ = ["vern9_coeff"]
-+import numpy as np
-+order = 9
-+rk_step = 16
-+rk_extra_step = 26
-+denseout_order = 9
-+
-+bh = np.zeros(rk_step, dtype=np.float64)
-+a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
-+b = np.zeros(rk_step, dtype=np.float64)
-+c = np.zeros(rk_extra_step, dtype=np.float64)
-+e = np.zeros(rk_step, dtype=np.float64)
-+bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
-+
-+c[0] = 0.
-+c[1] = .3462e-1
-+c[2] = .9702435063878044594828361677100617517633e-1
-+c[3] = .1455365259581706689224254251565092627645
-+c[4] = .561
-+c[5] = .2290079115904850126662751771814700052182
-+c[6] = .5449920884095149873337248228185299947818
-+c[7] = .645
-+c[8] = .4837500000000000000000000000000000000000
-+c[9] = .6757e-1
-+c[10] = .2500
-+c[11] = .6590650618730998549405331618649220295334
-+c[12] = .8206
-+c[13] = .9012
-+c[14] = 1.
-+c[15] = 1.
-+
-+a[1, 0] = .3462e-1
-+
-+a[2, 0] = -.389335438857287327017042687229284478532e-1
-+a[2, 1] = .1359578945245091786499878854939346230295
-+
-+a[3, 0] = .3638413148954266723060635628912731569111e-1
-+a[3, 1] = 0.
-+a[3, 2] = .1091523944686280016918190688673819470733
-+
-+a[4, 0] = 2.025763914393969636805657604282571047511
-+a[4, 1] = 0.
-+a[4, 2] = -7.638023836496292020387602153091964592952
-+a[4, 3] = 6.173259922102322383581944548809393545442
-+
-+a[5, 0] = .5112275589406060872792270881648288397197e-1
-+a[5, 1] = 0.
-+a[5, 2] = 0.
-+a[5, 3] = .1770823794555021537929910813839068684087
-+a[5, 4] = .80277624092225014536138698108025283759e-3
-+
-+a[6, 0] = .1316006357975216279279871693164256985334
-+a[6, 1] = 0.
-+a[6, 2] = 0.
-+a[6, 3] = -.2957276252669636417685183174672273730699
-+a[6, 4] = .878137803564295237421124704053886667082e-1
-+a[6, 5] = .6213052975225274774321435005639430026100
-+
-+a[7, 0] = .7166666666666666666666666666666666666667e-1
-+a[7, 1] = 0.
-+a[7, 2] = 0.
-+a[7, 3] = 0.
-+a[7, 4] = 0.
-+a[7, 5] = .3305533578915319409260346730051472207728
-+a[7, 6] = .2427799754418013924072986603281861125606
-+
-+a[8, 0] = .7180664062500000000000000000000000000000e-1
-+a[8, 1] = 0.
-+a[8, 2] = 0.
-+a[8, 3] = 0.
-+a[8, 4] = 0.
-+a[8, 5] = .3294380283228177160744825466257672816401
-+a[8, 6] = .1165190029271822839255174533742327183599
-+a[8, 7] = -.3401367187500000000000000000000000000000e-1
-+
-+a[9, 0] = .4836757646340646986611287718844085773549e-1
-+a[9, 1] = 0.
-+a[9, 2] = 0.
-+a[9, 3] = 0.
-+a[9, 4] = 0.
-+a[9, 5] = .3928989925676163974333190042057047002852e-1
-+a[9, 6] = .1054740945890344608263649267140088017604
-+a[9, 7] = -.2143865284648312665982642293830533996214e-1
-+a[9, 8] = -.1041229174627194437759832813847147895623
-+
-+a[10, 0] = -.2664561487201478635337289243849737340534e-1
-+a[10, 1] = 0.
-+a[10, 2] = 0.
-+a[10, 3] = 0.
-+a[10, 4] = 0.
-+a[10, 5] = .3333333333333333333333333333333333333333e-1
-+a[10, 6] = -.1631072244872467239162704487554706387141
-+a[10, 7] = .3396081684127761199487954930015522928244e-1
-+a[10, 8] = .1572319413814626097110769806810024118077
-+a[10, 9] = .2152267478031879552303534778794770376960
-+
-+a[11, 0] = .3689009248708622334786359863227633989718e-1
-+a[11, 1] = 0.
-+a[11, 2] = 0.
-+a[11, 3] = 0.
-+a[11, 4] = 0.
-+a[11, 5] = -.1465181576725542928653609891758501156785
-+a[11, 6] = .2242577768172024345345469822625833796001
-+a[11, 7] = .2294405717066072637090897902753790803034e-1
-+a[11, 8] = -.35850052905728761357394424889330334334e-2
-+a[11, 9] = .8669223316444385506869203619044453906053e-1
-+a[11, 10] = .4383840651968337846196219974168630120572
-+
-+a[12, 0] = -.4866012215113340846662212357570395295088
-+a[12, 1] = 0.
-+a[12, 2] = 0.
-+a[12, 3] = 0.
-+a[12, 4] = 0.
-+a[12, 5] = -6.304602650282852990657772792012007122988
-+a[12, 6] = -.281245618289472564778284183790118418111
-+a[12, 7] = -2.679019236219849057687906597489223155566
-+a[12, 8] = .518815663924157511565311164615012522024
-+a[12, 9] = 1.365353187603341710683633635235238678626
-+a[12, 10] = 5.885091088503946585721274891680604830712
-+a[12, 11] = 2.802808786272062889819965117517532194812
-+
-+a[13, 0] = .4185367457753471441471025246471931649633
-+a[13, 1] = 0.
-+a[13, 2] = 0.
-+a[13, 3] = 0.
-+a[13, 4] = 0.
-+a[13, 5] = 6.724547581906459363100870806514855026676
-+a[13, 6] = -.425444280164611790606983409697113064616
-+a[13, 7] = 3.343279153001265577811816947557982637749
-+a[13, 8] = .617081663117537759528421117507709784737
-+a[13, 9] = -.929966123939932833937749523988800852013
-+a[13, 10] = -6.099948804751010722472962837945508844846
-+a[13, 11] = -3.002206187889399044804158084895173690015
-+a[13, 12] = .2553202529443445472336424602988558373637
-+
-+a[14, 0] = -.779374086122884664644623040843840506343
-+a[14, 1] = 0.
-+a[14, 2] = 0.
-+a[14, 3] = 0.
-+a[14, 4] = 0.
-+a[14, 5] = -13.93734253810777678786523664804936051203
-+a[14, 6] = 1.252048853379357320949735183924200895136
-+a[14, 7] = -14.69150040801686878191527989293072091588
-+a[14, 8] = -.494705058533141685655191992136962873577
-+a[14, 9] = 2.242974909146236657906984549543692874755
-+a[14, 10] = 13.36789380382864375813864978592679139881
-+a[14, 11] = 14.39665048665068644512236935340272139005
-+a[14, 12] = -.7975813331776800379127866056663258667437
-+a[14, 13] = .4409353709534277758753793068298041158235
-+
-+a[15, 0] = 2.058051337466886442151242368989994043993
-+a[15, 1] = 0.
-+a[15, 2] = 0.
-+a[15, 3] = 0.
-+a[15, 4] = 0.
-+a[15, 5] = 22.35793772796803295519317565842520212899
-+a[15, 6] = .90949810997556332745009198137971890783
-+a[15, 7] = 35.89110098240264104710550686568482456493
-+a[15, 8] = -3.442515027624453437985000403608480262211
-+a[15, 9] = -4.865481358036368826566013387928704014496
-+a[15, 10] = -18.90980381354342625688427480879773032857
-+a[15, 11] = -34.26354448030451782929251177395134170515
-+a[15, 12] = 1.264756521695642578827783499806516664686
-+a[15, 13] = 0.
-+a[15, 14] = 0.
-+
-+b[0] = .1461197685842315252051541915018784713459e-1
-+b[1] = 0.
-+b[2] = 0.
-+b[3] = 0.
-+b[4] = 0.
-+b[5] = 0.
-+b[6] = 0.
-+b[7] = -.3915211862331339089410228267288242030810
-+b[8] = .2310932500289506415909675644868993669908
-+b[9] = .1274766769992852382560589467488989175618
-+b[10] = .2246434176204157731566981937082069688984
-+b[11] = .5684352689748512932705226972873692126743
-+b[12] = .5825871557215827200814768021863420902155e-1
-+b[13] = .1364317403482215641609022744494239843327
-+b[14] = .3057013983082797397721005067920369646664e-1
-+b[15] = 0.
-+
-+bh[0] = .1996996514886773085518508418098868756464e-1
-+bh[1] = 0.
-+bh[2] = 0.
-+bh[3] = 0.
-+bh[4] = 0.
-+bh[5] = 0.
-+bh[6] = 0.
-+bh[7] = 2.191499304949330054530747099310837524864
-+bh[8] = .8857071848208438030833722031786358862953e-1
-+bh[9] = .1140560234865965622484956605091432032674
-+bh[10] = .2533163805345107065564577734569651977347
-+bh[11] = -2.056564386240941011158999594595981300493
-+bh[12] = .3408096799013119935160094894224543812830
-+bh[13] = 0.
-+bh[14] = 0.
-+bh[15] = .4834231373823958314376726739772871714902e-1
-+
-+for i in range(16):
-+    e[i] = b[i] - bh[i]
-+
-+c[16] = 1.0
-+
-+a[16, 0] = .1461197685842315252051541915018784713459e-1
-+a[16, 1] = 0.
-+a[16, 2] = 0.
-+a[16, 3] = 0.
-+a[16, 4] = 0.
-+a[16, 5] = 0.
-+a[16, 6] = 0.
-+a[16, 7] = -.3915211862331339089410228267288242030810
-+a[16, 8] = .2310932500289506415909675644868993669908
-+a[16, 9] = .1274766769992852382560589467488989175618
-+a[16, 10] = .2246434176204157731566981937082069688984
-+a[16, 11] = .5684352689748512932705226972873692126743
-+a[16, 12] = .5825871557215827200814768021863420902155e-1
-+a[16, 13] = .1364317403482215641609022744494239843327
-+a[16, 14] = .3057013983082797397721005067920369646664e-1
-+a[16, 15] = 0.
-+
-+c[17] = .7404185470631561083004100761798676215811
-+
-+a[17, 0] = .1549973668189559302279946863304789372788e-1
-+a[17, 1] = 0.
-+a[17, 2] = 0.
-+a[17, 3] = 0.
-+a[17, 4] = 0.
-+a[17, 5] = 0.
-+a[17, 6] = 0.
-+a[17, 7] = .3355153219059635054403439303177105512242
-+a[17, 8] = .2003613944191860651552622660712101217322
-+a[17, 9] = .1252060659283549312946162355194540994211
-+a[17, 10] = .2298676393184206750544046308957155868736
-+a[17, 11] = -.2020250653476181447824906889122391003637
-+a[17, 12] = .5917103230665456601422111997583025339897e-1
-+a[17, 13] = -.2651834783047638681693835956996437528251e-1
-+a[17, 14] = -.2384094602130971415278110567256446033405e-1
-+a[17, 15] = 0.
-+a[17, 16] = .2718171570208501807097257892166705118335e-1
-+
-+c[18] = .888
-+
-+a[18, 0] = .1302453943114338366054520296881099431474e-1
-+a[18, 1] = 0.
-+a[18, 2] = 0.
-+a[18, 3] = 0.
-+a[18, 4] = 0.
-+a[18, 5] = 0.
-+a[18, 6] = 0.
-+a[18, 7] = -.7452850902413112085299330666038981625179
-+a[18, 8] = .2643867896429300961465132150322749722129
-+a[18, 9] = .1313961758372753932588328082078842388890
-+a[18, 10] = .2167253815122927263092467187957410643315
-+a[18, 11] = .8734117564076052559016338094938888451419
-+a[18, 12] = .1185905643935776688228545787724340848142e-1
-+a[18, 13] = .5876002941689550612992712203494447529933e-1
-+a[18, 14] = .3266518630202087866399279690939423159022e-2
-+a[18, 15] = 0.
-+a[18, 16] = -.8959308648417929824525368306101792182274e-2
-+a[18, 17] = .6941415157202692219907482080827253287034e-1
-+
-+c[19] = .696
-+
-+a[19, 0] = .1397089996925942721283716334050740168797e-1
-+a[19, 1] = 0.
-+a[19, 2] = 0.
-+a[19, 3] = 0.
-+a[19, 4] = 0.
-+a[19, 5] = 0.
-+a[19, 6] = 0.
-+a[19, 7] = -.4665765335957674596054673402956853940520
-+a[19, 8] = .2416372787216257077935214889875485248580
-+a[19, 9] = .1290363341345674735721677437066933999929
-+a[19, 10] = .2216700671735105311080225734522323922813
-+a[19, 11] = .6257275123364644931771253383573999863003
-+a[19, 12] = .4355312415679284117869124964829805160429e-1
-+a[19, 13] = .1011962491667290833450024852274278874501
-+a[19, 14] = .1808582254679721049279369742685497400353e-1
-+a[19, 15] = 0.
-+a[19, 16] = -.2079875587689169691156509689282083267654e-1
-+a[19, 17] = -.9022232517086218976198252891464664868640e-1
-+a[19, 18] = -.1212796735622254216011467740438097427634
-+
-+c[20] = .487
-+
-+a[20, 0] = .1604638888318112738641232352800290501904e-1
-+a[20, 1] = 0.
-+a[20, 2] = 0.
-+a[20, 3] = 0.
-+a[20, 4] = 0.
-+a[20, 5] = 0.
-+a[20, 6] = 0.
-+a[20, 7] = .9517712399458336651642257453589397190702e-1
-+a[20, 8] = .1359187264655317806136927180199100622471
-+a[20, 9] = .1237765280959854006935081364365637515893
-+a[20, 10] = .2335656264102966047058755123098072346246
-+a[20, 11] = -.9051508172625873314662090873741762206189e-1
-+a[20, 12] = -.2537574270006131028513276914038326155331e-1
-+a[20, 13] = -.1359631696887162048002744757083947500478
-+a[20, 14] = -.4679214284145113075088049469061349990847e-1
-+a[20, 15] = 0.
-+a[20, 16] = .5177958859391748239949773879090325427473e-1
-+a[20, 17] = .9672595677476773313884172931875718705561e-1
-+a[20, 18] = .1477312690340742769720989417101989769314
-+a[20, 19] = -.1150750712958503934434410263732282100773
-+c[21] = .25e-1
-+
-+a[21, 0] = .1802918623893620731908165792176564180038e-1
-+a[21, 1] = 0.
-+a[21, 2] = 0.
-+a[21, 3] = 0.
-+a[21, 4] = 0.
-+a[21, 5] = 0.
-+a[21, 6] = 0.
-+a[21, 7] = .6983601042028873702545973390560096201728e-1
-+a[21, 8] = -.2541247660791663512384395986842781657182e-1
-+a[21, 9] = .8487827035463274491721441398893680307535e-2
-+a[21, 10] = -.2427525516089801645451101966852425715128e-2
-+a[21, 11] = -.1047839752893819879012607694745789515746
-+a[21, 12] = -.1473147795248041942353840372690095884761e-1
-+a[21, 13] = -.3916338390816177165706892282751065537530e-1
-+a[21, 14] = -.1005657343293959419073236542225421561652e-1
-+a[21, 15] = 0.
-+a[21, 16] = .1102510392204834322538452331445716455061e-1
-+a[21, 17] = .5092830749095398308703438556315975226108e-2
-+a[21, 18] = .4759715599420644505591133410826632557391e-1
-+a[21, 19] = .3386307003288382751110965442296681690349e-1
-+a[21, 20] = .2764422831404797700452373965825845732168e-1
-+
-+c[22] = .15
-+
-+a[22, 0] = .1677431640522778042988664067637191163626e-1
-+a[22, 1] = 0.
-+a[22, 2] = 0.
-+a[22, 3] = 0.
-+a[22, 4] = 0.
-+a[22, 5] = 0.
-+a[22, 6] = 0.
-+a[22, 7] = .6220437408820475326702539861577894278533
-+a[22, 8] = -.2060859809768841878234097076241307428139
-+a[22, 9] = .1156394989766058889629372195583391792474
-+a[22, 10] = .2664101793378358946544219293685167025971e-1
-+a[22, 11] = -.9376810793418770527505892794460093668860
-+a[22, 12] = -.1367806466702160302637074581619101741312
-+a[22, 13] = -.3678480995268296672182605288991379118419
-+a[22, 14] = -.9547871314402478902820445838193201497337e-1
-+a[22, 15] = 0.
-+a[22, 16] = .1013492018422369748729008873270013785313
-+a[22, 17] = -.8911323084568593396468400926074881389560e-1
-+a[22, 18] = .4664140988974760478895528270623735057521
-+a[22, 19] = .4502736292354579812232681662308722738519
-+a[22, 20] = .1838522463326818655346135218242696774099
-+a[22, 21] = 0.
-+
-+c[23] = .32
-+
-+a[23, 0] = .1071149731491444187554380927165768658192e-1
-+a[23, 1] = 0.
-+a[23, 2] = 0.
-+a[23, 3] = 0.
-+a[23, 4] = 0.
-+a[23, 5] = 0.
-+a[23, 6] = 0.
-+a[23, 7] = -.7094336118221108191937165464264324417735e-1
-+a[23, 8] = .1002164900340091596740582334112699697590
-+a[23, 9] = .1383453980468025108839271214703390659581
-+a[23, 10] = .1796330633578163411338104055485109917477
-+a[23, 11] = .9048246545576180974879274948815422276563e-1
-+a[23, 12] = -.5460662294523338383345981122023862069115e-2
-+a[23, 13] = -.3000457905119619782973021046143166498567e-1
-+a[23, 14] = -.1145192026962799093665613252151017277867e-1
-+a[23, 15] = 0.
-+a[23, 16] = .1003394686109385076849515422360600302176e-1
-+a[23, 17] = -.9506485282809046129031027932806241113157e-1
-+a[23, 18] = .4853358804093591445756711642658478691640e-1
-+a[23, 19] = .8013325919783924638483373011297347396327e-1
-+a[23, 20] = -.1251643326835242045676140618774248455713
-+a[23, 21] = 0.
-+a[23, 22] = 0.
-+
-+c[24] = .78
-+
-+a[24, 0] = .1410172088869221367153586187761994182069e-1
-+a[24, 1] = 0.
-+a[24, 2] = 0.
-+a[24, 3] = 0.
-+a[24, 4] = 0.
-+a[24, 5] = 0.
-+a[24, 6] = 0.
-+a[24, 7] = -.3713379753704491105936205420001801316029
-+a[24, 8] = .2231265548117180273161442520179150684520
-+a[24, 9] = .1287005345918120122888629169443916280865
-+a[24, 10] = .2224600659675494761192249831098918110654
-+a[24, 11] = .5382853042550701952740528638168708946100
-+a[24, 12] = .5417202616988763101781128062036252796548e-1
-+a[24, 13] = .1256968791308743925752109039299467082975
-+a[24, 14] = .2784492789002054061504430663197543089132e-1
-+a[24, 15] = 0.
-+a[24, 16] = -.3077409246205059733390460511525401688205e-1
-+a[24, 17] = .8569805293689777608077303071761466118035e-2
-+a[24, 18] = -.1535174690587044615794997685221990516897
-+a[24, 19] = -.2179957030548196497189489878038029238243e-1
-+a[24, 20] = .1447128819737186799295514239727801525027e-1
-+a[24, 21] = 0.
-+a[24, 22] = 0.
-+a[24, 23] = 0.
-+
-+c[25] = .96
-+
-+a[25, 0] = .1424600411735646609296566581447532773183e-1
-+a[25, 1] = 0.
-+a[25, 2] = 0.
-+a[25, 3] = 0.
-+a[25, 4] = 0.
-+a[25, 5] = 0.
-+a[25, 6] = 0.
-+a[25, 7] = -.3767107393295407091303982522049390741260
-+a[25, 8] = .2252399780730421480874737297000189000070
-+a[25, 9] = .1283603076292529988314451246143633426068
-+a[25, 10] = .2230238705261692544876826347415151339678
-+a[25, 11] = .5463127827750747224899202176094949607118
-+a[25, 12] = .5526190791375779994553849469706124289752e-1
-+a[25, 13] = .1285613508749982456581494397108686240388
-+a[25, 14] = .2857250681296406482698934635829147899039e-1
-+a[25, 15] = 0.
-+a[25, 16] = -.2398761886357108720930416967644499057175e-1
-+a[25, 17] = .5556224458910509454379297181908734648749e-1
-+a[25, 18] = -.1740675650762838674257930398070760254668e-1
-+a[25, 19] = -.3815462365996979065575121886854199471011e-1
-+a[25, 20] = .1111878504898917877407531966545730451506e-1
-+a[25, 21] = 0.
-+a[25, 22] = 0.
-+a[25, 23] = 0.
-+a[25, 24] = 0.
-+
-+bi[0, 0] = 1.
-+bi[0, 1] = -28.33048870061739823290767301658881994700
-+bi[0, 2] = 257.6535452078577977252092979905248156497
-+bi[0, 3] = -1152.154455743457311528752964691951881858
-+bi[0, 4] = 2909.390878345408890936564599116550031880
-+bi[0, 5] = -4355.005172868188498048946108887283528629
-+bi[0, 6] = 3834.083497036262189455855371796461857871
-+bi[0, 7] = -1835.419052683407081215583427992189311730
-+bi[0, 8] = 368.7958613829998340610814211036270246107
-+
-+bi[1, 0] = 0.
-+bi[1, 1] = 0.
-+bi[1, 2] = 0.
-+bi[1, 3] = 0.
-+bi[1, 4] = 0.
-+bi[1, 5] = 0.
-+bi[1, 6] = 0.
-+bi[1, 7] = 0.
-+bi[1, 8] = 0.
-+
-+bi[2, 0] = 0.
-+bi[2, 1] = 0.
-+bi[2, 2] = 0.
-+bi[2, 3] = 0.
-+bi[2, 4] = 0.
-+bi[2, 5] = 0.
-+bi[2, 6] = 0.
-+bi[2, 7] = 0.
-+bi[2, 8] = 0.
-+
-+bi[3, 0] = 0.
-+bi[3, 1] = 0.
-+bi[3, 2] = 0.
-+bi[3, 3] = 0.
-+bi[3, 4] = 0.
-+bi[3, 5] = 0.
-+bi[3, 6] = 0.
-+bi[3, 7] = 0.
-+bi[3, 8] = 0.
-+
-+bi[4, 0] = 0.
-+bi[4, 1] = 0.
-+bi[4, 2] = 0.
-+bi[4, 3] = 0.
-+bi[4, 4] = 0.
-+bi[4, 5] = 0.
-+bi[4, 6] = 0.
-+bi[4, 7] = 0.
-+bi[4, 8] = 0.
-+
-+bi[5, 0] = 0.
-+bi[5, 1] = 0.
-+bi[5, 2] = 0.
-+bi[5, 3] = 0.
-+bi[5, 4] = 0.
-+bi[5, 5] = 0.
-+bi[5, 6] = 0.
-+bi[5, 7] = 0.
-+bi[5, 8] = 0.
-+
-+bi[6, 0] = 0.
-+bi[6, 1] = 0.
-+bi[6, 2] = 0.
-+bi[6, 3] = 0.
-+bi[6, 4] = 0.
-+bi[6, 5] = 0.
-+bi[6, 6] = 0.
-+bi[6, 7] = 0.
-+bi[6, 8] = 0.
-+
-+bi[7, 0] = 0.
-+bi[7, 1] = 2.649656243770091212685381903551424676261
-+bi[7, 2] = -96.30312807816005963630382777245983513008
-+bi[7, 3] = 869.3095462492795755338599928089438369769
-+bi[7, 4] = -3395.688567551074115525201961265641584358
-+bi[7, 5] = 6796.933987158715680563278170147156885480
-+bi[7, 6] = -7340.848417712071304684606060804637321789
-+bi[7, 7] = 4082.848896992365666259441580054990759905
-+bi[7, 8] = -919.2934944890586676320942978986329899642
-+
-+bi[8, 0] = 0.
-+bi[8, 1] = -1.563945181928732780647121505551017046606
-+bi[8, 2] = 56.84239739272860000194549791973820565214
-+bi[8, 3] = -513.1052300304284642178552372517916694426
-+bi[8, 4] = 2004.286702110323162741493515173880535381
-+bi[8, 5] = -4011.853305913929339500285683507736138334
-+bi[8, 6] = 4332.895839278586189971336003691596594090
-+bi[8, 7] = -2409.879347937144606091337260195738587773
-+bi[8, 8] = 542.6079835318221405169412532400889768401
-+
-+bi[9, 0] = 0.
-+bi[9, 1] = -.8627103334967223830653368770735555216700
-+bi[9, 2] = 31.35565375185173442495465167501846267906
-+bi[9, 3] = -283.0413682227354209126847112083546012674
-+bi[9, 4] = 1105.613463426006937052739159664962261462
-+bi[9, 5] = -2213.036200678452629288185991597653042989
-+bi[9, 6] = 2390.131097754120588994847482867886207858
-+bi[9, 7] = -1329.348266146873716496636094950745123424
-+bi[9, 8] = 299.3158071265785138462868993727082901209
-+
-+bi[10, 0] = 0.
-+bi[10, 1] = -1.520295337901214839055193576160469820911
-+bi[10, 2] = 55.25592121120227100440616045452813504748
-+bi[10, 3] = -498.7844190970740738969945498750124435385
-+bi[10, 4] = 1948.346888525776056658403461666308795237
-+bi[10, 5] = -3899.882136407551390287649940376076923682
-+bi[10, 6] = 4211.964345158858030803618536151121927765
-+bi[10, 7] = -2342.619408856117128087568672414857706561
-+bi[10, 8] = 527.4637482204278644179968961638568925209
-+
-+bi[11, 0] = 0.
-+bi[11, 1] = -3.846938844125523400516071820264700141179
-+bi[11, 2] = 139.8189840986840520353362018994734906611
-+bi[11, 3] = -1262.118687621600386514715930156791825893
-+bi[11, 4] = 4930.075848057311658057235318456802793199
-+bi[11, 5] = -9868.219486069539059368988308801366826185
-+bi[11, 6] = 10657.90892434886730229746304583865145121
-+bi[11, 7] = -5927.738759872814112912292792695856187255
-+bi[11, 8] = 1334.688551172190921099749059976639173619
-+
-+bi[12, 0] = 0.
-+bi[12, 1] = -.3942713061200141454309326713125653612517
-+bi[12, 2] = 14.32999476067649707020689155180345562459
-+bi[12, 3] = -129.3540665994558117853022852051786116929
-+bi[12, 4] = 505.2816077002517600897861155496606850457
-+bi[12, 5] = -1011.390080139433268878243655218566636574
-+bi[12, 6] = 1092.325051781891697669369143688906543465
-+bi[12, 7] = -607.5317019302810290917918493845279272648
-+bi[12, 8] = 136.7917244480423273434147193694336909663
-+
-+bi[13, 0] = 0.
-+bi[13, 1] = -.9233145622082101394378429409444333268499
-+bi[13, 2] = 33.55834582309798808260613735851232640640
-+bi[13, 3] = -302.9246397549735936661321348695774835448
-+bi[13, 4] = 1183.281306967867553342903125095128753568
-+bi[13, 5] = -2368.498986790111516106072390247333149007
-+bi[13, 6] = 2558.034559755808027369106332027405169828
-+bi[13, 7] = -1422.733175577880214903071122439856598476
-+bi[13, 8] = 320.3423358787481875842587982911148385364
-+
-+bi[14, 0] = 0.
-+bi[14, 1] = -.2068862802930053801253649628830330891017
-+bi[14, 2] = 7.519388975651662772174695012120581518594
-+bi[14, 3] = -67.87605708082904058354114755731111898667
-+bi[14, 4] = 265.1367996984150421661637988925923843021
-+bi[14, 5] = -530.7074807559025368587558119659212235622
-+bi[14, 6] = 573.1765495641490277116961329189087439579
-+bi[14, 7] = -318.7905688834868978004500126002971837241
-+bi[14, 8] = 71.77882490212657594681492031347005327988
-+
-+bi[15, 0] = 0.
-+bi[15, 1] = 0.
-+bi[15, 2] = 0.
-+bi[15, 3] = 0.
-+bi[15, 4] = 0.
-+bi[15, 5] = 0.
-+bi[15, 6] = 0.
-+bi[15, 7] = 0.
-+bi[15, 8] = 0.
-+
-+bi[16, 0] = 0.
-+bi[16, 1] = -.4472441906744099441704338175964823026105
-+bi[16, 2] = 16.44684676010503791623763886833381020592
-+bi[16, 3] = -154.4086105921295528355180056633078150675
-+bi[16, 4] = 641.8986298540248497333509289273669726482
-+bi[16, 5] = -1391.939225687982391028602609567895699003
-+bi[16, 6] = 1643.890568302952013019278202625162156841
-+bi[16, 7] = -1004.065297223317845596795060426393517046
-+bi[16, 8] = 248.6243327770222987362193390543305737239
-+
-+bi[17, 0] = 0.
-+bi[17, 1] = -.1507876007899797948720901584434839156279
-+bi[17, 2] = 5.527328824824632235316362126620825363280
-+bi[17, 3] = -51.33833743084618751433903968701557585387
-+bi[17, 4] = 209.6022002703280347991393999433060881829
-+bi[17, 5] = -442.7692650421825928714839983614217797969
-+bi[17, 6] = 505.0579312588052893780948070449787925777
-+bi[17, 7] = -295.6336410615619366143935619944592839974
-+bi[17, 8] = 69.70457078142274038253812108643441743987
-+
-+bi[18, 0] = 0.
-+bi[18, 1] = -.6413652207435296452288504944964177537185
-+bi[18, 2] = 23.51013248624684600263471193689787394701
-+bi[18, 3] = -218.3642683246972281497485359238725613162
-+bi[18, 4] = 891.5292818535365634586829868055833114383
-+bi[18, 5] = -1883.290177206007885518558760085145850658
-+bi[18, 6] = 2148.230954488399755970660772306573864434
-+bi[18, 7] = -1257.458401521712336970840850120592935471
-+bi[18, 8] = 296.4838434449778148523985255750527153802
-+
-+bi[19, 0] = 0.
-+bi[19, 1] = 1.810729313444845732964058528284532356045
-+bi[19, 2] = -66.37479657295337371220255196726289169374
-+bi[19, 3] = 616.4952025401106511929691356878863855003
-+bi[19, 4] = -2517.003030777322559684753470471663859295
-+bi[19, 5] = 5316.984175781033401491488704359579721604
-+bi[19, 6] = -6064.976140789574108556866601189158423779
-+bi[19, 7] = 3550.109538888391317555902194852386816092
-+bi[19, 8] = -837.0456783831301740195014698000522807852
-+
-+bi[20, 0] = 0.
-+bi[20, 1] = .5176008760353717918864555990277480363987e-1
-+bi[20, 2] = -1.897337862580348756406065418550014243949
-+bi[20, 3] = 17.62264820793629244181715147639285955422
-+bi[20, 4] = -71.94907400242465946110661282550878163878
-+bi[20, 5] = 151.9871383765666045085018751235590550206
-+bi[20, 6] = -173.3686498747860565970136435029707518663
-+bi[20, 7] = 101.4806461521468075879782291473158292931
-+bi[20, 8] = -23.92713108446217690295957956014097092250
-+
-+bi[21, 0] = 0.
-+bi[21, 1] = 31.32178255668799909977422939838912846070
-+bi[21, 2] = -355.6570858339106059687054319211280026146
-+bi[21, 3] = 1752.685282489515979253875884672206842255
-+bi[21, 4] = -4708.092293138363367969732154806019707156
-+bi[21, 5] = 7370.900776193488713149861391844801840850
-+bi[21, 6] = -6716.504964764565347011489385051202629762
-+bi[21, 7] = 3303.940398161185772296756776169088470785
-+bi[21, 8] = -678.5938956640391428503413103061359428182
-+
-+bi[22, 0] = 0.
-+bi[22, 1] = -2.719607334185924760747802644504744092917
-+bi[22, 2] = 86.64045615858264001154848875638486632034
-+bi[22, 3] = -454.1926030939030807863651114984001402596
-+bi[22, 4] = 1014.749221100543425314268817989377200147
-+bi[22, 5] = -1133.583456714543865890388885909333783663
-+bi[22, 6] = 610.4671827718666569168001429679645990946
-+bi[22, 7] = -109.0233499449543802317396567002119357593
-+bi[22, 8] = -12.33784294340547057337599296127606178639
-+
-+bi[23, 0] = 0.
-+bi[23, 1] = 3.177214801432923432265738869490200556403
-+bi[23, 2] = -113.8098697715142983214434051918276259885
-+bi[23, 3] = 978.0935981825675014833003847211971070224
-+bi[23, 4] = -3575.129377623670076451027372711378100786
-+bi[23, 5] = 6764.361519838450570830405988615992045681
-+bi[23, 6] = -6987.161043852012362644872233028628887679
-+bi[23, 7] = 3751.905762789571137088934326513342858381
-+bi[23, 8] = -821.4378043648253954175634277881875971878
-+
-+bi[24, 0] = 0.
-+bi[24, 1] = .8772843083465530069477626269697233842708
-+bi[24, 2] = -31.51810423988375104361582759389916060143
-+bi[24, 3] = 273.1229151353221133842213845530391043248
-+bi[24, 4] = -993.2198643101781966584366870874238565290
-+bi[24, 5] = 1787.888078312663987193988385659681964836
-+bi[24, 6] = -1677.394835799640950953367739332661886275
-+bi[24, 7] = 781.3579535062687952504707744453846824540
-+bi[24, 8] = -141.1134269128985501802080532710905715931
-+
-+bi[25, 0] = 0.
-+bi[25, 1] = 1.719427581798715782378897599231938082126
-+bi[25, 2] = -62.89867309250732184389962568482931880335
-+bi[25, 3] = 580.3335507873980391019057196688995930872
-+bi[25, 4] = -2348.110620506760958600472968113883922730
-+bi[25, 5] = 4921.119298612906015908637628774963068611
-+bi[25, 6] = -5597.912448707916639109910311016358007839
-+bi[25, 7] = 3288.597775149621789973016480733216881572
-+bi[25, 8] = -782.8483098245396412116558219612402319811
-+
-+vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
-diff --git a/qutip/solver/krylovsolve.py b/qutip/solver/krylovsolve.py
-index 99fa78b2..4d14262c 100644
---- a/qutip/solver/krylovsolve.py
-+++ b/qutip/solver/krylovsolve.py
-@@ -1,102 +1,102 @@
--__all__ = ['krylovsolve']
--
--from .. import QobjEvo
--from .sesolve import SESolver
--
--
--def krylovsolve(
--    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
--):
--    """
--    Schrodinger equation evolution of a state vector for time independent
--    Hamiltonians using Krylov method.
--
--    Evolve the state vector ("psi0") finding an approximation for the time
--    evolution operator of Hamiltonian ("H") by obtaining the projection of
--    the time evolution operator on a set of small dimensional Krylov
--    subspaces (m << dim(H)).
--
--    The output is either the state vector or unitary matrix at arbitrary points
--    in time (`tlist`), or the expectation values of the supplied operators
--    (`e_ops`). If e_ops is a callback function, it is invoked for each
--    time in `tlist` with time and the state as arguments, and the function
--    does not use any return values. e_ops cannot be used in conjunction
--    with solving the Schrodinger operator equation
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
--        System Hamiltonian as a Qobj or QobjEvo for time-dependent
--        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
--        that can be made into :class:`QobjEvo` are also accepted.
--
--    psi0 : :class:`qutip.qobj`
--        initial state vector (ket)
--        or initial unitary operator `psi0 = U`
--
--    tlist : *list* / *array*
--        list of times for :math:`t`.
--
--    krylov_dim: int
--        Dimension of Krylov approximation subspaces used for the time
--        evolution approximation.
--
--    e_ops : :class:`qutip.qobj`, callable, or list.
--        Single operator or list of operators for which to evaluate
--        expectation values or callable or list of callable.
--        Callable signature must be, `f(t: float, state: Qobj)`.
--        See :func:`expect` for more detail of operator expectation.
--
--    args : None / *dictionary*
--        dictionary of parameters for time-dependent Hamiltonians
--
--    options : None / dict
--        Dictionary of options for the solver.
--
--        - store_final_state : bool, [False]
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, [None]
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - normalize_output : bool, [True]
--          Normalize output state to hide ODE numerical errors.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict, [{"chunk_size": 10}]
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - atol: float [1e-7]
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps : int [100]
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - min_step, max_step : float, [1e-5, 1e5]
--          Miniumum and maximum lenght of one internal step.
--        - always_compute_step: bool [False]
--          If True, the step lenght is computed each time a new Krylov
--          subspace is computed. Otherwise it is computed only once when
--          creating the integrator.
--        - sub_system_tol: float, [1e-7]
--          Tolerance to detect an happy breakdown. An happy breakdown happens
--          when the initial ket is in a subspace of the Hamiltonian smaller
--          than ``krylov_dim``.
--
--    Returns
--    -------
--    result: :class:`qutip.Result`
--
--        An instance of the class :class:`qutip.Result`, which contains
--        a *list of array* `result.expect` of expectation values for the times
--        specified by `tlist`, and/or a *list* `result.states` of state vectors
--        or density matrices corresponding to the times in `tlist` [if `e_ops`
--        is an empty list of `store_states=True` in options].
--    """
--    H = QobjEvo(H, args=args, tlist=tlist)
--    options = options or {}
--    options["method"] = "krylov"
--    options["krylov_dim"] = krylov_dim
--    solver = SESolver(H, options=options)
--    return solver.run(psi0, tlist, e_ops=e_ops)
-+__all__ = ['krylovsolve']
-+
-+from .. import QobjEvo
-+from .sesolve import SESolver
-+
-+
-+def krylovsolve(
-+    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
-+):
-+    """
-+    Schrodinger equation evolution of a state vector for time independent
-+    Hamiltonians using Krylov method.
-+
-+    Evolve the state vector ("psi0") finding an approximation for the time
-+    evolution operator of Hamiltonian ("H") by obtaining the projection of
-+    the time evolution operator on a set of small dimensional Krylov
-+    subspaces (m << dim(H)).
-+
-+    The output is either the state vector or unitary matrix at arbitrary points
-+    in time (`tlist`), or the expectation values of the supplied operators
-+    (`e_ops`). If e_ops is a callback function, it is invoked for each
-+    time in `tlist` with time and the state as arguments, and the function
-+    does not use any return values. e_ops cannot be used in conjunction
-+    with solving the Schrodinger operator equation
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-+        that can be made into :class:`QobjEvo` are also accepted.
-+
-+    psi0 : :class:`qutip.qobj`
-+        initial state vector (ket)
-+        or initial unitary operator `psi0 = U`
-+
-+    tlist : *list* / *array*
-+        list of times for :math:`t`.
-+
-+    krylov_dim: int
-+        Dimension of Krylov approximation subspaces used for the time
-+        evolution approximation.
-+
-+    e_ops : :class:`qutip.qobj`, callable, or list.
-+        Single operator or list of operators for which to evaluate
-+        expectation values or callable or list of callable.
-+        Callable signature must be, `f(t: float, state: Qobj)`.
-+        See :func:`expect` for more detail of operator expectation.
-+
-+    args : None / *dictionary*
-+        dictionary of parameters for time-dependent Hamiltonians
-+
-+    options : None / dict
-+        Dictionary of options for the solver.
-+
-+        - store_final_state : bool, [False]
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, [None]
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - normalize_output : bool, [True]
-+          Normalize output state to hide ODE numerical errors.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict, [{"chunk_size": 10}]
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - atol: float [1e-7]
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps : int [100]
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - min_step, max_step : float, [1e-5, 1e5]
-+          Miniumum and maximum lenght of one internal step.
-+        - always_compute_step: bool [False]
-+          If True, the step lenght is computed each time a new Krylov
-+          subspace is computed. Otherwise it is computed only once when
-+          creating the integrator.
-+        - sub_system_tol: float, [1e-7]
-+          Tolerance to detect an happy breakdown. An happy breakdown happens
-+          when the initial ket is in a subspace of the Hamiltonian smaller
-+          than ``krylov_dim``.
-+
-+    Returns
-+    -------
-+    result: :class:`qutip.Result`
-+
-+        An instance of the class :class:`qutip.Result`, which contains
-+        a *list of array* `result.expect` of expectation values for the times
-+        specified by `tlist`, and/or a *list* `result.states` of state vectors
-+        or density matrices corresponding to the times in `tlist` [if `e_ops`
-+        is an empty list of `store_states=True` in options].
-+    """
-+    H = QobjEvo(H, args=args, tlist=tlist)
-+    options = options or {}
-+    options["method"] = "krylov"
-+    options["krylov_dim"] = krylov_dim
-+    solver = SESolver(H, options=options)
-+    return solver.run(psi0, tlist, e_ops=e_ops)
-diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
-index bc3369b9..f1a55bf2 100644
---- a/qutip/solver/mcsolve.py
-+++ b/qutip/solver/mcsolve.py
-@@ -1,527 +1,527 @@
--__all__ = ['mcsolve', "MCSolver"]
--
--import warnings
--
--import numpy as np
--from copy import copy
--from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
--from .multitraj import MultiTrajSolver
--from .solver_base import Solver
--from .result import McResult, Result
--from .mesolve import mesolve, MESolver
--import qutip.core.data as _data
--from time import time
--
--
--def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
--            args=None, options=None, seeds=None, target_tol=None, timeout=None):
--    r"""
--    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
--    given Hamiltonian and sets of collapse operators. Options for the
--    underlying ODE solver are given by the Options class.
--
--    Parameters
--    ----------
--    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
--        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
--        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
--        ``H`` can also be a superoperator (liouvillian) if some collapse
--        operators are to be treated deterministically.
--
--    state : :class:`qutip.Qobj`
--        Initial state vector.
--
--    tlist : array_like
--        Times at which results are recorded.
--
--    c_ops : list
--        A ``list`` of collapse operators in any input type that QobjEvo accepts
--        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
--        even if ``H`` is a superoperator. If none are given, the solver will
--        defer to ``sesolve`` or ``mesolve``.
--
--    e_ops : list, [optional]
--        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
--        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
--        are given, the solver will default to save the states.
--
--    ntraj : int
--        Maximum number of trajectories to run. Can be cut short if a time limit
--        is passed with the ``timeout`` keyword or if the target tolerance is
--        reached, see ``target_tol``.
--
--    args : None / dict
--        Arguments for time-dependent Hamiltonian and collapse operator terms.
--
--    options : None / dict
--        Dictionary of options for the solver.
--
--        - store_final_state : bool [False]
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, NoneType, [None]
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict, [{"chunk_size": 10}]
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
--          Which differential equation integration method to use.
--        - keep_runs_results : bool, [False]
--          Whether to store results from all trajectories or just store the
--          averages.
--        - map : str {"serial", "parallel", "loky"}, ["serial"]
--          How to run the trajectories. "parallel" uses concurent module to run
--          in parallel while "loky" use the module of the same name to do so.
--        - job_timeout : NoneType, int, [None]
--          Maximum time to compute one trajectory.
--        - num_cpus : NoneType, int, [None]
--          Number of cpus to use when running in parallel. ``None`` detect the
--          number of available cpus.
--        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
--          Parameters used to find the collapse location. ``norm_t_tol`` and
--          ``norm_tol`` are the tolerance in time and norm respectively.
--          An error will be raised if the collapse could not be found within
--          ``norm_steps`` tries.
--        - mc_corr_eps : float, [1e-10]
--          Small number used to detect non-physical collapse caused by numerical
--          imprecision.
--        - atol, rtol : float, [1e-8, 1e-6]
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps : int [2500]
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - max_step : float, [0]
--          Maximum lenght of one internal step. When using pulses, it should be
--          less than half the width of the thinnest pulse.
--
--    seeds : int, SeedSequence, list, [optional]
--        Seed for the random number generator. It can be a single seed used to
--        spawn seeds for each trajectory or a list of seeds, one for each
--        trajectory. Seeds are saved in the result and they can be reused with::
--
--            seeds=prev_result.seeds
--
--    target_tol : {float, tuple, list}, optional
--        Target tolerance of the evolution. The evolution will compute
--        trajectories until the error on the expectation values is lower than
--        this tolerance. The maximum number of trajectories employed is
--        given by ``ntraj``. The error is computed using jackknife resampling.
--        ``target_tol`` can be an absolute tolerance or a pair of absolute and
--        relative tolerance, in that order. Lastly, it can be a list of pairs of
--        (atol, rtol) for each e_ops.
--
--    timeout : float [optional]
--        Maximum time for the evolution in second. When reached, no more
--        trajectories will be computed. Overwrite the option of the same name.
--
--    Returns
--    -------
--    results : :class:`qutip.solver.Result`
--        Object storing all results from the simulation. Which results is saved
--        depends on the presence of ``e_ops`` and the options used. ``collapse``
--        and ``photocurrent`` is available to Monte Carlo simulation results.
--
--    .. note:
--        The simulation will end when the first end condition is reached between
--        ``ntraj``, ``timeout`` and ``target_tol``.
--    """
--    H = QobjEvo(H, args=args, tlist=tlist)
--    if not isinstance(c_ops, (list, tuple)):
--        c_ops = [c_ops]
--    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
--
--    if len(c_ops) == 0:
--        if options is None:
--            options = {}
--        options = {
--            key: options[key]
--            for key in options
--            if key in MESolver.solver_options
--        }
--        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
--                       options=options)
--
--    if isinstance(ntraj, (list, tuple)):
--        raise TypeError(
--            "ntraj must be an integer. "
--            "A list of numbers is not longer supported."
--        )
--
--    mc = MCSolver(H, c_ops, options=options)
--    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
--                    seed=seeds, target_tol=target_tol, timeout=timeout)
--    return result
--
--
--class MCIntegrator:
--    """
--    Integrator like object for mcsolve trajectory.
--    """
--    name = "mcsolve"
--
--    def __init__(self, integrator, c_ops, n_ops, options=None):
--        self._integrator = integrator
--        self._c_ops = c_ops
--        self._n_ops = n_ops
--        self.options = options
--        self._generator = None
--        self.method = f"{self.name} {self._integrator.method}"
--        self._is_set = False
--        self.issuper = c_ops[0].issuper
--
--    def set_state(self, t, state0, generator):
--        """
--        Set the state of the ODE solver.
--
--        Parameters
--        ----------
--        t : float
--            Initial time
--
--        state0 : qutip.Data
--            Initial state.
--
--        generator : numpy.random.generator
--            Random number generator.
--        """
--        self.collapses = []
--        self._generator = generator
--        self.target_norm = self._generator.random()
--        self._integrator.set_state(t, state0)
--        self._is_set = True
--
--    def get_state(self, copy=True):
--        return *self._integrator.get_state(copy), self._generator
--
--    def integrate(self, t, copy=False):
--        t_old, y_old = self._integrator.get_state(copy=False)
--        norm_old = self._prob_func(y_old)
--        while t_old < t:
--            t_step, state = self._integrator.mcstep(t, copy=False)
--            norm = self._prob_func(state)
--            if norm <= self.target_norm:
--                t_col, state = self._find_collapse_time(norm_old, norm,
--                                                        t_old, t_step)
--                self._do_collapse(t_col, state)
--                t_old, y_old = self._integrator.get_state(copy=False)
--                norm_old = 1.
--            else:
--                t_old, y_old = t_step, state
--                norm_old = norm
--
--        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
--
--    def run(self, tlist):
--        for t in tlist[1:]:
--            yield self.integrate(t, False)
--
--    def reset(self, hard=False):
--        self._integrator.reset(hard)
--
--    def _prob_func(self, state):
--        if self.issuper:
--            return _data.trace_oper_ket(state).real
--        return _data.norm.l2(state)**2
--
--    def _norm_func(self, state):
--        if self.issuper:
--            return _data.trace_oper_ket(state).real
--        return _data.norm.l2(state)
--
--    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
--        """Find the time of the collapse and state just before it."""
--        tries = 0
--        while tries < self.options['norm_steps']:
--            tries += 1
--            if (t_final - t_prev) < self.options['norm_t_tol']:
--                t_guess = t_final
--                _, state = self._integrator.get_state()
--                break
--            t_guess = (
--                t_prev
--                + ((t_final - t_prev)
--                   * np.log(norm_old / self.target_norm)
--                   / np.log(norm_old / norm))
--            )
--            if (t_guess - t_prev) < self.options['norm_t_tol']:
--                t_guess = t_prev + self.options['norm_t_tol']
--            _, state = self._integrator.mcstep(t_guess, copy=False)
--            norm2_guess = self._prob_func(state)
--            if (
--                np.abs(self.target_norm - norm2_guess) <
--                self.options['norm_tol'] * self.target_norm
--            ):
--                break
--            elif (norm2_guess < self.target_norm):
--                # t_guess is still > t_jump
--                t_final = t_guess
--                norm = norm2_guess
--            else:
--                # t_guess < t_jump
--                t_prev = t_guess
--                norm_old = norm2_guess
--
--        if tries >= self.options['norm_steps']:
--            raise RuntimeError(
--                "Could not find the collapse time within desired tolerance. "
--                "Increase accuracy of the ODE solver or lower the tolerance "
--                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
--
--        return t_guess, state
--
--    def _do_collapse(self, collapse_time, state):
--        """
--        Do the collapse:
--        - Find which operator did the collapse.
--        - Update the state and Integrator.
--        - Next collapse norm location
--        - Store collapse info.
--        """
--        # collapse_time, state is at the collapse
--        if len(self._n_ops) == 1:
--            which = 0
--        else:
--            probs = np.zeros(len(self._n_ops))
--            for i, n_op in enumerate(self._n_ops):
--                probs[i] = n_op.expect_data(collapse_time, state).real
--            probs = np.cumsum(probs)
--            which = np.searchsorted(probs,
--                                    probs[-1] * self._generator.random())
--
--        state_new = self._c_ops[which].matmul_data(collapse_time, state)
--        new_norm = self._norm_func(state_new)
--        if new_norm < self.options['mc_corr_eps']:
--            # This happen when the collapse is caused by numerical error
--            state_new = _data.mul(state, 1 / self._norm_func(state))
--        else:
--            state_new = _data.mul(state_new, 1 / new_norm)
--            self.collapses.append((collapse_time, which))
--            self.target_norm = self._generator.random()
--        self._integrator.set_state(collapse_time, state_new)
--
--    def arguments(self, args):
--        if args:
--            self._integrator.arguments(args)
--            for c_op in self._c_ops:
--                c_op.arguments(args)
--            for n_op in self._n_ops:
--                n_op.arguments(args)
--
--    @property
--    def integrator_options(self):
--        return self._integrator.integrator_options
--
--
--# -----------------------------------------------------------------------------
--# MONTE CARLO CLASS
--# -----------------------------------------------------------------------------
--class MCSolver(MultiTrajSolver):
--    r"""
--    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
--    given Hamiltonian and sets of collapse operators. Options for the
--    underlying ODE solver are given by the Options class.
--
--    Parameters
--    ----------
--    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
--        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
--        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
--        ``H`` can also be a superoperator (liouvillian) if some collapse
--        operators are to be treated deterministically.
--
--    c_ops : list
--        A ``list`` of collapse operators in any input type that QobjEvo accepts
--        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
--        even if ``H`` is a superoperator.
--
--    options : dict, [optional]
--        Options for the evolution.
--    """
--    name = "mcsolve"
--    resultclass = McResult
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size": 10},
--        "store_final_state": False,
--        "store_states": None,
--        "keep_runs_results": False,
--        "method": "adams",
--        "map": "serial",
--        "job_timeout": None,
--        "num_cpus": None,
--        "bitgenerator": None,
--        "mc_corr_eps": 1e-10,
--        "norm_steps": 5,
--        "norm_t_tol": 1e-6,
--        "norm_tol": 1e-4,
--    }
--
--    def __init__(self, H, c_ops, *, options=None):
--        _time_start = time()
--
--        if isinstance(c_ops, (Qobj, QobjEvo)):
--            c_ops = [c_ops]
--        c_ops = [QobjEvo(c_op) for c_op in c_ops]
--
--        if H.issuper:
--            self._c_ops = [
--                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
--                for c_op in c_ops
--            ]
--            self._n_ops = self._c_ops
--            rhs = QobjEvo(H)
--            for c_op in c_ops:
--                cdc = c_op.dag() @ c_op
--                rhs -= 0.5 * (spre(cdc) + spost(cdc))
--        else:
--            self._c_ops = c_ops
--            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
--            rhs = -1j * QobjEvo(H)
--            for n_op in self._n_ops:
--                rhs -= 0.5 * n_op
--
--        self._num_collapse = len(self._c_ops)
--
--        super().__init__(rhs, options=options)
--
--    def _restore_state(self, data, *, copy=True):
--        """
--        Retore the Qobj state from its data.
--        """
--        if self._state_metadata['dims'] == self.rhs.dims[1]:
--            state = Qobj(unstack_columns(data),
--                         **self._state_metadata, copy=False)
--        else:
--            state = Qobj(data, **self._state_metadata, copy=copy)
--
--        return state
--
--    def _initialize_stats(self):
--        stats = super()._initialize_stats()
--        stats.update({
--            "method": self.options["method"],
--            "solver": "Master Equation Evolution",
--            "num_collapse": self._num_collapse,
--        })
--        return stats
--
--    def _argument(self, args):
--        self._integrator.arguments(args)
--        self.rhs.arguments(args)
--        for c_op in self._c_ops:
--            c_op.arguments(args)
--        for n_op in self._n_ops:
--            n_op.arguments(args)
--
--    def _run_one_traj(self, seed, state, tlist, e_ops):
--        """
--        Run one trajectory and return the result.
--        """
--        # The integrators is reused, but non-reentrant. They are are fine for
--        # multiprocessing, but will fail with multithreading.
--        # If a thread base parallel map is created, eahc trajectory should use
--        # a copy of the integrator.
--        result = Result(e_ops, {**self.options, "normalize_output": False})
--        generator = self._get_generator(seed)
--        self._integrator.set_state(tlist[0], state, generator)
--        result.add(tlist[0], self._restore_state(state, copy=False))
--        for t in tlist[1:]:
--            t, state = self._integrator.integrate(t, copy=False)
--            result.add(t, self._restore_state(state, copy=False))
--        result.collapse = self._integrator.collapses
--        return seed, result
--
--    def _get_integrator(self):
--        _time_start = time()
--        method = self.options["method"]
--        if method in self.avail_integrators():
--            integrator = self.avail_integrators()[method]
--        elif issubclass(method, Integrator):
--            integrator = method
--        else:
--            raise ValueError("Integrator method not supported.")
--        integrator_instance = integrator(self.rhs, self.options)
--        mc_integrator = MCIntegrator(
--            integrator_instance, self._c_ops, self._n_ops, self.options
--        )
--        self._init_integrator_time = time() - _time_start
--        return mc_integrator
--
--    @property
--    def options(self):
--        """
--        Options for monte carlo solver:
--
--        store_final_state: bool, default=False
--            Whether or not to store the final state of the evolution in the
--            result class.
--
--        store_states: bool, default=None
--            Whether or not to store the state vectors or density matrices.
--            On `None` the states will be saved if no expectation operators are
--            given.
--
--        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
--            How to present the solver progress.
--            'tqdm' uses the python module of the same name and raise an error if
--            not installed. Empty string or False will disable the bar.
--
--        progress_kwargs: dict, default={"chunk_size":10}
--            Arguments to pass to the progress_bar. Qutip's bars use
--            ``chunk_size``.
--
--        keep_runs_results: bool
--          Whether to store results from all trajectories or just store the
--          averages.
--
--        method: str, default="adams"
--            Which ODE integrator methods are supported.
--
--        map: str {"serial", "parallel", "loky"}
--            How to run the trajectories. "parallel" uses concurent module to
--            run in parallel while "loky" use the module of the same name to do
--            so.
--
--        job_timeout: None, int
--            Maximum time to compute one trajectory.
--
--        num_cpus: None, int
--            Number of cpus to use when running in parallel. ``None`` detect the
--            number of available cpus.
--
--        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
--            Which of numpy.random's bitgenerator to use. With ``None``, your
--            numpy version's default is used.
--
--        mc_corr_eps: float
--            Small number used to detect non-physical collapse caused by
--            numerical imprecision.
--
--        norm_t_tol: float
--            Tolerance in time used when finding the collapse.
--
--        norm_tol: float
--            Tolerance in norm used when finding the collapse.
--
--        norm_steps: int
--            Maximum number of tries to find the collapse.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        MultiTrajSolver.options.fset(self, new_options)
--
--    @classmethod
--    def avail_integrators(cls):
--        if cls is Solver:
--            return cls._avail_integrators.copy()
--        return {
--            **Solver.avail_integrators(),
--            **cls._avail_integrators,
--        }
-+__all__ = ['mcsolve', "MCSolver"]
-+
-+import warnings
-+
-+import numpy as np
-+from copy import copy
-+from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
-+from .multitraj import MultiTrajSolver
-+from .solver_base import Solver
-+from .result import McResult, Result
-+from .mesolve import mesolve, MESolver
-+import qutip.core.data as _data
-+from time import time
-+
-+
-+def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
-+            args=None, options=None, seeds=None, target_tol=None, timeout=None):
-+    r"""
-+    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
-+    given Hamiltonian and sets of collapse operators. Options for the
-+    underlying ODE solver are given by the Options class.
-+
-+    Parameters
-+    ----------
-+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
-+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
-+        ``H`` can also be a superoperator (liouvillian) if some collapse
-+        operators are to be treated deterministically.
-+
-+    state : :class:`qutip.Qobj`
-+        Initial state vector.
-+
-+    tlist : array_like
-+        Times at which results are recorded.
-+
-+    c_ops : list
-+        A ``list`` of collapse operators in any input type that QobjEvo accepts
-+        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
-+        even if ``H`` is a superoperator. If none are given, the solver will
-+        defer to ``sesolve`` or ``mesolve``.
-+
-+    e_ops : list, [optional]
-+        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
-+        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
-+        are given, the solver will default to save the states.
-+
-+    ntraj : int
-+        Maximum number of trajectories to run. Can be cut short if a time limit
-+        is passed with the ``timeout`` keyword or if the target tolerance is
-+        reached, see ``target_tol``.
-+
-+    args : None / dict
-+        Arguments for time-dependent Hamiltonian and collapse operator terms.
-+
-+    options : None / dict
-+        Dictionary of options for the solver.
-+
-+        - store_final_state : bool [False]
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, NoneType, [None]
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict, [{"chunk_size": 10}]
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
-+          Which differential equation integration method to use.
-+        - keep_runs_results : bool, [False]
-+          Whether to store results from all trajectories or just store the
-+          averages.
-+        - map : str {"serial", "parallel", "loky"}, ["serial"]
-+          How to run the trajectories. "parallel" uses concurent module to run
-+          in parallel while "loky" use the module of the same name to do so.
-+        - job_timeout : NoneType, int, [None]
-+          Maximum time to compute one trajectory.
-+        - num_cpus : NoneType, int, [None]
-+          Number of cpus to use when running in parallel. ``None`` detect the
-+          number of available cpus.
-+        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
-+          Parameters used to find the collapse location. ``norm_t_tol`` and
-+          ``norm_tol`` are the tolerance in time and norm respectively.
-+          An error will be raised if the collapse could not be found within
-+          ``norm_steps`` tries.
-+        - mc_corr_eps : float, [1e-10]
-+          Small number used to detect non-physical collapse caused by numerical
-+          imprecision.
-+        - atol, rtol : float, [1e-8, 1e-6]
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps : int [2500]
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - max_step : float, [0]
-+          Maximum lenght of one internal step. When using pulses, it should be
-+          less than half the width of the thinnest pulse.
-+
-+    seeds : int, SeedSequence, list, [optional]
-+        Seed for the random number generator. It can be a single seed used to
-+        spawn seeds for each trajectory or a list of seeds, one for each
-+        trajectory. Seeds are saved in the result and they can be reused with::
-+
-+            seeds=prev_result.seeds
-+
-+    target_tol : {float, tuple, list}, optional
-+        Target tolerance of the evolution. The evolution will compute
-+        trajectories until the error on the expectation values is lower than
-+        this tolerance. The maximum number of trajectories employed is
-+        given by ``ntraj``. The error is computed using jackknife resampling.
-+        ``target_tol`` can be an absolute tolerance or a pair of absolute and
-+        relative tolerance, in that order. Lastly, it can be a list of pairs of
-+        (atol, rtol) for each e_ops.
-+
-+    timeout : float [optional]
-+        Maximum time for the evolution in second. When reached, no more
-+        trajectories will be computed. Overwrite the option of the same name.
-+
-+    Returns
-+    -------
-+    results : :class:`qutip.solver.Result`
-+        Object storing all results from the simulation. Which results is saved
-+        depends on the presence of ``e_ops`` and the options used. ``collapse``
-+        and ``photocurrent`` is available to Monte Carlo simulation results.
-+
-+    .. note:
-+        The simulation will end when the first end condition is reached between
-+        ``ntraj``, ``timeout`` and ``target_tol``.
-+    """
-+    H = QobjEvo(H, args=args, tlist=tlist)
-+    if not isinstance(c_ops, (list, tuple)):
-+        c_ops = [c_ops]
-+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-+
-+    if len(c_ops) == 0:
-+        if options is None:
-+            options = {}
-+        options = {
-+            key: options[key]
-+            for key in options
-+            if key in MESolver.solver_options
-+        }
-+        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
-+                       options=options)
-+
-+    if isinstance(ntraj, (list, tuple)):
-+        raise TypeError(
-+            "ntraj must be an integer. "
-+            "A list of numbers is not longer supported."
-+        )
-+
-+    mc = MCSolver(H, c_ops, options=options)
-+    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
-+                    seed=seeds, target_tol=target_tol, timeout=timeout)
-+    return result
-+
-+
-+class MCIntegrator:
-+    """
-+    Integrator like object for mcsolve trajectory.
-+    """
-+    name = "mcsolve"
-+
-+    def __init__(self, integrator, c_ops, n_ops, options=None):
-+        self._integrator = integrator
-+        self._c_ops = c_ops
-+        self._n_ops = n_ops
-+        self.options = options
-+        self._generator = None
-+        self.method = f"{self.name} {self._integrator.method}"
-+        self._is_set = False
-+        self.issuper = c_ops[0].issuper
-+
-+    def set_state(self, t, state0, generator):
-+        """
-+        Set the state of the ODE solver.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Initial time
-+
-+        state0 : qutip.Data
-+            Initial state.
-+
-+        generator : numpy.random.generator
-+            Random number generator.
-+        """
-+        self.collapses = []
-+        self._generator = generator
-+        self.target_norm = self._generator.random()
-+        self._integrator.set_state(t, state0)
-+        self._is_set = True
-+
-+    def get_state(self, copy=True):
-+        return *self._integrator.get_state(copy), self._generator
-+
-+    def integrate(self, t, copy=False):
-+        t_old, y_old = self._integrator.get_state(copy=False)
-+        norm_old = self._prob_func(y_old)
-+        while t_old < t:
-+            t_step, state = self._integrator.mcstep(t, copy=False)
-+            norm = self._prob_func(state)
-+            if norm <= self.target_norm:
-+                t_col, state = self._find_collapse_time(norm_old, norm,
-+                                                        t_old, t_step)
-+                self._do_collapse(t_col, state)
-+                t_old, y_old = self._integrator.get_state(copy=False)
-+                norm_old = 1.
-+            else:
-+                t_old, y_old = t_step, state
-+                norm_old = norm
-+
-+        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
-+
-+    def run(self, tlist):
-+        for t in tlist[1:]:
-+            yield self.integrate(t, False)
-+
-+    def reset(self, hard=False):
-+        self._integrator.reset(hard)
-+
-+    def _prob_func(self, state):
-+        if self.issuper:
-+            return _data.trace_oper_ket(state).real
-+        return _data.norm.l2(state)**2
-+
-+    def _norm_func(self, state):
-+        if self.issuper:
-+            return _data.trace_oper_ket(state).real
-+        return _data.norm.l2(state)
-+
-+    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
-+        """Find the time of the collapse and state just before it."""
-+        tries = 0
-+        while tries < self.options['norm_steps']:
-+            tries += 1
-+            if (t_final - t_prev) < self.options['norm_t_tol']:
-+                t_guess = t_final
-+                _, state = self._integrator.get_state()
-+                break
-+            t_guess = (
-+                t_prev
-+                + ((t_final - t_prev)
-+                   * np.log(norm_old / self.target_norm)
-+                   / np.log(norm_old / norm))
-+            )
-+            if (t_guess - t_prev) < self.options['norm_t_tol']:
-+                t_guess = t_prev + self.options['norm_t_tol']
-+            _, state = self._integrator.mcstep(t_guess, copy=False)
-+            norm2_guess = self._prob_func(state)
-+            if (
-+                np.abs(self.target_norm - norm2_guess) <
-+                self.options['norm_tol'] * self.target_norm
-+            ):
-+                break
-+            elif (norm2_guess < self.target_norm):
-+                # t_guess is still > t_jump
-+                t_final = t_guess
-+                norm = norm2_guess
-+            else:
-+                # t_guess < t_jump
-+                t_prev = t_guess
-+                norm_old = norm2_guess
-+
-+        if tries >= self.options['norm_steps']:
-+            raise RuntimeError(
-+                "Could not find the collapse time within desired tolerance. "
-+                "Increase accuracy of the ODE solver or lower the tolerance "
-+                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
-+
-+        return t_guess, state
-+
-+    def _do_collapse(self, collapse_time, state):
-+        """
-+        Do the collapse:
-+        - Find which operator did the collapse.
-+        - Update the state and Integrator.
-+        - Next collapse norm location
-+        - Store collapse info.
-+        """
-+        # collapse_time, state is at the collapse
-+        if len(self._n_ops) == 1:
-+            which = 0
-+        else:
-+            probs = np.zeros(len(self._n_ops))
-+            for i, n_op in enumerate(self._n_ops):
-+                probs[i] = n_op.expect_data(collapse_time, state).real
-+            probs = np.cumsum(probs)
-+            which = np.searchsorted(probs,
-+                                    probs[-1] * self._generator.random())
-+
-+        state_new = self._c_ops[which].matmul_data(collapse_time, state)
-+        new_norm = self._norm_func(state_new)
-+        if new_norm < self.options['mc_corr_eps']:
-+            # This happen when the collapse is caused by numerical error
-+            state_new = _data.mul(state, 1 / self._norm_func(state))
-+        else:
-+            state_new = _data.mul(state_new, 1 / new_norm)
-+            self.collapses.append((collapse_time, which))
-+            self.target_norm = self._generator.random()
-+        self._integrator.set_state(collapse_time, state_new)
-+
-+    def arguments(self, args):
-+        if args:
-+            self._integrator.arguments(args)
-+            for c_op in self._c_ops:
-+                c_op.arguments(args)
-+            for n_op in self._n_ops:
-+                n_op.arguments(args)
-+
-+    @property
-+    def integrator_options(self):
-+        return self._integrator.integrator_options
-+
-+
-+# -----------------------------------------------------------------------------
-+# MONTE CARLO CLASS
-+# -----------------------------------------------------------------------------
-+class MCSolver(MultiTrajSolver):
-+    r"""
-+    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
-+    given Hamiltonian and sets of collapse operators. Options for the
-+    underlying ODE solver are given by the Options class.
-+
-+    Parameters
-+    ----------
-+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
-+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
-+        ``H`` can also be a superoperator (liouvillian) if some collapse
-+        operators are to be treated deterministically.
-+
-+    c_ops : list
-+        A ``list`` of collapse operators in any input type that QobjEvo accepts
-+        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
-+        even if ``H`` is a superoperator.
-+
-+    options : dict, [optional]
-+        Options for the evolution.
-+    """
-+    name = "mcsolve"
-+    resultclass = McResult
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size": 10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "keep_runs_results": False,
-+        "method": "adams",
-+        "map": "serial",
-+        "job_timeout": None,
-+        "num_cpus": None,
-+        "bitgenerator": None,
-+        "mc_corr_eps": 1e-10,
-+        "norm_steps": 5,
-+        "norm_t_tol": 1e-6,
-+        "norm_tol": 1e-4,
-+    }
-+
-+    def __init__(self, H, c_ops, *, options=None):
-+        _time_start = time()
-+
-+        if isinstance(c_ops, (Qobj, QobjEvo)):
-+            c_ops = [c_ops]
-+        c_ops = [QobjEvo(c_op) for c_op in c_ops]
-+
-+        if H.issuper:
-+            self._c_ops = [
-+                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
-+                for c_op in c_ops
-+            ]
-+            self._n_ops = self._c_ops
-+            rhs = QobjEvo(H)
-+            for c_op in c_ops:
-+                cdc = c_op.dag() @ c_op
-+                rhs -= 0.5 * (spre(cdc) + spost(cdc))
-+        else:
-+            self._c_ops = c_ops
-+            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
-+            rhs = -1j * QobjEvo(H)
-+            for n_op in self._n_ops:
-+                rhs -= 0.5 * n_op
-+
-+        self._num_collapse = len(self._c_ops)
-+
-+        super().__init__(rhs, options=options)
-+
-+    def _restore_state(self, data, *, copy=True):
-+        """
-+        Retore the Qobj state from its data.
-+        """
-+        if self._state_metadata['dims'] == self.rhs.dims[1]:
-+            state = Qobj(unstack_columns(data),
-+                         **self._state_metadata, copy=False)
-+        else:
-+            state = Qobj(data, **self._state_metadata, copy=copy)
-+
-+        return state
-+
-+    def _initialize_stats(self):
-+        stats = super()._initialize_stats()
-+        stats.update({
-+            "method": self.options["method"],
-+            "solver": "Master Equation Evolution",
-+            "num_collapse": self._num_collapse,
-+        })
-+        return stats
-+
-+    def _argument(self, args):
-+        self._integrator.arguments(args)
-+        self.rhs.arguments(args)
-+        for c_op in self._c_ops:
-+            c_op.arguments(args)
-+        for n_op in self._n_ops:
-+            n_op.arguments(args)
-+
-+    def _run_one_traj(self, seed, state, tlist, e_ops):
-+        """
-+        Run one trajectory and return the result.
-+        """
-+        # The integrators is reused, but non-reentrant. They are are fine for
-+        # multiprocessing, but will fail with multithreading.
-+        # If a thread base parallel map is created, eahc trajectory should use
-+        # a copy of the integrator.
-+        result = Result(e_ops, {**self.options, "normalize_output": False})
-+        generator = self._get_generator(seed)
-+        self._integrator.set_state(tlist[0], state, generator)
-+        result.add(tlist[0], self._restore_state(state, copy=False))
-+        for t in tlist[1:]:
-+            t, state = self._integrator.integrate(t, copy=False)
-+            result.add(t, self._restore_state(state, copy=False))
-+        result.collapse = self._integrator.collapses
-+        return seed, result
-+
-+    def _get_integrator(self):
-+        _time_start = time()
-+        method = self.options["method"]
-+        if method in self.avail_integrators():
-+            integrator = self.avail_integrators()[method]
-+        elif issubclass(method, Integrator):
-+            integrator = method
-+        else:
-+            raise ValueError("Integrator method not supported.")
-+        integrator_instance = integrator(self.rhs, self.options)
-+        mc_integrator = MCIntegrator(
-+            integrator_instance, self._c_ops, self._n_ops, self.options
-+        )
-+        self._init_integrator_time = time() - _time_start
-+        return mc_integrator
-+
-+    @property
-+    def options(self):
-+        """
-+        Options for monte carlo solver:
-+
-+        store_final_state: bool, default=False
-+            Whether or not to store the final state of the evolution in the
-+            result class.
-+
-+        store_states: bool, default=None
-+            Whether or not to store the state vectors or density matrices.
-+            On `None` the states will be saved if no expectation operators are
-+            given.
-+
-+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-+            How to present the solver progress.
-+            'tqdm' uses the python module of the same name and raise an error if
-+            not installed. Empty string or False will disable the bar.
-+
-+        progress_kwargs: dict, default={"chunk_size":10}
-+            Arguments to pass to the progress_bar. Qutip's bars use
-+            ``chunk_size``.
-+
-+        keep_runs_results: bool
-+          Whether to store results from all trajectories or just store the
-+          averages.
-+
-+        method: str, default="adams"
-+            Which ODE integrator methods are supported.
-+
-+        map: str {"serial", "parallel", "loky"}
-+            How to run the trajectories. "parallel" uses concurent module to
-+            run in parallel while "loky" use the module of the same name to do
-+            so.
-+
-+        job_timeout: None, int
-+            Maximum time to compute one trajectory.
-+
-+        num_cpus: None, int
-+            Number of cpus to use when running in parallel. ``None`` detect the
-+            number of available cpus.
-+
-+        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
-+            Which of numpy.random's bitgenerator to use. With ``None``, your
-+            numpy version's default is used.
-+
-+        mc_corr_eps: float
-+            Small number used to detect non-physical collapse caused by
-+            numerical imprecision.
-+
-+        norm_t_tol: float
-+            Tolerance in time used when finding the collapse.
-+
-+        norm_tol: float
-+            Tolerance in norm used when finding the collapse.
-+
-+        norm_steps: int
-+            Maximum number of tries to find the collapse.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        MultiTrajSolver.options.fset(self, new_options)
-+
-+    @classmethod
-+    def avail_integrators(cls):
-+        if cls is Solver:
-+            return cls._avail_integrators.copy()
-+        return {
-+            **Solver.avail_integrators(),
-+            **cls._avail_integrators,
-+        }
-diff --git a/qutip/solver/mesolve.py b/qutip/solver/mesolve.py
-index 5792038a..fb7ff5c7 100644
---- a/qutip/solver/mesolve.py
-+++ b/qutip/solver/mesolve.py
-@@ -1,217 +1,217 @@
--"""
--This module provides solvers for the Lindblad master equation and von Neumann
--equation.
--"""
--
--__all__ = ['mesolve', 'MESolver']
--
--import numpy as np
--from time import time
--from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
--from ..core import stack_columns, unstack_columns
--from ..core.data import to
--from .solver_base import Solver
--from .sesolve import sesolve, SESolver
--
--
--def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
--    """
--    Master equation evolution of a density matrix for a given Hamiltonian and
--    set of collapse operators, or a Liouvillian.
--
--    Evolve the state vector or density matrix (`rho0`) using a given
--    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
--    (`c_ops`), by integrating the set of ordinary differential equations
--    that define the system. In the absence of collapse operators the system is
--    evolved according to the unitary evolution of the Hamiltonian.
--
--    The output is either the state vector at arbitrary points in time
--    (`tlist`), or the expectation values of the supplied operators
--    (`e_ops`). If e_ops is a callback function, it is invoked for each
--    time in `tlist` with time and the state as arguments, and the function
--    does not use any return values.
--
--    If either `H` or the Qobj elements in `c_ops` are superoperators, they
--    will be treated as direct contributions to the total system Liouvillian.
--    This allows the solution of master equations that are not in standard
--    Lindblad form.
--
--    **Time-dependent operators**
--
--    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
--    object that can be interpreted as :class:`QobjEvo` such as a list of
--    (Qobj, Coefficient) pairs or a function.
--
--    **Additional options**
--
--    Additional options to mesolve can be set via the `options` argument. Many
--    ODE integration options can be set this way, and the `store_states` and
--    `store_final_state` options can be used to store states even though
--    expectation values are requested via the `e_ops` argument.
--
--    .. note::
--
--        When no collapse operator are given and the `H` is not a superoperator,
--        it will defer to :func:`sesolve`.
--
--    Parameters
--    ----------
--
--    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    rho0 : :class:`Qobj`
--        initial density matrix or state vector (ket).
--
--    tlist : *list* / *array*
--        list of times for :math:`t`.
--
--    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
--        Single collapse operator, or list of collapse operators, or a list
--        of Liouvillian superoperators. None is equivalent to an empty list.
--
--    e_ops : list of :class:`Qobj` / callback function
--        Single operator or list of operators for which to evaluate
--        expectation values or callable or list of callable.
--        Callable signature must be, `f(t: float, state: Qobj)`.
--        See :func:`expect` for more detail of operator expectation.
--
--    args : None / *dictionary*
--        dictionary of parameters for time-dependent Hamiltonians and
--        collapse operators.
--
--    options : None / dict
--        Dictionary of options for the solver.
--
--        - store_final_state : bool
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, None
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - normalize_output : bool
--          Normalize output state to hide ODE numerical errors.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
--          Which differential equation integration method to use.
--        - atol, rtol : float
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps :
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - max_step : float, 0
--          Maximum lenght of one internal step. When using pulses, it should be
--          less than half the width of the thinnest pulse.
--
--        Other options could be supported depending on the integration method,
--        see `Integrator <./classes.html#classes-ode>`_.
--
--    Returns
--    -------
--    result: :class:`qutip.Result`
--
--        An instance of the class :class:`qutip.Result`, which contains
--        a *list of array* `result.expect` of expectation values for the times
--        specified by `tlist`, and/or a *list* `result.states` of state vectors
--        or density matrices corresponding to the times in `tlist` [if `e_ops`
--        is an empty list of `store_states=True` in options].
--
--    """
--    H = QobjEvo(H, args=args, tlist=tlist)
--
--    c_ops = c_ops if c_ops is not None else []
--    if not isinstance(c_ops, (list, tuple)):
--        c_ops = [c_ops]
--    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
--
--    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
--
--    if not use_mesolve:
--        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
--                       options=options)
--
--    solver = MESolver(H, c_ops, options=options)
--
--    return solver.run(rho0, tlist, e_ops=e_ops)
--
--
--class MESolver(SESolver):
--    """
--    Master equation evolution of a density matrix for a given Hamiltonian and
--    set of collapse operators, or a Liouvillian.
--
--    Evolve the density matrix (`rho0`) using a given
--    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
--    (`c_ops`), by integrating the set of ordinary differential equations
--    that define the system.
--
--    If either `H` or the Qobj elements in `c_ops` are superoperators, they
--    will be treated as direct contributions to the total system Liouvillian.
--    This allows the solution of master equations that are not in standard
--    Lindblad form.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
--        can be made into :class:`QobjEvo` are also accepted.
--
--    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
--        Single collapse operator, or list of collapse operators, or a list
--        of Liouvillian superoperators. None is equivalent to an empty list.
--
--    options : dict, optional
--        Options for the solver, see :obj:`MESolver.options` and
--        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
--
--    attributes
--    ----------
--    stats: dict
--        Diverse diagnostic statistics of the evolution.
--    """
--    name = "mesolve"
--    _avail_integrators = {}
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size":10},
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": True,
--        'method': 'adams',
--    }
--
--    def __init__(self, H, c_ops=None, *, options=None):
--        _time_start = time()
--
--        if not isinstance(H, (Qobj, QobjEvo)):
--            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
--        c_ops = c_ops or []
--        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
--        for c_op in c_ops:
--            if not isinstance(c_op, (Qobj, QobjEvo)):
--                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
--
--        self._num_collapse = len(c_ops)
--
--        rhs = H if H.issuper else liouvillian(H)
--        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
--                   for c_op in c_ops)
--
--        Solver.__init__(self, rhs, options=options)
--
--    def _initialize_stats(self):
--        stats = super()._initialize_stats()
--        stats.update({
--            "solver": "Master Equation Evolution",
--            "num_collapse": self._num_collapse,
--        })
--        return stats
-+"""
-+This module provides solvers for the Lindblad master equation and von Neumann
-+equation.
-+"""
-+
-+__all__ = ['mesolve', 'MESolver']
-+
-+import numpy as np
-+from time import time
-+from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
-+from ..core import stack_columns, unstack_columns
-+from ..core.data import to
-+from .solver_base import Solver
-+from .sesolve import sesolve, SESolver
-+
-+
-+def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
-+    """
-+    Master equation evolution of a density matrix for a given Hamiltonian and
-+    set of collapse operators, or a Liouvillian.
-+
-+    Evolve the state vector or density matrix (`rho0`) using a given
-+    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
-+    (`c_ops`), by integrating the set of ordinary differential equations
-+    that define the system. In the absence of collapse operators the system is
-+    evolved according to the unitary evolution of the Hamiltonian.
-+
-+    The output is either the state vector at arbitrary points in time
-+    (`tlist`), or the expectation values of the supplied operators
-+    (`e_ops`). If e_ops is a callback function, it is invoked for each
-+    time in `tlist` with time and the state as arguments, and the function
-+    does not use any return values.
-+
-+    If either `H` or the Qobj elements in `c_ops` are superoperators, they
-+    will be treated as direct contributions to the total system Liouvillian.
-+    This allows the solution of master equations that are not in standard
-+    Lindblad form.
-+
-+    **Time-dependent operators**
-+
-+    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
-+    object that can be interpreted as :class:`QobjEvo` such as a list of
-+    (Qobj, Coefficient) pairs or a function.
-+
-+    **Additional options**
-+
-+    Additional options to mesolve can be set via the `options` argument. Many
-+    ODE integration options can be set this way, and the `store_states` and
-+    `store_final_state` options can be used to store states even though
-+    expectation values are requested via the `e_ops` argument.
-+
-+    .. note::
-+
-+        When no collapse operator are given and the `H` is not a superoperator,
-+        it will defer to :func:`sesolve`.
-+
-+    Parameters
-+    ----------
-+
-+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    rho0 : :class:`Qobj`
-+        initial density matrix or state vector (ket).
-+
-+    tlist : *list* / *array*
-+        list of times for :math:`t`.
-+
-+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
-+        Single collapse operator, or list of collapse operators, or a list
-+        of Liouvillian superoperators. None is equivalent to an empty list.
-+
-+    e_ops : list of :class:`Qobj` / callback function
-+        Single operator or list of operators for which to evaluate
-+        expectation values or callable or list of callable.
-+        Callable signature must be, `f(t: float, state: Qobj)`.
-+        See :func:`expect` for more detail of operator expectation.
-+
-+    args : None / *dictionary*
-+        dictionary of parameters for time-dependent Hamiltonians and
-+        collapse operators.
-+
-+    options : None / dict
-+        Dictionary of options for the solver.
-+
-+        - store_final_state : bool
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, None
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - normalize_output : bool
-+          Normalize output state to hide ODE numerical errors.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-+          Which differential equation integration method to use.
-+        - atol, rtol : float
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps :
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - max_step : float, 0
-+          Maximum lenght of one internal step. When using pulses, it should be
-+          less than half the width of the thinnest pulse.
-+
-+        Other options could be supported depending on the integration method,
-+        see `Integrator <./classes.html#classes-ode>`_.
-+
-+    Returns
-+    -------
-+    result: :class:`qutip.Result`
-+
-+        An instance of the class :class:`qutip.Result`, which contains
-+        a *list of array* `result.expect` of expectation values for the times
-+        specified by `tlist`, and/or a *list* `result.states` of state vectors
-+        or density matrices corresponding to the times in `tlist` [if `e_ops`
-+        is an empty list of `store_states=True` in options].
-+
-+    """
-+    H = QobjEvo(H, args=args, tlist=tlist)
-+
-+    c_ops = c_ops if c_ops is not None else []
-+    if not isinstance(c_ops, (list, tuple)):
-+        c_ops = [c_ops]
-+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-+
-+    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
-+
-+    if not use_mesolve:
-+        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
-+                       options=options)
-+
-+    solver = MESolver(H, c_ops, options=options)
-+
-+    return solver.run(rho0, tlist, e_ops=e_ops)
-+
-+
-+class MESolver(SESolver):
-+    """
-+    Master equation evolution of a density matrix for a given Hamiltonian and
-+    set of collapse operators, or a Liouvillian.
-+
-+    Evolve the density matrix (`rho0`) using a given
-+    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
-+    (`c_ops`), by integrating the set of ordinary differential equations
-+    that define the system.
-+
-+    If either `H` or the Qobj elements in `c_ops` are superoperators, they
-+    will be treated as direct contributions to the total system Liouvillian.
-+    This allows the solution of master equations that are not in standard
-+    Lindblad form.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
-+        can be made into :class:`QobjEvo` are also accepted.
-+
-+    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
-+        Single collapse operator, or list of collapse operators, or a list
-+        of Liouvillian superoperators. None is equivalent to an empty list.
-+
-+    options : dict, optional
-+        Options for the solver, see :obj:`MESolver.options` and
-+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-+
-+    attributes
-+    ----------
-+    stats: dict
-+        Diverse diagnostic statistics of the evolution.
-+    """
-+    name = "mesolve"
-+    _avail_integrators = {}
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size":10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": True,
-+        'method': 'adams',
-+    }
-+
-+    def __init__(self, H, c_ops=None, *, options=None):
-+        _time_start = time()
-+
-+        if not isinstance(H, (Qobj, QobjEvo)):
-+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-+        c_ops = c_ops or []
-+        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
-+        for c_op in c_ops:
-+            if not isinstance(c_op, (Qobj, QobjEvo)):
-+                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
-+
-+        self._num_collapse = len(c_ops)
-+
-+        rhs = H if H.issuper else liouvillian(H)
-+        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
-+                   for c_op in c_ops)
-+
-+        Solver.__init__(self, rhs, options=options)
-+
-+    def _initialize_stats(self):
-+        stats = super()._initialize_stats()
-+        stats.update({
-+            "solver": "Master Equation Evolution",
-+            "num_collapse": self._num_collapse,
-+        })
-+        return stats
-diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
-index 204178d1..3123c72e 100644
---- a/qutip/solver/multitraj.py
-+++ b/qutip/solver/multitraj.py
-@@ -1,257 +1,257 @@
--from .. import Qobj, QobjEvo
--from .result import Result, MultiTrajResult
--from .parallel import _get_map
--from time import time
--from .solver_base import Solver
--import numpy as np
--from copy import copy
--
--__all__ = ["MultiTrajSolver", "TrajectorySolver"]
--
--
--class MultiTrajSolver(Solver):
--    """
--    Basic class for multi-trajectory evolutions.
--
--    As :class:`Solver` it can ``run`` or ``step`` evolution.
--    It manages the random seed for each trajectory.
--
--    The actual evolution is done by a single trajectory solver::
--        ``_traj_solver_class``
--
--    Parameters
--    ----------
--    rhs : Qobj, QobjEvo
--        Right hand side of the evolution::
--            d state / dt = rhs @ state
--
--    options : dict
--        Options for the solver.
--    """
--    name = "generic multi trajectory"
--    resultclass = MultiTrajResult
--    _avail_integrators = {}
--
--    # Class of option used by the solver
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size": 10},
--        "store_final_state": False,
--        "store_states": None,
--        "keep_runs_results": False,
--        "normalize_output": False,
--        "method": "",
--        "map": "serial",
--        "job_timeout": None,
--        "num_cpus": None,
--        "bitgenerator": None,
--    }
--
--    def __init__(self, rhs, *, options=None):
--        self.rhs = rhs
--        self.options = options
--        self.seed_sequence = np.random.SeedSequence()
--        self._integrator = self._get_integrator()
--        self._state_metadata = {}
--        self.stats = self._initialize_stats()
--
--    def start(self, state, t0, seed=None):
--        """
--        Set the initial state and time for a step evolution.
--
--        Parameters
--        ----------
--        state : :class:`Qobj`
--            Initial state of the evolution.
--
--        t0 : double
--            Initial time of the evolution.
--
--        seed : int, SeedSequence, list, {None}
--            Seed for the random number generator. It can be a single seed used
--            to spawn seeds for each trajectory or a list of seed, one for each
--            trajectory.
--
--        ..note ::
--            When using step evolution, only one trajectory can be computed at
--            once.
--        """
--        seeds = self._read_seed(seed, 1)
--        generator = self._get_generator(seeds[0])
--        self._integrator.set_state(t0, self._prepare_state(state), generator)
--
--    def step(self, t, *, args=None, copy=True):
--        """
--        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
--
--        Parameters
--        ----------
--        t : double
--            Time to evolve to, must be higher than the last call.
--
--        args : dict, optional {None}
--            Update the ``args`` of the system.
--            The change is effective from the beginning of the interval.
--            Changing ``args`` can slow the evolution.
--
--        copy : bool, optional {True}
--            Whether to return a copy of the data or the data in the ODE solver.
--        """
--        if not self._integrator._is_set:
--            raise RuntimeError("The `start` method must called first.")
--        self._argument(args)
--        _, state = self._integrator.integrate(t, copy=False)
--        return self._restore_state(state, copy=copy)
--
--    def run(self, state, tlist, ntraj=1, *,
--            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
--        """
--        Do the evolution of the Quantum system.
--
--        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
--        ``rhs`` and for each time in ``tlist`` store the state and/or
--        expectation values in a :cls:`Result`. The evolution method and stored
--        results are determined by ``options``.
--
--        Parameters
--        ----------
--        state : :class:`Qobj`
--            Initial state of the evolution.
--
--        tlist : list of double
--            Time for which to save the results (state and/or expect) of the
--            evolution. The first element of the list is the initial time of the
--            evolution. Time in the list must be in increasing order, but does
--            not need to be uniformly distributed.
--
--        ntraj : int
--            Number of trajectories to add.
--
--        args : dict, optional {None}
--            Change the ``args`` of the rhs for the evolution.
--
--        e_ops : list
--            list of Qobj or QobjEvo to compute the expectation values.
--            Alternatively, function[s] with the signature f(t, state) -> expect
--            can be used.
--
--        timeout : float, optional [1e8]
--            Maximum time in seconds for the trajectories to run. Once this time
--            is reached, the simulation will end even if the number
--            of trajectories is less than ``ntraj``. The map function, set in
--            options, can interupt the running trajectory or wait for it to
--            finish. Set to an arbitrary high number to disable.
--
--        target_tol : {float, tuple, list}, optional [None]
--            Target tolerance of the evolution. The evolution will compute
--            trajectories until the error on the expectation values is lower
--            than this tolerance. The maximum number of trajectories employed is
--            given by ``ntraj``. The error is computed using jackknife
--            resampling. ``target_tol`` can be an absolute tolerance or a pair
--            of absolute and relative tolerance, in that order. Lastly, it can
--            be a list of pairs of (atol, rtol) for each e_ops.
--
--        seed : {int, SeedSequence, list} optional
--            Seed or list of seeds for each trajectories.
--
--        Return
--        ------
--        results : :class:`qutip.solver.MultiTrajResult`
--            Results of the evolution. States and/or expect will be saved. You
--            can control the saved data in the options.
--
--        .. note:
--            The simulation will end when the first end condition is reached
--            between ``ntraj``, ``timeout`` and ``target_tol``.
--        """
--        start_time = time()
--        self._argument(args)
--        stats = self._initialize_stats()
--        seeds = self._read_seed(seed, ntraj)
--
--        result = self.resultclass(
--            e_ops, self.options, solver=self.name, stats=stats
--        )
--        result.add_end_condition(ntraj, target_tol)
--
--        map_func = _get_map[self.options['map']]
--        map_kw = {
--            'timeout': timeout,
--            'job_timeout': self.options['job_timeout'],
--            'num_cpus': self.options['num_cpus'],
--        }
--        state0 = self._prepare_state(state)
--        stats['preparation time'] += time() - start_time
--
--        start_time = time()
--        map_func(
--            self._run_one_traj, seeds,
--            (state0, tlist, e_ops),
--            reduce_func=result.add, map_kw=map_kw,
--            progress_bar=self.options["progress_bar"],
--            progress_bar_kwargs=self.options["progress_kwargs"]
--        )
--        result.stats['run time'] = time() - start_time
--        return result
--
--    def _run_one_traj(self, seed, state, tlist, e_ops):
--        """
--        Run one trajectory and return the result.
--        """
--        result = Result(e_ops, self.options)
--        generator = self._get_generator(seed)
--        self._integrator.set_state(tlist[0], state, generator)
--        result.add(tlist[0], self._restore_state(state, copy=False))
--        for t in tlist[1:]:
--            t, state = self._integrator.step(t, copy=False)
--            result.add(t, self._restore_state(state, copy=False))
--        return seed, result
--
--    def _read_seed(self, seed, ntraj):
--        """
--        Read user provided seed(s) and produce one for each trajectory.
--        Let numpy raise error for inputs that cannot be seeds.
--        """
--        if seed is None:
--            seeds = self.seed_sequence.spawn(ntraj)
--        elif isinstance(seed, np.random.SeedSequence):
--            seeds = seed.spawn(ntraj)
--        elif not isinstance(seed, list):
--            seeds = np.random.SeedSequence(seed).spawn(ntraj)
--        elif len(seed) >= ntraj:
--            seeds = [
--                seed_ if (isinstance(seed_, np.random.SeedSequence)
--                          or hasattr(seed_, 'random'))
--                else np.random.SeedSequence(seed_)
--                for seed_ in seed[:ntraj]
--            ]
--        else:
--            raise ValueError("A seed list must be longer than ntraj")
--        return seeds
--
--    def _argument(self, args):
--        """Update the args, for the `rhs` and `c_ops` and other operators."""
--        if args:
--            self.rhs.arguments(args)
--
--    def _get_generator(self, seed):
--        """
--        Read the seed and create the random number generator.
--        If the ``seed`` has a ``random`` method, it will be used as the
--        generator.
--        """
--        if hasattr(seed, 'random'):
--            # We check for the method, not the type to accept pseudo non-random
--            # generator for debug/testing purpose.
--            return seed
--
--        if self.options['bitgenerator']:
--            bit_gen = getattr(np.random, self.options['bitgenerator'])
--            generator = np.random.Generator(bit_gen(seed))
--        else:
--            generator = np.random.default_rng(seed)
--        return generator
--
--    @classmethod
--    def avail_integrators(cls):
--        return cls._avail_integrators
-+from .. import Qobj, QobjEvo
-+from .result import Result, MultiTrajResult
-+from .parallel import _get_map
-+from time import time
-+from .solver_base import Solver
-+import numpy as np
-+from copy import copy
-+
-+__all__ = ["MultiTrajSolver", "TrajectorySolver"]
-+
-+
-+class MultiTrajSolver(Solver):
-+    """
-+    Basic class for multi-trajectory evolutions.
-+
-+    As :class:`Solver` it can ``run`` or ``step`` evolution.
-+    It manages the random seed for each trajectory.
-+
-+    The actual evolution is done by a single trajectory solver::
-+        ``_traj_solver_class``
-+
-+    Parameters
-+    ----------
-+    rhs : Qobj, QobjEvo
-+        Right hand side of the evolution::
-+            d state / dt = rhs @ state
-+
-+    options : dict
-+        Options for the solver.
-+    """
-+    name = "generic multi trajectory"
-+    resultclass = MultiTrajResult
-+    _avail_integrators = {}
-+
-+    # Class of option used by the solver
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size": 10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "keep_runs_results": False,
-+        "normalize_output": False,
-+        "method": "",
-+        "map": "serial",
-+        "job_timeout": None,
-+        "num_cpus": None,
-+        "bitgenerator": None,
-+    }
-+
-+    def __init__(self, rhs, *, options=None):
-+        self.rhs = rhs
-+        self.options = options
-+        self.seed_sequence = np.random.SeedSequence()
-+        self._integrator = self._get_integrator()
-+        self._state_metadata = {}
-+        self.stats = self._initialize_stats()
-+
-+    def start(self, state, t0, seed=None):
-+        """
-+        Set the initial state and time for a step evolution.
-+
-+        Parameters
-+        ----------
-+        state : :class:`Qobj`
-+            Initial state of the evolution.
-+
-+        t0 : double
-+            Initial time of the evolution.
-+
-+        seed : int, SeedSequence, list, {None}
-+            Seed for the random number generator. It can be a single seed used
-+            to spawn seeds for each trajectory or a list of seed, one for each
-+            trajectory.
-+
-+        ..note ::
-+            When using step evolution, only one trajectory can be computed at
-+            once.
-+        """
-+        seeds = self._read_seed(seed, 1)
-+        generator = self._get_generator(seeds[0])
-+        self._integrator.set_state(t0, self._prepare_state(state), generator)
-+
-+    def step(self, t, *, args=None, copy=True):
-+        """
-+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-+
-+        Parameters
-+        ----------
-+        t : double
-+            Time to evolve to, must be higher than the last call.
-+
-+        args : dict, optional {None}
-+            Update the ``args`` of the system.
-+            The change is effective from the beginning of the interval.
-+            Changing ``args`` can slow the evolution.
-+
-+        copy : bool, optional {True}
-+            Whether to return a copy of the data or the data in the ODE solver.
-+        """
-+        if not self._integrator._is_set:
-+            raise RuntimeError("The `start` method must called first.")
-+        self._argument(args)
-+        _, state = self._integrator.integrate(t, copy=False)
-+        return self._restore_state(state, copy=copy)
-+
-+    def run(self, state, tlist, ntraj=1, *,
-+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
-+        """
-+        Do the evolution of the Quantum system.
-+
-+        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
-+        ``rhs`` and for each time in ``tlist`` store the state and/or
-+        expectation values in a :cls:`Result`. The evolution method and stored
-+        results are determined by ``options``.
-+
-+        Parameters
-+        ----------
-+        state : :class:`Qobj`
-+            Initial state of the evolution.
-+
-+        tlist : list of double
-+            Time for which to save the results (state and/or expect) of the
-+            evolution. The first element of the list is the initial time of the
-+            evolution. Time in the list must be in increasing order, but does
-+            not need to be uniformly distributed.
-+
-+        ntraj : int
-+            Number of trajectories to add.
-+
-+        args : dict, optional {None}
-+            Change the ``args`` of the rhs for the evolution.
-+
-+        e_ops : list
-+            list of Qobj or QobjEvo to compute the expectation values.
-+            Alternatively, function[s] with the signature f(t, state) -> expect
-+            can be used.
-+
-+        timeout : float, optional [1e8]
-+            Maximum time in seconds for the trajectories to run. Once this time
-+            is reached, the simulation will end even if the number
-+            of trajectories is less than ``ntraj``. The map function, set in
-+            options, can interupt the running trajectory or wait for it to
-+            finish. Set to an arbitrary high number to disable.
-+
-+        target_tol : {float, tuple, list}, optional [None]
-+            Target tolerance of the evolution. The evolution will compute
-+            trajectories until the error on the expectation values is lower
-+            than this tolerance. The maximum number of trajectories employed is
-+            given by ``ntraj``. The error is computed using jackknife
-+            resampling. ``target_tol`` can be an absolute tolerance or a pair
-+            of absolute and relative tolerance, in that order. Lastly, it can
-+            be a list of pairs of (atol, rtol) for each e_ops.
-+
-+        seed : {int, SeedSequence, list} optional
-+            Seed or list of seeds for each trajectories.
-+
-+        Return
-+        ------
-+        results : :class:`qutip.solver.MultiTrajResult`
-+            Results of the evolution. States and/or expect will be saved. You
-+            can control the saved data in the options.
-+
-+        .. note:
-+            The simulation will end when the first end condition is reached
-+            between ``ntraj``, ``timeout`` and ``target_tol``.
-+        """
-+        start_time = time()
-+        self._argument(args)
-+        stats = self._initialize_stats()
-+        seeds = self._read_seed(seed, ntraj)
-+
-+        result = self.resultclass(
-+            e_ops, self.options, solver=self.name, stats=stats
-+        )
-+        result.add_end_condition(ntraj, target_tol)
-+
-+        map_func = _get_map[self.options['map']]
-+        map_kw = {
-+            'timeout': timeout,
-+            'job_timeout': self.options['job_timeout'],
-+            'num_cpus': self.options['num_cpus'],
-+        }
-+        state0 = self._prepare_state(state)
-+        stats['preparation time'] += time() - start_time
-+
-+        start_time = time()
-+        map_func(
-+            self._run_one_traj, seeds,
-+            (state0, tlist, e_ops),
-+            reduce_func=result.add, map_kw=map_kw,
-+            progress_bar=self.options["progress_bar"],
-+            progress_bar_kwargs=self.options["progress_kwargs"]
-+        )
-+        result.stats['run time'] = time() - start_time
-+        return result
-+
-+    def _run_one_traj(self, seed, state, tlist, e_ops):
-+        """
-+        Run one trajectory and return the result.
-+        """
-+        result = Result(e_ops, self.options)
-+        generator = self._get_generator(seed)
-+        self._integrator.set_state(tlist[0], state, generator)
-+        result.add(tlist[0], self._restore_state(state, copy=False))
-+        for t in tlist[1:]:
-+            t, state = self._integrator.step(t, copy=False)
-+            result.add(t, self._restore_state(state, copy=False))
-+        return seed, result
-+
-+    def _read_seed(self, seed, ntraj):
-+        """
-+        Read user provided seed(s) and produce one for each trajectory.
-+        Let numpy raise error for inputs that cannot be seeds.
-+        """
-+        if seed is None:
-+            seeds = self.seed_sequence.spawn(ntraj)
-+        elif isinstance(seed, np.random.SeedSequence):
-+            seeds = seed.spawn(ntraj)
-+        elif not isinstance(seed, list):
-+            seeds = np.random.SeedSequence(seed).spawn(ntraj)
-+        elif len(seed) >= ntraj:
-+            seeds = [
-+                seed_ if (isinstance(seed_, np.random.SeedSequence)
-+                          or hasattr(seed_, 'random'))
-+                else np.random.SeedSequence(seed_)
-+                for seed_ in seed[:ntraj]
-+            ]
-+        else:
-+            raise ValueError("A seed list must be longer than ntraj")
-+        return seeds
-+
-+    def _argument(self, args):
-+        """Update the args, for the `rhs` and `c_ops` and other operators."""
-+        if args:
-+            self.rhs.arguments(args)
-+
-+    def _get_generator(self, seed):
-+        """
-+        Read the seed and create the random number generator.
-+        If the ``seed`` has a ``random`` method, it will be used as the
-+        generator.
-+        """
-+        if hasattr(seed, 'random'):
-+            # We check for the method, not the type to accept pseudo non-random
-+            # generator for debug/testing purpose.
-+            return seed
-+
-+        if self.options['bitgenerator']:
-+            bit_gen = getattr(np.random, self.options['bitgenerator'])
-+            generator = np.random.Generator(bit_gen(seed))
-+        else:
-+            generator = np.random.default_rng(seed)
-+        return generator
-+
-+    @classmethod
-+    def avail_integrators(cls):
-+        return cls._avail_integrators
-diff --git a/qutip/solver/options.py b/qutip/solver/options.py
-index 207fa897..737724b9 100644
---- a/qutip/solver/options.py
-+++ b/qutip/solver/options.py
-@@ -1,106 +1,106 @@
--__all__ = ["Options", "SolverOptions"]
--
--import warnings
--
--
--def SolverOptions(*args, **kwargs):
--    warnings.warn(
--        "Dedicated options class are no longer needed, "
--        "options should be passed as dict to solvers.",
--        FutureWarning
--    )
--    return kwargs
--
--
--def Options(**kwargs):
--    warnings.warn(
--        "Dedicated options class are no longer needed, "
--        "options should be passed as dict to solvers.",
--        FutureWarning
--    )
--    return kwargs
--
--
--class _SolverOptions(dict):
--    """
--    Class to hold options for solver and integrator.
--
--    Parameters
--    ----------
--    default : dict
--        Default dict, only keys in this will be accepted.
--    feedback : callable, ``f(keys : set) -> None``, optional
--        Function to called when an item is updated.
--    name : str, optional
--        Name of the solver or integrator that use this. Used in __repr__ only.
--    doc : str, optional
--        Overwrite the __doc__ of the instance.
--    """
--    def __init__(
--        self, default, feedback=None, name="", doc="", /, **kwargs
--    ):
--        self._default = default
--        self.__doc__ = doc
--        self._feedback = feedback
--        self._name = name
--        extra_keys = kwargs.keys() - default.keys()
--        if extra_keys:
--            raise KeyError(f"Options {extra_keys} are not supported.")
--        super().__init__(**{**self._default, **kwargs})
--
--    def __setitem__(self, key, val):
--        if key not in self._default:
--            raise KeyError(f"Options {key} is not supported.")
--        if val is None:
--            val = self._default[key]
--        if val == self[key]:
--            return
--        super().__setitem__(key, val)
--        if self._feedback:
--            self._feedback(key)
--
--    def __delitem__(self, key):
--        if key not in self._default:
--            raise KeyError(f"Options {key} is not supported.")
--        super().__setitem__(key, self._default[key])
--        if self._feedback:
--            self._feedback(key)
--
--    def copy(self):
--        return self.__class__(
--            self._default,
--            self._feedback,
--            self._name,
--            self.__doc__,
--            **self
--        )
--
--    def __str__(self):
--        lines = []
--        longest = max(len(key) for key in self.keys())
--        lines.append(f"Options for {self._name}:")
--        for key in self.keys():
--            default = "(default)" if self[key] == self._default[key] else ""
--            lines.append(f"    {key:{longest}} : "
--                         f"{self[key].__repr__():{70-longest}}"
--                         f"{default}")
--        return "\n".join(lines)
--
--    @classmethod
--    def _from_reduced(cls, default, feedback, name, doc, keys, args):
--        return cls(default, feedback, name, doc, **{
--            key: arg for key, arg in zip(keys, args)
--        })
--
--    def __reduce__(self):
--        return (
--            self._from_reduced,
--            (
--                self._default,
--                self._feedback,
--                self._name,
--                self.__doc__,
--                tuple(self.keys()),
--                tuple(self.values())
--                )
--            )
-+__all__ = ["Options", "SolverOptions"]
-+
-+import warnings
-+
-+
-+def SolverOptions(*args, **kwargs):
-+    warnings.warn(
-+        "Dedicated options class are no longer needed, "
-+        "options should be passed as dict to solvers.",
-+        FutureWarning
-+    )
-+    return kwargs
-+
-+
-+def Options(**kwargs):
-+    warnings.warn(
-+        "Dedicated options class are no longer needed, "
-+        "options should be passed as dict to solvers.",
-+        FutureWarning
-+    )
-+    return kwargs
-+
-+
-+class _SolverOptions(dict):
-+    """
-+    Class to hold options for solver and integrator.
-+
-+    Parameters
-+    ----------
-+    default : dict
-+        Default dict, only keys in this will be accepted.
-+    feedback : callable, ``f(keys : set) -> None``, optional
-+        Function to called when an item is updated.
-+    name : str, optional
-+        Name of the solver or integrator that use this. Used in __repr__ only.
-+    doc : str, optional
-+        Overwrite the __doc__ of the instance.
-+    """
-+    def __init__(
-+        self, default, feedback=None, name="", doc="", /, **kwargs
-+    ):
-+        self._default = default
-+        self.__doc__ = doc
-+        self._feedback = feedback
-+        self._name = name
-+        extra_keys = kwargs.keys() - default.keys()
-+        if extra_keys:
-+            raise KeyError(f"Options {extra_keys} are not supported.")
-+        super().__init__(**{**self._default, **kwargs})
-+
-+    def __setitem__(self, key, val):
-+        if key not in self._default:
-+            raise KeyError(f"Options {key} is not supported.")
-+        if val is None:
-+            val = self._default[key]
-+        if val == self[key]:
-+            return
-+        super().__setitem__(key, val)
-+        if self._feedback:
-+            self._feedback(key)
-+
-+    def __delitem__(self, key):
-+        if key not in self._default:
-+            raise KeyError(f"Options {key} is not supported.")
-+        super().__setitem__(key, self._default[key])
-+        if self._feedback:
-+            self._feedback(key)
-+
-+    def copy(self):
-+        return self.__class__(
-+            self._default,
-+            self._feedback,
-+            self._name,
-+            self.__doc__,
-+            **self
-+        )
-+
-+    def __str__(self):
-+        lines = []
-+        longest = max(len(key) for key in self.keys())
-+        lines.append(f"Options for {self._name}:")
-+        for key in self.keys():
-+            default = "(default)" if self[key] == self._default[key] else ""
-+            lines.append(f"    {key:{longest}} : "
-+                         f"{self[key].__repr__():{70-longest}}"
-+                         f"{default}")
-+        return "\n".join(lines)
-+
-+    @classmethod
-+    def _from_reduced(cls, default, feedback, name, doc, keys, args):
-+        return cls(default, feedback, name, doc, **{
-+            key: arg for key, arg in zip(keys, args)
-+        })
-+
-+    def __reduce__(self):
-+        return (
-+            self._from_reduced,
-+            (
-+                self._default,
-+                self._feedback,
-+                self._name,
-+                self.__doc__,
-+                tuple(self.keys()),
-+                tuple(self.values())
-+                )
-+            )
-diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
-index 4ceeb0fc..2c41fb7c 100644
---- a/qutip/solver/parallel.py
-+++ b/qutip/solver/parallel.py
-@@ -1,370 +1,370 @@
--"""
--This module provides functions for parallel execution of loops and function
--mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
--"""
--__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
--
--import multiprocessing
--import os
--import sys
--import time
--import threading
--import concurrent.futures
--from qutip.ui.progressbar import progess_bars
--from qutip.settings import available_cpu_count
--
--if sys.platform == 'darwin':
--    mp_context = multiprocessing.get_context('fork')
--elif sys.platform == 'linux':
--    # forkserver would handle threads better, but is much slower at starting
--    # the executor and spawning tasks
--    mp_context = multiprocessing.get_context('fork')
--else:
--    mp_context = multiprocessing.get_context()
--
--
--default_map_kw = {
--    'job_timeout': threading.TIMEOUT_MAX,
--    'timeout': threading.TIMEOUT_MAX,
--    'num_cpus': available_cpu_count(),
--    'fail_fast': True,
--}
--
--
--def _read_map_kw(options):
--    options = options or {}
--    map_kw = default_map_kw.copy()
--    map_kw.update({k: v for k, v in options.items() if v is not None})
--    return map_kw
--
--
--class MapExceptions(Exception):
--    def __init__(self, msg, errors, results):
--        super().__init__(msg, errors, results)
--        self.errors = errors
--        self.results = results
--
--
--def serial_map(task, values, task_args=None, task_kwargs=None,
--               reduce_func=None, map_kw=None,
--               progress_bar=None, progress_bar_kwargs={}):
--    """
--    Serial mapping function with the same call signature as parallel_map, for
--    easy switching between serial and parallel execution. This
--    is functionally equivalent to::
--
--        result = [task(value, *task_args, **task_kwargs) for value in values]
--
--    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
--
--    Parameters
--    ----------
--    task : a Python function
--        The function that is to be called for each value in ``task_vec``.
--    values : array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--    task_args : list / dictionary
--        The optional additional argument to the ``task`` function.
--    task_kwargs : list / dictionary
--        The optional additional keyword argument to the ``task`` function.
--    reduce_func : func (optional)
--        If provided, it will be called with the output of each tasks instead of
--        storing a them in a list.
--    progress_bar : string
--        Progress bar options's string for showing progress.
--    progress_bar_kwargs : dict
--        Options for the progress bar.
--    map_kw: dict (optional)
--        Dictionary containing:
--        - timeout: float, Maximum time (sec) for the whole map.
--        - fail_fast: bool, Raise an error at the first.
--
--    Returns
--    -------
--    result : list
--        The result list contains the value of
--        ``task(value, *task_args, **task_kwargs)`` for each
--        value in ``values``. If a ``reduce_func`` is provided, and empty list
--        will be returned.
--
--    """
--    if task_args is None:
--        task_args = ()
--    if task_kwargs is None:
--        task_kwargs = {}
--    map_kw = _read_map_kw(map_kw)
--    progress_bar = progess_bars[progress_bar]()
--    progress_bar.start(len(values), **progress_bar_kwargs)
--    end_time = map_kw['timeout'] + time.time()
--    results = None
--    if reduce_func is None:
--        results = [None] * len(values)
--    errors = {}
--    for n, value in enumerate(values):
--        if time.time() > end_time:
--            break
--        progress_bar.update(n)
--        try:
--            result = task(value, *task_args, **task_kwargs)
--        except Exception as err:
--            if map_kw["fail_fast"]:
--                raise err
--            else:
--                errors[n] = err
--        else:
--            if reduce_func is not None:
--                reduce_func(result)
--            else:
--                results[n] = result
--    progress_bar.finished()
--
--    if errors:
--        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
--                            errors, results)
--    return results
--
--
--def parallel_map(task, values, task_args=None, task_kwargs=None,
--                 reduce_func=None, map_kw=None,
--                 progress_bar=None, progress_bar_kwargs={}):
--    """
--    Parallel execution of a mapping of `values` to the function `task`. This
--    is functionally equivalent to::
--
--        result = [task(value, *task_args, **task_kwargs) for value in values]
--
--    Parameters
--    ----------
--    task : a Python function
--        The function that is to be called for each value in ``task_vec``.
--    values : array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--    task_args : list / dictionary
--        The optional additional argument to the ``task`` function.
--    task_kwargs : list / dictionary
--        The optional additional keyword argument to the ``task`` function.
--    reduce_func : func (optional)
--        If provided, it will be called with the output of each tasks instead of
--        storing a them in a list. Note that the order in which results are
--        passed to ``reduce_func`` is not defined.
--    progress_bar : string
--        Progress bar options's string for showing progress.
--    progress_bar_kwargs : dict
--        Options for the progress bar.
--    map_kw: dict (optional)
--        Dictionary containing entry for:
--        - timeout: float, Maximum time (sec) for the whole map.
--        - job_timeout: float, Maximum time (sec) for each job in the map.
--        - num_cpus: int, Number of job to run at once.
--        - fail_fast: bool, Raise an error at the first.
--
--    Returns
--    -------
--    result : list
--        The result list contains the value of
--        ``task(value, *task_args, **task_kwargs)`` for
--        each value in ``values``. If a ``reduce_func`` is provided, and empty
--        list will be returned.
--
--    """
--    if task_args is None:
--        task_args = ()
--    if task_kwargs is None:
--        task_kwargs = {}
--    map_kw = _read_map_kw(map_kw)
--    end_time = map_kw['timeout'] + time.time()
--    job_time = map_kw['job_timeout']
--
--    progress_bar = progess_bars[progress_bar]()
--    progress_bar.start(len(values), **progress_bar_kwargs)
--
--    errors = {}
--    if reduce_func is not None:
--        results = None
--        result_func = lambda i, value: reduce_func(value)
--    else:
--        results = [None] * len(values)
--        result_func = lambda i, value: results.__setitem__(i, value)
--
--    def _done_callback(future):
--        if not future.cancelled():
--            try:
--                result = future.result()
--            except Exception as e:
--                errors[future._i] = e
--        result_func(future._i, result)
--        progress_bar.update()
--
--    if sys.version_info >= (3, 7):
--        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
--        ctx_kw = {"mp_context": mp_context}
--    else:
--        ctx_kw = {}
--
--    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
--    try:
--        with concurrent.futures.ProcessPoolExecutor(
--            max_workers=map_kw['num_cpus'], **ctx_kw,
--        ) as executor:
--            waiting = set()
--            i = 0
--            while i < len(values):
--                # feed values to the executor, ensuring that there is at
--                # most one task per worker at any moment in time so that
--                # we can shutdown without waiting for greater than the time
--                # taken by the longest task
--                if len(waiting) >= map_kw['num_cpus']:
--                    # no space left, wait for a task to complete or
--                    # the time to run out
--                    timeout = max(0, end_time - time.time())
--                    _done, waiting = concurrent.futures.wait(
--                        waiting,
--                        timeout=timeout,
--                        return_when=concurrent.futures.FIRST_COMPLETED,
--                    )
--                if time.time() >= end_time or (errors and map_kw['fail_fast']):
--                    # no time left, exit the loop
--                    break
--                while len(waiting) < map_kw['num_cpus'] and i < len(values):
--                    # space and time available, add tasks
--                    value = values[i]
--                    future = executor.submit(
--                        task, *((value,) + task_args), **task_kwargs,
--                    )
--                    # small hack to avoid add_done_callback not supporting
--                    # extra arguments and closures inside loops retaining
--                    # a reference not a value:
--                    future._i = i
--                    future.add_done_callback(_done_callback)
--                    waiting.add(future)
--                    i += 1
--
--            timeout = max(0, end_time - time.time())
--            concurrent.futures.wait(waiting, timeout=timeout)
--    finally:
--        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--
--    progress_bar.finished()
--    if errors and map_kw["fail_fast"]:
--        raise list(errors.values())[0]
--    elif errors:
--        raise MapExceptions(
--            f"{len(errors)} iterations failed in parallel_map",
--            errors, results
--        )
--
--    return results
--
--
--def loky_pmap(task, values, task_args=None, task_kwargs=None,
--              reduce_func=None, map_kw=None,
--              progress_bar=None, progress_bar_kwargs={}):
--    """
--    Parallel execution of a mapping of `values` to the function `task`. This
--    is functionally equivalent to::
--
--        result = [task(value, *task_args, **task_kwargs) for value in values]
--
--    Use the loky module instead of multiprocessing.
--
--    Parameters
--    ----------
--    task : a Python function
--        The function that is to be called for each value in ``task_vec``.
--    values : array / list
--        The list or array of values for which the ``task`` function is to be
--        evaluated.
--    task_args : list / dictionary
--        The optional additional argument to the ``task`` function.
--    task_kwargs : list / dictionary
--        The optional additional keyword argument to the ``task`` function.
--    reduce_func : func (optional)
--        If provided, it will be called with the output of each tasks instead of
--        storing a them in a list.
--    progress_bar : string
--        Progress bar options's string for showing progress.
--    progress_bar_kwargs : dict
--        Options for the progress bar.
--    map_kw: dict (optional)
--        Dictionary containing entry for:
--        - timeout: float, Maximum time (sec) for the whole map.
--        - job_timeout: float, Maximum time (sec) for each job in the map.
--        - num_cpus: int, Number of job to run at once.
--        - fail_fast: bool, Raise an error at the first.
--
--    Returns
--    --------
--    result : list
--        The result list contains the value of
--        ``task(value, *task_args, **task_kwargs)`` for
--        each value in ``values``. If a ``reduce_func`` is provided, and empty
--        list will be returned.
--
--    """
--    if task_args is None:
--        task_args = ()
--    if task_kwargs is None:
--        task_kwargs = {}
--    map_kw = _read_map_kw(map_kw)
--    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
--    from loky import get_reusable_executor, TimeoutError
--
--    progress_bar = progess_bars[progress_bar]()
--    progress_bar.start(len(values), **progress_bar_kwargs)
--
--    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
--    end_time = map_kw['timeout'] + time.time()
--    job_time = map_kw['job_timeout']
--    results = None
--    errors = {}
--    if reduce_func is None:
--        results = [None] * len(values)
--
--    try:
--        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
--               for value in values]
--
--        for n, job in enumerate(jobs):
--            remaining_time = min(end_time - time.time(), job_time)
--            try:
--                result = job.result(remaining_time)
--            except Exception as err:
--                if map_kw["fail_fast"]:
--                    raise err
--                else:
--                    errors[n] = err
--            else:
--                if reduce_func is not None:
--                    reduce_func(result)
--                else:
--                    results[n] = result
--            progress_bar.update()
--
--    except KeyboardInterrupt as e:
--        [job.cancel() for job in jobs]
--        raise e
--
--    except TimeoutError:
--        [job.cancel() for job in jobs]
--
--    finally:
--        executor.shutdown()
--    progress_bar.finished()
--    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
--    if errors:
--        raise MapExceptions(
--            f"{len(errors)} iterations failed in loky_pmap",
--            errors, results
--        )
--    return results
--
--
--_get_map = {
--    "parallel_map": parallel_map,
--    "parallel": parallel_map,
--    "serial_map": serial_map,
--    "serial": serial_map,
--    "loky": loky_pmap
--}
-+"""
-+This module provides functions for parallel execution of loops and function
-+mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
-+"""
-+__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
-+
-+import multiprocessing
-+import os
-+import sys
-+import time
-+import threading
-+import concurrent.futures
-+from qutip.ui.progressbar import progess_bars
-+from qutip.settings import available_cpu_count
-+
-+if sys.platform == 'darwin':
-+    mp_context = multiprocessing.get_context('fork')
-+elif sys.platform == 'linux':
-+    # forkserver would handle threads better, but is much slower at starting
-+    # the executor and spawning tasks
-+    mp_context = multiprocessing.get_context('fork')
-+else:
-+    mp_context = multiprocessing.get_context()
-+
-+
-+default_map_kw = {
-+    'job_timeout': threading.TIMEOUT_MAX,
-+    'timeout': threading.TIMEOUT_MAX,
-+    'num_cpus': available_cpu_count(),
-+    'fail_fast': True,
-+}
-+
-+
-+def _read_map_kw(options):
-+    options = options or {}
-+    map_kw = default_map_kw.copy()
-+    map_kw.update({k: v for k, v in options.items() if v is not None})
-+    return map_kw
-+
-+
-+class MapExceptions(Exception):
-+    def __init__(self, msg, errors, results):
-+        super().__init__(msg, errors, results)
-+        self.errors = errors
-+        self.results = results
-+
-+
-+def serial_map(task, values, task_args=None, task_kwargs=None,
-+               reduce_func=None, map_kw=None,
-+               progress_bar=None, progress_bar_kwargs={}):
-+    """
-+    Serial mapping function with the same call signature as parallel_map, for
-+    easy switching between serial and parallel execution. This
-+    is functionally equivalent to::
-+
-+        result = [task(value, *task_args, **task_kwargs) for value in values]
-+
-+    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
-+
-+    Parameters
-+    ----------
-+    task : a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+    values : array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+    task_args : list / dictionary
-+        The optional additional argument to the ``task`` function.
-+    task_kwargs : list / dictionary
-+        The optional additional keyword argument to the ``task`` function.
-+    reduce_func : func (optional)
-+        If provided, it will be called with the output of each tasks instead of
-+        storing a them in a list.
-+    progress_bar : string
-+        Progress bar options's string for showing progress.
-+    progress_bar_kwargs : dict
-+        Options for the progress bar.
-+    map_kw: dict (optional)
-+        Dictionary containing:
-+        - timeout: float, Maximum time (sec) for the whole map.
-+        - fail_fast: bool, Raise an error at the first.
-+
-+    Returns
-+    -------
-+    result : list
-+        The result list contains the value of
-+        ``task(value, *task_args, **task_kwargs)`` for each
-+        value in ``values``. If a ``reduce_func`` is provided, and empty list
-+        will be returned.
-+
-+    """
-+    if task_args is None:
-+        task_args = ()
-+    if task_kwargs is None:
-+        task_kwargs = {}
-+    map_kw = _read_map_kw(map_kw)
-+    progress_bar = progess_bars[progress_bar]()
-+    progress_bar.start(len(values), **progress_bar_kwargs)
-+    end_time = map_kw['timeout'] + time.time()
-+    results = None
-+    if reduce_func is None:
-+        results = [None] * len(values)
-+    errors = {}
-+    for n, value in enumerate(values):
-+        if time.time() > end_time:
-+            break
-+        progress_bar.update(n)
-+        try:
-+            result = task(value, *task_args, **task_kwargs)
-+        except Exception as err:
-+            if map_kw["fail_fast"]:
-+                raise err
-+            else:
-+                errors[n] = err
-+        else:
-+            if reduce_func is not None:
-+                reduce_func(result)
-+            else:
-+                results[n] = result
-+    progress_bar.finished()
-+
-+    if errors:
-+        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
-+                            errors, results)
-+    return results
-+
-+
-+def parallel_map(task, values, task_args=None, task_kwargs=None,
-+                 reduce_func=None, map_kw=None,
-+                 progress_bar=None, progress_bar_kwargs={}):
-+    """
-+    Parallel execution of a mapping of `values` to the function `task`. This
-+    is functionally equivalent to::
-+
-+        result = [task(value, *task_args, **task_kwargs) for value in values]
-+
-+    Parameters
-+    ----------
-+    task : a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+    values : array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+    task_args : list / dictionary
-+        The optional additional argument to the ``task`` function.
-+    task_kwargs : list / dictionary
-+        The optional additional keyword argument to the ``task`` function.
-+    reduce_func : func (optional)
-+        If provided, it will be called with the output of each tasks instead of
-+        storing a them in a list. Note that the order in which results are
-+        passed to ``reduce_func`` is not defined.
-+    progress_bar : string
-+        Progress bar options's string for showing progress.
-+    progress_bar_kwargs : dict
-+        Options for the progress bar.
-+    map_kw: dict (optional)
-+        Dictionary containing entry for:
-+        - timeout: float, Maximum time (sec) for the whole map.
-+        - job_timeout: float, Maximum time (sec) for each job in the map.
-+        - num_cpus: int, Number of job to run at once.
-+        - fail_fast: bool, Raise an error at the first.
-+
-+    Returns
-+    -------
-+    result : list
-+        The result list contains the value of
-+        ``task(value, *task_args, **task_kwargs)`` for
-+        each value in ``values``. If a ``reduce_func`` is provided, and empty
-+        list will be returned.
-+
-+    """
-+    if task_args is None:
-+        task_args = ()
-+    if task_kwargs is None:
-+        task_kwargs = {}
-+    map_kw = _read_map_kw(map_kw)
-+    end_time = map_kw['timeout'] + time.time()
-+    job_time = map_kw['job_timeout']
-+
-+    progress_bar = progess_bars[progress_bar]()
-+    progress_bar.start(len(values), **progress_bar_kwargs)
-+
-+    errors = {}
-+    if reduce_func is not None:
-+        results = None
-+        result_func = lambda i, value: reduce_func(value)
-+    else:
-+        results = [None] * len(values)
-+        result_func = lambda i, value: results.__setitem__(i, value)
-+
-+    def _done_callback(future):
-+        if not future.cancelled():
-+            try:
-+                result = future.result()
-+            except Exception as e:
-+                errors[future._i] = e
-+        result_func(future._i, result)
-+        progress_bar.update()
-+
-+    if sys.version_info >= (3, 7):
-+        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
-+        ctx_kw = {"mp_context": mp_context}
-+    else:
-+        ctx_kw = {}
-+
-+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-+    try:
-+        with concurrent.futures.ProcessPoolExecutor(
-+            max_workers=map_kw['num_cpus'], **ctx_kw,
-+        ) as executor:
-+            waiting = set()
-+            i = 0
-+            while i < len(values):
-+                # feed values to the executor, ensuring that there is at
-+                # most one task per worker at any moment in time so that
-+                # we can shutdown without waiting for greater than the time
-+                # taken by the longest task
-+                if len(waiting) >= map_kw['num_cpus']:
-+                    # no space left, wait for a task to complete or
-+                    # the time to run out
-+                    timeout = max(0, end_time - time.time())
-+                    _done, waiting = concurrent.futures.wait(
-+                        waiting,
-+                        timeout=timeout,
-+                        return_when=concurrent.futures.FIRST_COMPLETED,
-+                    )
-+                if time.time() >= end_time or (errors and map_kw['fail_fast']):
-+                    # no time left, exit the loop
-+                    break
-+                while len(waiting) < map_kw['num_cpus'] and i < len(values):
-+                    # space and time available, add tasks
-+                    value = values[i]
-+                    future = executor.submit(
-+                        task, *((value,) + task_args), **task_kwargs,
-+                    )
-+                    # small hack to avoid add_done_callback not supporting
-+                    # extra arguments and closures inside loops retaining
-+                    # a reference not a value:
-+                    future._i = i
-+                    future.add_done_callback(_done_callback)
-+                    waiting.add(future)
-+                    i += 1
-+
-+            timeout = max(0, end_time - time.time())
-+            concurrent.futures.wait(waiting, timeout=timeout)
-+    finally:
-+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+
-+    progress_bar.finished()
-+    if errors and map_kw["fail_fast"]:
-+        raise list(errors.values())[0]
-+    elif errors:
-+        raise MapExceptions(
-+            f"{len(errors)} iterations failed in parallel_map",
-+            errors, results
-+        )
-+
-+    return results
-+
-+
-+def loky_pmap(task, values, task_args=None, task_kwargs=None,
-+              reduce_func=None, map_kw=None,
-+              progress_bar=None, progress_bar_kwargs={}):
-+    """
-+    Parallel execution of a mapping of `values` to the function `task`. This
-+    is functionally equivalent to::
-+
-+        result = [task(value, *task_args, **task_kwargs) for value in values]
-+
-+    Use the loky module instead of multiprocessing.
-+
-+    Parameters
-+    ----------
-+    task : a Python function
-+        The function that is to be called for each value in ``task_vec``.
-+    values : array / list
-+        The list or array of values for which the ``task`` function is to be
-+        evaluated.
-+    task_args : list / dictionary
-+        The optional additional argument to the ``task`` function.
-+    task_kwargs : list / dictionary
-+        The optional additional keyword argument to the ``task`` function.
-+    reduce_func : func (optional)
-+        If provided, it will be called with the output of each tasks instead of
-+        storing a them in a list.
-+    progress_bar : string
-+        Progress bar options's string for showing progress.
-+    progress_bar_kwargs : dict
-+        Options for the progress bar.
-+    map_kw: dict (optional)
-+        Dictionary containing entry for:
-+        - timeout: float, Maximum time (sec) for the whole map.
-+        - job_timeout: float, Maximum time (sec) for each job in the map.
-+        - num_cpus: int, Number of job to run at once.
-+        - fail_fast: bool, Raise an error at the first.
-+
-+    Returns
-+    --------
-+    result : list
-+        The result list contains the value of
-+        ``task(value, *task_args, **task_kwargs)`` for
-+        each value in ``values``. If a ``reduce_func`` is provided, and empty
-+        list will be returned.
-+
-+    """
-+    if task_args is None:
-+        task_args = ()
-+    if task_kwargs is None:
-+        task_kwargs = {}
-+    map_kw = _read_map_kw(map_kw)
-+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-+    from loky import get_reusable_executor, TimeoutError
-+
-+    progress_bar = progess_bars[progress_bar]()
-+    progress_bar.start(len(values), **progress_bar_kwargs)
-+
-+    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
-+    end_time = map_kw['timeout'] + time.time()
-+    job_time = map_kw['job_timeout']
-+    results = None
-+    errors = {}
-+    if reduce_func is None:
-+        results = [None] * len(values)
-+
-+    try:
-+        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
-+               for value in values]
-+
-+        for n, job in enumerate(jobs):
-+            remaining_time = min(end_time - time.time(), job_time)
-+            try:
-+                result = job.result(remaining_time)
-+            except Exception as err:
-+                if map_kw["fail_fast"]:
-+                    raise err
-+                else:
-+                    errors[n] = err
-+            else:
-+                if reduce_func is not None:
-+                    reduce_func(result)
-+                else:
-+                    results[n] = result
-+            progress_bar.update()
-+
-+    except KeyboardInterrupt as e:
-+        [job.cancel() for job in jobs]
-+        raise e
-+
-+    except TimeoutError:
-+        [job.cancel() for job in jobs]
-+
-+    finally:
-+        executor.shutdown()
-+    progress_bar.finished()
-+    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-+    if errors:
-+        raise MapExceptions(
-+            f"{len(errors)} iterations failed in loky_pmap",
-+            errors, results
-+        )
-+    return results
-+
-+
-+_get_map = {
-+    "parallel_map": parallel_map,
-+    "parallel": parallel_map,
-+    "serial_map": serial_map,
-+    "serial": serial_map,
-+    "loky": loky_pmap
-+}
-diff --git a/qutip/solver/propagator.py b/qutip/solver/propagator.py
-index 179c0dce..5ad10b6c 100644
---- a/qutip/solver/propagator.py
-+++ b/qutip/solver/propagator.py
-@@ -1,278 +1,278 @@
--__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
--
--import numbers
--import numpy as np
--
--from .. import Qobj, qeye, unstack_columns, QobjEvo
--from ..core import data as _data
--from .mesolve import mesolve, MESolver
--from .sesolve import sesolve, SESolver
--from .heom.bofin_solvers import HEOMSolver
--from .solver_base import Solver
--from .multitraj import MultiTrajSolver
--
--
--def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
--    r"""
--    Calculate the propagator U(t) for the density matrix or wave function such
--    that :math:`\psi(t) = U(t)\psi(0)` or
--    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
--    where :math:`\rho_{\mathrm vec}` is the vector representation of the
--    density matrix.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
--        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
--        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
--        that can be made into :class:`QobjEvo` are also accepted.
--
--    t : float or array-like
--        Time or list of times for which to evaluate the propagator.
--
--    c_ops : list, optional
--        List of Qobj or QobjEvo collapse operators.
--
--    args : dictionary, optional
--        Parameters to callback functions for time-dependent Hamiltonians and
--        collapse operators.
--
--    options : dict, optional
--        Options for the solver.
--
--    **kwargs :
--        Extra parameters to use when creating the :class:`QobjEvo` from a list
--        format ``H``.
--
--    Returns
--    -------
--    U : qobj, list
--        Instance representing the propagator(s) :math:`U(t)`. Return a single
--        Qobj when ``t`` is a number or a list when ``t`` is a list.
--
--    """
--    if isinstance(t, numbers.Real):
--        tlist = [0, t]
--        list_output = False
--    else:
--        tlist = t
--        list_output = True
--
--    if not isinstance(H, (Qobj, QobjEvo)):
--        H = QobjEvo(H, args=args, **kwargs)
--
--    if H.issuper or c_ops:
--        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
--                      args=args, options=options).states
--    else:
--        out = sesolve(H, qeye(H.dims[0]), tlist,
--                      args=args, options=options).states
--
--    if list_output:
--        return out
--    else:
--        return out[-1]
--
--
--def propagator_steadystate(U):
--    r"""Find the steady state for successive applications of the propagator
--    :math:`U`.
--
--    Parameters
--    ----------
--    U : qobj
--        Operator representing the propagator.
--
--    Returns
--    -------
--    a : qobj
--        Instance representing the steady-state density matrix.
--    """
--    evals, estates = U.eigenstates()
--    shifted_vals = np.abs(evals - 1.0)
--    ev_idx = np.argmin(shifted_vals)
--    rho_data = unstack_columns(estates[ev_idx].data)
--    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
--    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
--                dims=U.dims[0],
--                type='oper',
--                isherm=True,
--                copy=False)
--
--
--class Propagator:
--    """
--    A generator of propagator for a system.
--
--    Usage:
--        U = Propagator(H, c_ops)
--        psi_t = U(t) @ psi_0
--
--    Save some previously computed propagator are stored to speed up subsequent
--    computation. Changing ``args`` will erase these stored probagator.
--
--    Parameters
--    ----------
--    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
--        Possibly time-dependent system driving the evolution, either already
--        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
--        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
--        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
--        be made into :class:`QobjEvo` are also accepted.
--
--        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
--        not supported.
--
--    c_ops : list, optional
--        List of Qobj or QobjEvo collapse operators.
--
--    args : dictionary
--        Parameters to callback functions for time-dependent Hamiltonians and
--        collapse operators.
--
--    options : dict
--        Options for the solver.
--
--    memoize : int [10]
--        Max number of propagator to save.
--
--    tol : float [1e-14]
--        Absolute tolerance for the time. If a previous propagator was computed
--        at a time within tolerance, that propagator will be returned.
--
--    .. note::
--        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
--        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
--        into a :class:`QobjEvo` with ::
--            U = QobjEvo(Propagator(H))
--    """
--    def __init__(self, system, *, c_ops=(), args=None, options=None,
--                 memoize=10, tol=1e-14):
--        if isinstance(system, MultiTrajSolver):
--            raise TypeError("Non-deterministic solvers cannot be used "
--                            "as a propagator system")
--        elif isinstance(system, HEOMSolver):
--            raise NotImplementedError(
--                "HEOM is not supported by Propagator. "
--                "Please, tell us on GitHub issues if you need it!"
--            )
--        elif isinstance(system, Solver):
--            self.solver = system
--        else:
--            Hevo = QobjEvo(system, args=args)
--            c_ops = [QobjEvo(op, args=args) for op in c_ops]
--            if Hevo.issuper or c_ops:
--                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
--            else:
--                self.solver = SESolver(Hevo, options=options)
--
--        self.times = [0]
--        self.invs = [None]
--        self.props = [qeye(self.solver.sys_dims)]
--        self.solver.start(self.props[0], self.times[0])
--        self.cte = self.solver.rhs.isconstant
--        H_0 = self.solver.rhs(0)
--        self.unitary = not H_0.issuper and H_0.isherm
--        self.args = args
--        self.memoize = max(3, int(memoize))
--        self.tol = tol
--
--    def _lookup_or_compute(self, t):
--        """
--        Get U(t) from cache or compute it.
--        """
--        idx = np.searchsorted(self.times, t)
--        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
--            U = self.props[idx]
--        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
--            U = self.props[idx-1]
--        else:
--            U = self._compute(t, idx)
--            self._insert(t, U, idx)
--        return U
--
--    def __call__(self, t, t_start=0, **args):
--        """
--        Get the propagator from ``t_start`` to ``t``.
--
--        Parameters
--        ----------
--        t : float
--            Time at which to compute the propagator.
--        t_start: float [0]
--            Time at which the propagator start such that:
--                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
--        args : dict
--            Argument to pass to a time dependent Hamiltonian.
--            Updating ``args`` take effect since ``t=0`` and the new ``args``
--            will be used in future call.
--        """
--        # We could improve it when the system is constant using U(2t) = U(t)**2
--        if not self.cte and args and args != self.args:
--            self.args = args
--            self.solver._argument(args)
--            self.times = [0]
--            self.props = [qeye(self.props[0].dims[0])]
--            self.solver.start(self.props[0], self.times[0])
--
--        if t_start:
--            if t == t_start:
--                U = self._lookup_or_compute(0)
--            if self.cte:
--                U = self._lookup_or_compute(t - t_start)
--            else:
--                Uinv = self._inv(self._lookup_or_compute(t_start))
--                U = self._lookup_or_compute(t) @ Uinv
--        else:
--            U = self._lookup_or_compute(t)
--        return U
--
--    def inv(self, t, **args):
--        """
--        Get the inverse of the propagator at ``t``, such that
--            ``psi_0 = U.inv(t) @ psi_t``
--
--        Parameters
--        ----------
--        t : float
--            Time at which to compute the propagator.
--        args : dict
--            Argument to pass to a time dependent Hamiltonian.
--            Updating ``args`` take effect since ``t=0`` and the new ``args``
--            will be used in future call.
--        """
--        return self._inv(self(t, **args))
--
--    def _compute(self, t, idx):
--        """
--        Compute the propagator at ``t``, ``idx`` point to a pair of
--        (time, propagator) close to the desired time.
--        """
--        t_last = self.solver._integrator.get_state(copy=False)[0]
--        if self.times[idx-1] <= t_last <= t:
--            U = self.solver.step(t)
--        elif idx > 0:
--            self.solver.start(self.props[idx-1], self.times[idx-1])
--            U = self.solver.step(t)
--        else:
--            # Evolving backward in time is not supported by all integrator.
--            self.solver.start(qeye(self.props[0].dims[0]), t)
--            Uinv = self.solver.step(self.times[idx])
--            U = self._inv(Uinv)
--        return U
--
--    def _inv(self, U):
--        return U.dag() if self.unitary else U.inv()
--
--    def _insert(self, t, U, idx):
--        """
--        Insert a new pair of (time, propagator) to the memorized states.
--        """
--        while len(self.times) >= self.memoize:
--            rm_idx = self.memoize // 2
--            if self.times[rm_idx] < t:
--                idx -= 1
--            del self.times[rm_idx]
--            del self.props[rm_idx]
--        self.times.insert(idx, t)
--        self.props.insert(idx, U)
-+__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
-+
-+import numbers
-+import numpy as np
-+
-+from .. import Qobj, qeye, unstack_columns, QobjEvo
-+from ..core import data as _data
-+from .mesolve import mesolve, MESolver
-+from .sesolve import sesolve, SESolver
-+from .heom.bofin_solvers import HEOMSolver
-+from .solver_base import Solver
-+from .multitraj import MultiTrajSolver
-+
-+
-+def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
-+    r"""
-+    Calculate the propagator U(t) for the density matrix or wave function such
-+    that :math:`\psi(t) = U(t)\psi(0)` or
-+    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
-+    where :math:`\rho_{\mathrm vec}` is the vector representation of the
-+    density matrix.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-+        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
-+        that can be made into :class:`QobjEvo` are also accepted.
-+
-+    t : float or array-like
-+        Time or list of times for which to evaluate the propagator.
-+
-+    c_ops : list, optional
-+        List of Qobj or QobjEvo collapse operators.
-+
-+    args : dictionary, optional
-+        Parameters to callback functions for time-dependent Hamiltonians and
-+        collapse operators.
-+
-+    options : dict, optional
-+        Options for the solver.
-+
-+    **kwargs :
-+        Extra parameters to use when creating the :class:`QobjEvo` from a list
-+        format ``H``.
-+
-+    Returns
-+    -------
-+    U : qobj, list
-+        Instance representing the propagator(s) :math:`U(t)`. Return a single
-+        Qobj when ``t`` is a number or a list when ``t`` is a list.
-+
-+    """
-+    if isinstance(t, numbers.Real):
-+        tlist = [0, t]
-+        list_output = False
-+    else:
-+        tlist = t
-+        list_output = True
-+
-+    if not isinstance(H, (Qobj, QobjEvo)):
-+        H = QobjEvo(H, args=args, **kwargs)
-+
-+    if H.issuper or c_ops:
-+        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
-+                      args=args, options=options).states
-+    else:
-+        out = sesolve(H, qeye(H.dims[0]), tlist,
-+                      args=args, options=options).states
-+
-+    if list_output:
-+        return out
-+    else:
-+        return out[-1]
-+
-+
-+def propagator_steadystate(U):
-+    r"""Find the steady state for successive applications of the propagator
-+    :math:`U`.
-+
-+    Parameters
-+    ----------
-+    U : qobj
-+        Operator representing the propagator.
-+
-+    Returns
-+    -------
-+    a : qobj
-+        Instance representing the steady-state density matrix.
-+    """
-+    evals, estates = U.eigenstates()
-+    shifted_vals = np.abs(evals - 1.0)
-+    ev_idx = np.argmin(shifted_vals)
-+    rho_data = unstack_columns(estates[ev_idx].data)
-+    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
-+    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
-+                dims=U.dims[0],
-+                type='oper',
-+                isherm=True,
-+                copy=False)
-+
-+
-+class Propagator:
-+    """
-+    A generator of propagator for a system.
-+
-+    Usage:
-+        U = Propagator(H, c_ops)
-+        psi_t = U(t) @ psi_0
-+
-+    Save some previously computed propagator are stored to speed up subsequent
-+    computation. Changing ``args`` will erase these stored probagator.
-+
-+    Parameters
-+    ----------
-+    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
-+        Possibly time-dependent system driving the evolution, either already
-+        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
-+        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
-+        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
-+        be made into :class:`QobjEvo` are also accepted.
-+
-+        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
-+        not supported.
-+
-+    c_ops : list, optional
-+        List of Qobj or QobjEvo collapse operators.
-+
-+    args : dictionary
-+        Parameters to callback functions for time-dependent Hamiltonians and
-+        collapse operators.
-+
-+    options : dict
-+        Options for the solver.
-+
-+    memoize : int [10]
-+        Max number of propagator to save.
-+
-+    tol : float [1e-14]
-+        Absolute tolerance for the time. If a previous propagator was computed
-+        at a time within tolerance, that propagator will be returned.
-+
-+    .. note::
-+        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
-+        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
-+        into a :class:`QobjEvo` with ::
-+            U = QobjEvo(Propagator(H))
-+    """
-+    def __init__(self, system, *, c_ops=(), args=None, options=None,
-+                 memoize=10, tol=1e-14):
-+        if isinstance(system, MultiTrajSolver):
-+            raise TypeError("Non-deterministic solvers cannot be used "
-+                            "as a propagator system")
-+        elif isinstance(system, HEOMSolver):
-+            raise NotImplementedError(
-+                "HEOM is not supported by Propagator. "
-+                "Please, tell us on GitHub issues if you need it!"
-+            )
-+        elif isinstance(system, Solver):
-+            self.solver = system
-+        else:
-+            Hevo = QobjEvo(system, args=args)
-+            c_ops = [QobjEvo(op, args=args) for op in c_ops]
-+            if Hevo.issuper or c_ops:
-+                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
-+            else:
-+                self.solver = SESolver(Hevo, options=options)
-+
-+        self.times = [0]
-+        self.invs = [None]
-+        self.props = [qeye(self.solver.sys_dims)]
-+        self.solver.start(self.props[0], self.times[0])
-+        self.cte = self.solver.rhs.isconstant
-+        H_0 = self.solver.rhs(0)
-+        self.unitary = not H_0.issuper and H_0.isherm
-+        self.args = args
-+        self.memoize = max(3, int(memoize))
-+        self.tol = tol
-+
-+    def _lookup_or_compute(self, t):
-+        """
-+        Get U(t) from cache or compute it.
-+        """
-+        idx = np.searchsorted(self.times, t)
-+        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
-+            U = self.props[idx]
-+        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
-+            U = self.props[idx-1]
-+        else:
-+            U = self._compute(t, idx)
-+            self._insert(t, U, idx)
-+        return U
-+
-+    def __call__(self, t, t_start=0, **args):
-+        """
-+        Get the propagator from ``t_start`` to ``t``.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time at which to compute the propagator.
-+        t_start: float [0]
-+            Time at which the propagator start such that:
-+                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
-+        args : dict
-+            Argument to pass to a time dependent Hamiltonian.
-+            Updating ``args`` take effect since ``t=0`` and the new ``args``
-+            will be used in future call.
-+        """
-+        # We could improve it when the system is constant using U(2t) = U(t)**2
-+        if not self.cte and args and args != self.args:
-+            self.args = args
-+            self.solver._argument(args)
-+            self.times = [0]
-+            self.props = [qeye(self.props[0].dims[0])]
-+            self.solver.start(self.props[0], self.times[0])
-+
-+        if t_start:
-+            if t == t_start:
-+                U = self._lookup_or_compute(0)
-+            if self.cte:
-+                U = self._lookup_or_compute(t - t_start)
-+            else:
-+                Uinv = self._inv(self._lookup_or_compute(t_start))
-+                U = self._lookup_or_compute(t) @ Uinv
-+        else:
-+            U = self._lookup_or_compute(t)
-+        return U
-+
-+    def inv(self, t, **args):
-+        """
-+        Get the inverse of the propagator at ``t``, such that
-+            ``psi_0 = U.inv(t) @ psi_t``
-+
-+        Parameters
-+        ----------
-+        t : float
-+            Time at which to compute the propagator.
-+        args : dict
-+            Argument to pass to a time dependent Hamiltonian.
-+            Updating ``args`` take effect since ``t=0`` and the new ``args``
-+            will be used in future call.
-+        """
-+        return self._inv(self(t, **args))
-+
-+    def _compute(self, t, idx):
-+        """
-+        Compute the propagator at ``t``, ``idx`` point to a pair of
-+        (time, propagator) close to the desired time.
-+        """
-+        t_last = self.solver._integrator.get_state(copy=False)[0]
-+        if self.times[idx-1] <= t_last <= t:
-+            U = self.solver.step(t)
-+        elif idx > 0:
-+            self.solver.start(self.props[idx-1], self.times[idx-1])
-+            U = self.solver.step(t)
-+        else:
-+            # Evolving backward in time is not supported by all integrator.
-+            self.solver.start(qeye(self.props[0].dims[0]), t)
-+            Uinv = self.solver.step(self.times[idx])
-+            U = self._inv(Uinv)
-+        return U
-+
-+    def _inv(self, U):
-+        return U.dag() if self.unitary else U.inv()
-+
-+    def _insert(self, t, U, idx):
-+        """
-+        Insert a new pair of (time, propagator) to the memorized states.
-+        """
-+        while len(self.times) >= self.memoize:
-+            rm_idx = self.memoize // 2
-+            if self.times[rm_idx] < t:
-+                idx -= 1
-+            del self.times[rm_idx]
-+            del self.props[rm_idx]
-+        self.times.insert(idx, t)
-+        self.props.insert(idx, U)
-diff --git a/qutip/solver/result.py b/qutip/solver/result.py
-index a87ad920..c6360d4e 100644
---- a/qutip/solver/result.py
-+++ b/qutip/solver/result.py
-@@ -1,972 +1,972 @@
--""" Class for solve function results"""
--import numpy as np
--from ..core import Qobj, QobjEvo, expect, qzero
--
--__all__ = ["Result", "MultiTrajResult", "McResult"]
--
--
--class _QobjExpectEop:
--    """
--    Pickable e_ops callable that calculates the expectation value for a given
--    operator.
--
--    Parameters
--    ----------
--    op : :obj:`~Qobj`
--        The expectation value operator.
--    """
--    def __init__(self, op):
--        self.op = op
--
--    def __call__(self, t, state):
--        return expect(self.op, state)
--
--
--class ExpectOp:
--    """
--    A result e_op (expectation operation).
--
--    Parameters
--    ----------
--    op : object
--        The original object used to define the e_op operation, e.g. a
--        :~obj:`Qobj` or a function ``f(t, state)``.
--
--    f : function
--        A callable ``f(t, state)`` that will return the value of the e_op
--        for the specified state and time.
--
--    append : function
--        A callable ``append(value)``, e.g. ``expect[k].append``, that will
--        store the result of the e_ops function ``f(t, state)``.
--
--    Attributes
--    ----------
--    op : object
--        The original object used to define the e_op operation.
--    """
--    def __init__(self, op, f, append):
--        self.op = op
--        self._f = f
--        self._append = append
--
--    def __call__(self, t, state):
--        """
--        Return the expectation value for the given time, ``t`` and
--        state, ``state``.
--        """
--        return self._f(t, state)
--
--    def _store(self, t, state):
--        """
--        Store the result of the e_op function. Should only be called by
--        :class:`~Result`.
--        """
--        self._append(self._f(t, state))
--
--
--class _BaseResult:
--    """
--    Common method for all ``Result``.
--    """
--    def __init__(self, options, *, solver=None, stats=None):
--        self.solver = solver
--        if stats is None:
--            stats = {}
--        self.stats = stats
--
--        self._state_processors = []
--        self._state_processors_require_copy = False
--
--        self.options = options
--
--    def _e_ops_to_dict(self, e_ops):
--        """ Convert the supplied e_ops to a dictionary of Eop instances. """
--        if e_ops is None:
--            e_ops = {}
--        elif isinstance(e_ops, (list, tuple)):
--            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
--        elif isinstance(e_ops, dict):
--            pass
--        else:
--            e_ops = {0: e_ops}
--        return e_ops
--
--    def add_processor(self, f, requires_copy=False):
--        """
--        Append a processor ``f`` to the list of state processors.
--
--        Parameters
--        ----------
--        f : function, ``f(t, state)``
--            A function to be called each time a state is added to this
--            result object. The state is the state passed to ``.add``, after
--            applying the pre-processors, if any.
--
--        requires_copy : bool, default False
--            Whether this processor requires a copy of the state rather than
--            a reference. A processor must never modify the supplied state, but
--            if a processor stores the state it should set ``require_copy`` to
--            true.
--        """
--        self._state_processors.append(f)
--        self._state_processors_require_copy |= requires_copy
--
--
--class Result(_BaseResult):
--    """
--    Base class for storing solver results.
--
--    Parameters
--    ----------
--    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
--        The ``e_ops`` parameter defines the set of values to record at
--        each time step ``t``. If an element is a :obj:`~Qobj` or
--        :obj:`~QobjEvo` the value recorded is the expectation value of that
--        operator given the state at ``t``. If the element is a function, ``f``,
--        the value recorded is ``f(t, state)``.
--
--        The values are recorded in the ``e_data`` and ``expect`` attributes of
--        this result object. ``e_data`` is a dictionary and ``expect`` is a
--        list, where each item contains the values of the corresponding
--        ``e_op``.
--
--    options : dict
--        The options for this result class.
--
--    solver : str or None
--        The name of the solver generating these results.
--
--    stats : dict or None
--        The stats generated by the solver while producing these results. Note
--        that the solver may update the stats directly while producing results.
--
--    kw : dict
--        Additional parameters specific to a result sub-class.
--
--    Attributes
--    ----------
--    times : list
--        A list of the times at which the expectation values and states were
--        recorded.
--
--    states : list of :obj:`~Qobj`
--        The state at each time ``t`` (if the recording of the state was
--        requested).
--
--    final_state : :obj:`~Qobj`:
--        The final state (if the recording of the final state was requested).
--
--    expect : list of arrays of expectation values
--        A list containing the values of each ``e_op``. The list is in
--        the same order in which the ``e_ops`` were supplied and empty if
--        no ``e_ops`` were given.
--
--        Each element is itself a list and contains the values of the
--        corresponding ``e_op``, with one value for each time in ``.times``.
--
--        The same lists of values may be accessed via the ``.e_data`` dictionary
--        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
--
--    e_data : dict
--        A dictionary containing the values of each ``e_op``. If the ``e_ops``
--        were supplied as a dictionary, the keys are the same as in
--        that dictionary. Otherwise the keys are the index of the ``e_op``
--        in the ``.expect`` list.
--
--        The lists of expectation values returned are the *same* lists as
--        those returned by ``.expect``.
--
--    e_ops : dict
--        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
--        The keys of the dictionary are the same as for ``.e_data``.
--        Each value is object where ``.e_ops[k](t, state)`` calculates the
--        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
--        ``.e_ops[k].op`` is the original object supplied to create the
--        ``e_op``.
--
--    solver : str or None
--        The name of the solver generating these results.
--
--    stats : dict or None
--        The stats generated by the solver while producing these results.
--
--    options : dict
--        The options for this result class.
--    """
--    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
--        super().__init__(options, solver=solver, stats=stats)
--        raw_ops = self._e_ops_to_dict(e_ops)
--        self.e_data = {k: [] for k in raw_ops}
--        self.e_ops = {}
--        for k, op in raw_ops.items():
--            f = self._e_op_func(op)
--            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
--            self.add_processor(self.e_ops[k]._store)
--
--        self.times = []
--        self.states = []
--        self.final_state = None
--
--        self._post_init(**kw)
--
--    def _e_op_func(self, e_op):
--        """
--        Convert an e_op entry into a function, ``f(t, state)`` that returns
--        the appropriate value (usually an expectation value).
--
--        Sub-classes may override this function to calculate expectation values
--        in different ways.
--        """
--        if isinstance(e_op, Qobj):
--            return _QobjExpectEop(e_op)
--        elif isinstance(e_op, QobjEvo):
--            return e_op.expect
--        elif callable(e_op):
--            return e_op
--        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
--
--    def _post_init(self):
--        """
--        Perform post __init__ initialisation. In particular, add state
--        processors or pre-processors.
--
--        Sub-class may override this. If the sub-class wishes to register the
--        default processors for storing states, it should call this parent
--        ``.post_init()`` method.
--
--        Sub-class ``.post_init()`` implementation may take additional keyword
--        arguments if required.
--        """
--        store_states = self.options['store_states']
--        store_final_state = self.options['store_final_state']
--
--        if store_states is None:
--            store_states = len(self.e_ops) == 0
--        if store_states:
--            self.add_processor(self._store_state, requires_copy=True)
--
--        if store_states or store_final_state:
--            self.add_processor(self._store_final_state, requires_copy=True)
--
--    def _store_state(self, t, state):
--        """ Processor that stores a state in ``.states``. """
--        self.states.append(state)
--
--    def _store_final_state(self, t, state):
--        """ Processor that writes the state to ``.final_state``. """
--        self.final_state = state
--
--    def _pre_copy(self, state):
--        """ Return a copy of the state. Sub-classes may override this to
--            copy a state in different manner or to skip making a copy
--            altogether if a copy is not necessary.
--        """
--        return state.copy()
--
--    def add(self, t, state):
--        """
--        Add a state to the results for the time ``t`` of the evolution.
--
--        Adding a state calculates the expectation value of the state for
--        each of the supplied ``e_ops`` and stores the result in ``.expect``.
--
--        The state is recorded in ``.states`` and ``.final_state`` if specified
--        by the supplied result options.
--
--        Parameters
--        ----------
--        t : float
--            The time of the added state.
--
--        state : typically a :obj:`~Qobj`
--            The state a time ``t``. Usually this is a :obj:`~Qobj` with
--            suitable dimensions, but it sub-classes of result might support
--            other forms of the state.
--
--        .. note::
--
--           The expectation values, i.e. ``e_ops``, and states are recorded by
--           the state processors (see ``.add_processor``).
--
--           Additional processors may be added by sub-classes.
--        """
--        self.times.append(t)
--
--        if self._state_processors_require_copy:
--            state = self._pre_copy(state)
--
--        for op in self._state_processors:
--            op(t, state)
--
--    def __repr__(self):
--        lines = [
--            f"<{self.__class__.__name__}",
--            f"  Solver: {self.solver}",
--        ]
--        if self.stats:
--            lines.append("  Solver stats:")
--            lines.extend(
--                f"    {k}: {v!r}"
--                for k, v in self.stats.items()
--            )
--        if self.times:
--            lines.append(
--                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
--                f" ({len(self.times)} steps)"
--            )
--        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
--        if self.states:
--            lines.append("  States saved.")
--        elif self.final_state is not None:
--            lines.append("  Final state saved.")
--        else:
--            lines.append("  State not saved.")
--        lines.append(">")
--        return "\n".join(lines)
--
--    @property
--    def expect(self):
--        return [np.array(e_op) for e_op in self.e_data.values()]
--
--
--class MultiTrajResult(_BaseResult):
--    """
--    Base class for storing results for solver using multiple trajectories.
--
--    Parameters
--    ----------
--    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
--        The ``e_ops`` parameter defines the set of values to record at
--        each time step ``t``. If an element is a :obj:`~Qobj` or
--        :obj:`~QobjEvo` the value recorded is the expectation value of that
--        operator given the state at ``t``. If the element is a function, ``f``,
--        the value recorded is ``f(t, state)``.
--
--        The values are recorded in the ``.expect`` attribute of this result
--        object. ``.expect`` is a list, where each item contains the values
--        of the corresponding ``e_op``.
--
--        Function ``e_ops`` must return a number so the average can be computed.
--
--    options : dict
--        The options for this result class.
--
--    solver : str or None
--        The name of the solver generating these results.
--
--    stats : dict or None
--        The stats generated by the solver while producing these results. Note
--        that the solver may update the stats directly while producing results.
--
--    kw : dict
--        Additional parameters specific to a result sub-class.
--
--    Properties
--    ----------
--    times : list
--        A list of the times at which the expectation values and states were
--        recorded.
--
--    average_states : list of :obj:`~Qobj`
--        The state at each time ``t`` (if the recording of the state was
--        requested) averaged over all trajectories as a density matrix.
--
--    runs_states : list of list of :obj:`~Qobj`
--        The state for each trajectory and each time ``t`` (if the recording of
--        the states and trajectories was requested)
--
--    final_state : :obj:`~Qobj:
--        The final state (if the recording of the final state was requested)
--        averaged over all trajectories as a density matrix.
--
--    runs_final_state : list of :obj:`~Qobj`
--        The final state for each trajectory (if the recording of the final
--        state and trajectories was requested).
--
--    average_expect : list of array of expectation values
--        A list containing the values of each ``e_op`` averaged over each
--        trajectories. The list is in the same order in which the ``e_ops`` were
--        supplied and empty if no ``e_ops`` were given.
--
--        Each element is itself an array and contains the values of the
--        corresponding ``e_op``, with one value for each time in ``.times``.
--
--    std_expect : list of array of expectation values
--        A list containing the standard derivation of each ``e_op`` over each
--        trajectories. The list is in the same order in which the ``e_ops`` were
--        supplied and empty if no ``e_ops`` were given.
--
--        Each element is itself an array and contains the values of the
--        corresponding ``e_op``, with one value for each time in ``.times``.
--
--    runs_expect : list of array of expectation values
--        A list containing the values of each ``e_op`` for each trajectories.
--        The list is in the same order in which the ``e_ops`` were
--        supplied and empty if no ``e_ops`` were given. Only available if the
--        storing of trajectories was requested.
--
--        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
--
--        Each element is itself an array and contains the values of the
--        corresponding ``e_op``, with one value for each time in ``.times``.
--
--    average_e_data : dict
--        A dictionary containing the values of each ``e_op`` averaged over each
--        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
--        are the same as in that dictionary. Otherwise the keys are the index of
--        the ``e_op`` in the ``.expect`` list.
--
--        The lists of expectation values returned are the *same* lists as
--        those returned by ``.expect``.
--
--    average_e_data : dict
--        A dictionary containing the standard derivation of each ``e_op`` over
--        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
--        keys are the same as in that dictionary. Otherwise the keys are the
--        index of the ``e_op`` in the ``.expect`` list.
--
--        The lists of expectation values returned are the *same* lists as
--        those returned by ``.expect``.
--
--    runs_e_data : dict
--        A dictionary containing the values of each ``e_op`` for each
--        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
--        are the same as in that dictionary. Otherwise the keys are the index of
--        the ``e_op`` in the ``.expect`` list. Only available if the storing
--        of trajectories was requested.
--
--        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
--
--        The lists of expectation values returned are the *same* lists as
--        those returned by ``.expect``.
--
--    solver : str or None
--        The name of the solver generating these results.
--
--    stats : dict or None
--        The stats generated by the solver while producing these results.
--
--    options : :obj:`~SolverResultsOptions`
--        The options for this result class.
--    """
--    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
--        super().__init__(options, solver=solver, stats=stats)
--        self._raw_ops = self._e_ops_to_dict(e_ops)
--
--        self.times = []
--        self.trajectories = []
--        self.num_trajectories = 0
--        self.seeds = []
--
--        self._sum_states = None
--        self._sum_final_states = None
--        self._sum_expect = None
--        self._sum2_expect = None
--        self._target_tols = None
--
--        self.average_e_data = {}
--        self.e_data = {}
--        self.std_e_data = {}
--        self.runs_e_data = {}
--
--        self._post_init(**kw)
--
--    @staticmethod
--    def _to_dm(state):
--        if state.type == 'ket':
--            state = state.proj()
--        return state
--
--    def _add_first_traj(self, trajectory):
--        """
--        Read the first trajectory, intitializing needed data.
--        """
--        self.times = trajectory.times
--
--        if trajectory.states:
--            state = trajectory.states[0]
--            self._sum_states = [qzero(state.dims[0])
--                                for state in trajectory.states]
--        if trajectory.final_state:
--            state = trajectory.final_state
--            self._sum_final_states = qzero(state.dims[0])
--
--        self._sum_expect = [
--            np.zeros_like(expect) for expect in trajectory.expect
--        ]
--        self._sum2_expect = [
--            np.zeros_like(expect) for expect in trajectory.expect
--        ]
--
--        self.e_ops = trajectory.e_ops
--
--        self.average_e_data = {
--            k: list(avg_expect)
--            for k, avg_expect
--            in zip(self._raw_ops, self._sum_expect)
--        }
--        self.e_data = self.average_e_data
--        if self.options['keep_runs_results']:
--            self.runs_e_data = {k: [] for k in self._raw_ops}
--            self.e_data = self.runs_e_data
--
--    def _store_trajectory(self, trajectory):
--        self.trajectories.append(trajectory)
--
--    def _reduce_states(self, trajectory):
--        self._sum_states = [
--            accu + self._to_dm(state)
--            for accu, state
--            in zip(self._sum_states, trajectory.states)
--        ]
--
--    def _reduce_final_state(self, trajectory):
--        self._sum_final_states += self._to_dm(trajectory.final_state)
--
--    def _reduce_expect(self, trajectory):
--        """
--        Compute the average of the expectation values and store it in it's
--        multiple formats.
--        """
--        for i, k in enumerate(self._raw_ops):
--            expect_traj = trajectory.expect[i]
--
--            self._sum_expect[i] += expect_traj
--            self._sum2_expect[i] += expect_traj**2
--
--            avg = self._sum_expect[i] / self.num_trajectories
--            avg2 = self._sum2_expect[i] / self.num_trajectories
--
--            self.average_e_data[k] = list(avg)
--
--            # mean(expect**2) - mean(expect)**2 can something be very small
--            # negative (-1e-15) which raise an error for float sqrt.
--            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
--
--            if self.runs_e_data:
--                self.runs_e_data[k].append(trajectory.e_data[k])
--
--    def _increment_traj(self, trajectory):
--        if self.num_trajectories == 0:
--            self._add_first_traj(trajectory)
--        self.num_trajectories += 1
--
--    def _no_end(self):
--        """
--        Remaining number of trajectories needed to finish cannot be determined
--        by this object.
--        """
--        return np.inf
--
--    def _fixed_end(self):
--        """
--        Finish at a known number of trajectories.
--        """
--        ntraj_left = self._target_ntraj - self.num_trajectories
--        if ntraj_left == 0:
--            self.stats['end_condition'] = 'ntraj reached'
--        return ntraj_left
--
--    def _target_tolerance_end(self):
--        """
--        Compute the error on the expectation values using jackknife resampling.
--        Return the approximate number of trajectories needed to have this
--        error within the tolerance fot all e_ops and times.
--        """
--        if self.num_trajectories <= 1:
--            return np.inf
--        avg = np.array(self._sum_expect) / self.num_trajectories
--        avg2 = np.array(self._sum2_expect) / self.num_trajectories
--        target = np.array([
--            atol + rtol * mean
--            for mean, (atol, rtol)
--            in zip(avg, self._target_tols)
--        ])
--        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
--
--        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
--        if (self._estimated_ntraj - self.num_trajectories) <= 0:
--            self.stats['end_condition'] = 'target tolerance reached'
--        return self._estimated_ntraj - self.num_trajectories
--
--    def _post_init(self):
--        self.num_trajectories = 0
--        self._target_ntraj = None
--
--        store_states = self.options['store_states']
--        store_final_state = self.options['store_final_state']
--        store_traj = self.options['keep_runs_results']
--
--        self.add_processor(self._increment_traj)
--        if store_traj:
--            self.add_processor(self._store_trajectory)
--        if store_states is None:
--            store_states = len(self._raw_ops) == 0
--        if store_states:
--            self.add_processor(self._reduce_states)
--        if store_states or store_final_state:
--            self.add_processor(self._reduce_final_state)
--        if self._raw_ops:
--            self.add_processor(self._reduce_expect)
--
--        self._early_finish_check = self._no_end
--        self.stats['end_condition'] = 'unknown'
--
--    def add(self, trajectory_info):
--        """
--        Add a trajectory to the evolution.
--
--        Trajectories can be saved or average canbe extracted depending on the
--        options ``keep_runs_results``.
--
--        Parameters
--        ----------
--        trajectory_info : tuple of seed and trajectory
--            - seed: int, SeedSequence
--              Seed used to generate the trajectory.
--            - trajectory : :class:`Result`
--              Run result for one evolution over the times.
--
--        Return
--        ------
--        remaing_traj : number
--            Return the number of trajectories still needed to reach the target
--            tolerance. If no tolerance is provided, return infinity.
--        """
--        seed, trajectory = trajectory_info
--        self.seeds.append(seed)
--
--        for op in self._state_processors:
--            op(trajectory)
--
--        return self._early_finish_check()
--
--    def add_end_condition(self, ntraj, target_tol=None):
--        """
--        Set the condition to stop the computing trajectories when the certain
--        condition are fullfilled.
--        Supported end condition for multi trajectories computation are:
--        - Reaching a number of trajectories.
--        - Error bar on the expectation values reach smaller than a given
--          tolerance.
--
--        Parameters
--        ----------
--        ntraj : int
--            Number of trajectories expected.
--
--        target_tol : float, array_like, [optional]
--            Target tolerance of the evolution. The evolution will compute
--            trajectories until the error on the expectation values is lower
--            than this tolerance. The error is computed using jackknife
--            resampling. ``target_tol`` can be an absolute tolerance, a pair of
--            absolute and relative tolerance, in that order. Lastly, it can be a
--            list of pairs of (atol, rtol) for each e_ops.
--
--            Error estimation is done with jackknife resampling.
--        """
--        self._target_ntraj = ntraj
--        self.stats['end_condition'] = 'timeout'
--
--        if target_tol is None:
--            self._early_finish_check = self._fixed_end
--            return
--
--        num_e_ops = len(self._raw_ops)
--
--        if not num_e_ops:
--            raise ValueError("Cannot target a tolerance without e_ops")
--
--        self._estimated_ntraj = ntraj
--
--        targets = np.array(target_tol)
--        if targets.ndim == 0:
--            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
--        elif targets.shape == (2,):
--            self._target_tols = np.ones((num_e_ops, 2)) * targets
--        elif targets.shape == (num_e_ops, 2):
--            self._target_tols = targets
--        else:
--            raise ValueError("target_tol must be a number, a pair of (atol, "
--                             "rtol) or a list of (atol, rtol) for each e_ops")
--
--        self._early_finish_check = self._target_tolerance_end
--
--    @property
--    def runs_states(self):
--        """
--        States of every runs as ``states[run][t]``.
--        """
--        if self.trajectories and self.trajectories[0].states:
--            return [traj.states for traj in self.trajectories]
--        else:
--            return None
--
--    @property
--    def average_states(self):
--        """
--        States averages as density matrices.
--        """
--        if self._sum_states is None:
--            return None
--        return [final / self.num_trajectories for final in self._sum_states]
--
--    @property
--    def states(self):
--        """
--        Runs final states if available, average otherwise.
--        """
--        return self.runs_states or self.average_states
--
--    @property
--    def runs_final_states(self):
--        """
--        Last states of each trajectories.
--        """
--        if self.trajectories and self.trajectories[0].final_state:
--            return [traj.final_state for traj in self.trajectories]
--        else:
--            return None
--
--    @property
--    def average_final_state(self):
--        """
--        Last states of each trajectories averaged into a density matrix.
--        """
--        if self._sum_final_states is None:
--            return None
--        return self._sum_final_states / self.num_trajectories
--
--    @property
--    def final_state(self):
--        """
--        Runs final states if available, average otherwise.
--        """
--        return self.runs_final_states or self.average_final_state
--
--    @property
--    def average_expect(self):
--        return [np.array(val) for val in self.average_e_data.values()]
--
--    @property
--    def std_expect(self):
--        return [np.array(val) for val in self.std_e_data.values()]
--
--    @property
--    def runs_expect(self):
--        return [np.array(val) for val in self.runs_e_data.values()]
--
--    @property
--    def expect(self):
--        return [np.array(val) for val in self.e_data.values()]
--
--    def steady_state(self, N=0):
--        """
--        Average the states of the last ``N`` times of every runs as a density
--        matrix. Should converge to the steady state in the right circumstances.
--
--        Parameters
--        ----------
--        N : int [optional]
--            Number of states from the end of ``tlist`` to average. Per default
--            all states will be averaged.
--        """
--        N = int(N) or len(self.times)
--        N = len(self.times) if N > len(self.times) else N
--        states = self.average_states
--        if states is not None:
--            return sum(states[-N:]) / N
--        else:
--            return None
--
--    def __repr__(self):
--        lines = [
--            f"<{self.__class__.__name__}",
--            f"  Solver: {self.solver}",
--        ]
--        if self.stats:
--            lines.append("  Solver stats:")
--            lines.extend(
--                f"    {k}: {v!r}"
--                for k, v in self.stats.items()
--            )
--        if self.times:
--            lines.append(
--                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
--                f" ({len(self.times)} steps)"
--            )
--        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
--        if self.states:
--            lines.append("  States saved.")
--        elif self.final_state is not None:
--            lines.append("  Final state saved.")
--        else:
--            lines.append("  State not saved.")
--        lines.append(f"  Number of trajectories: {self.num_trajectories}")
--        if self.trajectories:
--            lines.append("  Trajectories saved.")
--        else:
--            lines.append("  Trajectories not saved.")
--        lines.append(">")
--        return "\n".join(lines)
--
--    def __add__(self, other):
--        if not isinstance(other, MultiTrajResult):
--            return NotImplemented
--        if self._raw_ops != other._raw_ops:
--            raise ValueError("Shared `e_ops` is required to merge results")
--        if self.times != other.times:
--            raise ValueError("Shared `times` are is required to merge results")
--        new = self.__class__(self._raw_ops, self.options,
--                             solver=self.solver, stats=self.stats)
--        if self.trajectories and other.trajectories:
--            new.trajectories = self.trajectories + other.trajectories
--        new.num_trajectories = self.num_trajectories + other.num_trajectories
--        new.times = self.times
--        new.seeds = self.seeds + other.seeds
--
--        if self._sum_states is not None and other._sum_states is not None:
--            new._sum_states = self._sum_states + other._sum_states
--
--        if (
--            self._sum_final_states is not None
--            and other._sum_final_states is not None
--        ):
--            new._sum_final_states = (
--                self._sum_final_states + other._sum_final_states
--            )
--        new._target_tols = None
--
--        new._sum_expect = []
--        new._sum2_expect = []
--        new.average_e_data = {}
--        new.std_e_data = {}
--
--        for i, k in enumerate(self._raw_ops):
--            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
--            new._sum2_expect.append(self._sum2_expect[i]
--                                    + other._sum2_expect[i])
--
--            avg = new._sum_expect[i] / new.num_trajectories
--            avg2 = new._sum2_expect[i] / new.num_trajectories
--
--            new.average_e_data[k] = list(avg)
--            new.e_data = new.average_e_data
--
--            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
--
--            if new.trajectories:
--                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
--                new.e_data = new.runs_e_data
--
--        new.stats["run time"] += other.stats["run time"]
--        new.stats['end_condition'] = "Merged results"
--
--        return new
--
--
--class McResult(MultiTrajResult):
--    """
--    Base class for storing solver results.
--
--    Parameters
--    ----------
--    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
--        The ``e_ops`` parameter defines the set of values to record at
--        each time step ``t``. If an element is a :obj:`~Qobj` or
--        :obj:`~QobjEvo` the value recorded is the expectation value of that
--        operator given the state at ``t``. If the element is a function, ``f``,
--        the value recorded is ``f(t, state)``.
--
--        The values are recorded in the ``.expect`` attribute of this result
--        object. ``.expect`` is a list, where each item contains the values
--        of the corresponding ``e_op``.
--
--    options : :obj:`~SolverResultsOptions`
--        The options for this result class.
--
--    solver : str or None
--        The name of the solver generating these results.
--
--    stats : dict
--        The stats generated by the solver while producing these results. Note
--        that the solver may update the stats directly while producing results.
--        Must include a value for "num_collapse".
--
--    kw : dict
--        Additional parameters specific to a result sub-class.
--
--    Properties
--    ----------
--    collapse : list
--        For each runs, a list of every collapse as a tuple of the time it
--        happened and the corresponding ``c_ops`` index.
--    """
--    # Collapse are only produced by mcsolve.
--
--    def _add_collapse(self, trajectory):
--        self.collapse.append(trajectory.collapse)
--
--    def _post_init(self):
--        super()._post_init()
--        self.num_c_ops = self.stats["num_collapse"]
--        self.collapse = []
--        self.add_processor(self._add_collapse)
--
--    @property
--    def col_times(self):
--        """
--        List of the times of the collapses for each runs.
--        """
--        out = []
--        for col_ in self.collapse:
--            col = list(zip(*col_))
--            col = ([] if len(col) == 0 else col[0])
--            out.append(col)
--        return out
--
--    @property
--    def col_which(self):
--        """
--        List of the indexes of the collapses for each runs.
--        """
--        out = []
--        for col_ in self.collapse:
--            col = list(zip(*col_))
--            col = ([] if len(col) == 0 else col[1])
--            out.append(col)
--        return out
--
--    @property
--    def photocurrent(self):
--        """
--        Average photocurrent or measurement of the evolution.
--        """
--        cols = [[] for _ in range(self.num_c_ops)]
--        tlist = self.times
--        for collapses in self.collapse:
--            for t, which in collapses:
--                cols[which].append(t)
--        mesurement = [
--            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
--            for i in range(self.num_c_ops)
--        ]
--        return mesurement
--
--    @property
--    def runs_photocurrent(self):
--        """
--        Photocurrent or measurement of each runs.
--        """
--        tlist = self.times
--        measurements = []
--        for collapses in self.collapse:
--            cols = [[] for _ in range(self.num_c_ops)]
--            for t, which in collapses:
--                cols[which].append(t)
--            measurements.append([
--                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
--                for i in range(self.num_c_ops)
--            ])
--        return measurements
-+""" Class for solve function results"""
-+import numpy as np
-+from ..core import Qobj, QobjEvo, expect, qzero
-+
-+__all__ = ["Result", "MultiTrajResult", "McResult"]
-+
-+
-+class _QobjExpectEop:
-+    """
-+    Pickable e_ops callable that calculates the expectation value for a given
-+    operator.
-+
-+    Parameters
-+    ----------
-+    op : :obj:`~Qobj`
-+        The expectation value operator.
-+    """
-+    def __init__(self, op):
-+        self.op = op
-+
-+    def __call__(self, t, state):
-+        return expect(self.op, state)
-+
-+
-+class ExpectOp:
-+    """
-+    A result e_op (expectation operation).
-+
-+    Parameters
-+    ----------
-+    op : object
-+        The original object used to define the e_op operation, e.g. a
-+        :~obj:`Qobj` or a function ``f(t, state)``.
-+
-+    f : function
-+        A callable ``f(t, state)`` that will return the value of the e_op
-+        for the specified state and time.
-+
-+    append : function
-+        A callable ``append(value)``, e.g. ``expect[k].append``, that will
-+        store the result of the e_ops function ``f(t, state)``.
-+
-+    Attributes
-+    ----------
-+    op : object
-+        The original object used to define the e_op operation.
-+    """
-+    def __init__(self, op, f, append):
-+        self.op = op
-+        self._f = f
-+        self._append = append
-+
-+    def __call__(self, t, state):
-+        """
-+        Return the expectation value for the given time, ``t`` and
-+        state, ``state``.
-+        """
-+        return self._f(t, state)
-+
-+    def _store(self, t, state):
-+        """
-+        Store the result of the e_op function. Should only be called by
-+        :class:`~Result`.
-+        """
-+        self._append(self._f(t, state))
-+
-+
-+class _BaseResult:
-+    """
-+    Common method for all ``Result``.
-+    """
-+    def __init__(self, options, *, solver=None, stats=None):
-+        self.solver = solver
-+        if stats is None:
-+            stats = {}
-+        self.stats = stats
-+
-+        self._state_processors = []
-+        self._state_processors_require_copy = False
-+
-+        self.options = options
-+
-+    def _e_ops_to_dict(self, e_ops):
-+        """ Convert the supplied e_ops to a dictionary of Eop instances. """
-+        if e_ops is None:
-+            e_ops = {}
-+        elif isinstance(e_ops, (list, tuple)):
-+            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
-+        elif isinstance(e_ops, dict):
-+            pass
-+        else:
-+            e_ops = {0: e_ops}
-+        return e_ops
-+
-+    def add_processor(self, f, requires_copy=False):
-+        """
-+        Append a processor ``f`` to the list of state processors.
-+
-+        Parameters
-+        ----------
-+        f : function, ``f(t, state)``
-+            A function to be called each time a state is added to this
-+            result object. The state is the state passed to ``.add``, after
-+            applying the pre-processors, if any.
-+
-+        requires_copy : bool, default False
-+            Whether this processor requires a copy of the state rather than
-+            a reference. A processor must never modify the supplied state, but
-+            if a processor stores the state it should set ``require_copy`` to
-+            true.
-+        """
-+        self._state_processors.append(f)
-+        self._state_processors_require_copy |= requires_copy
-+
-+
-+class Result(_BaseResult):
-+    """
-+    Base class for storing solver results.
-+
-+    Parameters
-+    ----------
-+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-+        The ``e_ops`` parameter defines the set of values to record at
-+        each time step ``t``. If an element is a :obj:`~Qobj` or
-+        :obj:`~QobjEvo` the value recorded is the expectation value of that
-+        operator given the state at ``t``. If the element is a function, ``f``,
-+        the value recorded is ``f(t, state)``.
-+
-+        The values are recorded in the ``e_data`` and ``expect`` attributes of
-+        this result object. ``e_data`` is a dictionary and ``expect`` is a
-+        list, where each item contains the values of the corresponding
-+        ``e_op``.
-+
-+    options : dict
-+        The options for this result class.
-+
-+    solver : str or None
-+        The name of the solver generating these results.
-+
-+    stats : dict or None
-+        The stats generated by the solver while producing these results. Note
-+        that the solver may update the stats directly while producing results.
-+
-+    kw : dict
-+        Additional parameters specific to a result sub-class.
-+
-+    Attributes
-+    ----------
-+    times : list
-+        A list of the times at which the expectation values and states were
-+        recorded.
-+
-+    states : list of :obj:`~Qobj`
-+        The state at each time ``t`` (if the recording of the state was
-+        requested).
-+
-+    final_state : :obj:`~Qobj`:
-+        The final state (if the recording of the final state was requested).
-+
-+    expect : list of arrays of expectation values
-+        A list containing the values of each ``e_op``. The list is in
-+        the same order in which the ``e_ops`` were supplied and empty if
-+        no ``e_ops`` were given.
-+
-+        Each element is itself a list and contains the values of the
-+        corresponding ``e_op``, with one value for each time in ``.times``.
-+
-+        The same lists of values may be accessed via the ``.e_data`` dictionary
-+        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
-+
-+    e_data : dict
-+        A dictionary containing the values of each ``e_op``. If the ``e_ops``
-+        were supplied as a dictionary, the keys are the same as in
-+        that dictionary. Otherwise the keys are the index of the ``e_op``
-+        in the ``.expect`` list.
-+
-+        The lists of expectation values returned are the *same* lists as
-+        those returned by ``.expect``.
-+
-+    e_ops : dict
-+        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
-+        The keys of the dictionary are the same as for ``.e_data``.
-+        Each value is object where ``.e_ops[k](t, state)`` calculates the
-+        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
-+        ``.e_ops[k].op`` is the original object supplied to create the
-+        ``e_op``.
-+
-+    solver : str or None
-+        The name of the solver generating these results.
-+
-+    stats : dict or None
-+        The stats generated by the solver while producing these results.
-+
-+    options : dict
-+        The options for this result class.
-+    """
-+    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
-+        super().__init__(options, solver=solver, stats=stats)
-+        raw_ops = self._e_ops_to_dict(e_ops)
-+        self.e_data = {k: [] for k in raw_ops}
-+        self.e_ops = {}
-+        for k, op in raw_ops.items():
-+            f = self._e_op_func(op)
-+            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
-+            self.add_processor(self.e_ops[k]._store)
-+
-+        self.times = []
-+        self.states = []
-+        self.final_state = None
-+
-+        self._post_init(**kw)
-+
-+    def _e_op_func(self, e_op):
-+        """
-+        Convert an e_op entry into a function, ``f(t, state)`` that returns
-+        the appropriate value (usually an expectation value).
-+
-+        Sub-classes may override this function to calculate expectation values
-+        in different ways.
-+        """
-+        if isinstance(e_op, Qobj):
-+            return _QobjExpectEop(e_op)
-+        elif isinstance(e_op, QobjEvo):
-+            return e_op.expect
-+        elif callable(e_op):
-+            return e_op
-+        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
-+
-+    def _post_init(self):
-+        """
-+        Perform post __init__ initialisation. In particular, add state
-+        processors or pre-processors.
-+
-+        Sub-class may override this. If the sub-class wishes to register the
-+        default processors for storing states, it should call this parent
-+        ``.post_init()`` method.
-+
-+        Sub-class ``.post_init()`` implementation may take additional keyword
-+        arguments if required.
-+        """
-+        store_states = self.options['store_states']
-+        store_final_state = self.options['store_final_state']
-+
-+        if store_states is None:
-+            store_states = len(self.e_ops) == 0
-+        if store_states:
-+            self.add_processor(self._store_state, requires_copy=True)
-+
-+        if store_states or store_final_state:
-+            self.add_processor(self._store_final_state, requires_copy=True)
-+
-+    def _store_state(self, t, state):
-+        """ Processor that stores a state in ``.states``. """
-+        self.states.append(state)
-+
-+    def _store_final_state(self, t, state):
-+        """ Processor that writes the state to ``.final_state``. """
-+        self.final_state = state
-+
-+    def _pre_copy(self, state):
-+        """ Return a copy of the state. Sub-classes may override this to
-+            copy a state in different manner or to skip making a copy
-+            altogether if a copy is not necessary.
-+        """
-+        return state.copy()
-+
-+    def add(self, t, state):
-+        """
-+        Add a state to the results for the time ``t`` of the evolution.
-+
-+        Adding a state calculates the expectation value of the state for
-+        each of the supplied ``e_ops`` and stores the result in ``.expect``.
-+
-+        The state is recorded in ``.states`` and ``.final_state`` if specified
-+        by the supplied result options.
-+
-+        Parameters
-+        ----------
-+        t : float
-+            The time of the added state.
-+
-+        state : typically a :obj:`~Qobj`
-+            The state a time ``t``. Usually this is a :obj:`~Qobj` with
-+            suitable dimensions, but it sub-classes of result might support
-+            other forms of the state.
-+
-+        .. note::
-+
-+           The expectation values, i.e. ``e_ops``, and states are recorded by
-+           the state processors (see ``.add_processor``).
-+
-+           Additional processors may be added by sub-classes.
-+        """
-+        self.times.append(t)
-+
-+        if self._state_processors_require_copy:
-+            state = self._pre_copy(state)
-+
-+        for op in self._state_processors:
-+            op(t, state)
-+
-+    def __repr__(self):
-+        lines = [
-+            f"<{self.__class__.__name__}",
-+            f"  Solver: {self.solver}",
-+        ]
-+        if self.stats:
-+            lines.append("  Solver stats:")
-+            lines.extend(
-+                f"    {k}: {v!r}"
-+                for k, v in self.stats.items()
-+            )
-+        if self.times:
-+            lines.append(
-+                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
-+                f" ({len(self.times)} steps)"
-+            )
-+        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
-+        if self.states:
-+            lines.append("  States saved.")
-+        elif self.final_state is not None:
-+            lines.append("  Final state saved.")
-+        else:
-+            lines.append("  State not saved.")
-+        lines.append(">")
-+        return "\n".join(lines)
-+
-+    @property
-+    def expect(self):
-+        return [np.array(e_op) for e_op in self.e_data.values()]
-+
-+
-+class MultiTrajResult(_BaseResult):
-+    """
-+    Base class for storing results for solver using multiple trajectories.
-+
-+    Parameters
-+    ----------
-+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-+        The ``e_ops`` parameter defines the set of values to record at
-+        each time step ``t``. If an element is a :obj:`~Qobj` or
-+        :obj:`~QobjEvo` the value recorded is the expectation value of that
-+        operator given the state at ``t``. If the element is a function, ``f``,
-+        the value recorded is ``f(t, state)``.
-+
-+        The values are recorded in the ``.expect`` attribute of this result
-+        object. ``.expect`` is a list, where each item contains the values
-+        of the corresponding ``e_op``.
-+
-+        Function ``e_ops`` must return a number so the average can be computed.
-+
-+    options : dict
-+        The options for this result class.
-+
-+    solver : str or None
-+        The name of the solver generating these results.
-+
-+    stats : dict or None
-+        The stats generated by the solver while producing these results. Note
-+        that the solver may update the stats directly while producing results.
-+
-+    kw : dict
-+        Additional parameters specific to a result sub-class.
-+
-+    Properties
-+    ----------
-+    times : list
-+        A list of the times at which the expectation values and states were
-+        recorded.
-+
-+    average_states : list of :obj:`~Qobj`
-+        The state at each time ``t`` (if the recording of the state was
-+        requested) averaged over all trajectories as a density matrix.
-+
-+    runs_states : list of list of :obj:`~Qobj`
-+        The state for each trajectory and each time ``t`` (if the recording of
-+        the states and trajectories was requested)
-+
-+    final_state : :obj:`~Qobj:
-+        The final state (if the recording of the final state was requested)
-+        averaged over all trajectories as a density matrix.
-+
-+    runs_final_state : list of :obj:`~Qobj`
-+        The final state for each trajectory (if the recording of the final
-+        state and trajectories was requested).
-+
-+    average_expect : list of array of expectation values
-+        A list containing the values of each ``e_op`` averaged over each
-+        trajectories. The list is in the same order in which the ``e_ops`` were
-+        supplied and empty if no ``e_ops`` were given.
-+
-+        Each element is itself an array and contains the values of the
-+        corresponding ``e_op``, with one value for each time in ``.times``.
-+
-+    std_expect : list of array of expectation values
-+        A list containing the standard derivation of each ``e_op`` over each
-+        trajectories. The list is in the same order in which the ``e_ops`` were
-+        supplied and empty if no ``e_ops`` were given.
-+
-+        Each element is itself an array and contains the values of the
-+        corresponding ``e_op``, with one value for each time in ``.times``.
-+
-+    runs_expect : list of array of expectation values
-+        A list containing the values of each ``e_op`` for each trajectories.
-+        The list is in the same order in which the ``e_ops`` were
-+        supplied and empty if no ``e_ops`` were given. Only available if the
-+        storing of trajectories was requested.
-+
-+        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
-+
-+        Each element is itself an array and contains the values of the
-+        corresponding ``e_op``, with one value for each time in ``.times``.
-+
-+    average_e_data : dict
-+        A dictionary containing the values of each ``e_op`` averaged over each
-+        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
-+        are the same as in that dictionary. Otherwise the keys are the index of
-+        the ``e_op`` in the ``.expect`` list.
-+
-+        The lists of expectation values returned are the *same* lists as
-+        those returned by ``.expect``.
-+
-+    average_e_data : dict
-+        A dictionary containing the standard derivation of each ``e_op`` over
-+        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
-+        keys are the same as in that dictionary. Otherwise the keys are the
-+        index of the ``e_op`` in the ``.expect`` list.
-+
-+        The lists of expectation values returned are the *same* lists as
-+        those returned by ``.expect``.
-+
-+    runs_e_data : dict
-+        A dictionary containing the values of each ``e_op`` for each
-+        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
-+        are the same as in that dictionary. Otherwise the keys are the index of
-+        the ``e_op`` in the ``.expect`` list. Only available if the storing
-+        of trajectories was requested.
-+
-+        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
-+
-+        The lists of expectation values returned are the *same* lists as
-+        those returned by ``.expect``.
-+
-+    solver : str or None
-+        The name of the solver generating these results.
-+
-+    stats : dict or None
-+        The stats generated by the solver while producing these results.
-+
-+    options : :obj:`~SolverResultsOptions`
-+        The options for this result class.
-+    """
-+    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
-+        super().__init__(options, solver=solver, stats=stats)
-+        self._raw_ops = self._e_ops_to_dict(e_ops)
-+
-+        self.times = []
-+        self.trajectories = []
-+        self.num_trajectories = 0
-+        self.seeds = []
-+
-+        self._sum_states = None
-+        self._sum_final_states = None
-+        self._sum_expect = None
-+        self._sum2_expect = None
-+        self._target_tols = None
-+
-+        self.average_e_data = {}
-+        self.e_data = {}
-+        self.std_e_data = {}
-+        self.runs_e_data = {}
-+
-+        self._post_init(**kw)
-+
-+    @staticmethod
-+    def _to_dm(state):
-+        if state.type == 'ket':
-+            state = state.proj()
-+        return state
-+
-+    def _add_first_traj(self, trajectory):
-+        """
-+        Read the first trajectory, intitializing needed data.
-+        """
-+        self.times = trajectory.times
-+
-+        if trajectory.states:
-+            state = trajectory.states[0]
-+            self._sum_states = [qzero(state.dims[0])
-+                                for state in trajectory.states]
-+        if trajectory.final_state:
-+            state = trajectory.final_state
-+            self._sum_final_states = qzero(state.dims[0])
-+
-+        self._sum_expect = [
-+            np.zeros_like(expect) for expect in trajectory.expect
-+        ]
-+        self._sum2_expect = [
-+            np.zeros_like(expect) for expect in trajectory.expect
-+        ]
-+
-+        self.e_ops = trajectory.e_ops
-+
-+        self.average_e_data = {
-+            k: list(avg_expect)
-+            for k, avg_expect
-+            in zip(self._raw_ops, self._sum_expect)
-+        }
-+        self.e_data = self.average_e_data
-+        if self.options['keep_runs_results']:
-+            self.runs_e_data = {k: [] for k in self._raw_ops}
-+            self.e_data = self.runs_e_data
-+
-+    def _store_trajectory(self, trajectory):
-+        self.trajectories.append(trajectory)
-+
-+    def _reduce_states(self, trajectory):
-+        self._sum_states = [
-+            accu + self._to_dm(state)
-+            for accu, state
-+            in zip(self._sum_states, trajectory.states)
-+        ]
-+
-+    def _reduce_final_state(self, trajectory):
-+        self._sum_final_states += self._to_dm(trajectory.final_state)
-+
-+    def _reduce_expect(self, trajectory):
-+        """
-+        Compute the average of the expectation values and store it in it's
-+        multiple formats.
-+        """
-+        for i, k in enumerate(self._raw_ops):
-+            expect_traj = trajectory.expect[i]
-+
-+            self._sum_expect[i] += expect_traj
-+            self._sum2_expect[i] += expect_traj**2
-+
-+            avg = self._sum_expect[i] / self.num_trajectories
-+            avg2 = self._sum2_expect[i] / self.num_trajectories
-+
-+            self.average_e_data[k] = list(avg)
-+
-+            # mean(expect**2) - mean(expect)**2 can something be very small
-+            # negative (-1e-15) which raise an error for float sqrt.
-+            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
-+
-+            if self.runs_e_data:
-+                self.runs_e_data[k].append(trajectory.e_data[k])
-+
-+    def _increment_traj(self, trajectory):
-+        if self.num_trajectories == 0:
-+            self._add_first_traj(trajectory)
-+        self.num_trajectories += 1
-+
-+    def _no_end(self):
-+        """
-+        Remaining number of trajectories needed to finish cannot be determined
-+        by this object.
-+        """
-+        return np.inf
-+
-+    def _fixed_end(self):
-+        """
-+        Finish at a known number of trajectories.
-+        """
-+        ntraj_left = self._target_ntraj - self.num_trajectories
-+        if ntraj_left == 0:
-+            self.stats['end_condition'] = 'ntraj reached'
-+        return ntraj_left
-+
-+    def _target_tolerance_end(self):
-+        """
-+        Compute the error on the expectation values using jackknife resampling.
-+        Return the approximate number of trajectories needed to have this
-+        error within the tolerance fot all e_ops and times.
-+        """
-+        if self.num_trajectories <= 1:
-+            return np.inf
-+        avg = np.array(self._sum_expect) / self.num_trajectories
-+        avg2 = np.array(self._sum2_expect) / self.num_trajectories
-+        target = np.array([
-+            atol + rtol * mean
-+            for mean, (atol, rtol)
-+            in zip(avg, self._target_tols)
-+        ])
-+        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
-+
-+        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
-+        if (self._estimated_ntraj - self.num_trajectories) <= 0:
-+            self.stats['end_condition'] = 'target tolerance reached'
-+        return self._estimated_ntraj - self.num_trajectories
-+
-+    def _post_init(self):
-+        self.num_trajectories = 0
-+        self._target_ntraj = None
-+
-+        store_states = self.options['store_states']
-+        store_final_state = self.options['store_final_state']
-+        store_traj = self.options['keep_runs_results']
-+
-+        self.add_processor(self._increment_traj)
-+        if store_traj:
-+            self.add_processor(self._store_trajectory)
-+        if store_states is None:
-+            store_states = len(self._raw_ops) == 0
-+        if store_states:
-+            self.add_processor(self._reduce_states)
-+        if store_states or store_final_state:
-+            self.add_processor(self._reduce_final_state)
-+        if self._raw_ops:
-+            self.add_processor(self._reduce_expect)
-+
-+        self._early_finish_check = self._no_end
-+        self.stats['end_condition'] = 'unknown'
-+
-+    def add(self, trajectory_info):
-+        """
-+        Add a trajectory to the evolution.
-+
-+        Trajectories can be saved or average canbe extracted depending on the
-+        options ``keep_runs_results``.
-+
-+        Parameters
-+        ----------
-+        trajectory_info : tuple of seed and trajectory
-+            - seed: int, SeedSequence
-+              Seed used to generate the trajectory.
-+            - trajectory : :class:`Result`
-+              Run result for one evolution over the times.
-+
-+        Return
-+        ------
-+        remaing_traj : number
-+            Return the number of trajectories still needed to reach the target
-+            tolerance. If no tolerance is provided, return infinity.
-+        """
-+        seed, trajectory = trajectory_info
-+        self.seeds.append(seed)
-+
-+        for op in self._state_processors:
-+            op(trajectory)
-+
-+        return self._early_finish_check()
-+
-+    def add_end_condition(self, ntraj, target_tol=None):
-+        """
-+        Set the condition to stop the computing trajectories when the certain
-+        condition are fullfilled.
-+        Supported end condition for multi trajectories computation are:
-+        - Reaching a number of trajectories.
-+        - Error bar on the expectation values reach smaller than a given
-+          tolerance.
-+
-+        Parameters
-+        ----------
-+        ntraj : int
-+            Number of trajectories expected.
-+
-+        target_tol : float, array_like, [optional]
-+            Target tolerance of the evolution. The evolution will compute
-+            trajectories until the error on the expectation values is lower
-+            than this tolerance. The error is computed using jackknife
-+            resampling. ``target_tol`` can be an absolute tolerance, a pair of
-+            absolute and relative tolerance, in that order. Lastly, it can be a
-+            list of pairs of (atol, rtol) for each e_ops.
-+
-+            Error estimation is done with jackknife resampling.
-+        """
-+        self._target_ntraj = ntraj
-+        self.stats['end_condition'] = 'timeout'
-+
-+        if target_tol is None:
-+            self._early_finish_check = self._fixed_end
-+            return
-+
-+        num_e_ops = len(self._raw_ops)
-+
-+        if not num_e_ops:
-+            raise ValueError("Cannot target a tolerance without e_ops")
-+
-+        self._estimated_ntraj = ntraj
-+
-+        targets = np.array(target_tol)
-+        if targets.ndim == 0:
-+            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
-+        elif targets.shape == (2,):
-+            self._target_tols = np.ones((num_e_ops, 2)) * targets
-+        elif targets.shape == (num_e_ops, 2):
-+            self._target_tols = targets
-+        else:
-+            raise ValueError("target_tol must be a number, a pair of (atol, "
-+                             "rtol) or a list of (atol, rtol) for each e_ops")
-+
-+        self._early_finish_check = self._target_tolerance_end
-+
-+    @property
-+    def runs_states(self):
-+        """
-+        States of every runs as ``states[run][t]``.
-+        """
-+        if self.trajectories and self.trajectories[0].states:
-+            return [traj.states for traj in self.trajectories]
-+        else:
-+            return None
-+
-+    @property
-+    def average_states(self):
-+        """
-+        States averages as density matrices.
-+        """
-+        if self._sum_states is None:
-+            return None
-+        return [final / self.num_trajectories for final in self._sum_states]
-+
-+    @property
-+    def states(self):
-+        """
-+        Runs final states if available, average otherwise.
-+        """
-+        return self.runs_states or self.average_states
-+
-+    @property
-+    def runs_final_states(self):
-+        """
-+        Last states of each trajectories.
-+        """
-+        if self.trajectories and self.trajectories[0].final_state:
-+            return [traj.final_state for traj in self.trajectories]
-+        else:
-+            return None
-+
-+    @property
-+    def average_final_state(self):
-+        """
-+        Last states of each trajectories averaged into a density matrix.
-+        """
-+        if self._sum_final_states is None:
-+            return None
-+        return self._sum_final_states / self.num_trajectories
-+
-+    @property
-+    def final_state(self):
-+        """
-+        Runs final states if available, average otherwise.
-+        """
-+        return self.runs_final_states or self.average_final_state
-+
-+    @property
-+    def average_expect(self):
-+        return [np.array(val) for val in self.average_e_data.values()]
-+
-+    @property
-+    def std_expect(self):
-+        return [np.array(val) for val in self.std_e_data.values()]
-+
-+    @property
-+    def runs_expect(self):
-+        return [np.array(val) for val in self.runs_e_data.values()]
-+
-+    @property
-+    def expect(self):
-+        return [np.array(val) for val in self.e_data.values()]
-+
-+    def steady_state(self, N=0):
-+        """
-+        Average the states of the last ``N`` times of every runs as a density
-+        matrix. Should converge to the steady state in the right circumstances.
-+
-+        Parameters
-+        ----------
-+        N : int [optional]
-+            Number of states from the end of ``tlist`` to average. Per default
-+            all states will be averaged.
-+        """
-+        N = int(N) or len(self.times)
-+        N = len(self.times) if N > len(self.times) else N
-+        states = self.average_states
-+        if states is not None:
-+            return sum(states[-N:]) / N
-+        else:
-+            return None
-+
-+    def __repr__(self):
-+        lines = [
-+            f"<{self.__class__.__name__}",
-+            f"  Solver: {self.solver}",
-+        ]
-+        if self.stats:
-+            lines.append("  Solver stats:")
-+            lines.extend(
-+                f"    {k}: {v!r}"
-+                for k, v in self.stats.items()
-+            )
-+        if self.times:
-+            lines.append(
-+                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
-+                f" ({len(self.times)} steps)"
-+            )
-+        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
-+        if self.states:
-+            lines.append("  States saved.")
-+        elif self.final_state is not None:
-+            lines.append("  Final state saved.")
-+        else:
-+            lines.append("  State not saved.")
-+        lines.append(f"  Number of trajectories: {self.num_trajectories}")
-+        if self.trajectories:
-+            lines.append("  Trajectories saved.")
-+        else:
-+            lines.append("  Trajectories not saved.")
-+        lines.append(">")
-+        return "\n".join(lines)
-+
-+    def __add__(self, other):
-+        if not isinstance(other, MultiTrajResult):
-+            return NotImplemented
-+        if self._raw_ops != other._raw_ops:
-+            raise ValueError("Shared `e_ops` is required to merge results")
-+        if self.times != other.times:
-+            raise ValueError("Shared `times` are is required to merge results")
-+        new = self.__class__(self._raw_ops, self.options,
-+                             solver=self.solver, stats=self.stats)
-+        if self.trajectories and other.trajectories:
-+            new.trajectories = self.trajectories + other.trajectories
-+        new.num_trajectories = self.num_trajectories + other.num_trajectories
-+        new.times = self.times
-+        new.seeds = self.seeds + other.seeds
-+
-+        if self._sum_states is not None and other._sum_states is not None:
-+            new._sum_states = self._sum_states + other._sum_states
-+
-+        if (
-+            self._sum_final_states is not None
-+            and other._sum_final_states is not None
-+        ):
-+            new._sum_final_states = (
-+                self._sum_final_states + other._sum_final_states
-+            )
-+        new._target_tols = None
-+
-+        new._sum_expect = []
-+        new._sum2_expect = []
-+        new.average_e_data = {}
-+        new.std_e_data = {}
-+
-+        for i, k in enumerate(self._raw_ops):
-+            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
-+            new._sum2_expect.append(self._sum2_expect[i]
-+                                    + other._sum2_expect[i])
-+
-+            avg = new._sum_expect[i] / new.num_trajectories
-+            avg2 = new._sum2_expect[i] / new.num_trajectories
-+
-+            new.average_e_data[k] = list(avg)
-+            new.e_data = new.average_e_data
-+
-+            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
-+
-+            if new.trajectories:
-+                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
-+                new.e_data = new.runs_e_data
-+
-+        new.stats["run time"] += other.stats["run time"]
-+        new.stats['end_condition'] = "Merged results"
-+
-+        return new
-+
-+
-+class McResult(MultiTrajResult):
-+    """
-+    Base class for storing solver results.
-+
-+    Parameters
-+    ----------
-+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-+        The ``e_ops`` parameter defines the set of values to record at
-+        each time step ``t``. If an element is a :obj:`~Qobj` or
-+        :obj:`~QobjEvo` the value recorded is the expectation value of that
-+        operator given the state at ``t``. If the element is a function, ``f``,
-+        the value recorded is ``f(t, state)``.
-+
-+        The values are recorded in the ``.expect`` attribute of this result
-+        object. ``.expect`` is a list, where each item contains the values
-+        of the corresponding ``e_op``.
-+
-+    options : :obj:`~SolverResultsOptions`
-+        The options for this result class.
-+
-+    solver : str or None
-+        The name of the solver generating these results.
-+
-+    stats : dict
-+        The stats generated by the solver while producing these results. Note
-+        that the solver may update the stats directly while producing results.
-+        Must include a value for "num_collapse".
-+
-+    kw : dict
-+        Additional parameters specific to a result sub-class.
-+
-+    Properties
-+    ----------
-+    collapse : list
-+        For each runs, a list of every collapse as a tuple of the time it
-+        happened and the corresponding ``c_ops`` index.
-+    """
-+    # Collapse are only produced by mcsolve.
-+
-+    def _add_collapse(self, trajectory):
-+        self.collapse.append(trajectory.collapse)
-+
-+    def _post_init(self):
-+        super()._post_init()
-+        self.num_c_ops = self.stats["num_collapse"]
-+        self.collapse = []
-+        self.add_processor(self._add_collapse)
-+
-+    @property
-+    def col_times(self):
-+        """
-+        List of the times of the collapses for each runs.
-+        """
-+        out = []
-+        for col_ in self.collapse:
-+            col = list(zip(*col_))
-+            col = ([] if len(col) == 0 else col[0])
-+            out.append(col)
-+        return out
-+
-+    @property
-+    def col_which(self):
-+        """
-+        List of the indexes of the collapses for each runs.
-+        """
-+        out = []
-+        for col_ in self.collapse:
-+            col = list(zip(*col_))
-+            col = ([] if len(col) == 0 else col[1])
-+            out.append(col)
-+        return out
-+
-+    @property
-+    def photocurrent(self):
-+        """
-+        Average photocurrent or measurement of the evolution.
-+        """
-+        cols = [[] for _ in range(self.num_c_ops)]
-+        tlist = self.times
-+        for collapses in self.collapse:
-+            for t, which in collapses:
-+                cols[which].append(t)
-+        mesurement = [
-+            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
-+            for i in range(self.num_c_ops)
-+        ]
-+        return mesurement
-+
-+    @property
-+    def runs_photocurrent(self):
-+        """
-+        Photocurrent or measurement of each runs.
-+        """
-+        tlist = self.times
-+        measurements = []
-+        for collapses in self.collapse:
-+            cols = [[] for _ in range(self.num_c_ops)]
-+            for t, which in collapses:
-+                cols[which].append(t)
-+            measurements.append([
-+                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
-+                for i in range(self.num_c_ops)
-+            ])
-+        return measurements
-diff --git a/qutip/solver/scattering.py b/qutip/solver/scattering.py
-index 5855832d..b7bdd251 100644
---- a/qutip/solver/scattering.py
-+++ b/qutip/solver/scattering.py
-@@ -1,301 +1,301 @@
--"""
--Photon scattering in quantum optical systems
--
--This module includes a collection of functions for numerically computing photon
--scattering in driven arbitrary systems coupled to some configuration of output
--waveguides. The implementation of these functions closely follows the
--mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
--Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
--"""
--# Author:  Ben Bartlett
--# Contact: benbartlett@stanford.edu
--
--import numpy as np
--from itertools import product, combinations_with_replacement
--from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
--from .propagator import propagator, Propagator
--
--__all__ = ['temporal_basis_vector',
--           'temporal_scattered_state',
--           'scattering_probability']
--
--
--def set_partition(collection, num_sets):
--    """
--    Enumerate all ways of partitioning collection into num_sets different
--    lists, e.g. :
--    list(set_partition([1,2], 2))
--    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
--
--    Parameters
--    ----------
--    collection : iterable
--        Collection to generate a set partition of.
--    num_sets : int
--        Number of sets to partition collection into.
--
--    Returns
--    -------
--    partition : iterable
--        The partitioning of collection into num_sets sets.
--    """
--    for partitioning in product(range(num_sets), repeat=len(collection)):
--        partition = [[] for _ in range(num_sets)]
--        for i, set_index in enumerate(partitioning):
--            partition[set_index].append(collection[i])
--        yield tuple(tuple(indices) for indices in partition)
--
--
--def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
--    """
--    Compute the scattering amplitude for a system emitting into multiple
--    waveguides.
--
--    Parameters
--    ----------
--    propagator : :class:Propagator
--        Propagator
--    c_ops : list
--        list of collapse operators for each waveguide; these are assumed to
--        include spontaneous decay rates, e.g.
--        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
--    tlist : array_like
--        List of times starting at the beginning and ending at the end of the
--        evolution.
--    taus : list-like
--        List of (list of emission times) for each waveguide.
--    psi : Qobj
--        State at the start of the evolution
--    psit : Qobj
--        State at the end of the evolution.
--    """
--    # Extract the full list of taus
--    tau_collapse = []
--    for i, tau_wg in enumerate(taus):
--        for t in tau_wg:
--            tau_collapse.append((t, i))
--    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
--
--    tq = tlist[0]
--    # Compute Prod Ueff(tq, tq-1)
--    for tau in tau_collapse:
--        tprev = tq
--        tq, q = tau
--        psi = c_ops[q] * propagator(tq, tprev) * psi
--
--    psi = propagator(tlist[-1], tq) * psi
--    return psit.overlap(psi)
--
--
--def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
--    """
--    Generate a the global index for the excitation.
--    """
--    idx = []
--    for i, wg_indices in enumerate(waveguide_emission_indices):
--        for index in wg_indices:
--            idx += [i * n_time_bins + index]
--    idx = idx or [0]
--    return tuple(idx)
--
--
--def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
--                         n_emissions=None):
--    """
--    Return the dims of the ``temporal_basis_vector``.
--    """
--    num_col = len(waveguide_emission_indices)
--    if n_emissions is None:
--        n_emissions = sum(
--            [len(waveguide_indices)
--             for waveguide_indices in waveguide_emission_indices])
--    n_emissions = n_emissions or 1
--    return [num_col * n_time_bins] * n_emissions
--
--
--def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
--                          n_emissions=None):
--    """
--    Generate a temporal basis vector for emissions at specified time bins into
--    specified waveguides.
--
--    Parameters
--    ----------
--    waveguide_emission_indices : list or tuple
--        List of indices where photon emission occurs for each waveguide,
--        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
--    n_time_bins : int
--        Number of time bins; the range over which each index can vary.
--
--    Returns
--    -------
--    temporal_basis_vector : :class: qutip.Qobj
--        A basis vector representing photon scattering at the specified indices.
--        If there are W waveguides, T times, and N photon emissions, then the
--        basis vector has dimensionality (W*T)^N.
--    """
--    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
--    dims = _temporal_basis_dims(waveguide_emission_indices,
--                                n_time_bins, n_emissions)
--    return basis(dims, list(idx))
--
--
--def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
--                               system_zero_state=None,
--                               construct_effective_hamiltonian=True):
--    """
--    Compute the scattered n-photon state as an ndarray.
--    """
--    T = len(tlist)
--    W = len(c_ops)
--    em_dims = max(n_emissions, 1)
--    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
--
--    if construct_effective_hamiltonian:
--        # Construct an effective Hamiltonian from system hamiltonian and c_ops
--        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
--    else:
--        Heff = H
--
--    evolver = Propagator(Heff, memoize=len(tlist))
--
--    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
--
--    if system_zero_state is None:
--        system_zero_state = psi0
--
--    # Compute <omega_tau> for all combinations of tau
--    for emission_indices in all_emission_indices:
--        # Consider unique partitionings of emission times into waveguides
--        partition = tuple(set(set_partition(emission_indices, W)))
--        # Consider all possible partitionings of time bins by waveguide
--        for indices in partition:
--            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
--            phi_n_amp = photon_scattering_amplitude(
--                evolver, c_ops, tlist,
--                taus, psi0, system_zero_state
--            )
--            # Add scatter amplitude times temporal basis to overall state
--            idx = _temporal_basis_idx(indices, T)
--            phi_n[idx] = phi_n_amp
--    return phi_n
--
--
--def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
--                             system_zero_state=None,
--                             construct_effective_hamiltonian=True):
--    """
--    Compute the scattered n-photon state projected onto the temporal basis.
--
--    Parameters
--    ----------
--    H : :class: qutip.Qobj or list
--        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
--        list-callback format. If construct_effective_hamiltonian is not
--        specified, an effective Hamiltonian is constructed from `H` and
--        `c_ops`.
--    psi0 : :class: qutip.Qobj
--        Initial state density matrix :math:`\\rho(t_0)` or state vector
--        :math:`\\psi(t_0)`.
--    n_emissions : int
--        Number of photon emissions to calculate.
--    c_ops : list
--        List of collapse operators for each waveguide; these are assumed to
--        include spontaneous decay rates, e.g.
--        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
--    tlist : array_like
--        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
--        the pulse duration / temporal region of interest.
--    system_zero_state : :class: qutip.Qobj
--        State representing zero excitations in the system. Defaults to
--        :math:`\\psi(t_0)`
--    construct_effective_hamiltonian : bool
--        Whether an effective Hamiltonian should be constructed from H and
--        c_ops:
--        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
--        Default: True.
--
--    Returns
--    -------
--    phi_n : :class: qutip.Qobj
--        The scattered bath state projected onto the temporal basis given by
--        tlist. If there are W waveguides, T times, and N photon emissions, then
--        the state is a tensor product state with dimensionality T^(W*N).
--    """
--    T = len(tlist)
--    W = len(c_ops)
--    em_dims = max(n_emissions, 1)
--    phi_n = _temporal_scattered_matrix(
--        H, psi0, n_emissions, c_ops, tlist,
--        system_zero_state, construct_effective_hamiltonian
--    )
--    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
--
--
--def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
--                           system_zero_state=None,
--                           construct_effective_hamiltonian=True):
--    """
--    Compute the integrated probability of scattering n photons in an arbitrary
--    system. This function accepts a nonlinearly spaced array of times.
--
--    Parameters
--    ----------
--    H : :class: qutip.Qobj or list
--        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
--        list-callback format. If construct_effective_hamiltonian is not
--        specified, an effective Hamiltonian is constructed from H and
--        `c_ops`.
--    psi0 : :class: qutip.Qobj
--        Initial state density matrix :math:`\\rho(t_0)` or state vector
--        :math:`\\psi(t_0)`.
--    n_emissions : int
--        Number of photons emitted by the system (into any combination of
--        waveguides).
--    c_ops : list
--        List of collapse operators for each waveguide; these are assumed to
--        include spontaneous decay rates, e.g.
--        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
--    tlist : array_like
--        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
--        the pulse duration / temporal region of interest; tlist need not be
--        linearly spaced.
--    system_zero_state : :class: qutip.Qobj
--        State representing zero excitations in the system. Defaults to
--        `basis(systemDims, 0)`.
--    construct_effective_hamiltonian : bool
--        Whether an effective Hamiltonian should be constructed from H and
--        c_ops:
--        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
--        Default: True.
--
--    Returns
--    -------
--    scattering_prob : float
--        The probability of scattering n photons from the system over the time
--        range specified.
--    """
--    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
--                                       system_zero_state,
--                                       construct_effective_hamiltonian)
--    T = len(tlist)
--    W = len(c_ops)
--
--    # Compute <omega_tau> for all combinations of tau
--    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
--    probs = np.zeros([T] * n_emissions)
--
--    # Project scattered state onto temporal basis
--    for emit_indices in all_emission_indices:
--        # Consider unique emission time partitionings
--        partition = tuple(set(set_partition(emit_indices, W)))
--        # wg_indices_list = list(set_partition(indices, W))
--        for wg_indices in partition:
--            idx = _temporal_basis_idx(wg_indices, T)
--            amplitude = phi_n[idx]
--            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
--
--    # Iteratively integrate to obtain single value
--    while probs.shape != ():
--        probs = np.trapz(probs, x=tlist)
--    return np.abs(probs)
-+"""
-+Photon scattering in quantum optical systems
-+
-+This module includes a collection of functions for numerically computing photon
-+scattering in driven arbitrary systems coupled to some configuration of output
-+waveguides. The implementation of these functions closely follows the
-+mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
-+Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
-+"""
-+# Author:  Ben Bartlett
-+# Contact: benbartlett@stanford.edu
-+
-+import numpy as np
-+from itertools import product, combinations_with_replacement
-+from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
-+from .propagator import propagator, Propagator
-+
-+__all__ = ['temporal_basis_vector',
-+           'temporal_scattered_state',
-+           'scattering_probability']
-+
-+
-+def set_partition(collection, num_sets):
-+    """
-+    Enumerate all ways of partitioning collection into num_sets different
-+    lists, e.g. :
-+    list(set_partition([1,2], 2))
-+    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
-+
-+    Parameters
-+    ----------
-+    collection : iterable
-+        Collection to generate a set partition of.
-+    num_sets : int
-+        Number of sets to partition collection into.
-+
-+    Returns
-+    -------
-+    partition : iterable
-+        The partitioning of collection into num_sets sets.
-+    """
-+    for partitioning in product(range(num_sets), repeat=len(collection)):
-+        partition = [[] for _ in range(num_sets)]
-+        for i, set_index in enumerate(partitioning):
-+            partition[set_index].append(collection[i])
-+        yield tuple(tuple(indices) for indices in partition)
-+
-+
-+def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
-+    """
-+    Compute the scattering amplitude for a system emitting into multiple
-+    waveguides.
-+
-+    Parameters
-+    ----------
-+    propagator : :class:Propagator
-+        Propagator
-+    c_ops : list
-+        list of collapse operators for each waveguide; these are assumed to
-+        include spontaneous decay rates, e.g.
-+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
-+    tlist : array_like
-+        List of times starting at the beginning and ending at the end of the
-+        evolution.
-+    taus : list-like
-+        List of (list of emission times) for each waveguide.
-+    psi : Qobj
-+        State at the start of the evolution
-+    psit : Qobj
-+        State at the end of the evolution.
-+    """
-+    # Extract the full list of taus
-+    tau_collapse = []
-+    for i, tau_wg in enumerate(taus):
-+        for t in tau_wg:
-+            tau_collapse.append((t, i))
-+    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
-+
-+    tq = tlist[0]
-+    # Compute Prod Ueff(tq, tq-1)
-+    for tau in tau_collapse:
-+        tprev = tq
-+        tq, q = tau
-+        psi = c_ops[q] * propagator(tq, tprev) * psi
-+
-+    psi = propagator(tlist[-1], tq) * psi
-+    return psit.overlap(psi)
-+
-+
-+def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
-+    """
-+    Generate a the global index for the excitation.
-+    """
-+    idx = []
-+    for i, wg_indices in enumerate(waveguide_emission_indices):
-+        for index in wg_indices:
-+            idx += [i * n_time_bins + index]
-+    idx = idx or [0]
-+    return tuple(idx)
-+
-+
-+def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
-+                         n_emissions=None):
-+    """
-+    Return the dims of the ``temporal_basis_vector``.
-+    """
-+    num_col = len(waveguide_emission_indices)
-+    if n_emissions is None:
-+        n_emissions = sum(
-+            [len(waveguide_indices)
-+             for waveguide_indices in waveguide_emission_indices])
-+    n_emissions = n_emissions or 1
-+    return [num_col * n_time_bins] * n_emissions
-+
-+
-+def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
-+                          n_emissions=None):
-+    """
-+    Generate a temporal basis vector for emissions at specified time bins into
-+    specified waveguides.
-+
-+    Parameters
-+    ----------
-+    waveguide_emission_indices : list or tuple
-+        List of indices where photon emission occurs for each waveguide,
-+        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
-+    n_time_bins : int
-+        Number of time bins; the range over which each index can vary.
-+
-+    Returns
-+    -------
-+    temporal_basis_vector : :class: qutip.Qobj
-+        A basis vector representing photon scattering at the specified indices.
-+        If there are W waveguides, T times, and N photon emissions, then the
-+        basis vector has dimensionality (W*T)^N.
-+    """
-+    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
-+    dims = _temporal_basis_dims(waveguide_emission_indices,
-+                                n_time_bins, n_emissions)
-+    return basis(dims, list(idx))
-+
-+
-+def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
-+                               system_zero_state=None,
-+                               construct_effective_hamiltonian=True):
-+    """
-+    Compute the scattered n-photon state as an ndarray.
-+    """
-+    T = len(tlist)
-+    W = len(c_ops)
-+    em_dims = max(n_emissions, 1)
-+    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
-+
-+    if construct_effective_hamiltonian:
-+        # Construct an effective Hamiltonian from system hamiltonian and c_ops
-+        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
-+    else:
-+        Heff = H
-+
-+    evolver = Propagator(Heff, memoize=len(tlist))
-+
-+    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
-+
-+    if system_zero_state is None:
-+        system_zero_state = psi0
-+
-+    # Compute <omega_tau> for all combinations of tau
-+    for emission_indices in all_emission_indices:
-+        # Consider unique partitionings of emission times into waveguides
-+        partition = tuple(set(set_partition(emission_indices, W)))
-+        # Consider all possible partitionings of time bins by waveguide
-+        for indices in partition:
-+            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
-+            phi_n_amp = photon_scattering_amplitude(
-+                evolver, c_ops, tlist,
-+                taus, psi0, system_zero_state
-+            )
-+            # Add scatter amplitude times temporal basis to overall state
-+            idx = _temporal_basis_idx(indices, T)
-+            phi_n[idx] = phi_n_amp
-+    return phi_n
-+
-+
-+def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
-+                             system_zero_state=None,
-+                             construct_effective_hamiltonian=True):
-+    """
-+    Compute the scattered n-photon state projected onto the temporal basis.
-+
-+    Parameters
-+    ----------
-+    H : :class: qutip.Qobj or list
-+        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
-+        list-callback format. If construct_effective_hamiltonian is not
-+        specified, an effective Hamiltonian is constructed from `H` and
-+        `c_ops`.
-+    psi0 : :class: qutip.Qobj
-+        Initial state density matrix :math:`\\rho(t_0)` or state vector
-+        :math:`\\psi(t_0)`.
-+    n_emissions : int
-+        Number of photon emissions to calculate.
-+    c_ops : list
-+        List of collapse operators for each waveguide; these are assumed to
-+        include spontaneous decay rates, e.g.
-+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
-+    tlist : array_like
-+        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
-+        the pulse duration / temporal region of interest.
-+    system_zero_state : :class: qutip.Qobj
-+        State representing zero excitations in the system. Defaults to
-+        :math:`\\psi(t_0)`
-+    construct_effective_hamiltonian : bool
-+        Whether an effective Hamiltonian should be constructed from H and
-+        c_ops:
-+        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
-+        Default: True.
-+
-+    Returns
-+    -------
-+    phi_n : :class: qutip.Qobj
-+        The scattered bath state projected onto the temporal basis given by
-+        tlist. If there are W waveguides, T times, and N photon emissions, then
-+        the state is a tensor product state with dimensionality T^(W*N).
-+    """
-+    T = len(tlist)
-+    W = len(c_ops)
-+    em_dims = max(n_emissions, 1)
-+    phi_n = _temporal_scattered_matrix(
-+        H, psi0, n_emissions, c_ops, tlist,
-+        system_zero_state, construct_effective_hamiltonian
-+    )
-+    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
-+
-+
-+def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
-+                           system_zero_state=None,
-+                           construct_effective_hamiltonian=True):
-+    """
-+    Compute the integrated probability of scattering n photons in an arbitrary
-+    system. This function accepts a nonlinearly spaced array of times.
-+
-+    Parameters
-+    ----------
-+    H : :class: qutip.Qobj or list
-+        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
-+        list-callback format. If construct_effective_hamiltonian is not
-+        specified, an effective Hamiltonian is constructed from H and
-+        `c_ops`.
-+    psi0 : :class: qutip.Qobj
-+        Initial state density matrix :math:`\\rho(t_0)` or state vector
-+        :math:`\\psi(t_0)`.
-+    n_emissions : int
-+        Number of photons emitted by the system (into any combination of
-+        waveguides).
-+    c_ops : list
-+        List of collapse operators for each waveguide; these are assumed to
-+        include spontaneous decay rates, e.g.
-+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
-+    tlist : array_like
-+        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
-+        the pulse duration / temporal region of interest; tlist need not be
-+        linearly spaced.
-+    system_zero_state : :class: qutip.Qobj
-+        State representing zero excitations in the system. Defaults to
-+        `basis(systemDims, 0)`.
-+    construct_effective_hamiltonian : bool
-+        Whether an effective Hamiltonian should be constructed from H and
-+        c_ops:
-+        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
-+        Default: True.
-+
-+    Returns
-+    -------
-+    scattering_prob : float
-+        The probability of scattering n photons from the system over the time
-+        range specified.
-+    """
-+    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
-+                                       system_zero_state,
-+                                       construct_effective_hamiltonian)
-+    T = len(tlist)
-+    W = len(c_ops)
-+
-+    # Compute <omega_tau> for all combinations of tau
-+    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
-+    probs = np.zeros([T] * n_emissions)
-+
-+    # Project scattered state onto temporal basis
-+    for emit_indices in all_emission_indices:
-+        # Consider unique emission time partitionings
-+        partition = tuple(set(set_partition(emit_indices, W)))
-+        # wg_indices_list = list(set_partition(indices, W))
-+        for wg_indices in partition:
-+            idx = _temporal_basis_idx(wg_indices, T)
-+            amplitude = phi_n[idx]
-+            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
-+
-+    # Iteratively integrate to obtain single value
-+    while probs.shape != ():
-+        probs = np.trapz(probs, x=tlist)
-+    return np.abs(probs)
-diff --git a/qutip/solver/sesolve.py b/qutip/solver/sesolve.py
-index 09146242..8ed998ba 100644
---- a/qutip/solver/sesolve.py
-+++ b/qutip/solver/sesolve.py
-@@ -1,189 +1,189 @@
--"""
--This module provides solvers for the unitary Schrodinger equation.
--"""
--
--__all__ = ['sesolve', 'SESolver']
--
--import numpy as np
--from time import time
--from .. import Qobj, QobjEvo
--from .solver_base import Solver
--
--
--def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
--    """
--    Schrodinger equation evolution of a state vector or unitary matrix
--    for a given Hamiltonian.
--
--    Evolve the state vector (`psi0`) using a given
--    Hamiltonian (`H`), by integrating the set of ordinary differential
--    equations that define the system. Alternatively evolve a unitary matrix in
--    solving the Schrodinger operator equation.
--
--    The output is either the state vector or unitary matrix at arbitrary points
--    in time (`tlist`), or the expectation values of the supplied operators
--    (`e_ops`). If e_ops is a callback function, it is invoked for each
--    time in `tlist` with time and the state as arguments, and the function
--    does not use any return values. e_ops cannot be used in conjunction
--    with solving the Schrodinger operator equation
--
--    **Time-dependent operators**
--
--    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
--    object that can be interpreted as :class:`QobjEvo` such as a list of
--    (Qobj, Coefficient) pairs or a function.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
--        System Hamiltonian as a Qobj or QobjEvo for time-dependent
--        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
--        that can be made into :class:`QobjEvo` are also accepted.
--
--    psi0 : :class:`qutip.qobj`
--        initial state vector (ket)
--        or initial unitary operator `psi0 = U`
--
--    tlist : *list* / *array*
--        list of times for :math:`t`.
--
--    e_ops : :class:`qutip.qobj`, callable, or list.
--        Single operator or list of operators for which to evaluate
--        expectation values or callable or list of callable.
--        Callable signature must be, `f(t: float, state: Qobj)`.
--        See :func:`expect` for more detail of operator expectation.
--
--    args : None / *dictionary*
--        dictionary of parameters for time-dependent Hamiltonians
--
--    options : None / dict
--        Dictionary of options for the solver.
--
--        - store_final_state : bool
--          Whether or not to store the final state of the evolution in the
--          result class.
--        - store_states : bool, None
--          Whether or not to store the state vectors or density matrices.
--          On `None` the states will be saved if no expectation operators are
--          given.
--        - normalize_output : bool
--          Normalize output state to hide ODE numerical errors.
--        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
--          How to present the solver progress.
--          'tqdm' uses the python module of the same name and raise an error
--          if not installed. Empty string or False will disable the bar.
--        - progress_kwargs : dict
--          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
--        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
--          Which differential equation integration method to use.
--        - atol, rtol : float
--          Absolute and relative tolerance of the ODE integrator.
--        - nsteps :
--          Maximum number of (internally defined) steps allowed in one ``tlist``
--          step.
--        - max_step : float, 0
--          Maximum lenght of one internal step. When using pulses, it should be
--          less than half the width of the thinnest pulse.
--
--        Other options could be supported depending on the integration method,
--        see `Integrator <./classes.html#classes-ode>`_.
--
--    Returns
--    -------
--    result: :class:`qutip.Result`
--
--        An instance of the class :class:`qutip.Result`, which contains
--        a *list of array* `result.expect` of expectation values for the times
--        specified by `tlist`, and/or a *list* `result.states` of state vectors
--        or density matrices corresponding to the times in `tlist` [if `e_ops`
--        is an empty list of `store_states=True` in options].
--    """
--    H = QobjEvo(H, args=args, tlist=tlist)
--    solver = SESolver(H, options=options)
--    return solver.run(psi0, tlist, e_ops=e_ops)
--
--
--class SESolver(Solver):
--    """
--    Schrodinger equation evolution of a state vector or unitary matrix
--    for a given Hamiltonian.
--
--    Parameters
--    ----------
--    H : :class:`Qobj`, :class:`QobjEvo`
--        System Hamiltonian as a Qobj or QobjEvo for time-dependent
--        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
--        that can be made into :class:`QobjEvo` are also accepted.
--
--    options : dict, optional
--        Options for the solver, see :obj:`SESolver.options` and
--        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
--
--    attributes
--    ----------
--    stats: dict
--        Diverse diagnostic statistics of the evolution.
--    """
--    name = "sesolve"
--    _avail_integrators = {}
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size":10},
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": True,
--        'method': 'adams',
--    }
--
--    def __init__(self, H, *, options=None):
--        _time_start = time()
--
--        if not isinstance(H, (Qobj, QobjEvo)):
--            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
--
--        rhs = -1j * H
--        if not rhs.isoper:
--            raise ValueError("The hamiltonian must be an operator")
--        super().__init__(rhs, options=options)
--
--    def _initialize_stats(self):
--        stats = super()._initialize_stats()
--        stats.update({
--            "solver": "Schrodinger Evolution",
--        })
--        return stats
--
--    @property
--    def options(self):
--        """
--        Solver's options:
--
--        store_final_state: bool, default=False
--            Whether or not to store the final state of the evolution in the
--            result class.
--
--        store_states: bool, default=None
--            Whether or not to store the state vectors or density matrices.
--            On `None` the states will be saved if no expectation operators are
--            given.
--
--        normalize_output: bool, default=True
--            Normalize output state to hide ODE numerical errors.
--
--        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
--            How to present the solver progress.
--            'tqdm' uses the python module of the same name and raise an error
--            if not installed. Empty string or False will disable the bar.
--
--        progress_kwargs: dict, default={"chunk_size": 10}
--            Arguments to pass to the progress_bar. Qutip's bars use
--            ``chunk_size``.
--
--        method: str, default="adams"
--            Which ordinary differential equation integration method to use.
--        """
--        return self._options
--
--    @options.setter
--    def options(self, new_options):
--        Solver.options.fset(self, new_options)
-+"""
-+This module provides solvers for the unitary Schrodinger equation.
-+"""
-+
-+__all__ = ['sesolve', 'SESolver']
-+
-+import numpy as np
-+from time import time
-+from .. import Qobj, QobjEvo
-+from .solver_base import Solver
-+
-+
-+def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
-+    """
-+    Schrodinger equation evolution of a state vector or unitary matrix
-+    for a given Hamiltonian.
-+
-+    Evolve the state vector (`psi0`) using a given
-+    Hamiltonian (`H`), by integrating the set of ordinary differential
-+    equations that define the system. Alternatively evolve a unitary matrix in
-+    solving the Schrodinger operator equation.
-+
-+    The output is either the state vector or unitary matrix at arbitrary points
-+    in time (`tlist`), or the expectation values of the supplied operators
-+    (`e_ops`). If e_ops is a callback function, it is invoked for each
-+    time in `tlist` with time and the state as arguments, and the function
-+    does not use any return values. e_ops cannot be used in conjunction
-+    with solving the Schrodinger operator equation
-+
-+    **Time-dependent operators**
-+
-+    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
-+    object that can be interpreted as :class:`QobjEvo` such as a list of
-+    (Qobj, Coefficient) pairs or a function.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-+        that can be made into :class:`QobjEvo` are also accepted.
-+
-+    psi0 : :class:`qutip.qobj`
-+        initial state vector (ket)
-+        or initial unitary operator `psi0 = U`
-+
-+    tlist : *list* / *array*
-+        list of times for :math:`t`.
-+
-+    e_ops : :class:`qutip.qobj`, callable, or list.
-+        Single operator or list of operators for which to evaluate
-+        expectation values or callable or list of callable.
-+        Callable signature must be, `f(t: float, state: Qobj)`.
-+        See :func:`expect` for more detail of operator expectation.
-+
-+    args : None / *dictionary*
-+        dictionary of parameters for time-dependent Hamiltonians
-+
-+    options : None / dict
-+        Dictionary of options for the solver.
-+
-+        - store_final_state : bool
-+          Whether or not to store the final state of the evolution in the
-+          result class.
-+        - store_states : bool, None
-+          Whether or not to store the state vectors or density matrices.
-+          On `None` the states will be saved if no expectation operators are
-+          given.
-+        - normalize_output : bool
-+          Normalize output state to hide ODE numerical errors.
-+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-+          How to present the solver progress.
-+          'tqdm' uses the python module of the same name and raise an error
-+          if not installed. Empty string or False will disable the bar.
-+        - progress_kwargs : dict
-+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-+          Which differential equation integration method to use.
-+        - atol, rtol : float
-+          Absolute and relative tolerance of the ODE integrator.
-+        - nsteps :
-+          Maximum number of (internally defined) steps allowed in one ``tlist``
-+          step.
-+        - max_step : float, 0
-+          Maximum lenght of one internal step. When using pulses, it should be
-+          less than half the width of the thinnest pulse.
-+
-+        Other options could be supported depending on the integration method,
-+        see `Integrator <./classes.html#classes-ode>`_.
-+
-+    Returns
-+    -------
-+    result: :class:`qutip.Result`
-+
-+        An instance of the class :class:`qutip.Result`, which contains
-+        a *list of array* `result.expect` of expectation values for the times
-+        specified by `tlist`, and/or a *list* `result.states` of state vectors
-+        or density matrices corresponding to the times in `tlist` [if `e_ops`
-+        is an empty list of `store_states=True` in options].
-+    """
-+    H = QobjEvo(H, args=args, tlist=tlist)
-+    solver = SESolver(H, options=options)
-+    return solver.run(psi0, tlist, e_ops=e_ops)
-+
-+
-+class SESolver(Solver):
-+    """
-+    Schrodinger equation evolution of a state vector or unitary matrix
-+    for a given Hamiltonian.
-+
-+    Parameters
-+    ----------
-+    H : :class:`Qobj`, :class:`QobjEvo`
-+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-+        that can be made into :class:`QobjEvo` are also accepted.
-+
-+    options : dict, optional
-+        Options for the solver, see :obj:`SESolver.options` and
-+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-+
-+    attributes
-+    ----------
-+    stats: dict
-+        Diverse diagnostic statistics of the evolution.
-+    """
-+    name = "sesolve"
-+    _avail_integrators = {}
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size":10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": True,
-+        'method': 'adams',
-+    }
-+
-+    def __init__(self, H, *, options=None):
-+        _time_start = time()
-+
-+        if not isinstance(H, (Qobj, QobjEvo)):
-+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-+
-+        rhs = -1j * H
-+        if not rhs.isoper:
-+            raise ValueError("The hamiltonian must be an operator")
-+        super().__init__(rhs, options=options)
-+
-+    def _initialize_stats(self):
-+        stats = super()._initialize_stats()
-+        stats.update({
-+            "solver": "Schrodinger Evolution",
-+        })
-+        return stats
-+
-+    @property
-+    def options(self):
-+        """
-+        Solver's options:
-+
-+        store_final_state: bool, default=False
-+            Whether or not to store the final state of the evolution in the
-+            result class.
-+
-+        store_states: bool, default=None
-+            Whether or not to store the state vectors or density matrices.
-+            On `None` the states will be saved if no expectation operators are
-+            given.
-+
-+        normalize_output: bool, default=True
-+            Normalize output state to hide ODE numerical errors.
-+
-+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
-+            How to present the solver progress.
-+            'tqdm' uses the python module of the same name and raise an error
-+            if not installed. Empty string or False will disable the bar.
-+
-+        progress_kwargs: dict, default={"chunk_size": 10}
-+            Arguments to pass to the progress_bar. Qutip's bars use
-+            ``chunk_size``.
-+
-+        method: str, default="adams"
-+            Which ordinary differential equation integration method to use.
-+        """
-+        return self._options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        Solver.options.fset(self, new_options)
-diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
-index 953bfab4..ae0db232 100644
---- a/qutip/solver/solver_base.py
-+++ b/qutip/solver/solver_base.py
-@@ -1,395 +1,395 @@
--__all__ = ['Solver']
--
--from .. import Qobj, QobjEvo, ket2dm
--from .options import _SolverOptions
--from ..core import stack_columns, unstack_columns
--from .result import Result
--from .integrator import Integrator
--from ..ui.progressbar import progess_bars
--from time import time
--
--
--class Solver:
--    """
--    Runner for an evolution.
--    Can run the evolution at once using :method:`run` or step by step using
--    :method:`start` and :method:`step`.
--
--    Parameters
--    ----------
--    rhs : Qobj, QobjEvo
--        Right hand side of the evolution::
--            d state / dt = rhs @ state
--
--    options : dict
--        Options for the solver
--    """
--    name = ""
--
--    # State, time and Integrator of the stepper functionnality
--    _integrator = None
--    _avail_integrators = {}
--
--    # Class of option used by the solver
--    solver_options = {
--        "progress_bar": "text",
--        "progress_kwargs": {"chunk_size": 10},
--        "store_final_state": False,
--        "store_states": None,
--        "normalize_output": "ket",
--        "method": "adams",
--    }
--    resultclass = Result
--
--    def __init__(self, rhs, *, options=None):
--        if isinstance(rhs, (QobjEvo, Qobj)):
--            self.rhs = QobjEvo(rhs)
--        else:
--            TypeError("The rhs must be a QobjEvo")
--        self.options = options
--        self._integrator = self._get_integrator()
--        self._state_metadata = {}
--        self.stats = self._initialize_stats()
--
--    def _initialize_stats(self):
--        """ Return the initial values for the solver stats.
--        """
--        return {
--            "method": self._integrator.name,
--            "init time": self._init_integrator_time,
--            "preparation time": 0.0,
--            "run time": 0.0,
--        }
--
--    def _prepare_state(self, state):
--        """
--        Extract the data of the Qobj state.
--
--        Is responsible for dims checks, preparing the data (stack columns, ...)
--        determining the dims of the output for :method:`_restore_state`.
--
--        Should return the state's data such that it can be used by Integrators.
--        """
--        if self.rhs.issuper and state.isket:
--            state = ket2dm(state)
--
--        if (
--            self.rhs.dims[1] != state.dims[0]
--            and self.rhs.dims[1] != state.dims
--        ):
--            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
--                            f" and {state.dims}")
--
--        self._state_metadata = {
--            'dims': state.dims,
--            'type': state.type,
--            'isherm': state.isherm and not (self.rhs.dims == state.dims)
--        }
--        if self.rhs.dims[1] == state.dims:
--            return stack_columns(state.data)
--        return state.data
--
--    def _restore_state(self, data, *, copy=True):
--        """
--        Retore the Qobj state from its data.
--        """
--        if self._state_metadata['dims'] == self.rhs.dims[1]:
--            state = Qobj(unstack_columns(data),
--                         **self._state_metadata, copy=False)
--        else:
--            state = Qobj(data, **self._state_metadata, copy=copy)
--
--        if data.shape[1] == 1 and self._options['normalize_output']:
--            state = state * (1 / state.norm())
--
--        return state
--
--    def run(self, state0, tlist, *, args=None, e_ops=None):
--        """
--        Do the evolution of the Quantum system.
--
--        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
--        ``rhs`` and for each time in ``tlist`` store the state and/or
--        expectation values in a :cls:`Result`. The evolution method and stored
--        results are determined by ``options``.
--
--        Parameters
--        ----------
--        state0 : :class:`Qobj`
--            Initial state of the evolution.
--
--        tlist : list of double
--            Time for which to save the results (state and/or expect) of the
--            evolution. The first element of the list is the initial time of the
--            evolution. Each times of the list must be increasing, but does not
--            need to be uniformy distributed.
--
--        args : dict, optional {None}
--            Change the ``args`` of the rhs for the evolution.
--
--        e_ops : list {None}
--            List of Qobj, QobjEvo or callable to compute the expectation
--            values. Function[s] must have the signature
--            f(t : float, state : Qobj) -> expect.
--
--        Return
--        ------
--        results : :class:`qutip.solver.Result`
--            Results of the evolution. States and/or expect will be saved. You
--            can control the saved data in the options.
--        """
--        _time_start = time()
--        _data0 = self._prepare_state(state0)
--        self._integrator.set_state(tlist[0], _data0)
--        self._argument(args)
--        stats = self._initialize_stats()
--        results = self.resultclass(
--            e_ops, self.options,
--            solver=self.name, stats=stats,
--        )
--        results.add(tlist[0], self._restore_state(_data0, copy=False))
--        stats['preparation time'] += time() - _time_start
--
--        progress_bar = progess_bars[self.options['progress_bar']]()
--        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
--        for t, state in self._integrator.run(tlist):
--            progress_bar.update()
--            results.add(t, self._restore_state(state, copy=False))
--        progress_bar.finished()
--
--        stats['run time'] = progress_bar.total_time()
--        # TODO: It would be nice if integrator could give evolution statistics
--        # stats.update(_integrator.stats)
--        return results
--
--    def start(self, state0, t0):
--        """
--        Set the initial state and time for a step evolution.
--        ``options`` for the evolutions are read at this step.
--
--        Parameters
--        ----------
--        state0 : :class:`Qobj`
--            Initial state of the evolution.
--
--        t0 : double
--            Initial time of the evolution.
--        """
--        _time_start = time()
--        self._integrator.set_state(t0, self._prepare_state(state0))
--        self.stats["preparation time"] += time() - _time_start
--
--    def step(self, t, *, args=None, copy=True):
--        """
--        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
--
--        Parameters
--        ----------
--        t : double
--            Time to evolve to, must be higher than the last call.
--
--        args : dict, optional {None}
--            Update the ``args`` of the system.
--            The change is effective from the beginning of the interval.
--            Changing ``args`` can slow the evolution.
--
--        copy : bool, optional {True}
--            Whether to return a copy of the data or the data in the ODE solver.
--
--        .. note::
--            The state must be initialized first by calling ``start`` or
--            ``run``. If ``run`` is called, ``step`` will continue from the last
--            time and state obtained.
--        """
--        if not self._integrator._is_set:
--            raise RuntimeError("The `start` method must called first")
--        _time_start = time()
--        self._argument(args)
--        _, state = self._integrator.integrate(t, copy=False)
--        self.stats["run time"] += time() - _time_start
--        return self._restore_state(state, copy=copy)
--
--    def _get_integrator(self):
--        """ Return the initialted integrator. """
--        _time_start = time()
--        method = self._options["method"]
--        if method in self.avail_integrators():
--            integrator = self.avail_integrators()[method]
--        elif issubclass(method, Integrator):
--            integrator = method
--        else:
--            raise ValueError("Integrator method not supported.")
--        integrator_instance = integrator(self.rhs, self.options)
--        self._init_integrator_time = time() - _time_start
--        return integrator_instance
--
--    @property
--    def sys_dims(self):
--        """
--        Dimensions of the space that the system use:
--
--        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
--        for this solver.
--        """
--        return self.rhs.dims[0]
--
--    @property
--    def options(self):
--        """
--        method: str
--            Which ordinary differential equation integration method to use.
--        """
--        return self._options
--
--    def _parse_options(self, new_options, default, old_options):
--        """
--        Do a first read through of the options:
--        - Split new options' items included in the default from those that are
--          not.
--        - Replace ``None`` with the default value.
--        - Remove items that are unchanged.
--        """
--        included_options = {
--            key: val
--            for key, val in new_options.items()
--            if key in default
--        }
--        extra_options = {
--            key: val
--            for key, val in new_options.items()
--            if key not in default
--        }
--
--        # First pass: Have ``None`` refert to the default.
--        included_options = {
--            key: (val if val is not None else default[key])
--            for key, val in included_options.items()
--        }
--        # Second pass: Remove options that remain unchanged.
--        included_options = {
--            key: val
--            for key, val in included_options.items()
--            if not (key in old_options and val == old_options[key])
--        }
--        return included_options, extra_options
--
--    @options.setter
--    def options(self, new_options):
--        if not hasattr(self, "_options"):
--            self._options = {}
--        if new_options is None:
--            new_options = {}
--        if not isinstance(new_options, dict):
--            raise TypeError("options most to be a dictionary.")
--        new_solver_options, new_ode_options = self._parse_options(
--            new_options, self.solver_options, self.options
--        )
--        method = new_solver_options.get(
--            "method", self.options.get("method", self.solver_options["method"])
--        )
--        integrator = self.avail_integrators()[method]
--
--        if method == self.options.get("method", None):
--            # If method changed, drop old ode options
--            old_ode_options = self.options
--            old_options = self._options
--        else:
--            old_ode_options = {}
--            old_options, _ = self._parse_options(
--                self._options, self.solver_options, {}
--            )
--
--        new_ode_options, extra_options = self._parse_options(
--            new_ode_options, integrator.integrator_options, self.options
--        )
--        if extra_options:
--            raise KeyError(f"Options {extra_options.keys()} are not supported")
--        if self._options and not (new_solver_options or new_ode_options):
--            return  # Nothing to do
--
--        self._options = _SolverOptions(
--            {**self.solver_options, **integrator.integrator_options},
--            self._apply_options,
--            self.name + " with " + integrator.method + " integrator",
--            self.__class__.options.__doc__ + integrator.options.__doc__,
--            **{**old_options, **new_solver_options, **new_ode_options}
--        )
--
--        self._apply_options(set(new_options.keys()))
--
--    def _apply_options(self, keys):
--        """
--        Method called when options are changed, either through
--        ``solver.options[key] = value`` or ``solver.options = options``.
--        Allow to update the solver with the new options
--        """
--        from_setter = isinstance(keys, (set))
--        if not from_setter:
--            keys = set([keys])
--
--        if not from_setter and "method" in keys:
--            # Drop the ode's options.
--            old_solver_options, _ = self._parse_options(
--                self.options, self.solver_options, {}
--            )
--            method = self.options["method"]
--            integrator = self.avail_integrators()[method]
--
--            self._options = _SolverOptions(
--                {**self.solver_options, **integrator.integrator_options},
--                self._apply_options,
--                self.name + " with " + integrator.method + " integrator",
--                self.__class__.options.__doc__ + integrator.options.__doc__,
--                **old_solver_options
--            )
--
--        if self._integrator is None or not keys:
--            pass
--        elif 'method' in keys and self._integrator._is_set:
--            state = self._integrator.get_state()
--            self._integrator = self._get_integrator()
--            self._integrator.set_state(*state)
--        elif "method" in keys:
--            self._integrator = self._get_integrator()
--        elif keys & self._integrator.integrator_options.keys():
--            # Some of the keys are used by the integrator.
--            self._integrator.options = self._options
--            self._integrator.reset(hard=True)
--
--    def _argument(self, args):
--        """Update the args, for the `rhs` and other operators."""
--        if args:
--            self.rhs.arguments(args)
--            self._integrator.arguments(args)
--
--    @classmethod
--    def avail_integrators(cls):
--        if cls is Solver:
--            return cls._avail_integrators.copy()
--        return {
--            **Solver.avail_integrators(),
--            **cls._avail_integrators,
--        }
--
--    @classmethod
--    def integrator(cls, key):
--        return cls.avail_integrators()[key]
--
--    @classmethod
--    def add_integrator(cls, integrator, key):
--        """
--        Register an integrator.
--
--        Parameters
--        ----------
--        integrator : Integrator
--            The ODE solver to register.
--
--        keys : list of str
--            Values of the method options that refer to this integrator.
--        """
--        if not issubclass(integrator, Integrator):
--            raise TypeError(f"The integrator {integrator} must be a subclass"
--                            " of `qutip.solver.Integrator`")
--
--        cls._avail_integrators[key] = integrator
-+__all__ = ['Solver']
-+
-+from .. import Qobj, QobjEvo, ket2dm
-+from .options import _SolverOptions
-+from ..core import stack_columns, unstack_columns
-+from .result import Result
-+from .integrator import Integrator
-+from ..ui.progressbar import progess_bars
-+from time import time
-+
-+
-+class Solver:
-+    """
-+    Runner for an evolution.
-+    Can run the evolution at once using :method:`run` or step by step using
-+    :method:`start` and :method:`step`.
-+
-+    Parameters
-+    ----------
-+    rhs : Qobj, QobjEvo
-+        Right hand side of the evolution::
-+            d state / dt = rhs @ state
-+
-+    options : dict
-+        Options for the solver
-+    """
-+    name = ""
-+
-+    # State, time and Integrator of the stepper functionnality
-+    _integrator = None
-+    _avail_integrators = {}
-+
-+    # Class of option used by the solver
-+    solver_options = {
-+        "progress_bar": "text",
-+        "progress_kwargs": {"chunk_size": 10},
-+        "store_final_state": False,
-+        "store_states": None,
-+        "normalize_output": "ket",
-+        "method": "adams",
-+    }
-+    resultclass = Result
-+
-+    def __init__(self, rhs, *, options=None):
-+        if isinstance(rhs, (QobjEvo, Qobj)):
-+            self.rhs = QobjEvo(rhs)
-+        else:
-+            TypeError("The rhs must be a QobjEvo")
-+        self.options = options
-+        self._integrator = self._get_integrator()
-+        self._state_metadata = {}
-+        self.stats = self._initialize_stats()
-+
-+    def _initialize_stats(self):
-+        """ Return the initial values for the solver stats.
-+        """
-+        return {
-+            "method": self._integrator.name,
-+            "init time": self._init_integrator_time,
-+            "preparation time": 0.0,
-+            "run time": 0.0,
-+        }
-+
-+    def _prepare_state(self, state):
-+        """
-+        Extract the data of the Qobj state.
-+
-+        Is responsible for dims checks, preparing the data (stack columns, ...)
-+        determining the dims of the output for :method:`_restore_state`.
-+
-+        Should return the state's data such that it can be used by Integrators.
-+        """
-+        if self.rhs.issuper and state.isket:
-+            state = ket2dm(state)
-+
-+        if (
-+            self.rhs.dims[1] != state.dims[0]
-+            and self.rhs.dims[1] != state.dims
-+        ):
-+            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
-+                            f" and {state.dims}")
-+
-+        self._state_metadata = {
-+            'dims': state.dims,
-+            'type': state.type,
-+            'isherm': state.isherm and not (self.rhs.dims == state.dims)
-+        }
-+        if self.rhs.dims[1] == state.dims:
-+            return stack_columns(state.data)
-+        return state.data
-+
-+    def _restore_state(self, data, *, copy=True):
-+        """
-+        Retore the Qobj state from its data.
-+        """
-+        if self._state_metadata['dims'] == self.rhs.dims[1]:
-+            state = Qobj(unstack_columns(data),
-+                         **self._state_metadata, copy=False)
-+        else:
-+            state = Qobj(data, **self._state_metadata, copy=copy)
-+
-+        if data.shape[1] == 1 and self._options['normalize_output']:
-+            state = state * (1 / state.norm())
-+
-+        return state
-+
-+    def run(self, state0, tlist, *, args=None, e_ops=None):
-+        """
-+        Do the evolution of the Quantum system.
-+
-+        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
-+        ``rhs`` and for each time in ``tlist`` store the state and/or
-+        expectation values in a :cls:`Result`. The evolution method and stored
-+        results are determined by ``options``.
-+
-+        Parameters
-+        ----------
-+        state0 : :class:`Qobj`
-+            Initial state of the evolution.
-+
-+        tlist : list of double
-+            Time for which to save the results (state and/or expect) of the
-+            evolution. The first element of the list is the initial time of the
-+            evolution. Each times of the list must be increasing, but does not
-+            need to be uniformy distributed.
-+
-+        args : dict, optional {None}
-+            Change the ``args`` of the rhs for the evolution.
-+
-+        e_ops : list {None}
-+            List of Qobj, QobjEvo or callable to compute the expectation
-+            values. Function[s] must have the signature
-+            f(t : float, state : Qobj) -> expect.
-+
-+        Return
-+        ------
-+        results : :class:`qutip.solver.Result`
-+            Results of the evolution. States and/or expect will be saved. You
-+            can control the saved data in the options.
-+        """
-+        _time_start = time()
-+        _data0 = self._prepare_state(state0)
-+        self._integrator.set_state(tlist[0], _data0)
-+        self._argument(args)
-+        stats = self._initialize_stats()
-+        results = self.resultclass(
-+            e_ops, self.options,
-+            solver=self.name, stats=stats,
-+        )
-+        results.add(tlist[0], self._restore_state(_data0, copy=False))
-+        stats['preparation time'] += time() - _time_start
-+
-+        progress_bar = progess_bars[self.options['progress_bar']]()
-+        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
-+        for t, state in self._integrator.run(tlist):
-+            progress_bar.update()
-+            results.add(t, self._restore_state(state, copy=False))
-+        progress_bar.finished()
-+
-+        stats['run time'] = progress_bar.total_time()
-+        # TODO: It would be nice if integrator could give evolution statistics
-+        # stats.update(_integrator.stats)
-+        return results
-+
-+    def start(self, state0, t0):
-+        """
-+        Set the initial state and time for a step evolution.
-+        ``options`` for the evolutions are read at this step.
-+
-+        Parameters
-+        ----------
-+        state0 : :class:`Qobj`
-+            Initial state of the evolution.
-+
-+        t0 : double
-+            Initial time of the evolution.
-+        """
-+        _time_start = time()
-+        self._integrator.set_state(t0, self._prepare_state(state0))
-+        self.stats["preparation time"] += time() - _time_start
-+
-+    def step(self, t, *, args=None, copy=True):
-+        """
-+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-+
-+        Parameters
-+        ----------
-+        t : double
-+            Time to evolve to, must be higher than the last call.
-+
-+        args : dict, optional {None}
-+            Update the ``args`` of the system.
-+            The change is effective from the beginning of the interval.
-+            Changing ``args`` can slow the evolution.
-+
-+        copy : bool, optional {True}
-+            Whether to return a copy of the data or the data in the ODE solver.
-+
-+        .. note::
-+            The state must be initialized first by calling ``start`` or
-+            ``run``. If ``run`` is called, ``step`` will continue from the last
-+            time and state obtained.
-+        """
-+        if not self._integrator._is_set:
-+            raise RuntimeError("The `start` method must called first")
-+        _time_start = time()
-+        self._argument(args)
-+        _, state = self._integrator.integrate(t, copy=False)
-+        self.stats["run time"] += time() - _time_start
-+        return self._restore_state(state, copy=copy)
-+
-+    def _get_integrator(self):
-+        """ Return the initialted integrator. """
-+        _time_start = time()
-+        method = self._options["method"]
-+        if method in self.avail_integrators():
-+            integrator = self.avail_integrators()[method]
-+        elif issubclass(method, Integrator):
-+            integrator = method
-+        else:
-+            raise ValueError("Integrator method not supported.")
-+        integrator_instance = integrator(self.rhs, self.options)
-+        self._init_integrator_time = time() - _time_start
-+        return integrator_instance
-+
-+    @property
-+    def sys_dims(self):
-+        """
-+        Dimensions of the space that the system use:
-+
-+        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
-+        for this solver.
-+        """
-+        return self.rhs.dims[0]
-+
-+    @property
-+    def options(self):
-+        """
-+        method: str
-+            Which ordinary differential equation integration method to use.
-+        """
-+        return self._options
-+
-+    def _parse_options(self, new_options, default, old_options):
-+        """
-+        Do a first read through of the options:
-+        - Split new options' items included in the default from those that are
-+          not.
-+        - Replace ``None`` with the default value.
-+        - Remove items that are unchanged.
-+        """
-+        included_options = {
-+            key: val
-+            for key, val in new_options.items()
-+            if key in default
-+        }
-+        extra_options = {
-+            key: val
-+            for key, val in new_options.items()
-+            if key not in default
-+        }
-+
-+        # First pass: Have ``None`` refert to the default.
-+        included_options = {
-+            key: (val if val is not None else default[key])
-+            for key, val in included_options.items()
-+        }
-+        # Second pass: Remove options that remain unchanged.
-+        included_options = {
-+            key: val
-+            for key, val in included_options.items()
-+            if not (key in old_options and val == old_options[key])
-+        }
-+        return included_options, extra_options
-+
-+    @options.setter
-+    def options(self, new_options):
-+        if not hasattr(self, "_options"):
-+            self._options = {}
-+        if new_options is None:
-+            new_options = {}
-+        if not isinstance(new_options, dict):
-+            raise TypeError("options most to be a dictionary.")
-+        new_solver_options, new_ode_options = self._parse_options(
-+            new_options, self.solver_options, self.options
-+        )
-+        method = new_solver_options.get(
-+            "method", self.options.get("method", self.solver_options["method"])
-+        )
-+        integrator = self.avail_integrators()[method]
-+
-+        if method == self.options.get("method", None):
-+            # If method changed, drop old ode options
-+            old_ode_options = self.options
-+            old_options = self._options
-+        else:
-+            old_ode_options = {}
-+            old_options, _ = self._parse_options(
-+                self._options, self.solver_options, {}
-+            )
-+
-+        new_ode_options, extra_options = self._parse_options(
-+            new_ode_options, integrator.integrator_options, self.options
-+        )
-+        if extra_options:
-+            raise KeyError(f"Options {extra_options.keys()} are not supported")
-+        if self._options and not (new_solver_options or new_ode_options):
-+            return  # Nothing to do
-+
-+        self._options = _SolverOptions(
-+            {**self.solver_options, **integrator.integrator_options},
-+            self._apply_options,
-+            self.name + " with " + integrator.method + " integrator",
-+            self.__class__.options.__doc__ + integrator.options.__doc__,
-+            **{**old_options, **new_solver_options, **new_ode_options}
-+        )
-+
-+        self._apply_options(set(new_options.keys()))
-+
-+    def _apply_options(self, keys):
-+        """
-+        Method called when options are changed, either through
-+        ``solver.options[key] = value`` or ``solver.options = options``.
-+        Allow to update the solver with the new options
-+        """
-+        from_setter = isinstance(keys, (set))
-+        if not from_setter:
-+            keys = set([keys])
-+
-+        if not from_setter and "method" in keys:
-+            # Drop the ode's options.
-+            old_solver_options, _ = self._parse_options(
-+                self.options, self.solver_options, {}
-+            )
-+            method = self.options["method"]
-+            integrator = self.avail_integrators()[method]
-+
-+            self._options = _SolverOptions(
-+                {**self.solver_options, **integrator.integrator_options},
-+                self._apply_options,
-+                self.name + " with " + integrator.method + " integrator",
-+                self.__class__.options.__doc__ + integrator.options.__doc__,
-+                **old_solver_options
-+            )
-+
-+        if self._integrator is None or not keys:
-+            pass
-+        elif 'method' in keys and self._integrator._is_set:
-+            state = self._integrator.get_state()
-+            self._integrator = self._get_integrator()
-+            self._integrator.set_state(*state)
-+        elif "method" in keys:
-+            self._integrator = self._get_integrator()
-+        elif keys & self._integrator.integrator_options.keys():
-+            # Some of the keys are used by the integrator.
-+            self._integrator.options = self._options
-+            self._integrator.reset(hard=True)
-+
-+    def _argument(self, args):
-+        """Update the args, for the `rhs` and other operators."""
-+        if args:
-+            self.rhs.arguments(args)
-+            self._integrator.arguments(args)
-+
-+    @classmethod
-+    def avail_integrators(cls):
-+        if cls is Solver:
-+            return cls._avail_integrators.copy()
-+        return {
-+            **Solver.avail_integrators(),
-+            **cls._avail_integrators,
-+        }
-+
-+    @classmethod
-+    def integrator(cls, key):
-+        return cls.avail_integrators()[key]
-+
-+    @classmethod
-+    def add_integrator(cls, integrator, key):
-+        """
-+        Register an integrator.
-+
-+        Parameters
-+        ----------
-+        integrator : Integrator
-+            The ODE solver to register.
-+
-+        keys : list of str
-+            Values of the method options that refer to this integrator.
-+        """
-+        if not issubclass(integrator, Integrator):
-+            raise TypeError(f"The integrator {integrator} must be a subclass"
-+                            " of `qutip.solver.Integrator`")
-+
-+        cls._avail_integrators[key] = integrator
-diff --git a/qutip/solver/spectrum.py b/qutip/solver/spectrum.py
-index cb92e1f0..a267ee64 100644
---- a/qutip/solver/spectrum.py
-+++ b/qutip/solver/spectrum.py
-@@ -1,188 +1,188 @@
--__all__ = ['spectrum', 'spectrum_correlation_fft']
--
--import numpy as np
--import scipy.fftpack
--
--from .steadystate import steadystate
--from ..core import liouvillian, spre, expect
--from ..core import data as _data
--from qutip.settings import settings
--
--def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
--    r"""
--    Calculate the spectrum of the correlation function
--    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
--    i.e., the Fourier transform of the correlation function:
--
--    .. math::
--
--        S(\omega) = \int_{-\infty}^{\infty}
--        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
--        e^{-i\omega\tau} d\tau.
--
--    using the solver indicated by the `solver` parameter. Note: this spectrum
--    is only defined for stationary statistics (uses steady state rho0)
--
--    Parameters
--    ----------
--    H : :class:`qutip.qobj`
--        system Hamiltonian.
--    wlist : array_like
--        List of frequencies for :math:`\omega`.
--    c_ops : list
--        List of collapse operators.
--    a_op : Qobj
--        Operator A.
--    b_op : Qobj
--        Operator B.
--    solver : str
--        Choice of solver (`es` for exponential series and
--        `pi` for psuedo-inverse, `solve` for generic solver).
--
--    Returns
--    -------
--    spectrum : array
--        An array with spectrum :math:`S(\omega)` for the frequencies
--        specified in `wlist`.
--
--    """
--    if not H.issuper:
--        L = liouvillian(H, c_ops)
--    else:
--        L = H + sum([lindblad_dissipator(c) for c in c_ops])
--    if solver == "es":
--        return _spectrum_es(L, wlist, a_op, b_op)
--    elif solver in ["pi", "solve"]:
--        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
--    raise ValueError(
--        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
--    )
--
--
--def spectrum_correlation_fft(tlist, y, inverse=False):
--    """
--    Calculate the power spectrum corresponding to a two-time correlation
--    function using FFT.
--
--    Parameters
--    ----------
--    tlist : array_like
--        list/array of times :math:`t` which the correlation function is given.
--    y : array_like
--        list/array of correlations corresponding to time delays :math:`t`.
--    inverse: boolean
--        boolean parameter for using a positive exponent in the Fourier
--        Transform instead. Default is False.
--
--    Returns
--    -------
--    w, S : tuple
--        Returns an array of angular frequencies 'w' and the corresponding
--        two-sided power spectrum 'S(w)'.
--
--    """
--    tlist = np.asarray(tlist)
--    N = tlist.shape[0]
--    dt = tlist[1] - tlist[0]
--    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
--        raise ValueError('tlist must be equally spaced for FFT.')
--    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
--    # calculate the frequencies for the components in F
--    f = scipy.fftpack.fftfreq(N, dt)
--    # re-order frequencies from most negative to most positive (centre on 0)
--    idx = np.array([], dtype='int')
--    idx = np.append(idx, np.where(f < 0.0))
--    idx = np.append(idx, np.where(f >= 0.0))
--    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
--
--
--def _spectrum_es(L, wlist, a_op, b_op):
--    r"""
--    Internal function for calculating the spectrum of the correlation function
--    :math:`\left<A(\tau)B(0)\right>`.
--    """
--    # find the steady state density matrix and a_op and b_op expecation values
--    rho0 = steadystate(L)
--    a_op_ss = expect(a_op, rho0)
--    b_op_ss = expect(b_op, rho0)
--    # eseries solution for (b * rho0)(t)
--    states, rates = _diagonal_evolution(L, b_op * rho0)
--    # correlation
--    ampls = [_data.expect(a_op.data, state) for state in states]
--    # make covariance
--    ampls += [-a_op_ss * b_op_ss]
--    rates += [0]
--    # Tidy up similar rates.
--    order = np.argsort(rates)
--    clean_rates = []
--    clean_ampls = []
--    prev_rate = np.nan
--    for idx in order:
--        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
--            clean_ampls[-1] += ampls[idx]
--        else:
--            clean_rates.append(rates[idx])
--            clean_ampls.append(ampls[idx])
--            prev_rate = rates[idx]
--    # Remove 0 amplitude
--    rates, ampls = zip(*[
--        (rate, ampl)
--        for rate, ampl in zip(clean_rates, clean_ampls)
--        if np.abs(ampl) > settings.core["atol"]
--    ])
--    ampls, rates = np.array(ampls), np.array(rates)
--    LW = np.subtract.outer(1j * np.array(wlist), rates).T
--    return (ampls @ (2 / LW)).real
--
--
--#
--# pseudo-inverse solvers
--def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
--    r"""
--    Internal function for calculating the spectrum of the correlation function
--    :math:`\left<A(\tau)B(0)\right>`.
--    """
--    dtype = type(L.data)
--    rho_ss = steadystate(L)
--    tr_mat = _data.identity[dtype](rho_ss.shape[0])
--    tr_vec = _data.column_stack(tr_mat).transpose()
--    rho = _data.column_stack(rho_ss.data)
--
--    A = L.data
--    ket = spre(b_op).data @ rho
--    bra = tr_vec @ spre(a_op).data
--
--    I = _data.identity[dtype](L.shape[0])
--    P = _data.kron(rho, tr_vec)
--    Q = I - P
--
--    spectrum = np.zeros(len(wlist))
--    for idx, w in enumerate(wlist):
--        if use_pinv and np.abs(w) > settings.core["atol"]:
--            # At w == 0., "L - iw" is singular
--            MMR = _data.inv(-1.0j * w * I + A)
--        else:
--            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
--
--        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
--    return spectrum
--
--
--def _diagonal_evolution(L, rho0, sparse=False):
--    if rho0.norm() < settings.core["atol"]:
--        return [_data.zeros["CSR"](*rho0.shape)], [0]
--    if isinstance(L.data, _data.CSR) and not sparse:
--        L = L.to(_data.Dense)
--    evals, evecs = _data.eigs(L.data)
--    size = rho0.shape[0] * rho0.shape[1]
--    r0 = _data.column_stack(rho0.data)
--    v0 = _data.solve(evecs, r0)
--    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
--    states = []
--    rates = []
--    for ket, rate in zip(_data.split_columns(vv), evals):
--        if _data.norm.l2(ket) < settings.core["atol"]:
--            continue
--        states.append(_data.column_unstack(ket, rho0.shape[0]))
--        rates.append(rate)
--    return states, rates
-+__all__ = ['spectrum', 'spectrum_correlation_fft']
-+
-+import numpy as np
-+import scipy.fftpack
-+
-+from .steadystate import steadystate
-+from ..core import liouvillian, spre, expect
-+from ..core import data as _data
-+from qutip.settings import settings
-+
-+def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
-+    r"""
-+    Calculate the spectrum of the correlation function
-+    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
-+    i.e., the Fourier transform of the correlation function:
-+
-+    .. math::
-+
-+        S(\omega) = \int_{-\infty}^{\infty}
-+        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
-+        e^{-i\omega\tau} d\tau.
-+
-+    using the solver indicated by the `solver` parameter. Note: this spectrum
-+    is only defined for stationary statistics (uses steady state rho0)
-+
-+    Parameters
-+    ----------
-+    H : :class:`qutip.qobj`
-+        system Hamiltonian.
-+    wlist : array_like
-+        List of frequencies for :math:`\omega`.
-+    c_ops : list
-+        List of collapse operators.
-+    a_op : Qobj
-+        Operator A.
-+    b_op : Qobj
-+        Operator B.
-+    solver : str
-+        Choice of solver (`es` for exponential series and
-+        `pi` for psuedo-inverse, `solve` for generic solver).
-+
-+    Returns
-+    -------
-+    spectrum : array
-+        An array with spectrum :math:`S(\omega)` for the frequencies
-+        specified in `wlist`.
-+
-+    """
-+    if not H.issuper:
-+        L = liouvillian(H, c_ops)
-+    else:
-+        L = H + sum([lindblad_dissipator(c) for c in c_ops])
-+    if solver == "es":
-+        return _spectrum_es(L, wlist, a_op, b_op)
-+    elif solver in ["pi", "solve"]:
-+        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
-+    raise ValueError(
-+        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
-+    )
-+
-+
-+def spectrum_correlation_fft(tlist, y, inverse=False):
-+    """
-+    Calculate the power spectrum corresponding to a two-time correlation
-+    function using FFT.
-+
-+    Parameters
-+    ----------
-+    tlist : array_like
-+        list/array of times :math:`t` which the correlation function is given.
-+    y : array_like
-+        list/array of correlations corresponding to time delays :math:`t`.
-+    inverse: boolean
-+        boolean parameter for using a positive exponent in the Fourier
-+        Transform instead. Default is False.
-+
-+    Returns
-+    -------
-+    w, S : tuple
-+        Returns an array of angular frequencies 'w' and the corresponding
-+        two-sided power spectrum 'S(w)'.
-+
-+    """
-+    tlist = np.asarray(tlist)
-+    N = tlist.shape[0]
-+    dt = tlist[1] - tlist[0]
-+    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
-+        raise ValueError('tlist must be equally spaced for FFT.')
-+    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
-+    # calculate the frequencies for the components in F
-+    f = scipy.fftpack.fftfreq(N, dt)
-+    # re-order frequencies from most negative to most positive (centre on 0)
-+    idx = np.array([], dtype='int')
-+    idx = np.append(idx, np.where(f < 0.0))
-+    idx = np.append(idx, np.where(f >= 0.0))
-+    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
-+
-+
-+def _spectrum_es(L, wlist, a_op, b_op):
-+    r"""
-+    Internal function for calculating the spectrum of the correlation function
-+    :math:`\left<A(\tau)B(0)\right>`.
-+    """
-+    # find the steady state density matrix and a_op and b_op expecation values
-+    rho0 = steadystate(L)
-+    a_op_ss = expect(a_op, rho0)
-+    b_op_ss = expect(b_op, rho0)
-+    # eseries solution for (b * rho0)(t)
-+    states, rates = _diagonal_evolution(L, b_op * rho0)
-+    # correlation
-+    ampls = [_data.expect(a_op.data, state) for state in states]
-+    # make covariance
-+    ampls += [-a_op_ss * b_op_ss]
-+    rates += [0]
-+    # Tidy up similar rates.
-+    order = np.argsort(rates)
-+    clean_rates = []
-+    clean_ampls = []
-+    prev_rate = np.nan
-+    for idx in order:
-+        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
-+            clean_ampls[-1] += ampls[idx]
-+        else:
-+            clean_rates.append(rates[idx])
-+            clean_ampls.append(ampls[idx])
-+            prev_rate = rates[idx]
-+    # Remove 0 amplitude
-+    rates, ampls = zip(*[
-+        (rate, ampl)
-+        for rate, ampl in zip(clean_rates, clean_ampls)
-+        if np.abs(ampl) > settings.core["atol"]
-+    ])
-+    ampls, rates = np.array(ampls), np.array(rates)
-+    LW = np.subtract.outer(1j * np.array(wlist), rates).T
-+    return (ampls @ (2 / LW)).real
-+
-+
-+#
-+# pseudo-inverse solvers
-+def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
-+    r"""
-+    Internal function for calculating the spectrum of the correlation function
-+    :math:`\left<A(\tau)B(0)\right>`.
-+    """
-+    dtype = type(L.data)
-+    rho_ss = steadystate(L)
-+    tr_mat = _data.identity[dtype](rho_ss.shape[0])
-+    tr_vec = _data.column_stack(tr_mat).transpose()
-+    rho = _data.column_stack(rho_ss.data)
-+
-+    A = L.data
-+    ket = spre(b_op).data @ rho
-+    bra = tr_vec @ spre(a_op).data
-+
-+    I = _data.identity[dtype](L.shape[0])
-+    P = _data.kron(rho, tr_vec)
-+    Q = I - P
-+
-+    spectrum = np.zeros(len(wlist))
-+    for idx, w in enumerate(wlist):
-+        if use_pinv and np.abs(w) > settings.core["atol"]:
-+            # At w == 0., "L - iw" is singular
-+            MMR = _data.inv(-1.0j * w * I + A)
-+        else:
-+            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
-+
-+        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
-+    return spectrum
-+
-+
-+def _diagonal_evolution(L, rho0, sparse=False):
-+    if rho0.norm() < settings.core["atol"]:
-+        return [_data.zeros["CSR"](*rho0.shape)], [0]
-+    if isinstance(L.data, _data.CSR) and not sparse:
-+        L = L.to(_data.Dense)
-+    evals, evecs = _data.eigs(L.data)
-+    size = rho0.shape[0] * rho0.shape[1]
-+    r0 = _data.column_stack(rho0.data)
-+    v0 = _data.solve(evecs, r0)
-+    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
-+    states = []
-+    rates = []
-+    for ket, rate in zip(_data.split_columns(vv), evals):
-+        if _data.norm.l2(ket) < settings.core["atol"]:
-+            continue
-+        states.append(_data.column_unstack(ket, rho0.shape[0]))
-+        rates.append(rate)
-+    return states, rates
-diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
-index f576c9f2..71efa268 100644
---- a/qutip/solver/steadystate.py
-+++ b/qutip/solver/steadystate.py
-@@ -1,537 +1,537 @@
--from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
--from qutip import vector_to_operator, operator_to_vector
--from qutip import settings
--import qutip.core.data as _data
--import numpy as np
--import scipy.sparse.csgraph
--import scipy.sparse.linalg
--from warnings import warn
--
--
--__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
--
--
--def _permute_wbm(L, b):
--    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
--    L = _data.permute.indices(L, perm, None)
--    b = _data.permute.indices(b, perm, None)
--    return L, b
--
--
--def _permute_rcm(L, b):
--    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
--    L = _data.permute.indices(L, perm, perm)
--    b = _data.permute.indices(b, perm, None)
--    return L, b, perm
--
--
--def _reverse_rcm(rho, perm):
--    rev_perm = np.argsort(perm)
--    rho = _data.permute.indices(rho, rev_perm, None)
--    return rho
--
--
--def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
--    """
--    Calculates the steady state for quantum evolution subject to the supplied
--    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
--    collapse operators.
--
--    If the user passes a Hamiltonian then it, along with the list of collapse
--    operators, will be converted into a Liouvillian operator in Lindblad form.
--
--    Parameters
--    ----------
--    A : :obj:`~Qobj`
--        A Hamiltonian or Liouvillian operator.
--
--    c_op_list : list
--        A list of collapse operators.
--
--    method : str, default='direct'
--        The allowed methods are composed of 2 parts, the steadystate method:
--        - "direct": Solving ``L(rho_ss) = 0``
--        - "eigen" : Eigenvalue problem
--        - "svd" : Singular value decomposition
--        - "power" : Inverse-power method
--
--    solver : str, default=None
--        'direct' and 'power' methods only.
--        Solver to use when solving the ``L(rho_ss) = 0`` equation.
--        Default supported solver are:
--
--        - "solve", "lstsq"
--          dense solver from numpy.linalg
--        - "spsolve", "gmres", "lgmres", "bicgstab"
--          sparse solver from scipy.sparse.linalg
--        - "mkl_spsolve"
--          sparse solver by mkl.
--
--        Extension to qutip, such as qutip-tensorflow, can use come with their
--        own solver. When ``A`` and ``c_ops`` use these data backends, see the
--        corresponding libraries ``linalg`` for available solver.
--
--        Extra options for these solver can be passed in ``**kw``.
--
--    use_rcm : bool, default False
--        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
--        factorization of the Liouvillian.
--        Used with 'direct' or 'power' method.
--
--    use_wbm : bool, default False
--        Use Weighted Bipartite Matching reordering to make the Liouvillian
--        diagonally dominant.  This is useful for iterative preconditioners
--        only. Used with 'direct' or 'power' method.
--
--    weight : float, optional
--        Sets the size of the elements used for adding the unity trace condition
--        to the linear solvers.  This is set to the average abs value of the
--        Liouvillian elements if not specified by the user.
--        Used with 'direct' method.
--
--    power_tol : float, default 1e-12
--        Tolerance for the solution when using the 'power' method.
--
--    power_maxiter : int, default 10
--        Maximum number of iteration to use when looking for a solution when
--        using the 'power' method.
--
--    power_eps: double, default 1e-15
--        Small weight used in the "power" method.
--
--    sparse: bool
--        Whether to use the sparse eigen solver with the "eigen" method
--        (default sparse).  With "direct" and "power" method, when the solver is
--        not specified, it is used to set whether "solve" or "spsolve" is
--        used as default solver.
--
--    **kwargs :
--        Extra options to pass to the linear system solver. See the
--        documentation of the used solver in ``numpy.linalg`` or
--        ``scipy.sparse.linalg`` to see what extra arguments are supported.
--
--    Returns
--    -------
--    dm : qobj
--        Steady state density matrix.
--    info : dict, optional
--        Dictionary containing solver-specific information about the solution.
--
--    .. note::
--
--        The SVD method works only for dense operators (i.e. small systems).
--
--    """
--    if not A.issuper and not c_ops:
--        raise TypeError('Cannot calculate the steady state for a ' +
--                        'non-dissipative system.')
--    if not A.issuper:
--        A = liouvillian(A)
--    for op in c_ops:
--        A += lindblad_dissipator(op)
--
--    if "-" in method:
--        # to support v4's "power-gmres" method
--        method, solver = method.split("-")
--
--    if solver == "mkl":
--        solver = "mkl_spsolve"
--
--    # Keys supported in v4, but removed in v5
--    if kwargs.pop("return_info", False):
--        warn("Steadystate no longer supports return_info", DeprecationWarning)
--    if "mtol" in kwargs and "power_tol" not in kwargs:
--        kwargs["power_tol"] = kwargs["mtol"]
--    kwargs.pop("mtol", None)
--
--    if method == "eigen":
--        return _steadystate_eigen(A, **kwargs)
--    if method == "svd":
--        return _steadystate_svd(A, **kwargs)
--
--    # We want to be able to use this without having to know what data type the
--    # liouvillian uses. For extra data types (tensorflow) we can expect
--    # the users to know they are using them and choose an appropriate solver
--    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
--    if not isinstance(A.data, (_data.CSR, _data.Dense)):
--        # Tensorflow, jax, etc. data type
--        pass
--    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
--        A = A.to("dense")
--    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
--        A = A.to("csr")
--    elif solver is None and kwargs.get("sparse", False):
--        A = A.to("csr")
--        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
--    elif solver is None and (kwargs.get("sparse", None) is False):
--        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
--        A = A.to("dense")
--        solver = "solve"
--
--    if method in ["direct", "iterative"]:
--        # Remove unused kwargs, so only used and pass-through ones are included
--        kwargs.pop("power_tol", 0)
--        kwargs.pop("power_maxiter", 0)
--        kwargs.pop("power_eps", 0)
--        kwargs.pop("sparse", 0)
--        return _steadystate_direct(A, kwargs.pop("weight", 0),
--                                   method=solver, **kwargs)
--
--    elif method == "power":
--        # Remove unused kwargs, so only used and pass-through ones are included
--        kwargs.pop("weight", 0)
--        kwargs.pop("sparse", 0)
--        return _steadystate_power(A, method=solver, **kwargs)
--    else:
--        raise ValueError(f"method {method} not supported.")
--
--
--def _steadystate_direct(A, weight, **kw):
--    # Find the weight, no good dispatched function available...
--    if weight:
--        pass
--    elif isinstance(A.data, _data.CSR):
--        weight = np.mean(np.abs(A.data.as_scipy().data))
--    else:
--        A_np = np.abs(A.full())
--        weight = np.mean(A_np[A_np > 0])
--
--    # Add weight to the Liouvillian
--    # A[:, 0] = vectorized(eye * weight)
--    # We don't have a function to overwrite part of an array, so
--    N = A.shape[0]
--    n = int(N**0.5)
--    dtype = type(A.data)
--    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
--    weight_mat = _data.kron(
--        weight_vec.transpose(),
--        _data.one_element[dtype]((N, 1), (0, 0), 1)
--    )
--    L = _data.add(weight_mat, A.data)
--    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
--
--    # Permutation are part of scipy.sparse, thus only supported for CSR.
--    if kw.pop("use_wbm", False):
--        if isinstance(L, _data.CSR):
--            L, b = _permute_wbm(L, b)
--        else:
--            warn("Only sparse matrice can be permuted.", RuntimeWarning)
--    use_rcm = False
--    if kw.pop("use_rcm", False):
--        if isinstance(L, _data.CSR):
--            L, b, perm = _permute_rcm(L, b)
--            use_rcm = True
--        else:
--            warn("Only sparse matrice can be permuted.", RuntimeWarning)
--    if kw.pop("use_precond", False):
--        if isinstance(L, _data.CSR):
--            kw["M"] = _compute_precond(L, kw)
--        else:
--            warn("Only sparse solver use preconditioners.", RuntimeWarning)
--
--
--    method = kw.pop("method", None)
--    steadystate = _data.solve(L, b, method, options=kw)
--
--    if use_rcm:
--        steadystate = _reverse_rcm(steadystate, perm)
--
--    rho_ss = _data.column_unstack(steadystate, n)
--    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
--
--    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
--
--
--def _steadystate_eigen(L, **kw):
--    val, vec = (L.dag() @ L).eigenstates(
--        eigvals=1,
--        sort="low",
--        # v4's implementation only uses sparse eigen solver
--        sparse=kw.pop("sparse", True)
--    )
--    rho = vector_to_operator(vec[0])
--    return rho / rho.tr()
--
--
--def _steadystate_svd(L, **kw):
--    u, s, vh = _data.svd(L.data, True)
--    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
--    rho = vector_to_operator(vec)
--    return rho / rho.tr()
--
--
--def _steadystate_power(A, **kw):
--    A += kw.pop("power_eps", 1e-15)
--    L = A.data
--    N = L.shape[1]
--    y = _data.Dense([1]*N)
--
--    # Permutation are part of scipy.sparse, thus only supported for CSR.
--    if kw.pop("use_wbm", False):
--        if isinstance(L, _data.CSR):
--            L, y = _permute_wbm(L, y)
--        else:
--            warn("Only sparse matrice can be permuted.", RuntimeWarning)
--    use_rcm = False
--    if kw.pop("use_rcm", False):
--        if isinstance(L, _data.CSR):
--            L, y, perm = _permute_rcm(L, y)
--            use_rcm = True
--        else:
--            warn("Only sparse matrice can be permuted.", RuntimeWarning)
--    if kw.pop("use_precond", False):
--        if isinstance(L, _data.CSR):
--            kw["M"] = _compute_precond(L, kw)
--        else:
--            warn("Only sparse solver use preconditioners.", RuntimeWarning)
--
--    it = 0
--    maxiter = kw.pop("power_maxiter", 10)
--    tol = kw.pop("power_tol", 1e-12)
--    method = kw.pop("method", None)
--    while it < maxiter and _data.norm.max(L @ y) > tol:
--        y = _data.solve(L, y, method, options=kw)
--        y = y / _data.norm.max(y)
--        it += 1
--
--    if it >= maxiter:
--        raise Exception('Failed to find steady state after ' +
--                        str(maxiter) + ' iterations')
--
--    if use_rcm:
--        y = _reverse_rcm(y, perm)
--
--    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
--    rho_ss = rho_ss + rho_ss.dag()
--    rho_ss = rho_ss / rho_ss.tr()
--    rho_ss.isherm = True
--    return rho_ss
--
--
--def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
--                        solver=None, **kwargs):
--    """
--    Calculates the effective steady state for a driven
--     system with a time-dependent cosinusoidal term:
--
--    .. math::
--
--        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
--         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
--
--    Parameters
--    ----------
--    H_0 : :obj:`~Qobj`
--        A Hamiltonian or Liouvillian operator.
--
--    c_ops : list
--        A list of collapse operators.
--
--    Op_t : :obj:`~Qobj`
--        The the interaction operator which is multiplied by the cosine
--
--    w_d : float, default 1.0
--        The frequency of the drive
--
--    n_it : int, default 3
--        The number of iterations for the solver
--
--    sparse : bool, default False
--        Solve for the steady state using sparse algorithms.
--
--    solver : str, default=None
--        Solver to use when solving the linear system.
--        Default supported solver are:
--
--        - "solve", "lstsq"
--          dense solver from numpy.linalg
--        - "spsolve", "gmres", "lgmres", "bicgstab"
--          sparse solver from scipy.sparse.linalg
--        - "mkl_spsolve"
--          sparse solver by mkl.
--
--        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
--        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
--        for the names and details of additional solvers they may provide.
--
--    **kwargs:
--        Extra options to pass to the linear system solver. See the
--        documentation of the used solver in ``numpy.linalg`` or
--        ``scipy.sparse.linalg`` to see what extra arguments are supported.
--
--    Returns
--    -------
--    dm : qobj
--        Steady state density matrix.
--
--    .. note::
--
--        See: Sze Meng Tan,
--        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
--        Section (10.16)
--
--    """
--
--    L_0 = liouvillian(H_0, c_ops)
--    L_m = L_p = 0.5 * liouvillian(Op_t)
--    # L_p and L_m correspond to the positive and negative
--    # frequency terms respectively.
--    # They are independent in the model, so we keep both names.
--    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
--    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
--
--    if isinstance(H_0.data, _data.CSR) and not sparse:
--        L_0 = L_0.to("Dense")
--        L_m = L_m.to("Dense")
--        L_p = L_p.to("Dense")
--        Id = Id.to("Dense")
--
--    for n_i in np.arange(n_it, 0, -1):
--        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
--        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
--        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
--        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
--
--    M_subs = L_0 + L_m @ S + L_p @ T
--    return steadystate(M_subs, solver=solver, **kwargs)
--
--
--def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
--                   **kwargs):
--    """
--    Compute the pseudo inverse for a Liouvillian superoperator, optionally
--    given its steady state density matrix (which will be computed if not
--    given).
--
--    Parameters
--    ----------
--    L : Qobj
--        A Liouvillian superoperator for which to compute the pseudo inverse.
--
--    rhoss : Qobj
--        A steadystate density matrix as Qobj instance, for the Liouvillian
--        superoperator L.
--
--    w : double
--        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
--        systems and large sparse systems. Small sparse systems can fail for
--        zero frequencies.
--
--    sparse : bool
--        Flag that indicate whether to use sparse or dense matrix methods when
--        computing the pseudo inverse.
--
--    method : string
--        Method used to compte matrix inverse.
--        Choice are 'pinv' to use scipy's function of the same name, or a linear
--        system solver.
--        Default supported solver are:
--
--        - "solve", "lstsq"
--          dense solver from numpy.linalg
--        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
--          sparse solver from scipy.sparse.linalg
--        - "mkl_spsolve",
--          sparse solver by mkl.
--
--        Extension to qutip, such as qutip-tensorflow, can use come with their
--        own solver. When ``L`` use these data backends, see the corresponding
--        libraries ``linalg`` for available solver.
--
--    kwargs : dictionary
--        Additional keyword arguments for setting parameters for solver methods.
--
--    Returns
--    -------
--    R : Qobj
--        Returns a Qobj instance representing the pseudo inverse of L.
--
--    .. note::
--
--        In general the inverse of a sparse matrix will be dense.  If you
--        are applying the inverse to a density matrix then it is better to
--        cast the problem as an Ax=b type problem where the explicit calculation
--        of the inverse is not required. See page 67 of "Electrons in
--        nanostructures" C. Flindt, PhD Thesis available online:
--        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
--        file_4732600/content
--
--        Note also that the definition of the pseudo-inverse herein is different
--        from numpys pinv() alone, as it includes pre and post projection onto
--        the subspace defined by the projector Q.
--
--    """
--    if rhoss is None:
--        rhoss = steadystate(L)
--
--    sparse = kwargs.pop("sparse", False)
--    if method == "direct":
--        method = "splu" if sparse else "pinv"
--    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
--    dense_solvers = ["solve", "lstsq", "pinv"]
--    if isinstance(L.data, _data.CSR) and method in dense_solvers:
--        L = L.to("dense")
--    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
--        L = L.to("csr")
--
--    N = np.prod(L.dims[0][0])
--    dtype = type(L.data)
--    rhoss_vec = operator_to_vector(rhoss)
--
--    tr_op = qeye(L.dims[0][0])
--    tr_op_vec = operator_to_vector(tr_op)
--
--    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
--    I = _data.csr.identity(N * N)
--    Q = _data.sub(I, P)
--
--    if w in [None, 0.0]:
--        L += 1e-15j
--    else:
--        L += 1.0j*w
--
--    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
--
--    if use_rcm:
--        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
--        A = _data.permute.indices(L.data, perm, perm)
--        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
--    else:
--        A = L.data
--
--    if method in ["pinv", "numpy", "scipy", "scipy2"]:
--        # from scipy 1.7.0, they all use the same algorithm.
--        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
--        LIQ = _data.matmul(LI, Q)
--    elif method == "spilu":
--        if not isinstance(A, _data.CSR):
--            raise TypeError("'spilu' method can only be used with sparse data")
--        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
--        LIQ = _data.Dense(ILU.solve(Q.to_array()))
--    else:
--        LIQ = _data.solve(A, Q, method, options=kwargs)
--
--    R = _data.matmul(Q, LIQ)
--
--    if use_rcm:
--        rev_perm = np.argsort(perm)
--        R = _data.permute.indices(R, rev_perm, rev_perm)
--
--    return Qobj(R, dims=L.dims)
--
--
--def _compute_precond(L, args):
--    spilu_keys = {
--        'permc_spec',
--        'drop_tol',
--        'diag_pivot_thresh',
--        'fill_factor',
--        'options',
--    }
--    ss_args = {
--        key: args.pop(key)
--        for key in spilu_keys
--        if key in args
--    }
--    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
--    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
-+from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
-+from qutip import vector_to_operator, operator_to_vector
-+from qutip import settings
-+import qutip.core.data as _data
-+import numpy as np
-+import scipy.sparse.csgraph
-+import scipy.sparse.linalg
-+from warnings import warn
-+
-+
-+__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
-+
-+
-+def _permute_wbm(L, b):
-+    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
-+    L = _data.permute.indices(L, perm, None)
-+    b = _data.permute.indices(b, perm, None)
-+    return L, b
-+
-+
-+def _permute_rcm(L, b):
-+    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
-+    L = _data.permute.indices(L, perm, perm)
-+    b = _data.permute.indices(b, perm, None)
-+    return L, b, perm
-+
-+
-+def _reverse_rcm(rho, perm):
-+    rev_perm = np.argsort(perm)
-+    rho = _data.permute.indices(rho, rev_perm, None)
-+    return rho
-+
-+
-+def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
-+    """
-+    Calculates the steady state for quantum evolution subject to the supplied
-+    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
-+    collapse operators.
-+
-+    If the user passes a Hamiltonian then it, along with the list of collapse
-+    operators, will be converted into a Liouvillian operator in Lindblad form.
-+
-+    Parameters
-+    ----------
-+    A : :obj:`~Qobj`
-+        A Hamiltonian or Liouvillian operator.
-+
-+    c_op_list : list
-+        A list of collapse operators.
-+
-+    method : str, default='direct'
-+        The allowed methods are composed of 2 parts, the steadystate method:
-+        - "direct": Solving ``L(rho_ss) = 0``
-+        - "eigen" : Eigenvalue problem
-+        - "svd" : Singular value decomposition
-+        - "power" : Inverse-power method
-+
-+    solver : str, default=None
-+        'direct' and 'power' methods only.
-+        Solver to use when solving the ``L(rho_ss) = 0`` equation.
-+        Default supported solver are:
-+
-+        - "solve", "lstsq"
-+          dense solver from numpy.linalg
-+        - "spsolve", "gmres", "lgmres", "bicgstab"
-+          sparse solver from scipy.sparse.linalg
-+        - "mkl_spsolve"
-+          sparse solver by mkl.
-+
-+        Extension to qutip, such as qutip-tensorflow, can use come with their
-+        own solver. When ``A`` and ``c_ops`` use these data backends, see the
-+        corresponding libraries ``linalg`` for available solver.
-+
-+        Extra options for these solver can be passed in ``**kw``.
-+
-+    use_rcm : bool, default False
-+        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
-+        factorization of the Liouvillian.
-+        Used with 'direct' or 'power' method.
-+
-+    use_wbm : bool, default False
-+        Use Weighted Bipartite Matching reordering to make the Liouvillian
-+        diagonally dominant.  This is useful for iterative preconditioners
-+        only. Used with 'direct' or 'power' method.
-+
-+    weight : float, optional
-+        Sets the size of the elements used for adding the unity trace condition
-+        to the linear solvers.  This is set to the average abs value of the
-+        Liouvillian elements if not specified by the user.
-+        Used with 'direct' method.
-+
-+    power_tol : float, default 1e-12
-+        Tolerance for the solution when using the 'power' method.
-+
-+    power_maxiter : int, default 10
-+        Maximum number of iteration to use when looking for a solution when
-+        using the 'power' method.
-+
-+    power_eps: double, default 1e-15
-+        Small weight used in the "power" method.
-+
-+    sparse: bool
-+        Whether to use the sparse eigen solver with the "eigen" method
-+        (default sparse).  With "direct" and "power" method, when the solver is
-+        not specified, it is used to set whether "solve" or "spsolve" is
-+        used as default solver.
-+
-+    **kwargs :
-+        Extra options to pass to the linear system solver. See the
-+        documentation of the used solver in ``numpy.linalg`` or
-+        ``scipy.sparse.linalg`` to see what extra arguments are supported.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Steady state density matrix.
-+    info : dict, optional
-+        Dictionary containing solver-specific information about the solution.
-+
-+    .. note::
-+
-+        The SVD method works only for dense operators (i.e. small systems).
-+
-+    """
-+    if not A.issuper and not c_ops:
-+        raise TypeError('Cannot calculate the steady state for a ' +
-+                        'non-dissipative system.')
-+    if not A.issuper:
-+        A = liouvillian(A)
-+    for op in c_ops:
-+        A += lindblad_dissipator(op)
-+
-+    if "-" in method:
-+        # to support v4's "power-gmres" method
-+        method, solver = method.split("-")
-+
-+    if solver == "mkl":
-+        solver = "mkl_spsolve"
-+
-+    # Keys supported in v4, but removed in v5
-+    if kwargs.pop("return_info", False):
-+        warn("Steadystate no longer supports return_info", DeprecationWarning)
-+    if "mtol" in kwargs and "power_tol" not in kwargs:
-+        kwargs["power_tol"] = kwargs["mtol"]
-+    kwargs.pop("mtol", None)
-+
-+    if method == "eigen":
-+        return _steadystate_eigen(A, **kwargs)
-+    if method == "svd":
-+        return _steadystate_svd(A, **kwargs)
-+
-+    # We want to be able to use this without having to know what data type the
-+    # liouvillian uses. For extra data types (tensorflow) we can expect
-+    # the users to know they are using them and choose an appropriate solver
-+    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
-+    if not isinstance(A.data, (_data.CSR, _data.Dense)):
-+        # Tensorflow, jax, etc. data type
-+        pass
-+    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
-+        A = A.to("dense")
-+    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
-+        A = A.to("csr")
-+    elif solver is None and kwargs.get("sparse", False):
-+        A = A.to("csr")
-+        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
-+    elif solver is None and (kwargs.get("sparse", None) is False):
-+        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
-+        A = A.to("dense")
-+        solver = "solve"
-+
-+    if method in ["direct", "iterative"]:
-+        # Remove unused kwargs, so only used and pass-through ones are included
-+        kwargs.pop("power_tol", 0)
-+        kwargs.pop("power_maxiter", 0)
-+        kwargs.pop("power_eps", 0)
-+        kwargs.pop("sparse", 0)
-+        return _steadystate_direct(A, kwargs.pop("weight", 0),
-+                                   method=solver, **kwargs)
-+
-+    elif method == "power":
-+        # Remove unused kwargs, so only used and pass-through ones are included
-+        kwargs.pop("weight", 0)
-+        kwargs.pop("sparse", 0)
-+        return _steadystate_power(A, method=solver, **kwargs)
-+    else:
-+        raise ValueError(f"method {method} not supported.")
-+
-+
-+def _steadystate_direct(A, weight, **kw):
-+    # Find the weight, no good dispatched function available...
-+    if weight:
-+        pass
-+    elif isinstance(A.data, _data.CSR):
-+        weight = np.mean(np.abs(A.data.as_scipy().data))
-+    else:
-+        A_np = np.abs(A.full())
-+        weight = np.mean(A_np[A_np > 0])
-+
-+    # Add weight to the Liouvillian
-+    # A[:, 0] = vectorized(eye * weight)
-+    # We don't have a function to overwrite part of an array, so
-+    N = A.shape[0]
-+    n = int(N**0.5)
-+    dtype = type(A.data)
-+    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
-+    weight_mat = _data.kron(
-+        weight_vec.transpose(),
-+        _data.one_element[dtype]((N, 1), (0, 0), 1)
-+    )
-+    L = _data.add(weight_mat, A.data)
-+    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
-+
-+    # Permutation are part of scipy.sparse, thus only supported for CSR.
-+    if kw.pop("use_wbm", False):
-+        if isinstance(L, _data.CSR):
-+            L, b = _permute_wbm(L, b)
-+        else:
-+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-+    use_rcm = False
-+    if kw.pop("use_rcm", False):
-+        if isinstance(L, _data.CSR):
-+            L, b, perm = _permute_rcm(L, b)
-+            use_rcm = True
-+        else:
-+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-+    if kw.pop("use_precond", False):
-+        if isinstance(L, _data.CSR):
-+            kw["M"] = _compute_precond(L, kw)
-+        else:
-+            warn("Only sparse solver use preconditioners.", RuntimeWarning)
-+
-+
-+    method = kw.pop("method", None)
-+    steadystate = _data.solve(L, b, method, options=kw)
-+
-+    if use_rcm:
-+        steadystate = _reverse_rcm(steadystate, perm)
-+
-+    rho_ss = _data.column_unstack(steadystate, n)
-+    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
-+
-+    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
-+
-+
-+def _steadystate_eigen(L, **kw):
-+    val, vec = (L.dag() @ L).eigenstates(
-+        eigvals=1,
-+        sort="low",
-+        # v4's implementation only uses sparse eigen solver
-+        sparse=kw.pop("sparse", True)
-+    )
-+    rho = vector_to_operator(vec[0])
-+    return rho / rho.tr()
-+
-+
-+def _steadystate_svd(L, **kw):
-+    u, s, vh = _data.svd(L.data, True)
-+    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
-+    rho = vector_to_operator(vec)
-+    return rho / rho.tr()
-+
-+
-+def _steadystate_power(A, **kw):
-+    A += kw.pop("power_eps", 1e-15)
-+    L = A.data
-+    N = L.shape[1]
-+    y = _data.Dense([1]*N)
-+
-+    # Permutation are part of scipy.sparse, thus only supported for CSR.
-+    if kw.pop("use_wbm", False):
-+        if isinstance(L, _data.CSR):
-+            L, y = _permute_wbm(L, y)
-+        else:
-+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-+    use_rcm = False
-+    if kw.pop("use_rcm", False):
-+        if isinstance(L, _data.CSR):
-+            L, y, perm = _permute_rcm(L, y)
-+            use_rcm = True
-+        else:
-+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-+    if kw.pop("use_precond", False):
-+        if isinstance(L, _data.CSR):
-+            kw["M"] = _compute_precond(L, kw)
-+        else:
-+            warn("Only sparse solver use preconditioners.", RuntimeWarning)
-+
-+    it = 0
-+    maxiter = kw.pop("power_maxiter", 10)
-+    tol = kw.pop("power_tol", 1e-12)
-+    method = kw.pop("method", None)
-+    while it < maxiter and _data.norm.max(L @ y) > tol:
-+        y = _data.solve(L, y, method, options=kw)
-+        y = y / _data.norm.max(y)
-+        it += 1
-+
-+    if it >= maxiter:
-+        raise Exception('Failed to find steady state after ' +
-+                        str(maxiter) + ' iterations')
-+
-+    if use_rcm:
-+        y = _reverse_rcm(y, perm)
-+
-+    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
-+    rho_ss = rho_ss + rho_ss.dag()
-+    rho_ss = rho_ss / rho_ss.tr()
-+    rho_ss.isherm = True
-+    return rho_ss
-+
-+
-+def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
-+                        solver=None, **kwargs):
-+    """
-+    Calculates the effective steady state for a driven
-+     system with a time-dependent cosinusoidal term:
-+
-+    .. math::
-+
-+        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
-+         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
-+
-+    Parameters
-+    ----------
-+    H_0 : :obj:`~Qobj`
-+        A Hamiltonian or Liouvillian operator.
-+
-+    c_ops : list
-+        A list of collapse operators.
-+
-+    Op_t : :obj:`~Qobj`
-+        The the interaction operator which is multiplied by the cosine
-+
-+    w_d : float, default 1.0
-+        The frequency of the drive
-+
-+    n_it : int, default 3
-+        The number of iterations for the solver
-+
-+    sparse : bool, default False
-+        Solve for the steady state using sparse algorithms.
-+
-+    solver : str, default=None
-+        Solver to use when solving the linear system.
-+        Default supported solver are:
-+
-+        - "solve", "lstsq"
-+          dense solver from numpy.linalg
-+        - "spsolve", "gmres", "lgmres", "bicgstab"
-+          sparse solver from scipy.sparse.linalg
-+        - "mkl_spsolve"
-+          sparse solver by mkl.
-+
-+        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
-+        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
-+        for the names and details of additional solvers they may provide.
-+
-+    **kwargs:
-+        Extra options to pass to the linear system solver. See the
-+        documentation of the used solver in ``numpy.linalg`` or
-+        ``scipy.sparse.linalg`` to see what extra arguments are supported.
-+
-+    Returns
-+    -------
-+    dm : qobj
-+        Steady state density matrix.
-+
-+    .. note::
-+
-+        See: Sze Meng Tan,
-+        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
-+        Section (10.16)
-+
-+    """
-+
-+    L_0 = liouvillian(H_0, c_ops)
-+    L_m = L_p = 0.5 * liouvillian(Op_t)
-+    # L_p and L_m correspond to the positive and negative
-+    # frequency terms respectively.
-+    # They are independent in the model, so we keep both names.
-+    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
-+    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
-+
-+    if isinstance(H_0.data, _data.CSR) and not sparse:
-+        L_0 = L_0.to("Dense")
-+        L_m = L_m.to("Dense")
-+        L_p = L_p.to("Dense")
-+        Id = Id.to("Dense")
-+
-+    for n_i in np.arange(n_it, 0, -1):
-+        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
-+        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
-+        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
-+        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
-+
-+    M_subs = L_0 + L_m @ S + L_p @ T
-+    return steadystate(M_subs, solver=solver, **kwargs)
-+
-+
-+def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
-+                   **kwargs):
-+    """
-+    Compute the pseudo inverse for a Liouvillian superoperator, optionally
-+    given its steady state density matrix (which will be computed if not
-+    given).
-+
-+    Parameters
-+    ----------
-+    L : Qobj
-+        A Liouvillian superoperator for which to compute the pseudo inverse.
-+
-+    rhoss : Qobj
-+        A steadystate density matrix as Qobj instance, for the Liouvillian
-+        superoperator L.
-+
-+    w : double
-+        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
-+        systems and large sparse systems. Small sparse systems can fail for
-+        zero frequencies.
-+
-+    sparse : bool
-+        Flag that indicate whether to use sparse or dense matrix methods when
-+        computing the pseudo inverse.
-+
-+    method : string
-+        Method used to compte matrix inverse.
-+        Choice are 'pinv' to use scipy's function of the same name, or a linear
-+        system solver.
-+        Default supported solver are:
-+
-+        - "solve", "lstsq"
-+          dense solver from numpy.linalg
-+        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
-+          sparse solver from scipy.sparse.linalg
-+        - "mkl_spsolve",
-+          sparse solver by mkl.
-+
-+        Extension to qutip, such as qutip-tensorflow, can use come with their
-+        own solver. When ``L`` use these data backends, see the corresponding
-+        libraries ``linalg`` for available solver.
-+
-+    kwargs : dictionary
-+        Additional keyword arguments for setting parameters for solver methods.
-+
-+    Returns
-+    -------
-+    R : Qobj
-+        Returns a Qobj instance representing the pseudo inverse of L.
-+
-+    .. note::
-+
-+        In general the inverse of a sparse matrix will be dense.  If you
-+        are applying the inverse to a density matrix then it is better to
-+        cast the problem as an Ax=b type problem where the explicit calculation
-+        of the inverse is not required. See page 67 of "Electrons in
-+        nanostructures" C. Flindt, PhD Thesis available online:
-+        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
-+        file_4732600/content
-+
-+        Note also that the definition of the pseudo-inverse herein is different
-+        from numpys pinv() alone, as it includes pre and post projection onto
-+        the subspace defined by the projector Q.
-+
-+    """
-+    if rhoss is None:
-+        rhoss = steadystate(L)
-+
-+    sparse = kwargs.pop("sparse", False)
-+    if method == "direct":
-+        method = "splu" if sparse else "pinv"
-+    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
-+    dense_solvers = ["solve", "lstsq", "pinv"]
-+    if isinstance(L.data, _data.CSR) and method in dense_solvers:
-+        L = L.to("dense")
-+    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
-+        L = L.to("csr")
-+
-+    N = np.prod(L.dims[0][0])
-+    dtype = type(L.data)
-+    rhoss_vec = operator_to_vector(rhoss)
-+
-+    tr_op = qeye(L.dims[0][0])
-+    tr_op_vec = operator_to_vector(tr_op)
-+
-+    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
-+    I = _data.csr.identity(N * N)
-+    Q = _data.sub(I, P)
-+
-+    if w in [None, 0.0]:
-+        L += 1e-15j
-+    else:
-+        L += 1.0j*w
-+
-+    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
-+
-+    if use_rcm:
-+        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
-+        A = _data.permute.indices(L.data, perm, perm)
-+        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
-+    else:
-+        A = L.data
-+
-+    if method in ["pinv", "numpy", "scipy", "scipy2"]:
-+        # from scipy 1.7.0, they all use the same algorithm.
-+        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
-+        LIQ = _data.matmul(LI, Q)
-+    elif method == "spilu":
-+        if not isinstance(A, _data.CSR):
-+            raise TypeError("'spilu' method can only be used with sparse data")
-+        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
-+        LIQ = _data.Dense(ILU.solve(Q.to_array()))
-+    else:
-+        LIQ = _data.solve(A, Q, method, options=kwargs)
-+
-+    R = _data.matmul(Q, LIQ)
-+
-+    if use_rcm:
-+        rev_perm = np.argsort(perm)
-+        R = _data.permute.indices(R, rev_perm, rev_perm)
-+
-+    return Qobj(R, dims=L.dims)
-+
-+
-+def _compute_precond(L, args):
-+    spilu_keys = {
-+        'permc_spec',
-+        'drop_tol',
-+        'diag_pivot_thresh',
-+        'fill_factor',
-+        'options',
-+    }
-+    ss_args = {
-+        key: args.pop(key)
-+        for key in spilu_keys
-+        if key in args
-+    }
-+    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
-+    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
-diff --git a/qutip/testing.py b/qutip/testing.py
-index 60eb677f..fc2d3768 100644
---- a/qutip/testing.py
-+++ b/qutip/testing.py
-@@ -1,34 +1,34 @@
--from .about import about
--from .settings import settings as qset
--
--def run(full=False):
--    """
--    Run the test scripts for QuTiP.
--
--    Parameters
--    ----------
--    full: bool
--        If True run all test (30 min). Otherwise skip few variants of the
--        slowest tests.
--    """
--    # Call about to get all version info printed with tests
--    about()
--    import pytest
--    # real_num_cpu = qset.num_cpus
--    # real_thresh = qset.openmp_thresh
--    # if qset.has_openmp:
--        # For travis which VMs have only 1 cpu.
--        # Make sure the openmp version of the functions are tested.
--    #     qset.num_cpus = 2
--    #     qset.openmp_thresh = 100
--
--    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
--    if not full:
--        test_options += ['-m', 'not slow']
--    pytest.main(test_options + ["qutip"])
--    # runs tests in qutip.tests module only
--
--    # Restore previous settings
--    # if qset.has_openmp:
--    #     qset.num_cpus = real_num_cpu
--    #     qset.openmp_thresh = real_thresh
-+from .about import about
-+from .settings import settings as qset
-+
-+def run(full=False):
-+    """
-+    Run the test scripts for QuTiP.
-+
-+    Parameters
-+    ----------
-+    full: bool
-+        If True run all test (30 min). Otherwise skip few variants of the
-+        slowest tests.
-+    """
-+    # Call about to get all version info printed with tests
-+    about()
-+    import pytest
-+    # real_num_cpu = qset.num_cpus
-+    # real_thresh = qset.openmp_thresh
-+    # if qset.has_openmp:
-+        # For travis which VMs have only 1 cpu.
-+        # Make sure the openmp version of the functions are tested.
-+    #     qset.num_cpus = 2
-+    #     qset.openmp_thresh = 100
-+
-+    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
-+    if not full:
-+        test_options += ['-m', 'not slow']
-+    pytest.main(test_options + ["qutip"])
-+    # runs tests in qutip.tests module only
-+
-+    # Restore previous settings
-+    # if qset.has_openmp:
-+    #     qset.num_cpus = real_num_cpu
-+    #     qset.openmp_thresh = real_thresh
-diff --git a/qutip/tests/Hadamard_params.ini b/qutip/tests/Hadamard_params.ini
-index 60dc840f..8d4ea5ab 100644
---- a/qutip/tests/Hadamard_params.ini
-+++ b/qutip/tests/Hadamard_params.ini
-@@ -1,19 +1,19 @@
--[optimconfig]
--optim_method=FMIN_L_BFGS_B
--pulse_type = LIN
--
--[dynamics]
--evo_time = 6
--num_tslots = 6
--
--[termconds]
--fid_err_targ = 1e-10
--
--[optimizer]
--amp_lbound = -1.0
--amp_ubound = 1.0
--
--[pulsegen]
--scaling = 1.0
--lbound = -1.0
--ubound = 1.0
-+[optimconfig]
-+optim_method=FMIN_L_BFGS_B
-+pulse_type = LIN
-+
-+[dynamics]
-+evo_time = 6
-+num_tslots = 6
-+
-+[termconds]
-+fid_err_targ = 1e-10
-+
-+[optimizer]
-+amp_lbound = -1.0
-+amp_ubound = 1.0
-+
-+[pulsegen]
-+scaling = 1.0
-+lbound = -1.0
-+ubound = 1.0
-diff --git a/qutip/tests/conftest.py b/qutip/tests/conftest.py
-index 49d4add0..71c90d86 100644
---- a/qutip/tests/conftest.py
-+++ b/qutip/tests/conftest.py
-@@ -1,158 +1,158 @@
--import pytest
--import functools
--import os
--import tempfile
--import numpy as np
--
--
--def _add_repeats_if_marked(metafunc):
--    """
--    If the metafunc is marked with the 'repeat' mark, then add the requisite
--    number of repeats via parametrisation.
--    """
--    marker = metafunc.definition.get_closest_marker('repeat')
--    if marker:
--        count = marker.args[0]
--        metafunc.fixturenames.append('_repeat_count')
--        metafunc.parametrize('_repeat_count',
--                             range(count),
--                             ids=["rep({})".format(x+1) for x in range(count)])
--
--
--def _skip_cython_tests_if_unavailable(item):
--    """
--    Skip the current test item if Cython is unavailable for import, or isn't a
--    high enough version.
--    """
--    if item.get_closest_marker("requires_cython"):
--        # importorskip rather than mark.skipif because this way we get pytest's
--        # version-handling semantics.
--        pytest.importorskip('Cython', minversion='0.14')
--
--
--@pytest.hookimpl(trylast=True)
--def pytest_generate_tests(metafunc):
--    _add_repeats_if_marked(metafunc)
--
--
--def pytest_runtest_setup(item):
--    _skip_cython_tests_if_unavailable(item)
--
--
--def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
--                           verbose=True, names=('ACTUAL', 'DESIRED'),
--                           precision=8):
--    """
--    Taken almost verbatim from `np.testing._private.utils`, except this version
--    doesn't truncate output if it's longer than three lines.
--
--    LICENCE
--    -------
--    Copyright (c) 2005-2020, NumPy Developers.
--    All rights reserved.
--
--    Redistribution and use in source and binary forms, with or without
--    modification, are permitted provided that the following conditions are met:
--
--    - Redistributions of source code must retain the above copyright notice,
--      this list of conditions and the following disclaimer.
--
--    - Redistributions in binary form must reproduce the above copyright notice,
--      this list of conditions and the following disclaimer in the documentation
--      and/or other materials provided with the distribution.
--
--    - Neither the name of the NumPy Developers nor the names of any
--      contributors may be used to endorse or promote products derived from this
--      software without specific prior written permission.
--
--    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
--    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
--    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
--    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
--    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
--    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
--    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
--    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
--    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
--    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
--    POSSIBILITY OF SUCH DAMAGE.
--    """
--    msg = ['\n' + header]
--    if err_msg:
--        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
--            msg = [msg[0] + ' ' + err_msg]
--        else:
--            msg.append(err_msg)
--    if verbose:
--        for i, a in enumerate(arrays):
--            if isinstance(a, np.ndarray):
--                # precision argument is only needed if the objects are ndarrays
--                r_func = functools.partial(np.core.array_repr,
--                                           precision=precision)
--            else:
--                r_func = repr
--
--            try:
--                # [diff] Remove truncation threshold from array output.
--                with np.printoptions(threshold=np.inf):
--                    r = r_func(a)
--            except Exception as exc:
--                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
--            # [diff] The original truncates the output to 3 lines here.
--            msg.append(' %s: %s' % (names[i], r))
--    return '\n'.join(msg)
--
--
--# Find the private module used by numpy to store its testing utility functions
--# so that we can monkeypatch the error messages to be more verbose.  QuTiP
--# supports numpy from 1.12 upwards, so we have to search.
--_numpy_private_utils_paths = [
--    ['_private', 'utils'],    # 1.15.0 <= x
--    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
--    ['utils'],                # 1.14.0 > x
--]
--for possible_path in _numpy_private_utils_paths:
--    try:
--        module = np.testing
--        for submodule in possible_path:
--            module = getattr(module, submodule)
--        _numpy_private_utils = module
--        break
--    except NameError:
--        pass
--else:
--    # If we can't locate it for some reason, then we don't attempt to patch.
--    _numpy_private_utils = None
--
--if _numpy_private_utils is not None:
--    @pytest.fixture(autouse=True)
--    def do_not_truncate_numpy_output(monkeypatch):
--        """
--        Monkeypatch the internal numpy function used for printing arrays so
--        that we get full output that isn't cut off after three lines.
--        """
--        with monkeypatch.context() as patch:
--            patch.setattr(np.testing._private.utils, "build_err_msg",
--                          _patched_build_err_msg)
--            # Yield inside context manager just to minimize the amount of time
--            # we've monkeypatched such a core library (and a private function!)
--            yield
--
--
--@pytest.fixture
--def in_temporary_directory():
--    """
--    Creates a temporary directory for the lifetime of the fixture and changes
--    into it.  All relative paths used will be in the temporary directory, and
--    everything will automatically be cleaned up at the end of the fixture's
--    life.
--    """
--    previous_dir = os.getcwd()
--    with tempfile.TemporaryDirectory() as temporary_dir:
--        os.chdir(temporary_dir)
--        yield
--        # pytest should catch exceptions occuring in functions using the
--        # fixture, so this should always be called.  We want it here rather
--        # than outside to prevent the case of the directory failing to be
--        # removed because it is 'busy'.
--        os.chdir(previous_dir)
-+import pytest
-+import functools
-+import os
-+import tempfile
-+import numpy as np
-+
-+
-+def _add_repeats_if_marked(metafunc):
-+    """
-+    If the metafunc is marked with the 'repeat' mark, then add the requisite
-+    number of repeats via parametrisation.
-+    """
-+    marker = metafunc.definition.get_closest_marker('repeat')
-+    if marker:
-+        count = marker.args[0]
-+        metafunc.fixturenames.append('_repeat_count')
-+        metafunc.parametrize('_repeat_count',
-+                             range(count),
-+                             ids=["rep({})".format(x+1) for x in range(count)])
-+
-+
-+def _skip_cython_tests_if_unavailable(item):
-+    """
-+    Skip the current test item if Cython is unavailable for import, or isn't a
-+    high enough version.
-+    """
-+    if item.get_closest_marker("requires_cython"):
-+        # importorskip rather than mark.skipif because this way we get pytest's
-+        # version-handling semantics.
-+        pytest.importorskip('Cython', minversion='0.14')
-+
-+
-+@pytest.hookimpl(trylast=True)
-+def pytest_generate_tests(metafunc):
-+    _add_repeats_if_marked(metafunc)
-+
-+
-+def pytest_runtest_setup(item):
-+    _skip_cython_tests_if_unavailable(item)
-+
-+
-+def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
-+                           verbose=True, names=('ACTUAL', 'DESIRED'),
-+                           precision=8):
-+    """
-+    Taken almost verbatim from `np.testing._private.utils`, except this version
-+    doesn't truncate output if it's longer than three lines.
-+
-+    LICENCE
-+    -------
-+    Copyright (c) 2005-2020, NumPy Developers.
-+    All rights reserved.
-+
-+    Redistribution and use in source and binary forms, with or without
-+    modification, are permitted provided that the following conditions are met:
-+
-+    - Redistributions of source code must retain the above copyright notice,
-+      this list of conditions and the following disclaimer.
-+
-+    - Redistributions in binary form must reproduce the above copyright notice,
-+      this list of conditions and the following disclaimer in the documentation
-+      and/or other materials provided with the distribution.
-+
-+    - Neither the name of the NumPy Developers nor the names of any
-+      contributors may be used to endorse or promote products derived from this
-+      software without specific prior written permission.
-+
-+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
-+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+    POSSIBILITY OF SUCH DAMAGE.
-+    """
-+    msg = ['\n' + header]
-+    if err_msg:
-+        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
-+            msg = [msg[0] + ' ' + err_msg]
-+        else:
-+            msg.append(err_msg)
-+    if verbose:
-+        for i, a in enumerate(arrays):
-+            if isinstance(a, np.ndarray):
-+                # precision argument is only needed if the objects are ndarrays
-+                r_func = functools.partial(np.core.array_repr,
-+                                           precision=precision)
-+            else:
-+                r_func = repr
-+
-+            try:
-+                # [diff] Remove truncation threshold from array output.
-+                with np.printoptions(threshold=np.inf):
-+                    r = r_func(a)
-+            except Exception as exc:
-+                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
-+            # [diff] The original truncates the output to 3 lines here.
-+            msg.append(' %s: %s' % (names[i], r))
-+    return '\n'.join(msg)
-+
-+
-+# Find the private module used by numpy to store its testing utility functions
-+# so that we can monkeypatch the error messages to be more verbose.  QuTiP
-+# supports numpy from 1.12 upwards, so we have to search.
-+_numpy_private_utils_paths = [
-+    ['_private', 'utils'],    # 1.15.0 <= x
-+    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
-+    ['utils'],                # 1.14.0 > x
-+]
-+for possible_path in _numpy_private_utils_paths:
-+    try:
-+        module = np.testing
-+        for submodule in possible_path:
-+            module = getattr(module, submodule)
-+        _numpy_private_utils = module
-+        break
-+    except NameError:
-+        pass
-+else:
-+    # If we can't locate it for some reason, then we don't attempt to patch.
-+    _numpy_private_utils = None
-+
-+if _numpy_private_utils is not None:
-+    @pytest.fixture(autouse=True)
-+    def do_not_truncate_numpy_output(monkeypatch):
-+        """
-+        Monkeypatch the internal numpy function used for printing arrays so
-+        that we get full output that isn't cut off after three lines.
-+        """
-+        with monkeypatch.context() as patch:
-+            patch.setattr(np.testing._private.utils, "build_err_msg",
-+                          _patched_build_err_msg)
-+            # Yield inside context manager just to minimize the amount of time
-+            # we've monkeypatched such a core library (and a private function!)
-+            yield
-+
-+
-+@pytest.fixture
-+def in_temporary_directory():
-+    """
-+    Creates a temporary directory for the lifetime of the fixture and changes
-+    into it.  All relative paths used will be in the temporary directory, and
-+    everything will automatically be cleaned up at the end of the fixture's
-+    life.
-+    """
-+    previous_dir = os.getcwd()
-+    with tempfile.TemporaryDirectory() as temporary_dir:
-+        os.chdir(temporary_dir)
-+        yield
-+        # pytest should catch exceptions occuring in functions using the
-+        # fixture, so this should always be called.  We want it here rather
-+        # than outside to prevent the case of the directory failing to be
-+        # removed because it is 'busy'.
-+        os.chdir(previous_dir)
-diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
-index 01d05c01..c46297b1 100644
---- a/qutip/tests/core/data/conftest.py
-+++ b/qutip/tests/core/data/conftest.py
-@@ -1,66 +1,66 @@
--import numpy as np
--import scipy.sparse
--
--import qutip
--
--
--def shuffle_indices_scipy_csr(matrix):
--    """
--    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
--    return a new array.  This should represent the same matrix, but in the less
--    efficient, "unsorted" manner.  All mathematical operations should still
--    work the same after this, but may be slower.
--
--    This is not guaranteed to change the order of the indices in every case.
--    If there is at most one value per row, there is no unsorted order.  In
--    general, we attempt to shuffle, and if this returns the same order as
--    before, we just reverse it to ensure it's different.
--    """
--    out = matrix.copy()
--    for row in range(out.shape[0]):
--        ptr = (out.indptr[row], out.indptr[row + 1])
--        if ptr[1] - ptr[0] > 1:
--            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
--            # If sorted, reverse it.
--            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
--            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
--            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
--    return out
--
--
--def random_scipy_csr(shape, density, sorted_):
--    """
--    Generate a random scipy CSR matrix with the given shape, nnz density, and
--    with indices that are either sorted or unsorted.  The nnz elements will
--    always be at least one.
--    """
--    nnz = int(shape[0] * shape[1] * density) or 1
--    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
--    rows = np.random.choice(np.arange(shape[0]), nnz)
--    cols = np.random.choice(np.arange(shape[1]), nnz)
--    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
--    if not sorted_:
--        shuffle_indices_scipy_csr(sci)
--    return sci
--
--
--def random_numpy_dense(shape, fortran):
--    """Generate a random numpy dense matrix with the given shape."""
--    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
--    if fortran:
--        out = np.asfortranarray(out)
--    return out
--
--
--def random_csr(shape, density, sorted_):
--    """
--    Generate a random qutip CSR matrix with the given shape, nnz density, and
--    with indices that are either sorted or unsorted.  The nnz elements will
--    always be at least one (use data.csr.zeros otherwise).
--    """
--    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
--
--
--def random_dense(shape, fortran):
--    """Generate a random qutip Dense matrix of the given shape."""
--    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
-+import numpy as np
-+import scipy.sparse
-+
-+import qutip
-+
-+
-+def shuffle_indices_scipy_csr(matrix):
-+    """
-+    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
-+    return a new array.  This should represent the same matrix, but in the less
-+    efficient, "unsorted" manner.  All mathematical operations should still
-+    work the same after this, but may be slower.
-+
-+    This is not guaranteed to change the order of the indices in every case.
-+    If there is at most one value per row, there is no unsorted order.  In
-+    general, we attempt to shuffle, and if this returns the same order as
-+    before, we just reverse it to ensure it's different.
-+    """
-+    out = matrix.copy()
-+    for row in range(out.shape[0]):
-+        ptr = (out.indptr[row], out.indptr[row + 1])
-+        if ptr[1] - ptr[0] > 1:
-+            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
-+            # If sorted, reverse it.
-+            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
-+            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
-+            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
-+    return out
-+
-+
-+def random_scipy_csr(shape, density, sorted_):
-+    """
-+    Generate a random scipy CSR matrix with the given shape, nnz density, and
-+    with indices that are either sorted or unsorted.  The nnz elements will
-+    always be at least one.
-+    """
-+    nnz = int(shape[0] * shape[1] * density) or 1
-+    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-+    rows = np.random.choice(np.arange(shape[0]), nnz)
-+    cols = np.random.choice(np.arange(shape[1]), nnz)
-+    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
-+    if not sorted_:
-+        shuffle_indices_scipy_csr(sci)
-+    return sci
-+
-+
-+def random_numpy_dense(shape, fortran):
-+    """Generate a random numpy dense matrix with the given shape."""
-+    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-+    if fortran:
-+        out = np.asfortranarray(out)
-+    return out
-+
-+
-+def random_csr(shape, density, sorted_):
-+    """
-+    Generate a random qutip CSR matrix with the given shape, nnz density, and
-+    with indices that are either sorted or unsorted.  The nnz elements will
-+    always be at least one (use data.csr.zeros otherwise).
-+    """
-+    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
-+
-+
-+def random_dense(shape, fortran):
-+    """Generate a random qutip Dense matrix of the given shape."""
-+    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
-diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
-index a7be4e6d..77cf03cc 100644
---- a/qutip/tests/core/data/test_convert.py
-+++ b/qutip/tests/core/data/test_convert.py
-@@ -1,78 +1,78 @@
--import numpy as np
--import pytest
--from scipy import sparse
--from qutip import data
--
--
--def test_init_empty_data():
--    shape = (3, 3)
--    base_data = data.Data(shape)
--    assert base_data.shape[0] == shape[0]
--    assert base_data.shape[1] == shape[1]
--
--
--@pytest.mark.parametrize(['base', 'dtype'], [
--    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
--    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
--    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
--                 id='array'),
--    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
--                 id='sparse'),
--    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
--    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
--                 id='sparse'),
--])
--def test_create(base, dtype):
--    # The test of exactitude is done in test_csr, test_dense.
--    created = data.create(base)
--    assert isinstance(created, dtype)
--
--
--@pytest.mark.parametrize(['from_', 'base'], [
--    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
--    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
--    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
--    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
--    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
--    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
--])
--@pytest.mark.parametrize(['to_', 'dtype'], [
--    pytest.param('dense', data.Dense, id='to Dense str'),
--    pytest.param('Dense', data.Dense, id='to Dense STR'),
--    pytest.param(data.Dense, data.Dense, id='to Dense type'),
--    pytest.param('csr', data.CSR, id='to CSR str'),
--    pytest.param('CSR', data.CSR, id='to CSR STR'),
--    pytest.param(data.CSR, data.CSR, id='to CSR type'),
--])
--def test_converters(from_, base, to_, dtype):
--    converter = data.to[to_, from_]
--    assert isinstance(converter(base), dtype)
--    converter = data.to[to_]
--    assert isinstance(converter(base), dtype)
--    assert isinstance(data.to(to_, base), dtype)
--
--
--dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
--dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
--@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
--                         ids=[str(dtype) for dtype in dtype_names])
--def test_parse_error(input, type_):
--    assert data.to.parse(input) is type_
--
--
--@pytest.mark.parametrize(['input', 'error', 'msg'], [
--    pytest.param(5, TypeError,
--                  "Invalid dtype is neither a type nor a type name: 5",
--                 id="wrong type"),
--    pytest.param("__this_is_not_a_known_type_name__", ValueError,
--                  "Type name is not known to the data-layer: "
--                  "'__this_is_not_a_known_type_name__'",
--                 id="not alias"),
--    pytest.param(object, ValueError,
--                  "Type is not a data-layer type: <class 'object'>",
--                 id="not Data"),
--])
--def test_parse_error(input, error, msg):
--    with pytest.raises(error) as exc:
--        data.to.parse(input)
--    assert str(exc.value) == msg
-+import numpy as np
-+import pytest
-+from scipy import sparse
-+from qutip import data
-+
-+
-+def test_init_empty_data():
-+    shape = (3, 3)
-+    base_data = data.Data(shape)
-+    assert base_data.shape[0] == shape[0]
-+    assert base_data.shape[1] == shape[1]
-+
-+
-+@pytest.mark.parametrize(['base', 'dtype'], [
-+    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
-+    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
-+    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
-+                 id='array'),
-+    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
-+                 id='sparse'),
-+    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
-+    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
-+                 id='sparse'),
-+])
-+def test_create(base, dtype):
-+    # The test of exactitude is done in test_csr, test_dense.
-+    created = data.create(base)
-+    assert isinstance(created, dtype)
-+
-+
-+@pytest.mark.parametrize(['from_', 'base'], [
-+    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
-+    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
-+    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
-+    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
-+    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
-+    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
-+])
-+@pytest.mark.parametrize(['to_', 'dtype'], [
-+    pytest.param('dense', data.Dense, id='to Dense str'),
-+    pytest.param('Dense', data.Dense, id='to Dense STR'),
-+    pytest.param(data.Dense, data.Dense, id='to Dense type'),
-+    pytest.param('csr', data.CSR, id='to CSR str'),
-+    pytest.param('CSR', data.CSR, id='to CSR STR'),
-+    pytest.param(data.CSR, data.CSR, id='to CSR type'),
-+])
-+def test_converters(from_, base, to_, dtype):
-+    converter = data.to[to_, from_]
-+    assert isinstance(converter(base), dtype)
-+    converter = data.to[to_]
-+    assert isinstance(converter(base), dtype)
-+    assert isinstance(data.to(to_, base), dtype)
-+
-+
-+dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
-+dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
-+@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
-+                         ids=[str(dtype) for dtype in dtype_names])
-+def test_parse_error(input, type_):
-+    assert data.to.parse(input) is type_
-+
-+
-+@pytest.mark.parametrize(['input', 'error', 'msg'], [
-+    pytest.param(5, TypeError,
-+                  "Invalid dtype is neither a type nor a type name: 5",
-+                 id="wrong type"),
-+    pytest.param("__this_is_not_a_known_type_name__", ValueError,
-+                  "Type name is not known to the data-layer: "
-+                  "'__this_is_not_a_known_type_name__'",
-+                 id="not alias"),
-+    pytest.param(object, ValueError,
-+                  "Type is not a data-layer type: <class 'object'>",
-+                 id="not Data"),
-+])
-+def test_parse_error(input, error, msg):
-+    with pytest.raises(error) as exc:
-+        data.to.parse(input)
-+    assert str(exc.value) == msg
-diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
-index 834c9feb..853c7622 100644
---- a/qutip/tests/core/data/test_csr.py
-+++ b/qutip/tests/core/data/test_csr.py
-@@ -1,454 +1,454 @@
--import numpy as np
--import scipy.sparse
--import pytest
--
--from qutip.core import data
--from qutip.core.data import csr
--from qutip import qeye, CoreOptions
--
--from . import conftest
--
--# We only choose a small subset of dtypes to test so it isn't crazy.
--_dtype_complex = ['complex128']
--_dtype_float = ['float64']
--_dtype_int = ['int32', 'int64']
--_dtype_uint = ['uint32']
--
--
--# Set up some fixtures for automatic parametrisation.
--
--@pytest.fixture(params=[
--    pytest.param((1, 5), id='bra'),
--    pytest.param((5, 1), id='ket'),
--    pytest.param((5, 5), id='square'),
--    pytest.param((2, 4), id='wide'),
--    pytest.param((4, 2), id='tall'),
--])
--def shape(request): return request.param
--
--
--@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
--def density(request): return request.param
--
--
--@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
--def sorted_(request): return request.param
--
--
--def _valid_scipy():
--    """Arbitrary valid scipy CSR"""
--    return conftest.random_scipy_csr((10, 10), 0.5, True)
--
--
--def _valid_arg():
--    """
--    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
--    """
--    sci = _valid_scipy()
--    return (sci.data, sci.indices, sci.indptr)
--
--
--@pytest.fixture(scope='function')
--def scipy_csr(shape, density, sorted_):
--    return conftest.random_scipy_csr(shape, density, sorted_)
--
--
--@pytest.fixture(scope='function')
--def data_csr(shape, density, sorted_):
--    return conftest.random_csr(shape, density, sorted_)
--
--
--class TestClassMethods:
--    def test_init_from_tuple(self, scipy_csr):
--        """
--        Test that __init__ does not throw when passed a 3-tuple.  Also tests
--        the as_scipy() method succeeds.
--        """
--        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
--        out = data.CSR(arg, shape=scipy_csr.shape)
--        assert out.shape == scipy_csr.shape
--        assert (out.as_scipy() - scipy_csr).nnz == 0
--
--    @pytest.mark.parametrize('d_type', (
--        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
--    ))
--    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
--    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
--    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
--        """
--        Test that initialisation can use a variety of dtypes and converts into
--        the correct type.
--        """
--        sci = _valid_scipy()
--        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
--        col_index = sci.indices.astype(c_type, casting='unsafe')
--        row_index = sci.indptr.astype(r_type, casting='unsafe')
--        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
--                                            shape=sci.shape)
--        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
--        out_scipy = out.as_scipy()
--        assert out.shape == scipy_csr.shape
--        assert out_scipy.data.dtype == np.complex128
--        assert (out_scipy - scipy_csr).nnz == 0
--
--    def test_init_from_scipy(self, scipy_csr):
--        """Test that __init__ can accept a scipy CSR matrix."""
--        out = data.CSR(scipy_csr)
--        assert out.shape == scipy_csr.shape
--        assert (out.as_scipy() - scipy_csr).nnz == 0
--
--    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
--        pytest.param((), {}, ValueError, id="arg 0 tuple"),
--        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
--        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
--        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
--        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
--        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
--                     id="scipy-shape 0 tuple"),
--        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
--                     id="scipy-shape 1 tuple"),
--        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
--                     id="scipy-shape None tuple"),
--        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
--                     id="scipy-shape list"),
--        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
--                     id="scipy-shape 3 tuple"),
--        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
--                     id="arg-shape 0 tuple"),
--        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
--                     id="arg-shape 1 tuple"),
--        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
--                     id="arg-shape None tuple"),
--        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
--                     id="arg-shape list"),
--        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
--                     id="arg-shape 3 tuple"),
--        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
--                     id="arg-negative shape"),
--    ])
--    def test_init_from_wrong_input(self, arg, kwargs, error):
--        """
--        Test that the __init__ method raises a suitable error when passed
--        incorrectly formatted inputs.
--
--        This test also serves as a *partial* check that CSR safely handles
--        deallocation in the presence of exceptions in its __init__ method.  If
--        the tests segfault, it's quite likely that the memory management isn't
--        being done correctly in the hand-off us setting our data buffers up and
--        marking the numpy actually owns the data.
--        """
--        with pytest.raises(error):
--            data.CSR(arg, **kwargs)
--
--    def test_copy_returns_a_correct_copy(self, data_csr):
--        """
--        Test that the copy() method produces an actual copy, and that the
--        result represents the same matrix.
--        """
--        original = data_csr
--        copy = data_csr.copy()
--        assert original is not copy
--        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
--
--    def test_as_scipy_returns_a_view(self, data_csr):
--        """
--        Test that modifying the views in the result of as_scipy() also modifies
--        the underlying data structures.  This is important for allowing minor
--        data modifications from within Python-space.
--        """
--        unmodified_copy = data_csr.copy()
--        data_csr.as_scipy().data[0] += 1
--        modified_copy = data_csr.copy()
--        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
--        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
--
--    def test_as_scipy_caches_result(self, data_csr):
--        """
--        Test that the as_scipy() method always returns the same view, even if
--        called multiple times.
--        """
--        assert data_csr.as_scipy() is data_csr.as_scipy()
--
--    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
--        """
--        Test that we produce a new scipy matrix, regardless of how we have
--        initialised the type.
--        """
--        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
--
--    def test_as_scipy_of_copy_is_different(self, data_csr):
--        """
--        Test that as_scipy() does not return the same array, or the same views
--        if it's not the same input matrix.  We don't want two CSR matrices to
--        be linked.
--        """
--        original = data_csr.as_scipy()
--        copy = data_csr.copy().as_scipy()
--        assert original is not copy
--        assert not np.may_share_memory(original.data, copy.data)
--        assert not np.may_share_memory(original.indices, copy.indices)
--        assert not np.may_share_memory(original.indptr, copy.indptr)
--
--    def test_as_scipy_is_correct_result(self, scipy_csr):
--        """
--        Test that as_scipy is actually giving the matrix we expect for a given
--        input.
--        """
--        data_csr = data.CSR(scipy_csr)
--        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
--        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
--
--    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
--        nnz = int(shape[0] * shape[1] * density) or 1
--        base = csr.empty(shape[0], shape[1], nnz)
--        sci = base.as_scipy()
--        assert sci.nnz == 0
--        assert len(sci.data) == 0
--        assert len(sci.indices) == 0
--
--    def test_to_array_is_correct_result(self, data_csr):
--        test_array = data_csr.to_array()
--        assert isinstance(test_array, np.ndarray)
--        # It's not enough to be accurate within a tolerance here - there's no
--        # mathematics, so they should be _identical_.
--        assert np.all(test_array == data_csr.as_scipy().toarray())
--
--    def test_sorted_indices(self, data_csr):
--        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
--        # per row), so we add in this additional assertion message just to help
--        # out.
--        message = (
--            "Sort on {}sorted indices failed."
--            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
--        )
--        # We test on a copy because scipy attempts to cache
--        # `has_sorted_indices`, but since it's a view, it has no idea what
--        # we've done to the indices behind the scenes and typically would not
--        # notice the change.  The copy will return a difference scipy matrix,
--        # so the cache will not be built.
--        copy = data_csr.copy()
--        copy.sort_indices()
--        assert copy.as_scipy().has_sorted_indices, message
--
--
--class TestFactoryMethods:
--    def test_empty(self, shape, density):
--        nnz = int(shape[0] * shape[1] * density) or 1
--        base = csr.empty(shape[0], shape[1], nnz)
--        sci = base.as_scipy(full=True)
--        assert isinstance(base, data.CSR)
--        assert isinstance(sci, scipy.sparse.csr_matrix)
--        assert base.shape == shape
--        assert sci.data.shape == (nnz,)
--        assert sci.indices.shape == (nnz,)
--        assert sci.indptr.shape == (shape[0] + 1,)
--
--    def test_zeros(self, shape):
--        base = csr.zeros(shape[0], shape[1])
--        sci = base.as_scipy()
--        assert isinstance(base, data.CSR)
--        assert base.shape == shape
--        assert sci.nnz == 0
--        assert sci.indptr.shape == (shape[0] + 1,)
--
--    @pytest.mark.parametrize('dimension', [1, 5, 100])
--    @pytest.mark.parametrize(
--        'scale',
--        [None, 2, -0.1, 1.5, 1.5+1j],
--        ids=['none', 'int', 'negative', 'float', 'complex']
--    )
--    def test_identity(self, dimension, scale):
--        # scale=None is testing that the default value returns the identity.
--        base = (csr.identity(dimension) if scale is None
--                else csr.identity(dimension, scale))
--        sci = base.as_scipy()
--        scipy_test = scipy.sparse.eye(dimension,
--                                      dtype=np.complex128, format='csr')
--        if scale is not None:
--            scipy_test *= scale
--        assert isinstance(base, data.CSR)
--        assert base.shape == (dimension, dimension)
--        assert sci.nnz == dimension
--        assert (sci - scipy_test).nnz == 0
--
--    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
--        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
--        pytest.param([1], None, None, id='1x1'),
--        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
--        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
--        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
--        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
--                     id='two diagonals'),
--        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
--        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
--        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
--        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
--                     id='two wide super'),
--        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
--        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
--                     id='two tall sub'),
--        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
--                     id='out of order'),
--        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
--                     id='sum duplicates'),
--    ])
--    def test_diags(self, diagonals, offsets, shape):
--        base = csr.diags(diagonals, offsets, shape)
--        # Build numpy version test.
--        if not isinstance(diagonals[0], list):
--            diagonals = [diagonals]
--        offsets = np.atleast_1d(offsets if offsets is not None else [0])
--        if shape is None:
--            size = len(diagonals[0]) + abs(offsets[0])
--            shape = (size, size)
--        test = np.zeros(shape, dtype=np.complex128)
--        for diagonal, offset in zip(diagonals, offsets):
--            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
--        assert isinstance(base, data.CSR)
--        assert base.shape == shape
--        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
--
--    @pytest.mark.parametrize(['shape', 'position', 'value'], [
--        pytest.param((1, 1), (0, 0), None, id='minimal'),
--        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
--        pytest.param((10, 10), (1, 5), 1., id='upper'),
--        pytest.param((10, 10), (5, 1), 2., id='lower'),
--        pytest.param((10, 1), (5, 0), None, id='column'),
--        pytest.param((1, 10), (0, 5), -5j, id='row'),
--        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
--        pytest.param((2, 10), (1, 5), 10, id='wide'),
--    ])
--    def test_one_element(self, shape, position, value):
--        test = np.zeros(shape, dtype=np.complex128)
--        if value is None:
--            base = data.one_element_csr(shape, position)
--            test[position] = 1.0+0.0j
--        else:
--            base = data.one_element_csr(shape, position, value)
--            test[position] = value
--        assert isinstance(base, data.CSR)
--        assert base.shape == shape
--        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
--
--    @pytest.mark.parametrize(['shape', 'position', 'value'], [
--        pytest.param((0, 0), (0, 0), None, id='zero shape'),
--        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
--        pytest.param((10, 10), (10, 5), 1., id='outside'),
--        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
--    ])
--    def test_one_element_error(self, shape, position, value):
--        with pytest.raises(ValueError) as exc:
--            base = data.one_element_csr(shape, position, value)
--        assert str(exc.value).startswith("Position of the elements"
--                                         " out of bound: ")
--
--
--class TestFromCSRBlocks:
--    class _blocks:
--        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
--            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
--            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
--            if isinstance(ops, int):
--                ops = [csr.zeros(block_size, block_size)] * ops
--            self.ops = np.array(ops, dtype=object)
--            self.n_blocks = n_blocks
--            self.block_size = block_size
--
--        def from_csr_blocks(self):
--            return csr._from_csr_blocks(
--                self.rows, self.cols, self.ops,
--                self.n_blocks, self.block_size,
--            )
--
--    @pytest.mark.parametrize(['blocks'], [
--        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
--        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
--    ])
--    def test_input_length_error(self, blocks):
--        with pytest.raises(ValueError) as exc:
--            blocks.from_csr_blocks()
--        assert str(exc.value) == (
--            "The arrays block_rows, block_cols and block_ops should have"
--            " the same length."
--        )
--
--    def test_op_shape_error(self):
--        blocks = self._blocks(
--            (0, 1), (0, 1),
--            (csr.zeros(2, 2), csr.zeros(3, 3)),
--        )
--        with pytest.raises(ValueError) as exc:
--            blocks.from_csr_blocks()
--        assert str(exc.value) == (
--            "Block operators (block_ops) do not have the correct shape."
--        )
--
--    @pytest.mark.parametrize(['blocks'], [
--        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
--        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
--        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
--    ])
--    def test_op_ordering_error(self, blocks):
--        with pytest.raises(ValueError) as exc:
--            blocks.from_csr_blocks()
--        assert str(exc.value) == (
--            "The arrays block_rows and block_cols must be sorted"
--            " by (row, column)."
--        )
--
--    @pytest.mark.parametrize(['blocks'], [
--        pytest.param(_blocks((), (), ()), id='no ops'),
--        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
--    ])
--    def test_zeros_output_fast_paths(self, blocks):
--        out = blocks.from_csr_blocks()
--        assert out == csr.zeros(2 * 2, 2 * 2)
--        assert csr.nnz(out) == 0
--
--    def test_construct_identity_with_empty(self):
--        # users are not expected to be exposed to
--        # csr.empty directly, but it is good to
--        # avoid segfaults, so we test passing
--        # csr.empty(..) blocks here explicitly
--        blocks = self._blocks(
--            [0, 0, 1, 1], [0, 1, 0, 1], [
--                csr.identity(2), csr.empty(2, 2, 0),
--                csr.empty(2, 2, 0), csr.identity(2),
--            ],
--        )
--        out = blocks.from_csr_blocks()
--        assert out == csr.identity(4)
--        assert csr.nnz(out) == 4
--
--    def test_construct_identity_with_zeros(self):
--        blocks = self._blocks(
--            [0, 0, 1, 1], [0, 1, 0, 1], [
--                csr.identity(2), csr.zeros(2, 2),
--                csr.zeros(2, 2), csr.identity(2),
--            ],
--        )
--        out = blocks.from_csr_blocks()
--        assert out == csr.identity(4)
--        assert csr.nnz(out) == 4
--
--    def test_construct_kron(self):
--        A = np.array([[1, 2], [3, 4]])
--        B = np.array([[0.3, 0.35], [0.4, 0.45]])
--        B_op = data.to("csr", data.Dense(B))
--        blocks = self._blocks(
--            [0, 0, 1, 1], [0, 1, 0, 1], [
--                A[0, 0] * B_op, A[0, 1] * B_op,
--                A[1, 0] * B_op, A[1, 1] * B_op,
--            ]
--        )
--        out = blocks.from_csr_blocks()
--        assert out == data.kron(data.Dense(A), data.Dense(B))
--        assert csr.nnz(out) == 16
--
--
--def test_tidyup():
--    small = qeye(1) * 1e-5
--    with CoreOptions(auto_tidyup_atol=1e-3):
--        assert (small + small).tr() == 0
--    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
--        assert (small + small).tr() == 2e-5
-+import numpy as np
-+import scipy.sparse
-+import pytest
-+
-+from qutip.core import data
-+from qutip.core.data import csr
-+from qutip import qeye, CoreOptions
-+
-+from . import conftest
-+
-+# We only choose a small subset of dtypes to test so it isn't crazy.
-+_dtype_complex = ['complex128']
-+_dtype_float = ['float64']
-+_dtype_int = ['int32', 'int64']
-+_dtype_uint = ['uint32']
-+
-+
-+# Set up some fixtures for automatic parametrisation.
-+
-+@pytest.fixture(params=[
-+    pytest.param((1, 5), id='bra'),
-+    pytest.param((5, 1), id='ket'),
-+    pytest.param((5, 5), id='square'),
-+    pytest.param((2, 4), id='wide'),
-+    pytest.param((4, 2), id='tall'),
-+])
-+def shape(request): return request.param
-+
-+
-+@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
-+def density(request): return request.param
-+
-+
-+@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
-+def sorted_(request): return request.param
-+
-+
-+def _valid_scipy():
-+    """Arbitrary valid scipy CSR"""
-+    return conftest.random_scipy_csr((10, 10), 0.5, True)
-+
-+
-+def _valid_arg():
-+    """
-+    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
-+    """
-+    sci = _valid_scipy()
-+    return (sci.data, sci.indices, sci.indptr)
-+
-+
-+@pytest.fixture(scope='function')
-+def scipy_csr(shape, density, sorted_):
-+    return conftest.random_scipy_csr(shape, density, sorted_)
-+
-+
-+@pytest.fixture(scope='function')
-+def data_csr(shape, density, sorted_):
-+    return conftest.random_csr(shape, density, sorted_)
-+
-+
-+class TestClassMethods:
-+    def test_init_from_tuple(self, scipy_csr):
-+        """
-+        Test that __init__ does not throw when passed a 3-tuple.  Also tests
-+        the as_scipy() method succeeds.
-+        """
-+        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
-+        out = data.CSR(arg, shape=scipy_csr.shape)
-+        assert out.shape == scipy_csr.shape
-+        assert (out.as_scipy() - scipy_csr).nnz == 0
-+
-+    @pytest.mark.parametrize('d_type', (
-+        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
-+    ))
-+    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
-+    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
-+    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
-+        """
-+        Test that initialisation can use a variety of dtypes and converts into
-+        the correct type.
-+        """
-+        sci = _valid_scipy()
-+        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
-+        col_index = sci.indices.astype(c_type, casting='unsafe')
-+        row_index = sci.indptr.astype(r_type, casting='unsafe')
-+        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
-+                                            shape=sci.shape)
-+        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
-+        out_scipy = out.as_scipy()
-+        assert out.shape == scipy_csr.shape
-+        assert out_scipy.data.dtype == np.complex128
-+        assert (out_scipy - scipy_csr).nnz == 0
-+
-+    def test_init_from_scipy(self, scipy_csr):
-+        """Test that __init__ can accept a scipy CSR matrix."""
-+        out = data.CSR(scipy_csr)
-+        assert out.shape == scipy_csr.shape
-+        assert (out.as_scipy() - scipy_csr).nnz == 0
-+
-+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
-+        pytest.param((), {}, ValueError, id="arg 0 tuple"),
-+        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
-+        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
-+        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
-+        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
-+        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
-+                     id="scipy-shape 0 tuple"),
-+        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
-+                     id="scipy-shape 1 tuple"),
-+        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
-+                     id="scipy-shape None tuple"),
-+        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
-+                     id="scipy-shape list"),
-+        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
-+                     id="scipy-shape 3 tuple"),
-+        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
-+                     id="arg-shape 0 tuple"),
-+        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
-+                     id="arg-shape 1 tuple"),
-+        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
-+                     id="arg-shape None tuple"),
-+        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
-+                     id="arg-shape list"),
-+        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
-+                     id="arg-shape 3 tuple"),
-+        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
-+                     id="arg-negative shape"),
-+    ])
-+    def test_init_from_wrong_input(self, arg, kwargs, error):
-+        """
-+        Test that the __init__ method raises a suitable error when passed
-+        incorrectly formatted inputs.
-+
-+        This test also serves as a *partial* check that CSR safely handles
-+        deallocation in the presence of exceptions in its __init__ method.  If
-+        the tests segfault, it's quite likely that the memory management isn't
-+        being done correctly in the hand-off us setting our data buffers up and
-+        marking the numpy actually owns the data.
-+        """
-+        with pytest.raises(error):
-+            data.CSR(arg, **kwargs)
-+
-+    def test_copy_returns_a_correct_copy(self, data_csr):
-+        """
-+        Test that the copy() method produces an actual copy, and that the
-+        result represents the same matrix.
-+        """
-+        original = data_csr
-+        copy = data_csr.copy()
-+        assert original is not copy
-+        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
-+
-+    def test_as_scipy_returns_a_view(self, data_csr):
-+        """
-+        Test that modifying the views in the result of as_scipy() also modifies
-+        the underlying data structures.  This is important for allowing minor
-+        data modifications from within Python-space.
-+        """
-+        unmodified_copy = data_csr.copy()
-+        data_csr.as_scipy().data[0] += 1
-+        modified_copy = data_csr.copy()
-+        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
-+        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
-+
-+    def test_as_scipy_caches_result(self, data_csr):
-+        """
-+        Test that the as_scipy() method always returns the same view, even if
-+        called multiple times.
-+        """
-+        assert data_csr.as_scipy() is data_csr.as_scipy()
-+
-+    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
-+        """
-+        Test that we produce a new scipy matrix, regardless of how we have
-+        initialised the type.
-+        """
-+        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
-+
-+    def test_as_scipy_of_copy_is_different(self, data_csr):
-+        """
-+        Test that as_scipy() does not return the same array, or the same views
-+        if it's not the same input matrix.  We don't want two CSR matrices to
-+        be linked.
-+        """
-+        original = data_csr.as_scipy()
-+        copy = data_csr.copy().as_scipy()
-+        assert original is not copy
-+        assert not np.may_share_memory(original.data, copy.data)
-+        assert not np.may_share_memory(original.indices, copy.indices)
-+        assert not np.may_share_memory(original.indptr, copy.indptr)
-+
-+    def test_as_scipy_is_correct_result(self, scipy_csr):
-+        """
-+        Test that as_scipy is actually giving the matrix we expect for a given
-+        input.
-+        """
-+        data_csr = data.CSR(scipy_csr)
-+        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
-+        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
-+
-+    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
-+        nnz = int(shape[0] * shape[1] * density) or 1
-+        base = csr.empty(shape[0], shape[1], nnz)
-+        sci = base.as_scipy()
-+        assert sci.nnz == 0
-+        assert len(sci.data) == 0
-+        assert len(sci.indices) == 0
-+
-+    def test_to_array_is_correct_result(self, data_csr):
-+        test_array = data_csr.to_array()
-+        assert isinstance(test_array, np.ndarray)
-+        # It's not enough to be accurate within a tolerance here - there's no
-+        # mathematics, so they should be _identical_.
-+        assert np.all(test_array == data_csr.as_scipy().toarray())
-+
-+    def test_sorted_indices(self, data_csr):
-+        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
-+        # per row), so we add in this additional assertion message just to help
-+        # out.
-+        message = (
-+            "Sort on {}sorted indices failed."
-+            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
-+        )
-+        # We test on a copy because scipy attempts to cache
-+        # `has_sorted_indices`, but since it's a view, it has no idea what
-+        # we've done to the indices behind the scenes and typically would not
-+        # notice the change.  The copy will return a difference scipy matrix,
-+        # so the cache will not be built.
-+        copy = data_csr.copy()
-+        copy.sort_indices()
-+        assert copy.as_scipy().has_sorted_indices, message
-+
-+
-+class TestFactoryMethods:
-+    def test_empty(self, shape, density):
-+        nnz = int(shape[0] * shape[1] * density) or 1
-+        base = csr.empty(shape[0], shape[1], nnz)
-+        sci = base.as_scipy(full=True)
-+        assert isinstance(base, data.CSR)
-+        assert isinstance(sci, scipy.sparse.csr_matrix)
-+        assert base.shape == shape
-+        assert sci.data.shape == (nnz,)
-+        assert sci.indices.shape == (nnz,)
-+        assert sci.indptr.shape == (shape[0] + 1,)
-+
-+    def test_zeros(self, shape):
-+        base = csr.zeros(shape[0], shape[1])
-+        sci = base.as_scipy()
-+        assert isinstance(base, data.CSR)
-+        assert base.shape == shape
-+        assert sci.nnz == 0
-+        assert sci.indptr.shape == (shape[0] + 1,)
-+
-+    @pytest.mark.parametrize('dimension', [1, 5, 100])
-+    @pytest.mark.parametrize(
-+        'scale',
-+        [None, 2, -0.1, 1.5, 1.5+1j],
-+        ids=['none', 'int', 'negative', 'float', 'complex']
-+    )
-+    def test_identity(self, dimension, scale):
-+        # scale=None is testing that the default value returns the identity.
-+        base = (csr.identity(dimension) if scale is None
-+                else csr.identity(dimension, scale))
-+        sci = base.as_scipy()
-+        scipy_test = scipy.sparse.eye(dimension,
-+                                      dtype=np.complex128, format='csr')
-+        if scale is not None:
-+            scipy_test *= scale
-+        assert isinstance(base, data.CSR)
-+        assert base.shape == (dimension, dimension)
-+        assert sci.nnz == dimension
-+        assert (sci - scipy_test).nnz == 0
-+
-+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
-+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
-+        pytest.param([1], None, None, id='1x1'),
-+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
-+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
-+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
-+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
-+                     id='two diagonals'),
-+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
-+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
-+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
-+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
-+                     id='two wide super'),
-+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
-+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
-+                     id='two tall sub'),
-+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
-+                     id='out of order'),
-+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
-+                     id='sum duplicates'),
-+    ])
-+    def test_diags(self, diagonals, offsets, shape):
-+        base = csr.diags(diagonals, offsets, shape)
-+        # Build numpy version test.
-+        if not isinstance(diagonals[0], list):
-+            diagonals = [diagonals]
-+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
-+        if shape is None:
-+            size = len(diagonals[0]) + abs(offsets[0])
-+            shape = (size, size)
-+        test = np.zeros(shape, dtype=np.complex128)
-+        for diagonal, offset in zip(diagonals, offsets):
-+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-+        assert isinstance(base, data.CSR)
-+        assert base.shape == shape
-+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
-+
-+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-+        pytest.param((1, 1), (0, 0), None, id='minimal'),
-+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
-+        pytest.param((10, 10), (1, 5), 1., id='upper'),
-+        pytest.param((10, 10), (5, 1), 2., id='lower'),
-+        pytest.param((10, 1), (5, 0), None, id='column'),
-+        pytest.param((1, 10), (0, 5), -5j, id='row'),
-+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
-+        pytest.param((2, 10), (1, 5), 10, id='wide'),
-+    ])
-+    def test_one_element(self, shape, position, value):
-+        test = np.zeros(shape, dtype=np.complex128)
-+        if value is None:
-+            base = data.one_element_csr(shape, position)
-+            test[position] = 1.0+0.0j
-+        else:
-+            base = data.one_element_csr(shape, position, value)
-+            test[position] = value
-+        assert isinstance(base, data.CSR)
-+        assert base.shape == shape
-+        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
-+
-+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
-+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
-+        pytest.param((10, 10), (10, 5), 1., id='outside'),
-+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
-+    ])
-+    def test_one_element_error(self, shape, position, value):
-+        with pytest.raises(ValueError) as exc:
-+            base = data.one_element_csr(shape, position, value)
-+        assert str(exc.value).startswith("Position of the elements"
-+                                         " out of bound: ")
-+
-+
-+class TestFromCSRBlocks:
-+    class _blocks:
-+        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
-+            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
-+            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
-+            if isinstance(ops, int):
-+                ops = [csr.zeros(block_size, block_size)] * ops
-+            self.ops = np.array(ops, dtype=object)
-+            self.n_blocks = n_blocks
-+            self.block_size = block_size
-+
-+        def from_csr_blocks(self):
-+            return csr._from_csr_blocks(
-+                self.rows, self.cols, self.ops,
-+                self.n_blocks, self.block_size,
-+            )
-+
-+    @pytest.mark.parametrize(['blocks'], [
-+        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
-+        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
-+    ])
-+    def test_input_length_error(self, blocks):
-+        with pytest.raises(ValueError) as exc:
-+            blocks.from_csr_blocks()
-+        assert str(exc.value) == (
-+            "The arrays block_rows, block_cols and block_ops should have"
-+            " the same length."
-+        )
-+
-+    def test_op_shape_error(self):
-+        blocks = self._blocks(
-+            (0, 1), (0, 1),
-+            (csr.zeros(2, 2), csr.zeros(3, 3)),
-+        )
-+        with pytest.raises(ValueError) as exc:
-+            blocks.from_csr_blocks()
-+        assert str(exc.value) == (
-+            "Block operators (block_ops) do not have the correct shape."
-+        )
-+
-+    @pytest.mark.parametrize(['blocks'], [
-+        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
-+        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
-+        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
-+    ])
-+    def test_op_ordering_error(self, blocks):
-+        with pytest.raises(ValueError) as exc:
-+            blocks.from_csr_blocks()
-+        assert str(exc.value) == (
-+            "The arrays block_rows and block_cols must be sorted"
-+            " by (row, column)."
-+        )
-+
-+    @pytest.mark.parametrize(['blocks'], [
-+        pytest.param(_blocks((), (), ()), id='no ops'),
-+        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
-+    ])
-+    def test_zeros_output_fast_paths(self, blocks):
-+        out = blocks.from_csr_blocks()
-+        assert out == csr.zeros(2 * 2, 2 * 2)
-+        assert csr.nnz(out) == 0
-+
-+    def test_construct_identity_with_empty(self):
-+        # users are not expected to be exposed to
-+        # csr.empty directly, but it is good to
-+        # avoid segfaults, so we test passing
-+        # csr.empty(..) blocks here explicitly
-+        blocks = self._blocks(
-+            [0, 0, 1, 1], [0, 1, 0, 1], [
-+                csr.identity(2), csr.empty(2, 2, 0),
-+                csr.empty(2, 2, 0), csr.identity(2),
-+            ],
-+        )
-+        out = blocks.from_csr_blocks()
-+        assert out == csr.identity(4)
-+        assert csr.nnz(out) == 4
-+
-+    def test_construct_identity_with_zeros(self):
-+        blocks = self._blocks(
-+            [0, 0, 1, 1], [0, 1, 0, 1], [
-+                csr.identity(2), csr.zeros(2, 2),
-+                csr.zeros(2, 2), csr.identity(2),
-+            ],
-+        )
-+        out = blocks.from_csr_blocks()
-+        assert out == csr.identity(4)
-+        assert csr.nnz(out) == 4
-+
-+    def test_construct_kron(self):
-+        A = np.array([[1, 2], [3, 4]])
-+        B = np.array([[0.3, 0.35], [0.4, 0.45]])
-+        B_op = data.to("csr", data.Dense(B))
-+        blocks = self._blocks(
-+            [0, 0, 1, 1], [0, 1, 0, 1], [
-+                A[0, 0] * B_op, A[0, 1] * B_op,
-+                A[1, 0] * B_op, A[1, 1] * B_op,
-+            ]
-+        )
-+        out = blocks.from_csr_blocks()
-+        assert out == data.kron(data.Dense(A), data.Dense(B))
-+        assert csr.nnz(out) == 16
-+
-+
-+def test_tidyup():
-+    small = qeye(1) * 1e-5
-+    with CoreOptions(auto_tidyup_atol=1e-3):
-+        assert (small + small).tr() == 0
-+    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
-+        assert (small + small).tr() == 2e-5
-diff --git a/qutip/tests/core/data/test_dense.py b/qutip/tests/core/data/test_dense.py
-index 07290811..198ecf98 100644
---- a/qutip/tests/core/data/test_dense.py
-+++ b/qutip/tests/core/data/test_dense.py
-@@ -1,297 +1,297 @@
--import numpy as np
--import pytest
--
--from qutip.core import data
--from qutip.core.data import dense, csr
--
--from . import conftest
--
--
--# Set up some fixtures for automatic parametrisation.
--
--@pytest.fixture(params=[
--    pytest.param((1, 5), id='ket'),
--    pytest.param((5, 1), id='bra'),
--    pytest.param((5, 5), id='square'),
--    pytest.param((2, 4), id='wide'),
--    pytest.param((4, 2), id='tall'),
--])
--def shape(request): return request.param
--
--
--@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
--def fortran(request): return request.param
--
--
--def _valid_numpy():
--    # Arbitrary valid numpy array.
--    return conftest.random_numpy_dense((5, 5), False)
--
--
--@pytest.fixture(scope='function')
--def numpy_dense(shape, fortran):
--    return conftest.random_numpy_dense(shape, fortran)
--
--
--@pytest.fixture(scope='function')
--def data_dense(shape, fortran):
--    return conftest.random_dense(shape, fortran)
--
--
--class TestClassMethods:
--    def test_init_from_ndarray(self, numpy_dense):
--        test = data.Dense(numpy_dense)
--        assert test.shape == numpy_dense.shape
--        assert np.all(test.as_ndarray() == numpy_dense)
--
--    @pytest.mark.parametrize('dtype', ['complex128',
--                                       'float64',
--                                       'int32', 'int64',
--                                       'uint32'])
--    def test_init_from_ndarray_other_dtype(self, shape, dtype):
--        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
--        test = data.Dense(numpy_dense)
--        assert test.shape == shape
--        assert test.as_ndarray().dtype == np.complex128
--        assert np.all(test.as_ndarray() == numpy_dense)
--
--    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
--        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
--                     id="numpy-shape 0 tuple"),
--        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
--                     id="numpy-shape 1 tuple"),
--        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
--                     id="numpy-shape None tuple"),
--        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
--                     id="numpy-shape list"),
--        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
--                     id="numpy-shape 3 tuple"),
--        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
--                     id="numpy-negative shape"),
--        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
--                     id="numpy-both negative shape"),
--        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
--                     id="numpy-different shape"),
--    ])
--    def test_init_from_wrong_input(self, arg, kwargs, error):
--        """
--        Test that the __init__ method raises a suitable error when passed
--        incorrectly formatted inputs.
--
--        This test also serves as a *partial* check that Dense safely handles
--        deallocation in the presence of exceptions in its __init__ method.  If
--        the tests segfault, it's quite likely that the memory management isn't
--        being done correctly in the hand-off us setting our data buffers up and
--        marking the numpy actually owns the data.
--        """
--        with pytest.raises(error):
--            data.Dense(arg, **kwargs)
--
--    def test_copy_returns_a_correct_copy(self, data_dense):
--        """
--        Test that the copy() method produces an actual copy, and that the
--        result represents the same matrix.
--        """
--        original = data_dense
--        copy = data_dense.copy()
--        assert original is not copy
--        assert np.all(original.as_ndarray() == copy.as_ndarray())
--
--    def test_as_ndarray_returns_a_view(self, data_dense):
--        """
--        Test that modifying the views in the result of as_ndarray() also
--        modifies the underlying data structures.  This is important for
--        allowing data modification from within Python-space.
--        """
--        unmodified_copy = data_dense.copy()
--        data_dense.as_ndarray()[0, 0] += 1
--        modified_copy = data_dense.copy()
--        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
--        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
--
--    def test_as_ndarray_caches_result(self, data_dense):
--        """
--        Test that the as_ndarray() method always returns the same view, even if
--        called multiple times.
--        """
--        assert data_dense.as_ndarray() is data_dense.as_ndarray()
--
--    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
--        """
--        Test that we produce a new ndarray, regardless of how we have
--        initialised the type.
--        """
--        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
--
--    def test_as_ndarray_of_copy_is_different(self, data_dense):
--        """
--        Test that as_ndarray() does not return the same array or a view to the
--        same data, if it's not the same input matrix.  We don't want two Dense
--        matrices to be linked.
--        """
--        original = data_dense.as_ndarray()
--        copy = data_dense.copy().as_ndarray()
--        assert original is not copy
--        assert not np.may_share_memory(original, copy)
--
--    def test_as_ndarray_is_correct_result(self, numpy_dense):
--        """
--        Test that as_ndarray is actually giving the matrix we expect for a given
--        input.
--        """
--        data_dense = data.Dense(numpy_dense)
--        nd_view = data_dense.as_ndarray()
--        assert isinstance(data_dense.as_ndarray(), np.ndarray)
--        assert nd_view.ndim == 2
--        assert nd_view.shape == numpy_dense.shape
--        assert nd_view.strides == numpy_dense.strides
--        assert np.all(nd_view == numpy_dense)
--        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
--        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
--
--    def test_to_array_is_correct_result(self, data_dense):
--        test_array = data_dense.to_array()
--        nd_view = data_dense.as_ndarray()
--        assert isinstance(test_array, np.ndarray)
--        assert test_array.ndim == 2
--        assert test_array.shape == nd_view.shape
--        assert test_array.strides == nd_view.strides
--        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
--        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
--        # It's not enough to be accurate within a tolerance here - there's no
--        # mathematics, so they should be _identical_.
--        assert np.all(test_array == nd_view)
--
--    @pytest.mark.parametrize('new_fortran', [
--        pytest.param(-1, id='swap'),
--        pytest.param(False, id='C'),
--        pytest.param(True, id='Fortran'),
--    ])
--    def test_reorder(self, data_dense, new_fortran):
--        reordered = data_dense.reorder(new_fortran)
--        assert isinstance(reordered, data.Dense)
--        assert reordered.shape == data_dense.shape
--        orig = data_dense.to_array()
--        test = reordered.to_array()
--        if new_fortran == -1:
--            orig.flags.f_contiguous == test.flags.c_contiguous
--            orig.flags.c_contiguous == test.flags.f_contiguous
--        elif new_fortran is True:
--            assert test.flags.f_contiguous
--        else:
--            assert test.flags.c_contiguous
--        assert np.all(orig == test)
--
--class TestFactoryMethods:
--    def test_empty(self, shape):
--        base = dense.empty(shape[0], shape[1])
--        nd = base.as_ndarray()
--        assert isinstance(base, data.Dense)
--        assert base.shape == shape
--        assert nd.shape == shape
--
--    def test_zeros(self, shape):
--        base = dense.zeros(shape[0], shape[1])
--        nd = base.as_ndarray()
--        assert isinstance(base, data.Dense)
--        assert base.shape == shape
--        assert nd.shape == shape
--        assert np.count_nonzero(nd) == 0
--
--    @pytest.mark.parametrize('dimension', [1, 5, 100])
--    @pytest.mark.parametrize(
--        'scale',
--        [None, 2, -0.1, 1.5, 1.5+1j],
--        ids=['none', 'int', 'negative', 'float', 'complex']
--    )
--    def test_identity(self, dimension, scale):
--        # scale=None is testing that the default value returns the identity.
--        base = (dense.identity(dimension) if scale is None
--                else dense.identity(dimension, scale))
--        nd = base.as_ndarray()
--        numpy_test = np.eye(dimension, dtype=np.complex128)
--        if scale is not None:
--            numpy_test *= scale
--        assert isinstance(base, data.Dense)
--        assert base.shape == (dimension, dimension)
--        assert np.count_nonzero(nd - numpy_test) == 0
--
--    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
--        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
--        pytest.param([1], None, None, id='1x1'),
--        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
--        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
--        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
--        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
--                     id='two diagonals'),
--        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
--        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
--        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
--        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
--                     id='two wide super'),
--        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
--        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
--                     id='two tall sub'),
--        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
--                     id='out of order'),
--        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
--                     id='sum duplicates'),
--    ])
--    def test_diags(self, diagonals, offsets, shape):
--        base = dense.diags(diagonals, offsets, shape)
--        # Build numpy version test.
--        if not isinstance(diagonals[0], list):
--            diagonals = [diagonals]
--        offsets = np.atleast_1d(offsets if offsets is not None else [0])
--        if shape is None:
--            size = len(diagonals[0]) + abs(offsets[0])
--            shape = (size, size)
--        test = np.zeros(shape, dtype=np.complex128)
--        for diagonal, offset in zip(diagonals, offsets):
--            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
--        assert isinstance(base, data.Dense)
--        assert base.shape == shape
--        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
--
--    @pytest.mark.parametrize(['shape', 'position', 'value'], [
--        pytest.param((1, 1), (0, 0), None, id='minimal'),
--        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
--        pytest.param((10, 10), (1, 5), 1., id='upper'),
--        pytest.param((10, 10), (5, 1), 2., id='lower'),
--        pytest.param((10, 1), (5, 0), None, id='column'),
--        pytest.param((1, 10), (0, 5), -5.j, id='row'),
--        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
--        pytest.param((2, 10), (1, 5), 10, id='wide'),
--    ])
--    def test_one_element(self, shape, position, value):
--        test = np.zeros(shape, dtype=np.complex128)
--        if value is None:
--            base = data.one_element_dense(shape, position)
--            test[position] = 1.0+0.0j
--        else:
--            base = data.one_element_dense(shape, position, value)
--            test[position] = value
--        assert isinstance(base, data.Dense)
--        assert base.shape == shape
--        assert np.allclose(base.to_array(), test, atol=1e-10)
--
--    @pytest.mark.parametrize(['shape', 'position', 'value'], [
--        pytest.param((0, 0), (0, 0), None, id='zero shape'),
--        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
--        pytest.param((10, 10), (10, 5), 1., id='outside'),
--        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
--    ])
--    def test_one_element_error(self, shape, position, value):
--        with pytest.raises(ValueError) as exc:
--            base = data.one_element_dense(shape, position, value)
--        assert str(exc.value).startswith("Position of the elements"
--                                         " out of bound: ")
--
--
--def test_OrderEfficiencyWarning():
--    N = 5
--    M = csr.identity(N)
--    C_ordered = dense.zeros(N, 1, fortran=False)
--    fortran_ordered = dense.zeros(N, 1, fortran=True)
--    with pytest.warns(dense.OrderEfficiencyWarning):
--        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
-+import numpy as np
-+import pytest
-+
-+from qutip.core import data
-+from qutip.core.data import dense, csr
-+
-+from . import conftest
-+
-+
-+# Set up some fixtures for automatic parametrisation.
-+
-+@pytest.fixture(params=[
-+    pytest.param((1, 5), id='ket'),
-+    pytest.param((5, 1), id='bra'),
-+    pytest.param((5, 5), id='square'),
-+    pytest.param((2, 4), id='wide'),
-+    pytest.param((4, 2), id='tall'),
-+])
-+def shape(request): return request.param
-+
-+
-+@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
-+def fortran(request): return request.param
-+
-+
-+def _valid_numpy():
-+    # Arbitrary valid numpy array.
-+    return conftest.random_numpy_dense((5, 5), False)
-+
-+
-+@pytest.fixture(scope='function')
-+def numpy_dense(shape, fortran):
-+    return conftest.random_numpy_dense(shape, fortran)
-+
-+
-+@pytest.fixture(scope='function')
-+def data_dense(shape, fortran):
-+    return conftest.random_dense(shape, fortran)
-+
-+
-+class TestClassMethods:
-+    def test_init_from_ndarray(self, numpy_dense):
-+        test = data.Dense(numpy_dense)
-+        assert test.shape == numpy_dense.shape
-+        assert np.all(test.as_ndarray() == numpy_dense)
-+
-+    @pytest.mark.parametrize('dtype', ['complex128',
-+                                       'float64',
-+                                       'int32', 'int64',
-+                                       'uint32'])
-+    def test_init_from_ndarray_other_dtype(self, shape, dtype):
-+        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
-+        test = data.Dense(numpy_dense)
-+        assert test.shape == shape
-+        assert test.as_ndarray().dtype == np.complex128
-+        assert np.all(test.as_ndarray() == numpy_dense)
-+
-+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
-+        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
-+                     id="numpy-shape 0 tuple"),
-+        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
-+                     id="numpy-shape 1 tuple"),
-+        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
-+                     id="numpy-shape None tuple"),
-+        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
-+                     id="numpy-shape list"),
-+        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
-+                     id="numpy-shape 3 tuple"),
-+        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
-+                     id="numpy-negative shape"),
-+        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
-+                     id="numpy-both negative shape"),
-+        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
-+                     id="numpy-different shape"),
-+    ])
-+    def test_init_from_wrong_input(self, arg, kwargs, error):
-+        """
-+        Test that the __init__ method raises a suitable error when passed
-+        incorrectly formatted inputs.
-+
-+        This test also serves as a *partial* check that Dense safely handles
-+        deallocation in the presence of exceptions in its __init__ method.  If
-+        the tests segfault, it's quite likely that the memory management isn't
-+        being done correctly in the hand-off us setting our data buffers up and
-+        marking the numpy actually owns the data.
-+        """
-+        with pytest.raises(error):
-+            data.Dense(arg, **kwargs)
-+
-+    def test_copy_returns_a_correct_copy(self, data_dense):
-+        """
-+        Test that the copy() method produces an actual copy, and that the
-+        result represents the same matrix.
-+        """
-+        original = data_dense
-+        copy = data_dense.copy()
-+        assert original is not copy
-+        assert np.all(original.as_ndarray() == copy.as_ndarray())
-+
-+    def test_as_ndarray_returns_a_view(self, data_dense):
-+        """
-+        Test that modifying the views in the result of as_ndarray() also
-+        modifies the underlying data structures.  This is important for
-+        allowing data modification from within Python-space.
-+        """
-+        unmodified_copy = data_dense.copy()
-+        data_dense.as_ndarray()[0, 0] += 1
-+        modified_copy = data_dense.copy()
-+        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
-+        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
-+
-+    def test_as_ndarray_caches_result(self, data_dense):
-+        """
-+        Test that the as_ndarray() method always returns the same view, even if
-+        called multiple times.
-+        """
-+        assert data_dense.as_ndarray() is data_dense.as_ndarray()
-+
-+    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
-+        """
-+        Test that we produce a new ndarray, regardless of how we have
-+        initialised the type.
-+        """
-+        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
-+
-+    def test_as_ndarray_of_copy_is_different(self, data_dense):
-+        """
-+        Test that as_ndarray() does not return the same array or a view to the
-+        same data, if it's not the same input matrix.  We don't want two Dense
-+        matrices to be linked.
-+        """
-+        original = data_dense.as_ndarray()
-+        copy = data_dense.copy().as_ndarray()
-+        assert original is not copy
-+        assert not np.may_share_memory(original, copy)
-+
-+    def test_as_ndarray_is_correct_result(self, numpy_dense):
-+        """
-+        Test that as_ndarray is actually giving the matrix we expect for a given
-+        input.
-+        """
-+        data_dense = data.Dense(numpy_dense)
-+        nd_view = data_dense.as_ndarray()
-+        assert isinstance(data_dense.as_ndarray(), np.ndarray)
-+        assert nd_view.ndim == 2
-+        assert nd_view.shape == numpy_dense.shape
-+        assert nd_view.strides == numpy_dense.strides
-+        assert np.all(nd_view == numpy_dense)
-+        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
-+        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
-+
-+    def test_to_array_is_correct_result(self, data_dense):
-+        test_array = data_dense.to_array()
-+        nd_view = data_dense.as_ndarray()
-+        assert isinstance(test_array, np.ndarray)
-+        assert test_array.ndim == 2
-+        assert test_array.shape == nd_view.shape
-+        assert test_array.strides == nd_view.strides
-+        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
-+        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
-+        # It's not enough to be accurate within a tolerance here - there's no
-+        # mathematics, so they should be _identical_.
-+        assert np.all(test_array == nd_view)
-+
-+    @pytest.mark.parametrize('new_fortran', [
-+        pytest.param(-1, id='swap'),
-+        pytest.param(False, id='C'),
-+        pytest.param(True, id='Fortran'),
-+    ])
-+    def test_reorder(self, data_dense, new_fortran):
-+        reordered = data_dense.reorder(new_fortran)
-+        assert isinstance(reordered, data.Dense)
-+        assert reordered.shape == data_dense.shape
-+        orig = data_dense.to_array()
-+        test = reordered.to_array()
-+        if new_fortran == -1:
-+            orig.flags.f_contiguous == test.flags.c_contiguous
-+            orig.flags.c_contiguous == test.flags.f_contiguous
-+        elif new_fortran is True:
-+            assert test.flags.f_contiguous
-+        else:
-+            assert test.flags.c_contiguous
-+        assert np.all(orig == test)
-+
-+class TestFactoryMethods:
-+    def test_empty(self, shape):
-+        base = dense.empty(shape[0], shape[1])
-+        nd = base.as_ndarray()
-+        assert isinstance(base, data.Dense)
-+        assert base.shape == shape
-+        assert nd.shape == shape
-+
-+    def test_zeros(self, shape):
-+        base = dense.zeros(shape[0], shape[1])
-+        nd = base.as_ndarray()
-+        assert isinstance(base, data.Dense)
-+        assert base.shape == shape
-+        assert nd.shape == shape
-+        assert np.count_nonzero(nd) == 0
-+
-+    @pytest.mark.parametrize('dimension', [1, 5, 100])
-+    @pytest.mark.parametrize(
-+        'scale',
-+        [None, 2, -0.1, 1.5, 1.5+1j],
-+        ids=['none', 'int', 'negative', 'float', 'complex']
-+    )
-+    def test_identity(self, dimension, scale):
-+        # scale=None is testing that the default value returns the identity.
-+        base = (dense.identity(dimension) if scale is None
-+                else dense.identity(dimension, scale))
-+        nd = base.as_ndarray()
-+        numpy_test = np.eye(dimension, dtype=np.complex128)
-+        if scale is not None:
-+            numpy_test *= scale
-+        assert isinstance(base, data.Dense)
-+        assert base.shape == (dimension, dimension)
-+        assert np.count_nonzero(nd - numpy_test) == 0
-+
-+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
-+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
-+        pytest.param([1], None, None, id='1x1'),
-+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
-+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
-+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
-+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
-+                     id='two diagonals'),
-+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
-+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
-+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
-+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
-+                     id='two wide super'),
-+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
-+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
-+                     id='two tall sub'),
-+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
-+                     id='out of order'),
-+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
-+                     id='sum duplicates'),
-+    ])
-+    def test_diags(self, diagonals, offsets, shape):
-+        base = dense.diags(diagonals, offsets, shape)
-+        # Build numpy version test.
-+        if not isinstance(diagonals[0], list):
-+            diagonals = [diagonals]
-+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
-+        if shape is None:
-+            size = len(diagonals[0]) + abs(offsets[0])
-+            shape = (size, size)
-+        test = np.zeros(shape, dtype=np.complex128)
-+        for diagonal, offset in zip(diagonals, offsets):
-+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-+        assert isinstance(base, data.Dense)
-+        assert base.shape == shape
-+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
-+
-+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-+        pytest.param((1, 1), (0, 0), None, id='minimal'),
-+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
-+        pytest.param((10, 10), (1, 5), 1., id='upper'),
-+        pytest.param((10, 10), (5, 1), 2., id='lower'),
-+        pytest.param((10, 1), (5, 0), None, id='column'),
-+        pytest.param((1, 10), (0, 5), -5.j, id='row'),
-+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
-+        pytest.param((2, 10), (1, 5), 10, id='wide'),
-+    ])
-+    def test_one_element(self, shape, position, value):
-+        test = np.zeros(shape, dtype=np.complex128)
-+        if value is None:
-+            base = data.one_element_dense(shape, position)
-+            test[position] = 1.0+0.0j
-+        else:
-+            base = data.one_element_dense(shape, position, value)
-+            test[position] = value
-+        assert isinstance(base, data.Dense)
-+        assert base.shape == shape
-+        assert np.allclose(base.to_array(), test, atol=1e-10)
-+
-+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
-+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
-+        pytest.param((10, 10), (10, 5), 1., id='outside'),
-+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
-+    ])
-+    def test_one_element_error(self, shape, position, value):
-+        with pytest.raises(ValueError) as exc:
-+            base = data.one_element_dense(shape, position, value)
-+        assert str(exc.value).startswith("Position of the elements"
-+                                         " out of bound: ")
-+
-+
-+def test_OrderEfficiencyWarning():
-+    N = 5
-+    M = csr.identity(N)
-+    C_ordered = dense.zeros(N, 1, fortran=False)
-+    fortran_ordered = dense.zeros(N, 1, fortran=True)
-+    with pytest.warns(dense.OrderEfficiencyWarning):
-+        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
-diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
-index 256a703a..29eaa5c2 100644
---- a/qutip/tests/core/data/test_expect.py
-+++ b/qutip/tests/core/data/test_expect.py
-@@ -1,67 +1,67 @@
--"""This file provides tests for expect specialisation. For tests at Qobj level
--see `qutip/tests/core/test_expect.py`"""
--
--from .test_mathematics import BinaryOpMixin
--import pytest
--import numpy as np
--from qutip import data
--from qutip.core.data import CSR, Dense
--from itertools import product
--
--
--class TestExpect(BinaryOpMixin):
--    def op_numpy(self, op, state):
--        is_ket = state.shape[1] == 1
--        if is_ket:
--            return np.conj(state.T)@op@state
--        else:
--            return np.trace(op@state)
--
--    _dim = 100
--    _ket = pytest.param((_dim, 1), id="ket")
--    _dm = pytest.param((_dim, _dim), id="dm")
--    _op = pytest.param((_dim, _dim), id="op")
--    _bra = pytest.param((1, _dim), id="bra")
--    _nonsquare = pytest.param((2, _dim), id="nonsquare")
--    _not_op = [_bra, _ket, _nonsquare]
--
--    shapes = [
--        (_op, _ket),
--        (_op, _dm),
--    ]
--    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
--    bad_shapes += [
--        (_op, _nonsquare),
--        (_op, _bra),
--    ]  # Bad ket/dm
--
--    specialisations = [
--        pytest.param(data.expect_csr, CSR, CSR, complex),
--        pytest.param(data.expect_dense, Dense, Dense, complex),
--        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
--    ]
--
--
--class TestExpectSuper(BinaryOpMixin):
--    def op_numpy(self, op, state):
--        n = np.sqrt(state.shape[0]).astype(int)
--        out_shape = (n, n)
--        return np.trace(np.reshape(op@state, newshape=out_shape))
--
--    _dim = 100
--    _super_ket = pytest.param((_dim, 1), id="super_ket")
--    _super_op = pytest.param((_dim, _dim), id="super_op")
--    _bra = pytest.param((1, _dim), id="row_stacked")
--    _nonsquare = pytest.param((2, _dim), id="nonsquare")
--    _not_super_ket = [_super_op, _bra, _nonsquare]
--    _not_super_op = [_super_ket, _bra, _nonsquare]
--
--    shapes = [(_super_op, _super_ket), ]
--    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
--    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
--
--    specialisations = [
--        pytest.param(data.expect_super_dense, Dense, Dense, complex),
--        pytest.param(data.expect_super_csr, CSR, CSR, complex),
--        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
--    ]
-+"""This file provides tests for expect specialisation. For tests at Qobj level
-+see `qutip/tests/core/test_expect.py`"""
-+
-+from .test_mathematics import BinaryOpMixin
-+import pytest
-+import numpy as np
-+from qutip import data
-+from qutip.core.data import CSR, Dense
-+from itertools import product
-+
-+
-+class TestExpect(BinaryOpMixin):
-+    def op_numpy(self, op, state):
-+        is_ket = state.shape[1] == 1
-+        if is_ket:
-+            return np.conj(state.T)@op@state
-+        else:
-+            return np.trace(op@state)
-+
-+    _dim = 100
-+    _ket = pytest.param((_dim, 1), id="ket")
-+    _dm = pytest.param((_dim, _dim), id="dm")
-+    _op = pytest.param((_dim, _dim), id="op")
-+    _bra = pytest.param((1, _dim), id="bra")
-+    _nonsquare = pytest.param((2, _dim), id="nonsquare")
-+    _not_op = [_bra, _ket, _nonsquare]
-+
-+    shapes = [
-+        (_op, _ket),
-+        (_op, _dm),
-+    ]
-+    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
-+    bad_shapes += [
-+        (_op, _nonsquare),
-+        (_op, _bra),
-+    ]  # Bad ket/dm
-+
-+    specialisations = [
-+        pytest.param(data.expect_csr, CSR, CSR, complex),
-+        pytest.param(data.expect_dense, Dense, Dense, complex),
-+        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
-+    ]
-+
-+
-+class TestExpectSuper(BinaryOpMixin):
-+    def op_numpy(self, op, state):
-+        n = np.sqrt(state.shape[0]).astype(int)
-+        out_shape = (n, n)
-+        return np.trace(np.reshape(op@state, newshape=out_shape))
-+
-+    _dim = 100
-+    _super_ket = pytest.param((_dim, 1), id="super_ket")
-+    _super_op = pytest.param((_dim, _dim), id="super_op")
-+    _bra = pytest.param((1, _dim), id="row_stacked")
-+    _nonsquare = pytest.param((2, _dim), id="nonsquare")
-+    _not_super_ket = [_super_op, _bra, _nonsquare]
-+    _not_super_op = [_super_ket, _bra, _nonsquare]
-+
-+    shapes = [(_super_op, _super_ket), ]
-+    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
-+    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
-+
-+    specialisations = [
-+        pytest.param(data.expect_super_dense, Dense, Dense, complex),
-+        pytest.param(data.expect_super_csr, CSR, CSR, complex),
-+        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
-+    ]
-diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
-index 50729bba..e1025fc2 100644
---- a/qutip/tests/core/data/test_linalg.py
-+++ b/qutip/tests/core/data/test_linalg.py
-@@ -1,139 +1,139 @@
--import qutip.settings as settings
--import numpy as np
--import scipy
--import pytest
--import qutip
--
--from qutip.core import data as _data
--from qutip.core.data import Data, Dense, CSR
--
--
--class TestSolve():
--    def op_numpy(self, A, b):
--        return np.linalg.solve(A, b)
--
--    def _gen_op(self, N, dtype):
--        return qutip.rand_unitary(N, dtype=dtype).data
--
--    def _gen_ket(self, N, dtype):
--        return qutip.rand_ket(N, dtype=dtype).data
--
--    @pytest.mark.parametrize(['method', "opt"], [
--        ("spsolve", {}),
--        ("splu", {"csc": True}),
--        ("gmres", {"atol": 1e-8}),
--        ("lsqr", {}),
--        pytest.param(
--            "mkl_spsolve", {},
--            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
--        ),
--    ],
--        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
--    )
--    def test_mathematically_correct_CSR(self, method, opt):
--        """
--        Test that the binary operation is mathematically correct for all the
--        known type specialisations.
--        """
--        A = self._gen_op(10, CSR)
--        b = self._gen_ket(10, Dense)
--        expected = self.op_numpy(A.to_array(), b.to_array())
--        test = _data.solve_csr_dense(A, b, method, opt)
--        test1 = _data.solve(A, b, method, opt)
--
--        assert test.shape == expected.shape
--        np.testing.assert_allclose(test.to_array(), expected,
--                                   atol=1e-7, rtol=1e-7)
--        np.testing.assert_allclose(test1.to_array(), expected,
--                                   atol=1e-7, rtol=1e-7)
--
--    @pytest.mark.parametrize(['method', "opt"], [
--        ("solve", {}),
--        ("lstsq", {}),
--    ])
--    def test_mathematically_correct_Dense(self, method, opt):
--        A = self._gen_op(10, Dense)
--        b = self._gen_ket(10, Dense)
--        expected = self.op_numpy(A.to_array(), b.to_array())
--        test = _data.solve_dense(A, b, method, opt)
--        test1 = _data.solve(A, b, method, opt)
--
--        assert test.shape == expected.shape
--        np.testing.assert_allclose(test.to_array(), expected,
--                                   atol=1e-7, rtol=1e-7)
--        np.testing.assert_allclose(test1.to_array(), expected,
--                                   atol=1e-7, rtol=1e-7)
--
--
--    def test_incorrect_shape_non_square(self):
--        A = qutip.Qobj(np.random.rand(5, 10)).data
--        b = qutip.Qobj(np.random.rand(10, 1)).data
--        with pytest.raises(ValueError):
--            test1 = _data.solve(A, b)
--
--
--    def test_incorrect_shape_mismatch(self):
--        A = qutip.Qobj(np.random.rand(10, 10)).data
--        b = qutip.Qobj(np.random.rand(9, 1)).data
--        with pytest.raises(ValueError):
--            test1 = _data.solve(A, b)
--
--
--class TestSVD():
--    def op_numpy(self, A):
--        return np.linalg.svd(A)
--
--    def _gen_dm(self, N, rank, dtype):
--        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
--
--    def _gen_non_square(self, N):
--        mat = np.random.randn(N, N//2)
--        for i in range(N//2):
--            # Ensure no zeros singular values
--            mat[i,i] += 5
--        return _data.Dense(mat)
--
--    @pytest.mark.parametrize("shape", ["square", "non-square"])
--    def test_mathematically_correct_svd(self, shape):
--        if shape == "square":
--            matrix = self._gen_dm(10, 6, Dense)
--        else:
--            matrix = self._gen_non_square(12)
--        u, s, v = self.op_numpy(matrix.to_array())
--        test_U, test_S, test_V = _data.svd(matrix, True)
--        only_S = _data.svd(matrix, False)
--
--        assert sum(test_S > 1e-10) == 6
--        # columns are definied up to a sign
--        np.testing.assert_allclose(
--            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
--        )
--        # rows are definied up to a sign
--        np.testing.assert_allclose(
--            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
--        )
--        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
--        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
--
--        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
--
--        np.testing.assert_allclose(
--            matrix.to_array(),
--            (test_U @ s_as_matrix @ test_V).to_array(),
--            atol=1e-7, rtol=1e-7
--        )
--
--    def test_mathematically_correct_svd_csr(self):
--        rank = 5
--        matrix = self._gen_dm(100, rank, CSR)
--        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
--        test_S2 = _data.svd_csr(matrix, False, k=rank)
--
--        assert len(test_S1) == rank
--        assert len(test_S2) == rank
--
--        np.testing.assert_allclose(
--            matrix.to_array(),
--            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
--            atol=1e-7, rtol=1e-7
--        )
-+import qutip.settings as settings
-+import numpy as np
-+import scipy
-+import pytest
-+import qutip
-+
-+from qutip.core import data as _data
-+from qutip.core.data import Data, Dense, CSR
-+
-+
-+class TestSolve():
-+    def op_numpy(self, A, b):
-+        return np.linalg.solve(A, b)
-+
-+    def _gen_op(self, N, dtype):
-+        return qutip.rand_unitary(N, dtype=dtype).data
-+
-+    def _gen_ket(self, N, dtype):
-+        return qutip.rand_ket(N, dtype=dtype).data
-+
-+    @pytest.mark.parametrize(['method', "opt"], [
-+        ("spsolve", {}),
-+        ("splu", {"csc": True}),
-+        ("gmres", {"atol": 1e-8}),
-+        ("lsqr", {}),
-+        pytest.param(
-+            "mkl_spsolve", {},
-+            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
-+        ),
-+    ],
-+        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
-+    )
-+    def test_mathematically_correct_CSR(self, method, opt):
-+        """
-+        Test that the binary operation is mathematically correct for all the
-+        known type specialisations.
-+        """
-+        A = self._gen_op(10, CSR)
-+        b = self._gen_ket(10, Dense)
-+        expected = self.op_numpy(A.to_array(), b.to_array())
-+        test = _data.solve_csr_dense(A, b, method, opt)
-+        test1 = _data.solve(A, b, method, opt)
-+
-+        assert test.shape == expected.shape
-+        np.testing.assert_allclose(test.to_array(), expected,
-+                                   atol=1e-7, rtol=1e-7)
-+        np.testing.assert_allclose(test1.to_array(), expected,
-+                                   atol=1e-7, rtol=1e-7)
-+
-+    @pytest.mark.parametrize(['method', "opt"], [
-+        ("solve", {}),
-+        ("lstsq", {}),
-+    ])
-+    def test_mathematically_correct_Dense(self, method, opt):
-+        A = self._gen_op(10, Dense)
-+        b = self._gen_ket(10, Dense)
-+        expected = self.op_numpy(A.to_array(), b.to_array())
-+        test = _data.solve_dense(A, b, method, opt)
-+        test1 = _data.solve(A, b, method, opt)
-+
-+        assert test.shape == expected.shape
-+        np.testing.assert_allclose(test.to_array(), expected,
-+                                   atol=1e-7, rtol=1e-7)
-+        np.testing.assert_allclose(test1.to_array(), expected,
-+                                   atol=1e-7, rtol=1e-7)
-+
-+
-+    def test_incorrect_shape_non_square(self):
-+        A = qutip.Qobj(np.random.rand(5, 10)).data
-+        b = qutip.Qobj(np.random.rand(10, 1)).data
-+        with pytest.raises(ValueError):
-+            test1 = _data.solve(A, b)
-+
-+
-+    def test_incorrect_shape_mismatch(self):
-+        A = qutip.Qobj(np.random.rand(10, 10)).data
-+        b = qutip.Qobj(np.random.rand(9, 1)).data
-+        with pytest.raises(ValueError):
-+            test1 = _data.solve(A, b)
-+
-+
-+class TestSVD():
-+    def op_numpy(self, A):
-+        return np.linalg.svd(A)
-+
-+    def _gen_dm(self, N, rank, dtype):
-+        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
-+
-+    def _gen_non_square(self, N):
-+        mat = np.random.randn(N, N//2)
-+        for i in range(N//2):
-+            # Ensure no zeros singular values
-+            mat[i,i] += 5
-+        return _data.Dense(mat)
-+
-+    @pytest.mark.parametrize("shape", ["square", "non-square"])
-+    def test_mathematically_correct_svd(self, shape):
-+        if shape == "square":
-+            matrix = self._gen_dm(10, 6, Dense)
-+        else:
-+            matrix = self._gen_non_square(12)
-+        u, s, v = self.op_numpy(matrix.to_array())
-+        test_U, test_S, test_V = _data.svd(matrix, True)
-+        only_S = _data.svd(matrix, False)
-+
-+        assert sum(test_S > 1e-10) == 6
-+        # columns are definied up to a sign
-+        np.testing.assert_allclose(
-+            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
-+        )
-+        # rows are definied up to a sign
-+        np.testing.assert_allclose(
-+            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
-+        )
-+        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
-+        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
-+
-+        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
-+
-+        np.testing.assert_allclose(
-+            matrix.to_array(),
-+            (test_U @ s_as_matrix @ test_V).to_array(),
-+            atol=1e-7, rtol=1e-7
-+        )
-+
-+    def test_mathematically_correct_svd_csr(self):
-+        rank = 5
-+        matrix = self._gen_dm(100, rank, CSR)
-+        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
-+        test_S2 = _data.svd_csr(matrix, False, k=rank)
-+
-+        assert len(test_S1) == rank
-+        assert len(test_S2) == rank
-+
-+        np.testing.assert_allclose(
-+            matrix.to_array(),
-+            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
-+            atol=1e-7, rtol=1e-7
-+        )
-diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
-index 459ab0d4..dfe3fe8a 100644
---- a/qutip/tests/core/data/test_mathematics.py
-+++ b/qutip/tests/core/data/test_mathematics.py
-@@ -1,952 +1,952 @@
--import itertools
--import numpy as np
--import scipy
--import pytest
--
--from qutip.core import data
--from qutip.core.data import Data, Dense, CSR
--
--from . import conftest
--
--# The ParameterSet is actually a pretty hidden type, so it's easiest to access
--# it like this.
--_ParameterSet = type(pytest.param())
--
--# First set up a bunch of allowable shapes, for different types of functions so
--# we don't have to respecify a whole lot of things on repeat.
--
--
--def shapes_unary(dim=100):
--    """Base shapes to test for unary functions."""
--    # Be sure to test a full spectrum bra-type, ket-type and square and
--    # non-square operators.  Keep the dimension sensible, particularly for
--    # things like kron, since these shapes are reused to build the shapes for
--    # higher-order functions too.
--    return [
--        pytest.param((1, 1), id="scalar"),
--        pytest.param((1, dim), id="bra"),
--        pytest.param((dim, 1), id="ket"),
--        pytest.param((dim, dim), id="square"),
--        pytest.param((2, dim), id="nonsquare"),
--    ]
--
--
--def shapes_binary_identical(dim=100):
--    """
--    Allowed shapes for binary operators that need the two matrices to be the
--    same shape, e.g. addition.
--    """
--    return [(x, x) for x in shapes_unary(dim)]
--
--
--def shapes_binary_bad_identical(dim=100):
--    """
--    Disallowed shapes for binary operators that need the two matrices to be the
--    same shape, e.g. addition.
--    """
--    return [
--        (x, y)
--        for x, y in itertools.product(shapes_unary(dim), repeat=2)
--        if x.values[0] != y.values[0]
--    ]
--
--
--def shapes_binary_unrestricted(dim=100):
--    """
--    Allowed shapes for binary operators which can take any shapes, e.g. the
--    Kronecker product.
--    """
--    return list(itertools.product(shapes_unary(dim), repeat=2))
--
--
--def shapes_binary_bad_unrestricted(dim=100):
--    """
--    Disallowed shapes for binary operators which can take any shapes, e.g. the
--    Kronecker product.  There aren't actually any of these, but we keep it just
--    for consistency.
--    """
--    return []
--
--
--def shapes_binary_matmul(dim=100):
--    """
--    Allowed shapes for "matmul"-like operators that require that the "inner"
--    two indices are equal, i.e. the columns on the left equal the rows on the
--    right.
--    """
--    return [
--        (x, y)
--        for x, y in itertools.product(shapes_unary(dim), repeat=2)
--        if x.values[0][1] == y.values[0][0]
--    ]
--
--
--def shapes_binary_bad_matmul(dim=100):
--    """
--    Disallowed shapes for "matmul"-like operators that require that the "inner"
--    two indices are equal, i.e. the columns on the left equal the rows on the
--    right.
--    """
--    return [
--        (x, y)
--        for x, y in itertools.product(shapes_unary(dim), repeat=2)
--        if x.values[0][1] != y.values[0][0]
--    ]
--
--
--def shapes_square(dim=100):
--    """Allowed shapes for operations that require square matrices. Examples of
--    these operations are trace, pow, expm and the trace norm."""
--    return [
--        (pytest.param((1, 1), id="1"),),
--        (pytest.param((dim, dim), id=str(dim)),),
--    ]
--
--
--def shapes_not_square(dim=100):
--    """Disallowed shapes for operations that require square matrices. Examples
--    of these operations are trace, pow, expm and the trace norm."""
--    return [
--        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
--    ]
--
--
--# Set up the special cases for each type of matrix that will be tested.  These
--# should be kept low, because mathematical operations will test a Cartesian
--# product of all the cases of the same order as the operation, which can get
--# very large very fast.  The operations should each complete in a small amount
--# of time, so having 10000+ tests in this file still ought to take less than 2
--# minutes, but it's easy to accidentally add orders of magnitude on.
--#
--# There is a layer of indirection---the cases are returned as 0-ary generator
--# closures---for two reasons:
--#   1. we don't have to store huge amounts of data at test collection time, but
--#      the matrices are only generated, and subsequently freed, within in each
--#      individual test.
--#   2. each test can be repeated, and new random matrices will be generated for
--#      each repeat, rather than re-using the same set.  This is somewhat
--#      "defeating" pytest fixtures, but here we're not worried about re-usable
--#      inputs, we just want the managed parametrisation.
--
--def cases_csr(shape):
--    """
--    Return a list of generators of the different special cases for CSR
--    matrices of a given shape.
--    """
--    def factory(density, sort):
--        return lambda: conftest.random_csr(shape, density, sort)
--
--    def zero_factory():
--        return lambda: data.csr.zeros(shape[0], shape[1])
--    return [
--        pytest.param(factory(0.001, True), id="sparse"),
--        pytest.param(factory(0.8, True), id="filled,sorted"),
--        pytest.param(factory(0.8, False), id="filled,unsorted"),
--        pytest.param(zero_factory(), id="zero"),
--    ]
--
--
--def cases_dense(shape):
--    """
--    Return a list of generators of the different special cases for Dense
--    matrices of a given shape.
--    """
--    def factory(fortran):
--        return lambda: conftest.random_dense(shape, fortran)
--    return [
--        pytest.param(factory(False), id="C"),
--        pytest.param(factory(True), id="Fortran"),
--    ]
--
--
--# Factory methods for generating the cases, mapping type to the function.
--# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
--# getting just a single case from each.
--_ALL_CASES = {
--    CSR: cases_csr,
--    Dense: cases_dense,
--}
--_RANDOM = {
--    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
--    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
--}
--
--
--def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
--    """
--    Return a list of `pytest.ParameterSet` which is a flat list of all the
--    special cases that should be tested for this operator specialisation `op`,
--    which takes in several types `types`, where the arguments have shapes taken
--    from the iterable of iterables `shapes`.  If `out_type` is specified, it
--    will be added into the output parameter set and its name added to the id,
--    but is otherwise not used.
--
--    Parameters
--    ----------
--    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
--        Mapping to get the special case generator from.  This is one of
--        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
--        from the case generator should all be closures of the form `() -> Data`
--        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
--        containing exactly one value, which is the same closure type.
--
--    op: Function
--        The specialisation of a mathematical operation that is being tested.
--        This is actually generally unused - it's just added in to the output
--        ParameterSet at the end so that it will get correctly parametrised.
--
--    types: Tuple[Type]
--        A tuple of data.Data subclass types (not instances).  This defines the
--        inputs to this particular specialisation under test.  There should be
--        as many types as there are Data arguments to `op`.
--
--    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
--        An iterable containing several sets of shapes to parameterise over.
--        Each element of the iterable should be s tuple of shapes, or
--        `pytest.ParameterSet` instances each containing a single shape.  A
--        shape is a 2-tuple of integers.  There should be as many elements of
--        this inner tuple as there are `types`, since each individual `shape`
--        goes with a `type`.
--
--    out_type: Type
--        The output type for this specialisation.  Not used other than its name
--        being added to the id, and it being added at the end of the
--        specialisation (if it is given), similarly to `op`.
--
--    Returns
--    -------
--    List[ParameterSet]
--        A list of individual test cases for parametrisation.  Each ParameterSet
--        will be
--            [op, *data_inputs, ?out_type]
--        where `data_inputs` is of the same length as the input parameter
--        `types` and represents the Data arguments to the specialisation `op`.
--        Each element of `data_inputs` is a generator function which takes no
--        arguments and returns a data.Data subclass of the correct type and
--        shape.  `out_type` is present in the output only if it were given as a
--        parameter itself.
--    """
--    def case(type_, shape_case, generator_case):
--        """
--        Build a case parameter for _one_ generator function which will return
--        a given type and shape.
--        """
--        id_ = type_.__name__
--        inner = ""
--        for extra in [shape_case, generator_case]:
--            if hasattr(extra, 'id') and extra.id:
--                inner += ("," if inner else "") + extra.id
--        if inner:
--            id_ += "[" + inner + "]"
--        func = (
--            generator_case.values[0]
--            if isinstance(generator_case, _ParameterSet)
--            else generator_case
--        )
--        return pytest.param(func, id=id_)
--
--    cases = []
--    for shapes_ in shapes:
--        # Convert the list of types into a list of lists of the special cases
--        # needed for each type.
--        matrix_cases = [
--            [case(type_, shape_case, type_case)
--             for type_case in cases_lookup[type_](shape_case.values[0])]
--            for type_, shape_case in zip(types, shapes_)
--        ]
--        # Now Cartesian product all the special cases together to make the full
--        # set of parametrisations.
--        for matrices in itertools.product(*matrix_cases):
--            id_ = ",".join(m.id for m in matrices)
--            args = [m for p_m in matrices for m in p_m.values]
--            if out_type is not None:
--                id_ += "->" + out_type.__name__
--                args += [out_type]
--            cases.append(pytest.param(op, *args, id=id_))
--    return cases
--
--
--# Now we start to actually build up all the test cases.  Since all the
--# mathematical operations are really pretty similar, and most just need the
--# basic testing functionality, we do this with a series of mix-in classes which
--# provide various components of the testing and test-generation infrastructure.
--#
--# In each, we use the idiom that "test_<x>" is a test function which pytest
--# will collect for us, and "generate_<x>" a method which will be called by
--# `pytest_generate_tests` in order to generate all the parametrisations for the
--# given test.
--
--class _GenericOpMixin:
--    """
--    Abstract base mix-in which sets up the test generation for the two basic
--    test operations, and puts in the very generic test generator.  This does
--    not actually define the tests themselves, because subclasses need to define
--    them so the method arguments can be introspected to parametrise over the
--    correct number of arguments.
--
--    The tests `mathematically_correct` and `incorrect_shape_raises` will
--    parametrise Data types over method arguments which have names `data_*`.
--
--    The class arguments defined here are effectively parametrising the
--    mathematical tests.
--
--    Attributes
--    ----------
--    op_numpy: *args -> np.ndarray
--        Function which takes the same arguments as the mathematical operation,
--        but with all data arguments numpy arrays, and returns the expected
--        result.
--
--    atol: float
--        The absolute tolerance to use when comparing the test value with the
--        expected value.  If the output is a Data type, the tolerance is
--        per-element of the output.
--
--    rtol: float
--        The relative tolerance to use when comparing the test value with the
--        expected value.  If the output is a Data type, the tolerance is
--        per-element of the output.
--
--    shapes: list of (list of shapes)
--        A list of the sets of shapes which should be used for the tests of
--        mathematical correctness.  Each element of the list is a set of shapes,
--        each one corresponding to one of the arguments of the operation.
--
--    bad_shapes: list of (list of shapes)
--        Similar to `shapes`, but these should be shapes which are invalid for
--        the given mathematical operation.
--
--    specialisations: list of (function, Type, Type, [Type, ...])
--        The specialisations of each mathematical function, and the types that
--        it takes in and returns.  For example, the function
--            add(CSR, Dense) -> Other
--        would be specified as `(add, CSR, Dense, Other)`.
--    """
--    def op_numpy(self, *args): raise NotImplementedError
--    # With dimensions of around 100, we have to account for floating-point
--    # addition not being associative; the maths on full numpy arrays will often
--    # produce slightly different results to sparse algebra, since the order of
--    # multiplications and additions will be different.
--    atol = 1e-10
--    rtol = 1e-7  # Same default as numpy
--    shapes = []
--    bad_shapes = []
--    specialisations = []
--
--    def generate_mathematically_correct(self, metafunc):
--        parameters = (
--            ['op']
--            + [x for x in metafunc.fixturenames
--               if x.startswith("data_")]
--            + ['out_type']
--        )
--        cases = []
--        for p_op in self.specialisations:
--            op, *types, out_type = p_op.values
--            args = (op, types, self.shapes, out_type)
--            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
--        metafunc.parametrize(parameters, cases)
--
--    def generate_incorrect_shape_raises(self, metafunc):
--        parameters = (
--            ['op']
--            + [x for x in metafunc.fixturenames
--               if x.startswith("data_")]
--        )
--        if not self.bad_shapes:
--            reason = "".join([
--                "no shapes are 'incorrect' for ",
--                metafunc.cls.__name__,
--                "::",
--                metafunc.function.__name__,
--            ])
--            false_case = pytest.param(*([None]*len(parameters)),
--                                      marks=pytest.mark.skip(reason),
--                                      id="no test")
--            metafunc.parametrize(parameters, [false_case])
--            return
--        cases = []
--        for p_op in self.specialisations:
--            op, *types, _ = p_op.values
--            args = (op, types, self.bad_shapes)
--            cases.extend(cases_type_shape_product(_RANDOM, *args))
--        metafunc.parametrize(parameters, cases)
--
--    def pytest_generate_tests(self, metafunc):
--        # For every test function "test_xyz", we use the test generator
--        # "generate_xyz" if it exists.  This allows derived classes to add
--        # their own tests and generators without overiding this method, cutting
--        # down on boilerplate, but also that derived classes _may_ override the
--        # generation of tests defined in a base class, say if they have
--        # additional special arguments that need parametrising over.
--        generator_name = (
--            "generate_"
--            + metafunc.function.__name__.replace("test_", "")
--        )
--        try:
--            generator = getattr(self, generator_name)
--        except AttributeError:
--            return
--        generator(metafunc)
--
--
--class UnaryOpMixin(_GenericOpMixin):
--    """
--    Mix-in for unary mathematical operations on Data instances (e.g. unary
--    negation).
--    """
--    shapes = [(x,) for x in shapes_unary()]
--    bad_shapes = []
--
--    def test_mathematically_correct(self, op, data_m, out_type):
--        matrix = data_m()
--        expected = self.op_numpy(matrix.to_array())
--        test = op(matrix)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol, rtol=self.rtol)
--        elif out_type is list:
--            for test_, expected_ in zip(test, expected):
--                assert test_.shape == expected_.shape
--                np.testing.assert_allclose(test_.to_array(), expected_,
--                                           atol=self.atol, rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--    def test_incorrect_shape_raises(self, op, data_m):
--        """
--        Test that the operation produces a suitable error if the shape of the
--        given operand is not compatible with the operation. Useful for
--        operations that require square matrices (trace, pow, ...).
--        """
--        with pytest.raises(ValueError):
--            op(data_m())
--
--
--class UnaryScalarOpMixin(_GenericOpMixin):
--    """
--    Mix-in for unary mathematical operations on Data instances, but that also
--    take in a numeric scalar (e.g. scalar multiplication).  Only generates
--    the test `mathematically_correct`, since there can't be a shape mismatch
--    when there's only one Data argument.
--    """
--    shapes = [(x,) for x in shapes_unary()]
--
--    @pytest.mark.parametrize('scalar', [
--        pytest.param(0, id='zero'),
--        pytest.param(4.5, id='real'),
--        pytest.param(3j, id='complex'),
--    ])
--    def test_mathematically_correct(self, op, data_m, scalar, out_type):
--        matrix = data_m()
--        expected = self.op_numpy(matrix.to_array(), scalar)
--        test = op(matrix, scalar)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol,
--                                       rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--
--class BinaryOpMixin(_GenericOpMixin):
--    """
--    Mix-in for binary mathematical operations on Data instances (e.g. binary
--    addition).
--    """
--    def test_mathematically_correct(self, op, data_l, data_r, out_type):
--        """
--        Test that the binary operation is mathematically correct for all the
--        known type specialisations.
--        """
--        left, right = data_l(), data_r()
--        expected = self.op_numpy(left.to_array(), right.to_array())
--        test = op(left, right)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol, rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--    def test_incorrect_shape_raises(self, op, data_l, data_r):
--        """
--        Test that the operation produces a suitable error if the shapes of the
--        given operands are not compatible.
--        """
--        with pytest.raises(ValueError):
--            op(data_l(), data_r())
--
--
--class TernaryOpMixin(_GenericOpMixin):
--    """
--    Mix-in for ternary mathematical operations on Data instances (e.g. inner
--    product with an operator in the middle).  This is pretty rare.
--    """
--    def test_mathematically_correct(self, op,
--                                    data_l, data_m, data_r,
--                                    out_type):
--        """
--        Test that the binary operation is mathematically correct for all the
--        known type specialisations.
--        """
--        left, mid, right = data_l(), data_m(), data_r()
--        expected = self.op_numpy(left.to_array(),
--                                 mid.to_array(),
--                                 right.to_array())
--        test = op(left, mid, right)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol, rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
--        """
--        Test that the operation produces a suitable error if the shapes of the
--        given operands are not compatible.
--        """
--        with pytest.raises(ValueError):
--            op(data_l(), data_m(), data_r())
--
--
--# And now finally we get into the meat of the actual mathematical tests.
--
--class TestAdd(BinaryOpMixin):
--    def op_numpy(self, left, right, scale):
--        return np.add(left, scale * right)
--
--    shapes = shapes_binary_identical()
--    bad_shapes = shapes_binary_bad_identical()
--    specialisations = [
--        pytest.param(data.add_csr, CSR, CSR, CSR),
--        pytest.param(data.add_dense, Dense, Dense, Dense),
--    ]
--
--    # `add` has an additional scalar parameter, because the operation is
--    # actually more like `A + c*B`.  We just parametrise that scalar
--    # separately.
--    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
--                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
--    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
--        """
--        Test that the binary operation is mathematically correct for all the
--        known type specialisations.
--        """
--        left, right = data_l(), data_r()
--        if scale is not None:
--            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
--            test = op(left, right, scale)
--        else:
--            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
--            test = op(left, right)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol, rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--
--class TestAdjoint(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return np.conj(matrix.T)
--
--    specialisations = [
--        pytest.param(data.adjoint_csr, CSR, CSR),
--        pytest.param(data.adjoint_dense, Dense, Dense),
--    ]
--
--
--class TestConj(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return np.conj(matrix)
--
--    specialisations = [
--        pytest.param(data.conj_csr, CSR, CSR),
--        pytest.param(data.conj_dense, Dense, Dense),
--    ]
--
--
--class TestInner(BinaryOpMixin):
--    # The inner product is a bit more specialist, since it has to handle inputs
--    # in a 1D space specially.  In order to keep things simple, we just
--    # generate those test cases completely separately from the standard
--    # `mathematically_correct`.
--
--    def op_numpy(self, left, right, scalar_is_ket=False):
--        if left.shape[1] == 1:
--            if left.shape[0] != 1 or scalar_is_ket:
--                left = np.conj(left.T)
--        return (left @ right)[0, 0]
--
--    # These shapes are a little more non-standard.
--    _dim = 100
--    _scalar = pytest.param((1, 1), id="scalar")
--    _bra = pytest.param((1, _dim), id="bra")
--    _ket = pytest.param((_dim, 1), id="ket")
--    _op = pytest.param((_dim, _dim), id="square")
--    shapes = [
--        (_bra, _ket),
--        (_ket, _ket),
--    ]
--    bad_shapes = [
--        (_bra, _bra),
--        (_ket, _bra),
--        (_op, _ket),
--        (_op, _bra),
--        (_bra, _op),
--        (_ket, _op),
--    ]
--
--    specialisations = [
--        pytest.param(data.inner_csr, CSR, CSR, complex),
--        pytest.param(data.inner_dense, Dense, Dense, complex),
--    ]
--
--    def generate_scalar_is_ket(self, metafunc):
--        # For 1D subspaces, the special cases don't really matter since there's
--        # only really one type of matrix available, so this is parametrised
--        # with only case for each input argument.
--        parameters = (
--            ['op']
--            + [x for x in metafunc.fixturenames
--               if x.startswith("data_")]
--            + ['out_type']
--        )
--        cases = []
--        for p_op in self.specialisations:
--            op, *types, out_type = p_op.values
--            args = (op, types, [(self._scalar, self._scalar)], out_type)
--            cases.extend(cases_type_shape_product(_RANDOM, *args))
--        metafunc.parametrize(parameters, cases)
--        metafunc.parametrize('scalar_is_ket',
--                             [True, False],
--                             ids=["ket", "bra"])
--
--    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
--        left, right = data_l(), data_r()
--        expected = self.op_numpy(left.to_array(), right.to_array(),
--                                 scalar_is_ket)
--        test = op(left, right, scalar_is_ket)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol, rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--
--class TestInnerOp(TernaryOpMixin):
--    # This is very very similar to TestInner.
--    def op_numpy(self, left, mid, right, scalar_is_ket=False):
--        if left.shape[1] == 1:
--            if left.shape[0] != 1 or scalar_is_ket:
--                left = np.conj(left.T)
--        return (left @ mid @ right)[0, 0]
--
--    _dim = 100
--    _scalar = pytest.param((1, 1), id="scalar")
--    _bra = pytest.param((1, _dim), id="bra")
--    _ket = pytest.param((_dim, 1), id="ket")
--    _op = pytest.param((_dim, _dim), id="square")
--    shapes = [
--        (_bra, _op, _ket),
--        (_ket, _op, _ket),
--    ]
--    bad_shapes = [
--        (_bra, _op, _bra),
--        (_ket, _op, _bra),
--        (_op, _op, _ket),
--        (_op, _op, _bra),
--        (_bra, _op, _op),
--        (_ket, _op, _op),
--        (_bra, _bra, _ket),
--        (_ket, _bra, _ket),
--        (_bra, _ket, _ket),
--        (_ket, _ket, _ket),
--    ]
--
--    specialisations = [
--        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
--        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
--    ]
--
--    def generate_scalar_is_ket(self, metafunc):
--        parameters = (
--            ['op']
--            + [x for x in metafunc.fixturenames
--               if x.startswith("data_")]
--            + ['out_type']
--        )
--        cases = []
--        for p_op in self.specialisations:
--            op, *types, out_type = p_op.values
--            args = (op, types, [(self._scalar,) * 3], out_type)
--            cases.extend(cases_type_shape_product(_RANDOM, *args))
--        metafunc.parametrize(parameters, cases)
--        metafunc.parametrize('scalar_is_ket',
--                             [True, False], ids=["ket", "bra"])
--
--    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
--                           scalar_is_ket):
--        left, mid, right = data_l(), data_m(), data_r()
--        expected = self.op_numpy(left.to_array(),
--                                 mid.to_array(),
--                                 right.to_array(),
--                                 scalar_is_ket)
--        test = op(left, mid, right, scalar_is_ket)
--        assert isinstance(test, out_type)
--        if issubclass(out_type, Data):
--            assert test.shape == expected.shape
--            np.testing.assert_allclose(test.to_array(), expected,
--                                       atol=self.atol,
--                                       rtol=self.rtol)
--        else:
--            np.testing.assert_allclose(test, expected, atol=self.atol,
--                                       rtol=self.rtol)
--
--
--class TestKron(BinaryOpMixin):
--    def op_numpy(self, left, right):
--        return np.kron(left, right)
--
--    # Keep the dimension low because kron can get very expensive.
--    shapes = shapes_binary_unrestricted(dim=5)
--    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
--    specialisations = [
--        pytest.param(data.kron_csr, CSR, CSR, CSR),
--        pytest.param(data.kron_dense, Dense, Dense, Dense),
--    ]
--
--
--class TestMatmul(BinaryOpMixin):
--    def op_numpy(self, left, right):
--        return np.matmul(left, right)
--
--    shapes = shapes_binary_matmul()
--    bad_shapes = shapes_binary_bad_matmul()
--    specialisations = [
--        pytest.param(data.matmul_csr, CSR, CSR, CSR),
--        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
--        pytest.param(data.matmul_dense, Dense, Dense, Dense),
--    ]
--
--
--class TestMultiply(BinaryOpMixin):
--    def op_numpy(self, left, right):
--        return left * right
--
--    shapes = shapes_binary_identical()
--    bad_shapes = shapes_binary_bad_identical()
--    specialisations = [
--        pytest.param(data.multiply_csr, CSR, CSR, CSR),
--        pytest.param(data.multiply_dense, Dense, Dense, Dense),
--    ]
--
--
--class TestMul(UnaryScalarOpMixin):
--    def op_numpy(self, matrix, scalar):
--        return scalar * matrix
--
--    specialisations = [
--        pytest.param(data.mul_csr, CSR, CSR),
--        pytest.param(data.mul_dense, Dense, Dense),
--    ]
--
--
--class TestNeg(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return -matrix
--
--    specialisations = [
--        pytest.param(data.neg_csr, CSR, CSR),
--        pytest.param(data.neg_dense, Dense, Dense),
--    ]
--
--
--class TestSub(BinaryOpMixin):
--    def op_numpy(self, left, right):
--        return left - right
--
--    shapes = shapes_binary_identical()
--    bad_shapes = shapes_binary_bad_identical()
--    specialisations = [
--        pytest.param(data.sub_csr, CSR, CSR, CSR),
--        pytest.param(data.sub_dense, Dense, Dense, Dense),
--    ]
--
--
--class TestTrace(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return np.sum(np.diag(matrix))
--
--    shapes = shapes_square()
--    bad_shapes = shapes_not_square()
--    specialisations = [
--        pytest.param(data.trace_csr, CSR, complex),
--        pytest.param(data.trace_dense, Dense, complex),
--    ]
--
--
--class TestTrace_oper_ket(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        N = int(matrix.shape[0] ** 0.5)
--        return np.sum(np.diag(matrix.reshape((N, N))))
--
--    shapes = [
--        (pytest.param((100, 1), id="oper-ket"),),
--    ]
--    bad_shapes = [
--        (pytest.param((1, 100), id="bra"),),
--        (pytest.param((99, 1), id="ket"),),
--        (pytest.param((99, 99), id="ket"),),
--        (pytest.param((2, 99), id="nonsquare"),),
--    ]
--    specialisations = [
--        pytest.param(data.trace_oper_ket_csr, CSR, complex),
--        pytest.param(data.trace_oper_ket_dense, Dense, complex),
--    ]
--
--
--class TestPow(UnaryOpMixin):
--    def op_numpy(self, matrix, n):
--        return np.linalg.matrix_power(matrix, n)
--
--    shapes = shapes_square()
--    bad_shapes = shapes_not_square()
--    specialisations = [
--        pytest.param(data.pow_csr, CSR, CSR),
--        pytest.param(data.pow_dense, Dense, Dense),
--    ]
--
--    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
--    def test_mathematically_correct(self, op, data_m, out_type, n):
--        matrix = data_m()
--        expected = self.op_numpy(matrix.to_array(), n)
--        test = op(matrix, n)
--        assert isinstance(test, out_type)
--        assert test.shape == expected.shape
--        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
--                                   rtol=self.rtol)
--
--    # Pow actually does have bad shape, so we put that in too.
--    def test_incorrect_shape_raises(self, op, data_m):
--        """
--        Test that the operation produces a suitable error if the shape is not a
--        square matrix.
--        """
--        with pytest.raises(ValueError):
--            op(data_m(), 10)
--
--
--class TestExpm(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return scipy.linalg.expm(matrix)
--
--    shapes = shapes_square()
--    bad_shapes = shapes_not_square()
--    specialisations = [
--        pytest.param(data.expm_csr, CSR, CSR),
--        pytest.param(data.expm_csr_dense, CSR, Dense),
--        pytest.param(data.expm_dense, Dense, Dense),
--    ]
--
--
--class TestLogm(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return scipy.linalg.logm(matrix)
--
--    shapes = shapes_square()
--    bad_shapes = shapes_not_square()
--    specialisations = [
--        pytest.param(data.logm_dense, Dense, Dense),
--    ]
--
--
--class TestTranspose(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return matrix.T
--
--    specialisations = [
--        pytest.param(data.transpose_csr, CSR, CSR),
--        pytest.param(data.transpose_dense, Dense, Dense),
--    ]
--
--
--class TestProject(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        if matrix.shape[0] == 1:
--            return np.outer(np.conj(matrix), matrix)
--        else:
--            return np.outer(matrix, np.conj(matrix))
--
--    shapes = [
--        (pytest.param((1, 1), id="scalar"),),
--        (pytest.param((1, 100), id="bra"),),
--        (pytest.param((100, 1), id="ket"),),
--    ]
--    bad_shapes = [
--        (pytest.param((10, 10), id="square"),),
--        (pytest.param((2, 10), id="nonsquare"),),
--    ]
--
--    specialisations = [
--        pytest.param(data.project_csr, CSR, CSR),
--        pytest.param(data.project_dense, Dense, Dense),
--    ]
--
--
--def _inv_dense(matrix):
--    # Add a diagonal so `matrix` is not singular
--    return data.inv_dense(
--        data.add(
--            matrix,
--            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
--        )
--    )
--
--
--def _inv_csr(matrix):
--    # Add a diagonal so `matrix` is not singular
--    return data.inv_csr(
--        data.add(
--            matrix,
--            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
--        )
--    )
--
--
--class TestInv(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
--
--    shapes = [
--        (pytest.param((1, 1), id="scalar"),),
--        (pytest.param((10, 10), id="square"),),
--    ]
--    bad_shapes = [
--        (pytest.param((2, 10), id="nonsquare"),),
--        (pytest.param((1, 100), id="bra"),),
--        (pytest.param((100, 1), id="ket"),),
--    ]
--
--    specialisations = [
--        pytest.param(_inv_csr, CSR, CSR),
--        pytest.param(_inv_dense, Dense, Dense),
--    ]
-+import itertools
-+import numpy as np
-+import scipy
-+import pytest
-+
-+from qutip.core import data
-+from qutip.core.data import Data, Dense, CSR
-+
-+from . import conftest
-+
-+# The ParameterSet is actually a pretty hidden type, so it's easiest to access
-+# it like this.
-+_ParameterSet = type(pytest.param())
-+
-+# First set up a bunch of allowable shapes, for different types of functions so
-+# we don't have to respecify a whole lot of things on repeat.
-+
-+
-+def shapes_unary(dim=100):
-+    """Base shapes to test for unary functions."""
-+    # Be sure to test a full spectrum bra-type, ket-type and square and
-+    # non-square operators.  Keep the dimension sensible, particularly for
-+    # things like kron, since these shapes are reused to build the shapes for
-+    # higher-order functions too.
-+    return [
-+        pytest.param((1, 1), id="scalar"),
-+        pytest.param((1, dim), id="bra"),
-+        pytest.param((dim, 1), id="ket"),
-+        pytest.param((dim, dim), id="square"),
-+        pytest.param((2, dim), id="nonsquare"),
-+    ]
-+
-+
-+def shapes_binary_identical(dim=100):
-+    """
-+    Allowed shapes for binary operators that need the two matrices to be the
-+    same shape, e.g. addition.
-+    """
-+    return [(x, x) for x in shapes_unary(dim)]
-+
-+
-+def shapes_binary_bad_identical(dim=100):
-+    """
-+    Disallowed shapes for binary operators that need the two matrices to be the
-+    same shape, e.g. addition.
-+    """
-+    return [
-+        (x, y)
-+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-+        if x.values[0] != y.values[0]
-+    ]
-+
-+
-+def shapes_binary_unrestricted(dim=100):
-+    """
-+    Allowed shapes for binary operators which can take any shapes, e.g. the
-+    Kronecker product.
-+    """
-+    return list(itertools.product(shapes_unary(dim), repeat=2))
-+
-+
-+def shapes_binary_bad_unrestricted(dim=100):
-+    """
-+    Disallowed shapes for binary operators which can take any shapes, e.g. the
-+    Kronecker product.  There aren't actually any of these, but we keep it just
-+    for consistency.
-+    """
-+    return []
-+
-+
-+def shapes_binary_matmul(dim=100):
-+    """
-+    Allowed shapes for "matmul"-like operators that require that the "inner"
-+    two indices are equal, i.e. the columns on the left equal the rows on the
-+    right.
-+    """
-+    return [
-+        (x, y)
-+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-+        if x.values[0][1] == y.values[0][0]
-+    ]
-+
-+
-+def shapes_binary_bad_matmul(dim=100):
-+    """
-+    Disallowed shapes for "matmul"-like operators that require that the "inner"
-+    two indices are equal, i.e. the columns on the left equal the rows on the
-+    right.
-+    """
-+    return [
-+        (x, y)
-+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-+        if x.values[0][1] != y.values[0][0]
-+    ]
-+
-+
-+def shapes_square(dim=100):
-+    """Allowed shapes for operations that require square matrices. Examples of
-+    these operations are trace, pow, expm and the trace norm."""
-+    return [
-+        (pytest.param((1, 1), id="1"),),
-+        (pytest.param((dim, dim), id=str(dim)),),
-+    ]
-+
-+
-+def shapes_not_square(dim=100):
-+    """Disallowed shapes for operations that require square matrices. Examples
-+    of these operations are trace, pow, expm and the trace norm."""
-+    return [
-+        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
-+    ]
-+
-+
-+# Set up the special cases for each type of matrix that will be tested.  These
-+# should be kept low, because mathematical operations will test a Cartesian
-+# product of all the cases of the same order as the operation, which can get
-+# very large very fast.  The operations should each complete in a small amount
-+# of time, so having 10000+ tests in this file still ought to take less than 2
-+# minutes, but it's easy to accidentally add orders of magnitude on.
-+#
-+# There is a layer of indirection---the cases are returned as 0-ary generator
-+# closures---for two reasons:
-+#   1. we don't have to store huge amounts of data at test collection time, but
-+#      the matrices are only generated, and subsequently freed, within in each
-+#      individual test.
-+#   2. each test can be repeated, and new random matrices will be generated for
-+#      each repeat, rather than re-using the same set.  This is somewhat
-+#      "defeating" pytest fixtures, but here we're not worried about re-usable
-+#      inputs, we just want the managed parametrisation.
-+
-+def cases_csr(shape):
-+    """
-+    Return a list of generators of the different special cases for CSR
-+    matrices of a given shape.
-+    """
-+    def factory(density, sort):
-+        return lambda: conftest.random_csr(shape, density, sort)
-+
-+    def zero_factory():
-+        return lambda: data.csr.zeros(shape[0], shape[1])
-+    return [
-+        pytest.param(factory(0.001, True), id="sparse"),
-+        pytest.param(factory(0.8, True), id="filled,sorted"),
-+        pytest.param(factory(0.8, False), id="filled,unsorted"),
-+        pytest.param(zero_factory(), id="zero"),
-+    ]
-+
-+
-+def cases_dense(shape):
-+    """
-+    Return a list of generators of the different special cases for Dense
-+    matrices of a given shape.
-+    """
-+    def factory(fortran):
-+        return lambda: conftest.random_dense(shape, fortran)
-+    return [
-+        pytest.param(factory(False), id="C"),
-+        pytest.param(factory(True), id="Fortran"),
-+    ]
-+
-+
-+# Factory methods for generating the cases, mapping type to the function.
-+# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
-+# getting just a single case from each.
-+_ALL_CASES = {
-+    CSR: cases_csr,
-+    Dense: cases_dense,
-+}
-+_RANDOM = {
-+    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
-+    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
-+}
-+
-+
-+def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
-+    """
-+    Return a list of `pytest.ParameterSet` which is a flat list of all the
-+    special cases that should be tested for this operator specialisation `op`,
-+    which takes in several types `types`, where the arguments have shapes taken
-+    from the iterable of iterables `shapes`.  If `out_type` is specified, it
-+    will be added into the output parameter set and its name added to the id,
-+    but is otherwise not used.
-+
-+    Parameters
-+    ----------
-+    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
-+        Mapping to get the special case generator from.  This is one of
-+        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
-+        from the case generator should all be closures of the form `() -> Data`
-+        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
-+        containing exactly one value, which is the same closure type.
-+
-+    op: Function
-+        The specialisation of a mathematical operation that is being tested.
-+        This is actually generally unused - it's just added in to the output
-+        ParameterSet at the end so that it will get correctly parametrised.
-+
-+    types: Tuple[Type]
-+        A tuple of data.Data subclass types (not instances).  This defines the
-+        inputs to this particular specialisation under test.  There should be
-+        as many types as there are Data arguments to `op`.
-+
-+    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
-+        An iterable containing several sets of shapes to parameterise over.
-+        Each element of the iterable should be s tuple of shapes, or
-+        `pytest.ParameterSet` instances each containing a single shape.  A
-+        shape is a 2-tuple of integers.  There should be as many elements of
-+        this inner tuple as there are `types`, since each individual `shape`
-+        goes with a `type`.
-+
-+    out_type: Type
-+        The output type for this specialisation.  Not used other than its name
-+        being added to the id, and it being added at the end of the
-+        specialisation (if it is given), similarly to `op`.
-+
-+    Returns
-+    -------
-+    List[ParameterSet]
-+        A list of individual test cases for parametrisation.  Each ParameterSet
-+        will be
-+            [op, *data_inputs, ?out_type]
-+        where `data_inputs` is of the same length as the input parameter
-+        `types` and represents the Data arguments to the specialisation `op`.
-+        Each element of `data_inputs` is a generator function which takes no
-+        arguments and returns a data.Data subclass of the correct type and
-+        shape.  `out_type` is present in the output only if it were given as a
-+        parameter itself.
-+    """
-+    def case(type_, shape_case, generator_case):
-+        """
-+        Build a case parameter for _one_ generator function which will return
-+        a given type and shape.
-+        """
-+        id_ = type_.__name__
-+        inner = ""
-+        for extra in [shape_case, generator_case]:
-+            if hasattr(extra, 'id') and extra.id:
-+                inner += ("," if inner else "") + extra.id
-+        if inner:
-+            id_ += "[" + inner + "]"
-+        func = (
-+            generator_case.values[0]
-+            if isinstance(generator_case, _ParameterSet)
-+            else generator_case
-+        )
-+        return pytest.param(func, id=id_)
-+
-+    cases = []
-+    for shapes_ in shapes:
-+        # Convert the list of types into a list of lists of the special cases
-+        # needed for each type.
-+        matrix_cases = [
-+            [case(type_, shape_case, type_case)
-+             for type_case in cases_lookup[type_](shape_case.values[0])]
-+            for type_, shape_case in zip(types, shapes_)
-+        ]
-+        # Now Cartesian product all the special cases together to make the full
-+        # set of parametrisations.
-+        for matrices in itertools.product(*matrix_cases):
-+            id_ = ",".join(m.id for m in matrices)
-+            args = [m for p_m in matrices for m in p_m.values]
-+            if out_type is not None:
-+                id_ += "->" + out_type.__name__
-+                args += [out_type]
-+            cases.append(pytest.param(op, *args, id=id_))
-+    return cases
-+
-+
-+# Now we start to actually build up all the test cases.  Since all the
-+# mathematical operations are really pretty similar, and most just need the
-+# basic testing functionality, we do this with a series of mix-in classes which
-+# provide various components of the testing and test-generation infrastructure.
-+#
-+# In each, we use the idiom that "test_<x>" is a test function which pytest
-+# will collect for us, and "generate_<x>" a method which will be called by
-+# `pytest_generate_tests` in order to generate all the parametrisations for the
-+# given test.
-+
-+class _GenericOpMixin:
-+    """
-+    Abstract base mix-in which sets up the test generation for the two basic
-+    test operations, and puts in the very generic test generator.  This does
-+    not actually define the tests themselves, because subclasses need to define
-+    them so the method arguments can be introspected to parametrise over the
-+    correct number of arguments.
-+
-+    The tests `mathematically_correct` and `incorrect_shape_raises` will
-+    parametrise Data types over method arguments which have names `data_*`.
-+
-+    The class arguments defined here are effectively parametrising the
-+    mathematical tests.
-+
-+    Attributes
-+    ----------
-+    op_numpy: *args -> np.ndarray
-+        Function which takes the same arguments as the mathematical operation,
-+        but with all data arguments numpy arrays, and returns the expected
-+        result.
-+
-+    atol: float
-+        The absolute tolerance to use when comparing the test value with the
-+        expected value.  If the output is a Data type, the tolerance is
-+        per-element of the output.
-+
-+    rtol: float
-+        The relative tolerance to use when comparing the test value with the
-+        expected value.  If the output is a Data type, the tolerance is
-+        per-element of the output.
-+
-+    shapes: list of (list of shapes)
-+        A list of the sets of shapes which should be used for the tests of
-+        mathematical correctness.  Each element of the list is a set of shapes,
-+        each one corresponding to one of the arguments of the operation.
-+
-+    bad_shapes: list of (list of shapes)
-+        Similar to `shapes`, but these should be shapes which are invalid for
-+        the given mathematical operation.
-+
-+    specialisations: list of (function, Type, Type, [Type, ...])
-+        The specialisations of each mathematical function, and the types that
-+        it takes in and returns.  For example, the function
-+            add(CSR, Dense) -> Other
-+        would be specified as `(add, CSR, Dense, Other)`.
-+    """
-+    def op_numpy(self, *args): raise NotImplementedError
-+    # With dimensions of around 100, we have to account for floating-point
-+    # addition not being associative; the maths on full numpy arrays will often
-+    # produce slightly different results to sparse algebra, since the order of
-+    # multiplications and additions will be different.
-+    atol = 1e-10
-+    rtol = 1e-7  # Same default as numpy
-+    shapes = []
-+    bad_shapes = []
-+    specialisations = []
-+
-+    def generate_mathematically_correct(self, metafunc):
-+        parameters = (
-+            ['op']
-+            + [x for x in metafunc.fixturenames
-+               if x.startswith("data_")]
-+            + ['out_type']
-+        )
-+        cases = []
-+        for p_op in self.specialisations:
-+            op, *types, out_type = p_op.values
-+            args = (op, types, self.shapes, out_type)
-+            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
-+        metafunc.parametrize(parameters, cases)
-+
-+    def generate_incorrect_shape_raises(self, metafunc):
-+        parameters = (
-+            ['op']
-+            + [x for x in metafunc.fixturenames
-+               if x.startswith("data_")]
-+        )
-+        if not self.bad_shapes:
-+            reason = "".join([
-+                "no shapes are 'incorrect' for ",
-+                metafunc.cls.__name__,
-+                "::",
-+                metafunc.function.__name__,
-+            ])
-+            false_case = pytest.param(*([None]*len(parameters)),
-+                                      marks=pytest.mark.skip(reason),
-+                                      id="no test")
-+            metafunc.parametrize(parameters, [false_case])
-+            return
-+        cases = []
-+        for p_op in self.specialisations:
-+            op, *types, _ = p_op.values
-+            args = (op, types, self.bad_shapes)
-+            cases.extend(cases_type_shape_product(_RANDOM, *args))
-+        metafunc.parametrize(parameters, cases)
-+
-+    def pytest_generate_tests(self, metafunc):
-+        # For every test function "test_xyz", we use the test generator
-+        # "generate_xyz" if it exists.  This allows derived classes to add
-+        # their own tests and generators without overiding this method, cutting
-+        # down on boilerplate, but also that derived classes _may_ override the
-+        # generation of tests defined in a base class, say if they have
-+        # additional special arguments that need parametrising over.
-+        generator_name = (
-+            "generate_"
-+            + metafunc.function.__name__.replace("test_", "")
-+        )
-+        try:
-+            generator = getattr(self, generator_name)
-+        except AttributeError:
-+            return
-+        generator(metafunc)
-+
-+
-+class UnaryOpMixin(_GenericOpMixin):
-+    """
-+    Mix-in for unary mathematical operations on Data instances (e.g. unary
-+    negation).
-+    """
-+    shapes = [(x,) for x in shapes_unary()]
-+    bad_shapes = []
-+
-+    def test_mathematically_correct(self, op, data_m, out_type):
-+        matrix = data_m()
-+        expected = self.op_numpy(matrix.to_array())
-+        test = op(matrix)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol, rtol=self.rtol)
-+        elif out_type is list:
-+            for test_, expected_ in zip(test, expected):
-+                assert test_.shape == expected_.shape
-+                np.testing.assert_allclose(test_.to_array(), expected_,
-+                                           atol=self.atol, rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+    def test_incorrect_shape_raises(self, op, data_m):
-+        """
-+        Test that the operation produces a suitable error if the shape of the
-+        given operand is not compatible with the operation. Useful for
-+        operations that require square matrices (trace, pow, ...).
-+        """
-+        with pytest.raises(ValueError):
-+            op(data_m())
-+
-+
-+class UnaryScalarOpMixin(_GenericOpMixin):
-+    """
-+    Mix-in for unary mathematical operations on Data instances, but that also
-+    take in a numeric scalar (e.g. scalar multiplication).  Only generates
-+    the test `mathematically_correct`, since there can't be a shape mismatch
-+    when there's only one Data argument.
-+    """
-+    shapes = [(x,) for x in shapes_unary()]
-+
-+    @pytest.mark.parametrize('scalar', [
-+        pytest.param(0, id='zero'),
-+        pytest.param(4.5, id='real'),
-+        pytest.param(3j, id='complex'),
-+    ])
-+    def test_mathematically_correct(self, op, data_m, scalar, out_type):
-+        matrix = data_m()
-+        expected = self.op_numpy(matrix.to_array(), scalar)
-+        test = op(matrix, scalar)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol,
-+                                       rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+
-+class BinaryOpMixin(_GenericOpMixin):
-+    """
-+    Mix-in for binary mathematical operations on Data instances (e.g. binary
-+    addition).
-+    """
-+    def test_mathematically_correct(self, op, data_l, data_r, out_type):
-+        """
-+        Test that the binary operation is mathematically correct for all the
-+        known type specialisations.
-+        """
-+        left, right = data_l(), data_r()
-+        expected = self.op_numpy(left.to_array(), right.to_array())
-+        test = op(left, right)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol, rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+    def test_incorrect_shape_raises(self, op, data_l, data_r):
-+        """
-+        Test that the operation produces a suitable error if the shapes of the
-+        given operands are not compatible.
-+        """
-+        with pytest.raises(ValueError):
-+            op(data_l(), data_r())
-+
-+
-+class TernaryOpMixin(_GenericOpMixin):
-+    """
-+    Mix-in for ternary mathematical operations on Data instances (e.g. inner
-+    product with an operator in the middle).  This is pretty rare.
-+    """
-+    def test_mathematically_correct(self, op,
-+                                    data_l, data_m, data_r,
-+                                    out_type):
-+        """
-+        Test that the binary operation is mathematically correct for all the
-+        known type specialisations.
-+        """
-+        left, mid, right = data_l(), data_m(), data_r()
-+        expected = self.op_numpy(left.to_array(),
-+                                 mid.to_array(),
-+                                 right.to_array())
-+        test = op(left, mid, right)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol, rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
-+        """
-+        Test that the operation produces a suitable error if the shapes of the
-+        given operands are not compatible.
-+        """
-+        with pytest.raises(ValueError):
-+            op(data_l(), data_m(), data_r())
-+
-+
-+# And now finally we get into the meat of the actual mathematical tests.
-+
-+class TestAdd(BinaryOpMixin):
-+    def op_numpy(self, left, right, scale):
-+        return np.add(left, scale * right)
-+
-+    shapes = shapes_binary_identical()
-+    bad_shapes = shapes_binary_bad_identical()
-+    specialisations = [
-+        pytest.param(data.add_csr, CSR, CSR, CSR),
-+        pytest.param(data.add_dense, Dense, Dense, Dense),
-+    ]
-+
-+    # `add` has an additional scalar parameter, because the operation is
-+    # actually more like `A + c*B`.  We just parametrise that scalar
-+    # separately.
-+    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
-+                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
-+    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
-+        """
-+        Test that the binary operation is mathematically correct for all the
-+        known type specialisations.
-+        """
-+        left, right = data_l(), data_r()
-+        if scale is not None:
-+            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
-+            test = op(left, right, scale)
-+        else:
-+            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
-+            test = op(left, right)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol, rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+
-+class TestAdjoint(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return np.conj(matrix.T)
-+
-+    specialisations = [
-+        pytest.param(data.adjoint_csr, CSR, CSR),
-+        pytest.param(data.adjoint_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestConj(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return np.conj(matrix)
-+
-+    specialisations = [
-+        pytest.param(data.conj_csr, CSR, CSR),
-+        pytest.param(data.conj_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestInner(BinaryOpMixin):
-+    # The inner product is a bit more specialist, since it has to handle inputs
-+    # in a 1D space specially.  In order to keep things simple, we just
-+    # generate those test cases completely separately from the standard
-+    # `mathematically_correct`.
-+
-+    def op_numpy(self, left, right, scalar_is_ket=False):
-+        if left.shape[1] == 1:
-+            if left.shape[0] != 1 or scalar_is_ket:
-+                left = np.conj(left.T)
-+        return (left @ right)[0, 0]
-+
-+    # These shapes are a little more non-standard.
-+    _dim = 100
-+    _scalar = pytest.param((1, 1), id="scalar")
-+    _bra = pytest.param((1, _dim), id="bra")
-+    _ket = pytest.param((_dim, 1), id="ket")
-+    _op = pytest.param((_dim, _dim), id="square")
-+    shapes = [
-+        (_bra, _ket),
-+        (_ket, _ket),
-+    ]
-+    bad_shapes = [
-+        (_bra, _bra),
-+        (_ket, _bra),
-+        (_op, _ket),
-+        (_op, _bra),
-+        (_bra, _op),
-+        (_ket, _op),
-+    ]
-+
-+    specialisations = [
-+        pytest.param(data.inner_csr, CSR, CSR, complex),
-+        pytest.param(data.inner_dense, Dense, Dense, complex),
-+    ]
-+
-+    def generate_scalar_is_ket(self, metafunc):
-+        # For 1D subspaces, the special cases don't really matter since there's
-+        # only really one type of matrix available, so this is parametrised
-+        # with only case for each input argument.
-+        parameters = (
-+            ['op']
-+            + [x for x in metafunc.fixturenames
-+               if x.startswith("data_")]
-+            + ['out_type']
-+        )
-+        cases = []
-+        for p_op in self.specialisations:
-+            op, *types, out_type = p_op.values
-+            args = (op, types, [(self._scalar, self._scalar)], out_type)
-+            cases.extend(cases_type_shape_product(_RANDOM, *args))
-+        metafunc.parametrize(parameters, cases)
-+        metafunc.parametrize('scalar_is_ket',
-+                             [True, False],
-+                             ids=["ket", "bra"])
-+
-+    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
-+        left, right = data_l(), data_r()
-+        expected = self.op_numpy(left.to_array(), right.to_array(),
-+                                 scalar_is_ket)
-+        test = op(left, right, scalar_is_ket)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol, rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+
-+class TestInnerOp(TernaryOpMixin):
-+    # This is very very similar to TestInner.
-+    def op_numpy(self, left, mid, right, scalar_is_ket=False):
-+        if left.shape[1] == 1:
-+            if left.shape[0] != 1 or scalar_is_ket:
-+                left = np.conj(left.T)
-+        return (left @ mid @ right)[0, 0]
-+
-+    _dim = 100
-+    _scalar = pytest.param((1, 1), id="scalar")
-+    _bra = pytest.param((1, _dim), id="bra")
-+    _ket = pytest.param((_dim, 1), id="ket")
-+    _op = pytest.param((_dim, _dim), id="square")
-+    shapes = [
-+        (_bra, _op, _ket),
-+        (_ket, _op, _ket),
-+    ]
-+    bad_shapes = [
-+        (_bra, _op, _bra),
-+        (_ket, _op, _bra),
-+        (_op, _op, _ket),
-+        (_op, _op, _bra),
-+        (_bra, _op, _op),
-+        (_ket, _op, _op),
-+        (_bra, _bra, _ket),
-+        (_ket, _bra, _ket),
-+        (_bra, _ket, _ket),
-+        (_ket, _ket, _ket),
-+    ]
-+
-+    specialisations = [
-+        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
-+        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
-+    ]
-+
-+    def generate_scalar_is_ket(self, metafunc):
-+        parameters = (
-+            ['op']
-+            + [x for x in metafunc.fixturenames
-+               if x.startswith("data_")]
-+            + ['out_type']
-+        )
-+        cases = []
-+        for p_op in self.specialisations:
-+            op, *types, out_type = p_op.values
-+            args = (op, types, [(self._scalar,) * 3], out_type)
-+            cases.extend(cases_type_shape_product(_RANDOM, *args))
-+        metafunc.parametrize(parameters, cases)
-+        metafunc.parametrize('scalar_is_ket',
-+                             [True, False], ids=["ket", "bra"])
-+
-+    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
-+                           scalar_is_ket):
-+        left, mid, right = data_l(), data_m(), data_r()
-+        expected = self.op_numpy(left.to_array(),
-+                                 mid.to_array(),
-+                                 right.to_array(),
-+                                 scalar_is_ket)
-+        test = op(left, mid, right, scalar_is_ket)
-+        assert isinstance(test, out_type)
-+        if issubclass(out_type, Data):
-+            assert test.shape == expected.shape
-+            np.testing.assert_allclose(test.to_array(), expected,
-+                                       atol=self.atol,
-+                                       rtol=self.rtol)
-+        else:
-+            np.testing.assert_allclose(test, expected, atol=self.atol,
-+                                       rtol=self.rtol)
-+
-+
-+class TestKron(BinaryOpMixin):
-+    def op_numpy(self, left, right):
-+        return np.kron(left, right)
-+
-+    # Keep the dimension low because kron can get very expensive.
-+    shapes = shapes_binary_unrestricted(dim=5)
-+    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
-+    specialisations = [
-+        pytest.param(data.kron_csr, CSR, CSR, CSR),
-+        pytest.param(data.kron_dense, Dense, Dense, Dense),
-+    ]
-+
-+
-+class TestMatmul(BinaryOpMixin):
-+    def op_numpy(self, left, right):
-+        return np.matmul(left, right)
-+
-+    shapes = shapes_binary_matmul()
-+    bad_shapes = shapes_binary_bad_matmul()
-+    specialisations = [
-+        pytest.param(data.matmul_csr, CSR, CSR, CSR),
-+        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
-+        pytest.param(data.matmul_dense, Dense, Dense, Dense),
-+    ]
-+
-+
-+class TestMultiply(BinaryOpMixin):
-+    def op_numpy(self, left, right):
-+        return left * right
-+
-+    shapes = shapes_binary_identical()
-+    bad_shapes = shapes_binary_bad_identical()
-+    specialisations = [
-+        pytest.param(data.multiply_csr, CSR, CSR, CSR),
-+        pytest.param(data.multiply_dense, Dense, Dense, Dense),
-+    ]
-+
-+
-+class TestMul(UnaryScalarOpMixin):
-+    def op_numpy(self, matrix, scalar):
-+        return scalar * matrix
-+
-+    specialisations = [
-+        pytest.param(data.mul_csr, CSR, CSR),
-+        pytest.param(data.mul_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestNeg(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return -matrix
-+
-+    specialisations = [
-+        pytest.param(data.neg_csr, CSR, CSR),
-+        pytest.param(data.neg_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestSub(BinaryOpMixin):
-+    def op_numpy(self, left, right):
-+        return left - right
-+
-+    shapes = shapes_binary_identical()
-+    bad_shapes = shapes_binary_bad_identical()
-+    specialisations = [
-+        pytest.param(data.sub_csr, CSR, CSR, CSR),
-+        pytest.param(data.sub_dense, Dense, Dense, Dense),
-+    ]
-+
-+
-+class TestTrace(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return np.sum(np.diag(matrix))
-+
-+    shapes = shapes_square()
-+    bad_shapes = shapes_not_square()
-+    specialisations = [
-+        pytest.param(data.trace_csr, CSR, complex),
-+        pytest.param(data.trace_dense, Dense, complex),
-+    ]
-+
-+
-+class TestTrace_oper_ket(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        N = int(matrix.shape[0] ** 0.5)
-+        return np.sum(np.diag(matrix.reshape((N, N))))
-+
-+    shapes = [
-+        (pytest.param((100, 1), id="oper-ket"),),
-+    ]
-+    bad_shapes = [
-+        (pytest.param((1, 100), id="bra"),),
-+        (pytest.param((99, 1), id="ket"),),
-+        (pytest.param((99, 99), id="ket"),),
-+        (pytest.param((2, 99), id="nonsquare"),),
-+    ]
-+    specialisations = [
-+        pytest.param(data.trace_oper_ket_csr, CSR, complex),
-+        pytest.param(data.trace_oper_ket_dense, Dense, complex),
-+    ]
-+
-+
-+class TestPow(UnaryOpMixin):
-+    def op_numpy(self, matrix, n):
-+        return np.linalg.matrix_power(matrix, n)
-+
-+    shapes = shapes_square()
-+    bad_shapes = shapes_not_square()
-+    specialisations = [
-+        pytest.param(data.pow_csr, CSR, CSR),
-+        pytest.param(data.pow_dense, Dense, Dense),
-+    ]
-+
-+    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
-+    def test_mathematically_correct(self, op, data_m, out_type, n):
-+        matrix = data_m()
-+        expected = self.op_numpy(matrix.to_array(), n)
-+        test = op(matrix, n)
-+        assert isinstance(test, out_type)
-+        assert test.shape == expected.shape
-+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-+                                   rtol=self.rtol)
-+
-+    # Pow actually does have bad shape, so we put that in too.
-+    def test_incorrect_shape_raises(self, op, data_m):
-+        """
-+        Test that the operation produces a suitable error if the shape is not a
-+        square matrix.
-+        """
-+        with pytest.raises(ValueError):
-+            op(data_m(), 10)
-+
-+
-+class TestExpm(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return scipy.linalg.expm(matrix)
-+
-+    shapes = shapes_square()
-+    bad_shapes = shapes_not_square()
-+    specialisations = [
-+        pytest.param(data.expm_csr, CSR, CSR),
-+        pytest.param(data.expm_csr_dense, CSR, Dense),
-+        pytest.param(data.expm_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestLogm(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return scipy.linalg.logm(matrix)
-+
-+    shapes = shapes_square()
-+    bad_shapes = shapes_not_square()
-+    specialisations = [
-+        pytest.param(data.logm_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestTranspose(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return matrix.T
-+
-+    specialisations = [
-+        pytest.param(data.transpose_csr, CSR, CSR),
-+        pytest.param(data.transpose_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestProject(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        if matrix.shape[0] == 1:
-+            return np.outer(np.conj(matrix), matrix)
-+        else:
-+            return np.outer(matrix, np.conj(matrix))
-+
-+    shapes = [
-+        (pytest.param((1, 1), id="scalar"),),
-+        (pytest.param((1, 100), id="bra"),),
-+        (pytest.param((100, 1), id="ket"),),
-+    ]
-+    bad_shapes = [
-+        (pytest.param((10, 10), id="square"),),
-+        (pytest.param((2, 10), id="nonsquare"),),
-+    ]
-+
-+    specialisations = [
-+        pytest.param(data.project_csr, CSR, CSR),
-+        pytest.param(data.project_dense, Dense, Dense),
-+    ]
-+
-+
-+def _inv_dense(matrix):
-+    # Add a diagonal so `matrix` is not singular
-+    return data.inv_dense(
-+        data.add(
-+            matrix,
-+            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
-+        )
-+    )
-+
-+
-+def _inv_csr(matrix):
-+    # Add a diagonal so `matrix` is not singular
-+    return data.inv_csr(
-+        data.add(
-+            matrix,
-+            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
-+        )
-+    )
-+
-+
-+class TestInv(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
-+
-+    shapes = [
-+        (pytest.param((1, 1), id="scalar"),),
-+        (pytest.param((10, 10), id="square"),),
-+    ]
-+    bad_shapes = [
-+        (pytest.param((2, 10), id="nonsquare"),),
-+        (pytest.param((1, 100), id="bra"),),
-+        (pytest.param((100, 1), id="ket"),),
-+    ]
-+
-+    specialisations = [
-+        pytest.param(_inv_csr, CSR, CSR),
-+        pytest.param(_inv_dense, Dense, Dense),
-+    ]
-diff --git a/qutip/tests/core/data/test_norm.py b/qutip/tests/core/data/test_norm.py
-index d285bb3e..7abac872 100644
---- a/qutip/tests/core/data/test_norm.py
-+++ b/qutip/tests/core/data/test_norm.py
-@@ -1,69 +1,69 @@
--from . import test_mathematics as testing
--import numpy as np
--import scipy.linalg
--import pytest
--from qutip import data
--from qutip.core.data import CSR, Dense
--import numbers
--
--
--class TestOneNorm(testing.UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return scipy.linalg.norm(matrix, 1)
--
--    specialisations = [
--        pytest.param(data.norm.one_csr, CSR, numbers.Number),
--        pytest.param(data.norm.one_dense, Dense, numbers.Number),
--    ]
--
--
--class TestFrobeniusNorm(testing.UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return scipy.linalg.norm(matrix, 'fro')
--
--    specialisations = [
--        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
--        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
--    ]
--
--
--class TestMaxNorm(testing.UnaryOpMixin):
--    def op_numpy(self, matrix):
--        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
--        # works differently for matrices.
--        return np.max(np.abs(matrix))
--
--    specialisations = [
--        pytest.param(data.norm.max_csr, CSR, numbers.Number),
--        pytest.param(data.norm.max_dense, Dense, numbers.Number),
--    ]
--
--
--class TestL2Norm(testing.UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return scipy.linalg.norm(matrix, 'fro')
--
--    # These shapes correspond to kets or bras
--    shapes = [
--        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
--                                                 or x.values[0][1] == 1)
--    ]
--    # These shapes are everything except for kets and bras
--    bad_shapes = [
--        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
--                                                     or x.values[0][1] == 1)
--    ]
--    specialisations = [
--        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
--        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
--    ]
--
--
--class TestTraceNorm(testing.UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return np.linalg.svd(matrix)[1].sum()
--
--    specialisations = [
--        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
--        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
--    ]
-+from . import test_mathematics as testing
-+import numpy as np
-+import scipy.linalg
-+import pytest
-+from qutip import data
-+from qutip.core.data import CSR, Dense
-+import numbers
-+
-+
-+class TestOneNorm(testing.UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return scipy.linalg.norm(matrix, 1)
-+
-+    specialisations = [
-+        pytest.param(data.norm.one_csr, CSR, numbers.Number),
-+        pytest.param(data.norm.one_dense, Dense, numbers.Number),
-+    ]
-+
-+
-+class TestFrobeniusNorm(testing.UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return scipy.linalg.norm(matrix, 'fro')
-+
-+    specialisations = [
-+        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
-+        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
-+    ]
-+
-+
-+class TestMaxNorm(testing.UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
-+        # works differently for matrices.
-+        return np.max(np.abs(matrix))
-+
-+    specialisations = [
-+        pytest.param(data.norm.max_csr, CSR, numbers.Number),
-+        pytest.param(data.norm.max_dense, Dense, numbers.Number),
-+    ]
-+
-+
-+class TestL2Norm(testing.UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return scipy.linalg.norm(matrix, 'fro')
-+
-+    # These shapes correspond to kets or bras
-+    shapes = [
-+        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
-+                                                 or x.values[0][1] == 1)
-+    ]
-+    # These shapes are everything except for kets and bras
-+    bad_shapes = [
-+        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
-+                                                     or x.values[0][1] == 1)
-+    ]
-+    specialisations = [
-+        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
-+        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
-+    ]
-+
-+
-+class TestTraceNorm(testing.UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return np.linalg.svd(matrix)[1].sum()
-+
-+    specialisations = [
-+        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
-+        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
-+    ]
-diff --git a/qutip/tests/core/data/test_operators.py b/qutip/tests/core/data/test_operators.py
-index 4416629b..eb2a7507 100644
---- a/qutip/tests/core/data/test_operators.py
-+++ b/qutip/tests/core/data/test_operators.py
-@@ -1,69 +1,69 @@
--import pytest
--import numpy
--import qutip
--from qutip.core import data as _data
--from qutip import settings
--
--
--@pytest.mark.parametrize('type_left', _data.to.dtypes)
--@pytest.mark.parametrize('type_right', _data.to.dtypes)
--@pytest.mark.parametrize(['operator', 'dispatch'], [
--    pytest.param(lambda left, right: left + right, _data.add, id="add"),
--    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
--    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
--])
--def test_data_binary_operator(type_left, type_right, operator, dispatch):
--    left = qutip.rand_dm(5, dtype=type_left).data
--    right = qutip.rand_dm(5, dtype=type_right).data
--    numpy.testing.assert_allclose(
--        operator(left, right).to_array(),
--        dispatch(left, right).to_array(),
--        rtol=1e-15
--    )
--
--
--@pytest.mark.parametrize('type_', _data.to.dtypes)
--@pytest.mark.parametrize(['operator', 'dispatch'], [
--    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
--    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
--    pytest.param(lambda data, number: data / number,
--                 lambda data, number: _data.mul(data, 1/number), id="div"),
--])
--def test_data_scalar_operator(type_, operator, dispatch):
--    data = qutip.qeye(2, dtype=type_).data
--    number = 3
--    numpy.testing.assert_allclose(
--        operator(data, number).to_array(),
--        dispatch(data, number).to_array(),
--        rtol=1e-15
--    )
--
--
--@pytest.mark.parametrize('type_', _data.to.dtypes)
--def test_data_neg_operator(type_):
--    data = qutip.qeye(2, dtype=type_).data
--    numpy.testing.assert_allclose(
--        (-data).to_array(), -data.to_array(), rtol=1e-15
--    )
--
--
--@pytest.mark.parametrize('type_left', _data.to.dtypes)
--@pytest.mark.parametrize('type_right', _data.to.dtypes)
--def test_data_eq_operator(type_left, type_right):
--    mat = qutip.rand_dm(5)
--    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
--
--    left = mat.to(type_left).data
--    right = mat.to(type_right).data
--    assert left == right
--    right = (mat + noise).to(type_right).data
--    assert left == right
--
--    right = (mat + noise * 100).to(type_right).data
--    assert left != right
--
--    right = qutip.operator_to_vector(mat).to(type_right).data
--    assert left != right
--
--    assert left != mat
--    assert numpy.all(left != mat.full())
-+import pytest
-+import numpy
-+import qutip
-+from qutip.core import data as _data
-+from qutip import settings
-+
-+
-+@pytest.mark.parametrize('type_left', _data.to.dtypes)
-+@pytest.mark.parametrize('type_right', _data.to.dtypes)
-+@pytest.mark.parametrize(['operator', 'dispatch'], [
-+    pytest.param(lambda left, right: left + right, _data.add, id="add"),
-+    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
-+    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
-+])
-+def test_data_binary_operator(type_left, type_right, operator, dispatch):
-+    left = qutip.rand_dm(5, dtype=type_left).data
-+    right = qutip.rand_dm(5, dtype=type_right).data
-+    numpy.testing.assert_allclose(
-+        operator(left, right).to_array(),
-+        dispatch(left, right).to_array(),
-+        rtol=1e-15
-+    )
-+
-+
-+@pytest.mark.parametrize('type_', _data.to.dtypes)
-+@pytest.mark.parametrize(['operator', 'dispatch'], [
-+    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
-+    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
-+    pytest.param(lambda data, number: data / number,
-+                 lambda data, number: _data.mul(data, 1/number), id="div"),
-+])
-+def test_data_scalar_operator(type_, operator, dispatch):
-+    data = qutip.qeye(2, dtype=type_).data
-+    number = 3
-+    numpy.testing.assert_allclose(
-+        operator(data, number).to_array(),
-+        dispatch(data, number).to_array(),
-+        rtol=1e-15
-+    )
-+
-+
-+@pytest.mark.parametrize('type_', _data.to.dtypes)
-+def test_data_neg_operator(type_):
-+    data = qutip.qeye(2, dtype=type_).data
-+    numpy.testing.assert_allclose(
-+        (-data).to_array(), -data.to_array(), rtol=1e-15
-+    )
-+
-+
-+@pytest.mark.parametrize('type_left', _data.to.dtypes)
-+@pytest.mark.parametrize('type_right', _data.to.dtypes)
-+def test_data_eq_operator(type_left, type_right):
-+    mat = qutip.rand_dm(5)
-+    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
-+
-+    left = mat.to(type_left).data
-+    right = mat.to(type_right).data
-+    assert left == right
-+    right = (mat + noise).to(type_right).data
-+    assert left == right
-+
-+    right = (mat + noise * 100).to(type_right).data
-+    assert left != right
-+
-+    right = qutip.operator_to_vector(mat).to(type_right).data
-+    assert left != right
-+
-+    assert left != mat
-+    assert numpy.all(left != mat.full())
-diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
-index de844bae..124d7d2f 100644
---- a/qutip/tests/core/data/test_properties.py
-+++ b/qutip/tests/core/data/test_properties.py
-@@ -1,175 +1,175 @@
--import numpy as np
--import pytest
--
--from qutip import data as _data
--
--
--@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
--def datatype(request):
--    return request.param
--
--
--class Test_isherm:
--    tol = 1e-12
--
--    @pytest.mark.repeat(20)
--    @pytest.mark.parametrize("density", (0.1, 0.8))
--    @pytest.mark.parametrize("size", (10, 100))
--    def test_random_equal_structure(self, datatype, size, density):
--        # This is only going to be approximate, as entries generated onto the
--        # diagonal will fill only one slot, not two, after addition with the
--        # transpose.  The densities are arbitrary, though, so this doesn't
--        # matter much.
--        nnz = int(0.5 * size*size * density) or 1
--        indices = np.triu_indices(size)
--        choice = np.random.choice(indices[0].size, nnz, replace=False)
--        indices = (indices[0][choice], indices[1][choice])
--
--        # Real-symmetric matrices.
--        base = np.zeros((size, size), dtype=np.complex128)
--        base[indices] = np.random.rand(nnz)
--        base += base.T.conj()
--        base = _data.to(datatype, _data.create(base))
--        assert _data.isherm(base)
--
--        # Complex Hermitian matrices
--        base = np.zeros((size, size), dtype=np.complex128)
--        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
--        base += base.T.conj()
--        base = _data.to(datatype, _data.create(base))
--        assert _data.isherm(base)
--
--        # Complex skew-Hermitian matrices
--        base = np.zeros((size, size), dtype=np.complex128)
--        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
--        base += base.T
--        base = _data.to(datatype, _data.create(base))
--        assert not _data.isherm(base)
--
--    @pytest.mark.parametrize("cols", (2, 4))
--    @pytest.mark.parametrize("rows", (1, 5))
--    def test_nonsquare_shapes(self, datatype, rows, cols):
--        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
--        assert not _data.isherm(real, self.tol)
--        assert not _data.isherm(real.transpose(), self.tol)
--
--        imag = _data.to(
--            datatype,
--            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
--        )
--        assert not _data.isherm(imag, self.tol)
--        assert not _data.isherm(imag.transpose(), self.tol)
--
--    def test_diagonal_elements(self, datatype):
--        n = 10
--        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
--        assert _data.isherm(base, tol=self.tol)
--        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
--
--    def test_compare_implicit_zero_structure(self, datatype):
--        """
--        Regression test for gh-1350, comparing explicitly stored values in the
--        matrix (but below the tolerance for allowable Hermicity) to implicit
--        zeros.
--        """
--
--        base = _data.to(
--            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
--        )
--        # If this first line fails, the zero has been stored explicitly and so
--        # the test is invalid.
--        assert np.count_nonzero(base.to_array()) == 3
--        assert _data.isherm(base, tol=self.tol)
--        assert _data.isherm(base.transpose(), tol=self.tol)
--
--        # A similar test if the structures are different, but it's not
--        # Hermitian.
--        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
--        assert np.count_nonzero(base.to_array()) == 3
--        assert not _data.isherm(base, tol=self.tol)
--        assert not _data.isherm(base.transpose(), tol=self.tol)
--
--        # Catch possible edge case where it shouldn't be Hermitian, but faulty
--        # loop logic doesn't fully compare all rows.
--        base = _data.to(
--            datatype,
--            _data.create(
--                np.array(
--                    [
--                        [0, 0, 0, 0],
--                        [0, 0, 0, 0],
--                        [0, 1, 0, 0],
--                        [0, 0, 0, 0],
--                    ],
--                    dtype=np.complex128,
--                )
--            ),
--        )
--        assert np.count_nonzero(base.to_array()) == 1
--        assert not _data.isherm(base, tol=self.tol)
--        assert not _data.isherm(base.transpose(), tol=self.tol)
--
--    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
--    def test_compare_implicit_zero_random(self, datatype, density):
--        """
--        Regression test of gh-1350.
--
--        Larger matrices where all off-diagonal elements are below the
--        absolute tolerance, so everything should always appear Hermitian, but
--        with random patterns of non-zero elements.  It doesn't matter that it
--        isn't Hermitian if scaled up; everything is below absolute tolerance,
--        so it should appear so.  We also set the diagonal to be larger to the
--        tolerance to ensure isherm can't just compare everything to zero.
--        """
--        n = 10
--        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
--        # Mask some values out to zero.
--        base[np.random.rand(n, n) > density] = 0
--        np.fill_diagonal(base, self.tol * 1000)
--        nnz = np.count_nonzero(base)
--        base = _data.to(datatype, _data.create(base))
--        assert np.count_nonzero(base.to_array()) == nnz
--        assert _data.isherm(base, tol=self.tol)
--        assert _data.isherm(base.transpose(), tol=self.tol)
--
--        # Similar test when it must be non-Hermitian.  We set the diagonal
--        # to be real because we want to test off-diagonal implicit zeros,
--        # and having an imaginary first element would automatically fail.
--        nnz = 0
--        while nnz <= n:
--            # Ensure that we don't just have the real diagonal.
--            base = self.tol * 1000j * np.random.rand(n, n)
--            # Mask some values out to zero.
--            base[np.random.rand(n, n) > density] = 0
--            np.fill_diagonal(base, self.tol * 1000)
--            nnz = np.count_nonzero(base)
--        base = _data.to(datatype, _data.create(base))
--        assert np.count_nonzero(base.to_array()) == nnz
--        assert not _data.isherm(base, tol=self.tol)
--        assert not _data.isherm(base.transpose(), tol=self.tol)
--
--    def test_structure_detection(self, datatype):
--        base = np.array([[1,1,0],
--                         [0,1,1],
--                         [1,0,1]])
--        base = _data.to(datatype, _data.create(base))
--        assert not _data.isherm(base, tol=self.tol)
--
--
--class Test_isdiag:
--    @pytest.mark.parametrize("shape",
--        [(10, 1), (2, 5), (5, 2), (5, 5)]
--    )
--    def test_isdiag(self, shape, datatype):
--        mat = np.zeros(shape)
--        data = _data.to(datatype, _data.Dense(mat))
--        # empty matrices are diagonal
--        assert _data.isdiag(data)
--
--        mat[0, 0] = 1
--        data = _data.to(datatype, _data.Dense(mat))
--        assert _data.isdiag(data)
--
--        mat[1, 0] = 1
--        data = _data.to(datatype, _data.Dense(mat))
--        assert not _data.isdiag(data)
-+import numpy as np
-+import pytest
-+
-+from qutip import data as _data
-+
-+
-+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
-+def datatype(request):
-+    return request.param
-+
-+
-+class Test_isherm:
-+    tol = 1e-12
-+
-+    @pytest.mark.repeat(20)
-+    @pytest.mark.parametrize("density", (0.1, 0.8))
-+    @pytest.mark.parametrize("size", (10, 100))
-+    def test_random_equal_structure(self, datatype, size, density):
-+        # This is only going to be approximate, as entries generated onto the
-+        # diagonal will fill only one slot, not two, after addition with the
-+        # transpose.  The densities are arbitrary, though, so this doesn't
-+        # matter much.
-+        nnz = int(0.5 * size*size * density) or 1
-+        indices = np.triu_indices(size)
-+        choice = np.random.choice(indices[0].size, nnz, replace=False)
-+        indices = (indices[0][choice], indices[1][choice])
-+
-+        # Real-symmetric matrices.
-+        base = np.zeros((size, size), dtype=np.complex128)
-+        base[indices] = np.random.rand(nnz)
-+        base += base.T.conj()
-+        base = _data.to(datatype, _data.create(base))
-+        assert _data.isherm(base)
-+
-+        # Complex Hermitian matrices
-+        base = np.zeros((size, size), dtype=np.complex128)
-+        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-+        base += base.T.conj()
-+        base = _data.to(datatype, _data.create(base))
-+        assert _data.isherm(base)
-+
-+        # Complex skew-Hermitian matrices
-+        base = np.zeros((size, size), dtype=np.complex128)
-+        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-+        base += base.T
-+        base = _data.to(datatype, _data.create(base))
-+        assert not _data.isherm(base)
-+
-+    @pytest.mark.parametrize("cols", (2, 4))
-+    @pytest.mark.parametrize("rows", (1, 5))
-+    def test_nonsquare_shapes(self, datatype, rows, cols):
-+        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
-+        assert not _data.isherm(real, self.tol)
-+        assert not _data.isherm(real.transpose(), self.tol)
-+
-+        imag = _data.to(
-+            datatype,
-+            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
-+        )
-+        assert not _data.isherm(imag, self.tol)
-+        assert not _data.isherm(imag.transpose(), self.tol)
-+
-+    def test_diagonal_elements(self, datatype):
-+        n = 10
-+        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
-+        assert _data.isherm(base, tol=self.tol)
-+        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
-+
-+    def test_compare_implicit_zero_structure(self, datatype):
-+        """
-+        Regression test for gh-1350, comparing explicitly stored values in the
-+        matrix (but below the tolerance for allowable Hermicity) to implicit
-+        zeros.
-+        """
-+
-+        base = _data.to(
-+            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
-+        )
-+        # If this first line fails, the zero has been stored explicitly and so
-+        # the test is invalid.
-+        assert np.count_nonzero(base.to_array()) == 3
-+        assert _data.isherm(base, tol=self.tol)
-+        assert _data.isherm(base.transpose(), tol=self.tol)
-+
-+        # A similar test if the structures are different, but it's not
-+        # Hermitian.
-+        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
-+        assert np.count_nonzero(base.to_array()) == 3
-+        assert not _data.isherm(base, tol=self.tol)
-+        assert not _data.isherm(base.transpose(), tol=self.tol)
-+
-+        # Catch possible edge case where it shouldn't be Hermitian, but faulty
-+        # loop logic doesn't fully compare all rows.
-+        base = _data.to(
-+            datatype,
-+            _data.create(
-+                np.array(
-+                    [
-+                        [0, 0, 0, 0],
-+                        [0, 0, 0, 0],
-+                        [0, 1, 0, 0],
-+                        [0, 0, 0, 0],
-+                    ],
-+                    dtype=np.complex128,
-+                )
-+            ),
-+        )
-+        assert np.count_nonzero(base.to_array()) == 1
-+        assert not _data.isherm(base, tol=self.tol)
-+        assert not _data.isherm(base.transpose(), tol=self.tol)
-+
-+    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
-+    def test_compare_implicit_zero_random(self, datatype, density):
-+        """
-+        Regression test of gh-1350.
-+
-+        Larger matrices where all off-diagonal elements are below the
-+        absolute tolerance, so everything should always appear Hermitian, but
-+        with random patterns of non-zero elements.  It doesn't matter that it
-+        isn't Hermitian if scaled up; everything is below absolute tolerance,
-+        so it should appear so.  We also set the diagonal to be larger to the
-+        tolerance to ensure isherm can't just compare everything to zero.
-+        """
-+        n = 10
-+        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
-+        # Mask some values out to zero.
-+        base[np.random.rand(n, n) > density] = 0
-+        np.fill_diagonal(base, self.tol * 1000)
-+        nnz = np.count_nonzero(base)
-+        base = _data.to(datatype, _data.create(base))
-+        assert np.count_nonzero(base.to_array()) == nnz
-+        assert _data.isherm(base, tol=self.tol)
-+        assert _data.isherm(base.transpose(), tol=self.tol)
-+
-+        # Similar test when it must be non-Hermitian.  We set the diagonal
-+        # to be real because we want to test off-diagonal implicit zeros,
-+        # and having an imaginary first element would automatically fail.
-+        nnz = 0
-+        while nnz <= n:
-+            # Ensure that we don't just have the real diagonal.
-+            base = self.tol * 1000j * np.random.rand(n, n)
-+            # Mask some values out to zero.
-+            base[np.random.rand(n, n) > density] = 0
-+            np.fill_diagonal(base, self.tol * 1000)
-+            nnz = np.count_nonzero(base)
-+        base = _data.to(datatype, _data.create(base))
-+        assert np.count_nonzero(base.to_array()) == nnz
-+        assert not _data.isherm(base, tol=self.tol)
-+        assert not _data.isherm(base.transpose(), tol=self.tol)
-+
-+    def test_structure_detection(self, datatype):
-+        base = np.array([[1,1,0],
-+                         [0,1,1],
-+                         [1,0,1]])
-+        base = _data.to(datatype, _data.create(base))
-+        assert not _data.isherm(base, tol=self.tol)
-+
-+
-+class Test_isdiag:
-+    @pytest.mark.parametrize("shape",
-+        [(10, 1), (2, 5), (5, 2), (5, 5)]
-+    )
-+    def test_isdiag(self, shape, datatype):
-+        mat = np.zeros(shape)
-+        data = _data.to(datatype, _data.Dense(mat))
-+        # empty matrices are diagonal
-+        assert _data.isdiag(data)
-+
-+        mat[0, 0] = 1
-+        data = _data.to(datatype, _data.Dense(mat))
-+        assert _data.isdiag(data)
-+
-+        mat[1, 0] = 1
-+        data = _data.to(datatype, _data.Dense(mat))
-+        assert not _data.isdiag(data)
-diff --git a/qutip/tests/core/data/test_ptrace.py b/qutip/tests/core/data/test_ptrace.py
-index 84fd4101..37b28c29 100644
---- a/qutip/tests/core/data/test_ptrace.py
-+++ b/qutip/tests/core/data/test_ptrace.py
-@@ -1,108 +1,108 @@
--from . import test_mathematics as testing
--import numpy as np
--import scipy.linalg
--import pytest
--from qutip import data
--from qutip.core.data import CSR, Dense
--
--
--class TestPtrace(testing.UnaryOpMixin):
--    def op_numpy(self, matrix, dims, sel):
--        sel.sort()
--        ndims = len(dims)
--        dkeep = [dims[x] for x in sel]
--        qtrace = list(set(range(ndims)) - set(sel))
--        dtrace = [dims[x] for x in qtrace]
--
--        matrix = matrix.reshape(dims + dims)
--        matrix = matrix.transpose(
--            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
--        )
--        matrix = matrix.reshape(
--            [
--                np.prod(dtrace, dtype=int),
--                np.prod(dtrace, dtype=int),
--                np.prod(dkeep, dtype=int),
--                np.prod(dkeep, dtype=int),
--            ]
--        )
--        return np.trace(matrix)
--
--    # Custom shapes to have also custom dims and sel arguments.
--    # These values should not be changed.
--    dims = [2] * 7
--    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
--    bad_shapes = testing.shapes_not_square(np.prod(dims))
--
--    specialisations = [
--        pytest.param(data.ptrace_csr, CSR, CSR),
--        pytest.param(data.ptrace_csr_dense, CSR, Dense),
--        pytest.param(data.ptrace_dense, Dense, Dense),
--    ]
--
--    @pytest.mark.parametrize(
--        "sel",
--        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
--        ids=[
--            "keep_one",
--            "keep_multiple_sorted",
--            "keep_multiple_unsorted",
--            "trace_none",
--            "trace_all",
--        ],
--    )
--    def test_mathematically_correct(self, op, data_m, out_type, sel):
--        """
--        Test that the unary operation is mathematically correct for all the
--        known type specialisations.
--        """
--        matrix = data_m()
--        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
--        test = op(matrix, self.dims, sel)
--        assert isinstance(test, out_type)
--        assert test.shape == expected.shape
--        np.testing.assert_allclose(
--            test.to_array(), expected, atol=self.atol, rtol=self.rtol
--        )
--
--    def test_incorrect_shape_raises(self, op, data_m):
--        """
--        Test that the operation produces a suitable error if the shape of the
--        operand is not square.
--        """
--        with pytest.raises(ValueError):
--            op(data_m(), self.dims, sel=[0, 1])
--
--    # `out_type` is included but not used so that
--    # `generate_mathematically_correct` can be re-used.
--    @pytest.mark.parametrize(
--        "dims",
--        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
--        ids=[
--            "dims_different_to_shape",
--            "dims_0",
--            "dims_prod_is_shape_but_negative",
--            "dims_is_not_int",
--        ],
--    )
--    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
--        with pytest.raises(ValueError):
--            op(data_m(), dims, sel=[0, 1])
--
--    def generate_incorrect_dims_raises(self, metafunc):
--        self.generate_mathematically_correct(metafunc)
--
--    @pytest.mark.parametrize(
--        "sel",
--        [[2, 10], [-1, 2]],
--        ids=[
--            "sel_value_larger_than_dims",
--            "sel_value_negative",
--        ],
--    )
--    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
--        with pytest.raises(IndexError):
--            op(data_m(), dims=self.dims, sel=sel)
--
--    def generate_incorrect_sel_raises(self, metafunc):
--        self.generate_mathematically_correct(metafunc)
-+from . import test_mathematics as testing
-+import numpy as np
-+import scipy.linalg
-+import pytest
-+from qutip import data
-+from qutip.core.data import CSR, Dense
-+
-+
-+class TestPtrace(testing.UnaryOpMixin):
-+    def op_numpy(self, matrix, dims, sel):
-+        sel.sort()
-+        ndims = len(dims)
-+        dkeep = [dims[x] for x in sel]
-+        qtrace = list(set(range(ndims)) - set(sel))
-+        dtrace = [dims[x] for x in qtrace]
-+
-+        matrix = matrix.reshape(dims + dims)
-+        matrix = matrix.transpose(
-+            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
-+        )
-+        matrix = matrix.reshape(
-+            [
-+                np.prod(dtrace, dtype=int),
-+                np.prod(dtrace, dtype=int),
-+                np.prod(dkeep, dtype=int),
-+                np.prod(dkeep, dtype=int),
-+            ]
-+        )
-+        return np.trace(matrix)
-+
-+    # Custom shapes to have also custom dims and sel arguments.
-+    # These values should not be changed.
-+    dims = [2] * 7
-+    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
-+    bad_shapes = testing.shapes_not_square(np.prod(dims))
-+
-+    specialisations = [
-+        pytest.param(data.ptrace_csr, CSR, CSR),
-+        pytest.param(data.ptrace_csr_dense, CSR, Dense),
-+        pytest.param(data.ptrace_dense, Dense, Dense),
-+    ]
-+
-+    @pytest.mark.parametrize(
-+        "sel",
-+        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
-+        ids=[
-+            "keep_one",
-+            "keep_multiple_sorted",
-+            "keep_multiple_unsorted",
-+            "trace_none",
-+            "trace_all",
-+        ],
-+    )
-+    def test_mathematically_correct(self, op, data_m, out_type, sel):
-+        """
-+        Test that the unary operation is mathematically correct for all the
-+        known type specialisations.
-+        """
-+        matrix = data_m()
-+        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
-+        test = op(matrix, self.dims, sel)
-+        assert isinstance(test, out_type)
-+        assert test.shape == expected.shape
-+        np.testing.assert_allclose(
-+            test.to_array(), expected, atol=self.atol, rtol=self.rtol
-+        )
-+
-+    def test_incorrect_shape_raises(self, op, data_m):
-+        """
-+        Test that the operation produces a suitable error if the shape of the
-+        operand is not square.
-+        """
-+        with pytest.raises(ValueError):
-+            op(data_m(), self.dims, sel=[0, 1])
-+
-+    # `out_type` is included but not used so that
-+    # `generate_mathematically_correct` can be re-used.
-+    @pytest.mark.parametrize(
-+        "dims",
-+        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
-+        ids=[
-+            "dims_different_to_shape",
-+            "dims_0",
-+            "dims_prod_is_shape_but_negative",
-+            "dims_is_not_int",
-+        ],
-+    )
-+    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
-+        with pytest.raises(ValueError):
-+            op(data_m(), dims, sel=[0, 1])
-+
-+    def generate_incorrect_dims_raises(self, metafunc):
-+        self.generate_mathematically_correct(metafunc)
-+
-+    @pytest.mark.parametrize(
-+        "sel",
-+        [[2, 10], [-1, 2]],
-+        ids=[
-+            "sel_value_larger_than_dims",
-+            "sel_value_negative",
-+        ],
-+    )
-+    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
-+        with pytest.raises(IndexError):
-+            op(data_m(), dims=self.dims, sel=sel)
-+
-+    def generate_incorrect_sel_raises(self, metafunc):
-+        self.generate_mathematically_correct(metafunc)
-diff --git a/qutip/tests/core/data/test_reshape.py b/qutip/tests/core/data/test_reshape.py
-index e86b327c..ad863b55 100644
---- a/qutip/tests/core/data/test_reshape.py
-+++ b/qutip/tests/core/data/test_reshape.py
-@@ -1,121 +1,121 @@
--from .test_mathematics import UnaryOpMixin
--import pytest
--import numpy as np
--from qutip import data
--from qutip.core.data import CSR, Dense
--
--
--class TestSplitColumns(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        return [column[:, np.newaxis] for column in matrix.T]
--
--    specialisations = [
--        pytest.param(data.split_columns_csr, CSR, list),
--        pytest.param(data.split_columns_dense, Dense, list),
--    ]
--
--
--class TestColumnStack(UnaryOpMixin):
--    def op_numpy(self, matrix):
--        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
--        return np.reshape(matrix, newshape=out_shape, order='F')
--
--    specialisations = [
--        pytest.param(data.column_stack_csr, CSR, CSR),
--        pytest.param(data.column_stack_dense, Dense, Dense),
--    ]
--
--
--class TestColumnUnstack(UnaryOpMixin):
--    def op_numpy(self, matrix, rows):
--        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
--        return np.reshape(matrix, newshape=out_shape, order='F')
--
--    shapes = [
--        (pytest.param((10, 1), id="ket"), ),
--    ]
--
--    bad_shapes = [
--        (pytest.param((1, 10), id="bra"), ),
--        (pytest.param((10, 10), id="square"), ),
--        (pytest.param((2, 10), id="non_square"), ),
--    ]
--
--    specialisations = [
--        pytest.param(data.column_unstack_csr, CSR, CSR),
--        pytest.param(data.column_unstack_dense, Dense, Dense),
--    ]
--
--    @pytest.mark.parametrize('rows', [2, 5])
--    def test_mathematically_correct(self, op, data_m, rows, out_type):
--        """
--        Test that the binary operation is correct for all the known type
--        specialisations.
--        """
--        matrix = data_m()
--        expected = self.op_numpy(matrix.to_array(), rows)
--        test = op(matrix, rows)
--        assert isinstance(test, out_type)
--        assert test.shape == expected.shape
--        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
--                                   rtol=self.rtol)
--
--    def test_incorrect_shape_raises(self, op, data_m):
--        with pytest.raises(ValueError):
--            op(data_m(), 1)  # We set rows to one so that it is always valid
--
--    # `out_type` is included but not used so that
--    # `generate_mathematically_correct` can be re-used.
--    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
--                                                      'invalid'])
--    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
--        with pytest.raises(ValueError):
--            op(data_m(), rows)
--
--    def generate_incorrect_rows_raises(self, metafunc):
--        self.generate_mathematically_correct(metafunc)
--
--
--class TestReshape(UnaryOpMixin):
--    def op_numpy(self, matrix, rows, columns):
--        out_shape = (rows, columns)
--        return np.reshape(matrix, newshape=out_shape, order='C')
--
--    # All matrices should have the same number of elements in total, so we can
--    # use the same (rows, columns) parametrisation for each input.
--    shapes = [
--        (pytest.param((1, 100), id="bra"), ),
--        (pytest.param((100, 1), id="ket"), ),
--        (pytest.param((2, 50), id="non_square"), ),
--        (pytest.param((10, 10), id="square"), ),
--    ]
--
--    specialisations = [
--        pytest.param(data.reshape_dense, Dense, Dense),
--        pytest.param(data.reshape_csr, CSR, CSR),
--    ]
--
--    # `out_type` is included but not used so that
--    # `generate_mathematically_correct` can be re-used.
--    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
--    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
--        """
--        Test that the binary operation is correct for all the known type
--        specialisations.
--        """
--        matrix = data_m()
--        expected = self.op_numpy(matrix.to_array(), rows, columns)
--        test = op(matrix, rows, columns)
--        assert isinstance(test, out_type)
--        assert test.shape == expected.shape
--        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
--                                   rtol=self.rtol)
--
--    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
--                             ids=["negative1", "negative2", "invalid"])
--    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
--        with pytest.raises(ValueError):
--            op(data_m(), rows, columns)
--
--    def generate_incorrect_rows_raises(self, metafunc):
--        self.generate_mathematically_correct(metafunc)
-+from .test_mathematics import UnaryOpMixin
-+import pytest
-+import numpy as np
-+from qutip import data
-+from qutip.core.data import CSR, Dense
-+
-+
-+class TestSplitColumns(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        return [column[:, np.newaxis] for column in matrix.T]
-+
-+    specialisations = [
-+        pytest.param(data.split_columns_csr, CSR, list),
-+        pytest.param(data.split_columns_dense, Dense, list),
-+    ]
-+
-+
-+class TestColumnStack(UnaryOpMixin):
-+    def op_numpy(self, matrix):
-+        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
-+        return np.reshape(matrix, newshape=out_shape, order='F')
-+
-+    specialisations = [
-+        pytest.param(data.column_stack_csr, CSR, CSR),
-+        pytest.param(data.column_stack_dense, Dense, Dense),
-+    ]
-+
-+
-+class TestColumnUnstack(UnaryOpMixin):
-+    def op_numpy(self, matrix, rows):
-+        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
-+        return np.reshape(matrix, newshape=out_shape, order='F')
-+
-+    shapes = [
-+        (pytest.param((10, 1), id="ket"), ),
-+    ]
-+
-+    bad_shapes = [
-+        (pytest.param((1, 10), id="bra"), ),
-+        (pytest.param((10, 10), id="square"), ),
-+        (pytest.param((2, 10), id="non_square"), ),
-+    ]
-+
-+    specialisations = [
-+        pytest.param(data.column_unstack_csr, CSR, CSR),
-+        pytest.param(data.column_unstack_dense, Dense, Dense),
-+    ]
-+
-+    @pytest.mark.parametrize('rows', [2, 5])
-+    def test_mathematically_correct(self, op, data_m, rows, out_type):
-+        """
-+        Test that the binary operation is correct for all the known type
-+        specialisations.
-+        """
-+        matrix = data_m()
-+        expected = self.op_numpy(matrix.to_array(), rows)
-+        test = op(matrix, rows)
-+        assert isinstance(test, out_type)
-+        assert test.shape == expected.shape
-+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-+                                   rtol=self.rtol)
-+
-+    def test_incorrect_shape_raises(self, op, data_m):
-+        with pytest.raises(ValueError):
-+            op(data_m(), 1)  # We set rows to one so that it is always valid
-+
-+    # `out_type` is included but not used so that
-+    # `generate_mathematically_correct` can be re-used.
-+    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
-+                                                      'invalid'])
-+    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
-+        with pytest.raises(ValueError):
-+            op(data_m(), rows)
-+
-+    def generate_incorrect_rows_raises(self, metafunc):
-+        self.generate_mathematically_correct(metafunc)
-+
-+
-+class TestReshape(UnaryOpMixin):
-+    def op_numpy(self, matrix, rows, columns):
-+        out_shape = (rows, columns)
-+        return np.reshape(matrix, newshape=out_shape, order='C')
-+
-+    # All matrices should have the same number of elements in total, so we can
-+    # use the same (rows, columns) parametrisation for each input.
-+    shapes = [
-+        (pytest.param((1, 100), id="bra"), ),
-+        (pytest.param((100, 1), id="ket"), ),
-+        (pytest.param((2, 50), id="non_square"), ),
-+        (pytest.param((10, 10), id="square"), ),
-+    ]
-+
-+    specialisations = [
-+        pytest.param(data.reshape_dense, Dense, Dense),
-+        pytest.param(data.reshape_csr, CSR, CSR),
-+    ]
-+
-+    # `out_type` is included but not used so that
-+    # `generate_mathematically_correct` can be re-used.
-+    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
-+    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
-+        """
-+        Test that the binary operation is correct for all the known type
-+        specialisations.
-+        """
-+        matrix = data_m()
-+        expected = self.op_numpy(matrix.to_array(), rows, columns)
-+        test = op(matrix, rows, columns)
-+        assert isinstance(test, out_type)
-+        assert test.shape == expected.shape
-+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-+                                   rtol=self.rtol)
-+
-+    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
-+                             ids=["negative1", "negative2", "invalid"])
-+    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
-+        with pytest.raises(ValueError):
-+            op(data_m(), rows, columns)
-+
-+    def generate_incorrect_rows_raises(self, metafunc):
-+        self.generate_mathematically_correct(metafunc)
-diff --git a/qutip/tests/core/test_brtools.py b/qutip/tests/core/test_brtools.py
-index 527ca897..c1b43188 100644
---- a/qutip/tests/core/test_brtools.py
-+++ b/qutip/tests/core/test_brtools.py
-@@ -1,336 +1,336 @@
--import pytest
--import qutip
--import numpy as np
--from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
--from qutip.core.blochredfield import brterm, bloch_redfield_tensor
--from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
--                                  _br_term_data, _BlochRedfieldElement)
--
--
--def _make_rand_data(shape):
--    np.random.seed(11)
--    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
--    return qutip.data.Dense(array)
--
--
--transform = {
--    0: lambda x: x,
--    1: qutip.data.transpose,
--    2: qutip.data.conj,
--    3: qutip.data.adjoint
--}
--
--
--@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
--@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
--                         ids=['', 'transpose', 'conj', 'dag'])
--@pytest.mark.parametrize('transright', [0, 1, 2, 3],
--                         ids=['', 'transpose', 'conj', 'dag'])
--def test_matmul_var(datatype, transleft, transright):
--    shape = (5, 5)
--    np.random.seed(11)
--    left = qutip.data.to(datatype, _make_rand_data(shape))
--    right = qutip.data.to(datatype, _make_rand_data(shape))
--
--    expected = qutip.data.matmul(
--        transform[transleft](left),
--        transform[transright](right),
--        ).to_array()
--
--    computed = matmul_var_data(left, right, transleft, transright).to_array()
--    np.testing.assert_allclose(computed, expected, rtol=1e-14)
--
--
--@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
--def test_eigen_transform(sparse):
--    a = qutip.destroy(5)
--    f = lambda t: t
--    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
--    eigenT = _EigenBasisTransform(op, sparse=sparse)
--    evecs_qevo = eigenT.as_Qobj()
--
--    for t in [0, 1, 1.5]:
--        eigenvals, ekets = op(t).eigenstates()
--        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
--                                   rtol=1e-14, atol=1e-14)
--        np.testing.assert_allclose(
--            np.abs(np.hstack([eket.full() for eket in ekets])),
--            np.abs(eigenT.evecs(t).to_array()),
--            rtol=1e-14, atol=1e-14
--        )
--        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
--                                   np.abs(eigenT.evecs(t).to_array()),
--                                   rtol=1e-14, atol=1e-14)
--
--
--def test_eigen_transform_ket():
--    N = 5
--    a = qutip.destroy(N)
--    op = a*a.dag() + a + a.dag()
--    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
--    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
--
--    state = qutip.coherent(N, 1.1)
--
--    expected = (op @ state).full()
--    computed = eigenT.from_eigbasis(
--        0,
--        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
--    ).to_array()
--    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
--
--
--def test_eigen_transform_dm():
--    N = 5
--    a = qutip.destroy(N)
--    op = a*a.dag() + a + a.dag()
--    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
--    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
--
--    state = qutip.coherent_dm(N, 1.1)
--
--    expected = (op @ state).full()
--    computed = eigenT.from_eigbasis(
--        0,
--        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
--    ).to_array()
--    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
--
--
--def test_eigen_transform_oper_ket():
--    N = 5
--    a = qutip.destroy(N)
--    op = a*a.dag() + a + a.dag()
--    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
--    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
--
--    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
--
--    expected = (qutip.spre(op) @ state).full()
--    computed = eigenT.from_eigbasis(
--        0,
--        qutip.data.matmul(qutip.spre(op_diag).data,
--                          eigenT.to_eigbasis(0, state.data))
--    ).to_array()
--    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
--
--
--def test_eigen_transform_super_ops():
--    N = 5
--    a = qutip.destroy(N)
--    op = a*a.dag() + a + a.dag()
--    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
--    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
--
--    state = qutip.sprepost(
--        qutip.coherent_dm(N, 1.1),
--        qutip.thermal_dm(N, 1.1)
--    )
--
--    expected = (qutip.spre(op) @ state).full()
--    computed = eigenT.from_eigbasis(
--        0,
--        qutip.data.matmul(qutip.spre(op_diag).data,
--                          eigenT.to_eigbasis(0, state.data))
--    ).to_array()
--    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('func',
--                         [_br_term_dense, _br_term_sparse, _br_term_data],
--                         ids=['dense', 'sparse', 'data'])
--def test_br_term_linbblad_comp(func):
--    N = 5
--    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
--    A_op = a + a.dag()
--    H = qutip.num(N)
--    diag = H.eigenenergies()
--    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
--    spectrum = (skew > 0) * 1.
--    computation = func(A_op.data, spectrum, skew, 2).to_array()
--    lindblad = qutip.lindblad_dissipator(a).full()
--    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
--@pytest.mark.parametrize('spectra', [
--    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
--    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
--    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
--])
--def test_br_term(cutoff, spectra):
--    N = 5
--    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
--    A_op = a + a.dag()
--    H = qutip.num(N)
--    diag = H.eigenenergies()
--    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
--    spectrum = spectra(skew)
--    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
--    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
--    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
--    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
--    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
--def test_brterm(cutoff):
--    N = 5
--    H = qutip.num(N)
--    a = qutip.destroy(N)
--    A_op = a + a.dag()
--    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
--    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
--    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
--    assert isinstance(R, qutip.Qobj)
--    assert isinstance(R_eigs, qutip.Qobj)
--    assert isinstance(evecs, qutip.Qobj)
--    state = qutip.operator_to_vector(qutip.rand_dm(N))
--    fock_computed = R @ state
--    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
--    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
--    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
--                               rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
--def test_td_brterm(cutoff):
--    N = 5
--    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
--    a = qutip.destroy(N)
--    A_op = qutip.QobjEvo([a + a.dag(), "t"])
--    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
--    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
--    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
--    assert isinstance(R, qutip.QobjEvo)
--    assert isinstance(R_eigs, qutip.QobjEvo)
--    assert isinstance(evecs, qutip.QobjEvo)
--    state = qutip.operator_to_vector(qutip.rand_dm(N))
--    fock_computed = R @ state
--    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
--    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
--    for t in [0, 0.5, 1.0]:
--        np.testing.assert_allclose(
--            (R(t) @ state).full(),
--            R.matmul(t, state).full(),
--            rtol=1e-14, atol=1e-14
--        )
--        np.testing.assert_allclose(fock_computed(t).full(),
--                                   eig_computed(t).full(),
--                                   rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
--def test_bloch_redfield_tensor_basis(cutoff):
--    N = 5
--    H = qutip.num(N)
--    a = qutip.destroy(N)
--    A_op = a + a.dag()
--    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
--    R = bloch_redfield_tensor(
--        H=H,
--        a_ops=[(A_op, spectra)],
--        c_ops=[a**2],
--        sec_cutoff=cutoff,
--        fock_basis=True
--    )
--    R_eigs, evecs = bloch_redfield_tensor(
--        H=H,
--        a_ops=[(A_op, spectra)],
--        c_ops=[a**2],
--        sec_cutoff=cutoff,
--        fock_basis=False
--    )
--    assert isinstance(R, qutip.Qobj)
--    assert isinstance(R_eigs, qutip.Qobj)
--    assert isinstance(evecs, qutip.Qobj)
--    state = qutip.operator_to_vector(qutip.rand_dm(N))
--    fock_computed = R @ state
--    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
--    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
--    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
--                               rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
--def test_bloch_redfield_tensor(cutoff):
--    N = 5
--    H = qutip.num(N)
--    a = qutip.destroy(N)
--    A_op = a + a.dag()
--    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
--    R = bloch_redfield_tensor(
--        H=H,
--        a_ops=[(A_op, spectra)],
--        c_ops=[a**2],
--        sec_cutoff=cutoff,
--        fock_basis=True
--    )
--    R_expected = qutip.liouvillian(H, [a**2])
--    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
--
--    assert isinstance(R, qutip.Qobj)
--    assert isinstance(R_expected, qutip.Qobj)
--    np.testing.assert_allclose(R.full(), R_expected.full(),
--                               rtol=1e-14, atol=1e-14)
--
--
--@pytest.mark.parametrize('fock_basis', [True, False])
--@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
--def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
--    N = 3
--    H = qutip.QobjEvo([qutip.num(N), "t"])
--    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
--    A_op = a + a.dag()
--    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
--    R = bloch_redfield_tensor(
--        H=H,
--        a_ops=[(A_op, spectra)],
--        c_ops=[qutip.destroy(N)],
--        sec_cutoff=cutoff,
--        fock_basis=fock_basis
--    )
--    R = R[0] if not fock_basis else R
--    assert isinstance(R, qutip.QobjEvo)
--    for t in [0, 0.5, 1.0, 1.5]:
--        R_expected = bloch_redfield_tensor(
--            H=H(t),
--            a_ops=[(A_op(t), spectra)],
--            c_ops=[qutip.destroy(N)],
--            sec_cutoff=cutoff,
--            fock_basis=fock_basis
--        )
--        R_expected = R_expected[0] if not fock_basis else R_expected
--        np.testing.assert_allclose(R(t).full(), R_expected.full(),
--                                   rtol=1e-14, atol=1e-14)
--
--
--def test_bloch_redfield_tensor_spectral_string():
--    N = 5
--    H = qutip.num(N)
--    a = qutip.destroy(N)
--    A_op = a + a.dag()
--    spectra = "(w>0) * 0.5"
--    R_eigs, evecs = bloch_redfield_tensor(
--        H=H,
--        a_ops=[(A_op, spectra)],
--        c_ops=[a**2],
--        fock_basis=False
--    )
--    assert isinstance(R_eigs, qutip.Qobj)
--    assert isinstance(evecs, qutip.Qobj)
--
--def test_bloch_redfield_tensor_spectral_callable():
--    N = 5
--    H = qutip.num(N)
--    a = qutip.destroy(N)
--    A_op = a + a.dag()
--    spectra = lambda w: (w>0) * 0.5
--    R_eigs, evecs = bloch_redfield_tensor(
--        H=H,
--        a_ops=[(A_op, spectra)],
--        c_ops=[a**2],
--        fock_basis=False
--    )
--    assert isinstance(R_eigs, qutip.Qobj)
-+import pytest
-+import qutip
-+import numpy as np
-+from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
-+from qutip.core.blochredfield import brterm, bloch_redfield_tensor
-+from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
-+                                  _br_term_data, _BlochRedfieldElement)
-+
-+
-+def _make_rand_data(shape):
-+    np.random.seed(11)
-+    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-+    return qutip.data.Dense(array)
-+
-+
-+transform = {
-+    0: lambda x: x,
-+    1: qutip.data.transpose,
-+    2: qutip.data.conj,
-+    3: qutip.data.adjoint
-+}
-+
-+
-+@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
-+@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
-+                         ids=['', 'transpose', 'conj', 'dag'])
-+@pytest.mark.parametrize('transright', [0, 1, 2, 3],
-+                         ids=['', 'transpose', 'conj', 'dag'])
-+def test_matmul_var(datatype, transleft, transright):
-+    shape = (5, 5)
-+    np.random.seed(11)
-+    left = qutip.data.to(datatype, _make_rand_data(shape))
-+    right = qutip.data.to(datatype, _make_rand_data(shape))
-+
-+    expected = qutip.data.matmul(
-+        transform[transleft](left),
-+        transform[transright](right),
-+        ).to_array()
-+
-+    computed = matmul_var_data(left, right, transleft, transright).to_array()
-+    np.testing.assert_allclose(computed, expected, rtol=1e-14)
-+
-+
-+@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
-+def test_eigen_transform(sparse):
-+    a = qutip.destroy(5)
-+    f = lambda t: t
-+    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
-+    eigenT = _EigenBasisTransform(op, sparse=sparse)
-+    evecs_qevo = eigenT.as_Qobj()
-+
-+    for t in [0, 1, 1.5]:
-+        eigenvals, ekets = op(t).eigenstates()
-+        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
-+                                   rtol=1e-14, atol=1e-14)
-+        np.testing.assert_allclose(
-+            np.abs(np.hstack([eket.full() for eket in ekets])),
-+            np.abs(eigenT.evecs(t).to_array()),
-+            rtol=1e-14, atol=1e-14
-+        )
-+        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
-+                                   np.abs(eigenT.evecs(t).to_array()),
-+                                   rtol=1e-14, atol=1e-14)
-+
-+
-+def test_eigen_transform_ket():
-+    N = 5
-+    a = qutip.destroy(N)
-+    op = a*a.dag() + a + a.dag()
-+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-+
-+    state = qutip.coherent(N, 1.1)
-+
-+    expected = (op @ state).full()
-+    computed = eigenT.from_eigbasis(
-+        0,
-+        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
-+    ).to_array()
-+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-+
-+
-+def test_eigen_transform_dm():
-+    N = 5
-+    a = qutip.destroy(N)
-+    op = a*a.dag() + a + a.dag()
-+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-+
-+    state = qutip.coherent_dm(N, 1.1)
-+
-+    expected = (op @ state).full()
-+    computed = eigenT.from_eigbasis(
-+        0,
-+        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
-+    ).to_array()
-+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-+
-+
-+def test_eigen_transform_oper_ket():
-+    N = 5
-+    a = qutip.destroy(N)
-+    op = a*a.dag() + a + a.dag()
-+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-+
-+    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
-+
-+    expected = (qutip.spre(op) @ state).full()
-+    computed = eigenT.from_eigbasis(
-+        0,
-+        qutip.data.matmul(qutip.spre(op_diag).data,
-+                          eigenT.to_eigbasis(0, state.data))
-+    ).to_array()
-+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-+
-+
-+def test_eigen_transform_super_ops():
-+    N = 5
-+    a = qutip.destroy(N)
-+    op = a*a.dag() + a + a.dag()
-+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-+
-+    state = qutip.sprepost(
-+        qutip.coherent_dm(N, 1.1),
-+        qutip.thermal_dm(N, 1.1)
-+    )
-+
-+    expected = (qutip.spre(op) @ state).full()
-+    computed = eigenT.from_eigbasis(
-+        0,
-+        qutip.data.matmul(qutip.spre(op_diag).data,
-+                          eigenT.to_eigbasis(0, state.data))
-+    ).to_array()
-+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('func',
-+                         [_br_term_dense, _br_term_sparse, _br_term_data],
-+                         ids=['dense', 'sparse', 'data'])
-+def test_br_term_linbblad_comp(func):
-+    N = 5
-+    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
-+    A_op = a + a.dag()
-+    H = qutip.num(N)
-+    diag = H.eigenenergies()
-+    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
-+    spectrum = (skew > 0) * 1.
-+    computation = func(A_op.data, spectrum, skew, 2).to_array()
-+    lindblad = qutip.lindblad_dissipator(a).full()
-+    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
-+@pytest.mark.parametrize('spectra', [
-+    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
-+    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
-+    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
-+])
-+def test_br_term(cutoff, spectra):
-+    N = 5
-+    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
-+    A_op = a + a.dag()
-+    H = qutip.num(N)
-+    diag = H.eigenenergies()
-+    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
-+    spectrum = spectra(skew)
-+    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
-+    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
-+    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
-+    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
-+    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-+def test_brterm(cutoff):
-+    N = 5
-+    H = qutip.num(N)
-+    a = qutip.destroy(N)
-+    A_op = a + a.dag()
-+    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
-+    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
-+    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
-+    assert isinstance(R, qutip.Qobj)
-+    assert isinstance(R_eigs, qutip.Qobj)
-+    assert isinstance(evecs, qutip.Qobj)
-+    state = qutip.operator_to_vector(qutip.rand_dm(N))
-+    fock_computed = R @ state
-+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-+    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
-+                               rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-+def test_td_brterm(cutoff):
-+    N = 5
-+    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
-+    a = qutip.destroy(N)
-+    A_op = qutip.QobjEvo([a + a.dag(), "t"])
-+    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
-+    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
-+    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
-+    assert isinstance(R, qutip.QobjEvo)
-+    assert isinstance(R_eigs, qutip.QobjEvo)
-+    assert isinstance(evecs, qutip.QobjEvo)
-+    state = qutip.operator_to_vector(qutip.rand_dm(N))
-+    fock_computed = R @ state
-+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-+    for t in [0, 0.5, 1.0]:
-+        np.testing.assert_allclose(
-+            (R(t) @ state).full(),
-+            R.matmul(t, state).full(),
-+            rtol=1e-14, atol=1e-14
-+        )
-+        np.testing.assert_allclose(fock_computed(t).full(),
-+                                   eig_computed(t).full(),
-+                                   rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-+def test_bloch_redfield_tensor_basis(cutoff):
-+    N = 5
-+    H = qutip.num(N)
-+    a = qutip.destroy(N)
-+    A_op = a + a.dag()
-+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-+    R = bloch_redfield_tensor(
-+        H=H,
-+        a_ops=[(A_op, spectra)],
-+        c_ops=[a**2],
-+        sec_cutoff=cutoff,
-+        fock_basis=True
-+    )
-+    R_eigs, evecs = bloch_redfield_tensor(
-+        H=H,
-+        a_ops=[(A_op, spectra)],
-+        c_ops=[a**2],
-+        sec_cutoff=cutoff,
-+        fock_basis=False
-+    )
-+    assert isinstance(R, qutip.Qobj)
-+    assert isinstance(R_eigs, qutip.Qobj)
-+    assert isinstance(evecs, qutip.Qobj)
-+    state = qutip.operator_to_vector(qutip.rand_dm(N))
-+    fock_computed = R @ state
-+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-+    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
-+                               rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-+def test_bloch_redfield_tensor(cutoff):
-+    N = 5
-+    H = qutip.num(N)
-+    a = qutip.destroy(N)
-+    A_op = a + a.dag()
-+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-+    R = bloch_redfield_tensor(
-+        H=H,
-+        a_ops=[(A_op, spectra)],
-+        c_ops=[a**2],
-+        sec_cutoff=cutoff,
-+        fock_basis=True
-+    )
-+    R_expected = qutip.liouvillian(H, [a**2])
-+    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
-+
-+    assert isinstance(R, qutip.Qobj)
-+    assert isinstance(R_expected, qutip.Qobj)
-+    np.testing.assert_allclose(R.full(), R_expected.full(),
-+                               rtol=1e-14, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize('fock_basis', [True, False])
-+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-+def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
-+    N = 3
-+    H = qutip.QobjEvo([qutip.num(N), "t"])
-+    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
-+    A_op = a + a.dag()
-+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-+    R = bloch_redfield_tensor(
-+        H=H,
-+        a_ops=[(A_op, spectra)],
-+        c_ops=[qutip.destroy(N)],
-+        sec_cutoff=cutoff,
-+        fock_basis=fock_basis
-+    )
-+    R = R[0] if not fock_basis else R
-+    assert isinstance(R, qutip.QobjEvo)
-+    for t in [0, 0.5, 1.0, 1.5]:
-+        R_expected = bloch_redfield_tensor(
-+            H=H(t),
-+            a_ops=[(A_op(t), spectra)],
-+            c_ops=[qutip.destroy(N)],
-+            sec_cutoff=cutoff,
-+            fock_basis=fock_basis
-+        )
-+        R_expected = R_expected[0] if not fock_basis else R_expected
-+        np.testing.assert_allclose(R(t).full(), R_expected.full(),
-+                                   rtol=1e-14, atol=1e-14)
-+
-+
-+def test_bloch_redfield_tensor_spectral_string():
-+    N = 5
-+    H = qutip.num(N)
-+    a = qutip.destroy(N)
-+    A_op = a + a.dag()
-+    spectra = "(w>0) * 0.5"
-+    R_eigs, evecs = bloch_redfield_tensor(
-+        H=H,
-+        a_ops=[(A_op, spectra)],
-+        c_ops=[a**2],
-+        fock_basis=False
-+    )
-+    assert isinstance(R_eigs, qutip.Qobj)
-+    assert isinstance(evecs, qutip.Qobj)
-+
-+def test_bloch_redfield_tensor_spectral_callable():
-+    N = 5
-+    H = qutip.num(N)
-+    a = qutip.destroy(N)
-+    A_op = a + a.dag()
-+    spectra = lambda w: (w>0) * 0.5
-+    R_eigs, evecs = bloch_redfield_tensor(
-+        H=H,
-+        a_ops=[(A_op, spectra)],
-+        c_ops=[a**2],
-+        fock_basis=False
-+    )
-+    assert isinstance(R_eigs, qutip.Qobj)
-     assert isinstance(evecs, qutip.Qobj)
-\ No newline at end of file
-diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
-index 2fe5ff0b..5c2807ac 100644
---- a/qutip/tests/core/test_coefficient.py
-+++ b/qutip/tests/core/test_coefficient.py
-@@ -1,397 +1,397 @@
--import pytest
--import pickle
--import qutip
--import numpy as np
--import scipy.interpolate as interp
--from functools import partial
--from qutip.core.coefficient import (coefficient, norm, conj,
--                                    CompilationOptions, Coefficient,
--                                    clean_compiled_coefficient
--                                   )
--from qutip.core.options import CoreOptions
--
--# Ensure the latest version is tested
--clean_compiled_coefficient(True)
--
--
--def f(t, w):
--    return np.exp(w * t * np.pi)
--
--
--def g(t, w):
--    return np.cos(w * t * np.pi)
--
--
--def h(t, a, b):
--    return a + b + t
--
--
--def f_kw(t, w, **args):
--    return f(t, w)
--
--
--def g_kw(t, w, **args):
--    return g(t, w)
--
--
--def h_kw(t, a, b, **args):
--    return h(t, a, b)
--
--
--def f_qtv4(t, args):
--    return f(t, args["w"])
--
--
--def g_qtv4(t, args):
--    return g(t, args["w"])
--
--
--def h_qtv4(t, args):
--    return h(t, args["a"], args["b"])
--
--
--def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
--    "assert coeff1 == coeff2"
--    "inside refer to the range covered by tlistlog: [0.01, 1]"
--    ts = np.linspace(0.01, 1, 20)
--    eps = 1e-12
--    crit_times = [0.01+eps, 0.95, 1-eps]
--    if not inside:
--        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
--    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
--    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
--    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
--
--
--args = {"w": 1j}
--tlist = np.linspace(0, 1, 101)
--f_asarray = f(tlist, **args)
--g_asarray = g(tlist, **args)
--tlistlog = np.logspace(-2, 0, 501)
--f_asarraylog = f(tlistlog, **args)
--
--
--def coeff_generator(style, func):
--    """Make a Coefficient"""
--    if func == "f":
--        base = f
--    else:
--        base = g
--
--    if style == "func":
--        return coefficient(base, args=args)
--    if style == "array":
--        return coefficient(base(tlist, **args), tlist=tlist)
--    if style == "arraylog":
--        return coefficient(base(tlistlog, **args), tlist=tlistlog)
--    if style == "string" and func == "f":
--        return coefficient("exp(w * t * pi)", args=args)
--    if style == "string" and func == "g":
--        return coefficient("cos(w * t * pi)", args=args)
--    if style == "steparray":
--        return coefficient(base(tlist, **args), tlist=tlist,
--                           order=0)
--    if style == "steparraylog":
--        return coefficient(base(tlistlog, **args), tlist=tlistlog,
--                           order=0)
--
--
--@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
--    pytest.param(f, {'args': args},
--                 1e-10, id="func"),
--    pytest.param(f_kw, {'args': args},
--                 1e-10, id="func_keywords"),
--    pytest.param(f_qtv4, {'args': args},
--                 1e-10, id="func_qutip_v4"),
--    pytest.param(f_asarray, {'tlist': tlist},
--                 1e-6,  id="array"),
--    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
--                 1e-1, id="step_array"),
--    pytest.param(f_asarraylog, {'tlist': tlistlog},
--                 1e-6, id="nonlinear_array"),
--    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
--                 1e-1, id="nonlinear_step_array"),
--    pytest.param("exp(w * t * pi)", {'args': args},
--                 1e-10, id="string")
--])
--def test_CoeffCreationCall(base, kwargs, tol):
--    opt = CompilationOptions(recompile=True)
--    expected = lambda t: np.exp(1j * t * np.pi)
--    coeff = coefficient(base, **kwargs, compile_opt=opt)
--    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
--
--
--@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
--    pytest.param(f, {'args': args},
--                 1e-10, id="func"),
--    pytest.param(f_kw, {'args': args},
--                 1e-10, id="func_keywords"),
--    pytest.param(f_qtv4, {'args': args},
--                 1e-10, id="func_qutip_v4"),
--    pytest.param("exp(w * t * pi)", {'args': args},
--                 1e-10, id="string")
--])
--def test_CoeffCallArgs(base, kwargs, tol):
--    w = np.e + 0.5j
--    expected = lambda t: np.exp(w * t * np.pi)
--    coeff = coefficient(base, **kwargs)
--    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
--
--
--@pytest.mark.parametrize(['base', 'tol'], [
--    pytest.param(h, 1e-10, id="func"),
--    pytest.param(h_kw, 1e-10, id="func_keywords"),
--    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
--    pytest.param("a + b + t", 1e-10, id="string")
--])
--def test_CoeffCallArguments(base, tol):
--    # Partial args update
--    args = {"a": 1, "b": 1}
--    a = np.e
--    expected = lambda t: a + 1 + t
--    coeff = coefficient(base, args=args)
--    coeff = coeff.replace_arguments({"a": a})
--    _assert_eq_over_interval(coeff, expected, rtol=tol)
--    b = np.pi
--    expected = lambda t: a + b + t
--    coeff = coeff.replace_arguments(b=b)
--    _assert_eq_over_interval(coeff, expected, rtol=tol)
--
--
--@pytest.mark.parametrize(['style'], [
--    pytest.param("func", id="func"),
--    pytest.param("array", id="array"),
--    pytest.param("arraylog", id="logarray"),
--    pytest.param("string", id="string"),
--    pytest.param("steparray", id="steparray"),
--    pytest.param("steparraylog", id="steparraylog")
--])
--@pytest.mark.parametrize(['transform', 'expected'], [
--    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
--    pytest.param(conj, lambda val: np.conj(val), id="conj"),
--])
--def test_CoeffUnitaryTransform(style, transform, expected):
--    coeff = coeff_generator(style, "f")
--    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
--
--
--@pytest.mark.parametrize(['style_left'], [
--    pytest.param("func", id="func"),
--    pytest.param("array", id="array"),
--    pytest.param("arraylog", id="logarray"),
--    pytest.param("string", id="string"),
--    pytest.param("steparray", id="steparray"),
--    pytest.param("steparraylog", id="steparraylog")
--])
--@pytest.mark.parametrize(['style_right'], [
--    pytest.param("func", id="func"),
--    pytest.param("array", id="array"),
--    pytest.param("arraylog", id="logarray"),
--    pytest.param("string", id="string"),
--    pytest.param("steparray", id="steparray"),
--    pytest.param("steparraylog", id="steparraylog")
--])
--@pytest.mark.parametrize(['oper'], [
--    pytest.param(lambda a, b: a+b, id="sum"),
--    pytest.param(lambda a, b: a*b, id="prod"),
--])
--def test_CoeffOperation(style_left, style_right, oper):
--    coeff_left = coeff_generator(style_left, "f")
--    coeff_right = coeff_generator(style_right, "g")
--    _assert_eq_over_interval(
--        oper(coeff_left, coeff_right),
--        lambda t: oper(coeff_left(t), coeff_right(t))
--    )
--
--
--@pytest.mark.requires_cython
--def test_CoeffReuse():
--    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
--    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
--    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
--    assert isinstance(coeff2, coeff1.__class__)
--    assert isinstance(coeff3, coeff1.__class__)
--
--
--@pytest.mark.requires_cython
--def test_CoeffOptions():
--    from itertools import combinations
--    base = "1 + 1. + 1j"
--    options = []
--    options.append(CompilationOptions(accept_int=True))
--    options.append(CompilationOptions(accept_float=False))
--    options.append(CompilationOptions(static_types=True))
--    options.append(CompilationOptions(try_parse=False))
--    options.append(CompilationOptions(use_cython=False))
--    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
--    for coeff in coeffs:
--        assert coeff(0) == 2+1j
--    for coeff1, coeff2 in combinations(coeffs, 2):
--        assert not isinstance(coeff1, coeff2.__class__)
--
--
--@pytest.mark.requires_cython
--@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
--    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
--                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
--                 lambda t: 0, id="long"),
--    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
--                 lambda t: t + 1, id="lots_of_ctes"),
--    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
--                 lambda t: np.cos(t), id="real_array_subscript"),
--    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
--                 lambda t: 1, id="cplx_array_subscript"),
--    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
--                 lambda t: np.cos(t), id="dictargs"),
--    pytest.param("cos(t*a); print(a)", {'a': 1},
--                 lambda t: np.cos(t), id="print"),
--    pytest.param("t + (0 if not 'something' else 1)", {},
--                 lambda t: t + 1, id="branch")
--])
--@pytest.mark.filterwarnings(
--    "ignore::qutip.core.coefficient.StringParsingWarning"
--)
--def test_CoeffParsingStressTest(codestring, args, reference):
--    opt = CompilationOptions(recompile=True)
--    coeff = coefficient(codestring, args=args, compile_opt=opt)
--    _assert_eq_over_interval(coeff, reference)
--
--
--@pytest.mark.requires_cython
--@pytest.mark.filterwarnings("error")
--def test_manual_typing():
--    opt = CompilationOptions(recompile=True)
--    coeff = coefficient("my_list[0] + my_dict[5]",
--                        args={"my_list": [1], "my_dict": {5: 2}},
--                        args_ctypes={"my_list": "list", "my_dict": "dict"},
--                        compile_opt=opt)
--    assert coeff(0) == 3
--
--
--@pytest.mark.requires_cython
--def test_advance_use():
--    opt = CompilationOptions(recompile=True, extra_import="""
--from qutip import basis
--from qutip.core.data cimport CSR
--from qutip.core.data.expect cimport expect_csr
--""")
--    csr = qutip.num(3).data
--    coeff = coefficient("expect_csr(op, op)",
--                        args={"op": csr},
--                        args_ctypes={"op": "CSR"},
--                        compile_opt=opt)
--    assert coeff(0) == 5.
--
--
--def _add(coeff):
--    return coeff + coeff
--
--
--def _pass(coeff):
--    return coeff
--
--
--def _mul(coeff):
--    return coeff * coeff
--
--
--@pytest.mark.parametrize(['style'], [
--    pytest.param("func", id="func"),
--    pytest.param("array", id="array"),
--    pytest.param("arraylog", id="logarray"),
--    pytest.param("string", id="string"),
--    pytest.param("steparray", id="steparray"),
--    pytest.param("steparraylog", id="steparraylog")
--])
--@pytest.mark.parametrize(['transform'], [
--    pytest.param(_pass, id="single"),
--    pytest.param(_add, id="sum"),
--    pytest.param(_mul, id="prod"),
--    pytest.param(norm, id="norm"),
--    pytest.param(conj, id="conj"),
--])
--def test_Coeffpickle(style, transform):
--    coeff = coeff_generator(style, "f")
--    coeff = transform(coeff)
--    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
--    _assert_eq_over_interval(coeff, coeff_pick)
--
--
--@pytest.mark.parametrize(['style'], [
--    pytest.param("func", id="func"),
--    pytest.param("array", id="array"),
--    pytest.param("arraylog", id="logarray"),
--    pytest.param("string", id="string"),
--    pytest.param("steparray", id="steparray"),
--    pytest.param("steparraylog", id="steparraylog")
--])
--@pytest.mark.parametrize(['transform'], [
--    pytest.param(_pass, id="single"),
--    pytest.param(_add, id="sum"),
--    pytest.param(_mul, id="prod"),
--    pytest.param(norm, id="norm"),
--    pytest.param(conj, id="conj"),
--])
--def test_Coeffcopy(style, transform):
--    coeff = coeff_generator(style, "f")
--    coeff = transform(coeff)
--    coeff_cp = coeff.copy()
--    _assert_eq_over_interval(coeff, coeff_cp)
--
--
--@pytest.mark.parametrize('order', [0, 1, 2, 3])
--def test_CoeffArray(order):
--    tlist = np.linspace(0, 1, 101)
--    y = np.exp((-1 + 1j) * tlist)
--    coeff = coefficient(y, tlist=tlist, order=order)
--    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
--    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
--                             inside=True)
--    dt = 1e-4
--    t = 0.0225
--    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
--    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
--    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
--             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
--    derrs = [derr, derr2, derr3]
--    for i in range(order):
--        assert derrs[i] != 0
--    for i in range(order, 3):
--        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
--
--
--def test_CoeffFromScipy():
--    tlist = np.linspace(0, 1.01, 101)
--    y = np.exp((-1 + 1j) * tlist)
--
--    coeff = coefficient(y, tlist=tlist, order=3)
--    from_scipy = coefficient(interp.CubicSpline(tlist, y))
--    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
--
--    coeff = coefficient(y, tlist=tlist, order=3)
--    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
--    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
--
--    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
--    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
--    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
--
--
--@pytest.mark.parametrize('map_func', [
--    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
--    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
--])
--@pytest.mark.requires_cython
--def test_coefficient_parallel(map_func):
--    otherwise_never_used = "np.log(np.exp(t + t + t))"
--    expected = coefficient(lambda t: 3 * t)
--
--    if map_func is qutip.solver.parallel.loky_pmap:
--        loky = pytest.importorskip("loky")
--        otherwise_never_used += " + 0"
--
--    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
--
--    for coeff in coeffs:
--        assert isinstance(coeff, Coefficient)
--        _assert_eq_over_interval(coeff, expected)
-+import pytest
-+import pickle
-+import qutip
-+import numpy as np
-+import scipy.interpolate as interp
-+from functools import partial
-+from qutip.core.coefficient import (coefficient, norm, conj,
-+                                    CompilationOptions, Coefficient,
-+                                    clean_compiled_coefficient
-+                                   )
-+from qutip.core.options import CoreOptions
-+
-+# Ensure the latest version is tested
-+clean_compiled_coefficient(True)
-+
-+
-+def f(t, w):
-+    return np.exp(w * t * np.pi)
-+
-+
-+def g(t, w):
-+    return np.cos(w * t * np.pi)
-+
-+
-+def h(t, a, b):
-+    return a + b + t
-+
-+
-+def f_kw(t, w, **args):
-+    return f(t, w)
-+
-+
-+def g_kw(t, w, **args):
-+    return g(t, w)
-+
-+
-+def h_kw(t, a, b, **args):
-+    return h(t, a, b)
-+
-+
-+def f_qtv4(t, args):
-+    return f(t, args["w"])
-+
-+
-+def g_qtv4(t, args):
-+    return g(t, args["w"])
-+
-+
-+def h_qtv4(t, args):
-+    return h(t, args["a"], args["b"])
-+
-+
-+def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
-+    "assert coeff1 == coeff2"
-+    "inside refer to the range covered by tlistlog: [0.01, 1]"
-+    ts = np.linspace(0.01, 1, 20)
-+    eps = 1e-12
-+    crit_times = [0.01+eps, 0.95, 1-eps]
-+    if not inside:
-+        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
-+    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
-+    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
-+    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
-+
-+
-+args = {"w": 1j}
-+tlist = np.linspace(0, 1, 101)
-+f_asarray = f(tlist, **args)
-+g_asarray = g(tlist, **args)
-+tlistlog = np.logspace(-2, 0, 501)
-+f_asarraylog = f(tlistlog, **args)
-+
-+
-+def coeff_generator(style, func):
-+    """Make a Coefficient"""
-+    if func == "f":
-+        base = f
-+    else:
-+        base = g
-+
-+    if style == "func":
-+        return coefficient(base, args=args)
-+    if style == "array":
-+        return coefficient(base(tlist, **args), tlist=tlist)
-+    if style == "arraylog":
-+        return coefficient(base(tlistlog, **args), tlist=tlistlog)
-+    if style == "string" and func == "f":
-+        return coefficient("exp(w * t * pi)", args=args)
-+    if style == "string" and func == "g":
-+        return coefficient("cos(w * t * pi)", args=args)
-+    if style == "steparray":
-+        return coefficient(base(tlist, **args), tlist=tlist,
-+                           order=0)
-+    if style == "steparraylog":
-+        return coefficient(base(tlistlog, **args), tlist=tlistlog,
-+                           order=0)
-+
-+
-+@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
-+    pytest.param(f, {'args': args},
-+                 1e-10, id="func"),
-+    pytest.param(f_kw, {'args': args},
-+                 1e-10, id="func_keywords"),
-+    pytest.param(f_qtv4, {'args': args},
-+                 1e-10, id="func_qutip_v4"),
-+    pytest.param(f_asarray, {'tlist': tlist},
-+                 1e-6,  id="array"),
-+    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
-+                 1e-1, id="step_array"),
-+    pytest.param(f_asarraylog, {'tlist': tlistlog},
-+                 1e-6, id="nonlinear_array"),
-+    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
-+                 1e-1, id="nonlinear_step_array"),
-+    pytest.param("exp(w * t * pi)", {'args': args},
-+                 1e-10, id="string")
-+])
-+def test_CoeffCreationCall(base, kwargs, tol):
-+    opt = CompilationOptions(recompile=True)
-+    expected = lambda t: np.exp(1j * t * np.pi)
-+    coeff = coefficient(base, **kwargs, compile_opt=opt)
-+    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
-+
-+
-+@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
-+    pytest.param(f, {'args': args},
-+                 1e-10, id="func"),
-+    pytest.param(f_kw, {'args': args},
-+                 1e-10, id="func_keywords"),
-+    pytest.param(f_qtv4, {'args': args},
-+                 1e-10, id="func_qutip_v4"),
-+    pytest.param("exp(w * t * pi)", {'args': args},
-+                 1e-10, id="string")
-+])
-+def test_CoeffCallArgs(base, kwargs, tol):
-+    w = np.e + 0.5j
-+    expected = lambda t: np.exp(w * t * np.pi)
-+    coeff = coefficient(base, **kwargs)
-+    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
-+
-+
-+@pytest.mark.parametrize(['base', 'tol'], [
-+    pytest.param(h, 1e-10, id="func"),
-+    pytest.param(h_kw, 1e-10, id="func_keywords"),
-+    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
-+    pytest.param("a + b + t", 1e-10, id="string")
-+])
-+def test_CoeffCallArguments(base, tol):
-+    # Partial args update
-+    args = {"a": 1, "b": 1}
-+    a = np.e
-+    expected = lambda t: a + 1 + t
-+    coeff = coefficient(base, args=args)
-+    coeff = coeff.replace_arguments({"a": a})
-+    _assert_eq_over_interval(coeff, expected, rtol=tol)
-+    b = np.pi
-+    expected = lambda t: a + b + t
-+    coeff = coeff.replace_arguments(b=b)
-+    _assert_eq_over_interval(coeff, expected, rtol=tol)
-+
-+
-+@pytest.mark.parametrize(['style'], [
-+    pytest.param("func", id="func"),
-+    pytest.param("array", id="array"),
-+    pytest.param("arraylog", id="logarray"),
-+    pytest.param("string", id="string"),
-+    pytest.param("steparray", id="steparray"),
-+    pytest.param("steparraylog", id="steparraylog")
-+])
-+@pytest.mark.parametrize(['transform', 'expected'], [
-+    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
-+    pytest.param(conj, lambda val: np.conj(val), id="conj"),
-+])
-+def test_CoeffUnitaryTransform(style, transform, expected):
-+    coeff = coeff_generator(style, "f")
-+    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
-+
-+
-+@pytest.mark.parametrize(['style_left'], [
-+    pytest.param("func", id="func"),
-+    pytest.param("array", id="array"),
-+    pytest.param("arraylog", id="logarray"),
-+    pytest.param("string", id="string"),
-+    pytest.param("steparray", id="steparray"),
-+    pytest.param("steparraylog", id="steparraylog")
-+])
-+@pytest.mark.parametrize(['style_right'], [
-+    pytest.param("func", id="func"),
-+    pytest.param("array", id="array"),
-+    pytest.param("arraylog", id="logarray"),
-+    pytest.param("string", id="string"),
-+    pytest.param("steparray", id="steparray"),
-+    pytest.param("steparraylog", id="steparraylog")
-+])
-+@pytest.mark.parametrize(['oper'], [
-+    pytest.param(lambda a, b: a+b, id="sum"),
-+    pytest.param(lambda a, b: a*b, id="prod"),
-+])
-+def test_CoeffOperation(style_left, style_right, oper):
-+    coeff_left = coeff_generator(style_left, "f")
-+    coeff_right = coeff_generator(style_right, "g")
-+    _assert_eq_over_interval(
-+        oper(coeff_left, coeff_right),
-+        lambda t: oper(coeff_left(t), coeff_right(t))
-+    )
-+
-+
-+@pytest.mark.requires_cython
-+def test_CoeffReuse():
-+    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
-+    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
-+    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
-+    assert isinstance(coeff2, coeff1.__class__)
-+    assert isinstance(coeff3, coeff1.__class__)
-+
-+
-+@pytest.mark.requires_cython
-+def test_CoeffOptions():
-+    from itertools import combinations
-+    base = "1 + 1. + 1j"
-+    options = []
-+    options.append(CompilationOptions(accept_int=True))
-+    options.append(CompilationOptions(accept_float=False))
-+    options.append(CompilationOptions(static_types=True))
-+    options.append(CompilationOptions(try_parse=False))
-+    options.append(CompilationOptions(use_cython=False))
-+    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
-+    for coeff in coeffs:
-+        assert coeff(0) == 2+1j
-+    for coeff1, coeff2 in combinations(coeffs, 2):
-+        assert not isinstance(coeff1, coeff2.__class__)
-+
-+
-+@pytest.mark.requires_cython
-+@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
-+    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
-+                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
-+                 lambda t: 0, id="long"),
-+    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
-+                 lambda t: t + 1, id="lots_of_ctes"),
-+    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
-+                 lambda t: np.cos(t), id="real_array_subscript"),
-+    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
-+                 lambda t: 1, id="cplx_array_subscript"),
-+    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
-+                 lambda t: np.cos(t), id="dictargs"),
-+    pytest.param("cos(t*a); print(a)", {'a': 1},
-+                 lambda t: np.cos(t), id="print"),
-+    pytest.param("t + (0 if not 'something' else 1)", {},
-+                 lambda t: t + 1, id="branch")
-+])
-+@pytest.mark.filterwarnings(
-+    "ignore::qutip.core.coefficient.StringParsingWarning"
-+)
-+def test_CoeffParsingStressTest(codestring, args, reference):
-+    opt = CompilationOptions(recompile=True)
-+    coeff = coefficient(codestring, args=args, compile_opt=opt)
-+    _assert_eq_over_interval(coeff, reference)
-+
-+
-+@pytest.mark.requires_cython
-+@pytest.mark.filterwarnings("error")
-+def test_manual_typing():
-+    opt = CompilationOptions(recompile=True)
-+    coeff = coefficient("my_list[0] + my_dict[5]",
-+                        args={"my_list": [1], "my_dict": {5: 2}},
-+                        args_ctypes={"my_list": "list", "my_dict": "dict"},
-+                        compile_opt=opt)
-+    assert coeff(0) == 3
-+
-+
-+@pytest.mark.requires_cython
-+def test_advance_use():
-+    opt = CompilationOptions(recompile=True, extra_import="""
-+from qutip import basis
-+from qutip.core.data cimport CSR
-+from qutip.core.data.expect cimport expect_csr
-+""")
-+    csr = qutip.num(3).data
-+    coeff = coefficient("expect_csr(op, op)",
-+                        args={"op": csr},
-+                        args_ctypes={"op": "CSR"},
-+                        compile_opt=opt)
-+    assert coeff(0) == 5.
-+
-+
-+def _add(coeff):
-+    return coeff + coeff
-+
-+
-+def _pass(coeff):
-+    return coeff
-+
-+
-+def _mul(coeff):
-+    return coeff * coeff
-+
-+
-+@pytest.mark.parametrize(['style'], [
-+    pytest.param("func", id="func"),
-+    pytest.param("array", id="array"),
-+    pytest.param("arraylog", id="logarray"),
-+    pytest.param("string", id="string"),
-+    pytest.param("steparray", id="steparray"),
-+    pytest.param("steparraylog", id="steparraylog")
-+])
-+@pytest.mark.parametrize(['transform'], [
-+    pytest.param(_pass, id="single"),
-+    pytest.param(_add, id="sum"),
-+    pytest.param(_mul, id="prod"),
-+    pytest.param(norm, id="norm"),
-+    pytest.param(conj, id="conj"),
-+])
-+def test_Coeffpickle(style, transform):
-+    coeff = coeff_generator(style, "f")
-+    coeff = transform(coeff)
-+    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
-+    _assert_eq_over_interval(coeff, coeff_pick)
-+
-+
-+@pytest.mark.parametrize(['style'], [
-+    pytest.param("func", id="func"),
-+    pytest.param("array", id="array"),
-+    pytest.param("arraylog", id="logarray"),
-+    pytest.param("string", id="string"),
-+    pytest.param("steparray", id="steparray"),
-+    pytest.param("steparraylog", id="steparraylog")
-+])
-+@pytest.mark.parametrize(['transform'], [
-+    pytest.param(_pass, id="single"),
-+    pytest.param(_add, id="sum"),
-+    pytest.param(_mul, id="prod"),
-+    pytest.param(norm, id="norm"),
-+    pytest.param(conj, id="conj"),
-+])
-+def test_Coeffcopy(style, transform):
-+    coeff = coeff_generator(style, "f")
-+    coeff = transform(coeff)
-+    coeff_cp = coeff.copy()
-+    _assert_eq_over_interval(coeff, coeff_cp)
-+
-+
-+@pytest.mark.parametrize('order', [0, 1, 2, 3])
-+def test_CoeffArray(order):
-+    tlist = np.linspace(0, 1, 101)
-+    y = np.exp((-1 + 1j) * tlist)
-+    coeff = coefficient(y, tlist=tlist, order=order)
-+    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
-+    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
-+                             inside=True)
-+    dt = 1e-4
-+    t = 0.0225
-+    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
-+    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
-+    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
-+             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
-+    derrs = [derr, derr2, derr3]
-+    for i in range(order):
-+        assert derrs[i] != 0
-+    for i in range(order, 3):
-+        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
-+
-+
-+def test_CoeffFromScipy():
-+    tlist = np.linspace(0, 1.01, 101)
-+    y = np.exp((-1 + 1j) * tlist)
-+
-+    coeff = coefficient(y, tlist=tlist, order=3)
-+    from_scipy = coefficient(interp.CubicSpline(tlist, y))
-+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-+
-+    coeff = coefficient(y, tlist=tlist, order=3)
-+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
-+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-+
-+    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
-+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
-+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-+
-+
-+@pytest.mark.parametrize('map_func', [
-+    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
-+    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
-+])
-+@pytest.mark.requires_cython
-+def test_coefficient_parallel(map_func):
-+    otherwise_never_used = "np.log(np.exp(t + t + t))"
-+    expected = coefficient(lambda t: 3 * t)
-+
-+    if map_func is qutip.solver.parallel.loky_pmap:
-+        loky = pytest.importorskip("loky")
-+        otherwise_never_used += " + 0"
-+
-+    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
-+
-+    for coeff in coeffs:
-+        assert isinstance(coeff, Coefficient)
-+        _assert_eq_over_interval(coeff, expected)
-diff --git a/qutip/tests/core/test_dimensions.py b/qutip/tests/core/test_dimensions.py
-index a32c3029..d21f2983 100644
---- a/qutip/tests/core/test_dimensions.py
-+++ b/qutip/tests/core/test_dimensions.py
-@@ -1,201 +1,201 @@
--# -*- coding: utf-8 -*-
--
--import pytest
--import collections
--import qutip
--from qutip.core.dimensions import (
--    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
--    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
--    collapse_dims_super, collapse_dims_oper,
--)
--
--_v = "vector"
--_vo = "vectorized_oper"
--
--
--@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
--    pytest.param([1], _v, True, id="scalar"),
--    pytest.param([1, 1], _v, True, id="tensor scalar"),
--    pytest.param([[1]], _vo, True, id="nested scalar"),
--    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
--    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
--    pytest.param([2], _v, False, id="vector"),
--    pytest.param([2, 3], _v, False, id="tensor vector"),
--    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
--    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
--    pytest.param([[2]], _vo, False, id="vectorised operator"),
--    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
--    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
--])
--@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
--def test_rank_type_detection(rank, actual_type, scalar, test_type):
--    """
--    Test the rank detection tests `is_scalar`, `is_vector` and
--    `is_vectorized_oper` for a range of different test cases.  These tests are
--    designed to be called on individual elements of the two-element `dims`
--    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
--
--    It's possible to be both a scalar and something else, but "vector" and
--    "vectorized_oper" are mutually exclusive.
--
--    These functions aren't properly specified for improper dimension setups, so
--    there are no tests for those.
--    """
--    expected = scalar if test_type == "scalar" else (actual_type == test_type)
--    function = getattr(qutip.dimensions, "is_" + test_type)
--    assert function(rank) == expected
--
--
--@pytest.mark.parametrize(["base", "flat"], [
--    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
--    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
--                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
--    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
--    pytest.param([], [], id="empty list"),
--    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
--])
--class TestFlattenUnflatten:
--    def test_flatten(self, base, flat):
--        assert flatten(base) == flat
--
--    def test_unflatten(self, base, flat):
--        labels = enumerate_flat(base)
--        assert unflatten(flat, labels) == base
--
--
--@pytest.mark.parametrize(["base", "expected"], [
--    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
--    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
--    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
--    pytest.param([], [], id="empty"),
--    pytest.param([[], [], [[[], [], []]]],
--                 [[], [], [[[], [], []]]], id="nested empty lists"),
--])
--def test_enumerate_flat(base, expected):
--    assert enumerate_flat(base) == expected
--
--
--@pytest.mark.parametrize(["base", "to_remove", "expected"], [
--    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
--    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
--                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
--    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
--    pytest.param([], (), [], id="empty"),
--])
--def test_deep_remove(base, to_remove, expected):
--    assert deep_remove(base, *to_remove) == expected
--
--
--@pytest.mark.parametrize("mapping", [
--    pytest.param(lambda x: x*2, id="(x -> 2x)"),
--    pytest.param(lambda x: [x], id="(x -> [x])"),
--])
--@pytest.mark.parametrize("base", [
--    pytest.param([[[0], 1], 2], id="standard"),
--    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
--    pytest.param([1, 2, 3], id="flat"),
--    pytest.param([], id="empty list"),
--    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
--])
--def test_deep_map(base, mapping):
--    """
--    Test the deep mapping.  To simplify generation of edge-cases, this tests
--    against an equivalent (but slower) operation of flattening and unflattening
--    the list.  We can get false negatives if the `flatten` or `unflatten`
--    functions are broken, but other tests should catch those.
--    """
--    # This function might not need to be public, and consequently might not
--    # need to be tested here.
--    labels = enumerate_flat(base)
--    expected = unflatten([mapping(x) for x in flatten(base)], labels)
--    assert deep_map(mapping, base) == expected
--
--
--_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
--
--
--@pytest.mark.parametrize("indices", [
--    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
--    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
--                 id="tensor-ket preserved"),
--    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
--    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
--                 id="tensor-bra preserved"),
--    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
--    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
--                 id="tensor-oper preserved"),
--    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
--                          [2, 3, 0, 1, 6, 7, 4, 5],
--                          (6, 8, 2, 4, 5, 7, 1, 3)),
--                 id="super-oper"),
--    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
--                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
--                 id="operator-ket"),
--    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
--                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
--                 id="operator-bra"),
--])
--class TestSuperOperatorDimsModification:
--    def test_dims_to_tensor_perm(self, indices):
--        # This function might not need to be public, and consequently might not
--        # need to be tested here.
--        assert dims_to_tensor_perm(indices.base) == indices.permutation
--
--    def test_dims_idxs_to_tensor_idxs(self, indices):
--        test_indices = list(range(len(flatten(indices.base))))
--        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
--                == indices.permutation)
--
--    def test_dims_to_tensor_shape(self, indices):
--        assert dims_to_tensor_shape(indices.base) == indices.shape
--
--
--class TestTypeFromDims:
--    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
--        pytest.param([[2], [2]], 'oper', True),
--        pytest.param([[2, 3], [2, 3]], 'oper', True),
--        pytest.param([[2], [3]], 'other', True),
--        pytest.param([[2], [3]], 'oper', False),
--        pytest.param([[2], [1]], 'ket', True),
--        pytest.param([[1], [2]], 'bra', True),
--        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
--        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
--        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
--        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
--        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
--    ])
--    def test_type_from_dims(self, base, expected, enforce_square):
--        assert type_from_dims(base, enforce_square=enforce_square) == expected
--
--    @pytest.mark.parametrize("qobj", [
--        pytest.param(qutip.rand_ket(10), id='ket'),
--        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
--        pytest.param(qutip.rand_dm(10), id='oper'),
--        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
--    ])
--    def test_qobj_dims_match_qobj(self, qobj):
--        assert type_from_dims(qobj.dims) == qobj.type
--
--
--class TestCollapseDims:
--    @pytest.mark.parametrize(["base", "expected"], [
--        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
--        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
--        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
--        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
--        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
--        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
--    ])
--    def test_oper(self, base, expected):
--        assert collapse_dims_oper(base) == expected
--
--    @pytest.mark.parametrize(["base", "expected"], [
--        pytest.param([[[1]], [[2, 3], [2, 3]]],
--                     [[[1]], [[6], [6]]], id="operator-ket"),
--        pytest.param([[[2, 3], [2, 3]], [[1]]],
--                     [[[6], [6]], [[1]]], id="operator-bra"),
--        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
--                     [[[6], [6]], [[6], [6]]], id="super"),
--    ])
--    def test_super(self, base, expected):
--        assert collapse_dims_super(base) == expected
-+# -*- coding: utf-8 -*-
-+
-+import pytest
-+import collections
-+import qutip
-+from qutip.core.dimensions import (
-+    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
-+    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
-+    collapse_dims_super, collapse_dims_oper,
-+)
-+
-+_v = "vector"
-+_vo = "vectorized_oper"
-+
-+
-+@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
-+    pytest.param([1], _v, True, id="scalar"),
-+    pytest.param([1, 1], _v, True, id="tensor scalar"),
-+    pytest.param([[1]], _vo, True, id="nested scalar"),
-+    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
-+    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
-+    pytest.param([2], _v, False, id="vector"),
-+    pytest.param([2, 3], _v, False, id="tensor vector"),
-+    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
-+    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
-+    pytest.param([[2]], _vo, False, id="vectorised operator"),
-+    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
-+    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
-+])
-+@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
-+def test_rank_type_detection(rank, actual_type, scalar, test_type):
-+    """
-+    Test the rank detection tests `is_scalar`, `is_vector` and
-+    `is_vectorized_oper` for a range of different test cases.  These tests are
-+    designed to be called on individual elements of the two-element `dims`
-+    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
-+
-+    It's possible to be both a scalar and something else, but "vector" and
-+    "vectorized_oper" are mutually exclusive.
-+
-+    These functions aren't properly specified for improper dimension setups, so
-+    there are no tests for those.
-+    """
-+    expected = scalar if test_type == "scalar" else (actual_type == test_type)
-+    function = getattr(qutip.dimensions, "is_" + test_type)
-+    assert function(rank) == expected
-+
-+
-+@pytest.mark.parametrize(["base", "flat"], [
-+    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
-+    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
-+                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
-+    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
-+    pytest.param([], [], id="empty list"),
-+    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
-+])
-+class TestFlattenUnflatten:
-+    def test_flatten(self, base, flat):
-+        assert flatten(base) == flat
-+
-+    def test_unflatten(self, base, flat):
-+        labels = enumerate_flat(base)
-+        assert unflatten(flat, labels) == base
-+
-+
-+@pytest.mark.parametrize(["base", "expected"], [
-+    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
-+    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
-+    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
-+    pytest.param([], [], id="empty"),
-+    pytest.param([[], [], [[[], [], []]]],
-+                 [[], [], [[[], [], []]]], id="nested empty lists"),
-+])
-+def test_enumerate_flat(base, expected):
-+    assert enumerate_flat(base) == expected
-+
-+
-+@pytest.mark.parametrize(["base", "to_remove", "expected"], [
-+    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
-+    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
-+                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
-+    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
-+    pytest.param([], (), [], id="empty"),
-+])
-+def test_deep_remove(base, to_remove, expected):
-+    assert deep_remove(base, *to_remove) == expected
-+
-+
-+@pytest.mark.parametrize("mapping", [
-+    pytest.param(lambda x: x*2, id="(x -> 2x)"),
-+    pytest.param(lambda x: [x], id="(x -> [x])"),
-+])
-+@pytest.mark.parametrize("base", [
-+    pytest.param([[[0], 1], 2], id="standard"),
-+    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
-+    pytest.param([1, 2, 3], id="flat"),
-+    pytest.param([], id="empty list"),
-+    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
-+])
-+def test_deep_map(base, mapping):
-+    """
-+    Test the deep mapping.  To simplify generation of edge-cases, this tests
-+    against an equivalent (but slower) operation of flattening and unflattening
-+    the list.  We can get false negatives if the `flatten` or `unflatten`
-+    functions are broken, but other tests should catch those.
-+    """
-+    # This function might not need to be public, and consequently might not
-+    # need to be tested here.
-+    labels = enumerate_flat(base)
-+    expected = unflatten([mapping(x) for x in flatten(base)], labels)
-+    assert deep_map(mapping, base) == expected
-+
-+
-+_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
-+
-+
-+@pytest.mark.parametrize("indices", [
-+    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
-+    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
-+                 id="tensor-ket preserved"),
-+    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
-+    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
-+                 id="tensor-bra preserved"),
-+    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
-+    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
-+                 id="tensor-oper preserved"),
-+    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
-+                          [2, 3, 0, 1, 6, 7, 4, 5],
-+                          (6, 8, 2, 4, 5, 7, 1, 3)),
-+                 id="super-oper"),
-+    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
-+                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
-+                 id="operator-ket"),
-+    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
-+                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
-+                 id="operator-bra"),
-+])
-+class TestSuperOperatorDimsModification:
-+    def test_dims_to_tensor_perm(self, indices):
-+        # This function might not need to be public, and consequently might not
-+        # need to be tested here.
-+        assert dims_to_tensor_perm(indices.base) == indices.permutation
-+
-+    def test_dims_idxs_to_tensor_idxs(self, indices):
-+        test_indices = list(range(len(flatten(indices.base))))
-+        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
-+                == indices.permutation)
-+
-+    def test_dims_to_tensor_shape(self, indices):
-+        assert dims_to_tensor_shape(indices.base) == indices.shape
-+
-+
-+class TestTypeFromDims:
-+    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
-+        pytest.param([[2], [2]], 'oper', True),
-+        pytest.param([[2, 3], [2, 3]], 'oper', True),
-+        pytest.param([[2], [3]], 'other', True),
-+        pytest.param([[2], [3]], 'oper', False),
-+        pytest.param([[2], [1]], 'ket', True),
-+        pytest.param([[1], [2]], 'bra', True),
-+        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
-+        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
-+        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
-+        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
-+        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
-+    ])
-+    def test_type_from_dims(self, base, expected, enforce_square):
-+        assert type_from_dims(base, enforce_square=enforce_square) == expected
-+
-+    @pytest.mark.parametrize("qobj", [
-+        pytest.param(qutip.rand_ket(10), id='ket'),
-+        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
-+        pytest.param(qutip.rand_dm(10), id='oper'),
-+        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
-+    ])
-+    def test_qobj_dims_match_qobj(self, qobj):
-+        assert type_from_dims(qobj.dims) == qobj.type
-+
-+
-+class TestCollapseDims:
-+    @pytest.mark.parametrize(["base", "expected"], [
-+        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
-+        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
-+        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
-+        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
-+        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
-+        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
-+    ])
-+    def test_oper(self, base, expected):
-+        assert collapse_dims_oper(base) == expected
-+
-+    @pytest.mark.parametrize(["base", "expected"], [
-+        pytest.param([[[1]], [[2, 3], [2, 3]]],
-+                     [[[1]], [[6], [6]]], id="operator-ket"),
-+        pytest.param([[[2, 3], [2, 3]], [[1]]],
-+                     [[[6], [6]], [[1]]], id="operator-bra"),
-+        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
-+                     [[[6], [6]], [[6], [6]]], id="super"),
-+    ])
-+    def test_super(self, base, expected):
-+        assert collapse_dims_super(base) == expected
-diff --git a/qutip/tests/core/test_eigen.py b/qutip/tests/core/test_eigen.py
-index ecf6f609..05e06db0 100644
---- a/qutip/tests/core/test_eigen.py
-+++ b/qutip/tests/core/test_eigen.py
-@@ -1,118 +1,118 @@
--import scipy
--import numpy as np
--import pytest
--import qutip
--
--
--def is_eigen_set(oper, vals, vecs):
--    for val, vec in zip(vals, vecs):
--        assert abs(vec.norm() - 1) < 1e-13
--        assert abs(qutip.expect(oper, vec) - val) < 1e-13
--
--
--@pytest.mark.parametrize(["sparse", 'dtype'], [
--    pytest.param(True, 'csr', id="sparse"),
--    pytest.param(False, 'csr', id="sparse2dense"),
--    pytest.param(False, 'dense', id="dense"),
--])
--def test_eigen_known_oper(sparse, dtype):
--    N = qutip.num(10, dtype=dtype)
--    spvals, spvecs = N.eigenstates(sparse=sparse)
--    expected = np.arange(10)
--    is_eigen_set(N, spvals, spvecs)
--    np.testing.assert_allclose(spvals, expected, atol=1e-13)
--
--
--@pytest.mark.parametrize(["sparse", 'dtype'], [
--    pytest.param(True, 'csr', id="sparse"),
--    pytest.param(False, 'csr', id="sparse2dense"),
--    pytest.param(False, 'dense', id="dense"),
--])
--@pytest.mark.parametrize(["rand"], [
--    pytest.param(qutip.rand_herm, id="hermitian"),
--    pytest.param(qutip.rand_unitary, id="non-hermitian"),
--])
--@pytest.mark.parametrize("order", ['low', 'high'])
--def test_eigen_rand_oper(rand, sparse, dtype, order):
--    H = rand(10, dtype=dtype)
--    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
--    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
--    if order == 'low':
--        assert np.all(np.diff(spvals).real >= 0)
--    else:
--        assert np.all(np.diff(spvals).real <= 0)
--    is_eigen_set(H, spvals, spvecs)
--    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
--
--
--@pytest.mark.parametrize(["sparse", 'dtype'], [
--    pytest.param(True, 'csr', id="sparse"),
--    pytest.param(False, 'csr', id="sparse2dense"),
--    pytest.param(False, 'dense', id="dense"),
--])
--@pytest.mark.parametrize("rand", [
--    pytest.param(qutip.rand_herm, id="hermitian"),
--    pytest.param(qutip.rand_unitary, id="non-hermitian"),
--])
--@pytest.mark.parametrize("order", ['low', 'high'])
--@pytest.mark.parametrize("N", [1, 5, 8, 9])
--def test_FewState(rand, sparse, dtype, order, N):
--    H = rand(10, dtype=dtype)
--    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
--    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
--    assert np.allclose(all_spvals[:N], spvals)
--    is_eigen_set(H, spvals, spvecs)
--    if order == 'low':
--        assert np.all(np.diff(spvals).real >= 0)
--    else:
--        assert np.all(np.diff(spvals).real <= 0)
--
--
--@pytest.mark.parametrize(["sparse", 'dtype'], [
--    pytest.param(True, 'csr', id="sparse"),
--    pytest.param(False, 'csr', id="sparse2dense"),
--    pytest.param(False, 'dense', id="dense"),
--])
--@pytest.mark.parametrize(["rand"], [
--    pytest.param(qutip.rand_herm, id="hermitian"),
--    pytest.param(qutip.rand_unitary, id="non-hermitian"),
--])
--@pytest.mark.parametrize("order", ['low', 'high'])
--@pytest.mark.parametrize("N", [1, 5, 8, 9])
--def test_ValsOnly(rand, sparse, dtype, order, N):
--    H = rand(10, dtype=dtype)
--    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
--    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
--    assert np.allclose(all_spvals[:N], spvals)
--    if order == 'low':
--        assert np.all(np.diff(spvals).real >= 0)
--    else:
--        assert np.all(np.diff(spvals).real <= 0)
--
--
--@pytest.mark.parametrize(["sparse", 'dtype'], [
--    pytest.param(True, 'csr', id="sparse"),
--    pytest.param(False, 'csr', id="sparse2dense"),
--    pytest.param(False, 'dense', id="dense"),
--])
--def test_eigen_small(sparse, dtype):
--    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
--    all_spvals = H.eigenenergies(sparse=sparse)
--    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
--    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
--    is_eigen_set(H, spvals, spvecs)
--
--
--def test_BigDenseValsOnly():
--    """
--    This checks eigenvalue calculation for large dense matrices, which
--    historically have had instabilities with certain OS and BLAS combinations
--    (see e.g. #1288 and #1495).
--    """
--    dimension = 2000
--    # Allow an average absolute tolerance for each eigenvalue; we expect
--    # uncertainty in the sum to add in quadrature.
--    tol = 1e-12 * np.sqrt(dimension)
--    H = qutip.rand_herm(dimension, density=1e-2)
--    spvals = H.eigenenergies()
--    assert abs(H.tr() - spvals.sum()) < tol
-+import scipy
-+import numpy as np
-+import pytest
-+import qutip
-+
-+
-+def is_eigen_set(oper, vals, vecs):
-+    for val, vec in zip(vals, vecs):
-+        assert abs(vec.norm() - 1) < 1e-13
-+        assert abs(qutip.expect(oper, vec) - val) < 1e-13
-+
-+
-+@pytest.mark.parametrize(["sparse", 'dtype'], [
-+    pytest.param(True, 'csr', id="sparse"),
-+    pytest.param(False, 'csr', id="sparse2dense"),
-+    pytest.param(False, 'dense', id="dense"),
-+])
-+def test_eigen_known_oper(sparse, dtype):
-+    N = qutip.num(10, dtype=dtype)
-+    spvals, spvecs = N.eigenstates(sparse=sparse)
-+    expected = np.arange(10)
-+    is_eigen_set(N, spvals, spvecs)
-+    np.testing.assert_allclose(spvals, expected, atol=1e-13)
-+
-+
-+@pytest.mark.parametrize(["sparse", 'dtype'], [
-+    pytest.param(True, 'csr', id="sparse"),
-+    pytest.param(False, 'csr', id="sparse2dense"),
-+    pytest.param(False, 'dense', id="dense"),
-+])
-+@pytest.mark.parametrize(["rand"], [
-+    pytest.param(qutip.rand_herm, id="hermitian"),
-+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-+])
-+@pytest.mark.parametrize("order", ['low', 'high'])
-+def test_eigen_rand_oper(rand, sparse, dtype, order):
-+    H = rand(10, dtype=dtype)
-+    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
-+    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
-+    if order == 'low':
-+        assert np.all(np.diff(spvals).real >= 0)
-+    else:
-+        assert np.all(np.diff(spvals).real <= 0)
-+    is_eigen_set(H, spvals, spvecs)
-+    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
-+
-+
-+@pytest.mark.parametrize(["sparse", 'dtype'], [
-+    pytest.param(True, 'csr', id="sparse"),
-+    pytest.param(False, 'csr', id="sparse2dense"),
-+    pytest.param(False, 'dense', id="dense"),
-+])
-+@pytest.mark.parametrize("rand", [
-+    pytest.param(qutip.rand_herm, id="hermitian"),
-+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-+])
-+@pytest.mark.parametrize("order", ['low', 'high'])
-+@pytest.mark.parametrize("N", [1, 5, 8, 9])
-+def test_FewState(rand, sparse, dtype, order, N):
-+    H = rand(10, dtype=dtype)
-+    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
-+    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
-+    assert np.allclose(all_spvals[:N], spvals)
-+    is_eigen_set(H, spvals, spvecs)
-+    if order == 'low':
-+        assert np.all(np.diff(spvals).real >= 0)
-+    else:
-+        assert np.all(np.diff(spvals).real <= 0)
-+
-+
-+@pytest.mark.parametrize(["sparse", 'dtype'], [
-+    pytest.param(True, 'csr', id="sparse"),
-+    pytest.param(False, 'csr', id="sparse2dense"),
-+    pytest.param(False, 'dense', id="dense"),
-+])
-+@pytest.mark.parametrize(["rand"], [
-+    pytest.param(qutip.rand_herm, id="hermitian"),
-+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-+])
-+@pytest.mark.parametrize("order", ['low', 'high'])
-+@pytest.mark.parametrize("N", [1, 5, 8, 9])
-+def test_ValsOnly(rand, sparse, dtype, order, N):
-+    H = rand(10, dtype=dtype)
-+    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
-+    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
-+    assert np.allclose(all_spvals[:N], spvals)
-+    if order == 'low':
-+        assert np.all(np.diff(spvals).real >= 0)
-+    else:
-+        assert np.all(np.diff(spvals).real <= 0)
-+
-+
-+@pytest.mark.parametrize(["sparse", 'dtype'], [
-+    pytest.param(True, 'csr', id="sparse"),
-+    pytest.param(False, 'csr', id="sparse2dense"),
-+    pytest.param(False, 'dense', id="dense"),
-+])
-+def test_eigen_small(sparse, dtype):
-+    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
-+    all_spvals = H.eigenenergies(sparse=sparse)
-+    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
-+    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
-+    is_eigen_set(H, spvals, spvecs)
-+
-+
-+def test_BigDenseValsOnly():
-+    """
-+    This checks eigenvalue calculation for large dense matrices, which
-+    historically have had instabilities with certain OS and BLAS combinations
-+    (see e.g. #1288 and #1495).
-+    """
-+    dimension = 2000
-+    # Allow an average absolute tolerance for each eigenvalue; we expect
-+    # uncertainty in the sum to add in quadrature.
-+    tol = 1e-12 * np.sqrt(dimension)
-+    H = qutip.rand_herm(dimension, density=1e-2)
-+    spvals = H.eigenenergies()
-+    assert abs(H.tr() - spvals.sum()) < tol
-diff --git a/qutip/tests/core/test_eigenstates.py b/qutip/tests/core/test_eigenstates.py
-index e03add4b..bbd00c22 100644
---- a/qutip/tests/core/test_eigenstates.py
-+++ b/qutip/tests/core/test_eigenstates.py
-@@ -1,98 +1,98 @@
--import pytest
--import numpy as np
--import qutip
--from itertools import combinations
--
--
--def _canonicalise_eigenvector(vec):
--    """
--    Normalise an eigenvector so that the first non-zero value is equal to one,
--    and the array is flattened.  Just normalising based on vector magnitude
--    isn't enough to fully fix the gauge because the vectors could still be
--    multiplied by a unit complex number.
--    """
--    vec = vec.flatten()
--    nonzero = vec != 0
--    if not np.any(nonzero):
--        return vec
--    return vec / vec[np.argmax(nonzero)]
--
--
--# Random diagonal Hamiltonian.
--_diagonal_dimension = 10
--_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
--_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
--                                  for n in range(_diagonal_dimension)])
--_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
--
--# Arbitrary known non-diagonal complex Hamiltonian.
--_nondiagonal_hamiltonian = qutip.Qobj(np.array([
--    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
--    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
--    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
--_nondiagonal_eigenvalues = np.array([
--    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
--_nondiagonal_eigenstates = np.array([
--    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
--     0.009793118179759598+0.3029065489313791j],
--    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
--     -0.3741560255426259+0.6067259021655438j],
--    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
--     -0.5593181579625106+0.2953063897306936j]])
--
--
--@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
--    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
--    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
--                 _diagonal_eigenstates,
--                 id="diagonal-"+str(_diagonal_dimension)),
--    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
--    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
--                 _nondiagonal_eigenstates, id="non-diagonal"),
--])
--def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
--    test_values, test_states = hamiltonian.eigenstates()
--    eigenvalues = np.array(eigenvalues)
--    eigenstates = np.array(eigenstates)
--    test_order = np.argsort(test_values)
--    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
--                    for i in test_order]
--    expected_order = np.argsort(eigenvalues)
--    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
--                        for i in expected_order]
--    np.testing.assert_allclose(test_values[test_order],
--                               eigenvalues[expected_order],
--                               atol=1e-10)
--    for test, expected in zip(test_vectors, expected_vectors):
--        np.testing.assert_allclose(test, expected, atol=1e-10)
--
--
--# Specify parametrisation over a random Hamiltonian by specifying the
--# dimensions, rather than duplicating that logic.
--@pytest.fixture(params=[
--    pytest.param([10], id="simple"),
--    pytest.param([5, 3, 4], id="tensor"),
--    pytest.param([3, 3, 3], id="degenerate")])
--def random_hamiltonian(request):
--    dimensions = request.param
--    eigen = None
--    dist = "fill"
--    if dimensions == [3, 3, 3]:
--        eigen = [0, 1, 1] * 9
--        dist = "eigen"
--    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
--
--
--@pytest.mark.parametrize('sparse', [True, False])
--@pytest.mark.parametrize('dtype', ['csr', 'dense'])
--def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
--    random_hamiltonian = random_hamiltonian.to(dtype)
--    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
--    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
--        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
--                                   (eigenvalue * eigenstate).full(),
--                                   atol=1e-10)
--        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
--    errors = [evec1.overlap(evec2)
--              for evec1, evec2 in combinations(eigenstates, 2)]
--    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
-+import pytest
-+import numpy as np
-+import qutip
-+from itertools import combinations
-+
-+
-+def _canonicalise_eigenvector(vec):
-+    """
-+    Normalise an eigenvector so that the first non-zero value is equal to one,
-+    and the array is flattened.  Just normalising based on vector magnitude
-+    isn't enough to fully fix the gauge because the vectors could still be
-+    multiplied by a unit complex number.
-+    """
-+    vec = vec.flatten()
-+    nonzero = vec != 0
-+    if not np.any(nonzero):
-+        return vec
-+    return vec / vec[np.argmax(nonzero)]
-+
-+
-+# Random diagonal Hamiltonian.
-+_diagonal_dimension = 10
-+_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
-+_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
-+                                  for n in range(_diagonal_dimension)])
-+_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
-+
-+# Arbitrary known non-diagonal complex Hamiltonian.
-+_nondiagonal_hamiltonian = qutip.Qobj(np.array([
-+    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
-+    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
-+    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
-+_nondiagonal_eigenvalues = np.array([
-+    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
-+_nondiagonal_eigenstates = np.array([
-+    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
-+     0.009793118179759598+0.3029065489313791j],
-+    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
-+     -0.3741560255426259+0.6067259021655438j],
-+    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
-+     -0.5593181579625106+0.2953063897306936j]])
-+
-+
-+@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
-+    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
-+    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
-+                 _diagonal_eigenstates,
-+                 id="diagonal-"+str(_diagonal_dimension)),
-+    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
-+    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
-+                 _nondiagonal_eigenstates, id="non-diagonal"),
-+])
-+def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
-+    test_values, test_states = hamiltonian.eigenstates()
-+    eigenvalues = np.array(eigenvalues)
-+    eigenstates = np.array(eigenstates)
-+    test_order = np.argsort(test_values)
-+    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
-+                    for i in test_order]
-+    expected_order = np.argsort(eigenvalues)
-+    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
-+                        for i in expected_order]
-+    np.testing.assert_allclose(test_values[test_order],
-+                               eigenvalues[expected_order],
-+                               atol=1e-10)
-+    for test, expected in zip(test_vectors, expected_vectors):
-+        np.testing.assert_allclose(test, expected, atol=1e-10)
-+
-+
-+# Specify parametrisation over a random Hamiltonian by specifying the
-+# dimensions, rather than duplicating that logic.
-+@pytest.fixture(params=[
-+    pytest.param([10], id="simple"),
-+    pytest.param([5, 3, 4], id="tensor"),
-+    pytest.param([3, 3, 3], id="degenerate")])
-+def random_hamiltonian(request):
-+    dimensions = request.param
-+    eigen = None
-+    dist = "fill"
-+    if dimensions == [3, 3, 3]:
-+        eigen = [0, 1, 1] * 9
-+        dist = "eigen"
-+    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
-+
-+
-+@pytest.mark.parametrize('sparse', [True, False])
-+@pytest.mark.parametrize('dtype', ['csr', 'dense'])
-+def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
-+    random_hamiltonian = random_hamiltonian.to(dtype)
-+    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
-+    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
-+        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
-+                                   (eigenvalue * eigenstate).full(),
-+                                   atol=1e-10)
-+        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
-+    errors = [evec1.overlap(evec2)
-+              for evec1, evec2 in combinations(eigenstates, 2)]
-+    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
-diff --git a/qutip/tests/core/test_expect.py b/qutip/tests/core/test_expect.py
-index 906880ce..96e7ff0f 100644
---- a/qutip/tests/core/test_expect.py
-+++ b/qutip/tests/core/test_expect.py
-@@ -1,179 +1,179 @@
--import pytest
--import collections
--import functools
--import numpy as np
--import qutip
--from qutip.core.data import CSR, Dense
--import qutip.core.data as _data
--
--# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
--# of different systems, without having to repeatedly specify the systems over
--# and over again.  We first store a small number of test cases for known
--# expectation value in the most bundled-up form, because it's easier to unroll
--# these by applying the expected broadcasting rules explicitly ourselves than
--# performing the inverse operation.
--#
--# We store a single test case in a record type, just to keep things neatly
--# together while we're munging them, so it's clear at all times what
--# constitutes a valid test case.
--
--_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
--
--
--def _case_to_dm(case):
--    return case._replace(state=[x.proj() for x in case.state])
--
--
--def _unwrap(list_):
--    """Unwrap lists until we reach the first non-list element."""
--    out = list_
--    while isinstance(out, list):
--        out = out[0]
--    return out
--
--
--def _case_id(case):
--    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
--    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
--    return op_part + "-" + state_part
--
--
--# This is the minimal set of test cases, with a Fock system and a qubit system
--# both in ket form and dm form.  The reference expectations are a 2D array
--# which would be found by broadcasting `operator` against `state` and applying
--# `qutip.expect` to the pairs.
--_dim = 5
--_num, _a = qutip.num(_dim), qutip.destroy(_dim)
--_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
--_known_fock = _Case([_num, _a],
--                    [qutip.fock(_dim, n) for n in range(_dim)],
--                    np.array([np.arange(_dim), np.zeros(_dim)]))
--_known_qubit = _Case([_sx, _sz, _sp],
--                     [qutip.basis(2, 0), qutip.basis(2, 1)],
--                     np.array([[0, 0], [1, -1], [0, 0]]))
--_known_cases = [_known_fock, _case_to_dm(_known_fock),
--                _known_qubit, _case_to_dm(_known_qubit)]
--
--
--class TestKnownExpectation:
--    def pytest_generate_tests(self, metafunc):
--        """
--        Perform the parametrisation over the test cases, performing the
--        explicit broadcasting into separate test cases when required.
--
--        We detect whether to perform explicit broadcasting over one of the
--        arguments of the `_Case` by looking for a singular/plural name of the
--        parameter in the test.  If the parameter is singular, then we manually
--        perform the broadcasting rule for that fixture, and parametrise over
--        the resulting list, taking care to pick out the correct parts of the
--        reference array.
--        """
--        cases = _known_cases
--        op_name, state_name = 'operator', 'state'
--        if op_name not in metafunc.fixturenames:
--            op_name += 's'
--        else:
--            cases = [_Case(op, case.state, expected)
--                     for case in cases
--                     for op, expected in zip(case.operator, case.expected)]
--        if state_name not in metafunc.fixturenames:
--            state_name += 's'
--        else:
--            cases = [_Case(case.operator, state, expected)
--                     for case in cases
--                     for state, expected in zip(case.state, case.expected.T)]
--        metafunc.parametrize([op_name, state_name, 'expected'], cases,
--                             ids=[_case_id(case) for case in cases])
--
--    def test_operator_by_basis(self, operator, state, expected):
--        result = qutip.expect(operator, state)
--        assert result == expected
--        assert isinstance(result, float if operator.isherm else complex)
--
--    def test_broadcast_operator_list(self, operators, state, expected):
--        result = qutip.expect(operators, state)
--        expected_dtype = (np.float64 if all(op.isherm for op in operators)
--                          else np.complex128)
--        assert isinstance(result, np.ndarray)
--        assert result.dtype == expected_dtype
--        assert list(result) == list(expected)
--
--    def test_broadcast_state_list(self, operator, states, expected):
--        result = qutip.expect(operator, states)
--        expected_dtype = np.float64 if operator.isherm else np.complex128
--        assert isinstance(result, np.ndarray)
--        assert result.dtype == expected_dtype
--        assert list(result) == list(expected)
--
--    def test_broadcast_both_lists(self, operators, states, expected):
--        result = qutip.expect(operators, states)
--        assert len(result) == len(operators)
--        for part, operator, expected_part in zip(result, operators, expected):
--            expected_dtype = np.float64 if operator.isherm else np.complex128
--            assert isinstance(part, np.ndarray)
--            assert part.dtype == expected_dtype
--            assert list(part) == list(expected_part)
--
--
--@pytest.mark.repeat(5)
--@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
--@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
--@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
--def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
--    dimension = 20
--    state = qutip.rand_ket(dimension, 0.3).to(op_type)
--    op = qutip.rand_herm(dimension, 0.2).to(state_type)
--    if not hermitian:
--        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
--    expected = state.dag() * op * state
--    assert abs(qutip.expect(op, state) - expected) < 1e-14
--
--
--@pytest.mark.parametrize("solve", [
--    pytest.param(qutip.sesolve, id="sesolve"),
--    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
--                 id="mesolve"),
--])
--def test_compatibility_with_solver(solve):
--    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
--    e_ops += [lambda t, psi: np.sin(t)]
--    h = qutip.sigmax()
--    state = qutip.basis(2, 0)
--    times = np.linspace(0, 10, 101)
--    options = {"store_states":True}
--    result = solve(h, state, times, e_ops=e_ops, options=options)
--    direct, states = result.expect, result.states
--    indirect = qutip.expect(e_ops[:-1], states)
--    # check measurement operators based on quantum objects
--    assert len(direct)-1 == len(indirect)
--    for direct_, indirect_ in zip(direct, indirect):
--        assert len(direct_) == len(indirect_)
--        assert isinstance(direct_, np.ndarray)
--        assert isinstance(indirect_, np.ndarray)
--        assert direct_.dtype == indirect_.dtype
--        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
--        # test measurement operators based on lambda functions
--        direct_ = direct[-1]
--        indirect_ = np.sin(times)
--        assert len(direct_) == len(indirect_)
--        assert isinstance(direct_, np.ndarray)
--        assert isinstance(indirect_, np.ndarray)
--        assert direct_.dtype == indirect_.dtype
--        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
--
--
--def test_no_real_attribute(monkeypatch):
--    """This tests ensures that expect still works even if the output of a
--    specialisation does not have the ``real`` attribute. This is the case for
--    the tensorflow and cupy data layers."""
--
--    def mocker_expect_return(oper, state):
--        """
--        We simply return None which does not have the `real` attribute.
--        """
--        return "object without .real"
--
--    monkeypatch.setattr(_data, "expect", mocker_expect_return)
--
--    sz = qutip.sigmaz() # the choice of the matrix does not matter
--    assert "object without .real" == qutip.expect(sz, sz)
-+import pytest
-+import collections
-+import functools
-+import numpy as np
-+import qutip
-+from qutip.core.data import CSR, Dense
-+import qutip.core.data as _data
-+
-+# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
-+# of different systems, without having to repeatedly specify the systems over
-+# and over again.  We first store a small number of test cases for known
-+# expectation value in the most bundled-up form, because it's easier to unroll
-+# these by applying the expected broadcasting rules explicitly ourselves than
-+# performing the inverse operation.
-+#
-+# We store a single test case in a record type, just to keep things neatly
-+# together while we're munging them, so it's clear at all times what
-+# constitutes a valid test case.
-+
-+_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
-+
-+
-+def _case_to_dm(case):
-+    return case._replace(state=[x.proj() for x in case.state])
-+
-+
-+def _unwrap(list_):
-+    """Unwrap lists until we reach the first non-list element."""
-+    out = list_
-+    while isinstance(out, list):
-+        out = out[0]
-+    return out
-+
-+
-+def _case_id(case):
-+    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
-+    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
-+    return op_part + "-" + state_part
-+
-+
-+# This is the minimal set of test cases, with a Fock system and a qubit system
-+# both in ket form and dm form.  The reference expectations are a 2D array
-+# which would be found by broadcasting `operator` against `state` and applying
-+# `qutip.expect` to the pairs.
-+_dim = 5
-+_num, _a = qutip.num(_dim), qutip.destroy(_dim)
-+_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
-+_known_fock = _Case([_num, _a],
-+                    [qutip.fock(_dim, n) for n in range(_dim)],
-+                    np.array([np.arange(_dim), np.zeros(_dim)]))
-+_known_qubit = _Case([_sx, _sz, _sp],
-+                     [qutip.basis(2, 0), qutip.basis(2, 1)],
-+                     np.array([[0, 0], [1, -1], [0, 0]]))
-+_known_cases = [_known_fock, _case_to_dm(_known_fock),
-+                _known_qubit, _case_to_dm(_known_qubit)]
-+
-+
-+class TestKnownExpectation:
-+    def pytest_generate_tests(self, metafunc):
-+        """
-+        Perform the parametrisation over the test cases, performing the
-+        explicit broadcasting into separate test cases when required.
-+
-+        We detect whether to perform explicit broadcasting over one of the
-+        arguments of the `_Case` by looking for a singular/plural name of the
-+        parameter in the test.  If the parameter is singular, then we manually
-+        perform the broadcasting rule for that fixture, and parametrise over
-+        the resulting list, taking care to pick out the correct parts of the
-+        reference array.
-+        """
-+        cases = _known_cases
-+        op_name, state_name = 'operator', 'state'
-+        if op_name not in metafunc.fixturenames:
-+            op_name += 's'
-+        else:
-+            cases = [_Case(op, case.state, expected)
-+                     for case in cases
-+                     for op, expected in zip(case.operator, case.expected)]
-+        if state_name not in metafunc.fixturenames:
-+            state_name += 's'
-+        else:
-+            cases = [_Case(case.operator, state, expected)
-+                     for case in cases
-+                     for state, expected in zip(case.state, case.expected.T)]
-+        metafunc.parametrize([op_name, state_name, 'expected'], cases,
-+                             ids=[_case_id(case) for case in cases])
-+
-+    def test_operator_by_basis(self, operator, state, expected):
-+        result = qutip.expect(operator, state)
-+        assert result == expected
-+        assert isinstance(result, float if operator.isherm else complex)
-+
-+    def test_broadcast_operator_list(self, operators, state, expected):
-+        result = qutip.expect(operators, state)
-+        expected_dtype = (np.float64 if all(op.isherm for op in operators)
-+                          else np.complex128)
-+        assert isinstance(result, np.ndarray)
-+        assert result.dtype == expected_dtype
-+        assert list(result) == list(expected)
-+
-+    def test_broadcast_state_list(self, operator, states, expected):
-+        result = qutip.expect(operator, states)
-+        expected_dtype = np.float64 if operator.isherm else np.complex128
-+        assert isinstance(result, np.ndarray)
-+        assert result.dtype == expected_dtype
-+        assert list(result) == list(expected)
-+
-+    def test_broadcast_both_lists(self, operators, states, expected):
-+        result = qutip.expect(operators, states)
-+        assert len(result) == len(operators)
-+        for part, operator, expected_part in zip(result, operators, expected):
-+            expected_dtype = np.float64 if operator.isherm else np.complex128
-+            assert isinstance(part, np.ndarray)
-+            assert part.dtype == expected_dtype
-+            assert list(part) == list(expected_part)
-+
-+
-+@pytest.mark.repeat(5)
-+@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
-+@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
-+@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
-+def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
-+    dimension = 20
-+    state = qutip.rand_ket(dimension, 0.3).to(op_type)
-+    op = qutip.rand_herm(dimension, 0.2).to(state_type)
-+    if not hermitian:
-+        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
-+    expected = state.dag() * op * state
-+    assert abs(qutip.expect(op, state) - expected) < 1e-14
-+
-+
-+@pytest.mark.parametrize("solve", [
-+    pytest.param(qutip.sesolve, id="sesolve"),
-+    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
-+                 id="mesolve"),
-+])
-+def test_compatibility_with_solver(solve):
-+    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
-+    e_ops += [lambda t, psi: np.sin(t)]
-+    h = qutip.sigmax()
-+    state = qutip.basis(2, 0)
-+    times = np.linspace(0, 10, 101)
-+    options = {"store_states":True}
-+    result = solve(h, state, times, e_ops=e_ops, options=options)
-+    direct, states = result.expect, result.states
-+    indirect = qutip.expect(e_ops[:-1], states)
-+    # check measurement operators based on quantum objects
-+    assert len(direct)-1 == len(indirect)
-+    for direct_, indirect_ in zip(direct, indirect):
-+        assert len(direct_) == len(indirect_)
-+        assert isinstance(direct_, np.ndarray)
-+        assert isinstance(indirect_, np.ndarray)
-+        assert direct_.dtype == indirect_.dtype
-+        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
-+        # test measurement operators based on lambda functions
-+        direct_ = direct[-1]
-+        indirect_ = np.sin(times)
-+        assert len(direct_) == len(indirect_)
-+        assert isinstance(direct_, np.ndarray)
-+        assert isinstance(indirect_, np.ndarray)
-+        assert direct_.dtype == indirect_.dtype
-+        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
-+
-+
-+def test_no_real_attribute(monkeypatch):
-+    """This tests ensures that expect still works even if the output of a
-+    specialisation does not have the ``real`` attribute. This is the case for
-+    the tensorflow and cupy data layers."""
-+
-+    def mocker_expect_return(oper, state):
-+        """
-+        We simply return None which does not have the `real` attribute.
-+        """
-+        return "object without .real"
-+
-+    monkeypatch.setattr(_data, "expect", mocker_expect_return)
-+
-+    sz = qutip.sigmaz() # the choice of the matrix does not matter
-+    assert "object without .real" == qutip.expect(sz, sz)
-diff --git a/qutip/tests/core/test_gates.py b/qutip/tests/core/test_gates.py
-index 7b3795b5..92f81c7f 100644
---- a/qutip/tests/core/test_gates.py
-+++ b/qutip/tests/core/test_gates.py
-@@ -1,144 +1,144 @@
--import pytest
--import numpy as np
--import qutip
--from qutip.core import gates
--
--
--def _infidelity(a, b):
--    """Infidelity between two kets."""
--    return 1 - abs(a.overlap(b))
--
--
--def _remove_global_phase(qobj):
--    """
--    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
--    we set the first non-zero element to be purely real-positive.
--    """
--    flat = qobj.tidyup(1e-14).full().flat.copy()
--    for phase in flat:
--        if phase != 0:
--            # Fix the gauge for any global phase.
--            flat = flat * np.exp(-1j * np.angle(phase))
--            break
--    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
--
--
--def _make_random_three_qubit_gate():
--    """Create a random three-qubit gate."""
--    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
--
--    def gate(N=None, controls=None, target=None):
--        if N is None:
--            return operation
--        return gates.gate_expand_3toN(operation, N, controls, target)
--    return gate
--
--
--def _make_controled(op):
--    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
--    out += qutip.tensor(qutip.fock_dm(2, 1), op)
--    return out
--
--
--class TestExplicitForm:
--    def test_swap(self):
--        states = [qutip.rand_ket(2) for _ in [None]*2]
--        start = qutip.tensor(states)
--        swapped = qutip.tensor(states[::-1])
--        swap = gates.swap()
--        assert _infidelity(swapped, swap*start) < 1e-12
--        assert _infidelity(start, swap*swap*start) < 1e-12
--
--    @pytest.mark.parametrize(["gate", "cgate", "args"], [
--        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
--        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
--        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
--        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
--        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
--        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
--        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
--        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
--        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
--    ])
--    def test_controled(self, gate, cgate, args):
--        expected = _make_controled(gate(*args))
--        assert cgate(*args) == expected
--
--    @pytest.mark.parametrize(["gate", "power", "expected"], [
--        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
--        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
--        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
--        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
--                     id="berkeley"),
--        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
--        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
--        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
--    ])
--    def gate_power_relation(self, gate, expected, power):
--        assert gate()**power == expected()
--
--    @pytest.mark.parametrize(['angle', 'expected'], [
--        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
--                     id="pi"),
--        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
--    ])
--    def test_molmer_sorensen(self, angle, expected):
--        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
--                                   expected.full(), atol=1e-15)
--
--    @pytest.mark.parametrize(["gate", "n_angles"], [
--        pytest.param(gates.rx, 1, id="Rx"),
--        pytest.param(gates.ry, 1, id="Ry"),
--        pytest.param(gates.rz, 1, id="Rz"),
--        pytest.param(gates.phasegate, 1, id="phase"),
--        pytest.param(gates.qrot, 2, id="Rabi rotation"),
--    ])
--    def test_zero_rotations_are_identity(self, gate, n_angles):
--        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
--                                   atol=1e-15)
--
--    def test_hadamard(self):
--        N = 3
--        expected = qutip.tensor([gates.snot()] * N)
--        assert gates.hadamard_transform(N) == expected
--
--    def test_globalphase(self):
--        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
--
--
--class TestCliffordGroup:
--    """
--    Test a sufficient set of conditions to prove that we have a full Clifford
--    group for a single qubit.
--    """
--    clifford = gates.qubit_clifford_group()
--    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
--
--    def test_single_qubit_group_dimension_is_24(self):
--        assert len(self.clifford) == 24
--
--    def test_all_elements_different(self):
--        clifford = [_remove_global_phase(gate) for gate in self.clifford]
--        for i, gate in enumerate(clifford):
--            for other in clifford[i+1:]:
--                # Big tolerance because we actually want to test the inverse.
--                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
--
--    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
--    def test_gate_normalises_pauli_group(self, gate):
--        """
--        Test the fundamental definition of the Clifford group, i.e. that it
--        normalises the Pauli group.
--        """
--        # Assert that each Clifford gate maps the set of Pauli gates back onto
--        # itself (though not necessarily in order).  This condition is no
--        # stronger than simply considering each (gate, Pauli) pair separately.
--        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
--        normalised = [_remove_global_phase(gate * pauli * gate.dag())
--                      for pauli in self.pauli]
--        for gate in normalised:
--            for i, pauli in enumerate(pauli_gates):
--                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
--                    del pauli_gates[i]
--                    break
--        assert len(pauli_gates) == 0
-+import pytest
-+import numpy as np
-+import qutip
-+from qutip.core import gates
-+
-+
-+def _infidelity(a, b):
-+    """Infidelity between two kets."""
-+    return 1 - abs(a.overlap(b))
-+
-+
-+def _remove_global_phase(qobj):
-+    """
-+    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
-+    we set the first non-zero element to be purely real-positive.
-+    """
-+    flat = qobj.tidyup(1e-14).full().flat.copy()
-+    for phase in flat:
-+        if phase != 0:
-+            # Fix the gauge for any global phase.
-+            flat = flat * np.exp(-1j * np.angle(phase))
-+            break
-+    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
-+
-+
-+def _make_random_three_qubit_gate():
-+    """Create a random three-qubit gate."""
-+    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
-+
-+    def gate(N=None, controls=None, target=None):
-+        if N is None:
-+            return operation
-+        return gates.gate_expand_3toN(operation, N, controls, target)
-+    return gate
-+
-+
-+def _make_controled(op):
-+    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
-+    out += qutip.tensor(qutip.fock_dm(2, 1), op)
-+    return out
-+
-+
-+class TestExplicitForm:
-+    def test_swap(self):
-+        states = [qutip.rand_ket(2) for _ in [None]*2]
-+        start = qutip.tensor(states)
-+        swapped = qutip.tensor(states[::-1])
-+        swap = gates.swap()
-+        assert _infidelity(swapped, swap*start) < 1e-12
-+        assert _infidelity(start, swap*swap*start) < 1e-12
-+
-+    @pytest.mark.parametrize(["gate", "cgate", "args"], [
-+        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
-+        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
-+        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
-+        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
-+        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
-+        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
-+        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
-+        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
-+        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
-+    ])
-+    def test_controled(self, gate, cgate, args):
-+        expected = _make_controled(gate(*args))
-+        assert cgate(*args) == expected
-+
-+    @pytest.mark.parametrize(["gate", "power", "expected"], [
-+        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
-+        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
-+        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
-+        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
-+                     id="berkeley"),
-+        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
-+        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
-+        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
-+    ])
-+    def gate_power_relation(self, gate, expected, power):
-+        assert gate()**power == expected()
-+
-+    @pytest.mark.parametrize(['angle', 'expected'], [
-+        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
-+                     id="pi"),
-+        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
-+    ])
-+    def test_molmer_sorensen(self, angle, expected):
-+        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
-+                                   expected.full(), atol=1e-15)
-+
-+    @pytest.mark.parametrize(["gate", "n_angles"], [
-+        pytest.param(gates.rx, 1, id="Rx"),
-+        pytest.param(gates.ry, 1, id="Ry"),
-+        pytest.param(gates.rz, 1, id="Rz"),
-+        pytest.param(gates.phasegate, 1, id="phase"),
-+        pytest.param(gates.qrot, 2, id="Rabi rotation"),
-+    ])
-+    def test_zero_rotations_are_identity(self, gate, n_angles):
-+        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
-+                                   atol=1e-15)
-+
-+    def test_hadamard(self):
-+        N = 3
-+        expected = qutip.tensor([gates.snot()] * N)
-+        assert gates.hadamard_transform(N) == expected
-+
-+    def test_globalphase(self):
-+        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
-+
-+
-+class TestCliffordGroup:
-+    """
-+    Test a sufficient set of conditions to prove that we have a full Clifford
-+    group for a single qubit.
-+    """
-+    clifford = gates.qubit_clifford_group()
-+    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-+
-+    def test_single_qubit_group_dimension_is_24(self):
-+        assert len(self.clifford) == 24
-+
-+    def test_all_elements_different(self):
-+        clifford = [_remove_global_phase(gate) for gate in self.clifford]
-+        for i, gate in enumerate(clifford):
-+            for other in clifford[i+1:]:
-+                # Big tolerance because we actually want to test the inverse.
-+                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
-+
-+    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
-+    def test_gate_normalises_pauli_group(self, gate):
-+        """
-+        Test the fundamental definition of the Clifford group, i.e. that it
-+        normalises the Pauli group.
-+        """
-+        # Assert that each Clifford gate maps the set of Pauli gates back onto
-+        # itself (though not necessarily in order).  This condition is no
-+        # stronger than simply considering each (gate, Pauli) pair separately.
-+        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
-+        normalised = [_remove_global_phase(gate * pauli * gate.dag())
-+                      for pauli in self.pauli]
-+        for gate in normalised:
-+            for i, pauli in enumerate(pauli_gates):
-+                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
-+                    del pauli_gates[i]
-+                    break
-+        assert len(pauli_gates) == 0
-diff --git a/qutip/tests/core/test_metrics.py b/qutip/tests/core/test_metrics.py
-index e52a074b..945c1cfb 100644
---- a/qutip/tests/core/test_metrics.py
-+++ b/qutip/tests/core/test_metrics.py
-@@ -1,551 +1,551 @@
--# -*- coding: utf-8 -*-
--
--import platform
--
--import numpy as np
--import pytest
--
--from qutip import (
--    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
--    qeye, rand_ket, rand_super_bcsz, rand_dm,
--    rand_unitary, to_super, to_choi, kraus_to_choi,
--    to_chi, to_kraus,
--)
--from qutip.core.gates import snot, swap
--
--try:
--    import cvxpy
--    import cvxopt
--except ImportError:
--    cvxpy, cvxopt = None, None
--
--# These ones are the metrics functions that we actually want to test.
--from qutip import (
--    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
--    unitarity, hilbert_dist, bures_dist, process_fidelity,
--)
--from qutip.core.metrics import _hilbert_space_dims
--
--
--@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
--def dimension(request):
--    # There are also some cases in the file where this fixture is explicitly
--    # overridden by a more local mark.  That is deliberate; this dimension is
--    # intended for non-superoperators, and may cause inordinantly long tests if
--    # (for example) something uses dimension=100 then makes a superoperator out
--    # of it.
--    return request.param
--
--
--@pytest.fixture(scope="function", params=[
--    pytest.param(rand_ket, id="pure"),
--    pytest.param(rand_dm, id="mixed"),
--])
--def state(request, dimension):
--    return request.param(dimension)
--
--
--# Also parametrise left, right as if they're the names of two states for tests
--# that need to take two states.
--left = right = state
--
--
--# The class names have an unusual naming convention to make them more
--# convenient to use with the `pytest -k "expr"` selection syntax.  They start
--# with the standard `Test`, but then are the name of the function they are
--# testing in the function naming convention, so it's easy to remember the
--# selector to choose a particular function.
--
--class Test_fidelity:
--    def test_mixed_state_inequality(self, dimension):
--        tol = 1e-7
--        rho1 = rand_dm(dimension, density=0.25)
--        rho2 = rand_dm(dimension, density=0.25)
--        F = fidelity(rho1, rho2)
--        assert 1 - F <= np.sqrt(1 - F*F) + tol
--
--    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
--    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
--    def test_orthogonal(self, left_dm, right_dm, dimension):
--        left = basis(dimension, 0)
--        right = basis(dimension, dimension//2)
--        if left_dm:
--            left = left.proj()
--        if right_dm:
--            right = right.proj()
--        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
--
--    def test_invariant_under_unitary_transformation(self, dimension):
--        rho1 = rand_dm(dimension, density=0.25)
--        rho2 = rand_dm(dimension, density=0.25)
--        U = rand_unitary(dimension)
--        F = fidelity(rho1, rho2)
--        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
--        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
--
--    def test_state_with_itself(self, state):
--        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
--
--    def test_bounded(self, left, right, dimension):
--        """Test that fidelity is bounded on [0, 1]."""
--        tol = 1e-7
--        assert -tol <= fidelity(left, right) <= 1 + tol
--
--    def test_pure_state_equivalent_to_overlap(self, dimension):
--        """Check fidelity against pure-state overlap, see gh-361."""
--        psi = rand_ket(dimension)
--        phi = rand_ket(dimension)
--        overlap = np.abs(psi.overlap(phi))
--        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
--
--    ket_0 = basis(2, 0)
--    ket_1 = basis(2, 1)
--    ket_p = (ket_0 + ket_1).unit()
--    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
--    max_mixed = qeye(2).unit()
--
--    @pytest.mark.parametrize(['left', 'right', 'expected'], [
--        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
--        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
--        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
--        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
--                     id="|+>,|+'>"),
--    ])
--    def test_known_cases(self, left, right, expected):
--        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
--
--
--class Test_tracedist:
--    def test_state_with_itself(self, state):
--        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
--
--    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
--    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
--    def test_orthogonal(self, left_dm, right_dm, dimension):
--        left = basis(dimension, 0)
--        right = basis(dimension, dimension//2)
--        if left_dm:
--            left = left.proj()
--        if right_dm:
--            right = right.proj()
--        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
--
--    def test_invariant_under_unitary_transformation(self, dimension):
--        rho1 = rand_dm(dimension, density=0.25)
--        rho2 = rand_dm(dimension, density=0.25)
--        U = rand_unitary(dimension)
--        D = tracedist(rho1, rho2)
--        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
--        assert D == pytest.approx(DU, rel=1e-5)
--
--
--class Test_hellinger_dist:
--    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
--    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
--    def test_orthogonal(self, left_dm, right_dm, dimension):
--        left = basis(dimension, 0)
--        right = basis(dimension, dimension//2)
--        if left_dm:
--            left = left.proj()
--        if right_dm:
--            right = right.proj()
--        expected = np.sqrt(2)
--        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
--
--    def test_state_with_itself(self, state):
--        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
--
--    def test_known_cases_pure_states(self, dimension):
--        left = rand_ket(dimension)
--        right = rand_ket(dimension)
--        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
--        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
--
--    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
--    def test_monotonicity(self, dimension):
--        """
--        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
--        arXiv:1611.03449v2:
--            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
--            >= hellinger_dist(rhoA, sigmaA)
--        with equality iff sigmaB = rhoB where '&' is the tensor product.
--        """
--        tol = 1e-5
--        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
--        rho = tensor(rhoA, rhoB)
--        rho_sim = tensor(rhoA, sigmaB)
--        sigma = tensor(sigmaA, sigmaB)
--        dist = hellinger_dist(rhoA, sigmaA)
--        assert hellinger_dist(rho, sigma) + tol > dist
--        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
--
--
--class Test_average_gate_fidelity:
--    def test_identity(self, dimension):
--        id = qeye(dimension)
--        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
--
--    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
--    def test_bounded(self, dimension):
--        tol = 1e-7
--        channel = rand_super_bcsz(dimension)
--        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
--
--    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
--    def test_unitaries_equal_1(self, dimension):
--        """Tests that for random unitaries U, AGF(U, U) = 1."""
--        tol = 1e-7
--        U = rand_unitary(dimension)
--        SU = to_super(U)
--        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
--
--    def test_average_gate_fidelity_against_legacy_implementation(self):
--        """
--        Metrics: Test that AGF coincides with pre-5.0 implementation
--        """
--        def agf_pre_50(oper, target=None):
--            kraus = to_kraus(oper)
--            d = kraus[0].shape[0]
--
--            if kraus[0].shape[1] != d:
--                return TypeError(
--                    "Average gate fidelity only implemented for square "
--                    "superoperators.")
--
--            if target is None:
--                return (
--                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
--                    (d * d + d)
--                )
--            return (
--                (d + np.sum([
--                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
--                ])) / (d * d + d)
--            )
--
--        oper = rand_super_bcsz(16)
--        target = rand_unitary(16)
--        np.testing.assert_almost_equal(
--            average_gate_fidelity(oper, target),
--            agf_pre_50(oper, target)
--        )
--
--
--class Test_hilbert_dist:
--    def test_known_cases(self):
--        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
--        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
--        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
--
--
--paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
--
--
--class Test_unitarity:
--    @pytest.mark.parametrize(['operator', 'expected'], [
--        pytest.param(to_super(sigmax()), 1, id="sigmax"),
--        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
--        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
--                     id="id+sigmax"),
--    ])
--    def test_known_cases(self, operator, expected):
--        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
--
--    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
--    def test_bounded(self, n_qubits):
--        tol = 1e-7
--        operator = rand_super_bcsz(2**n_qubits)
--        assert -tol <= unitarity(operator) <= 1 + tol
--
--
--class TestComparisons:
--    """Test some known inequalities between two different metrics."""
--
--    def test_inequality_tracedist_to_fidelity(self, left, right):
--        tol = 1e-7
--        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
--
--    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
--        tol = 1e-7
--        hellinger = hellinger_dist(left, right)
--        bures = bures_dist(left, right)
--        assert bures <= hellinger + tol
--
--
--def overrotation(x):
--    return to_super((1j * np.pi * x * sigmax() / 2).expm())
--
--
--def had_mixture(x):
--    id_chan = to_choi(qeye(2))
--    S_eye = to_super(id_chan)
--    S_H = to_super(snot())
--    return (1 - x) * S_eye + x * S_H
--
--
--def swap_map(x):
--    base = (1j * x * swap()).expm()
--    dims = [[[2], [2]], [[2], [2]]]
--    return Qobj(base, dims=dims, type='super', superrep='super')
--
--
--def adc_choi(x):
--    kraus = [
--        np.sqrt(1 - x) * qeye(2),
--        np.sqrt(x) * destroy(2),
--        np.sqrt(x) * fock_dm(2, 0),
--    ]
--    return kraus_to_choi(kraus)
--
--
--# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
--# to solve the problem, and this can cause an entire test-suite failure.  As
--# long as we are using random tests (perhaps not ideal), this will happen
--# occasionally.  This isn't entirely a bug, it's just a reality of using a
--# one-size-fits-all solver; we've historically assumed users who come up
--# against this sort of thing will be accepting of the fact that dnorm
--# calculation is nontrivial, and isn't always entirely feasible.
--#
--# To deal with it, we allow each test to be rerun twice, using
--# pytest-rerunfailures.  This should forbid pathological cases where the test
--# is failing every time, but not penalise one-off failures.  As far as we know,
--# the failing tests always involve a random step, so triggering a re-run will
--# have them choose new variables as well.
--#
--# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
--# which is deprecated as of numpy 1.20.
--#
--# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
--# depends on them.
--@pytest.mark.skipif(cvxpy is None or cvxopt is None,
--                    reason="Skipping dnorm tests because dnorm requires cvxpy"
--                    " and cvxopt which are not installed.")
--@pytest.mark.skipif("Windows" in platform.system(),
--                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
--                    " installed on Windows but fail to correctly solve"
--                    " the given optimization problems.")
--@pytest.mark.flaky(reruns=2)
--@pytest.mark.filterwarnings(
--    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
--)
--class Test_dnorm:
--    @pytest.fixture(params=[2, 3])
--    def dimension(self, request):
--        return request.param
--
--    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
--    def sparse(self, request):
--        return request.param
--
--    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
--    def test_sparse_against_dense_adc(self, variable):
--        """
--        Test sparse versus dense dnorm calculation for a sample of
--        amplitude-damping channels.
--        """
--        # Choi matrix for identity channel on 1 qubit
--        A = kraus_to_choi([qeye(2)])
--        B = adc_choi(variable)
--        dense = dnorm(A, B, force_solve=True, sparse=False)
--        sparse = dnorm(A, B, force_solve=True, sparse=True)
--        assert dense == pytest.approx(sparse, abs=1e-7)
--
--    @pytest.mark.repeat(3)
--    def test_sparse_against_dense_random(self, dimension):
--        """
--        Test sparse versus dense dnorm calculation for random superoperators.
--        """
--        A = rand_super_bcsz(dimension)
--        dense_run_result = dnorm(A, force_solve=True, sparse=False)
--        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
--        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
--
--    def test_bounded(self, dimension, sparse):
--        """dnorm(A - B) in [0, 2] for random superops A, B."""
--        tol = 1e-7
--        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
--        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
--
--    def test_qubit_simple_known_cases(self, sparse):
--        """Check agreement for known qubit channels."""
--        id_chan = to_choi(qeye(2))
--        X_chan = to_choi(sigmax())
--        depol = to_choi(Qobj(
--            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
--        ))
--        # We need to restrict the number of iterations for things on the
--        # boundary, such as perfectly distinguishable channels.
--        assert (
--            dnorm(id_chan, X_chan, sparse=sparse)
--            == pytest.approx(2, abs=1e-7)
--        )
--        assert (
--            dnorm(id_chan, depol, sparse=sparse)
--            == pytest.approx(1.5, abs=1e-7)
--        )
--        # Finally, we add a known case from Johnston's QETLAB documentation,
--        #   || Phi - I ||_♢,
--        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
--        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
--        assert (
--            dnorm(U, qeye(2), sparse=sparse)
--            == pytest.approx(np.sqrt(2), abs=1e-7)
--        )
--
--    @pytest.mark.parametrize(["variable", "expected", "generator"], [
--        [1.0e-3, 3.141591e-03, overrotation],
--        [3.1e-3, 9.738899e-03, overrotation],
--        [1.0e-2, 3.141463e-02, overrotation],
--        [3.1e-2, 9.735089e-02, overrotation],
--        [1.0e-1, 3.128689e-01, overrotation],
--        [3.1e-1, 9.358596e-01, overrotation],
--        [1.0e-3, 2.000000e-03, had_mixture],
--        [3.1e-3, 6.200000e-03, had_mixture],
--        [1.0e-2, 2.000000e-02, had_mixture],
--        [3.1e-2, 6.200000e-02, had_mixture],
--        [1.0e-1, 2.000000e-01, had_mixture],
--        [3.1e-1, 6.200000e-01, had_mixture],
--        [1.0e-3, 2.000000e-03, swap_map],
--        [3.1e-3, 6.199997e-03, swap_map],
--        [1.0e-2, 1.999992e-02, swap_map],
--        [3.1e-2, 6.199752e-02, swap_map],
--        [1.0e-1, 1.999162e-01, swap_map],
--        [3.1e-1, 6.173918e-01, swap_map],
--    ])
--    def test_qubit_known_cases(self, variable, expected, generator, sparse):
--        """
--        Test cases based on comparisons to pre-existing dnorm implementations.
--        In particular, the targets for the following test cases were generated
--        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
--        """
--        id_chan = to_choi(qeye(2))
--        channel = generator(variable)
--        assert (
--            dnorm(channel, id_chan, sparse=sparse)
--            == pytest.approx(expected, abs=1e-7)
--        )
--
--    def test_qubit_scalar(self, dimension):
--        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
--        a = np.random.random()
--        A = rand_super_bcsz(dimension)
--        B = rand_super_bcsz(dimension)
--        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
--
--    def test_qubit_triangle(self, dimension):
--        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
--        A = rand_super_bcsz(dimension)
--        B = rand_super_bcsz(dimension)
--        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
--
--    @pytest.mark.repeat(3)
--    @pytest.mark.parametrize("generator", [
--        pytest.param(rand_super_bcsz, id="super"),
--        pytest.param(rand_unitary, id="unitary"),
--    ])
--    def test_force_solve(self, dimension, generator):
--        """
--        Metrics: checks that special cases for dnorm agree with SDP solutions.
--        """
--        A, B = generator(dimension), generator(dimension)
--        assert (
--            dnorm(A, B, force_solve=False)
--            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
--        )
--
--    @pytest.mark.repeat(3)
--    def test_cptp(self, dimension, sparse):
--        """Check that the diamond norm is one for CPTP maps."""
--        A = rand_super_bcsz(dimension)
--        assert A.iscptp
--        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
--
--
--@pytest.mark.parametrize('superrep_conversion',
--                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
--def test_process_fidelity_of_identity(superrep_conversion):
--    """
--    Metrics: process fidelity of identity map is 1
--    """
--    num_qubits = 3
--    oper = qeye(num_qubits*[2])
--    f = process_fidelity(superrep_conversion(oper))
--    assert np.isrealobj(f)
--    assert f == pytest.approx(1)
--
--
--@pytest.mark.parametrize('superrep_conversion',
--                         [to_super, to_choi, to_chi, to_kraus])
--def test_process_fidelity_identical_channels(superrep_conversion):
--    """
--    Metrics: process fidelity of a map to itself is 1
--    """
--    num_qubits = 2
--    for k in range(10):
--        oper = rand_super_bcsz(num_qubits*[2])
--        oper = superrep_conversion(oper)
--        f = process_fidelity(oper, oper)
--        assert f == pytest.approx(1)
--
--
--def test_process_fidelity_identical_unitaries():
--    """
--    Metrics: process fidelity of a unitary to itself is 1
--    """
--    num_qubits = 3
--    for k in range(10):
--        oper = rand_unitary(num_qubits * [2])
--        f = process_fidelity(oper, oper)
--        assert f == pytest.approx(1)
--
--
--def test_process_fidelity_consistency():
--    """
--    Metrics: process fidelity independent of how channels are represented
--    """
--    num_qubits = 2
--    for k in range(10):
--        fidelities_u_to_u = []
--        fidelities_u_to_id = []
--        u1 = rand_unitary(num_qubits * [2])
--        u2 = rand_unitary(num_qubits * [2])
--        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
--            fidelities_u_to_id.append(process_fidelity(map1(u1)))
--            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
--                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
--        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
--        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
--
--
--def test_process_fidelity_unitary_invariance():
--    """
--    Metrics: process fidelity, invariance under unitary trans.
--    """
--    for k in range(10):
--        op1 = rand_super_bcsz(10)
--        op2 = rand_super_bcsz(10)
--        u = to_super(rand_unitary(10))
--        assert abs(
--            process_fidelity(op1, op2)
--            - process_fidelity(u*op1, u*op2)
--        ) < 1e-8
--
--
--@pytest.mark.parametrize('superrep_conversion',
--                         [lambda x: x, to_super, to_choi, to_kraus])
--def test_hilbert_space_dims(superrep_conversion):
--    """
--    Metrics: check _hilbert_space_dims
--    """
--    dims = [[2, 3], [4, 5]]
--    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
--    assert _hilbert_space_dims(superrep_conversion(u)) == dims
--
--
--def test_hilbert_space_dims_chi():
--    """
--    Metrics: check _hilbert_space_dims for a chi channel
--    """
--    dims = [[2, 2], [2, 2]]
--    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
--    assert _hilbert_space_dims(to_chi(u)) == dims
-+# -*- coding: utf-8 -*-
-+
-+import platform
-+
-+import numpy as np
-+import pytest
-+
-+from qutip import (
-+    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
-+    qeye, rand_ket, rand_super_bcsz, rand_dm,
-+    rand_unitary, to_super, to_choi, kraus_to_choi,
-+    to_chi, to_kraus,
-+)
-+from qutip.core.gates import snot, swap
-+
-+try:
-+    import cvxpy
-+    import cvxopt
-+except ImportError:
-+    cvxpy, cvxopt = None, None
-+
-+# These ones are the metrics functions that we actually want to test.
-+from qutip import (
-+    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
-+    unitarity, hilbert_dist, bures_dist, process_fidelity,
-+)
-+from qutip.core.metrics import _hilbert_space_dims
-+
-+
-+@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
-+def dimension(request):
-+    # There are also some cases in the file where this fixture is explicitly
-+    # overridden by a more local mark.  That is deliberate; this dimension is
-+    # intended for non-superoperators, and may cause inordinantly long tests if
-+    # (for example) something uses dimension=100 then makes a superoperator out
-+    # of it.
-+    return request.param
-+
-+
-+@pytest.fixture(scope="function", params=[
-+    pytest.param(rand_ket, id="pure"),
-+    pytest.param(rand_dm, id="mixed"),
-+])
-+def state(request, dimension):
-+    return request.param(dimension)
-+
-+
-+# Also parametrise left, right as if they're the names of two states for tests
-+# that need to take two states.
-+left = right = state
-+
-+
-+# The class names have an unusual naming convention to make them more
-+# convenient to use with the `pytest -k "expr"` selection syntax.  They start
-+# with the standard `Test`, but then are the name of the function they are
-+# testing in the function naming convention, so it's easy to remember the
-+# selector to choose a particular function.
-+
-+class Test_fidelity:
-+    def test_mixed_state_inequality(self, dimension):
-+        tol = 1e-7
-+        rho1 = rand_dm(dimension, density=0.25)
-+        rho2 = rand_dm(dimension, density=0.25)
-+        F = fidelity(rho1, rho2)
-+        assert 1 - F <= np.sqrt(1 - F*F) + tol
-+
-+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-+    def test_orthogonal(self, left_dm, right_dm, dimension):
-+        left = basis(dimension, 0)
-+        right = basis(dimension, dimension//2)
-+        if left_dm:
-+            left = left.proj()
-+        if right_dm:
-+            right = right.proj()
-+        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
-+
-+    def test_invariant_under_unitary_transformation(self, dimension):
-+        rho1 = rand_dm(dimension, density=0.25)
-+        rho2 = rand_dm(dimension, density=0.25)
-+        U = rand_unitary(dimension)
-+        F = fidelity(rho1, rho2)
-+        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
-+        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
-+
-+    def test_state_with_itself(self, state):
-+        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
-+
-+    def test_bounded(self, left, right, dimension):
-+        """Test that fidelity is bounded on [0, 1]."""
-+        tol = 1e-7
-+        assert -tol <= fidelity(left, right) <= 1 + tol
-+
-+    def test_pure_state_equivalent_to_overlap(self, dimension):
-+        """Check fidelity against pure-state overlap, see gh-361."""
-+        psi = rand_ket(dimension)
-+        phi = rand_ket(dimension)
-+        overlap = np.abs(psi.overlap(phi))
-+        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
-+
-+    ket_0 = basis(2, 0)
-+    ket_1 = basis(2, 1)
-+    ket_p = (ket_0 + ket_1).unit()
-+    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
-+    max_mixed = qeye(2).unit()
-+
-+    @pytest.mark.parametrize(['left', 'right', 'expected'], [
-+        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
-+        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
-+        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
-+        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
-+                     id="|+>,|+'>"),
-+    ])
-+    def test_known_cases(self, left, right, expected):
-+        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
-+
-+
-+class Test_tracedist:
-+    def test_state_with_itself(self, state):
-+        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
-+
-+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-+    def test_orthogonal(self, left_dm, right_dm, dimension):
-+        left = basis(dimension, 0)
-+        right = basis(dimension, dimension//2)
-+        if left_dm:
-+            left = left.proj()
-+        if right_dm:
-+            right = right.proj()
-+        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
-+
-+    def test_invariant_under_unitary_transformation(self, dimension):
-+        rho1 = rand_dm(dimension, density=0.25)
-+        rho2 = rand_dm(dimension, density=0.25)
-+        U = rand_unitary(dimension)
-+        D = tracedist(rho1, rho2)
-+        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
-+        assert D == pytest.approx(DU, rel=1e-5)
-+
-+
-+class Test_hellinger_dist:
-+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-+    def test_orthogonal(self, left_dm, right_dm, dimension):
-+        left = basis(dimension, 0)
-+        right = basis(dimension, dimension//2)
-+        if left_dm:
-+            left = left.proj()
-+        if right_dm:
-+            right = right.proj()
-+        expected = np.sqrt(2)
-+        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
-+
-+    def test_state_with_itself(self, state):
-+        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
-+
-+    def test_known_cases_pure_states(self, dimension):
-+        left = rand_ket(dimension)
-+        right = rand_ket(dimension)
-+        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
-+        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
-+
-+    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
-+    def test_monotonicity(self, dimension):
-+        """
-+        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
-+        arXiv:1611.03449v2:
-+            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
-+            >= hellinger_dist(rhoA, sigmaA)
-+        with equality iff sigmaB = rhoB where '&' is the tensor product.
-+        """
-+        tol = 1e-5
-+        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
-+        rho = tensor(rhoA, rhoB)
-+        rho_sim = tensor(rhoA, sigmaB)
-+        sigma = tensor(sigmaA, sigmaB)
-+        dist = hellinger_dist(rhoA, sigmaA)
-+        assert hellinger_dist(rho, sigma) + tol > dist
-+        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
-+
-+
-+class Test_average_gate_fidelity:
-+    def test_identity(self, dimension):
-+        id = qeye(dimension)
-+        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
-+
-+    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
-+    def test_bounded(self, dimension):
-+        tol = 1e-7
-+        channel = rand_super_bcsz(dimension)
-+        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
-+
-+    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
-+    def test_unitaries_equal_1(self, dimension):
-+        """Tests that for random unitaries U, AGF(U, U) = 1."""
-+        tol = 1e-7
-+        U = rand_unitary(dimension)
-+        SU = to_super(U)
-+        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
-+
-+    def test_average_gate_fidelity_against_legacy_implementation(self):
-+        """
-+        Metrics: Test that AGF coincides with pre-5.0 implementation
-+        """
-+        def agf_pre_50(oper, target=None):
-+            kraus = to_kraus(oper)
-+            d = kraus[0].shape[0]
-+
-+            if kraus[0].shape[1] != d:
-+                return TypeError(
-+                    "Average gate fidelity only implemented for square "
-+                    "superoperators.")
-+
-+            if target is None:
-+                return (
-+                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
-+                    (d * d + d)
-+                )
-+            return (
-+                (d + np.sum([
-+                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
-+                ])) / (d * d + d)
-+            )
-+
-+        oper = rand_super_bcsz(16)
-+        target = rand_unitary(16)
-+        np.testing.assert_almost_equal(
-+            average_gate_fidelity(oper, target),
-+            agf_pre_50(oper, target)
-+        )
-+
-+
-+class Test_hilbert_dist:
-+    def test_known_cases(self):
-+        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
-+        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
-+        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
-+
-+
-+paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
-+
-+
-+class Test_unitarity:
-+    @pytest.mark.parametrize(['operator', 'expected'], [
-+        pytest.param(to_super(sigmax()), 1, id="sigmax"),
-+        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
-+        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
-+                     id="id+sigmax"),
-+    ])
-+    def test_known_cases(self, operator, expected):
-+        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
-+
-+    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
-+    def test_bounded(self, n_qubits):
-+        tol = 1e-7
-+        operator = rand_super_bcsz(2**n_qubits)
-+        assert -tol <= unitarity(operator) <= 1 + tol
-+
-+
-+class TestComparisons:
-+    """Test some known inequalities between two different metrics."""
-+
-+    def test_inequality_tracedist_to_fidelity(self, left, right):
-+        tol = 1e-7
-+        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
-+
-+    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
-+        tol = 1e-7
-+        hellinger = hellinger_dist(left, right)
-+        bures = bures_dist(left, right)
-+        assert bures <= hellinger + tol
-+
-+
-+def overrotation(x):
-+    return to_super((1j * np.pi * x * sigmax() / 2).expm())
-+
-+
-+def had_mixture(x):
-+    id_chan = to_choi(qeye(2))
-+    S_eye = to_super(id_chan)
-+    S_H = to_super(snot())
-+    return (1 - x) * S_eye + x * S_H
-+
-+
-+def swap_map(x):
-+    base = (1j * x * swap()).expm()
-+    dims = [[[2], [2]], [[2], [2]]]
-+    return Qobj(base, dims=dims, type='super', superrep='super')
-+
-+
-+def adc_choi(x):
-+    kraus = [
-+        np.sqrt(1 - x) * qeye(2),
-+        np.sqrt(x) * destroy(2),
-+        np.sqrt(x) * fock_dm(2, 0),
-+    ]
-+    return kraus_to_choi(kraus)
-+
-+
-+# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
-+# to solve the problem, and this can cause an entire test-suite failure.  As
-+# long as we are using random tests (perhaps not ideal), this will happen
-+# occasionally.  This isn't entirely a bug, it's just a reality of using a
-+# one-size-fits-all solver; we've historically assumed users who come up
-+# against this sort of thing will be accepting of the fact that dnorm
-+# calculation is nontrivial, and isn't always entirely feasible.
-+#
-+# To deal with it, we allow each test to be rerun twice, using
-+# pytest-rerunfailures.  This should forbid pathological cases where the test
-+# is failing every time, but not penalise one-off failures.  As far as we know,
-+# the failing tests always involve a random step, so triggering a re-run will
-+# have them choose new variables as well.
-+#
-+# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
-+# which is deprecated as of numpy 1.20.
-+#
-+# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
-+# depends on them.
-+@pytest.mark.skipif(cvxpy is None or cvxopt is None,
-+                    reason="Skipping dnorm tests because dnorm requires cvxpy"
-+                    " and cvxopt which are not installed.")
-+@pytest.mark.skipif("Windows" in platform.system(),
-+                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
-+                    " installed on Windows but fail to correctly solve"
-+                    " the given optimization problems.")
-+@pytest.mark.flaky(reruns=2)
-+@pytest.mark.filterwarnings(
-+    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
-+)
-+class Test_dnorm:
-+    @pytest.fixture(params=[2, 3])
-+    def dimension(self, request):
-+        return request.param
-+
-+    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
-+    def sparse(self, request):
-+        return request.param
-+
-+    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
-+    def test_sparse_against_dense_adc(self, variable):
-+        """
-+        Test sparse versus dense dnorm calculation for a sample of
-+        amplitude-damping channels.
-+        """
-+        # Choi matrix for identity channel on 1 qubit
-+        A = kraus_to_choi([qeye(2)])
-+        B = adc_choi(variable)
-+        dense = dnorm(A, B, force_solve=True, sparse=False)
-+        sparse = dnorm(A, B, force_solve=True, sparse=True)
-+        assert dense == pytest.approx(sparse, abs=1e-7)
-+
-+    @pytest.mark.repeat(3)
-+    def test_sparse_against_dense_random(self, dimension):
-+        """
-+        Test sparse versus dense dnorm calculation for random superoperators.
-+        """
-+        A = rand_super_bcsz(dimension)
-+        dense_run_result = dnorm(A, force_solve=True, sparse=False)
-+        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
-+        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
-+
-+    def test_bounded(self, dimension, sparse):
-+        """dnorm(A - B) in [0, 2] for random superops A, B."""
-+        tol = 1e-7
-+        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
-+        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
-+
-+    def test_qubit_simple_known_cases(self, sparse):
-+        """Check agreement for known qubit channels."""
-+        id_chan = to_choi(qeye(2))
-+        X_chan = to_choi(sigmax())
-+        depol = to_choi(Qobj(
-+            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
-+        ))
-+        # We need to restrict the number of iterations for things on the
-+        # boundary, such as perfectly distinguishable channels.
-+        assert (
-+            dnorm(id_chan, X_chan, sparse=sparse)
-+            == pytest.approx(2, abs=1e-7)
-+        )
-+        assert (
-+            dnorm(id_chan, depol, sparse=sparse)
-+            == pytest.approx(1.5, abs=1e-7)
-+        )
-+        # Finally, we add a known case from Johnston's QETLAB documentation,
-+        #   || Phi - I ||_♢,
-+        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
-+        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
-+        assert (
-+            dnorm(U, qeye(2), sparse=sparse)
-+            == pytest.approx(np.sqrt(2), abs=1e-7)
-+        )
-+
-+    @pytest.mark.parametrize(["variable", "expected", "generator"], [
-+        [1.0e-3, 3.141591e-03, overrotation],
-+        [3.1e-3, 9.738899e-03, overrotation],
-+        [1.0e-2, 3.141463e-02, overrotation],
-+        [3.1e-2, 9.735089e-02, overrotation],
-+        [1.0e-1, 3.128689e-01, overrotation],
-+        [3.1e-1, 9.358596e-01, overrotation],
-+        [1.0e-3, 2.000000e-03, had_mixture],
-+        [3.1e-3, 6.200000e-03, had_mixture],
-+        [1.0e-2, 2.000000e-02, had_mixture],
-+        [3.1e-2, 6.200000e-02, had_mixture],
-+        [1.0e-1, 2.000000e-01, had_mixture],
-+        [3.1e-1, 6.200000e-01, had_mixture],
-+        [1.0e-3, 2.000000e-03, swap_map],
-+        [3.1e-3, 6.199997e-03, swap_map],
-+        [1.0e-2, 1.999992e-02, swap_map],
-+        [3.1e-2, 6.199752e-02, swap_map],
-+        [1.0e-1, 1.999162e-01, swap_map],
-+        [3.1e-1, 6.173918e-01, swap_map],
-+    ])
-+    def test_qubit_known_cases(self, variable, expected, generator, sparse):
-+        """
-+        Test cases based on comparisons to pre-existing dnorm implementations.
-+        In particular, the targets for the following test cases were generated
-+        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
-+        """
-+        id_chan = to_choi(qeye(2))
-+        channel = generator(variable)
-+        assert (
-+            dnorm(channel, id_chan, sparse=sparse)
-+            == pytest.approx(expected, abs=1e-7)
-+        )
-+
-+    def test_qubit_scalar(self, dimension):
-+        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
-+        a = np.random.random()
-+        A = rand_super_bcsz(dimension)
-+        B = rand_super_bcsz(dimension)
-+        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
-+
-+    def test_qubit_triangle(self, dimension):
-+        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
-+        A = rand_super_bcsz(dimension)
-+        B = rand_super_bcsz(dimension)
-+        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
-+
-+    @pytest.mark.repeat(3)
-+    @pytest.mark.parametrize("generator", [
-+        pytest.param(rand_super_bcsz, id="super"),
-+        pytest.param(rand_unitary, id="unitary"),
-+    ])
-+    def test_force_solve(self, dimension, generator):
-+        """
-+        Metrics: checks that special cases for dnorm agree with SDP solutions.
-+        """
-+        A, B = generator(dimension), generator(dimension)
-+        assert (
-+            dnorm(A, B, force_solve=False)
-+            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
-+        )
-+
-+    @pytest.mark.repeat(3)
-+    def test_cptp(self, dimension, sparse):
-+        """Check that the diamond norm is one for CPTP maps."""
-+        A = rand_super_bcsz(dimension)
-+        assert A.iscptp
-+        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
-+
-+
-+@pytest.mark.parametrize('superrep_conversion',
-+                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
-+def test_process_fidelity_of_identity(superrep_conversion):
-+    """
-+    Metrics: process fidelity of identity map is 1
-+    """
-+    num_qubits = 3
-+    oper = qeye(num_qubits*[2])
-+    f = process_fidelity(superrep_conversion(oper))
-+    assert np.isrealobj(f)
-+    assert f == pytest.approx(1)
-+
-+
-+@pytest.mark.parametrize('superrep_conversion',
-+                         [to_super, to_choi, to_chi, to_kraus])
-+def test_process_fidelity_identical_channels(superrep_conversion):
-+    """
-+    Metrics: process fidelity of a map to itself is 1
-+    """
-+    num_qubits = 2
-+    for k in range(10):
-+        oper = rand_super_bcsz(num_qubits*[2])
-+        oper = superrep_conversion(oper)
-+        f = process_fidelity(oper, oper)
-+        assert f == pytest.approx(1)
-+
-+
-+def test_process_fidelity_identical_unitaries():
-+    """
-+    Metrics: process fidelity of a unitary to itself is 1
-+    """
-+    num_qubits = 3
-+    for k in range(10):
-+        oper = rand_unitary(num_qubits * [2])
-+        f = process_fidelity(oper, oper)
-+        assert f == pytest.approx(1)
-+
-+
-+def test_process_fidelity_consistency():
-+    """
-+    Metrics: process fidelity independent of how channels are represented
-+    """
-+    num_qubits = 2
-+    for k in range(10):
-+        fidelities_u_to_u = []
-+        fidelities_u_to_id = []
-+        u1 = rand_unitary(num_qubits * [2])
-+        u2 = rand_unitary(num_qubits * [2])
-+        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
-+            fidelities_u_to_id.append(process_fidelity(map1(u1)))
-+            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
-+                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
-+        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
-+        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
-+
-+
-+def test_process_fidelity_unitary_invariance():
-+    """
-+    Metrics: process fidelity, invariance under unitary trans.
-+    """
-+    for k in range(10):
-+        op1 = rand_super_bcsz(10)
-+        op2 = rand_super_bcsz(10)
-+        u = to_super(rand_unitary(10))
-+        assert abs(
-+            process_fidelity(op1, op2)
-+            - process_fidelity(u*op1, u*op2)
-+        ) < 1e-8
-+
-+
-+@pytest.mark.parametrize('superrep_conversion',
-+                         [lambda x: x, to_super, to_choi, to_kraus])
-+def test_hilbert_space_dims(superrep_conversion):
-+    """
-+    Metrics: check _hilbert_space_dims
-+    """
-+    dims = [[2, 3], [4, 5]]
-+    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
-+    assert _hilbert_space_dims(superrep_conversion(u)) == dims
-+
-+
-+def test_hilbert_space_dims_chi():
-+    """
-+    Metrics: check _hilbert_space_dims for a chi channel
-+    """
-+    dims = [[2, 2], [2, 2]]
-+    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
-+    assert _hilbert_space_dims(to_chi(u)) == dims
-diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
-index c8e6d72f..f59dce8f 100644
---- a/qutip/tests/core/test_operators.py
-+++ b/qutip/tests/core/test_operators.py
-@@ -1,295 +1,295 @@
--import numbers
--import numpy as np
--import pytest
--import qutip
--
--
--N = 5
--
--
--def test_jmat_12():
--    spinhalf = qutip.jmat(1 / 2.)
--
--    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
--    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
--    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
--    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
--    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
--
--    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
--    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
--    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
--    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
--    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
--
--    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
--    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
--    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
--    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
--    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
--
--    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
--    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
--    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
--    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
--    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
--
--    spin_set = qutip.spin_J_set(0.5)
--    for i in range(3):
--        assert spinhalf[i] == spin_set[i]
--
--
--
--def test_jmat_32():
--    spin32 = qutip.jmat(3 / 2.)
--
--    paulix32 = np.array(
--        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
--         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
--         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
--         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
--
--    pauliy32 = np.array(
--        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
--         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
--         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
--         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
--
--    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
--                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
--                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
--                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
--
--    np.testing.assert_allclose(spin32[0].full(), paulix32)
--    np.testing.assert_allclose(spin32[1].full(), pauliy32)
--    np.testing.assert_allclose(spin32[2].full(), pauliz32)
--
--
--@pytest.mark.parametrize(['spin', 'N'], [
--    pytest.param(3/2., 4, id="1.5"),
--    pytest.param(5/2., 6, id="2.5"),
--    pytest.param(3.0, 7, id="3.0"),
--])
--def test_jmat_dims(spin, N):
--    spin_mat = qutip.jmat(spin, '+')
--    assert spin_mat.dims == [[N], [N]]
--    assert spin_mat.shape == (N, N)
--
--
--def test_jmat_raise():
--    with pytest.raises(ValueError) as e:
--        qutip.jmat(0.25)
--    assert str(e.value) == 'j must be a non-negative integer or half-integer'
--
--    with pytest.raises(ValueError) as e:
--        qutip.jmat(0.5, 'zx+')
--    assert "Invalid spin operator" in str(e.value)
--
--
--@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
--    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
--    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
--    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
--    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
--                 id="destroy_offset"),
--    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
--    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
--                 id="create_offset"),
--    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
--    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
--    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
--    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
--                 id="charge_args"),
--])
--def test_diagonal_operators(oper_func, diag, offset, args):
--    oper = oper_func(N, *args)
--    assert oper == qutip.Qobj(np.diag(diag, offset))
--
--
--@pytest.mark.parametrize(['function', 'message'], [
--    (qutip.qeye, "All dimensions must be integers >= 0"),
--    (qutip.destroy, "Hilbert space dimension must be integer value"),
--    (qutip.create, "Hilbert space dimension must be integer value"),
--], ids=["qeye", "destroy", "create"])
--def test_diagonal_raise(function, message):
--    with pytest.raises(ValueError) as e:
--        function(2.5)
--    assert str(e.value) == message
--
--
--@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
--@pytest.mark.parametrize("dimensions", [
--        2,
--        [2],
--        [2, 3, 4],
--        1,
--        [1],
--        [1, 1],
--    ])
--def test_implicit_tensor_creation(to_test, dimensions):
--    implicit = to_test(dimensions)
--    if isinstance(dimensions, numbers.Integral):
--        dimensions = [dimensions]
--    assert implicit.dims == [dimensions, dimensions]
--
--
--@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
--def test_super_operator_creation(to_test):
--    size = 2
--    implicit = to_test([[size], [size]])
--    explicit = qutip.to_super(to_test(size))
--    assert implicit == explicit
--
--
--def test_position():
--    operator = qutip.position(N)
--    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
--                np.diag((np.arange(1, N) / 2)**0.5, k=1))
--    np.testing.assert_allclose(operator.full(), expected)
--    assert operator._isherm == True
--
--
--def test_momentum():
--    operator = qutip.momentum(N)
--    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
--                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
--    np.testing.assert_allclose(operator.full(), expected)
--    assert operator._isherm == True
--
--
--def test_squeeze():
--    sq = qutip.squeeze(4, 0.1 + 0.1j)
--    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
--                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
--                         [0.00000000 + 0.j, 0.98503746 + 0.j,
--                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
--                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
--                          0.99500417 + 0.j, 0.00000000 + 0.j],
--                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
--                          0.00000000 + 0.j, 0.98503746 + 0.j]])
--    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
--
--
--def test_squeezing():
--    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
--    a = qutip.destroy(4)
--    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
--    assert squeeze == squeezing
--
--
--def test_displace():
--    dp = qutip.displace(4, 0.25)
--    dpmatrix = np.array(
--        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
--          0.00626025 + 0.j],
--         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
--          0.j, 0.07418172 + 0.j],
--         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
--          0.j, -0.41083747 + 0.j],
--         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
--          0.90866411 + 0.j]])
--    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
--
--
--@pytest.mark.parametrize("shift", [1, 2])
--def test_tunneling(shift):
--    N = 10
--    tn = qutip.tunneling(N, shift)
--    tn_matrix = np.diag(np.ones(N - shift), k=shift)
--    tn_matrix += tn_matrix.T
--    np.testing.assert_allclose(tn.full(), tn_matrix)
--
--
--def test_commutator():
--    A = qutip.qeye(N)
--    B = qutip.destroy(N)
--    assert qutip.commutator(A, B) == qutip.qzero(N)
--
--    sx = qutip.sigmax()
--    sy = qutip.sigmay()
--    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
--
--    A = qutip.qeye(N)
--    B = qutip.destroy(N)
--    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
--
--    sx = qutip.sigmax()
--    sy = qutip.sigmay()
--    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
--
--    with pytest.raises(TypeError) as e:
--        qutip.commutator(sx, sy, 'something')
--    assert str(e.value).startswith("Unknown commutator kind")
--
--def test_qutrit_ops():
--    ops = qutip.qutrit_ops()
--    assert qutip.qeye(3) == sum(ops[:3])
--    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
--    expected = np.zeros((3, 3))
--    expected[2, 0] = 1
--    np.testing.assert_allclose(expected, ops[5].full())
--
--
--def _id_func(val):
--    "ids generated from the function only"
--    if isinstance(val, tuple):
--        return ""
--
--
--# random object accept `str` and base.Data
--# Obtain all valid dtype from `to`
--dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
--dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
--@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
--                         ids=[str(dtype) for dtype in dtype_names])
--@pytest.mark.parametrize(['func', 'args'], [
--    (qutip.qdiags, ([0, 1, 2], 1)),
--    (qutip.jmat, (1,)),
--    (qutip.spin_Jx, (1,)),
--    (qutip.spin_Jy, (1,)),
--    (qutip.spin_Jz, (1,)),
--    (qutip.spin_Jp, (1,)),
--    (qutip.destroy, (5,)),
--    (qutip.create, (5,)),
--    (qutip.qzero, (5,)),
--    (qutip.qeye, (5,)),
--    (qutip.position, (5,)),
--    (qutip.momentum, (5,)),
--    (qutip.num, (5,)),
--    (qutip.squeeze, (5, 0.5)),
--    (qutip.displace, (5, 1.0)),
--    (qutip.qutrit_ops, ()),
--    (qutip.phase, (5,)),
--    (qutip.charge, (5,)),
--    (qutip.tunneling, (5,)),
--    (qutip.enr_destroy, ([3, 3, 3], 4)),
--    (qutip.enr_identity, ([3, 3, 3], 4)),
--], ids=_id_func)
--def test_operator_type(func, args, alias, dtype):
--    object = func(*args, dtype=alias)
--    if isinstance(object, qutip.Qobj):
--        assert isinstance(object.data, dtype)
--    else:
--        for obj in object:
--            assert isinstance(obj.data, dtype)
--
--    with qutip.CoreOptions(default_dtype=alias):
--        object = func(*args)
--        if isinstance(object, qutip.Qobj):
--            assert isinstance(object.data, dtype)
--        else:
--            for obj in object:
--                assert isinstance(obj.data, dtype)
--
--
--@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
--def test_qft(dims):
--    N = np.prod(dims)
--    qft = qutip.qft(N).full()
--    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
--    for i in range(N):
--        target = np.zeros(N)
--        target[i] = 1
--        fft = np.fft.fft(qft[:,i])
--        fft /= np.sum(fft)
--        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
-+import numbers
-+import numpy as np
-+import pytest
-+import qutip
-+
-+
-+N = 5
-+
-+
-+def test_jmat_12():
-+    spinhalf = qutip.jmat(1 / 2.)
-+
-+    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
-+    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
-+    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
-+    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
-+    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
-+
-+    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
-+    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
-+    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
-+    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
-+    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
-+
-+    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
-+    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
-+    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
-+    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
-+    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
-+
-+    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
-+    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
-+    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
-+    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
-+    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
-+
-+    spin_set = qutip.spin_J_set(0.5)
-+    for i in range(3):
-+        assert spinhalf[i] == spin_set[i]
-+
-+
-+
-+def test_jmat_32():
-+    spin32 = qutip.jmat(3 / 2.)
-+
-+    paulix32 = np.array(
-+        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
-+         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
-+         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
-+         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
-+
-+    pauliy32 = np.array(
-+        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
-+         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
-+         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
-+         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
-+
-+    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
-+                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
-+                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
-+                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
-+
-+    np.testing.assert_allclose(spin32[0].full(), paulix32)
-+    np.testing.assert_allclose(spin32[1].full(), pauliy32)
-+    np.testing.assert_allclose(spin32[2].full(), pauliz32)
-+
-+
-+@pytest.mark.parametrize(['spin', 'N'], [
-+    pytest.param(3/2., 4, id="1.5"),
-+    pytest.param(5/2., 6, id="2.5"),
-+    pytest.param(3.0, 7, id="3.0"),
-+])
-+def test_jmat_dims(spin, N):
-+    spin_mat = qutip.jmat(spin, '+')
-+    assert spin_mat.dims == [[N], [N]]
-+    assert spin_mat.shape == (N, N)
-+
-+
-+def test_jmat_raise():
-+    with pytest.raises(ValueError) as e:
-+        qutip.jmat(0.25)
-+    assert str(e.value) == 'j must be a non-negative integer or half-integer'
-+
-+    with pytest.raises(ValueError) as e:
-+        qutip.jmat(0.5, 'zx+')
-+    assert "Invalid spin operator" in str(e.value)
-+
-+
-+@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
-+    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
-+    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
-+    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
-+    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
-+                 id="destroy_offset"),
-+    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
-+    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
-+                 id="create_offset"),
-+    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
-+    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
-+    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
-+    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
-+                 id="charge_args"),
-+])
-+def test_diagonal_operators(oper_func, diag, offset, args):
-+    oper = oper_func(N, *args)
-+    assert oper == qutip.Qobj(np.diag(diag, offset))
-+
-+
-+@pytest.mark.parametrize(['function', 'message'], [
-+    (qutip.qeye, "All dimensions must be integers >= 0"),
-+    (qutip.destroy, "Hilbert space dimension must be integer value"),
-+    (qutip.create, "Hilbert space dimension must be integer value"),
-+], ids=["qeye", "destroy", "create"])
-+def test_diagonal_raise(function, message):
-+    with pytest.raises(ValueError) as e:
-+        function(2.5)
-+    assert str(e.value) == message
-+
-+
-+@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
-+@pytest.mark.parametrize("dimensions", [
-+        2,
-+        [2],
-+        [2, 3, 4],
-+        1,
-+        [1],
-+        [1, 1],
-+    ])
-+def test_implicit_tensor_creation(to_test, dimensions):
-+    implicit = to_test(dimensions)
-+    if isinstance(dimensions, numbers.Integral):
-+        dimensions = [dimensions]
-+    assert implicit.dims == [dimensions, dimensions]
-+
-+
-+@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
-+def test_super_operator_creation(to_test):
-+    size = 2
-+    implicit = to_test([[size], [size]])
-+    explicit = qutip.to_super(to_test(size))
-+    assert implicit == explicit
-+
-+
-+def test_position():
-+    operator = qutip.position(N)
-+    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
-+                np.diag((np.arange(1, N) / 2)**0.5, k=1))
-+    np.testing.assert_allclose(operator.full(), expected)
-+    assert operator._isherm == True
-+
-+
-+def test_momentum():
-+    operator = qutip.momentum(N)
-+    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
-+                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
-+    np.testing.assert_allclose(operator.full(), expected)
-+    assert operator._isherm == True
-+
-+
-+def test_squeeze():
-+    sq = qutip.squeeze(4, 0.1 + 0.1j)
-+    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
-+                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
-+                         [0.00000000 + 0.j, 0.98503746 + 0.j,
-+                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
-+                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
-+                          0.99500417 + 0.j, 0.00000000 + 0.j],
-+                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
-+                          0.00000000 + 0.j, 0.98503746 + 0.j]])
-+    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
-+
-+
-+def test_squeezing():
-+    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
-+    a = qutip.destroy(4)
-+    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
-+    assert squeeze == squeezing
-+
-+
-+def test_displace():
-+    dp = qutip.displace(4, 0.25)
-+    dpmatrix = np.array(
-+        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
-+          0.00626025 + 0.j],
-+         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
-+          0.j, 0.07418172 + 0.j],
-+         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
-+          0.j, -0.41083747 + 0.j],
-+         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
-+          0.90866411 + 0.j]])
-+    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
-+
-+
-+@pytest.mark.parametrize("shift", [1, 2])
-+def test_tunneling(shift):
-+    N = 10
-+    tn = qutip.tunneling(N, shift)
-+    tn_matrix = np.diag(np.ones(N - shift), k=shift)
-+    tn_matrix += tn_matrix.T
-+    np.testing.assert_allclose(tn.full(), tn_matrix)
-+
-+
-+def test_commutator():
-+    A = qutip.qeye(N)
-+    B = qutip.destroy(N)
-+    assert qutip.commutator(A, B) == qutip.qzero(N)
-+
-+    sx = qutip.sigmax()
-+    sy = qutip.sigmay()
-+    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
-+
-+    A = qutip.qeye(N)
-+    B = qutip.destroy(N)
-+    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
-+
-+    sx = qutip.sigmax()
-+    sy = qutip.sigmay()
-+    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
-+
-+    with pytest.raises(TypeError) as e:
-+        qutip.commutator(sx, sy, 'something')
-+    assert str(e.value).startswith("Unknown commutator kind")
-+
-+def test_qutrit_ops():
-+    ops = qutip.qutrit_ops()
-+    assert qutip.qeye(3) == sum(ops[:3])
-+    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
-+    expected = np.zeros((3, 3))
-+    expected[2, 0] = 1
-+    np.testing.assert_allclose(expected, ops[5].full())
-+
-+
-+def _id_func(val):
-+    "ids generated from the function only"
-+    if isinstance(val, tuple):
-+        return ""
-+
-+
-+# random object accept `str` and base.Data
-+# Obtain all valid dtype from `to`
-+dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
-+dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
-+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-+                         ids=[str(dtype) for dtype in dtype_names])
-+@pytest.mark.parametrize(['func', 'args'], [
-+    (qutip.qdiags, ([0, 1, 2], 1)),
-+    (qutip.jmat, (1,)),
-+    (qutip.spin_Jx, (1,)),
-+    (qutip.spin_Jy, (1,)),
-+    (qutip.spin_Jz, (1,)),
-+    (qutip.spin_Jp, (1,)),
-+    (qutip.destroy, (5,)),
-+    (qutip.create, (5,)),
-+    (qutip.qzero, (5,)),
-+    (qutip.qeye, (5,)),
-+    (qutip.position, (5,)),
-+    (qutip.momentum, (5,)),
-+    (qutip.num, (5,)),
-+    (qutip.squeeze, (5, 0.5)),
-+    (qutip.displace, (5, 1.0)),
-+    (qutip.qutrit_ops, ()),
-+    (qutip.phase, (5,)),
-+    (qutip.charge, (5,)),
-+    (qutip.tunneling, (5,)),
-+    (qutip.enr_destroy, ([3, 3, 3], 4)),
-+    (qutip.enr_identity, ([3, 3, 3], 4)),
-+], ids=_id_func)
-+def test_operator_type(func, args, alias, dtype):
-+    object = func(*args, dtype=alias)
-+    if isinstance(object, qutip.Qobj):
-+        assert isinstance(object.data, dtype)
-+    else:
-+        for obj in object:
-+            assert isinstance(obj.data, dtype)
-+
-+    with qutip.CoreOptions(default_dtype=alias):
-+        object = func(*args)
-+        if isinstance(object, qutip.Qobj):
-+            assert isinstance(object.data, dtype)
-+        else:
-+            for obj in object:
-+                assert isinstance(obj.data, dtype)
-+
-+
-+@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
-+def test_qft(dims):
-+    N = np.prod(dims)
-+    qft = qutip.qft(N).full()
-+    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
-+    for i in range(N):
-+        target = np.zeros(N)
-+        target[i] = 1
-+        fft = np.fft.fft(qft[:,i])
-+        fft /= np.sum(fft)
-+        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
-diff --git a/qutip/tests/core/test_ptrace.py b/qutip/tests/core/test_ptrace.py
-index 40efd151..8ae26d52 100644
---- a/qutip/tests/core/test_ptrace.py
-+++ b/qutip/tests/core/test_ptrace.py
-@@ -1,130 +1,130 @@
--import itertools
--
--import numpy as np
--import pytest
--
--import qutip
--from qutip.core import data as _data
--
--
--def expected(qobj, sel):
--    if qobj.isbra or qobj.isket:
--        qobj = qobj.proj()
--    sel = sorted(sel)
--    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
--    new_shape = (np.prod(dims[0], dtype=int),) * 2
--    out = qobj.full()
--    before, after = 1, qobj.shape[0]
--    for i, dim in enumerate(qobj.dims[0]):
--        after //= dim
--        if i in sel:
--            before = before * dim
--            continue
--        tmp_dims = (before, dim, after) * 2
--        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
--    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
--
--
--@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
--def dtype(request):
--    return request.param
--
--
--@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
--def dm(request):
--    return request.param
--
--
--@pytest.fixture
--def state(dtype, dm):
--    dims = [2, 3, 4]
--    state = qutip.rand_ket(dims)
--    if dm:
--        state = state.proj()
--    return state.to(dtype)
--
--
--def test_ptrace_noncompound_rand(dtype, dm):
--    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
--    for _ in range(5):
--        state = qutip.rand_ket(5)
--        if dm:
--            state = state.proj()
--        state = state.to(dtype)
--        assert state.ptrace(0) == (state if dm else state.proj())
--
--
--@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
--def test_ptrace_unsorted_selection_subset(state, pair):
--    """
--    Regression test for gh-1325.  ptrace should work the same independently of
--    the order of the input; no transposition in done in the trace operation.
--    """
--    # pair is always sorted.
--    state_ordered = state.ptrace(pair)
--    state_reversed = state.ptrace(pair[::-1])
--    assert state_ordered.dims == state_reversed.dims
--    assert state_ordered == state_reversed
--
--
--@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
--def test_ptrace_unsorted_selection_all(state, permutation):
--    state_ptraced = state.ptrace(permutation)
--    if state.isket:
--        state = state.proj()
--    assert state.dims == state_ptraced.dims
--    assert state == state_ptraced
--
--
--@pytest.mark.parametrize(['selection', 'exception'], [
--    pytest.param(4, IndexError, id='too big'),
--    pytest.param(-1, IndexError, id='too small'),
--    pytest.param([0, 0], ValueError, id='duplicate'),
--    # 'too many' may throw either from duplication or invalid index.
--    pytest.param([0, 1, 2, 3], Exception, id='too many'),
--])
--def test_ptrace_fails_on_invalid_input(state, selection, exception):
--    with pytest.raises(exception):
--        state.ptrace(selection)
--
--
--@pytest.mark.parametrize('dims, sel',
--                         [
--                             ([5, 2, 3], [2, 1]),
--                             ([5, 2, 3], [0, 2]),
--                             ([5, 2, 3], [0, 1]),
--                             ([2]*6, [3, 2]),
--                             ([2]*6, [0, 2]),
--                             ([2]*6, [0, 1]),
--                         ])
--def test_ptrace_rand_ket(dtype, dims, sel):
--    A = qutip.rand_ket(dims)
--    assert A.ptrace(sel) == expected(A, sel)
--
--
--@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
--                         ids=['trace_all',
--                              'trace_none',
--                              'trace_one',
--                              'trace_one_2',
--                              'trace_multiple',
--                              'trace_multiple_not_sorted',
--                              ])
--def test_ptrace_rand_dm(dtype, sel):
--    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
--    assert A.ptrace(sel) == expected(A, sel)
--
--
--@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
--                         ids=['trace_all',
--                              'trace_none',
--                              'trace_one',
--                              'trace_one_2',
--                              'trace_multiple',
--                              'trace_multiple_not_sorted',
--                              ])
--def test_ptrace_operator(dtype, sel):
--    A = qutip.tensor(
--        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
--    ).to(dtype)
--    assert A.ptrace(sel) == expected(A, sel)
-+import itertools
-+
-+import numpy as np
-+import pytest
-+
-+import qutip
-+from qutip.core import data as _data
-+
-+
-+def expected(qobj, sel):
-+    if qobj.isbra or qobj.isket:
-+        qobj = qobj.proj()
-+    sel = sorted(sel)
-+    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
-+    new_shape = (np.prod(dims[0], dtype=int),) * 2
-+    out = qobj.full()
-+    before, after = 1, qobj.shape[0]
-+    for i, dim in enumerate(qobj.dims[0]):
-+        after //= dim
-+        if i in sel:
-+            before = before * dim
-+            continue
-+        tmp_dims = (before, dim, after) * 2
-+        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
-+    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
-+
-+
-+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
-+def dtype(request):
-+    return request.param
-+
-+
-+@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
-+def dm(request):
-+    return request.param
-+
-+
-+@pytest.fixture
-+def state(dtype, dm):
-+    dims = [2, 3, 4]
-+    state = qutip.rand_ket(dims)
-+    if dm:
-+        state = state.proj()
-+    return state.to(dtype)
-+
-+
-+def test_ptrace_noncompound_rand(dtype, dm):
-+    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
-+    for _ in range(5):
-+        state = qutip.rand_ket(5)
-+        if dm:
-+            state = state.proj()
-+        state = state.to(dtype)
-+        assert state.ptrace(0) == (state if dm else state.proj())
-+
-+
-+@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
-+def test_ptrace_unsorted_selection_subset(state, pair):
-+    """
-+    Regression test for gh-1325.  ptrace should work the same independently of
-+    the order of the input; no transposition in done in the trace operation.
-+    """
-+    # pair is always sorted.
-+    state_ordered = state.ptrace(pair)
-+    state_reversed = state.ptrace(pair[::-1])
-+    assert state_ordered.dims == state_reversed.dims
-+    assert state_ordered == state_reversed
-+
-+
-+@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
-+def test_ptrace_unsorted_selection_all(state, permutation):
-+    state_ptraced = state.ptrace(permutation)
-+    if state.isket:
-+        state = state.proj()
-+    assert state.dims == state_ptraced.dims
-+    assert state == state_ptraced
-+
-+
-+@pytest.mark.parametrize(['selection', 'exception'], [
-+    pytest.param(4, IndexError, id='too big'),
-+    pytest.param(-1, IndexError, id='too small'),
-+    pytest.param([0, 0], ValueError, id='duplicate'),
-+    # 'too many' may throw either from duplication or invalid index.
-+    pytest.param([0, 1, 2, 3], Exception, id='too many'),
-+])
-+def test_ptrace_fails_on_invalid_input(state, selection, exception):
-+    with pytest.raises(exception):
-+        state.ptrace(selection)
-+
-+
-+@pytest.mark.parametrize('dims, sel',
-+                         [
-+                             ([5, 2, 3], [2, 1]),
-+                             ([5, 2, 3], [0, 2]),
-+                             ([5, 2, 3], [0, 1]),
-+                             ([2]*6, [3, 2]),
-+                             ([2]*6, [0, 2]),
-+                             ([2]*6, [0, 1]),
-+                         ])
-+def test_ptrace_rand_ket(dtype, dims, sel):
-+    A = qutip.rand_ket(dims)
-+    assert A.ptrace(sel) == expected(A, sel)
-+
-+
-+@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
-+                         ids=['trace_all',
-+                              'trace_none',
-+                              'trace_one',
-+                              'trace_one_2',
-+                              'trace_multiple',
-+                              'trace_multiple_not_sorted',
-+                              ])
-+def test_ptrace_rand_dm(dtype, sel):
-+    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
-+    assert A.ptrace(sel) == expected(A, sel)
-+
-+
-+@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
-+                         ids=['trace_all',
-+                              'trace_none',
-+                              'trace_one',
-+                              'trace_one_2',
-+                              'trace_multiple',
-+                              'trace_multiple_not_sorted',
-+                              ])
-+def test_ptrace_operator(dtype, sel):
-+    A = qutip.tensor(
-+        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
-+    ).to(dtype)
-+    assert A.ptrace(sel) == expected(A, sel)
-diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
-index 85e091b6..9c1aa156 100644
---- a/qutip/tests/core/test_qobj.py
-+++ b/qutip/tests/core/test_qobj.py
-@@ -1,1228 +1,1228 @@
--import numbers
--import operator
--import pytest
--
--import numpy as np
--import scipy.sparse
--import scipy.linalg
--
--import qutip
--from qutip.core import data as _data
--
--
--@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
--def datatype(request):
--    return request.param
--
--
--def _random_not_singular(N):
--    """
--    return a N*N complex array with determinant not 0.
--    """
--    data = np.zeros((1, 1))
--    while np.linalg.det(data) == 0:
--        data = np.random.random((N, N)) + \
--               1j * np.random.random((N, N)) - (0.5 + 0.5j)
--    return data
--
--
--def assert_hermicity(oper, hermicity):
--    # Check the cached isherm, if any exists.
--    assert oper.isherm == hermicity
--    # Force a reset of the cached value for isherm.
--    oper._isherm = None
--    # Force a recalculation of isherm.
--    assert oper.isherm == hermicity
--
--
--def test_QobjData():
--    "qutip.Qobj data"
--    N = 10
--    data1 = _random_not_singular(N)
--    q1 = qutip.Qobj(data1)
--    assert isinstance(q1.data, qutip.core.data.Data)
--    assert np.all(q1.data.to_array() == data1)
--
--    data2 = _random_not_singular(N)
--    data2 = scipy.sparse.csr_matrix(data2)
--    q2 = qutip.Qobj(data2)
--    assert isinstance(q2.data, qutip.core.data.Data)
--
--
--@pytest.mark.parametrize("original_data",
--                         [
--                            qutip.data.Dense(_random_not_singular(2)),
--                            qutip.data.csr.identity(2),
--                            qutip.Qobj(_random_not_singular(2)),
--                            _random_not_singular(2),
--                         ],
--                         ids=[
--                             "Dense",
--                             "CSR",
--                             "Qobj",
--                             "ndarray",
--                         ])
--@pytest.mark.parametrize("copy", [True, False],
--                         ids=["copy=True", "copy=False"])
--def test_QobjCopyArgument(original_data, copy):
--    """Tests that Qobj copy argument works properly when instantiating Qobj."""
--    qobj_data = qutip.Qobj(original_data, copy=copy).data
--
--    if isinstance(original_data, qutip.Qobj):
--        # Qobj copies the data of another Qobj, so we take `data` if
--        # original_data was a Qobj
--        original_data = original_data.data
--
--    if isinstance(original_data, np.ndarray):
--        # For numpy object we compare with data's data. This should be dense so
--        # we get its data as ndarray.
--        qobj_data = qobj_data.as_ndarray()
--
--        # We look at the memory and see if it is shared or not to asses wether
--        # copy argument worked or not.
--        assert np.shares_memory(qobj_data, original_data) != copy
--
--    else:
--        assert (original_data is qobj_data) != copy
--
--
--def test_QobjType():
--    "qutip.Qobj type"
--    N = int(np.ceil(10.0 * np.random.random())) + 5
--
--    ket_data = np.random.random((N, 1))
--    ket_qobj = qutip.Qobj(ket_data)
--    assert ket_qobj.type == 'ket'
--    assert ket_qobj.isket
--
--    bra_data = np.random.random((1, N))
--    bra_qobj = qutip.Qobj(bra_data)
--    assert bra_qobj.type == 'bra'
--    assert bra_qobj.isbra
--
--    oper_data = np.random.random((N, N))
--    oper_qobj = qutip.Qobj(oper_data)
--    assert oper_qobj.type == 'oper'
--    assert oper_qobj.isoper
--
--    N = 9
--    super_data = np.random.random((N, N))
--    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
--    assert super_qobj.type == 'super'
--    assert super_qobj.issuper
--    assert super_qobj.superrep == 'super'
--
--    super_data = np.random.random(N)
--    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
--    assert super_qobj.type == 'operator-ket'
--    assert super_qobj.isoperket
--    assert super_qobj.superrep == 'super'
--
--    super_data = np.random.random(N)
--    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
--    assert super_qobj.type == 'operator-bra'
--    assert super_qobj.isoperbra
--    assert super_qobj.superrep == 'super'
--
--    operket_qobj = qutip.operator_to_vector(oper_qobj)
--    assert operket_qobj.isoperket
--    assert operket_qobj.dag().isoperbra
--
--
--class TestQobjHermicity:
--    def test_standard(self):
--        base = _random_not_singular(10)
--        assert_hermicity(qutip.Qobj(base), False)
--        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
--        assert_hermicity(qutip.destroy(5), False)
--        assert_hermicity(qutip.create(5), False)
--
--    def test_addition(self):
--        q_a, q_ad = qutip.destroy(5), qutip.create(5)
--        # test addition of two nonhermitian operators adding up to be hermitian
--        q_x = q_a + q_ad
--        assert_hermicity(q_x, True)
--        # test addition of one hermitan and one nonhermitian operator
--        assert_hermicity(q_x + q_a, False)
--        # test addition of two hermitan operators
--        assert_hermicity(q_x + q_x, True)
--
--    def test_multiplication(self):
--        # Test multiplication of two Hermitian operators.  This results in a
--        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
--        # set wrong metadata.
--        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
--        # Similarly, we need to check that -Z = X * iY is correctly identified
--        # as Hermitian.
--        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
--
--
--def assert_unitarity(oper, unitarity):
--    # Check the cached isunitary.
--    assert oper.isunitary == unitarity
--
--    # Force a reset of the cached value for isunitary.
--    oper._isunitary = None
--    # Force a recalculation of isunitary.
--    assert oper.isunitary == unitarity
--
--
--def test_QobjUnitaryOper():
--    "qutip.Qobj unitarity"
--    # Check some standard operators
--    Sx = qutip.sigmax()
--    Sy = qutip.sigmay()
--    assert_unitarity(qutip.qeye(4), True)
--    assert_unitarity(Sx, True)
--    assert_unitarity(Sy, True)
--    assert_unitarity(qutip.sigmam(), False)
--    assert_unitarity(qutip.destroy(10), False)
--    # Check multiplcation of unitary is unitary
--    assert_unitarity(Sx*Sy, True)
--    # Check some other operations clear unitarity
--    assert_unitarity(Sx+Sy, False)
--    assert_unitarity(4*Sx, False)
--    assert_unitarity(Sx*4, False)
--    assert_unitarity(4+Sx, False)
--    assert_unitarity(Sx+4, False)
--    # Check that when multipliying scalar numbers with absolute value 1 we
--    # maintain unitarity.
--    assert_unitarity(Sx*np.exp(5j), True)
--    assert_unitarity(Sx*1j, True)
--    assert_unitarity(Sx*1, True)
--    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
--    # We do not know if it is unitary until we check the whole matrix again.
--    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
--    # This may be removed in the future as if scalar has abs value of 1 and
--    # matrix is not unitary, output wont be unitary.
--    assert (qutip.sigmam()*1)._isunitary == None
--
--
--def test_QobjDimsShape():
--    "qutip.Qobj shape"
--    N = 10
--    data = _random_not_singular(N)
--
--    q1 = qutip.Qobj(data)
--    assert q1.dims == [[10], [10]]
--    assert q1.shape == (10, 10)
--
--    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
--
--    q1 = qutip.Qobj(data)
--    assert q1.dims == [[10], [1]]
--    assert q1.shape == (10, 1)
--
--    data = _random_not_singular(4)
--
--    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
--    assert q1.dims == [[2, 2], [2, 2]]
--    assert q1.shape == (4, 4)
--
--
--def test_QobjMulNonsquareDims():
--    """
--    qutip.Qobj: multiplication w/ non-square qobj.dims
--
--    Checks for regression of #331.
--    """
--    data = np.array([[0, 1], [1, 0]])
--
--    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
--    q2 = qutip.Qobj(data, dims=[[2], [2]])
--
--    assert (q1 * q2).dims == [[2, 1], [2]]
--    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
--    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
--
--    # Because of the above, we also need to check for extra indices
--    # that aren't of length 1.
--    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
--                     [0.+0.j,  1.+0.j],
--                     [0.+0.j,  1.+0.j],
--                     [1.+0.j,  0.+0.j],
--                     [0.+0.j,  0.-1.j],
--                     [0.+1.j,  0.+0.j],
--                     [1.+0.j,  0.+0.j],
--                     [0.+0.j, -1.+0.j]],
--                    dims=[[4, 2], [2]])
--    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
--
--
--def test_QobjAddition():
--    "qutip.Qobj addition"
--    data1 = np.array([[1, 2], [3, 4]])
--    data2 = np.array([[5, 6], [7, 8]])
--    data3 = data1 + data2
--
--    q1 = qutip.Qobj(data1)
--    q2 = qutip.Qobj(data2)
--    q3 = qutip.Qobj(data3)
--
--    q4 = q1 + q2
--    q4_type = q4.type
--    q4_isherm = q4.isherm
--    q4._type = None
--    q4._isherm = None  # clear cached values
--    assert q4_type == q4.type
--    assert q4_isherm == q4.isherm
--
--    # check elementwise addition/subtraction
--    assert q3 == q4
--
--    # check that addition is commutative
--    assert q1 + q2 == q2 + q1
--
--    data = np.random.random((5, 5))
--    q = qutip.Qobj(data)
--    x1 = q + 5
--    x2 = 5 + q
--    data = data + np.eye(5) * 5
--    assert np.all(x1.full() == data)
--    assert np.all(x2.full() == data)
--
--
--def test_QobjSubtraction():
--    "qutip.Qobj subtraction"
--    data1 = _random_not_singular(5)
--    q1 = qutip.Qobj(data1)
--
--    data2 = _random_not_singular(5)
--    q2 = qutip.Qobj(data2)
--
--    q3 = q1 - q2
--    data3 = data1 - data2
--    assert np.all(q3.full() == data3)
--
--    q4 = q2 - q1
--    data4 = data2 - data1
--    assert np.all(q4.full() == data4)
--
--
--def test_QobjMultiplication():
--    "qutip.Qobj multiplication"
--    data1 = np.array([[1, 2], [3, 4]])
--    data2 = np.array([[5, 6], [7, 8]])
--
--    data3 = np.dot(data1, data2)
--
--    q1 = qutip.Qobj(data1)
--    q2 = qutip.Qobj(data2)
--    q3 = qutip.Qobj(data3)
--
--    q4 = q1 * q2
--
--    assert q3 == q4
--
--
--# Allowed mul operations (scalar)
--@pytest.mark.parametrize("scalar",
--                         [2+2j,  np.array(2+2j), np.array([2+2j])],
--                         ids=[
--                             "python_number",
--                             "scalar_like_array_shape_0",
--                             "scalar_like_array_shape_1",
--                         ])
--def test_QobjMulValidScalar(scalar):
--    "Tests multiplication of Qobj times scalar."
--    data = np.array([[1, 2], [3, 4]])
--    q = qutip.Qobj(data)
--    expect = data * (2+2j)
--
--    # Check __mul__
--    result = q * scalar
--    assert np.all(result.full() == expect)
--
--    # Check __rmul__
--    result = scalar * q
--    assert np.all(result.full() == expect)
--
--
--# We do not allow yet qobj being multiplied by a numpy array that does not
--# represent a scalar. If we include the feature of numpy broadcasting an qobj
--# as scalar, this test should be removed.
--@pytest.mark.parametrize("not_scalar",
--                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
--                         ids=[
--                             "not_scalar_like_vector",
--                             "not_scalar_like_matrix",
--                         ])
--def test_QobjMulNotValidScalar(not_scalar):
--    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
--
--    with pytest.raises(TypeError):
--        not_scalar * q1
--
--    with pytest.raises(TypeError):
--        q1 * not_scalar
--
--
--# Allowed division operations (scalar)
--@pytest.mark.parametrize("scalar",
--                         [2+2j,  np.array(2+2j), np.array([2+2j])],
--                         ids=[
--                             "python_number",
--                             "scalar_like_array_shape_0",
--                             "scalar_like_array_shape_1",
--                         ])
--def test_QobjDivisionValidScalar(scalar):
--    "Tests multiplication of Qobj times scalar."
--    data = np.array([[1, 2], [3, 4]])
--    q = qutip.Qobj(data)
--    expect = data / (2+2j)
--
--    # Check __truediv__
--    result = q / scalar
--    assert np.all(result.full() == expect)
--
--
--# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
--# non scalar numpy values. This should also be removed in case of implementing
--# broadcasting rules for Qobj.
--@pytest.mark.parametrize("not_scalar",
--                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
--                         ids=[
--                             "not_scalar_like_vector",
--                             "not_scalar_like_matrix",
--                         ])
--def test_QobjDivisionNotValidScalar(not_scalar):
--    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
--
--    with pytest.raises(TypeError):
--        q1 / not_scalar
--
--
--def test_QobjNotImplemented():
--    class MockerScalar():
--        def __mul__(self, other):
--            return "object not accepted by _data.mul, mul"
--
--        def __rmul__(self, other):
--            return "object not accepted by _data.mul, rmul"
--
--        def __rtruediv__(self, other):
--            return "object not accepted by _data.mul, rtruediv"
--
--    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
--    scalar = MockerScalar()
--    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
--    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
--    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
--
--def test_QobjDivision():
--    "qutip.Qobj division"
--    data = _random_not_singular(5)
--    q = qutip.Qobj(data)
--    randN = 10 * np.random.random()
--    q = q / randN
--    assert np.allclose(q.full(), data/randN)
--
--
--def test_QobjPower():
--    "qutip.Qobj power"
--    data = _random_not_singular(5)
--    q = qutip.Qobj(data)
--    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
--    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
--
--
--def test_QobjNeg():
--    "qutip.Qobj negation"
--    data = _random_not_singular(5)
--    q = qutip.Qobj(data)
--    x = -q
--    assert np.all(x.full() == -data)
--    assert q.isherm == x.isherm
--    assert q.type == x.type
--
--
--def test_QobjEquals():
--    "qutip.Qobj equals"
--    data = _random_not_singular(5)
--    q1 = qutip.Qobj(data)
--    q2 = qutip.Qobj(data)
--    assert q1 == q2
--
--    q1 = qutip.Qobj(data)
--    q2 = qutip.Qobj(-data)
--    assert q1 != q2
--
--
--def test_QobjGetItem():
--    "qutip.Qobj getitem"
--    data = _random_not_singular(5)
--    q = qutip.Qobj(data)
--    assert q[0, 0] == data[0, 0]
--    assert q[-1, 2] == data[-1, 2]
--
--
--def test_CheckMulType():
--    "qutip.Qobj multiplication type"
--    # ket-bra and bra-ket multiplication
--    psi = qutip.basis(5, 0)
--    dm = psi * psi.dag()
--    assert dm.isoper
--    assert dm.isherm
--
--    nrm = psi.dag() * psi
--    assert isinstance(nrm, numbers.Complex)
--    assert abs(nrm) == 1
--
--    # operator-operator multiplication
--    H1 = qutip.rand_herm(3)
--    H2 = qutip.rand_herm(3)
--    out = H1 * H2
--    assert out.isoper
--    out = H1 * H1
--    assert out.isoper
--    assert out.isherm
--    out = H2 * H2
--    assert out.isoper
--    assert out.isherm
--
--    U = qutip.rand_unitary(5)
--    out = U.dag() * U
--    assert out.isoper
--    assert out.isherm
--
--    N = qutip.num(5)
--
--    out = N * N
--    assert out.isoper
--    assert out.isherm
--
--    # operator-ket and bra-operator multiplication
--    op = qutip.sigmax()
--    ket1 = qutip.basis(2, 0)
--    ket2 = op * ket1
--    assert ket2.isket
--
--    bra1 = qutip.basis(2, 0).dag()
--    bra2 = bra1 * op
--    assert bra2.isbra
--
--    assert bra2.dag() == ket2
--
--    # superoperator-operket and operbra-superoperator multiplication
--    sop = qutip.to_super(qutip.sigmax())
--    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
--    opket2 = sop * opket1
--    assert opket2.isoperket
--
--    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
--    opbra2 = opbra1 * sop
--    assert opbra2.isoperbra
--
--    assert opbra2.dag() == opket2
--
--
--def test_operator_ket_superrep():
--    sop = qutip.to_super(qutip.sigmax())
--    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
--    opket2 = sop * opket1
--    assert opket1.superrep == opket2.superrep
--
--    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
--    opbra2 = opbra1 * sop
--    assert opbra1.superrep == opbra2.superrep
--
--
--def test_QobjConjugate():
--    "qutip.Qobj conjugate"
--    data = _random_not_singular(5)
--    A = qutip.Qobj(data)
--    B = A.conj()
--    assert np.all(B.full() == data.conj())
--    assert A.isherm == B.isherm
--    assert A.type == B.type
--    assert A.superrep == B.superrep
--
--
--def test_QobjDagger():
--    "qutip.Qobj adjoint (dagger)"
--    data = _random_not_singular(5)
--    A = qutip.Qobj(data)
--    B = A.dag()
--    assert np.all(B.full() == data.conj().T)
--    assert A.isherm == B.isherm
--    assert A.type == B.type
--    assert A.superrep == B.superrep
--
--
--def test_QobjDiagonals():
--    "qutip.Qobj diagonals"
--    data = _random_not_singular(5)
--    A = qutip.Qobj(data)
--    b = A.diag()
--    assert np.all(b == np.diag(data))
--
--
--def test_QobjEigenEnergies():
--    "qutip.Qobj eigenenergies"
--    data = np.eye(5)
--    A = qutip.Qobj(data)
--    b = A.eigenenergies()
--    assert np.all(b == np.ones(5))
--
--    data = np.diag(np.arange(10))
--    A = qutip.Qobj(data)
--    b = A.eigenenergies()
--    assert np.all(b == np.arange(10))
--
--    data = np.diag(np.arange(10))
--    A = 5 * qutip.Qobj(data)
--    b = A.eigenenergies()
--    assert np.all(b == 5*np.arange(10))
--
--
--def test_QobjEigenStates():
--    "qutip.Qobj eigenstates"
--    data = np.eye(5)
--    A = qutip.Qobj(data)
--    b, c = A.eigenstates()
--    assert np.all(b == np.ones(5))
--    kets = [qutip.basis(5, k) for k in range(5)]
--    for k in range(5):
--        assert c[k] == kets[k]
--
--
--def test_QobjExpm():
--    "qutip.Qobj expm (dense)"
--    data = _random_not_singular(15)
--    A = qutip.Qobj(data)
--    B = A.expm()
--    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
--
--
--def test_QobjExpmExplicitlySparse():
--    "qutip.Qobj expm (sparse)"
--    data = _random_not_singular(15)
--    A = qutip.Qobj(data)
--    B = A.expm(dtype=qutip.data.CSR)
--    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
--
--
--def test_QobjExpmZeroOper():
--    "qutip.Qobj expm zero_oper (#493)"
--    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
--    B = A.expm()
--    assert B == qutip.qeye(5)
--
--
--def test_QobjLogm():
--    "qutip.Qobj expm (dense)"
--    data = _random_not_singular(15)
--    A = qutip.Qobj(data)
--    B = A.logm()
--    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
--
--
--def test_QobjLogmExplicitlySparse():
--    "qutip.Qobj logm (sparse)"
--    data = _random_not_singular(15)
--    A = qutip.Qobj(data).to("csr")
--    B = A.logm()
--    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
--
--
--def test_QobjLogmZeroOper():
--    "qutip.Qobj logm zero_oper (#493)"
--    A = qutip.qeye(5)
--    B = A.logm()
--    assert B == qutip.qzero(5)
--
--
--def test_Qobj_sqrtm():
--    "qutip.Qobj sqrtm"
--    data = _random_not_singular(5)
--    A = qutip.Qobj(data)
--    B = A.sqrtm()
--    assert A == B * B
--
--
--def test_Qobj_inv():
--    "qutip.Qobj inv"
--    data = _random_not_singular(5)
--    A = qutip.Qobj(data)
--    B = A.inv()
--    assert qutip.qeye(5) == A * B
--    assert qutip.qeye(5) == B * A
--    B = A.inv(sparse=True)
--    assert qutip.qeye(5) == A * B
--    assert qutip.qeye(5) == B * A
--
--
--def test_QobjFull():
--    "qutip.Qobj full"
--    data = _random_not_singular(15)
--    A = qutip.Qobj(data)
--    b = A.full()
--    assert np.all(b == data)
--
--
--def test_QobjNorm():
--    "qutip.Qobj norm"
--    # vector L2-norm test
--    N = 20
--    x = np.random.random(N) + 1j*np.random.random(N)
--    A = qutip.Qobj(x)
--    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
--    # vector max (inf) norm test
--    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
--                               atol=1e-12)
--    # operator frobius norm
--    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
--    A = qutip.Qobj(x)
--    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
--                               atol=1e-12)
--    # operator trace norm
--    a = qutip.rand_herm(10, density=0.25)
--    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
--    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
--    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
--
--
--def test_QobjPurity():
--    "Tests the purity method of `qutip.Qobj`"
--    psi = qutip.basis(2, 1)
--    # check purity of pure ket state
--    np.testing.assert_allclose(psi.purity(), 1)
--    # check purity of pure ket state (superposition)
--    psi2 = qutip.basis(2, 0)
--    psi_tot = (psi+psi2).unit()
--    np.testing.assert_allclose(psi_tot.purity(), 1)
--    # check purity of density matrix of pure state
--    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
--    # check purity of maximally mixed density matrix
--    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
--    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
--
--
--def test_QobjPermute(datatype):
--    "qutip.Qobj permute"
--    A = qutip.basis(3, 0, dtype=datatype)
--    B = qutip.basis(5, 4, dtype=datatype)
--    C = qutip.basis(4, 2, dtype=datatype)
--    psi = qutip.tensor(A, B, C)
--    psi2 = psi.permute([2, 0, 1])
--    assert psi2 == qutip.tensor(C, A, B)
--
--    psi_bra = psi.dag()
--    psi2_bra = psi_bra.permute([2, 0, 1])
--    assert psi2_bra == qutip.tensor(C, A, B).dag()
--
--    A = qutip.fock_dm(3, 0, dtype=datatype)
--    B = qutip.fock_dm(5, 4, dtype=datatype)
--    C = qutip.fock_dm(4, 2, dtype=datatype)
--    rho = qutip.tensor(A, B, C)
--    rho2 = rho.permute([2, 0, 1])
--    assert rho2 == qutip.tensor(C, A, B)
--
--    for _ in range(3):
--        A = qutip.rand_ket(3, dtype=datatype)
--        B = qutip.rand_ket(4, dtype=datatype)
--        C = qutip.rand_ket(5, dtype=datatype)
--        psi = qutip.tensor(A, B, C)
--        psi2 = psi.permute([1, 0, 2])
--        assert psi2 == qutip.tensor(B, A, C)
--
--        psi_bra = psi.dag()
--        psi2_bra = psi_bra.permute([1, 0, 2])
--        assert psi2_bra == qutip.tensor(B, A, C).dag()
--
--    for _ in range(3):
--        A = qutip.rand_dm(3, dtype=datatype)
--        B = qutip.rand_dm(4, dtype=datatype)
--        C = qutip.rand_dm(5, dtype=datatype)
--        rho = qutip.tensor(A, B, C)
--        rho2 = rho.permute([1, 0, 2])
--        assert rho2 == qutip.tensor(B, A, C)
--
--        rho_vec = qutip.operator_to_vector(rho)
--        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
--        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
--
--        rho_vec_bra = qutip.operator_to_vector(rho).dag()
--        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
--        assert (rho2_vec_bra
--                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
--
--    for _ in range(3):
--        super_dims = [3, 5, 4]
--        U = qutip.rand_unitary(super_dims, dtype=datatype)
--        Unew = U.permute([2, 1, 0])
--        S_tens = qutip.to_super(U)
--        S_tens_new = qutip.to_super(Unew)
--        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
--
--
--def test_KetType():
--    "qutip.Qobj ket type"
--
--    psi = qutip.basis(2, 1)
--
--    assert psi.isket
--    assert not psi.isbra
--    assert not psi.isoper
--    assert not psi.issuper
--
--    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
--
--    assert psi.isket
--    assert not psi.isbra
--    assert not psi.isoper
--    assert not psi.issuper
--
--
--def test_BraType():
--    "qutip.Qobj bra type"
--
--    psi = qutip.basis(2, 1).dag()
--    assert not psi.isket
--    assert psi.isbra
--    assert not psi.isoper
--    assert not psi.issuper
--
--    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
--    assert not psi.isket
--    assert psi.isbra
--    assert not psi.isoper
--    assert not psi.issuper
--
--
--def test_OperType():
--    "qutip.Qobj operator type"
--
--    psi = qutip.basis(2, 1)
--    rho = psi * psi.dag()
--
--    assert not rho.isket
--    assert not rho.isbra
--    assert rho.isoper
--    assert not rho.issuper
--
--
--def test_SuperType():
--    "qutip.Qobj superoperator type"
--
--    psi = qutip.basis(2, 1)
--    rho = psi * psi.dag()
--
--    sop = qutip.spre(rho)
--
--    assert not sop.isket
--    assert not sop.isbra
--    assert not sop.isoper
--    assert sop.issuper
--
--    sop = qutip.spost(rho)
--
--    assert not sop.isket
--    assert not sop.isbra
--    assert not sop.isoper
--    assert sop.issuper
--
--
--@pytest.mark.parametrize("dimension", [2, 4, 8])
--@pytest.mark.parametrize("conversion", [
--    pytest.param(qutip.to_super, id='to_super'),
--    pytest.param(qutip.to_choi, id='to_choi'),
--    pytest.param(qutip.to_chi, id='to_chi'),
--])
--def test_dag_preserves_superrep(dimension, conversion):
--    """
--    Checks that dag() preserves superrep.
--    """
--    qobj = conversion(qutip.rand_super_bcsz(dimension))
--    assert qobj.superrep == qobj.dag().superrep
--
--
--@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
--@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
--    pytest.param(operator.add, True, True, id='add'),
--    pytest.param(operator.sub, True, True, id='sub'),
--    pytest.param(operator.mul, True, True, id='mul'),
--    pytest.param(operator.truediv, False, True, id='div'),
--    pytest.param(qutip.tensor, True, False, id='tensor'),
--])
--def test_arithmetic_preserves_superrep(superrep,
--                                       operation, check_op, check_scalar):
--    """
--    Checks that binary ops preserve 'superrep'.
--
--    .. note::
--
--        The random superoperators are not chosen in a way that reflects the
--        structure of that superrep, but are simply random matrices.
--    """
--    dims = [[[2], [2]], [[2], [2]]]
--    shape = (4, 4)
--    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
--    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
--    x = np.random.random()
--
--    check_list = []
--    if check_op:
--        check_list.append(operation(S1, S2))
--    if check_scalar:
--        check_list.append(operation(S1, x))
--    if check_op and check_scalar:
--        check_list.append(operation(x, S2))
--
--    for S in check_list:
--        assert S.issuper
--        assert S.type == "super"
--        assert S.superrep == superrep
--
--
--def test_isherm_skew():
--    """
--    mul and tensor of skew-Hermitian operators report ``isherm = True``.
--    """
--    iH = 1j * qutip.rand_herm(5)
--    assert_hermicity(iH, False)
--    assert_hermicity(iH * iH, True)
--    assert_hermicity(qutip.tensor(iH, iH), True)
--
--
--def test_super_tensor_operket():
--    """
--    Tensor: Checks that super_tensor respects states.
--    """
--    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
--    qutip.operator_to_vector(rho1)
--    qutip.operator_to_vector(rho2)
--
--
--def test_super_tensor_property():
--    """
--    Tensor: Super_tensor correctly tensors on underlying spaces.
--    """
--    U1 = qutip.rand_unitary(3)
--    U2 = qutip.rand_unitary(5)
--    U = qutip.tensor(U1, U2)
--    S_tens = qutip.to_super(U)
--    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
--    assert S_tens == S_supertens
--    assert S_supertens.superrep == 'super'
--
--
--def test_composite_oper():
--    """
--    Composite: Tests compositing unitaries and superoperators.
--    """
--    U1 = qutip.rand_unitary(3)
--    U2 = qutip.rand_unitary(5)
--    S1 = qutip.to_super(U1)
--    S2 = qutip.to_super(U2)
--    S3 = qutip.rand_super(4)
--    S4 = qutip.rand_super(7)
--
--    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
--    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
--    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
--    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
--
--
--def test_composite_vec():
--    """
--    Composite: Tests compositing states and density operators.
--    """
--    k1 = qutip.rand_ket(5)
--    k2 = qutip.rand_ket(7)
--    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
--    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
--
--    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
--    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
--
--    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
--    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
--    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
--    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
--
--# TODO: move out to a more appropriate module.
--
--
--def trunc_neg_case(qobj, method, expected=None):
--    pos_qobj = qobj.trunc_neg(method=method)
--    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
--    np.testing.assert_allclose(pos_qobj.tr(), 1)
--    if expected is not None:
--        test_array = pos_qobj.full()
--        exp_array = expected.full()
--        np.testing.assert_allclose(test_array, exp_array)
--
--
--class TestTruncNeg:
--    """Test qutip.Qobj.trunc_neg for several different cases."""
--    def test_positive_operator(self):
--        trunc_neg_case(qutip.rand_dm(5), 'clip')
--        trunc_neg_case(qutip.rand_dm(5), 'sgs')
--
--    def test_diagonal_operator(self):
--        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
--        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
--        trunc_neg_case(to_test, 'clip', expected)
--        trunc_neg_case(to_test, 'sgs', expected)
--
--    def test_nondiagonal_operator(self):
--        U = qutip.rand_unitary(3)
--        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
--        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
--        trunc_neg_case(to_test, 'clip', expected)
--        trunc_neg_case(to_test, 'sgs', expected)
--
--    def test_sgs_known_good(self):
--        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
--                       'sgs',
--                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
--
--
--def test_cosm():
--    """
--    Test qutip.Qobj: cosm
--    """
--    A = qutip.rand_herm(5)
--    B = A.cosm().full()
--    C = scipy.linalg.cosm(A.full())
--    np.testing.assert_allclose(B, C, atol=1e-14)
--
--
--def test_sinm():
--    """
--    Test qutip.Qobj: sinm
--    """
--    A = qutip.rand_herm(5)
--    B = A.sinm().full()
--    C = scipy.linalg.sinm(A.full())
--    np.testing.assert_allclose(B, C, atol=1e-14)
--
--
--@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
--def test_dual_channel(sub_dimensions, n_trials=50):
--    """
--    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
--    """
--    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
--    S.dims = [[sub_dimensions, sub_dimensions],
--              [sub_dimensions, sub_dimensions]]
--    S = qutip.to_super(S)
--    left_dims, right_dims = S.dims
--
--    # Assume for the purposes of the test that S maps square operators to
--    # square operators.
--    in_dim = np.prod(right_dims[0])
--    out_dim = np.prod(left_dims[0])
--
--    S_dual = qutip.to_super(S.dual_chan())
--
--    primals = []
--    duals = []
--
--    for _ in [None]*n_trials:
--        X = qutip.rand_dm(out_dim)
--        X.dims = left_dims
--        X = qutip.operator_to_vector(X)
--        Y = qutip.rand_dm(in_dim)
--        Y.dims = right_dims
--        Y = qutip.operator_to_vector(Y)
--
--        primals.append(X.dag() * S * Y)
--        duals.append(X.dag() * S_dual.dag() * Y)
--
--    np.testing.assert_allclose(primals, duals)
--
--
--def test_call():
--    """
--    Test qutip.Qobj: Call
--    """
--    # Make test objects.
--    psi = qutip.rand_ket(3)
--    rho = qutip.rand_dm(3)
--    U = qutip.rand_unitary(3)
--    S = qutip.rand_super_bcsz(3)
--
--    # Case 0: oper(ket).
--    assert U(psi) == U * psi
--    # Case 1: oper(oper). Should raise TypeError.
--    with pytest.raises(TypeError):
--        U(rho)
--    # Case 2: super(ket).
--    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
--    assert S(psi) == expected
--    # Case 3: super(oper).
--    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
--    assert S(rho) == expected
--    # Case 4: super(super). Should raise TypeError.
--    with pytest.raises(TypeError):
--        S(S)
--
--
--def test_mat_elem():
--    """
--    Test qutip.Qobj: Compute matrix elements
--    """
--    for _ in range(10):
--        N = 20
--        H = qutip.rand_herm(N, density=0.2)
--        L = qutip.rand_ket(N, density=0.3)
--        Ld = L.dag()
--        R = qutip.rand_ket(N, density=0.3)
--        ans = Ld * H * R
--        # bra-ket
--        out1 = H.matrix_element(Ld, R)
--        # ket-ket
--        out2 = H.matrix_element(Ld, R)
--        assert abs(ans - out1) < 1e-14
--        assert abs(ans - out2) < 1e-14
--
--
--def test_projection():
--    """
--    Test qutip.Qobj: Projection operator
--    """
--    for _ in range(10):
--        N = 5
--        K = qutip.rand_ket([N, N], density=0.75)
--        B = K.dag()
--        ans = K * K.dag()
--        out1 = K.proj()
--        out2 = B.proj()
--        assert out1 == ans
--        assert out2 == ans
--
--
--def test_overlap():
--    """
--    Test qutip.Qobj: Overlap (inner product)
--    """
--    for _ in range(10):
--        N = 10
--        A = qutip.rand_ket(N, density=0.75)
--        Ad = A.dag()
--        B = qutip.rand_ket(N, density=0.75)
--        Bd = B.dag()
--        ans = A.dag() * B
--        np.testing.assert_allclose(A.overlap(B), ans)
--        np.testing.assert_allclose(Ad.overlap(B), ans)
--        np.testing.assert_allclose(Ad.overlap(Bd), ans)
--        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
--
--
--def test_unit():
--    """
--    Test qutip.Qobj: unit
--    """
--    psi = (10*np.random.randn()*qutip.basis(2, 0)
--           - 10j*np.random.randn()*qutip.basis(2, 1))
--    psi2 = psi.unit()
--    psi.unit(inplace=True)
--    assert psi == psi2
--    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
--
--
--def test_trace():
--    sz = qutip.sigmaz()
--    assert sz.tr() == 0
--
--
--def test_no_real_attribute(monkeypatch):
--    """This tests ensures that trace still works even if the output of a
--    specialisation does not have the ``real`` attribute. This is the case for
--    the tensorflow and cupy data layers."""
--
--    def mocker_trace_return(oper):
--        """
--        We simply return a string which does not have the `real` attribute.
--        """
--        return "object without .real"
--
--    monkeypatch.setattr(_data, "trace", mocker_trace_return)
--
--    sz = qutip.sigmaz() # the choice of the matrix does not matter
--    assert "object without .real" == sz.tr()
--
--
--@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
--@pytest.mark.parametrize(['expanded', 'contracted'], [
--    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
--    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
--    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
--    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
--    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
--                 id='mixed'),
--    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
--                 id='mixed,unchanged'),
--    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
--                 id='mixed,unchanged'),
--    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
--    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
--    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
--                 id='ket,unchanged'),
--    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
--    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
--    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
--                 id='bra,unchanged'),
--    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
--                 id='operket'),
--    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
--                 id='operbra'),
--])
--def test_contract(expanded, contracted, inplace):
--    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
--    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
--    qobj = qutip.Qobj(data, dims=expanded)
--    assert qobj.dims == expanded
--    out = qobj.contract(inplace=inplace)
--    if inplace:
--        assert out is qobj
--    else:
--        assert out is not qobj
--    assert out.dims == contracted
--    assert out.shape == qobj.shape
--    assert np.all(out.full() == qobj.full())
--
--
--@pytest.mark.parametrize(["shape"], [
--    pytest.param((5, 1), id='ket'),
--    pytest.param((5, 2), id='tall'),
--    pytest.param((1, 5), id='bra'),
--    pytest.param((2, 5), id='wide'),
--    pytest.param((3, 3), id='oper'),
--])
--def test_sum_zero(shape):
--    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
--    qobj = qutip.Qobj(data)
--    assert qobj + 0 == qobj
--    assert qobj - 0 == qobj
--    assert 0 + qobj == qobj
--    assert 0 - qobj == -qobj
--
--
--@pytest.mark.parametrize(["shape"], [
--    pytest.param((5, 1), id='ket'),
--    pytest.param((5, 2), id='tall'),
--    pytest.param((1, 5), id='bra'),
--    pytest.param((2, 5), id='wide'),
--    pytest.param((3, 3), id='oper'),
--])
--def test_sum_buildin(shape):
--    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
--    qobj = qutip.Qobj(data)
--    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
--
--
--def test_groundstate():
--    eigenvals = np.sort(np.random.rand(10))
--    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
--    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
--    groundenergy, groundstate = qobj.groundstate()
--    assert groundenergy == pytest.approx(eigenvals[0])
--    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
--    assert groundstate.overlap(groundstate) == pytest.approx(1)
--
--    with pytest.warns(UserWarning) as warning:
--        qutip.qeye(5).groundstate()
--    assert "degenerate" in warning[0].message.args[0]
-+import numbers
-+import operator
-+import pytest
-+
-+import numpy as np
-+import scipy.sparse
-+import scipy.linalg
-+
-+import qutip
-+from qutip.core import data as _data
-+
-+
-+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
-+def datatype(request):
-+    return request.param
-+
-+
-+def _random_not_singular(N):
-+    """
-+    return a N*N complex array with determinant not 0.
-+    """
-+    data = np.zeros((1, 1))
-+    while np.linalg.det(data) == 0:
-+        data = np.random.random((N, N)) + \
-+               1j * np.random.random((N, N)) - (0.5 + 0.5j)
-+    return data
-+
-+
-+def assert_hermicity(oper, hermicity):
-+    # Check the cached isherm, if any exists.
-+    assert oper.isherm == hermicity
-+    # Force a reset of the cached value for isherm.
-+    oper._isherm = None
-+    # Force a recalculation of isherm.
-+    assert oper.isherm == hermicity
-+
-+
-+def test_QobjData():
-+    "qutip.Qobj data"
-+    N = 10
-+    data1 = _random_not_singular(N)
-+    q1 = qutip.Qobj(data1)
-+    assert isinstance(q1.data, qutip.core.data.Data)
-+    assert np.all(q1.data.to_array() == data1)
-+
-+    data2 = _random_not_singular(N)
-+    data2 = scipy.sparse.csr_matrix(data2)
-+    q2 = qutip.Qobj(data2)
-+    assert isinstance(q2.data, qutip.core.data.Data)
-+
-+
-+@pytest.mark.parametrize("original_data",
-+                         [
-+                            qutip.data.Dense(_random_not_singular(2)),
-+                            qutip.data.csr.identity(2),
-+                            qutip.Qobj(_random_not_singular(2)),
-+                            _random_not_singular(2),
-+                         ],
-+                         ids=[
-+                             "Dense",
-+                             "CSR",
-+                             "Qobj",
-+                             "ndarray",
-+                         ])
-+@pytest.mark.parametrize("copy", [True, False],
-+                         ids=["copy=True", "copy=False"])
-+def test_QobjCopyArgument(original_data, copy):
-+    """Tests that Qobj copy argument works properly when instantiating Qobj."""
-+    qobj_data = qutip.Qobj(original_data, copy=copy).data
-+
-+    if isinstance(original_data, qutip.Qobj):
-+        # Qobj copies the data of another Qobj, so we take `data` if
-+        # original_data was a Qobj
-+        original_data = original_data.data
-+
-+    if isinstance(original_data, np.ndarray):
-+        # For numpy object we compare with data's data. This should be dense so
-+        # we get its data as ndarray.
-+        qobj_data = qobj_data.as_ndarray()
-+
-+        # We look at the memory and see if it is shared or not to asses wether
-+        # copy argument worked or not.
-+        assert np.shares_memory(qobj_data, original_data) != copy
-+
-+    else:
-+        assert (original_data is qobj_data) != copy
-+
-+
-+def test_QobjType():
-+    "qutip.Qobj type"
-+    N = int(np.ceil(10.0 * np.random.random())) + 5
-+
-+    ket_data = np.random.random((N, 1))
-+    ket_qobj = qutip.Qobj(ket_data)
-+    assert ket_qobj.type == 'ket'
-+    assert ket_qobj.isket
-+
-+    bra_data = np.random.random((1, N))
-+    bra_qobj = qutip.Qobj(bra_data)
-+    assert bra_qobj.type == 'bra'
-+    assert bra_qobj.isbra
-+
-+    oper_data = np.random.random((N, N))
-+    oper_qobj = qutip.Qobj(oper_data)
-+    assert oper_qobj.type == 'oper'
-+    assert oper_qobj.isoper
-+
-+    N = 9
-+    super_data = np.random.random((N, N))
-+    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
-+    assert super_qobj.type == 'super'
-+    assert super_qobj.issuper
-+    assert super_qobj.superrep == 'super'
-+
-+    super_data = np.random.random(N)
-+    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
-+    assert super_qobj.type == 'operator-ket'
-+    assert super_qobj.isoperket
-+    assert super_qobj.superrep == 'super'
-+
-+    super_data = np.random.random(N)
-+    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
-+    assert super_qobj.type == 'operator-bra'
-+    assert super_qobj.isoperbra
-+    assert super_qobj.superrep == 'super'
-+
-+    operket_qobj = qutip.operator_to_vector(oper_qobj)
-+    assert operket_qobj.isoperket
-+    assert operket_qobj.dag().isoperbra
-+
-+
-+class TestQobjHermicity:
-+    def test_standard(self):
-+        base = _random_not_singular(10)
-+        assert_hermicity(qutip.Qobj(base), False)
-+        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
-+        assert_hermicity(qutip.destroy(5), False)
-+        assert_hermicity(qutip.create(5), False)
-+
-+    def test_addition(self):
-+        q_a, q_ad = qutip.destroy(5), qutip.create(5)
-+        # test addition of two nonhermitian operators adding up to be hermitian
-+        q_x = q_a + q_ad
-+        assert_hermicity(q_x, True)
-+        # test addition of one hermitan and one nonhermitian operator
-+        assert_hermicity(q_x + q_a, False)
-+        # test addition of two hermitan operators
-+        assert_hermicity(q_x + q_x, True)
-+
-+    def test_multiplication(self):
-+        # Test multiplication of two Hermitian operators.  This results in a
-+        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
-+        # set wrong metadata.
-+        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
-+        # Similarly, we need to check that -Z = X * iY is correctly identified
-+        # as Hermitian.
-+        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
-+
-+
-+def assert_unitarity(oper, unitarity):
-+    # Check the cached isunitary.
-+    assert oper.isunitary == unitarity
-+
-+    # Force a reset of the cached value for isunitary.
-+    oper._isunitary = None
-+    # Force a recalculation of isunitary.
-+    assert oper.isunitary == unitarity
-+
-+
-+def test_QobjUnitaryOper():
-+    "qutip.Qobj unitarity"
-+    # Check some standard operators
-+    Sx = qutip.sigmax()
-+    Sy = qutip.sigmay()
-+    assert_unitarity(qutip.qeye(4), True)
-+    assert_unitarity(Sx, True)
-+    assert_unitarity(Sy, True)
-+    assert_unitarity(qutip.sigmam(), False)
-+    assert_unitarity(qutip.destroy(10), False)
-+    # Check multiplcation of unitary is unitary
-+    assert_unitarity(Sx*Sy, True)
-+    # Check some other operations clear unitarity
-+    assert_unitarity(Sx+Sy, False)
-+    assert_unitarity(4*Sx, False)
-+    assert_unitarity(Sx*4, False)
-+    assert_unitarity(4+Sx, False)
-+    assert_unitarity(Sx+4, False)
-+    # Check that when multipliying scalar numbers with absolute value 1 we
-+    # maintain unitarity.
-+    assert_unitarity(Sx*np.exp(5j), True)
-+    assert_unitarity(Sx*1j, True)
-+    assert_unitarity(Sx*1, True)
-+    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
-+    # We do not know if it is unitary until we check the whole matrix again.
-+    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
-+    # This may be removed in the future as if scalar has abs value of 1 and
-+    # matrix is not unitary, output wont be unitary.
-+    assert (qutip.sigmam()*1)._isunitary == None
-+
-+
-+def test_QobjDimsShape():
-+    "qutip.Qobj shape"
-+    N = 10
-+    data = _random_not_singular(N)
-+
-+    q1 = qutip.Qobj(data)
-+    assert q1.dims == [[10], [10]]
-+    assert q1.shape == (10, 10)
-+
-+    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
-+
-+    q1 = qutip.Qobj(data)
-+    assert q1.dims == [[10], [1]]
-+    assert q1.shape == (10, 1)
-+
-+    data = _random_not_singular(4)
-+
-+    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
-+    assert q1.dims == [[2, 2], [2, 2]]
-+    assert q1.shape == (4, 4)
-+
-+
-+def test_QobjMulNonsquareDims():
-+    """
-+    qutip.Qobj: multiplication w/ non-square qobj.dims
-+
-+    Checks for regression of #331.
-+    """
-+    data = np.array([[0, 1], [1, 0]])
-+
-+    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
-+    q2 = qutip.Qobj(data, dims=[[2], [2]])
-+
-+    assert (q1 * q2).dims == [[2, 1], [2]]
-+    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
-+    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
-+
-+    # Because of the above, we also need to check for extra indices
-+    # that aren't of length 1.
-+    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
-+                     [0.+0.j,  1.+0.j],
-+                     [0.+0.j,  1.+0.j],
-+                     [1.+0.j,  0.+0.j],
-+                     [0.+0.j,  0.-1.j],
-+                     [0.+1.j,  0.+0.j],
-+                     [1.+0.j,  0.+0.j],
-+                     [0.+0.j, -1.+0.j]],
-+                    dims=[[4, 2], [2]])
-+    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
-+
-+
-+def test_QobjAddition():
-+    "qutip.Qobj addition"
-+    data1 = np.array([[1, 2], [3, 4]])
-+    data2 = np.array([[5, 6], [7, 8]])
-+    data3 = data1 + data2
-+
-+    q1 = qutip.Qobj(data1)
-+    q2 = qutip.Qobj(data2)
-+    q3 = qutip.Qobj(data3)
-+
-+    q4 = q1 + q2
-+    q4_type = q4.type
-+    q4_isherm = q4.isherm
-+    q4._type = None
-+    q4._isherm = None  # clear cached values
-+    assert q4_type == q4.type
-+    assert q4_isherm == q4.isherm
-+
-+    # check elementwise addition/subtraction
-+    assert q3 == q4
-+
-+    # check that addition is commutative
-+    assert q1 + q2 == q2 + q1
-+
-+    data = np.random.random((5, 5))
-+    q = qutip.Qobj(data)
-+    x1 = q + 5
-+    x2 = 5 + q
-+    data = data + np.eye(5) * 5
-+    assert np.all(x1.full() == data)
-+    assert np.all(x2.full() == data)
-+
-+
-+def test_QobjSubtraction():
-+    "qutip.Qobj subtraction"
-+    data1 = _random_not_singular(5)
-+    q1 = qutip.Qobj(data1)
-+
-+    data2 = _random_not_singular(5)
-+    q2 = qutip.Qobj(data2)
-+
-+    q3 = q1 - q2
-+    data3 = data1 - data2
-+    assert np.all(q3.full() == data3)
-+
-+    q4 = q2 - q1
-+    data4 = data2 - data1
-+    assert np.all(q4.full() == data4)
-+
-+
-+def test_QobjMultiplication():
-+    "qutip.Qobj multiplication"
-+    data1 = np.array([[1, 2], [3, 4]])
-+    data2 = np.array([[5, 6], [7, 8]])
-+
-+    data3 = np.dot(data1, data2)
-+
-+    q1 = qutip.Qobj(data1)
-+    q2 = qutip.Qobj(data2)
-+    q3 = qutip.Qobj(data3)
-+
-+    q4 = q1 * q2
-+
-+    assert q3 == q4
-+
-+
-+# Allowed mul operations (scalar)
-+@pytest.mark.parametrize("scalar",
-+                         [2+2j,  np.array(2+2j), np.array([2+2j])],
-+                         ids=[
-+                             "python_number",
-+                             "scalar_like_array_shape_0",
-+                             "scalar_like_array_shape_1",
-+                         ])
-+def test_QobjMulValidScalar(scalar):
-+    "Tests multiplication of Qobj times scalar."
-+    data = np.array([[1, 2], [3, 4]])
-+    q = qutip.Qobj(data)
-+    expect = data * (2+2j)
-+
-+    # Check __mul__
-+    result = q * scalar
-+    assert np.all(result.full() == expect)
-+
-+    # Check __rmul__
-+    result = scalar * q
-+    assert np.all(result.full() == expect)
-+
-+
-+# We do not allow yet qobj being multiplied by a numpy array that does not
-+# represent a scalar. If we include the feature of numpy broadcasting an qobj
-+# as scalar, this test should be removed.
-+@pytest.mark.parametrize("not_scalar",
-+                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
-+                         ids=[
-+                             "not_scalar_like_vector",
-+                             "not_scalar_like_matrix",
-+                         ])
-+def test_QobjMulNotValidScalar(not_scalar):
-+    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-+
-+    with pytest.raises(TypeError):
-+        not_scalar * q1
-+
-+    with pytest.raises(TypeError):
-+        q1 * not_scalar
-+
-+
-+# Allowed division operations (scalar)
-+@pytest.mark.parametrize("scalar",
-+                         [2+2j,  np.array(2+2j), np.array([2+2j])],
-+                         ids=[
-+                             "python_number",
-+                             "scalar_like_array_shape_0",
-+                             "scalar_like_array_shape_1",
-+                         ])
-+def test_QobjDivisionValidScalar(scalar):
-+    "Tests multiplication of Qobj times scalar."
-+    data = np.array([[1, 2], [3, 4]])
-+    q = qutip.Qobj(data)
-+    expect = data / (2+2j)
-+
-+    # Check __truediv__
-+    result = q / scalar
-+    assert np.all(result.full() == expect)
-+
-+
-+# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
-+# non scalar numpy values. This should also be removed in case of implementing
-+# broadcasting rules for Qobj.
-+@pytest.mark.parametrize("not_scalar",
-+                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
-+                         ids=[
-+                             "not_scalar_like_vector",
-+                             "not_scalar_like_matrix",
-+                         ])
-+def test_QobjDivisionNotValidScalar(not_scalar):
-+    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-+
-+    with pytest.raises(TypeError):
-+        q1 / not_scalar
-+
-+
-+def test_QobjNotImplemented():
-+    class MockerScalar():
-+        def __mul__(self, other):
-+            return "object not accepted by _data.mul, mul"
-+
-+        def __rmul__(self, other):
-+            return "object not accepted by _data.mul, rmul"
-+
-+        def __rtruediv__(self, other):
-+            return "object not accepted by _data.mul, rtruediv"
-+
-+    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-+    scalar = MockerScalar()
-+    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
-+    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
-+    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
-+
-+def test_QobjDivision():
-+    "qutip.Qobj division"
-+    data = _random_not_singular(5)
-+    q = qutip.Qobj(data)
-+    randN = 10 * np.random.random()
-+    q = q / randN
-+    assert np.allclose(q.full(), data/randN)
-+
-+
-+def test_QobjPower():
-+    "qutip.Qobj power"
-+    data = _random_not_singular(5)
-+    q = qutip.Qobj(data)
-+    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
-+    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
-+
-+
-+def test_QobjNeg():
-+    "qutip.Qobj negation"
-+    data = _random_not_singular(5)
-+    q = qutip.Qobj(data)
-+    x = -q
-+    assert np.all(x.full() == -data)
-+    assert q.isherm == x.isherm
-+    assert q.type == x.type
-+
-+
-+def test_QobjEquals():
-+    "qutip.Qobj equals"
-+    data = _random_not_singular(5)
-+    q1 = qutip.Qobj(data)
-+    q2 = qutip.Qobj(data)
-+    assert q1 == q2
-+
-+    q1 = qutip.Qobj(data)
-+    q2 = qutip.Qobj(-data)
-+    assert q1 != q2
-+
-+
-+def test_QobjGetItem():
-+    "qutip.Qobj getitem"
-+    data = _random_not_singular(5)
-+    q = qutip.Qobj(data)
-+    assert q[0, 0] == data[0, 0]
-+    assert q[-1, 2] == data[-1, 2]
-+
-+
-+def test_CheckMulType():
-+    "qutip.Qobj multiplication type"
-+    # ket-bra and bra-ket multiplication
-+    psi = qutip.basis(5, 0)
-+    dm = psi * psi.dag()
-+    assert dm.isoper
-+    assert dm.isherm
-+
-+    nrm = psi.dag() * psi
-+    assert isinstance(nrm, numbers.Complex)
-+    assert abs(nrm) == 1
-+
-+    # operator-operator multiplication
-+    H1 = qutip.rand_herm(3)
-+    H2 = qutip.rand_herm(3)
-+    out = H1 * H2
-+    assert out.isoper
-+    out = H1 * H1
-+    assert out.isoper
-+    assert out.isherm
-+    out = H2 * H2
-+    assert out.isoper
-+    assert out.isherm
-+
-+    U = qutip.rand_unitary(5)
-+    out = U.dag() * U
-+    assert out.isoper
-+    assert out.isherm
-+
-+    N = qutip.num(5)
-+
-+    out = N * N
-+    assert out.isoper
-+    assert out.isherm
-+
-+    # operator-ket and bra-operator multiplication
-+    op = qutip.sigmax()
-+    ket1 = qutip.basis(2, 0)
-+    ket2 = op * ket1
-+    assert ket2.isket
-+
-+    bra1 = qutip.basis(2, 0).dag()
-+    bra2 = bra1 * op
-+    assert bra2.isbra
-+
-+    assert bra2.dag() == ket2
-+
-+    # superoperator-operket and operbra-superoperator multiplication
-+    sop = qutip.to_super(qutip.sigmax())
-+    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
-+    opket2 = sop * opket1
-+    assert opket2.isoperket
-+
-+    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
-+    opbra2 = opbra1 * sop
-+    assert opbra2.isoperbra
-+
-+    assert opbra2.dag() == opket2
-+
-+
-+def test_operator_ket_superrep():
-+    sop = qutip.to_super(qutip.sigmax())
-+    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
-+    opket2 = sop * opket1
-+    assert opket1.superrep == opket2.superrep
-+
-+    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
-+    opbra2 = opbra1 * sop
-+    assert opbra1.superrep == opbra2.superrep
-+
-+
-+def test_QobjConjugate():
-+    "qutip.Qobj conjugate"
-+    data = _random_not_singular(5)
-+    A = qutip.Qobj(data)
-+    B = A.conj()
-+    assert np.all(B.full() == data.conj())
-+    assert A.isherm == B.isherm
-+    assert A.type == B.type
-+    assert A.superrep == B.superrep
-+
-+
-+def test_QobjDagger():
-+    "qutip.Qobj adjoint (dagger)"
-+    data = _random_not_singular(5)
-+    A = qutip.Qobj(data)
-+    B = A.dag()
-+    assert np.all(B.full() == data.conj().T)
-+    assert A.isherm == B.isherm
-+    assert A.type == B.type
-+    assert A.superrep == B.superrep
-+
-+
-+def test_QobjDiagonals():
-+    "qutip.Qobj diagonals"
-+    data = _random_not_singular(5)
-+    A = qutip.Qobj(data)
-+    b = A.diag()
-+    assert np.all(b == np.diag(data))
-+
-+
-+def test_QobjEigenEnergies():
-+    "qutip.Qobj eigenenergies"
-+    data = np.eye(5)
-+    A = qutip.Qobj(data)
-+    b = A.eigenenergies()
-+    assert np.all(b == np.ones(5))
-+
-+    data = np.diag(np.arange(10))
-+    A = qutip.Qobj(data)
-+    b = A.eigenenergies()
-+    assert np.all(b == np.arange(10))
-+
-+    data = np.diag(np.arange(10))
-+    A = 5 * qutip.Qobj(data)
-+    b = A.eigenenergies()
-+    assert np.all(b == 5*np.arange(10))
-+
-+
-+def test_QobjEigenStates():
-+    "qutip.Qobj eigenstates"
-+    data = np.eye(5)
-+    A = qutip.Qobj(data)
-+    b, c = A.eigenstates()
-+    assert np.all(b == np.ones(5))
-+    kets = [qutip.basis(5, k) for k in range(5)]
-+    for k in range(5):
-+        assert c[k] == kets[k]
-+
-+
-+def test_QobjExpm():
-+    "qutip.Qobj expm (dense)"
-+    data = _random_not_singular(15)
-+    A = qutip.Qobj(data)
-+    B = A.expm()
-+    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
-+
-+
-+def test_QobjExpmExplicitlySparse():
-+    "qutip.Qobj expm (sparse)"
-+    data = _random_not_singular(15)
-+    A = qutip.Qobj(data)
-+    B = A.expm(dtype=qutip.data.CSR)
-+    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
-+
-+
-+def test_QobjExpmZeroOper():
-+    "qutip.Qobj expm zero_oper (#493)"
-+    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
-+    B = A.expm()
-+    assert B == qutip.qeye(5)
-+
-+
-+def test_QobjLogm():
-+    "qutip.Qobj expm (dense)"
-+    data = _random_not_singular(15)
-+    A = qutip.Qobj(data)
-+    B = A.logm()
-+    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
-+
-+
-+def test_QobjLogmExplicitlySparse():
-+    "qutip.Qobj logm (sparse)"
-+    data = _random_not_singular(15)
-+    A = qutip.Qobj(data).to("csr")
-+    B = A.logm()
-+    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
-+
-+
-+def test_QobjLogmZeroOper():
-+    "qutip.Qobj logm zero_oper (#493)"
-+    A = qutip.qeye(5)
-+    B = A.logm()
-+    assert B == qutip.qzero(5)
-+
-+
-+def test_Qobj_sqrtm():
-+    "qutip.Qobj sqrtm"
-+    data = _random_not_singular(5)
-+    A = qutip.Qobj(data)
-+    B = A.sqrtm()
-+    assert A == B * B
-+
-+
-+def test_Qobj_inv():
-+    "qutip.Qobj inv"
-+    data = _random_not_singular(5)
-+    A = qutip.Qobj(data)
-+    B = A.inv()
-+    assert qutip.qeye(5) == A * B
-+    assert qutip.qeye(5) == B * A
-+    B = A.inv(sparse=True)
-+    assert qutip.qeye(5) == A * B
-+    assert qutip.qeye(5) == B * A
-+
-+
-+def test_QobjFull():
-+    "qutip.Qobj full"
-+    data = _random_not_singular(15)
-+    A = qutip.Qobj(data)
-+    b = A.full()
-+    assert np.all(b == data)
-+
-+
-+def test_QobjNorm():
-+    "qutip.Qobj norm"
-+    # vector L2-norm test
-+    N = 20
-+    x = np.random.random(N) + 1j*np.random.random(N)
-+    A = qutip.Qobj(x)
-+    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
-+    # vector max (inf) norm test
-+    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
-+                               atol=1e-12)
-+    # operator frobius norm
-+    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
-+    A = qutip.Qobj(x)
-+    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
-+                               atol=1e-12)
-+    # operator trace norm
-+    a = qutip.rand_herm(10, density=0.25)
-+    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
-+    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
-+    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
-+
-+
-+def test_QobjPurity():
-+    "Tests the purity method of `qutip.Qobj`"
-+    psi = qutip.basis(2, 1)
-+    # check purity of pure ket state
-+    np.testing.assert_allclose(psi.purity(), 1)
-+    # check purity of pure ket state (superposition)
-+    psi2 = qutip.basis(2, 0)
-+    psi_tot = (psi+psi2).unit()
-+    np.testing.assert_allclose(psi_tot.purity(), 1)
-+    # check purity of density matrix of pure state
-+    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
-+    # check purity of maximally mixed density matrix
-+    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
-+    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
-+
-+
-+def test_QobjPermute(datatype):
-+    "qutip.Qobj permute"
-+    A = qutip.basis(3, 0, dtype=datatype)
-+    B = qutip.basis(5, 4, dtype=datatype)
-+    C = qutip.basis(4, 2, dtype=datatype)
-+    psi = qutip.tensor(A, B, C)
-+    psi2 = psi.permute([2, 0, 1])
-+    assert psi2 == qutip.tensor(C, A, B)
-+
-+    psi_bra = psi.dag()
-+    psi2_bra = psi_bra.permute([2, 0, 1])
-+    assert psi2_bra == qutip.tensor(C, A, B).dag()
-+
-+    A = qutip.fock_dm(3, 0, dtype=datatype)
-+    B = qutip.fock_dm(5, 4, dtype=datatype)
-+    C = qutip.fock_dm(4, 2, dtype=datatype)
-+    rho = qutip.tensor(A, B, C)
-+    rho2 = rho.permute([2, 0, 1])
-+    assert rho2 == qutip.tensor(C, A, B)
-+
-+    for _ in range(3):
-+        A = qutip.rand_ket(3, dtype=datatype)
-+        B = qutip.rand_ket(4, dtype=datatype)
-+        C = qutip.rand_ket(5, dtype=datatype)
-+        psi = qutip.tensor(A, B, C)
-+        psi2 = psi.permute([1, 0, 2])
-+        assert psi2 == qutip.tensor(B, A, C)
-+
-+        psi_bra = psi.dag()
-+        psi2_bra = psi_bra.permute([1, 0, 2])
-+        assert psi2_bra == qutip.tensor(B, A, C).dag()
-+
-+    for _ in range(3):
-+        A = qutip.rand_dm(3, dtype=datatype)
-+        B = qutip.rand_dm(4, dtype=datatype)
-+        C = qutip.rand_dm(5, dtype=datatype)
-+        rho = qutip.tensor(A, B, C)
-+        rho2 = rho.permute([1, 0, 2])
-+        assert rho2 == qutip.tensor(B, A, C)
-+
-+        rho_vec = qutip.operator_to_vector(rho)
-+        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
-+        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
-+
-+        rho_vec_bra = qutip.operator_to_vector(rho).dag()
-+        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
-+        assert (rho2_vec_bra
-+                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
-+
-+    for _ in range(3):
-+        super_dims = [3, 5, 4]
-+        U = qutip.rand_unitary(super_dims, dtype=datatype)
-+        Unew = U.permute([2, 1, 0])
-+        S_tens = qutip.to_super(U)
-+        S_tens_new = qutip.to_super(Unew)
-+        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
-+
-+
-+def test_KetType():
-+    "qutip.Qobj ket type"
-+
-+    psi = qutip.basis(2, 1)
-+
-+    assert psi.isket
-+    assert not psi.isbra
-+    assert not psi.isoper
-+    assert not psi.issuper
-+
-+    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
-+
-+    assert psi.isket
-+    assert not psi.isbra
-+    assert not psi.isoper
-+    assert not psi.issuper
-+
-+
-+def test_BraType():
-+    "qutip.Qobj bra type"
-+
-+    psi = qutip.basis(2, 1).dag()
-+    assert not psi.isket
-+    assert psi.isbra
-+    assert not psi.isoper
-+    assert not psi.issuper
-+
-+    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
-+    assert not psi.isket
-+    assert psi.isbra
-+    assert not psi.isoper
-+    assert not psi.issuper
-+
-+
-+def test_OperType():
-+    "qutip.Qobj operator type"
-+
-+    psi = qutip.basis(2, 1)
-+    rho = psi * psi.dag()
-+
-+    assert not rho.isket
-+    assert not rho.isbra
-+    assert rho.isoper
-+    assert not rho.issuper
-+
-+
-+def test_SuperType():
-+    "qutip.Qobj superoperator type"
-+
-+    psi = qutip.basis(2, 1)
-+    rho = psi * psi.dag()
-+
-+    sop = qutip.spre(rho)
-+
-+    assert not sop.isket
-+    assert not sop.isbra
-+    assert not sop.isoper
-+    assert sop.issuper
-+
-+    sop = qutip.spost(rho)
-+
-+    assert not sop.isket
-+    assert not sop.isbra
-+    assert not sop.isoper
-+    assert sop.issuper
-+
-+
-+@pytest.mark.parametrize("dimension", [2, 4, 8])
-+@pytest.mark.parametrize("conversion", [
-+    pytest.param(qutip.to_super, id='to_super'),
-+    pytest.param(qutip.to_choi, id='to_choi'),
-+    pytest.param(qutip.to_chi, id='to_chi'),
-+])
-+def test_dag_preserves_superrep(dimension, conversion):
-+    """
-+    Checks that dag() preserves superrep.
-+    """
-+    qobj = conversion(qutip.rand_super_bcsz(dimension))
-+    assert qobj.superrep == qobj.dag().superrep
-+
-+
-+@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
-+@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
-+    pytest.param(operator.add, True, True, id='add'),
-+    pytest.param(operator.sub, True, True, id='sub'),
-+    pytest.param(operator.mul, True, True, id='mul'),
-+    pytest.param(operator.truediv, False, True, id='div'),
-+    pytest.param(qutip.tensor, True, False, id='tensor'),
-+])
-+def test_arithmetic_preserves_superrep(superrep,
-+                                       operation, check_op, check_scalar):
-+    """
-+    Checks that binary ops preserve 'superrep'.
-+
-+    .. note::
-+
-+        The random superoperators are not chosen in a way that reflects the
-+        structure of that superrep, but are simply random matrices.
-+    """
-+    dims = [[[2], [2]], [[2], [2]]]
-+    shape = (4, 4)
-+    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
-+    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
-+    x = np.random.random()
-+
-+    check_list = []
-+    if check_op:
-+        check_list.append(operation(S1, S2))
-+    if check_scalar:
-+        check_list.append(operation(S1, x))
-+    if check_op and check_scalar:
-+        check_list.append(operation(x, S2))
-+
-+    for S in check_list:
-+        assert S.issuper
-+        assert S.type == "super"
-+        assert S.superrep == superrep
-+
-+
-+def test_isherm_skew():
-+    """
-+    mul and tensor of skew-Hermitian operators report ``isherm = True``.
-+    """
-+    iH = 1j * qutip.rand_herm(5)
-+    assert_hermicity(iH, False)
-+    assert_hermicity(iH * iH, True)
-+    assert_hermicity(qutip.tensor(iH, iH), True)
-+
-+
-+def test_super_tensor_operket():
-+    """
-+    Tensor: Checks that super_tensor respects states.
-+    """
-+    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
-+    qutip.operator_to_vector(rho1)
-+    qutip.operator_to_vector(rho2)
-+
-+
-+def test_super_tensor_property():
-+    """
-+    Tensor: Super_tensor correctly tensors on underlying spaces.
-+    """
-+    U1 = qutip.rand_unitary(3)
-+    U2 = qutip.rand_unitary(5)
-+    U = qutip.tensor(U1, U2)
-+    S_tens = qutip.to_super(U)
-+    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
-+    assert S_tens == S_supertens
-+    assert S_supertens.superrep == 'super'
-+
-+
-+def test_composite_oper():
-+    """
-+    Composite: Tests compositing unitaries and superoperators.
-+    """
-+    U1 = qutip.rand_unitary(3)
-+    U2 = qutip.rand_unitary(5)
-+    S1 = qutip.to_super(U1)
-+    S2 = qutip.to_super(U2)
-+    S3 = qutip.rand_super(4)
-+    S4 = qutip.rand_super(7)
-+
-+    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
-+    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
-+    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
-+    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
-+
-+
-+def test_composite_vec():
-+    """
-+    Composite: Tests compositing states and density operators.
-+    """
-+    k1 = qutip.rand_ket(5)
-+    k2 = qutip.rand_ket(7)
-+    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
-+    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
-+
-+    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
-+    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
-+
-+    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
-+    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
-+    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
-+    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
-+
-+# TODO: move out to a more appropriate module.
-+
-+
-+def trunc_neg_case(qobj, method, expected=None):
-+    pos_qobj = qobj.trunc_neg(method=method)
-+    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
-+    np.testing.assert_allclose(pos_qobj.tr(), 1)
-+    if expected is not None:
-+        test_array = pos_qobj.full()
-+        exp_array = expected.full()
-+        np.testing.assert_allclose(test_array, exp_array)
-+
-+
-+class TestTruncNeg:
-+    """Test qutip.Qobj.trunc_neg for several different cases."""
-+    def test_positive_operator(self):
-+        trunc_neg_case(qutip.rand_dm(5), 'clip')
-+        trunc_neg_case(qutip.rand_dm(5), 'sgs')
-+
-+    def test_diagonal_operator(self):
-+        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
-+        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
-+        trunc_neg_case(to_test, 'clip', expected)
-+        trunc_neg_case(to_test, 'sgs', expected)
-+
-+    def test_nondiagonal_operator(self):
-+        U = qutip.rand_unitary(3)
-+        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
-+        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
-+        trunc_neg_case(to_test, 'clip', expected)
-+        trunc_neg_case(to_test, 'sgs', expected)
-+
-+    def test_sgs_known_good(self):
-+        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
-+                       'sgs',
-+                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
-+
-+
-+def test_cosm():
-+    """
-+    Test qutip.Qobj: cosm
-+    """
-+    A = qutip.rand_herm(5)
-+    B = A.cosm().full()
-+    C = scipy.linalg.cosm(A.full())
-+    np.testing.assert_allclose(B, C, atol=1e-14)
-+
-+
-+def test_sinm():
-+    """
-+    Test qutip.Qobj: sinm
-+    """
-+    A = qutip.rand_herm(5)
-+    B = A.sinm().full()
-+    C = scipy.linalg.sinm(A.full())
-+    np.testing.assert_allclose(B, C, atol=1e-14)
-+
-+
-+@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
-+def test_dual_channel(sub_dimensions, n_trials=50):
-+    """
-+    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
-+    """
-+    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
-+    S.dims = [[sub_dimensions, sub_dimensions],
-+              [sub_dimensions, sub_dimensions]]
-+    S = qutip.to_super(S)
-+    left_dims, right_dims = S.dims
-+
-+    # Assume for the purposes of the test that S maps square operators to
-+    # square operators.
-+    in_dim = np.prod(right_dims[0])
-+    out_dim = np.prod(left_dims[0])
-+
-+    S_dual = qutip.to_super(S.dual_chan())
-+
-+    primals = []
-+    duals = []
-+
-+    for _ in [None]*n_trials:
-+        X = qutip.rand_dm(out_dim)
-+        X.dims = left_dims
-+        X = qutip.operator_to_vector(X)
-+        Y = qutip.rand_dm(in_dim)
-+        Y.dims = right_dims
-+        Y = qutip.operator_to_vector(Y)
-+
-+        primals.append(X.dag() * S * Y)
-+        duals.append(X.dag() * S_dual.dag() * Y)
-+
-+    np.testing.assert_allclose(primals, duals)
-+
-+
-+def test_call():
-+    """
-+    Test qutip.Qobj: Call
-+    """
-+    # Make test objects.
-+    psi = qutip.rand_ket(3)
-+    rho = qutip.rand_dm(3)
-+    U = qutip.rand_unitary(3)
-+    S = qutip.rand_super_bcsz(3)
-+
-+    # Case 0: oper(ket).
-+    assert U(psi) == U * psi
-+    # Case 1: oper(oper). Should raise TypeError.
-+    with pytest.raises(TypeError):
-+        U(rho)
-+    # Case 2: super(ket).
-+    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
-+    assert S(psi) == expected
-+    # Case 3: super(oper).
-+    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
-+    assert S(rho) == expected
-+    # Case 4: super(super). Should raise TypeError.
-+    with pytest.raises(TypeError):
-+        S(S)
-+
-+
-+def test_mat_elem():
-+    """
-+    Test qutip.Qobj: Compute matrix elements
-+    """
-+    for _ in range(10):
-+        N = 20
-+        H = qutip.rand_herm(N, density=0.2)
-+        L = qutip.rand_ket(N, density=0.3)
-+        Ld = L.dag()
-+        R = qutip.rand_ket(N, density=0.3)
-+        ans = Ld * H * R
-+        # bra-ket
-+        out1 = H.matrix_element(Ld, R)
-+        # ket-ket
-+        out2 = H.matrix_element(Ld, R)
-+        assert abs(ans - out1) < 1e-14
-+        assert abs(ans - out2) < 1e-14
-+
-+
-+def test_projection():
-+    """
-+    Test qutip.Qobj: Projection operator
-+    """
-+    for _ in range(10):
-+        N = 5
-+        K = qutip.rand_ket([N, N], density=0.75)
-+        B = K.dag()
-+        ans = K * K.dag()
-+        out1 = K.proj()
-+        out2 = B.proj()
-+        assert out1 == ans
-+        assert out2 == ans
-+
-+
-+def test_overlap():
-+    """
-+    Test qutip.Qobj: Overlap (inner product)
-+    """
-+    for _ in range(10):
-+        N = 10
-+        A = qutip.rand_ket(N, density=0.75)
-+        Ad = A.dag()
-+        B = qutip.rand_ket(N, density=0.75)
-+        Bd = B.dag()
-+        ans = A.dag() * B
-+        np.testing.assert_allclose(A.overlap(B), ans)
-+        np.testing.assert_allclose(Ad.overlap(B), ans)
-+        np.testing.assert_allclose(Ad.overlap(Bd), ans)
-+        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
-+
-+
-+def test_unit():
-+    """
-+    Test qutip.Qobj: unit
-+    """
-+    psi = (10*np.random.randn()*qutip.basis(2, 0)
-+           - 10j*np.random.randn()*qutip.basis(2, 1))
-+    psi2 = psi.unit()
-+    psi.unit(inplace=True)
-+    assert psi == psi2
-+    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
-+
-+
-+def test_trace():
-+    sz = qutip.sigmaz()
-+    assert sz.tr() == 0
-+
-+
-+def test_no_real_attribute(monkeypatch):
-+    """This tests ensures that trace still works even if the output of a
-+    specialisation does not have the ``real`` attribute. This is the case for
-+    the tensorflow and cupy data layers."""
-+
-+    def mocker_trace_return(oper):
-+        """
-+        We simply return a string which does not have the `real` attribute.
-+        """
-+        return "object without .real"
-+
-+    monkeypatch.setattr(_data, "trace", mocker_trace_return)
-+
-+    sz = qutip.sigmaz() # the choice of the matrix does not matter
-+    assert "object without .real" == sz.tr()
-+
-+
-+@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
-+@pytest.mark.parametrize(['expanded', 'contracted'], [
-+    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
-+    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
-+    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
-+    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
-+    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
-+                 id='mixed'),
-+    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
-+                 id='mixed,unchanged'),
-+    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
-+                 id='mixed,unchanged'),
-+    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
-+    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
-+    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
-+                 id='ket,unchanged'),
-+    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
-+    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
-+    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
-+                 id='bra,unchanged'),
-+    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
-+                 id='operket'),
-+    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
-+                 id='operbra'),
-+])
-+def test_contract(expanded, contracted, inplace):
-+    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
-+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-+    qobj = qutip.Qobj(data, dims=expanded)
-+    assert qobj.dims == expanded
-+    out = qobj.contract(inplace=inplace)
-+    if inplace:
-+        assert out is qobj
-+    else:
-+        assert out is not qobj
-+    assert out.dims == contracted
-+    assert out.shape == qobj.shape
-+    assert np.all(out.full() == qobj.full())
-+
-+
-+@pytest.mark.parametrize(["shape"], [
-+    pytest.param((5, 1), id='ket'),
-+    pytest.param((5, 2), id='tall'),
-+    pytest.param((1, 5), id='bra'),
-+    pytest.param((2, 5), id='wide'),
-+    pytest.param((3, 3), id='oper'),
-+])
-+def test_sum_zero(shape):
-+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-+    qobj = qutip.Qobj(data)
-+    assert qobj + 0 == qobj
-+    assert qobj - 0 == qobj
-+    assert 0 + qobj == qobj
-+    assert 0 - qobj == -qobj
-+
-+
-+@pytest.mark.parametrize(["shape"], [
-+    pytest.param((5, 1), id='ket'),
-+    pytest.param((5, 2), id='tall'),
-+    pytest.param((1, 5), id='bra'),
-+    pytest.param((2, 5), id='wide'),
-+    pytest.param((3, 3), id='oper'),
-+])
-+def test_sum_buildin(shape):
-+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-+    qobj = qutip.Qobj(data)
-+    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
-+
-+
-+def test_groundstate():
-+    eigenvals = np.sort(np.random.rand(10))
-+    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
-+    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
-+    groundenergy, groundstate = qobj.groundstate()
-+    assert groundenergy == pytest.approx(eigenvals[0])
-+    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
-+    assert groundstate.overlap(groundstate) == pytest.approx(1)
-+
-+    with pytest.warns(UserWarning) as warning:
-+        qutip.qeye(5).groundstate()
-+    assert "degenerate" in warning[0].message.args[0]
-diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
-index 77fe8fba..dbcb3979 100644
---- a/qutip/tests/core/test_qobjevo.py
-+++ b/qutip/tests/core/test_qobjevo.py
-@@ -1,515 +1,515 @@
--import operator
--
--import pytest
--from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
--                   rand_stochastic, rand_herm, rand_ket, liouvillian,
--                   basis, spre, spost, to_choi)
--import numpy as np
--from numpy.testing import assert_allclose
--
--from qutip.core import data as _data
--
--# prepare coefficient
--class Pseudo_qevo:
--    # Mimic QobjEvo on __call__
--    # and can return parameter to create the equivalent QobjEvo
--    # for each coefficient type
--    def __init__(self, cte, qobj, func, string, args):
--        self.cte = cte
--        self.qobj = qobj
--        self.func = func
--        self.str = string
--        self.args = args
--
--    def array(self):
--        tlist = np.linspace(0, 10, 10001)
--        coeff = self.func(tlist, self.args)
--        return ([self.cte, [self.qobj, coeff]], {}, tlist)
--
--    def logarray(self):
--        tlist = np.logspace(-3, 1, 10001)
--        coeff = self.func(tlist, self.args)
--        return ([self.cte, [self.qobj, coeff]], {}, tlist)
--
--    def func_coeff(self):
--        return ([self.cte, [self.qobj, self.func]], self.args)
--
--    def string(self):
--        return ([self.cte, [self.qobj, self.str]], self.args)
--
--    def func_call(self):
--        return (self.__call__, self.args)
--
--    def __call__(self, t, args={}):
--        args = args or self.args
--        return self.cte + self.qobj * self.func(t, args)
--
--    def __getitem__(self, which):
--        return getattr(self, which)()
--
--
--N = 3
--args = {'w1': 1, "w2": 2}
--TESTTIMES = np.linspace(0.001, 1.0, 10)
--
--
--def _real(t, args):
--    return np.sin(t*args['w1'])
--
--
--def _cplx(t, args):
--    return np.exp(1j*t*args['w2'])
--
--
--real_qevo = Pseudo_qevo(
--    rand_stochastic(N).to(_data.CSR),
--    rand_stochastic(N).to(_data.CSR),
--    _real, "sin(t*w1)", args)
--
--herm_qevo = Pseudo_qevo(
--    rand_herm(N).to(_data.Dense),
--    rand_herm(N).to(_data.Dense),
--    _real, "sin(t*w1)", args)
--
--cplx_qevo = Pseudo_qevo(
--    rand_stochastic(N).to(_data.Dense),
--    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
--    _cplx, "exp(1j*t*w2)", args)
--
--
--@pytest.fixture(params=['func_coeff', 'string',
--                        'array', 'logarray', 'func_call'])
--def coeff_type(request):
--    # all available QobjEvo types
--    return request.param
--
--
--@pytest.fixture(params=[
--    pytest.param(real_qevo, id="real"),
--    pytest.param(herm_qevo, id="hermitian"),
--    pytest.param(cplx_qevo, id="complex"),
--])
--def pseudo_qevo(request):
--    return request.param
--
--
--@pytest.fixture
--def all_qevo(pseudo_qevo, coeff_type):
--    return QobjEvo(*pseudo_qevo[coeff_type])
--
--
--@pytest.fixture
--def other_qevo(all_qevo):
--    return all_qevo
--
--
--def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
--    for t in TESTTIMES:
--        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
--
--
--def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
--    assert obj1.dims == obj2.dims
--    assert obj1.shape == obj2.shape
--    assert obj1.type == obj2.type
--    assert _data.iszero((obj1 - obj2).data, tol)
--
--
--def _assert_qobjevo_different(obj1, obj2):
--    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
--
--
--def _div(a, b):
--    return a / b
--
--
--def test_call(pseudo_qevo, coeff_type):
--    # test creation of QobjEvo and call
--    qevo = QobjEvo(*pseudo_qevo[coeff_type])
--    assert isinstance(qevo(0), Qobj)
--    assert qevo.isoper
--    assert not qevo.isconstant
--    assert not qevo.issuper
--    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
--
--
--# Test the QobjEvo.__repr__()
--def test_QobjEvo_repr():
--    # case_n: cases with Objects of QobjEvo with unique __repr__
--    # expected_repr_n: are the Expected result from the __repr__
--
--    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
--    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
--    expected_repr_1 += 'type = oper, superrep = None, '
--    expected_repr_1 += 'isconstant = False, num_elements = 1'
--    assert case_1 == expected_repr_1
--
--    case_2 = repr(QobjEvo(qeye(2)))
--    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
--    expected_repr_2 += 'type = oper, superrep = None, '
--    expected_repr_2 += 'isconstant = True, num_elements = 1'
--    assert case_2 == expected_repr_2
--
--    case_3 = repr(QobjEvo(basis(5, 2)))
--    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
--    expected_repr_3 += 'type = ket, superrep = None, '
--    expected_repr_3 += 'isconstant = True, num_elements = 1'
--    assert case_3 == expected_repr_3
--
--    X = sigmax()
--    S = spre(X) * spost(X.dag())
--    case_4 = repr(QobjEvo(to_choi(S)))
--    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
--    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
--    expected_repr_4 += 'isconstant = True, num_elements = 1'
--    assert case_4 == expected_repr_4
--
--    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
--                           [qeye(4), lambda t: t]], compress=False))
--    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
--    expected_repr_5 += 'type = oper, superrep = None, '
--    expected_repr_5 += 'isconstant = False, num_elements = 2'
--    assert case_5 == expected_repr_5
--
--
--@pytest.mark.parametrize('coeff_type',
--                         ['func_coeff', 'string', 'array', 'logarray'])
--def test_product_coeff(pseudo_qevo, coeff_type):
--    # test creation of QobjEvo with Qobj * Coefficient
--    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
--    base = pseudo_qevo[coeff_type]
--    cte, [qobj, coeff] = base[0]
--    args = base[1] if len(base) >= 2 else {}
--    tlist = base[2] if len(base) >= 3 else None
--    coeff = coefficient(coeff, args=args, tlist=tlist)
--    created = cte + qobj * coeff
--    _assert_qobjevo_equivalent(pseudo_qevo, created)
--
--def test_copy(all_qevo):
--    qevo = all_qevo
--    copy = qevo.copy()
--    _assert_qobjevo_equivalent(copy, qevo)
--    assert copy is not qevo
--
--
--@pytest.mark.parametrize('bin_op', [
--    pytest.param(lambda a, b: a + b, id="add"),
--    pytest.param(lambda a, b: a - b, id="sub"),
--    pytest.param(lambda a, b: a * b, id="mul"),
--    pytest.param(lambda a, b: a @ b, id="matmul"),
--    pytest.param(lambda a, b: a & b, id="tensor"),
--])
--def test_binopt(all_qevo, other_qevo, bin_op):
--    "QobjEvo arithmetic"
--    obj1 = all_qevo
--    obj2 = other_qevo
--    for t in TESTTIMES:
--        as_qevo = bin_op(obj1, obj2)(t)
--        as_qobj = bin_op(obj1(t), obj2(t))
--        _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--
--@pytest.mark.parametrize('bin_op', [
--    pytest.param(operator.iadd, id="add"),
--    pytest.param(operator.isub, id="sub"),
--    pytest.param(operator.imul, id="mul"),
--    pytest.param(operator.imatmul, id="matmul"),
--    pytest.param(operator.iand, id="tensor"),
--])
--def test_binopt_inplace(all_qevo, other_qevo, bin_op):
--    obj1 = all_qevo
--    obj2 = other_qevo
--    for t in TESTTIMES:
--        as_qevo = bin_op(obj1.copy(), obj2)(t)
--        as_qobj = bin_op(obj1(t).copy(), obj2(t))
--        _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--
--@pytest.mark.parametrize('bin_op', [
--    pytest.param(lambda a, b: a + b, id="add"),
--    pytest.param(lambda a, b: a - b, id="sub"),
--    pytest.param(lambda a, b: a * b, id="mul"),
--    pytest.param(lambda a, b: a @ b, id="matmul"),
--    pytest.param(lambda a, b: a & b, id="tensor"),
--])
--def test_binopt_qobj(all_qevo, bin_op):
--    "QobjEvo arithmetic"
--    obj = all_qevo
--    qobj = rand_herm(N)
--    for t in TESTTIMES:
--        as_qevo = bin_op(obj, qobj)(t)
--        as_qobj = bin_op(obj(t), qobj)
--        _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--        as_qevo = bin_op(qobj, obj)(t)
--        as_qobj = bin_op(qobj, obj(t))
--        _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--
--@pytest.mark.parametrize('bin_op', [
--    pytest.param(lambda a, b: a + b, id="add"),
--    pytest.param(lambda a, b: a - b, id="sub"),
--    pytest.param(lambda a, b: a * b, id="mul"),
--    pytest.param(_div, id="div"),
--])
--def test_binopt_scalar(all_qevo, bin_op):
--    "QobjEvo arithmetic"
--    obj = all_qevo
--    scalar = 0.5 + 1j
--    for t in TESTTIMES:
--        as_qevo = bin_op(obj, scalar)(t)
--        as_qobj = bin_op(obj(t), scalar)
--        _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--        if bin_op is not _div:
--            as_qevo = bin_op(scalar, obj)(t)
--            as_qobj = bin_op(scalar, obj(t))
--            _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--
--def binop_coeff(all_qevo):
--    obj = all_qevo
--    coeff = coeffient("t")
--    created = obj * coeff_t
--    for t in TESTTIMES:
--        _assert_qobj_almost_eq(created(t), obj(t) * t)
--
--
--@pytest.mark.parametrize('unary_op', [
--    pytest.param(lambda a: a.conj(), id="conj"),
--    pytest.param(lambda a: a.dag(), id="dag"),
--    pytest.param(lambda a: a.trans(), id="trans"),
--    pytest.param(lambda a: -a, id="neg"),
--])
--def test_unary(all_qevo, unary_op):
--    "QobjEvo arithmetic"
--    obj = all_qevo
--    for t in TESTTIMES:
--        as_qevo = unary_op(obj)(t)
--        as_qobj = unary_op(obj(t))
--        _assert_qobj_almost_eq(as_qevo, as_qobj)
--
--
--@pytest.mark.parametrize('args_coeff_type',
--                         ['func_coeff', 'string', 'func_call'])
--def test_args(pseudo_qevo, args_coeff_type):
--    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
--    args = {'w1': 3, "w2": 3}
--
--    for t in TESTTIMES:
--        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
--        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
--
--    # Did it modify original args
--    _assert_qobjevo_equivalent(obj, pseudo_qevo)
--
--    obj.arguments(args)
--    _assert_qobjevo_different(obj, pseudo_qevo)
--    for t in TESTTIMES:
--        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
--
--    args = {'w1': 4, "w2": 4}
--    obj.arguments(**args)
--    _assert_qobjevo_different(obj, pseudo_qevo)
--    for t in TESTTIMES:
--        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
--
--
--def test_copy_side_effects(all_qevo):
--    t = 0.2
--    qevo = all_qevo
--    copy = qevo.copy()
--    before = qevo(t)
--    # Ensure inplace modification of the copy do not affect the original
--    copy *= 2
--    copy += rand_herm(N)
--    copy *= rand_herm(N)
--    copy.arguments({'w1': 3, "w2": 3})
--    after = qevo(t)
--    _assert_qobj_almost_eq(before, after)
--
--
--@pytest.mark.parametrize('coeff_type',
--    ['func_coeff', 'string', 'array', 'logarray']
--)
--def test_tidyup(all_qevo):
--    "QobjEvo tidyup"
--    obj = all_qevo
--    obj *= 1e-12
--    obj.tidyup(atol=1e-8)
--    t = 0.2
--    # check that the Qobj are cleaned
--    assert_allclose(obj(t).full(), 0)
--
--
--def test_QobjEvo_pickle(all_qevo):
--    "QobjEvo pickle"
--    # used in parallel_map
--    import pickle
--    obj = all_qevo
--    pickled = pickle.dumps(obj, -1)
--    recreated = pickle.loads(pickled)
--    _assert_qobjevo_equivalent(recreated, obj)
--
--
--def test_QobjEvo_restore(all_qevo):
--    "QobjEvo pickle"
--    # used in parallel_map
--    obj = all_qevo
--    state = obj._getstate()
--    recreated = QobjEvo._restore(**state)
--    _assert_qobjevo_equivalent(recreated, obj)
--
--
--def test_mul_vec(all_qevo):
--    "QobjEvo matmul ket"
--    vec = Qobj(np.arange(N)*.5+.5j)
--    op = all_qevo
--    for t in TESTTIMES:
--        assert_allclose((op(t) @ vec).full(),
--                        op.matmul(t, vec).full(), atol=1e-14)
--
--
--def test_matmul(all_qevo):
--    "QobjEvo matmul oper"
--    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
--    matDense = Qobj(mat).to(_data.Dense)
--    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
--    matCSR = Qobj(mat).to(_data.CSR)
--    op = all_qevo
--    for t in TESTTIMES:
--        Qo1 = op(t)
--        assert_allclose((Qo1 @ mat).full(),
--                        op.matmul(t, matF).full(), atol=1e-14)
--        assert_allclose((Qo1 @ mat).full(),
--                        op.matmul(t, matDense).full(), atol=1e-14)
--        assert_allclose((Qo1 @ mat).full(),
--                        op.matmul(t, matCSR).full(), atol=1e-14)
--
--
--def test_expect_psi(all_qevo):
--    "QobjEvo expect psi"
--    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
--    qobj = Qobj(vec)
--    op = all_qevo
--    for t in TESTTIMES:
--        Qo1 = op(t)
--        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
--                        atol=1e-14)
--
--
--def test_expect_rho(all_qevo):
--    "QobjEvo expect rho"
--    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
--                                      + 1j * np.random.rand(N*N))
--    mat = _data.column_unstack_dense(vec, N)
--    qobj = Qobj(mat)
--    op = liouvillian(all_qevo)
--    for t in TESTTIMES:
--        Qo1 = op(t)
--        assert abs(_data.expect_super(Qo1.data, vec)
--                   - op.expect(t, qobj)) < 1e-14
--
--
--@pytest.mark.parametrize('dtype',
--[pytest.param(dtype, id=dtype.__name__)
--     for dtype in _data.to.dtypes])
--def test_convert(all_qevo, dtype):
--    "QobjEvo expect rho"
--    op = all_qevo.to(dtype)
--    assert isinstance(op(0.5).data, dtype)
--
--
--def test_compress():
--    "QobjEvo compress"
--    obj1 = QobjEvo(
--        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
--    assert obj1.num_elements == 1
--    obj2 = QobjEvo(
--        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
--    assert obj2.num_elements == 3
--    _assert_qobjevo_equivalent(obj1, obj2)
--    obj3 = obj2.copy()
--    assert obj3.num_elements == 3
--    obj3.compress()
--    assert obj3.num_elements == 1
--    _assert_qobjevo_equivalent(obj2, obj3)
--
--
--@pytest.mark.parametrize(['qobjdtype'],
--    [pytest.param(dtype, id=dtype.__name__)
--     for dtype in _data.to.dtypes])
--@pytest.mark.parametrize(['statedtype'],
--    [pytest.param(dtype, id=dtype.__name__)
--     for dtype in _data.to.dtypes])
--def test_layer_support(qobjdtype, statedtype):
--    N = 10
--    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
--    state_dense = rand_ket(N).to(_data.Dense)
--    state = state_dense.to(statedtype).data
--    state_dense = state_dense.data
--    exp_any = qevo.expect_data(0, state)
--    exp_dense = qevo.expect_data(0, state_dense)
--    assert_allclose(exp_any, exp_dense)
--    mul_any = qevo.matmul_data(0, state).to_array()
--    mul_dense = qevo.matmul_data(0, state_dense).to_array()
--    assert_allclose(mul_any, mul_dense)
--
--
--def test_QobjEvo_step_coeff():
--    "QobjEvo step interpolation"
--    coeff1 = np.random.rand(6)
--    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
--    # uniform t
--    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
--    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
--                      tlist=tlist, order=0)
--    assert qobjevo(2.0)[0,0] == coeff1[0]
--    assert qobjevo(7.0)[0,0] == coeff1[5]
--    assert qobjevo(5.0001)[0,0] == coeff1[3]
--    assert qobjevo(3.9999)[0,0] == coeff1[1]
--
--    assert qobjevo(2.0)[0,1] == coeff2[0]
--    assert qobjevo(7.0)[0,1] == coeff2[5]
--    assert qobjevo(5.0001)[0,1] == coeff2[3]
--    assert qobjevo(3.9999)[0,1] == coeff2[1]
--
--    # non-uniform t
--    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
--    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
--        tlist=tlist, order=0)
--    assert qobjevo(1.0)[0,0] == coeff1[0]
--    assert qobjevo(8.0)[0,0] == coeff1[5]
--    assert qobjevo(3.9999)[0,0] == coeff1[1]
--    assert qobjevo(4.23)[0,0] == coeff1[2]
--    assert qobjevo(1.23)[0,0] == coeff1[0]
--
--    assert qobjevo(1.0)[0,1] == coeff2[0]
--    assert qobjevo(8.0)[0,1] == coeff2[5]
--    assert qobjevo(6.7)[0,1] == coeff2[4]
--    assert qobjevo(7.9999)[0,1] == coeff2[4]
--    assert qobjevo(3.9999)[0,1] == coeff2[1]
--
--
--def test_QobjEvo_isherm_flag_knowcase():
--    assert QobjEvo(sigmax())(0)._isherm is True
--    non_hermitian = sigmax() + 1j
--    non_hermitian.isherm  # set flag
--    assert QobjEvo(non_hermitian)(0)._isherm is False
--    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
--    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
--    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
--    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
--    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
--
--
--@pytest.mark.parametrize(
--    "coeff_type",
--    ['func_coeff', 'string', 'array', 'logarray']
--)
--def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
--    qevo = QobjEvo(*pseudo_qevo[coeff_type])
--    as_list = qevo.to_list()
--    assert len(as_list) == 2
--    restored = QobjEvo(as_list)
--    _assert_qobjevo_equivalent(qevo, restored)
-+import operator
-+
-+import pytest
-+from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
-+                   rand_stochastic, rand_herm, rand_ket, liouvillian,
-+                   basis, spre, spost, to_choi)
-+import numpy as np
-+from numpy.testing import assert_allclose
-+
-+from qutip.core import data as _data
-+
-+# prepare coefficient
-+class Pseudo_qevo:
-+    # Mimic QobjEvo on __call__
-+    # and can return parameter to create the equivalent QobjEvo
-+    # for each coefficient type
-+    def __init__(self, cte, qobj, func, string, args):
-+        self.cte = cte
-+        self.qobj = qobj
-+        self.func = func
-+        self.str = string
-+        self.args = args
-+
-+    def array(self):
-+        tlist = np.linspace(0, 10, 10001)
-+        coeff = self.func(tlist, self.args)
-+        return ([self.cte, [self.qobj, coeff]], {}, tlist)
-+
-+    def logarray(self):
-+        tlist = np.logspace(-3, 1, 10001)
-+        coeff = self.func(tlist, self.args)
-+        return ([self.cte, [self.qobj, coeff]], {}, tlist)
-+
-+    def func_coeff(self):
-+        return ([self.cte, [self.qobj, self.func]], self.args)
-+
-+    def string(self):
-+        return ([self.cte, [self.qobj, self.str]], self.args)
-+
-+    def func_call(self):
-+        return (self.__call__, self.args)
-+
-+    def __call__(self, t, args={}):
-+        args = args or self.args
-+        return self.cte + self.qobj * self.func(t, args)
-+
-+    def __getitem__(self, which):
-+        return getattr(self, which)()
-+
-+
-+N = 3
-+args = {'w1': 1, "w2": 2}
-+TESTTIMES = np.linspace(0.001, 1.0, 10)
-+
-+
-+def _real(t, args):
-+    return np.sin(t*args['w1'])
-+
-+
-+def _cplx(t, args):
-+    return np.exp(1j*t*args['w2'])
-+
-+
-+real_qevo = Pseudo_qevo(
-+    rand_stochastic(N).to(_data.CSR),
-+    rand_stochastic(N).to(_data.CSR),
-+    _real, "sin(t*w1)", args)
-+
-+herm_qevo = Pseudo_qevo(
-+    rand_herm(N).to(_data.Dense),
-+    rand_herm(N).to(_data.Dense),
-+    _real, "sin(t*w1)", args)
-+
-+cplx_qevo = Pseudo_qevo(
-+    rand_stochastic(N).to(_data.Dense),
-+    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
-+    _cplx, "exp(1j*t*w2)", args)
-+
-+
-+@pytest.fixture(params=['func_coeff', 'string',
-+                        'array', 'logarray', 'func_call'])
-+def coeff_type(request):
-+    # all available QobjEvo types
-+    return request.param
-+
-+
-+@pytest.fixture(params=[
-+    pytest.param(real_qevo, id="real"),
-+    pytest.param(herm_qevo, id="hermitian"),
-+    pytest.param(cplx_qevo, id="complex"),
-+])
-+def pseudo_qevo(request):
-+    return request.param
-+
-+
-+@pytest.fixture
-+def all_qevo(pseudo_qevo, coeff_type):
-+    return QobjEvo(*pseudo_qevo[coeff_type])
-+
-+
-+@pytest.fixture
-+def other_qevo(all_qevo):
-+    return all_qevo
-+
-+
-+def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
-+    for t in TESTTIMES:
-+        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
-+
-+
-+def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
-+    assert obj1.dims == obj2.dims
-+    assert obj1.shape == obj2.shape
-+    assert obj1.type == obj2.type
-+    assert _data.iszero((obj1 - obj2).data, tol)
-+
-+
-+def _assert_qobjevo_different(obj1, obj2):
-+    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
-+
-+
-+def _div(a, b):
-+    return a / b
-+
-+
-+def test_call(pseudo_qevo, coeff_type):
-+    # test creation of QobjEvo and call
-+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
-+    assert isinstance(qevo(0), Qobj)
-+    assert qevo.isoper
-+    assert not qevo.isconstant
-+    assert not qevo.issuper
-+    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
-+
-+
-+# Test the QobjEvo.__repr__()
-+def test_QobjEvo_repr():
-+    # case_n: cases with Objects of QobjEvo with unique __repr__
-+    # expected_repr_n: are the Expected result from the __repr__
-+
-+    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
-+    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
-+    expected_repr_1 += 'type = oper, superrep = None, '
-+    expected_repr_1 += 'isconstant = False, num_elements = 1'
-+    assert case_1 == expected_repr_1
-+
-+    case_2 = repr(QobjEvo(qeye(2)))
-+    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
-+    expected_repr_2 += 'type = oper, superrep = None, '
-+    expected_repr_2 += 'isconstant = True, num_elements = 1'
-+    assert case_2 == expected_repr_2
-+
-+    case_3 = repr(QobjEvo(basis(5, 2)))
-+    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
-+    expected_repr_3 += 'type = ket, superrep = None, '
-+    expected_repr_3 += 'isconstant = True, num_elements = 1'
-+    assert case_3 == expected_repr_3
-+
-+    X = sigmax()
-+    S = spre(X) * spost(X.dag())
-+    case_4 = repr(QobjEvo(to_choi(S)))
-+    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
-+    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
-+    expected_repr_4 += 'isconstant = True, num_elements = 1'
-+    assert case_4 == expected_repr_4
-+
-+    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
-+                           [qeye(4), lambda t: t]], compress=False))
-+    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
-+    expected_repr_5 += 'type = oper, superrep = None, '
-+    expected_repr_5 += 'isconstant = False, num_elements = 2'
-+    assert case_5 == expected_repr_5
-+
-+
-+@pytest.mark.parametrize('coeff_type',
-+                         ['func_coeff', 'string', 'array', 'logarray'])
-+def test_product_coeff(pseudo_qevo, coeff_type):
-+    # test creation of QobjEvo with Qobj * Coefficient
-+    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
-+    base = pseudo_qevo[coeff_type]
-+    cte, [qobj, coeff] = base[0]
-+    args = base[1] if len(base) >= 2 else {}
-+    tlist = base[2] if len(base) >= 3 else None
-+    coeff = coefficient(coeff, args=args, tlist=tlist)
-+    created = cte + qobj * coeff
-+    _assert_qobjevo_equivalent(pseudo_qevo, created)
-+
-+def test_copy(all_qevo):
-+    qevo = all_qevo
-+    copy = qevo.copy()
-+    _assert_qobjevo_equivalent(copy, qevo)
-+    assert copy is not qevo
-+
-+
-+@pytest.mark.parametrize('bin_op', [
-+    pytest.param(lambda a, b: a + b, id="add"),
-+    pytest.param(lambda a, b: a - b, id="sub"),
-+    pytest.param(lambda a, b: a * b, id="mul"),
-+    pytest.param(lambda a, b: a @ b, id="matmul"),
-+    pytest.param(lambda a, b: a & b, id="tensor"),
-+])
-+def test_binopt(all_qevo, other_qevo, bin_op):
-+    "QobjEvo arithmetic"
-+    obj1 = all_qevo
-+    obj2 = other_qevo
-+    for t in TESTTIMES:
-+        as_qevo = bin_op(obj1, obj2)(t)
-+        as_qobj = bin_op(obj1(t), obj2(t))
-+        _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+
-+@pytest.mark.parametrize('bin_op', [
-+    pytest.param(operator.iadd, id="add"),
-+    pytest.param(operator.isub, id="sub"),
-+    pytest.param(operator.imul, id="mul"),
-+    pytest.param(operator.imatmul, id="matmul"),
-+    pytest.param(operator.iand, id="tensor"),
-+])
-+def test_binopt_inplace(all_qevo, other_qevo, bin_op):
-+    obj1 = all_qevo
-+    obj2 = other_qevo
-+    for t in TESTTIMES:
-+        as_qevo = bin_op(obj1.copy(), obj2)(t)
-+        as_qobj = bin_op(obj1(t).copy(), obj2(t))
-+        _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+
-+@pytest.mark.parametrize('bin_op', [
-+    pytest.param(lambda a, b: a + b, id="add"),
-+    pytest.param(lambda a, b: a - b, id="sub"),
-+    pytest.param(lambda a, b: a * b, id="mul"),
-+    pytest.param(lambda a, b: a @ b, id="matmul"),
-+    pytest.param(lambda a, b: a & b, id="tensor"),
-+])
-+def test_binopt_qobj(all_qevo, bin_op):
-+    "QobjEvo arithmetic"
-+    obj = all_qevo
-+    qobj = rand_herm(N)
-+    for t in TESTTIMES:
-+        as_qevo = bin_op(obj, qobj)(t)
-+        as_qobj = bin_op(obj(t), qobj)
-+        _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+        as_qevo = bin_op(qobj, obj)(t)
-+        as_qobj = bin_op(qobj, obj(t))
-+        _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+
-+@pytest.mark.parametrize('bin_op', [
-+    pytest.param(lambda a, b: a + b, id="add"),
-+    pytest.param(lambda a, b: a - b, id="sub"),
-+    pytest.param(lambda a, b: a * b, id="mul"),
-+    pytest.param(_div, id="div"),
-+])
-+def test_binopt_scalar(all_qevo, bin_op):
-+    "QobjEvo arithmetic"
-+    obj = all_qevo
-+    scalar = 0.5 + 1j
-+    for t in TESTTIMES:
-+        as_qevo = bin_op(obj, scalar)(t)
-+        as_qobj = bin_op(obj(t), scalar)
-+        _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+        if bin_op is not _div:
-+            as_qevo = bin_op(scalar, obj)(t)
-+            as_qobj = bin_op(scalar, obj(t))
-+            _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+
-+def binop_coeff(all_qevo):
-+    obj = all_qevo
-+    coeff = coeffient("t")
-+    created = obj * coeff_t
-+    for t in TESTTIMES:
-+        _assert_qobj_almost_eq(created(t), obj(t) * t)
-+
-+
-+@pytest.mark.parametrize('unary_op', [
-+    pytest.param(lambda a: a.conj(), id="conj"),
-+    pytest.param(lambda a: a.dag(), id="dag"),
-+    pytest.param(lambda a: a.trans(), id="trans"),
-+    pytest.param(lambda a: -a, id="neg"),
-+])
-+def test_unary(all_qevo, unary_op):
-+    "QobjEvo arithmetic"
-+    obj = all_qevo
-+    for t in TESTTIMES:
-+        as_qevo = unary_op(obj)(t)
-+        as_qobj = unary_op(obj(t))
-+        _assert_qobj_almost_eq(as_qevo, as_qobj)
-+
-+
-+@pytest.mark.parametrize('args_coeff_type',
-+                         ['func_coeff', 'string', 'func_call'])
-+def test_args(pseudo_qevo, args_coeff_type):
-+    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
-+    args = {'w1': 3, "w2": 3}
-+
-+    for t in TESTTIMES:
-+        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
-+        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
-+
-+    # Did it modify original args
-+    _assert_qobjevo_equivalent(obj, pseudo_qevo)
-+
-+    obj.arguments(args)
-+    _assert_qobjevo_different(obj, pseudo_qevo)
-+    for t in TESTTIMES:
-+        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
-+
-+    args = {'w1': 4, "w2": 4}
-+    obj.arguments(**args)
-+    _assert_qobjevo_different(obj, pseudo_qevo)
-+    for t in TESTTIMES:
-+        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
-+
-+
-+def test_copy_side_effects(all_qevo):
-+    t = 0.2
-+    qevo = all_qevo
-+    copy = qevo.copy()
-+    before = qevo(t)
-+    # Ensure inplace modification of the copy do not affect the original
-+    copy *= 2
-+    copy += rand_herm(N)
-+    copy *= rand_herm(N)
-+    copy.arguments({'w1': 3, "w2": 3})
-+    after = qevo(t)
-+    _assert_qobj_almost_eq(before, after)
-+
-+
-+@pytest.mark.parametrize('coeff_type',
-+    ['func_coeff', 'string', 'array', 'logarray']
-+)
-+def test_tidyup(all_qevo):
-+    "QobjEvo tidyup"
-+    obj = all_qevo
-+    obj *= 1e-12
-+    obj.tidyup(atol=1e-8)
-+    t = 0.2
-+    # check that the Qobj are cleaned
-+    assert_allclose(obj(t).full(), 0)
-+
-+
-+def test_QobjEvo_pickle(all_qevo):
-+    "QobjEvo pickle"
-+    # used in parallel_map
-+    import pickle
-+    obj = all_qevo
-+    pickled = pickle.dumps(obj, -1)
-+    recreated = pickle.loads(pickled)
-+    _assert_qobjevo_equivalent(recreated, obj)
-+
-+
-+def test_QobjEvo_restore(all_qevo):
-+    "QobjEvo pickle"
-+    # used in parallel_map
-+    obj = all_qevo
-+    state = obj._getstate()
-+    recreated = QobjEvo._restore(**state)
-+    _assert_qobjevo_equivalent(recreated, obj)
-+
-+
-+def test_mul_vec(all_qevo):
-+    "QobjEvo matmul ket"
-+    vec = Qobj(np.arange(N)*.5+.5j)
-+    op = all_qevo
-+    for t in TESTTIMES:
-+        assert_allclose((op(t) @ vec).full(),
-+                        op.matmul(t, vec).full(), atol=1e-14)
-+
-+
-+def test_matmul(all_qevo):
-+    "QobjEvo matmul oper"
-+    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
-+    matDense = Qobj(mat).to(_data.Dense)
-+    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
-+    matCSR = Qobj(mat).to(_data.CSR)
-+    op = all_qevo
-+    for t in TESTTIMES:
-+        Qo1 = op(t)
-+        assert_allclose((Qo1 @ mat).full(),
-+                        op.matmul(t, matF).full(), atol=1e-14)
-+        assert_allclose((Qo1 @ mat).full(),
-+                        op.matmul(t, matDense).full(), atol=1e-14)
-+        assert_allclose((Qo1 @ mat).full(),
-+                        op.matmul(t, matCSR).full(), atol=1e-14)
-+
-+
-+def test_expect_psi(all_qevo):
-+    "QobjEvo expect psi"
-+    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
-+    qobj = Qobj(vec)
-+    op = all_qevo
-+    for t in TESTTIMES:
-+        Qo1 = op(t)
-+        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
-+                        atol=1e-14)
-+
-+
-+def test_expect_rho(all_qevo):
-+    "QobjEvo expect rho"
-+    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
-+                                      + 1j * np.random.rand(N*N))
-+    mat = _data.column_unstack_dense(vec, N)
-+    qobj = Qobj(mat)
-+    op = liouvillian(all_qevo)
-+    for t in TESTTIMES:
-+        Qo1 = op(t)
-+        assert abs(_data.expect_super(Qo1.data, vec)
-+                   - op.expect(t, qobj)) < 1e-14
-+
-+
-+@pytest.mark.parametrize('dtype',
-+[pytest.param(dtype, id=dtype.__name__)
-+     for dtype in _data.to.dtypes])
-+def test_convert(all_qevo, dtype):
-+    "QobjEvo expect rho"
-+    op = all_qevo.to(dtype)
-+    assert isinstance(op(0.5).data, dtype)
-+
-+
-+def test_compress():
-+    "QobjEvo compress"
-+    obj1 = QobjEvo(
-+        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
-+    assert obj1.num_elements == 1
-+    obj2 = QobjEvo(
-+        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
-+    assert obj2.num_elements == 3
-+    _assert_qobjevo_equivalent(obj1, obj2)
-+    obj3 = obj2.copy()
-+    assert obj3.num_elements == 3
-+    obj3.compress()
-+    assert obj3.num_elements == 1
-+    _assert_qobjevo_equivalent(obj2, obj3)
-+
-+
-+@pytest.mark.parametrize(['qobjdtype'],
-+    [pytest.param(dtype, id=dtype.__name__)
-+     for dtype in _data.to.dtypes])
-+@pytest.mark.parametrize(['statedtype'],
-+    [pytest.param(dtype, id=dtype.__name__)
-+     for dtype in _data.to.dtypes])
-+def test_layer_support(qobjdtype, statedtype):
-+    N = 10
-+    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
-+    state_dense = rand_ket(N).to(_data.Dense)
-+    state = state_dense.to(statedtype).data
-+    state_dense = state_dense.data
-+    exp_any = qevo.expect_data(0, state)
-+    exp_dense = qevo.expect_data(0, state_dense)
-+    assert_allclose(exp_any, exp_dense)
-+    mul_any = qevo.matmul_data(0, state).to_array()
-+    mul_dense = qevo.matmul_data(0, state_dense).to_array()
-+    assert_allclose(mul_any, mul_dense)
-+
-+
-+def test_QobjEvo_step_coeff():
-+    "QobjEvo step interpolation"
-+    coeff1 = np.random.rand(6)
-+    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
-+    # uniform t
-+    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
-+    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
-+                      tlist=tlist, order=0)
-+    assert qobjevo(2.0)[0,0] == coeff1[0]
-+    assert qobjevo(7.0)[0,0] == coeff1[5]
-+    assert qobjevo(5.0001)[0,0] == coeff1[3]
-+    assert qobjevo(3.9999)[0,0] == coeff1[1]
-+
-+    assert qobjevo(2.0)[0,1] == coeff2[0]
-+    assert qobjevo(7.0)[0,1] == coeff2[5]
-+    assert qobjevo(5.0001)[0,1] == coeff2[3]
-+    assert qobjevo(3.9999)[0,1] == coeff2[1]
-+
-+    # non-uniform t
-+    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
-+    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
-+        tlist=tlist, order=0)
-+    assert qobjevo(1.0)[0,0] == coeff1[0]
-+    assert qobjevo(8.0)[0,0] == coeff1[5]
-+    assert qobjevo(3.9999)[0,0] == coeff1[1]
-+    assert qobjevo(4.23)[0,0] == coeff1[2]
-+    assert qobjevo(1.23)[0,0] == coeff1[0]
-+
-+    assert qobjevo(1.0)[0,1] == coeff2[0]
-+    assert qobjevo(8.0)[0,1] == coeff2[5]
-+    assert qobjevo(6.7)[0,1] == coeff2[4]
-+    assert qobjevo(7.9999)[0,1] == coeff2[4]
-+    assert qobjevo(3.9999)[0,1] == coeff2[1]
-+
-+
-+def test_QobjEvo_isherm_flag_knowcase():
-+    assert QobjEvo(sigmax())(0)._isherm is True
-+    non_hermitian = sigmax() + 1j
-+    non_hermitian.isherm  # set flag
-+    assert QobjEvo(non_hermitian)(0)._isherm is False
-+    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
-+    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
-+    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
-+    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
-+    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
-+
-+
-+@pytest.mark.parametrize(
-+    "coeff_type",
-+    ['func_coeff', 'string', 'array', 'logarray']
-+)
-+def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
-+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
-+    as_list = qevo.to_list()
-+    assert len(as_list) == 2
-+    restored = QobjEvo(as_list)
-+    _assert_qobjevo_equivalent(qevo, restored)
-diff --git a/qutip/tests/core/test_states.py b/qutip/tests/core/test_states.py
-index be17941d..edacd7d6 100644
---- a/qutip/tests/core/test_states.py
-+++ b/qutip/tests/core/test_states.py
-@@ -1,318 +1,318 @@
--import pytest
--import numpy as np
--import qutip
--from functools import partial
--from itertools import combinations
--
--
--@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
--def test_basis_simple(size, n):
--    qobj = qutip.basis(size, n)
--    numpy = np.zeros((size, 1), dtype=complex)
--    numpy[n, 0] = 1
--    assert np.array_equal(qobj.full(), numpy)
--
--
--@pytest.mark.parametrize("to_test", [
--    qutip.basis, qutip.fock, qutip.fock_dm,
--])
--@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
--def test_implicit_tensor_basis_like(to_test, size, n):
--    implicit = to_test(size, n)
--    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
--    assert implicit == explicit
--
--
--@pytest.mark.parametrize("size, n, offset, msg", [
--    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
--    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
--    (-1, 0, 0, "All dimensions must be >= 0."),
--    (1.5, 0, 0, "All dimensions must be >= 0."),
--    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
--    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
--], ids=["n too long", "offset too long", "neg dims",
--        "fraction dims", "n too large", "n too small"]
--)
--def test_basis_error(size, n, offset, msg):
--    with pytest.raises(ValueError) as e:
--        qutip.basis(size, n, offset)
--    assert str(e.value) == msg
--
--
--def test_basis_error_type():
--    with pytest.raises(TypeError) as e:
--        qutip.basis(5, 3.5)
--    assert str(e.value) == ("Dimensions must be an integer "
--                            "or list of integers.")
--
--
--@pytest.mark.parametrize("size, n, m", [
--        ([2, 2], [0, 0], [1, 1]),
--        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
--    ])
--def test_implicit_tensor_projection(size, n, m):
--    implicit = qutip.projection(size, n, m)
--    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
--                              for ss, nn, mm in zip(size, n, m)])
--    assert implicit == explicit
--
--
--@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
--    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
--                 id="basis"),
--    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
--                 id="basis,offset"),
--    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
--                 id="fock"),
--    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
--                 id="fock_dm"),
--    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
--                 id="fock_dm,offset"),
--    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
--                 id="coherent"),
--    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
--                 id="coherent,offset"),
--    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
--                 id="coherent_dm"),
--    pytest.param(qutip.phase_basis, qutip.phase,
--                 (10, 3), (10,), 3 * 2 * np.pi / 10,
--                 id="phase_basis"),
--    pytest.param(qutip.phase_basis, qutip.phase,
--                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
--                 id="phase_basis,phi0"),
--    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
--                 id="spin_state"),
--    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
--                 id="zero_ket"),
--])
--def test_diverse_basis(base, operator, args, opargs, eigenval):
--    # For state which are supposed to eigenvector of an operator
--    # Verify that correspondance
--    state = base(*args)
--    oper = operator(*opargs)
--    assert qutip.expect(oper, state) == pytest.approx(eigenval)
--
--
--@pytest.mark.parametrize('dm', [
--    partial(qutip.thermal_dm, n=1.),
--    qutip.maximally_mixed_dm,
--    partial(qutip.coherent_dm, alpha=0.5),
--    partial(qutip.fock_dm, n=1),
--    partial(qutip.spin_state, m=2, type='dm'),
--    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
--], ids=[
--    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
--    'fock_dm', 'spin_state', 'spin_coherent'
--])
--def test_dm(dm):
--    N = 5
--    rho = dm(N)
--    # make sure rho has trace close to 1.0
--    assert rho.tr() == pytest.approx(1.0)
--
--
--def test_CoherentState():
--    N = 10
--    alpha = 0.5
--    c1 = qutip.coherent(N, alpha)  # displacement method
--    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
--    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
--    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
--    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
--    with pytest.raises(TypeError) as e:
--        qutip.coherent(N, alpha, method="other")
--    assert all(method in str(e.value) for method in ["operator", "analytic"])
--    with pytest.raises(ValueError) as e:
--        qutip.coherent(N, alpha, offset=-1)
--    assert str(e.value) == ("Offset must be non-negative")
--    with pytest.raises(ValueError) as e:
--        qutip.coherent(N, alpha, offset=1, method="operator")
--    assert str(e.value) == (
--        "The method 'operator' does not support offset != 0. Please"
--        " select another method or set the offset to zero."
--    )
--
--
--def test_CoherentDensityMatrix():
--    N = 10
--    rho = qutip.coherent_dm(N, 1)
--    assert rho.tr() == pytest.approx(1.0)
--    with pytest.raises(TypeError) as e:
--        qutip.coherent_dm(N, 1, method="other")
--    assert all(method in str(e.value) for method in ["operator", "analytic"])
--    with pytest.raises(ValueError) as e:
--        qutip.coherent_dm(N, 1, offset=-1)
--    assert str(e.value) == ("Offset must be non-negative")
--    with pytest.raises(ValueError) as e:
--        qutip.coherent_dm(N, 1, offset=1, method="operator")
--    assert str(e.value) == (
--        "The method 'operator' does not support offset != 0. Please"
--        " select another method or set the offset to zero."
--    )
--
--
--def test_thermal():
--    N = 10
--    beta = 0.5
--    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
--
--    thermal_operator = qutip.thermal_dm(N, beta)
--    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
--    np.testing.assert_allclose(thermal_operator.full(),
--                               thermal_analytic.full(), atol=2e-5)
--
--    with pytest.raises(ValueError) as e:
--        qutip.thermal_dm(N, beta, method="other")
--    assert all(method in str(e.value) for method in ["operator", "analytic"])
--
--
--@pytest.mark.parametrize('func', [
--    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
--])
--def test_spin_output(func):
--    assert qutip.isket(func(1.0, 0, type='ket'))
--    assert qutip.isbra(func(1.0, 0, type='bra'))
--    assert qutip.isoper(func(1.0, 0, type='dm'))
--
--    with pytest.raises(ValueError) as e:
--        func(1.0, 0, type='something')
--    assert str(e.value).startswith("Invalid value keyword argument")
--
--
--@pytest.mark.parametrize('N', [2.5, -1])
--def test_maximally_mixed_dm_error(N):
--    with pytest.raises(ValueError) as e:
--        qutip.maximally_mixed_dm(N)
--    assert str(e.value) == "N must be integer N > 0"
--
--
--def test_TripletStateNorm():
--    for triplet in qutip.triplet_states():
--        assert triplet.norm() == pytest.approx(1.)
--    for t1, t2 in combinations(qutip.triplet_states(), 2):
--        assert t1.overlap(t2) == pytest.approx(0.)
--
--
--def test_ket2dm():
--    N = 5
--    ket = qutip.coherent(N, 2)
--    bra = ket.dag()
--    oper = qutip.ket2dm(ket)
--    oper_from_bra = qutip.ket2dm(bra)
--    assert qutip.expect(oper, ket) == pytest.approx(1.)
--    assert qutip.isoper(oper)
--    assert oper == ket * bra
--    assert oper == oper_from_bra
--    with pytest.raises(TypeError) as e:
--        qutip.ket2dm(oper)
--    assert str(e.value) == "Input is not a ket or bra vector."
--
--
--@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
--def test_qstate(state):
--    from_basis = qutip.basis([2] * len(state), state)
--    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
--    assert from_basis == from_qstate
--
--
--def test_qstate_error():
--    with pytest.raises(TypeError) as e:
--        qutip.qstate("eeggg")
--    assert str(e.value) == ('String input to QSTATE must consist ' +
--                            'of "u" and "d" elements only')
--
--
--@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
--def test_bra_ket(state):
--    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
--    from_ket = qutip.ket(state)
--    from_bra = qutip.bra(state).dag()
--    assert from_basis == from_ket
--    assert from_basis == from_bra
--
--
--def test_w_states():
--    state = (
--        qutip.qstate("uddd") +
--        qutip.qstate("dudd") +
--        qutip.qstate("ddud") +
--        qutip.qstate("dddu")
--    ) / 2
--    assert state == qutip.w_state(4)
--
--
--def test_ghz_states():
--    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
--    assert state == qutip.ghz_state(3)
--
--
--def test_bell_state():
--    states = [
--        qutip.bell_state('00'),
--        qutip.bell_state('01'),
--        qutip.bell_state('10'),
--        qutip.bell_state('11')
--    ]
--    exited = qutip.basis([2, 2], [1, 1])
--    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
--        assert state.norm() == pytest.approx(1.0)
--        assert state.overlap(exited) == pytest.approx(overlap)
--
--    for state1, state2 in combinations(states, 2):
--        assert state1.overlap(state2) == pytest.approx(0.0)
--
--    assert qutip.singlet_state() == qutip.bell_state('11')
--
--
--def _id_func(val):
--    "ids generated from the function only"
--    if isinstance(val, tuple):
--        return ""
--
--
--# random object accept `str` and base.Data
--# Obtain all valid dtype from `to`
--dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
--dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
--@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
--                         ids=[str(dtype) for dtype in dtype_names])
--@pytest.mark.parametrize(['func', 'args'], [
--    (qutip.basis, (5, 1)),
--    (qutip.fock, (5, 1)),
--    (qutip.fock_dm, (5, 1)),
--    (qutip.coherent, (5, 1)),
--    (qutip.coherent_dm, (5, 1)),
--    (qutip.thermal_dm, (5, 1)),
--    (qutip.maximally_mixed_dm, (5,)),
--    (qutip.phase_basis, (5, 1)),
--    (qutip.zero_ket, (5,)),
--    (qutip.spin_state, (5, 1)),
--    (qutip.spin_coherent, (5, 1, 0.5)),
--    (qutip.projection, (5, 1, 2)),
--    (qutip.ket, ("001",)),
--    (qutip.bra, ('010',)),
--    (qutip.qstate, ("uud",)),
--    (qutip.w_state, (5,)),
--    (qutip.ghz_state, (5,)),
--    (qutip.qutrit_basis, ()),
--    (qutip.triplet_states, ()),
--    (qutip.singlet_state, ()),
--    (qutip.bell_state, ('10',)),
--    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
--    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
--], ids=_id_func)
--def test_state_type(func, args, alias, dtype):
--    object = func(*args, dtype=alias)
--    if isinstance(object, qutip.Qobj):
--        assert isinstance(object.data, dtype)
--    else:
--        for obj in object:
--            assert isinstance(obj.data, dtype)
--
--    with qutip.CoreOptions(default_dtype=alias):
--        object = func(*args)
--        if isinstance(object, qutip.Qobj):
--            assert isinstance(object.data, dtype)
--        else:
--            for obj in object:
--                assert isinstance(obj.data, dtype)
-+import pytest
-+import numpy as np
-+import qutip
-+from functools import partial
-+from itertools import combinations
-+
-+
-+@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
-+def test_basis_simple(size, n):
-+    qobj = qutip.basis(size, n)
-+    numpy = np.zeros((size, 1), dtype=complex)
-+    numpy[n, 0] = 1
-+    assert np.array_equal(qobj.full(), numpy)
-+
-+
-+@pytest.mark.parametrize("to_test", [
-+    qutip.basis, qutip.fock, qutip.fock_dm,
-+])
-+@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
-+def test_implicit_tensor_basis_like(to_test, size, n):
-+    implicit = to_test(size, n)
-+    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
-+    assert implicit == explicit
-+
-+
-+@pytest.mark.parametrize("size, n, offset, msg", [
-+    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
-+    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
-+    (-1, 0, 0, "All dimensions must be >= 0."),
-+    (1.5, 0, 0, "All dimensions must be >= 0."),
-+    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
-+    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
-+], ids=["n too long", "offset too long", "neg dims",
-+        "fraction dims", "n too large", "n too small"]
-+)
-+def test_basis_error(size, n, offset, msg):
-+    with pytest.raises(ValueError) as e:
-+        qutip.basis(size, n, offset)
-+    assert str(e.value) == msg
-+
-+
-+def test_basis_error_type():
-+    with pytest.raises(TypeError) as e:
-+        qutip.basis(5, 3.5)
-+    assert str(e.value) == ("Dimensions must be an integer "
-+                            "or list of integers.")
-+
-+
-+@pytest.mark.parametrize("size, n, m", [
-+        ([2, 2], [0, 0], [1, 1]),
-+        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
-+    ])
-+def test_implicit_tensor_projection(size, n, m):
-+    implicit = qutip.projection(size, n, m)
-+    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
-+                              for ss, nn, mm in zip(size, n, m)])
-+    assert implicit == explicit
-+
-+
-+@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
-+    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
-+                 id="basis"),
-+    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
-+                 id="basis,offset"),
-+    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
-+                 id="fock"),
-+    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
-+                 id="fock_dm"),
-+    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
-+                 id="fock_dm,offset"),
-+    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
-+                 id="coherent"),
-+    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
-+                 id="coherent,offset"),
-+    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
-+                 id="coherent_dm"),
-+    pytest.param(qutip.phase_basis, qutip.phase,
-+                 (10, 3), (10,), 3 * 2 * np.pi / 10,
-+                 id="phase_basis"),
-+    pytest.param(qutip.phase_basis, qutip.phase,
-+                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
-+                 id="phase_basis,phi0"),
-+    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
-+                 id="spin_state"),
-+    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
-+                 id="zero_ket"),
-+])
-+def test_diverse_basis(base, operator, args, opargs, eigenval):
-+    # For state which are supposed to eigenvector of an operator
-+    # Verify that correspondance
-+    state = base(*args)
-+    oper = operator(*opargs)
-+    assert qutip.expect(oper, state) == pytest.approx(eigenval)
-+
-+
-+@pytest.mark.parametrize('dm', [
-+    partial(qutip.thermal_dm, n=1.),
-+    qutip.maximally_mixed_dm,
-+    partial(qutip.coherent_dm, alpha=0.5),
-+    partial(qutip.fock_dm, n=1),
-+    partial(qutip.spin_state, m=2, type='dm'),
-+    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
-+], ids=[
-+    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
-+    'fock_dm', 'spin_state', 'spin_coherent'
-+])
-+def test_dm(dm):
-+    N = 5
-+    rho = dm(N)
-+    # make sure rho has trace close to 1.0
-+    assert rho.tr() == pytest.approx(1.0)
-+
-+
-+def test_CoherentState():
-+    N = 10
-+    alpha = 0.5
-+    c1 = qutip.coherent(N, alpha)  # displacement method
-+    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
-+    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
-+    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
-+    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
-+    with pytest.raises(TypeError) as e:
-+        qutip.coherent(N, alpha, method="other")
-+    assert all(method in str(e.value) for method in ["operator", "analytic"])
-+    with pytest.raises(ValueError) as e:
-+        qutip.coherent(N, alpha, offset=-1)
-+    assert str(e.value) == ("Offset must be non-negative")
-+    with pytest.raises(ValueError) as e:
-+        qutip.coherent(N, alpha, offset=1, method="operator")
-+    assert str(e.value) == (
-+        "The method 'operator' does not support offset != 0. Please"
-+        " select another method or set the offset to zero."
-+    )
-+
-+
-+def test_CoherentDensityMatrix():
-+    N = 10
-+    rho = qutip.coherent_dm(N, 1)
-+    assert rho.tr() == pytest.approx(1.0)
-+    with pytest.raises(TypeError) as e:
-+        qutip.coherent_dm(N, 1, method="other")
-+    assert all(method in str(e.value) for method in ["operator", "analytic"])
-+    with pytest.raises(ValueError) as e:
-+        qutip.coherent_dm(N, 1, offset=-1)
-+    assert str(e.value) == ("Offset must be non-negative")
-+    with pytest.raises(ValueError) as e:
-+        qutip.coherent_dm(N, 1, offset=1, method="operator")
-+    assert str(e.value) == (
-+        "The method 'operator' does not support offset != 0. Please"
-+        " select another method or set the offset to zero."
-+    )
-+
-+
-+def test_thermal():
-+    N = 10
-+    beta = 0.5
-+    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
-+
-+    thermal_operator = qutip.thermal_dm(N, beta)
-+    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
-+    np.testing.assert_allclose(thermal_operator.full(),
-+                               thermal_analytic.full(), atol=2e-5)
-+
-+    with pytest.raises(ValueError) as e:
-+        qutip.thermal_dm(N, beta, method="other")
-+    assert all(method in str(e.value) for method in ["operator", "analytic"])
-+
-+
-+@pytest.mark.parametrize('func', [
-+    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
-+])
-+def test_spin_output(func):
-+    assert qutip.isket(func(1.0, 0, type='ket'))
-+    assert qutip.isbra(func(1.0, 0, type='bra'))
-+    assert qutip.isoper(func(1.0, 0, type='dm'))
-+
-+    with pytest.raises(ValueError) as e:
-+        func(1.0, 0, type='something')
-+    assert str(e.value).startswith("Invalid value keyword argument")
-+
-+
-+@pytest.mark.parametrize('N', [2.5, -1])
-+def test_maximally_mixed_dm_error(N):
-+    with pytest.raises(ValueError) as e:
-+        qutip.maximally_mixed_dm(N)
-+    assert str(e.value) == "N must be integer N > 0"
-+
-+
-+def test_TripletStateNorm():
-+    for triplet in qutip.triplet_states():
-+        assert triplet.norm() == pytest.approx(1.)
-+    for t1, t2 in combinations(qutip.triplet_states(), 2):
-+        assert t1.overlap(t2) == pytest.approx(0.)
-+
-+
-+def test_ket2dm():
-+    N = 5
-+    ket = qutip.coherent(N, 2)
-+    bra = ket.dag()
-+    oper = qutip.ket2dm(ket)
-+    oper_from_bra = qutip.ket2dm(bra)
-+    assert qutip.expect(oper, ket) == pytest.approx(1.)
-+    assert qutip.isoper(oper)
-+    assert oper == ket * bra
-+    assert oper == oper_from_bra
-+    with pytest.raises(TypeError) as e:
-+        qutip.ket2dm(oper)
-+    assert str(e.value) == "Input is not a ket or bra vector."
-+
-+
-+@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
-+def test_qstate(state):
-+    from_basis = qutip.basis([2] * len(state), state)
-+    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
-+    assert from_basis == from_qstate
-+
-+
-+def test_qstate_error():
-+    with pytest.raises(TypeError) as e:
-+        qutip.qstate("eeggg")
-+    assert str(e.value) == ('String input to QSTATE must consist ' +
-+                            'of "u" and "d" elements only')
-+
-+
-+@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
-+def test_bra_ket(state):
-+    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
-+    from_ket = qutip.ket(state)
-+    from_bra = qutip.bra(state).dag()
-+    assert from_basis == from_ket
-+    assert from_basis == from_bra
-+
-+
-+def test_w_states():
-+    state = (
-+        qutip.qstate("uddd") +
-+        qutip.qstate("dudd") +
-+        qutip.qstate("ddud") +
-+        qutip.qstate("dddu")
-+    ) / 2
-+    assert state == qutip.w_state(4)
-+
-+
-+def test_ghz_states():
-+    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
-+    assert state == qutip.ghz_state(3)
-+
-+
-+def test_bell_state():
-+    states = [
-+        qutip.bell_state('00'),
-+        qutip.bell_state('01'),
-+        qutip.bell_state('10'),
-+        qutip.bell_state('11')
-+    ]
-+    exited = qutip.basis([2, 2], [1, 1])
-+    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
-+        assert state.norm() == pytest.approx(1.0)
-+        assert state.overlap(exited) == pytest.approx(overlap)
-+
-+    for state1, state2 in combinations(states, 2):
-+        assert state1.overlap(state2) == pytest.approx(0.0)
-+
-+    assert qutip.singlet_state() == qutip.bell_state('11')
-+
-+
-+def _id_func(val):
-+    "ids generated from the function only"
-+    if isinstance(val, tuple):
-+        return ""
-+
-+
-+# random object accept `str` and base.Data
-+# Obtain all valid dtype from `to`
-+dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
-+dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
-+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-+                         ids=[str(dtype) for dtype in dtype_names])
-+@pytest.mark.parametrize(['func', 'args'], [
-+    (qutip.basis, (5, 1)),
-+    (qutip.fock, (5, 1)),
-+    (qutip.fock_dm, (5, 1)),
-+    (qutip.coherent, (5, 1)),
-+    (qutip.coherent_dm, (5, 1)),
-+    (qutip.thermal_dm, (5, 1)),
-+    (qutip.maximally_mixed_dm, (5,)),
-+    (qutip.phase_basis, (5, 1)),
-+    (qutip.zero_ket, (5,)),
-+    (qutip.spin_state, (5, 1)),
-+    (qutip.spin_coherent, (5, 1, 0.5)),
-+    (qutip.projection, (5, 1, 2)),
-+    (qutip.ket, ("001",)),
-+    (qutip.bra, ('010',)),
-+    (qutip.qstate, ("uud",)),
-+    (qutip.w_state, (5,)),
-+    (qutip.ghz_state, (5,)),
-+    (qutip.qutrit_basis, ()),
-+    (qutip.triplet_states, ()),
-+    (qutip.singlet_state, ()),
-+    (qutip.bell_state, ('10',)),
-+    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
-+    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
-+], ids=_id_func)
-+def test_state_type(func, args, alias, dtype):
-+    object = func(*args, dtype=alias)
-+    if isinstance(object, qutip.Qobj):
-+        assert isinstance(object.data, dtype)
-+    else:
-+        for obj in object:
-+            assert isinstance(obj.data, dtype)
-+
-+    with qutip.CoreOptions(default_dtype=alias):
-+        object = func(*args)
-+        if isinstance(object, qutip.Qobj):
-+            assert isinstance(object.data, dtype)
-+        else:
-+            for obj in object:
-+                assert isinstance(obj.data, dtype)
-diff --git a/qutip/tests/core/test_superop_reps.py b/qutip/tests/core/test_superop_reps.py
-index 31c538d1..7e04579c 100644
---- a/qutip/tests/core/test_superop_reps.py
-+++ b/qutip/tests/core/test_superop_reps.py
-@@ -1,347 +1,347 @@
--# -*- coding: utf-8 -*-
--"""
--Created on Wed May 29 11:23:46 2013
--
--@author: dcriger
--"""
--
--from __future__ import division
--
--import numpy as np
--import pytest
--
--from qutip import (
--    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
--    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
--    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
--    vector_to_operator, sprepost, destroy
--)
--from qutip.core.gates import swap
--
--
--tol = 1e-8
--
--
--def assert_kraus_equivalence(a, b, tol=tol):
--    assert a.shape == b.shape
--    assert a.dims == b.dims
--    assert a.type == b.type
--    # Kraus operators may vary by a global phase.  Let's find the first
--    # non-zero element, set the phase such that that element has the same phase
--    # in both, and then compare.  We have to take care to find the first
--    # element.
--    a, b = a.full(), b.full()
--    a_nz = np.nonzero(np.abs(a) > tol)
--    if len(a_nz[0]) == 0:
--        np.testing.assert_allclose(b, 0, atol=tol)
--    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
--    assert b_el != 0
--    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
--    np.testing.assert_allclose(a, b)
--
--
--@pytest.fixture(scope="function", params=[2, 3, 7])
--def dimension(request):
--    # There are also some cases in the file where this fixture is explicitly
--    # overridden by a more local mark.  That is deliberate.
--    return request.param
--
--
--@pytest.fixture(scope="function", params=[
--    pytest.param(rand_super, id="super"),
--    pytest.param(rand_super_bcsz, id="super_bcz")
--])
--def superoperator(request, dimension):
--    return request.param(dimension)
--
--
--class TestSuperopReps:
--    """
--    A test class for the QuTiP function for applying superoperators to
--    subsystems.
--    """
--
--    def test_SuperChoiSuper(self, superoperator):
--        """
--        Superoperator: Converting superoperator to Choi matrix and back.
--        """
--        choi_matrix = to_choi(superoperator)
--        test_supe = to_super(choi_matrix)
--
--        # Assert both that the result is close to expected, and has the right
--        # type.
--        assert (test_supe - superoperator).norm() < tol
--        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
--        assert test_supe.type == "super" and test_supe.superrep == "super"
--
--    @pytest.mark.parametrize('dimension', [2, 4])
--    def test_SuperChoiChiSuper(self, dimension):
--        """
--        Superoperator: Converting two-qubit superoperator through
--        Choi and chi representations goes back to right superoperator.
--        """
--        superoperator = super_tensor(
--            rand_super(dimension), rand_super(dimension),
--        )
--
--        choi_matrix = to_choi(superoperator)
--        chi_matrix = to_chi(choi_matrix)
--        test_supe = to_super(chi_matrix)
--
--        # Assert both that the result is close to expected, and has the right
--        # type.
--        assert (test_supe - superoperator).norm() < tol
--        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
--        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
--        assert test_supe.type == "super" and test_supe.superrep == "super"
--
--    def test_ChoiKrausChoi(self, superoperator):
--        """
--        Superoperator: Convert superoperator to Choi matrix and back.
--        """
--        choi_matrix = to_choi(superoperator)
--        kraus_ops = to_kraus(choi_matrix)
--        test_choi = kraus_to_choi(kraus_ops)
--
--        # Assert both that the result is close to expected, and has the right
--        # type.
--        assert (test_choi - choi_matrix).norm() < tol
--        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
--        assert test_choi.type == "super" and test_choi.superrep == "choi"
--
--    def test_NonSquareKrausSuperChoi(self):
--        """
--        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
--        and back.
--        """
--        zero = np.array([[1], [0]], dtype=complex)
--        one = np.array([[0], [1]], dtype=complex)
--        zero_log = np.kron(np.kron(zero, zero), zero)
--        one_log = np.kron(np.kron(one, one), one)
--        # non-square Kraus operator (isometry)
--        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
--        super = sprepost(kraus, kraus.dag())
--        choi = to_choi(super)
--        op1 = to_kraus(super)
--        op2 = to_kraus(choi)
--        op3 = to_super(choi)
--        assert choi.type == "super" and choi.superrep == "choi"
--        assert super.type == "super" and super.superrep == "super"
--        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
--        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
--        assert abs((op3 - super).norm()) < 1e-8
--
--    def test_NeglectSmallKraus(self):
--        """
--        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
--        Kraus operators.
--        """
--        zero = np.array([[1], [0]], dtype=complex)
--        one = np.array([[0], [1]], dtype=complex)
--        zero_log = np.kron(np.kron(zero, zero), zero)
--        one_log = np.kron(np.kron(one, one), one)
--        # non-square Kraus operator (isometry)
--        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
--        super = sprepost(kraus, kraus.dag())
--        # 1 non-zero Kraus operator the rest are zero
--        sixteen_kraus_ops = to_kraus(super, tol=0.0)
--        # default is tol=1e-9
--        one_kraus_op = to_kraus(super)
--        assert len(sixteen_kraus_ops) == 16
--        assert len(one_kraus_op) == 1
--        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
--
--    def test_SuperPreservesSelf(self, superoperator):
--        """
--        Superoperator: to_super(q) returns q if q is already a
--        supermatrix.
--        """
--
--        assert superoperator is to_super(superoperator)
--
--    def test_ChoiPreservesSelf(self, superoperator):
--        """
--        Superoperator: to_choi(q) returns q if q is already Choi.
--        """
--        choi = to_choi(superoperator)
--        assert choi is to_choi(choi)
--
--    def test_random_iscptp(self, superoperator):
--        """
--        Superoperator: Randomly generated superoperators are
--        correctly reported as CPTP and HP.
--        """
--        assert superoperator.iscptp
--        assert superoperator.ishp
--
--    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
--        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
--        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
--        pytest.param(qeye(2), True, True, True),
--        pytest.param(sigmax(), True, True, True),
--        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
--        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
--                            + to_super(tensor(qeye(2), sigmay()))),
--                     True, True, True,
--                     id="linear combination of bipartite unitaries"),
--        pytest.param(Qobj(swap(), type='super', superrep='choi'),
--                     True, False, True,
--                     id="partial transpose map"),
--        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
--                     id="subnormalized map"),
--        pytest.param(basis(2, 0), False, False, False, id="ket"),
--    ])
--    def test_known_iscptp(self, qobj, hp, cp, tp):
--        """
--        Superoperator: ishp, iscp, istp and iscptp known cases.
--        """
--        assert qobj.ishp == hp
--        assert qobj.iscp == cp
--        assert qobj.istp == tp
--        assert qobj.iscptp == (cp and tp)
--
--    def test_choi_tr(self):
--        """
--        Superoperator: Trace returned by to_choi matches docstring.
--        """
--        for dims in range(2, 5):
--            assert abs(to_choi(identity(dims)).tr() - dims) < tol
--
--
--    # Conjugation by a creation operator
--    a = create(2).dag()
--    S = sprepost(a, a.dag())
--
--    # A single off-diagonal element
--    S_ = sprepost(a, a)
--
--    # Check that a linear combination of bipartite unitaries is CPTP and HP.
--    S_U = (
--        to_super(tensor(sigmax(), identity(2))) +
--        to_super(tensor(identity(2), sigmay()))
--    ) / 2
--
--    # The partial transpose map, whose Choi matrix is SWAP
--    ptr_swap = Qobj(swap(), type='super', superrep='choi')
--
--    # Subnormalized maps (representing erasure channels, for instance)
--    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
--
--    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
--        pytest.param(S, True, True, False, id="conjugatio by create op"),
--        pytest.param(S_, False, False, False, id="single off-diag"),
--        pytest.param(identity(2), True, True, True, id="Identity"),
--        pytest.param(sigmax(), True, True, True, id="Pauli X"),
--        pytest.param(
--            tensor(sigmax(), identity(2)), True, True, True,
--            id="bipartite system",
--        ),
--        pytest.param(
--            S_U, True, True, True, id="linear combination of bip. unitaries",
--        ),
--        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
--        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
--        pytest.param(basis(2), False, False, False, id="not an operator"),
--
--    ])
--    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
--        """
--        Superoperator: ishp, iscp, istp and iscptp known cases.
--        """
--        assert qobj.ishp == shouldhp
--        assert qobj.iscp == shouldcp
--        assert qobj.istp == shouldtp
--        assert qobj.iscptp == (shouldcp and shouldtp)
--
--    def test_choi_tr(self, dimension):
--        """
--        Superoperator: Trace returned by to_choi matches docstring.
--        """
--        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
--
--    def test_stinespring_cp(self, dimension):
--        """
--        Stinespring: A and B match for CP maps.
--        """
--        superop = rand_super_bcsz(dimension)
--        A, B = to_stinespring(superop)
--
--        assert (A - B).norm() < tol
--
--    @pytest.mark.repeat(3)
--    def test_stinespring_agrees(self, dimension):
--        """
--        Stinespring: Partial Tr over pair agrees w/ supermatrix.
--        """
--
--        map = rand_super_bcsz(dimension)
--        state = rand_dm(dimension)
--
--        S = to_super(map)
--        A, B = to_stinespring(map)
--
--        q1 = vector_to_operator(
--            S * operator_to_vector(state)
--        )
--        # FIXME: problem if Kraus index is implicitly
--        #        ptraced!
--        q2 = (A * state * B.dag()).ptrace((0,))
--
--        assert (q1 - q2).norm('tr') <= tol
--
--    def test_stinespring_dims(self, dimension):
--        """
--        Stinespring: Check that dims of channels are preserved.
--        """
--        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
--        A, B = to_stinespring(chan)
--        assert A.dims == [[2, dimension, 1], [2, dimension]]
--        assert B.dims == [[2, dimension, 1], [2, dimension]]
--
--    @pytest.mark.parametrize('dimension', [2, 4, 8])
--    def test_chi_choi_roundtrip(self, dimension):
--
--        superop = rand_super_bcsz(dimension)
--        superop = to_chi(superop)
--        rt_superop = to_chi(to_choi(superop))
--        dif = (rt_superop - superop).norm()
--
--        assert dif == pytest.approx(0, abs=1e-7)
--        assert rt_superop.type == superop.type
--        assert rt_superop.dims == superop.dims
--
--    chi_sigmax = [
--        [0, 0, 0, 0],
--        [0, 4, 0, 0],
--        [0, 0, 0, 0],
--        [0, 0, 0, 0]
--    ]
--    chi_diag2 = [
--        [4, 0, 0, 0],
--        [0, 0, 0, 0],
--        [0, 0, 0, 0],
--        [0, 0, 0, 0]
--    ]
--    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
--    chi_rotX_pi_4 = [
--        [2, 2j, 0, 0],
--        [-2j, 2, 0, 0],
--        [0, 0, 0, 0],
--        [0, 0, 0, 0]
--    ]
--
--    @pytest.mark.parametrize(['superop', 'chi_expected'], [
--        pytest.param(sigmax(), chi_sigmax),
--        pytest.param(to_super(sigmax()), chi_sigmax),
--        pytest.param(qeye(2), chi_diag2),
--        pytest.param(rotX_pi_4, chi_rotX_pi_4)
--    ])
--    def test_chi_known(self, superop, chi_expected):
--        """
--        Superoperator: Chi-matrix for known cases is correct.
--        """
--        chi_actual = to_chi(superop)
--        chiq = Qobj(
--            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
--        )
--        assert (chi_actual - chiq).norm() < tol
-+# -*- coding: utf-8 -*-
-+"""
-+Created on Wed May 29 11:23:46 2013
-+
-+@author: dcriger
-+"""
-+
-+from __future__ import division
-+
-+import numpy as np
-+import pytest
-+
-+from qutip import (
-+    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
-+    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
-+    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
-+    vector_to_operator, sprepost, destroy
-+)
-+from qutip.core.gates import swap
-+
-+
-+tol = 1e-8
-+
-+
-+def assert_kraus_equivalence(a, b, tol=tol):
-+    assert a.shape == b.shape
-+    assert a.dims == b.dims
-+    assert a.type == b.type
-+    # Kraus operators may vary by a global phase.  Let's find the first
-+    # non-zero element, set the phase such that that element has the same phase
-+    # in both, and then compare.  We have to take care to find the first
-+    # element.
-+    a, b = a.full(), b.full()
-+    a_nz = np.nonzero(np.abs(a) > tol)
-+    if len(a_nz[0]) == 0:
-+        np.testing.assert_allclose(b, 0, atol=tol)
-+    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
-+    assert b_el != 0
-+    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
-+    np.testing.assert_allclose(a, b)
-+
-+
-+@pytest.fixture(scope="function", params=[2, 3, 7])
-+def dimension(request):
-+    # There are also some cases in the file where this fixture is explicitly
-+    # overridden by a more local mark.  That is deliberate.
-+    return request.param
-+
-+
-+@pytest.fixture(scope="function", params=[
-+    pytest.param(rand_super, id="super"),
-+    pytest.param(rand_super_bcsz, id="super_bcz")
-+])
-+def superoperator(request, dimension):
-+    return request.param(dimension)
-+
-+
-+class TestSuperopReps:
-+    """
-+    A test class for the QuTiP function for applying superoperators to
-+    subsystems.
-+    """
-+
-+    def test_SuperChoiSuper(self, superoperator):
-+        """
-+        Superoperator: Converting superoperator to Choi matrix and back.
-+        """
-+        choi_matrix = to_choi(superoperator)
-+        test_supe = to_super(choi_matrix)
-+
-+        # Assert both that the result is close to expected, and has the right
-+        # type.
-+        assert (test_supe - superoperator).norm() < tol
-+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-+        assert test_supe.type == "super" and test_supe.superrep == "super"
-+
-+    @pytest.mark.parametrize('dimension', [2, 4])
-+    def test_SuperChoiChiSuper(self, dimension):
-+        """
-+        Superoperator: Converting two-qubit superoperator through
-+        Choi and chi representations goes back to right superoperator.
-+        """
-+        superoperator = super_tensor(
-+            rand_super(dimension), rand_super(dimension),
-+        )
-+
-+        choi_matrix = to_choi(superoperator)
-+        chi_matrix = to_chi(choi_matrix)
-+        test_supe = to_super(chi_matrix)
-+
-+        # Assert both that the result is close to expected, and has the right
-+        # type.
-+        assert (test_supe - superoperator).norm() < tol
-+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-+        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
-+        assert test_supe.type == "super" and test_supe.superrep == "super"
-+
-+    def test_ChoiKrausChoi(self, superoperator):
-+        """
-+        Superoperator: Convert superoperator to Choi matrix and back.
-+        """
-+        choi_matrix = to_choi(superoperator)
-+        kraus_ops = to_kraus(choi_matrix)
-+        test_choi = kraus_to_choi(kraus_ops)
-+
-+        # Assert both that the result is close to expected, and has the right
-+        # type.
-+        assert (test_choi - choi_matrix).norm() < tol
-+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-+        assert test_choi.type == "super" and test_choi.superrep == "choi"
-+
-+    def test_NonSquareKrausSuperChoi(self):
-+        """
-+        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
-+        and back.
-+        """
-+        zero = np.array([[1], [0]], dtype=complex)
-+        one = np.array([[0], [1]], dtype=complex)
-+        zero_log = np.kron(np.kron(zero, zero), zero)
-+        one_log = np.kron(np.kron(one, one), one)
-+        # non-square Kraus operator (isometry)
-+        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
-+        super = sprepost(kraus, kraus.dag())
-+        choi = to_choi(super)
-+        op1 = to_kraus(super)
-+        op2 = to_kraus(choi)
-+        op3 = to_super(choi)
-+        assert choi.type == "super" and choi.superrep == "choi"
-+        assert super.type == "super" and super.superrep == "super"
-+        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
-+        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
-+        assert abs((op3 - super).norm()) < 1e-8
-+
-+    def test_NeglectSmallKraus(self):
-+        """
-+        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
-+        Kraus operators.
-+        """
-+        zero = np.array([[1], [0]], dtype=complex)
-+        one = np.array([[0], [1]], dtype=complex)
-+        zero_log = np.kron(np.kron(zero, zero), zero)
-+        one_log = np.kron(np.kron(one, one), one)
-+        # non-square Kraus operator (isometry)
-+        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
-+        super = sprepost(kraus, kraus.dag())
-+        # 1 non-zero Kraus operator the rest are zero
-+        sixteen_kraus_ops = to_kraus(super, tol=0.0)
-+        # default is tol=1e-9
-+        one_kraus_op = to_kraus(super)
-+        assert len(sixteen_kraus_ops) == 16
-+        assert len(one_kraus_op) == 1
-+        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
-+
-+    def test_SuperPreservesSelf(self, superoperator):
-+        """
-+        Superoperator: to_super(q) returns q if q is already a
-+        supermatrix.
-+        """
-+
-+        assert superoperator is to_super(superoperator)
-+
-+    def test_ChoiPreservesSelf(self, superoperator):
-+        """
-+        Superoperator: to_choi(q) returns q if q is already Choi.
-+        """
-+        choi = to_choi(superoperator)
-+        assert choi is to_choi(choi)
-+
-+    def test_random_iscptp(self, superoperator):
-+        """
-+        Superoperator: Randomly generated superoperators are
-+        correctly reported as CPTP and HP.
-+        """
-+        assert superoperator.iscptp
-+        assert superoperator.ishp
-+
-+    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
-+        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
-+        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
-+        pytest.param(qeye(2), True, True, True),
-+        pytest.param(sigmax(), True, True, True),
-+        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
-+        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
-+                            + to_super(tensor(qeye(2), sigmay()))),
-+                     True, True, True,
-+                     id="linear combination of bipartite unitaries"),
-+        pytest.param(Qobj(swap(), type='super', superrep='choi'),
-+                     True, False, True,
-+                     id="partial transpose map"),
-+        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
-+                     id="subnormalized map"),
-+        pytest.param(basis(2, 0), False, False, False, id="ket"),
-+    ])
-+    def test_known_iscptp(self, qobj, hp, cp, tp):
-+        """
-+        Superoperator: ishp, iscp, istp and iscptp known cases.
-+        """
-+        assert qobj.ishp == hp
-+        assert qobj.iscp == cp
-+        assert qobj.istp == tp
-+        assert qobj.iscptp == (cp and tp)
-+
-+    def test_choi_tr(self):
-+        """
-+        Superoperator: Trace returned by to_choi matches docstring.
-+        """
-+        for dims in range(2, 5):
-+            assert abs(to_choi(identity(dims)).tr() - dims) < tol
-+
-+
-+    # Conjugation by a creation operator
-+    a = create(2).dag()
-+    S = sprepost(a, a.dag())
-+
-+    # A single off-diagonal element
-+    S_ = sprepost(a, a)
-+
-+    # Check that a linear combination of bipartite unitaries is CPTP and HP.
-+    S_U = (
-+        to_super(tensor(sigmax(), identity(2))) +
-+        to_super(tensor(identity(2), sigmay()))
-+    ) / 2
-+
-+    # The partial transpose map, whose Choi matrix is SWAP
-+    ptr_swap = Qobj(swap(), type='super', superrep='choi')
-+
-+    # Subnormalized maps (representing erasure channels, for instance)
-+    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
-+
-+    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
-+        pytest.param(S, True, True, False, id="conjugatio by create op"),
-+        pytest.param(S_, False, False, False, id="single off-diag"),
-+        pytest.param(identity(2), True, True, True, id="Identity"),
-+        pytest.param(sigmax(), True, True, True, id="Pauli X"),
-+        pytest.param(
-+            tensor(sigmax(), identity(2)), True, True, True,
-+            id="bipartite system",
-+        ),
-+        pytest.param(
-+            S_U, True, True, True, id="linear combination of bip. unitaries",
-+        ),
-+        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
-+        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
-+        pytest.param(basis(2), False, False, False, id="not an operator"),
-+
-+    ])
-+    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
-+        """
-+        Superoperator: ishp, iscp, istp and iscptp known cases.
-+        """
-+        assert qobj.ishp == shouldhp
-+        assert qobj.iscp == shouldcp
-+        assert qobj.istp == shouldtp
-+        assert qobj.iscptp == (shouldcp and shouldtp)
-+
-+    def test_choi_tr(self, dimension):
-+        """
-+        Superoperator: Trace returned by to_choi matches docstring.
-+        """
-+        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
-+
-+    def test_stinespring_cp(self, dimension):
-+        """
-+        Stinespring: A and B match for CP maps.
-+        """
-+        superop = rand_super_bcsz(dimension)
-+        A, B = to_stinespring(superop)
-+
-+        assert (A - B).norm() < tol
-+
-+    @pytest.mark.repeat(3)
-+    def test_stinespring_agrees(self, dimension):
-+        """
-+        Stinespring: Partial Tr over pair agrees w/ supermatrix.
-+        """
-+
-+        map = rand_super_bcsz(dimension)
-+        state = rand_dm(dimension)
-+
-+        S = to_super(map)
-+        A, B = to_stinespring(map)
-+
-+        q1 = vector_to_operator(
-+            S * operator_to_vector(state)
-+        )
-+        # FIXME: problem if Kraus index is implicitly
-+        #        ptraced!
-+        q2 = (A * state * B.dag()).ptrace((0,))
-+
-+        assert (q1 - q2).norm('tr') <= tol
-+
-+    def test_stinespring_dims(self, dimension):
-+        """
-+        Stinespring: Check that dims of channels are preserved.
-+        """
-+        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
-+        A, B = to_stinespring(chan)
-+        assert A.dims == [[2, dimension, 1], [2, dimension]]
-+        assert B.dims == [[2, dimension, 1], [2, dimension]]
-+
-+    @pytest.mark.parametrize('dimension', [2, 4, 8])
-+    def test_chi_choi_roundtrip(self, dimension):
-+
-+        superop = rand_super_bcsz(dimension)
-+        superop = to_chi(superop)
-+        rt_superop = to_chi(to_choi(superop))
-+        dif = (rt_superop - superop).norm()
-+
-+        assert dif == pytest.approx(0, abs=1e-7)
-+        assert rt_superop.type == superop.type
-+        assert rt_superop.dims == superop.dims
-+
-+    chi_sigmax = [
-+        [0, 0, 0, 0],
-+        [0, 4, 0, 0],
-+        [0, 0, 0, 0],
-+        [0, 0, 0, 0]
-+    ]
-+    chi_diag2 = [
-+        [4, 0, 0, 0],
-+        [0, 0, 0, 0],
-+        [0, 0, 0, 0],
-+        [0, 0, 0, 0]
-+    ]
-+    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
-+    chi_rotX_pi_4 = [
-+        [2, 2j, 0, 0],
-+        [-2j, 2, 0, 0],
-+        [0, 0, 0, 0],
-+        [0, 0, 0, 0]
-+    ]
-+
-+    @pytest.mark.parametrize(['superop', 'chi_expected'], [
-+        pytest.param(sigmax(), chi_sigmax),
-+        pytest.param(to_super(sigmax()), chi_sigmax),
-+        pytest.param(qeye(2), chi_diag2),
-+        pytest.param(rotX_pi_4, chi_rotX_pi_4)
-+    ])
-+    def test_chi_known(self, superop, chi_expected):
-+        """
-+        Superoperator: Chi-matrix for known cases is correct.
-+        """
-+        chi_actual = to_chi(superop)
-+        chiq = Qobj(
-+            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
-+        )
-+        assert (chi_actual - chiq).norm() < tol
-diff --git a/qutip/tests/core/test_superoper.py b/qutip/tests/core/test_superoper.py
-index b5ba6fd1..bbeeb682 100644
---- a/qutip/tests/core/test_superoper.py
-+++ b/qutip/tests/core/test_superoper.py
-@@ -1,269 +1,269 @@
--import numpy as np
--import scipy.linalg
--
--import qutip
--from qutip.core import data as _data
--import pytest
--
--
--def f(t, args):
--    return t * (1 - 0.5j)
--
--
--def liouvillian_ref(H, c_ops=()):
--    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
--    for c in c_ops:
--        if c.issuper:
--            L += c
--        else:
--            cdc = c.dag() * c
--            L += qutip.sprepost(c, c.dag())
--            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
--    return L
--
--
--class TestMatVec:
--    """
--    A test class for the QuTiP function for matrix/vector conversion.
--    """
--    def testOperatorVector(self):
--        """
--        Superoperator: Operator - vector - operator conversion.
--        """
--        N = 3
--        rho1 = qutip.rand_dm(N)
--        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
--        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
--
--    def testsuperrep(self):
--        N = 3
--        rho1 = qutip.rand_dm(N)
--        as_vec = qutip.operator_to_vector(rho1)
--        assert as_vec.superrep == 'super'
--
--        with pytest.raises(TypeError) as err:
--            bad_vec = as_vec.copy()
--            bad_vec.superrep = ""
--            qutip.vector_to_operator(bad_vec)
--        assert err.value.args[0] == ("only defined for operator-kets "
--                                     "in super format")
--
--        with pytest.raises(TypeError) as err:
--            qutip.operator_to_vector(as_vec)
--        assert err.value.args[0] == ("Cannot convert object already "
--                                     "in super representation")
--
--    def testOperatorVectorTensor(self):
--        """
--        Superoperator: Operator - vector - operator conversion with a tensor
--        product state.
--        """
--        Na = 3
--        Nb = 2
--        rhoa = qutip.rand_dm(Na)
--        rhob = qutip.rand_dm(Nb)
--        rho1 = qutip.tensor(rhoa, rhob)
--        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
--        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
--
--    def testOperatorVectorNotSquare(self):
--        """
--        Superoperator: Operator - vector - operator conversion for non-square
--        matrix.
--        """
--        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
--        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
--        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
--
--    def testOperatorSpreAppl(self):
--        """
--        Superoperator: apply operator and superoperator from left (spre)
--        """
--        N = 3
--        rho = qutip.rand_dm(N)
--        U = qutip.rand_unitary(N)
--        rho1 = U * rho
--        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
--        rho2 = qutip.vector_to_operator(rho2_vec)
--        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
--
--    def testOperatorSpostAppl(self):
--        """
--        Superoperator: apply operator and superoperator from right (spost)
--        """
--        N = 3
--        rho = qutip.rand_dm(N)
--        U = qutip.rand_unitary(N)
--        rho1 = rho * U
--        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
--        rho2 = qutip.vector_to_operator(rho2_vec)
--        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
--
--    def testOperatorUnitaryTransform(self):
--        """
--        Superoperator: Unitary transformation with operators and superoperators
--        """
--        N = 3
--        rho = qutip.rand_dm(N)
--        U = qutip.rand_unitary(N)
--        rho1 = U * rho * U.dag()
--        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
--        rho2 = qutip.vector_to_operator(rho2_vec)
--        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
--
--    def testMatrixVecMat(self):
--        """
--        Superoperator: Conversion matrix to vector to matrix
--        """
--        M = _data.create(np.random.rand(10, 10))
--        V = qutip.stack_columns(M)
--        M2 = qutip.unstack_columns(V)
--        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
--
--    def testVecMatVec(self):
--        """
--        Superoperator: Conversion vector to matrix to vector
--        """
--        V = _data.create(np.random.rand(100, 1))
--        M = qutip.unstack_columns(V)
--        V2 = qutip.stack_columns(M)
--        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
--
--    def testVecMatIndexConversion(self):
--        """
--        Superoperator: Conversion between matrix and vector indices
--        """
--        N = 10
--        for i in range(N * N):
--            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
--
--    def testVecMatIndexCompability(self):
--        """
--        Superoperator: Compatibility between matrix/vector and
--        corresponding index conversions.
--        """
--        N = 10
--        M = _data.create(np.random.rand(N, N))
--        V = qutip.stack_columns(M)
--        for idx in range(N * N):
--            i, j = qutip.unstacked_index(N, idx)
--            assert V.to_array()[idx, 0] == M.to_array()[i, j]
--
--    def test_reshuffle(self):
--        U1 = qutip.rand_unitary(2)
--        U2 = qutip.rand_unitary(3)
--        U3 = qutip.rand_unitary(4)
--        U = qutip.tensor(U1, U2, U3)
--        S = qutip.to_super(U)
--        S_col = qutip.reshuffle(S)
--        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
--        assert qutip.reshuffle(S_col) == S
--
--    def test_sprepost(self):
--        U1 = qutip.rand_unitary(3)
--        U2 = qutip.rand_unitary(3)
--        S1 = qutip.spre(U1) * qutip.spost(U2)
--        S2 = qutip.sprepost(U1, U2)
--        assert S1 == S2
--
--    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
--    @pytest.mark.parametrize("operation", [qutip.spre,
--                                           qutip.spost,
--                                           qutip.liouvillian,
--                                           qutip.lindblad_dissipator])
--    def test_operation_dtype(self, dtype, operation):
--        """This test checks that the dtype is properly kept with the
--        `operation` function."""
--        U1 = qutip.rand_unitary(3).to(dtype)
--        result = operation(U1)
--        assert type(result.data) == dtype
--
--    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
--    def test_sprepost_dtype(self, dtype):
--        """This test checks that the dtype is properly kept with `sprepost`
--        function."""
--        U1 = qutip.rand_unitary(3).to(dtype)
--        result = qutip.sprepost(U1, U1)
--        assert type(result.data) == dtype
--
--    def testLiouvillianImplem(self):
--        """
--        Superoperator: Randomized comparison of standard and reference
--        Liouvillian functions.
--        """
--        N1, N2, N3 = 3, 4, 5
--        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
--                          qutip.qeye([N2, N3]))
--        a2 = qutip.tensor(qutip.qeye(N1),
--                          qutip.rand_dm(N2, density=0.75),
--                          qutip.qeye(N3))
--        a3 = qutip.tensor(qutip.qeye([N1, N2]),
--                          qutip.rand_dm(N3, density=0.75))
--        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
--        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
--        L1 = qutip.liouvillian(H, c_ops)
--        L2 = liouvillian_ref(H, c_ops)
--        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
--
--
--class TestSuper_td:
--    """
--    A test class for the QuTiP superoperator functions.
--    """
--    N = 3
--    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
--                        [qutip.create(N) * (1 - 0.1j), f]])
--    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
--    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
--    q1 = qutip.qeye(N) * (1 + 0.3j)
--    q2 = qutip.destroy(N) * (1 - 0.3j)
--    q3 = qutip.num(N) * (1 + 0.4j)
--
--    def test_spre_td(self):
--        "Superoperator: spre, time-dependent"
--        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
--
--    def test_spost_td(self):
--        "Superoperator: spre, time-dependent"
--        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
--
--    def test_sprepost_td(self):
--        "Superoperator: sprepost, time-dependent"
--        # left QobjEvo
--        assert (qutip.sprepost(self.t1, self.q2)(0.5)
--                == qutip.sprepost(self.t1(0.5), self.q2))
--        # left QobjEvo
--        assert (qutip.sprepost(self.q2, self.t1)(0.5)
--                == qutip.sprepost(self.q2, self.t1(0.5)))
--        # left 2 QobjEvo, one cte
--        assert (qutip.sprepost(self.t1, self.t2)(0.5)
--                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
--
--    def test_operator_vector_td(self):
--        "Superoperator: operator_to_vector, time-dependent"
--        assert (qutip.operator_to_vector(self.t1)(0.5)
--                == qutip.operator_to_vector(self.t1(0.5)))
--        vec = qutip.operator_to_vector(self.t1)
--        assert (qutip.vector_to_operator(vec)(0.5)
--                == qutip.vector_to_operator(vec(0.5)))
--
--    def test_liouvillian_td(self):
--        "Superoperator: liouvillian, time-dependent"
--        assert (qutip.liouvillian(self.t1)(0.5)
--                == qutip.liouvillian(self.t1(0.5)))
--        assert (qutip.liouvillian(None, [self.t2])(0.5)
--                == qutip.liouvillian(None, [self.t2(0.5)]))
--        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
--                                  chi=[1, 2, 3])(0.5)
--                == qutip.liouvillian(self.t1(0.5),
--                                     [self.t2(0.5), self.q1, self.t3(0.5)],
--                                     chi=[1, 2, 3]))
--
--    def test_lindblad_dissipator_td(self):
--        "Superoperator: lindblad_dissipator, time-dependent"
--        assert (qutip.lindblad_dissipator(self.t2)(0.5)
--                == qutip.lindblad_dissipator(self.t2(0.5)))
--        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
--                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
--        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
--                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
-+import numpy as np
-+import scipy.linalg
-+
-+import qutip
-+from qutip.core import data as _data
-+import pytest
-+
-+
-+def f(t, args):
-+    return t * (1 - 0.5j)
-+
-+
-+def liouvillian_ref(H, c_ops=()):
-+    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
-+    for c in c_ops:
-+        if c.issuper:
-+            L += c
-+        else:
-+            cdc = c.dag() * c
-+            L += qutip.sprepost(c, c.dag())
-+            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
-+    return L
-+
-+
-+class TestMatVec:
-+    """
-+    A test class for the QuTiP function for matrix/vector conversion.
-+    """
-+    def testOperatorVector(self):
-+        """
-+        Superoperator: Operator - vector - operator conversion.
-+        """
-+        N = 3
-+        rho1 = qutip.rand_dm(N)
-+        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
-+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-+
-+    def testsuperrep(self):
-+        N = 3
-+        rho1 = qutip.rand_dm(N)
-+        as_vec = qutip.operator_to_vector(rho1)
-+        assert as_vec.superrep == 'super'
-+
-+        with pytest.raises(TypeError) as err:
-+            bad_vec = as_vec.copy()
-+            bad_vec.superrep = ""
-+            qutip.vector_to_operator(bad_vec)
-+        assert err.value.args[0] == ("only defined for operator-kets "
-+                                     "in super format")
-+
-+        with pytest.raises(TypeError) as err:
-+            qutip.operator_to_vector(as_vec)
-+        assert err.value.args[0] == ("Cannot convert object already "
-+                                     "in super representation")
-+
-+    def testOperatorVectorTensor(self):
-+        """
-+        Superoperator: Operator - vector - operator conversion with a tensor
-+        product state.
-+        """
-+        Na = 3
-+        Nb = 2
-+        rhoa = qutip.rand_dm(Na)
-+        rhob = qutip.rand_dm(Nb)
-+        rho1 = qutip.tensor(rhoa, rhob)
-+        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
-+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-+
-+    def testOperatorVectorNotSquare(self):
-+        """
-+        Superoperator: Operator - vector - operator conversion for non-square
-+        matrix.
-+        """
-+        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
-+        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
-+        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
-+
-+    def testOperatorSpreAppl(self):
-+        """
-+        Superoperator: apply operator and superoperator from left (spre)
-+        """
-+        N = 3
-+        rho = qutip.rand_dm(N)
-+        U = qutip.rand_unitary(N)
-+        rho1 = U * rho
-+        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
-+        rho2 = qutip.vector_to_operator(rho2_vec)
-+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-+
-+    def testOperatorSpostAppl(self):
-+        """
-+        Superoperator: apply operator and superoperator from right (spost)
-+        """
-+        N = 3
-+        rho = qutip.rand_dm(N)
-+        U = qutip.rand_unitary(N)
-+        rho1 = rho * U
-+        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
-+        rho2 = qutip.vector_to_operator(rho2_vec)
-+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-+
-+    def testOperatorUnitaryTransform(self):
-+        """
-+        Superoperator: Unitary transformation with operators and superoperators
-+        """
-+        N = 3
-+        rho = qutip.rand_dm(N)
-+        U = qutip.rand_unitary(N)
-+        rho1 = U * rho * U.dag()
-+        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
-+        rho2 = qutip.vector_to_operator(rho2_vec)
-+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-+
-+    def testMatrixVecMat(self):
-+        """
-+        Superoperator: Conversion matrix to vector to matrix
-+        """
-+        M = _data.create(np.random.rand(10, 10))
-+        V = qutip.stack_columns(M)
-+        M2 = qutip.unstack_columns(V)
-+        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
-+
-+    def testVecMatVec(self):
-+        """
-+        Superoperator: Conversion vector to matrix to vector
-+        """
-+        V = _data.create(np.random.rand(100, 1))
-+        M = qutip.unstack_columns(V)
-+        V2 = qutip.stack_columns(M)
-+        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
-+
-+    def testVecMatIndexConversion(self):
-+        """
-+        Superoperator: Conversion between matrix and vector indices
-+        """
-+        N = 10
-+        for i in range(N * N):
-+            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
-+
-+    def testVecMatIndexCompability(self):
-+        """
-+        Superoperator: Compatibility between matrix/vector and
-+        corresponding index conversions.
-+        """
-+        N = 10
-+        M = _data.create(np.random.rand(N, N))
-+        V = qutip.stack_columns(M)
-+        for idx in range(N * N):
-+            i, j = qutip.unstacked_index(N, idx)
-+            assert V.to_array()[idx, 0] == M.to_array()[i, j]
-+
-+    def test_reshuffle(self):
-+        U1 = qutip.rand_unitary(2)
-+        U2 = qutip.rand_unitary(3)
-+        U3 = qutip.rand_unitary(4)
-+        U = qutip.tensor(U1, U2, U3)
-+        S = qutip.to_super(U)
-+        S_col = qutip.reshuffle(S)
-+        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
-+        assert qutip.reshuffle(S_col) == S
-+
-+    def test_sprepost(self):
-+        U1 = qutip.rand_unitary(3)
-+        U2 = qutip.rand_unitary(3)
-+        S1 = qutip.spre(U1) * qutip.spost(U2)
-+        S2 = qutip.sprepost(U1, U2)
-+        assert S1 == S2
-+
-+    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
-+    @pytest.mark.parametrize("operation", [qutip.spre,
-+                                           qutip.spost,
-+                                           qutip.liouvillian,
-+                                           qutip.lindblad_dissipator])
-+    def test_operation_dtype(self, dtype, operation):
-+        """This test checks that the dtype is properly kept with the
-+        `operation` function."""
-+        U1 = qutip.rand_unitary(3).to(dtype)
-+        result = operation(U1)
-+        assert type(result.data) == dtype
-+
-+    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
-+    def test_sprepost_dtype(self, dtype):
-+        """This test checks that the dtype is properly kept with `sprepost`
-+        function."""
-+        U1 = qutip.rand_unitary(3).to(dtype)
-+        result = qutip.sprepost(U1, U1)
-+        assert type(result.data) == dtype
-+
-+    def testLiouvillianImplem(self):
-+        """
-+        Superoperator: Randomized comparison of standard and reference
-+        Liouvillian functions.
-+        """
-+        N1, N2, N3 = 3, 4, 5
-+        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
-+                          qutip.qeye([N2, N3]))
-+        a2 = qutip.tensor(qutip.qeye(N1),
-+                          qutip.rand_dm(N2, density=0.75),
-+                          qutip.qeye(N3))
-+        a3 = qutip.tensor(qutip.qeye([N1, N2]),
-+                          qutip.rand_dm(N3, density=0.75))
-+        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
-+        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
-+        L1 = qutip.liouvillian(H, c_ops)
-+        L2 = liouvillian_ref(H, c_ops)
-+        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
-+
-+
-+class TestSuper_td:
-+    """
-+    A test class for the QuTiP superoperator functions.
-+    """
-+    N = 3
-+    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
-+                        [qutip.create(N) * (1 - 0.1j), f]])
-+    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
-+    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
-+    q1 = qutip.qeye(N) * (1 + 0.3j)
-+    q2 = qutip.destroy(N) * (1 - 0.3j)
-+    q3 = qutip.num(N) * (1 + 0.4j)
-+
-+    def test_spre_td(self):
-+        "Superoperator: spre, time-dependent"
-+        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
-+
-+    def test_spost_td(self):
-+        "Superoperator: spre, time-dependent"
-+        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
-+
-+    def test_sprepost_td(self):
-+        "Superoperator: sprepost, time-dependent"
-+        # left QobjEvo
-+        assert (qutip.sprepost(self.t1, self.q2)(0.5)
-+                == qutip.sprepost(self.t1(0.5), self.q2))
-+        # left QobjEvo
-+        assert (qutip.sprepost(self.q2, self.t1)(0.5)
-+                == qutip.sprepost(self.q2, self.t1(0.5)))
-+        # left 2 QobjEvo, one cte
-+        assert (qutip.sprepost(self.t1, self.t2)(0.5)
-+                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
-+
-+    def test_operator_vector_td(self):
-+        "Superoperator: operator_to_vector, time-dependent"
-+        assert (qutip.operator_to_vector(self.t1)(0.5)
-+                == qutip.operator_to_vector(self.t1(0.5)))
-+        vec = qutip.operator_to_vector(self.t1)
-+        assert (qutip.vector_to_operator(vec)(0.5)
-+                == qutip.vector_to_operator(vec(0.5)))
-+
-+    def test_liouvillian_td(self):
-+        "Superoperator: liouvillian, time-dependent"
-+        assert (qutip.liouvillian(self.t1)(0.5)
-+                == qutip.liouvillian(self.t1(0.5)))
-+        assert (qutip.liouvillian(None, [self.t2])(0.5)
-+                == qutip.liouvillian(None, [self.t2(0.5)]))
-+        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
-+                                  chi=[1, 2, 3])(0.5)
-+                == qutip.liouvillian(self.t1(0.5),
-+                                     [self.t2(0.5), self.q1, self.t3(0.5)],
-+                                     chi=[1, 2, 3]))
-+
-+    def test_lindblad_dissipator_td(self):
-+        "Superoperator: lindblad_dissipator, time-dependent"
-+        assert (qutip.lindblad_dissipator(self.t2)(0.5)
-+                == qutip.lindblad_dissipator(self.t2(0.5)))
-+        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
-+                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
-+        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
-+                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
-diff --git a/qutip/tests/core/test_tensor.py b/qutip/tests/core/test_tensor.py
-index 10e493e4..41ba5672 100644
---- a/qutip/tests/core/test_tensor.py
-+++ b/qutip/tests/core/test_tensor.py
-@@ -1,257 +1,257 @@
--import numpy as np
--
--from numpy.testing import assert_equal, assert_
--import pytest
--import functools
--import itertools
--import qutip
--from qutip import (
--    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
--    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
--    expand_operator
--)
--
--
--def test_tensor_contract_ident():
--    qobj = identity([2, 3, 4])
--    ans = 3 * identity([2, 4])
--
--    assert_(ans == tensor_contract(qobj, (1, 4)))
--
--    # Now try for superoperators.
--    # For now, we just ensure the dims are correct.
--    sqobj = to_super(qobj)
--    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
--    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
--
--
--def case_tensor_contract_other(left, right, pairs,
--                               expected_dims, expected_data):
--    dat = np.arange(np.prod(left) * np.prod(right))
--    dat = dat.reshape((np.prod(left), np.prod(right)))
--
--    qobj = Qobj(dat, dims=[left, right])
--    cqobj = tensor_contract(qobj, *pairs)
--    assert_equal(cqobj.dims, expected_dims)
--    assert_equal(cqobj.full(), expected_data)
--
--
--def test_tensor_contract_other():
--    case_tensor_contract_other(
--        [2, 3], [3, 4], [(1, 2)],
--        [[2], [4]],
--        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
--    )
--
--    case_tensor_contract_other(
--        [2, 3], [4, 3], [(1, 3)],
--        [[2], [4]],
--        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
--    )
--
--    case_tensor_contract_other(
--        [2, 3], [4, 3], [(1, 3)],
--        [[2], [4]],
--        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
--    )
--
--    # Make non-rectangular outputs in a column-/row-symmetric fashion.
--    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
--
--    case_tensor_contract_other(
--        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
--        [[[3], [3]], [[2, 3], [2, 3]]],
--        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
--
--    case_tensor_contract_other(
--        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
--        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
--        # We separate einsum into two calls due to a bug internal to
--        # einsum.
--        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
--
--    # Now we try collapsing in a way that's sensitive to column- and row-
--    # stacking conventions.
--    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
--    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
--    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
--    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
--
--    # Let's try a weird tensor contraction; this will likely never come up in
--    # practice, but it should serve as a good canary for more reasonable
--    # contractions.
--    case_tensor_contract_other(
--        big_dims[0], big_dims[1], [(0, 4)],
--        [[[2], [3, 3]], [[3], [2, 3]]],
--        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
--
--
--def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
--    sqobj = tensor_swap(qobj, *pairs)
--
--    assert_equal(sqobj.dims, expected_dims)
--    assert_equal(sqobj.full(), expected_data.full())
--
--
--def test_tensor_swap_other():
--    dims = (2, 3, 4, 5, 7)
--    for dim in dims:
--        S = to_super(rand_super_bcsz(dim))
--        # Swapping the inner indices on a superoperator should give a Choi
--        # matrix.
--        J = to_choi(S)
--        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
--
--
--def test_tensor_qobjevo():
--    N = 5
--    t = 1.5
--    left = QobjEvo([num(N),[destroy(N),"t"]])
--    right = QobjEvo([identity(2),[sigmax(),"t"]])
--    assert tensor(left, right)(t) == tensor(left(t), right(t))
--    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
--    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
--
--
--def test_tensor_qobjevo_non_square():
--    N = 5
--    t = 1.5
--    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
--    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
--    assert tensor(left, right)(t) == tensor(left(t), right(t))
--
--
--def test_tensor_qobjevo_multiple():
--    N = 5
--    t = 1.5
--    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
--    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
--    right = QobjEvo([sigmax()])
--    as_QobjEvo = tensor(left, center, right)(t)
--    as_Qobj = tensor(left(t), center(t), right(t))
--    assert as_QobjEvo == as_Qobj
--
--
--def test_tensor_and():
--    N = 5
--    t = 1.5
--    sx = sigmax()
--    evo = QobjEvo([num(N),[destroy(N),"t"]])
--    assert tensor([sx, sx, sx]) == sx & sx & sx
--    assert tensor(evo, sx)(t) == (evo & sx)(t)
--    assert tensor(sx, evo)(t) == (sx & evo)(t)
--    assert tensor(evo, evo)(t) == (evo & evo)(t)
--
--
--def _permutation_id(permutation):
--    return str(len(permutation)) + "-" + "".join(map(str, permutation))
--
--
--def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
--    """
--    Create a full tensor product when a subspace component is already in an
--    entangled state.  The locations in `all_qubits` which are the entangled
--    points in the output are ignored and can take any value.
--
--    For example,
--        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
--    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
--    in the final output are entangled, but the others are still separable.
--
--    Parameters:
--        all_qubits: list of kets --
--            A list of separable parts to tensor together.  States that are in
--            the locations referred to by `entangled_locations` are completely
--            ignored.
--        entangled: tensor-product ket -- the full entangled subspace
--        entangled_locations: list of int --
--            The locations that the qubits in the entangled subspace should be
--            in in the final tensor-product space.
--    """
--    n_entangled = len(entangled.dims[0])
--    n_separable = len(all_qubits) - n_entangled
--    separable = all_qubits.copy()
--    # Remove in reverse order so subsequent deletion locations don't change.
--    for location in sorted(entangled_locations, reverse=True):
--        del separable[location]
--    # Can't separate out entangled states to pass to tensor in the right places
--    # immediately, so tensor in at one end and then permute into place.
--    out = qutip.tensor(*separable, entangled)
--    permutation = list(range(n_separable))
--    current_locations = range(n_separable, n_separable + n_entangled)
--    # Sort to prevert later insertions changing previous locations.
--    insertions = sorted(zip(entangled_locations, current_locations),
--                        key=lambda x: x[0])
--    for out_location, current_location in insertions:
--        permutation.insert(out_location, current_location)
--    return out.permute(permutation)
--
--
--def _apply_permutation(permutation):
--    """
--    Permute the given permutation into the order denoted by its elements, i.e.
--        out[0] = permutation[permutation[0]]
--        out[1] = permutation[permutation[1]]
--        ...
--
--    This function is its own inverse.
--    """
--    out = [None] * len(permutation)
--    for value, location in enumerate(permutation):
--        out[location] = value
--    return out
--
--
--class Test_expand_operator:
--    @pytest.mark.parametrize(
--        'permutation',
--        tuple(itertools.chain(*[
--            itertools.permutations(range(k)) for k in [2, 3, 4]
--        ])),
--        ids=_permutation_id)
--    def test_permutation_without_expansion(self, permutation):
--        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
--        test = expand_operator(base, [2] * len(permutation), permutation)
--        expected = base.permute(_apply_permutation(permutation))
--        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
--
--    @pytest.mark.parametrize('n_targets', range(1, 5))
--    def test_general_qubit_expansion(self, n_targets):
--        # Test all permutations with the given number of targets.
--        n_qubits = 5
--        operation = qutip.rand_unitary([2]*n_targets)
--        for targets in itertools.permutations(range(n_qubits), n_targets):
--            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
--                                                 operation, targets)
--            test = expand_operator(operation, [2] * 5, targets)
--            np.testing.assert_allclose(test.full(), expected.full(),
--                                       atol=1e-15)
--
--    def test_cnot_explicit(self):
--        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
--        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
--                             [0, 0, 0, 0, 0, 1, 0, 0],
--                             [0, 0, 1, 0, 0, 0, 0, 0],
--                             [0, 0, 0, 0, 0, 0, 0, 1],
--                             [0, 0, 0, 0, 1, 0, 0, 0],
--                             [0, 1, 0, 0, 0, 0, 0, 0],
--                             [0, 0, 0, 0, 0, 0, 1, 0],
--                             [0, 0, 0, 1, 0, 0, 0, 0]])
--        np.testing.assert_allclose(test, expected, atol=1e-15)
--
--    @pytest.mark.parametrize('dimensions', [
--        pytest.param([3, 4, 5], id="standard"),
--        pytest.param([3, 3, 4, 4, 2], id="standard"),
--        pytest.param([1, 2, 3], id="1D space"),
--    ])
--    def test_non_qubit_systems(self, dimensions):
--        n_qubits = len(dimensions)
--        for targets in itertools.permutations(range(n_qubits), 2):
--            operators = [qutip.rand_unitary(dimension) if n in targets
--                         else qutip.qeye(dimension)
--                         for n, dimension in enumerate(dimensions)]
--            expected = qutip.tensor(*operators)
--            base_test = qutip.tensor(*[operators[x] for x in targets])
--            test = expand_operator(base_test, dims=dimensions, targets=targets)
--            assert test.dims == expected.dims
--            np.testing.assert_allclose(test.full(), expected.full())
-+import numpy as np
-+
-+from numpy.testing import assert_equal, assert_
-+import pytest
-+import functools
-+import itertools
-+import qutip
-+from qutip import (
-+    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
-+    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
-+    expand_operator
-+)
-+
-+
-+def test_tensor_contract_ident():
-+    qobj = identity([2, 3, 4])
-+    ans = 3 * identity([2, 4])
-+
-+    assert_(ans == tensor_contract(qobj, (1, 4)))
-+
-+    # Now try for superoperators.
-+    # For now, we just ensure the dims are correct.
-+    sqobj = to_super(qobj)
-+    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
-+    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
-+
-+
-+def case_tensor_contract_other(left, right, pairs,
-+                               expected_dims, expected_data):
-+    dat = np.arange(np.prod(left) * np.prod(right))
-+    dat = dat.reshape((np.prod(left), np.prod(right)))
-+
-+    qobj = Qobj(dat, dims=[left, right])
-+    cqobj = tensor_contract(qobj, *pairs)
-+    assert_equal(cqobj.dims, expected_dims)
-+    assert_equal(cqobj.full(), expected_data)
-+
-+
-+def test_tensor_contract_other():
-+    case_tensor_contract_other(
-+        [2, 3], [3, 4], [(1, 2)],
-+        [[2], [4]],
-+        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
-+    )
-+
-+    case_tensor_contract_other(
-+        [2, 3], [4, 3], [(1, 3)],
-+        [[2], [4]],
-+        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
-+    )
-+
-+    case_tensor_contract_other(
-+        [2, 3], [4, 3], [(1, 3)],
-+        [[2], [4]],
-+        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
-+    )
-+
-+    # Make non-rectangular outputs in a column-/row-symmetric fashion.
-+    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
-+
-+    case_tensor_contract_other(
-+        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
-+        [[[3], [3]], [[2, 3], [2, 3]]],
-+        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
-+
-+    case_tensor_contract_other(
-+        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
-+        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
-+        # We separate einsum into two calls due to a bug internal to
-+        # einsum.
-+        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
-+
-+    # Now we try collapsing in a way that's sensitive to column- and row-
-+    # stacking conventions.
-+    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
-+    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
-+    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
-+    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
-+
-+    # Let's try a weird tensor contraction; this will likely never come up in
-+    # practice, but it should serve as a good canary for more reasonable
-+    # contractions.
-+    case_tensor_contract_other(
-+        big_dims[0], big_dims[1], [(0, 4)],
-+        [[[2], [3, 3]], [[3], [2, 3]]],
-+        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
-+
-+
-+def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
-+    sqobj = tensor_swap(qobj, *pairs)
-+
-+    assert_equal(sqobj.dims, expected_dims)
-+    assert_equal(sqobj.full(), expected_data.full())
-+
-+
-+def test_tensor_swap_other():
-+    dims = (2, 3, 4, 5, 7)
-+    for dim in dims:
-+        S = to_super(rand_super_bcsz(dim))
-+        # Swapping the inner indices on a superoperator should give a Choi
-+        # matrix.
-+        J = to_choi(S)
-+        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
-+
-+
-+def test_tensor_qobjevo():
-+    N = 5
-+    t = 1.5
-+    left = QobjEvo([num(N),[destroy(N),"t"]])
-+    right = QobjEvo([identity(2),[sigmax(),"t"]])
-+    assert tensor(left, right)(t) == tensor(left(t), right(t))
-+    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
-+    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
-+
-+
-+def test_tensor_qobjevo_non_square():
-+    N = 5
-+    t = 1.5
-+    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
-+    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
-+    assert tensor(left, right)(t) == tensor(left(t), right(t))
-+
-+
-+def test_tensor_qobjevo_multiple():
-+    N = 5
-+    t = 1.5
-+    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
-+    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
-+    right = QobjEvo([sigmax()])
-+    as_QobjEvo = tensor(left, center, right)(t)
-+    as_Qobj = tensor(left(t), center(t), right(t))
-+    assert as_QobjEvo == as_Qobj
-+
-+
-+def test_tensor_and():
-+    N = 5
-+    t = 1.5
-+    sx = sigmax()
-+    evo = QobjEvo([num(N),[destroy(N),"t"]])
-+    assert tensor([sx, sx, sx]) == sx & sx & sx
-+    assert tensor(evo, sx)(t) == (evo & sx)(t)
-+    assert tensor(sx, evo)(t) == (sx & evo)(t)
-+    assert tensor(evo, evo)(t) == (evo & evo)(t)
-+
-+
-+def _permutation_id(permutation):
-+    return str(len(permutation)) + "-" + "".join(map(str, permutation))
-+
-+
-+def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
-+    """
-+    Create a full tensor product when a subspace component is already in an
-+    entangled state.  The locations in `all_qubits` which are the entangled
-+    points in the output are ignored and can take any value.
-+
-+    For example,
-+        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
-+    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
-+    in the final output are entangled, but the others are still separable.
-+
-+    Parameters:
-+        all_qubits: list of kets --
-+            A list of separable parts to tensor together.  States that are in
-+            the locations referred to by `entangled_locations` are completely
-+            ignored.
-+        entangled: tensor-product ket -- the full entangled subspace
-+        entangled_locations: list of int --
-+            The locations that the qubits in the entangled subspace should be
-+            in in the final tensor-product space.
-+    """
-+    n_entangled = len(entangled.dims[0])
-+    n_separable = len(all_qubits) - n_entangled
-+    separable = all_qubits.copy()
-+    # Remove in reverse order so subsequent deletion locations don't change.
-+    for location in sorted(entangled_locations, reverse=True):
-+        del separable[location]
-+    # Can't separate out entangled states to pass to tensor in the right places
-+    # immediately, so tensor in at one end and then permute into place.
-+    out = qutip.tensor(*separable, entangled)
-+    permutation = list(range(n_separable))
-+    current_locations = range(n_separable, n_separable + n_entangled)
-+    # Sort to prevert later insertions changing previous locations.
-+    insertions = sorted(zip(entangled_locations, current_locations),
-+                        key=lambda x: x[0])
-+    for out_location, current_location in insertions:
-+        permutation.insert(out_location, current_location)
-+    return out.permute(permutation)
-+
-+
-+def _apply_permutation(permutation):
-+    """
-+    Permute the given permutation into the order denoted by its elements, i.e.
-+        out[0] = permutation[permutation[0]]
-+        out[1] = permutation[permutation[1]]
-+        ...
-+
-+    This function is its own inverse.
-+    """
-+    out = [None] * len(permutation)
-+    for value, location in enumerate(permutation):
-+        out[location] = value
-+    return out
-+
-+
-+class Test_expand_operator:
-+    @pytest.mark.parametrize(
-+        'permutation',
-+        tuple(itertools.chain(*[
-+            itertools.permutations(range(k)) for k in [2, 3, 4]
-+        ])),
-+        ids=_permutation_id)
-+    def test_permutation_without_expansion(self, permutation):
-+        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
-+        test = expand_operator(base, [2] * len(permutation), permutation)
-+        expected = base.permute(_apply_permutation(permutation))
-+        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
-+
-+    @pytest.mark.parametrize('n_targets', range(1, 5))
-+    def test_general_qubit_expansion(self, n_targets):
-+        # Test all permutations with the given number of targets.
-+        n_qubits = 5
-+        operation = qutip.rand_unitary([2]*n_targets)
-+        for targets in itertools.permutations(range(n_qubits), n_targets):
-+            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
-+                                                 operation, targets)
-+            test = expand_operator(operation, [2] * 5, targets)
-+            np.testing.assert_allclose(test.full(), expected.full(),
-+                                       atol=1e-15)
-+
-+    def test_cnot_explicit(self):
-+        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
-+        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
-+                             [0, 0, 0, 0, 0, 1, 0, 0],
-+                             [0, 0, 1, 0, 0, 0, 0, 0],
-+                             [0, 0, 0, 0, 0, 0, 0, 1],
-+                             [0, 0, 0, 0, 1, 0, 0, 0],
-+                             [0, 1, 0, 0, 0, 0, 0, 0],
-+                             [0, 0, 0, 0, 0, 0, 1, 0],
-+                             [0, 0, 0, 1, 0, 0, 0, 0]])
-+        np.testing.assert_allclose(test, expected, atol=1e-15)
-+
-+    @pytest.mark.parametrize('dimensions', [
-+        pytest.param([3, 4, 5], id="standard"),
-+        pytest.param([3, 3, 4, 4, 2], id="standard"),
-+        pytest.param([1, 2, 3], id="1D space"),
-+    ])
-+    def test_non_qubit_systems(self, dimensions):
-+        n_qubits = len(dimensions)
-+        for targets in itertools.permutations(range(n_qubits), 2):
-+            operators = [qutip.rand_unitary(dimension) if n in targets
-+                         else qutip.qeye(dimension)
-+                         for n, dimension in enumerate(dimensions)]
-+            expected = qutip.tensor(*operators)
-+            base_test = qutip.tensor(*[operators[x] for x in targets])
-+            test = expand_operator(base_test, dims=dimensions, targets=targets)
-+            assert test.dims == expected.dims
-+            np.testing.assert_allclose(test.full(), expected.full())
-diff --git a/qutip/tests/pytest.ini b/qutip/tests/pytest.ini
-index 02ffbe59..97561c15 100644
---- a/qutip/tests/pytest.ini
-+++ b/qutip/tests/pytest.ini
-@@ -1,5 +1,5 @@
--[pytest]
--markers =
--    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
--    repeat(n): Repeat the given test 'n' times.
--    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
-+[pytest]
-+markers =
-+    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
-+    repeat(n): Repeat the given test 'n' times.
-+    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
-diff --git a/qutip/tests/solve/test_piqs.py b/qutip/tests/solve/test_piqs.py
-index a069a290..293cd586 100644
---- a/qutip/tests/solve/test_piqs.py
-+++ b/qutip/tests/solve/test_piqs.py
-@@ -1,1536 +1,1536 @@
--"""
--Tests for Permutational Invariant Quantum solver (PIQS).
--"""
--import numpy as np
--from numpy.testing import (
--    assert_,
--    run_module_suite,
--    assert_raises,
--    assert_array_equal,
--    assert_array_almost_equal,
--    assert_almost_equal,
--    assert_equal,
--)
--from scipy.sparse import block_diag
--from qutip import Qobj, entropy_vn, sigmax, sigmaz
--from qutip.solve._piqs import (
--    get_blocks,
--    j_min,
--    j_vals,
--    m_vals,
--    _num_dicke_states,
--    _num_dicke_ladders,
--    get_index,
--    jmm1_dictionary,
--)
--from qutip.solve._piqs import Dicke as _Dicke
--from qutip.solve.piqs import *
--
--import sys
--import unittest
--
--
--# Disable tests for python2 as qutip.piqs does not support python2.
--if sys.version_info[0] < 3:
--    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
--
--
--class TestDicke:
--    """
--    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
--    """
--
--    def test_num_dicke_states(self):
--        """
--        PIQS: Test the `num_dicke_state` function.
--        """
--        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
--        dicke_states = [num_dicke_states(i) for i in N_list]
--        assert_array_equal(
--            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
--        )
--        N = -1
--        assert_raises(ValueError, num_dicke_states, N)
--        N = 0.2
--        assert_raises(ValueError, num_dicke_states, N)
--
--    def test_num_tls(self):
--        """
--        PIQS: Test the `num_two_level` function.
--        """
--        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
--        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
--        calculated_N = [num_tls(i) for i in N_dicke]
--        assert_array_equal(calculated_N, N)
--
--    def test_num_dicke_ladders(self):
--        """
--        PIQS: Test the `_num_dicke_ladders` function.
--        """
--        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
--        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
--        assert_array_equal(ndl, ndl_true)
--
--    def test_get_blocks(self):
--        """
--        PIQS: Test the function to get blocks.
--        """
--        N_list = [1, 2, 5, 7]
--        blocks = [
--            np.array([2]),
--            np.array([3, 4]),
--            np.array([6, 10, 12]),
--            np.array([8, 14, 18, 20]),
--        ]
--        calculated_blocks = [get_blocks(i) for i in N_list]
--        for (i, j) in zip(calculated_blocks, blocks):
--            assert_array_equal(i, j)
--
--    def test_j_vals(self):
--        """
--        PIQS: Test calculation of j values for given N.
--        """
--        N_list = [1, 2, 3, 4, 7]
--        j_vals_real = [
--            np.array([0.5]),
--            np.array([0.0, 1.0]),
--            np.array([0.5, 1.5]),
--            np.array([0.0, 1.0, 2.0]),
--            np.array([0.5, 1.5, 2.5, 3.5]),
--        ]
--        j_vals_calc = [j_vals(i) for i in N_list]
--
--        for (i, j) in zip(j_vals_calc, j_vals_real):
--            assert_array_equal(i, j)
--
--    def test_m_vals(self):
--        """
--        PIQS: Test calculation of m values for a particular j.
--        """
--        j_list = [0.5, 1, 1.5, 2, 2.5]
--        m_real = [
--            np.array([-0.5, 0.5]),
--            np.array([-1, 0, 1]),
--            np.array([-1.5, -0.5, 0.5, 1.5]),
--            np.array([-2, -1, 0, 1, 2]),
--            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
--        ]
--
--        m_calc = [m_vals(i) for i in j_list]
--        for (i, j) in zip(m_real, m_calc):
--            assert_array_equal(i, j)
--
--    def test_dicke_blocks(self):
--        """
--        PIQS: Test the `dicke_blocks` function.
--        """
--        # test 1
--        # mixed state with non-symmetrical block matrix elements
--        N = 3
--        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
--        test_blocks = dicke_blocks(true_matrix)
--        test_matrix = Qobj(block_diag(test_blocks))
--        assert_(test_matrix == true_matrix)
--        # test 2
--        # all elements in block-diagonal matrix
--        N = 4
--        true_matrix = Qobj(block_matrix(N)).unit()
--        test_blocks = dicke_blocks(true_matrix)
--        test_matrix = Qobj(block_diag(test_blocks))
--        assert_(test_matrix == true_matrix)
--
--    def test_dicke_blocks_full(self):
--        """
--        PIQS: Test the `dicke_blocks_full` function.
--        """
--        N = 3
--        test_blocks = dicke_blocks_full(excited(3))
--        test_matrix = Qobj(block_diag(test_blocks))
--        true_expanded = np.zeros((8, 8))
--        true_expanded[0, 0] = 1.0
--        assert_(test_matrix == Qobj(true_expanded))
--
--    def test_dicke_function_trace(self):
--        """
--        PIQS: Test the `dicke_function_trace` function.
--        """
--        ## test for N odd
--        N = 3
--        # test trace
--        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
--        f = lambda x: x
--        test_val = dicke_function_trace(f, rho_mixed)
--        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
--        true_val2 = (rho_mixed).tr()
--        # test with linear function (trace)
--        assert_almost_equal(test_val, true_val)
--        assert_almost_equal(test_val, true_val2)
--        # test with nonlinear function
--        f = lambda rho: rho ** 3
--        test_val3 = dicke_function_trace(f, rho_mixed)
--        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
--        assert_almost_equal(test_val3, true_val3)
--        ## test for N even
--        N = 4
--        # test trace
--        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
--        f = lambda x: x
--        test_val = dicke_function_trace(f, rho_mixed)
--        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
--        true_val2 = (rho_mixed).tr()
--        # test with linear function (trace)
--        assert_almost_equal(test_val, true_val)
--        assert_almost_equal(test_val, true_val2)
--        # test with nonlinear function
--        f = lambda rho: rho ** 3
--        test_val3 = dicke_function_trace(f, rho_mixed)
--        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
--        assert np.allclose(test_val3, true_val3)
--
--    def test_entropy_vn_dicke(self):
--        """
--        PIQS: Test the `entropy_vn_dicke` function.
--        """
--        N = 3
--        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
--        test_val = entropy_vn_dicke(rho_mixed)
--        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
--        assert np.allclose(test_val, true_val)
--
--    def test_purity_dicke(self):
--        """
--        PIQS: Test the `purity_dicke` function.
--        """
--        N = 3
--        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
--        test_val = purity_dicke(rho_mixed)
--        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
--        assert np.allclose(test_val, true_val)
--
--    def test_get_index(self):
--        """
--        PIQS: Test the index fetching function for given j, m, m1 value.
--        """
--        N = 1
--        jmm1_list = [
--            (0.5, 0.5, 0.5),
--            (0.5, 0.5, -0.5),
--            (0.5, -0.5, 0.5),
--            (0.5, -0.5, -0.5),
--        ]
--        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
--
--        blocks = get_blocks(N)
--        calculated_indices = [
--            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
--            for jmm1 in jmm1_list
--        ]
--        assert_array_almost_equal(calculated_indices, indices)
--        N = 2
--        blocks = get_blocks(N)
--        jmm1_list = [
--            (1, 1, 1),
--            (1, 1, 0),
--            (1, 1, -1),
--            (1, 0, 1),
--            (1, 0, 0),
--            (1, 0, -1),
--            (1, -1, 1),
--            (1, -1, 0),
--            (1, -1, -1),
--            (0, 0, 0),
--        ]
--        indices = [
--            (0, 0),
--            (0, 1),
--            (0, 2),
--            (1, 0),
--            (1, 1),
--            (1, 2),
--            (2, 0),
--            (2, 1),
--            (2, 2),
--            (3, 3),
--        ]
--        calculated_indices = [
--            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
--            for jmm1 in jmm1_list
--        ]
--        assert_array_almost_equal(calculated_indices, indices)
--        N = 3
--        blocks = get_blocks(N)
--        jmm1_list = [
--            (1.5, 1.5, 1.5),
--            (1.5, 1.5, 0.5),
--            (1.5, 1.5, -0.5),
--            (1.5, 1.5, -1.5),
--            (1.5, 0.5, 0.5),
--            (1.5, -0.5, -0.5),
--            (1.5, -1.5, -1.5),
--            (1.5, -1.5, 1.5),
--            (0.5, 0.5, 0.5),
--            (0.5, 0.5, -0.5),
--            (0.5, -0.5, 0.5),
--            (0.5, -0.5, -0.5),
--        ]
--
--        indices = [
--            (0, 0),
--            (0, 1),
--            (0, 2),
--            (0, 3),
--            (1, 1),
--            (2, 2),
--            (3, 3),
--            (3, 0),
--            (4, 4),
--            (4, 5),
--            (5, 4),
--            (5, 5),
--        ]
--
--        calculated_indices = [
--            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
--            for jmm1 in jmm1_list
--        ]
--        assert_array_almost_equal(calculated_indices, indices)
--
--    def test_jmm1_dictionary(self):
--        """
--        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
--        """
--        d1, d2, d3, d4 = jmm1_dictionary(1)
--
--        d1_correct = {
--            (0, 0): (0.5, 0.5, 0.5),
--            (0, 1): (0.5, 0.5, -0.5),
--            (1, 0): (0.5, -0.5, 0.5),
--            (1, 1): (0.5, -0.5, -0.5),
--        }
--
--        d2_correct = {
--            (0.5, -0.5, -0.5): (1, 1),
--            (0.5, -0.5, 0.5): (1, 0),
--            (0.5, 0.5, -0.5): (0, 1),
--            (0.5, 0.5, 0.5): (0, 0),
--        }
--
--        d3_correct = {
--            0: (0.5, 0.5, 0.5),
--            1: (0.5, 0.5, -0.5),
--            2: (0.5, -0.5, 0.5),
--            3: (0.5, -0.5, -0.5),
--        }
--
--        d4_correct = {
--            (0.5, -0.5, -0.5): 3,
--            (0.5, -0.5, 0.5): 2,
--            (0.5, 0.5, -0.5): 1,
--            (0.5, 0.5, 0.5): 0,
--        }
--
--        assert_equal(d1, d1_correct)
--        assert_equal(d2, d2_correct)
--        assert_equal(d3, d3_correct)
--        assert_equal(d4, d4_correct)
--
--        d1, d2, d3, d4 = jmm1_dictionary(2)
--
--        d1_correct = {
--            (3, 3): (0.0, -0.0, -0.0),
--            (2, 2): (1.0, -1.0, -1.0),
--            (2, 1): (1.0, -1.0, 0.0),
--            (2, 0): (1.0, -1.0, 1.0),
--            (1, 2): (1.0, 0.0, -1.0),
--            (1, 1): (1.0, 0.0, 0.0),
--            (1, 0): (1.0, 0.0, 1.0),
--            (0, 2): (1.0, 1.0, -1.0),
--            (0, 1): (1.0, 1.0, 0.0),
--            (0, 0): (1.0, 1.0, 1.0),
--        }
--
--        d2_correct = {
--            (0.0, -0.0, -0.0): (3, 3),
--            (1.0, -1.0, -1.0): (2, 2),
--            (1.0, -1.0, 0.0): (2, 1),
--            (1.0, -1.0, 1.0): (2, 0),
--            (1.0, 0.0, -1.0): (1, 2),
--            (1.0, 0.0, 0.0): (1, 1),
--            (1.0, 0.0, 1.0): (1, 0),
--            (1.0, 1.0, -1.0): (0, 2),
--            (1.0, 1.0, 0.0): (0, 1),
--            (1.0, 1.0, 1.0): (0, 0),
--        }
--
--        d3_correct = {
--            15: (0.0, -0.0, -0.0),
--            10: (1.0, -1.0, -1.0),
--            9: (1.0, -1.0, 0.0),
--            8: (1.0, -1.0, 1.0),
--            6: (1.0, 0.0, -1.0),
--            5: (1.0, 0.0, 0.0),
--            4: (1.0, 0.0, 1.0),
--            2: (1.0, 1.0, -1.0),
--            1: (1.0, 1.0, 0.0),
--            0: (1.0, 1.0, 1.0),
--        }
--
--        d4_correct = {
--            (0.0, -0.0, -0.0): 15,
--            (1.0, -1.0, -1.0): 10,
--            (1.0, -1.0, 0.0): 9,
--            (1.0, -1.0, 1.0): 8,
--            (1.0, 0.0, -1.0): 6,
--            (1.0, 0.0, 0.0): 5,
--            (1.0, 0.0, 1.0): 4,
--            (1.0, 1.0, -1.0): 2,
--            (1.0, 1.0, 0.0): 1,
--            (1.0, 1.0, 1.0): 0,
--        }
--
--        assert_equal(d1, d1_correct)
--        assert_equal(d2, d2_correct)
--        assert_equal(d3, d3_correct)
--        assert_equal(d4, d4_correct)
--
--    def test_lindbladian(self):
--        """
--        PIQS: Test the generation of the Lindbladian matrix.
--        """
--        N = 1
--        gCE = 0.5
--        gCD = 0.5
--        gCP = 0.5
--        gE = 0.1
--        gD = 0.1
--        gP = 0.1
--
--        system = Dicke(
--            N=N,
--            emission=gE,
--            pumping=gP,
--            dephasing=gD,
--            collective_emission=gCE,
--            collective_pumping=gCP,
--            collective_dephasing=gCD,
--        )
--
--        lindbladian = system.lindbladian()
--        Ldata = np.zeros((4, 4), dtype="complex")
--        Ldata[0] = [-0.6, 0, 0, 0.6]
--        Ldata[1] = [0, -0.9, 0, 0]
--        Ldata[2] = [0, 0, -0.9, 0]
--        Ldata[3] = [0.6, 0, 0, -0.6]
--
--        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
--        assert_array_almost_equal(lindbladian.full(), Ldata)
--        N = 2
--        gCE = 0.5
--        gCD = 0.5
--        gCP = 0.5
--        gE = 0.1
--        gD = 0.1
--        gP = 0.1
--        system = Dicke(
--            N=N,
--            emission=gE,
--            pumping=gP,
--            dephasing=gD,
--            collective_emission=gCE,
--            collective_pumping=gCP,
--            collective_dephasing=gCD,
--        )
--
--        lindbladian = system.lindbladian()
--
--        Ldata = np.zeros((16, 16), dtype="complex")
--        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
--        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
--        Ldata[2, 2] = -2.2999999999999998
--        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
--        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
--            1.1,
--            -2.25,
--            1.1,
--            0.05,
--        )
--        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
--        Ldata[8, 8] = -2.2999999999999998
--        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
--        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
--        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
--            0.1,
--            0.05,
--            0.1,
--            -0.25,
--        )
--        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
--        assert_array_almost_equal(lindbladian.full(), Ldata)
--
--    def test_gamma(self):
--        """
--        PIQS: Test the calculation of various gamma values for diagonal system.
--
--        For N = 6 |j, m> would be :
--
--        | 3, 3>
--        | 3, 2> | 2, 2>
--        | 3, 1> | 2, 1> | 1, 1>
--        | 3, 0> | 2, 0> | 1, 0> |0, 0>
--        | 3,-1> | 2,-1> | 1,-1>
--        | 3,-2> | 2,-2>
--        | 3,-3>
--        """
--        N = 6
--        collective_emission = 1.0
--        emission = 1.0
--        dephasing = 1.0
--        pumping = 1.0
--        collective_pumping = 1.0
--        model = _Dicke(
--            N,
--            collective_emission=collective_emission,
--            emission=emission,
--            dephasing=dephasing,
--            pumping=pumping,
--            collective_pumping=collective_pumping,
--        )
--        tau_calculated = [
--            model.gamma3((3, 1, 1)),
--            model.gamma2((2, 1, 1)),
--            model.gamma4((1, 1, 1)),
--            model.gamma5((3, 0, 0)),
--            model.gamma1((2, 0, 0)),
--            model.gamma6((1, 0, 0)),
--            model.gamma7((3, -1, -1)),
--            model.gamma8((2, -1, -1)),
--            model.gamma9((1, -1, -1)),
--        ]
--        tau_real = [
--            2.0,
--            8.0,
--            0.333333,
--            1.5,
--            -19.5,
--            0.666667,
--            2.0,
--            8.0,
--            0.333333,
--        ]
--        assert_array_almost_equal(tau_calculated, tau_real)
--
--    def test_jspin(self):
--        """
--        PIQS: Test calculation of the j algebra relation for the total operators.
--
--        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
--        basis should follow the following algebra
--        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
--        """
--        N_list = [1, 2, 3, 4, 7]
--
--        for nn in N_list:
--            # tests 1
--            [jx, jy, jz] = jspin(nn)
--            jp, jm = jspin(nn, "+"), jspin(nn, "-")
--            test_jxjy = jx * jy - jy * jx
--            true_jxjy = 1j * jz
--            test_jpjm = jp * jm - jm * jp
--            true_jpjm = 2 * jz
--
--            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
--            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
--
--            # tests 2
--            [jx, jy, jz] = jspin(nn)
--            jp, jm = jspin(nn, "+"), jspin(nn, "-")
--            test_jxjy = jx * jy - jy * jx
--            true_jxjy = 1j * jz
--            test_jpjm = jp * jm - jm * jp
--            true_jpjm = 2 * jz
--
--            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
--            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
--
--            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
--            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
--            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
--            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
--            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
--            assert_raises(TypeError, jspin, nn, "q")
--
--    def test_j_min_(self):
--        """
--        PIQS: Test the `j_min` function.
--        """
--        even = [2, 4, 6, 8]
--        odd = [1, 3, 5, 7]
--
--        for i in even:
--            assert_(j_min(i) == 0)
--
--        for i in odd:
--            assert_(j_min(i) == 0.5)
--
--    def test_energy_degeneracy(self):
--        """
--        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
--        """
--        true_en_deg = [1, 1, 1, 1, 1]
--        true_en_deg_even = [2, 6, 20]
--        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
--        test_en_deg = []
--        test_en_deg_even = []
--        test_en_deg_odd = []
--
--        for nn in [1, 2, 3, 4, 7]:
--            test_en_deg.append(energy_degeneracy(nn, nn / 2))
--
--        for nn in [2, 4, 6]:
--            test_en_deg_even.append(energy_degeneracy(nn, 0))
--
--        for nn in [1, 3, 7]:
--            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
--            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
--
--        assert_array_equal(test_en_deg, true_en_deg)
--        assert_array_equal(test_en_deg_even, true_en_deg_even)
--        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
--
--    def test_state_degeneracy(self):
--        """
--        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
--        state_degeneracy(N, j).
--        """
--        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
--        state_deg = []
--        state_deg = []
--        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
--            state_deg.append(state_degeneracy(nn, nn / 2))
--        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
--            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
--        assert_array_equal(state_deg, true_state_deg)
--
--        # check error
--        assert_raises(ValueError, state_degeneracy, 2, -1)
--
--    def test_m_degeneracy(self):
--        """
--        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
--        """
--        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
--        m_deg = []
--        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
--            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
--        assert_array_equal(m_deg, true_m_deg)
--
--        # check error
--        assert_raises(ValueError, m_degeneracy, 6, -6)
--
--    def test_ap(self):
--        """
--        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
--
--        For given values of j, m. For a Dicke state,
--        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
--        """
--        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
--        ap_list = []
--        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
--            ap_list.append(ap(10, m) ** 2)
--
--        assert_almost_equal(ap_list, true_ap_list)
--
--    def test_am(self):
--        """
--        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
--
--        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
--        """
--        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
--        am_list = []
--        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
--            am_list.append(am(10, m) ** 2)
--
--        assert_almost_equal(am_list, true_am_list)
--
--    def test_spin_algebra(self):
--        """
--        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
--        The list [sx, sy, sz, sp, sm] is checked for N = 2.
--        """
--        sx1 = [
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
--            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        sx2 = [
--            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        sy1 = [
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
--            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        sy2 = [
--            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
--        ]
--
--        sz1 = [
--            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
--        ]
--
--        sz2 = [
--            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
--        ]
--
--        sp1 = [
--            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        sp2 = [
--            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        sm1 = [
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        sm2 = [
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
--        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
--        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
--        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
--        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
--        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
--        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
--        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
--        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
--        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
--
--        # test error
--        assert_raises(TypeError, spin_algebra, 2, "q")
--
--    def test_collective_algebra(self):
--        """
--        PIQS: Test the generation of the collective algebra in uncoupled basis.
--
--        The list [jx, jy, jz] created in the 2^N Hilbert space is
--        checked for N = 2.
--        """
--
--        jx_n2 = [
--            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
--            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
--            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
--            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        jy_n2 = [
--            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
--            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
--            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
--            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
--        ]
--
--        jz_n2 = [
--            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
--        ]
--
--        jp_n2 = [
--            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        jm_n2 = [
--            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
--            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
--        ]
--
--        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
--        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
--        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
--        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
--        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
--
--        # error
--        assert_raises(TypeError, spin_algebra, 2, "q")
--
--    def test_block_matrix(self):
--        """
--        PIQS: Test the calculation of the block-diagonal matrix for given N.
--
--        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
--        """
--        # N = 1 TLSs
--        block_1 = [[1.0, 1.0], [1.0, 1.0]]
--
--        # N = 2 TLSs
--        block_2 = [
--            [1.0, 1.0, 1.0, 0.0],
--            [1.0, 1.0, 1.0, 0.0],
--            [1.0, 1.0, 1.0, 0.0],
--            [0.0, 0.0, 0.0, 1.0],
--        ]
--
--        # N = 3 TLSs
--        block_3 = [
--            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
--            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
--            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
--            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
--            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
--            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
--        ]
--
--        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
--        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
--        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
--
--    def test_dicke_basis(self):
--        """
--        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
--
--        We test the state with for N = 2,
--
--        0   0   0.3 0
--        0   0.5 0   0
--        0.3 0   0   0
--        0   0   0   0.5
--        """
--        N = 2
--        true_dicke_basis = np.zeros((4, 4))
--        true_dicke_basis[1, 1] = 0.5
--        true_dicke_basis[-1, -1] = 0.5
--        true_dicke_basis[0, 2] = 0.3
--        true_dicke_basis[2, 0] = 0.3
--        true_dicke_basis = Qobj(true_dicke_basis)
--        jmm1_1 = {(N / 2, 0, 0): 0.5}
--        jmm1_2 = {(0, 0, 0): 0.5}
--        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
--        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
--        db1 = dicke_basis(2, jmm1_1)
--        db2 = dicke_basis(2, jmm1_2)
--        db3 = dicke_basis(2, jmm1_3)
--        db4 = dicke_basis(2, jmm1_4)
--        test_dicke_basis = db1 + db2 + db3 + db4
--        assert_equal(test_dicke_basis, true_dicke_basis)
--
--        # error
--        assert_raises(AttributeError, dicke_basis, N)
--
--    def test_dicke(self):
--        """
--        PIQS: Test the calculation of the Dicke state as a pure state.
--        """
--        true_excited = np.zeros((4, 4))
--        true_excited[0, 0] = 1
--
--        true_superradiant = np.zeros((4, 4))
--        true_superradiant[1, 1] = 1
--
--        true_subradiant = np.zeros((4, 4))
--        true_subradiant[-1, -1] = 1
--
--        test_excited = dicke(2, 1, 1)
--        test_superradiant = dicke(2, 1, 0)
--        test_subradiant = dicke(2, 0, 0)
--
--        assert_equal(test_excited, Qobj(true_excited))
--        assert_equal(test_superradiant, Qobj(true_superradiant))
--        assert_equal(test_subradiant, Qobj(true_subradiant))
--
--    def test_excited(self):
--        """
--        PIQS: Test the calculation of the totally excited state density matrix.
--
--        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
--        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
--        """
--        N = 3
--        true_state = np.zeros((6, 6))
--        true_state[0, 0] = 1
--        true_state = Qobj(true_state)
--
--        test_state = excited(N)
--        assert_equal(test_state, true_state)
--
--        N = 4
--        true_state = np.zeros((9, 9))
--        true_state[0, 0] = 1
--        true_state = Qobj(true_state)
--
--        test_state = excited(N)
--        assert_equal(test_state, true_state)
--
--        # uncoupled
--        test_state_uncoupled = excited(2, basis="uncoupled")
--        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
--        assert_array_equal(test_state_uncoupled.shape, (4, 4))
--        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
--
--    def test_superradiant(self):
--        """
--        PIQS: Test the calculation of the superradiant state density matrix.
--
--        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
--        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
--        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
--        """
--        N = 3
--        true_state = np.zeros((6, 6))
--        true_state[1, 1] = 1
--        true_state = Qobj(true_state)
--        test_state = superradiant(N)
--        assert_equal(test_state, true_state)
--        N = 4
--        true_state = np.zeros((9, 9))
--        true_state[2, 2] = 1
--        true_state = Qobj(true_state)
--        test_state = superradiant(N)
--        assert_equal(test_state, true_state)
--
--        # uncoupled
--        test_state_uncoupled = superradiant(2, basis="uncoupled")
--        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
--        assert_array_equal(test_state_uncoupled.shape, (4, 4))
--        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
--
--    def test_ghz(self):
--        """
--        PIQS: Test the calculation of the density matrix of the GHZ state.
--
--        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
--        """
--        ghz_dicke = Qobj(
--            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
--        )
--        ghz_uncoupled = Qobj(
--            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
--        )
--        ghz_uncoupled.dims = [[2, 2], [2, 2]]
--        assert_equal(ghz(2), ghz_dicke)
--        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
--
--    def test_ground(self):
--        """
--        PIQS: Test the calculation of the density matrix of the ground state.
--
--        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
--        """
--        zeros = np.zeros((4, 4), dtype=np.complex128)
--        gdicke = zeros.copy()
--        guncoupled = zeros.copy()
--        gdicke[2, 2] = 1
--        guncoupled[3, 3] = 1
--
--        dim_dicke = [[4], [4]]
--        dim_uncoupled = [[2, 2], [2, 2]]
--
--        test_ground_dicke = ground(2)
--        test_ground_uncoupled = ground(2, "uncoupled")
--
--        assert_array_equal(test_ground_dicke.full(), gdicke)
--        assert_array_equal(test_ground_dicke.dims, dim_dicke)
--        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
--        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
--
--    def test_identity_uncoupled(self):
--        """
--        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
--        """
--        test_identity = identity_uncoupled(4)
--        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
--        assert_array_equal(
--            np.diag(test_identity.full()), np.ones(16, np.complex128)
--        )
--
--    def test_css(self):
--        """
--        PIQS: Test the calculation of the CSS state.
--        """
--        test_css_uncoupled = css(2, basis="uncoupled")
--        test_css_dicke = css(2)
--        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
--        css_dicke = np.array(
--            [
--                [
--                    0.25000000 + 0.0j,
--                    0.35355339 + 0.0j,
--                    0.25000000 + 0.0j,
--                    0.00000000 + 0.0j,
--                ],
--                [
--                    0.35355339 + 0.0j,
--                    0.50000000 + 0.0j,
--                    0.35355339 + 0.0j,
--                    0.00000000 + 0.0j,
--                ],
--                [
--                    0.25000000 + 0.0j,
--                    0.35355339 + 0.0j,
--                    0.25000000 + 0.0j,
--                    0.00000000 + 0.0j,
--                ],
--                [
--                    0.00000000 + 0.0j,
--                    0.00000000 + 0.0j,
--                    0.00000000 + 0.0j,
--                    0.00000000 + 0.0j,
--                ],
--            ]
--        )
--        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
--        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
--
--    def test_collapse_uncoupled(self):
--        """
--        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
--
--        In the "uncoupled" basis of N two-level system (TLS).
--        The test is performed for N = 2 and emission = 1.
--        """
--        c1 = Qobj(
--            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
--            dims=[[2, 2], [2, 2]],
--        )
--        c2 = Qobj(
--            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
--            dims=[[2, 2], [2, 2]],
--        )
--        true_c_ops = [c1, c2]
--        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
--        system = Dicke(N=2, emission=1)
--        assert_equal(true_c_ops, system.c_ops())
--
--    def test_get_blocks(self):
--        """
--        PIQS: Test the calculation of list of cumulative elements at each block.
--
--        For N = 4
--
--        1 1 1 1 1
--        1 1 1 1 1
--        1 1 1 1 1
--        1 1 1 1 1
--        1 1 1 1 1
--                1 1 1
--                1 1 1
--                1 1 1
--                     1
--        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
--        elements have been accounted for and so on.
--        """
--        trueb1 = [2]
--        trueb2 = [3, 4]
--        trueb3 = [4, 6]
--        trueb4 = [5, 8, 9]
--
--        test_b1 = get_blocks(1)
--        test_b2 = get_blocks(2)
--        test_b3 = get_blocks(3)
--        test_b4 = get_blocks(4)
--
--        assert_equal(test_b1, trueb1)
--        assert_equal(test_b2, trueb2)
--        assert_equal(test_b3, trueb3)
--
--    def test_lindbladian_dims(self):
--        """
--        PIQS: Test the calculation of the lindbladian matrix.
--        """
--        true_L = [
--            [-4, 0, 0, 3],
--            [0, -3.54999995, 0, 0],
--            [0, 0, -3.54999995, 0],
--            [4, 0, 0, -3],
--        ]
--        true_L = Qobj(true_L)
--        true_L.dims = [[[2], [2]], [[2], [2]]]
--        N = 1
--        test_dicke = _Dicke(
--            N=N,
--            pumping=1,
--            collective_pumping=2,
--            emission=1,
--            collective_emission=3,
--            dephasing=0.1,
--        )
--        test_L = test_dicke.lindbladian()
--        assert_array_almost_equal(test_L.full(), true_L.full())
--        assert_array_equal(test_L.dims, true_L.dims)
--
--    def test_liouvillian(self):
--        """
--        PIQS: Test the calculation of the liouvillian matrix.
--        """
--        true_L = [
--            [-4, 0, 0, 3],
--            [0, -3.54999995, 0, 0],
--            [0, 0, -3.54999995, 0],
--            [4, 0, 0, -3],
--        ]
--        true_L = Qobj(true_L)
--        true_L.dims = [[[2], [2]], [[2], [2]]]
--        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
--        true_H = Qobj(true_H)
--        true_H.dims = [[[2], [2]]]
--        true_liouvillian = [
--            [-4, -1.0j, 1.0j, 3],
--            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
--            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
--            [4, +1.0j, -1.0j, -3],
--        ]
--        true_liouvillian = Qobj(true_liouvillian)
--        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
--        N = 1
--        test_piqs = Dicke(
--            hamiltonian=sigmaz() + sigmax(),
--            N=N,
--            pumping=1,
--            collective_pumping=2,
--            emission=1,
--            collective_emission=3,
--            dephasing=0.1,
--        )
--        test_liouvillian = test_piqs.liouvillian()
--        test_hamiltonian = test_piqs.hamiltonian
--        assert_array_almost_equal(
--            test_liouvillian.full(), true_liouvillian.full()
--        )
--        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
--        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
--
--        # no Hamiltonian
--        test_piqs = Dicke(
--            N=N,
--            pumping=1,
--            collective_pumping=2,
--            emission=1,
--            collective_emission=3,
--            dephasing=0.1,
--        )
--        liouv = test_piqs.liouvillian()
--        lindblad = test_piqs.lindbladian()
--        assert_equal(liouv, lindblad)
--
--    def test_gamma1(self):
--        """
--        PIQS: Test the calculation of gamma1.
--        """
--        true_gamma_1 = -2
--        true_gamma_2 = -3
--        true_gamma_3 = -7
--        true_gamma_4 = -1
--        true_gamma_5 = 0
--        true_gamma_6 = 0
--
--        N = 4
--        test_dicke = _Dicke(N=N, collective_emission=1)
--        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
--        test_dicke = _Dicke(N=N, emission=1)
--        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
--        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
--        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
--        test_dicke = _Dicke(N=N, dephasing=4)
--        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
--        test_dicke = _Dicke(N=N, collective_pumping=2)
--        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
--        test_dicke = _Dicke(N=N, collective_dephasing=2)
--        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--        assert_almost_equal(true_gamma_5, test_gamma_5)
--        assert_almost_equal(true_gamma_6, test_gamma_6)
--
--    def test_gamma2(self):
--        """
--        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 2
--        true_gamma_2 = 1.5
--        true_gamma_3 = 5.5
--        true_gamma_4 = 0
--        true_gamma_5 = 0
--        true_gamma_6 = 0
--
--        N = 4
--        test_dicke = _Dicke(N=N, collective_emission=1)
--        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
--        test_dicke = _Dicke(N=N, emission=1)
--        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
--        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
--        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
--        test_dicke = _Dicke(N=N, dephasing=4)
--        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
--        test_dicke = _Dicke(N=N, collective_pumping=2)
--        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
--        test_dicke = _Dicke(N=N, collective_dephasing=2)
--        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--        assert_almost_equal(true_gamma_5, test_gamma_5)
--        assert_almost_equal(true_gamma_6, test_gamma_6)
--
--    def test_gamma3(self):
--        """
--        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 0
--        true_gamma_2 = 1.3333333730697632
--        true_gamma_3 = 1.3333333730697632
--        true_gamma_4 = 0
--        true_gamma_5 = 0
--        true_gamma_6 = 0
--
--        N = 4
--        test_dicke = _Dicke(N=N, collective_emission=1)
--        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
--        test_dicke = _Dicke(N=N, emission=1)
--        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
--        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
--        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
--        test_dicke = _Dicke(N=N, dephasing=4)
--        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
--        test_dicke = _Dicke(N=N, collective_pumping=2)
--        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
--        test_dicke = _Dicke(N=N, collective_dephasing=2)
--        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
--        #
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--        assert_almost_equal(true_gamma_5, test_gamma_5)
--        assert_almost_equal(true_gamma_6, test_gamma_6)
--
--    def test_gamma4(self):
--        """
--        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 0.1666666716337204
--        true_gamma_2 = 2
--        true_gamma_3 = 0
--        true_gamma_4 = 0.40824830532073975
--
--        N = 4
--        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
--        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
--        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
--        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
--        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--
--    def test_gamma5(self):
--        """
--        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 0
--        true_gamma_2 = 0
--        true_gamma_3 = 0.75
--        true_gamma_4 = 0
--
--        N = 4
--        test_dicke = _Dicke(N=N, dephasing=1)
--        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
--        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
--        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
--        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--
--    def test_gamma6(self):
--        """
--        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 0.25
--        true_gamma_2 = 1
--        true_gamma_3 = 0
--        true_gamma_4 = 0.25
--
--        N = 4
--        test_dicke = _Dicke(N=N, dephasing=1)
--        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
--        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
--        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
--        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--
--    def test_gamma7(self):
--        """
--        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 0
--        true_gamma_2 = 0.5
--        true_gamma_3 = 0
--        true_gamma_4 = 1.5
--
--        N = 4
--        test_dicke = _Dicke(N=N, pumping=1)
--        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
--        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
--        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
--        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--
--    def test_gamma8(self):
--        """
--        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 0
--        true_gamma_2 = 13.5
--        true_gamma_3 = 5.5
--        true_gamma_4 = 13.5
--
--        N = 4
--        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
--        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
--        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
--        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
--        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
--
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--
--    def test_gamma9(self):
--        """
--        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
--        """
--        true_gamma_1 = 1
--        true_gamma_2 = 0
--        true_gamma_3 = 0.5
--        true_gamma_4 = 0
--        N = 4
--        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
--        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
--        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
--        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
--        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
--        assert_almost_equal(true_gamma_1, test_gamma_1)
--        assert_almost_equal(true_gamma_2, test_gamma_2)
--        assert_almost_equal(true_gamma_3, test_gamma_3)
--        assert_almost_equal(true_gamma_4, test_gamma_4)
--
--
--class TestPim:
--    """
--    Tests for the `qutip.piqs.Pim` class.
--    """
--
--    def test_gamma(self):
--        """
--        PIQS: Test the calculation of various gamma values for diagonal system.
--
--        For N = 6 |j, m> would be :
--
--        | 3, 3>
--        | 3, 2> | 2, 2>
--        | 3, 1> | 2, 1> | 1, 1>
--        | 3, 0> | 2, 0> | 1, 0> |0, 0>
--        | 3,-1> | 2,-1> | 1,-1>
--        | 3,-2> | 2,-2>
--        | 3,-3>
--        """
--        N = 6
--        collective_emission = 1.0
--        emission = 1.0
--        dephasing = 1.0
--        pumping = 1.0
--        collective_pumping = 1.0
--        model = Pim(
--            N,
--            collective_emission=collective_emission,
--            emission=emission,
--            dephasing=dephasing,
--            pumping=pumping,
--            collective_pumping=collective_pumping,
--        )
--        tau_calculated = [
--            model.tau3(3, 1),
--            model.tau2(2, 1),
--            model.tau4(1, 1),
--            model.tau5(3, 0),
--            model.tau1(2, 0),
--            model.tau6(1, 0),
--            model.tau7(3, -1),
--            model.tau8(2, -1),
--            model.tau9(1, -1),
--        ]
--        tau_real = [
--            2.0,
--            8.0,
--            0.333333,
--            1.5,
--            -19.5,
--            0.666667,
--            2.0,
--            8.0,
--            0.333333,
--        ]
--        assert_array_almost_equal(tau_calculated, tau_real)
--
--    def test_isdicke(self):
--        """
--        PIQS: Test the `isdicke` function
--        """
--        N1 = 1
--        g0 = 0.01
--        nth = 0.01
--        gP = g0 * nth
--        gL = g0 * (0.1 + nth)
--        gS = 0.1
--        gD = 0.1
--
--        pim1 = Pim(N1, gS, gL, gD, gP)
--
--        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
--        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
--
--        N2 = 4
--
--        pim2 = Pim(N2, gS, gL, gD, gP)
--        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
--        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
--
--        assert_array_equal(dicke_labels, [True, False, True, False, True])
--
--    def test_isdiagonal(self):
--        """
--        PIQS: Test the isdiagonal function.
--        """
--        mat1 = np.array([[1, 2], [3, 4]])
--        mat2 = np.array([[1, 0.0], [0.0, 2]])
--        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
--        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
--        assert_equal(isdiagonal(mat1), False)
--        assert_equal(isdiagonal(mat2), True)
--        assert_equal(isdiagonal(mat3), False)
--        assert_equal(isdiagonal(mat4), True)
--
--    def test_pisolve(self):
--        """
--        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
--        """
--        jx, jy, jz = jspin(4)
--        jp, jm = jspin(4, "+"), jspin(4, "-")
--
--    def test_coefficient_matrix(self):
--        """
--        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
--        """
--        N = 2
--        ensemble = Pim(N, emission=1)
--        test_matrix = ensemble.coefficient_matrix().toarray()
--        ensemble2 = Dicke(N, emission=1)
--        test_matrix2 = ensemble.coefficient_matrix().toarray()
--        true_matrix = [
--            [-2, 0, 0, 0],
--            [1, -1, 0, 0],
--            [0, 1, 0, 1.0],
--            [1, 0, 0, -1.0],
--        ]
--
--        assert_array_almost_equal(test_matrix, true_matrix)
--        assert_array_almost_equal(test_matrix2, true_matrix)
--
--    def test_pisolve(self):
--        """
--        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
--        """
--        jx, jy, jz = jspin(4)
--        jp, jm = jspin(4, "+"), jspin(4, "-")
--        non_diag_hamiltonian = jx
--        diag_hamiltonian = jz
--
--        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
--        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
--
--        diag_initial_state = dicke(4, 1, 0)
--        non_diag_initial_state = ghz(4)
--        tlist = np.linspace(0, 10, 100)
--
--        assert_raises(
--            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
--        )
--        assert_raises(
--            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
--        )
--        assert_raises(
--            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
--        )
--
--        non_dicke_initial_state = excited(4, basis="uncoupled")
--        assert_raises(
--            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
--        )
--
--        # no Hamiltonian
--        no_hamiltonian_system = Dicke(4, emission=0.1)
--        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
--        assert_equal(True, len(result.states) > 0)
--
--
--if __name__ == "__main__":
--    run_module_suite()
-+"""
-+Tests for Permutational Invariant Quantum solver (PIQS).
-+"""
-+import numpy as np
-+from numpy.testing import (
-+    assert_,
-+    run_module_suite,
-+    assert_raises,
-+    assert_array_equal,
-+    assert_array_almost_equal,
-+    assert_almost_equal,
-+    assert_equal,
-+)
-+from scipy.sparse import block_diag
-+from qutip import Qobj, entropy_vn, sigmax, sigmaz
-+from qutip.solve._piqs import (
-+    get_blocks,
-+    j_min,
-+    j_vals,
-+    m_vals,
-+    _num_dicke_states,
-+    _num_dicke_ladders,
-+    get_index,
-+    jmm1_dictionary,
-+)
-+from qutip.solve._piqs import Dicke as _Dicke
-+from qutip.solve.piqs import *
-+
-+import sys
-+import unittest
-+
-+
-+# Disable tests for python2 as qutip.piqs does not support python2.
-+if sys.version_info[0] < 3:
-+    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
-+
-+
-+class TestDicke:
-+    """
-+    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
-+    """
-+
-+    def test_num_dicke_states(self):
-+        """
-+        PIQS: Test the `num_dicke_state` function.
-+        """
-+        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
-+        dicke_states = [num_dicke_states(i) for i in N_list]
-+        assert_array_equal(
-+            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
-+        )
-+        N = -1
-+        assert_raises(ValueError, num_dicke_states, N)
-+        N = 0.2
-+        assert_raises(ValueError, num_dicke_states, N)
-+
-+    def test_num_tls(self):
-+        """
-+        PIQS: Test the `num_two_level` function.
-+        """
-+        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
-+        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
-+        calculated_N = [num_tls(i) for i in N_dicke]
-+        assert_array_equal(calculated_N, N)
-+
-+    def test_num_dicke_ladders(self):
-+        """
-+        PIQS: Test the `_num_dicke_ladders` function.
-+        """
-+        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
-+        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
-+        assert_array_equal(ndl, ndl_true)
-+
-+    def test_get_blocks(self):
-+        """
-+        PIQS: Test the function to get blocks.
-+        """
-+        N_list = [1, 2, 5, 7]
-+        blocks = [
-+            np.array([2]),
-+            np.array([3, 4]),
-+            np.array([6, 10, 12]),
-+            np.array([8, 14, 18, 20]),
-+        ]
-+        calculated_blocks = [get_blocks(i) for i in N_list]
-+        for (i, j) in zip(calculated_blocks, blocks):
-+            assert_array_equal(i, j)
-+
-+    def test_j_vals(self):
-+        """
-+        PIQS: Test calculation of j values for given N.
-+        """
-+        N_list = [1, 2, 3, 4, 7]
-+        j_vals_real = [
-+            np.array([0.5]),
-+            np.array([0.0, 1.0]),
-+            np.array([0.5, 1.5]),
-+            np.array([0.0, 1.0, 2.0]),
-+            np.array([0.5, 1.5, 2.5, 3.5]),
-+        ]
-+        j_vals_calc = [j_vals(i) for i in N_list]
-+
-+        for (i, j) in zip(j_vals_calc, j_vals_real):
-+            assert_array_equal(i, j)
-+
-+    def test_m_vals(self):
-+        """
-+        PIQS: Test calculation of m values for a particular j.
-+        """
-+        j_list = [0.5, 1, 1.5, 2, 2.5]
-+        m_real = [
-+            np.array([-0.5, 0.5]),
-+            np.array([-1, 0, 1]),
-+            np.array([-1.5, -0.5, 0.5, 1.5]),
-+            np.array([-2, -1, 0, 1, 2]),
-+            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
-+        ]
-+
-+        m_calc = [m_vals(i) for i in j_list]
-+        for (i, j) in zip(m_real, m_calc):
-+            assert_array_equal(i, j)
-+
-+    def test_dicke_blocks(self):
-+        """
-+        PIQS: Test the `dicke_blocks` function.
-+        """
-+        # test 1
-+        # mixed state with non-symmetrical block matrix elements
-+        N = 3
-+        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-+        test_blocks = dicke_blocks(true_matrix)
-+        test_matrix = Qobj(block_diag(test_blocks))
-+        assert_(test_matrix == true_matrix)
-+        # test 2
-+        # all elements in block-diagonal matrix
-+        N = 4
-+        true_matrix = Qobj(block_matrix(N)).unit()
-+        test_blocks = dicke_blocks(true_matrix)
-+        test_matrix = Qobj(block_diag(test_blocks))
-+        assert_(test_matrix == true_matrix)
-+
-+    def test_dicke_blocks_full(self):
-+        """
-+        PIQS: Test the `dicke_blocks_full` function.
-+        """
-+        N = 3
-+        test_blocks = dicke_blocks_full(excited(3))
-+        test_matrix = Qobj(block_diag(test_blocks))
-+        true_expanded = np.zeros((8, 8))
-+        true_expanded[0, 0] = 1.0
-+        assert_(test_matrix == Qobj(true_expanded))
-+
-+    def test_dicke_function_trace(self):
-+        """
-+        PIQS: Test the `dicke_function_trace` function.
-+        """
-+        ## test for N odd
-+        N = 3
-+        # test trace
-+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-+        f = lambda x: x
-+        test_val = dicke_function_trace(f, rho_mixed)
-+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
-+        true_val2 = (rho_mixed).tr()
-+        # test with linear function (trace)
-+        assert_almost_equal(test_val, true_val)
-+        assert_almost_equal(test_val, true_val2)
-+        # test with nonlinear function
-+        f = lambda rho: rho ** 3
-+        test_val3 = dicke_function_trace(f, rho_mixed)
-+        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
-+        assert_almost_equal(test_val3, true_val3)
-+        ## test for N even
-+        N = 4
-+        # test trace
-+        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
-+        f = lambda x: x
-+        test_val = dicke_function_trace(f, rho_mixed)
-+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
-+        true_val2 = (rho_mixed).tr()
-+        # test with linear function (trace)
-+        assert_almost_equal(test_val, true_val)
-+        assert_almost_equal(test_val, true_val2)
-+        # test with nonlinear function
-+        f = lambda rho: rho ** 3
-+        test_val3 = dicke_function_trace(f, rho_mixed)
-+        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
-+        assert np.allclose(test_val3, true_val3)
-+
-+    def test_entropy_vn_dicke(self):
-+        """
-+        PIQS: Test the `entropy_vn_dicke` function.
-+        """
-+        N = 3
-+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-+        test_val = entropy_vn_dicke(rho_mixed)
-+        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
-+        assert np.allclose(test_val, true_val)
-+
-+    def test_purity_dicke(self):
-+        """
-+        PIQS: Test the `purity_dicke` function.
-+        """
-+        N = 3
-+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-+        test_val = purity_dicke(rho_mixed)
-+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
-+        assert np.allclose(test_val, true_val)
-+
-+    def test_get_index(self):
-+        """
-+        PIQS: Test the index fetching function for given j, m, m1 value.
-+        """
-+        N = 1
-+        jmm1_list = [
-+            (0.5, 0.5, 0.5),
-+            (0.5, 0.5, -0.5),
-+            (0.5, -0.5, 0.5),
-+            (0.5, -0.5, -0.5),
-+        ]
-+        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
-+
-+        blocks = get_blocks(N)
-+        calculated_indices = [
-+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-+            for jmm1 in jmm1_list
-+        ]
-+        assert_array_almost_equal(calculated_indices, indices)
-+        N = 2
-+        blocks = get_blocks(N)
-+        jmm1_list = [
-+            (1, 1, 1),
-+            (1, 1, 0),
-+            (1, 1, -1),
-+            (1, 0, 1),
-+            (1, 0, 0),
-+            (1, 0, -1),
-+            (1, -1, 1),
-+            (1, -1, 0),
-+            (1, -1, -1),
-+            (0, 0, 0),
-+        ]
-+        indices = [
-+            (0, 0),
-+            (0, 1),
-+            (0, 2),
-+            (1, 0),
-+            (1, 1),
-+            (1, 2),
-+            (2, 0),
-+            (2, 1),
-+            (2, 2),
-+            (3, 3),
-+        ]
-+        calculated_indices = [
-+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-+            for jmm1 in jmm1_list
-+        ]
-+        assert_array_almost_equal(calculated_indices, indices)
-+        N = 3
-+        blocks = get_blocks(N)
-+        jmm1_list = [
-+            (1.5, 1.5, 1.5),
-+            (1.5, 1.5, 0.5),
-+            (1.5, 1.5, -0.5),
-+            (1.5, 1.5, -1.5),
-+            (1.5, 0.5, 0.5),
-+            (1.5, -0.5, -0.5),
-+            (1.5, -1.5, -1.5),
-+            (1.5, -1.5, 1.5),
-+            (0.5, 0.5, 0.5),
-+            (0.5, 0.5, -0.5),
-+            (0.5, -0.5, 0.5),
-+            (0.5, -0.5, -0.5),
-+        ]
-+
-+        indices = [
-+            (0, 0),
-+            (0, 1),
-+            (0, 2),
-+            (0, 3),
-+            (1, 1),
-+            (2, 2),
-+            (3, 3),
-+            (3, 0),
-+            (4, 4),
-+            (4, 5),
-+            (5, 4),
-+            (5, 5),
-+        ]
-+
-+        calculated_indices = [
-+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-+            for jmm1 in jmm1_list
-+        ]
-+        assert_array_almost_equal(calculated_indices, indices)
-+
-+    def test_jmm1_dictionary(self):
-+        """
-+        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
-+        """
-+        d1, d2, d3, d4 = jmm1_dictionary(1)
-+
-+        d1_correct = {
-+            (0, 0): (0.5, 0.5, 0.5),
-+            (0, 1): (0.5, 0.5, -0.5),
-+            (1, 0): (0.5, -0.5, 0.5),
-+            (1, 1): (0.5, -0.5, -0.5),
-+        }
-+
-+        d2_correct = {
-+            (0.5, -0.5, -0.5): (1, 1),
-+            (0.5, -0.5, 0.5): (1, 0),
-+            (0.5, 0.5, -0.5): (0, 1),
-+            (0.5, 0.5, 0.5): (0, 0),
-+        }
-+
-+        d3_correct = {
-+            0: (0.5, 0.5, 0.5),
-+            1: (0.5, 0.5, -0.5),
-+            2: (0.5, -0.5, 0.5),
-+            3: (0.5, -0.5, -0.5),
-+        }
-+
-+        d4_correct = {
-+            (0.5, -0.5, -0.5): 3,
-+            (0.5, -0.5, 0.5): 2,
-+            (0.5, 0.5, -0.5): 1,
-+            (0.5, 0.5, 0.5): 0,
-+        }
-+
-+        assert_equal(d1, d1_correct)
-+        assert_equal(d2, d2_correct)
-+        assert_equal(d3, d3_correct)
-+        assert_equal(d4, d4_correct)
-+
-+        d1, d2, d3, d4 = jmm1_dictionary(2)
-+
-+        d1_correct = {
-+            (3, 3): (0.0, -0.0, -0.0),
-+            (2, 2): (1.0, -1.0, -1.0),
-+            (2, 1): (1.0, -1.0, 0.0),
-+            (2, 0): (1.0, -1.0, 1.0),
-+            (1, 2): (1.0, 0.0, -1.0),
-+            (1, 1): (1.0, 0.0, 0.0),
-+            (1, 0): (1.0, 0.0, 1.0),
-+            (0, 2): (1.0, 1.0, -1.0),
-+            (0, 1): (1.0, 1.0, 0.0),
-+            (0, 0): (1.0, 1.0, 1.0),
-+        }
-+
-+        d2_correct = {
-+            (0.0, -0.0, -0.0): (3, 3),
-+            (1.0, -1.0, -1.0): (2, 2),
-+            (1.0, -1.0, 0.0): (2, 1),
-+            (1.0, -1.0, 1.0): (2, 0),
-+            (1.0, 0.0, -1.0): (1, 2),
-+            (1.0, 0.0, 0.0): (1, 1),
-+            (1.0, 0.0, 1.0): (1, 0),
-+            (1.0, 1.0, -1.0): (0, 2),
-+            (1.0, 1.0, 0.0): (0, 1),
-+            (1.0, 1.0, 1.0): (0, 0),
-+        }
-+
-+        d3_correct = {
-+            15: (0.0, -0.0, -0.0),
-+            10: (1.0, -1.0, -1.0),
-+            9: (1.0, -1.0, 0.0),
-+            8: (1.0, -1.0, 1.0),
-+            6: (1.0, 0.0, -1.0),
-+            5: (1.0, 0.0, 0.0),
-+            4: (1.0, 0.0, 1.0),
-+            2: (1.0, 1.0, -1.0),
-+            1: (1.0, 1.0, 0.0),
-+            0: (1.0, 1.0, 1.0),
-+        }
-+
-+        d4_correct = {
-+            (0.0, -0.0, -0.0): 15,
-+            (1.0, -1.0, -1.0): 10,
-+            (1.0, -1.0, 0.0): 9,
-+            (1.0, -1.0, 1.0): 8,
-+            (1.0, 0.0, -1.0): 6,
-+            (1.0, 0.0, 0.0): 5,
-+            (1.0, 0.0, 1.0): 4,
-+            (1.0, 1.0, -1.0): 2,
-+            (1.0, 1.0, 0.0): 1,
-+            (1.0, 1.0, 1.0): 0,
-+        }
-+
-+        assert_equal(d1, d1_correct)
-+        assert_equal(d2, d2_correct)
-+        assert_equal(d3, d3_correct)
-+        assert_equal(d4, d4_correct)
-+
-+    def test_lindbladian(self):
-+        """
-+        PIQS: Test the generation of the Lindbladian matrix.
-+        """
-+        N = 1
-+        gCE = 0.5
-+        gCD = 0.5
-+        gCP = 0.5
-+        gE = 0.1
-+        gD = 0.1
-+        gP = 0.1
-+
-+        system = Dicke(
-+            N=N,
-+            emission=gE,
-+            pumping=gP,
-+            dephasing=gD,
-+            collective_emission=gCE,
-+            collective_pumping=gCP,
-+            collective_dephasing=gCD,
-+        )
-+
-+        lindbladian = system.lindbladian()
-+        Ldata = np.zeros((4, 4), dtype="complex")
-+        Ldata[0] = [-0.6, 0, 0, 0.6]
-+        Ldata[1] = [0, -0.9, 0, 0]
-+        Ldata[2] = [0, 0, -0.9, 0]
-+        Ldata[3] = [0.6, 0, 0, -0.6]
-+
-+        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
-+        assert_array_almost_equal(lindbladian.full(), Ldata)
-+        N = 2
-+        gCE = 0.5
-+        gCD = 0.5
-+        gCP = 0.5
-+        gE = 0.1
-+        gD = 0.1
-+        gP = 0.1
-+        system = Dicke(
-+            N=N,
-+            emission=gE,
-+            pumping=gP,
-+            dephasing=gD,
-+            collective_emission=gCE,
-+            collective_pumping=gCP,
-+            collective_dephasing=gCD,
-+        )
-+
-+        lindbladian = system.lindbladian()
-+
-+        Ldata = np.zeros((16, 16), dtype="complex")
-+        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
-+        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
-+        Ldata[2, 2] = -2.2999999999999998
-+        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
-+        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
-+            1.1,
-+            -2.25,
-+            1.1,
-+            0.05,
-+        )
-+        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
-+        Ldata[8, 8] = -2.2999999999999998
-+        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
-+        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
-+        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
-+            0.1,
-+            0.05,
-+            0.1,
-+            -0.25,
-+        )
-+        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
-+        assert_array_almost_equal(lindbladian.full(), Ldata)
-+
-+    def test_gamma(self):
-+        """
-+        PIQS: Test the calculation of various gamma values for diagonal system.
-+
-+        For N = 6 |j, m> would be :
-+
-+        | 3, 3>
-+        | 3, 2> | 2, 2>
-+        | 3, 1> | 2, 1> | 1, 1>
-+        | 3, 0> | 2, 0> | 1, 0> |0, 0>
-+        | 3,-1> | 2,-1> | 1,-1>
-+        | 3,-2> | 2,-2>
-+        | 3,-3>
-+        """
-+        N = 6
-+        collective_emission = 1.0
-+        emission = 1.0
-+        dephasing = 1.0
-+        pumping = 1.0
-+        collective_pumping = 1.0
-+        model = _Dicke(
-+            N,
-+            collective_emission=collective_emission,
-+            emission=emission,
-+            dephasing=dephasing,
-+            pumping=pumping,
-+            collective_pumping=collective_pumping,
-+        )
-+        tau_calculated = [
-+            model.gamma3((3, 1, 1)),
-+            model.gamma2((2, 1, 1)),
-+            model.gamma4((1, 1, 1)),
-+            model.gamma5((3, 0, 0)),
-+            model.gamma1((2, 0, 0)),
-+            model.gamma6((1, 0, 0)),
-+            model.gamma7((3, -1, -1)),
-+            model.gamma8((2, -1, -1)),
-+            model.gamma9((1, -1, -1)),
-+        ]
-+        tau_real = [
-+            2.0,
-+            8.0,
-+            0.333333,
-+            1.5,
-+            -19.5,
-+            0.666667,
-+            2.0,
-+            8.0,
-+            0.333333,
-+        ]
-+        assert_array_almost_equal(tau_calculated, tau_real)
-+
-+    def test_jspin(self):
-+        """
-+        PIQS: Test calculation of the j algebra relation for the total operators.
-+
-+        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
-+        basis should follow the following algebra
-+        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
-+        """
-+        N_list = [1, 2, 3, 4, 7]
-+
-+        for nn in N_list:
-+            # tests 1
-+            [jx, jy, jz] = jspin(nn)
-+            jp, jm = jspin(nn, "+"), jspin(nn, "-")
-+            test_jxjy = jx * jy - jy * jx
-+            true_jxjy = 1j * jz
-+            test_jpjm = jp * jm - jm * jp
-+            true_jpjm = 2 * jz
-+
-+            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
-+            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
-+
-+            # tests 2
-+            [jx, jy, jz] = jspin(nn)
-+            jp, jm = jspin(nn, "+"), jspin(nn, "-")
-+            test_jxjy = jx * jy - jy * jx
-+            true_jxjy = 1j * jz
-+            test_jpjm = jp * jm - jm * jp
-+            true_jpjm = 2 * jz
-+
-+            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
-+            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
-+
-+            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
-+            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
-+            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
-+            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
-+            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
-+            assert_raises(TypeError, jspin, nn, "q")
-+
-+    def test_j_min_(self):
-+        """
-+        PIQS: Test the `j_min` function.
-+        """
-+        even = [2, 4, 6, 8]
-+        odd = [1, 3, 5, 7]
-+
-+        for i in even:
-+            assert_(j_min(i) == 0)
-+
-+        for i in odd:
-+            assert_(j_min(i) == 0.5)
-+
-+    def test_energy_degeneracy(self):
-+        """
-+        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
-+        """
-+        true_en_deg = [1, 1, 1, 1, 1]
-+        true_en_deg_even = [2, 6, 20]
-+        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
-+        test_en_deg = []
-+        test_en_deg_even = []
-+        test_en_deg_odd = []
-+
-+        for nn in [1, 2, 3, 4, 7]:
-+            test_en_deg.append(energy_degeneracy(nn, nn / 2))
-+
-+        for nn in [2, 4, 6]:
-+            test_en_deg_even.append(energy_degeneracy(nn, 0))
-+
-+        for nn in [1, 3, 7]:
-+            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
-+            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
-+
-+        assert_array_equal(test_en_deg, true_en_deg)
-+        assert_array_equal(test_en_deg_even, true_en_deg_even)
-+        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
-+
-+    def test_state_degeneracy(self):
-+        """
-+        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
-+        state_degeneracy(N, j).
-+        """
-+        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
-+        state_deg = []
-+        state_deg = []
-+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-+            state_deg.append(state_degeneracy(nn, nn / 2))
-+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-+            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
-+        assert_array_equal(state_deg, true_state_deg)
-+
-+        # check error
-+        assert_raises(ValueError, state_degeneracy, 2, -1)
-+
-+    def test_m_degeneracy(self):
-+        """
-+        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
-+        """
-+        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
-+        m_deg = []
-+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-+            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
-+        assert_array_equal(m_deg, true_m_deg)
-+
-+        # check error
-+        assert_raises(ValueError, m_degeneracy, 6, -6)
-+
-+    def test_ap(self):
-+        """
-+        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
-+
-+        For given values of j, m. For a Dicke state,
-+        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
-+        """
-+        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
-+        ap_list = []
-+        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
-+            ap_list.append(ap(10, m) ** 2)
-+
-+        assert_almost_equal(ap_list, true_ap_list)
-+
-+    def test_am(self):
-+        """
-+        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
-+
-+        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
-+        """
-+        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
-+        am_list = []
-+        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
-+            am_list.append(am(10, m) ** 2)
-+
-+        assert_almost_equal(am_list, true_am_list)
-+
-+    def test_spin_algebra(self):
-+        """
-+        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
-+        The list [sx, sy, sz, sp, sm] is checked for N = 2.
-+        """
-+        sx1 = [
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        sx2 = [
-+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        sy1 = [
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        sy2 = [
-+            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
-+        ]
-+
-+        sz1 = [
-+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
-+        ]
-+
-+        sz2 = [
-+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
-+        ]
-+
-+        sp1 = [
-+            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        sp2 = [
-+            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        sm1 = [
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        sm2 = [
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
-+        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
-+        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
-+        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
-+        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
-+        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
-+        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
-+        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
-+        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
-+        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
-+
-+        # test error
-+        assert_raises(TypeError, spin_algebra, 2, "q")
-+
-+    def test_collective_algebra(self):
-+        """
-+        PIQS: Test the generation of the collective algebra in uncoupled basis.
-+
-+        The list [jx, jy, jz] created in the 2^N Hilbert space is
-+        checked for N = 2.
-+        """
-+
-+        jx_n2 = [
-+            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-+            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        jy_n2 = [
-+            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
-+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-+            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
-+        ]
-+
-+        jz_n2 = [
-+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
-+        ]
-+
-+        jp_n2 = [
-+            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        jm_n2 = [
-+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-+            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-+        ]
-+
-+        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
-+        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
-+        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
-+        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
-+        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
-+
-+        # error
-+        assert_raises(TypeError, spin_algebra, 2, "q")
-+
-+    def test_block_matrix(self):
-+        """
-+        PIQS: Test the calculation of the block-diagonal matrix for given N.
-+
-+        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
-+        """
-+        # N = 1 TLSs
-+        block_1 = [[1.0, 1.0], [1.0, 1.0]]
-+
-+        # N = 2 TLSs
-+        block_2 = [
-+            [1.0, 1.0, 1.0, 0.0],
-+            [1.0, 1.0, 1.0, 0.0],
-+            [1.0, 1.0, 1.0, 0.0],
-+            [0.0, 0.0, 0.0, 1.0],
-+        ]
-+
-+        # N = 3 TLSs
-+        block_3 = [
-+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-+            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
-+            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
-+        ]
-+
-+        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
-+        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
-+        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
-+
-+    def test_dicke_basis(self):
-+        """
-+        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
-+
-+        We test the state with for N = 2,
-+
-+        0   0   0.3 0
-+        0   0.5 0   0
-+        0.3 0   0   0
-+        0   0   0   0.5
-+        """
-+        N = 2
-+        true_dicke_basis = np.zeros((4, 4))
-+        true_dicke_basis[1, 1] = 0.5
-+        true_dicke_basis[-1, -1] = 0.5
-+        true_dicke_basis[0, 2] = 0.3
-+        true_dicke_basis[2, 0] = 0.3
-+        true_dicke_basis = Qobj(true_dicke_basis)
-+        jmm1_1 = {(N / 2, 0, 0): 0.5}
-+        jmm1_2 = {(0, 0, 0): 0.5}
-+        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
-+        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
-+        db1 = dicke_basis(2, jmm1_1)
-+        db2 = dicke_basis(2, jmm1_2)
-+        db3 = dicke_basis(2, jmm1_3)
-+        db4 = dicke_basis(2, jmm1_4)
-+        test_dicke_basis = db1 + db2 + db3 + db4
-+        assert_equal(test_dicke_basis, true_dicke_basis)
-+
-+        # error
-+        assert_raises(AttributeError, dicke_basis, N)
-+
-+    def test_dicke(self):
-+        """
-+        PIQS: Test the calculation of the Dicke state as a pure state.
-+        """
-+        true_excited = np.zeros((4, 4))
-+        true_excited[0, 0] = 1
-+
-+        true_superradiant = np.zeros((4, 4))
-+        true_superradiant[1, 1] = 1
-+
-+        true_subradiant = np.zeros((4, 4))
-+        true_subradiant[-1, -1] = 1
-+
-+        test_excited = dicke(2, 1, 1)
-+        test_superradiant = dicke(2, 1, 0)
-+        test_subradiant = dicke(2, 0, 0)
-+
-+        assert_equal(test_excited, Qobj(true_excited))
-+        assert_equal(test_superradiant, Qobj(true_superradiant))
-+        assert_equal(test_subradiant, Qobj(true_subradiant))
-+
-+    def test_excited(self):
-+        """
-+        PIQS: Test the calculation of the totally excited state density matrix.
-+
-+        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
-+        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
-+        """
-+        N = 3
-+        true_state = np.zeros((6, 6))
-+        true_state[0, 0] = 1
-+        true_state = Qobj(true_state)
-+
-+        test_state = excited(N)
-+        assert_equal(test_state, true_state)
-+
-+        N = 4
-+        true_state = np.zeros((9, 9))
-+        true_state[0, 0] = 1
-+        true_state = Qobj(true_state)
-+
-+        test_state = excited(N)
-+        assert_equal(test_state, true_state)
-+
-+        # uncoupled
-+        test_state_uncoupled = excited(2, basis="uncoupled")
-+        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
-+        assert_array_equal(test_state_uncoupled.shape, (4, 4))
-+        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
-+
-+    def test_superradiant(self):
-+        """
-+        PIQS: Test the calculation of the superradiant state density matrix.
-+
-+        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
-+        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
-+        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
-+        """
-+        N = 3
-+        true_state = np.zeros((6, 6))
-+        true_state[1, 1] = 1
-+        true_state = Qobj(true_state)
-+        test_state = superradiant(N)
-+        assert_equal(test_state, true_state)
-+        N = 4
-+        true_state = np.zeros((9, 9))
-+        true_state[2, 2] = 1
-+        true_state = Qobj(true_state)
-+        test_state = superradiant(N)
-+        assert_equal(test_state, true_state)
-+
-+        # uncoupled
-+        test_state_uncoupled = superradiant(2, basis="uncoupled")
-+        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
-+        assert_array_equal(test_state_uncoupled.shape, (4, 4))
-+        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
-+
-+    def test_ghz(self):
-+        """
-+        PIQS: Test the calculation of the density matrix of the GHZ state.
-+
-+        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
-+        """
-+        ghz_dicke = Qobj(
-+            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
-+        )
-+        ghz_uncoupled = Qobj(
-+            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
-+        )
-+        ghz_uncoupled.dims = [[2, 2], [2, 2]]
-+        assert_equal(ghz(2), ghz_dicke)
-+        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
-+
-+    def test_ground(self):
-+        """
-+        PIQS: Test the calculation of the density matrix of the ground state.
-+
-+        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
-+        """
-+        zeros = np.zeros((4, 4), dtype=np.complex128)
-+        gdicke = zeros.copy()
-+        guncoupled = zeros.copy()
-+        gdicke[2, 2] = 1
-+        guncoupled[3, 3] = 1
-+
-+        dim_dicke = [[4], [4]]
-+        dim_uncoupled = [[2, 2], [2, 2]]
-+
-+        test_ground_dicke = ground(2)
-+        test_ground_uncoupled = ground(2, "uncoupled")
-+
-+        assert_array_equal(test_ground_dicke.full(), gdicke)
-+        assert_array_equal(test_ground_dicke.dims, dim_dicke)
-+        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
-+        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
-+
-+    def test_identity_uncoupled(self):
-+        """
-+        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
-+        """
-+        test_identity = identity_uncoupled(4)
-+        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
-+        assert_array_equal(
-+            np.diag(test_identity.full()), np.ones(16, np.complex128)
-+        )
-+
-+    def test_css(self):
-+        """
-+        PIQS: Test the calculation of the CSS state.
-+        """
-+        test_css_uncoupled = css(2, basis="uncoupled")
-+        test_css_dicke = css(2)
-+        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
-+        css_dicke = np.array(
-+            [
-+                [
-+                    0.25000000 + 0.0j,
-+                    0.35355339 + 0.0j,
-+                    0.25000000 + 0.0j,
-+                    0.00000000 + 0.0j,
-+                ],
-+                [
-+                    0.35355339 + 0.0j,
-+                    0.50000000 + 0.0j,
-+                    0.35355339 + 0.0j,
-+                    0.00000000 + 0.0j,
-+                ],
-+                [
-+                    0.25000000 + 0.0j,
-+                    0.35355339 + 0.0j,
-+                    0.25000000 + 0.0j,
-+                    0.00000000 + 0.0j,
-+                ],
-+                [
-+                    0.00000000 + 0.0j,
-+                    0.00000000 + 0.0j,
-+                    0.00000000 + 0.0j,
-+                    0.00000000 + 0.0j,
-+                ],
-+            ]
-+        )
-+        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
-+        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
-+
-+    def test_collapse_uncoupled(self):
-+        """
-+        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
-+
-+        In the "uncoupled" basis of N two-level system (TLS).
-+        The test is performed for N = 2 and emission = 1.
-+        """
-+        c1 = Qobj(
-+            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
-+            dims=[[2, 2], [2, 2]],
-+        )
-+        c2 = Qobj(
-+            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
-+            dims=[[2, 2], [2, 2]],
-+        )
-+        true_c_ops = [c1, c2]
-+        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
-+        system = Dicke(N=2, emission=1)
-+        assert_equal(true_c_ops, system.c_ops())
-+
-+    def test_get_blocks(self):
-+        """
-+        PIQS: Test the calculation of list of cumulative elements at each block.
-+
-+        For N = 4
-+
-+        1 1 1 1 1
-+        1 1 1 1 1
-+        1 1 1 1 1
-+        1 1 1 1 1
-+        1 1 1 1 1
-+                1 1 1
-+                1 1 1
-+                1 1 1
-+                     1
-+        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
-+        elements have been accounted for and so on.
-+        """
-+        trueb1 = [2]
-+        trueb2 = [3, 4]
-+        trueb3 = [4, 6]
-+        trueb4 = [5, 8, 9]
-+
-+        test_b1 = get_blocks(1)
-+        test_b2 = get_blocks(2)
-+        test_b3 = get_blocks(3)
-+        test_b4 = get_blocks(4)
-+
-+        assert_equal(test_b1, trueb1)
-+        assert_equal(test_b2, trueb2)
-+        assert_equal(test_b3, trueb3)
-+
-+    def test_lindbladian_dims(self):
-+        """
-+        PIQS: Test the calculation of the lindbladian matrix.
-+        """
-+        true_L = [
-+            [-4, 0, 0, 3],
-+            [0, -3.54999995, 0, 0],
-+            [0, 0, -3.54999995, 0],
-+            [4, 0, 0, -3],
-+        ]
-+        true_L = Qobj(true_L)
-+        true_L.dims = [[[2], [2]], [[2], [2]]]
-+        N = 1
-+        test_dicke = _Dicke(
-+            N=N,
-+            pumping=1,
-+            collective_pumping=2,
-+            emission=1,
-+            collective_emission=3,
-+            dephasing=0.1,
-+        )
-+        test_L = test_dicke.lindbladian()
-+        assert_array_almost_equal(test_L.full(), true_L.full())
-+        assert_array_equal(test_L.dims, true_L.dims)
-+
-+    def test_liouvillian(self):
-+        """
-+        PIQS: Test the calculation of the liouvillian matrix.
-+        """
-+        true_L = [
-+            [-4, 0, 0, 3],
-+            [0, -3.54999995, 0, 0],
-+            [0, 0, -3.54999995, 0],
-+            [4, 0, 0, -3],
-+        ]
-+        true_L = Qobj(true_L)
-+        true_L.dims = [[[2], [2]], [[2], [2]]]
-+        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
-+        true_H = Qobj(true_H)
-+        true_H.dims = [[[2], [2]]]
-+        true_liouvillian = [
-+            [-4, -1.0j, 1.0j, 3],
-+            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
-+            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
-+            [4, +1.0j, -1.0j, -3],
-+        ]
-+        true_liouvillian = Qobj(true_liouvillian)
-+        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
-+        N = 1
-+        test_piqs = Dicke(
-+            hamiltonian=sigmaz() + sigmax(),
-+            N=N,
-+            pumping=1,
-+            collective_pumping=2,
-+            emission=1,
-+            collective_emission=3,
-+            dephasing=0.1,
-+        )
-+        test_liouvillian = test_piqs.liouvillian()
-+        test_hamiltonian = test_piqs.hamiltonian
-+        assert_array_almost_equal(
-+            test_liouvillian.full(), true_liouvillian.full()
-+        )
-+        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
-+        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
-+
-+        # no Hamiltonian
-+        test_piqs = Dicke(
-+            N=N,
-+            pumping=1,
-+            collective_pumping=2,
-+            emission=1,
-+            collective_emission=3,
-+            dephasing=0.1,
-+        )
-+        liouv = test_piqs.liouvillian()
-+        lindblad = test_piqs.lindbladian()
-+        assert_equal(liouv, lindblad)
-+
-+    def test_gamma1(self):
-+        """
-+        PIQS: Test the calculation of gamma1.
-+        """
-+        true_gamma_1 = -2
-+        true_gamma_2 = -3
-+        true_gamma_3 = -7
-+        true_gamma_4 = -1
-+        true_gamma_5 = 0
-+        true_gamma_6 = 0
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, collective_emission=1)
-+        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
-+        test_dicke = _Dicke(N=N, emission=1)
-+        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
-+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-+        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
-+        test_dicke = _Dicke(N=N, dephasing=4)
-+        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
-+        test_dicke = _Dicke(N=N, collective_pumping=2)
-+        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
-+        test_dicke = _Dicke(N=N, collective_dephasing=2)
-+        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+        assert_almost_equal(true_gamma_5, test_gamma_5)
-+        assert_almost_equal(true_gamma_6, test_gamma_6)
-+
-+    def test_gamma2(self):
-+        """
-+        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 2
-+        true_gamma_2 = 1.5
-+        true_gamma_3 = 5.5
-+        true_gamma_4 = 0
-+        true_gamma_5 = 0
-+        true_gamma_6 = 0
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, collective_emission=1)
-+        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
-+        test_dicke = _Dicke(N=N, emission=1)
-+        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
-+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-+        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
-+        test_dicke = _Dicke(N=N, dephasing=4)
-+        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
-+        test_dicke = _Dicke(N=N, collective_pumping=2)
-+        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
-+        test_dicke = _Dicke(N=N, collective_dephasing=2)
-+        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+        assert_almost_equal(true_gamma_5, test_gamma_5)
-+        assert_almost_equal(true_gamma_6, test_gamma_6)
-+
-+    def test_gamma3(self):
-+        """
-+        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 0
-+        true_gamma_2 = 1.3333333730697632
-+        true_gamma_3 = 1.3333333730697632
-+        true_gamma_4 = 0
-+        true_gamma_5 = 0
-+        true_gamma_6 = 0
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, collective_emission=1)
-+        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
-+        test_dicke = _Dicke(N=N, emission=1)
-+        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
-+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-+        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
-+        test_dicke = _Dicke(N=N, dephasing=4)
-+        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
-+        test_dicke = _Dicke(N=N, collective_pumping=2)
-+        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
-+        test_dicke = _Dicke(N=N, collective_dephasing=2)
-+        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
-+        #
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+        assert_almost_equal(true_gamma_5, test_gamma_5)
-+        assert_almost_equal(true_gamma_6, test_gamma_6)
-+
-+    def test_gamma4(self):
-+        """
-+        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 0.1666666716337204
-+        true_gamma_2 = 2
-+        true_gamma_3 = 0
-+        true_gamma_4 = 0.40824830532073975
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-+        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
-+        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
-+        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
-+        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+
-+    def test_gamma5(self):
-+        """
-+        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 0
-+        true_gamma_2 = 0
-+        true_gamma_3 = 0.75
-+        true_gamma_4 = 0
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, dephasing=1)
-+        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
-+        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
-+        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
-+        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+
-+    def test_gamma6(self):
-+        """
-+        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 0.25
-+        true_gamma_2 = 1
-+        true_gamma_3 = 0
-+        true_gamma_4 = 0.25
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, dephasing=1)
-+        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
-+        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
-+        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
-+        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+
-+    def test_gamma7(self):
-+        """
-+        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 0
-+        true_gamma_2 = 0.5
-+        true_gamma_3 = 0
-+        true_gamma_4 = 1.5
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, pumping=1)
-+        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
-+        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
-+        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
-+        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+
-+    def test_gamma8(self):
-+        """
-+        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 0
-+        true_gamma_2 = 13.5
-+        true_gamma_3 = 5.5
-+        true_gamma_4 = 13.5
-+
-+        N = 4
-+        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
-+        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
-+        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
-+        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
-+        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
-+
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+
-+    def test_gamma9(self):
-+        """
-+        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
-+        """
-+        true_gamma_1 = 1
-+        true_gamma_2 = 0
-+        true_gamma_3 = 0.5
-+        true_gamma_4 = 0
-+        N = 4
-+        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
-+        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
-+        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
-+        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
-+        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
-+        assert_almost_equal(true_gamma_1, test_gamma_1)
-+        assert_almost_equal(true_gamma_2, test_gamma_2)
-+        assert_almost_equal(true_gamma_3, test_gamma_3)
-+        assert_almost_equal(true_gamma_4, test_gamma_4)
-+
-+
-+class TestPim:
-+    """
-+    Tests for the `qutip.piqs.Pim` class.
-+    """
-+
-+    def test_gamma(self):
-+        """
-+        PIQS: Test the calculation of various gamma values for diagonal system.
-+
-+        For N = 6 |j, m> would be :
-+
-+        | 3, 3>
-+        | 3, 2> | 2, 2>
-+        | 3, 1> | 2, 1> | 1, 1>
-+        | 3, 0> | 2, 0> | 1, 0> |0, 0>
-+        | 3,-1> | 2,-1> | 1,-1>
-+        | 3,-2> | 2,-2>
-+        | 3,-3>
-+        """
-+        N = 6
-+        collective_emission = 1.0
-+        emission = 1.0
-+        dephasing = 1.0
-+        pumping = 1.0
-+        collective_pumping = 1.0
-+        model = Pim(
-+            N,
-+            collective_emission=collective_emission,
-+            emission=emission,
-+            dephasing=dephasing,
-+            pumping=pumping,
-+            collective_pumping=collective_pumping,
-+        )
-+        tau_calculated = [
-+            model.tau3(3, 1),
-+            model.tau2(2, 1),
-+            model.tau4(1, 1),
-+            model.tau5(3, 0),
-+            model.tau1(2, 0),
-+            model.tau6(1, 0),
-+            model.tau7(3, -1),
-+            model.tau8(2, -1),
-+            model.tau9(1, -1),
-+        ]
-+        tau_real = [
-+            2.0,
-+            8.0,
-+            0.333333,
-+            1.5,
-+            -19.5,
-+            0.666667,
-+            2.0,
-+            8.0,
-+            0.333333,
-+        ]
-+        assert_array_almost_equal(tau_calculated, tau_real)
-+
-+    def test_isdicke(self):
-+        """
-+        PIQS: Test the `isdicke` function
-+        """
-+        N1 = 1
-+        g0 = 0.01
-+        nth = 0.01
-+        gP = g0 * nth
-+        gL = g0 * (0.1 + nth)
-+        gS = 0.1
-+        gD = 0.1
-+
-+        pim1 = Pim(N1, gS, gL, gD, gP)
-+
-+        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
-+        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
-+
-+        N2 = 4
-+
-+        pim2 = Pim(N2, gS, gL, gD, gP)
-+        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
-+        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
-+
-+        assert_array_equal(dicke_labels, [True, False, True, False, True])
-+
-+    def test_isdiagonal(self):
-+        """
-+        PIQS: Test the isdiagonal function.
-+        """
-+        mat1 = np.array([[1, 2], [3, 4]])
-+        mat2 = np.array([[1, 0.0], [0.0, 2]])
-+        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
-+        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
-+        assert_equal(isdiagonal(mat1), False)
-+        assert_equal(isdiagonal(mat2), True)
-+        assert_equal(isdiagonal(mat3), False)
-+        assert_equal(isdiagonal(mat4), True)
-+
-+    def test_pisolve(self):
-+        """
-+        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
-+        """
-+        jx, jy, jz = jspin(4)
-+        jp, jm = jspin(4, "+"), jspin(4, "-")
-+
-+    def test_coefficient_matrix(self):
-+        """
-+        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
-+        """
-+        N = 2
-+        ensemble = Pim(N, emission=1)
-+        test_matrix = ensemble.coefficient_matrix().toarray()
-+        ensemble2 = Dicke(N, emission=1)
-+        test_matrix2 = ensemble.coefficient_matrix().toarray()
-+        true_matrix = [
-+            [-2, 0, 0, 0],
-+            [1, -1, 0, 0],
-+            [0, 1, 0, 1.0],
-+            [1, 0, 0, -1.0],
-+        ]
-+
-+        assert_array_almost_equal(test_matrix, true_matrix)
-+        assert_array_almost_equal(test_matrix2, true_matrix)
-+
-+    def test_pisolve(self):
-+        """
-+        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
-+        """
-+        jx, jy, jz = jspin(4)
-+        jp, jm = jspin(4, "+"), jspin(4, "-")
-+        non_diag_hamiltonian = jx
-+        diag_hamiltonian = jz
-+
-+        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
-+        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
-+
-+        diag_initial_state = dicke(4, 1, 0)
-+        non_diag_initial_state = ghz(4)
-+        tlist = np.linspace(0, 10, 100)
-+
-+        assert_raises(
-+            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
-+        )
-+        assert_raises(
-+            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
-+        )
-+        assert_raises(
-+            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
-+        )
-+
-+        non_dicke_initial_state = excited(4, basis="uncoupled")
-+        assert_raises(
-+            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
-+        )
-+
-+        # no Hamiltonian
-+        no_hamiltonian_system = Dicke(4, emission=0.1)
-+        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
-+        assert_equal(True, len(result.states) > 0)
-+
-+
-+if __name__ == "__main__":
-+    run_module_suite()
-diff --git a/qutip/tests/solve/test_qubit_evolution.py b/qutip/tests/solve/test_qubit_evolution.py
-index d75697f9..7157e3ff 100644
---- a/qutip/tests/solve/test_qubit_evolution.py
-+++ b/qutip/tests/solve/test_qubit_evolution.py
-@@ -1,124 +1,124 @@
--import numpy as np
--import pytest
--from qutip import (
--    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
--)
--
--
--def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
--
--    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
--
--    c_op_list = []
--
--    rate = g1
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * sigmam())
--
--    rate = g2
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * sigmaz())
--
--    e_ops = [sigmax(), sigmay(), sigmaz()]
--
--    if solver == "me":
--        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
--    elif solver == "mc":
--        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
--    else:
--        raise ValueError("unknown solver")
--
--    return output.expect[0], output.expect[1], output.expect[2]
--
--
--def test_MESolverCase1():
--    """
--    Test mesolve qubit, with dissipation
--    """
--
--    epsilon = 0.0 * 2 * np.pi   # cavity frequency
--    delta = 1.0 * 2 * np.pi   # atom frequency
--    g2 = 0.1
--    g1 = 0.0
--    psi0 = basis(2, 0)        # initial state
--    tlist = np.linspace(0, 5, 200)
--
--    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
--
--    sx_analytic = np.zeros(np.shape(tlist))
--    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
--    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
--
--    assert max(abs(sx - sx_analytic)) < 0.05
--    assert max(abs(sy - sy_analytic)) < 0.05
--    assert max(abs(sz - sz_analytic)) < 0.05
--
--
--def test_MESolverCase2():
--    """
--    Test mesolve qubit, no dissipation
--    """
--
--    epsilon = 0.0 * 2 * np.pi   # cavity frequency
--    delta = 1.0 * 2 * np.pi   # atom frequency
--    g2 = 0.0
--    g1 = 0.0
--    psi0 = basis(2, 0)        # initial state
--    tlist = np.linspace(0, 5, 200)
--
--    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
--
--    sx_analytic = np.zeros(np.shape(tlist))
--    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
--    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
--
--    assert max(abs(sx - sx_analytic)) < 0.05
--    assert max(abs(sy - sy_analytic)) < 0.05
--    assert max(abs(sz - sz_analytic)) < 0.05
--
--
--def test_MCSolverCase1():
--    """
--    Test mcsolve qubit, with dissipation
--    """
--
--    epsilon = 0.0 * 2 * np.pi      # cavity frequency
--    delta = 1.0 * 2 * np.pi        # atom frequency
--    g2 = 0.1
--    g1 = 0.0
--    psi0 = basis(2, 0)          # initial state
--    tlist = np.linspace(0, 5, 200)
--
--    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
--
--    sx_analytic = np.zeros(np.shape(tlist))
--    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
--    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
--
--    assert max(abs(sx - sx_analytic)) < 0.25
--    assert max(abs(sy - sy_analytic)) < 0.25
--    assert max(abs(sz - sz_analytic)) < 0.25
--
--
--@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
--def test_MCSolverCase2():
--    """
--    Test mcsolve qubit, no dissipation
--    """
--
--    epsilon = 0.0 * 2 * np.pi      # cavity frequency
--    delta = 1.0 * 2 * np.pi        # atom frequency
--    g2 = 0.0
--    g1 = 0.0
--    psi0 = basis(2, 0)          # initial state
--    tlist = np.linspace(0, 5, 200)
--
--    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
--
--    sx_analytic = np.zeros(np.shape(tlist))
--    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
--    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
--
--    assert max(abs(sx - sx_analytic)) < 0.25
--    assert max(abs(sy - sy_analytic)) < 0.25
--    assert max(abs(sz - sz_analytic)) < 0.25
-+import numpy as np
-+import pytest
-+from qutip import (
-+    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
-+)
-+
-+
-+def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
-+
-+    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
-+
-+    c_op_list = []
-+
-+    rate = g1
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * sigmam())
-+
-+    rate = g2
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * sigmaz())
-+
-+    e_ops = [sigmax(), sigmay(), sigmaz()]
-+
-+    if solver == "me":
-+        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
-+    elif solver == "mc":
-+        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
-+    else:
-+        raise ValueError("unknown solver")
-+
-+    return output.expect[0], output.expect[1], output.expect[2]
-+
-+
-+def test_MESolverCase1():
-+    """
-+    Test mesolve qubit, with dissipation
-+    """
-+
-+    epsilon = 0.0 * 2 * np.pi   # cavity frequency
-+    delta = 1.0 * 2 * np.pi   # atom frequency
-+    g2 = 0.1
-+    g1 = 0.0
-+    psi0 = basis(2, 0)        # initial state
-+    tlist = np.linspace(0, 5, 200)
-+
-+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
-+
-+    sx_analytic = np.zeros(np.shape(tlist))
-+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+
-+    assert max(abs(sx - sx_analytic)) < 0.05
-+    assert max(abs(sy - sy_analytic)) < 0.05
-+    assert max(abs(sz - sz_analytic)) < 0.05
-+
-+
-+def test_MESolverCase2():
-+    """
-+    Test mesolve qubit, no dissipation
-+    """
-+
-+    epsilon = 0.0 * 2 * np.pi   # cavity frequency
-+    delta = 1.0 * 2 * np.pi   # atom frequency
-+    g2 = 0.0
-+    g1 = 0.0
-+    psi0 = basis(2, 0)        # initial state
-+    tlist = np.linspace(0, 5, 200)
-+
-+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
-+
-+    sx_analytic = np.zeros(np.shape(tlist))
-+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+
-+    assert max(abs(sx - sx_analytic)) < 0.05
-+    assert max(abs(sy - sy_analytic)) < 0.05
-+    assert max(abs(sz - sz_analytic)) < 0.05
-+
-+
-+def test_MCSolverCase1():
-+    """
-+    Test mcsolve qubit, with dissipation
-+    """
-+
-+    epsilon = 0.0 * 2 * np.pi      # cavity frequency
-+    delta = 1.0 * 2 * np.pi        # atom frequency
-+    g2 = 0.1
-+    g1 = 0.0
-+    psi0 = basis(2, 0)          # initial state
-+    tlist = np.linspace(0, 5, 200)
-+
-+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
-+
-+    sx_analytic = np.zeros(np.shape(tlist))
-+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+
-+    assert max(abs(sx - sx_analytic)) < 0.25
-+    assert max(abs(sy - sy_analytic)) < 0.25
-+    assert max(abs(sz - sz_analytic)) < 0.25
-+
-+
-+@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
-+def test_MCSolverCase2():
-+    """
-+    Test mcsolve qubit, no dissipation
-+    """
-+
-+    epsilon = 0.0 * 2 * np.pi      # cavity frequency
-+    delta = 1.0 * 2 * np.pi        # atom frequency
-+    g2 = 0.0
-+    g1 = 0.0
-+    psi0 = basis(2, 0)          # initial state
-+    tlist = np.linspace(0, 5, 200)
-+
-+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
-+
-+    sx_analytic = np.zeros(np.shape(tlist))
-+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+
-+    assert max(abs(sx - sx_analytic)) < 0.25
-+    assert max(abs(sy - sy_analytic)) < 0.25
-+    assert max(abs(sz - sz_analytic)) < 0.25
-diff --git a/qutip/tests/solve/test_stochastic_me.py b/qutip/tests/solve/test_stochastic_me.py
-index 27ac7c82..f282254b 100644
---- a/qutip/tests/solve/test_stochastic_me.py
-+++ b/qutip/tests/solve/test_stochastic_me.py
-@@ -1,309 +1,309 @@
--import pytest
--import numpy as np
--from numpy.testing import assert_, run_module_suite
--
--from qutip import (
--    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
--    destroy, coherent, qeye, fock_dm, general_stochastic, num,
--)
--from qutip.solve.parallel import parallel_map
--from qutip.core import data as _data
--def f(t, args):
--    return args["a"] * t
--
--
--@pytest.mark.slow
--def test_smesolve_homodyne_methods():
--    "Stochastic: smesolve: homodyne methods with single jump operator"
--
--    def arccoth(x):
--        return 0.5*np.log((1.+x)/(x-1.))
--
--    th = 0.1 # Interaction parameter
--    alpha = np.cos(th)
--    beta = np.sin(th)
--    gamma = 1.
--
--    N = 30                 # number of Fock states
--    Id = qeye(N)
--    a = destroy(N)
--    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
--    x = (a + a.dag()) * 2**-0.5
--    H = Id
--    c_op = [gamma**0.5 * a]
--    sc_op = [s]
--    e_op = [x, x*x]
--    rho0 = fock_dm(N,0)      # initial vacuum state
--
--    T = 3.                   # final time
--    # number of time steps for which we save the expectation values
--    N_store = 121
--    Nsub = 10
--    tlist = np.linspace(0, T, N_store)
--    ddt = (tlist[1]-tlist[0])
--
--    #### Analytic solution
--    y0 = 0.5
--    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
--    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
--    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
--
--
--    list_methods_tol = [['euler-maruyama', 2e-2],
--                        ['pc-euler', 2e-3],
--                        ['pc-euler-2', 2e-3],
--                        ['platen', 1e-3],
--                        ['milstein', 1e-3],
--                        ['milstein-imp', 1e-3],
--                        ['rouchon', 1e-3],
--                        ['taylor1.5', 1e-4],
--                        ['taylor1.5-imp', 1e-4],
--                        ['explicit1.5', 1e-4],
--                        ['taylor2.0', 1e-4]]
--    for n_method in list_methods_tol:
--        # Comparisons of error between sol and sol3 depend on the stochastic
--        # noise, thus the seed, fixing the seed remove random fails.
--        np.random.seed(1)
--        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
--                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
--        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
--                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
--                       noise = sol.noise)
--        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
--                        nsubsteps=Nsub*5, method='homodyne',
--                        solver = n_method[0], tol=1e-8)
--        err = 1/T * np.sum(np.abs(y_an - \
--                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
--        err3 = 1/T * np.sum(np.abs(y_an - \
--                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
--        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
--        assert_(err < n_method[1])
--        # 5* more substep should decrease the error
--        assert_(err3 < err)
--        # just to check that noise is not affected by smesolve
--        assert_(np.all(sol.noise == sol2.noise))
--        assert_(np.all(sol.expect[0] == sol2.expect[0]))
--
--    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
--                    nsubsteps=Nsub, method='homodyne', solver='euler',
--                    store_measurement=1)
--    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
--                    nsubsteps=Nsub, method='homodyne', solver='euler',
--                    store_measurement=0)
--    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
--                    nsubsteps=Nsub, method='homodyne', solver='euler')
--    # sol and sol2 have the same seed, sol3 differ.
--    assert_(np.all(sol.noise == sol2.noise))
--    assert_(np.all(sol.noise != sol3.noise))
--    assert_(not np.all(sol.measurement[0] == 0.+0j))
--    assert_(np.all(sol2.measurement[0] == 0.+0j))
--    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
--                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
--    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
--                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
--    # sol and sol2 have the seed of traj 1 and 2 reversed.
--    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
--    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
--
--
--def test_smesolve_photocurrent():
--    "Stochastic: photocurrent_mesolve"
--    tol = 0.01
--
--    N = 4
--    gamma = 0.25
--    ntraj = 20
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [[a.dag() * a,f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    times = np.linspace(0, 1.0, 21)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
--                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
--                   map_func=parallel_map)
--
--    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
--                 for idx in range(len(e_ops))]))
--    assert_(len(res.measurement) == ntraj)
--    assert_(all([m.shape == (len(times), len(sc_ops))
--                 for m in res.measurement]))
--
--
--def test_smesolve_homodyne():
--    "Stochastic: smesolve: homodyne, time-dependent H"
--    tol = 0.01
--
--    N = 4
--    gamma = 0.25
--    ntraj = 20
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [[a.dag() * a,f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    times = np.linspace(0, 1.0, 21)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    list_methods_tol = ['euler-maruyama',
--                        'pc-euler',
--                        'pc-euler-2',
--                        'platen',
--                        'milstein',
--                        'milstein-imp',
--                        'rouchon',
--                        'taylor15',
--                        'taylor15-imp',
--                        'explicit15']
--    for solver in list_methods_tol:
--        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
--                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
--                       method='homodyne', store_measurement=True,
--                       solver=solver, map_func=parallel_map)
--        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
--                     for idx in range(len(e_ops))]))
--        assert_(len(res.measurement) == ntraj)
--        assert_(all([m.shape == (len(times), len(sc_ops))
--                     for m in res.measurement]))
--
--
--@pytest.mark.slow
--def test_smesolve_heterodyne():
--    "Stochastic: smesolve: heterodyne, time-dependent H"
--    tol = 0.01
--
--    N = 4
--    gamma = 0.25
--    ntraj = 20
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [[a.dag() * a, f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    times = np.linspace(0, 1.0, 21)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    list_methods_tol = ['euler-maruyama',
--                        'pc-euler',
--                        'pc-euler-2',
--                        'platen',
--                        'milstein',
--                        'milstein-imp',
--                        'rouchon',
--                        'taylor15',
--                        'taylor15-imp',
--                        'explicit15']
--    for solver in list_methods_tol:
--        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
--                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
--                       method='heterodyne', store_measurement=True,
--                       solver=solver, map_func=parallel_map)
--        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
--                     for idx in range(len(e_ops))]))
--        assert_(len(res.measurement) == ntraj)
--        assert_(all([m.shape == (len(times), len(sc_ops), 2)
--                     for m in res.measurement]))
--
--
--@pytest.mark.slow
--def test_general_stochastic():
--    "Stochastic: general_stochastic"
--    "Reproduce smesolve homodyne"
--    tol = 0.025
--    N = 4
--    gamma = 0.25
--    ntraj = 20
--    nsubsteps = 50
--    a = destroy(N)
--
--    H = [[a.dag() * a,f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
--    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
--    e_opsM = [spre(op) for op in e_ops]
--
--    def d1(t, vec):
--        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
--
--    def d2(t, vec):
--        out = []
--        vec_d = _data.Dense(vec)
--        for op in sc_opsM:
--            scale = -op.expect_data(t,vec_d)
--            out.append(
--                _data.add(op.matmul_data(t,vec_d),
--                          vec_d, scale)
--                )
--        return np.stack([o.to_array().ravel() for o in out])
--
--    times = np.linspace(0, 0.5, 13)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    list_methods_tol = ['euler-maruyama',
--                        'platen',
--                        'explicit15']
--    for solver in list_methods_tol:
--        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
--                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
--                                 nsubsteps=nsubsteps, solver=solver)
--    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
--                 for idx in range(len(e_ops))]))
--    assert_(len(res.measurement) == ntraj)
--
--
--def f_dargs(a, args):
--    return args["expect_op_3"] - 1
--
--
--@pytest.mark.xfail(reason="not working yet")
--def test_ssesolve_feedback():
--    "Stochastic: ssesolve: time-dependent H with feedback"
--    tol = 0.01
--    N = 4
--    ntraj = 10
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [num(N)]
--    psi0 = coherent(N, 2.5)
--    sc_ops = [[a + a.dag(), f_dargs]]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
--
--    times = np.linspace(0, 10, 101)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
--                      args={"expect_op_3":qeye(N)})
--    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
--                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
--                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
--
--    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
--
--
--def test_smesolve_bad_e_ops():
--    "Stochastic: ssesolve: time-dependent H with feedback"
--    tol = 0.01
--    N = 4
--    ntraj = 10
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [num(N)]
--    psi0 = coherent(N, 2.5)
--    sc_ops = [a + a.dag()]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
--
--    times = np.linspace(0, 10, 101)
--    with pytest.raises(TypeError) as exc:
--        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
--                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
--                       map_func=parallel_map)
-+import pytest
-+import numpy as np
-+from numpy.testing import assert_, run_module_suite
-+
-+from qutip import (
-+    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
-+    destroy, coherent, qeye, fock_dm, general_stochastic, num,
-+)
-+from qutip.solve.parallel import parallel_map
-+from qutip.core import data as _data
-+def f(t, args):
-+    return args["a"] * t
-+
-+
-+@pytest.mark.slow
-+def test_smesolve_homodyne_methods():
-+    "Stochastic: smesolve: homodyne methods with single jump operator"
-+
-+    def arccoth(x):
-+        return 0.5*np.log((1.+x)/(x-1.))
-+
-+    th = 0.1 # Interaction parameter
-+    alpha = np.cos(th)
-+    beta = np.sin(th)
-+    gamma = 1.
-+
-+    N = 30                 # number of Fock states
-+    Id = qeye(N)
-+    a = destroy(N)
-+    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-+    x = (a + a.dag()) * 2**-0.5
-+    H = Id
-+    c_op = [gamma**0.5 * a]
-+    sc_op = [s]
-+    e_op = [x, x*x]
-+    rho0 = fock_dm(N,0)      # initial vacuum state
-+
-+    T = 3.                   # final time
-+    # number of time steps for which we save the expectation values
-+    N_store = 121
-+    Nsub = 10
-+    tlist = np.linspace(0, T, N_store)
-+    ddt = (tlist[1]-tlist[0])
-+
-+    #### Analytic solution
-+    y0 = 0.5
-+    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
-+    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
-+    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
-+
-+
-+    list_methods_tol = [['euler-maruyama', 2e-2],
-+                        ['pc-euler', 2e-3],
-+                        ['pc-euler-2', 2e-3],
-+                        ['platen', 1e-3],
-+                        ['milstein', 1e-3],
-+                        ['milstein-imp', 1e-3],
-+                        ['rouchon', 1e-3],
-+                        ['taylor1.5', 1e-4],
-+                        ['taylor1.5-imp', 1e-4],
-+                        ['explicit1.5', 1e-4],
-+                        ['taylor2.0', 1e-4]]
-+    for n_method in list_methods_tol:
-+        # Comparisons of error between sol and sol3 depend on the stochastic
-+        # noise, thus the seed, fixing the seed remove random fails.
-+        np.random.seed(1)
-+        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-+                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
-+        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
-+                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
-+                       noise = sol.noise)
-+        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-+                        nsubsteps=Nsub*5, method='homodyne',
-+                        solver = n_method[0], tol=1e-8)
-+        err = 1/T * np.sum(np.abs(y_an - \
-+                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-+        err3 = 1/T * np.sum(np.abs(y_an - \
-+                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-+        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
-+        assert_(err < n_method[1])
-+        # 5* more substep should decrease the error
-+        assert_(err3 < err)
-+        # just to check that noise is not affected by smesolve
-+        assert_(np.all(sol.noise == sol2.noise))
-+        assert_(np.all(sol.expect[0] == sol2.expect[0]))
-+
-+    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-+                    nsubsteps=Nsub, method='homodyne', solver='euler',
-+                    store_measurement=1)
-+    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-+                    nsubsteps=Nsub, method='homodyne', solver='euler',
-+                    store_measurement=0)
-+    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
-+                    nsubsteps=Nsub, method='homodyne', solver='euler')
-+    # sol and sol2 have the same seed, sol3 differ.
-+    assert_(np.all(sol.noise == sol2.noise))
-+    assert_(np.all(sol.noise != sol3.noise))
-+    assert_(not np.all(sol.measurement[0] == 0.+0j))
-+    assert_(np.all(sol2.measurement[0] == 0.+0j))
-+    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
-+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-+    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
-+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-+    # sol and sol2 have the seed of traj 1 and 2 reversed.
-+    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
-+    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
-+
-+
-+def test_smesolve_photocurrent():
-+    "Stochastic: photocurrent_mesolve"
-+    tol = 0.01
-+
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 20
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a,f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    times = np.linspace(0, 1.0, 21)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
-+                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
-+                   map_func=parallel_map)
-+
-+    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-+                 for idx in range(len(e_ops))]))
-+    assert_(len(res.measurement) == ntraj)
-+    assert_(all([m.shape == (len(times), len(sc_ops))
-+                 for m in res.measurement]))
-+
-+
-+def test_smesolve_homodyne():
-+    "Stochastic: smesolve: homodyne, time-dependent H"
-+    tol = 0.01
-+
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 20
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a,f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    times = np.linspace(0, 1.0, 21)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    list_methods_tol = ['euler-maruyama',
-+                        'pc-euler',
-+                        'pc-euler-2',
-+                        'platen',
-+                        'milstein',
-+                        'milstein-imp',
-+                        'rouchon',
-+                        'taylor15',
-+                        'taylor15-imp',
-+                        'explicit15']
-+    for solver in list_methods_tol:
-+        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-+                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-+                       method='homodyne', store_measurement=True,
-+                       solver=solver, map_func=parallel_map)
-+        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-+                     for idx in range(len(e_ops))]))
-+        assert_(len(res.measurement) == ntraj)
-+        assert_(all([m.shape == (len(times), len(sc_ops))
-+                     for m in res.measurement]))
-+
-+
-+@pytest.mark.slow
-+def test_smesolve_heterodyne():
-+    "Stochastic: smesolve: heterodyne, time-dependent H"
-+    tol = 0.01
-+
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 20
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a, f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    times = np.linspace(0, 1.0, 21)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    list_methods_tol = ['euler-maruyama',
-+                        'pc-euler',
-+                        'pc-euler-2',
-+                        'platen',
-+                        'milstein',
-+                        'milstein-imp',
-+                        'rouchon',
-+                        'taylor15',
-+                        'taylor15-imp',
-+                        'explicit15']
-+    for solver in list_methods_tol:
-+        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-+                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-+                       method='heterodyne', store_measurement=True,
-+                       solver=solver, map_func=parallel_map)
-+        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-+                     for idx in range(len(e_ops))]))
-+        assert_(len(res.measurement) == ntraj)
-+        assert_(all([m.shape == (len(times), len(sc_ops), 2)
-+                     for m in res.measurement]))
-+
-+
-+@pytest.mark.slow
-+def test_general_stochastic():
-+    "Stochastic: general_stochastic"
-+    "Reproduce smesolve homodyne"
-+    tol = 0.025
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 20
-+    nsubsteps = 50
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a,f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
-+    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
-+    e_opsM = [spre(op) for op in e_ops]
-+
-+    def d1(t, vec):
-+        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
-+
-+    def d2(t, vec):
-+        out = []
-+        vec_d = _data.Dense(vec)
-+        for op in sc_opsM:
-+            scale = -op.expect_data(t,vec_d)
-+            out.append(
-+                _data.add(op.matmul_data(t,vec_d),
-+                          vec_d, scale)
-+                )
-+        return np.stack([o.to_array().ravel() for o in out])
-+
-+    times = np.linspace(0, 0.5, 13)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    list_methods_tol = ['euler-maruyama',
-+                        'platen',
-+                        'explicit15']
-+    for solver in list_methods_tol:
-+        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
-+                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
-+                                 nsubsteps=nsubsteps, solver=solver)
-+    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-+                 for idx in range(len(e_ops))]))
-+    assert_(len(res.measurement) == ntraj)
-+
-+
-+def f_dargs(a, args):
-+    return args["expect_op_3"] - 1
-+
-+
-+@pytest.mark.xfail(reason="not working yet")
-+def test_ssesolve_feedback():
-+    "Stochastic: ssesolve: time-dependent H with feedback"
-+    tol = 0.01
-+    N = 4
-+    ntraj = 10
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [num(N)]
-+    psi0 = coherent(N, 2.5)
-+    sc_ops = [[a + a.dag(), f_dargs]]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-+
-+    times = np.linspace(0, 10, 101)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-+                      args={"expect_op_3":qeye(N)})
-+    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-+                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-+                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
-+
-+    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
-+
-+
-+def test_smesolve_bad_e_ops():
-+    "Stochastic: ssesolve: time-dependent H with feedback"
-+    tol = 0.01
-+    N = 4
-+    ntraj = 10
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [num(N)]
-+    psi0 = coherent(N, 2.5)
-+    sc_ops = [a + a.dag()]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
-+
-+    times = np.linspace(0, 10, 101)
-+    with pytest.raises(TypeError) as exc:
-+        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-+                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-+                       map_func=parallel_map)
-diff --git a/qutip/tests/solve/test_stochastic_se.py b/qutip/tests/solve/test_stochastic_se.py
-index 8a40f2d7..e18ec023 100644
---- a/qutip/tests/solve/test_stochastic_se.py
-+++ b/qutip/tests/solve/test_stochastic_se.py
-@@ -1,230 +1,230 @@
--import pytest
--import numpy as np
--from numpy.testing import assert_
--
--from qutip import (
--    ssesolve, destroy, coherent, mesolve, fock, qeye,
--    photocurrent_sesolve, num,
--)
--from qutip.solve.parallel import parallel_map
--
--def f(t, args):
--    return args["a"] * t
--
--
--@pytest.mark.slow
--def test_ssesolve_homodyne_methods():
--    "Stochastic: ssesolve: homodyne methods with single jump operator"
--
--    def arccoth(x):
--        return 0.5*np.log((1.+x)/(x-1.))
--
--    th = 0.1 # Interaction parameter
--    alpha = np.cos(th)
--    beta = np.sin(th)
--    gamma = 1.
--
--    N = 30                 # number of Fock states
--    Id = qeye(N)
--    a = destroy(N)
--    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
--    x = (a + a.dag()) * 2**-0.5
--    H = Id + gamma * a * a.dag()
--    sc_op = [s]
--    e_op = [x, x*x]
--    rho0 = fock(N,0)      # initial vacuum state
--
--    T = 6.                   # final time
--    # number of time steps for which we save the expectation values
--    N_store = 200
--    Nsub = 10
--    tlist = np.linspace(0, T, N_store)
--    ddt = (tlist[1]-tlist[0])
--
--    #### No analytic solution for ssesolve, taylor15 with 500 substep
--    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
--                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
--    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
--
--
--    list_methods_tol = [['euler-maruyama', 3e-2],
--                        ['pc-euler', 5e-3],
--                        ['pc-euler-2', 5e-3],
--                        ['platen', 5e-3],
--                        ['milstein', 5e-3],
--                        ['milstein-imp', 5e-3],
--                        ['taylor1.5', 5e-4],
--                        ['taylor1.5-imp', 5e-4],
--                        ['explicit1.5', 5e-4],
--                        ['taylor2.0', 5e-4]]
--    for n_method in list_methods_tol:
--        # Comparisons of error between sol and sol3 depend on the stochastic
--        # noise, thus the seed, fixing the seed remove random fails.
--        np.random.seed(1)
--        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
--                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
--        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
--                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
--                       noise = sol.noise)
--        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
--                        nsubsteps=Nsub*10, method='homodyne',
--                        solver=n_method[0], tol=1e-8)
--        err = 1/T * np.sum(np.abs(y_an - \
--                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
--        err3 = 1/T * np.sum(np.abs(y_an - \
--                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
--        assert err < n_method[1]
--        # 5* more substep should decrease the error
--        assert err3 < err
--        # just to check that noise is not affected by ssesolve
--        assert np.all(sol.noise == sol2.noise)
--        assert np.all(sol.expect[0] == sol2.expect[0])
--
--    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
--                    nsubsteps=Nsub, method='homodyne', solver='euler',
--                    store_measurement=1)
--    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
--                    nsubsteps=Nsub, method='homodyne', solver='euler',
--                    store_measurement=0)
--    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
--                    nsubsteps=Nsub, method='homodyne', solver='euler')
--    # sol and sol2 have the same seed, sol3 differ.
--    assert np.all(sol.noise == sol2.noise)
--    assert np.all(sol.noise != sol3.noise)
--    assert not np.all(sol.measurement[0] == 0.+0j)
--    assert np.all(sol2.measurement[0] == 0.+0j)
--    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
--                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
--    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
--                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
--    # sol and sol2 have the seed of traj 1 and 2 reversed.
--    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
--    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
--
--
--def test_ssesolve_photocurrent():
--    "Stochastic: photocurrent_sesolve"
--    tol = 0.01
--
--    N = 4
--    gamma = 0.25
--    ntraj = 25
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [[a.dag() * a,f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    times = np.linspace(0, 2.5, 50)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
--                              nsubsteps=nsubsteps, store_measurement=True,
--                              map_func=parallel_map, args={"a":2})
--
--    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
--    assert len(res.measurement) == ntraj
--    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
--
--
--def test_ssesolve_homodyne():
--    "Stochastic: ssesolve: homodyne, time-dependent H"
--    tol = 0.01
--
--    N = 4
--    gamma = 0.25
--    ntraj = 25
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [[a.dag() * a,f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    times = np.linspace(0, 2.5, 50)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    res = ssesolve(H, psi0, times, sc_ops, e_ops,
--                   ntraj=ntraj, nsubsteps=nsubsteps,
--                   method='homodyne', store_measurement=True,
--                   map_func=parallel_map, args={"a":2})
--
--    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
--    assert len(res.measurement) == ntraj
--    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
--
--
--@pytest.mark.slow
--def test_ssesolve_heterodyne():
--    "Stochastic: ssesolve: heterodyne, time-dependent H"
--    tol = 0.01
--
--    N = 4
--    gamma = 0.25
--    ntraj = 25
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [[a.dag() * a,f]]
--    psi0 = coherent(N, 0.5)
--    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
--
--    times = np.linspace(0, 2.5, 50)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
--    res = ssesolve(H, psi0, times, sc_ops, e_ops,
--                   ntraj=ntraj, nsubsteps=nsubsteps,
--                   method='heterodyne', store_measurement=True,
--                   map_func=parallel_map, args={"a":2})
--
--    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
--    assert len(res.measurement) == ntraj
--    assert all(m.shape == (len(times), len(sc_ops), 2)
--               for m in res.measurement)
--
--
--def f_dargs(t, args):
--    return args["expect_op_3"] - 1
--
--
--@pytest.mark.xfail(reason="not yet working")
--def test_ssesolve_feedback():
--    "Stochastic: ssesolve: time-dependent H with feedback"
--    tol = 0.01
--    N = 4
--    ntraj = 10
--    nsubsteps = 100
--    a = destroy(N)
--
--    H = [num(N)]
--    psi0 = coherent(N, 2.5)
--    sc_ops = [[a + a.dag(), f_dargs]]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
--
--    times = np.linspace(0, 10, 101)
--    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
--                      args={"expect_op_3": qeye(N)})
--    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
--                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
--                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
--    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
--
--
--def test_ssesolve_bad_e_ops():
--    tol = 0.01
--    N = 4
--    ntraj = 10
--    nsubsteps = 100
--    a = destroy(N)
--    b = destroy(N-1)
--
--    H = [num(N)]
--    psi0 = coherent(N, 2.5)
--    sc_ops = [a + a.dag()]
--    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
--    times = np.linspace(0, 10, 101)
--    with pytest.raises(TypeError) as exc:
--        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
--                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
--                       map_func=parallel_map)
-+import pytest
-+import numpy as np
-+from numpy.testing import assert_
-+
-+from qutip import (
-+    ssesolve, destroy, coherent, mesolve, fock, qeye,
-+    photocurrent_sesolve, num,
-+)
-+from qutip.solve.parallel import parallel_map
-+
-+def f(t, args):
-+    return args["a"] * t
-+
-+
-+@pytest.mark.slow
-+def test_ssesolve_homodyne_methods():
-+    "Stochastic: ssesolve: homodyne methods with single jump operator"
-+
-+    def arccoth(x):
-+        return 0.5*np.log((1.+x)/(x-1.))
-+
-+    th = 0.1 # Interaction parameter
-+    alpha = np.cos(th)
-+    beta = np.sin(th)
-+    gamma = 1.
-+
-+    N = 30                 # number of Fock states
-+    Id = qeye(N)
-+    a = destroy(N)
-+    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-+    x = (a + a.dag()) * 2**-0.5
-+    H = Id + gamma * a * a.dag()
-+    sc_op = [s]
-+    e_op = [x, x*x]
-+    rho0 = fock(N,0)      # initial vacuum state
-+
-+    T = 6.                   # final time
-+    # number of time steps for which we save the expectation values
-+    N_store = 200
-+    Nsub = 10
-+    tlist = np.linspace(0, T, N_store)
-+    ddt = (tlist[1]-tlist[0])
-+
-+    #### No analytic solution for ssesolve, taylor15 with 500 substep
-+    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-+                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
-+    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
-+
-+
-+    list_methods_tol = [['euler-maruyama', 3e-2],
-+                        ['pc-euler', 5e-3],
-+                        ['pc-euler-2', 5e-3],
-+                        ['platen', 5e-3],
-+                        ['milstein', 5e-3],
-+                        ['milstein-imp', 5e-3],
-+                        ['taylor1.5', 5e-4],
-+                        ['taylor1.5-imp', 5e-4],
-+                        ['explicit1.5', 5e-4],
-+                        ['taylor2.0', 5e-4]]
-+    for n_method in list_methods_tol:
-+        # Comparisons of error between sol and sol3 depend on the stochastic
-+        # noise, thus the seed, fixing the seed remove random fails.
-+        np.random.seed(1)
-+        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-+                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
-+        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
-+                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
-+                       noise = sol.noise)
-+        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
-+                        nsubsteps=Nsub*10, method='homodyne',
-+                        solver=n_method[0], tol=1e-8)
-+        err = 1/T * np.sum(np.abs(y_an - \
-+                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-+        err3 = 1/T * np.sum(np.abs(y_an - \
-+                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-+        assert err < n_method[1]
-+        # 5* more substep should decrease the error
-+        assert err3 < err
-+        # just to check that noise is not affected by ssesolve
-+        assert np.all(sol.noise == sol2.noise)
-+        assert np.all(sol.expect[0] == sol2.expect[0])
-+
-+    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-+                    nsubsteps=Nsub, method='homodyne', solver='euler',
-+                    store_measurement=1)
-+    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-+                    nsubsteps=Nsub, method='homodyne', solver='euler',
-+                    store_measurement=0)
-+    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
-+                    nsubsteps=Nsub, method='homodyne', solver='euler')
-+    # sol and sol2 have the same seed, sol3 differ.
-+    assert np.all(sol.noise == sol2.noise)
-+    assert np.all(sol.noise != sol3.noise)
-+    assert not np.all(sol.measurement[0] == 0.+0j)
-+    assert np.all(sol2.measurement[0] == 0.+0j)
-+    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
-+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-+    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
-+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-+    # sol and sol2 have the seed of traj 1 and 2 reversed.
-+    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
-+    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
-+
-+
-+def test_ssesolve_photocurrent():
-+    "Stochastic: photocurrent_sesolve"
-+    tol = 0.01
-+
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 25
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a,f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    times = np.linspace(0, 2.5, 50)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
-+                              nsubsteps=nsubsteps, store_measurement=True,
-+                              map_func=parallel_map, args={"a":2})
-+
-+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-+    assert len(res.measurement) == ntraj
-+    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
-+
-+
-+def test_ssesolve_homodyne():
-+    "Stochastic: ssesolve: homodyne, time-dependent H"
-+    tol = 0.01
-+
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 25
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a,f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    times = np.linspace(0, 2.5, 50)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-+                   ntraj=ntraj, nsubsteps=nsubsteps,
-+                   method='homodyne', store_measurement=True,
-+                   map_func=parallel_map, args={"a":2})
-+
-+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-+    assert len(res.measurement) == ntraj
-+    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
-+
-+
-+@pytest.mark.slow
-+def test_ssesolve_heterodyne():
-+    "Stochastic: ssesolve: heterodyne, time-dependent H"
-+    tol = 0.01
-+
-+    N = 4
-+    gamma = 0.25
-+    ntraj = 25
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [[a.dag() * a,f]]
-+    psi0 = coherent(N, 0.5)
-+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-+
-+    times = np.linspace(0, 2.5, 50)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-+    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-+                   ntraj=ntraj, nsubsteps=nsubsteps,
-+                   method='heterodyne', store_measurement=True,
-+                   map_func=parallel_map, args={"a":2})
-+
-+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-+    assert len(res.measurement) == ntraj
-+    assert all(m.shape == (len(times), len(sc_ops), 2)
-+               for m in res.measurement)
-+
-+
-+def f_dargs(t, args):
-+    return args["expect_op_3"] - 1
-+
-+
-+@pytest.mark.xfail(reason="not yet working")
-+def test_ssesolve_feedback():
-+    "Stochastic: ssesolve: time-dependent H with feedback"
-+    tol = 0.01
-+    N = 4
-+    ntraj = 10
-+    nsubsteps = 100
-+    a = destroy(N)
-+
-+    H = [num(N)]
-+    psi0 = coherent(N, 2.5)
-+    sc_ops = [[a + a.dag(), f_dargs]]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-+
-+    times = np.linspace(0, 10, 101)
-+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-+                      args={"expect_op_3": qeye(N)})
-+    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-+                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-+                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
-+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-+
-+
-+def test_ssesolve_bad_e_ops():
-+    tol = 0.01
-+    N = 4
-+    ntraj = 10
-+    nsubsteps = 100
-+    a = destroy(N)
-+    b = destroy(N-1)
-+
-+    H = [num(N)]
-+    psi0 = coherent(N, 2.5)
-+    sc_ops = [a + a.dag()]
-+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
-+    times = np.linspace(0, 10, 101)
-+    with pytest.raises(TypeError) as exc:
-+        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-+                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-+                       map_func=parallel_map)
-diff --git a/qutip/tests/solver/heom/test_bofin_baths.py b/qutip/tests/solver/heom/test_bofin_baths.py
-index c6c5c80f..32a4eca2 100644
---- a/qutip/tests/solver/heom/test_bofin_baths.py
-+++ b/qutip/tests/solver/heom/test_bofin_baths.py
-@@ -1,465 +1,465 @@
--"""
--Tests for qutip.nonmarkov.bofin_baths.
--"""
--
--import numpy as np
--import pytest
--
--from qutip import spre, spost, sigmax, sigmaz
--from qutip.core import data as _data
--from qutip.solver.heom.bofin_baths import (
--    BathExponent,
--    Bath,
--    BosonicBath,
--    DrudeLorentzBath,
--    DrudeLorentzPadeBath,
--    UnderDampedBath,
--    FermionicBath,
--    LorentzianBath,
--    LorentzianPadeBath,
--)
--
--
--def isequal(Q1, Q2, tol):
--    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
--    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
--
--
--def check_exponent(
--    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
--):
--    """ Check the attributes of a BathExponent. """
--    assert exp.type is BathExponent.types[type]
--    assert exp.fermionic == (type in ["+", "-"])
--    assert exp.dim == dim
--    assert exp.Q == Q
--    assert exp.ck == pytest.approx(ck)
--    assert exp.vk == pytest.approx(vk)
--    assert exp.ck2 == pytest.approx(ck2)
--    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
--    assert exp.tag == tag
--
--
--class TestBathExponent:
--    def test_create(self):
--        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
--        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
--
--        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
--        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
--
--        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
--        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
--
--        exp_p = BathExponent(
--            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
--        )
--        check_exponent(
--            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
--        )
--
--        exp_m = BathExponent(
--            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
--        )
--        check_exponent(
--            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
--        )
--
--        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
--        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
--
--        for exp_type, kw in [
--            ("R", {}),
--            ("I", {}),
--            ("+", {"sigma_bar_k_offset": 1}),
--            ("-", {"sigma_bar_k_offset": -1}),
--        ]:
--            with pytest.raises(ValueError) as err:
--                BathExponent(
--                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
--                )
--            assert str(err.value) == (
--                "Second co-efficient (ck2) should only be specified for RI"
--                " bath exponents"
--            )
--
--        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
--            with pytest.raises(ValueError) as err:
--                BathExponent(
--                    exp_type, None, Q=None, ck=1.0, vk=2.0,
--                    sigma_bar_k_offset=1, **kw,
--                )
--            assert str(err.value) == (
--                "Offset of sigma bar (sigma_bar_k_offset) should only be"
--                " specified for + and - bath exponents"
--            )
--
--    def test_repr(self):
--        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
--        assert repr(exp1) == (
--            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
--            " ck=1.0 vk=2.0 ck2=None"
--            " sigma_bar_k_offset=None fermionic=False tag=None>"
--        )
--        exp2 = BathExponent(
--            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
--            tag="bath1",
--        )
--        assert repr(exp2) == (
--            "<BathExponent type=+ dim=None Q.dims=None"
--            " ck=1.0 vk=2.0 ck2=None"
--            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
--        )
--
--
--class TestBath:
--    def test_create(self):
--        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
--        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
--        bath = Bath([exp_r, exp_i])
--        assert bath.exponents == [exp_r, exp_i]
--
--
--class TestBosonicBath:
--    def test_create(self):
--        Q = sigmaz()
--        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
--        exp_r, exp_i = bath.exponents
--        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
--        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
--
--        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
--        [exp_ri] = bath.exponents
--        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
--
--        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
--        exp_r, exp_i = bath.exponents
--        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
--        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
--
--        with pytest.raises(ValueError) as err:
--            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
--        assert str(err.value) == "The coupling operator Q must be a Qobj."
--
--        with pytest.raises(ValueError) as err:
--            BosonicBath(Q, [1.], [], [2.], [0.6])
--        assert str(err.value) == (
--            "The bath exponent lists ck_real and vk_real, and ck_imag and"
--            " vk_imag must be the same length."
--        )
--
--        with pytest.raises(ValueError) as err:
--            BosonicBath(Q, [1.], [0.5], [2.], [])
--        assert str(err.value) == (
--            "The bath exponent lists ck_real and vk_real, and ck_imag and"
--            " vk_imag must be the same length."
--        )
--
--    def test_combine(self):
--        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
--        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
--        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
--        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
--
--        [exp] = BosonicBath.combine([exp_rx, exp_rx])
--        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
--
--        [exp] = BosonicBath.combine([exp_ix, exp_ix])
--        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
--
--        [exp] = BosonicBath.combine([exp_rix, exp_rix])
--        check_exponent(
--            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
--        )
--
--        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
--        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
--        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
--
--        [exp] = BosonicBath.combine([exp_rx, exp_ix])
--        check_exponent(
--            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
--        )
--
--        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
--        check_exponent(
--            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
--        )
--
--
--class TestDrudeLorentzBath:
--    def test_create(self):
--        Q = sigmaz()
--        ck_real = [0.05262168274189053, 0.0007958201977617107]
--        vk_real = [0.05, 6.613879270715354]
--        ck_imag = [-0.0012500000000000002]
--        vk_imag = [0.05]
--
--        bath = DrudeLorentzBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
--        )
--        [exp1, exp2] = bath.exponents
--        check_exponent(
--            exp1, "RI", dim=None, Q=Q,
--            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
--            tag="bath1",
--        )
--        check_exponent(
--            exp2, "R", dim=None, Q=Q,
--            ck=ck_real[1], vk=vk_real[1],
--            tag="bath1",
--        )
--
--        bath = DrudeLorentzBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
--        )
--        [exp1, exp2, exp3] = bath.exponents
--        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
--        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
--        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
--
--    @pytest.mark.parametrize(['combine'], [
--        pytest.param(True, id="combine"),
--        pytest.param(False, id="no-combine"),
--    ])
--    def test_terminator(self, combine):
--        Q = sigmaz()
--        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
--
--        bath = DrudeLorentzBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
--        )
--        delta, terminator = bath.terminator()
--
--        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
--        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
--
--
--class TestDrudeLorentzPadeBath:
--    def test_create(self):
--        Q = sigmaz()
--        ck_real = [0.05262168274189053, 0.0016138037466648136]
--        vk_real = [0.05, 8.153649149910352]
--        ck_imag = [-0.0012500000000000002]
--        vk_imag = [0.05]
--
--        bath = DrudeLorentzPadeBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
--        )
--        [exp1, exp2] = bath.exponents
--        check_exponent(
--            exp1, "RI", dim=None, Q=Q,
--            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
--            tag="bath1",
--        )
--        check_exponent(
--            exp2, "R", dim=None, Q=Q,
--            ck=ck_real[1], vk=vk_real[1],
--            tag="bath1",
--        )
--
--        bath = DrudeLorentzPadeBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
--        )
--        [exp1, exp2, exp3] = bath.exponents
--        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
--        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
--        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
--
--    @pytest.mark.parametrize(['combine'], [
--        pytest.param(True, id="combine"),
--        pytest.param(False, id="no-combine"),
--    ])
--    def test_terminator(self, combine):
--        Q = sigmaz()
--        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
--
--        bath = DrudeLorentzPadeBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
--        )
--        delta, terminator = bath.terminator()
--
--        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
--        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
--
--
--class TestUnderDampedBath:
--    def test_create(self):
--        Q = sigmaz()
--        ck_real = [
--            0.0003533235200322013-7.634500355085952e-06j,
--            0.0003533235200322013+7.634500355085952e-06j,
--            -2.173594134367819e-07+0j,
--        ]
--        vk_real = [
--            0.025-0.9996874511566103j,
--            0.025+0.9996874511566103j,
--            6.613879270715354,
--        ]
--        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
--        vk_imag = [
--            0.025-0.9996874511566103j,
--            0.025+0.9996874511566103j,
--        ]
--
--        bath = UnderDampedBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
--        )
--        [exp1, exp2, exp3] = bath.exponents
--        check_exponent(
--            exp1, "RI", dim=None, Q=Q,
--            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
--            tag="bath1",
--        )
--        check_exponent(
--            exp2, "RI", dim=None, Q=Q,
--            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
--            tag="bath1",
--        )
--        check_exponent(
--            exp3, "R", dim=None, Q=Q,
--            ck=ck_real[2], vk=vk_real[2],
--            tag="bath1",
--        )
--
--        bath = UnderDampedBath(
--            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
--        )
--        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
--        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
--        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
--        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
--        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
--        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
--
--
--class TestFermionicBath:
--    def test_create(self):
--        Q = 1j * sigmaz()
--        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
--        exp_p, exp_m = bath.exponents
--        check_exponent(
--            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
--        )
--        check_exponent(
--            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
--        )
--
--        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
--        exp_p, exp_m = bath.exponents
--        check_exponent(
--            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
--            tag="bath1",
--        )
--        check_exponent(
--            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
--            tag="bath1",
--        )
--
--        with pytest.raises(ValueError) as err:
--            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
--        assert str(err.value) == "The coupling operator Q must be a Qobj."
--
--        with pytest.raises(ValueError) as err:
--            FermionicBath(Q, [1.], [], [2.], [0.6])
--        assert str(err.value) == (
--            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
--            " vk_minus must be the same length."
--        )
--
--        with pytest.raises(ValueError) as err:
--            FermionicBath(Q, [1.], [0.5], [2.], [])
--        assert str(err.value) == (
--            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
--            " vk_minus must be the same length."
--        )
--
--
--class TestLorentzianBath:
--    def test_create(self):
--        Q = sigmaz()
--        ck_plus = [
--            0.0025-0.0013376935246402686j,
--            -0.00026023645770006167j,
--            -0.0002748355116913478j,
--        ]
--        vk_plus = [
--            1+1j,
--            0.08121642500626945+1j,
--            0.24364927501880834+1j,
--        ]
--        ck_minus = [
--            0.0025-0.0013376935246402686j,
--            -0.00026023645770006167j,
--            -0.0002748355116913478j,
--        ]
--        vk_minus = [
--            1-1j,
--            0.08121642500626945-1j,
--            0.24364927501880834-1j,
--        ]
--
--        bath = LorentzianBath(
--            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
--        )
--        assert len(bath.exponents) == 6
--        for i in range(len(ck_plus)):
--            exp_p = bath.exponents[2 * i]
--            exp_m = bath.exponents[2 * i + 1]
--            check_exponent(
--                exp_p, "+", dim=2, Q=Q,
--                ck=ck_plus[i], vk=vk_plus[i],
--                sigma_bar_k_offset=1,
--                tag="bath1",
--            )
--            check_exponent(
--                exp_m, "-", dim=2, Q=Q,
--                ck=ck_minus[i], vk=vk_minus[i],
--                sigma_bar_k_offset=-1,
--                tag="bath1",
--            )
--
--
--class TestLorentzianPadeBath:
--    def test_create(self):
--        Q = sigmaz()
--        ck_plus = [
--            0.0025+0.0014269000277373958j,
--            -0.0002608459250597002j,
--            -0.0011660541026776957j,
--        ]
--        vk_plus = [
--            1+1j,
--            0.08123902308117874+1j,
--            0.3371925267385835+1j,
--        ]
--        ck_minus = [
--            0.0025+0.0014269000277373958j,
--            -0.0002608459250597002j,
--            -0.0011660541026776957j,
--        ]
--        vk_minus = [
--            1-1j,
--            0.08123902308117874-1j,
--            0.3371925267385835-1j,
--        ]
--
--        bath = LorentzianPadeBath(
--            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
--        )
--        assert len(bath.exponents) == 6
--        for i in range(len(ck_plus)):
--            exp_p = bath.exponents[2 * i]
--            exp_m = bath.exponents[2 * i + 1]
--            check_exponent(
--                exp_p, "+", dim=2, Q=Q,
--                ck=ck_plus[i], vk=vk_plus[i],
--                sigma_bar_k_offset=1,
--                tag="bath1",
--            )
--            check_exponent(
--                exp_m, "-", dim=2, Q=Q,
--                ck=ck_minus[i], vk=vk_minus[i],
--                sigma_bar_k_offset=-1,
--                tag="bath1",
--            )
-+"""
-+Tests for qutip.nonmarkov.bofin_baths.
-+"""
-+
-+import numpy as np
-+import pytest
-+
-+from qutip import spre, spost, sigmax, sigmaz
-+from qutip.core import data as _data
-+from qutip.solver.heom.bofin_baths import (
-+    BathExponent,
-+    Bath,
-+    BosonicBath,
-+    DrudeLorentzBath,
-+    DrudeLorentzPadeBath,
-+    UnderDampedBath,
-+    FermionicBath,
-+    LorentzianBath,
-+    LorentzianPadeBath,
-+)
-+
-+
-+def isequal(Q1, Q2, tol):
-+    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
-+    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
-+
-+
-+def check_exponent(
-+    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
-+):
-+    """ Check the attributes of a BathExponent. """
-+    assert exp.type is BathExponent.types[type]
-+    assert exp.fermionic == (type in ["+", "-"])
-+    assert exp.dim == dim
-+    assert exp.Q == Q
-+    assert exp.ck == pytest.approx(ck)
-+    assert exp.vk == pytest.approx(vk)
-+    assert exp.ck2 == pytest.approx(ck2)
-+    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
-+    assert exp.tag == tag
-+
-+
-+class TestBathExponent:
-+    def test_create(self):
-+        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
-+        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
-+
-+        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
-+        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
-+
-+        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
-+        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
-+
-+        exp_p = BathExponent(
-+            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-+        )
-+        check_exponent(
-+            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-+        )
-+
-+        exp_m = BathExponent(
-+            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
-+        )
-+        check_exponent(
-+            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
-+        )
-+
-+        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
-+        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
-+
-+        for exp_type, kw in [
-+            ("R", {}),
-+            ("I", {}),
-+            ("+", {"sigma_bar_k_offset": 1}),
-+            ("-", {"sigma_bar_k_offset": -1}),
-+        ]:
-+            with pytest.raises(ValueError) as err:
-+                BathExponent(
-+                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
-+                )
-+            assert str(err.value) == (
-+                "Second co-efficient (ck2) should only be specified for RI"
-+                " bath exponents"
-+            )
-+
-+        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
-+            with pytest.raises(ValueError) as err:
-+                BathExponent(
-+                    exp_type, None, Q=None, ck=1.0, vk=2.0,
-+                    sigma_bar_k_offset=1, **kw,
-+                )
-+            assert str(err.value) == (
-+                "Offset of sigma bar (sigma_bar_k_offset) should only be"
-+                " specified for + and - bath exponents"
-+            )
-+
-+    def test_repr(self):
-+        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
-+        assert repr(exp1) == (
-+            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
-+            " ck=1.0 vk=2.0 ck2=None"
-+            " sigma_bar_k_offset=None fermionic=False tag=None>"
-+        )
-+        exp2 = BathExponent(
-+            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-+            tag="bath1",
-+        )
-+        assert repr(exp2) == (
-+            "<BathExponent type=+ dim=None Q.dims=None"
-+            " ck=1.0 vk=2.0 ck2=None"
-+            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
-+        )
-+
-+
-+class TestBath:
-+    def test_create(self):
-+        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
-+        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
-+        bath = Bath([exp_r, exp_i])
-+        assert bath.exponents == [exp_r, exp_i]
-+
-+
-+class TestBosonicBath:
-+    def test_create(self):
-+        Q = sigmaz()
-+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
-+        exp_r, exp_i = bath.exponents
-+        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
-+        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
-+
-+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
-+        [exp_ri] = bath.exponents
-+        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
-+
-+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
-+        exp_r, exp_i = bath.exponents
-+        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
-+        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
-+
-+        with pytest.raises(ValueError) as err:
-+            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
-+        assert str(err.value) == "The coupling operator Q must be a Qobj."
-+
-+        with pytest.raises(ValueError) as err:
-+            BosonicBath(Q, [1.], [], [2.], [0.6])
-+        assert str(err.value) == (
-+            "The bath exponent lists ck_real and vk_real, and ck_imag and"
-+            " vk_imag must be the same length."
-+        )
-+
-+        with pytest.raises(ValueError) as err:
-+            BosonicBath(Q, [1.], [0.5], [2.], [])
-+        assert str(err.value) == (
-+            "The bath exponent lists ck_real and vk_real, and ck_imag and"
-+            " vk_imag must be the same length."
-+        )
-+
-+    def test_combine(self):
-+        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
-+        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
-+        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
-+        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
-+
-+        [exp] = BosonicBath.combine([exp_rx, exp_rx])
-+        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
-+
-+        [exp] = BosonicBath.combine([exp_ix, exp_ix])
-+        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
-+
-+        [exp] = BosonicBath.combine([exp_rix, exp_rix])
-+        check_exponent(
-+            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
-+        )
-+
-+        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
-+        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
-+        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
-+
-+        [exp] = BosonicBath.combine([exp_rx, exp_ix])
-+        check_exponent(
-+            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
-+        )
-+
-+        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
-+        check_exponent(
-+            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
-+        )
-+
-+
-+class TestDrudeLorentzBath:
-+    def test_create(self):
-+        Q = sigmaz()
-+        ck_real = [0.05262168274189053, 0.0007958201977617107]
-+        vk_real = [0.05, 6.613879270715354]
-+        ck_imag = [-0.0012500000000000002]
-+        vk_imag = [0.05]
-+
-+        bath = DrudeLorentzBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
-+        )
-+        [exp1, exp2] = bath.exponents
-+        check_exponent(
-+            exp1, "RI", dim=None, Q=Q,
-+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-+            tag="bath1",
-+        )
-+        check_exponent(
-+            exp2, "R", dim=None, Q=Q,
-+            ck=ck_real[1], vk=vk_real[1],
-+            tag="bath1",
-+        )
-+
-+        bath = DrudeLorentzBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
-+        )
-+        [exp1, exp2, exp3] = bath.exponents
-+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-+        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-+
-+    @pytest.mark.parametrize(['combine'], [
-+        pytest.param(True, id="combine"),
-+        pytest.param(False, id="no-combine"),
-+    ])
-+    def test_terminator(self, combine):
-+        Q = sigmaz()
-+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-+
-+        bath = DrudeLorentzBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
-+        )
-+        delta, terminator = bath.terminator()
-+
-+        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
-+        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
-+
-+
-+class TestDrudeLorentzPadeBath:
-+    def test_create(self):
-+        Q = sigmaz()
-+        ck_real = [0.05262168274189053, 0.0016138037466648136]
-+        vk_real = [0.05, 8.153649149910352]
-+        ck_imag = [-0.0012500000000000002]
-+        vk_imag = [0.05]
-+
-+        bath = DrudeLorentzPadeBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
-+        )
-+        [exp1, exp2] = bath.exponents
-+        check_exponent(
-+            exp1, "RI", dim=None, Q=Q,
-+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-+            tag="bath1",
-+        )
-+        check_exponent(
-+            exp2, "R", dim=None, Q=Q,
-+            ck=ck_real[1], vk=vk_real[1],
-+            tag="bath1",
-+        )
-+
-+        bath = DrudeLorentzPadeBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
-+        )
-+        [exp1, exp2, exp3] = bath.exponents
-+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-+        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-+
-+    @pytest.mark.parametrize(['combine'], [
-+        pytest.param(True, id="combine"),
-+        pytest.param(False, id="no-combine"),
-+    ])
-+    def test_terminator(self, combine):
-+        Q = sigmaz()
-+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-+
-+        bath = DrudeLorentzPadeBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
-+        )
-+        delta, terminator = bath.terminator()
-+
-+        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
-+        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
-+
-+
-+class TestUnderDampedBath:
-+    def test_create(self):
-+        Q = sigmaz()
-+        ck_real = [
-+            0.0003533235200322013-7.634500355085952e-06j,
-+            0.0003533235200322013+7.634500355085952e-06j,
-+            -2.173594134367819e-07+0j,
-+        ]
-+        vk_real = [
-+            0.025-0.9996874511566103j,
-+            0.025+0.9996874511566103j,
-+            6.613879270715354,
-+        ]
-+        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
-+        vk_imag = [
-+            0.025-0.9996874511566103j,
-+            0.025+0.9996874511566103j,
-+        ]
-+
-+        bath = UnderDampedBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
-+        )
-+        [exp1, exp2, exp3] = bath.exponents
-+        check_exponent(
-+            exp1, "RI", dim=None, Q=Q,
-+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-+            tag="bath1",
-+        )
-+        check_exponent(
-+            exp2, "RI", dim=None, Q=Q,
-+            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
-+            tag="bath1",
-+        )
-+        check_exponent(
-+            exp3, "R", dim=None, Q=Q,
-+            ck=ck_real[2], vk=vk_real[2],
-+            tag="bath1",
-+        )
-+
-+        bath = UnderDampedBath(
-+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
-+        )
-+        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
-+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-+        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
-+        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-+        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
-+
-+
-+class TestFermionicBath:
-+    def test_create(self):
-+        Q = 1j * sigmaz()
-+        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
-+        exp_p, exp_m = bath.exponents
-+        check_exponent(
-+            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
-+        )
-+        check_exponent(
-+            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
-+        )
-+
-+        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
-+        exp_p, exp_m = bath.exponents
-+        check_exponent(
-+            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
-+            tag="bath1",
-+        )
-+        check_exponent(
-+            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
-+            tag="bath1",
-+        )
-+
-+        with pytest.raises(ValueError) as err:
-+            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
-+        assert str(err.value) == "The coupling operator Q must be a Qobj."
-+
-+        with pytest.raises(ValueError) as err:
-+            FermionicBath(Q, [1.], [], [2.], [0.6])
-+        assert str(err.value) == (
-+            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-+            " vk_minus must be the same length."
-+        )
-+
-+        with pytest.raises(ValueError) as err:
-+            FermionicBath(Q, [1.], [0.5], [2.], [])
-+        assert str(err.value) == (
-+            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-+            " vk_minus must be the same length."
-+        )
-+
-+
-+class TestLorentzianBath:
-+    def test_create(self):
-+        Q = sigmaz()
-+        ck_plus = [
-+            0.0025-0.0013376935246402686j,
-+            -0.00026023645770006167j,
-+            -0.0002748355116913478j,
-+        ]
-+        vk_plus = [
-+            1+1j,
-+            0.08121642500626945+1j,
-+            0.24364927501880834+1j,
-+        ]
-+        ck_minus = [
-+            0.0025-0.0013376935246402686j,
-+            -0.00026023645770006167j,
-+            -0.0002748355116913478j,
-+        ]
-+        vk_minus = [
-+            1-1j,
-+            0.08121642500626945-1j,
-+            0.24364927501880834-1j,
-+        ]
-+
-+        bath = LorentzianBath(
-+            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
-+        )
-+        assert len(bath.exponents) == 6
-+        for i in range(len(ck_plus)):
-+            exp_p = bath.exponents[2 * i]
-+            exp_m = bath.exponents[2 * i + 1]
-+            check_exponent(
-+                exp_p, "+", dim=2, Q=Q,
-+                ck=ck_plus[i], vk=vk_plus[i],
-+                sigma_bar_k_offset=1,
-+                tag="bath1",
-+            )
-+            check_exponent(
-+                exp_m, "-", dim=2, Q=Q,
-+                ck=ck_minus[i], vk=vk_minus[i],
-+                sigma_bar_k_offset=-1,
-+                tag="bath1",
-+            )
-+
-+
-+class TestLorentzianPadeBath:
-+    def test_create(self):
-+        Q = sigmaz()
-+        ck_plus = [
-+            0.0025+0.0014269000277373958j,
-+            -0.0002608459250597002j,
-+            -0.0011660541026776957j,
-+        ]
-+        vk_plus = [
-+            1+1j,
-+            0.08123902308117874+1j,
-+            0.3371925267385835+1j,
-+        ]
-+        ck_minus = [
-+            0.0025+0.0014269000277373958j,
-+            -0.0002608459250597002j,
-+            -0.0011660541026776957j,
-+        ]
-+        vk_minus = [
-+            1-1j,
-+            0.08123902308117874-1j,
-+            0.3371925267385835-1j,
-+        ]
-+
-+        bath = LorentzianPadeBath(
-+            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
-+        )
-+        assert len(bath.exponents) == 6
-+        for i in range(len(ck_plus)):
-+            exp_p = bath.exponents[2 * i]
-+            exp_m = bath.exponents[2 * i + 1]
-+            check_exponent(
-+                exp_p, "+", dim=2, Q=Q,
-+                ck=ck_plus[i], vk=vk_plus[i],
-+                sigma_bar_k_offset=1,
-+                tag="bath1",
-+            )
-+            check_exponent(
-+                exp_m, "-", dim=2, Q=Q,
-+                ck=ck_minus[i], vk=vk_minus[i],
-+                sigma_bar_k_offset=-1,
-+                tag="bath1",
-+            )
-diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
-index 72b737a9..69935d01 100644
---- a/qutip/tests/solver/heom/test_bofin_solvers.py
-+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
-@@ -1,1396 +1,1396 @@
--"""
--Tests for qutip.nonmarkov.bofin_solvers.
--"""
--
--import numpy as np
--import pytest
--from numpy.linalg import eigvalsh
--from scipy.integrate import quad
--
--from qutip import (
--    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
--    tensor, Qobj, QobjEvo
--)
--from qutip.core import data as _data
--from qutip.solver.heom.bofin_baths import (
--    BathExponent,
--    Bath,
--    BosonicBath,
--    DrudeLorentzBath,
--    DrudeLorentzPadeBath,
--    UnderDampedBath,
--    FermionicBath,
--    LorentzianBath,
--    LorentzianPadeBath,
--)
--from qutip.solver.heom.bofin_solvers import (
--    heomsolve,
--    HierarchyADOs,
--    HierarchyADOsState,
--    HEOMResult,
--    HEOMSolver,
--    HSolverDL,
--    _GatherHEOMRHS,
--)
--from qutip.solver import (
--    IntegratorException,
--)
--
--
--def fill_options(**kwargs):
--    """Fill the options with minimal entries needed by HEOMResult."""
--    return {
--        "store_final_state": False,
--        "store_states": None,
--        "store_ados": False,
--        **kwargs
--    }
--
--
--def assert_raises_steady_state_time_dependent(hsolver):
--    """ Assert that calling .steady_state() on a HEOMSolver with
--        a time-dependent Hamiltonian raises the appropriate exception.
--    """
--    with pytest.raises(ValueError) as err:
--        hsolver.steady_state()
--    assert str(err.value) == (
--       "A steady state cannot be determined for a time-dependent"
--       " system"
--    )
--
--
--class TestHierarchyADOs:
--    def mk_exponents(self, dims):
--        return [
--            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
--        ]
--
--    def test_create(self):
--        exponents = self.mk_exponents([2, 3])
--        ados = HierarchyADOs(exponents, max_depth=2)
--
--        assert ados.exponents == exponents
--        assert ados.max_depth == 2
--
--        assert ados.dims == [2, 3]
--        assert ados.vk == [2.0, 2.0]
--        assert ados.ck == [1.0, 1.0]
--        assert ados.ck2 == [None, None]
--        assert ados.sigma_bar_k_offset == [None, None]
--
--        assert ados.labels == [
--            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
--        ]
--
--    def test_state_idx(self):
--        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
--        assert ados.idx((0, 0)) == 0
--        assert ados.idx((0, 1)) == 1
--        assert ados.idx((0, 2)) == 2
--        assert ados.idx((1, 0)) == 3
--        assert ados.idx((1, 1)) == 4
--
--    def test_next(self):
--        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
--        assert ados.next((0, 0), 0) == (1, 0)
--        assert ados.next((0, 0), 1) == (0, 1)
--        assert ados.next((1, 0), 0) is None
--        assert ados.next((1, 0), 1) == (1, 1)
--        assert ados.next((1, 1), 1) is None
--
--    def test_prev(self):
--        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
--        assert ados.prev((0, 0), 0) is None
--        assert ados.prev((0, 0), 1) is None
--        assert ados.prev((1, 0), 0) == (0, 0)
--        assert ados.prev((0, 1), 1) == (0, 0)
--        assert ados.prev((1, 1), 1) == (1, 0)
--        assert ados.prev((0, 2), 1) == (0, 1)
--
--    def test_exps(self):
--        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
--        assert ados.exps((0, 0, 0)) == ()
--        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
--        assert ados.exps((2, 0, 0)) == (
--            ados.exponents[0], ados.exponents[0],
--        )
--        assert ados.exps((1, 2, 1)) == (
--            ados.exponents[0],
--            ados.exponents[1], ados.exponents[1],
--            ados.exponents[2],
--        )
--
--    def test_filter_by_nothing(self):
--        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
--        assert ados.filter() == [
--            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
--        ]
--
--    def test_filter_by_level(self):
--        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
--        assert ados.filter(level=0) == [
--            (0, 0),
--        ]
--        assert ados.filter(level=1) == [
--            (0, 1),
--            (1, 0),
--        ]
--        assert ados.filter(level=2) == [
--            (0, 2),
--            (1, 1),
--        ]
--        assert ados.filter(level=3) == []
--
--    def test_filter_by_exponents(self):
--        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
--        assert ados.filter(dims=[]) == [
--            (0, 0),
--        ]
--        assert ados.filter(dims=[2]) == [
--            (1, 0),
--        ]
--        assert ados.filter(level=1, dims=[2]) == [
--            (1, 0),
--        ]
--        assert ados.filter(dims=[3]) == [
--            (0, 1),
--        ]
--        assert ados.filter(dims=[2, 3]) == [
--            (1, 1),
--        ]
--        assert ados.filter(level=2, dims=[2, 3]) == [
--            (1, 1),
--        ]
--        assert ados.filter(dims=[3, 3]) == [
--            (0, 2),
--        ]
--        assert ados.filter(types=["I"]) == [
--            (0, 1),
--            (1, 0),
--        ]
--        assert ados.filter(types=["I", "I"]) == [
--            (0, 2),
--            (1, 1),
--        ]
--
--        with pytest.raises(ValueError) as err:
--            ados.filter(types=[], dims=[2])
--        assert str(err.value) == (
--            "The tags, dims and types filters must all be the same length."
--        )
--
--        with pytest.raises(ValueError) as err:
--            ados.filter(dims=[2, 2, 2])
--        assert str(err.value) == (
--            "The maximum depth for the hierarchy is 2 but 3 levels of"
--            " excitation filters were given."
--        )
--
--        with pytest.raises(ValueError) as err:
--            ados.filter(level=0, dims=[2])
--        assert str(err.value) == (
--            "The level parameter is 0 but 1 levels of excitation filters"
--            " were given."
--        )
--
--
--class TestHierarchyADOsState:
--    def mk_ados(self, bath_dims, max_depth):
--        exponents = [
--            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
--        ]
--        ados = HierarchyADOs(exponents, max_depth=max_depth)
--        return ados
--
--    def mk_rho_and_soln(self, ados, rho_dims):
--        n_ados = len(ados.labels)
--        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
--        rho = Qobj(ado_soln[0, :], dims=rho_dims)
--        return rho, ado_soln
--
--    def test_create(self):
--        ados = self.mk_ados([2, 3], max_depth=2)
--        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
--        ado_state = HierarchyADOsState(rho, ados, ado_soln)
--        assert ado_state.rho == rho
--        assert ado_state.labels == ados.labels
--        assert ado_state.exponents == ados.exponents
--        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
--        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
--
--    def test_extract(self):
--        ados = self.mk_ados([2, 3], max_depth=2)
--        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
--        ado_state = HierarchyADOsState(rho, ados, ado_soln)
--        ado_state.extract((0, 0)) == rho
--        ado_state.extract(0) == rho
--        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
--        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
--
--
--class DrudeLorentzPureDephasingModel:
--    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
--        solver.
--    """
--    def __init__(self, lam, gamma, T, Nk):
--        self.lam = lam
--        self.gamma = gamma
--        self.T = T
--        self.Nk = Nk
--        # we add a very weak system hamiltonian here to avoid having
--        # singular system that causes problems for the scipy.sparse.linalg
--        # superLU solver used in spsolve.
--        self.H = Qobj(1e-5 * np.ones((2, 2)))
--        self.Q = sigmaz()
--
--    def rho(self):
--        """ Initial state. """
--        return 0.5 * Qobj(np.ones((2, 2)))
--
--    def state_results(self, states):
--        projector = basis(2, 0) * basis(2, 1).dag()
--        return expect(states, projector)
--
--    def analytic_results(self, tlist):
--        lam, gamma, T = self.lam, self.gamma, self.T
--        lam_c = lam / np.pi
--
--        def _integrand(omega, t):
--            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
--            return (-4 * J * (1 - np.cos(omega*t))
--                    / (np.tanh(0.5*omega / T) * omega**2))
--
--        # Calculate the analytical results by numerical integration
--        return [
--            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
--            for t in tlist
--        ]
--
--    def bath_coefficients(self):
--        """ Correlation function expansion coefficients for the Drude-Lorentz
--            bath.
--        """
--        lam, gamma, T = self.lam, self.gamma, self.T
--        Nk = self.Nk
--        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
--        ck_real.extend([
--            (4 * lam * gamma * T * 2 * np.pi * k * T /
--                ((2 * np.pi * k * T)**2 - gamma**2))
--            for k in range(1, Nk + 1)
--        ])
--        vk_real = [gamma]
--        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
--        ck_imag = [lam * gamma * (-1.0)]
--        vk_imag = [gamma]
--        return ck_real, vk_real, ck_imag, vk_imag
--
--
--class UnderdampedPureDephasingModel:
--    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
--        solver.
--    """
--    def __init__(self, lam,  gamma, w0, T, Nk):
--        self.lam = lam
--        self.gamma = gamma
--        self.w0 = w0
--        self.T = T
--        self.Nk = Nk
--        # we add a very weak system hamiltonian here to avoid having
--        # singular system that causes problems for the scipy.sparse.linalg
--        # superLU solver used in spsolve.
--        self.H = Qobj(1e-5 * np.ones((2, 2)))
--        self.Q = sigmaz()
--
--    def rho(self):
--        """ Initial state. """
--        return 0.5 * Qobj(np.ones((2, 2)))
--
--    def state_results(self, states):
--        projector = basis(2, 0) * basis(2, 1).dag()
--        return expect(states, projector)
--
--    def analytic_results(self, tlist):
--        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
--        lam_c = lam**2 / np.pi
--
--        def _integrand(omega, t):
--            Jw = (
--                lam_c * omega * gamma /
--                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
--            )
--            return (-4 * Jw * (1 - np.cos(omega*t))
--                    / (np.tanh(0.5*omega / T) * omega**2))
--
--        return [
--            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
--            for t in tlist
--        ]
--
--
--class BosonicMode:
--    """ A description of a bosonic mode for inclusion in a
--        DiscreteLevelCurrentModel.
--    """
--    def __init__(self, N, Lambda, Omega, gamma_b):
--        self.N = N
--        self.Lambda = Lambda
--        self.Omega = Omega
--        self.gamma_b = gamma_b
--
--    def bath_coefficients(self):
--        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
--        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
--
--        ck_imag = [
--            -1.0j * self.Omega + self.gamma_b / 2,
--            1.0j * self.Omega + self.gamma_b / 2,
--        ]
--        vk_imag = [
--            -1.0j * self.Omega + self.gamma_b / 2,
--            1.0j * self.Omega + self.gamma_b / 2,
--        ]
--        return ck_real, ck_imag, vk_real, vk_imag
--
--
--class DiscreteLevelCurrentModel:
--    """ Analytic discrete level current model for testing the HEOM solver
--        with a fermionic bath (and optionally a bosonic mode).
--    """
--    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
--        # single fermion
--        self.e1 = e1  # energy
--
--        # parameters for the fermionic leads
--        self.gamma = gamma
--        self.W = W
--        self.T = T
--        self.lmax = lmax  # Pade cut-off
--        self.beta = 1. / T
--        self.theta = theta  # bias
--
--        # bosonic_mode
--        self.bosonic_mode = bosonic_mode
--
--        # Construct Hamiltonian and coupling operator
--        if self.bosonic_mode is None:
--            d1 = destroy(2)
--            self.H = self.e1 * d1.dag() @ d1
--            self.Q = d1
--            self._sys_occupation_op = d1.dag() @ d1
--        else:
--            d1 = destroy(2) & qeye(self.bosonic_mode.N)
--            a = qeye(2) & destroy(self.bosonic_mode.N)
--            self.H = (
--                self.e1 * d1.dag() @ d1 +
--                self.bosonic_mode.Omega * a.dag() @ a +
--                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
--            )
--            if self.bosonic_mode.gamma_b != 0:
--                # apply phenomenological damping:
--                self.H = liouvillian(
--                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
--                )
--            self.Q = d1
--            self._sys_occupation_op = d1.dag() @ d1
--
--    def rho(self, rho_fermion=None):
--        """ Return initial system density matrix given the density matrix for
--            the single Fermionic mode.
--        """
--        if rho_fermion is None:
--            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
--        elif rho_fermion.isket:
--            rho_fermion = rho_fermion.proj()
--        if self.bosonic_mode is None:
--            rho = rho_fermion
--        else:
--            bm0 = basis(self.bosonic_mode.N, 0)
--            rho = rho_fermion & (bm0 @ bm0.dag())
--        return rho
--
--    def sys_occupation(self, state):
--        return expect(state, self._sys_occupation_op)
--
--    def state_current(self, ado_state, tags=None):
--        level_1_aux = [
--            (ado_state.extract(label), ado_state.exps(label)[0])
--            for label in ado_state.filter(level=1, tags=tags)
--        ]
--
--        def exp_sign(exp):
--            return 1 if exp.type == exp.types["+"] else -1
--
--        def exp_op(exp):
--            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
--
--        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
--        # and thus the first 2 * k exponents
--        k = self.lmax + 1
--        return 1.0j * sum(
--            exp_sign(exp) * (exp_op(exp) * aux).tr()
--            for aux, exp in level_1_aux[:2 * k]
--        )
--
--    def analytic_current(self):
--        if self.bosonic_mode is not None:
--            raise RuntimeError(
--                "Analytic calculation of the current is not implemented in the"
--                " case where a bosonic mode is present."
--            )
--
--        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
--        mu_l = self.theta / 2.
--        mu_r = - self.theta / 2.
--
--        def f(x):
--            return 1 / (np.exp(x) + 1.)
--
--        def Gamma_w(w, mu):
--            return Gamma * W**2 / ((w-mu)**2 + W**2)
--
--        def lamshift(w, mu):
--            return (w-mu)*Gamma_w(w, mu)/(2*W)
--
--        def integrand(w):
--            return (
--                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
--                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
--                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
--                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
--            )
--
--        def real_func(x):
--            return np.real(integrand(x))
--
--        def imag_func(x):
--            return np.imag(integrand(x))
--
--        # These integral bounds should be checked to be wide enough if the
--        # parameters are changed
--        a = -2
--        b = 2
--        real_integral = quad(real_func, a, b)
--        imag_integral = quad(imag_func, a, b)
--
--        return real_integral[0] + 1.0j * imag_integral[0]
--
--    def bath_coefficients(self):
--        """ Correlation function expansion coefficients for the fermionic bath.
--        """
--        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
--        mu_l = self.theta / 2.
--        mu_r = - self.theta / 2.
--
--        def deltafun(j, k):
--            return 1. if j == k else 0.
--
--        Alpha = np.zeros((2 * lmax, 2 * lmax))
--        for j in range(2*lmax):
--            for k in range(2*lmax):
--                Alpha[j][k] = (
--                    (deltafun(j, k + 1) + deltafun(j, k - 1))
--                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
--                )
--
--        eigvalsA = eigvalsh(Alpha)
--
--        eps = []
--        for val in eigvalsA[0:lmax]:
--            eps.append(-2 / val)
--
--        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
--        for j in range(2 * lmax - 1):
--            for k in range(2 * lmax - 1):
--                AlphaP[j][k] = (
--                    (deltafun(j, k + 1) + deltafun(j, k - 1))
--                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
--                )
--
--        eigvalsAP = eigvalsh(AlphaP)
--
--        chi = []
--        for val in eigvalsAP[0:lmax - 1]:
--            chi.append(-2/val)
--
--        eta_list = [
--            0.5 * lmax * (2 * (lmax + 1) - 1) * (
--                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
--                np.prod([
--                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
--                ])
--            )
--            for j in range(lmax)
--        ]
--
--        kappa = [0] + eta_list
--        epsilon = [0] + eps
--
--        def f_approx(x):
--            f = 0.5
--            for ll in range(1, lmax + 1):
--                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
--            return f
--
--        def C(sigma, mu):
--            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
--            gamma_0 = W - sigma*1.0j*mu
--            eta_list = [eta_0]
--            gamma_list = [gamma_0]
--            if lmax > 0:
--                for ll in range(1, lmax + 1):
--                    eta_list.append(
--                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
--                        / (-(epsilon[ll]**2 / beta**2) + W**2)
--                    )
--                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
--            return eta_list, gamma_list
--
--        etapL, gampL = C(1.0, mu_l)
--        etamL, gammL = C(-1.0, mu_l)
--
--        etapR, gampR = C(1.0, mu_r)
--        etamR, gammR = C(-1.0, mu_r)
--
--        ck_plus = etapR + etapL
--        vk_plus = gampR + gampL
--        ck_minus = etamR + etamL
--        vk_minus = gammR + gammL
--
--        return ck_plus, vk_plus, ck_minus, vk_minus
--
--
--_HAMILTONIAN_EVO_KINDS = {
--    "qobj": lambda H: H,
--    "qobjevo_const": lambda H: QobjEvo([H]),
--    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
--    "listevo_const": lambda H: [H],
--}
--
--
--def hamiltonian_to_sys(H, evo, liouvillianize):
--    if liouvillianize:
--        H = liouvillian(H)
--    H = _HAMILTONIAN_EVO_KINDS[evo](H)
--    return H
--
--
--class TestHEOMSolver:
--    def test_create_bosonic(self):
--        Q = sigmaz()
--        H = sigmax()
--        exponents = [
--            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
--            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
--            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
--        ]
--        bath = Bath(exponents)
--
--        hsolver = HEOMSolver(H, bath, 2)
--        assert hsolver.ados.exponents == exponents
--        assert hsolver.ados.max_depth == 2
--
--        hsolver = HEOMSolver(H, [bath] * 3, 2)
--        assert hsolver.ados.exponents == exponents * 3
--        assert hsolver.ados.max_depth == 2
--
--    def test_create_fermionic(self):
--        Q = sigmaz()
--        H = sigmax()
--        exponents = [
--            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
--            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
--        ]
--        bath = Bath(exponents)
--
--        hsolver = HEOMSolver(H, bath, 2)
--        assert hsolver.ados.exponents == exponents
--        assert hsolver.ados.max_depth == 2
--
--        hsolver = HEOMSolver(H, [bath] * 3, 2)
--        assert hsolver.ados.exponents == exponents * 3
--        assert hsolver.ados.max_depth == 2
--
--    def test_create_mixed_bosonic_and_fermionic(self):
--        Q = sigmaz()
--        H = sigmax()
--        exponents = [
--            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
--            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
--            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
--        ]
--        bath = Bath(exponents)
--
--        hsolver = HEOMSolver(H, bath, 2)
--        assert hsolver.ados.exponents == exponents
--        assert hsolver.ados.max_depth == 2
--
--        hsolver = HEOMSolver(H, [bath] * 3, 2)
--        assert hsolver.ados.exponents == exponents * 3
--        assert hsolver.ados.max_depth == 2
--
--    def test_create_bath_errors(self):
--        Q = sigmaz()
--        H = sigmax()
--        mixed_q_dims = [
--            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
--            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
--        ]
--
--        with pytest.raises(ValueError) as err:
--            HEOMSolver(H, Bath(mixed_q_dims), 2)
--        assert str(err.value) == (
--            "All bath exponents must have system coupling operators with the"
--            " same dimensions but a mixture of dimensions was given."
--        )
--
--    def test_create_h_sys_errors(self):
--        H = object()
--        with pytest.raises(TypeError) as err:
--            HEOMSolver(H, Bath([]), 2)
--        assert str(err.value) == (
--            "The Hamiltonian (H) must be a Qobj or QobjEvo"
--        )
--
--        H = [sigmax()]
--        with pytest.raises(TypeError) as err:
--            HEOMSolver([H], Bath([]), 2)
--        assert str(err.value) == (
--            "The Hamiltonian (H) must be a Qobj or QobjEvo"
--        )
--
--    @pytest.mark.parametrize(['method'], [
--        pytest.param("run", id="run"),
--        pytest.param("start", id="start"),
--    ])
--    def test_invalid_rho0_errors(self, method):
--        Q = sigmaz()
--        H = sigmax()
--        exponents = [
--            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
--            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
--            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
--        ]
--        bath = Bath(exponents)
--        hsolver = HEOMSolver(H, bath, 2)
--
--        if method == "run":
--            def solve_method(rho0):
--                return hsolver.run(rho0, [0, 1])
--        elif method == "start":
--            def solve_method(rho0):
--                return hsolver.start(rho0, 0)
--        else:
--            assert False, f"method {method} not supported by test"
--
--        with pytest.raises(ValueError) as err:
--            solve_method(basis(3, 0))
--        assert str(err.value) == (
--            "Initial state rho has dims [[3], [1]]"
--            " but the system dims are [[2], [2]]"
--        )
--
--        with pytest.raises(TypeError) as err:
--            solve_method("batman")
--        assert str(err.value) == (
--            "Initial ADOs passed have type <class 'str'> but a "
--            "HierarchyADOsState or a numpy array-like instance was expected"
--        )
--
--        with pytest.raises(ValueError) as err:
--            solve_method(np.array([1, 2, 3]))
--        assert str(err.value) == (
--            "Initial ADOs passed have shape (3,) but the solver hierarchy"
--            " shape is (10, 2, 2)"
--        )
--
--    @pytest.mark.parametrize(['evo'], [
--        pytest.param("qobj", id="qobj"),
--        pytest.param("qobjevo_const", id="qobjevo_const"),
--        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
--    ])
--    @pytest.mark.parametrize(['liouvillianize'], [
--        pytest.param(False, id="hamiltonian"),
--        pytest.param(True, id="liouvillian"),
--    ])
--    def test_pure_dephasing_model_bosonic_bath(
--        self, evo, liouvillianize, atol=1e-3
--    ):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
--        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
--
--        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
--        options = {"nsteps": 15000, "store_states": True}
--        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
--
--        tlist = np.linspace(0, 10, 21)
--        result = hsolver.run(dlm.rho(), tlist)
--
--        test = dlm.state_results(result.states)
--        expected = dlm.analytic_results(tlist)
--        np.testing.assert_allclose(test, expected, atol=atol)
--
--        if evo != "qobjevo_timedep":
--            rho_final, ado_state = hsolver.steady_state()
--            test = dlm.state_results([rho_final])
--            expected = dlm.analytic_results([100])
--            np.testing.assert_allclose(test, expected, atol=atol)
--            assert rho_final == ado_state.extract(0)
--        else:
--            assert_raises_steady_state_time_dependent(hsolver)
--
--    @pytest.mark.parametrize(['terminator'], [
--        pytest.param(True, id="terminator"),
--        pytest.param(False, id="noterminator"),
--    ])
--    @pytest.mark.parametrize(['bath_cls'], [
--        pytest.param(DrudeLorentzBath, id="matsubara"),
--        pytest.param(DrudeLorentzPadeBath, id="pade"),
--    ])
--    def test_pure_dephasing_model_drude_lorentz_baths(
--        self, terminator, bath_cls, atol=1e-3
--    ):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        bath = bath_cls(
--            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
--        )
--        if terminator:
--            _, terminator_op = bath.terminator()
--            H_sys = liouvillian(dlm.H) + terminator_op
--        else:
--            H_sys = dlm.H
--
--        options = {"nsteps": 15000, "store_states": True}
--        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
--
--        tlist = np.linspace(0, 10, 21)
--        result = hsolver.run(dlm.rho(), tlist)
--
--        test = dlm.state_results(result.states)
--        expected = dlm.analytic_results(tlist)
--        np.testing.assert_allclose(test, expected, atol=atol)
--
--        rho_final, ado_state = hsolver.steady_state()
--        test = dlm.state_results([rho_final])
--        expected = dlm.analytic_results([100])
--        np.testing.assert_allclose(test, expected, atol=atol)
--        assert rho_final == ado_state.extract(0)
--
--    def test_underdamped_pure_dephasing_model_underdamped_bath(
--        self, atol=1e-3
--    ):
--        udm = UnderdampedPureDephasingModel(
--            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
--        )
--        bath = UnderDampedBath(
--            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
--            w0=udm.w0,
--        )
--
--        options = {"nsteps": 15000, "store_states": True}
--        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
--
--        tlist = np.linspace(0, 10, 21)
--        result = hsolver.run(udm.rho(), tlist)
--
--        test = udm.state_results(result.states)
--        expected = udm.analytic_results(tlist)
--        np.testing.assert_allclose(test, expected, atol=atol)
--
--        rho_final, ado_state = hsolver.steady_state()
--        test = udm.state_results([rho_final])
--        expected = udm.analytic_results([5000])
--        np.testing.assert_allclose(test, expected, atol=atol)
--        assert rho_final == ado_state.extract(0)
--
--    @pytest.mark.parametrize(['evo'], [
--        pytest.param("qobj"),
--        pytest.param("qobjevo_const"),
--        pytest.param("qobjevo_timedep"),
--    ])
--    @pytest.mark.parametrize(['liouvillianize'], [
--        pytest.param(False, id="hamiltonian"),
--        pytest.param(True, id="liouvillian"),
--    ])
--    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
--        dlm = DiscreteLevelCurrentModel(
--            gamma=0.01, W=1, T=0.025851991, lmax=10,
--        )
--        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
--        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
--
--        options = {
--            "store_states": True,
--            "store_ados": True,
--            "nsteps": 15_000,
--            "rtol": 1e-7,
--            "atol": 1e-7,
--        }
--        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
--        # for a single impurity we converge with max_depth = 2
--        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
--
--        tlist = [0, 600]
--        result = hsolver.run(dlm.rho(), tlist)
--        current = dlm.state_current(result.ado_states[-1])
--        analytic_current = dlm.analytic_current()
--        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
--
--        if evo != "qobjevo_timedep":
--            rho_final, ado_state = hsolver.steady_state()
--            current = dlm.state_current(ado_state)
--            analytic_current = dlm.analytic_current()
--            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
--        else:
--            assert_raises_steady_state_time_dependent(hsolver)
--
--    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
--        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
--        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
--    ])
--    def test_discrete_level_model_lorentzian_baths(
--        self, bath_cls, analytic_current, atol=1e-3
--    ):
--        dlm = DiscreteLevelCurrentModel(
--            gamma=0.01, W=1, T=0.025851991, lmax=10,
--        )
--
--        options = {
--            "nsteps": 15_000, "store_states": True, "store_ados": True,
--            "rtol": 1e-7, "atol": 1e-7,
--        }
--        bath_l = bath_cls(
--            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
--            Nk=dlm.lmax,
--        )
--        bath_r = bath_cls(
--            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
--            Nk=dlm.lmax,
--        )
--        # for a single impurity we converge with max_depth = 2
--        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
--
--        tlist = [0, 600]
--        result = hsolver.run(dlm.rho(), tlist)
--        current = dlm.state_current(result.ado_states[-1])
--        # analytic_current = dlm.analytic_current()
--        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
--
--        rho_final, ado_state = hsolver.steady_state()
--        current = dlm.state_current(ado_state)
--        # analytic_current = dlm.analytic_current()
--        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
--
--    @pytest.mark.parametrize(['evo'], [
--        pytest.param("qobj"),
--        pytest.param("qobjevo_const"),
--        pytest.param("qobjevo_timedep"),
--    ])
--    @pytest.mark.parametrize(['liouvillianize'], [
--        pytest.param(False, id="hamiltonian"),
--        pytest.param(True, id="liouvillian"),
--    ])
--    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
--        self, evo, liouvillianize
--    ):
--        dlm = DiscreteLevelCurrentModel(
--            gamma=0.01, W=1, T=0.025851991, lmax=10,
--        )
--        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
--        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
--
--        options = {
--            "store_states": True,
--            "store_ados": True,
--            "nsteps": 15_000,
--            "rtol": 1e-7,
--            "atol": 1e-7,
--        }
--        fermionic_bath = FermionicBath(
--            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
--        )
--        # very weak bosonic coupling which should not affect the dynamics of
--        # the interaction between the system and the fermionic bath:
--        eps = [1e-10] * 5
--        bosonic_Q = sigmax()
--        bosonic_bath = BosonicBath(
--            bosonic_Q, eps, eps, eps, eps, combine=False,
--        )
--        # for a single impurity we converge with max_depth = 2
--        # we specify the bosonic bath first to ensure that the test checks
--        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
--        # mode is before the fermionic ones
--        hsolver = HEOMSolver(
--            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
--        )
--
--        tlist = [0, 600]
--        result = hsolver.run(dlm.rho(), tlist)
--        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
--        analytic_current = dlm.analytic_current()
--        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
--
--        if evo != "qobjevo_timedep":
--            rho_final, ado_state = hsolver.steady_state()
--            current = dlm.state_current(ado_state)
--            analytic_current = dlm.analytic_current()
--            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
--        else:
--            assert_raises_steady_state_time_dependent(hsolver)
--
--    @pytest.mark.parametrize(['evo'], [
--        pytest.param("qobj"),
--        pytest.param("qobjevo_const"),
--        pytest.param("qobjevo_timedep"),
--    ])
--    @pytest.mark.parametrize(['liouvillianize'], [
--        pytest.param(False, id="hamiltonian"),
--        pytest.param(True, id="liouvillian"),
--    ])
--    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
--        self, evo, liouvillianize
--    ):
--        dlm = DiscreteLevelCurrentModel(
--            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
--        )
--        bosonic_mode = BosonicMode(
--            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
--        )
--
--        dlm_ref = DiscreteLevelCurrentModel(
--            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
--            bosonic_mode=bosonic_mode,
--        )
--
--        options = {
--            "store_states": True,
--            "store_ados": True,
--            "nsteps": 15_000,
--            "rtol": 1e-7,
--            "atol": 1e-7,
--        }
--
--        # First we construct a solver with the boson modelled as part of the
--        # system and only a single Fermionic bath. This will provide the
--        # reference result for the test:
--        fermionic_bath_ref = FermionicBath(
--            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
--        )
--
--        hsolver_ref = HEOMSolver(
--            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
--        )
--
--        # Then we construct a solver for the same system, but with the
--        # bosonic mode as a bath This is the result we would like to check:
--        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
--
--        fermionic_bath = FermionicBath(
--            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
--        )
--
--        bosonic_bath = BosonicBath(
--            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
--            combine=True, tag="bosonic",
--        )
--
--        hsolver = HEOMSolver(
--            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
--        )
--
--        # Calculate currents and occupations:
--        tlist = np.linspace(0, 1000, 300)
--        psi0 = basis(2, 0)
--
--        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
--        current_ref = [
--            dlm_ref.state_current(ado_state, tags=["fermionic"])
--            for ado_state in result_ref.ado_states
--        ]
--        sys_occupation_ref = dlm_ref.sys_occupation(
--            result_ref.states
--        )
--
--        result = hsolver.run(dlm.rho(psi0), tlist)
--        current = [
--            dlm.state_current(ado_state, tags=["fermionic"])
--            for ado_state in result.ado_states
--        ]
--        sys_occupation = dlm.sys_occupation(result.states)
--
--        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
--        np.testing.assert_allclose(
--            sys_occupation_ref, sys_occupation, rtol=1e-3,
--        )
--
--        if evo != "qobjevo_timedep":
--            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
--            current_ss_ref = dlm_ref.state_current(ado_state_ref)
--            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
--
--            rho_final, ado_state = hsolver.steady_state()
--            current_ss = dlm.state_current(ado_state)
--            sys_occupation_ss = dlm.sys_occupation(rho_final)
--
--            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
--            np.testing.assert_allclose(
--                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
--            )
--        else:
--            assert_raises_steady_state_time_dependent(hsolver)
--
--    @pytest.mark.parametrize(['ado_format'], [
--        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
--        pytest.param("numpy", id="numpy"),
--    ])
--    def test_ado_input_and_return(self, ado_format):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
--
--        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
--        options = {
--            "nsteps": 15_000, "store_states": True, "store_ados": True,
--        }
--        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
--
--        tlist_1 = [0, 1, 2]
--        result_1 = hsolver.run(dlm.rho(), tlist_1)
--
--        tlist_2 = [2, 3, 4]
--        rho0 = result_1.ado_states[-1]
--        if ado_format == "numpy":
--            rho0 = rho0._ado_state  # extract the raw numpy array
--        result_2 = hsolver.run(rho0, tlist_2)
--
--        tlist_full = tlist_1 + tlist_2[1:]
--        result_full = hsolver.run(dlm.rho(), tlist_full)
--
--        times_12 = result_1.times + result_2.times[1:]
--        times_full = result_full.times
--        assert times_12 == tlist_full
--        assert times_full == tlist_full
--
--        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
--        ado_states_full = result_full.ado_states
--        assert len(ado_states_12) == len(tlist_full)
--        assert len(ado_states_full) == len(tlist_full)
--        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
--            for label in hsolver.ados.labels:
--                np.testing.assert_allclose(
--                    ado_12.extract(label).full(),
--                    ado_full.extract(label).full(),
--                    atol=1e-6,
--                )
--
--        states_12 = result_1.states + result_2.states[1:]
--        states_full = result_full.states
--        assert len(states_12) == len(tlist_full)
--        assert len(states_full) == len(tlist_full)
--        for ado_12, state_12 in zip(ado_states_12, states_12):
--            assert ado_12.rho == state_12
--        for ado_full, state_full in zip(ado_states_full, states_full):
--            assert ado_full.rho == state_full
--
--        expected = dlm.analytic_results(tlist_full)
--        test_12 = dlm.state_results(states_12)
--        np.testing.assert_allclose(test_12, expected, atol=1e-3)
--        test_full = dlm.state_results(states_full)
--        np.testing.assert_allclose(test_full, expected, atol=1e-3)
--
--    def test_solving_with_step(self):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
--
--        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
--        options = {"nsteps": 15_000, "store_ados": True}
--        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
--
--        tlist = np.linspace(0, 10, 21)
--        ado_state = None
--        states = [dlm.rho()]
--        hsolver.start(states[0], 0)
--        for t in tlist[1:]:
--            ado_state = hsolver.step(t)
--            states.append(ado_state.rho)
--
--        test = dlm.state_results(states)
--        expected = dlm.analytic_results(tlist)
--        np.testing.assert_allclose(test, expected, atol=1e-3)
--
--        assert states[-1] == ado_state.extract(0)
--
--
--class TestHeomsolveFunction:
--    @pytest.mark.parametrize(['evo'], [
--        pytest.param("qobj", id="qobj"),
--        pytest.param("listevo_const", id="listevo_const"),
--        pytest.param("qobjevo_const", id="qobjevo_const"),
--        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
--    ])
--    @pytest.mark.parametrize(['liouvillianize'], [
--        pytest.param(False, id="hamiltonian"),
--        pytest.param(True, id="liouvillian"),
--    ])
--    def test_heomsolve_with_pure_dephasing_model(
--        self, evo, liouvillianize, atol=1e-3
--    ):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
--        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
--
--        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
--        options = {"nsteps": 15000, "store_states": True}
--
--        e_ops = {
--            "11": basis(2, 0) * basis(2, 0).dag(),
--            "22": basis(2, 1) * basis(2, 1).dag(),
--        }
--
--        tlist = np.linspace(0, 10, 21)
--        result = heomsolve(
--            H_sys, bath, 14, dlm.rho(), tlist,
--            e_ops=e_ops, args={"foo": 1}, options=options)
--
--        test = dlm.state_results(result.states)
--        expected = dlm.analytic_results(tlist)
--        np.testing.assert_allclose(test, expected, atol=atol)
--
--        for label in ["11", "22"]:
--            np.testing.assert_allclose(
--                result.e_data[label],
--                [expect(rho, e_ops[label]) for rho in result.states],
--                atol=atol,
--            )
--
--
--class TestHSolverDL:
--    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
--        pytest.param(True, 1e-4, id="bnd_cut_approx"),
--        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
--    ])
--    @pytest.mark.parametrize(['evo', 'combine'], [
--        pytest.param("qobj", True, id="qobj-combined"),
--        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
--        pytest.param("listevo_const", True, id="listevo-const-combined"),
--        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
--        pytest.param(
--            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
--        ),
--    ])
--    @pytest.mark.parametrize(['liouvillianize'], [
--        pytest.param(False, id="hamiltonian"),
--        pytest.param(True, id="liouvillian"),
--    ])
--    def test_pure_dephasing_model(
--        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
--    ):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
--        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
--
--        options = {"nsteps": 15_000, "store_states": True}
--        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
--                            14, 2, dlm.gamma,
--                            bnd_cut_approx=bnd_cut_approx,
--                            options=options, combine=combine)
--
--        tlist = np.linspace(0, 10, 21)
--        result = hsolver.run(dlm.rho(), tlist)
--
--        test = dlm.state_results(result.states)
--        expected = dlm.analytic_results(tlist)
--        np.testing.assert_allclose(test, expected, atol=atol)
--
--        if evo != "qobjevo_timedep":
--            rho_final, ado_state = hsolver.steady_state()
--            test = dlm.state_results([rho_final])
--            expected = dlm.analytic_results([100])
--            np.testing.assert_allclose(test, expected, atol=atol)
--            assert rho_final == ado_state.extract(0)
--        else:
--            assert_raises_steady_state_time_dependent(hsolver)
--
--    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
--        pytest.param(True, 1e-4, id="bnd_cut_approx"),
--        pytest.param(False, 1e-3, id="renorm"),
--    ])
--    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
--        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
--        # is repeated here to ensure the new HSolverDL remains compatibile
--        # with the old one until it is removed.
--        cut_frequency = 0.05
--        coupling_strength = 0.025
--        lam_c = coupling_strength / np.pi
--        temperature = 1 / 0.95
--        times = np.linspace(0, 10, 21)
--
--        def _integrand(omega, t):
--            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
--            return (-4 * J * (1 - np.cos(omega*t))
--                    / (np.tanh(0.5*omega / temperature) * omega**2))
--
--        # Calculate the analytical results by numerical integration
--        expected = [
--            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
--            for t in times
--        ]
--
--        H_sys = Qobj(np.zeros((2, 2)))
--        Q = sigmaz()
--        initial_state = 0.5*Qobj(np.ones((2, 2)))
--        projector = basis(2, 0) * basis(2, 1).dag()
--        options = {"nsteps": 15_000, "store_states": True}
--        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
--                            20, 2, cut_frequency,
--                            bnd_cut_approx=bnd_cut_approx,
--                            options=options)
--        test = expect(hsolver.run(initial_state, times).states, projector)
--        np.testing.assert_allclose(test, expected, atol=tol)
--
--    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
--    def test_integration_error(self):
--        dlm = DrudeLorentzPureDephasingModel(
--            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
--        )
--        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
--
--        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
--        options = {"nsteps": 10}
--        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
--
--        with pytest.raises(IntegratorException) as err:
--            hsolver.run(dlm.rho(), tlist=[0, 10])
--
--        assert str(err.value) == (
--            "Excess work done on this call. Try to increasing the nsteps"
--            " parameter in the Options class"
--        )
--
--
--class TestHEOMResult:
--    def mk_ados(self, bath_dims, max_depth):
--        exponents = [
--            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
--        ]
--        ados = HierarchyADOs(exponents, max_depth=max_depth)
--        return ados
--
--    def mk_rho_and_soln(self, ados, rho_dims):
--        n_ados = len(ados.labels)
--        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
--        rho = Qobj(ado_soln[0, :], dims=rho_dims)
--        return rho, ado_soln
--
--    def test_create_ado_states_attribute(self):
--        options = fill_options()
--        result = HEOMResult(e_ops=[], options=options)
--        assert not hasattr(result, "final_ado_state")
--        assert not hasattr(result, "ado_states")
--        assert result.store_ados is False
--
--        options = fill_options(store_ados=True)
--        result = HEOMResult(e_ops=[], options=options)
--        assert result.final_ado_state is None
--        assert result.ado_states == []
--        assert result.store_ados is True
--
--    @pytest.mark.parametrize(['e_op_type'], [
--        pytest.param("qobj", id="qobj"),
--        pytest.param("qobjevo", id="qobjevo"),
--        pytest.param("callable", id="callable"),
--    ])
--    def test_e_ops(self, e_op_type):
--        op = Qobj([[1, 0], [0, 0]])
--        if e_op_type == "qobj":
--            e_op = op
--        elif e_op_type == "qobjevo":
--            e_op = QobjEvo(op)
--        elif e_op_type == "callable":
--            def e_op(f, ado_state):
--                return expect(op, ado_state.rho)
--        else:
--            assert False, f"unknown e_op_type {e_op_type!r}"
--
--        options = fill_options()
--        result = HEOMResult(e_ops=e_op, options=options)
--
--        ados = self.mk_ados([2, 3], max_depth=2)
--        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
--        e_op_value = expect(op, rho)
--        ado_state = HierarchyADOsState(rho, ados, ado_soln)
--
--        result.add(0.1, ado_state)
--
--        assert result.expect[0] == [e_op_value]
--        assert result.e_data[0] == [e_op_value]
--
--    def test_store_state(self):
--        options = fill_options()
--        result = HEOMResult(e_ops=[], options=options)
--
--        ados = self.mk_ados([2, 3], max_depth=2)
--        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
--        ado_state = HierarchyADOsState(rho, ados, ado_soln)
--
--        result.add(0.1, ado_state)
--
--        assert result.times == [0.1]
--        assert result.states == [rho]
--        assert result.final_state is rho
--
--    def test_store_ados(self):
--        options = fill_options(store_ados=True)
--        result = HEOMResult(e_ops=[], options=options)
--
--        ados = self.mk_ados([2, 3], max_depth=2)
--        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
--        ado_state = HierarchyADOsState(rho, ados, ado_soln)
--
--        result.add(0.1, ado_state)
--        assert result.times == [0.1]
--        assert result.states == [rho]
--        assert result.final_state is rho
--        assert result.ado_states == [ado_state]
--        assert result.final_ado_state is ado_state
--
--
--class Test_GatherHEOMRHS:
--    def test_simple_gather(self):
--        def f(label):
--            return int(label.lstrip("o"))
--
--        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
--
--        for i in range(3):
--            for j in range(3):
--                base = 10 * (j * 2) + (i * 2)
--                block_op = _data.to(
--                    _data.CSR,
--                    _data.create(np.array([
--                        [base, base + 10],
--                        [base + 1, base + 11],
--                    ]))
--                )
--                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
--
--        op = gather_heoms.gather()
--
--        expected_op = np.array([
--            [10 * i + j for i in range(2 * 3)]
--            for j in range(2 * 3)
--        ], dtype=np.complex128)
--
--        np.testing.assert_array_equal(op.to_array(), expected_op)
--        assert isinstance(op, _data.CSR)
-+"""
-+Tests for qutip.nonmarkov.bofin_solvers.
-+"""
-+
-+import numpy as np
-+import pytest
-+from numpy.linalg import eigvalsh
-+from scipy.integrate import quad
-+
-+from qutip import (
-+    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
-+    tensor, Qobj, QobjEvo
-+)
-+from qutip.core import data as _data
-+from qutip.solver.heom.bofin_baths import (
-+    BathExponent,
-+    Bath,
-+    BosonicBath,
-+    DrudeLorentzBath,
-+    DrudeLorentzPadeBath,
-+    UnderDampedBath,
-+    FermionicBath,
-+    LorentzianBath,
-+    LorentzianPadeBath,
-+)
-+from qutip.solver.heom.bofin_solvers import (
-+    heomsolve,
-+    HierarchyADOs,
-+    HierarchyADOsState,
-+    HEOMResult,
-+    HEOMSolver,
-+    HSolverDL,
-+    _GatherHEOMRHS,
-+)
-+from qutip.solver import (
-+    IntegratorException,
-+)
-+
-+
-+def fill_options(**kwargs):
-+    """Fill the options with minimal entries needed by HEOMResult."""
-+    return {
-+        "store_final_state": False,
-+        "store_states": None,
-+        "store_ados": False,
-+        **kwargs
-+    }
-+
-+
-+def assert_raises_steady_state_time_dependent(hsolver):
-+    """ Assert that calling .steady_state() on a HEOMSolver with
-+        a time-dependent Hamiltonian raises the appropriate exception.
-+    """
-+    with pytest.raises(ValueError) as err:
-+        hsolver.steady_state()
-+    assert str(err.value) == (
-+       "A steady state cannot be determined for a time-dependent"
-+       " system"
-+    )
-+
-+
-+class TestHierarchyADOs:
-+    def mk_exponents(self, dims):
-+        return [
-+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
-+        ]
-+
-+    def test_create(self):
-+        exponents = self.mk_exponents([2, 3])
-+        ados = HierarchyADOs(exponents, max_depth=2)
-+
-+        assert ados.exponents == exponents
-+        assert ados.max_depth == 2
-+
-+        assert ados.dims == [2, 3]
-+        assert ados.vk == [2.0, 2.0]
-+        assert ados.ck == [1.0, 1.0]
-+        assert ados.ck2 == [None, None]
-+        assert ados.sigma_bar_k_offset == [None, None]
-+
-+        assert ados.labels == [
-+            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
-+        ]
-+
-+    def test_state_idx(self):
-+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-+        assert ados.idx((0, 0)) == 0
-+        assert ados.idx((0, 1)) == 1
-+        assert ados.idx((0, 2)) == 2
-+        assert ados.idx((1, 0)) == 3
-+        assert ados.idx((1, 1)) == 4
-+
-+    def test_next(self):
-+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-+        assert ados.next((0, 0), 0) == (1, 0)
-+        assert ados.next((0, 0), 1) == (0, 1)
-+        assert ados.next((1, 0), 0) is None
-+        assert ados.next((1, 0), 1) == (1, 1)
-+        assert ados.next((1, 1), 1) is None
-+
-+    def test_prev(self):
-+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-+        assert ados.prev((0, 0), 0) is None
-+        assert ados.prev((0, 0), 1) is None
-+        assert ados.prev((1, 0), 0) == (0, 0)
-+        assert ados.prev((0, 1), 1) == (0, 0)
-+        assert ados.prev((1, 1), 1) == (1, 0)
-+        assert ados.prev((0, 2), 1) == (0, 1)
-+
-+    def test_exps(self):
-+        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
-+        assert ados.exps((0, 0, 0)) == ()
-+        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
-+        assert ados.exps((2, 0, 0)) == (
-+            ados.exponents[0], ados.exponents[0],
-+        )
-+        assert ados.exps((1, 2, 1)) == (
-+            ados.exponents[0],
-+            ados.exponents[1], ados.exponents[1],
-+            ados.exponents[2],
-+        )
-+
-+    def test_filter_by_nothing(self):
-+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-+        assert ados.filter() == [
-+            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
-+        ]
-+
-+    def test_filter_by_level(self):
-+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-+        assert ados.filter(level=0) == [
-+            (0, 0),
-+        ]
-+        assert ados.filter(level=1) == [
-+            (0, 1),
-+            (1, 0),
-+        ]
-+        assert ados.filter(level=2) == [
-+            (0, 2),
-+            (1, 1),
-+        ]
-+        assert ados.filter(level=3) == []
-+
-+    def test_filter_by_exponents(self):
-+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-+        assert ados.filter(dims=[]) == [
-+            (0, 0),
-+        ]
-+        assert ados.filter(dims=[2]) == [
-+            (1, 0),
-+        ]
-+        assert ados.filter(level=1, dims=[2]) == [
-+            (1, 0),
-+        ]
-+        assert ados.filter(dims=[3]) == [
-+            (0, 1),
-+        ]
-+        assert ados.filter(dims=[2, 3]) == [
-+            (1, 1),
-+        ]
-+        assert ados.filter(level=2, dims=[2, 3]) == [
-+            (1, 1),
-+        ]
-+        assert ados.filter(dims=[3, 3]) == [
-+            (0, 2),
-+        ]
-+        assert ados.filter(types=["I"]) == [
-+            (0, 1),
-+            (1, 0),
-+        ]
-+        assert ados.filter(types=["I", "I"]) == [
-+            (0, 2),
-+            (1, 1),
-+        ]
-+
-+        with pytest.raises(ValueError) as err:
-+            ados.filter(types=[], dims=[2])
-+        assert str(err.value) == (
-+            "The tags, dims and types filters must all be the same length."
-+        )
-+
-+        with pytest.raises(ValueError) as err:
-+            ados.filter(dims=[2, 2, 2])
-+        assert str(err.value) == (
-+            "The maximum depth for the hierarchy is 2 but 3 levels of"
-+            " excitation filters were given."
-+        )
-+
-+        with pytest.raises(ValueError) as err:
-+            ados.filter(level=0, dims=[2])
-+        assert str(err.value) == (
-+            "The level parameter is 0 but 1 levels of excitation filters"
-+            " were given."
-+        )
-+
-+
-+class TestHierarchyADOsState:
-+    def mk_ados(self, bath_dims, max_depth):
-+        exponents = [
-+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
-+        ]
-+        ados = HierarchyADOs(exponents, max_depth=max_depth)
-+        return ados
-+
-+    def mk_rho_and_soln(self, ados, rho_dims):
-+        n_ados = len(ados.labels)
-+        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
-+        rho = Qobj(ado_soln[0, :], dims=rho_dims)
-+        return rho, ado_soln
-+
-+    def test_create(self):
-+        ados = self.mk_ados([2, 3], max_depth=2)
-+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-+        assert ado_state.rho == rho
-+        assert ado_state.labels == ados.labels
-+        assert ado_state.exponents == ados.exponents
-+        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
-+        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
-+
-+    def test_extract(self):
-+        ados = self.mk_ados([2, 3], max_depth=2)
-+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-+        ado_state.extract((0, 0)) == rho
-+        ado_state.extract(0) == rho
-+        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
-+        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
-+
-+
-+class DrudeLorentzPureDephasingModel:
-+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
-+        solver.
-+    """
-+    def __init__(self, lam, gamma, T, Nk):
-+        self.lam = lam
-+        self.gamma = gamma
-+        self.T = T
-+        self.Nk = Nk
-+        # we add a very weak system hamiltonian here to avoid having
-+        # singular system that causes problems for the scipy.sparse.linalg
-+        # superLU solver used in spsolve.
-+        self.H = Qobj(1e-5 * np.ones((2, 2)))
-+        self.Q = sigmaz()
-+
-+    def rho(self):
-+        """ Initial state. """
-+        return 0.5 * Qobj(np.ones((2, 2)))
-+
-+    def state_results(self, states):
-+        projector = basis(2, 0) * basis(2, 1).dag()
-+        return expect(states, projector)
-+
-+    def analytic_results(self, tlist):
-+        lam, gamma, T = self.lam, self.gamma, self.T
-+        lam_c = lam / np.pi
-+
-+        def _integrand(omega, t):
-+            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
-+            return (-4 * J * (1 - np.cos(omega*t))
-+                    / (np.tanh(0.5*omega / T) * omega**2))
-+
-+        # Calculate the analytical results by numerical integration
-+        return [
-+            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-+            for t in tlist
-+        ]
-+
-+    def bath_coefficients(self):
-+        """ Correlation function expansion coefficients for the Drude-Lorentz
-+            bath.
-+        """
-+        lam, gamma, T = self.lam, self.gamma, self.T
-+        Nk = self.Nk
-+        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
-+        ck_real.extend([
-+            (4 * lam * gamma * T * 2 * np.pi * k * T /
-+                ((2 * np.pi * k * T)**2 - gamma**2))
-+            for k in range(1, Nk + 1)
-+        ])
-+        vk_real = [gamma]
-+        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
-+        ck_imag = [lam * gamma * (-1.0)]
-+        vk_imag = [gamma]
-+        return ck_real, vk_real, ck_imag, vk_imag
-+
-+
-+class UnderdampedPureDephasingModel:
-+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
-+        solver.
-+    """
-+    def __init__(self, lam,  gamma, w0, T, Nk):
-+        self.lam = lam
-+        self.gamma = gamma
-+        self.w0 = w0
-+        self.T = T
-+        self.Nk = Nk
-+        # we add a very weak system hamiltonian here to avoid having
-+        # singular system that causes problems for the scipy.sparse.linalg
-+        # superLU solver used in spsolve.
-+        self.H = Qobj(1e-5 * np.ones((2, 2)))
-+        self.Q = sigmaz()
-+
-+    def rho(self):
-+        """ Initial state. """
-+        return 0.5 * Qobj(np.ones((2, 2)))
-+
-+    def state_results(self, states):
-+        projector = basis(2, 0) * basis(2, 1).dag()
-+        return expect(states, projector)
-+
-+    def analytic_results(self, tlist):
-+        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
-+        lam_c = lam**2 / np.pi
-+
-+        def _integrand(omega, t):
-+            Jw = (
-+                lam_c * omega * gamma /
-+                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
-+            )
-+            return (-4 * Jw * (1 - np.cos(omega*t))
-+                    / (np.tanh(0.5*omega / T) * omega**2))
-+
-+        return [
-+            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-+            for t in tlist
-+        ]
-+
-+
-+class BosonicMode:
-+    """ A description of a bosonic mode for inclusion in a
-+        DiscreteLevelCurrentModel.
-+    """
-+    def __init__(self, N, Lambda, Omega, gamma_b):
-+        self.N = N
-+        self.Lambda = Lambda
-+        self.Omega = Omega
-+        self.gamma_b = gamma_b
-+
-+    def bath_coefficients(self):
-+        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
-+        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
-+
-+        ck_imag = [
-+            -1.0j * self.Omega + self.gamma_b / 2,
-+            1.0j * self.Omega + self.gamma_b / 2,
-+        ]
-+        vk_imag = [
-+            -1.0j * self.Omega + self.gamma_b / 2,
-+            1.0j * self.Omega + self.gamma_b / 2,
-+        ]
-+        return ck_real, ck_imag, vk_real, vk_imag
-+
-+
-+class DiscreteLevelCurrentModel:
-+    """ Analytic discrete level current model for testing the HEOM solver
-+        with a fermionic bath (and optionally a bosonic mode).
-+    """
-+    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
-+        # single fermion
-+        self.e1 = e1  # energy
-+
-+        # parameters for the fermionic leads
-+        self.gamma = gamma
-+        self.W = W
-+        self.T = T
-+        self.lmax = lmax  # Pade cut-off
-+        self.beta = 1. / T
-+        self.theta = theta  # bias
-+
-+        # bosonic_mode
-+        self.bosonic_mode = bosonic_mode
-+
-+        # Construct Hamiltonian and coupling operator
-+        if self.bosonic_mode is None:
-+            d1 = destroy(2)
-+            self.H = self.e1 * d1.dag() @ d1
-+            self.Q = d1
-+            self._sys_occupation_op = d1.dag() @ d1
-+        else:
-+            d1 = destroy(2) & qeye(self.bosonic_mode.N)
-+            a = qeye(2) & destroy(self.bosonic_mode.N)
-+            self.H = (
-+                self.e1 * d1.dag() @ d1 +
-+                self.bosonic_mode.Omega * a.dag() @ a +
-+                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
-+            )
-+            if self.bosonic_mode.gamma_b != 0:
-+                # apply phenomenological damping:
-+                self.H = liouvillian(
-+                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
-+                )
-+            self.Q = d1
-+            self._sys_occupation_op = d1.dag() @ d1
-+
-+    def rho(self, rho_fermion=None):
-+        """ Return initial system density matrix given the density matrix for
-+            the single Fermionic mode.
-+        """
-+        if rho_fermion is None:
-+            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
-+        elif rho_fermion.isket:
-+            rho_fermion = rho_fermion.proj()
-+        if self.bosonic_mode is None:
-+            rho = rho_fermion
-+        else:
-+            bm0 = basis(self.bosonic_mode.N, 0)
-+            rho = rho_fermion & (bm0 @ bm0.dag())
-+        return rho
-+
-+    def sys_occupation(self, state):
-+        return expect(state, self._sys_occupation_op)
-+
-+    def state_current(self, ado_state, tags=None):
-+        level_1_aux = [
-+            (ado_state.extract(label), ado_state.exps(label)[0])
-+            for label in ado_state.filter(level=1, tags=tags)
-+        ]
-+
-+        def exp_sign(exp):
-+            return 1 if exp.type == exp.types["+"] else -1
-+
-+        def exp_op(exp):
-+            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
-+
-+        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
-+        # and thus the first 2 * k exponents
-+        k = self.lmax + 1
-+        return 1.0j * sum(
-+            exp_sign(exp) * (exp_op(exp) * aux).tr()
-+            for aux, exp in level_1_aux[:2 * k]
-+        )
-+
-+    def analytic_current(self):
-+        if self.bosonic_mode is not None:
-+            raise RuntimeError(
-+                "Analytic calculation of the current is not implemented in the"
-+                " case where a bosonic mode is present."
-+            )
-+
-+        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
-+        mu_l = self.theta / 2.
-+        mu_r = - self.theta / 2.
-+
-+        def f(x):
-+            return 1 / (np.exp(x) + 1.)
-+
-+        def Gamma_w(w, mu):
-+            return Gamma * W**2 / ((w-mu)**2 + W**2)
-+
-+        def lamshift(w, mu):
-+            return (w-mu)*Gamma_w(w, mu)/(2*W)
-+
-+        def integrand(w):
-+            return (
-+                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
-+                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
-+                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
-+                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
-+            )
-+
-+        def real_func(x):
-+            return np.real(integrand(x))
-+
-+        def imag_func(x):
-+            return np.imag(integrand(x))
-+
-+        # These integral bounds should be checked to be wide enough if the
-+        # parameters are changed
-+        a = -2
-+        b = 2
-+        real_integral = quad(real_func, a, b)
-+        imag_integral = quad(imag_func, a, b)
-+
-+        return real_integral[0] + 1.0j * imag_integral[0]
-+
-+    def bath_coefficients(self):
-+        """ Correlation function expansion coefficients for the fermionic bath.
-+        """
-+        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
-+        mu_l = self.theta / 2.
-+        mu_r = - self.theta / 2.
-+
-+        def deltafun(j, k):
-+            return 1. if j == k else 0.
-+
-+        Alpha = np.zeros((2 * lmax, 2 * lmax))
-+        for j in range(2*lmax):
-+            for k in range(2*lmax):
-+                Alpha[j][k] = (
-+                    (deltafun(j, k + 1) + deltafun(j, k - 1))
-+                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
-+                )
-+
-+        eigvalsA = eigvalsh(Alpha)
-+
-+        eps = []
-+        for val in eigvalsA[0:lmax]:
-+            eps.append(-2 / val)
-+
-+        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
-+        for j in range(2 * lmax - 1):
-+            for k in range(2 * lmax - 1):
-+                AlphaP[j][k] = (
-+                    (deltafun(j, k + 1) + deltafun(j, k - 1))
-+                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
-+                )
-+
-+        eigvalsAP = eigvalsh(AlphaP)
-+
-+        chi = []
-+        for val in eigvalsAP[0:lmax - 1]:
-+            chi.append(-2/val)
-+
-+        eta_list = [
-+            0.5 * lmax * (2 * (lmax + 1) - 1) * (
-+                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
-+                np.prod([
-+                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
-+                ])
-+            )
-+            for j in range(lmax)
-+        ]
-+
-+        kappa = [0] + eta_list
-+        epsilon = [0] + eps
-+
-+        def f_approx(x):
-+            f = 0.5
-+            for ll in range(1, lmax + 1):
-+                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
-+            return f
-+
-+        def C(sigma, mu):
-+            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
-+            gamma_0 = W - sigma*1.0j*mu
-+            eta_list = [eta_0]
-+            gamma_list = [gamma_0]
-+            if lmax > 0:
-+                for ll in range(1, lmax + 1):
-+                    eta_list.append(
-+                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
-+                        / (-(epsilon[ll]**2 / beta**2) + W**2)
-+                    )
-+                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
-+            return eta_list, gamma_list
-+
-+        etapL, gampL = C(1.0, mu_l)
-+        etamL, gammL = C(-1.0, mu_l)
-+
-+        etapR, gampR = C(1.0, mu_r)
-+        etamR, gammR = C(-1.0, mu_r)
-+
-+        ck_plus = etapR + etapL
-+        vk_plus = gampR + gampL
-+        ck_minus = etamR + etamL
-+        vk_minus = gammR + gammL
-+
-+        return ck_plus, vk_plus, ck_minus, vk_minus
-+
-+
-+_HAMILTONIAN_EVO_KINDS = {
-+    "qobj": lambda H: H,
-+    "qobjevo_const": lambda H: QobjEvo([H]),
-+    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
-+    "listevo_const": lambda H: [H],
-+}
-+
-+
-+def hamiltonian_to_sys(H, evo, liouvillianize):
-+    if liouvillianize:
-+        H = liouvillian(H)
-+    H = _HAMILTONIAN_EVO_KINDS[evo](H)
-+    return H
-+
-+
-+class TestHEOMSolver:
-+    def test_create_bosonic(self):
-+        Q = sigmaz()
-+        H = sigmax()
-+        exponents = [
-+            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
-+            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
-+            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
-+        ]
-+        bath = Bath(exponents)
-+
-+        hsolver = HEOMSolver(H, bath, 2)
-+        assert hsolver.ados.exponents == exponents
-+        assert hsolver.ados.max_depth == 2
-+
-+        hsolver = HEOMSolver(H, [bath] * 3, 2)
-+        assert hsolver.ados.exponents == exponents * 3
-+        assert hsolver.ados.max_depth == 2
-+
-+    def test_create_fermionic(self):
-+        Q = sigmaz()
-+        H = sigmax()
-+        exponents = [
-+            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
-+            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
-+        ]
-+        bath = Bath(exponents)
-+
-+        hsolver = HEOMSolver(H, bath, 2)
-+        assert hsolver.ados.exponents == exponents
-+        assert hsolver.ados.max_depth == 2
-+
-+        hsolver = HEOMSolver(H, [bath] * 3, 2)
-+        assert hsolver.ados.exponents == exponents * 3
-+        assert hsolver.ados.max_depth == 2
-+
-+    def test_create_mixed_bosonic_and_fermionic(self):
-+        Q = sigmaz()
-+        H = sigmax()
-+        exponents = [
-+            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
-+            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
-+            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
-+        ]
-+        bath = Bath(exponents)
-+
-+        hsolver = HEOMSolver(H, bath, 2)
-+        assert hsolver.ados.exponents == exponents
-+        assert hsolver.ados.max_depth == 2
-+
-+        hsolver = HEOMSolver(H, [bath] * 3, 2)
-+        assert hsolver.ados.exponents == exponents * 3
-+        assert hsolver.ados.max_depth == 2
-+
-+    def test_create_bath_errors(self):
-+        Q = sigmaz()
-+        H = sigmax()
-+        mixed_q_dims = [
-+            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
-+            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
-+        ]
-+
-+        with pytest.raises(ValueError) as err:
-+            HEOMSolver(H, Bath(mixed_q_dims), 2)
-+        assert str(err.value) == (
-+            "All bath exponents must have system coupling operators with the"
-+            " same dimensions but a mixture of dimensions was given."
-+        )
-+
-+    def test_create_h_sys_errors(self):
-+        H = object()
-+        with pytest.raises(TypeError) as err:
-+            HEOMSolver(H, Bath([]), 2)
-+        assert str(err.value) == (
-+            "The Hamiltonian (H) must be a Qobj or QobjEvo"
-+        )
-+
-+        H = [sigmax()]
-+        with pytest.raises(TypeError) as err:
-+            HEOMSolver([H], Bath([]), 2)
-+        assert str(err.value) == (
-+            "The Hamiltonian (H) must be a Qobj or QobjEvo"
-+        )
-+
-+    @pytest.mark.parametrize(['method'], [
-+        pytest.param("run", id="run"),
-+        pytest.param("start", id="start"),
-+    ])
-+    def test_invalid_rho0_errors(self, method):
-+        Q = sigmaz()
-+        H = sigmax()
-+        exponents = [
-+            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
-+            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
-+            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
-+        ]
-+        bath = Bath(exponents)
-+        hsolver = HEOMSolver(H, bath, 2)
-+
-+        if method == "run":
-+            def solve_method(rho0):
-+                return hsolver.run(rho0, [0, 1])
-+        elif method == "start":
-+            def solve_method(rho0):
-+                return hsolver.start(rho0, 0)
-+        else:
-+            assert False, f"method {method} not supported by test"
-+
-+        with pytest.raises(ValueError) as err:
-+            solve_method(basis(3, 0))
-+        assert str(err.value) == (
-+            "Initial state rho has dims [[3], [1]]"
-+            " but the system dims are [[2], [2]]"
-+        )
-+
-+        with pytest.raises(TypeError) as err:
-+            solve_method("batman")
-+        assert str(err.value) == (
-+            "Initial ADOs passed have type <class 'str'> but a "
-+            "HierarchyADOsState or a numpy array-like instance was expected"
-+        )
-+
-+        with pytest.raises(ValueError) as err:
-+            solve_method(np.array([1, 2, 3]))
-+        assert str(err.value) == (
-+            "Initial ADOs passed have shape (3,) but the solver hierarchy"
-+            " shape is (10, 2, 2)"
-+        )
-+
-+    @pytest.mark.parametrize(['evo'], [
-+        pytest.param("qobj", id="qobj"),
-+        pytest.param("qobjevo_const", id="qobjevo_const"),
-+        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
-+    ])
-+    @pytest.mark.parametrize(['liouvillianize'], [
-+        pytest.param(False, id="hamiltonian"),
-+        pytest.param(True, id="liouvillian"),
-+    ])
-+    def test_pure_dephasing_model_bosonic_bath(
-+        self, evo, liouvillianize, atol=1e-3
-+    ):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-+
-+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-+        options = {"nsteps": 15000, "store_states": True}
-+        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
-+
-+        tlist = np.linspace(0, 10, 21)
-+        result = hsolver.run(dlm.rho(), tlist)
-+
-+        test = dlm.state_results(result.states)
-+        expected = dlm.analytic_results(tlist)
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+
-+        if evo != "qobjevo_timedep":
-+            rho_final, ado_state = hsolver.steady_state()
-+            test = dlm.state_results([rho_final])
-+            expected = dlm.analytic_results([100])
-+            np.testing.assert_allclose(test, expected, atol=atol)
-+            assert rho_final == ado_state.extract(0)
-+        else:
-+            assert_raises_steady_state_time_dependent(hsolver)
-+
-+    @pytest.mark.parametrize(['terminator'], [
-+        pytest.param(True, id="terminator"),
-+        pytest.param(False, id="noterminator"),
-+    ])
-+    @pytest.mark.parametrize(['bath_cls'], [
-+        pytest.param(DrudeLorentzBath, id="matsubara"),
-+        pytest.param(DrudeLorentzPadeBath, id="pade"),
-+    ])
-+    def test_pure_dephasing_model_drude_lorentz_baths(
-+        self, terminator, bath_cls, atol=1e-3
-+    ):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        bath = bath_cls(
-+            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
-+        )
-+        if terminator:
-+            _, terminator_op = bath.terminator()
-+            H_sys = liouvillian(dlm.H) + terminator_op
-+        else:
-+            H_sys = dlm.H
-+
-+        options = {"nsteps": 15000, "store_states": True}
-+        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
-+
-+        tlist = np.linspace(0, 10, 21)
-+        result = hsolver.run(dlm.rho(), tlist)
-+
-+        test = dlm.state_results(result.states)
-+        expected = dlm.analytic_results(tlist)
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+
-+        rho_final, ado_state = hsolver.steady_state()
-+        test = dlm.state_results([rho_final])
-+        expected = dlm.analytic_results([100])
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+        assert rho_final == ado_state.extract(0)
-+
-+    def test_underdamped_pure_dephasing_model_underdamped_bath(
-+        self, atol=1e-3
-+    ):
-+        udm = UnderdampedPureDephasingModel(
-+            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
-+        )
-+        bath = UnderDampedBath(
-+            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
-+            w0=udm.w0,
-+        )
-+
-+        options = {"nsteps": 15000, "store_states": True}
-+        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
-+
-+        tlist = np.linspace(0, 10, 21)
-+        result = hsolver.run(udm.rho(), tlist)
-+
-+        test = udm.state_results(result.states)
-+        expected = udm.analytic_results(tlist)
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+
-+        rho_final, ado_state = hsolver.steady_state()
-+        test = udm.state_results([rho_final])
-+        expected = udm.analytic_results([5000])
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+        assert rho_final == ado_state.extract(0)
-+
-+    @pytest.mark.parametrize(['evo'], [
-+        pytest.param("qobj"),
-+        pytest.param("qobjevo_const"),
-+        pytest.param("qobjevo_timedep"),
-+    ])
-+    @pytest.mark.parametrize(['liouvillianize'], [
-+        pytest.param(False, id="hamiltonian"),
-+        pytest.param(True, id="liouvillian"),
-+    ])
-+    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
-+        dlm = DiscreteLevelCurrentModel(
-+            gamma=0.01, W=1, T=0.025851991, lmax=10,
-+        )
-+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
-+
-+        options = {
-+            "store_states": True,
-+            "store_ados": True,
-+            "nsteps": 15_000,
-+            "rtol": 1e-7,
-+            "atol": 1e-7,
-+        }
-+        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
-+        # for a single impurity we converge with max_depth = 2
-+        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
-+
-+        tlist = [0, 600]
-+        result = hsolver.run(dlm.rho(), tlist)
-+        current = dlm.state_current(result.ado_states[-1])
-+        analytic_current = dlm.analytic_current()
-+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-+
-+        if evo != "qobjevo_timedep":
-+            rho_final, ado_state = hsolver.steady_state()
-+            current = dlm.state_current(ado_state)
-+            analytic_current = dlm.analytic_current()
-+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-+        else:
-+            assert_raises_steady_state_time_dependent(hsolver)
-+
-+    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
-+        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
-+        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
-+    ])
-+    def test_discrete_level_model_lorentzian_baths(
-+        self, bath_cls, analytic_current, atol=1e-3
-+    ):
-+        dlm = DiscreteLevelCurrentModel(
-+            gamma=0.01, W=1, T=0.025851991, lmax=10,
-+        )
-+
-+        options = {
-+            "nsteps": 15_000, "store_states": True, "store_ados": True,
-+            "rtol": 1e-7, "atol": 1e-7,
-+        }
-+        bath_l = bath_cls(
-+            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
-+            Nk=dlm.lmax,
-+        )
-+        bath_r = bath_cls(
-+            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
-+            Nk=dlm.lmax,
-+        )
-+        # for a single impurity we converge with max_depth = 2
-+        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
-+
-+        tlist = [0, 600]
-+        result = hsolver.run(dlm.rho(), tlist)
-+        current = dlm.state_current(result.ado_states[-1])
-+        # analytic_current = dlm.analytic_current()
-+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-+
-+        rho_final, ado_state = hsolver.steady_state()
-+        current = dlm.state_current(ado_state)
-+        # analytic_current = dlm.analytic_current()
-+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-+
-+    @pytest.mark.parametrize(['evo'], [
-+        pytest.param("qobj"),
-+        pytest.param("qobjevo_const"),
-+        pytest.param("qobjevo_timedep"),
-+    ])
-+    @pytest.mark.parametrize(['liouvillianize'], [
-+        pytest.param(False, id="hamiltonian"),
-+        pytest.param(True, id="liouvillian"),
-+    ])
-+    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
-+        self, evo, liouvillianize
-+    ):
-+        dlm = DiscreteLevelCurrentModel(
-+            gamma=0.01, W=1, T=0.025851991, lmax=10,
-+        )
-+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
-+
-+        options = {
-+            "store_states": True,
-+            "store_ados": True,
-+            "nsteps": 15_000,
-+            "rtol": 1e-7,
-+            "atol": 1e-7,
-+        }
-+        fermionic_bath = FermionicBath(
-+            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
-+        )
-+        # very weak bosonic coupling which should not affect the dynamics of
-+        # the interaction between the system and the fermionic bath:
-+        eps = [1e-10] * 5
-+        bosonic_Q = sigmax()
-+        bosonic_bath = BosonicBath(
-+            bosonic_Q, eps, eps, eps, eps, combine=False,
-+        )
-+        # for a single impurity we converge with max_depth = 2
-+        # we specify the bosonic bath first to ensure that the test checks
-+        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
-+        # mode is before the fermionic ones
-+        hsolver = HEOMSolver(
-+            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
-+        )
-+
-+        tlist = [0, 600]
-+        result = hsolver.run(dlm.rho(), tlist)
-+        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
-+        analytic_current = dlm.analytic_current()
-+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-+
-+        if evo != "qobjevo_timedep":
-+            rho_final, ado_state = hsolver.steady_state()
-+            current = dlm.state_current(ado_state)
-+            analytic_current = dlm.analytic_current()
-+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-+        else:
-+            assert_raises_steady_state_time_dependent(hsolver)
-+
-+    @pytest.mark.parametrize(['evo'], [
-+        pytest.param("qobj"),
-+        pytest.param("qobjevo_const"),
-+        pytest.param("qobjevo_timedep"),
-+    ])
-+    @pytest.mark.parametrize(['liouvillianize'], [
-+        pytest.param(False, id="hamiltonian"),
-+        pytest.param(True, id="liouvillian"),
-+    ])
-+    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
-+        self, evo, liouvillianize
-+    ):
-+        dlm = DiscreteLevelCurrentModel(
-+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
-+        )
-+        bosonic_mode = BosonicMode(
-+            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
-+        )
-+
-+        dlm_ref = DiscreteLevelCurrentModel(
-+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
-+            bosonic_mode=bosonic_mode,
-+        )
-+
-+        options = {
-+            "store_states": True,
-+            "store_ados": True,
-+            "nsteps": 15_000,
-+            "rtol": 1e-7,
-+            "atol": 1e-7,
-+        }
-+
-+        # First we construct a solver with the boson modelled as part of the
-+        # system and only a single Fermionic bath. This will provide the
-+        # reference result for the test:
-+        fermionic_bath_ref = FermionicBath(
-+            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
-+        )
-+
-+        hsolver_ref = HEOMSolver(
-+            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
-+        )
-+
-+        # Then we construct a solver for the same system, but with the
-+        # bosonic mode as a bath This is the result we would like to check:
-+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-+
-+        fermionic_bath = FermionicBath(
-+            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
-+        )
-+
-+        bosonic_bath = BosonicBath(
-+            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
-+            combine=True, tag="bosonic",
-+        )
-+
-+        hsolver = HEOMSolver(
-+            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
-+        )
-+
-+        # Calculate currents and occupations:
-+        tlist = np.linspace(0, 1000, 300)
-+        psi0 = basis(2, 0)
-+
-+        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
-+        current_ref = [
-+            dlm_ref.state_current(ado_state, tags=["fermionic"])
-+            for ado_state in result_ref.ado_states
-+        ]
-+        sys_occupation_ref = dlm_ref.sys_occupation(
-+            result_ref.states
-+        )
-+
-+        result = hsolver.run(dlm.rho(psi0), tlist)
-+        current = [
-+            dlm.state_current(ado_state, tags=["fermionic"])
-+            for ado_state in result.ado_states
-+        ]
-+        sys_occupation = dlm.sys_occupation(result.states)
-+
-+        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
-+        np.testing.assert_allclose(
-+            sys_occupation_ref, sys_occupation, rtol=1e-3,
-+        )
-+
-+        if evo != "qobjevo_timedep":
-+            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
-+            current_ss_ref = dlm_ref.state_current(ado_state_ref)
-+            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
-+
-+            rho_final, ado_state = hsolver.steady_state()
-+            current_ss = dlm.state_current(ado_state)
-+            sys_occupation_ss = dlm.sys_occupation(rho_final)
-+
-+            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
-+            np.testing.assert_allclose(
-+                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
-+            )
-+        else:
-+            assert_raises_steady_state_time_dependent(hsolver)
-+
-+    @pytest.mark.parametrize(['ado_format'], [
-+        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
-+        pytest.param("numpy", id="numpy"),
-+    ])
-+    def test_ado_input_and_return(self, ado_format):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-+
-+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-+        options = {
-+            "nsteps": 15_000, "store_states": True, "store_ados": True,
-+        }
-+        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
-+
-+        tlist_1 = [0, 1, 2]
-+        result_1 = hsolver.run(dlm.rho(), tlist_1)
-+
-+        tlist_2 = [2, 3, 4]
-+        rho0 = result_1.ado_states[-1]
-+        if ado_format == "numpy":
-+            rho0 = rho0._ado_state  # extract the raw numpy array
-+        result_2 = hsolver.run(rho0, tlist_2)
-+
-+        tlist_full = tlist_1 + tlist_2[1:]
-+        result_full = hsolver.run(dlm.rho(), tlist_full)
-+
-+        times_12 = result_1.times + result_2.times[1:]
-+        times_full = result_full.times
-+        assert times_12 == tlist_full
-+        assert times_full == tlist_full
-+
-+        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
-+        ado_states_full = result_full.ado_states
-+        assert len(ado_states_12) == len(tlist_full)
-+        assert len(ado_states_full) == len(tlist_full)
-+        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
-+            for label in hsolver.ados.labels:
-+                np.testing.assert_allclose(
-+                    ado_12.extract(label).full(),
-+                    ado_full.extract(label).full(),
-+                    atol=1e-6,
-+                )
-+
-+        states_12 = result_1.states + result_2.states[1:]
-+        states_full = result_full.states
-+        assert len(states_12) == len(tlist_full)
-+        assert len(states_full) == len(tlist_full)
-+        for ado_12, state_12 in zip(ado_states_12, states_12):
-+            assert ado_12.rho == state_12
-+        for ado_full, state_full in zip(ado_states_full, states_full):
-+            assert ado_full.rho == state_full
-+
-+        expected = dlm.analytic_results(tlist_full)
-+        test_12 = dlm.state_results(states_12)
-+        np.testing.assert_allclose(test_12, expected, atol=1e-3)
-+        test_full = dlm.state_results(states_full)
-+        np.testing.assert_allclose(test_full, expected, atol=1e-3)
-+
-+    def test_solving_with_step(self):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-+
-+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-+        options = {"nsteps": 15_000, "store_ados": True}
-+        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
-+
-+        tlist = np.linspace(0, 10, 21)
-+        ado_state = None
-+        states = [dlm.rho()]
-+        hsolver.start(states[0], 0)
-+        for t in tlist[1:]:
-+            ado_state = hsolver.step(t)
-+            states.append(ado_state.rho)
-+
-+        test = dlm.state_results(states)
-+        expected = dlm.analytic_results(tlist)
-+        np.testing.assert_allclose(test, expected, atol=1e-3)
-+
-+        assert states[-1] == ado_state.extract(0)
-+
-+
-+class TestHeomsolveFunction:
-+    @pytest.mark.parametrize(['evo'], [
-+        pytest.param("qobj", id="qobj"),
-+        pytest.param("listevo_const", id="listevo_const"),
-+        pytest.param("qobjevo_const", id="qobjevo_const"),
-+        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
-+    ])
-+    @pytest.mark.parametrize(['liouvillianize'], [
-+        pytest.param(False, id="hamiltonian"),
-+        pytest.param(True, id="liouvillian"),
-+    ])
-+    def test_heomsolve_with_pure_dephasing_model(
-+        self, evo, liouvillianize, atol=1e-3
-+    ):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-+
-+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-+        options = {"nsteps": 15000, "store_states": True}
-+
-+        e_ops = {
-+            "11": basis(2, 0) * basis(2, 0).dag(),
-+            "22": basis(2, 1) * basis(2, 1).dag(),
-+        }
-+
-+        tlist = np.linspace(0, 10, 21)
-+        result = heomsolve(
-+            H_sys, bath, 14, dlm.rho(), tlist,
-+            e_ops=e_ops, args={"foo": 1}, options=options)
-+
-+        test = dlm.state_results(result.states)
-+        expected = dlm.analytic_results(tlist)
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+
-+        for label in ["11", "22"]:
-+            np.testing.assert_allclose(
-+                result.e_data[label],
-+                [expect(rho, e_ops[label]) for rho in result.states],
-+                atol=atol,
-+            )
-+
-+
-+class TestHSolverDL:
-+    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
-+        pytest.param(True, 1e-4, id="bnd_cut_approx"),
-+        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
-+    ])
-+    @pytest.mark.parametrize(['evo', 'combine'], [
-+        pytest.param("qobj", True, id="qobj-combined"),
-+        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
-+        pytest.param("listevo_const", True, id="listevo-const-combined"),
-+        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
-+        pytest.param(
-+            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
-+        ),
-+    ])
-+    @pytest.mark.parametrize(['liouvillianize'], [
-+        pytest.param(False, id="hamiltonian"),
-+        pytest.param(True, id="liouvillian"),
-+    ])
-+    def test_pure_dephasing_model(
-+        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
-+    ):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-+
-+        options = {"nsteps": 15_000, "store_states": True}
-+        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
-+                            14, 2, dlm.gamma,
-+                            bnd_cut_approx=bnd_cut_approx,
-+                            options=options, combine=combine)
-+
-+        tlist = np.linspace(0, 10, 21)
-+        result = hsolver.run(dlm.rho(), tlist)
-+
-+        test = dlm.state_results(result.states)
-+        expected = dlm.analytic_results(tlist)
-+        np.testing.assert_allclose(test, expected, atol=atol)
-+
-+        if evo != "qobjevo_timedep":
-+            rho_final, ado_state = hsolver.steady_state()
-+            test = dlm.state_results([rho_final])
-+            expected = dlm.analytic_results([100])
-+            np.testing.assert_allclose(test, expected, atol=atol)
-+            assert rho_final == ado_state.extract(0)
-+        else:
-+            assert_raises_steady_state_time_dependent(hsolver)
-+
-+    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
-+        pytest.param(True, 1e-4, id="bnd_cut_approx"),
-+        pytest.param(False, 1e-3, id="renorm"),
-+    ])
-+    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
-+        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
-+        # is repeated here to ensure the new HSolverDL remains compatibile
-+        # with the old one until it is removed.
-+        cut_frequency = 0.05
-+        coupling_strength = 0.025
-+        lam_c = coupling_strength / np.pi
-+        temperature = 1 / 0.95
-+        times = np.linspace(0, 10, 21)
-+
-+        def _integrand(omega, t):
-+            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
-+            return (-4 * J * (1 - np.cos(omega*t))
-+                    / (np.tanh(0.5*omega / temperature) * omega**2))
-+
-+        # Calculate the analytical results by numerical integration
-+        expected = [
-+            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-+            for t in times
-+        ]
-+
-+        H_sys = Qobj(np.zeros((2, 2)))
-+        Q = sigmaz()
-+        initial_state = 0.5*Qobj(np.ones((2, 2)))
-+        projector = basis(2, 0) * basis(2, 1).dag()
-+        options = {"nsteps": 15_000, "store_states": True}
-+        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
-+                            20, 2, cut_frequency,
-+                            bnd_cut_approx=bnd_cut_approx,
-+                            options=options)
-+        test = expect(hsolver.run(initial_state, times).states, projector)
-+        np.testing.assert_allclose(test, expected, atol=tol)
-+
-+    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
-+    def test_integration_error(self):
-+        dlm = DrudeLorentzPureDephasingModel(
-+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-+        )
-+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-+
-+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-+        options = {"nsteps": 10}
-+        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
-+
-+        with pytest.raises(IntegratorException) as err:
-+            hsolver.run(dlm.rho(), tlist=[0, 10])
-+
-+        assert str(err.value) == (
-+            "Excess work done on this call. Try to increasing the nsteps"
-+            " parameter in the Options class"
-+        )
-+
-+
-+class TestHEOMResult:
-+    def mk_ados(self, bath_dims, max_depth):
-+        exponents = [
-+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
-+        ]
-+        ados = HierarchyADOs(exponents, max_depth=max_depth)
-+        return ados
-+
-+    def mk_rho_and_soln(self, ados, rho_dims):
-+        n_ados = len(ados.labels)
-+        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
-+        rho = Qobj(ado_soln[0, :], dims=rho_dims)
-+        return rho, ado_soln
-+
-+    def test_create_ado_states_attribute(self):
-+        options = fill_options()
-+        result = HEOMResult(e_ops=[], options=options)
-+        assert not hasattr(result, "final_ado_state")
-+        assert not hasattr(result, "ado_states")
-+        assert result.store_ados is False
-+
-+        options = fill_options(store_ados=True)
-+        result = HEOMResult(e_ops=[], options=options)
-+        assert result.final_ado_state is None
-+        assert result.ado_states == []
-+        assert result.store_ados is True
-+
-+    @pytest.mark.parametrize(['e_op_type'], [
-+        pytest.param("qobj", id="qobj"),
-+        pytest.param("qobjevo", id="qobjevo"),
-+        pytest.param("callable", id="callable"),
-+    ])
-+    def test_e_ops(self, e_op_type):
-+        op = Qobj([[1, 0], [0, 0]])
-+        if e_op_type == "qobj":
-+            e_op = op
-+        elif e_op_type == "qobjevo":
-+            e_op = QobjEvo(op)
-+        elif e_op_type == "callable":
-+            def e_op(f, ado_state):
-+                return expect(op, ado_state.rho)
-+        else:
-+            assert False, f"unknown e_op_type {e_op_type!r}"
-+
-+        options = fill_options()
-+        result = HEOMResult(e_ops=e_op, options=options)
-+
-+        ados = self.mk_ados([2, 3], max_depth=2)
-+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-+        e_op_value = expect(op, rho)
-+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-+
-+        result.add(0.1, ado_state)
-+
-+        assert result.expect[0] == [e_op_value]
-+        assert result.e_data[0] == [e_op_value]
-+
-+    def test_store_state(self):
-+        options = fill_options()
-+        result = HEOMResult(e_ops=[], options=options)
-+
-+        ados = self.mk_ados([2, 3], max_depth=2)
-+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-+
-+        result.add(0.1, ado_state)
-+
-+        assert result.times == [0.1]
-+        assert result.states == [rho]
-+        assert result.final_state is rho
-+
-+    def test_store_ados(self):
-+        options = fill_options(store_ados=True)
-+        result = HEOMResult(e_ops=[], options=options)
-+
-+        ados = self.mk_ados([2, 3], max_depth=2)
-+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-+
-+        result.add(0.1, ado_state)
-+        assert result.times == [0.1]
-+        assert result.states == [rho]
-+        assert result.final_state is rho
-+        assert result.ado_states == [ado_state]
-+        assert result.final_ado_state is ado_state
-+
-+
-+class Test_GatherHEOMRHS:
-+    def test_simple_gather(self):
-+        def f(label):
-+            return int(label.lstrip("o"))
-+
-+        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
-+
-+        for i in range(3):
-+            for j in range(3):
-+                base = 10 * (j * 2) + (i * 2)
-+                block_op = _data.to(
-+                    _data.CSR,
-+                    _data.create(np.array([
-+                        [base, base + 10],
-+                        [base + 1, base + 11],
-+                    ]))
-+                )
-+                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
-+
-+        op = gather_heoms.gather()
-+
-+        expected_op = np.array([
-+            [10 * i + j for i in range(2 * 3)]
-+            for j in range(2 * 3)
-+        ], dtype=np.complex128)
-+
-+        np.testing.assert_array_equal(op.to_array(), expected_op)
-+        assert isinstance(op, _data.CSR)
-diff --git a/qutip/tests/solver/heom/test_heom.py b/qutip/tests/solver/heom/test_heom.py
-index c8988a16..ad5680b6 100644
---- a/qutip/tests/solver/heom/test_heom.py
-+++ b/qutip/tests/solver/heom/test_heom.py
-@@ -1,46 +1,46 @@
--"""
--Tests for qutip.nonmarkov.heom.
--"""
--
--import pytest
--from qutip.solver.heom import (
--    BathExponent,
--    Bath,
--    BosonicBath,
--    DrudeLorentzBath,
--    DrudeLorentzPadeBath,
--    UnderDampedBath,
--    FermionicBath,
--    LorentzianBath,
--    LorentzianPadeBath,
--    heomsolve,
--    HEOMSolver,
--    HEOMResult,
--    HSolverDL,
--    HierarchyADOs,
--    HierarchyADOsState,
--)
--
--class TestBathAPI:
--    def test_api(self):
--        # just assert that the baths are importable
--        assert BathExponent
--        assert Bath
--        assert BosonicBath
--        assert DrudeLorentzBath
--        assert DrudeLorentzPadeBath
--        assert UnderDampedBath
--        assert FermionicBath
--        assert LorentzianBath
--        assert LorentzianPadeBath
--
--
--class TestSolverAPI:
--    def test_api(self):
--        # just assert that the solvers and associated classes are importable
--        assert heomsolve
--        assert HEOMSolver
--        assert HEOMResult
--        assert HSolverDL
--        assert HierarchyADOs
--        assert HierarchyADOsState
-+"""
-+Tests for qutip.nonmarkov.heom.
-+"""
-+
-+import pytest
-+from qutip.solver.heom import (
-+    BathExponent,
-+    Bath,
-+    BosonicBath,
-+    DrudeLorentzBath,
-+    DrudeLorentzPadeBath,
-+    UnderDampedBath,
-+    FermionicBath,
-+    LorentzianBath,
-+    LorentzianPadeBath,
-+    heomsolve,
-+    HEOMSolver,
-+    HEOMResult,
-+    HSolverDL,
-+    HierarchyADOs,
-+    HierarchyADOsState,
-+)
-+
-+class TestBathAPI:
-+    def test_api(self):
-+        # just assert that the baths are importable
-+        assert BathExponent
-+        assert Bath
-+        assert BosonicBath
-+        assert DrudeLorentzBath
-+        assert DrudeLorentzPadeBath
-+        assert UnderDampedBath
-+        assert FermionicBath
-+        assert LorentzianBath
-+        assert LorentzianPadeBath
-+
-+
-+class TestSolverAPI:
-+    def test_api(self):
-+        # just assert that the solvers and associated classes are importable
-+        assert heomsolve
-+        assert HEOMSolver
-+        assert HEOMResult
-+        assert HSolverDL
-+        assert HierarchyADOs
-+        assert HierarchyADOsState
-diff --git a/qutip/tests/solver/test_brmesolve.py b/qutip/tests/solver/test_brmesolve.py
-index 7b1aef06..bc5b4c6d 100644
---- a/qutip/tests/solver/test_brmesolve.py
-+++ b/qutip/tests/solver/test_brmesolve.py
-@@ -1,296 +1,296 @@
--import pytest
--import numpy as np
--import qutip
--from qutip.solver.brmesolve import brmesolve
--
--
--def pauli_spin_operators():
--    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
--
--
--_simple_qubit_gamma = 0.25
--coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
--                          args={'w':0})
--_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
--_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
--_x_a_op = [qutip.sigmax(), coeff]
--
--
--@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
--    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
--    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
--    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
--                 id="me collapse-br collapse-br coupling"),
--])
--def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
--    """
--    Test that the BR solver handles collapse and coupling operators correctly
--    relative to the standard ME solver.
--    """
--    delta = 0.0
--    epsilon = 0.5 * 2 * np.pi
--    e_ops = pauli_spin_operators()
--    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
--    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
--    times = np.linspace(0, 10, 100)
--    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
--    opt = {"tensor_type": "dense"}
--    brme = brmesolve(
--        H, psi0, times,
--        a_ops=brme_a_ops, c_ops=brme_c_ops,
--        e_ops=e_ops, options=opt
--    )
--    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
--        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
--
--
--def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
--    if n_th == 0:
--        return lambda w: kappa * (w >= 0)
--
--    w_th = w0 / np.log(1 + 1/n_th)
--
--    def f(t, w):
--        scale = np.exp(w / w_th) if w < 0 else 1
--        return (n_th + 1) * kappa * scale
--    return f
--
--
--def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
--    a = qutip.destroy(dimension)
--    if n_th == 0:
--        return [np.sqrt(kappa) * a]
--    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
--
--
--@pytest.mark.parametrize("n_th", [0, 0.15])
--def test_harmonic_oscillator(n_th):
--    N = 10
--    w0 = 1.0 * 2*np.pi
--    g = 0.05 * w0
--    kappa = 0.15
--    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
--
--    a = qutip.destroy(N)
--    H = w0*a.dag()*a + g*(a+a.dag())
--    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
--    psi0 = qutip.ket2dm(psi0)
--    times = np.linspace(0, 20, 1000)
--
--    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
--    a_ops = [[a + a.dag(), S_w]]
--    e_ops = [a.dag()*a, a+a.dag()]
--
--    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
--    brme = brmesolve(H, psi0, times, a_ops, e_ops)
--    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
--        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
--
--    num = qutip.num(N)
--    me_num = qutip.expect(num, me.states)
--    brme_num = qutip.expect(num, brme.states)
--    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
--
--
--def test_jaynes_cummings_zero_temperature_spectral_callable():
--    """
--    brmesolve: Jaynes-Cummings model, zero temperature
--    """
--    N = 10
--    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
--    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
--    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
--    kappa = 0.05
--    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
--    e_ops = [a.dag()*a, sp.dag()*sp]
--
--    w0 = 1.0 * 2*np.pi
--    g = 0.05 * 2*np.pi
--    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
--
--    c_ops = [np.sqrt(kappa) * a]
--    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
--
--    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
--    brme = brmesolve(H, psi0, times, a_ops, e_ops)
--    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
--        # Accept 5% error.
--        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
--
--
--def test_tensor_system():
--    """
--    brmesolve: Check for #572 bug.
--    """
--    w1, w2, w3 = 1, 2, 3
--    gamma2, gamma3 = 0.1, 0.1
--    id2 = qutip.qeye(2)
--
--    # Hamiltonian for three uncoupled qubits
--    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
--         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
--         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
--
--    # White noise
--    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
--    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
--
--    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
--    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
--
--    # Initial state : first qubit is excited
--    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
--    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
--    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
--
--    # Projector on the excited state of qubit 1
--    proj_up1 = qutip.tensor(exc2, id2, id2)
--    times = np.linspace(0, 10./gamma3, 1000)
--
--    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
--                    e_ops=[proj_up1]).expect[0]
--
--    np.testing.assert_allclose(sol, np.ones_like(times))
--
--
--def test_solver_accepts_list_hamiltonian():
--    """
--    brmesolve: input list of Qobj
--    """
--    delta = 0.0 * 2 * np.pi
--    epsilon = 0.5 * 2 * np.pi
--    gamma = 0.25
--    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
--    e_ops = pauli_spin_operators()
--    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
--    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
--    times = np.linspace(0, 10, 100)
--    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
--    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
--    for me_expectation, brme_expectation in zip(me, brme):
--        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
--
--
--def test_jaynes_cummings_zero_temperature_spectral_str():
--    N = 10
--    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
--    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
--    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
--    kappa = 0.05
--    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
--    e_ops = [a.dag()*a, sp.dag()*sp]
--
--    w0 = 1.0 * 2*np.pi
--    g = 0.05 * 2*np.pi
--    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
--
--    c_ops = [np.sqrt(kappa) * a]
--    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
--
--    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
--    brme = brmesolve(H, psi0, times, a_ops, e_ops)
--    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
--        # Accept 5% error.
--        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
--
--
--def _mixed_string(kappa, _):
--    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
--
--
--def _separate_strings(kappa, _):
--    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
--
--
--def _string_w_interpolating_t(kappa, times):
--    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
--    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
--
--
--@pytest.mark.slow
--@pytest.mark.parametrize("time_dependence_tuple", [
--        _mixed_string,
--        _separate_strings,
--        _string_w_interpolating_t,
--    ])
--def test_time_dependence_tuples(time_dependence_tuple):
--    N = 10
--    a = qutip.destroy(N)
--    H = a.dag()*a
--    psi0 = qutip.basis(N, 9)
--    times = np.linspace(0, 10, 100)
--    kappa = 0.2
--    spectra, coeff = time_dependence_tuple(kappa, times)
--    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
--    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
--    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
--    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
--
--
--def test_time_dependent_spline_in_c_ops():
--    N = 10
--    a = qutip.destroy(N)
--    H = a.dag()*a
--    psi0 = qutip.basis(N, 9)
--    times = np.linspace(0, 10, 100)
--    kappa = 0.2
--    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
--    spectra, coeff = _string_w_interpolating_t(kappa, times)
--    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
--    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
--    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
--    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
--    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
--
--
--@pytest.mark.slow
--def test_nonhermitian_e_ops():
--    N = 5
--    a = qutip.destroy(N)
--    coefficient = np.random.random() + 1j*np.random.random()
--    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
--    H_brme = [[H, '1']]
--    psi0 = qutip.basis(N, 2)
--    times = np.linspace(0, 10, 10)
--    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
--    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
--    np.testing.assert_allclose(me, brme, atol=1e-4)
--
--
--@pytest.mark.slow
--def test_result_states():
--    N = 5
--    a = qutip.destroy(N)
--    coefficient = np.random.random() + 1j*np.random.random()
--    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
--    H_brme = [[H, '1']]
--    psi0 = qutip.fock_dm(N, 2)
--    times = np.linspace(0, 10, 10)
--    me = qutip.mesolve(H, psi0, times).states
--    brme = brmesolve(H_brme, psi0, times).states
--    assert max(np.abs((me_state - brme_state).full()).max()
--               for me_state, brme_state in zip(me, brme)) < 1e-5
--
--
--@pytest.mark.slow
--def test_hamiltonian_taking_arguments():
--    N = 10
--    w0 = 1.0 * 2*np.pi
--    g = 0.75 * 2*np.pi
--    kappa = 0.05
--    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
--    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
--    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
--    psi0 = qutip.ket2dm(psi0)
--    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
--
--    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
--    e_ops = [a.dag()*a, sp.dag()*sp]
--
--    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
--    args = {'ii': 1}
--
--    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
--    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
--    for arg, no_arg in zip(args.expect, no_args.expect):
--        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
-+import pytest
-+import numpy as np
-+import qutip
-+from qutip.solver.brmesolve import brmesolve
-+
-+
-+def pauli_spin_operators():
-+    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-+
-+
-+_simple_qubit_gamma = 0.25
-+coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
-+                          args={'w':0})
-+_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
-+_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
-+_x_a_op = [qutip.sigmax(), coeff]
-+
-+
-+@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
-+    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
-+    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
-+    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
-+                 id="me collapse-br collapse-br coupling"),
-+])
-+def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
-+    """
-+    Test that the BR solver handles collapse and coupling operators correctly
-+    relative to the standard ME solver.
-+    """
-+    delta = 0.0
-+    epsilon = 0.5 * 2 * np.pi
-+    e_ops = pauli_spin_operators()
-+    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
-+    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-+    times = np.linspace(0, 10, 100)
-+    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
-+    opt = {"tensor_type": "dense"}
-+    brme = brmesolve(
-+        H, psi0, times,
-+        a_ops=brme_a_ops, c_ops=brme_c_ops,
-+        e_ops=e_ops, options=opt
-+    )
-+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
-+
-+
-+def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
-+    if n_th == 0:
-+        return lambda w: kappa * (w >= 0)
-+
-+    w_th = w0 / np.log(1 + 1/n_th)
-+
-+    def f(t, w):
-+        scale = np.exp(w / w_th) if w < 0 else 1
-+        return (n_th + 1) * kappa * scale
-+    return f
-+
-+
-+def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
-+    a = qutip.destroy(dimension)
-+    if n_th == 0:
-+        return [np.sqrt(kappa) * a]
-+    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
-+
-+
-+@pytest.mark.parametrize("n_th", [0, 0.15])
-+def test_harmonic_oscillator(n_th):
-+    N = 10
-+    w0 = 1.0 * 2*np.pi
-+    g = 0.05 * w0
-+    kappa = 0.15
-+    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
-+
-+    a = qutip.destroy(N)
-+    H = w0*a.dag()*a + g*(a+a.dag())
-+    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
-+    psi0 = qutip.ket2dm(psi0)
-+    times = np.linspace(0, 20, 1000)
-+
-+    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
-+    a_ops = [[a + a.dag(), S_w]]
-+    e_ops = [a.dag()*a, a+a.dag()]
-+
-+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
-+
-+    num = qutip.num(N)
-+    me_num = qutip.expect(num, me.states)
-+    brme_num = qutip.expect(num, brme.states)
-+    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
-+
-+
-+def test_jaynes_cummings_zero_temperature_spectral_callable():
-+    """
-+    brmesolve: Jaynes-Cummings model, zero temperature
-+    """
-+    N = 10
-+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-+    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
-+    kappa = 0.05
-+    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
-+    e_ops = [a.dag()*a, sp.dag()*sp]
-+
-+    w0 = 1.0 * 2*np.pi
-+    g = 0.05 * 2*np.pi
-+    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
-+
-+    c_ops = [np.sqrt(kappa) * a]
-+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-+
-+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-+        # Accept 5% error.
-+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
-+
-+
-+def test_tensor_system():
-+    """
-+    brmesolve: Check for #572 bug.
-+    """
-+    w1, w2, w3 = 1, 2, 3
-+    gamma2, gamma3 = 0.1, 0.1
-+    id2 = qutip.qeye(2)
-+
-+    # Hamiltonian for three uncoupled qubits
-+    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
-+         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
-+         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
-+
-+    # White noise
-+    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
-+    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
-+
-+    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
-+    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
-+
-+    # Initial state : first qubit is excited
-+    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
-+    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
-+    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
-+
-+    # Projector on the excited state of qubit 1
-+    proj_up1 = qutip.tensor(exc2, id2, id2)
-+    times = np.linspace(0, 10./gamma3, 1000)
-+
-+    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
-+                    e_ops=[proj_up1]).expect[0]
-+
-+    np.testing.assert_allclose(sol, np.ones_like(times))
-+
-+
-+def test_solver_accepts_list_hamiltonian():
-+    """
-+    brmesolve: input list of Qobj
-+    """
-+    delta = 0.0 * 2 * np.pi
-+    epsilon = 0.5 * 2 * np.pi
-+    gamma = 0.25
-+    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
-+    e_ops = pauli_spin_operators()
-+    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
-+    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-+    times = np.linspace(0, 10, 100)
-+    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
-+    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
-+    for me_expectation, brme_expectation in zip(me, brme):
-+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
-+
-+
-+def test_jaynes_cummings_zero_temperature_spectral_str():
-+    N = 10
-+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-+    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
-+    kappa = 0.05
-+    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
-+    e_ops = [a.dag()*a, sp.dag()*sp]
-+
-+    w0 = 1.0 * 2*np.pi
-+    g = 0.05 * 2*np.pi
-+    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
-+
-+    c_ops = [np.sqrt(kappa) * a]
-+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-+
-+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-+        # Accept 5% error.
-+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
-+
-+
-+def _mixed_string(kappa, _):
-+    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
-+
-+
-+def _separate_strings(kappa, _):
-+    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
-+
-+
-+def _string_w_interpolating_t(kappa, times):
-+    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
-+    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
-+
-+
-+@pytest.mark.slow
-+@pytest.mark.parametrize("time_dependence_tuple", [
-+        _mixed_string,
-+        _separate_strings,
-+        _string_w_interpolating_t,
-+    ])
-+def test_time_dependence_tuples(time_dependence_tuple):
-+    N = 10
-+    a = qutip.destroy(N)
-+    H = a.dag()*a
-+    psi0 = qutip.basis(N, 9)
-+    times = np.linspace(0, 10, 100)
-+    kappa = 0.2
-+    spectra, coeff = time_dependence_tuple(kappa, times)
-+    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
-+    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
-+    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
-+    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
-+
-+
-+def test_time_dependent_spline_in_c_ops():
-+    N = 10
-+    a = qutip.destroy(N)
-+    H = a.dag()*a
-+    psi0 = qutip.basis(N, 9)
-+    times = np.linspace(0, 10, 100)
-+    kappa = 0.2
-+    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
-+    spectra, coeff = _string_w_interpolating_t(kappa, times)
-+    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
-+    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
-+    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
-+    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
-+    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
-+
-+
-+@pytest.mark.slow
-+def test_nonhermitian_e_ops():
-+    N = 5
-+    a = qutip.destroy(N)
-+    coefficient = np.random.random() + 1j*np.random.random()
-+    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
-+    H_brme = [[H, '1']]
-+    psi0 = qutip.basis(N, 2)
-+    times = np.linspace(0, 10, 10)
-+    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
-+    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
-+    np.testing.assert_allclose(me, brme, atol=1e-4)
-+
-+
-+@pytest.mark.slow
-+def test_result_states():
-+    N = 5
-+    a = qutip.destroy(N)
-+    coefficient = np.random.random() + 1j*np.random.random()
-+    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
-+    H_brme = [[H, '1']]
-+    psi0 = qutip.fock_dm(N, 2)
-+    times = np.linspace(0, 10, 10)
-+    me = qutip.mesolve(H, psi0, times).states
-+    brme = brmesolve(H_brme, psi0, times).states
-+    assert max(np.abs((me_state - brme_state).full()).max()
-+               for me_state, brme_state in zip(me, brme)) < 1e-5
-+
-+
-+@pytest.mark.slow
-+def test_hamiltonian_taking_arguments():
-+    N = 10
-+    w0 = 1.0 * 2*np.pi
-+    g = 0.75 * 2*np.pi
-+    kappa = 0.05
-+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-+    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
-+    psi0 = qutip.ket2dm(psi0)
-+    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
-+
-+    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
-+    e_ops = [a.dag()*a, sp.dag()*sp]
-+
-+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-+    args = {'ii': 1}
-+
-+    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
-+    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
-+    for arg, no_arg in zip(args.expect, no_args.expect):
-+        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
-diff --git a/qutip/tests/solver/test_correlation.py b/qutip/tests/solver/test_correlation.py
-index bf96b045..f2af197d 100644
---- a/qutip/tests/solver/test_correlation.py
-+++ b/qutip/tests/solver/test_correlation.py
-@@ -1,329 +1,329 @@
--import pytest
--import functools
--from itertools import product
--import numpy as np
--import qutip
--
--pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
--
--_equivalence_dimension = 15
--_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
--_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
--
--
--@pytest.mark.filterwarnings("ignore::FutureWarning")
--@pytest.mark.parametrize(["solver", "start"], [
--    pytest.param("es", _equivalence_coherent, id="es"),
--    pytest.param("es", None, id="es-steady state"),
--])
--def test_correlation_solver_equivalence(solver, start):
--    """
--    Test that all of the correlation solvers give the same results for a given
--    system.
--    """
--    a = qutip.destroy(_equivalence_dimension)
--    x = ( a + a.dag() ) / np.sqrt(2)
--    H = a.dag() * a
--    G1 = 0.75
--    n_th = 2
--    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
--             np.sqrt(G1 * n_th) * a.dag()]
--    times = np.linspace(0, 3, 61)
--    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
--    # long simulation time.
--    tol = 0.25 if solver == "mc" else 1e-4
--    # We use the master equation version as a base, but it doesn't actually
--    # matter - if all the tests fail, it implies that the "me" solver might be
--    # broken, whereas if only one fails, then it implies that only that one is
--    # broken.  We test that all solvers are equivalent by transitive equality
--    # to the "me" solver.
--    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
--                                    a.dag(), a, solver="me")
--    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
--                                   a.dag(), a, solver=solver)
--    np.testing.assert_allclose(base, cmp, atol=tol)
--
--
--def _spectrum_wrapper(solver):
--    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
--    @functools.wraps(qutip.spectrum)
--    def out(H, c_ops, a, b):
--        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
--                frequencies)
--    return out
--
--
--def _spectrum_fft(H, c_ops, a, b):
--    times = np.linspace(0, 100, 2500)
--    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
--    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
--    return spectrum, frequencies
--
--
--@pytest.mark.parametrize("spectrum", [
--    pytest.param(_spectrum_fft, id="fft"),
--    pytest.param(_spectrum_wrapper("es"), id="es"),
--    pytest.param(_spectrum_wrapper("pi"), id="pi"),
--    pytest.param(_spectrum_wrapper("solve"), id="solve"),
--])
--def test_spectrum_solver_equivalence_to_es(spectrum):
--    """Test equivalence of the spectrum solvers to the base "es" method."""
--    # Jaynes--Cummings model.
--    dimension = 4
--    wc = wa = 1.0 * 2*np.pi
--    g = 0.1 * 2*np.pi
--    kappa = 0.75
--    gamma = 0.25
--    n_th = 0.01
--
--    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
--    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
--    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
--    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
--             np.sqrt(kappa * n_th) * a.dag(),
--             np.sqrt(gamma) * sm.dag()]
--
--    test, frequencies = spectrum(H, c_ops, a.dag(), a)
--    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
--    np.testing.assert_allclose(base, test, atol=1e-3)
--
--
--def _trapz_2d(z, xy):
--    """2D trapezium-method integration assuming a square grid."""
--    dx = xy[1] - xy[0]
--    return dx*dx * np.trapz(np.trapz(z, axis=0))
--
--
--def _n_correlation(times, n):
--    """
--    Numerical integration of the correlation function given an array of
--    expectation values.
--    """
--    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
--                     for t in range(times.shape[0])])
--
--
--def _coefficient_function(t, args):
--    t_off, tp = args['t_off'], args['tp']
--    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
--
--
--_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
--
--
--def _h_qobj_function(t, args):
--    return args['H0'] * _coefficient_function(t, args)
--
--
--# 2LS and 3LS stand for two- and three-level system respectively.
--
--_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
--_2ls_times = np.linspace(0, 5, 51)
--_3ls_args = {'t_off': 2, 'tp': 1}
--_3ls_times = np.linspace(0, 6, 20)
--
--
--def _2ls_g2_0(H, c_ops):
--    sp = qutip.sigmap()
--    start = qutip.basis(2, 0)
--    times = _2ls_times
--    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
--    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
--                                           sp.dag(), sp.dag()*sp, sp,
--                                           args=_2ls_args)
--    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
--                                  e_ops=[qutip.num(2)],
--                                  args=_2ls_args).expect[0]
--    integral_correlation = _trapz_2d(np.real(correlation), times)
--    integral_n_expectation = np.trapz(n_expectation, times)
--    # Factor of two from negative time correlations.
--    return 2 * integral_correlation / integral_n_expectation**2
--
--
--@pytest.fixture(params=[
--    pytest.param(_coefficient_string, id="string"),
--    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
--    pytest.param(_coefficient_function, id="function"),
--])
--def dependence_2ls(request):
--    return request.param
--
--
--class TestTimeDependence:
--    """
--    Test correlations with time-dependent operators using a two-level system
--    (2LS) or a three-level system (3LS).
--    """
--    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
--        H = [[_2ls_args['H0'], dependence_2ls]]
--        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
--
--    def test_hamiltonian_from_function_2ls(self):
--        H = _h_qobj_function
--        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
--
--    @pytest.mark.slow
--    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
--        H = [[_2ls_args['H0'], dependence_2ls]]
--        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
--        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
--
--    @pytest.mark.slow
--    @pytest.mark.parametrize("dependence_3ls", [
--        pytest.param(_coefficient_string, id="string"),
--        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
--        pytest.param(_coefficient_function, id="function"),
--    ])
--    def test_coefficient_c_ops_3ls(self, dependence_3ls):
--        # Calculate zero-delay HOM cross-correlation for incoherently pumped
--        # three-level system, g2_ab[0] with gamma = 1.
--        dimension = 3
--        H = qutip.qzero(dimension)
--        start = qutip.basis(dimension, 2)
--        times = _3ls_times
--        project_0_1 = qutip.projection(dimension, 0, 1)
--        project_1_2 = qutip.projection(dimension, 1, 2)
--        population_1 = qutip.projection(dimension, 1, 1)
--        # Define the pi pulse to be when 99% of the population is transferred.
--        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
--        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
--                                      args=_3ls_args)
--        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
--        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
--                                            project_0_1.dag(), project_0_1,
--                                            args=_3ls_args)
--        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
--                                             project_0_1.dag(), project_0_1,
--                                             args=_3ls_args, reverse=True)
--        times2 = np.concatenate([times, times[1:] + times[-1]])
--        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
--                                 e_ops=[population_1]).expect[0]
--        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
--        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
--        assert abs(g2_ab_0 - 0.185) < 1e-2
--
--
--def _step(t):
--    return np.arctan(t)/np.pi + 0.5
--
--
--def test_hamiltonian_order_unimportant():
--    # Testing for regression on issue 1048.
--    sp = qutip.sigmap()
--    H = [[qutip.sigmax(), lambda t: _step(t-2)],
--         [qutip.qeye(2), lambda t: _step(-(t-2))]]
--    start = qutip.basis(2, 0)
--    times = np.linspace(0, 5, 6)
--    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
--                                        sp.dag(), sp)
--    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
--                                         sp.dag(), sp)
--    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
--
--
--@pytest.mark.parametrize(['solver', 'state'], [
--    pytest.param('me', _equivalence_fock, id="me-ket"),
--    pytest.param('me', _equivalence_coherent, id="me-dm"),
--    pytest.param('me', None, id="me-steady"),
--    pytest.param('es', _equivalence_fock, id="es-ket"),
--    pytest.param('es', _equivalence_coherent, id="es-dm"),
--    pytest.param('es', None, id="es-steady"),
--])
--@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
--                         ids=["hermitian", "nonhermitian"])
--@pytest.mark.parametrize("w", [1, 2])
--@pytest.mark.parametrize("gamma", [1, 10])
--def test_correlation_2op_1t_known_cases(solver,
--                                        state,
--                                        is_e_op_hermitian,
--                                        w,
--                                        gamma,
--                                       ):
--    """This test compares the output correlation_2op_1 solution to an analytical
--    solution."""
--
--    a = qutip.destroy(_equivalence_dimension)
--    x = (a + a.dag())/np.sqrt(2)
--
--    H = w * a.dag() * a
--
--    a_op = x if is_e_op_hermitian else a
--    b_op = x if is_e_op_hermitian else a.dag()
--    c_ops = [np.sqrt(gamma) * a]
--
--    times = np.linspace(0, 1, 30)
--
--    # Handle the case state==None when computing expt values
--    rho0 = state if state else qutip.steadystate(H, c_ops)
--    if is_e_op_hermitian:
--        # Analitycal solution for x,x as operators.
--        base = 0
--        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
--        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
--        base /= np.sqrt(2)
--    else:
--        # Analitycal solution for a,adag as operators.
--        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
--
--    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
--
--    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
--
--
--def test_correlation_timedependant_op():
--    num = qutip.num(2)
--    a = qutip.destroy(2)
--    sx = qutip.sigmax()
--    sz = qutip.sigmaz()
--    times = np.arange(4)
--    # switch between sx and sz at t=1.5
--    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
--
--    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
--    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
--    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
--    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
--    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
--
--
--def test_alternative_solver():
--    from qutip.solver.mesolve import MESolver
--    from qutip.solver.brmesolve import BRSolver
--
--    H = qutip.num(5)
--    a = qutip.destroy(5)
--    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
--
--    br = BRSolver(H, a_ops)
--    me = MESolver(H, [a])
--    times = np.arange(4)
--
--    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
--    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
--
--    np.testing.assert_allclose(br_corr, me_corr)
--
--
--def test_G1():
--    H = qutip.Qobj([[0,1], [1,0]])
--    psi0 = qutip.basis(2)
--    taus = np.linspace(0, 1, 11)
--    scale = 2
--    a_op = qutip.sigmaz() * scale
--    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
--    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
--    np.testing.assert_allclose(g1, expected, rtol=2e-5)
--    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
--
--
--def test_G2():
--    N = 10
--    H = qutip.rand_dm(N)
--    psi0 = qutip.rand_ket(N)
--    taus = np.linspace(0, 1, 11)
--    scale = 2
--    a_op = qutip.rand_unitary(N) * scale
--    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
--    expected = np.ones(11)
--    np.testing.assert_allclose(g1, expected, rtol=2e-5)
--    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
-+import pytest
-+import functools
-+from itertools import product
-+import numpy as np
-+import qutip
-+
-+pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
-+
-+_equivalence_dimension = 15
-+_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
-+_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
-+
-+
-+@pytest.mark.filterwarnings("ignore::FutureWarning")
-+@pytest.mark.parametrize(["solver", "start"], [
-+    pytest.param("es", _equivalence_coherent, id="es"),
-+    pytest.param("es", None, id="es-steady state"),
-+])
-+def test_correlation_solver_equivalence(solver, start):
-+    """
-+    Test that all of the correlation solvers give the same results for a given
-+    system.
-+    """
-+    a = qutip.destroy(_equivalence_dimension)
-+    x = ( a + a.dag() ) / np.sqrt(2)
-+    H = a.dag() * a
-+    G1 = 0.75
-+    n_th = 2
-+    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
-+             np.sqrt(G1 * n_th) * a.dag()]
-+    times = np.linspace(0, 3, 61)
-+    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
-+    # long simulation time.
-+    tol = 0.25 if solver == "mc" else 1e-4
-+    # We use the master equation version as a base, but it doesn't actually
-+    # matter - if all the tests fail, it implies that the "me" solver might be
-+    # broken, whereas if only one fails, then it implies that only that one is
-+    # broken.  We test that all solvers are equivalent by transitive equality
-+    # to the "me" solver.
-+    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
-+                                    a.dag(), a, solver="me")
-+    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
-+                                   a.dag(), a, solver=solver)
-+    np.testing.assert_allclose(base, cmp, atol=tol)
-+
-+
-+def _spectrum_wrapper(solver):
-+    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
-+    @functools.wraps(qutip.spectrum)
-+    def out(H, c_ops, a, b):
-+        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
-+                frequencies)
-+    return out
-+
-+
-+def _spectrum_fft(H, c_ops, a, b):
-+    times = np.linspace(0, 100, 2500)
-+    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
-+    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
-+    return spectrum, frequencies
-+
-+
-+@pytest.mark.parametrize("spectrum", [
-+    pytest.param(_spectrum_fft, id="fft"),
-+    pytest.param(_spectrum_wrapper("es"), id="es"),
-+    pytest.param(_spectrum_wrapper("pi"), id="pi"),
-+    pytest.param(_spectrum_wrapper("solve"), id="solve"),
-+])
-+def test_spectrum_solver_equivalence_to_es(spectrum):
-+    """Test equivalence of the spectrum solvers to the base "es" method."""
-+    # Jaynes--Cummings model.
-+    dimension = 4
-+    wc = wa = 1.0 * 2*np.pi
-+    g = 0.1 * 2*np.pi
-+    kappa = 0.75
-+    gamma = 0.25
-+    n_th = 0.01
-+
-+    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
-+    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
-+    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
-+    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
-+             np.sqrt(kappa * n_th) * a.dag(),
-+             np.sqrt(gamma) * sm.dag()]
-+
-+    test, frequencies = spectrum(H, c_ops, a.dag(), a)
-+    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
-+    np.testing.assert_allclose(base, test, atol=1e-3)
-+
-+
-+def _trapz_2d(z, xy):
-+    """2D trapezium-method integration assuming a square grid."""
-+    dx = xy[1] - xy[0]
-+    return dx*dx * np.trapz(np.trapz(z, axis=0))
-+
-+
-+def _n_correlation(times, n):
-+    """
-+    Numerical integration of the correlation function given an array of
-+    expectation values.
-+    """
-+    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
-+                     for t in range(times.shape[0])])
-+
-+
-+def _coefficient_function(t, args):
-+    t_off, tp = args['t_off'], args['tp']
-+    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
-+
-+
-+_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
-+
-+
-+def _h_qobj_function(t, args):
-+    return args['H0'] * _coefficient_function(t, args)
-+
-+
-+# 2LS and 3LS stand for two- and three-level system respectively.
-+
-+_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
-+_2ls_times = np.linspace(0, 5, 51)
-+_3ls_args = {'t_off': 2, 'tp': 1}
-+_3ls_times = np.linspace(0, 6, 20)
-+
-+
-+def _2ls_g2_0(H, c_ops):
-+    sp = qutip.sigmap()
-+    start = qutip.basis(2, 0)
-+    times = _2ls_times
-+    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
-+    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
-+                                           sp.dag(), sp.dag()*sp, sp,
-+                                           args=_2ls_args)
-+    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
-+                                  e_ops=[qutip.num(2)],
-+                                  args=_2ls_args).expect[0]
-+    integral_correlation = _trapz_2d(np.real(correlation), times)
-+    integral_n_expectation = np.trapz(n_expectation, times)
-+    # Factor of two from negative time correlations.
-+    return 2 * integral_correlation / integral_n_expectation**2
-+
-+
-+@pytest.fixture(params=[
-+    pytest.param(_coefficient_string, id="string"),
-+    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
-+    pytest.param(_coefficient_function, id="function"),
-+])
-+def dependence_2ls(request):
-+    return request.param
-+
-+
-+class TestTimeDependence:
-+    """
-+    Test correlations with time-dependent operators using a two-level system
-+    (2LS) or a three-level system (3LS).
-+    """
-+    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
-+        H = [[_2ls_args['H0'], dependence_2ls]]
-+        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
-+
-+    def test_hamiltonian_from_function_2ls(self):
-+        H = _h_qobj_function
-+        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
-+
-+    @pytest.mark.slow
-+    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
-+        H = [[_2ls_args['H0'], dependence_2ls]]
-+        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
-+        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
-+
-+    @pytest.mark.slow
-+    @pytest.mark.parametrize("dependence_3ls", [
-+        pytest.param(_coefficient_string, id="string"),
-+        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
-+        pytest.param(_coefficient_function, id="function"),
-+    ])
-+    def test_coefficient_c_ops_3ls(self, dependence_3ls):
-+        # Calculate zero-delay HOM cross-correlation for incoherently pumped
-+        # three-level system, g2_ab[0] with gamma = 1.
-+        dimension = 3
-+        H = qutip.qzero(dimension)
-+        start = qutip.basis(dimension, 2)
-+        times = _3ls_times
-+        project_0_1 = qutip.projection(dimension, 0, 1)
-+        project_1_2 = qutip.projection(dimension, 1, 2)
-+        population_1 = qutip.projection(dimension, 1, 1)
-+        # Define the pi pulse to be when 99% of the population is transferred.
-+        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
-+        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
-+                                      args=_3ls_args)
-+        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
-+        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
-+                                            project_0_1.dag(), project_0_1,
-+                                            args=_3ls_args)
-+        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
-+                                             project_0_1.dag(), project_0_1,
-+                                             args=_3ls_args, reverse=True)
-+        times2 = np.concatenate([times, times[1:] + times[-1]])
-+        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
-+                                 e_ops=[population_1]).expect[0]
-+        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
-+        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
-+        assert abs(g2_ab_0 - 0.185) < 1e-2
-+
-+
-+def _step(t):
-+    return np.arctan(t)/np.pi + 0.5
-+
-+
-+def test_hamiltonian_order_unimportant():
-+    # Testing for regression on issue 1048.
-+    sp = qutip.sigmap()
-+    H = [[qutip.sigmax(), lambda t: _step(t-2)],
-+         [qutip.qeye(2), lambda t: _step(-(t-2))]]
-+    start = qutip.basis(2, 0)
-+    times = np.linspace(0, 5, 6)
-+    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
-+                                        sp.dag(), sp)
-+    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
-+                                         sp.dag(), sp)
-+    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
-+
-+
-+@pytest.mark.parametrize(['solver', 'state'], [
-+    pytest.param('me', _equivalence_fock, id="me-ket"),
-+    pytest.param('me', _equivalence_coherent, id="me-dm"),
-+    pytest.param('me', None, id="me-steady"),
-+    pytest.param('es', _equivalence_fock, id="es-ket"),
-+    pytest.param('es', _equivalence_coherent, id="es-dm"),
-+    pytest.param('es', None, id="es-steady"),
-+])
-+@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
-+                         ids=["hermitian", "nonhermitian"])
-+@pytest.mark.parametrize("w", [1, 2])
-+@pytest.mark.parametrize("gamma", [1, 10])
-+def test_correlation_2op_1t_known_cases(solver,
-+                                        state,
-+                                        is_e_op_hermitian,
-+                                        w,
-+                                        gamma,
-+                                       ):
-+    """This test compares the output correlation_2op_1 solution to an analytical
-+    solution."""
-+
-+    a = qutip.destroy(_equivalence_dimension)
-+    x = (a + a.dag())/np.sqrt(2)
-+
-+    H = w * a.dag() * a
-+
-+    a_op = x if is_e_op_hermitian else a
-+    b_op = x if is_e_op_hermitian else a.dag()
-+    c_ops = [np.sqrt(gamma) * a]
-+
-+    times = np.linspace(0, 1, 30)
-+
-+    # Handle the case state==None when computing expt values
-+    rho0 = state if state else qutip.steadystate(H, c_ops)
-+    if is_e_op_hermitian:
-+        # Analitycal solution for x,x as operators.
-+        base = 0
-+        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
-+        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
-+        base /= np.sqrt(2)
-+    else:
-+        # Analitycal solution for a,adag as operators.
-+        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
-+
-+    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
-+
-+    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
-+
-+
-+def test_correlation_timedependant_op():
-+    num = qutip.num(2)
-+    a = qutip.destroy(2)
-+    sx = qutip.sigmax()
-+    sz = qutip.sigmaz()
-+    times = np.arange(4)
-+    # switch between sx and sz at t=1.5
-+    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
-+
-+    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
-+    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
-+    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
-+    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
-+    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
-+
-+
-+def test_alternative_solver():
-+    from qutip.solver.mesolve import MESolver
-+    from qutip.solver.brmesolve import BRSolver
-+
-+    H = qutip.num(5)
-+    a = qutip.destroy(5)
-+    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
-+
-+    br = BRSolver(H, a_ops)
-+    me = MESolver(H, [a])
-+    times = np.arange(4)
-+
-+    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
-+    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
-+
-+    np.testing.assert_allclose(br_corr, me_corr)
-+
-+
-+def test_G1():
-+    H = qutip.Qobj([[0,1], [1,0]])
-+    psi0 = qutip.basis(2)
-+    taus = np.linspace(0, 1, 11)
-+    scale = 2
-+    a_op = qutip.sigmaz() * scale
-+    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
-+    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
-+    np.testing.assert_allclose(g1, expected, rtol=2e-5)
-+    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
-+
-+
-+def test_G2():
-+    N = 10
-+    H = qutip.rand_dm(N)
-+    psi0 = qutip.rand_ket(N)
-+    taus = np.linspace(0, 1, 11)
-+    scale = 2
-+    a_op = qutip.rand_unitary(N) * scale
-+    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
-+    expected = np.ones(11)
-+    np.testing.assert_allclose(g1, expected, rtol=2e-5)
-+    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
-diff --git a/qutip/tests/solver/test_countstat.py b/qutip/tests/solver/test_countstat.py
-index 6d389b20..130afec6 100644
---- a/qutip/tests/solver/test_countstat.py
-+++ b/qutip/tests/solver/test_countstat.py
-@@ -1,90 +1,90 @@
--import numpy as np
--import qutip
--import pytest
--
--
--@pytest.mark.filterwarnings("ignore::FutureWarning")
--def test_dqd_current():
--    "Counting statistics: current and current noise in a DQD model"
--
--    G = 0
--    L = 1
--    R = 2
--
--    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
--    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
--    sR = qutip.projection(3, G, R)
--    sL = qutip.projection(3, G, L)
--
--    w0 = 1
--    tc = 0.6 * w0
--    GammaR = 0.0075 * w0
--    GammaL = 0.0075 * w0
--    nth = 0.00
--    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
--
--    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
--
--    c_ops = [
--        np.sqrt(GammaR * (1 + nth)) * sR,
--        np.sqrt(GammaR * (nth)) * sR.dag(),
--        np.sqrt(GammaL * (nth)) * sL,
--        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
--    ]
--
--    current = np.zeros(len(eps_vec))
--    noise = np.zeros(len(eps_vec))
--
--    for n, eps in enumerate(eps_vec):
--        H = eps / 2 * sz + tc * sx
--        L0 = qutip.liouvillian(H)
--        L = qutip.liouvillian(H, c_ops)
--        rhoss = qutip.steadystate(L)
--        current_1, noise_1 = qutip.countstat_current_noise(
--            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
--        )
--        current[n] = current_1[0]
--        noise[n] = noise_1[0, 0, 0]
--
--        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
--        assert abs(current_1[0] - current_2[0]) < 1e-8
--
--        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
--        assert abs(current_1[0] - current_2[0]) < 1e-8
--
--        current_2 = qutip.countstat_current(H, c_ops)
--        assert abs(current_1[0] - current_2[0]) < 1e-8
--
--        current_3, noise_3 = qutip.countstat_current_noise(
--            L, c_ops, wlist=[0, 1], sparse=False
--        )
--        assert abs(current_1[0] - current_3[0]) < 1e-6
--        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
--                                   atol=1e-6)
--
--    current_target = (
--        tc**2
--        * GammaR
--        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
--    )
--    noise_target = current_target * (
--        1
--        - (
--            8
--            * GammaL
--            * tc**2
--            * (
--                4 * eps_vec**2 * (GammaR - GammaL)
--                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
--            )
--            / (
--                4 * tc**2 * (2 * GammaL + GammaR)
--                + GammaL * GammaR**2
--                + 4 * eps_vec**2 * GammaL
--            )
--            ** 2
--        )
--    )
--
--    np.testing.assert_allclose(current, current_target, atol=1e-4)
--    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
-+import numpy as np
-+import qutip
-+import pytest
-+
-+
-+@pytest.mark.filterwarnings("ignore::FutureWarning")
-+def test_dqd_current():
-+    "Counting statistics: current and current noise in a DQD model"
-+
-+    G = 0
-+    L = 1
-+    R = 2
-+
-+    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
-+    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
-+    sR = qutip.projection(3, G, R)
-+    sL = qutip.projection(3, G, L)
-+
-+    w0 = 1
-+    tc = 0.6 * w0
-+    GammaR = 0.0075 * w0
-+    GammaL = 0.0075 * w0
-+    nth = 0.00
-+    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
-+
-+    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
-+
-+    c_ops = [
-+        np.sqrt(GammaR * (1 + nth)) * sR,
-+        np.sqrt(GammaR * (nth)) * sR.dag(),
-+        np.sqrt(GammaL * (nth)) * sL,
-+        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
-+    ]
-+
-+    current = np.zeros(len(eps_vec))
-+    noise = np.zeros(len(eps_vec))
-+
-+    for n, eps in enumerate(eps_vec):
-+        H = eps / 2 * sz + tc * sx
-+        L0 = qutip.liouvillian(H)
-+        L = qutip.liouvillian(H, c_ops)
-+        rhoss = qutip.steadystate(L)
-+        current_1, noise_1 = qutip.countstat_current_noise(
-+            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
-+        )
-+        current[n] = current_1[0]
-+        noise[n] = noise_1[0, 0, 0]
-+
-+        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
-+        assert abs(current_1[0] - current_2[0]) < 1e-8
-+
-+        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
-+        assert abs(current_1[0] - current_2[0]) < 1e-8
-+
-+        current_2 = qutip.countstat_current(H, c_ops)
-+        assert abs(current_1[0] - current_2[0]) < 1e-8
-+
-+        current_3, noise_3 = qutip.countstat_current_noise(
-+            L, c_ops, wlist=[0, 1], sparse=False
-+        )
-+        assert abs(current_1[0] - current_3[0]) < 1e-6
-+        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
-+                                   atol=1e-6)
-+
-+    current_target = (
-+        tc**2
-+        * GammaR
-+        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
-+    )
-+    noise_target = current_target * (
-+        1
-+        - (
-+            8
-+            * GammaL
-+            * tc**2
-+            * (
-+                4 * eps_vec**2 * (GammaR - GammaL)
-+                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
-+            )
-+            / (
-+                4 * tc**2 * (2 * GammaL + GammaR)
-+                + GammaL * GammaR**2
-+                + 4 * eps_vec**2 * GammaL
-+            )
-+            ** 2
-+        )
-+    )
-+
-+    np.testing.assert_allclose(current, current_target, atol=1e-4)
-+    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
-diff --git a/qutip/tests/solver/test_floquet.py b/qutip/tests/solver/test_floquet.py
-index be90e6fa..723bf684 100644
---- a/qutip/tests/solver/test_floquet.py
-+++ b/qutip/tests/solver/test_floquet.py
-@@ -1,333 +1,333 @@
--import numpy as np
--from qutip import (
--    sigmax, sigmay, sigmaz,  sigmap, sigmam,
--    rand_ket, num, destroy,
--    mesolve, expect, sesolve,
--    Qobj, QobjEvo, coefficient
-- )
--
--from qutip.solver.floquet import (
--    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
--    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
--)
--import pytest
--
--
--def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
--    """
--    Convert e_ops for fmmesolve to mesolve
--    """
--    c_op_mesolve = []
--    N = len(vp)
--    for i in range(N):
--        for j in range(N):
--            if i != j:
--                # caclculate the rate
--                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
--                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
--                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
--
--                # add c_op for mesolve
--                c_op_mesolve.append(
--                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
--                )
--    return c_op_mesolve
--
--
--class TestFloquet:
--    """
--    A test class for the QuTiP functions for Floquet formalism.
--    """
--
--    def testFloquetBasis(self):
--        N = 10
--        a = destroy(N)
--        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
--        T = 2 * np.pi
--        floquet_basis = FloquetBasis(H, T)
--        psi0 = rand_ket(N)
--        tlist = np.linspace(0, 10, 11)
--        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
--        states = sesolve(H, psi0, tlist).states
--        for t, state in zip(tlist, states):
--            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
--            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
--
--    def testFloquetUnitary(self):
--        N = 10
--        a = destroy(N)
--        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
--        T = 2 * np.pi
--        psi0 = rand_ket(N)
--        tlist = np.linspace(0, 10, 11)
--        states_se = sesolve(H, psi0, tlist).states
--        states_fse = fsesolve(H, psi0, tlist, T=T).states
--        for state_se, state_fse in zip(states_se, states_fse):
--            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
--
--
--    def testFloquetMasterEquation1(self):
--        """
--        Test Floquet-Markov Master Equation for a driven two-level system
--        without dissipation.
--        """
--        delta = 1.0 * 2 * np.pi
--        eps0 = 1.0 * 2 * np.pi
--        A = 0.5 * 2 * np.pi
--        omega = np.sqrt(delta ** 2 + eps0 ** 2)
--        T = (2 * np.pi) / omega
--        tlist = np.linspace(0.0, 2 * T, 101)
--        psi0 = rand_ket(2)
--        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
--        H1 = A / 2.0 * sigmax()
--        args = {'w': omega}
--        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
--        e_ops = [num(2)]
--        gamma1 = 0
--
--        # Collapse operator for Floquet-Markov Master Equation
--        c_op_fmmesolve = sigmax()
--
--        # Collapse operators for Lindblad Master Equation
--        def spectrum(omega):
--            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
--
--        ep, vp = H0.eigenstates()
--        op0 = vp[0]*vp[0].dag()
--        op1 = vp[1]*vp[1].dag()
--
--        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
--
--        # Solve the floquet-markov master equation
--        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
--                         [spectrum], T, args=args).expect[0]
--
--        # Compare with mesolve
--        p_ex_ref = mesolve(
--            H, psi0, tlist, c_op_mesolve, [num(2)], args
--        ).expect[0]
--
--        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
--
--    def testFloquetMasterEquation2(self):
--        """
--        Test Floquet-Markov Master Equation for a two-level system
--        subject to dissipation.
--        """
--        delta = 1.0 * 2 * np.pi
--        eps0 = 1.0 * 2 * np.pi
--        A = 0.0 * 2 * np.pi
--        omega = np.sqrt(delta ** 2 + eps0 ** 2)
--        T = (2 * np.pi) / omega
--        tlist = np.linspace(0.0, 2 * T, 101)
--        psi0 = rand_ket(2)
--        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
--        H1 = A / 2.0 * sigmax()
--        args = {'w': omega}
--        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
--                    args=args)
--        e_ops = [num(2)]
--        gamma1 = 1
--
--        # Collapse operator for Floquet-Markov Master Equation
--        c_op_fmmesolve = sigmax()
--
--        # Collapse operator for Lindblad Master Equation
--        def spectrum(omega):
--            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
--
--        ep, vp = H0.eigenstates()
--        op0 = vp[0]*vp[0].dag()
--        op1 = vp[1]*vp[1].dag()
--
--        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
--
--        # Solve the floquet-markov master equation
--        p_ex = fmmesolve(
--            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
--            [spectrum], T, args=args
--        ).expect[0]
--
--        # Compare with mesolve
--        p_ex_ref = mesolve(
--            H, psi0, tlist, c_op_mesolve, [num(2)], args
--        ).expect[0]
--
--        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
--
--    @pytest.mark.parametrize("kmax", [5, 25, 100])
--    def testFloquetMasterEquation3(self, kmax):
--        """
--        Test Floquet-Markov Master Equation for a two-level system
--        subject to dissipation with internal transform of fmmesolve
--        """
--        delta = 1.0 * 2 * np.pi
--        eps0 = 1.0 * 2 * np.pi
--        A = 0.0 * 2 * np.pi
--        omega = np.sqrt(delta ** 2 + eps0 ** 2)
--        T = (2 * np.pi) / omega
--        tlist = np.linspace(0.0, 2 * T, 101)
--        psi0 = rand_ket(2)
--        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
--        H1 = A / 2.0 * sigmax()
--        args = {'w': omega}
--        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
--                    args=args)
--        e_ops = [num(2)]
--        gamma1 = 1
--
--        # Collapse operator for Floquet-Markov Master Equation
--        c_op_fmmesolve = sigmax()
--
--        # Collapse operator for Lindblad Master Equation
--        def spectrum(omega):
--            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
--
--        ep, vp = H0.eigenstates()
--        op0 = vp[0]*vp[0].dag()
--        op1 = vp[1]*vp[1].dag()
--
--        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
--
--        # Solve the floquet-markov master equation
--        floquet_basis = FloquetBasis(H, T)
--        solver = FMESolver(
--            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
--        )
--        solver.start(psi0, tlist[0])
--        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
--
--        # Compare with mesolve
--        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
--        p_ex_ref = output2.expect[0]
--
--        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
--                                   atol=5 * 1e-4)
--
--    def testFloquetMasterEquation_multiple_coupling(self):
--        """
--        Test Floquet-Markov Master Equation for a two-level system
--        subject to dissipation with multiple coupling operators
--        """
--        delta = 1.0 * 2 * np.pi
--        eps0 = 1.0 * 2 * np.pi
--        A = 0.0 * 2 * np.pi
--        omega = np.sqrt(delta ** 2 + eps0 ** 2)
--        T = (2 * np.pi) / omega
--        tlist = np.linspace(0.0, 2 * T, 101)
--        psi0 = rand_ket(2)
--        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
--        H1 = A / 2.0 * sigmax()
--        args = {'w': omega}
--        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
--                    args=args)
--        e_ops = [num(2)]
--        gamma1 = 1
--
--        # Collapse operator for Floquet-Markov Master Equation
--        c_ops_fmmesolve = [sigmax(), sigmay()]
--
--        # Collapse operator for Lindblad Master Equation
--        def noise_spectrum1(omega):
--            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
--
--        def noise_spectrum2(omega):
--            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
--
--        noise_spectra = [noise_spectrum1, noise_spectrum2]
--
--        ep, vp = H0.eigenstates()
--        op0 = vp[0]*vp[0].dag()
--        op1 = vp[1]*vp[1].dag()
--
--        c_op_mesolve = []
--
--        # Convert the c_ops for fmmesolve to c_ops for mesolve
--        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
--                                                   noise_spectra):
--            c_op_mesolve += _convert_c_ops(
--                c_op_fmmesolve, noise_spectrum, vp, ep
--            )
--
--        # Solve the floquet-markov master equation
--        output1 = fmmesolve(
--            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
--        )
--        p_ex = output1.expect[0]
--        # Compare with mesolve
--        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
--        p_ex_ref = output2.expect[0]
--
--        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
--
--    def testFloquetRates(self):
--        """
--        Compare rate transition and frequency transitions to analytical
--        results for a driven two-level system, for different drive amplitudes.
--        """
--        # Parameters
--        wq = 5.4 * 2 * np.pi
--        wd = 6.7 * 2 * np.pi
--        delta = wq - wd
--        T = 2 * np.pi / wd
--        tlist = np.linspace(0.0, 2 * T, 101)
--        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
--        H0 = Qobj(wq / 2 * sigmaz())
--        args = {'wd': wd}
--        c_ops = sigmax()
--        gamma1 = 1
--        kmax = 5
--
--        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
--        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
--        array_ana_delta = [
--            2 * np.sqrt((delta / 2)**2 + a**2)
--            for a in array_A
--        ]
--
--        def noise_spectrum(omega):
--            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
--
--        idx = 0
--        for a in array_A:
--            # Hamiltonian
--            H1_p = a * sigmap()
--            H1_m = a * sigmam()
--            H = QobjEvo(
--                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
--                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
--            )
--
--            floquet_basis = FloquetBasis(H, T)
--            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
--            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
--
--            # Check energies
--            deltas = np.ndarray.flatten(DeltaMatrix)
--
--            # deltas and array_ana_delta have at least 1 value in common.
--            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
--
--            # Check matrix elements
--            Xs = np.concatenate(
--                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
--            ).flatten()
--
--            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
--            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
--
--            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
--            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
--            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
--            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
--            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
--            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
--            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
--            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
--            Xpm_p1 = (a / (normMinus * normPlus)
--                      * (array_ana_E0[idx]- delta / 2))
--            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
--            Xpm_m1 = (a / (normMinus * normPlus)
--                      * (array_ana_E1[idx] - delta / 2))
--            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
--            idx += 1
-+import numpy as np
-+from qutip import (
-+    sigmax, sigmay, sigmaz,  sigmap, sigmam,
-+    rand_ket, num, destroy,
-+    mesolve, expect, sesolve,
-+    Qobj, QobjEvo, coefficient
-+ )
-+
-+from qutip.solver.floquet import (
-+    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
-+    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
-+)
-+import pytest
-+
-+
-+def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
-+    """
-+    Convert e_ops for fmmesolve to mesolve
-+    """
-+    c_op_mesolve = []
-+    N = len(vp)
-+    for i in range(N):
-+        for j in range(N):
-+            if i != j:
-+                # caclculate the rate
-+                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
-+                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
-+                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
-+
-+                # add c_op for mesolve
-+                c_op_mesolve.append(
-+                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
-+                )
-+    return c_op_mesolve
-+
-+
-+class TestFloquet:
-+    """
-+    A test class for the QuTiP functions for Floquet formalism.
-+    """
-+
-+    def testFloquetBasis(self):
-+        N = 10
-+        a = destroy(N)
-+        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
-+        T = 2 * np.pi
-+        floquet_basis = FloquetBasis(H, T)
-+        psi0 = rand_ket(N)
-+        tlist = np.linspace(0, 10, 11)
-+        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
-+        states = sesolve(H, psi0, tlist).states
-+        for t, state in zip(tlist, states):
-+            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
-+            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
-+
-+    def testFloquetUnitary(self):
-+        N = 10
-+        a = destroy(N)
-+        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
-+        T = 2 * np.pi
-+        psi0 = rand_ket(N)
-+        tlist = np.linspace(0, 10, 11)
-+        states_se = sesolve(H, psi0, tlist).states
-+        states_fse = fsesolve(H, psi0, tlist, T=T).states
-+        for state_se, state_fse in zip(states_se, states_fse):
-+            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
-+
-+
-+    def testFloquetMasterEquation1(self):
-+        """
-+        Test Floquet-Markov Master Equation for a driven two-level system
-+        without dissipation.
-+        """
-+        delta = 1.0 * 2 * np.pi
-+        eps0 = 1.0 * 2 * np.pi
-+        A = 0.5 * 2 * np.pi
-+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-+        T = (2 * np.pi) / omega
-+        tlist = np.linspace(0.0, 2 * T, 101)
-+        psi0 = rand_ket(2)
-+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-+        H1 = A / 2.0 * sigmax()
-+        args = {'w': omega}
-+        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
-+        e_ops = [num(2)]
-+        gamma1 = 0
-+
-+        # Collapse operator for Floquet-Markov Master Equation
-+        c_op_fmmesolve = sigmax()
-+
-+        # Collapse operators for Lindblad Master Equation
-+        def spectrum(omega):
-+            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
-+
-+        ep, vp = H0.eigenstates()
-+        op0 = vp[0]*vp[0].dag()
-+        op1 = vp[1]*vp[1].dag()
-+
-+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-+
-+        # Solve the floquet-markov master equation
-+        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
-+                         [spectrum], T, args=args).expect[0]
-+
-+        # Compare with mesolve
-+        p_ex_ref = mesolve(
-+            H, psi0, tlist, c_op_mesolve, [num(2)], args
-+        ).expect[0]
-+
-+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-+
-+    def testFloquetMasterEquation2(self):
-+        """
-+        Test Floquet-Markov Master Equation for a two-level system
-+        subject to dissipation.
-+        """
-+        delta = 1.0 * 2 * np.pi
-+        eps0 = 1.0 * 2 * np.pi
-+        A = 0.0 * 2 * np.pi
-+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-+        T = (2 * np.pi) / omega
-+        tlist = np.linspace(0.0, 2 * T, 101)
-+        psi0 = rand_ket(2)
-+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-+        H1 = A / 2.0 * sigmax()
-+        args = {'w': omega}
-+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-+                    args=args)
-+        e_ops = [num(2)]
-+        gamma1 = 1
-+
-+        # Collapse operator for Floquet-Markov Master Equation
-+        c_op_fmmesolve = sigmax()
-+
-+        # Collapse operator for Lindblad Master Equation
-+        def spectrum(omega):
-+            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
-+
-+        ep, vp = H0.eigenstates()
-+        op0 = vp[0]*vp[0].dag()
-+        op1 = vp[1]*vp[1].dag()
-+
-+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-+
-+        # Solve the floquet-markov master equation
-+        p_ex = fmmesolve(
-+            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
-+            [spectrum], T, args=args
-+        ).expect[0]
-+
-+        # Compare with mesolve
-+        p_ex_ref = mesolve(
-+            H, psi0, tlist, c_op_mesolve, [num(2)], args
-+        ).expect[0]
-+
-+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-+
-+    @pytest.mark.parametrize("kmax", [5, 25, 100])
-+    def testFloquetMasterEquation3(self, kmax):
-+        """
-+        Test Floquet-Markov Master Equation for a two-level system
-+        subject to dissipation with internal transform of fmmesolve
-+        """
-+        delta = 1.0 * 2 * np.pi
-+        eps0 = 1.0 * 2 * np.pi
-+        A = 0.0 * 2 * np.pi
-+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-+        T = (2 * np.pi) / omega
-+        tlist = np.linspace(0.0, 2 * T, 101)
-+        psi0 = rand_ket(2)
-+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-+        H1 = A / 2.0 * sigmax()
-+        args = {'w': omega}
-+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-+                    args=args)
-+        e_ops = [num(2)]
-+        gamma1 = 1
-+
-+        # Collapse operator for Floquet-Markov Master Equation
-+        c_op_fmmesolve = sigmax()
-+
-+        # Collapse operator for Lindblad Master Equation
-+        def spectrum(omega):
-+            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
-+
-+        ep, vp = H0.eigenstates()
-+        op0 = vp[0]*vp[0].dag()
-+        op1 = vp[1]*vp[1].dag()
-+
-+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-+
-+        # Solve the floquet-markov master equation
-+        floquet_basis = FloquetBasis(H, T)
-+        solver = FMESolver(
-+            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
-+        )
-+        solver.start(psi0, tlist[0])
-+        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
-+
-+        # Compare with mesolve
-+        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
-+        p_ex_ref = output2.expect[0]
-+
-+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
-+                                   atol=5 * 1e-4)
-+
-+    def testFloquetMasterEquation_multiple_coupling(self):
-+        """
-+        Test Floquet-Markov Master Equation for a two-level system
-+        subject to dissipation with multiple coupling operators
-+        """
-+        delta = 1.0 * 2 * np.pi
-+        eps0 = 1.0 * 2 * np.pi
-+        A = 0.0 * 2 * np.pi
-+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-+        T = (2 * np.pi) / omega
-+        tlist = np.linspace(0.0, 2 * T, 101)
-+        psi0 = rand_ket(2)
-+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-+        H1 = A / 2.0 * sigmax()
-+        args = {'w': omega}
-+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-+                    args=args)
-+        e_ops = [num(2)]
-+        gamma1 = 1
-+
-+        # Collapse operator for Floquet-Markov Master Equation
-+        c_ops_fmmesolve = [sigmax(), sigmay()]
-+
-+        # Collapse operator for Lindblad Master Equation
-+        def noise_spectrum1(omega):
-+            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
-+
-+        def noise_spectrum2(omega):
-+            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
-+
-+        noise_spectra = [noise_spectrum1, noise_spectrum2]
-+
-+        ep, vp = H0.eigenstates()
-+        op0 = vp[0]*vp[0].dag()
-+        op1 = vp[1]*vp[1].dag()
-+
-+        c_op_mesolve = []
-+
-+        # Convert the c_ops for fmmesolve to c_ops for mesolve
-+        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
-+                                                   noise_spectra):
-+            c_op_mesolve += _convert_c_ops(
-+                c_op_fmmesolve, noise_spectrum, vp, ep
-+            )
-+
-+        # Solve the floquet-markov master equation
-+        output1 = fmmesolve(
-+            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
-+        )
-+        p_ex = output1.expect[0]
-+        # Compare with mesolve
-+        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
-+        p_ex_ref = output2.expect[0]
-+
-+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-+
-+    def testFloquetRates(self):
-+        """
-+        Compare rate transition and frequency transitions to analytical
-+        results for a driven two-level system, for different drive amplitudes.
-+        """
-+        # Parameters
-+        wq = 5.4 * 2 * np.pi
-+        wd = 6.7 * 2 * np.pi
-+        delta = wq - wd
-+        T = 2 * np.pi / wd
-+        tlist = np.linspace(0.0, 2 * T, 101)
-+        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
-+        H0 = Qobj(wq / 2 * sigmaz())
-+        args = {'wd': wd}
-+        c_ops = sigmax()
-+        gamma1 = 1
-+        kmax = 5
-+
-+        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
-+        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
-+        array_ana_delta = [
-+            2 * np.sqrt((delta / 2)**2 + a**2)
-+            for a in array_A
-+        ]
-+
-+        def noise_spectrum(omega):
-+            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
-+
-+        idx = 0
-+        for a in array_A:
-+            # Hamiltonian
-+            H1_p = a * sigmap()
-+            H1_m = a * sigmam()
-+            H = QobjEvo(
-+                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
-+                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
-+            )
-+
-+            floquet_basis = FloquetBasis(H, T)
-+            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
-+            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
-+
-+            # Check energies
-+            deltas = np.ndarray.flatten(DeltaMatrix)
-+
-+            # deltas and array_ana_delta have at least 1 value in common.
-+            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
-+
-+            # Check matrix elements
-+            Xs = np.concatenate(
-+                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
-+            ).flatten()
-+
-+            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
-+            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
-+
-+            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
-+            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
-+            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
-+            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
-+            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
-+            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
-+            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
-+            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
-+            Xpm_p1 = (a / (normMinus * normPlus)
-+                      * (array_ana_E0[idx]- delta / 2))
-+            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
-+            Xpm_m1 = (a / (normMinus * normPlus)
-+                      * (array_ana_E1[idx] - delta / 2))
-+            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
-+            idx += 1
-diff --git a/qutip/tests/solver/test_integrator.py b/qutip/tests/solver/test_integrator.py
-index 8779ea76..5c46c8f3 100644
---- a/qutip/tests/solver/test_integrator.py
-+++ b/qutip/tests/solver/test_integrator.py
-@@ -1,164 +1,164 @@
--from qutip.solver.sesolve import SESolver
--from qutip.solver.mesolve import MESolver
--from qutip.solver.mcsolve import MCSolver
--from qutip.solver.solver_base import Solver
--from qutip.solver.integrator import *
--import qutip
--import numpy as np
--from numpy.testing import assert_allclose
--import pytest
--
--
--class TestIntegratorCte():
--    _analytical_se = lambda _, t: np.cos(t * np.pi)
--    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
--    _analytical_me = lambda _, t: 1 - np.exp(-t)
--    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
--                                  c_ops=[qutip.destroy(2)])
--
--    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
--    def se_method(self, request):
--        return request.param
--
--    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
--    def me_method(self, request):
--        return request.param
--
--    # TODO: Change when the MCSolver is added
--    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
--    def mc_method(self, request):
--        return request.param
--
--    def test_se_integration(self, se_method):
--        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
--        state0 = qutip.basis(2, 0).data
--        evol.set_state(0, state0)
--        for t, state in evol.run(np.linspace(0, 2, 21)):
--            assert_allclose(self._analytical_se(t),
--                            state.to_array()[0, 0], atol=2e-5)
--            assert state.shape == (2, 1)
--
--    def test_me_integration(self, me_method):
--        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
--        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
--        evol.set_state(0, state0)
--        for t in np.linspace(0, 2, 21):
--            t_, state = evol.integrate(t)
--            assert t_ == t
--            assert_allclose(self._analytical_me(t),
--                            state.to_array()[0, 0], atol=2e-5)
--
--    def test_mc_integration(self, mc_method):
--        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
--        state = qutip.basis(2,0).data
--        evol.set_state(0, state)
--        t = 0
--        for i in range(1, 21):
--            t_target = i * 0.05
--            while t < t_target:
--                t_old, y_old = evol.get_state()
--                t, state = evol.mcstep(t_target)
--                assert t <= t_target
--                assert t > t_old
--                assert_allclose(self._analytical_se(t),
--                                state.to_array()[0, 0], atol=2e-5)
--                t_back = (t + t_old) / 2
--                t_got, bstate = evol.mcstep(t_back)
--                assert t_back == t_got
--                assert_allclose(self._analytical_se(t),
--                                state.to_array()[0, 0], atol=2e-5)
--                t, state = evol.mcstep(t)
--
--
--    @pytest.mark.parametrize('start', [1, -1])
--    def test_mc_integration_mixed(self, start, mc_method):
--        system = qutip.QobjEvo(qutip.qeye(1))
--        evol = Solver.avail_integrators()[mc_method](system, {})
--
--        state = qutip.basis(1,0).data
--        evol.set_state(start, state)
--        t = start
--        t_target = start + .1
--        while t < t_target:
--            t, _ = evol.mcstep(start + .1)
--        _ = evol.mcstep(start + .2)
--        t_target = (start + .1 + t) / 2
--        t, state = evol.mcstep(t_target)
--        assert (
--            state.to_array()[0, 0]
--            == pytest.approx(np.exp(t - start), abs=1e-5)
--        )
--
--
--class TestIntegrator(TestIntegratorCte):
--    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
--    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
--    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
--    me_system = qutip.liouvillian(
--        qutip.QobjEvo(qutip.qeye(2)),
--        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
--    )
--
--    @pytest.fixture(
--        params=[key for key, integrator in SESolver.avail_integrators().items()
--                if integrator.support_time_dependant]
--    )
--    def se_method(self, request):
--        return request.param
--
--    @pytest.fixture(
--        params=[key for key, integrator in MESolver.avail_integrators().items()
--                if integrator.support_time_dependant]
--    )
--    def me_method(self, request):
--        return request.param
--
--    @pytest.fixture(
--        params=[key for key, integrator in MCSolver.avail_integrators().items()
--                if integrator.support_time_dependant]
--    )
--    def mc_method(self, request):
--        return request.param
--
--
--@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
--                     ids=["large", "multiple subspaces", "diagonal"])
--def test_krylov(sizes):
--    # Krylov solve act differently for large systems composed tensored
--    # sub systems.
--    N, M = sizes
--    H = qutip.qeye(N)
--    if M:
--        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
--    H = qutip.QobjEvo(-1j * H)
--    integrator = IntegratorKrylov(H, {})
--    ref_integrator = IntegratorDiag(H, {})
--    psi = qutip.basis(100, 95).data
--    integrator.set_state(0, psi)
--    ref_integrator.set_state(0, psi)
--    for t in np.linspace(0.25, 1, 4):
--        out = integrator.integrate(t)[1]
--        ref = ref_integrator.integrate(t)[1]
--        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
--
--
--@pytest.mark.parametrize('integrator',
--    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
--    ids=["adams", 'bdf', "lsoda"]
--)
--def test_concurent_usage(integrator):
--    opt = {'atol':1e-10, 'rtol':1e-7}
--
--    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
--    inter1 = integrator(sys1, opt)
--    inter1.set_state(0, qutip.basis(1,0).data)
--
--    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
--    inter2 = integrator(sys2, opt)
--    inter2.set_state(0, qutip.basis(1,0).data)
--
--    for t in np.linspace(0,1,6):
--        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
--        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
--        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
--        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
-+from qutip.solver.sesolve import SESolver
-+from qutip.solver.mesolve import MESolver
-+from qutip.solver.mcsolve import MCSolver
-+from qutip.solver.solver_base import Solver
-+from qutip.solver.integrator import *
-+import qutip
-+import numpy as np
-+from numpy.testing import assert_allclose
-+import pytest
-+
-+
-+class TestIntegratorCte():
-+    _analytical_se = lambda _, t: np.cos(t * np.pi)
-+    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
-+    _analytical_me = lambda _, t: 1 - np.exp(-t)
-+    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
-+                                  c_ops=[qutip.destroy(2)])
-+
-+    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
-+    def se_method(self, request):
-+        return request.param
-+
-+    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
-+    def me_method(self, request):
-+        return request.param
-+
-+    # TODO: Change when the MCSolver is added
-+    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
-+    def mc_method(self, request):
-+        return request.param
-+
-+    def test_se_integration(self, se_method):
-+        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
-+        state0 = qutip.basis(2, 0).data
-+        evol.set_state(0, state0)
-+        for t, state in evol.run(np.linspace(0, 2, 21)):
-+            assert_allclose(self._analytical_se(t),
-+                            state.to_array()[0, 0], atol=2e-5)
-+            assert state.shape == (2, 1)
-+
-+    def test_me_integration(self, me_method):
-+        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
-+        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
-+        evol.set_state(0, state0)
-+        for t in np.linspace(0, 2, 21):
-+            t_, state = evol.integrate(t)
-+            assert t_ == t
-+            assert_allclose(self._analytical_me(t),
-+                            state.to_array()[0, 0], atol=2e-5)
-+
-+    def test_mc_integration(self, mc_method):
-+        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
-+        state = qutip.basis(2,0).data
-+        evol.set_state(0, state)
-+        t = 0
-+        for i in range(1, 21):
-+            t_target = i * 0.05
-+            while t < t_target:
-+                t_old, y_old = evol.get_state()
-+                t, state = evol.mcstep(t_target)
-+                assert t <= t_target
-+                assert t > t_old
-+                assert_allclose(self._analytical_se(t),
-+                                state.to_array()[0, 0], atol=2e-5)
-+                t_back = (t + t_old) / 2
-+                t_got, bstate = evol.mcstep(t_back)
-+                assert t_back == t_got
-+                assert_allclose(self._analytical_se(t),
-+                                state.to_array()[0, 0], atol=2e-5)
-+                t, state = evol.mcstep(t)
-+
-+
-+    @pytest.mark.parametrize('start', [1, -1])
-+    def test_mc_integration_mixed(self, start, mc_method):
-+        system = qutip.QobjEvo(qutip.qeye(1))
-+        evol = Solver.avail_integrators()[mc_method](system, {})
-+
-+        state = qutip.basis(1,0).data
-+        evol.set_state(start, state)
-+        t = start
-+        t_target = start + .1
-+        while t < t_target:
-+            t, _ = evol.mcstep(start + .1)
-+        _ = evol.mcstep(start + .2)
-+        t_target = (start + .1 + t) / 2
-+        t, state = evol.mcstep(t_target)
-+        assert (
-+            state.to_array()[0, 0]
-+            == pytest.approx(np.exp(t - start), abs=1e-5)
-+        )
-+
-+
-+class TestIntegrator(TestIntegratorCte):
-+    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
-+    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
-+    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
-+    me_system = qutip.liouvillian(
-+        qutip.QobjEvo(qutip.qeye(2)),
-+        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
-+    )
-+
-+    @pytest.fixture(
-+        params=[key for key, integrator in SESolver.avail_integrators().items()
-+                if integrator.support_time_dependant]
-+    )
-+    def se_method(self, request):
-+        return request.param
-+
-+    @pytest.fixture(
-+        params=[key for key, integrator in MESolver.avail_integrators().items()
-+                if integrator.support_time_dependant]
-+    )
-+    def me_method(self, request):
-+        return request.param
-+
-+    @pytest.fixture(
-+        params=[key for key, integrator in MCSolver.avail_integrators().items()
-+                if integrator.support_time_dependant]
-+    )
-+    def mc_method(self, request):
-+        return request.param
-+
-+
-+@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
-+                     ids=["large", "multiple subspaces", "diagonal"])
-+def test_krylov(sizes):
-+    # Krylov solve act differently for large systems composed tensored
-+    # sub systems.
-+    N, M = sizes
-+    H = qutip.qeye(N)
-+    if M:
-+        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
-+    H = qutip.QobjEvo(-1j * H)
-+    integrator = IntegratorKrylov(H, {})
-+    ref_integrator = IntegratorDiag(H, {})
-+    psi = qutip.basis(100, 95).data
-+    integrator.set_state(0, psi)
-+    ref_integrator.set_state(0, psi)
-+    for t in np.linspace(0.25, 1, 4):
-+        out = integrator.integrate(t)[1]
-+        ref = ref_integrator.integrate(t)[1]
-+        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
-+
-+
-+@pytest.mark.parametrize('integrator',
-+    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
-+    ids=["adams", 'bdf', "lsoda"]
-+)
-+def test_concurent_usage(integrator):
-+    opt = {'atol':1e-10, 'rtol':1e-7}
-+
-+    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
-+    inter1 = integrator(sys1, opt)
-+    inter1.set_state(0, qutip.basis(1,0).data)
-+
-+    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
-+    inter2 = integrator(sys2, opt)
-+    inter2.set_state(0, qutip.basis(1,0).data)
-+
-+    for t in np.linspace(0,1,6):
-+        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
-+        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
-+        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
-+        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
-diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
-index be5b5b3b..840f7337 100644
---- a/qutip/tests/solver/test_mcsolve.py
-+++ b/qutip/tests/solver/test_mcsolve.py
-@@ -1,439 +1,439 @@
--import pytest
--import numpy as np
--import qutip
--from copy import copy
--from qutip.solver.mcsolve import mcsolve, MCSolver
--from qutip.solver.solver_base import Solver
--
--def _return_constant(t, args):
--    return args['constant']
--
--
--def _return_decay(t, args):
--    return args['constant'] * np.exp(-args['rate'] * t)
--
--
--class callable_qobj:
--    def __init__(self, oper, coeff=None):
--        self.oper = oper
--        self.coeff = coeff
--
--    def __call__(self, t, args):
--        if self.coeff is not None:
--            return self.oper * self.coeff(t, args)
--        return self.oper
--
--
--@pytest.mark.usefixtures("in_temporary_directory")
--class StatesAndExpectOutputCase:
--    """
--    Mixin class to test the states and expectation values from ``mcsolve``.
--    """
--    size = 10
--    h = qutip.num(size)
--    state = qutip.basis(size, size-1)
--    times = np.linspace(0, 1, 101)
--    e_ops = [qutip.num(size)]
--    ntraj = 2000
--
--    def _assert_states(self, result, expected, tol):
--        assert hasattr(result, 'states')
--        assert len(result.states) == len(self.times)
--        assert len(self.e_ops) == len(expected)
--        for test_operator, expected_part in zip(self.e_ops, expected):
--            test = qutip.expect(test_operator, result.states)
--            np.testing.assert_allclose(test, expected_part, rtol=tol)
--
--    def _assert_expect(self, result, expected, tol):
--        assert hasattr(result, 'expect')
--        assert len(result.expect) == len(self.e_ops)
--        assert len(self.e_ops) == len(expected)
--        for test, expected_part in zip(result.expect, expected):
--            np.testing.assert_allclose(test, expected_part, rtol=tol)
--
--    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
--        options = {"store_states": True, "map": "serial"}
--        result = mcsolve(hamiltonian, self.state, self.times, args=args,
--                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
--                         options=options, target_tol=0.05)
--        self._assert_expect(result, expected, tol)
--        self._assert_states(result, expected, tol)
--
--
--class TestNoCollapse(StatesAndExpectOutputCase):
--    """
--    Test that `mcsolve` correctly solves the system when there is a constant
--    Hamiltonian and no collapses.
--    """
--    def pytest_generate_tests(self, metafunc):
--        tol = 1e-8
--        expect = (qutip.expect(self.e_ops[0], self.state)
--                  * np.ones_like(self.times))
--        hamiltonian_types = [
--            (self.h, "Qobj"),
--            ([self.h], "list"),
--            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
--                           args= {'constant': 0}), "QobjEvo"),
--            (callable_qobj(self.h), "callable"),
--        ]
--        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
--                 for hamiltonian, id in hamiltonian_types]
--        metafunc.parametrize(
--            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
--            cases)
--
--    # Previously the "states_only" and "expect_only" tests were mixed in to
--    # every other test case.  We move them out into the simplest set so that
--    # their behaviour remains tested, but isn't repeated as often to keep test
--    # runtimes shorter.  The known-good cases are still tested in the other
--    # test cases, this is just testing the single-output behaviour.
--
--    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
--        options = {"store_states": True, "map": "serial"}
--        result = mcsolve(hamiltonian, self.state, self.times, args=args,
--                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
--                         options=options)
--        self._assert_states(result, expected, tol)
--
--    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
--        result = mcsolve(hamiltonian, self.state, self.times, args=args,
--                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
--                         options={'map': 'serial'})
--        self._assert_expect(result, expected, tol)
--
--
--class TestConstantCollapse(StatesAndExpectOutputCase):
--    """
--    Test that `mcsolve` correctly solves the system when there is a constant
--    collapse operator.
--    """
--    def pytest_generate_tests(self, metafunc):
--        tol = 0.25
--        coupling = 0.2
--        expect = (qutip.expect(self.e_ops[0], self.state)
--                  * np.exp(-coupling * self.times))
--        collapse_op = qutip.destroy(self.size)
--        c_op_types = [
--            (np.sqrt(coupling)*collapse_op, {}, "constant"),
--            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
--            (callable_qobj(collapse_op, _return_constant),
--             {'constant': np.sqrt(coupling)}, "function"),
--        ]
--        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
--                 for c_op, args, id in c_op_types]
--        metafunc.parametrize(
--            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
--            cases)
--
--
--class TestTimeDependentCollapse(StatesAndExpectOutputCase):
--    """
--    Test that `mcsolve` correctly solves the system when the collapse operators
--    are time-dependent.
--    """
--    def pytest_generate_tests(self, metafunc):
--        tol = 0.25
--        coupling = 0.2
--        expect = (qutip.expect(self.e_ops[0], self.state)
--                  * np.exp(-coupling * (1 - np.exp(-self.times))))
--        collapse_op = qutip.destroy(self.size)
--        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
--        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
--        c_op_types = [
--            ([collapse_op, _return_decay], collapse_args, "function"),
--            ([collapse_op, collapse_string], {}, "string"),
--        ]
--        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
--                 for c_op, args, id in c_op_types]
--        metafunc.parametrize(
--            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
--            cases)
--
--
--def test_stored_collapse_operators_and_times():
--    """
--    Test that the output contains information on which collapses happened and
--    at what times, and make sure that this information makes sense.
--    """
--    size = 10
--    a = qutip.destroy(size)
--    H = qutip.num(size)
--    state = qutip.basis(size, size-1)
--    times = np.linspace(0, 10, 100)
--    c_ops = [a, a]
--    result = mcsolve(H, state, times, c_ops, ntraj=3,
--                     options={'map': 'serial'})
--    assert len(result.col_times[0]) > 0
--    assert len(result.col_which) == len(result.col_times)
--    assert all(col in [0, 1] for col in result.col_which[0])
--
--
--@pytest.mark.parametrize('keep_runs_results', [True, False])
--def test_states_outputs(keep_runs_results):
--    # We're just testing the output value, so it's important whether certain
--    # things are complex or real, but not what the magnitudes of constants are.
--    focks = 5
--    ntraj = 5
--    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
--    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
--    H = 1j*a.dag()*sm + a
--    H = H + H.dag()
--    state = qutip.basis([focks, 2], [0, 1])
--    times = np.linspace(0, 10, 21)
--    c_ops = [a, sm]
--    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
--                   options={"keep_runs_results": keep_runs_results,
--                            'map': 'serial'})
--
--    assert len(data.average_states) == len(times)
--    assert isinstance(data.average_states[0], qutip.Qobj)
--    assert data.average_states[0].norm() == pytest.approx(1.)
--    assert data.average_states[0].isoper
--
--    assert isinstance(data.average_final_state, qutip.Qobj)
--    assert data.average_final_state.norm() == pytest.approx(1.)
--    assert data.average_final_state.isoper
--
--    assert isinstance(data.photocurrent[0][1], float)
--    assert isinstance(data.photocurrent[1][1], float)
--    assert (np.array(data.runs_photocurrent).shape
--        == (ntraj, len(c_ops), len(times)-1))
--
--    if keep_runs_results:
--        assert len(data.runs_states) == ntraj
--        assert len(data.runs_states[0]) == len(times)
--        assert isinstance(data.runs_states[0][0], qutip.Qobj)
--        assert data.runs_states[0][0].norm() == pytest.approx(1.)
--        assert data.runs_states[0][0].isket
--
--        assert len(data.runs_final_states) == ntraj
--        assert isinstance(data.runs_final_states[0], qutip.Qobj)
--        assert data.runs_final_states[0].norm() == pytest.approx(1.)
--        assert data.runs_final_states[0].isket
--
--    assert isinstance(data.steady_state(), qutip.Qobj)
--    assert data.steady_state().norm() == pytest.approx(1.)
--    assert data.steady_state().isoper
--
--    np.testing.assert_allclose(times, data.times)
--    assert data.num_trajectories == ntraj
--    assert len(data.e_ops) == 0
--    assert data.stats["num_collapse"] == len(c_ops)
--    assert len(data.col_times) == ntraj
--    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
--    assert data.stats['end_condition'] == "ntraj reached"
--
--
--@pytest.mark.parametrize('keep_runs_results', [True, False])
--def test_expectation_outputs(keep_runs_results):
--    # We're just testing the output value, so it's important whether certain
--    # things are complex or real, but not what the magnitudes of constants are.
--    focks = 5
--    ntraj = 5
--    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
--    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
--    H = 1j*a.dag()*sm + a
--    H = H + H.dag()
--    state = qutip.basis([focks, 2], [0, 1])
--    times = np.linspace(0, 10, 5)
--    c_ops = [a, sm]
--    e_ops = [a.dag()*a, sm.dag()*sm, a]
--    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
--                   options={"keep_runs_results": keep_runs_results,
--                            'map': 'serial'})
--    assert isinstance(data.average_expect[0][1], float)
--    assert isinstance(data.average_expect[1][1], float)
--    assert isinstance(data.average_expect[2][1], complex)
--    assert isinstance(data.std_expect[0][1], float)
--    assert isinstance(data.std_expect[1][1], float)
--    assert isinstance(data.std_expect[2][1], float)
--    if keep_runs_results:
--        assert len(data.runs_expect) == len(e_ops)
--        assert len(data.runs_expect[0]) == ntraj
--        assert isinstance(data.runs_expect[0][0][1], float)
--        assert isinstance(data.runs_expect[1][0][1], float)
--        assert isinstance(data.runs_expect[2][0][1], complex)
--    assert isinstance(data.photocurrent[0][0], float)
--    assert isinstance(data.photocurrent[1][0], float)
--    assert (np.array(data.runs_photocurrent).shape
--            == (ntraj, len(c_ops), len(times)-1))
--    np.testing.assert_allclose(times, data.times)
--    assert data.num_trajectories == ntraj
--    assert len(data.e_ops) == len(e_ops)
--    assert data.stats["num_collapse"] == len(c_ops)
--    assert len(data.col_times) == ntraj
--    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
--    assert data.stats['end_condition'] == "ntraj reached"
--
--
--class TestSeeds:
--    sizes = [6, 6, 6]
--    dampings = [0.1, 0.4, 0.1]
--    ntraj = 25  # Big enough to ensure there are differences without being slow
--    a = [qutip.destroy(size) for size in sizes]
--    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
--              - qutip.tensor(a[0].dag(), a[1], a[2]))
--    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
--                         qutip.basis(sizes[1:], [0, 0]))
--    times = np.linspace(0, 10, 2)
--    c_ops = [
--        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
--        (np.sqrt(2*dampings[1])
--         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
--        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
--    ]
--
--    def test_seeds_can_be_reused(self):
--        args = (self.H, self.state, self.times)
--        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
--        first = mcsolve(*args, **kwargs)
--        second = mcsolve(*args, seeds=first.seeds, **kwargs)
--        for first_t, second_t in zip(first.col_times, second.col_times):
--            np.testing.assert_equal(first_t, second_t)
--        for first_w, second_w in zip(first.col_which, second.col_which):
--            np.testing.assert_equal(first_w, second_w)
--
--    def test_seeds_are_not_reused_by_default(self):
--        args = (self.H, self.state, self.times)
--        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
--        first = mcsolve(*args, **kwargs)
--        second = mcsolve(*args, **kwargs)
--        assert not all(np.array_equal(first_t, second_t)
--                       for first_t, second_t in zip(first.col_times,
--                                                    second.col_times))
--        assert not all(np.array_equal(first_w, second_w)
--                       for first_w, second_w in zip(first.col_which,
--                                                    second.col_which))
--
--    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
--    def test_seed_type(self, seed):
--        args = (self.H, self.state, self.times)
--        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
--        first = mcsolve(*args, seeds=copy(seed), **kwargs)
--        second = mcsolve(*args, seeds=copy(seed), **kwargs)
--        for f_seed, s_seed in zip(first.seeds, second.seeds):
--            assert f_seed.state == s_seed.state
--
--    def test_bad_seed(self):
--        args = (self.H, self.state, self.times)
--        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
--        with pytest.raises(ValueError):
--            first = mcsolve(*args, seeds=[1], **kwargs)
--
--    def test_generator(self):
--        args = (self.H, self.state, self.times)
--        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
--        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
--                        **kwargs)
--        second = mcsolve(*args, seeds=1, **kwargs)
--        for f_seed, s_seed in zip(first.seeds, second.seeds):
--            assert f_seed.state == s_seed.state
--        assert not all(np.array_equal(first_t, second_t)
--                       for first_t, second_t in zip(first.col_times,
--                                                    second.col_times))
--        assert not all(np.array_equal(first_w, second_w)
--                       for first_w, second_w in zip(first.col_which,
--                                                    second.col_which))
--
--    def test_stepping(self):
--        size = 10
--        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
--        H = qutip.num(size)
--        mcsolver = MCSolver(H, a, options={'map': 'serial'})
--        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
--        state_1 = mcsolver.step(1, args={'alpha':1})
--
--        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
--        state_2 = mcsolver.step(1, args={'alpha':1})
--        assert state_1 == state_2
--
--
--def test_timeout():
--    size = 10
--    ntraj = 1000
--    a = qutip.destroy(size)
--    H = qutip.num(size)
--    state = qutip.basis(size, size-1)
--    times = np.linspace(0, 1.0, 100)
--    coupling = 0.5
--    n_th = 0.05
--    c_ops = np.sqrt(coupling * (n_th + 1)) * a
--    e_ops = [qutip.num(size)]
--    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
--                  options={'map': 'serial'}, timeout=1e-6)
--    assert res.stats['end_condition'] == 'timeout'
--
--
--def test_super_H():
--    size = 10
--    ntraj = 1000
--    a = qutip.destroy(size)
--    H = qutip.num(size)
--    state = qutip.basis(size, size-1)
--    times = np.linspace(0, 1.0, 100)
--    # Arbitrary coupling and bath temperature.
--    coupling = 0.5
--    n_th = 0.05
--    c_ops = np.sqrt(coupling * (n_th + 1)) * a
--    e_ops = [qutip.num(size)]
--    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
--                          target_tol=0.1, options={'map': 'serial'})
--    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
--                 target_tol=0.1, options={'map': 'serial'})
--    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
--
--
--def test_MCSolver_run():
--    size = 10
--    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
--    H = qutip.num(size)
--    solver = MCSolver(H, a)
--    solver.options = {'store_final_state': True}
--    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
--                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
--    assert res.final_state is not None
--    assert len(res.collapse[0]) != 0
--    assert res.num_trajectories == 1
--    np.testing.assert_allclose(res.expect[0], np.ones(11))
--    res += solver.run(
--        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
--        e_ops=[qutip.qeye(size)], args={'coupling': 1},
--        ntraj=1000, target_tol=0.1
--    )
--    assert res.num_trajectories == 1001
--
--
--def test_MCSolver_stepping():
--    size = 10
--    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
--    H = qutip.num(size)
--    solver = MCSolver(H, a)
--    solver.start(qutip.basis(size, size-1), 0, seed=0)
--    solver.options = {'method': 'lsoda'}
--    state = solver.step(1)
--    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
--    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
--    assert state.isket
--    state = solver.step(5, args={'coupling': 5})
--    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
--    assert qutip.expect(qutip.num(size), state) <= size - 1
--    assert state.isket
--
--
--# Defined in module-scope so it's pickleable.
--def _dynamic(t, args):
--    return 0 if args["collapse"] else 1
--
--
--@pytest.mark.xfail(reason="current limitation of McSolve")
--def test_dynamic_arguments():
--    """Test dynamically updated arguments are usable."""
--    size = 5
--    a = qutip.destroy(size)
--    H = qutip.num(size)
--    times = np.linspace(0, 1, 11)
--    state = qutip.basis(size, 2)
--
--    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
--    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
--    assert all(len(collapses) <= 1 for collapses in mc.col_which)
-+import pytest
-+import numpy as np
-+import qutip
-+from copy import copy
-+from qutip.solver.mcsolve import mcsolve, MCSolver
-+from qutip.solver.solver_base import Solver
-+
-+def _return_constant(t, args):
-+    return args['constant']
-+
-+
-+def _return_decay(t, args):
-+    return args['constant'] * np.exp(-args['rate'] * t)
-+
-+
-+class callable_qobj:
-+    def __init__(self, oper, coeff=None):
-+        self.oper = oper
-+        self.coeff = coeff
-+
-+    def __call__(self, t, args):
-+        if self.coeff is not None:
-+            return self.oper * self.coeff(t, args)
-+        return self.oper
-+
-+
-+@pytest.mark.usefixtures("in_temporary_directory")
-+class StatesAndExpectOutputCase:
-+    """
-+    Mixin class to test the states and expectation values from ``mcsolve``.
-+    """
-+    size = 10
-+    h = qutip.num(size)
-+    state = qutip.basis(size, size-1)
-+    times = np.linspace(0, 1, 101)
-+    e_ops = [qutip.num(size)]
-+    ntraj = 2000
-+
-+    def _assert_states(self, result, expected, tol):
-+        assert hasattr(result, 'states')
-+        assert len(result.states) == len(self.times)
-+        assert len(self.e_ops) == len(expected)
-+        for test_operator, expected_part in zip(self.e_ops, expected):
-+            test = qutip.expect(test_operator, result.states)
-+            np.testing.assert_allclose(test, expected_part, rtol=tol)
-+
-+    def _assert_expect(self, result, expected, tol):
-+        assert hasattr(result, 'expect')
-+        assert len(result.expect) == len(self.e_ops)
-+        assert len(self.e_ops) == len(expected)
-+        for test, expected_part in zip(result.expect, expected):
-+            np.testing.assert_allclose(test, expected_part, rtol=tol)
-+
-+    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
-+        options = {"store_states": True, "map": "serial"}
-+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-+                         options=options, target_tol=0.05)
-+        self._assert_expect(result, expected, tol)
-+        self._assert_states(result, expected, tol)
-+
-+
-+class TestNoCollapse(StatesAndExpectOutputCase):
-+    """
-+    Test that `mcsolve` correctly solves the system when there is a constant
-+    Hamiltonian and no collapses.
-+    """
-+    def pytest_generate_tests(self, metafunc):
-+        tol = 1e-8
-+        expect = (qutip.expect(self.e_ops[0], self.state)
-+                  * np.ones_like(self.times))
-+        hamiltonian_types = [
-+            (self.h, "Qobj"),
-+            ([self.h], "list"),
-+            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
-+                           args= {'constant': 0}), "QobjEvo"),
-+            (callable_qobj(self.h), "callable"),
-+        ]
-+        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
-+                 for hamiltonian, id in hamiltonian_types]
-+        metafunc.parametrize(
-+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-+            cases)
-+
-+    # Previously the "states_only" and "expect_only" tests were mixed in to
-+    # every other test case.  We move them out into the simplest set so that
-+    # their behaviour remains tested, but isn't repeated as often to keep test
-+    # runtimes shorter.  The known-good cases are still tested in the other
-+    # test cases, this is just testing the single-output behaviour.
-+
-+    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
-+        options = {"store_states": True, "map": "serial"}
-+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-+                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
-+                         options=options)
-+        self._assert_states(result, expected, tol)
-+
-+    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
-+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-+                         options={'map': 'serial'})
-+        self._assert_expect(result, expected, tol)
-+
-+
-+class TestConstantCollapse(StatesAndExpectOutputCase):
-+    """
-+    Test that `mcsolve` correctly solves the system when there is a constant
-+    collapse operator.
-+    """
-+    def pytest_generate_tests(self, metafunc):
-+        tol = 0.25
-+        coupling = 0.2
-+        expect = (qutip.expect(self.e_ops[0], self.state)
-+                  * np.exp(-coupling * self.times))
-+        collapse_op = qutip.destroy(self.size)
-+        c_op_types = [
-+            (np.sqrt(coupling)*collapse_op, {}, "constant"),
-+            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
-+            (callable_qobj(collapse_op, _return_constant),
-+             {'constant': np.sqrt(coupling)}, "function"),
-+        ]
-+        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
-+                 for c_op, args, id in c_op_types]
-+        metafunc.parametrize(
-+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-+            cases)
-+
-+
-+class TestTimeDependentCollapse(StatesAndExpectOutputCase):
-+    """
-+    Test that `mcsolve` correctly solves the system when the collapse operators
-+    are time-dependent.
-+    """
-+    def pytest_generate_tests(self, metafunc):
-+        tol = 0.25
-+        coupling = 0.2
-+        expect = (qutip.expect(self.e_ops[0], self.state)
-+                  * np.exp(-coupling * (1 - np.exp(-self.times))))
-+        collapse_op = qutip.destroy(self.size)
-+        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
-+        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
-+        c_op_types = [
-+            ([collapse_op, _return_decay], collapse_args, "function"),
-+            ([collapse_op, collapse_string], {}, "string"),
-+        ]
-+        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
-+                 for c_op, args, id in c_op_types]
-+        metafunc.parametrize(
-+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-+            cases)
-+
-+
-+def test_stored_collapse_operators_and_times():
-+    """
-+    Test that the output contains information on which collapses happened and
-+    at what times, and make sure that this information makes sense.
-+    """
-+    size = 10
-+    a = qutip.destroy(size)
-+    H = qutip.num(size)
-+    state = qutip.basis(size, size-1)
-+    times = np.linspace(0, 10, 100)
-+    c_ops = [a, a]
-+    result = mcsolve(H, state, times, c_ops, ntraj=3,
-+                     options={'map': 'serial'})
-+    assert len(result.col_times[0]) > 0
-+    assert len(result.col_which) == len(result.col_times)
-+    assert all(col in [0, 1] for col in result.col_which[0])
-+
-+
-+@pytest.mark.parametrize('keep_runs_results', [True, False])
-+def test_states_outputs(keep_runs_results):
-+    # We're just testing the output value, so it's important whether certain
-+    # things are complex or real, but not what the magnitudes of constants are.
-+    focks = 5
-+    ntraj = 5
-+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
-+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
-+    H = 1j*a.dag()*sm + a
-+    H = H + H.dag()
-+    state = qutip.basis([focks, 2], [0, 1])
-+    times = np.linspace(0, 10, 21)
-+    c_ops = [a, sm]
-+    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
-+                   options={"keep_runs_results": keep_runs_results,
-+                            'map': 'serial'})
-+
-+    assert len(data.average_states) == len(times)
-+    assert isinstance(data.average_states[0], qutip.Qobj)
-+    assert data.average_states[0].norm() == pytest.approx(1.)
-+    assert data.average_states[0].isoper
-+
-+    assert isinstance(data.average_final_state, qutip.Qobj)
-+    assert data.average_final_state.norm() == pytest.approx(1.)
-+    assert data.average_final_state.isoper
-+
-+    assert isinstance(data.photocurrent[0][1], float)
-+    assert isinstance(data.photocurrent[1][1], float)
-+    assert (np.array(data.runs_photocurrent).shape
-+        == (ntraj, len(c_ops), len(times)-1))
-+
-+    if keep_runs_results:
-+        assert len(data.runs_states) == ntraj
-+        assert len(data.runs_states[0]) == len(times)
-+        assert isinstance(data.runs_states[0][0], qutip.Qobj)
-+        assert data.runs_states[0][0].norm() == pytest.approx(1.)
-+        assert data.runs_states[0][0].isket
-+
-+        assert len(data.runs_final_states) == ntraj
-+        assert isinstance(data.runs_final_states[0], qutip.Qobj)
-+        assert data.runs_final_states[0].norm() == pytest.approx(1.)
-+        assert data.runs_final_states[0].isket
-+
-+    assert isinstance(data.steady_state(), qutip.Qobj)
-+    assert data.steady_state().norm() == pytest.approx(1.)
-+    assert data.steady_state().isoper
-+
-+    np.testing.assert_allclose(times, data.times)
-+    assert data.num_trajectories == ntraj
-+    assert len(data.e_ops) == 0
-+    assert data.stats["num_collapse"] == len(c_ops)
-+    assert len(data.col_times) == ntraj
-+    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
-+    assert data.stats['end_condition'] == "ntraj reached"
-+
-+
-+@pytest.mark.parametrize('keep_runs_results', [True, False])
-+def test_expectation_outputs(keep_runs_results):
-+    # We're just testing the output value, so it's important whether certain
-+    # things are complex or real, but not what the magnitudes of constants are.
-+    focks = 5
-+    ntraj = 5
-+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
-+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
-+    H = 1j*a.dag()*sm + a
-+    H = H + H.dag()
-+    state = qutip.basis([focks, 2], [0, 1])
-+    times = np.linspace(0, 10, 5)
-+    c_ops = [a, sm]
-+    e_ops = [a.dag()*a, sm.dag()*sm, a]
-+    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-+                   options={"keep_runs_results": keep_runs_results,
-+                            'map': 'serial'})
-+    assert isinstance(data.average_expect[0][1], float)
-+    assert isinstance(data.average_expect[1][1], float)
-+    assert isinstance(data.average_expect[2][1], complex)
-+    assert isinstance(data.std_expect[0][1], float)
-+    assert isinstance(data.std_expect[1][1], float)
-+    assert isinstance(data.std_expect[2][1], float)
-+    if keep_runs_results:
-+        assert len(data.runs_expect) == len(e_ops)
-+        assert len(data.runs_expect[0]) == ntraj
-+        assert isinstance(data.runs_expect[0][0][1], float)
-+        assert isinstance(data.runs_expect[1][0][1], float)
-+        assert isinstance(data.runs_expect[2][0][1], complex)
-+    assert isinstance(data.photocurrent[0][0], float)
-+    assert isinstance(data.photocurrent[1][0], float)
-+    assert (np.array(data.runs_photocurrent).shape
-+            == (ntraj, len(c_ops), len(times)-1))
-+    np.testing.assert_allclose(times, data.times)
-+    assert data.num_trajectories == ntraj
-+    assert len(data.e_ops) == len(e_ops)
-+    assert data.stats["num_collapse"] == len(c_ops)
-+    assert len(data.col_times) == ntraj
-+    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
-+    assert data.stats['end_condition'] == "ntraj reached"
-+
-+
-+class TestSeeds:
-+    sizes = [6, 6, 6]
-+    dampings = [0.1, 0.4, 0.1]
-+    ntraj = 25  # Big enough to ensure there are differences without being slow
-+    a = [qutip.destroy(size) for size in sizes]
-+    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
-+              - qutip.tensor(a[0].dag(), a[1], a[2]))
-+    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
-+                         qutip.basis(sizes[1:], [0, 0]))
-+    times = np.linspace(0, 10, 2)
-+    c_ops = [
-+        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
-+        (np.sqrt(2*dampings[1])
-+         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
-+        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
-+    ]
-+
-+    def test_seeds_can_be_reused(self):
-+        args = (self.H, self.state, self.times)
-+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-+        first = mcsolve(*args, **kwargs)
-+        second = mcsolve(*args, seeds=first.seeds, **kwargs)
-+        for first_t, second_t in zip(first.col_times, second.col_times):
-+            np.testing.assert_equal(first_t, second_t)
-+        for first_w, second_w in zip(first.col_which, second.col_which):
-+            np.testing.assert_equal(first_w, second_w)
-+
-+    def test_seeds_are_not_reused_by_default(self):
-+        args = (self.H, self.state, self.times)
-+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-+        first = mcsolve(*args, **kwargs)
-+        second = mcsolve(*args, **kwargs)
-+        assert not all(np.array_equal(first_t, second_t)
-+                       for first_t, second_t in zip(first.col_times,
-+                                                    second.col_times))
-+        assert not all(np.array_equal(first_w, second_w)
-+                       for first_w, second_w in zip(first.col_which,
-+                                                    second.col_which))
-+
-+    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
-+    def test_seed_type(self, seed):
-+        args = (self.H, self.state, self.times)
-+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-+        first = mcsolve(*args, seeds=copy(seed), **kwargs)
-+        second = mcsolve(*args, seeds=copy(seed), **kwargs)
-+        for f_seed, s_seed in zip(first.seeds, second.seeds):
-+            assert f_seed.state == s_seed.state
-+
-+    def test_bad_seed(self):
-+        args = (self.H, self.state, self.times)
-+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-+        with pytest.raises(ValueError):
-+            first = mcsolve(*args, seeds=[1], **kwargs)
-+
-+    def test_generator(self):
-+        args = (self.H, self.state, self.times)
-+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-+        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
-+                        **kwargs)
-+        second = mcsolve(*args, seeds=1, **kwargs)
-+        for f_seed, s_seed in zip(first.seeds, second.seeds):
-+            assert f_seed.state == s_seed.state
-+        assert not all(np.array_equal(first_t, second_t)
-+                       for first_t, second_t in zip(first.col_times,
-+                                                    second.col_times))
-+        assert not all(np.array_equal(first_w, second_w)
-+                       for first_w, second_w in zip(first.col_which,
-+                                                    second.col_which))
-+
-+    def test_stepping(self):
-+        size = 10
-+        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
-+        H = qutip.num(size)
-+        mcsolver = MCSolver(H, a, options={'map': 'serial'})
-+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-+        state_1 = mcsolver.step(1, args={'alpha':1})
-+
-+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-+        state_2 = mcsolver.step(1, args={'alpha':1})
-+        assert state_1 == state_2
-+
-+
-+def test_timeout():
-+    size = 10
-+    ntraj = 1000
-+    a = qutip.destroy(size)
-+    H = qutip.num(size)
-+    state = qutip.basis(size, size-1)
-+    times = np.linspace(0, 1.0, 100)
-+    coupling = 0.5
-+    n_th = 0.05
-+    c_ops = np.sqrt(coupling * (n_th + 1)) * a
-+    e_ops = [qutip.num(size)]
-+    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-+                  options={'map': 'serial'}, timeout=1e-6)
-+    assert res.stats['end_condition'] == 'timeout'
-+
-+
-+def test_super_H():
-+    size = 10
-+    ntraj = 1000
-+    a = qutip.destroy(size)
-+    H = qutip.num(size)
-+    state = qutip.basis(size, size-1)
-+    times = np.linspace(0, 1.0, 100)
-+    # Arbitrary coupling and bath temperature.
-+    coupling = 0.5
-+    n_th = 0.05
-+    c_ops = np.sqrt(coupling * (n_th + 1)) * a
-+    e_ops = [qutip.num(size)]
-+    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-+                          target_tol=0.1, options={'map': 'serial'})
-+    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
-+                 target_tol=0.1, options={'map': 'serial'})
-+    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
-+
-+
-+def test_MCSolver_run():
-+    size = 10
-+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
-+    H = qutip.num(size)
-+    solver = MCSolver(H, a)
-+    solver.options = {'store_final_state': True}
-+    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
-+                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
-+    assert res.final_state is not None
-+    assert len(res.collapse[0]) != 0
-+    assert res.num_trajectories == 1
-+    np.testing.assert_allclose(res.expect[0], np.ones(11))
-+    res += solver.run(
-+        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
-+        e_ops=[qutip.qeye(size)], args={'coupling': 1},
-+        ntraj=1000, target_tol=0.1
-+    )
-+    assert res.num_trajectories == 1001
-+
-+
-+def test_MCSolver_stepping():
-+    size = 10
-+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
-+    H = qutip.num(size)
-+    solver = MCSolver(H, a)
-+    solver.start(qutip.basis(size, size-1), 0, seed=0)
-+    solver.options = {'method': 'lsoda'}
-+    state = solver.step(1)
-+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
-+    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
-+    assert state.isket
-+    state = solver.step(5, args={'coupling': 5})
-+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
-+    assert qutip.expect(qutip.num(size), state) <= size - 1
-+    assert state.isket
-+
-+
-+# Defined in module-scope so it's pickleable.
-+def _dynamic(t, args):
-+    return 0 if args["collapse"] else 1
-+
-+
-+@pytest.mark.xfail(reason="current limitation of McSolve")
-+def test_dynamic_arguments():
-+    """Test dynamically updated arguments are usable."""
-+    size = 5
-+    a = qutip.destroy(size)
-+    H = qutip.num(size)
-+    times = np.linspace(0, 1, 11)
-+    state = qutip.basis(size, 2)
-+
-+    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
-+    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
-+    assert all(len(collapses) <= 1 for collapses in mc.col_which)
-diff --git a/qutip/tests/solver/test_mesolve.py b/qutip/tests/solver/test_mesolve.py
-index 6f6bbab6..deb12479 100644
---- a/qutip/tests/solver/test_mesolve.py
-+++ b/qutip/tests/solver/test_mesolve.py
-@@ -1,677 +1,677 @@
--import numpy as np
--from types import FunctionType
--
--import qutip
--from qutip.solver.mesolve import mesolve, MESolver
--from qutip.solver.solver_base import Solver
--import pickle
--import pytest
--
--all_ode_method = [
--    method for method, integrator in MESolver.avail_integrators().items()
--    if integrator.support_time_dependant
--]
--
--def fidelitycheck(out1, out2, rho0vec):
--    fid = np.zeros(len(out1.states))
--    for i, E in enumerate(out2.states):
--        rhot = qutip.vector_to_operator(E*rho0vec)
--        fid[i] = qutip.fidelity(out1.states[i], rhot)
--    return fid
--
--
--class TestMESolveDecay:
--    N = 10
--    a = qutip.destroy(N)
--    kappa = 0.2
--    tlist = np.linspace(0, 10, 201)
--    ada = a.dag() * a
--
--    @pytest.fixture(params=[
--        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
--        pytest.param([ada, '1'], id='Hlist_str'),
--        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
--        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
--        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
--                     id='func'),
--    ])
--    def H(self, request):
--        return request.param
--
--    @pytest.fixture(params=[
--        pytest.param(np.sqrt(kappa) * a,
--                     id='const'),
--        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
--                                      * qutip.destroy(10)),
--                     id='func'),
--        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
--                     id='list_func'),
--        pytest.param([a, 'sqrt(kappa)'],
--                     id='list_str'),
--        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
--                     id='list_array'),
--        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
--                     id='QobjEvo'),
--    ])
--    def cte_c_ops(self, request):
--        return request.param
--
--    @pytest.fixture(params=[
--        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
--                  id='list_func'),
--        pytest.param([a, 'sqrt(kappa * exp(-t))'],
--                  id='list_str'),
--        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
--                  id='list_array'),
--        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
--                          args={'kappa': kappa}),
--                  id='QobjEvo'),
--        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
--                                      qutip.destroy(10)),
--                     id='func'),
--    ])
--    def c_ops(self, request):
--        return request.param
--
--    c_ops_1 = c_ops
--
--    def testME_CteDecay(self, cte_c_ops):
--        "mesolve: simple constant decay"
--        me_error = 1e-6
--        H = self.a.dag() * self.a
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        c_op_list = [cte_c_ops]
--        options = {"progress_bar": None}
--        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
--                         args={"kappa": self.kappa},
--                         options=options)
--        expt = medata.expect[0]
--        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
--        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
--
--    @pytest.mark.parametrize('method',
--                             all_ode_method, ids=all_ode_method)
--    def testME_TDDecay(self, c_ops, method):
--        "mesolve: time-dependence as function list"
--        me_error = 1e-5
--        H = self.a.dag() * self.a
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        c_op_list = [c_ops]
--        options = {"method": method, "progress_bar": None}
--        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
--                         args={"kappa": self.kappa}, options=options)
--        expt = medata.expect[0]
--        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
--        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
--
--    def testME_2TDDecay(self, c_ops, c_ops_1):
--        "mesolve: time-dependence as function list"
--        me_error = 1e-5
--        H = self.a.dag() * self.a
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        c_op_list = [c_ops, c_ops_1]
--        options = {"progress_bar": None}
--        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
--                         args={"kappa": self.kappa},
--                         options=options)
--        expt = medata.expect[0]
--        actual_answer = 9.0 * np.exp(-2 * self.kappa *
--                                     (1.0 - np.exp(-self.tlist)))
--        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
--
--    def testME_TDH_TDDecay(self, H, c_ops):
--        "mesolve: time-dependence as function list"
--        me_error = 5e-6
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        c_op_list = [c_ops]
--        options = {"progress_bar": None}
--        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
--                         args={"kappa": self.kappa},
--                         options=options)
--        expt = medata.expect[0]
--        actual_answer = 9.0 * np.exp(-self.kappa *
--                                     (1.0 - np.exp(-self.tlist)))
--        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
--
--    def testME_TDH_longTDDecay(self, H, c_ops):
--        "mesolve: time-dependence as function list"
--        me_error = 2e-5
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        if isinstance(c_ops, FunctionType):
--            return
--        if isinstance(c_ops, qutip.QobjEvo):
--            c_op_list = [c_ops + c_ops]
--        else:
--            c_op_list = [[c_ops, c_ops]]
--        options = {"progress_bar": None}
--        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
--                         args={"kappa": self.kappa},
--                         options=options)
--        expt = medata.expect[0]
--        actual_answer = 9.0 * np.exp(-4 * self.kappa *
--                                     (1.0 - np.exp(-self.tlist)))
--        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
--
--    def testME_TDDecayUnitary(self, c_ops):
--        "mesolve: time-dependence as function list with super as init cond"
--        me_error = 5e-6
--
--        H = self.ada
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
--        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
--        options = {"progress_bar": None}
--        c_op_list = [c_ops]
--        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
--                       args={"kappa": self.kappa},
--                       options=options)
--        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
--                       args={"kappa": self.kappa},
--                       options=options)
--
--        fid = fidelitycheck(out1, out2, rho0vec)
--        assert fid == pytest.approx(1., abs=me_error)
--
--    def testME_TDDecayliouvillian(self, c_ops):
--        "mesolve: time-dependence as function list with super as init cond"
--        me_error = 5e-6
--
--        H = self.ada
--        L = qutip.liouvillian(H)
--        psi0 = qutip.basis(self.N, 9)  # initial state
--        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
--        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
--        options = {"progress_bar": None}
--        c_op_list = [c_ops]
--        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
--                       args={"kappa": self.kappa},
--                       options=options)
--        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
--                       args={"kappa": self.kappa},
--                       options=options)
--
--        fid = fidelitycheck(out1, out2, rho0vec)
--        assert fid == pytest.approx(1., abs=me_error)
--
--    @pytest.mark.parametrize(['state_type'], [
--        pytest.param("ket", id="ket"),
--        pytest.param("dm", id="dm"),
--        pytest.param("unitary", id="unitary"),
--    ])
--    def test_mesolve_normalization(self, state_type):
--        # non-hermitean H causes state to evolve non-unitarily
--        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
--        H = qutip.sprepost(H, H) # ensure use of MeSolve
--        psi0 = qutip.basis(2, 0)
--        options = {"normalize_output": True, "progress_bar": None}
--
--        if state_type in {"ket", "dm"}:
--            if state_type == "dm":
--                psi0 = qutip.ket2dm(psi0)
--            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
--            norms = [state.norm() for state in output.states]
--            np.testing.assert_allclose(
--                norms, [1.0 for _ in self.tlist], atol=1e-15,
--            )
--        else:
--            # evolution of unitaries should not be normalized
--            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
--            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
--            norms = [state.norm() for state in output.states]
--            assert all(norm > 4 for norm in norms[1:])
--
--    def test_mesolver_pickling(self):
--        options = {"progress_bar": None}
--        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
--        solver_copy = pickle.loads(pickle.dumps(solver_obj))
--        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
--                            e_ops=[self.ada]).expect[0]
--        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
--                            e_ops=[self.ada]).expect[0]
--        np.testing.assert_allclose(e1, e2)
--
--    @pytest.mark.parametrize('method',
--                             all_ode_method, ids=all_ode_method)
--    def test_mesolver_stepping(self, method):
--        options = {"method": method, "progress_bar": None}
--        solver_obj = MESolver(
--            self.ada,
--            c_ops=qutip.QobjEvo(
--                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
--                args={'kappa': 1.}
--            ),
--            options=options
--        )
--        solver_obj.start(qutip.basis(self.N, 9), 0)
--        state1 = solver_obj.step(1)
--        assert qutip.expect(self.ada, state1) != (
--            qutip.expect(self.ada, qutip.basis(self.N, 9))
--        )
--        state2 = solver_obj.step(2, args={"kappa":0.})
--        np.testing.assert_allclose(qutip.expect(self.ada, state1),
--                                   qutip.expect(self.ada, state2), 1e-6)
--
--
--@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
--                         ids=["ket", "dm", "liouvillian"])
--def testME_SesolveFallback(super_):
--    "mesolve: final_state has correct dims"
--    N = 5
--    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
--    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
--    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
--    psi0 = qutip.tensor(qutip.basis(N+1,0),
--                        qutip.basis(N+1,0),
--                        qutip.basis(N+1,N))
--    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
--    if super_ == "dm":
--        state0 = qutip.ket2dm(psi0)
--    else:
--        state0 = psi0
--    if super_ == "liouvillian":
--        H = qutip.liouvillian(H)
--
--    times = np.linspace(0.0, 0.1, 3)
--    options = {
--        "store_states": False,
--        "store_final_state": True,
--        "progress_bar": None
--    }
--    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
--    if super_ == "ket":
--        assert result.final_state.dims == psi0.dims
--    else:
--        assert result.final_state.dims == qutip.ket2dm(psi0).dims
--
--
--class TestJCModelEvolution:
--    """
--    A test class for the QuTiP functions for the evolution of JC model
--    """
--    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
--
--        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
--
--        c_op_list = []
--
--        rate = g1
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
--
--        rate = g2
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
--
--        output = mesolve(H, psi0, tlist, c_op_list,
--            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
--        )
--
--        return output.expect[0], output.expect[1], output.expect[2]
--
--    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
--                       pump, psi0, use_rwa, tlist):
--
--        # Hamiltonian
--        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
--        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
--
--        if use_rwa:
--            # use the rotating wave approxiation
--            H = (wc * a.dag() * a + wa * sm.dag() * sm
--                 + g * (a.dag() * sm + a * sm.dag()))
--        else:
--            H = (wc * a.dag() * a + wa * sm.dag() * sm
--                 + g * (a.dag() + a) * (sm + sm.dag()))
--
--        # collapse operators
--        c_op_list = []
--
--        n_th_a = 0.0  # zero temperature
--
--        rate = kappa * (1 + n_th_a)
--        c_op_list.append(np.sqrt(rate) * a)
--
--        rate = kappa * n_th_a
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * a.dag())
--
--        rate = gamma
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * sm)
--
--        rate = pump
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * sm.dag())
--
--        # find the steady state
--        rho_ss = qutip.steadystate(H, c_op_list)
--
--        return (qutip.expect(a.dag() * a, rho_ss),
--                qutip.expect(sm.dag() * sm, rho_ss))
--
--    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
--                     pump, psi0, use_rwa, tlist, oper_evo=False):
--
--        # Hamiltonian
--        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
--        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
--
--        # Identity super-operator
--        E0 = qutip.sprepost(
--            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
--            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
--        )
--
--        if use_rwa:
--            # use the rotating wave approxiation
--            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
--                a.dag() * sm + a * sm.dag())
--        else:
--            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
--                a.dag() + a) * (sm + sm.dag())
--
--        # collapse operators
--        c_op_list = []
--
--        n_th_a = 0.0  # zero temperature
--
--        rate = kappa * (1 + n_th_a)
--        c_op_list.append(np.sqrt(rate) * a)
--
--        rate = kappa * n_th_a
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * a.dag())
--
--        rate = gamma
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * sm)
--
--        rate = pump
--        if rate > 0.0:
--            c_op_list.append(np.sqrt(rate) * sm.dag())
--
--        options = {"store_states": True, "progress_bar": None}
--
--        # evolve and calculate expectation values
--        output = mesolve(
--            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
--            options=options)
--        if oper_evo:
--            output2 = mesolve(H, E0, tlist, c_op_list, [])
--            return output, output2
--        return output.expect[0], output.expect[1]
--
--    def testSuperJC(self):
--        "mesolve: super vs. density matrix as initial condition"
--        me_error = 1e-6
--
--        use_rwa = True
--        N = 4           # number of cavity fock states
--        wc = 2 * np.pi * 1.0   # cavity frequency
--        wa = 2 * np.pi * 1.0   # atom frequency
--        g = 2 * np.pi * 0.1   # coupling strength
--        kappa = 0.05    # cavity dissipation rate
--        gamma = 0.001   # atom dissipation rate
--        pump = 0.25    # atom pump rate
--
--        # start with an excited atom and maximum number of photons
--        n = N - 2
--        psi0 = qutip.basis([N, 2], [n, 1])
--        rho0vec = qutip.operator_to_vector(psi0.proj())
--        tlist = np.linspace(0, 100, 50)
--
--        out1, out2 = self.jc_integrate(
--            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
--
--        fid = fidelitycheck(out1, out2, rho0vec)
--        assert fid == pytest.approx(1., abs=me_error)
--
--    def testQubitDynamics1(self):
--        "mesolve: qubit with dissipation"
--
--        epsilon = 0.0 * 2 * np.pi   # cavity frequency
--        delta = 1.0 * 2 * np.pi   # atom frequency
--        g2 = 0.1
--        g1 = 0.0
--        psi0 = qutip.basis(2, 0)        # initial state
--        tlist = np.linspace(0, 5, 200)
--
--        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
--
--        sx_analytic = np.zeros(np.shape(tlist))
--        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
--        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
--
--        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
--        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
--        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
--
--    def testQubitDynamics2(self):
--        "mesolve: qubit without dissipation"
--
--        epsilon = 0.0 * 2 * np.pi   # cavity frequency
--        delta = 1.0 * 2 * np.pi   # atom frequency
--        g2 = 0.0
--        g1 = 0.0
--        psi0 = qutip.basis(2, 0)        # initial state
--        tlist = np.linspace(0, 5, 200)
--
--        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
--
--        sx_analytic = np.zeros(np.shape(tlist))
--        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
--        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
--
--        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
--        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
--        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
--
--    def testCavity1(self):
--        "mesolve: cavity-qubit interaction, no dissipation"
--
--        use_rwa = True
--        N = 4           # number of cavity fock states
--        wc = 2 * np.pi * 1.0   # cavity frequency
--        wa = 2 * np.pi * 1.0   # atom frequency
--        g = 2 * np.pi * 0.01   # coupling strength
--        kappa = 0.0     # cavity dissipation rate
--        gamma = 0.0     # atom dissipation rate
--        pump = 0.0      # atom pump rate
--
--        # start with an excited atom and maximum number of photons
--        n = N - 2
--        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
--        tlist = np.linspace(0, 1000, 2000)
--
--        nc, na = self.jc_integrate(
--            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
--
--        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
--        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
--
--        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
--        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
--
--    def testCavity2(self):
--        "mesolve: cavity-qubit without interaction, decay"
--
--        use_rwa = True
--        N = 4           # number of cavity fock states
--        wc = 2 * np.pi * 1.0   # cavity frequency
--        wa = 2 * np.pi * 1.0   # atom frequency
--        g = 2 * np.pi * 0.0    # coupling strength
--        kappa = 0.005   # cavity dissipation rate
--        gamma = 0.01    # atom dissipation rate
--        pump = 0.0      # atom pump rate
--
--        # start with an excited atom and maximum number of photons
--        n = N - 2
--        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
--        tlist = np.linspace(0, 1000, 2000)
--
--        nc, na = self.jc_integrate(
--            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
--
--        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
--            np.exp(-kappa * tlist)
--        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
--            np.exp(-gamma * tlist)
--
--        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
--        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
--
--    def testCavity3(self):
--        "mesolve: cavity-qubit with interaction, decay"
--
--        use_rwa = True
--        N = 4           # number of cavity fock states
--        wc = 2 * np.pi * 1.0   # cavity frequency
--        wa = 2 * np.pi * 1.0   # atom frequency
--        g = 2 * np.pi * 0.1   # coupling strength
--        kappa = 0.05    # cavity dissipation rate
--        gamma = 0.001   # atom dissipation rate
--        pump = 0.25    # atom pump rate
--
--        # start with an excited atom and maximum number of photons
--        n = N - 2
--        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
--        tlist = np.linspace(0, 200, 500)
--
--        nc, na = self.jc_integrate(
--            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
--
--        # we don't have any analytics for this parameters, so
--        # compare with the steady state
--        nc_ss, na_ss = self.jc_steadystate(
--            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
--
--        nc_ss = nc_ss * np.ones(np.shape(nc))
--        na_ss = na_ss * np.ones(np.shape(na))
--
--        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
--        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
--
--
--class TestMESolveStepFuncCoeff:
--    """
--    A Test class for using time-dependent array coefficients
--    as step functions instead of doing interpolation
--    """
--    # Runge-Kutta method (dop853) behave better with step function evolution
--    # than multi-step methods (adams, qutip 4's default)
--    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
--
--    def python_coeff(self, t, args):
--        if t < np.pi/2:
--            return 1.
--        else:
--            return 0.
--
--    @pytest.mark.parametrize('method',
--                             all_ode_method, ids=all_ode_method)
--    def test_py_coeff(self, method):
--        """
--        Test for Python function as coefficient as step function coeff
--        """
--        rho0 = qutip.rand_ket(2)
--        tlist = np.array([0, np.pi/2])
--        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
--        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
--                     tlist=tlist, order=0)
--        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
--        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
--        assert fid == pytest.approx(1)
--
--    def test_array_cte_coeff(self):
--        """
--        Test for Array coefficient with uniform tlist as step function coeff
--        """
--        rho0 = qutip.rand_ket(2)
--        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
--        npcoeff = np.array([0.25, 0.75, 0.75])
--        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
--        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
--        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
--        assert fid == pytest.approx(1)
--
--    def test_array_t_coeff(self):
--        """
--        Test for Array with non-uniform tlist as step function coeff
--        """
--        rho0 = qutip.rand_ket(2)
--        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
--        npcoeff = np.array([0.5, 0.25, 0.25])
--        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
--        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
--        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
--        assert fid == pytest.approx(1)
--
--    def test_array_str_coeff(self):
--        """
--        Test for Array and string as step function coeff.
--        qobjevo_codegen is used and uniform tlist
--        """
--        rho0 = qutip.rand_ket(2)
--        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
--        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
--        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
--        strcoeff = "1."
--        qu = qutip.QobjEvo(
--            [[qutip.sigmax(), npcoeff1],
--             [qutip.sigmax(), strcoeff],
--             [qutip.sigmax(), npcoeff2]],
--            tlist=tlist, order=0)
--        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
--        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
--        assert fid == pytest.approx(1)
--
--    def test_array_str_py_coeff(self):
--        """
--        Test for Array, string and Python function as step function coeff.
--        qobjevo_codegen is used and non non-uniform tlist
--        """
--        rho0 = qutip.rand_ket(2)
--        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
--        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
--        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
--        strcoeff = "1."
--        qu = qutip.QobjEvo(
--            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
--             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
--            tlist=tlist, order=0)
--        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
--        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
--        assert fid == pytest.approx(1)
--
--
--def test_num_collapse_set():
--    H = qutip.sigmaz()
--    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
--    ts = [0, 1]
--    for c_ops in (
--        qutip.sigmax(),
--        [qutip.sigmax()],
--        [qutip.sigmay(), qutip.sigmax()],
--    ):
--        res = mesolve(H, psi, ts, c_ops=c_ops)
--        if not isinstance(c_ops, list):
--            c_ops = [c_ops]
--        assert res.stats["num_collapse"] == len(c_ops)
--
--
--def test_mesolve_bad_H():
--    with pytest.raises(TypeError):
--        MESolver([qutip.qeye(3), 't'], [])
--    with pytest.raises(TypeError):
--        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
--
--
--def test_mesolve_bad_state():
--    solver = MESolver(qutip.qeye(4), [])
--    with pytest.raises(TypeError):
--        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
--
--
--def test_mesolve_bad_options():
--    with pytest.raises(TypeError):
--        MESolver(qutip.qeye(4), [], options=False)
-+import numpy as np
-+from types import FunctionType
-+
-+import qutip
-+from qutip.solver.mesolve import mesolve, MESolver
-+from qutip.solver.solver_base import Solver
-+import pickle
-+import pytest
-+
-+all_ode_method = [
-+    method for method, integrator in MESolver.avail_integrators().items()
-+    if integrator.support_time_dependant
-+]
-+
-+def fidelitycheck(out1, out2, rho0vec):
-+    fid = np.zeros(len(out1.states))
-+    for i, E in enumerate(out2.states):
-+        rhot = qutip.vector_to_operator(E*rho0vec)
-+        fid[i] = qutip.fidelity(out1.states[i], rhot)
-+    return fid
-+
-+
-+class TestMESolveDecay:
-+    N = 10
-+    a = qutip.destroy(N)
-+    kappa = 0.2
-+    tlist = np.linspace(0, 10, 201)
-+    ada = a.dag() * a
-+
-+    @pytest.fixture(params=[
-+        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
-+        pytest.param([ada, '1'], id='Hlist_str'),
-+        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
-+        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
-+        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
-+                     id='func'),
-+    ])
-+    def H(self, request):
-+        return request.param
-+
-+    @pytest.fixture(params=[
-+        pytest.param(np.sqrt(kappa) * a,
-+                     id='const'),
-+        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
-+                                      * qutip.destroy(10)),
-+                     id='func'),
-+        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
-+                     id='list_func'),
-+        pytest.param([a, 'sqrt(kappa)'],
-+                     id='list_str'),
-+        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
-+                     id='list_array'),
-+        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
-+                     id='QobjEvo'),
-+    ])
-+    def cte_c_ops(self, request):
-+        return request.param
-+
-+    @pytest.fixture(params=[
-+        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
-+                  id='list_func'),
-+        pytest.param([a, 'sqrt(kappa * exp(-t))'],
-+                  id='list_str'),
-+        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
-+                  id='list_array'),
-+        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
-+                          args={'kappa': kappa}),
-+                  id='QobjEvo'),
-+        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
-+                                      qutip.destroy(10)),
-+                     id='func'),
-+    ])
-+    def c_ops(self, request):
-+        return request.param
-+
-+    c_ops_1 = c_ops
-+
-+    def testME_CteDecay(self, cte_c_ops):
-+        "mesolve: simple constant decay"
-+        me_error = 1e-6
-+        H = self.a.dag() * self.a
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        c_op_list = [cte_c_ops]
-+        options = {"progress_bar": None}
-+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-+                         args={"kappa": self.kappa},
-+                         options=options)
-+        expt = medata.expect[0]
-+        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
-+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-+
-+    @pytest.mark.parametrize('method',
-+                             all_ode_method, ids=all_ode_method)
-+    def testME_TDDecay(self, c_ops, method):
-+        "mesolve: time-dependence as function list"
-+        me_error = 1e-5
-+        H = self.a.dag() * self.a
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        c_op_list = [c_ops]
-+        options = {"method": method, "progress_bar": None}
-+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-+                         args={"kappa": self.kappa}, options=options)
-+        expt = medata.expect[0]
-+        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
-+        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
-+
-+    def testME_2TDDecay(self, c_ops, c_ops_1):
-+        "mesolve: time-dependence as function list"
-+        me_error = 1e-5
-+        H = self.a.dag() * self.a
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        c_op_list = [c_ops, c_ops_1]
-+        options = {"progress_bar": None}
-+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-+                         args={"kappa": self.kappa},
-+                         options=options)
-+        expt = medata.expect[0]
-+        actual_answer = 9.0 * np.exp(-2 * self.kappa *
-+                                     (1.0 - np.exp(-self.tlist)))
-+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-+
-+    def testME_TDH_TDDecay(self, H, c_ops):
-+        "mesolve: time-dependence as function list"
-+        me_error = 5e-6
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        c_op_list = [c_ops]
-+        options = {"progress_bar": None}
-+        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
-+                         args={"kappa": self.kappa},
-+                         options=options)
-+        expt = medata.expect[0]
-+        actual_answer = 9.0 * np.exp(-self.kappa *
-+                                     (1.0 - np.exp(-self.tlist)))
-+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-+
-+    def testME_TDH_longTDDecay(self, H, c_ops):
-+        "mesolve: time-dependence as function list"
-+        me_error = 2e-5
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        if isinstance(c_ops, FunctionType):
-+            return
-+        if isinstance(c_ops, qutip.QobjEvo):
-+            c_op_list = [c_ops + c_ops]
-+        else:
-+            c_op_list = [[c_ops, c_ops]]
-+        options = {"progress_bar": None}
-+        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
-+                         args={"kappa": self.kappa},
-+                         options=options)
-+        expt = medata.expect[0]
-+        actual_answer = 9.0 * np.exp(-4 * self.kappa *
-+                                     (1.0 - np.exp(-self.tlist)))
-+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-+
-+    def testME_TDDecayUnitary(self, c_ops):
-+        "mesolve: time-dependence as function list with super as init cond"
-+        me_error = 5e-6
-+
-+        H = self.ada
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
-+        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
-+        options = {"progress_bar": None}
-+        c_op_list = [c_ops]
-+        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
-+                       args={"kappa": self.kappa},
-+                       options=options)
-+        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
-+                       args={"kappa": self.kappa},
-+                       options=options)
-+
-+        fid = fidelitycheck(out1, out2, rho0vec)
-+        assert fid == pytest.approx(1., abs=me_error)
-+
-+    def testME_TDDecayliouvillian(self, c_ops):
-+        "mesolve: time-dependence as function list with super as init cond"
-+        me_error = 5e-6
-+
-+        H = self.ada
-+        L = qutip.liouvillian(H)
-+        psi0 = qutip.basis(self.N, 9)  # initial state
-+        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
-+        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
-+        options = {"progress_bar": None}
-+        c_op_list = [c_ops]
-+        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
-+                       args={"kappa": self.kappa},
-+                       options=options)
-+        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
-+                       args={"kappa": self.kappa},
-+                       options=options)
-+
-+        fid = fidelitycheck(out1, out2, rho0vec)
-+        assert fid == pytest.approx(1., abs=me_error)
-+
-+    @pytest.mark.parametrize(['state_type'], [
-+        pytest.param("ket", id="ket"),
-+        pytest.param("dm", id="dm"),
-+        pytest.param("unitary", id="unitary"),
-+    ])
-+    def test_mesolve_normalization(self, state_type):
-+        # non-hermitean H causes state to evolve non-unitarily
-+        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
-+        H = qutip.sprepost(H, H) # ensure use of MeSolve
-+        psi0 = qutip.basis(2, 0)
-+        options = {"normalize_output": True, "progress_bar": None}
-+
-+        if state_type in {"ket", "dm"}:
-+            if state_type == "dm":
-+                psi0 = qutip.ket2dm(psi0)
-+            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
-+            norms = [state.norm() for state in output.states]
-+            np.testing.assert_allclose(
-+                norms, [1.0 for _ in self.tlist], atol=1e-15,
-+            )
-+        else:
-+            # evolution of unitaries should not be normalized
-+            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
-+            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
-+            norms = [state.norm() for state in output.states]
-+            assert all(norm > 4 for norm in norms[1:])
-+
-+    def test_mesolver_pickling(self):
-+        options = {"progress_bar": None}
-+        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
-+        solver_copy = pickle.loads(pickle.dumps(solver_obj))
-+        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
-+                            e_ops=[self.ada]).expect[0]
-+        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
-+                            e_ops=[self.ada]).expect[0]
-+        np.testing.assert_allclose(e1, e2)
-+
-+    @pytest.mark.parametrize('method',
-+                             all_ode_method, ids=all_ode_method)
-+    def test_mesolver_stepping(self, method):
-+        options = {"method": method, "progress_bar": None}
-+        solver_obj = MESolver(
-+            self.ada,
-+            c_ops=qutip.QobjEvo(
-+                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
-+                args={'kappa': 1.}
-+            ),
-+            options=options
-+        )
-+        solver_obj.start(qutip.basis(self.N, 9), 0)
-+        state1 = solver_obj.step(1)
-+        assert qutip.expect(self.ada, state1) != (
-+            qutip.expect(self.ada, qutip.basis(self.N, 9))
-+        )
-+        state2 = solver_obj.step(2, args={"kappa":0.})
-+        np.testing.assert_allclose(qutip.expect(self.ada, state1),
-+                                   qutip.expect(self.ada, state2), 1e-6)
-+
-+
-+@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
-+                         ids=["ket", "dm", "liouvillian"])
-+def testME_SesolveFallback(super_):
-+    "mesolve: final_state has correct dims"
-+    N = 5
-+    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
-+    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
-+    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
-+    psi0 = qutip.tensor(qutip.basis(N+1,0),
-+                        qutip.basis(N+1,0),
-+                        qutip.basis(N+1,N))
-+    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
-+    if super_ == "dm":
-+        state0 = qutip.ket2dm(psi0)
-+    else:
-+        state0 = psi0
-+    if super_ == "liouvillian":
-+        H = qutip.liouvillian(H)
-+
-+    times = np.linspace(0.0, 0.1, 3)
-+    options = {
-+        "store_states": False,
-+        "store_final_state": True,
-+        "progress_bar": None
-+    }
-+    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
-+    if super_ == "ket":
-+        assert result.final_state.dims == psi0.dims
-+    else:
-+        assert result.final_state.dims == qutip.ket2dm(psi0).dims
-+
-+
-+class TestJCModelEvolution:
-+    """
-+    A test class for the QuTiP functions for the evolution of JC model
-+    """
-+    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
-+
-+        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
-+
-+        c_op_list = []
-+
-+        rate = g1
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
-+
-+        rate = g2
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
-+
-+        output = mesolve(H, psi0, tlist, c_op_list,
-+            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-+        )
-+
-+        return output.expect[0], output.expect[1], output.expect[2]
-+
-+    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
-+                       pump, psi0, use_rwa, tlist):
-+
-+        # Hamiltonian
-+        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
-+        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
-+
-+        if use_rwa:
-+            # use the rotating wave approxiation
-+            H = (wc * a.dag() * a + wa * sm.dag() * sm
-+                 + g * (a.dag() * sm + a * sm.dag()))
-+        else:
-+            H = (wc * a.dag() * a + wa * sm.dag() * sm
-+                 + g * (a.dag() + a) * (sm + sm.dag()))
-+
-+        # collapse operators
-+        c_op_list = []
-+
-+        n_th_a = 0.0  # zero temperature
-+
-+        rate = kappa * (1 + n_th_a)
-+        c_op_list.append(np.sqrt(rate) * a)
-+
-+        rate = kappa * n_th_a
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * a.dag())
-+
-+        rate = gamma
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * sm)
-+
-+        rate = pump
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * sm.dag())
-+
-+        # find the steady state
-+        rho_ss = qutip.steadystate(H, c_op_list)
-+
-+        return (qutip.expect(a.dag() * a, rho_ss),
-+                qutip.expect(sm.dag() * sm, rho_ss))
-+
-+    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
-+                     pump, psi0, use_rwa, tlist, oper_evo=False):
-+
-+        # Hamiltonian
-+        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
-+        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
-+
-+        # Identity super-operator
-+        E0 = qutip.sprepost(
-+            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
-+            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
-+        )
-+
-+        if use_rwa:
-+            # use the rotating wave approxiation
-+            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
-+                a.dag() * sm + a * sm.dag())
-+        else:
-+            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
-+                a.dag() + a) * (sm + sm.dag())
-+
-+        # collapse operators
-+        c_op_list = []
-+
-+        n_th_a = 0.0  # zero temperature
-+
-+        rate = kappa * (1 + n_th_a)
-+        c_op_list.append(np.sqrt(rate) * a)
-+
-+        rate = kappa * n_th_a
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * a.dag())
-+
-+        rate = gamma
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * sm)
-+
-+        rate = pump
-+        if rate > 0.0:
-+            c_op_list.append(np.sqrt(rate) * sm.dag())
-+
-+        options = {"store_states": True, "progress_bar": None}
-+
-+        # evolve and calculate expectation values
-+        output = mesolve(
-+            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
-+            options=options)
-+        if oper_evo:
-+            output2 = mesolve(H, E0, tlist, c_op_list, [])
-+            return output, output2
-+        return output.expect[0], output.expect[1]
-+
-+    def testSuperJC(self):
-+        "mesolve: super vs. density matrix as initial condition"
-+        me_error = 1e-6
-+
-+        use_rwa = True
-+        N = 4           # number of cavity fock states
-+        wc = 2 * np.pi * 1.0   # cavity frequency
-+        wa = 2 * np.pi * 1.0   # atom frequency
-+        g = 2 * np.pi * 0.1   # coupling strength
-+        kappa = 0.05    # cavity dissipation rate
-+        gamma = 0.001   # atom dissipation rate
-+        pump = 0.25    # atom pump rate
-+
-+        # start with an excited atom and maximum number of photons
-+        n = N - 2
-+        psi0 = qutip.basis([N, 2], [n, 1])
-+        rho0vec = qutip.operator_to_vector(psi0.proj())
-+        tlist = np.linspace(0, 100, 50)
-+
-+        out1, out2 = self.jc_integrate(
-+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
-+
-+        fid = fidelitycheck(out1, out2, rho0vec)
-+        assert fid == pytest.approx(1., abs=me_error)
-+
-+    def testQubitDynamics1(self):
-+        "mesolve: qubit with dissipation"
-+
-+        epsilon = 0.0 * 2 * np.pi   # cavity frequency
-+        delta = 1.0 * 2 * np.pi   # atom frequency
-+        g2 = 0.1
-+        g1 = 0.0
-+        psi0 = qutip.basis(2, 0)        # initial state
-+        tlist = np.linspace(0, 5, 200)
-+
-+        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
-+
-+        sx_analytic = np.zeros(np.shape(tlist))
-+        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+
-+        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
-+        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
-+        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
-+
-+    def testQubitDynamics2(self):
-+        "mesolve: qubit without dissipation"
-+
-+        epsilon = 0.0 * 2 * np.pi   # cavity frequency
-+        delta = 1.0 * 2 * np.pi   # atom frequency
-+        g2 = 0.0
-+        g1 = 0.0
-+        psi0 = qutip.basis(2, 0)        # initial state
-+        tlist = np.linspace(0, 5, 200)
-+
-+        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
-+
-+        sx_analytic = np.zeros(np.shape(tlist))
-+        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-+
-+        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
-+        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
-+        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
-+
-+    def testCavity1(self):
-+        "mesolve: cavity-qubit interaction, no dissipation"
-+
-+        use_rwa = True
-+        N = 4           # number of cavity fock states
-+        wc = 2 * np.pi * 1.0   # cavity frequency
-+        wa = 2 * np.pi * 1.0   # atom frequency
-+        g = 2 * np.pi * 0.01   # coupling strength
-+        kappa = 0.0     # cavity dissipation rate
-+        gamma = 0.0     # atom dissipation rate
-+        pump = 0.0      # atom pump rate
-+
-+        # start with an excited atom and maximum number of photons
-+        n = N - 2
-+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-+        tlist = np.linspace(0, 1000, 2000)
-+
-+        nc, na = self.jc_integrate(
-+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-+
-+        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
-+        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
-+
-+        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
-+        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
-+
-+    def testCavity2(self):
-+        "mesolve: cavity-qubit without interaction, decay"
-+
-+        use_rwa = True
-+        N = 4           # number of cavity fock states
-+        wc = 2 * np.pi * 1.0   # cavity frequency
-+        wa = 2 * np.pi * 1.0   # atom frequency
-+        g = 2 * np.pi * 0.0    # coupling strength
-+        kappa = 0.005   # cavity dissipation rate
-+        gamma = 0.01    # atom dissipation rate
-+        pump = 0.0      # atom pump rate
-+
-+        # start with an excited atom and maximum number of photons
-+        n = N - 2
-+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-+        tlist = np.linspace(0, 1000, 2000)
-+
-+        nc, na = self.jc_integrate(
-+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-+
-+        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
-+            np.exp(-kappa * tlist)
-+        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
-+            np.exp(-gamma * tlist)
-+
-+        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
-+        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
-+
-+    def testCavity3(self):
-+        "mesolve: cavity-qubit with interaction, decay"
-+
-+        use_rwa = True
-+        N = 4           # number of cavity fock states
-+        wc = 2 * np.pi * 1.0   # cavity frequency
-+        wa = 2 * np.pi * 1.0   # atom frequency
-+        g = 2 * np.pi * 0.1   # coupling strength
-+        kappa = 0.05    # cavity dissipation rate
-+        gamma = 0.001   # atom dissipation rate
-+        pump = 0.25    # atom pump rate
-+
-+        # start with an excited atom and maximum number of photons
-+        n = N - 2
-+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-+        tlist = np.linspace(0, 200, 500)
-+
-+        nc, na = self.jc_integrate(
-+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-+
-+        # we don't have any analytics for this parameters, so
-+        # compare with the steady state
-+        nc_ss, na_ss = self.jc_steadystate(
-+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-+
-+        nc_ss = nc_ss * np.ones(np.shape(nc))
-+        na_ss = na_ss * np.ones(np.shape(na))
-+
-+        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
-+        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
-+
-+
-+class TestMESolveStepFuncCoeff:
-+    """
-+    A Test class for using time-dependent array coefficients
-+    as step functions instead of doing interpolation
-+    """
-+    # Runge-Kutta method (dop853) behave better with step function evolution
-+    # than multi-step methods (adams, qutip 4's default)
-+    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
-+
-+    def python_coeff(self, t, args):
-+        if t < np.pi/2:
-+            return 1.
-+        else:
-+            return 0.
-+
-+    @pytest.mark.parametrize('method',
-+                             all_ode_method, ids=all_ode_method)
-+    def test_py_coeff(self, method):
-+        """
-+        Test for Python function as coefficient as step function coeff
-+        """
-+        rho0 = qutip.rand_ket(2)
-+        tlist = np.array([0, np.pi/2])
-+        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
-+        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
-+                     tlist=tlist, order=0)
-+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
-+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-+        assert fid == pytest.approx(1)
-+
-+    def test_array_cte_coeff(self):
-+        """
-+        Test for Array coefficient with uniform tlist as step function coeff
-+        """
-+        rho0 = qutip.rand_ket(2)
-+        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
-+        npcoeff = np.array([0.25, 0.75, 0.75])
-+        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
-+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-+        assert fid == pytest.approx(1)
-+
-+    def test_array_t_coeff(self):
-+        """
-+        Test for Array with non-uniform tlist as step function coeff
-+        """
-+        rho0 = qutip.rand_ket(2)
-+        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
-+        npcoeff = np.array([0.5, 0.25, 0.25])
-+        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
-+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-+        assert fid == pytest.approx(1)
-+
-+    def test_array_str_coeff(self):
-+        """
-+        Test for Array and string as step function coeff.
-+        qobjevo_codegen is used and uniform tlist
-+        """
-+        rho0 = qutip.rand_ket(2)
-+        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
-+        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
-+        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
-+        strcoeff = "1."
-+        qu = qutip.QobjEvo(
-+            [[qutip.sigmax(), npcoeff1],
-+             [qutip.sigmax(), strcoeff],
-+             [qutip.sigmax(), npcoeff2]],
-+            tlist=tlist, order=0)
-+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-+        assert fid == pytest.approx(1)
-+
-+    def test_array_str_py_coeff(self):
-+        """
-+        Test for Array, string and Python function as step function coeff.
-+        qobjevo_codegen is used and non non-uniform tlist
-+        """
-+        rho0 = qutip.rand_ket(2)
-+        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
-+        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
-+        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
-+        strcoeff = "1."
-+        qu = qutip.QobjEvo(
-+            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
-+             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
-+            tlist=tlist, order=0)
-+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-+        assert fid == pytest.approx(1)
-+
-+
-+def test_num_collapse_set():
-+    H = qutip.sigmaz()
-+    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-+    ts = [0, 1]
-+    for c_ops in (
-+        qutip.sigmax(),
-+        [qutip.sigmax()],
-+        [qutip.sigmay(), qutip.sigmax()],
-+    ):
-+        res = mesolve(H, psi, ts, c_ops=c_ops)
-+        if not isinstance(c_ops, list):
-+            c_ops = [c_ops]
-+        assert res.stats["num_collapse"] == len(c_ops)
-+
-+
-+def test_mesolve_bad_H():
-+    with pytest.raises(TypeError):
-+        MESolver([qutip.qeye(3), 't'], [])
-+    with pytest.raises(TypeError):
-+        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
-+
-+
-+def test_mesolve_bad_state():
-+    solver = MESolver(qutip.qeye(4), [])
-+    with pytest.raises(TypeError):
-+        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
-+
-+
-+def test_mesolve_bad_options():
-+    with pytest.raises(TypeError):
-+        MESolver(qutip.qeye(4), [], options=False)
-diff --git a/qutip/tests/solver/test_options.py b/qutip/tests/solver/test_options.py
-index 5f75405b..7337db1c 100644
---- a/qutip/tests/solver/test_options.py
-+++ b/qutip/tests/solver/test_options.py
-@@ -1,142 +1,142 @@
--import pytest
--import qutip
--import numpy as np
--from qutip.solver.options import _SolverOptions
--
--
--default = {
--    "opt1": False,
--    "opt2": True,
--    "opt3": None,
--}
--
--
--def test_default():
--    opt = _SolverOptions(default)
--    assert opt
--    assert default.keys() == opt.keys()
--    assert opt["opt1"] is False
--    assert opt["opt2"] is True
--    assert opt["opt3"] is None
--
--
--def test_SolverOptions_dictlike():
--    opt_dict = {
--        "opt1": True,
--        "opt2": None,
--    }
--    opt = _SolverOptions(default, **opt_dict)
--    assert opt
--    assert default.keys() == opt.keys()
--    assert opt["opt1"] is True
--    assert opt["opt2"] is None
--    assert opt["opt3"] is None
--
--    copy = opt.copy()
--    assert opt.items() == copy.items()
--    copy['opt3'] = 2
--    assert opt.items() != copy.items()
--
--    assert len(opt.values()) == 3
--    assert len(opt.items()) == 3
--    assert len(opt.keys()) == 3
--
--
--def test_del():
--    opt_dict = {
--        "opt1": True,
--    }
--    opt = _SolverOptions(default, opt1=True)
--    del opt["opt1"]
--    assert opt["opt1"] is False
--
--
--def test_SolverOptions_Feedback():
--    called = []
--
--    def _catch(keys):
--        assert isinstance(keys, (set, str))
--        called.append(keys)
--
--    opt = _SolverOptions(default, _catch)
--    opt["opt1"] = 2
--    opt["opt2"] = 1e-5
--
--    assert "opt1" in called
--    assert "opt2" in called
--    assert len(called) == 2
--
--
--def test_error():
--    with pytest.raises(KeyError) as err:
--        _SolverOptions(default, opt4=4)
--    assert "opt4" in str(err.value)
--
--    with pytest.raises(KeyError) as err:
--        opt = _SolverOptions(default)
--        opt["opt4"] = 4
--    assert "opt4" in str(err.value)
--
--
--def test_print():
--    opt = _SolverOptions(default, None, "Test options", "Custom doc")
--    assert "Test options" in opt.__str__()
--    assert "opt1 : False" in opt.__str__()
--    assert "opt2 : True" in opt.__str__()
--    assert "opt3 : None" in opt.__str__()
--    assert opt.__doc__ == "Custom doc"
--
--
--def test_in_solver():
--    opt = {"method": "adams", "store_states": True, "atol": 1}
--    solver = qutip.SESolver(qutip.qeye(1), options=opt)
--    adams = qutip.integrator.IntegratorScipyAdams
--    lsoda = qutip.integrator.IntegratorScipylsoda
--    bdf = qutip.integrator.IntegratorScipyBDF
--    assert solver.options["store_states"] is True
--    assert solver.options["method"] == "adams"
--    assert solver.options["atol"] == 1
--    assert solver.options["order"] == adams.integrator_options["order"]
--
--    solver.options["method"] = "bdf"
--    assert solver.options["store_states"] is True
--    assert solver.options["method"] == "bdf"
--    assert solver.options["atol"] == bdf.integrator_options["atol"]
--    assert solver.options["order"] == bdf.integrator_options["order"]
--
--    solver.options = {
--        "method": "vern7",
--        "store_final_state": True,
--        "atol": 0.01
--    }
--    assert solver.options["store_states"] is True
--    assert solver.options["store_final_state"] is True
--    assert solver.options["method"] == "vern7"
--    assert solver.options["atol"] == 0.01
--    assert "order" not in solver.options
--    assert "interpolate" in solver.options
--
--
--def test_options_update_solver():
--    opt = {"method": "adams", "normalize_output": False}
--    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
--
--    solver.start(qutip.basis(1), 0)
--    err_atol_def = (solver.step(1) - np.exp(1)).norm()
--
--    solver.options["atol"] = 1
--    solver.start(qutip.basis(1), 0)
--    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
--
--    del solver.options["atol"]
--    solver.start(qutip.basis(1), 0)
--    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
--
--    solver.options["atol"] = 1
--    solver.options["atol"] = None
--    solver.start(qutip.basis(1), 0)
--    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
--
--    solver.options["method"] = "diag"
--    solver.start(qutip.basis(1), 0)
--    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
-+import pytest
-+import qutip
-+import numpy as np
-+from qutip.solver.options import _SolverOptions
-+
-+
-+default = {
-+    "opt1": False,
-+    "opt2": True,
-+    "opt3": None,
-+}
-+
-+
-+def test_default():
-+    opt = _SolverOptions(default)
-+    assert opt
-+    assert default.keys() == opt.keys()
-+    assert opt["opt1"] is False
-+    assert opt["opt2"] is True
-+    assert opt["opt3"] is None
-+
-+
-+def test_SolverOptions_dictlike():
-+    opt_dict = {
-+        "opt1": True,
-+        "opt2": None,
-+    }
-+    opt = _SolverOptions(default, **opt_dict)
-+    assert opt
-+    assert default.keys() == opt.keys()
-+    assert opt["opt1"] is True
-+    assert opt["opt2"] is None
-+    assert opt["opt3"] is None
-+
-+    copy = opt.copy()
-+    assert opt.items() == copy.items()
-+    copy['opt3'] = 2
-+    assert opt.items() != copy.items()
-+
-+    assert len(opt.values()) == 3
-+    assert len(opt.items()) == 3
-+    assert len(opt.keys()) == 3
-+
-+
-+def test_del():
-+    opt_dict = {
-+        "opt1": True,
-+    }
-+    opt = _SolverOptions(default, opt1=True)
-+    del opt["opt1"]
-+    assert opt["opt1"] is False
-+
-+
-+def test_SolverOptions_Feedback():
-+    called = []
-+
-+    def _catch(keys):
-+        assert isinstance(keys, (set, str))
-+        called.append(keys)
-+
-+    opt = _SolverOptions(default, _catch)
-+    opt["opt1"] = 2
-+    opt["opt2"] = 1e-5
-+
-+    assert "opt1" in called
-+    assert "opt2" in called
-+    assert len(called) == 2
-+
-+
-+def test_error():
-+    with pytest.raises(KeyError) as err:
-+        _SolverOptions(default, opt4=4)
-+    assert "opt4" in str(err.value)
-+
-+    with pytest.raises(KeyError) as err:
-+        opt = _SolverOptions(default)
-+        opt["opt4"] = 4
-+    assert "opt4" in str(err.value)
-+
-+
-+def test_print():
-+    opt = _SolverOptions(default, None, "Test options", "Custom doc")
-+    assert "Test options" in opt.__str__()
-+    assert "opt1 : False" in opt.__str__()
-+    assert "opt2 : True" in opt.__str__()
-+    assert "opt3 : None" in opt.__str__()
-+    assert opt.__doc__ == "Custom doc"
-+
-+
-+def test_in_solver():
-+    opt = {"method": "adams", "store_states": True, "atol": 1}
-+    solver = qutip.SESolver(qutip.qeye(1), options=opt)
-+    adams = qutip.integrator.IntegratorScipyAdams
-+    lsoda = qutip.integrator.IntegratorScipylsoda
-+    bdf = qutip.integrator.IntegratorScipyBDF
-+    assert solver.options["store_states"] is True
-+    assert solver.options["method"] == "adams"
-+    assert solver.options["atol"] == 1
-+    assert solver.options["order"] == adams.integrator_options["order"]
-+
-+    solver.options["method"] = "bdf"
-+    assert solver.options["store_states"] is True
-+    assert solver.options["method"] == "bdf"
-+    assert solver.options["atol"] == bdf.integrator_options["atol"]
-+    assert solver.options["order"] == bdf.integrator_options["order"]
-+
-+    solver.options = {
-+        "method": "vern7",
-+        "store_final_state": True,
-+        "atol": 0.01
-+    }
-+    assert solver.options["store_states"] is True
-+    assert solver.options["store_final_state"] is True
-+    assert solver.options["method"] == "vern7"
-+    assert solver.options["atol"] == 0.01
-+    assert "order" not in solver.options
-+    assert "interpolate" in solver.options
-+
-+
-+def test_options_update_solver():
-+    opt = {"method": "adams", "normalize_output": False}
-+    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
-+
-+    solver.start(qutip.basis(1), 0)
-+    err_atol_def = (solver.step(1) - np.exp(1)).norm()
-+
-+    solver.options["atol"] = 1
-+    solver.start(qutip.basis(1), 0)
-+    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
-+
-+    del solver.options["atol"]
-+    solver.start(qutip.basis(1), 0)
-+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
-+
-+    solver.options["atol"] = 1
-+    solver.options["atol"] = None
-+    solver.start(qutip.basis(1), 0)
-+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
-+
-+    solver.options["method"] = "diag"
-+    solver.start(qutip.basis(1), 0)
-+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
-diff --git a/qutip/tests/solver/test_parallel.py b/qutip/tests/solver/test_parallel.py
-index 41636917..9d18a70d 100644
---- a/qutip/tests/solver/test_parallel.py
-+++ b/qutip/tests/solver/test_parallel.py
-@@ -1,121 +1,121 @@
--import numpy as np
--import time
--import pytest
--import threading
--
--from qutip.solver.parallel import (
--    parallel_map, serial_map, loky_pmap, MapExceptions
--)
--
--
--def _func1(x):
--    return x**2
--
--
--def _func2(x, a, b, c, d=0, e=0, f=0):
--    assert d > 0
--    assert e > 0
--    assert f > 0
--    time.sleep(np.random.rand() * 0.1)  # random delay
--    return x**2
--
--@pytest.mark.parametrize('map', [
--    pytest.param(parallel_map, id='parallel_map'),
--    pytest.param(loky_pmap, id='loky_pmap'),
--    pytest.param(serial_map, id='serial_map'),
--])
--@pytest.mark.parametrize('num_cpus',
--                         [1, 2],
--                         ids=['1', '2'])
--def test_map(map, num_cpus):
--    if map is loky_pmap:
--        loky = pytest.importorskip("loky")
--
--    args = (1, 2, 3)
--    kwargs = {'d': 4, 'e': 5, 'f': 6}
--    map_kw = {
--        'job_timeout': threading.TIMEOUT_MAX,
--        'timeout': threading.TIMEOUT_MAX,
--        'num_cpus': num_cpus,
--    }
--
--    x = np.arange(10)
--    y1 = [_func1(xx) for xx in x]
--
--    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
--    assert ((np.array(y1) == np.array(y2)).all())
--
--
--@pytest.mark.parametrize('map', [
--    pytest.param(parallel_map, id='parallel_map'),
--    pytest.param(loky_pmap, id='loky_pmap'),
--    pytest.param(serial_map, id='serial_map'),
--])
--@pytest.mark.parametrize('num_cpus',
--                         [1, 2],
--                         ids=['1', '2'])
--def test_map_accumulator(map, num_cpus):
--    if map is loky_pmap:
--        loky = pytest.importorskip("loky")
--    args = (1, 2, 3)
--    kwargs = {'d': 4, 'e': 5, 'f': 6}
--    map_kw = {
--        'job_timeout': threading.TIMEOUT_MAX,
--        'timeout': threading.TIMEOUT_MAX,
--        'num_cpus': num_cpus,
--    }
--    y2 = []
--
--    x = np.arange(10)
--    y1 = [_func1(xx) for xx in x]
--
--    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
--    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
--
--
--class CustomException(Exception):
--    pass
--
--
--def func(i):
--    if i % 2 == 1:
--        raise CustomException(f"Error in subprocess {i}")
--    return i
--
--
--@pytest.mark.parametrize('map', [
--    pytest.param(parallel_map, id='parallel_map'),
--    pytest.param(loky_pmap, id='loky_pmap'),
--    pytest.param(serial_map, id='serial_map'),
--])
--def test_map_pass_error(map):
--    if map is loky_pmap:
--        loky = pytest.importorskip("loky")
--
--    with pytest.raises(CustomException) as err:
--        map(func, range(10))
--    assert "Error in subprocess" in str(err.value)
--
--
--@pytest.mark.parametrize('map', [
--    pytest.param(parallel_map, id='parallel_map'),
--    pytest.param(loky_pmap, id='loky_pmap'),
--    pytest.param(serial_map, id='serial_map'),
--])
--def test_map_store_error(map):
--    if map is loky_pmap:
--        loky = pytest.importorskip("loky")
--
--    with pytest.raises(MapExceptions) as err:
--        map(func, range(10), map_kw={"fail_fast": False})
--    map_error = err.value
--    assert "iterations failed" in str(map_error)
--    for iter, error in map_error.errors.items():
--        assert isinstance(error, CustomException)
--        assert f"Error in subprocess {iter}" == str(error)
--    for n, result in enumerate(map_error.results):
--        if n % 2 == 0:
--            # Passed
--            assert result == n
--        else:
--            assert result is None
-+import numpy as np
-+import time
-+import pytest
-+import threading
-+
-+from qutip.solver.parallel import (
-+    parallel_map, serial_map, loky_pmap, MapExceptions
-+)
-+
-+
-+def _func1(x):
-+    return x**2
-+
-+
-+def _func2(x, a, b, c, d=0, e=0, f=0):
-+    assert d > 0
-+    assert e > 0
-+    assert f > 0
-+    time.sleep(np.random.rand() * 0.1)  # random delay
-+    return x**2
-+
-+@pytest.mark.parametrize('map', [
-+    pytest.param(parallel_map, id='parallel_map'),
-+    pytest.param(loky_pmap, id='loky_pmap'),
-+    pytest.param(serial_map, id='serial_map'),
-+])
-+@pytest.mark.parametrize('num_cpus',
-+                         [1, 2],
-+                         ids=['1', '2'])
-+def test_map(map, num_cpus):
-+    if map is loky_pmap:
-+        loky = pytest.importorskip("loky")
-+
-+    args = (1, 2, 3)
-+    kwargs = {'d': 4, 'e': 5, 'f': 6}
-+    map_kw = {
-+        'job_timeout': threading.TIMEOUT_MAX,
-+        'timeout': threading.TIMEOUT_MAX,
-+        'num_cpus': num_cpus,
-+    }
-+
-+    x = np.arange(10)
-+    y1 = [_func1(xx) for xx in x]
-+
-+    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
-+    assert ((np.array(y1) == np.array(y2)).all())
-+
-+
-+@pytest.mark.parametrize('map', [
-+    pytest.param(parallel_map, id='parallel_map'),
-+    pytest.param(loky_pmap, id='loky_pmap'),
-+    pytest.param(serial_map, id='serial_map'),
-+])
-+@pytest.mark.parametrize('num_cpus',
-+                         [1, 2],
-+                         ids=['1', '2'])
-+def test_map_accumulator(map, num_cpus):
-+    if map is loky_pmap:
-+        loky = pytest.importorskip("loky")
-+    args = (1, 2, 3)
-+    kwargs = {'d': 4, 'e': 5, 'f': 6}
-+    map_kw = {
-+        'job_timeout': threading.TIMEOUT_MAX,
-+        'timeout': threading.TIMEOUT_MAX,
-+        'num_cpus': num_cpus,
-+    }
-+    y2 = []
-+
-+    x = np.arange(10)
-+    y1 = [_func1(xx) for xx in x]
-+
-+    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
-+    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
-+
-+
-+class CustomException(Exception):
-+    pass
-+
-+
-+def func(i):
-+    if i % 2 == 1:
-+        raise CustomException(f"Error in subprocess {i}")
-+    return i
-+
-+
-+@pytest.mark.parametrize('map', [
-+    pytest.param(parallel_map, id='parallel_map'),
-+    pytest.param(loky_pmap, id='loky_pmap'),
-+    pytest.param(serial_map, id='serial_map'),
-+])
-+def test_map_pass_error(map):
-+    if map is loky_pmap:
-+        loky = pytest.importorskip("loky")
-+
-+    with pytest.raises(CustomException) as err:
-+        map(func, range(10))
-+    assert "Error in subprocess" in str(err.value)
-+
-+
-+@pytest.mark.parametrize('map', [
-+    pytest.param(parallel_map, id='parallel_map'),
-+    pytest.param(loky_pmap, id='loky_pmap'),
-+    pytest.param(serial_map, id='serial_map'),
-+])
-+def test_map_store_error(map):
-+    if map is loky_pmap:
-+        loky = pytest.importorskip("loky")
-+
-+    with pytest.raises(MapExceptions) as err:
-+        map(func, range(10), map_kw={"fail_fast": False})
-+    map_error = err.value
-+    assert "iterations failed" in str(map_error)
-+    for iter, error in map_error.errors.items():
-+        assert isinstance(error, CustomException)
-+        assert f"Error in subprocess {iter}" == str(error)
-+    for n, result in enumerate(map_error.results):
-+        if n % 2 == 0:
-+            # Passed
-+            assert result == n
-+        else:
-+            assert result is None
-diff --git a/qutip/tests/solver/test_propagator.py b/qutip/tests/solver/test_propagator.py
-index 2d36d9f9..0a7393ec 100644
---- a/qutip/tests/solver/test_propagator.py
-+++ b/qutip/tests/solver/test_propagator.py
-@@ -1,140 +1,140 @@
--import numpy as np
--from qutip import (destroy, propagator, Propagator, propagator_steadystate,
--                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
--import qutip
--import pytest
--from qutip.solver.brmesolve import BRSolver
--from qutip.solver.mesolve import MESolver
--from qutip.solver.sesolve import SESolver
--from qutip.solver.mcsolve import MCSolver
--
--
--def testPropHOB():
--    a = destroy(5)
--    H = a.dag()*a
--    U = propagator(H, 1)
--    U2 = (-1j * H).expm()
--    assert (U - U2).norm('max') < 1e-4
--
--
--def testPropObj():
--    opt = {"method": "dop853"}
--    a = destroy(5)
--    H = a.dag()*a
--    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
--    # Few call to fill the stored propagators.
--    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
--    assert len(U.times) == 5
--    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
--    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
--    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
--    # Within tol, should use the precomupted value at U(0.5)
--    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
--
--
--def func(t):
--    return np.cos(t)
--
--
--def testPropHOTd():
--    "Propagator: func td format"
--    a = destroy(5)
--    H = a.dag()*a
--    Htd = [H, [H, func]]
--    U = propagator(Htd, 1)
--    ts = np.linspace(0, 1, 101)
--    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
--    assert (U - U2).norm('max') < 1e-4
--
--
--def testPropObjTd():
--    a = destroy(5)
--    H = a.dag()*a
--    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
--    assert (
--        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
--    ).norm('max') < 1e-4
--    assert (
--        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
--    ).norm('max') < 1e-4
--    assert (
--        U(1.5, 0.5, w=1.5)
--        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
--    ).norm('max') < 1e-4
--
--
--def testPropHOSteady():
--    "Propagator: steady state"
--    a = destroy(5)
--    H = a.dag()*a
--    c_op_list = []
--    kappa = 0.1
--    n_th = 2
--    rate = kappa * (1 + n_th)
--    c_op_list.append(np.sqrt(rate) * a)
--    rate = kappa * n_th
--    c_op_list.append(np.sqrt(rate) * a.dag())
--    U = propagator(H, 2*np.pi, c_op_list)
--    rho_prop = propagator_steadystate(U)
--    rho_ss = steadystate(H, c_op_list)
--    assert (rho_prop - rho_ss).norm('max') < 1e-4
--
--
--def testPropHDims():
--    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
--    H = tensor([qeye(2), qeye(2)])
--    U = propagator(H, 1)
--    assert U.dims == H.dims
--
--
--def testPropEvo():
--    a = destroy(5)
--    H = a.dag()*a
--    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
--    psi = QobjEvo(U) @ basis(5, 4)
--    tlist = np.linspace(0, 1, 6)
--    psi_expected = sesolve(
--        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
--    ).states
--    for t, psi_t in zip(tlist, psi_expected):
--        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
--
--
--def _make_se(H, a):
--    return SESolver(H)
--
--
--def _make_me(H, a):
--    return MESolver(H, [a])
--
--
--def _make_br(H, a):
--    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
--    return BRSolver(H, [(a+a.dag(), spectra)])
--
--
--@pytest.mark.parametrize('solver', [
--    pytest.param(_make_se, id='SESolver'),
--    pytest.param(_make_me, id='MESolver'),
--    pytest.param(_make_br, id='BRSolver'),
--])
--def testPropSolver(solver):
--    a = destroy(5)
--    H = a.dag()*a
--    U = Propagator(solver(H, a))
--    c_ops = []
--    if solver is not _make_se:
--        c_ops = [a]
--
--    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
--    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
--    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
--
--
--def testPropMCSolver():
--    a = destroy(5)
--    H = a.dag()*a
--    solver = MCSolver(H, [a])
--    with pytest.raises(TypeError) as err:
--        Propagator(solver)
--    assert str(err.value).startswith("Non-deterministic")
-+import numpy as np
-+from qutip import (destroy, propagator, Propagator, propagator_steadystate,
-+                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
-+import qutip
-+import pytest
-+from qutip.solver.brmesolve import BRSolver
-+from qutip.solver.mesolve import MESolver
-+from qutip.solver.sesolve import SESolver
-+from qutip.solver.mcsolve import MCSolver
-+
-+
-+def testPropHOB():
-+    a = destroy(5)
-+    H = a.dag()*a
-+    U = propagator(H, 1)
-+    U2 = (-1j * H).expm()
-+    assert (U - U2).norm('max') < 1e-4
-+
-+
-+def testPropObj():
-+    opt = {"method": "dop853"}
-+    a = destroy(5)
-+    H = a.dag()*a
-+    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
-+    # Few call to fill the stored propagators.
-+    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
-+    assert len(U.times) == 5
-+    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
-+    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
-+    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
-+    # Within tol, should use the precomupted value at U(0.5)
-+    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
-+
-+
-+def func(t):
-+    return np.cos(t)
-+
-+
-+def testPropHOTd():
-+    "Propagator: func td format"
-+    a = destroy(5)
-+    H = a.dag()*a
-+    Htd = [H, [H, func]]
-+    U = propagator(Htd, 1)
-+    ts = np.linspace(0, 1, 101)
-+    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
-+    assert (U - U2).norm('max') < 1e-4
-+
-+
-+def testPropObjTd():
-+    a = destroy(5)
-+    H = a.dag()*a
-+    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
-+    assert (
-+        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
-+    ).norm('max') < 1e-4
-+    assert (
-+        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
-+    ).norm('max') < 1e-4
-+    assert (
-+        U(1.5, 0.5, w=1.5)
-+        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
-+    ).norm('max') < 1e-4
-+
-+
-+def testPropHOSteady():
-+    "Propagator: steady state"
-+    a = destroy(5)
-+    H = a.dag()*a
-+    c_op_list = []
-+    kappa = 0.1
-+    n_th = 2
-+    rate = kappa * (1 + n_th)
-+    c_op_list.append(np.sqrt(rate) * a)
-+    rate = kappa * n_th
-+    c_op_list.append(np.sqrt(rate) * a.dag())
-+    U = propagator(H, 2*np.pi, c_op_list)
-+    rho_prop = propagator_steadystate(U)
-+    rho_ss = steadystate(H, c_op_list)
-+    assert (rho_prop - rho_ss).norm('max') < 1e-4
-+
-+
-+def testPropHDims():
-+    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
-+    H = tensor([qeye(2), qeye(2)])
-+    U = propagator(H, 1)
-+    assert U.dims == H.dims
-+
-+
-+def testPropEvo():
-+    a = destroy(5)
-+    H = a.dag()*a
-+    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
-+    psi = QobjEvo(U) @ basis(5, 4)
-+    tlist = np.linspace(0, 1, 6)
-+    psi_expected = sesolve(
-+        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
-+    ).states
-+    for t, psi_t in zip(tlist, psi_expected):
-+        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
-+
-+
-+def _make_se(H, a):
-+    return SESolver(H)
-+
-+
-+def _make_me(H, a):
-+    return MESolver(H, [a])
-+
-+
-+def _make_br(H, a):
-+    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
-+    return BRSolver(H, [(a+a.dag(), spectra)])
-+
-+
-+@pytest.mark.parametrize('solver', [
-+    pytest.param(_make_se, id='SESolver'),
-+    pytest.param(_make_me, id='MESolver'),
-+    pytest.param(_make_br, id='BRSolver'),
-+])
-+def testPropSolver(solver):
-+    a = destroy(5)
-+    H = a.dag()*a
-+    U = Propagator(solver(H, a))
-+    c_ops = []
-+    if solver is not _make_se:
-+        c_ops = [a]
-+
-+    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
-+    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
-+    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
-+
-+
-+def testPropMCSolver():
-+    a = destroy(5)
-+    H = a.dag()*a
-+    solver = MCSolver(H, [a])
-+    with pytest.raises(TypeError) as err:
-+        Propagator(solver)
-+    assert str(err.value).startswith("Non-deterministic")
-diff --git a/qutip/tests/solver/test_results.py b/qutip/tests/solver/test_results.py
-index 3aa46982..2bcfa2e9 100644
---- a/qutip/tests/solver/test_results.py
-+++ b/qutip/tests/solver/test_results.py
-@@ -1,352 +1,352 @@
--import numpy as np
--import pytest
--
--import qutip
--from qutip.solver.result import Result, MultiTrajResult, McResult
--
--
--def fill_options(**kwargs):
--    return {
--        "store_states": None,
--        "store_final_state": False,
--        "keep_runs_results": False,
--        **kwargs
--    }
--
--
--def e_op_state_by_time(t, state):
--    """ An e_ops function that returns the state multiplied by the time. """
--    return t * state
--
--
--class TestResult:
--    @pytest.mark.parametrize(["N", "e_ops", "options"], [
--        pytest.param(10, (), {}, id="no-e-ops"),
--        pytest.param(
--            10, qutip.create(10), {"store_states": True}, id="store-states",
--        )
--    ])
--    def test_states(self, N, e_ops, options):
--        res = Result(e_ops, fill_options(**options))
--        for i in range(N):
--            res.add(i, qutip.basis(N, i))
--        np.testing.assert_allclose(np.array(res.times), np.arange(N))
--        assert res.states == [qutip.basis(N, i) for i in range(N)]
--        assert res.final_state == qutip.basis(N, N-1)
--
--    @pytest.mark.parametrize(["N", "e_ops", "options"], [
--        pytest.param(10, (), {
--            "store_states": False, "store_final_state": True
--        }, id="no-e-ops"),
--        pytest.param(10, qutip.create(10), {
--            "store_final_state": True,
--        }, id="with-eops"),
--    ])
--    def test_final_state_only(self, N, e_ops, options):
--        res = Result(e_ops, fill_options(**options))
--        for i in range(N):
--            res.add(i, qutip.basis(N, i))
--        np.testing.assert_allclose(np.array(res.times), np.arange(N))
--        assert res.states == []
--        assert res.final_state == qutip.basis(N, N-1)
--
--    @pytest.mark.parametrize(["N", "e_ops", "results"], [
--        pytest.param(
--            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
--        ),
--        pytest.param(
--            10,
--            [qutip.num(10), qutip.qeye(10)],
--            {0: np.arange(10), 1: np.ones(10)},
--            id="list-e-ops",
--        ),
--        pytest.param(
--            10,
--            {"a": qutip.num(10), "b": qutip.qeye(10)},
--            {"a": np.arange(10), "b": np.ones(10)},
--            id="dict-e-ops",
--        ),
--        pytest.param(
--            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
--        ),
--        pytest.param(
--            5, e_op_state_by_time,
--            {0: [i * qutip.basis(5, i) for i in range(5)]},
--            id="function",
--        )
--    ])
--    def test_expect_and_e_ops(self, N, e_ops, results):
--        res = Result(
--            e_ops,
--            fill_options(
--                store_final_state=False,
--                store_states=False),
--        )
--        if isinstance(e_ops, dict):
--            raw_ops = e_ops
--        elif isinstance(e_ops, (list, tuple)):
--            raw_ops = dict(enumerate(e_ops))
--        else:
--            raw_ops = {0: e_ops}
--        for i in range(N):
--            res.add(i, qutip.basis(N, i))
--        np.testing.assert_allclose(np.array(res.times), np.arange(N))
--        assert res.final_state is None
--        assert not res.states
--        for i, k in enumerate(results):
--            assert res.e_ops[k].op is raw_ops[k]
--            e_op_call_values = [
--                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
--            ]
--            if isinstance(res.expect[i][0], qutip.Qobj):
--                assert (res.expect[i] == results[k]).all()
--                assert res.e_data[k] == results[k]
--                assert e_op_call_values == results[k]
--            else:
--                np.testing.assert_allclose(res.expect[i], results[k])
--                np.testing.assert_allclose(res.e_data[k], results[k])
--                np.testing.assert_allclose(e_op_call_values, results[k])
--
--    def test_add_processor(self):
--        res = Result([], fill_options(store_states=False))
--        a = []
--        b = []
--        states = [{"t": 0}, {"t": 1}]
--
--        res.add_processor(lambda t, state: a.append((t, state)))
--        res.add(0, states[0])
--        res.add_processor(
--            lambda t, state: b.append((t, state)),
--            requires_copy=True,
--        )
--        res.add(1, states[1])
--
--        assert a == [(0, {"t": 0}), (1, {"t": 1})]
--        assert a[0][1] is states[0]  # no copy made
--        assert a[1][1] is not states[1]  # copy made (for b)
--        assert b == [(1, {"t": 1})]
--        assert b[0][1] is not states[1]  # copy made
--
--    def test_repr_minimal(self):
--        res = Result(
--            [],
--            fill_options(store_final_state=False, store_states=False),
--        )
--        assert repr(res) == "\n".join([
--            "<Result",
--            "  Solver: None",
--            "  Number of e_ops: 0",
--            "  State not saved.",
--            ">",
--        ])
--
--    def test_repr_full(self):
--        res = Result(
--            [qutip.num(5), qutip.qeye(5)],
--            fill_options(store_states=True),
--            solver="test-solver",
--            stats={"stat-a": 1, "stat-b": 2},
--        )
--        for i in range(5):
--            res.add(i, qutip.basis(5, i))
--        assert repr(res) == "\n".join([
--            "<Result",
--            "  Solver: test-solver",
--            "  Solver stats:",
--            "    stat-a: 1",
--            "    stat-b: 2",
--            "  Time interval: [0, 4] (5 steps)",
--            "  Number of e_ops: 2",
--            "  States saved.",
--            ">",
--        ])
--
--
--def e_op_num(t, state):
--    """ An e_ops function that returns the ground state occupation. """
--    return state.dag() @ qutip.num(5) @ state
--
--
--class TestMultiTrajResult:
--    def _fill_trajectories(self, multiresult, N, ntraj,
--                           collapse=False, noise=0, dm=False):
--        for _ in range(ntraj):
--            result = Result(multiresult._raw_ops, multiresult.options)
--            result.collapse = []
--            for t in range(N):
--                delta = 1 + noise * np.random.randn()
--                state = qutip.basis(N, t) * delta
--                if dm:
--                    state = state.proj()
--                result.add(t, state)
--                if collapse:
--                    result.collapse.append((t+0.1, 0))
--                    result.collapse.append((t+0.2, 1))
--                    result.collapse.append((t+0.3, 1))
--            if multiresult.add((0, result)) <= 0:
--                break
--
--    def _expect_check_types(self, multiresult):
--        assert isinstance(multiresult.std_expect, list)
--        assert isinstance(multiresult.average_e_data, dict)
--        assert isinstance(multiresult.std_expect, list)
--        assert isinstance(multiresult.average_e_data, dict)
--
--        if multiresult.trajectories:
--            assert isinstance(multiresult.runs_expect, list)
--            assert isinstance(multiresult.runs_e_data, dict)
--        else:
--            assert multiresult.runs_expect == []
--            assert multiresult.runs_e_data == {}
--
--    @pytest.mark.parametrize('keep_runs_results', [True, False])
--    @pytest.mark.parametrize('dm', [True, False])
--    def test_McResult(self, dm, keep_runs_results):
--        N = 10
--        ntraj = 5
--        e_ops = [qutip.num(N), qutip.qeye(N)]
--        opt = fill_options(keep_runs_results=keep_runs_results)
--
--        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
--        m_res.add_end_condition(ntraj, None)
--        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
--
--        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
--        assert m_res.stats['end_condition'] == "ntraj reached"
--        self._expect_check_types(m_res)
--
--        assert np.all(np.array(m_res.col_which) < 2)
--        assert isinstance(m_res.collapse, list)
--        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
--        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
--        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
--
--    @pytest.mark.parametrize('keep_runs_results', [True, False])
--    @pytest.mark.parametrize(["e_ops", "results"], [
--        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
--        pytest.param(
--            {"a": qutip.num(5), "b": qutip.qeye(5)},
--            [np.arange(5), np.ones(5)],
--            id="dict-e-ops",
--        ),
--        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
--        pytest.param(e_op_num, [np.arange(5)], id="function"),
--        pytest.param(
--            [qutip.num(5), e_op_num],
--            [np.arange(5), np.arange(5)],
--            id="list-e-ops",
--        ),
--    ])
--    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
--        N = 5
--        ntraj = 25
--        opt = fill_options(keep_runs_results=keep_runs_results)
--        m_res = MultiTrajResult(e_ops, opt, stats={})
--        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
--
--        for expect, expected in zip(m_res.average_expect, results):
--            np.testing.assert_allclose(expect, expected,
--                                       atol=1e-14, rtol=0.02)
--
--        for variance, expected in zip(m_res.std_expect, results):
--            np.testing.assert_allclose(variance, 0.02 * expected,
--                                       atol=1e-14, rtol=0.9)
--
--        if keep_runs_results:
--            for runs_expect, expected in zip(m_res.runs_expect, results):
--                for expect in runs_expect:
--                    np.testing.assert_allclose(expect, expected,
--                                               atol=1e-14, rtol=0.1)
--
--        self._expect_check_types(m_res)
--
--        assert m_res.stats['end_condition'] == "unknown"
--
--    @pytest.mark.parametrize('keep_runs_results', [True, False])
--    @pytest.mark.parametrize('dm', [True, False])
--    def test_multitraj_state(self, keep_runs_results, dm):
--        N = 5
--        ntraj = 25
--        opt = fill_options(keep_runs_results=keep_runs_results)
--        m_res = MultiTrajResult([], opt)
--        self._fill_trajectories(m_res, N, ntraj, dm=dm)
--
--        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
--
--        for i in range(N):
--            assert m_res.average_states[i] == qutip.fock_dm(N, i)
--        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
--
--        if keep_runs_results:
--            assert len(m_res.runs_states) == 25
--            assert len(m_res.runs_states[0]) == N
--            for i in range(ntraj):
--                expected = qutip.basis(N, N-1)
--                if dm:
--                    expected = expected.proj()
--                assert m_res.runs_final_states[i] == expected
--
--    @pytest.mark.parametrize('keep_runs_results', [True, False])
--    @pytest.mark.parametrize('targettol', [
--        pytest.param(0.1, id='atol'),
--        pytest.param([0.001, 0.1], id='rtol'),
--        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
--    ])
--    def test_multitraj_targettol(self, keep_runs_results, targettol):
--        N = 10
--        ntraj = 1000
--        opt = fill_options(
--            keep_runs_results=keep_runs_results, store_states=True
--        )
--        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
--        m_res.add_end_condition(ntraj, targettol)
--        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
--
--        assert m_res.stats['end_condition'] == "target tolerance reached"
--        assert m_res.num_trajectories <= 1000
--
--    def test_multitraj_steadystate(self):
--        N = 5
--        ntraj = 100
--        opt = fill_options()
--        m_res = MultiTrajResult([], opt, stats={})
--        m_res.add_end_condition(1000)
--        self._fill_trajectories(m_res, N, ntraj)
--        assert m_res.stats['end_condition'] == "timeout"
--        assert m_res.steady_state() == qutip.qeye(5) / 5
--
--    @pytest.mark.parametrize('keep_runs_results', [True, False])
--    def test_repr(self, keep_runs_results):
--        N = 10
--        ntraj = 10
--        opt = fill_options(keep_runs_results=keep_runs_results)
--        m_res = MultiTrajResult([], opt)
--        self._fill_trajectories(m_res, N, ntraj)
--        repr = m_res.__repr__()
--        assert "Number of trajectories: 10" in repr
--        if keep_runs_results:
--            assert "Trajectories saved." in repr
--
--    @pytest.mark.parametrize('keep_runs_results', [True, False])
--    def test_merge_result(self, keep_runs_results):
--        N = 10
--        opt = fill_options(
--            keep_runs_results=keep_runs_results, store_states=True
--        )
--        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
--        self._fill_trajectories(m_res1, N, 10, noise=0.1)
--
--        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
--        self._fill_trajectories(m_res2, N, 30, noise=0.1)
--
--        merged_res = m_res1 + m_res2
--        assert merged_res.num_trajectories == 40
--        np.testing.assert_allclose(merged_res.average_expect[0],
--                                   np.arange(10), rtol=0.1)
--        np.testing.assert_allclose(
--            np.diag(sum(merged_res.average_states).full()),
--            np.ones(N),
--            rtol=0.1
--        )
--        assert bool(merged_res.trajectories) == keep_runs_results
--        assert merged_res.stats["run time"] == 3
-+import numpy as np
-+import pytest
-+
-+import qutip
-+from qutip.solver.result import Result, MultiTrajResult, McResult
-+
-+
-+def fill_options(**kwargs):
-+    return {
-+        "store_states": None,
-+        "store_final_state": False,
-+        "keep_runs_results": False,
-+        **kwargs
-+    }
-+
-+
-+def e_op_state_by_time(t, state):
-+    """ An e_ops function that returns the state multiplied by the time. """
-+    return t * state
-+
-+
-+class TestResult:
-+    @pytest.mark.parametrize(["N", "e_ops", "options"], [
-+        pytest.param(10, (), {}, id="no-e-ops"),
-+        pytest.param(
-+            10, qutip.create(10), {"store_states": True}, id="store-states",
-+        )
-+    ])
-+    def test_states(self, N, e_ops, options):
-+        res = Result(e_ops, fill_options(**options))
-+        for i in range(N):
-+            res.add(i, qutip.basis(N, i))
-+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-+        assert res.states == [qutip.basis(N, i) for i in range(N)]
-+        assert res.final_state == qutip.basis(N, N-1)
-+
-+    @pytest.mark.parametrize(["N", "e_ops", "options"], [
-+        pytest.param(10, (), {
-+            "store_states": False, "store_final_state": True
-+        }, id="no-e-ops"),
-+        pytest.param(10, qutip.create(10), {
-+            "store_final_state": True,
-+        }, id="with-eops"),
-+    ])
-+    def test_final_state_only(self, N, e_ops, options):
-+        res = Result(e_ops, fill_options(**options))
-+        for i in range(N):
-+            res.add(i, qutip.basis(N, i))
-+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-+        assert res.states == []
-+        assert res.final_state == qutip.basis(N, N-1)
-+
-+    @pytest.mark.parametrize(["N", "e_ops", "results"], [
-+        pytest.param(
-+            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
-+        ),
-+        pytest.param(
-+            10,
-+            [qutip.num(10), qutip.qeye(10)],
-+            {0: np.arange(10), 1: np.ones(10)},
-+            id="list-e-ops",
-+        ),
-+        pytest.param(
-+            10,
-+            {"a": qutip.num(10), "b": qutip.qeye(10)},
-+            {"a": np.arange(10), "b": np.ones(10)},
-+            id="dict-e-ops",
-+        ),
-+        pytest.param(
-+            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
-+        ),
-+        pytest.param(
-+            5, e_op_state_by_time,
-+            {0: [i * qutip.basis(5, i) for i in range(5)]},
-+            id="function",
-+        )
-+    ])
-+    def test_expect_and_e_ops(self, N, e_ops, results):
-+        res = Result(
-+            e_ops,
-+            fill_options(
-+                store_final_state=False,
-+                store_states=False),
-+        )
-+        if isinstance(e_ops, dict):
-+            raw_ops = e_ops
-+        elif isinstance(e_ops, (list, tuple)):
-+            raw_ops = dict(enumerate(e_ops))
-+        else:
-+            raw_ops = {0: e_ops}
-+        for i in range(N):
-+            res.add(i, qutip.basis(N, i))
-+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-+        assert res.final_state is None
-+        assert not res.states
-+        for i, k in enumerate(results):
-+            assert res.e_ops[k].op is raw_ops[k]
-+            e_op_call_values = [
-+                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
-+            ]
-+            if isinstance(res.expect[i][0], qutip.Qobj):
-+                assert (res.expect[i] == results[k]).all()
-+                assert res.e_data[k] == results[k]
-+                assert e_op_call_values == results[k]
-+            else:
-+                np.testing.assert_allclose(res.expect[i], results[k])
-+                np.testing.assert_allclose(res.e_data[k], results[k])
-+                np.testing.assert_allclose(e_op_call_values, results[k])
-+
-+    def test_add_processor(self):
-+        res = Result([], fill_options(store_states=False))
-+        a = []
-+        b = []
-+        states = [{"t": 0}, {"t": 1}]
-+
-+        res.add_processor(lambda t, state: a.append((t, state)))
-+        res.add(0, states[0])
-+        res.add_processor(
-+            lambda t, state: b.append((t, state)),
-+            requires_copy=True,
-+        )
-+        res.add(1, states[1])
-+
-+        assert a == [(0, {"t": 0}), (1, {"t": 1})]
-+        assert a[0][1] is states[0]  # no copy made
-+        assert a[1][1] is not states[1]  # copy made (for b)
-+        assert b == [(1, {"t": 1})]
-+        assert b[0][1] is not states[1]  # copy made
-+
-+    def test_repr_minimal(self):
-+        res = Result(
-+            [],
-+            fill_options(store_final_state=False, store_states=False),
-+        )
-+        assert repr(res) == "\n".join([
-+            "<Result",
-+            "  Solver: None",
-+            "  Number of e_ops: 0",
-+            "  State not saved.",
-+            ">",
-+        ])
-+
-+    def test_repr_full(self):
-+        res = Result(
-+            [qutip.num(5), qutip.qeye(5)],
-+            fill_options(store_states=True),
-+            solver="test-solver",
-+            stats={"stat-a": 1, "stat-b": 2},
-+        )
-+        for i in range(5):
-+            res.add(i, qutip.basis(5, i))
-+        assert repr(res) == "\n".join([
-+            "<Result",
-+            "  Solver: test-solver",
-+            "  Solver stats:",
-+            "    stat-a: 1",
-+            "    stat-b: 2",
-+            "  Time interval: [0, 4] (5 steps)",
-+            "  Number of e_ops: 2",
-+            "  States saved.",
-+            ">",
-+        ])
-+
-+
-+def e_op_num(t, state):
-+    """ An e_ops function that returns the ground state occupation. """
-+    return state.dag() @ qutip.num(5) @ state
-+
-+
-+class TestMultiTrajResult:
-+    def _fill_trajectories(self, multiresult, N, ntraj,
-+                           collapse=False, noise=0, dm=False):
-+        for _ in range(ntraj):
-+            result = Result(multiresult._raw_ops, multiresult.options)
-+            result.collapse = []
-+            for t in range(N):
-+                delta = 1 + noise * np.random.randn()
-+                state = qutip.basis(N, t) * delta
-+                if dm:
-+                    state = state.proj()
-+                result.add(t, state)
-+                if collapse:
-+                    result.collapse.append((t+0.1, 0))
-+                    result.collapse.append((t+0.2, 1))
-+                    result.collapse.append((t+0.3, 1))
-+            if multiresult.add((0, result)) <= 0:
-+                break
-+
-+    def _expect_check_types(self, multiresult):
-+        assert isinstance(multiresult.std_expect, list)
-+        assert isinstance(multiresult.average_e_data, dict)
-+        assert isinstance(multiresult.std_expect, list)
-+        assert isinstance(multiresult.average_e_data, dict)
-+
-+        if multiresult.trajectories:
-+            assert isinstance(multiresult.runs_expect, list)
-+            assert isinstance(multiresult.runs_e_data, dict)
-+        else:
-+            assert multiresult.runs_expect == []
-+            assert multiresult.runs_e_data == {}
-+
-+    @pytest.mark.parametrize('keep_runs_results', [True, False])
-+    @pytest.mark.parametrize('dm', [True, False])
-+    def test_McResult(self, dm, keep_runs_results):
-+        N = 10
-+        ntraj = 5
-+        e_ops = [qutip.num(N), qutip.qeye(N)]
-+        opt = fill_options(keep_runs_results=keep_runs_results)
-+
-+        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
-+        m_res.add_end_condition(ntraj, None)
-+        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
-+
-+        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
-+        assert m_res.stats['end_condition'] == "ntraj reached"
-+        self._expect_check_types(m_res)
-+
-+        assert np.all(np.array(m_res.col_which) < 2)
-+        assert isinstance(m_res.collapse, list)
-+        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
-+        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
-+        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
-+
-+    @pytest.mark.parametrize('keep_runs_results', [True, False])
-+    @pytest.mark.parametrize(["e_ops", "results"], [
-+        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
-+        pytest.param(
-+            {"a": qutip.num(5), "b": qutip.qeye(5)},
-+            [np.arange(5), np.ones(5)],
-+            id="dict-e-ops",
-+        ),
-+        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
-+        pytest.param(e_op_num, [np.arange(5)], id="function"),
-+        pytest.param(
-+            [qutip.num(5), e_op_num],
-+            [np.arange(5), np.arange(5)],
-+            id="list-e-ops",
-+        ),
-+    ])
-+    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
-+        N = 5
-+        ntraj = 25
-+        opt = fill_options(keep_runs_results=keep_runs_results)
-+        m_res = MultiTrajResult(e_ops, opt, stats={})
-+        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
-+
-+        for expect, expected in zip(m_res.average_expect, results):
-+            np.testing.assert_allclose(expect, expected,
-+                                       atol=1e-14, rtol=0.02)
-+
-+        for variance, expected in zip(m_res.std_expect, results):
-+            np.testing.assert_allclose(variance, 0.02 * expected,
-+                                       atol=1e-14, rtol=0.9)
-+
-+        if keep_runs_results:
-+            for runs_expect, expected in zip(m_res.runs_expect, results):
-+                for expect in runs_expect:
-+                    np.testing.assert_allclose(expect, expected,
-+                                               atol=1e-14, rtol=0.1)
-+
-+        self._expect_check_types(m_res)
-+
-+        assert m_res.stats['end_condition'] == "unknown"
-+
-+    @pytest.mark.parametrize('keep_runs_results', [True, False])
-+    @pytest.mark.parametrize('dm', [True, False])
-+    def test_multitraj_state(self, keep_runs_results, dm):
-+        N = 5
-+        ntraj = 25
-+        opt = fill_options(keep_runs_results=keep_runs_results)
-+        m_res = MultiTrajResult([], opt)
-+        self._fill_trajectories(m_res, N, ntraj, dm=dm)
-+
-+        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
-+
-+        for i in range(N):
-+            assert m_res.average_states[i] == qutip.fock_dm(N, i)
-+        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
-+
-+        if keep_runs_results:
-+            assert len(m_res.runs_states) == 25
-+            assert len(m_res.runs_states[0]) == N
-+            for i in range(ntraj):
-+                expected = qutip.basis(N, N-1)
-+                if dm:
-+                    expected = expected.proj()
-+                assert m_res.runs_final_states[i] == expected
-+
-+    @pytest.mark.parametrize('keep_runs_results', [True, False])
-+    @pytest.mark.parametrize('targettol', [
-+        pytest.param(0.1, id='atol'),
-+        pytest.param([0.001, 0.1], id='rtol'),
-+        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
-+    ])
-+    def test_multitraj_targettol(self, keep_runs_results, targettol):
-+        N = 10
-+        ntraj = 1000
-+        opt = fill_options(
-+            keep_runs_results=keep_runs_results, store_states=True
-+        )
-+        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
-+        m_res.add_end_condition(ntraj, targettol)
-+        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
-+
-+        assert m_res.stats['end_condition'] == "target tolerance reached"
-+        assert m_res.num_trajectories <= 1000
-+
-+    def test_multitraj_steadystate(self):
-+        N = 5
-+        ntraj = 100
-+        opt = fill_options()
-+        m_res = MultiTrajResult([], opt, stats={})
-+        m_res.add_end_condition(1000)
-+        self._fill_trajectories(m_res, N, ntraj)
-+        assert m_res.stats['end_condition'] == "timeout"
-+        assert m_res.steady_state() == qutip.qeye(5) / 5
-+
-+    @pytest.mark.parametrize('keep_runs_results', [True, False])
-+    def test_repr(self, keep_runs_results):
-+        N = 10
-+        ntraj = 10
-+        opt = fill_options(keep_runs_results=keep_runs_results)
-+        m_res = MultiTrajResult([], opt)
-+        self._fill_trajectories(m_res, N, ntraj)
-+        repr = m_res.__repr__()
-+        assert "Number of trajectories: 10" in repr
-+        if keep_runs_results:
-+            assert "Trajectories saved." in repr
-+
-+    @pytest.mark.parametrize('keep_runs_results', [True, False])
-+    def test_merge_result(self, keep_runs_results):
-+        N = 10
-+        opt = fill_options(
-+            keep_runs_results=keep_runs_results, store_states=True
-+        )
-+        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
-+        self._fill_trajectories(m_res1, N, 10, noise=0.1)
-+
-+        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
-+        self._fill_trajectories(m_res2, N, 30, noise=0.1)
-+
-+        merged_res = m_res1 + m_res2
-+        assert merged_res.num_trajectories == 40
-+        np.testing.assert_allclose(merged_res.average_expect[0],
-+                                   np.arange(10), rtol=0.1)
-+        np.testing.assert_allclose(
-+            np.diag(sum(merged_res.average_states).full()),
-+            np.ones(N),
-+            rtol=0.1
-+        )
-+        assert bool(merged_res.trajectories) == keep_runs_results
-+        assert merged_res.stats["run time"] == 3
-diff --git a/qutip/tests/solver/test_scattering.py b/qutip/tests/solver/test_scattering.py
-index 0ad7257e..33905067 100644
---- a/qutip/tests/solver/test_scattering.py
-+++ b/qutip/tests/solver/test_scattering.py
-@@ -1,92 +1,92 @@
--"""
--This module includes a collection of testing functions for the QuTiP scattering
--module. Tests are approximate with low resolution to minimize runtime.
--"""
--
--# Author:  Ben Bartlett
--# Contact: benbartlett@stanford.edu
--
--import numpy as np
--from numpy.testing import assert_, run_module_suite
--from qutip import create, destroy, basis
--from qutip.solver.scattering import *
--
--
--class TestScattering:
--    """
--    A test class for the QuTiP quantum optical scattering module. These tests
--    only use the two-level system for comparison, since larger systems can
--    take a long time to run.
--    """
--
--    def testScatteringProbability(self):
--        """
--        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
--        """
--        w0 = 1.0 * 2 * np.pi
--        gamma = 1.0
--        sm = np.sqrt(gamma) * destroy(2)
--        pulseArea = np.pi
--        pulseLength = 0.2 / gamma
--        RabiFreq = pulseArea / (2 * pulseLength)
--        psi0 = basis(2, 0)
--        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
--        # Define TLS Hamiltonian
--        H0S = w0 * create(2) * destroy(2)
--        H1S1 = lambda t, args: \
--            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
--        H1S2 = lambda t, args: \
--            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
--        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
--        # Run the test
--        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
--        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
--        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
--        assert P0 < 1e-3
--        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
--
--    def testScatteringAmplitude(self):
--        """
--        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
--        """
--        w0 = 1.0 * 2 * np.pi
--        gamma = 1.0
--        sm = np.sqrt(gamma) * destroy(2)
--        pulseArea = 2 * np.pi
--        pulseLength = 0.2 / gamma
--        RabiFreq = pulseArea / (2 * pulseLength)
--        psi0 = basis(2, 0)
--        T = 50
--        tlist = np.linspace(0, 1 / gamma, T)
--        # Define TLS Hamiltonian
--        H0S = w0 * create(2) * destroy(2)
--        H1S1 = lambda t, args: \
--            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
--        H1S2 = lambda t, args: \
--            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
--        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
--        # Run the test
--        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
--        basisVec = temporal_basis_vector([[40]], T)
--        assert np.abs(basisVec.dag() @ state) < 1e-3
--
--    def testWaveguideSplit(self):
--        """
--        Checks that a trivial splitting of a waveguide collapse operator like
--        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
--        """
--        gamma = 1.0
--        sm = np.sqrt(gamma) * destroy(2)
--        pulseArea = np.pi
--        pulseLength = 0.2 / gamma
--        RabiFreq = pulseArea / (2 * pulseLength)
--        psi0 = basis(2, 0)
--        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
--        # Define TLS Hamiltonian with rotating frame transformation
--        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
--        # Run the test
--        c_ops = [sm]
--        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
--        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
--        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
--        assert np.abs(P1/P1_split - 1) < 1e-7
-+"""
-+This module includes a collection of testing functions for the QuTiP scattering
-+module. Tests are approximate with low resolution to minimize runtime.
-+"""
-+
-+# Author:  Ben Bartlett
-+# Contact: benbartlett@stanford.edu
-+
-+import numpy as np
-+from numpy.testing import assert_, run_module_suite
-+from qutip import create, destroy, basis
-+from qutip.solver.scattering import *
-+
-+
-+class TestScattering:
-+    """
-+    A test class for the QuTiP quantum optical scattering module. These tests
-+    only use the two-level system for comparison, since larger systems can
-+    take a long time to run.
-+    """
-+
-+    def testScatteringProbability(self):
-+        """
-+        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
-+        """
-+        w0 = 1.0 * 2 * np.pi
-+        gamma = 1.0
-+        sm = np.sqrt(gamma) * destroy(2)
-+        pulseArea = np.pi
-+        pulseLength = 0.2 / gamma
-+        RabiFreq = pulseArea / (2 * pulseLength)
-+        psi0 = basis(2, 0)
-+        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
-+        # Define TLS Hamiltonian
-+        H0S = w0 * create(2) * destroy(2)
-+        H1S1 = lambda t, args: \
-+            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
-+        H1S2 = lambda t, args: \
-+            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
-+        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
-+        # Run the test
-+        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
-+        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
-+        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
-+        assert P0 < 1e-3
-+        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
-+
-+    def testScatteringAmplitude(self):
-+        """
-+        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
-+        """
-+        w0 = 1.0 * 2 * np.pi
-+        gamma = 1.0
-+        sm = np.sqrt(gamma) * destroy(2)
-+        pulseArea = 2 * np.pi
-+        pulseLength = 0.2 / gamma
-+        RabiFreq = pulseArea / (2 * pulseLength)
-+        psi0 = basis(2, 0)
-+        T = 50
-+        tlist = np.linspace(0, 1 / gamma, T)
-+        # Define TLS Hamiltonian
-+        H0S = w0 * create(2) * destroy(2)
-+        H1S1 = lambda t, args: \
-+            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
-+        H1S2 = lambda t, args: \
-+            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
-+        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
-+        # Run the test
-+        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
-+        basisVec = temporal_basis_vector([[40]], T)
-+        assert np.abs(basisVec.dag() @ state) < 1e-3
-+
-+    def testWaveguideSplit(self):
-+        """
-+        Checks that a trivial splitting of a waveguide collapse operator like
-+        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
-+        """
-+        gamma = 1.0
-+        sm = np.sqrt(gamma) * destroy(2)
-+        pulseArea = np.pi
-+        pulseLength = 0.2 / gamma
-+        RabiFreq = pulseArea / (2 * pulseLength)
-+        psi0 = basis(2, 0)
-+        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
-+        # Define TLS Hamiltonian with rotating frame transformation
-+        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
-+        # Run the test
-+        c_ops = [sm]
-+        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
-+        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
-+        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
-+        assert np.abs(P1/P1_split - 1) < 1e-7
-diff --git a/qutip/tests/solver/test_sesolve.py b/qutip/tests/solver/test_sesolve.py
-index 5ca744f9..1814b0ca 100644
---- a/qutip/tests/solver/test_sesolve.py
-+++ b/qutip/tests/solver/test_sesolve.py
-@@ -1,301 +1,301 @@
--import pytest
--import pickle
--import qutip
--import numpy as np
--from qutip.solver.sesolve import sesolve, SESolver
--from qutip.solver.krylovsolve import krylovsolve
--from qutip.solver.solver_base import Solver
--
--all_ode_method = [
--    method for method, integrator in SESolver.avail_integrators().items()
--    if integrator.support_time_dependant
--]
--
--def _analytic(t, alpha):
--    return ((1 - np.exp(-alpha * t)) / alpha)
--
--
--class TestSeSolve():
--    H0 = 0.2 * np.pi * qutip.sigmaz()
--    H1 = np.pi * qutip.sigmax()
--    tlist = np.linspace(0, 20, 200)
--    args = {'alpha': 0.5}
--    w_a = 0.35
--    a = 0.5
--
--    @pytest.mark.parametrize(['unitary_op'], [
--        pytest.param(None, id="state"),
--        pytest.param(qutip.qeye(2), id="unitary"),
--    ])
--    @pytest.mark.parametrize(['H', 'analytical'], [
--        pytest.param(H1, lambda t, _: t, id='const_H'),
--        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
--                                       * np.exp(-alpha * t)),
--                     _analytic, id='func_H'),
--        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
--                     _analytic, id='list_func_H'),
--        pytest.param([[H1, 'exp(-alpha*t)']],
--                     _analytic, id='list_str_H'),
--        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
--                     _analytic, id='list_array_H'),
--        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
--                     _analytic, id='QobjEvo_H'),
--    ])
--    def test_sesolve(self, H, analytical, unitary_op):
--        """
--        Compare integrated evolution with analytical result
--        If U0 is not None then operator evo is checked
--        Otherwise state evo
--        """
--        tol = 5e-3
--        psi0 = qutip.basis(2, 0)
--        options = {"progress_bar": None}
--
--        if unitary_op is None:
--            output = sesolve(H, psi0, self.tlist,
--                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
--                             args=self.args, options=options)
--            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
--        else:
--            output = sesolve(H, unitary_op, self.tlist, args=self.args,
--                             options=options)
--            sx = [qutip.expect(qutip.sigmax(), U * psi0)
--                  for U in output.states]
--            sy = [qutip.expect(qutip.sigmay(), U * psi0)
--                  for U in output.states]
--            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
--                  for U in output.states]
--
--        sx_analytic = np.zeros(np.shape(self.tlist))
--        sy_analytic = np.array(
--            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
--             for t in self.tlist]
--        )
--        sz_analytic = np.array(
--            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
--             for t in self.tlist]
--        )
--
--        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
--        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
--        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
--
--    @pytest.mark.parametrize(['state_type'], [
--        pytest.param("ket", id="ket"),
--        pytest.param("unitary", id="unitary"),
--    ])
--    def test_sesolve_normalization(self, state_type):
--        # non-hermitean H causes state to evolve non-unitarily
--        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
--        psi0 = qutip.basis(2, 0)
--        options = {"normalize_output": True, "progress_bar": None}
--
--        if state_type == "ket":
--            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
--            norms = [state.norm() for state in output.states]
--            np.testing.assert_allclose(
--                norms, [1.0 for _ in self.tlist], atol=1e-15,
--            )
--        else:
--            # evolution of unitaries should not be normalized
--            U = qutip.qeye(2)
--            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
--            norms = [state.norm() for state in output.states]
--            assert all(norm > 2 for norm in norms[1:])
--
--    @pytest.mark.parametrize(['unitary_op'], [
--        pytest.param(None, id="state"),
--        pytest.param(qutip.qeye(2), id="unitary"),
--    ])
--    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
--    def test_sesolve_method(self, method, unitary_op):
--        """
--        Compare integrated evolution with analytical result
--        If U0 is not None then operator evo is checked
--        Otherwise state evo
--        """
--        tol = 5e-3
--        psi0 = qutip.basis(2, 0)
--        options = {"method": method, "progress_bar": None}
--        H = [[self.H1, 'exp(-alpha*t)']]
--
--        if unitary_op is None:
--            output = sesolve(H, psi0, self.tlist,
--                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
--                             args=self.args, options=options)
--            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
--        else:
--            output = sesolve(H, unitary_op, self.tlist,
--                             args=self.args, options=options)
--            sx = [qutip.expect(qutip.sigmax(), U * psi0)
--                  for U in output.states]
--            sy = [qutip.expect(qutip.sigmay(), U * psi0)
--                  for U in output.states]
--            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
--                  for U in output.states]
--
--        sx_analytic = np.zeros(np.shape(self.tlist))
--        sy_analytic = np.array(
--            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
--             for t in self.tlist]
--        )
--        sz_analytic = np.array(
--            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
--             for t in self.tlist]
--        )
--
--        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
--        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
--        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
--
--    @pytest.mark.parametrize('normalize', [True, False],
--                             ids=['Normalized', ''])
--    @pytest.mark.parametrize(['H', 'args'],
--        [pytest.param(H0 + H1, {}, id='const_H'),
--         pytest.param(lambda t, a, w_a: (
--             a * t * 0.2 * np.pi * qutip.sigmaz() +
--             np.cos(w_a * t) * np.pi * qutip.sigmax()
--         ), {'a':a, 'w_a':w_a}, id='func_H'),
--         pytest.param([
--             [H0, lambda t, args: args['a']*t],
--             [H1, lambda t, args: np.cos(args['w_a']*t)]
--         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
--         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
--    ])
--    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
--        """
--        Compare integrated evolution of unitary operator with state evo
--        """
--        psi0 = qutip.basis(2, 0)
--        U0 = qutip.qeye(2)
--
--        options = {
--            "store_states": True,
--            "normalize_output": normalize,
--            "progress_bar": None
--        }
--        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
--                                              qutip.sigmay(),
--                                              qutip.sigmaz()],
--                        options=options, args=args)
--        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
--        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
--        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
--        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
--
--        np.testing.assert_allclose(xs, xss, atol=tol)
--        np.testing.assert_allclose(ys, yss, atol=tol)
--        np.testing.assert_allclose(zs, zss, atol=tol)
--
--        if normalize:
--            # propagator evolution is not normalized (yet?)
--            tol = 5e-4
--        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
--        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
--        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
--        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
--
--        np.testing.assert_allclose(xs, xu, atol=tol)
--        np.testing.assert_allclose(ys, yu, atol=tol)
--        np.testing.assert_allclose(zs, zu, atol=tol)
--
--    def test_sesolver_args(self):
--        options = {"progress_bar": None}
--        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
--                                            args={'a': 1}),
--                              options=options)
--        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
--                             e_ops=[qutip.num(2)], args={'a':0})
--        np.testing.assert_allclose(res.expect[0], 1)
--
--    def test_sesolver_pickling(self):
--        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
--        options = {"progress_bar": None}
--        solver_obj = SESolver(self.H0 + self.H1,
--                              options=options)
--        solver_copy = pickle.loads(pickle.dumps(solver_obj))
--        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
--                                    e_ops=e_ops).expect
--        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
--                                       e_ops=e_ops).expect
--        np.testing.assert_allclose(sx, csx)
--        np.testing.assert_allclose(sy, csy)
--        np.testing.assert_allclose(sz, csz)
--
--    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
--    def test_sesolver_stepping(self, method):
--        options = {
--            "method": method,
--            "atol": 1e-7,
--            "rtol": 1e-8,
--            "progress_bar": None
--        }
--        solver_obj = SESolver(
--            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
--            options=options
--        )
--        solver_obj.start(qutip.basis(2,0), 0)
--        sr2 = -(2**.5)/2
--        state = solver_obj.step(1)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
--                                   atol=2e-6)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
--                                   atol=2e-6)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
--                                   atol=2e-6)
--
--        state = solver_obj.step(2, args={"a":0.125})
--        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
--                                   atol=2e-6)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
--                                   atol=2e-6)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
--                                   atol=2e-6)
--
--        solver_obj.options = {
--            "method": "adams",
--            "atol": 1e-7,
--            "rtol": 1e-8,
--            "progress_bar": None
--        }
--        state = solver_obj.step(3, args={"a":0})
--        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
--                                   atol=2e-6)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
--                                   atol=2e-6)
--        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
--                                   atol=2e-6)
--
--
--def test_sesolve_bad_H():
--    with pytest.raises(TypeError):
--        SESolver(np.eye(3))
--    with pytest.raises(ValueError):
--        SESolver(qutip.basis(3,1))
--
--
--def test_sesolve_bad_state():
--    solver = SESolver(qutip.qeye(4))
--    with pytest.raises(TypeError):
--        solver.start(qutip.basis(4,1).dag(), 0)
--    with pytest.raises(TypeError):
--        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
--
--
--def test_sesolve_step_no_start():
--    solver = SESolver(qutip.qeye(4))
--    with pytest.raises(RuntimeError):
--        solver.step(1)
--
--
--@pytest.mark.parametrize("always_compute_step", [True, False])
--def test_krylovsolve(always_compute_step):
--    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
--    psi0 = qutip.basis([2]*8, [1]*8)
--    e_op = qutip.num(256)
--    e_op.dims = H.dims
--    tlist = np.linspace(0, 1, 11)
--    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
--    options = {"always_compute_step", always_compute_step}
--    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
--    np.testing.assert_allclose(ref, krylov_sol)
-+import pytest
-+import pickle
-+import qutip
-+import numpy as np
-+from qutip.solver.sesolve import sesolve, SESolver
-+from qutip.solver.krylovsolve import krylovsolve
-+from qutip.solver.solver_base import Solver
-+
-+all_ode_method = [
-+    method for method, integrator in SESolver.avail_integrators().items()
-+    if integrator.support_time_dependant
-+]
-+
-+def _analytic(t, alpha):
-+    return ((1 - np.exp(-alpha * t)) / alpha)
-+
-+
-+class TestSeSolve():
-+    H0 = 0.2 * np.pi * qutip.sigmaz()
-+    H1 = np.pi * qutip.sigmax()
-+    tlist = np.linspace(0, 20, 200)
-+    args = {'alpha': 0.5}
-+    w_a = 0.35
-+    a = 0.5
-+
-+    @pytest.mark.parametrize(['unitary_op'], [
-+        pytest.param(None, id="state"),
-+        pytest.param(qutip.qeye(2), id="unitary"),
-+    ])
-+    @pytest.mark.parametrize(['H', 'analytical'], [
-+        pytest.param(H1, lambda t, _: t, id='const_H'),
-+        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
-+                                       * np.exp(-alpha * t)),
-+                     _analytic, id='func_H'),
-+        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
-+                     _analytic, id='list_func_H'),
-+        pytest.param([[H1, 'exp(-alpha*t)']],
-+                     _analytic, id='list_str_H'),
-+        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
-+                     _analytic, id='list_array_H'),
-+        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
-+                     _analytic, id='QobjEvo_H'),
-+    ])
-+    def test_sesolve(self, H, analytical, unitary_op):
-+        """
-+        Compare integrated evolution with analytical result
-+        If U0 is not None then operator evo is checked
-+        Otherwise state evo
-+        """
-+        tol = 5e-3
-+        psi0 = qutip.basis(2, 0)
-+        options = {"progress_bar": None}
-+
-+        if unitary_op is None:
-+            output = sesolve(H, psi0, self.tlist,
-+                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
-+                             args=self.args, options=options)
-+            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
-+        else:
-+            output = sesolve(H, unitary_op, self.tlist, args=self.args,
-+                             options=options)
-+            sx = [qutip.expect(qutip.sigmax(), U * psi0)
-+                  for U in output.states]
-+            sy = [qutip.expect(qutip.sigmay(), U * psi0)
-+                  for U in output.states]
-+            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
-+                  for U in output.states]
-+
-+        sx_analytic = np.zeros(np.shape(self.tlist))
-+        sy_analytic = np.array(
-+            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
-+             for t in self.tlist]
-+        )
-+        sz_analytic = np.array(
-+            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
-+             for t in self.tlist]
-+        )
-+
-+        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
-+        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
-+        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
-+
-+    @pytest.mark.parametrize(['state_type'], [
-+        pytest.param("ket", id="ket"),
-+        pytest.param("unitary", id="unitary"),
-+    ])
-+    def test_sesolve_normalization(self, state_type):
-+        # non-hermitean H causes state to evolve non-unitarily
-+        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
-+        psi0 = qutip.basis(2, 0)
-+        options = {"normalize_output": True, "progress_bar": None}
-+
-+        if state_type == "ket":
-+            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
-+            norms = [state.norm() for state in output.states]
-+            np.testing.assert_allclose(
-+                norms, [1.0 for _ in self.tlist], atol=1e-15,
-+            )
-+        else:
-+            # evolution of unitaries should not be normalized
-+            U = qutip.qeye(2)
-+            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
-+            norms = [state.norm() for state in output.states]
-+            assert all(norm > 2 for norm in norms[1:])
-+
-+    @pytest.mark.parametrize(['unitary_op'], [
-+        pytest.param(None, id="state"),
-+        pytest.param(qutip.qeye(2), id="unitary"),
-+    ])
-+    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
-+    def test_sesolve_method(self, method, unitary_op):
-+        """
-+        Compare integrated evolution with analytical result
-+        If U0 is not None then operator evo is checked
-+        Otherwise state evo
-+        """
-+        tol = 5e-3
-+        psi0 = qutip.basis(2, 0)
-+        options = {"method": method, "progress_bar": None}
-+        H = [[self.H1, 'exp(-alpha*t)']]
-+
-+        if unitary_op is None:
-+            output = sesolve(H, psi0, self.tlist,
-+                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
-+                             args=self.args, options=options)
-+            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
-+        else:
-+            output = sesolve(H, unitary_op, self.tlist,
-+                             args=self.args, options=options)
-+            sx = [qutip.expect(qutip.sigmax(), U * psi0)
-+                  for U in output.states]
-+            sy = [qutip.expect(qutip.sigmay(), U * psi0)
-+                  for U in output.states]
-+            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
-+                  for U in output.states]
-+
-+        sx_analytic = np.zeros(np.shape(self.tlist))
-+        sy_analytic = np.array(
-+            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
-+             for t in self.tlist]
-+        )
-+        sz_analytic = np.array(
-+            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
-+             for t in self.tlist]
-+        )
-+
-+        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
-+        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
-+        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
-+
-+    @pytest.mark.parametrize('normalize', [True, False],
-+                             ids=['Normalized', ''])
-+    @pytest.mark.parametrize(['H', 'args'],
-+        [pytest.param(H0 + H1, {}, id='const_H'),
-+         pytest.param(lambda t, a, w_a: (
-+             a * t * 0.2 * np.pi * qutip.sigmaz() +
-+             np.cos(w_a * t) * np.pi * qutip.sigmax()
-+         ), {'a':a, 'w_a':w_a}, id='func_H'),
-+         pytest.param([
-+             [H0, lambda t, args: args['a']*t],
-+             [H1, lambda t, args: np.cos(args['w_a']*t)]
-+         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
-+         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
-+    ])
-+    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
-+        """
-+        Compare integrated evolution of unitary operator with state evo
-+        """
-+        psi0 = qutip.basis(2, 0)
-+        U0 = qutip.qeye(2)
-+
-+        options = {
-+            "store_states": True,
-+            "normalize_output": normalize,
-+            "progress_bar": None
-+        }
-+        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
-+                                              qutip.sigmay(),
-+                                              qutip.sigmaz()],
-+                        options=options, args=args)
-+        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
-+        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
-+        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
-+        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
-+
-+        np.testing.assert_allclose(xs, xss, atol=tol)
-+        np.testing.assert_allclose(ys, yss, atol=tol)
-+        np.testing.assert_allclose(zs, zss, atol=tol)
-+
-+        if normalize:
-+            # propagator evolution is not normalized (yet?)
-+            tol = 5e-4
-+        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
-+        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
-+        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
-+        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
-+
-+        np.testing.assert_allclose(xs, xu, atol=tol)
-+        np.testing.assert_allclose(ys, yu, atol=tol)
-+        np.testing.assert_allclose(zs, zu, atol=tol)
-+
-+    def test_sesolver_args(self):
-+        options = {"progress_bar": None}
-+        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
-+                                            args={'a': 1}),
-+                              options=options)
-+        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
-+                             e_ops=[qutip.num(2)], args={'a':0})
-+        np.testing.assert_allclose(res.expect[0], 1)
-+
-+    def test_sesolver_pickling(self):
-+        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-+        options = {"progress_bar": None}
-+        solver_obj = SESolver(self.H0 + self.H1,
-+                              options=options)
-+        solver_copy = pickle.loads(pickle.dumps(solver_obj))
-+        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
-+                                    e_ops=e_ops).expect
-+        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
-+                                       e_ops=e_ops).expect
-+        np.testing.assert_allclose(sx, csx)
-+        np.testing.assert_allclose(sy, csy)
-+        np.testing.assert_allclose(sz, csz)
-+
-+    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
-+    def test_sesolver_stepping(self, method):
-+        options = {
-+            "method": method,
-+            "atol": 1e-7,
-+            "rtol": 1e-8,
-+            "progress_bar": None
-+        }
-+        solver_obj = SESolver(
-+            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
-+            options=options
-+        )
-+        solver_obj.start(qutip.basis(2,0), 0)
-+        sr2 = -(2**.5)/2
-+        state = solver_obj.step(1)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-+                                   atol=2e-6)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
-+                                   atol=2e-6)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
-+                                   atol=2e-6)
-+
-+        state = solver_obj.step(2, args={"a":0.125})
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-+                                   atol=2e-6)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
-+                                   atol=2e-6)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
-+                                   atol=2e-6)
-+
-+        solver_obj.options = {
-+            "method": "adams",
-+            "atol": 1e-7,
-+            "rtol": 1e-8,
-+            "progress_bar": None
-+        }
-+        state = solver_obj.step(3, args={"a":0})
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-+                                   atol=2e-6)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
-+                                   atol=2e-6)
-+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
-+                                   atol=2e-6)
-+
-+
-+def test_sesolve_bad_H():
-+    with pytest.raises(TypeError):
-+        SESolver(np.eye(3))
-+    with pytest.raises(ValueError):
-+        SESolver(qutip.basis(3,1))
-+
-+
-+def test_sesolve_bad_state():
-+    solver = SESolver(qutip.qeye(4))
-+    with pytest.raises(TypeError):
-+        solver.start(qutip.basis(4,1).dag(), 0)
-+    with pytest.raises(TypeError):
-+        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
-+
-+
-+def test_sesolve_step_no_start():
-+    solver = SESolver(qutip.qeye(4))
-+    with pytest.raises(RuntimeError):
-+        solver.step(1)
-+
-+
-+@pytest.mark.parametrize("always_compute_step", [True, False])
-+def test_krylovsolve(always_compute_step):
-+    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
-+    psi0 = qutip.basis([2]*8, [1]*8)
-+    e_op = qutip.num(256)
-+    e_op.dims = H.dims
-+    tlist = np.linspace(0, 1, 11)
-+    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
-+    options = {"always_compute_step", always_compute_step}
-+    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
-+    np.testing.assert_allclose(ref, krylov_sol)
-diff --git a/qutip/tests/solver/test_steadystate.py b/qutip/tests/solver/test_steadystate.py
-index 6ae02a64..38c85dfa 100644
---- a/qutip/tests/solver/test_steadystate.py
-+++ b/qutip/tests/solver/test_steadystate.py
-@@ -1,241 +1,241 @@
--import numpy as np
--import pytest
--import qutip
--import warnings
--
--
--@pytest.mark.parametrize(['method', 'kwargs'], [
--    pytest.param('direct', {}, id="direct"),
--    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
--                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
--                                          reason='MKL extensions not found.')),
--    pytest.param('direct', {'sparse':False}, id="direct_dense"),
--    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
--    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
--    pytest.param('eigen', {}, id="eigen"),
--    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
--    pytest.param('svd', {}, id="svd"),
--    pytest.param('power', {'power_tol':1e-5}, id="power"),
--    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
--                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
--                                          reason='MKL extensions not found.')),
--    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
--    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
--                 id="power-gmres_perm"),
--    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
--    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
--    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
--                 id="iterative-gmres_perm"),
--    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
--                 id="iterative-bicgstab"),
--])
--def test_qubit(method, kwargs):
--    # thermal steadystate of a qubit: compare numerics with analytical formula
--    sz = qutip.sigmaz()
--    sm = qutip.destroy(2)
--
--    H = 0.5 * 2 * np.pi * sz
--    gamma1 = 0.05
--
--    wth_vec = np.linspace(0.1, 3, 20)
--    p_ss = np.zeros(np.shape(wth_vec))
--
--    for idx, wth in enumerate(wth_vec):
--        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
--        c_op_list = []
--        rate = gamma1 * (1 + n_th)
--        c_op_list.append(np.sqrt(rate) * sm)
--        rate = gamma1 * n_th
--        c_op_list.append(np.sqrt(rate) * sm.dag())
--        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
--        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
--
--    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
--    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
--
--
--@pytest.mark.parametrize(['method', 'kwargs'], [
--    pytest.param('direct', {}, id="direct"),
--    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
--                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
--                                          reason='MKL extensions not found.')),
--    pytest.param('direct', {'sparse': False}, id="direct_dense"),
--    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
--    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
--    pytest.param('eigen', {}, id="eigen"),
--    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
--    pytest.param('svd', {}, id="svd"),
--])
--def test_exact_solution_for_simple_methods(method, kwargs):
--    # this tests that simple methods correctly determine the steadystate
--    # with high accuracy for a small Liouvillian requiring correct weighting.
--    H = qutip.identity(2)
--    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
--    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
--    expected_rho_ss = np.array([
--        [1.e-10+0.j, 0.e+00-0.j],
--        [0.e+00-0.j, 1.e+00+0.j],
--    ])
--    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
--    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
--
--
--@pytest.mark.parametrize(['method', 'kwargs'], [
--    pytest.param('direct', {}, id="direct"),
--    pytest.param('direct', {'sparse':False}, id="direct_dense"),
--    pytest.param('eigen', {'sparse':False}, id="eigen"),
--    pytest.param('power', {'power_tol':1e-5}, id="power"),
--    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
--    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
--    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
--])
--def test_ho(method, kwargs):
--    # thermal steadystate of an oscillator: compare numerics with analytical
--    # formula
--    a = qutip.destroy(30)
--    H = 0.5 * 2 * np.pi * a.dag() * a
--    gamma1 = 0.05
--
--    wth_vec = np.linspace(0.1, 3, 11)
--    p_ss = np.zeros(np.shape(wth_vec))
--
--    for idx, wth in enumerate(wth_vec):
--
--        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
--        c_op_list = []
--        rate = gamma1 * (1 + n_th)
--        c_op_list.append(np.sqrt(rate) * a)
--        rate = gamma1 * n_th
--        c_op_list.append(np.sqrt(rate) * a.dag())
--        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
--        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
--
--    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
--    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
--
--
--@pytest.mark.parametrize(['method', 'kwargs'], [
--    pytest.param('direct', {}, id="direct"),
--    pytest.param('direct', {'sparse':False}, id="direct_dense"),
--    pytest.param('eigen', {}, id="eigen"),
--    pytest.param('svd', {}, id="svd"),
--    pytest.param('power', {}, id="power"),
--    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
--                 id="power-gmres"),
--    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
--                 id="power-bicgstab"),
--    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
--    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
--])
--def test_driven_cavity(method, kwargs):
--    N = 30
--    Omega = 0.01 * 2 * np.pi
--    Gamma = 0.05
--
--    a = qutip.destroy(N)
--    H = Omega * (a.dag() + a)
--    c_ops = [np.sqrt(Gamma) * a]
--    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
--    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
--
--    np.testing.assert_allclose(
--        rho_ss, rho_ss_analytic, atol=1e-4
--    )
--    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
--
--
--@pytest.mark.parametrize(['method', 'kwargs'], [
--    pytest.param('solve', {}, id="dense_direct"),
--    pytest.param('numpy', {}, id="dense_numpy"),
--    pytest.param('spilu', {},  id="spilu"),
--])
--def test_pseudo_inverse(method, kwargs):
--    N = 4
--    a = qutip.destroy(N)
--    H = (a.dag() + a)
--    L = qutip.liouvillian(H, [a])
--    rho = qutip.steadystate(L)
--    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
--    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
--    np.testing.assert_allclose(
--        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
--    )
--    assert rho.tr() == pytest.approx(1, abs=3e-15)
--
--
--@pytest.mark.parametrize('sparse', [True, False])
--def test_steadystate_floquet(sparse):
--    """
--    Test the steadystate solution for a periodically
--    driven system.
--    """
--    N_c = 20
--
--    a = qutip.destroy(N_c)
--    a_d = a.dag()
--    X_c = a + a_d
--
--    w_c = 1
--
--    A_l = 0.001
--    w_l = w_c
--    gam = 0.01
--
--    H = w_c * a_d * a
--
--    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
--
--    psi0 = qutip.fock(N_c, 0)
--
--    args = {"A_l": A_l, "w_l": w_l}
--
--    c_ops = []
--    c_ops.append(np.sqrt(gam) * a)
--
--    t_l = np.linspace(0, 20 / gam, 2000)
--
--    expect_me = qutip.mesolve(H_t, psi0, t_l,
--                        c_ops, [a_d * a], args=args).expect[0]
--
--    rho_ss = qutip.steadystate_floquet(H, c_ops,
--                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
--    expect_ss = qutip.expect(a_d * a, rho_ss)
--
--    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
--    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
--
--
--def test_bad_options_steadystate():
--    N = 4
--    a = qutip.destroy(N)
--    H = (a.dag() + a)
--    c_ops = [a]
--    with pytest.raises(ValueError):
--        qutip.steadystate(H, c_ops, method='not a method')
--    with pytest.raises(TypeError):
--        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
--    with pytest.raises(ValueError):
--        qutip.steadystate(H, c_ops, method='direct', solver='Error')
--
--
--def test_bad_options_pseudo_inverse():
--    N = 4
--    a = qutip.destroy(N)
--    H = (a.dag() + a)
--    L = qutip.liouvillian(H, [a])
--    with pytest.raises(TypeError):
--        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
--    with pytest.raises(ValueError):
--        qutip.pseudo_inverse(L, method='not a method', sparse=False)
--    with pytest.raises(ValueError):
--        qutip.pseudo_inverse(L, method='not a method')
--
--
--def test_bad_system():
--    N = 4
--    a = qutip.destroy(N)
--    H = (a.dag() + a)
--    with pytest.raises(TypeError):
--        qutip.steadystate(H, [], method='direct')
--    with pytest.raises(TypeError):
--        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
-+import numpy as np
-+import pytest
-+import qutip
-+import warnings
-+
-+
-+@pytest.mark.parametrize(['method', 'kwargs'], [
-+    pytest.param('direct', {}, id="direct"),
-+    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
-+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-+                                          reason='MKL extensions not found.')),
-+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-+    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
-+    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
-+    pytest.param('eigen', {}, id="eigen"),
-+    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
-+    pytest.param('svd', {}, id="svd"),
-+    pytest.param('power', {'power_tol':1e-5}, id="power"),
-+    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
-+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-+                                          reason='MKL extensions not found.')),
-+    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
-+    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
-+                 id="power-gmres_perm"),
-+    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
-+    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
-+    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
-+                 id="iterative-gmres_perm"),
-+    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
-+                 id="iterative-bicgstab"),
-+])
-+def test_qubit(method, kwargs):
-+    # thermal steadystate of a qubit: compare numerics with analytical formula
-+    sz = qutip.sigmaz()
-+    sm = qutip.destroy(2)
-+
-+    H = 0.5 * 2 * np.pi * sz
-+    gamma1 = 0.05
-+
-+    wth_vec = np.linspace(0.1, 3, 20)
-+    p_ss = np.zeros(np.shape(wth_vec))
-+
-+    for idx, wth in enumerate(wth_vec):
-+        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
-+        c_op_list = []
-+        rate = gamma1 * (1 + n_th)
-+        c_op_list.append(np.sqrt(rate) * sm)
-+        rate = gamma1 * n_th
-+        c_op_list.append(np.sqrt(rate) * sm.dag())
-+        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
-+        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
-+
-+    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
-+    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
-+
-+
-+@pytest.mark.parametrize(['method', 'kwargs'], [
-+    pytest.param('direct', {}, id="direct"),
-+    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
-+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-+                                          reason='MKL extensions not found.')),
-+    pytest.param('direct', {'sparse': False}, id="direct_dense"),
-+    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
-+    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
-+    pytest.param('eigen', {}, id="eigen"),
-+    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
-+    pytest.param('svd', {}, id="svd"),
-+])
-+def test_exact_solution_for_simple_methods(method, kwargs):
-+    # this tests that simple methods correctly determine the steadystate
-+    # with high accuracy for a small Liouvillian requiring correct weighting.
-+    H = qutip.identity(2)
-+    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
-+    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
-+    expected_rho_ss = np.array([
-+        [1.e-10+0.j, 0.e+00-0.j],
-+        [0.e+00-0.j, 1.e+00+0.j],
-+    ])
-+    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
-+    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
-+
-+
-+@pytest.mark.parametrize(['method', 'kwargs'], [
-+    pytest.param('direct', {}, id="direct"),
-+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-+    pytest.param('eigen', {'sparse':False}, id="eigen"),
-+    pytest.param('power', {'power_tol':1e-5}, id="power"),
-+    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
-+    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
-+    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
-+])
-+def test_ho(method, kwargs):
-+    # thermal steadystate of an oscillator: compare numerics with analytical
-+    # formula
-+    a = qutip.destroy(30)
-+    H = 0.5 * 2 * np.pi * a.dag() * a
-+    gamma1 = 0.05
-+
-+    wth_vec = np.linspace(0.1, 3, 11)
-+    p_ss = np.zeros(np.shape(wth_vec))
-+
-+    for idx, wth in enumerate(wth_vec):
-+
-+        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
-+        c_op_list = []
-+        rate = gamma1 * (1 + n_th)
-+        c_op_list.append(np.sqrt(rate) * a)
-+        rate = gamma1 * n_th
-+        c_op_list.append(np.sqrt(rate) * a.dag())
-+        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
-+        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
-+
-+    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
-+    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
-+
-+
-+@pytest.mark.parametrize(['method', 'kwargs'], [
-+    pytest.param('direct', {}, id="direct"),
-+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-+    pytest.param('eigen', {}, id="eigen"),
-+    pytest.param('svd', {}, id="svd"),
-+    pytest.param('power', {}, id="power"),
-+    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
-+                 id="power-gmres"),
-+    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
-+                 id="power-bicgstab"),
-+    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
-+    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
-+])
-+def test_driven_cavity(method, kwargs):
-+    N = 30
-+    Omega = 0.01 * 2 * np.pi
-+    Gamma = 0.05
-+
-+    a = qutip.destroy(N)
-+    H = Omega * (a.dag() + a)
-+    c_ops = [np.sqrt(Gamma) * a]
-+    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
-+    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
-+
-+    np.testing.assert_allclose(
-+        rho_ss, rho_ss_analytic, atol=1e-4
-+    )
-+    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
-+
-+
-+@pytest.mark.parametrize(['method', 'kwargs'], [
-+    pytest.param('solve', {}, id="dense_direct"),
-+    pytest.param('numpy', {}, id="dense_numpy"),
-+    pytest.param('spilu', {},  id="spilu"),
-+])
-+def test_pseudo_inverse(method, kwargs):
-+    N = 4
-+    a = qutip.destroy(N)
-+    H = (a.dag() + a)
-+    L = qutip.liouvillian(H, [a])
-+    rho = qutip.steadystate(L)
-+    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
-+    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
-+    np.testing.assert_allclose(
-+        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
-+    )
-+    assert rho.tr() == pytest.approx(1, abs=3e-15)
-+
-+
-+@pytest.mark.parametrize('sparse', [True, False])
-+def test_steadystate_floquet(sparse):
-+    """
-+    Test the steadystate solution for a periodically
-+    driven system.
-+    """
-+    N_c = 20
-+
-+    a = qutip.destroy(N_c)
-+    a_d = a.dag()
-+    X_c = a + a_d
-+
-+    w_c = 1
-+
-+    A_l = 0.001
-+    w_l = w_c
-+    gam = 0.01
-+
-+    H = w_c * a_d * a
-+
-+    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
-+
-+    psi0 = qutip.fock(N_c, 0)
-+
-+    args = {"A_l": A_l, "w_l": w_l}
-+
-+    c_ops = []
-+    c_ops.append(np.sqrt(gam) * a)
-+
-+    t_l = np.linspace(0, 20 / gam, 2000)
-+
-+    expect_me = qutip.mesolve(H_t, psi0, t_l,
-+                        c_ops, [a_d * a], args=args).expect[0]
-+
-+    rho_ss = qutip.steadystate_floquet(H, c_ops,
-+                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
-+    expect_ss = qutip.expect(a_d * a, rho_ss)
-+
-+    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
-+    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
-+
-+
-+def test_bad_options_steadystate():
-+    N = 4
-+    a = qutip.destroy(N)
-+    H = (a.dag() + a)
-+    c_ops = [a]
-+    with pytest.raises(ValueError):
-+        qutip.steadystate(H, c_ops, method='not a method')
-+    with pytest.raises(TypeError):
-+        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
-+    with pytest.raises(ValueError):
-+        qutip.steadystate(H, c_ops, method='direct', solver='Error')
-+
-+
-+def test_bad_options_pseudo_inverse():
-+    N = 4
-+    a = qutip.destroy(N)
-+    H = (a.dag() + a)
-+    L = qutip.liouvillian(H, [a])
-+    with pytest.raises(TypeError):
-+        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
-+    with pytest.raises(ValueError):
-+        qutip.pseudo_inverse(L, method='not a method', sparse=False)
-+    with pytest.raises(ValueError):
-+        qutip.pseudo_inverse(L, method='not a method')
-+
-+
-+def test_bad_system():
-+    N = 4
-+    a = qutip.destroy(N)
-+    H = (a.dag() + a)
-+    with pytest.raises(TypeError):
-+        qutip.steadystate(H, [], method='direct')
-+    with pytest.raises(TypeError):
-+        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
-diff --git a/qutip/tests/test_basis_transformation.py b/qutip/tests/test_basis_transformation.py
-index 1e406e9f..080296a3 100644
---- a/qutip/tests/test_basis_transformation.py
-+++ b/qutip/tests/test_basis_transformation.py
-@@ -1,55 +1,55 @@
--import numpy as np
--import pytest
--import qutip
--
--
--def real_hermitian(n_levels):
--    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
--    return qobj + qobj.dag()
--
--
--def imaginary_hermitian(n_levels):
--    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
--    return qobj + qobj.dag()
--
--
--def complex_hermitian(n_levels):
--    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
--
--
--def rand_bra(n_levels):
--    return qutip.rand_ket(n_levels).dag()
--
--
--@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
--                                                   imaginary_hermitian,
--                                                   complex_hermitian])
--@pytest.mark.parametrize("n_levels", [2, 10])
--def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
--                                                    n_levels):
--    """Transform n-level real-values to eigenbasis and back"""
--    H1 = hermitian_constructor(n_levels)
--    _, ekets = H1.eigenstates()
--    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
--    H2 = Heb.transform(ekets, True)  # Back to original basis
--    assert (H1 - H2).norm() < 1e-6
--
--
--@pytest.mark.parametrize("n_levels", [4])
--def test_ket_and_dm_transformations_equivalent(n_levels):
--    """Consistency between transformations of kets and density matrices."""
--    psi0 = qutip.rand_ket(n_levels)
--    # Generate a random basis
--    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
--    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
--    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
--    assert (rho1 - rho2).norm() < 1e-6
--
--
--def test_eigenbasis_transformation_makes_diagonal_operator():
--    """Check diagonalization via eigenbasis transformation."""
--    cx, cy, cz = np.random.random_sample((3,))
--    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
--    _, ekets = H.eigenstates()
--    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
--    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
-+import numpy as np
-+import pytest
-+import qutip
-+
-+
-+def real_hermitian(n_levels):
-+    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
-+    return qobj + qobj.dag()
-+
-+
-+def imaginary_hermitian(n_levels):
-+    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
-+    return qobj + qobj.dag()
-+
-+
-+def complex_hermitian(n_levels):
-+    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
-+
-+
-+def rand_bra(n_levels):
-+    return qutip.rand_ket(n_levels).dag()
-+
-+
-+@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
-+                                                   imaginary_hermitian,
-+                                                   complex_hermitian])
-+@pytest.mark.parametrize("n_levels", [2, 10])
-+def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
-+                                                    n_levels):
-+    """Transform n-level real-values to eigenbasis and back"""
-+    H1 = hermitian_constructor(n_levels)
-+    _, ekets = H1.eigenstates()
-+    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
-+    H2 = Heb.transform(ekets, True)  # Back to original basis
-+    assert (H1 - H2).norm() < 1e-6
-+
-+
-+@pytest.mark.parametrize("n_levels", [4])
-+def test_ket_and_dm_transformations_equivalent(n_levels):
-+    """Consistency between transformations of kets and density matrices."""
-+    psi0 = qutip.rand_ket(n_levels)
-+    # Generate a random basis
-+    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
-+    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
-+    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
-+    assert (rho1 - rho2).norm() < 1e-6
-+
-+
-+def test_eigenbasis_transformation_makes_diagonal_operator():
-+    """Check diagonalization via eigenbasis transformation."""
-+    cx, cy, cz = np.random.random_sample((3,))
-+    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
-+    _, ekets = H.eigenstates()
-+    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
-+    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
-diff --git a/qutip/tests/test_bloch.py b/qutip/tests/test_bloch.py
-index 33e8fb2f..e87517d3 100644
---- a/qutip/tests/test_bloch.py
-+++ b/qutip/tests/test_bloch.py
-@@ -1,479 +1,479 @@
--import copy
--
--import numpy as np
--import pytest
--
--from qutip.bloch import Bloch
--from qutip import ket, ket2dm
--
--try:
--    import matplotlib.pyplot as plt
--    from matplotlib.testing.decorators import check_figures_equal
--    import IPython
--    check_pngs_equal = check_figures_equal(extensions=["png"])
--except ImportError:
--    plt = None
--    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
--
--
--class RefBloch(Bloch):
--    """ A helper for rendering reference Bloch spheres. """
--    def render(self):
--        raise NotImplementedError("RefBloch disables .render()")
--
--    def render_back(self):
--        old_plot_front = self.plot_front
--        self.plot_front = lambda: None
--        try:
--            Bloch.render(self)
--        finally:
--            self.plot_front = old_plot_front
--
--    def render_front(self):
--        self.plot_front()
--
--
--class TestBloch:
--    def plot_arc_test(self, fig, *args, **kw):
--        b = Bloch(fig=fig)
--        b.add_arc(*args, **kw)
--        b.render()
--
--    def plot_arc_ref(self, fig, start, end, **kw):
--        fmt = kw.pop("fmt", "b")
--        steps = kw.pop("steps", None)
--        start = np.array(start)
--        end = np.array(end)
--        if steps is None:
--            steps = int(np.linalg.norm(start - end) * 100)
--            steps = max(2, steps)
--
--        t = np.linspace(0, 1, steps)
--        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
--        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
--
--        b = RefBloch(fig=fig)
--        b.render_back()
--        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
--        b.render_front()
--
--    @pytest.mark.parametrize([
--        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
--    ], [
--        pytest.param(
--            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
--        pytest.param(
--            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
--            id="small-radius"),
--        pytest.param(
--            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
--            id="tiny-radius"),
--        pytest.param(
--            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
--            id="large-radius"),
--        pytest.param(
--            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
--            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
--        ),
--        pytest.param(
--            ket("0"), (0, 0, 1),
--            (ket("0") + ket("1")).unit(), (1, 0, 0),
--            {}, id="kets",
--        ),
--        pytest.param(
--            ket2dm(ket("0")), (0, 0, 1),
--            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
--            {}, id="dms",
--        ),
--        pytest.param(
--            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
--            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
--            {}, id="non-unit-dms",
--        ),
--    ])
--    @check_pngs_equal
--    def test_arc(
--        self, start_test, start_ref, end_test, end_ref, kwargs,
--        fig_test, fig_ref,
--    ):
--        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
--        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
--
--    @pytest.mark.parametrize([
--        "start", "end", "err_msg",
--    ], [
--        pytest.param(
--            (0, 0, 0), (0, 1, 0),
--            "Polar and azimuthal angles undefined at origin.",
--            id="start-origin",
--        ),
--        pytest.param(
--            (1, 0, 0), (0, 0, 0),
--            "Polar and azimuthal angles undefined at origin.",
--            id="end-origin",
--        ),
--        pytest.param(
--            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
--            id="different-spheres",
--        ),
--        pytest.param(
--            (1, 0, 0), (1, 0, 0),
--            "Start and end represent the same point. No arc can be formed.",
--            id="same-points",
--        ),
--        pytest.param(
--            (1, 0, 0), (-1, 0, 0),
--            "Start and end are diagonally opposite, no unique arc is"
--            " possible.",
--            id="opposite-points",
--        ),
--    ])
--    def test_arc_errors(self, start, end, err_msg):
--        b = Bloch()
--        with pytest.raises(ValueError) as err:
--            b.add_arc(start, end)
--        assert str(err.value) == err_msg
--
--    def plot_line_test(self, fig, *args, **kw):
--        b = Bloch(fig=fig)
--        b.add_line(*args, **kw)
--        b.render()
--
--    def plot_line_ref(self, fig, start, end, **kw):
--        fmt = kw.pop("fmt", "k")
--
--        x = [start[1], end[1]]
--        y = [-start[0], -end[0]]
--        z = [start[2], end[2]]
--
--        b = RefBloch(fig=fig)
--        b.render_back()
--        b.axes.plot(x, y, z, fmt, **kw)
--        b.render_front()
--
--    @pytest.mark.parametrize([
--        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
--    ], [
--        pytest.param(
--            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
--        pytest.param(
--            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
--            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
--        ),
--        pytest.param(
--            ket("0"), (0, 0, 1),
--            (ket("0") + ket("1")).unit(), (1, 0, 0),
--            {}, id="kets",
--        ),
--        pytest.param(
--            ket2dm(ket("0")), (0, 0, 1),
--            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
--            {}, id="dms",
--        ),
--        pytest.param(
--            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
--            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
--            {}, id="non-unit-dms",
--        ),
--    ])
--    @check_pngs_equal
--    def test_line(
--        self, start_test, start_ref, end_test, end_ref, kwargs,
--        fig_test, fig_ref,
--    ):
--        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
--        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
--
--    def plot_point_test(self, fig, point_kws):
--        b = Bloch(fig=fig)
--        for kw in point_kws:
--            points = kw.pop("points")
--            b.add_points(points, **kw)
--        b.render()
--
--    def plot_point_ref(self, fig, point_kws):
--        b = RefBloch(fig=fig)
--        b.render_back()
--        point_colors = ['b', 'r', 'g', '#CC6600']
--        point_sizes = [25, 32, 35, 45]
--        point_markers = ["o", "s", "d", "^"]
--
--        for idx, kw in enumerate(point_kws):
--            points = kw.pop("points")
--            if not isinstance(points[0], (list, tuple, np.ndarray)):
--                points = [[points[0]], [points[1]], [points[2]]]
--            points = np.array(points)
--
--            point_style = kw.pop("meth", "s")
--            colors = kw.pop("colors", None)
--            if colors is None and point_style in ['s', 'l']:
--                colors = point_colors[idx % len(point_colors)]
--            elif colors is None and point_style == 'm':
--                colors = np.tile(point_colors,
--                                 np.ceil(points.shape[1]/len(point_colors)
--                                         ).astype(int))
--                colors = colors[:points.shape[1]]
--            point_size = point_sizes[idx % len(point_sizes)]
--            point_marker = point_markers[idx % len(point_markers)]
--            point_alpha = kw.get("alpha", 1.0)
--
--            if len(points[0]) == 1 and point_style == "s":
--                points = np.append(points, points, axis=1)
--
--            if point_style == 's':
--                b.axes.scatter(
--                    np.real(points[1]),
--                    -np.real(points[0]),
--                    np.real(points[2]),
--                    s=point_size,
--                    alpha=point_alpha,
--                    edgecolor=None,
--                    zdir='z',
--                    color=colors,
--                    marker=point_marker)
--            elif point_style == 'l':
--                b.axes.plot(
--                    np.real(points[1]),
--                    -np.real(points[0]),
--                    np.real(points[2]),
--                    alpha=point_alpha,
--                    zdir='z',
--                    color=colors,
--                )
--            elif point_style == 'm':
--                b.axes.scatter(
--                    np.real(points[1]),
--                    -np.real(points[0]),
--                    np.real(points[2]),
--                    s=point_size,
--                    marker=point_marker,
--                    color=colors,
--                    alpha=point_alpha,
--                    edgecolor=None,
--                    zdir='z',
--                )
--            else:
--                raise ValueError(
--                    "Tests currently only support point method 's'"
--                )
--        b.render_front()
--
--    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
--                                                               "scatter",
--                                                               "line",
--                                                               "multicolored"])
--    @pytest.mark.parametrize([
--        "point_kws"
--    ], [
--        pytest.param(
--            dict(points=np.array([
--                [
--                    np.cos(np.pi / 4) * np.cos(t),
--                    np.sin(np.pi / 4) * np.cos(t),
--                    np.sin(t),
--                ]
--                for t in np.linspace(0, 2 * np.pi, 20)
--            ]).T, alpha=0.5), id="circle-of-points"),
--        pytest.param(
--            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
--        pytest.param(
--            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
--        pytest.param(
--            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
--        pytest.param(
--            dict(points=(0, 0, 1)), id="alpha-default"),
--        pytest.param(
--            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
--            id="color-green"),
--        pytest.param([
--            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
--            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
--        ], id="alpha-multiple-point-sets"),
--        pytest.param([
--            dict(points=[(0), (0), (1)], alpha=1.0),
--            dict(points=[(0), (1), (0)], alpha=1.0),
--            dict(points=[(1), (0), (0)], alpha=1.0),
--            dict(points=[(1), (1), (1)], alpha=1.0),
--        ], id="alpha-multiple-point-sets-all_sizes_markers"),
--    ])
--    @check_pngs_equal
--    def test_point(self, point_kws, meth, fig_test, fig_ref):
--        if meth and isinstance(point_kws, dict):
--            point_kws["meth"] = meth
--
--        elif meth and isinstance(point_kws, list):
--            for point_kw in point_kws:
--                point_kw["meth"] = meth
--
--        if isinstance(point_kws, dict):
--            point_kws = [point_kws]
--
--        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
--        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
--
--    def test_point_errors_meth(self):
--        with pytest.raises(ValueError) as err:
--            b = Bloch()
--            b.add_points((0, 0, 1), meth='k')
--            b.render()
--
--        err_msg = ("The value for meth = k is not valid."
--                   " Please use 's', 'l' or 'm'.")
--        assert str(err.value) == err_msg
--
--    @pytest.mark.parametrize("points",
--                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
--                              np.arange(12).reshape((3, 2, 2))],
--                             ids=["long_tuple", "short_tuple", "short_list",
--                                  "short_numpy", "wrong_shape_numpy"]
--                             )
--    def test_point_errors_wrong_points(self, points):
--        with pytest.raises(ValueError) as err:
--            b = Bloch()
--            b.add_points(points)
--            b.render()
--
--        err_msg = ("The included points are not valid. Points must "
--                   "be equivalent to a 2D array where the first "
--                   "index represents the x,y,z values and the "
--                   "second index iterates over the points.")
--        assert str(err.value) == err_msg
--
--    def plot_vector_test(self, fig, vector_kws):
--        b = Bloch(fig=fig)
--        for kw in vector_kws:
--            vectors = kw.pop("vectors")
--            b.add_vectors(vectors, **kw)
--        b.render()
--
--    def plot_vector_ref(self, fig, vector_kws):
--        from qutip.bloch import Arrow3D
--        b = RefBloch(fig=fig)
--        b.render_back()
--        vector_colors = ['g', '#CC6600', 'b', 'r']
--        idx = 0
--
--        for kw in vector_kws:
--            vectors = kw.pop("vectors")
--
--            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
--                vectors = [vectors]
--
--            colors = kw.pop("colors", None)
--            for k, v in enumerate(vectors):
--                if colors is None:
--                    color = vector_colors[idx % len(vector_colors)]
--                else:
--                    color = colors[k]
--
--                alpha = kw.get("alpha", 1.0)
--                idx += 1
--
--                xs3d = v[1] * np.array([0, 1])
--                ys3d = -v[0] * np.array([0, 1])
--                zs3d = v[2] * np.array([0, 1])
--                a = Arrow3D(
--                    xs3d, ys3d, zs3d,
--                    mutation_scale=20, lw=3, arrowstyle="-|>",
--                    color=color, alpha=alpha)
--                b.axes.add_artist(a)
--        b.render_front()
--
--    @pytest.mark.parametrize([
--        "vector_kws"
--    ], [
--        pytest.param(
--            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
--        pytest.param(
--            dict(vectors=[0, 0, 1]), id="single-vector-list"),
--        pytest.param(
--            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
--        pytest.param(
--            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
--        pytest.param(
--            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
--        pytest.param(
--            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
--        pytest.param(
--            dict(vectors=[
--                [
--                    np.cos(np.pi / 4) * np.cos(t),
--                    np.sin(np.pi / 4) * np.cos(t),
--                    np.sin(t),
--                ]
--                for t in np.linspace(0, 2 * np.pi, 20)
--            ], alpha=0.5), id="circle-of-vectors"),
--        pytest.param(
--            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
--        pytest.param(
--            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
--        pytest.param(
--            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
--        pytest.param(
--            dict(vectors=(0, 0, 1)), id="alpha-default"),
--        pytest.param([
--            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
--            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
--        ], id="alpha-multiple-vector-sets"),
--        pytest.param(
--            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
--        pytest.param(
--            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
--            id="color-two-y"),
--        pytest.param([
--            dict(vectors=[(0, 0, 1)], colors=['y']),
--            dict(vectors=[(1, 0, 1)], colors=['g']),
--        ], id="color-yg"),
--    ])
--    @check_pngs_equal
--    def test_vector(self, vector_kws, fig_test, fig_ref):
--        if isinstance(vector_kws, dict):
--            vector_kws = [vector_kws]
--        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
--        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
--
--    @pytest.mark.parametrize("vectors",
--                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
--                              np.arange(12).reshape((3, 2, 2))],
--                             ids=["long_tuple", "short_tuple", "short_list",
--                                  "short_numpy", "wrong_shape_numpy"]
--                             )
--    def test_vector_errors_wrong_vectors(self, vectors):
--        with pytest.raises(ValueError) as err:
--            b = Bloch()
--            b.add_vectors(vectors)
--            b.render()
--
--        err_msg = ("The included vectors are not valid. Vectors must "
--                   "be equivalent to a 2D array where the first "
--                   "index represents the iteration over the vectors and the "
--                   "second index represents the position in 3D of vector "
--                   "head.")
--        assert str(err.value) == err_msg
--
--    @pytest.mark.parametrize("vectors, colors",
--                             [([0, 0, 1], ['g', 'y']),
--                              ([[0, 0, 1], [0, 1, 0]], ['y']),
--                              ([0, 0, 1], [['g', 'y']])],
--                             ids=["one-vec-two-colors", "two-vec-one-color",
--                                  "wrong-dimension-list"]
--                             )
--    def test_vector_errors_color_length(self, vectors, colors):
--        with pytest.raises(ValueError) as err:
--            b = Bloch()
--            b.add_vectors(vectors, colors=colors)
--            b.render()
--
--        err_msg = ("The included colors are not valid. colors must "
--                   "be equivalent to a 1D array with the same "
--                   "size as the number of vectors. ")
--        assert str(err.value) == err_msg
--
--
--def test_repr_svg():
--    pytest.importorskip("matplotlib")
--    pytest.importorskip("ipython")
--    svg = Bloch()._repr_svg_()
--    assert isinstance(svg, str)
--    assert svg.startswith("<?xml")
--    assert svg.endswith("</svg>\n")
-+import copy
-+
-+import numpy as np
-+import pytest
-+
-+from qutip.bloch import Bloch
-+from qutip import ket, ket2dm
-+
-+try:
-+    import matplotlib.pyplot as plt
-+    from matplotlib.testing.decorators import check_figures_equal
-+    import IPython
-+    check_pngs_equal = check_figures_equal(extensions=["png"])
-+except ImportError:
-+    plt = None
-+    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
-+
-+
-+class RefBloch(Bloch):
-+    """ A helper for rendering reference Bloch spheres. """
-+    def render(self):
-+        raise NotImplementedError("RefBloch disables .render()")
-+
-+    def render_back(self):
-+        old_plot_front = self.plot_front
-+        self.plot_front = lambda: None
-+        try:
-+            Bloch.render(self)
-+        finally:
-+            self.plot_front = old_plot_front
-+
-+    def render_front(self):
-+        self.plot_front()
-+
-+
-+class TestBloch:
-+    def plot_arc_test(self, fig, *args, **kw):
-+        b = Bloch(fig=fig)
-+        b.add_arc(*args, **kw)
-+        b.render()
-+
-+    def plot_arc_ref(self, fig, start, end, **kw):
-+        fmt = kw.pop("fmt", "b")
-+        steps = kw.pop("steps", None)
-+        start = np.array(start)
-+        end = np.array(end)
-+        if steps is None:
-+            steps = int(np.linalg.norm(start - end) * 100)
-+            steps = max(2, steps)
-+
-+        t = np.linspace(0, 1, steps)
-+        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
-+        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
-+
-+        b = RefBloch(fig=fig)
-+        b.render_back()
-+        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
-+        b.render_front()
-+
-+    @pytest.mark.parametrize([
-+        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
-+    ], [
-+        pytest.param(
-+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
-+        pytest.param(
-+            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
-+            id="small-radius"),
-+        pytest.param(
-+            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
-+            id="tiny-radius"),
-+        pytest.param(
-+            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
-+            id="large-radius"),
-+        pytest.param(
-+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
-+            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
-+        ),
-+        pytest.param(
-+            ket("0"), (0, 0, 1),
-+            (ket("0") + ket("1")).unit(), (1, 0, 0),
-+            {}, id="kets",
-+        ),
-+        pytest.param(
-+            ket2dm(ket("0")), (0, 0, 1),
-+            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
-+            {}, id="dms",
-+        ),
-+        pytest.param(
-+            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
-+            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
-+            {}, id="non-unit-dms",
-+        ),
-+    ])
-+    @check_pngs_equal
-+    def test_arc(
-+        self, start_test, start_ref, end_test, end_ref, kwargs,
-+        fig_test, fig_ref,
-+    ):
-+        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
-+        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
-+
-+    @pytest.mark.parametrize([
-+        "start", "end", "err_msg",
-+    ], [
-+        pytest.param(
-+            (0, 0, 0), (0, 1, 0),
-+            "Polar and azimuthal angles undefined at origin.",
-+            id="start-origin",
-+        ),
-+        pytest.param(
-+            (1, 0, 0), (0, 0, 0),
-+            "Polar and azimuthal angles undefined at origin.",
-+            id="end-origin",
-+        ),
-+        pytest.param(
-+            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
-+            id="different-spheres",
-+        ),
-+        pytest.param(
-+            (1, 0, 0), (1, 0, 0),
-+            "Start and end represent the same point. No arc can be formed.",
-+            id="same-points",
-+        ),
-+        pytest.param(
-+            (1, 0, 0), (-1, 0, 0),
-+            "Start and end are diagonally opposite, no unique arc is"
-+            " possible.",
-+            id="opposite-points",
-+        ),
-+    ])
-+    def test_arc_errors(self, start, end, err_msg):
-+        b = Bloch()
-+        with pytest.raises(ValueError) as err:
-+            b.add_arc(start, end)
-+        assert str(err.value) == err_msg
-+
-+    def plot_line_test(self, fig, *args, **kw):
-+        b = Bloch(fig=fig)
-+        b.add_line(*args, **kw)
-+        b.render()
-+
-+    def plot_line_ref(self, fig, start, end, **kw):
-+        fmt = kw.pop("fmt", "k")
-+
-+        x = [start[1], end[1]]
-+        y = [-start[0], -end[0]]
-+        z = [start[2], end[2]]
-+
-+        b = RefBloch(fig=fig)
-+        b.render_back()
-+        b.axes.plot(x, y, z, fmt, **kw)
-+        b.render_front()
-+
-+    @pytest.mark.parametrize([
-+        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
-+    ], [
-+        pytest.param(
-+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
-+        pytest.param(
-+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
-+            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
-+        ),
-+        pytest.param(
-+            ket("0"), (0, 0, 1),
-+            (ket("0") + ket("1")).unit(), (1, 0, 0),
-+            {}, id="kets",
-+        ),
-+        pytest.param(
-+            ket2dm(ket("0")), (0, 0, 1),
-+            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
-+            {}, id="dms",
-+        ),
-+        pytest.param(
-+            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
-+            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
-+            {}, id="non-unit-dms",
-+        ),
-+    ])
-+    @check_pngs_equal
-+    def test_line(
-+        self, start_test, start_ref, end_test, end_ref, kwargs,
-+        fig_test, fig_ref,
-+    ):
-+        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
-+        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
-+
-+    def plot_point_test(self, fig, point_kws):
-+        b = Bloch(fig=fig)
-+        for kw in point_kws:
-+            points = kw.pop("points")
-+            b.add_points(points, **kw)
-+        b.render()
-+
-+    def plot_point_ref(self, fig, point_kws):
-+        b = RefBloch(fig=fig)
-+        b.render_back()
-+        point_colors = ['b', 'r', 'g', '#CC6600']
-+        point_sizes = [25, 32, 35, 45]
-+        point_markers = ["o", "s", "d", "^"]
-+
-+        for idx, kw in enumerate(point_kws):
-+            points = kw.pop("points")
-+            if not isinstance(points[0], (list, tuple, np.ndarray)):
-+                points = [[points[0]], [points[1]], [points[2]]]
-+            points = np.array(points)
-+
-+            point_style = kw.pop("meth", "s")
-+            colors = kw.pop("colors", None)
-+            if colors is None and point_style in ['s', 'l']:
-+                colors = point_colors[idx % len(point_colors)]
-+            elif colors is None and point_style == 'm':
-+                colors = np.tile(point_colors,
-+                                 np.ceil(points.shape[1]/len(point_colors)
-+                                         ).astype(int))
-+                colors = colors[:points.shape[1]]
-+            point_size = point_sizes[idx % len(point_sizes)]
-+            point_marker = point_markers[idx % len(point_markers)]
-+            point_alpha = kw.get("alpha", 1.0)
-+
-+            if len(points[0]) == 1 and point_style == "s":
-+                points = np.append(points, points, axis=1)
-+
-+            if point_style == 's':
-+                b.axes.scatter(
-+                    np.real(points[1]),
-+                    -np.real(points[0]),
-+                    np.real(points[2]),
-+                    s=point_size,
-+                    alpha=point_alpha,
-+                    edgecolor=None,
-+                    zdir='z',
-+                    color=colors,
-+                    marker=point_marker)
-+            elif point_style == 'l':
-+                b.axes.plot(
-+                    np.real(points[1]),
-+                    -np.real(points[0]),
-+                    np.real(points[2]),
-+                    alpha=point_alpha,
-+                    zdir='z',
-+                    color=colors,
-+                )
-+            elif point_style == 'm':
-+                b.axes.scatter(
-+                    np.real(points[1]),
-+                    -np.real(points[0]),
-+                    np.real(points[2]),
-+                    s=point_size,
-+                    marker=point_marker,
-+                    color=colors,
-+                    alpha=point_alpha,
-+                    edgecolor=None,
-+                    zdir='z',
-+                )
-+            else:
-+                raise ValueError(
-+                    "Tests currently only support point method 's'"
-+                )
-+        b.render_front()
-+
-+    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
-+                                                               "scatter",
-+                                                               "line",
-+                                                               "multicolored"])
-+    @pytest.mark.parametrize([
-+        "point_kws"
-+    ], [
-+        pytest.param(
-+            dict(points=np.array([
-+                [
-+                    np.cos(np.pi / 4) * np.cos(t),
-+                    np.sin(np.pi / 4) * np.cos(t),
-+                    np.sin(t),
-+                ]
-+                for t in np.linspace(0, 2 * np.pi, 20)
-+            ]).T, alpha=0.5), id="circle-of-points"),
-+        pytest.param(
-+            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
-+        pytest.param(
-+            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
-+        pytest.param(
-+            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
-+        pytest.param(
-+            dict(points=(0, 0, 1)), id="alpha-default"),
-+        pytest.param(
-+            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
-+            id="color-green"),
-+        pytest.param([
-+            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
-+            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
-+        ], id="alpha-multiple-point-sets"),
-+        pytest.param([
-+            dict(points=[(0), (0), (1)], alpha=1.0),
-+            dict(points=[(0), (1), (0)], alpha=1.0),
-+            dict(points=[(1), (0), (0)], alpha=1.0),
-+            dict(points=[(1), (1), (1)], alpha=1.0),
-+        ], id="alpha-multiple-point-sets-all_sizes_markers"),
-+    ])
-+    @check_pngs_equal
-+    def test_point(self, point_kws, meth, fig_test, fig_ref):
-+        if meth and isinstance(point_kws, dict):
-+            point_kws["meth"] = meth
-+
-+        elif meth and isinstance(point_kws, list):
-+            for point_kw in point_kws:
-+                point_kw["meth"] = meth
-+
-+        if isinstance(point_kws, dict):
-+            point_kws = [point_kws]
-+
-+        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
-+        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
-+
-+    def test_point_errors_meth(self):
-+        with pytest.raises(ValueError) as err:
-+            b = Bloch()
-+            b.add_points((0, 0, 1), meth='k')
-+            b.render()
-+
-+        err_msg = ("The value for meth = k is not valid."
-+                   " Please use 's', 'l' or 'm'.")
-+        assert str(err.value) == err_msg
-+
-+    @pytest.mark.parametrize("points",
-+                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
-+                              np.arange(12).reshape((3, 2, 2))],
-+                             ids=["long_tuple", "short_tuple", "short_list",
-+                                  "short_numpy", "wrong_shape_numpy"]
-+                             )
-+    def test_point_errors_wrong_points(self, points):
-+        with pytest.raises(ValueError) as err:
-+            b = Bloch()
-+            b.add_points(points)
-+            b.render()
-+
-+        err_msg = ("The included points are not valid. Points must "
-+                   "be equivalent to a 2D array where the first "
-+                   "index represents the x,y,z values and the "
-+                   "second index iterates over the points.")
-+        assert str(err.value) == err_msg
-+
-+    def plot_vector_test(self, fig, vector_kws):
-+        b = Bloch(fig=fig)
-+        for kw in vector_kws:
-+            vectors = kw.pop("vectors")
-+            b.add_vectors(vectors, **kw)
-+        b.render()
-+
-+    def plot_vector_ref(self, fig, vector_kws):
-+        from qutip.bloch import Arrow3D
-+        b = RefBloch(fig=fig)
-+        b.render_back()
-+        vector_colors = ['g', '#CC6600', 'b', 'r']
-+        idx = 0
-+
-+        for kw in vector_kws:
-+            vectors = kw.pop("vectors")
-+
-+            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
-+                vectors = [vectors]
-+
-+            colors = kw.pop("colors", None)
-+            for k, v in enumerate(vectors):
-+                if colors is None:
-+                    color = vector_colors[idx % len(vector_colors)]
-+                else:
-+                    color = colors[k]
-+
-+                alpha = kw.get("alpha", 1.0)
-+                idx += 1
-+
-+                xs3d = v[1] * np.array([0, 1])
-+                ys3d = -v[0] * np.array([0, 1])
-+                zs3d = v[2] * np.array([0, 1])
-+                a = Arrow3D(
-+                    xs3d, ys3d, zs3d,
-+                    mutation_scale=20, lw=3, arrowstyle="-|>",
-+                    color=color, alpha=alpha)
-+                b.axes.add_artist(a)
-+        b.render_front()
-+
-+    @pytest.mark.parametrize([
-+        "vector_kws"
-+    ], [
-+        pytest.param(
-+            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
-+        pytest.param(
-+            dict(vectors=[0, 0, 1]), id="single-vector-list"),
-+        pytest.param(
-+            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
-+        pytest.param(
-+            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
-+        pytest.param(
-+            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
-+        pytest.param(
-+            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
-+        pytest.param(
-+            dict(vectors=[
-+                [
-+                    np.cos(np.pi / 4) * np.cos(t),
-+                    np.sin(np.pi / 4) * np.cos(t),
-+                    np.sin(t),
-+                ]
-+                for t in np.linspace(0, 2 * np.pi, 20)
-+            ], alpha=0.5), id="circle-of-vectors"),
-+        pytest.param(
-+            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
-+        pytest.param(
-+            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
-+        pytest.param(
-+            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
-+        pytest.param(
-+            dict(vectors=(0, 0, 1)), id="alpha-default"),
-+        pytest.param([
-+            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
-+            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
-+        ], id="alpha-multiple-vector-sets"),
-+        pytest.param(
-+            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
-+        pytest.param(
-+            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
-+            id="color-two-y"),
-+        pytest.param([
-+            dict(vectors=[(0, 0, 1)], colors=['y']),
-+            dict(vectors=[(1, 0, 1)], colors=['g']),
-+        ], id="color-yg"),
-+    ])
-+    @check_pngs_equal
-+    def test_vector(self, vector_kws, fig_test, fig_ref):
-+        if isinstance(vector_kws, dict):
-+            vector_kws = [vector_kws]
-+        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
-+        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
-+
-+    @pytest.mark.parametrize("vectors",
-+                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
-+                              np.arange(12).reshape((3, 2, 2))],
-+                             ids=["long_tuple", "short_tuple", "short_list",
-+                                  "short_numpy", "wrong_shape_numpy"]
-+                             )
-+    def test_vector_errors_wrong_vectors(self, vectors):
-+        with pytest.raises(ValueError) as err:
-+            b = Bloch()
-+            b.add_vectors(vectors)
-+            b.render()
-+
-+        err_msg = ("The included vectors are not valid. Vectors must "
-+                   "be equivalent to a 2D array where the first "
-+                   "index represents the iteration over the vectors and the "
-+                   "second index represents the position in 3D of vector "
-+                   "head.")
-+        assert str(err.value) == err_msg
-+
-+    @pytest.mark.parametrize("vectors, colors",
-+                             [([0, 0, 1], ['g', 'y']),
-+                              ([[0, 0, 1], [0, 1, 0]], ['y']),
-+                              ([0, 0, 1], [['g', 'y']])],
-+                             ids=["one-vec-two-colors", "two-vec-one-color",
-+                                  "wrong-dimension-list"]
-+                             )
-+    def test_vector_errors_color_length(self, vectors, colors):
-+        with pytest.raises(ValueError) as err:
-+            b = Bloch()
-+            b.add_vectors(vectors, colors=colors)
-+            b.render()
-+
-+        err_msg = ("The included colors are not valid. colors must "
-+                   "be equivalent to a 1D array with the same "
-+                   "size as the number of vectors. ")
-+        assert str(err.value) == err_msg
-+
-+
-+def test_repr_svg():
-+    pytest.importorskip("matplotlib")
-+    pytest.importorskip("ipython")
-+    svg = Bloch()._repr_svg_()
-+    assert isinstance(svg, str)
-+    assert svg.startswith("<?xml")
-+    assert svg.endswith("</svg>\n")
-diff --git a/qutip/tests/test_enr_state_operator.py b/qutip/tests/test_enr_state_operator.py
-index 9002c375..d07b7ebb 100644
---- a/qutip/tests/test_enr_state_operator.py
-+++ b/qutip/tests/test_enr_state_operator.py
-@@ -1,116 +1,116 @@
--import pytest
--import itertools
--import random
--import numpy as np
--import qutip
--
--
--def _n_enr_states(dimensions, n_excitations):
--    """
--    Calculate the total number of distinct ENR states for a given set of
--    subspaces.  This method is not intended to be fast or efficient, it's
--    intended to be obviously correct for testing purposes.
--    """
--    count = 0
--    for excitations in itertools.product(*map(range, dimensions)):
--        count += int(sum(excitations) <= n_excitations)
--    return count
--
--
--@pytest.fixture(params=[
--    pytest.param([4], id="single"),
--    pytest.param([4]*2, id="tensor-equal-2"),
--    pytest.param([4]*3, id="tensor-equal-3"),
--    pytest.param([4]*4, id="tensor-equal-4"),
--    pytest.param([2, 3, 4], id="tensor-not-equal"),
--])
--def dimensions(request):
--    return request.param
--
--
--@pytest.fixture(params=[1, 2, 3, 1_000_000])
--def n_excitations(request):
--    return request.param
--
--
--class TestOperator:
--    def test_no_restrictions(self, dimensions):
--        """
--        Test that the restricted-excitation operators are equal to the standard
--        operators when there aren't any restrictions.
--        """
--        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
--        a = [qutip.destroy(n) for n in dimensions]
--        iden = [qutip.qeye(n) for n in dimensions]
--        for i, test in enumerate(test_operators):
--            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
--            assert test == expected
--            assert test.dims == [dimensions, dimensions]
--
--    def test_space_size_reduction(self, dimensions, n_excitations):
--        test_operators = qutip.enr_destroy(dimensions, n_excitations)
--        expected_size = _n_enr_states(dimensions, n_excitations)
--        expected_shape = (expected_size, expected_size)
--        for test in test_operators:
--            assert test.shape == expected_shape
--            assert test.dims == [dimensions, dimensions]
--
--    def test_identity(self, dimensions, n_excitations):
--        iden = qutip.enr_identity(dimensions, n_excitations)
--        expected_size = _n_enr_states(dimensions, n_excitations)
--        expected_shape = (expected_size, expected_size)
--        assert np.all(iden.diag() == 1)
--        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
--        assert iden.shape == expected_shape
--        assert iden.dims == [dimensions, dimensions]
--
--
--def test_fock_state(dimensions, n_excitations):
--    """
--    Test Fock state creation agrees with the number operators implied by the
--    existence of the ENR annihiliation operators.
--    """
--    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
--    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
--    n_samples = min((len(bases), 5))
--    for basis in random.sample(bases, n_samples):
--        state = qutip.enr_fock(dimensions, n_excitations, basis)
--        for n, x in zip(number, basis):
--            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
--
--
--def test_fock_state_error():
--    with pytest.raises(ValueError) as e:
--        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
--    assert str(e.value).startswith("The state tuple ")
--
--
--def _reference_dm(dimensions, n_excitations, nbars):
--    """
--    Get the reference density matrix explicitly, to compare to the direct ENR
--    construction.
--    """
--    if np.isscalar(nbars):
--        nbars = [nbars] * len(dimensions)
--    keep = np.array([
--        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
--        if sum(state) <= n_excitations
--    ])
--    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
--                       for dimension, nbar in zip(dimensions, nbars)])
--    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
--    return out / out.tr()
--
--
--@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
--def test_thermal_dm(dimensions, n_excitations, nbar_type):
--    # Ensure that the average number of excitations over all the states is
--    # much less than the total number of allowed excitations.
--    if nbar_type == "scalar":
--        nbars = 0.1 * n_excitations / len(dimensions)
--    else:
--        nbars = np.random.rand(len(dimensions))
--        nbars *= (0.1 * n_excitations) / np.sum(nbars)
--    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
--    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
--    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
-+import pytest
-+import itertools
-+import random
-+import numpy as np
-+import qutip
-+
-+
-+def _n_enr_states(dimensions, n_excitations):
-+    """
-+    Calculate the total number of distinct ENR states for a given set of
-+    subspaces.  This method is not intended to be fast or efficient, it's
-+    intended to be obviously correct for testing purposes.
-+    """
-+    count = 0
-+    for excitations in itertools.product(*map(range, dimensions)):
-+        count += int(sum(excitations) <= n_excitations)
-+    return count
-+
-+
-+@pytest.fixture(params=[
-+    pytest.param([4], id="single"),
-+    pytest.param([4]*2, id="tensor-equal-2"),
-+    pytest.param([4]*3, id="tensor-equal-3"),
-+    pytest.param([4]*4, id="tensor-equal-4"),
-+    pytest.param([2, 3, 4], id="tensor-not-equal"),
-+])
-+def dimensions(request):
-+    return request.param
-+
-+
-+@pytest.fixture(params=[1, 2, 3, 1_000_000])
-+def n_excitations(request):
-+    return request.param
-+
-+
-+class TestOperator:
-+    def test_no_restrictions(self, dimensions):
-+        """
-+        Test that the restricted-excitation operators are equal to the standard
-+        operators when there aren't any restrictions.
-+        """
-+        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
-+        a = [qutip.destroy(n) for n in dimensions]
-+        iden = [qutip.qeye(n) for n in dimensions]
-+        for i, test in enumerate(test_operators):
-+            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
-+            assert test == expected
-+            assert test.dims == [dimensions, dimensions]
-+
-+    def test_space_size_reduction(self, dimensions, n_excitations):
-+        test_operators = qutip.enr_destroy(dimensions, n_excitations)
-+        expected_size = _n_enr_states(dimensions, n_excitations)
-+        expected_shape = (expected_size, expected_size)
-+        for test in test_operators:
-+            assert test.shape == expected_shape
-+            assert test.dims == [dimensions, dimensions]
-+
-+    def test_identity(self, dimensions, n_excitations):
-+        iden = qutip.enr_identity(dimensions, n_excitations)
-+        expected_size = _n_enr_states(dimensions, n_excitations)
-+        expected_shape = (expected_size, expected_size)
-+        assert np.all(iden.diag() == 1)
-+        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
-+        assert iden.shape == expected_shape
-+        assert iden.dims == [dimensions, dimensions]
-+
-+
-+def test_fock_state(dimensions, n_excitations):
-+    """
-+    Test Fock state creation agrees with the number operators implied by the
-+    existence of the ENR annihiliation operators.
-+    """
-+    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
-+    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
-+    n_samples = min((len(bases), 5))
-+    for basis in random.sample(bases, n_samples):
-+        state = qutip.enr_fock(dimensions, n_excitations, basis)
-+        for n, x in zip(number, basis):
-+            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
-+
-+
-+def test_fock_state_error():
-+    with pytest.raises(ValueError) as e:
-+        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
-+    assert str(e.value).startswith("The state tuple ")
-+
-+
-+def _reference_dm(dimensions, n_excitations, nbars):
-+    """
-+    Get the reference density matrix explicitly, to compare to the direct ENR
-+    construction.
-+    """
-+    if np.isscalar(nbars):
-+        nbars = [nbars] * len(dimensions)
-+    keep = np.array([
-+        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
-+        if sum(state) <= n_excitations
-+    ])
-+    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
-+                       for dimension, nbar in zip(dimensions, nbars)])
-+    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
-+    return out / out.tr()
-+
-+
-+@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
-+def test_thermal_dm(dimensions, n_excitations, nbar_type):
-+    # Ensure that the average number of excitations over all the states is
-+    # much less than the total number of allowed excitations.
-+    if nbar_type == "scalar":
-+        nbars = 0.1 * n_excitations / len(dimensions)
-+    else:
-+        nbars = np.random.rand(len(dimensions))
-+        nbars *= (0.1 * n_excitations) / np.sum(nbars)
-+    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
-+    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
-+    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
-diff --git a/qutip/tests/test_entropy.py b/qutip/tests/test_entropy.py
-index ecf465c9..ea0f0c35 100644
---- a/qutip/tests/test_entropy.py
-+++ b/qutip/tests/test_entropy.py
-@@ -1,212 +1,212 @@
--import pytest
--import numpy as np
--import qutip
--
--
--class TestVonNeumannEntropy:
--    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
--    def test_binary(self, p):
--        dm = qutip.qdiags([p, 1 - p], 0)
--        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
--        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
--
--    @pytest.mark.repeat(10)
--    def test_pure_state(self):
--        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
--
--
--class TestLinearEntropy:
--    @pytest.mark.repeat(10)
--    def test_less_than_von_neumann(self):
--        dm = qutip.rand_dm(10)
--        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
--
--    @pytest.mark.repeat(10)
--    def test_pure_state(self):
--        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
--
--
--class TestConcurrence:
--    @pytest.mark.parametrize("dm", [
--        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
--        for x in ['00', '01', '10', '11']
--    ])
--    def test_maximally_entangled(self, dm):
--        assert abs(qutip.concurrence(dm) - 1) < 1e-12
--
--    @pytest.mark.repeat(10)
--    def test_nonzero(self):
--        dm = qutip.rand_dm([2, 2])
--        assert qutip.concurrence(dm) >= 0
--
--
--@pytest.mark.repeat(10)
--class TestMutualInformation:
--    def test_pure_state_additive(self):
--        # Verify mutual information = S(A) + S(B) for pure states.
--        dm = qutip.rand_dm([5, 5], distribution="pure")
--        expect = (qutip.entropy_vn(dm.ptrace(0))
--                  + qutip.entropy_vn(dm.ptrace(1)))
--        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
--
--    def test_component_selection(self):
--        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
--        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
--                  + qutip.entropy_vn(dm.ptrace(1)))
--        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
--
--
--class TestRelativeEntropy:
--    def _simple_relative_entropy_implementation(
--            self, rho, sigma, log_base=np.log, tol=1e-12):
--        """ A simplified relative entropy implementation for use in
--            double-checking the optimised implementation within
--            QuTiP itself.
--        """
--        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
--        rvals, rvecs = rho.eigenstates()
--        svals, svecs = sigma.eigenstates()
--        rvecs = np.hstack([vec.full() for vec in rvecs]).T
--        svecs = np.hstack([vec.full() for vec in svecs]).T
--        # Calculate S
--        S = 0
--        for i in range(len(rvals)):
--            if abs(rvals[i]) >= tol:
--                S += rvals[i] * log_base(rvals[i])
--            for j in range(len(svals)):
--                P_ij = (
--                    np.dot(rvecs[i], svecs[j].conjugate()) *
--                    np.dot(svecs[j], rvecs[i].conjugate())
--                )
--                if abs(svals[j]) < tol and not (
--                        abs(rvals[i]) < tol or abs(P_ij) < tol):
--                    # kernel of sigma intersects support of rho
--                    return np.inf
--                if abs(svals[j]) >= tol:
--                    S -= rvals[i] * P_ij * log_base(svals[j])
--        return np.real(S)
--
--    def test_rho_or_sigma_not_oper(self):
--        rho = qutip.bra("00")
--        sigma = qutip.bra("01")
--        with pytest.raises(TypeError) as exc:
--            qutip.entropy_relative(rho.dag(), sigma)
--        assert str(exc.value) == "Inputs must be density matrices."
--        with pytest.raises(TypeError) as exc:
--            qutip.entropy_relative(rho, sigma.dag())
--        assert str(exc.value) == "Inputs must be density matrices."
--        with pytest.raises(TypeError) as exc:
--            qutip.entropy_relative(rho, sigma)
--        assert str(exc.value) == "Inputs must be density matrices."
--
--    def test_rho_and_sigma_have_different_shape_and_dims(self):
--        # test different shape and dims
--        rho = qutip.ket("00")
--        sigma = qutip.ket("0")
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho, sigma)
--        assert str(exc.value) == "Inputs must have the same shape and dims."
--        # test same shape, difference dims
--        rho = qutip.basis([2, 3], [0, 0])
--        sigma = qutip.basis([3, 2], [0, 0])
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho, sigma)
--        assert str(exc.value) == "Inputs must have the same shape and dims."
--
--    def test_base_not_2_or_e(self):
--        rho = qutip.ket("00")
--        sigma = qutip.ket("01")
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho, sigma, base=3)
--        assert str(exc.value) == "Base must be 2 or e."
--
--    def test_infinite_relative_entropy(self):
--        rho = qutip.ket("00")
--        sigma = qutip.ket("01")
--        assert qutip.entropy_relative(rho, sigma) == np.inf
--
--    def test_base_2_or_e(self):
--        rho = qutip.ket2dm(qutip.ket("00"))
--        sigma = rho + qutip.ket2dm(qutip.ket("01"))
--        sigma = sigma.unit()
--        assert (
--            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
--        )
--        assert (
--            qutip.entropy_relative(rho, sigma, base=np.e)
--            == pytest.approx(0.69314718)
--        )
--        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
--
--    def test_pure_vs_maximally_mixed_state(self):
--        rho = qutip.ket("00")
--        sigma = sum(
--            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
--        ).unit()
--        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
--
--    def test_density_matrices_with_non_real_eigenvalues(self):
--        rho = qutip.ket2dm(qutip.ket("00"))
--        sigma = qutip.ket2dm(qutip.ket("01"))
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho + 1j, sigma)
--        assert str(exc.value) == "Input rho has non-real eigenvalues."
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho - 1j, sigma)
--        assert str(exc.value) == "Input rho has non-real eigenvalues."
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho, sigma + 1j)
--        assert str(exc.value) == "Input sigma has non-real eigenvalues."
--        with pytest.raises(ValueError) as exc:
--            qutip.entropy_relative(rho, sigma - 1j)
--        assert str(exc.value) == "Input sigma has non-real eigenvalues."
--
--    @pytest.mark.repeat(20)
--    def test_random_dm_with_self(self):
--        rho = qutip.rand_dm(8)
--        rel = qutip.entropy_relative(rho, rho)
--        assert abs(rel) < 1e-13
--
--    @pytest.mark.repeat(20)
--    def test_random_rho_sigma(self):
--        rho = qutip.rand_dm(8)
--        sigma = qutip.rand_dm(8)
--        rel = qutip.entropy_relative(rho, sigma)
--        assert rel >= 0
--        assert rel == pytest.approx(
--            self._simple_relative_entropy_implementation(rho, sigma, np.log)
--        )
--
--
--@pytest.mark.repeat(20)
--class TestConditionalEntropy:
--    def test_inequality_3_qubits(self):
--        # S(A | B,C) <= S(A|B)
--        full = qutip.rand_dm([2]*3, distribution="pure")
--        ab = full.ptrace([0, 1])
--        assert (qutip.entropy_conditional(full, [1, 2])
--                <= qutip.entropy_conditional(ab, 1))
--
--    def test_triangle_inequality_4_qubits(self):
--        # S(A,B | C,D) <= S(A|C) + S(B|D)
--        full = qutip.rand_dm([2]*4, distribution="pure")
--        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
--        assert (qutip.entropy_conditional(full, [2, 3])
--                <= (qutip.entropy_conditional(ac, 1)
--                    + qutip.entropy_conditional(bd, 1)))
--
--
--_alpha = 2*np.pi * np.random.rand()
--
--
--@pytest.mark.parametrize(["gate", "expected"], [
--    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
--    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
--    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
--    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
--    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
--    pytest.param(qutip.gates.swapalpha(_alpha),
--                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
--])
--def test_entangling_power(gate, expected):
--    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
-+import pytest
-+import numpy as np
-+import qutip
-+
-+
-+class TestVonNeumannEntropy:
-+    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
-+    def test_binary(self, p):
-+        dm = qutip.qdiags([p, 1 - p], 0)
-+        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
-+        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
-+
-+    @pytest.mark.repeat(10)
-+    def test_pure_state(self):
-+        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
-+
-+
-+class TestLinearEntropy:
-+    @pytest.mark.repeat(10)
-+    def test_less_than_von_neumann(self):
-+        dm = qutip.rand_dm(10)
-+        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
-+
-+    @pytest.mark.repeat(10)
-+    def test_pure_state(self):
-+        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
-+
-+
-+class TestConcurrence:
-+    @pytest.mark.parametrize("dm", [
-+        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
-+        for x in ['00', '01', '10', '11']
-+    ])
-+    def test_maximally_entangled(self, dm):
-+        assert abs(qutip.concurrence(dm) - 1) < 1e-12
-+
-+    @pytest.mark.repeat(10)
-+    def test_nonzero(self):
-+        dm = qutip.rand_dm([2, 2])
-+        assert qutip.concurrence(dm) >= 0
-+
-+
-+@pytest.mark.repeat(10)
-+class TestMutualInformation:
-+    def test_pure_state_additive(self):
-+        # Verify mutual information = S(A) + S(B) for pure states.
-+        dm = qutip.rand_dm([5, 5], distribution="pure")
-+        expect = (qutip.entropy_vn(dm.ptrace(0))
-+                  + qutip.entropy_vn(dm.ptrace(1)))
-+        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
-+
-+    def test_component_selection(self):
-+        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
-+        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
-+                  + qutip.entropy_vn(dm.ptrace(1)))
-+        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
-+
-+
-+class TestRelativeEntropy:
-+    def _simple_relative_entropy_implementation(
-+            self, rho, sigma, log_base=np.log, tol=1e-12):
-+        """ A simplified relative entropy implementation for use in
-+            double-checking the optimised implementation within
-+            QuTiP itself.
-+        """
-+        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
-+        rvals, rvecs = rho.eigenstates()
-+        svals, svecs = sigma.eigenstates()
-+        rvecs = np.hstack([vec.full() for vec in rvecs]).T
-+        svecs = np.hstack([vec.full() for vec in svecs]).T
-+        # Calculate S
-+        S = 0
-+        for i in range(len(rvals)):
-+            if abs(rvals[i]) >= tol:
-+                S += rvals[i] * log_base(rvals[i])
-+            for j in range(len(svals)):
-+                P_ij = (
-+                    np.dot(rvecs[i], svecs[j].conjugate()) *
-+                    np.dot(svecs[j], rvecs[i].conjugate())
-+                )
-+                if abs(svals[j]) < tol and not (
-+                        abs(rvals[i]) < tol or abs(P_ij) < tol):
-+                    # kernel of sigma intersects support of rho
-+                    return np.inf
-+                if abs(svals[j]) >= tol:
-+                    S -= rvals[i] * P_ij * log_base(svals[j])
-+        return np.real(S)
-+
-+    def test_rho_or_sigma_not_oper(self):
-+        rho = qutip.bra("00")
-+        sigma = qutip.bra("01")
-+        with pytest.raises(TypeError) as exc:
-+            qutip.entropy_relative(rho.dag(), sigma)
-+        assert str(exc.value) == "Inputs must be density matrices."
-+        with pytest.raises(TypeError) as exc:
-+            qutip.entropy_relative(rho, sigma.dag())
-+        assert str(exc.value) == "Inputs must be density matrices."
-+        with pytest.raises(TypeError) as exc:
-+            qutip.entropy_relative(rho, sigma)
-+        assert str(exc.value) == "Inputs must be density matrices."
-+
-+    def test_rho_and_sigma_have_different_shape_and_dims(self):
-+        # test different shape and dims
-+        rho = qutip.ket("00")
-+        sigma = qutip.ket("0")
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho, sigma)
-+        assert str(exc.value) == "Inputs must have the same shape and dims."
-+        # test same shape, difference dims
-+        rho = qutip.basis([2, 3], [0, 0])
-+        sigma = qutip.basis([3, 2], [0, 0])
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho, sigma)
-+        assert str(exc.value) == "Inputs must have the same shape and dims."
-+
-+    def test_base_not_2_or_e(self):
-+        rho = qutip.ket("00")
-+        sigma = qutip.ket("01")
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho, sigma, base=3)
-+        assert str(exc.value) == "Base must be 2 or e."
-+
-+    def test_infinite_relative_entropy(self):
-+        rho = qutip.ket("00")
-+        sigma = qutip.ket("01")
-+        assert qutip.entropy_relative(rho, sigma) == np.inf
-+
-+    def test_base_2_or_e(self):
-+        rho = qutip.ket2dm(qutip.ket("00"))
-+        sigma = rho + qutip.ket2dm(qutip.ket("01"))
-+        sigma = sigma.unit()
-+        assert (
-+            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
-+        )
-+        assert (
-+            qutip.entropy_relative(rho, sigma, base=np.e)
-+            == pytest.approx(0.69314718)
-+        )
-+        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
-+
-+    def test_pure_vs_maximally_mixed_state(self):
-+        rho = qutip.ket("00")
-+        sigma = sum(
-+            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
-+        ).unit()
-+        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
-+
-+    def test_density_matrices_with_non_real_eigenvalues(self):
-+        rho = qutip.ket2dm(qutip.ket("00"))
-+        sigma = qutip.ket2dm(qutip.ket("01"))
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho + 1j, sigma)
-+        assert str(exc.value) == "Input rho has non-real eigenvalues."
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho - 1j, sigma)
-+        assert str(exc.value) == "Input rho has non-real eigenvalues."
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho, sigma + 1j)
-+        assert str(exc.value) == "Input sigma has non-real eigenvalues."
-+        with pytest.raises(ValueError) as exc:
-+            qutip.entropy_relative(rho, sigma - 1j)
-+        assert str(exc.value) == "Input sigma has non-real eigenvalues."
-+
-+    @pytest.mark.repeat(20)
-+    def test_random_dm_with_self(self):
-+        rho = qutip.rand_dm(8)
-+        rel = qutip.entropy_relative(rho, rho)
-+        assert abs(rel) < 1e-13
-+
-+    @pytest.mark.repeat(20)
-+    def test_random_rho_sigma(self):
-+        rho = qutip.rand_dm(8)
-+        sigma = qutip.rand_dm(8)
-+        rel = qutip.entropy_relative(rho, sigma)
-+        assert rel >= 0
-+        assert rel == pytest.approx(
-+            self._simple_relative_entropy_implementation(rho, sigma, np.log)
-+        )
-+
-+
-+@pytest.mark.repeat(20)
-+class TestConditionalEntropy:
-+    def test_inequality_3_qubits(self):
-+        # S(A | B,C) <= S(A|B)
-+        full = qutip.rand_dm([2]*3, distribution="pure")
-+        ab = full.ptrace([0, 1])
-+        assert (qutip.entropy_conditional(full, [1, 2])
-+                <= qutip.entropy_conditional(ab, 1))
-+
-+    def test_triangle_inequality_4_qubits(self):
-+        # S(A,B | C,D) <= S(A|C) + S(B|D)
-+        full = qutip.rand_dm([2]*4, distribution="pure")
-+        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
-+        assert (qutip.entropy_conditional(full, [2, 3])
-+                <= (qutip.entropy_conditional(ac, 1)
-+                    + qutip.entropy_conditional(bd, 1)))
-+
-+
-+_alpha = 2*np.pi * np.random.rand()
-+
-+
-+@pytest.mark.parametrize(["gate", "expected"], [
-+    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
-+    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
-+    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
-+    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
-+    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
-+    pytest.param(qutip.gates.swapalpha(_alpha),
-+                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
-+])
-+def test_entangling_power(gate, expected):
-+    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
-diff --git a/qutip/tests/test_fileio.py b/qutip/tests/test_fileio.py
-index 74337606..13e20458 100644
---- a/qutip/tests/test_fileio.py
-+++ b/qutip/tests/test_fileio.py
-@@ -1,62 +1,62 @@
--import pytest
--import numpy as np
--import uuid
--import qutip
--from pathlib import Path
--
--# qsave _always_ appends a suffix to the file name at the time of writing, but
--# in case this changes in the future, to ensure that we never leak a temporary
--# file into the user's folders, we simply apply these tests in a temporary
--# directory.  Windows also does not allow temporary files to be opened multiple
--# times, so using a temporary directory is best.
--pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
--
--_dimension = 10
--
--
--def _random_file_name():
--    return "_" + str(uuid.uuid4())
--
--
--class Test_file_data_store_file_data_read:
--    # Tests parametrised seprately to give nicer descriptions in verbose mode.
--
--    def case(self, filename, kwargs):
--        data = 1 - 2*np.random.rand(_dimension, _dimension)
--        if kwargs.get('numtype', 'complex') == 'complex':
--            data = data * (0.5*0.5j)
--        qutip.file_data_store(filename, data, **kwargs)
--        out = qutip.file_data_read(filename)
--        np.testing.assert_allclose(data, out, atol=1e-8)
--
--    def test_defaults(self):
--        return self.case(_random_file_name(), {})
--
--    @pytest.mark.parametrize("type_", ["real", "complex"])
--    @pytest.mark.parametrize("format_", ["decimal", "exp"])
--    def test_type_format(self, type_, format_):
--
--        kwargs = {'numtype': type_, 'numformat': format_}
--        return self.case(_random_file_name(), kwargs)
--
--    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
--                             ids=lambda x: "'" + x + "'")
--    def test_separator_detection(self, separator):
--        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
--        return self.case(_random_file_name(), kwargs)
--
--
--@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
--@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
--def test_qsave_qload(use_path, suffix):
--    ops_in = [qutip.sigmax(),
--              qutip.num(_dimension),
--              qutip.coherent_dm(_dimension, 1j)]
--    filename = _random_file_name() + suffix
--    if use_path:
--        filename = Path.cwd() / filename
--    qutip.qsave(ops_in, filename)
--    ops_out = qutip.qload(filename)
--    assert ops_in == ops_out
--    # check that the file was saved with the correct name:
--    assert Path(str(filename) + ".qu").exists()
-+import pytest
-+import numpy as np
-+import uuid
-+import qutip
-+from pathlib import Path
-+
-+# qsave _always_ appends a suffix to the file name at the time of writing, but
-+# in case this changes in the future, to ensure that we never leak a temporary
-+# file into the user's folders, we simply apply these tests in a temporary
-+# directory.  Windows also does not allow temporary files to be opened multiple
-+# times, so using a temporary directory is best.
-+pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
-+
-+_dimension = 10
-+
-+
-+def _random_file_name():
-+    return "_" + str(uuid.uuid4())
-+
-+
-+class Test_file_data_store_file_data_read:
-+    # Tests parametrised seprately to give nicer descriptions in verbose mode.
-+
-+    def case(self, filename, kwargs):
-+        data = 1 - 2*np.random.rand(_dimension, _dimension)
-+        if kwargs.get('numtype', 'complex') == 'complex':
-+            data = data * (0.5*0.5j)
-+        qutip.file_data_store(filename, data, **kwargs)
-+        out = qutip.file_data_read(filename)
-+        np.testing.assert_allclose(data, out, atol=1e-8)
-+
-+    def test_defaults(self):
-+        return self.case(_random_file_name(), {})
-+
-+    @pytest.mark.parametrize("type_", ["real", "complex"])
-+    @pytest.mark.parametrize("format_", ["decimal", "exp"])
-+    def test_type_format(self, type_, format_):
-+
-+        kwargs = {'numtype': type_, 'numformat': format_}
-+        return self.case(_random_file_name(), kwargs)
-+
-+    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
-+                             ids=lambda x: "'" + x + "'")
-+    def test_separator_detection(self, separator):
-+        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
-+        return self.case(_random_file_name(), kwargs)
-+
-+
-+@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
-+@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
-+def test_qsave_qload(use_path, suffix):
-+    ops_in = [qutip.sigmax(),
-+              qutip.num(_dimension),
-+              qutip.coherent_dm(_dimension, 1j)]
-+    filename = _random_file_name() + suffix
-+    if use_path:
-+        filename = Path.cwd() / filename
-+    qutip.qsave(ops_in, filename)
-+    ops_out = qutip.qload(filename)
-+    assert ops_in == ops_out
-+    # check that the file was saved with the correct name:
-+    assert Path(str(filename) + ".qu").exists()
-diff --git a/qutip/tests/test_ipynbtools.py b/qutip/tests/test_ipynbtools.py
-index 2b1c7655..25f3ec16 100644
---- a/qutip/tests/test_ipynbtools.py
-+++ b/qutip/tests/test_ipynbtools.py
-@@ -1,24 +1,24 @@
--from qutip.ipynbtools import version_table
--import pytest
--
--
--@pytest.mark.parametrize('verbose', [False, True])
--def test_version_table(verbose):
--    html_data = version_table(verbose=verbose).data
--    assert "<th>Software</th>" in html_data
--    assert "<th>Version</th>" in html_data
--    assert "<td>QuTiP</td>" in html_data
--    assert "<td>Numpy</td>" in html_data
--    assert "<td>SciPy</td>" in html_data
--    assert "<td>matplotlib</td>" in html_data
--    assert "<td>IPython</td>" in html_data
--    if verbose:
--        assert "<td>Installation path</td>" in html_data
--        if pytest.importorskip("getpass") is not None:
--            assert "<td>User</td>" in html_data
--
--
--@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
--def test_version_table_with_cython():
--    html_data = version_table().data
--    assert "<td>Cython</td>" in html_data
-+from qutip.ipynbtools import version_table
-+import pytest
-+
-+
-+@pytest.mark.parametrize('verbose', [False, True])
-+def test_version_table(verbose):
-+    html_data = version_table(verbose=verbose).data
-+    assert "<th>Software</th>" in html_data
-+    assert "<th>Version</th>" in html_data
-+    assert "<td>QuTiP</td>" in html_data
-+    assert "<td>Numpy</td>" in html_data
-+    assert "<td>SciPy</td>" in html_data
-+    assert "<td>matplotlib</td>" in html_data
-+    assert "<td>IPython</td>" in html_data
-+    if verbose:
-+        assert "<td>Installation path</td>" in html_data
-+        if pytest.importorskip("getpass") is not None:
-+            assert "<td>User</td>" in html_data
-+
-+
-+@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
-+def test_version_table_with_cython():
-+    html_data = version_table().data
-+    assert "<td>Cython</td>" in html_data
-diff --git a/qutip/tests/test_measurement.py b/qutip/tests/test_measurement.py
-index 6bccd1a3..b904e2c3 100644
---- a/qutip/tests/test_measurement.py
-+++ b/qutip/tests/test_measurement.py
-@@ -1,324 +1,324 @@
--import numpy as np
--import scipy
--import pytest
--from math import sqrt
--from qutip import (
--    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
--    rand_ket,
--)
--from qutip.measurement import (
--    measure_povm, measurement_statistics_povm, measure_observable,
--    measurement_statistics_observable,
--)
--
--
--class EigenPairs:
--    """ Manage pairs of eigenvalues and eigenstates for an operator. """
--    def __init__(self, pairs):
--        self.pairs = pairs
--        self.eigenvalues = [p[0] for p in pairs]
--        self.eigenstates = [p[1] for p in pairs]
--        self.projectors = [v * v.dag() for v in self.eigenstates]
--
--    def __getitem__(self, i):
--        return self.pairs[i]
--
--    def __contains__(self, other):
--        for i, val in enumerate(self.eigenvalues):
--            if abs(val - other[0]) < 1e-8:
--                break
--        else:
--            return False
--        return _equivalent(other[1], self.eigenstates[i])
--
--
--def pairs2dm(pairs):
--    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
--    return [(v, e.proj()) for v, e in pairs]
--
--
--SIGMAZ = EigenPairs([
--    (-1.0, -basis(2, 1)),
--    (1.0, -basis(2, 0)),
--])
--
--SIGMAX = EigenPairs([
--    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
--    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
--])
--
--SIGMAY = EigenPairs([
--    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
--    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
--])
--
--state0 = basis(2, 0)
--state1 = basis(2, 1)
--stateplus = (basis(2, 0) + basis(2, 1)).unit()
--stateminus = (basis(2, 0) - basis(2, 1)).unit()
--stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
--stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
--PZ = [ket2dm(state0), ket2dm(state1)]
--PX = [ket2dm(stateplus), ket2dm(stateminus)]
--PY = [ket2dm(stateR), ket2dm(stateL)]
--PZ_ket = [state0, state1]
--
--
--def _equivalent(left, right, tol=1e-8):
--    """ Equal up to a phase """
--    return 1 - abs(left.overlap(right)) < tol
--
--
--@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
--    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
--    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
--    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
--    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
--                 id="sigmax_dm"),
--    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
--    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
--                 id="sigmay_dm"),
--])
--def test_measurement_statistics_observable(op, state, pairs, probabilities):
--    """ measurement_statistics_observable: observables on basis states. """
--
--    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
--    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
--    if state.isket:
--        ess = ess_or_projs
--        assert len(ess) == len(pairs.eigenstates)
--        for a, b in zip(ess, pairs.eigenstates):
--            assert _equivalent(a, b)
--    else:
--        projs = ess_or_projs
--        assert len(projs) == len(pairs.projectors)
--        for a, b in zip(projs, pairs.projectors):
--            assert _equivalent(a, b)
--    np.testing.assert_almost_equal(probs, probabilities)
--
--
--@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
--    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
--    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
--                 id="PZ_dm"),
--    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
--    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
--                 id="PZket_dm"),
--    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
--                 id="PX_ket"),
--    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
--                 [0.5, 0.5], id="PX_dm"),
--    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
--    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
--                 [0.5, 0.5], id="PY_dm")])
--def test_measurement_statistics_povm(ops, state, final_states, probabilities):
--    """ measurement_statistics_povm: projectors applied to basis states. """
--
--    collapsed_states, probs = measurement_statistics_povm(state, ops)
--    for i, final_state in enumerate(final_states):
--        collapsed_state = collapsed_states[i]
--        if final_state:
--            assert collapsed_state == final_state
--        else:
--            assert collapsed_state is None
--    np.testing.assert_almost_equal(probs, probabilities)
--
--
--def test_measurement_statistics_povm_input_errors():
--    """ measurement_statistics_povm: check input errors """
--
--    np.testing.assert_raises_regex(
--        ValueError, "op must be all operators or all kets",
--        measurement_statistics_povm,
--        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
--    np.testing.assert_raises_regex(
--        TypeError, "state must be a Qobj",
--        measurement_statistics_povm, "notqobj", [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError, "state must be a ket or a density matrix",
--        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should be compatible when state is a ket",
--        measurement_statistics_povm, basis(3, 0), [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should match when state is a density matrix",
--        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "measurement operators must sum to identity",
--        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "measurement operators must sum to identity",
--        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
--
--
--def test_measurement_statistics_observable_input_errors():
--    """ measurement_statistics_observable: check input errors """
--
--    np.testing.assert_raises_regex(
--        TypeError, "op must be a Qobj",
--        measurement_statistics_observable, basis(2, 0), "notqobj")
--    np.testing.assert_raises_regex(
--        ValueError, "op must be all operators or all kets",
--        measurement_statistics_observable, basis(2, 0), basis(2, 1))
--    np.testing.assert_raises_regex(
--        TypeError, "state must be a Qobj",
--        measurement_statistics_observable, "notqobj",  sigmaz())
--    np.testing.assert_raises_regex(
--        ValueError, "state must be a ket or a density matrix",
--        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should be compatible when state is a ket",
--        measurement_statistics_observable, basis(3, 0), sigmaz())
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should match when state is a density matrix",
--        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
--
--
--@pytest.mark.parametrize(["op", "state"], [
--                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
--                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
--                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
--                                 id="sigmaz_dm1"),
--                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
--                                 id="sigmaz_dm2"),
--
--                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
--                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
--                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
--                                 id="sigmax_dm"),
--
--                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
--                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
--                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
--                                 id="sigmay_dm")])
--def test_measure_observable(op, state):
--    """ measure_observable: basis states using different observables """
--    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
--
--    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
--    for _ in range(10):
--        assert (measure_observable(state, op) in expected_measurements)
--
--
--@pytest.mark.parametrize(["ops", "state"], [
--
--                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
--                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
--                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
--                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
--
--                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
--                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
--                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
--                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
--
--                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
--                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
--                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
--
--                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
--                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
--                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
--def test_measure(ops, state):
--    """measure_povm: test on basis states using different projectors """
--
--    collapsed_states, _ = measurement_statistics_povm(state, ops)
--    for _ in range(10):
--        index, final_state = measure_povm(state, ops)
--        assert final_state == collapsed_states[index]
--
--
--def test_measure_input_errors():
--    """ measure_povm: check input errors """
--    np.testing.assert_raises_regex(
--        ValueError, "op must be all operators or all kets",
--        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
--    np.testing.assert_raises_regex(
--        TypeError, "state must be a Qobj",
--        measure_povm, "notqobj", [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError, "state must be a ket or a density matrix",
--        measure_povm, basis(2, 0).dag(), [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should be compatible when state is a ket",
--        measure_povm, basis(3, 0), [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should match when state is a density matrix",
--        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "measurement operators must sum to identity",
--        measure_povm, basis(2, 0), [basis(2, 0)])
--    np.testing.assert_raises_regex(
--        ValueError,
--        "measurement operators must sum to identity",
--        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
--
--
--def test_measure_observable_input_errors():
--    """ measure_observable: check input errors """
--    np.testing.assert_raises_regex(
--        TypeError, "op must be a Qobj",
--        measure_observable, basis(2, 0), "notqobj")
--    np.testing.assert_raises_regex(
--        ValueError, "op must be all operators or all kets",
--        measure_observable, basis(2, 0),  basis(2, 1))
--    np.testing.assert_raises_regex(
--        TypeError, "state must be a Qobj",
--        measure_observable, "notqobj", sigmaz())
--    np.testing.assert_raises_regex(
--        ValueError, "state must be a ket or a density matrix",
--        measure_observable, basis(2, 0).dag(), sigmaz())
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should be compatible when state is a ket",
--        measure_observable, basis(3, 0), sigmaz())
--    np.testing.assert_raises_regex(
--        ValueError,
--        "op and state dims should match when state is a density matrix",
--        measure_observable, ket2dm(basis(3, 0)), sigmaz())
--
--
--def test_povm():
--    """
--    Test if povm formulation works correctly by checking probabilities for
--    the quantum state discrimination example
--    """
--
--    coeff = (sqrt(2)/(1+sqrt(2)))
--
--    E_1 = coeff * ket2dm(basis(2, 1))
--    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
--    E_3 = identity(2) - E_1 - E_2
--
--    M_1 = E_1.sqrtm()
--    M_2 = E_2.sqrtm()
--    M_3 = E_3.sqrtm()
--
--    ket1 = basis(2, 0)
--    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
--
--    dm1 = ket2dm(ket1)
--    dm2 = ket2dm(ket2)
--
--    M = [M_1, M_2, M_3]
--
--    _, probabilities = measurement_statistics_povm(ket1, M)
--    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
--
--    _, probabilities = measurement_statistics_povm(ket2, M)
--    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
--
--    _, probabilities = measurement_statistics_povm(dm1, M)
--    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
--
--    _, probabilities = measurement_statistics_povm(dm2, M)
--    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
-+import numpy as np
-+import scipy
-+import pytest
-+from math import sqrt
-+from qutip import (
-+    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
-+    rand_ket,
-+)
-+from qutip.measurement import (
-+    measure_povm, measurement_statistics_povm, measure_observable,
-+    measurement_statistics_observable,
-+)
-+
-+
-+class EigenPairs:
-+    """ Manage pairs of eigenvalues and eigenstates for an operator. """
-+    def __init__(self, pairs):
-+        self.pairs = pairs
-+        self.eigenvalues = [p[0] for p in pairs]
-+        self.eigenstates = [p[1] for p in pairs]
-+        self.projectors = [v * v.dag() for v in self.eigenstates]
-+
-+    def __getitem__(self, i):
-+        return self.pairs[i]
-+
-+    def __contains__(self, other):
-+        for i, val in enumerate(self.eigenvalues):
-+            if abs(val - other[0]) < 1e-8:
-+                break
-+        else:
-+            return False
-+        return _equivalent(other[1], self.eigenstates[i])
-+
-+
-+def pairs2dm(pairs):
-+    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
-+    return [(v, e.proj()) for v, e in pairs]
-+
-+
-+SIGMAZ = EigenPairs([
-+    (-1.0, -basis(2, 1)),
-+    (1.0, -basis(2, 0)),
-+])
-+
-+SIGMAX = EigenPairs([
-+    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
-+    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
-+])
-+
-+SIGMAY = EigenPairs([
-+    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
-+    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
-+])
-+
-+state0 = basis(2, 0)
-+state1 = basis(2, 1)
-+stateplus = (basis(2, 0) + basis(2, 1)).unit()
-+stateminus = (basis(2, 0) - basis(2, 1)).unit()
-+stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
-+stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
-+PZ = [ket2dm(state0), ket2dm(state1)]
-+PX = [ket2dm(stateplus), ket2dm(stateminus)]
-+PY = [ket2dm(stateR), ket2dm(stateL)]
-+PZ_ket = [state0, state1]
-+
-+
-+def _equivalent(left, right, tol=1e-8):
-+    """ Equal up to a phase """
-+    return 1 - abs(left.overlap(right)) < tol
-+
-+
-+@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
-+    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
-+    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
-+    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
-+    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
-+                 id="sigmax_dm"),
-+    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
-+    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
-+                 id="sigmay_dm"),
-+])
-+def test_measurement_statistics_observable(op, state, pairs, probabilities):
-+    """ measurement_statistics_observable: observables on basis states. """
-+
-+    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
-+    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
-+    if state.isket:
-+        ess = ess_or_projs
-+        assert len(ess) == len(pairs.eigenstates)
-+        for a, b in zip(ess, pairs.eigenstates):
-+            assert _equivalent(a, b)
-+    else:
-+        projs = ess_or_projs
-+        assert len(projs) == len(pairs.projectors)
-+        for a, b in zip(projs, pairs.projectors):
-+            assert _equivalent(a, b)
-+    np.testing.assert_almost_equal(probs, probabilities)
-+
-+
-+@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
-+    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
-+    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
-+                 id="PZ_dm"),
-+    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
-+    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
-+                 id="PZket_dm"),
-+    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
-+                 id="PX_ket"),
-+    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
-+                 [0.5, 0.5], id="PX_dm"),
-+    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
-+    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
-+                 [0.5, 0.5], id="PY_dm")])
-+def test_measurement_statistics_povm(ops, state, final_states, probabilities):
-+    """ measurement_statistics_povm: projectors applied to basis states. """
-+
-+    collapsed_states, probs = measurement_statistics_povm(state, ops)
-+    for i, final_state in enumerate(final_states):
-+        collapsed_state = collapsed_states[i]
-+        if final_state:
-+            assert collapsed_state == final_state
-+        else:
-+            assert collapsed_state is None
-+    np.testing.assert_almost_equal(probs, probabilities)
-+
-+
-+def test_measurement_statistics_povm_input_errors():
-+    """ measurement_statistics_povm: check input errors """
-+
-+    np.testing.assert_raises_regex(
-+        ValueError, "op must be all operators or all kets",
-+        measurement_statistics_povm,
-+        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
-+    np.testing.assert_raises_regex(
-+        TypeError, "state must be a Qobj",
-+        measurement_statistics_povm, "notqobj", [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError, "state must be a ket or a density matrix",
-+        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should be compatible when state is a ket",
-+        measurement_statistics_povm, basis(3, 0), [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should match when state is a density matrix",
-+        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "measurement operators must sum to identity",
-+        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "measurement operators must sum to identity",
-+        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
-+
-+
-+def test_measurement_statistics_observable_input_errors():
-+    """ measurement_statistics_observable: check input errors """
-+
-+    np.testing.assert_raises_regex(
-+        TypeError, "op must be a Qobj",
-+        measurement_statistics_observable, basis(2, 0), "notqobj")
-+    np.testing.assert_raises_regex(
-+        ValueError, "op must be all operators or all kets",
-+        measurement_statistics_observable, basis(2, 0), basis(2, 1))
-+    np.testing.assert_raises_regex(
-+        TypeError, "state must be a Qobj",
-+        measurement_statistics_observable, "notqobj",  sigmaz())
-+    np.testing.assert_raises_regex(
-+        ValueError, "state must be a ket or a density matrix",
-+        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should be compatible when state is a ket",
-+        measurement_statistics_observable, basis(3, 0), sigmaz())
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should match when state is a density matrix",
-+        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
-+
-+
-+@pytest.mark.parametrize(["op", "state"], [
-+                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
-+                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
-+                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
-+                                 id="sigmaz_dm1"),
-+                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
-+                                 id="sigmaz_dm2"),
-+
-+                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
-+                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
-+                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
-+                                 id="sigmax_dm"),
-+
-+                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
-+                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
-+                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
-+                                 id="sigmay_dm")])
-+def test_measure_observable(op, state):
-+    """ measure_observable: basis states using different observables """
-+    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
-+
-+    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
-+    for _ in range(10):
-+        assert (measure_observable(state, op) in expected_measurements)
-+
-+
-+@pytest.mark.parametrize(["ops", "state"], [
-+
-+                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
-+                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
-+                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
-+                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
-+
-+                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
-+                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
-+                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
-+                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
-+
-+                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
-+                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
-+                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
-+
-+                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
-+                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
-+                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
-+def test_measure(ops, state):
-+    """measure_povm: test on basis states using different projectors """
-+
-+    collapsed_states, _ = measurement_statistics_povm(state, ops)
-+    for _ in range(10):
-+        index, final_state = measure_povm(state, ops)
-+        assert final_state == collapsed_states[index]
-+
-+
-+def test_measure_input_errors():
-+    """ measure_povm: check input errors """
-+    np.testing.assert_raises_regex(
-+        ValueError, "op must be all operators or all kets",
-+        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
-+    np.testing.assert_raises_regex(
-+        TypeError, "state must be a Qobj",
-+        measure_povm, "notqobj", [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError, "state must be a ket or a density matrix",
-+        measure_povm, basis(2, 0).dag(), [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should be compatible when state is a ket",
-+        measure_povm, basis(3, 0), [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should match when state is a density matrix",
-+        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "measurement operators must sum to identity",
-+        measure_povm, basis(2, 0), [basis(2, 0)])
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "measurement operators must sum to identity",
-+        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
-+
-+
-+def test_measure_observable_input_errors():
-+    """ measure_observable: check input errors """
-+    np.testing.assert_raises_regex(
-+        TypeError, "op must be a Qobj",
-+        measure_observable, basis(2, 0), "notqobj")
-+    np.testing.assert_raises_regex(
-+        ValueError, "op must be all operators or all kets",
-+        measure_observable, basis(2, 0),  basis(2, 1))
-+    np.testing.assert_raises_regex(
-+        TypeError, "state must be a Qobj",
-+        measure_observable, "notqobj", sigmaz())
-+    np.testing.assert_raises_regex(
-+        ValueError, "state must be a ket or a density matrix",
-+        measure_observable, basis(2, 0).dag(), sigmaz())
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should be compatible when state is a ket",
-+        measure_observable, basis(3, 0), sigmaz())
-+    np.testing.assert_raises_regex(
-+        ValueError,
-+        "op and state dims should match when state is a density matrix",
-+        measure_observable, ket2dm(basis(3, 0)), sigmaz())
-+
-+
-+def test_povm():
-+    """
-+    Test if povm formulation works correctly by checking probabilities for
-+    the quantum state discrimination example
-+    """
-+
-+    coeff = (sqrt(2)/(1+sqrt(2)))
-+
-+    E_1 = coeff * ket2dm(basis(2, 1))
-+    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
-+    E_3 = identity(2) - E_1 - E_2
-+
-+    M_1 = E_1.sqrtm()
-+    M_2 = E_2.sqrtm()
-+    M_3 = E_3.sqrtm()
-+
-+    ket1 = basis(2, 0)
-+    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
-+
-+    dm1 = ket2dm(ket1)
-+    dm2 = ket2dm(ket2)
-+
-+    M = [M_1, M_2, M_3]
-+
-+    _, probabilities = measurement_statistics_povm(ket1, M)
-+    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
-+
-+    _, probabilities = measurement_statistics_povm(ket2, M)
-+    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
-+
-+    _, probabilities = measurement_statistics_povm(dm1, M)
-+    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
-+
-+    _, probabilities = measurement_statistics_povm(dm2, M)
-+    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
-diff --git a/qutip/tests/test_mkl.py b/qutip/tests/test_mkl.py
-index 734f33e2..3eeb83f1 100644
---- a/qutip/tests/test_mkl.py
-+++ b/qutip/tests/test_mkl.py
-@@ -1,116 +1,116 @@
--import pytest
--import numpy as np
--import scipy.linalg
--import scipy.sparse
--
--import qutip
--if qutip.settings.has_mkl:
--    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
--
--pytestmark = [
--    pytest.mark.skipif(not qutip.settings.has_mkl,
--                       reason='MKL extensions not found.'),
--]
--
--
--class Test_spsolve:
--    def test_single_rhs_vector_real(self):
--        Adense = np.array([[0, 1, 1],
--                           [1, 0, 1],
--                           [0, 0, 1]])
--        As = scipy.sparse.csr_matrix(Adense)
--        np.random.seed(1234)
--        x = np.random.randn(3)
--        b = As * x
--        x2 = mkl_spsolve(As, b, verbose=True)
--        np.testing.assert_allclose(x, x2)
--
--    def test_single_rhs_vector_complex(self):
--        A = qutip.rand_herm(10, density=0.8, dtype='csr')
--        x = qutip.rand_ket(10).full()
--        b = A.full() @ x
--        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
--        np.testing.assert_allclose(x, y)
--
--    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
--    def test_multi_rhs_vector(self, dtype):
--        M = np.array([
--            [1, 0, 2],
--            [0, 0, 3],
--            [-4, 5, 6],
--        ], dtype=dtype)
--        sM = scipy.sparse.csr_matrix(M)
--        N = np.array([
--            [3, 0, 1],
--            [0, 2, 0],
--            [0, 0, 0],
--        ], dtype=dtype)
--        sX = mkl_spsolve(sM, N, verbose=True)
--        X = scipy.linalg.solve(M, N)
--        np.testing.assert_allclose(X, sX)
--
--    def test_rhs_shape_is_maintained(self):
--        A = scipy.sparse.csr_matrix(np.array([
--            [1, 0, 2],
--            [0, 0, 3],
--            [-4, 5, 6],
--        ], dtype=np.complex128))
--        b = np.array([0, 2, 0], dtype=np.complex128)
--        out = mkl_spsolve(A, b, verbose=True)
--        assert b.shape == out.shape
--
--        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
--        out = mkl_spsolve(A, b, verbose=True)
--        assert b.shape == out.shape
--
--    def test_sparse_rhs(self):
--        A = scipy.sparse.csr_matrix([
--            [1, 2, 0],
--            [0, 3, 0],
--            [0, 0, 5],
--        ])
--        b = scipy.sparse.csr_matrix([
--            [0, 1],
--            [1, 0],
--            [0, 0],
--        ])
--        x = mkl_spsolve(A, b, verbose=True)
--        ans = np.array([[-0.66666667, 1],
--                        [0.33333333, 0],
--                        [0, 0]])
--        np.testing.assert_allclose(x.toarray(), ans)
--
--    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
--    def test_symmetric_solver(self, dtype):
--        A = qutip.rand_herm(10, distribution="eigen",
--                            eigenvalues=np.arange(1, 11),
--                            dtype='csr').data.as_scipy()
--        if dtype == np.float64:
--            A = A.real
--        x = np.ones(10, dtype=dtype)
--        b = A.dot(x)
--        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
--        np.testing.assert_allclose(x, y)
--
--
--class Test_splu:
--    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
--    def test_repeated_rhs_solve(self, dtype):
--        M = np.array([
--            [1, 0, 2],
--            [0, 0, 3],
--            [-4, 5, 6],
--        ], dtype=dtype)
--        sM = scipy.sparse.csr_matrix(M)
--        N = np.array([
--            [3, 0, 1],
--            [0, 2, 0],
--            [0, 0, 0],
--        ], dtype=dtype)
--        test_X = np.zeros((3, 3), dtype=dtype)
--        lu = mkl_splu(sM, verbose=True)
--        for k in range(3):
--            test_X[:, k] = lu.solve(N[:, k])
--        lu.delete()
--        expected_X = scipy.linalg.solve(M, N)
--        np.testing.assert_allclose(test_X, expected_X)
-+import pytest
-+import numpy as np
-+import scipy.linalg
-+import scipy.sparse
-+
-+import qutip
-+if qutip.settings.has_mkl:
-+    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
-+
-+pytestmark = [
-+    pytest.mark.skipif(not qutip.settings.has_mkl,
-+                       reason='MKL extensions not found.'),
-+]
-+
-+
-+class Test_spsolve:
-+    def test_single_rhs_vector_real(self):
-+        Adense = np.array([[0, 1, 1],
-+                           [1, 0, 1],
-+                           [0, 0, 1]])
-+        As = scipy.sparse.csr_matrix(Adense)
-+        np.random.seed(1234)
-+        x = np.random.randn(3)
-+        b = As * x
-+        x2 = mkl_spsolve(As, b, verbose=True)
-+        np.testing.assert_allclose(x, x2)
-+
-+    def test_single_rhs_vector_complex(self):
-+        A = qutip.rand_herm(10, density=0.8, dtype='csr')
-+        x = qutip.rand_ket(10).full()
-+        b = A.full() @ x
-+        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
-+        np.testing.assert_allclose(x, y)
-+
-+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-+    def test_multi_rhs_vector(self, dtype):
-+        M = np.array([
-+            [1, 0, 2],
-+            [0, 0, 3],
-+            [-4, 5, 6],
-+        ], dtype=dtype)
-+        sM = scipy.sparse.csr_matrix(M)
-+        N = np.array([
-+            [3, 0, 1],
-+            [0, 2, 0],
-+            [0, 0, 0],
-+        ], dtype=dtype)
-+        sX = mkl_spsolve(sM, N, verbose=True)
-+        X = scipy.linalg.solve(M, N)
-+        np.testing.assert_allclose(X, sX)
-+
-+    def test_rhs_shape_is_maintained(self):
-+        A = scipy.sparse.csr_matrix(np.array([
-+            [1, 0, 2],
-+            [0, 0, 3],
-+            [-4, 5, 6],
-+        ], dtype=np.complex128))
-+        b = np.array([0, 2, 0], dtype=np.complex128)
-+        out = mkl_spsolve(A, b, verbose=True)
-+        assert b.shape == out.shape
-+
-+        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
-+        out = mkl_spsolve(A, b, verbose=True)
-+        assert b.shape == out.shape
-+
-+    def test_sparse_rhs(self):
-+        A = scipy.sparse.csr_matrix([
-+            [1, 2, 0],
-+            [0, 3, 0],
-+            [0, 0, 5],
-+        ])
-+        b = scipy.sparse.csr_matrix([
-+            [0, 1],
-+            [1, 0],
-+            [0, 0],
-+        ])
-+        x = mkl_spsolve(A, b, verbose=True)
-+        ans = np.array([[-0.66666667, 1],
-+                        [0.33333333, 0],
-+                        [0, 0]])
-+        np.testing.assert_allclose(x.toarray(), ans)
-+
-+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-+    def test_symmetric_solver(self, dtype):
-+        A = qutip.rand_herm(10, distribution="eigen",
-+                            eigenvalues=np.arange(1, 11),
-+                            dtype='csr').data.as_scipy()
-+        if dtype == np.float64:
-+            A = A.real
-+        x = np.ones(10, dtype=dtype)
-+        b = A.dot(x)
-+        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
-+        np.testing.assert_allclose(x, y)
-+
-+
-+class Test_splu:
-+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-+    def test_repeated_rhs_solve(self, dtype):
-+        M = np.array([
-+            [1, 0, 2],
-+            [0, 0, 3],
-+            [-4, 5, 6],
-+        ], dtype=dtype)
-+        sM = scipy.sparse.csr_matrix(M)
-+        N = np.array([
-+            [3, 0, 1],
-+            [0, 2, 0],
-+            [0, 0, 0],
-+        ], dtype=dtype)
-+        test_X = np.zeros((3, 3), dtype=dtype)
-+        lu = mkl_splu(sM, verbose=True)
-+        for k in range(3):
-+            test_X[:, k] = lu.solve(N[:, k])
-+        lu.delete()
-+        expected_X = scipy.linalg.solve(M, N)
-+        np.testing.assert_allclose(test_X, expected_X)
-diff --git a/qutip/tests/test_openmp.py b/qutip/tests/test_openmp.py
-index 05804ca5..604df3c6 100644
---- a/qutip/tests/test_openmp.py
-+++ b/qutip/tests/test_openmp.py
-@@ -1,111 +1,111 @@
--import numpy as np
--from numpy.testing import assert_equal, assert_, run_module_suite
--import unittest
--from qutip import *
--from qutip.settings import settings as qset
--# if qset.has_openmp:
--#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
--
--
--# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
--@unittest.skipIf(True, 'OPENMP disabled.')
--def test_openmp_spmv():
--    "OPENMP : spmvpy_openmp == spmvpy"
--    for k in range(100):
--        L = rand_herm(10,0.25).data
--        vec = rand_ket(L.shape[0],0.25).full().ravel()
--        out = np.zeros_like(vec)
--        out_openmp = np.zeros_like(vec)
--        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
--        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
--        assert_(np.allclose(out, out_openmp, 1e-15))
--
--# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
--@unittest.skipIf(True, 'OPENMP disabled.')
--def test_openmp_mesolve():
--    "OPENMP : mesolve"
--    N = 100
--    wc = 1.0  * 2 * np.pi  # cavity frequency
--    wa = 1.0  * 2 * np.pi  # atom frequency
--    g  = 0.05 * 2 * np.pi  # coupling strength
--    kappa = 0.005          # cavity dissipation rate
--    gamma = 0.05           # atom dissipation rate
--    n_th_a = 1           # temperature in frequency units
--    use_rwa = 0
--    # operators
--    a  = tensor(destroy(N), qeye(2))
--    sm = tensor(qeye(N), destroy(2))
--    # Hamiltonian
--    if use_rwa:
--        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
--    else:
--        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
--    c_op_list = []
--
--    rate = kappa * (1 + n_th_a)
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * a)
--
--    rate = kappa * n_th_a
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * a.dag())
--
--    rate = gamma
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * sm)
--
--    n = N - 2
--    psi0 = tensor(basis(N, n), basis(2, 1))
--    tlist = np.linspace(0, 1, 100)
--    opts = SolverOptions(use_openmp=False)
--    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
--    opts = SolverOptions(use_openmp=True)
--    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
--    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
--    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
--
--
--# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
--@unittest.skipIf(True, 'OPENMP disabled.')
--def test_openmp_mesolve_td():
--    "OPENMP : mesolve (td)"
--    N = 100
--    wc = 1.0  * 2 * np.pi  # cavity frequency
--    wa = 1.0  * 2 * np.pi  # atom frequency
--    g  = 0.5 * 2 * np.pi  # coupling strength
--    kappa = 0.005          # cavity dissipation rate
--    gamma = 0.05           # atom dissipation rate
--    n_th_a = 1           # temperature in frequency units
--    use_rwa = 0
--    # operators
--    a  = tensor(destroy(N), qeye(2))
--    sm = tensor(qeye(N), destroy(2))
--    # Hamiltonian
--    H0 = wc * a.dag() * a + wa * sm.dag() * sm
--    H1 = g * (a.dag() + a) * (sm + sm.dag())
--
--    H = [H0, [H1,'sin(t)']]
--
--    c_op_list = []
--
--    rate = kappa * (1 + n_th_a)
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * a)
--
--    rate = kappa * n_th_a
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * a.dag())
--
--    rate = gamma
--    if rate > 0.0:
--        c_op_list.append(np.sqrt(rate) * sm)
--
--    n = N - 10
--    psi0 = tensor(basis(N, n), basis(2, 1))
--    tlist = np.linspace(0, 1, 100)
--    opts = SolverOptions(use_openmp=True)
--    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
--    opts = SolverOptions(use_openmp=False)
--    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
--    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
--    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
-+import numpy as np
-+from numpy.testing import assert_equal, assert_, run_module_suite
-+import unittest
-+from qutip import *
-+from qutip.settings import settings as qset
-+# if qset.has_openmp:
-+#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
-+
-+
-+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-+@unittest.skipIf(True, 'OPENMP disabled.')
-+def test_openmp_spmv():
-+    "OPENMP : spmvpy_openmp == spmvpy"
-+    for k in range(100):
-+        L = rand_herm(10,0.25).data
-+        vec = rand_ket(L.shape[0],0.25).full().ravel()
-+        out = np.zeros_like(vec)
-+        out_openmp = np.zeros_like(vec)
-+        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
-+        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
-+        assert_(np.allclose(out, out_openmp, 1e-15))
-+
-+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-+@unittest.skipIf(True, 'OPENMP disabled.')
-+def test_openmp_mesolve():
-+    "OPENMP : mesolve"
-+    N = 100
-+    wc = 1.0  * 2 * np.pi  # cavity frequency
-+    wa = 1.0  * 2 * np.pi  # atom frequency
-+    g  = 0.05 * 2 * np.pi  # coupling strength
-+    kappa = 0.005          # cavity dissipation rate
-+    gamma = 0.05           # atom dissipation rate
-+    n_th_a = 1           # temperature in frequency units
-+    use_rwa = 0
-+    # operators
-+    a  = tensor(destroy(N), qeye(2))
-+    sm = tensor(qeye(N), destroy(2))
-+    # Hamiltonian
-+    if use_rwa:
-+        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
-+    else:
-+        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
-+    c_op_list = []
-+
-+    rate = kappa * (1 + n_th_a)
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * a)
-+
-+    rate = kappa * n_th_a
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * a.dag())
-+
-+    rate = gamma
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * sm)
-+
-+    n = N - 2
-+    psi0 = tensor(basis(N, n), basis(2, 1))
-+    tlist = np.linspace(0, 1, 100)
-+    opts = SolverOptions(use_openmp=False)
-+    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-+    opts = SolverOptions(use_openmp=True)
-+    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-+    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-+    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
-+
-+
-+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-+@unittest.skipIf(True, 'OPENMP disabled.')
-+def test_openmp_mesolve_td():
-+    "OPENMP : mesolve (td)"
-+    N = 100
-+    wc = 1.0  * 2 * np.pi  # cavity frequency
-+    wa = 1.0  * 2 * np.pi  # atom frequency
-+    g  = 0.5 * 2 * np.pi  # coupling strength
-+    kappa = 0.005          # cavity dissipation rate
-+    gamma = 0.05           # atom dissipation rate
-+    n_th_a = 1           # temperature in frequency units
-+    use_rwa = 0
-+    # operators
-+    a  = tensor(destroy(N), qeye(2))
-+    sm = tensor(qeye(N), destroy(2))
-+    # Hamiltonian
-+    H0 = wc * a.dag() * a + wa * sm.dag() * sm
-+    H1 = g * (a.dag() + a) * (sm + sm.dag())
-+
-+    H = [H0, [H1,'sin(t)']]
-+
-+    c_op_list = []
-+
-+    rate = kappa * (1 + n_th_a)
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * a)
-+
-+    rate = kappa * n_th_a
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * a.dag())
-+
-+    rate = gamma
-+    if rate > 0.0:
-+        c_op_list.append(np.sqrt(rate) * sm)
-+
-+    n = N - 10
-+    psi0 = tensor(basis(N, n), basis(2, 1))
-+    tlist = np.linspace(0, 1, 100)
-+    opts = SolverOptions(use_openmp=True)
-+    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-+    opts = SolverOptions(use_openmp=False)
-+    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-+    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-+    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
-diff --git a/qutip/tests/test_orbital.py b/qutip/tests/test_orbital.py
-index e5a18297..0fe0fb3f 100644
---- a/qutip/tests/test_orbital.py
-+++ b/qutip/tests/test_orbital.py
-@@ -1,55 +1,55 @@
--import pytest
--from scipy.special import sph_harm
--from qutip.orbital import orbital
--import qutip
--import numpy as np
--
--
--def test_orbital_single_ket():
--    """ Checks output for a single ket as input"""
--    # setup mesh for theta and phi
--    theta_list = np.linspace(0, np.pi, num=50)
--    phi_list = np.linspace(0, 2 * np.pi, num=100)
--    for theta, phi in zip(theta_list, phi_list):
--        # set l and m
--        for l in range(0, 5):
--            for m in range(-l, l + 1):
--                q = qutip.basis(2 * l + 1, l + m)
--                # check that outputs are the same,
--                # note that theta and phi are interchanged for scipy
--                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
--
--
--def test_orbital_multiple_ket():
--    """ Checks if the combination of multiple kets works """
--    theta_list = np.linspace(0, np.pi, num=50)
--    phi_list = np.linspace(0, 2 * np.pi, num=100)
--    l, m = 5, 2
--    q1 = qutip.basis(2 * l + 1, l + m)
--    l, m = 3, -1
--    q2 = qutip.basis(2 * l + 1, l + m)
--    for theta, phi in zip(theta_list, phi_list):
--        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
--        assert orbital(theta, phi, q1, q2) ==  exp
--
--
--def test_orbital_explicit():
--    """ Checks explicit configurations of orbital functions"""
--    theta_list = np.linspace(0, np.pi, num=50)
--    phi_list = np.linspace(0, 2 * np.pi, num=100)
--    # Constant function
--    l, m = 0, 0
--    q = qutip.basis(2 * l + 1, l + m)
--    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
--    # cosine function
--    l, m = 1, 0
--    q = qutip.basis(2 * l + 1, l + m)
--    assert np.allclose(orbital(theta_list, 0, q),
--                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
--    # cosine with phase
--    l, m = 1, 1
--    q = qutip.basis(2 * l + 1, l + m)
--    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
--    assert np.allclose(orbital(theta_list, phi_list, q),
--                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
--                           theta_mesh) * np.exp(1j * phi_mesh))
-+import pytest
-+from scipy.special import sph_harm
-+from qutip.orbital import orbital
-+import qutip
-+import numpy as np
-+
-+
-+def test_orbital_single_ket():
-+    """ Checks output for a single ket as input"""
-+    # setup mesh for theta and phi
-+    theta_list = np.linspace(0, np.pi, num=50)
-+    phi_list = np.linspace(0, 2 * np.pi, num=100)
-+    for theta, phi in zip(theta_list, phi_list):
-+        # set l and m
-+        for l in range(0, 5):
-+            for m in range(-l, l + 1):
-+                q = qutip.basis(2 * l + 1, l + m)
-+                # check that outputs are the same,
-+                # note that theta and phi are interchanged for scipy
-+                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
-+
-+
-+def test_orbital_multiple_ket():
-+    """ Checks if the combination of multiple kets works """
-+    theta_list = np.linspace(0, np.pi, num=50)
-+    phi_list = np.linspace(0, 2 * np.pi, num=100)
-+    l, m = 5, 2
-+    q1 = qutip.basis(2 * l + 1, l + m)
-+    l, m = 3, -1
-+    q2 = qutip.basis(2 * l + 1, l + m)
-+    for theta, phi in zip(theta_list, phi_list):
-+        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
-+        assert orbital(theta, phi, q1, q2) ==  exp
-+
-+
-+def test_orbital_explicit():
-+    """ Checks explicit configurations of orbital functions"""
-+    theta_list = np.linspace(0, np.pi, num=50)
-+    phi_list = np.linspace(0, 2 * np.pi, num=100)
-+    # Constant function
-+    l, m = 0, 0
-+    q = qutip.basis(2 * l + 1, l + m)
-+    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
-+    # cosine function
-+    l, m = 1, 0
-+    q = qutip.basis(2 * l + 1, l + m)
-+    assert np.allclose(orbital(theta_list, 0, q),
-+                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
-+    # cosine with phase
-+    l, m = 1, 1
-+    q = qutip.basis(2 * l + 1, l + m)
-+    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
-+    assert np.allclose(orbital(theta_list, phi_list, q),
-+                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
-+                           theta_mesh) * np.exp(1j * phi_mesh))
-diff --git a/qutip/tests/test_partial_transpose.py b/qutip/tests/test_partial_transpose.py
-index 02d3fec3..26dffb3a 100644
---- a/qutip/tests/test_partial_transpose.py
-+++ b/qutip/tests/test_partial_transpose.py
-@@ -1,78 +1,78 @@
--"""
--Unit tests for QuTiP partial transpose functions.
--"""
--
--import numpy as np
--from numpy.testing import assert_, run_module_suite
--
--from qutip import Qobj, partial_transpose, tensor, rand_dm
--from qutip.partial_transpose import _partial_transpose_reference
--
--
--def test_partial_transpose_bipartite():
--    """partial transpose of bipartite systems"""
--
--    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
--
--    # no transpose
--    rho_pt = partial_transpose(rho, [0, 0])
--    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
--
--    # partial transpose subsystem 1
--    rho_pt = partial_transpose(rho, [1, 0])
--    rho_pt_expected = np.array([[0, 1,  8,  9],
--                                [4, 5, 12, 13],
--                                [2, 3, 10, 11],
--                                [6, 7, 14, 15]])
--    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
--
--    # partial transpose subsystem 2
--    rho_pt = partial_transpose(rho, [0, 1])
--    rho_pt_expected = np.array([[0, 4, 2, 6],
--                                [1, 5, 3, 7],
--                                [8, 12, 10, 14],
--                                [9, 13, 11, 15]])
--    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
--
--    # full transpose
--    rho_pt = partial_transpose(rho, [1, 1])
--    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
--
--
--def test_partial_transpose_comparison():
--    """partial transpose: comparing sparse and dense implementations"""
--
--    N = 10
--    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
--
--    # partial transpose of system 1
--    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
--    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
--    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
--
--    # partial transpose of system 2
--    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
--    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
--    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
--
--
--def test_partial_transpose_randomized():
--    """partial transpose: randomized tests on tripartite system"""
--
--    rho = tensor(rand_dm(2, density=1),
--                 rand_dm(2, density=1),
--                 rand_dm(2, density=1))
--
--    mask = np.random.randint(2, size=3)
--
--    rho_pt_ref = _partial_transpose_reference(rho, mask)
--
--    rho_pt1 = partial_transpose(rho, mask, method="dense")
--    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
--
--    rho_pt2 = partial_transpose(rho, mask, method="sparse")
--    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
--
--
--if __name__ == "__main__":
--    run_module_suite()
-+"""
-+Unit tests for QuTiP partial transpose functions.
-+"""
-+
-+import numpy as np
-+from numpy.testing import assert_, run_module_suite
-+
-+from qutip import Qobj, partial_transpose, tensor, rand_dm
-+from qutip.partial_transpose import _partial_transpose_reference
-+
-+
-+def test_partial_transpose_bipartite():
-+    """partial transpose of bipartite systems"""
-+
-+    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
-+
-+    # no transpose
-+    rho_pt = partial_transpose(rho, [0, 0])
-+    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
-+
-+    # partial transpose subsystem 1
-+    rho_pt = partial_transpose(rho, [1, 0])
-+    rho_pt_expected = np.array([[0, 1,  8,  9],
-+                                [4, 5, 12, 13],
-+                                [2, 3, 10, 11],
-+                                [6, 7, 14, 15]])
-+    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
-+
-+    # partial transpose subsystem 2
-+    rho_pt = partial_transpose(rho, [0, 1])
-+    rho_pt_expected = np.array([[0, 4, 2, 6],
-+                                [1, 5, 3, 7],
-+                                [8, 12, 10, 14],
-+                                [9, 13, 11, 15]])
-+    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
-+
-+    # full transpose
-+    rho_pt = partial_transpose(rho, [1, 1])
-+    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
-+
-+
-+def test_partial_transpose_comparison():
-+    """partial transpose: comparing sparse and dense implementations"""
-+
-+    N = 10
-+    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
-+
-+    # partial transpose of system 1
-+    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
-+    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
-+    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
-+
-+    # partial transpose of system 2
-+    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
-+    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
-+    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
-+
-+
-+def test_partial_transpose_randomized():
-+    """partial transpose: randomized tests on tripartite system"""
-+
-+    rho = tensor(rand_dm(2, density=1),
-+                 rand_dm(2, density=1),
-+                 rand_dm(2, density=1))
-+
-+    mask = np.random.randint(2, size=3)
-+
-+    rho_pt_ref = _partial_transpose_reference(rho, mask)
-+
-+    rho_pt1 = partial_transpose(rho, mask, method="dense")
-+    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
-+
-+    rho_pt2 = partial_transpose(rho, mask, method="sparse")
-+    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
-+
-+
-+if __name__ == "__main__":
-+    run_module_suite()
-diff --git a/qutip/tests/test_qip.py b/qutip/tests/test_qip.py
-index d0168787..3f34d4f0 100644
---- a/qutip/tests/test_qip.py
-+++ b/qutip/tests/test_qip.py
-@@ -1,46 +1,46 @@
--import sys
--
--import pytest
--
--
--@pytest.fixture
--def without_qutip_qip(monkeypatch):
--    monkeypatch.setitem(sys.modules, "qutip_qip", None)
--    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
--
--
--@pytest.fixture
--def with_qutip_qip_stub(tmp_path, monkeypatch):
--    pkg_dir = tmp_path / "qutip_qip"
--    pkg_dir.mkdir()
--    init_file = pkg_dir / "__init__.py"
--    init_file.write_text("__version__ = 'x.y.z'")
--    circuit_file = pkg_dir / "circuit.py"
--    circuit_file.write_text("class QubitCircuit:\n    pass")
--
--    monkeypatch.syspath_prepend(tmp_path)
--    # Make sure the stub modules is the one imported
--    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
--    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
--
--
--def test_failed_import(without_qutip_qip):
--    # Ensure 'qutip.qip' is not imported yet
--    assert "qutip.qip" not in sys.modules
--    with pytest.raises(
--        ImportError,
--        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
--    ):
--        import qutip.qip
--
--
--def test_with_qip(with_qutip_qip_stub):
--    import qutip.qip
--    import qutip.qip.circuit as circuit
--    from qutip.qip.circuit import QubitCircuit
--    import qutip_qip
--
--    assert qutip.qip.__version__ == "x.y.z"
--    assert qutip.qip is qutip_qip
--    assert circuit is qutip_qip.circuit
--    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
-+import sys
-+
-+import pytest
-+
-+
-+@pytest.fixture
-+def without_qutip_qip(monkeypatch):
-+    monkeypatch.setitem(sys.modules, "qutip_qip", None)
-+    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
-+
-+
-+@pytest.fixture
-+def with_qutip_qip_stub(tmp_path, monkeypatch):
-+    pkg_dir = tmp_path / "qutip_qip"
-+    pkg_dir.mkdir()
-+    init_file = pkg_dir / "__init__.py"
-+    init_file.write_text("__version__ = 'x.y.z'")
-+    circuit_file = pkg_dir / "circuit.py"
-+    circuit_file.write_text("class QubitCircuit:\n    pass")
-+
-+    monkeypatch.syspath_prepend(tmp_path)
-+    # Make sure the stub modules is the one imported
-+    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
-+    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
-+
-+
-+def test_failed_import(without_qutip_qip):
-+    # Ensure 'qutip.qip' is not imported yet
-+    assert "qutip.qip" not in sys.modules
-+    with pytest.raises(
-+        ImportError,
-+        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
-+    ):
-+        import qutip.qip
-+
-+
-+def test_with_qip(with_qutip_qip_stub):
-+    import qutip.qip
-+    import qutip.qip.circuit as circuit
-+    from qutip.qip.circuit import QubitCircuit
-+    import qutip_qip
-+
-+    assert qutip.qip.__version__ == "x.y.z"
-+    assert qutip.qip is qutip_qip
-+    assert circuit is qutip_qip.circuit
-+    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
-diff --git a/qutip/tests/test_qpt.py b/qutip/tests/test_qpt.py
-index c2d092e2..896a8da9 100644
---- a/qutip/tests/test_qpt.py
-+++ b/qutip/tests/test_qpt.py
-@@ -1,50 +1,50 @@
--import numpy as np
--from numpy.testing import assert_, run_module_suite
--import scipy.linalg as la
--
--from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
--from qutip.core.gates import snot, cnot
--
--
--def test_qpt_snot():
--    "quantum process tomography for snot gate"
--
--    U_psi = snot()
--    U_rho = spre(U_psi) * spost(U_psi.dag())
--    N = 1
--    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
--    # op_label = [["i", "x", "y", "z"] for i in range(N)]
--    chi1 = qpt(U_rho, op_basis)
--
--    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
--    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
--
--    assert_(la.norm(chi2 - chi1) < 1e-8)
--
--
--def test_qpt_cnot():
--    "quantum process tomography for cnot gate"
--
--    U_psi = cnot()
--    U_rho = spre(U_psi) * spost(U_psi.dag())
--    N = 2
--    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
--    # op_label = [["i", "x", "y", "z"] for i in range(N)]
--    chi1 = qpt(U_rho, op_basis)
--
--    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
--    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
--
--    chi2[12, 0] = chi2[12, 1] = 0.25
--    chi2[13, 0] = chi2[13, 1] = -0.25
--
--    chi2[0, 12] = chi2[1, 12] = 0.25
--    chi2[0, 13] = chi2[1, 13] = -0.25
--
--    chi2[12, 12] = chi2[13, 13] = 0.25
--    chi2[13, 12] = chi2[12, 13] = -0.25
--
--    assert_(la.norm(chi2 - chi1) < 1e-8)
--
--if __name__ == "__main__":
--    run_module_suite()
-+import numpy as np
-+from numpy.testing import assert_, run_module_suite
-+import scipy.linalg as la
-+
-+from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
-+from qutip.core.gates import snot, cnot
-+
-+
-+def test_qpt_snot():
-+    "quantum process tomography for snot gate"
-+
-+    U_psi = snot()
-+    U_rho = spre(U_psi) * spost(U_psi.dag())
-+    N = 1
-+    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
-+    # op_label = [["i", "x", "y", "z"] for i in range(N)]
-+    chi1 = qpt(U_rho, op_basis)
-+
-+    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
-+    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
-+
-+    assert_(la.norm(chi2 - chi1) < 1e-8)
-+
-+
-+def test_qpt_cnot():
-+    "quantum process tomography for cnot gate"
-+
-+    U_psi = cnot()
-+    U_rho = spre(U_psi) * spost(U_psi.dag())
-+    N = 2
-+    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
-+    # op_label = [["i", "x", "y", "z"] for i in range(N)]
-+    chi1 = qpt(U_rho, op_basis)
-+
-+    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
-+    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
-+
-+    chi2[12, 0] = chi2[12, 1] = 0.25
-+    chi2[13, 0] = chi2[13, 1] = -0.25
-+
-+    chi2[0, 12] = chi2[1, 12] = 0.25
-+    chi2[0, 13] = chi2[1, 13] = -0.25
-+
-+    chi2[12, 12] = chi2[13, 13] = 0.25
-+    chi2[13, 12] = chi2[12, 13] = -0.25
-+
-+    assert_(la.norm(chi2 - chi1) < 1e-8)
-+
-+if __name__ == "__main__":
-+    run_module_suite()
-diff --git a/qutip/tests/test_random.py b/qutip/tests/test_random.py
-index 13f9554b..8b700296 100644
---- a/qutip/tests/test_random.py
-+++ b/qutip/tests/test_random.py
-@@ -1,311 +1,311 @@
--import numpy as np
--from numpy.random import SeedSequence, default_rng
--import scipy.sparse as sp
--import scipy.linalg as la
--import pytest
--
--from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
--from qutip import data as _data
--from qutip.random_objects import (
--    rand_herm,
--    rand_unitary,
--    rand_dm,
--    rand_ket,
--    rand_stochastic,
--    rand_super,
--    rand_super_bcsz,
--    rand_kraus_map,
--)
--
--
--@pytest.fixture(params=[
--    12,
--    [8],
--    [2, 2, 3],
--    [[2], [2]]
--], ids=["int", "list", "tensor", "super"])
--def dimensions(request):
--    return request.param
--
--
--@pytest.fixture(
--    params=list(_data.to.dtypes),
--    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
--)
--def dtype(request):
--    return request.param
--
--
--def _assert_density(qobj, density):
--    N = np.sum(qobj.full() != 0)
--    density = N / np.prod(qobj.shape)
--    assert density == pytest.approx(density, abs=0.2)
--
--
--def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
--    if isinstance(dims, int):
--        dims = [dims]
--    N = np.prod(dims)
--    if super and not isinstance(dims[0], list):
--        target_dims_0 = [dims, dims]
--        shape0 = N**2
--    else:
--        target_dims_0 = dims
--        shape0 = N
--
--    if ket:
--        target_dims_1 = [1]
--        shape1 = 1
--    else:
--        target_dims_1 = target_dims_0
--        shape1 = shape0
--
--    assert random_qobj.dims[0] == target_dims_0
--    assert random_qobj.dims[1] == target_dims_1
--    assert random_qobj.shape == (shape0, shape1)
--
--    if dtype:
--        assert isinstance(random_qobj.data, dtype)
--
--
--@pytest.mark.repeat(3)
--@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
--@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
--def test_rand_herm(dimensions, density, distribution, dtype):
--    """
--    Random Qobjs: Hermitian matrix
--    """
--    random_qobj = rand_herm(
--        dimensions,
--        density=density,
--        distribution=distribution,
--        dtype=dtype
--    )
--    if distribution == "pos_def":
--        assert all(random_qobj.eigenenergies() > -1e14)
--    assert random_qobj.isherm
--    assert _data.isherm(random_qobj.data)
--    _assert_metadata(random_qobj, dimensions, dtype)
--    _assert_density(random_qobj, density)
--
--
--@pytest.mark.repeat(3)
--@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
--def test_rand_herm_Eigs(dimensions, density):
--    """
--    Random Qobjs: Hermitian matrix - Eigs given
--    """
--    N = np.prod(dimensions)
--    eigs = np.random.random(N)
--    eigs /= np.sum(eigs)
--    eigs.sort()
--    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
--    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
--    # verify hermitian
--    assert random_qobj.isherm
--    assert _data.isherm(random_qobj.data)
--    _assert_metadata(random_qobj, dimensions)
--    _assert_density(random_qobj, density)
--
--
--@pytest.mark.repeat(5)
--@pytest.mark.parametrize('distribution', ["haar", "exp"])
--@pytest.mark.parametrize('density', [0.2, 0.8])
--def test_rand_unitary(dimensions, distribution, density, dtype):
--    """
--    Random Qobjs: Tests that unitaries are actually unitary.
--    """
--    N = np.prod(dimensions)
--    random_qobj = rand_unitary(
--        dimensions, distribution=distribution,
--        density=density, dtype=dtype
--    )
--    I = qeye(dimensions)
--    assert random_qobj * random_qobj.dag() == I
--    _assert_metadata(random_qobj, dimensions, dtype)
--    if distribution == "exp":
--        _assert_density(random_qobj, density)
--
--
--@pytest.mark.repeat(3)
--@pytest.mark.parametrize(["distribution", "kw"], [
--    pytest.param("ginibre", {"rank": 3}),
--    pytest.param("ginibre", {"rank": 1}),
--    pytest.param("hs", {"rank": 0}),
--    pytest.param("pure", {"rank": 1, "density": 0.5}),
--    pytest.param("eigen", {"eigenvalues": True}),
--    pytest.param("herm", {"density": 0.7}),
--    pytest.param("herm", {"density": 0.3}),
--])
--def test_rand_dm(dimensions, kw, dtype, distribution):
--    """
--    Random Qobjs: Density matrix
--    """
--    N = np.prod(dimensions)
--    print(N, kw)
--    if "eigenvalues" in kw:
--        eigs = np.random.random(N)
--        eigs /= np.sum(eigs)
--        eigs.sort()
--        kw["eigenvalues"] = eigs
--
--    random_qobj = rand_dm(
--        dimensions,
--        distribution=distribution,
--        dtype=dtype,
--        **kw
--    )
--    assert abs(random_qobj.tr() - 1.0) < 1e-14
--    # verify all eigvals are >=0
--    assert all(random_qobj.eigenenergies() >= -1e-14)
--    # verify hermitian
--    assert random_qobj.isherm
--    assert _data.isherm(random_qobj.data)
--
--    _assert_metadata(random_qobj, dimensions, dtype)
--
--    eigenvalues = random_qobj.eigenenergies()
--
--    if "rank" in kw:
--        print(kw["rank"], N, kw["rank"] or N)
--        desired_rank = kw["rank"] or N  # 'hs' is full rank.
--        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
--        assert rank == desired_rank
--
--    if "eigenvalues" in kw:
--        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
--
--    if "density" in kw:
--        _assert_density(random_qobj, kw["density"])
--
--
--@pytest.mark.repeat(5)
--@pytest.mark.parametrize('kind', ["left", "right"])
--def test_rand_stochastic(dimensions, kind, dtype):
--    """
--    Random Qobjs: Test random stochastic
--    """
--    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
--    axis = {"left":0, "right":1}[kind]
--    np.testing.assert_allclose(
--        np.sum(random_qobj.full(), axis=axis),
--        1, atol=1e-14
--    )
--    _assert_metadata(random_qobj, dimensions, dtype)
--
--
--@pytest.mark.repeat(5)
--@pytest.mark.parametrize('distribution', ["haar", "fill"])
--def test_rand_ket(dimensions, distribution, dtype):
--    """
--    Random Qobjs: Test random ket type and norm.
--    """
--    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
--
--    assert random_qobj.type == 'ket'
--    assert abs(random_qobj.norm() - 1) < 1e-14
--
--    if isinstance(dimensions, int):
--        dims = [dimensions]
--    N = np.prod(dimensions)
--    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
--
--
--@pytest.mark.repeat(2)
--@pytest.mark.parametrize('superrep', ["choi", "super"])
--def test_rand_super(dimensions, dtype, superrep):
--    """
--    Random Qobjs: Super operator.
--    """
--    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
--    assert random_qobj.issuper
--    with CoreOptions(atol=1e-9):
--        assert random_qobj.iscptp
--    assert random_qobj.superrep == superrep
--    _assert_metadata(random_qobj, dimensions, dtype, super=True)
--
--
--@pytest.mark.repeat(2)
--@pytest.mark.parametrize('rank', [None, 4])
--@pytest.mark.parametrize('superrep', ["choi", "super"])
--def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
--    """
--    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
--    """
--
--    random_qobj = rand_super_bcsz(dimensions, rank=rank,
--                                  dtype=dtype, superrep=superrep)
--    assert random_qobj.issuper
--    with CoreOptions(atol=1e-9):
--        assert random_qobj.iscptp
--    assert random_qobj.superrep == superrep
--    _assert_metadata(random_qobj, dimensions, dtype, super=True)
--    if (
--        not rank
--        and isinstance(dimensions, list)
--        and isinstance(dimensions[0], list)
--    ):
--        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
--        rank = np.prod(dimensions)
--    elif not rank:
--        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
--        rank = np.prod(dimensions)**2
--    rank = rank or N
--    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
--    assert obtained_rank == rank
--
--
--@pytest.mark.parametrize("function", [
--    pytest.param(rand_herm, id="rand_herm"),
--    pytest.param(rand_unitary, id="rand_unitary"),
--    pytest.param(rand_dm, id="rand_dm"),
--    pytest.param(rand_ket, id="rand_ket"),
--    pytest.param(rand_stochastic, id="rand_stochastic"),
--    pytest.param(rand_super, id="rand_super"),
--    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
--])
--@pytest.mark.parametrize("seed", [
--    pytest.param(lambda : 123, id="int"),
--    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
--    pytest.param(lambda : default_rng(123), id="Generator")
--])
--def test_random_seeds(function, seed):
--    """
--    Random Qobjs: Random number generator seed
--    """
--    U0 = function(5, seed=seed())
--    U1 = function(5, seed=None)
--    U2 = function(5, seed=seed())
--    assert U0 != U1
--    assert U0 == U2
--
--
--def test_kraus_map(dimensions, dtype):
--    kmap = rand_kraus_map(dimensions, dtype=dtype)
--    _assert_metadata(kmap[0], dimensions, dtype)
--    with CoreOptions(atol=1e-9):
--        assert kraus_to_choi(kmap).iscptp
--
--
--dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
--dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
--@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
--                         ids=[str(dtype) for dtype in dtype_names])
--@pytest.mark.parametrize('func', [
--    rand_herm,
--    rand_unitary,
--    rand_dm,
--    rand_ket,
--    rand_stochastic,
--    rand_super,
--    rand_super_bcsz,
--    rand_kraus_map,
--])
--def test_random_dtype(func, alias, dtype):
--    with CoreOptions(default_dtype=alias):
--        object = func(2)
--        if isinstance(object, Qobj):
--            assert isinstance(object.data, dtype)
--        else:
--            for obj in object:
--                assert isinstance(obj.data, dtype)
-+import numpy as np
-+from numpy.random import SeedSequence, default_rng
-+import scipy.sparse as sp
-+import scipy.linalg as la
-+import pytest
-+
-+from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
-+from qutip import data as _data
-+from qutip.random_objects import (
-+    rand_herm,
-+    rand_unitary,
-+    rand_dm,
-+    rand_ket,
-+    rand_stochastic,
-+    rand_super,
-+    rand_super_bcsz,
-+    rand_kraus_map,
-+)
-+
-+
-+@pytest.fixture(params=[
-+    12,
-+    [8],
-+    [2, 2, 3],
-+    [[2], [2]]
-+], ids=["int", "list", "tensor", "super"])
-+def dimensions(request):
-+    return request.param
-+
-+
-+@pytest.fixture(
-+    params=list(_data.to.dtypes),
-+    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
-+)
-+def dtype(request):
-+    return request.param
-+
-+
-+def _assert_density(qobj, density):
-+    N = np.sum(qobj.full() != 0)
-+    density = N / np.prod(qobj.shape)
-+    assert density == pytest.approx(density, abs=0.2)
-+
-+
-+def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
-+    if isinstance(dims, int):
-+        dims = [dims]
-+    N = np.prod(dims)
-+    if super and not isinstance(dims[0], list):
-+        target_dims_0 = [dims, dims]
-+        shape0 = N**2
-+    else:
-+        target_dims_0 = dims
-+        shape0 = N
-+
-+    if ket:
-+        target_dims_1 = [1]
-+        shape1 = 1
-+    else:
-+        target_dims_1 = target_dims_0
-+        shape1 = shape0
-+
-+    assert random_qobj.dims[0] == target_dims_0
-+    assert random_qobj.dims[1] == target_dims_1
-+    assert random_qobj.shape == (shape0, shape1)
-+
-+    if dtype:
-+        assert isinstance(random_qobj.data, dtype)
-+
-+
-+@pytest.mark.repeat(3)
-+@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
-+@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
-+def test_rand_herm(dimensions, density, distribution, dtype):
-+    """
-+    Random Qobjs: Hermitian matrix
-+    """
-+    random_qobj = rand_herm(
-+        dimensions,
-+        density=density,
-+        distribution=distribution,
-+        dtype=dtype
-+    )
-+    if distribution == "pos_def":
-+        assert all(random_qobj.eigenenergies() > -1e14)
-+    assert random_qobj.isherm
-+    assert _data.isherm(random_qobj.data)
-+    _assert_metadata(random_qobj, dimensions, dtype)
-+    _assert_density(random_qobj, density)
-+
-+
-+@pytest.mark.repeat(3)
-+@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
-+def test_rand_herm_Eigs(dimensions, density):
-+    """
-+    Random Qobjs: Hermitian matrix - Eigs given
-+    """
-+    N = np.prod(dimensions)
-+    eigs = np.random.random(N)
-+    eigs /= np.sum(eigs)
-+    eigs.sort()
-+    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
-+    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
-+    # verify hermitian
-+    assert random_qobj.isherm
-+    assert _data.isherm(random_qobj.data)
-+    _assert_metadata(random_qobj, dimensions)
-+    _assert_density(random_qobj, density)
-+
-+
-+@pytest.mark.repeat(5)
-+@pytest.mark.parametrize('distribution', ["haar", "exp"])
-+@pytest.mark.parametrize('density', [0.2, 0.8])
-+def test_rand_unitary(dimensions, distribution, density, dtype):
-+    """
-+    Random Qobjs: Tests that unitaries are actually unitary.
-+    """
-+    N = np.prod(dimensions)
-+    random_qobj = rand_unitary(
-+        dimensions, distribution=distribution,
-+        density=density, dtype=dtype
-+    )
-+    I = qeye(dimensions)
-+    assert random_qobj * random_qobj.dag() == I
-+    _assert_metadata(random_qobj, dimensions, dtype)
-+    if distribution == "exp":
-+        _assert_density(random_qobj, density)
-+
-+
-+@pytest.mark.repeat(3)
-+@pytest.mark.parametrize(["distribution", "kw"], [
-+    pytest.param("ginibre", {"rank": 3}),
-+    pytest.param("ginibre", {"rank": 1}),
-+    pytest.param("hs", {"rank": 0}),
-+    pytest.param("pure", {"rank": 1, "density": 0.5}),
-+    pytest.param("eigen", {"eigenvalues": True}),
-+    pytest.param("herm", {"density": 0.7}),
-+    pytest.param("herm", {"density": 0.3}),
-+])
-+def test_rand_dm(dimensions, kw, dtype, distribution):
-+    """
-+    Random Qobjs: Density matrix
-+    """
-+    N = np.prod(dimensions)
-+    print(N, kw)
-+    if "eigenvalues" in kw:
-+        eigs = np.random.random(N)
-+        eigs /= np.sum(eigs)
-+        eigs.sort()
-+        kw["eigenvalues"] = eigs
-+
-+    random_qobj = rand_dm(
-+        dimensions,
-+        distribution=distribution,
-+        dtype=dtype,
-+        **kw
-+    )
-+    assert abs(random_qobj.tr() - 1.0) < 1e-14
-+    # verify all eigvals are >=0
-+    assert all(random_qobj.eigenenergies() >= -1e-14)
-+    # verify hermitian
-+    assert random_qobj.isherm
-+    assert _data.isherm(random_qobj.data)
-+
-+    _assert_metadata(random_qobj, dimensions, dtype)
-+
-+    eigenvalues = random_qobj.eigenenergies()
-+
-+    if "rank" in kw:
-+        print(kw["rank"], N, kw["rank"] or N)
-+        desired_rank = kw["rank"] or N  # 'hs' is full rank.
-+        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
-+        assert rank == desired_rank
-+
-+    if "eigenvalues" in kw:
-+        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
-+
-+    if "density" in kw:
-+        _assert_density(random_qobj, kw["density"])
-+
-+
-+@pytest.mark.repeat(5)
-+@pytest.mark.parametrize('kind', ["left", "right"])
-+def test_rand_stochastic(dimensions, kind, dtype):
-+    """
-+    Random Qobjs: Test random stochastic
-+    """
-+    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
-+    axis = {"left":0, "right":1}[kind]
-+    np.testing.assert_allclose(
-+        np.sum(random_qobj.full(), axis=axis),
-+        1, atol=1e-14
-+    )
-+    _assert_metadata(random_qobj, dimensions, dtype)
-+
-+
-+@pytest.mark.repeat(5)
-+@pytest.mark.parametrize('distribution', ["haar", "fill"])
-+def test_rand_ket(dimensions, distribution, dtype):
-+    """
-+    Random Qobjs: Test random ket type and norm.
-+    """
-+    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
-+
-+    assert random_qobj.type == 'ket'
-+    assert abs(random_qobj.norm() - 1) < 1e-14
-+
-+    if isinstance(dimensions, int):
-+        dims = [dimensions]
-+    N = np.prod(dimensions)
-+    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
-+
-+
-+@pytest.mark.repeat(2)
-+@pytest.mark.parametrize('superrep', ["choi", "super"])
-+def test_rand_super(dimensions, dtype, superrep):
-+    """
-+    Random Qobjs: Super operator.
-+    """
-+    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
-+    assert random_qobj.issuper
-+    with CoreOptions(atol=1e-9):
-+        assert random_qobj.iscptp
-+    assert random_qobj.superrep == superrep
-+    _assert_metadata(random_qobj, dimensions, dtype, super=True)
-+
-+
-+@pytest.mark.repeat(2)
-+@pytest.mark.parametrize('rank', [None, 4])
-+@pytest.mark.parametrize('superrep', ["choi", "super"])
-+def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
-+    """
-+    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
-+    """
-+
-+    random_qobj = rand_super_bcsz(dimensions, rank=rank,
-+                                  dtype=dtype, superrep=superrep)
-+    assert random_qobj.issuper
-+    with CoreOptions(atol=1e-9):
-+        assert random_qobj.iscptp
-+    assert random_qobj.superrep == superrep
-+    _assert_metadata(random_qobj, dimensions, dtype, super=True)
-+    if (
-+        not rank
-+        and isinstance(dimensions, list)
-+        and isinstance(dimensions[0], list)
-+    ):
-+        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
-+        rank = np.prod(dimensions)
-+    elif not rank:
-+        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
-+        rank = np.prod(dimensions)**2
-+    rank = rank or N
-+    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
-+    assert obtained_rank == rank
-+
-+
-+@pytest.mark.parametrize("function", [
-+    pytest.param(rand_herm, id="rand_herm"),
-+    pytest.param(rand_unitary, id="rand_unitary"),
-+    pytest.param(rand_dm, id="rand_dm"),
-+    pytest.param(rand_ket, id="rand_ket"),
-+    pytest.param(rand_stochastic, id="rand_stochastic"),
-+    pytest.param(rand_super, id="rand_super"),
-+    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
-+])
-+@pytest.mark.parametrize("seed", [
-+    pytest.param(lambda : 123, id="int"),
-+    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
-+    pytest.param(lambda : default_rng(123), id="Generator")
-+])
-+def test_random_seeds(function, seed):
-+    """
-+    Random Qobjs: Random number generator seed
-+    """
-+    U0 = function(5, seed=seed())
-+    U1 = function(5, seed=None)
-+    U2 = function(5, seed=seed())
-+    assert U0 != U1
-+    assert U0 == U2
-+
-+
-+def test_kraus_map(dimensions, dtype):
-+    kmap = rand_kraus_map(dimensions, dtype=dtype)
-+    _assert_metadata(kmap[0], dimensions, dtype)
-+    with CoreOptions(atol=1e-9):
-+        assert kraus_to_choi(kmap).iscptp
-+
-+
-+dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
-+dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
-+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-+                         ids=[str(dtype) for dtype in dtype_names])
-+@pytest.mark.parametrize('func', [
-+    rand_herm,
-+    rand_unitary,
-+    rand_dm,
-+    rand_ket,
-+    rand_stochastic,
-+    rand_super,
-+    rand_super_bcsz,
-+    rand_kraus_map,
-+])
-+def test_random_dtype(func, alias, dtype):
-+    with CoreOptions(default_dtype=alias):
-+        object = func(2)
-+        if isinstance(object, Qobj):
-+            assert isinstance(object.data, dtype)
-+        else:
-+            for obj in object:
-+                assert isinstance(obj.data, dtype)
-diff --git a/qutip/tests/test_simdiag.py b/qutip/tests/test_simdiag.py
-index a45076fd..b388ad33 100644
---- a/qutip/tests/test_simdiag.py
-+++ b/qutip/tests/test_simdiag.py
-@@ -1,92 +1,92 @@
--import pytest
--import numpy as np
--import qutip
--
--
--@pytest.mark.flaky(reruns=2)
--@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
--def test_simdiag(num_mat):
--    N = 10
--
--    U = qutip.rand_unitary(N)
--    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
--                          for _ in range(num_mat)]
--    all_evals, evecs = qutip.simdiag(commuting_matrices)
--
--    for matrix, evals in zip(commuting_matrices, all_evals):
--        for eval, evec in zip(evals, evecs):
--            assert matrix * evec == evec * eval
--
--
--@pytest.mark.flaky(reruns=2)
--@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
--def test_simdiag_no_evals(num_mat):
--    N = 10
--
--    U = qutip.rand_unitary(N)
--    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
--                          for _ in range(num_mat)]
--    evecs = qutip.simdiag(commuting_matrices, evals=False)
--
--    for matrix in commuting_matrices:
--        for evec in evecs:
--            Mvec = matrix * evec
--            eval = Mvec.norm() / evec.norm()
--            assert matrix * evec == evec * eval
--
--
--@pytest.mark.flaky(reruns=2)
--def test_simdiag_degen():
--    N = 10
--    U = qutip.rand_unitary(N)
--    commuting_matrices = [
--        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
--        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
--        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
--    ]
--    all_evals, evecs = qutip.simdiag(commuting_matrices)
--
--    for matrix, evals in zip(commuting_matrices, all_evals):
--        for eval, evec in zip(evals, evecs):
--            np.testing.assert_allclose(
--                (matrix * evec).full(),
--                (evec * eval).full(),
--                atol=3e-14
--            )
--
--@pytest.mark.flaky(reruns=2)
--@pytest.mark.repeat(2)
--def test_simdiag_degen_large():
--    N = 20
--    U = qutip.rand_unitary(N)
--    commuting_matrices = [
--        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
--        for _ in range(5)
--    ]
--    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
--
--    for matrix, evals in zip(commuting_matrices, all_evals):
--        for eval, evec in zip(evals, evecs):
--            np.testing.assert_allclose(
--                (matrix * evec).full(),
--                (evec * eval).full(),
--                atol=1e-13
--            )
--
--
--def test_simdiag_no_input():
--    with pytest.raises(ValueError):
--        qutip.simdiag([])
--
--
--@pytest.mark.parametrize(['ops', 'error'], [
--    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
--    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
--    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
--    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
--                 id="Not commuting"),
--])
--def test_simdiag_errors(ops, error):
--    with pytest.raises(TypeError) as err:
--        qutip.simdiag(ops)
--    assert error in str(err.value)
-+import pytest
-+import numpy as np
-+import qutip
-+
-+
-+@pytest.mark.flaky(reruns=2)
-+@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
-+def test_simdiag(num_mat):
-+    N = 10
-+
-+    U = qutip.rand_unitary(N)
-+    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
-+                          for _ in range(num_mat)]
-+    all_evals, evecs = qutip.simdiag(commuting_matrices)
-+
-+    for matrix, evals in zip(commuting_matrices, all_evals):
-+        for eval, evec in zip(evals, evecs):
-+            assert matrix * evec == evec * eval
-+
-+
-+@pytest.mark.flaky(reruns=2)
-+@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
-+def test_simdiag_no_evals(num_mat):
-+    N = 10
-+
-+    U = qutip.rand_unitary(N)
-+    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
-+                          for _ in range(num_mat)]
-+    evecs = qutip.simdiag(commuting_matrices, evals=False)
-+
-+    for matrix in commuting_matrices:
-+        for evec in evecs:
-+            Mvec = matrix * evec
-+            eval = Mvec.norm() / evec.norm()
-+            assert matrix * evec == evec * eval
-+
-+
-+@pytest.mark.flaky(reruns=2)
-+def test_simdiag_degen():
-+    N = 10
-+    U = qutip.rand_unitary(N)
-+    commuting_matrices = [
-+        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
-+        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
-+        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
-+    ]
-+    all_evals, evecs = qutip.simdiag(commuting_matrices)
-+
-+    for matrix, evals in zip(commuting_matrices, all_evals):
-+        for eval, evec in zip(evals, evecs):
-+            np.testing.assert_allclose(
-+                (matrix * evec).full(),
-+                (evec * eval).full(),
-+                atol=3e-14
-+            )
-+
-+@pytest.mark.flaky(reruns=2)
-+@pytest.mark.repeat(2)
-+def test_simdiag_degen_large():
-+    N = 20
-+    U = qutip.rand_unitary(N)
-+    commuting_matrices = [
-+        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
-+        for _ in range(5)
-+    ]
-+    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
-+
-+    for matrix, evals in zip(commuting_matrices, all_evals):
-+        for eval, evec in zip(evals, evecs):
-+            np.testing.assert_allclose(
-+                (matrix * evec).full(),
-+                (evec * eval).full(),
-+                atol=1e-13
-+            )
-+
-+
-+def test_simdiag_no_input():
-+    with pytest.raises(ValueError):
-+        qutip.simdiag([])
-+
-+
-+@pytest.mark.parametrize(['ops', 'error'], [
-+    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
-+    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
-+    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
-+    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
-+                 id="Not commuting"),
-+])
-+def test_simdiag_errors(ops, error):
-+    with pytest.raises(TypeError) as err:
-+        qutip.simdiag(ops)
-+    assert error in str(err.value)
-diff --git a/qutip/tests/test_subsys_apply.py b/qutip/tests/test_subsys_apply.py
-index ed854666..0c73ff12 100644
---- a/qutip/tests/test_subsys_apply.py
-+++ b/qutip/tests/test_subsys_apply.py
-@@ -1,141 +1,141 @@
--from numpy.linalg import norm
--from numpy.testing import assert_, run_module_suite
--
--from qutip import (
--    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
--    subsystem_apply, rand_dm, rand_unitary,
--)
--from qutip.random_objects import rand_kraus_map
--
--
--class TestSubsysApply(object):
--    """
--    A test class for the QuTiP function for applying superoperators to
--    subsystems.
--    The four tests below determine whether efficient numerics, naive numerics
--    and semi-analytic results are identical.
--    """
--
--    def test_SimpleSingleApply(self):
--        """
--        Non-composite system, operator on Hilbert space.
--        """
--        tol = 1e-12
--        rho_3 = rand_dm(3)
--        single_op = rand_unitary(3)
--        analytic_result = single_op * rho_3 * single_op.dag()
--        naive_result = subsystem_apply(rho_3, single_op, [True],
--                                       reference=True)
--        naive_diff = (analytic_result - naive_result).full()
--        naive_diff_norm = norm(naive_diff)
--        assert_(naive_diff_norm < tol,
--                msg="SimpleSingle: naive_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        naive_diff_norm, tol))
--
--        efficient_result = subsystem_apply(rho_3, single_op, [True])
--        efficient_diff = (efficient_result - analytic_result).full()
--        efficient_diff_norm = norm(efficient_diff)
--        assert_(efficient_diff_norm < tol,
--                msg="SimpleSingle: efficient_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        efficient_diff_norm, tol))
--
--    def test_SimpleSuperApply(self):
--        """
--        Non-composite system, operator on Liouville space.
--        """
--        tol = 1e-12
--        rho_3 = rand_dm(3)
--        superop = kraus_to_super(rand_kraus_map(3))
--        analytic_result = vector_to_operator(superop @
--                                             operator_to_vector(rho_3))
--        naive_result = subsystem_apply(rho_3, superop, [True],
--                                       reference=True)
--        naive_diff = (analytic_result - naive_result).full()
--        naive_diff_norm = norm(naive_diff)
--        assert_(naive_diff_norm < tol,
--                msg="SimpleSuper: naive_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        naive_diff_norm, tol))
--
--        efficient_result = subsystem_apply(rho_3, superop, [True])
--        efficient_diff = (efficient_result - analytic_result).full()
--        efficient_diff_norm = norm(efficient_diff)
--        assert_(efficient_diff_norm < tol,
--                msg="SimpleSuper: efficient_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        efficient_diff_norm, tol))
--
--    def test_ComplexSingleApply(self):
--        """
--        Composite system, operator on Hilbert space.
--        """
--        tol = 1e-12
--        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
--        rho_input = tensor(rho_list)
--        single_op = rand_unitary(3)
--
--        analytic_result = rho_list
--        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
--        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
--        analytic_result = tensor(analytic_result)
--
--        naive_result = subsystem_apply(rho_input, single_op,
--                                       [False, True, False, True, False],
--                                       reference=True)
--        naive_diff = (analytic_result - naive_result).full()
--        naive_diff_norm = norm(naive_diff)
--        assert_(naive_diff_norm < tol,
--                msg="ComplexSingle: naive_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        naive_diff_norm, tol))
--
--        efficient_result = subsystem_apply(rho_input, single_op,
--                                           [False, True, False, True, False])
--        efficient_diff = (efficient_result - analytic_result).full()
--        efficient_diff_norm = norm(efficient_diff)
--        assert_(efficient_diff_norm < tol,
--                msg="ComplexSingle: efficient_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        efficient_diff_norm, tol))
--
--    def test_ComplexSuperApply(self):
--        """
--        Superoperator: Efficient numerics and reference return same result,
--        acting on non-composite system
--        """
--        tol = 1e-10
--        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
--        rho_input = tensor(rho_list)
--        superop = kraus_to_super(rand_kraus_map(3))
--
--        analytic_result = rho_list
--        analytic_result[1] = Qobj(
--            vector_to_operator(
--                superop @ operator_to_vector(analytic_result[1])
--            ))
--        analytic_result[3] = Qobj(
--            vector_to_operator(
--                superop @ operator_to_vector(analytic_result[3])
--            ))
--        analytic_result = tensor(analytic_result)
--
--        naive_result = subsystem_apply(rho_input, superop,
--                                       [False, True, False, True, False],
--                                       reference=True)
--        naive_diff = (analytic_result - naive_result).full()
--        naive_diff_norm = norm(naive_diff)
--        assert_(naive_diff_norm < tol,
--                msg="ComplexSuper: naive_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        naive_diff_norm, tol))
--
--        efficient_result = subsystem_apply(rho_input, superop,
--                                           [False, True, False, True, False])
--        efficient_diff = (efficient_result - analytic_result).full()
--        efficient_diff_norm = norm(efficient_diff)
--        assert_(efficient_diff_norm < tol,
--                msg="ComplexSuper: efficient_diff_norm {} "
--                    "is beyond tolerance {}".format(
--                        efficient_diff_norm, tol))
-+from numpy.linalg import norm
-+from numpy.testing import assert_, run_module_suite
-+
-+from qutip import (
-+    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
-+    subsystem_apply, rand_dm, rand_unitary,
-+)
-+from qutip.random_objects import rand_kraus_map
-+
-+
-+class TestSubsysApply(object):
-+    """
-+    A test class for the QuTiP function for applying superoperators to
-+    subsystems.
-+    The four tests below determine whether efficient numerics, naive numerics
-+    and semi-analytic results are identical.
-+    """
-+
-+    def test_SimpleSingleApply(self):
-+        """
-+        Non-composite system, operator on Hilbert space.
-+        """
-+        tol = 1e-12
-+        rho_3 = rand_dm(3)
-+        single_op = rand_unitary(3)
-+        analytic_result = single_op * rho_3 * single_op.dag()
-+        naive_result = subsystem_apply(rho_3, single_op, [True],
-+                                       reference=True)
-+        naive_diff = (analytic_result - naive_result).full()
-+        naive_diff_norm = norm(naive_diff)
-+        assert_(naive_diff_norm < tol,
-+                msg="SimpleSingle: naive_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        naive_diff_norm, tol))
-+
-+        efficient_result = subsystem_apply(rho_3, single_op, [True])
-+        efficient_diff = (efficient_result - analytic_result).full()
-+        efficient_diff_norm = norm(efficient_diff)
-+        assert_(efficient_diff_norm < tol,
-+                msg="SimpleSingle: efficient_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        efficient_diff_norm, tol))
-+
-+    def test_SimpleSuperApply(self):
-+        """
-+        Non-composite system, operator on Liouville space.
-+        """
-+        tol = 1e-12
-+        rho_3 = rand_dm(3)
-+        superop = kraus_to_super(rand_kraus_map(3))
-+        analytic_result = vector_to_operator(superop @
-+                                             operator_to_vector(rho_3))
-+        naive_result = subsystem_apply(rho_3, superop, [True],
-+                                       reference=True)
-+        naive_diff = (analytic_result - naive_result).full()
-+        naive_diff_norm = norm(naive_diff)
-+        assert_(naive_diff_norm < tol,
-+                msg="SimpleSuper: naive_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        naive_diff_norm, tol))
-+
-+        efficient_result = subsystem_apply(rho_3, superop, [True])
-+        efficient_diff = (efficient_result - analytic_result).full()
-+        efficient_diff_norm = norm(efficient_diff)
-+        assert_(efficient_diff_norm < tol,
-+                msg="SimpleSuper: efficient_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        efficient_diff_norm, tol))
-+
-+    def test_ComplexSingleApply(self):
-+        """
-+        Composite system, operator on Hilbert space.
-+        """
-+        tol = 1e-12
-+        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
-+        rho_input = tensor(rho_list)
-+        single_op = rand_unitary(3)
-+
-+        analytic_result = rho_list
-+        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
-+        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
-+        analytic_result = tensor(analytic_result)
-+
-+        naive_result = subsystem_apply(rho_input, single_op,
-+                                       [False, True, False, True, False],
-+                                       reference=True)
-+        naive_diff = (analytic_result - naive_result).full()
-+        naive_diff_norm = norm(naive_diff)
-+        assert_(naive_diff_norm < tol,
-+                msg="ComplexSingle: naive_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        naive_diff_norm, tol))
-+
-+        efficient_result = subsystem_apply(rho_input, single_op,
-+                                           [False, True, False, True, False])
-+        efficient_diff = (efficient_result - analytic_result).full()
-+        efficient_diff_norm = norm(efficient_diff)
-+        assert_(efficient_diff_norm < tol,
-+                msg="ComplexSingle: efficient_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        efficient_diff_norm, tol))
-+
-+    def test_ComplexSuperApply(self):
-+        """
-+        Superoperator: Efficient numerics and reference return same result,
-+        acting on non-composite system
-+        """
-+        tol = 1e-10
-+        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
-+        rho_input = tensor(rho_list)
-+        superop = kraus_to_super(rand_kraus_map(3))
-+
-+        analytic_result = rho_list
-+        analytic_result[1] = Qobj(
-+            vector_to_operator(
-+                superop @ operator_to_vector(analytic_result[1])
-+            ))
-+        analytic_result[3] = Qobj(
-+            vector_to_operator(
-+                superop @ operator_to_vector(analytic_result[3])
-+            ))
-+        analytic_result = tensor(analytic_result)
-+
-+        naive_result = subsystem_apply(rho_input, superop,
-+                                       [False, True, False, True, False],
-+                                       reference=True)
-+        naive_diff = (analytic_result - naive_result).full()
-+        naive_diff_norm = norm(naive_diff)
-+        assert_(naive_diff_norm < tol,
-+                msg="ComplexSuper: naive_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        naive_diff_norm, tol))
-+
-+        efficient_result = subsystem_apply(rho_input, superop,
-+                                           [False, True, False, True, False])
-+        efficient_diff = (efficient_result - analytic_result).full()
-+        efficient_diff_norm = norm(efficient_diff)
-+        assert_(efficient_diff_norm < tol,
-+                msg="ComplexSuper: efficient_diff_norm {} "
-+                    "is beyond tolerance {}".format(
-+                        efficient_diff_norm, tol))
-diff --git a/qutip/tests/test_three_level.py b/qutip/tests/test_three_level.py
-index 6aee63c0..372605d7 100644
---- a/qutip/tests/test_three_level.py
-+++ b/qutip/tests/test_three_level.py
-@@ -1,27 +1,27 @@
--import numpy as np
--from numpy.testing import assert_, assert_equal, run_module_suite
--from qutip import basis
--from qutip.three_level_atom import *
--
--
--three_states = three_level_basis()
--three_check = np.empty((3,), dtype=object)
--three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
--three_ops = three_level_ops()
--
--
--def testThreeStates():
--    "Three-level atom: States"
--    assert_equal(np.all(three_states == three_check), True)
--
--
--def testThreeOps():
--    "Three-level atom: Operators"
--    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
--    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
--    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
--    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
--    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
--
--if __name__ == "__main__":
--    run_module_suite()
-+import numpy as np
-+from numpy.testing import assert_, assert_equal, run_module_suite
-+from qutip import basis
-+from qutip.three_level_atom import *
-+
-+
-+three_states = three_level_basis()
-+three_check = np.empty((3,), dtype=object)
-+three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
-+three_ops = three_level_ops()
-+
-+
-+def testThreeStates():
-+    "Three-level atom: States"
-+    assert_equal(np.all(three_states == three_check), True)
-+
-+
-+def testThreeOps():
-+    "Three-level atom: Operators"
-+    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
-+    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
-+    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
-+    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
-+    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
-+
-+if __name__ == "__main__":
-+    run_module_suite()
-diff --git a/qutip/tests/test_transfertensor.py b/qutip/tests/test_transfertensor.py
-index c736ef04..34cacd2c 100644
---- a/qutip/tests/test_transfertensor.py
-+++ b/qutip/tests/test_transfertensor.py
-@@ -1,45 +1,45 @@
--import pytest
--import qutip as qt
--import numpy as np
--from qutip.solve.nonmarkov.transfertensor import ttmsolve
--
--
--def test_ttmsolve_jc_model():
--    """
--    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
--    which can also be found in the qutip-notebooks repository.
--    """
--    # Define Hamiltonian and states
--    N, kappa, g = 3, 1.0, 10
--    a = qt.tensor(qt.qeye(2), qt.destroy(N))
--    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
--    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
--    H = g * (a.dag() * sm + a * sm.dag())
--    c_ops = [np.sqrt(kappa) * a]
--    # identity superoperator
--    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
--    E0 = qt.sprepost(Id, Id)
--    # partial trace superoperator
--    ptracesuper = qt.tensor_contract(E0, (1, N))
--    # initial states
--    rho0a = qt.ket2dm(qt.basis(2, 0))
--    psi0c = qt.basis(N, 0)
--    rho0c = qt.ket2dm(psi0c)
--    rho0 = qt.tensor(rho0a, rho0c)
--    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
--                               qt.tensor(qt.qeye(2), psi0c.dag()))
--
--    # calculate exact solution using mesolve
--    times = np.arange(0, 5.0, 0.1)
--    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
--    exact_z = qt.expect(sz, exactsol.states)
--
--    # solve using transfer method
--    learning_times = np.arange(0, 2.0, 0.1)
--    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
--    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
--    ttmsol = ttmsolve(learning_maps, rho0a, times)
--    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
--
--    # check that ttm result and exact solution are close in the learning times
--    assert np.allclose(ttm_z, exact_z, atol=1e-5)
-+import pytest
-+import qutip as qt
-+import numpy as np
-+from qutip.solve.nonmarkov.transfertensor import ttmsolve
-+
-+
-+def test_ttmsolve_jc_model():
-+    """
-+    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
-+    which can also be found in the qutip-notebooks repository.
-+    """
-+    # Define Hamiltonian and states
-+    N, kappa, g = 3, 1.0, 10
-+    a = qt.tensor(qt.qeye(2), qt.destroy(N))
-+    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
-+    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
-+    H = g * (a.dag() * sm + a * sm.dag())
-+    c_ops = [np.sqrt(kappa) * a]
-+    # identity superoperator
-+    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
-+    E0 = qt.sprepost(Id, Id)
-+    # partial trace superoperator
-+    ptracesuper = qt.tensor_contract(E0, (1, N))
-+    # initial states
-+    rho0a = qt.ket2dm(qt.basis(2, 0))
-+    psi0c = qt.basis(N, 0)
-+    rho0c = qt.ket2dm(psi0c)
-+    rho0 = qt.tensor(rho0a, rho0c)
-+    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
-+                               qt.tensor(qt.qeye(2), psi0c.dag()))
-+
-+    # calculate exact solution using mesolve
-+    times = np.arange(0, 5.0, 0.1)
-+    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
-+    exact_z = qt.expect(sz, exactsol.states)
-+
-+    # solve using transfer method
-+    learning_times = np.arange(0, 2.0, 0.1)
-+    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
-+    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
-+    ttmsol = ttmsolve(learning_maps, rho0a, times)
-+    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
-+
-+    # check that ttm result and exact solution are close in the learning times
-+    assert np.allclose(ttm_z, exact_z, atol=1e-5)
-diff --git a/qutip/tests/test_utilities.py b/qutip/tests/test_utilities.py
-index f29d8224..648d6a4d 100644
---- a/qutip/tests/test_utilities.py
-+++ b/qutip/tests/test_utilities.py
-@@ -1,121 +1,121 @@
--import numpy as np
--from qutip import convert_unit, clebsch, n_thermal
--import qutip.utilities as utils
--from functools import partial
--import pytest
--
--
--@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
--    pytest.param(np.log(2), 1, 1, id='log(2)'),
--    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
--    pytest.param(0, 1, 0, id="0_energy"),
--    pytest.param(1, -1, 0, id="neg_temp"),
--    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
--                 np.array([1, 1/2, 1/3]), id="array"),
--])
--def test_n_thermal(w, w_th, expected):
--    np.testing.assert_allclose(n_thermal(w, w_th), expected)
--
--
--def _get_converter(orig, target):
--    """get funtion 'convert_{}_to_{}' when available for coverage """
--    try:
--        func = getattr(utils, f'convert_{orig}_to_{target}')
--    except AttributeError:
--        func = partial(convert_unit, orig=orig, to=target)
--    return func
--
--
--@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
--@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
--def test_unit_conversions(orig, target):
--    T = np.random.rand() * 100.0
--    T_converted = convert_unit(T, orig=orig, to=target)
--    T_back = convert_unit(T_converted, orig=target, to=orig)
--
--    assert T == pytest.approx(T_back)
--
--    T_converted = _get_converter(orig=orig, target=target)(T)
--    T_back = _get_converter(orig=target, target=orig)(T_converted)
--
--    assert T == pytest.approx(T_back)
--
--
--@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
--@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
--@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
--def test_unit_conversions_loop(orig, middle, target):
--    T = np.random.rand() * 100.0
--    T_middle = convert_unit(T, orig=orig, to=middle)
--    T_converted = convert_unit(T_middle, orig=middle, to=target)
--    T_back = convert_unit(T_converted, orig=target, to=orig)
--
--    assert T == pytest.approx(T_back)
--
--
--def test_unit_conversions_bad_unit():
--    with pytest.raises(TypeError):
--        convert_unit(10, orig="bad", to="J")
--    with pytest.raises(TypeError):
--        convert_unit(10, orig="J", to="bad")
--
--
--@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
--@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
--def test_unit_clebsch_delta_j(j1, j2):
--    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
--    delta j3,j3' delta m3,m3'"""
--    for _ in range(10):
--        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
--        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
--        m3 = np.random.choice(np.arange(-j3, j3+1))
--        m3p = np.random.choice(np.arange(-j3p, j3p+1))
--
--        sum_match = 0
--        sum_differ = 0
--        for m1 in np.arange(-j1, j1+1):
--            for m2 in np.arange(-j2, j2+1):
--                c1 = clebsch(j1, j2, j3, m1, m2, m3)
--                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
--                sum_match += c1**2
--                sum_differ += c1*c2
--        assert sum_match == pytest.approx(1)
--        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
--
--
--@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
--@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
--def test_unit_clebsch_delta_m(j1, j2):
--    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
--    delta m1,m1' delta m2,m2'"""
--    for _ in range(10):
--        m1 = np.random.choice(np.arange(-j1, j1+1))
--        m1p = np.random.choice(np.arange(-j1, j1+1))
--        m2 = np.random.choice(np.arange(-j2, j2+1))
--        m2p = np.random.choice(np.arange(-j2, j2+1))
--
--        sum_match = 0
--        sum_differ = 0
--        for j3 in np.arange(abs(j1-j2), j1+j2+1):
--            for m3 in np.arange(-j3, j3+1):
--                c1 = clebsch(j1, j2, j3, m1, m2, m3)
--                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
--                sum_match += c1**2
--                sum_differ += c1*c2
--        assert sum_match == pytest.approx(1)
--        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
--
--
--def test_cpu_count(monkeypatch):
--    from qutip.settings import available_cpu_count
--    ncpus = available_cpu_count()
--    assert isinstance(ncpus, int)
--    assert ncpus >= 1
--
--    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
--    new_ncpus = available_cpu_count()
--    assert new_ncpus == ncpus + 2
--
--    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
--    new_ncpus = available_cpu_count()
--    assert new_ncpus >= 1
-+import numpy as np
-+from qutip import convert_unit, clebsch, n_thermal
-+import qutip.utilities as utils
-+from functools import partial
-+import pytest
-+
-+
-+@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
-+    pytest.param(np.log(2), 1, 1, id='log(2)'),
-+    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
-+    pytest.param(0, 1, 0, id="0_energy"),
-+    pytest.param(1, -1, 0, id="neg_temp"),
-+    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
-+                 np.array([1, 1/2, 1/3]), id="array"),
-+])
-+def test_n_thermal(w, w_th, expected):
-+    np.testing.assert_allclose(n_thermal(w, w_th), expected)
-+
-+
-+def _get_converter(orig, target):
-+    """get funtion 'convert_{}_to_{}' when available for coverage """
-+    try:
-+        func = getattr(utils, f'convert_{orig}_to_{target}')
-+    except AttributeError:
-+        func = partial(convert_unit, orig=orig, to=target)
-+    return func
-+
-+
-+@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
-+@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
-+def test_unit_conversions(orig, target):
-+    T = np.random.rand() * 100.0
-+    T_converted = convert_unit(T, orig=orig, to=target)
-+    T_back = convert_unit(T_converted, orig=target, to=orig)
-+
-+    assert T == pytest.approx(T_back)
-+
-+    T_converted = _get_converter(orig=orig, target=target)(T)
-+    T_back = _get_converter(orig=target, target=orig)(T_converted)
-+
-+    assert T == pytest.approx(T_back)
-+
-+
-+@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
-+@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
-+@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
-+def test_unit_conversions_loop(orig, middle, target):
-+    T = np.random.rand() * 100.0
-+    T_middle = convert_unit(T, orig=orig, to=middle)
-+    T_converted = convert_unit(T_middle, orig=middle, to=target)
-+    T_back = convert_unit(T_converted, orig=target, to=orig)
-+
-+    assert T == pytest.approx(T_back)
-+
-+
-+def test_unit_conversions_bad_unit():
-+    with pytest.raises(TypeError):
-+        convert_unit(10, orig="bad", to="J")
-+    with pytest.raises(TypeError):
-+        convert_unit(10, orig="J", to="bad")
-+
-+
-+@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-+@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-+def test_unit_clebsch_delta_j(j1, j2):
-+    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
-+    delta j3,j3' delta m3,m3'"""
-+    for _ in range(10):
-+        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
-+        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
-+        m3 = np.random.choice(np.arange(-j3, j3+1))
-+        m3p = np.random.choice(np.arange(-j3p, j3p+1))
-+
-+        sum_match = 0
-+        sum_differ = 0
-+        for m1 in np.arange(-j1, j1+1):
-+            for m2 in np.arange(-j2, j2+1):
-+                c1 = clebsch(j1, j2, j3, m1, m2, m3)
-+                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
-+                sum_match += c1**2
-+                sum_differ += c1*c2
-+        assert sum_match == pytest.approx(1)
-+        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
-+
-+
-+@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-+@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-+def test_unit_clebsch_delta_m(j1, j2):
-+    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
-+    delta m1,m1' delta m2,m2'"""
-+    for _ in range(10):
-+        m1 = np.random.choice(np.arange(-j1, j1+1))
-+        m1p = np.random.choice(np.arange(-j1, j1+1))
-+        m2 = np.random.choice(np.arange(-j2, j2+1))
-+        m2p = np.random.choice(np.arange(-j2, j2+1))
-+
-+        sum_match = 0
-+        sum_differ = 0
-+        for j3 in np.arange(abs(j1-j2), j1+j2+1):
-+            for m3 in np.arange(-j3, j3+1):
-+                c1 = clebsch(j1, j2, j3, m1, m2, m3)
-+                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
-+                sum_match += c1**2
-+                sum_differ += c1*c2
-+        assert sum_match == pytest.approx(1)
-+        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
-+
-+
-+def test_cpu_count(monkeypatch):
-+    from qutip.settings import available_cpu_count
-+    ncpus = available_cpu_count()
-+    assert isinstance(ncpus, int)
-+    assert ncpus >= 1
-+
-+    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
-+    new_ncpus = available_cpu_count()
-+    assert new_ncpus == ncpus + 2
-+
-+    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
-+    new_ncpus = available_cpu_count()
-+    assert new_ncpus >= 1
-diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
-index 78c57148..5dd34556 100644
---- a/qutip/tests/test_wigner.py
-+++ b/qutip/tests/test_wigner.py
-@@ -1,693 +1,693 @@
--import pytest
--import numpy as np
--import itertools
--from scipy.special import laguerre
--from numpy.random import rand
--from numpy.testing import assert_, run_module_suite, assert_equal, \
--    assert_almost_equal, assert_allclose
--
--import qutip
--from qutip.core.states import coherent, fock, ket, bell_state
--from qutip.wigner import wigner, wigner_transform, _parity
--from qutip.random_objects import rand_dm, rand_ket
--
--
--class TestHusimiQ:
--    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
--    def test_failure_if_non_arraylike_coordinates(self, xs):
--        state = qutip.rand_ket(4)
--        valid = np.linspace(-1, 1, 5)
--        with pytest.raises(TypeError) as e:
--            qutip.qfunc(state, xs, valid)
--        assert "must be array-like" in e.value.args[0]
--        with pytest.raises(TypeError) as e:
--            qutip.qfunc(state, valid, xs)
--        assert "must be array-like" in e.value.args[0]
--        with pytest.raises(TypeError) as e:
--            qutip.QFunc(xs, valid)
--        assert "must be array-like" in e.value.args[0]
--        with pytest.raises(TypeError) as e:
--            qutip.QFunc(valid, xs)
--        assert "must be array-like" in e.value.args[0]
--
--    @pytest.mark.parametrize('ndim', [2, 3])
--    def test_failure_if_coordinates_not_1d(self, ndim):
--        state = qutip.rand_ket(4)
--        valid = np.linspace(-1, 1, 5)
--        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
--        with pytest.raises(ValueError) as e:
--            qutip.qfunc(state, bad, valid)
--        assert "must be 1D" in e.value.args[0]
--        with pytest.raises(ValueError) as e:
--            qutip.qfunc(state, valid, bad)
--        assert "must be 1D" in e.value.args[0]
--        with pytest.raises(ValueError) as e:
--            qutip.QFunc(bad, valid)
--        assert "must be 1D" in e.value.args[0]
--        with pytest.raises(ValueError) as e:
--            qutip.QFunc(valid, bad)
--        assert "must be 1D" in e.value.args[0]
--
--    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
--    def test_failure_if_tensor_hilbert_space(self, dm):
--        if dm:
--            state = qutip.rand_dm([2, 2])
--        else:
--            state = qutip.rand_ket([2, 2])
--        xs = np.linspace(-1, 1, 5)
--        with pytest.raises(ValueError) as e:
--            qutip.qfunc(state, xs, xs)
--        assert "must not have tensor structure" in e.value.args[0]
--        with pytest.raises(ValueError) as e:
--            qutip.QFunc(xs, xs)(state)
--        assert "must not have tensor structure" in e.value.args[0]
--
--    def test_QFunc_raises_if_insufficient_memory(self):
--        xs = np.linspace(-1, 1, 11)
--        state = qutip.rand_ket(4)
--        qfunc = qutip.QFunc(xs, xs, memory=0)
--        with pytest.raises(MemoryError) as e:
--            qfunc(state)
--        assert e.value.args[0].startswith("Refusing to precompute")
--
--    def test_qfunc_warns_if_insufficient_memory(self):
--        xs = np.linspace(-1, 1, 11)
--        state = qutip.rand_dm(4)
--        with pytest.warns(UserWarning) as e:
--            qutip.qfunc(state, xs, xs, precompute_memory=0)
--        assert (
--            e[0].message.args[0]
--            .startswith("Falling back to iterative algorithm")
--        )
--
--    @pytest.mark.parametrize('obj', [
--        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
--        pytest.param([[1, 0], [0, 1]], id='list'),
--        pytest.param(1, id='int'),
--    ])
--    def test_failure_if_not_a_Qobj(self, obj):
--        xs = np.linspace(-1, 1, 11)
--        with pytest.raises(TypeError) as e:
--            qutip.qfunc(obj, xs, xs)
--        assert e.value.args[0].startswith("state must be Qobj")
--        qfunc = qutip.QFunc(xs, xs)
--        with pytest.raises(TypeError) as e:
--            qfunc(obj)
--        assert e.value.args[0].startswith("state must be Qobj")
--
--    # Use indirection so that the tests can still be collected if there's a bug
--    # in the generating QuTiP functions.
--    @pytest.mark.parametrize('state', [
--        pytest.param(lambda: qutip.rand_super(2), id='super'),
--        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
--        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
--        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
--                     id='nonsquare dm'),
--        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
--                     id='operator-ket'),
--        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
--                     id='operator-bra'),
--    ])
--    def test_failure_if_not_a_state(self, state):
--        xs = np.linspace(-1, 1, 11)
--        state = state()
--        with pytest.raises(ValueError) as e:
--            qutip.qfunc(state, xs, xs)
--        assert (
--            e.value.args[0].startswith("state must be a ket or density matrix")
--        )
--        qfunc = qutip.QFunc(xs, xs)
--        with pytest.raises(ValueError) as e:
--            qfunc(state)
--        assert (
--            e.value.args[0].startswith("state must be a ket or density matrix")
--        )
--
--    @pytest.mark.parametrize('g', [
--        pytest.param(np.sqrt(2), id='natural units'),
--        pytest.param(1, id='arb units'),
--    ])
--    @pytest.mark.parametrize('n_ys', [5, 101])
--    @pytest.mark.parametrize('n_xs', [5, 101])
--    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
--    @pytest.mark.parametrize('size', [5, 32])
--    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
--        xs = np.linspace(-1, 1, n_xs)
--        ys = np.linspace(0, 2, n_ys)
--        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
--        function = qutip.qfunc(state, xs, ys, g)
--        class_ = qutip.QFunc(xs, ys, g)(state)
--        np.testing.assert_allclose(function, class_)
--
--    @pytest.mark.parametrize('g', [
--        pytest.param(np.sqrt(2), id='natural units'),
--        pytest.param(1, id='arb units'),
--    ])
--    @pytest.mark.parametrize('n_ys', [5, 101])
--    @pytest.mark.parametrize('n_xs', [5, 101])
--    @pytest.mark.parametrize('size', [5, 32])
--    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
--        xs = np.linspace(-1, 1, n_xs)
--        ys = np.linspace(0, 2, n_ys)
--        state = qutip.rand_dm(size)
--        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
--        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
--        np.testing.assert_allclose(iterate, precompute)
--
--    @pytest.mark.parametrize('initial_size', [5, 8])
--    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
--    def test_same_class_can_take_many_sizes(self, dm, initial_size):
--        xs = np.linspace(-1, 1, 11)
--        ys = np.linspace(0, 2, 11)
--        shape = np.meshgrid(xs, ys)[0].shape
--        sizes = initial_size + np.array([0, 1, -1, 4])
--        qfunc = qutip.QFunc(xs, ys)
--        for size in sizes:
--            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
--            out = qfunc(state)
--            assert isinstance(out, np.ndarray)
--            assert out.shape == shape
--
--    @pytest.mark.parametrize('dm_first', [True, False])
--    def test_same_class_can_mix_ket_and_dm(self, dm_first):
--        dms = [True, False, True, False]
--        if not dm_first:
--            dms = dms[::-1]
--        xs = np.linspace(-1, 1, 11)
--        ys = np.linspace(0, 2, 11)
--        shape = np.meshgrid(xs, ys)[0].shape
--        qfunc = qutip.QFunc(xs, ys)
--        for dm in dms:
--            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
--            out = qfunc(state)
--            assert isinstance(out, np.ndarray)
--            assert out.shape == shape
--
--    @pytest.mark.parametrize('n_ys', [5, 101])
--    @pytest.mark.parametrize('n_xs', [5, 101])
--    @pytest.mark.parametrize('mix', [0.1, 0.5])
--    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
--        xs = np.linspace(-1, 1, n_xs)
--        ys = np.linspace(-1, 1, n_ys)
--        qfunc = qutip.QFunc(xs, ys)
--        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
--        qleft, qright = qfunc(left), qfunc(right)
--        qboth = qfunc(mix*left + (1-mix)*right)
--        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
--
--    @pytest.mark.parametrize('n_ys', [5, 101])
--    @pytest.mark.parametrize('n_xs', [5, 101])
--    @pytest.mark.parametrize('size', [5, 32])
--    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
--        xs = np.linspace(-1, 1, n_xs)
--        ys = np.linspace(-1, 1, n_ys)
--        state = qutip.rand_ket(size)
--        qfunc = qutip.QFunc(xs, ys)
--        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
--
--    @pytest.mark.parametrize('g', [
--        pytest.param(np.sqrt(2), id='natural units'),
--        pytest.param(1, id='arb units'),
--    ])
--    @pytest.mark.parametrize('ys', [
--        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
--        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
--    ])
--    @pytest.mark.parametrize('xs', [
--        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
--        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
--    ])
--    @pytest.mark.parametrize('size', [3, 5])
--    def test_against_naive_implementation(self, xs, ys, g, size):
--        state = qutip.rand_dm(size)
--        state_np = state.full()
--        x, y = np.meshgrid(xs, ys)
--        alphas = 0.5*g * (x + 1j*y)
--        naive = np.empty(alphas.shape, dtype=np.float64)
--        for i, alpha in enumerate(alphas.flat):
--            coh = qutip.coherent(size, alpha, method='analytic').full()
--            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
--        naive *= (0.5*g)**2 / np.pi
--        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
--        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
--
--
--def test_wigner_bell1_su2parity():
--    """wigner: testing the SU2 parity of the first Bell state.
--    """
--    psi = bell_state('00')
--
--    steps = 25
--    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
--    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
--    slicearray = ['l', 'l']
--
--    wigner_analyt = np.zeros((steps, steps))
--    for t in range(steps):
--        for p in range(steps):
--            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
--                                            * np.cos(theta[0, t]))
--                                           * (1 + np.sqrt(3)
--                                           * np.cos(theta[1, t]))
--                                           + 3 * (np.sin(theta[0, t])
--                                           * np.exp(-1j * phi[0, p])
--                                           * np.sin(theta[1, t])
--                                           * np.exp(-1j * phi[1, p])
--                                           + np.sin(theta[0, t])
--                                           * np.exp(1j * phi[0, p])
--                                           * np.sin(theta[1, t])
--                                           * np.exp(1j * phi[1, p]))
--                                           + (1 - np.sqrt(3)
--                                           * np.cos(theta[0, t]))
--                                           * (1 - np.sqrt(3)
--                                           * np.cos(theta[1, t]))) / 8.)
--
--    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
--
--    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
--
--
--@pytest.mark.slow
--def test_wigner_bell4_su2parity():
--    """wigner: testing the SU2 parity of the fourth Bell state.
--    """
--    psi = bell_state('11')
--
--    steps = 25
--    slicearray = ['l', 'l']
--
--    wigner_analyt = np.zeros((steps, steps))
--    for t in range(steps):
--        for p in range(steps):
--            wigner_analyt[t, p] = -0.5
--
--    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
--
--    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
--
--
--@pytest.mark.slow
--def test_wigner_bell4_fullparity():
--    """wigner: testing the parity of the fourth Bell state using the parity of
--    the full space.
--    """
--    psi = bell_state('11')
--
--    steps = 25
--    slicearray = ['l', 'l']
--
--    wigner_analyt = np.zeros((steps, steps))
--    for t in range(steps):
--        for p in range(steps):
--            wigner_analyt[t, p] = -0.30901699
--
--    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
--    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
--
--
--def test_parity():
--    """wigner: testing the parity function.
--    """
--    j = 0.5
--    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
--    assert_(_parity(2, j)[0, 1] < 1e-11)
--    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
--    assert_(_parity(2, j)[1, 0] < 1e-11)
--
--
--@pytest.mark.slow
--def test_wigner_pure_su2():
--    """wigner: testing the SU2 wigner transformation of a pure state.
--    """
--    psi = (ket([1]))
--    steps = 25
--    theta = np.linspace(0, np.pi, steps)
--    phi = np.linspace(0, 2 * np.pi, steps)
--    theta = theta[None, :]
--    phi = phi[None, :]
--    slicearray = ['l']
--
--    wigner_analyt = np.zeros((steps, steps))
--    for t in range(steps):
--        for p in range(steps):
--            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
--
--    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
--
--    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
--
--
--@pytest.mark.slow
--def test_wigner_ghz_su2parity():
--    """wigner: testing the SU2 wigner transformation of the GHZ state.
--    """
--    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
--
--    steps = 25
--    N = 3
--    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
--    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
--    slicearray = ['l', 'l', 'l']
--
--    wigner_analyt = np.zeros((steps, steps))
--    for t in range(steps):
--        for p in range(steps):
--            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
--                                           * (1 + np.sqrt(3)
--                                           * np.cos(theta[1, t]))
--                                           * (1 + np.sqrt(3)
--                                           * np.cos(theta[2, t]))
--                                           + 3**(3 / 2) * (np.sin(theta[0, t])
--                                           * np.exp(-1j * phi[0, p])
--                                           * np.sin(theta[1, t])
--                                           * np.exp(-1j * phi[1, p])
--                                           * np.sin(theta[2, t])
--                                           * np.exp(-1j * phi[2, p])
--                                           + np.sin(theta[0, t])
--                                           * np.exp(1j * phi[0, p])
--                                           * np.sin(theta[1, t])
--                                           * np.exp(1j * phi[1, p])
--                                           * np.sin(theta[2, t])
--                                           * np.exp(1j * phi[2, p]))
--                                           + (1 - np.sqrt(3)
--                                           * np.cos(theta[0, t]))
--                                           * (1 - np.sqrt(3)
--                                           * np.cos(theta[1, t]))
--                                           * (1 - np.sqrt(3)
--                                           * np.cos(theta[2, t]))) / 16.)
--
--    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
--
--    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
--
--
--@pytest.mark.slow
--def test_angle_slicing():
--    """wigner: tests angle slicing.
--    """
--    psi1 = bell_state('00')
--    psi2 = bell_state('01')
--    psi3 = bell_state('10')
--    psi4 = bell_state('11')
--
--    steps = 25
--    j = 0.5
--
--    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
--    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
--    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
--    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
--
--    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
--    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
--    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
--    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
--
--
--def test_wigner_coherent():
--    "wigner: test wigner function calculation for coherent states"
--    xvec = np.linspace(-5.0, 5.0, 100)
--    yvec = xvec
--
--    X, Y = np.meshgrid(xvec, yvec)
--
--    a = X + 1j * Y  # consistent with g=2 option to wigner function
--
--    dx = xvec[1] - xvec[0]
--    dy = yvec[1] - yvec[0]
--
--    N = 20
--    beta = rand() + rand() * 1.0j
--    psi = coherent(N, beta)
--
--    # calculate the wigner function using qutip and analytic formula
--    W_qutip = wigner(psi, xvec, yvec, g=2)
--    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
--    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
--
--    # check difference
--    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
--    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
--
--    # check normalization
--    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
--    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
--    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
--
--
--def test_wigner_fock():
--    "wigner: test wigner function calculation for Fock states"
--
--    xvec = np.linspace(-5.0, 5.0, 100)
--    yvec = xvec
--
--    X, Y = np.meshgrid(xvec, yvec)
--
--    a = X + 1j * Y  # consistent with g=2 option to wigner function
--
--    dx = xvec[1] - xvec[0]
--    dy = yvec[1] - yvec[0]
--
--    N = 15
--
--    for n in [2, 3, 4, 5, 6]:
--
--        psi = fock(N, n)
--
--        # calculate the wigner function using qutip and analytic formula
--        W_qutip = wigner(psi, xvec, yvec, g=2)
--        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
--        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
--        W_analytic = 2 / np.pi * (-1) ** n * \
--            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
--
--        # check difference
--        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
--        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
--        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
--
--        # check normalization
--        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
--        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
--        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
--        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
--
--
--def test_wigner_compare_methods_dm():
--    "wigner: compare wigner methods for random density matrices"
--
--    xvec = np.linspace(-5.0, 5.0, 100)
--    yvec = xvec
--
--    X, Y = np.meshgrid(xvec, yvec)
--
--    # a = X + 1j * Y  # consistent with g=2 option to wigner function
--
--    dx = xvec[1] - xvec[0]
--    dy = yvec[1] - yvec[0]
--
--    N = 15
--
--    for n in range(10):
--        # try ten different random density matrices
--
--        rho = rand_dm(N, density=0.5 + rand() / 2)
--
--        # calculate the wigner function using qutip and analytic formula
--        W_qutip1 = wigner(rho, xvec, yvec, g=2)
--        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
--
--        # check difference
--        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
--
--        # check normalization
--        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
--        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
--
--
--def test_wigner_compare_methods_ket():
--    "wigner: compare wigner methods for random state vectors"
--
--    xvec = np.linspace(-5.0, 5.0, 100)
--    yvec = xvec
--
--    X, Y = np.meshgrid(xvec, yvec)
--
--    # a = X + 1j * Y  # consistent with g=2 option to wigner function
--
--    dx = xvec[1] - xvec[0]
--    dy = yvec[1] - yvec[0]
--
--    N = 15
--
--    for n in range(10):
--        # try ten different random density matrices
--
--        psi = rand_ket(N, density=0.5 + rand() / 2)
--
--        # calculate the wigner function using qutip and analytic formula
--        W_qutip1 = wigner(psi, xvec, yvec, g=2)
--        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
--
--        # check difference
--        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
--
--        # check normalization
--        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
--        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
--
--
--def test_wigner_fft_comparse_ket():
--    "Wigner: Compare Wigner fft and iterative for rand. ket"
--    N = 20
--    xvec = np.linspace(-10, 10, 128)
--    for i in range(3):
--        rho = rand_ket(N)
--
--        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
--        W = wigner(rho, xvec, yvec, method='iterative')
--
--        Wdiff = abs(W - Wfft)
--        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
--
--
--def test_wigner_fft_comparse_dm():
--    "Wigner: Compare Wigner fft and iterative for rand. dm"
--    N = 20
--    xvec = np.linspace(-10, 10, 128)
--    for i in range(3):
--        rho = rand_dm(N)
--
--        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
--        W = wigner(rho, xvec, yvec, method='iterative')
--
--        Wdiff = abs(W - Wfft)
--        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
--
--
--def test_wigner_clenshaw_iter_dm():
--    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
--    N = 20
--    xvec = np.linspace(-10, 10, 128)
--    for i in range(3):
--        rho = rand_dm(N)
--
--        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
--        W = wigner(rho, xvec, xvec, method='iterative')
--
--        Wdiff = abs(W - Wclen)
--        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
--
--
--def test_wigner_clenshaw_sp_iter_dm():
--    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
--    N = 20
--    xvec = np.linspace(-10, 10, 128)
--    for i in range(3):
--        rho = rand_dm(N)
--
--        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
--        W = wigner(rho, xvec, xvec, method='iterative')
--
--        Wdiff = abs(W - Wclen)
--        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
--
--@pytest.mark.parametrize(['spin'], [
--    pytest.param(1/2, id="spin-one-half"),
--    pytest.param(3, id="spin-three"),
--    pytest.param(13/2, id="spin-thirteen-half"),
--    pytest.param(7, id="spin-seven")
--])
--@pytest.mark.parametrize("pure", [
--    pytest.param("pure", id="pure"),
--    pytest.param("herm", id="mixed")
--])
--def test_spin_q_function(spin, pure):
--    d = int(2*spin + 1)
--    rho = rand_dm(d, distribution=pure)
--
--    # Points at which to evaluate the spin Q function
--    theta = np.linspace(0, np.pi, 16, endpoint=True)
--    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
--    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
--
--    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
--        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
--        direct_Q = abs(state.dag() * rho * state)
--        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
--
--@pytest.mark.parametrize(['spin'], [
--    pytest.param(1/2, id="spin-one-half"),
--    pytest.param(3, id="spin-three"),
--    pytest.param(13/2, id="spin-thirteen-half"),
--    pytest.param(7, id="spin-seven")
--])
--@pytest.mark.parametrize("pure", [
--    pytest.param("pure", id="pure"),
--    pytest.param("herm", id="mixed")
--])
--def test_spin_q_function_normalized(spin, pure):
--    d = int(2 * spin + 1)
--    rho = rand_dm(d, distribution=pure)
--
--    # Points at which to evaluate the spin Q function
--    theta = np.linspace(0, np.pi, 128, endpoint=True)
--    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
--    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
--
--    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
--    assert_almost_equal(norm, 1, decimal=4)
--
--
--@pytest.mark.parametrize(["spin"], [
--    pytest.param(1/2, id="spin-one-half"),
--    pytest.param(1, id="spin-one"),
--    pytest.param(3/2, id="spin-three-half"),
--    pytest.param(2, id="spin-two")
--])
--@pytest.mark.parametrize("pure", [
--    pytest.param("pure", id="pure"),
--    pytest.param("herm", id="mixed")
--])
--def test_spin_wigner_normalized(spin, pure):
--    d = int(2*spin + 1)
--    rho = rand_dm(d, distribution=pure)
--
--    # Points at which to evaluate the spin Wigner function
--    theta = np.linspace(0, np.pi, 256, endpoint=True)
--    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
--    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
--
--    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
--    assert_almost_equal(norm, 1, decimal=4)
--
--@pytest.mark.parametrize(['spin'], [
--    pytest.param(1 / 2, id="spin-one-half"),
--    pytest.param(1, id="spin-one"),
--    pytest.param(3 / 2, id="spin-three-half"),
--    pytest.param(2, id="spin-two")
--])
--@pytest.mark.parametrize("pure", [
--    pytest.param("pure", id="pure"),
--    pytest.param("herm", id="mixed")
--])
--def test_spin_wigner_overlap(spin, pure, n=5):
--    d = int(2*spin + 1)
--    rho = rand_dm(d, distribution=pure)
--
--    # Points at which to evaluate the spin Wigner function
--    theta = np.linspace(0, np.pi, 256, endpoint=True)
--    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
--    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
--
--    for k in range(n):
--        test_state = rand_dm(d)
--        state_overlap = (test_state*rho).tr().real
--
--        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
--        W_overlap = np.trapz(
--            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
--        assert_almost_equal(W_overlap, state_overlap, decimal=4)
--
--if __name__ == "__main__":
--    run_module_suite()
-+import pytest
-+import numpy as np
-+import itertools
-+from scipy.special import laguerre
-+from numpy.random import rand
-+from numpy.testing import assert_, run_module_suite, assert_equal, \
-+    assert_almost_equal, assert_allclose
-+
-+import qutip
-+from qutip.core.states import coherent, fock, ket, bell_state
-+from qutip.wigner import wigner, wigner_transform, _parity
-+from qutip.random_objects import rand_dm, rand_ket
-+
-+
-+class TestHusimiQ:
-+    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
-+    def test_failure_if_non_arraylike_coordinates(self, xs):
-+        state = qutip.rand_ket(4)
-+        valid = np.linspace(-1, 1, 5)
-+        with pytest.raises(TypeError) as e:
-+            qutip.qfunc(state, xs, valid)
-+        assert "must be array-like" in e.value.args[0]
-+        with pytest.raises(TypeError) as e:
-+            qutip.qfunc(state, valid, xs)
-+        assert "must be array-like" in e.value.args[0]
-+        with pytest.raises(TypeError) as e:
-+            qutip.QFunc(xs, valid)
-+        assert "must be array-like" in e.value.args[0]
-+        with pytest.raises(TypeError) as e:
-+            qutip.QFunc(valid, xs)
-+        assert "must be array-like" in e.value.args[0]
-+
-+    @pytest.mark.parametrize('ndim', [2, 3])
-+    def test_failure_if_coordinates_not_1d(self, ndim):
-+        state = qutip.rand_ket(4)
-+        valid = np.linspace(-1, 1, 5)
-+        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
-+        with pytest.raises(ValueError) as e:
-+            qutip.qfunc(state, bad, valid)
-+        assert "must be 1D" in e.value.args[0]
-+        with pytest.raises(ValueError) as e:
-+            qutip.qfunc(state, valid, bad)
-+        assert "must be 1D" in e.value.args[0]
-+        with pytest.raises(ValueError) as e:
-+            qutip.QFunc(bad, valid)
-+        assert "must be 1D" in e.value.args[0]
-+        with pytest.raises(ValueError) as e:
-+            qutip.QFunc(valid, bad)
-+        assert "must be 1D" in e.value.args[0]
-+
-+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-+    def test_failure_if_tensor_hilbert_space(self, dm):
-+        if dm:
-+            state = qutip.rand_dm([2, 2])
-+        else:
-+            state = qutip.rand_ket([2, 2])
-+        xs = np.linspace(-1, 1, 5)
-+        with pytest.raises(ValueError) as e:
-+            qutip.qfunc(state, xs, xs)
-+        assert "must not have tensor structure" in e.value.args[0]
-+        with pytest.raises(ValueError) as e:
-+            qutip.QFunc(xs, xs)(state)
-+        assert "must not have tensor structure" in e.value.args[0]
-+
-+    def test_QFunc_raises_if_insufficient_memory(self):
-+        xs = np.linspace(-1, 1, 11)
-+        state = qutip.rand_ket(4)
-+        qfunc = qutip.QFunc(xs, xs, memory=0)
-+        with pytest.raises(MemoryError) as e:
-+            qfunc(state)
-+        assert e.value.args[0].startswith("Refusing to precompute")
-+
-+    def test_qfunc_warns_if_insufficient_memory(self):
-+        xs = np.linspace(-1, 1, 11)
-+        state = qutip.rand_dm(4)
-+        with pytest.warns(UserWarning) as e:
-+            qutip.qfunc(state, xs, xs, precompute_memory=0)
-+        assert (
-+            e[0].message.args[0]
-+            .startswith("Falling back to iterative algorithm")
-+        )
-+
-+    @pytest.mark.parametrize('obj', [
-+        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
-+        pytest.param([[1, 0], [0, 1]], id='list'),
-+        pytest.param(1, id='int'),
-+    ])
-+    def test_failure_if_not_a_Qobj(self, obj):
-+        xs = np.linspace(-1, 1, 11)
-+        with pytest.raises(TypeError) as e:
-+            qutip.qfunc(obj, xs, xs)
-+        assert e.value.args[0].startswith("state must be Qobj")
-+        qfunc = qutip.QFunc(xs, xs)
-+        with pytest.raises(TypeError) as e:
-+            qfunc(obj)
-+        assert e.value.args[0].startswith("state must be Qobj")
-+
-+    # Use indirection so that the tests can still be collected if there's a bug
-+    # in the generating QuTiP functions.
-+    @pytest.mark.parametrize('state', [
-+        pytest.param(lambda: qutip.rand_super(2), id='super'),
-+        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
-+        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
-+        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
-+                     id='nonsquare dm'),
-+        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
-+                     id='operator-ket'),
-+        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
-+                     id='operator-bra'),
-+    ])
-+    def test_failure_if_not_a_state(self, state):
-+        xs = np.linspace(-1, 1, 11)
-+        state = state()
-+        with pytest.raises(ValueError) as e:
-+            qutip.qfunc(state, xs, xs)
-+        assert (
-+            e.value.args[0].startswith("state must be a ket or density matrix")
-+        )
-+        qfunc = qutip.QFunc(xs, xs)
-+        with pytest.raises(ValueError) as e:
-+            qfunc(state)
-+        assert (
-+            e.value.args[0].startswith("state must be a ket or density matrix")
-+        )
-+
-+    @pytest.mark.parametrize('g', [
-+        pytest.param(np.sqrt(2), id='natural units'),
-+        pytest.param(1, id='arb units'),
-+    ])
-+    @pytest.mark.parametrize('n_ys', [5, 101])
-+    @pytest.mark.parametrize('n_xs', [5, 101])
-+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-+    @pytest.mark.parametrize('size', [5, 32])
-+    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
-+        xs = np.linspace(-1, 1, n_xs)
-+        ys = np.linspace(0, 2, n_ys)
-+        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
-+        function = qutip.qfunc(state, xs, ys, g)
-+        class_ = qutip.QFunc(xs, ys, g)(state)
-+        np.testing.assert_allclose(function, class_)
-+
-+    @pytest.mark.parametrize('g', [
-+        pytest.param(np.sqrt(2), id='natural units'),
-+        pytest.param(1, id='arb units'),
-+    ])
-+    @pytest.mark.parametrize('n_ys', [5, 101])
-+    @pytest.mark.parametrize('n_xs', [5, 101])
-+    @pytest.mark.parametrize('size', [5, 32])
-+    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
-+        xs = np.linspace(-1, 1, n_xs)
-+        ys = np.linspace(0, 2, n_ys)
-+        state = qutip.rand_dm(size)
-+        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
-+        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
-+        np.testing.assert_allclose(iterate, precompute)
-+
-+    @pytest.mark.parametrize('initial_size', [5, 8])
-+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-+    def test_same_class_can_take_many_sizes(self, dm, initial_size):
-+        xs = np.linspace(-1, 1, 11)
-+        ys = np.linspace(0, 2, 11)
-+        shape = np.meshgrid(xs, ys)[0].shape
-+        sizes = initial_size + np.array([0, 1, -1, 4])
-+        qfunc = qutip.QFunc(xs, ys)
-+        for size in sizes:
-+            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
-+            out = qfunc(state)
-+            assert isinstance(out, np.ndarray)
-+            assert out.shape == shape
-+
-+    @pytest.mark.parametrize('dm_first', [True, False])
-+    def test_same_class_can_mix_ket_and_dm(self, dm_first):
-+        dms = [True, False, True, False]
-+        if not dm_first:
-+            dms = dms[::-1]
-+        xs = np.linspace(-1, 1, 11)
-+        ys = np.linspace(0, 2, 11)
-+        shape = np.meshgrid(xs, ys)[0].shape
-+        qfunc = qutip.QFunc(xs, ys)
-+        for dm in dms:
-+            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
-+            out = qfunc(state)
-+            assert isinstance(out, np.ndarray)
-+            assert out.shape == shape
-+
-+    @pytest.mark.parametrize('n_ys', [5, 101])
-+    @pytest.mark.parametrize('n_xs', [5, 101])
-+    @pytest.mark.parametrize('mix', [0.1, 0.5])
-+    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
-+        xs = np.linspace(-1, 1, n_xs)
-+        ys = np.linspace(-1, 1, n_ys)
-+        qfunc = qutip.QFunc(xs, ys)
-+        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
-+        qleft, qright = qfunc(left), qfunc(right)
-+        qboth = qfunc(mix*left + (1-mix)*right)
-+        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
-+
-+    @pytest.mark.parametrize('n_ys', [5, 101])
-+    @pytest.mark.parametrize('n_xs', [5, 101])
-+    @pytest.mark.parametrize('size', [5, 32])
-+    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
-+        xs = np.linspace(-1, 1, n_xs)
-+        ys = np.linspace(-1, 1, n_ys)
-+        state = qutip.rand_ket(size)
-+        qfunc = qutip.QFunc(xs, ys)
-+        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
-+
-+    @pytest.mark.parametrize('g', [
-+        pytest.param(np.sqrt(2), id='natural units'),
-+        pytest.param(1, id='arb units'),
-+    ])
-+    @pytest.mark.parametrize('ys', [
-+        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
-+        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
-+    ])
-+    @pytest.mark.parametrize('xs', [
-+        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
-+        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
-+    ])
-+    @pytest.mark.parametrize('size', [3, 5])
-+    def test_against_naive_implementation(self, xs, ys, g, size):
-+        state = qutip.rand_dm(size)
-+        state_np = state.full()
-+        x, y = np.meshgrid(xs, ys)
-+        alphas = 0.5*g * (x + 1j*y)
-+        naive = np.empty(alphas.shape, dtype=np.float64)
-+        for i, alpha in enumerate(alphas.flat):
-+            coh = qutip.coherent(size, alpha, method='analytic').full()
-+            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
-+        naive *= (0.5*g)**2 / np.pi
-+        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
-+        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
-+
-+
-+def test_wigner_bell1_su2parity():
-+    """wigner: testing the SU2 parity of the first Bell state.
-+    """
-+    psi = bell_state('00')
-+
-+    steps = 25
-+    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
-+    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
-+    slicearray = ['l', 'l']
-+
-+    wigner_analyt = np.zeros((steps, steps))
-+    for t in range(steps):
-+        for p in range(steps):
-+            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
-+                                            * np.cos(theta[0, t]))
-+                                           * (1 + np.sqrt(3)
-+                                           * np.cos(theta[1, t]))
-+                                           + 3 * (np.sin(theta[0, t])
-+                                           * np.exp(-1j * phi[0, p])
-+                                           * np.sin(theta[1, t])
-+                                           * np.exp(-1j * phi[1, p])
-+                                           + np.sin(theta[0, t])
-+                                           * np.exp(1j * phi[0, p])
-+                                           * np.sin(theta[1, t])
-+                                           * np.exp(1j * phi[1, p]))
-+                                           + (1 - np.sqrt(3)
-+                                           * np.cos(theta[0, t]))
-+                                           * (1 - np.sqrt(3)
-+                                           * np.cos(theta[1, t]))) / 8.)
-+
-+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-+
-+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-+
-+
-+@pytest.mark.slow
-+def test_wigner_bell4_su2parity():
-+    """wigner: testing the SU2 parity of the fourth Bell state.
-+    """
-+    psi = bell_state('11')
-+
-+    steps = 25
-+    slicearray = ['l', 'l']
-+
-+    wigner_analyt = np.zeros((steps, steps))
-+    for t in range(steps):
-+        for p in range(steps):
-+            wigner_analyt[t, p] = -0.5
-+
-+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-+
-+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-+
-+
-+@pytest.mark.slow
-+def test_wigner_bell4_fullparity():
-+    """wigner: testing the parity of the fourth Bell state using the parity of
-+    the full space.
-+    """
-+    psi = bell_state('11')
-+
-+    steps = 25
-+    slicearray = ['l', 'l']
-+
-+    wigner_analyt = np.zeros((steps, steps))
-+    for t in range(steps):
-+        for p in range(steps):
-+            wigner_analyt[t, p] = -0.30901699
-+
-+    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
-+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
-+
-+
-+def test_parity():
-+    """wigner: testing the parity function.
-+    """
-+    j = 0.5
-+    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
-+    assert_(_parity(2, j)[0, 1] < 1e-11)
-+    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
-+    assert_(_parity(2, j)[1, 0] < 1e-11)
-+
-+
-+@pytest.mark.slow
-+def test_wigner_pure_su2():
-+    """wigner: testing the SU2 wigner transformation of a pure state.
-+    """
-+    psi = (ket([1]))
-+    steps = 25
-+    theta = np.linspace(0, np.pi, steps)
-+    phi = np.linspace(0, 2 * np.pi, steps)
-+    theta = theta[None, :]
-+    phi = phi[None, :]
-+    slicearray = ['l']
-+
-+    wigner_analyt = np.zeros((steps, steps))
-+    for t in range(steps):
-+        for p in range(steps):
-+            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
-+
-+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-+
-+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-+
-+
-+@pytest.mark.slow
-+def test_wigner_ghz_su2parity():
-+    """wigner: testing the SU2 wigner transformation of the GHZ state.
-+    """
-+    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
-+
-+    steps = 25
-+    N = 3
-+    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
-+    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
-+    slicearray = ['l', 'l', 'l']
-+
-+    wigner_analyt = np.zeros((steps, steps))
-+    for t in range(steps):
-+        for p in range(steps):
-+            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
-+                                           * (1 + np.sqrt(3)
-+                                           * np.cos(theta[1, t]))
-+                                           * (1 + np.sqrt(3)
-+                                           * np.cos(theta[2, t]))
-+                                           + 3**(3 / 2) * (np.sin(theta[0, t])
-+                                           * np.exp(-1j * phi[0, p])
-+                                           * np.sin(theta[1, t])
-+                                           * np.exp(-1j * phi[1, p])
-+                                           * np.sin(theta[2, t])
-+                                           * np.exp(-1j * phi[2, p])
-+                                           + np.sin(theta[0, t])
-+                                           * np.exp(1j * phi[0, p])
-+                                           * np.sin(theta[1, t])
-+                                           * np.exp(1j * phi[1, p])
-+                                           * np.sin(theta[2, t])
-+                                           * np.exp(1j * phi[2, p]))
-+                                           + (1 - np.sqrt(3)
-+                                           * np.cos(theta[0, t]))
-+                                           * (1 - np.sqrt(3)
-+                                           * np.cos(theta[1, t]))
-+                                           * (1 - np.sqrt(3)
-+                                           * np.cos(theta[2, t]))) / 16.)
-+
-+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-+
-+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-+
-+
-+@pytest.mark.slow
-+def test_angle_slicing():
-+    """wigner: tests angle slicing.
-+    """
-+    psi1 = bell_state('00')
-+    psi2 = bell_state('01')
-+    psi3 = bell_state('10')
-+    psi4 = bell_state('11')
-+
-+    steps = 25
-+    j = 0.5
-+
-+    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
-+    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
-+    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
-+    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
-+
-+    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
-+    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
-+    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
-+    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
-+
-+
-+def test_wigner_coherent():
-+    "wigner: test wigner function calculation for coherent states"
-+    xvec = np.linspace(-5.0, 5.0, 100)
-+    yvec = xvec
-+
-+    X, Y = np.meshgrid(xvec, yvec)
-+
-+    a = X + 1j * Y  # consistent with g=2 option to wigner function
-+
-+    dx = xvec[1] - xvec[0]
-+    dy = yvec[1] - yvec[0]
-+
-+    N = 20
-+    beta = rand() + rand() * 1.0j
-+    psi = coherent(N, beta)
-+
-+    # calculate the wigner function using qutip and analytic formula
-+    W_qutip = wigner(psi, xvec, yvec, g=2)
-+    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
-+    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
-+
-+    # check difference
-+    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
-+    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
-+
-+    # check normalization
-+    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-+    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-+    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
-+
-+
-+def test_wigner_fock():
-+    "wigner: test wigner function calculation for Fock states"
-+
-+    xvec = np.linspace(-5.0, 5.0, 100)
-+    yvec = xvec
-+
-+    X, Y = np.meshgrid(xvec, yvec)
-+
-+    a = X + 1j * Y  # consistent with g=2 option to wigner function
-+
-+    dx = xvec[1] - xvec[0]
-+    dy = yvec[1] - yvec[0]
-+
-+    N = 15
-+
-+    for n in [2, 3, 4, 5, 6]:
-+
-+        psi = fock(N, n)
-+
-+        # calculate the wigner function using qutip and analytic formula
-+        W_qutip = wigner(psi, xvec, yvec, g=2)
-+        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
-+        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
-+        W_analytic = 2 / np.pi * (-1) ** n * \
-+            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
-+
-+        # check difference
-+        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
-+        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
-+        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
-+
-+        # check normalization
-+        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-+        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-+        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
-+        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
-+
-+
-+def test_wigner_compare_methods_dm():
-+    "wigner: compare wigner methods for random density matrices"
-+
-+    xvec = np.linspace(-5.0, 5.0, 100)
-+    yvec = xvec
-+
-+    X, Y = np.meshgrid(xvec, yvec)
-+
-+    # a = X + 1j * Y  # consistent with g=2 option to wigner function
-+
-+    dx = xvec[1] - xvec[0]
-+    dy = yvec[1] - yvec[0]
-+
-+    N = 15
-+
-+    for n in range(10):
-+        # try ten different random density matrices
-+
-+        rho = rand_dm(N, density=0.5 + rand() / 2)
-+
-+        # calculate the wigner function using qutip and analytic formula
-+        W_qutip1 = wigner(rho, xvec, yvec, g=2)
-+        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
-+
-+        # check difference
-+        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
-+
-+        # check normalization
-+        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-+        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
-+
-+
-+def test_wigner_compare_methods_ket():
-+    "wigner: compare wigner methods for random state vectors"
-+
-+    xvec = np.linspace(-5.0, 5.0, 100)
-+    yvec = xvec
-+
-+    X, Y = np.meshgrid(xvec, yvec)
-+
-+    # a = X + 1j * Y  # consistent with g=2 option to wigner function
-+
-+    dx = xvec[1] - xvec[0]
-+    dy = yvec[1] - yvec[0]
-+
-+    N = 15
-+
-+    for n in range(10):
-+        # try ten different random density matrices
-+
-+        psi = rand_ket(N, density=0.5 + rand() / 2)
-+
-+        # calculate the wigner function using qutip and analytic formula
-+        W_qutip1 = wigner(psi, xvec, yvec, g=2)
-+        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
-+
-+        # check difference
-+        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
-+
-+        # check normalization
-+        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-+        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
-+
-+
-+def test_wigner_fft_comparse_ket():
-+    "Wigner: Compare Wigner fft and iterative for rand. ket"
-+    N = 20
-+    xvec = np.linspace(-10, 10, 128)
-+    for i in range(3):
-+        rho = rand_ket(N)
-+
-+        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
-+        W = wigner(rho, xvec, yvec, method='iterative')
-+
-+        Wdiff = abs(W - Wfft)
-+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-+
-+
-+def test_wigner_fft_comparse_dm():
-+    "Wigner: Compare Wigner fft and iterative for rand. dm"
-+    N = 20
-+    xvec = np.linspace(-10, 10, 128)
-+    for i in range(3):
-+        rho = rand_dm(N)
-+
-+        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
-+        W = wigner(rho, xvec, yvec, method='iterative')
-+
-+        Wdiff = abs(W - Wfft)
-+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-+
-+
-+def test_wigner_clenshaw_iter_dm():
-+    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
-+    N = 20
-+    xvec = np.linspace(-10, 10, 128)
-+    for i in range(3):
-+        rho = rand_dm(N)
-+
-+        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
-+        W = wigner(rho, xvec, xvec, method='iterative')
-+
-+        Wdiff = abs(W - Wclen)
-+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-+
-+
-+def test_wigner_clenshaw_sp_iter_dm():
-+    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
-+    N = 20
-+    xvec = np.linspace(-10, 10, 128)
-+    for i in range(3):
-+        rho = rand_dm(N)
-+
-+        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
-+        W = wigner(rho, xvec, xvec, method='iterative')
-+
-+        Wdiff = abs(W - Wclen)
-+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-+
-+@pytest.mark.parametrize(['spin'], [
-+    pytest.param(1/2, id="spin-one-half"),
-+    pytest.param(3, id="spin-three"),
-+    pytest.param(13/2, id="spin-thirteen-half"),
-+    pytest.param(7, id="spin-seven")
-+])
-+@pytest.mark.parametrize("pure", [
-+    pytest.param("pure", id="pure"),
-+    pytest.param("herm", id="mixed")
-+])
-+def test_spin_q_function(spin, pure):
-+    d = int(2*spin + 1)
-+    rho = rand_dm(d, distribution=pure)
-+
-+    # Points at which to evaluate the spin Q function
-+    theta = np.linspace(0, np.pi, 16, endpoint=True)
-+    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
-+    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
-+
-+    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
-+        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
-+        direct_Q = abs(state.dag() * rho * state)
-+        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
-+
-+@pytest.mark.parametrize(['spin'], [
-+    pytest.param(1/2, id="spin-one-half"),
-+    pytest.param(3, id="spin-three"),
-+    pytest.param(13/2, id="spin-thirteen-half"),
-+    pytest.param(7, id="spin-seven")
-+])
-+@pytest.mark.parametrize("pure", [
-+    pytest.param("pure", id="pure"),
-+    pytest.param("herm", id="mixed")
-+])
-+def test_spin_q_function_normalized(spin, pure):
-+    d = int(2 * spin + 1)
-+    rho = rand_dm(d, distribution=pure)
-+
-+    # Points at which to evaluate the spin Q function
-+    theta = np.linspace(0, np.pi, 128, endpoint=True)
-+    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
-+    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
-+
-+    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
-+    assert_almost_equal(norm, 1, decimal=4)
-+
-+
-+@pytest.mark.parametrize(["spin"], [
-+    pytest.param(1/2, id="spin-one-half"),
-+    pytest.param(1, id="spin-one"),
-+    pytest.param(3/2, id="spin-three-half"),
-+    pytest.param(2, id="spin-two")
-+])
-+@pytest.mark.parametrize("pure", [
-+    pytest.param("pure", id="pure"),
-+    pytest.param("herm", id="mixed")
-+])
-+def test_spin_wigner_normalized(spin, pure):
-+    d = int(2*spin + 1)
-+    rho = rand_dm(d, distribution=pure)
-+
-+    # Points at which to evaluate the spin Wigner function
-+    theta = np.linspace(0, np.pi, 256, endpoint=True)
-+    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
-+    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
-+
-+    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
-+    assert_almost_equal(norm, 1, decimal=4)
-+
-+@pytest.mark.parametrize(['spin'], [
-+    pytest.param(1 / 2, id="spin-one-half"),
-+    pytest.param(1, id="spin-one"),
-+    pytest.param(3 / 2, id="spin-three-half"),
-+    pytest.param(2, id="spin-two")
-+])
-+@pytest.mark.parametrize("pure", [
-+    pytest.param("pure", id="pure"),
-+    pytest.param("herm", id="mixed")
-+])
-+def test_spin_wigner_overlap(spin, pure, n=5):
-+    d = int(2*spin + 1)
-+    rho = rand_dm(d, distribution=pure)
-+
-+    # Points at which to evaluate the spin Wigner function
-+    theta = np.linspace(0, np.pi, 256, endpoint=True)
-+    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
-+    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
-+
-+    for k in range(n):
-+        test_state = rand_dm(d)
-+        state_overlap = (test_state*rho).tr().real
-+
-+        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
-+        W_overlap = np.trapz(
-+            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
-+        assert_almost_equal(W_overlap, state_overlap, decimal=4)
-+
-+if __name__ == "__main__":
-+    run_module_suite()
-diff --git a/qutip/three_level_atom.py b/qutip/three_level_atom.py
-index eee506ef..8db037df 100644
---- a/qutip/three_level_atom.py
-+++ b/qutip/three_level_atom.py
-@@ -1,74 +1,74 @@
--r'''
--This module provides functions that are useful for simulating the
--three level atom with QuTiP.  A three level atom (qutrit) has three states,
--which are linked by dipole transitions so that 1 <-> 2 <-> 3.
--Depending on there relative energies they are in the ladder, lambda or
--vee configuration. The structure of the relevant operators is the same
--for any of the three configurations::
--
--    Ladder:          Lambda:                 Vee:
--                                |two>                       |three>
--      -------|three>           -------                      -------
--         |                       / \             |one>         /
--         |                      /   \           -------       /
--         |                     /     \             \         /
--      -------|two>            /       \             \       /
--         |                   /         \             \     /
--         |                  /           \             \   /
--         |                 /        --------           \ /
--      -------|one>      -------      |three>         -------
--                         |one>                       |two>
--
--References
------------
--The naming of qutip operators follows the convention in [1]_ .
--
--.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
--   Wiley, 1990.
--
--Notes
-------
--Contributed by Markus Baden, Oct. 07, 2011
--
--'''
--
--__all__ = ['three_level_basis', 'three_level_ops']
--
--import numpy as np
--from . import qutrit_basis
--
--
--def three_level_basis():
--    ''' Basis states for a three level atom.
--
--    Returns
--    -------
--    states : np.array
--        :obj:`numpy.ndarray` of three level atom basis vectors.
--    '''
--    # A three level atom has the same representation as a qutrit, i.e.
--    # three states
--    return qutrit_basis()
--
--
--def three_level_ops():
--    """
--    Operators for a three level system (qutrit)
--
--    Returns
--    -------
--    ops : np.array
--        :obj:`numpy.ndarray` of three level operators.
--    """
--    out = np.empty((5,), dtype=object)
--    one, two, three = qutrit_basis()
--    # Note that the three level operators are different
--    # from the qutrit operators. A three level atom only
--    # has transitions 1 <-> 2 <-> 3, so we define the
--    # operators seperately from the qutrit code
--    out[0] = one * one.dag()
--    out[1] = two * two.dag()
--    out[2] = three * three.dag()
--    out[3] = one * two.dag()
--    out[4] = three * two.dag()
--    return out
-+r'''
-+This module provides functions that are useful for simulating the
-+three level atom with QuTiP.  A three level atom (qutrit) has three states,
-+which are linked by dipole transitions so that 1 <-> 2 <-> 3.
-+Depending on there relative energies they are in the ladder, lambda or
-+vee configuration. The structure of the relevant operators is the same
-+for any of the three configurations::
-+
-+    Ladder:          Lambda:                 Vee:
-+                                |two>                       |three>
-+      -------|three>           -------                      -------
-+         |                       / \             |one>         /
-+         |                      /   \           -------       /
-+         |                     /     \             \         /
-+      -------|two>            /       \             \       /
-+         |                   /         \             \     /
-+         |                  /           \             \   /
-+         |                 /        --------           \ /
-+      -------|one>      -------      |three>         -------
-+                         |one>                       |two>
-+
-+References
-+----------
-+The naming of qutip operators follows the convention in [1]_ .
-+
-+.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
-+   Wiley, 1990.
-+
-+Notes
-+-----
-+Contributed by Markus Baden, Oct. 07, 2011
-+
-+'''
-+
-+__all__ = ['three_level_basis', 'three_level_ops']
-+
-+import numpy as np
-+from . import qutrit_basis
-+
-+
-+def three_level_basis():
-+    ''' Basis states for a three level atom.
-+
-+    Returns
-+    -------
-+    states : np.array
-+        :obj:`numpy.ndarray` of three level atom basis vectors.
-+    '''
-+    # A three level atom has the same representation as a qutrit, i.e.
-+    # three states
-+    return qutrit_basis()
-+
-+
-+def three_level_ops():
-+    """
-+    Operators for a three level system (qutrit)
-+
-+    Returns
-+    -------
-+    ops : np.array
-+        :obj:`numpy.ndarray` of three level operators.
-+    """
-+    out = np.empty((5,), dtype=object)
-+    one, two, three = qutrit_basis()
-+    # Note that the three level operators are different
-+    # from the qutrit operators. A three level atom only
-+    # has transitions 1 <-> 2 <-> 3, so we define the
-+    # operators seperately from the qutrit code
-+    out[0] = one * one.dag()
-+    out[1] = two * two.dag()
-+    out[2] = three * three.dag()
-+    out[3] = one * two.dag()
-+    out[4] = three * two.dag()
-+    return out
-diff --git a/qutip/tomography.py b/qutip/tomography.py
-index a663ee30..bf83020e 100644
---- a/qutip/tomography.py
-+++ b/qutip/tomography.py
-@@ -1,190 +1,190 @@
--__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
--
--from numpy import hstack, real, imag
--import scipy.linalg as la
--from . import tensor, spre, spost, stack_columns, unstack_columns
--from .visualization import matrix_histogram, matrix_histogram_complex
--
--try:
--    import matplotlib.pyplot as plt
--except:
--    pass
--
--
--def _index_permutations(size_list, perm=[]):
--    """
--    Generate a list with all index permutations.
--
--    Parameters
--    ----------
--    size_list : list
--        A list that contains the sizes for each composite system.
--    perm : list
--        A list of permutations
--
--    Returns
--    -------
--    perm_idx : list
--        List containing index permutations.
--
--
--    """
--    if len(size_list) == 0:
--        yield perm
--    else:
--        for n in range(size_list[0]):
--            for ip in _index_permutations(size_list[1:], perm + [n]):
--                yield ip
--
--
--def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
--    """
--    Visualize the quantum process tomography chi matrix. Plot the real and
--    imaginary parts separately.
--
--    Parameters
--    ----------
--    chi : array
--        Input QPT chi matrix.
--    lbls_list : list
--        List of labels for QPT plot axes.
--    title : string
--        Plot title.
--    fig : figure instance
--        User defined figure instance used for generating QPT plot.
--    axes : list of figure axis instance
--        User defined figure axis instance (list of two axes) used for
--        generating QPT plot.
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    """
--
--    if axes is None or len(axes) != 2:
--        if fig is None:
--            fig = plt.figure(figsize=(16, 8))
--
--        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
--        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
--
--        axes = [ax1, ax2]
--
--    xlabels = []
--    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
--        xlabels.append("".join([lbls_list[k][inds[k]]
--                                for k in range(len(lbls_list))]))
--
--    matrix_histogram(real(chi), xlabels, xlabels,
--                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
--    matrix_histogram(imag(chi), xlabels, xlabels,
--                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
--
--    if title and fig:
--        fig.suptitle(title)
--
--    return fig, axes
--
--
--def qpt_plot_combined(chi, lbls_list, title=None,
--                      fig=None, ax=None, figsize=(8, 6),
--                      threshold=None):
--    """
--    Visualize the quantum process tomography chi matrix. Plot bars with
--    height and color corresponding to the absolute value and phase,
--    respectively.
--
--    Parameters
--    ----------
--    chi : array
--        Input QPT chi matrix.
--
--    lbls_list : list
--        List of labels for QPT plot axes.
--
--    title : string
--        Plot title.
--
--    fig : figure instance
--        User defined figure instance used for generating QPT plot.
--
--    ax : figure axis instance
--        User defined figure axis instance used for generating QPT plot
--        (alternative to the fig argument).
--
--    threshold: float (None)
--        Threshold for when bars of smaller height should be transparent. If
--        not set, all bars are colored according to the color map.
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--
--    if ax is None:
--        if fig is None:
--            fig = plt.figure(figsize=figsize)
--        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
--
--    xlabels = []
--    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
--        xlabels.append("".join(
--            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
--
--    if not title:
--        title = r"$\chi$"
--
--    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
--                             threshold=threshold)
--
--    return fig, ax
--
--
--def qpt(U, op_basis_list):
--    """
--    Calculate the quantum process tomography chi matrix for a given (possibly
--    nonunitary) transformation matrix U, which transforms a density matrix in
--    vector form according to:
--
--        vec(rho) = U * vec(rho0)
--
--        or
--
--        rho = unstack_columns(U * stack_columns(rho0))
--
--    U can be calculated for an open quantum system using the QuTiP propagator
--    function.
--
--    Parameters
--    ----------
--    U : Qobj
--        Transformation operator. Can be calculated using QuTiP propagator
--        function.
--
--    op_basis_list : list
--        A list of Qobj's representing the basis states.
--
--    Returns
--    -------
--    chi : array
--        QPT chi matrix
--
--    """
--
--    E_ops = []
--    # loop over all index permutations
--    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
--        # loop over all composite systems
--        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
--            op_basis_list))]
--        E_ops.append(tensor(E_op_list))
--    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
--    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
--    Uvec = U.full().ravel('F')
--    chi_vec = la.solve(M, Uvec)
--    return chi_vec.reshape(U.shape).T
-+__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
-+
-+from numpy import hstack, real, imag
-+import scipy.linalg as la
-+from . import tensor, spre, spost, stack_columns, unstack_columns
-+from .visualization import matrix_histogram, matrix_histogram_complex
-+
-+try:
-+    import matplotlib.pyplot as plt
-+except:
-+    pass
-+
-+
-+def _index_permutations(size_list, perm=[]):
-+    """
-+    Generate a list with all index permutations.
-+
-+    Parameters
-+    ----------
-+    size_list : list
-+        A list that contains the sizes for each composite system.
-+    perm : list
-+        A list of permutations
-+
-+    Returns
-+    -------
-+    perm_idx : list
-+        List containing index permutations.
-+
-+
-+    """
-+    if len(size_list) == 0:
-+        yield perm
-+    else:
-+        for n in range(size_list[0]):
-+            for ip in _index_permutations(size_list[1:], perm + [n]):
-+                yield ip
-+
-+
-+def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
-+    """
-+    Visualize the quantum process tomography chi matrix. Plot the real and
-+    imaginary parts separately.
-+
-+    Parameters
-+    ----------
-+    chi : array
-+        Input QPT chi matrix.
-+    lbls_list : list
-+        List of labels for QPT plot axes.
-+    title : string
-+        Plot title.
-+    fig : figure instance
-+        User defined figure instance used for generating QPT plot.
-+    axes : list of figure axis instance
-+        User defined figure axis instance (list of two axes) used for
-+        generating QPT plot.
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    """
-+
-+    if axes is None or len(axes) != 2:
-+        if fig is None:
-+            fig = plt.figure(figsize=(16, 8))
-+
-+        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
-+        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
-+
-+        axes = [ax1, ax2]
-+
-+    xlabels = []
-+    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
-+        xlabels.append("".join([lbls_list[k][inds[k]]
-+                                for k in range(len(lbls_list))]))
-+
-+    matrix_histogram(real(chi), xlabels, xlabels,
-+                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
-+    matrix_histogram(imag(chi), xlabels, xlabels,
-+                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
-+
-+    if title and fig:
-+        fig.suptitle(title)
-+
-+    return fig, axes
-+
-+
-+def qpt_plot_combined(chi, lbls_list, title=None,
-+                      fig=None, ax=None, figsize=(8, 6),
-+                      threshold=None):
-+    """
-+    Visualize the quantum process tomography chi matrix. Plot bars with
-+    height and color corresponding to the absolute value and phase,
-+    respectively.
-+
-+    Parameters
-+    ----------
-+    chi : array
-+        Input QPT chi matrix.
-+
-+    lbls_list : list
-+        List of labels for QPT plot axes.
-+
-+    title : string
-+        Plot title.
-+
-+    fig : figure instance
-+        User defined figure instance used for generating QPT plot.
-+
-+    ax : figure axis instance
-+        User defined figure axis instance used for generating QPT plot
-+        (alternative to the fig argument).
-+
-+    threshold: float (None)
-+        Threshold for when bars of smaller height should be transparent. If
-+        not set, all bars are colored according to the color map.
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+
-+    if ax is None:
-+        if fig is None:
-+            fig = plt.figure(figsize=figsize)
-+        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
-+
-+    xlabels = []
-+    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
-+        xlabels.append("".join(
-+            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
-+
-+    if not title:
-+        title = r"$\chi$"
-+
-+    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
-+                             threshold=threshold)
-+
-+    return fig, ax
-+
-+
-+def qpt(U, op_basis_list):
-+    """
-+    Calculate the quantum process tomography chi matrix for a given (possibly
-+    nonunitary) transformation matrix U, which transforms a density matrix in
-+    vector form according to:
-+
-+        vec(rho) = U * vec(rho0)
-+
-+        or
-+
-+        rho = unstack_columns(U * stack_columns(rho0))
-+
-+    U can be calculated for an open quantum system using the QuTiP propagator
-+    function.
-+
-+    Parameters
-+    ----------
-+    U : Qobj
-+        Transformation operator. Can be calculated using QuTiP propagator
-+        function.
-+
-+    op_basis_list : list
-+        A list of Qobj's representing the basis states.
-+
-+    Returns
-+    -------
-+    chi : array
-+        QPT chi matrix
-+
-+    """
-+
-+    E_ops = []
-+    # loop over all index permutations
-+    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
-+        # loop over all composite systems
-+        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
-+            op_basis_list))]
-+        E_ops.append(tensor(E_op_list))
-+    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
-+    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
-+    Uvec = U.full().ravel('F')
-+    chi_vec = la.solve(M, Uvec)
-+    return chi_vec.reshape(U.shape).T
-diff --git a/qutip/ui/__init__.py b/qutip/ui/__init__.py
-index d9fdd468..a640ed1f 100644
---- a/qutip/ui/__init__.py
-+++ b/qutip/ui/__init__.py
-@@ -1 +1 @@
--from qutip.ui.progressbar import *
-+from qutip.ui.progressbar import *
-diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
-index 8bebca70..a862a24d 100644
---- a/qutip/ui/progressbar.py
-+++ b/qutip/ui/progressbar.py
-@@ -1,212 +1,212 @@
--__all__ = ['BaseProgressBar', 'TextProgressBar',
--           'EnhancedTextProgressBar', 'TqdmProgressBar',
--           'HTMLProgressBar', 'progess_bars']
--
--import time
--import datetime
--import sys
--
--
--class BaseProgressBar(object):
--    """
--    An abstract progress bar with some shared functionality.
--
--    Example usage:
--
--        n_vec = linspace(0, 10, 100)
--        pbar = TextProgressBar(len(n_vec))
--        for n in n_vec:
--            pbar.update(n)
--            compute_with_n(n)
--        pbar.finished()
--
--    """
--
--    def __init__(self, iterations=0, chunk_size=10):
--        pass
--
--    def start(self, iterations, chunk_size=10, **kwargs):
--        self.N = float(iterations)
--        self.n = 0
--        self.p_chunk_size = chunk_size
--        self.p_chunk = chunk_size
--        self.t_start = time.time()
--        self.t_done = self.t_start - 1
--
--    def update(self, n=None):
--        pass
--
--    def total_time(self):
--        return self.t_done - self.t_start
--
--    def time_elapsed(self):
--        return "%6.2fs" % (time.time() - self.t_start)
--
--    def time_remaining_est(self, p):
--        if p > 0.0:
--            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
--        else:
--            t_r_est = 0
--
--        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
--        time_string = "%02d:%02d:%02d:%02d" % \
--            (dd.day - 1, dd.hour, dd.minute, dd.second)
--
--        return time_string
--
--    def finished(self):
--        self.t_done = time.time()
--
--
--class TextProgressBar(BaseProgressBar):
--    """
--    A simple text-based progress bar.
--    """
--
--    def __init__(self, iterations=0, chunk_size=10):
--        pass
--        # super(TextProgressBar, self).start(iterations, chunk_size)
--
--    def start(self, iterations, chunk_size=10, **kwargs):
--        super(TextProgressBar, self).start(iterations, chunk_size)
--
--    def update(self, n=None):
--        self.n += 1
--        n = self.n
--        p = (n / self.N) * 100.0
--        if p >= self.p_chunk:
--            print("%4.1f%%." % p +
--                  " Run time: %s." % self.time_elapsed() +
--                  " Est. time left: %s" % self.time_remaining_est(p))
--            sys.stdout.flush()
--            self.p_chunk += self.p_chunk_size
--
--    def finished(self):
--        self.t_done = time.time()
--        print("Total run time: %s" % self.time_elapsed())
--
--
--class EnhancedTextProgressBar(BaseProgressBar):
--    """
--    An enhanced text-based progress bar.
--    """
--
--    def __init__(self, iterations=0, chunk_size=10):
--        pass
--        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
--
--    def start(self, iterations, chunk_size=10, **kwargs):
--        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
--        self.fill_char = '*'
--        self.width = 25
--
--    def update(self, n=None):
--        self.n += 1
--        n = self.n
--        percent_done = int(round(n / self.N * 100.0))
--        all_full = self.width - 2
--        num_hashes = int(round((percent_done / 100.0) * all_full))
--        prog_bar = ('[' + self.fill_char * num_hashes +
--                    ' ' * (all_full - num_hashes) + ']')
--        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
--        pct_string = '%d%%' % percent_done
--        prog_bar = (prog_bar[0:pct_place] +
--                    (pct_string + prog_bar[pct_place + len(pct_string):]))
--        prog_bar += ' Elapsed %s / Remaining %s' % (
--            self.time_elapsed().strip(),
--            self.time_remaining_est(percent_done))
--        print('\r', prog_bar, end='')
--        sys.stdout.flush()
--
--    def finished(self):
--        self.t_done = time.time()
--        print("\r", "Total run time: %s" % self.time_elapsed())
--
--
--class TqdmProgressBar(BaseProgressBar):
--    """
--    A progress bar using tqdm module
--    """
--
--    def __init__(self, iterations=0, chunk_size=10):
--        from tqdm.auto import tqdm
--        self.tqdm = tqdm
--
--    def start(self, iterations, **kwargs):
--        self.pbar = self.tqdm(total=iterations, **kwargs)
--        self.t_start = time.time()
--        self.t_done = self.t_start - 1
--
--    def update(self, n=None):
--        self.pbar.update()
--
--    def finished(self):
--        self.pbar.close()
--        self.t_done = time.time()
--
--
--class HTMLProgressBar(BaseProgressBar):
--    """
--    A simple HTML progress bar for using in IPython notebooks. Based on
--    IPython ProgressBar demo notebook:
--    https://github.com/ipython/ipython/tree/master/examples/notebooks
--
--    Example usage:
--
--        n_vec = linspace(0, 10, 100)
--        pbar = HTMLProgressBar(len(n_vec))
--        for n in n_vec:
--            pbar.update(n)
--            compute_with_n(n)
--    """
--
--    def __init__(self, iterations=0, chunk_size=1.0):
--        self.divid = str(uuid.uuid4())
--        self.textid = str(uuid.uuid4())
--        self.pb = HTML("""\
--<div style="border: 2px solid grey; width: 600px">
--  <div id="%s" \
--style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
--</div>
--<p id="%s"></p>
--""" % (self.divid, self.textid))
--        display(self.pb)
--        super(HTMLProgressBar, self).start(iterations, chunk_size)
--
--    def start(self, iterations=0, chunk_size=1.0):
--        super(HTMLProgressBar, self).start(iterations, chunk_size)
--
--    def update(self, n):
--        p = (n / self.N) * 100.0
--        if p >= self.p_chunk:
--            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
--                   "Est. remaining time: %s." % self.time_remaining_est(p))
--            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
--                       "$('p#%s').text('%s');" % (self.textid, lbl))
--            display(Javascript(js_code))
--            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
--            # p)))
--            self.p_chunk += self.p_chunk_size
--
--    def finished(self):
--        self.t_done = time.time()
--        lbl = "Elapsed time: %s" % self.time_elapsed()
--        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
--                   "$('p#%s').text('%s');" % (self.textid, lbl))
--        display(Javascript(js_code))
--
--
--progess_bars = {
--    "Enhanced": EnhancedTextProgressBar,
--    "enhanced": EnhancedTextProgressBar,
--    "Text": TextProgressBar,
--    "text": TextProgressBar,
--    True: TextProgressBar,
--    "Tqdm": TqdmProgressBar,
--    "tqdm": TqdmProgressBar,
--    "Html": HTMLProgressBar,
--    "html": HTMLProgressBar,
--    "": BaseProgressBar,
--    False: BaseProgressBar,
--    None: BaseProgressBar,
--}
-+__all__ = ['BaseProgressBar', 'TextProgressBar',
-+           'EnhancedTextProgressBar', 'TqdmProgressBar',
-+           'HTMLProgressBar', 'progess_bars']
-+
-+import time
-+import datetime
-+import sys
-+
-+
-+class BaseProgressBar(object):
-+    """
-+    An abstract progress bar with some shared functionality.
-+
-+    Example usage:
-+
-+        n_vec = linspace(0, 10, 100)
-+        pbar = TextProgressBar(len(n_vec))
-+        for n in n_vec:
-+            pbar.update(n)
-+            compute_with_n(n)
-+        pbar.finished()
-+
-+    """
-+
-+    def __init__(self, iterations=0, chunk_size=10):
-+        pass
-+
-+    def start(self, iterations, chunk_size=10, **kwargs):
-+        self.N = float(iterations)
-+        self.n = 0
-+        self.p_chunk_size = chunk_size
-+        self.p_chunk = chunk_size
-+        self.t_start = time.time()
-+        self.t_done = self.t_start - 1
-+
-+    def update(self, n=None):
-+        pass
-+
-+    def total_time(self):
-+        return self.t_done - self.t_start
-+
-+    def time_elapsed(self):
-+        return "%6.2fs" % (time.time() - self.t_start)
-+
-+    def time_remaining_est(self, p):
-+        if p > 0.0:
-+            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
-+        else:
-+            t_r_est = 0
-+
-+        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
-+        time_string = "%02d:%02d:%02d:%02d" % \
-+            (dd.day - 1, dd.hour, dd.minute, dd.second)
-+
-+        return time_string
-+
-+    def finished(self):
-+        self.t_done = time.time()
-+
-+
-+class TextProgressBar(BaseProgressBar):
-+    """
-+    A simple text-based progress bar.
-+    """
-+
-+    def __init__(self, iterations=0, chunk_size=10):
-+        pass
-+        # super(TextProgressBar, self).start(iterations, chunk_size)
-+
-+    def start(self, iterations, chunk_size=10, **kwargs):
-+        super(TextProgressBar, self).start(iterations, chunk_size)
-+
-+    def update(self, n=None):
-+        self.n += 1
-+        n = self.n
-+        p = (n / self.N) * 100.0
-+        if p >= self.p_chunk:
-+            print("%4.1f%%." % p +
-+                  " Run time: %s." % self.time_elapsed() +
-+                  " Est. time left: %s" % self.time_remaining_est(p))
-+            sys.stdout.flush()
-+            self.p_chunk += self.p_chunk_size
-+
-+    def finished(self):
-+        self.t_done = time.time()
-+        print("Total run time: %s" % self.time_elapsed())
-+
-+
-+class EnhancedTextProgressBar(BaseProgressBar):
-+    """
-+    An enhanced text-based progress bar.
-+    """
-+
-+    def __init__(self, iterations=0, chunk_size=10):
-+        pass
-+        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-+
-+    def start(self, iterations, chunk_size=10, **kwargs):
-+        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-+        self.fill_char = '*'
-+        self.width = 25
-+
-+    def update(self, n=None):
-+        self.n += 1
-+        n = self.n
-+        percent_done = int(round(n / self.N * 100.0))
-+        all_full = self.width - 2
-+        num_hashes = int(round((percent_done / 100.0) * all_full))
-+        prog_bar = ('[' + self.fill_char * num_hashes +
-+                    ' ' * (all_full - num_hashes) + ']')
-+        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
-+        pct_string = '%d%%' % percent_done
-+        prog_bar = (prog_bar[0:pct_place] +
-+                    (pct_string + prog_bar[pct_place + len(pct_string):]))
-+        prog_bar += ' Elapsed %s / Remaining %s' % (
-+            self.time_elapsed().strip(),
-+            self.time_remaining_est(percent_done))
-+        print('\r', prog_bar, end='')
-+        sys.stdout.flush()
-+
-+    def finished(self):
-+        self.t_done = time.time()
-+        print("\r", "Total run time: %s" % self.time_elapsed())
-+
-+
-+class TqdmProgressBar(BaseProgressBar):
-+    """
-+    A progress bar using tqdm module
-+    """
-+
-+    def __init__(self, iterations=0, chunk_size=10):
-+        from tqdm.auto import tqdm
-+        self.tqdm = tqdm
-+
-+    def start(self, iterations, **kwargs):
-+        self.pbar = self.tqdm(total=iterations, **kwargs)
-+        self.t_start = time.time()
-+        self.t_done = self.t_start - 1
-+
-+    def update(self, n=None):
-+        self.pbar.update()
-+
-+    def finished(self):
-+        self.pbar.close()
-+        self.t_done = time.time()
-+
-+
-+class HTMLProgressBar(BaseProgressBar):
-+    """
-+    A simple HTML progress bar for using in IPython notebooks. Based on
-+    IPython ProgressBar demo notebook:
-+    https://github.com/ipython/ipython/tree/master/examples/notebooks
-+
-+    Example usage:
-+
-+        n_vec = linspace(0, 10, 100)
-+        pbar = HTMLProgressBar(len(n_vec))
-+        for n in n_vec:
-+            pbar.update(n)
-+            compute_with_n(n)
-+    """
-+
-+    def __init__(self, iterations=0, chunk_size=1.0):
-+        self.divid = str(uuid.uuid4())
-+        self.textid = str(uuid.uuid4())
-+        self.pb = HTML("""\
-+<div style="border: 2px solid grey; width: 600px">
-+  <div id="%s" \
-+style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
-+</div>
-+<p id="%s"></p>
-+""" % (self.divid, self.textid))
-+        display(self.pb)
-+        super(HTMLProgressBar, self).start(iterations, chunk_size)
-+
-+    def start(self, iterations=0, chunk_size=1.0):
-+        super(HTMLProgressBar, self).start(iterations, chunk_size)
-+
-+    def update(self, n):
-+        p = (n / self.N) * 100.0
-+        if p >= self.p_chunk:
-+            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
-+                   "Est. remaining time: %s." % self.time_remaining_est(p))
-+            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
-+                       "$('p#%s').text('%s');" % (self.textid, lbl))
-+            display(Javascript(js_code))
-+            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
-+            # p)))
-+            self.p_chunk += self.p_chunk_size
-+
-+    def finished(self):
-+        self.t_done = time.time()
-+        lbl = "Elapsed time: %s" % self.time_elapsed()
-+        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
-+                   "$('p#%s').text('%s');" % (self.textid, lbl))
-+        display(Javascript(js_code))
-+
-+
-+progess_bars = {
-+    "Enhanced": EnhancedTextProgressBar,
-+    "enhanced": EnhancedTextProgressBar,
-+    "Text": TextProgressBar,
-+    "text": TextProgressBar,
-+    True: TextProgressBar,
-+    "Tqdm": TqdmProgressBar,
-+    "tqdm": TqdmProgressBar,
-+    "Html": HTMLProgressBar,
-+    "html": HTMLProgressBar,
-+    "": BaseProgressBar,
-+    False: BaseProgressBar,
-+    None: BaseProgressBar,
-+}
-diff --git a/qutip/utilities.py b/qutip/utilities.py
-index 8d638307..5413730a 100644
---- a/qutip/utilities.py
-+++ b/qutip/utilities.py
-@@ -1,332 +1,332 @@
--"""
--This module contains utility functions that are commonly needed in other
--qutip modules.
--"""
--
--__all__ = ['n_thermal', 'clebsch', 'convert_unit']
--
--import numpy as np
--
--def n_thermal(w, w_th):
--    """
--    Return the number of photons in thermal equilibrium for an harmonic
--    oscillator mode with frequency 'w', at the temperature described by
--    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
--
--    Parameters
--    ----------
--
--    w : *float* or *array*
--        Frequency of the oscillator.
--
--    w_th : *float*
--        The temperature in units of frequency (or the same units as `w`).
--
--
--    Returns
--    -------
--
--    n_avg : *float* or *array*
--
--        Return the number of average photons in thermal equilibrium for a
--        an oscillator with the given frequency and temperature.
--
--
--    """
--
--    if isinstance(w, np.ndarray):
--        return 1.0 / (np.exp(w / w_th) - 1.0)
--
--    else:
--        if (w_th > 0) and np.exp(w / w_th) != 1.0:
--            return 1.0 / (np.exp(w / w_th) - 1.0)
--        else:
--            return 0.0
--
--
--def _factorial_prod(N, arr):
--    arr[:int(N)] += 1
--
--
--def _factorial_div(N, arr):
--    arr[:int(N)] -= 1
--
--
--def _to_long(arr):
--    prod = 1
--    for i, v in enumerate(arr):
--        prod *= (i+1)**int(v)
--    return prod
--
--
--def clebsch(j1, j2, j3, m1, m2, m3):
--    """Calculates the Clebsch-Gordon coefficient
--    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
--
--    Parameters
--    ----------
--    j1 : float
--        Total angular momentum 1.
--
--    j2 : float
--        Total angular momentum 2.
--
--    j3 : float
--        Total angular momentum 3.
--
--    m1 : float
--        z-component of angular momentum 1.
--
--    m2 : float
--        z-component of angular momentum 2.
--
--    m3 : float
--        z-component of angular momentum 3.
--
--    Returns
--    -------
--    cg_coeff : float
--        Requested Clebsch-Gordan coefficient.
--
--    """
--    if m3 != m1 + m2:
--        return 0
--    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
--    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
--
--    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
--    _factorial_prod(j3 + j1 - j2, c_factor)
--    _factorial_prod(j3 - j1 + j2, c_factor)
--    _factorial_prod(j1 + j2 - j3, c_factor)
--    _factorial_prod(j3 + m3, c_factor)
--    _factorial_prod(j3 - m3, c_factor)
--    _factorial_div(j1 + j2 + j3 + 1, c_factor)
--    _factorial_div(j1 - m1, c_factor)
--    _factorial_div(j1 + m1, c_factor)
--    _factorial_div(j2 - m2, c_factor)
--    _factorial_div(j2 + m2, c_factor)
--    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
--
--    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
--    sign = (-1) ** (vmin + j2 + m2)
--    for i,v in enumerate(range(vmin, vmax + 1)):
--        factor = s_factors[i,:]
--        _factorial_prod(j2 + j3 + m1 - v, factor)
--        _factorial_prod(j1 - m1 + v, factor)
--        _factorial_div(j3 - j1 + j2 - v, factor)
--        _factorial_div(j3 + m3 - v, factor)
--        _factorial_div(v + j1 - j2 - m3, factor)
--        _factorial_div(v, factor)
--    common_denominator = -np.min(s_factors, axis=0)
--    numerators = s_factors + common_denominator
--    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
--        sign / _to_long(common_denominator)
--    return C * S
--
--
--# -----------------------------------------------------------------------------
--# Functions for unit conversions
--#
--_e = 1.602176565e-19  # C
--_kB = 1.3806488e-23   # J/K
--_h = 6.62606957e-34   # Js
--
--_unit_factor_tbl = {
--    #   "unit": "factor that convert argument from unit 'unit' to Joule"
--    "J": 1.0,
--    "eV": _e,
--    "meV": 1.0e-3 * _e,
--    "GHz": 1.0e9 * _h,
--    "mK": 1.0e-3 * _kB,
--}
--
--
--def convert_unit(value, orig="meV", to="GHz"):
--    """
--    Convert an energy from unit `orig` to unit `to`.
--
--    Parameters
--    ----------
--    value : float / array
--        The energy in the old unit.
--
--    orig : string
--        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
--
--    to : string
--        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
--
--    Returns
--    -------
--    value_new_unit : float / array
--        The energy in the new unit.
--    """
--    if orig not in _unit_factor_tbl:
--        raise TypeError("Unsupported unit %s" % orig)
--
--    if to not in _unit_factor_tbl:
--        raise TypeError("Unsupported unit %s" % to)
--
--    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
--
--
--def convert_GHz_to_meV(w):
--    """
--    Convert an energy from unit GHz to unit meV.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
--    w_meV = w * 4.1357e-3
--    return w_meV
--
--
--def convert_meV_to_GHz(w):
--    """
--    Convert an energy from unit meV to unit GHz.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # 1 meV = 1.0/4.1357e-3 GHz
--    w_GHz = w / 4.1357e-3
--    return w_GHz
--
--
--def convert_J_to_meV(w):
--    """
--    Convert an energy from unit J to unit meV.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # 1 eV = 1.602e-19 J
--    w_meV = 1000.0 * w / _e
--    return w_meV
--
--
--def convert_meV_to_J(w):
--    """
--    Convert an energy from unit meV to unit J.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # 1 eV = 1.602e-19 J
--    w_J = 0.001 * w * _e
--    return w_J
--
--
--def convert_meV_to_mK(w):
--    """
--    Convert an energy from unit meV to unit mK.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # 1 mK = 0.0000861740 meV
--    w_mK = w / 0.0000861740
--    return w_mK
--
--
--def convert_mK_to_meV(w):
--    """
--    Convert an energy from unit mK to unit meV.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # 1 mK = 0.0000861740 meV
--    w_meV = w * 0.0000861740
--    return w_meV
--
--
--def convert_GHz_to_mK(w):
--    """
--    Convert an energy from unit GHz to unit mK.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--    """
--    # h v [Hz] = kB T [K]
--    # h 1e9 v [GHz] = kB 1e-3 T [mK]
--    # T [mK] = 1e12 * (h/kB) * v [GHz]
--    w_mK = w * 1.0e12 * (_h / _kB)
--    return w_mK
--
--
--def convert_mK_to_GHz(w):
--    """
--    Convert an energy from unit mK to unit GHz.
--
--    Parameters
--    ----------
--    w : float / array
--        The energy in the old unit.
--
--    Returns
--    -------
--    w_new_unit : float / array
--        The energy in the new unit.
--
--    """
--    w_GHz = w * 1.0e-12 * (_kB / _h)
--    return w_GHz
--
--
--def _version2int(version_string):
--    str_list = version_string.split(
--        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
--        "post")[0].split('.')
--    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
--                for n, d in enumerate(str_list[:3])])
-+"""
-+This module contains utility functions that are commonly needed in other
-+qutip modules.
-+"""
-+
-+__all__ = ['n_thermal', 'clebsch', 'convert_unit']
-+
-+import numpy as np
-+
-+def n_thermal(w, w_th):
-+    """
-+    Return the number of photons in thermal equilibrium for an harmonic
-+    oscillator mode with frequency 'w', at the temperature described by
-+    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
-+
-+    Parameters
-+    ----------
-+
-+    w : *float* or *array*
-+        Frequency of the oscillator.
-+
-+    w_th : *float*
-+        The temperature in units of frequency (or the same units as `w`).
-+
-+
-+    Returns
-+    -------
-+
-+    n_avg : *float* or *array*
-+
-+        Return the number of average photons in thermal equilibrium for a
-+        an oscillator with the given frequency and temperature.
-+
-+
-+    """
-+
-+    if isinstance(w, np.ndarray):
-+        return 1.0 / (np.exp(w / w_th) - 1.0)
-+
-+    else:
-+        if (w_th > 0) and np.exp(w / w_th) != 1.0:
-+            return 1.0 / (np.exp(w / w_th) - 1.0)
-+        else:
-+            return 0.0
-+
-+
-+def _factorial_prod(N, arr):
-+    arr[:int(N)] += 1
-+
-+
-+def _factorial_div(N, arr):
-+    arr[:int(N)] -= 1
-+
-+
-+def _to_long(arr):
-+    prod = 1
-+    for i, v in enumerate(arr):
-+        prod *= (i+1)**int(v)
-+    return prod
-+
-+
-+def clebsch(j1, j2, j3, m1, m2, m3):
-+    """Calculates the Clebsch-Gordon coefficient
-+    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
-+
-+    Parameters
-+    ----------
-+    j1 : float
-+        Total angular momentum 1.
-+
-+    j2 : float
-+        Total angular momentum 2.
-+
-+    j3 : float
-+        Total angular momentum 3.
-+
-+    m1 : float
-+        z-component of angular momentum 1.
-+
-+    m2 : float
-+        z-component of angular momentum 2.
-+
-+    m3 : float
-+        z-component of angular momentum 3.
-+
-+    Returns
-+    -------
-+    cg_coeff : float
-+        Requested Clebsch-Gordan coefficient.
-+
-+    """
-+    if m3 != m1 + m2:
-+        return 0
-+    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
-+    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
-+
-+    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
-+    _factorial_prod(j3 + j1 - j2, c_factor)
-+    _factorial_prod(j3 - j1 + j2, c_factor)
-+    _factorial_prod(j1 + j2 - j3, c_factor)
-+    _factorial_prod(j3 + m3, c_factor)
-+    _factorial_prod(j3 - m3, c_factor)
-+    _factorial_div(j1 + j2 + j3 + 1, c_factor)
-+    _factorial_div(j1 - m1, c_factor)
-+    _factorial_div(j1 + m1, c_factor)
-+    _factorial_div(j2 - m2, c_factor)
-+    _factorial_div(j2 + m2, c_factor)
-+    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
-+
-+    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
-+    sign = (-1) ** (vmin + j2 + m2)
-+    for i,v in enumerate(range(vmin, vmax + 1)):
-+        factor = s_factors[i,:]
-+        _factorial_prod(j2 + j3 + m1 - v, factor)
-+        _factorial_prod(j1 - m1 + v, factor)
-+        _factorial_div(j3 - j1 + j2 - v, factor)
-+        _factorial_div(j3 + m3 - v, factor)
-+        _factorial_div(v + j1 - j2 - m3, factor)
-+        _factorial_div(v, factor)
-+    common_denominator = -np.min(s_factors, axis=0)
-+    numerators = s_factors + common_denominator
-+    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
-+        sign / _to_long(common_denominator)
-+    return C * S
-+
-+
-+# -----------------------------------------------------------------------------
-+# Functions for unit conversions
-+#
-+_e = 1.602176565e-19  # C
-+_kB = 1.3806488e-23   # J/K
-+_h = 6.62606957e-34   # Js
-+
-+_unit_factor_tbl = {
-+    #   "unit": "factor that convert argument from unit 'unit' to Joule"
-+    "J": 1.0,
-+    "eV": _e,
-+    "meV": 1.0e-3 * _e,
-+    "GHz": 1.0e9 * _h,
-+    "mK": 1.0e-3 * _kB,
-+}
-+
-+
-+def convert_unit(value, orig="meV", to="GHz"):
-+    """
-+    Convert an energy from unit `orig` to unit `to`.
-+
-+    Parameters
-+    ----------
-+    value : float / array
-+        The energy in the old unit.
-+
-+    orig : string
-+        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
-+
-+    to : string
-+        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
-+
-+    Returns
-+    -------
-+    value_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    if orig not in _unit_factor_tbl:
-+        raise TypeError("Unsupported unit %s" % orig)
-+
-+    if to not in _unit_factor_tbl:
-+        raise TypeError("Unsupported unit %s" % to)
-+
-+    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
-+
-+
-+def convert_GHz_to_meV(w):
-+    """
-+    Convert an energy from unit GHz to unit meV.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
-+    w_meV = w * 4.1357e-3
-+    return w_meV
-+
-+
-+def convert_meV_to_GHz(w):
-+    """
-+    Convert an energy from unit meV to unit GHz.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # 1 meV = 1.0/4.1357e-3 GHz
-+    w_GHz = w / 4.1357e-3
-+    return w_GHz
-+
-+
-+def convert_J_to_meV(w):
-+    """
-+    Convert an energy from unit J to unit meV.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # 1 eV = 1.602e-19 J
-+    w_meV = 1000.0 * w / _e
-+    return w_meV
-+
-+
-+def convert_meV_to_J(w):
-+    """
-+    Convert an energy from unit meV to unit J.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # 1 eV = 1.602e-19 J
-+    w_J = 0.001 * w * _e
-+    return w_J
-+
-+
-+def convert_meV_to_mK(w):
-+    """
-+    Convert an energy from unit meV to unit mK.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # 1 mK = 0.0000861740 meV
-+    w_mK = w / 0.0000861740
-+    return w_mK
-+
-+
-+def convert_mK_to_meV(w):
-+    """
-+    Convert an energy from unit mK to unit meV.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # 1 mK = 0.0000861740 meV
-+    w_meV = w * 0.0000861740
-+    return w_meV
-+
-+
-+def convert_GHz_to_mK(w):
-+    """
-+    Convert an energy from unit GHz to unit mK.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+    """
-+    # h v [Hz] = kB T [K]
-+    # h 1e9 v [GHz] = kB 1e-3 T [mK]
-+    # T [mK] = 1e12 * (h/kB) * v [GHz]
-+    w_mK = w * 1.0e12 * (_h / _kB)
-+    return w_mK
-+
-+
-+def convert_mK_to_GHz(w):
-+    """
-+    Convert an energy from unit mK to unit GHz.
-+
-+    Parameters
-+    ----------
-+    w : float / array
-+        The energy in the old unit.
-+
-+    Returns
-+    -------
-+    w_new_unit : float / array
-+        The energy in the new unit.
-+
-+    """
-+    w_GHz = w * 1.0e-12 * (_kB / _h)
-+    return w_GHz
-+
-+
-+def _version2int(version_string):
-+    str_list = version_string.split(
-+        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
-+        "post")[0].split('.')
-+    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
-+                for n, d in enumerate(str_list[:3])])
-diff --git a/qutip/visualization.py b/qutip/visualization.py
-index 27fe62c6..3262da18 100644
---- a/qutip/visualization.py
-+++ b/qutip/visualization.py
-@@ -1,1819 +1,1819 @@
--"""
--Functions for visualizing results of quantum dynamics simulations,
--visualizations of quantum states and processes.
--"""
--
--__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
--           'plot_energy_levels', 'fock_distribution',
--           'plot_fock_distribution', 'wigner_fock_distribution',
--           'plot_wigner_fock_distribution', 'plot_wigner',
--           'plot_expectation_values', 'plot_spin_distribution_2d',
--           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
--           'complex_array_to_rgb', 'matrix_histogram',
--           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
--
--import warnings
--import itertools as it
--import numpy as np
--from numpy import pi, array, sin, cos, angle, log2
--
--from packaging.version import parse as parse_version
--
--from . import (
--    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
--)
--from .core.dimensions import flatten
--from .core.superop_reps import _to_superpauli, isqubitdims
--from .wigner import wigner
--from .matplotlib_utilities import complex_phase_cmap
--
--try:
--    import matplotlib.pyplot as plt
--    import matplotlib as mpl
--    from matplotlib import cm
--    from mpl_toolkits.mplot3d import Axes3D
--
--    # Define a custom _axes3D function based on the matplotlib version.
--    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
--    if parse_version(mpl.__version__) >= parse_version('3.4'):
--        def _axes3D(fig, *args, **kwargs):
--            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
--            return fig.add_axes(ax)
--    else:
--        def _axes3D(*args, **kwargs):
--            return Axes3D(*args, **kwargs)
--except:
--    pass
--
--
--def plot_wigner_sphere(fig, ax, wigner, reflections):
--    """Plots a coloured Bloch sphere.
--
--    Parameters
--    ----------
--    fig : :obj:`matplotlib.figure.Figure`
--        An instance of :obj:`~matplotlib.figure.Figure`.
--    ax : :obj:`matplotlib.axes.Axes`
--        An axes instance in the given figure.
--    wigner : list of float
--        The wigner transformation at `steps` different theta and phi.
--    reflections : bool
--        If the reflections of the sphere should be plotted as well.
--
--    Notes
--    -----
--    Special thanks to Russell P Rundle for writing this function.
--    """
--    ax.set_xlabel("x")
--    ax.set_ylabel("y")
--    ax.set_zlabel("z")
--
--    steps = len(wigner)
--
--    theta = np.linspace(0, np.pi, steps)
--    phi = np.linspace(0, 2 * np.pi, steps)
--    x = np.outer(np.sin(theta), np.cos(phi))
--    y = np.outer(np.sin(theta), np.sin(phi))
--    z = np.outer(np.cos(theta), np.ones(steps))
--    wigner = np.real(wigner)
--    wigner_max = np.real(np.amax(np.abs(wigner)))
--
--    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
--
--    # Plot coloured Bloch sphere:
--    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
--                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
--                    zorder=0.5, antialiased=None)
--
--    if reflections:
--        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
--                                 (2*wigner_max))  # bottom
--        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
--                                 (2*wigner_max))  # side
--        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
--                                 (2*wigner_max))  # back
--
--        # Plot bottom reflection:
--        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
--                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
--                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
--                        ccount=steps/2, linewidth=0, zorder=0.5,
--                        antialiased=False)
--
--        # Plot side reflection:
--        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
--                        z[0:steps, 0:steps], facecolors=wigner_c3,
--                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
--                        ccount=steps/2, linewidth=0, zorder=0.5,
--                        antialiased=False)
--
--        # Plot back reflection:
--        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
--                        z[0:steps, 0:steps], facecolors=wigner_c4,
--                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
--                        ccount=steps/2, linewidth=0, zorder=0.5,
--                        antialiased=False)
--
--    # Create colourbar:
--    m = cm.ScalarMappable(cmap=cm.seismic_r)
--    m.set_array([-wigner_max, wigner_max])
--    plt.colorbar(m, shrink=0.5, aspect=10)
--
--    plt.show()
--
--
--# Adopted from the SciPy Cookbook.
--def _blob(x, y, w, w_max, area, color_fn, ax=None):
--    """
--    Draws a square-shaped blob with the given area (< 1) at
--    the given coordinates.
--    """
--    hs = np.sqrt(area) / 2
--    xcorners = array([x - hs, x + hs, x + hs, x - hs])
--    ycorners = array([y - hs, y - hs, y + hs, y + hs])
--
--    if ax is not None:
--        handle = ax
--    else:
--        handle = plt
--
--    handle.fill(xcorners, ycorners,
--             color=color_fn(w))
--
--
--def _cb_labels(left_dims):
--    """Creates plot labels for matrix elements in the computational basis.
--
--    Parameters
--    ----------
--    left_dims : flat list of ints
--        Dimensions of the left index of a density operator. E. g.
--        [2, 3] for a qubit tensored with a qutrit.
--
--    Returns
--    -------
--    left_labels, right_labels : lists of strings
--        Labels for the left and right indices of a density operator
--        (kets and bras, respectively).
--    """
--    # FIXME: assumes dims, such that we only need left_dims == dims[0].
--    basis_labels = list(map(",".join, it.product(*[
--        map(str, range(dim))
--        for dim in left_dims
--    ])))
--    return [
--        map(fmt.format, basis_labels) for fmt in
--        (
--            r"$\langle{}|$",
--            r"$|{}\rangle$",
--        )
--    ]
--
--
--# Adopted from the SciPy Cookbook.
--def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
--           label_top=True, color_style="scaled"):
--    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
--
--    Parameters
--    ----------
--    rho : qobj
--        Input density matrix or superoperator.
--
--    xlabels : list of strings or False
--        list of x labels
--
--    ylabels : list of strings or False
--        list of y labels
--
--    title : string
--        title of the plot (optional)
--
--    ax : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    cmap : a matplotlib colormap instance
--        Color map to use when plotting.
--
--    label_top : bool
--        If True, x-axis labels will be placed on top, otherwise
--        they will appear below the plot.
--
--    color_style : string
--        Determines how colors are assigned to each square:
--
--        -  If set to ``"scaled"`` (default), each color is chosen by
--           passing the absolute value of the corresponding matrix
--           element into `cmap` with the sign of the real part.
--        -  If set to ``"threshold"``, each square is plotted as
--           the maximum of `cmap` for the positive real part and as
--           the minimum for the negative part of the matrix element;
--           note that this generalizes `"threshold"` to complex numbers.
--        -  If set to ``"phase"``, each color is chosen according to
--           the angle of the corresponding matrix element.
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    Raises
--    ------
--    ValueError
--        Input argument is not a quantum object.
--
--    Examples
--    --------
--    >>> import qutip
--    >>>
--    >>> dm = qutip.rand_dm(4)
--    >>> fig, ax = qutip.hinton(dm)
--    >>> fig.show()
--    >>>
--    >>> qutip.settings.colorblind_safe = True
--    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
--    >>> fig.show()
--    >>> qutip.settings.colorblind_safe = False
--    >>>
--    >>> fig, ax = qutip.hinton(dm, color_style="phase")
--    >>> fig.show()
--    """
--
--    # Apply default colormaps.
--    # TODO: abstract this away into something that makes default
--    #       colormaps.
--    cmap = (
--        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
--        if cmap is None else cmap
--    )
--
--    # Extract plotting data W from the input.
--    if isinstance(rho, Qobj):
--        if rho.isoper:
--            W = rho.full()
--
--            # Create default labels if none are given.
--            if xlabels is None or ylabels is None:
--                labels = _cb_labels(rho.dims[0])
--                xlabels = xlabels if xlabels is not None else list(labels[0])
--                ylabels = ylabels if ylabels is not None else list(labels[1])
--
--        elif rho.isoperket:
--            W = vector_to_operator(rho).full()
--        elif rho.isoperbra:
--            W = vector_to_operator(rho.dag()).full()
--        elif rho.issuper:
--            if not isqubitdims(rho.dims):
--                raise ValueError("Hinton plots of superoperators are "
--                                 "currently only supported for qubits.")
--            # Convert to a superoperator in the Pauli basis,
--            # so that all the elements are real.
--            sqobj = _to_superpauli(rho)
--            nq = int(log2(sqobj.shape[0]) / 2)
--            W = sqobj.full().T
--            # Create default labels, too.
--            if (xlabels is None) or (ylabels is None):
--                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
--                xlabels = xlabels if xlabels is not None else labels
--                ylabels = ylabels if ylabels is not None else labels
--
--        else:
--            raise ValueError(
--                "Input quantum object must be an operator or superoperator."
--            )
--
--    else:
--        W = rho
--
--    if ax is None:
--        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
--    else:
--        fig = None
--
--    if not (xlabels or ylabels):
--        ax.axis('off')
--    if title:
--        ax.set_title(title)
--
--    ax.axis('equal')
--    ax.set_frame_on(False)
--
--    height, width = W.shape
--
--    w_max = 1.25 * max(abs(np.array(W)).flatten())
--    if w_max <= 0.0:
--        w_max = 1.0
--
--    # Set color_fn here.
--    if color_style == "scaled":
--        def color_fn(w):
--            w = np.abs(w) * np.sign(np.real(w))
--            return cmap(int((w + w_max) * 256 / (2 * w_max)))
--    elif color_style == "threshold":
--        def color_fn(w):
--            w = np.real(w)
--            return cmap(255 if w > 0 else 0)
--    elif color_style == "phase":
--        def color_fn(w):
--            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
--    else:
--        raise ValueError(
--            "Unknown color style {} for Hinton diagrams.".format(color_style)
--        )
--
--    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
--            color=cmap(128))
--    for x in range(width):
--        for y in range(height):
--            _x = x + 1
--            _y = y + 1
--            _blob(
--                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
--                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
--
--    # color axis
--    vmax = np.pi if color_style == "phase" else abs(W).max()
--    norm = mpl.colors.Normalize(-vmax, vmax)
--    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
--    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
--
--    xtics = 0.5 + np.arange(width)
--    # x axis
--    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
--    if xlabels:
--        nxlabels = len(xlabels)
--        if nxlabels != len(xtics):
--            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
--        ax.set_xticklabels(xlabels)
--        if label_top:
--            ax.xaxis.tick_top()
--    ax.tick_params(axis='x', labelsize=14)
--
--    # y axis
--    ytics = 0.5 + np.arange(height)
--    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
--    if ylabels:
--        nylabels = len(ylabels)
--        if nylabels != len(ytics):
--            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
--        ax.set_yticklabels(list(reversed(ylabels)))
--    ax.tick_params(axis='y', labelsize=14)
--
--    return fig, ax
--
--
--def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
--    """Plots a matrix of values on a sphere
--
--    Parameters
--    ----------
--    theta : float
--        Angle with respect to z-axis
--
--    phi : float
--        Angle in x-y plane
--
--    values : array
--        Data set to be plotted
--
--    fig : a matplotlib Figure instance
--        The Figure canvas in which the plot will be drawn.
--
--    ax : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    save : bool {False , True}
--        Whether to save the figure or not
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--    if fig is None or ax is None:
--        fig = plt.figure()
--        ax = _axes3D(fig)
--
--    thetam, phim = np.meshgrid(theta, phi)
--    xx = sin(thetam) * cos(phim)
--    yy = sin(thetam) * sin(phim)
--    zz = cos(thetam)
--    r = array(abs(values))
--    ph = angle(values)
--    # normalize color range based on phase angles in list ph
--    nrm = mpl.colors.Normalize(ph.min(), ph.max())
--
--    # plot with facecolors set to cm.jet colormap normalized to nrm
--    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
--                    facecolors=cm.jet(nrm(ph)), linewidth=0)
--    # create new axes on plot for colorbar and shrink it a bit.
--    # pad shifts location of bar with repsect to the main plot
--    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
--
--    # create new colorbar in axes cax with cm jet and normalized to nrm like
--    # our facecolors
--    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
--    # add our colorbar label
--    cb1.set_label('Angle')
--
--    if save:
--        plt.savefig("sphereplot.png")
--
--    return fig, ax
--
--
--def _remove_margins(axis):
--    """
--    removes margins about z = 0 and improves the style
--    by monkey patching
--    """
--    def _get_coord_info_new(renderer):
--        mins, maxs, centers, deltas, tc, highs = \
--            _get_coord_info_old(renderer)
--        mins += deltas / 4
--        maxs -= deltas / 4
--        return mins, maxs, centers, deltas, tc, highs
--
--    _get_coord_info_old = axis._get_coord_info
--    axis._get_coord_info = _get_coord_info_new
--
--
--def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
--    """
--    truncates portion of a colormap and returns the new one
--    """
--    if isinstance(cmap, str):
--        cmap = plt.get_cmap(cmap)
--    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
--        'trunc({n},{a:.2f},{b:.2f})'.format(
--            n=cmap.name, a=minval, b=maxval),
--        cmap(np.linspace(minval, maxval, n)))
--    return new_cmap
--
--
--def _stick_to_planes(stick, azim, ax, M, spacing):
--    """adjusts xlim and ylim in way that bars will
--    Stick to xz and yz planes
--    """
--    if stick is True:
--        azim = azim % 360
--        if 0 <= azim <= 90:
--            ax.set_ylim(1 - .5,)
--            ax.set_xlim(1 - .5,)
--        elif 90 < azim <= 180:
--            ax.set_ylim(1 - .5,)
--            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
--        elif 180 < azim <= 270:
--            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
--            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
--        elif 270 < azim < 360:
--            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
--            ax.set_xlim(1 - .5,)
--
--
--def _update_yaxis(spacing, M, ax, ylabels):
--    """
--    updates the y-axis
--    """
--    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
--    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
--    if ylabels:
--        nylabels = len(ylabels)
--        if nylabels != len(ytics):
--            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
--        ax.set_yticklabels(ylabels)
--    else:
--        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
--        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
--    ax.tick_params(axis='y', labelsize=14)
--    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
--
--
--def _update_xaxis(spacing, M, ax, xlabels):
--    """
--    updates the x-axis
--    """
--    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
--    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
--    if xlabels:
--        nxlabels = len(xlabels)
--        if nxlabels != len(xtics):
--            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
--        ax.set_xticklabels(xlabels)
--    else:
--        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
--        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
--    ax.tick_params(axis='x', labelsize=14)
--    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
--
--
--def _update_zaxis(ax, z_min, z_max, zticks):
--    """
--    updates the z-axis
--    """
--    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
--    if isinstance(zticks, list):
--        ax.set_zticks(zticks)
--    ax.set_zlim3d([min(z_min, 0), z_max])
--
--
--def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
--                     colorbar=True, fig=None, ax=None, options=None):
--    """
--    Draw a histogram for the matrix M, with the given x and y labels and title.
--
--    Parameters
--    ----------
--    M : Matrix of Qobj
--        The matrix to visualize
--
--    xlabels : list of strings
--        list of x labels
--
--    ylabels : list of strings
--        list of y labels
--
--    title : string
--        title of the plot (optional)
--
--    limits : list/array with two float numbers
--        The z-axis limits [min, max] (optional)
--
--    ax : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    colorbar : bool (default: True)
--        show colorbar
--
--    options : dict
--        A dictionary containing extra options for the plot.
--        The names (keys) and values of the options are
--        described below:
--
--        'zticks' : list of numbers
--            A list of z-axis tick locations.
--
--        'cmap' : string (default: 'jet')
--            The name of the color map to use.
--
--        'cmap_min' : float (default: 0.0)
--            The lower bound to truncate the color map at.
--            A value in range 0 - 1. The default, 0, leaves the lower
--            bound of the map unchanged.
--
--        'cmap_max' : float (default: 1.0)
--            The upper bound to truncate the color map at.
--            A value in range 0 - 1. The default, 1, leaves the upper
--            bound of the map unchanged.
--
--        'bars_spacing' : float (default: 0.1)
--            spacing between bars.
--
--        'bars_alpha' : float (default: 1.)
--            transparency of bars, should be in range 0 - 1
--
--        'bars_lw' : float (default: 0.5)
--            linewidth of bars' edges.
--
--        'bars_edgecolor' : color (default: 'k')
--            The colors of the bars' edges.
--            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
--
--        'shade' : bool (default: True)
--            Whether to shade the dark sides of the bars (True) or not (False).
--            The shading is relative to plot's source of light.
--
--        'azim' : float
--            The azimuthal viewing angle.
--
--        'elev' : float
--            The elevation viewing angle.
--
--        'proj_type' : string (default: 'ortho' if ax is not passed)
--            The type of projection ('ortho' or 'persp')
--
--        'stick' : bool (default: False)
--            Changes xlim and ylim in such a way that bars next to
--            XZ and YZ planes will stick to those planes.
--            This option has no effect if ``ax`` is passed as a parameter.
--
--        'cbar_pad' : float (default: 0.04)
--            The fraction of the original axes between the colorbar
--            and the new image axes.
--            (i.e. the padding between the 3D figure and the colorbar).
--
--        'cbar_to_z' : bool (default: False)
--            Whether to set the color of maximum and minimum z-values to the
--            maximum and minimum colors in the colorbar (True) or not (False).
--
--        'figsize' : tuple of two numbers
--            The size of the figure.
--
--    Returns :
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    Raises
--    ------
--    ValueError
--        Input argument is not valid.
--
--    """
--
--    # default options
--    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
--                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
--                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
--                    'shade': False, 'azim': -35, 'elev': 35,
--                    'proj_type': 'ortho', 'stick': False,
--                    'cbar_pad': 0.04, 'cbar_to_z': False}
--
--    # update default_opts from input options
--    if options is None:
--        pass
--    elif isinstance(options, dict):
--        # check if keys in options dict are valid
--        if set(options) - set(default_opts):
--            raise ValueError("invalid key(s) found in options: "
--                             f"{', '.join(set(options) - set(default_opts))}")
--        else:
--            # updating default options
--            default_opts.update(options)
--    else:
--        raise ValueError("options must be a dictionary")
--
--    if isinstance(M, Qobj):
--        # extract matrix data from Qobj
--        M = M.full()
--
--    n = np.size(M)
--    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
--    xpos = xpos.T.flatten() + 0.5
--    ypos = ypos.T.flatten() + 0.5
--    zpos = np.zeros(n)
--    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
--    dz = np.real(M.flatten())
--
--    if isinstance(limits, list) and len(limits) == 2:
--        z_min = limits[0]
--        z_max = limits[1]
--    else:
--        z_min = min(dz)
--        z_max = max(dz)
--        if z_min == z_max:
--            z_min -= 0.1
--            z_max += 0.1
--
--    if default_opts['cbar_to_z']:
--        norm = mpl.colors.Normalize(min(dz), max(dz))
--    else:
--        norm = mpl.colors.Normalize(z_min, z_max)
--    cmap = _truncate_colormap(default_opts['cmap'],
--                              default_opts['cmap_min'],
--                              default_opts['cmap_max'])
--    colors = cmap(norm(dz))
--
--    if ax is None:
--        fig = plt.figure(figsize=default_opts['figsize'])
--        ax = _axes3D(fig,
--                     azim=default_opts['azim'] % 360,
--                     elev=default_opts['elev'] % 360)
--        ax.set_proj_type(default_opts['proj_type'])
--
--    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
--             edgecolors=default_opts['bars_edgecolor'],
--             linewidths=default_opts['bars_lw'],
--             alpha=default_opts['bars_alpha'],
--             shade=default_opts['shade'])
--    # remove vertical lines on xz and yz plane
--    ax.yaxis._axinfo["grid"]['linewidth'] = 0
--    ax.xaxis._axinfo["grid"]['linewidth'] = 0
--
--    if title:
--        ax.set_title(title)
--
--    # x axis
--    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
--
--    # y axis
--    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
--
--    # z axis
--    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
--
--    # stick to xz and yz plane
--    _stick_to_planes(default_opts['stick'],
--                     default_opts['azim'], ax, M,
--                     default_opts['bars_spacing'])
--
--    # color axis
--    if colorbar:
--        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
--                                         pad=default_opts['cbar_pad'])
--        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
--
--    # removing margins
--    _remove_margins(ax.xaxis)
--    _remove_margins(ax.yaxis)
--    _remove_margins(ax.zaxis)
--
--    return fig, ax
--
--
--def matrix_histogram_complex(M, xlabels=None, ylabels=None,
--                             title=None, limits=None, phase_limits=None,
--                             colorbar=True, fig=None, ax=None,
--                             threshold=None):
--    """
--    Draw a histogram for the amplitudes of matrix M, using the argument
--    of each element for coloring the bars, with the given x and y labels
--    and title.
--
--    Parameters
--    ----------
--    M : Matrix of Qobj
--        The matrix to visualize
--
--    xlabels : list of strings
--        list of x labels
--
--    ylabels : list of strings
--        list of y labels
--
--    title : string
--        title of the plot (optional)
--
--    limits : list/array with two float numbers
--        The z-axis limits [min, max] (optional)
--
--    phase_limits : list/array with two float numbers
--        The phase-axis (colorbar) limits [min, max] (optional)
--
--    ax : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    threshold: float (None)
--        Threshold for when bars of smaller height should be transparent. If
--        not set, all bars are colored according to the color map.
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    Raises
--    ------
--    ValueError
--        Input argument is not valid.
--
--    """
--
--    if isinstance(M, Qobj):
--        # extract matrix data from Qobj
--        M = M.full()
--
--    n = np.size(M)
--    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
--    xpos = xpos.T.flatten() - 0.5
--    ypos = ypos.T.flatten() - 0.5
--    zpos = np.zeros(n)
--    dx = dy = 0.8 * np.ones(n)
--    Mvec = M.flatten()
--    dz = abs(Mvec)
--
--    # make small numbers real, to avoid random colors
--    idx, = np.where(abs(Mvec) < 0.001)
--    Mvec[idx] = abs(Mvec[idx])
--
--    if phase_limits:  # check that limits is a list type
--        phase_min = phase_limits[0]
--        phase_max = phase_limits[1]
--    else:
--        phase_min = -pi
--        phase_max = pi
--
--    norm = mpl.colors.Normalize(phase_min, phase_max)
--    cmap = complex_phase_cmap()
--
--    colors = cmap(norm(angle(Mvec)))
--    if threshold is not None:
--        colors[:, 3] = 1 * (dz > threshold)
--
--    if ax is None:
--        fig = plt.figure()
--        ax = _axes3D(fig, azim=-35, elev=35)
--
--    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
--
--    if title:
--        ax.set_title(title)
--
--    # x axis
--    xtics = -0.5 + np.arange(M.shape[0])
--    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
--    if xlabels:
--        nxlabels = len(xlabels)
--        if nxlabels != len(xtics):
--            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
--        ax.set_xticklabels(xlabels)
--    ax.tick_params(axis='x', labelsize=12)
--
--    # y axis
--    ytics = -0.5 + np.arange(M.shape[1])
--    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
--    if ylabels:
--        nylabels = len(ylabels)
--        if nylabels != len(ytics):
--            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
--        ax.set_yticklabels(ylabels)
--    ax.tick_params(axis='y', labelsize=12)
--
--    # z axis
--    if limits and isinstance(limits, list):
--        ax.set_zlim3d(limits)
--    else:
--        ax.set_zlim3d([0, 1])  # use min/max
--    # ax.set_zlabel('abs')
--
--    # color axis
--    if colorbar:
--        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
--        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
--        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
--        cb.set_ticklabels(
--            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
--        cb.set_label('arg')
--
--    return fig, ax
--
--
--def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
--                       figsize=(8, 12), fig=None, ax=None):
--    """
--    Plot the energy level diagrams for a list of Hamiltonians. Include
--    up to N energy levels. For each element in H_list, the energy
--    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
--    where n is the index of an element in H_list.
--
--    Parameters
--    ----------
--
--        H_list : List of Qobj
--            A list of Hamiltonians.
--
--        labels : List of string
--            A list of labels for each Hamiltonian
--
--        show_ylabels : Bool (default False)
--            Show y labels to the left of energy levels of the initial
--            Hamiltonian.
--
--        N : int
--            The number of energy levels to plot
--
--        figsize : tuple (int,int)
--            The size of the figure (width, height).
--
--        fig : a matplotlib Figure instance
--            The Figure canvas in which the plot will be drawn.
--
--        ax : a matplotlib axes instance
--            The axes context in which the plot will be drawn.
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    Raises
--    ------
--
--        ValueError
--            Input argument is not valid.
--
--    """
--
--    if not isinstance(H_list, list):
--        raise ValueError("H_list must be a list of Qobj instances")
--
--    if not fig and not ax:
--        fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--    H = H_list[0]
--    N = H.shape[0] if N == 0 else min(H.shape[0], N)
--
--    xticks = []
--    yticks = []
--
--    x = 0
--    evals0 = H.eigenenergies(eigvals=N)
--    for e_idx, e in enumerate(evals0[:N]):
--        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
--        yticks.append(e)
--    xticks.append(x + 1)
--    x += 2
--
--    for H1 in H_list[1:]:
--
--        H = H + H1
--        evals1 = H.eigenenergies()
--
--        for e_idx, e in enumerate(evals1[:N]):
--            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
--        x += 1
--
--        for e_idx, e in enumerate(evals1[:N]):
--            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
--        xticks.append(x + 1)
--        x += 2
--
--        evals0 = evals1
--
--    ax.set_frame_on(False)
--
--    if show_ylabels:
--        yticks = np.unique(np.around(yticks, 1))
--        ax.set_yticks(yticks)
--    else:
--        ax.axes.get_yaxis().set_visible(False)
--
--    if labels:
--        ax.get_xaxis().tick_bottom()
--        ax.set_xticks(xticks)
--        ax.set_xticklabels(labels, fontsize=16)
--    else:
--        ax.axes.get_xaxis().set_visible(False)
--
--    return fig, ax
--
--
--def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
--                         figsize=(8, 12), fig=None, ax=None):
--    warnings.warn("Deprecated: Use plot_energy_levels")
--    return plot_energy_levels(H_list, N=N, labels=labels,
--                              show_ylabels=show_ylabels,
--                              figsize=figsize, fig=fig, ax=ax)
--
--
--def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
--                           figsize=(8, 6), title=None, unit_y_range=True):
--    """
--    Plot the Fock distribution for a density matrix (or ket) that describes
--    an oscillator mode.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        The density matrix (or ket) of the state to visualize.
--
--    fig : a matplotlib Figure instance
--        The Figure canvas in which the plot will be drawn.
--
--    ax : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    title : string
--        An optional title for the figure.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--
--    if not fig and not ax:
--        fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--    if isket(rho):
--        rho = ket2dm(rho)
--
--    N = rho.shape[0]
--
--    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
--           color="green", alpha=0.6, width=0.8)
--    if unit_y_range:
--        ax.set_ylim(0, 1)
--
--    ax.set_xlim(-.5 + offset, N + offset)
--    ax.set_xlabel('Fock number', fontsize=12)
--    ax.set_ylabel('Occupation probability', fontsize=12)
--
--    if title:
--        ax.set_title(title)
--
--    return fig, ax
--
--
--def fock_distribution(rho, offset=0, fig=None, ax=None,
--                      figsize=(8, 6), title=None, unit_y_range=True):
--    warnings.warn("Deprecated: Use plot_fock_distribution")
--    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
--                                  figsize=figsize, title=title,
--                                  unit_y_range=unit_y_range)
--
--
--def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
--                cmap=None, alpha_max=7.5, colorbar=False,
--                method='clenshaw', projection='2d'):
--    """
--    Plot the the Wigner function for a density matrix (or ket) that describes
--    an oscillator mode.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        The density matrix (or ket) of the state to visualize.
--
--    fig : a matplotlib Figure instance
--        The Figure canvas in which the plot will be drawn.
--
--    ax : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    cmap : a matplotlib cmap instance
--        The colormap.
--
--    alpha_max : float
--        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
--
--    colorbar : bool
--        Whether (True) or not (False) a colorbar should be attached to the
--        Wigner function graph.
--
--    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
--        The method used for calculating the wigner function. See the
--        documentation for qutip.wigner for details.
--
--    projection: string {'2d', '3d'}
--        Specify whether the Wigner function is to be plotted as a
--        contour graph ('2d') or surface plot ('3d').
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--
--    if not fig and not ax:
--        if projection == '2d':
--            fig, ax = plt.subplots(1, 1, figsize=figsize)
--        elif projection == '3d':
--            fig = plt.figure(figsize=figsize)
--            ax = fig.add_subplot(1, 1, 1, projection='3d')
--        else:
--            raise ValueError('Unexpected value of projection keyword argument')
--
--    if isket(rho):
--        rho = ket2dm(rho)
--
--    xvec = np.linspace(-alpha_max, alpha_max, 200)
--    W0 = wigner(rho, xvec, xvec, method=method)
--
--    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
--
--    wlim = abs(W).max()
--
--    if cmap is None:
--        cmap = cm.get_cmap('RdBu')
--
--    if projection == '2d':
--        cf = ax.contourf(xvec, yvec, W, 100,
--                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
--    elif projection == '3d':
--        X, Y = np.meshgrid(xvec, xvec)
--        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
--                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
--    else:
--        raise ValueError('Unexpected value of projection keyword argument.')
--
--    if xvec is not yvec:
--        ax.set_ylim(xvec.min(), xvec.max())
--
--    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
--    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
--
--    if colorbar:
--        fig.colorbar(cf, ax=ax)
--
--    ax.set_title("Wigner function", fontsize=12)
--
--    return fig, ax
--
--
--def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
--                                  cmap=None, alpha_max=7.5, colorbar=False,
--                                  method='iterative', projection='2d'):
--    """
--    Plot the Fock distribution and the Wigner function for a density matrix
--    (or ket) that describes an oscillator mode.
--
--    Parameters
--    ----------
--    rho : :class:`qutip.Qobj`
--        The density matrix (or ket) of the state to visualize.
--
--    fig : a matplotlib Figure instance
--        The Figure canvas in which the plot will be drawn.
--
--    axes : a list of two matplotlib axes instances
--        The axes context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    cmap : a matplotlib cmap instance
--        The colormap.
--
--    alpha_max : float
--        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
--
--    colorbar : bool
--        Whether (True) or not (False) a colorbar should be attached to the
--        Wigner function graph.
--
--    method : string {'iterative', 'laguerre', 'fft'}
--        The method used for calculating the wigner function. See the
--        documentation for qutip.wigner for details.
--
--    projection: string {'2d', '3d'}
--        Specify whether the Wigner function is to be plotted as a
--        contour graph ('2d') or surface plot ('3d').
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--
--    if not fig and not axes:
--        if projection == '2d':
--            fig, axes = plt.subplots(1, 2, figsize=figsize)
--        elif projection == '3d':
--            fig = plt.figure(figsize=figsize)
--            axes = [fig.add_subplot(1, 2, 1),
--                    fig.add_subplot(1, 2, 2, projection='3d')]
--        else:
--            raise ValueError('Unexpected value of projection keyword argument')
--
--    if isket(rho):
--        rho = ket2dm(rho)
--
--    plot_fock_distribution(rho, fig=fig, ax=axes[0])
--    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
--                alpha_max=alpha_max, colorbar=colorbar, method=method,
--                projection=projection)
--
--    return fig, axes
--
--
--def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
--                             cmap=None, alpha_max=7.5, colorbar=False,
--                             method='iterative'):
--    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
--    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
--                                         figsize=figsize, cmap=cmap,
--                                         alpha_max=alpha_max,
--                                         colorbar=colorbar,
--                                         method=method)
--
--
--def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
--                            fig=None, axes=None, figsize=(8, 4)):
--    """
--    Visualize the results (expectation values) for an evolution solver.
--    `results` is assumed to be an instance of Result, or a list of Result
--    instances.
--
--    Parameters
--    ----------
--    results : (list of) :class:`qutip.solver.Result`
--        List of results objects returned by any of the QuTiP evolution solvers.
--
--    ylabels : list of strings
--        The y-axis labels. List should be of the same length as `results`.
--
--    title : string
--        The title of the figure.
--
--    show_legend : bool
--        Whether or not to show the legend.
--
--    fig : a matplotlib Figure instance
--        The Figure canvas in which the plot will be drawn.
--
--    axes : a matplotlib axes instance
--        The axes context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--    if not isinstance(results, list):
--        results = [results]
--
--    n_e_ops = max([len(result.expect) for result in results])
--
--    if not fig or not axes:
--        if not figsize:
--            figsize = (12, 3 * n_e_ops)
--        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
--                                 figsize=figsize, squeeze=False)
--
--    for r_idx, result in enumerate(results):
--        for e_idx, e in enumerate(result.expect):
--            axes[e_idx, 0].plot(result.times, e,
--                                label="%s [%d]" % (result.solver, e_idx))
--
--    if title:
--        fig.suptitle(title)
--
--    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
--    for n in range(n_e_ops):
--        if show_legend:
--            axes[n, 0].legend()
--        if ylabels:
--            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
--
--    return fig, axes
--
--
--def plot_spin_distribution_2d(P, THETA, PHI,
--                              fig=None, ax=None, figsize=(8, 8)):
--    """
--    Plot a spin distribution function (given as meshgrid data) with a 2D
--    projection where the surface of the unit sphere is mapped on the unit disk.
--
--    Parameters
--    ----------
--    P : matrix
--        Distribution values as a meshgrid matrix.
--
--    THETA : matrix
--        Meshgrid matrix for the theta coordinate.
--
--    PHI : matrix
--        Meshgrid matrix for the phi coordinate.
--
--    fig : a matplotlib figure instance
--        The figure canvas on which the plot will be drawn.
--
--    ax : a matplotlib axis instance
--        The axis context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--    """
--
--    if not fig or not ax:
--        if not figsize:
--            figsize = (8, 8)
--        fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--    Y = (THETA - pi / 2) / (pi / 2)
--    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
--
--    if P.min() < -1e12:
--        cmap = cm.RdBu
--    else:
--        cmap = cm.RdYlBu
--
--    ax.pcolor(X, Y, P.real, cmap=cmap)
--    ax.set_xlabel(r'$\varphi$', fontsize=18)
--    ax.set_ylabel(r'$\theta$', fontsize=18)
--
--    ax.set_xticks([-1, 0, 1])
--    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
--    ax.set_yticks([-1, 0, 1])
--    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
--
--    return fig, ax
--
--
--def plot_spin_distribution_3d(P, THETA, PHI,
--                              fig=None, ax=None, figsize=(8, 6)):
--    """Plots a matrix of values on a sphere
--
--    Parameters
--    ----------
--    P : matrix
--        Distribution values as a meshgrid matrix.
--
--    THETA : matrix
--        Meshgrid matrix for the theta coordinate.
--
--    PHI : matrix
--        Meshgrid matrix for the phi coordinate.
--
--    fig : a matplotlib figure instance
--        The figure canvas on which the plot will be drawn.
--
--    ax : a matplotlib axis instance
--        The axis context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    """
--
--    if fig is None or ax is None:
--        fig = plt.figure(figsize=figsize)
--        ax = _axes3D(fig, azim=-35, elev=35)
--
--    xx = sin(THETA) * cos(PHI)
--    yy = sin(THETA) * sin(PHI)
--    zz = cos(THETA)
--
--    if P.min() < -1e12:
--        cmap = cm.RdBu
--        norm = mpl.colors.Normalize(-P.max(), P.max())
--    else:
--        cmap = cm.RdYlBu
--        norm = mpl.colors.Normalize(P.min(), P.max())
--
--    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
--                    facecolors=cmap(norm(P)), linewidth=0)
--
--    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
--    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
--    cb1.set_label('magnitude')
--
--    return fig, ax
--
--
--#
--# Qubism and other qubistic visualizations
--#
--def complex_array_to_rgb(X, theme='light', rmax=None):
--    """
--    Makes an array of complex number and converts it to an array of [r, g, b],
--    where phase gives hue and saturation/value are given by the absolute value.
--    Especially for use with imshow for complex plots.
--
--    For more info on coloring, see:
--        Emilia Petrisor,
--        Visualizing complex-valued functions with Matplotlib and Mayavi
--        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
--
--    Parameters
--    ----------
--    X : array
--        Array (of any dimension) of complex numbers.
--
--    theme : 'light' (default) or 'dark'
--        Set coloring theme for mapping complex values into colors.
--
--    rmax : float
--        Maximal abs value for color normalization.
--        If None (default), uses np.abs(X).max().
--
--    Returns
--    -------
--    Y : array
--        Array of colors (of shape X.shape + (3,)).
--
--    """
--
--    absmax = rmax or np.abs(X).max()
--    if absmax == 0.:
--        absmax = 1.
--    Y = np.zeros(X.shape + (3,), dtype='float')
--    Y[..., 0] = np.angle(X) / (2 * pi) % 1
--    if theme == 'light':
--        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
--        Y[..., 2] = 1
--    elif theme == 'dark':
--        Y[..., 1] = 1
--        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
--    Y = mpl.colors.hsv_to_rgb(Y)
--    return Y
--
--
--def _index_to_sequence(i, dim_list):
--    """
--    For a matrix entry with index i it returns state it corresponds to.
--    In particular, for dim_list=[2]*n it returns i written as a binary number.
--
--    Parameters
--    ----------
--    i : int
--        Index in a matrix.
--
--    dim_list : list of int
--        List of dimensions of consecutive particles.
--
--    Returns
--    -------
--    seq : list
--        List of coordinates for each particle.
--
--    """
--    res = []
--    j = i
--    for d in reversed(dim_list):
--        j, s = divmod(j, d)
--        res.append(s)
--    return list(reversed(res))
--
--
--def _sequence_to_index(seq, dim_list):
--    """
--    Inverse of _index_to_sequence.
--
--    Parameters
--    ----------
--    seq : list of ints
--        List of coordinates for each particle.
--
--    dim_list : list of int
--        List of dimensions of consecutive particles.
--
--    Returns
--    -------
--    i : list
--        Index in a matrix.
--
--    """
--    i = 0
--    for s, d in zip(seq, dim_list):
--        i *= d
--        i += s
--
--    return i
--
--
--def _to_qubism_index_pair(i, dim_list, how='pairs'):
--    """
--    For a matrix entry with index i
--    it returns x, y coordinates in qubism mapping.
--
--    Parameters
--    ----------
--    i : int
--        Index in a matrix.
--
--    dim_list : list of int
--        List of dimensions of consecutive particles.
--
--    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
--        Type of qubistic plot.
--
--    Returns
--    -------
--    x, y : tuple of ints
--        List of coordinates for each particle.
--
--    """
--    seq = _index_to_sequence(i, dim_list)
--
--    if how == 'pairs':
--        y = _sequence_to_index(seq[::2], dim_list[::2])
--        x = _sequence_to_index(seq[1::2], dim_list[1::2])
--    elif how == 'pairs_skewed':
--        dim_list2 = dim_list[::2]
--        y = _sequence_to_index(seq[::2], dim_list2)
--        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
--        x = _sequence_to_index(seq2, dim_list2)
--    elif how == 'before_after':
--        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
--        n = len(dim_list)
--        y = _sequence_to_index(reversed(seq[:(n // 2)]),
--                               reversed(dim_list[:(n // 2)]))
--        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
--    else:
--        raise Exception("No such 'how'.")
--
--    return x, y
--
--
--def _sequence_to_latex(seq, style='ket'):
--    """
--    For a sequence of particle states generate LaTeX code.
--
--    Parameters
--    ----------
--    seq : list of ints
--        List of coordinates for each particle.
--
--    style : 'ket' (default), 'bra' or 'bare'
--        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
--
--    Returns
--    -------
--    latex : str
--        LaTeX output.
--
--    """
--    if style == 'ket':
--        latex = "$\\left|{0}\\right\\rangle$"
--    elif style == 'bra':
--        latex = "$\\left\\langle{0}\\right|$"
--    elif style == 'bare':
--        latex = "${0}$"
--    else:
--        raise Exception("No such style.")
--    return latex.format("".join(map(str, seq)))
--
--
--def plot_qubism(ket, theme='light', how='pairs',
--                grid_iteration=1, legend_iteration=0,
--                fig=None, ax=None, figsize=(6, 6)):
--    """
--    Qubism plot for pure states of many qudits.  Works best for spin chains,
--    especially with even number of particles of the same dimension.  Allows to
--    see entanglement between first 2k particles and the rest.
--
--    Parameters
--    ----------
--    ket : Qobj
--        Pure state for plotting.
--
--    theme : 'light' (default) or 'dark'
--        Set coloring theme for mapping complex values into colors.
--        See: complex_array_to_rgb.
--
--    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
--        Type of Qubism plotting.  Options:
--
--        - 'pairs' - typical coordinates,
--        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
--        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
--
--    grid_iteration : int (default 1)
--        Helper lines to be drawn on plot.
--        Show tiles for 2*grid_iteration particles vs all others.
--
--    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
--        Show labels for first ``2*legend_iteration`` particles.  Option
--        'grid_iteration' sets the same number of particles as for
--        grid_iteration.  Option 'all' makes label for all particles.  Typically
--        it should be 0, 1, 2 or perhaps 3.
--
--    fig : a matplotlib figure instance
--        The figure canvas on which the plot will be drawn.
--
--    ax : a matplotlib axis instance
--        The axis context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    Notes
--    -----
--    See also [1]_.
--
--    References
--    ----------
--    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
--       and G. Sierra, *Qubism: self-similar visualization of many-body
--       wavefunctions*, `New J. Phys. 14 053028
--       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
--       (2012), open access.
--    """
--
--    if not isket(ket):
--        raise Exception("Qubism works only for pure states, i.e. kets.")
--        # add for dm? (perhaps a separate function, plot_qubism_dm)
--
--    if not fig and not ax:
--        fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--    dim_list = ket.dims[0]
--    n = len(dim_list)
--
--    # for odd number of particles - pixels are rectangular
--    if n % 2 == 1:
--        ket = tensor(ket, Qobj([1] * dim_list[-1]))
--        dim_list = ket.dims[0]
--        n += 1
--
--    ketdata = ket.full()
--
--    if how == 'pairs':
--        dim_list_y = dim_list[::2]
--        dim_list_x = dim_list[1::2]
--    elif how == 'pairs_skewed':
--        dim_list_y = dim_list[::2]
--        dim_list_x = dim_list[1::2]
--        if dim_list_x != dim_list_y:
--            raise Exception("For 'pairs_skewed' pairs " +
--                            "of dimensions need to be the same.")
--    elif how == 'before_after':
--        dim_list_y = list(reversed(dim_list[:(n // 2)]))
--        dim_list_x = dim_list[(n // 2):]
--    else:
--        raise Exception("No such 'how'.")
--
--    size_x = np.prod(dim_list_x)
--    size_y = np.prod(dim_list_y)
--
--    qub = np.zeros([size_x, size_y], dtype=complex)
--    for i in range(ketdata.size):
--        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
--    qub = qub.transpose()
--
--    quadrants_x = np.prod(dim_list_x[:grid_iteration])
--    quadrants_y = np.prod(dim_list_y[:grid_iteration])
--
--    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
--    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
--
--    ax.set_xticks(ticks_x)
--    ax.set_xticklabels([""] * (quadrants_x - 1))
--    ax.set_yticks(ticks_y)
--    ax.set_yticklabels([""] * (quadrants_y - 1))
--    theme2color_of_lines = {'light': '#000000',
--                            'dark': '#FFFFFF'}
--    ax.grid(True, color=theme2color_of_lines[theme])
--    ax.imshow(complex_array_to_rgb(qub, theme=theme),
--              interpolation="none",
--              extent=(0, size_x, 0, size_y))
--
--    if legend_iteration == 'all':
--        label_n = n // 2
--    elif legend_iteration == 'grid_iteration':
--        label_n = grid_iteration
--    else:
--        try:
--            label_n = int(legend_iteration)
--        except:
--            raise Exception("No such option for legend_iteration keyword " +
--                            "argument. Use 'all', 'grid_iteration' or an " +
--                            "integer.")
--
--    if label_n:
--
--        if how == 'before_after':
--            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
--                + dim_list_x[:label_n]
--        else:
--            dim_list_small = []
--            for j in range(label_n):
--                dim_list_small.append(dim_list_y[j])
--                dim_list_small.append(dim_list_x[j])
--
--        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
--        shift_x = 0.5 * scale_x
--        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
--        shift_y = 0.5 * scale_y
--
--        bbox = ax.get_window_extent().transformed(
--            fig.dpi_scale_trans.inverted())
--        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
--        opts = {'fontsize': fontsize,
--                'color': theme2color_of_lines[theme],
--                'horizontalalignment': 'center',
--                'verticalalignment': 'center'}
--        for i in range(np.prod(dim_list_small)):
--            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
--            seq = _index_to_sequence(i, dim_list=dim_list_small)
--            ax.text(scale_x * x + shift_x,
--                    size_y - (scale_y * y + shift_y),
--                    _sequence_to_latex(seq),
--                    **opts)
--    return fig, ax
--
--
--def plot_schmidt(ket, splitting=None,
--                 labels_iteration=(3, 2),
--                 theme='light',
--                 fig=None, ax=None, figsize=(6, 6)):
--    """
--    Plotting scheme related to Schmidt decomposition.
--    Converts a state into a matrix (A_ij -> A_i^j),
--    where rows are first particles and columns - last.
--
--    See also: plot_qubism with how='before_after' for a similar plot.
--
--    Parameters
--    ----------
--    ket : Qobj
--        Pure state for plotting.
--
--    splitting : int
--        Plot for a number of first particles versus the rest.
--        If not given, it is (number of particles + 1) // 2.
--
--    theme : 'light' (default) or 'dark'
--        Set coloring theme for mapping complex values into colors.
--        See: complex_array_to_rgb.
--
--    labels_iteration : int or pair of ints (default (3,2))
--        Number of particles to be shown as tick labels,
--        for first (vertical) and last (horizontal) particles, respectively.
--
--    fig : a matplotlib figure instance
--        The figure canvas on which the plot will be drawn.
--
--    ax : a matplotlib axis instance
--        The axis context in which the plot will be drawn.
--
--    figsize : (width, height)
--        The size of the matplotlib figure (in inches) if it is to be created
--        (that is, if no 'fig' and 'ax' arguments are passed).
--
--    Returns
--    -------
--    fig, ax : tuple
--        A tuple of the matplotlib figure and axes instances used to produce
--        the figure.
--
--    """
--    if not isket(ket):
--        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
--
--    if not fig and not ax:
--        fig, ax = plt.subplots(1, 1, figsize=figsize)
--
--    dim_list = ket.dims[0]
--
--    if splitting is None:
--        splitting = (len(dim_list) + 1) // 2
--
--    if isinstance(labels_iteration, int):
--        labels_iteration = labels_iteration, labels_iteration
--
--    ketdata = ket.full()
--
--    dim_list_y = dim_list[:splitting]
--    dim_list_x = dim_list[splitting:]
--
--    size_x = np.prod(dim_list_x)
--    size_y = np.prod(dim_list_y)
--
--    ketdata = ketdata.reshape((size_y, size_x))
--
--    dim_list_small_x = dim_list_x[:labels_iteration[1]]
--    dim_list_small_y = dim_list_y[:labels_iteration[0]]
--
--    quadrants_x = np.prod(dim_list_small_x)
--    quadrants_y = np.prod(dim_list_small_y)
--
--    ticks_x = [size_x / quadrants_x * (i + 0.5)
--               for i in range(quadrants_x)]
--    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
--               for i in range(quadrants_y)]
--
--    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
--                                                      dim_list=dim_list_x))
--                for i in range(quadrants_x)]
--    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
--                                                      dim_list=dim_list_y))
--                for i in range(quadrants_y)]
--
--    ax.set_xticks(ticks_x)
--    ax.set_xticklabels(labels_x)
--    ax.set_yticks(ticks_y)
--    ax.set_yticklabels(labels_y)
--    ax.set_xlabel("last particles")
--    ax.set_ylabel("first particles")
--
--    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
--              interpolation="none",
--              extent=(0, size_x, 0, size_y))
--
--    return fig, ax
-+"""
-+Functions for visualizing results of quantum dynamics simulations,
-+visualizations of quantum states and processes.
-+"""
-+
-+__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
-+           'plot_energy_levels', 'fock_distribution',
-+           'plot_fock_distribution', 'wigner_fock_distribution',
-+           'plot_wigner_fock_distribution', 'plot_wigner',
-+           'plot_expectation_values', 'plot_spin_distribution_2d',
-+           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
-+           'complex_array_to_rgb', 'matrix_histogram',
-+           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
-+
-+import warnings
-+import itertools as it
-+import numpy as np
-+from numpy import pi, array, sin, cos, angle, log2
-+
-+from packaging.version import parse as parse_version
-+
-+from . import (
-+    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
-+)
-+from .core.dimensions import flatten
-+from .core.superop_reps import _to_superpauli, isqubitdims
-+from .wigner import wigner
-+from .matplotlib_utilities import complex_phase_cmap
-+
-+try:
-+    import matplotlib.pyplot as plt
-+    import matplotlib as mpl
-+    from matplotlib import cm
-+    from mpl_toolkits.mplot3d import Axes3D
-+
-+    # Define a custom _axes3D function based on the matplotlib version.
-+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-+    if parse_version(mpl.__version__) >= parse_version('3.4'):
-+        def _axes3D(fig, *args, **kwargs):
-+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-+            return fig.add_axes(ax)
-+    else:
-+        def _axes3D(*args, **kwargs):
-+            return Axes3D(*args, **kwargs)
-+except:
-+    pass
-+
-+
-+def plot_wigner_sphere(fig, ax, wigner, reflections):
-+    """Plots a coloured Bloch sphere.
-+
-+    Parameters
-+    ----------
-+    fig : :obj:`matplotlib.figure.Figure`
-+        An instance of :obj:`~matplotlib.figure.Figure`.
-+    ax : :obj:`matplotlib.axes.Axes`
-+        An axes instance in the given figure.
-+    wigner : list of float
-+        The wigner transformation at `steps` different theta and phi.
-+    reflections : bool
-+        If the reflections of the sphere should be plotted as well.
-+
-+    Notes
-+    -----
-+    Special thanks to Russell P Rundle for writing this function.
-+    """
-+    ax.set_xlabel("x")
-+    ax.set_ylabel("y")
-+    ax.set_zlabel("z")
-+
-+    steps = len(wigner)
-+
-+    theta = np.linspace(0, np.pi, steps)
-+    phi = np.linspace(0, 2 * np.pi, steps)
-+    x = np.outer(np.sin(theta), np.cos(phi))
-+    y = np.outer(np.sin(theta), np.sin(phi))
-+    z = np.outer(np.cos(theta), np.ones(steps))
-+    wigner = np.real(wigner)
-+    wigner_max = np.real(np.amax(np.abs(wigner)))
-+
-+    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
-+
-+    # Plot coloured Bloch sphere:
-+    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
-+                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
-+                    zorder=0.5, antialiased=None)
-+
-+    if reflections:
-+        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-+                                 (2*wigner_max))  # bottom
-+        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-+                                 (2*wigner_max))  # side
-+        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-+                                 (2*wigner_max))  # back
-+
-+        # Plot bottom reflection:
-+        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
-+                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
-+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-+                        ccount=steps/2, linewidth=0, zorder=0.5,
-+                        antialiased=False)
-+
-+        # Plot side reflection:
-+        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
-+                        z[0:steps, 0:steps], facecolors=wigner_c3,
-+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-+                        ccount=steps/2, linewidth=0, zorder=0.5,
-+                        antialiased=False)
-+
-+        # Plot back reflection:
-+        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
-+                        z[0:steps, 0:steps], facecolors=wigner_c4,
-+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-+                        ccount=steps/2, linewidth=0, zorder=0.5,
-+                        antialiased=False)
-+
-+    # Create colourbar:
-+    m = cm.ScalarMappable(cmap=cm.seismic_r)
-+    m.set_array([-wigner_max, wigner_max])
-+    plt.colorbar(m, shrink=0.5, aspect=10)
-+
-+    plt.show()
-+
-+
-+# Adopted from the SciPy Cookbook.
-+def _blob(x, y, w, w_max, area, color_fn, ax=None):
-+    """
-+    Draws a square-shaped blob with the given area (< 1) at
-+    the given coordinates.
-+    """
-+    hs = np.sqrt(area) / 2
-+    xcorners = array([x - hs, x + hs, x + hs, x - hs])
-+    ycorners = array([y - hs, y - hs, y + hs, y + hs])
-+
-+    if ax is not None:
-+        handle = ax
-+    else:
-+        handle = plt
-+
-+    handle.fill(xcorners, ycorners,
-+             color=color_fn(w))
-+
-+
-+def _cb_labels(left_dims):
-+    """Creates plot labels for matrix elements in the computational basis.
-+
-+    Parameters
-+    ----------
-+    left_dims : flat list of ints
-+        Dimensions of the left index of a density operator. E. g.
-+        [2, 3] for a qubit tensored with a qutrit.
-+
-+    Returns
-+    -------
-+    left_labels, right_labels : lists of strings
-+        Labels for the left and right indices of a density operator
-+        (kets and bras, respectively).
-+    """
-+    # FIXME: assumes dims, such that we only need left_dims == dims[0].
-+    basis_labels = list(map(",".join, it.product(*[
-+        map(str, range(dim))
-+        for dim in left_dims
-+    ])))
-+    return [
-+        map(fmt.format, basis_labels) for fmt in
-+        (
-+            r"$\langle{}|$",
-+            r"$|{}\rangle$",
-+        )
-+    ]
-+
-+
-+# Adopted from the SciPy Cookbook.
-+def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
-+           label_top=True, color_style="scaled"):
-+    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        Input density matrix or superoperator.
-+
-+    xlabels : list of strings or False
-+        list of x labels
-+
-+    ylabels : list of strings or False
-+        list of y labels
-+
-+    title : string
-+        title of the plot (optional)
-+
-+    ax : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    cmap : a matplotlib colormap instance
-+        Color map to use when plotting.
-+
-+    label_top : bool
-+        If True, x-axis labels will be placed on top, otherwise
-+        they will appear below the plot.
-+
-+    color_style : string
-+        Determines how colors are assigned to each square:
-+
-+        -  If set to ``"scaled"`` (default), each color is chosen by
-+           passing the absolute value of the corresponding matrix
-+           element into `cmap` with the sign of the real part.
-+        -  If set to ``"threshold"``, each square is plotted as
-+           the maximum of `cmap` for the positive real part and as
-+           the minimum for the negative part of the matrix element;
-+           note that this generalizes `"threshold"` to complex numbers.
-+        -  If set to ``"phase"``, each color is chosen according to
-+           the angle of the corresponding matrix element.
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    Raises
-+    ------
-+    ValueError
-+        Input argument is not a quantum object.
-+
-+    Examples
-+    --------
-+    >>> import qutip
-+    >>>
-+    >>> dm = qutip.rand_dm(4)
-+    >>> fig, ax = qutip.hinton(dm)
-+    >>> fig.show()
-+    >>>
-+    >>> qutip.settings.colorblind_safe = True
-+    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
-+    >>> fig.show()
-+    >>> qutip.settings.colorblind_safe = False
-+    >>>
-+    >>> fig, ax = qutip.hinton(dm, color_style="phase")
-+    >>> fig.show()
-+    """
-+
-+    # Apply default colormaps.
-+    # TODO: abstract this away into something that makes default
-+    #       colormaps.
-+    cmap = (
-+        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
-+        if cmap is None else cmap
-+    )
-+
-+    # Extract plotting data W from the input.
-+    if isinstance(rho, Qobj):
-+        if rho.isoper:
-+            W = rho.full()
-+
-+            # Create default labels if none are given.
-+            if xlabels is None or ylabels is None:
-+                labels = _cb_labels(rho.dims[0])
-+                xlabels = xlabels if xlabels is not None else list(labels[0])
-+                ylabels = ylabels if ylabels is not None else list(labels[1])
-+
-+        elif rho.isoperket:
-+            W = vector_to_operator(rho).full()
-+        elif rho.isoperbra:
-+            W = vector_to_operator(rho.dag()).full()
-+        elif rho.issuper:
-+            if not isqubitdims(rho.dims):
-+                raise ValueError("Hinton plots of superoperators are "
-+                                 "currently only supported for qubits.")
-+            # Convert to a superoperator in the Pauli basis,
-+            # so that all the elements are real.
-+            sqobj = _to_superpauli(rho)
-+            nq = int(log2(sqobj.shape[0]) / 2)
-+            W = sqobj.full().T
-+            # Create default labels, too.
-+            if (xlabels is None) or (ylabels is None):
-+                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-+                xlabels = xlabels if xlabels is not None else labels
-+                ylabels = ylabels if ylabels is not None else labels
-+
-+        else:
-+            raise ValueError(
-+                "Input quantum object must be an operator or superoperator."
-+            )
-+
-+    else:
-+        W = rho
-+
-+    if ax is None:
-+        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
-+    else:
-+        fig = None
-+
-+    if not (xlabels or ylabels):
-+        ax.axis('off')
-+    if title:
-+        ax.set_title(title)
-+
-+    ax.axis('equal')
-+    ax.set_frame_on(False)
-+
-+    height, width = W.shape
-+
-+    w_max = 1.25 * max(abs(np.array(W)).flatten())
-+    if w_max <= 0.0:
-+        w_max = 1.0
-+
-+    # Set color_fn here.
-+    if color_style == "scaled":
-+        def color_fn(w):
-+            w = np.abs(w) * np.sign(np.real(w))
-+            return cmap(int((w + w_max) * 256 / (2 * w_max)))
-+    elif color_style == "threshold":
-+        def color_fn(w):
-+            w = np.real(w)
-+            return cmap(255 if w > 0 else 0)
-+    elif color_style == "phase":
-+        def color_fn(w):
-+            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
-+    else:
-+        raise ValueError(
-+            "Unknown color style {} for Hinton diagrams.".format(color_style)
-+        )
-+
-+    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
-+            color=cmap(128))
-+    for x in range(width):
-+        for y in range(height):
-+            _x = x + 1
-+            _y = y + 1
-+            _blob(
-+                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
-+                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
-+
-+    # color axis
-+    vmax = np.pi if color_style == "phase" else abs(W).max()
-+    norm = mpl.colors.Normalize(-vmax, vmax)
-+    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-+    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-+
-+    xtics = 0.5 + np.arange(width)
-+    # x axis
-+    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
-+    if xlabels:
-+        nxlabels = len(xlabels)
-+        if nxlabels != len(xtics):
-+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-+        ax.set_xticklabels(xlabels)
-+        if label_top:
-+            ax.xaxis.tick_top()
-+    ax.tick_params(axis='x', labelsize=14)
-+
-+    # y axis
-+    ytics = 0.5 + np.arange(height)
-+    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
-+    if ylabels:
-+        nylabels = len(ylabels)
-+        if nylabels != len(ytics):
-+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-+        ax.set_yticklabels(list(reversed(ylabels)))
-+    ax.tick_params(axis='y', labelsize=14)
-+
-+    return fig, ax
-+
-+
-+def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
-+    """Plots a matrix of values on a sphere
-+
-+    Parameters
-+    ----------
-+    theta : float
-+        Angle with respect to z-axis
-+
-+    phi : float
-+        Angle in x-y plane
-+
-+    values : array
-+        Data set to be plotted
-+
-+    fig : a matplotlib Figure instance
-+        The Figure canvas in which the plot will be drawn.
-+
-+    ax : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    save : bool {False , True}
-+        Whether to save the figure or not
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+    if fig is None or ax is None:
-+        fig = plt.figure()
-+        ax = _axes3D(fig)
-+
-+    thetam, phim = np.meshgrid(theta, phi)
-+    xx = sin(thetam) * cos(phim)
-+    yy = sin(thetam) * sin(phim)
-+    zz = cos(thetam)
-+    r = array(abs(values))
-+    ph = angle(values)
-+    # normalize color range based on phase angles in list ph
-+    nrm = mpl.colors.Normalize(ph.min(), ph.max())
-+
-+    # plot with facecolors set to cm.jet colormap normalized to nrm
-+    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
-+                    facecolors=cm.jet(nrm(ph)), linewidth=0)
-+    # create new axes on plot for colorbar and shrink it a bit.
-+    # pad shifts location of bar with repsect to the main plot
-+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-+
-+    # create new colorbar in axes cax with cm jet and normalized to nrm like
-+    # our facecolors
-+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
-+    # add our colorbar label
-+    cb1.set_label('Angle')
-+
-+    if save:
-+        plt.savefig("sphereplot.png")
-+
-+    return fig, ax
-+
-+
-+def _remove_margins(axis):
-+    """
-+    removes margins about z = 0 and improves the style
-+    by monkey patching
-+    """
-+    def _get_coord_info_new(renderer):
-+        mins, maxs, centers, deltas, tc, highs = \
-+            _get_coord_info_old(renderer)
-+        mins += deltas / 4
-+        maxs -= deltas / 4
-+        return mins, maxs, centers, deltas, tc, highs
-+
-+    _get_coord_info_old = axis._get_coord_info
-+    axis._get_coord_info = _get_coord_info_new
-+
-+
-+def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
-+    """
-+    truncates portion of a colormap and returns the new one
-+    """
-+    if isinstance(cmap, str):
-+        cmap = plt.get_cmap(cmap)
-+    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
-+        'trunc({n},{a:.2f},{b:.2f})'.format(
-+            n=cmap.name, a=minval, b=maxval),
-+        cmap(np.linspace(minval, maxval, n)))
-+    return new_cmap
-+
-+
-+def _stick_to_planes(stick, azim, ax, M, spacing):
-+    """adjusts xlim and ylim in way that bars will
-+    Stick to xz and yz planes
-+    """
-+    if stick is True:
-+        azim = azim % 360
-+        if 0 <= azim <= 90:
-+            ax.set_ylim(1 - .5,)
-+            ax.set_xlim(1 - .5,)
-+        elif 90 < azim <= 180:
-+            ax.set_ylim(1 - .5,)
-+            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
-+        elif 180 < azim <= 270:
-+            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
-+            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
-+        elif 270 < azim < 360:
-+            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
-+            ax.set_xlim(1 - .5,)
-+
-+
-+def _update_yaxis(spacing, M, ax, ylabels):
-+    """
-+    updates the y-axis
-+    """
-+    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-+    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-+    if ylabels:
-+        nylabels = len(ylabels)
-+        if nylabels != len(ytics):
-+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-+        ax.set_yticklabels(ylabels)
-+    else:
-+        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
-+        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
-+    ax.tick_params(axis='y', labelsize=14)
-+    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
-+
-+
-+def _update_xaxis(spacing, M, ax, xlabels):
-+    """
-+    updates the x-axis
-+    """
-+    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-+    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-+    if xlabels:
-+        nxlabels = len(xlabels)
-+        if nxlabels != len(xtics):
-+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-+        ax.set_xticklabels(xlabels)
-+    else:
-+        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
-+        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
-+    ax.tick_params(axis='x', labelsize=14)
-+    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
-+
-+
-+def _update_zaxis(ax, z_min, z_max, zticks):
-+    """
-+    updates the z-axis
-+    """
-+    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
-+    if isinstance(zticks, list):
-+        ax.set_zticks(zticks)
-+    ax.set_zlim3d([min(z_min, 0), z_max])
-+
-+
-+def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
-+                     colorbar=True, fig=None, ax=None, options=None):
-+    """
-+    Draw a histogram for the matrix M, with the given x and y labels and title.
-+
-+    Parameters
-+    ----------
-+    M : Matrix of Qobj
-+        The matrix to visualize
-+
-+    xlabels : list of strings
-+        list of x labels
-+
-+    ylabels : list of strings
-+        list of y labels
-+
-+    title : string
-+        title of the plot (optional)
-+
-+    limits : list/array with two float numbers
-+        The z-axis limits [min, max] (optional)
-+
-+    ax : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    colorbar : bool (default: True)
-+        show colorbar
-+
-+    options : dict
-+        A dictionary containing extra options for the plot.
-+        The names (keys) and values of the options are
-+        described below:
-+
-+        'zticks' : list of numbers
-+            A list of z-axis tick locations.
-+
-+        'cmap' : string (default: 'jet')
-+            The name of the color map to use.
-+
-+        'cmap_min' : float (default: 0.0)
-+            The lower bound to truncate the color map at.
-+            A value in range 0 - 1. The default, 0, leaves the lower
-+            bound of the map unchanged.
-+
-+        'cmap_max' : float (default: 1.0)
-+            The upper bound to truncate the color map at.
-+            A value in range 0 - 1. The default, 1, leaves the upper
-+            bound of the map unchanged.
-+
-+        'bars_spacing' : float (default: 0.1)
-+            spacing between bars.
-+
-+        'bars_alpha' : float (default: 1.)
-+            transparency of bars, should be in range 0 - 1
-+
-+        'bars_lw' : float (default: 0.5)
-+            linewidth of bars' edges.
-+
-+        'bars_edgecolor' : color (default: 'k')
-+            The colors of the bars' edges.
-+            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
-+
-+        'shade' : bool (default: True)
-+            Whether to shade the dark sides of the bars (True) or not (False).
-+            The shading is relative to plot's source of light.
-+
-+        'azim' : float
-+            The azimuthal viewing angle.
-+
-+        'elev' : float
-+            The elevation viewing angle.
-+
-+        'proj_type' : string (default: 'ortho' if ax is not passed)
-+            The type of projection ('ortho' or 'persp')
-+
-+        'stick' : bool (default: False)
-+            Changes xlim and ylim in such a way that bars next to
-+            XZ and YZ planes will stick to those planes.
-+            This option has no effect if ``ax`` is passed as a parameter.
-+
-+        'cbar_pad' : float (default: 0.04)
-+            The fraction of the original axes between the colorbar
-+            and the new image axes.
-+            (i.e. the padding between the 3D figure and the colorbar).
-+
-+        'cbar_to_z' : bool (default: False)
-+            Whether to set the color of maximum and minimum z-values to the
-+            maximum and minimum colors in the colorbar (True) or not (False).
-+
-+        'figsize' : tuple of two numbers
-+            The size of the figure.
-+
-+    Returns :
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    Raises
-+    ------
-+    ValueError
-+        Input argument is not valid.
-+
-+    """
-+
-+    # default options
-+    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
-+                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
-+                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-+                    'shade': False, 'azim': -35, 'elev': 35,
-+                    'proj_type': 'ortho', 'stick': False,
-+                    'cbar_pad': 0.04, 'cbar_to_z': False}
-+
-+    # update default_opts from input options
-+    if options is None:
-+        pass
-+    elif isinstance(options, dict):
-+        # check if keys in options dict are valid
-+        if set(options) - set(default_opts):
-+            raise ValueError("invalid key(s) found in options: "
-+                             f"{', '.join(set(options) - set(default_opts))}")
-+        else:
-+            # updating default options
-+            default_opts.update(options)
-+    else:
-+        raise ValueError("options must be a dictionary")
-+
-+    if isinstance(M, Qobj):
-+        # extract matrix data from Qobj
-+        M = M.full()
-+
-+    n = np.size(M)
-+    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-+    xpos = xpos.T.flatten() + 0.5
-+    ypos = ypos.T.flatten() + 0.5
-+    zpos = np.zeros(n)
-+    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
-+    dz = np.real(M.flatten())
-+
-+    if isinstance(limits, list) and len(limits) == 2:
-+        z_min = limits[0]
-+        z_max = limits[1]
-+    else:
-+        z_min = min(dz)
-+        z_max = max(dz)
-+        if z_min == z_max:
-+            z_min -= 0.1
-+            z_max += 0.1
-+
-+    if default_opts['cbar_to_z']:
-+        norm = mpl.colors.Normalize(min(dz), max(dz))
-+    else:
-+        norm = mpl.colors.Normalize(z_min, z_max)
-+    cmap = _truncate_colormap(default_opts['cmap'],
-+                              default_opts['cmap_min'],
-+                              default_opts['cmap_max'])
-+    colors = cmap(norm(dz))
-+
-+    if ax is None:
-+        fig = plt.figure(figsize=default_opts['figsize'])
-+        ax = _axes3D(fig,
-+                     azim=default_opts['azim'] % 360,
-+                     elev=default_opts['elev'] % 360)
-+        ax.set_proj_type(default_opts['proj_type'])
-+
-+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
-+             edgecolors=default_opts['bars_edgecolor'],
-+             linewidths=default_opts['bars_lw'],
-+             alpha=default_opts['bars_alpha'],
-+             shade=default_opts['shade'])
-+    # remove vertical lines on xz and yz plane
-+    ax.yaxis._axinfo["grid"]['linewidth'] = 0
-+    ax.xaxis._axinfo["grid"]['linewidth'] = 0
-+
-+    if title:
-+        ax.set_title(title)
-+
-+    # x axis
-+    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
-+
-+    # y axis
-+    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
-+
-+    # z axis
-+    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
-+
-+    # stick to xz and yz plane
-+    _stick_to_planes(default_opts['stick'],
-+                     default_opts['azim'], ax, M,
-+                     default_opts['bars_spacing'])
-+
-+    # color axis
-+    if colorbar:
-+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-+                                         pad=default_opts['cbar_pad'])
-+        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-+
-+    # removing margins
-+    _remove_margins(ax.xaxis)
-+    _remove_margins(ax.yaxis)
-+    _remove_margins(ax.zaxis)
-+
-+    return fig, ax
-+
-+
-+def matrix_histogram_complex(M, xlabels=None, ylabels=None,
-+                             title=None, limits=None, phase_limits=None,
-+                             colorbar=True, fig=None, ax=None,
-+                             threshold=None):
-+    """
-+    Draw a histogram for the amplitudes of matrix M, using the argument
-+    of each element for coloring the bars, with the given x and y labels
-+    and title.
-+
-+    Parameters
-+    ----------
-+    M : Matrix of Qobj
-+        The matrix to visualize
-+
-+    xlabels : list of strings
-+        list of x labels
-+
-+    ylabels : list of strings
-+        list of y labels
-+
-+    title : string
-+        title of the plot (optional)
-+
-+    limits : list/array with two float numbers
-+        The z-axis limits [min, max] (optional)
-+
-+    phase_limits : list/array with two float numbers
-+        The phase-axis (colorbar) limits [min, max] (optional)
-+
-+    ax : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    threshold: float (None)
-+        Threshold for when bars of smaller height should be transparent. If
-+        not set, all bars are colored according to the color map.
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    Raises
-+    ------
-+    ValueError
-+        Input argument is not valid.
-+
-+    """
-+
-+    if isinstance(M, Qobj):
-+        # extract matrix data from Qobj
-+        M = M.full()
-+
-+    n = np.size(M)
-+    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-+    xpos = xpos.T.flatten() - 0.5
-+    ypos = ypos.T.flatten() - 0.5
-+    zpos = np.zeros(n)
-+    dx = dy = 0.8 * np.ones(n)
-+    Mvec = M.flatten()
-+    dz = abs(Mvec)
-+
-+    # make small numbers real, to avoid random colors
-+    idx, = np.where(abs(Mvec) < 0.001)
-+    Mvec[idx] = abs(Mvec[idx])
-+
-+    if phase_limits:  # check that limits is a list type
-+        phase_min = phase_limits[0]
-+        phase_max = phase_limits[1]
-+    else:
-+        phase_min = -pi
-+        phase_max = pi
-+
-+    norm = mpl.colors.Normalize(phase_min, phase_max)
-+    cmap = complex_phase_cmap()
-+
-+    colors = cmap(norm(angle(Mvec)))
-+    if threshold is not None:
-+        colors[:, 3] = 1 * (dz > threshold)
-+
-+    if ax is None:
-+        fig = plt.figure()
-+        ax = _axes3D(fig, azim=-35, elev=35)
-+
-+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
-+
-+    if title:
-+        ax.set_title(title)
-+
-+    # x axis
-+    xtics = -0.5 + np.arange(M.shape[0])
-+    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-+    if xlabels:
-+        nxlabels = len(xlabels)
-+        if nxlabels != len(xtics):
-+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-+        ax.set_xticklabels(xlabels)
-+    ax.tick_params(axis='x', labelsize=12)
-+
-+    # y axis
-+    ytics = -0.5 + np.arange(M.shape[1])
-+    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-+    if ylabels:
-+        nylabels = len(ylabels)
-+        if nylabels != len(ytics):
-+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-+        ax.set_yticklabels(ylabels)
-+    ax.tick_params(axis='y', labelsize=12)
-+
-+    # z axis
-+    if limits and isinstance(limits, list):
-+        ax.set_zlim3d(limits)
-+    else:
-+        ax.set_zlim3d([0, 1])  # use min/max
-+    # ax.set_zlabel('abs')
-+
-+    # color axis
-+    if colorbar:
-+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
-+        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-+        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-+        cb.set_ticklabels(
-+            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
-+        cb.set_label('arg')
-+
-+    return fig, ax
-+
-+
-+def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
-+                       figsize=(8, 12), fig=None, ax=None):
-+    """
-+    Plot the energy level diagrams for a list of Hamiltonians. Include
-+    up to N energy levels. For each element in H_list, the energy
-+    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
-+    where n is the index of an element in H_list.
-+
-+    Parameters
-+    ----------
-+
-+        H_list : List of Qobj
-+            A list of Hamiltonians.
-+
-+        labels : List of string
-+            A list of labels for each Hamiltonian
-+
-+        show_ylabels : Bool (default False)
-+            Show y labels to the left of energy levels of the initial
-+            Hamiltonian.
-+
-+        N : int
-+            The number of energy levels to plot
-+
-+        figsize : tuple (int,int)
-+            The size of the figure (width, height).
-+
-+        fig : a matplotlib Figure instance
-+            The Figure canvas in which the plot will be drawn.
-+
-+        ax : a matplotlib axes instance
-+            The axes context in which the plot will be drawn.
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    Raises
-+    ------
-+
-+        ValueError
-+            Input argument is not valid.
-+
-+    """
-+
-+    if not isinstance(H_list, list):
-+        raise ValueError("H_list must be a list of Qobj instances")
-+
-+    if not fig and not ax:
-+        fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+    H = H_list[0]
-+    N = H.shape[0] if N == 0 else min(H.shape[0], N)
-+
-+    xticks = []
-+    yticks = []
-+
-+    x = 0
-+    evals0 = H.eigenenergies(eigvals=N)
-+    for e_idx, e in enumerate(evals0[:N]):
-+        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
-+        yticks.append(e)
-+    xticks.append(x + 1)
-+    x += 2
-+
-+    for H1 in H_list[1:]:
-+
-+        H = H + H1
-+        evals1 = H.eigenenergies()
-+
-+        for e_idx, e in enumerate(evals1[:N]):
-+            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
-+        x += 1
-+
-+        for e_idx, e in enumerate(evals1[:N]):
-+            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
-+        xticks.append(x + 1)
-+        x += 2
-+
-+        evals0 = evals1
-+
-+    ax.set_frame_on(False)
-+
-+    if show_ylabels:
-+        yticks = np.unique(np.around(yticks, 1))
-+        ax.set_yticks(yticks)
-+    else:
-+        ax.axes.get_yaxis().set_visible(False)
-+
-+    if labels:
-+        ax.get_xaxis().tick_bottom()
-+        ax.set_xticks(xticks)
-+        ax.set_xticklabels(labels, fontsize=16)
-+    else:
-+        ax.axes.get_xaxis().set_visible(False)
-+
-+    return fig, ax
-+
-+
-+def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
-+                         figsize=(8, 12), fig=None, ax=None):
-+    warnings.warn("Deprecated: Use plot_energy_levels")
-+    return plot_energy_levels(H_list, N=N, labels=labels,
-+                              show_ylabels=show_ylabels,
-+                              figsize=figsize, fig=fig, ax=ax)
-+
-+
-+def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
-+                           figsize=(8, 6), title=None, unit_y_range=True):
-+    """
-+    Plot the Fock distribution for a density matrix (or ket) that describes
-+    an oscillator mode.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        The density matrix (or ket) of the state to visualize.
-+
-+    fig : a matplotlib Figure instance
-+        The Figure canvas in which the plot will be drawn.
-+
-+    ax : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    title : string
-+        An optional title for the figure.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+
-+    if not fig and not ax:
-+        fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+    if isket(rho):
-+        rho = ket2dm(rho)
-+
-+    N = rho.shape[0]
-+
-+    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
-+           color="green", alpha=0.6, width=0.8)
-+    if unit_y_range:
-+        ax.set_ylim(0, 1)
-+
-+    ax.set_xlim(-.5 + offset, N + offset)
-+    ax.set_xlabel('Fock number', fontsize=12)
-+    ax.set_ylabel('Occupation probability', fontsize=12)
-+
-+    if title:
-+        ax.set_title(title)
-+
-+    return fig, ax
-+
-+
-+def fock_distribution(rho, offset=0, fig=None, ax=None,
-+                      figsize=(8, 6), title=None, unit_y_range=True):
-+    warnings.warn("Deprecated: Use plot_fock_distribution")
-+    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
-+                                  figsize=figsize, title=title,
-+                                  unit_y_range=unit_y_range)
-+
-+
-+def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
-+                cmap=None, alpha_max=7.5, colorbar=False,
-+                method='clenshaw', projection='2d'):
-+    """
-+    Plot the the Wigner function for a density matrix (or ket) that describes
-+    an oscillator mode.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        The density matrix (or ket) of the state to visualize.
-+
-+    fig : a matplotlib Figure instance
-+        The Figure canvas in which the plot will be drawn.
-+
-+    ax : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    cmap : a matplotlib cmap instance
-+        The colormap.
-+
-+    alpha_max : float
-+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-+
-+    colorbar : bool
-+        Whether (True) or not (False) a colorbar should be attached to the
-+        Wigner function graph.
-+
-+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-+        The method used for calculating the wigner function. See the
-+        documentation for qutip.wigner for details.
-+
-+    projection: string {'2d', '3d'}
-+        Specify whether the Wigner function is to be plotted as a
-+        contour graph ('2d') or surface plot ('3d').
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+
-+    if not fig and not ax:
-+        if projection == '2d':
-+            fig, ax = plt.subplots(1, 1, figsize=figsize)
-+        elif projection == '3d':
-+            fig = plt.figure(figsize=figsize)
-+            ax = fig.add_subplot(1, 1, 1, projection='3d')
-+        else:
-+            raise ValueError('Unexpected value of projection keyword argument')
-+
-+    if isket(rho):
-+        rho = ket2dm(rho)
-+
-+    xvec = np.linspace(-alpha_max, alpha_max, 200)
-+    W0 = wigner(rho, xvec, xvec, method=method)
-+
-+    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
-+
-+    wlim = abs(W).max()
-+
-+    if cmap is None:
-+        cmap = cm.get_cmap('RdBu')
-+
-+    if projection == '2d':
-+        cf = ax.contourf(xvec, yvec, W, 100,
-+                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-+    elif projection == '3d':
-+        X, Y = np.meshgrid(xvec, xvec)
-+        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
-+                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-+    else:
-+        raise ValueError('Unexpected value of projection keyword argument.')
-+
-+    if xvec is not yvec:
-+        ax.set_ylim(xvec.min(), xvec.max())
-+
-+    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
-+    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
-+
-+    if colorbar:
-+        fig.colorbar(cf, ax=ax)
-+
-+    ax.set_title("Wigner function", fontsize=12)
-+
-+    return fig, ax
-+
-+
-+def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-+                                  cmap=None, alpha_max=7.5, colorbar=False,
-+                                  method='iterative', projection='2d'):
-+    """
-+    Plot the Fock distribution and the Wigner function for a density matrix
-+    (or ket) that describes an oscillator mode.
-+
-+    Parameters
-+    ----------
-+    rho : :class:`qutip.Qobj`
-+        The density matrix (or ket) of the state to visualize.
-+
-+    fig : a matplotlib Figure instance
-+        The Figure canvas in which the plot will be drawn.
-+
-+    axes : a list of two matplotlib axes instances
-+        The axes context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    cmap : a matplotlib cmap instance
-+        The colormap.
-+
-+    alpha_max : float
-+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-+
-+    colorbar : bool
-+        Whether (True) or not (False) a colorbar should be attached to the
-+        Wigner function graph.
-+
-+    method : string {'iterative', 'laguerre', 'fft'}
-+        The method used for calculating the wigner function. See the
-+        documentation for qutip.wigner for details.
-+
-+    projection: string {'2d', '3d'}
-+        Specify whether the Wigner function is to be plotted as a
-+        contour graph ('2d') or surface plot ('3d').
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+
-+    if not fig and not axes:
-+        if projection == '2d':
-+            fig, axes = plt.subplots(1, 2, figsize=figsize)
-+        elif projection == '3d':
-+            fig = plt.figure(figsize=figsize)
-+            axes = [fig.add_subplot(1, 2, 1),
-+                    fig.add_subplot(1, 2, 2, projection='3d')]
-+        else:
-+            raise ValueError('Unexpected value of projection keyword argument')
-+
-+    if isket(rho):
-+        rho = ket2dm(rho)
-+
-+    plot_fock_distribution(rho, fig=fig, ax=axes[0])
-+    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
-+                alpha_max=alpha_max, colorbar=colorbar, method=method,
-+                projection=projection)
-+
-+    return fig, axes
-+
-+
-+def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-+                             cmap=None, alpha_max=7.5, colorbar=False,
-+                             method='iterative'):
-+    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
-+    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
-+                                         figsize=figsize, cmap=cmap,
-+                                         alpha_max=alpha_max,
-+                                         colorbar=colorbar,
-+                                         method=method)
-+
-+
-+def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
-+                            fig=None, axes=None, figsize=(8, 4)):
-+    """
-+    Visualize the results (expectation values) for an evolution solver.
-+    `results` is assumed to be an instance of Result, or a list of Result
-+    instances.
-+
-+    Parameters
-+    ----------
-+    results : (list of) :class:`qutip.solver.Result`
-+        List of results objects returned by any of the QuTiP evolution solvers.
-+
-+    ylabels : list of strings
-+        The y-axis labels. List should be of the same length as `results`.
-+
-+    title : string
-+        The title of the figure.
-+
-+    show_legend : bool
-+        Whether or not to show the legend.
-+
-+    fig : a matplotlib Figure instance
-+        The Figure canvas in which the plot will be drawn.
-+
-+    axes : a matplotlib axes instance
-+        The axes context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+    if not isinstance(results, list):
-+        results = [results]
-+
-+    n_e_ops = max([len(result.expect) for result in results])
-+
-+    if not fig or not axes:
-+        if not figsize:
-+            figsize = (12, 3 * n_e_ops)
-+        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
-+                                 figsize=figsize, squeeze=False)
-+
-+    for r_idx, result in enumerate(results):
-+        for e_idx, e in enumerate(result.expect):
-+            axes[e_idx, 0].plot(result.times, e,
-+                                label="%s [%d]" % (result.solver, e_idx))
-+
-+    if title:
-+        fig.suptitle(title)
-+
-+    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
-+    for n in range(n_e_ops):
-+        if show_legend:
-+            axes[n, 0].legend()
-+        if ylabels:
-+            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
-+
-+    return fig, axes
-+
-+
-+def plot_spin_distribution_2d(P, THETA, PHI,
-+                              fig=None, ax=None, figsize=(8, 8)):
-+    """
-+    Plot a spin distribution function (given as meshgrid data) with a 2D
-+    projection where the surface of the unit sphere is mapped on the unit disk.
-+
-+    Parameters
-+    ----------
-+    P : matrix
-+        Distribution values as a meshgrid matrix.
-+
-+    THETA : matrix
-+        Meshgrid matrix for the theta coordinate.
-+
-+    PHI : matrix
-+        Meshgrid matrix for the phi coordinate.
-+
-+    fig : a matplotlib figure instance
-+        The figure canvas on which the plot will be drawn.
-+
-+    ax : a matplotlib axis instance
-+        The axis context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+    """
-+
-+    if not fig or not ax:
-+        if not figsize:
-+            figsize = (8, 8)
-+        fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+    Y = (THETA - pi / 2) / (pi / 2)
-+    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-+
-+    if P.min() < -1e12:
-+        cmap = cm.RdBu
-+    else:
-+        cmap = cm.RdYlBu
-+
-+    ax.pcolor(X, Y, P.real, cmap=cmap)
-+    ax.set_xlabel(r'$\varphi$', fontsize=18)
-+    ax.set_ylabel(r'$\theta$', fontsize=18)
-+
-+    ax.set_xticks([-1, 0, 1])
-+    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
-+    ax.set_yticks([-1, 0, 1])
-+    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-+
-+    return fig, ax
-+
-+
-+def plot_spin_distribution_3d(P, THETA, PHI,
-+                              fig=None, ax=None, figsize=(8, 6)):
-+    """Plots a matrix of values on a sphere
-+
-+    Parameters
-+    ----------
-+    P : matrix
-+        Distribution values as a meshgrid matrix.
-+
-+    THETA : matrix
-+        Meshgrid matrix for the theta coordinate.
-+
-+    PHI : matrix
-+        Meshgrid matrix for the phi coordinate.
-+
-+    fig : a matplotlib figure instance
-+        The figure canvas on which the plot will be drawn.
-+
-+    ax : a matplotlib axis instance
-+        The axis context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    """
-+
-+    if fig is None or ax is None:
-+        fig = plt.figure(figsize=figsize)
-+        ax = _axes3D(fig, azim=-35, elev=35)
-+
-+    xx = sin(THETA) * cos(PHI)
-+    yy = sin(THETA) * sin(PHI)
-+    zz = cos(THETA)
-+
-+    if P.min() < -1e12:
-+        cmap = cm.RdBu
-+        norm = mpl.colors.Normalize(-P.max(), P.max())
-+    else:
-+        cmap = cm.RdYlBu
-+        norm = mpl.colors.Normalize(P.min(), P.max())
-+
-+    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-+                    facecolors=cmap(norm(P)), linewidth=0)
-+
-+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-+    cb1.set_label('magnitude')
-+
-+    return fig, ax
-+
-+
-+#
-+# Qubism and other qubistic visualizations
-+#
-+def complex_array_to_rgb(X, theme='light', rmax=None):
-+    """
-+    Makes an array of complex number and converts it to an array of [r, g, b],
-+    where phase gives hue and saturation/value are given by the absolute value.
-+    Especially for use with imshow for complex plots.
-+
-+    For more info on coloring, see:
-+        Emilia Petrisor,
-+        Visualizing complex-valued functions with Matplotlib and Mayavi
-+        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
-+
-+    Parameters
-+    ----------
-+    X : array
-+        Array (of any dimension) of complex numbers.
-+
-+    theme : 'light' (default) or 'dark'
-+        Set coloring theme for mapping complex values into colors.
-+
-+    rmax : float
-+        Maximal abs value for color normalization.
-+        If None (default), uses np.abs(X).max().
-+
-+    Returns
-+    -------
-+    Y : array
-+        Array of colors (of shape X.shape + (3,)).
-+
-+    """
-+
-+    absmax = rmax or np.abs(X).max()
-+    if absmax == 0.:
-+        absmax = 1.
-+    Y = np.zeros(X.shape + (3,), dtype='float')
-+    Y[..., 0] = np.angle(X) / (2 * pi) % 1
-+    if theme == 'light':
-+        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
-+        Y[..., 2] = 1
-+    elif theme == 'dark':
-+        Y[..., 1] = 1
-+        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
-+    Y = mpl.colors.hsv_to_rgb(Y)
-+    return Y
-+
-+
-+def _index_to_sequence(i, dim_list):
-+    """
-+    For a matrix entry with index i it returns state it corresponds to.
-+    In particular, for dim_list=[2]*n it returns i written as a binary number.
-+
-+    Parameters
-+    ----------
-+    i : int
-+        Index in a matrix.
-+
-+    dim_list : list of int
-+        List of dimensions of consecutive particles.
-+
-+    Returns
-+    -------
-+    seq : list
-+        List of coordinates for each particle.
-+
-+    """
-+    res = []
-+    j = i
-+    for d in reversed(dim_list):
-+        j, s = divmod(j, d)
-+        res.append(s)
-+    return list(reversed(res))
-+
-+
-+def _sequence_to_index(seq, dim_list):
-+    """
-+    Inverse of _index_to_sequence.
-+
-+    Parameters
-+    ----------
-+    seq : list of ints
-+        List of coordinates for each particle.
-+
-+    dim_list : list of int
-+        List of dimensions of consecutive particles.
-+
-+    Returns
-+    -------
-+    i : list
-+        Index in a matrix.
-+
-+    """
-+    i = 0
-+    for s, d in zip(seq, dim_list):
-+        i *= d
-+        i += s
-+
-+    return i
-+
-+
-+def _to_qubism_index_pair(i, dim_list, how='pairs'):
-+    """
-+    For a matrix entry with index i
-+    it returns x, y coordinates in qubism mapping.
-+
-+    Parameters
-+    ----------
-+    i : int
-+        Index in a matrix.
-+
-+    dim_list : list of int
-+        List of dimensions of consecutive particles.
-+
-+    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
-+        Type of qubistic plot.
-+
-+    Returns
-+    -------
-+    x, y : tuple of ints
-+        List of coordinates for each particle.
-+
-+    """
-+    seq = _index_to_sequence(i, dim_list)
-+
-+    if how == 'pairs':
-+        y = _sequence_to_index(seq[::2], dim_list[::2])
-+        x = _sequence_to_index(seq[1::2], dim_list[1::2])
-+    elif how == 'pairs_skewed':
-+        dim_list2 = dim_list[::2]
-+        y = _sequence_to_index(seq[::2], dim_list2)
-+        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
-+        x = _sequence_to_index(seq2, dim_list2)
-+    elif how == 'before_after':
-+        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
-+        n = len(dim_list)
-+        y = _sequence_to_index(reversed(seq[:(n // 2)]),
-+                               reversed(dim_list[:(n // 2)]))
-+        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
-+    else:
-+        raise Exception("No such 'how'.")
-+
-+    return x, y
-+
-+
-+def _sequence_to_latex(seq, style='ket'):
-+    """
-+    For a sequence of particle states generate LaTeX code.
-+
-+    Parameters
-+    ----------
-+    seq : list of ints
-+        List of coordinates for each particle.
-+
-+    style : 'ket' (default), 'bra' or 'bare'
-+        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
-+
-+    Returns
-+    -------
-+    latex : str
-+        LaTeX output.
-+
-+    """
-+    if style == 'ket':
-+        latex = "$\\left|{0}\\right\\rangle$"
-+    elif style == 'bra':
-+        latex = "$\\left\\langle{0}\\right|$"
-+    elif style == 'bare':
-+        latex = "${0}$"
-+    else:
-+        raise Exception("No such style.")
-+    return latex.format("".join(map(str, seq)))
-+
-+
-+def plot_qubism(ket, theme='light', how='pairs',
-+                grid_iteration=1, legend_iteration=0,
-+                fig=None, ax=None, figsize=(6, 6)):
-+    """
-+    Qubism plot for pure states of many qudits.  Works best for spin chains,
-+    especially with even number of particles of the same dimension.  Allows to
-+    see entanglement between first 2k particles and the rest.
-+
-+    Parameters
-+    ----------
-+    ket : Qobj
-+        Pure state for plotting.
-+
-+    theme : 'light' (default) or 'dark'
-+        Set coloring theme for mapping complex values into colors.
-+        See: complex_array_to_rgb.
-+
-+    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
-+        Type of Qubism plotting.  Options:
-+
-+        - 'pairs' - typical coordinates,
-+        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
-+        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
-+
-+    grid_iteration : int (default 1)
-+        Helper lines to be drawn on plot.
-+        Show tiles for 2*grid_iteration particles vs all others.
-+
-+    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
-+        Show labels for first ``2*legend_iteration`` particles.  Option
-+        'grid_iteration' sets the same number of particles as for
-+        grid_iteration.  Option 'all' makes label for all particles.  Typically
-+        it should be 0, 1, 2 or perhaps 3.
-+
-+    fig : a matplotlib figure instance
-+        The figure canvas on which the plot will be drawn.
-+
-+    ax : a matplotlib axis instance
-+        The axis context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    Notes
-+    -----
-+    See also [1]_.
-+
-+    References
-+    ----------
-+    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
-+       and G. Sierra, *Qubism: self-similar visualization of many-body
-+       wavefunctions*, `New J. Phys. 14 053028
-+       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
-+       (2012), open access.
-+    """
-+
-+    if not isket(ket):
-+        raise Exception("Qubism works only for pure states, i.e. kets.")
-+        # add for dm? (perhaps a separate function, plot_qubism_dm)
-+
-+    if not fig and not ax:
-+        fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+    dim_list = ket.dims[0]
-+    n = len(dim_list)
-+
-+    # for odd number of particles - pixels are rectangular
-+    if n % 2 == 1:
-+        ket = tensor(ket, Qobj([1] * dim_list[-1]))
-+        dim_list = ket.dims[0]
-+        n += 1
-+
-+    ketdata = ket.full()
-+
-+    if how == 'pairs':
-+        dim_list_y = dim_list[::2]
-+        dim_list_x = dim_list[1::2]
-+    elif how == 'pairs_skewed':
-+        dim_list_y = dim_list[::2]
-+        dim_list_x = dim_list[1::2]
-+        if dim_list_x != dim_list_y:
-+            raise Exception("For 'pairs_skewed' pairs " +
-+                            "of dimensions need to be the same.")
-+    elif how == 'before_after':
-+        dim_list_y = list(reversed(dim_list[:(n // 2)]))
-+        dim_list_x = dim_list[(n // 2):]
-+    else:
-+        raise Exception("No such 'how'.")
-+
-+    size_x = np.prod(dim_list_x)
-+    size_y = np.prod(dim_list_y)
-+
-+    qub = np.zeros([size_x, size_y], dtype=complex)
-+    for i in range(ketdata.size):
-+        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
-+    qub = qub.transpose()
-+
-+    quadrants_x = np.prod(dim_list_x[:grid_iteration])
-+    quadrants_y = np.prod(dim_list_y[:grid_iteration])
-+
-+    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
-+    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
-+
-+    ax.set_xticks(ticks_x)
-+    ax.set_xticklabels([""] * (quadrants_x - 1))
-+    ax.set_yticks(ticks_y)
-+    ax.set_yticklabels([""] * (quadrants_y - 1))
-+    theme2color_of_lines = {'light': '#000000',
-+                            'dark': '#FFFFFF'}
-+    ax.grid(True, color=theme2color_of_lines[theme])
-+    ax.imshow(complex_array_to_rgb(qub, theme=theme),
-+              interpolation="none",
-+              extent=(0, size_x, 0, size_y))
-+
-+    if legend_iteration == 'all':
-+        label_n = n // 2
-+    elif legend_iteration == 'grid_iteration':
-+        label_n = grid_iteration
-+    else:
-+        try:
-+            label_n = int(legend_iteration)
-+        except:
-+            raise Exception("No such option for legend_iteration keyword " +
-+                            "argument. Use 'all', 'grid_iteration' or an " +
-+                            "integer.")
-+
-+    if label_n:
-+
-+        if how == 'before_after':
-+            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
-+                + dim_list_x[:label_n]
-+        else:
-+            dim_list_small = []
-+            for j in range(label_n):
-+                dim_list_small.append(dim_list_y[j])
-+                dim_list_small.append(dim_list_x[j])
-+
-+        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
-+        shift_x = 0.5 * scale_x
-+        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
-+        shift_y = 0.5 * scale_y
-+
-+        bbox = ax.get_window_extent().transformed(
-+            fig.dpi_scale_trans.inverted())
-+        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
-+        opts = {'fontsize': fontsize,
-+                'color': theme2color_of_lines[theme],
-+                'horizontalalignment': 'center',
-+                'verticalalignment': 'center'}
-+        for i in range(np.prod(dim_list_small)):
-+            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
-+            seq = _index_to_sequence(i, dim_list=dim_list_small)
-+            ax.text(scale_x * x + shift_x,
-+                    size_y - (scale_y * y + shift_y),
-+                    _sequence_to_latex(seq),
-+                    **opts)
-+    return fig, ax
-+
-+
-+def plot_schmidt(ket, splitting=None,
-+                 labels_iteration=(3, 2),
-+                 theme='light',
-+                 fig=None, ax=None, figsize=(6, 6)):
-+    """
-+    Plotting scheme related to Schmidt decomposition.
-+    Converts a state into a matrix (A_ij -> A_i^j),
-+    where rows are first particles and columns - last.
-+
-+    See also: plot_qubism with how='before_after' for a similar plot.
-+
-+    Parameters
-+    ----------
-+    ket : Qobj
-+        Pure state for plotting.
-+
-+    splitting : int
-+        Plot for a number of first particles versus the rest.
-+        If not given, it is (number of particles + 1) // 2.
-+
-+    theme : 'light' (default) or 'dark'
-+        Set coloring theme for mapping complex values into colors.
-+        See: complex_array_to_rgb.
-+
-+    labels_iteration : int or pair of ints (default (3,2))
-+        Number of particles to be shown as tick labels,
-+        for first (vertical) and last (horizontal) particles, respectively.
-+
-+    fig : a matplotlib figure instance
-+        The figure canvas on which the plot will be drawn.
-+
-+    ax : a matplotlib axis instance
-+        The axis context in which the plot will be drawn.
-+
-+    figsize : (width, height)
-+        The size of the matplotlib figure (in inches) if it is to be created
-+        (that is, if no 'fig' and 'ax' arguments are passed).
-+
-+    Returns
-+    -------
-+    fig, ax : tuple
-+        A tuple of the matplotlib figure and axes instances used to produce
-+        the figure.
-+
-+    """
-+    if not isket(ket):
-+        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
-+
-+    if not fig and not ax:
-+        fig, ax = plt.subplots(1, 1, figsize=figsize)
-+
-+    dim_list = ket.dims[0]
-+
-+    if splitting is None:
-+        splitting = (len(dim_list) + 1) // 2
-+
-+    if isinstance(labels_iteration, int):
-+        labels_iteration = labels_iteration, labels_iteration
-+
-+    ketdata = ket.full()
-+
-+    dim_list_y = dim_list[:splitting]
-+    dim_list_x = dim_list[splitting:]
-+
-+    size_x = np.prod(dim_list_x)
-+    size_y = np.prod(dim_list_y)
-+
-+    ketdata = ketdata.reshape((size_y, size_x))
-+
-+    dim_list_small_x = dim_list_x[:labels_iteration[1]]
-+    dim_list_small_y = dim_list_y[:labels_iteration[0]]
-+
-+    quadrants_x = np.prod(dim_list_small_x)
-+    quadrants_y = np.prod(dim_list_small_y)
-+
-+    ticks_x = [size_x / quadrants_x * (i + 0.5)
-+               for i in range(quadrants_x)]
-+    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
-+               for i in range(quadrants_y)]
-+
-+    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
-+                                                      dim_list=dim_list_x))
-+                for i in range(quadrants_x)]
-+    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
-+                                                      dim_list=dim_list_y))
-+                for i in range(quadrants_y)]
-+
-+    ax.set_xticks(ticks_x)
-+    ax.set_xticklabels(labels_x)
-+    ax.set_yticks(ticks_y)
-+    ax.set_yticklabels(labels_y)
-+    ax.set_xlabel("last particles")
-+    ax.set_ylabel("first particles")
-+
-+    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
-+              interpolation="none",
-+              extent=(0, size_x, 0, size_y))
-+
-+    return fig, ax
-diff --git a/qutip/wigner.py b/qutip/wigner.py
-index 48abd663..cc0a130f 100644
---- a/qutip/wigner.py
-+++ b/qutip/wigner.py
-@@ -1,1003 +1,1003 @@
--__all__ = [
--    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
--    'wigner_transform',
--]
--
--import numpy as np
--import warnings
--from numpy import (
--    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
--)
--import scipy.sparse as sp
--import scipy.fftpack as ft
--import scipy.linalg as la
--import scipy.special
--from scipy.special import genlaguerre, binom, sph_harm, factorial
--
--import qutip
--from qutip import Qobj, ket2dm, jmat
--from .solver.parallel import parallel_map
--from .utilities import clebsch
--from .core import data as _data
--from .core.data.eigen import eigh
--
--
--def wigner_transform(psi, j, fullparity, steps, slicearray):
--    """takes the density matrix or state vector of any finite state and
--    generates the Wigner function for that state on a sphere, generating a spin
--    Wigner function useful for displaying the quasi-probability for a qubit or
--    any qudit. For the standard, continuous-variable Wigner function for
--    position and momentum variables, wigner() should be used.
--
--    Parameters
--    ----------
--        psi : qobj
--              a state vector or density matrix.
--        j : int
--            the total angular momentum of the quantum state.
--        fullparity : bool
--                     should the parity of the full SU space be used?
--        steps : int
--                number of points at which the Wigner transform is calculated.
--        slicearray : list of str
--                     the angle slice to be used for each particle in case of a
--                     multi-particle quantum state. 'l' yields an equal angle
--                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
--
--    Returns
--    ----------
--        wigner : list of float
--                 the wigner transformation at `steps` different theta and phi.
--
--    Raises
--    ------
--    ComplexWarning
--        This can be ignored as it is caused due to rounding errors.
--
--    Notes
--    ------
--    See example notebook wigner_visualisation.
--
--    References
--    ------
--    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
--        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
--    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
--        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
--    """
--    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
--        raise TypeError('Input state is not a valid operator.')
--
--    if psi.isket or psi.isbra:
--        rho = psi.proj()
--    else:
--        rho = psi
--
--    sun = 2   # The order of the SU group
--
--    # calculate total number of particles in quantum state:
--    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
--
--    theta = np.zeros((N, steps))
--    phi = np.zeros((N, steps))
--
--    for i in range(N):
--        theta[i, :] = np.linspace(0, np.pi, steps)
--        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
--
--    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
--
--    wigner = np.zeros((steps, steps))
--    if fullparity:
--        pari = _parity(sun**N, j)
--    else:
--        pari = _parity(sun, j)
--    for t in range(steps):
--        for p in range(steps):
--            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
--            kernel = _data.dense.fast_from_numpy(kernel)
--            wigner[t, p] = _data.expect(rho.data, kernel).real
--    return wigner
--
--
--def _parity(N, j):
--    """Private function to calculate the parity of the quantum system.
--    """
--    if j == 0.5:
--        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
--        return pi / N
--    elif j > 0.5:
--        mult = np.int32(2 * j + 1)
--        matrix = np.zeros((mult, mult))
--        foo = np.ones(mult)
--        for n in np.arange(-j, j + 1, 1):
--            for l in np.arange(0, mult, 1):
--                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
--            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
--        return matrix / mult
--
--
--def _lambda_f(N):
--    """Private function needed for the calculation of the parity.
--    """
--    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
--    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
--    return matrix
--
--
--def _kernelsu2(theta, phi, N, j, parity, fullparity):
--    """Private function that calculates the kernel for the SU2 unitary group.
--    """
--    U = np.ones(1)
--    # calculate the total rotation matrix (tensor product for each particle):
--    for i in range(0, N):
--        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
--    if not fullparity:
--        op_parity = parity   # The parity for a one particle system
--        for i in range(1, N):
--            parity = np.kron(parity, op_parity)
--    matrix = U @ parity @ U.conj().T
--    return matrix
--
--
--def _rotation_matrix(theta, phi, j):
--    """Private function to calculate the rotation operator for the SU2 kernel.
--    """
--    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
--           la.expm(1j * theta * jmat(j, 'y').full())
--
--
--def _angle_slice(slicearray, theta, phi):
--    """Private function to modify theta and phi for angle slicing.
--    """
--    xind = np.where(slicearray == 'x')
--    theta[xind, :] = np.pi - theta[xind, :]
--    phi[xind, :] = -phi[xind, :]
--    yind = np.where(slicearray == 'y')
--    theta[yind, :] = np.pi - theta[yind, :]
--    phi[yind, :] = np.pi - phi[yind, :]
--    zind = np.where(slicearray == 'z')
--    phi[zind, :] = phi[zind, :] + np.pi
--    return theta, phi
--
--
--def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
--           sparse=False, parfor=False):
--    """Wigner function for a state vector or density matrix at points
--    `xvec + i * yvec`.
--
--    Parameters
--    ----------
--
--    state : qobj
--        A state vector or density matrix.
--
--    xvec : array_like
--        x-coordinates at which to calculate the Wigner function.
--
--    yvec : array_like
--        y-coordinates at which to calculate the Wigner function.  Does not
--        apply to the 'fft' method.
--
--    g : float
--        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
--        The value of `g` is related to the value of `hbar` in the commutation
--        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
--        value `hbar=1`.
--
--    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
--        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
--        and 'iterative' use an iterative method to evaluate the Wigner functions for density
--        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
--        in scipy for the same task. The 'fft' method evaluates the Fourier
--        transform of the density matrix. The 'iterative' method is default, and
--        in general recommended, but the 'laguerre' method is more efficient for
--        very sparse density matrices (e.g., superpositions of Fock states in a
--        large Hilbert space). The 'clenshaw' method is the preferred method for
--        dealing with density matrices that have a large number of excitations
--        (>~50). 'clenshaw' is a fast and numerically stable method.
--
--    sparse : bool {False, True}
--        Tells the default solver whether or not to keep the input density
--        matrix in sparse format.  As the dimensions of the density matrix
--        grow, setthing this flag can result in increased performance.
--
--    parfor : bool {False, True}
--        Flag for calculating the Laguerre polynomial based Wigner function
--        method='laguerre' in parallel using the parfor function.
--
--
--    Returns
--    -------
--
--    W : array
--        Values representing the Wigner function calculated over the specified
--        range [xvec,yvec].
--
--    yvex : array
--        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
--        transform.
--
--    Notes
--    -----
--    The 'fft' method accepts only an xvec input for the x-coordinate.
--    The y-coordinates are calculated internally.
--
--    References
--    ----------
--
--    Ulf Leonhardt,
--    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
--
--    """
--
--    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
--        raise TypeError('Input state is not a valid operator.')
--
--    if method == 'fft':
--        return _wigner_fourier(psi, xvec, g)
--
--    if psi.isket or psi.isbra:
--        rho = psi.proj()
--    else:
--        rho = psi
--
--    if method == 'iterative':
--        return _wigner_iterative(rho, xvec, yvec, g)
--
--    elif method == 'laguerre':
--        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
--
--    elif method == 'clenshaw':
--        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
--
--    else:
--        raise TypeError(
--            "method must be either 'iterative', 'laguerre', or 'fft'.")
--
--
--def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
--    r"""
--    Using an iterative method to evaluate the wigner functions for the Fock
--    state :math:`|m><n|`.
--
--    The Wigner function is calculated as
--    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
--    function for the density matrix :math:`|m><n|`.
--
--    In this implementation, for each row m, Wlist contains the Wigner functions
--    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
--    calculated, the corresponding contribution is added to the total Wigner
--    function, weighted by the corresponding element in the density matrix
--    :math:`rho_{mn}`.
--    """
--
--    M = np.prod(rho.shape[0])
--    X, Y = meshgrid(xvec, yvec)
--    A = 0.5 * g * (X + 1.0j * Y)
--
--    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
--    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
--
--    W = real(rho[0, 0]) * real(Wlist[0])
--    for n in range(1, M):
--        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
--        W += 2 * real(rho[0, n] * Wlist[n])
--
--    for m in range(1, M):
--        temp = copy(Wlist[m])
--        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
--
--        # Wlist[m] = Wigner function for |m><m|
--        W += real(rho[m, m] * Wlist[m])
--
--        for n in range(m + 1, M):
--            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
--            temp = copy(Wlist[n])
--            Wlist[n] = temp2
--
--            # Wlist[n] = Wigner function for |m><n|
--            W += 2 * real(rho[m, n] * Wlist[n])
--
--    return 0.5 * W * g ** 2
--
--
--def _wigner_laguerre(rho, xvec, yvec, g, parallel):
--    r"""
--    Using Laguerre polynomials from scipy to evaluate the Wigner function for
--    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
--    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
--    """
--
--    M = np.prod(rho.shape[0])
--    X, Y = meshgrid(xvec, yvec)
--    A = 0.5 * g * (X + 1.0j * Y)
--    W = zeros(np.shape(A))
--
--    # compute wigner functions for density matrices |m><n| and
--    # weight by all the elements in the density matrix
--    B = 4 * abs(A) ** 2
--    if sp.isspmatrix_csr(rho.data):
--        # for compress sparse row matrices
--        if parallel:
--            iterator = (
--                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
--            W1_out = parallel_map(_par_wig_eval, iterator)
--            W += sum(W1_out)
--        else:
--            for m in range(len(rho.data.indptr) - 1):
--                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
--                    n = rho.data.indices[jj]
--
--                    if m == n:
--                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
--
--                    elif n > m:
--                        W += 2.0 * real(rho[m, n] * (-1) ** m *
--                                        (2 * A) ** (n - m) *
--                                        sqrt(factorial(m) / factorial(n)) *
--                                        genlaguerre(m, n - m)(B))
--    else:
--        # for dense density matrices
--        B = 4 * abs(A) ** 2
--        for m in range(M):
--            if abs(rho[m, m]) > 0.0:
--                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
--            for n in range(m + 1, M):
--                if abs(rho[m, n]) > 0.0:
--                    W += 2.0 * real(rho[m, n] * (-1) ** m *
--                                    (2 * A) ** (n - m) *
--                                    sqrt(factorial(m) / factorial(n)) *
--                                    genlaguerre(m, n - m)(B))
--
--    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
--
--
--def _par_wig_eval(args):
--    """
--    Private function for calculating terms of Laguerre Wigner function
--    using parfor.
--    """
--    m, rho, A, B = args
--    W1 = zeros(np.shape(A))
--    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
--        n = rho.data.indices[jj]
--
--        if m == n:
--            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
--
--        elif n > m:
--            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
--                             (2 * A) ** (n - m) *
--                             sqrt(factorial(m) / factorial(n)) *
--                             genlaguerre(m, n - m)(B))
--    return W1
--
--
--def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
--    """
--    Evaluate the Wigner function via the Fourier transform.
--    """
--    if psi.type == 'bra':
--        psi = psi.dag()
--    if psi.type == 'ket':
--        return _psi_wigner_fft(psi.full(), xvec, g)
--    elif psi.type == 'oper':
--        eig_vals, eig_vecs = eigh(psi.full())
--        W = 0
--        for ii in range(psi.shape[0]):
--            W1, yvec = _psi_wigner_fft(
--                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
--            W += eig_vals[ii] * W1
--        return W, yvec
--
--
--def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
--    """
--    FFT method for a single state vector.  Called multiple times when the
--    input is a density matrix.
--    """
--    n = len(psi)
--    A = _osc_eigen(n, xvec * g / np.sqrt(2))
--    xpsi = np.dot(psi.T, A)
--    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
--    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
--
--
--def _wigner_fft(psi, xvec):
--    """
--    Evaluates the Fourier transformation of a given state vector.
--    Returns the corresponding density matrix and range
--    """
--    n = 2*len(psi.T)
--    r1 = np.concatenate((np.array([[0]]),
--                        np.fliplr(psi.conj()),
--                        np.zeros((1, n//2 - 1))), axis=1)
--    r2 = np.concatenate((np.array([[0]]), psi,
--                        np.zeros((1, n//2 - 1))), axis=1)
--    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
--        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
--    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
--    w = ft.fft(w)
--    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
--    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
--    w = w / (p[1] - p[0]) / n
--    return w, p
--
--
--def _osc_eigen(N, pnts):
--    """
--    Vector of and N-dim oscillator eigenfunctions evaluated
--    at the points in pnts.
--    """
--    pnts = np.asarray(pnts)
--    lpnts = len(pnts)
--    A = np.zeros((N, lpnts))
--    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
--    if N == 1:
--        return A
--    else:
--        A[1, :] = np.sqrt(2) * pnts * A[0, :]
--        for k in range(2, N):
--            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
--                np.sqrt((k - 1.0) / k) * A[k - 2, :]
--        return A
--
--
--def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
--    r"""
--    Using Clenshaw summation - numerically stable and efficient
--    iterative algorithm to evaluate polynomial series.
--
--    The Wigner function is calculated as
--    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
--    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
--    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
--    """
--
--    M = np.prod(rho.shape[0])
--    X,Y = np.meshgrid(xvec, yvec)
--    #A = 0.5 * g * (X + 1.0j * Y)
--    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
--
--    B = np.abs(A2)
--    B *= B
--    w0 = (2*rho[0, -1])*np.ones_like(A2)
--    L = M-1
--    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
--    #using Horner's method
--    if not sparse:
--        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
--        while L > 0:
--            L -= 1
--            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
--            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
--    else:
--        # TODO: fix dispatch.
--        _rho = _data.to(_data.CSR, rho.data).as_scipy()
--        while L > 0:
--            L -= 1
--            diag = _rho.diagonal(L)
--            if L != 0:
--                diag *= 2
--            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
--            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
--
--    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
--
--
--def _wig_laguerre_val(L, x, c):
--    r"""
--    this is evaluation of polynomial series inspired by hermval from numpy.
--    Returns polynomial series
--
--    .. math:
--        \sum_n b_n LL_n^L,
--
--    where
--
--    .. math:
--        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
--
--    The evaluation uses Clenshaw recursion.
--    """
--
--    if len(c) == 1:
--        y0 = c[0]
--        y1 = 0
--    elif len(c) == 2:
--        y0 = c[0]
--        y1 = c[1]
--    else:
--        k = len(c)
--        y0 = c[-2]
--        y1 = c[-1]
--        for i in range(3, len(c) + 1):
--            k -= 1
--            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
--            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
--
--    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
--
--
--# -----------------------------------------------------------------------------
--# Q FUNCTION
--#
--def _qfunc_check_state(state: Qobj):
--    if not isinstance(state, Qobj):
--        raise TypeError(f"state must be Qobj, but is {state}")
--    # This is only approximate, but it's enough for our purposes; doing more
--    # than this would take computational effort we don't _need_ to do.
--    isdm = (
--        state.isoper
--        and state.dims[0] == state.dims[1]
--        and state.isherm
--        and abs(state.tr() - 1) < qutip.settings.core['atol']
--    )
--    if not (state.isket or isdm):
--        raise ValueError(
--            f"state must be a ket or density matrix, but is {state}"
--        )
--    if len(state.dims[0]) != 1:
--        raise ValueError(
--            "state must not have tensor structure, but has dimensions:"
--            f" {state.dims}"
--        )
--    return state
--
--
--def _qfunc_check_coordinates(xvec, yvec):
--    if np.isscalar(xvec) or xvec is None:
--        raise TypeError("xvec must be array-like, but is " + repr(xvec))
--    if np.isscalar(yvec) or yvec is None:
--        raise TypeError("yvec must be array-like, but is " + repr(yvec))
--    xvec = np.asarray(xvec, dtype=np.float64)
--    yvec = np.asarray(yvec, dtype=np.float64)
--    if xvec.ndim != 1 or yvec.ndim != 1:
--        raise ValueError(
--            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
--        )
--    return xvec, yvec
--
--
--class _QFuncCoherentGrid:
--    """
--    Internal function to compute coherent state operators corresponding to a
--    grid of complex values in phase space.  For efficiency reasons, this class
--    produces the adjoint of the coherent states, to save allocations when
--    calculating inner products later.
--
--    Examples
--    --------
--    Initialise the grid calculator.
--
--    >>> xvec = yvec = np.linspace(-1, 1, 21)
--    >>> g = np.sqrt(0.5)
--    >>> max_ns = 10
--    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
--
--    The naive construction of the grid is
--
--    >>> xs, ys = np.meshgrid(xvec, yvec)
--    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
--    >>> naive = np.array([
--    ...     [
--    ...         qutip.coherent(max_ns, alpha, method='analytic')
--    ...             .dag().full().ravel()
--    ...         for alpha in x_alphas
--    ...     ]
--    ...     for y_alphas in all_alphas
--    ... ])
--
--    The naive approach is typically several of orders of magnitude slower than
--    this class, which uses much simpler vectorised operations.  The outputs are
--    within close tolerance, however:
--
--    >>> np.allclose(naive, grid(max_ns))
--    True
--    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
--    True
--    """
--    def __init__(self, xvec, yvec, g: float):
--        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
--        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
--        self.grid = np.empty(x.shape, dtype=np.complex128)
--        self.grid.real = x
--        # We produce the adjoint of the coherent states to save an operation
--        # later when computing dot products, hence the negative imaginary part.
--        self.grid.imag = -y
--        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
--
--    def _start(self, first: int):
--        """
--        Get the coherent state matrix corresponding to the first needed Fock
--        state.
--        """
--        if first == 0:
--            return self.prefactor.copy()
--        out = np.power(self.grid, first)
--        out *= self.prefactor
--        return out
--
--    def __call__(self, first: int, last: int = None):
--        """
--        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
--        coherent-state vectors for all the Fock states in the range ``first``
--        to ``last``, excluding the end point.  The first two axes are the y-
--        and x-coordinates of phase space (i.e. Cartesian indexing, like
--        ``numpy.meshgrid``), and the last runs over the selected range of
--        Fock-space dimensions.
--        """
--        ns = np.arange(first, last).reshape(1, 1, -1)
--        # Technically we could avoid hitting the limits of floating-point
--        # exponents for longer by doing all this in logarithmic space (using
--        # scipy.special.gammaln), but that ends up involving more
--        # floating-point operations overall, and needs special care around the
--        # point alpha = 0 to avoid nan appearing, due to how Python handles
--        # mixed-width arithmetic operations.
--        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
--        out[:, :, 0] = self._start(ns.flat[0])
--        for i in range(ns.size - 1):
--            out[:, :, i+1] = out[:, :, i] * self.grid
--        out /= np.sqrt(scipy.special.factorial(ns))
--        return out
--
--
--class QFunc:
--    r"""
--    Class-based method of calculating the Husimi-Q function of many different
--    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
--    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
--    subsequent operations will be several times faster. However, it can require
--    quite a lot of memory. Call the created object as a function to retrieve
--    the Husimi-Q function.
--
--    Parameters
--    ----------
--    xvec, yvec : array_like
--        x- and y-coordinates at which to calculate the Husimi-Q function.
--
--    g : float, default sqrt(2)
--        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
--        related to the value of `hbar` in the commutation relation
--        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
--        corresponds to :math:`\hbar=1`.
--
--    memory : real, default 1024
--        Size in MB that may be used internally as workspace.  This class will
--        raise ``MemoryError`` if subsequently passed a state of sufficiently
--        large dimension that this bound would be exceeded.  In those cases, use
--        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
--        the slower, more memory-efficient algorithm.
--
--    Examples
--    --------
--    Initialise the class for a square set of coordinates, with some states we
--    want to investigate.
--
--    >>> xvec = np.linspace(-2, 2, 101)
--    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
--    >>> qfunc = qutip.QFunc(xvec, xvec)
--
--    Now we can calculate the Husimi-Q function over each of the states more
--    efficiently with:
--
--    >>> husimiq = np.array([qfunc(state) for state in states])
--
--    See Also
--    --------
--    :obj:`.qfunc` :
--        a single function version, which will involve computing several
--        quantities multiple times in order to use less memory.
--    """
--
--    def __init__(
--        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
--    ):
--        self._g = g
--        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
--        # 16 bytes per complex, 1024**2 bytes per MB.
--        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
--        self._memory_mb = memory
--        self._max_size = int(self._memory_mb // self._size_mb)
--        self._current_size = 0
--        self._cache = None
--
--    def _alphas(self, size: int):
--        r"""
--        Retrive the full tensor of (the conjugate of) coherent states over all
--        values of :math:`\alpha`, for states of dimension ``size``.
--        """
--        if self._current_size >= size:
--            return self._cache[:, :, :size]
--        if size > self._max_size:
--            requirement = self._size_mb * size
--            raise MemoryError(
--                f"Refusing to precompute up to {size} basis states."
--                f" This would require {requirement:.2f} MB,"
--                f" but only {self._memory_mb} MB is allowed."
--            )
--        if self._cache is None:
--            self._cache = self._coherent_grid(self._current_size, size)
--        else:
--            self._cache = np.dstack(
--                [self._cache, self._coherent_grid(self._current_size, size)]
--            )
--        self._current_size = size
--        return self._cache
--
--    def _single(self, vector: np.ndarray, alphas: np.ndarray):
--        r"""
--        Get the Q function (without the :math:`\pi` scaling factor) of a single
--        state vector.
--        """
--        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
--
--    def __call__(self, state: Qobj):
--        """
--        Get the Husimi-Q function for the given state vector or density matrix,
--        over the coordinates used to initialise the class.  If called multiple
--        times, the states do not need to have the same dimensions, but none of
--        them can have tensor-product structure.
--        """
--        state = _qfunc_check_state(state)
--        alphas = self._alphas(state.shape[0])
--        if state.isket:
--            return self._single(state.full().ravel(), alphas) / np.pi
--        # We don't use Qobj.eigenstates() to avoid building many unnecessary
--        # CSR versions of dense matrices.
--        values, vectors = eigh(state.full())
--        vectors = vectors.T
--        out = values[0] * self._single(vectors[0], alphas)
--        for value, vector in zip(values[1:], vectors[1:]):
--            out += value * self._single(vector, alphas)
--        return out / np.pi
--
--
--def _qfunc_iterative_single(
--    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
--):
--    r"""
--    Get the Q function (without the :math:`\pi` scaling factor) of a single
--    state vector, using the iterative algorithm which recomputes the powers of
--    the coherent-state matrix.
--    """
--    ns = np.arange(vector.shape[0])
--    out = np.polyval(
--        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
--        alpha_grid.grid,
--    )
--    out *= alpha_grid.prefactor
--    return np.abs(out)**2
--
--
--def qfunc(
--    state: Qobj,
--    xvec,
--    yvec,
--    g: float = sqrt(2),
--    precompute_memory: float = 1024,
--):
--    r"""
--    Husimi-Q function of a given state vector or density matrix at phase-space
--    points ``0.5 * g * (xvec + i*yvec)``.
--
--    Parameters
--    ----------
--    state : :obj:`.Qobj`
--        A state vector or density matrix.  This cannot have tensor-product
--        structure.
--
--    xvec, yvec : array_like
--        x- and y-coordinates at which to calculate the Husimi-Q function.
--
--    g : float, default sqrt(2)
--        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
--        related to the value of :math:`\hbar` in the commutation relation
--        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
--        corresponds to :math:`\hbar=1`.
--
--    precompute_memory : real, default 1024
--        Size in MB that may be used during calculations as working space when
--        dealing with density-matrix inputs.  This is ignored for state-vector
--        inputs.  The bound is not quite exact due to other, order-of-magnitude
--        smaller, intermediaries being necessary, but is a good approximation.
--        If you want to use the same iterative algorithm for density matrices
--        that is used for single kets, set ``precompute_memory=None``.
--
--    Returns
--    -------
--    ndarray
--        Values representing the Husimi-Q function calculated over the specified
--        range ``[xvec, yvec]``.
--
--    See Also
--    --------
--    :obj:`.QFunc` :
--        a class-based version, more efficient if you want to calculate the
--        Husimi-Q function for several states over the same coordinates.
--    """
--    state = _qfunc_check_state(state)
--    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
--    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
--    enough_memory = (
--        precompute_memory is not None
--        and precompute_memory > required_memory
--    )
--    if state.isoper and enough_memory:
--        return QFunc(xvec, yvec, g)(state)
--    if precompute_memory is not None and state.isoper:
--        warnings.warn(
--            "Falling back to iterative algorithm due to lack of memory."
--            f" Needed {required_memory:.2f} MB, but only allowed to use"
--            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
--            " raise limit, or set to `None` to suppress warning."
--        )
--    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
--    if state.isket:
--        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
--        out /= np.pi
--        return out
--    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
--    # versions of dense matrices.
--    values, vectors = eigh(state.full())
--    vectors = vectors.T
--    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
--    for value, vector in zip(values[1:], vectors[1:]):
--        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
--    out /= np.pi
--    return out
--
--
--# -----------------------------------------------------------------------------
--# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
--#
--def spin_q_function(rho, theta, phi):
--    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
--    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
--    j, theta, phi)`` where j is the spin length.
--    The implementation here is more efficient as it doesn't
--    generate all of the SCS at theta and phi (see references).
--
--    The spin Q function is normal when integrated over the surface of the
--    sphere
--
--    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
--              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
--
--    Parameters
--    ----------
--    state : qobj
--        A state vector or density matrix for a spin-j quantum system.
--    theta : array_like
--        Polar (colatitude) angle at which to calculate the Husimi-Q function.
--    phi : array_like
--        Azimuthal angle at which to calculate the Husimi-Q function.
--
--    Returns
--    -------
--    Q, THETA, PHI : 2d-array
--        Values representing the spin Husimi Q function at the values specified
--        by THETA and PHI.
--
--    References
--    ----------
--    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
--    https://doi.org/10.1119/1.4898595
--
--    """
--
--    if rho.isket or rho.isbra:
--        rho = rho.proj()
--
--    J = rho.shape[0]
--    j = (J - 1) / 2
--
--    THETA, PHI = meshgrid(theta, phi)
--
--    Q = np.zeros_like(THETA, dtype=complex)
--    data = rho.full()
--
--    for m1 in arange(-j, j + 1):
--        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
--             sin(THETA / 2) ** (2 * (j - m1)) * \
--             data[int(j - m1), int(j - m1)]
--
--        for m2 in arange(m1 + 1, j + 1):
--            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
--                  cos(THETA / 2) ** (2 * j + m1 + m2) *
--                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
--             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
--              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
--
--    return Q.real, THETA, PHI
--
--
--def _rho_kq(rho, j, k, q):
--    """
--    This calculates the trace of the multipole operator T_kq and the density
--    matrix rho for use in the spin Wigner quasiprobability distribution.
--
--    Parameters
--    ----------
--    rho : qobj
--        A density matrix for a spin-j quantum system.
--    j : float
--        The spin length of the system.
--    k : int
--        Spherical harmonic degree
--    q : int
--        Spherical harmonic order
--
--    Returns
--    -------
--    v : float
--        Overlap of state with multipole operator T_kq
--    """
--
--    v = 0j
--    data = rho.full()
--    for m1 in arange(-j, j+1):
--        for m2 in arange(-j, j+1):
--            v += (
--                    (-1) ** (2 * j - k - m1 - m2)
--                    * np.sqrt((2 * k + 1) / (2 * j + 1))
--                    * clebsch(j, k, j, -m1, q, -m2)
--                    * data[int(j - m1), int(j - m2)]
--            )
--    return v
--
--
--def spin_wigner(rho, theta, phi):
--    r"""Wigner function for a spin-j system.
--
--    The spin W function is normal when integrated over the surface of the
--    sphere
--
--    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
--              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
--
--
--    Parameters
--    ----------
--    state : qobj
--        A state vector or density matrix for a spin-j quantum system.
--    theta : array_like
--        Polar (colatitude) angle at which to calculate the W function.
--    phi : array_like
--        Azimuthal angle at which to calculate the W function.
--
--    Returns
--    -------
--    W, THETA, PHI : 2d-array
--        Values representing the spin Wigner function at the values specified
--        by THETA and PHI.
--
--    References
--    ----------
--    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
--    https://doi.org/10.1103/PhysRevA.24.2889
--
--    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
--    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
--
--    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
--    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
--
--    """
--    if rho.isket or rho.isbra:
--        rho = rho.proj()
--
--    J = rho.shape[0]
--    j = (J - 1) / 2
--
--    THETA, PHI = meshgrid(theta, phi)
--
--    W = np.zeros_like(THETA, dtype=complex)
--
--    for k in range(int(2 * j)+1):
--        for q in arange(-k, k+1):
--            # sph_harm takes azimuthal angle then polar angle as arguments
--            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
--
--    return W.real, THETA, PHI
-+__all__ = [
-+    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
-+    'wigner_transform',
-+]
-+
-+import numpy as np
-+import warnings
-+from numpy import (
-+    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
-+)
-+import scipy.sparse as sp
-+import scipy.fftpack as ft
-+import scipy.linalg as la
-+import scipy.special
-+from scipy.special import genlaguerre, binom, sph_harm, factorial
-+
-+import qutip
-+from qutip import Qobj, ket2dm, jmat
-+from .solver.parallel import parallel_map
-+from .utilities import clebsch
-+from .core import data as _data
-+from .core.data.eigen import eigh
-+
-+
-+def wigner_transform(psi, j, fullparity, steps, slicearray):
-+    """takes the density matrix or state vector of any finite state and
-+    generates the Wigner function for that state on a sphere, generating a spin
-+    Wigner function useful for displaying the quasi-probability for a qubit or
-+    any qudit. For the standard, continuous-variable Wigner function for
-+    position and momentum variables, wigner() should be used.
-+
-+    Parameters
-+    ----------
-+        psi : qobj
-+              a state vector or density matrix.
-+        j : int
-+            the total angular momentum of the quantum state.
-+        fullparity : bool
-+                     should the parity of the full SU space be used?
-+        steps : int
-+                number of points at which the Wigner transform is calculated.
-+        slicearray : list of str
-+                     the angle slice to be used for each particle in case of a
-+                     multi-particle quantum state. 'l' yields an equal angle
-+                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
-+
-+    Returns
-+    ----------
-+        wigner : list of float
-+                 the wigner transformation at `steps` different theta and phi.
-+
-+    Raises
-+    ------
-+    ComplexWarning
-+        This can be ignored as it is caused due to rounding errors.
-+
-+    Notes
-+    ------
-+    See example notebook wigner_visualisation.
-+
-+    References
-+    ------
-+    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
-+        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
-+    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
-+        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
-+    """
-+    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
-+        raise TypeError('Input state is not a valid operator.')
-+
-+    if psi.isket or psi.isbra:
-+        rho = psi.proj()
-+    else:
-+        rho = psi
-+
-+    sun = 2   # The order of the SU group
-+
-+    # calculate total number of particles in quantum state:
-+    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
-+
-+    theta = np.zeros((N, steps))
-+    phi = np.zeros((N, steps))
-+
-+    for i in range(N):
-+        theta[i, :] = np.linspace(0, np.pi, steps)
-+        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
-+
-+    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
-+
-+    wigner = np.zeros((steps, steps))
-+    if fullparity:
-+        pari = _parity(sun**N, j)
-+    else:
-+        pari = _parity(sun, j)
-+    for t in range(steps):
-+        for p in range(steps):
-+            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
-+            kernel = _data.dense.fast_from_numpy(kernel)
-+            wigner[t, p] = _data.expect(rho.data, kernel).real
-+    return wigner
-+
-+
-+def _parity(N, j):
-+    """Private function to calculate the parity of the quantum system.
-+    """
-+    if j == 0.5:
-+        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
-+        return pi / N
-+    elif j > 0.5:
-+        mult = np.int32(2 * j + 1)
-+        matrix = np.zeros((mult, mult))
-+        foo = np.ones(mult)
-+        for n in np.arange(-j, j + 1, 1):
-+            for l in np.arange(0, mult, 1):
-+                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
-+            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
-+        return matrix / mult
-+
-+
-+def _lambda_f(N):
-+    """Private function needed for the calculation of the parity.
-+    """
-+    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
-+    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
-+    return matrix
-+
-+
-+def _kernelsu2(theta, phi, N, j, parity, fullparity):
-+    """Private function that calculates the kernel for the SU2 unitary group.
-+    """
-+    U = np.ones(1)
-+    # calculate the total rotation matrix (tensor product for each particle):
-+    for i in range(0, N):
-+        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
-+    if not fullparity:
-+        op_parity = parity   # The parity for a one particle system
-+        for i in range(1, N):
-+            parity = np.kron(parity, op_parity)
-+    matrix = U @ parity @ U.conj().T
-+    return matrix
-+
-+
-+def _rotation_matrix(theta, phi, j):
-+    """Private function to calculate the rotation operator for the SU2 kernel.
-+    """
-+    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
-+           la.expm(1j * theta * jmat(j, 'y').full())
-+
-+
-+def _angle_slice(slicearray, theta, phi):
-+    """Private function to modify theta and phi for angle slicing.
-+    """
-+    xind = np.where(slicearray == 'x')
-+    theta[xind, :] = np.pi - theta[xind, :]
-+    phi[xind, :] = -phi[xind, :]
-+    yind = np.where(slicearray == 'y')
-+    theta[yind, :] = np.pi - theta[yind, :]
-+    phi[yind, :] = np.pi - phi[yind, :]
-+    zind = np.where(slicearray == 'z')
-+    phi[zind, :] = phi[zind, :] + np.pi
-+    return theta, phi
-+
-+
-+def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
-+           sparse=False, parfor=False):
-+    """Wigner function for a state vector or density matrix at points
-+    `xvec + i * yvec`.
-+
-+    Parameters
-+    ----------
-+
-+    state : qobj
-+        A state vector or density matrix.
-+
-+    xvec : array_like
-+        x-coordinates at which to calculate the Wigner function.
-+
-+    yvec : array_like
-+        y-coordinates at which to calculate the Wigner function.  Does not
-+        apply to the 'fft' method.
-+
-+    g : float
-+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-+        The value of `g` is related to the value of `hbar` in the commutation
-+        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
-+        value `hbar=1`.
-+
-+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-+        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
-+        and 'iterative' use an iterative method to evaluate the Wigner functions for density
-+        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
-+        in scipy for the same task. The 'fft' method evaluates the Fourier
-+        transform of the density matrix. The 'iterative' method is default, and
-+        in general recommended, but the 'laguerre' method is more efficient for
-+        very sparse density matrices (e.g., superpositions of Fock states in a
-+        large Hilbert space). The 'clenshaw' method is the preferred method for
-+        dealing with density matrices that have a large number of excitations
-+        (>~50). 'clenshaw' is a fast and numerically stable method.
-+
-+    sparse : bool {False, True}
-+        Tells the default solver whether or not to keep the input density
-+        matrix in sparse format.  As the dimensions of the density matrix
-+        grow, setthing this flag can result in increased performance.
-+
-+    parfor : bool {False, True}
-+        Flag for calculating the Laguerre polynomial based Wigner function
-+        method='laguerre' in parallel using the parfor function.
-+
-+
-+    Returns
-+    -------
-+
-+    W : array
-+        Values representing the Wigner function calculated over the specified
-+        range [xvec,yvec].
-+
-+    yvex : array
-+        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
-+        transform.
-+
-+    Notes
-+    -----
-+    The 'fft' method accepts only an xvec input for the x-coordinate.
-+    The y-coordinates are calculated internally.
-+
-+    References
-+    ----------
-+
-+    Ulf Leonhardt,
-+    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
-+
-+    """
-+
-+    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
-+        raise TypeError('Input state is not a valid operator.')
-+
-+    if method == 'fft':
-+        return _wigner_fourier(psi, xvec, g)
-+
-+    if psi.isket or psi.isbra:
-+        rho = psi.proj()
-+    else:
-+        rho = psi
-+
-+    if method == 'iterative':
-+        return _wigner_iterative(rho, xvec, yvec, g)
-+
-+    elif method == 'laguerre':
-+        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
-+
-+    elif method == 'clenshaw':
-+        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
-+
-+    else:
-+        raise TypeError(
-+            "method must be either 'iterative', 'laguerre', or 'fft'.")
-+
-+
-+def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
-+    r"""
-+    Using an iterative method to evaluate the wigner functions for the Fock
-+    state :math:`|m><n|`.
-+
-+    The Wigner function is calculated as
-+    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
-+    function for the density matrix :math:`|m><n|`.
-+
-+    In this implementation, for each row m, Wlist contains the Wigner functions
-+    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
-+    calculated, the corresponding contribution is added to the total Wigner
-+    function, weighted by the corresponding element in the density matrix
-+    :math:`rho_{mn}`.
-+    """
-+
-+    M = np.prod(rho.shape[0])
-+    X, Y = meshgrid(xvec, yvec)
-+    A = 0.5 * g * (X + 1.0j * Y)
-+
-+    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
-+    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
-+
-+    W = real(rho[0, 0]) * real(Wlist[0])
-+    for n in range(1, M):
-+        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
-+        W += 2 * real(rho[0, n] * Wlist[n])
-+
-+    for m in range(1, M):
-+        temp = copy(Wlist[m])
-+        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
-+
-+        # Wlist[m] = Wigner function for |m><m|
-+        W += real(rho[m, m] * Wlist[m])
-+
-+        for n in range(m + 1, M):
-+            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
-+            temp = copy(Wlist[n])
-+            Wlist[n] = temp2
-+
-+            # Wlist[n] = Wigner function for |m><n|
-+            W += 2 * real(rho[m, n] * Wlist[n])
-+
-+    return 0.5 * W * g ** 2
-+
-+
-+def _wigner_laguerre(rho, xvec, yvec, g, parallel):
-+    r"""
-+    Using Laguerre polynomials from scipy to evaluate the Wigner function for
-+    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
-+    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
-+    """
-+
-+    M = np.prod(rho.shape[0])
-+    X, Y = meshgrid(xvec, yvec)
-+    A = 0.5 * g * (X + 1.0j * Y)
-+    W = zeros(np.shape(A))
-+
-+    # compute wigner functions for density matrices |m><n| and
-+    # weight by all the elements in the density matrix
-+    B = 4 * abs(A) ** 2
-+    if sp.isspmatrix_csr(rho.data):
-+        # for compress sparse row matrices
-+        if parallel:
-+            iterator = (
-+                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
-+            W1_out = parallel_map(_par_wig_eval, iterator)
-+            W += sum(W1_out)
-+        else:
-+            for m in range(len(rho.data.indptr) - 1):
-+                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
-+                    n = rho.data.indices[jj]
-+
-+                    if m == n:
-+                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-+
-+                    elif n > m:
-+                        W += 2.0 * real(rho[m, n] * (-1) ** m *
-+                                        (2 * A) ** (n - m) *
-+                                        sqrt(factorial(m) / factorial(n)) *
-+                                        genlaguerre(m, n - m)(B))
-+    else:
-+        # for dense density matrices
-+        B = 4 * abs(A) ** 2
-+        for m in range(M):
-+            if abs(rho[m, m]) > 0.0:
-+                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-+            for n in range(m + 1, M):
-+                if abs(rho[m, n]) > 0.0:
-+                    W += 2.0 * real(rho[m, n] * (-1) ** m *
-+                                    (2 * A) ** (n - m) *
-+                                    sqrt(factorial(m) / factorial(n)) *
-+                                    genlaguerre(m, n - m)(B))
-+
-+    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
-+
-+
-+def _par_wig_eval(args):
-+    """
-+    Private function for calculating terms of Laguerre Wigner function
-+    using parfor.
-+    """
-+    m, rho, A, B = args
-+    W1 = zeros(np.shape(A))
-+    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
-+        n = rho.data.indices[jj]
-+
-+        if m == n:
-+            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-+
-+        elif n > m:
-+            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
-+                             (2 * A) ** (n - m) *
-+                             sqrt(factorial(m) / factorial(n)) *
-+                             genlaguerre(m, n - m)(B))
-+    return W1
-+
-+
-+def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
-+    """
-+    Evaluate the Wigner function via the Fourier transform.
-+    """
-+    if psi.type == 'bra':
-+        psi = psi.dag()
-+    if psi.type == 'ket':
-+        return _psi_wigner_fft(psi.full(), xvec, g)
-+    elif psi.type == 'oper':
-+        eig_vals, eig_vecs = eigh(psi.full())
-+        W = 0
-+        for ii in range(psi.shape[0]):
-+            W1, yvec = _psi_wigner_fft(
-+                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
-+            W += eig_vals[ii] * W1
-+        return W, yvec
-+
-+
-+def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
-+    """
-+    FFT method for a single state vector.  Called multiple times when the
-+    input is a density matrix.
-+    """
-+    n = len(psi)
-+    A = _osc_eigen(n, xvec * g / np.sqrt(2))
-+    xpsi = np.dot(psi.T, A)
-+    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
-+    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
-+
-+
-+def _wigner_fft(psi, xvec):
-+    """
-+    Evaluates the Fourier transformation of a given state vector.
-+    Returns the corresponding density matrix and range
-+    """
-+    n = 2*len(psi.T)
-+    r1 = np.concatenate((np.array([[0]]),
-+                        np.fliplr(psi.conj()),
-+                        np.zeros((1, n//2 - 1))), axis=1)
-+    r2 = np.concatenate((np.array([[0]]), psi,
-+                        np.zeros((1, n//2 - 1))), axis=1)
-+    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
-+        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
-+    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
-+    w = ft.fft(w)
-+    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
-+    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
-+    w = w / (p[1] - p[0]) / n
-+    return w, p
-+
-+
-+def _osc_eigen(N, pnts):
-+    """
-+    Vector of and N-dim oscillator eigenfunctions evaluated
-+    at the points in pnts.
-+    """
-+    pnts = np.asarray(pnts)
-+    lpnts = len(pnts)
-+    A = np.zeros((N, lpnts))
-+    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
-+    if N == 1:
-+        return A
-+    else:
-+        A[1, :] = np.sqrt(2) * pnts * A[0, :]
-+        for k in range(2, N):
-+            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
-+                np.sqrt((k - 1.0) / k) * A[k - 2, :]
-+        return A
-+
-+
-+def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
-+    r"""
-+    Using Clenshaw summation - numerically stable and efficient
-+    iterative algorithm to evaluate polynomial series.
-+
-+    The Wigner function is calculated as
-+    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
-+    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
-+    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
-+    """
-+
-+    M = np.prod(rho.shape[0])
-+    X,Y = np.meshgrid(xvec, yvec)
-+    #A = 0.5 * g * (X + 1.0j * Y)
-+    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
-+
-+    B = np.abs(A2)
-+    B *= B
-+    w0 = (2*rho[0, -1])*np.ones_like(A2)
-+    L = M-1
-+    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
-+    #using Horner's method
-+    if not sparse:
-+        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
-+        while L > 0:
-+            L -= 1
-+            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
-+            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
-+    else:
-+        # TODO: fix dispatch.
-+        _rho = _data.to(_data.CSR, rho.data).as_scipy()
-+        while L > 0:
-+            L -= 1
-+            diag = _rho.diagonal(L)
-+            if L != 0:
-+                diag *= 2
-+            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
-+            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
-+
-+    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
-+
-+
-+def _wig_laguerre_val(L, x, c):
-+    r"""
-+    this is evaluation of polynomial series inspired by hermval from numpy.
-+    Returns polynomial series
-+
-+    .. math:
-+        \sum_n b_n LL_n^L,
-+
-+    where
-+
-+    .. math:
-+        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
-+
-+    The evaluation uses Clenshaw recursion.
-+    """
-+
-+    if len(c) == 1:
-+        y0 = c[0]
-+        y1 = 0
-+    elif len(c) == 2:
-+        y0 = c[0]
-+        y1 = c[1]
-+    else:
-+        k = len(c)
-+        y0 = c[-2]
-+        y1 = c[-1]
-+        for i in range(3, len(c) + 1):
-+            k -= 1
-+            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
-+            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
-+
-+    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
-+
-+
-+# -----------------------------------------------------------------------------
-+# Q FUNCTION
-+#
-+def _qfunc_check_state(state: Qobj):
-+    if not isinstance(state, Qobj):
-+        raise TypeError(f"state must be Qobj, but is {state}")
-+    # This is only approximate, but it's enough for our purposes; doing more
-+    # than this would take computational effort we don't _need_ to do.
-+    isdm = (
-+        state.isoper
-+        and state.dims[0] == state.dims[1]
-+        and state.isherm
-+        and abs(state.tr() - 1) < qutip.settings.core['atol']
-+    )
-+    if not (state.isket or isdm):
-+        raise ValueError(
-+            f"state must be a ket or density matrix, but is {state}"
-+        )
-+    if len(state.dims[0]) != 1:
-+        raise ValueError(
-+            "state must not have tensor structure, but has dimensions:"
-+            f" {state.dims}"
-+        )
-+    return state
-+
-+
-+def _qfunc_check_coordinates(xvec, yvec):
-+    if np.isscalar(xvec) or xvec is None:
-+        raise TypeError("xvec must be array-like, but is " + repr(xvec))
-+    if np.isscalar(yvec) or yvec is None:
-+        raise TypeError("yvec must be array-like, but is " + repr(yvec))
-+    xvec = np.asarray(xvec, dtype=np.float64)
-+    yvec = np.asarray(yvec, dtype=np.float64)
-+    if xvec.ndim != 1 or yvec.ndim != 1:
-+        raise ValueError(
-+            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
-+        )
-+    return xvec, yvec
-+
-+
-+class _QFuncCoherentGrid:
-+    """
-+    Internal function to compute coherent state operators corresponding to a
-+    grid of complex values in phase space.  For efficiency reasons, this class
-+    produces the adjoint of the coherent states, to save allocations when
-+    calculating inner products later.
-+
-+    Examples
-+    --------
-+    Initialise the grid calculator.
-+
-+    >>> xvec = yvec = np.linspace(-1, 1, 21)
-+    >>> g = np.sqrt(0.5)
-+    >>> max_ns = 10
-+    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
-+
-+    The naive construction of the grid is
-+
-+    >>> xs, ys = np.meshgrid(xvec, yvec)
-+    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
-+    >>> naive = np.array([
-+    ...     [
-+    ...         qutip.coherent(max_ns, alpha, method='analytic')
-+    ...             .dag().full().ravel()
-+    ...         for alpha in x_alphas
-+    ...     ]
-+    ...     for y_alphas in all_alphas
-+    ... ])
-+
-+    The naive approach is typically several of orders of magnitude slower than
-+    this class, which uses much simpler vectorised operations.  The outputs are
-+    within close tolerance, however:
-+
-+    >>> np.allclose(naive, grid(max_ns))
-+    True
-+    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
-+    True
-+    """
-+    def __init__(self, xvec, yvec, g: float):
-+        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
-+        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
-+        self.grid = np.empty(x.shape, dtype=np.complex128)
-+        self.grid.real = x
-+        # We produce the adjoint of the coherent states to save an operation
-+        # later when computing dot products, hence the negative imaginary part.
-+        self.grid.imag = -y
-+        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
-+
-+    def _start(self, first: int):
-+        """
-+        Get the coherent state matrix corresponding to the first needed Fock
-+        state.
-+        """
-+        if first == 0:
-+            return self.prefactor.copy()
-+        out = np.power(self.grid, first)
-+        out *= self.prefactor
-+        return out
-+
-+    def __call__(self, first: int, last: int = None):
-+        """
-+        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
-+        coherent-state vectors for all the Fock states in the range ``first``
-+        to ``last``, excluding the end point.  The first two axes are the y-
-+        and x-coordinates of phase space (i.e. Cartesian indexing, like
-+        ``numpy.meshgrid``), and the last runs over the selected range of
-+        Fock-space dimensions.
-+        """
-+        ns = np.arange(first, last).reshape(1, 1, -1)
-+        # Technically we could avoid hitting the limits of floating-point
-+        # exponents for longer by doing all this in logarithmic space (using
-+        # scipy.special.gammaln), but that ends up involving more
-+        # floating-point operations overall, and needs special care around the
-+        # point alpha = 0 to avoid nan appearing, due to how Python handles
-+        # mixed-width arithmetic operations.
-+        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
-+        out[:, :, 0] = self._start(ns.flat[0])
-+        for i in range(ns.size - 1):
-+            out[:, :, i+1] = out[:, :, i] * self.grid
-+        out /= np.sqrt(scipy.special.factorial(ns))
-+        return out
-+
-+
-+class QFunc:
-+    r"""
-+    Class-based method of calculating the Husimi-Q function of many different
-+    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
-+    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
-+    subsequent operations will be several times faster. However, it can require
-+    quite a lot of memory. Call the created object as a function to retrieve
-+    the Husimi-Q function.
-+
-+    Parameters
-+    ----------
-+    xvec, yvec : array_like
-+        x- and y-coordinates at which to calculate the Husimi-Q function.
-+
-+    g : float, default sqrt(2)
-+        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
-+        related to the value of `hbar` in the commutation relation
-+        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
-+        corresponds to :math:`\hbar=1`.
-+
-+    memory : real, default 1024
-+        Size in MB that may be used internally as workspace.  This class will
-+        raise ``MemoryError`` if subsequently passed a state of sufficiently
-+        large dimension that this bound would be exceeded.  In those cases, use
-+        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
-+        the slower, more memory-efficient algorithm.
-+
-+    Examples
-+    --------
-+    Initialise the class for a square set of coordinates, with some states we
-+    want to investigate.
-+
-+    >>> xvec = np.linspace(-2, 2, 101)
-+    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
-+    >>> qfunc = qutip.QFunc(xvec, xvec)
-+
-+    Now we can calculate the Husimi-Q function over each of the states more
-+    efficiently with:
-+
-+    >>> husimiq = np.array([qfunc(state) for state in states])
-+
-+    See Also
-+    --------
-+    :obj:`.qfunc` :
-+        a single function version, which will involve computing several
-+        quantities multiple times in order to use less memory.
-+    """
-+
-+    def __init__(
-+        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
-+    ):
-+        self._g = g
-+        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
-+        # 16 bytes per complex, 1024**2 bytes per MB.
-+        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
-+        self._memory_mb = memory
-+        self._max_size = int(self._memory_mb // self._size_mb)
-+        self._current_size = 0
-+        self._cache = None
-+
-+    def _alphas(self, size: int):
-+        r"""
-+        Retrive the full tensor of (the conjugate of) coherent states over all
-+        values of :math:`\alpha`, for states of dimension ``size``.
-+        """
-+        if self._current_size >= size:
-+            return self._cache[:, :, :size]
-+        if size > self._max_size:
-+            requirement = self._size_mb * size
-+            raise MemoryError(
-+                f"Refusing to precompute up to {size} basis states."
-+                f" This would require {requirement:.2f} MB,"
-+                f" but only {self._memory_mb} MB is allowed."
-+            )
-+        if self._cache is None:
-+            self._cache = self._coherent_grid(self._current_size, size)
-+        else:
-+            self._cache = np.dstack(
-+                [self._cache, self._coherent_grid(self._current_size, size)]
-+            )
-+        self._current_size = size
-+        return self._cache
-+
-+    def _single(self, vector: np.ndarray, alphas: np.ndarray):
-+        r"""
-+        Get the Q function (without the :math:`\pi` scaling factor) of a single
-+        state vector.
-+        """
-+        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
-+
-+    def __call__(self, state: Qobj):
-+        """
-+        Get the Husimi-Q function for the given state vector or density matrix,
-+        over the coordinates used to initialise the class.  If called multiple
-+        times, the states do not need to have the same dimensions, but none of
-+        them can have tensor-product structure.
-+        """
-+        state = _qfunc_check_state(state)
-+        alphas = self._alphas(state.shape[0])
-+        if state.isket:
-+            return self._single(state.full().ravel(), alphas) / np.pi
-+        # We don't use Qobj.eigenstates() to avoid building many unnecessary
-+        # CSR versions of dense matrices.
-+        values, vectors = eigh(state.full())
-+        vectors = vectors.T
-+        out = values[0] * self._single(vectors[0], alphas)
-+        for value, vector in zip(values[1:], vectors[1:]):
-+            out += value * self._single(vector, alphas)
-+        return out / np.pi
-+
-+
-+def _qfunc_iterative_single(
-+    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
-+):
-+    r"""
-+    Get the Q function (without the :math:`\pi` scaling factor) of a single
-+    state vector, using the iterative algorithm which recomputes the powers of
-+    the coherent-state matrix.
-+    """
-+    ns = np.arange(vector.shape[0])
-+    out = np.polyval(
-+        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
-+        alpha_grid.grid,
-+    )
-+    out *= alpha_grid.prefactor
-+    return np.abs(out)**2
-+
-+
-+def qfunc(
-+    state: Qobj,
-+    xvec,
-+    yvec,
-+    g: float = sqrt(2),
-+    precompute_memory: float = 1024,
-+):
-+    r"""
-+    Husimi-Q function of a given state vector or density matrix at phase-space
-+    points ``0.5 * g * (xvec + i*yvec)``.
-+
-+    Parameters
-+    ----------
-+    state : :obj:`.Qobj`
-+        A state vector or density matrix.  This cannot have tensor-product
-+        structure.
-+
-+    xvec, yvec : array_like
-+        x- and y-coordinates at which to calculate the Husimi-Q function.
-+
-+    g : float, default sqrt(2)
-+        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
-+        related to the value of :math:`\hbar` in the commutation relation
-+        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
-+        corresponds to :math:`\hbar=1`.
-+
-+    precompute_memory : real, default 1024
-+        Size in MB that may be used during calculations as working space when
-+        dealing with density-matrix inputs.  This is ignored for state-vector
-+        inputs.  The bound is not quite exact due to other, order-of-magnitude
-+        smaller, intermediaries being necessary, but is a good approximation.
-+        If you want to use the same iterative algorithm for density matrices
-+        that is used for single kets, set ``precompute_memory=None``.
-+
-+    Returns
-+    -------
-+    ndarray
-+        Values representing the Husimi-Q function calculated over the specified
-+        range ``[xvec, yvec]``.
-+
-+    See Also
-+    --------
-+    :obj:`.QFunc` :
-+        a class-based version, more efficient if you want to calculate the
-+        Husimi-Q function for several states over the same coordinates.
-+    """
-+    state = _qfunc_check_state(state)
-+    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
-+    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
-+    enough_memory = (
-+        precompute_memory is not None
-+        and precompute_memory > required_memory
-+    )
-+    if state.isoper and enough_memory:
-+        return QFunc(xvec, yvec, g)(state)
-+    if precompute_memory is not None and state.isoper:
-+        warnings.warn(
-+            "Falling back to iterative algorithm due to lack of memory."
-+            f" Needed {required_memory:.2f} MB, but only allowed to use"
-+            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
-+            " raise limit, or set to `None` to suppress warning."
-+        )
-+    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
-+    if state.isket:
-+        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
-+        out /= np.pi
-+        return out
-+    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
-+    # versions of dense matrices.
-+    values, vectors = eigh(state.full())
-+    vectors = vectors.T
-+    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
-+    for value, vector in zip(values[1:], vectors[1:]):
-+        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
-+    out /= np.pi
-+    return out
-+
-+
-+# -----------------------------------------------------------------------------
-+# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
-+#
-+def spin_q_function(rho, theta, phi):
-+    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
-+    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
-+    j, theta, phi)`` where j is the spin length.
-+    The implementation here is more efficient as it doesn't
-+    generate all of the SCS at theta and phi (see references).
-+
-+    The spin Q function is normal when integrated over the surface of the
-+    sphere
-+
-+    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
-+              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
-+
-+    Parameters
-+    ----------
-+    state : qobj
-+        A state vector or density matrix for a spin-j quantum system.
-+    theta : array_like
-+        Polar (colatitude) angle at which to calculate the Husimi-Q function.
-+    phi : array_like
-+        Azimuthal angle at which to calculate the Husimi-Q function.
-+
-+    Returns
-+    -------
-+    Q, THETA, PHI : 2d-array
-+        Values representing the spin Husimi Q function at the values specified
-+        by THETA and PHI.
-+
-+    References
-+    ----------
-+    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
-+    https://doi.org/10.1119/1.4898595
-+
-+    """
-+
-+    if rho.isket or rho.isbra:
-+        rho = rho.proj()
-+
-+    J = rho.shape[0]
-+    j = (J - 1) / 2
-+
-+    THETA, PHI = meshgrid(theta, phi)
-+
-+    Q = np.zeros_like(THETA, dtype=complex)
-+    data = rho.full()
-+
-+    for m1 in arange(-j, j + 1):
-+        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
-+             sin(THETA / 2) ** (2 * (j - m1)) * \
-+             data[int(j - m1), int(j - m1)]
-+
-+        for m2 in arange(m1 + 1, j + 1):
-+            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
-+                  cos(THETA / 2) ** (2 * j + m1 + m2) *
-+                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
-+             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
-+              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
-+
-+    return Q.real, THETA, PHI
-+
-+
-+def _rho_kq(rho, j, k, q):
-+    """
-+    This calculates the trace of the multipole operator T_kq and the density
-+    matrix rho for use in the spin Wigner quasiprobability distribution.
-+
-+    Parameters
-+    ----------
-+    rho : qobj
-+        A density matrix for a spin-j quantum system.
-+    j : float
-+        The spin length of the system.
-+    k : int
-+        Spherical harmonic degree
-+    q : int
-+        Spherical harmonic order
-+
-+    Returns
-+    -------
-+    v : float
-+        Overlap of state with multipole operator T_kq
-+    """
-+
-+    v = 0j
-+    data = rho.full()
-+    for m1 in arange(-j, j+1):
-+        for m2 in arange(-j, j+1):
-+            v += (
-+                    (-1) ** (2 * j - k - m1 - m2)
-+                    * np.sqrt((2 * k + 1) / (2 * j + 1))
-+                    * clebsch(j, k, j, -m1, q, -m2)
-+                    * data[int(j - m1), int(j - m2)]
-+            )
-+    return v
-+
-+
-+def spin_wigner(rho, theta, phi):
-+    r"""Wigner function for a spin-j system.
-+
-+    The spin W function is normal when integrated over the surface of the
-+    sphere
-+
-+    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
-+              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
-+
-+
-+    Parameters
-+    ----------
-+    state : qobj
-+        A state vector or density matrix for a spin-j quantum system.
-+    theta : array_like
-+        Polar (colatitude) angle at which to calculate the W function.
-+    phi : array_like
-+        Azimuthal angle at which to calculate the W function.
-+
-+    Returns
-+    -------
-+    W, THETA, PHI : 2d-array
-+        Values representing the spin Wigner function at the values specified
-+        by THETA and PHI.
-+
-+    References
-+    ----------
-+    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
-+    https://doi.org/10.1103/PhysRevA.24.2889
-+
-+    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
-+    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
-+
-+    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
-+    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
-+
-+    """
-+    if rho.isket or rho.isbra:
-+        rho = rho.proj()
-+
-+    J = rho.shape[0]
-+    j = (J - 1) / 2
-+
-+    THETA, PHI = meshgrid(theta, phi)
-+
-+    W = np.zeros_like(THETA, dtype=complex)
-+
-+    for k in range(int(2 * j)+1):
-+        for q in arange(-k, k+1):
-+            # sph_harm takes azimuthal angle then polar angle as arguments
-+            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
-+
-+    return W.real, THETA, PHI
-diff --git a/requirements.txt b/requirements.txt
-index 41d2c09a..ce27f298 100644
---- a/requirements.txt
-+++ b/requirements.txt
-@@ -1,4 +1,4 @@
--cython>=0.29.20
--numpy>=1.16.6
--scipy>=1.5
--packaging
-+cython>=0.29.20
-+numpy>=1.16.6
-+scipy>=1.5
-+packaging
-diff --git a/setup.cfg b/setup.cfg
-index 1eb1f11c..d5d6815f 100644
---- a/setup.cfg
-+++ b/setup.cfg
-@@ -1,70 +1,70 @@
--[metadata]
--name = qutip
--url = https://qutip.org
--description = QuTiP: The Quantum Toolbox in Python
--long_description = file: README.md
--long_description_content_type = text/markdown; variant=GFM
--keywords = quantum, physics, dynamics
--license = BSD 3-Clause License
--license_files = LICENSE.txt
--project_urls =
--    Bug Tracker = https://github.com/qutip/qutip/issues
--    Documentation = https://qutip.org/docs/latest/
--    Source Code = https://github.com/qutip/qutip
--classifiers =
--    Development Status :: 2 - Pre-Alpha
--    Intended Audience :: Science/Research
--    License :: OSI Approved :: BSD License
--    Programming Language :: Python
--    Programming Language :: Python :: 3
--    Topic :: Scientific/Engineering
--    Operating System :: MacOS
--    Operating System :: POSIX
--    Operating System :: Unix
--    Operating System :: Microsoft :: Windows
--author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
--author_email = qutip-admin@googlegroups.com
--platforms = Linux, Mac OSX, Unix, Windows
--
--[options]
--packages = find:
--include_package_data = True
--zip_safe = False
--install_requires =
--    numpy>=1.16.6
--    scipy>=1.0
--    packaging
--setup_requires =
--    numpy>=1.13.3
--    scipy>=1.0
--    cython>=0.29.20
--    packaging
--
--[options.packages.find]
--include = qutip*
--
--[options.extras_require]
--graphics = matplotlib>=1.2.1
--runtime_compilation =
--    cython>=0.29.20
--    filelock
--semidefinite =
--    cvxpy>=1.0
--    cvxopt
--tests =
--    pytest>=5.2
--    pytest-rerunfailures
--ipython =
--    ipython
--extras =
--    loky
--    tqdm
--; This uses ConfigParser's string interpolation to include all the above
--; dependencies into one single target, convenient for testing full builds.
--full =
--    %(graphics)s
--    %(runtime_compilation)s
--    %(semidefinite)s
--    %(tests)s
--    %(ipython)s
--    %(extras)s
-+[metadata]
-+name = qutip
-+url = https://qutip.org
-+description = QuTiP: The Quantum Toolbox in Python
-+long_description = file: README.md
-+long_description_content_type = text/markdown; variant=GFM
-+keywords = quantum, physics, dynamics
-+license = BSD 3-Clause License
-+license_files = LICENSE.txt
-+project_urls =
-+    Bug Tracker = https://github.com/qutip/qutip/issues
-+    Documentation = https://qutip.org/docs/latest/
-+    Source Code = https://github.com/qutip/qutip
-+classifiers =
-+    Development Status :: 2 - Pre-Alpha
-+    Intended Audience :: Science/Research
-+    License :: OSI Approved :: BSD License
-+    Programming Language :: Python
-+    Programming Language :: Python :: 3
-+    Topic :: Scientific/Engineering
-+    Operating System :: MacOS
-+    Operating System :: POSIX
-+    Operating System :: Unix
-+    Operating System :: Microsoft :: Windows
-+author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
-+author_email = qutip-admin@googlegroups.com
-+platforms = Linux, Mac OSX, Unix, Windows
-+
-+[options]
-+packages = find:
-+include_package_data = True
-+zip_safe = False
-+install_requires =
-+    numpy>=1.16.6
-+    scipy>=1.0
-+    packaging
-+setup_requires =
-+    numpy>=1.13.3
-+    scipy>=1.0
-+    cython>=0.29.20
-+    packaging
-+
-+[options.packages.find]
-+include = qutip*
-+
-+[options.extras_require]
-+graphics = matplotlib>=1.2.1
-+runtime_compilation =
-+    cython>=0.29.20
-+    filelock
-+semidefinite =
-+    cvxpy>=1.0
-+    cvxopt
-+tests =
-+    pytest>=5.2
-+    pytest-rerunfailures
-+ipython =
-+    ipython
-+extras =
-+    loky
-+    tqdm
-+; This uses ConfigParser's string interpolation to include all the above
-+; dependencies into one single target, convenient for testing full builds.
-+full =
-+    %(graphics)s
-+    %(runtime_compilation)s
-+    %(semidefinite)s
-+    %(tests)s
-+    %(ipython)s
-+    %(extras)s
-diff --git a/setup.py b/setup.py
-index 0bf5b8de..ddde7658 100755
---- a/setup.py
-+++ b/setup.py
-@@ -1,312 +1,312 @@
--#!/usr/bin/env python
--
--import collections
--import os
--import pathlib
--import subprocess
--import sys
--import sysconfig
--import warnings
--
--# Required third-party imports, must be specified in pyproject.toml.
--import packaging.version
--from setuptools import setup, Extension
--import distutils.sysconfig
--import numpy as np
--from Cython.Build import cythonize
--from Cython.Distutils import build_ext
--
--
--def process_options():
--    """
--    Determine all runtime options, returning a dictionary of the results.  The
--    keys are:
--        'rootdir': str
--            The root directory of the setup.  Almost certainly the directory
--            that this setup.py file is contained in.
--        'release': bool
--            Is this a release build (True) or a local development build (False)
--        'openmp': bool
--            Should we build our OpenMP extensions and attempt to link in OpenMP
--            libraries? (Not supported in this version.)
--        'cflags': list of str
--            Flags to be passed to the C++ compiler.
--        'ldflags': list of str
--            Flags to be passed to the linker.
--        'include': list of str
--            Additional directories to be added to the header files include
--            path.  These files will be detected by Cython as dependencies, so
--            changes to them will trigger recompilation of .pyx files, whereas
--            includes added in 'cflags' as '-I/path/to/include' may not.
--    """
--    options = {}
--    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
--    options = _determine_user_arguments(options)
--    options = _determine_version(options)
--    options = _determine_compilation_options(options)
--    options = _determine_cythonize_options(options)
--    return options
--
--
--def _get_environment_bool(var, default=False):
--    """
--    Get a boolean value from the environment variable `var`.  This evalutes to
--    `default` if the environment variable is not present.  The false-y values
--    are '0', 'false', 'none' and empty string, insensitive to case.  All other
--    values are truth-y.
--    """
--    from_env = os.environ.get(var)
--    if from_env is None:
--        return default
--    return from_env.lower() not in {'0', 'false', 'none', ''}
--
--
--def _parse_bool_user_argument(options, name):
--    """
--    Parse a single boolean option from the commandline or environment.
--    """
--    cmd_flag = "--with-" + name.lower().replace("_", "-")
--    env_var = "CI_QUTIP_WITH_" + name.upper()
--    options[name] = (
--        cmd_flag in sys.argv
--        or _get_environment_bool(env_var)
--    )
--    if cmd_flag in sys.argv:
--        sys.argv.remove(cmd_flag)
--    return options
--
--
--def _determine_user_arguments(options):
--    """
--    Add the 'openmp' option to the collection, based on the passed command-line
--    arguments or environment variables.
--
--    If using PEP517 builds, one can pass these options on the command-line
--    using, for example:
--
--        python -m build \
--            --wheel \
--            --config-setting="--global-option=--with-openmp"
--    """
--    # options = _parse_bool_user_argument(options, 'openmp')
--    options['openmp'] = False  # Not supported yet
--    options = _parse_bool_user_argument(options, 'idxint_64')
--    return options
--
--
--def _determine_compilation_options(options):
--    """
--    Add additional options specific to C/C++ compilation.  These are 'cflags',
--    'ldflags' and 'include'.
--    """
--    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
--    # process uses in addition to user-specified ones; the flag is not valid
--    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
--    config = distutils.sysconfig.get_config_vars()
--    if "CFLAGS" in config:
--        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
--    options['cflags'] = []
--    options['ldflags'] = []
--    options['include'] = [np.get_include()]
--    if (
--        sysconfig.get_platform().startswith("win")
--        and os.environ.get('MSYSTEM') is None
--    ):
--        # Visual Studio
--        options['cflags'].extend(['/w', '/Ox'])
--        if options['openmp']:
--            options['cflags'].append('/openmp')
--    else:
--        # Everything else
--        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
--        if options['openmp']:
--            options['cflags'].append('-fopenmp')
--            options['ldflags'].append('-fopenmp')
--    if sysconfig.get_platform().startswith("macos"):
--        # These are needed for compiling on OSX 10.14+
--        options['cflags'].append('-mmacosx-version-min=10.9')
--        options['ldflags'].append('-mmacosx-version-min=10.9')
--        if options['openmp']:
--            options['cflags'].append('-fopenmp')
--            options['ldflags'].append('-fopenmp')
--    return options
--
--
--def _determine_cythonize_options(options):
--    options["annotate"] = False
--    if "--annotate" in sys.argv:
--        options["annotate"] = True
--        sys.argv.remove("--annotate")
--    if "-a" in sys.argv:
--        options["annotate"] = True
--        sys.argv.remove("-a")
--    return options
--
--
--def _determine_version(options):
--    """
--    Adds the 'short_version', 'version' and 'release' options.
--
--    Read from the VERSION file to discover the version.  This should be a
--    single line file containing valid Python package public identifier (see PEP
--    440), for example
--      4.5.2rc2
--      5.0.0
--      5.1.1a1
--    We do that here rather than in setup.cfg so we can apply the local
--    versioning number as well.
--    """
--    version_filename = os.path.join(options['rootdir'], 'VERSION')
--    with open(version_filename, "r") as version_file:
--        version_string = version_file.read().strip()
--    version = packaging.version.Version(version_string)
--    options['short_version'] = str(version.public)
--    options['release'] = not version.is_devrelease
--    if not options['release']:
--        # Put the version string into canonical form, if it wasn't already.
--        version_string = str(version)
--        version_string += "+"
--        try:
--            git_out = subprocess.run(
--                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
--                check=True,
--                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
--            )
--            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
--            version_string += git_hash or "nogit"
--        # CalledProcessError is for if the git command fails for internal
--        # reasons (e.g. we're not in a git repository), OSError is for if
--        # something goes wrong when trying to run git (e.g. it's not installed,
--        # or a permission error).
--        except (subprocess.CalledProcessError, OSError):
--            version_string += "nogit"
--    options['version'] = version_string
--    return options
--
--
--def create_version_py_file(options):
--    """
--    Generate and write out the file qutip/version.py, which is used to produce
--    the '__version__' information for the module.  This function will overwrite
--    an existing file at that location.
--    """
--    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
--    content = "\n".join([
--        f"# This file is automatically generated by QuTiP's setup.py.",
--        f"short_version = '{options['short_version']}'",
--        f"version = '{options['version']}'",
--        f"release = {options['release']}",
--    ])
--    with open(filename, 'w') as file:
--        print(content, file=file)
--
--
--def _extension_extra_sources():
--    """
--    Get a mapping of {module: extra_sources} for all modules to be built.  The
--    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
--    and extra_sources is a list of strings of relative paths to files.  If no
--    extra sources are known for a given module, the mapping will return an
--    empty list.
--    """
--    # For typing brevity we specify sources in Unix-style string form, then
--    # normalise them into the OS-specific form later.
--    extra_sources = {
--        'qutip.core.data.matmul': [
--            'qutip/core/data/src/matmul_csr_vector.cpp',
--        ],
--    }
--    out = collections.defaultdict(list)
--    for module, sources in extra_sources.items():
--        # Normalise the sources into OS-specific form.
--        out[module] = [str(pathlib.Path(source)) for source in sources]
--    return out
--
--
--def _create_int_type_file(options):
--    """
--    Create the `data/src/intdtype.h` file.
--    """
--    if options['idxint_64']:
--        typedef = "typedef int64_t idxint;\n"
--        typedef += "int _idxint_size=64;\n"
--    else:
--        typedef = "typedef int32_t idxint;\n"
--        typedef += "int _idxint_size=32;\n"
--    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
--    file = os.path.join(path, 'intdtype.h')
--    if os.path.exists(file):
--        with open(file, 'r') as source:
--            if source.read() == typedef:
--                # The file is already existing and the same, nothing to do.
--                return
--
--    with open(file, 'w') as source:
--        source.write(typedef)
--
--
--def create_extension_modules(options):
--    """
--    Discover and Cythonise all extension modules that need to be built.  These
--    are returned so they can be passed into the setup command.
--    """
--    out = []
--    root = pathlib.Path(options['rootdir'])
--    _create_int_type_file(options)
--    pyx_files = set(root.glob('qutip/**/*.pyx'))
--    if not options['openmp']:
--        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
--    extra_sources = _extension_extra_sources()
--    # Add Cython files from qutip
--    for pyx_file in pyx_files:
--        pyx_file = pyx_file.relative_to(root)
--        pyx_file_str = str(pyx_file)
--        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
--            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
--            # Cythonised time-dependent coefficients would get dropped in the
--            # qutip directory if you weren't careful - this is just trying to
--            # minimise the occasional developer error.
--            warnings.warn(
--                "skipping generated time-dependent coefficient: "
--                + pyx_file_str
--            )
--            continue
--        # The module name is the same as the folder structure, but with dots in
--        # place of separators ('/' or '\'), and without the '.pyx' extension.
--        pyx_module = ".".join(pyx_file.parts)[:-4]
--        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
--        out.append(Extension(pyx_module,
--                             sources=pyx_sources,
--                             include_dirs=options['include'],
--                             extra_compile_args=options['cflags'],
--                             extra_link_args=options['ldflags'],
--                             language='c++'))
--    return cythonize(out, annotate=options["annotate"])
--
--
--def print_epilogue():
--    """Display a post-setup epilogue."""
--    longbar = "="*80
--    message = "\n".join([
--        longbar,
--        "Installation complete",
--        "Please cite QuTiP in your publication.",
--        longbar,
--        "For your convenience a BibTeX reference can be easily generated with",
--        "`qutip.cite()`",
--    ])
--    print(message)
--
--
--if __name__ == "__main__":
--    options = process_options()
--    create_version_py_file(options)
--    extensions = create_extension_modules(options)
--    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
--    # keep here are ones that we have done some compile-time processing on.
--    setup(
--        version=options['version'],
--        ext_modules=extensions,
--        cmdclass={'build_ext': build_ext},
--    )
--    print_epilogue()
-+#!/usr/bin/env python
-+
-+import collections
-+import os
-+import pathlib
-+import subprocess
-+import sys
-+import sysconfig
-+import warnings
-+
-+# Required third-party imports, must be specified in pyproject.toml.
-+import packaging.version
-+from setuptools import setup, Extension
-+import distutils.sysconfig
-+import numpy as np
-+from Cython.Build import cythonize
-+from Cython.Distutils import build_ext
-+
-+
-+def process_options():
-+    """
-+    Determine all runtime options, returning a dictionary of the results.  The
-+    keys are:
-+        'rootdir': str
-+            The root directory of the setup.  Almost certainly the directory
-+            that this setup.py file is contained in.
-+        'release': bool
-+            Is this a release build (True) or a local development build (False)
-+        'openmp': bool
-+            Should we build our OpenMP extensions and attempt to link in OpenMP
-+            libraries? (Not supported in this version.)
-+        'cflags': list of str
-+            Flags to be passed to the C++ compiler.
-+        'ldflags': list of str
-+            Flags to be passed to the linker.
-+        'include': list of str
-+            Additional directories to be added to the header files include
-+            path.  These files will be detected by Cython as dependencies, so
-+            changes to them will trigger recompilation of .pyx files, whereas
-+            includes added in 'cflags' as '-I/path/to/include' may not.
-+    """
-+    options = {}
-+    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
-+    options = _determine_user_arguments(options)
-+    options = _determine_version(options)
-+    options = _determine_compilation_options(options)
-+    options = _determine_cythonize_options(options)
-+    return options
-+
-+
-+def _get_environment_bool(var, default=False):
-+    """
-+    Get a boolean value from the environment variable `var`.  This evalutes to
-+    `default` if the environment variable is not present.  The false-y values
-+    are '0', 'false', 'none' and empty string, insensitive to case.  All other
-+    values are truth-y.
-+    """
-+    from_env = os.environ.get(var)
-+    if from_env is None:
-+        return default
-+    return from_env.lower() not in {'0', 'false', 'none', ''}
-+
-+
-+def _parse_bool_user_argument(options, name):
-+    """
-+    Parse a single boolean option from the commandline or environment.
-+    """
-+    cmd_flag = "--with-" + name.lower().replace("_", "-")
-+    env_var = "CI_QUTIP_WITH_" + name.upper()
-+    options[name] = (
-+        cmd_flag in sys.argv
-+        or _get_environment_bool(env_var)
-+    )
-+    if cmd_flag in sys.argv:
-+        sys.argv.remove(cmd_flag)
-+    return options
-+
-+
-+def _determine_user_arguments(options):
-+    """
-+    Add the 'openmp' option to the collection, based on the passed command-line
-+    arguments or environment variables.
-+
-+    If using PEP517 builds, one can pass these options on the command-line
-+    using, for example:
-+
-+        python -m build \
-+            --wheel \
-+            --config-setting="--global-option=--with-openmp"
-+    """
-+    # options = _parse_bool_user_argument(options, 'openmp')
-+    options['openmp'] = False  # Not supported yet
-+    options = _parse_bool_user_argument(options, 'idxint_64')
-+    return options
-+
-+
-+def _determine_compilation_options(options):
-+    """
-+    Add additional options specific to C/C++ compilation.  These are 'cflags',
-+    'ldflags' and 'include'.
-+    """
-+    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
-+    # process uses in addition to user-specified ones; the flag is not valid
-+    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
-+    config = distutils.sysconfig.get_config_vars()
-+    if "CFLAGS" in config:
-+        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
-+    options['cflags'] = []
-+    options['ldflags'] = []
-+    options['include'] = [np.get_include()]
-+    if (
-+        sysconfig.get_platform().startswith("win")
-+        and os.environ.get('MSYSTEM') is None
-+    ):
-+        # Visual Studio
-+        options['cflags'].extend(['/w', '/Ox'])
-+        if options['openmp']:
-+            options['cflags'].append('/openmp')
-+    else:
-+        # Everything else
-+        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
-+        if options['openmp']:
-+            options['cflags'].append('-fopenmp')
-+            options['ldflags'].append('-fopenmp')
-+    if sysconfig.get_platform().startswith("macos"):
-+        # These are needed for compiling on OSX 10.14+
-+        options['cflags'].append('-mmacosx-version-min=10.9')
-+        options['ldflags'].append('-mmacosx-version-min=10.9')
-+        if options['openmp']:
-+            options['cflags'].append('-fopenmp')
-+            options['ldflags'].append('-fopenmp')
-+    return options
-+
-+
-+def _determine_cythonize_options(options):
-+    options["annotate"] = False
-+    if "--annotate" in sys.argv:
-+        options["annotate"] = True
-+        sys.argv.remove("--annotate")
-+    if "-a" in sys.argv:
-+        options["annotate"] = True
-+        sys.argv.remove("-a")
-+    return options
-+
-+
-+def _determine_version(options):
-+    """
-+    Adds the 'short_version', 'version' and 'release' options.
-+
-+    Read from the VERSION file to discover the version.  This should be a
-+    single line file containing valid Python package public identifier (see PEP
-+    440), for example
-+      4.5.2rc2
-+      5.0.0
-+      5.1.1a1
-+    We do that here rather than in setup.cfg so we can apply the local
-+    versioning number as well.
-+    """
-+    version_filename = os.path.join(options['rootdir'], 'VERSION')
-+    with open(version_filename, "r") as version_file:
-+        version_string = version_file.read().strip()
-+    version = packaging.version.Version(version_string)
-+    options['short_version'] = str(version.public)
-+    options['release'] = not version.is_devrelease
-+    if not options['release']:
-+        # Put the version string into canonical form, if it wasn't already.
-+        version_string = str(version)
-+        version_string += "+"
-+        try:
-+            git_out = subprocess.run(
-+                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
-+                check=True,
-+                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-+            )
-+            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
-+            version_string += git_hash or "nogit"
-+        # CalledProcessError is for if the git command fails for internal
-+        # reasons (e.g. we're not in a git repository), OSError is for if
-+        # something goes wrong when trying to run git (e.g. it's not installed,
-+        # or a permission error).
-+        except (subprocess.CalledProcessError, OSError):
-+            version_string += "nogit"
-+    options['version'] = version_string
-+    return options
-+
-+
-+def create_version_py_file(options):
-+    """
-+    Generate and write out the file qutip/version.py, which is used to produce
-+    the '__version__' information for the module.  This function will overwrite
-+    an existing file at that location.
-+    """
-+    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
-+    content = "\n".join([
-+        f"# This file is automatically generated by QuTiP's setup.py.",
-+        f"short_version = '{options['short_version']}'",
-+        f"version = '{options['version']}'",
-+        f"release = {options['release']}",
-+    ])
-+    with open(filename, 'w') as file:
-+        print(content, file=file)
-+
-+
-+def _extension_extra_sources():
-+    """
-+    Get a mapping of {module: extra_sources} for all modules to be built.  The
-+    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
-+    and extra_sources is a list of strings of relative paths to files.  If no
-+    extra sources are known for a given module, the mapping will return an
-+    empty list.
-+    """
-+    # For typing brevity we specify sources in Unix-style string form, then
-+    # normalise them into the OS-specific form later.
-+    extra_sources = {
-+        'qutip.core.data.matmul': [
-+            'qutip/core/data/src/matmul_csr_vector.cpp',
-+        ],
-+    }
-+    out = collections.defaultdict(list)
-+    for module, sources in extra_sources.items():
-+        # Normalise the sources into OS-specific form.
-+        out[module] = [str(pathlib.Path(source)) for source in sources]
-+    return out
-+
-+
-+def _create_int_type_file(options):
-+    """
-+    Create the `data/src/intdtype.h` file.
-+    """
-+    if options['idxint_64']:
-+        typedef = "typedef int64_t idxint;\n"
-+        typedef += "int _idxint_size=64;\n"
-+    else:
-+        typedef = "typedef int32_t idxint;\n"
-+        typedef += "int _idxint_size=32;\n"
-+    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
-+    file = os.path.join(path, 'intdtype.h')
-+    if os.path.exists(file):
-+        with open(file, 'r') as source:
-+            if source.read() == typedef:
-+                # The file is already existing and the same, nothing to do.
-+                return
-+
-+    with open(file, 'w') as source:
-+        source.write(typedef)
-+
-+
-+def create_extension_modules(options):
-+    """
-+    Discover and Cythonise all extension modules that need to be built.  These
-+    are returned so they can be passed into the setup command.
-+    """
-+    out = []
-+    root = pathlib.Path(options['rootdir'])
-+    _create_int_type_file(options)
-+    pyx_files = set(root.glob('qutip/**/*.pyx'))
-+    if not options['openmp']:
-+        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
-+    extra_sources = _extension_extra_sources()
-+    # Add Cython files from qutip
-+    for pyx_file in pyx_files:
-+        pyx_file = pyx_file.relative_to(root)
-+        pyx_file_str = str(pyx_file)
-+        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
-+            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
-+            # Cythonised time-dependent coefficients would get dropped in the
-+            # qutip directory if you weren't careful - this is just trying to
-+            # minimise the occasional developer error.
-+            warnings.warn(
-+                "skipping generated time-dependent coefficient: "
-+                + pyx_file_str
-+            )
-+            continue
-+        # The module name is the same as the folder structure, but with dots in
-+        # place of separators ('/' or '\'), and without the '.pyx' extension.
-+        pyx_module = ".".join(pyx_file.parts)[:-4]
-+        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
-+        out.append(Extension(pyx_module,
-+                             sources=pyx_sources,
-+                             include_dirs=options['include'],
-+                             extra_compile_args=options['cflags'],
-+                             extra_link_args=options['ldflags'],
-+                             language='c++'))
-+    return cythonize(out, annotate=options["annotate"])
-+
-+
-+def print_epilogue():
-+    """Display a post-setup epilogue."""
-+    longbar = "="*80
-+    message = "\n".join([
-+        longbar,
-+        "Installation complete",
-+        "Please cite QuTiP in your publication.",
-+        longbar,
-+        "For your convenience a BibTeX reference can be easily generated with",
-+        "`qutip.cite()`",
-+    ])
-+    print(message)
-+
-+
-+if __name__ == "__main__":
-+    options = process_options()
-+    create_version_py_file(options)
-+    extensions = create_extension_modules(options)
-+    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
-+    # keep here are ones that we have done some compile-time processing on.
-+    setup(
-+        version=options['version'],
-+        ext_modules=extensions,
-+        cmdclass={'build_ext': build_ext},
-+    )
-+    print_epilogue()
diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index fe7c021e26..892c0a651a 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -283,12 +283,6 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
-.. note::
-    While the example code simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
-    allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting the sec_cutoff 
-    parameter to -1. as well as do a partial secular approximation by setting it to a  float. the default value is 0.1
-
-    Note that using the non-secular version may lead to negativity issues.
 
 .. _td-bloch-redfield:
 
diff --git a/pyproject.toml b/pyproject.toml
index c858ef1e37..f854fa46f5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,54 +1,54 @@
-[build-system]
-requires = [
-    "setuptools",
-    "packaging",
-    "wheel",
-    "cython>=0.29.20",
-    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
-    # the recommended way to build against numpy's C API:
-    "oldest-supported-numpy",
-    "scipy>=1.0",
-]
-build-backend = "setuptools.build_meta"
-
-[tool.cibuildwheel]
-manylinux-x86_64-image = "manylinux2014"
-manylinux-i686-image = "manylinux2014"
-# Change in future version to "build"
-build-frontend = "pip"
-
-[[tool.cibuildwheel.overrides]]
-# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
-select = "cp3{6,7}-*"
-manylinux-x86_64-image = "manylinux2010"
-manylinux-i686-image = "manylinux2010"
-
-[tool.towncrier]
-directory = "doc/changes"
-filename = "doc/changelog.rst"
-name = "QuTiP"
-package = "qutip"
-[[tool.towncrier.type]]
-directory = "deprecation"
-name = "Deprecations"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "feature"
-name = "Features"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "bugfix"
-name = "Bug Fixes"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "removal"
-name = "Removals"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "doc"
-name = "Documentation"
-showcontent = true
-[[tool.towncrier.type]]
-directory = "misc"
-name = "Miscellaneous"
-showcontent = true
+[build-system]
+requires = [
+    "setuptools",
+    "packaging",
+    "wheel",
+    "cython>=0.29.20",
+    # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
+    # the recommended way to build against numpy's C API:
+    "oldest-supported-numpy",
+    "scipy>=1.0",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.cibuildwheel]
+manylinux-x86_64-image = "manylinux2014"
+manylinux-i686-image = "manylinux2014"
+# Change in future version to "build"
+build-frontend = "pip"
+
+[[tool.cibuildwheel.overrides]]
+# NumPy and SciPy support manylinux2010 on CPython 3.6 and 3.7
+select = "cp3{6,7}-*"
+manylinux-x86_64-image = "manylinux2010"
+manylinux-i686-image = "manylinux2010"
+
+[tool.towncrier]
+directory = "doc/changes"
+filename = "doc/changelog.rst"
+name = "QuTiP"
+package = "qutip"
+[[tool.towncrier.type]]
+directory = "deprecation"
+name = "Deprecations"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "feature"
+name = "Features"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "bugfix"
+name = "Bug Fixes"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "removal"
+name = "Removals"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "doc"
+name = "Documentation"
+showcontent = true
+[[tool.towncrier.type]]
+directory = "misc"
+name = "Miscellaneous"
+showcontent = true
diff --git a/qutip/__init__.py b/qutip/__init__.py
index fe889959ea..fc7f65b409 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -1,68 +1,68 @@
-import os
-import warnings
-
-import qutip.settings
-from qutip.settings import settings
-import qutip.version
-from qutip.version import version as __version__
-
-# -----------------------------------------------------------------------------
-# Look to see if we are running with OPENMP
-#
-# Set environ variable to determin if running in parallel mode
-# (i.e. in parfor or parallel_map)
-os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-
-
-# -----------------------------------------------------------------------------
-# Check that import modules are compatible with requested configuration
-#
-
-# Check for Matplotlib
-try:
-    import matplotlib
-except ImportError:
-    warnings.warn("matplotlib not found: Graphics will not work.")
-else:
-    del matplotlib
-
-
-# -----------------------------------------------------------------------------
-# Load modules
-#
-
-from .core import *
-from .solver import *
-from .solve import nonmarkov
-import qutip.solve.piqs as piqs
-from .solve.stochastic import *
-
-# graphics
-from .bloch import *
-from .visualization import *
-from .orbital import *
-from .bloch3d import *
-from .matplotlib_utilities import *
-
-# library functions
-from .tomography import *
-from .wigner import *
-from .random_objects import *
-from .simdiag import *
-from .entropy import *
-from .partial_transpose import *
-from .continuous_variables import *
-from .distributions import *
-from .three_level_atom import *
-
-
-# utilities
-from .utilities import *
-from .fileio import *
-from .about import *
-from .cite import *
-
-# -----------------------------------------------------------------------------
-# Clean name space
-#
-del os, warnings
+import os
+import warnings
+
+import qutip.settings
+from qutip.settings import settings
+import qutip.version
+from qutip.version import version as __version__
+
+# -----------------------------------------------------------------------------
+# Look to see if we are running with OPENMP
+#
+# Set environ variable to determin if running in parallel mode
+# (i.e. in parfor or parallel_map)
+os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+
+
+# -----------------------------------------------------------------------------
+# Check that import modules are compatible with requested configuration
+#
+
+# Check for Matplotlib
+try:
+    import matplotlib
+except ImportError:
+    warnings.warn("matplotlib not found: Graphics will not work.")
+else:
+    del matplotlib
+
+
+# -----------------------------------------------------------------------------
+# Load modules
+#
+
+from .core import *
+from .solver import *
+from .solve import nonmarkov
+import qutip.solve.piqs as piqs
+from .solve.stochastic import *
+
+# graphics
+from .bloch import *
+from .visualization import *
+from .orbital import *
+from .bloch3d import *
+from .matplotlib_utilities import *
+
+# library functions
+from .tomography import *
+from .wigner import *
+from .random_objects import *
+from .simdiag import *
+from .entropy import *
+from .partial_transpose import *
+from .continuous_variables import *
+from .distributions import *
+from .three_level_atom import *
+
+
+# utilities
+from .utilities import *
+from .fileio import *
+from .about import *
+from .cite import *
+
+# -----------------------------------------------------------------------------
+# Clean name space
+#
+del os, warnings
diff --git a/qutip/_mkl/__init__.py b/qutip/_mkl/__init__.py
index d3f5a12faa..8b13789179 100644
--- a/qutip/_mkl/__init__.py
+++ b/qutip/_mkl/__init__.py
@@ -1 +1 @@
-
+
diff --git a/qutip/_mkl/spmv.py b/qutip/_mkl/spmv.py
index 909e7b4b49..ac2ca16c28 100644
--- a/qutip/_mkl/spmv.py
+++ b/qutip/_mkl/spmv.py
@@ -1,38 +1,38 @@
-import numpy as np
-from ctypes import POINTER, c_int, c_char, byref
-from numpy.ctypeslib import ndpointer
-import qutip.settings as qset
-zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
-
-
-def mkl_spmv(A, x):
-    """
-    sparse csr_spmv using MKL
-    """
-    m, _ = A.shape
-
-    # Pointers to data of the matrix
-    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
-    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
-    indices = A.indices.ctypes.data_as(POINTER(c_int))
-
-    # Allocate output, using same conventions as input
-    if x.ndim == 1:
-        y = np.empty(m, dtype=np.complex128, order='C')
-    elif x.ndim == 2 and x.shape[1] == 1:
-        y = np.empty((m, 1), dtype=np.complex128, order='C')
-    else:
-        raise Exception('Input vector must be 1D row or 2D column vector')
-
-    # Now call MKL. This returns the answer in the last argument, which shares
-    # memory with y.
-    zcsrgemv(
-        byref(c_char(bytes(b'N'))),
-        byref(c_int(m)),
-        data,
-        indptr,
-        indices,
-        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
-        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
-    )
-    return y
+import numpy as np
+from ctypes import POINTER, c_int, c_char, byref
+from numpy.ctypeslib import ndpointer
+import qutip.settings as qset
+zcsrgemv = qset.mkl_lib.mkl_cspblas_zcsrgemv
+
+
+def mkl_spmv(A, x):
+    """
+    sparse csr_spmv using MKL
+    """
+    m, _ = A.shape
+
+    # Pointers to data of the matrix
+    data = A.data.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C'))
+    indptr = A.indptr.ctypes.data_as(POINTER(c_int))
+    indices = A.indices.ctypes.data_as(POINTER(c_int))
+
+    # Allocate output, using same conventions as input
+    if x.ndim == 1:
+        y = np.empty(m, dtype=np.complex128, order='C')
+    elif x.ndim == 2 and x.shape[1] == 1:
+        y = np.empty((m, 1), dtype=np.complex128, order='C')
+    else:
+        raise Exception('Input vector must be 1D row or 2D column vector')
+
+    # Now call MKL. This returns the answer in the last argument, which shares
+    # memory with y.
+    zcsrgemv(
+        byref(c_char(bytes(b'N'))),
+        byref(c_int(m)),
+        data,
+        indptr,
+        indices,
+        x.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
+        y.ctypes.data_as(ndpointer(np.complex128, ndim=1, flags='C')),
+    )
+    return y
diff --git a/qutip/_mkl/spsolve.py b/qutip/_mkl/spsolve.py
index 82d2266bbd..7a38c5151f 100644
--- a/qutip/_mkl/spsolve.py
+++ b/qutip/_mkl/spsolve.py
@@ -1,405 +1,405 @@
-import sys
-import numpy as np
-import scipy.sparse as sp
-from ctypes import c_int, byref
-from numpy.ctypeslib import ndpointer
-import time
-from qutip.settings import settings as qset
-
-# Load solver functions from mkl_lib
-pardiso = qset.mkl_lib.pardiso
-pardiso_delete = qset.mkl_lib.pardiso_handle_delete
-if sys.maxsize > 2**32: #Running 64-bit
-    pardiso_64 = qset.mkl_lib.pardiso_64
-    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
-
-
-def _pardiso_parameters(hermitian, has_perm,
-                        max_iter_refine,
-                        scaling_vectors,
-                        weighted_matching):
-    iparm = np.zeros(64, dtype=np.int32)
-    iparm[0] = 1  # Do not use default values
-    iparm[1] = 3  # Use openmp nested dissection
-    if has_perm:
-        iparm[4] = 1
-    iparm[7] = max_iter_refine  # Max number of iterative refinements
-    if hermitian:
-        iparm[9] = 8
-    else:
-        iparm[9] = 13
-    if not hermitian:
-        iparm[10] = int(scaling_vectors)
-        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
-    iparm[17] = -1
-    iparm[20] = 1
-    iparm[23] = 1  # Parallel factorization
-    iparm[26] = 0  # Check matrix structure
-    iparm[34] = 1  # Use zero-based indexing
-    return iparm
-
-
-# Set error messages
-pardiso_error_msgs = {
-    '-1': 'Input inconsistant',
-    '-2': 'Out of memory',
-    '-3': 'Reordering problem',
-    '-4':
-        'Zero pivot, numerical factorization or iterative refinement problem',
-    '-5': 'Unclassified internal error',
-    '-6': 'Reordering failed',
-    '-7': 'Diagonal matrix is singular',
-    '-8': '32-bit integer overflow',
-    '-9': 'Not enough memory for OOC',
-    '-10': 'Error opening OOC files',
-    '-11': 'Read/write error with OOC files',
-    '-12': 'Pardiso-64 called from 32-bit library',
-}
-
-
-def _default_solver_args():
-    return {
-        'hermitian': False,
-        'posdef': False,
-        'max_iter_refine': 10,
-        'scaling_vectors': True,
-        'weighted_matching': True,
-        'return_info': False,
-    }
-
-
-class mkl_lu:
-    """
-    Object pointing to LU factorization of a sparse matrix
-    generated by mkl_splu.
-
-    Methods
-    -------
-    solve(b, verbose=False)
-        Solve system of equations using given RHS vector 'b'.
-        Returns solution ndarray with same shape as input.
-
-    info()
-        Returns the statistics of the factorization and
-        solution in the lu.info attribute.
-
-    delete()
-        Deletes the allocated solver memory.
-
-    """
-    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
-                 indptr=None, indices=None, iparm=None, np_iparm=None,
-                 mtype=None, perm=None, np_perm=None, factor_time=None):
-        self._np_pt = np_pt
-        self._dim = dim
-        self._is_complex = is_complex
-        self._data = data
-        self._indptr = indptr
-        self._indices = indices
-        self._iparm = iparm
-        self._np_iparm = np_iparm
-        self._mtype = mtype
-        self._perm = perm
-        self._np_perm = np_perm
-        self._factor_time = factor_time
-        self._solve_time = None
-
-    def solve(self, b, verbose=None):
-        b_shp = b.shape
-        if b.ndim == 2 and b.shape[1] == 1:
-            b = b.ravel()
-            nrhs = 1
-        elif b.ndim == 2 and b.shape[1] != 1:
-            nrhs = b.shape[1]
-            b = b.ravel(order='F')
-        else:
-            b = b.ravel()
-            nrhs = 1
-
-        data_type = np.complex128 if self._is_complex else np.float64
-        if b.dtype != data_type:
-            b = b.astype(np.complex128, copy=False)
-
-        # Create solution array (x) and pointers to x and b
-        x = np.zeros(b.shape, dtype=data_type, order='C')
-        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-
-        error = np.zeros(1, dtype=np.int32)
-        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-        # Call solver
-        _solve_start = time.time()
-        pardiso(
-            self._np_pt,
-            byref(c_int(1)),
-            byref(c_int(1)),
-            byref(c_int(self._mtype)),
-            byref(c_int(33)),
-            byref(c_int(self._dim)),
-            self._data,
-            self._indptr,
-            self._indices,
-            self._np_perm,
-            byref(c_int(nrhs)),
-            self._np_iparm,
-            byref(c_int(0)),
-            np_b,
-            np_x,
-            np_error,
-        )
-        self._solve_time = time.time() - _solve_start
-        if error[0] != 0:
-            raise Exception(pardiso_error_msgs[str(error[0])])
-
-        if verbose:
-            print('Solution Stage')
-            print('--------------')
-            print('Solution time:                  ',
-                  round(self._solve_time, 4))
-            print('Solution memory (Mb):           ',
-                  round(self._iparm[16]/1024, 4))
-            print('Number of iterative refinements:',
-                  self._iparm[6])
-            print('Total memory (Mb):              ',
-                  round(sum(self._iparm[15:17])/1024, 4))
-            print()
-        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
-
-    def info(self):
-        info = {'FactorTime': self._factor_time,
-                'SolveTime': self._solve_time,
-                'Factormem': round(self._iparm[15]/1024, 4),
-                'Solvemem': round(self._iparm[16]/1024, 4),
-                'IterRefine': self._iparm[6]}
-        return info
-
-    def delete(self):
-        # Delete all data
-        error = np.zeros(1, dtype=np.int32)
-        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-        pardiso(
-            self._np_pt,
-            byref(c_int(1)),
-            byref(c_int(1)),
-            byref(c_int(self._mtype)),
-            byref(c_int(-1)),
-            byref(c_int(self._dim)),
-            self._data,
-            self._indptr,
-            self._indices,
-            self._np_perm,
-            byref(c_int(1)),
-            self._np_iparm,
-            byref(c_int(0)),
-            byref(c_int(0)),
-            byref(c_int(0)),
-            np_error,
-        )
-        if error[0] == -10:
-            raise Exception('Error freeing solver memory')
-
-
-_MATRIX_TYPE_NAMES = {
-    4: 'Complex Hermitian positive-definite',
-    -4: 'Complex Hermitian indefinite',
-    2: 'Real symmetric positive-definite',
-    -2: 'Real symmetric indefinite',
-    11: 'Real non-symmetric',
-    13: 'Complex non-symmetric',
-}
-
-
-def _mkl_matrix_type(dtype, solver_args):
-    if not solver_args['hermitian']:
-        return 13 if dtype == np.complex128 else 11
-    out = 4 if dtype == np.complex128 else 2
-    return out if solver_args['posdef'] else -out
-
-
-def mkl_splu(A, perm=None, verbose=False, **kwargs):
-    """
-    Returns the LU factorization of the sparse matrix A.
-
-    Parameters
-    ----------
-    A : csr_matrix
-        Sparse input matrix.
-    perm : ndarray (optional)
-        User defined matrix factorization permutation.
-    verbose : bool {False, True}
-        Report factorization details.
-
-    Returns
-    -------
-    lu : mkl_lu
-        Returns object containing LU factorization with a
-        solve method for solving with a given RHS vector.
-
-    """
-    if not sp.isspmatrix_csr(A):
-        raise TypeError('Input matrix must be in sparse CSR format.')
-
-    if A.shape[0] != A.shape[1]:
-        raise Exception('Input matrix must be square')
-
-    dim = A.shape[0]
-    solver_args = _default_solver_args()
-    if set(kwargs) - set(solver_args):
-        raise ValueError(
-            "Unknown keyword arguments pass to mkl_splu: {!r}"
-            .format(set(kwargs) - set(solver_args))
-        )
-    solver_args.update(kwargs)
-
-    # If hermitian, then take upper-triangle of matrix only
-    if solver_args['hermitian']:
-        B = sp.triu(A, format='csr')
-        A = B  # This gets around making a full copy of A in triu
-    is_complex = bool(A.dtype == np.complex128)
-    if not is_complex:
-        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
-    data_type = A.dtype
-
-    # Create pointer to internal memory
-    pt = np.zeros(64, dtype=int)
-    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
-
-    # Create pointers to sparse matrix arrays
-    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # Setup perm array
-    if perm is None:
-        perm = np.zeros(dim, dtype=np.int32)
-        has_perm = 0
-    else:
-        has_perm = 1
-    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # setup iparm
-    iparm = _pardiso_parameters(
-        solver_args['hermitian'],
-        has_perm,
-        solver_args['max_iter_refine'],
-        solver_args['scaling_vectors'],
-        solver_args['weighted_matching'],
-    )
-    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # setup call parameters
-    mtype = _mkl_matrix_type(data_type, solver_args)
-
-    if verbose:
-        print('Solver Initialization')
-        print('---------------------')
-        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
-        print('Input matrix shape:', A.shape)
-        print('Input matrix NNZ:  ', A.nnz)
-        print()
-
-    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
-    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
-    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
-
-    error = np.zeros(1, dtype=np.int32)
-    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
-
-    # Call solver
-    _factor_start = time.time()
-    pardiso(
-        np_pt,
-        byref(c_int(1)),
-        byref(c_int(1)),
-        byref(c_int(mtype)),
-        byref(c_int(12)),
-        byref(c_int(dim)),
-        data,
-        indptr,
-        indices,
-        np_perm,
-        byref(c_int(1)),
-        np_iparm,
-        byref(c_int(0)),
-        np_b,
-        np_x,
-        np_error,
-    )
-    _factor_time = time.time() - _factor_start
-    if error[0] != 0:
-        raise Exception(pardiso_error_msgs[str(error[0])])
-
-    if verbose:
-        print('Analysis and Factorization Stage')
-        print('--------------------------------')
-        print('Factorization time:       ', round(_factor_time, 4))
-        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
-        print('NNZ in LU factors:        ', iparm[17])
-        print()
-
-    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
-                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
-
-
-def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
-    """
-    Solves a sparse linear system of equations using the
-    Intel MKL Pardiso solver.
-
-    Parameters
-    ----------
-    A : csr_matrix
-        Sparse matrix.
-    b : ndarray or sparse matrix
-        The vector or matrix representing the right hand side of the equation.
-        If a vector, b.shape must be (n,) or (n, 1).
-    perm : ndarray (optional)
-        User defined matrix factorization permutation.
-
-    Returns
-    -------
-    x : ndarray or csr_matrix
-        The solution of the sparse linear equation.
-        If b is a vector, then x is a vector of size A.shape[1]
-        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
-
-    """
-    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
-    b_is_sparse = sp.isspmatrix(b)
-    b_shp = b.shape
-    if b_is_sparse and b.shape[1] == 1:
-        b = b.toarray()
-        b_is_sparse = False
-    elif b_is_sparse and b.shape[1] != 1:
-        nrhs = b.shape[1]
-        if lu._is_complex:
-            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
-        else:
-            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
-
-    # Do dense RHS solving
-    if not b_is_sparse:
-        x = lu.solve(b, verbose=verbose)
-    # Solve each RHS vec individually and convert to sparse
-    else:
-        data_segs = []
-        row_segs = []
-        col_segs = []
-        for j in range(nrhs):
-            bj = b[:, j].A.ravel()
-            xj = lu.solve(bj)
-            w = np.flatnonzero(xj)
-            segment_length = w.shape[0]
-            row_segs.append(w)
-            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
-            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
-        sp_data = np.concatenate(data_segs)
-        sp_row = np.concatenate(row_segs)
-        sp_col = np.concatenate(col_segs)
-        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
-
-    info = lu.info()
-    lu.delete()
-    return (x, info) if kwargs.get('return_info', False) else x
+import sys
+import numpy as np
+import scipy.sparse as sp
+from ctypes import c_int, byref
+from numpy.ctypeslib import ndpointer
+import time
+from qutip.settings import settings as qset
+
+# Load solver functions from mkl_lib
+pardiso = qset.mkl_lib.pardiso
+pardiso_delete = qset.mkl_lib.pardiso_handle_delete
+if sys.maxsize > 2**32: #Running 64-bit
+    pardiso_64 = qset.mkl_lib.pardiso_64
+    pardiso_delete_64 = qset.mkl_lib.pardiso_handle_delete_64
+
+
+def _pardiso_parameters(hermitian, has_perm,
+                        max_iter_refine,
+                        scaling_vectors,
+                        weighted_matching):
+    iparm = np.zeros(64, dtype=np.int32)
+    iparm[0] = 1  # Do not use default values
+    iparm[1] = 3  # Use openmp nested dissection
+    if has_perm:
+        iparm[4] = 1
+    iparm[7] = max_iter_refine  # Max number of iterative refinements
+    if hermitian:
+        iparm[9] = 8
+    else:
+        iparm[9] = 13
+    if not hermitian:
+        iparm[10] = int(scaling_vectors)
+        iparm[12] = int(weighted_matching)  # Non-symmetric weighted matching
+    iparm[17] = -1
+    iparm[20] = 1
+    iparm[23] = 1  # Parallel factorization
+    iparm[26] = 0  # Check matrix structure
+    iparm[34] = 1  # Use zero-based indexing
+    return iparm
+
+
+# Set error messages
+pardiso_error_msgs = {
+    '-1': 'Input inconsistant',
+    '-2': 'Out of memory',
+    '-3': 'Reordering problem',
+    '-4':
+        'Zero pivot, numerical factorization or iterative refinement problem',
+    '-5': 'Unclassified internal error',
+    '-6': 'Reordering failed',
+    '-7': 'Diagonal matrix is singular',
+    '-8': '32-bit integer overflow',
+    '-9': 'Not enough memory for OOC',
+    '-10': 'Error opening OOC files',
+    '-11': 'Read/write error with OOC files',
+    '-12': 'Pardiso-64 called from 32-bit library',
+}
+
+
+def _default_solver_args():
+    return {
+        'hermitian': False,
+        'posdef': False,
+        'max_iter_refine': 10,
+        'scaling_vectors': True,
+        'weighted_matching': True,
+        'return_info': False,
+    }
+
+
+class mkl_lu:
+    """
+    Object pointing to LU factorization of a sparse matrix
+    generated by mkl_splu.
+
+    Methods
+    -------
+    solve(b, verbose=False)
+        Solve system of equations using given RHS vector 'b'.
+        Returns solution ndarray with same shape as input.
+
+    info()
+        Returns the statistics of the factorization and
+        solution in the lu.info attribute.
+
+    delete()
+        Deletes the allocated solver memory.
+
+    """
+    def __init__(self, np_pt=None, dim=None, is_complex=None, data=None,
+                 indptr=None, indices=None, iparm=None, np_iparm=None,
+                 mtype=None, perm=None, np_perm=None, factor_time=None):
+        self._np_pt = np_pt
+        self._dim = dim
+        self._is_complex = is_complex
+        self._data = data
+        self._indptr = indptr
+        self._indices = indices
+        self._iparm = iparm
+        self._np_iparm = np_iparm
+        self._mtype = mtype
+        self._perm = perm
+        self._np_perm = np_perm
+        self._factor_time = factor_time
+        self._solve_time = None
+
+    def solve(self, b, verbose=None):
+        b_shp = b.shape
+        if b.ndim == 2 and b.shape[1] == 1:
+            b = b.ravel()
+            nrhs = 1
+        elif b.ndim == 2 and b.shape[1] != 1:
+            nrhs = b.shape[1]
+            b = b.ravel(order='F')
+        else:
+            b = b.ravel()
+            nrhs = 1
+
+        data_type = np.complex128 if self._is_complex else np.float64
+        if b.dtype != data_type:
+            b = b.astype(np.complex128, copy=False)
+
+        # Create solution array (x) and pointers to x and b
+        x = np.zeros(b.shape, dtype=data_type, order='C')
+        np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+        np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+
+        error = np.zeros(1, dtype=np.int32)
+        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+        # Call solver
+        _solve_start = time.time()
+        pardiso(
+            self._np_pt,
+            byref(c_int(1)),
+            byref(c_int(1)),
+            byref(c_int(self._mtype)),
+            byref(c_int(33)),
+            byref(c_int(self._dim)),
+            self._data,
+            self._indptr,
+            self._indices,
+            self._np_perm,
+            byref(c_int(nrhs)),
+            self._np_iparm,
+            byref(c_int(0)),
+            np_b,
+            np_x,
+            np_error,
+        )
+        self._solve_time = time.time() - _solve_start
+        if error[0] != 0:
+            raise Exception(pardiso_error_msgs[str(error[0])])
+
+        if verbose:
+            print('Solution Stage')
+            print('--------------')
+            print('Solution time:                  ',
+                  round(self._solve_time, 4))
+            print('Solution memory (Mb):           ',
+                  round(self._iparm[16]/1024, 4))
+            print('Number of iterative refinements:',
+                  self._iparm[6])
+            print('Total memory (Mb):              ',
+                  round(sum(self._iparm[15:17])/1024, 4))
+            print()
+        return np.reshape(x, b_shp, order=('C' if nrhs == 1 else 'F'))
+
+    def info(self):
+        info = {'FactorTime': self._factor_time,
+                'SolveTime': self._solve_time,
+                'Factormem': round(self._iparm[15]/1024, 4),
+                'Solvemem': round(self._iparm[16]/1024, 4),
+                'IterRefine': self._iparm[6]}
+        return info
+
+    def delete(self):
+        # Delete all data
+        error = np.zeros(1, dtype=np.int32)
+        np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+        pardiso(
+            self._np_pt,
+            byref(c_int(1)),
+            byref(c_int(1)),
+            byref(c_int(self._mtype)),
+            byref(c_int(-1)),
+            byref(c_int(self._dim)),
+            self._data,
+            self._indptr,
+            self._indices,
+            self._np_perm,
+            byref(c_int(1)),
+            self._np_iparm,
+            byref(c_int(0)),
+            byref(c_int(0)),
+            byref(c_int(0)),
+            np_error,
+        )
+        if error[0] == -10:
+            raise Exception('Error freeing solver memory')
+
+
+_MATRIX_TYPE_NAMES = {
+    4: 'Complex Hermitian positive-definite',
+    -4: 'Complex Hermitian indefinite',
+    2: 'Real symmetric positive-definite',
+    -2: 'Real symmetric indefinite',
+    11: 'Real non-symmetric',
+    13: 'Complex non-symmetric',
+}
+
+
+def _mkl_matrix_type(dtype, solver_args):
+    if not solver_args['hermitian']:
+        return 13 if dtype == np.complex128 else 11
+    out = 4 if dtype == np.complex128 else 2
+    return out if solver_args['posdef'] else -out
+
+
+def mkl_splu(A, perm=None, verbose=False, **kwargs):
+    """
+    Returns the LU factorization of the sparse matrix A.
+
+    Parameters
+    ----------
+    A : csr_matrix
+        Sparse input matrix.
+    perm : ndarray (optional)
+        User defined matrix factorization permutation.
+    verbose : bool {False, True}
+        Report factorization details.
+
+    Returns
+    -------
+    lu : mkl_lu
+        Returns object containing LU factorization with a
+        solve method for solving with a given RHS vector.
+
+    """
+    if not sp.isspmatrix_csr(A):
+        raise TypeError('Input matrix must be in sparse CSR format.')
+
+    if A.shape[0] != A.shape[1]:
+        raise Exception('Input matrix must be square')
+
+    dim = A.shape[0]
+    solver_args = _default_solver_args()
+    if set(kwargs) - set(solver_args):
+        raise ValueError(
+            "Unknown keyword arguments pass to mkl_splu: {!r}"
+            .format(set(kwargs) - set(solver_args))
+        )
+    solver_args.update(kwargs)
+
+    # If hermitian, then take upper-triangle of matrix only
+    if solver_args['hermitian']:
+        B = sp.triu(A, format='csr')
+        A = B  # This gets around making a full copy of A in triu
+    is_complex = bool(A.dtype == np.complex128)
+    if not is_complex:
+        A = sp.csr_matrix(A, dtype=np.float64, copy=False)
+    data_type = A.dtype
+
+    # Create pointer to internal memory
+    pt = np.zeros(64, dtype=int)
+    np_pt = pt.ctypes.data_as(ndpointer(int, ndim=1, flags='C'))
+
+    # Create pointers to sparse matrix arrays
+    data = A.data.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+    indptr = A.indptr.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+    indices = A.indices.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # Setup perm array
+    if perm is None:
+        perm = np.zeros(dim, dtype=np.int32)
+        has_perm = 0
+    else:
+        has_perm = 1
+    np_perm = perm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # setup iparm
+    iparm = _pardiso_parameters(
+        solver_args['hermitian'],
+        has_perm,
+        solver_args['max_iter_refine'],
+        solver_args['scaling_vectors'],
+        solver_args['weighted_matching'],
+    )
+    np_iparm = iparm.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # setup call parameters
+    mtype = _mkl_matrix_type(data_type, solver_args)
+
+    if verbose:
+        print('Solver Initialization')
+        print('---------------------')
+        print('Input matrix type: ', _MATRIX_TYPE_NAMES[mtype])
+        print('Input matrix shape:', A.shape)
+        print('Input matrix NNZ:  ', A.nnz)
+        print()
+
+    b = np.zeros(1, dtype=data_type)  # Input dummy RHS at this phase
+    np_b = b.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+    x = np.zeros(1, dtype=data_type)  # Input dummy solution at this phase
+    np_x = x.ctypes.data_as(ndpointer(data_type, ndim=1, flags='C'))
+
+    error = np.zeros(1, dtype=np.int32)
+    np_error = error.ctypes.data_as(ndpointer(np.int32, ndim=1, flags='C'))
+
+    # Call solver
+    _factor_start = time.time()
+    pardiso(
+        np_pt,
+        byref(c_int(1)),
+        byref(c_int(1)),
+        byref(c_int(mtype)),
+        byref(c_int(12)),
+        byref(c_int(dim)),
+        data,
+        indptr,
+        indices,
+        np_perm,
+        byref(c_int(1)),
+        np_iparm,
+        byref(c_int(0)),
+        np_b,
+        np_x,
+        np_error,
+    )
+    _factor_time = time.time() - _factor_start
+    if error[0] != 0:
+        raise Exception(pardiso_error_msgs[str(error[0])])
+
+    if verbose:
+        print('Analysis and Factorization Stage')
+        print('--------------------------------')
+        print('Factorization time:       ', round(_factor_time, 4))
+        print('Factorization memory (Mb):', round(iparm[15]/1024, 4))
+        print('NNZ in LU factors:        ', iparm[17])
+        print()
+
+    return mkl_lu(np_pt, dim, is_complex, data, indptr, indices,
+                  iparm, np_iparm, mtype, perm, np_perm, _factor_time)
+
+
+def mkl_spsolve(A, b, perm=None, verbose=False, **kwargs):
+    """
+    Solves a sparse linear system of equations using the
+    Intel MKL Pardiso solver.
+
+    Parameters
+    ----------
+    A : csr_matrix
+        Sparse matrix.
+    b : ndarray or sparse matrix
+        The vector or matrix representing the right hand side of the equation.
+        If a vector, b.shape must be (n,) or (n, 1).
+    perm : ndarray (optional)
+        User defined matrix factorization permutation.
+
+    Returns
+    -------
+    x : ndarray or csr_matrix
+        The solution of the sparse linear equation.
+        If b is a vector, then x is a vector of size A.shape[1]
+        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])
+
+    """
+    lu = mkl_splu(A, perm=perm, verbose=verbose, **kwargs)
+    b_is_sparse = sp.isspmatrix(b)
+    b_shp = b.shape
+    if b_is_sparse and b.shape[1] == 1:
+        b = b.toarray()
+        b_is_sparse = False
+    elif b_is_sparse and b.shape[1] != 1:
+        nrhs = b.shape[1]
+        if lu._is_complex:
+            b = sp.csc_matrix(b, dtype=np.complex128, copy=False)
+        else:
+            b = sp.csc_matrix(b, dtype=np.float64, copy=False)
+
+    # Do dense RHS solving
+    if not b_is_sparse:
+        x = lu.solve(b, verbose=verbose)
+    # Solve each RHS vec individually and convert to sparse
+    else:
+        data_segs = []
+        row_segs = []
+        col_segs = []
+        for j in range(nrhs):
+            bj = b[:, j].A.ravel()
+            xj = lu.solve(bj)
+            w = np.flatnonzero(xj)
+            segment_length = w.shape[0]
+            row_segs.append(w)
+            col_segs.append(np.ones(segment_length, dtype=np.int32)*j)
+            data_segs.append(np.asarray(xj[w], dtype=xj.dtype))
+        sp_data = np.concatenate(data_segs)
+        sp_row = np.concatenate(row_segs)
+        sp_col = np.concatenate(col_segs)
+        x = sp.csr_matrix((sp_data, (sp_row, sp_col)), shape=b_shp)
+
+    info = lu.info()
+    lu.delete()
+    return (x, info) if kwargs.get('return_info', False) else x
diff --git a/qutip/about.py b/qutip/about.py
index 57e7322cab..0e5eb1662a 100644
--- a/qutip/about.py
+++ b/qutip/about.py
@@ -1,75 +1,75 @@
-"""
-Command line output of information on QuTiP and dependencies.
-"""
-__all__ = ['about']
-
-import sys
-import os
-import platform
-import numpy
-import scipy
-import inspect
-import qutip
-from qutip.settings import _blas_info, settings
-
-
-def about():
-    """
-    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
-    and MatPlotLib.
-    """
-    print("")
-    print("QuTiP: Quantum Toolbox in Python")
-    print("================================")
-    print("Copyright (c) QuTiP team 2011 and later.")
-    print(
-        "Current admin team: Alexander Pitchford, "
-        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
-        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
-    )
-    print(
-        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
-        "Franco Nori and Will Zeng."
-    )
-    print("Original developers: R. J. Johansson & P. D. Nation.")
-    print("Previous lead developers: Chris Granade & A. Grimsmo.")
-    print("Currently developed through wide collaboration. "
-          "See https://github.com/qutip for details.")
-    print("")
-    print("QuTiP Version:      %s" % qutip.__version__)
-    print("Numpy Version:      %s" % numpy.__version__)
-    print("Scipy Version:      %s" % scipy.__version__)
-    try:
-        import Cython
-        cython_ver = Cython.__version__
-    except ImportError:
-        cython_ver = 'None'
-    print("Cython Version:     %s" % cython_ver)
-    try:
-        import matplotlib
-        matplotlib_ver = matplotlib.__version__
-    except ImportError:
-        matplotlib_ver = 'None'
-    print("Matplotlib Version: %s" % matplotlib_ver)
-    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
-    print("Number of CPUs:     %s" % settings.num_cpus)
-    print("BLAS Info:          %s" % _blas_info())
-    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
-    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
-    print("Platform Info:      %s (%s)" % (platform.system(),
-                                           platform.machine()))
-    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
-    print("Installation path:  %s" % qutip_install_path)
-
-    # citation
-    longbar = "=" * 80
-    cite_msg = "For your convenience a bibtex reference can be easily"
-    cite_msg += " generated using `qutip.cite()`"
-    print(longbar)
-    print("Please cite QuTiP in your publication.")
-    print(longbar)
-    print(cite_msg)
-
-
-if __name__ == "__main__":
-    about()
+"""
+Command line output of information on QuTiP and dependencies.
+"""
+__all__ = ['about']
+
+import sys
+import os
+import platform
+import numpy
+import scipy
+import inspect
+import qutip
+from qutip.settings import _blas_info, settings
+
+
+def about():
+    """
+    About box for QuTiP. Gives version numbers for QuTiP, NumPy, SciPy, Cython,
+    and MatPlotLib.
+    """
+    print("")
+    print("QuTiP: Quantum Toolbox in Python")
+    print("================================")
+    print("Copyright (c) QuTiP team 2011 and later.")
+    print(
+        "Current admin team: Alexander Pitchford, "
+        "Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, "
+        "Boxi Li, Jake Lishman, Simon Cross and Asier Galicia."
+    )
+    print(
+        "Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, "
+        "Franco Nori and Will Zeng."
+    )
+    print("Original developers: R. J. Johansson & P. D. Nation.")
+    print("Previous lead developers: Chris Granade & A. Grimsmo.")
+    print("Currently developed through wide collaboration. "
+          "See https://github.com/qutip for details.")
+    print("")
+    print("QuTiP Version:      %s" % qutip.__version__)
+    print("Numpy Version:      %s" % numpy.__version__)
+    print("Scipy Version:      %s" % scipy.__version__)
+    try:
+        import Cython
+        cython_ver = Cython.__version__
+    except ImportError:
+        cython_ver = 'None'
+    print("Cython Version:     %s" % cython_ver)
+    try:
+        import matplotlib
+        matplotlib_ver = matplotlib.__version__
+    except ImportError:
+        matplotlib_ver = 'None'
+    print("Matplotlib Version: %s" % matplotlib_ver)
+    print("Python Version:     %d.%d.%d" % sys.version_info[0:3])
+    print("Number of CPUs:     %s" % settings.num_cpus)
+    print("BLAS Info:          %s" % _blas_info())
+    # print("OPENMP Installed:   %s" % str(qutip.settings.has_openmp))
+    print("INTEL MKL Ext:      %s" % str(settings.has_mkl))
+    print("Platform Info:      %s (%s)" % (platform.system(),
+                                           platform.machine()))
+    qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
+    print("Installation path:  %s" % qutip_install_path)
+
+    # citation
+    longbar = "=" * 80
+    cite_msg = "For your convenience a bibtex reference can be easily"
+    cite_msg += " generated using `qutip.cite()`"
+    print(longbar)
+    print("Please cite QuTiP in your publication.")
+    print(longbar)
+    print(cite_msg)
+
+
+if __name__ == "__main__":
+    about()
diff --git a/qutip/bloch.py b/qutip/bloch.py
index e67ed5046b..980502dd9d 100644
--- a/qutip/bloch.py
+++ b/qutip/bloch.py
@@ -1,928 +1,928 @@
-__all__ = ['Bloch']
-
-import os
-
-import numpy as np
-from numpy import (outer, cos, sin, ones)
-
-from packaging.version import parse as parse_version
-
-from . import Qobj, expect, sigmax, sigmay, sigmaz
-
-try:
-    import matplotlib
-    import matplotlib.pyplot as plt
-    from mpl_toolkits.mplot3d import Axes3D
-    from matplotlib.patches import FancyArrowPatch
-    from mpl_toolkits.mplot3d import proj3d
-
-    # Define a custom _axes3D function based on the matplotlib version.
-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
-        def _axes3D(fig, *args, **kwargs):
-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-            return fig.add_axes(ax)
-    else:
-        def _axes3D(*args, **kwargs):
-            return Axes3D(*args, **kwargs)
-
-    class Arrow3D(FancyArrowPatch):
-        def __init__(self, xs, ys, zs, *args, **kwargs):
-            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
-
-            self._verts3d = xs, ys, zs
-
-        def draw(self, renderer):
-            xs3d, ys3d, zs3d = self._verts3d
-            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
-
-            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
-            FancyArrowPatch.draw(self, renderer)
-
-        def do_3d_projection(self, renderer=None):
-            # only called by matplotlib >= 3.5
-            xs3d, ys3d, zs3d = self._verts3d
-            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
-            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
-            return np.min(zs)
-except ImportError:
-    pass
-
-try:
-    from IPython.display import display
-except ImportError:
-    pass
-
-
-class Bloch:
-    r"""
-    Class for plotting data on the Bloch sphere.  Valid data can be either
-    points, vectors, or Qobj objects.
-
-    Attributes
-    ----------
-    axes : matplotlib.axes.Axes
-        User supplied Matplotlib axes for Bloch sphere animation.
-    fig : matplotlib.figure.Figure
-        User supplied Matplotlib Figure instance for plotting Bloch sphere.
-    font_color : str, default 'black'
-        Color of font used for Bloch sphere labels.
-    font_size : int, default 20
-        Size of font used for Bloch sphere labels.
-    frame_alpha : float, default 0.1
-        Sets transparency of Bloch sphere frame.
-    frame_color : str, default 'gray'
-        Color of sphere wireframe.
-    frame_width : int, default 1
-        Width of wireframe.
-    point_color : list, default ["b", "r", "g", "#CC6600"]
-        List of colors for Bloch sphere point markers to cycle through, i.e.
-        by default, points 0 and 4 will both be blue ('b').
-    point_marker : list, default ["o", "s", "d", "^"]
-        List of point marker shapes to cycle through.
-    point_size : list, default [25, 32, 35, 45]
-        List of point marker sizes. Note, not all point markers look the same
-        size when plotted!
-    sphere_alpha : float, default 0.2
-        Transparency of Bloch sphere itself.
-    sphere_color : str, default '#FFDDDD'
-        Color of Bloch sphere.
-    figsize : list, default [7, 7]
-        Figure size of Bloch sphere plot.  Best to have both numbers the same;
-        otherwise you will have a Bloch sphere that looks like a football.
-    vector_color : list, ["g", "#CC6600", "b", "r"]
-        List of vector colors to cycle through.
-    vector_width : int, default 5
-        Width of displayed vectors.
-    vector_style : str, default '-\|>'
-        Vector arrowhead style (from matplotlib's arrow style).
-    vector_mutation : int, default 20
-        Width of vectors arrowhead.
-    view : list, default [-60, 30]
-        Azimuthal and Elevation viewing angles.
-    xlabel : list, default ["$x$", ""]
-        List of strings corresponding to +x and -x axes labels, respectively.
-    xlpos : list, default [1.1, -1.1]
-        Positions of +x and -x labels respectively.
-    ylabel : list, default ["$y$", ""]
-        List of strings corresponding to +y and -y axes labels, respectively.
-    ylpos : list, default [1.2, -1.2]
-        Positions of +y and -y labels respectively.
-    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
-        List of strings corresponding to +z and -z axes labels, respectively.
-    zlpos : list, default [1.2, -1.2]
-        Positions of +z and -z labels respectively.
-    """
-    def __init__(self, fig=None, axes=None, view=None, figsize=None,
-                 background=False):
-        # Figure and axes
-        self.fig = fig
-        self._ext_fig = fig is not None
-        self.axes = axes
-        # Background axes, default = False
-        self.background = background
-        # The size of the figure in inches, default = [5,5].
-        self.figsize = figsize if figsize else [5, 5]
-        # Azimuthal and Elvation viewing angles, default = [-60,30].
-        self.view = view if view else [-60, 30]
-        # Color of Bloch sphere, default = #FFDDDD
-        self.sphere_color = '#FFDDDD'
-        # Transparency of Bloch sphere, default = 0.2
-        self.sphere_alpha = 0.2
-        # Color of wireframe, default = 'gray'
-        self.frame_color = 'gray'
-        # Width of wireframe, default = 1
-        self.frame_width = 1
-        # Transparency of wireframe, default = 0.2
-        self.frame_alpha = 0.2
-        # Labels for x-axis (in LaTex), default = ['$x$', '']
-        self.xlabel = ['$x$', '']
-        # Position of x-axis labels, default = [1.2, -1.2]
-        self.xlpos = [1.2, -1.2]
-        # Labels for y-axis (in LaTex), default = ['$y$', '']
-        self.ylabel = ['$y$', '']
-        # Position of y-axis labels, default = [1.1, -1.1]
-        self.ylpos = [1.2, -1.2]
-        # Labels for z-axis (in LaTex),
-        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
-        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
-        # Position of z-axis labels, default = [1.2, -1.2]
-        self.zlpos = [1.2, -1.2]
-        # ---font options---
-        # Color of fonts, default = 'black'
-        self.font_color = 'black'
-        # Size of fonts, default = 20
-        self.font_size = 20
-
-        # ---vector options---
-        # List of colors for Bloch vectors, default = ['b','g','r','y']
-        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
-        # List that stores the display colors for each vector
-        self.vector_color = []
-        #: Width of Bloch vectors, default = 5
-        self.vector_width = 3
-        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
-        self.vector_style = '-|>'
-        #: Sets the width of the vectors arrowhead
-        self.vector_mutation = 20
-
-        # ---point options---
-        # List of colors for Bloch point markers, default = ['b','g','r','y']
-        self.point_default_color = ['b', 'r', 'g', '#CC6600']
-        # List that stores the display colors for each set of points
-        self.point_color = []
-        # Size of point markers, default = 25
-        self.point_size = [25, 32, 35, 45]
-        # Shape of point markers, default = ['o','^','d','s']
-        self.point_marker = ['o', 's', 'd', '^']
-
-        # ---data lists---
-        # Data for point markers
-        self.points = []
-        # Data for Bloch vectors
-        self.vectors = []
-        # Transparency of vectors, alpha value from 0 to 1
-        self.vector_alpha = []
-        # Data for annotations
-        self.annotations = []
-        # Number of times sphere has been saved
-        self.savenum = 0
-        # Style of points, 'm' for multiple colors, 's' for single color
-        self.point_style = []
-        # Transparency of points, alpha value from 0 to 1
-        self.point_alpha = []
-        # Data for line segment
-        self._lines = []
-        # Data for arcs and arc style
-        self._arcs = []
-
-    def set_label_convention(self, convention):
-        """Set x, y and z labels according to one of conventions.
-
-        Parameters
-        ----------
-        convention : string
-            One of the following:
-
-            - "original"
-            - "xyz"
-            - "sx sy sz"
-            - "01"
-            - "polarization jones"
-            - "polarization jones letters"
-              see also: https://en.wikipedia.org/wiki/Jones_calculus
-            - "polarization stokes"
-              see also: https://en.wikipedia.org/wiki/Stokes_parameters
-        """
-        ketex = "$\\left.|%s\\right\\rangle$"
-        # \left.| is on purpose, so that every ket has the same size
-
-        if convention == "original":
-            self.xlabel = ['$x$', '']
-            self.ylabel = ['$y$', '']
-            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
-        elif convention == "xyz":
-            self.xlabel = ['$x$', '']
-            self.ylabel = ['$y$', '']
-            self.zlabel = ['$z$', '']
-        elif convention == "sx sy sz":
-            self.xlabel = ['$s_x$', '']
-            self.ylabel = ['$s_y$', '']
-            self.zlabel = ['$s_z$', '']
-        elif convention == "01":
-            self.xlabel = ['', '']
-            self.ylabel = ['', '']
-            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
-        elif convention == "polarization jones":
-            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
-                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
-            self.ylabel = [ketex % "\\circlearrowleft", ketex %
-                           "\\circlearrowright"]
-            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
-        elif convention == "polarization jones letters":
-            self.xlabel = [ketex % "D", ketex % "A"]
-            self.ylabel = [ketex % "L", ketex % "R"]
-            self.zlabel = [ketex % "H", ketex % "V"]
-        elif convention == "polarization stokes":
-            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
-                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
-            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
-            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
-        else:
-            raise Exception("No such convention.")
-
-    def __str__(self):
-        s = ""
-        s += "Bloch data:\n"
-        s += "-----------\n"
-        s += "Number of points:  " + str(len(self.points)) + "\n"
-        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
-        s += "\n"
-        s += "Bloch sphere properties:\n"
-        s += "------------------------\n"
-        s += "font_color:      " + str(self.font_color) + "\n"
-        s += "font_size:       " + str(self.font_size) + "\n"
-        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
-        s += "frame_color:     " + str(self.frame_color) + "\n"
-        s += "frame_width:     " + str(self.frame_width) + "\n"
-        s += "point_default_color:" + str(self.point_default_color) + "\n"
-        s += "point_marker:    " + str(self.point_marker) + "\n"
-        s += "point_size:      " + str(self.point_size) + "\n"
-        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
-        s += "sphere_color:    " + str(self.sphere_color) + "\n"
-        s += "figsize:         " + str(self.figsize) + "\n"
-        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
-        s += "vector_width:    " + str(self.vector_width) + "\n"
-        s += "vector_style:    " + str(self.vector_style) + "\n"
-        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
-        s += "view:            " + str(self.view) + "\n"
-        s += "xlabel:          " + str(self.xlabel) + "\n"
-        s += "xlpos:           " + str(self.xlpos) + "\n"
-        s += "ylabel:          " + str(self.ylabel) + "\n"
-        s += "ylpos:           " + str(self.ylpos) + "\n"
-        s += "zlabel:          " + str(self.zlabel) + "\n"
-        s += "zlpos:           " + str(self.zlpos) + "\n"
-        return s
-
-    def _repr_png_(self):
-        from IPython.core.pylabtools import print_figure
-        self.render()
-        fig_data = print_figure(self.fig, 'png')
-        plt.close(self.fig)
-        return fig_data
-
-    def _repr_svg_(self):
-        from IPython.core.pylabtools import print_figure
-        self.render()
-        fig_data = print_figure(self.fig, 'svg')
-        plt.close(self.fig)
-        return fig_data
-
-    def clear(self):
-        """Resets Bloch sphere data sets to empty.
-        """
-        self.points = []
-        self.vectors = []
-        self.point_style = []
-        self.point_alpha = []
-        self.vector_alpha = []
-        self.annotations = []
-        self.vector_color = []
-        self.point_color = []
-        self._lines = []
-        self._arcs = []
-
-    def add_points(self, points, meth='s', colors=None, alpha=1.0):
-        """Add a list of data points to bloch sphere.
-
-        Parameters
-        ----------
-        points : array_like
-            Collection of data points.
-
-        meth : {'s', 'm', 'l'}
-            Type of points to plot, use 'm' for multicolored, 'l' for points
-            connected with a line.
-
-        colors : array_like
-            Optional array with colors for the points.
-            A single color for meth 's', and list of colors for meth 'm'
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        .. note::
-
-           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
-           to ``0.75`` and there was no way to alter it.
-           When the ``alpha`` parameter was added in QuTiP 4.7, the default
-           became ``alpha=1.0`` for values of ``meth``.
-        """
-
-        points = np.asarray(points)
-
-        if points.ndim == 1:
-            points = points[:, np.newaxis]
-
-        if points.ndim != 2 or points.shape[0] != 3:
-            raise ValueError("The included points are not valid. Points must "
-                             "be equivalent to a 2D array where the first "
-                             "index represents the x,y,z values and the "
-                             "second index iterates over the points.")
-
-        if meth not in ['s', 'm', 'l']:
-            raise ValueError(f"The value for meth = {meth} is not valid."
-                             " Please use 's', 'l' or 'm'.")
-
-        if meth == 's' and points.shape[1] == 1:
-            points = np.append(points[:, :1], points, axis=1)
-
-        self.point_style.append(meth)
-        self.points.append(points)
-        self.point_alpha.append(alpha)
-        self.point_color.append(colors)
-
-    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
-        """Add a state vector Qobj to Bloch sphere.
-
-        Parameters
-        ----------
-        state : Qobj
-            Input state vector.
-
-        kind : {'vector', 'point'}
-            Type of object to plot.
-
-        colors : array_like
-            Optional array with colors for the states.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-        """
-        if isinstance(state, Qobj):
-            state = [state]
-        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
-            colors = [colors]
-
-        for k, st in enumerate(state):
-            vec = [expect(sigmax(), st),
-                   expect(sigmay(), st),
-                   expect(sigmaz(), st)]
-
-            if kind == 'vector':
-                if colors is not None:
-                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
-                else:
-                    self.add_vectors(vec)
-            elif kind == 'point':
-                if colors is not None:
-                    self.add_points(vec, colors=colors[k], alpha=alpha)
-                else:
-                    self.add_points(vec)
-
-    def add_vectors(self, vectors, colors=None, alpha=1.0):
-        """Add a list of vectors to Bloch sphere.
-
-        Parameters
-        ----------
-        vectors : array_like
-            Array with vectors of unit length or smaller.
-
-        colors : array_like
-            Optional array with colors for the vectors.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        """
-        vectors = np.asarray(vectors)
-
-        if vectors.ndim == 1:
-            vectors = vectors[np.newaxis, :]
-
-        if vectors.ndim != 2 or vectors.shape[1] != 3:
-            raise ValueError(
-                "The included vectors are not valid. Vectors must "
-                "be equivalent to a 2D array where the first "
-                "index represents the iteration over the vectors and the "
-                "second index represents the position in 3D of vector head.")
-
-        n_vectors = vectors.shape[0]
-        if colors is None:
-            colors = np.array([None] * n_vectors)
-        else:
-            colors = np.asarray(colors)
-
-        if colors.ndim != 1 or colors.size != n_vectors:
-            raise ValueError("The included colors are not valid. colors must "
-                             "be equivalent to a 1D array with the same "
-                             "size as the number of vectors. ")
-
-        for k, vec in enumerate(vectors):
-            self.vectors.append(vec)
-            self.vector_alpha.append(alpha)
-            self.vector_color.append(colors[k])
-
-    def add_annotation(self, state_or_vector, text, **kwargs):
-        """
-        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
-        state or a vector.
-
-        Parameters
-        ----------
-        state_or_vector : Qobj/array/list/tuple
-            Position for the annotaion.
-            Qobj of a qubit or a vector of 3 elements.
-
-        text : str
-            Annotation text.
-            You can use LaTeX, but remember to use raw string
-            e.g. r"$\\langle x \\rangle$"
-            or escape backslashes
-            e.g. "$\\\\langle x \\\\rangle$".
-
-        kwargs :
-            Options as for mplot3d.axes3d.text, including:
-            fontsize, color, horizontalalignment, verticalalignment.
-
-        """
-        if isinstance(state_or_vector, Qobj):
-            vec = [expect(sigmax(), state_or_vector),
-                   expect(sigmay(), state_or_vector),
-                   expect(sigmaz(), state_or_vector)]
-        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
-                and len(state_or_vector) == 3:
-            vec = state_or_vector
-        else:
-            raise Exception("Position needs to be specified by a qubit " +
-                            "state or a 3D vector.")
-        self.annotations.append({'position': vec,
-                                 'text': text,
-                                 'opts': kwargs})
-
-    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
-        """Adds an arc between two points on a sphere. The arc is set to be
-        blue solid curve by default.
-
-        The start and end points must be on the same sphere (i.e. have the
-        same radius) but need not be on the unit sphere.
-
-        Parameters
-        ----------
-        start : Qobj or array-like
-            Array with cartesian coordinates of the first point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        end : Qobj or array-like
-            Array with cartesian coordinates of the second point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        fmt : str, default: "b"
-            A matplotlib format string for rendering the arc.
-        steps : int, default: None
-            The number of segments to use when rendering the arc. The default
-            uses 100 steps times the distance between the start and end points,
-            with a minimum of 2 steps.
-        **kwargs : dict
-            Additional parameters to pass to the matplotlib .plot function
-            when rendering this arc.
-        """
-        if isinstance(start, Qobj):
-            pt1 = [
-                expect(sigmax(), start),
-                expect(sigmay(), start),
-                expect(sigmaz(), start),
-            ]
-        else:
-            pt1 = start
-
-        if isinstance(end, Qobj):
-            pt2 = [
-                expect(sigmax(), end),
-                expect(sigmay(), end),
-                expect(sigmaz(), end),
-            ]
-        else:
-            pt2 = end
-
-        pt1 = np.asarray(pt1)
-        pt2 = np.asarray(pt2)
-
-        len1 = np.linalg.norm(pt1)
-        len2 = np.linalg.norm(pt2)
-        if len1 < 1e-12 or len2 < 1e-12:
-            raise ValueError('Polar and azimuthal angles undefined at origin.')
-        elif abs(len1 - len2) > 1e-12:
-            raise ValueError("Points not on the same sphere.")
-        elif (pt1 == pt2).all():
-            raise ValueError(
-                "Start and end represent the same point. No arc can be formed."
-            )
-        elif (pt1 == -pt2).all():
-            raise ValueError(
-                "Start and end are diagonally opposite, no unique arc is"
-                " possible."
-            )
-
-        if steps is None:
-            steps = int(np.linalg.norm(pt1 - pt2) * 100)
-            steps = max(2, steps)
-        t = np.linspace(0, 1, steps)
-        # All the points in this line are contained in the plane defined
-        # by pt1, pt2 and the origin.
-        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
-        # Normalize all the points in the line so that are distance len1 from
-        # the origin.
-        arc = line * len1 / np.linalg.norm(line, axis=0)
-        self._arcs.append([arc, fmt, kwargs])
-
-    def add_line(self, start, end, fmt="k", **kwargs):
-        """Adds a line segment connecting two points on the bloch sphere.
-
-        The line segment is set to be a black solid line by default.
-
-        Parameters
-        ----------
-        start : Qobj or array-like
-            Array with cartesian coordinates of the first point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        end : Qobj or array-like
-            Array with cartesian coordinates of the second point, or a state
-            vector or density matrix that can be mapped to a point on or
-            within the Bloch sphere.
-        fmt : str, default: "k"
-            A matplotlib format string for rendering the line.
-        **kwargs : dict
-            Additional parameters to pass to the matplotlib .plot function
-            when rendering this line.
-        """
-        if isinstance(start, Qobj):
-            pt1 = [
-                expect(sigmax(), start),
-                expect(sigmay(), start),
-                expect(sigmaz(), start),
-            ]
-        else:
-            pt1 = start
-
-        if isinstance(end, Qobj):
-            pt2 = [
-                expect(sigmax(), end),
-                expect(sigmay(), end),
-                expect(sigmaz(), end),
-            ]
-        else:
-            pt2 = end
-
-        pt1 = np.asarray(pt1)
-        pt2 = np.asarray(pt2)
-
-        x = [pt1[1], pt2[1]]
-        y = [-pt1[0], -pt2[0]]
-        z = [pt1[2], pt2[2]]
-        v = [x, y, z]
-        self._lines.append([v, fmt, kwargs])
-
-    def make_sphere(self):
-        """
-        Plots Bloch sphere and data sets.
-        """
-        self.render()
-
-    def run_from_ipython(self):
-        try:
-            __IPYTHON__
-            return True
-        except NameError:
-            return False
-
-    def _is_inline_backend(self):
-        backend = matplotlib.get_backend()
-        return backend == "module://matplotlib_inline.backend_inline"
-
-    def render(self):
-        """
-        Render the Bloch sphere and its data sets in on given figure and axes.
-        """
-        if not self._ext_fig and not self._is_inline_backend():
-            # If no external figure was supplied, we check to see if the
-            # figure we created in a previous call to .render() has been
-            # closed, and re-create if has been. This has the unfortunate
-            # side effect of losing any modifications made to the axes or
-            # figure, but the alternative is to crash the matplotlib backend.
-            #
-            # The inline backend used by, e.g. jupyter notebooks, is happy to
-            # use closed figures so we leave those figures intact.
-            if (
-                self.fig is not None and
-                not plt.fignum_exists(self.fig.number)
-            ):
-                self.fig = None
-                self.axes = None
-
-        if self.fig is None:
-            self.fig = plt.figure(figsize=self.figsize)
-            if self._is_inline_backend():
-                # We immediately close the inline figure do avoid displaying
-                # the figure twice when .show() calls display.
-                plt.close(self.fig)
-
-        if self.axes is None:
-            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
-
-        # Clearing the axes is horrifically slow and loses a lot of the
-        # axes state, but matplotlib doesn't seem to provide a better way
-        # to redraw Axes3D. :/
-        self.axes.clear()
-        self.axes.grid(False)
-        if self.background:
-            self.axes.set_xlim3d(-1.3, 1.3)
-            self.axes.set_ylim3d(-1.3, 1.3)
-            self.axes.set_zlim3d(-1.3, 1.3)
-        else:
-            self.axes.set_axis_off()
-            self.axes.set_xlim3d(-0.7, 0.7)
-            self.axes.set_ylim3d(-0.7, 0.7)
-            self.axes.set_zlim3d(-0.7, 0.7)
-        # Manually set aspect ratio to fit a square bounding box.
-        # Matplotlib did this stretching for < 3.3.0, but not above.
-        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
-            self.axes.set_box_aspect((1, 1, 1))
-        if not self.background:
-            self.plot_axes()
-
-        self.plot_back()
-        self.plot_points()
-        self.plot_vectors()
-        self.plot_lines()
-        self.plot_arcs()
-        self.plot_front()
-        self.plot_axes_labels()
-        self.plot_annotations()
-        # Trigger an update of the Bloch sphere if it is already shown:
-        self.fig.canvas.draw()
-
-    def plot_back(self):
-        # back half of sphere
-        u = np.linspace(0, np.pi, 25)
-        v = np.linspace(0, np.pi, 25)
-        x = outer(cos(u), sin(v))
-        y = outer(sin(u), sin(v))
-        z = outer(ones(np.size(u)), cos(v))
-        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
-                               color=self.sphere_color, linewidth=0,
-                               alpha=self.sphere_alpha)
-        # wireframe
-        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
-                                 color=self.frame_color,
-                                 alpha=self.frame_alpha)
-        # equator
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
-                       lw=self.frame_width, color=self.frame_color)
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
-                       lw=self.frame_width, color=self.frame_color)
-
-    def plot_front(self):
-        # front half of sphere
-        u = np.linspace(-np.pi, 0, 25)
-        v = np.linspace(0, np.pi, 25)
-        x = outer(cos(u), sin(v))
-        y = outer(sin(u), sin(v))
-        z = outer(ones(np.size(u)), cos(v))
-        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
-                               color=self.sphere_color, linewidth=0,
-                               alpha=self.sphere_alpha)
-        # wireframe
-        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
-                                 color=self.frame_color,
-                                 alpha=self.frame_alpha)
-        # equator
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
-                       zs=0, zdir='z', lw=self.frame_width,
-                       color=self.frame_color)
-        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
-                       zs=0, zdir='x', lw=self.frame_width,
-                       color=self.frame_color)
-
-    def plot_axes(self):
-        # axes
-        span = np.linspace(-1.0, 1.0, 2)
-        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
-                       lw=self.frame_width, color=self.frame_color)
-        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
-                       lw=self.frame_width, color=self.frame_color)
-        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
-                       lw=self.frame_width, color=self.frame_color)
-
-    def plot_axes_labels(self):
-        # axes labels
-        opts = {'fontsize': self.font_size,
-                'color': self.font_color,
-                'horizontalalignment': 'center',
-                'verticalalignment': 'center'}
-        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
-        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
-
-        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
-        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
-
-        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
-        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
-
-        for a in (self.axes.xaxis.get_ticklines() +
-                  self.axes.xaxis.get_ticklabels()):
-            a.set_visible(False)
-        for a in (self.axes.yaxis.get_ticklines() +
-                  self.axes.yaxis.get_ticklabels()):
-            a.set_visible(False)
-        for a in (self.axes.zaxis.get_ticklines() +
-                  self.axes.zaxis.get_ticklabels()):
-            a.set_visible(False)
-
-    def plot_vectors(self):
-        # -X and Y data are switched for plotting purposes
-        for k, vec in enumerate(self.vectors):
-
-            xs3d = vec[1] * np.array([0, 1])
-            ys3d = -vec[0] * np.array([0, 1])
-            zs3d = vec[2] * np.array([0, 1])
-
-            alpha = self.vector_alpha[k]
-            color = self.vector_color[k]
-            if color is None:
-                idx = k % len(self.vector_default_color)
-                color = self.vector_default_color[idx]
-
-            # decorated style, with arrow heads
-            a = Arrow3D(xs3d, ys3d, zs3d,
-                        mutation_scale=self.vector_mutation,
-                        lw=self.vector_width,
-                        arrowstyle=self.vector_style,
-                        color=color, alpha=alpha)
-
-            self.axes.add_artist(a)
-
-    def plot_points(self):
-        # -X and Y data are switched for plotting purposes
-        for k, points in enumerate(self.points):
-            points = np.asarray(points)
-            num_points = points.shape[1]
-
-            dist = np.linalg.norm(points, axis=0)
-            if not np.allclose(dist, dist[0], rtol=1e-12):
-                indperm = np.argsort(dist)
-                points = points[:, indperm]
-            else:
-                indperm = np.arange(num_points)
-
-            s = self.point_size[np.mod(k, len(self.point_size))]
-            marker = self.point_marker[np.mod(k, len(self.point_marker))]
-            style = self.point_style[k]
-            if self.point_color[k] is not None:
-                color = self.point_color[k]
-            elif self.point_style[k] in ['s', 'l']:
-                color = self.point_default_color[
-                    k % len(self.point_default_color)
-                ]
-            elif self.point_style[k] == 'm':
-                length = np.ceil(num_points/len(self.point_default_color))
-                color = np.tile(self.point_default_color, length.astype(int))
-                color = color[indperm]
-
-            if self.point_style[k] in ['s', 'm']:
-                self.axes.scatter(np.real(points[1]),
-                                  -np.real(points[0]),
-                                  np.real(points[2]),
-                                  s=s,
-                                  marker=marker,
-                                  color=color,
-                                  alpha=self.point_alpha[k],
-                                  edgecolor=None,
-                                  zdir='z',
-                                  )
-
-            elif self.point_style[k] == 'l':
-                self.axes.plot(np.real(points[1]),
-                               -np.real(points[0]),
-                               np.real(points[2]),
-                               color=color,
-                               alpha=self.point_alpha[k],
-                               zdir='z',
-                               )
-
-    def plot_annotations(self):
-        # -X and Y data are switched for plotting purposes
-        for annotation in self.annotations:
-            vec = annotation['position']
-            opts = {'fontsize': self.font_size,
-                    'color': self.font_color,
-                    'horizontalalignment': 'center',
-                    'verticalalignment': 'center'}
-            opts.update(annotation['opts'])
-            self.axes.text(vec[1], -vec[0], vec[2],
-                           annotation['text'], **opts)
-
-    def plot_lines(self):
-        for line, fmt, kw in self._lines:
-            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
-
-    def plot_arcs(self):
-        for arc, fmt, kw in self._arcs:
-            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
-
-    def show(self):
-        """
-        Display Bloch sphere and corresponding data sets.
-
-        Notes
-        -----
-
-        When using inline plotting in Jupyter notebooks, any figure created
-        in a notebook cell is displayed after the cell executes. Thus if you
-        create a figure yourself and use it create a Bloch sphere with
-        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
-        cell, then the figure will be displayed twice. If you do create your
-        own figure, the simplest solution to this is to not call ``.show()``
-        in the cell you create the figure in.
-        """
-        self.render()
-        if self.run_from_ipython():
-            display(self.fig)
-        else:
-            self.fig.show()
-
-    def save(self, name=None, format='png', dirc=None, dpin=None):
-        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
-
-        Parameters
-        ----------
-
-        name : str
-            Name of saved image. Must include path and format as well.
-            i.e. '/Users/Paul/Desktop/bloch.png'
-            This overrides the 'format' and 'dirc' arguments.
-        format : str
-            Format of output image.
-        dirc : str
-            Directory for output images. Defaults to current working directory.
-        dpin : int
-            Resolution in dots per inch.
-
-        Returns
-        -------
-        File containing plot of Bloch sphere.
-
-        """
-        self.render()
-        # Conditional variable for first argument to savefig
-        # that is set in subsequent if-elses
-        complete_path = ""
-        if dirc:
-            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
-                os.makedirs(os.getcwd() + "/" + str(dirc))
-        if name is None:
-            if dirc:
-                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
-                                + str(self.savenum) + '.' + format
-            else:
-                complete_path = os.getcwd() + '/bloch_' + \
-                                str(self.savenum) + '.' + format
-        else:
-            complete_path = name
-
-        if dpin:
-            self.fig.savefig(complete_path, dpi=dpin)
-        else:
-            self.fig.savefig(complete_path)
-        self.savenum += 1
-        if self.fig:
-            plt.close(self.fig)
-
-
-def _hide_tick_lines_and_labels(axis):
-    '''
-    Set visible property of ticklines and ticklabels of an axis to False
-    '''
-    for a in axis.get_ticklines() + axis.get_ticklabels():
-        a.set_visible(False)
+__all__ = ['Bloch']
+
+import os
+
+import numpy as np
+from numpy import (outer, cos, sin, ones)
+
+from packaging.version import parse as parse_version
+
+from . import Qobj, expect, sigmax, sigmay, sigmaz
+
+try:
+    import matplotlib
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d import Axes3D
+    from matplotlib.patches import FancyArrowPatch
+    from mpl_toolkits.mplot3d import proj3d
+
+    # Define a custom _axes3D function based on the matplotlib version.
+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+    if parse_version(matplotlib.__version__) >= parse_version('3.4'):
+        def _axes3D(fig, *args, **kwargs):
+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+            return fig.add_axes(ax)
+    else:
+        def _axes3D(*args, **kwargs):
+            return Axes3D(*args, **kwargs)
+
+    class Arrow3D(FancyArrowPatch):
+        def __init__(self, xs, ys, zs, *args, **kwargs):
+            FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
+
+            self._verts3d = xs, ys, zs
+
+        def draw(self, renderer):
+            xs3d, ys3d, zs3d = self._verts3d
+            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+
+            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+            FancyArrowPatch.draw(self, renderer)
+
+        def do_3d_projection(self, renderer=None):
+            # only called by matplotlib >= 3.5
+            xs3d, ys3d, zs3d = self._verts3d
+            xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+            return np.min(zs)
+except ImportError:
+    pass
+
+try:
+    from IPython.display import display
+except ImportError:
+    pass
+
+
+class Bloch:
+    r"""
+    Class for plotting data on the Bloch sphere.  Valid data can be either
+    points, vectors, or Qobj objects.
+
+    Attributes
+    ----------
+    axes : matplotlib.axes.Axes
+        User supplied Matplotlib axes for Bloch sphere animation.
+    fig : matplotlib.figure.Figure
+        User supplied Matplotlib Figure instance for plotting Bloch sphere.
+    font_color : str, default 'black'
+        Color of font used for Bloch sphere labels.
+    font_size : int, default 20
+        Size of font used for Bloch sphere labels.
+    frame_alpha : float, default 0.1
+        Sets transparency of Bloch sphere frame.
+    frame_color : str, default 'gray'
+        Color of sphere wireframe.
+    frame_width : int, default 1
+        Width of wireframe.
+    point_color : list, default ["b", "r", "g", "#CC6600"]
+        List of colors for Bloch sphere point markers to cycle through, i.e.
+        by default, points 0 and 4 will both be blue ('b').
+    point_marker : list, default ["o", "s", "d", "^"]
+        List of point marker shapes to cycle through.
+    point_size : list, default [25, 32, 35, 45]
+        List of point marker sizes. Note, not all point markers look the same
+        size when plotted!
+    sphere_alpha : float, default 0.2
+        Transparency of Bloch sphere itself.
+    sphere_color : str, default '#FFDDDD'
+        Color of Bloch sphere.
+    figsize : list, default [7, 7]
+        Figure size of Bloch sphere plot.  Best to have both numbers the same;
+        otherwise you will have a Bloch sphere that looks like a football.
+    vector_color : list, ["g", "#CC6600", "b", "r"]
+        List of vector colors to cycle through.
+    vector_width : int, default 5
+        Width of displayed vectors.
+    vector_style : str, default '-\|>'
+        Vector arrowhead style (from matplotlib's arrow style).
+    vector_mutation : int, default 20
+        Width of vectors arrowhead.
+    view : list, default [-60, 30]
+        Azimuthal and Elevation viewing angles.
+    xlabel : list, default ["$x$", ""]
+        List of strings corresponding to +x and -x axes labels, respectively.
+    xlpos : list, default [1.1, -1.1]
+        Positions of +x and -x labels respectively.
+    ylabel : list, default ["$y$", ""]
+        List of strings corresponding to +y and -y axes labels, respectively.
+    ylpos : list, default [1.2, -1.2]
+        Positions of +y and -y labels respectively.
+    zlabel : list, default ['$\\left\|0\\right>$', '$\\left\|1\\right>$']
+        List of strings corresponding to +z and -z axes labels, respectively.
+    zlpos : list, default [1.2, -1.2]
+        Positions of +z and -z labels respectively.
+    """
+    def __init__(self, fig=None, axes=None, view=None, figsize=None,
+                 background=False):
+        # Figure and axes
+        self.fig = fig
+        self._ext_fig = fig is not None
+        self.axes = axes
+        # Background axes, default = False
+        self.background = background
+        # The size of the figure in inches, default = [5,5].
+        self.figsize = figsize if figsize else [5, 5]
+        # Azimuthal and Elvation viewing angles, default = [-60,30].
+        self.view = view if view else [-60, 30]
+        # Color of Bloch sphere, default = #FFDDDD
+        self.sphere_color = '#FFDDDD'
+        # Transparency of Bloch sphere, default = 0.2
+        self.sphere_alpha = 0.2
+        # Color of wireframe, default = 'gray'
+        self.frame_color = 'gray'
+        # Width of wireframe, default = 1
+        self.frame_width = 1
+        # Transparency of wireframe, default = 0.2
+        self.frame_alpha = 0.2
+        # Labels for x-axis (in LaTex), default = ['$x$', '']
+        self.xlabel = ['$x$', '']
+        # Position of x-axis labels, default = [1.2, -1.2]
+        self.xlpos = [1.2, -1.2]
+        # Labels for y-axis (in LaTex), default = ['$y$', '']
+        self.ylabel = ['$y$', '']
+        # Position of y-axis labels, default = [1.1, -1.1]
+        self.ylpos = [1.2, -1.2]
+        # Labels for z-axis (in LaTex),
+        # default = [r'$\left\|0\right>$', r'$\left|1\right>$']
+        self.zlabel = [r'$\left|0\right>$', r'$\left|1\right>$']
+        # Position of z-axis labels, default = [1.2, -1.2]
+        self.zlpos = [1.2, -1.2]
+        # ---font options---
+        # Color of fonts, default = 'black'
+        self.font_color = 'black'
+        # Size of fonts, default = 20
+        self.font_size = 20
+
+        # ---vector options---
+        # List of colors for Bloch vectors, default = ['b','g','r','y']
+        self.vector_default_color = ['g', '#CC6600', 'b', 'r']
+        # List that stores the display colors for each vector
+        self.vector_color = []
+        #: Width of Bloch vectors, default = 5
+        self.vector_width = 3
+        #: Style of Bloch vectors, default = '-\|>' (or 'simple')
+        self.vector_style = '-|>'
+        #: Sets the width of the vectors arrowhead
+        self.vector_mutation = 20
+
+        # ---point options---
+        # List of colors for Bloch point markers, default = ['b','g','r','y']
+        self.point_default_color = ['b', 'r', 'g', '#CC6600']
+        # List that stores the display colors for each set of points
+        self.point_color = []
+        # Size of point markers, default = 25
+        self.point_size = [25, 32, 35, 45]
+        # Shape of point markers, default = ['o','^','d','s']
+        self.point_marker = ['o', 's', 'd', '^']
+
+        # ---data lists---
+        # Data for point markers
+        self.points = []
+        # Data for Bloch vectors
+        self.vectors = []
+        # Transparency of vectors, alpha value from 0 to 1
+        self.vector_alpha = []
+        # Data for annotations
+        self.annotations = []
+        # Number of times sphere has been saved
+        self.savenum = 0
+        # Style of points, 'm' for multiple colors, 's' for single color
+        self.point_style = []
+        # Transparency of points, alpha value from 0 to 1
+        self.point_alpha = []
+        # Data for line segment
+        self._lines = []
+        # Data for arcs and arc style
+        self._arcs = []
+
+    def set_label_convention(self, convention):
+        """Set x, y and z labels according to one of conventions.
+
+        Parameters
+        ----------
+        convention : string
+            One of the following:
+
+            - "original"
+            - "xyz"
+            - "sx sy sz"
+            - "01"
+            - "polarization jones"
+            - "polarization jones letters"
+              see also: https://en.wikipedia.org/wiki/Jones_calculus
+            - "polarization stokes"
+              see also: https://en.wikipedia.org/wiki/Stokes_parameters
+        """
+        ketex = "$\\left.|%s\\right\\rangle$"
+        # \left.| is on purpose, so that every ket has the same size
+
+        if convention == "original":
+            self.xlabel = ['$x$', '']
+            self.ylabel = ['$y$', '']
+            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
+        elif convention == "xyz":
+            self.xlabel = ['$x$', '']
+            self.ylabel = ['$y$', '']
+            self.zlabel = ['$z$', '']
+        elif convention == "sx sy sz":
+            self.xlabel = ['$s_x$', '']
+            self.ylabel = ['$s_y$', '']
+            self.zlabel = ['$s_z$', '']
+        elif convention == "01":
+            self.xlabel = ['', '']
+            self.ylabel = ['', '']
+            self.zlabel = ['$\\left|0\\right>$', '$\\left|1\\right>$']
+        elif convention == "polarization jones":
+            self.xlabel = [ketex % "\\nearrow\\hspace{-1.46}\\swarrow",
+                           ketex % "\\nwarrow\\hspace{-1.46}\\searrow"]
+            self.ylabel = [ketex % "\\circlearrowleft", ketex %
+                           "\\circlearrowright"]
+            self.zlabel = [ketex % "\\leftrightarrow", ketex % "\\updownarrow"]
+        elif convention == "polarization jones letters":
+            self.xlabel = [ketex % "D", ketex % "A"]
+            self.ylabel = [ketex % "L", ketex % "R"]
+            self.zlabel = [ketex % "H", ketex % "V"]
+        elif convention == "polarization stokes":
+            self.ylabel = ["$\\nearrow\\hspace{-1.46}\\swarrow$",
+                           "$\\nwarrow\\hspace{-1.46}\\searrow$"]
+            self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
+            self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
+        else:
+            raise Exception("No such convention.")
+
+    def __str__(self):
+        s = ""
+        s += "Bloch data:\n"
+        s += "-----------\n"
+        s += "Number of points:  " + str(len(self.points)) + "\n"
+        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
+        s += "\n"
+        s += "Bloch sphere properties:\n"
+        s += "------------------------\n"
+        s += "font_color:      " + str(self.font_color) + "\n"
+        s += "font_size:       " + str(self.font_size) + "\n"
+        s += "frame_alpha:     " + str(self.frame_alpha) + "\n"
+        s += "frame_color:     " + str(self.frame_color) + "\n"
+        s += "frame_width:     " + str(self.frame_width) + "\n"
+        s += "point_default_color:" + str(self.point_default_color) + "\n"
+        s += "point_marker:    " + str(self.point_marker) + "\n"
+        s += "point_size:      " + str(self.point_size) + "\n"
+        s += "sphere_alpha:    " + str(self.sphere_alpha) + "\n"
+        s += "sphere_color:    " + str(self.sphere_color) + "\n"
+        s += "figsize:         " + str(self.figsize) + "\n"
+        s += "vector_default_color:" + str(self.vector_default_color) + "\n"
+        s += "vector_width:    " + str(self.vector_width) + "\n"
+        s += "vector_style:    " + str(self.vector_style) + "\n"
+        s += "vector_mutation: " + str(self.vector_mutation) + "\n"
+        s += "view:            " + str(self.view) + "\n"
+        s += "xlabel:          " + str(self.xlabel) + "\n"
+        s += "xlpos:           " + str(self.xlpos) + "\n"
+        s += "ylabel:          " + str(self.ylabel) + "\n"
+        s += "ylpos:           " + str(self.ylpos) + "\n"
+        s += "zlabel:          " + str(self.zlabel) + "\n"
+        s += "zlpos:           " + str(self.zlpos) + "\n"
+        return s
+
+    def _repr_png_(self):
+        from IPython.core.pylabtools import print_figure
+        self.render()
+        fig_data = print_figure(self.fig, 'png')
+        plt.close(self.fig)
+        return fig_data
+
+    def _repr_svg_(self):
+        from IPython.core.pylabtools import print_figure
+        self.render()
+        fig_data = print_figure(self.fig, 'svg')
+        plt.close(self.fig)
+        return fig_data
+
+    def clear(self):
+        """Resets Bloch sphere data sets to empty.
+        """
+        self.points = []
+        self.vectors = []
+        self.point_style = []
+        self.point_alpha = []
+        self.vector_alpha = []
+        self.annotations = []
+        self.vector_color = []
+        self.point_color = []
+        self._lines = []
+        self._arcs = []
+
+    def add_points(self, points, meth='s', colors=None, alpha=1.0):
+        """Add a list of data points to bloch sphere.
+
+        Parameters
+        ----------
+        points : array_like
+            Collection of data points.
+
+        meth : {'s', 'm', 'l'}
+            Type of points to plot, use 'm' for multicolored, 'l' for points
+            connected with a line.
+
+        colors : array_like
+            Optional array with colors for the points.
+            A single color for meth 's', and list of colors for meth 'm'
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        .. note::
+
+           When using ``meth=l`` in QuTiP 4.6, the line transparency defaulted
+           to ``0.75`` and there was no way to alter it.
+           When the ``alpha`` parameter was added in QuTiP 4.7, the default
+           became ``alpha=1.0`` for values of ``meth``.
+        """
+
+        points = np.asarray(points)
+
+        if points.ndim == 1:
+            points = points[:, np.newaxis]
+
+        if points.ndim != 2 or points.shape[0] != 3:
+            raise ValueError("The included points are not valid. Points must "
+                             "be equivalent to a 2D array where the first "
+                             "index represents the x,y,z values and the "
+                             "second index iterates over the points.")
+
+        if meth not in ['s', 'm', 'l']:
+            raise ValueError(f"The value for meth = {meth} is not valid."
+                             " Please use 's', 'l' or 'm'.")
+
+        if meth == 's' and points.shape[1] == 1:
+            points = np.append(points[:, :1], points, axis=1)
+
+        self.point_style.append(meth)
+        self.points.append(points)
+        self.point_alpha.append(alpha)
+        self.point_color.append(colors)
+
+    def add_states(self, state, kind='vector', colors=None, alpha=1.0):
+        """Add a state vector Qobj to Bloch sphere.
+
+        Parameters
+        ----------
+        state : Qobj
+            Input state vector.
+
+        kind : {'vector', 'point'}
+            Type of object to plot.
+
+        colors : array_like
+            Optional array with colors for the states.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+        """
+        if isinstance(state, Qobj):
+            state = [state]
+        if not isinstance(colors, (list, np.ndarray)) and colors is not None:
+            colors = [colors]
+
+        for k, st in enumerate(state):
+            vec = [expect(sigmax(), st),
+                   expect(sigmay(), st),
+                   expect(sigmaz(), st)]
+
+            if kind == 'vector':
+                if colors is not None:
+                    self.add_vectors(vec, colors=colors[k], alpha=alpha)
+                else:
+                    self.add_vectors(vec)
+            elif kind == 'point':
+                if colors is not None:
+                    self.add_points(vec, colors=colors[k], alpha=alpha)
+                else:
+                    self.add_points(vec)
+
+    def add_vectors(self, vectors, colors=None, alpha=1.0):
+        """Add a list of vectors to Bloch sphere.
+
+        Parameters
+        ----------
+        vectors : array_like
+            Array with vectors of unit length or smaller.
+
+        colors : array_like
+            Optional array with colors for the vectors.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        """
+        vectors = np.asarray(vectors)
+
+        if vectors.ndim == 1:
+            vectors = vectors[np.newaxis, :]
+
+        if vectors.ndim != 2 or vectors.shape[1] != 3:
+            raise ValueError(
+                "The included vectors are not valid. Vectors must "
+                "be equivalent to a 2D array where the first "
+                "index represents the iteration over the vectors and the "
+                "second index represents the position in 3D of vector head.")
+
+        n_vectors = vectors.shape[0]
+        if colors is None:
+            colors = np.array([None] * n_vectors)
+        else:
+            colors = np.asarray(colors)
+
+        if colors.ndim != 1 or colors.size != n_vectors:
+            raise ValueError("The included colors are not valid. colors must "
+                             "be equivalent to a 1D array with the same "
+                             "size as the number of vectors. ")
+
+        for k, vec in enumerate(vectors):
+            self.vectors.append(vec)
+            self.vector_alpha.append(alpha)
+            self.vector_color.append(colors[k])
+
+    def add_annotation(self, state_or_vector, text, **kwargs):
+        """
+        Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit
+        state or a vector.
+
+        Parameters
+        ----------
+        state_or_vector : Qobj/array/list/tuple
+            Position for the annotaion.
+            Qobj of a qubit or a vector of 3 elements.
+
+        text : str
+            Annotation text.
+            You can use LaTeX, but remember to use raw string
+            e.g. r"$\\langle x \\rangle$"
+            or escape backslashes
+            e.g. "$\\\\langle x \\\\rangle$".
+
+        kwargs :
+            Options as for mplot3d.axes3d.text, including:
+            fontsize, color, horizontalalignment, verticalalignment.
+
+        """
+        if isinstance(state_or_vector, Qobj):
+            vec = [expect(sigmax(), state_or_vector),
+                   expect(sigmay(), state_or_vector),
+                   expect(sigmaz(), state_or_vector)]
+        elif isinstance(state_or_vector, (list, np.ndarray, tuple)) \
+                and len(state_or_vector) == 3:
+            vec = state_or_vector
+        else:
+            raise Exception("Position needs to be specified by a qubit " +
+                            "state or a 3D vector.")
+        self.annotations.append({'position': vec,
+                                 'text': text,
+                                 'opts': kwargs})
+
+    def add_arc(self, start, end, fmt="b", steps=None, **kwargs):
+        """Adds an arc between two points on a sphere. The arc is set to be
+        blue solid curve by default.
+
+        The start and end points must be on the same sphere (i.e. have the
+        same radius) but need not be on the unit sphere.
+
+        Parameters
+        ----------
+        start : Qobj or array-like
+            Array with cartesian coordinates of the first point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        end : Qobj or array-like
+            Array with cartesian coordinates of the second point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        fmt : str, default: "b"
+            A matplotlib format string for rendering the arc.
+        steps : int, default: None
+            The number of segments to use when rendering the arc. The default
+            uses 100 steps times the distance between the start and end points,
+            with a minimum of 2 steps.
+        **kwargs : dict
+            Additional parameters to pass to the matplotlib .plot function
+            when rendering this arc.
+        """
+        if isinstance(start, Qobj):
+            pt1 = [
+                expect(sigmax(), start),
+                expect(sigmay(), start),
+                expect(sigmaz(), start),
+            ]
+        else:
+            pt1 = start
+
+        if isinstance(end, Qobj):
+            pt2 = [
+                expect(sigmax(), end),
+                expect(sigmay(), end),
+                expect(sigmaz(), end),
+            ]
+        else:
+            pt2 = end
+
+        pt1 = np.asarray(pt1)
+        pt2 = np.asarray(pt2)
+
+        len1 = np.linalg.norm(pt1)
+        len2 = np.linalg.norm(pt2)
+        if len1 < 1e-12 or len2 < 1e-12:
+            raise ValueError('Polar and azimuthal angles undefined at origin.')
+        elif abs(len1 - len2) > 1e-12:
+            raise ValueError("Points not on the same sphere.")
+        elif (pt1 == pt2).all():
+            raise ValueError(
+                "Start and end represent the same point. No arc can be formed."
+            )
+        elif (pt1 == -pt2).all():
+            raise ValueError(
+                "Start and end are diagonally opposite, no unique arc is"
+                " possible."
+            )
+
+        if steps is None:
+            steps = int(np.linalg.norm(pt1 - pt2) * 100)
+            steps = max(2, steps)
+        t = np.linspace(0, 1, steps)
+        # All the points in this line are contained in the plane defined
+        # by pt1, pt2 and the origin.
+        line = pt1[:, np.newaxis] * t + pt2[:, np.newaxis] * (1 - t)
+        # Normalize all the points in the line so that are distance len1 from
+        # the origin.
+        arc = line * len1 / np.linalg.norm(line, axis=0)
+        self._arcs.append([arc, fmt, kwargs])
+
+    def add_line(self, start, end, fmt="k", **kwargs):
+        """Adds a line segment connecting two points on the bloch sphere.
+
+        The line segment is set to be a black solid line by default.
+
+        Parameters
+        ----------
+        start : Qobj or array-like
+            Array with cartesian coordinates of the first point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        end : Qobj or array-like
+            Array with cartesian coordinates of the second point, or a state
+            vector or density matrix that can be mapped to a point on or
+            within the Bloch sphere.
+        fmt : str, default: "k"
+            A matplotlib format string for rendering the line.
+        **kwargs : dict
+            Additional parameters to pass to the matplotlib .plot function
+            when rendering this line.
+        """
+        if isinstance(start, Qobj):
+            pt1 = [
+                expect(sigmax(), start),
+                expect(sigmay(), start),
+                expect(sigmaz(), start),
+            ]
+        else:
+            pt1 = start
+
+        if isinstance(end, Qobj):
+            pt2 = [
+                expect(sigmax(), end),
+                expect(sigmay(), end),
+                expect(sigmaz(), end),
+            ]
+        else:
+            pt2 = end
+
+        pt1 = np.asarray(pt1)
+        pt2 = np.asarray(pt2)
+
+        x = [pt1[1], pt2[1]]
+        y = [-pt1[0], -pt2[0]]
+        z = [pt1[2], pt2[2]]
+        v = [x, y, z]
+        self._lines.append([v, fmt, kwargs])
+
+    def make_sphere(self):
+        """
+        Plots Bloch sphere and data sets.
+        """
+        self.render()
+
+    def run_from_ipython(self):
+        try:
+            __IPYTHON__
+            return True
+        except NameError:
+            return False
+
+    def _is_inline_backend(self):
+        backend = matplotlib.get_backend()
+        return backend == "module://matplotlib_inline.backend_inline"
+
+    def render(self):
+        """
+        Render the Bloch sphere and its data sets in on given figure and axes.
+        """
+        if not self._ext_fig and not self._is_inline_backend():
+            # If no external figure was supplied, we check to see if the
+            # figure we created in a previous call to .render() has been
+            # closed, and re-create if has been. This has the unfortunate
+            # side effect of losing any modifications made to the axes or
+            # figure, but the alternative is to crash the matplotlib backend.
+            #
+            # The inline backend used by, e.g. jupyter notebooks, is happy to
+            # use closed figures so we leave those figures intact.
+            if (
+                self.fig is not None and
+                not plt.fignum_exists(self.fig.number)
+            ):
+                self.fig = None
+                self.axes = None
+
+        if self.fig is None:
+            self.fig = plt.figure(figsize=self.figsize)
+            if self._is_inline_backend():
+                # We immediately close the inline figure do avoid displaying
+                # the figure twice when .show() calls display.
+                plt.close(self.fig)
+
+        if self.axes is None:
+            self.axes = _axes3D(self.fig, azim=self.view[0], elev=self.view[1])
+
+        # Clearing the axes is horrifically slow and loses a lot of the
+        # axes state, but matplotlib doesn't seem to provide a better way
+        # to redraw Axes3D. :/
+        self.axes.clear()
+        self.axes.grid(False)
+        if self.background:
+            self.axes.set_xlim3d(-1.3, 1.3)
+            self.axes.set_ylim3d(-1.3, 1.3)
+            self.axes.set_zlim3d(-1.3, 1.3)
+        else:
+            self.axes.set_axis_off()
+            self.axes.set_xlim3d(-0.7, 0.7)
+            self.axes.set_ylim3d(-0.7, 0.7)
+            self.axes.set_zlim3d(-0.7, 0.7)
+        # Manually set aspect ratio to fit a square bounding box.
+        # Matplotlib did this stretching for < 3.3.0, but not above.
+        if parse_version(matplotlib.__version__) >= parse_version('3.3'):
+            self.axes.set_box_aspect((1, 1, 1))
+        if not self.background:
+            self.plot_axes()
+
+        self.plot_back()
+        self.plot_points()
+        self.plot_vectors()
+        self.plot_lines()
+        self.plot_arcs()
+        self.plot_front()
+        self.plot_axes_labels()
+        self.plot_annotations()
+        # Trigger an update of the Bloch sphere if it is already shown:
+        self.fig.canvas.draw()
+
+    def plot_back(self):
+        # back half of sphere
+        u = np.linspace(0, np.pi, 25)
+        v = np.linspace(0, np.pi, 25)
+        x = outer(cos(u), sin(v))
+        y = outer(sin(u), sin(v))
+        z = outer(ones(np.size(u)), cos(v))
+        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
+                               color=self.sphere_color, linewidth=0,
+                               alpha=self.sphere_alpha)
+        # wireframe
+        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
+                                 color=self.frame_color,
+                                 alpha=self.frame_alpha)
+        # equator
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='z',
+                       lw=self.frame_width, color=self.frame_color)
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u), zs=0, zdir='x',
+                       lw=self.frame_width, color=self.frame_color)
+
+    def plot_front(self):
+        # front half of sphere
+        u = np.linspace(-np.pi, 0, 25)
+        v = np.linspace(0, np.pi, 25)
+        x = outer(cos(u), sin(v))
+        y = outer(sin(u), sin(v))
+        z = outer(ones(np.size(u)), cos(v))
+        self.axes.plot_surface(x, y, z, rstride=2, cstride=2,
+                               color=self.sphere_color, linewidth=0,
+                               alpha=self.sphere_alpha)
+        # wireframe
+        self.axes.plot_wireframe(x, y, z, rstride=5, cstride=5,
+                                 color=self.frame_color,
+                                 alpha=self.frame_alpha)
+        # equator
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
+                       zs=0, zdir='z', lw=self.frame_width,
+                       color=self.frame_color)
+        self.axes.plot(1.0 * cos(u), 1.0 * sin(u),
+                       zs=0, zdir='x', lw=self.frame_width,
+                       color=self.frame_color)
+
+    def plot_axes(self):
+        # axes
+        span = np.linspace(-1.0, 1.0, 2)
+        self.axes.plot(span, 0 * span, zs=0, zdir='z', label='X',
+                       lw=self.frame_width, color=self.frame_color)
+        self.axes.plot(0 * span, span, zs=0, zdir='z', label='Y',
+                       lw=self.frame_width, color=self.frame_color)
+        self.axes.plot(0 * span, span, zs=0, zdir='y', label='Z',
+                       lw=self.frame_width, color=self.frame_color)
+
+    def plot_axes_labels(self):
+        # axes labels
+        opts = {'fontsize': self.font_size,
+                'color': self.font_color,
+                'horizontalalignment': 'center',
+                'verticalalignment': 'center'}
+        self.axes.text(0, -self.xlpos[0], 0, self.xlabel[0], **opts)
+        self.axes.text(0, -self.xlpos[1], 0, self.xlabel[1], **opts)
+
+        self.axes.text(self.ylpos[0], 0, 0, self.ylabel[0], **opts)
+        self.axes.text(self.ylpos[1], 0, 0, self.ylabel[1], **opts)
+
+        self.axes.text(0, 0, self.zlpos[0], self.zlabel[0], **opts)
+        self.axes.text(0, 0, self.zlpos[1], self.zlabel[1], **opts)
+
+        for a in (self.axes.xaxis.get_ticklines() +
+                  self.axes.xaxis.get_ticklabels()):
+            a.set_visible(False)
+        for a in (self.axes.yaxis.get_ticklines() +
+                  self.axes.yaxis.get_ticklabels()):
+            a.set_visible(False)
+        for a in (self.axes.zaxis.get_ticklines() +
+                  self.axes.zaxis.get_ticklabels()):
+            a.set_visible(False)
+
+    def plot_vectors(self):
+        # -X and Y data are switched for plotting purposes
+        for k, vec in enumerate(self.vectors):
+
+            xs3d = vec[1] * np.array([0, 1])
+            ys3d = -vec[0] * np.array([0, 1])
+            zs3d = vec[2] * np.array([0, 1])
+
+            alpha = self.vector_alpha[k]
+            color = self.vector_color[k]
+            if color is None:
+                idx = k % len(self.vector_default_color)
+                color = self.vector_default_color[idx]
+
+            # decorated style, with arrow heads
+            a = Arrow3D(xs3d, ys3d, zs3d,
+                        mutation_scale=self.vector_mutation,
+                        lw=self.vector_width,
+                        arrowstyle=self.vector_style,
+                        color=color, alpha=alpha)
+
+            self.axes.add_artist(a)
+
+    def plot_points(self):
+        # -X and Y data are switched for plotting purposes
+        for k, points in enumerate(self.points):
+            points = np.asarray(points)
+            num_points = points.shape[1]
+
+            dist = np.linalg.norm(points, axis=0)
+            if not np.allclose(dist, dist[0], rtol=1e-12):
+                indperm = np.argsort(dist)
+                points = points[:, indperm]
+            else:
+                indperm = np.arange(num_points)
+
+            s = self.point_size[np.mod(k, len(self.point_size))]
+            marker = self.point_marker[np.mod(k, len(self.point_marker))]
+            style = self.point_style[k]
+            if self.point_color[k] is not None:
+                color = self.point_color[k]
+            elif self.point_style[k] in ['s', 'l']:
+                color = self.point_default_color[
+                    k % len(self.point_default_color)
+                ]
+            elif self.point_style[k] == 'm':
+                length = np.ceil(num_points/len(self.point_default_color))
+                color = np.tile(self.point_default_color, length.astype(int))
+                color = color[indperm]
+
+            if self.point_style[k] in ['s', 'm']:
+                self.axes.scatter(np.real(points[1]),
+                                  -np.real(points[0]),
+                                  np.real(points[2]),
+                                  s=s,
+                                  marker=marker,
+                                  color=color,
+                                  alpha=self.point_alpha[k],
+                                  edgecolor=None,
+                                  zdir='z',
+                                  )
+
+            elif self.point_style[k] == 'l':
+                self.axes.plot(np.real(points[1]),
+                               -np.real(points[0]),
+                               np.real(points[2]),
+                               color=color,
+                               alpha=self.point_alpha[k],
+                               zdir='z',
+                               )
+
+    def plot_annotations(self):
+        # -X and Y data are switched for plotting purposes
+        for annotation in self.annotations:
+            vec = annotation['position']
+            opts = {'fontsize': self.font_size,
+                    'color': self.font_color,
+                    'horizontalalignment': 'center',
+                    'verticalalignment': 'center'}
+            opts.update(annotation['opts'])
+            self.axes.text(vec[1], -vec[0], vec[2],
+                           annotation['text'], **opts)
+
+    def plot_lines(self):
+        for line, fmt, kw in self._lines:
+            self.axes.plot(line[0], line[1], line[2], fmt, **kw)
+
+    def plot_arcs(self):
+        for arc, fmt, kw in self._arcs:
+            self.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
+
+    def show(self):
+        """
+        Display Bloch sphere and corresponding data sets.
+
+        Notes
+        -----
+
+        When using inline plotting in Jupyter notebooks, any figure created
+        in a notebook cell is displayed after the cell executes. Thus if you
+        create a figure yourself and use it create a Bloch sphere with
+        ``b = Bloch(..., fig=fig)`` and then call ``b.show()`` in the same
+        cell, then the figure will be displayed twice. If you do create your
+        own figure, the simplest solution to this is to not call ``.show()``
+        in the cell you create the figure in.
+        """
+        self.render()
+        if self.run_from_ipython():
+            display(self.fig)
+        else:
+            self.fig.show()
+
+    def save(self, name=None, format='png', dirc=None, dpin=None):
+        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
+
+        Parameters
+        ----------
+
+        name : str
+            Name of saved image. Must include path and format as well.
+            i.e. '/Users/Paul/Desktop/bloch.png'
+            This overrides the 'format' and 'dirc' arguments.
+        format : str
+            Format of output image.
+        dirc : str
+            Directory for output images. Defaults to current working directory.
+        dpin : int
+            Resolution in dots per inch.
+
+        Returns
+        -------
+        File containing plot of Bloch sphere.
+
+        """
+        self.render()
+        # Conditional variable for first argument to savefig
+        # that is set in subsequent if-elses
+        complete_path = ""
+        if dirc:
+            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
+                os.makedirs(os.getcwd() + "/" + str(dirc))
+        if name is None:
+            if dirc:
+                complete_path = os.getcwd() + "/" + str(dirc) + '/bloch_' \
+                                + str(self.savenum) + '.' + format
+            else:
+                complete_path = os.getcwd() + '/bloch_' + \
+                                str(self.savenum) + '.' + format
+        else:
+            complete_path = name
+
+        if dpin:
+            self.fig.savefig(complete_path, dpi=dpin)
+        else:
+            self.fig.savefig(complete_path)
+        self.savenum += 1
+        if self.fig:
+            plt.close(self.fig)
+
+
+def _hide_tick_lines_and_labels(axis):
+    '''
+    Set visible property of ticklines and ticklabels of an axis to False
+    '''
+    for a in axis.get_ticklines() + axis.get_ticklabels():
+        a.set_visible(False)
diff --git a/qutip/bloch3d.py b/qutip/bloch3d.py
index 748e5cf750..d387b6c4d3 100644
--- a/qutip/bloch3d.py
+++ b/qutip/bloch3d.py
@@ -1,517 +1,517 @@
-__all__ = ['Bloch3d']
-
-import numpy as np
-from . import Qobj, expect, sigmax, sigmay, sigmaz
-
-
-class Bloch3d:
-    """Class for plotting data on a 3D Bloch sphere using mayavi.
-    Valid data can be either points, vectors, or qobj objects
-    corresponding to state vectors or density matrices. for
-    a two-state system (or subsystem).
-
-    Attributes
-    ----------
-    fig : instance {None}
-        User supplied Matplotlib Figure instance for plotting Bloch sphere.
-    font_color : str {'black'}
-        Color of font used for Bloch sphere labels.
-    font_scale : float {0.08}
-        Scale for font used for Bloch sphere labels.
-    frame : bool {True}
-        Draw frame for Bloch sphere
-    frame_alpha : float {0.05}
-        Sets transparency of Bloch sphere frame.
-    frame_color : str {'gray'}
-        Color of sphere wireframe.
-    frame_num : int {8}
-        Number of frame elements to draw.
-    frame_radius : floats {0.005}
-        Width of wireframe.
-    point_color : list {['r', 'g', 'b', 'y']}
-        List of colors for Bloch sphere point markers to cycle through.
-        i.e. By default, points 0 and 4 will both be blue ('r').
-    point_mode : string {'sphere','cone','cube','cylinder','point'}
-        Point marker shapes.
-    point_size : float {0.075}
-        Size of points on Bloch sphere.
-    sphere_alpha : float {0.1}
-        Transparency of Bloch sphere itself.
-    sphere_color : str {'#808080'}
-        Color of Bloch sphere.
-    size : list {[500,500]}
-        Size of Bloch sphere plot in pixels. Best to have both numbers the same
-        otherwise you will have a Bloch sphere that looks like a football.
-    vector_color : list {['r', 'g', 'b', 'y']}
-        List of vector colors to cycle through.
-    vector_width : int {3}
-        Width of displayed vectors.
-    view : list {[45,65]}
-        Azimuthal and Elevation viewing angles.
-    xlabel : list {``['|x>', '']``}
-        List of strings corresponding to +x and -x axes labels, respectively.
-    xlpos : list {[1.07,-1.07]}
-        Positions of +x and -x labels respectively.
-    ylabel : list {``['|y>', '']``}
-        List of strings corresponding to +y and -y axes labels, respectively.
-    ylpos : list {[1.07,-1.07]}
-        Positions of +y and -y labels respectively.
-    zlabel : list {``['|0>', '|1>']``}
-        List of strings corresponding to +z and -z axes labels, respectively.
-    zlpos : list {[1.07,-1.07]}
-        Positions of +z and -z labels respectively.
-
-    Notes
-    -----
-    The use of mayavi for 3D rendering of the Bloch sphere comes with
-    a few limitations: I) You can not embed a Bloch3d figure into a
-    matplotlib window. II) The use of LaTex is not supported by the
-    mayavi rendering engine. Therefore all labels must be defined using
-    standard text. Of course you can post-process the generated figures
-    later to add LaTeX using other software if needed.
-
-
-    """
-    def __init__(self, fig=None):
-        # ----check for mayavi-----
-        try:
-            from mayavi import mlab
-        except:
-            raise Exception("This function requires the mayavi module.")
-
-        # ---Image options---
-        self.fig = None
-        self.user_fig = None
-        # check if user specified figure or axes.
-        if fig:
-            self.user_fig = fig
-        # The size of the figure in inches, default = [500,500].
-        self.size = [500, 500]
-        # Azimuthal and Elvation viewing angles, default = [45,65].
-        self.view = [45, 65]
-        # Image background color
-        self.bgcolor = 'white'
-        # Image foreground color. Other options can override.
-        self.fgcolor = 'black'
-
-        # ---Sphere options---
-        # Color of Bloch sphere, default = #808080
-        self.sphere_color = '#808080'
-        # Transparency of Bloch sphere, default = 0.1
-        self.sphere_alpha = 0.1
-
-        # ---Frame options---
-        # Draw frame?
-        self.frame = True
-        # number of lines to draw for frame
-        self.frame_num = 8
-        # Color of wireframe, default = 'gray'
-        self.frame_color = 'black'
-        # Transparency of wireframe, default = 0.2
-        self.frame_alpha = 0.05
-        # Radius of frame lines
-        self.frame_radius = 0.005
-
-        # --Axes---
-        # Axes color
-        self.axes_color = 'black'
-        # Transparency of axes
-        self.axes_alpha = 0.4
-        # Radius of axes lines
-        self.axes_radius = 0.005
-
-        # ---Labels---
-        # Labels for x-axis (in LaTex), default = ['$x$','']
-        self.xlabel = ['|x>', '']
-        # Position of x-axis labels, default = [1.2,-1.2]
-        self.xlpos = [1.07, -1.07]
-        # Labels for y-axis (in LaTex), default = ['$y$','']
-        self.ylabel = ['|y>', '']
-        # Position of y-axis labels, default = [1.1,-1.1]
-        self.ylpos = [1.07, -1.07]
-        # Labels for z-axis
-        self.zlabel = ['|0>', '|1>']
-        # Position of z-axis labels, default = [1.05,-1.05]
-        self.zlpos = [1.07, -1.07]
-
-        # ---Font options---
-        # Color of fonts, default = 'black'
-        self.font_color = 'black'
-        # Size of fonts, default = 20
-        self.font_scale = 0.08
-
-        # ---Vector options---
-        # Object used for representing vectors on Bloch sphere.
-        # List of colors for Bloch vectors, default = ['b','g','r','y']
-        self.vector_color = ['r', 'g', 'b', 'y']
-        # Width of Bloch vectors, default = 2
-        self.vector_width = 2.0
-        # Height of vector head
-        self.vector_head_height = 0.15
-        # Radius of vector head
-        self.vector_head_radius = 0.075
-
-        # ---Point options---
-        # List of colors for Bloch point markers, default = ['b','g','r','y']
-        self.point_color = ['r', 'g', 'b', 'y']
-        # Size of point markers
-        self.point_size = 0.06
-        # Shape of point markers
-        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
-        # Default = 'sphere'
-        self.point_mode = 'sphere'
-
-        # ---Data lists---
-        # Data for point markers
-        self.points = []
-        # Data for Bloch vectors
-        self.vectors = []
-        # Number of times sphere has been saved
-        self.savenum = 0
-        # Style of points, 'm' for multiple colors, 's' for single color
-        self.point_style = []
-        # Transparency of points
-        self.point_alpha = []
-        # Transparency of vectors
-        self.vector_alpha = []
-
-    def __str__(self):
-        s = ""
-        s += "Bloch3D data:\n"
-        s += "-----------\n"
-        s += "Number of points:  " + str(len(self.points)) + "\n"
-        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
-        s += "\n"
-        s += "Bloch3D sphere properties:\n"
-        s += "--------------------------\n"
-        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
-        s += "axes_color:         " + str(self.axes_color) + "\n"
-        s += "axes_radius:        " + str(self.axes_radius) + "\n"
-        s += "bgcolor:            " + str(self.bgcolor) + "\n"
-        s += "fgcolor:            " + str(self.fgcolor) + "\n"
-        s += "font_color:         " + str(self.font_color) + "\n"
-        s += "font_scale:         " + str(self.font_scale) + "\n"
-        s += "frame:              " + str(self.frame) + "\n"
-        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
-        s += "frame_color:        " + str(self.frame_color) + "\n"
-        s += "frame_num:          " + str(self.frame_num) + "\n"
-        s += "frame_radius:       " + str(self.frame_radius) + "\n"
-        s += "point_color:        " + str(self.point_color) + "\n"
-        s += "point_mode:         " + str(self.point_mode) + "\n"
-        s += "point_size:         " + str(self.point_size) + "\n"
-        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
-        s += "sphere_color:       " + str(self.sphere_color) + "\n"
-        s += "size:               " + str(self.size) + "\n"
-        s += "vector_color:       " + str(self.vector_color) + "\n"
-        s += "vector_width:       " + str(self.vector_width) + "\n"
-        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
-        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
-        s += "view:               " + str(self.view) + "\n"
-        s += "xlabel:             " + str(self.xlabel) + "\n"
-        s += "xlpos:              " + str(self.xlpos) + "\n"
-        s += "ylabel:             " + str(self.ylabel) + "\n"
-        s += "ylpos:              " + str(self.ylpos) + "\n"
-        s += "zlabel:             " + str(self.zlabel) + "\n"
-        s += "zlpos:              " + str(self.zlpos) + "\n"
-        return s
-
-    def clear(self):
-        """Resets the Bloch sphere data sets to empty.
-        """
-        self.points = []
-        self.vectors = []
-        self.point_style = []
-
-    def add_points(self, points, meth='s', alpha=1.0):
-        """Add a list of data points to bloch sphere.
-
-        Parameters
-        ----------
-        points : array/list
-            Collection of data points.
-
-        meth : str {'s','m'}
-            Type of points to plot, use 'm' for multicolored.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        """
-        if not isinstance(points[0], (list, np.ndarray)):
-            points = [[points[0]], [points[1]], [points[2]]]
-        points = np.array(points)
-        if meth == 's':
-            if len(points[0]) == 1:
-                pnts = np.array(
-                    [[points[0][0]], [points[1][0]], [points[2][0]]])
-                pnts = np.append(pnts, points, axis=1)
-            else:
-                pnts = points
-            self.points.append(pnts)
-            self.point_style.append('s')
-        else:
-            self.points.append(points)
-            self.point_style.append('m')
-        self.point_alpha.append(alpha)
-
-    def add_states(self, state, kind='vector', alpha=1.0):
-        """Add a state vector Qobj to Bloch sphere.
-
-        Parameters
-        ----------
-        state : qobj
-            Input state vector.
-
-        kind : str {'vector','point'}
-            Type of object to plot.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-        """
-        if isinstance(state, Qobj):
-            state = [state]
-        for st in state:
-            if kind == 'vector':
-                vec = [expect(sigmax(), st), expect(sigmay(), st),
-                       expect(sigmaz(), st)]
-                self.add_vectors(vec, alpha=alpha)
-            elif kind == 'point':
-                pnt = [expect(sigmax(), st), expect(sigmay(), st),
-                       expect(sigmaz(), st)]
-                self.add_points(pnt, alpha=alpha)
-
-    def add_vectors(self, vectors, alpha=1.0):
-        """Add a list of vectors to Bloch sphere.
-
-        Parameters
-        ----------
-        vectors : array/list
-            Array with vectors of unit length or smaller.
-
-        alpha : float, default=1.
-            Transparency value for the vectors. Values between 0 and 1.
-
-        """
-        if isinstance(vectors[0], (list, np.ndarray)):
-            for vec in vectors:
-                self.vectors.append(vec)
-                self.vector_alpha.append(alpha)
-        else:
-            self.vectors.append(vectors)
-            self.vector_alpha.append(alpha)
-
-    def plot_vectors(self):
-        """
-        Plots vectors on the Bloch sphere.
-        """
-        from mayavi import mlab
-        from tvtk.api import tvtk
-        import matplotlib.colors as colors
-        ii = 0
-        for k in range(len(self.vectors)):
-            vec = np.array(self.vectors[k])
-            norm = np.linalg.norm(vec)
-            theta = np.arccos(vec[2] / norm)
-            phi = np.arctan2(vec[1], vec[0])
-            vec -= 0.5 * self.vector_head_height * \
-                np.array([np.sin(theta) * np.cos(phi),
-                          np.sin(theta) * np.sin(phi), np.cos(theta)])
-
-            color = colors.colorConverter.to_rgb(
-                self.vector_color[np.mod(k, len(self.vector_color))])
-
-            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
-                        name='vector' + str(ii), tube_sides=100,
-                        line_width=self.vector_width,
-                        opacity=self.vector_alpha[k],
-                        color=color)
-
-            cone = tvtk.ConeSource(height=self.vector_head_height,
-                                   radius=self.vector_head_radius,
-                                   resolution=100)
-            cone_mapper = tvtk.PolyDataMapper(
-                input_connection=cone.output_port)
-            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
-            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
-            cc.rotate_z(np.degrees(phi))
-            cc.rotate_y(-90 + np.degrees(theta))
-            cc.position = vec
-            self.fig.scene.add_actor(cc)
-
-    def plot_points(self):
-        """
-        Plots points on the Bloch sphere.
-        """
-        from mayavi import mlab
-        import matplotlib.colors as colors
-        for k in range(len(self.points)):
-            num = len(self.points[k][0])
-            dist = [np.sqrt(self.points[k][0][j] ** 2 +
-                            self.points[k][1][j] ** 2 +
-                            self.points[k][2][j] ** 2) for j in range(num)]
-            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
-                # combine arrays so that they can be sorted together
-                # and sort rates from lowest to highest
-                zipped = sorted(zip(dist, range(num)))
-                dist, indperm = zip(*zipped)
-                indperm = np.array(indperm)
-            else:
-                indperm = range(num)
-            if self.point_style[k] == 's':
-                color = colors.colorConverter.to_rgb(
-                    self.point_color[np.mod(k, len(self.point_color))])
-                mlab.points3d(
-                    self.points[k][0][indperm], self.points[k][1][indperm],
-                    self.points[k][2][indperm], figure=self.fig,
-                    resolution=100, scale_factor=self.point_size,
-                    mode=self.point_mode, color=color,
-                    opacity=self.point_alpha[k])
-
-            elif self.point_style[k] == 'm':
-                pnt_colors = np.array(self.point_color * np.ceil(
-                    num / float(len(self.point_color))))
-                pnt_colors = pnt_colors[0:num]
-                pnt_colors = list(pnt_colors[indperm])
-                for kk in range(num):
-                    mlab.points3d(
-                        self.points[k][0][
-                            indperm[kk]], self.points[k][1][indperm[kk]],
-                        self.points[k][2][
-                            indperm[kk]], figure=self.fig, resolution=100,
-                        scale_factor=self.point_size, mode=self.point_mode,
-                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
-                        opacity=self.point_alpha[k])
-
-    def make_sphere(self):
-        """
-        Plots Bloch sphere and data sets.
-        """
-        # setup plot
-        # Figure instance for Bloch sphere plot
-        from mayavi import mlab
-        import matplotlib.colors as colors
-        if self.user_fig:
-            self.fig = self.user_fig
-        else:
-            self.fig = mlab.figure(
-                1, size=self.size,
-                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
-                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
-
-        sphere = mlab.points3d(
-            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
-            color=colors.colorConverter.to_rgb(self.sphere_color),
-            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
-
-        # Thse commands make the sphere look better
-        sphere.actor.property.specular = 0.45
-        sphere.actor.property.specular_power = 5
-        sphere.actor.property.backface_culling = True
-
-        # make frame for sphere surface
-        if self.frame:
-            theta = np.linspace(0, 2 * np.pi, 100)
-            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
-                xlat = np.cos(theta) * np.cos(angle)
-                ylat = np.sin(theta) * np.cos(angle)
-                zlat = np.ones_like(theta) * np.sin(angle)
-                xlon = np.sin(angle) * np.sin(theta)
-                ylon = np.cos(angle) * np.sin(theta)
-                zlon = np.cos(theta)
-                mlab.plot3d(
-                    xlat, ylat, zlat,
-                    color=colors.colorConverter.to_rgb(self.frame_color),
-                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
-                mlab.plot3d(
-                    xlon, ylon, zlon,
-                    color=colors.colorConverter.to_rgb(self.frame_color),
-                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
-
-        # add axes
-        axis = np.linspace(-1.0, 1.0, 10)
-        other = np.zeros_like(axis)
-        mlab.plot3d(
-            axis, other, other,
-            color=colors.colorConverter.to_rgb(self.axes_color),
-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-        mlab.plot3d(
-            other, axis, other,
-            color=colors.colorConverter.to_rgb(self.axes_color),
-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-        mlab.plot3d(
-            other, other, axis,
-            color=colors.colorConverter.to_rgb(self.axes_color),
-            tube_radius=self.axes_radius, opacity=self.axes_alpha)
-
-        # add data to sphere
-        self.plot_points()
-        self.plot_vectors()
-
-        # #add labels
-        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
-                    color=colors.colorConverter.to_rgb(self.font_color),
-                    scale=self.font_scale)
-
-    def show(self):
-        """
-        Display the Bloch sphere and corresponding data sets.
-        """
-        from mayavi import mlab
-        self.make_sphere()
-        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
-        if self.fig:
-            mlab.show()
-
-    def save(self, name=None, format='png', dirc=None):
-        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
-
-        Parameters
-        ----------
-        name : str
-            Name of saved image. Must include path and format as well.
-            i.e. '/Users/Paul/Desktop/bloch.png'
-            This overrides the 'format' and 'dirc' arguments.
-        format : str
-            Format of output image. Default is 'png'.
-        dirc : str
-            Directory for output images. Defaults to current working directory.
-
-        Returns
-        -------
-        File containing plot of Bloch sphere.
-
-        """
-        from mayavi import mlab
-        import os
-        self.make_sphere()
-        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
-        if dirc:
-            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
-                os.makedirs(os.getcwd() + "/" + str(dirc))
-        if name is None:
-            if dirc:
-                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
-                             str(self.savenum) + '.' + format)
-            else:
-                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
-                             '.' + format)
-        else:
-            mlab.savefig(name)
-        self.savenum += 1
-        if self.fig:
-            mlab.close(self.fig)
+__all__ = ['Bloch3d']
+
+import numpy as np
+from . import Qobj, expect, sigmax, sigmay, sigmaz
+
+
+class Bloch3d:
+    """Class for plotting data on a 3D Bloch sphere using mayavi.
+    Valid data can be either points, vectors, or qobj objects
+    corresponding to state vectors or density matrices. for
+    a two-state system (or subsystem).
+
+    Attributes
+    ----------
+    fig : instance {None}
+        User supplied Matplotlib Figure instance for plotting Bloch sphere.
+    font_color : str {'black'}
+        Color of font used for Bloch sphere labels.
+    font_scale : float {0.08}
+        Scale for font used for Bloch sphere labels.
+    frame : bool {True}
+        Draw frame for Bloch sphere
+    frame_alpha : float {0.05}
+        Sets transparency of Bloch sphere frame.
+    frame_color : str {'gray'}
+        Color of sphere wireframe.
+    frame_num : int {8}
+        Number of frame elements to draw.
+    frame_radius : floats {0.005}
+        Width of wireframe.
+    point_color : list {['r', 'g', 'b', 'y']}
+        List of colors for Bloch sphere point markers to cycle through.
+        i.e. By default, points 0 and 4 will both be blue ('r').
+    point_mode : string {'sphere','cone','cube','cylinder','point'}
+        Point marker shapes.
+    point_size : float {0.075}
+        Size of points on Bloch sphere.
+    sphere_alpha : float {0.1}
+        Transparency of Bloch sphere itself.
+    sphere_color : str {'#808080'}
+        Color of Bloch sphere.
+    size : list {[500,500]}
+        Size of Bloch sphere plot in pixels. Best to have both numbers the same
+        otherwise you will have a Bloch sphere that looks like a football.
+    vector_color : list {['r', 'g', 'b', 'y']}
+        List of vector colors to cycle through.
+    vector_width : int {3}
+        Width of displayed vectors.
+    view : list {[45,65]}
+        Azimuthal and Elevation viewing angles.
+    xlabel : list {``['|x>', '']``}
+        List of strings corresponding to +x and -x axes labels, respectively.
+    xlpos : list {[1.07,-1.07]}
+        Positions of +x and -x labels respectively.
+    ylabel : list {``['|y>', '']``}
+        List of strings corresponding to +y and -y axes labels, respectively.
+    ylpos : list {[1.07,-1.07]}
+        Positions of +y and -y labels respectively.
+    zlabel : list {``['|0>', '|1>']``}
+        List of strings corresponding to +z and -z axes labels, respectively.
+    zlpos : list {[1.07,-1.07]}
+        Positions of +z and -z labels respectively.
+
+    Notes
+    -----
+    The use of mayavi for 3D rendering of the Bloch sphere comes with
+    a few limitations: I) You can not embed a Bloch3d figure into a
+    matplotlib window. II) The use of LaTex is not supported by the
+    mayavi rendering engine. Therefore all labels must be defined using
+    standard text. Of course you can post-process the generated figures
+    later to add LaTeX using other software if needed.
+
+
+    """
+    def __init__(self, fig=None):
+        # ----check for mayavi-----
+        try:
+            from mayavi import mlab
+        except:
+            raise Exception("This function requires the mayavi module.")
+
+        # ---Image options---
+        self.fig = None
+        self.user_fig = None
+        # check if user specified figure or axes.
+        if fig:
+            self.user_fig = fig
+        # The size of the figure in inches, default = [500,500].
+        self.size = [500, 500]
+        # Azimuthal and Elvation viewing angles, default = [45,65].
+        self.view = [45, 65]
+        # Image background color
+        self.bgcolor = 'white'
+        # Image foreground color. Other options can override.
+        self.fgcolor = 'black'
+
+        # ---Sphere options---
+        # Color of Bloch sphere, default = #808080
+        self.sphere_color = '#808080'
+        # Transparency of Bloch sphere, default = 0.1
+        self.sphere_alpha = 0.1
+
+        # ---Frame options---
+        # Draw frame?
+        self.frame = True
+        # number of lines to draw for frame
+        self.frame_num = 8
+        # Color of wireframe, default = 'gray'
+        self.frame_color = 'black'
+        # Transparency of wireframe, default = 0.2
+        self.frame_alpha = 0.05
+        # Radius of frame lines
+        self.frame_radius = 0.005
+
+        # --Axes---
+        # Axes color
+        self.axes_color = 'black'
+        # Transparency of axes
+        self.axes_alpha = 0.4
+        # Radius of axes lines
+        self.axes_radius = 0.005
+
+        # ---Labels---
+        # Labels for x-axis (in LaTex), default = ['$x$','']
+        self.xlabel = ['|x>', '']
+        # Position of x-axis labels, default = [1.2,-1.2]
+        self.xlpos = [1.07, -1.07]
+        # Labels for y-axis (in LaTex), default = ['$y$','']
+        self.ylabel = ['|y>', '']
+        # Position of y-axis labels, default = [1.1,-1.1]
+        self.ylpos = [1.07, -1.07]
+        # Labels for z-axis
+        self.zlabel = ['|0>', '|1>']
+        # Position of z-axis labels, default = [1.05,-1.05]
+        self.zlpos = [1.07, -1.07]
+
+        # ---Font options---
+        # Color of fonts, default = 'black'
+        self.font_color = 'black'
+        # Size of fonts, default = 20
+        self.font_scale = 0.08
+
+        # ---Vector options---
+        # Object used for representing vectors on Bloch sphere.
+        # List of colors for Bloch vectors, default = ['b','g','r','y']
+        self.vector_color = ['r', 'g', 'b', 'y']
+        # Width of Bloch vectors, default = 2
+        self.vector_width = 2.0
+        # Height of vector head
+        self.vector_head_height = 0.15
+        # Radius of vector head
+        self.vector_head_radius = 0.075
+
+        # ---Point options---
+        # List of colors for Bloch point markers, default = ['b','g','r','y']
+        self.point_color = ['r', 'g', 'b', 'y']
+        # Size of point markers
+        self.point_size = 0.06
+        # Shape of point markers
+        # Options: 'cone' or 'cube' or 'cylinder' or 'point' or 'sphere'.
+        # Default = 'sphere'
+        self.point_mode = 'sphere'
+
+        # ---Data lists---
+        # Data for point markers
+        self.points = []
+        # Data for Bloch vectors
+        self.vectors = []
+        # Number of times sphere has been saved
+        self.savenum = 0
+        # Style of points, 'm' for multiple colors, 's' for single color
+        self.point_style = []
+        # Transparency of points
+        self.point_alpha = []
+        # Transparency of vectors
+        self.vector_alpha = []
+
+    def __str__(self):
+        s = ""
+        s += "Bloch3D data:\n"
+        s += "-----------\n"
+        s += "Number of points:  " + str(len(self.points)) + "\n"
+        s += "Number of vectors: " + str(len(self.vectors)) + "\n"
+        s += "\n"
+        s += "Bloch3D sphere properties:\n"
+        s += "--------------------------\n"
+        s += "axes_alpha:         " + str(self.axes_alpha) + "\n"
+        s += "axes_color:         " + str(self.axes_color) + "\n"
+        s += "axes_radius:        " + str(self.axes_radius) + "\n"
+        s += "bgcolor:            " + str(self.bgcolor) + "\n"
+        s += "fgcolor:            " + str(self.fgcolor) + "\n"
+        s += "font_color:         " + str(self.font_color) + "\n"
+        s += "font_scale:         " + str(self.font_scale) + "\n"
+        s += "frame:              " + str(self.frame) + "\n"
+        s += "frame_alpha:        " + str(self.frame_alpha) + "\n"
+        s += "frame_color:        " + str(self.frame_color) + "\n"
+        s += "frame_num:          " + str(self.frame_num) + "\n"
+        s += "frame_radius:       " + str(self.frame_radius) + "\n"
+        s += "point_color:        " + str(self.point_color) + "\n"
+        s += "point_mode:         " + str(self.point_mode) + "\n"
+        s += "point_size:         " + str(self.point_size) + "\n"
+        s += "sphere_alpha:       " + str(self.sphere_alpha) + "\n"
+        s += "sphere_color:       " + str(self.sphere_color) + "\n"
+        s += "size:               " + str(self.size) + "\n"
+        s += "vector_color:       " + str(self.vector_color) + "\n"
+        s += "vector_width:       " + str(self.vector_width) + "\n"
+        s += "vector_head_height: " + str(self.vector_head_height) + "\n"
+        s += "vector_head_radius: " + str(self.vector_head_radius) + "\n"
+        s += "view:               " + str(self.view) + "\n"
+        s += "xlabel:             " + str(self.xlabel) + "\n"
+        s += "xlpos:              " + str(self.xlpos) + "\n"
+        s += "ylabel:             " + str(self.ylabel) + "\n"
+        s += "ylpos:              " + str(self.ylpos) + "\n"
+        s += "zlabel:             " + str(self.zlabel) + "\n"
+        s += "zlpos:              " + str(self.zlpos) + "\n"
+        return s
+
+    def clear(self):
+        """Resets the Bloch sphere data sets to empty.
+        """
+        self.points = []
+        self.vectors = []
+        self.point_style = []
+
+    def add_points(self, points, meth='s', alpha=1.0):
+        """Add a list of data points to bloch sphere.
+
+        Parameters
+        ----------
+        points : array/list
+            Collection of data points.
+
+        meth : str {'s','m'}
+            Type of points to plot, use 'm' for multicolored.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        """
+        if not isinstance(points[0], (list, np.ndarray)):
+            points = [[points[0]], [points[1]], [points[2]]]
+        points = np.array(points)
+        if meth == 's':
+            if len(points[0]) == 1:
+                pnts = np.array(
+                    [[points[0][0]], [points[1][0]], [points[2][0]]])
+                pnts = np.append(pnts, points, axis=1)
+            else:
+                pnts = points
+            self.points.append(pnts)
+            self.point_style.append('s')
+        else:
+            self.points.append(points)
+            self.point_style.append('m')
+        self.point_alpha.append(alpha)
+
+    def add_states(self, state, kind='vector', alpha=1.0):
+        """Add a state vector Qobj to Bloch sphere.
+
+        Parameters
+        ----------
+        state : qobj
+            Input state vector.
+
+        kind : str {'vector','point'}
+            Type of object to plot.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+        """
+        if isinstance(state, Qobj):
+            state = [state]
+        for st in state:
+            if kind == 'vector':
+                vec = [expect(sigmax(), st), expect(sigmay(), st),
+                       expect(sigmaz(), st)]
+                self.add_vectors(vec, alpha=alpha)
+            elif kind == 'point':
+                pnt = [expect(sigmax(), st), expect(sigmay(), st),
+                       expect(sigmaz(), st)]
+                self.add_points(pnt, alpha=alpha)
+
+    def add_vectors(self, vectors, alpha=1.0):
+        """Add a list of vectors to Bloch sphere.
+
+        Parameters
+        ----------
+        vectors : array/list
+            Array with vectors of unit length or smaller.
+
+        alpha : float, default=1.
+            Transparency value for the vectors. Values between 0 and 1.
+
+        """
+        if isinstance(vectors[0], (list, np.ndarray)):
+            for vec in vectors:
+                self.vectors.append(vec)
+                self.vector_alpha.append(alpha)
+        else:
+            self.vectors.append(vectors)
+            self.vector_alpha.append(alpha)
+
+    def plot_vectors(self):
+        """
+        Plots vectors on the Bloch sphere.
+        """
+        from mayavi import mlab
+        from tvtk.api import tvtk
+        import matplotlib.colors as colors
+        ii = 0
+        for k in range(len(self.vectors)):
+            vec = np.array(self.vectors[k])
+            norm = np.linalg.norm(vec)
+            theta = np.arccos(vec[2] / norm)
+            phi = np.arctan2(vec[1], vec[0])
+            vec -= 0.5 * self.vector_head_height * \
+                np.array([np.sin(theta) * np.cos(phi),
+                          np.sin(theta) * np.sin(phi), np.cos(theta)])
+
+            color = colors.colorConverter.to_rgb(
+                self.vector_color[np.mod(k, len(self.vector_color))])
+
+            mlab.plot3d([0, vec[0]], [0, vec[1]], [0, vec[2]],
+                        name='vector' + str(ii), tube_sides=100,
+                        line_width=self.vector_width,
+                        opacity=self.vector_alpha[k],
+                        color=color)
+
+            cone = tvtk.ConeSource(height=self.vector_head_height,
+                                   radius=self.vector_head_radius,
+                                   resolution=100)
+            cone_mapper = tvtk.PolyDataMapper(
+                input_connection=cone.output_port)
+            prop = tvtk.Property(opacity=self.vector_alpha[k], color=color)
+            cc = tvtk.Actor(mapper=cone_mapper, property=prop)
+            cc.rotate_z(np.degrees(phi))
+            cc.rotate_y(-90 + np.degrees(theta))
+            cc.position = vec
+            self.fig.scene.add_actor(cc)
+
+    def plot_points(self):
+        """
+        Plots points on the Bloch sphere.
+        """
+        from mayavi import mlab
+        import matplotlib.colors as colors
+        for k in range(len(self.points)):
+            num = len(self.points[k][0])
+            dist = [np.sqrt(self.points[k][0][j] ** 2 +
+                            self.points[k][1][j] ** 2 +
+                            self.points[k][2][j] ** 2) for j in range(num)]
+            if any(abs(dist - dist[0]) / dist[0] > 1e-12):
+                # combine arrays so that they can be sorted together
+                # and sort rates from lowest to highest
+                zipped = sorted(zip(dist, range(num)))
+                dist, indperm = zip(*zipped)
+                indperm = np.array(indperm)
+            else:
+                indperm = range(num)
+            if self.point_style[k] == 's':
+                color = colors.colorConverter.to_rgb(
+                    self.point_color[np.mod(k, len(self.point_color))])
+                mlab.points3d(
+                    self.points[k][0][indperm], self.points[k][1][indperm],
+                    self.points[k][2][indperm], figure=self.fig,
+                    resolution=100, scale_factor=self.point_size,
+                    mode=self.point_mode, color=color,
+                    opacity=self.point_alpha[k])
+
+            elif self.point_style[k] == 'm':
+                pnt_colors = np.array(self.point_color * np.ceil(
+                    num / float(len(self.point_color))))
+                pnt_colors = pnt_colors[0:num]
+                pnt_colors = list(pnt_colors[indperm])
+                for kk in range(num):
+                    mlab.points3d(
+                        self.points[k][0][
+                            indperm[kk]], self.points[k][1][indperm[kk]],
+                        self.points[k][2][
+                            indperm[kk]], figure=self.fig, resolution=100,
+                        scale_factor=self.point_size, mode=self.point_mode,
+                        color=colors.colorConverter.to_rgb(pnt_colors[kk]),
+                        opacity=self.point_alpha[k])
+
+    def make_sphere(self):
+        """
+        Plots Bloch sphere and data sets.
+        """
+        # setup plot
+        # Figure instance for Bloch sphere plot
+        from mayavi import mlab
+        import matplotlib.colors as colors
+        if self.user_fig:
+            self.fig = self.user_fig
+        else:
+            self.fig = mlab.figure(
+                1, size=self.size,
+                bgcolor=colors.colorConverter.to_rgb(self.bgcolor),
+                fgcolor=colors.colorConverter.to_rgb(self.fgcolor))
+
+        sphere = mlab.points3d(
+            0, 0, 0, figure=self.fig, scale_mode='none', scale_factor=2,
+            color=colors.colorConverter.to_rgb(self.sphere_color),
+            resolution=100, opacity=self.sphere_alpha, name='bloch_sphere')
+
+        # Thse commands make the sphere look better
+        sphere.actor.property.specular = 0.45
+        sphere.actor.property.specular_power = 5
+        sphere.actor.property.backface_culling = True
+
+        # make frame for sphere surface
+        if self.frame:
+            theta = np.linspace(0, 2 * np.pi, 100)
+            for angle in np.linspace(-np.pi, np.pi, self.frame_num):
+                xlat = np.cos(theta) * np.cos(angle)
+                ylat = np.sin(theta) * np.cos(angle)
+                zlat = np.ones_like(theta) * np.sin(angle)
+                xlon = np.sin(angle) * np.sin(theta)
+                ylon = np.cos(angle) * np.sin(theta)
+                zlon = np.cos(theta)
+                mlab.plot3d(
+                    xlat, ylat, zlat,
+                    color=colors.colorConverter.to_rgb(self.frame_color),
+                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
+                mlab.plot3d(
+                    xlon, ylon, zlon,
+                    color=colors.colorConverter.to_rgb(self.frame_color),
+                    opacity=self.frame_alpha, tube_radius=self.frame_radius)
+
+        # add axes
+        axis = np.linspace(-1.0, 1.0, 10)
+        other = np.zeros_like(axis)
+        mlab.plot3d(
+            axis, other, other,
+            color=colors.colorConverter.to_rgb(self.axes_color),
+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+        mlab.plot3d(
+            other, axis, other,
+            color=colors.colorConverter.to_rgb(self.axes_color),
+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+        mlab.plot3d(
+            other, other, axis,
+            color=colors.colorConverter.to_rgb(self.axes_color),
+            tube_radius=self.axes_radius, opacity=self.axes_alpha)
+
+        # add data to sphere
+        self.plot_points()
+        self.plot_vectors()
+
+        # #add labels
+        mlab.text3d(0, 0, self.zlpos[0], self.zlabel[0],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(0, 0, self.zlpos[1], self.zlabel[1],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(self.xlpos[0], 0, 0, self.xlabel[0],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(self.xlpos[1], 0, 0, self.xlabel[1],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(0, self.ylpos[0], 0, self.ylabel[0],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+        mlab.text3d(0, self.ylpos[1], 0, self.ylabel[1],
+                    color=colors.colorConverter.to_rgb(self.font_color),
+                    scale=self.font_scale)
+
+    def show(self):
+        """
+        Display the Bloch sphere and corresponding data sets.
+        """
+        from mayavi import mlab
+        self.make_sphere()
+        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
+        if self.fig:
+            mlab.show()
+
+    def save(self, name=None, format='png', dirc=None):
+        """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
+
+        Parameters
+        ----------
+        name : str
+            Name of saved image. Must include path and format as well.
+            i.e. '/Users/Paul/Desktop/bloch.png'
+            This overrides the 'format' and 'dirc' arguments.
+        format : str
+            Format of output image. Default is 'png'.
+        dirc : str
+            Directory for output images. Defaults to current working directory.
+
+        Returns
+        -------
+        File containing plot of Bloch sphere.
+
+        """
+        from mayavi import mlab
+        import os
+        self.make_sphere()
+        mlab.view(azimuth=self.view[0], elevation=self.view[1], distance=5)
+        if dirc:
+            if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
+                os.makedirs(os.getcwd() + "/" + str(dirc))
+        if name is None:
+            if dirc:
+                mlab.savefig(os.getcwd() + "/" + str(dirc) + '/bloch_' +
+                             str(self.savenum) + '.' + format)
+            else:
+                mlab.savefig(os.getcwd() + '/bloch_' + str(self.savenum) +
+                             '.' + format)
+        else:
+            mlab.savefig(name)
+        self.savenum += 1
+        if self.fig:
+            mlab.close(self.fig)
diff --git a/qutip/cite.py b/qutip/cite.py
index 124b11978c..e3efb3e16c 100644
--- a/qutip/cite.py
+++ b/qutip/cite.py
@@ -1,60 +1,60 @@
-"""
-Citation generator for QuTiP
-"""
-import os
-
-__all__ = ['cite']
-
-
-def cite(save=False, path=None):
-    """
-    Citation information and bibtex generator for QuTiP
-
-    Parameters
-    ----------
-    save: bool
-        The flag specifying whether to save the .bib file.
-
-    path: str
-        The complete directory path to generate the bibtex file.
-        If not specified then the citation will be generated in cwd
-    """
-    citation = ["@article{qutip2,",
-                "doi = {10.1016/j.cpc.2012.11.019},",
-                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
-                "year  = {2013},",
-                "month = {apr},",
-                "publisher = {Elsevier {BV}},",
-                "volume = {184},",
-                "number = {4},",
-                "pages = {1234--1240},",
-                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
-                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
-                "journal = {Computer Physics Communications}",
-                "}",
-                "@article{qutip1,",
-                "doi = {10.1016/j.cpc.2012.02.021},",
-                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
-                "year  = {2012},",
-                "month = {aug},",
-                "publisher = {Elsevier {BV}},",
-                "volume = {183},",
-                "number = {8},",
-                "pages = {1760--1772},",
-                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
-                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
-                "journal = {Computer Physics Communications}",
-                "}"]
-    print("\n".join(citation))
-
-    if not path:
-        path = os.getcwd()
-
-    if save:
-        filename = "qutip.bib"
-        with open(os.path.join(path, filename), 'w') as f:
-            f.write("\n".join(citation))
-
-
-if __name__ == "__main__":
-    cite()
+"""
+Citation generator for QuTiP
+"""
+import os
+
+__all__ = ['cite']
+
+
+def cite(save=False, path=None):
+    """
+    Citation information and bibtex generator for QuTiP
+
+    Parameters
+    ----------
+    save: bool
+        The flag specifying whether to save the .bib file.
+
+    path: str
+        The complete directory path to generate the bibtex file.
+        If not specified then the citation will be generated in cwd
+    """
+    citation = ["@article{qutip2,",
+                "doi = {10.1016/j.cpc.2012.11.019},",
+                "url = {https://doi.org/10.1016/j.cpc.2012.11.019},",
+                "year  = {2013},",
+                "month = {apr},",
+                "publisher = {Elsevier {BV}},",
+                "volume = {184},",
+                "number = {4},",
+                "pages = {1234--1240},",
+                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
+                "title = {{QuTiP} 2: A {P}ython framework for the dynamics of open quantum systems},",
+                "journal = {Computer Physics Communications}",
+                "}",
+                "@article{qutip1,",
+                "doi = {10.1016/j.cpc.2012.02.021},",
+                "url = {https://doi.org/10.1016/j.cpc.2012.02.021},",
+                "year  = {2012},",
+                "month = {aug},",
+                "publisher = {Elsevier {BV}},",
+                "volume = {183},",
+                "number = {8},",
+                "pages = {1760--1772},",
+                "author = {J.R. Johansson and P.D. Nation and F. Nori},",
+                "title = {{QuTiP}: An open-source {P}ython framework for the dynamics of open quantum systems},",
+                "journal = {Computer Physics Communications}",
+                "}"]
+    print("\n".join(citation))
+
+    if not path:
+        path = os.getcwd()
+
+    if save:
+        filename = "qutip.bib"
+        with open(os.path.join(path, filename), 'w') as f:
+            f.write("\n".join(citation))
+
+
+if __name__ == "__main__":
+    cite()
diff --git a/qutip/continuous_variables.py b/qutip/continuous_variables.py
index 004b5b365b..519f070ffa 100644
--- a/qutip/continuous_variables.py
+++ b/qutip/continuous_variables.py
@@ -1,259 +1,259 @@
-"""
-This module contains a collection functions for calculating continuous variable
-quantities from fock-basis representation of the state of multi-mode fields.
-"""
-
-__all__ = ['correlation_matrix', 'covariance_matrix',
-           'correlation_matrix_field', 'correlation_matrix_quadrature',
-           'wigner_covariance_matrix', 'logarithmic_negativity']
-
-from . import expect
-import numpy as np
-
-
-def correlation_matrix(basis, rho=None):
-    r"""
-    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
-    matrix:
-
-    .. math::
-
-        C_{mn} = \langle a_m a_n \rangle
-
-    Parameters
-    ----------
-    basis : list
-        List of operators that defines the basis for the correlation matrix.
-    rho : Qobj
-        Density matrix for which to calculate the correlation matrix. If
-        `rho` is `None`, then a matrix of correlation matrix operators is
-        returned instead of expectation values of those operators.
-
-    Returns
-    -------
-    corr_mat : ndarray
-        A 2-dimensional *array* of correlation values or operators.
-
-
-    """
-    if rho is None:
-        # return array of operators
-        out = np.empty((len(basis), len(basis)), dtype=object)
-        for i, op2 in enumerate(basis):
-            out[i, :] = [op1 * op2 for op1 in basis]
-        return out
-    else:
-        # return array of expectation values
-        return np.array([[expect(op1 * op2, rho)
-                          for op1 in basis] for op2 in basis])
-
-
-def covariance_matrix(basis, rho, symmetrized=True):
-    r"""
-    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
-    matrix:
-
-    .. math::
-
-        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
-        \langle a_m \rangle \langle a_n\rangle
-
-    or, if of the optional argument `symmetrized=False`,
-
-    .. math::
-
-        V_{mn} = \langle a_m a_n\rangle -
-        \langle a_m \rangle \langle a_n\rangle
-
-    Parameters
-    ----------
-    basis : list
-        List of operators that defines the basis for the covariance matrix.
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-    symmetrized : bool {True, False}
-        Flag indicating whether the symmetrized (default) or non-symmetrized
-        correlation matrix is to be calculated.
-
-    Returns
-    -------
-    corr_mat : ndarray
-        A 2-dimensional array of covariance values.
-
-    """
-    if symmetrized:
-        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
-                          expect(op1, rho) * expect(op2, rho)
-                          for op1 in basis] for op2 in basis])
-    else:
-        return np.array([[expect(op1 * op2, rho) -
-                          expect(op1, rho) * expect(op2, rho)
-                          for op1 in basis] for op2 in basis])
-
-
-def correlation_matrix_field(a1, a2, rho=None):
-    """
-    Calculates the correlation matrix for given field operators :math:`a_1` and
-    :math:`a_2`. If a density matrix is given the expectation values are
-    calculated, otherwise a matrix with operators is returned.
-
-    Parameters
-    ----------
-    a1 : Qobj
-        Field operator for mode 1.
-    a2 : Qobj
-        Field operator for mode 2.
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-
-    Returns
-    -------
-    cov_mat : ndarray 
-        Array of complex numbers or Qobj's
-        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
-        of operators.
-    """
-    basis = [a1, a1.dag(), a2, a2.dag()]
-    return correlation_matrix(basis, rho)
-
-
-def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
-    """
-    Calculate the quadrature correlation matrix with given field operators
-    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
-    values are calculated, otherwise a matrix with operators is returned.
-
-    Parameters
-    ----------
-    a1 : Qobj
-        Field operator for mode 1.
-    a2 : Qobj
-        Field operator for mode 2.
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation 
-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
-        value `hbar=1`. 
-
-    Returns
-    -------
-    corr_mat : ndarray 
-        Array of complex numbers or Qobj's
-        A 2-dimensional *array* of covariance values for the field quadratures,
-        or, if rho=0, a matrix of operators.
-
-    """
-    x1 = (a1 + a1.dag()) / g
-    p1 = -1j * (a1 - a1.dag()) / g
-    x2 = (a2 + a2.dag()) / g
-    p2 = -1j * (a2 - a2.dag()) / g
-    basis = [x1, p1, x2, p2]
-    return correlation_matrix(basis, rho)
-
-
-def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
-    r"""
-    Calculates the Wigner covariance matrix
-    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
-    the quadrature correlation matrix
-    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
-    \langle R_{i}\rangle \langle R_{j}\rangle`, where
-    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
-    for the two modes.
-
-    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
-    for the two modes are supplied instead, the quadrature correlation matrix
-    is constructed from the annihilation operators before then the covariance
-    matrix is calculated.
-
-    Parameters
-    ----------
-
-    a1 : Qobj
-        Field operator for mode 1.
-
-    a2 : Qobj
-        Field operator for mode 2.
-
-    R : ndarray
-        The quadrature correlation matrix.
-
-    rho : Qobj
-        Density matrix for which to calculate the covariance matrix.
-
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation 
-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
-        value `hbar=1`. 
-
-    Returns
-    -------
-    cov_mat : ndarray
-        A 2-dimensional array of covariance values.
-
-    """
-    if R is not None:
-        if rho is None:
-            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
-                              for i in range(4)]
-                             for j in range(4)], dtype=np.float64)
-        else:
-            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
-                              for i in range(4)]
-                             for j in range(4)], dtype=np.float64)
-    elif a1 is not None and a2 is not None:
-        if rho is not None:
-            x1 = (a1 + a1.dag()) / g
-            p1 = -1j * (a1 - a1.dag()) / g
-            x2 = (a2 + a2.dag()) / g
-            p2 = -1j * (a2 - a2.dag()) / g
-            return covariance_matrix([x1, p1, x2, p2], rho)
-        else:
-            raise ValueError("Must give rho if using field operators " +
-                             "(a1 and a2)")
-    else:
-        raise ValueError("Must give either field operators (a1 and a2) " +
-                         "or a precomputed correlation matrix (R)")
-
-
-def logarithmic_negativity(V, g=np.sqrt(2)):
-    """
-    Calculates the logarithmic negativity given a symmetrized covariance
-    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
-    the two-mode field state that is described by `V` must be Gaussian for this
-    function to applicable.
-
-    Parameters
-    ----------
-
-    V : *2d array*
-        The covariance matrix.
-
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation 
-        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
-        value `hbar=1`. 
-
-    Returns
-    -------
-
-    N : float 
-        The logarithmic negativity for the two-mode Gaussian state
-        that is described by the the Wigner covariance matrix V.
-
-    """
-    A = 0.5 * V[0:2, 0:2] * g ** 2
-    B = 0.5 * V[2:4, 2:4] * g ** 2
-    C = 0.5 * V[0:2, 2:4] * g ** 2
-    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
-    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
-    if nu_ < 0.0:
-        return 0.0
-    nu = np.sqrt(nu_)
-    lognu = -np.log(2 * nu)
-    logneg = max(0, lognu)
-    return logneg
+"""
+This module contains a collection functions for calculating continuous variable
+quantities from fock-basis representation of the state of multi-mode fields.
+"""
+
+__all__ = ['correlation_matrix', 'covariance_matrix',
+           'correlation_matrix_field', 'correlation_matrix_quadrature',
+           'wigner_covariance_matrix', 'logarithmic_negativity']
+
+from . import expect
+import numpy as np
+
+
+def correlation_matrix(basis, rho=None):
+    r"""
+    Given a basis set of operators :math:`\{a\}_n`, calculate the correlation
+    matrix:
+
+    .. math::
+
+        C_{mn} = \langle a_m a_n \rangle
+
+    Parameters
+    ----------
+    basis : list
+        List of operators that defines the basis for the correlation matrix.
+    rho : Qobj
+        Density matrix for which to calculate the correlation matrix. If
+        `rho` is `None`, then a matrix of correlation matrix operators is
+        returned instead of expectation values of those operators.
+
+    Returns
+    -------
+    corr_mat : ndarray
+        A 2-dimensional *array* of correlation values or operators.
+
+
+    """
+    if rho is None:
+        # return array of operators
+        out = np.empty((len(basis), len(basis)), dtype=object)
+        for i, op2 in enumerate(basis):
+            out[i, :] = [op1 * op2 for op1 in basis]
+        return out
+    else:
+        # return array of expectation values
+        return np.array([[expect(op1 * op2, rho)
+                          for op1 in basis] for op2 in basis])
+
+
+def covariance_matrix(basis, rho, symmetrized=True):
+    r"""
+    Given a basis set of operators :math:`\{a\}_n`, calculate the covariance
+    matrix:
+
+    .. math::
+
+        V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle -
+        \langle a_m \rangle \langle a_n\rangle
+
+    or, if of the optional argument `symmetrized=False`,
+
+    .. math::
+
+        V_{mn} = \langle a_m a_n\rangle -
+        \langle a_m \rangle \langle a_n\rangle
+
+    Parameters
+    ----------
+    basis : list
+        List of operators that defines the basis for the covariance matrix.
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+    symmetrized : bool {True, False}
+        Flag indicating whether the symmetrized (default) or non-symmetrized
+        correlation matrix is to be calculated.
+
+    Returns
+    -------
+    corr_mat : ndarray
+        A 2-dimensional array of covariance values.
+
+    """
+    if symmetrized:
+        return np.array([[0.5 * expect(op1 * op2 + op2 * op1, rho) -
+                          expect(op1, rho) * expect(op2, rho)
+                          for op1 in basis] for op2 in basis])
+    else:
+        return np.array([[expect(op1 * op2, rho) -
+                          expect(op1, rho) * expect(op2, rho)
+                          for op1 in basis] for op2 in basis])
+
+
+def correlation_matrix_field(a1, a2, rho=None):
+    """
+    Calculates the correlation matrix for given field operators :math:`a_1` and
+    :math:`a_2`. If a density matrix is given the expectation values are
+    calculated, otherwise a matrix with operators is returned.
+
+    Parameters
+    ----------
+    a1 : Qobj
+        Field operator for mode 1.
+    a2 : Qobj
+        Field operator for mode 2.
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+
+    Returns
+    -------
+    cov_mat : ndarray 
+        Array of complex numbers or Qobj's
+        A 2-dimensional *array* of covariance values, or, if rho=0, a matrix
+        of operators.
+    """
+    basis = [a1, a1.dag(), a2, a2.dag()]
+    return correlation_matrix(basis, rho)
+
+
+def correlation_matrix_quadrature(a1, a2, rho=None, g=np.sqrt(2)):
+    """
+    Calculate the quadrature correlation matrix with given field operators
+    :math:`a_1` and :math:`a_2`. If a density matrix is given the expectation
+    values are calculated, otherwise a matrix with operators is returned.
+
+    Parameters
+    ----------
+    a1 : Qobj
+        Field operator for mode 1.
+    a2 : Qobj
+        Field operator for mode 2.
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation 
+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default
+        value `hbar=1`. 
+
+    Returns
+    -------
+    corr_mat : ndarray 
+        Array of complex numbers or Qobj's
+        A 2-dimensional *array* of covariance values for the field quadratures,
+        or, if rho=0, a matrix of operators.
+
+    """
+    x1 = (a1 + a1.dag()) / g
+    p1 = -1j * (a1 - a1.dag()) / g
+    x2 = (a2 + a2.dag()) / g
+    p2 = -1j * (a2 - a2.dag()) / g
+    basis = [x1, p1, x2, p2]
+    return correlation_matrix(basis, rho)
+
+
+def wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None, g=np.sqrt(2)):
+    r"""
+    Calculates the Wigner covariance matrix
+    :math:`V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})`, given
+    the quadrature correlation matrix
+    :math:`R_{ij} = \langle R_{i} R_{j}\rangle -
+    \langle R_{i}\rangle \langle R_{j}\rangle`, where
+    :math:`R = (q_1, p_1, q_2, p_2)^T` is the vector with quadrature operators
+    for the two modes.
+
+    Alternatively, if `R = None`, and if annihilation operators `a1` and `a2`
+    for the two modes are supplied instead, the quadrature correlation matrix
+    is constructed from the annihilation operators before then the covariance
+    matrix is calculated.
+
+    Parameters
+    ----------
+
+    a1 : Qobj
+        Field operator for mode 1.
+
+    a2 : Qobj
+        Field operator for mode 2.
+
+    R : ndarray
+        The quadrature correlation matrix.
+
+    rho : Qobj
+        Density matrix for which to calculate the covariance matrix.
+
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation 
+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
+        value `hbar=1`. 
+
+    Returns
+    -------
+    cov_mat : ndarray
+        A 2-dimensional array of covariance values.
+
+    """
+    if R is not None:
+        if rho is None:
+            return np.array([[0.5 * np.real(R[i, j] + R[j, i])
+                              for i in range(4)]
+                             for j in range(4)], dtype=np.float64)
+        else:
+            return np.array([[0.5 * np.real(expect(R[i, j] + R[j, i], rho))
+                              for i in range(4)]
+                             for j in range(4)], dtype=np.float64)
+    elif a1 is not None and a2 is not None:
+        if rho is not None:
+            x1 = (a1 + a1.dag()) / g
+            p1 = -1j * (a1 - a1.dag()) / g
+            x2 = (a2 + a2.dag()) / g
+            p2 = -1j * (a2 - a2.dag()) / g
+            return covariance_matrix([x1, p1, x2, p2], rho)
+        else:
+            raise ValueError("Must give rho if using field operators " +
+                             "(a1 and a2)")
+    else:
+        raise ValueError("Must give either field operators (a1 and a2) " +
+                         "or a precomputed correlation matrix (R)")
+
+
+def logarithmic_negativity(V, g=np.sqrt(2)):
+    """
+    Calculates the logarithmic negativity given a symmetrized covariance
+    matrix, see :func:`qutip.continuous_variables.covariance_matrix`. Note that
+    the two-mode field state that is described by `V` must be Gaussian for this
+    function to applicable.
+
+    Parameters
+    ----------
+
+    V : *2d array*
+        The covariance matrix.
+
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation 
+        relation `[x, y] = i * hbar` via `hbar=2/g ** 2` giving the default 
+        value `hbar=1`. 
+
+    Returns
+    -------
+
+    N : float 
+        The logarithmic negativity for the two-mode Gaussian state
+        that is described by the the Wigner covariance matrix V.
+
+    """
+    A = 0.5 * V[0:2, 0:2] * g ** 2
+    B = 0.5 * V[2:4, 2:4] * g ** 2
+    C = 0.5 * V[0:2, 2:4] * g ** 2
+    sigma = np.linalg.det(A) + np.linalg.det(B) - 2 * np.linalg.det(C)
+    nu_ = sigma / 2 - np.sqrt(sigma ** 2 - 4 * np.linalg.det(V)) / 2
+    if nu_ < 0.0:
+        return 0.0
+    nu = np.sqrt(nu_)
+    lognu = -np.log(2 * nu)
+    logneg = max(0, lognu)
+    return logneg
diff --git a/qutip/control.py b/qutip/control.py
index 7b3fb74fb1..559a6a8d27 100644
--- a/qutip/control.py
+++ b/qutip/control.py
@@ -1,13 +1,13 @@
-"""Module replicating the qutip_qtrl package from within qutip."""
-import sys
-
-try:
-    import qutip_qtrl
-    del qutip_qtrl
-    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
-except ImportError:
-    raise ImportError(
-        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
-        "Install it with `pip install qutip-qtrl` (for more details, go to "
-        "https://qutip-qtrl.readthedocs.io/)."
-    )
+"""Module replicating the qutip_qtrl package from within qutip."""
+import sys
+
+try:
+    import qutip_qtrl
+    del qutip_qtrl
+    sys.modules["qutip.control"] = sys.modules["qutip_qtrl"]
+except ImportError:
+    raise ImportError(
+        "Importing 'qutip.control' requires the 'qutip_qtrl' package. "
+        "Install it with `pip install qutip-qtrl` (for more details, go to "
+        "https://qutip-qtrl.readthedocs.io/)."
+    )
diff --git a/qutip/core/__init__.py b/qutip/core/__init__.py
index dc1835185b..b12830ba87 100644
--- a/qutip/core/__init__.py
+++ b/qutip/core/__init__.py
@@ -1,16 +1,16 @@
-from .options import *
-from .coefficient import *
-from .qobj import *
-from .cy.qobjevo import *
-from .expect import *
-from .tensor import *
-from .states import *
-from .operators import *
-from .metrics import *
-from .superoperator import *
-from .superop_reps import *
-from .subsystem_apply import *
-from .blochredfield import *
-from . import gates
-
-del cy  # File in cy are not public facing
+from .options import *
+from .coefficient import *
+from .qobj import *
+from .cy.qobjevo import *
+from .expect import *
+from .tensor import *
+from .states import *
+from .operators import *
+from .metrics import *
+from .superoperator import *
+from .superop_reps import *
+from .subsystem_apply import *
+from .blochredfield import *
+from . import gates
+
+del cy  # File in cy are not public facing
diff --git a/qutip/core/_brtensor.pyx b/qutip/core/_brtensor.pyx
index 2578823307..530cf63d1b 100644
--- a/qutip/core/_brtensor.pyx
+++ b/qutip/core/_brtensor.pyx
@@ -1,337 +1,337 @@
-#cython: language_level=3
-cimport cython
-
-import qutip.core.data as _data
-from qutip.core.data cimport Dense, CSR, Data, idxint, csr
-from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
-from qutip.core._brtools cimport _EigenBasisTransform
-from qutip.core.qobj import Qobj
-
-import numpy as np
-from libcpp.vector cimport vector
-from libc.math cimport fabs, fmin
-
-__all__ = []
-
-
-cpdef enum TensorType:
-    SPARSE = 0
-    DENSE = 1
-    DATA = 2
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
-                         double[:, ::1] skew, double cutoff):
-    """
-    Compute the contribution of A to the Bloch Redfield tensor.
-    Computation are done using dispatched function.
-    """
-    cdef object cutoff_arr
-    cdef int nrows = A.shape[0], a, b, c, d
-    cdef Data S, I, AS, AST, out, C
-    cdef type cls = type(A)
-
-    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
-    I = _data.identity[cls](nrows)
-    AS = _data.multiply(A, S)
-    AST = _data.multiply(A, _data.transpose(S))
-
-    out = _data.kron(AST, _data.transpose(A))
-    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
-    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
-    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
-
-    if cutoff == np.inf:
-        return out
-
-    # The cutoff_arr should be sparse most of the time, but it depend on the
-    # cutoff and we cannot easily guess a nnz to make it efficiently...
-    # But there is probably room from improvement.
-    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
-    for a in range(nrows):
-        for b in range(nrows):
-            for c in range(nrows):
-                for d in range(nrows):
-                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
-                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
-    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
-    return _data.multiply(out, C)
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
-                           double[:, ::1] skew, double cutoff):
-    """
-    Compute the contribution of A to the Bloch Redfield tensor.
-    Allocate a Dense array and fill it.
-    """
-    cdef size_t nrows = A.shape[0]
-    cdef size_t a, b, c, d, k # matrix indexing variables
-    cdef double complex elem
-    cdef double complex[:,:] A_mat, ac_term, bd_term
-    cdef object np2term
-    cdef Dense out
-    cdef double complex[::1, :] out_array
-
-    if type(A) is Dense:
-        A_mat = A.as_ndarray()
-    else:
-        A_mat = A.to_array()
-
-    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
-    out_array = out.as_ndarray()
-
-    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
-    ac_term = np2term[:, :, 0]
-    bd_term = np2term[:, :, 1]
-
-
-    for a in range(nrows):
-        for b in range(nrows-1, -1, -1):
-            if fabs(skew[a, b]) < cutoff:
-                for k in range(nrows):
-                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
-                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
-
-    # TODO: we could use openmp to speed up.
-    for a in range(nrows):
-        for b in range(nrows):
-            for c in range(nrows):
-                for d in range(nrows):
-                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
-                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
-                        elem *= (spectrum[c, a] + spectrum[d, b])
-                        if a == c:
-                            elem = elem - 0.5 * ac_term[d, b]
-                        if b == d:
-                            elem = elem - 0.5 * bd_term[a, c]
-                        out_array[a * nrows + b, c * nrows + d] = elem
-    return out
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
-                          double[:, ::1] skew, double cutoff):
-    """
-    Compute the contribution of A to the Bloch Redfield tensor.
-    Create it as coo pointers and return as CSR.
-    """
-    cdef size_t nrows = A.shape[0]
-    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
-    cdef double complex elem, ac_elem, bd_elem
-    cdef double complex[:,:] A_mat, ac_term, bd_term
-    cdef double dskew
-    cdef object np2term
-    cdef vector[idxint] coo_rows, coo_cols
-    cdef vector[double complex] coo_data
-
-    if type(A) is Dense:
-        A_mat = A.as_ndarray()
-    else:
-        A_mat = A.to_array()
-
-    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
-    ac_term = np2term[:, :, 0]
-    bd_term = np2term[:, :, 1]
-
-    for a in range(nrows):
-        for b in range(nrows-1, -1, -1):
-            if fabs(skew[a, b]) < cutoff:
-                for k in range(nrows):
-                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
-                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
-            elif skew[a, b] > cutoff:
-                break
-
-    # skew[a,b] = w[a] - w[b]
-    # (w[a] - w[b] - w[c] + w[d]) < cutoff
-    # w's are sorted so we can skip part of the loop.
-    for a in range(nrows):
-        for b in range(nrows):
-            d_min = 0
-            for c in range(nrows):
-                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
-                    break
-                for d in range(d_min, nrows):
-                    dskew = skew[a, b] - skew[c, d]
-                    if -dskew > cutoff:
-                        d_min = d
-                    elif fabs(dskew) < cutoff:
-                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
-                        elem *= (spectrum[c, a] + spectrum[d, b])
-                        if a == c:
-                            elem -= 0.5 * ac_term[d, b]
-                        if b == d:
-                            elem -= 0.5 * bd_term[a, c]
-                        if elem != 0:
-                            coo_rows.push_back(a * nrows + b)
-                            coo_cols.push_back(c * nrows + d)
-                            coo_data.push_back(elem)
-                    elif dskew >= cutoff:
-                        break
-
-    return csr.from_coo_pointers(
-        coo_rows.data(), coo_cols.data(), coo_data.data(),
-        nrows*nrows, nrows*nrows, coo_rows.size()
-    )
-
-
-cdef class _BlochRedfieldElement(_BaseElement):
-    """
-    Element for individual Bloch Redfield collapse term.
-
-    The tensor is computed in the ``eig_basis``, but is returned in the outside
-    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
-    on a state expected to be in that basis. It transform the state instead of
-    the tensor as it is usually faster, the state being a density matrix in
-    most cases.
-
-    Diffenrent term can share a same instance of the eigen transform tool
-    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
-    only once even when needed by multiple terms.
-    """
-    cdef readonly _EigenBasisTransform H
-    cdef readonly QobjEvo a_op
-    cdef readonly Coefficient spectra
-    cdef readonly double sec_cutoff
-    cdef readonly size_t nrows
-    cdef readonly (idxint, idxint) shape
-    cdef readonly list dims
-    cdef readonly object np_datas
-    cdef readonly double[:, ::1] skew
-    cdef readonly double[:, ::1] spectrum
-    cdef readonly bint eig_basis
-    cdef readonly TensorType tensortype
-
-    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
-                 dtype=None):
-        if isinstance(H, _EigenBasisTransform):
-            self.H = H
-        else:
-            self.H = _EigenBasisTransform(H)
-
-        self.a_op = a_op
-        self.spectra = spectra
-        self.sec_cutoff = sec_cutoff
-        self.eig_basis = eig_basis
-        self.nrows = a_op.shape[0]
-        self.dims = [a_op.dims, a_op.dims]
-
-        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
-        self.tensortype = {
-            'sparse': SPARSE,
-            'dense': DENSE,
-            'data': DATA
-        }[dtype]
-
-        # Allocate some array
-        # Let numpy manage memory
-        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
-                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
-        self.skew = self.np_datas[0]
-        self.spectrum = self.np_datas[1]
-
-    cpdef double _compute_spectrum(self, double t) except *:
-        "Compute the skew, spectrum and dw_min"
-        cdef Coefficient spec
-        cdef double dw_min = np.inf
-        eigvals = self.H.eigenvalues(t)
-
-        for col in range(0, self.nrows):
-            self.skew[col, col] = 0.
-            self.spectrum[col, col] = self.spectra(t, w=0).real
-            for row in range(col, self.nrows):
-                dw = eigvals[row] - eigvals[col]
-                self.skew[row, col] = dw
-                self.skew[col, row] = -dw
-                if dw != 0:
-                    dw_min = fmin(fabs(dw), dw_min)
-                self.spectrum[row, col] = self.spectra(t, w=dw).real
-                self.spectrum[col, row] = self.spectra(t, w=-dw).real
-        return dw_min
-
-    cdef Data _br_term(self, Data A_eig, double cutoff):
-        if self.tensortype == DENSE:
-            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
-        elif self.tensortype == SPARSE:
-            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
-        elif self.tensortype == DATA:
-            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
-        raise ValueError('Invalid tensortype')
-
-    cpdef object qobj(self, t):
-        return Qobj(self.data(t), dims=self.dims, type="super",
-                    copy=False, superrep="super")
-
-    cpdef object coeff(self, t):
-        return 1.
-
-    cpdef Data data(self, t):
-        cdef size_t i
-        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
-        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
-        BR_eig = self._br_term(A_eig, cutoff)
-        if self.eig_basis:
-            return BR_eig
-        return self.H.from_eigbasis(t, BR_eig)
-
-    cdef Data matmul_data_t(self, t, Data state, Data out=None):
-        cdef size_t i
-        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
-        cdef Data A_eig, BR_eig
-
-        if not self.eig_basis:
-            state = self.H.to_eigbasis(t, state)
-        if not self.eig_basis and out is not None:
-            out = self.H.to_eigbasis(t, out)
-        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
-        BR_eig = self._br_term(A_eig, cutoff)
-        out = _data.add(_data.matmul(BR_eig, state), out)
-        if not self.eig_basis:
-            out = self.H.from_eigbasis(t, out)
-        return out
-
-    def linear_map(self, f, anti=False):
-        return _MapElement(self, [f])
-
-    def replace_arguments(self, args, cache=None):
-        if cache is None:
-            return _BlochRedfieldElement(
-                self.H,
-                QobjEvo(self.a_op, args=args),
-                self.spectra,
-                self.sec_cutoff
-            )
-        H = None
-        for old, new in cache:
-            if old is self:
-                return new
-            if old is self.H:
-                H = new
-        if H is None:
-            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
-                                     type(self.H.oper) is CSR)
-        new = _BlochRedfieldElement(
-            H, QobjEvo(self.a_op, args=args),
-            self.spectra.replace_arguments(**args), self.sec_cutoff
-        )
-        cache.append((self, new))
-        cache.append((self.H, H))
-        return new
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    def __mul__(left, right):
-        cdef _MapElement out
-        if type(left) is _BlochRedfieldElement:
-            out = _MapElement(left, [], right)
-        if type(right) is _BlochRedfieldElement:
-            out = _MapElement(right, [], left)
-        return out
+#cython: language_level=3
+cimport cython
+
+import qutip.core.data as _data
+from qutip.core.data cimport Dense, CSR, Data, idxint, csr
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.cy._element cimport _BaseElement, _MapElement, _ProdElement
+from qutip.core._brtools cimport _EigenBasisTransform
+from qutip.core.qobj import Qobj
+
+import numpy as np
+from libcpp.vector cimport vector
+from libc.math cimport fabs, fmin
+
+__all__ = []
+
+
+cpdef enum TensorType:
+    SPARSE = 0
+    DENSE = 1
+    DATA = 2
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef Data _br_term_data(Data A, double[:, ::1] spectrum,
+                         double[:, ::1] skew, double cutoff):
+    """
+    Compute the contribution of A to the Bloch Redfield tensor.
+    Computation are done using dispatched function.
+    """
+    cdef object cutoff_arr
+    cdef int nrows = A.shape[0], a, b, c, d
+    cdef Data S, I, AS, AST, out, C
+    cdef type cls = type(A)
+
+    S = _data.to(cls, _data.mul(_data.Dense(spectrum, copy=False), 0.5))
+    I = _data.identity[cls](nrows)
+    AS = _data.multiply(A, S)
+    AST = _data.multiply(A, _data.transpose(S))
+
+    out = _data.kron(AST, _data.transpose(A))
+    out = _data.add(out, _data.kron(A, _data.transpose(AS)))
+    out = _data.sub(out, _data.kron(I, _data.transpose(_data.matmul(AS, A))))
+    out = _data.sub(out, _data.kron(_data.matmul(A, AST), I))
+
+    if cutoff == np.inf:
+        return out
+
+    # The cutoff_arr should be sparse most of the time, but it depend on the
+    # cutoff and we cannot easily guess a nnz to make it efficiently...
+    # But there is probably room from improvement.
+    cutoff_arr = np.zeros((nrows*nrows, nrows*nrows), dtype=np.complex128)
+    for a in range(nrows):
+        for b in range(nrows):
+            for c in range(nrows):
+                for d in range(nrows):
+                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
+                        cutoff_arr[a * nrows + b, c * nrows + d] = 1.
+    C = _data.to(cls, _data.Dense(cutoff_arr, copy=False))
+    return _data.multiply(out, C)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef Dense _br_term_dense(Data A, double[:, ::1] spectrum,
+                           double[:, ::1] skew, double cutoff):
+    """
+    Compute the contribution of A to the Bloch Redfield tensor.
+    Allocate a Dense array and fill it.
+    """
+    cdef size_t nrows = A.shape[0]
+    cdef size_t a, b, c, d, k # matrix indexing variables
+    cdef double complex elem
+    cdef double complex[:,:] A_mat, ac_term, bd_term
+    cdef object np2term
+    cdef Dense out
+    cdef double complex[::1, :] out_array
+
+    if type(A) is Dense:
+        A_mat = A.as_ndarray()
+    else:
+        A_mat = A.to_array()
+
+    out = _data.dense.zeros(nrows*nrows, nrows*nrows)
+    out_array = out.as_ndarray()
+
+    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
+    ac_term = np2term[:, :, 0]
+    bd_term = np2term[:, :, 1]
+
+
+    for a in range(nrows):
+        for b in range(nrows-1, -1, -1):
+            if fabs(skew[a, b]) < cutoff:
+                for k in range(nrows):
+                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
+                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
+
+    # TODO: we could use openmp to speed up.
+    for a in range(nrows):
+        for b in range(nrows):
+            for c in range(nrows):
+                for d in range(nrows):
+                    if fabs(skew[a, b] - skew[c, d]) < cutoff:
+                        elem = A_mat[a, c] * A_mat[d, b] * 0.5
+                        elem *= (spectrum[c, a] + spectrum[d, b])
+                        if a == c:
+                            elem = elem - 0.5 * ac_term[d, b]
+                        if b == d:
+                            elem = elem - 0.5 * bd_term[a, c]
+                        out_array[a * nrows + b, c * nrows + d] = elem
+    return out
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef CSR _br_term_sparse(Data A, double[:, :] spectrum,
+                          double[:, ::1] skew, double cutoff):
+    """
+    Compute the contribution of A to the Bloch Redfield tensor.
+    Create it as coo pointers and return as CSR.
+    """
+    cdef size_t nrows = A.shape[0]
+    cdef size_t a, b, c, d, k, d_min # matrix indexing variables
+    cdef double complex elem, ac_elem, bd_elem
+    cdef double complex[:,:] A_mat, ac_term, bd_term
+    cdef double dskew
+    cdef object np2term
+    cdef vector[idxint] coo_rows, coo_cols
+    cdef vector[double complex] coo_data
+
+    if type(A) is Dense:
+        A_mat = A.as_ndarray()
+    else:
+        A_mat = A.to_array()
+
+    np2term = np.zeros((nrows, nrows, 2), dtype=np.complex128)
+    ac_term = np2term[:, :, 0]
+    bd_term = np2term[:, :, 1]
+
+    for a in range(nrows):
+        for b in range(nrows-1, -1, -1):
+            if fabs(skew[a, b]) < cutoff:
+                for k in range(nrows):
+                    ac_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[a, k]
+                    bd_term[a, b] += A_mat[a, k] * A_mat[k, b] * spectrum[b, k]
+            elif skew[a, b] > cutoff:
+                break
+
+    # skew[a,b] = w[a] - w[b]
+    # (w[a] - w[b] - w[c] + w[d]) < cutoff
+    # w's are sorted so we can skip part of the loop.
+    for a in range(nrows):
+        for b in range(nrows):
+            d_min = 0
+            for c in range(nrows):
+                if skew[a, b] - skew[c, nrows-1] <= -cutoff:
+                    break
+                for d in range(d_min, nrows):
+                    dskew = skew[a, b] - skew[c, d]
+                    if -dskew > cutoff:
+                        d_min = d
+                    elif fabs(dskew) < cutoff:
+                        elem = (A_mat[a, c] * A_mat[d, b]) * 0.5
+                        elem *= (spectrum[c, a] + spectrum[d, b])
+                        if a == c:
+                            elem -= 0.5 * ac_term[d, b]
+                        if b == d:
+                            elem -= 0.5 * bd_term[a, c]
+                        if elem != 0:
+                            coo_rows.push_back(a * nrows + b)
+                            coo_cols.push_back(c * nrows + d)
+                            coo_data.push_back(elem)
+                    elif dskew >= cutoff:
+                        break
+
+    return csr.from_coo_pointers(
+        coo_rows.data(), coo_cols.data(), coo_data.data(),
+        nrows*nrows, nrows*nrows, coo_rows.size()
+    )
+
+
+cdef class _BlochRedfieldElement(_BaseElement):
+    """
+    Element for individual Bloch Redfield collapse term.
+
+    The tensor is computed in the ``eig_basis``, but is returned in the outside
+    basis unless ``eig_basis`` is True. The ``matmul_data_t`` method also act
+    on a state expected to be in that basis. It transform the state instead of
+    the tensor as it is usually faster, the state being a density matrix in
+    most cases.
+
+    Diffenrent term can share a same instance of the eigen transform tool
+    (``H`` as _EigenBasisTransform) so that the Hamiltonian is diagonalized
+    only once even when needed by multiple terms.
+    """
+    cdef readonly _EigenBasisTransform H
+    cdef readonly QobjEvo a_op
+    cdef readonly Coefficient spectra
+    cdef readonly double sec_cutoff
+    cdef readonly size_t nrows
+    cdef readonly (idxint, idxint) shape
+    cdef readonly list dims
+    cdef readonly object np_datas
+    cdef readonly double[:, ::1] skew
+    cdef readonly double[:, ::1] spectrum
+    cdef readonly bint eig_basis
+    cdef readonly TensorType tensortype
+
+    def __init__(self, H, a_op, spectra, sec_cutoff, eig_basis=False,
+                 dtype=None):
+        if isinstance(H, _EigenBasisTransform):
+            self.H = H
+        else:
+            self.H = _EigenBasisTransform(H)
+
+        self.a_op = a_op
+        self.spectra = spectra
+        self.sec_cutoff = sec_cutoff
+        self.eig_basis = eig_basis
+        self.nrows = a_op.shape[0]
+        self.dims = [a_op.dims, a_op.dims]
+
+        dtype = dtype or ('dense' if sec_cutoff >= np.inf else 'sparse')
+        self.tensortype = {
+            'sparse': SPARSE,
+            'dense': DENSE,
+            'data': DATA
+        }[dtype]
+
+        # Allocate some array
+        # Let numpy manage memory
+        self.np_datas = [np.zeros((self.nrows, self.nrows), dtype=np.float64),
+                         np.zeros((self.nrows, self.nrows), dtype=np.float64)]
+        self.skew = self.np_datas[0]
+        self.spectrum = self.np_datas[1]
+
+    cpdef double _compute_spectrum(self, double t) except *:
+        "Compute the skew, spectrum and dw_min"
+        cdef Coefficient spec
+        cdef double dw_min = np.inf
+        eigvals = self.H.eigenvalues(t)
+
+        for col in range(0, self.nrows):
+            self.skew[col, col] = 0.
+            self.spectrum[col, col] = self.spectra(t, w=0).real
+            for row in range(col, self.nrows):
+                dw = eigvals[row] - eigvals[col]
+                self.skew[row, col] = dw
+                self.skew[col, row] = -dw
+                if dw != 0:
+                    dw_min = fmin(fabs(dw), dw_min)
+                self.spectrum[row, col] = self.spectra(t, w=dw).real
+                self.spectrum[col, row] = self.spectra(t, w=-dw).real
+        return dw_min
+
+    cdef Data _br_term(self, Data A_eig, double cutoff):
+        if self.tensortype == DENSE:
+            return _br_term_dense(A_eig, self.spectrum, self.skew, cutoff)
+        elif self.tensortype == SPARSE:
+            return _br_term_sparse(A_eig, self.spectrum, self.skew, cutoff)
+        elif self.tensortype == DATA:
+            return _br_term_data(A_eig, self.spectrum, self.skew, cutoff)
+        raise ValueError('Invalid tensortype')
+
+    cpdef object qobj(self, t):
+        return Qobj(self.data(t), dims=self.dims, type="super",
+                    copy=False, superrep="super")
+
+    cpdef object coeff(self, t):
+        return 1.
+
+    cpdef Data data(self, t):
+        cdef size_t i
+        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
+        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
+        BR_eig = self._br_term(A_eig, cutoff)
+        if self.eig_basis:
+            return BR_eig
+        return self.H.from_eigbasis(t, BR_eig)
+
+    cdef Data matmul_data_t(self, t, Data state, Data out=None):
+        cdef size_t i
+        cdef double cutoff = self.sec_cutoff * self._compute_spectrum(t)
+        cdef Data A_eig, BR_eig
+
+        if not self.eig_basis:
+            state = self.H.to_eigbasis(t, state)
+        if not self.eig_basis and out is not None:
+            out = self.H.to_eigbasis(t, out)
+        A_eig = self.H.to_eigbasis(t, self.a_op._call(t))
+        BR_eig = self._br_term(A_eig, cutoff)
+        out = _data.add(_data.matmul(BR_eig, state), out)
+        if not self.eig_basis:
+            out = self.H.from_eigbasis(t, out)
+        return out
+
+    def linear_map(self, f, anti=False):
+        return _MapElement(self, [f])
+
+    def replace_arguments(self, args, cache=None):
+        if cache is None:
+            return _BlochRedfieldElement(
+                self.H,
+                QobjEvo(self.a_op, args=args),
+                self.spectra,
+                self.sec_cutoff
+            )
+        H = None
+        for old, new in cache:
+            if old is self:
+                return new
+            if old is self.H:
+                H = new
+        if H is None:
+            H = _EigenBasisTransform(QobjEvo(self.H.oper, args=args),
+                                     type(self.H.oper) is CSR)
+        new = _BlochRedfieldElement(
+            H, QobjEvo(self.a_op, args=args),
+            self.spectra.replace_arguments(**args), self.sec_cutoff
+        )
+        cache.append((self, new))
+        cache.append((self.H, H))
+        return new
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    def __mul__(left, right):
+        cdef _MapElement out
+        if type(left) is _BlochRedfieldElement:
+            out = _MapElement(left, [], right)
+        if type(right) is _BlochRedfieldElement:
+            out = _MapElement(right, [], left)
+        return out
diff --git a/qutip/core/_brtools.pxd b/qutip/core/_brtools.pxd
index 508d84603d..ca9e3dd3ee 100644
--- a/qutip/core/_brtools.pxd
+++ b/qutip/core/_brtools.pxd
@@ -1,32 +1,32 @@
-#cython: language_level=3
-from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.data cimport Data
-
-cdef class SpectraCoefficient(Coefficient):
-    cdef Coefficient coeff_t
-    cdef Coefficient coeff_w
-    cdef double w
-
-cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
-
-cdef class _EigenBasisTransform:
-    cdef:
-        QobjEvo oper
-        int size
-        readonly bint isconstant
-        double _t
-        object _eigvals  # np.ndarray
-        Data _evecs, _evecs_inv
-
-    cpdef object eigenvalues(self, double t)
-    cpdef Data evecs(self, double t)
-
-    cpdef Data to_eigbasis(self, double t, Data fock)
-    cpdef Data from_eigbasis(self, double t, Data eig)
-
-    cdef Data _inv(self, double t)
-    cdef void _compute_eigen(self, double t) except *
-
-    cdef Data _S_converter(self, double t)
-    cdef Data _S_converter_inverse(self, double t)
+#cython: language_level=3
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.data cimport Data
+
+cdef class SpectraCoefficient(Coefficient):
+    cdef Coefficient coeff_t
+    cdef Coefficient coeff_w
+    cdef double w
+
+cpdef Data matmul_var_data(Data left, Data right, int transleft, int transright)
+
+cdef class _EigenBasisTransform:
+    cdef:
+        QobjEvo oper
+        int size
+        readonly bint isconstant
+        double _t
+        object _eigvals  # np.ndarray
+        Data _evecs, _evecs_inv
+
+    cpdef object eigenvalues(self, double t)
+    cpdef Data evecs(self, double t)
+
+    cpdef Data to_eigbasis(self, double t, Data fock)
+    cpdef Data from_eigbasis(self, double t, Data eig)
+
+    cdef Data _inv(self, double t)
+    cdef void _compute_eigen(self, double t) except *
+
+    cdef Data _S_converter(self, double t)
+    cdef Data _S_converter_inverse(self, double t)
diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
index 98737b0fb0..a7e379c964 100644
--- a/qutip/core/_brtools.pyx
+++ b/qutip/core/_brtools.pyx
@@ -1,327 +1,327 @@
-#cython: language_level=3
-from libc.math cimport fabs, fmin
-from libc.float cimport DBL_MAX
-
-cimport numpy as cnp
-import numpy as np
-
-cimport cython
-
-from qutip.core.cy.qobjevo cimport QobjEvo
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.data cimport Data, Dense, idxint
-import qutip.core.data as _data
-from qutip.core import Qobj
-from scipy.linalg cimport cython_blas as blas
-
-
-__all__ = ['SpectraCoefficient']
-
-
-cdef class SpectraCoefficient(Coefficient):
-    """
-    Change a Coefficient with `t` dependence to one with `w` dependence to use
-    in Bloch-Redfield tensor to allow array based coefficients to be used as
-    spectral functions.
-    If 2 coefficients are passed, the first one is the frequence response and
-    the second is the time response.
-    """
-    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
-        self.coeff_t = coeff_t
-        self.coeff_w = coeff_w
-        self.w = w
-
-    cdef complex _call(self, double t) except *:
-        if self.coeff_t is None:
-            return self.coeff_w(self.w)
-        return self.coeff_t(t) * self.coeff_w(self.w)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
-
-    def replace_arguments(self, _args=None, *, w=None, **kwargs):
-        if _args:
-            kwargs.update(_args)
-        if kwargs:
-            return SpectraCoefficient(
-                self.coeff_w.replace(**kwargs),
-                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
-                kwargs.get('w', w or self.w)
-              )
-        if w is not None:
-            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
-        return self
-
-
-@cython.overflowcheck(True)
-cdef size_t _mul_checked(size_t a, size_t b) except? -1:
-    return a * b
-
-
-cdef Data _apply_trans(Data original, int trans):
-    """helper function for matmul_var_data, apply transform."""
-    cdef Data out
-    if trans == 0:
-        out = original
-    elif trans == 1:
-        out = original.transpose()
-    elif trans == 2:
-        out = original.conj()
-    elif trans == 3:
-        out = original.adjoint()
-    return out
-
-
-cdef char _fetch_trans_code(int trans):
-    """helper function for matmul_var_Dense, fetch the blas flag byte"""
-    if trans == 0:
-        return b'N'
-    elif trans == 1:
-        return b'T'
-    elif trans == 3:
-        return b'C'
-
-
-cpdef Data matmul_var_data(Data left, Data right,
-                           int transleft, int transright):
-    """
-    matmul which input matrices can be transposed or adjoint.
-    out = transleft(left) @ transright(right)
-
-    with trans[left, right]:
-        0 : Normal
-        1 : Transpose
-        2 : Conjugate
-        3 : Adjoint
-    """
-    # Should this be supported in data.matmul?
-    # A.dag() @ A is quite common.
-    cdef int size
-    cdef double complex beta
-    cdef char left_code, right_code
-    if (
-        type(left) is Dense
-        and type(right) is Dense
-        and left.shape[0] == left.shape[1]
-        and left.shape[0] == right.shape[0]
-        and left.shape[0] == right.shape[1]
-    ):
-        return matmul_var_Dense(left, right, transleft, transright)
-    left = _apply_trans(left, transleft)
-    right = _apply_trans(right, transright)
-    return _data.matmul(left, right)
-
-
-cdef Dense matmul_var_Dense(Dense left, Dense right,
-                            int transleft, int transright):
-    """
-    matmul which input matrices can be transposed or adjoint.
-    out = transleft(left) @ transright(right)
-
-    with trans[left, right]:
-       0 : Normal
-       1 : Transpose
-       2 : Conjugate
-       3 : Adjoint
-    """
-    # blas support matmul for normal, transpose, adjoint for fortran ordered
-    # matrices.
-    if not (
-        left.shape[0] == left.shape[1]
-        and left.shape[0] == right.shape[0]
-        and left.shape[0] == right.shape[1]
-    ):
-        raise ValueError("Only implemented for square operators")
-    cdef Dense out, a, b
-    cdef double complex alpha = 1., beta = 0.
-    cdef int tleft, tright, size = left.shape[0]
-
-    # Since fortran to C equivalent to transpose, fix the codes to fortran
-    tleft = transleft ^ (not left.fortran)
-    tright = transright ^ (not right.fortran)
-
-    # blas.zgemm does not support adjoint.
-    if tleft + tright == 5:
-        # adjoint and conjugate, we can't transpose the output to use zgemm
-        out = matmul_var_data(left, right, transleft-2, transright-2)
-        return out.conj()
-    if tleft == 2 or tright == 2:
-        # Need a conjugate, we compute the transpose of the desired results.
-        # A.conj @ B^op -> (B^T^op @ A.dag)^T
-        out = _data.dense.empty(left.shape[0], right.shape[1], False)
-        a, b = right, left
-        tleft, tright = tright ^ 1, tleft ^ 1
-    else:
-        out = _data.dense.empty(left.shape[0], right.shape[1], True)
-        a, b = left, right
-
-    left_code = _fetch_trans_code(tleft)
-    right_code = _fetch_trans_code(tright)
-    blas.zgemm(&left_code, &right_code, &size, &size, &size,
-               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
-               &beta, (<Dense> out).data, &size)
-
-    return out
-
-
-class _eigen_qevo:
-    """
-    Callable function to represent the eigenvectors of a QobjEvo at a time
-    ``t``.
-    """
-    def __init__(self, qevo):
-        self.qevo = QobjEvo(qevo)  # Force a copy
-        self.args = None
-        # This is a base conversion operator, the eigen basis part of the dims
-        # are flat.
-        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
-
-    def __call__(self, t, args):
-        if args is not self.args:
-            self.args = args
-            self.qevo.arguments(self.args)
-        _, data = _data.eigs(self.qevo._call(t), True, True)
-        return Qobj(data, copy=False, dims=self.out_dims)
-
-
-cdef class _EigenBasisTransform:
-    """
-    For an hermitian operator, compute the eigenvalues and eigenstates and do
-    the base change to and from that eigenbasis.
-
-    parameter
-    ---------
-    oper : QobjEvo
-        Hermitian operator for which to compute the eigenbasis.
-
-    sparse : bool [False]
-        Whether to use sparse solver for eigen decomposition.
-    """
-    def __init__(self, QobjEvo oper, bint sparse=False):
-        if oper.dims[0] != oper.dims[1]:
-            raise ValueError
-        if type(oper(0).data) is _data.CSR and not sparse:
-            oper = oper.to(Dense)
-        self.oper = oper
-        self.isconstant = oper.isconstant
-        self.size = oper.shape[0]
-
-        if oper.isconstant:
-            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
-                                                    True, True)
-        else:
-            self._evecs = None
-            self._eigvals = None
-
-        self._t = np.nan
-        self._evecs_inv = None
-
-    def as_Qobj(self):
-        """Make an Qobj or QobjEvo of the eigenvectors."""
-        if self.isconstant:
-            return Qobj(self.evecs(0), dims=self.oper.dims)
-        else:
-            return QobjEvo(_eigen_qevo(self.oper))
-
-    cdef void _compute_eigen(self, double t) except *:
-        if self._t != t and not self.isconstant:
-            self._t = t
-            self._evecs_inv = None
-            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
-
-    cpdef object eigenvalues(self, double t):
-        """
-        Return the eigenvalues at ``t``.
-        """
-        self._compute_eigen(t)
-        return self._eigvals
-
-    cpdef Data evecs(self, double t):
-        """
-        Return the eigenstates at ``t``.
-        """
-        self._compute_eigen(t)
-        return self._evecs
-
-    cdef Data _inv(self, double t):
-        if self._evecs_inv is None:
-            self._evecs_inv = self.evecs(t).adjoint()
-        return self._evecs_inv
-
-    cdef Data _S_converter(self, double t):
-        return _data.kron(self.evecs(t).transpose(), self._inv(t))
-
-    cdef Data _S_converter_inverse(self, double t):
-        return _data.kron(self._inv(t).transpose(), self.evecs(t))
-
-    cpdef Data to_eigbasis(self, double t, Data fock):
-        """
-        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
-        ``oper(t)`` is diagonalized.
-        """
-        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
-        # Blas include A.dag @ B in one operation. We use it if we can so we
-        # don't make unneeded copy of evecs.
-        cdef Data temp
-        if fock.shape[0] == self.size and fock.shape[1] == 1:
-            return matmul_var_data(self.evecs(t), fock, 3, 0)
-
-        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
-            if type(fock) is Dense and (<Dense> fock).fortran:
-                fock = _data.column_unstack_dense(fock, self.size, True)
-                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-                                    self.evecs(t))
-                fock = _data.column_stack_dense(fock, True)
-            else:
-                fock = _data.column_unstack(fock, self.size)
-                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-                                    self.evecs(t))
-            if type(temp) is Dense:
-                return _data.column_stack_dense(temp, True)
-            return _data.column_stack(temp)
-
-        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
-            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
-                                self.evecs(t))
-
-        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
-            temp = self._S_converter_inverse(t)
-            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
-
-        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
-                         "can't guess type from shape.")
-
-    cpdef Data from_eigbasis(self, double t, Data eig):
-        """
-        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
-        ``oper(t)`` is diagonalized to the outside basis.
-        """
-        cdef Data temp
-        if eig.shape[0] == self.size and eig.shape[1] == 1:
-            return _data.matmul(self.evecs(t), eig)
-
-        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
-            if type(eig) is Dense and (<Dense> eig).fortran:
-                eig = _data.column_unstack_dense(eig, self.size, True)
-                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
-                                  self.evecs(t), 0, 3)
-                eig = _data.column_stack_dense(eig, True)
-            else:
-                eig = _data.column_unstack(eig, self.size)
-                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
-                                  self.evecs(t), 0, 3)
-            if type(temp) is Dense:
-                return _data.column_stack_dense(temp, True)
-            return _data.column_stack(temp)
-
-        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
-            temp = self.evecs(t)
-            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
-
-        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
-            temp = self._S_converter_inverse(t)
-            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
-
-        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
-                         "can't guess type from shape.")
+#cython: language_level=3
+from libc.math cimport fabs, fmin
+from libc.float cimport DBL_MAX
+
+cimport numpy as cnp
+import numpy as np
+
+cimport cython
+
+from qutip.core.cy.qobjevo cimport QobjEvo
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.data cimport Data, Dense, idxint
+import qutip.core.data as _data
+from qutip.core import Qobj
+from scipy.linalg cimport cython_blas as blas
+
+
+__all__ = ['SpectraCoefficient']
+
+
+cdef class SpectraCoefficient(Coefficient):
+    """
+    Change a Coefficient with `t` dependence to one with `w` dependence to use
+    in Bloch-Redfield tensor to allow array based coefficients to be used as
+    spectral functions.
+    If 2 coefficients are passed, the first one is the frequence response and
+    the second is the time response.
+    """
+    def __init__(self, Coefficient coeff_w, Coefficient coeff_t=None, double w=0):
+        self.coeff_t = coeff_t
+        self.coeff_w = coeff_w
+        self.w = w
+
+    cdef complex _call(self, double t) except *:
+        if self.coeff_t is None:
+            return self.coeff_w(self.w)
+        return self.coeff_t(t) * self.coeff_w(self.w)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return SpectraCoefficient(self.coeff_t, self.coeff_w, self.w)
+
+    def replace_arguments(self, _args=None, *, w=None, **kwargs):
+        if _args:
+            kwargs.update(_args)
+        if kwargs:
+            return SpectraCoefficient(
+                self.coeff_w.replace(**kwargs),
+                self.coeff_t.replace(**kwargs) if self.coeff_t else None,
+                kwargs.get('w', w or self.w)
+              )
+        if w is not None:
+            return SpectraCoefficient(self.coeff_w, self.coeff_t, w)
+        return self
+
+
+@cython.overflowcheck(True)
+cdef size_t _mul_checked(size_t a, size_t b) except? -1:
+    return a * b
+
+
+cdef Data _apply_trans(Data original, int trans):
+    """helper function for matmul_var_data, apply transform."""
+    cdef Data out
+    if trans == 0:
+        out = original
+    elif trans == 1:
+        out = original.transpose()
+    elif trans == 2:
+        out = original.conj()
+    elif trans == 3:
+        out = original.adjoint()
+    return out
+
+
+cdef char _fetch_trans_code(int trans):
+    """helper function for matmul_var_Dense, fetch the blas flag byte"""
+    if trans == 0:
+        return b'N'
+    elif trans == 1:
+        return b'T'
+    elif trans == 3:
+        return b'C'
+
+
+cpdef Data matmul_var_data(Data left, Data right,
+                           int transleft, int transright):
+    """
+    matmul which input matrices can be transposed or adjoint.
+    out = transleft(left) @ transright(right)
+
+    with trans[left, right]:
+        0 : Normal
+        1 : Transpose
+        2 : Conjugate
+        3 : Adjoint
+    """
+    # Should this be supported in data.matmul?
+    # A.dag() @ A is quite common.
+    cdef int size
+    cdef double complex beta
+    cdef char left_code, right_code
+    if (
+        type(left) is Dense
+        and type(right) is Dense
+        and left.shape[0] == left.shape[1]
+        and left.shape[0] == right.shape[0]
+        and left.shape[0] == right.shape[1]
+    ):
+        return matmul_var_Dense(left, right, transleft, transright)
+    left = _apply_trans(left, transleft)
+    right = _apply_trans(right, transright)
+    return _data.matmul(left, right)
+
+
+cdef Dense matmul_var_Dense(Dense left, Dense right,
+                            int transleft, int transright):
+    """
+    matmul which input matrices can be transposed or adjoint.
+    out = transleft(left) @ transright(right)
+
+    with trans[left, right]:
+       0 : Normal
+       1 : Transpose
+       2 : Conjugate
+       3 : Adjoint
+    """
+    # blas support matmul for normal, transpose, adjoint for fortran ordered
+    # matrices.
+    if not (
+        left.shape[0] == left.shape[1]
+        and left.shape[0] == right.shape[0]
+        and left.shape[0] == right.shape[1]
+    ):
+        raise ValueError("Only implemented for square operators")
+    cdef Dense out, a, b
+    cdef double complex alpha = 1., beta = 0.
+    cdef int tleft, tright, size = left.shape[0]
+
+    # Since fortran to C equivalent to transpose, fix the codes to fortran
+    tleft = transleft ^ (not left.fortran)
+    tright = transright ^ (not right.fortran)
+
+    # blas.zgemm does not support adjoint.
+    if tleft + tright == 5:
+        # adjoint and conjugate, we can't transpose the output to use zgemm
+        out = matmul_var_data(left, right, transleft-2, transright-2)
+        return out.conj()
+    if tleft == 2 or tright == 2:
+        # Need a conjugate, we compute the transpose of the desired results.
+        # A.conj @ B^op -> (B^T^op @ A.dag)^T
+        out = _data.dense.empty(left.shape[0], right.shape[1], False)
+        a, b = right, left
+        tleft, tright = tright ^ 1, tleft ^ 1
+    else:
+        out = _data.dense.empty(left.shape[0], right.shape[1], True)
+        a, b = left, right
+
+    left_code = _fetch_trans_code(tleft)
+    right_code = _fetch_trans_code(tright)
+    blas.zgemm(&left_code, &right_code, &size, &size, &size,
+               &alpha, (<Dense> a).data, &size, (<Dense> b).data, &size,
+               &beta, (<Dense> out).data, &size)
+
+    return out
+
+
+class _eigen_qevo:
+    """
+    Callable function to represent the eigenvectors of a QobjEvo at a time
+    ``t``.
+    """
+    def __init__(self, qevo):
+        self.qevo = QobjEvo(qevo)  # Force a copy
+        self.args = None
+        # This is a base conversion operator, the eigen basis part of the dims
+        # are flat.
+        self.out_dims = [qevo.dims[0], [qevo.shape[1]]]
+
+    def __call__(self, t, args):
+        if args is not self.args:
+            self.args = args
+            self.qevo.arguments(self.args)
+        _, data = _data.eigs(self.qevo._call(t), True, True)
+        return Qobj(data, copy=False, dims=self.out_dims)
+
+
+cdef class _EigenBasisTransform:
+    """
+    For an hermitian operator, compute the eigenvalues and eigenstates and do
+    the base change to and from that eigenbasis.
+
+    parameter
+    ---------
+    oper : QobjEvo
+        Hermitian operator for which to compute the eigenbasis.
+
+    sparse : bool [False]
+        Whether to use sparse solver for eigen decomposition.
+    """
+    def __init__(self, QobjEvo oper, bint sparse=False):
+        if oper.dims[0] != oper.dims[1]:
+            raise ValueError
+        if type(oper(0).data) is _data.CSR and not sparse:
+            oper = oper.to(Dense)
+        self.oper = oper
+        self.isconstant = oper.isconstant
+        self.size = oper.shape[0]
+
+        if oper.isconstant:
+            self._eigvals, self._evecs = _data.eigs(self.oper._call(0),
+                                                    True, True)
+        else:
+            self._evecs = None
+            self._eigvals = None
+
+        self._t = np.nan
+        self._evecs_inv = None
+
+    def as_Qobj(self):
+        """Make an Qobj or QobjEvo of the eigenvectors."""
+        if self.isconstant:
+            return Qobj(self.evecs(0), dims=self.oper.dims)
+        else:
+            return QobjEvo(_eigen_qevo(self.oper))
+
+    cdef void _compute_eigen(self, double t) except *:
+        if self._t != t and not self.isconstant:
+            self._t = t
+            self._evecs_inv = None
+            self._eigvals, self._evecs = _data.eigs(self.oper._call(t), True, True)
+
+    cpdef object eigenvalues(self, double t):
+        """
+        Return the eigenvalues at ``t``.
+        """
+        self._compute_eigen(t)
+        return self._eigvals
+
+    cpdef Data evecs(self, double t):
+        """
+        Return the eigenstates at ``t``.
+        """
+        self._compute_eigen(t)
+        return self._evecs
+
+    cdef Data _inv(self, double t):
+        if self._evecs_inv is None:
+            self._evecs_inv = self.evecs(t).adjoint()
+        return self._evecs_inv
+
+    cdef Data _S_converter(self, double t):
+        return _data.kron(self.evecs(t).transpose(), self._inv(t))
+
+    cdef Data _S_converter_inverse(self, double t):
+        return _data.kron(self._inv(t).transpose(), self.evecs(t))
+
+    cpdef Data to_eigbasis(self, double t, Data fock):
+        """
+        Do the transformation of the :cls:`Qobj` ``fock`` to the basis where
+        ``oper(t)`` is diagonalized.
+        """
+        # For Hermitian operator, the inverse of evecs is the adjoint matrix.
+        # Blas include A.dag @ B in one operation. We use it if we can so we
+        # don't make unneeded copy of evecs.
+        cdef Data temp
+        if fock.shape[0] == self.size and fock.shape[1] == 1:
+            return matmul_var_data(self.evecs(t), fock, 3, 0)
+
+        elif fock.shape[0] == self.size**2 and fock.shape[1] == 1:
+            if type(fock) is Dense and (<Dense> fock).fortran:
+                fock = _data.column_unstack_dense(fock, self.size, True)
+                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+                                    self.evecs(t))
+                fock = _data.column_stack_dense(fock, True)
+            else:
+                fock = _data.column_unstack(fock, self.size)
+                temp = _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+                                    self.evecs(t))
+            if type(temp) is Dense:
+                return _data.column_stack_dense(temp, True)
+            return _data.column_stack(temp)
+
+        elif fock.shape[0] == self.size and fock.shape[0] == fock.shape[1]:
+            return _data.matmul(matmul_var_data(self.evecs(t), fock, 3, 0),
+                                self.evecs(t))
+
+        elif fock.shape[0] == self.size**2 and fock.shape[0] == fock.shape[1]:
+            temp = self._S_converter_inverse(t)
+            return _data.matmul(matmul_var_data(temp, fock, 3, 0), temp)
+
+        raise ValueError("Could not convert the Qobj's data to eigenbasis: "
+                         "can't guess type from shape.")
+
+    cpdef Data from_eigbasis(self, double t, Data eig):
+        """
+        Do the transformation of the :cls:`Qobj` ``eig`` in the basis where
+        ``oper(t)`` is diagonalized to the outside basis.
+        """
+        cdef Data temp
+        if eig.shape[0] == self.size and eig.shape[1] == 1:
+            return _data.matmul(self.evecs(t), eig)
+
+        elif eig.shape[0] == self.size**2 and eig.shape[1] == 1:
+            if type(eig) is Dense and (<Dense> eig).fortran:
+                eig = _data.column_unstack_dense(eig, self.size, True)
+                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
+                                  self.evecs(t), 0, 3)
+                eig = _data.column_stack_dense(eig, True)
+            else:
+                eig = _data.column_unstack(eig, self.size)
+                temp = matmul_var_data(_data.matmul(self.evecs(t), eig),
+                                  self.evecs(t), 0, 3)
+            if type(temp) is Dense:
+                return _data.column_stack_dense(temp, True)
+            return _data.column_stack(temp)
+
+        elif eig.shape[0] == self.size and eig.shape[0] == eig.shape[1]:
+            temp = self.evecs(t)
+            return matmul_var_data(_data.matmul(temp, eig), temp, 0, 3)
+
+        elif eig.shape[0] == self.size**2 and eig.shape[0] == eig.shape[1]:
+            temp = self._S_converter_inverse(t)
+            return _data.matmul(temp, matmul_var_data(eig, temp, 0, 3))
+
+        raise ValueError("Could not convert the Qobj's data from eigenbasis: "
+                         "can't guess type from shape.")
diff --git a/qutip/core/blochredfield.py b/qutip/core/blochredfield.py
index 7a3c6d25e4..e23f6af90a 100644
--- a/qutip/core/blochredfield.py
+++ b/qutip/core/blochredfield.py
@@ -1,188 +1,188 @@
-import os
-import inspect
-import numpy as np
-from qutip.settings import settings as qset
-
-from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
-from ._brtools import SpectraCoefficient, _EigenBasisTransform
-from .cy.coefficient import InterCoefficient, Coefficient
-from ._brtensor import _BlochRedfieldElement
-
-
-__all__ = ['bloch_redfield_tensor', 'brterm']
-
-
-def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
-                          fock_basis=False, sparse_eigensolver=False,
-                          br_dtype='sparse'):
-    """
-    Calculates the Bloch-Redfield tensor for a system given
-    a set of operators and corresponding spectral functions that describes the
-    system's coupling to its environment.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-        System Hamiltonian.
-
-    a_ops : list of (a_op, spectra)
-        Nested list of system operators that couple to the environment,
-        and the corresponding bath spectra.
-
-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-            The operator coupling to the environment. Must be hermitian.
-
-        spectra : :class:`Coefficient`, func, str
-            The corresponding bath spectra.
-            Can be a :class:`~Coefficient` using an 'w' args, a function of the
-            frequency or a string. The :class:`SpectraCoefficient` can be used for
-            array based coefficient.
-            The spectra can depend on ``t`` if the corresponding
-            ``a_op`` is a :class:`QobjEvo`.
-
-        Example:
-
-        .. code-block::
-
-            a_ops = [
-                (a+a.dag(), ('w>0', args={"w": 0})),
-                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
-                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-            ]
-
-
-    c_ops : list
-        List of system collapse operators.
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    fock_basis : bool {False}
-        Whether to return the tensor in the input basis or the diagonalized
-        basis.
-
-    sparse_eigensolver : bool {False}
-        Whether to use the sparse eigensolver
-
-    br_dtype : ['sparse', 'dense', 'data']
-        Which data type to use when computing the brtensor.
-        With a cutoff 'sparse' is usually the most efficient.
-
-    Returns
-    -------
-    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
-        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
-        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
-        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
-        column.
-    """
-    R = liouvillian(H, c_ops)
-    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
-
-    if fock_basis:
-        for (a_op, spectra) in a_ops:
-            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
-                        br_dtype=br_dtype)
-        return R
-    else:
-        # When the Hamiltonian is time-dependent, the transformation of `L` to
-        # eigenbasis is not optimized.
-        if isinstance(R, QobjEvo):
-            # The `sprepost` will be computed 2 times for each parts of `R`.
-            # Compressing the QobjEvo will lower the number of parts.
-            R.compress()
-        evec = H_transform.as_Qobj()
-        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
-        for (a_op, spectra) in a_ops:
-            R += brterm(H_transform, a_op, spectra, sec_cutoff,
-                        False, br_dtype=br_dtype)[0]
-        return R, H_transform.as_Qobj()
-
-
-def brterm(H, a_op, spectra, sec_cutoff=0.1,
-           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
-    """
-    Calculates the contribution of one coupling operator to the Bloch-Redfield
-    tensor.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-        System Hamiltonian.
-
-    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-        The operator coupling to the environment. Must be hermitian.
-
-    spectra : :class:`Coefficient`, func, str
-        The corresponding bath spectra.
-        Can be a :class:`~Coefficient` using an 'w' args, a function of the
-        frequency or a string. The :class:`SpectraCoefficient` can be used for
-        array based coefficient.
-        The spectra can depend on ``t`` if the corresponding
-        ``a_op`` is a :class:`QobjEvo`.
-
-        Example:
-
-            coefficient('w>0', args={"w": 0})
-            SpectraCoefficient(coefficient(array, tlist=...))
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    fock_basis : bool {False}
-        Whether to return the tensor in the input basis or the diagonalized
-        basis.
-
-    sparse_eigensolver : bool {False}
-        Whether to use the sparse eigensolver on the Hamiltonian.
-
-    br_dtype : ['sparse', 'dense', 'data']
-        Which data type to use when computing the brtensor.
-        With a cutoff 'sparse' is usually the most efficient.
-
-    Returns
-    -------
-    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
-        If ``fock_basis``, return the Bloch Redfield tensor in the outside
-        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
-        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
-        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
-        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
-    """
-    if isinstance(H, _EigenBasisTransform):
-        Hdiag = H
-    else:
-        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
-
-    # convert spectra to Coefficient
-    if isinstance(spectra, str):
-        spectra = coefficient(spectra, args={'w': 0})
-    elif isinstance(spectra, InterCoefficient):
-        spectra = SpectraCoefficient(spectra)
-    elif isinstance(spectra, Coefficient):
-        pass
-    elif callable(spectra):
-        sig = inspect.signature(spectra)
-        if tuple(sig.parameters.keys()) == ("w",):
-            spectra = SpectraCoefficient(coefficient(spectra))
-        else:
-            spectra = coefficient(spectra, args={'w': 0})
-    else:
-        raise TypeError("a_ops's spectra not known")
-
-    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
-    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
-                sec_cutoff, not fock_basis, dtype=br_dtype))
-
-    if (
-        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
-         or isinstance(H, Qobj))
-        and isinstance(a_op, Qobj)
-    ):
-        R = R(0)
-    return R if fock_basis else (R, Hdiag.as_Qobj())
+import os
+import inspect
+import numpy as np
+from qutip.settings import settings as qset
+
+from . import Qobj, QobjEvo, liouvillian, coefficient, sprepost
+from ._brtools import SpectraCoefficient, _EigenBasisTransform
+from .cy.coefficient import InterCoefficient, Coefficient
+from ._brtensor import _BlochRedfieldElement
+
+
+__all__ = ['bloch_redfield_tensor', 'brterm']
+
+
+def bloch_redfield_tensor(H, a_ops, c_ops=[], sec_cutoff=0.1,
+                          fock_basis=False, sparse_eigensolver=False,
+                          br_dtype='sparse'):
+    """
+    Calculates the Bloch-Redfield tensor for a system given
+    a set of operators and corresponding spectral functions that describes the
+    system's coupling to its environment.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+        System Hamiltonian.
+
+    a_ops : list of (a_op, spectra)
+        Nested list of system operators that couple to the environment,
+        and the corresponding bath spectra.
+
+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+            The operator coupling to the environment. Must be hermitian.
+
+        spectra : :class:`Coefficient`, func, str
+            The corresponding bath spectra.
+            Can be a :class:`~Coefficient` using an 'w' args, a function of the
+            frequency or a string. The :class:`SpectraCoefficient` can be used for
+            array based coefficient.
+            The spectra can depend on ``t`` if the corresponding
+            ``a_op`` is a :class:`QobjEvo`.
+
+        Example:
+
+        .. code-block::
+
+            a_ops = [
+                (a+a.dag(), ('w>0', args={"w": 0})),
+                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
+                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+            ]
+
+
+    c_ops : list
+        List of system collapse operators.
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    fock_basis : bool {False}
+        Whether to return the tensor in the input basis or the diagonalized
+        basis.
+
+    sparse_eigensolver : bool {False}
+        Whether to use the sparse eigensolver
+
+    br_dtype : ['sparse', 'dense', 'data']
+        Which data type to use when computing the brtensor.
+        With a cutoff 'sparse' is usually the most efficient.
+
+    Returns
+    -------
+    R, [evecs]: :class:`qutip.Qobj`, tuple of :class:`qutip.Qobj`
+        If ``fock_basis``, return the Bloch Redfield tensor in the laboratory
+        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
+        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
+        column.
+    """
+    R = liouvillian(H, c_ops)
+    H_transform = _EigenBasisTransform(QobjEvo(H), sparse_eigensolver)
+
+    if fock_basis:
+        for (a_op, spectra) in a_ops:
+            R += brterm(H_transform, a_op, spectra, sec_cutoff, True,
+                        br_dtype=br_dtype)
+        return R
+    else:
+        # When the Hamiltonian is time-dependent, the transformation of `L` to
+        # eigenbasis is not optimized.
+        if isinstance(R, QobjEvo):
+            # The `sprepost` will be computed 2 times for each parts of `R`.
+            # Compressing the QobjEvo will lower the number of parts.
+            R.compress()
+        evec = H_transform.as_Qobj()
+        R = sprepost(evec, evec.dag()) @ R @ sprepost(evec.dag(), evec)
+        for (a_op, spectra) in a_ops:
+            R += brterm(H_transform, a_op, spectra, sec_cutoff,
+                        False, br_dtype=br_dtype)[0]
+        return R, H_transform.as_Qobj()
+
+
+def brterm(H, a_op, spectra, sec_cutoff=0.1,
+           fock_basis=False, sparse_eigensolver=False, br_dtype='sparse'):
+    """
+    Calculates the contribution of one coupling operator to the Bloch-Redfield
+    tensor.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+        System Hamiltonian.
+
+    a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+        The operator coupling to the environment. Must be hermitian.
+
+    spectra : :class:`Coefficient`, func, str
+        The corresponding bath spectra.
+        Can be a :class:`~Coefficient` using an 'w' args, a function of the
+        frequency or a string. The :class:`SpectraCoefficient` can be used for
+        array based coefficient.
+        The spectra can depend on ``t`` if the corresponding
+        ``a_op`` is a :class:`QobjEvo`.
+
+        Example:
+
+            coefficient('w>0', args={"w": 0})
+            SpectraCoefficient(coefficient(array, tlist=...))
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    fock_basis : bool {False}
+        Whether to return the tensor in the input basis or the diagonalized
+        basis.
+
+    sparse_eigensolver : bool {False}
+        Whether to use the sparse eigensolver on the Hamiltonian.
+
+    br_dtype : ['sparse', 'dense', 'data']
+        Which data type to use when computing the brtensor.
+        With a cutoff 'sparse' is usually the most efficient.
+
+    Returns
+    -------
+    R, [evecs]: :class:`~Qobj`, :class:`~QobjEvo` or tuple
+        If ``fock_basis``, return the Bloch Redfield tensor in the outside
+        basis. Otherwise return the Bloch Redfield tensor in the diagonalized
+        Hamiltonian basis and the eigenvectors of the Hamiltonian as hstacked
+        column. The tensors and, if given, evecs, will be :obj:`~QobjEvo` if
+        the ``H`` and ``a_op`` is time dependent, :obj:`Qobj` otherwise.
+    """
+    if isinstance(H, _EigenBasisTransform):
+        Hdiag = H
+    else:
+        Hdiag = _EigenBasisTransform(QobjEvo(H), sparse=sparse_eigensolver)
+
+    # convert spectra to Coefficient
+    if isinstance(spectra, str):
+        spectra = coefficient(spectra, args={'w': 0})
+    elif isinstance(spectra, InterCoefficient):
+        spectra = SpectraCoefficient(spectra)
+    elif isinstance(spectra, Coefficient):
+        pass
+    elif callable(spectra):
+        sig = inspect.signature(spectra)
+        if tuple(sig.parameters.keys()) == ("w",):
+            spectra = SpectraCoefficient(coefficient(spectra))
+        else:
+            spectra = coefficient(spectra, args={'w': 0})
+    else:
+        raise TypeError("a_ops's spectra not known")
+
+    sec_cutoff = sec_cutoff if sec_cutoff >= 0 else np.inf
+    R = QobjEvo(_BlochRedfieldElement(Hdiag, QobjEvo(a_op), spectra,
+                sec_cutoff, not fock_basis, dtype=br_dtype))
+
+    if (
+        ((isinstance(H, _EigenBasisTransform) and H.isconstant)
+         or isinstance(H, Qobj))
+        and isinstance(a_op, Qobj)
+    ):
+        R = R(0)
+    return R if fock_basis else (R, Hdiag.as_Qobj())
diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index a738e630c2..d029461f1a 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -1,776 +1,776 @@
-import numpy as np
-import scipy
-import scipy.interpolate
-import os
-import sys
-import re
-import dis
-import hashlib
-import glob
-import importlib
-import warnings
-import numbers
-from contextlib import contextmanager
-from collections import defaultdict
-from setuptools import setup, Extension
-try:
-    from Cython.Build import cythonize
-    import filelock
-except ImportError:
-    pass
-
-from ..settings import settings as qset
-from .options import QutipOptions
-from .data import Data
-from .cy.coefficient import (
-    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
-    ConjCoefficient, NormCoefficient
-)
-
-
-__all__ = ["coefficient", "CompilationOptions", "Coefficient",
-           "clean_compiled_coefficient"]
-
-
-class StringParsingWarning(Warning):
-    pass
-
-
-def _return(base, **kwargs):
-    return base
-
-
-# The `coefficient` function is dispatcher for the type of the `base` to the
-# function that created the `Coefficient` object. `coefficient_builders` stores
-# the map `type -> function(base, **kw)`. Optional module can add their
-# `Coefficient` specializations here.
-coefficient_builders = {
-    Coefficient: _return,
-    np.ndarray: InterCoefficient,
-    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
-    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
-}
-
-
-def coefficient(base, *, tlist=None, args={}, args_ctypes={},
-                order=3, compile_opt=None, function_style=None,
-                boundary_conditions=None, **kwargs):
-    """Build ``Coefficient`` for time dependent systems:
-
-    ```
-    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
-    ```
-
-    The coefficients can be a function, a string or a numpy array. Other
-    packages may add support for other kind of coefficients.
-
-    For function based coefficients, the function signature must be either:
-
-    * ``f(t, ...)`` where the other arguments are supplied as ordinary
-      "pythonic" arguments (e.g. ``f(t, w, a=5))
-    * ``f(t, args)`` where the arguments are supplied in a "dict" named
-      ``args``
-
-    By default the signature style is controlled by the
-    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
-    may be overriden here by specifying either ``function_style="pythonic"``
-    or ``function_style="dict"``.
-
-    *Examples*
-        # pythonic style function signature
-
-        def f1_t(t, w):
-            return np.exp(-1j * t * w)
-
-        coeff1 = coefficient(f1_t, args={"w": 1.})
-
-        # dict style function signature
-
-        def f2_t(t, args):
-            return np.exp(-1j * t * args["w"])
-
-        coeff2 = coefficient(f2_t, args={"w": 1.})
-
-    For string based coeffients, the string must be a compilable python code
-    resulting in a complex. The following symbols are defined:
-        sin cos tan asin acos atan pi
-        sinh cosh tanh asinh acosh atanh
-        exp log log10 erf zerf sqrt
-        real imag conj abs norm arg proj
-        numpy as np,
-        scipy.special as spe (python interface)
-        and cython_special (scipy cython interface)
-
-    *Examples*
-        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
-    'args' is needed for string coefficient at compilation.
-    It is a dict of (name:object). The keys must be a valid variables string.
-
-    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
-
-    For numpy array format, the array must be an 1d of dtype float or complex.
-    A list of times (float64) at which the coeffients must be given (tlist).
-    The coeffients array must have the same len as the tlist.
-    The time of the tlist do not need to be equidistant, but must be sorted.
-    By default, a cubic spline interpolation will be used to compute the
-    coefficient at time t. The keyword ``order`` sets the order of the
-    interpolation. When ``order = 0``, the interpolation is step function that
-    evaluates to the most recent value.
-
-    *Examples*
-        tlist = np.logspace(-5,0,100)
-        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
-
-    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
-    also converted to interpolated coefficients (the same kind of coefficient
-    created from ``ndarray``). Other interpolation methods from
-    scipy are converted to a function-based coefficient (the same kind of
-    coefficient created from callables).
-
-    Parameters
-    ----------
-    base : object
-        Base object to make into a Coefficient.
-
-    args : dict, optional
-        Dictionary of arguments to pass to the function or string coefficient.
-
-    order : int, default=3
-        Order of the spline for array based coefficient.
-
-    tlist : iterable, optional
-        Times for each element of an array based coefficient.
-
-    function_style : str, ["dict", "pythonic", None]
-        Function signature of function based coefficients.
-
-    args_ctypes : dict, optional
-        C type for the args when compiling array based coefficients.
-
-    compile_opt : CompilationOptions, optional
-        Sets of options for the compilation of string based coefficients.
-
-    boundary_conditions: 2-tupule, str or None, optional
-        Specify boundary conditions for spline interpolation.
-
-    **kwargs
-        Extra arguments to pass the the coefficients.
-    """
-    kwargs.update({
-        "tlist": tlist,
-        'args': args,
-        'args_ctypes': args_ctypes,
-        'order': order,
-        'compile_opt': compile_opt,
-        'function_style': function_style,
-        'boundary_conditions': boundary_conditions
-    })
-
-    for type_ in coefficient_builders:
-        if isinstance(base, type_):
-            return coefficient_builders[type_](base, **kwargs)
-
-    if callable(base):
-        op = FunctionCoefficient(base, args.copy(), style=function_style)
-        if not isinstance(op(0), numbers.Number):
-            raise TypeError("The coefficient function must return a number")
-        return op
-    else:
-        raise ValueError("coefficient format not understood")
-
-
-def norm(coeff):
-    """ return a Coefficient with is the norm: |c|^2.
-    """
-    return NormCoefficient(coeff)
-
-
-def conj(coeff):
-    """ return a Coefficient with is the conjugate.
-    """
-    return ConjCoefficient(coeff)
-
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-class CompilationOptions(QutipOptions):
-    """
-    Compilation options:
-
-    use_cython: bool
-        Whether to compile strings as cython code or use python's ``exec``.
-
-    try_parse: bool [True]
-        Whether to try parsing the string for reuse and static typing.
-
-    static_types : bool [True]
-        Whether to use C types for constant and args.
-
-    accept_int : None, bool
-        Whether to use the type ``int`` for integer constants and args or
-        upgrade it to ``float`` or ``complex``.
-        If `None`, it will only use ``int`` when subscription is found in the
-        code.
-
-    accept_float : bool
-        Whether to use the type ``float`` or upgrade them to ``complex``.
-
-    recompile : bool
-        Do not use previously made files but build a new one.
-
-    compiler_flags : str
-        Flags to pass to the compiler, ex: "-Wall -O3"...
-        Flags not matching your comiler and OS may cause compilation to fail.
-        Use "recompile=True", when trying to if the string pattern was
-        previously used.
-
-    link_flags : str
-        Libraries to link to pass to the compiler. They can not be used to add
-        function to the string coefficient.
-
-    extra_import : str
-        Cython code to add at the head of the file. Can be used to add extra
-        import or cimport code, ex:
-        extra_import="from scipy.linalg import det"
-        extra_import="from qutip.core.data cimport CSR"
-
-    clean_on_error : bool [True]
-        When writing a cython file that cannot be imported, erase it.
-    """
-    _link_flags = ""
-    _compiler_flags = ""
-    if sys.platform == 'win32':
-        _compiler_flags = ''
-    elif sys.platform == 'darwin':
-        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
-        _link_flags += '-mmacosx-version-min=10.9'
-    else:
-        _compiler_flags = '-w -O3 -funroll-loops'
-
-    try:
-        import cython
-        import filelock
-        _use_cython = True
-    except ImportError:
-        _use_cython = False
-
-    _options = {
-        "use_cython": _use_cython,
-        "try_parse": True,
-        "static_types": True,
-        "accept_int": None,
-        "accept_float": True,
-        "recompile": False,
-        "compiler_flags": _compiler_flags,
-        "link_flags": _link_flags,
-        "extra_import": "",
-        "clean_on_error": True,
-    }
-    _settings_name = "compile"
-
-
-# Create the default instance in settings.
-qset.compile = CompilationOptions()
-
-
-# Version number of the Coefficient
-COEFF_VERSION = "1.1"
-
-try:
-    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
-    qset.coeffroot = root
-except OSError:
-    qset.coeffroot = "."
-
-
-def clean_compiled_coefficient(all=False):
-    """
-    Remove previouly compiled string Coefficient.
-
-    Parameter:
-    ----------
-    all: bool
-        If not `all` will remove only previous version.
-    """
-    import glob
-    import shutil
-    tmproot = qset.tmproot
-    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
-    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
-    for folder in folders:
-        if all or folder != root:
-            shutil.rmtree(folder)
-    # Recreate the empty folder.
-    qset.coeffroot = qset.coeffroot
-
-
-def proj(x):
-    if np.isfinite(x):
-        return (x)
-    else:
-        return np.inf + 0j * np.imag(x)
-
-
-str_env = {
-    "sin": np.sin,
-    "cos": np.cos,
-    "tan": np.tan,
-    "asin": np.arcsin,
-    "acos": np.arccos,
-    "atan": np.arctan,
-    "pi": np.pi,
-    "sinh": np.sinh,
-    "cosh": np.cosh,
-    "tanh": np.tanh,
-    "asinh": np.arcsinh,
-    "acosh": np.arccosh,
-    "atanh": np.arctanh,
-    "exp": np.exp,
-    "log": np.log,
-    "log10": np.log10,
-    "erf": scipy.special.erf,
-    "zerf": scipy.special.erf,
-    "sqrt": np.sqrt,
-    "real": np.real,
-    "imag": np.imag,
-    "conj": np.conj,
-    "abs": np.abs,
-    "norm": lambda x: np.abs(x)**2,
-    "arg": np.angle,
-    "proj": proj,
-    "np": np,
-    "spe": scipy.special}
-
-
-def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
-    """
-    Entry point for string based coefficients
-    - Test if the string is valid
-    - Parse: "cos(a*t)" and "cos( w1 * t )"
-        should be recognised as the same compiled object.
-    - Verify if already compiled and compile if not
-    """
-    # First, a sanity check before thinking of compiling
-    if compile_opt is None:
-        compile_opt = qset.compile
-    if not compile_opt['extra_import']:
-        try:
-            env = {"t": 0}
-            env.update(args)
-            exec(base, str_env, env)
-        except Exception as err:
-            raise Exception("Invalid string coefficient") from err
-    coeff = None
-    # Do we compile?
-    if not compile_opt['use_cython']:
-        return StrFunctionCoefficient(base, args)
-    # Parsing tries to make the code in common pattern
-    parsed, variables, constants, raw = try_parse(base, args,
-                                                  args_ctypes, compile_opt)
-    # Once parsed, the code should be unique enough to get a filename
-    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
-    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
-    # See if it already exist and import it.
-    if not compile_opt['recompile']:
-        coeff = try_import(file_name, parsed)
-
-    if not coeff and qset.coeff_write_ok:
-        # Previously compiled coefficient not available: create the cython code
-        code = make_cy_code(parsed, variables, constants,
-                            raw, compile_opt)
-        try :
-            coeff = compile_code(code, file_name, parsed, compile_opt)
-        except PermissionError:
-            pass
-    if coeff is None:
-        # We don't use cython or compilation failed
-        return StrFunctionCoefficient(base, args)
-    keys = [key for _, key, _ in variables]
-    const = [fromstr(val) for _, val, _ in constants]
-    return coeff(base, keys, const, args)
-
-
-coefficient_builders[str] = coeff_from_str
-
-
-def try_import(file_name, parsed_in):
-    """ Import the compiled coefficient if existing and check for
-    name collision.
-    """
-    try:
-        mod = importlib.import_module(file_name)
-    except ModuleNotFoundError:
-        # Coefficient does not exist, to compile as file_name
-        return None
-
-    if mod.parsed_code == parsed_in:
-        # Coefficient found!
-        return mod.StrCoefficient
-    else:
-        raise ValueError("string hash collision, change the string "
-                         "or clean files in qutip.settings.coeffroot")
-
-
-def make_cy_code(code, variables, constants, raw, compile_opt):
-    """
-    Generate the code for the string coefficients.
-    """
-    cdef_cte = ""
-    init_cte = ""
-    copy_cte = ""
-    for i, (name, val, ctype) in enumerate(constants):
-        cdef_cte += "        {} {}\n".format(ctype, name[5:])
-        copy_cte += "        out.{} = {}\n".format(name[5:], name)
-        init_cte += "        {} = cte[{}]\n".format(name, i)
-    cdef_var = ""
-    init_var = ""
-    init_arg = ""
-    replace_var = ""
-    call_var = ""
-    copy_var = ""
-    for i, (name, val, ctype) in enumerate(variables):
-        cdef_var += "        str key{}\n".format(i)
-        cdef_var += "        {} {}\n".format(ctype, name[5:])
-        copy_var += "        out.key{} = self.key{}\n".format(i, i)
-        copy_var += "        out.{} = {}\n".format(name[5:], name)
-        if not raw:
-            init_var += "        self.key{} = var[{}]\n".format(i, i)
-        else:
-            init_var += "        self.key{} = '{}'\n".format(i, val)
-        init_arg += "        {} = args[self.key{}]\n".format(name, i)
-        replace_var += "            if self.key{} in kwargs:\n".format(i)
-        replace_var += ("                out.{}"
-                        " = kwargs[self.key{}]\n".format(name[5:], i))
-        if raw:
-            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
-
-    code = f"""#cython: language_level=3
-# This file is generated automatically by QuTiP.
-
-import numpy as np
-import scipy.special as spe
-from scipy.special cimport cython_special
-cimport cython
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.cy.math cimport erf, zerf
-from qutip.core.cy.complex_math cimport *
-from qutip.core.data cimport Data
-cdef double pi = 3.14159265358979323
-{compile_opt['extra_import']}
-
-parsed_code = "{code}"
-
-@cython.auto_pickle(True)
-cdef class StrCoefficient(Coefficient):
-    \"\"\"
-    String compiled as a :obj:`Coefficient` using cython.
-    \"\"\"
-    cdef:
-        str codeString
-{cdef_cte}{cdef_var}
-
-    def __init__(self, base, var, cte, args):
-        self.codeString = base
-{init_cte}{init_var}{init_arg}
-
-    cpdef Coefficient copy(self):
-        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
-        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
-        out.codeString = self.codeString
-{copy_cte}{copy_var}
-        return out
-
-    def replace_arguments(self, _args=None, **kwargs):
-        \"\"\"
-        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
-        built from 'str' or a python function. Or a the :obj:`Coefficient`
-        itself if the :obj:`Coefficient` does not use arguments. New arguments
-        can be passed as a dict or as keywords.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        \"\"\"
-        cdef StrCoefficient out
-
-        if _args:
-            kwargs.update(_args)
-        if kwargs:
-            out = self.copy()
-{replace_var}
-            return out
-        return self
-
-    @cython.initializedcheck(False)
-    @cython.cdivision(True)
-    cdef complex _call(self, double t) except *:
-{call_var}        return {code}
-"""
-    return code
-
-
-def compile_code(code, file_name, parsed, c_opt):
-    pwd = os.getcwd()
-    os.chdir(qset.coeffroot)
-    # Files with the same name, but differents extension than the pyx file, are
-    # erased during cythonization process, breaking filelock.
-    # Adding a prefix make them safe to use.
-    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
-    try:
-        lock.acquire(timeout=0)
-        for file in glob.glob(file_name + "*"):
-            os.remove(file)
-        file_ = open(file_name + ".pyx", "w")
-        file_.writelines(code)
-        file_.close()
-        oldargs = sys.argv
-        try:
-            sys.argv = ["setup.py", "build_ext", "--inplace"]
-            coeff_file = Extension(
-                file_name,
-                sources=[file_name + ".pyx"],
-                extra_compile_args=c_opt['compiler_flags'].split(),
-                extra_link_args=c_opt['link_flags'].split(),
-                include_dirs=[np.get_include()],
-                language='c++'
-            )
-            ext_modules = cythonize(coeff_file, force=True)
-            setup(ext_modules=ext_modules)
-        except Exception as e:
-            if c_opt['clean_on_error']:
-                for file in glob.glob(file_name + "*"):
-                    os.remove(file)
-            raise Exception("Could not compile") from e
-        finally:
-            sys.argv = oldargs
-    except filelock.Timeout:
-        with lock:
-            # We wait for the lock to be released and then retry the import.
-            pass
-    finally:
-        lock.release()
-        os.chdir(pwd)
-    return try_import(file_name, parsed)
-
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
-# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-# Parsing here is extracting constants and args name to replace them with
-# attribute of the Coefficient so similar string like:
-# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
-# are all reconized as the same compiled object and only compiled once.
-# Weakness:
-#   typing: "1" and "1j" or the type of args ("w1") make different object
-#   complex: "1+1j" is seens as cte(double) + cte(complex)
-#   negative: "-1" is not seens as a constant but "- constant"
-#
-# int and double can be seens as complex with flags in CompilationOptions
-
-def fromstr(base):
-    """Read a varibles in a string"""
-    ls = {}
-    exec("out = " + base, {}, ls)
-    return ls["out"]
-
-
-typeCodes = {
-    "Data": "_datalayer",
-    "complex": "_cpl",
-    "double": "_dbl",
-    "int": "_int",
-    "str": "_str",
-    "object": "_obj"
-}
-
-
-def compileType(value):
-    """Obtain the index of typeCodes that correspond to the value
-    4.5 -> 'double'..."""
-    if isinstance(value, Data):
-        ctype = "Data"
-    elif isinstance(value, numbers.Integral):
-        ctype = "int"
-    elif isinstance(value, numbers.Real):
-        ctype = "double"
-    elif isinstance(value, numbers.Complex):
-        ctype = "complex"
-    elif isinstance(value, str):
-        ctype = "str"
-    else:
-        ctype = "object"
-    return ctype
-
-
-def find_type_from_str(chars):
-    """ '1j' -> complex """
-    try:
-        lc = {}
-        exec("out = " + chars, {}, lc)
-        return compileType(lc["out"])
-    except Exception:
-        return None
-
-
-def fix_type(ctype, accept_int, accept_float):
-    """int and double could be complex to limit the number of compiled object.
-    change the types is we choose not to support all.
-    """
-    if ctype == "int" and not accept_int:
-        ctype = "double"
-    if ctype == "double" and not accept_float:
-        ctype = "complex"
-    return ctype
-
-
-def extract_constant(code):
-    """Look for floating and complex constants and replace them with variable.
-    """
-    code = " " + code + " "
-    contants = []
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
-    code = extract_cte_pattern(code, contants,
-                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
-    return code, contants
-
-
-def extract_cte_pattern(code, constants, pattern):
-    """replace the constant following a pattern with variable"""
-    const_strs = re.findall(pattern, code)
-    for cte in const_strs:
-        name = " _cte_temp{}_ ".format(len(constants))
-        code = code.replace(cte, cte[0] + name, 1)
-        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
-    return code
-
-
-def space_parts(code, names):
-    """Force spacing: single space between element"""
-    for name in names:
-        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
-                      " " + name + " ", code)
-    code = " ".join(code.split())
-    return code
-
-
-def parse(code, args, compile_opt):
-    """
-    Read the code and rewrite it in a reutilisable form:
-    Ins:
-        '2.*cos(a*t)', {"a":5+1j}
-    Outs:
-        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
-        variables = [('self._arg_cpl0', 'a', 'complex')]
-        ordered_constants = [('self._cte_dbl0', 2, 'double')]
-    """
-    code, constants = extract_constant(code)
-    names = re.findall("[0-9a-zA-Z_]+", code)
-    code = space_parts(code, names)
-    constants_names = [const[0] for const in constants]
-    new_code = []
-    ordered_constants = []
-    variables = []
-    typeCounts = defaultdict(lambda: 0)
-    accept_int = compile_opt['accept_int']
-    accept_float = compile_opt['accept_float']
-    if accept_int is None:
-        # If there is a subscript: a[b] int are always accepted to be safe
-        # with TypeError
-        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
-    for word in code.split():
-        if word not in names:
-            # syntax
-            new_code.append(word)
-        elif word in args:
-            # find first if the variable is use more than once and reuse
-            var_name = [var_name for var_name, name, _ in variables
-                        if word == name]
-            if var_name:
-                var_name = var_name[0]
-            else:
-                ctype = compileType(args[word])
-                ctype = fix_type(ctype, accept_int, accept_float)
-                var_name = ("self._arg" + typeCodes[ctype] +
-                            str(typeCounts[ctype]))
-                typeCounts[ctype] += 1
-                variables.append((var_name, word, ctype))
-            new_code.append(var_name)
-        elif word in constants_names:
-            name, val, ctype = constants[int(word[9:-1])]
-            ctype = fix_type(ctype, accept_int, accept_float)
-            cte_name = "self._cte" + typeCodes[ctype] +\
-                       str(len(ordered_constants))
-            new_code.append(cte_name)
-            ordered_constants.append((cte_name, val, ctype))
-        else:
-            # Hopefully a buildin or known object
-            new_code.append(word)
-        code = " ".join(new_code)
-    return code, variables, ordered_constants
-
-
-def use_hinted_type(variables, code, args_ctypes):
-    variables_manually_typed = []
-    for i, (name, key, type_) in enumerate(variables):
-        if key in args_ctypes:
-            new_name = "self._custom_" + args_ctypes[key] + str(i)
-            code = code.replace(name, new_name)
-            variables_manually_typed.append((new_name, key, args_ctypes[key]))
-        else:
-            variables_manually_typed.append((name, key, type_))
-    return code, variables_manually_typed
-
-
-def try_parse(code, args, args_ctypes, compile_opt):
-    """
-    Try to parse and verify that the result is still usable.
-    """
-    if not compile_opt['try_parse']:
-        variables = [("self." + name, name, "object") for name in args
-                     if name in code]
-        code, variables = use_hinted_type(variables, code, args_ctypes)
-        return code, variables, [], True
-    ncode, variables, constants = parse(code, args, compile_opt)
-    if not compile_opt['static_types']:
-        # Fallback to object
-        variables = [(f, s, "object") for f, s, _ in variables]
-        constants = [(f, s, "object") for f, s, _ in constants]
-    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
-    if (
-        (compile_opt['extra_import']
-         and not compile_opt['extra_import'].isspace())
-        or test_parsed(ncode, variables, constants, args)
-    ):
-        return ncode, variables, constants, False
-    else:
-        warnings.warn("Could not find c types", StringParsingWarning)
-        remaped_variable = []
-        for _, name, ctype in variables:
-            remaped_variable.append(("self." + name, name, "object"))
-        return code, remaped_variable, [], True
-
-
-def test_parsed(code, variables, constants, args):
-    """
-    Test if parsed code broke anything.
-    """
-    class DummySelf:
-        pass
-    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
-    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
-    loc_env = {"t": 0, 'self': DummySelf}
-    try:
-        exec(code, str_env, loc_env)
-    except Exception as e:
-        return False
-    return True
+import numpy as np
+import scipy
+import scipy.interpolate
+import os
+import sys
+import re
+import dis
+import hashlib
+import glob
+import importlib
+import warnings
+import numbers
+from contextlib import contextmanager
+from collections import defaultdict
+from setuptools import setup, Extension
+try:
+    from Cython.Build import cythonize
+    import filelock
+except ImportError:
+    pass
+
+from ..settings import settings as qset
+from .options import QutipOptions
+from .data import Data
+from .cy.coefficient import (
+    Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
+    ConjCoefficient, NormCoefficient
+)
+
+
+__all__ = ["coefficient", "CompilationOptions", "Coefficient",
+           "clean_compiled_coefficient"]
+
+
+class StringParsingWarning(Warning):
+    pass
+
+
+def _return(base, **kwargs):
+    return base
+
+
+# The `coefficient` function is dispatcher for the type of the `base` to the
+# function that created the `Coefficient` object. `coefficient_builders` stores
+# the map `type -> function(base, **kw)`. Optional module can add their
+# `Coefficient` specializations here.
+coefficient_builders = {
+    Coefficient: _return,
+    np.ndarray: InterCoefficient,
+    scipy.interpolate.PPoly: InterCoefficient.from_PPoly,
+    scipy.interpolate.BSpline: InterCoefficient.from_Bspline,
+}
+
+
+def coefficient(base, *, tlist=None, args={}, args_ctypes={},
+                order=3, compile_opt=None, function_style=None,
+                boundary_conditions=None, **kwargs):
+    """Build ``Coefficient`` for time dependent systems:
+
+    ```
+    QobjEvo = Qobj + Qobj * Coefficient + Qobj * Coefficient + ...
+    ```
+
+    The coefficients can be a function, a string or a numpy array. Other
+    packages may add support for other kind of coefficients.
+
+    For function based coefficients, the function signature must be either:
+
+    * ``f(t, ...)`` where the other arguments are supplied as ordinary
+      "pythonic" arguments (e.g. ``f(t, w, a=5))
+    * ``f(t, args)`` where the arguments are supplied in a "dict" named
+      ``args``
+
+    By default the signature style is controlled by the
+    ``qutip.settings.core["function_coefficient_style"]`` setting, but it
+    may be overriden here by specifying either ``function_style="pythonic"``
+    or ``function_style="dict"``.
+
+    *Examples*
+        # pythonic style function signature
+
+        def f1_t(t, w):
+            return np.exp(-1j * t * w)
+
+        coeff1 = coefficient(f1_t, args={"w": 1.})
+
+        # dict style function signature
+
+        def f2_t(t, args):
+            return np.exp(-1j * t * args["w"])
+
+        coeff2 = coefficient(f2_t, args={"w": 1.})
+
+    For string based coeffients, the string must be a compilable python code
+    resulting in a complex. The following symbols are defined:
+        sin cos tan asin acos atan pi
+        sinh cosh tanh asinh acosh atanh
+        exp log log10 erf zerf sqrt
+        real imag conj abs norm arg proj
+        numpy as np,
+        scipy.special as spe (python interface)
+        and cython_special (scipy cython interface)
+
+    *Examples*
+        coeff = coefficient('exp(-1j*w1*t)', args={"w1":1.})
+    'args' is needed for string coefficient at compilation.
+    It is a dict of (name:object). The keys must be a valid variables string.
+
+    Compilation options can be passed as "compile_opt=CompilationOptions(...)".
+
+    For numpy array format, the array must be an 1d of dtype float or complex.
+    A list of times (float64) at which the coeffients must be given (tlist).
+    The coeffients array must have the same len as the tlist.
+    The time of the tlist do not need to be equidistant, but must be sorted.
+    By default, a cubic spline interpolation will be used to compute the
+    coefficient at time t. The keyword ``order`` sets the order of the
+    interpolation. When ``order = 0``, the interpolation is step function that
+    evaluates to the most recent value.
+
+    *Examples*
+        tlist = np.logspace(-5,0,100)
+        H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)
+
+    ``scipy.interpolate``'s ``CubicSpline``, ``PPoly`` and ``Bspline`` are
+    also converted to interpolated coefficients (the same kind of coefficient
+    created from ``ndarray``). Other interpolation methods from
+    scipy are converted to a function-based coefficient (the same kind of
+    coefficient created from callables).
+
+    Parameters
+    ----------
+    base : object
+        Base object to make into a Coefficient.
+
+    args : dict, optional
+        Dictionary of arguments to pass to the function or string coefficient.
+
+    order : int, default=3
+        Order of the spline for array based coefficient.
+
+    tlist : iterable, optional
+        Times for each element of an array based coefficient.
+
+    function_style : str, ["dict", "pythonic", None]
+        Function signature of function based coefficients.
+
+    args_ctypes : dict, optional
+        C type for the args when compiling array based coefficients.
+
+    compile_opt : CompilationOptions, optional
+        Sets of options for the compilation of string based coefficients.
+
+    boundary_conditions: 2-tupule, str or None, optional
+        Specify boundary conditions for spline interpolation.
+
+    **kwargs
+        Extra arguments to pass the the coefficients.
+    """
+    kwargs.update({
+        "tlist": tlist,
+        'args': args,
+        'args_ctypes': args_ctypes,
+        'order': order,
+        'compile_opt': compile_opt,
+        'function_style': function_style,
+        'boundary_conditions': boundary_conditions
+    })
+
+    for type_ in coefficient_builders:
+        if isinstance(base, type_):
+            return coefficient_builders[type_](base, **kwargs)
+
+    if callable(base):
+        op = FunctionCoefficient(base, args.copy(), style=function_style)
+        if not isinstance(op(0), numbers.Number):
+            raise TypeError("The coefficient function must return a number")
+        return op
+    else:
+        raise ValueError("coefficient format not understood")
+
+
+def norm(coeff):
+    """ return a Coefficient with is the norm: |c|^2.
+    """
+    return NormCoefficient(coeff)
+
+
+def conj(coeff):
+    """ return a Coefficient with is the conjugate.
+    """
+    return ConjCoefficient(coeff)
+
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+class CompilationOptions(QutipOptions):
+    """
+    Compilation options:
+
+    use_cython: bool
+        Whether to compile strings as cython code or use python's ``exec``.
+
+    try_parse: bool [True]
+        Whether to try parsing the string for reuse and static typing.
+
+    static_types : bool [True]
+        Whether to use C types for constant and args.
+
+    accept_int : None, bool
+        Whether to use the type ``int`` for integer constants and args or
+        upgrade it to ``float`` or ``complex``.
+        If `None`, it will only use ``int`` when subscription is found in the
+        code.
+
+    accept_float : bool
+        Whether to use the type ``float`` or upgrade them to ``complex``.
+
+    recompile : bool
+        Do not use previously made files but build a new one.
+
+    compiler_flags : str
+        Flags to pass to the compiler, ex: "-Wall -O3"...
+        Flags not matching your comiler and OS may cause compilation to fail.
+        Use "recompile=True", when trying to if the string pattern was
+        previously used.
+
+    link_flags : str
+        Libraries to link to pass to the compiler. They can not be used to add
+        function to the string coefficient.
+
+    extra_import : str
+        Cython code to add at the head of the file. Can be used to add extra
+        import or cimport code, ex:
+        extra_import="from scipy.linalg import det"
+        extra_import="from qutip.core.data cimport CSR"
+
+    clean_on_error : bool [True]
+        When writing a cython file that cannot be imported, erase it.
+    """
+    _link_flags = ""
+    _compiler_flags = ""
+    if sys.platform == 'win32':
+        _compiler_flags = ''
+    elif sys.platform == 'darwin':
+        _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'
+        _link_flags += '-mmacosx-version-min=10.9'
+    else:
+        _compiler_flags = '-w -O3 -funroll-loops'
+
+    try:
+        import cython
+        import filelock
+        _use_cython = True
+    except ImportError:
+        _use_cython = False
+
+    _options = {
+        "use_cython": _use_cython,
+        "try_parse": True,
+        "static_types": True,
+        "accept_int": None,
+        "accept_float": True,
+        "recompile": False,
+        "compiler_flags": _compiler_flags,
+        "link_flags": _link_flags,
+        "extra_import": "",
+        "clean_on_error": True,
+    }
+    _settings_name = "compile"
+
+
+# Create the default instance in settings.
+qset.compile = CompilationOptions()
+
+
+# Version number of the Coefficient
+COEFF_VERSION = "1.1"
+
+try:
+    root = os.path.join(qset.tmproot, f"qutip_coeffs_{COEFF_VERSION}")
+    qset.coeffroot = root
+except OSError:
+    qset.coeffroot = "."
+
+
+def clean_compiled_coefficient(all=False):
+    """
+    Remove previouly compiled string Coefficient.
+
+    Parameter:
+    ----------
+    all: bool
+        If not `all` will remove only previous version.
+    """
+    import glob
+    import shutil
+    tmproot = qset.tmproot
+    root = os.path.join(tmproot, f'qutip_coeffs_{COEFF_VERSION}')
+    folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + "*")
+    for folder in folders:
+        if all or folder != root:
+            shutil.rmtree(folder)
+    # Recreate the empty folder.
+    qset.coeffroot = qset.coeffroot
+
+
+def proj(x):
+    if np.isfinite(x):
+        return (x)
+    else:
+        return np.inf + 0j * np.imag(x)
+
+
+str_env = {
+    "sin": np.sin,
+    "cos": np.cos,
+    "tan": np.tan,
+    "asin": np.arcsin,
+    "acos": np.arccos,
+    "atan": np.arctan,
+    "pi": np.pi,
+    "sinh": np.sinh,
+    "cosh": np.cosh,
+    "tanh": np.tanh,
+    "asinh": np.arcsinh,
+    "acosh": np.arccosh,
+    "atanh": np.arctanh,
+    "exp": np.exp,
+    "log": np.log,
+    "log10": np.log10,
+    "erf": scipy.special.erf,
+    "zerf": scipy.special.erf,
+    "sqrt": np.sqrt,
+    "real": np.real,
+    "imag": np.imag,
+    "conj": np.conj,
+    "abs": np.abs,
+    "norm": lambda x: np.abs(x)**2,
+    "arg": np.angle,
+    "proj": proj,
+    "np": np,
+    "spe": scipy.special}
+
+
+def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
+    """
+    Entry point for string based coefficients
+    - Test if the string is valid
+    - Parse: "cos(a*t)" and "cos( w1 * t )"
+        should be recognised as the same compiled object.
+    - Verify if already compiled and compile if not
+    """
+    # First, a sanity check before thinking of compiling
+    if compile_opt is None:
+        compile_opt = qset.compile
+    if not compile_opt['extra_import']:
+        try:
+            env = {"t": 0}
+            env.update(args)
+            exec(base, str_env, env)
+        except Exception as err:
+            raise Exception("Invalid string coefficient") from err
+    coeff = None
+    # Do we compile?
+    if not compile_opt['use_cython']:
+        return StrFunctionCoefficient(base, args)
+    # Parsing tries to make the code in common pattern
+    parsed, variables, constants, raw = try_parse(base, args,
+                                                  args_ctypes, compile_opt)
+    # Once parsed, the code should be unique enough to get a filename
+    hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))
+    file_name = "qtcoeff_" + hash_.hexdigest()[:30]
+    # See if it already exist and import it.
+    if not compile_opt['recompile']:
+        coeff = try_import(file_name, parsed)
+
+    if not coeff and qset.coeff_write_ok:
+        # Previously compiled coefficient not available: create the cython code
+        code = make_cy_code(parsed, variables, constants,
+                            raw, compile_opt)
+        try :
+            coeff = compile_code(code, file_name, parsed, compile_opt)
+        except PermissionError:
+            pass
+    if coeff is None:
+        # We don't use cython or compilation failed
+        return StrFunctionCoefficient(base, args)
+    keys = [key for _, key, _ in variables]
+    const = [fromstr(val) for _, val, _ in constants]
+    return coeff(base, keys, const, args)
+
+
+coefficient_builders[str] = coeff_from_str
+
+
+def try_import(file_name, parsed_in):
+    """ Import the compiled coefficient if existing and check for
+    name collision.
+    """
+    try:
+        mod = importlib.import_module(file_name)
+    except ModuleNotFoundError:
+        # Coefficient does not exist, to compile as file_name
+        return None
+
+    if mod.parsed_code == parsed_in:
+        # Coefficient found!
+        return mod.StrCoefficient
+    else:
+        raise ValueError("string hash collision, change the string "
+                         "or clean files in qutip.settings.coeffroot")
+
+
+def make_cy_code(code, variables, constants, raw, compile_opt):
+    """
+    Generate the code for the string coefficients.
+    """
+    cdef_cte = ""
+    init_cte = ""
+    copy_cte = ""
+    for i, (name, val, ctype) in enumerate(constants):
+        cdef_cte += "        {} {}\n".format(ctype, name[5:])
+        copy_cte += "        out.{} = {}\n".format(name[5:], name)
+        init_cte += "        {} = cte[{}]\n".format(name, i)
+    cdef_var = ""
+    init_var = ""
+    init_arg = ""
+    replace_var = ""
+    call_var = ""
+    copy_var = ""
+    for i, (name, val, ctype) in enumerate(variables):
+        cdef_var += "        str key{}\n".format(i)
+        cdef_var += "        {} {}\n".format(ctype, name[5:])
+        copy_var += "        out.key{} = self.key{}\n".format(i, i)
+        copy_var += "        out.{} = {}\n".format(name[5:], name)
+        if not raw:
+            init_var += "        self.key{} = var[{}]\n".format(i, i)
+        else:
+            init_var += "        self.key{} = '{}'\n".format(i, val)
+        init_arg += "        {} = args[self.key{}]\n".format(name, i)
+        replace_var += "            if self.key{} in kwargs:\n".format(i)
+        replace_var += ("                out.{}"
+                        " = kwargs[self.key{}]\n".format(name[5:], i))
+        if raw:
+            call_var += "        cdef {} {} = {}\n".format(ctype, val, name)
+
+    code = f"""#cython: language_level=3
+# This file is generated automatically by QuTiP.
+
+import numpy as np
+import scipy.special as spe
+from scipy.special cimport cython_special
+cimport cython
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.cy.math cimport erf, zerf
+from qutip.core.cy.complex_math cimport *
+from qutip.core.data cimport Data
+cdef double pi = 3.14159265358979323
+{compile_opt['extra_import']}
+
+parsed_code = "{code}"
+
+@cython.auto_pickle(True)
+cdef class StrCoefficient(Coefficient):
+    \"\"\"
+    String compiled as a :obj:`Coefficient` using cython.
+    \"\"\"
+    cdef:
+        str codeString
+{cdef_cte}{cdef_var}
+
+    def __init__(self, base, var, cte, args):
+        self.codeString = base
+{init_cte}{init_var}{init_arg}
+
+    cpdef Coefficient copy(self):
+        \"\"\"Return a copy of the :obj:`Coefficient`.\"\"\"
+        cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)
+        out.codeString = self.codeString
+{copy_cte}{copy_var}
+        return out
+
+    def replace_arguments(self, _args=None, **kwargs):
+        \"\"\"
+        Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`
+        built from 'str' or a python function. Or a the :obj:`Coefficient`
+        itself if the :obj:`Coefficient` does not use arguments. New arguments
+        can be passed as a dict or as keywords.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        \"\"\"
+        cdef StrCoefficient out
+
+        if _args:
+            kwargs.update(_args)
+        if kwargs:
+            out = self.copy()
+{replace_var}
+            return out
+        return self
+
+    @cython.initializedcheck(False)
+    @cython.cdivision(True)
+    cdef complex _call(self, double t) except *:
+{call_var}        return {code}
+"""
+    return code
+
+
+def compile_code(code, file_name, parsed, c_opt):
+    pwd = os.getcwd()
+    os.chdir(qset.coeffroot)
+    # Files with the same name, but differents extension than the pyx file, are
+    # erased during cythonization process, breaking filelock.
+    # Adding a prefix make them safe to use.
+    lock = filelock.FileLock("compile_lock_" + file_name + ".lock")
+    try:
+        lock.acquire(timeout=0)
+        for file in glob.glob(file_name + "*"):
+            os.remove(file)
+        file_ = open(file_name + ".pyx", "w")
+        file_.writelines(code)
+        file_.close()
+        oldargs = sys.argv
+        try:
+            sys.argv = ["setup.py", "build_ext", "--inplace"]
+            coeff_file = Extension(
+                file_name,
+                sources=[file_name + ".pyx"],
+                extra_compile_args=c_opt['compiler_flags'].split(),
+                extra_link_args=c_opt['link_flags'].split(),
+                include_dirs=[np.get_include()],
+                language='c++'
+            )
+            ext_modules = cythonize(coeff_file, force=True)
+            setup(ext_modules=ext_modules)
+        except Exception as e:
+            if c_opt['clean_on_error']:
+                for file in glob.glob(file_name + "*"):
+                    os.remove(file)
+            raise Exception("Could not compile") from e
+        finally:
+            sys.argv = oldargs
+    except filelock.Timeout:
+        with lock:
+            # We wait for the lock to be released and then retry the import.
+            pass
+    finally:
+        lock.release()
+        os.chdir(pwd)
+    return try_import(file_name, parsed)
+
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# %%%%%%%%%        Everything under this is for parsing string        %%%%%%%%%
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# Parsing here is extracting constants and args name to replace them with
+# attribute of the Coefficient so similar string like:
+# "2.*cos(a*t)", "5.2 * cos(w1 *t)", "5 * cos(w3 * t)"
+# are all reconized as the same compiled object and only compiled once.
+# Weakness:
+#   typing: "1" and "1j" or the type of args ("w1") make different object
+#   complex: "1+1j" is seens as cte(double) + cte(complex)
+#   negative: "-1" is not seens as a constant but "- constant"
+#
+# int and double can be seens as complex with flags in CompilationOptions
+
+def fromstr(base):
+    """Read a varibles in a string"""
+    ls = {}
+    exec("out = " + base, {}, ls)
+    return ls["out"]
+
+
+typeCodes = {
+    "Data": "_datalayer",
+    "complex": "_cpl",
+    "double": "_dbl",
+    "int": "_int",
+    "str": "_str",
+    "object": "_obj"
+}
+
+
+def compileType(value):
+    """Obtain the index of typeCodes that correspond to the value
+    4.5 -> 'double'..."""
+    if isinstance(value, Data):
+        ctype = "Data"
+    elif isinstance(value, numbers.Integral):
+        ctype = "int"
+    elif isinstance(value, numbers.Real):
+        ctype = "double"
+    elif isinstance(value, numbers.Complex):
+        ctype = "complex"
+    elif isinstance(value, str):
+        ctype = "str"
+    else:
+        ctype = "object"
+    return ctype
+
+
+def find_type_from_str(chars):
+    """ '1j' -> complex """
+    try:
+        lc = {}
+        exec("out = " + chars, {}, lc)
+        return compileType(lc["out"])
+    except Exception:
+        return None
+
+
+def fix_type(ctype, accept_int, accept_float):
+    """int and double could be complex to limit the number of compiled object.
+    change the types is we choose not to support all.
+    """
+    if ctype == "int" and not accept_int:
+        ctype = "double"
+    if ctype == "double" and not accept_float:
+        ctype = "complex"
+    return ctype
+
+
+def extract_constant(code):
+    """Look for floating and complex constants and replace them with variable.
+    """
+    code = " " + code + " "
+    contants = []
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?")
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?")
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?")
+    code = extract_cte_pattern(code, contants,
+                               "[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?")
+    return code, contants
+
+
+def extract_cte_pattern(code, constants, pattern):
+    """replace the constant following a pattern with variable"""
+    const_strs = re.findall(pattern, code)
+    for cte in const_strs:
+        name = " _cte_temp{}_ ".format(len(constants))
+        code = code.replace(cte, cte[0] + name, 1)
+        constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))
+    return code
+
+
+def space_parts(code, names):
+    """Force spacing: single space between element"""
+    for name in names:
+        code = re.sub("(?<=[^0-9a-zA-Z_])" + name + "(?=[^0-9a-zA-Z_])",
+                      " " + name + " ", code)
+    code = " ".join(code.split())
+    return code
+
+
+def parse(code, args, compile_opt):
+    """
+    Read the code and rewrite it in a reutilisable form:
+    Ins:
+        '2.*cos(a*t)', {"a":5+1j}
+    Outs:
+        code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'
+        variables = [('self._arg_cpl0', 'a', 'complex')]
+        ordered_constants = [('self._cte_dbl0', 2, 'double')]
+    """
+    code, constants = extract_constant(code)
+    names = re.findall("[0-9a-zA-Z_]+", code)
+    code = space_parts(code, names)
+    constants_names = [const[0] for const in constants]
+    new_code = []
+    ordered_constants = []
+    variables = []
+    typeCounts = defaultdict(lambda: 0)
+    accept_int = compile_opt['accept_int']
+    accept_float = compile_opt['accept_float']
+    if accept_int is None:
+        # If there is a subscript: a[b] int are always accepted to be safe
+        # with TypeError
+        accept_int = "SUBSCR" in dis.Bytecode(code).dis()
+    for word in code.split():
+        if word not in names:
+            # syntax
+            new_code.append(word)
+        elif word in args:
+            # find first if the variable is use more than once and reuse
+            var_name = [var_name for var_name, name, _ in variables
+                        if word == name]
+            if var_name:
+                var_name = var_name[0]
+            else:
+                ctype = compileType(args[word])
+                ctype = fix_type(ctype, accept_int, accept_float)
+                var_name = ("self._arg" + typeCodes[ctype] +
+                            str(typeCounts[ctype]))
+                typeCounts[ctype] += 1
+                variables.append((var_name, word, ctype))
+            new_code.append(var_name)
+        elif word in constants_names:
+            name, val, ctype = constants[int(word[9:-1])]
+            ctype = fix_type(ctype, accept_int, accept_float)
+            cte_name = "self._cte" + typeCodes[ctype] +\
+                       str(len(ordered_constants))
+            new_code.append(cte_name)
+            ordered_constants.append((cte_name, val, ctype))
+        else:
+            # Hopefully a buildin or known object
+            new_code.append(word)
+        code = " ".join(new_code)
+    return code, variables, ordered_constants
+
+
+def use_hinted_type(variables, code, args_ctypes):
+    variables_manually_typed = []
+    for i, (name, key, type_) in enumerate(variables):
+        if key in args_ctypes:
+            new_name = "self._custom_" + args_ctypes[key] + str(i)
+            code = code.replace(name, new_name)
+            variables_manually_typed.append((new_name, key, args_ctypes[key]))
+        else:
+            variables_manually_typed.append((name, key, type_))
+    return code, variables_manually_typed
+
+
+def try_parse(code, args, args_ctypes, compile_opt):
+    """
+    Try to parse and verify that the result is still usable.
+    """
+    if not compile_opt['try_parse']:
+        variables = [("self." + name, name, "object") for name in args
+                     if name in code]
+        code, variables = use_hinted_type(variables, code, args_ctypes)
+        return code, variables, [], True
+    ncode, variables, constants = parse(code, args, compile_opt)
+    if not compile_opt['static_types']:
+        # Fallback to object
+        variables = [(f, s, "object") for f, s, _ in variables]
+        constants = [(f, s, "object") for f, s, _ in constants]
+    ncode, variables = use_hinted_type(variables, ncode, args_ctypes)
+    if (
+        (compile_opt['extra_import']
+         and not compile_opt['extra_import'].isspace())
+        or test_parsed(ncode, variables, constants, args)
+    ):
+        return ncode, variables, constants, False
+    else:
+        warnings.warn("Could not find c types", StringParsingWarning)
+        remaped_variable = []
+        for _, name, ctype in variables:
+            remaped_variable.append(("self." + name, name, "object"))
+        return code, remaped_variable, [], True
+
+
+def test_parsed(code, variables, constants, args):
+    """
+    Test if parsed code broke anything.
+    """
+    class DummySelf:
+        pass
+    [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]
+    [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]
+    loc_env = {"t": 0, 'self': DummySelf}
+    try:
+        exec(code, str_env, loc_env)
+    except Exception as e:
+        return False
+    return True
diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
index 55c6c84714..46f869b266 100644
--- a/qutip/core/cy/_element.pxd
+++ b/qutip/core/cy/_element.pxd
@@ -1,42 +1,42 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense, Data
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.data.base cimport idxint
-from libcpp cimport bool
-
-cdef class _BaseElement:
-    cpdef Data data(self, t)
-    cpdef object qobj(self, t)
-    cpdef object coeff(self, t)
-    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
-
-
-cdef class _ConstantElement(_BaseElement):
-    cdef readonly object _qobj
-
-
-cdef class _EvoElement(_BaseElement):
-    cdef readonly object _qobj
-    cdef readonly Coefficient _coefficient
-
-
-cdef class _FuncElement(_BaseElement):
-    cdef readonly object _func
-    cdef readonly dict _args
-    cdef readonly tuple _previous
-    cdef readonly bint _f_pythonic
-    cdef readonly set _f_parameters
-
-
-cdef class _MapElement(_BaseElement):
-    cdef readonly _FuncElement _base
-    cdef readonly list _transform
-    cdef readonly double complex _coeff
-
-
-cdef class _ProdElement(_BaseElement):
-    cdef readonly _BaseElement _left
-    cdef readonly _BaseElement _right
-    cdef readonly list _transform
-    cdef readonly bool _conj
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense, Data
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.data.base cimport idxint
+from libcpp cimport bool
+
+cdef class _BaseElement:
+    cpdef Data data(self, t)
+    cpdef object qobj(self, t)
+    cpdef object coeff(self, t)
+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=?)
+
+
+cdef class _ConstantElement(_BaseElement):
+    cdef readonly object _qobj
+
+
+cdef class _EvoElement(_BaseElement):
+    cdef readonly object _qobj
+    cdef readonly Coefficient _coefficient
+
+
+cdef class _FuncElement(_BaseElement):
+    cdef readonly object _func
+    cdef readonly dict _args
+    cdef readonly tuple _previous
+    cdef readonly bint _f_pythonic
+    cdef readonly set _f_parameters
+
+
+cdef class _MapElement(_BaseElement):
+    cdef readonly _FuncElement _base
+    cdef readonly list _transform
+    cdef readonly double complex _coeff
+
+
+cdef class _ProdElement(_BaseElement):
+    cdef readonly _BaseElement _left
+    cdef readonly _BaseElement _right
+    cdef readonly list _transform
+    cdef readonly bool _conj
diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
index a845b63d5f..999d51d06d 100644
--- a/qutip/core/cy/_element.pyx
+++ b/qutip/core/cy/_element.pyx
@@ -1,625 +1,625 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
-
-from .. import data as _data
-from qutip.core.cy.coefficient import coefficient_function_parameters
-from qutip.core.data cimport Dense, Data, dense
-from qutip.core.data.matmul cimport *
-from math import nan as Nan
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-__all__ = ['_ConstantElement', '_EvoElement',
-           '_FuncElement', '_MapElement', '_ProdElement']
-
-
-cdef class _BaseElement:
-    """
-    The representation of a single time-dependent term in the list of
-    terms used by QobjEvo and solvers to describe operators.
-
-    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
-    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
-    are functions of time. :meth:`~_BaseElement.coeff` returns the
-    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
-
-    For example, a :obj:`QobjEvo` instance created by::
-
-      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
-
-    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
-    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
-
-    :obj:`~_BaseElement` defines the interface to time-dependent terms.
-    Sub-classes implement terms defined in different ways.
-    For example, :obj:`~_ConstantElement` implements a term that
-    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
-    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
-    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
-    so on.
-
-    .. note::
-
-      There are three methods to return the factors of the term.
-
-      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
-      coefficient and operator factors respectively. They are separate to
-      avoid constructing an intermediate Python object when called from
-      Cython code (which may take as long as the rest of the call).
-
-      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
-      provides a convenience method for this common operation.
-
-    .. note::
-
-      All :obj:`~_BaseElement` instances are immutable and methods that would
-      modify an object return a new instance instead.
-    """
-    cpdef Data data(self, t):
-        """
-        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
-        of the term at time ``t``.
-
-        Parameters
-        ----------
-        t : double
-          The time, ``t``.
-
-        Returns
-        -------
-        :obj:`~Data`
-          The underlying data of the :obj:`~Qobj` component of the term
-          at time ``t``.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .data(t)."
-        )
-
-    cpdef object qobj(self, t):
-        """
-        Returns the :obj:`~Qobj` component of the term at time ``t``.
-
-        Parameters
-        ----------
-        t : float
-          The time, ``t``.
-
-        Returns
-        -------
-        :obj:`~Qobj`
-          The :obj:`~Qobj` component of the term at time ``t``.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .qobj(t)."
-        )
-
-    cpdef object coeff(self, t):
-        """
-        Returns the complex coefficient of the term at time ``t``.
-
-        Parameters
-        ----------
-        t : float
-          The time, ``t``.
-
-        Returns
-        -------
-        complex
-          The complex coefficient of the term at time ``t``.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .coeff(t)."
-        )
-
-    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
-        """
-        Possibly in-place multiplication and addition. Multiplies a given state
-        by the elemen's value at time ``t`` and adds the result to ``out``.
-        Equivalent to::
-
-          out += self.coeff(t) * self.qobj(t) @ state
-
-        Sub-classes may override :meth:`~matmul_data_t` to provide an more
-        efficient implementation.
-
-        Parameters
-        ----------
-        t : double
-          The time, ``t``.
-
-        state : :obj:`~Data`
-          The state to multiply by the element term.
-
-        out : :obj:`~Data` or ``NULL``
-          The output to add the result of the multiplication to. If ``NULL``,
-          the result of the multiplication is returned directly (i.e. ``out``
-          is assumed to be the zero matrix).
-
-        Returns
-        -------
-        data
-          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
-          the addition possibly having been performed in-place on ``out``.
-
-        .. note::
-
-          Because of the possibly but not definitely in-place behaviour of
-          this function, the result should always be assigned to some variable
-          and surrounding code should assume that ``out`` maybe have been
-          modified and that the result may be a reference to ``out``. The
-          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
-
-        .. note::
-
-          This method would ideally be implemented using a special
-          function dispatched by the data layer so that it did not have to
-          special case the ``Dense`` operation itself, but the data layer
-          dispatch does not yet support in-place operations. Once it does
-          this method should be updated to use the new support.
-        """
-        if out is None:
-            return _data.matmul(self.data(t), state, self.coeff(t))
-        elif type(state) is Dense and type(out) is Dense:
-            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
-            return out
-        else:
-            return _data.add(
-                out,
-                _data.matmul(self.data(t), state, self.coeff(t))
-            )
-
-    def linear_map(self, f, anti=False):
-        """
-        Return a new element representing a linear transformation ``f``
-        of the :obj:`~Qobj` portion of this element and possibly a
-        complex conjucation of the coefficient portion (when ``f`` is an
-        antilinear map).
-
-        If this element represents ``coeff * qobj`` the returned element
-        represents ``coeff * f(obj)`` (if ``anti=False``) or
-        ``conj(coeff) * f(obj)`` (if ``anti=True``).
-
-        Parameters
-        ----------
-        f : function
-          The linear transformation to apply to the :obj:`~Qobj` of this
-          element.
-        anti : bool
-          Whether to take the complex conjugate of the coefficient. Default
-          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
-          map such as the adjoint (i.e. dagger).
-
-        Returns
-        -------
-        _BaseElement
-          A new element with the transformation applied.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .linear_map(t)."
-        )
-
-    def replace_arguments(self, args, cache=None):
-        """
-        Return a copy of the element with the (possible) additional arguments
-        to any time-dependent functions updated to the given argument values.
-        The arguments of any contained :obj:`~Coefficient` instances are also
-        replaced.
-
-        If the operation does not modify this element, the original element
-        may be returned.
-
-        Parameters
-        ----------
-        args : dict
-          A dictionary of arguments to update. Keys are the names of the
-          arguments and values are the new argument values. Arguments
-          not included retain their original values.
-
-        cache : list or ``None``
-          A cache to add updated elements to. Unmodified elements are not
-          added to the cache. If a cache is supplied and ``.replace_arguments``
-          would be called again on the same element with the same arguments,
-          the new element from the cache will be returned instead.
-
-          By default the cache is ``None`` and no caching is performed. Cache
-          users should supply either ``cache=[]`` (which activates caching)
-          or an existing cache (for example, if making calls on sub-elements
-          of some composite element).
-
-        Returns
-        -------
-        _BaseElement
-          A new element with the arguments replaced, or possibly this element
-          if it would not be modified.
-
-        Example
-        -------
-
-        If ``elem`` is a product element for ``op * op.dag()`` it will contain
-        two references to the same element for ``op``. Calling::
-
-          elem = elem.replace_arguments({"theta": 3.1416})
-
-        will return a new element that contains two *different* copies of
-        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
-        to be evaluated *twice* when ``elem.qobj(t)`` is called.
-
-        Calling instead::
-
-          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
-
-        will return a new element that contains two references to *one* copy
-        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
-        performance when calling ``elem.qobj(t)`` later.
-        """
-        raise NotImplementedError(
-          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
-        )
-
-    def __call__(self, t, args=None):
-        if args:
-            cache = []
-            self = self.replace_arguments(args, cache)
-        return self.qobj(t) * self.coeff(t)
-
-
-cdef class _ConstantElement(_BaseElement):
-    """
-    Constant part of a list format :obj:`QobjEvo`.
-    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
-
-      qevo = QobjEvo(H0)
-      qevo.elements = [_ConstantElement(H0)]
-    """
-    def __init__(self, qobj):
-        self._qobj = qobj
-
-    def __mul__(left, right):
-        if type(left) is _ConstantElement:
-            return _ConstantElement((<_ConstantElement> left)._qobj * right)
-        elif type(right) is _ConstantElement:
-            return _ConstantElement((<_ConstantElement> right)._qobj * left)
-        return NotImplemented
-
-    def __matmul__(left, right):
-        if type(left) is _ConstantElement and type(right) is _ConstantElement:
-            return _ConstantElement(
-                (<_ConstantElement> left)._qobj @
-                (<_ConstantElement> right)._qobj
-            )
-        return NotImplemented
-
-    cpdef Data data(self, t):
-        return self._qobj.data
-
-    cpdef object qobj(self, t):
-        return self._qobj
-
-    cpdef object coeff(self, t):
-        return 1.
-
-    def linear_map(self, f, anti=False):
-        return _ConstantElement(f(self._qobj))
-
-    def replace_arguments(self, args, cache=None):
-        return self
-
-    def __call__(self, t, args=None):
-        return self._qobj
-
-
-cdef class _EvoElement(_BaseElement):
-    """
-    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
-    time-dependent operator::
-
-      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
-      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
-    """
-    def __init__(self, qobj, coefficient):
-        self._qobj = qobj
-        self._coefficient = coefficient
-
-    def __mul__(left, right):
-        cdef _EvoElement base
-        cdef object factor
-        if type(left) is _EvoElement:
-            base = left
-            factor = right
-        if type(right) is _EvoElement:
-            base = right
-            factor = left
-        return _EvoElement(base._qobj * factor, base._coefficient)
-
-    def __matmul__(left, right):
-        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
-            coefficient = left._coefficient * right._coefficient
-        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
-            coefficient = left._coefficient
-        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
-            coefficient = right._coefficient
-        else:
-            return NotImplemented
-        return _EvoElement(left._qobj * right._qobj, coefficient)
-
-    cpdef Data data(self, t):
-        return self._qobj.data
-
-    cpdef object qobj(self, t):
-        return self._qobj
-
-    cpdef object coeff(self, t):
-        return self._coefficient(t)
-
-    def linear_map(self, f, anti=False):
-        return _EvoElement(
-            f(self._qobj),
-            self._coefficient.conj() if anti else self._coefficient,
-        )
-
-    def replace_arguments(self, args, cache=None):
-        return _EvoElement(
-            self._qobj.copy(),
-            self._coefficient.replace_arguments(args)
-        )
-
-
-cdef class _FuncElement(_BaseElement):
-    """
-    Used with :obj:`QobjEvo` to build an evolution term from a function with
-    either the signature: ::
-
-        func(t: float, ...) -> Qobj
-
-    or the older QuTiP 4 style signature: ::
-
-        func(t: float, args: dict) -> Qobj
-
-    In the new style, ``func`` may accept arbitrary named arguments and
-    is called as ``func(t, **args)``.
-
-    A :obj:`QobjEvo` created from such a function contains one
-    :obj:`_FuncElement`: ::
-
-        qevo = QobjEvo(func, args=args)
-        qevo.elements = [_FuncElement(func, args)]
-
-    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
-    of function and argument.
-
-    This class has a basic capacity to memoize calls to ``func`` by saving the
-    result of the last call ::
-
-        op = QobjEvo(func, args=args)
-        (op.dag() * op)(t)
-
-    calls ``func`` only once.
-
-    Parameters
-    ----------
-    func : callable(t : float, ...) -> Qobj
-        Function returning the element value at time ``t``.
-
-    args : dict
-        Values of the arguments to pass to ``func``.
-
-    style : {None, "pythonic", "dict", "auto"}
-        The style of the signature used. If style is ``None``,
-        the value of ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
-    style and parameter detection and are not intended to be part of
-    the public interface.
-    """
-
-    _UNSET = object()
-
-    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
-        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
-            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
-                raise TypeError(
-                    "_f_pythonic and _f_parameters should always be given together."
-                )
-            _f_pythonic, _f_parameters = coefficient_function_parameters(
-                func, style=style)
-            if _f_parameters is not None:
-                args = {k: args[k] for k in _f_parameters & args.keys()}
-            else:
-                args = args.copy()
-        self._func = func
-        self._args = args
-        self._f_pythonic = _f_pythonic
-        self._f_parameters = _f_parameters
-        self._previous = (Nan, None)
-
-    def __mul__(left, right):
-        cdef _MapElement out
-        if type(left) is _FuncElement:
-            out = _MapElement(left, [], right)
-        if type(right) is _FuncElement:
-            out = _MapElement(right, [], left)
-        return out
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    cpdef Data data(self, t):
-        return self.qobj(t).data
-
-    cpdef object qobj(self, t):
-        cdef double _t
-        cdef object _qobj
-        _t, _qobj = self._previous
-        if t == _t:
-            return _qobj
-        if self._f_pythonic:
-            _qobj = self._func(t, **self._args)
-        else:
-            _qobj = self._func(t, self._args)
-        self._previous = (t, _qobj)
-        return _qobj
-
-    cpdef object coeff(self, t):
-        return 1.
-
-    def linear_map(self, f, anti=False):
-        return _MapElement(self, [f])
-
-    def replace_arguments(_FuncElement self, args, cache=None):
-        if self._f_parameters is not None:
-            args = {k: args[k] for k in self._f_parameters & args.keys()}
-        if not args:
-            return self
-        if cache is not None:
-            for old, new in cache:
-                if old is self:
-                    return new
-        new = _FuncElement(
-                self._func,
-                {**self._args, **args},
-                _f_pythonic=self._f_pythonic,
-                _f_parameters=self._f_parameters,
-        )
-        if cache is not None:
-            cache.append((self, new))
-        return new
-
-
-cdef class _MapElement(_BaseElement):
-    """
-    :obj:`_FuncElement` decorated with linear tranformations.
-
-    Linear tranformations available in :obj:`QobjEvo` include transpose,
-    adjoint, conjugate, convertion and product with number::
-    ```
-        op = QobjEvo(f, args=args)
-        op2 = op.conj().dag() * 2
-    ```
-    Then ``op2.elements`` is::
-        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
-
-    """
-    def __init__(self, _FuncElement base, transform, coeff=1.):
-        self._base = base
-        self._transform = transform
-        self._coeff = coeff
-
-    def __mul__(left, right):
-        cdef _MapElement out, self
-        cdef double complex factor
-        if type(left) is _MapElement:
-            self = left
-            factor = right
-        elif type(right) is _MapElement:
-            self = right
-            factor = left
-        return _MapElement(
-            self._base,
-            self._transform.copy(),
-            self._coeff*factor
-        )
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    cpdef Data data(self, t):
-        return self.qobj(t).data
-
-    cpdef object qobj(self, t):
-        out = self._base.qobj(t)
-        for func in self._transform:
-            out = func(out)
-        return out
-
-    cpdef object coeff(self, t):
-        return self._coeff
-
-    def linear_map(self, f, anti=False):
-        return _MapElement(
-            self._base,
-            self._transform + [f],
-            conj(self._coeff) if anti else self._coeff
-        )
-
-    def replace_arguments(_MapElement self, args, cache=None):
-        return _MapElement(
-            self._base.replace_arguments(args, cache=cache),
-            self._transform.copy(),
-            self._coeff,
-        )
-
-
-cdef class _ProdElement(_BaseElement):
-    """
-    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
-    :obj:`_BaseElement`. Include a stack of linear transformation to be
-    applied after the product::
-
-        ``op = QobjEvo(f) * qobj1``
-    Then ``op.elements`` is::
-        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
-    """
-    def __init__(self, left, right, transform, conj=False):
-        self._left = left
-        self._right = right
-        self._conj = conj
-        self._transform = transform
-
-    def __mul__(left, right):
-        cdef _ProdElement self
-        cdef double complex factor
-        if type(left) is _ProdElement:
-            self = left
-            factor = right
-        if type(right) is _ProdElement:
-            self = right
-            factor = left
-        return _ProdElement(self._left, self._right * factor,
-                            self._transform.copy(), self._conj)
-
-    def __matmul__(left, right):
-        return _ProdElement(left, right, [])
-
-    cpdef Data data(self, t):
-        return self.qobj(t).data
-
-    cpdef object qobj(self, t):
-        out = self._left.qobj(t) @ self._right.qobj(t)
-        for func in self._transform:
-            out = func(out)
-        return out
-
-    cpdef object coeff(self, t):
-        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
-        return conj(out) if self._conj else out
-
-    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
-        cdef Data temp
-        if not self._transform:
-            temp = self._right.matmul_data_t(t, state)
-            out = self._left.matmul_data_t(t, temp, out)
-            return out
-        elif type(state) is Dense and type(out) is Dense:
-            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
-            return out
-        else:
-            return _data.add(
-                out,
-                _data.matmul(self.data(t), state, self.coeff(t))
-            )
-
-    def linear_map(self, f, anti=False):
-        return _ProdElement(
-            self._left, self._right,
-            self._transform + [f],
-            self._conj ^ anti
-        )
-
-    def replace_arguments(_ProdElement self, args, cache=None):
-        return _ProdElement(
-            self._left.replace_arguments(args, cache=cache),
-            self._right.replace_arguments(args, cache=cache),
-            self._transform.copy(),
-            self._conj
-        )
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+
+from .. import data as _data
+from qutip.core.cy.coefficient import coefficient_function_parameters
+from qutip.core.data cimport Dense, Data, dense
+from qutip.core.data.matmul cimport *
+from math import nan as Nan
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+__all__ = ['_ConstantElement', '_EvoElement',
+           '_FuncElement', '_MapElement', '_ProdElement']
+
+
+cdef class _BaseElement:
+    """
+    The representation of a single time-dependent term in the list of
+    terms used by QobjEvo and solvers to describe operators.
+
+    Conceptually each term is given by ``coeff(t) * qobj(t)`` where
+    ``coeff`` is a complex coefficient and ``qobj`` is a :obj:`~Qobj`. Both
+    are functions of time. :meth:`~_BaseElement.coeff` returns the
+    coefficient at ``t``. :meth:`~_BaseElement.qobj` returns the :obj:`~Qobj`.
+
+    For example, a :obj:`QobjEvo` instance created by::
+
+      QobjEvo([sigmax(), [sigmay(), 'cos(pi * t)']])
+
+    would contain one :obj:`~_BaseElement` instance for the ``sigmax()`` term,
+    and one for the ``[sigmay(), 'cos(pi*t)']`` term.
+
+    :obj:`~_BaseElement` defines the interface to time-dependent terms.
+    Sub-classes implement terms defined in different ways.
+    For example, :obj:`~_ConstantElement` implements a term that
+    consists only of a constant :obj:`~Qobj` (i.e. where there is no dependence
+    on ``t``), :obj:`~_EvoElement` implements a term that consists of a
+    time-dependet :obj:`~Coefficient` times a constant :obj:`~Qobj`, and
+    so on.
+
+    .. note::
+
+      There are three methods to return the factors of the term.
+
+      :meth:`~_BaseElement.coeff` and :meth:`~_BaseElement.qobj` return the
+      coefficient and operator factors respectively. They are separate to
+      avoid constructing an intermediate Python object when called from
+      Cython code (which may take as long as the rest of the call).
+
+      :meth:`~BaseElement.data` is equivalent to ``.qobj(t).data`` and
+      provides a convenience method for this common operation.
+
+    .. note::
+
+      All :obj:`~_BaseElement` instances are immutable and methods that would
+      modify an object return a new instance instead.
+    """
+    cpdef Data data(self, t):
+        """
+        Returns the underlying :obj:`~Data` of the :obj:`~Qobj` component
+        of the term at time ``t``.
+
+        Parameters
+        ----------
+        t : double
+          The time, ``t``.
+
+        Returns
+        -------
+        :obj:`~Data`
+          The underlying data of the :obj:`~Qobj` component of the term
+          at time ``t``.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .data(t)."
+        )
+
+    cpdef object qobj(self, t):
+        """
+        Returns the :obj:`~Qobj` component of the term at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+          The time, ``t``.
+
+        Returns
+        -------
+        :obj:`~Qobj`
+          The :obj:`~Qobj` component of the term at time ``t``.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .qobj(t)."
+        )
+
+    cpdef object coeff(self, t):
+        """
+        Returns the complex coefficient of the term at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+          The time, ``t``.
+
+        Returns
+        -------
+        complex
+          The complex coefficient of the term at time ``t``.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .coeff(t)."
+        )
+
+    cdef Data matmul_data_t(_BaseElement self, t, Data state, Data out=None):
+        """
+        Possibly in-place multiplication and addition. Multiplies a given state
+        by the elemen's value at time ``t`` and adds the result to ``out``.
+        Equivalent to::
+
+          out += self.coeff(t) * self.qobj(t) @ state
+
+        Sub-classes may override :meth:`~matmul_data_t` to provide an more
+        efficient implementation.
+
+        Parameters
+        ----------
+        t : double
+          The time, ``t``.
+
+        state : :obj:`~Data`
+          The state to multiply by the element term.
+
+        out : :obj:`~Data` or ``NULL``
+          The output to add the result of the multiplication to. If ``NULL``,
+          the result of the multiplication is returned directly (i.e. ``out``
+          is assumed to be the zero matrix).
+
+        Returns
+        -------
+        data
+          The result of ``self.coeff(t) * self.qobj(t) @ state + out``, with
+          the addition possibly having been performed in-place on ``out``.
+
+        .. note::
+
+          Because of the possibly but not definitely in-place behaviour of
+          this function, the result should always be assigned to some variable
+          and surrounding code should assume that ``out`` maybe have been
+          modified and that the result may be a reference to ``out``. The
+          safest is simply to write ``out = elem.matmul_data_t(t, state, out)``.
+
+        .. note::
+
+          This method would ideally be implemented using a special
+          function dispatched by the data layer so that it did not have to
+          special case the ``Dense`` operation itself, but the data layer
+          dispatch does not yet support in-place operations. Once it does
+          this method should be updated to use the new support.
+        """
+        if out is None:
+            return _data.matmul(self.data(t), state, self.coeff(t))
+        elif type(state) is Dense and type(out) is Dense:
+            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
+            return out
+        else:
+            return _data.add(
+                out,
+                _data.matmul(self.data(t), state, self.coeff(t))
+            )
+
+    def linear_map(self, f, anti=False):
+        """
+        Return a new element representing a linear transformation ``f``
+        of the :obj:`~Qobj` portion of this element and possibly a
+        complex conjucation of the coefficient portion (when ``f`` is an
+        antilinear map).
+
+        If this element represents ``coeff * qobj`` the returned element
+        represents ``coeff * f(obj)`` (if ``anti=False``) or
+        ``conj(coeff) * f(obj)`` (if ``anti=True``).
+
+        Parameters
+        ----------
+        f : function
+          The linear transformation to apply to the :obj:`~Qobj` of this
+          element.
+        anti : bool
+          Whether to take the complex conjugate of the coefficient. Default
+          is ``False``. Should be set to ``True`` if ``f`` is an antilinear
+          map such as the adjoint (i.e. dagger).
+
+        Returns
+        -------
+        _BaseElement
+          A new element with the transformation applied.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .linear_map(t)."
+        )
+
+    def replace_arguments(self, args, cache=None):
+        """
+        Return a copy of the element with the (possible) additional arguments
+        to any time-dependent functions updated to the given argument values.
+        The arguments of any contained :obj:`~Coefficient` instances are also
+        replaced.
+
+        If the operation does not modify this element, the original element
+        may be returned.
+
+        Parameters
+        ----------
+        args : dict
+          A dictionary of arguments to update. Keys are the names of the
+          arguments and values are the new argument values. Arguments
+          not included retain their original values.
+
+        cache : list or ``None``
+          A cache to add updated elements to. Unmodified elements are not
+          added to the cache. If a cache is supplied and ``.replace_arguments``
+          would be called again on the same element with the same arguments,
+          the new element from the cache will be returned instead.
+
+          By default the cache is ``None`` and no caching is performed. Cache
+          users should supply either ``cache=[]`` (which activates caching)
+          or an existing cache (for example, if making calls on sub-elements
+          of some composite element).
+
+        Returns
+        -------
+        _BaseElement
+          A new element with the arguments replaced, or possibly this element
+          if it would not be modified.
+
+        Example
+        -------
+
+        If ``elem`` is a product element for ``op * op.dag()`` it will contain
+        two references to the same element for ``op``. Calling::
+
+          elem = elem.replace_arguments({"theta": 3.1416})
+
+        will return a new element that contains two *different* copies of
+        ``op.replace_arguments({"theta": 3.1416})``. This will cause ``op``
+        to be evaluated *twice* when ``elem.qobj(t)`` is called.
+
+        Calling instead::
+
+          elem = elem.replace_arguments({"theta": 3.1416}, cache=[])
+
+        will return a new element that contains two references to *one* copy
+        of ``op.replace_arguments({"theta": 3.1416})``, which will improve
+        performance when calling ``elem.qobj(t)`` later.
+        """
+        raise NotImplementedError(
+          "Sub-classes of _BaseElement should implement .replace_arguments(t)."
+        )
+
+    def __call__(self, t, args=None):
+        if args:
+            cache = []
+            self = self.replace_arguments(args, cache)
+        return self.qobj(t) * self.coeff(t)
+
+
+cdef class _ConstantElement(_BaseElement):
+    """
+    Constant part of a list format :obj:`QobjEvo`.
+    A constant :obj:`QobjEvo` will contain one `_ConstantElement`::
+
+      qevo = QobjEvo(H0)
+      qevo.elements = [_ConstantElement(H0)]
+    """
+    def __init__(self, qobj):
+        self._qobj = qobj
+
+    def __mul__(left, right):
+        if type(left) is _ConstantElement:
+            return _ConstantElement((<_ConstantElement> left)._qobj * right)
+        elif type(right) is _ConstantElement:
+            return _ConstantElement((<_ConstantElement> right)._qobj * left)
+        return NotImplemented
+
+    def __matmul__(left, right):
+        if type(left) is _ConstantElement and type(right) is _ConstantElement:
+            return _ConstantElement(
+                (<_ConstantElement> left)._qobj @
+                (<_ConstantElement> right)._qobj
+            )
+        return NotImplemented
+
+    cpdef Data data(self, t):
+        return self._qobj.data
+
+    cpdef object qobj(self, t):
+        return self._qobj
+
+    cpdef object coeff(self, t):
+        return 1.
+
+    def linear_map(self, f, anti=False):
+        return _ConstantElement(f(self._qobj))
+
+    def replace_arguments(self, args, cache=None):
+        return self
+
+    def __call__(self, t, args=None):
+        return self._qobj
+
+
+cdef class _EvoElement(_BaseElement):
+    """
+    A pair of a :obj:`Qobj` and a :obj:`Coefficient` from the list format
+    time-dependent operator::
+
+      qevo = QobjEvo([[H0, coeff0], [H1, coeff1]])
+      qevo.elements = [_EvoElement(H0, coeff0), _EvoElement(H1, coeff1)]
+    """
+    def __init__(self, qobj, coefficient):
+        self._qobj = qobj
+        self._coefficient = coefficient
+
+    def __mul__(left, right):
+        cdef _EvoElement base
+        cdef object factor
+        if type(left) is _EvoElement:
+            base = left
+            factor = right
+        if type(right) is _EvoElement:
+            base = right
+            factor = left
+        return _EvoElement(base._qobj * factor, base._coefficient)
+
+    def __matmul__(left, right):
+        if isinstance(left, _EvoElement) and isinstance(right, _EvoElement):
+            coefficient = left._coefficient * right._coefficient
+        elif isinstance(left, _EvoElement) and isinstance(right, _ConstantElement):
+            coefficient = left._coefficient
+        elif isinstance(right, _EvoElement) and isinstance(left, _ConstantElement):
+            coefficient = right._coefficient
+        else:
+            return NotImplemented
+        return _EvoElement(left._qobj * right._qobj, coefficient)
+
+    cpdef Data data(self, t):
+        return self._qobj.data
+
+    cpdef object qobj(self, t):
+        return self._qobj
+
+    cpdef object coeff(self, t):
+        return self._coefficient(t)
+
+    def linear_map(self, f, anti=False):
+        return _EvoElement(
+            f(self._qobj),
+            self._coefficient.conj() if anti else self._coefficient,
+        )
+
+    def replace_arguments(self, args, cache=None):
+        return _EvoElement(
+            self._qobj.copy(),
+            self._coefficient.replace_arguments(args)
+        )
+
+
+cdef class _FuncElement(_BaseElement):
+    """
+    Used with :obj:`QobjEvo` to build an evolution term from a function with
+    either the signature: ::
+
+        func(t: float, ...) -> Qobj
+
+    or the older QuTiP 4 style signature: ::
+
+        func(t: float, args: dict) -> Qobj
+
+    In the new style, ``func`` may accept arbitrary named arguments and
+    is called as ``func(t, **args)``.
+
+    A :obj:`QobjEvo` created from such a function contains one
+    :obj:`_FuncElement`: ::
+
+        qevo = QobjEvo(func, args=args)
+        qevo.elements = [_FuncElement(func, args)]
+
+    Each :obj:`_FuncElement` consists of an immutable pair ``(func, args)``
+    of function and argument.
+
+    This class has a basic capacity to memoize calls to ``func`` by saving the
+    result of the last call ::
+
+        op = QobjEvo(func, args=args)
+        (op.dag() * op)(t)
+
+    calls ``func`` only once.
+
+    Parameters
+    ----------
+    func : callable(t : float, ...) -> Qobj
+        Function returning the element value at time ``t``.
+
+    args : dict
+        Values of the arguments to pass to ``func``.
+
+    style : {None, "pythonic", "dict", "auto"}
+        The style of the signature used. If style is ``None``,
+        the value of ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
+    style and parameter detection and are not intended to be part of
+    the public interface.
+    """
+
+    _UNSET = object()
+
+    def __init__(self, func, args, style=None, _f_pythonic=_UNSET, _f_parameters=_UNSET):
+        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
+            if not (_f_pythonic is self._UNSET and _f_parameters is self._UNSET):
+                raise TypeError(
+                    "_f_pythonic and _f_parameters should always be given together."
+                )
+            _f_pythonic, _f_parameters = coefficient_function_parameters(
+                func, style=style)
+            if _f_parameters is not None:
+                args = {k: args[k] for k in _f_parameters & args.keys()}
+            else:
+                args = args.copy()
+        self._func = func
+        self._args = args
+        self._f_pythonic = _f_pythonic
+        self._f_parameters = _f_parameters
+        self._previous = (Nan, None)
+
+    def __mul__(left, right):
+        cdef _MapElement out
+        if type(left) is _FuncElement:
+            out = _MapElement(left, [], right)
+        if type(right) is _FuncElement:
+            out = _MapElement(right, [], left)
+        return out
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    cpdef Data data(self, t):
+        return self.qobj(t).data
+
+    cpdef object qobj(self, t):
+        cdef double _t
+        cdef object _qobj
+        _t, _qobj = self._previous
+        if t == _t:
+            return _qobj
+        if self._f_pythonic:
+            _qobj = self._func(t, **self._args)
+        else:
+            _qobj = self._func(t, self._args)
+        self._previous = (t, _qobj)
+        return _qobj
+
+    cpdef object coeff(self, t):
+        return 1.
+
+    def linear_map(self, f, anti=False):
+        return _MapElement(self, [f])
+
+    def replace_arguments(_FuncElement self, args, cache=None):
+        if self._f_parameters is not None:
+            args = {k: args[k] for k in self._f_parameters & args.keys()}
+        if not args:
+            return self
+        if cache is not None:
+            for old, new in cache:
+                if old is self:
+                    return new
+        new = _FuncElement(
+                self._func,
+                {**self._args, **args},
+                _f_pythonic=self._f_pythonic,
+                _f_parameters=self._f_parameters,
+        )
+        if cache is not None:
+            cache.append((self, new))
+        return new
+
+
+cdef class _MapElement(_BaseElement):
+    """
+    :obj:`_FuncElement` decorated with linear tranformations.
+
+    Linear tranformations available in :obj:`QobjEvo` include transpose,
+    adjoint, conjugate, convertion and product with number::
+    ```
+        op = QobjEvo(f, args=args)
+        op2 = op.conj().dag() * 2
+    ```
+    Then ``op2.elements`` is::
+        ``[_MapElement(_FuncElement(f, args), [conj, dag], 2)]``
+
+    """
+    def __init__(self, _FuncElement base, transform, coeff=1.):
+        self._base = base
+        self._transform = transform
+        self._coeff = coeff
+
+    def __mul__(left, right):
+        cdef _MapElement out, self
+        cdef double complex factor
+        if type(left) is _MapElement:
+            self = left
+            factor = right
+        elif type(right) is _MapElement:
+            self = right
+            factor = left
+        return _MapElement(
+            self._base,
+            self._transform.copy(),
+            self._coeff*factor
+        )
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    cpdef Data data(self, t):
+        return self.qobj(t).data
+
+    cpdef object qobj(self, t):
+        out = self._base.qobj(t)
+        for func in self._transform:
+            out = func(out)
+        return out
+
+    cpdef object coeff(self, t):
+        return self._coeff
+
+    def linear_map(self, f, anti=False):
+        return _MapElement(
+            self._base,
+            self._transform + [f],
+            conj(self._coeff) if anti else self._coeff
+        )
+
+    def replace_arguments(_MapElement self, args, cache=None):
+        return _MapElement(
+            self._base.replace_arguments(args, cache=cache),
+            self._transform.copy(),
+            self._coeff,
+        )
+
+
+cdef class _ProdElement(_BaseElement):
+    """
+    Product of a :obj:`_FuncElement` or :obj:`_MapElement` with other
+    :obj:`_BaseElement`. Include a stack of linear transformation to be
+    applied after the product::
+
+        ``op = QobjEvo(f) * qobj1``
+    Then ``op.elements`` is::
+        ``[_ProdElement(_FuncElement(f, {}), _ConstantElement(qobj1))]``
+    """
+    def __init__(self, left, right, transform, conj=False):
+        self._left = left
+        self._right = right
+        self._conj = conj
+        self._transform = transform
+
+    def __mul__(left, right):
+        cdef _ProdElement self
+        cdef double complex factor
+        if type(left) is _ProdElement:
+            self = left
+            factor = right
+        if type(right) is _ProdElement:
+            self = right
+            factor = left
+        return _ProdElement(self._left, self._right * factor,
+                            self._transform.copy(), self._conj)
+
+    def __matmul__(left, right):
+        return _ProdElement(left, right, [])
+
+    cpdef Data data(self, t):
+        return self.qobj(t).data
+
+    cpdef object qobj(self, t):
+        out = self._left.qobj(t) @ self._right.qobj(t)
+        for func in self._transform:
+            out = func(out)
+        return out
+
+    cpdef object coeff(self, t):
+        cdef double complex out = self._left.coeff(t) * self._right.coeff(t)
+        return conj(out) if self._conj else out
+
+    cdef Data matmul_data_t(_ProdElement self, t, Data state, Data out=None):
+        cdef Data temp
+        if not self._transform:
+            temp = self._right.matmul_data_t(t, state)
+            out = self._left.matmul_data_t(t, temp, out)
+            return out
+        elif type(state) is Dense and type(out) is Dense:
+            imatmul_data_dense(self.data(t), state, self.coeff(t), out)
+            return out
+        else:
+            return _data.add(
+                out,
+                _data.matmul(self.data(t), state, self.coeff(t))
+            )
+
+    def linear_map(self, f, anti=False):
+        return _ProdElement(
+            self._left, self._right,
+            self._transform + [f],
+            self._conj ^ anti
+        )
+
+    def replace_arguments(_ProdElement self, args, cache=None):
+        return _ProdElement(
+            self._left.replace_arguments(args, cache=cache),
+            self._right.replace_arguments(args, cache=cache),
+            self._transform.copy(),
+            self._conj
+        )
diff --git a/qutip/core/cy/coefficient.pxd b/qutip/core/cy/coefficient.pxd
index c4824b7d4a..f81858c2ef 100644
--- a/qutip/core/cy/coefficient.pxd
+++ b/qutip/core/cy/coefficient.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-cdef class Coefficient:
-    cdef readonly dict args
-    cdef double complex _call(self, double t) except *
-    cpdef Coefficient copy(self)
+#cython: language_level=3
+cdef class Coefficient:
+    cdef readonly dict args
+    cdef double complex _call(self, double t) except *
+    cpdef Coefficient copy(self)
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index b2755c3a4a..79fd84e5ae 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -1,728 +1,728 @@
-#cython: language_level=3
-import inspect
-import pickle
-import scipy
-from scipy.interpolate import make_interp_spline
-import numpy as np
-cimport numpy as cnp
-cimport cython
-import qutip
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-    double         norm(double complex x)
-
-
-def coefficient_function_parameters(func, style=None):
-    """
-    Return the function style (either "pythonic" or not) and a list of
-    additional parameters accepted.
-
-    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
-    call signature of the supplied function based on the given style (or
-    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
-    and the signature of the given function.
-
-    Parameters
-    ----------
-    func : function
-        The :obj:`FunctionCoefficient` to inspect. The first argument
-        of the function is assumed to be ``t`` (the time at which to
-        evaluate the coefficient). The remaining arguments depend on
-        the signature style (see below).
-
-    style : {None, "pythonic", "dict", "auto"}
-        The style of the signature used. If style is ``None``,
-        the value of ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-    Returns
-    -------
-    (f_pythonic, f_parameters)
-
-    f_pythonic : bool
-        True if the function should be called as ``f(t, **kw)`` and False
-        if the function should be called as ``f(t, kw_dict)``.
-
-    f_parameters : set or None
-        The set of parameters (other than ``t``) of the function or
-        ``None`` if the function accepts arbitrary parameters.
-    """
-    sig = inspect.signature(func)
-    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
-    if style is None:
-        style = qutip.settings.core["function_coefficient_style"]
-    if style == "auto":
-        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
-            # if the signature is exactly f(t, args), then assume parameters
-            # are supplied in an argument dictionary
-            style = "dict"
-        else:
-            style = "pythonic"
-    if style == "dict" or f_has_kw:
-        # f might accept any parameter
-        f_parameters = None
-    else:
-        # f accepts only t and the named parameters
-        f_parameters = set(list(sig.parameters.keys())[1:])
-    return (style == "pythonic", f_parameters)
-
-
-cdef class Coefficient:
-    """
-    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
-    composing time-dependant operator in list format for :obj:`QobjEvo`.
-
-    :obj:`Coefficient` are immutable.
-    """
-    def __init__(self, args, **_):
-        self.args = args
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return self
-
-    def __call__(self, t, dict _args=None, **kwargs):
-        """
-        Return the coefficient value at time `t`.
-        Stored arguments can overwriten with `_args` or as keywords parameters.
-
-        Parameters
-        ----------
-        t : float
-            Time at which to evaluate the :obj:`Coefficient`.
-
-        _args : dict
-            Dictionary of arguments to use instead of the stored ones.
-
-        **kwargs
-            Arguments to overwrite for this call.
-        """
-        if _args is not None or kwargs:
-            return (<Coefficient> self.replace_arguments(_args,
-                                                         **kwargs))._call(t)
-        return self._call(t)
-
-    cdef double complex _call(self, double t) except *:
-        """Core computation of the :obj:`Coefficient`."""
-        # All Coefficient sub-classes should overwrite this or __call__
-        return complex(self(t))
-
-    def __add__(left, right):
-        if (
-            isinstance(left, InterCoefficient)
-            and isinstance(right, InterCoefficient)
-        ):
-            return add_inter(left, right)
-        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
-            return SumCoefficient(left.copy(), right.copy())
-        return NotImplemented
-
-    def __mul__(left, right):
-        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
-            return MulCoefficient(left.copy(), right.copy())
-        if isinstance(left, qutip.Qobj):
-            return qutip.QobjEvo([left.copy(), right.copy()])
-        if isinstance(right, qutip.Qobj):
-            return qutip.QobjEvo([right.copy(), left.copy()])
-        return NotImplemented
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return pickle.loads(pickle.dumps(self))
-
-    def conj(self):
-        """ Return a conjugate :obj:`Coefficient` of this"""
-        return ConjCoefficient(self)
-
-    def _cdc(self):
-        """ Return a :obj:`Coefficient` being the norm of this"""
-        return NormCoefficient(self)
-
-
-@cython.auto_pickle(True)
-cdef class FunctionCoefficient(Coefficient):
-    """
-    :obj:`Coefficient` wrapping a Python function.
-
-    Parameters
-    ----------
-    func : callable(t : float, ...) -> complex
-        Function returning the coefficient value at time ``t``.
-
-    args : dict
-        Values of the arguments to pass to ``func``.
-
-    style : {None, "pythonic", "dict", "auto"}
-        The style of function signature used. If style is ``None``,
-        the value of ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
-    style and parameter detection and are not intended to be part of
-    the public interface.
-    """
-    cdef object func
-    cdef bint _f_pythonic
-    cdef set _f_parameters
-
-    _UNSET = object()
-
-    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
-                 _f_parameters=_UNSET, **_):
-        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
-            if not (_f_pythonic is self._UNSET
-                    and _f_parameters is self._UNSET):
-                raise TypeError(
-                    "_f_pythonic and _f_parameters should "
-                    "always be given together."
-                )
-            _f_pythonic, _f_parameters = coefficient_function_parameters(
-                func, style=style)
-            if _f_parameters is not None:
-                args = {k: args[k] for k in _f_parameters & args.keys()}
-            else:
-                args = args.copy()
-        self.func = func
-        self.args = args
-        self._f_pythonic = _f_pythonic
-        self._f_parameters = _f_parameters
-
-    def __call__(self, t, dict _args=None, **kwargs):
-        if _args is not None or kwargs:
-            return self.replace_arguments(_args, **kwargs)(t)
-        if self._f_pythonic:
-            return self.func(t, **self.args)
-        return self.func(t, self.args)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return FunctionCoefficient(
-            self.func,
-            self.args.copy(),
-            _f_pythonic=self._f_pythonic,
-            _f_parameters=self._f_parameters,
-        )
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        if _args:
-            kwargs.update(_args)
-        if self._f_parameters is not None:
-            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
-        if not kwargs:
-            return self
-        return FunctionCoefficient(
-            self.func,
-            {**self.args, **kwargs},
-            _f_pythonic=self._f_pythonic,
-            _f_parameters=self._f_parameters,
-        )
-
-
-def proj(x):
-    if np.isfinite(x):
-        return (x)
-    else:
-        return np.inf + 0j * np.imag(x)
-
-
-cdef class StrFunctionCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` defined by a string containing a simple Python
-    expression.
-
-    The string should contain a compilable Python expression that results in a
-    complex number. The time ``t`` is available as a local variable, as are the
-    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
-    itself is not accessible.
-
-    The following symbols are defined:
-        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
-        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
-        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
-        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
-        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
-
-    Examples
-    --------
-    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
-
-    Parameters
-    ----------
-    base : str
-        A string representing a compilable Python expression that results in a
-        complex number.
-
-    args : dict
-        A dictionary of variable used in the code string. It may include unused
-        variables.
-    """
-    cdef object func
-    cdef str base
-
-    str_env = {
-        "sin": np.sin,
-        "cos": np.cos,
-        "tan": np.tan,
-        "asin": np.arcsin,
-        "acos": np.arccos,
-        "atan": np.arctan,
-        "pi": np.pi,
-        "sinh": np.sinh,
-        "cosh": np.cosh,
-        "tanh": np.tanh,
-        "asinh": np.arcsinh,
-        "acosh": np.arccosh,
-        "atanh": np.arctanh,
-        "exp": np.exp,
-        "log": np.log,
-        "log10": np.log10,
-        "erf": scipy.special.erf,
-        "zerf": scipy.special.erf,
-        "sqrt": np.sqrt,
-        "real": np.real,
-        "imag": np.imag,
-        "conj": np.conj,
-        "abs": np.abs,
-        "norm": lambda x: np.abs(x)**2,
-        "arg": np.angle,
-        "proj": proj,
-        "np": np,
-        "spe": scipy.special}
-
-    def __init__(self, base, dict args, **_):
-        args2var = "\n".join(["    {} = args['{}']".format(key, key)
-                              for key in args])
-        code = f"""
-def coeff(t, args):
-{args2var}
-    return {base}"""
-        lc = {}
-        exec(code, self.str_env, lc)
-        self.base = base
-        self.func = lc["coeff"]
-        self.args = args
-
-    cdef complex _call(self, double t) except *:
-        return self.func(t, self.args)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return StrFunctionCoefficient(self.base, self.args.copy())
-
-    def __reduce__(self):
-        return (StrFunctionCoefficient, (self.base, self.args))
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        if _args:
-            kwargs.update(_args)
-        if kwargs:
-            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
-        return self
-
-
-cdef class InterCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` built from an interpolation of a numpy array.
-
-    Parameters
-    ----------
-    coeff_arr : np.ndarray
-        The array of coefficient values to interpolate.
-
-    tlist : np.ndarray
-        An array of times corresponding to each coefficient value. The times
-        must be increasing, but do not need to be uniformly spaced.
-
-    order : int
-        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
-        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
-
-    boundary_conditions : 2-Tuple, str or None, optional
-        Boundary conditions for spline evaluation. Default value is `None`.
-        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
-        Refer to Scipy's documentation for further details:
-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-    """
-    cdef int order
-    cdef double dt
-    cdef double[::1] tlist
-    cdef complex[:, :] poly
-    cdef object np_arrays
-
-    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
-        tlist = np.array(tlist, dtype=np.float64)
-        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
-
-        if coeff_arr.ndim != 1:
-            raise ValueError("The array to interpolate must be a 1D array")
-        if coeff_arr.shape != tlist.shape:
-            raise ValueError("tlist must be the same len "
-                             "as the array to interpolate")
-        if order < 0:
-            raise ValueError("order must be a positive integer")
-
-        order = min(order, len(tlist) - 1)
-
-        if order == 0:
-            coeff_arr = coeff_arr.reshape((1, -1))
-        elif order == 1:
-            coeff_arr = np.vstack([
-                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
-                    coeff_arr
-                ])
-        elif order >= 2:
-            # Use scipy to compute the spline and transform it to polynomes
-            # as used in scipy's PPoly which is easier for us to use.
-            spline = make_interp_spline(tlist, coeff_arr, k=order,
-                                        bc_type=boundary_conditions)
-            # Scipy can move knots, we add them to tlist
-            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
-            a = np.arange(spline.k+1)
-            a[0] = 1
-            fact = np.cumprod(a)
-            coeff_arr = np.concatenate([
-                spline(tlist, i) / fact[i]
-                for i in range(spline.k, -1, -1)
-            ]).reshape((spline.k+1, -1))
-
-        self._prepare(tlist, coeff_arr)
-
-    def _prepare(self, np_tlist, np_poly, dt=None):
-        self.np_arrays = (np_tlist, np_poly)
-        self.tlist = np_tlist
-        self.poly = np_poly
-        self.order = self.poly.shape[0] - 1
-        diff = np.diff(self.np_arrays[0])
-        if dt is not None:
-            self.dt = dt
-        elif len(diff) >= 1 and np.allclose(diff[0], diff):
-            self.dt = diff[0]
-        else:
-            self.dt = 0
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef size_t _binary_search(self, double x):
-        # Binary search for the interval
-        # return the indice of the of the biggest element where t <= x
-        cdef size_t low = 0
-        cdef size_t high = self.tlist.shape[0]
-        cdef size_t middle
-        cdef size_t count = 0
-        while low+1 != high and count < 64:
-            middle = (low + high)//2
-            if x < self.tlist[middle]:
-                high = middle
-            else:
-                low = middle
-            # We keep a count to be sure that it never get into an infinit loop
-            # even if tlist has an unexpected format.
-            count += 1
-        return low
-
-    @cython.initializedcheck(False)
-    @cython.cdivision(True)
-    cdef double complex _call(self, double t) except *:
-        cdef size_t idx, i
-        cdef double factor
-        cdef double complex out
-        cdef double complex[:] slice
-        if t <= self.tlist[0]:
-            return self.poly[-1, 0]
-        elif t >= self.tlist[-1]:
-            return self.poly[-1, -1]
-        if self.dt:
-            idx = <size_t>((t - self.tlist[0]) / self.dt)
-        else:
-            idx = self._binary_search(t)
-        if self.order == 0:
-            out = self.poly[0, idx]
-        else:
-            factor = t - self.tlist[idx]
-            slice = self.poly[:, idx]
-            out = 0.
-            for i in range(self.order+1):
-                out *= factor
-                out += slice[i]
-        return out
-
-    def __reduce__(self):
-        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
-
-    @classmethod
-    def restore(cls, np_tlist, np_poly, dt=None):
-        cdef InterCoefficient out = cls.__new__(cls)
-        out._prepare(np_tlist, np_poly, dt)
-        return out
-
-    @classmethod
-    def from_PPoly(cls, ppoly, **_):
-        return cls.restore(ppoly.x, ppoly.c)
-
-    @classmethod
-    def from_Bspline(cls, spline, **_):
-        tlist = np.unique(spline.t)
-        a = np.arange(spline.k+1)
-        a[0] = 1
-        fact = np.cumprod(a) + 0j
-        poly = np.concatenate([
-            spline(tlist, i) / fact[i]
-            for i in range(spline.k, -1, -1)
-        ]).reshape((spline.k+1, -1))
-        return cls.restore(tlist, poly)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return InterCoefficient.restore(*self.np_arrays, self.dt)
-
-
-cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
-    """ Add two array coefficient with matching tlist into one."""
-    if (
-        left.np_arrays[0].shape == right.np_arrays[0].shape
-        and np.allclose(left.np_arrays[0], right.np_arrays[0],
-                        rtol=1e-15, atol=1e-15)
-        and (left.order == right.order)
-    ):
-        return InterCoefficient.restore(
-            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
-            left.dt
-        )
-    else:
-        # It would be possible to add them by merging tlist.
-        return SumCoefficient(left, right)
-
-
-@cython.auto_pickle(True)
-cdef class SumCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` built from the sum of two other coefficients.
-
-    A :obj:`SumCoefficient` is returned as the result of the addition of two
-    coefficients, e.g. ::
-
-        coefficient("t * t") + coefficient("t")  # SumCoefficient
-    """
-    cdef Coefficient first
-    cdef Coefficient second
-
-    def __init__(self, Coefficient first, Coefficient second):
-        self.first = first
-        self.second = second
-
-    cdef complex _call(self, double t) except *:
-        return self.first._call(t) + self.second._call(t)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return SumCoefficient(self.first.copy(), self.second.copy())
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return SumCoefficient(
-            self.first.replace_arguments(_args, **kwargs),
-            self.second.replace_arguments(_args, **kwargs)
-        )
-
-
-@cython.auto_pickle(True)
-cdef class MulCoefficient(Coefficient):
-    """
-    A :obj:`Coefficient` built from the product of two other coefficients.
-
-    A :obj:`MulCoefficient` is returned as the result of the multiplication of
-    two coefficients, e.g. ::
-
-        coefficient("w * t", args={'w': 1}) * coefficient("t")
-    """
-    cdef Coefficient first
-    cdef Coefficient second
-
-    def __init__(self, Coefficient first, Coefficient second):
-        self.first = first
-        self.second = second
-
-    cdef complex _call(self, double t) except *:
-        return self.first._call(t) * self.second._call(t)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return MulCoefficient(self.first.copy(), self.second.copy())
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return MulCoefficient(
-            self.first.replace_arguments(_args, **kwargs),
-            self.second.replace_arguments(_args, **kwargs)
-        )
-
-
-@cython.auto_pickle(True)
-cdef class ConjCoefficient(Coefficient):
-    """
-    The conjugate of a :obj:`Coefficient`.
-
-    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
-    ``qutip.coefficent.conj(Coefficient)``.
-    """
-    cdef Coefficient base
-
-    def __init__(self, Coefficient base):
-        self.base = base
-
-    cdef complex _call(self, double t) except *:
-        return conj(self.base._call(t))
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return ConjCoefficient(self.base.copy())
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return ConjCoefficient(
-            self.base.replace_arguments(_args, **kwargs)
-        )
-
-
-@cython.auto_pickle(True)
-cdef class NormCoefficient(Coefficient):
-    """
-    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
-    ``conj(coeff) * coeff``.
-
-    :obj:`NormCoefficient` is returned by
-    ``qutip.coefficent.norm(Coefficient)``.
-    """
-    cdef Coefficient base
-
-    def __init__(self, Coefficient base):
-        self.base = base
-
-    def replace_arguments(self, _args=None, **kwargs):
-        """
-        Replace the arguments (``args``) of a coefficient.
-
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
-
-        Parameters
-        ----------
-        _args : dict
-            Dictionary of arguments to replace.
-
-        **kwargs
-            Arguments to replace.
-        """
-        return NormCoefficient(
-            self.base.replace_arguments(_args, **kwargs)
-        )
-
-    cdef complex _call(self, double t) except *:
-        return norm(self.base._call(t))
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        return NormCoefficient(self.base.copy())
+#cython: language_level=3
+import inspect
+import pickle
+import scipy
+from scipy.interpolate import make_interp_spline
+import numpy as np
+cimport numpy as cnp
+cimport cython
+import qutip
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+    double         norm(double complex x)
+
+
+def coefficient_function_parameters(func, style=None):
+    """
+    Return the function style (either "pythonic" or not) and a list of
+    additional parameters accepted.
+
+    Used by :obj:`FunctionCoefficient` and :obj:`_FuncElement` to determine the
+    call signature of the supplied function based on the given style (or
+    ``qutip.settings.core["function_coefficient_style"]`` if no style is given)
+    and the signature of the given function.
+
+    Parameters
+    ----------
+    func : function
+        The :obj:`FunctionCoefficient` to inspect. The first argument
+        of the function is assumed to be ``t`` (the time at which to
+        evaluate the coefficient). The remaining arguments depend on
+        the signature style (see below).
+
+    style : {None, "pythonic", "dict", "auto"}
+        The style of the signature used. If style is ``None``,
+        the value of ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+    Returns
+    -------
+    (f_pythonic, f_parameters)
+
+    f_pythonic : bool
+        True if the function should be called as ``f(t, **kw)`` and False
+        if the function should be called as ``f(t, kw_dict)``.
+
+    f_parameters : set or None
+        The set of parameters (other than ``t``) of the function or
+        ``None`` if the function accepts arbitrary parameters.
+    """
+    sig = inspect.signature(func)
+    f_has_kw = any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values())
+    if style is None:
+        style = qutip.settings.core["function_coefficient_style"]
+    if style == "auto":
+        if tuple(sig.parameters.keys()) == ("t", "args") and not f_has_kw:
+            # if the signature is exactly f(t, args), then assume parameters
+            # are supplied in an argument dictionary
+            style = "dict"
+        else:
+            style = "pythonic"
+    if style == "dict" or f_has_kw:
+        # f might accept any parameter
+        f_parameters = None
+    else:
+        # f accepts only t and the named parameters
+        f_parameters = set(list(sig.parameters.keys())[1:])
+    return (style == "pythonic", f_parameters)
+
+
+cdef class Coefficient:
+    """
+    `Coefficient` are the time-dependant scalar of a `[Qobj, coeff]` pair
+    composing time-dependant operator in list format for :obj:`QobjEvo`.
+
+    :obj:`Coefficient` are immutable.
+    """
+    def __init__(self, args, **_):
+        self.args = args
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return self
+
+    def __call__(self, t, dict _args=None, **kwargs):
+        """
+        Return the coefficient value at time `t`.
+        Stored arguments can overwriten with `_args` or as keywords parameters.
+
+        Parameters
+        ----------
+        t : float
+            Time at which to evaluate the :obj:`Coefficient`.
+
+        _args : dict
+            Dictionary of arguments to use instead of the stored ones.
+
+        **kwargs
+            Arguments to overwrite for this call.
+        """
+        if _args is not None or kwargs:
+            return (<Coefficient> self.replace_arguments(_args,
+                                                         **kwargs))._call(t)
+        return self._call(t)
+
+    cdef double complex _call(self, double t) except *:
+        """Core computation of the :obj:`Coefficient`."""
+        # All Coefficient sub-classes should overwrite this or __call__
+        return complex(self(t))
+
+    def __add__(left, right):
+        if (
+            isinstance(left, InterCoefficient)
+            and isinstance(right, InterCoefficient)
+        ):
+            return add_inter(left, right)
+        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
+            return SumCoefficient(left.copy(), right.copy())
+        return NotImplemented
+
+    def __mul__(left, right):
+        if isinstance(left, Coefficient) and isinstance(right, Coefficient):
+            return MulCoefficient(left.copy(), right.copy())
+        if isinstance(left, qutip.Qobj):
+            return qutip.QobjEvo([left.copy(), right.copy()])
+        if isinstance(right, qutip.Qobj):
+            return qutip.QobjEvo([right.copy(), left.copy()])
+        return NotImplemented
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return pickle.loads(pickle.dumps(self))
+
+    def conj(self):
+        """ Return a conjugate :obj:`Coefficient` of this"""
+        return ConjCoefficient(self)
+
+    def _cdc(self):
+        """ Return a :obj:`Coefficient` being the norm of this"""
+        return NormCoefficient(self)
+
+
+@cython.auto_pickle(True)
+cdef class FunctionCoefficient(Coefficient):
+    """
+    :obj:`Coefficient` wrapping a Python function.
+
+    Parameters
+    ----------
+    func : callable(t : float, ...) -> complex
+        Function returning the coefficient value at time ``t``.
+
+    args : dict
+        Values of the arguments to pass to ``func``.
+
+    style : {None, "pythonic", "dict", "auto"}
+        The style of function signature used. If style is ``None``,
+        the value of ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+    The parameters ``_f_pythonic`` and ``_f_parameters`` override function
+    style and parameter detection and are not intended to be part of
+    the public interface.
+    """
+    cdef object func
+    cdef bint _f_pythonic
+    cdef set _f_parameters
+
+    _UNSET = object()
+
+    def __init__(self, func, dict args, style=None, _f_pythonic=_UNSET,
+                 _f_parameters=_UNSET, **_):
+        if _f_pythonic is self._UNSET or _f_parameters is self._UNSET:
+            if not (_f_pythonic is self._UNSET
+                    and _f_parameters is self._UNSET):
+                raise TypeError(
+                    "_f_pythonic and _f_parameters should "
+                    "always be given together."
+                )
+            _f_pythonic, _f_parameters = coefficient_function_parameters(
+                func, style=style)
+            if _f_parameters is not None:
+                args = {k: args[k] for k in _f_parameters & args.keys()}
+            else:
+                args = args.copy()
+        self.func = func
+        self.args = args
+        self._f_pythonic = _f_pythonic
+        self._f_parameters = _f_parameters
+
+    def __call__(self, t, dict _args=None, **kwargs):
+        if _args is not None or kwargs:
+            return self.replace_arguments(_args, **kwargs)(t)
+        if self._f_pythonic:
+            return self.func(t, **self.args)
+        return self.func(t, self.args)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return FunctionCoefficient(
+            self.func,
+            self.args.copy(),
+            _f_pythonic=self._f_pythonic,
+            _f_parameters=self._f_parameters,
+        )
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        if self._f_parameters is not None:
+            kwargs = {k: kwargs[k] for k in self._f_parameters & kwargs.keys()}
+        if not kwargs:
+            return self
+        return FunctionCoefficient(
+            self.func,
+            {**self.args, **kwargs},
+            _f_pythonic=self._f_pythonic,
+            _f_parameters=self._f_parameters,
+        )
+
+
+def proj(x):
+    if np.isfinite(x):
+        return (x)
+    else:
+        return np.inf + 0j * np.imag(x)
+
+
+cdef class StrFunctionCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` defined by a string containing a simple Python
+    expression.
+
+    The string should contain a compilable Python expression that results in a
+    complex number. The time ``t`` is available as a local variable, as are the
+    individual arguments (i.e. the keys of ``args``). The ``args`` dictionary
+    itself is not accessible.
+
+    The following symbols are defined:
+        ``sin``, ``cos``, ``tan``, ``asin``, ``acos``, ``atan``, ``pi``,
+        ``sinh``, ``cosh``, ``tanh``, ``asinh``, ``acosh``, ``atanh``,
+        ``exp``, ``log``, ``log10``, ``erf``, ``zerf``, ``sqrt``,
+        ``real``, ``imag``, ``conj``, ``abs``, ``norm``, ``arg``, ``proj``,
+        ``numpy`` as ``np`` and ``scipy.special`` as ``spe``.
+
+    Examples
+    --------
+    >>> StrFunctionCoefficient("sin(w * pi * t)", {'w': 1j})
+
+    Parameters
+    ----------
+    base : str
+        A string representing a compilable Python expression that results in a
+        complex number.
+
+    args : dict
+        A dictionary of variable used in the code string. It may include unused
+        variables.
+    """
+    cdef object func
+    cdef str base
+
+    str_env = {
+        "sin": np.sin,
+        "cos": np.cos,
+        "tan": np.tan,
+        "asin": np.arcsin,
+        "acos": np.arccos,
+        "atan": np.arctan,
+        "pi": np.pi,
+        "sinh": np.sinh,
+        "cosh": np.cosh,
+        "tanh": np.tanh,
+        "asinh": np.arcsinh,
+        "acosh": np.arccosh,
+        "atanh": np.arctanh,
+        "exp": np.exp,
+        "log": np.log,
+        "log10": np.log10,
+        "erf": scipy.special.erf,
+        "zerf": scipy.special.erf,
+        "sqrt": np.sqrt,
+        "real": np.real,
+        "imag": np.imag,
+        "conj": np.conj,
+        "abs": np.abs,
+        "norm": lambda x: np.abs(x)**2,
+        "arg": np.angle,
+        "proj": proj,
+        "np": np,
+        "spe": scipy.special}
+
+    def __init__(self, base, dict args, **_):
+        args2var = "\n".join(["    {} = args['{}']".format(key, key)
+                              for key in args])
+        code = f"""
+def coeff(t, args):
+{args2var}
+    return {base}"""
+        lc = {}
+        exec(code, self.str_env, lc)
+        self.base = base
+        self.func = lc["coeff"]
+        self.args = args
+
+    cdef complex _call(self, double t) except *:
+        return self.func(t, self.args)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return StrFunctionCoefficient(self.base, self.args.copy())
+
+    def __reduce__(self):
+        return (StrFunctionCoefficient, (self.base, self.args))
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        if kwargs:
+            return StrFunctionCoefficient(self.base, {**self.args, **kwargs})
+        return self
+
+
+cdef class InterCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` built from an interpolation of a numpy array.
+
+    Parameters
+    ----------
+    coeff_arr : np.ndarray
+        The array of coefficient values to interpolate.
+
+    tlist : np.ndarray
+        An array of times corresponding to each coefficient value. The times
+        must be increasing, but do not need to be uniformly spaced.
+
+    order : int
+        Order of the interpolation. Order ``0`` uses the previous (i.e. left)
+        value. The order will be reduced to ``len(tlist) - 1`` if it is larger.
+
+    boundary_conditions : 2-Tuple, str or None, optional
+        Boundary conditions for spline evaluation. Default value is `None`.
+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+        Refer to Scipy's documentation for further details:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+    """
+    cdef int order
+    cdef double dt
+    cdef double[::1] tlist
+    cdef complex[:, :] poly
+    cdef object np_arrays
+
+    def __init__(self, coeff_arr, tlist, int order, boundary_conditions, **_):
+        tlist = np.array(tlist, dtype=np.float64)
+        coeff_arr = np.array(coeff_arr, dtype=np.complex128)
+
+        if coeff_arr.ndim != 1:
+            raise ValueError("The array to interpolate must be a 1D array")
+        if coeff_arr.shape != tlist.shape:
+            raise ValueError("tlist must be the same len "
+                             "as the array to interpolate")
+        if order < 0:
+            raise ValueError("order must be a positive integer")
+
+        order = min(order, len(tlist) - 1)
+
+        if order == 0:
+            coeff_arr = coeff_arr.reshape((1, -1))
+        elif order == 1:
+            coeff_arr = np.vstack([
+                    np.diff(coeff_arr, append=-1) / np.diff(tlist, append=-1),
+                    coeff_arr
+                ])
+        elif order >= 2:
+            # Use scipy to compute the spline and transform it to polynomes
+            # as used in scipy's PPoly which is easier for us to use.
+            spline = make_interp_spline(tlist, coeff_arr, k=order,
+                                        bc_type=boundary_conditions)
+            # Scipy can move knots, we add them to tlist
+            tlist = np.sort(np.unique(np.concatenate([spline.t, tlist])))
+            a = np.arange(spline.k+1)
+            a[0] = 1
+            fact = np.cumprod(a)
+            coeff_arr = np.concatenate([
+                spline(tlist, i) / fact[i]
+                for i in range(spline.k, -1, -1)
+            ]).reshape((spline.k+1, -1))
+
+        self._prepare(tlist, coeff_arr)
+
+    def _prepare(self, np_tlist, np_poly, dt=None):
+        self.np_arrays = (np_tlist, np_poly)
+        self.tlist = np_tlist
+        self.poly = np_poly
+        self.order = self.poly.shape[0] - 1
+        diff = np.diff(self.np_arrays[0])
+        if dt is not None:
+            self.dt = dt
+        elif len(diff) >= 1 and np.allclose(diff[0], diff):
+            self.dt = diff[0]
+        else:
+            self.dt = 0
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef size_t _binary_search(self, double x):
+        # Binary search for the interval
+        # return the indice of the of the biggest element where t <= x
+        cdef size_t low = 0
+        cdef size_t high = self.tlist.shape[0]
+        cdef size_t middle
+        cdef size_t count = 0
+        while low+1 != high and count < 64:
+            middle = (low + high)//2
+            if x < self.tlist[middle]:
+                high = middle
+            else:
+                low = middle
+            # We keep a count to be sure that it never get into an infinit loop
+            # even if tlist has an unexpected format.
+            count += 1
+        return low
+
+    @cython.initializedcheck(False)
+    @cython.cdivision(True)
+    cdef double complex _call(self, double t) except *:
+        cdef size_t idx, i
+        cdef double factor
+        cdef double complex out
+        cdef double complex[:] slice
+        if t <= self.tlist[0]:
+            return self.poly[-1, 0]
+        elif t >= self.tlist[-1]:
+            return self.poly[-1, -1]
+        if self.dt:
+            idx = <size_t>((t - self.tlist[0]) / self.dt)
+        else:
+            idx = self._binary_search(t)
+        if self.order == 0:
+            out = self.poly[0, idx]
+        else:
+            factor = t - self.tlist[idx]
+            slice = self.poly[:, idx]
+            out = 0.
+            for i in range(self.order+1):
+                out *= factor
+                out += slice[i]
+        return out
+
+    def __reduce__(self):
+        return (InterCoefficient.restore, (*self.np_arrays, self.dt))
+
+    @classmethod
+    def restore(cls, np_tlist, np_poly, dt=None):
+        cdef InterCoefficient out = cls.__new__(cls)
+        out._prepare(np_tlist, np_poly, dt)
+        return out
+
+    @classmethod
+    def from_PPoly(cls, ppoly, **_):
+        return cls.restore(ppoly.x, ppoly.c)
+
+    @classmethod
+    def from_Bspline(cls, spline, **_):
+        tlist = np.unique(spline.t)
+        a = np.arange(spline.k+1)
+        a[0] = 1
+        fact = np.cumprod(a) + 0j
+        poly = np.concatenate([
+            spline(tlist, i) / fact[i]
+            for i in range(spline.k, -1, -1)
+        ]).reshape((spline.k+1, -1))
+        return cls.restore(tlist, poly)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return InterCoefficient.restore(*self.np_arrays, self.dt)
+
+
+cdef Coefficient add_inter(InterCoefficient left, InterCoefficient right):
+    """ Add two array coefficient with matching tlist into one."""
+    if (
+        left.np_arrays[0].shape == right.np_arrays[0].shape
+        and np.allclose(left.np_arrays[0], right.np_arrays[0],
+                        rtol=1e-15, atol=1e-15)
+        and (left.order == right.order)
+    ):
+        return InterCoefficient.restore(
+            left.np_arrays[0], left.np_arrays[1] + right.np_arrays[1],
+            left.dt
+        )
+    else:
+        # It would be possible to add them by merging tlist.
+        return SumCoefficient(left, right)
+
+
+@cython.auto_pickle(True)
+cdef class SumCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` built from the sum of two other coefficients.
+
+    A :obj:`SumCoefficient` is returned as the result of the addition of two
+    coefficients, e.g. ::
+
+        coefficient("t * t") + coefficient("t")  # SumCoefficient
+    """
+    cdef Coefficient first
+    cdef Coefficient second
+
+    def __init__(self, Coefficient first, Coefficient second):
+        self.first = first
+        self.second = second
+
+    cdef complex _call(self, double t) except *:
+        return self.first._call(t) + self.second._call(t)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return SumCoefficient(self.first.copy(), self.second.copy())
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return SumCoefficient(
+            self.first.replace_arguments(_args, **kwargs),
+            self.second.replace_arguments(_args, **kwargs)
+        )
+
+
+@cython.auto_pickle(True)
+cdef class MulCoefficient(Coefficient):
+    """
+    A :obj:`Coefficient` built from the product of two other coefficients.
+
+    A :obj:`MulCoefficient` is returned as the result of the multiplication of
+    two coefficients, e.g. ::
+
+        coefficient("w * t", args={'w': 1}) * coefficient("t")
+    """
+    cdef Coefficient first
+    cdef Coefficient second
+
+    def __init__(self, Coefficient first, Coefficient second):
+        self.first = first
+        self.second = second
+
+    cdef complex _call(self, double t) except *:
+        return self.first._call(t) * self.second._call(t)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return MulCoefficient(self.first.copy(), self.second.copy())
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return MulCoefficient(
+            self.first.replace_arguments(_args, **kwargs),
+            self.second.replace_arguments(_args, **kwargs)
+        )
+
+
+@cython.auto_pickle(True)
+cdef class ConjCoefficient(Coefficient):
+    """
+    The conjugate of a :obj:`Coefficient`.
+
+    A :obj:`ConjCoefficient` is returned by ``Coefficient.conj()`` and
+    ``qutip.coefficent.conj(Coefficient)``.
+    """
+    cdef Coefficient base
+
+    def __init__(self, Coefficient base):
+        self.base = base
+
+    cdef complex _call(self, double t) except *:
+        return conj(self.base._call(t))
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return ConjCoefficient(self.base.copy())
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return ConjCoefficient(
+            self.base.replace_arguments(_args, **kwargs)
+        )
+
+
+@cython.auto_pickle(True)
+cdef class NormCoefficient(Coefficient):
+    """
+    The L2 :func:`norm` of a :obj:`Coefficient`. A shortcut for
+    ``conj(coeff) * coeff``.
+
+    :obj:`NormCoefficient` is returned by
+    ``qutip.coefficent.norm(Coefficient)``.
+    """
+    cdef Coefficient base
+
+    def __init__(self, Coefficient base):
+        self.base = base
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return NormCoefficient(
+            self.base.replace_arguments(_args, **kwargs)
+        )
+
+    cdef complex _call(self, double t) except *:
+        return norm(self.base._call(t))
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return NormCoefficient(self.base.copy())
diff --git a/qutip/core/cy/complex_math.pxd b/qutip/core/cy/complex_math.pxd
index 5271c33010..43f0fd1793 100644
--- a/qutip/core/cy/complex_math.pxd
+++ b/qutip/core/cy/complex_math.pxd
@@ -1,24 +1,24 @@
-cdef extern from "<complex>" namespace "std" nogil:
-    double         abs(double complex x)
-    double complex acos(double complex x)
-    double complex acosh(double complex x)
-    double         arg(double complex x)
-    double complex asin(double complex x)
-    double complex asinh(double complex x)
-    double complex atan(double complex x)
-    double complex atanh(double complex x)
-    double complex conj(double complex x)
-    double complex cos(double complex x)
-    double complex cosh(double complex x)
-    double complex exp(double complex x)
-    double         imag(double complex x)
-    double complex log(double complex x)
-    double complex log10(double complex x)
-    double         norm(double complex x)
-    double complex proj(double complex x)
-    double         real(double complex x)
-    double complex sin(double complex x)
-    double complex sinh(double complex x)
-    double complex sqrt(double complex x)
-    double complex tan(double complex x)
-    double complex tanh(double complex x)
+cdef extern from "<complex>" namespace "std" nogil:
+    double         abs(double complex x)
+    double complex acos(double complex x)
+    double complex acosh(double complex x)
+    double         arg(double complex x)
+    double complex asin(double complex x)
+    double complex asinh(double complex x)
+    double complex atan(double complex x)
+    double complex atanh(double complex x)
+    double complex conj(double complex x)
+    double complex cos(double complex x)
+    double complex cosh(double complex x)
+    double complex exp(double complex x)
+    double         imag(double complex x)
+    double complex log(double complex x)
+    double complex log10(double complex x)
+    double         norm(double complex x)
+    double complex proj(double complex x)
+    double         real(double complex x)
+    double complex sin(double complex x)
+    double complex sinh(double complex x)
+    double complex sqrt(double complex x)
+    double complex tan(double complex x)
+    double complex tanh(double complex x)
diff --git a/qutip/core/cy/math.pxd b/qutip/core/cy/math.pxd
index 6002bf9cb4..6f304b4916 100644
--- a/qutip/core/cy/math.pxd
+++ b/qutip/core/cy/math.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-cdef double erf(double x)
-
-cdef double complex zerf(double complex Z)
+#cython: language_level=3
+
+cdef double erf(double x)
+
+cdef double complex zerf(double complex Z)
diff --git a/qutip/core/cy/math.pyx b/qutip/core/cy/math.pyx
index e9f113cf45..abdda8c5ae 100644
--- a/qutip/core/cy/math.pyx
+++ b/qutip/core/cy/math.pyx
@@ -1,159 +1,159 @@
-#cython: language_level=3
-
-cimport cython
-from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double real(double complex x)
-    double imag(double complex x)
-
-@cython.boundscheck(False)
-@cython.cdivision(True)
-cdef double erf(double x):
-    """
-    A Cython version of the erf function from the cdflib in SciPy.
-    """
-    cdef double c = 0.564189583547756
-
-    cdef double a[5]
-    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
-                     0.479137145607681e-1, 0.128379167095513]
-
-    cdef double b[3]
-    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
-
-    cdef double p[8]
-    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
-                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
-                     4.51918953711873e2, 3.00459261020162e2]
-
-    cdef double q[8]
-    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
-                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
-                     3.00459260956983e2]
-
-    cdef double r[5]
-    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
-                      4.65807828718470, 2.82094791773523e-1]
-
-    cdef double s[4]
-    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
-                     1.80124575948747e1]
-
-    cdef double ax = fabs(x)
-    cdef double t, x2, top, bot, erf
-
-    if ax <= 0.5:
-        t = x*x
-        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
-        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
-        erf = x * (top/bot)
-        return erf
-    elif ax <= 4.0:
-        x2 = x*x
-        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
-        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
-        erf = 0.5 + (0.5-exp(-x2)*top/bot)
-        if x < 0.0:
-            erf = -erf
-        return erf
-    elif ax < 5.8:
-        x2 = x*x
-        t = 1.0/x2
-        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
-        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
-        erf = (c-top/(x2*bot))/ax
-        erf = 0.5 + (0.5-exp(-x2)*erf)
-        if x < 0.0:
-            erf = -erf
-        return erf
-    else:
-        erf = copysign(1.0, x)
-        return erf
-
-
-#       COMPUTATION OF SPECIAL FUNCTIONS
-#
-#          Shanjie Zhang and Jianming Jin
-#
-#       Copyrighted but permission granted to use code in programs.
-# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
-    
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cdef double complex zerf(double complex Z):
-    """
-    Parameters
-    ----------
-    Z : double complex
-        Input parameter.
-    X : double
-        Real part of Z.
-    Y : double
-        Imag part of Z.
-
-    Returns
-    -------
-    erf(z) : double complex
-    """
-    
-    cdef double EPS = 1e-12
-    cdef double X = real(Z)
-    cdef double Y = imag(Z)
-    cdef double X2 = X * X
-    
-    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
-    
-    cdef size_t K, N
-    
-    if X < 3.5:
-        ER = 1.0
-        R = 1.0
-        W = 0.0
-        for K in range(1, 100):
-            R = R*X2/(K+0.5)
-            ER = ER+R
-            if (fabs(ER-W) < EPS*fabs(ER)):
-                break
-            W = ER
-        C0 = 2.0/sqrt(pi)*X*exp(-X2)
-        ER0 = C0*ER
-    else:
-        ER = 1.0
-        R=1.0
-        for K in range(1, 12):
-            R = -R*(K-0.5)/X2
-            ER = ER+R
-        C0 = exp(-X2)/(X*sqrt(pi))
-        ER0 = 1.0-C0*ER
-    
-    if Y == 0.0:
-        ERR = ER0
-        ERI = 0.0
-    else:
-        CS = cos(2.0*X*Y)
-        SS = sin(2.0*X*Y)
-        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
-        EI1 = exp(-X2)*SS/(2.0*pi*X)
-        ER2 = 0.0
-        W1 = 0.0
-        
-        for N in range(1,100):
-            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
-            if (fabs((ER2-W1)/ER2) < EPS):
-                break
-            W1 = ER2
-        
-        C0 = 2.0*exp(-X2)/pi
-        ERR = ER0+ER1+C0*ER2
-        EI2 = 0.0
-        W2 = 0.0
-        
-        for N in range(1,100):
-            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
-            if (fabs((EI2-W2)/EI2) < EPS):
-                break
-            W2 = EI2
-        ERI = EI1+C0*EI2
-        
-    return ERR + 1j*ERI
+#cython: language_level=3
+
+cimport cython
+from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign)
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double real(double complex x)
+    double imag(double complex x)
+
+@cython.boundscheck(False)
+@cython.cdivision(True)
+cdef double erf(double x):
+    """
+    A Cython version of the erf function from the cdflib in SciPy.
+    """
+    cdef double c = 0.564189583547756
+
+    cdef double a[5]
+    a[:] = [0.771058495001320e-4, -0.133733772997339e-2, 0.323076579225834e-1,
+                     0.479137145607681e-1, 0.128379167095513]
+
+    cdef double b[3]
+    b[:] = [0.301048631703895e-2, 0.538971687740286e-1, .375795757275549]
+
+    cdef double p[8]
+    p[:] = [-1.36864857382717e-7, 5.64195517478974e-1, 7.21175825088309,
+                     4.31622272220567e1, 1.52989285046940e2, 3.39320816734344e2,
+                     4.51918953711873e2, 3.00459261020162e2]
+
+    cdef double q[8]
+    q[:]= [1.0, 1.27827273196294e1, 7.70001529352295e1, 2.77585444743988e2,
+                     6.38980264465631e2, 9.31354094850610e2, 7.90950925327898e2,
+                     3.00459260956983e2]
+
+    cdef double r[5]
+    r[:] = [2.10144126479064, 2.62370141675169e1, 2.13688200555087e1,
+                      4.65807828718470, 2.82094791773523e-1]
+
+    cdef double s[4]
+    s[:] = [9.41537750555460e1, 1.87114811799590e2, 9.90191814623914e1,
+                     1.80124575948747e1]
+
+    cdef double ax = fabs(x)
+    cdef double t, x2, top, bot, erf
+
+    if ax <= 0.5:
+        t = x*x
+        top = ((((a[0]*t+a[1])*t+a[2])*t+a[3])*t+a[4]) + 1.0
+        bot = ((b[0]*t+b[1])*t+b[2])*t + 1.0
+        erf = x * (top/bot)
+        return erf
+    elif ax <= 4.0:
+        x2 = x*x
+        top = ((((((p[0]*ax+p[1])*ax+p[2])*ax+p[3])*ax+p[4])*ax+p[5])*ax+p[6])*ax + p[7]
+        bot = ((((((q[0]*ax+q[1])*ax+q[2])*ax+q[3])*ax+q[4])*ax+q[5])*ax+q[6])*ax + q[7]
+        erf = 0.5 + (0.5-exp(-x2)*top/bot)
+        if x < 0.0:
+            erf = -erf
+        return erf
+    elif ax < 5.8:
+        x2 = x*x
+        t = 1.0/x2
+        top = (((r[0]*t+r[1])*t+r[2])*t+r[3])*t + r[4]
+        bot = (((s[0]*t+s[1])*t+s[2])*t+s[3])*t + 1.0
+        erf = (c-top/(x2*bot))/ax
+        erf = 0.5 + (0.5-exp(-x2)*erf)
+        if x < 0.0:
+            erf = -erf
+        return erf
+    else:
+        erf = copysign(1.0, x)
+        return erf
+
+
+#       COMPUTATION OF SPECIAL FUNCTIONS
+#
+#          Shanjie Zhang and Jianming Jin
+#
+#       Copyrighted but permission granted to use code in programs.
+# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
+    
+@cython.cdivision(True)
+@cython.boundscheck(False)
+cdef double complex zerf(double complex Z):
+    """
+    Parameters
+    ----------
+    Z : double complex
+        Input parameter.
+    X : double
+        Real part of Z.
+    Y : double
+        Imag part of Z.
+
+    Returns
+    -------
+    erf(z) : double complex
+    """
+    
+    cdef double EPS = 1e-12
+    cdef double X = real(Z)
+    cdef double Y = imag(Z)
+    cdef double X2 = X * X
+    
+    cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1
+    
+    cdef size_t K, N
+    
+    if X < 3.5:
+        ER = 1.0
+        R = 1.0
+        W = 0.0
+        for K in range(1, 100):
+            R = R*X2/(K+0.5)
+            ER = ER+R
+            if (fabs(ER-W) < EPS*fabs(ER)):
+                break
+            W = ER
+        C0 = 2.0/sqrt(pi)*X*exp(-X2)
+        ER0 = C0*ER
+    else:
+        ER = 1.0
+        R=1.0
+        for K in range(1, 12):
+            R = -R*(K-0.5)/X2
+            ER = ER+R
+        C0 = exp(-X2)/(X*sqrt(pi))
+        ER0 = 1.0-C0*ER
+    
+    if Y == 0.0:
+        ERR = ER0
+        ERI = 0.0
+    else:
+        CS = cos(2.0*X*Y)
+        SS = sin(2.0*X*Y)
+        ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X)
+        EI1 = exp(-X2)*SS/(2.0*pi*X)
+        ER2 = 0.0
+        W1 = 0.0
+        
+        for N in range(1,100):
+            ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS)
+            if (fabs((ER2-W1)/ER2) < EPS):
+                break
+            W1 = ER2
+        
+        C0 = 2.0*exp(-X2)/pi
+        ERR = ER0+ER1+C0*ER2
+        EI2 = 0.0
+        W2 = 0.0
+        
+        for N in range(1,100):
+            EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS)
+            if (fabs((EI2-W2)/EI2) < EPS):
+                break
+            W2 = EI2
+        ERI = EI1+C0*EI2
+        
+    return ERR + 1j*ERI
diff --git a/qutip/core/cy/openmp/bench_openmp.py b/qutip/core/cy/openmp/bench_openmp.py
index 88868a8200..84db486bb5 100644
--- a/qutip/core/cy/openmp/bench_openmp.py
+++ b/qutip/core/cy/openmp/bench_openmp.py
@@ -1,154 +1,154 @@
-import numpy as np
-from qutip.settings import settings as qset
-from timeit import default_timer as timer
-
-
-def _min_timer(function, *args, **kwargs):
-    min_time = 1e6
-    for kk in range(10000):
-        t0 = timer()
-        function(*args, **kwargs)
-        t1 = timer()
-        min_time = min(min_time, t1-t0)
-    return min_time
-
-
-def system_bench(func, dims):
-    from qutip.random_objects import rand_ket
-    ratio = 0
-    ratio_old = 0
-    nnz_old = 0
-    for N in dims:
-        L = func(N).data
-        vec = rand_ket(L.shape[0], 0.25).full().ravel()
-        nnz = L.nnz
-        out = np.zeros_like(vec)
-        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
-        out = np.zeros_like(vec)
-        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
-        ratio = ser/par
-        if ratio > 1:
-            break
-        nnz_old = nnz
-        ratio_old = ratio
-    if ratio > 1:
-        rate = (ratio-ratio_old)/(nnz-nnz_old)
-        return int((1.0-ratio_old)/rate+nnz_old)
-    else:
-        return -1
-
-
-def calculate_openmp_thresh():
-    # if qset.num_cpus == 1:
-    #    return qset.openmp_thresh
-    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
-    jc_result = system_bench(_jc_liouvillian, jc_dims)
-
-    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
-    opto_result = system_bench(_opto_liouvillian, opto_dims)
-
-    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
-    spin_result = system_bench(_spin_hamiltonian, spin_dims)
-
-    # Double result to be conservative
-    thresh = 2*int(max([jc_result, opto_result, spin_result]))
-    if thresh < 0:
-        thresh = np.iinfo(np.int32).max
-    return thresh
-
-
-def _jc_liouvillian(N):
-    from qutip.core import tensor, destroy, qeye, liouvillian
-    wc = 2*np.pi * 1.0   # cavity frequency
-    wa = 2*np.pi * 1.0   # atom frequency
-    g = 2*np.pi * 0.05   # coupling strength
-    kappa = 0.005        # cavity dissipation rate
-    gamma = 0.05         # atom dissipation rate
-    n_th_a = 1           # temperature in frequency units
-    use_rwa = 0
-    # operators
-    a = tensor(destroy(N), qeye(2))
-    sm = tensor(qeye(N), destroy(2))
-    # Hamiltonian
-    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
-    c_op_list = []
-
-    rate = kappa * (1 + n_th_a)
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a)
-
-    rate = kappa * n_th_a
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a.dag())
-
-    rate = gamma
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sm)
-
-    return liouvillian(H, c_op_list)
-
-
-def _opto_liouvillian(N):
-    from qutip.core import tensor, destroy, qeye, liouvillian
-    Nc = 5                      # Number of cavity states
-    Nm = N                     # Number of mech states
-    kappa = 0.3                 # Cavity damping rate
-    E = 0.1                     # Driving Amplitude
-    g0 = 2.4*kappa              # Coupling strength
-    Qm = 1e4                    # Mech quality factor
-    gamma = 1/Qm                # Mech damping rate
-    n_th = 1                    # Mech bath temperature
-    delta = -0.43               # Detuning
-    a = tensor(destroy(Nc), qeye(Nm))
-    b = tensor(qeye(Nc), destroy(Nm))
-    num_b = b.dag()*b
-    num_a = a.dag()*a
-    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
-    cc = np.sqrt(kappa)*a
-    cm = np.sqrt(gamma*(1.0 + n_th))*b
-    cp = np.sqrt(gamma*n_th)*b.dag()
-    c_ops = [cc, cm, cp]
-    return liouvillian(H, c_ops)
-
-
-def _spin_hamiltonian(N):
-    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
-    # array of spin energy splittings and coupling strengths. here we use
-    # uniform parameters, but in general we don't have too
-    h = 2*np.pi * 1.0 * np.ones(N)
-    Jz = 2*np.pi * 0.1 * np.ones(N)
-    Jx = 2*np.pi * 0.1 * np.ones(N)
-    Jy = 2*np.pi * 0.1 * np.ones(N)
-    # dephasing rate
-
-    si = qeye(2)
-    sx = sigmax()
-    sy = sigmay()
-    sz = sigmaz()
-
-    sx_list = []
-    sy_list = []
-    sz_list = []
-
-    for n in range(N):
-        op_list = [si] * N
-        op_list[n] = sx
-        sx_list.append(tensor(op_list))
-        op_list[n] = sy
-        sy_list.append(tensor(op_list))
-        op_list[n] = sz
-        sz_list.append(tensor(op_list))
-
-    # construct the hamiltonian
-    H = 0
-
-    # energy splitting terms
-    for n in range(N):
-        H += - 0.5 * h[n] * sz_list[n]
-
-    # interaction terms
-    for n in range(N-1):
-        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
-        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
-        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
-    return H
+import numpy as np
+from qutip.settings import settings as qset
+from timeit import default_timer as timer
+
+
+def _min_timer(function, *args, **kwargs):
+    min_time = 1e6
+    for kk in range(10000):
+        t0 = timer()
+        function(*args, **kwargs)
+        t1 = timer()
+        min_time = min(min_time, t1-t0)
+    return min_time
+
+
+def system_bench(func, dims):
+    from qutip.random_objects import rand_ket
+    ratio = 0
+    ratio_old = 0
+    nnz_old = 0
+    for N in dims:
+        L = func(N).data
+        vec = rand_ket(L.shape[0], 0.25).full().ravel()
+        nnz = L.nnz
+        out = np.zeros_like(vec)
+        ser = _min_timer(_spmvpy, L.data, L.indices, L.indptr, vec, 1, out)
+        out = np.zeros_like(vec)
+        par = _min_timer(_spmvpy_openmp, L.data, L.indices, L.indptr, vec, 1, out, 2)
+        ratio = ser/par
+        if ratio > 1:
+            break
+        nnz_old = nnz
+        ratio_old = ratio
+    if ratio > 1:
+        rate = (ratio-ratio_old)/(nnz-nnz_old)
+        return int((1.0-ratio_old)/rate+nnz_old)
+    else:
+        return -1
+
+
+def calculate_openmp_thresh():
+    # if qset.num_cpus == 1:
+    #    return qset.openmp_thresh
+    jc_dims = np.unique(np.logspace(0.45, 1.78, 20, dtype=int))
+    jc_result = system_bench(_jc_liouvillian, jc_dims)
+
+    opto_dims = np.unique(np.logspace(0.4, 1.33, 12, dtype=int))
+    opto_result = system_bench(_opto_liouvillian, opto_dims)
+
+    spin_dims = np.unique(np.logspace(0.45, 1.17, 10, dtype=int))
+    spin_result = system_bench(_spin_hamiltonian, spin_dims)
+
+    # Double result to be conservative
+    thresh = 2*int(max([jc_result, opto_result, spin_result]))
+    if thresh < 0:
+        thresh = np.iinfo(np.int32).max
+    return thresh
+
+
+def _jc_liouvillian(N):
+    from qutip.core import tensor, destroy, qeye, liouvillian
+    wc = 2*np.pi * 1.0   # cavity frequency
+    wa = 2*np.pi * 1.0   # atom frequency
+    g = 2*np.pi * 0.05   # coupling strength
+    kappa = 0.005        # cavity dissipation rate
+    gamma = 0.05         # atom dissipation rate
+    n_th_a = 1           # temperature in frequency units
+    use_rwa = 0
+    # operators
+    a = tensor(destroy(N), qeye(2))
+    sm = tensor(qeye(N), destroy(2))
+    # Hamiltonian
+    H = wc*a.dag()*a + wa*sm.dag()*sm + g*(a.dag()*sm + a*sm.dag())
+    c_op_list = []
+
+    rate = kappa * (1 + n_th_a)
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a)
+
+    rate = kappa * n_th_a
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a.dag())
+
+    rate = gamma
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sm)
+
+    return liouvillian(H, c_op_list)
+
+
+def _opto_liouvillian(N):
+    from qutip.core import tensor, destroy, qeye, liouvillian
+    Nc = 5                      # Number of cavity states
+    Nm = N                     # Number of mech states
+    kappa = 0.3                 # Cavity damping rate
+    E = 0.1                     # Driving Amplitude
+    g0 = 2.4*kappa              # Coupling strength
+    Qm = 1e4                    # Mech quality factor
+    gamma = 1/Qm                # Mech damping rate
+    n_th = 1                    # Mech bath temperature
+    delta = -0.43               # Detuning
+    a = tensor(destroy(Nc), qeye(Nm))
+    b = tensor(qeye(Nc), destroy(Nm))
+    num_b = b.dag()*b
+    num_a = a.dag()*a
+    H = -delta*(num_a)+num_b+g0*(b.dag()+b)*num_a+E*(a.dag()+a)
+    cc = np.sqrt(kappa)*a
+    cm = np.sqrt(gamma*(1.0 + n_th))*b
+    cp = np.sqrt(gamma*n_th)*b.dag()
+    c_ops = [cc, cm, cp]
+    return liouvillian(H, c_ops)
+
+
+def _spin_hamiltonian(N):
+    from qutip.core import tensor, qeye, sigmax, sigmay, sigmaz
+    # array of spin energy splittings and coupling strengths. here we use
+    # uniform parameters, but in general we don't have too
+    h = 2*np.pi * 1.0 * np.ones(N)
+    Jz = 2*np.pi * 0.1 * np.ones(N)
+    Jx = 2*np.pi * 0.1 * np.ones(N)
+    Jy = 2*np.pi * 0.1 * np.ones(N)
+    # dephasing rate
+
+    si = qeye(2)
+    sx = sigmax()
+    sy = sigmay()
+    sz = sigmaz()
+
+    sx_list = []
+    sy_list = []
+    sz_list = []
+
+    for n in range(N):
+        op_list = [si] * N
+        op_list[n] = sx
+        sx_list.append(tensor(op_list))
+        op_list[n] = sy
+        sy_list.append(tensor(op_list))
+        op_list[n] = sz
+        sz_list.append(tensor(op_list))
+
+    # construct the hamiltonian
+    H = 0
+
+    # energy splitting terms
+    for n in range(N):
+        H += - 0.5 * h[n] * sz_list[n]
+
+    # interaction terms
+    for n in range(N-1):
+        H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1]
+        H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1]
+        H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1]
+    return H
diff --git a/qutip/core/cy/openmp/parfuncs.pxd b/qutip/core/cy/openmp/parfuncs.pxd
index 73a4186df9..a8a14bea5a 100644
--- a/qutip/core/cy/openmp/parfuncs.pxd
+++ b/qutip/core/cy/openmp/parfuncs.pxd
@@ -1,9 +1,9 @@
-#cython: language_level=3
-
-cimport numpy as cnp
-cimport cython
-
-cdef void spmvpy_openmp(
-    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
-    unsigned int nrows, unsigned int nthr,
-)
+#cython: language_level=3
+
+cimport numpy as cnp
+cimport cython
+
+cdef void spmvpy_openmp(
+    complex *data, int *ind, int *ptr, complex * vec, complex a, complex * out,
+    unsigned int nrows, unsigned int nthr,
+)
diff --git a/qutip/core/cy/openmp/parfuncs.pyx b/qutip/core/cy/openmp/parfuncs.pyx
index 382c75b461..919a209ea1 100644
--- a/qutip/core/cy/openmp/parfuncs.pyx
+++ b/qutip/core/cy/openmp/parfuncs.pyx
@@ -1,13 +1,13 @@
-#cython: language_level=3
-
-cdef extern from "src/zspmv_openmp.hpp" nogil:
-    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
-                double complex a, double complex *out, int nrows, int nthr)
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
-                               complex * vec, complex a, complex * out,
-                               unsigned int nrows, unsigned int nthr):
-    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
+#cython: language_level=3
+
+cdef extern from "src/zspmv_openmp.hpp" nogil:
+    void zspmvpy_openmp(double complex *data, int *ind, int *ptr, double complex *vec,
+                double complex a, double complex *out, int nrows, int nthr)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef inline void spmvpy_openmp(complex * data, int * ind, int * ptr,
+                               complex * vec, complex a, complex * out,
+                               unsigned int nrows, unsigned int nthr):
+    zspmvpy_openmp(data, ind, ptr, vec, a, out, nrows, nthr)
diff --git a/qutip/core/cy/openmp/src/zspmv_openmp.cpp b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
index f6b42c3ab3..7e98b93412 100644
--- a/qutip/core/cy/openmp/src/zspmv_openmp.cpp
+++ b/qutip/core/cy/openmp/src/zspmv_openmp.cpp
@@ -1,166 +1,166 @@
-#include <complex>
-#include <omp.h>
-
-#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
-#include <pmmintrin.h>
-void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-            const int * __restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-            std::complex<double> * __restrict__ out, const unsigned int nrows,
-            const unsigned int nthr)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    #pragma omp parallel for \
-        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        num4 = _mm_setzero_pd();
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
-    }
-}
-#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
-void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-            const int * __restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-            std::complex<double> * __restrict__ out, const unsigned int nrows,
-            const unsigned int nthr)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    #pragma omp parallel for \
-        private(row,dot,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
-    }
-}
-#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
-#include <pmmintrin.h>
-void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
-            const int * __restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a,
-            std::complex<double> * __restrict out, const int nrows,
-            const unsigned int nthr)
-{
-    int row, jj;
-    int row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    #pragma omp parallel for \
-        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        num4 = _mm_setzero_pd();
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
-    }
-}
-#elif defined(_MSC_VER) // Visual Studio no AVX
-void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
-            const int * __restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a,
-            std::complex<double> * __restrict out, const int nrows,
-            const unsigned int nthr)
-{
-    int row, jj;
-    int row_start, row_end;
-    std::complex<double> dot;
-    #pragma omp parallel for \
-        private(row,dot,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
-    }
-}
-#else // Everything else
-void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
-            const int * ptr,
-            const std::complex<double> * vec, const std::complex<double> a,
-            std::complex<double> * out, const unsigned int nrows,
-            const unsigned int nthr)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    #pragma omp parallel for \
-        private(row,dot,row_start,row_end,jj) \
-        shared(data,ind,ptr,out,vec) schedule(static) \
-        num_threads(nthr)
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
-    }
-}
-#endif
+#include <complex>
+#include <omp.h>
+
+#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
+#include <pmmintrin.h>
+void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
+            const int * __restrict__ ptr,
+            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
+            std::complex<double> * __restrict__ out, const unsigned int nrows,
+            const unsigned int nthr)
+{
+    size_t row, jj;
+    unsigned int row_start, row_end;
+    __m128d num1, num2, num3, num4;
+    #pragma omp parallel for \
+        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        num4 = _mm_setzero_pd();
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
+            num3 = _mm_mul_pd(num2, num1);
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+            num2 = _mm_shuffle_pd(num2, num2, 1);
+            num2 = _mm_mul_pd(num2, num1);
+            num3 = _mm_addsub_pd(num3, num2);
+            num4 = _mm_add_pd(num3, num4);
+        }
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+        num3 = _mm_mul_pd(num4, num1);
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+        num4 = _mm_shuffle_pd(num4, num4, 1);
+        num4 = _mm_mul_pd(num4, num1);
+        num3 = _mm_addsub_pd(num3, num4);
+        num2 = _mm_loadu_pd((double *)&out[row]);
+        num3 = _mm_add_pd(num2, num3);
+        _mm_storeu_pd((double *)&out[row], num3);
+    }
+}
+#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
+void zspmvpy_openmp(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
+            const int * __restrict__ ptr,
+            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
+            std::complex<double> * __restrict__ out, const unsigned int nrows,
+            const unsigned int nthr)
+{
+    size_t row, jj;
+    unsigned int row_start, row_end;
+    std::complex<double> dot;
+    #pragma omp parallel for \
+        private(row,dot,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            dot += data[jj]*vec[ind[jj]];
+        }
+        out[row] += a*dot;
+    }
+}
+#elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
+#include <pmmintrin.h>
+void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
+            const int * __restrict ptr,
+            const std::complex<double> * __restrict vec, const std::complex<double> a,
+            std::complex<double> * __restrict out, const int nrows,
+            const unsigned int nthr)
+{
+    int row, jj;
+    int row_start, row_end;
+    __m128d num1, num2, num3, num4;
+    #pragma omp parallel for \
+        private(row,num1,num2,num3,num4,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        num4 = _mm_setzero_pd();
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
+            num3 = _mm_mul_pd(num2, num1);
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+            num2 = _mm_shuffle_pd(num2, num2, 1);
+            num2 = _mm_mul_pd(num2, num1);
+            num3 = _mm_addsub_pd(num3, num2);
+            num4 = _mm_add_pd(num3, num4);
+        }
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+        num3 = _mm_mul_pd(num4, num1);
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+        num4 = _mm_shuffle_pd(num4, num4, 1);
+        num4 = _mm_mul_pd(num4, num1);
+        num3 = _mm_addsub_pd(num3, num4);
+        num2 = _mm_loadu_pd((double *)&out[row]);
+        num3 = _mm_add_pd(num2, num3);
+        _mm_storeu_pd((double *)&out[row], num3);
+    }
+}
+#elif defined(_MSC_VER) // Visual Studio no AVX
+void zspmvpy_openmp(const std::complex<double> * __restrict data, const int * __restrict ind,
+            const int * __restrict ptr,
+            const std::complex<double> * __restrict vec, const std::complex<double> a,
+            std::complex<double> * __restrict out, const int nrows,
+            const unsigned int nthr)
+{
+    int row, jj;
+    int row_start, row_end;
+    std::complex<double> dot;
+    #pragma omp parallel for \
+        private(row,dot,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            dot += data[jj]*vec[ind[jj]];
+        }
+        out[row] += a*dot;
+    }
+}
+#else // Everything else
+void zspmvpy_openmp(const std::complex<double> * data, const int * ind,
+            const int * ptr,
+            const std::complex<double> * vec, const std::complex<double> a,
+            std::complex<double> * out, const unsigned int nrows,
+            const unsigned int nthr)
+{
+    size_t row, jj;
+    unsigned int row_start, row_end;
+    std::complex<double> dot;
+    #pragma omp parallel for \
+        private(row,dot,row_start,row_end,jj) \
+        shared(data,ind,ptr,out,vec) schedule(static) \
+        num_threads(nthr)
+    for (row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = ptr[row];
+        row_end = ptr[row+1];
+        for (jj=row_start; jj <row_end; jj++)
+        {
+            dot += data[jj]*vec[ind[jj]];
+        }
+        out[row] += a*dot;
+    }
+}
+#endif
diff --git a/qutip/core/cy/openmp/utilities.py b/qutip/core/cy/openmp/utilities.py
index ac5bab8676..9627576919 100644
--- a/qutip/core/cy/openmp/utilities.py
+++ b/qutip/core/cy/openmp/utilities.py
@@ -1,41 +1,41 @@
-import os
-from qutip.settings import settings as qset
-
-
-def check_use_openmp(options):
-    """
-    Check to see if OPENMP should be used in dynamic solvers.
-    """
-    # TODO: sort this out.
-    return False
-    """
-    force_omp = False
-    if qset.has_openmp:
-        if options.use_openmp is None:
-            options.use_openmp = True
-        else:
-            force_omp = bool(options.use_openmp)
-    elif (not qset.has_openmp) and options.use_openmp:
-        raise Exception('OPENMP not available.')
-    else:
-        options.use_openmp = False
-        force_omp = False
-    # Disable OPENMP in parallel mode unless explicitly set.
-    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
-        options.use_openmp = False"""
-
-
-def use_openmp():
-    """
-    Check for using openmp in general cases outside of dynamics
-    """
-    return False
-    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
-        return True
-    else:
-        return False
-
-
-def openmp_components(ptr_list):
-    return np.array([False for ptr in ptr_list], dtype=bool)
-    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
+import os
+from qutip.settings import settings as qset
+
+
+def check_use_openmp(options):
+    """
+    Check to see if OPENMP should be used in dynamic solvers.
+    """
+    # TODO: sort this out.
+    return False
+    """
+    force_omp = False
+    if qset.has_openmp:
+        if options.use_openmp is None:
+            options.use_openmp = True
+        else:
+            force_omp = bool(options.use_openmp)
+    elif (not qset.has_openmp) and options.use_openmp:
+        raise Exception('OPENMP not available.')
+    else:
+        options.use_openmp = False
+        force_omp = False
+    # Disable OPENMP in parallel mode unless explicitly set.
+    if not force_omp and os.environ['QUTIP_IN_PARALLEL'] == 'TRUE':
+        options.use_openmp = False"""
+
+
+def use_openmp():
+    """
+    Check for using openmp in general cases outside of dynamics
+    """
+    return False
+    if qset.has_openmp and os.environ['QUTIP_IN_PARALLEL'] != 'TRUE':
+        return True
+    else:
+        return False
+
+
+def openmp_components(ptr_list):
+    return np.array([False for ptr in ptr_list], dtype=bool)
+    return np.array([ptr[-1] >= qset.openmp_thresh for ptr in ptr_list], dtype=bool)
diff --git a/qutip/core/cy/qobjevo.pxd b/qutip/core/cy/qobjevo.pxd
index 73b7f01b91..07e0d3df7c 100644
--- a/qutip/core/cy/qobjevo.pxd
+++ b/qutip/core/cy/qobjevo.pxd
@@ -1,24 +1,24 @@
-#cython: language_level=3
-
-from qutip.core.data cimport Dense, Data
-from qutip.core.data.base cimport idxint
-
-cdef class QobjEvo:
-    cdef:
-        list elements
-        readonly list dims
-        readonly (idxint, idxint) shape
-        readonly str type
-        readonly str superrep
-        int _issuper
-        int _isoper
-
-    cpdef Data _call(QobjEvo self, double t)
-
-    cdef object _prepare(QobjEvo self, object t, Data state=*)
-
-    cpdef object expect_data(QobjEvo self, object t, Data state)
-
-    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
-
-    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
+#cython: language_level=3
+
+from qutip.core.data cimport Dense, Data
+from qutip.core.data.base cimport idxint
+
+cdef class QobjEvo:
+    cdef:
+        list elements
+        readonly list dims
+        readonly (idxint, idxint) shape
+        readonly str type
+        readonly str superrep
+        int _issuper
+        int _isoper
+
+    cpdef Data _call(QobjEvo self, double t)
+
+    cdef object _prepare(QobjEvo self, object t, Data state=*)
+
+    cpdef object expect_data(QobjEvo self, object t, Data state)
+
+    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *
+
+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=*)
diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index cddeb5d09d..513d3ae519 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -1,1019 +1,1019 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
-
-import numpy as np
-import numbers
-import itertools
-from functools import partial
-
-import qutip
-from .. import Qobj
-from .. import data as _data
-from ..coefficient import coefficient, CompilationOptions
-from ._element import *
-from ..dimensions import type_from_dims
-from qutip.settings import settings
-
-from qutip.core.cy._element cimport _BaseElement
-from qutip.core.data cimport Dense, Data, dense
-from qutip.core.data.expect cimport *
-from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
-from qutip.core.cy.coefficient cimport Coefficient
-from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
-from libc.math cimport fabs
-
-__all__ = ['QobjEvo']
-
-cdef class QobjEvo:
-    """
-    A class for representing time-dependent quantum objects, such as quantum
-    operators and states.
-
-    Importantly, :obj:`~QobjEvo` instances are used to represent such
-    time-dependent quantum objects when working with QuTiP solvers.
-
-    A :obj:`~QobjEvo` instance may be constructed from one of the following:
-
-      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
-        value of the quantum object at time ``t``.
-
-      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
-        any item that can be used to construct a coefficient (e.g. a function,
-        a numpy array of coefficient values, a string expression).
-
-      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
-
-      * a list of such callables, pairs or :obj:`~Qobj`\s.
-
-      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
-        are ignored except ``args`` which, if passed, replaces the existing
-        arguments).
-
-    Parameters
-    ----------
-    Q_object : callable, list or Qobj
-        A specification of the time-depedent quantum object. See the
-        paragraph above for a full description and the examples section below
-        for examples.
-
-    args : dict, optional
-        A dictionary that contains the arguments for the coefficients.
-        Arguments may be omitted if no function or string coefficients that
-        require arguments are present.
-
-    tlist : array-like, optional
-        A list of times corresponding to the values of the coefficients
-        supplied as numpy arrays. If no coefficients are supplied as numpy
-        arrays, ``tlist`` may be omitted, otherwise it is required.
-
-        The times in ``tlist`` do not need to be equidistant, but must
-        be sorted.
-
-        By default, a cubic spline interpolation will be used to interpolate
-        the value of the (numpy array) coefficients at time ``t``. If the
-        coefficients are to be treated as step functions, pass the argument
-        ``order=0`` (see below).
-
-    order : int, default=3
-        Order of the spline interpolation that is to be used to interpolate
-        the value of the (numpy array) coefficients at time ``t``.
-        ``0`` use previous or left value.
-
-    copy : bool, default=True
-        Whether to make a copy of the :obj:`Qobj` instances supplied in
-        the ``Q_object`` parameter.
-
-    compress : bool, default=True
-        Whether to compress the :obj:`QobjEvo` instance terms after the
-        instance has been created.
-
-        This sums the constant terms in a single term and combines
-        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
-        pair containing the sum of the coefficients.
-
-        See :meth:`compress`.
-
-    function_style : {None, "pythonic", "dict", "auto"}
-        The style of function signature used by callables in ``Q_object``.
-        If style is ``None``, the value of
-        ``qutip.settings.core["function_coefficient_style"]``
-        is used. Otherwise the supplied value overrides the global setting.
-
-
-    boundary_conditions : 2-Tuple, str or None, optional
-        Boundary conditions for spline evaluation. Default value is `None`.
-        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
-        Refer to Scipy's documentation for further details:
-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
-
-
-    Attributes
-    ----------
-    dims : list
-        List of dimensions keeping track of the tensor structure.
-
-    shape : (int, int)
-        List of dimensions keeping track of the tensor structure.
-
-    type : str
-        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
-        'operator-bra', or 'super'.
-
-    superrep : str
-        Representation used if `type` is 'super'. One of 'super'
-        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
-
-    Examples
-    --------
-
-    A :obj:`~QobjEvo` constructed from a function:
-
-    .. code-block::
-
-        def f(t, args):
-            return qutip.qeye(N) * np.exp(args['w'] * t)
-
-        QobjEvo(f, args={'w': 1j})
-
-
-    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
-    ``[Qobj, Coefficient]`` pairs:
-
-    .. code-block::
-
-        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
-
-    The coefficients may be specified either using a :obj:`~Coefficient`
-    object or by a function, string, numpy array or any object that
-    can be passed to the :func:`~coefficient` function. See the documentation
-    of :func:`coefficient` for a full description.
-
-    An example of a coefficient specified by a function:
-
-    .. code-block::
-
-        def f1_t(t, args):
-            return np.exp(-1j * t * args["w1"])
-
-        QobjEvo([[H1, f1_t]], args={"w1": 1.})
-
-    And of coefficients specified by string expressions:
-
-    .. code-block::
-
-        H = QobjEvo(
-            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
-            args={"w1": 1., "w2": 2.}
-        )
-
-    Coefficients maybe also be expressed as numpy arrays giving a list
-    of the coefficient values:
-
-    .. code-block:: python
-
-        tlist = np.logspace(-5, 0, 100)
-        H = QobjEvo(
-            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
-            tlist=tlist
-        )
-
-    The coeffients array must have the same len as the tlist.
-
-    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
-    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
-
-    .. code-block:: python
-
-        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
-        qevo = H0 + H1 * coeff
-
-    """
-    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
-                 order=3, copy=True, compress=True,
-                 function_style=None, boundary_conditions=None):
-        if isinstance(Q_object, QobjEvo):
-            self.dims = Q_object.dims.copy()
-            self.shape = Q_object.shape
-            self.type = Q_object.type
-            self._issuper = (<QobjEvo> Q_object)._issuper
-            self._isoper = (<QobjEvo> Q_object)._isoper
-            self.elements = (<QobjEvo> Q_object).elements.copy()
-            if args:
-                self.arguments(args)
-            if compress:
-                self.compress()
-            return
-
-        self.elements = []
-        self.dims = None
-        self.shape = (0, 0)
-        self._issuper = -1
-        self._isoper = -1
-        args = args or {}
-
-        if (
-            isinstance(Q_object, list)
-            and len(Q_object) == 2
-            and isinstance(Q_object[0], Qobj)
-            and not isinstance(Q_object[1], (Qobj, list))
-        ):
-            # The format is [Qobj, coefficient]
-            Q_object = [Q_object]
-
-        if isinstance(Q_object, list):
-            for op in Q_object:
-                self.elements.append(
-                    self._read_element(
-                        op, copy=copy, tlist=tlist, args=args, order=order,
-                        function_style=function_style,
-                        boundary_conditions=boundary_conditions
-                    )
-                )
-        else:
-            self.elements.append(
-                self._read_element(
-                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
-                    function_style=function_style,
-                    boundary_conditions=boundary_conditions
-                )
-            )
-
-        if compress:
-            self.compress()
-
-    def __repr__(self):
-        cls = self.__class__.__name__
-        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
-        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
-        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
-        return repr_str
-
-    def _read_element(self, op, copy, tlist, args, order, function_style, 
-                      boundary_conditions):
-        """ Read a Q_object item and return an element for that item. """
-        if isinstance(op, Qobj):
-            out = _ConstantElement(op.copy() if copy else op)
-            qobj = op
-        elif isinstance(op, list):
-            out = _EvoElement(
-                op[0].copy() if copy else op[0],
-                coefficient(op[1], tlist=tlist, args=args, order=order, 
-                            boundary_conditions=boundary_conditions)
-            )
-            qobj = op[0]
-        elif isinstance(op, _BaseElement):
-            out = op
-            qobj = op.qobj(0)
-        elif callable(op):
-            out = _FuncElement(op, args, style=function_style)
-            qobj = out.qobj(0)
-            if not isinstance(qobj, Qobj):
-                raise TypeError(
-                    "Function based time-dependent elements must have the"
-                    " signature f(t: double, args: dict) -> Qobj, but"
-                    " {!r} returned: {!r}".format(op, qobj)
-                )
-        else:
-            raise TypeError(
-                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
-                " or a function f(t: double, args: dict) -> Qobj, but"
-                " received: {!r}".format(op)
-            )
-
-        if self.dims is None:
-            self.dims = qobj.dims
-            self.shape = qobj.shape
-            self.type = qobj.type
-            self.superrep = qobj.superrep
-        elif self.dims != qobj.dims or self.shape != qobj.shape:
-            raise ValueError(
-                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
-                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
-                f" and shape {self.shape!r}."
-            )
-        elif self.type != qobj.type:
-            raise ValueError(
-                f"QobjEvo term {op!r} has type {qobj.type!r} but "
-                f"previous terms had type {self.type!r}."
-            )
-        elif self.superrep != qobj.superrep:
-            raise ValueError(
-                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
-                f"previous terms had superrep {self.superrep!r}."
-            )
-
-        return out
-
-    @classmethod
-    def _restore(cls, elements, dims, shape, type, superrep, flags):
-        """Recreate a QobjEvo without using __init__. """
-        cdef QobjEvo out = cls.__new__(cls)
-        out.elements = elements
-        out.dims = dims
-        out.shape = shape
-        out.type = type
-        out.superrep = superrep
-        out._issuper, out._isoper = flags
-        return out
-
-    def _getstate(self):
-        """ Obtain the state """
-        # For jax pytree representation
-        # auto_pickle create similar method __getstate__, but since it's
-        # automatically created, it could change depending on cython version
-        # etc., so we create our own.
-        return {
-            "elements": self.elements,
-            "dims": self.dims,
-            "shape": self.shape,
-            "type": self.type,
-            "superrep": self.superrep,
-            "flags": (self._issuper, self._isoper,)
-        }
-
-    def __call__(self, double t, dict _args=None, **kwargs):
-        """
-        Get the :class:`~Qobj` at ``t``.
-
-        Parameters
-        ----------
-        t : float
-            Time at which the ``QobjEvo`` is to be evalued.
-
-        _args : dict [optional]
-            New arguments as a dict. Update args with ``arguments(new_args)``.
-
-        **kwargs :
-            New arguments as a keywors. Update args with
-            ``arguments(**new_args)``.
-
-        .. note::
-            If both the positional ``_args`` and keywords are passed new values
-            from both will be used. If a key is present with both, the
-            ``_args`` dict value will take priority.
-        """
-        if _args is not None or kwargs:
-            if _args is not None:
-                kwargs.update(_args)
-            return QobjEvo(self, args=kwargs)(t)
-
-        t = self._prepare(t, None)
-
-        if self.isconstant:
-            # For constant QobjEvo's, we sum the contained Qobjs directly in
-            # order to retain the cached values of attributes like .isherm when
-            # possible, rather than calling _call(t) which may lose this cached
-            # information.
-            return sum(element.qobj(t) for element in self.elements)
-
-        cdef _BaseElement part = self.elements[0]
-        cdef double complex coeff = part.coeff(t)
-        obj = part.qobj(t)
-        cdef Data out = _data.mul(obj.data, coeff)
-        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
-        for element in self.elements[1:]:
-            part = <_BaseElement> element
-            coeff = part.coeff(t)
-            obj = part.qobj(t)
-            isherm &= <bint> obj._isherm and coeff.imag == 0
-            out = _data.add(out, obj.data, coeff)
-
-        return Qobj(
-            out, dims=self.dims, copy=False, isherm=isherm or None,
-            type=self.type, superrep=self.superrep
-        )
-
-    cpdef Data _call(QobjEvo self, double t):
-        t = self._prepare(t, None)
-        cdef Data out
-        cdef _BaseElement part = self.elements[0]
-        out = _data.mul(part.data(t),
-                        part.coeff(t))
-        for element in self.elements[1:]:
-            part = <_BaseElement> element
-
-            out = _data.add(
-                out,
-                part.data(t),
-                part.coeff(t)
-            )
-        return out
-
-    cdef object _prepare(QobjEvo self, object t, Data state=None):
-        """ Precomputation before computing getting the element at `t`"""
-        # We keep the function for feedback eventually
-        return t
-
-    def copy(QobjEvo self):
-        """Return a copy of this `QobjEvo`"""
-        return QobjEvo(self, compress=False)
-
-    def arguments(QobjEvo self, dict _args=None, **kwargs):
-        """
-        Update the arguments.
-
-        Parameters
-        ----------
-        _args : dict [optional]
-            New arguments as a dict. Update args with ``arguments(new_args)``.
-
-        **kwargs :
-            New arguments as a keywors. Update args with
-            ``arguments(**new_args)``.
-
-        .. note::
-            If both the positional ``_args`` and keywords are passed new values
-            from both will be used. If a key is present with both, the ``_args``
-            dict value will take priority.
-        """
-        if _args is not None:
-            kwargs.update(_args)
-        cache = []
-        self.elements = [
-            element.replace_arguments(kwargs, cache=cache)
-            for element in self.elements
-        ]
-
-
-    ###########################################################################
-    # Math function                                                           #
-    ###########################################################################
-    def __add__(left, right):
-        if isinstance(left, QobjEvo):
-            self = left
-            other = right
-        else:
-            self = right
-            other = left
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        res = self.copy()
-        res += other
-        return res
-
-    def __radd__(self, other):
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        res = self.copy()
-        res += other
-        return res
-
-    def __iadd__(QobjEvo self, other):
-        cdef _BaseElement element
-        if isinstance(other, QobjEvo):
-            if other.dims != self.dims:
-                raise TypeError("incompatible dimensions" +
-                                str(self.dims) + ", " + str(other.dims))
-            for element in (<QobjEvo> other).elements:
-                self.elements.append(element)
-        elif isinstance(other, Qobj):
-            if other.dims != self.dims:
-                raise TypeError("incompatible dimensions" +
-                                str(self.dims) + ", " + str(other.dims))
-            self.elements.append(_ConstantElement(other))
-        elif (
-            isinstance(other, numbers.Number) and
-            self.dims[0] == self.dims[1]
-        ):
-            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
-        else:
-            return NotImplemented
-        return self
-
-    def __sub__(left, right):
-        if isinstance(left, QobjEvo):
-            res = left.copy()
-            res += -right
-            return res
-        else:
-            res = -right.copy()
-            res += left
-            return res
-
-    def __rsub__(self, other):
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        res = -self
-        res += other
-        return res
-
-    def __isub__(self, other):
-        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
-            return NotImplemented
-        self += (-other)
-        return self
-
-    def __matmul__(left, right):
-        cdef QobjEvo res
-        if isinstance(left, QobjEvo):
-            return left.copy().__imatmul__(right)
-        elif isinstance(left, Qobj):
-            if left.dims[1] != (<QobjEvo> right).dims[0]:
-                raise TypeError("incompatible dimensions" +
-                                 str(left.dims[1]) + ", " +
-                                 str((<QobjEvo> right).dims[0]))
-
-            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
-            if type_ is None:
-                raise TypeError(
-                    "incompatible matmul types "
-                    + repr(left.type) + " and " + repr(right.type)
-                )
-
-            res = right.copy()
-            res.dims = [left.dims[0], right.dims[1]]
-            res.shape = (left.shape[0], right.shape[1])
-            res.type = type_
-            left = _ConstantElement(left)
-            res.elements = [left @ element for element in res.elements]
-            res._issuper = -1
-            res._isoper = -1
-            return res
-        else:
-            return NotImplemented
-
-    def __rmatmul__(QobjEvo self, other):
-        cdef QobjEvo res
-        if isinstance(other, Qobj):
-            if other.dims[1] != self.dims[0]:
-                raise TypeError("incompatible dimensions" +
-                                 str(other.dims[1]) + ", " +
-                                 str(self.dims[0]))
-
-            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
-            if type_ is None:
-                raise TypeError(
-                    "incompatible matmul types "
-                    + repr(other.type) + " and " + repr(self.type)
-                )
-
-            res = self.copy()
-            res.dims = [other.dims[0], res.dims[1]]
-            res.shape = (other.shape[0], res.shape[1])
-            res.type = type_
-            other = _ConstantElement(other)
-            res.elements = [other @ element for element in res.elements]
-            res._issuper = -1
-            res._isoper = -1
-            return res
-        else:
-            return NotImplemented
-
-    def __imatmul__(QobjEvo self, other):
-        if isinstance(other, (Qobj, QobjEvo)):
-            if self.dims[1] != other.dims[0]:
-                raise TypeError("incompatible dimensions" +
-                                str(self.dims[1]) + ", " +
-                                str(other.dims[0]))
-
-            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
-            if type_ is None:
-                raise TypeError(
-                    "incompatible matmul types "
-                    + repr(self.type) + " and " + repr(other.type)
-                )
-
-            self.dims = [self.dims[0], other.dims[1]]
-            self.shape = (self.shape[0], other.shape[1])
-            self.type = type_
-            self._issuper = -1
-            self._isoper = -1
-            if isinstance(other, Qobj):
-                other = _ConstantElement(other)
-                self.elements = [element @ other for element in self.elements]
-
-            elif isinstance(other, QobjEvo):
-                self.elements = [left @ right
-                    for left, right in itertools.product(
-                        self.elements, (<QobjEvo> other).elements
-                    )]
-        else:
-            return NotImplemented
-        return self
-
-    def __mul__(left, right):
-        if isinstance(left, QobjEvo):
-            return left.copy().__imul__(right)
-        elif isinstance(left, Qobj):
-            return right.__rmatmul__(left)
-        elif isinstance(left, (numbers.Number, Coefficient)):
-            return right.copy().__imul__(left)
-        else:
-            return NotImplemented
-
-    def __rmul__(self, other):
-        if isinstance(other, Qobj):
-            return self.__rmatmul__(other)
-        else:
-            res = self.copy()
-            res *= other
-            return res
-
-    def __imul__(QobjEvo self, other):
-        if isinstance(other, (Qobj, QobjEvo)):
-            self @= other
-        elif isinstance(other, numbers.Number):
-            self.elements = [element * other for element in self.elements]
-        elif isinstance(other, Coefficient):
-            other = _EvoElement(qutip.qeye(self.dims[1]), other)
-            self.elements = [element @ other for element in self.elements]
-        else:
-            return NotImplemented
-        return self
-
-    def __truediv__(left, right):
-        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
-            res = left.copy()
-            res *= 1 / right
-            return res
-        return NotImplemented
-
-    def __idiv__(self, other):
-        if not isinstance(other, numbers.Number):
-            return NotImplemented
-        self *= 1 / other
-        return self
-
-    def __neg__(self):
-        res = self.copy()
-        res *= -1
-        return res
-
-    ###########################################################################
-    # tensor                                                                  #
-    ###########################################################################
-    def __and__(left, right):
-        """
-        Syntax shortcut for tensor:
-        A & B ==> tensor(A, B)
-        """
-        return qutip.tensor(left, right)
-
-    ###########################################################################
-    # Unary transformation                                                    #
-    ###########################################################################
-    def trans(self):
-        """ Transpose of the quantum object """
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(Qobj.trans)
-                        for element in res.elements]
-        return res
-
-    def conj(self):
-        """Get the element-wise conjugation of the quantum object."""
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(Qobj.conj, True)
-                        for element in res.elements]
-        return res
-
-    def dag(self):
-        """Get the Hermitian adjoint of the quantum object."""
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(Qobj.dag, True)
-                        for element in res.elements]
-        return res
-
-    def to(self, data_type):
-        """
-        Convert the underlying data store of all component into the desired
-        storage representation.
-
-        The different storage representations available are the "data-layer
-        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
-        which respectively construct a dense matrix store and a compressed
-        sparse row one.
-
-        The `QobjEvo` is transformed inplace.
-
-        Parameters
-        ----------
-        data_type : type
-            The data-layer type that the data of this `Qobj` should be
-            converted to.
-
-        Returns
-        -------
-        None
-        """
-        return self.linear_map(partial(Qobj.to, data_type=data_type),
-                               _skip_check=True)
-
-    def tidyup(self, atol=1e-12):
-        """Removes small elements from quantum object."""
-        for element in self.elements:
-            if type(element) is _ConstantElement:
-                element = _ConstantElement(element.qobj(0).tidyup(atol))
-            elif type(element) is _EvoElement:
-                element = _EvoElement(element.qobj(0).tidyup(atol),
-                                      element._coefficient)
-        return self
-
-    def linear_map(self, op_mapping, *, _skip_check=False):
-        """
-        Apply mapping to each Qobj contribution.
-
-        Example:
-        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
-        gives the same result has
-        ``QobjEvo([spre(sigmax()), coeff])``
-
-        Returns
-        -------
-        :class:`.QobjEvo`
-            Modified object
-
-        Notes
-        -----
-        Does not modify the coefficients, thus ``linear_map(conj)`` would not
-        give the the conjugate of the QobjEvo. It's only valid for linear
-        transformations.
-        """
-        if not _skip_check:
-            out = op_mapping(self(0))
-            if not isinstance(out, Qobj):
-                raise TypeError("The op_mapping function must return a Qobj")
-        cdef QobjEvo res = self.copy()
-        res.elements = [element.linear_map(op_mapping) for element in res.elements]
-        res.dims = res.elements[0].qobj(0).dims
-        res.shape = res.elements[0].qobj(0).shape
-        res.type = res.elements[0].qobj(0).type
-        res._issuper = res.elements[0].qobj(0).issuper
-        res._isoper = res.elements[0].qobj(0).isoper
-        if not _skip_check:
-            if res(0) != out:
-                raise ValueError("The mapping is not linear")
-
-        return res
-
-    ###########################################################################
-    # Cleaning and compress                                                   #
-    ###########################################################################
-    def _compress_merge_qobj(self, coeff_elements):
-        """Merge element with matching qobj:
-        ``[A, f1], [A, f2] -> [A, f1+f2]``
-        """
-        cleaned_elements = []
-        # Mimic a dict with Qobj not hashable
-        qobjs = []
-        coeffs = []
-        for element in coeff_elements:
-            for i, qobj in enumerate(qobjs):
-                if element.qobj(0) == qobj:
-                    coeffs[i] = coeffs[i] + element._coefficient
-                    break
-            else:
-                qobjs.append(element.qobj(0))
-                coeffs.append(element._coefficient)
-        for qobj, coeff in zip(qobjs, coeffs):
-            cleaned_elements.append(_EvoElement(qobj, coeff))
-        return cleaned_elements
-
-    def compress(self):
-        """
-        Look for redundance in the :obj:`~QobjEvo` components:
-
-        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
-        summed.
-        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
-
-        Example:
-        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
-
-        The :class:`~QobjEvo` is transformed inplace.
-
-        Returns
-        -------
-        None
-        """
-        cte_elements = []
-        coeff_elements = []
-        func_elements = []
-        for element in self.elements:
-            if type(element) is _ConstantElement:
-                cte_elements.append(element)
-            elif type(element) is _EvoElement:
-                coeff_elements.append(element)
-            else:
-                func_elements.append(element)
-
-        cleaned_elements = []
-        if len(cte_elements) >= 2:
-            # Multiple constant parts
-            cleaned_elements.append(_ConstantElement(
-                sum(element.qobj(0) for element in cte_elements)))
-        else:
-            cleaned_elements += cte_elements
-
-        coeff_elements = self._compress_merge_qobj(coeff_elements)
-        cleaned_elements += coeff_elements + func_elements
-
-        self.elements = cleaned_elements
-
-    def to_list(QobjEvo self):
-        """
-        Restore the QobjEvo to a list form.
-
-        Returns
-        -------
-        list_qevo: list
-            The QobjEvo as a list, element are either :class:`Qobj` for
-            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
-            The original format of the :class:`Coefficient` is not restored.
-            Lastly if the original `QobjEvo` is constructed with a function
-            returning a Qobj, the term is returned as a pair of the original
-            function and args (``dict``).
-        """
-        out = []
-        for element in self.elements:
-            if isinstance(element, _ConstantElement):
-                out.append(element.qobj(0))
-            elif isinstance(element, _EvoElement):
-                coeff = element._coefficient
-                out.append([element.qobj(0), coeff])
-            elif isinstance(element, _FuncElement):
-                func = element._func
-                args = element._args
-                out.append([func, args])
-            else:
-                out.append([element, {}])
-        return out
-
-    ###########################################################################
-    # properties                                                              #
-    ###########################################################################
-    @property
-    def num_elements(self):
-        """Number of parts composing the system"""
-        return len(self.elements)
-
-    @property
-    def isconstant(self):
-        """Does the system change depending on ``t``"""
-        return not any(type(element) is not _ConstantElement
-                       for element in self.elements)
-
-    @property
-    def isoper(self):
-        """Indicates if the system represents an operator."""
-        # TODO: isoper should be part of dims
-        if self._isoper == -1:
-            self._isoper = type_from_dims(self.dims) == "oper"
-        return self._isoper
-
-    @property
-    def issuper(self):
-        """Indicates if the system represents a superoperator."""
-        # TODO: issuper should/will be part of dims
-        # remove self._issuper then
-        if self._issuper == -1:
-            self._issuper = type_from_dims(self.dims) == "super"
-        return self._issuper
-
-    ###########################################################################
-    # operation methods                                                       #
-    ###########################################################################
-    def expect(QobjEvo self, object t, state, check_real=True):
-        """
-        Expectation value of this operator at time ``t`` with the state.
-
-        Parameters
-        ----------
-        t : float
-            Time of the operator to apply.
-
-        state : Qobj
-            right matrix of the product
-
-        check_real : bool (True)
-            Whether to convert the result to a `real` when the imaginary part
-            is smaller than the real part by a dactor of
-            ``settings.core['rtol']``.
-
-        Returns
-        -------
-        expect : float or complex
-            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
-            ``trace(self @ matrix)`` is ``state`` is an operator or
-            operator-ket.
-        """
-        # TODO: remove reading from `settings` for a typed value when options
-        # support property.
-        cdef float herm_rtol = settings.core['rtol']
-        if not isinstance(state, Qobj):
-            raise TypeError("A Qobj state is expected")
-        if not (self.isoper or self.issuper):
-            raise ValueError("Must be an operator or super operator to compute"
-                             " an expectation value")
-        if not (
-            (self.dims[1] == state.dims[0]) or
-            (self.issuper and self.dims[1] == state.dims)
-        ):
-            raise ValueError("incompatible dimensions " + str(self.dims) +
-                             ", " + str(state.dims))
-        out = self.expect_data(t, state.data)
-        if (
-            check_real and
-            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
-        ):
-            return out.real
-        return out
-
-    cpdef object expect_data(QobjEvo self, object t, Data state):
-        """
-        Expectation is defined as ``state.adjoint() @ self @ state`` if
-        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
-        superoperator.  If ``state`` is an operator and ``self`` is an
-        operator, then expectation is ``trace(self @ matrix)``.
-        """
-        if type(state) is Dense:
-            return self._expect_dense(t, state)
-        cdef _BaseElement part
-        cdef object out = 0.
-        cdef Data part_data
-        cdef object expect_func
-        t = self._prepare(t, state)
-        if self.issuper:
-            if state.shape[1] != 1:
-                state = _data.column_stack(state)
-            expect_func = _data.expect_super
-        else:
-            expect_func = _data.expect
-
-        for element in self.elements:
-            part = (<_BaseElement> element)
-            part_data = part.data(t)
-            out += part.coeff(t) * expect_func(part_data, state)
-        return out
-
-    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
-        """For Dense state, ``column_stack_dense`` can be done inplace if in
-        fortran format."""
-        cdef size_t nrow = state.shape[0]
-        cdef _BaseElement part
-        cdef double complex out = 0., coeff
-        cdef Data part_data
-        t = self._prepare(t, state)
-        if self.issuper:
-            if state.shape[1] != 1:
-                state = column_stack_dense(state, inplace=state.fortran)
-            try:
-                for element in self.elements:
-                    part = (<_BaseElement> element)
-                    coeff = part.coeff(t)
-                    part_data = part.data(t)
-                    out += coeff * expect_super_data_dense(part_data, state)
-            finally:
-                if state.fortran:
-                    # `state` was reshaped inplace, restore it's original shape
-                    column_unstack_dense(state, nrow, inplace=state.fortran)
-        else:
-            for element in self.elements:
-                part = (<_BaseElement> element)
-                coeff = part.coeff(t)
-                part_data = part.data(t)
-                out += coeff * expect_data_dense(part_data, state)
-        return out
-
-    def matmul(self, t, state):
-        """
-        Product of this operator at time ``t`` to the state.
-        ``self(t) @ state``
-
-        Parameters
-        ----------
-        t : float
-            Time of the operator to apply.
-        state : Qobj
-            right matrix of the product
-
-        Returns
-        -------
-        product : Qobj
-            The result product as a Qobj
-        """
-        if not isinstance(state, Qobj):
-            raise TypeError("A Qobj state is expected")
-
-        if self.dims[1] != state.dims[0]:
-            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
-                             ", " + str(state.dims[0]))
-
-        return Qobj(self.matmul_data(t, state.data),
-                    dims=[self.dims[0], state.dims[1]],
-                    copy=False
-                    )
-
-    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
-        """Compute ``out += self(t) @ state``"""
-        cdef _BaseElement part
-        t = self._prepare(t, state)
-        if out is None and type(state) is Dense:
-            out = dense.zeros(self.shape[0], state.shape[1],
-                              (<Dense> state).fortran)
-        elif out is None:
-            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
-
-        for element in self.elements:
-            part = (<_BaseElement> element)
-            out = part.matmul_data_t(t, state, out)
-        return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+
+import numpy as np
+import numbers
+import itertools
+from functools import partial
+
+import qutip
+from .. import Qobj
+from .. import data as _data
+from ..coefficient import coefficient, CompilationOptions
+from ._element import *
+from ..dimensions import type_from_dims
+from qutip.settings import settings
+
+from qutip.core.cy._element cimport _BaseElement
+from qutip.core.data cimport Dense, Data, dense
+from qutip.core.data.expect cimport *
+from qutip.core.data.reshape cimport (column_stack_dense, column_unstack_dense)
+from qutip.core.cy.coefficient cimport Coefficient
+from qutip.core.qobj import _MATMUL_TYPE_LOOKUP
+from libc.math cimport fabs
+
+__all__ = ['QobjEvo']
+
+cdef class QobjEvo:
+    """
+    A class for representing time-dependent quantum objects, such as quantum
+    operators and states.
+
+    Importantly, :obj:`~QobjEvo` instances are used to represent such
+    time-dependent quantum objects when working with QuTiP solvers.
+
+    A :obj:`~QobjEvo` instance may be constructed from one of the following:
+
+      * a callable ``f(t: double, args: dict) -> Qobj`` that returns the
+        value of the quantum object at time ``t``.
+
+      * a ``[Qobj, Coefficient]`` pair, where :obj:`~Coefficient` may also be
+        any item that can be used to construct a coefficient (e.g. a function,
+        a numpy array of coefficient values, a string expression).
+
+      * a :obj:`~Qobj` (which creates a constant :obj:`~QobjEvo` term).
+
+      * a list of such callables, pairs or :obj:`~Qobj`\s.
+
+      * a :obj:`~QobjEvo` (in which case a copy is created, all other arguments
+        are ignored except ``args`` which, if passed, replaces the existing
+        arguments).
+
+    Parameters
+    ----------
+    Q_object : callable, list or Qobj
+        A specification of the time-depedent quantum object. See the
+        paragraph above for a full description and the examples section below
+        for examples.
+
+    args : dict, optional
+        A dictionary that contains the arguments for the coefficients.
+        Arguments may be omitted if no function or string coefficients that
+        require arguments are present.
+
+    tlist : array-like, optional
+        A list of times corresponding to the values of the coefficients
+        supplied as numpy arrays. If no coefficients are supplied as numpy
+        arrays, ``tlist`` may be omitted, otherwise it is required.
+
+        The times in ``tlist`` do not need to be equidistant, but must
+        be sorted.
+
+        By default, a cubic spline interpolation will be used to interpolate
+        the value of the (numpy array) coefficients at time ``t``. If the
+        coefficients are to be treated as step functions, pass the argument
+        ``order=0`` (see below).
+
+    order : int, default=3
+        Order of the spline interpolation that is to be used to interpolate
+        the value of the (numpy array) coefficients at time ``t``.
+        ``0`` use previous or left value.
+
+    copy : bool, default=True
+        Whether to make a copy of the :obj:`Qobj` instances supplied in
+        the ``Q_object`` parameter.
+
+    compress : bool, default=True
+        Whether to compress the :obj:`QobjEvo` instance terms after the
+        instance has been created.
+
+        This sums the constant terms in a single term and combines
+        ``[Qobj, coefficient]`` pairs with the same :obj:`~Qobj` into a single
+        pair containing the sum of the coefficients.
+
+        See :meth:`compress`.
+
+    function_style : {None, "pythonic", "dict", "auto"}
+        The style of function signature used by callables in ``Q_object``.
+        If style is ``None``, the value of
+        ``qutip.settings.core["function_coefficient_style"]``
+        is used. Otherwise the supplied value overrides the global setting.
+
+
+    boundary_conditions : 2-Tuple, str or None, optional
+        Boundary conditions for spline evaluation. Default value is `None`.
+        Correspond to `bc_type` of scipy.interpolate.make_interp_spline.
+        Refer to Scipy's documentation for further details:
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.make_interp_spline.html
+
+
+    Attributes
+    ----------
+    dims : list
+        List of dimensions keeping track of the tensor structure.
+
+    shape : (int, int)
+        List of dimensions keeping track of the tensor structure.
+
+    type : str
+        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
+        'operator-bra', or 'super'.
+
+    superrep : str
+        Representation used if `type` is 'super'. One of 'super'
+        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
+
+    Examples
+    --------
+
+    A :obj:`~QobjEvo` constructed from a function:
+
+    .. code-block::
+
+        def f(t, args):
+            return qutip.qeye(N) * np.exp(args['w'] * t)
+
+        QobjEvo(f, args={'w': 1j})
+
+
+    For list based :obj:`~QobjEvo`, the list must consist of :obj`~Qobj` or
+    ``[Qobj, Coefficient]`` pairs:
+
+    .. code-block::
+
+        QobjEvo([H0, [H1, coeff1], [H2, coeff2]], args=args)
+
+    The coefficients may be specified either using a :obj:`~Coefficient`
+    object or by a function, string, numpy array or any object that
+    can be passed to the :func:`~coefficient` function. See the documentation
+    of :func:`coefficient` for a full description.
+
+    An example of a coefficient specified by a function:
+
+    .. code-block::
+
+        def f1_t(t, args):
+            return np.exp(-1j * t * args["w1"])
+
+        QobjEvo([[H1, f1_t]], args={"w1": 1.})
+
+    And of coefficients specified by string expressions:
+
+    .. code-block::
+
+        H = QobjEvo(
+            [H0, [H1, 'exp(-1j*w1*t)'], [H2, 'cos(w2*t)']],
+            args={"w1": 1., "w2": 2.}
+        )
+
+    Coefficients maybe also be expressed as numpy arrays giving a list
+    of the coefficient values:
+
+    .. code-block:: python
+
+        tlist = np.logspace(-5, 0, 100)
+        H = QobjEvo(
+            [H0, [H1, np.exp(-1j * tlist)], [H2, np.cos(2. * tlist)]],
+            tlist=tlist
+        )
+
+    The coeffients array must have the same len as the tlist.
+
+    A :obj:`~QobjEvo` may also be built using simple arithmetic operations
+    combining :obj:`~Qobj` with :obj:`~Coefficient`, for example:
+
+    .. code-block:: python
+
+        coeff = qutip.coefficient("exp(-1j*w1*t)", args={"w1": 1})
+        qevo = H0 + H1 * coeff
+
+    """
+    def __init__(QobjEvo self, Q_object, args=None, tlist=None,
+                 order=3, copy=True, compress=True,
+                 function_style=None, boundary_conditions=None):
+        if isinstance(Q_object, QobjEvo):
+            self.dims = Q_object.dims.copy()
+            self.shape = Q_object.shape
+            self.type = Q_object.type
+            self._issuper = (<QobjEvo> Q_object)._issuper
+            self._isoper = (<QobjEvo> Q_object)._isoper
+            self.elements = (<QobjEvo> Q_object).elements.copy()
+            if args:
+                self.arguments(args)
+            if compress:
+                self.compress()
+            return
+
+        self.elements = []
+        self.dims = None
+        self.shape = (0, 0)
+        self._issuper = -1
+        self._isoper = -1
+        args = args or {}
+
+        if (
+            isinstance(Q_object, list)
+            and len(Q_object) == 2
+            and isinstance(Q_object[0], Qobj)
+            and not isinstance(Q_object[1], (Qobj, list))
+        ):
+            # The format is [Qobj, coefficient]
+            Q_object = [Q_object]
+
+        if isinstance(Q_object, list):
+            for op in Q_object:
+                self.elements.append(
+                    self._read_element(
+                        op, copy=copy, tlist=tlist, args=args, order=order,
+                        function_style=function_style,
+                        boundary_conditions=boundary_conditions
+                    )
+                )
+        else:
+            self.elements.append(
+                self._read_element(
+                    Q_object, copy=copy, tlist=tlist, args=args, order=order,
+                    function_style=function_style,
+                    boundary_conditions=boundary_conditions
+                )
+            )
+
+        if compress:
+            self.compress()
+
+    def __repr__(self):
+        cls = self.__class__.__name__
+        repr_str = f'{cls}: dims = {self.dims}, shape = {self.shape}, '
+        repr_str += f'type = {self.type}, superrep = {self.superrep}, '
+        repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
+        return repr_str
+
+    def _read_element(self, op, copy, tlist, args, order, function_style, 
+                      boundary_conditions):
+        """ Read a Q_object item and return an element for that item. """
+        if isinstance(op, Qobj):
+            out = _ConstantElement(op.copy() if copy else op)
+            qobj = op
+        elif isinstance(op, list):
+            out = _EvoElement(
+                op[0].copy() if copy else op[0],
+                coefficient(op[1], tlist=tlist, args=args, order=order, 
+                            boundary_conditions=boundary_conditions)
+            )
+            qobj = op[0]
+        elif isinstance(op, _BaseElement):
+            out = op
+            qobj = op.qobj(0)
+        elif callable(op):
+            out = _FuncElement(op, args, style=function_style)
+            qobj = out.qobj(0)
+            if not isinstance(qobj, Qobj):
+                raise TypeError(
+                    "Function based time-dependent elements must have the"
+                    " signature f(t: double, args: dict) -> Qobj, but"
+                    " {!r} returned: {!r}".format(op, qobj)
+                )
+        else:
+            raise TypeError(
+                "QobjEvo terms should be Qobjs, a list of [Qobj, coefficient],"
+                " or a function f(t: double, args: dict) -> Qobj, but"
+                " received: {!r}".format(op)
+            )
+
+        if self.dims is None:
+            self.dims = qobj.dims
+            self.shape = qobj.shape
+            self.type = qobj.type
+            self.superrep = qobj.superrep
+        elif self.dims != qobj.dims or self.shape != qobj.shape:
+            raise ValueError(
+                f"QobjEvo term {op!r} has dims {qobj.dims!r} and shape"
+                f" {qobj.shape!r} but previous terms had dims {self.dims!r}"
+                f" and shape {self.shape!r}."
+            )
+        elif self.type != qobj.type:
+            raise ValueError(
+                f"QobjEvo term {op!r} has type {qobj.type!r} but "
+                f"previous terms had type {self.type!r}."
+            )
+        elif self.superrep != qobj.superrep:
+            raise ValueError(
+                f"QobjEvo term {op!r} has superrep {qobj.superrep!r} but "
+                f"previous terms had superrep {self.superrep!r}."
+            )
+
+        return out
+
+    @classmethod
+    def _restore(cls, elements, dims, shape, type, superrep, flags):
+        """Recreate a QobjEvo without using __init__. """
+        cdef QobjEvo out = cls.__new__(cls)
+        out.elements = elements
+        out.dims = dims
+        out.shape = shape
+        out.type = type
+        out.superrep = superrep
+        out._issuper, out._isoper = flags
+        return out
+
+    def _getstate(self):
+        """ Obtain the state """
+        # For jax pytree representation
+        # auto_pickle create similar method __getstate__, but since it's
+        # automatically created, it could change depending on cython version
+        # etc., so we create our own.
+        return {
+            "elements": self.elements,
+            "dims": self.dims,
+            "shape": self.shape,
+            "type": self.type,
+            "superrep": self.superrep,
+            "flags": (self._issuper, self._isoper,)
+        }
+
+    def __call__(self, double t, dict _args=None, **kwargs):
+        """
+        Get the :class:`~Qobj` at ``t``.
+
+        Parameters
+        ----------
+        t : float
+            Time at which the ``QobjEvo`` is to be evalued.
+
+        _args : dict [optional]
+            New arguments as a dict. Update args with ``arguments(new_args)``.
+
+        **kwargs :
+            New arguments as a keywors. Update args with
+            ``arguments(**new_args)``.
+
+        .. note::
+            If both the positional ``_args`` and keywords are passed new values
+            from both will be used. If a key is present with both, the
+            ``_args`` dict value will take priority.
+        """
+        if _args is not None or kwargs:
+            if _args is not None:
+                kwargs.update(_args)
+            return QobjEvo(self, args=kwargs)(t)
+
+        t = self._prepare(t, None)
+
+        if self.isconstant:
+            # For constant QobjEvo's, we sum the contained Qobjs directly in
+            # order to retain the cached values of attributes like .isherm when
+            # possible, rather than calling _call(t) which may lose this cached
+            # information.
+            return sum(element.qobj(t) for element in self.elements)
+
+        cdef _BaseElement part = self.elements[0]
+        cdef double complex coeff = part.coeff(t)
+        obj = part.qobj(t)
+        cdef Data out = _data.mul(obj.data, coeff)
+        cdef bint isherm = <bint> obj._isherm and coeff.imag == 0
+        for element in self.elements[1:]:
+            part = <_BaseElement> element
+            coeff = part.coeff(t)
+            obj = part.qobj(t)
+            isherm &= <bint> obj._isherm and coeff.imag == 0
+            out = _data.add(out, obj.data, coeff)
+
+        return Qobj(
+            out, dims=self.dims, copy=False, isherm=isherm or None,
+            type=self.type, superrep=self.superrep
+        )
+
+    cpdef Data _call(QobjEvo self, double t):
+        t = self._prepare(t, None)
+        cdef Data out
+        cdef _BaseElement part = self.elements[0]
+        out = _data.mul(part.data(t),
+                        part.coeff(t))
+        for element in self.elements[1:]:
+            part = <_BaseElement> element
+
+            out = _data.add(
+                out,
+                part.data(t),
+                part.coeff(t)
+            )
+        return out
+
+    cdef object _prepare(QobjEvo self, object t, Data state=None):
+        """ Precomputation before computing getting the element at `t`"""
+        # We keep the function for feedback eventually
+        return t
+
+    def copy(QobjEvo self):
+        """Return a copy of this `QobjEvo`"""
+        return QobjEvo(self, compress=False)
+
+    def arguments(QobjEvo self, dict _args=None, **kwargs):
+        """
+        Update the arguments.
+
+        Parameters
+        ----------
+        _args : dict [optional]
+            New arguments as a dict. Update args with ``arguments(new_args)``.
+
+        **kwargs :
+            New arguments as a keywors. Update args with
+            ``arguments(**new_args)``.
+
+        .. note::
+            If both the positional ``_args`` and keywords are passed new values
+            from both will be used. If a key is present with both, the ``_args``
+            dict value will take priority.
+        """
+        if _args is not None:
+            kwargs.update(_args)
+        cache = []
+        self.elements = [
+            element.replace_arguments(kwargs, cache=cache)
+            for element in self.elements
+        ]
+
+
+    ###########################################################################
+    # Math function                                                           #
+    ###########################################################################
+    def __add__(left, right):
+        if isinstance(left, QobjEvo):
+            self = left
+            other = right
+        else:
+            self = right
+            other = left
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        res = self.copy()
+        res += other
+        return res
+
+    def __radd__(self, other):
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        res = self.copy()
+        res += other
+        return res
+
+    def __iadd__(QobjEvo self, other):
+        cdef _BaseElement element
+        if isinstance(other, QobjEvo):
+            if other.dims != self.dims:
+                raise TypeError("incompatible dimensions" +
+                                str(self.dims) + ", " + str(other.dims))
+            for element in (<QobjEvo> other).elements:
+                self.elements.append(element)
+        elif isinstance(other, Qobj):
+            if other.dims != self.dims:
+                raise TypeError("incompatible dimensions" +
+                                str(self.dims) + ", " + str(other.dims))
+            self.elements.append(_ConstantElement(other))
+        elif (
+            isinstance(other, numbers.Number) and
+            self.dims[0] == self.dims[1]
+        ):
+            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
+        else:
+            return NotImplemented
+        return self
+
+    def __sub__(left, right):
+        if isinstance(left, QobjEvo):
+            res = left.copy()
+            res += -right
+            return res
+        else:
+            res = -right.copy()
+            res += left
+            return res
+
+    def __rsub__(self, other):
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        res = -self
+        res += other
+        return res
+
+    def __isub__(self, other):
+        if not isinstance(other, (Qobj, QobjEvo, numbers.Number)):
+            return NotImplemented
+        self += (-other)
+        return self
+
+    def __matmul__(left, right):
+        cdef QobjEvo res
+        if isinstance(left, QobjEvo):
+            return left.copy().__imatmul__(right)
+        elif isinstance(left, Qobj):
+            if left.dims[1] != (<QobjEvo> right).dims[0]:
+                raise TypeError("incompatible dimensions" +
+                                 str(left.dims[1]) + ", " +
+                                 str((<QobjEvo> right).dims[0]))
+
+            type_ =_MATMUL_TYPE_LOOKUP.get((left.type, right.type))
+            if type_ is None:
+                raise TypeError(
+                    "incompatible matmul types "
+                    + repr(left.type) + " and " + repr(right.type)
+                )
+
+            res = right.copy()
+            res.dims = [left.dims[0], right.dims[1]]
+            res.shape = (left.shape[0], right.shape[1])
+            res.type = type_
+            left = _ConstantElement(left)
+            res.elements = [left @ element for element in res.elements]
+            res._issuper = -1
+            res._isoper = -1
+            return res
+        else:
+            return NotImplemented
+
+    def __rmatmul__(QobjEvo self, other):
+        cdef QobjEvo res
+        if isinstance(other, Qobj):
+            if other.dims[1] != self.dims[0]:
+                raise TypeError("incompatible dimensions" +
+                                 str(other.dims[1]) + ", " +
+                                 str(self.dims[0]))
+
+            type_ =_MATMUL_TYPE_LOOKUP.get((other.type, self.type))
+            if type_ is None:
+                raise TypeError(
+                    "incompatible matmul types "
+                    + repr(other.type) + " and " + repr(self.type)
+                )
+
+            res = self.copy()
+            res.dims = [other.dims[0], res.dims[1]]
+            res.shape = (other.shape[0], res.shape[1])
+            res.type = type_
+            other = _ConstantElement(other)
+            res.elements = [other @ element for element in res.elements]
+            res._issuper = -1
+            res._isoper = -1
+            return res
+        else:
+            return NotImplemented
+
+    def __imatmul__(QobjEvo self, other):
+        if isinstance(other, (Qobj, QobjEvo)):
+            if self.dims[1] != other.dims[0]:
+                raise TypeError("incompatible dimensions" +
+                                str(self.dims[1]) + ", " +
+                                str(other.dims[0]))
+
+            type_ =_MATMUL_TYPE_LOOKUP.get((self.type, other.type))
+            if type_ is None:
+                raise TypeError(
+                    "incompatible matmul types "
+                    + repr(self.type) + " and " + repr(other.type)
+                )
+
+            self.dims = [self.dims[0], other.dims[1]]
+            self.shape = (self.shape[0], other.shape[1])
+            self.type = type_
+            self._issuper = -1
+            self._isoper = -1
+            if isinstance(other, Qobj):
+                other = _ConstantElement(other)
+                self.elements = [element @ other for element in self.elements]
+
+            elif isinstance(other, QobjEvo):
+                self.elements = [left @ right
+                    for left, right in itertools.product(
+                        self.elements, (<QobjEvo> other).elements
+                    )]
+        else:
+            return NotImplemented
+        return self
+
+    def __mul__(left, right):
+        if isinstance(left, QobjEvo):
+            return left.copy().__imul__(right)
+        elif isinstance(left, Qobj):
+            return right.__rmatmul__(left)
+        elif isinstance(left, (numbers.Number, Coefficient)):
+            return right.copy().__imul__(left)
+        else:
+            return NotImplemented
+
+    def __rmul__(self, other):
+        if isinstance(other, Qobj):
+            return self.__rmatmul__(other)
+        else:
+            res = self.copy()
+            res *= other
+            return res
+
+    def __imul__(QobjEvo self, other):
+        if isinstance(other, (Qobj, QobjEvo)):
+            self @= other
+        elif isinstance(other, numbers.Number):
+            self.elements = [element * other for element in self.elements]
+        elif isinstance(other, Coefficient):
+            other = _EvoElement(qutip.qeye(self.dims[1]), other)
+            self.elements = [element @ other for element in self.elements]
+        else:
+            return NotImplemented
+        return self
+
+    def __truediv__(left, right):
+        if isinstance(left, QobjEvo) and isinstance(right, numbers.Number):
+            res = left.copy()
+            res *= 1 / right
+            return res
+        return NotImplemented
+
+    def __idiv__(self, other):
+        if not isinstance(other, numbers.Number):
+            return NotImplemented
+        self *= 1 / other
+        return self
+
+    def __neg__(self):
+        res = self.copy()
+        res *= -1
+        return res
+
+    ###########################################################################
+    # tensor                                                                  #
+    ###########################################################################
+    def __and__(left, right):
+        """
+        Syntax shortcut for tensor:
+        A & B ==> tensor(A, B)
+        """
+        return qutip.tensor(left, right)
+
+    ###########################################################################
+    # Unary transformation                                                    #
+    ###########################################################################
+    def trans(self):
+        """ Transpose of the quantum object """
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(Qobj.trans)
+                        for element in res.elements]
+        return res
+
+    def conj(self):
+        """Get the element-wise conjugation of the quantum object."""
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(Qobj.conj, True)
+                        for element in res.elements]
+        return res
+
+    def dag(self):
+        """Get the Hermitian adjoint of the quantum object."""
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(Qobj.dag, True)
+                        for element in res.elements]
+        return res
+
+    def to(self, data_type):
+        """
+        Convert the underlying data store of all component into the desired
+        storage representation.
+
+        The different storage representations available are the "data-layer
+        types".  By default, these are `qutip.data.Dense` and `qutip.data.CSR`,
+        which respectively construct a dense matrix store and a compressed
+        sparse row one.
+
+        The `QobjEvo` is transformed inplace.
+
+        Parameters
+        ----------
+        data_type : type
+            The data-layer type that the data of this `Qobj` should be
+            converted to.
+
+        Returns
+        -------
+        None
+        """
+        return self.linear_map(partial(Qobj.to, data_type=data_type),
+                               _skip_check=True)
+
+    def tidyup(self, atol=1e-12):
+        """Removes small elements from quantum object."""
+        for element in self.elements:
+            if type(element) is _ConstantElement:
+                element = _ConstantElement(element.qobj(0).tidyup(atol))
+            elif type(element) is _EvoElement:
+                element = _EvoElement(element.qobj(0).tidyup(atol),
+                                      element._coefficient)
+        return self
+
+    def linear_map(self, op_mapping, *, _skip_check=False):
+        """
+        Apply mapping to each Qobj contribution.
+
+        Example:
+        ``QobjEvo([sigmax(), coeff]).linear_map(spre)``
+        gives the same result has
+        ``QobjEvo([spre(sigmax()), coeff])``
+
+        Returns
+        -------
+        :class:`.QobjEvo`
+            Modified object
+
+        Notes
+        -----
+        Does not modify the coefficients, thus ``linear_map(conj)`` would not
+        give the the conjugate of the QobjEvo. It's only valid for linear
+        transformations.
+        """
+        if not _skip_check:
+            out = op_mapping(self(0))
+            if not isinstance(out, Qobj):
+                raise TypeError("The op_mapping function must return a Qobj")
+        cdef QobjEvo res = self.copy()
+        res.elements = [element.linear_map(op_mapping) for element in res.elements]
+        res.dims = res.elements[0].qobj(0).dims
+        res.shape = res.elements[0].qobj(0).shape
+        res.type = res.elements[0].qobj(0).type
+        res._issuper = res.elements[0].qobj(0).issuper
+        res._isoper = res.elements[0].qobj(0).isoper
+        if not _skip_check:
+            if res(0) != out:
+                raise ValueError("The mapping is not linear")
+
+        return res
+
+    ###########################################################################
+    # Cleaning and compress                                                   #
+    ###########################################################################
+    def _compress_merge_qobj(self, coeff_elements):
+        """Merge element with matching qobj:
+        ``[A, f1], [A, f2] -> [A, f1+f2]``
+        """
+        cleaned_elements = []
+        # Mimic a dict with Qobj not hashable
+        qobjs = []
+        coeffs = []
+        for element in coeff_elements:
+            for i, qobj in enumerate(qobjs):
+                if element.qobj(0) == qobj:
+                    coeffs[i] = coeffs[i] + element._coefficient
+                    break
+            else:
+                qobjs.append(element.qobj(0))
+                coeffs.append(element._coefficient)
+        for qobj, coeff in zip(qobjs, coeffs):
+            cleaned_elements.append(_EvoElement(qobj, coeff))
+        return cleaned_elements
+
+    def compress(self):
+        """
+        Look for redundance in the :obj:`~QobjEvo` components:
+
+        Constant parts, (:class:`~Qobj` without :class:`~Coefficient`) will be
+        summed.
+        Pairs ``[Qobj, Coefficient]`` with the same :class:`~Qobj` are merged.
+
+        Example:
+        ``[[sigmax(), f1], [sigmax(), f2]] -> [[sigmax(), f1+f2]]``
+
+        The :class:`~QobjEvo` is transformed inplace.
+
+        Returns
+        -------
+        None
+        """
+        cte_elements = []
+        coeff_elements = []
+        func_elements = []
+        for element in self.elements:
+            if type(element) is _ConstantElement:
+                cte_elements.append(element)
+            elif type(element) is _EvoElement:
+                coeff_elements.append(element)
+            else:
+                func_elements.append(element)
+
+        cleaned_elements = []
+        if len(cte_elements) >= 2:
+            # Multiple constant parts
+            cleaned_elements.append(_ConstantElement(
+                sum(element.qobj(0) for element in cte_elements)))
+        else:
+            cleaned_elements += cte_elements
+
+        coeff_elements = self._compress_merge_qobj(coeff_elements)
+        cleaned_elements += coeff_elements + func_elements
+
+        self.elements = cleaned_elements
+
+    def to_list(QobjEvo self):
+        """
+        Restore the QobjEvo to a list form.
+
+        Returns
+        -------
+        list_qevo: list
+            The QobjEvo as a list, element are either :class:`Qobj` for
+            constant parts, ``[Qobj, Coefficient]`` for coefficient based term.
+            The original format of the :class:`Coefficient` is not restored.
+            Lastly if the original `QobjEvo` is constructed with a function
+            returning a Qobj, the term is returned as a pair of the original
+            function and args (``dict``).
+        """
+        out = []
+        for element in self.elements:
+            if isinstance(element, _ConstantElement):
+                out.append(element.qobj(0))
+            elif isinstance(element, _EvoElement):
+                coeff = element._coefficient
+                out.append([element.qobj(0), coeff])
+            elif isinstance(element, _FuncElement):
+                func = element._func
+                args = element._args
+                out.append([func, args])
+            else:
+                out.append([element, {}])
+        return out
+
+    ###########################################################################
+    # properties                                                              #
+    ###########################################################################
+    @property
+    def num_elements(self):
+        """Number of parts composing the system"""
+        return len(self.elements)
+
+    @property
+    def isconstant(self):
+        """Does the system change depending on ``t``"""
+        return not any(type(element) is not _ConstantElement
+                       for element in self.elements)
+
+    @property
+    def isoper(self):
+        """Indicates if the system represents an operator."""
+        # TODO: isoper should be part of dims
+        if self._isoper == -1:
+            self._isoper = type_from_dims(self.dims) == "oper"
+        return self._isoper
+
+    @property
+    def issuper(self):
+        """Indicates if the system represents a superoperator."""
+        # TODO: issuper should/will be part of dims
+        # remove self._issuper then
+        if self._issuper == -1:
+            self._issuper = type_from_dims(self.dims) == "super"
+        return self._issuper
+
+    ###########################################################################
+    # operation methods                                                       #
+    ###########################################################################
+    def expect(QobjEvo self, object t, state, check_real=True):
+        """
+        Expectation value of this operator at time ``t`` with the state.
+
+        Parameters
+        ----------
+        t : float
+            Time of the operator to apply.
+
+        state : Qobj
+            right matrix of the product
+
+        check_real : bool (True)
+            Whether to convert the result to a `real` when the imaginary part
+            is smaller than the real part by a dactor of
+            ``settings.core['rtol']``.
+
+        Returns
+        -------
+        expect : float or complex
+            ``state.adjoint() @ self @ state`` if ``state`` is a ket.
+            ``trace(self @ matrix)`` is ``state`` is an operator or
+            operator-ket.
+        """
+        # TODO: remove reading from `settings` for a typed value when options
+        # support property.
+        cdef float herm_rtol = settings.core['rtol']
+        if not isinstance(state, Qobj):
+            raise TypeError("A Qobj state is expected")
+        if not (self.isoper or self.issuper):
+            raise ValueError("Must be an operator or super operator to compute"
+                             " an expectation value")
+        if not (
+            (self.dims[1] == state.dims[0]) or
+            (self.issuper and self.dims[1] == state.dims)
+        ):
+            raise ValueError("incompatible dimensions " + str(self.dims) +
+                             ", " + str(state.dims))
+        out = self.expect_data(t, state.data)
+        if (
+            check_real and
+            (out == 0 or (out.real and fabs(out.imag / out.real) < herm_rtol))
+        ):
+            return out.real
+        return out
+
+    cpdef object expect_data(QobjEvo self, object t, Data state):
+        """
+        Expectation is defined as ``state.adjoint() @ self @ state`` if
+        ``state`` is a vector, or ``state`` is an operator and ``self`` is a
+        superoperator.  If ``state`` is an operator and ``self`` is an
+        operator, then expectation is ``trace(self @ matrix)``.
+        """
+        if type(state) is Dense:
+            return self._expect_dense(t, state)
+        cdef _BaseElement part
+        cdef object out = 0.
+        cdef Data part_data
+        cdef object expect_func
+        t = self._prepare(t, state)
+        if self.issuper:
+            if state.shape[1] != 1:
+                state = _data.column_stack(state)
+            expect_func = _data.expect_super
+        else:
+            expect_func = _data.expect
+
+        for element in self.elements:
+            part = (<_BaseElement> element)
+            part_data = part.data(t)
+            out += part.coeff(t) * expect_func(part_data, state)
+        return out
+
+    cdef double complex _expect_dense(QobjEvo self, double t, Dense state) except *:
+        """For Dense state, ``column_stack_dense`` can be done inplace if in
+        fortran format."""
+        cdef size_t nrow = state.shape[0]
+        cdef _BaseElement part
+        cdef double complex out = 0., coeff
+        cdef Data part_data
+        t = self._prepare(t, state)
+        if self.issuper:
+            if state.shape[1] != 1:
+                state = column_stack_dense(state, inplace=state.fortran)
+            try:
+                for element in self.elements:
+                    part = (<_BaseElement> element)
+                    coeff = part.coeff(t)
+                    part_data = part.data(t)
+                    out += coeff * expect_super_data_dense(part_data, state)
+            finally:
+                if state.fortran:
+                    # `state` was reshaped inplace, restore it's original shape
+                    column_unstack_dense(state, nrow, inplace=state.fortran)
+        else:
+            for element in self.elements:
+                part = (<_BaseElement> element)
+                coeff = part.coeff(t)
+                part_data = part.data(t)
+                out += coeff * expect_data_dense(part_data, state)
+        return out
+
+    def matmul(self, t, state):
+        """
+        Product of this operator at time ``t`` to the state.
+        ``self(t) @ state``
+
+        Parameters
+        ----------
+        t : float
+            Time of the operator to apply.
+        state : Qobj
+            right matrix of the product
+
+        Returns
+        -------
+        product : Qobj
+            The result product as a Qobj
+        """
+        if not isinstance(state, Qobj):
+            raise TypeError("A Qobj state is expected")
+
+        if self.dims[1] != state.dims[0]:
+            raise ValueError("incompatible dimensions " + str(self.dims[1]) +
+                             ", " + str(state.dims[0]))
+
+        return Qobj(self.matmul_data(t, state.data),
+                    dims=[self.dims[0], state.dims[1]],
+                    copy=False
+                    )
+
+    cpdef Data matmul_data(QobjEvo self, object t, Data state, Data out=None):
+        """Compute ``out += self(t) @ state``"""
+        cdef _BaseElement part
+        t = self._prepare(t, state)
+        if out is None and type(state) is Dense:
+            out = dense.zeros(self.shape[0], state.shape[1],
+                              (<Dense> state).fortran)
+        elif out is None:
+            out = _data.zeros[type(state)](self.shape[0], state.shape[1])
+
+        for element in self.elements:
+            part = (<_BaseElement> element)
+            out = part.matmul_data_t(t, state, out)
+        return out
diff --git a/qutip/core/data/__init__.pxd b/qutip/core/data/__init__.pxd
index 1f5c75d908..c1b4e6809d 100644
--- a/qutip/core/data/__init__.pxd
+++ b/qutip/core/data/__init__.pxd
@@ -1,13 +1,13 @@
-#cython: language_level=3
-
-# Package-level relative imports in Cython (0.29.17) are temperamental.
-from qutip.core.data cimport dense, csr
-from qutip.core.data.base cimport Data, idxint
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.csr cimport CSR
-
-from qutip.core.data.add cimport *
-from qutip.core.data.adjoint cimport *
-from qutip.core.data.kron cimport *
-from qutip.core.data.matmul cimport *
-from qutip.core.data.mul cimport *
+#cython: language_level=3
+
+# Package-level relative imports in Cython (0.29.17) are temperamental.
+from qutip.core.data cimport dense, csr
+from qutip.core.data.base cimport Data, idxint
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport CSR
+
+from qutip.core.data.add cimport *
+from qutip.core.data.adjoint cimport *
+from qutip.core.data.kron cimport *
+from qutip.core.data.matmul cimport *
+from qutip.core.data.mul cimport *
diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index 5fd15509ab..557aff5c04 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -1,56 +1,56 @@
-# First-class type imports
-
-from . import dense, csr
-from .dense import Dense
-from .csr import CSR
-from .base import Data
-
-from .add import *
-from .adjoint import *
-from .constant import *
-from .eigen import *
-from .expect import *
-from .expm import *
-from .inner import *
-from .kron import *
-from .linalg import *
-from .matmul import *
-from .make import *
-from .mul import *
-from .pow import *
-from .project import *
-from .properties import *
-from .ptrace import *
-from .reshape import *
-from .tidyup import *
-from .trace import *
-from .solve import *
-# For operations with mulitple related versions, we just import the module.
-from . import norm, permute
-
-
-# Set up the data conversions that are known by us.  All types covered by
-# conversions will be made available for use in the dispatcher functions.
-
-from .convert import to, create
-to.add_conversions([
-    (Dense, CSR, dense.from_csr, 1),
-    (CSR, Dense, csr.from_dense, 1.4),
-])
-to.register_aliases(['csr', 'CSR'], CSR)
-to.register_aliases(['Dense', 'dense'], Dense)
-
-
-from . import _creator_utils
-import numpy as np
-create.add_creators([
-    (_creator_utils.is_data, _creator_utils.data_copy, 100),
-    (_creator_utils.isspmatrix_csr, CSR, 80),
-    (_creator_utils.is_nparray, Dense, 80),
-    (_creator_utils.issparse, CSR, 20),
-    (_creator_utils.true, Dense, -np.inf),
-])
-del _creator_utils
-del np
-
-from .dispatch import Dispatcher
+# First-class type imports
+
+from . import dense, csr
+from .dense import Dense
+from .csr import CSR
+from .base import Data
+
+from .add import *
+from .adjoint import *
+from .constant import *
+from .eigen import *
+from .expect import *
+from .expm import *
+from .inner import *
+from .kron import *
+from .linalg import *
+from .matmul import *
+from .make import *
+from .mul import *
+from .pow import *
+from .project import *
+from .properties import *
+from .ptrace import *
+from .reshape import *
+from .tidyup import *
+from .trace import *
+from .solve import *
+# For operations with mulitple related versions, we just import the module.
+from . import norm, permute
+
+
+# Set up the data conversions that are known by us.  All types covered by
+# conversions will be made available for use in the dispatcher functions.
+
+from .convert import to, create
+to.add_conversions([
+    (Dense, CSR, dense.from_csr, 1),
+    (CSR, Dense, csr.from_dense, 1.4),
+])
+to.register_aliases(['csr', 'CSR'], CSR)
+to.register_aliases(['Dense', 'dense'], Dense)
+
+
+from . import _creator_utils
+import numpy as np
+create.add_creators([
+    (_creator_utils.is_data, _creator_utils.data_copy, 100),
+    (_creator_utils.isspmatrix_csr, CSR, 80),
+    (_creator_utils.is_nparray, Dense, 80),
+    (_creator_utils.issparse, CSR, 20),
+    (_creator_utils.true, Dense, -np.inf),
+])
+del _creator_utils
+del np
+
+from .dispatch import Dispatcher
diff --git a/qutip/core/data/_creator_utils.py b/qutip/core/data/_creator_utils.py
index 1432804b94..3f3779e219 100644
--- a/qutip/core/data/_creator_utils.py
+++ b/qutip/core/data/_creator_utils.py
@@ -1,31 +1,31 @@
-"""
-Define functions to use as Data creator for `create` in `convert.py`.
-"""
-
-from scipy.sparse import isspmatrix_csr, issparse
-import numpy as np
-from .csr import CSR
-from .base import Data
-from .dense import Dense
-
-__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
-
-
-def is_data(arg):
-    return isinstance(arg, Data)
-
-
-def is_nparray(arg):
-    return isinstance(arg, np.ndarray)
-
-
-def true(arg):
-    return True
-
-
-def data_copy(arg, shape, copy=True):
-    if shape is not None and shape != arg.shape:
-        raise ValueError("".join([
-            "shapes do not match: ", str(shape), " and ", str(arg.shape),
-        ]))
-    return arg.copy() if copy else arg
+"""
+Define functions to use as Data creator for `create` in `convert.py`.
+"""
+
+from scipy.sparse import isspmatrix_csr, issparse
+import numpy as np
+from .csr import CSR
+from .base import Data
+from .dense import Dense
+
+__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
+
+
+def is_data(arg):
+    return isinstance(arg, Data)
+
+
+def is_nparray(arg):
+    return isinstance(arg, np.ndarray)
+
+
+def true(arg):
+    return True
+
+
+def data_copy(arg, shape, copy=True):
+    if shape is not None and shape != arg.shape:
+        raise ValueError("".join([
+            "shapes do not match: ", str(shape), " and ", str(arg.shape),
+        ]))
+    return arg.copy() if copy else arg
diff --git a/qutip/core/data/add.pxd b/qutip/core/data/add.pxd
index e05941870b..edb30f14ae 100644
--- a/qutip/core/data/add.pxd
+++ b/qutip/core/data/add.pxd
@@ -1,12 +1,12 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-
-cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
-cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
-cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
-cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
-
-cpdef CSR sub_csr(CSR left, CSR right)
-cpdef Dense sub_dense(Dense left, Dense right)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+
+cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
+cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
+cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
+cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
+
+cpdef CSR sub_csr(CSR left, CSR right)
+cpdef Dense sub_dense(Dense left, Dense right)
diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index 0b65d2e32a..4a24a193a4 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -1,276 +1,276 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-import numpy as np
-cimport numpy as cnp
-from scipy.linalg cimport cython_blas as blas
-from qutip.settings import settings
-
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.csr cimport (
-    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
-)
-from qutip.core.data cimport csr, dense
-
-cnp.import_array()
-
-cdef extern from *:
-    void *PyDataMem_NEW(size_t size)
-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-    void PyDataMem_FREE(void *ptr)
-
-
-__all__ = [
-    'add', 'add_csr', 'add_dense', 'iadd_dense',
-    'sub', 'sub_csr', 'sub_dense',
-]
-
-
-cdef int _ONE=1
-
-
-cdef void _check_shape(Data left, Data right) nogil except *:
-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-
-
-cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
-    """
-    Perform the operation
-        c := a + b
-    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
-    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
-
-    Return the true value of nnz(c).
-    """
-    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
-    cdef idxint ncols = a.shape[1]
-    c.row_index[0] = nnz
-    ptr_a_max = ptr_b_max = 0
-    for row in range(a.shape[0]):
-        ptr_a = ptr_a_max
-        ptr_a_max = a.row_index[row + 1]
-        ptr_b = ptr_b_max
-        ptr_b_max = b.row_index[row + 1]
-        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-        # We use this method of going through the row to give the Accumulator
-        # the best chance of receiving the scatters in a sorted order.  We
-        # could also safely iterate through a completely then b, which would be
-        # more cache efficient, but would quite often require a sort within the
-        # gather, making the algorithimic complexity worse.
-        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
-            if col_a < col_b:
-                acc_scatter(acc, a.data[ptr_a], col_a)
-                ptr_a += 1
-                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-            else:
-                acc_scatter(acc, b.data[ptr_b], col_b)
-                ptr_b += 1
-                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-            # There's no need to test col_a == col_b because the Accumulator
-            # already tests that in all scatters anyway.
-        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
-        acc_reset(acc)
-        c.row_index[row + 1] = nnz
-    return nnz
-
-
-cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
-                           double complex scale, double tol) nogil:
-    """
-    Perform the operation
-        c := a + scale*b
-    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
-    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
-
-    Return the true value of nnz(c).
-    """
-    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
-    cdef idxint ncols = a.shape[1]
-    c.row_index[0] = nnz
-    ptr_a_max = ptr_b_max = 0
-    for row in range(a.shape[0]):
-        ptr_a = ptr_a_max
-        ptr_a_max = a.row_index[row + 1]
-        ptr_b = ptr_b_max
-        ptr_b_max = b.row_index[row + 1]
-        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
-            if col_a < col_b:
-                acc_scatter(acc, a.data[ptr_a], col_a)
-                ptr_a += 1
-                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
-            else:
-                acc_scatter(acc, scale * b.data[ptr_b], col_b)
-                ptr_b += 1
-                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
-        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
-        acc_reset(acc)
-        c.row_index[row + 1] = nnz
-    return nnz
-
-
-cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
-    """
-    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
-    `right` is multiplied by `scale`, so the full operation is
-        ``out := left + scale*right``
-    The two matrices must be of exactly the same shape.
-
-    Parameters
-    ----------
-    left : CSR
-        Matrix to be added.
-    right : CSR
-        Matrix to be added.  If `scale` is given, this matrix will be
-        multiplied by `scale` before addition.
-    scale : optional double complex (1)
-        The scalar value to multiply `right` by before addition.
-
-    Returns
-    -------
-    out : CSR
-        The result `left + scale*right`.
-    """
-    _check_shape(left, right)
-    cdef idxint left_nnz = csr.nnz(left)
-    cdef idxint right_nnz = csr.nnz(right)
-    cdef idxint worst_nnz = left_nnz + right_nnz
-    cdef idxint i
-    cdef CSR out
-    cdef Accumulator acc
-    cdef double tol = 0
-    if settings.core['auto_tidyup']:
-        tol = settings.core['auto_tidyup_atol']
-    # Fast paths for zero matrices.
-    if right_nnz == 0 or scale == 0:
-        return left.copy()
-    if left_nnz == 0:
-        out = right.copy()
-        # Fast path if the multiplication is a no-op.
-        if scale != 1:
-            for i in range(right_nnz):
-                out.data[i] *= scale
-        return out
-    # Main path.
-    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
-    acc = acc_alloc(left.shape[1])
-    if scale == 1:
-        _add_csr(&acc, left, right, out, tol)
-    else:
-        _add_csr_scale(&acc, left, right, out, scale, tol)
-    acc_free(&acc)
-    return out
-
-
-cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
-    cdef int size = left.shape[0] * left.shape[1]
-    with nogil:
-        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
-
-
-cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
-    cdef Dense out = left.copy()
-    cdef int size = left.shape[0] * left.shape[1]
-    with nogil:
-        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
-    return out
-
-
-cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
-    _check_shape(left, right)
-    if not (left.fortran ^ right.fortran):
-        return _add_dense_eq_order(left, right, scale)
-    cdef Dense out = left.copy()
-    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
-    # We always iterate through `left` and `out` in memory-layout order.
-    cdef int dim1, dim2
-    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
-    with nogil:
-        for idx in range(dim2):
-            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
-    return out
-
-
-cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
-    _check_shape(left, right)
-    cdef int size = left.shape[0] * left.shape[1]
-    cdef int dim1, dim2
-    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
-    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
-    with nogil:
-        if not (left.fortran ^ right.fortran):
-            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
-        else:
-            for idx in range(dim2):
-                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
-                           left.data + idx*dim1, &_ONE)
-    return left
-
-
-cpdef CSR sub_csr(CSR left, CSR right):
-    return add_csr(left, right, -1)
-
-
-cpdef Dense sub_dense(Dense left, Dense right):
-    return add_dense(left, right, -1)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-add = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='add',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-add.__doc__ =\
-    """
-    Perform the operation
-        left + scale*right
-    where `left` and `right` are matrices, and `scale` is an optional complex
-    scalar.
-    """
-add.add_specialisations([
-    (Dense, Dense, Dense, add_dense),
-    (CSR, CSR, CSR, add_csr),
-], _defer=True)
-
-sub = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='sub',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-sub.__doc__ =\
-    """
-    Perform the operation
-        left - right
-    where `left` and `right` are matrices.
-    """
-sub.add_specialisations([
-    (Dense, Dense, Dense, sub_dense),
-    (CSR, CSR, CSR, sub_csr),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+import numpy as np
+cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
+from qutip.settings import settings
+
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport (
+    CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
+)
+from qutip.core.data cimport csr, dense
+
+cnp.import_array()
+
+cdef extern from *:
+    void *PyDataMem_NEW(size_t size)
+    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
+    void PyDataMem_FREE(void *ptr)
+
+
+__all__ = [
+    'add', 'add_csr', 'add_dense', 'iadd_dense',
+    'sub', 'sub_csr', 'sub_dense',
+]
+
+
+cdef int _ONE=1
+
+
+cdef void _check_shape(Data left, Data right) nogil except *:
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+
+
+cdef idxint _add_csr(Accumulator *acc, CSR a, CSR b, CSR c, double tol) nogil:
+    """
+    Perform the operation
+        c := a + b
+    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
+    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
+
+    Return the true value of nnz(c).
+    """
+    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
+    cdef idxint ncols = a.shape[1]
+    c.row_index[0] = nnz
+    ptr_a_max = ptr_b_max = 0
+    for row in range(a.shape[0]):
+        ptr_a = ptr_a_max
+        ptr_a_max = a.row_index[row + 1]
+        ptr_b = ptr_b_max
+        ptr_b_max = b.row_index[row + 1]
+        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+        # We use this method of going through the row to give the Accumulator
+        # the best chance of receiving the scatters in a sorted order.  We
+        # could also safely iterate through a completely then b, which would be
+        # more cache efficient, but would quite often require a sort within the
+        # gather, making the algorithimic complexity worse.
+        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
+            if col_a < col_b:
+                acc_scatter(acc, a.data[ptr_a], col_a)
+                ptr_a += 1
+                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+            else:
+                acc_scatter(acc, b.data[ptr_b], col_b)
+                ptr_b += 1
+                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+            # There's no need to test col_a == col_b because the Accumulator
+            # already tests that in all scatters anyway.
+        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
+        acc_reset(acc)
+        c.row_index[row + 1] = nnz
+    return nnz
+
+
+cdef idxint _add_csr_scale(Accumulator *acc, CSR a, CSR b, CSR c,
+                           double complex scale, double tol) nogil:
+    """
+    Perform the operation
+        c := a + scale*b
+    for CSR matrices, where `a` and `b` are guaranteed to be the correct shape,
+    and `c` already has enough space allocated (at least nnz(a)+nnz(b)).
+
+    Return the true value of nnz(c).
+    """
+    cdef idxint row, ptr_a, ptr_b, ptr_a_max, ptr_b_max, nnz=0, col_a, col_b
+    cdef idxint ncols = a.shape[1]
+    c.row_index[0] = nnz
+    ptr_a_max = ptr_b_max = 0
+    for row in range(a.shape[0]):
+        ptr_a = ptr_a_max
+        ptr_a_max = a.row_index[row + 1]
+        ptr_b = ptr_b_max
+        ptr_b_max = b.row_index[row + 1]
+        col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+        col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+        while ptr_a < ptr_a_max or ptr_b < ptr_b_max:
+            if col_a < col_b:
+                acc_scatter(acc, a.data[ptr_a], col_a)
+                ptr_a += 1
+                col_a = a.col_index[ptr_a] if ptr_a < ptr_a_max else ncols + 1
+            else:
+                acc_scatter(acc, scale * b.data[ptr_b], col_b)
+                ptr_b += 1
+                col_b = b.col_index[ptr_b] if ptr_b < ptr_b_max else ncols + 1
+        nnz += acc_gather(acc, c.data + nnz, c.col_index + nnz, tol)
+        acc_reset(acc)
+        c.row_index[row + 1] = nnz
+    return nnz
+
+
+cpdef CSR add_csr(CSR left, CSR right, double complex scale=1):
+    """
+    Matrix addition of `left` and `right` for CSR inputs and output.  If given,
+    `right` is multiplied by `scale`, so the full operation is
+        ``out := left + scale*right``
+    The two matrices must be of exactly the same shape.
+
+    Parameters
+    ----------
+    left : CSR
+        Matrix to be added.
+    right : CSR
+        Matrix to be added.  If `scale` is given, this matrix will be
+        multiplied by `scale` before addition.
+    scale : optional double complex (1)
+        The scalar value to multiply `right` by before addition.
+
+    Returns
+    -------
+    out : CSR
+        The result `left + scale*right`.
+    """
+    _check_shape(left, right)
+    cdef idxint left_nnz = csr.nnz(left)
+    cdef idxint right_nnz = csr.nnz(right)
+    cdef idxint worst_nnz = left_nnz + right_nnz
+    cdef idxint i
+    cdef CSR out
+    cdef Accumulator acc
+    cdef double tol = 0
+    if settings.core['auto_tidyup']:
+        tol = settings.core['auto_tidyup_atol']
+    # Fast paths for zero matrices.
+    if right_nnz == 0 or scale == 0:
+        return left.copy()
+    if left_nnz == 0:
+        out = right.copy()
+        # Fast path if the multiplication is a no-op.
+        if scale != 1:
+            for i in range(right_nnz):
+                out.data[i] *= scale
+        return out
+    # Main path.
+    out = csr.empty(left.shape[0], left.shape[1], worst_nnz)
+    acc = acc_alloc(left.shape[1])
+    if scale == 1:
+        _add_csr(&acc, left, right, out, tol)
+    else:
+        _add_csr_scale(&acc, left, right, out, scale, tol)
+    acc_free(&acc)
+    return out
+
+
+cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale):
+    cdef int size = left.shape[0] * left.shape[1]
+    with nogil:
+        blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
+
+
+cdef Dense _add_dense_eq_order(Dense left, Dense right, double complex scale):
+    cdef Dense out = left.copy()
+    cdef int size = left.shape[0] * left.shape[1]
+    with nogil:
+        blas.zaxpy(&size, &scale, right.data, &_ONE, out.data, &_ONE)
+    return out
+
+
+cpdef Dense add_dense(Dense left, Dense right, double complex scale=1):
+    _check_shape(left, right)
+    if not (left.fortran ^ right.fortran):
+        return _add_dense_eq_order(left, right, scale)
+    cdef Dense out = left.copy()
+    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
+    # We always iterate through `left` and `out` in memory-layout order.
+    cdef int dim1, dim2
+    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
+    with nogil:
+        for idx in range(dim2):
+            blas.zaxpy(&dim1, &scale, right.data + idx, &dim2, out.data + idx*dim1, &_ONE)
+    return out
+
+
+cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
+    _check_shape(left, right)
+    cdef int size = left.shape[0] * left.shape[1]
+    cdef int dim1, dim2
+    cdef size_t nrows=left.shape[0], ncols=left.shape[1], idx
+    dim1, dim2 = (nrows, ncols) if left.fortran else (ncols, nrows)
+    with nogil:
+        if not (left.fortran ^ right.fortran):
+            blas.zaxpy(&size, &scale, right.data, &_ONE, left.data, &_ONE)
+        else:
+            for idx in range(dim2):
+                blas.zaxpy(&dim1, &scale, right.data + idx, &dim2,
+                           left.data + idx*dim1, &_ONE)
+    return left
+
+
+cpdef CSR sub_csr(CSR left, CSR right):
+    return add_csr(left, right, -1)
+
+
+cpdef Dense sub_dense(Dense left, Dense right):
+    return add_dense(left, right, -1)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+add = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='add',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+add.__doc__ =\
+    """
+    Perform the operation
+        left + scale*right
+    where `left` and `right` are matrices, and `scale` is an optional complex
+    scalar.
+    """
+add.add_specialisations([
+    (Dense, Dense, Dense, add_dense),
+    (CSR, CSR, CSR, add_csr),
+], _defer=True)
+
+sub = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='sub',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+sub.__doc__ =\
+    """
+    Perform the operation
+        left - right
+    where `left` and `right` are matrices.
+    """
+sub.add_specialisations([
+    (Dense, Dense, Dense, sub_dense),
+    (CSR, CSR, CSR, sub_csr),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/adjoint.pxd b/qutip/core/data/adjoint.pxd
index ced7be525e..793aac6409 100644
--- a/qutip/core/data/adjoint.pxd
+++ b/qutip/core/data/adjoint.pxd
@@ -1,12 +1,12 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-
-cpdef CSR adjoint_csr(CSR matrix)
-cpdef CSR transpose_csr(CSR matrix)
-cpdef CSR conj_csr(CSR matrix)
-
-cpdef Dense adjoint_dense(Dense matrix)
-cpdef Dense transpose_dense(Dense matrix)
-cpdef Dense conj_dense(Dense matrix)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+
+cpdef CSR adjoint_csr(CSR matrix)
+cpdef CSR transpose_csr(CSR matrix)
+cpdef CSR conj_csr(CSR matrix)
+
+cpdef Dense adjoint_dense(Dense matrix)
+cpdef Dense transpose_dense(Dense matrix)
+cpdef Dense conj_dense(Dense matrix)
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index 4f1543cdaa..ebff9e4d6c 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -1,160 +1,160 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset
-
-cimport cython
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data cimport csr, dense
-
-# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex _conj "conj"(double complex x)
-
-__all__ = [
-    'adjoint', 'adjoint_csr', 'adjoint_dense',
-    'conj', 'conj_csr', 'conj_dense',
-    'transpose', 'transpose_csr', 'transpose_dense',
-]
-
-
-cpdef CSR transpose_csr(CSR matrix):
-    """Transpose the CSR matrix, and return a new object."""
-    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
-    cdef idxint row, col, ptr, ptr_out
-    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
-    with nogil:
-        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr] + 1
-                out.row_index[col] += 1
-        for row in range(rows_out):
-            out.row_index[row + 1] += out.row_index[row]
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr]
-                ptr_out = out.row_index[col]
-                out.data[ptr_out] = matrix.data[ptr]
-                out.col_index[ptr_out] = row
-                out.row_index[col] = ptr_out + 1
-        for row in range(rows_out, 0, -1):
-            out.row_index[row] = out.row_index[row - 1]
-        out.row_index[0] = 0
-    return out
-
-
-cpdef CSR adjoint_csr(CSR matrix):
-    """Conjugate-transpose the CSR matrix, and return a new object."""
-    cdef idxint nnz_ = csr.nnz(matrix)
-    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
-    cdef idxint row, col, ptr, ptr_out
-    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
-    with nogil:
-        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr] + 1
-                out.row_index[col] += 1
-        for row in range(rows_out):
-            out.row_index[row + 1] += out.row_index[row]
-        for row in range(rows_in):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr]
-                ptr_out = out.row_index[col]
-                out.data[ptr_out] = _conj(matrix.data[ptr])
-                out.col_index[ptr_out] = row
-                out.row_index[col] = ptr_out + 1
-        for row in range(rows_out, 0, -1):
-            out.row_index[row] = out.row_index[row - 1]
-        out.row_index[0] = 0
-    return out
-
-
-cpdef CSR conj_csr(CSR matrix):
-    """Conjugate the CSR matrix, and return a new object."""
-    cdef CSR out = csr.copy_structure(matrix)
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            out.data[ptr] = _conj(matrix.data[ptr])
-    return out
-
-
-cpdef Dense adjoint_dense(Dense matrix):
-    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
-    out.shape = (out.shape[1], out.shape[0])
-    with nogil:
-        for ptr in range(matrix.shape[0] * matrix.shape[1]):
-            out.data[ptr] = _conj(matrix.data[ptr])
-    return out
-
-
-cpdef Dense transpose_dense(Dense matrix):
-    cdef Dense out = matrix.copy()
-    out.shape = (out.shape[1], out.shape[0])
-    out.fortran = not out.fortran
-    return out
-
-
-cpdef Dense conj_dense(Dense matrix):
-    cdef Dense out = dense.empty_like(matrix)
-    cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0] * matrix.shape[1]):
-            out.data[ptr] = _conj(matrix.data[ptr])
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-adjoint = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='adjoint',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
-adjoint.add_specialisations([
-    (Dense, Dense, adjoint_dense),
-    (CSR, CSR, adjoint_csr),
-], _defer=True)
-
-transpose = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='transpose',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-transpose.__doc__ = """Transpose of a matrix."""
-transpose.add_specialisations([
-    (Dense, Dense, transpose_dense),
-    (CSR, CSR, transpose_csr),
-], _defer=True)
-
-conj = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='conj',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-conj.__doc__ = """Element-wise conjugation of a matrix."""
-conj.add_specialisations([
-    (Dense, Dense, conj_dense),
-    (CSR, CSR, conj_csr),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset
+
+cimport cython
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data cimport csr, dense
+
+# Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex _conj "conj"(double complex x)
+
+__all__ = [
+    'adjoint', 'adjoint_csr', 'adjoint_dense',
+    'conj', 'conj_csr', 'conj_dense',
+    'transpose', 'transpose_csr', 'transpose_dense',
+]
+
+
+cpdef CSR transpose_csr(CSR matrix):
+    """Transpose the CSR matrix, and return a new object."""
+    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], csr.nnz(matrix))
+    cdef idxint row, col, ptr, ptr_out
+    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
+    with nogil:
+        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr] + 1
+                out.row_index[col] += 1
+        for row in range(rows_out):
+            out.row_index[row + 1] += out.row_index[row]
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr]
+                ptr_out = out.row_index[col]
+                out.data[ptr_out] = matrix.data[ptr]
+                out.col_index[ptr_out] = row
+                out.row_index[col] = ptr_out + 1
+        for row in range(rows_out, 0, -1):
+            out.row_index[row] = out.row_index[row - 1]
+        out.row_index[0] = 0
+    return out
+
+
+cpdef CSR adjoint_csr(CSR matrix):
+    """Conjugate-transpose the CSR matrix, and return a new object."""
+    cdef idxint nnz_ = csr.nnz(matrix)
+    cdef CSR out = csr.empty(matrix.shape[1], matrix.shape[0], nnz_)
+    cdef idxint row, col, ptr, ptr_out
+    cdef idxint rows_in=matrix.shape[0], rows_out=matrix.shape[1]
+    with nogil:
+        memset(&out.row_index[0], 0, (rows_out + 1) * sizeof(idxint))
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr] + 1
+                out.row_index[col] += 1
+        for row in range(rows_out):
+            out.row_index[row + 1] += out.row_index[row]
+        for row in range(rows_in):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr]
+                ptr_out = out.row_index[col]
+                out.data[ptr_out] = _conj(matrix.data[ptr])
+                out.col_index[ptr_out] = row
+                out.row_index[col] = ptr_out + 1
+        for row in range(rows_out, 0, -1):
+            out.row_index[row] = out.row_index[row - 1]
+        out.row_index[0] = 0
+    return out
+
+
+cpdef CSR conj_csr(CSR matrix):
+    """Conjugate the CSR matrix, and return a new object."""
+    cdef CSR out = csr.copy_structure(matrix)
+    cdef idxint ptr
+    with nogil:
+        for ptr in range(csr.nnz(matrix)):
+            out.data[ptr] = _conj(matrix.data[ptr])
+    return out
+
+
+cpdef Dense adjoint_dense(Dense matrix):
+    cdef Dense out = dense.empty_like(matrix, fortran=not matrix.fortran)
+    out.shape = (out.shape[1], out.shape[0])
+    with nogil:
+        for ptr in range(matrix.shape[0] * matrix.shape[1]):
+            out.data[ptr] = _conj(matrix.data[ptr])
+    return out
+
+
+cpdef Dense transpose_dense(Dense matrix):
+    cdef Dense out = matrix.copy()
+    out.shape = (out.shape[1], out.shape[0])
+    out.fortran = not out.fortran
+    return out
+
+
+cpdef Dense conj_dense(Dense matrix):
+    cdef Dense out = dense.empty_like(matrix)
+    cdef size_t ptr
+    with nogil:
+        for ptr in range(matrix.shape[0] * matrix.shape[1]):
+            out.data[ptr] = _conj(matrix.data[ptr])
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+adjoint = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='adjoint',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
+adjoint.add_specialisations([
+    (Dense, Dense, adjoint_dense),
+    (CSR, CSR, adjoint_csr),
+], _defer=True)
+
+transpose = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='transpose',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+transpose.__doc__ = """Transpose of a matrix."""
+transpose.add_specialisations([
+    (Dense, Dense, transpose_dense),
+    (CSR, CSR, transpose_csr),
+], _defer=True)
+
+conj = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='conj',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+conj.__doc__ = """Element-wise conjugation of a matrix."""
+conj.add_specialisations([
+    (Dense, Dense, conj_dense),
+    (CSR, CSR, conj_csr),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/base.pxd b/qutip/core/data/base.pxd
index 4aa8d08372..f34a80ff24 100644
--- a/qutip/core/data/base.pxd
+++ b/qutip/core/data/base.pxd
@@ -1,17 +1,17 @@
-#cython: language_level=3
-
-cdef extern from "src/intdtype.h":
-    # cython is smart enough to understand this int can be 32 or 64 bits.
-    ctypedef int idxint
-    cdef int _idxint_size
-
-cdef int idxint_DTYPE
-
-cdef class Data:
-    cdef readonly (idxint, idxint) shape
-    cpdef object to_array(self)
-    cpdef double complex trace(self)
-    cpdef Data adjoint(self)
-    cpdef Data conj(self)
-    cpdef Data transpose(self)
-    cpdef Data copy(self)
+#cython: language_level=3
+
+cdef extern from "src/intdtype.h":
+    # cython is smart enough to understand this int can be 32 or 64 bits.
+    ctypedef int idxint
+    cdef int _idxint_size
+
+cdef int idxint_DTYPE
+
+cdef class Data:
+    cdef readonly (idxint, idxint) shape
+    cpdef object to_array(self)
+    cpdef double complex trace(self)
+    cpdef Data adjoint(self)
+    cpdef Data conj(self)
+    cpdef Data transpose(self)
+    cpdef Data copy(self)
diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
index a7c599399d..a463bf3834 100644
--- a/qutip/core/data/base.pyx
+++ b/qutip/core/data/base.pyx
@@ -1,89 +1,89 @@
-#cython: language_level=3
-
-import numpy as np
-cimport numpy as cnp
-import qutip.core.data as _data
-from qutip.settings import settings
-
-__all__ = [
-    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
-]
-
-if _idxint_size == 32:
-    idxint_dtype = np.int32
-    idxint_DTYPE = cnp.NPY_INT32
-else:
-    idxint_dtype = np.int64
-    idxint_DTYPE = cnp.NPY_INT64
-
-idxint_size = _idxint_size
-
-# As this is an abstract base class with C entry points, we have to explicitly
-# stub out methods since we can't mark them as abstract.
-cdef class Data:
-    def __init__(self, shape):
-        self.shape = shape
-
-    cpdef object to_array(self):
-        raise NotImplementedError
-
-    cpdef double complex trace(self):
-        return NotImplementedError
-
-    cpdef Data adjoint(self):
-        raise NotImplementedError
-
-    cpdef Data conj(self):
-        raise NotImplementedError
-
-    cpdef Data transpose(self):
-        raise NotImplementedError
-
-    cpdef Data copy(self):
-        raise NotImplementedError
-
-    def __add__(left, right):
-        if isinstance(left, Data) and isinstance(right, Data):
-            return _data.add(left, right)
-        return NotImplemented
-
-    def __sub__(left, right):
-        if isinstance(left, Data) and isinstance(right, Data):
-            return _data.sub(left, right)
-        return NotImplemented
-
-    def __matmul__(left, right):
-        if isinstance(left, Data) and isinstance(right, Data):
-            return _data.matmul(left, right)
-        return NotImplemented
-
-    def __mul__(left, right):
-        data, number = (left, right) if isinstance(left, Data) else (right, left)
-        try:
-            return _data.mul(data, number)
-        except TypeError:
-            return NotImplemented
-
-    def __truediv__(left, right):
-        data, number = (left, right) if isinstance(left, Data) else (right, left)
-        try:
-            return _data.mul(data, 1/number)
-        except TypeError:
-            return NotImplemented
-
-    def __neg__(self):
-        return _data.neg(self)
-
-    def __eq__(left, right):
-        if not (isinstance(left, Data) and isinstance(right, Data)):
-            return NotImplemented
-        if (
-            left.shape[0] == right.shape[0]
-            and left.shape[1] == right.shape[1]
-        ):
-            return _data.iszero(_data.sub(left, right), settings.core['atol'])
-        return False
-
-
-class EfficiencyWarning(Warning):
-    pass
+#cython: language_level=3
+
+import numpy as np
+cimport numpy as cnp
+import qutip.core.data as _data
+from qutip.settings import settings
+
+__all__ = [
+    'idxint_size', 'idxint_dtype', 'Data', 'EfficiencyWarning',
+]
+
+if _idxint_size == 32:
+    idxint_dtype = np.int32
+    idxint_DTYPE = cnp.NPY_INT32
+else:
+    idxint_dtype = np.int64
+    idxint_DTYPE = cnp.NPY_INT64
+
+idxint_size = _idxint_size
+
+# As this is an abstract base class with C entry points, we have to explicitly
+# stub out methods since we can't mark them as abstract.
+cdef class Data:
+    def __init__(self, shape):
+        self.shape = shape
+
+    cpdef object to_array(self):
+        raise NotImplementedError
+
+    cpdef double complex trace(self):
+        return NotImplementedError
+
+    cpdef Data adjoint(self):
+        raise NotImplementedError
+
+    cpdef Data conj(self):
+        raise NotImplementedError
+
+    cpdef Data transpose(self):
+        raise NotImplementedError
+
+    cpdef Data copy(self):
+        raise NotImplementedError
+
+    def __add__(left, right):
+        if isinstance(left, Data) and isinstance(right, Data):
+            return _data.add(left, right)
+        return NotImplemented
+
+    def __sub__(left, right):
+        if isinstance(left, Data) and isinstance(right, Data):
+            return _data.sub(left, right)
+        return NotImplemented
+
+    def __matmul__(left, right):
+        if isinstance(left, Data) and isinstance(right, Data):
+            return _data.matmul(left, right)
+        return NotImplemented
+
+    def __mul__(left, right):
+        data, number = (left, right) if isinstance(left, Data) else (right, left)
+        try:
+            return _data.mul(data, number)
+        except TypeError:
+            return NotImplemented
+
+    def __truediv__(left, right):
+        data, number = (left, right) if isinstance(left, Data) else (right, left)
+        try:
+            return _data.mul(data, 1/number)
+        except TypeError:
+            return NotImplemented
+
+    def __neg__(self):
+        return _data.neg(self)
+
+    def __eq__(left, right):
+        if not (isinstance(left, Data) and isinstance(right, Data)):
+            return NotImplemented
+        if (
+            left.shape[0] == right.shape[0]
+            and left.shape[1] == right.shape[1]
+        ):
+            return _data.iszero(_data.sub(left, right), settings.core['atol'])
+        return False
+
+
+class EfficiencyWarning(Warning):
+    pass
diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 6f850d22c9..a60341a364 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -1,73 +1,73 @@
-# This module exists to supply a couple of very standard constant matrices
-# which are used in the data layer, and within `Qobj` itself.  Other matrices
-# (e.g. `create`) should not be here, but should be defined within the
-# higher-level components of QuTiP instead.
-
-from . import csr, dense
-from .csr import CSR
-from .dense import Dense
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-__all__ = ['zeros', 'identity']
-
-zeros = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='zeros',
-    module=__name__,
-    inputs=(),
-    out=True,
-)
-zeros.__doc__ =\
-    """
-    Create matrix representation of 0 with the given dimensions.
-
-    Depending on the selected output type, this may or may not actually
-    contained explicit values; sparse matrices will typically contain nothing
-    (which is their representation of 0), and dense matrices will still be
-    filled.
-
-    Parameters
-    ----------
-    rows, cols : int
-        The number of rows and columns in the output matrix.
-    """
-zeros.add_specialisations([
-    (CSR, csr.zeros),
-    (Dense, dense.zeros),
-], _defer=True)
-
-identity = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('dimension',
-                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='identity',
-    module=__name__,
-    inputs=(),
-    out=True,
-)
-identity.__doc__ =\
-    """
-    Create a square identity matrix of the given dimension.  Optionally, the
-    `scale` can be given, where all the diagonal elements will be that instead
-    of 1.
-
-    Parameters
-    ----------
-    dimension : int
-        The dimension of the square output identity matrix.
-    scale : complex, optional
-        The element which should be placed on the diagonal.
-    """
-identity.add_specialisations([
-    (CSR, csr.identity),
-    (Dense, dense.identity),
-], _defer=True)
-
-del _Dispatcher, _inspect
+# This module exists to supply a couple of very standard constant matrices
+# which are used in the data layer, and within `Qobj` itself.  Other matrices
+# (e.g. `create`) should not be here, but should be defined within the
+# higher-level components of QuTiP instead.
+
+from . import csr, dense
+from .csr import CSR
+from .dense import Dense
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+__all__ = ['zeros', 'identity']
+
+zeros = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('cols', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='zeros',
+    module=__name__,
+    inputs=(),
+    out=True,
+)
+zeros.__doc__ =\
+    """
+    Create matrix representation of 0 with the given dimensions.
+
+    Depending on the selected output type, this may or may not actually
+    contained explicit values; sparse matrices will typically contain nothing
+    (which is their representation of 0), and dense matrices will still be
+    filled.
+
+    Parameters
+    ----------
+    rows, cols : int
+        The number of rows and columns in the output matrix.
+    """
+zeros.add_specialisations([
+    (CSR, csr.zeros),
+    (Dense, dense.zeros),
+], _defer=True)
+
+identity = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('dimension',
+                           _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='identity',
+    module=__name__,
+    inputs=(),
+    out=True,
+)
+identity.__doc__ =\
+    """
+    Create a square identity matrix of the given dimension.  Optionally, the
+    `scale` can be given, where all the diagonal elements will be that instead
+    of 1.
+
+    Parameters
+    ----------
+    dimension : int
+        The dimension of the square output identity matrix.
+    scale : complex, optional
+        The element which should be placed on the diagonal.
+    """
+identity.add_specialisations([
+    (CSR, csr.identity),
+    (Dense, dense.identity),
+], _defer=True)
+
+del _Dispatcher, _inspect
diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index 6826ac818a..c2feed3dd1 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -1,436 +1,436 @@
-#cython: language_level=3
-
-"""
-The conversion machinery between different data-layer types, and creation
-routines from arbitrary data.  The classes `_to` and `_create` are not intended
-to be exported names, but are the backing machinery of the functions `data.to`
-and `data.create`, which are built up as the last objects in the `__init__.py`
-initialisation of the `data` module.
-"""
-
-# This module is compiled by Cython because it's the core of the entire
-# dispatch table, and having it compiled to a C extension saves about 1µs per
-# call.  This is not much at all, and there's very little which benefits from
-# Cython compiliation, but such core functionality is called millions of times
-# even in a simple interactive QuTiP session, and it all adds up.
-
-import numbers
-
-import numpy as np
-from scipy.sparse import dok_matrix, csgraph
-cimport cython
-
-__all__ = ['to', 'create']
-
-
-def _raise_if_unconnected(dtype_list, weights):
-    unconnected = {}
-    for i, type_ in enumerate(dtype_list):
-        missing = [dtype_list[j].__name__
-                   for j, weight in enumerate(weights[:, i])
-                   if weight == np.inf]
-        if missing:
-            unconnected[type_.__name__] = missing
-    if unconnected:
-        message = "Conversion graph not connected.  Cannot reach:\n * "
-        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
-                                for to, froms in unconnected.items())
-        raise NotImplementedError(message)
-
-
-cdef class _converter:
-    """Callable which converts objects of type `x.from_` to type `x.to`."""
-
-    cdef list functions
-    cdef Py_ssize_t n_functions
-    cdef readonly type to
-    cdef readonly type from_
-
-    def __init__(self, functions, to_type, from_type):
-        self.functions = list(functions)
-        self.n_functions = len(self.functions)
-        self.to = to_type
-        self.from_ = from_type
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def __call__(self, arg):
-        if not isinstance(arg, self.from_):
-            raise TypeError(str(arg) + " is not of type " + str(self.from_))
-        cdef Py_ssize_t i
-        for i in range(self.n_functions):
-            arg = self.functions[i](arg)
-        return arg
-
-    def __repr__(self):
-        return ("<converter to "
-                + self.to.__name__
-                + " from " + self.from_.__name__
-                + ">")
-
-
-cdef class _partial_converter:
-    """Convert from any known data-layer type into the type `x.to`."""
-
-    cdef dict converters
-    cdef readonly type to
-
-    def __init__(self, converters, to_type):
-        self.converters = dict(converters)
-        self.to = to_type
-
-    def __call__(self, arg):
-        try:
-            return self.converters[type(arg)](arg)
-        except KeyError:
-            raise TypeError("unknown type of input: " + str(arg)) from None
-
-    def __repr__(self):
-        return "<converter to " + self.to.__name__ + ">"
-
-
-# While `_to` and `_create` are defined as objects here, they are actually
-# exported by `data.__init__.py` as singleton function objects of their
-# respective types (without the leading underscore).
-
-cdef class _to:
-    """
-    Convert data into a different type.  This object is the knowledge source
-    for every allowable data-layer type in QuTiP, and provides the conversions
-    between all of them.
-
-    The base use is to call this object as a function with signature
-        (type, data) -> converted_data
-    where `type` is a type object (such as `data.CSR`, or that obtained by
-    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
-    want to create a data-layer type from non-data-layer data, use `create`
-    instead.
-
-    You can get individual converters by using the key-lookup syntax.  For
-    example, the item
-        to[CSR, Dense]
-    is a callable which accepts arguments of type `Dense` and returns the
-    equivalent item of type `CSR`.  You can also get a generic converter to a
-    particular data type if only one type is specified, so
-        to[Dense]
-    is a callable which accepts all known (at the time of the lookup)
-    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
-    section below for more detail.
-
-    Internally, the conversion process may go through several steps if new
-    data-layer types have been defined with few conversions specified between
-    them and the pre-existing converters.  The first-class QuTiP data types
-    `Dense` and `CSR` will typically have the best connectivity.
-
-
-    Adding new types
-    ----------------
-    You can add new data-layer types by calling the `add_conversions` method of
-    this object, and then rebuilding all of the mathematical dispatchers.  See
-    the docstring of that method for more information.
-
-
-    Efficiency notes
-    ----------------
-    From an efficiency perspective, there is very little benefit to using the
-    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
-    `to[to_type, type(data)]`, so storing the object elides the creation of a
-    single tuple and a dict lookup, but the cost of this is generally less than
-    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
-    efficient than the general call at all, but can be used in cases where a
-    single callable is required and is more efficient than `functools.partial`.
-    """
-
-    cdef readonly set dtypes
-    cdef readonly list dispatchers
-    cdef dict _direct_convert
-    cdef dict _convert
-    cdef readonly dict weight
-    cdef readonly dict _str2type
-
-    def __init__(self):
-        self._direct_convert = {}
-        self._convert = {}
-        self.dtypes = set()
-        self.weight = {}
-        self.dispatchers = []
-        self._str2type = {}
-
-    def add_conversions(self, converters):
-        """
-        Add conversion functions between different data types.  This is an
-        advanced function, and is only intended for the QuTiP user who wants to
-        add a new underlying data type to QuTiP.
-
-        Any new data type must have at least one converter function given to
-        produce the new data type from an existing data type, and at least one
-        which produces an existing data type from the new one.  You need not
-        specify any more than this, although for efficiency reasons, you may
-        want to specify direct conversions for all types you expect the new
-        type to interact with frequently.
-
-        Parameters
-        ----------
-        converters : iterable of (to_type, from_type, converter, [weight])
-            An iterable of 3- or 4-tuples describing all the new conversions.
-            Each element can individually be a 3- or 4-tuple; they do not need
-            to be all one or the other.
-
-            Elements
-            ........
-            to_type : type
-                The data-layer type that is output by the converter.
-
-            from_type : type
-                The data-layer type to be input to the converter.
-
-            converter : callable (Data -> Data)
-                The converter function.  This should take a single argument
-                (the input data-layer function) and output a data-layer object
-                of `to_type`.  The converter may assume without error checking
-                that its input will always be of `to_type`.  It is safe to
-                specify the same conversion function for multiple inputs so
-                long as the function handles them all safely, but it must
-                always return a single output type.
-
-            weight : positive real, optional (1)
-                The weight associated with this conversion.  This must be > 0,
-                and defaults to `1` if not supplied (which is fixed to be the
-                cost of conversion to `Dense` from `CSR`).  It is generally
-                safe just to leave this blank; it is always at best an
-                approximation.  The currently defined weights are accessible in
-                the `weights` attribute of this object.
-        """
-        for arg in converters:
-            if len(arg) == 3:
-                to_type, from_type, converter = arg
-                weight = 1
-            elif len(arg) == 4:
-                to_type, from_type, converter, weight = arg
-            else:
-                raise TypeError("unknown converter specification: " + str(arg))
-            if not isinstance(to_type, type):
-                raise TypeError(repr(to_type) + " is not a type object")
-            if not isinstance(from_type, type):
-                raise TypeError(repr(from_type) + " is not a type object")
-            if not isinstance(weight, numbers.Real) or weight <= 0:
-                raise TypeError("weight " + repr(weight) + " is not valid")
-            self.dtypes.add(from_type)
-            self.dtypes.add(to_type)
-            self._direct_convert[(to_type, from_type)] = (converter, weight)
-        # Two-way mapping to convert between the type of a dtype and an integer
-        # enumeration value for it.
-        order, index = [], {}
-        for i, dtype in enumerate(self.dtypes):
-            order.append(dtype)
-            index[dtype] = i
-        # Treat the conversion problem as a shortest-path graph problem.  We
-        # build up the graph description as a matrix, then solve the
-        # all-pairs-shortest-path problem.  We forbid negative weights and
-        # there are unlikely to be many data types, so the choice of algorithm
-        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
-        graph = dok_matrix((len(order), len(order)))
-        for (to_type, from_type), (_, weight) in self._direct_convert.items():
-            graph[index[from_type], index[to_type]] = weight
-        weights, predecessors =\
-            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
-        _raise_if_unconnected(order, weights)
-        # Build the whole shortest path conversion lookup.  We directly store
-        # all complete shortest paths, even though this is not the most memory
-        # efficient, because we expect that there will generally be a small
-        # number of available data types, and we care more about minimising the
-        # number of lookups required.
-        self.weight = {}
-        self._convert = {}
-        for i, from_t in enumerate(order):
-            for j, to_t in enumerate(order):
-                convert = []
-                weight = 0
-                cur_t = to_t
-                pred_i = predecessors[i, j]
-                while pred_i >= 0:
-                    pred_t = order[pred_i]
-                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
-                    convert.append(_convert)
-                    weight += _weight
-                    cur_t = pred_t
-                    pred_i = predecessors[i, pred_i]
-                self.weight[(to_t, from_t)] = weight
-                self._convert[(to_t, from_t)] =\
-                    _converter(convert[::-1], to_t, from_t)
-        for dispatcher in self.dispatchers:
-            dispatcher.rebuild_lookup()
-
-    def register_aliases(self, aliases, layer_type):
-        """
-        Register a user frendly name for a data-layer type to be recognized by
-        the :method:`parse` method.
-
-        Parameters
-        ----------
-        aliases : str or list of str
-            Name of list of names to be understood to represent the layer_type.
-
-        layer_type : type
-            Data-layer type, must have been registered with
-            :method:`add_conversions` first.
-        """
-        if layer_type not in self.dtypes:
-            raise ValueError(
-                "Type is not a data-layer type: " + repr(layer_type))
-        if isinstance(aliases, str):
-            aliases = [aliases]
-        for alias in aliases:
-            if type(alias) is not str:
-                raise TypeError("The alias must be a str : " + repr(alias))
-            self._str2type[alias] = layer_type
-
-    def parse(self, dtype):
-        """
-        Return a data-layer type object given its name or the type itself.
-
-        Parameters
-        ----------
-        dtype : type, str
-            Either the name of a data-layer type or a type itself.
-
-        Returns
-        -------
-        type
-            A data-layer type.
-
-        Raises
-        ------
-        TypeError
-            If ``dtype`` is neither a string nor a type.
-        ValueError
-            If ``dtype`` is a name, but no data-layer type of that name is
-            registered, or if ``dtype`` is a type, but not a known data-layer
-            type.
-        """
-        if type(dtype) is type:
-            if dtype not in self.dtypes:
-                raise ValueError(
-                    "Type is not a data-layer type: " + repr(dtype))
-            return dtype
-        elif type(dtype) is str:
-            try:
-                return self._str2type[dtype]
-            except KeyError:
-                raise ValueError(
-                    "Type name is not known to the data-layer: " + repr(dtype)
-                    ) from None
-
-        raise TypeError(
-            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def __getitem__(self, arg):
-        if type(arg) is not tuple:
-            arg = (arg,)
-        if not arg or len(arg) > 2:
-            raise KeyError(arg)
-        to_t = self.parse(arg[0])
-        if len(arg) == 1:
-            converters = {
-                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
-            }
-            return _partial_converter(converters, to_t)
-        from_t = self.parse(arg[1])
-        return self._convert[to_t, from_t]
-
-    def __call__(self, to_type, data):
-        to_type = self.parse(to_type)
-        from_type = self.parse(type(data))
-        if to_type == from_type:
-            return data
-        return self._convert[to_type, from_type](data)
-
-
-cdef class _create:
-    cdef readonly list _creators
-
-    def __init__(self):
-        self._creators = []
-
-    def add_creators(self, creators):
-        """
-        Add creation functions to make a data-layer object from an arbitrary
-        Python object.
-
-        Parameters
-        ----------
-        creators : iterable of (condition, creator, [priority])
-            An iterable of 2- or 3-tuples describing the new data layer
-            creation functions.
-            Each element can individually be a 2- or 3-tuple; they do not need
-            to be all one or the other.
-
-            Elements
-            ........
-            condition : callable (object) -> bool
-                Function determining if the given object can be converted to a
-                data-layer type using this creator.
-
-            creator function: callable (object, shape, copy=True) -> Data
-                The creator function. It should take an object and a shape and
-                return a data-layer type instance. The object may be any object
-                for which the condition function returned ``True`` when tested.
-                The ``object`` and ``shape`` parameters are passed positionally,
-                and the ``copy`` parameter is passed by keyword.
-
-            priority : real, optional (0)
-                The priority associated with this creator. Higher priority
-                conditions will be tested first and the first valid creator
-                (i.e. for which ``condition(object) == True``) will handle
-                the creation.
-
-        Notes
-        -----
-        Default creators are added with the following priorities:
-
-        * Objects that are instances of data-layer types are
-          converted using ``.copy`` with priority 100.
-        * Objects that have a direct equivalent such as ``numpy.ndarray``
-          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
-        * Objects for which ``scipy.sparse.issparse`` is ``True``
-          are converted using an internal CSR converter with
-          priority 20.
-        * If no condition are meet, ``numpy.array`` is used to try convert
-          the input to an array (priority -inf).
-        """
-        for condition, creator, *priority in creators:
-            if not callable(condition):
-                raise TypeError(repr(condition) + " is not a callable")
-            if not callable(create):
-                raise TypeError(repr(create) + " is not a callable")
-            if len(priority) >= 2:
-                raise ValueError("Too many values to unpack for a creator, " +
-                                 "expected 2 or 3, got "+ str(2+len(priority)))
-            priority = float(priority[0] if priority else 0)
-            self._creators.append((condition, creator, priority))
-        self._creators.sort(key=lambda creator: creator[2], reverse=True)
-
-    def __call__(self, arg, shape=None, copy=True):
-        """
-        Build a :class:`qutip.data.Data` object from arg.
-
-        Parameters
-        ----------
-        arg : object
-            Object to be converted to `qutip.data.Data`. Anything that can be
-            converted to a numpy array are valid input.
-
-        shape : tuple, optional
-            The shape of the output as (``rows``, ``columns``).
-        """
-        for condition, create, _ in self._creators:
-            if condition(arg):
-                return create(arg, shape, copy=copy)
-        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
-                        "qutip data format")
-
-
-to = _to()
-create = _create()
+#cython: language_level=3
+
+"""
+The conversion machinery between different data-layer types, and creation
+routines from arbitrary data.  The classes `_to` and `_create` are not intended
+to be exported names, but are the backing machinery of the functions `data.to`
+and `data.create`, which are built up as the last objects in the `__init__.py`
+initialisation of the `data` module.
+"""
+
+# This module is compiled by Cython because it's the core of the entire
+# dispatch table, and having it compiled to a C extension saves about 1µs per
+# call.  This is not much at all, and there's very little which benefits from
+# Cython compiliation, but such core functionality is called millions of times
+# even in a simple interactive QuTiP session, and it all adds up.
+
+import numbers
+
+import numpy as np
+from scipy.sparse import dok_matrix, csgraph
+cimport cython
+
+__all__ = ['to', 'create']
+
+
+def _raise_if_unconnected(dtype_list, weights):
+    unconnected = {}
+    for i, type_ in enumerate(dtype_list):
+        missing = [dtype_list[j].__name__
+                   for j, weight in enumerate(weights[:, i])
+                   if weight == np.inf]
+        if missing:
+            unconnected[type_.__name__] = missing
+    if unconnected:
+        message = "Conversion graph not connected.  Cannot reach:\n * "
+        message += "\n * ".join(to + " from (" + ", ".join(froms) + ")"
+                                for to, froms in unconnected.items())
+        raise NotImplementedError(message)
+
+
+cdef class _converter:
+    """Callable which converts objects of type `x.from_` to type `x.to`."""
+
+    cdef list functions
+    cdef Py_ssize_t n_functions
+    cdef readonly type to
+    cdef readonly type from_
+
+    def __init__(self, functions, to_type, from_type):
+        self.functions = list(functions)
+        self.n_functions = len(self.functions)
+        self.to = to_type
+        self.from_ = from_type
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    def __call__(self, arg):
+        if not isinstance(arg, self.from_):
+            raise TypeError(str(arg) + " is not of type " + str(self.from_))
+        cdef Py_ssize_t i
+        for i in range(self.n_functions):
+            arg = self.functions[i](arg)
+        return arg
+
+    def __repr__(self):
+        return ("<converter to "
+                + self.to.__name__
+                + " from " + self.from_.__name__
+                + ">")
+
+
+cdef class _partial_converter:
+    """Convert from any known data-layer type into the type `x.to`."""
+
+    cdef dict converters
+    cdef readonly type to
+
+    def __init__(self, converters, to_type):
+        self.converters = dict(converters)
+        self.to = to_type
+
+    def __call__(self, arg):
+        try:
+            return self.converters[type(arg)](arg)
+        except KeyError:
+            raise TypeError("unknown type of input: " + str(arg)) from None
+
+    def __repr__(self):
+        return "<converter to " + self.to.__name__ + ">"
+
+
+# While `_to` and `_create` are defined as objects here, they are actually
+# exported by `data.__init__.py` as singleton function objects of their
+# respective types (without the leading underscore).
+
+cdef class _to:
+    """
+    Convert data into a different type.  This object is the knowledge source
+    for every allowable data-layer type in QuTiP, and provides the conversions
+    between all of them.
+
+    The base use is to call this object as a function with signature
+        (type, data) -> converted_data
+    where `type` is a type object (such as `data.CSR`, or that obtained by
+    calling `type(matrix)`) and `data` is data in a data-layer type.  If you
+    want to create a data-layer type from non-data-layer data, use `create`
+    instead.
+
+    You can get individual converters by using the key-lookup syntax.  For
+    example, the item
+        to[CSR, Dense]
+    is a callable which accepts arguments of type `Dense` and returns the
+    equivalent item of type `CSR`.  You can also get a generic converter to a
+    particular data type if only one type is specified, so
+        to[Dense]
+    is a callable which accepts all known (at the time of the lookup)
+    data-layer types, and converts them to `Dense`.  See the `Efficiency notes`
+    section below for more detail.
+
+    Internally, the conversion process may go through several steps if new
+    data-layer types have been defined with few conversions specified between
+    them and the pre-existing converters.  The first-class QuTiP data types
+    `Dense` and `CSR` will typically have the best connectivity.
+
+
+    Adding new types
+    ----------------
+    You can add new data-layer types by calling the `add_conversions` method of
+    this object, and then rebuilding all of the mathematical dispatchers.  See
+    the docstring of that method for more information.
+
+
+    Efficiency notes
+    ----------------
+    From an efficiency perspective, there is very little benefit to using the
+    key-lookup syntax.  Internally, `to(to_type, data)` effectively calls
+    `to[to_type, type(data)]`, so storing the object elides the creation of a
+    single tuple and a dict lookup, but the cost of this is generally less than
+    500ns.  Using the one-argument lookup (e.g. `to[Dense]`) is no more
+    efficient than the general call at all, but can be used in cases where a
+    single callable is required and is more efficient than `functools.partial`.
+    """
+
+    cdef readonly set dtypes
+    cdef readonly list dispatchers
+    cdef dict _direct_convert
+    cdef dict _convert
+    cdef readonly dict weight
+    cdef readonly dict _str2type
+
+    def __init__(self):
+        self._direct_convert = {}
+        self._convert = {}
+        self.dtypes = set()
+        self.weight = {}
+        self.dispatchers = []
+        self._str2type = {}
+
+    def add_conversions(self, converters):
+        """
+        Add conversion functions between different data types.  This is an
+        advanced function, and is only intended for the QuTiP user who wants to
+        add a new underlying data type to QuTiP.
+
+        Any new data type must have at least one converter function given to
+        produce the new data type from an existing data type, and at least one
+        which produces an existing data type from the new one.  You need not
+        specify any more than this, although for efficiency reasons, you may
+        want to specify direct conversions for all types you expect the new
+        type to interact with frequently.
+
+        Parameters
+        ----------
+        converters : iterable of (to_type, from_type, converter, [weight])
+            An iterable of 3- or 4-tuples describing all the new conversions.
+            Each element can individually be a 3- or 4-tuple; they do not need
+            to be all one or the other.
+
+            Elements
+            ........
+            to_type : type
+                The data-layer type that is output by the converter.
+
+            from_type : type
+                The data-layer type to be input to the converter.
+
+            converter : callable (Data -> Data)
+                The converter function.  This should take a single argument
+                (the input data-layer function) and output a data-layer object
+                of `to_type`.  The converter may assume without error checking
+                that its input will always be of `to_type`.  It is safe to
+                specify the same conversion function for multiple inputs so
+                long as the function handles them all safely, but it must
+                always return a single output type.
+
+            weight : positive real, optional (1)
+                The weight associated with this conversion.  This must be > 0,
+                and defaults to `1` if not supplied (which is fixed to be the
+                cost of conversion to `Dense` from `CSR`).  It is generally
+                safe just to leave this blank; it is always at best an
+                approximation.  The currently defined weights are accessible in
+                the `weights` attribute of this object.
+        """
+        for arg in converters:
+            if len(arg) == 3:
+                to_type, from_type, converter = arg
+                weight = 1
+            elif len(arg) == 4:
+                to_type, from_type, converter, weight = arg
+            else:
+                raise TypeError("unknown converter specification: " + str(arg))
+            if not isinstance(to_type, type):
+                raise TypeError(repr(to_type) + " is not a type object")
+            if not isinstance(from_type, type):
+                raise TypeError(repr(from_type) + " is not a type object")
+            if not isinstance(weight, numbers.Real) or weight <= 0:
+                raise TypeError("weight " + repr(weight) + " is not valid")
+            self.dtypes.add(from_type)
+            self.dtypes.add(to_type)
+            self._direct_convert[(to_type, from_type)] = (converter, weight)
+        # Two-way mapping to convert between the type of a dtype and an integer
+        # enumeration value for it.
+        order, index = [], {}
+        for i, dtype in enumerate(self.dtypes):
+            order.append(dtype)
+            index[dtype] = i
+        # Treat the conversion problem as a shortest-path graph problem.  We
+        # build up the graph description as a matrix, then solve the
+        # all-pairs-shortest-path problem.  We forbid negative weights and
+        # there are unlikely to be many data types, so the choice of algorithm
+        # is unimportant (Dijkstra's, Floyd--Warshall, Bellman--Ford, etc).
+        graph = dok_matrix((len(order), len(order)))
+        for (to_type, from_type), (_, weight) in self._direct_convert.items():
+            graph[index[from_type], index[to_type]] = weight
+        weights, predecessors =\
+            csgraph.floyd_warshall(graph.tocsr(), return_predecessors=True)
+        _raise_if_unconnected(order, weights)
+        # Build the whole shortest path conversion lookup.  We directly store
+        # all complete shortest paths, even though this is not the most memory
+        # efficient, because we expect that there will generally be a small
+        # number of available data types, and we care more about minimising the
+        # number of lookups required.
+        self.weight = {}
+        self._convert = {}
+        for i, from_t in enumerate(order):
+            for j, to_t in enumerate(order):
+                convert = []
+                weight = 0
+                cur_t = to_t
+                pred_i = predecessors[i, j]
+                while pred_i >= 0:
+                    pred_t = order[pred_i]
+                    _convert, _weight = self._direct_convert[(cur_t, pred_t)]
+                    convert.append(_convert)
+                    weight += _weight
+                    cur_t = pred_t
+                    pred_i = predecessors[i, pred_i]
+                self.weight[(to_t, from_t)] = weight
+                self._convert[(to_t, from_t)] =\
+                    _converter(convert[::-1], to_t, from_t)
+        for dispatcher in self.dispatchers:
+            dispatcher.rebuild_lookup()
+
+    def register_aliases(self, aliases, layer_type):
+        """
+        Register a user frendly name for a data-layer type to be recognized by
+        the :method:`parse` method.
+
+        Parameters
+        ----------
+        aliases : str or list of str
+            Name of list of names to be understood to represent the layer_type.
+
+        layer_type : type
+            Data-layer type, must have been registered with
+            :method:`add_conversions` first.
+        """
+        if layer_type not in self.dtypes:
+            raise ValueError(
+                "Type is not a data-layer type: " + repr(layer_type))
+        if isinstance(aliases, str):
+            aliases = [aliases]
+        for alias in aliases:
+            if type(alias) is not str:
+                raise TypeError("The alias must be a str : " + repr(alias))
+            self._str2type[alias] = layer_type
+
+    def parse(self, dtype):
+        """
+        Return a data-layer type object given its name or the type itself.
+
+        Parameters
+        ----------
+        dtype : type, str
+            Either the name of a data-layer type or a type itself.
+
+        Returns
+        -------
+        type
+            A data-layer type.
+
+        Raises
+        ------
+        TypeError
+            If ``dtype`` is neither a string nor a type.
+        ValueError
+            If ``dtype`` is a name, but no data-layer type of that name is
+            registered, or if ``dtype`` is a type, but not a known data-layer
+            type.
+        """
+        if type(dtype) is type:
+            if dtype not in self.dtypes:
+                raise ValueError(
+                    "Type is not a data-layer type: " + repr(dtype))
+            return dtype
+        elif type(dtype) is str:
+            try:
+                return self._str2type[dtype]
+            except KeyError:
+                raise ValueError(
+                    "Type name is not known to the data-layer: " + repr(dtype)
+                    ) from None
+
+        raise TypeError(
+            "Invalid dtype is neither a type nor a type name: " + repr(dtype))
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    def __getitem__(self, arg):
+        if type(arg) is not tuple:
+            arg = (arg,)
+        if not arg or len(arg) > 2:
+            raise KeyError(arg)
+        to_t = self.parse(arg[0])
+        if len(arg) == 1:
+            converters = {
+                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
+            }
+            return _partial_converter(converters, to_t)
+        from_t = self.parse(arg[1])
+        return self._convert[to_t, from_t]
+
+    def __call__(self, to_type, data):
+        to_type = self.parse(to_type)
+        from_type = self.parse(type(data))
+        if to_type == from_type:
+            return data
+        return self._convert[to_type, from_type](data)
+
+
+cdef class _create:
+    cdef readonly list _creators
+
+    def __init__(self):
+        self._creators = []
+
+    def add_creators(self, creators):
+        """
+        Add creation functions to make a data-layer object from an arbitrary
+        Python object.
+
+        Parameters
+        ----------
+        creators : iterable of (condition, creator, [priority])
+            An iterable of 2- or 3-tuples describing the new data layer
+            creation functions.
+            Each element can individually be a 2- or 3-tuple; they do not need
+            to be all one or the other.
+
+            Elements
+            ........
+            condition : callable (object) -> bool
+                Function determining if the given object can be converted to a
+                data-layer type using this creator.
+
+            creator function: callable (object, shape, copy=True) -> Data
+                The creator function. It should take an object and a shape and
+                return a data-layer type instance. The object may be any object
+                for which the condition function returned ``True`` when tested.
+                The ``object`` and ``shape`` parameters are passed positionally,
+                and the ``copy`` parameter is passed by keyword.
+
+            priority : real, optional (0)
+                The priority associated with this creator. Higher priority
+                conditions will be tested first and the first valid creator
+                (i.e. for which ``condition(object) == True``) will handle
+                the creation.
+
+        Notes
+        -----
+        Default creators are added with the following priorities:
+
+        * Objects that are instances of data-layer types are
+          converted using ``.copy`` with priority 100.
+        * Objects that have a direct equivalent such as ``numpy.ndarray``
+          or ``scipy.sparse.csr_matrix`` are converted with priority 80.
+        * Objects for which ``scipy.sparse.issparse`` is ``True``
+          are converted using an internal CSR converter with
+          priority 20.
+        * If no condition are meet, ``numpy.array`` is used to try convert
+          the input to an array (priority -inf).
+        """
+        for condition, creator, *priority in creators:
+            if not callable(condition):
+                raise TypeError(repr(condition) + " is not a callable")
+            if not callable(create):
+                raise TypeError(repr(create) + " is not a callable")
+            if len(priority) >= 2:
+                raise ValueError("Too many values to unpack for a creator, " +
+                                 "expected 2 or 3, got "+ str(2+len(priority)))
+            priority = float(priority[0] if priority else 0)
+            self._creators.append((condition, creator, priority))
+        self._creators.sort(key=lambda creator: creator[2], reverse=True)
+
+    def __call__(self, arg, shape=None, copy=True):
+        """
+        Build a :class:`qutip.data.Data` object from arg.
+
+        Parameters
+        ----------
+        arg : object
+            Object to be converted to `qutip.data.Data`. Anything that can be
+            converted to a numpy array are valid input.
+
+        shape : tuple, optional
+            The shape of the output as (``rows``, ``columns``).
+        """
+        for condition, create, _ in self._creators:
+            if condition(arg):
+                return create(arg, shape, copy=copy)
+        raise TypeError(f"arg `{repr(arg)}` cannot be converted to "
+                        "qutip data format")
+
+
+to = _to()
+create = _create()
diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
index a05e9b9c45..65dcd3193c 100644
--- a/qutip/core/data/csr.pxd
+++ b/qutip/core/data/csr.pxd
@@ -1,166 +1,166 @@
-#cython: language_level=3
-
-from cpython cimport mem
-from libcpp.algorithm cimport sort
-from libc.math cimport fabs
-
-cdef extern from *:
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-import numpy as np
-cimport numpy as cnp
-
-from qutip.core.data cimport base
-from qutip.core.data.dense cimport Dense
-
-cdef class CSR(base.Data):
-    cdef double complex *data
-    cdef base.idxint *col_index
-    cdef base.idxint *row_index
-    cdef size_t size
-    cdef object _scipy
-    cdef bint _deallocate
-    cpdef CSR copy(CSR self)
-    cpdef object as_scipy(CSR self, bint full=*)
-    cpdef CSR sort_indices(CSR self)
-    cpdef double complex trace(CSR self)
-    cpdef CSR adjoint(CSR self)
-    cpdef CSR conj(CSR self)
-    cpdef CSR transpose(CSR self)
-
-
-cdef struct Accumulator:
-    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
-    # matrices row-by-row (or column-by-column for CSC) where entries may need
-    # to be accumulated (summed) from several locations which may not be
-    # sorted.
-    #
-    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
-    # to the accumulator for this row by calling `scatter`, then fill the row
-    # in the output by calling `gather`.  Prepare the accumulator to receive
-    # the next row by calling `reset`.
-    double complex *values
-    size_t *modified
-    base.idxint *nonzero
-    size_t _cur_row, nnz, size
-    bint _sorted
-
-cdef inline Accumulator acc_alloc(size_t size):
-    """
-    Initialise this accumulator.  `size` should be the number of columns in the
-    matrix (for CSR) or the number of rows (for CSC).
-    """
-    cdef Accumulator acc
-    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
-    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
-    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
-    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
-        raise MemoryError
-    acc.size = size
-    acc.nnz = 0
-    # The value of _cur_row doesn't actually need to match the true row in
-    # the output, it just needs to be a unique number so that we can use it
-    # as a sentinel in `modified` to tell if there's a value in the current
-    # column.
-    acc._cur_row = 1
-    acc._sorted = True
-    return acc
-
-cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
-    """
-    Add a value to the accumulator for this row, in column `position`.  The
-    value is added on to any value already scattered into this position.
-    """
-    # We have to branch on modified[position] anyway (to know whether to add an
-    # entry in nonzero), so we _actually_ reset `values` here.  This has the
-    # potential to save operations too, if the same column is never touched
-    # again.
-    if acc.modified[position] == acc._cur_row:
-        acc.values[position] += value
-    else:
-        acc.values[position] = value
-        acc.modified[position] = acc._cur_row
-        acc.nonzero[acc.nnz] = position
-        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
-        acc.nnz += 1
-
-cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
-    """
-    Copy all the accumulated values into this row into the output pointers.
-    This will always output its values in sorted order.  The pointers should
-    point to the first free space for data to be copied into.  This method will
-    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
-    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
-    updated after each `self.scatter()` operation, and is reset by
-    `self.reset()`.
-
-    Return the actual number of elements copied in.
-    """
-    cdef size_t i, nnz=0, position
-    cdef double complex value
-    if not acc._sorted:
-        sort(acc.nonzero, acc.nonzero + acc.nnz)
-        acc._sorted = True
-    for i in range(acc.nnz):
-        position = acc.nonzero[i]
-        value = acc.values[position]
-        if fabs(value.real) < tol:
-            value.real = 0
-        if fabs(value.imag) < tol:
-            value.imag = 0
-        if value != 0:
-            values[nnz] = value
-            indices[nnz] = position
-            nnz += 1
-    return nnz
-
-cdef inline void acc_reset(Accumulator *acc) nogil:
-    """Prepare the accumulator to accept the next row of input."""
-    # We actually don't need to do anything to reset other than to change
-    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
-    # whether a value was set in this current row (and if not, `scatter`
-    # resets it when it's used), while `nnz`
-    acc.nnz = 0
-    acc._sorted = True
-    acc._cur_row += 1
-
-cdef inline void acc_free(Accumulator *acc):
-    mem.PyMem_Free(acc.values)
-    mem.PyMem_Free(acc.modified)
-    mem.PyMem_Free(acc.nonzero)
-
-
-# Internal structure for sorting pairs of elements.  Not actually meant to be
-# used in external code.
-cdef struct _data_col:
-    double complex data
-    base.idxint col
-
-cdef class Sorter:
-    cdef size_t size
-    cdef base.idxint **argsort
-    cdef _data_col *sort
-
-    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
-    cdef void copy(Sorter self,
-                   double complex *dest_data, base.idxint *dest_cols,
-                   double complex *src_data, base.idxint *src_cols,
-                   size_t size) nogil
-
-
-cpdef CSR fast_from_scipy(object sci)
-cpdef CSR copy_structure(CSR matrix)
-cpdef CSR sorted(CSR matrix)
-cpdef base.idxint nnz(CSR matrix) nogil
-cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
-cpdef CSR empty_like(CSR other)
-cpdef CSR zeros(base.idxint rows, base.idxint cols)
-cpdef CSR identity(base.idxint dimension, double complex scale=*)
-
-cpdef CSR from_dense(Dense matrix)
-cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
-                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
-                           double tol=*)
-
-cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
-                          base.idxint n_blocks, base.idxint block_size)
+#cython: language_level=3
+
+from cpython cimport mem
+from libcpp.algorithm cimport sort
+from libc.math cimport fabs
+
+cdef extern from *:
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+import numpy as np
+cimport numpy as cnp
+
+from qutip.core.data cimport base
+from qutip.core.data.dense cimport Dense
+
+cdef class CSR(base.Data):
+    cdef double complex *data
+    cdef base.idxint *col_index
+    cdef base.idxint *row_index
+    cdef size_t size
+    cdef object _scipy
+    cdef bint _deallocate
+    cpdef CSR copy(CSR self)
+    cpdef object as_scipy(CSR self, bint full=*)
+    cpdef CSR sort_indices(CSR self)
+    cpdef double complex trace(CSR self)
+    cpdef CSR adjoint(CSR self)
+    cpdef CSR conj(CSR self)
+    cpdef CSR transpose(CSR self)
+
+
+cdef struct Accumulator:
+    # Provides the scatter/gather accumulator pattern for populating CSR/CSC
+    # matrices row-by-row (or column-by-column for CSC) where entries may need
+    # to be accumulated (summed) from several locations which may not be
+    # sorted.
+    #
+    # See usage in `csr.from_coo_pointers` and `add_csr`; generally, add values
+    # to the accumulator for this row by calling `scatter`, then fill the row
+    # in the output by calling `gather`.  Prepare the accumulator to receive
+    # the next row by calling `reset`.
+    double complex *values
+    size_t *modified
+    base.idxint *nonzero
+    size_t _cur_row, nnz, size
+    bint _sorted
+
+cdef inline Accumulator acc_alloc(size_t size):
+    """
+    Initialise this accumulator.  `size` should be the number of columns in the
+    matrix (for CSR) or the number of rows (for CSC).
+    """
+    cdef Accumulator acc
+    acc.values = <double complex *> mem.PyMem_Malloc(size * sizeof(double complex))
+    acc.modified = <size_t *> PyMem_Calloc(size, sizeof(size_t))
+    acc.nonzero = <base.idxint *> mem.PyMem_Malloc(size * sizeof(base.idxint))
+    if acc.values == NULL or acc.modified == NULL or acc.nonzero == NULL:
+        raise MemoryError
+    acc.size = size
+    acc.nnz = 0
+    # The value of _cur_row doesn't actually need to match the true row in
+    # the output, it just needs to be a unique number so that we can use it
+    # as a sentinel in `modified` to tell if there's a value in the current
+    # column.
+    acc._cur_row = 1
+    acc._sorted = True
+    return acc
+
+cdef inline void acc_scatter(Accumulator *acc, double complex value, base.idxint position) nogil:
+    """
+    Add a value to the accumulator for this row, in column `position`.  The
+    value is added on to any value already scattered into this position.
+    """
+    # We have to branch on modified[position] anyway (to know whether to add an
+    # entry in nonzero), so we _actually_ reset `values` here.  This has the
+    # potential to save operations too, if the same column is never touched
+    # again.
+    if acc.modified[position] == acc._cur_row:
+        acc.values[position] += value
+    else:
+        acc.values[position] = value
+        acc.modified[position] = acc._cur_row
+        acc.nonzero[acc.nnz] = position
+        acc._sorted &= acc.nnz == 0 or acc.nonzero[acc.nnz - 1] < position
+        acc.nnz += 1
+
+cdef inline base.idxint acc_gather(Accumulator *acc, double complex *values, base.idxint *indices, double tol=0) nogil:
+    """
+    Copy all the accumulated values into this row into the output pointers.
+    This will always output its values in sorted order.  The pointers should
+    point to the first free space for data to be copied into.  This method will
+    copy in _at most_ `self.nnz` elements into the pointers, but may copy in
+    slightly fewer if some of them are now (explicit) zeros.  `self.nnz` is
+    updated after each `self.scatter()` operation, and is reset by
+    `self.reset()`.
+
+    Return the actual number of elements copied in.
+    """
+    cdef size_t i, nnz=0, position
+    cdef double complex value
+    if not acc._sorted:
+        sort(acc.nonzero, acc.nonzero + acc.nnz)
+        acc._sorted = True
+    for i in range(acc.nnz):
+        position = acc.nonzero[i]
+        value = acc.values[position]
+        if fabs(value.real) < tol:
+            value.real = 0
+        if fabs(value.imag) < tol:
+            value.imag = 0
+        if value != 0:
+            values[nnz] = value
+            indices[nnz] = position
+            nnz += 1
+    return nnz
+
+cdef inline void acc_reset(Accumulator *acc) nogil:
+    """Prepare the accumulator to accept the next row of input."""
+    # We actually don't need to do anything to reset other than to change
+    # our sentinel values; the sentinel `_cur_row` makes it easy to detect
+    # whether a value was set in this current row (and if not, `scatter`
+    # resets it when it's used), while `nnz`
+    acc.nnz = 0
+    acc._sorted = True
+    acc._cur_row += 1
+
+cdef inline void acc_free(Accumulator *acc):
+    mem.PyMem_Free(acc.values)
+    mem.PyMem_Free(acc.modified)
+    mem.PyMem_Free(acc.nonzero)
+
+
+# Internal structure for sorting pairs of elements.  Not actually meant to be
+# used in external code.
+cdef struct _data_col:
+    double complex data
+    base.idxint col
+
+cdef class Sorter:
+    cdef size_t size
+    cdef base.idxint **argsort
+    cdef _data_col *sort
+
+    cdef void inplace(Sorter self, CSR matrix, base.idxint ptr, size_t size) nogil
+    cdef void copy(Sorter self,
+                   double complex *dest_data, base.idxint *dest_cols,
+                   double complex *src_data, base.idxint *src_cols,
+                   size_t size) nogil
+
+
+cpdef CSR fast_from_scipy(object sci)
+cpdef CSR copy_structure(CSR matrix)
+cpdef CSR sorted(CSR matrix)
+cpdef base.idxint nnz(CSR matrix) nogil
+cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size)
+cpdef CSR empty_like(CSR other)
+cpdef CSR zeros(base.idxint rows, base.idxint cols)
+cpdef CSR identity(base.idxint dimension, double complex scale=*)
+
+cpdef CSR from_dense(Dense matrix)
+cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
+                           base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
+                           double tol=*)
+
+cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+                          base.idxint n_blocks, base.idxint block_size)
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index fb9fa24494..6cf30b06e6 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -1,965 +1,965 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-
-from libcpp cimport bool
-from libcpp.algorithm cimport sort
-
-cimport cython
-
-from cpython cimport mem
-
-import numbers
-import warnings
-
-import numpy as np
-cimport numpy as cnp
-import scipy.sparse
-from scipy.sparse import csr_matrix as scipy_csr_matrix
-try:
-    from scipy.sparse.data import _data_matrix as scipy_data_matrix
-except ImportError:
-    # The file data was renamed to _data from scipy 1.8.0
-    from scipy.sparse._data import _data_matrix as scipy_data_matrix
-from scipy.linalg cimport cython_blas as blas
-
-from qutip.core.data cimport base, Dense
-from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
-from qutip.core.data.trace cimport trace_csr
-from qutip.core.data.tidyup cimport tidyup_csr
-from .base import idxint_dtype
-from qutip.settings import settings
-
-cnp.import_array()
-
-cdef extern from *:
-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-    void *PyDataMem_NEW(size_t size)
-    void PyDataMem_FREE(void *ptr)
-
-# Very little should be exported on star-import, because most stuff will have
-# naming collisions with other type modules.
-__all__ = ['CSR']
-
-cdef int _ONE = 1
-
-cdef object _csr_matrix(data, indices, indptr, shape):
-    """
-    Factory method of scipy csr_matrix: we skip all the index type-checking
-    because this takes tens of microseconds, and we already know we're in
-    a sensible format.
-    """
-    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
-    # `_data_matrix` is the first object in the inheritance chain which
-    # doesn't have a really slow __init__.
-    scipy_data_matrix.__init__(out)
-    out.data = data
-    out.indices = indices
-    out.indptr = indptr
-    out._shape = shape
-    return out
-
-
-cdef class CSR(base.Data):
-    """
-    Data type for quantum objects storing its data in compressed sparse row
-    (CSR) format.  This is similar to the `scipy` type
-    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
-    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
-    using the `as_scipy()` method.
-    """
-    def __cinit__(self, *args, **kwargs):
-        # By default, we want CSR to deallocate its memory (we depend on Cython
-        # to ensure we don't deallocate a NULL pointer), and we only flip this
-        # when we create a scipy backing.  Since creating the scipy backing
-        # depends on knowing the shape, which happens _after_ data
-        # initialisation and may throw an exception, it is better to have a
-        # single flag that is set as soon as the pointers are assigned.
-        self._deallocate = True
-
-    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
-        # This is the Python __init__ method, so we do not care that it is not
-        # super-fast C access.  Typically Cython code will not call this, but
-        # will use a factory method in this module or at worst, call
-        # CSR.__new__ and manually set everything.  We must be very careful in
-        # this function that the deallocation is set up correctly if any
-        # exceptions occur.
-        cdef size_t ptr
-        cdef base.idxint col
-        cdef object data, col_index, row_index
-        if isinstance(arg, scipy.sparse.spmatrix):
-            arg = arg.tocsr()
-            if shape is not None and shape != arg.shape:
-                raise ValueError("".join([
-                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
-                ]))
-            shape = arg.shape
-            arg = (arg.data, arg.indices, arg.indptr)
-        if not isinstance(arg, tuple):
-            raise TypeError("arg must be a scipy matrix or tuple")
-        if len(arg) != 3:
-            raise ValueError("arg must be a (data, col_index, row_index) tuple")
-        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
-        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
-        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
-        # This flag must be set at the same time as data, col_index and
-        # row_index are assigned.  These assignments cannot raise an exception
-        # in user code due to the above three lines, but further code may.
-        self._deallocate = False
-        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
-        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
-        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
-        self.size = (cnp.PyArray_SIZE(data)
-                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
-                     else cnp.PyArray_SIZE(col_index))
-        if shape is None:
-            warnings.warn("instantiating CSR matrix of unknown shape")
-            # row_index contains an extra element which is nnz.  We assume the
-            # smallest matrix which can hold all these values by iterating
-            # through the columns.  This is slow and probably inaccurate, since
-            # there could be columns containing zero (hence the warning).
-            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
-            col = 1
-            for ptr in range(self.size):
-                col = self.col_index[ptr] if self.col_index[ptr] > col else col
-            self.shape[1] = col
-        else:
-            if not isinstance(shape, tuple):
-                raise TypeError("shape must be a 2-tuple of positive ints")
-            if not (len(shape) == 2
-                    and isinstance(shape[0], int)
-                    and isinstance(shape[1], int)
-                    and shape[0] > 0
-                    and shape[1] > 0):
-                raise ValueError("shape must be a 2-tuple of positive ints")
-            self.shape = shape
-        # Store a reference to the backing scipy matrix so it doesn't get
-        # deallocated before us.
-        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
-        if tidyup:
-            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
-
-    def __reduce__(self):
-        return (fast_from_scipy, (self.as_scipy(),))
-
-    cpdef CSR copy(self):
-        """
-        Return a complete (deep) copy of this object.
-
-        If the type currently has a scipy backing, such as that produced by
-        `as_scipy`, this will not be copied.  The backing is a view onto our
-        data, and a straight copy of this view would be incorrect.  We do not
-        create a new view at copy time, since the user may only access this
-        through a creation method, and creating it ahead of time would incur an
-        unnecessary speed penalty for users who do not need it (including
-        low-level C code).
-        """
-        cdef base.idxint nnz_ = nnz(self)
-        cdef CSR out = empty_like(self)
-        memcpy(out.data, self.data, nnz_*sizeof(double complex))
-        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
-        memcpy(out.row_index, self.row_index,
-               (self.shape[0] + 1)*sizeof(base.idxint))
-        return out
-
-    cpdef object to_array(self):
-        """
-        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
-        is not a view onto the data, and changes to new array will not affect
-        the original data structure.
-        """
-        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
-        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
-        cdef double complex [:, ::1] buffer = out
-        cdef size_t row, ptr
-        for row in range(self.shape[0]):
-            for ptr in range(self.row_index[row], self.row_index[row + 1]):
-                buffer[row, self.col_index[ptr]] = self.data[ptr]
-        return out
-
-    cpdef object as_scipy(self, bint full=False):
-        """
-        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
-        underlying data structures are exposed, such that modifications to the
-        `data`, `indices` and `indptr` buffers in the resulting object will
-        modify this object too.
-
-        If `full` is False (the default), the output array is squeezed so that
-        the SciPy array sees only the filled elements.  If `full` is True,
-        SciPy will see the full underlying buffers, which may include
-        uninitialised elements.  Setting `full=True` is intended for
-        Python-space factory methods.  In all other use cases, `full=False` is
-        much less error prone.
-        """
-        # We store a reference to the scipy matrix not only for caching this
-        # relatively expensive method, but also because we transferred
-        # ownership of our data to the numpy arrays, and we can't allow them to
-        # be collected while we're alive.
-        if self._scipy is not None:
-            return self._scipy
-        cdef cnp.npy_intp length = self.size if full else nnz(self)
-        data = cnp.PyArray_SimpleNewFromData(1, [length],
-                                             cnp.NPY_COMPLEX128,
-                                             self.data)
-        indices = cnp.PyArray_SimpleNewFromData(1, [length],
-                                                base.idxint_DTYPE,
-                                                self.col_index)
-        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
-                                               base.idxint_DTYPE,
-                                               self.row_index)
-        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
-        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
-        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
-        self._deallocate = False
-        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
-        return self._scipy
-
-    cpdef CSR sort_indices(self):
-        cdef Sorter sort
-        cdef base.idxint ptr
-        cdef size_t row, diff, size=0
-        for row in range(self.shape[0]):
-            diff = self.row_index[row + 1] - self.row_index[row]
-            size = diff if diff > size else size
-        sort = Sorter(size)
-        for row in range(self.shape[0]):
-            ptr = self.row_index[row]
-            diff = self.row_index[row + 1] - ptr
-            sort.inplace(self, ptr, diff)
-        return self
-
-    cpdef double complex trace(self):
-        return trace_csr(self)
-
-    cpdef CSR adjoint(self):
-        return adjoint_csr(self)
-
-    cpdef CSR conj(self):
-        return conj_csr(self)
-
-    cpdef CSR transpose(self):
-        return transpose_csr(self)
-
-    def __repr__(self):
-        return "".join([
-            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
-        ])
-
-    def __str__(self):
-        return self.__repr__()
-
-    def __dealloc__(self):
-        # If we have a reference to a scipy type, then we've passed ownership
-        # of the data to numpy, so we let it handle refcounting and we don't
-        # need to deallocate anything ourselves.
-        if not self._deallocate:
-            return
-        if self.data != NULL:
-            PyDataMem_FREE(self.data)
-        if self.col_index != NULL:
-            PyDataMem_FREE(self.col_index)
-        if self.row_index != NULL:
-            PyDataMem_FREE(self.row_index)
-
-
-cpdef CSR fast_from_scipy(object sci):
-    """
-    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
-    checking on any of the inputs, and should consequently be considered very
-    unsafe.  This is primarily for use in the unpickling operation.
-    """
-    cdef CSR out = CSR.__new__(CSR)
-    out.shape = sci.shape
-    out._deallocate = False
-    out._scipy = sci
-    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
-    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
-    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
-    out.size = cnp.PyArray_SIZE(sci.data)
-    return out
-
-
-cpdef CSR copy_structure(CSR matrix):
-    """
-    Return a copy of the input matrix with identical `col_index` and
-    `row_index` matrices, and an allocated, but empty, `data`.  The returned
-    pointers are all separately allocated, but contain the same information.
-
-    This is intended for unary functions on CSR types that maintain the exact
-    structure, but modify each non-zero data element without change their
-    location.
-    """
-    cdef CSR out = empty_like(matrix)
-    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
-    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
-    return out
-
-
-cpdef inline base.idxint nnz(CSR matrix) nogil:
-    """Get the number of non-zero elements of a CSR matrix."""
-    return matrix.row_index[matrix.shape[0]]
-
-
-cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
-    return i[0] < j[0]
-
-cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
-    return x.col < y.col
-
-ctypedef fused _swap_data:
-    double complex
-    base.idxint
-
-cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
-    a[0], b[0] = b[0], a[0]
-
-cdef class Sorter:
-    # Look on my works, ye mighty, and despair!
-    #
-    # This class has hard-coded sorts for up to three elements, for both
-    # copying and in-place varieties.  Everything above that we delegate to a
-    # proper sorting algorithm.
-    def __init__(self, size_t size):
-        self.size = size
-
-    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
-        cdef size_t n
-        cdef base.idxint col0, col1, col2
-        # Fast paths for tridiagonal matrices.  These fast paths minimise the
-        # number of comparisons and swaps made.
-        if size < 2:
-            return
-        if size == 2:
-            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-            return
-        if size == 3:
-            # Faster to store rather than re-dereference, and if someone
-            # changes the data underneath us, we've got larger problems anyway.
-            col0 = matrix.col_index[ptr]
-            col1 = matrix.col_index[ptr + 1]
-            col2 = matrix.col_index[ptr + 2]
-            if col0 < col1:
-                if col1 > col2:
-                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
-                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
-                    if col0 > col2:
-                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-            elif col1 < col2:
-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
-                if col0 > col2:
-                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
-                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
-            else:
-                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
-                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
-            return
-        # Now we actually have to do the sort properly.  It's easiest just to
-        # copy the data into a temporary structure.
-        if size > self.size or self.sort == NULL:
-            # realloc(NULL, size) is equivalent to malloc(size), so there's no
-            # problem if cols and argsort weren't allocated before.
-            self.size = size if size > self.size else self.size
-            with gil:
-                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
-                                                            self.size * sizeof(_data_col))
-        for n in range(size):
-            self.sort[n].data = matrix.data[ptr + n]
-            self.sort[n].col = matrix.col_index[ptr + n]
-        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
-        for n in range(size):
-            matrix.data[ptr + n] = self.sort[n].data
-            matrix.col_index[ptr + n] = self.sort[n].col
-
-    cdef void copy(self,
-                   double complex *dest_data, base.idxint *dest_cols,
-                   double complex *src_data, base.idxint *src_cols,
-                   size_t size) nogil:
-        cdef size_t n, ptr
-        # Fast paths for small sizes.  Not pretty, but it speeds things up a
-        # lot for up to triadiaongal systems (which are pretty common).
-        if size == 0:
-            return
-        if size == 1:
-            dest_cols[0] = src_cols[0]
-            dest_data[0] = src_data[0]
-            return
-        if size == 2:
-            if src_cols[0] < src_cols[1]:
-                dest_cols[0] = src_cols[0]
-                dest_data[0] = src_data[0]
-                dest_cols[1] = src_cols[1]
-                dest_data[1] = src_data[1]
-            else:
-                dest_cols[1] = src_cols[0]
-                dest_data[1] = src_data[0]
-                dest_cols[0] = src_cols[1]
-                dest_data[0] = src_data[1]
-            return
-        if size == 3:
-            if src_cols[0] < src_cols[1]:
-                if src_cols[0] < src_cols[2]:
-                    dest_cols[0] = src_cols[0]
-                    dest_data[0] = src_data[0]
-                    if src_cols[1] < src_cols[2]:
-                        dest_cols[1] = src_cols[1]
-                        dest_data[1] = src_data[1]
-                        dest_cols[2] = src_cols[2]
-                        dest_data[2] = src_data[2]
-                    else:
-                        dest_cols[2] = src_cols[1]
-                        dest_data[2] = src_data[1]
-                        dest_cols[1] = src_cols[2]
-                        dest_data[1] = src_data[2]
-                else:
-                    dest_cols[1] = src_cols[0]
-                    dest_data[1] = src_data[0]
-                    dest_cols[2] = src_cols[1]
-                    dest_data[2] = src_data[1]
-                    dest_cols[0] = src_cols[2]
-                    dest_data[0] = src_data[2]
-            elif src_cols[0] < src_cols[2]:
-                dest_cols[1] = src_cols[0]
-                dest_data[1] = src_data[0]
-                dest_cols[0] = src_cols[1]
-                dest_data[0] = src_data[1]
-                dest_cols[2] = src_cols[2]
-                dest_data[2] = src_data[2]
-            else:
-                dest_cols[2] = src_cols[0]
-                dest_data[2] = src_data[0]
-                if src_cols[1] < src_cols[2]:
-                    dest_cols[0] = src_cols[1]
-                    dest_data[0] = src_data[1]
-                    dest_cols[1] = src_cols[2]
-                    dest_data[1] = src_data[2]
-                else:
-                    dest_cols[1] = src_cols[1]
-                    dest_data[1] = src_data[1]
-                    dest_cols[0] = src_cols[2]
-                    dest_data[0] = src_data[2]
-            return
-        # Now we're left with the full case, and we have to sort properly.
-        if size > self.size or self.argsort == NULL:
-            # realloc(NULL, size) is equivalent to malloc(size), so there's no
-            # problem if cols and argsort weren't allocated before.
-            self.size = size if size > self.size else self.size
-            with gil:
-                self.argsort = (
-                    <base.idxint **>
-                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
-                )
-        # We do the argsort with two levels of indirection to minimise memory
-        # allocation and copying requirements when this function is being used
-        # to assemble a CSR matrix under an operation which may change the
-        # order of the columns (e.g. permute).  First the user makes the
-        # columns accessible in some contiguous memory (or if they're not
-        # changing them, they can just use the CSR buffers).  We put pointers
-        # to each of those columns in the array which actually gets sorted
-        # using a comparison function which dereferences the pointers and
-        # compares the result.  After the sort, `argsort` will be the pointers
-        # sorted according to the new column, and we know that the "lowest"
-        # pointer in there has the value `src_cols`, so we can do pointer
-        # arithmetic to know which element we should take.
-        #
-        # This is about 30-40% faster than allocating space for structs of
-        # (double complex, idxint), copying in the data and column, sorting and
-        # copying into the new arrays.  Allocating the structs actually
-        # allocates more space than the pointer method (double complex is
-        # very likely to be 2x the size of a pointer, _and_ the struct may need
-        # extra padding to be aligned), so it's probably actually worse for
-        # cache locality.  Despite the sort relying on pointer dereference in
-        # this case, it's actually got very good cache locality.
-        for n in range(size):
-            self.argsort[n] = src_cols + n
-        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
-        for n in range(size):
-            ptr = self.argsort[n] - src_cols
-            dest_cols[n] = src_cols[ptr]
-            dest_data[n] = src_data[ptr]
-
-    def __dealloc__(self):
-        if self.argsort != NULL:
-            mem.PyMem_Free(self.argsort)
-        if self.sort != NULL:
-            mem.PyMem_Free(self.sort)
-
-cpdef CSR sorted(CSR matrix):
-    cdef CSR out = empty_like(matrix)
-    cdef Sorter sort
-    cdef base.idxint ptr
-    cdef size_t row, diff, size=0
-    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
-    for row in range(matrix.shape[0]):
-        diff = matrix.row_index[row + 1] - matrix.row_index[row]
-        size = diff if diff > size else size
-    sort = Sorter(size)
-    for row in range(matrix.shape[0]):
-        ptr = matrix.row_index[row]
-        diff = matrix.row_index[row + 1] - ptr
-        sort.copy(out.data + ptr, out.col_index + ptr,
-                  matrix.data + ptr, matrix.col_index + ptr,
-                  diff)
-    return out
-
-
-cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
-    """
-    Allocate an empty CSR matrix of the given shape, with space for `size`
-    elements in the `data` and `col_index` arrays.
-
-    This does not initialise any of the memory returned, but sets the last
-    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
-    """
-    if size < 0:
-        raise ValueError("size must be a positive integer.")
-    # Python doesn't like allocating nothing.
-    if size == 0:
-        size += 1
-    cdef CSR out = CSR.__new__(CSR)
-    cdef base.idxint row_size = rows + 1
-    out.shape = (rows, cols)
-    out.size = size
-    out.data =\
-        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
-    out.col_index =\
-        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
-    out.row_index =\
-        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
-    # Set the number of non-zero elements to 0.
-    out.row_index[rows] = 0
-    return out
-
-
-cpdef CSR empty_like(CSR other):
-    return empty(other.shape[0], other.shape[1], nnz(other))
-
-
-cpdef CSR zeros(base.idxint rows, base.idxint cols):
-    """
-    Allocate the zero matrix with a given shape.  There will not be any room in
-    the `data` and `col_index` buffers to add new elements.
-    """
-    # We always allocate matrices with at least one element to ensure that we
-    # actually _are_ asking for memory (Python doesn't like allocating nothing)
-    cdef CSR out = empty(rows, cols, 1)
-    out.data[0] = out.col_index[0] = 0
-    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
-    return out
-
-
-cpdef CSR identity(base.idxint dimension, double complex scale=1):
-    """
-    Return a square matrix of the specified dimension, with a constant along
-    the diagonal.  By default this will be the identity matrix, but if `scale`
-    is passed, then the result will be `scale` times the identity.
-    """
-    cdef CSR out = empty(dimension, dimension, dimension)
-    cdef base.idxint i
-    for i in range(dimension):
-        out.data[i] = scale
-        out.col_index[i] = i
-        out.row_index[i] = i
-    out.row_index[dimension] = dimension
-    return out
-
-cpdef CSR from_dense(Dense matrix):
-    # Assume worst-case scenario for non-zero.
-    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
-                         matrix.shape[0]*matrix.shape[1])
-    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
-    row_stride = 1 if matrix.fortran else matrix.shape[1]
-    col_stride = matrix.shape[0] if matrix.fortran else 1
-    out.row_index[0] = 0
-    for row in range(matrix.shape[0]):
-        ptr_in = row_stride * row
-        for col in range(matrix.shape[1]):
-            if matrix.data[ptr_in] != 0:
-                out.data[ptr_out] = matrix.data[ptr_in]
-                out.col_index[ptr_out] = col
-                ptr_out += 1
-            ptr_in += col_stride
-        out.row_index[row + 1] = ptr_out
-    return out
-
-cdef CSR from_coo_pointers(
-    base.idxint *rows, base.idxint *cols, double complex *data,
-    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
-):
-    # Note that COO pointers may not be sorted in row-major order, and that
-    # they may contain duplicate entries which should be implicitly summed.
-    cdef Accumulator acc = acc_alloc(n_cols)
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    cdef double complex *data_tmp
-    cdef base.idxint *cols_tmp
-    cdef base.idxint row
-    cdef size_t ptr_in, ptr_out, ptr_prev
-    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
-    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
-    if data_tmp == NULL or cols_tmp == NULL:
-        raise MemoryError
-    with nogil:
-        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
-        for ptr_in in range(nnz):
-            out.row_index[rows[ptr_in] + 1] += 1
-        for ptr_out in range(n_rows):
-            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
-        # out.row_index is currently in the normal output form, but we're
-        # temporarily going to modify it to keep track of how many values we've
-        # placed in each row as we iterate through.  At every state,
-        # out.row_index[row] will contain a pointer to the next location that
-        # an element should be placed in this row.
-        for ptr_in in range(nnz):
-            row = rows[ptr_in]
-            ptr_out = out.row_index[row]
-            cols_tmp[ptr_out] = cols[ptr_in]
-            data_tmp[ptr_out] = data[ptr_in]
-            out.row_index[row] += 1
-        # Apply the scatter/gather pattern to find the actual number of
-        # non-zero elements we're writing into each row (since there's a sum,
-        # there may be some zeros of duplicates).  Remember we also need to
-        # shift the row_index array back to what it was before as well.
-        ptr_out = 0
-        ptr_prev = 0
-        for row in range(n_rows):
-            for ptr_in in range(ptr_prev, out.row_index[row]):
-                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
-            ptr_prev = out.row_index[row]
-            out.row_index[row] = ptr_out
-            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
-            acc_reset(&acc)
-        out.row_index[n_rows] = ptr_out
-    mem.PyMem_Free(data_tmp)
-    mem.PyMem_Free(cols_tmp)
-    acc_free(&acc)
-    return out
-
-
-cdef inline base.idxint _diagonal_length(
-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-) nogil:
-    if offset > 0:
-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-    return n_cols if offset > n_cols - n_rows else n_rows + offset
-
-cdef CSR diag(
-    double complex[:] diagonal, base.idxint offset,
-    base.idxint n_rows, base.idxint n_cols,
-):
-    """
-    Construct a CSR matrix with a single non-zero diagonal.
-
-    Parameters
-    ----------
-    diagonal : indexable of double complex
-        The entries (including zeros) that should be placed on the diagonal in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal.
-
-    offsets : idxint
-        The index of the diagonals.  An offset of 0 is the main diagonal,
-        positive values are above the main diagonal and negative ones are below
-        the main diagonal.
-
-    n_rows, n_cols : idxint
-        The shape of the output.  The result does not need to be square, but
-        the diagonal must be of the correct length to fit in.
-    """
-    if n_rows < 0 or n_cols < 0:
-        raise ValueError("shape must be positive")
-    cdef base.idxint nnz = len(diagonal)
-    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
-    if nnz != n_diag:
-        raise ValueError("incorrect number of diagonal elements")
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    cdef base.idxint start_row = 0 if offset >= 0 else -offset
-    cdef base.idxint col = 0 if offset <= 0 else offset
-    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
-    nnz = 0
-    for row in range(start_row + 1, start_row + n_diag + 1):
-        out.col_index[nnz] = col
-        out.data[nnz] = diagonal[nnz]
-        col += 1
-        nnz += 1
-        out.row_index[row] = nnz
-    for row in range(start_row + n_diag + 1, n_rows + 1):
-        out.row_index[row] = nnz
-    return out
-
-cdef CSR diags_(
-    list diagonals, base.idxint[:] offsets,
-    base.idxint n_rows, base.idxint n_cols,
-):
-    """
-    Construct a CSR matrix from a list of diagonals and their offsets.  The
-    offsets are assumed to be in sorted order.  This is the C-only interface to
-    csr.diags, and inputs are not sanity checked (use the Python interface for
-    that).
-
-    Parameters
-    ----------
-    diagonals : list of indexable of double complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal (not checked).
-
-    offsets : idxint[:]
-        The indices of the diagonals.  These should be sorted and without
-        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
-        An offset of 0 is the main diagonal, positive values are above the main
-        diagonal and negative ones are below the main diagonal.
-
-    n_rows, n_cols : idxint
-        The shape of the output.  The result does not need to be square, but
-        the diagonals must be of the correct length to fit in.
-    """
-    cdef size_t n_diagonals = len(diagonals)
-    if n_diagonals == 0:
-        return zeros(n_rows, n_cols)
-    cdef base.idxint k, row, start_row, offset, nnz=0,
-    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
-    cdef double complex value
-    for k in range(n_diagonals):
-        offset = offsets[k]
-        if offset >= 0 and min_k > k:
-            min_k = k
-        nnz += _diagonal_length(offset, n_rows, n_cols)
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    nnz = 0
-    out.row_index[0] = 0
-    for row in range(n_rows):
-        if min_k > 0:
-            offset = offsets[min_k - 1]
-            start_row = 0 if offset >= 0 else -offset
-            if start_row == row:
-                min_k -= 1
-        if max_k > 0:
-            offset = offsets[max_k - 1]
-            start_row = 0 if offset >= 0 else -offset
-            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
-                max_k -= 1
-        for k in range(min_k, max_k):
-            offset = offsets[k]
-            value = diagonals[k][row if offset >= 0 else row + offset]
-            if value == 0:
-                continue
-            out.data[nnz] = value
-            out.col_index[nnz] = row + offset
-            nnz += 1
-        out.row_index[row + 1] = nnz
-    return out
-
-@cython.wraparound(True)
-def diags(diagonals, offsets=None, shape=None):
-    """
-    Construct a CSR matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements.  Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    cdef base.idxint n_rows, n_cols, offset
-    try:
-        diagonals = list(diagonals)
-        if diagonals and np.isscalar(diagonals[0]):
-            # Catch the case where we're being called as (for example)
-            #   diags([1, 2, 3], 0)
-            # with a single diagonal and offset.
-            diagonals = [diagonals]
-    except TypeError:
-        raise TypeError("diagonals must be a list of arrays of complex") from None
-    if offsets is None:
-        if len(diagonals) == 0:
-            offsets = []
-        elif len(diagonals) == 1:
-            offsets = [0]
-        else:
-            raise TypeError("offsets must be supplied if passing more than one diagonal")
-    offsets = np.atleast_1d(offsets)
-    if offsets.ndim > 1:
-        raise ValueError("offsets must be a 1D array of integers")
-    if len(diagonals) != len(offsets):
-        raise ValueError("number of diagonals does not match number of offsets")
-    if len(diagonals) == 0:
-        if shape is None:
-            raise ValueError("cannot construct matrix with no diagonals without a shape")
-        else:
-            n_rows, n_cols = shape
-        return zeros(n_rows, n_cols)
-    order = np.argsort(offsets)
-    diagonals_ = []
-    offsets_ = []
-    prev, cur = None, None
-    for i in order:
-        cur = offsets[i]
-        if cur == prev:
-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-        else:
-            offsets_.append(cur)
-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-        prev = cur
-    if shape is None:
-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-    else:
-        try:
-            n_rows, n_cols = shape
-        except (TypeError, ValueError):
-            raise TypeError("shape must be a 2-tuple of positive integers")
-        if n_rows < 0 or n_cols < 0:
-            raise ValueError("shape must be a 2-tuple of positive integers")
-    for i in range(len(diagonals_)):
-        offset = offsets_[i]
-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-            raise ValueError("given diagonals do not have the correct lengths")
-    if n_rows == 0 and n_cols == 0:
-        raise ValueError("can't produce a 0x0 matrix")
-    if len(offsets) == 1:
-        # Fast path for a single diagonal.
-        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
-    return diags_(
-        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
-    )
-
-
-cpdef CSR _from_csr_blocks(
-    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
-    base.idxint n_blocks, base.idxint block_size
-):
-    """
-    Construct a CSR from non-overlapping blocks.
-
-    Each operator in ``block_ops`` should be a square CSR operator with
-    shape ``(block_size, block_size)``. The output operator consists of
-    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
-    ``(n_blocks * block_size, n_blocks * block_size)``.
-
-    None of the operators should overlap (i.e. the list of block row and
-    column pairs should be unique).
-
-    Parameters
-    ----------
-    block_rows : sequence of base.idxint integers
-        The block row for each operator. The block row should be in
-        ``range(0, n_blocks)``.
-
-    block_cols : sequence of base.idxint integers
-        The block column for each operator. The block column should be in
-        ``range(0, n_blocks)``.
-
-    block_ops : sequence of CSR matrixes
-        The operators corresponding to the rows and columns in ``block_rows``
-        and ``block_cols``.
-
-    n_blocks : base.idxint
-        Number of blocks. The shape of the final matrix is
-        (n_blocks * block, n_blocks * block).
-
-    block_size : base.idxint
-        Size of each block. The shape of matrices in ``block_ops`` is
-        ``(block_size, block_size)``.
-    """
-    cdef CSR op
-    cdef base.idxint shape = n_blocks * block_size
-    cdef base.idxint nnz_ = 0
-    cdef base.idxint n_ops = len(block_ops)
-    cdef base.idxint i, j
-    cdef base.idxint row_idx, col_idx
-
-    # check arrays are the same length
-    if len(block_rows) != n_ops or len(block_cols) != n_ops:
-        raise ValueError(
-            "The arrays block_rows, block_cols and block_ops should have"
-            " the same length."
-        )
-
-    if n_ops == 0:
-        return zeros(shape, shape)
-
-    # check op shapes and calculate nnz
-    for op in block_ops:
-        nnz_ += nnz(op)
-        if op.shape[0] != block_size or op.shape[1] != block_size:
-            raise ValueError(
-                "Block operators (block_ops) do not have the correct shape."
-            )
-
-    # check ops are ordered by (row, column)
-    row_idx = block_rows[0]
-    col_idx = block_cols[0]
-    for i in range(1, n_ops):
-        if (
-            block_rows[i] < row_idx or
-            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
-        ):
-            raise ValueError(
-                "The arrays block_rows and block_cols must be sorted"
-                " by (row, column)."
-            )
-        row_idx = block_rows[i]
-        col_idx = block_cols[i]
-
-    if nnz_ == 0:
-        return zeros(shape, shape)
-
-    cdef CSR out = empty(shape, shape, nnz_)
-    cdef base.idxint op_idx = 0
-    cdef base.idxint prev_op_idx = 0
-    cdef base.idxint end = 0
-    cdef base.idxint row_pos, col_pos
-    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
-
-    out.row_index[0] = 0
-
-    for row_idx in range(n_blocks):
-        prev_op_idx = op_idx
-        while op_idx < n_ops:
-            if block_rows[op_idx] != row_idx:
-                break
-            op_idx += 1
-
-        row_pos = row_idx * block_size
-        for op_row in range(block_size):
-            for i in range(prev_op_idx, op_idx):
-                op = block_ops[i]
-                if nnz(op) == 0:
-                    # empty CSR matrices have uninitialized row_index entries.
-                    # it's unclear whether users should ever see such matrixes
-                    # but we support them here anyway.
-                    continue
-                col_idx = block_cols[i]
-                col_pos = col_idx * block_size
-                op_row_start = op.row_index[op_row]
-                op_row_end = op.row_index[op_row + 1]
-                op_row_len = op_row_end - op_row_start
-                for j in range(op_row_len):
-                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
-                    out.data[end + j] = op.data[op_row_start + j]
-                end += op_row_len
-            out.row_index[row_pos + op_row + 1] = end
-
-    return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+
+from libcpp cimport bool
+from libcpp.algorithm cimport sort
+
+cimport cython
+
+from cpython cimport mem
+
+import numbers
+import warnings
+
+import numpy as np
+cimport numpy as cnp
+import scipy.sparse
+from scipy.sparse import csr_matrix as scipy_csr_matrix
+try:
+    from scipy.sparse.data import _data_matrix as scipy_data_matrix
+except ImportError:
+    # The file data was renamed to _data from scipy 1.8.0
+    from scipy.sparse._data import _data_matrix as scipy_data_matrix
+from scipy.linalg cimport cython_blas as blas
+
+from qutip.core.data cimport base, Dense
+from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
+from qutip.core.data.trace cimport trace_csr
+from qutip.core.data.tidyup cimport tidyup_csr
+from .base import idxint_dtype
+from qutip.settings import settings
+
+cnp.import_array()
+
+cdef extern from *:
+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+    void *PyDataMem_NEW(size_t size)
+    void PyDataMem_FREE(void *ptr)
+
+# Very little should be exported on star-import, because most stuff will have
+# naming collisions with other type modules.
+__all__ = ['CSR']
+
+cdef int _ONE = 1
+
+cdef object _csr_matrix(data, indices, indptr, shape):
+    """
+    Factory method of scipy csr_matrix: we skip all the index type-checking
+    because this takes tens of microseconds, and we already know we're in
+    a sensible format.
+    """
+    cdef object out = scipy_csr_matrix.__new__(scipy_csr_matrix)
+    # `_data_matrix` is the first object in the inheritance chain which
+    # doesn't have a really slow __init__.
+    scipy_data_matrix.__init__(out)
+    out.data = data
+    out.indices = indices
+    out.indptr = indptr
+    out._shape = shape
+    return out
+
+
+cdef class CSR(base.Data):
+    """
+    Data type for quantum objects storing its data in compressed sparse row
+    (CSR) format.  This is similar to the `scipy` type
+    `scipy.sparse.csr_matrix`, but significantly faster on many operations.
+    You can retrieve a `scipy.sparse.csr_matrix` which views onto the same data
+    using the `as_scipy()` method.
+    """
+    def __cinit__(self, *args, **kwargs):
+        # By default, we want CSR to deallocate its memory (we depend on Cython
+        # to ensure we don't deallocate a NULL pointer), and we only flip this
+        # when we create a scipy backing.  Since creating the scipy backing
+        # depends on knowing the shape, which happens _after_ data
+        # initialisation and may throw an exception, it is better to have a
+        # single flag that is set as soon as the pointers are assigned.
+        self._deallocate = True
+
+    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
+        # This is the Python __init__ method, so we do not care that it is not
+        # super-fast C access.  Typically Cython code will not call this, but
+        # will use a factory method in this module or at worst, call
+        # CSR.__new__ and manually set everything.  We must be very careful in
+        # this function that the deallocation is set up correctly if any
+        # exceptions occur.
+        cdef size_t ptr
+        cdef base.idxint col
+        cdef object data, col_index, row_index
+        if isinstance(arg, scipy.sparse.spmatrix):
+            arg = arg.tocsr()
+            if shape is not None and shape != arg.shape:
+                raise ValueError("".join([
+                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
+                ]))
+            shape = arg.shape
+            arg = (arg.data, arg.indices, arg.indptr)
+        if not isinstance(arg, tuple):
+            raise TypeError("arg must be a scipy matrix or tuple")
+        if len(arg) != 3:
+            raise ValueError("arg must be a (data, col_index, row_index) tuple")
+        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
+        col_index = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
+        row_index = np.array(arg[2], dtype=idxint_dtype, copy=copy, order='C')
+        # This flag must be set at the same time as data, col_index and
+        # row_index are assigned.  These assignments cannot raise an exception
+        # in user code due to the above three lines, but further code may.
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
+        self.col_index = <base.idxint *> cnp.PyArray_GETPTR1(col_index, 0)
+        self.row_index = <base.idxint *> cnp.PyArray_GETPTR1(row_index, 0)
+        self.size = (cnp.PyArray_SIZE(data)
+                     if cnp.PyArray_SIZE(data) < cnp.PyArray_SIZE(col_index)
+                     else cnp.PyArray_SIZE(col_index))
+        if shape is None:
+            warnings.warn("instantiating CSR matrix of unknown shape")
+            # row_index contains an extra element which is nnz.  We assume the
+            # smallest matrix which can hold all these values by iterating
+            # through the columns.  This is slow and probably inaccurate, since
+            # there could be columns containing zero (hence the warning).
+            self.shape[0] = cnp.PyArray_DIMS(row_index)[0] - 1
+            col = 1
+            for ptr in range(self.size):
+                col = self.col_index[ptr] if self.col_index[ptr] > col else col
+            self.shape[1] = col
+        else:
+            if not isinstance(shape, tuple):
+                raise TypeError("shape must be a 2-tuple of positive ints")
+            if not (len(shape) == 2
+                    and isinstance(shape[0], int)
+                    and isinstance(shape[1], int)
+                    and shape[0] > 0
+                    and shape[1] > 0):
+                raise ValueError("shape must be a 2-tuple of positive ints")
+            self.shape = shape
+        # Store a reference to the backing scipy matrix so it doesn't get
+        # deallocated before us.
+        self._scipy = _csr_matrix(data, col_index, row_index, self.shape)
+        if tidyup:
+            tidyup_csr(self, settings.core['auto_tidyup_atol'], True)
+
+    def __reduce__(self):
+        return (fast_from_scipy, (self.as_scipy(),))
+
+    cpdef CSR copy(self):
+        """
+        Return a complete (deep) copy of this object.
+
+        If the type currently has a scipy backing, such as that produced by
+        `as_scipy`, this will not be copied.  The backing is a view onto our
+        data, and a straight copy of this view would be incorrect.  We do not
+        create a new view at copy time, since the user may only access this
+        through a creation method, and creating it ahead of time would incur an
+        unnecessary speed penalty for users who do not need it (including
+        low-level C code).
+        """
+        cdef base.idxint nnz_ = nnz(self)
+        cdef CSR out = empty_like(self)
+        memcpy(out.data, self.data, nnz_*sizeof(double complex))
+        memcpy(out.col_index, self.col_index, nnz_*sizeof(base.idxint))
+        memcpy(out.row_index, self.row_index,
+               (self.shape[0] + 1)*sizeof(base.idxint))
+        return out
+
+    cpdef object to_array(self):
+        """
+        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
+        is not a view onto the data, and changes to new array will not affect
+        the original data structure.
+        """
+        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
+        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
+        cdef double complex [:, ::1] buffer = out
+        cdef size_t row, ptr
+        for row in range(self.shape[0]):
+            for ptr in range(self.row_index[row], self.row_index[row + 1]):
+                buffer[row, self.col_index[ptr]] = self.data[ptr]
+        return out
+
+    cpdef object as_scipy(self, bint full=False):
+        """
+        Get a view onto this object as a `scipy.sparse.csr_matrix`.  The
+        underlying data structures are exposed, such that modifications to the
+        `data`, `indices` and `indptr` buffers in the resulting object will
+        modify this object too.
+
+        If `full` is False (the default), the output array is squeezed so that
+        the SciPy array sees only the filled elements.  If `full` is True,
+        SciPy will see the full underlying buffers, which may include
+        uninitialised elements.  Setting `full=True` is intended for
+        Python-space factory methods.  In all other use cases, `full=False` is
+        much less error prone.
+        """
+        # We store a reference to the scipy matrix not only for caching this
+        # relatively expensive method, but also because we transferred
+        # ownership of our data to the numpy arrays, and we can't allow them to
+        # be collected while we're alive.
+        if self._scipy is not None:
+            return self._scipy
+        cdef cnp.npy_intp length = self.size if full else nnz(self)
+        data = cnp.PyArray_SimpleNewFromData(1, [length],
+                                             cnp.NPY_COMPLEX128,
+                                             self.data)
+        indices = cnp.PyArray_SimpleNewFromData(1, [length],
+                                                base.idxint_DTYPE,
+                                                self.col_index)
+        indptr = cnp.PyArray_SimpleNewFromData(1, [self.shape[0] + 1],
+                                               base.idxint_DTYPE,
+                                               self.row_index)
+        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
+        PyArray_ENABLEFLAGS(indices, cnp.NPY_ARRAY_OWNDATA)
+        PyArray_ENABLEFLAGS(indptr, cnp.NPY_ARRAY_OWNDATA)
+        self._deallocate = False
+        self._scipy = _csr_matrix(data, indices, indptr, self.shape)
+        return self._scipy
+
+    cpdef CSR sort_indices(self):
+        cdef Sorter sort
+        cdef base.idxint ptr
+        cdef size_t row, diff, size=0
+        for row in range(self.shape[0]):
+            diff = self.row_index[row + 1] - self.row_index[row]
+            size = diff if diff > size else size
+        sort = Sorter(size)
+        for row in range(self.shape[0]):
+            ptr = self.row_index[row]
+            diff = self.row_index[row + 1] - ptr
+            sort.inplace(self, ptr, diff)
+        return self
+
+    cpdef double complex trace(self):
+        return trace_csr(self)
+
+    cpdef CSR adjoint(self):
+        return adjoint_csr(self)
+
+    cpdef CSR conj(self):
+        return conj_csr(self)
+
+    cpdef CSR transpose(self):
+        return transpose_csr(self)
+
+    def __repr__(self):
+        return "".join([
+            "CSR(shape=", str(self.shape), ", nnz=", str(nnz(self)), ")",
+        ])
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __dealloc__(self):
+        # If we have a reference to a scipy type, then we've passed ownership
+        # of the data to numpy, so we let it handle refcounting and we don't
+        # need to deallocate anything ourselves.
+        if not self._deallocate:
+            return
+        if self.data != NULL:
+            PyDataMem_FREE(self.data)
+        if self.col_index != NULL:
+            PyDataMem_FREE(self.col_index)
+        if self.row_index != NULL:
+            PyDataMem_FREE(self.row_index)
+
+
+cpdef CSR fast_from_scipy(object sci):
+    """
+    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
+    checking on any of the inputs, and should consequently be considered very
+    unsafe.  This is primarily for use in the unpickling operation.
+    """
+    cdef CSR out = CSR.__new__(CSR)
+    out.shape = sci.shape
+    out._deallocate = False
+    out._scipy = sci
+    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
+    out.col_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indices, 0)
+    out.row_index = <base.idxint *> cnp.PyArray_GETPTR1(sci.indptr, 0)
+    out.size = cnp.PyArray_SIZE(sci.data)
+    return out
+
+
+cpdef CSR copy_structure(CSR matrix):
+    """
+    Return a copy of the input matrix with identical `col_index` and
+    `row_index` matrices, and an allocated, but empty, `data`.  The returned
+    pointers are all separately allocated, but contain the same information.
+
+    This is intended for unary functions on CSR types that maintain the exact
+    structure, but modify each non-zero data element without change their
+    location.
+    """
+    cdef CSR out = empty_like(matrix)
+    memcpy(out.col_index, matrix.col_index, nnz(matrix) * sizeof(base.idxint))
+    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1)*sizeof(base.idxint))
+    return out
+
+
+cpdef inline base.idxint nnz(CSR matrix) nogil:
+    """Get the number of non-zero elements of a CSR matrix."""
+    return matrix.row_index[matrix.shape[0]]
+
+
+cdef bool _sorter_cmp_ptr(base.idxint *i, base.idxint *j) nogil:
+    return i[0] < j[0]
+
+cdef bool _sorter_cmp_struct(_data_col x, _data_col y) nogil:
+    return x.col < y.col
+
+ctypedef fused _swap_data:
+    double complex
+    base.idxint
+
+cdef inline void _sorter_swap(_swap_data *a, _swap_data *b) nogil:
+    a[0], b[0] = b[0], a[0]
+
+cdef class Sorter:
+    # Look on my works, ye mighty, and despair!
+    #
+    # This class has hard-coded sorts for up to three elements, for both
+    # copying and in-place varieties.  Everything above that we delegate to a
+    # proper sorting algorithm.
+    def __init__(self, size_t size):
+        self.size = size
+
+    cdef void inplace(self, CSR matrix, base.idxint ptr, size_t size) nogil:
+        cdef size_t n
+        cdef base.idxint col0, col1, col2
+        # Fast paths for tridiagonal matrices.  These fast paths minimise the
+        # number of comparisons and swaps made.
+        if size < 2:
+            return
+        if size == 2:
+            if matrix.col_index[ptr] > matrix.col_index[ptr + 1]:
+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+            return
+        if size == 3:
+            # Faster to store rather than re-dereference, and if someone
+            # changes the data underneath us, we've got larger problems anyway.
+            col0 = matrix.col_index[ptr]
+            col1 = matrix.col_index[ptr + 1]
+            col2 = matrix.col_index[ptr + 2]
+            if col0 < col1:
+                if col1 > col2:
+                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
+                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
+                    if col0 > col2:
+                        _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+                        _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+            elif col1 < col2:
+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+1)
+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+1)
+                if col0 > col2:
+                    _sorter_swap(matrix.col_index + ptr+1, matrix.col_index + ptr+2)
+                    _sorter_swap(matrix.data + ptr+1, matrix.data + ptr+2)
+            else:
+                _sorter_swap(matrix.col_index + ptr, matrix.col_index + ptr+2)
+                _sorter_swap(matrix.data + ptr, matrix.data + ptr+2)
+            return
+        # Now we actually have to do the sort properly.  It's easiest just to
+        # copy the data into a temporary structure.
+        if size > self.size or self.sort == NULL:
+            # realloc(NULL, size) is equivalent to malloc(size), so there's no
+            # problem if cols and argsort weren't allocated before.
+            self.size = size if size > self.size else self.size
+            with gil:
+                self.sort = <_data_col *> mem.PyMem_Realloc(self.sort,
+                                                            self.size * sizeof(_data_col))
+        for n in range(size):
+            self.sort[n].data = matrix.data[ptr + n]
+            self.sort[n].col = matrix.col_index[ptr + n]
+        sort(self.sort, self.sort + size, &_sorter_cmp_struct)
+        for n in range(size):
+            matrix.data[ptr + n] = self.sort[n].data
+            matrix.col_index[ptr + n] = self.sort[n].col
+
+    cdef void copy(self,
+                   double complex *dest_data, base.idxint *dest_cols,
+                   double complex *src_data, base.idxint *src_cols,
+                   size_t size) nogil:
+        cdef size_t n, ptr
+        # Fast paths for small sizes.  Not pretty, but it speeds things up a
+        # lot for up to triadiaongal systems (which are pretty common).
+        if size == 0:
+            return
+        if size == 1:
+            dest_cols[0] = src_cols[0]
+            dest_data[0] = src_data[0]
+            return
+        if size == 2:
+            if src_cols[0] < src_cols[1]:
+                dest_cols[0] = src_cols[0]
+                dest_data[0] = src_data[0]
+                dest_cols[1] = src_cols[1]
+                dest_data[1] = src_data[1]
+            else:
+                dest_cols[1] = src_cols[0]
+                dest_data[1] = src_data[0]
+                dest_cols[0] = src_cols[1]
+                dest_data[0] = src_data[1]
+            return
+        if size == 3:
+            if src_cols[0] < src_cols[1]:
+                if src_cols[0] < src_cols[2]:
+                    dest_cols[0] = src_cols[0]
+                    dest_data[0] = src_data[0]
+                    if src_cols[1] < src_cols[2]:
+                        dest_cols[1] = src_cols[1]
+                        dest_data[1] = src_data[1]
+                        dest_cols[2] = src_cols[2]
+                        dest_data[2] = src_data[2]
+                    else:
+                        dest_cols[2] = src_cols[1]
+                        dest_data[2] = src_data[1]
+                        dest_cols[1] = src_cols[2]
+                        dest_data[1] = src_data[2]
+                else:
+                    dest_cols[1] = src_cols[0]
+                    dest_data[1] = src_data[0]
+                    dest_cols[2] = src_cols[1]
+                    dest_data[2] = src_data[1]
+                    dest_cols[0] = src_cols[2]
+                    dest_data[0] = src_data[2]
+            elif src_cols[0] < src_cols[2]:
+                dest_cols[1] = src_cols[0]
+                dest_data[1] = src_data[0]
+                dest_cols[0] = src_cols[1]
+                dest_data[0] = src_data[1]
+                dest_cols[2] = src_cols[2]
+                dest_data[2] = src_data[2]
+            else:
+                dest_cols[2] = src_cols[0]
+                dest_data[2] = src_data[0]
+                if src_cols[1] < src_cols[2]:
+                    dest_cols[0] = src_cols[1]
+                    dest_data[0] = src_data[1]
+                    dest_cols[1] = src_cols[2]
+                    dest_data[1] = src_data[2]
+                else:
+                    dest_cols[1] = src_cols[1]
+                    dest_data[1] = src_data[1]
+                    dest_cols[0] = src_cols[2]
+                    dest_data[0] = src_data[2]
+            return
+        # Now we're left with the full case, and we have to sort properly.
+        if size > self.size or self.argsort == NULL:
+            # realloc(NULL, size) is equivalent to malloc(size), so there's no
+            # problem if cols and argsort weren't allocated before.
+            self.size = size if size > self.size else self.size
+            with gil:
+                self.argsort = (
+                    <base.idxint **>
+                    mem.PyMem_Realloc(self.argsort, self.size * sizeof(base.idxint *))
+                )
+        # We do the argsort with two levels of indirection to minimise memory
+        # allocation and copying requirements when this function is being used
+        # to assemble a CSR matrix under an operation which may change the
+        # order of the columns (e.g. permute).  First the user makes the
+        # columns accessible in some contiguous memory (or if they're not
+        # changing them, they can just use the CSR buffers).  We put pointers
+        # to each of those columns in the array which actually gets sorted
+        # using a comparison function which dereferences the pointers and
+        # compares the result.  After the sort, `argsort` will be the pointers
+        # sorted according to the new column, and we know that the "lowest"
+        # pointer in there has the value `src_cols`, so we can do pointer
+        # arithmetic to know which element we should take.
+        #
+        # This is about 30-40% faster than allocating space for structs of
+        # (double complex, idxint), copying in the data and column, sorting and
+        # copying into the new arrays.  Allocating the structs actually
+        # allocates more space than the pointer method (double complex is
+        # very likely to be 2x the size of a pointer, _and_ the struct may need
+        # extra padding to be aligned), so it's probably actually worse for
+        # cache locality.  Despite the sort relying on pointer dereference in
+        # this case, it's actually got very good cache locality.
+        for n in range(size):
+            self.argsort[n] = src_cols + n
+        sort(self.argsort, self.argsort + size, &_sorter_cmp_ptr)
+        for n in range(size):
+            ptr = self.argsort[n] - src_cols
+            dest_cols[n] = src_cols[ptr]
+            dest_data[n] = src_data[ptr]
+
+    def __dealloc__(self):
+        if self.argsort != NULL:
+            mem.PyMem_Free(self.argsort)
+        if self.sort != NULL:
+            mem.PyMem_Free(self.sort)
+
+cpdef CSR sorted(CSR matrix):
+    cdef CSR out = empty_like(matrix)
+    cdef Sorter sort
+    cdef base.idxint ptr
+    cdef size_t row, diff, size=0
+    memcpy(out.row_index, matrix.row_index, (matrix.shape[0] + 1) * sizeof(base.idxint))
+    for row in range(matrix.shape[0]):
+        diff = matrix.row_index[row + 1] - matrix.row_index[row]
+        size = diff if diff > size else size
+    sort = Sorter(size)
+    for row in range(matrix.shape[0]):
+        ptr = matrix.row_index[row]
+        diff = matrix.row_index[row + 1] - ptr
+        sort.copy(out.data + ptr, out.col_index + ptr,
+                  matrix.data + ptr, matrix.col_index + ptr,
+                  diff)
+    return out
+
+
+cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
+    """
+    Allocate an empty CSR matrix of the given shape, with space for `size`
+    elements in the `data` and `col_index` arrays.
+
+    This does not initialise any of the memory returned, but sets the last
+    element of `row_index` to 0 to indicate that there are 0 non-zero elements.
+    """
+    if size < 0:
+        raise ValueError("size must be a positive integer.")
+    # Python doesn't like allocating nothing.
+    if size == 0:
+        size += 1
+    cdef CSR out = CSR.__new__(CSR)
+    cdef base.idxint row_size = rows + 1
+    out.shape = (rows, cols)
+    out.size = size
+    out.data =\
+        <double complex *> PyDataMem_NEW(size * sizeof(double complex))
+    out.col_index =\
+        <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
+    out.row_index =\
+        <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
+    # Set the number of non-zero elements to 0.
+    out.row_index[rows] = 0
+    return out
+
+
+cpdef CSR empty_like(CSR other):
+    return empty(other.shape[0], other.shape[1], nnz(other))
+
+
+cpdef CSR zeros(base.idxint rows, base.idxint cols):
+    """
+    Allocate the zero matrix with a given shape.  There will not be any room in
+    the `data` and `col_index` buffers to add new elements.
+    """
+    # We always allocate matrices with at least one element to ensure that we
+    # actually _are_ asking for memory (Python doesn't like allocating nothing)
+    cdef CSR out = empty(rows, cols, 1)
+    out.data[0] = out.col_index[0] = 0
+    memset(out.row_index, 0, (rows + 1) * sizeof(base.idxint))
+    return out
+
+
+cpdef CSR identity(base.idxint dimension, double complex scale=1):
+    """
+    Return a square matrix of the specified dimension, with a constant along
+    the diagonal.  By default this will be the identity matrix, but if `scale`
+    is passed, then the result will be `scale` times the identity.
+    """
+    cdef CSR out = empty(dimension, dimension, dimension)
+    cdef base.idxint i
+    for i in range(dimension):
+        out.data[i] = scale
+        out.col_index[i] = i
+        out.row_index[i] = i
+    out.row_index[dimension] = dimension
+    return out
+
+cpdef CSR from_dense(Dense matrix):
+    # Assume worst-case scenario for non-zero.
+    cdef CSR out = empty(matrix.shape[0], matrix.shape[1],
+                         matrix.shape[0]*matrix.shape[1])
+    cdef size_t row, col, ptr_in, ptr_out=0, row_stride, col_stride
+    row_stride = 1 if matrix.fortran else matrix.shape[1]
+    col_stride = matrix.shape[0] if matrix.fortran else 1
+    out.row_index[0] = 0
+    for row in range(matrix.shape[0]):
+        ptr_in = row_stride * row
+        for col in range(matrix.shape[1]):
+            if matrix.data[ptr_in] != 0:
+                out.data[ptr_out] = matrix.data[ptr_in]
+                out.col_index[ptr_out] = col
+                ptr_out += 1
+            ptr_in += col_stride
+        out.row_index[row + 1] = ptr_out
+    return out
+
+cdef CSR from_coo_pointers(
+    base.idxint *rows, base.idxint *cols, double complex *data,
+    base.idxint n_rows, base.idxint n_cols, base.idxint nnz, double tol=0
+):
+    # Note that COO pointers may not be sorted in row-major order, and that
+    # they may contain duplicate entries which should be implicitly summed.
+    cdef Accumulator acc = acc_alloc(n_cols)
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    cdef double complex *data_tmp
+    cdef base.idxint *cols_tmp
+    cdef base.idxint row
+    cdef size_t ptr_in, ptr_out, ptr_prev
+    data_tmp = <double complex *> mem.PyMem_Malloc(nnz * sizeof(double complex))
+    cols_tmp = <base.idxint *> mem.PyMem_Malloc(nnz * sizeof(base.idxint))
+    if data_tmp == NULL or cols_tmp == NULL:
+        raise MemoryError
+    with nogil:
+        memset(out.row_index, 0, (n_rows + 1) * sizeof(base.idxint))
+        for ptr_in in range(nnz):
+            out.row_index[rows[ptr_in] + 1] += 1
+        for ptr_out in range(n_rows):
+            out.row_index[ptr_out + 1] += out.row_index[ptr_out]
+        # out.row_index is currently in the normal output form, but we're
+        # temporarily going to modify it to keep track of how many values we've
+        # placed in each row as we iterate through.  At every state,
+        # out.row_index[row] will contain a pointer to the next location that
+        # an element should be placed in this row.
+        for ptr_in in range(nnz):
+            row = rows[ptr_in]
+            ptr_out = out.row_index[row]
+            cols_tmp[ptr_out] = cols[ptr_in]
+            data_tmp[ptr_out] = data[ptr_in]
+            out.row_index[row] += 1
+        # Apply the scatter/gather pattern to find the actual number of
+        # non-zero elements we're writing into each row (since there's a sum,
+        # there may be some zeros of duplicates).  Remember we also need to
+        # shift the row_index array back to what it was before as well.
+        ptr_out = 0
+        ptr_prev = 0
+        for row in range(n_rows):
+            for ptr_in in range(ptr_prev, out.row_index[row]):
+                acc_scatter(&acc, data_tmp[ptr_in], cols_tmp[ptr_in])
+            ptr_prev = out.row_index[row]
+            out.row_index[row] = ptr_out
+            ptr_out += acc_gather(&acc, out.data + ptr_out, out.col_index + ptr_out, tol)
+            acc_reset(&acc)
+        out.row_index[n_rows] = ptr_out
+    mem.PyMem_Free(data_tmp)
+    mem.PyMem_Free(cols_tmp)
+    acc_free(&acc)
+    return out
+
+
+cdef inline base.idxint _diagonal_length(
+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+) nogil:
+    if offset > 0:
+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+    return n_cols if offset > n_cols - n_rows else n_rows + offset
+
+cdef CSR diag(
+    double complex[:] diagonal, base.idxint offset,
+    base.idxint n_rows, base.idxint n_cols,
+):
+    """
+    Construct a CSR matrix with a single non-zero diagonal.
+
+    Parameters
+    ----------
+    diagonal : indexable of double complex
+        The entries (including zeros) that should be placed on the diagonal in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal.
+
+    offsets : idxint
+        The index of the diagonals.  An offset of 0 is the main diagonal,
+        positive values are above the main diagonal and negative ones are below
+        the main diagonal.
+
+    n_rows, n_cols : idxint
+        The shape of the output.  The result does not need to be square, but
+        the diagonal must be of the correct length to fit in.
+    """
+    if n_rows < 0 or n_cols < 0:
+        raise ValueError("shape must be positive")
+    cdef base.idxint nnz = len(diagonal)
+    cdef base.idxint n_diag = _diagonal_length(offset, n_rows, n_cols)
+    if nnz != n_diag:
+        raise ValueError("incorrect number of diagonal elements")
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    cdef base.idxint start_row = 0 if offset >= 0 else -offset
+    cdef base.idxint col = 0 if offset <= 0 else offset
+    memset(out.row_index, 0, (start_row + 1) * sizeof(base.idxint))
+    nnz = 0
+    for row in range(start_row + 1, start_row + n_diag + 1):
+        out.col_index[nnz] = col
+        out.data[nnz] = diagonal[nnz]
+        col += 1
+        nnz += 1
+        out.row_index[row] = nnz
+    for row in range(start_row + n_diag + 1, n_rows + 1):
+        out.row_index[row] = nnz
+    return out
+
+cdef CSR diags_(
+    list diagonals, base.idxint[:] offsets,
+    base.idxint n_rows, base.idxint n_cols,
+):
+    """
+    Construct a CSR matrix from a list of diagonals and their offsets.  The
+    offsets are assumed to be in sorted order.  This is the C-only interface to
+    csr.diags, and inputs are not sanity checked (use the Python interface for
+    that).
+
+    Parameters
+    ----------
+    diagonals : list of indexable of double complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal (not checked).
+
+    offsets : idxint[:]
+        The indices of the diagonals.  These should be sorted and without
+        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
+        An offset of 0 is the main diagonal, positive values are above the main
+        diagonal and negative ones are below the main diagonal.
+
+    n_rows, n_cols : idxint
+        The shape of the output.  The result does not need to be square, but
+        the diagonals must be of the correct length to fit in.
+    """
+    cdef size_t n_diagonals = len(diagonals)
+    if n_diagonals == 0:
+        return zeros(n_rows, n_cols)
+    cdef base.idxint k, row, start_row, offset, nnz=0,
+    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
+    cdef double complex value
+    for k in range(n_diagonals):
+        offset = offsets[k]
+        if offset >= 0 and min_k > k:
+            min_k = k
+        nnz += _diagonal_length(offset, n_rows, n_cols)
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    nnz = 0
+    out.row_index[0] = 0
+    for row in range(n_rows):
+        if min_k > 0:
+            offset = offsets[min_k - 1]
+            start_row = 0 if offset >= 0 else -offset
+            if start_row == row:
+                min_k -= 1
+        if max_k > 0:
+            offset = offsets[max_k - 1]
+            start_row = 0 if offset >= 0 else -offset
+            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
+                max_k -= 1
+        for k in range(min_k, max_k):
+            offset = offsets[k]
+            value = diagonals[k][row if offset >= 0 else row + offset]
+            if value == 0:
+                continue
+            out.data[nnz] = value
+            out.col_index[nnz] = row + offset
+            nnz += 1
+        out.row_index[row + 1] = nnz
+    return out
+
+@cython.wraparound(True)
+def diags(diagonals, offsets=None, shape=None):
+    """
+    Construct a CSR matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements.  Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    cdef base.idxint n_rows, n_cols, offset
+    try:
+        diagonals = list(diagonals)
+        if diagonals and np.isscalar(diagonals[0]):
+            # Catch the case where we're being called as (for example)
+            #   diags([1, 2, 3], 0)
+            # with a single diagonal and offset.
+            diagonals = [diagonals]
+    except TypeError:
+        raise TypeError("diagonals must be a list of arrays of complex") from None
+    if offsets is None:
+        if len(diagonals) == 0:
+            offsets = []
+        elif len(diagonals) == 1:
+            offsets = [0]
+        else:
+            raise TypeError("offsets must be supplied if passing more than one diagonal")
+    offsets = np.atleast_1d(offsets)
+    if offsets.ndim > 1:
+        raise ValueError("offsets must be a 1D array of integers")
+    if len(diagonals) != len(offsets):
+        raise ValueError("number of diagonals does not match number of offsets")
+    if len(diagonals) == 0:
+        if shape is None:
+            raise ValueError("cannot construct matrix with no diagonals without a shape")
+        else:
+            n_rows, n_cols = shape
+        return zeros(n_rows, n_cols)
+    order = np.argsort(offsets)
+    diagonals_ = []
+    offsets_ = []
+    prev, cur = None, None
+    for i in order:
+        cur = offsets[i]
+        if cur == prev:
+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+        else:
+            offsets_.append(cur)
+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+        prev = cur
+    if shape is None:
+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+    else:
+        try:
+            n_rows, n_cols = shape
+        except (TypeError, ValueError):
+            raise TypeError("shape must be a 2-tuple of positive integers")
+        if n_rows < 0 or n_cols < 0:
+            raise ValueError("shape must be a 2-tuple of positive integers")
+    for i in range(len(diagonals_)):
+        offset = offsets_[i]
+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+            raise ValueError("given diagonals do not have the correct lengths")
+    if n_rows == 0 and n_cols == 0:
+        raise ValueError("can't produce a 0x0 matrix")
+    if len(offsets) == 1:
+        # Fast path for a single diagonal.
+        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
+    return diags_(
+        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
+    )
+
+
+cpdef CSR _from_csr_blocks(
+    base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
+    base.idxint n_blocks, base.idxint block_size
+):
+    """
+    Construct a CSR from non-overlapping blocks.
+
+    Each operator in ``block_ops`` should be a square CSR operator with
+    shape ``(block_size, block_size)``. The output operator consists of
+    ``n_blocks`` by ``n_blocks`` blocks and thus has shape
+    ``(n_blocks * block_size, n_blocks * block_size)``.
+
+    None of the operators should overlap (i.e. the list of block row and
+    column pairs should be unique).
+
+    Parameters
+    ----------
+    block_rows : sequence of base.idxint integers
+        The block row for each operator. The block row should be in
+        ``range(0, n_blocks)``.
+
+    block_cols : sequence of base.idxint integers
+        The block column for each operator. The block column should be in
+        ``range(0, n_blocks)``.
+
+    block_ops : sequence of CSR matrixes
+        The operators corresponding to the rows and columns in ``block_rows``
+        and ``block_cols``.
+
+    n_blocks : base.idxint
+        Number of blocks. The shape of the final matrix is
+        (n_blocks * block, n_blocks * block).
+
+    block_size : base.idxint
+        Size of each block. The shape of matrices in ``block_ops`` is
+        ``(block_size, block_size)``.
+    """
+    cdef CSR op
+    cdef base.idxint shape = n_blocks * block_size
+    cdef base.idxint nnz_ = 0
+    cdef base.idxint n_ops = len(block_ops)
+    cdef base.idxint i, j
+    cdef base.idxint row_idx, col_idx
+
+    # check arrays are the same length
+    if len(block_rows) != n_ops or len(block_cols) != n_ops:
+        raise ValueError(
+            "The arrays block_rows, block_cols and block_ops should have"
+            " the same length."
+        )
+
+    if n_ops == 0:
+        return zeros(shape, shape)
+
+    # check op shapes and calculate nnz
+    for op in block_ops:
+        nnz_ += nnz(op)
+        if op.shape[0] != block_size or op.shape[1] != block_size:
+            raise ValueError(
+                "Block operators (block_ops) do not have the correct shape."
+            )
+
+    # check ops are ordered by (row, column)
+    row_idx = block_rows[0]
+    col_idx = block_cols[0]
+    for i in range(1, n_ops):
+        if (
+            block_rows[i] < row_idx or
+            (block_rows[i] == row_idx and block_cols[i] <= col_idx)
+        ):
+            raise ValueError(
+                "The arrays block_rows and block_cols must be sorted"
+                " by (row, column)."
+            )
+        row_idx = block_rows[i]
+        col_idx = block_cols[i]
+
+    if nnz_ == 0:
+        return zeros(shape, shape)
+
+    cdef CSR out = empty(shape, shape, nnz_)
+    cdef base.idxint op_idx = 0
+    cdef base.idxint prev_op_idx = 0
+    cdef base.idxint end = 0
+    cdef base.idxint row_pos, col_pos
+    cdef base.idxint op_row, op_row_start, op_row_end, op_row_len
+
+    out.row_index[0] = 0
+
+    for row_idx in range(n_blocks):
+        prev_op_idx = op_idx
+        while op_idx < n_ops:
+            if block_rows[op_idx] != row_idx:
+                break
+            op_idx += 1
+
+        row_pos = row_idx * block_size
+        for op_row in range(block_size):
+            for i in range(prev_op_idx, op_idx):
+                op = block_ops[i]
+                if nnz(op) == 0:
+                    # empty CSR matrices have uninitialized row_index entries.
+                    # it's unclear whether users should ever see such matrixes
+                    # but we support them here anyway.
+                    continue
+                col_idx = block_cols[i]
+                col_pos = col_idx * block_size
+                op_row_start = op.row_index[op_row]
+                op_row_end = op.row_index[op_row + 1]
+                op_row_len = op_row_end - op_row_start
+                for j in range(op_row_len):
+                    out.col_index[end + j] = op.col_index[op_row_start + j] + col_pos
+                    out.data[end + j] = op.data[op_row_start + j]
+                end += op_row_len
+            out.row_index[row_pos + op_row + 1] = end
+
+    return out
diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
index 354bf51045..3c3dad938a 100644
--- a/qutip/core/data/dense.pxd
+++ b/qutip/core/data/dense.pxd
@@ -1,30 +1,30 @@
-#cython: language_level=3
-
-cimport numpy as cnp
-
-from . cimport base
-from .csr cimport CSR
-
-cdef class Dense(base.Data):
-    cdef double complex *data
-    cdef bint fortran
-    cdef object _np
-    cdef bint _deallocate
-    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
-    cpdef Dense reorder(Dense self, int fortran=*)
-    cpdef Dense copy(Dense self)
-    cpdef object as_ndarray(Dense self)
-    cpdef object to_array(Dense self)
-    cpdef double complex trace(Dense self)
-    cpdef Dense adjoint(Dense self)
-    cpdef Dense conj(Dense self)
-    cpdef Dense transpose(Dense self)
-
-cpdef Dense fast_from_numpy(object array)
-cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
-cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
-cpdef Dense empty_like(Dense other, int fortran=*)
-cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
-cpdef Dense identity(base.idxint dimension, double complex scale=*,
-                     bint fortran=*)
-cpdef Dense from_csr(CSR matrix, bint fortran=*)
+#cython: language_level=3
+
+cimport numpy as cnp
+
+from . cimport base
+from .csr cimport CSR
+
+cdef class Dense(base.Data):
+    cdef double complex *data
+    cdef bint fortran
+    cdef object _np
+    cdef bint _deallocate
+    cdef void _fix_flags(Dense self, object array, bint make_owner=*)
+    cpdef Dense reorder(Dense self, int fortran=*)
+    cpdef Dense copy(Dense self)
+    cpdef object as_ndarray(Dense self)
+    cpdef object to_array(Dense self)
+    cpdef double complex trace(Dense self)
+    cpdef Dense adjoint(Dense self)
+    cpdef Dense conj(Dense self)
+    cpdef Dense transpose(Dense self)
+
+cpdef Dense fast_from_numpy(object array)
+cdef Dense wrap(double complex *ptr, base.idxint rows, base.idxint cols, bint fortran=*)
+cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=*)
+cpdef Dense empty_like(Dense other, int fortran=*)
+cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
+cpdef Dense identity(base.idxint dimension, double complex scale=*,
+                     bint fortran=*)
+cpdef Dense from_csr(CSR matrix, bint fortran=*)
diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
index f16578b4ba..38c32f5bb8 100644
--- a/qutip/core/data/dense.pyx
+++ b/qutip/core/data/dense.pyx
@@ -1,409 +1,409 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memcpy
-cimport cython
-
-import numbers
-
-import numpy as np
-cimport numpy as cnp
-from scipy.linalg cimport cython_blas as blas
-
-from .base import EfficiencyWarning
-from qutip.core.data cimport base, CSR
-from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
-from qutip.core.data.trace cimport trace_dense
-
-cnp.import_array()
-
-cdef int _ONE = 1
-
-cdef extern from *:
-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
-    void *PyDataMem_NEW(size_t size)
-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-    void PyDataMem_FREE(void *ptr)
-
-
-# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
-# to avoid naming clashes with other type modules.
-__all__ = [
-    'Dense', 'OrderEfficiencyWarning',
-]
-
-
-class OrderEfficiencyWarning(EfficiencyWarning):
-    pass
-
-
-cdef class Dense(base.Data):
-    def __init__(self, data, shape=None, copy=True):
-        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
-        # Ensure that the array is contiguous.
-        # Non contiguous array with copy=False would otherwise slip through
-        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
-                cnp.PyArray_IS_F_CONTIGUOUS(base)):
-            base = base.copy()
-        if shape is None:
-            shape = base.shape
-            if len(shape) == 0:
-                shape = (1, 1)
-            # Promote to a ket by default if passed 1D data.
-            if len(shape) == 1:
-                shape = (shape[0], 1)
-        if not (
-            len(shape) == 2
-            and isinstance(shape[0], numbers.Integral)
-            and isinstance(shape[1], numbers.Integral)
-            and shape[0] > 0
-            and shape[1] > 0
-        ):
-            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
-        if shape[0] * shape[1] != base.size:
-            raise ValueError("".join([
-                "invalid shape ",
-                str(shape),
-                " for input data with size ",
-                str(base.size)
-            ]))
-        self._np = base.reshape(shape, order='A')
-        self._deallocate = False
-        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
-        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
-        self.shape = (shape[0], shape[1])
-
-    def __reduce__(self):
-        return (fast_from_numpy, (self.as_ndarray(),))
-
-    def __repr__(self):
-        return "".join([
-            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
-        ])
-
-    def __str__(self):
-        return self.__repr__()
-
-    cpdef Dense reorder(self, int fortran=-1):
-        cdef bint fortran_
-        if fortran < 0:
-            fortran_ = not self.fortran
-        else:
-            fortran_ = fortran
-        if bool(fortran_) == bool(self.fortran):
-            return self.copy()
-        cdef Dense out = empty_like(self, fortran_)
-        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
-        stride = self.shape[1] if self.fortran else self.shape[0]
-        splits = self.shape[0] if self.fortran else self.shape[1]
-        for idx_out_start in range(stride):
-            idx_out = idx_out_start
-            for _ in range(splits):
-                out.data[idx_out] = self.data[idx_self]
-                idx_self += 1
-                idx_out += stride
-        return out
-
-    cpdef Dense copy(self):
-        """
-        Return a complete (deep) copy of this object.
-
-        If the type currently has a numpy backing, such as that produced by
-        `as_ndarray`, this will not be copied.  The backing is a view onto our
-        data, and a straight copy of this view would be incorrect.  We do not
-        create a new view at copy time, since the user may only access this
-        through a creation method, and creating it ahead of time would incur an
-        unnecessary speed penalty for users who do not need it (including
-        low-level C code).
-        """
-        cdef Dense out = Dense.__new__(Dense)
-        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
-        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
-        memcpy(ptr, self.data, size)
-        out.shape = self.shape
-        out.data = ptr
-        out.fortran = self.fortran
-        out._deallocate = True
-        return out
-
-    cdef void _fix_flags(self, object array, bint make_owner=False):
-        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
-        cdef int disable = 0
-        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
-        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
-        # Not necessary when creating a new array because this will already
-        # have been done, but needed for as_ndarray() if we have been mutated.
-        dims[0] = self.shape[0]
-        dims[1] = self.shape[1]
-        if self.shape[0] == 1 or self.shape[1] == 1:
-            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
-            strides[0] = self.shape[1] * sizeof(double complex)
-            strides[1] = sizeof(double complex)
-        elif self.fortran:
-            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
-            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
-            strides[0] = sizeof(double complex)
-            strides[1] = self.shape[0] * sizeof(double complex)
-        else:
-            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
-            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
-            strides[0] = self.shape[1] * sizeof(double complex)
-            strides[1] = sizeof(double complex)
-        PyArray_ENABLEFLAGS(array, enable)
-        PyArray_CLEARFLAGS(array, disable)
-
-    cpdef object to_array(self):
-        """
-        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
-        be Fortran or C-ordered, but will be contiguous in one of the
-        dimensions.  This is not a view onto the data, and changes to new array
-        will not affect the original data structure.
-        """
-        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
-        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
-        memcpy(ptr, self.data, size)
-        cdef object out =\
-            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
-                                          cnp.NPY_COMPLEX128, ptr)
-        self._fix_flags(out, make_owner=True)
-        return out
-
-    cpdef object as_ndarray(self):
-        """
-        Get a view onto this object as a `numpy.ndarray`.  The underlying data
-        structure is exposed, such that modifications to the array will modify
-        this object too.
-
-        The array may be uninitialised, depending on how the Dense type was
-        created.  The output will be contiguous and of dtype 'complex128', but
-        may be C- or Fortran-ordered.
-        """
-        if self._np is not None:
-            # We have to do this every time in case someone has changed our
-            # ordering or shape inplace.
-            self._fix_flags(self._np, make_owner=False)
-            return self._np
-        self._np =\
-            cnp.PyArray_SimpleNewFromData(
-                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
-            )
-        self._fix_flags(self._np, make_owner=self._deallocate)
-        self._deallocate = False
-        return self._np
-
-    cpdef double complex trace(self):
-        return trace_dense(self)
-
-    cpdef Dense adjoint(self):
-        return adjoint_dense(self)
-
-    cpdef Dense conj(self):
-        return conj_dense(self)
-
-    cpdef Dense transpose(self):
-        return transpose_dense(self)
-
-    def __dealloc__(self):
-        if self._deallocate and self.data != NULL:
-            PyDataMem_FREE(self.data)
-
-
-cpdef Dense fast_from_numpy(object array):
-    """
-    Fast path construction from numpy ndarray.  This does _no_ type checking on
-    the input, and should consequently be considered very unsafe.  This is
-    primarily for use in the unpickling operation.
-    """
-    cdef Dense out = Dense.__new__(Dense)
-    if array.ndim == 1:
-        out.shape = (array.shape[0], 1)
-        array = array[:, None]
-    else:
-        out.shape = (array.shape[0], array.shape[1])
-    out._deallocate = False
-    out._np = array
-    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
-    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
-    return out
-
-cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
-    cdef Dense out = Dense.__new__(Dense)
-    out.data = data
-    out._deallocate = False
-    out.fortran = fortran or cols == 1 or rows == 1
-    out.shape = (rows, cols)
-    return out
-
-
-cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
-    """
-    Return a new Dense type of the given shape, with the data allocated but
-    uninitialised.
-    """
-    cdef Dense out = Dense.__new__(Dense)
-    out.shape = (rows, cols)
-    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
-    out._deallocate = True
-    out.fortran = fortran
-    return out
-
-
-cpdef Dense empty_like(Dense other, int fortran=-1):
-    cdef bint fortran_
-    if fortran < 0:
-        fortran_ = other.fortran
-    else:
-        fortran_ = fortran
-    return empty(other.shape[0], other.shape[1], fortran=fortran_)
-
-
-cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
-    """Return the zero matrix with the given shape."""
-    cdef Dense out = Dense.__new__(Dense)
-    out.shape = (rows, cols)
-    out.data =\
-        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
-    out.fortran = fortran
-    out._deallocate = True
-    return out
-
-
-cpdef Dense identity(base.idxint dimension, double complex scale=1,
-                     bint fortran=True):
-    """
-    Return a square matrix of the specified dimension, with a constant along
-    the diagonal.  By default this will be the identity matrix, but if `scale`
-    is passed, then the result will be `scale` times the identity.
-    """
-    cdef size_t row
-    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
-    for row in range(dimension):
-        out.data[row*dimension + row] = scale
-    return out
-
-
-cpdef Dense from_csr(CSR matrix, bint fortran=False):
-    cdef Dense out = Dense.__new__(Dense)
-    out.shape = matrix.shape
-    out.data = (
-        <double complex *>
-        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
-    )
-    out.fortran = fortran
-    out._deallocate = True
-    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
-    row_stride = 1 if fortran else out.shape[1]
-    col_stride = out.shape[0] if fortran else 1
-    ptr_out = 0
-    for row in range(out.shape[0]):
-        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
-            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
-        ptr_out += row_stride
-    return out
-
-
-cdef inline base.idxint _diagonal_length(
-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-) nogil:
-    if offset > 0:
-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-    return n_cols if offset > n_cols - n_rows else n_rows + offset
-
-
-@cython.wraparound(True)
-def diags(diagonals, offsets=None, shape=None):
-    """
-    Construct a matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements. Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    cdef base.idxint n_rows, n_cols, offset
-    try:
-        diagonals = list(diagonals)
-        if diagonals and np.isscalar(diagonals[0]):
-            # Catch the case where we're being called as (for example)
-            #   diags([1, 2, 3], 0)
-            # with a single diagonal and offset.
-            diagonals = [diagonals]
-    except TypeError:
-        raise TypeError("diagonals must be a list of arrays of complex") from None
-    if offsets is None:
-        if len(diagonals) == 0:
-            offsets = []
-        elif len(diagonals) == 1:
-            offsets = [0]
-        else:
-            raise TypeError("offsets must be supplied if passing more than one diagonal")
-    offsets = np.atleast_1d(offsets)
-    if offsets.ndim > 1:
-        raise ValueError("offsets must be a 1D array of integers")
-    if len(diagonals) != len(offsets):
-        raise ValueError("number of diagonals does not match number of offsets")
-    if len(diagonals) == 0:
-        if shape is None:
-            raise ValueError("cannot construct matrix with no diagonals without a shape")
-        else:
-            n_rows, n_cols = shape
-        return zeros(n_rows, n_cols)
-    order = np.argsort(offsets)
-    diagonals_ = []
-    offsets_ = []
-    prev, cur = None, None
-    for i in order:
-        cur = offsets[i]
-        if cur == prev:
-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-        else:
-            offsets_.append(cur)
-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-        prev = cur
-    if shape is None:
-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-    else:
-        try:
-            n_rows, n_cols = shape
-        except (TypeError, ValueError):
-            raise TypeError("shape must be a 2-tuple of positive integers")
-        if n_rows < 0 or n_cols < 0:
-            raise ValueError("shape must be a 2-tuple of positive integers")
-    for i in range(len(diagonals_)):
-        offset = offsets_[i]
-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-            raise ValueError("given diagonals do not have the correct lengths")
-    if n_rows == 0 and n_cols == 0:
-        raise ValueError("can't produce a 0x0 matrix")
-
-    out = zeros(n_rows, n_cols, fortran=True)
-
-    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
-
-    for diag_idx in range(n_diagonals):
-        offset = offsets_[diag_idx]
-        if offset <= 0:
-            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
-                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
-        else:
-            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
-                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
-    return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memcpy
+cimport cython
+
+import numbers
+
+import numpy as np
+cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
+
+from .base import EfficiencyWarning
+from qutip.core.data cimport base, CSR
+from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
+from qutip.core.data.trace cimport trace_dense
+
+cnp.import_array()
+
+cdef int _ONE = 1
+
+cdef extern from *:
+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+    void PyArray_CLEARFLAGS(cnp.ndarray arr, int flags)
+    void *PyDataMem_NEW(size_t size)
+    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
+    void PyDataMem_FREE(void *ptr)
+
+
+# Creation functions like 'identity' and 'from_csr' aren't exported in __all__
+# to avoid naming clashes with other type modules.
+__all__ = [
+    'Dense', 'OrderEfficiencyWarning',
+]
+
+
+class OrderEfficiencyWarning(EfficiencyWarning):
+    pass
+
+
+cdef class Dense(base.Data):
+    def __init__(self, data, shape=None, copy=True):
+        base = np.array(data, dtype=np.complex128, order='K', copy=copy)
+        # Ensure that the array is contiguous.
+        # Non contiguous array with copy=False would otherwise slip through
+        if not (cnp.PyArray_IS_C_CONTIGUOUS(base) or
+                cnp.PyArray_IS_F_CONTIGUOUS(base)):
+            base = base.copy()
+        if shape is None:
+            shape = base.shape
+            if len(shape) == 0:
+                shape = (1, 1)
+            # Promote to a ket by default if passed 1D data.
+            if len(shape) == 1:
+                shape = (shape[0], 1)
+        if not (
+            len(shape) == 2
+            and isinstance(shape[0], numbers.Integral)
+            and isinstance(shape[1], numbers.Integral)
+            and shape[0] > 0
+            and shape[1] > 0
+        ):
+            raise ValueError("shape must be a 2-tuple of positive ints, but is " + repr(shape))
+        if shape[0] * shape[1] != base.size:
+            raise ValueError("".join([
+                "invalid shape ",
+                str(shape),
+                " for input data with size ",
+                str(base.size)
+            ]))
+        self._np = base.reshape(shape, order='A')
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR2(self._np, 0, 0)
+        self.fortran = cnp.PyArray_IS_F_CONTIGUOUS(self._np)
+        self.shape = (shape[0], shape[1])
+
+    def __reduce__(self):
+        return (fast_from_numpy, (self.as_ndarray(),))
+
+    def __repr__(self):
+        return "".join([
+            "Dense(shape=", str(self.shape), ", fortran=", str(self.fortran), ")",
+        ])
+
+    def __str__(self):
+        return self.__repr__()
+
+    cpdef Dense reorder(self, int fortran=-1):
+        cdef bint fortran_
+        if fortran < 0:
+            fortran_ = not self.fortran
+        else:
+            fortran_ = fortran
+        if bool(fortran_) == bool(self.fortran):
+            return self.copy()
+        cdef Dense out = empty_like(self, fortran_)
+        cdef size_t idx_self=0, idx_out, idx_out_start, stride, splits
+        stride = self.shape[1] if self.fortran else self.shape[0]
+        splits = self.shape[0] if self.fortran else self.shape[1]
+        for idx_out_start in range(stride):
+            idx_out = idx_out_start
+            for _ in range(splits):
+                out.data[idx_out] = self.data[idx_self]
+                idx_self += 1
+                idx_out += stride
+        return out
+
+    cpdef Dense copy(self):
+        """
+        Return a complete (deep) copy of this object.
+
+        If the type currently has a numpy backing, such as that produced by
+        `as_ndarray`, this will not be copied.  The backing is a view onto our
+        data, and a straight copy of this view would be incorrect.  We do not
+        create a new view at copy time, since the user may only access this
+        through a creation method, and creating it ahead of time would incur an
+        unnecessary speed penalty for users who do not need it (including
+        low-level C code).
+        """
+        cdef Dense out = Dense.__new__(Dense)
+        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
+        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+        memcpy(ptr, self.data, size)
+        out.shape = self.shape
+        out.data = ptr
+        out.fortran = self.fortran
+        out._deallocate = True
+        return out
+
+    cdef void _fix_flags(self, object array, bint make_owner=False):
+        cdef int enable = cnp.NPY_ARRAY_OWNDATA if make_owner else 0
+        cdef int disable = 0
+        cdef cnp.Py_intptr_t *dims = cnp.PyArray_DIMS(array)
+        cdef cnp.Py_intptr_t *strides = cnp.PyArray_STRIDES(array)
+        # Not necessary when creating a new array because this will already
+        # have been done, but needed for as_ndarray() if we have been mutated.
+        dims[0] = self.shape[0]
+        dims[1] = self.shape[1]
+        if self.shape[0] == 1 or self.shape[1] == 1:
+            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS | cnp.NPY_ARRAY_C_CONTIGUOUS
+            strides[0] = self.shape[1] * sizeof(double complex)
+            strides[1] = sizeof(double complex)
+        elif self.fortran:
+            enable |= cnp.NPY_ARRAY_F_CONTIGUOUS
+            disable |= cnp.NPY_ARRAY_C_CONTIGUOUS
+            strides[0] = sizeof(double complex)
+            strides[1] = self.shape[0] * sizeof(double complex)
+        else:
+            enable |= cnp.NPY_ARRAY_C_CONTIGUOUS
+            disable |= cnp.NPY_ARRAY_F_CONTIGUOUS
+            strides[0] = self.shape[1] * sizeof(double complex)
+            strides[1] = sizeof(double complex)
+        PyArray_ENABLEFLAGS(array, enable)
+        PyArray_CLEARFLAGS(array, disable)
+
+    cpdef object to_array(self):
+        """
+        Get a copy of this data as a full 2D, contiguous NumPy array.  This may
+        be Fortran or C-ordered, but will be contiguous in one of the
+        dimensions.  This is not a view onto the data, and changes to new array
+        will not affect the original data structure.
+        """
+        cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
+        cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+        memcpy(ptr, self.data, size)
+        cdef object out =\
+            cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
+                                          cnp.NPY_COMPLEX128, ptr)
+        self._fix_flags(out, make_owner=True)
+        return out
+
+    cpdef object as_ndarray(self):
+        """
+        Get a view onto this object as a `numpy.ndarray`.  The underlying data
+        structure is exposed, such that modifications to the array will modify
+        this object too.
+
+        The array may be uninitialised, depending on how the Dense type was
+        created.  The output will be contiguous and of dtype 'complex128', but
+        may be C- or Fortran-ordered.
+        """
+        if self._np is not None:
+            # We have to do this every time in case someone has changed our
+            # ordering or shape inplace.
+            self._fix_flags(self._np, make_owner=False)
+            return self._np
+        self._np =\
+            cnp.PyArray_SimpleNewFromData(
+                2, [self.shape[0], self.shape[1]], cnp.NPY_COMPLEX128, self.data
+            )
+        self._fix_flags(self._np, make_owner=self._deallocate)
+        self._deallocate = False
+        return self._np
+
+    cpdef double complex trace(self):
+        return trace_dense(self)
+
+    cpdef Dense adjoint(self):
+        return adjoint_dense(self)
+
+    cpdef Dense conj(self):
+        return conj_dense(self)
+
+    cpdef Dense transpose(self):
+        return transpose_dense(self)
+
+    def __dealloc__(self):
+        if self._deallocate and self.data != NULL:
+            PyDataMem_FREE(self.data)
+
+
+cpdef Dense fast_from_numpy(object array):
+    """
+    Fast path construction from numpy ndarray.  This does _no_ type checking on
+    the input, and should consequently be considered very unsafe.  This is
+    primarily for use in the unpickling operation.
+    """
+    cdef Dense out = Dense.__new__(Dense)
+    if array.ndim == 1:
+        out.shape = (array.shape[0], 1)
+        array = array[:, None]
+    else:
+        out.shape = (array.shape[0], array.shape[1])
+    out._deallocate = False
+    out._np = array
+    out.data = <double complex *> cnp.PyArray_GETPTR2(array, 0, 0)
+    out.fortran = cnp.PyArray_IS_F_CONTIGUOUS(array)
+    return out
+
+cdef Dense wrap(double complex *data, base.idxint rows, base.idxint cols, bint fortran=False):
+    cdef Dense out = Dense.__new__(Dense)
+    out.data = data
+    out._deallocate = False
+    out.fortran = fortran or cols == 1 or rows == 1
+    out.shape = (rows, cols)
+    return out
+
+
+cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
+    """
+    Return a new Dense type of the given shape, with the data allocated but
+    uninitialised.
+    """
+    cdef Dense out = Dense.__new__(Dense)
+    out.shape = (rows, cols)
+    out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
+    out._deallocate = True
+    out.fortran = fortran
+    return out
+
+
+cpdef Dense empty_like(Dense other, int fortran=-1):
+    cdef bint fortran_
+    if fortran < 0:
+        fortran_ = other.fortran
+    else:
+        fortran_ = fortran
+    return empty(other.shape[0], other.shape[1], fortran=fortran_)
+
+
+cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
+    """Return the zero matrix with the given shape."""
+    cdef Dense out = Dense.__new__(Dense)
+    out.shape = (rows, cols)
+    out.data =\
+        <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
+    out.fortran = fortran
+    out._deallocate = True
+    return out
+
+
+cpdef Dense identity(base.idxint dimension, double complex scale=1,
+                     bint fortran=True):
+    """
+    Return a square matrix of the specified dimension, with a constant along
+    the diagonal.  By default this will be the identity matrix, but if `scale`
+    is passed, then the result will be `scale` times the identity.
+    """
+    cdef size_t row
+    cdef Dense out = zeros(dimension, dimension, fortran=fortran)
+    for row in range(dimension):
+        out.data[row*dimension + row] = scale
+    return out
+
+
+cpdef Dense from_csr(CSR matrix, bint fortran=False):
+    cdef Dense out = Dense.__new__(Dense)
+    out.shape = matrix.shape
+    out.data = (
+        <double complex *>
+        PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
+    )
+    out.fortran = fortran
+    out._deallocate = True
+    cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
+    row_stride = 1 if fortran else out.shape[1]
+    col_stride = out.shape[0] if fortran else 1
+    ptr_out = 0
+    for row in range(out.shape[0]):
+        for ptr_in in range(matrix.row_index[row], matrix.row_index[row + 1]):
+            out.data[ptr_out + matrix.col_index[ptr_in]*col_stride] = matrix.data[ptr_in]
+        ptr_out += row_stride
+    return out
+
+
+cdef inline base.idxint _diagonal_length(
+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+) nogil:
+    if offset > 0:
+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+    return n_cols if offset > n_cols - n_rows else n_rows + offset
+
+
+@cython.wraparound(True)
+def diags(diagonals, offsets=None, shape=None):
+    """
+    Construct a matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements. Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    cdef base.idxint n_rows, n_cols, offset
+    try:
+        diagonals = list(diagonals)
+        if diagonals and np.isscalar(diagonals[0]):
+            # Catch the case where we're being called as (for example)
+            #   diags([1, 2, 3], 0)
+            # with a single diagonal and offset.
+            diagonals = [diagonals]
+    except TypeError:
+        raise TypeError("diagonals must be a list of arrays of complex") from None
+    if offsets is None:
+        if len(diagonals) == 0:
+            offsets = []
+        elif len(diagonals) == 1:
+            offsets = [0]
+        else:
+            raise TypeError("offsets must be supplied if passing more than one diagonal")
+    offsets = np.atleast_1d(offsets)
+    if offsets.ndim > 1:
+        raise ValueError("offsets must be a 1D array of integers")
+    if len(diagonals) != len(offsets):
+        raise ValueError("number of diagonals does not match number of offsets")
+    if len(diagonals) == 0:
+        if shape is None:
+            raise ValueError("cannot construct matrix with no diagonals without a shape")
+        else:
+            n_rows, n_cols = shape
+        return zeros(n_rows, n_cols)
+    order = np.argsort(offsets)
+    diagonals_ = []
+    offsets_ = []
+    prev, cur = None, None
+    for i in order:
+        cur = offsets[i]
+        if cur == prev:
+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+        else:
+            offsets_.append(cur)
+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+        prev = cur
+    if shape is None:
+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+    else:
+        try:
+            n_rows, n_cols = shape
+        except (TypeError, ValueError):
+            raise TypeError("shape must be a 2-tuple of positive integers")
+        if n_rows < 0 or n_cols < 0:
+            raise ValueError("shape must be a 2-tuple of positive integers")
+    for i in range(len(diagonals_)):
+        offset = offsets_[i]
+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+            raise ValueError("given diagonals do not have the correct lengths")
+    if n_rows == 0 and n_cols == 0:
+        raise ValueError("can't produce a 0x0 matrix")
+
+    out = zeros(n_rows, n_cols, fortran=True)
+
+    cdef size_t diag_idx, idx, n_diagonals = len(diagonals_)
+
+    for diag_idx in range(n_diagonals):
+        offset = offsets_[diag_idx]
+        if offset <= 0:
+            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
+                out.data[idx*(n_rows+1) - offset] = diagonals_[diag_idx][idx]
+        else:
+            for idx in range(_diagonal_length(offset, n_rows, n_cols)):
+                out.data[idx*(n_rows+1) + offset*n_rows] = diagonals_[diag_idx][idx]
+    return out
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 276477b4d9..e8abebd7bc 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -1,583 +1,583 @@
-#cython: language_level=3
-
-import functools
-import inspect
-import itertools
-import warnings
-
-from .convert import to as _to
-
-cimport cython
-from libc cimport math
-from libcpp cimport bool
-
-__all__ = ['Dispatcher']
-
-cdef class _bind:
-    """
-    Cythonised implementation of inspect.Signature.bind, supporting faster
-    binding and handling of default arguments.  On construction, the signature
-    of the base function is extracted, and all parameters are parsed into
-    positional or keyword slots, using positional wherever possible, and their
-    defaults are stored.
-    """
-    # Instance of inpsect.Signature representing the function.
-    cdef object signature
-    cdef object inputs
-    # Mapping of (str: int), where str is the name of any argument which may be
-    # specified by a keyword, and int is its location in `self._pos` if
-    # available, or -1 if it is keyword-only.
-    cdef dict _locations
-    # Default values (or inspect.Parameter.empty) for every parameter which
-    # may be passed as a positional argument.
-    cdef list _pos
-    # For each dispatcher input which can be given as a positional argument,
-    # these two lists hold the index of the input in the given tuple of input
-    # names and the corresponding index into the positional arguments after
-    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
-    # effectively the same mapping as _kw_inputs (but for positional
-    # arguments), but we use two lists rather than a dictionary for speed.
-    cdef list _pos_inputs_input, _pos_inputs_pos
-    # Default values (or inspect.Parameter.empty) for every parameter which
-    # _must_ be passed as a keyword argument.
-    cdef dict _kw
-    # Mapping of (name, index into the input tuple) for each input which must
-    # be specified as a keyword argument
-    cdef list _kw_inputs
-    # Names of the keyword arguments which have default values.
-    cdef set _default_kw_names
-    # Respectively, numbers of positional parameters, keyword-only parameters
-    # and dispatcher inputs.
-    cdef Py_ssize_t n_args, n_kwargs, n_inputs
-    # Respectively, numbers of inputs which are positional and keyword-only.
-    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
-    # Respectively, numbers of positional arguments without a default, and
-    # number of keyword-only arguments which _have_ a default.
-    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
-
-
-    def __init__(self, signature, tuple inputs):
-        for arg in inputs:
-            if arg not in signature.parameters:
-                raise AttributeError("No argument matches '{}'.".format(arg))
-        self.signature = signature
-        self.inputs = inputs
-        self._locations = {}
-        self._pos = []
-        self._pos_inputs_input = []
-        self._pos_inputs_pos = []
-        self._kw = {}
-        self._kw_inputs = []
-        self._default_kw_names = set()
-        self._n_pos_no_default = 0
-        # signature.parameters is ordered for all Python versions.
-        for i, (name, parameter) in enumerate(signature.parameters.items()):
-            kind = parameter.kind
-            if (kind == parameter.VAR_POSITIONAL
-                    or kind == parameter.VAR_KEYWORD):
-                raise TypeError("Cannot dispatch with *args or **kwargs.")
-            if kind == parameter.KEYWORD_ONLY:
-                self._kw[name] = parameter.default
-                self._locations[name] = -1
-                if parameter.default is not parameter.empty:
-                    self._default_kw_names.add(name)
-                if name in inputs:
-                    self._kw_inputs.append((name, inputs.index(name)))
-            else:
-                self._pos.append(parameter.default)
-                if kind != parameter.POSITIONAL_ONLY:
-                    self._locations[name] = i
-                if parameter.default is parameter.empty:
-                    self._n_pos_no_default += 1
-                if name in inputs:
-                    # Effectively a mapping.
-                    self._pos_inputs_input.append(inputs.index(name))
-                    self._pos_inputs_pos.append(len(self._pos) - 1)
-        self.n_args = len(self._pos)
-        self.n_kwargs = len(self._kw)
-        self.n_inputs = len(inputs)
-        self._n_pos_inputs = len(self._pos_inputs_input)
-        self._n_kw_inputs = len(self._kw_inputs)
-        self._n_kw_default = len(self._default_kw_names)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef tuple bind(self, tuple args, dict kwargs):
-        """
-        Cython reimplementation of inspect.Signature.bind for binding the
-        collected `*args` and `**kwargs` of a generic call to a specific
-        signature, checking that everything matches.
-
-        The output is a parsed tuple (args, kwargs), where `args` is a list and
-        `kwargs` is a dict, however all arguments which _can_ be passed
-        positionally will be moved from `kwargs` into `args` for the output.
-        The resultant `args` and `kwargs` can be unpacked into the underlying
-        function call safely.  Default values are not filled in by this method.
-
-        This is necessary to allow a generic `Dispatcher` class to work with
-        all type signatures.  The result of this function can be fed to
-        `_bind.convert_types` and `_bind.dispatch_types`.
-        """
-        cdef Py_ssize_t location, got_pos=0, got_kw=0
-        cdef Py_ssize_t n_passed_args = len(args)
-        if n_passed_args > self.n_args:
-            raise TypeError(
-                "Too many arguments: expected at most {} but received {}."
-                .format(n_passed_args, self.n_args)
-            )
-        # _pos and _kw are filled with their defaults at initialisation, and
-        # _pos is already the correct length (no-default parameters have
-        # sentinel values).
-        cdef list out_pos = self._pos.copy()
-        cdef dict out_kw = self._kw.copy()
-        got_pos = self.n_args - self._n_pos_no_default
-        got_kw = self._n_kw_default
-        # Positional arguments unambiguously fill the first positional slots.
-        for location in range(n_passed_args):
-            out_pos[location] = args[location]
-        # How many arguments that we didn't have defaults for did we just get?
-        # Positionals with a default are always after those without one.
-        if n_passed_args > self._n_pos_no_default:
-            got_pos += self._n_pos_no_default
-        else:
-            got_pos += n_passed_args
-        # Everything else has been passed by keyword, but it may be allowed to
-        # be passed positionally, which is the case we prefer.  dict.items() is
-        # (relatively) expensive, so we use a boolean test for the fast path.
-        cdef str kw
-        cdef object arg
-        if kwargs:
-            for kw, arg in kwargs.items():
-                try:
-                    location = self._locations[kw]
-                except KeyError:
-                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
-                # _locations[kw] = -1 if kw is keyword-only, otherwise the
-                # corresponding positional location.
-                if location >= 0:
-                    if location < n_passed_args:
-                        raise TypeError("Multiple values for '{}'".format(kw))
-                    out_pos[location] = arg
-                    if location < self._n_pos_no_default:
-                        got_pos += 1
-                else:
-                    out_kw[kw] = arg
-                    if kw not in self._default_kw_names:
-                        got_kw += 1
-        if got_pos < self.n_args:
-            raise TypeError("Too few positional arguments passed.")
-        if got_kw < self.n_kwargs:
-            raise TypeError("Not all keyword arguments were filled.")
-        return out_pos, out_kw
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef list dispatch_types(self, list args, dict kwargs):
-        """
-        Get a list of the types which the dispatch should operate over, given
-        the output of `_bind.bind`.  The return value is a list of the _input_
-        types to be dispatched on, in order that they were specified at
-        `Dispatcher` creation.  The output type is not returned as part of this
-        list, because there is no way for `_bind` to know it.
-        """
-        cdef list dispatch = [None] * self.n_inputs
-        cdef str kw
-        cdef Py_ssize_t location, i
-        for location in range(self._n_pos_inputs):
-            dispatch[self._pos_inputs_input[location]]\
-                = type(args[self._pos_inputs_pos[location]])
-        for i in range(self._n_kw_inputs):
-            kw, location = self._kw_inputs[i]
-            dispatch[location] = type(kwargs[kw])
-        return dispatch
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
-        """
-        Apply the type converters `converters` to the parsed arguments `args`
-        and `kwargs`.
-
-        If there are `n` inputs which are dispatched on, `converters` should be
-        a tuple whose first `n` elements are converters (such as those obtained
-        from `data.to[to_type, from_type]`) to the desired types.
-
-        `args` and `kwargs` should be the output of `_bind.bind`; the function
-        will likely fail if called on unparsed arguments.
-        """
-        cdef str kw
-        cdef Py_ssize_t location, i
-        for location in range(self._n_pos_inputs):
-            args[location] = converters[location](args[location])
-        for i in range(self._n_kw_inputs):
-            kw, location = self._kw_inputs[i]
-            kwargs[kw] = converters[location](kwargs[kw])
-        return args, kwargs
-
-
-cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
-    """
-    Find the total weight of conversion if the types in `froms` are converted
-    element-wise to the types in `tos`.  `weight_map` is a mapping of
-    `(to_type, from_type): real`; it should almost certainly be
-    `data.to.weight`.
-    """
-    cdef double weight = 0.0
-    cdef Py_ssize_t i, n=len(froms)
-    if len(tos) != n:
-        raise ValueError(
-            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
-        )
-    if out:
-        n = n - 1
-        weight += weight_map[froms[n], tos[n]]
-    for i in range(n):
-        weight += weight_map[tos[i], froms[i]]
-    return weight
-
-
-cdef class _constructed_specialisation:
-    """
-    Callable object providing the specialisation of a data-layer operation for
-    a particular set of types (`self.types`).  This may or may not involve
-    conversion of the input types and the output to match a known
-    specialisation; if it has no conversions, `self.direct` will be `True`,
-    otherwise it will be `False`.
-
-    See `self.__signature__` or `self.__text_signature__` for the call
-    signature of this object.
-    """
-    cdef _bind _parameters
-    cdef bint _output
-    cdef object _call
-    cdef Py_ssize_t _n_dispatch
-    cdef readonly tuple types
-    cdef tuple _converters
-    cdef str _short_name
-    cdef public str __doc__
-    cdef public str __name__
-    cdef public str __module__
-    cdef public object __signature__
-    cdef readonly str __text_signature__
-    cdef readonly bint direct
-
-    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
-                 direct):
-        self.__doc__ = inspect.getdoc(dispatcher)
-        self._short_name = dispatcher.__name__
-        self.__name__ = (
-            self._short_name
-            + "_"
-            + "_".join([x.__name__ for x in types])
-        )
-        self.__module__ = dispatcher.__module__
-        self.__signature__ = dispatcher.__signature__
-        self.__text_signature__ = dispatcher.__text_signature__
-        self._parameters = dispatcher._parameters
-        self._output = out
-        self._call = base
-        self._n_dispatch = len(types)
-        self.types = types
-        self.direct = direct
-        self._converters = converters
-
-    cdef object prebound(self, list args, dict kwargs):
-        """
-        Call this specialisation with pre-parsed arguments and keyword
-        arguments.  `args` and `kwargs` must be the output of the relevant
-        `_bind.bind` method for this function.
-        """
-        self._parameters.convert_types(args, kwargs, self._converters)
-        out = self._call(*args, **kwargs)
-        if self._output:
-            out = self._converters[self._n_dispatch - 1](out)
-        return out
-
-    def __call__(self, *args, **kwargs):
-        cdef list args_
-        cdef dict kwargs_
-        args_, kwargs_ = self._parameters.bind(args, kwargs)
-        return self.prebound(args_, kwargs_)
-
-    def __repr__(self):
-        if len(self.types) == 1:
-            spec = self.types[0].__name__
-        else:
-            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
-        direct = ("" if self.direct else "in") + "direct"
-        return "".join([
-            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
-        ])
-
-
-cdef class Dispatcher:
-    """
-    Dispatcher for a data-layer operation.  This object can be called with the
-    signature shown in `self.__signature__` or `self.__text_signature__`, where
-    the arguments listed in `self.inputs` can be any data-layer types (i.e.
-    ones that have valid conversions in `data.to`).
-
-    You can define additional specialisations for this dispatcher by calling
-    its `add_specialisations` method.  New data types must be added to
-    `data.to` before they can be added as specialisations to a dispatcher.
-
-    You can get a callable object representing a single set of dispatcher types
-    by using the key-lookup syntax
-        Dispatcher[type1, type2, ...]
-    where `type1`, `type2`, etc are the dispatched arguments (with the output
-    type on the end, if this is a dispatcher over the output type.
-    """
-    cdef _bind _parameters
-    cdef readonly dict _specialisations
-    cdef Py_ssize_t _n_dispatch
-    cdef readonly dict _lookup
-    cdef set _dtypes
-    cdef bint _pass_on_dtype
-    cdef readonly tuple inputs
-    cdef readonly bint output
-    cdef public str __doc__
-    cdef public str __name__
-    cdef public str __module__
-    cdef public object __signature__
-    cdef readonly str __text_signature__
-
-    def __init__(self, signature_source, inputs, bint out=False,
-                 str name=None, str module=None):
-        """
-        Create a new data layer dispatching operator.
-
-        Parameters
-        ----------
-        signature_source : callable or inspect.Signature
-            An object from which the call signature of operation can be
-            determined.  You can pass any callable defined in Python space, and
-            the signature will be extracted.  Note that the callable will not
-            be added as a specialisation by this; you will still have to call
-            `add_specialisations`.
-
-            If you cannot provide a callable with an extractable signature
-            (e.g. Cython extension methods), you can instead directly provide
-            an instance of `inspect.Signature`, which will be used instead.
-
-        inputs : iterable of str
-            The parameters which should be dispatched over.  These can be
-            positional or keyword arguments, but must feature in the signature
-            provided.
-
-        out : bool, optional (False)
-            Whether to dispatch on the output of the function.  Defaults to
-            `False`.
-
-        name : str, optional
-            If given, the `__name__` parameter of the dispatcher is set to
-            this.  If not given and `signature_source` is _not_ an instance of
-            `inspect.Signature`, then we will attempt to read `__name__` from
-            there instead.
-
-        module : str, optional
-            If given, the `__module__` parameter of the dispatcher is set to
-            this.  If not given and `signature_source` is _not_ an instance of
-            `inspect.Signature`, then we will attempt to read `__module__` from
-            there instead.
-        """
-        if isinstance(inputs, str):
-            inputs = (inputs,)
-        inputs = tuple(inputs)
-        if inputs == () and out is False:
-            warnings.warn(
-                "No parameters to dispatch on."
-                " Maybe you meant to specify 'inputs' or 'out'?"
-            )
-        self.inputs = inputs
-        if isinstance(signature_source, inspect.Signature):
-            self.__signature__ = signature_source
-        else:
-            self.__signature__ = inspect.signature(signature_source)
-        self._parameters = _bind(self.__signature__, inputs)
-        if name is not None:
-            self.__name__ = name
-        elif not isinstance(signature_source, inspect.Signature):
-            self.__name__ = signature_source.__name__
-        else:
-            self.__name__ = 'dispatcher'
-        if module is not None:
-            self.__module__ = module
-        elif not isinstance(signature_source, inspect.Signature):
-            self.__module__ = signature_source.__module__
-        self.__text_signature__ = self.__name__ + str(self.__signature__)
-        if not isinstance(signature_source, inspect.Signature):
-            self.__doc__ = inspect.getdoc(signature_source)
-        self.output = out
-        self._specialisations = {}
-        self._lookup = {}
-        self._n_dispatch = self._parameters.n_inputs + self.output
-        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
-        # Add ourselves to the list of dispatchers to be updated.
-        _to.dispatchers.append(self)
-
-    def add_specialisations(self, specialisations, _defer=False):
-        """
-        Add specialisations for particular combinations of data types to this
-        operation.  The data types must already be known in `data.to` before
-        you try to provide them here.  All data types defined in `data.to` will
-        automatically work with this dispatcher, but will involve inefficient
-        conversions to and from other types unless you define a closer
-        specialisation using this method.
-
-        The lookup table will automatically be rebuilt after this method is
-        called.  Specialisations defined more than once will use the most
-        recent version; you can use this to override currently known
-        specialisations if desired.
-
-        Parameters
-        ----------
-        specialisations : iterable of tuples
-            An iterable where each element specifies a new specialisation for
-            this operation.  Each element of the iterable should be a tuple,
-            whose items are the types (instances of `type`) which this
-            specialisation takes in each of the slots defined by
-            `Dispatcher.inputs`, and the output type if this is a dispatcher
-            over output types.  The last element should be the callable itself.
-
-            The callable must have exactly the same signature as
-            `Dispatcher.__signature__`; it is not enough that it takes all the
-            same keyword arguments, but they must come in the same order as
-            well (this is a speed optimisation for the dispatching operation).
-
-            For example, if this is a dispatcher with the signature
-                add(left, right, scale=1)
-            which also dispatches over its output, and we have specialisations
-                add_1(left: CSR, right: Dense, scale=1) -> Dense
-                add_2(left: Dense, right: CSC, scale=1) -> CSR
-            then to add this, `specialisations` should look like
-                [
-                    (CSR, Dense, Dense, add_1),
-                    (Dense, CSC, CSR, add_2),
-                ]
-            Type annotations present in the specialisation objects are ignored.
-
-        _defer : bool, optional (False)
-            Only intended for internal library use during initialisation. If
-            `True`, then the input types are not checked, and the full lookup
-            table is not built until a manual call to
-            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
-            remember that you should add the data type conversions to `data.to`
-            before you try to add specialisations.
-        """
-        for arg in specialisations:
-            arg = tuple(arg)
-            if len(arg) != self._n_dispatch + 1:
-                raise ValueError(
-                    "specialisation " + str(arg)
-                    + " has wrong number of parameters: needed types for "
-                    + str(self._parameters.inputs)
-                    + (", an output type" if self.output else "")
-                    + " and a callable"
-                )
-            for i in range(self._n_dispatch):
-                if (not _defer) and arg[i] not in _to.dtypes:
-                    raise ValueError(str(arg[i]) + " is not a known data type")
-            if not callable(arg[self._n_dispatch]):
-                raise TypeError(str(arg[-1]) + " is not callable")
-            self._specialisations[arg[:-1]] = arg[-1]
-        if not _defer:
-            self.rebuild_lookup()
-
-    def rebuild_lookup(self):
-        """
-        Manually trigger a rebuild of the lookup table for this dispatcher.
-        This is called automatically when new data types are added to
-        `data.to`, or when specialisations are added to this object with
-        `Dispatcher.add_specialisations`.
-
-        You most likely do not need to call this function yourself.
-        """
-        cdef double weight, cur
-        cdef tuple types, out_types
-        cdef object function
-        if not self._specialisations:
-            return
-        self._dtypes = _to.dtypes.copy()
-        # The complexity of building the table here is very poor, but it's a
-        # cost we pay very infrequently, and until it's proved to be a
-        # bottle-neck in real code, we stick with the simple algorithm.
-        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
-            weight = math.INFINITY
-            types = None
-            function = None
-            for out_types, out_function in self._specialisations.items():
-                cur = _conversion_weight(in_types, out_types, _to.weight,
-                                         out=self.output)
-                if cur < weight:
-                    weight = cur
-                    types = out_types
-                    function = out_function
-            if self.output:
-                converters = tuple(
-                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
-                    + [_to[in_types[-1], types[-1]]]
-                )
-            else:
-                converters = tuple(_to[pair] for pair in zip(types, in_types))
-            self._lookup[in_types] =\
-                _constructed_specialisation(function, self, in_types,
-                                            converters, self.output,
-                                            weight == 0)
-        # Now build the lookup table in the case that we dispatch on the output
-        # type as well, but the user has called us without specifying it.
-        # TODO: option to control default output type choice if unspecified?
-        if self.output:
-            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
-                weight = math.INFINITY
-                types = None
-                function = None
-                for out_types, out_function in self._specialisations.items():
-                    cur = _conversion_weight(in_types, out_types[:-1],
-                                             _to.weight, out=False)
-                    if cur < weight:
-                        weight = cur
-                        types = out_types
-                        function = out_function
-                converters = tuple(_to[pair] for pair in zip(types, in_types))
-                self._lookup[in_types] =\
-                    _constructed_specialisation(function, self,
-                                                in_types + (types[-1],),
-                                                converters, False,
-                                                weight == 0)
-
-    def __getitem__(self, types):
-        """
-        Get the particular specialisation for the given types.  The output is a
-        callable object which requires that the dispatched arguments match
-        those specified in `types`.
-        """
-        if type(types) is not tuple:
-            types = (types,)
-        types = tuple(_to.parse(arg) for arg in types)
-        try:
-            return self._lookup[types]
-        except KeyError:
-            raise TypeError("specialisation not known for types: " + str(types)) from None
-
-    def __repr__(self):
-        return "<dispatcher: " + self.__text_signature__ + ">"
-
-    def __call__(self, *args, dtype=None, **kwargs):
-        cdef list args_, dispatch
-        cdef dict kwargs_
-        if self._pass_on_dtype:
-            kwargs['dtype'] = dtype
-        if not (self._pass_on_dtype or self.output) and dtype is not None:
-            raise TypeError("unknown argument 'dtype'")
-        args_, kwargs_ = self._parameters.bind(args, kwargs)
-        dispatch = self._parameters.dispatch_types(args_, kwargs_)
-        if self.output and dtype is not None:
-            dtype = _to.parse(dtype)
-            dispatch.append(dtype)
-        cdef _constructed_specialisation function
-        try:
-            function = self._lookup[tuple(dispatch)]
-        except KeyError:
-            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
-        return function.prebound(args_, kwargs_)
+#cython: language_level=3
+
+import functools
+import inspect
+import itertools
+import warnings
+
+from .convert import to as _to
+
+cimport cython
+from libc cimport math
+from libcpp cimport bool
+
+__all__ = ['Dispatcher']
+
+cdef class _bind:
+    """
+    Cythonised implementation of inspect.Signature.bind, supporting faster
+    binding and handling of default arguments.  On construction, the signature
+    of the base function is extracted, and all parameters are parsed into
+    positional or keyword slots, using positional wherever possible, and their
+    defaults are stored.
+    """
+    # Instance of inpsect.Signature representing the function.
+    cdef object signature
+    cdef object inputs
+    # Mapping of (str: int), where str is the name of any argument which may be
+    # specified by a keyword, and int is its location in `self._pos` if
+    # available, or -1 if it is keyword-only.
+    cdef dict _locations
+    # Default values (or inspect.Parameter.empty) for every parameter which
+    # may be passed as a positional argument.
+    cdef list _pos
+    # For each dispatcher input which can be given as a positional argument,
+    # these two lists hold the index of the input in the given tuple of input
+    # names and the corresponding index into the positional arguments after
+    # binding is complete.  {_pos_inputs_pos[n]: _pos_inputs_input[n]} is
+    # effectively the same mapping as _kw_inputs (but for positional
+    # arguments), but we use two lists rather than a dictionary for speed.
+    cdef list _pos_inputs_input, _pos_inputs_pos
+    # Default values (or inspect.Parameter.empty) for every parameter which
+    # _must_ be passed as a keyword argument.
+    cdef dict _kw
+    # Mapping of (name, index into the input tuple) for each input which must
+    # be specified as a keyword argument
+    cdef list _kw_inputs
+    # Names of the keyword arguments which have default values.
+    cdef set _default_kw_names
+    # Respectively, numbers of positional parameters, keyword-only parameters
+    # and dispatcher inputs.
+    cdef Py_ssize_t n_args, n_kwargs, n_inputs
+    # Respectively, numbers of inputs which are positional and keyword-only.
+    cdef Py_ssize_t _n_pos_inputs, _n_kw_inputs
+    # Respectively, numbers of positional arguments without a default, and
+    # number of keyword-only arguments which _have_ a default.
+    cdef Py_ssize_t _n_pos_no_default, _n_kw_default
+
+
+    def __init__(self, signature, tuple inputs):
+        for arg in inputs:
+            if arg not in signature.parameters:
+                raise AttributeError("No argument matches '{}'.".format(arg))
+        self.signature = signature
+        self.inputs = inputs
+        self._locations = {}
+        self._pos = []
+        self._pos_inputs_input = []
+        self._pos_inputs_pos = []
+        self._kw = {}
+        self._kw_inputs = []
+        self._default_kw_names = set()
+        self._n_pos_no_default = 0
+        # signature.parameters is ordered for all Python versions.
+        for i, (name, parameter) in enumerate(signature.parameters.items()):
+            kind = parameter.kind
+            if (kind == parameter.VAR_POSITIONAL
+                    or kind == parameter.VAR_KEYWORD):
+                raise TypeError("Cannot dispatch with *args or **kwargs.")
+            if kind == parameter.KEYWORD_ONLY:
+                self._kw[name] = parameter.default
+                self._locations[name] = -1
+                if parameter.default is not parameter.empty:
+                    self._default_kw_names.add(name)
+                if name in inputs:
+                    self._kw_inputs.append((name, inputs.index(name)))
+            else:
+                self._pos.append(parameter.default)
+                if kind != parameter.POSITIONAL_ONLY:
+                    self._locations[name] = i
+                if parameter.default is parameter.empty:
+                    self._n_pos_no_default += 1
+                if name in inputs:
+                    # Effectively a mapping.
+                    self._pos_inputs_input.append(inputs.index(name))
+                    self._pos_inputs_pos.append(len(self._pos) - 1)
+        self.n_args = len(self._pos)
+        self.n_kwargs = len(self._kw)
+        self.n_inputs = len(inputs)
+        self._n_pos_inputs = len(self._pos_inputs_input)
+        self._n_kw_inputs = len(self._kw_inputs)
+        self._n_kw_default = len(self._default_kw_names)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef tuple bind(self, tuple args, dict kwargs):
+        """
+        Cython reimplementation of inspect.Signature.bind for binding the
+        collected `*args` and `**kwargs` of a generic call to a specific
+        signature, checking that everything matches.
+
+        The output is a parsed tuple (args, kwargs), where `args` is a list and
+        `kwargs` is a dict, however all arguments which _can_ be passed
+        positionally will be moved from `kwargs` into `args` for the output.
+        The resultant `args` and `kwargs` can be unpacked into the underlying
+        function call safely.  Default values are not filled in by this method.
+
+        This is necessary to allow a generic `Dispatcher` class to work with
+        all type signatures.  The result of this function can be fed to
+        `_bind.convert_types` and `_bind.dispatch_types`.
+        """
+        cdef Py_ssize_t location, got_pos=0, got_kw=0
+        cdef Py_ssize_t n_passed_args = len(args)
+        if n_passed_args > self.n_args:
+            raise TypeError(
+                "Too many arguments: expected at most {} but received {}."
+                .format(n_passed_args, self.n_args)
+            )
+        # _pos and _kw are filled with their defaults at initialisation, and
+        # _pos is already the correct length (no-default parameters have
+        # sentinel values).
+        cdef list out_pos = self._pos.copy()
+        cdef dict out_kw = self._kw.copy()
+        got_pos = self.n_args - self._n_pos_no_default
+        got_kw = self._n_kw_default
+        # Positional arguments unambiguously fill the first positional slots.
+        for location in range(n_passed_args):
+            out_pos[location] = args[location]
+        # How many arguments that we didn't have defaults for did we just get?
+        # Positionals with a default are always after those without one.
+        if n_passed_args > self._n_pos_no_default:
+            got_pos += self._n_pos_no_default
+        else:
+            got_pos += n_passed_args
+        # Everything else has been passed by keyword, but it may be allowed to
+        # be passed positionally, which is the case we prefer.  dict.items() is
+        # (relatively) expensive, so we use a boolean test for the fast path.
+        cdef str kw
+        cdef object arg
+        if kwargs:
+            for kw, arg in kwargs.items():
+                try:
+                    location = self._locations[kw]
+                except KeyError:
+                    raise TypeError("Unknown argument '{}'.".format(kw)) from None
+                # _locations[kw] = -1 if kw is keyword-only, otherwise the
+                # corresponding positional location.
+                if location >= 0:
+                    if location < n_passed_args:
+                        raise TypeError("Multiple values for '{}'".format(kw))
+                    out_pos[location] = arg
+                    if location < self._n_pos_no_default:
+                        got_pos += 1
+                else:
+                    out_kw[kw] = arg
+                    if kw not in self._default_kw_names:
+                        got_kw += 1
+        if got_pos < self.n_args:
+            raise TypeError("Too few positional arguments passed.")
+        if got_kw < self.n_kwargs:
+            raise TypeError("Not all keyword arguments were filled.")
+        return out_pos, out_kw
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef list dispatch_types(self, list args, dict kwargs):
+        """
+        Get a list of the types which the dispatch should operate over, given
+        the output of `_bind.bind`.  The return value is a list of the _input_
+        types to be dispatched on, in order that they were specified at
+        `Dispatcher` creation.  The output type is not returned as part of this
+        list, because there is no way for `_bind` to know it.
+        """
+        cdef list dispatch = [None] * self.n_inputs
+        cdef str kw
+        cdef Py_ssize_t location, i
+        for location in range(self._n_pos_inputs):
+            dispatch[self._pos_inputs_input[location]]\
+                = type(args[self._pos_inputs_pos[location]])
+        for i in range(self._n_kw_inputs):
+            kw, location = self._kw_inputs[i]
+            dispatch[location] = type(kwargs[kw])
+        return dispatch
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef tuple convert_types(self, list args, dict kwargs, tuple converters):
+        """
+        Apply the type converters `converters` to the parsed arguments `args`
+        and `kwargs`.
+
+        If there are `n` inputs which are dispatched on, `converters` should be
+        a tuple whose first `n` elements are converters (such as those obtained
+        from `data.to[to_type, from_type]`) to the desired types.
+
+        `args` and `kwargs` should be the output of `_bind.bind`; the function
+        will likely fail if called on unparsed arguments.
+        """
+        cdef str kw
+        cdef Py_ssize_t location, i
+        for location in range(self._n_pos_inputs):
+            args[location] = converters[location](args[location])
+        for i in range(self._n_kw_inputs):
+            kw, location = self._kw_inputs[i]
+            kwargs[kw] = converters[location](kwargs[kw])
+        return args, kwargs
+
+
+cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out) except -1:
+    """
+    Find the total weight of conversion if the types in `froms` are converted
+    element-wise to the types in `tos`.  `weight_map` is a mapping of
+    `(to_type, from_type): real`; it should almost certainly be
+    `data.to.weight`.
+    """
+    cdef double weight = 0.0
+    cdef Py_ssize_t i, n=len(froms)
+    if len(tos) != n:
+        raise ValueError(
+            "number of arguments not equal: " + str(n) + " and " + str(len(tos))
+        )
+    if out:
+        n = n - 1
+        weight += weight_map[froms[n], tos[n]]
+    for i in range(n):
+        weight += weight_map[tos[i], froms[i]]
+    return weight
+
+
+cdef class _constructed_specialisation:
+    """
+    Callable object providing the specialisation of a data-layer operation for
+    a particular set of types (`self.types`).  This may or may not involve
+    conversion of the input types and the output to match a known
+    specialisation; if it has no conversions, `self.direct` will be `True`,
+    otherwise it will be `False`.
+
+    See `self.__signature__` or `self.__text_signature__` for the call
+    signature of this object.
+    """
+    cdef _bind _parameters
+    cdef bint _output
+    cdef object _call
+    cdef Py_ssize_t _n_dispatch
+    cdef readonly tuple types
+    cdef tuple _converters
+    cdef str _short_name
+    cdef public str __doc__
+    cdef public str __name__
+    cdef public str __module__
+    cdef public object __signature__
+    cdef readonly str __text_signature__
+    cdef readonly bint direct
+
+    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
+                 direct):
+        self.__doc__ = inspect.getdoc(dispatcher)
+        self._short_name = dispatcher.__name__
+        self.__name__ = (
+            self._short_name
+            + "_"
+            + "_".join([x.__name__ for x in types])
+        )
+        self.__module__ = dispatcher.__module__
+        self.__signature__ = dispatcher.__signature__
+        self.__text_signature__ = dispatcher.__text_signature__
+        self._parameters = dispatcher._parameters
+        self._output = out
+        self._call = base
+        self._n_dispatch = len(types)
+        self.types = types
+        self.direct = direct
+        self._converters = converters
+
+    cdef object prebound(self, list args, dict kwargs):
+        """
+        Call this specialisation with pre-parsed arguments and keyword
+        arguments.  `args` and `kwargs` must be the output of the relevant
+        `_bind.bind` method for this function.
+        """
+        self._parameters.convert_types(args, kwargs, self._converters)
+        out = self._call(*args, **kwargs)
+        if self._output:
+            out = self._converters[self._n_dispatch - 1](out)
+        return out
+
+    def __call__(self, *args, **kwargs):
+        cdef list args_
+        cdef dict kwargs_
+        args_, kwargs_ = self._parameters.bind(args, kwargs)
+        return self.prebound(args_, kwargs_)
+
+    def __repr__(self):
+        if len(self.types) == 1:
+            spec = self.types[0].__name__
+        else:
+            spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
+        direct = ("" if self.direct else "in") + "direct"
+        return "".join([
+            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
+        ])
+
+
+cdef class Dispatcher:
+    """
+    Dispatcher for a data-layer operation.  This object can be called with the
+    signature shown in `self.__signature__` or `self.__text_signature__`, where
+    the arguments listed in `self.inputs` can be any data-layer types (i.e.
+    ones that have valid conversions in `data.to`).
+
+    You can define additional specialisations for this dispatcher by calling
+    its `add_specialisations` method.  New data types must be added to
+    `data.to` before they can be added as specialisations to a dispatcher.
+
+    You can get a callable object representing a single set of dispatcher types
+    by using the key-lookup syntax
+        Dispatcher[type1, type2, ...]
+    where `type1`, `type2`, etc are the dispatched arguments (with the output
+    type on the end, if this is a dispatcher over the output type.
+    """
+    cdef _bind _parameters
+    cdef readonly dict _specialisations
+    cdef Py_ssize_t _n_dispatch
+    cdef readonly dict _lookup
+    cdef set _dtypes
+    cdef bint _pass_on_dtype
+    cdef readonly tuple inputs
+    cdef readonly bint output
+    cdef public str __doc__
+    cdef public str __name__
+    cdef public str __module__
+    cdef public object __signature__
+    cdef readonly str __text_signature__
+
+    def __init__(self, signature_source, inputs, bint out=False,
+                 str name=None, str module=None):
+        """
+        Create a new data layer dispatching operator.
+
+        Parameters
+        ----------
+        signature_source : callable or inspect.Signature
+            An object from which the call signature of operation can be
+            determined.  You can pass any callable defined in Python space, and
+            the signature will be extracted.  Note that the callable will not
+            be added as a specialisation by this; you will still have to call
+            `add_specialisations`.
+
+            If you cannot provide a callable with an extractable signature
+            (e.g. Cython extension methods), you can instead directly provide
+            an instance of `inspect.Signature`, which will be used instead.
+
+        inputs : iterable of str
+            The parameters which should be dispatched over.  These can be
+            positional or keyword arguments, but must feature in the signature
+            provided.
+
+        out : bool, optional (False)
+            Whether to dispatch on the output of the function.  Defaults to
+            `False`.
+
+        name : str, optional
+            If given, the `__name__` parameter of the dispatcher is set to
+            this.  If not given and `signature_source` is _not_ an instance of
+            `inspect.Signature`, then we will attempt to read `__name__` from
+            there instead.
+
+        module : str, optional
+            If given, the `__module__` parameter of the dispatcher is set to
+            this.  If not given and `signature_source` is _not_ an instance of
+            `inspect.Signature`, then we will attempt to read `__module__` from
+            there instead.
+        """
+        if isinstance(inputs, str):
+            inputs = (inputs,)
+        inputs = tuple(inputs)
+        if inputs == () and out is False:
+            warnings.warn(
+                "No parameters to dispatch on."
+                " Maybe you meant to specify 'inputs' or 'out'?"
+            )
+        self.inputs = inputs
+        if isinstance(signature_source, inspect.Signature):
+            self.__signature__ = signature_source
+        else:
+            self.__signature__ = inspect.signature(signature_source)
+        self._parameters = _bind(self.__signature__, inputs)
+        if name is not None:
+            self.__name__ = name
+        elif not isinstance(signature_source, inspect.Signature):
+            self.__name__ = signature_source.__name__
+        else:
+            self.__name__ = 'dispatcher'
+        if module is not None:
+            self.__module__ = module
+        elif not isinstance(signature_source, inspect.Signature):
+            self.__module__ = signature_source.__module__
+        self.__text_signature__ = self.__name__ + str(self.__signature__)
+        if not isinstance(signature_source, inspect.Signature):
+            self.__doc__ = inspect.getdoc(signature_source)
+        self.output = out
+        self._specialisations = {}
+        self._lookup = {}
+        self._n_dispatch = self._parameters.n_inputs + self.output
+        self._pass_on_dtype = 'dtype' in self.__signature__.parameters
+        # Add ourselves to the list of dispatchers to be updated.
+        _to.dispatchers.append(self)
+
+    def add_specialisations(self, specialisations, _defer=False):
+        """
+        Add specialisations for particular combinations of data types to this
+        operation.  The data types must already be known in `data.to` before
+        you try to provide them here.  All data types defined in `data.to` will
+        automatically work with this dispatcher, but will involve inefficient
+        conversions to and from other types unless you define a closer
+        specialisation using this method.
+
+        The lookup table will automatically be rebuilt after this method is
+        called.  Specialisations defined more than once will use the most
+        recent version; you can use this to override currently known
+        specialisations if desired.
+
+        Parameters
+        ----------
+        specialisations : iterable of tuples
+            An iterable where each element specifies a new specialisation for
+            this operation.  Each element of the iterable should be a tuple,
+            whose items are the types (instances of `type`) which this
+            specialisation takes in each of the slots defined by
+            `Dispatcher.inputs`, and the output type if this is a dispatcher
+            over output types.  The last element should be the callable itself.
+
+            The callable must have exactly the same signature as
+            `Dispatcher.__signature__`; it is not enough that it takes all the
+            same keyword arguments, but they must come in the same order as
+            well (this is a speed optimisation for the dispatching operation).
+
+            For example, if this is a dispatcher with the signature
+                add(left, right, scale=1)
+            which also dispatches over its output, and we have specialisations
+                add_1(left: CSR, right: Dense, scale=1) -> Dense
+                add_2(left: Dense, right: CSC, scale=1) -> CSR
+            then to add this, `specialisations` should look like
+                [
+                    (CSR, Dense, Dense, add_1),
+                    (Dense, CSC, CSR, add_2),
+                ]
+            Type annotations present in the specialisation objects are ignored.
+
+        _defer : bool, optional (False)
+            Only intended for internal library use during initialisation. If
+            `True`, then the input types are not checked, and the full lookup
+            table is not built until a manual call to
+            `Dispatcher.rebuild_lookup()` is made.  If you are getting errors,
+            remember that you should add the data type conversions to `data.to`
+            before you try to add specialisations.
+        """
+        for arg in specialisations:
+            arg = tuple(arg)
+            if len(arg) != self._n_dispatch + 1:
+                raise ValueError(
+                    "specialisation " + str(arg)
+                    + " has wrong number of parameters: needed types for "
+                    + str(self._parameters.inputs)
+                    + (", an output type" if self.output else "")
+                    + " and a callable"
+                )
+            for i in range(self._n_dispatch):
+                if (not _defer) and arg[i] not in _to.dtypes:
+                    raise ValueError(str(arg[i]) + " is not a known data type")
+            if not callable(arg[self._n_dispatch]):
+                raise TypeError(str(arg[-1]) + " is not callable")
+            self._specialisations[arg[:-1]] = arg[-1]
+        if not _defer:
+            self.rebuild_lookup()
+
+    def rebuild_lookup(self):
+        """
+        Manually trigger a rebuild of the lookup table for this dispatcher.
+        This is called automatically when new data types are added to
+        `data.to`, or when specialisations are added to this object with
+        `Dispatcher.add_specialisations`.
+
+        You most likely do not need to call this function yourself.
+        """
+        cdef double weight, cur
+        cdef tuple types, out_types
+        cdef object function
+        if not self._specialisations:
+            return
+        self._dtypes = _to.dtypes.copy()
+        # The complexity of building the table here is very poor, but it's a
+        # cost we pay very infrequently, and until it's proved to be a
+        # bottle-neck in real code, we stick with the simple algorithm.
+        for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
+            weight = math.INFINITY
+            types = None
+            function = None
+            for out_types, out_function in self._specialisations.items():
+                cur = _conversion_weight(in_types, out_types, _to.weight,
+                                         out=self.output)
+                if cur < weight:
+                    weight = cur
+                    types = out_types
+                    function = out_function
+            if self.output:
+                converters = tuple(
+                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
+                    + [_to[in_types[-1], types[-1]]]
+                )
+            else:
+                converters = tuple(_to[pair] for pair in zip(types, in_types))
+            self._lookup[in_types] =\
+                _constructed_specialisation(function, self, in_types,
+                                            converters, self.output,
+                                            weight == 0)
+        # Now build the lookup table in the case that we dispatch on the output
+        # type as well, but the user has called us without specifying it.
+        # TODO: option to control default output type choice if unspecified?
+        if self.output:
+            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
+                weight = math.INFINITY
+                types = None
+                function = None
+                for out_types, out_function in self._specialisations.items():
+                    cur = _conversion_weight(in_types, out_types[:-1],
+                                             _to.weight, out=False)
+                    if cur < weight:
+                        weight = cur
+                        types = out_types
+                        function = out_function
+                converters = tuple(_to[pair] for pair in zip(types, in_types))
+                self._lookup[in_types] =\
+                    _constructed_specialisation(function, self,
+                                                in_types + (types[-1],),
+                                                converters, False,
+                                                weight == 0)
+
+    def __getitem__(self, types):
+        """
+        Get the particular specialisation for the given types.  The output is a
+        callable object which requires that the dispatched arguments match
+        those specified in `types`.
+        """
+        if type(types) is not tuple:
+            types = (types,)
+        types = tuple(_to.parse(arg) for arg in types)
+        try:
+            return self._lookup[types]
+        except KeyError:
+            raise TypeError("specialisation not known for types: " + str(types)) from None
+
+    def __repr__(self):
+        return "<dispatcher: " + self.__text_signature__ + ">"
+
+    def __call__(self, *args, dtype=None, **kwargs):
+        cdef list args_, dispatch
+        cdef dict kwargs_
+        if self._pass_on_dtype:
+            kwargs['dtype'] = dtype
+        if not (self._pass_on_dtype or self.output) and dtype is not None:
+            raise TypeError("unknown argument 'dtype'")
+        args_, kwargs_ = self._parameters.bind(args, kwargs)
+        dispatch = self._parameters.dispatch_types(args_, kwargs_)
+        if self.output and dtype is not None:
+            dtype = _to.parse(dtype)
+            dispatch.append(dtype)
+        cdef _constructed_specialisation function
+        try:
+            function = self._lookup[tuple(dispatch)]
+        except KeyError:
+            raise TypeError("unknown types to dispatch on: " + str(dispatch)) from None
+        return function.prebound(args_, kwargs_)
diff --git a/qutip/core/data/eigen.py b/qutip/core/data/eigen.py
index f5aa6e0f3e..c860fc2003 100644
--- a/qutip/core/data/eigen.py
+++ b/qutip/core/data/eigen.py
@@ -1,454 +1,454 @@
-import numpy as np
-import scipy.linalg
-import scipy.sparse as sp
-import scipy.sparse.linalg
-from itertools import combinations
-
-from .dense import Dense, from_csr
-from .csr import CSR
-from .properties import isherm as _isherm
-from qutip.settings import settings
-
-__all__ = [
-    'eigs', 'eigs_csr', 'eigs_dense',
-    'svd', 'svd_csr', 'svd_dense',
-]
-
-
-def _orthogonalize(vec, other):
-    cross = np.sum(np.conj(other) * vec)
-    vec -= cross * other
-    norm = np.sum(np.conj(vec) * vec)**0.5
-    vec /= norm
-
-
-if settings.eigh_unsafe:
-    def eigh(mat, eigvals=None):
-        val, vec = scipy.linalg.eig(mat)
-        val = np.real(val)
-        idx = np.argsort(val)
-        val = val[idx]
-        vec = vec[:, idx]
-        if eigvals:
-            val = val[eigvals[0]:eigvals[1]+1]
-            vec = vec[:, eigvals[0]:eigvals[1]+1]
-        same_eigv = 0
-        for i in range(1, len(val)):
-            if abs(val[i] - val[i-1]) < 1e-12:
-                same_eigv += 1
-                for j in range(same_eigv):
-                    _orthogonalize(vec[:, i], vec[:, i-j-1])
-            else:
-                same_eigv = 0
-        return val, vec
-
-    def eigvalsh(a, eigvals=None):
-        val = scipy.linalg.eigvals(a)
-        val = np.sort(np.real(val))
-        if eigvals:
-            return val[eigvals[0]:eigvals[1]+1]
-        return val
-else:
-    eigh = scipy.linalg.eigh
-    eigvalsh = scipy.linalg.eigvalsh
-
-
-def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
-    """
-    Internal functions for computing eigenvalues and eigenstates for a dense
-    matrix.
-    """
-    N = data.shape[0]
-    kwargs = {}
-    if eigvals != 0 and isherm:
-        kwargs['subset_by_index'] = (
-            [0, num_small-1] if num_small else [N-num_large, N-1]
-        )
-    if vecs:
-        driver = eigh if isherm else scipy.linalg.eig
-        evals, evecs = driver(data, **kwargs)
-    else:
-        driver = eigvalsh if isherm else scipy.linalg.eigvals
-        evals = driver(data, **kwargs)
-        evecs = None
-
-    _zipped = list(zip(evals, range(len(evals))))
-    _zipped.sort()
-    evals, perm = list(zip(*_zipped))
-
-    if vecs:
-        evecs = np.array([evecs[:, k] for k in perm]).T
-
-    if not isherm and eigvals > 0:
-        if vecs:
-            if num_small > 0:
-                evals, evecs = evals[:num_small], evecs[:, :num_small]
-            elif num_large > 0:
-                evals = evals[(N - num_large):]
-                evecs = evecs[:, (N - num_large):]
-        else:
-            if num_small > 0:
-                evals = evals[:num_small]
-            elif num_large > 0:
-                evals = evals[(N - num_large):]
-    return np.array(evals), evecs
-
-
-def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
-    """
-    Internal functions for computing eigenvalues and eigenstates for a sparse
-    matrix.
-    """
-    N = data.shape[0]
-    big_vals = np.array([])
-    small_vals = np.array([])
-    evecs = None
-
-    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
-    if eigvals == (N - 1):
-        # calculate all eigenvalues and remove one at output if using sparse
-        # 1: remove the smallest, -1, remove the largest
-        remove_one = 1 if (num_small > 0) else -1
-        eigvals = 0
-        num_small = num_large = N // 2
-        num_small += N % 2
-
-    if vecs:
-        if isherm:
-            if num_large > 0:
-                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
-                                                     which='LA', tol=tol,
-                                                     maxiter=maxiter)
-            if num_small > 0:
-                small_vals, small_vecs = sp.linalg.eigsh(
-                    data, k=num_small, which='SA',
-                    tol=tol, maxiter=maxiter)
-
-        else:
-            if num_large > 0:
-                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
-                                                    which='LR', tol=tol,
-                                                    maxiter=maxiter)
-            if num_small > 0:
-                small_vals, small_vecs = sp.linalg.eigs(
-                    data, k=num_small, which='SR',
-                    tol=tol, maxiter=maxiter)
-
-        if num_large != 0 and num_small != 0:
-            evecs = np.hstack([small_vecs, big_vecs])
-        elif num_large != 0 and num_small == 0:
-            evecs = big_vecs
-        elif num_large == 0 and num_small != 0:
-            evecs = small_vecs
-    else:
-        if isherm:
-            if num_large > 0:
-                big_vals = sp.linalg.eigsh(
-                    data, k=num_large, which='LA',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-            if num_small > 0:
-                small_vals = sp.linalg.eigsh(
-                    data, k=num_small, which='SA',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-        else:
-            if num_large > 0:
-                big_vals = sp.linalg.eigs(
-                    data, k=num_large, which='LR',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-            if num_small > 0:
-                small_vals = sp.linalg.eigs(
-                    data, k=num_small, which='SR',
-                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
-
-    evals = np.hstack((small_vals, big_vals))
-    if isherm:
-        evals = np.real(evals)
-
-    _zipped = list(zip(evals, range(len(evals))))
-    _zipped.sort()
-    evals, perm = list(zip(*_zipped))
-
-    if vecs:
-        evecs = np.array([evecs[:, k] for k in perm]).T
-
-    # remove last element if requesting N-1 eigs and using sparse
-    if remove_one == 1:
-        evals = evals[:-1]
-        if vecs:
-            evecs = evecs[:, :-1]
-    elif remove_one == -1:
-        evals = evals[1:]
-        if vecs:
-            evecs = evecs[:, 1:]
-
-    return np.array(evals), evecs
-
-
-def _eigs_check_shape(data):
-    if data.shape[0] != data.shape[1]:
-        raise TypeError("Can only diagonalize square matrices")
-
-
-def _eigs_fix_eigvals(data, eigvals, sort):
-    N = data.shape[0]
-    if eigvals == N:
-        eigvals = 0
-    if eigvals > N:
-        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
-    if sort not in ('low', 'high'):
-        raise ValueError("'sort' must be 'low' or 'high'")
-
-    # set number of large and small eigenvals/vecs
-    if eigvals == 0:  # user wants all eigs (default)
-        num_small = num_large = N // 2
-        num_small += N % 2
-    else:  # if user wants only a few eigen vals/vecs
-        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
-    return eigvals, num_large, num_small
-
-
-def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
-             tol=0, maxiter=100000):
-    """
-    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
-    may take some extra keyword arguments in addition to the full documentation
-    specified in :func:`.eigs`.
-
-    This method is typically slower and less accurate than the dense eigenvalue
-    solver; you probably want that, unless memory concerns deem it impossible.
-
-    Extra keyword arguments
-    -----------------------
-    tol : float (0)
-        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
-        as 0) cause the solver to use machine precision.
-    maxiter : int (100_000)
-        Max number of iterations used by sparse eigensolver.
-    """
-    if not isinstance(data, CSR):
-        raise TypeError("expected data in CSR format but got "
-                        + str(type(data)))
-    if data.shape[0] < 4:
-        # For small matrix, the sparse solver can't compute all eigenvalues.
-        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
-    _eigs_check_shape(data)
-    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
-    isherm = isherm if isherm is not None else _isherm(data)
-    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
-                             num_large, num_small, tol, maxiter)
-
-    if vecs and isherm:
-        i = 0
-        while i < len(evals):
-            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
-            # orthogonalize vectors 1 .. k with respect to the first, then
-            # 2 .. k with respect to the second, and so on. Relies on both the
-            # order of each pair and the ordering of pairs returned by
-            # combinations.
-            for k, l in combinations(range(num_degen), 2):
-                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
-            i += num_degen
-
-    if sort == 'high':
-        # Flip arrays around.
-        if vecs:
-            evecs = np.fliplr(evecs)
-        evals = evals[::-1]
-    return (evals, Dense(evecs, copy=False)) if vecs else evals
-
-
-def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
-    """
-    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
-    keyword arguments; see the primary documentation in :func:`.eigs`.
-    """
-    if not isinstance(data, Dense):
-        raise TypeError("expected data in Dense format but got "
-                        + str(type(data)))
-    _eigs_check_shape(data)
-    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
-    isherm = isherm if isherm is not None else _isherm(data)
-    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
-                               num_large, num_small)
-    if sort == 'high':
-        # Flip arrays around.
-        if vecs:
-            evecs = np.fliplr(evecs)
-        evals = evals[::-1]
-    return (evals, Dense(evecs, copy=False)) if vecs else evals
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-
-# We use eigs_dense as the signature source, since in this case it has the
-# complete signature that we allow, so we don't need to manually set it.
-eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
-eigs.__doc__ =\
-    """
-    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
-
-    Some particular specialisations of this function may take additional
-    keyword arguments (such as the CSR solver).  See their particular
-    docstrings for details on those.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    isherm : bool, optional
-        Indicate whether the matrix is Hermitian or not.  There are special
-        Hermitian eigenvalue and -vector solvers for this case, which will take
-        care of orthonormalisation and ensuring better accuracy.  If this is
-        not specified either way, it will be calculated from the data.
-    vecs : bool, optional (True)
-        Whether the eigenvectors should be returned as well.
-    sort : {'low', 'high'}, optional
-        Sort the output of the eigenvalues and -vectors ordered by the relevant
-        size of the real part of the eigenvalue from 'low' to high or from
-        'high' to low.  If not all of the eigenvalues are requested, this
-        influences which eigenvalues will be found.
-    eigvals : int, optional
-        Number of eigenvalues and -vectors to return.  If `0`, then returns
-        all.
-
-    Returns
-    -------
-    eigenvalues : np.ndarray
-        The requested eigenvalues, sorted in the expected order.  The dtype is
-        `np.complex128`, unless `isherm=True`, in which case it will be
-        `np.float64`.
-    eigenvectors : Data
-        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
-        order of the eigenvalues.
-    """
-eigs.add_specialisations([
-    (CSR, eigs_csr),
-    (Dense, eigs_dense),
-], _defer=True)
-
-
-def svd_csr(data, vecs=True, k=6, **kw):
-    """
-    Singular Value Decomposition:
-
-    ``data = U @ S @ Vh``
-
-    Where ``S`` is diagonal.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    vecs : bool, optional (True)
-        Whether the singular vectors (``U``, ``Vh``) should be returned.
-    k : int, optional (6)
-        Number of state to compute, default is ``6`` to match scipy's default.
-    **kw : dict
-        Options to pass to ``scipy.sparse.linalg.svds``.
-
-    Returns
-    -------
-    U : Dense
-        Left singular vectors as columns. Only returned if ``vecs == True``.
-        shape = (data.shape[0], k)
-    S : np.ndarray
-        The ``k``'s largest singular values.
-    Vh : Dense
-        Right singular vectors as rows. Only returned if ``vecs == True``.
-        shape = (k, data.shape[1])
-
-    .. note::
-        svds cannot compute all states at once. While it could find the
-        largest and smallest in 2 calls, it has issues converging with when
-        solving for the smallest (finding the 5 smallest in a 50x50 matrix
-        can fail with default options). It should be used when not all states
-        are needed.
-    """
-    out = scipy.sparse.linalg.svds(
-        data.as_scipy(), k, return_singular_vectors=vecs, **kw
-    )
-    if vecs:
-        u, s, vh = out
-        return Dense(u, copy=False), s, Dense(vh, copy=False)
-    return out
-
-
-def svd_dense(data, vecs=True, **kw):
-    """
-    Singular Value Decomposition:
-
-    ``data = U @ S @ Vh``
-
-    Where ``S`` is diagonal.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    vecs : bool, optional (True)
-        Whether the singular vectors (``U``, ``Vh``) should be returned.
-    **kw : dict
-        Options to pass to ``scipy.linalg.svd``.
-
-    Returns
-    -------
-    U : Dense
-        Left singular vectors as columns. Only returned if ``vecs == True``.
-    S : np.ndarray
-        Singular values.
-    Vh : Dense
-        Right singular vectors as rows. Only returned if ``vecs == True``.
-    """
-    out = scipy.linalg.svd(
-        data.to_array(), compute_uv=vecs, **kw
-    )
-    if vecs:
-        u, s, vh = out
-        return Dense(u, copy=False), s, Dense(vh, copy=False)
-    return out
-
-
-svd = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='svd',
-    module=__name__,
-    inputs=('data',),
-    out=False)
-svd.__doc__ =\
-    """
-    Singular Value Decomposition:
-
-    ``data = U @ S @ Vh``
-
-    Where ``S`` is diagonal.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-    vecs : bool, optional (True)
-        Whether the singular vectors (``U``, ``Vh``) should be returned.
-
-    Returns
-    -------
-    U : Dense
-        Left singular vectors as columns. Only returned if ``vecs == True``.
-    S : np.ndarray
-        Singular values.
-    Vh : Dense
-        Right singular vectors as rows. Only returned if ``vecs == True``.
-    """
-# Dense implementation return all states, but sparse implementation compute
-# only a few states. So only the dense version is registered.
-svd.add_specialisations([
-    (Dense, svd_dense),
-], _defer=True)
-
-
-del _Dispatcher
-del _inspect
+import numpy as np
+import scipy.linalg
+import scipy.sparse as sp
+import scipy.sparse.linalg
+from itertools import combinations
+
+from .dense import Dense, from_csr
+from .csr import CSR
+from .properties import isherm as _isherm
+from qutip.settings import settings
+
+__all__ = [
+    'eigs', 'eigs_csr', 'eigs_dense',
+    'svd', 'svd_csr', 'svd_dense',
+]
+
+
+def _orthogonalize(vec, other):
+    cross = np.sum(np.conj(other) * vec)
+    vec -= cross * other
+    norm = np.sum(np.conj(vec) * vec)**0.5
+    vec /= norm
+
+
+if settings.eigh_unsafe:
+    def eigh(mat, eigvals=None):
+        val, vec = scipy.linalg.eig(mat)
+        val = np.real(val)
+        idx = np.argsort(val)
+        val = val[idx]
+        vec = vec[:, idx]
+        if eigvals:
+            val = val[eigvals[0]:eigvals[1]+1]
+            vec = vec[:, eigvals[0]:eigvals[1]+1]
+        same_eigv = 0
+        for i in range(1, len(val)):
+            if abs(val[i] - val[i-1]) < 1e-12:
+                same_eigv += 1
+                for j in range(same_eigv):
+                    _orthogonalize(vec[:, i], vec[:, i-j-1])
+            else:
+                same_eigv = 0
+        return val, vec
+
+    def eigvalsh(a, eigvals=None):
+        val = scipy.linalg.eigvals(a)
+        val = np.sort(np.real(val))
+        if eigvals:
+            return val[eigvals[0]:eigvals[1]+1]
+        return val
+else:
+    eigh = scipy.linalg.eigh
+    eigvalsh = scipy.linalg.eigvalsh
+
+
+def _eigs_dense(data, isherm, vecs, eigvals, num_large, num_small):
+    """
+    Internal functions for computing eigenvalues and eigenstates for a dense
+    matrix.
+    """
+    N = data.shape[0]
+    kwargs = {}
+    if eigvals != 0 and isherm:
+        kwargs['subset_by_index'] = (
+            [0, num_small-1] if num_small else [N-num_large, N-1]
+        )
+    if vecs:
+        driver = eigh if isherm else scipy.linalg.eig
+        evals, evecs = driver(data, **kwargs)
+    else:
+        driver = eigvalsh if isherm else scipy.linalg.eigvals
+        evals = driver(data, **kwargs)
+        evecs = None
+
+    _zipped = list(zip(evals, range(len(evals))))
+    _zipped.sort()
+    evals, perm = list(zip(*_zipped))
+
+    if vecs:
+        evecs = np.array([evecs[:, k] for k in perm]).T
+
+    if not isherm and eigvals > 0:
+        if vecs:
+            if num_small > 0:
+                evals, evecs = evals[:num_small], evecs[:, :num_small]
+            elif num_large > 0:
+                evals = evals[(N - num_large):]
+                evecs = evecs[:, (N - num_large):]
+        else:
+            if num_small > 0:
+                evals = evals[:num_small]
+            elif num_large > 0:
+                evals = evals[(N - num_large):]
+    return np.array(evals), evecs
+
+
+def _eigs_csr(data, isherm, vecs, eigvals, num_large, num_small, tol, maxiter):
+    """
+    Internal functions for computing eigenvalues and eigenstates for a sparse
+    matrix.
+    """
+    N = data.shape[0]
+    big_vals = np.array([])
+    small_vals = np.array([])
+    evecs = None
+
+    remove_one = 0  # 0: remove none, 1: remove smallest, -1: remove largest
+    if eigvals == (N - 1):
+        # calculate all eigenvalues and remove one at output if using sparse
+        # 1: remove the smallest, -1, remove the largest
+        remove_one = 1 if (num_small > 0) else -1
+        eigvals = 0
+        num_small = num_large = N // 2
+        num_small += N % 2
+
+    if vecs:
+        if isherm:
+            if num_large > 0:
+                big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,
+                                                     which='LA', tol=tol,
+                                                     maxiter=maxiter)
+            if num_small > 0:
+                small_vals, small_vecs = sp.linalg.eigsh(
+                    data, k=num_small, which='SA',
+                    tol=tol, maxiter=maxiter)
+
+        else:
+            if num_large > 0:
+                big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,
+                                                    which='LR', tol=tol,
+                                                    maxiter=maxiter)
+            if num_small > 0:
+                small_vals, small_vecs = sp.linalg.eigs(
+                    data, k=num_small, which='SR',
+                    tol=tol, maxiter=maxiter)
+
+        if num_large != 0 and num_small != 0:
+            evecs = np.hstack([small_vecs, big_vecs])
+        elif num_large != 0 and num_small == 0:
+            evecs = big_vecs
+        elif num_large == 0 and num_small != 0:
+            evecs = small_vecs
+    else:
+        if isherm:
+            if num_large > 0:
+                big_vals = sp.linalg.eigsh(
+                    data, k=num_large, which='LA',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+            if num_small > 0:
+                small_vals = sp.linalg.eigsh(
+                    data, k=num_small, which='SA',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+        else:
+            if num_large > 0:
+                big_vals = sp.linalg.eigs(
+                    data, k=num_large, which='LR',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+            if num_small > 0:
+                small_vals = sp.linalg.eigs(
+                    data, k=num_small, which='SR',
+                    return_eigenvectors=False, tol=tol, maxiter=maxiter)
+
+    evals = np.hstack((small_vals, big_vals))
+    if isherm:
+        evals = np.real(evals)
+
+    _zipped = list(zip(evals, range(len(evals))))
+    _zipped.sort()
+    evals, perm = list(zip(*_zipped))
+
+    if vecs:
+        evecs = np.array([evecs[:, k] for k in perm]).T
+
+    # remove last element if requesting N-1 eigs and using sparse
+    if remove_one == 1:
+        evals = evals[:-1]
+        if vecs:
+            evecs = evecs[:, :-1]
+    elif remove_one == -1:
+        evals = evals[1:]
+        if vecs:
+            evecs = evecs[:, 1:]
+
+    return np.array(evals), evecs
+
+
+def _eigs_check_shape(data):
+    if data.shape[0] != data.shape[1]:
+        raise TypeError("Can only diagonalize square matrices")
+
+
+def _eigs_fix_eigvals(data, eigvals, sort):
+    N = data.shape[0]
+    if eigvals == N:
+        eigvals = 0
+    if eigvals > N:
+        raise ValueError("Number of requested eigen vals/vecs must be <= N.")
+    if sort not in ('low', 'high'):
+        raise ValueError("'sort' must be 'low' or 'high'")
+
+    # set number of large and small eigenvals/vecs
+    if eigvals == 0:  # user wants all eigs (default)
+        num_small = num_large = N // 2
+        num_small += N % 2
+    else:  # if user wants only a few eigen vals/vecs
+        num_small, num_large = (eigvals, 0) if sort == 'low' else (0, eigvals)
+    return eigvals, num_large, num_small
+
+
+def eigs_csr(data, isherm=None, vecs=True, sort='low', eigvals=0,
+             tol=0, maxiter=100000):
+    """
+    Return eigenvalues and eigenvectors for a CSR matrix.  This specialisation
+    may take some extra keyword arguments in addition to the full documentation
+    specified in :func:`.eigs`.
+
+    This method is typically slower and less accurate than the dense eigenvalue
+    solver; you probably want that, unless memory concerns deem it impossible.
+
+    Extra keyword arguments
+    -----------------------
+    tol : float (0)
+        Tolerance for sparse eigensolver.  Sufficiently small tolerances (such
+        as 0) cause the solver to use machine precision.
+    maxiter : int (100_000)
+        Max number of iterations used by sparse eigensolver.
+    """
+    if not isinstance(data, CSR):
+        raise TypeError("expected data in CSR format but got "
+                        + str(type(data)))
+    if data.shape[0] < 4:
+        # For small matrix, the sparse solver can't compute all eigenvalues.
+        return eigs_dense(from_csr(data), isherm, vecs, sort, eigvals)
+    _eigs_check_shape(data)
+    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
+    isherm = isherm if isherm is not None else _isherm(data)
+    evals, evecs = _eigs_csr(data.as_scipy(), isherm, vecs, eigvals,
+                             num_large, num_small, tol, maxiter)
+
+    if vecs and isherm:
+        i = 0
+        while i < len(evals):
+            num_degen = np.sum(np.abs(evals - evals[i]) < (2 * tol or 1e-14))
+            # orthogonalize vectors 1 .. k with respect to the first, then
+            # 2 .. k with respect to the second, and so on. Relies on both the
+            # order of each pair and the ordering of pairs returned by
+            # combinations.
+            for k, l in combinations(range(num_degen), 2):
+                _orthogonalize(evecs[:, i+l], evecs[:, i+k])
+            i += num_degen
+
+    if sort == 'high':
+        # Flip arrays around.
+        if vecs:
+            evecs = np.fliplr(evecs)
+        evals = evals[::-1]
+    return (evals, Dense(evecs, copy=False)) if vecs else evals
+
+
+def eigs_dense(data, isherm=None, vecs=True, sort='low', eigvals=0):
+    """
+    Return eigenvalues and eigenvectors for a Dense matrix.  Takes no special
+    keyword arguments; see the primary documentation in :func:`.eigs`.
+    """
+    if not isinstance(data, Dense):
+        raise TypeError("expected data in Dense format but got "
+                        + str(type(data)))
+    _eigs_check_shape(data)
+    eigvals, num_large, num_small = _eigs_fix_eigvals(data, eigvals, sort)
+    isherm = isherm if isherm is not None else _isherm(data)
+    evals, evecs = _eigs_dense(data.as_ndarray(), isherm, vecs, eigvals,
+                               num_large, num_small)
+    if sort == 'high':
+        # Flip arrays around.
+        if vecs:
+            evecs = np.fliplr(evecs)
+        evals = evals[::-1]
+    return (evals, Dense(evecs, copy=False)) if vecs else evals
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+# We use eigs_dense as the signature source, since in this case it has the
+# complete signature that we allow, so we don't need to manually set it.
+eigs = _Dispatcher(eigs_dense, name='eigs', inputs=('data',), out=False)
+eigs.__doc__ =\
+    """
+    Return eigenvalues and (optionally) eigenvectors for a data-layer object.
+
+    Some particular specialisations of this function may take additional
+    keyword arguments (such as the CSR solver).  See their particular
+    docstrings for details on those.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    isherm : bool, optional
+        Indicate whether the matrix is Hermitian or not.  There are special
+        Hermitian eigenvalue and -vector solvers for this case, which will take
+        care of orthonormalisation and ensuring better accuracy.  If this is
+        not specified either way, it will be calculated from the data.
+    vecs : bool, optional (True)
+        Whether the eigenvectors should be returned as well.
+    sort : {'low', 'high'}, optional
+        Sort the output of the eigenvalues and -vectors ordered by the relevant
+        size of the real part of the eigenvalue from 'low' to high or from
+        'high' to low.  If not all of the eigenvalues are requested, this
+        influences which eigenvalues will be found.
+    eigvals : int, optional
+        Number of eigenvalues and -vectors to return.  If `0`, then returns
+        all.
+
+    Returns
+    -------
+    eigenvalues : np.ndarray
+        The requested eigenvalues, sorted in the expected order.  The dtype is
+        `np.complex128`, unless `isherm=True`, in which case it will be
+        `np.float64`.
+    eigenvectors : Data
+        Only if `vecs=True`.  An array of the eigenvectors corresponding to the
+        order of the eigenvalues.
+    """
+eigs.add_specialisations([
+    (CSR, eigs_csr),
+    (Dense, eigs_dense),
+], _defer=True)
+
+
+def svd_csr(data, vecs=True, k=6, **kw):
+    """
+    Singular Value Decomposition:
+
+    ``data = U @ S @ Vh``
+
+    Where ``S`` is diagonal.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    vecs : bool, optional (True)
+        Whether the singular vectors (``U``, ``Vh``) should be returned.
+    k : int, optional (6)
+        Number of state to compute, default is ``6`` to match scipy's default.
+    **kw : dict
+        Options to pass to ``scipy.sparse.linalg.svds``.
+
+    Returns
+    -------
+    U : Dense
+        Left singular vectors as columns. Only returned if ``vecs == True``.
+        shape = (data.shape[0], k)
+    S : np.ndarray
+        The ``k``'s largest singular values.
+    Vh : Dense
+        Right singular vectors as rows. Only returned if ``vecs == True``.
+        shape = (k, data.shape[1])
+
+    .. note::
+        svds cannot compute all states at once. While it could find the
+        largest and smallest in 2 calls, it has issues converging with when
+        solving for the smallest (finding the 5 smallest in a 50x50 matrix
+        can fail with default options). It should be used when not all states
+        are needed.
+    """
+    out = scipy.sparse.linalg.svds(
+        data.as_scipy(), k, return_singular_vectors=vecs, **kw
+    )
+    if vecs:
+        u, s, vh = out
+        return Dense(u, copy=False), s, Dense(vh, copy=False)
+    return out
+
+
+def svd_dense(data, vecs=True, **kw):
+    """
+    Singular Value Decomposition:
+
+    ``data = U @ S @ Vh``
+
+    Where ``S`` is diagonal.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    vecs : bool, optional (True)
+        Whether the singular vectors (``U``, ``Vh``) should be returned.
+    **kw : dict
+        Options to pass to ``scipy.linalg.svd``.
+
+    Returns
+    -------
+    U : Dense
+        Left singular vectors as columns. Only returned if ``vecs == True``.
+    S : np.ndarray
+        Singular values.
+    Vh : Dense
+        Right singular vectors as rows. Only returned if ``vecs == True``.
+    """
+    out = scipy.linalg.svd(
+        data.to_array(), compute_uv=vecs, **kw
+    )
+    if vecs:
+        u, s, vh = out
+        return Dense(u, copy=False), s, Dense(vh, copy=False)
+    return out
+
+
+svd = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('data', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('vecs', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='svd',
+    module=__name__,
+    inputs=('data',),
+    out=False)
+svd.__doc__ =\
+    """
+    Singular Value Decomposition:
+
+    ``data = U @ S @ Vh``
+
+    Where ``S`` is diagonal.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+    vecs : bool, optional (True)
+        Whether the singular vectors (``U``, ``Vh``) should be returned.
+
+    Returns
+    -------
+    U : Dense
+        Left singular vectors as columns. Only returned if ``vecs == True``.
+    S : np.ndarray
+        Singular values.
+    Vh : Dense
+        Right singular vectors as rows. Only returned if ``vecs == True``.
+    """
+# Dense implementation return all states, but sparse implementation compute
+# only a few states. So only the dense version is registered.
+svd.add_specialisations([
+    (Dense, svd_dense),
+], _defer=True)
+
+
+del _Dispatcher
+del _inspect
diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
index da6ab98754..4e7d2af104 100644
--- a/qutip/core/data/expect.pxd
+++ b/qutip/core/data/expect.pxd
@@ -1,16 +1,16 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data cimport CSR, Dense, Data
-
-cpdef double complex expect_csr(CSR op, CSR state) nogil except *
-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
-
-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
-
-cpdef double complex expect_dense(Dense op, Dense state) nogil except *
-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
-
-cdef double complex expect_data_dense(Data op, Dense state) except *
-cdef double complex expect_super_data_dense(Data op, Dense state) except *
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data cimport CSR, Dense, Data
+
+cpdef double complex expect_csr(CSR op, CSR state) nogil except *
+cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
+
+cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
+cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
+
+cpdef double complex expect_dense(Dense op, Dense state) nogil except *
+cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
+
+cdef double complex expect_data_dense(Data op, Dense state) except *
+cdef double complex expect_super_data_dense(Data op, Dense state) except *
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 72903acb08..9b2089943e 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -1,325 +1,325 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-# The exported function `expect(op, state)` is equivalent to
-# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
-# `trace(op @ state)` if state is a density matrix, but it's optimised to not
-# make unnecessary extra allocations, or calculate extra factors.
-
-from libc.math cimport sqrt
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data cimport csr, CSR, Dense
-
-__all__ = [
-    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
-    'expect_super', 'expect_super_csr',
-    'expect_super_csr_dense', 'expect_super_dense',
-]
-
-cdef void _check_shape_ket(Data op, Data state) nogil except *:
-    if (
-        op.shape[1] != state.shape[0]  # Matrix multiplication
-        or state.shape[1] != 1  # State is ket
-        or op.shape[0] != op.shape[1]  # op must be square matrix
-    ):
-        raise ValueError("incorrect input shapes "
-                         + str(op.shape) + " and " + str(state.shape))
-
-cdef void _check_shape_dm(Data op, Data state) nogil except *:
-    if (
-        op.shape[1] != state.shape[0]  # Matrix multiplication
-        or state.shape[0] != state.shape[1]  # State is square 
-        or op.shape[0] != op.shape[1]  # Op is square
-    ):
-        raise ValueError("incorrect input shapes "
-                         + str(op.shape) + " and " + str(state.shape))
-
-cdef void _check_shape_super(Data op, Data state) nogil except *:
-    if state.shape[1] != 1:
-        raise ValueError("expected a column-stacked matrix")
-    if (
-        op.shape[1] != state.shape[0]  # Matrix multiplication
-        or op.shape[0] != op.shape[1]  # Square matrix
-    ):
-        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
-
-
-cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
-    """
-    Perform the operation
-        state.adjoint() @ op @ state
-    for a ket `state` and a square operator `op`.
-    """
-    _check_shape_ket(op, state)
-    cdef double complex out=0, sum=0, mul
-    cdef size_t row, col, ptr_op, ptr_ket
-    for row in range(state.shape[0]):
-        ptr_ket = state.row_index[row]
-        if ptr_ket == state.row_index[row + 1]:
-            continue
-        sum = 0
-        mul = conj(state.data[ptr_ket])
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            ptr_ket = state.row_index[col]
-            if ptr_ket != state.row_index[col + 1]:
-                sum += op.data[ptr_op] * state.data[ptr_ket]
-        out += mul * sum
-    return out
-
-cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
-    """
-    Perform the operation
-        tr(op @ state)
-    for an operator `op` and a density matrix `state`.
-    """
-    _check_shape_dm(op, state)
-    cdef double complex out=0
-    cdef size_t row, col, ptr_op, ptr_state
-    for row in range(op.shape[0]):
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
-                if state.col_index[ptr_state] == row:
-                    out += op.data[ptr_op] * state.data[ptr_state]
-                    break
-    return out
-
-
-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.
-    """
-    _check_shape_super(op, state)
-    cdef double complex out = 0.0
-    cdef size_t row=0, ptr, col
-    cdef size_t n = <size_t> sqrt(state.shape[0])
-    for _ in range(n):
-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr]
-            if state.row_index[col] != state.row_index[col + 1]:
-                out += op.data[ptr] * state.data[state.row_index[col]]
-        row += n + 1
-    return out
-
-
-cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-    if state.shape[1] == 1:
-        return _expect_csr_ket(op, state)
-    return _expect_csr_dm(op, state)
-
-cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
-    _check_shape_ket(op, state)
-    cdef double complex out=0, sum
-    cdef size_t row, ptr
-    for row in range(op.shape[0]):
-        if op.row_index[row] == op.row_index[row + 1]:
-            continue
-        sum = 0
-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-            sum += op.data[ptr] * state.data[op.col_index[ptr]]
-        out += sum * conj(state.data[row])
-    return out
-
-cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
-    _check_shape_dm(op, state)
-    cdef double complex out=0
-    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
-    row_stride = 1 if state.fortran else state.shape[1]
-    col_stride = state.shape[0] if state.fortran else 1
-    for row in range(op.shape[0]):
-        if op.row_index[row] == op.row_index[row + 1]:
-            continue
-        ptr_state = row * col_stride
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
-    return out
-
-
-cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
-    _check_shape_ket(op, state)
-    cdef double complex out=0, sum
-    cdef size_t row, col, op_row_stride, op_col_stride
-    op_row_stride = 1 if op.fortran else op.shape[1]
-    op_col_stride = op.shape[0] if op.fortran else 1
-
-    for row in range(op.shape[0]):
-        sum = 0
-        for col in range(op.shape[0]):
-            sum += (op.data[row * op_row_stride + col * op_col_stride] *
-                    state.data[col])
-        out += sum * conj(state.data[row])
-    return out
-
-cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
-    _check_shape_dm(op, state)
-    cdef double complex out=0
-    cdef size_t row, col, op_row_stride, op_col_stride
-    cdef size_t state_row_stride, state_col_stride
-    state_row_stride = 1 if state.fortran else state.shape[1]
-    state_col_stride = state.shape[0] if state.fortran else 1
-    op_row_stride = 1 if op.fortran else op.shape[1]
-    op_col_stride = op.shape[0] if op.fortran else 1
-
-    for row in range(op.shape[0]):
-        for col in range(op.shape[1]):
-            out += op.data[row * op_row_stride + col * op_col_stride] * \
-                   state.data[col * state_row_stride + row * state_col_stride]
-    return out
-
-
-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-    if state.shape[1] == 1:
-        return _expect_csr_dense_ket(op, state)
-    return _expect_csr_dense_dm(op, state)
-
-
-cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-    if state.shape[1] == 1:
-        return _expect_dense_ket(op, state)
-    return _expect_dense_dense_dm(op, state)
-
-
-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.
-    """
-    _check_shape_super(op, state)
-    cdef double complex out=0
-    cdef size_t row=0, ptr
-    cdef size_t n = <size_t> sqrt(state.shape[0])
-    for _ in range(n):
-        for ptr in range(op.row_index[row], op.row_index[row + 1]):
-            out += op.data[ptr] * state.data[op.col_index[ptr]]
-        row += n + 1
-    return out
-
-
-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.
-    """
-    _check_shape_super(op, state)
-    cdef double complex out=0
-    cdef size_t row=0, col, N = state.shape[0]
-    cdef size_t n = <size_t> sqrt(state.shape[0])
-    cdef size_t op_row_stride, op_col_stride
-    op_row_stride = 1 if op.fortran else op.shape[1]
-    op_col_stride = op.shape[0] if op.fortran else 1
-
-    for _ in range(n):
-        for col in range(N):
-            out += op.data[row * op_row_stride + col * op_col_stride] * \
-                   state.data[col]
-        row += n + 1
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-expect = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='expect',
-    module=__name__,
-    inputs=('op', 'state'),
-    out=False,
-)
-expect.__doc__ =\
-    """
-    Get the expectation value of the operator `op` over the state `state`.  The
-    state can be either a ket or a density matrix.  Returns a complex number.
-
-    The expectation of a state is defined as the operation:
-        state.adjoint() @ op @ state
-    and of a density matrix:
-        tr(op @ state)
-    """
-expect.add_specialisations([
-    (CSR, CSR, expect_csr),
-    (CSR, Dense, expect_csr_dense),
-    (Dense, Dense, expect_dense),
-], _defer=True)
-
-expect_super = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='expect_super',
-    module=__name__,
-    inputs=('op', 'state'),
-    out=False,
-)
-expect_super.__doc__ =\
-    """
-    Perform the operation `tr(op @ state)` where `op` is supplied as a
-    superoperator, and `state` is a column-stacked operator.  Returns a complex
-    number.
-    """
-expect_super.add_specialisations([
-    (CSR, CSR, expect_super_csr),
-    (CSR, Dense, expect_super_csr_dense),
-    (Dense, Dense, expect_super_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
-
-
-cdef double complex expect_data_dense(Data op, Dense state) except *:
-    cdef double complex out
-    if type(op) is CSR:
-        out = expect_csr_dense(op, state)
-    elif type(op) is Dense:
-        out = expect_dense(op, state)
-    else:
-        out = expect(op, state)
-    return out
-
-
-cdef double complex expect_super_data_dense(Data op, Dense state) except *:
-    cdef double complex out
-    if type(op) is CSR:
-        out = expect_super_csr_dense(op, state)
-    elif type(op) is Dense:
-        out = expect_super_dense(op, state)
-    else:
-        out = expect_super(op, state)
-    return out
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+# The exported function `expect(op, state)` is equivalent to
+# `inner_op(state.adjoint(), op, state)` if `state` is a ket, or
+# `trace(op @ state)` if state is a density matrix, but it's optimised to not
+# make unnecessary extra allocations, or calculate extra factors.
+
+from libc.math cimport sqrt
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data cimport csr, CSR, Dense
+
+__all__ = [
+    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
+    'expect_super', 'expect_super_csr',
+    'expect_super_csr_dense', 'expect_super_dense',
+]
+
+cdef void _check_shape_ket(Data op, Data state) nogil except *:
+    if (
+        op.shape[1] != state.shape[0]  # Matrix multiplication
+        or state.shape[1] != 1  # State is ket
+        or op.shape[0] != op.shape[1]  # op must be square matrix
+    ):
+        raise ValueError("incorrect input shapes "
+                         + str(op.shape) + " and " + str(state.shape))
+
+cdef void _check_shape_dm(Data op, Data state) nogil except *:
+    if (
+        op.shape[1] != state.shape[0]  # Matrix multiplication
+        or state.shape[0] != state.shape[1]  # State is square 
+        or op.shape[0] != op.shape[1]  # Op is square
+    ):
+        raise ValueError("incorrect input shapes "
+                         + str(op.shape) + " and " + str(state.shape))
+
+cdef void _check_shape_super(Data op, Data state) nogil except *:
+    if state.shape[1] != 1:
+        raise ValueError("expected a column-stacked matrix")
+    if (
+        op.shape[1] != state.shape[0]  # Matrix multiplication
+        or op.shape[0] != op.shape[1]  # Square matrix
+    ):
+        raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
+
+
+cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
+    """
+    Perform the operation
+        state.adjoint() @ op @ state
+    for a ket `state` and a square operator `op`.
+    """
+    _check_shape_ket(op, state)
+    cdef double complex out=0, sum=0, mul
+    cdef size_t row, col, ptr_op, ptr_ket
+    for row in range(state.shape[0]):
+        ptr_ket = state.row_index[row]
+        if ptr_ket == state.row_index[row + 1]:
+            continue
+        sum = 0
+        mul = conj(state.data[ptr_ket])
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            ptr_ket = state.row_index[col]
+            if ptr_ket != state.row_index[col + 1]:
+                sum += op.data[ptr_op] * state.data[ptr_ket]
+        out += mul * sum
+    return out
+
+cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
+    """
+    Perform the operation
+        tr(op @ state)
+    for an operator `op` and a density matrix `state`.
+    """
+    _check_shape_dm(op, state)
+    cdef double complex out=0
+    cdef size_t row, col, ptr_op, ptr_state
+    for row in range(op.shape[0]):
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            for ptr_state in range(state.row_index[col], state.row_index[col + 1]):
+                if state.col_index[ptr_state] == row:
+                    out += op.data[ptr_op] * state.data[ptr_state]
+                    break
+    return out
+
+
+cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    cdef double complex out = 0.0
+    cdef size_t row=0, ptr, col
+    cdef size_t n = <size_t> sqrt(state.shape[0])
+    for _ in range(n):
+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr]
+            if state.row_index[col] != state.row_index[col + 1]:
+                out += op.data[ptr] * state.data[state.row_index[col]]
+        row += n + 1
+    return out
+
+
+cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        return _expect_csr_ket(op, state)
+    return _expect_csr_dm(op, state)
+
+cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
+    _check_shape_ket(op, state)
+    cdef double complex out=0, sum
+    cdef size_t row, ptr
+    for row in range(op.shape[0]):
+        if op.row_index[row] == op.row_index[row + 1]:
+            continue
+        sum = 0
+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+            sum += op.data[ptr] * state.data[op.col_index[ptr]]
+        out += sum * conj(state.data[row])
+    return out
+
+cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
+    _check_shape_dm(op, state)
+    cdef double complex out=0
+    cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
+    row_stride = 1 if state.fortran else state.shape[1]
+    col_stride = state.shape[0] if state.fortran else 1
+    for row in range(op.shape[0]):
+        if op.row_index[row] == op.row_index[row + 1]:
+            continue
+        ptr_state = row * col_stride
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            out += op.data[ptr_op] * state.data[ptr_state + row_stride*op.col_index[ptr_op]]
+    return out
+
+
+cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
+    _check_shape_ket(op, state)
+    cdef double complex out=0, sum
+    cdef size_t row, col, op_row_stride, op_col_stride
+    op_row_stride = 1 if op.fortran else op.shape[1]
+    op_col_stride = op.shape[0] if op.fortran else 1
+
+    for row in range(op.shape[0]):
+        sum = 0
+        for col in range(op.shape[0]):
+            sum += (op.data[row * op_row_stride + col * op_col_stride] *
+                    state.data[col])
+        out += sum * conj(state.data[row])
+    return out
+
+cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
+    _check_shape_dm(op, state)
+    cdef double complex out=0
+    cdef size_t row, col, op_row_stride, op_col_stride
+    cdef size_t state_row_stride, state_col_stride
+    state_row_stride = 1 if state.fortran else state.shape[1]
+    state_col_stride = state.shape[0] if state.fortran else 1
+    op_row_stride = 1 if op.fortran else op.shape[1]
+    op_col_stride = op.shape[0] if op.fortran else 1
+
+    for row in range(op.shape[0]):
+        for col in range(op.shape[1]):
+            out += op.data[row * op_row_stride + col * op_col_stride] * \
+                   state.data[col * state_row_stride + row * state_col_stride]
+    return out
+
+
+cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        return _expect_csr_dense_ket(op, state)
+    return _expect_csr_dense_dm(op, state)
+
+
+cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        return _expect_dense_ket(op, state)
+    return _expect_dense_dense_dm(op, state)
+
+
+cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    cdef double complex out=0
+    cdef size_t row=0, ptr
+    cdef size_t n = <size_t> sqrt(state.shape[0])
+    for _ in range(n):
+        for ptr in range(op.row_index[row], op.row_index[row + 1]):
+            out += op.data[ptr] * state.data[op.col_index[ptr]]
+        row += n + 1
+    return out
+
+
+cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    cdef double complex out=0
+    cdef size_t row=0, col, N = state.shape[0]
+    cdef size_t n = <size_t> sqrt(state.shape[0])
+    cdef size_t op_row_stride, op_col_stride
+    op_row_stride = 1 if op.fortran else op.shape[1]
+    op_col_stride = op.shape[0] if op.fortran else 1
+
+    for _ in range(n):
+        for col in range(N):
+            out += op.data[row * op_row_stride + col * op_col_stride] * \
+                   state.data[col]
+        row += n + 1
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+expect = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='expect',
+    module=__name__,
+    inputs=('op', 'state'),
+    out=False,
+)
+expect.__doc__ =\
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.  Returns a complex number.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+expect.add_specialisations([
+    (CSR, CSR, expect_csr),
+    (CSR, Dense, expect_csr_dense),
+    (Dense, Dense, expect_dense),
+], _defer=True)
+
+expect_super = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='expect_super',
+    module=__name__,
+    inputs=('op', 'state'),
+    out=False,
+)
+expect_super.__doc__ =\
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.  Returns a complex
+    number.
+    """
+expect_super.add_specialisations([
+    (CSR, CSR, expect_super_csr),
+    (CSR, Dense, expect_super_csr_dense),
+    (Dense, Dense, expect_super_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
+
+
+cdef double complex expect_data_dense(Data op, Dense state) except *:
+    cdef double complex out
+    if type(op) is CSR:
+        out = expect_csr_dense(op, state)
+    elif type(op) is Dense:
+        out = expect_dense(op, state)
+    else:
+        out = expect(op, state)
+    return out
+
+
+cdef double complex expect_super_data_dense(Data op, Dense state) except *:
+    cdef double complex out
+    if type(op) is CSR:
+        out = expect_super_csr_dense(op, state)
+    elif type(op) is Dense:
+        out = expect_super_dense(op, state)
+    else:
+        out = expect_super(op, state)
+    return out
diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index 5d3bfc615f..27586d1678 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -1,93 +1,93 @@
-import numpy as np
-import scipy.sparse.linalg
-import scipy.linalg
-
-from .dense import Dense
-from .csr import CSR
-from .properties import isdiag_csr
-from qutip.settings import settings
-from .base import idxint_dtype
-
-__all__ = [
-    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
-    'logm', 'logm_dense',
-]
-
-
-def expm_csr(matrix: CSR) -> CSR:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only exponentiate square matrix")
-    if isdiag_csr(matrix):
-        matrix_sci = matrix.as_scipy()
-        data = np.ones(matrix.shape[0], dtype=np.complex128)
-        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
-        return CSR(
-            (
-                data,
-                np.arange(matrix.shape[0], dtype=idxint_dtype),
-                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
-            ),
-            shape=matrix.shape,
-            copy=False,
-        )
-    # The scipy solvers for the Pade approximant are more efficient with the
-    # CSC format than the CSR one.
-    csc = matrix.as_scipy().tocsc()
-    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
-               tidyup=settings.core['auto_tidyup'])
-
-
-def expm_csr_dense(matrix: CSR) -> Dense:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only exponentiate square matrix")
-    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
-
-
-def expm_dense(matrix: Dense) -> Dense:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only exponentiate square matrix")
-    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-
-expm = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='expm',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
-expm.add_specialisations([
-    (CSR, CSR, expm_csr),
-    (CSR, Dense, expm_csr_dense),
-    (Dense, Dense, expm_dense),
-], _defer=True)
-
-
-def logm_dense(matrix: Dense) -> Dense:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only compute logarithm square matrix")
-    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
-
-
-logm = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='logm',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
-logm.add_specialisations([
-    (Dense, Dense, logm_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+import numpy as np
+import scipy.sparse.linalg
+import scipy.linalg
+
+from .dense import Dense
+from .csr import CSR
+from .properties import isdiag_csr
+from qutip.settings import settings
+from .base import idxint_dtype
+
+__all__ = [
+    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
+    'logm', 'logm_dense',
+]
+
+
+def expm_csr(matrix: CSR) -> CSR:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    if isdiag_csr(matrix):
+        matrix_sci = matrix.as_scipy()
+        data = np.ones(matrix.shape[0], dtype=np.complex128)
+        data[matrix_sci.indices] += np.expm1(matrix_sci.data)
+        return CSR(
+            (
+                data,
+                np.arange(matrix.shape[0], dtype=idxint_dtype),
+                np.arange(matrix.shape[0] + 1, dtype=idxint_dtype),
+            ),
+            shape=matrix.shape,
+            copy=False,
+        )
+    # The scipy solvers for the Pade approximant are more efficient with the
+    # CSC format than the CSR one.
+    csc = matrix.as_scipy().tocsc()
+    return CSR(scipy.sparse.linalg.expm(csc).tocsr(),
+               tidyup=settings.core['auto_tidyup'])
+
+
+def expm_csr_dense(matrix: CSR) -> Dense:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    return Dense(scipy.sparse.linalg.expm(matrix.to_array()))
+
+
+def expm_dense(matrix: Dense) -> Dense:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    return Dense(scipy.linalg.expm(matrix.as_ndarray()), copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+expm = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='expm',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+expm.__doc__ = """Matrix exponential `e**A` for a matrix `A`."""
+expm.add_specialisations([
+    (CSR, CSR, expm_csr),
+    (CSR, Dense, expm_csr_dense),
+    (Dense, Dense, expm_dense),
+], _defer=True)
+
+
+def logm_dense(matrix: Dense) -> Dense:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only compute logarithm square matrix")
+    return Dense(scipy.linalg.logm(matrix.as_ndarray()), copy=False)
+
+
+logm = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='logm',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+logm.__doc__ = """Matrix logarithm `ln(A)` for a matrix `A`."""
+logm.add_specialisations([
+    (Dense, Dense, logm_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/inner.pxd b/qutip/core/data/inner.pxd
index 2560e43586..1d5000dd7a 100644
--- a/qutip/core/data/inner.pxd
+++ b/qutip/core/data/inner.pxd
@@ -1,6 +1,6 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index 47331c7173..9491970044 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -1,286 +1,286 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data cimport csr, dense
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.matmul cimport matmul_dense
-
-__all__ = [
-    'inner', 'inner_csr', 'inner_dense',
-    'inner_op', 'inner_op_csr', 'inner_op_dense',
-]
-
-
-cdef void _check_shape_inner(Data left, Data right) nogil except *:
-    if (
-        (left.shape[0] != 1 and left.shape[1] != 1)
-        or right.shape[1] != 1
-    ):
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-
-cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
-    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
-    cdef bint left_op = (
-        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
-        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
-    )
-    cdef bint op_right = op.shape[1] == right.shape[0]
-    cdef bint right_shape = right.shape[1] == 1
-    if not (left_shape and left_op and op_right and right_shape):
-        raise ValueError("".join([
-            "incompatible matrix shapes ",
-            str(left.shape),
-            ", ",
-            str(op.shape),
-            " and ",
-            str(right.shape),
-        ]))
-
-cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
-    cdef size_t col, ptr_bra, ptr_ket
-    cdef double complex out = 0
-    # We actually don't care if left is sorted or not.
-    for ptr_bra in range(csr.nnz(left)):
-        col = left.col_index[ptr_bra]
-        ptr_ket = right.row_index[col]
-        if right.row_index[col + 1] != ptr_ket:
-            out += left.data[ptr_bra] * right.data[ptr_ket]
-    return out
-
-cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
-    cdef size_t row, ptr_l, ptr_r
-    cdef double complex out = 0
-    for row in range(left.shape[0]):
-        ptr_l = left.row_index[row]
-        ptr_r = right.row_index[row]
-        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
-            out += conj(left.data[ptr_l]) * right.data[ptr_r]
-    return out
-
-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
-    """
-    Compute the complex inner product <left|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner(left, right)
-    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
-        if csr.nnz(left) and csr.nnz(right):
-            return (
-                conj(left.data[0]) * right.data[0] if scalar_is_ket
-                else left.data[0] * right.data[0]
-            )
-        return 0
-    if left.shape[0] == 1:
-        return _inner_csr_bra_ket(left, right)
-    return _inner_csr_ket_ket(left, right)
-
-cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
-    """
-    Compute the complex inner product <left|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner(left, right)
-    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
-        return (
-                conj(left.data[0]) * right.data[0] if scalar_is_ket
-                else left.data[0] * right.data[0]
-        )
-    cdef double complex out = 0
-    cdef size_t i
-    if left.shape[0] == 1:
-        for i in range(right.shape[0]):
-            out += left.data[i] * right.data[i]
-    else:
-        for i in range(right.shape[0]):
-            out += conj(left.data[i]) * right.data[i]
-    return out
-
-
-cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
-    cdef size_t ptr_l, ptr_op, ptr_r, row, col
-    cdef double complex sum, out=0
-    # left does not need to be sorted.
-    for ptr_l in range(csr.nnz(left)):
-        row = left.col_index[ptr_l]
-        sum = 0
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            ptr_r = right.row_index[col]
-            if ptr_r != right.row_index[col + 1]:
-                sum += op.data[ptr_op] * right.data[ptr_r]
-        out += left.data[ptr_l] * sum
-    return out
-
-cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
-    cdef size_t ptr_l, ptr_op, ptr_r, row, col
-    cdef double complex sum, out=0
-    for row in range(op.shape[0]):
-        ptr_l = left.row_index[row]
-        if left.row_index[row + 1] == ptr_l:
-            continue
-        sum = 0
-        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
-            col = op.col_index[ptr_op]
-            ptr_r = right.row_index[col]
-            if ptr_r != right.row_index[col + 1]:
-                sum += op.data[ptr_op] * right.data[ptr_r]
-        out += conj(left.data[ptr_l]) * sum
-    return out
-
-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
-                                  bint scalar_is_ket=False) nogil except *:
-    """
-    Compute the complex inner product <left|op|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner_op(left, op, right)
-    cdef double complex l
-    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
-        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
-            return 0
-        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
-        return l * op.data[0] * right.data[0]
-    if left.shape[0] == 1:
-        return _inner_op_csr_bra_ket(left, op, right)
-    return _inner_op_csr_ket_ket(left, op, right)
-
-cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
-                                  bint scalar_is_ket=False) except *:
-    """
-    Compute the complex inner product <left|op|right>.  The shape of `left` is
-    used to determine if it has been supplied as a ket or a bra.  The result of
-    this function will be identical if passed `left` or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-    """
-    _check_shape_inner_op(left, op, right)
-    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-inner = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=False),
-    ]),
-    name='inner',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=False,
-)
-inner.__doc__ =\
-    """
-    Compute the complex inner product <left|right>.  Return the complex value.
-
-    The shape of `left` is used to determine if it has been supplied as a ket
-    or a bra.  The result of this function will be identical if passed `left`
-    or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-
-    Parameters
-    ----------
-    left : Data
-        The left operand as either a bra or a ket matrix.
-
-    right : Data
-        The right operand as a ket matrix.
-
-    scalar_is_ket : bool, optional (False)
-        If `False`, then `left` is assumed to be a bra if it is
-        one-dimensional.  If `True`, then it is assumed to be a ket.  This
-        parameter is ignored if `left` and `right` are not one-dimensional.
-    """
-inner.add_specialisations([
-    (CSR, CSR, inner_csr),
-    (Dense, Dense, inner_dense),
-], _defer=True)
-
-inner_op = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=False),
-    ]),
-    name='inner_op',
-    module=__name__,
-    inputs=('left', 'op', 'right'),
-    out=False,
-)
-inner_op.__doc__ =\
-    """
-    Compute the complex inner product <left|op|right>.  Return the complex
-    value.  This operation is also known as taking a matrix element.
-
-    The shape of `left` is used to determine if it has been supplied as a ket
-    or a bra.  The result of this function will be identical if passed `left`
-    or `adjoint(left)`.
-
-    The parameter `scalar_is_ket` is only intended for the case where `left`
-    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
-    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
-    all other times.
-
-    Parameters
-    ----------
-    left : Data
-        The left operand as either a bra or a ket matrix.
-
-    op : Data
-        The operator of which to take the matrix element.  Must have dimensions
-        which match `left` and `right`.
-
-    right : Data
-        The right operand as a ket matrix.
-
-    scalar_is_ket : bool, optional (False)
-        If `False`, then `left` is assumed to be a bra if it is
-        one-dimensional.  If `True`, then it is assumed to be a ket.  This
-        parameter is ignored if `left` and `right` are not one-dimensional.
-    """
-inner_op.add_specialisations([
-    (CSR, CSR, CSR, inner_op_csr),
-    (Dense, Dense, Dense, inner_op_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data cimport csr, dense
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.matmul cimport matmul_dense
+
+__all__ = [
+    'inner', 'inner_csr', 'inner_dense',
+    'inner_op', 'inner_op_csr', 'inner_op_dense',
+]
+
+
+cdef void _check_shape_inner(Data left, Data right) nogil except *:
+    if (
+        (left.shape[0] != 1 and left.shape[1] != 1)
+        or right.shape[1] != 1
+    ):
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+
+cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
+    cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
+    cdef bint left_op = (
+        (left.shape[0] == 1 and left.shape[1] == op.shape[0])
+        or (left.shape[1] == 1 and left.shape[0] == op.shape[0])
+    )
+    cdef bint op_right = op.shape[1] == right.shape[0]
+    cdef bint right_shape = right.shape[1] == 1
+    if not (left_shape and left_op and op_right and right_shape):
+        raise ValueError("".join([
+            "incompatible matrix shapes ",
+            str(left.shape),
+            ", ",
+            str(op.shape),
+            " and ",
+            str(right.shape),
+        ]))
+
+cdef double complex _inner_csr_bra_ket(CSR left, CSR right) nogil:
+    cdef size_t col, ptr_bra, ptr_ket
+    cdef double complex out = 0
+    # We actually don't care if left is sorted or not.
+    for ptr_bra in range(csr.nnz(left)):
+        col = left.col_index[ptr_bra]
+        ptr_ket = right.row_index[col]
+        if right.row_index[col + 1] != ptr_ket:
+            out += left.data[ptr_bra] * right.data[ptr_ket]
+    return out
+
+cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
+    cdef size_t row, ptr_l, ptr_r
+    cdef double complex out = 0
+    for row in range(left.shape[0]):
+        ptr_l = left.row_index[row]
+        ptr_r = right.row_index[row]
+        if left.row_index[row+1] != ptr_l and right.row_index[row+1] != ptr_r:
+            out += conj(left.data[ptr_l]) * right.data[ptr_r]
+    return out
+
+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner(left, right)
+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+        if csr.nnz(left) and csr.nnz(right):
+            return (
+                conj(left.data[0]) * right.data[0] if scalar_is_ket
+                else left.data[0] * right.data[0]
+            )
+        return 0
+    if left.shape[0] == 1:
+        return _inner_csr_bra_ket(left, right)
+    return _inner_csr_ket_ket(left, right)
+
+cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner(left, right)
+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+        return (
+                conj(left.data[0]) * right.data[0] if scalar_is_ket
+                else left.data[0] * right.data[0]
+        )
+    cdef double complex out = 0
+    cdef size_t i
+    if left.shape[0] == 1:
+        for i in range(right.shape[0]):
+            out += left.data[i] * right.data[i]
+    else:
+        for i in range(right.shape[0]):
+            out += conj(left.data[i]) * right.data[i]
+    return out
+
+
+cdef double complex _inner_op_csr_bra_ket(CSR left, CSR op, CSR right) nogil:
+    cdef size_t ptr_l, ptr_op, ptr_r, row, col
+    cdef double complex sum, out=0
+    # left does not need to be sorted.
+    for ptr_l in range(csr.nnz(left)):
+        row = left.col_index[ptr_l]
+        sum = 0
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            ptr_r = right.row_index[col]
+            if ptr_r != right.row_index[col + 1]:
+                sum += op.data[ptr_op] * right.data[ptr_r]
+        out += left.data[ptr_l] * sum
+    return out
+
+cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
+    cdef size_t ptr_l, ptr_op, ptr_r, row, col
+    cdef double complex sum, out=0
+    for row in range(op.shape[0]):
+        ptr_l = left.row_index[row]
+        if left.row_index[row + 1] == ptr_l:
+            continue
+        sum = 0
+        for ptr_op in range(op.row_index[row], op.row_index[row + 1]):
+            col = op.col_index[ptr_op]
+            ptr_r = right.row_index[col]
+            if ptr_r != right.row_index[col + 1]:
+                sum += op.data[ptr_op] * right.data[ptr_r]
+        out += conj(left.data[ptr_l]) * sum
+    return out
+
+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
+                                  bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|op|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner_op(left, op, right)
+    cdef double complex l
+    if left.shape[0] == left.shape[1] == op.shape[0] == op.shape[1] == right.shape[1] == 1:
+        if not (csr.nnz(left) and csr.nnz(op) and csr.nnz(right)):
+            return 0
+        l = conj(left.data[0]) if scalar_is_ket else left.data[0]
+        return l * op.data[0] * right.data[0]
+    if left.shape[0] == 1:
+        return _inner_op_csr_bra_ket(left, op, right)
+    return _inner_op_csr_ket_ket(left, op, right)
+
+cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
+                                  bint scalar_is_ket=False) except *:
+    """
+    Compute the complex inner product <left|op|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner_op(left, op, right)
+    return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+inner = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=False),
+    ]),
+    name='inner',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=False,
+)
+inner.__doc__ =\
+    """
+    Compute the complex inner product <left|right>.  Return the complex value.
+
+    The shape of `left` is used to determine if it has been supplied as a ket
+    or a bra.  The result of this function will be identical if passed `left`
+    or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+
+    Parameters
+    ----------
+    left : Data
+        The left operand as either a bra or a ket matrix.
+
+    right : Data
+        The right operand as a ket matrix.
+
+    scalar_is_ket : bool, optional (False)
+        If `False`, then `left` is assumed to be a bra if it is
+        one-dimensional.  If `True`, then it is assumed to be a ket.  This
+        parameter is ignored if `left` and `right` are not one-dimensional.
+    """
+inner.add_specialisations([
+    (CSR, CSR, inner_csr),
+    (Dense, Dense, inner_dense),
+], _defer=True)
+
+inner_op = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('op', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scalar_is_ket', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=False),
+    ]),
+    name='inner_op',
+    module=__name__,
+    inputs=('left', 'op', 'right'),
+    out=False,
+)
+inner_op.__doc__ =\
+    """
+    Compute the complex inner product <left|op|right>.  Return the complex
+    value.  This operation is also known as taking a matrix element.
+
+    The shape of `left` is used to determine if it has been supplied as a ket
+    or a bra.  The result of this function will be identical if passed `left`
+    or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+
+    Parameters
+    ----------
+    left : Data
+        The left operand as either a bra or a ket matrix.
+
+    op : Data
+        The operator of which to take the matrix element.  Must have dimensions
+        which match `left` and `right`.
+
+    right : Data
+        The right operand as a ket matrix.
+
+    scalar_is_ket : bool, optional (False)
+        If `False`, then `left` is assumed to be a bra if it is
+        one-dimensional.  If `True`, then it is assumed to be a ket.  This
+        parameter is ignored if `left` and `right` are not one-dimensional.
+    """
+inner_op.add_specialisations([
+    (CSR, CSR, CSR, inner_op_csr),
+    (Dense, Dense, Dense, inner_op_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/kron.pxd b/qutip/core/data/kron.pxd
index 89f717f8a7..6caa261983 100644
--- a/qutip/core/data/kron.pxd
+++ b/qutip/core/data/kron.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR kron_csr(CSR left, CSR right)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR kron_csr(CSR left, CSR right)
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index 5cd9d5697b..fd94adc369 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -1,91 +1,91 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data cimport csr
-import numpy
-
-__all__ = [
-    'kron', 'kron_csr', 'kron_dense'
-]
-
-
-@cython.overflowcheck(True)
-cdef idxint _mul_checked(idxint a, idxint b):
-    return a * b
-
-
-cpdef Dense kron_dense(Dense left, Dense right):
-    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
-
-
-cpdef CSR kron_csr(CSR left, CSR right):
-    """Kronecker product of two CSR matrices."""
-    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
-    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
-    cdef idxint row_l, row_r, row_out
-    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
-    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
-    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
-                             _mul_checked(ncols_l, ncols_r),
-                             _mul_checked(csr.nnz(left), csr.nnz(right)))
-    with nogil:
-        row_out = 0
-        out.row_index[row_out] = 0
-        for row_l in range(nrows_l):
-            ptr_start_l = left.row_index[row_l]
-            ptr_end_l = left.row_index[row_l + 1]
-            dist_l = ptr_end_l - ptr_start_l
-
-            for row_r in range(nrows_r):
-                ptr_start_r = right.row_index[row_r]
-                ptr_end_r = right.row_index[row_r + 1]
-                dist_r = ptr_end_r - ptr_start_r
-
-                ptr_start_out = out.row_index[row_out]
-                ptr_end_out = ptr_start_out + dist_r
-
-                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
-                row_out += 1
-
-                for ptr_l in range(ptr_start_l, ptr_end_l):
-                    ptr_r = ptr_start_r
-                    for ptr_out in range(ptr_start_out, ptr_end_out):
-                        out.col_index[ptr_out] =\
-                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
-                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
-                        ptr_r += 1
-
-                    ptr_start_out += dist_r
-                    ptr_end_out += dist_r
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-kron = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='kron',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-kron.__doc__ =\
-    """
-    Compute the Kronecker product of two matrices.  This is used to represent
-    quantum tensor products of vector spaces.
-    """
-kron.add_specialisations([
-    (CSR, CSR, CSR, kron_csr),
-    (Dense, Dense, Dense, kron_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data cimport csr
+import numpy
+
+__all__ = [
+    'kron', 'kron_csr', 'kron_dense'
+]
+
+
+@cython.overflowcheck(True)
+cdef idxint _mul_checked(idxint a, idxint b):
+    return a * b
+
+
+cpdef Dense kron_dense(Dense left, Dense right):
+    return Dense(numpy.kron(left.as_ndarray(), right.as_ndarray()), copy=False)
+
+
+cpdef CSR kron_csr(CSR left, CSR right):
+    """Kronecker product of two CSR matrices."""
+    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
+    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
+    cdef idxint row_l, row_r, row_out
+    cdef idxint ptr_start_l, ptr_end_l, ptr_start_r, ptr_end_r, dist_l, dist_r
+    cdef idxint ptr_l, ptr_r, ptr_out, ptr_start_out, ptr_end_out
+    cdef CSR out = csr.empty(_mul_checked(nrows_l, nrows_r),
+                             _mul_checked(ncols_l, ncols_r),
+                             _mul_checked(csr.nnz(left), csr.nnz(right)))
+    with nogil:
+        row_out = 0
+        out.row_index[row_out] = 0
+        for row_l in range(nrows_l):
+            ptr_start_l = left.row_index[row_l]
+            ptr_end_l = left.row_index[row_l + 1]
+            dist_l = ptr_end_l - ptr_start_l
+
+            for row_r in range(nrows_r):
+                ptr_start_r = right.row_index[row_r]
+                ptr_end_r = right.row_index[row_r + 1]
+                dist_r = ptr_end_r - ptr_start_r
+
+                ptr_start_out = out.row_index[row_out]
+                ptr_end_out = ptr_start_out + dist_r
+
+                out.row_index[row_out+1] = out.row_index[row_out] + dist_l*dist_r
+                row_out += 1
+
+                for ptr_l in range(ptr_start_l, ptr_end_l):
+                    ptr_r = ptr_start_r
+                    for ptr_out in range(ptr_start_out, ptr_end_out):
+                        out.col_index[ptr_out] =\
+                            left.col_index[ptr_l]*ncols_r + right.col_index[ptr_r]
+                        out.data[ptr_out] = left.data[ptr_l] * right.data[ptr_r]
+                        ptr_r += 1
+
+                    ptr_start_out += dist_r
+                    ptr_end_out += dist_r
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+kron = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='kron',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+kron.__doc__ =\
+    """
+    Compute the Kronecker product of two matrices.  This is used to represent
+    quantum tensor products of vector spaces.
+    """
+kron.add_specialisations([
+    (CSR, CSR, CSR, kron_csr),
+    (Dense, Dense, Dense, kron_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/linalg.py b/qutip/core/data/linalg.py
index e3847257ad..f55077381c 100644
--- a/qutip/core/data/linalg.py
+++ b/qutip/core/data/linalg.py
@@ -1,55 +1,55 @@
-import scipy.linalg
-import scipy.sparse
-from .dense import Dense
-from .csr import CSR
-
-__all__ = ['inv', 'inv_csr', 'inv_dense']
-
-
-def inv_dense(data):
-    """Compute the inverse of a matrix"""
-    if not isinstance(data, Dense):
-        raise TypeError("expected data in Dense format but got "
-                        + str(type(data)))
-    if data.shape[0] != data.shape[1]:
-        raise ValueError('Cannot compute the matrix inverse'
-                         ' of a nonsquare matrix')
-    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
-
-
-def inv_csr(data):
-    """Compute the inverse of a sparse matrix"""
-    if not isinstance(data, CSR):
-        raise TypeError("expected data in CSR format but got "
-                        + str(type(data)))
-    if data.shape[0] != data.shape[1]:
-        raise ValueError('Cannot compute the matrix inverse '
-                         'of a nonsquare matrix')
-    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
-    # scipy.sparse.linalg.inv can return dense or sparse arrays.
-    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-
-inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
-inv.__doc__ =\
-    """
-    Return matrix inverse for a data-layer object.
-
-    Parameters
-    ----------
-    data : Data
-        Input matrix
-
-    Returns
-    -------
-    inverse : Data
-        Inverse of data
-    """
-inv.add_specialisations([
-    (CSR, CSR, inv_csr),
-    (Dense, Dense, inv_dense),
-], _defer=True)
-
-del _Dispatcher
+import scipy.linalg
+import scipy.sparse
+from .dense import Dense
+from .csr import CSR
+
+__all__ = ['inv', 'inv_csr', 'inv_dense']
+
+
+def inv_dense(data):
+    """Compute the inverse of a matrix"""
+    if not isinstance(data, Dense):
+        raise TypeError("expected data in Dense format but got "
+                        + str(type(data)))
+    if data.shape[0] != data.shape[1]:
+        raise ValueError('Cannot compute the matrix inverse'
+                         ' of a nonsquare matrix')
+    return Dense(scipy.linalg.inv(data.as_ndarray()), copy=False)
+
+
+def inv_csr(data):
+    """Compute the inverse of a sparse matrix"""
+    if not isinstance(data, CSR):
+        raise TypeError("expected data in CSR format but got "
+                        + str(type(data)))
+    if data.shape[0] != data.shape[1]:
+        raise ValueError('Cannot compute the matrix inverse '
+                         'of a nonsquare matrix')
+    inv = scipy.sparse.linalg.inv(data.as_scipy().tocsc())
+    # scipy.sparse.linalg.inv can return dense or sparse arrays.
+    return CSR(scipy.sparse.csr_matrix(inv), copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+
+inv = _Dispatcher(inv_dense, name='inv', inputs=('data',), out=True)
+inv.__doc__ =\
+    """
+    Return matrix inverse for a data-layer object.
+
+    Parameters
+    ----------
+    data : Data
+        Input matrix
+
+    Returns
+    -------
+    inverse : Data
+        Inverse of data
+    """
+inv.add_specialisations([
+    (CSR, CSR, inv_csr),
+    (Dense, Dense, inv_dense),
+], _defer=True)
+
+del _Dispatcher
diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
index 69f1ddcba6..8b34d6565c 100644
--- a/qutip/core/data/make.py
+++ b/qutip/core/data/make.py
@@ -1,101 +1,101 @@
-from .dispatch import Dispatcher as _Dispatcher
-from . import csr, dense, CSR, Dense
-
-__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
-
-
-def _diag_signature(diagonals, offsets=0, shape=None):
-    """
-    Construct a matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements. Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    pass
-
-
-diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
-diag.add_specialisations([
-    (CSR, csr.diags),
-    (Dense, dense.diags),
-], _defer=True)
-
-del _diag_signature
-
-
-def one_element_csr(shape, position, value=1.0):
-    """
-    Create a matrix with only one nonzero element.
-
-    Parameters
-    ----------
-    shape : tuple
-        The shape of the output as (``rows``, ``columns``).
-
-    position : tuple
-        The position of the non zero in the matrix as (``rows``, ``columns``).
-
-    value : complex, optional
-        The value of the non-null element.
-    """
-    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
-        raise ValueError("Position of the elements out of bound: " +
-                         str(position) + " in " + str(shape))
-    data = csr.empty(*shape, 1)
-    sci = data.as_scipy(full=True)
-    sci.data[0] = value
-    sci.indices[0] = position[1]
-    sci.indptr[:position[0]+1] = 0
-    sci.indptr[position[0]+1:] = 1
-    return data
-
-
-def one_element_dense(shape, position, value=1.0):
-    """
-    Create a matrix with only one nonzero element.
-
-    Parameters
-    ----------
-    shape : tuple
-        The shape of the output as (``rows``, ``columns``).
-
-    position : tuple
-        The position of the non zero in the matrix as (``rows``, ``columns``).
-
-    value : complex, optional
-        The value of the non-null element.
-    """
-    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
-        raise ValueError("Position of the elements out of bound: " +
-                         str(position) + " in " + str(shape))
-    data = dense.zeros(*shape, 1)
-    nda = data.as_ndarray()
-    nda[position] = value
-    return data
-
-
-one_element = _Dispatcher(one_element_dense, name='one_element',
-                          inputs=(), out=True)
-one_element.add_specialisations([
-    (CSR, one_element_csr),
-    (Dense, one_element_dense),
-], _defer=True)
+from .dispatch import Dispatcher as _Dispatcher
+from . import csr, dense, CSR, Dense
+
+__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
+
+
+def _diag_signature(diagonals, offsets=0, shape=None):
+    """
+    Construct a matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements. Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    pass
+
+
+diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
+diag.add_specialisations([
+    (CSR, csr.diags),
+    (Dense, dense.diags),
+], _defer=True)
+
+del _diag_signature
+
+
+def one_element_csr(shape, position, value=1.0):
+    """
+    Create a matrix with only one nonzero element.
+
+    Parameters
+    ----------
+    shape : tuple
+        The shape of the output as (``rows``, ``columns``).
+
+    position : tuple
+        The position of the non zero in the matrix as (``rows``, ``columns``).
+
+    value : complex, optional
+        The value of the non-null element.
+    """
+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+        raise ValueError("Position of the elements out of bound: " +
+                         str(position) + " in " + str(shape))
+    data = csr.empty(*shape, 1)
+    sci = data.as_scipy(full=True)
+    sci.data[0] = value
+    sci.indices[0] = position[1]
+    sci.indptr[:position[0]+1] = 0
+    sci.indptr[position[0]+1:] = 1
+    return data
+
+
+def one_element_dense(shape, position, value=1.0):
+    """
+    Create a matrix with only one nonzero element.
+
+    Parameters
+    ----------
+    shape : tuple
+        The shape of the output as (``rows``, ``columns``).
+
+    position : tuple
+        The position of the non zero in the matrix as (``rows``, ``columns``).
+
+    value : complex, optional
+        The value of the non-null element.
+    """
+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+        raise ValueError("Position of the elements out of bound: " +
+                         str(position) + " in " + str(shape))
+    data = dense.zeros(*shape, 1)
+    nda = data.as_ndarray()
+    nda[position] = value
+    return data
+
+
+one_element = _Dispatcher(one_element_dense, name='one_element',
+                          inputs=(), out=True)
+one_element.add_specialisations([
+    (CSR, one_element_csr),
+    (Dense, one_element_dense),
+], _defer=True)
diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
index b9d85556bb..54d21798d0 100644
--- a/qutip/core/data/matmul.pxd
+++ b/qutip/core/data/matmul.pxd
@@ -1,14 +1,14 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.base cimport Data
-
-cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
-cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
-cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
-cdef Dense matmul_data_dense(Data left, Dense right)
-cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
-
-cpdef Dense multiply_dense(Dense left, Dense right)
-cpdef CSR multiply_csr(CSR left, CSR right)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.base cimport Data
+
+cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
+cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
+cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
+cdef Dense matmul_data_dense(Data left, Dense right)
+cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
+
+cpdef Dense multiply_dense(Dense left, Dense right)
+cpdef CSR multiply_csr(CSR left, CSR right)
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index d2d67e9723..1d05387961 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -1,474 +1,474 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-from libc.math cimport fabs
-
-import warnings
-from qutip.settings import settings
-
-cimport cython
-
-from cpython cimport mem
-
-import numpy as np
-cimport numpy as cnp
-from scipy.linalg cimport cython_blas as blas
-
-from qutip.core.data.base import idxint_dtype
-from qutip.core.data.base cimport idxint, Data
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.csr cimport CSR
-from qutip.core.data cimport csr, dense
-from qutip.core.data.add cimport iadd_dense, add_csr
-from qutip.core.data.dense import OrderEfficiencyWarning
-
-cnp.import_array()
-
-cdef extern from *:
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-# This function is templated over integral types on import to allow `idxint` to
-# be any signed integer (though likely things will only work for >=32-bit).  To
-# change integral types, you only need to change the `idxint` definitions in
-# `core.data.base` at compile-time.
-cdef extern from "src/matmul_csr_vector.hpp" nogil:
-    void _matmul_csr_vector[T](
-        double complex *data, T *col_index, T *row_index,
-        double complex *vec, double complex scale, double complex *out,
-        T nrows)
-
-__all__ = [
-    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
-    'multiply', 'multiply_csr', 'multiply_dense',
-]
-
-
-cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
-    if left.shape[1] != right.shape[0]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-    if (
-        out is not None
-        and out.shape[0] != left.shape[0]
-        and out.shape[1] != right.shape[1]
-    ):
-        raise ValueError(
-            "incompatible output shape, got "
-            + str(out.shape)
-            + " but needed "
-            + str((left.shape[0], right.shape[1]))
-        )
-
-
-cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
-    """
-    Produce a sensible upper-bound for the number of non-zero elements that
-    will be present in a matrix multiplication between the two matrices.
-    """
-    cdef idxint j, k, nnz=0
-    cdef idxint ii, jj, kk
-    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
-    # Setup mask array
-    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
-    with nogil:
-        for ii in range(ncols):
-            mask[ii] = -1
-        for ii in range(nrows):
-            for jj in range(left.row_index[ii], left.row_index[ii+1]):
-                j = left.col_index[jj]
-                for kk in range(right.row_index[j], right.row_index[j+1]):
-                    k = right.col_index[kk]
-                    if mask[k] != ii:
-                        mask[k] = ii
-                        nnz += 1
-    mem.PyMem_Free(mask)
-    return nnz
-
-
-cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
-    """
-    Multiply two CSR matrices together to produce another CSR.  If `out` is
-    specified, it must be pre-allocated with enough space to hold the output
-    result.
-
-    This is the operation
-        ``out := left @ right``
-    where `out` will be allocated if not supplied.
-
-    Parameters
-    ----------
-    left : CSR
-        CSR matrix on the left of the multiplication.
-    right : CSR
-        CSR matrix on the right of the multiplication.
-    out : optional CSR
-        Allocated space to store the result.  This must have enough space in
-        the `data`, `col_index` and `row_index` pointers already allocated.
-
-    Returns
-    -------
-    out : CSR
-        The result of the matrix multiplication.  This will be the same object
-        as the input parameter `out` if that was supplied.
-    """
-    _check_shape(left, right)
-    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
-    if out is not None:
-        raise TypeError("passing an `out` entry for CSR operations makes no sense")
-    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
-    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
-        # Ensure the out array row_index is zeroed.  The others need not be,
-        # because they don't represent valid entries since row_index is zeroed.
-        with nogil:
-            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
-        return out
-
-    # Initialise actual matrix multiplication.
-    nnz = 0
-    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
-    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
-    cdef double complex val
-    cdef double complex *sums
-    cdef idxint *nxt
-    cdef double tol = 0
-    if settings.core['auto_tidyup']:
-        tol = settings.core['auto_tidyup_atol']
-    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
-    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
-    with nogil:
-        for col_r in range(ncols):
-            nxt[col_r] = -1
-
-        # Perform operation.
-        out.row_index[0] = 0
-        for row_l in range(nrows):
-            head = -2
-            length = 0
-            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
-                row_r = left.col_index[ptr_l]
-                val = left.data[ptr_l]
-                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
-                    col_r = right.col_index[ptr_r]
-                    sums[col_r] += val * right.data[ptr_r]
-                    if nxt[col_r] == -1:
-                        nxt[col_r] = head
-                        head = col_r
-                        length += 1
-            for col_r in range(length):
-                if fabs(sums[head].real) < tol:
-                    sums[head].real = 0
-                if fabs(sums[head].imag) < tol:
-                    sums[head].imag = 0
-                if sums[head] != 0:
-                    out.col_index[nnz] = head
-                    out.data[nnz] = scale * sums[head]
-                    nnz += 1
-                tmp = head
-                head = nxt[head]
-                nxt[tmp] = -1
-                sums[tmp] = 0
-            out.row_index[row_l + 1] = nnz
-    mem.PyMem_Free(sums)
-    mem.PyMem_Free(nxt)
-    return out
-
-
-cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
-                                   double complex scale=1, Dense out=None):
-    """
-    Perform the operation
-        ``out := scale * (left @ right) + out``
-    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
-    defaulting to 1.
-
-    If `out` is not given, it will be allocated as if it were a zero matrix.
-    """
-    _check_shape(left, right, out)
-    cdef Dense tmp = None
-    if out is None:
-        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
-    if bool(right.fortran) != bool(out.fortran):
-        msg = (
-            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
-            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
-        )
-        warnings.warn(msg, OrderEfficiencyWarning)
-        # Rather than making loads of copies of the same code, we just moan at
-        # the user and then transpose one of the arrays.  We prefer to have
-        # `right` in Fortran-order for cache efficiency.
-        if right.fortran:
-            tmp = out
-            out = out.reorder()
-        else:
-            right = right.reorder()
-    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
-    cdef double complex val
-    if right.fortran:
-        idx_r = idx_out = 0
-        for _ in range(ncols):
-            _matmul_csr_vector(left.data, left.col_index, left.row_index,
-                               right.data + idx_r,
-                               scale,
-                               out.data + idx_out,
-                               nrows)
-            idx_out += nrows
-            idx_r += right.shape[0]
-    else:
-        for row in range(nrows):
-            for ptr in range(left.row_index[row], left.row_index[row + 1]):
-                val = scale * left.data[ptr]
-                idx_out = row * ncols
-                idx_r = left.col_index[ptr] * ncols
-                for _ in range(ncols):
-                    out.data[idx_out] += val * right.data[idx_r]
-                    idx_out += 1
-                    idx_r += 1
-    if tmp is None:
-        return out
-    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
-    return tmp
-
-
-cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
-    """
-    Perform the operation
-        ``out := scale * (left @ right) + out``
-    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
-    defaulting to 1.
-
-    If `out` is not given, it will be allocated as if it were a zero matrix.
-    """
-    _check_shape(left, right, out)
-    cdef double complex out_scale
-    # If not supplied, it's more efficient from a memory allocation perspective
-    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
-    if out is None:
-        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
-        out_scale = 0
-    else:
-        out_scale = 1
-    cdef double complex *a
-    cdef double complex *b
-    cdef char transa, transb
-    cdef int m, n, k=left.shape[1], lda, ldb
-    if right.shape[1] == 1:
-        # Matrix Vector product
-        a, b = left.data, right.data
-        if left.fortran:
-            lda = left.shape[0]
-            transa = b'n'
-            m = left.shape[0]
-            n = left.shape[1]
-        else:
-            lda = left.shape[1]
-            transa = b't'
-            m = left.shape[1]
-            n = left.shape[0]
-        ldb = 1
-        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
-                   &out_scale, out.data, &ldb)
-        return out
-    # We use the BLAS routine zgemm for every single call and pretend that
-    # we're always supplying it with Fortran-ordered matrices, but to achieve
-    # what we want, we use the property of matrix multiplication that
-    #   A.B = (B'.A')'
-    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
-    # matrix as a C-ordered one is equivalent to taking the transpose.  If
-    # `right` is supplied in C-order, then from Fortran's perspective we
-    # actually have `B'`, so to retrieve `B` should we want to use it, we set
-    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
-    # need to switch the input order, _not_ whether we actually need B'.
-    #
-    # In order to make the output correct, we ensure that we put A.B in if the
-    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
-    # This is actually more flexible than `np.dot` which requires that the
-    # output is C-ordered.
-    if out.fortran:
-        # Need to make A.B
-        a, b = left.data, right.data
-        m, n = left.shape[0], right.shape[1]
-        lda = left.shape[0] if left.fortran else left.shape[1]
-        transa = b'n' if left.fortran else b't'
-        ldb = right.shape[0] if right.fortran else right.shape[1]
-        transb = b'n' if right.fortran else b't'
-    else:
-        # Need to make B'.A'
-        a, b = right.data, left.data
-        m, n = right.shape[1], left.shape[0]
-        lda = right.shape[0] if right.fortran else right.shape[1]
-        transa = b't' if right.fortran else b'n'
-        ldb = left.shape[0] if left.fortran else left.shape[1]
-        transb = b't' if left.fortran else b'n'
-    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
-               &out_scale, out.data, &m)
-    return out
-
-
-cpdef CSR multiply_csr(CSR left, CSR right):
-    """Element-wise multiplication of CSR matrices."""
-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-    cdef idxint col_left, left_nnz = csr.nnz(left)
-    cdef idxint col_right, right_nnz = csr.nnz(right)
-    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
-    cdef idxint row, nnz=0, ncols=left.shape[1]
-    cdef CSR out
-    cdef list nans=[]
-    # Fast paths for zero matrices.
-    if right_nnz == 0 or left_nnz == 0:
-        return csr.zeros(left.shape[0], left.shape[1])
-    # Main path.
-    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
-    out.row_index[0] = nnz
-    ptr_left_max = ptr_right_max = 0
-
-    for row in range(left.shape[0]):
-        ptr_left = ptr_left_max
-        ptr_left_max = left.row_index[row + 1]
-        ptr_right = ptr_right_max
-        ptr_right_max = right.row_index[row + 1]
-        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
-            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
-            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
-            if col_left == col_right:
-                out.col_index[nnz] = col_left
-                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
-                ptr_left += 1
-                ptr_right += 1
-                nnz += 1
-            elif col_left <= col_right:
-                if left.data[ptr_left] is np.nan:
-                    # Test for NaN since `NaN * 0 = NaN`
-                    nans.append((row, col_left))
-                ptr_left += 1
-            else:
-                if right.data[ptr_right] != right.data[ptr_right]:
-                    nans.append((row, col_right))
-                ptr_right += 1
-        out.row_index[row + 1] = nnz
-    if nans:
-        # We expect Nan to be rare enough that we don't allocate memory for
-        # them, but add them here after the loop.
-        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
-        nnz = nans_pos.shape[0]
-        nans_csr = csr.from_coo_pointers(
-            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
-            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
-            <double complex *> cnp.PyArray_GETPTR1(
-                np.array([np.nan]*nnz, dtype=np.complex128), 0),
-            left.shape[0], left.shape[1], nnz
-        )
-        out = add_csr(out, nans_csr)
-    return out
-
-
-cpdef Dense multiply_dense(Dense left, Dense right):
-    """Element-wise multiplication of Dense matrices."""
-    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
-        raise ValueError(
-            "incompatible matrix shapes "
-            + str(left.shape)
-            + " and "
-            + str(right.shape)
-        )
-    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-# At the time of putting in the dispatchers, the idea of an "out" parameter
-# isn't really supported in the model; since `out` would be potentially
-# modified in-place, it couldn't safely go through a conversion process.  For
-# the dispatched operation, then, we omit the `scale` and `out` parameters, and
-# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
-# are needed, the library will have to manually do any relevant conversions,
-# and then call a direct specialisation (which are exported to the `data`
-# namespace).
-
-matmul = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='matmul',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-matmul.__doc__ =\
-    """
-    Compute the matrix multiplication of two matrices, with the operation
-        scale * (left @ right)
-    where `scale` is (optionally) a scalar, and `left` and `right` are
-    matrices.
-
-    Parameters
-    ----------
-    left : Data
-        The left operand as either a bra or a ket matrix.
-
-    right : Data
-        The right operand as a ket matrix.
-
-    scale : complex, optional
-        The scalar to multiply the output by.
-    """
-matmul.add_specialisations([
-    (CSR, CSR, CSR, matmul_csr),
-    (CSR, Dense, Dense, matmul_csr_dense_dense),
-    (Dense, Dense, Dense, matmul_dense),
-], _defer=True)
-
-
-multiply = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='multiply',
-    module=__name__,
-    inputs=('left', 'right'),
-    out=True,
-)
-multiply.__doc__ =\
-    """Element-wise multiplication of matrices."""
-multiply.add_specialisations([
-    (CSR, CSR, CSR, multiply_csr),
-    (Dense, Dense, Dense, multiply_dense),
-], _defer=True)
-
-
-del _inspect, _Dispatcher
-
-
-cdef Dense matmul_data_dense(Data left, Dense right):
-    cdef Dense out
-    if type(left) is CSR:
-        out = matmul_csr_dense_dense(left, right)
-    elif type(left) is Dense:
-        out = matmul_dense(left, right)
-    else:
-        out = matmul(left, right)
-    return out
-
-
-cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
-    if type(left) is CSR:
-        matmul_csr_dense_dense(left, right, scale, out)
-    elif type(left) is Dense:
-        matmul_dense(left, right, scale, out)
-    else:
-        iadd_dense(out, matmul(left, right), scale)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+from libc.math cimport fabs
+
+import warnings
+from qutip.settings import settings
+
+cimport cython
+
+from cpython cimport mem
+
+import numpy as np
+cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
+
+from qutip.core.data.base import idxint_dtype
+from qutip.core.data.base cimport idxint, Data
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport CSR
+from qutip.core.data cimport csr, dense
+from qutip.core.data.add cimport iadd_dense, add_csr
+from qutip.core.data.dense import OrderEfficiencyWarning
+
+cnp.import_array()
+
+cdef extern from *:
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+# This function is templated over integral types on import to allow `idxint` to
+# be any signed integer (though likely things will only work for >=32-bit).  To
+# change integral types, you only need to change the `idxint` definitions in
+# `core.data.base` at compile-time.
+cdef extern from "src/matmul_csr_vector.hpp" nogil:
+    void _matmul_csr_vector[T](
+        double complex *data, T *col_index, T *row_index,
+        double complex *vec, double complex scale, double complex *out,
+        T nrows)
+
+__all__ = [
+    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
+    'multiply', 'multiply_csr', 'multiply_dense',
+]
+
+
+cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
+    if left.shape[1] != right.shape[0]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    if (
+        out is not None
+        and out.shape[0] != left.shape[0]
+        and out.shape[1] != right.shape[1]
+    ):
+        raise ValueError(
+            "incompatible output shape, got "
+            + str(out.shape)
+            + " but needed "
+            + str((left.shape[0], right.shape[1]))
+        )
+
+
+cdef idxint _matmul_csr_estimate_nnz(CSR left, CSR right):
+    """
+    Produce a sensible upper-bound for the number of non-zero elements that
+    will be present in a matrix multiplication between the two matrices.
+    """
+    cdef idxint j, k, nnz=0
+    cdef idxint ii, jj, kk
+    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
+    # Setup mask array
+    cdef idxint *mask = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
+    with nogil:
+        for ii in range(ncols):
+            mask[ii] = -1
+        for ii in range(nrows):
+            for jj in range(left.row_index[ii], left.row_index[ii+1]):
+                j = left.col_index[jj]
+                for kk in range(right.row_index[j], right.row_index[j+1]):
+                    k = right.col_index[kk]
+                    if mask[k] != ii:
+                        mask[k] = ii
+                        nnz += 1
+    mem.PyMem_Free(mask)
+    return nnz
+
+
+cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=1, CSR out=None):
+    """
+    Multiply two CSR matrices together to produce another CSR.  If `out` is
+    specified, it must be pre-allocated with enough space to hold the output
+    result.
+
+    This is the operation
+        ``out := left @ right``
+    where `out` will be allocated if not supplied.
+
+    Parameters
+    ----------
+    left : CSR
+        CSR matrix on the left of the multiplication.
+    right : CSR
+        CSR matrix on the right of the multiplication.
+    out : optional CSR
+        Allocated space to store the result.  This must have enough space in
+        the `data`, `col_index` and `row_index` pointers already allocated.
+
+    Returns
+    -------
+    out : CSR
+        The result of the matrix multiplication.  This will be the same object
+        as the input parameter `out` if that was supplied.
+    """
+    _check_shape(left, right)
+    cdef idxint nnz = _matmul_csr_estimate_nnz(left, right)
+    if out is not None:
+        raise TypeError("passing an `out` entry for CSR operations makes no sense")
+    out = csr.empty(left.shape[0], right.shape[1], nnz if nnz != 0 else 1)
+    if nnz == 0 or csr.nnz(left) == 0 or csr.nnz(right) == 0:
+        # Ensure the out array row_index is zeroed.  The others need not be,
+        # because they don't represent valid entries since row_index is zeroed.
+        with nogil:
+            memset(&out.row_index[0], 0, (out.shape[0] + 1) * sizeof(idxint))
+        return out
+
+    # Initialise actual matrix multiplication.
+    nnz = 0
+    cdef idxint head, length, row_l, ptr_l, row_r, ptr_r, col_r, tmp
+    cdef idxint nrows=left.shape[0], ncols=right.shape[1]
+    cdef double complex val
+    cdef double complex *sums
+    cdef idxint *nxt
+    cdef double tol = 0
+    if settings.core['auto_tidyup']:
+        tol = settings.core['auto_tidyup_atol']
+    sums = <double complex *> PyMem_Calloc(ncols, sizeof(double complex))
+    nxt = <idxint *> mem.PyMem_Malloc(ncols * sizeof(idxint))
+    with nogil:
+        for col_r in range(ncols):
+            nxt[col_r] = -1
+
+        # Perform operation.
+        out.row_index[0] = 0
+        for row_l in range(nrows):
+            head = -2
+            length = 0
+            for ptr_l in range(left.row_index[row_l], left.row_index[row_l+1]):
+                row_r = left.col_index[ptr_l]
+                val = left.data[ptr_l]
+                for ptr_r in range(right.row_index[row_r], right.row_index[row_r+1]):
+                    col_r = right.col_index[ptr_r]
+                    sums[col_r] += val * right.data[ptr_r]
+                    if nxt[col_r] == -1:
+                        nxt[col_r] = head
+                        head = col_r
+                        length += 1
+            for col_r in range(length):
+                if fabs(sums[head].real) < tol:
+                    sums[head].real = 0
+                if fabs(sums[head].imag) < tol:
+                    sums[head].imag = 0
+                if sums[head] != 0:
+                    out.col_index[nnz] = head
+                    out.data[nnz] = scale * sums[head]
+                    nnz += 1
+                tmp = head
+                head = nxt[head]
+                nxt[tmp] = -1
+                sums[tmp] = 0
+            out.row_index[row_l + 1] = nnz
+    mem.PyMem_Free(sums)
+    mem.PyMem_Free(nxt)
+    return out
+
+
+cpdef Dense matmul_csr_dense_dense(CSR left, Dense right,
+                                   double complex scale=1, Dense out=None):
+    """
+    Perform the operation
+        ``out := scale * (left @ right) + out``
+    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
+    defaulting to 1.
+
+    If `out` is not given, it will be allocated as if it were a zero matrix.
+    """
+    _check_shape(left, right, out)
+    cdef Dense tmp = None
+    if out is None:
+        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
+    if bool(right.fortran) != bool(out.fortran):
+        msg = (
+            "out matrix is {}-ordered".format('Fortran' if out.fortran else 'C')
+            + " but input is {}-ordered".format('Fortran' if right.fortran else 'C')
+        )
+        warnings.warn(msg, OrderEfficiencyWarning)
+        # Rather than making loads of copies of the same code, we just moan at
+        # the user and then transpose one of the arrays.  We prefer to have
+        # `right` in Fortran-order for cache efficiency.
+        if right.fortran:
+            tmp = out
+            out = out.reorder()
+        else:
+            right = right.reorder()
+    cdef idxint row, ptr, idx_r, idx_out, nrows=left.shape[0], ncols=right.shape[1]
+    cdef double complex val
+    if right.fortran:
+        idx_r = idx_out = 0
+        for _ in range(ncols):
+            _matmul_csr_vector(left.data, left.col_index, left.row_index,
+                               right.data + idx_r,
+                               scale,
+                               out.data + idx_out,
+                               nrows)
+            idx_out += nrows
+            idx_r += right.shape[0]
+    else:
+        for row in range(nrows):
+            for ptr in range(left.row_index[row], left.row_index[row + 1]):
+                val = scale * left.data[ptr]
+                idx_out = row * ncols
+                idx_r = left.col_index[ptr] * ncols
+                for _ in range(ncols):
+                    out.data[idx_out] += val * right.data[idx_r]
+                    idx_out += 1
+                    idx_r += 1
+    if tmp is None:
+        return out
+    memcpy(tmp.data, out.data, ncols * nrows * sizeof(double complex))
+    return tmp
+
+
+cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense out=None):
+    """
+    Perform the operation
+        ``out := scale * (left @ right) + out``
+    where `left`, `right` and `out` are matrices.  `scale` is a complex scalar,
+    defaulting to 1.
+
+    If `out` is not given, it will be allocated as if it were a zero matrix.
+    """
+    _check_shape(left, right, out)
+    cdef double complex out_scale
+    # If not supplied, it's more efficient from a memory allocation perspective
+    # to do the calculation as `a*A.B + 0*C` with arbitrary C.
+    if out is None:
+        out = dense.empty(left.shape[0], right.shape[1], right.fortran)
+        out_scale = 0
+    else:
+        out_scale = 1
+    cdef double complex *a
+    cdef double complex *b
+    cdef char transa, transb
+    cdef int m, n, k=left.shape[1], lda, ldb
+    if right.shape[1] == 1:
+        # Matrix Vector product
+        a, b = left.data, right.data
+        if left.fortran:
+            lda = left.shape[0]
+            transa = b'n'
+            m = left.shape[0]
+            n = left.shape[1]
+        else:
+            lda = left.shape[1]
+            transa = b't'
+            m = left.shape[1]
+            n = left.shape[0]
+        ldb = 1
+        blas.zgemv(&transa, &m , &n, &scale, a, &lda, b, &ldb,
+                   &out_scale, out.data, &ldb)
+        return out
+    # We use the BLAS routine zgemm for every single call and pretend that
+    # we're always supplying it with Fortran-ordered matrices, but to achieve
+    # what we want, we use the property of matrix multiplication that
+    #   A.B = (B'.A')'
+    # where ' is the matrix transpose, and that interpreting a Fortran-ordered
+    # matrix as a C-ordered one is equivalent to taking the transpose.  If
+    # `right` is supplied in C-order, then from Fortran's perspective we
+    # actually have `B'`, so to retrieve `B` should we want to use it, we set
+    # `transb = b't'`.  What we set `transa` and `transb` to depends on if we
+    # need to switch the input order, _not_ whether we actually need B'.
+    #
+    # In order to make the output correct, we ensure that we put A.B in if the
+    # output is Fortran ordered, or B'.A' (note no final transpose) if not.
+    # This is actually more flexible than `np.dot` which requires that the
+    # output is C-ordered.
+    if out.fortran:
+        # Need to make A.B
+        a, b = left.data, right.data
+        m, n = left.shape[0], right.shape[1]
+        lda = left.shape[0] if left.fortran else left.shape[1]
+        transa = b'n' if left.fortran else b't'
+        ldb = right.shape[0] if right.fortran else right.shape[1]
+        transb = b'n' if right.fortran else b't'
+    else:
+        # Need to make B'.A'
+        a, b = right.data, left.data
+        m, n = right.shape[1], left.shape[0]
+        lda = right.shape[0] if right.fortran else right.shape[1]
+        transa = b't' if right.fortran else b'n'
+        ldb = left.shape[0] if left.fortran else left.shape[1]
+        transb = b't' if left.fortran else b'n'
+    blas.zgemm(&transa, &transb, &m, &n, &k, &scale, a, &lda, b, &ldb,
+               &out_scale, out.data, &m)
+    return out
+
+
+cpdef CSR multiply_csr(CSR left, CSR right):
+    """Element-wise multiplication of CSR matrices."""
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    cdef idxint col_left, left_nnz = csr.nnz(left)
+    cdef idxint col_right, right_nnz = csr.nnz(right)
+    cdef idxint ptr_left, ptr_right, ptr_left_max, ptr_right_max
+    cdef idxint row, nnz=0, ncols=left.shape[1]
+    cdef CSR out
+    cdef list nans=[]
+    # Fast paths for zero matrices.
+    if right_nnz == 0 or left_nnz == 0:
+        return csr.zeros(left.shape[0], left.shape[1])
+    # Main path.
+    out = csr.empty(left.shape[0], left.shape[1], max(left_nnz, right_nnz))
+    out.row_index[0] = nnz
+    ptr_left_max = ptr_right_max = 0
+
+    for row in range(left.shape[0]):
+        ptr_left = ptr_left_max
+        ptr_left_max = left.row_index[row + 1]
+        ptr_right = ptr_right_max
+        ptr_right_max = right.row_index[row + 1]
+        while ptr_left < ptr_left_max or ptr_right < ptr_right_max:
+            col_left = left.col_index[ptr_left] if ptr_left < ptr_left_max else ncols + 1
+            col_right = right.col_index[ptr_right] if ptr_right < ptr_right_max else ncols + 1
+            if col_left == col_right:
+                out.col_index[nnz] = col_left
+                out.data[nnz] = left.data[ptr_left] * right.data[ptr_right]
+                ptr_left += 1
+                ptr_right += 1
+                nnz += 1
+            elif col_left <= col_right:
+                if left.data[ptr_left] is np.nan:
+                    # Test for NaN since `NaN * 0 = NaN`
+                    nans.append((row, col_left))
+                ptr_left += 1
+            else:
+                if right.data[ptr_right] != right.data[ptr_right]:
+                    nans.append((row, col_right))
+                ptr_right += 1
+        out.row_index[row + 1] = nnz
+    if nans:
+        # We expect Nan to be rare enough that we don't allocate memory for
+        # them, but add them here after the loop.
+        nans_pos = np.array(nans, order='F', dtype=idxint_dtype)
+        nnz = nans_pos.shape[0]
+        nans_csr = csr.from_coo_pointers(
+            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 0),
+            <idxint *> cnp.PyArray_GETPTR2(nans_pos, 0, 1),
+            <double complex *> cnp.PyArray_GETPTR1(
+                np.array([np.nan]*nnz, dtype=np.complex128), 0),
+            left.shape[0], left.shape[1], nnz
+        )
+        out = add_csr(out, nans_csr)
+    return out
+
+
+cpdef Dense multiply_dense(Dense left, Dense right):
+    """Element-wise multiplication of Dense matrices."""
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    return Dense(left.as_ndarray() * right.as_ndarray(), copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+# At the time of putting in the dispatchers, the idea of an "out" parameter
+# isn't really supported in the model; since `out` would be potentially
+# modified in-place, it couldn't safely go through a conversion process.  For
+# the dispatched operation, then, we omit the `scale` and `out` parameters, and
+# only dispatch on the operation `a @ b`.  If the `out` and `scale` parameters
+# are needed, the library will have to manually do any relevant conversions,
+# and then call a direct specialisation (which are exported to the `data`
+# namespace).
+
+matmul = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('scale', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='matmul',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+matmul.__doc__ =\
+    """
+    Compute the matrix multiplication of two matrices, with the operation
+        scale * (left @ right)
+    where `scale` is (optionally) a scalar, and `left` and `right` are
+    matrices.
+
+    Parameters
+    ----------
+    left : Data
+        The left operand as either a bra or a ket matrix.
+
+    right : Data
+        The right operand as a ket matrix.
+
+    scale : complex, optional
+        The scalar to multiply the output by.
+    """
+matmul.add_specialisations([
+    (CSR, CSR, CSR, matmul_csr),
+    (CSR, Dense, Dense, matmul_csr_dense_dense),
+    (Dense, Dense, Dense, matmul_dense),
+], _defer=True)
+
+
+multiply = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='multiply',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+multiply.__doc__ =\
+    """Element-wise multiplication of matrices."""
+multiply.add_specialisations([
+    (CSR, CSR, CSR, multiply_csr),
+    (Dense, Dense, Dense, multiply_dense),
+], _defer=True)
+
+
+del _inspect, _Dispatcher
+
+
+cdef Dense matmul_data_dense(Data left, Dense right):
+    cdef Dense out
+    if type(left) is CSR:
+        out = matmul_csr_dense_dense(left, right)
+    elif type(left) is Dense:
+        out = matmul_dense(left, right)
+    else:
+        out = matmul(left, right)
+    return out
+
+
+cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
+    if type(left) is CSR:
+        matmul_csr_dense_dense(left, right, scale, out)
+    elif type(left) is Dense:
+        matmul_dense(left, right, scale, out)
+    else:
+        iadd_dense(out, matmul(left, right), scale)
diff --git a/qutip/core/data/mul.pxd b/qutip/core/data/mul.pxd
index f935e1ee07..2c29259631 100644
--- a/qutip/core/data/mul.pxd
+++ b/qutip/core/data/mul.pxd
@@ -1,13 +1,13 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense, Data
-
-cpdef CSR imul_csr(CSR matrix, double complex value)
-cpdef CSR mul_csr(CSR matrix, double complex value)
-cpdef CSR neg_csr(CSR matrix)
-
-cpdef Dense imul_dense(Dense matrix, double complex value)
-cpdef Dense mul_dense(Dense matrix, double complex value)
-cpdef Dense neg_dense(Dense matrix)
-
-cpdef Data imul_data(Data matrix, double complex value)
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense, Data
+
+cpdef CSR imul_csr(CSR matrix, double complex value)
+cpdef CSR mul_csr(CSR matrix, double complex value)
+cpdef CSR neg_csr(CSR matrix)
+
+cpdef Dense imul_dense(Dense matrix, double complex value)
+cpdef Dense mul_dense(Dense matrix, double complex value)
+cpdef Dense neg_dense(Dense matrix)
+
+cpdef Data imul_data(Data matrix, double complex value)
diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 80928edee1..439c6cf694 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -1,134 +1,134 @@
-#cython: language_level=3
-#cython: boundscheck=False, wrapround=False, initializedcheck=False
-
-from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
-from scipy.linalg.cython_blas cimport zscal
-
-__all__ = [
-    'mul', 'mul_csr', 'mul_dense',
-    'imul', 'imul_csr', 'imul_dense', 'imul_data',
-    'neg', 'neg_csr', 'neg_dense',
-]
-
-
-cpdef CSR imul_csr(CSR matrix, double complex value):
-    """Multiply this CSR `matrix` by a complex scalar `value`."""
-    cdef idxint l = csr.nnz(matrix)
-    cdef int ONE=1
-    zscal(&l, &value, matrix.data, &ONE)
-    return matrix
-
-cpdef CSR mul_csr(CSR matrix, double complex value):
-    """Multiply this CSR `matrix` by a complex scalar `value`."""
-    if value == 0:
-        return csr.zeros(matrix.shape[0], matrix.shape[1])
-    cdef CSR out = csr.copy_structure(matrix)
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            out.data[ptr] = value * matrix.data[ptr]
-    return out
-
-cpdef CSR neg_csr(CSR matrix):
-    """Unary negation of this CSR `matrix`.  Return a new object."""
-    cdef CSR out = csr.copy_structure(matrix)
-    cdef idxint ptr
-    with nogil:
-        for ptr in range(csr.nnz(matrix)):
-            out.data[ptr] = -matrix.data[ptr]
-    return out
-
-
-cpdef Dense imul_dense(Dense matrix, double complex value):
-    """Multiply this Dense `matrix` by a complex scalar `value`."""
-    cdef size_t ptr
-    cdef int ONE=1
-    cdef idxint l = matrix.shape[0]*matrix.shape[1]
-    zscal(&l, &value, matrix.data, &ONE)
-    return matrix
-
-cpdef Dense mul_dense(Dense matrix, double complex value):
-    """Multiply this Dense `matrix` by a complex scalar `value`."""
-    cdef Dense out = dense.empty_like(matrix)
-    cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-            out.data[ptr] = value * matrix.data[ptr]
-    return out
-
-cpdef Dense neg_dense(Dense matrix):
-    """Unary negation of this Dense `matrix`.  Return a new object."""
-    cdef Dense out = dense.empty_like(matrix)
-    cdef size_t ptr
-    with nogil:
-        for ptr in range(matrix.shape[0]*matrix.shape[1]):
-            out.data[ptr] = -matrix.data[ptr]
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-mul = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='mul',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-mul.__doc__ =\
-    """Multiply a matrix element-wise by a scalar."""
-mul.add_specialisations([
-    (CSR, CSR, mul_csr),
-    (Dense, Dense, mul_dense),
-], _defer=True)
-
-imul = _Dispatcher(
-    # Will not be inplce if specialisation does not exist but should still
-    # give expected results if used as:
-    # mat = imul(mat, x)
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='imul',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-imul.__doc__ =\
-    """Multiply inplace a matrix element-wise by a scalar."""
-imul.add_specialisations([
-    (CSR, CSR, imul_csr),
-    (Dense, Dense, imul_dense),
-], _defer=True)
-
-neg = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='neg',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-neg.__doc__ =\
-    """Unary element-wise negation of a matrix."""
-neg.add_specialisations([
-    (CSR, CSR, neg_csr),
-    (Dense, Dense, neg_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
-
-
-cpdef Data imul_data(Data matrix, double complex value):
-    if type(matrix) is CSR:
-        return imul_csr(matrix, value)
-    elif type(matrix) is Dense:
-        return imul_dense(matrix, value)
-    else:
-        return imul(matrix, value)
+#cython: language_level=3
+#cython: boundscheck=False, wrapround=False, initializedcheck=False
+
+from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
+from scipy.linalg.cython_blas cimport zscal
+
+__all__ = [
+    'mul', 'mul_csr', 'mul_dense',
+    'imul', 'imul_csr', 'imul_dense', 'imul_data',
+    'neg', 'neg_csr', 'neg_dense',
+]
+
+
+cpdef CSR imul_csr(CSR matrix, double complex value):
+    """Multiply this CSR `matrix` by a complex scalar `value`."""
+    cdef idxint l = csr.nnz(matrix)
+    cdef int ONE=1
+    zscal(&l, &value, matrix.data, &ONE)
+    return matrix
+
+cpdef CSR mul_csr(CSR matrix, double complex value):
+    """Multiply this CSR `matrix` by a complex scalar `value`."""
+    if value == 0:
+        return csr.zeros(matrix.shape[0], matrix.shape[1])
+    cdef CSR out = csr.copy_structure(matrix)
+    cdef idxint ptr
+    with nogil:
+        for ptr in range(csr.nnz(matrix)):
+            out.data[ptr] = value * matrix.data[ptr]
+    return out
+
+cpdef CSR neg_csr(CSR matrix):
+    """Unary negation of this CSR `matrix`.  Return a new object."""
+    cdef CSR out = csr.copy_structure(matrix)
+    cdef idxint ptr
+    with nogil:
+        for ptr in range(csr.nnz(matrix)):
+            out.data[ptr] = -matrix.data[ptr]
+    return out
+
+
+cpdef Dense imul_dense(Dense matrix, double complex value):
+    """Multiply this Dense `matrix` by a complex scalar `value`."""
+    cdef size_t ptr
+    cdef int ONE=1
+    cdef idxint l = matrix.shape[0]*matrix.shape[1]
+    zscal(&l, &value, matrix.data, &ONE)
+    return matrix
+
+cpdef Dense mul_dense(Dense matrix, double complex value):
+    """Multiply this Dense `matrix` by a complex scalar `value`."""
+    cdef Dense out = dense.empty_like(matrix)
+    cdef size_t ptr
+    with nogil:
+        for ptr in range(matrix.shape[0]*matrix.shape[1]):
+            out.data[ptr] = value * matrix.data[ptr]
+    return out
+
+cpdef Dense neg_dense(Dense matrix):
+    """Unary negation of this Dense `matrix`.  Return a new object."""
+    cdef Dense out = dense.empty_like(matrix)
+    cdef size_t ptr
+    with nogil:
+        for ptr in range(matrix.shape[0]*matrix.shape[1]):
+            out.data[ptr] = -matrix.data[ptr]
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+mul = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='mul',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+mul.__doc__ =\
+    """Multiply a matrix element-wise by a scalar."""
+mul.add_specialisations([
+    (CSR, CSR, mul_csr),
+    (Dense, Dense, mul_dense),
+], _defer=True)
+
+imul = _Dispatcher(
+    # Will not be inplce if specialisation does not exist but should still
+    # give expected results if used as:
+    # mat = imul(mat, x)
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('value', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='imul',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+imul.__doc__ =\
+    """Multiply inplace a matrix element-wise by a scalar."""
+imul.add_specialisations([
+    (CSR, CSR, imul_csr),
+    (Dense, Dense, imul_dense),
+], _defer=True)
+
+neg = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='neg',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+neg.__doc__ =\
+    """Unary element-wise negation of a matrix."""
+neg.add_specialisations([
+    (CSR, CSR, neg_csr),
+    (Dense, Dense, neg_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
+
+
+cpdef Data imul_data(Data matrix, double complex value):
+    if type(matrix) is CSR:
+        return imul_csr(matrix, value)
+    elif type(matrix) is Dense:
+        return imul_dense(matrix, value)
+    else:
+        return imul(matrix, value)
diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
index 560d163e28..5e1b7ebe0d 100644
--- a/qutip/core/data/norm.pxd
+++ b/qutip/core/data/norm.pxd
@@ -1,15 +1,15 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data cimport CSR, Dense, Data
-
-cpdef double one_csr(CSR matrix) except -1
-cpdef double trace_csr(CSR matrix) except -1
-cpdef double max_csr(CSR matrix) nogil
-cpdef double frobenius_csr(CSR matrix) nogil
-cpdef double l2_csr(CSR matrix) nogil except -1
-
-cpdef double frobenius_dense(Dense matrix) nogil
-cpdef double l2_dense(Dense matrix) nogil except -1
-
-cpdef double frobenius_data(Data state)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data cimport CSR, Dense, Data
+
+cpdef double one_csr(CSR matrix) except -1
+cpdef double trace_csr(CSR matrix) except -1
+cpdef double max_csr(CSR matrix) nogil
+cpdef double frobenius_csr(CSR matrix) nogil
+cpdef double l2_csr(CSR matrix) nogil except -1
+
+cpdef double frobenius_dense(Dense matrix) nogil
+cpdef double l2_dense(Dense matrix) nogil except -1
+
+cpdef double frobenius_data(Data state)
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 40f15837c0..998d49d1d2 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -1,229 +1,229 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc cimport math
-
-from cpython cimport mem
-
-from scipy.linalg cimport cython_blas as blas
-import scipy
-
-from qutip.core.data cimport CSR, Dense, csr, dense, Data
-
-from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
-from qutip.core.data.matmul cimport matmul_csr
-
-from qutip.core.data import eigs_csr, eigs_dense
-
-cdef extern from *:
-    # Not included in Cython for some reason?
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-cdef extern from "<complex>" namespace "std" nogil:
-    # abs is templated such that Cython treats std::abs as complex->complex
-    double abs(double complex x)
-
-cdef double abssq(double complex x) nogil:
-    return x.real*x.real + x.imag*x.imag
-
-# We always use BLAS routines where possible because architecture-specific
-# libraries will typically apply vectorised operations for us.
-
-# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
-__all__ = []
-
-cpdef double one_csr(CSR matrix) except -1:
-    cdef int n=matrix.shape[1], inc=1
-    cdef size_t ptr
-    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
-    try:
-        for ptr in range(csr.nnz(matrix)):
-            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
-        # BLAS is a Fortran library, so it's one-indexed of course...
-        return col[blas.idamax(&n, col, &inc) - 1]
-    finally:
-        mem.PyMem_Free(col)
-
-
-cpdef double trace_dense(Dense matrix) except -1:
-    """Compute the trace norm relaying scipy for dense operations."""
-    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
-
-
-cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
-    """Compute the trace norm using only sparse operations. These consist
-    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
-    their square roots."""
-    # For column and row vectors we simply use the l2 norm as it is equivalent
-    # to the trace norm.
-    if matrix.shape[0]==1 or matrix.shape[1]==1:
-        return l2_csr(matrix)
-
-    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
-    cdef size_t i
-    cdef double [::1] eigs
-
-    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
-
-    cdef double total = 0
-    for i in range(matrix.shape[0]):
-        # The abs is technically not part of the definition, but since all
-        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
-        # which are lower will just be ~1e-15 due to numerical approximations.
-        total += math.sqrt(abs(eigs[i]))
-    return total
-
-
-cpdef double max_csr(CSR matrix) nogil:
-    cdef size_t ptr
-    cdef double total=0, cur
-    for ptr in range(csr.nnz(matrix)):
-        # The positive square root is monotonic over positive reals, so we can
-        # find the maximum value by considering the abs squared (which doesn't
-        # require a sqrt) rather than the abs(which does), and then perform
-        # only a single sqrt at the end.
-        cur = abssq(matrix.data[ptr])
-        total = cur if cur > total else total
-    return math.sqrt(total)
-
-cpdef double frobenius_csr(CSR matrix) nogil:
-    # The Frobenius norm is effectively the same as the L2 norm when
-    # considering the non-zero elements as a vector.
-    cdef int n=csr.nnz(matrix), inc=1
-    return blas.dznrm2(&n, &matrix.data[0], &inc)
-
-cpdef double l2_csr(CSR matrix) nogil except -1:
-    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
-        raise ValueError("L2 norm is only defined on vectors")
-    return frobenius_csr(matrix)
-
-cpdef double one_dense(Dense matrix) nogil:
-    cdef size_t ptr, col, row, col_stride, row_stride
-    cdef double out=0, cur
-    col_stride = matrix.shape[0] if matrix.fortran else 1
-    row_stride = 1 if matrix.fortran else matrix.shape[1]
-    for col in range(matrix.shape[1]):
-        ptr = col * col_stride
-        cur = 0
-        for row in range(matrix.shape[0]):
-            cur += abs(matrix.data[ptr])
-            ptr += row_stride
-        out = cur if cur > out else out
-    return out
-
-cpdef double max_dense(Dense matrix) nogil:
-    cdef size_t ptr
-    cdef double total=0, cur
-    for ptr in range(matrix.shape[0] * matrix.shape[1]):
-        # The positive square root is monotonic over positive reals, so we can
-        # find the maximum value by considering the abs squared (which doesn't
-        # require a sqrt) rather than the abs(which does), and then perform
-        # only a single sqrt at the end.
-        cur = abssq(matrix.data[ptr])
-        total = cur if cur > total else total
-    return math.sqrt(total)
-
-cpdef double frobenius_dense(Dense matrix) nogil:
-    cdef int n = matrix.shape[0] * matrix.shape[1]
-    cdef int inc = 1
-    return blas.dznrm2(&n, matrix.data, &inc)
-
-cpdef double l2_dense(Dense matrix) nogil except -1:
-    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
-        raise ValueError("L2 norm is only defined on vectors")
-    return frobenius_dense(matrix)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-l2 = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='l2',
-    module=__name__,
-    inputs=('vector',),
-)
-l2.__doc__ =\
-    """
-    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
-        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
-    This is only defined for vectors, but see `norm.frobenius` for the similar
-    norm defined on all matrices.
-    """
-l2.add_specialisations([
-    (Dense, l2_dense),
-    (CSR, l2_csr),
-], _defer=True)
-
-_norm_signature = _inspect.Signature([
-    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-])
-
-frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
-frobenius.__doc__ =\
-    """
-    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
-    as the
-        sqrt(sum_i sum_j |matrix[i, j]|**2)
-    and is similar to an extension of the vector L2 norm to all matrices.
-    """
-frobenius.add_specialisations([
-    (Dense, frobenius_dense),
-    (CSR, frobenius_csr),
-], _defer=True)
-
-max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
-max.__doc__ =\
-    """
-    Compute the max norm of a matrix.  This is the largest absolute value of an
-    entry in the matrix, or mathematically
-        max_{i,j} |matrix[i, j]|
-    """
-max.add_specialisations([
-    (Dense, max_dense),
-    (CSR, max_csr),
-], _defer=True)
-
-one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
-one.__doc__ =\
-    """
-    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
-    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
-    the sum of the absolute values.
-    """
-one.add_specialisations([
-    (Dense, one_dense),
-    (CSR, one_csr),
-], _defer=True)
-
-
-trace = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    inputs=('matrix',),
-    name='trace',
-    module=__name__,
-    out=False,
-)
-trace.__doc__ =\
-    """
-    Compute the trace-norm of a matrix.  This is the sum of the singular values
-    of the matrix, or equivalently
-        Tr(sqrt(A @ A.adjoint()))
-    """
-trace.add_specialisations([
-    (CSR, trace_csr),
-    (Dense, trace_dense),
-], _defer=True)
-
-
-cpdef double frobenius_data(Data state):
-    if type(state) is Dense:
-        return frobenius_dense(state)
-    elif type(state) is CSR:
-        return frobenius_csr(state)
-    else:
-        return frobenius(state)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc cimport math
+
+from cpython cimport mem
+
+from scipy.linalg cimport cython_blas as blas
+import scipy
+
+from qutip.core.data cimport CSR, Dense, csr, dense, Data
+
+from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
+from qutip.core.data.matmul cimport matmul_csr
+
+from qutip.core.data import eigs_csr, eigs_dense
+
+cdef extern from *:
+    # Not included in Cython for some reason?
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+cdef extern from "<complex>" namespace "std" nogil:
+    # abs is templated such that Cython treats std::abs as complex->complex
+    double abs(double complex x)
+
+cdef double abssq(double complex x) nogil:
+    return x.real*x.real + x.imag*x.imag
+
+# We always use BLAS routines where possible because architecture-specific
+# libraries will typically apply vectorised operations for us.
+
+# This module is meant to be accessed by dot-access (e.g. norm.one_csr).
+__all__ = []
+
+cpdef double one_csr(CSR matrix) except -1:
+    cdef int n=matrix.shape[1], inc=1
+    cdef size_t ptr
+    cdef double *col = <double *> PyMem_Calloc(matrix.shape[1], sizeof(double))
+    try:
+        for ptr in range(csr.nnz(matrix)):
+            col[matrix.col_index[ptr]] += abs(matrix.data[ptr])
+        # BLAS is a Fortran library, so it's one-indexed of course...
+        return col[blas.idamax(&n, col, &inc) - 1]
+    finally:
+        mem.PyMem_Free(col)
+
+
+cpdef double trace_dense(Dense matrix) except -1:
+    """Compute the trace norm relaying scipy for dense operations."""
+    return scipy.linalg.norm(matrix.as_ndarray(), 'nuc')
+
+
+cpdef double trace_csr(CSR matrix, tol=0, maxiter=None) except -1:
+    """Compute the trace norm using only sparse operations. These consist
+    of determining the eigenvalues of `matrix @ matrix.adjoint()` and summing
+    their square roots."""
+    # For column and row vectors we simply use the l2 norm as it is equivalent
+    # to the trace norm.
+    if matrix.shape[0]==1 or matrix.shape[1]==1:
+        return l2_csr(matrix)
+
+    cdef CSR op = matmul_csr(matrix, adjoint_csr(matrix))
+    cdef size_t i
+    cdef double [::1] eigs
+
+    eigs = eigs_csr(op, isherm=True, vecs=False, tol=tol, maxiter=maxiter)
+
+    cdef double total = 0
+    for i in range(matrix.shape[0]):
+        # The abs is technically not part of the definition, but since all
+        # eigenvalues _should_ be > 0 (as X @ X.adjoint() is Hermitian), any
+        # which are lower will just be ~1e-15 due to numerical approximations.
+        total += math.sqrt(abs(eigs[i]))
+    return total
+
+
+cpdef double max_csr(CSR matrix) nogil:
+    cdef size_t ptr
+    cdef double total=0, cur
+    for ptr in range(csr.nnz(matrix)):
+        # The positive square root is monotonic over positive reals, so we can
+        # find the maximum value by considering the abs squared (which doesn't
+        # require a sqrt) rather than the abs(which does), and then perform
+        # only a single sqrt at the end.
+        cur = abssq(matrix.data[ptr])
+        total = cur if cur > total else total
+    return math.sqrt(total)
+
+cpdef double frobenius_csr(CSR matrix) nogil:
+    # The Frobenius norm is effectively the same as the L2 norm when
+    # considering the non-zero elements as a vector.
+    cdef int n=csr.nnz(matrix), inc=1
+    return blas.dznrm2(&n, &matrix.data[0], &inc)
+
+cpdef double l2_csr(CSR matrix) nogil except -1:
+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+        raise ValueError("L2 norm is only defined on vectors")
+    return frobenius_csr(matrix)
+
+cpdef double one_dense(Dense matrix) nogil:
+    cdef size_t ptr, col, row, col_stride, row_stride
+    cdef double out=0, cur
+    col_stride = matrix.shape[0] if matrix.fortran else 1
+    row_stride = 1 if matrix.fortran else matrix.shape[1]
+    for col in range(matrix.shape[1]):
+        ptr = col * col_stride
+        cur = 0
+        for row in range(matrix.shape[0]):
+            cur += abs(matrix.data[ptr])
+            ptr += row_stride
+        out = cur if cur > out else out
+    return out
+
+cpdef double max_dense(Dense matrix) nogil:
+    cdef size_t ptr
+    cdef double total=0, cur
+    for ptr in range(matrix.shape[0] * matrix.shape[1]):
+        # The positive square root is monotonic over positive reals, so we can
+        # find the maximum value by considering the abs squared (which doesn't
+        # require a sqrt) rather than the abs(which does), and then perform
+        # only a single sqrt at the end.
+        cur = abssq(matrix.data[ptr])
+        total = cur if cur > total else total
+    return math.sqrt(total)
+
+cpdef double frobenius_dense(Dense matrix) nogil:
+    cdef int n = matrix.shape[0] * matrix.shape[1]
+    cdef int inc = 1
+    return blas.dznrm2(&n, matrix.data, &inc)
+
+cpdef double l2_dense(Dense matrix) nogil except -1:
+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+        raise ValueError("L2 norm is only defined on vectors")
+    return frobenius_dense(matrix)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+l2 = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('vector', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='l2',
+    module=__name__,
+    inputs=('vector',),
+)
+l2.__doc__ =\
+    """
+    Compute the L2 (Euclidean) norm of a bra or ket vector.  This is equal to
+        sqrt(|v[0]|**2 + |v[1]|**2 + ...)
+    This is only defined for vectors, but see `norm.frobenius` for the similar
+    norm defined on all matrices.
+    """
+l2.add_specialisations([
+    (Dense, l2_dense),
+    (CSR, l2_csr),
+], _defer=True)
+
+_norm_signature = _inspect.Signature([
+    _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+])
+
+frobenius = _Dispatcher(_norm_signature, name='frobenius', module=__name__, inputs=('matrix',))
+frobenius.__doc__ =\
+    """
+    Compute the Frobenius (Hilbert-Schmidt) norm of a matrix.  This is defined
+    as the
+        sqrt(sum_i sum_j |matrix[i, j]|**2)
+    and is similar to an extension of the vector L2 norm to all matrices.
+    """
+frobenius.add_specialisations([
+    (Dense, frobenius_dense),
+    (CSR, frobenius_csr),
+], _defer=True)
+
+max = _Dispatcher(_norm_signature, name='max', module=__name__, inputs=('matrix',))
+max.__doc__ =\
+    """
+    Compute the max norm of a matrix.  This is the largest absolute value of an
+    entry in the matrix, or mathematically
+        max_{i,j} |matrix[i, j]|
+    """
+max.add_specialisations([
+    (Dense, max_dense),
+    (CSR, max_csr),
+], _defer=True)
+
+one = _Dispatcher(_norm_signature, name='one', module=__name__, inputs=('matrix',))
+one.__doc__ =\
+    """
+    Compute the one-norm (L1--L1) norm of a matrix.  This is the value of the
+    largest L1 norm of a column in the matrix, where the L1 norm of a vector is
+    the sum of the absolute values.
+    """
+one.add_specialisations([
+    (Dense, one_dense),
+    (CSR, one_csr),
+], _defer=True)
+
+
+trace = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    inputs=('matrix',),
+    name='trace',
+    module=__name__,
+    out=False,
+)
+trace.__doc__ =\
+    """
+    Compute the trace-norm of a matrix.  This is the sum of the singular values
+    of the matrix, or equivalently
+        Tr(sqrt(A @ A.adjoint()))
+    """
+trace.add_specialisations([
+    (CSR, trace_csr),
+    (Dense, trace_dense),
+], _defer=True)
+
+
+cpdef double frobenius_data(Data state):
+    if type(state) is Dense:
+        return frobenius_dense(state)
+    elif type(state) is CSR:
+        return frobenius_csr(state)
+    else:
+        return frobenius(state)
diff --git a/qutip/core/data/permute.pxd b/qutip/core/data/permute.pxd
index 422be089a7..1ac9a33500 100644
--- a/qutip/core/data/permute.pxd
+++ b/qutip/core/data/permute.pxd
@@ -1,7 +1,7 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
-cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR indices_csr(CSR matrix, object row_perm=*, object col_perm=*)
+cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order)
diff --git a/qutip/core/data/permute.pyx b/qutip/core/data/permute.pyx
index 4e08fa74e9..72f44af2af 100644
--- a/qutip/core/data/permute.pyx
+++ b/qutip/core/data/permute.pyx
@@ -1,405 +1,405 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-
-from libcpp cimport bool
-from libcpp.algorithm cimport sort
-
-cimport cython
-
-from cpython cimport mem
-
-import numpy as np
-cimport numpy as cnp
-
-from qutip.core.data.base cimport idxint, idxint_DTYPE
-from qutip.core.data cimport csr, dense, CSR, Dense
-
-from qutip.core.data.base import idxint_dtype
-
-cnp.import_array()
-
-cdef extern from *:
-    void *PyMem_Calloc(size_t n, size_t elsize)
-
-# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
-__all__ = []
-
-
-cdef class _Indexer:
-    cdef size_t ndims, size
-    cdef readonly cnp.ndarray new_dimensions
-    cdef idxint[:] dimensions
-    cdef idxint *cumprod
-
-    def __init__(self, idxint[:] dimensions, idxint[:] order):
-        cdef size_t i
-        cdef idxint dim, ord
-        cdef idxint prev
-        self.ndims = dimensions.shape[0]
-        self.dimensions = dimensions
-        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
-        cdef idxint[:] new_dimensions = self.new_dimensions
-        if order.shape[0] != self.ndims:
-            raise ValueError("invalid order: wrong number of elements")
-        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
-        try:
-            for i in range(self.ndims):
-                ord = order[i]
-                if ord < 0 or ord >= self.ndims:
-                    raise ValueError("invalid order element: " + str(ord))
-                if tmp[ord]:
-                    raise ValueError("duplicate order element: " + str(ord))
-                tmp[ord] = True
-                dim = self.dimensions[ord]
-                if dim < 0:
-                    raise ValueError("found negative dimension: " + str(dim))
-                elif dim == 0:
-                    raise ValueError("found zero dimension")
-                new_dimensions[i] = dim
-        finally:
-            mem.PyMem_Free(tmp)
-        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
-        prev = self.cumprod[order[self.ndims - 1]] = 1
-        for i in range(self.ndims - 2, -1, -1):
-            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
-        self.size = self.cumprod[order[0]] * new_dimensions[0]
-
-    @cython.cdivision(True)
-    cdef cnp.ndarray all(self):
-        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
-        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
-        cdef idxint i
-        for i in range(self.size):
-            _out[i] = self.single(i)
-        return out
-
-    @cython.cdivision(True)
-    cdef idxint single(self, idxint idx) nogil:
-        cdef size_t i
-        cdef idxint out=0, dim
-        for i in range(self.ndims - 1, -1, -1):
-            dim = self.dimensions[i]
-            # Dimensions cannot be zero due to the check in __init__.
-            out += self.cumprod[i] * (idx % dim)
-            idx //= dim
-            if idx == 0:
-                break
-        return out
-
-    def __dealloc__(self):
-        if self.cumprod != NULL:
-            mem.PyMem_Free(self.cumprod)
-
-cdef bint _check_indices(size_t size, idxint[:] order) except True:
-    """
-    Test whether the permutation `order` is a valid permutation of `size`
-    number of elements.  This is functionally equivalent to
-
-    ```
-    if np.sort(order) != np.arange(size):
-        raise ValueError
-    return False
-    ```
-
-    In other words, we test that each integer on [0, size) is present exactly
-    once in `order`, and raise ValueError if that is not the case (returns True
-    if an error is detected, and False if not to help pure Cython avoiding
-    exceptions).
-    """
-    if order.shape[0] != size:
-        raise ValueError("invalid permutation: wrong number of elements")
-    cdef size_t ptr
-    cdef idxint value
-    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
-    if test == NULL:
-        raise MemoryError
-    try:
-        for ptr in range(size):
-            value = order[ptr]
-            if not 0 <= value < size:
-                raise ValueError("invalid entry in permutation: " + str(value))
-            if test[value]:
-                raise ValueError("duplicate entry in permutation: " + str(value))
-            test[value] = True
-        return False
-    finally:
-        mem.PyMem_Free(test)
-
-cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
-    cdef size_t n_rows=matrix.shape[0]
-    _check_indices(n_rows, rows)
-    cdef CSR out = csr.empty_like(matrix)
-    cdef size_t row, ptr_in, ptr_out, len
-    out.row_index[0] = 0
-    for row in range(matrix.shape[0]):
-        out.row_index[rows[row] + 1] =\
-            matrix.row_index[row + 1] - matrix.row_index[row]
-    for row in range(matrix.shape[0]):
-        out.row_index[row + 1] += out.row_index[row]
-    for row in range(matrix.shape[0]):
-        ptr_in = matrix.row_index[row]
-        ptr_out = out.row_index[rows[row]]
-        len = matrix.row_index[row + 1] - ptr_in
-        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
-        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
-    return out
-
-cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
-    _check_indices(matrix.shape[0], rows)
-    _check_indices(matrix.shape[1], cols)
-    cdef CSR out = csr.empty_like(matrix)
-    cdef size_t row, ptr_in, ptr_out, len, n
-    # First build up the row index structure by cumulative sum, so we know
-    # where to place the data and column indices.  We also use this opportunity
-    # to find the maximum number of non-zero elements in a row.
-    with nogil:
-        len = 0
-        out.row_index[0] = 0
-        for row in range(matrix.shape[0]):
-            n = matrix.row_index[row + 1] - matrix.row_index[row]
-            out.row_index[rows[row] + 1] = n
-            len = n if n > len else len
-        for row in range(matrix.shape[0]):
-            out.row_index[row + 1] += out.row_index[row]
-    # Now we know that `len` is the most number of non-zero elements in a row,
-    # so we can allocate space to sort only once.
-    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
-    cdef csr.Sorter sort = csr.Sorter(len)
-    for row in range(matrix.shape[0]):
-        ptr_in = matrix.row_index[row]
-        ptr_out = out.row_index[rows[row]]
-        len = matrix.row_index[row + 1] - ptr_in
-        for n in range(len):
-            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
-        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
-                  &matrix.data[ptr_in], new_cols,
-                  len)
-    mem.PyMem_Free(new_cols)
-    return out
-
-cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
-    if row_perm is None and col_perm is None:
-        return matrix.copy()
-    if col_perm is None:
-        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
-    cdef idxint *rows = NULL
-    cdef idxint n
-    if row_perm is None:
-        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
-        for n in range(matrix.shape[0]):
-            rows[n] = n
-        try:
-            return _indices_csr_full(matrix,
-                                     <idxint [:matrix.shape[0]]>rows,
-                                     np.asarray(col_perm, dtype=idxint_dtype))
-        finally:
-            mem.PyMem_Free(rows)
-    return _indices_csr_full(matrix,
-                             np.asarray(row_perm, dtype=idxint_dtype),
-                             np.asarray(col_perm, dtype=idxint_dtype))
-
-cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
-    if row_perm is None and col_perm is None:
-        return matrix.copy()
-    array = matrix.as_ndarray()
-    if row_perm is not None:
-        array = array[np.argsort(row_perm), :]
-    if col_perm is not None:
-        array = array[:, np.argsort(col_perm)]
-    return Dense(array)
-
-
-cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
-    if matrix.shape[0] != 1:
-        raise ValueError("expected bra-like matrix")
-    cdef size_t nnz = csr.nnz(matrix)
-    cdef CSR out = csr.empty_like(matrix)
-    out.row_index[0] = 0
-    out.row_index[1] = nnz
-    cdef size_t n
-    cdef csr.Sorter sort = csr.Sorter(nnz)
-    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
-    try:
-        for n in range(nnz):
-            new_cols[n] = index.single(matrix.col_index[n])
-        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
-        return out
-    finally:
-        mem.PyMem_Free(new_cols)
-
-cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
-    cdef CSR out = csr.empty_like(matrix)
-    cdef csr.Sorter sort
-    cdef size_t row, n, len=0
-    cdef idxint ptr_in, ptr_out, col
-    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
-    try:
-        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
-        with nogil:
-            for row in range(matrix.shape[0]):
-                n = matrix.row_index[row + 1] - matrix.row_index[row]
-                if n:
-                    idx_lookup[row] = index.single(row)
-                    out.row_index[idx_lookup[row] + 1] = n
-                    len = n if n > len else len
-                else:
-                    # Use a sentinel value so we can avoid looking up columns
-                    # that we already know about later.  Not all values in
-                    # idx_lookup will even be filled---this is the speed up
-                    # this function achieves over `_indices_csr_all`.
-                    idx_lookup[row] = -1
-            for row in range(matrix.shape[0]):
-                out.row_index[row + 1] += out.row_index[row]
-        # Since this is very sparse, we expect almost all rows to have at most two
-        # elements in them.  It will be faster to copy them across, and perform the
-        # sort in place rather than allocating temporary space and making an
-        # additional copy.  This will still work even if there are more in a row,
-        # it just won't be quite as efficient in that case (which should be rare).
-        sort = csr.Sorter(len)
-        for row in range(matrix.shape[0]):
-            ptr_in = matrix.row_index[row]
-            len = matrix.row_index[row + 1] - ptr_in
-            if len == 0:
-                continue
-            ptr_out = out.row_index[idx_lookup[row]]
-            for n in range(len):
-                col = matrix.col_index[ptr_in + n]
-                if idx_lookup[col] == -1:
-                    idx_lookup[col] = index.single(col)
-                out.col_index[ptr_out + n] = idx_lookup[col]
-            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
-            sort.inplace(out, ptr_out, len)
-        return out
-    finally:
-        mem.PyMem_Free(idx_lookup)
-
-@cython.cdivision(True)
-cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
-    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
-                                   np.asarray(order, dtype=idxint_dtype))
-    cdef idxint[:] permutation
-    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
-        return matrix.copy()
-    if matrix.shape[0] == 1:
-        return _dimensions_csr_columns(matrix, index)
-    if matrix.shape[1] == 1:
-        return _indices_csr_rowonly(matrix, index.all())
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("dimensional permute requires square operators")
-    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
-    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
-    # calls to `index.single()` than the matrix dimension.  To be sure of this,
-    # we actually require the density per row to be less than 1/2, because we
-    # have to look up both the row _and_ column on output.  This only
-    # corresponds to exceptionally sparse matrices.  We try to avoid these
-    # calls because index.single has ~logarithmic complexity in the dimension
-    # (so for qubit systems it's linear in the number of qubits), and
-    # consequently `index.all()` is a hidden quadratic complexity.
-    if row_density >= 0.5:
-        permutation = index.all()
-        return _indices_csr_full(matrix, permutation, permutation)
-    return _dimensions_csr_sparse(matrix, index)
-
-@cython.cdivision(True)
-cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
-    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
-                                   np.asarray(order, dtype=idxint_dtype))
-    cdef idxint[:] permutation = index.all()
-    row_perm, col_perm = None, None
-    if matrix.shape[0] != 1:
-        row_perm = permutation
-    if matrix.shape[1] != 1:
-        col_perm = permutation
-    return indices_dense(matrix, row_perm, col_perm)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-dimensions = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='dimensions',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-dimensions.__doc__ =\
-    """
-    Reorder the tensor-product structure of a matrix, assuming that the
-    underlying structure is defined by `dimensions`.  For a separable system,
-    this function produces a matrix which is equivalent to having performed
-    `kron` in a different order on the separable parts.
-
-    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
-    respectively, then
-        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
-                                                  [2, 3, 4],
-                                                  [1, 2, 0])
-    In other words, the inputs to `kron` are reordered so that input `n` moves
-    to position `order[n]`.
-
-    Parameters
-    ----------
-    matrix : Data
-        Input matrix to reorder.  This can either be a square matrix
-        representing an operator, or a bra- or ket-like vector.
-
-    dimensions : 1D array_like of integers
-        The tensor-product structure of the space the matrix lives on.  This
-        will typically be one of the two elements of `Qobj.dims` (e.g. for a
-        ket, it will be `Qobj.dims[0]`).
-
-    order : 1D array_like of integers
-        The new order of the tensor-product elements.  This should be a 1D list
-        with the integers from `0` to `N - 1` inclusive, if there are `N`
-        elements in the tensor product.
-    """
-dimensions.add_specialisations([
-    (CSR, CSR, dimensions_csr),
-    (Dense, Dense, dimensions_dense),
-], _defer=True)
-
-indices = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=None),
-        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=None),
-    ]),
-    name='indices',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-indices.__doc__ =\
-    """
-    Permute the rows and columns of a matrix according to a row and column
-    permutation.  This is a "dumb" operation with regards to the representation
-    of quantum states; if you want to "reorder" the tensor-product structure of
-    a system, you want `permute.dimensions` instead.
-
-    Parameters
-    ----------
-    matrix : Data
-        The input matrix.
-
-    row_perm, col_perm : 1D array_like of integer, optional
-        The new order that the rows or columns should be shuffled into.  If the
-        input matrix is `N x M`, then `row_perm` would be an array containing
-        all the integers from `0` to `N - 1` inclusive in some new order.  Row
-        `n` in the input will be at row `row_perm[n]` in the output, and
-        similar for the column permutation.
-    """
-indices.add_specialisations([
-    (CSR, CSR, indices_csr),
-    (Dense, Dense, indices_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+
+from libcpp cimport bool
+from libcpp.algorithm cimport sort
+
+cimport cython
+
+from cpython cimport mem
+
+import numpy as np
+cimport numpy as cnp
+
+from qutip.core.data.base cimport idxint, idxint_DTYPE
+from qutip.core.data cimport csr, dense, CSR, Dense
+
+from qutip.core.data.base import idxint_dtype
+
+cnp.import_array()
+
+cdef extern from *:
+    void *PyMem_Calloc(size_t n, size_t elsize)
+
+# This module is meant to be used with dot-access (e.g. `permute.dimensions`).
+__all__ = []
+
+
+cdef class _Indexer:
+    cdef size_t ndims, size
+    cdef readonly cnp.ndarray new_dimensions
+    cdef idxint[:] dimensions
+    cdef idxint *cumprod
+
+    def __init__(self, idxint[:] dimensions, idxint[:] order):
+        cdef size_t i
+        cdef idxint dim, ord
+        cdef idxint prev
+        self.ndims = dimensions.shape[0]
+        self.dimensions = dimensions
+        self.new_dimensions = cnp.PyArray_EMPTY(1, [self.ndims], idxint_DTYPE, False)
+        cdef idxint[:] new_dimensions = self.new_dimensions
+        if order.shape[0] != self.ndims:
+            raise ValueError("invalid order: wrong number of elements")
+        cdef bint *tmp = <bint *> PyMem_Calloc(self.ndims, sizeof(bint))
+        try:
+            for i in range(self.ndims):
+                ord = order[i]
+                if ord < 0 or ord >= self.ndims:
+                    raise ValueError("invalid order element: " + str(ord))
+                if tmp[ord]:
+                    raise ValueError("duplicate order element: " + str(ord))
+                tmp[ord] = True
+                dim = self.dimensions[ord]
+                if dim < 0:
+                    raise ValueError("found negative dimension: " + str(dim))
+                elif dim == 0:
+                    raise ValueError("found zero dimension")
+                new_dimensions[i] = dim
+        finally:
+            mem.PyMem_Free(tmp)
+        self.cumprod = <idxint *> mem.PyMem_Malloc(self.ndims * sizeof(idxint))
+        prev = self.cumprod[order[self.ndims - 1]] = 1
+        for i in range(self.ndims - 2, -1, -1):
+            prev = self.cumprod[order[i]] = prev * new_dimensions[i + 1]
+        self.size = self.cumprod[order[0]] * new_dimensions[0]
+
+    @cython.cdivision(True)
+    cdef cnp.ndarray all(self):
+        cdef object out = cnp.PyArray_EMPTY(1, [self.size], idxint_DTYPE, False)
+        cdef idxint *_out = <idxint *> cnp.PyArray_GETPTR1(out, 0)
+        cdef idxint i
+        for i in range(self.size):
+            _out[i] = self.single(i)
+        return out
+
+    @cython.cdivision(True)
+    cdef idxint single(self, idxint idx) nogil:
+        cdef size_t i
+        cdef idxint out=0, dim
+        for i in range(self.ndims - 1, -1, -1):
+            dim = self.dimensions[i]
+            # Dimensions cannot be zero due to the check in __init__.
+            out += self.cumprod[i] * (idx % dim)
+            idx //= dim
+            if idx == 0:
+                break
+        return out
+
+    def __dealloc__(self):
+        if self.cumprod != NULL:
+            mem.PyMem_Free(self.cumprod)
+
+cdef bint _check_indices(size_t size, idxint[:] order) except True:
+    """
+    Test whether the permutation `order` is a valid permutation of `size`
+    number of elements.  This is functionally equivalent to
+
+    ```
+    if np.sort(order) != np.arange(size):
+        raise ValueError
+    return False
+    ```
+
+    In other words, we test that each integer on [0, size) is present exactly
+    once in `order`, and raise ValueError if that is not the case (returns True
+    if an error is detected, and False if not to help pure Cython avoiding
+    exceptions).
+    """
+    if order.shape[0] != size:
+        raise ValueError("invalid permutation: wrong number of elements")
+    cdef size_t ptr
+    cdef idxint value
+    cdef bint *test = <bint *> PyMem_Calloc(size, sizeof(bint))
+    if test == NULL:
+        raise MemoryError
+    try:
+        for ptr in range(size):
+            value = order[ptr]
+            if not 0 <= value < size:
+                raise ValueError("invalid entry in permutation: " + str(value))
+            if test[value]:
+                raise ValueError("duplicate entry in permutation: " + str(value))
+            test[value] = True
+        return False
+    finally:
+        mem.PyMem_Free(test)
+
+cdef CSR _indices_csr_rowonly(CSR matrix, idxint[:] rows):
+    cdef size_t n_rows=matrix.shape[0]
+    _check_indices(n_rows, rows)
+    cdef CSR out = csr.empty_like(matrix)
+    cdef size_t row, ptr_in, ptr_out, len
+    out.row_index[0] = 0
+    for row in range(matrix.shape[0]):
+        out.row_index[rows[row] + 1] =\
+            matrix.row_index[row + 1] - matrix.row_index[row]
+    for row in range(matrix.shape[0]):
+        out.row_index[row + 1] += out.row_index[row]
+    for row in range(matrix.shape[0]):
+        ptr_in = matrix.row_index[row]
+        ptr_out = out.row_index[rows[row]]
+        len = matrix.row_index[row + 1] - ptr_in
+        memcpy(&out.col_index[ptr_out], &matrix.col_index[ptr_in], len * sizeof(idxint))
+        memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len * sizeof(double complex))
+    return out
+
+cdef CSR _indices_csr_full(CSR matrix, idxint[:] rows, idxint[:] cols):
+    _check_indices(matrix.shape[0], rows)
+    _check_indices(matrix.shape[1], cols)
+    cdef CSR out = csr.empty_like(matrix)
+    cdef size_t row, ptr_in, ptr_out, len, n
+    # First build up the row index structure by cumulative sum, so we know
+    # where to place the data and column indices.  We also use this opportunity
+    # to find the maximum number of non-zero elements in a row.
+    with nogil:
+        len = 0
+        out.row_index[0] = 0
+        for row in range(matrix.shape[0]):
+            n = matrix.row_index[row + 1] - matrix.row_index[row]
+            out.row_index[rows[row] + 1] = n
+            len = n if n > len else len
+        for row in range(matrix.shape[0]):
+            out.row_index[row + 1] += out.row_index[row]
+    # Now we know that `len` is the most number of non-zero elements in a row,
+    # so we can allocate space to sort only once.
+    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(len * sizeof(idxint))
+    cdef csr.Sorter sort = csr.Sorter(len)
+    for row in range(matrix.shape[0]):
+        ptr_in = matrix.row_index[row]
+        ptr_out = out.row_index[rows[row]]
+        len = matrix.row_index[row + 1] - ptr_in
+        for n in range(len):
+            new_cols[n] = cols[matrix.col_index[ptr_in + n]]
+        sort.copy(&out.data[ptr_out], &out.col_index[ptr_out],
+                  &matrix.data[ptr_in], new_cols,
+                  len)
+    mem.PyMem_Free(new_cols)
+    return out
+
+cpdef CSR indices_csr(CSR matrix, object row_perm=None, object col_perm=None):
+    if row_perm is None and col_perm is None:
+        return matrix.copy()
+    if col_perm is None:
+        return _indices_csr_rowonly(matrix, np.asarray(row_perm, dtype=idxint_dtype))
+    cdef idxint *rows = NULL
+    cdef idxint n
+    if row_perm is None:
+        rows = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
+        for n in range(matrix.shape[0]):
+            rows[n] = n
+        try:
+            return _indices_csr_full(matrix,
+                                     <idxint [:matrix.shape[0]]>rows,
+                                     np.asarray(col_perm, dtype=idxint_dtype))
+        finally:
+            mem.PyMem_Free(rows)
+    return _indices_csr_full(matrix,
+                             np.asarray(row_perm, dtype=idxint_dtype),
+                             np.asarray(col_perm, dtype=idxint_dtype))
+
+cpdef Dense indices_dense(Dense matrix, object row_perm=None, object col_perm=None):
+    if row_perm is None and col_perm is None:
+        return matrix.copy()
+    array = matrix.as_ndarray()
+    if row_perm is not None:
+        array = array[np.argsort(row_perm), :]
+    if col_perm is not None:
+        array = array[:, np.argsort(col_perm)]
+    return Dense(array)
+
+
+cdef CSR _dimensions_csr_columns(CSR matrix, _Indexer index):
+    if matrix.shape[0] != 1:
+        raise ValueError("expected bra-like matrix")
+    cdef size_t nnz = csr.nnz(matrix)
+    cdef CSR out = csr.empty_like(matrix)
+    out.row_index[0] = 0
+    out.row_index[1] = nnz
+    cdef size_t n
+    cdef csr.Sorter sort = csr.Sorter(nnz)
+    cdef idxint *new_cols = <idxint *> mem.PyMem_Malloc(nnz * sizeof(idxint))
+    try:
+        for n in range(nnz):
+            new_cols[n] = index.single(matrix.col_index[n])
+        sort.copy(&out.data[0], &out.col_index[0], &matrix.data[0], new_cols, nnz)
+        return out
+    finally:
+        mem.PyMem_Free(new_cols)
+
+cdef CSR _dimensions_csr_sparse(CSR matrix, _Indexer index):
+    cdef CSR out = csr.empty_like(matrix)
+    cdef csr.Sorter sort
+    cdef size_t row, n, len=0
+    cdef idxint ptr_in, ptr_out, col
+    cdef idxint *idx_lookup = <idxint *> mem.PyMem_Malloc(matrix.shape[0] * sizeof(idxint))
+    try:
+        memset(&out.row_index[0], 0, (matrix.shape[0] + 1) * sizeof(idxint))
+        with nogil:
+            for row in range(matrix.shape[0]):
+                n = matrix.row_index[row + 1] - matrix.row_index[row]
+                if n:
+                    idx_lookup[row] = index.single(row)
+                    out.row_index[idx_lookup[row] + 1] = n
+                    len = n if n > len else len
+                else:
+                    # Use a sentinel value so we can avoid looking up columns
+                    # that we already know about later.  Not all values in
+                    # idx_lookup will even be filled---this is the speed up
+                    # this function achieves over `_indices_csr_all`.
+                    idx_lookup[row] = -1
+            for row in range(matrix.shape[0]):
+                out.row_index[row + 1] += out.row_index[row]
+        # Since this is very sparse, we expect almost all rows to have at most two
+        # elements in them.  It will be faster to copy them across, and perform the
+        # sort in place rather than allocating temporary space and making an
+        # additional copy.  This will still work even if there are more in a row,
+        # it just won't be quite as efficient in that case (which should be rare).
+        sort = csr.Sorter(len)
+        for row in range(matrix.shape[0]):
+            ptr_in = matrix.row_index[row]
+            len = matrix.row_index[row + 1] - ptr_in
+            if len == 0:
+                continue
+            ptr_out = out.row_index[idx_lookup[row]]
+            for n in range(len):
+                col = matrix.col_index[ptr_in + n]
+                if idx_lookup[col] == -1:
+                    idx_lookup[col] = index.single(col)
+                out.col_index[ptr_out + n] = idx_lookup[col]
+            memcpy(&out.data[ptr_out], &matrix.data[ptr_in], len*sizeof(double complex))
+            sort.inplace(out, ptr_out, len)
+        return out
+    finally:
+        mem.PyMem_Free(idx_lookup)
+
+@cython.cdivision(True)
+cpdef CSR dimensions_csr(CSR matrix, object dimensions, object order):
+    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
+                                   np.asarray(order, dtype=idxint_dtype))
+    cdef idxint[:] permutation
+    if matrix.shape[0] == 1 and matrix.shape[1] == 1 or csr.nnz(matrix) == 0:
+        return matrix.copy()
+    if matrix.shape[0] == 1:
+        return _dimensions_csr_columns(matrix, index)
+    if matrix.shape[1] == 1:
+        return _indices_csr_rowonly(matrix, index.all())
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("dimensional permute requires square operators")
+    cdef double row_density = (<double> csr.nnz(matrix)) / (<double> matrix.shape[0])
+    # The speed-up for _dimensions_csr_sparse is only achieved by having fewer
+    # calls to `index.single()` than the matrix dimension.  To be sure of this,
+    # we actually require the density per row to be less than 1/2, because we
+    # have to look up both the row _and_ column on output.  This only
+    # corresponds to exceptionally sparse matrices.  We try to avoid these
+    # calls because index.single has ~logarithmic complexity in the dimension
+    # (so for qubit systems it's linear in the number of qubits), and
+    # consequently `index.all()` is a hidden quadratic complexity.
+    if row_density >= 0.5:
+        permutation = index.all()
+        return _indices_csr_full(matrix, permutation, permutation)
+    return _dimensions_csr_sparse(matrix, index)
+
+@cython.cdivision(True)
+cpdef Dense dimensions_dense(Dense matrix, object dimensions, object order):
+    cdef _Indexer index = _Indexer(np.asarray(dimensions, dtype=idxint_dtype),
+                                   np.asarray(order, dtype=idxint_dtype))
+    cdef idxint[:] permutation = index.all()
+    row_perm, col_perm = None, None
+    if matrix.shape[0] != 1:
+        row_perm = permutation
+    if matrix.shape[1] != 1:
+        col_perm = permutation
+    return indices_dense(matrix, row_perm, col_perm)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+dimensions = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('dimensions', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('order', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='dimensions',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+dimensions.__doc__ =\
+    """
+    Reorder the tensor-product structure of a matrix, assuming that the
+    underlying structure is defined by `dimensions`.  For a separable system,
+    this function produces a matrix which is equivalent to having performed
+    `kron` in a different order on the separable parts.
+
+    For example if `a`, `b` and `c` are matrices with sizes 2, 3 and 4
+    respectively, then
+        kron(kron(c, a), b) == permute.dimensions(kron(kron(a, b), c),
+                                                  [2, 3, 4],
+                                                  [1, 2, 0])
+    In other words, the inputs to `kron` are reordered so that input `n` moves
+    to position `order[n]`.
+
+    Parameters
+    ----------
+    matrix : Data
+        Input matrix to reorder.  This can either be a square matrix
+        representing an operator, or a bra- or ket-like vector.
+
+    dimensions : 1D array_like of integers
+        The tensor-product structure of the space the matrix lives on.  This
+        will typically be one of the two elements of `Qobj.dims` (e.g. for a
+        ket, it will be `Qobj.dims[0]`).
+
+    order : 1D array_like of integers
+        The new order of the tensor-product elements.  This should be a 1D list
+        with the integers from `0` to `N - 1` inclusive, if there are `N`
+        elements in the tensor product.
+    """
+dimensions.add_specialisations([
+    (CSR, CSR, dimensions_csr),
+    (Dense, Dense, dimensions_dense),
+], _defer=True)
+
+indices = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('row_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=None),
+        _inspect.Parameter('col_perm', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=None),
+    ]),
+    name='indices',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+indices.__doc__ =\
+    """
+    Permute the rows and columns of a matrix according to a row and column
+    permutation.  This is a "dumb" operation with regards to the representation
+    of quantum states; if you want to "reorder" the tensor-product structure of
+    a system, you want `permute.dimensions` instead.
+
+    Parameters
+    ----------
+    matrix : Data
+        The input matrix.
+
+    row_perm, col_perm : 1D array_like of integer, optional
+        The new order that the rows or columns should be shuffled into.  If the
+        input matrix is `N x M`, then `row_perm` would be an array containing
+        all the integers from `0` to `N - 1` inclusive in some new order.  Row
+        `n` in the input will be at row `row_perm[n]` in the output, and
+        similar for the column permutation.
+    """
+indices.add_specialisations([
+    (CSR, CSR, indices_csr),
+    (Dense, Dense, indices_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/pow.pxd b/qutip/core/data/pow.pxd
index 04a0c79fc6..d74b871fd0 100644
--- a/qutip/core/data/pow.pxd
+++ b/qutip/core/data/pow.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR pow_csr(CSR matrix, unsigned long long n)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR pow_csr(CSR matrix, unsigned long long n)
diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
index 7c0c6bf7c0..b90a1a44b7 100644
--- a/qutip/core/data/pow.pyx
+++ b/qutip/core/data/pow.pyx
@@ -1,86 +1,86 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-
-from qutip.core.data cimport csr, dense
-from qutip.core.data.csr cimport CSR
-from qutip.core.data.dense cimport Dense
-from qutip.core.data.matmul cimport matmul_csr
-import numpy as np
-
-__all__ = [
-    'pow', 'pow_csr', 'pow_dense',
-]
-
-
-@cython.nonecheck(False)
-@cython.cdivision(True)
-cpdef CSR pow_csr(CSR matrix, unsigned long long n):
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("matrix power only works with square matrices")
-    if n == 0:
-        return csr.identity(matrix.shape[0])
-    if n == 1:
-        return matrix.copy()
-    # We do the matrix power in terms of powers of two, so we can do it
-    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
-    # number of set bits in the input.
-    #
-    # We don't have to do matrix.copy() or pow.copy() here, because we've
-    # guaranteed that we won't be returning without at least one matrix
-    # multiplcation, which will allocate a new matrix.
-    cdef CSR pow = matrix
-    cdef CSR out = pow if n & 1 else None
-    n >>= 1
-    while n:
-        pow = matmul_csr(pow, pow)
-        if n & 1:
-            out = pow if out is None else matmul_csr(out, pow)
-        n >>= 1
-    return out
-
-
-cpdef Dense pow_dense(Dense matrix, unsigned long long n):
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("matrix power only works with square matrices")
-    if n == 0:
-        return dense.identity(matrix.shape[0])
-    if n == 1:
-        return matrix.copy()
-    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-pow = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='pow',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-pow.__doc__ =\
-    """
-    Compute the integer matrix power of the square input matrix.  The power
-    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
-    the same shape.
-
-    Parameters
-    ----------
-    matrix : Data
-        Input matrix to take the power of.
-
-    n : non-negative integer
-        The power to which to raise the matrix.
-    """
-pow.add_specialisations([
-    (CSR, CSR, pow_csr),
-    (Dense, Dense, pow_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+
+from qutip.core.data cimport csr, dense
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dense cimport Dense
+from qutip.core.data.matmul cimport matmul_csr
+import numpy as np
+
+__all__ = [
+    'pow', 'pow_csr', 'pow_dense',
+]
+
+
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cpdef CSR pow_csr(CSR matrix, unsigned long long n):
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("matrix power only works with square matrices")
+    if n == 0:
+        return csr.identity(matrix.shape[0])
+    if n == 1:
+        return matrix.copy()
+    # We do the matrix power in terms of powers of two, so we can do it
+    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
+    # number of set bits in the input.
+    #
+    # We don't have to do matrix.copy() or pow.copy() here, because we've
+    # guaranteed that we won't be returning without at least one matrix
+    # multiplcation, which will allocate a new matrix.
+    cdef CSR pow = matrix
+    cdef CSR out = pow if n & 1 else None
+    n >>= 1
+    while n:
+        pow = matmul_csr(pow, pow)
+        if n & 1:
+            out = pow if out is None else matmul_csr(out, pow)
+        n >>= 1
+    return out
+
+
+cpdef Dense pow_dense(Dense matrix, unsigned long long n):
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("matrix power only works with square matrices")
+    if n == 0:
+        return dense.identity(matrix.shape[0])
+    if n == 1:
+        return matrix.copy()
+    return Dense(np.linalg.matrix_power(matrix.as_ndarray(), n))
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+pow = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('n', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='pow',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+pow.__doc__ =\
+    """
+    Compute the integer matrix power of the square input matrix.  The power
+    must be an integer >= 0.  `A ** 0` is defined to be the identity matrix of
+    the same shape.
+
+    Parameters
+    ----------
+    matrix : Data
+        Input matrix to take the power of.
+
+    n : non-negative integer
+        The power to which to raise the matrix.
+    """
+pow.add_specialisations([
+    (CSR, CSR, pow_csr),
+    (Dense, Dense, pow_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/project.pxd b/qutip/core/data/project.pxd
index 86baf76291..07dabb79ca 100644
--- a/qutip/core/data/project.pxd
+++ b/qutip/core/data/project.pxd
@@ -1,5 +1,5 @@
-#cython: language_level=3
-
-from qutip.core.data.csr cimport CSR
-
-cpdef CSR project_csr(CSR state)
+#cython: language_level=3
+
+from qutip.core.data.csr cimport CSR
+
+cpdef CSR project_csr(CSR state)
diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
index 03a8bf7309..b88771e365 100644
--- a/qutip/core/data/project.pyx
+++ b/qutip/core/data/project.pyx
@@ -1,144 +1,144 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memcpy
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, Dense
-from qutip.core.data.csr cimport CSR
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-__all__ = [
-    'project', 'project_csr', 'project_dense',
-]
-
-
-cdef void _project_ket_csr(CSR ket, CSR out) nogil:
-    """
-    Calculate the projection of the given ket, and place the output in out.
-    """
-    cdef size_t row, ptr, offset=0
-    cdef idxint nnz_in = csr.nnz(ket)
-    for row in range(ket.shape[0]):
-        out.row_index[row] = ket.row_index[row] * nnz_in
-        if ket.row_index[row + 1] != ket.row_index[row]:
-            for ptr in range(nnz_in):
-                out.col_index[offset + ptr*nnz_in] = row
-            offset += 1
-    out.row_index[ket.shape[0]] = nnz_in * nnz_in
-    offset = 0
-    for row in range(nnz_in):
-        for ptr in range(nnz_in):
-            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
-        offset += nnz_in
-
-
-cdef void _project_bra_csr(CSR bra, CSR out) nogil:
-    """
-    Calculate the projection of the given bra, and place the output in out.
-    """
-    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
-    cdef double complex mul
-    cdef idxint nnz_in = csr.nnz(bra)
-    # The algorithm is much more simple conceptually if the indices are sorted,
-    # and doesn't affect runtime much since sorting is worst-case
-    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
-    # sort now than later while there are fewer entries.  No need to sort when
-    # projecting a ket because all the col_index values are 0.
-    with gil:
-        bra.sort_indices()
-    out.row_index[0] = cur
-    for ptr_bra in range(nnz_in):
-        # Handle all zero rows between the last non-zero entry and this one.
-        for row_out in range(row_out, bra.col_index[ptr_bra]):
-            out.row_index[row_out + 1] = cur
-        row_out = bra.col_index[ptr_bra]
-        cur += nnz_in
-        out.row_index[row_out + 1] = cur
-        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
-        mul = conj(bra.data[ptr_bra])
-        for ptr in range(nnz_in):
-            out.data[ptr_out] = mul * bra.data[ptr]
-            ptr_out += 1
-        row_out += 1
-    # Handle all zero rows after the last non-zero entry.
-    for row_out in range(row_out, out.shape[0]):
-        out.row_index[row_out + 1] = cur
-
-cpdef CSR project_csr(CSR state):
-    """
-    Calculate the projection |state><state|.  The shape of `state` will be used
-    to determine if it has been supplied as a ket or a bra.  The result of this
-    function will be identical is passed `state` or `adjoint(state)`.
-    """
-    cdef size_t nnz_in = csr.nnz(state)
-    cdef CSR out
-    # We don't actually need to both handling the shape=(1, 1) case specially,
-    # because it doesn't matter if we interpret it as a ket or a bra---the
-    # output will be a shape=(1, 1) matrix with the only data element equal to
-    # abs(state.data[0])**2 either way.
-    if state.shape[1] == 1:
-        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
-        _project_ket_csr(state, out)
-        return out
-    if state.shape[0] == 1:
-        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
-        _project_bra_csr(state, out)
-        return out
-    raise ValueError("state must be a ket or a bra.")
-
-cpdef Dense project_dense(Dense state):
-    """
-    Calculate the projection |state><state|.  The shape of `state` will be used
-    to determine if it has been supplied as a ket or a bra.  The result of this
-    function will be identical is passed `state` or `adjoint(state)`.
-    """
-    cdef Dense out
-    cdef size_t size, i
-    cdef bint fortran
-    if state.shape[1] == 1:
-        size = state.shape[0]
-        fortran = True
-    elif state.shape[0] == 1:
-        size = state.shape[1]
-        fortran = False
-    else:
-        raise ValueError("state must be a ket or a bra.")
-    out = dense.zeros(size, size, fortran)
-    for i in range(size):
-        for j in range(size):
-            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
-    return out
-
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-project = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='project',
-    module=__name__,
-    inputs=('state',),
-    out=True,
-)
-project.__doc__ =\
-    """
-    Get the projector of a state with itself.  Mathematically, if passed an
-    object `|a>` or `<a|`, then return the matrix `|a><a|`.
-
-    Parameters
-    ----------
-    state : Data
-        The input state bra- or ket-like vector.
-    """
-project.add_specialisations([
-    (CSR, CSR, project_csr),
-    (Dense, Dense, project_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memcpy
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport csr, dense, Dense
+from qutip.core.data.csr cimport CSR
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+__all__ = [
+    'project', 'project_csr', 'project_dense',
+]
+
+
+cdef void _project_ket_csr(CSR ket, CSR out) nogil:
+    """
+    Calculate the projection of the given ket, and place the output in out.
+    """
+    cdef size_t row, ptr, offset=0
+    cdef idxint nnz_in = csr.nnz(ket)
+    for row in range(ket.shape[0]):
+        out.row_index[row] = ket.row_index[row] * nnz_in
+        if ket.row_index[row + 1] != ket.row_index[row]:
+            for ptr in range(nnz_in):
+                out.col_index[offset + ptr*nnz_in] = row
+            offset += 1
+    out.row_index[ket.shape[0]] = nnz_in * nnz_in
+    offset = 0
+    for row in range(nnz_in):
+        for ptr in range(nnz_in):
+            out.data[offset + ptr] = ket.data[row] * conj(ket.data[ptr])
+        offset += nnz_in
+
+
+cdef void _project_bra_csr(CSR bra, CSR out) nogil:
+    """
+    Calculate the projection of the given bra, and place the output in out.
+    """
+    cdef size_t row_out=0, ptr_bra, ptr, ptr_out=0, cur=0
+    cdef double complex mul
+    cdef idxint nnz_in = csr.nnz(bra)
+    # The algorithm is much more simple conceptually if the indices are sorted,
+    # and doesn't affect runtime much since sorting is worst-case
+    # O(nnz log(nnz)) and the projection is O(nnz^2).  Also, much better to
+    # sort now than later while there are fewer entries.  No need to sort when
+    # projecting a ket because all the col_index values are 0.
+    with gil:
+        bra.sort_indices()
+    out.row_index[0] = cur
+    for ptr_bra in range(nnz_in):
+        # Handle all zero rows between the last non-zero entry and this one.
+        for row_out in range(row_out, bra.col_index[ptr_bra]):
+            out.row_index[row_out + 1] = cur
+        row_out = bra.col_index[ptr_bra]
+        cur += nnz_in
+        out.row_index[row_out + 1] = cur
+        memcpy(&out.col_index[ptr_out], &bra.col_index[0], nnz_in * sizeof(idxint))
+        mul = conj(bra.data[ptr_bra])
+        for ptr in range(nnz_in):
+            out.data[ptr_out] = mul * bra.data[ptr]
+            ptr_out += 1
+        row_out += 1
+    # Handle all zero rows after the last non-zero entry.
+    for row_out in range(row_out, out.shape[0]):
+        out.row_index[row_out + 1] = cur
+
+cpdef CSR project_csr(CSR state):
+    """
+    Calculate the projection |state><state|.  The shape of `state` will be used
+    to determine if it has been supplied as a ket or a bra.  The result of this
+    function will be identical is passed `state` or `adjoint(state)`.
+    """
+    cdef size_t nnz_in = csr.nnz(state)
+    cdef CSR out
+    # We don't actually need to both handling the shape=(1, 1) case specially,
+    # because it doesn't matter if we interpret it as a ket or a bra---the
+    # output will be a shape=(1, 1) matrix with the only data element equal to
+    # abs(state.data[0])**2 either way.
+    if state.shape[1] == 1:
+        out = csr.empty(state.shape[0], state.shape[0], nnz_in*nnz_in)
+        _project_ket_csr(state, out)
+        return out
+    if state.shape[0] == 1:
+        out = csr.empty(state.shape[1], state.shape[1], nnz_in*nnz_in)
+        _project_bra_csr(state, out)
+        return out
+    raise ValueError("state must be a ket or a bra.")
+
+cpdef Dense project_dense(Dense state):
+    """
+    Calculate the projection |state><state|.  The shape of `state` will be used
+    to determine if it has been supplied as a ket or a bra.  The result of this
+    function will be identical is passed `state` or `adjoint(state)`.
+    """
+    cdef Dense out
+    cdef size_t size, i
+    cdef bint fortran
+    if state.shape[1] == 1:
+        size = state.shape[0]
+        fortran = True
+    elif state.shape[0] == 1:
+        size = state.shape[1]
+        fortran = False
+    else:
+        raise ValueError("state must be a ket or a bra.")
+    out = dense.zeros(size, size, fortran)
+    for i in range(size):
+        for j in range(size):
+            out.data[i*size+j] = conj(state.data[i]) * state.data[j]
+    return out
+
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+project = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('state', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='project',
+    module=__name__,
+    inputs=('state',),
+    out=True,
+)
+project.__doc__ =\
+    """
+    Get the projector of a state with itself.  Mathematically, if passed an
+    object `|a>` or `<a|`, then return the matrix `|a><a|`.
+
+    Parameters
+    ----------
+    state : Data
+        The input state bra- or ket-like vector.
+    """
+project.add_specialisations([
+    (CSR, CSR, project_csr),
+    (Dense, Dense, project_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/properties.pxd b/qutip/core/data/properties.pxd
index 9ce22e1292..57424d9638 100644
--- a/qutip/core/data/properties.pxd
+++ b/qutip/core/data/properties.pxd
@@ -1,8 +1,8 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef bint isherm_csr(CSR matrix, double tol=*)
-cpdef bint isdiag_csr(CSR matrix) nogil
-cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
-cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef bint isherm_csr(CSR matrix, double tol=*)
+cpdef bint isdiag_csr(CSR matrix) nogil
+cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
+cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
index 38116cabcd..ded226cbe7 100644
--- a/qutip/core/data/properties.pyx
+++ b/qutip/core/data/properties.pyx
@@ -1,319 +1,319 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-from cpython cimport mem
-
-from qutip.settings import settings
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense
-from qutip.core.data.adjoint cimport transpose_csr
-
-cdef extern from *:
-    # Not defined in cpython.mem for some reason, but is in pymem.h.
-    void *PyMem_Calloc(size_t nelem, size_t elsize)
-
-__all__ = [
-    'isherm', 'isherm_csr', 'isherm_dense',
-    'isdiag', 'isdiag_csr', 'isdiag_dense',
-    'iszero', 'iszero_csr', 'iszero_dense',
-]
-
-cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
-    """Check whether a == conj(b) up to an absolute tolerance."""
-    cdef double re = a.real - b.real
-    cdef double im = a.imag + b.imag
-    # Comparing the squares should be fine---there is possible precision loss
-    # in the addition, but as re*re and im*im are both positive semidefinite,
-    # the floating point result is strictly not greater than the true value.
-    # Save the cycles: don't sqrt.
-    return re*re + im*im < tol*tol
-
-cdef inline bint _feq_zero(double complex a, double tol) nogil:
-    return a.real*a.real + a.imag*a.imag < tol*tol
-
-cdef inline double _abssq(double complex x) nogil:
-    return x.real*x.real + x.imag*x.imag
-
-
-cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
-    """
-    Full, structural test for Hermicity of a matrix.  We assume that the input
-    matrix has already had its shape tested (must be square).
-
-    This test is only necessary when there is at least one value which is less
-    than the tolerance, and needed to be compared to an implicit zero.  In
-    general it is less efficient than the other test, and allocates more
-    memory.
-    """
-    cdef CSR transpose = transpose_csr(matrix)
-    cdef idxint row, ptr_a, ptr_b, col_a, col_b
-    for row in range(matrix.shape[0]):
-        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
-        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
-        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
-            # Doing this on every loop actually involves a few more
-            # de-references than are strictly necessary, but just
-            # simplifies the logic checking for the end of the row.
-            col_a = matrix.col_index[ptr_a]
-            col_b = transpose.col_index[ptr_b]
-            if col_a == col_b:
-                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
-                    return False
-                ptr_a += 1
-                ptr_b += 1
-            elif col_a < col_b:
-                if not _feq_zero(matrix.data[ptr_a], tol):
-                    return False
-                ptr_a += 1
-            else:
-                if not _feq_zero(transpose.data[ptr_b], tol):
-                    return False
-                ptr_b += 1
-        for ptr_a in range(ptr_a, ptr_a_end):
-            if not _feq_zero(matrix.data[ptr_a], tol):
-                return False
-        for ptr_b in range(ptr_b, ptr_b_end):
-            if not _feq_zero(transpose.data[ptr_b], tol):
-                return False
-    return True
-
-cpdef bint isherm_csr(CSR matrix, double tol=-1):
-    """
-    Determine whether an input CSR matrix is Hermitian up to a given
-    floating-point tolerance.
-
-    Parameters
-    ----------
-    matrix : CSR
-        Input matrix to test
-    tol : double, optional
-        Absolute tolerance value to use.  Defaults to
-        :obj:`settings.core['atol']`.
-
-    Returns
-    -------
-    bint
-        Boolean True if it is Hermitian, False if not.
-
-    Notes
-    -----
-    The implementation is effectively just taking the adjoint, but rather than
-    actually allocating and creating a new matrix, we just check whether the
-    output would match the input matrix.  If we cannot be certain of Hermicity
-    because the sizes of some elements are within tolerance of 0, we have to
-    resort to a complete adjoint calculation.
-    """
-    tol = tol if tol >= 0 else settings.core["atol"]
-    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
-    if matrix.shape[0] != matrix.shape[1]:
-        return False
-    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
-    if out_row_index == NULL:
-        raise MemoryError
-    matrix.sort_indices()
-    try:
-        for row in range(nrows):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr] + 1
-                out_row_index[col] += 1
-        for row in range(nrows):
-            out_row_index[row+1] += out_row_index[row]
-            if out_row_index[row + 1] != matrix.row_index[row + 1]:
-                # Structures are not the same, but it could still be Hermitian
-                # if any value is less than the tolerance.  That is the
-                # worst-case scenario, so we sacrifice its speed in favour of
-                # returning faster for the more common failure cases.
-                for ptr in range(matrix.row_index[nrows]):
-                    if _conj_feq(matrix.data[ptr], 0, tol):
-                        return _isherm_csr_full(matrix, tol)
-                return False
-        for row in range(nrows):
-            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-                col = matrix.col_index[ptr]
-                # Pointer into the "transposed" matrix.
-                ptr_t = out_row_index[col]
-                out_row_index[col] += 1
-                if row != matrix.col_index[ptr_t]:
-                    return _isherm_csr_full(matrix, tol)
-                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
-                    return False
-        return True
-    finally:
-        mem.PyMem_Free(out_row_index)
-
-
-cpdef bint isherm_dense(Dense matrix, double tol=-1):
-    """
-    Determine whether an input Dense matrix is Hermitian up to a given
-    floating-point tolerance.
-
-    Parameters
-    ----------
-    matrix : Dense
-        Input matrix to test
-    tol : double, optional
-        Absolute tolerance value to use.  Defaults to
-        :obj:`settings.core['atol']`.
-
-    Returns
-    -------
-    bint
-        Boolean True if it is Hermitian, False if not.
-    """
-    if matrix.shape[0] != matrix.shape[1]:
-        return False
-    tol = tol if tol >= 0 else settings.core["atol"]
-    cdef size_t row, col, size=matrix.shape[0]
-    for row in range(size):
-        for col in range(row + 1):
-            if not _conj_feq(
-                matrix.data[col*size+row],
-                matrix.data[row*size+col],
-                tol
-            ):
-                return False
-    return True
-
-
-cpdef bint isdiag_csr(CSR matrix) nogil:
-    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
-    for row in range(matrix.shape[0]):
-        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
-        if ptr_end - ptr_start > 1:
-            return False
-        if ptr_end - ptr_start == 1:
-            if matrix.col_index[ptr_start] != row:
-                return False
-    return True
-
-
-cpdef bint isdiag_dense(Dense matrix) nogil:
-    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
-    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
-    for row in range(matrix.shape[0]):
-        for col in range(matrix.shape[1]):
-            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
-                return False
-    return True
-
-
-cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
-    cdef size_t ptr
-    if tol < 0:
-        with gil:
-            tol = settings.core["atol"]
-    tolsq = tol*tol
-    for ptr in range(csr.nnz(matrix)):
-        if _abssq(matrix.data[ptr]) > tolsq:
-            return False
-    return True
-
-cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
-    cdef size_t ptr
-    if tol < 0:
-        with gil:
-            tol = settings.core["atol"]
-    tolsq = tol*tol
-    for ptr in range(matrix.shape[0]*matrix.shape[1]):
-        if _abssq(matrix.data[ptr]) > tolsq:
-            return False
-    return True
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-isherm = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=-1),
-    ]),
-    name='isherm',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-isherm.__doc__ =\
-    """
-    Check if the matrix is Hermitian up to a optional element-wise absolute
-    tolerance.  If the tolerance given is less than zero, the global settings
-    value `qutip.settings.atol` will be used instead.
-
-    Only square matrices can possibly be Hermitian.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to test for Hermicity.
-
-    tol : real, optional
-        If given, the absolute tolerance used to compare two values for
-        equality.  If not given, or given and negative, the value of
-        `qutip.settings.atol` is used instead.
-    """
-isherm.add_specialisations([
-    (Dense, isherm_dense),
-    (CSR, isherm_csr),
-], _defer=True)
-
-isdiag = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='isdiag',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-isdiag.__doc__ =\
-    """
-    Check if the matrix is diagonal.  The matrix need not be square to test.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to test for diagonality.
-    """
-isdiag.add_specialisations([
-    (Dense, isdiag_dense),
-    (CSR, isdiag_csr),
-], _defer=True)
-
-iszero = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=-1),
-    ]),
-    name='iszero',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-iszero.__doc__ =\
-    """
-    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to test.
-    tol : real, optional
-        The absolute tolerance to use when comparing to zero.  If not given, or
-        less than 0, use the core setting `atol`.
-
-    Returns
-    -------
-    bool
-        Whether the matrix is equivalent to 0 under the given absolute
-        tolerance.
-    """
-iszero.add_specialisations([
-    (CSR, iszero_csr),
-    (Dense, iszero_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+from cpython cimport mem
+
+from qutip.settings import settings
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport csr, dense, CSR, Dense
+from qutip.core.data.adjoint cimport transpose_csr
+
+cdef extern from *:
+    # Not defined in cpython.mem for some reason, but is in pymem.h.
+    void *PyMem_Calloc(size_t nelem, size_t elsize)
+
+__all__ = [
+    'isherm', 'isherm_csr', 'isherm_dense',
+    'isdiag', 'isdiag_csr', 'isdiag_dense',
+    'iszero', 'iszero_csr', 'iszero_dense',
+]
+
+cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
+    """Check whether a == conj(b) up to an absolute tolerance."""
+    cdef double re = a.real - b.real
+    cdef double im = a.imag + b.imag
+    # Comparing the squares should be fine---there is possible precision loss
+    # in the addition, but as re*re and im*im are both positive semidefinite,
+    # the floating point result is strictly not greater than the true value.
+    # Save the cycles: don't sqrt.
+    return re*re + im*im < tol*tol
+
+cdef inline bint _feq_zero(double complex a, double tol) nogil:
+    return a.real*a.real + a.imag*a.imag < tol*tol
+
+cdef inline double _abssq(double complex x) nogil:
+    return x.real*x.real + x.imag*x.imag
+
+
+cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
+    """
+    Full, structural test for Hermicity of a matrix.  We assume that the input
+    matrix has already had its shape tested (must be square).
+
+    This test is only necessary when there is at least one value which is less
+    than the tolerance, and needed to be compared to an implicit zero.  In
+    general it is less efficient than the other test, and allocates more
+    memory.
+    """
+    cdef CSR transpose = transpose_csr(matrix)
+    cdef idxint row, ptr_a, ptr_b, col_a, col_b
+    for row in range(matrix.shape[0]):
+        ptr_a, ptr_a_end = matrix.row_index[row], matrix.row_index[row + 1]
+        ptr_b, ptr_b_end = transpose.row_index[row], transpose.row_index[row + 1]
+        while ptr_a < ptr_a_end and ptr_b < ptr_b_end:
+            # Doing this on every loop actually involves a few more
+            # de-references than are strictly necessary, but just
+            # simplifies the logic checking for the end of the row.
+            col_a = matrix.col_index[ptr_a]
+            col_b = transpose.col_index[ptr_b]
+            if col_a == col_b:
+                if not _conj_feq(matrix.data[ptr_a], transpose.data[ptr_b], tol):
+                    return False
+                ptr_a += 1
+                ptr_b += 1
+            elif col_a < col_b:
+                if not _feq_zero(matrix.data[ptr_a], tol):
+                    return False
+                ptr_a += 1
+            else:
+                if not _feq_zero(transpose.data[ptr_b], tol):
+                    return False
+                ptr_b += 1
+        for ptr_a in range(ptr_a, ptr_a_end):
+            if not _feq_zero(matrix.data[ptr_a], tol):
+                return False
+        for ptr_b in range(ptr_b, ptr_b_end):
+            if not _feq_zero(transpose.data[ptr_b], tol):
+                return False
+    return True
+
+cpdef bint isherm_csr(CSR matrix, double tol=-1):
+    """
+    Determine whether an input CSR matrix is Hermitian up to a given
+    floating-point tolerance.
+
+    Parameters
+    ----------
+    matrix : CSR
+        Input matrix to test
+    tol : double, optional
+        Absolute tolerance value to use.  Defaults to
+        :obj:`settings.core['atol']`.
+
+    Returns
+    -------
+    bint
+        Boolean True if it is Hermitian, False if not.
+
+    Notes
+    -----
+    The implementation is effectively just taking the adjoint, but rather than
+    actually allocating and creating a new matrix, we just check whether the
+    output would match the input matrix.  If we cannot be certain of Hermicity
+    because the sizes of some elements are within tolerance of 0, we have to
+    resort to a complete adjoint calculation.
+    """
+    tol = tol if tol >= 0 else settings.core["atol"]
+    cdef size_t row, col, ptr, ptr_t, nrows=matrix.shape[0]
+    if matrix.shape[0] != matrix.shape[1]:
+        return False
+    cdef idxint *out_row_index = <idxint *>PyMem_Calloc(nrows + 1, sizeof(idxint))
+    if out_row_index == NULL:
+        raise MemoryError
+    matrix.sort_indices()
+    try:
+        for row in range(nrows):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr] + 1
+                out_row_index[col] += 1
+        for row in range(nrows):
+            out_row_index[row+1] += out_row_index[row]
+            if out_row_index[row + 1] != matrix.row_index[row + 1]:
+                # Structures are not the same, but it could still be Hermitian
+                # if any value is less than the tolerance.  That is the
+                # worst-case scenario, so we sacrifice its speed in favour of
+                # returning faster for the more common failure cases.
+                for ptr in range(matrix.row_index[nrows]):
+                    if _conj_feq(matrix.data[ptr], 0, tol):
+                        return _isherm_csr_full(matrix, tol)
+                return False
+        for row in range(nrows):
+            for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+                col = matrix.col_index[ptr]
+                # Pointer into the "transposed" matrix.
+                ptr_t = out_row_index[col]
+                out_row_index[col] += 1
+                if row != matrix.col_index[ptr_t]:
+                    return _isherm_csr_full(matrix, tol)
+                if not _conj_feq(matrix.data[ptr], matrix.data[ptr_t], tol):
+                    return False
+        return True
+    finally:
+        mem.PyMem_Free(out_row_index)
+
+
+cpdef bint isherm_dense(Dense matrix, double tol=-1):
+    """
+    Determine whether an input Dense matrix is Hermitian up to a given
+    floating-point tolerance.
+
+    Parameters
+    ----------
+    matrix : Dense
+        Input matrix to test
+    tol : double, optional
+        Absolute tolerance value to use.  Defaults to
+        :obj:`settings.core['atol']`.
+
+    Returns
+    -------
+    bint
+        Boolean True if it is Hermitian, False if not.
+    """
+    if matrix.shape[0] != matrix.shape[1]:
+        return False
+    tol = tol if tol >= 0 else settings.core["atol"]
+    cdef size_t row, col, size=matrix.shape[0]
+    for row in range(size):
+        for col in range(row + 1):
+            if not _conj_feq(
+                matrix.data[col*size+row],
+                matrix.data[row*size+col],
+                tol
+            ):
+                return False
+    return True
+
+
+cpdef bint isdiag_csr(CSR matrix) nogil:
+    cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
+    for row in range(matrix.shape[0]):
+        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
+        if ptr_end - ptr_start > 1:
+            return False
+        if ptr_end - ptr_start == 1:
+            if matrix.col_index[ptr_start] != row:
+                return False
+    return True
+
+
+cpdef bint isdiag_dense(Dense matrix) nogil:
+    cdef size_t row, row_stride = 1 if matrix.fortran else matrix.shape[1]
+    cdef size_t col, col_stride = matrix.shape[0] if matrix.fortran else 1
+    for row in range(matrix.shape[0]):
+        for col in range(matrix.shape[1]):
+            if (col != row) and matrix.data[col * col_stride + row * row_stride] != 0.:
+                return False
+    return True
+
+
+cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
+    cdef size_t ptr
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    tolsq = tol*tol
+    for ptr in range(csr.nnz(matrix)):
+        if _abssq(matrix.data[ptr]) > tolsq:
+            return False
+    return True
+
+cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
+    cdef size_t ptr
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    tolsq = tol*tol
+    for ptr in range(matrix.shape[0]*matrix.shape[1]):
+        if _abssq(matrix.data[ptr]) > tolsq:
+            return False
+    return True
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+isherm = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=-1),
+    ]),
+    name='isherm',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+isherm.__doc__ =\
+    """
+    Check if the matrix is Hermitian up to a optional element-wise absolute
+    tolerance.  If the tolerance given is less than zero, the global settings
+    value `qutip.settings.atol` will be used instead.
+
+    Only square matrices can possibly be Hermitian.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to test for Hermicity.
+
+    tol : real, optional
+        If given, the absolute tolerance used to compare two values for
+        equality.  If not given, or given and negative, the value of
+        `qutip.settings.atol` is used instead.
+    """
+isherm.add_specialisations([
+    (Dense, isherm_dense),
+    (CSR, isherm_csr),
+], _defer=True)
+
+isdiag = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='isdiag',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+isdiag.__doc__ =\
+    """
+    Check if the matrix is diagonal.  The matrix need not be square to test.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to test for diagonality.
+    """
+isdiag.add_specialisations([
+    (Dense, isdiag_dense),
+    (CSR, isdiag_csr),
+], _defer=True)
+
+iszero = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=-1),
+    ]),
+    name='iszero',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+iszero.__doc__ =\
+    """
+    Test if this matrix is the zero matrix, up to a certain absolute tolerance.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to test.
+    tol : real, optional
+        The absolute tolerance to use when comparing to zero.  If not given, or
+        less than 0, use the core setting `atol`.
+
+    Returns
+    -------
+    bool
+        Whether the matrix is equivalent to 0 under the given absolute
+        tolerance.
+    """
+iszero.add_specialisations([
+    (CSR, iszero_csr),
+    (Dense, iszero_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/ptrace.pxd b/qutip/core/data/ptrace.pxd
index a233d0c0a3..6689bafaec 100644
--- a/qutip/core/data/ptrace.pxd
+++ b/qutip/core/data/ptrace.pxd
@@ -1,7 +1,7 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
-cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
-cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef CSR ptrace_csr(CSR matrix, object dims, object sel)
+cpdef Dense ptrace_dense(Dense matrix, object dims, object sel)
+cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel)
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index e45522ef5d..3e58e82d94 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -1,216 +1,216 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
-
-import numbers
-
-import numpy as np
-
-cimport numpy as cnp
-
-from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
-from qutip.core.data.base import idxint_dtype
-from qutip.settings import settings
-
-cnp.import_array()
-
-__all__ = [
-    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
-]
-
-cdef tuple _parse_inputs(object dims, object sel, tuple shape):
-    cdef Py_ssize_t i
-
-    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
-    sel = np.atleast_1d(sel).astype(idxint_dtype)
-    sel.sort()
-
-    if shape[0] != shape[1]:
-        raise ValueError("ptrace is only defined for square density matrices")
-
-    if shape[0] != np.prod(dims, dtype=int):
-        raise ValueError(f"the input matrix shape, {shape} and the"
-                         f" dimension argument, {dims}, are not compatible.")
-    if sel.ndim != 1:
-        raise ValueError("Selection must be one-dimensional")
-
-    if any(d < 1 for d in dims):
-        raise ValueError("dimensions must be greated than zero but where"
-                         f" dims={dims}.")
-
-    for i in range(sel.shape[0]):
-        if sel[i] < 0 or sel[i] >= dims.size:
-            raise IndexError("Invalid selection index in ptrace.")
-        if i > 0 and sel[i] == sel[i - 1]:
-            raise ValueError("Duplicate selection index in ptrace.")
-
-    return dims, sel
-
-cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
-    """
-    Populate the helper structure `tensor_table`.  Returns the size (number of
-    rows and number of columns) of the matrix which will be output.
-    """
-    cdef size_t ii
-    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
-    cdef size_t num_dims = _dims.shape[0]
-    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
-    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
-    for ii in range(_sel.shape[0]):
-        if _sel[ii] < 0 or _sel[ii] >= num_dims:
-            raise TypeError("Invalid selection index in ptrace.")
-    for ii in range(num_dims - 1,-1,-1):
-        tensor_table[ii, 0] = factor_tensor
-        factor_tensor *= _dims[ii]
-        if _in(ii, _sel):
-            tensor_table[ii, 1] = factor_keep
-            factor_keep *= _dims[ii]
-        else:
-            tensor_table[ii, 2]  = factor_trace
-            factor_trace *= _dims[ii]
-    return factor_keep
-
-
-cdef bint _in(idxint val, idxint[::1] vec):
-    cdef int ii
-    for ii in range(vec.shape[0]):
-        if val == vec[ii]:
-            return True
-    return False
-
-
-cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
-    # indices determining function for ptrace
-    cdef size_t ii
-    cdef idxint t1, t2
-    out[0] = out[1] = 0
-    for ii in range(tensor_table.shape[0]):
-        t1 = tensor_table[ii, 0]
-        t2 = N / t1
-        N = N % t1
-        out[0] += tensor_table[ii, 1] * t2
-        out[1] += tensor_table[ii, 2] * t2
-
-
-cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
-    if len(sel) == len(dims):
-        return matrix.copy()
-    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-    cdef idxint size
-    size = _populate_tensor_table(dims, sel, tensor_table)
-    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
-    cdef idxint pos_c[2]
-    cdef idxint pos_r[2]
-    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
-    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
-    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
-    cdef double tol = 0
-    if settings.core['auto_tidyup']:
-        tol = settings.core['auto_tidyup_atol']
-    for row in range(matrix.shape[0]):
-        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
-            _i2_k_t(row, tensor_table, pos_r)
-            if pos_c[1] == pos_r[1]:
-                new_data[p] = matrix.data[ptr]
-                new_row[p] = pos_r[0]
-                new_col[p] = pos_c[0]
-                p += 1
-    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
-                                 size, size, p, tol)
-
-
-cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
-    if len(sel) == len(dims):
-        return dense.from_csr(matrix)
-    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-    cdef idxint size
-    size = _populate_tensor_table(dims, sel, tensor_table)
-    cdef size_t ii, jj
-    cdef idxint pos_c[2]
-    cdef idxint pos_r[2]
-    cdef Dense out = dense.zeros(size, size, fortran=False)
-    for ii in range(matrix.shape[0]):
-        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
-            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
-            _i2_k_t(ii, tensor_table, pos_r)
-            if pos_c[1] == pos_r[1]:
-                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
-    return out
-
-
-cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
-    if len(sel) == len(dims):
-        return matrix.copy()
-    nd = dims.shape[0]
-    dkeep = [dims[x] for x in sel]
-    qtrace = list(set(np.arange(nd)) - set(sel))
-    dtrace = [dims[x] for x in qtrace]
-    dims = list(dims)
-    sel = list(sel)
-    rhomat = np.trace(matrix.as_ndarray()
-                      .reshape(dims + dims)
-                      .transpose(qtrace + [nd + q for q in qtrace] +
-                                 sel + [nd + q for q in sel])
-                      .reshape([np.prod(dtrace, dtype=int),
-                                np.prod(dtrace, dtype=int),
-                                np.prod(dkeep, dtype=int),
-                                np.prod(dkeep, dtype=int)]))
-    return dense.fast_from_numpy(rhomat)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-ptrace = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='ptrace',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-ptrace.__doc__ =\
-    """
-    Compute the partial trace of this matrix, leaving the subspaces whose
-    indices are in `sel`.  This is only defined for square density matrices,
-    and always returns a density matrix.
-
-    The order of the indices in `sel` do not matter; the output matrix will
-    always have the selected subspaces in the same order that they are in the
-    input matrix.
-
-    For example, if the input is the matrix backing a `Qobj` with
-    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
-        ptrace(data, [2, 3, 4], [0, 2])
-    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The density matrix to be partially traced.
-
-    dims : array_like of integer
-        The dimensions of the subspaces.  This is most likely a 1D list, and
-        since this is only defined on square matrices, there is no need to pass
-        before the left and right sides.  Typically the input matrix will be
-        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
-
-    sel : integer or array_like of integer
-        The indices of the subspaces which should be _kept_.
-    """
-ptrace.add_specialisations([
-    (CSR, CSR, ptrace_csr),
-    (CSR, Dense, ptrace_csr_dense),
-    (Dense, Dense, ptrace_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
+
+import numbers
+
+import numpy as np
+
+cimport numpy as cnp
+
+from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
+from qutip.core.data.base import idxint_dtype
+from qutip.settings import settings
+
+cnp.import_array()
+
+__all__ = [
+    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
+]
+
+cdef tuple _parse_inputs(object dims, object sel, tuple shape):
+    cdef Py_ssize_t i
+
+    dims = np.atleast_1d(dims).astype(idxint_dtype).ravel()
+    sel = np.atleast_1d(sel).astype(idxint_dtype)
+    sel.sort()
+
+    if shape[0] != shape[1]:
+        raise ValueError("ptrace is only defined for square density matrices")
+
+    if shape[0] != np.prod(dims, dtype=int):
+        raise ValueError(f"the input matrix shape, {shape} and the"
+                         f" dimension argument, {dims}, are not compatible.")
+    if sel.ndim != 1:
+        raise ValueError("Selection must be one-dimensional")
+
+    if any(d < 1 for d in dims):
+        raise ValueError("dimensions must be greated than zero but where"
+                         f" dims={dims}.")
+
+    for i in range(sel.shape[0]):
+        if sel[i] < 0 or sel[i] >= dims.size:
+            raise IndexError("Invalid selection index in ptrace.")
+        if i > 0 and sel[i] == sel[i - 1]:
+            raise ValueError("Duplicate selection index in ptrace.")
+
+    return dims, sel
+
+cdef idxint _populate_tensor_table(dims, sel, idxint[:, ::1] tensor_table) except -1:
+    """
+    Populate the helper structure `tensor_table`.  Returns the size (number of
+    rows and number of columns) of the matrix which will be output.
+    """
+    cdef size_t ii
+    cdef idxint[::1] _dims = np.asarray(dims, dtype=idxint_dtype).ravel()
+    cdef size_t num_dims = _dims.shape[0]
+    cdef idxint factor_tensor=1, factor_keep=1, factor_trace=1
+    cdef idxint[::1] _sel = np.asarray(sel, dtype=idxint_dtype)
+    for ii in range(_sel.shape[0]):
+        if _sel[ii] < 0 or _sel[ii] >= num_dims:
+            raise TypeError("Invalid selection index in ptrace.")
+    for ii in range(num_dims - 1,-1,-1):
+        tensor_table[ii, 0] = factor_tensor
+        factor_tensor *= _dims[ii]
+        if _in(ii, _sel):
+            tensor_table[ii, 1] = factor_keep
+            factor_keep *= _dims[ii]
+        else:
+            tensor_table[ii, 2]  = factor_trace
+            factor_trace *= _dims[ii]
+    return factor_keep
+
+
+cdef bint _in(idxint val, idxint[::1] vec):
+    cdef int ii
+    for ii in range(vec.shape[0]):
+        if val == vec[ii]:
+            return True
+    return False
+
+
+cdef inline void _i2_k_t(idxint N, idxint[:, ::1] tensor_table, idxint out[2]):
+    # indices determining function for ptrace
+    cdef size_t ii
+    cdef idxint t1, t2
+    out[0] = out[1] = 0
+    for ii in range(tensor_table.shape[0]):
+        t1 = tensor_table[ii, 0]
+        t2 = N / t1
+        N = N % t1
+        out[0] += tensor_table[ii, 1] * t2
+        out[1] += tensor_table[ii, 2] * t2
+
+
+cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return matrix.copy()
+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+    cdef idxint size
+    size = _populate_tensor_table(dims, sel, tensor_table)
+    cdef size_t p=0, nnz=csr.nnz(matrix), row, ptr
+    cdef idxint pos_c[2]
+    cdef idxint pos_r[2]
+    cdef cnp.ndarray[double complex, ndim=1, mode='c'] new_data = np.zeros(nnz, dtype=complex)
+    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_col = np.zeros(nnz, dtype=idxint_dtype)
+    cdef cnp.ndarray[idxint, ndim=1, mode='c'] new_row = np.zeros(nnz, dtype=idxint_dtype)
+    cdef double tol = 0
+    if settings.core['auto_tidyup']:
+        tol = settings.core['auto_tidyup_atol']
+    for row in range(matrix.shape[0]):
+        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+            _i2_k_t(matrix.col_index[ptr], tensor_table, pos_c)
+            _i2_k_t(row, tensor_table, pos_r)
+            if pos_c[1] == pos_r[1]:
+                new_data[p] = matrix.data[ptr]
+                new_row[p] = pos_r[0]
+                new_col[p] = pos_c[0]
+                p += 1
+    return csr.from_coo_pointers(&new_row[0], &new_col[0], &new_data[0],
+                                 size, size, p, tol)
+
+
+cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return dense.from_csr(matrix)
+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+    cdef idxint size
+    size = _populate_tensor_table(dims, sel, tensor_table)
+    cdef size_t ii, jj
+    cdef idxint pos_c[2]
+    cdef idxint pos_r[2]
+    cdef Dense out = dense.zeros(size, size, fortran=False)
+    for ii in range(matrix.shape[0]):
+        for jj in range(matrix.row_index[ii], matrix.row_index[ii+1]):
+            _i2_k_t(matrix.col_index[jj], tensor_table, pos_c)
+            _i2_k_t(ii, tensor_table, pos_r)
+            if pos_c[1] == pos_r[1]:
+                out.data[pos_r[0]*size + pos_c[0]] += matrix.data[jj]
+    return out
+
+
+cpdef Dense ptrace_dense(Dense matrix, object dims, object sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return matrix.copy()
+    nd = dims.shape[0]
+    dkeep = [dims[x] for x in sel]
+    qtrace = list(set(np.arange(nd)) - set(sel))
+    dtrace = [dims[x] for x in qtrace]
+    dims = list(dims)
+    sel = list(sel)
+    rhomat = np.trace(matrix.as_ndarray()
+                      .reshape(dims + dims)
+                      .transpose(qtrace + [nd + q for q in qtrace] +
+                                 sel + [nd + q for q in sel])
+                      .reshape([np.prod(dtrace, dtype=int),
+                                np.prod(dtrace, dtype=int),
+                                np.prod(dkeep, dtype=int),
+                                np.prod(dkeep, dtype=int)]))
+    return dense.fast_from_numpy(rhomat)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+ptrace = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('dims', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('sel', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='ptrace',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+ptrace.__doc__ =\
+    """
+    Compute the partial trace of this matrix, leaving the subspaces whose
+    indices are in `sel`.  This is only defined for square density matrices,
+    and always returns a density matrix.
+
+    The order of the indices in `sel` do not matter; the output matrix will
+    always have the selected subspaces in the same order that they are in the
+    input matrix.
+
+    For example, if the input is the matrix backing a `Qobj` with
+    `dims = [[2, 3, 4], [2, 3, 4]]`, then the output of
+        ptrace(data, [2, 3, 4], [0, 2])
+    will be a matrix with effective dimensions `[[2, 4], [2, 4]]`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The density matrix to be partially traced.
+
+    dims : array_like of integer
+        The dimensions of the subspaces.  This is most likely a 1D list, and
+        since this is only defined on square matrices, there is no need to pass
+        before the left and right sides.  Typically the input matrix will be
+        taken from a `Qobj`, and then this parameter will be `Qobj.dims[0]`.
+
+    sel : integer or array_like of integer
+        The indices of the subspaces which should be _kept_.
+    """
+ptrace.add_specialisations([
+    (CSR, CSR, ptrace_csr),
+    (CSR, Dense, ptrace_csr_dense),
+    (Dense, Dense, ptrace_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/reshape.pxd b/qutip/core/data/reshape.pxd
index 1b04512f60..4efae3a0e4 100644
--- a/qutip/core/data/reshape.pxd
+++ b/qutip/core/data/reshape.pxd
@@ -1,12 +1,12 @@
-#cython: language_level=3
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport CSR, Dense
-
-cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
-cpdef CSR column_stack_csr(CSR matrix)
-cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
-
-cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
-cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
-cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
+#cython: language_level=3
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport CSR, Dense
+
+cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
+cpdef CSR column_stack_csr(CSR matrix)
+cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
+
+cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
+cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
+cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
index aeb83a22ff..6871e12c9b 100644
--- a/qutip/core/data/reshape.pyx
+++ b/qutip/core/data/reshape.pyx
@@ -1,285 +1,285 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
-
-from libc.string cimport memcpy, memset
-
-cimport cython
-
-import warnings
-
-from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense, Data
-
-__all__ = [
-    'reshape', 'reshape_csr', 'reshape_dense',
-    'column_stack', 'column_stack_csr', 'column_stack_dense',
-    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
-    'split_columns', 'split_columns_dense', 'split_columns_csr',
-]
-
-
-cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
-    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
-        message = "".join([
-            "cannot reshape ", str(matrix.shape), " to ",
-            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
-        ])
-        raise ValueError(message)
-    if n_rows_out <= 0 or n_cols_out <= 0:
-        raise ValueError("must have > 0 rows and columns")
-
-
-cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
-    cdef size_t ptr, row_in, row_out=0, loc, cur=0
-    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
-    cdef idxint nnz = csr.nnz(matrix)
-    cdef CSR out
-    _reshape_check_input(matrix, n_rows_out, n_cols_out)
-    out = csr.empty(n_rows_out, n_cols_out, nnz)
-    matrix.sort_indices()
-    with nogil:
-        # Since the indices are now sorted, the data arrays will be identical.
-        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
-        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
-        for row_in in range(n_rows_in):
-            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
-                loc = cur + matrix.col_index[ptr]
-                out.row_index[loc // n_cols_out + 1] += 1
-                out.col_index[ptr] = loc % n_cols_out
-            cur += n_cols_in
-        for row_out in range(n_rows_out):
-            out.row_index[row_out + 1] += out.row_index[row_out]
-    return out
-
-
-cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
-    return (idx // size) + (idx % size)
-
-
-cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
-    _reshape_check_input(matrix, n_rows_out, n_cols_out)
-    cdef Dense out
-    if not matrix.fortran:
-        out = matrix.copy()
-        out.shape = (n_rows_out, n_cols_out)
-        return out
-    out = dense.zeros(n_rows_out, n_cols_out)
-    cdef size_t idx_in=0, idx_out=0
-    cdef size_t size = n_rows_out * n_cols_out
-    # TODO: improve the algorithm here.
-    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
-    for idx_in in range(size):
-        out.data[idx_out] = matrix.data[idx_in]
-        idx_out = _reshape_dense_reindex(idx_out + stride, size)
-    return out
-
-
-cpdef CSR column_stack_csr(CSR matrix):
-    if matrix.shape[1] == 1:
-        return matrix.copy()
-    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
-
-
-cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
-    cdef Dense out
-    if inplace and matrix.fortran:
-        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
-        return matrix
-    if matrix.fortran:
-        out = matrix.copy()
-        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
-        return out
-    if inplace:
-        warnings.warn("cannot stack columns inplace for C-ordered matrix")
-    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
-
-
-cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
-    if matrix.shape[1] != 1:
-        raise ValueError("input is not a single column")
-    if rows < 1:
-        raise ValueError("rows must be a positive integer")
-    if matrix.shape[0] % rows:
-        raise ValueError("number of rows does not divide into the shape")
-
-
-cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
-    _column_unstack_check_shape(matrix, rows)
-    cdef idxint cols = matrix.shape[0] // rows
-    return reshape_csr(matrix, cols, rows).transpose()
-
-cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
-    _column_unstack_check_shape(matrix, rows)
-    cdef idxint cols = matrix.shape[0] // rows
-    if inplace and matrix.fortran:
-        matrix.shape = (rows, cols)
-        return matrix
-    elif inplace:
-        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
-    out = dense.empty(rows, cols, fortran=True)
-    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
-    return out
-
-
-cpdef list split_columns_dense(Dense matrix, copy=True):
-    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
-            for k in range(matrix.shape[1])]
-
-cpdef list split_columns_csr(CSR matrix, copy=True):
-    return [CSR(matrix.as_scipy()[:, k], copy=copy)
-            for k in range(matrix.shape[1])]
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-reshape = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='reshape',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-reshape.__doc__ =\
-    """
-    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
-    match the current total number of elements of the matrix.
-
-    Parameters
-    ----------
-    matrix : Data
-        The input matrix to reshape.
-
-    n_rows_out, n_cols_out : integer
-        The number of rows and columns in the output matrix.
-    """
-reshape.add_specialisations([
-    (CSR, CSR, reshape_csr),
-    (Dense, Dense, reshape_dense),
-], _defer=True)
-
-
-# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
-# signature of `column_stack` because the dispatcher logic currently doesn't
-# support the idea of an input parameter also being the output.
-
-column_stack = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='column_stack',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-column_stack.__doc__ =\
-    """
-    Stack the columns of a matrix so it becomes a ket-like vector.  For
-    example, the matrix
-        [[0, 1, 2],
-         [3, 4, 5],
-         [6, 7, 8]]
-    would be transformed to
-        [[0],
-         [3],
-         [6],
-         [1],
-         ...
-         [5],
-         [8]]
-    This is used for transforming between operator and operator-ket
-    representations in the super-operator formalism.
-
-    The inverse of this operation is `column_unstack`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to stack the columns of.
-    """
-column_stack.add_specialisations([
-    (CSR, CSR, column_stack_csr),
-    (Dense, Dense, column_stack_dense),
-], _defer=True)
-
-column_unstack = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='column_unstack',
-    module=__name__,
-    inputs=('matrix',),
-    out=True,
-)
-column_unstack.__doc__ =\
-    """
-    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
-    number of rows.  For example, the matrix
-        [[0],
-         [1],
-         [2],
-         [3]]
-    would be unstacked with `rows = 2` to
-        [[0, 2],
-         [1, 3]]
-    This is used for transforming between the operator-ket and operator
-    representations in the super-operator formalism.
-
-    The inverse of this operation is `column_stack`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to unstack the columns of.
-
-    rows : integer
-        The number of rows there should be in the output matrix.  This must
-        divide into the total number of elements in the input.
-    """
-column_unstack.add_specialisations([
-    (CSR, CSR, column_unstack_csr),
-    (Dense, Dense, column_unstack_dense),
-], _defer=True)
-
-
-split_columns = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=1),
-    ]),
-    name='split_columns',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-split_columns.__doc__ =\
-    """
-    Make a ket-shaped data out of each columns of the matrix.
-    This is used for to split the eigenvectors from :obj:`eigs`.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to unstack the columns of.
-
-    copy : bool, optional
-        The number of rows there should be in the output matrix.  This must
-        divide into the total number of elements in the input.
-
-    Returns
-    -------
-    kets : list
-        list of Data of each columns of the matrix.
-    """
-split_columns.add_specialisations([
-    (CSR, split_columns_csr),
-    (Dense, split_columns_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True
+
+from libc.string cimport memcpy, memset
+
+cimport cython
+
+import warnings
+
+from qutip.core.data.base cimport idxint
+from qutip.core.data cimport csr, dense, CSR, Dense, Data
+
+__all__ = [
+    'reshape', 'reshape_csr', 'reshape_dense',
+    'column_stack', 'column_stack_csr', 'column_stack_dense',
+    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
+    'split_columns', 'split_columns_dense', 'split_columns_csr',
+]
+
+
+cdef void _reshape_check_input(Data matrix, idxint n_rows_out, idxint n_cols_out) except *:
+    if n_rows_out * n_cols_out != matrix.shape[0] * matrix.shape[1]:
+        message = "".join([
+            "cannot reshape ", str(matrix.shape), " to ",
+            "(", str(n_rows_out), ", ", str(n_cols_out), ")",
+        ])
+        raise ValueError(message)
+    if n_rows_out <= 0 or n_cols_out <= 0:
+        raise ValueError("must have > 0 rows and columns")
+
+
+cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out):
+    cdef size_t ptr, row_in, row_out=0, loc, cur=0
+    cdef size_t n_rows_in=matrix.shape[0], n_cols_in=matrix.shape[1]
+    cdef idxint nnz = csr.nnz(matrix)
+    cdef CSR out
+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+    out = csr.empty(n_rows_out, n_cols_out, nnz)
+    matrix.sort_indices()
+    with nogil:
+        # Since the indices are now sorted, the data arrays will be identical.
+        memcpy(out.data, matrix.data, nnz*sizeof(double complex))
+        memset(out.row_index, 0, (n_rows_out + 1) * sizeof(idxint))
+        for row_in in range(n_rows_in):
+            for ptr in range(matrix.row_index[row_in], matrix.row_index[row_in+1]):
+                loc = cur + matrix.col_index[ptr]
+                out.row_index[loc // n_cols_out + 1] += 1
+                out.col_index[ptr] = loc % n_cols_out
+            cur += n_cols_in
+        for row_out in range(n_rows_out):
+            out.row_index[row_out + 1] += out.row_index[row_out]
+    return out
+
+
+cdef inline idxint _reshape_dense_reindex(idxint idx, idxint size):
+    return (idx // size) + (idx % size)
+
+
+cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+    cdef Dense out
+    if not matrix.fortran:
+        out = matrix.copy()
+        out.shape = (n_rows_out, n_cols_out)
+        return out
+    out = dense.zeros(n_rows_out, n_cols_out)
+    cdef size_t idx_in=0, idx_out=0
+    cdef size_t size = n_rows_out * n_cols_out
+    # TODO: improve the algorithm here.
+    cdef size_t stride = _reshape_dense_reindex(matrix.shape[1]*n_rows_out, size)
+    for idx_in in range(size):
+        out.data[idx_out] = matrix.data[idx_in]
+        idx_out = _reshape_dense_reindex(idx_out + stride, size)
+    return out
+
+
+cpdef CSR column_stack_csr(CSR matrix):
+    if matrix.shape[1] == 1:
+        return matrix.copy()
+    return reshape_csr(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+
+
+cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
+    cdef Dense out
+    if inplace and matrix.fortran:
+        matrix.shape = (matrix.shape[0] * matrix.shape[1], 1)
+        return matrix
+    if matrix.fortran:
+        out = matrix.copy()
+        out.shape = (matrix.shape[0]*matrix.shape[1], 1)
+        return out
+    if inplace:
+        warnings.warn("cannot stack columns inplace for C-ordered matrix")
+    return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+
+
+cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
+    if matrix.shape[1] != 1:
+        raise ValueError("input is not a single column")
+    if rows < 1:
+        raise ValueError("rows must be a positive integer")
+    if matrix.shape[0] % rows:
+        raise ValueError("number of rows does not divide into the shape")
+
+
+cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
+    _column_unstack_check_shape(matrix, rows)
+    cdef idxint cols = matrix.shape[0] // rows
+    return reshape_csr(matrix, cols, rows).transpose()
+
+cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
+    _column_unstack_check_shape(matrix, rows)
+    cdef idxint cols = matrix.shape[0] // rows
+    if inplace and matrix.fortran:
+        matrix.shape = (rows, cols)
+        return matrix
+    elif inplace:
+        warnings.warn("cannot unstack columns inplace for C-ordered matrix")
+    out = dense.empty(rows, cols, fortran=True)
+    memcpy(out.data, matrix.data, rows*cols * sizeof(double complex))
+    return out
+
+
+cpdef list split_columns_dense(Dense matrix, copy=True):
+    return [Dense(matrix.as_ndarray()[:, k], copy=copy)
+            for k in range(matrix.shape[1])]
+
+cpdef list split_columns_csr(CSR matrix, copy=True):
+    return [CSR(matrix.as_scipy()[:, k], copy=copy)
+            for k in range(matrix.shape[1])]
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+reshape = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('n_rows_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('n_cols_out', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='reshape',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+reshape.__doc__ =\
+    """
+    Reshape the input matrix.  The values of `n_rows_out` and `n_cols_out` must
+    match the current total number of elements of the matrix.
+
+    Parameters
+    ----------
+    matrix : Data
+        The input matrix to reshape.
+
+    n_rows_out, n_cols_out : integer
+        The number of rows and columns in the output matrix.
+    """
+reshape.add_specialisations([
+    (CSR, CSR, reshape_csr),
+    (Dense, Dense, reshape_dense),
+], _defer=True)
+
+
+# Similar to the `out` parameter of `matmul`, we don't include `inplace` in the
+# signature of `column_stack` because the dispatcher logic currently doesn't
+# support the idea of an input parameter also being the output.
+
+column_stack = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='column_stack',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+column_stack.__doc__ =\
+    """
+    Stack the columns of a matrix so it becomes a ket-like vector.  For
+    example, the matrix
+        [[0, 1, 2],
+         [3, 4, 5],
+         [6, 7, 8]]
+    would be transformed to
+        [[0],
+         [3],
+         [6],
+         [1],
+         ...
+         [5],
+         [8]]
+    This is used for transforming between operator and operator-ket
+    representations in the super-operator formalism.
+
+    The inverse of this operation is `column_unstack`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to stack the columns of.
+    """
+column_stack.add_specialisations([
+    (CSR, CSR, column_stack_csr),
+    (Dense, Dense, column_stack_dense),
+], _defer=True)
+
+column_unstack = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('rows', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='column_unstack',
+    module=__name__,
+    inputs=('matrix',),
+    out=True,
+)
+column_unstack.__doc__ =\
+    """
+    Unstack the columns of a ket-like vector so it becomes a matrix with `rows`
+    number of rows.  For example, the matrix
+        [[0],
+         [1],
+         [2],
+         [3]]
+    would be unstacked with `rows = 2` to
+        [[0, 2],
+         [1, 3]]
+    This is used for transforming between the operator-ket and operator
+    representations in the super-operator formalism.
+
+    The inverse of this operation is `column_stack`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to unstack the columns of.
+
+    rows : integer
+        The number of rows there should be in the output matrix.  This must
+        divide into the total number of elements in the input.
+    """
+column_unstack.add_specialisations([
+    (CSR, CSR, column_unstack_csr),
+    (Dense, Dense, column_unstack_dense),
+], _defer=True)
+
+
+split_columns = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=1),
+    ]),
+    name='split_columns',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+split_columns.__doc__ =\
+    """
+    Make a ket-shaped data out of each columns of the matrix.
+    This is used for to split the eigenvectors from :obj:`eigs`.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to unstack the columns of.
+
+    copy : bool, optional
+        The number of rows there should be in the output matrix.  This must
+        divide into the total number of elements in the input.
+
+    Returns
+    -------
+    kets : list
+        list of Data of each columns of the matrix.
+    """
+split_columns.add_specialisations([
+    (CSR, split_columns_csr),
+    (Dense, split_columns_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index 30cb4dd6c2..a164d4f745 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -1,208 +1,208 @@
-from qutip.core.data import CSR, Data, csr, Dense
-import qutip.core.data as _data
-import scipy.sparse.linalg as splinalg
-import numpy as np
-from qutip.settings import settings
-if settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_spsolve
-else:
-    mkl_spsolve = None
-
-
-def _splu(A, B, **kwargs):
-    lu = splinalg.splu(A, **kwargs)
-    return lu.solve(B)
-
-
-def solve_csr_dense(matrix: CSR, target: Dense, method=None,
-                    options: dict={}) -> Dense:
-    """
-    Solve ``Ax=b`` for ``x``.
-
-    Parameters:
-    -----------
-
-    matrix : CSR
-        The matrix ``A``.
-
-    target : Data
-        The matrix or vector ``b``.
-
-    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
-        The function to use to solve the system. Any function from
-        scipy.sparse.linalg which solve the equation Ax=b can be used.
-        `splu` from the same and `mkl_spsolve` are also valid choice.
-
-    options : dict
-        Keywork options to pass to the solver. Refer to the documenentation in
-        scipy.sparse.linalg of the used method for a list of supported keyword.
-        The keyword "csc" can be set to ``True`` to convert the sparse matrix
-        before passing it to the solver.
-
-    .. note::
-        Options for ``mkl_spsolve`` are presently only found in the source
-        code.
-
-    Returns:
-    --------
-    x : Dense
-        Solution to the system Ax = b.
-    """
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only solve using square matrix")
-    if matrix.shape[1] != target.shape[0]:
-        raise ValueError("target does not match the system")
-
-    b = target.as_ndarray()
-
-    method = method or "spsolve"
-
-    if method == "splu":
-        solver = _splu
-    elif hasattr(splinalg, method):
-        solver = getattr(splinalg, method)
-    elif method == "mkl_spsolve" and mkl_spsolve is None:
-        raise ValueError("mkl is not available")
-    elif method == "mkl_spsolve":
-        solver = mkl_spsolve
-    else:
-        raise ValueError(f"Unknown sparse solver {method}.")
-
-    options = options.copy()
-    M = matrix.as_scipy()
-    if options.pop("csc", False):
-        M = M.tocsc()
-
-    out = solver(M, b, **options)
-
-    if isinstance(out, tuple) and len(out) == 2:
-        # iterative method return a success flag
-        out, check = out
-        if check == 0:
-            # Successful
-            pass
-        elif check > 0:
-            raise RuntimeError(
-                f"scipy.sparse.linalg.{method} error: Tolerance was not"
-                f" reached. Error code: {check}"
-            )
-
-        elif check < 0:
-            raise RuntimeError(
-                f"scipy.sparse.linalg.{method} error: Bad input. "
-                f"Error code: {check}"
-            )
-    elif isinstance(out, tuple) and len(out) > 2:
-        # least sqare method return residual, flag, etc.
-        out, *_ = out
-    return Dense(out, copy=False)
-
-
-def solve_dense(matrix: Dense, target: Data, method=None,
-                options: dict={}) -> Dense:
-    """
-    Solve ``Ax=b`` for ``x``.
-
-    Parameters:
-    -----------
-
-    matrix : Dense
-        The matrix ``A``.
-
-    target : Data
-        The matrix or vector ``b``.
-
-    method : str {"solve", "lstsq"}, default="solve"
-        The function from numpy.linalg to use to solve the system.
-
-    options : dict
-        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
-        not use any.
-
-    Returns:
-    --------
-    x : Dense
-        Solution to the system Ax = b.
-    """
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("can only solve using square matrix")
-    if matrix.shape[1] != target.shape[0]:
-        raise ValueError("target does not match the system")
-
-    if isinstance(target, Dense):
-        b = target.as_ndarray()
-    else:
-        b = target.to_array()
-
-    if method in ["solve", None]:
-        out = np.linalg.solve(matrix.as_ndarray(), b)
-    elif method == "lstsq":
-        out, *_ = np.linalg.lstsq(
-            matrix.as_ndarray(),
-            b,
-            rcond=options.get("rcond", None)
-        )
-    else:
-        raise ValueError(f"Unknown solver {method},"
-                         " 'solve' and 'lstsq' are supported.")
-    return Dense(out, copy=False)
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-
-solve = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=None),
-        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default={}),
-    ]),
-    name='solve',
-    module=__name__,
-    inputs=('matrix', 'target'),
-    out=True,
-)
-solve.__doc__ = """
-    Solve ``Ax=b`` for ``x``.
-
-    Parameters:
-    -----------
-    matrix : Data
-    The matrix ``A``.
-
-    target : Data
-    The matrix or vector ``b``.
-
-    method : str
-        The function to use to solve the system. Function which solve the
-        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
-        numpy.linalg (Dense ``matrix``) can be used.
-        Sparse cases also accept `splu` and `mkl_spsolve`.
-
-    options : dict
-        Keywork options to pass to the solver. Refer to the documenentation
-        for the chosen method in scipy.sparse.linalg or numpy.linalg.
-        The keyword "csc" can be set to ``True`` to convert the sparse matrix
-        in sparse cases.
-
-    .. note::
-        Options for ``mkl_spsolve`` are presently only found in the source
-        code.
-
-    Returns:
-    --------
-    x : Data
-        Solution to the system Ax = b.
-"""
-solve.add_specialisations([
-    (CSR, Dense, Dense, solve_csr_dense),
-    (Dense, Dense, Dense, solve_dense),
-], _defer=True)
-
-
-del _Dispatcher
-del _inspect
+from qutip.core.data import CSR, Data, csr, Dense
+import qutip.core.data as _data
+import scipy.sparse.linalg as splinalg
+import numpy as np
+from qutip.settings import settings
+if settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_spsolve
+else:
+    mkl_spsolve = None
+
+
+def _splu(A, B, **kwargs):
+    lu = splinalg.splu(A, **kwargs)
+    return lu.solve(B)
+
+
+def solve_csr_dense(matrix: CSR, target: Dense, method=None,
+                    options: dict={}) -> Dense:
+    """
+    Solve ``Ax=b`` for ``x``.
+
+    Parameters:
+    -----------
+
+    matrix : CSR
+        The matrix ``A``.
+
+    target : Data
+        The matrix or vector ``b``.
+
+    method : str {"spsolve", "splu", "mkl_spsolve", etc.}, default="spsolve"
+        The function to use to solve the system. Any function from
+        scipy.sparse.linalg which solve the equation Ax=b can be used.
+        `splu` from the same and `mkl_spsolve` are also valid choice.
+
+    options : dict
+        Keywork options to pass to the solver. Refer to the documenentation in
+        scipy.sparse.linalg of the used method for a list of supported keyword.
+        The keyword "csc" can be set to ``True`` to convert the sparse matrix
+        before passing it to the solver.
+
+    .. note::
+        Options for ``mkl_spsolve`` are presently only found in the source
+        code.
+
+    Returns:
+    --------
+    x : Dense
+        Solution to the system Ax = b.
+    """
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only solve using square matrix")
+    if matrix.shape[1] != target.shape[0]:
+        raise ValueError("target does not match the system")
+
+    b = target.as_ndarray()
+
+    method = method or "spsolve"
+
+    if method == "splu":
+        solver = _splu
+    elif hasattr(splinalg, method):
+        solver = getattr(splinalg, method)
+    elif method == "mkl_spsolve" and mkl_spsolve is None:
+        raise ValueError("mkl is not available")
+    elif method == "mkl_spsolve":
+        solver = mkl_spsolve
+    else:
+        raise ValueError(f"Unknown sparse solver {method}.")
+
+    options = options.copy()
+    M = matrix.as_scipy()
+    if options.pop("csc", False):
+        M = M.tocsc()
+
+    out = solver(M, b, **options)
+
+    if isinstance(out, tuple) and len(out) == 2:
+        # iterative method return a success flag
+        out, check = out
+        if check == 0:
+            # Successful
+            pass
+        elif check > 0:
+            raise RuntimeError(
+                f"scipy.sparse.linalg.{method} error: Tolerance was not"
+                f" reached. Error code: {check}"
+            )
+
+        elif check < 0:
+            raise RuntimeError(
+                f"scipy.sparse.linalg.{method} error: Bad input. "
+                f"Error code: {check}"
+            )
+    elif isinstance(out, tuple) and len(out) > 2:
+        # least sqare method return residual, flag, etc.
+        out, *_ = out
+    return Dense(out, copy=False)
+
+
+def solve_dense(matrix: Dense, target: Data, method=None,
+                options: dict={}) -> Dense:
+    """
+    Solve ``Ax=b`` for ``x``.
+
+    Parameters:
+    -----------
+
+    matrix : Dense
+        The matrix ``A``.
+
+    target : Data
+        The matrix or vector ``b``.
+
+    method : str {"solve", "lstsq"}, default="solve"
+        The function from numpy.linalg to use to solve the system.
+
+    options : dict
+        Options to pass to the solver. "lstsq" use "rcond" while, "solve" do
+        not use any.
+
+    Returns:
+    --------
+    x : Dense
+        Solution to the system Ax = b.
+    """
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only solve using square matrix")
+    if matrix.shape[1] != target.shape[0]:
+        raise ValueError("target does not match the system")
+
+    if isinstance(target, Dense):
+        b = target.as_ndarray()
+    else:
+        b = target.to_array()
+
+    if method in ["solve", None]:
+        out = np.linalg.solve(matrix.as_ndarray(), b)
+    elif method == "lstsq":
+        out, *_ = np.linalg.lstsq(
+            matrix.as_ndarray(),
+            b,
+            rcond=options.get("rcond", None)
+        )
+    else:
+        raise ValueError(f"Unknown solver {method},"
+                         " 'solve' and 'lstsq' are supported.")
+    return Dense(out, copy=False)
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+solve = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('target', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('method', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=None),
+        _inspect.Parameter('options', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default={}),
+    ]),
+    name='solve',
+    module=__name__,
+    inputs=('matrix', 'target'),
+    out=True,
+)
+solve.__doc__ = """
+    Solve ``Ax=b`` for ``x``.
+
+    Parameters:
+    -----------
+    matrix : Data
+    The matrix ``A``.
+
+    target : Data
+    The matrix or vector ``b``.
+
+    method : str
+        The function to use to solve the system. Function which solve the
+        equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
+        numpy.linalg (Dense ``matrix``) can be used.
+        Sparse cases also accept `splu` and `mkl_spsolve`.
+
+    options : dict
+        Keywork options to pass to the solver. Refer to the documenentation
+        for the chosen method in scipy.sparse.linalg or numpy.linalg.
+        The keyword "csc" can be set to ``True`` to convert the sparse matrix
+        in sparse cases.
+
+    .. note::
+        Options for ``mkl_spsolve`` are presently only found in the source
+        code.
+
+    Returns:
+    --------
+    x : Data
+        Solution to the system Ax = b.
+"""
+solve.add_specialisations([
+    (CSR, Dense, Dense, solve_csr_dense),
+    (Dense, Dense, Dense, solve_dense),
+], _defer=True)
+
+
+del _Dispatcher
+del _inspect
diff --git a/qutip/core/data/src/intdtype.h b/qutip/core/data/src/intdtype.h
index 40920a715c..f88c65f952 100644
--- a/qutip/core/data/src/intdtype.h
+++ b/qutip/core/data/src/intdtype.h
@@ -1,2 +1,2 @@
-typedef int32_t idxint;
-int _idxint_size=32;
+typedef int32_t idxint;
+int _idxint_size=32;
diff --git a/qutip/core/data/src/matmul_csr_vector.cpp b/qutip/core/data/src/matmul_csr_vector.cpp
index 08424c0250..2294f3b754 100644
--- a/qutip/core/data/src/matmul_csr_vector.cpp
+++ b/qutip/core/data/src/matmul_csr_vector.cpp
@@ -1,116 +1,116 @@
-#include <complex>
-#if \
-    (defined(__GNUC__) && defined(__SSE3__))\
-    || (defined(_MSC_VER) && defined(__AVX__))
-/* If we're going to manually do the vectorisation, we need to make sure we've
- * included the preprocessor directives.
- */
-# include <pmmintrin.h>
-#endif
-
-#include "matmul_csr_vector.hpp"
-
-template <typename IntT>
-#if \
-    (defined(__GNUC__) && defined(__SSE3__))\
-    || (defined(_MSC_VER) && defined(__AVX__))
-/* Manually apply the vectorisation. */
-void _matmul_csr_vector(
-        const std::complex<double> * _RESTRICT data,
-        const IntT * _RESTRICT col_index,
-        const IntT * _RESTRICT row_index,
-        const std::complex<double> * _RESTRICT vec,
-        const std::complex<double> scale,
-        std::complex<double> * _RESTRICT out,
-        const IntT nrows)
-{
-    IntT row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    for (IntT row=0; row < nrows; row++) {
-        num4 = _mm_setzero_pd();
-        row_start = row_index[row];
-        row_end = row_index[row+1];
-        for (IntT ptr=row_start; ptr < row_end; ptr++) {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
-            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
-                              std::real(vec[col_index[ptr]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
-    }
-}
-#else
-/* No manual vectorisation. */
-void _matmul_csr_vector(
-        const std::complex<double> * _RESTRICT data,
-        const IntT * _RESTRICT col_index,
-        const IntT * _RESTRICT row_index,
-        const std::complex<double> * _RESTRICT vec,
-        const std::complex<double> scale,
-        std::complex<double> * _RESTRICT out,
-        const IntT nrows)
-{
-    IntT row_start, row_end;
-    std::complex<double> dot;
-    for (size_t row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = row_index[row];
-        row_end = row_index[row+1];
-        for (size_t ptr=row_start; ptr < row_end; ptr++)
-        {
-            dot += data[ptr]*vec[col_index[ptr]];
-        }
-        out[row] += scale * dot;
-    }
-}
-#endif
-
-/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
- * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
- * latter causes compatibility issues with defining the sized types with the
- * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
- * three of `int`, `long` and `long long` when doing things this way (despite
- * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
- * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
- * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
- * and `long long`.
- * - Jake Lishman 2020-08-10.
- */
-template void _matmul_csr_vector<>(
-        const std::complex<double> * _RESTRICT,
-        const int * _RESTRICT,
-        const int * _RESTRICT,
-        const std::complex<double> * _RESTRICT,
-        const std::complex<double>,
-        std::complex<double> * _RESTRICT,
-        const int);
-template void _matmul_csr_vector<>(
-        const std::complex<double> * _RESTRICT,
-        const long * _RESTRICT,
-        const long * _RESTRICT,
-        const std::complex<double> * _RESTRICT,
-        const std::complex<double>,
-        std::complex<double> * _RESTRICT,
-        const long);
-template void _matmul_csr_vector<>(
-        const std::complex<double> * _RESTRICT,
-        const long long * _RESTRICT,
-        const long long * _RESTRICT,
-        const std::complex<double> * _RESTRICT,
-        const std::complex<double>,
-        std::complex<double> * _RESTRICT,
-        const long long);
+#include <complex>
+#if \
+    (defined(__GNUC__) && defined(__SSE3__))\
+    || (defined(_MSC_VER) && defined(__AVX__))
+/* If we're going to manually do the vectorisation, we need to make sure we've
+ * included the preprocessor directives.
+ */
+# include <pmmintrin.h>
+#endif
+
+#include "matmul_csr_vector.hpp"
+
+template <typename IntT>
+#if \
+    (defined(__GNUC__) && defined(__SSE3__))\
+    || (defined(_MSC_VER) && defined(__AVX__))
+/* Manually apply the vectorisation. */
+void _matmul_csr_vector(
+        const std::complex<double> * _RESTRICT data,
+        const IntT * _RESTRICT col_index,
+        const IntT * _RESTRICT row_index,
+        const std::complex<double> * _RESTRICT vec,
+        const std::complex<double> scale,
+        std::complex<double> * _RESTRICT out,
+        const IntT nrows)
+{
+    IntT row_start, row_end;
+    __m128d num1, num2, num3, num4;
+    for (IntT row=0; row < nrows; row++) {
+        num4 = _mm_setzero_pd();
+        row_start = row_index[row];
+        row_end = row_index[row+1];
+        for (IntT ptr=row_start; ptr < row_end; ptr++) {
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[0]);
+            num2 = _mm_set_pd(std::imag(vec[col_index[ptr]]),
+                              std::real(vec[col_index[ptr]]));
+            num3 = _mm_mul_pd(num2, num1);
+            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[ptr])[1]);
+            num2 = _mm_shuffle_pd(num2, num2, 1);
+            num2 = _mm_mul_pd(num2, num1);
+            num3 = _mm_addsub_pd(num3, num2);
+            num4 = _mm_add_pd(num3, num4);
+        }
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[0]);
+        num3 = _mm_mul_pd(num4, num1);
+        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(scale)[1]);
+        num4 = _mm_shuffle_pd(num4, num4, 1);
+        num4 = _mm_mul_pd(num4, num1);
+        num3 = _mm_addsub_pd(num3, num4);
+        num2 = _mm_loadu_pd((double *)&out[row]);
+        num3 = _mm_add_pd(num2, num3);
+        _mm_storeu_pd((double *)&out[row], num3);
+    }
+}
+#else
+/* No manual vectorisation. */
+void _matmul_csr_vector(
+        const std::complex<double> * _RESTRICT data,
+        const IntT * _RESTRICT col_index,
+        const IntT * _RESTRICT row_index,
+        const std::complex<double> * _RESTRICT vec,
+        const std::complex<double> scale,
+        std::complex<double> * _RESTRICT out,
+        const IntT nrows)
+{
+    IntT row_start, row_end;
+    std::complex<double> dot;
+    for (size_t row=0; row < nrows; row++)
+    {
+        dot = 0;
+        row_start = row_index[row];
+        row_end = row_index[row+1];
+        for (size_t ptr=row_start; ptr < row_end; ptr++)
+        {
+            dot += data[ptr]*vec[col_index[ptr]];
+        }
+        out[row] += scale * dot;
+    }
+}
+#endif
+
+/* It seems wrong to me to specify the integer specialisations as `int`, `long` and
+ * `long long` rather than just `int32_t` and `int64_t`, but for some reason the
+ * latter causes compatibility issues with defining the sized types with the
+ * numpy `cnp.npy_int32` and `cnp.npy_int64` typedefs.  We need to specify all
+ * three of `int`, `long` and `long long` when doing things this way (despite
+ * the almost certain duplication) because on Unix-likes (where `int`[`long`] is
+ * typically 32[64]-bit) numpy typedef's int32 to int and int64 to long, whereas
+ * on Windows (where `int` and `long` are both 32-bit), it typedef's to `long`
+ * and `long long`.
+ * - Jake Lishman 2020-08-10.
+ */
+template void _matmul_csr_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const int * _RESTRICT,
+        const int * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double>,
+        std::complex<double> * _RESTRICT,
+        const int);
+template void _matmul_csr_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const long * _RESTRICT,
+        const long * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double>,
+        std::complex<double> * _RESTRICT,
+        const long);
+template void _matmul_csr_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const long long * _RESTRICT,
+        const long long * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double>,
+        std::complex<double> * _RESTRICT,
+        const long long);
diff --git a/qutip/core/data/src/matmul_csr_vector.hpp b/qutip/core/data/src/matmul_csr_vector.hpp
index 4dd3e72ea0..694329ac37 100755
--- a/qutip/core/data/src/matmul_csr_vector.hpp
+++ b/qutip/core/data/src/matmul_csr_vector.hpp
@@ -1,17 +1,17 @@
-#include <complex>
-
-#if defined(__GNUC__) || defined(_MSC_VER)
-# define _RESTRICT __restrict
-#else
-# define _RESTRICT
-#endif
-
-template <typename IntT>
-void _matmul_csr_vector(
-        const std::complex<double> * _RESTRICT data,
-        const IntT * _RESTRICT col_index,
-        const IntT * _RESTRICT row_index,
-        const std::complex<double> * _RESTRICT vec,
-        const std::complex<double> scale,
-        std::complex<double> * _RESTRICT out,
-        const IntT nrows);
+#include <complex>
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+# define _RESTRICT __restrict
+#else
+# define _RESTRICT
+#endif
+
+template <typename IntT>
+void _matmul_csr_vector(
+        const std::complex<double> * _RESTRICT data,
+        const IntT * _RESTRICT col_index,
+        const IntT * _RESTRICT row_index,
+        const std::complex<double> * _RESTRICT vec,
+        const std::complex<double> scale,
+        std::complex<double> * _RESTRICT out,
+        const IntT nrows);
diff --git a/qutip/core/data/tidyup.pxd b/qutip/core/data/tidyup.pxd
index cd88c2900c..4444714507 100644
--- a/qutip/core/data/tidyup.pxd
+++ b/qutip/core/data/tidyup.pxd
@@ -1,7 +1,7 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
-cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
+cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
index b733871855..a9b80798f1 100644
--- a/qutip/core/data/tidyup.pyx
+++ b/qutip/core/data/tidyup.pyx
@@ -1,106 +1,106 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.math cimport fabs
-
-cimport numpy as cnp
-
-from qutip.core.data cimport csr, dense, CSR, Dense
-
-cdef extern from "<complex>" namespace "std" nogil:
-    # abs is templated such that Cython treats std::abs as complex->complex
-    double abs(double complex x)
-
-__all__ = [
-    'tidyup', 'tidyup_csr', 'tidyup_dense',
-]
-
-
-cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
-    cdef bint re, im
-    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
-    cdef double complex value
-    cdef CSR out = matrix if inplace else matrix.copy()
-    nnz = 0
-    out.row_index[0] = 0
-    for row in range(matrix.shape[0]):
-        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
-        for ptr in range(ptr_start, ptr_end):
-            re = im = False
-            value = matrix.data[ptr]
-            if fabs(value.real) < tol:
-                re = True
-                value.real = 0
-            if fabs(value.imag) < tol:
-                im = True
-                value.imag = 0
-            if not (re & im):
-                out.data[nnz] = value
-                out.col_index[nnz] = matrix.col_index[ptr]
-                nnz += 1
-        out.row_index[row + 1] = nnz
-    return out
-
-
-cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
-    cdef Dense out = matrix if inplace else matrix.copy()
-    cdef double complex value
-    cdef size_t ptr
-    for ptr in range(matrix.shape[0] * matrix.shape[1]):
-        value = matrix.data[ptr]
-        if fabs(value.real) < tol:
-            matrix.data[ptr].real = 0
-        if fabs(value.imag) < tol:
-            matrix.data[ptr].imag = 0
-    return out
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-# In this case, to support the `inplace` argument, we do not support
-# dispatching on the output.
-
-tidyup = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                           default=True),
-    ]),
-    name='tidyup',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-tidyup.__doc__ =\
-    """
-    Tidy up the input matrix by truncating small values to zero.  The real and
-    imaginary parts are treated individually, so (for example) the number
-        1e-18 + 2j
-    would be truncated with a tolerance of `1e-15` to just
-        2j
-
-    By default, this operation is in-place.  The output type will always match
-    the input type; no dispatching takes place on the output.
-
-    Parameters
-    ----------
-    matrix : Data
-        The matrix to tidy up.
-
-    tol : real
-        The absolute tolerance to use to determine whether a real or imaginary
-        part should be truncated to zero.
-
-    inplace : bool, optional (True)
-        Whether to do the operation in-place.  The output matrix will always be
-        returned, even if this argument is `True`; it will just be the same
-        Python object as was input.
-    """
-tidyup.add_specialisations([
-    (CSR, tidyup_csr),
-    (Dense, tidyup_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.math cimport fabs
+
+cimport numpy as cnp
+
+from qutip.core.data cimport csr, dense, CSR, Dense
+
+cdef extern from "<complex>" namespace "std" nogil:
+    # abs is templated such that Cython treats std::abs as complex->complex
+    double abs(double complex x)
+
+__all__ = [
+    'tidyup', 'tidyup_csr', 'tidyup_dense',
+]
+
+
+cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=True):
+    cdef bint re, im
+    cdef size_t row, ptr, ptr_start, ptr_end=0, nnz
+    cdef double complex value
+    cdef CSR out = matrix if inplace else matrix.copy()
+    nnz = 0
+    out.row_index[0] = 0
+    for row in range(matrix.shape[0]):
+        ptr_start, ptr_end = ptr_end, matrix.row_index[row + 1]
+        for ptr in range(ptr_start, ptr_end):
+            re = im = False
+            value = matrix.data[ptr]
+            if fabs(value.real) < tol:
+                re = True
+                value.real = 0
+            if fabs(value.imag) < tol:
+                im = True
+                value.imag = 0
+            if not (re & im):
+                out.data[nnz] = value
+                out.col_index[nnz] = matrix.col_index[ptr]
+                nnz += 1
+        out.row_index[row + 1] = nnz
+    return out
+
+
+cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
+    cdef Dense out = matrix if inplace else matrix.copy()
+    cdef double complex value
+    cdef size_t ptr
+    for ptr in range(matrix.shape[0] * matrix.shape[1]):
+        value = matrix.data[ptr]
+        if fabs(value.real) < tol:
+            matrix.data[ptr].real = 0
+        if fabs(value.imag) < tol:
+            matrix.data[ptr].imag = 0
+    return out
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+# In this case, to support the `inplace` argument, we do not support
+# dispatching on the output.
+
+tidyup = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('tol', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('inplace', _inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                           default=True),
+    ]),
+    name='tidyup',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+tidyup.__doc__ =\
+    """
+    Tidy up the input matrix by truncating small values to zero.  The real and
+    imaginary parts are treated individually, so (for example) the number
+        1e-18 + 2j
+    would be truncated with a tolerance of `1e-15` to just
+        2j
+
+    By default, this operation is in-place.  The output type will always match
+    the input type; no dispatching takes place on the output.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to tidy up.
+
+    tol : real
+        The absolute tolerance to use to determine whether a real or imaginary
+        part should be truncated to zero.
+
+    inplace : bool, optional (True)
+        Whether to do the operation in-place.  The output matrix will always be
+        returned, even if this argument is `True`; it will just be the same
+        Python object as was input.
+    """
+tidyup.add_specialisations([
+    (CSR, tidyup_csr),
+    (Dense, tidyup_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index 0c9a9d4d10..e231896f8f 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -1,9 +1,9 @@
-#cython: language_level=3
-
-from qutip.core.data cimport CSR, Dense
-
-cpdef double complex trace_csr(CSR matrix) nogil except *
-cpdef double complex trace_dense(Dense matrix) nogil except *
-
-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
+#cython: language_level=3
+
+from qutip.core.data cimport CSR, Dense
+
+cpdef double complex trace_csr(CSR matrix) nogil except *
+cpdef double complex trace_dense(Dense matrix) nogil except *
+
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 5dec3f6de0..c256f537cc 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -1,109 +1,109 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-cimport cython
-from libc.math cimport sqrt
-
-from qutip.core.data cimport Data, CSR, Dense
-from qutip.core.data cimport base
-
-__all__ = [
-    'trace', 'trace_csr', 'trace_dense',
-    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
-]
-
-
-cdef void _check_shape(Data matrix) nogil except *:
-    if matrix.shape[0] != matrix.shape[1]:
-        raise ValueError("".join([
-            "matrix shape ", str(matrix.shape), " is not square.",
-        ]))
-
-
-cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
-    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
-        raise ValueError("".join([
-            "matrix ", str(matrix.shape), " is not a stacked square matrix."
-        ]))
-
-
-cpdef double complex trace_csr(CSR matrix) nogil except *:
-    _check_shape(matrix)
-    cdef size_t row, ptr
-    cdef double complex trace = 0
-    for row in range(matrix.shape[0]):
-        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
-            if matrix.col_index[ptr] == row:
-                trace += matrix.data[ptr]
-                break
-    return trace
-
-cpdef double complex trace_dense(Dense matrix) nogil except *:
-    _check_shape(matrix)
-    cdef double complex trace = 0
-    cdef size_t ptr = 0
-    cdef size_t stride = matrix.shape[0] + 1
-    for _ in range(matrix.shape[0]):
-        trace += matrix.data[ptr]
-        ptr += stride
-    return trace
-
-
-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
-    cdef size_t N = <size_t>sqrt(matrix.shape[0])
-    _check_shape_oper_ket(N, matrix)
-    cdef size_t row
-    cdef double complex trace = 0
-    cdef size_t stride = N + 1
-    for row in range(N):
-        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
-            trace += matrix.data[matrix.row_index[row * stride]]
-    return trace
-
-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
-    cdef size_t N = <size_t>sqrt(matrix.shape[0])
-    _check_shape_oper_ket(N, matrix)
-    cdef double complex trace = 0
-    cdef size_t ptr = 0
-    cdef size_t stride = N + 1
-    for ptr in range(N):
-        trace += matrix.data[ptr * stride]
-    return trace
-
-
-from .dispatch import Dispatcher as _Dispatcher
-import inspect as _inspect
-
-trace = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='trace',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-trace.__doc__ =\
-    """Compute the trace (sum of digaonal elements) of a square matrix."""
-trace.add_specialisations([
-    (CSR, trace_csr),
-    (Dense, trace_dense),
-], _defer=True)
-
-trace_oper_ket = _Dispatcher(
-    _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
-    ]),
-    name='trace_oper_ket',
-    module=__name__,
-    inputs=('matrix',),
-    out=False,
-)
-trace_oper_ket.__doc__ =\
-    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
-trace_oper_ket.add_specialisations([
-    (CSR, trace_oper_ket_csr),
-    (Dense, trace_oper_ket_dense),
-], _defer=True)
-
-del _inspect, _Dispatcher
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+cimport cython
+from libc.math cimport sqrt
+
+from qutip.core.data cimport Data, CSR, Dense
+from qutip.core.data cimport base
+
+__all__ = [
+    'trace', 'trace_csr', 'trace_dense',
+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
+]
+
+
+cdef void _check_shape(Data matrix) nogil except *:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("".join([
+            "matrix shape ", str(matrix.shape), " is not square.",
+        ]))
+
+
+cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
+    if matrix.shape[0] != N * N or matrix.shape[1] != 1:
+        raise ValueError("".join([
+            "matrix ", str(matrix.shape), " is not a stacked square matrix."
+        ]))
+
+
+cpdef double complex trace_csr(CSR matrix) nogil except *:
+    _check_shape(matrix)
+    cdef size_t row, ptr
+    cdef double complex trace = 0
+    for row in range(matrix.shape[0]):
+        for ptr in range(matrix.row_index[row], matrix.row_index[row + 1]):
+            if matrix.col_index[ptr] == row:
+                trace += matrix.data[ptr]
+                break
+    return trace
+
+cpdef double complex trace_dense(Dense matrix) nogil except *:
+    _check_shape(matrix)
+    cdef double complex trace = 0
+    cdef size_t ptr = 0
+    cdef size_t stride = matrix.shape[0] + 1
+    for _ in range(matrix.shape[0]):
+        trace += matrix.data[ptr]
+        ptr += stride
+    return trace
+
+
+cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef size_t row
+    cdef double complex trace = 0
+    cdef size_t stride = N + 1
+    for row in range(N):
+        if matrix.row_index[row * stride] != matrix.row_index[row * stride + 1]:
+            trace += matrix.data[matrix.row_index[row * stride]]
+    return trace
+
+cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef double complex trace = 0
+    cdef size_t ptr = 0
+    cdef size_t stride = N + 1
+    for ptr in range(N):
+        trace += matrix.data[ptr * stride]
+    return trace
+
+
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+trace = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='trace',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+trace.__doc__ =\
+    """Compute the trace (sum of digaonal elements) of a square matrix."""
+trace.add_specialisations([
+    (CSR, trace_csr),
+    (Dense, trace_dense),
+], _defer=True)
+
+trace_oper_ket = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+    ]),
+    name='trace_oper_ket',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+trace_oper_ket.__doc__ =\
+    """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
+trace_oper_ket.add_specialisations([
+    (CSR, trace_oper_ket_csr),
+    (Dense, trace_oper_ket_dense),
+], _defer=True)
+
+del _inspect, _Dispatcher
diff --git a/qutip/core/dimensions.py b/qutip/core/dimensions.py
index 612e97c8ff..a2a4003a52 100644
--- a/qutip/core/dimensions.py
+++ b/qutip/core/dimensions.py
@@ -1,345 +1,345 @@
-"""
-Internal use module for manipulating dims specifications.
-"""
-
-# Everything should be explicitly imported, not made available by default.
-
-import numpy as np
-from operator import getitem
-from functools import partial
-
-
-def is_scalar(dims):
-    """
-    Returns True if a dims specification is effectively
-    a scalar (has dimension 1).
-    """
-    return np.prod(flatten(dims)) == 1
-
-
-def is_vector(dims):
-    return (
-        isinstance(dims, list) and
-        isinstance(dims[0], (int, np.integer))
-    )
-
-
-def is_vectorized_oper(dims):
-    return (
-        isinstance(dims, list) and
-        isinstance(dims[0], list)
-    )
-
-
-def type_from_dims(dims, enforce_square=False):
-    bra_like, ket_like = map(is_scalar, dims)
-
-    if bra_like:
-        if is_vector(dims[1]):
-            return 'bra'
-        elif is_vectorized_oper(dims[1]):
-            return 'operator-bra'
-
-    if ket_like:
-        if is_vector(dims[0]):
-            return 'ket'
-        elif is_vectorized_oper(dims[0]):
-            return 'operator-ket'
-
-    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
-        return 'oper'
-
-    elif (
-        is_vectorized_oper(dims[0])
-        and (
-            not enforce_square
-            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
-        )
-    ):
-        return 'super'
-    return 'other'
-
-
-def flatten(l):
-    """Flattens a list of lists to the first level.
-
-    Given a list containing a mix of scalars and lists,
-    flattens down to a list of the scalars within the original
-    list.
-
-    Examples
-    --------
-
-    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
-    [0, 1, 2]
-
-    """
-    if not isinstance(l, list):
-        return [l]
-    else:
-        return sum(map(flatten, l), [])
-
-
-def deep_remove(l, *what):
-    """Removes scalars from all levels of a nested list.
-
-    Given a list containing a mix of scalars and lists,
-    returns a list of the same structure, but where one or
-    more scalars have been removed.
-
-    Examples
-    --------
-
-    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
-    [[[[1, 2]], [3, 4], [], [6, 7]]]
-
-    """
-    if isinstance(l, list):
-        # Make a shallow copy at this level.
-        l = l[:]
-        for to_remove in what:
-            if to_remove in l:
-                l.remove(to_remove)
-            else:
-                l = [deep_remove(elem, to_remove) for elem in l]
-    return l
-
-
-def unflatten(l, idxs):
-    """Unflattens a list by a given structure.
-
-    Given a list of scalars and a deep list of indices
-    as produced by `flatten`, returns an "unflattened"
-    form of the list. This perfectly inverts `flatten`.
-
-    Examples
-    --------
-
-    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
-    >>> idxs = enumerate_flat(l) # doctest: +SKIP
-    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
-    True
-
-    """
-    acc = []
-    for idx in idxs:
-        if isinstance(idx, list):
-            acc.append(unflatten(l, idx))
-        else:
-            acc.append(l[idx])
-    return acc
-
-
-def _enumerate_flat(l, idx=0):
-    if not isinstance(l, list):
-        # Found a scalar, so return and increment.
-        return idx, idx + 1
-    else:
-        # Found a list, so append all the scalars
-        # from it and recurse to keep the increment
-        # correct.
-        acc = []
-        for elem in l:
-            labels, idx = _enumerate_flat(elem, idx)
-            acc.append(labels)
-        return acc, idx
-
-
-def _collapse_composite_index(dims):
-    """
-    Given the dimensions specification for a composite index
-    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
-    returns a dimensions specification for an index of the same shape,
-    but collapsed to a single "leg." In the previous example, [2, 3]
-    would collapse to [6].
-    """
-    return [np.prod(dims)]
-
-
-def _collapse_dims_to_level(dims, level=1):
-    """
-    Recursively collapses all indices in a dimensions specification
-    appearing at a given level, such that the returned dimensions
-    specification does not represent any composite systems.
-    """
-    if level == 0:
-        return _collapse_composite_index(dims)
-    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
-
-
-def collapse_dims_oper(dims):
-    """
-    Given the dimensions specifications for a ket-, bra- or oper-type
-    Qobj, returns a dimensions specification describing the same shape
-    by collapsing all composite systems. For instance, the bra-type
-    dimensions specification ``[[2, 3], [1]]`` collapses to
-    ``[[6], [1]]``.
-
-    Parameters
-    ----------
-
-    dims : list of lists of ints
-        Dimensions specifications to be collapsed.
-
-    Returns
-    -------
-
-    collapsed_dims : list of lists of ints
-        Collapsed dimensions specification describing the same shape
-        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
-    """
-    return _collapse_dims_to_level(dims, 1)
-
-
-def collapse_dims_super(dims):
-    """
-    Given the dimensions specifications for an operator-ket-, operator-bra- or
-    super-type Qobj, returns a dimensions specification describing the same shape
-    by collapsing all composite systems. For instance, the super-type
-    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
-    ``[[[6], [6]], [[6], [6]]]``.
-
-    Parameters
-    ----------
-
-    dims : list of lists of ints
-        Dimensions specifications to be collapsed.
-
-    Returns
-    -------
-
-    collapsed_dims : list of lists of ints
-        Collapsed dimensions specification describing the same shape
-        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
-        in ``range(2)``.
-    """
-    return _collapse_dims_to_level(dims, 2)
-
-
-def enumerate_flat(l):
-    """Labels the indices at which scalars occur in a flattened list.
-
-    Given a list containing a mix of scalars and lists,
-    returns a list of the same structure, where each scalar
-    has been replaced by an index into the flattened list.
-
-    Examples
-    --------
-
-    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
-    [[[0], [1, 2]], 3]
-
-    """
-    return _enumerate_flat(l)[0]
-
-
-def deep_map(fn, collection, over=(tuple, list)):
-    if isinstance(collection, over):
-        return type(collection)(deep_map(fn, el, over) for el in collection)
-    else:
-        return fn(collection)
-
-
-def dims_to_tensor_perm(dims):
-    """
-    Given the dims of a Qobj instance, returns a list representing
-    a permutation from the flattening of that dims specification to
-    the corresponding tensor indices.
-
-    Parameters
-    ----------
-
-    dims : list
-        Dimensions specification for a Qobj.
-
-    Returns
-    -------
-
-    perm : list
-        A list such that ``data[flatten(dims)[idx]]`` gives the
-        index of the tensor ``data`` corresponding to the ``idx``th
-        dimension of ``dims``.
-    """
-    # We figure out the type of the dims specification,
-    # relaxing the requirement that operators be square.
-    # This means that dims_type need not coincide with
-    # Qobj.type, but that works fine for our purposes here.
-    dims_type = type_from_dims(dims, enforce_square=False)
-    perm = enumerate_flat(dims)
-    if dims_type in ('oper', 'ket', 'bra'):
-        return flatten(perm)
-
-    # If the type is other, we need to figure out if the
-    # dims is superlike on its outputs and inputs
-    # This is the case if the dims type for left or right
-    # are, respectively, oper-like.
-    if dims_type == 'other':
-        raise NotImplementedError("Not yet implemented for type='other'.")
-
-    # If we're still here, the story is more complicated. We'll
-    # follow the strategy of creating a permutation by using
-    # enumerate_flat then transforming the result to swap
-    # input and output indices of vectorized matrices, then flattening
-    # the result. We'll then rebuild indices using this permutation.
-    if dims_type in ('operator-ket', 'super'):
-        # Swap the input and output spaces of the right part of
-        # perm.
-        perm[1] = list(reversed(perm[1]))
-    if dims_type in ('operator-bra', 'super'):
-        # Ditto, but for the left indices.
-        perm[0] = list(reversed(perm[0]))
-    return flatten(perm)
-
-
-def dims_to_tensor_shape(dims):
-    """
-    Given the dims of a Qobj instance, returns the shape of the
-    corresponding tensor. This helps, for instance, resolve the
-    column-stacking convention for superoperators.
-
-    Parameters
-    ----------
-
-    dims : list
-        Dimensions specification for a Qobj.
-
-    Returns
-    -------
-
-    tensor_shape : tuple
-        NumPy shape of the corresponding tensor.
-    """
-    perm = dims_to_tensor_perm(dims)
-    dims = flatten(dims)
-    return tuple(map(partial(getitem, dims), perm))
-
-
-def dims_idxs_to_tensor_idxs(dims, indices):
-    """
-    Given the dims of a Qobj instance, and some indices into
-    dims, returns the corresponding tensor indices. This helps
-    resolve, for instance, that column-stacking for superoperators,
-    oper-ket and oper-bra implies that the input and output tensor
-    indices are reversed from their order in dims.
-
-    Parameters
-    ----------
-
-    dims : list
-        Dimensions specification for a Qobj.
-
-    indices : int, list or tuple
-        Indices to convert to tensor indices. Can be specified
-        as a single index, or as a collection of indices.
-        In the latter case, this can be nested arbitrarily
-        deep. For instance, [0, [0, (2, 3)]].
-
-    Returns
-    -------
-
-    tens_indices : int, list or tuple
-        Container of the same structure as indices containing
-        the tensor indices for each element of indices.
-    """
-    perm = dims_to_tensor_perm(dims)
-    return deep_map(partial(getitem, perm), indices)
+"""
+Internal use module for manipulating dims specifications.
+"""
+
+# Everything should be explicitly imported, not made available by default.
+
+import numpy as np
+from operator import getitem
+from functools import partial
+
+
+def is_scalar(dims):
+    """
+    Returns True if a dims specification is effectively
+    a scalar (has dimension 1).
+    """
+    return np.prod(flatten(dims)) == 1
+
+
+def is_vector(dims):
+    return (
+        isinstance(dims, list) and
+        isinstance(dims[0], (int, np.integer))
+    )
+
+
+def is_vectorized_oper(dims):
+    return (
+        isinstance(dims, list) and
+        isinstance(dims[0], list)
+    )
+
+
+def type_from_dims(dims, enforce_square=False):
+    bra_like, ket_like = map(is_scalar, dims)
+
+    if bra_like:
+        if is_vector(dims[1]):
+            return 'bra'
+        elif is_vectorized_oper(dims[1]):
+            return 'operator-bra'
+
+    if ket_like:
+        if is_vector(dims[0]):
+            return 'ket'
+        elif is_vectorized_oper(dims[0]):
+            return 'operator-ket'
+
+    elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square):
+        return 'oper'
+
+    elif (
+        is_vectorized_oper(dims[0])
+        and (
+            not enforce_square
+            or (dims[0] == dims[1] and dims[0][0] == dims[1][0])
+        )
+    ):
+        return 'super'
+    return 'other'
+
+
+def flatten(l):
+    """Flattens a list of lists to the first level.
+
+    Given a list containing a mix of scalars and lists,
+    flattens down to a list of the scalars within the original
+    list.
+
+    Examples
+    --------
+
+    >>> flatten([[[0], 1], 2]) # doctest: +SKIP
+    [0, 1, 2]
+
+    """
+    if not isinstance(l, list):
+        return [l]
+    else:
+        return sum(map(flatten, l), [])
+
+
+def deep_remove(l, *what):
+    """Removes scalars from all levels of a nested list.
+
+    Given a list containing a mix of scalars and lists,
+    returns a list of the same structure, but where one or
+    more scalars have been removed.
+
+    Examples
+    --------
+
+    >>> deep_remove([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], 0, 5) # doctest: +SKIP
+    [[[[1, 2]], [3, 4], [], [6, 7]]]
+
+    """
+    if isinstance(l, list):
+        # Make a shallow copy at this level.
+        l = l[:]
+        for to_remove in what:
+            if to_remove in l:
+                l.remove(to_remove)
+            else:
+                l = [deep_remove(elem, to_remove) for elem in l]
+    return l
+
+
+def unflatten(l, idxs):
+    """Unflattens a list by a given structure.
+
+    Given a list of scalars and a deep list of indices
+    as produced by `flatten`, returns an "unflattened"
+    form of the list. This perfectly inverts `flatten`.
+
+    Examples
+    --------
+
+    >>> l = [[[10, 20, 30], [40, 50, 60]], [[70, 80, 90], [100, 110, 120]]] # doctest: +SKIP
+    >>> idxs = enumerate_flat(l) # doctest: +SKIP
+    >>> unflatten(flatten(l), idxs) == l # doctest: +SKIP
+    True
+
+    """
+    acc = []
+    for idx in idxs:
+        if isinstance(idx, list):
+            acc.append(unflatten(l, idx))
+        else:
+            acc.append(l[idx])
+    return acc
+
+
+def _enumerate_flat(l, idx=0):
+    if not isinstance(l, list):
+        # Found a scalar, so return and increment.
+        return idx, idx + 1
+    else:
+        # Found a list, so append all the scalars
+        # from it and recurse to keep the increment
+        # correct.
+        acc = []
+        for elem in l:
+            labels, idx = _enumerate_flat(elem, idx)
+            acc.append(labels)
+        return acc, idx
+
+
+def _collapse_composite_index(dims):
+    """
+    Given the dimensions specification for a composite index
+    (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]),
+    returns a dimensions specification for an index of the same shape,
+    but collapsed to a single "leg." In the previous example, [2, 3]
+    would collapse to [6].
+    """
+    return [np.prod(dims)]
+
+
+def _collapse_dims_to_level(dims, level=1):
+    """
+    Recursively collapses all indices in a dimensions specification
+    appearing at a given level, such that the returned dimensions
+    specification does not represent any composite systems.
+    """
+    if level == 0:
+        return _collapse_composite_index(dims)
+    return [_collapse_dims_to_level(index, level=level - 1) for index in dims]
+
+
+def collapse_dims_oper(dims):
+    """
+    Given the dimensions specifications for a ket-, bra- or oper-type
+    Qobj, returns a dimensions specification describing the same shape
+    by collapsing all composite systems. For instance, the bra-type
+    dimensions specification ``[[2, 3], [1]]`` collapses to
+    ``[[6], [1]]``.
+
+    Parameters
+    ----------
+
+    dims : list of lists of ints
+        Dimensions specifications to be collapsed.
+
+    Returns
+    -------
+
+    collapsed_dims : list of lists of ints
+        Collapsed dimensions specification describing the same shape
+        such that ``len(collapsed_dims[0]) == len(collapsed_dims[1]) == 1``.
+    """
+    return _collapse_dims_to_level(dims, 1)
+
+
+def collapse_dims_super(dims):
+    """
+    Given the dimensions specifications for an operator-ket-, operator-bra- or
+    super-type Qobj, returns a dimensions specification describing the same shape
+    by collapsing all composite systems. For instance, the super-type
+    dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to
+    ``[[[6], [6]], [[6], [6]]]``.
+
+    Parameters
+    ----------
+
+    dims : list of lists of ints
+        Dimensions specifications to be collapsed.
+
+    Returns
+    -------
+
+    collapsed_dims : list of lists of ints
+        Collapsed dimensions specification describing the same shape
+        such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j``
+        in ``range(2)``.
+    """
+    return _collapse_dims_to_level(dims, 2)
+
+
+def enumerate_flat(l):
+    """Labels the indices at which scalars occur in a flattened list.
+
+    Given a list containing a mix of scalars and lists,
+    returns a list of the same structure, where each scalar
+    has been replaced by an index into the flattened list.
+
+    Examples
+    --------
+
+    >>> print(enumerate_flat([[[10], [20, 30]], 40])) # doctest: +SKIP
+    [[[0], [1, 2]], 3]
+
+    """
+    return _enumerate_flat(l)[0]
+
+
+def deep_map(fn, collection, over=(tuple, list)):
+    if isinstance(collection, over):
+        return type(collection)(deep_map(fn, el, over) for el in collection)
+    else:
+        return fn(collection)
+
+
+def dims_to_tensor_perm(dims):
+    """
+    Given the dims of a Qobj instance, returns a list representing
+    a permutation from the flattening of that dims specification to
+    the corresponding tensor indices.
+
+    Parameters
+    ----------
+
+    dims : list
+        Dimensions specification for a Qobj.
+
+    Returns
+    -------
+
+    perm : list
+        A list such that ``data[flatten(dims)[idx]]`` gives the
+        index of the tensor ``data`` corresponding to the ``idx``th
+        dimension of ``dims``.
+    """
+    # We figure out the type of the dims specification,
+    # relaxing the requirement that operators be square.
+    # This means that dims_type need not coincide with
+    # Qobj.type, but that works fine for our purposes here.
+    dims_type = type_from_dims(dims, enforce_square=False)
+    perm = enumerate_flat(dims)
+    if dims_type in ('oper', 'ket', 'bra'):
+        return flatten(perm)
+
+    # If the type is other, we need to figure out if the
+    # dims is superlike on its outputs and inputs
+    # This is the case if the dims type for left or right
+    # are, respectively, oper-like.
+    if dims_type == 'other':
+        raise NotImplementedError("Not yet implemented for type='other'.")
+
+    # If we're still here, the story is more complicated. We'll
+    # follow the strategy of creating a permutation by using
+    # enumerate_flat then transforming the result to swap
+    # input and output indices of vectorized matrices, then flattening
+    # the result. We'll then rebuild indices using this permutation.
+    if dims_type in ('operator-ket', 'super'):
+        # Swap the input and output spaces of the right part of
+        # perm.
+        perm[1] = list(reversed(perm[1]))
+    if dims_type in ('operator-bra', 'super'):
+        # Ditto, but for the left indices.
+        perm[0] = list(reversed(perm[0]))
+    return flatten(perm)
+
+
+def dims_to_tensor_shape(dims):
+    """
+    Given the dims of a Qobj instance, returns the shape of the
+    corresponding tensor. This helps, for instance, resolve the
+    column-stacking convention for superoperators.
+
+    Parameters
+    ----------
+
+    dims : list
+        Dimensions specification for a Qobj.
+
+    Returns
+    -------
+
+    tensor_shape : tuple
+        NumPy shape of the corresponding tensor.
+    """
+    perm = dims_to_tensor_perm(dims)
+    dims = flatten(dims)
+    return tuple(map(partial(getitem, dims), perm))
+
+
+def dims_idxs_to_tensor_idxs(dims, indices):
+    """
+    Given the dims of a Qobj instance, and some indices into
+    dims, returns the corresponding tensor indices. This helps
+    resolve, for instance, that column-stacking for superoperators,
+    oper-ket and oper-bra implies that the input and output tensor
+    indices are reversed from their order in dims.
+
+    Parameters
+    ----------
+
+    dims : list
+        Dimensions specification for a Qobj.
+
+    indices : int, list or tuple
+        Indices to convert to tensor indices. Can be specified
+        as a single index, or as a collection of indices.
+        In the latter case, this can be nested arbitrarily
+        deep. For instance, [0, [0, (2, 3)]].
+
+    Returns
+    -------
+
+    tens_indices : int, list or tuple
+        Container of the same structure as indices containing
+        the tensor indices for each element of indices.
+    """
+    perm = dims_to_tensor_perm(dims)
+    return deep_map(partial(getitem, perm), indices)
diff --git a/qutip/core/expect.py b/qutip/core/expect.py
index f290a25b90..65888f8c7e 100644
--- a/qutip/core/expect.py
+++ b/qutip/core/expect.py
@@ -1,97 +1,97 @@
-__all__ = ['expect', 'variance']
-
-import numpy as np
-
-from .qobj import Qobj
-from . import data as _data
-
-
-def expect(oper, state):
-    """
-    Calculate the expectation value for operator(s) and state(s).  The
-    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
-    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
-
-    Parameters
-    ----------
-    oper : qobj/array-like
-        A single or a `list` or operators for expectation value.
-
-    state : qobj/array-like
-        A single or a `list` of quantum states or density matrices.
-
-    Returns
-    -------
-    expt : float/complex/array-like
-        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
-        otherwise. A (nested) array of expectaction values of state or operator
-        are arrays.
-
-    Examples
-    --------
-    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
-        True
-
-    """
-    if isinstance(state, Qobj) and isinstance(oper, Qobj):
-        return _single_qobj_expect(oper, state)
-
-    elif isinstance(oper, (list, np.ndarray)):
-        if isinstance(state, Qobj):
-            dtype = np.complex128
-            if all(op.isherm for op in oper) and (state.isket or state.isherm):
-                dtype = np.float64
-            return np.array([_single_qobj_expect(op, state) for op in oper],
-                            dtype=dtype)
-        return [expect(op, state) for op in oper]
-
-    elif isinstance(state, (list, np.ndarray)):
-        dtype = np.complex128
-        if oper.isherm and all(op.isherm or op.isket for op in state):
-            dtype = np.float64
-        return np.array([_single_qobj_expect(oper, x) for x in state],
-                        dtype=dtype)
-    raise TypeError('Arguments must be quantum objects')
-
-
-def _single_qobj_expect(oper, state):
-    """
-    Private function used by expect to calculate expectation values of Qobjs.
-    """
-    if not oper.isoper or not (state.isket or state.isoper):
-        raise TypeError('invalid operand types')
-    if oper.dims[1] != state.dims[0]:
-        msg = (
-            "incompatible dimensions "
-            + str(oper.dims[1]) + " and " + str(state.dims[0])
-        )
-        raise ValueError(msg)
-    out = _data.expect(oper.data, state.data)
-
-    # This ensures that expect can return something that is not a number such
-    # as a `tensorflow.Tensor` in qutip-tensorflow.
-    return out.real if (oper.isherm
-                        and (state.isket or state.isherm)
-                        and hasattr(out, "real")
-                        ) else out
-
-
-def variance(oper, state):
-    """
-    Variance of an operator for the given state vector or density matrix.
-
-    Parameters
-    ----------
-    oper : qobj
-        Operator for expectation value.
-
-    state : qobj/list
-        A single or `list` of quantum states or density matrices..
-
-    Returns
-    -------
-    var : float
-        Variance of operator 'oper' for given state.
-
-    """
-    return expect(oper**2, state) - expect(oper, state)**2
+__all__ = ['expect', 'variance']
+
+import numpy as np
+
+from .qobj import Qobj
+from . import data as _data
+
+
+def expect(oper, state):
+    """
+    Calculate the expectation value for operator(s) and state(s).  The
+    expectation of state `k` on operator `A` is defined as `k.dag() @ A @ k`,
+    and for density matrix `R` on operator `A` it is `trace(A @ R)`.
+
+    Parameters
+    ----------
+    oper : qobj/array-like
+        A single or a `list` or operators for expectation value.
+
+    state : qobj/array-like
+        A single or a `list` of quantum states or density matrices.
+
+    Returns
+    -------
+    expt : float/complex/array-like
+        Expectation value.  ``real`` if `oper` is Hermitian, ``complex``
+        otherwise. A (nested) array of expectaction values of state or operator
+        are arrays.
+
+    Examples
+    --------
+    >>> expect(num(4), basis(4, 3)) == 3 # doctest: +NORMALIZE_WHITESPACE
+        True
+
+    """
+    if isinstance(state, Qobj) and isinstance(oper, Qobj):
+        return _single_qobj_expect(oper, state)
+
+    elif isinstance(oper, (list, np.ndarray)):
+        if isinstance(state, Qobj):
+            dtype = np.complex128
+            if all(op.isherm for op in oper) and (state.isket or state.isherm):
+                dtype = np.float64
+            return np.array([_single_qobj_expect(op, state) for op in oper],
+                            dtype=dtype)
+        return [expect(op, state) for op in oper]
+
+    elif isinstance(state, (list, np.ndarray)):
+        dtype = np.complex128
+        if oper.isherm and all(op.isherm or op.isket for op in state):
+            dtype = np.float64
+        return np.array([_single_qobj_expect(oper, x) for x in state],
+                        dtype=dtype)
+    raise TypeError('Arguments must be quantum objects')
+
+
+def _single_qobj_expect(oper, state):
+    """
+    Private function used by expect to calculate expectation values of Qobjs.
+    """
+    if not oper.isoper or not (state.isket or state.isoper):
+        raise TypeError('invalid operand types')
+    if oper.dims[1] != state.dims[0]:
+        msg = (
+            "incompatible dimensions "
+            + str(oper.dims[1]) + " and " + str(state.dims[0])
+        )
+        raise ValueError(msg)
+    out = _data.expect(oper.data, state.data)
+
+    # This ensures that expect can return something that is not a number such
+    # as a `tensorflow.Tensor` in qutip-tensorflow.
+    return out.real if (oper.isherm
+                        and (state.isket or state.isherm)
+                        and hasattr(out, "real")
+                        ) else out
+
+
+def variance(oper, state):
+    """
+    Variance of an operator for the given state vector or density matrix.
+
+    Parameters
+    ----------
+    oper : qobj
+        Operator for expectation value.
+
+    state : qobj/list
+        A single or `list` of quantum states or density matrices..
+
+    Returns
+    -------
+    var : float
+        Variance of operator 'oper' for given state.
+
+    """
+    return expect(oper**2, state) - expect(oper, state)**2
diff --git a/qutip/core/gates.py b/qutip/core/gates.py
index ae99fc4446..28726e292c 100644
--- a/qutip/core/gates.py
+++ b/qutip/core/gates.py
@@ -1,747 +1,747 @@
-from itertools import product
-from functools import partial, reduce
-from operator import mul
-
-import numpy as np
-import scipy.sparse as sp
-from . import Qobj, qeye, sigmax, fock_dm, qdiags
-
-
-__all__ = [
-    "rx",
-    "ry",
-    "rz",
-    "sqrtnot",
-    "snot",
-    "phasegate",
-    "qrot",
-    "cy_gate",
-    "cz_gate",
-    "s_gate",
-    "t_gate",
-    "cs_gate",
-    "ct_gate",
-    "cphase",
-    "cnot",
-    "csign",
-    "berkeley",
-    "swapalpha",
-    "swap",
-    "iswap",
-    "sqrtswap",
-    "sqrtiswap",
-    "fredkin",
-    "molmer_sorensen",
-    "toffoli",
-    "hadamard_transform",
-    "qubit_clifford_group",
-]
-
-
-def cy_gate(*, dtype="csr"):
-    """Controlled Y gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def cz_gate(*, dtype="csr"):
-    """Controlled Z gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-    """
-    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
-
-
-def s_gate(*, dtype="csr"):
-    """Single-qubit rotation also called Phase gate or the Z90 gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing
-        a 90 degree rotation around the z-axis.
-
-    """
-    return qdiags([1, 1j], dtype=dtype)
-
-
-def cs_gate(*, dtype="csr"):
-    """Controlled S gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-
-    """
-    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
-
-
-def t_gate(*, dtype="csr"):
-    """Single-qubit rotation related to the S gate by the relationship S=T*T.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing a phase shift of pi/4.
-
-    """
-    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
-
-
-def ct_gate(*, dtype="csr"):
-    """Controlled T gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : :class:`qutip.Qobj`
-        Quantum object for operator describing the rotation.
-
-    """
-    return qdiags(
-        [1, 1, 1, np.exp(1j * np.pi / 4)],
-        dims=[[2, 2], [2, 2]],
-        dtype=dtype,
-    )
-
-
-def rx(phi, *, dtype="dense"):
-    """Single-qubit rotation for operator sigmax with angle phi.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the rotation.
-
-    """
-    return Qobj(
-        [
-            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
-            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
-        ]
-    ).to(dtype)
-
-
-def ry(phi, *, dtype="dense"):
-    """Single-qubit rotation for operator sigmay with angle phi.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the rotation.
-
-    """
-    return Qobj(
-        [
-            [np.cos(phi / 2), -np.sin(phi / 2)],
-            [np.sin(phi / 2), np.cos(phi / 2)],
-        ]
-    ).to(dtype)
-
-
-def rz(phi, *, dtype="csr"):
-    """Single-qubit rotation for operator sigmaz with angle phi.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the rotation.
-
-    """
-    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
-
-
-def sqrtnot(*, dtype="dense"):
-    """Single-qubit square root NOT gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    result : qobj
-        Quantum object for operator describing the square root NOT gate.
-
-    """
-    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
-
-
-def snot(*, dtype="dense"):
-    """Quantum object representing the SNOT (Hadamard) gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    snot_gate : qobj
-        Quantum object representation of SNOT gate.
-
-    """
-    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
-
-
-def phasegate(theta, *, dtype="csr"):
-    """
-    Returns quantum object representing the phase shift gate.
-
-    Parameters
-    ----------
-    theta : float
-        Phase rotation angle.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    phase_gate : qobj
-        Quantum object representation of phase shift gate.
-
-    """
-    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
-
-
-def qrot(theta, phi, *, dtype="dense"):
-    """
-    Single qubit rotation driving by Rabi oscillation with 0 detune.
-
-    Parameters
-    ----------
-    phi : float
-        The inital phase of the rabi pulse.
-    theta : float
-        The duration of the rabi pulse.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    qrot_gate : :class:`qutip.Qobj`
-        Quantum object representation of physical qubit rotation under
-        a rabi pulse.
-    """
-    return Qobj(
-        [
-            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
-            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
-        ]
-    ).to(dtype)
-
-
-#
-# 2 Qubit Gates
-#
-
-
-def cphase(theta, *, dtype="csr"):
-    """
-    Returns quantum object representing the controlled phase shift gate.
-
-    Parameters
-    ----------
-    theta : float
-        Phase rotation angle.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    U : qobj
-        Quantum object representation of controlled phase gate.
-    """
-    return qdiags(
-        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
-    )
-
-
-def cnot(*, dtype="csr"):
-    """
-    Quantum object representing the CNOT gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    cnot_gate : qobj
-        Quantum object representation of CNOT gate
-
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def csign(*, dtype="csr"):
-    """
-    Quantum object representing the CSIGN gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    csign_gate : qobj
-        Quantum object representation of CSIGN gate
-
-    """
-    return cz_gate(dtype=dtype)
-
-
-def berkeley(*, dtype="dense"):
-    """
-    Quantum object representing the Berkeley gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    berkeley_gate : qobj
-        Quantum object representation of Berkeley gate
-
-    """
-    return Qobj(
-        [
-            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
-            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
-            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
-            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
-        ],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def swapalpha(alpha, *, dtype="csr"):
-    """
-    Quantum object representing the SWAPalpha gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    swapalpha_gate : qobj
-        Quantum object representation of SWAPalpha gate
-    """
-    phase = np.exp(1.0j * np.pi * alpha)
-    return Qobj(
-        [
-            [1, 0, 0, 0],
-            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
-            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
-            [0, 0, 0, 1],
-        ],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def swap(*, dtype="csr"):
-    """Quantum object representing the SWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    swap_gate : qobj
-        Quantum object representation of SWAP gate
-
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def iswap(*, dtype="csr"):
-    """Quantum object representing the iSWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    iswap_gate : qobj
-        Quantum object representation of iSWAP gate
-    """
-    return Qobj(
-        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def sqrtswap(*, dtype="dense"):
-    """Quantum object representing the square root SWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    sqrtswap_gate : qobj
-        Quantum object representation of square root SWAP gate
-
-    """
-    return Qobj(
-        np.array(
-            [
-                [1, 0, 0, 0],
-                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
-                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
-                [0, 0, 0, 1],
-            ]
-        ),
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def sqrtiswap(*, dtype="dense"):
-    """Quantum object representing the square root iSWAP gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    sqrtiswap_gate : qobj
-        Quantum object representation of square root iSWAP gate
-    """
-    return Qobj(
-        np.array(
-            [
-                [1, 0, 0, 0],
-                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
-                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
-                [0, 0, 0, 1],
-            ]
-        ),
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-def molmer_sorensen(theta, *, dtype="dense"):
-    """
-    Quantum object of a Mølmer–Sørensen gate.
-
-    Parameters
-    ----------
-    theta: float
-        The duration of the interaction pulse.
-    N: int
-        Number of qubits in the system.
-    target: int
-        The indices of the target qubits.
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    molmer_sorensen_gate: :class:`qutip.Qobj`
-        Quantum object representation of the Mølmer–Sørensen gate.
-    """
-    return Qobj(
-        [
-            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
-            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
-            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
-            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
-        ],
-        dims=[[2, 2], [2, 2]],
-    ).to(dtype)
-
-
-#
-# 3 Qubit Gates
-#
-
-
-def fredkin(*, dtype="csr"):
-    """Quantum object representing the Fredkin gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    fredkin_gate : qobj
-        Quantum object representation of Fredkin gate.
-
-    """
-    return Qobj(
-        [
-            [1, 0, 0, 0, 0, 0, 0, 0],
-            [0, 1, 0, 0, 0, 0, 0, 0],
-            [0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 1, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0],
-            [0, 0, 0, 0, 0, 0, 1, 0],
-            [0, 0, 0, 0, 0, 1, 0, 0],
-            [0, 0, 0, 0, 0, 0, 0, 1],
-        ],
-        dims=[[2, 2, 2], [2, 2, 2]],
-    ).to(dtype)
-
-
-def toffoli(*, dtype="csr"):
-    """Quantum object representing the Toffoli gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    toff_gate : qobj
-        Quantum object representation of Toffoli gate.
-
-    """
-    return Qobj(
-        [
-            [1, 0, 0, 0, 0, 0, 0, 0],
-            [0, 1, 0, 0, 0, 0, 0, 0],
-            [0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 1, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0],
-            [0, 0, 0, 0, 0, 1, 0, 0],
-            [0, 0, 0, 0, 0, 0, 0, 1],
-            [0, 0, 0, 0, 0, 0, 1, 0],
-        ],
-        dims=[[2, 2, 2], [2, 2, 2]],
-    ).to(dtype)
-
-
-#
-# Miscellaneous Gates
-#
-
-
-def globalphase(theta, N=1, *, dtype="csr"):
-    """
-    Returns quantum object representing the global phase shift gate.
-
-    Parameters
-    ----------
-    theta : float
-        Phase rotation angle.
-
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    phase_gate : qobj
-        Quantum object representation of global phase shift gate.
-
-    """
-    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
-
-
-#
-# Operation on Gates
-#
-
-
-def _hamming_distance(x):
-    """
-    Calculate the bit-wise Hamming distance of x from 0: That is, the number
-    1s in the integer x.
-    """
-    tot = 0
-    while x:
-        tot += 1
-        x &= x - 1
-    return tot
-
-
-def hadamard_transform(N=1, *, dtype="dense"):
-    """Quantum object representing the N-qubit Hadamard gate.
-
-    Parameters
-    ----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    q : qobj
-        Quantum object representation of the N-qubit Hadamard gate.
-
-    """
-    data = 2 ** (-N / 2) * np.array(
-        [
-            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
-            for j in range(2**N)
-        ]
-    )
-
-    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
-
-
-def _powers(op, N):
-    """
-    Generator that yields powers of an operator `op`,
-    through to `N`.
-    """
-    acc = qeye(op.dims[0])
-    yield acc
-
-    for _ in range(N - 1):
-        acc *= op
-        yield acc
-
-
-def qubit_clifford_group(*, dtype="dense"):
-    """
-    Generates the Clifford group on a single qubit,
-    using the presentation of the group given by Ross and Selinger
-    (http://www.mathstat.dal.ca/~selinger/newsynth/).
-
-    Parameters
-    -----------
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Return
-    ------
-    op : list of Qobj
-        Clifford operators, represented as Qobj instances.
-
-    """
-
-    # The Ross-Selinger presentation of the single-qubit Clifford
-    # group expresses each element in the form C_{ijk} = E^i X^j S^k
-    # for gates E, X and S, and for i in range(3), j in range(2) and
-    # k in range(4).
-    #
-    # We start by defining these gates. E is defined in terms of H,
-    # \omega and S, so we define \omega and H first.
-    w = np.exp(1j * 2 * np.pi / 8)
-    H = snot()
-
-    X = sigmax()
-    S = phasegate(np.pi / 2)
-    E = H * (S**3) * w**3
-
-    # partial(reduce, mul) returns a function that takes products
-    # of its argument, by analogy to sum. Note that by analogy,
-    # sum can be written as partial(reduce, add).
-
-    # product(...) yields the Cartesian product of its arguments.
-    # Here, each element is a tuple (E**i, X**j, S**k) such that
-    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
-    return [
-        op.to(dtype)
-        for op in map(
-            partial(reduce, mul),
-            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
-        )
-    ]
+from itertools import product
+from functools import partial, reduce
+from operator import mul
+
+import numpy as np
+import scipy.sparse as sp
+from . import Qobj, qeye, sigmax, fock_dm, qdiags
+
+
+__all__ = [
+    "rx",
+    "ry",
+    "rz",
+    "sqrtnot",
+    "snot",
+    "phasegate",
+    "qrot",
+    "cy_gate",
+    "cz_gate",
+    "s_gate",
+    "t_gate",
+    "cs_gate",
+    "ct_gate",
+    "cphase",
+    "cnot",
+    "csign",
+    "berkeley",
+    "swapalpha",
+    "swap",
+    "iswap",
+    "sqrtswap",
+    "sqrtiswap",
+    "fredkin",
+    "molmer_sorensen",
+    "toffoli",
+    "hadamard_transform",
+    "qubit_clifford_group",
+]
+
+
+def cy_gate(*, dtype="csr"):
+    """Controlled Y gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def cz_gate(*, dtype="csr"):
+    """Controlled Z gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+    """
+    return qdiags([1, 1, 1, -1], dims=[[2, 2], [2, 2]], dtype=dtype)
+
+
+def s_gate(*, dtype="csr"):
+    """Single-qubit rotation also called Phase gate or the Z90 gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing
+        a 90 degree rotation around the z-axis.
+
+    """
+    return qdiags([1, 1j], dtype=dtype)
+
+
+def cs_gate(*, dtype="csr"):
+    """Controlled S gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+
+    """
+    return qdiags([1, 1, 1, 1j], dims=[[2, 2], [2, 2]], dtype=dtype)
+
+
+def t_gate(*, dtype="csr"):
+    """Single-qubit rotation related to the S gate by the relationship S=T*T.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing a phase shift of pi/4.
+
+    """
+    return qdiags([1, np.exp(1j * np.pi / 4)], dtype=dtype)
+
+
+def ct_gate(*, dtype="csr"):
+    """Controlled T gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : :class:`qutip.Qobj`
+        Quantum object for operator describing the rotation.
+
+    """
+    return qdiags(
+        [1, 1, 1, np.exp(1j * np.pi / 4)],
+        dims=[[2, 2], [2, 2]],
+        dtype=dtype,
+    )
+
+
+def rx(phi, *, dtype="dense"):
+    """Single-qubit rotation for operator sigmax with angle phi.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the rotation.
+
+    """
+    return Qobj(
+        [
+            [np.cos(phi / 2), -1j * np.sin(phi / 2)],
+            [-1j * np.sin(phi / 2), np.cos(phi / 2)],
+        ]
+    ).to(dtype)
+
+
+def ry(phi, *, dtype="dense"):
+    """Single-qubit rotation for operator sigmay with angle phi.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the rotation.
+
+    """
+    return Qobj(
+        [
+            [np.cos(phi / 2), -np.sin(phi / 2)],
+            [np.sin(phi / 2), np.cos(phi / 2)],
+        ]
+    ).to(dtype)
+
+
+def rz(phi, *, dtype="csr"):
+    """Single-qubit rotation for operator sigmaz with angle phi.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the rotation.
+
+    """
+    return qdiags([np.exp(-1j * phi / 2), np.exp(1j * phi / 2)], dtype=dtype)
+
+
+def sqrtnot(*, dtype="dense"):
+    """Single-qubit square root NOT gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    result : qobj
+        Quantum object for operator describing the square root NOT gate.
+
+    """
+    return Qobj([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]).to(dtype)
+
+
+def snot(*, dtype="dense"):
+    """Quantum object representing the SNOT (Hadamard) gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    snot_gate : qobj
+        Quantum object representation of SNOT gate.
+
+    """
+    return Qobj([[1, 1], [1, -1]]).to(dtype) / np.sqrt(2.0)
+
+
+def phasegate(theta, *, dtype="csr"):
+    """
+    Returns quantum object representing the phase shift gate.
+
+    Parameters
+    ----------
+    theta : float
+        Phase rotation angle.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    phase_gate : qobj
+        Quantum object representation of phase shift gate.
+
+    """
+    return qdiags([1, np.exp(1.0j * theta)], dtype=dtype)
+
+
+def qrot(theta, phi, *, dtype="dense"):
+    """
+    Single qubit rotation driving by Rabi oscillation with 0 detune.
+
+    Parameters
+    ----------
+    phi : float
+        The inital phase of the rabi pulse.
+    theta : float
+        The duration of the rabi pulse.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    qrot_gate : :class:`qutip.Qobj`
+        Quantum object representation of physical qubit rotation under
+        a rabi pulse.
+    """
+    return Qobj(
+        [
+            [np.cos(theta / 2), -1j * np.exp(-1j * phi) * np.sin(theta / 2)],
+            [-1j * np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
+        ]
+    ).to(dtype)
+
+
+#
+# 2 Qubit Gates
+#
+
+
+def cphase(theta, *, dtype="csr"):
+    """
+    Returns quantum object representing the controlled phase shift gate.
+
+    Parameters
+    ----------
+    theta : float
+        Phase rotation angle.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    U : qobj
+        Quantum object representation of controlled phase gate.
+    """
+    return qdiags(
+        [1, 1, 1, np.exp(1.0j * theta)], dims=[[2, 2], [2, 2]], dtype=dtype
+    )
+
+
+def cnot(*, dtype="csr"):
+    """
+    Quantum object representing the CNOT gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    cnot_gate : qobj
+        Quantum object representation of CNOT gate
+
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def csign(*, dtype="csr"):
+    """
+    Quantum object representing the CSIGN gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    csign_gate : qobj
+        Quantum object representation of CSIGN gate
+
+    """
+    return cz_gate(dtype=dtype)
+
+
+def berkeley(*, dtype="dense"):
+    """
+    Quantum object representing the Berkeley gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    berkeley_gate : qobj
+        Quantum object representation of Berkeley gate
+
+    """
+    return Qobj(
+        [
+            [np.cos(np.pi / 8), 0, 0, 1.0j * np.sin(np.pi / 8)],
+            [0, np.cos(3 * np.pi / 8), 1.0j * np.sin(3 * np.pi / 8), 0],
+            [0, 1.0j * np.sin(3 * np.pi / 8), np.cos(3 * np.pi / 8), 0],
+            [1.0j * np.sin(np.pi / 8), 0, 0, np.cos(np.pi / 8)],
+        ],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def swapalpha(alpha, *, dtype="csr"):
+    """
+    Quantum object representing the SWAPalpha gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    swapalpha_gate : qobj
+        Quantum object representation of SWAPalpha gate
+    """
+    phase = np.exp(1.0j * np.pi * alpha)
+    return Qobj(
+        [
+            [1, 0, 0, 0],
+            [0, 0.5 * (1 + phase), 0.5 * (1 - phase), 0],
+            [0, 0.5 * (1 - phase), 0.5 * (1 + phase), 0],
+            [0, 0, 0, 1],
+        ],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def swap(*, dtype="csr"):
+    """Quantum object representing the SWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    swap_gate : qobj
+        Quantum object representation of SWAP gate
+
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def iswap(*, dtype="csr"):
+    """Quantum object representing the iSWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    iswap_gate : qobj
+        Quantum object representation of iSWAP gate
+    """
+    return Qobj(
+        [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def sqrtswap(*, dtype="dense"):
+    """Quantum object representing the square root SWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    sqrtswap_gate : qobj
+        Quantum object representation of square root SWAP gate
+
+    """
+    return Qobj(
+        np.array(
+            [
+                [1, 0, 0, 0],
+                [0, 0.5 + 0.5j, 0.5 - 0.5j, 0],
+                [0, 0.5 - 0.5j, 0.5 + 0.5j, 0],
+                [0, 0, 0, 1],
+            ]
+        ),
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def sqrtiswap(*, dtype="dense"):
+    """Quantum object representing the square root iSWAP gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    sqrtiswap_gate : qobj
+        Quantum object representation of square root iSWAP gate
+    """
+    return Qobj(
+        np.array(
+            [
+                [1, 0, 0, 0],
+                [0, 1 / np.sqrt(2), 1j / np.sqrt(2), 0],
+                [0, 1j / np.sqrt(2), 1 / np.sqrt(2), 0],
+                [0, 0, 0, 1],
+            ]
+        ),
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+def molmer_sorensen(theta, *, dtype="dense"):
+    """
+    Quantum object of a Mølmer–Sørensen gate.
+
+    Parameters
+    ----------
+    theta: float
+        The duration of the interaction pulse.
+    N: int
+        Number of qubits in the system.
+    target: int
+        The indices of the target qubits.
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    molmer_sorensen_gate: :class:`qutip.Qobj`
+        Quantum object representation of the Mølmer–Sørensen gate.
+    """
+    return Qobj(
+        [
+            [np.cos(theta / 2.0), 0, 0, -1.0j * np.sin(theta / 2.0)],
+            [0, np.cos(theta / 2.0), -1.0j * np.sin(theta / 2.0), 0],
+            [0, -1.0j * np.sin(theta / 2.0), np.cos(theta / 2.0), 0],
+            [-1.0j * np.sin(theta / 2.0), 0, 0, np.cos(theta / 2.0)],
+        ],
+        dims=[[2, 2], [2, 2]],
+    ).to(dtype)
+
+
+#
+# 3 Qubit Gates
+#
+
+
+def fredkin(*, dtype="csr"):
+    """Quantum object representing the Fredkin gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    fredkin_gate : qobj
+        Quantum object representation of Fredkin gate.
+
+    """
+    return Qobj(
+        [
+            [1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1],
+        ],
+        dims=[[2, 2, 2], [2, 2, 2]],
+    ).to(dtype)
+
+
+def toffoli(*, dtype="csr"):
+    """Quantum object representing the Toffoli gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    toff_gate : qobj
+        Quantum object representation of Toffoli gate.
+
+    """
+    return Qobj(
+        [
+            [1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+        ],
+        dims=[[2, 2, 2], [2, 2, 2]],
+    ).to(dtype)
+
+
+#
+# Miscellaneous Gates
+#
+
+
+def globalphase(theta, N=1, *, dtype="csr"):
+    """
+    Returns quantum object representing the global phase shift gate.
+
+    Parameters
+    ----------
+    theta : float
+        Phase rotation angle.
+
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    phase_gate : qobj
+        Quantum object representation of global phase shift gate.
+
+    """
+    return qeye([2] * N, dtype=dtype) * np.exp(1.0j * theta)
+
+
+#
+# Operation on Gates
+#
+
+
+def _hamming_distance(x):
+    """
+    Calculate the bit-wise Hamming distance of x from 0: That is, the number
+    1s in the integer x.
+    """
+    tot = 0
+    while x:
+        tot += 1
+        x &= x - 1
+    return tot
+
+
+def hadamard_transform(N=1, *, dtype="dense"):
+    """Quantum object representing the N-qubit Hadamard gate.
+
+    Parameters
+    ----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    q : qobj
+        Quantum object representation of the N-qubit Hadamard gate.
+
+    """
+    data = 2 ** (-N / 2) * np.array(
+        [
+            [(-1) ** _hamming_distance(i & j) for i in range(2**N)]
+            for j in range(2**N)
+        ]
+    )
+
+    return Qobj(data, dims=[[2] * N, [2] * N]).to(dtype)
+
+
+def _powers(op, N):
+    """
+    Generator that yields powers of an operator `op`,
+    through to `N`.
+    """
+    acc = qeye(op.dims[0])
+    yield acc
+
+    for _ in range(N - 1):
+        acc *= op
+        yield acc
+
+
+def qubit_clifford_group(*, dtype="dense"):
+    """
+    Generates the Clifford group on a single qubit,
+    using the presentation of the group given by Ross and Selinger
+    (http://www.mathstat.dal.ca/~selinger/newsynth/).
+
+    Parameters
+    -----------
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Return
+    ------
+    op : list of Qobj
+        Clifford operators, represented as Qobj instances.
+
+    """
+
+    # The Ross-Selinger presentation of the single-qubit Clifford
+    # group expresses each element in the form C_{ijk} = E^i X^j S^k
+    # for gates E, X and S, and for i in range(3), j in range(2) and
+    # k in range(4).
+    #
+    # We start by defining these gates. E is defined in terms of H,
+    # \omega and S, so we define \omega and H first.
+    w = np.exp(1j * 2 * np.pi / 8)
+    H = snot()
+
+    X = sigmax()
+    S = phasegate(np.pi / 2)
+    E = H * (S**3) * w**3
+
+    # partial(reduce, mul) returns a function that takes products
+    # of its argument, by analogy to sum. Note that by analogy,
+    # sum can be written as partial(reduce, add).
+
+    # product(...) yields the Cartesian product of its arguments.
+    # Here, each element is a tuple (E**i, X**j, S**k) such that
+    # partial(reduce, mul) acting on the tuple yields E**i * X**j * S**k.
+    return [
+        op.to(dtype)
+        for op in map(
+            partial(reduce, mul),
+            product(_powers(E, 3), _powers(X, 2), _powers(S, 4)),
+        )
+    ]
diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
index c87c13756b..08c635326c 100644
--- a/qutip/core/metrics.py
+++ b/qutip/core/metrics.py
@@ -1,590 +1,590 @@
-# -*- coding: utf-8 -*-
-
-"""
-This module contains a collection of functions for calculating metrics
-(distance measures) between states and operators.
-"""
-
-__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
-           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
-           'process_fidelity', 'unitarity', 'dnorm']
-
-import warnings
-
-import numpy as np
-from scipy import linalg as la
-import scipy.sparse as sp
-from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
-                           kraus_to_choi)
-from .superoperator import operator_to_vector, vector_to_operator
-from .operators import qeye
-from .states import ket2dm
-from .semidefinite import dnorm_problem, dnorm_sparse_problem
-from . import data as _data
-
-try:
-    import cvxpy
-except ImportError:
-    cvxpy = None
-
-
-def fidelity(A, B):
-    """
-    Calculates the fidelity (pseudo-metric) between two density matrices.
-    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    fid : float
-        Fidelity pseudo-metric between A and B.
-
-    Examples
-    --------
-    >>> x = fock_dm(5,3)
-    >>> y = coherent_dm(5,1)
-    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
-    """
-    if A.isket or A.isbra:
-        if B.isket or B.isbra:
-            # The fidelity for pure states reduces to the modulus of their
-            # inner product.
-            return np.abs(A.overlap(B))
-        # Take advantage of the fact that the density operator for A
-        # is a projector to avoid a sqrtm call.
-        sqrtmA = ket2dm(A)
-    else:
-        if B.isket or B.isbra:
-            # Swap the order so that we can take a more numerically
-            # stable square root of B.
-            return fidelity(B, A)
-        # If we made it here, both A and B are operators, so
-        # we have to take the sqrtm of one of them.
-        sqrtmA = A.sqrtm()
-
-    if sqrtmA.dims != B.dims:
-        raise TypeError('Density matrices do not have same dimensions.')
-
-    # We don't actually need the whole matrix here, just the trace
-    # of its square root, so let's just get its eigenenergies instead.
-    # We also truncate negative eigenvalues to avoid nan propagation;
-    # even for positive semidefinite matrices, small negative eigenvalues
-    # can be reported.
-    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
-    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
-
-
-def _hilbert_space_dims(oper):
-    """
-    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
-    of the output Hilbert space and the input Hilbert space.
-    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
-    - If oper is a list of Kraus operators, then
-     `oper[0].dims == [dims_out, dims_in]`.
-    - If oper is a superoperator with `oper.superrep == 'super'`:
-     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
-    - If oper is a superoperator with `oper.superrep == 'choi'`:
-     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
-    - If oper is a superoperator with `oper.superrep == 'chi', then
-      `dims_out == dims_in` and
-      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
-    :param oper: A quantum channel, represented by a unitary, a list of Kraus
-    operators, or a superoperator
-    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
-     of integers
-    """
-    if isinstance(oper, list):
-        return oper[0].dims
-    elif oper.type == 'oper':  # interpret as unitary quantum channel
-        return oper.dims
-    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
-        return [oper.dims[0][1], oper.dims[1][0]]
-    else:
-        raise TypeError('oper is not a valid quantum channel!')
-
-
-def _process_fidelity_to_id(oper):
-    """
-    Internal function returning the process fidelity of a quantum channel
-    to the identity quantum channel.
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-    Returns
-    -------
-    fid : float
-    """
-    dims_out, dims_in = _hilbert_space_dims(oper)
-    if dims_out != dims_in:
-        raise TypeError('The process fidelity to identity is only defined '
-                        'for dimension preserving channels.')
-    d = np.prod(dims_in)
-    if isinstance(oper, list):  # oper is a list of Kraus operators
-        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
-    elif oper.type == 'oper':  # interpret as unitary
-        return np.abs(oper.tr()) ** 2 / d ** 2
-    elif oper.type == 'super':
-        if oper.superrep == 'chi':
-            return oper[0, 0].real / d ** 2
-        else:  # oper.superrep is either 'super' or 'choi':
-            return to_super(oper).tr().real / d ** 2
-
-
-def _kraus_or_qobj_to_choi(oper):
-    if isinstance(oper, list):
-        return kraus_to_choi(oper)
-    else:
-        return to_choi(oper)
-
-
-def process_fidelity(oper, target=None):
-    """
-    Returns the process fidelity of a quantum channel to the target
-    channel, or to the identity channel if no target is given.
-    The process fidelity between two channels is defined as the state
-    fidelity between their normalized Choi matrices.
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-    target : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-
-    Returns
-    -------
-    fid : float
-        Process fidelity between oper and target, or between oper and identity.
-
-    Notes
-    -----
-    Since Qutip 5.0, this function computes the process fidelity as defined
-    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
-    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
-    that is now implemented in
-    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
-    The definition of state fidelity that the process fidelity is based on
-    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
-    It is the square of the one implemented in
-    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
-    "Quantum Computation and Quantum Information"
-
-    """
-    if target is None:
-        return _process_fidelity_to_id(oper)
-
-    dims_out, dims_in = _hilbert_space_dims(oper)
-    if dims_out != dims_in:
-        raise NotImplementedError('Process fidelity only implemented for '
-                                  'dimension-preserving operators.')
-    dims_out_target, dims_in_target = _hilbert_space_dims(target)
-    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
-        raise TypeError('Dimensions of oper and target do not match')
-
-    if not isinstance(target, list) and target.type == 'oper':
-        # interpret target as unitary.
-        if isinstance(oper, list):  # oper is a list of Kraus operators
-            return _process_fidelity_to_id([k * target.dag() for k in oper])
-        elif oper.type == 'oper':
-            return _process_fidelity_to_id(oper*target.dag())
-        elif oper.type == 'super':
-            oper_super = to_super(oper)
-            target_dag_super = to_super(target.dag())
-            return _process_fidelity_to_id(oper_super * target_dag_super)
-    else:  # target is a list of Kraus operators or a superoperator
-        if not isinstance(oper, list) and oper.type == 'oper':
-            return process_fidelity(target, oper)  # reverse order
-        oper_choi = _kraus_or_qobj_to_choi(oper)
-        target_choi = _kraus_or_qobj_to_choi(target)
-        d = np.prod(dims_in)
-        return (fidelity(oper_choi, target_choi)/d)**2
-
-
-def average_gate_fidelity(oper, target=None):
-    """
-    Returns the average gate fidelity of a quantum channel to the target
-    channel, or to the identity channel if no target is given.
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`/list
-        A unitary operator, or a superoperator in supermatrix, Choi or
-        chi-matrix form, or a list of Kraus operators
-    target : :class:`qutip.Qobj`
-        A unitary operator
-
-    Returns
-    -------
-    fid : float
-        Average gate fidelity between oper and target,
-        or between oper and identity.
-
-    Notes
-    -----
-    The average gate fidelity is defined for example in:
-    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
-    The definition of state fidelity that the average gate fidelity is based on
-    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
-    It is the square of the fidelity implemented in
-    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
-    "Quantum Computation and Quantum Information"
-
-    """
-    dims_out, dims_in = _hilbert_space_dims(oper)
-    if not (target is None or target.type == 'oper'):
-        raise TypeError(
-            'target must be None or a Qobj representing a unitary.')
-
-    d = np.prod(dims_in)
-    return (d * process_fidelity(oper, target) + 1) / (d + 1)
-
-
-def tracedist(A, B, sparse=False, tol=0):
-    """
-    Calculates the trace distance between two density matrices..
-    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
-
-    Parameters
-    ----------!=
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-    tol : float
-        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
-    sparse : {False, True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    tracedist : float
-        Trace distance between A and B.
-
-    Examples
-    --------
-    >>> x=fock_dm(5,3)
-    >>> y=coherent_dm(5,1)
-    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError("A and B do not have same dimensions.")
-    diff = A - B
-    diff = diff.dag() * diff
-    vals = diff.eigenenergies(sparse=sparse, tol=tol)
-    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
-
-
-def hilbert_dist(A, B):
-    """
-    Returns the Hilbert-Schmidt distance between two density matrices A & B.
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    dist : float
-        Hilbert-Schmidt distance between density matrices.
-
-    Notes
-    -----
-    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
-
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError('A and B do not have same dimensions.')
-    return ((A - B)**2).tr()
-
-
-def bures_dist(A, B):
-    """
-    Returns the Bures distance between two density matrices A & B.
-
-    The Bures distance ranges from 0, for states with unit fidelity,
-    to sqrt(2).
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    dist : float
-        Bures distance between density matrices.
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError('A and B do not have same dimensions.')
-    dist = np.sqrt(2 * (1 - fidelity(A, B)))
-    return dist
-
-
-def bures_angle(A, B):
-    """
-    Returns the Bures Angle between two density matrices A & B.
-
-    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
-
-    Parameters
-    ----------
-    A : qobj
-        Density matrix or state vector.
-    B : qobj
-        Density matrix or state vector with same dimensions as A.
-
-    Returns
-    -------
-    angle : float
-        Bures angle between density matrices.
-    """
-    if A.isket or A.isbra:
-        A = A.proj()
-    if B.isket or B.isbra:
-        B = B.proj()
-    if A.dims != B.dims:
-        raise TypeError('A and B do not have same dimensions.')
-    return np.arccos(fidelity(A, B))
-
-
-def hellinger_dist(A, B, sparse=False, tol=0):
-    """
-    Calculates the quantum Hellinger distance between two density matrices.
-
-    Formula:
-    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
-
-    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
-    measures of quantum correlations with Bures and Hellinger distances"
-    arXiv:1611.03449
-
-    Parameters
-    ----------
-    A : :class:`qutip.Qobj`
-        Density matrix or state vector.
-    B : :class:`qutip.Qobj`
-        Density matrix or state vector with same dimensions as A.
-    tol : float
-        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
-    sparse : {False, True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    hellinger_dist : float
-        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
-
-    Examples
-    --------
-    >>> x=fock_dm(5,3)
-    >>> y=coherent_dm(5,1)
-    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
-    """
-    if A.isket or A.isbra:
-        sqrtmA = ket2dm(A)
-    else:
-        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
-    if B.isket or B.isbra:
-        sqrtmB = ket2dm(B)
-    else:
-        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
-
-    if sqrtmA.dims != sqrtmB.dims:
-        raise TypeError("A and B do not have compatible dimensions.")
-
-    product = sqrtmA*sqrtmB
-    eigs = product.eigenenergies(sparse=sparse, tol=tol)
-    # np.maximum() is to avoid nan appearing sometimes due to numerical
-    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
-    # hellinger_dist(A, B) is called for A=B
-    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
-
-
-def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
-          sparse=True):
-    """
-    Calculates the diamond norm of the quantum map q_oper, using
-    the simplified semidefinite program of [Wat13]_.
-
-    The diamond norm SDP is solved by using CVXPY_.
-
-    Parameters
-    ----------
-    A : Qobj
-        Quantum map to take the diamond norm of.
-    B : Qobj or None
-        If provided, the diamond norm of :math:`A - B` is taken instead.
-    solver : str
-        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
-        latter tends to be significantly faster, but somewhat less accurate.
-    verbose : bool
-        If True, prints additional information about the solution.
-    force_solve : bool
-        If True, forces dnorm to solve the associated SDP, even if a special
-        case is known for the argument.
-    sparse : bool
-        Whether to use sparse matrices in the convex optimisation problem.
-        Default True.
-
-    Returns
-    -------
-    dn : float
-        Diamond norm of q_oper.
-
-    Raises
-    ------
-    ImportError
-        If CVXPY cannot be imported.
-
-    .. _cvxpy: https://www.cvxpy.org/en/latest/
-    """
-    if cvxpy is None:  # pragma: no cover
-        raise ImportError("dnorm() requires CVXPY to be installed.")
-
-    # We follow the strategy of using Watrous' simpler semidefinite
-    # program in its primal form. This is the same strategy used,
-    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
-    # QETLAB uses the dual problem.)
-
-    # Check if A and B are both unitaries. If so, then we can without
-    # loss of generality choose B to be the identity by using the
-    # unitary invariance of the diamond norm,
-    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
-    # Then, using the technique mentioned by each of Johnston and
-    # da Silva,
-    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
-    # where \lambda_i(U) is the ith eigenvalue of U.
-
-    # There's a lot of conditions to check for this path.  Only check if they
-    # aren't superoperators.  The difference of unitaries optimization is
-    # currently only implemented for d == 2. Much of the code below is more
-    # general, though, in anticipation of generalizing the optimization.
-    if (
-        not force_solve
-        and B is not None
-        and A.isoper and B.isoper
-        and A.shape[0] == 2
-    ):
-        # Make an identity the same size as A and B to
-        # compare against.
-        I = qeye(A.dims[0])
-        # Compare to B first, so that an error is raised
-        # as soon as possible.
-        Bd = B.dag()
-        if (
-            (B * Bd - I).norm() < 1e-6 and
-            (A * A.dag() - I).norm() < 1e-6
-        ):
-            # Now we are on the fast path, so let's compute the
-            # eigenvalues, then find the diameter of the smallest circle
-            # containing all of them.
-            #
-            # For now, this is only implemented for dim = 2, such that
-            # generalizing here will allow for generalizing the optimization.
-            # A reasonable approach would probably be to use Welzl's algorithm
-            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
-            U = A * B.dag()
-            eigs = U.eigenenergies()
-            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
-            return np.max(eig_distances)
-
-    # Force the input superoperator to be a Choi matrix.
-    J = to_choi(A)
-
-    if B is not None:
-        J -= to_choi(B)
-
-    # Watrous 2012 also points out that the diamond norm of Lambda
-    # is the same as the completely-bounded operator-norm (∞-norm)
-    # of the dual map of Lambda. We can evaluate that norm much more
-    # easily if Lambda is completely positive, since then the largest
-    # eigenvalue is the same as the largest singular value.
-
-    if not force_solve and J.iscp:
-        S_dual = to_super(J.dual_chan())
-        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
-        op = vector_to_operator(S_dual * vec_eye)
-        # The 2-norm was not implemented for sparse matrices as of the time
-        # of this writing. Thus, we must yet again go dense.
-        return la.norm(op.full(), 2)
-
-    # If we're still here, we need to actually solve the problem.
-
-    # Assume square...
-    dim = np.prod(J.dims[0][0])
-
-    # The constraints only depend on the dimension, so
-    # we can cache them efficiently.
-    problem, Jr, Ji, *_ = dnorm_problem(dim)
-
-    # Load the parameters with the Choi matrix passed in.
-    J_dat = _data.to('csr', J.data).as_scipy()
-
-    if not sparse:
-        # The parameters and constraints only depend on the dimension, so
-        # we can cache them efficiently.
-        problem, Jr, Ji = dnorm_problem(dim)
-
-        # Load the parameters with the Choi matrix passed in.
-        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
-                                  J_dat.indptr),
-                                 shape=J_dat.shape).toarray()
-
-        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
-                                  J_dat.indptr),
-                                 shape=J_dat.shape).toarray()
-    else:
-
-        # The parameters do not depend solely on the dimension,
-        # so we can not cache them efficiently.
-        problem = dnorm_sparse_problem(dim, J_dat)
-
-    problem.solve(solver=solver, verbose=verbose)
-
-    return problem.value
-
-
-def unitarity(oper):
-    """
-    Returns the unitarity of a quantum map, defined as the Frobenius norm
-    of the unital block of that map's superoperator representation.
-
-    Parameters
-    ----------
-    oper : Qobj
-        Quantum map under consideration.
-
-    Returns
-    -------
-    u : float
-        Unitarity of ``oper``.
-    """
-    Eu = _to_superpauli(oper).full()[1:, 1:]
-    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
+# -*- coding: utf-8 -*-
+
+"""
+This module contains a collection of functions for calculating metrics
+(distance measures) between states and operators.
+"""
+
+__all__ = ['fidelity', 'tracedist', 'bures_dist', 'bures_angle',
+           'hellinger_dist', 'hilbert_dist', 'average_gate_fidelity',
+           'process_fidelity', 'unitarity', 'dnorm']
+
+import warnings
+
+import numpy as np
+from scipy import linalg as la
+import scipy.sparse as sp
+from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
+                           kraus_to_choi)
+from .superoperator import operator_to_vector, vector_to_operator
+from .operators import qeye
+from .states import ket2dm
+from .semidefinite import dnorm_problem, dnorm_sparse_problem
+from . import data as _data
+
+try:
+    import cvxpy
+except ImportError:
+    cvxpy = None
+
+
+def fidelity(A, B):
+    """
+    Calculates the fidelity (pseudo-metric) between two density matrices.
+    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    fid : float
+        Fidelity pseudo-metric between A and B.
+
+    Examples
+    --------
+    >>> x = fock_dm(5,3)
+    >>> y = coherent_dm(5,1)
+    >>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)
+    """
+    if A.isket or A.isbra:
+        if B.isket or B.isbra:
+            # The fidelity for pure states reduces to the modulus of their
+            # inner product.
+            return np.abs(A.overlap(B))
+        # Take advantage of the fact that the density operator for A
+        # is a projector to avoid a sqrtm call.
+        sqrtmA = ket2dm(A)
+    else:
+        if B.isket or B.isbra:
+            # Swap the order so that we can take a more numerically
+            # stable square root of B.
+            return fidelity(B, A)
+        # If we made it here, both A and B are operators, so
+        # we have to take the sqrtm of one of them.
+        sqrtmA = A.sqrtm()
+
+    if sqrtmA.dims != B.dims:
+        raise TypeError('Density matrices do not have same dimensions.')
+
+    # We don't actually need the whole matrix here, just the trace
+    # of its square root, so let's just get its eigenenergies instead.
+    # We also truncate negative eigenvalues to avoid nan propagation;
+    # even for positive semidefinite matrices, small negative eigenvalues
+    # can be reported.
+    eig_vals = (sqrtmA * B * sqrtmA).eigenenergies()
+    return float(np.real(np.sqrt(eig_vals[eig_vals > 0]).sum()))
+
+
+def _hilbert_space_dims(oper):
+    """
+    For a quantum channel `oper`, return the dimensions `[dims_out, dims_in]`
+    of the output Hilbert space and the input Hilbert space.
+    - If oper is a unitary, then `oper.dims == [dims_out, dims_in]`.
+    - If oper is a list of Kraus operators, then
+     `oper[0].dims == [dims_out, dims_in]`.
+    - If oper is a superoperator with `oper.superrep == 'super'`:
+     `oper.dims == [[dims_out, dims_out], [dims_in, dims_in]]`
+    - If oper is a superoperator with `oper.superrep == 'choi'`:
+     `oper.dims == [[dims_in, dims_out], [dims_in, dims_out]]`
+    - If oper is a superoperator with `oper.superrep == 'chi', then
+      `dims_out == dims_in` and
+      `oper.dims == [[dims_out, dims_out], [dims_out, dims_out]]`.
+    :param oper: A quantum channel, represented by a unitary, a list of Kraus
+    operators, or a superoperator
+    :return: `[dims_out, dims_in]`, where `dims_out` and `dims_in` are lists
+     of integers
+    """
+    if isinstance(oper, list):
+        return oper[0].dims
+    elif oper.type == 'oper':  # interpret as unitary quantum channel
+        return oper.dims
+    elif oper.type == 'super' and oper.superrep in ['choi', 'chi', 'super']:
+        return [oper.dims[0][1], oper.dims[1][0]]
+    else:
+        raise TypeError('oper is not a valid quantum channel!')
+
+
+def _process_fidelity_to_id(oper):
+    """
+    Internal function returning the process fidelity of a quantum channel
+    to the identity quantum channel.
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+    Returns
+    -------
+    fid : float
+    """
+    dims_out, dims_in = _hilbert_space_dims(oper)
+    if dims_out != dims_in:
+        raise TypeError('The process fidelity to identity is only defined '
+                        'for dimension preserving channels.')
+    d = np.prod(dims_in)
+    if isinstance(oper, list):  # oper is a list of Kraus operators
+        return np.sum([np.abs(k.tr()) ** 2 for k in oper]) / d ** 2
+    elif oper.type == 'oper':  # interpret as unitary
+        return np.abs(oper.tr()) ** 2 / d ** 2
+    elif oper.type == 'super':
+        if oper.superrep == 'chi':
+            return oper[0, 0].real / d ** 2
+        else:  # oper.superrep is either 'super' or 'choi':
+            return to_super(oper).tr().real / d ** 2
+
+
+def _kraus_or_qobj_to_choi(oper):
+    if isinstance(oper, list):
+        return kraus_to_choi(oper)
+    else:
+        return to_choi(oper)
+
+
+def process_fidelity(oper, target=None):
+    """
+    Returns the process fidelity of a quantum channel to the target
+    channel, or to the identity channel if no target is given.
+    The process fidelity between two channels is defined as the state
+    fidelity between their normalized Choi matrices.
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+    target : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+
+    Returns
+    -------
+    fid : float
+        Process fidelity between oper and target, or between oper and identity.
+
+    Notes
+    -----
+    Since Qutip 5.0, this function computes the process fidelity as defined
+    for example in: A. Gilchrist, N.K. Langford, M.A. Nielsen,
+    Phys. Rev. A 71, 062310 (2005). Previously, it computed a function
+    that is now implemented in
+    :func:`control.fidcomp.FidCompUnitary.get_fidelity`.
+    The definition of state fidelity that the process fidelity is based on
+    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
+    It is the square of the one implemented in
+    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
+    "Quantum Computation and Quantum Information"
+
+    """
+    if target is None:
+        return _process_fidelity_to_id(oper)
+
+    dims_out, dims_in = _hilbert_space_dims(oper)
+    if dims_out != dims_in:
+        raise NotImplementedError('Process fidelity only implemented for '
+                                  'dimension-preserving operators.')
+    dims_out_target, dims_in_target = _hilbert_space_dims(target)
+    if [dims_out, dims_in] != [dims_out_target, dims_in_target]:
+        raise TypeError('Dimensions of oper and target do not match')
+
+    if not isinstance(target, list) and target.type == 'oper':
+        # interpret target as unitary.
+        if isinstance(oper, list):  # oper is a list of Kraus operators
+            return _process_fidelity_to_id([k * target.dag() for k in oper])
+        elif oper.type == 'oper':
+            return _process_fidelity_to_id(oper*target.dag())
+        elif oper.type == 'super':
+            oper_super = to_super(oper)
+            target_dag_super = to_super(target.dag())
+            return _process_fidelity_to_id(oper_super * target_dag_super)
+    else:  # target is a list of Kraus operators or a superoperator
+        if not isinstance(oper, list) and oper.type == 'oper':
+            return process_fidelity(target, oper)  # reverse order
+        oper_choi = _kraus_or_qobj_to_choi(oper)
+        target_choi = _kraus_or_qobj_to_choi(target)
+        d = np.prod(dims_in)
+        return (fidelity(oper_choi, target_choi)/d)**2
+
+
+def average_gate_fidelity(oper, target=None):
+    """
+    Returns the average gate fidelity of a quantum channel to the target
+    channel, or to the identity channel if no target is given.
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`/list
+        A unitary operator, or a superoperator in supermatrix, Choi or
+        chi-matrix form, or a list of Kraus operators
+    target : :class:`qutip.Qobj`
+        A unitary operator
+
+    Returns
+    -------
+    fid : float
+        Average gate fidelity between oper and target,
+        or between oper and identity.
+
+    Notes
+    -----
+    The average gate fidelity is defined for example in:
+    A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005).
+    The definition of state fidelity that the average gate fidelity is based on
+    is the one from R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994).
+    It is the square of the fidelity implemented in
+    :func:`qutip.core.metrics.fidelity` which follows Nielsen & Chuang,
+    "Quantum Computation and Quantum Information"
+
+    """
+    dims_out, dims_in = _hilbert_space_dims(oper)
+    if not (target is None or target.type == 'oper'):
+        raise TypeError(
+            'target must be None or a Qobj representing a unitary.')
+
+    d = np.prod(dims_in)
+    return (d * process_fidelity(oper, target) + 1) / (d + 1)
+
+
+def tracedist(A, B, sparse=False, tol=0):
+    """
+    Calculates the trace distance between two density matrices..
+    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
+
+    Parameters
+    ----------!=
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+    tol : float
+        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
+    sparse : {False, True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    tracedist : float
+        Trace distance between A and B.
+
+    Examples
+    --------
+    >>> x=fock_dm(5,3)
+    >>> y=coherent_dm(5,1)
+    >>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError("A and B do not have same dimensions.")
+    diff = A - B
+    diff = diff.dag() * diff
+    vals = diff.eigenenergies(sparse=sparse, tol=tol)
+    return float(np.real(0.5 * np.sum(np.sqrt(np.abs(vals)))))
+
+
+def hilbert_dist(A, B):
+    """
+    Returns the Hilbert-Schmidt distance between two density matrices A & B.
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    dist : float
+        Hilbert-Schmidt distance between density matrices.
+
+    Notes
+    -----
+    See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).
+
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError('A and B do not have same dimensions.')
+    return ((A - B)**2).tr()
+
+
+def bures_dist(A, B):
+    """
+    Returns the Bures distance between two density matrices A & B.
+
+    The Bures distance ranges from 0, for states with unit fidelity,
+    to sqrt(2).
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    dist : float
+        Bures distance between density matrices.
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError('A and B do not have same dimensions.')
+    dist = np.sqrt(2 * (1 - fidelity(A, B)))
+    return dist
+
+
+def bures_angle(A, B):
+    """
+    Returns the Bures Angle between two density matrices A & B.
+
+    The Bures angle ranges from 0, for states with unit fidelity, to pi/2.
+
+    Parameters
+    ----------
+    A : qobj
+        Density matrix or state vector.
+    B : qobj
+        Density matrix or state vector with same dimensions as A.
+
+    Returns
+    -------
+    angle : float
+        Bures angle between density matrices.
+    """
+    if A.isket or A.isbra:
+        A = A.proj()
+    if B.isket or B.isbra:
+        B = B.proj()
+    if A.dims != B.dims:
+        raise TypeError('A and B do not have same dimensions.')
+    return np.arccos(fidelity(A, B))
+
+
+def hellinger_dist(A, B, sparse=False, tol=0):
+    """
+    Calculates the quantum Hellinger distance between two density matrices.
+
+    Formula:
+    hellinger_dist(A, B) = sqrt(2-2*Tr(sqrt(A)*sqrt(B)))
+
+    See: D. Spehner, F. Illuminati, M. Orszag, and W. Roga, "Geometric
+    measures of quantum correlations with Bures and Hellinger distances"
+    arXiv:1611.03449
+
+    Parameters
+    ----------
+    A : :class:`qutip.Qobj`
+        Density matrix or state vector.
+    B : :class:`qutip.Qobj`
+        Density matrix or state vector with same dimensions as A.
+    tol : float
+        Tolerance used by sparse eigensolver, if used. (0=Machine precision)
+    sparse : {False, True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    hellinger_dist : float
+        Quantum Hellinger distance between A and B. Ranges from 0 to sqrt(2).
+
+    Examples
+    --------
+    >>> x=fock_dm(5,3)
+    >>> y=coherent_dm(5,1)
+    >>> np.testing.assert_almost_equal(hellinger_dist(x,y), 1.3725145002591095)
+    """
+    if A.isket or A.isbra:
+        sqrtmA = ket2dm(A)
+    else:
+        sqrtmA = A.sqrtm(sparse=sparse, tol=tol)
+    if B.isket or B.isbra:
+        sqrtmB = ket2dm(B)
+    else:
+        sqrtmB = B.sqrtm(sparse=sparse, tol=tol)
+
+    if sqrtmA.dims != sqrtmB.dims:
+        raise TypeError("A and B do not have compatible dimensions.")
+
+    product = sqrtmA*sqrtmB
+    eigs = product.eigenenergies(sparse=sparse, tol=tol)
+    # np.maximum() is to avoid nan appearing sometimes due to numerical
+    # instabilities causing np.sum(eigs) slightly (~1e-8) larger than 1 when
+    # hellinger_dist(A, B) is called for A=B
+    return np.sqrt(2.0 * np.maximum(0, 1 - np.real(np.sum(eigs))))
+
+
+def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
+          sparse=True):
+    """
+    Calculates the diamond norm of the quantum map q_oper, using
+    the simplified semidefinite program of [Wat13]_.
+
+    The diamond norm SDP is solved by using CVXPY_.
+
+    Parameters
+    ----------
+    A : Qobj
+        Quantum map to take the diamond norm of.
+    B : Qobj or None
+        If provided, the diamond norm of :math:`A - B` is taken instead.
+    solver : str
+        Solver to use with CVXPY. One of "CVXOPT" (default) or "SCS". The
+        latter tends to be significantly faster, but somewhat less accurate.
+    verbose : bool
+        If True, prints additional information about the solution.
+    force_solve : bool
+        If True, forces dnorm to solve the associated SDP, even if a special
+        case is known for the argument.
+    sparse : bool
+        Whether to use sparse matrices in the convex optimisation problem.
+        Default True.
+
+    Returns
+    -------
+    dn : float
+        Diamond norm of q_oper.
+
+    Raises
+    ------
+    ImportError
+        If CVXPY cannot be imported.
+
+    .. _cvxpy: https://www.cvxpy.org/en/latest/
+    """
+    if cvxpy is None:  # pragma: no cover
+        raise ImportError("dnorm() requires CVXPY to be installed.")
+
+    # We follow the strategy of using Watrous' simpler semidefinite
+    # program in its primal form. This is the same strategy used,
+    # for instance, by both pyGSTi and SchattenNorms.jl. (By contrast,
+    # QETLAB uses the dual problem.)
+
+    # Check if A and B are both unitaries. If so, then we can without
+    # loss of generality choose B to be the identity by using the
+    # unitary invariance of the diamond norm,
+    #     || A - B ||_♢ = || A B⁺ - I ||_♢.
+    # Then, using the technique mentioned by each of Johnston and
+    # da Silva,
+    #     || A B⁺ - I ||_♢ = max_{i, j} | \lambda_i(A B⁺) - \lambda_j(A B⁺) |,
+    # where \lambda_i(U) is the ith eigenvalue of U.
+
+    # There's a lot of conditions to check for this path.  Only check if they
+    # aren't superoperators.  The difference of unitaries optimization is
+    # currently only implemented for d == 2. Much of the code below is more
+    # general, though, in anticipation of generalizing the optimization.
+    if (
+        not force_solve
+        and B is not None
+        and A.isoper and B.isoper
+        and A.shape[0] == 2
+    ):
+        # Make an identity the same size as A and B to
+        # compare against.
+        I = qeye(A.dims[0])
+        # Compare to B first, so that an error is raised
+        # as soon as possible.
+        Bd = B.dag()
+        if (
+            (B * Bd - I).norm() < 1e-6 and
+            (A * A.dag() - I).norm() < 1e-6
+        ):
+            # Now we are on the fast path, so let's compute the
+            # eigenvalues, then find the diameter of the smallest circle
+            # containing all of them.
+            #
+            # For now, this is only implemented for dim = 2, such that
+            # generalizing here will allow for generalizing the optimization.
+            # A reasonable approach would probably be to use Welzl's algorithm
+            # (https://en.wikipedia.org/wiki/Smallest-circle_problem).
+            U = A * B.dag()
+            eigs = U.eigenenergies()
+            eig_distances = np.abs(eigs[:, None] - eigs[None, :])
+            return np.max(eig_distances)
+
+    # Force the input superoperator to be a Choi matrix.
+    J = to_choi(A)
+
+    if B is not None:
+        J -= to_choi(B)
+
+    # Watrous 2012 also points out that the diamond norm of Lambda
+    # is the same as the completely-bounded operator-norm (∞-norm)
+    # of the dual map of Lambda. We can evaluate that norm much more
+    # easily if Lambda is completely positive, since then the largest
+    # eigenvalue is the same as the largest singular value.
+
+    if not force_solve and J.iscp:
+        S_dual = to_super(J.dual_chan())
+        vec_eye = operator_to_vector(qeye(S_dual.dims[1][1]))
+        op = vector_to_operator(S_dual * vec_eye)
+        # The 2-norm was not implemented for sparse matrices as of the time
+        # of this writing. Thus, we must yet again go dense.
+        return la.norm(op.full(), 2)
+
+    # If we're still here, we need to actually solve the problem.
+
+    # Assume square...
+    dim = np.prod(J.dims[0][0])
+
+    # The constraints only depend on the dimension, so
+    # we can cache them efficiently.
+    problem, Jr, Ji, *_ = dnorm_problem(dim)
+
+    # Load the parameters with the Choi matrix passed in.
+    J_dat = _data.to('csr', J.data).as_scipy()
+
+    if not sparse:
+        # The parameters and constraints only depend on the dimension, so
+        # we can cache them efficiently.
+        problem, Jr, Ji = dnorm_problem(dim)
+
+        # Load the parameters with the Choi matrix passed in.
+        Jr.value = sp.csr_matrix((J_dat.data.real, J_dat.indices,
+                                  J_dat.indptr),
+                                 shape=J_dat.shape).toarray()
+
+        Ji.value = sp.csr_matrix((J_dat.data.imag, J_dat.indices,
+                                  J_dat.indptr),
+                                 shape=J_dat.shape).toarray()
+    else:
+
+        # The parameters do not depend solely on the dimension,
+        # so we can not cache them efficiently.
+        problem = dnorm_sparse_problem(dim, J_dat)
+
+    problem.solve(solver=solver, verbose=verbose)
+
+    return problem.value
+
+
+def unitarity(oper):
+    """
+    Returns the unitarity of a quantum map, defined as the Frobenius norm
+    of the unital block of that map's superoperator representation.
+
+    Parameters
+    ----------
+    oper : Qobj
+        Quantum map under consideration.
+
+    Returns
+    -------
+    u : float
+        Unitarity of ``oper``.
+    """
+    Eu = _to_superpauli(oper).full()[1:, 1:]
+    return np.linalg.norm(Eu, 'fro')**2 / len(Eu)
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index f3de7e2223..f2921882a9 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -1,1073 +1,1073 @@
-"""
-This module contains functions for generating Qobj representation of a variety
-of commonly occuring quantum operators.
-"""
-
-__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
-           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
-           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
-           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
-           'enr_identity', 'charge', 'tunneling', 'qft']
-
-import numbers
-
-import numpy as np
-import scipy.sparse
-
-from . import data as _data
-from .qobj import Qobj
-from .dimensions import flatten
-from .. import settings
-
-
-def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
-           dtype=None):
-    """
-    Constructs an operator from an array of diagonals.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like
-        Array of elements to place along the selected diagonals.
-
-    offsets : sequence of ints, optional
-        Sequence for diagonals to be set:
-            - k=0 main diagonal
-            - k>0 kth upper diagonal
-            - k<0 kth lower diagonal
-
-    dims : list, optional
-        Dimensions for operator
-
-    shape : list, tuple, optional
-        Shape of operator.  If omitted, a square operator large enough
-        to contain the diagonals is generated.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Examples
-    --------
-    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
-    Quantum object: dims = [[4], [4]], \
-shape = [4, 4], type = oper, isherm = False
-    Qobj data =
-    [[ 0.          1.          0.          0.        ]
-     [ 0.          0.          1.41421356  0.        ]
-     [ 0.          0.          0.          1.73205081]
-     [ 0.          0.          0.          0.        ]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    offsets = [0] if offsets is None else offsets
-    data = _data.diag[dtype](diagonals, offsets, shape)
-    return Qobj(data, dims=dims, type='oper', copy=False)
-
-
-def jmat(j, which=None, *, dtype=None):
-    """Higher-order spin operators:
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    which : str
-        Which operator to return 'x','y','z','+','-'.
-        If no args given, then output is ['x','y','z']
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    jmat : Qobj or tuple of Qobj
-        ``qobj`` for requested spin operator(s).
-
-
-    Examples
-    --------
-    >>> jmat(1) # doctest: +SKIP
-    [ Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.          0.70710678  0.        ]
-     [ 0.70710678  0.          0.70710678]
-     [ 0.          0.70710678  0.        ]]
-     Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
-     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
-     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
-     Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 1.  0.  0.]
-     [ 0.  0.  0.]
-     [ 0.  0. -1.]]]
-
-    Notes
-    -----
-    If no 'args' input, then returns array of ['x','y','z'] operators.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if int(2 * j) != 2 * j or j < 0:
-        raise ValueError('j must be a non-negative integer or half-integer')
-
-    if not which:
-        return (
-            jmat(j, 'x', dtype=dtype),
-            jmat(j, 'y', dtype=dtype),
-            jmat(j, 'z', dtype=dtype)
-        )
-
-    dims = [[int(2*j + 1)]]*2
-    if which == '+':
-        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
-                    isherm=False, isunitary=False, copy=False)
-    if which == '-':
-        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
-                    isherm=False, isunitary=False, copy=False)
-    if which == 'x':
-        A =  _jplus(j, dtype=dtype)
-        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
-                    isherm=True, isunitary=False, copy=False) * 0.5
-    if which == 'y':
-        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
-        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
-                    isherm=True, isunitary=False, copy=False)
-    if which == 'z':
-        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
-                    isherm=True, isunitary=False, copy=False)
-    raise ValueError('Invalid spin operator: ' + which)
-
-
-def _jplus(j, *, dtype=None):
-    """
-    Internal functions for generating the data representing the J-plus
-    operator.
-    """
-    m = np.arange(j, -j - 1, -1, dtype=complex)
-    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
-    return _data.diag[dtype](data, 1)
-
-
-def _jz(j, *, dtype=None):
-    """
-    Internal functions for generating the data representing the J-z operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    N = int(2*j + 1)
-    data = np.array([j-k for k in range(N)], dtype=complex)
-    return _data.diag[dtype](data, 0)
-
-
-#
-# Spin j operators:
-#
-def spin_Jx(j, *, dtype=None):
-    """Spin-j x operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, 'x', dtype=dtype)
-
-
-def spin_Jy(j, *, dtype=None):
-    """Spin-j y operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, 'y', dtype=dtype)
-
-
-def spin_Jz(j, *, dtype=None):
-    """Spin-j z operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, 'z', dtype=dtype)
-
-
-def spin_Jm(j, *, dtype=None):
-    """Spin-j annihilation operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, '-', dtype=dtype)
-
-
-def spin_Jp(j, *, dtype=None):
-    """Spin-j creation operator
-
-    Parameters
-    ----------
-    j : float
-        Spin of operator
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        ``qobj`` representation of the operator.
-
-    """
-    return jmat(j, '+', dtype=dtype)
-
-
-def spin_J_set(j, *, dtype=None):
-    """Set of spin-j operators (x, y, z)
-
-    Parameters
-    ----------
-    j : float
-        Spin of operators
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    list : list of Qobj
-        list of ``qobj`` representating of the spin operator.
-
-    """
-    return jmat(j, dtype=dtype)
-
-
-# Pauli spin-1/2 operators.
-#
-# These are so common in quantum information that we want them to be
-# near-instantaneous to initialise, so we cache them at package import, and
-# just return copies when someone requests one.
-_SIGMAP = jmat(0.5, '+')
-_SIGMAM = jmat(0.5, '-')
-_SIGMAX = 2 * jmat(0.5, 'x')
-_SIGMAY = 2 * jmat(0.5, 'y')
-_SIGMAZ = 2 * jmat(0.5, 'z')
-
-
-def sigmap():
-    """Creation operator for Pauli spins.
-
-    Examples
-    --------
-    >>> sigmap() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.  1.]
-     [ 0.  0.]]
-
-    """
-    return _SIGMAP.copy()
-
-
-def sigmam():
-    """Annihilation operator for Pauli spins.
-
-    Examples
-    --------
-    >>> sigmam() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.  0.]
-     [ 1.  0.]]
-
-    """
-    return _SIGMAM.copy()
-
-
-def sigmax():
-    """Pauli spin 1/2 sigma-x operator
-
-    Examples
-    --------
-    >>> sigmax() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.  1.]
-     [ 1.  0.]]
-
-    """
-    return _SIGMAX.copy()
-
-
-def sigmay():
-    """Pauli spin 1/2 sigma-y operator.
-
-    Examples
-    --------
-    >>> sigmay() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j  0.-1.j]
-     [ 0.+1.j  0.+0.j]]
-
-    """
-    return _SIGMAY.copy()
-
-
-def sigmaz():
-    """Pauli spin 1/2 sigma-z operator.
-
-    Examples
-    --------
-    >>> sigmaz() # doctest: +SKIP
-    Quantum object: dims = [[2], [2]], \
-shape = [2, 2], type = oper, isHerm = True
-    Qobj data =
-    [[ 1.  0.]
-     [ 0. -1.]]
-
-    """
-    return _SIGMAZ.copy()
-
-
-def destroy(N, offset=0, *, dtype=None):
-    """
-    Destruction (lowering) operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Qobj for lowering operator.
-
-    Examples
-    --------
-    >>> destroy(4) # doctest: +SKIP
-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
-    Qobj data =
-    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
-        raise ValueError("Hilbert space dimension must be integer value")
-    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
-    return qdiags(data, 1, dtype=dtype)
-
-
-def create(N, offset=0, *, dtype=None):
-    """
-    Creation (raising) operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Qobj for raising operator.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    Examples
-    --------
-    >>> create(4) # doctest: +SKIP
-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
-    Qobj data =
-    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
-        raise ValueError("Hilbert space dimension must be integer value")
-    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
-    return qdiags(data, -1, dtype=dtype)
-
-
-def _implicit_tensor_dimensions(dimensions):
-    """
-    Total flattened size and operator dimensions for operator creation routines
-    that automatically perform tensor products.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        First dimension of an operator which can create an implicit tensor
-        product.  If the type is `int`, it is promoted first to `[dimensions]`.
-        From there, it should be one of the two-elements `dims` parameter of a
-        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
-        products.
-
-    Returns
-    -------
-    size : int
-        Dimension of backing matrix required to represent operator.
-    dimensions : list
-        Dimension list in the form required by ``Qobj`` creation.
-    """
-    if not isinstance(dimensions, list):
-        dimensions = [dimensions]
-    flat = flatten(dimensions)
-    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
-        raise ValueError("All dimensions must be integers >= 0")
-    return np.prod(flat), [dimensions, dimensions]
-
-
-def qzero(dimensions, *, dtype=None):
-    """
-    Zero operator.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    qzero : qobj
-        Zero operator Qobj.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    size, dimensions = _implicit_tensor_dimensions(dimensions)
-    # A sparse matrix with no data is equal to a zero matrix.
-    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
-    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
-                isherm=True, isunitary=False, copy=False)
-
-
-def qeye(dimensions, *, dtype=None):
-    """
-    Identity operator.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Identity operator Qobj.
-
-    Examples
-    --------
-    >>> qeye(3) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
-isherm = True
-    Qobj data =
-    [[ 1.  0.  0.]
-     [ 0.  1.  0.]
-     [ 0.  0.  1.]]
-    >>> qeye([2,2]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
-isherm = True
-    Qobj data =
-    [[1. 0. 0. 0.]
-     [0. 1. 0. 0.]
-     [0. 0. 1. 0.]
-     [0. 0. 0. 1.]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    size, dimensions = _implicit_tensor_dimensions(dimensions)
-    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
-    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
-                isherm=True, isunitary=True, copy=False)
-
-
-# Name alias.
-identity = qeye
-
-
-def position(N, offset=0, *, dtype=None):
-    """
-    Position operator x=1/sqrt(2)*(a+a.dag())
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Position operator as Qobj.
-    """
-    a = destroy(N, offset=offset, dtype=dtype)
-    position = np.sqrt(0.5) * (a + a.dag())
-    position.isherm = True
-    return position
-
-
-def momentum(N, offset=0, *, dtype=None):
-    """
-    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Momentum operator as Qobj.
-    """
-    a = destroy(N, offset=offset, dtype=dtype)
-    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
-    momentum.isherm = True
-    return momentum
-
-
-def num(N, offset=0, *, dtype=None):
-    """
-    Quantum object for number operator.
-
-    Parameters
-    ----------
-    N : int
-        The dimension of the Hilbert space.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper: qobj
-        Qobj for number operator.
-
-    Examples
-    --------
-    >>> num(4) # doctest: +SKIP
-    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
-    Qobj data =
-    [[0 0 0 0]
-     [0 1 0 0]
-     [0 0 2 0]
-     [0 0 0 3]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    data = np.arange(offset, offset + N, dtype=complex)
-    return qdiags(data, 0, dtype=dtype)
-
-
-def squeeze(N, z, offset=0, *, dtype=None):
-    """Single-mode squeezing operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of hilbert space.
-
-    z : float/complex
-        Squeezing parameter.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : :class:`qutip.Qobj`
-        Squeezing operator.
-
-
-    Examples
-    --------
-    >>> squeeze(4, 0.25) # doctest: +SKIP
-    Quantum object: dims = [[4], [4]], \
-shape = [4, 4], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
-     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
-     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
-
-    """
-    asq = destroy(N, offset=offset, dtype=dtype) ** 2
-    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
-    return op.expm(dtype=dtype)
-
-
-def squeezing(a1, a2, z):
-    """Generalized squeezing operator.
-
-    .. math::
-
-        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
-        - za_1^\\dagger a_2^\\dagger\\right)\\right)
-
-    Parameters
-    ----------
-    a1 : :class:`qutip.Qobj`
-        Operator 1.
-
-    a2 : :class:`qutip.Qobj`
-        Operator 2.
-
-    z : float/complex
-        Squeezing parameter.
-
-    Returns
-    -------
-    oper : :class:`qutip.Qobj`
-        Squeezing operator.
-
-    """
-    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
-    return b.expm()
-
-
-def displace(N, alpha, offset=0, *, dtype=None):
-    """Single-mode displacement operator.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of Hilbert space.
-
-    alpha : float/complex
-        Displacement amplitude.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the operator.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Displacement operator.
-
-    Examples
-    --------
-    >>> displace(4,0.25) # doctest: +SKIP
-    Quantum object: dims = [[4], [4]], \
-shape = [4, 4], type = oper, isHerm = False
-    Qobj data =
-    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
-     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
-     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
-     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    a = destroy(N, offset=offset)
-    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
-
-
-def commutator(A, B, kind="normal"):
-    """
-    Return the commutator of kind `kind` (normal, anti) of the
-    two operators A and B.
-    """
-    if kind == 'normal':
-        return A @ B - B @ A
-
-    elif kind == 'anti':
-        return A @ B + B @ A
-
-    else:
-        raise TypeError("Unknown commutator kind '%s'" % kind)
-
-
-def qutrit_ops(*, dtype=None):
-    """
-    Operators for a three level system (qutrit).
-
-    Parameters
-    ----------
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    opers: array
-        `array` of qutrit operators.
-
-    """
-    from .states import qutrit_basis
-
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    out = np.empty((6,), dtype=object)
-    one, two, three = qutrit_basis(dtype=dtype)
-    out[0] = one * one.dag()
-    out[1] = two * two.dag()
-    out[2] = three * three.dag()
-    out[3] = one * two.dag()
-    out[4] = two * three.dag()
-    out[5] = three * one.dag()
-    return out
-
-
-def phase(N, phi0=0, *, dtype=None):
-    """
-    Single-mode Pegg-Barnett phase operator.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    phi0 : float
-        Reference phase.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Phase operator with respect to reference phase.
-
-    Notes
-    -----
-    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
-    n = np.arange(N)[:, np.newaxis]
-    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
-                       for kk in phim])
-    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
-    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
-
-
-def enr_destroy(dims, excitations, *, dtype=None):
-    """
-    Generate annilation operators for modes in a excitation-number-restricted
-    state space. For example, consider a system consisting of 4 modes, each
-    with 5 states. The total hilbert space size is 5**4 = 625. If we are
-    only interested in states that contain up to 2 excitations, we only need
-    to include states such as
-
-        (0, 0, 0, 0)
-        (0, 0, 0, 1)
-        (0, 0, 0, 2)
-        (0, 0, 1, 0)
-        (0, 0, 1, 1)
-        (0, 0, 2, 0)
-        ...
-
-    This function creates annihilation operators for the 4 modes that act
-    within this state space:
-
-        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
-
-    From this point onwards, the annihiltion operators a1, ..., a4 can be
-    used to setup a Hamiltonian, collapse operators and expectation-value
-    operators, etc., following the usual pattern.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    a_ops : list of qobj
-        A list of annihilation operators for each mode in the composite
-        quantum system described by dims.
-    """
-    from .states import enr_state_dictionaries
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-
-    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
-
-    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
-             for _ in dims]
-
-    for n1, state1 in enumerate(idx2state):
-        for idx, s in enumerate(state1):
-            # if s > 0, the annihilation operator of mode idx has a non-zero
-            # entry with one less excitation in mode idx in the final state
-            if s > 0:
-                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
-                n2 = state2idx[state2]
-                a_ops[idx][n2, n1] = np.sqrt(s)
-
-    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
-
-
-def enr_identity(dims, excitations, *, dtype=None):
-    """
-    Generate the identity operator for the excitation-number restricted
-    state space defined by the `dims` and `exciations` arguments. See the
-    docstring for enr_fock for a more detailed description of these arguments.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    state : list of integers
-        The state in the number basis representation.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    op : Qobj
-        A Qobj instance that represent the identity operator in the
-        exication-number-restricted state space defined by `dims` and
-        `exciations`.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    from .states import enr_state_dictionaries
-    nstates, _, _ = enr_state_dictionaries(dims, excitations)
-    return Qobj(_data.identity[dtype](nstates),
-                dims=[dims, dims],
-                type='oper',
-                isherm=True,
-                isunitary=True,
-                copy=False)
-
-
-def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
-    """
-    Generate the diagonal charge operator over charge states
-    from Nmin to Nmax.
-
-    Parameters
-    ----------
-    Nmax : int
-        Maximum charge state to consider.
-
-    Nmin : int (default = -Nmax)
-        Lowest charge state to consider.
-
-    frac : float (default = 1)
-        Specify fractional charge if needed.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    C : Qobj
-        Charge operator over [Nmin, Nmax].
-
-    Notes
-    -----
-    .. versionadded:: 3.2
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if Nmin is None:
-        Nmin = -Nmax
-    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
-    out = qdiags(diag, 0, dtype=dtype)
-    out.isherm = True
-    return out
-
-
-def tunneling(N, m=1, *, dtype=None):
-    r"""
-    Tunneling operator with elements of the form
-    :math:`\\sum |N><N+m| + |N+m><N|`.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    m : int (default = 1)
-        Number of excitations in tunneling event.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    T : Qobj
-        Tunneling operator.
-
-    Notes
-    -----
-    .. versionadded:: 3.2
-
-    """
-    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
-    T = qdiags(diags, [m, -m], dtype=dtype)
-    T.isherm = True
-    return T
-
-
-def qft(dimensions, *, dtype="dense"):
-    """
-    Quantum Fourier Transform operator.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.
-
-    dtype : str or type, [keyword only] [optional]
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    QFT: qobj
-        Quantum Fourier transform operator.
-
-    """
-    N2, dimensions = _implicit_tensor_dimensions(dimensions)
-
-    phase = 2.0j * np.pi / N2
-    arr = np.arange(N2)
-    L, M = np.meshgrid(arr, arr)
-    data = np.exp(phase * (L * M)) / np.sqrt(N2)
-    return Qobj(data, dims=dimensions).to(dtype)
+"""
+This module contains functions for generating Qobj representation of a variety
+of commonly occuring quantum operators.
+"""
+
+__all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
+           'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
+           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
+           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
+           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
+           'enr_identity', 'charge', 'tunneling', 'qft']
+
+import numbers
+
+import numpy as np
+import scipy.sparse
+
+from . import data as _data
+from .qobj import Qobj
+from .dimensions import flatten
+from .. import settings
+
+
+def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
+           dtype=None):
+    """
+    Constructs an operator from an array of diagonals.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like
+        Array of elements to place along the selected diagonals.
+
+    offsets : sequence of ints, optional
+        Sequence for diagonals to be set:
+            - k=0 main diagonal
+            - k>0 kth upper diagonal
+            - k<0 kth lower diagonal
+
+    dims : list, optional
+        Dimensions for operator
+
+    shape : list, tuple, optional
+        Shape of operator.  If omitted, a square operator large enough
+        to contain the diagonals is generated.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Examples
+    --------
+    >>> qdiags(sqrt(range(1, 4)), 1) # doctest: +SKIP
+    Quantum object: dims = [[4], [4]], \
+shape = [4, 4], type = oper, isherm = False
+    Qobj data =
+    [[ 0.          1.          0.          0.        ]
+     [ 0.          0.          1.41421356  0.        ]
+     [ 0.          0.          0.          1.73205081]
+     [ 0.          0.          0.          0.        ]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    offsets = [0] if offsets is None else offsets
+    data = _data.diag[dtype](diagonals, offsets, shape)
+    return Qobj(data, dims=dims, type='oper', copy=False)
+
+
+def jmat(j, which=None, *, dtype=None):
+    """Higher-order spin operators:
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    which : str
+        Which operator to return 'x','y','z','+','-'.
+        If no args given, then output is ['x','y','z']
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    jmat : Qobj or tuple of Qobj
+        ``qobj`` for requested spin operator(s).
+
+
+    Examples
+    --------
+    >>> jmat(1) # doctest: +SKIP
+    [ Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.          0.70710678  0.        ]
+     [ 0.70710678  0.          0.70710678]
+     [ 0.          0.70710678  0.        ]]
+     Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
+     [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
+     [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
+     Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 1.  0.  0.]
+     [ 0.  0.  0.]
+     [ 0.  0. -1.]]]
+
+    Notes
+    -----
+    If no 'args' input, then returns array of ['x','y','z'] operators.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if int(2 * j) != 2 * j or j < 0:
+        raise ValueError('j must be a non-negative integer or half-integer')
+
+    if not which:
+        return (
+            jmat(j, 'x', dtype=dtype),
+            jmat(j, 'y', dtype=dtype),
+            jmat(j, 'z', dtype=dtype)
+        )
+
+    dims = [[int(2*j + 1)]]*2
+    if which == '+':
+        return Qobj(_jplus(j, dtype=dtype), dims=dims, type='oper',
+                    isherm=False, isunitary=False, copy=False)
+    if which == '-':
+        return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
+                    isherm=False, isunitary=False, copy=False)
+    if which == 'x':
+        A =  _jplus(j, dtype=dtype)
+        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
+                    isherm=True, isunitary=False, copy=False) * 0.5
+    if which == 'y':
+        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
+        return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
+                    isherm=True, isunitary=False, copy=False)
+    if which == 'z':
+        return Qobj(_jz(j, dtype=dtype), dims=dims, type='oper',
+                    isherm=True, isunitary=False, copy=False)
+    raise ValueError('Invalid spin operator: ' + which)
+
+
+def _jplus(j, *, dtype=None):
+    """
+    Internal functions for generating the data representing the J-plus
+    operator.
+    """
+    m = np.arange(j, -j - 1, -1, dtype=complex)
+    data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]
+    return _data.diag[dtype](data, 1)
+
+
+def _jz(j, *, dtype=None):
+    """
+    Internal functions for generating the data representing the J-z operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    N = int(2*j + 1)
+    data = np.array([j-k for k in range(N)], dtype=complex)
+    return _data.diag[dtype](data, 0)
+
+
+#
+# Spin j operators:
+#
+def spin_Jx(j, *, dtype=None):
+    """Spin-j x operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, 'x', dtype=dtype)
+
+
+def spin_Jy(j, *, dtype=None):
+    """Spin-j y operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, 'y', dtype=dtype)
+
+
+def spin_Jz(j, *, dtype=None):
+    """Spin-j z operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, 'z', dtype=dtype)
+
+
+def spin_Jm(j, *, dtype=None):
+    """Spin-j annihilation operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, '-', dtype=dtype)
+
+
+def spin_Jp(j, *, dtype=None):
+    """Spin-j creation operator
+
+    Parameters
+    ----------
+    j : float
+        Spin of operator
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        ``qobj`` representation of the operator.
+
+    """
+    return jmat(j, '+', dtype=dtype)
+
+
+def spin_J_set(j, *, dtype=None):
+    """Set of spin-j operators (x, y, z)
+
+    Parameters
+    ----------
+    j : float
+        Spin of operators
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    list : list of Qobj
+        list of ``qobj`` representating of the spin operator.
+
+    """
+    return jmat(j, dtype=dtype)
+
+
+# Pauli spin-1/2 operators.
+#
+# These are so common in quantum information that we want them to be
+# near-instantaneous to initialise, so we cache them at package import, and
+# just return copies when someone requests one.
+_SIGMAP = jmat(0.5, '+')
+_SIGMAM = jmat(0.5, '-')
+_SIGMAX = 2 * jmat(0.5, 'x')
+_SIGMAY = 2 * jmat(0.5, 'y')
+_SIGMAZ = 2 * jmat(0.5, 'z')
+
+
+def sigmap():
+    """Creation operator for Pauli spins.
+
+    Examples
+    --------
+    >>> sigmap() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.  1.]
+     [ 0.  0.]]
+
+    """
+    return _SIGMAP.copy()
+
+
+def sigmam():
+    """Annihilation operator for Pauli spins.
+
+    Examples
+    --------
+    >>> sigmam() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.  0.]
+     [ 1.  0.]]
+
+    """
+    return _SIGMAM.copy()
+
+
+def sigmax():
+    """Pauli spin 1/2 sigma-x operator
+
+    Examples
+    --------
+    >>> sigmax() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.  1.]
+     [ 1.  0.]]
+
+    """
+    return _SIGMAX.copy()
+
+
+def sigmay():
+    """Pauli spin 1/2 sigma-y operator.
+
+    Examples
+    --------
+    >>> sigmay() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j  0.-1.j]
+     [ 0.+1.j  0.+0.j]]
+
+    """
+    return _SIGMAY.copy()
+
+
+def sigmaz():
+    """Pauli spin 1/2 sigma-z operator.
+
+    Examples
+    --------
+    >>> sigmaz() # doctest: +SKIP
+    Quantum object: dims = [[2], [2]], \
+shape = [2, 2], type = oper, isHerm = True
+    Qobj data =
+    [[ 1.  0.]
+     [ 0. -1.]]
+
+    """
+    return _SIGMAZ.copy()
+
+
+def destroy(N, offset=0, *, dtype=None):
+    """
+    Destruction (lowering) operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for lowering operator.
+
+    Examples
+    --------
+    >>> destroy(4) # doctest: +SKIP
+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
+    Qobj data =
+    [[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
+        raise ValueError("Hilbert space dimension must be integer value")
+    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
+    return qdiags(data, 1, dtype=dtype)
+
+
+def create(N, offset=0, *, dtype=None):
+    """
+    Creation (raising) operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for raising operator.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    Examples
+    --------
+    >>> create(4) # doctest: +SKIP
+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
+    Qobj data =
+    [[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if not isinstance(N, (int, np.integer)):  # raise error if N not integer
+        raise ValueError("Hilbert space dimension must be integer value")
+    data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
+    return qdiags(data, -1, dtype=dtype)
+
+
+def _implicit_tensor_dimensions(dimensions):
+    """
+    Total flattened size and operator dimensions for operator creation routines
+    that automatically perform tensor products.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        First dimension of an operator which can create an implicit tensor
+        product.  If the type is `int`, it is promoted first to `[dimensions]`.
+        From there, it should be one of the two-elements `dims` parameter of a
+        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
+        products.
+
+    Returns
+    -------
+    size : int
+        Dimension of backing matrix required to represent operator.
+    dimensions : list
+        Dimension list in the form required by ``Qobj`` creation.
+    """
+    if not isinstance(dimensions, list):
+        dimensions = [dimensions]
+    flat = flatten(dimensions)
+    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
+        raise ValueError("All dimensions must be integers >= 0")
+    return np.prod(flat), [dimensions, dimensions]
+
+
+def qzero(dimensions, *, dtype=None):
+    """
+    Zero operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    qzero : qobj
+        Zero operator Qobj.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    size, dimensions = _implicit_tensor_dimensions(dimensions)
+    # A sparse matrix with no data is equal to a zero matrix.
+    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
+    return Qobj(_data.zeros[dtype](size, size), dims=dimensions, type=type_,
+                isherm=True, isunitary=False, copy=False)
+
+
+def qeye(dimensions, *, dtype=None):
+    """
+    Identity operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Identity operator Qobj.
+
+    Examples
+    --------
+    >>> qeye(3) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
+isherm = True
+    Qobj data =
+    [[ 1.  0.  0.]
+     [ 0.  1.  0.]
+     [ 0.  0.  1.]]
+    >>> qeye([2,2]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
+isherm = True
+    Qobj data =
+    [[1. 0. 0. 0.]
+     [0. 1. 0. 0.]
+     [0. 0. 1. 0.]
+     [0. 0. 0. 1.]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    size, dimensions = _implicit_tensor_dimensions(dimensions)
+    type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
+    return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
+                isherm=True, isunitary=True, copy=False)
+
+
+# Name alias.
+identity = qeye
+
+
+def position(N, offset=0, *, dtype=None):
+    """
+    Position operator x=1/sqrt(2)*(a+a.dag())
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Position operator as Qobj.
+    """
+    a = destroy(N, offset=offset, dtype=dtype)
+    position = np.sqrt(0.5) * (a + a.dag())
+    position.isherm = True
+    return position
+
+
+def momentum(N, offset=0, *, dtype=None):
+    """
+    Momentum operator p=-1j/sqrt(2)*(a-a.dag())
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Momentum operator as Qobj.
+    """
+    a = destroy(N, offset=offset, dtype=dtype)
+    momentum = -1j * np.sqrt(0.5) * (a - a.dag())
+    momentum.isherm = True
+    return momentum
+
+
+def num(N, offset=0, *, dtype=None):
+    """
+    Quantum object for number operator.
+
+    Parameters
+    ----------
+    N : int
+        The dimension of the Hilbert space.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper: qobj
+        Qobj for number operator.
+
+    Examples
+    --------
+    >>> num(4) # doctest: +SKIP
+    Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
+    Qobj data =
+    [[0 0 0 0]
+     [0 1 0 0]
+     [0 0 2 0]
+     [0 0 0 3]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    data = np.arange(offset, offset + N, dtype=complex)
+    return qdiags(data, 0, dtype=dtype)
+
+
+def squeeze(N, z, offset=0, *, dtype=None):
+    """Single-mode squeezing operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of hilbert space.
+
+    z : float/complex
+        Squeezing parameter.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : :class:`qutip.Qobj`
+        Squeezing operator.
+
+
+    Examples
+    --------
+    >>> squeeze(4, 0.25) # doctest: +SKIP
+    Quantum object: dims = [[4], [4]], \
+shape = [4, 4], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
+     [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
+     [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]
+
+    """
+    asq = destroy(N, offset=offset, dtype=dtype) ** 2
+    op = 0.5*np.conj(z)*asq - 0.5*z*asq.dag()
+    return op.expm(dtype=dtype)
+
+
+def squeezing(a1, a2, z):
+    """Generalized squeezing operator.
+
+    .. math::
+
+        S(z) = \\exp\\left(\\frac{1}{2}\\left(z^*a_1a_2
+        - za_1^\\dagger a_2^\\dagger\\right)\\right)
+
+    Parameters
+    ----------
+    a1 : :class:`qutip.Qobj`
+        Operator 1.
+
+    a2 : :class:`qutip.Qobj`
+        Operator 2.
+
+    z : float/complex
+        Squeezing parameter.
+
+    Returns
+    -------
+    oper : :class:`qutip.Qobj`
+        Squeezing operator.
+
+    """
+    b = 0.5 * (np.conj(z)*(a1 @ a2) - z*(a1.dag() @ a2.dag()))
+    return b.expm()
+
+
+def displace(N, alpha, offset=0, *, dtype=None):
+    """Single-mode displacement operator.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    alpha : float/complex
+        Displacement amplitude.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the operator.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Displacement operator.
+
+    Examples
+    --------
+    >>> displace(4,0.25) # doctest: +SKIP
+    Quantum object: dims = [[4], [4]], \
+shape = [4, 4], type = oper, isHerm = False
+    Qobj data =
+    [[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
+     [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
+     [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
+     [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    a = destroy(N, offset=offset)
+    return (alpha * a.dag() - np.conj(alpha) * a).expm(dtype=dtype)
+
+
+def commutator(A, B, kind="normal"):
+    """
+    Return the commutator of kind `kind` (normal, anti) of the
+    two operators A and B.
+    """
+    if kind == 'normal':
+        return A @ B - B @ A
+
+    elif kind == 'anti':
+        return A @ B + B @ A
+
+    else:
+        raise TypeError("Unknown commutator kind '%s'" % kind)
+
+
+def qutrit_ops(*, dtype=None):
+    """
+    Operators for a three level system (qutrit).
+
+    Parameters
+    ----------
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    opers: array
+        `array` of qutrit operators.
+
+    """
+    from .states import qutrit_basis
+
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    out = np.empty((6,), dtype=object)
+    one, two, three = qutrit_basis(dtype=dtype)
+    out[0] = one * one.dag()
+    out[1] = two * two.dag()
+    out[2] = three * three.dag()
+    out[3] = one * two.dag()
+    out[4] = two * three.dag()
+    out[5] = three * one.dag()
+    return out
+
+
+def phase(N, phi0=0, *, dtype=None):
+    """
+    Single-mode Pegg-Barnett phase operator.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    phi0 : float
+        Reference phase.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Phase operator with respect to reference phase.
+
+    Notes
+    -----
+    The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    phim = phi0 + (2 * np.pi * np.arange(N)) / N  # discrete phase angles
+    n = np.arange(N)[:, np.newaxis]
+    states = np.array([np.sqrt(kk) / np.sqrt(N) * np.exp(1j * n * kk)
+                       for kk in phim])
+    ops = np.sum([np.outer(st, st.conj()) for st in states], axis=0)
+    return Qobj(ops, dims=[[N], [N]], type='oper', copy=False).to(dtype)
+
+
+def enr_destroy(dims, excitations, *, dtype=None):
+    """
+    Generate annilation operators for modes in a excitation-number-restricted
+    state space. For example, consider a system consisting of 4 modes, each
+    with 5 states. The total hilbert space size is 5**4 = 625. If we are
+    only interested in states that contain up to 2 excitations, we only need
+    to include states such as
+
+        (0, 0, 0, 0)
+        (0, 0, 0, 1)
+        (0, 0, 0, 2)
+        (0, 0, 1, 0)
+        (0, 0, 1, 1)
+        (0, 0, 2, 0)
+        ...
+
+    This function creates annihilation operators for the 4 modes that act
+    within this state space:
+
+        a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
+
+    From this point onwards, the annihiltion operators a1, ..., a4 can be
+    used to setup a Hamiltonian, collapse operators and expectation-value
+    operators, etc., following the usual pattern.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    a_ops : list of qobj
+        A list of annihilation operators for each mode in the composite
+        quantum system described by dims.
+    """
+    from .states import enr_state_dictionaries
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+
+    nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
+
+    a_ops = [scipy.sparse.lil_matrix((nstates, nstates), dtype=np.complex128)
+             for _ in dims]
+
+    for n1, state1 in enumerate(idx2state):
+        for idx, s in enumerate(state1):
+            # if s > 0, the annihilation operator of mode idx has a non-zero
+            # entry with one less excitation in mode idx in the final state
+            if s > 0:
+                state2 = state1[:idx] + (s-1,) + state1[idx+1:]
+                n2 = state2idx[state2]
+                a_ops[idx][n2, n1] = np.sqrt(s)
+
+    return [Qobj(a, dims=[dims, dims]).to(dtype) for a in a_ops]
+
+
+def enr_identity(dims, excitations, *, dtype=None):
+    """
+    Generate the identity operator for the excitation-number restricted
+    state space defined by the `dims` and `exciations` arguments. See the
+    docstring for enr_fock for a more detailed description of these arguments.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    state : list of integers
+        The state in the number basis representation.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    op : Qobj
+        A Qobj instance that represent the identity operator in the
+        exication-number-restricted state space defined by `dims` and
+        `exciations`.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    from .states import enr_state_dictionaries
+    nstates, _, _ = enr_state_dictionaries(dims, excitations)
+    return Qobj(_data.identity[dtype](nstates),
+                dims=[dims, dims],
+                type='oper',
+                isherm=True,
+                isunitary=True,
+                copy=False)
+
+
+def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
+    """
+    Generate the diagonal charge operator over charge states
+    from Nmin to Nmax.
+
+    Parameters
+    ----------
+    Nmax : int
+        Maximum charge state to consider.
+
+    Nmin : int (default = -Nmax)
+        Lowest charge state to consider.
+
+    frac : float (default = 1)
+        Specify fractional charge if needed.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    C : Qobj
+        Charge operator over [Nmin, Nmax].
+
+    Notes
+    -----
+    .. versionadded:: 3.2
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if Nmin is None:
+        Nmin = -Nmax
+    diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
+    out = qdiags(diag, 0, dtype=dtype)
+    out.isherm = True
+    return out
+
+
+def tunneling(N, m=1, *, dtype=None):
+    r"""
+    Tunneling operator with elements of the form
+    :math:`\\sum |N><N+m| + |N+m><N|`.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    m : int (default = 1)
+        Number of excitations in tunneling event.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    T : Qobj
+        Tunneling operator.
+
+    Notes
+    -----
+    .. versionadded:: 3.2
+
+    """
+    diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)]
+    T = qdiags(diags, [m, -m], dtype=dtype)
+    T.isherm = True
+    return T
+
+
+def qft(dimensions, *, dtype="dense"):
+    """
+    Quantum Fourier Transform operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.
+
+    dtype : str or type, [keyword only] [optional]
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    QFT: qobj
+        Quantum Fourier transform operator.
+
+    """
+    N2, dimensions = _implicit_tensor_dimensions(dimensions)
+
+    phase = 2.0j * np.pi / N2
+    arr = np.arange(N2)
+    L, M = np.meshgrid(arr, arr)
+    data = np.exp(phase * (L * M)) / np.sqrt(N2)
+    return Qobj(data, dims=dimensions).to(dtype)
diff --git a/qutip/core/options.py b/qutip/core/options.py
index daa3db0b3b..1724c81890 100644
--- a/qutip/core/options.py
+++ b/qutip/core/options.py
@@ -1,123 +1,123 @@
-from ..settings import settings
-
-__all__ = ["CoreOptions"]
-
-
-class QutipOptions:
-    """
-    Class for basic functionality for qutip's options.
-
-    Define basic method to wrap an ``options`` dict.
-    Default options are in a class _options dict.
-    """
-    _options = {}
-    _settings_name = None  # Where the default is in settings
-
-    def __init__(self, **options):
-        self.options = self._options.copy()
-        for key in set(options) & set(self.options):
-            self[key] = options.pop(key)
-        if options:
-            raise KeyError(f"Options {set(options)} are not supported.")
-
-    def __contains__(self, key):
-        return key in self.options
-
-    def __getitem__(self, key):
-        # Let the dict catch the KeyError
-        return self.options[key]
-
-    def __setitem__(self, key, value):
-        # Let the dict catch the KeyError
-        self.options[key] = value
-
-    def __repr__(self, full=True):
-        out = [f"<{self.__class__.__name__}("]
-        for key, value in self.options.items():
-            if full or value != self._options[key]:
-                out += [f"    '{key}': {repr(value)},"]
-        out += [")>"]
-        if len(out)-2:
-            return "\n".join(out)
-        else:
-            return "".join(out)
-
-    def __enter__(self):
-        self._backup = getattr(settings, self._settings_name)
-        setattr(settings, self._settings_name, self)
-
-    def __exit__(self, exc_type, exc_value, exc_traceback):
-        setattr(settings, self._settings_name, self._backup)
-
-
-class CoreOptions(QutipOptions):
-    """
-    Options used by the core of qutip such as the tolerance of :class:`Qobj`
-    comparison or coefficient's format.
-
-    Values can be changed in ``qutip.settings.core`` or by using context:
-    ``with CoreOptions(atol=1e-6): ...``.
-
-    Options
-    -------
-    auto_tidyup : bool
-        Whether to tidyup during sparse operations.
-
-    auto_tidyup_dims : bool [True]
-        Use auto tidyup dims on multiplication. (Not used yet)
-
-    atol : float {1e-12}
-        General absolute tolerance
-
-    rtol : float {1e-12}
-        General relative tolerance
-        Used to choose QobjEvo.expect output type
-
-    auto_tidyup_atol : float {1e-14}
-        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
-        parameter above) and the default value of ``atol`` used in
-        :method:`Qobj.tidyup`.
-
-    function_coefficient_style : str {"auto"}
-        The signature expected by function coefficients. The options are:
-
-        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
-          is the time and the ``...`` are the remaining arguments passed
-          directly into the function. E.g. ``f(t, w, b=5)``.
-
-        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
-          the time and ``args`` is a dict containing the remaining arguments.
-          E.g. ``f(t, {"w": w, "b": 5})``.
-
-        - "auto": select automatically between the two options above based
-          on the signature of the supplied function. If the function signature
-          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
-          ``pythonic`` is used.
-
-    default_dtype : Nonetype, str, type {None}
-        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
-        :func:"rand_herm", will use the specified data type. Any data-layer
-        known to ``qutip.data.to`` is accepted. When ``None``, these functions
-        will default to a sensible data type.
-    """
-    _options = {
-        # use auto tidyup
-        "auto_tidyup": True,
-        # use auto tidyup dims on multiplication
-        "auto_tidyup_dims": True,
-        # general absolute tolerance
-        "atol": 1e-12,
-        # general relative tolerance
-        "rtol": 1e-12,
-        # use auto tidyup absolute tolerance
-        "auto_tidyup_atol": 1e-14,
-        # signature style expected by function coefficients
-        "function_coefficient_style": "auto",
-        # Default Qobj dtype for Qobj create function
-        "default_dtype": None,
-    }
-    _settings_name = "core"
-
-
-# Creating the instance of core options to use everywhere.
-settings.core = CoreOptions()
+from ..settings import settings
+
+__all__ = ["CoreOptions"]
+
+
+class QutipOptions:
+    """
+    Class for basic functionality for qutip's options.
+
+    Define basic method to wrap an ``options`` dict.
+    Default options are in a class _options dict.
+    """
+    _options = {}
+    _settings_name = None  # Where the default is in settings
+
+    def __init__(self, **options):
+        self.options = self._options.copy()
+        for key in set(options) & set(self.options):
+            self[key] = options.pop(key)
+        if options:
+            raise KeyError(f"Options {set(options)} are not supported.")
+
+    def __contains__(self, key):
+        return key in self.options
+
+    def __getitem__(self, key):
+        # Let the dict catch the KeyError
+        return self.options[key]
+
+    def __setitem__(self, key, value):
+        # Let the dict catch the KeyError
+        self.options[key] = value
+
+    def __repr__(self, full=True):
+        out = [f"<{self.__class__.__name__}("]
+        for key, value in self.options.items():
+            if full or value != self._options[key]:
+                out += [f"    '{key}': {repr(value)},"]
+        out += [")>"]
+        if len(out)-2:
+            return "\n".join(out)
+        else:
+            return "".join(out)
+
+    def __enter__(self):
+        self._backup = getattr(settings, self._settings_name)
+        setattr(settings, self._settings_name, self)
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        setattr(settings, self._settings_name, self._backup)
+
+
+class CoreOptions(QutipOptions):
+    """
+    Options used by the core of qutip such as the tolerance of :class:`Qobj`
+    comparison or coefficient's format.
+
+    Values can be changed in ``qutip.settings.core`` or by using context:
+    ``with CoreOptions(atol=1e-6): ...``.
+
+    Options
+    -------
+    auto_tidyup : bool
+        Whether to tidyup during sparse operations.
+
+    auto_tidyup_dims : bool [True]
+        Use auto tidyup dims on multiplication. (Not used yet)
+
+    atol : float {1e-12}
+        General absolute tolerance
+
+    rtol : float {1e-12}
+        General relative tolerance
+        Used to choose QobjEvo.expect output type
+
+    auto_tidyup_atol : float {1e-14}
+        The absolute tolerance used in automatic tidyup (see the ``auto_tidyup``
+        parameter above) and the default value of ``atol`` used in
+        :method:`Qobj.tidyup`.
+
+    function_coefficient_style : str {"auto"}
+        The signature expected by function coefficients. The options are:
+
+        - "pythonic": the signature should be ``f(t, ...)`` where ``t``
+          is the time and the ``...`` are the remaining arguments passed
+          directly into the function. E.g. ``f(t, w, b=5)``.
+
+        - "dict": the signature shoule be ``f(t, args)`` where ``t`` is
+          the time and ``args`` is a dict containing the remaining arguments.
+          E.g. ``f(t, {"w": w, "b": 5})``.
+
+        - "auto": select automatically between the two options above based
+          on the signature of the supplied function. If the function signature
+          is exactly ``f(t, args)`` then ``dict`` is used. Otherwise
+          ``pythonic`` is used.
+
+    default_dtype : Nonetype, str, type {None}
+        When set, functions creating :class:`Qobj`, such as :func:"qeye" or
+        :func:"rand_herm", will use the specified data type. Any data-layer
+        known to ``qutip.data.to`` is accepted. When ``None``, these functions
+        will default to a sensible data type.
+    """
+    _options = {
+        # use auto tidyup
+        "auto_tidyup": True,
+        # use auto tidyup dims on multiplication
+        "auto_tidyup_dims": True,
+        # general absolute tolerance
+        "atol": 1e-12,
+        # general relative tolerance
+        "rtol": 1e-12,
+        # use auto tidyup absolute tolerance
+        "auto_tidyup_atol": 1e-14,
+        # signature style expected by function coefficients
+        "function_coefficient_style": "auto",
+        # Default Qobj dtype for Qobj create function
+        "default_dtype": None,
+    }
+    _settings_name = "core"
+
+
+# Creating the instance of core options to use everywhere.
+settings.core = CoreOptions()
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index b6128d55cf..83a778b052 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -1,1811 +1,1811 @@
-"""The Quantum Object (Qobj) class, for representing quantum states and
-operators, and related functions.
-"""
-
-__all__ = [
-    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
-    'isherm', 'ptrace',
-]
-
-import functools
-import numbers
-import warnings
-
-import numpy as np
-import scipy.sparse
-
-from .. import __version__
-from ..settings import settings
-from . import data as _data
-from .dimensions import (
-    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
-)
-
-
-_ADJOINT_TYPE_LOOKUP = {
-    'oper': 'oper',
-    'super': 'super',
-    'ket': 'bra',
-    'bra': 'ket',
-    'operator-ket': 'operator-bra',
-    'operator-bra': 'operator-ket',
-}
-
-_MATMUL_TYPE_LOOKUP = {
-    ('oper', 'ket'): 'ket',
-    ('oper', 'oper'): 'oper',
-    ('ket', 'bra'): 'oper',
-    ('bra', 'oper'): 'bra',
-    ('super', 'super'): 'super',
-    ('super', 'operator-ket'): 'operator-ket',
-    ('operator-bra', 'super'): 'operator-bra',
-    ('operator-ket', 'operator-bra'): 'super',
-}
-
-_NORM_FUNCTION_LOOKUP = {
-    'tr': _data.norm.trace,
-    'one': _data.norm.one,
-    'max': _data.norm.max,
-    'fro': _data.norm.frobenius,
-    'l2': _data.norm.l2,
-}
-_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
-_NORM_ALLOWED_VECTOR = {'l2', 'max'}
-
-_CALL_ALLOWED = {
-    ('super', 'oper'),
-    ('super', 'ket'),
-    ('oper', 'ket'),
-}
-
-
-def isbra(x):
-    return isinstance(x, Qobj) and x.type == 'bra'
-
-
-def isket(x):
-    return isinstance(x, Qobj) and x.type == 'ket'
-
-
-def isoper(x):
-    return isinstance(x, Qobj) and x.type == 'oper'
-
-
-def isoperbra(x):
-    return isinstance(x, Qobj) and x.type == 'operator-bra'
-
-
-def isoperket(x):
-    return isinstance(x, Qobj) and x.type == 'operator-ket'
-
-
-def issuper(x):
-    return isinstance(x, Qobj) and x.type == 'super'
-
-
-def isherm(x):
-    return isinstance(x, Qobj) and x.isherm
-
-
-def _require_equal_type(method):
-    """
-    Decorate a binary Qobj method to ensure both operands are Qobj and of the
-    same type and dimensions.  Promote numeric scalar to identity matrices of
-    the same type and shape.
-    """
-    @functools.wraps(method)
-    def out(self, other):
-        if other == 0:
-            return method(self, other)
-        if (
-            self.type in ('oper', 'super')
-            and self.dims[0] == self.dims[1]
-            and isinstance(other, numbers.Number)
-        ):
-            scale = complex(other)
-            other = Qobj(_data.identity(self.shape[0], scale,
-                                        dtype=type(self.data)),
-                         dims=self.dims,
-                         type=self.type,
-                         superrep=self.superrep,
-                         isherm=(scale.imag == 0),
-                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
-                         copy=False)
-        if not isinstance(other, Qobj):
-            try:
-                other = Qobj(other, type=self.type)
-            except TypeError:
-                return NotImplemented
-        if self.dims != other.dims:
-            msg = (
-                "incompatible dimensions "
-                + repr(self.dims) + " and " + repr(other.dims)
-            )
-            raise ValueError(msg)
-        if self.type != other.type:
-            msg = "incompatible types " + self.type + " and " + other.type
-            raise ValueError(msg)
-        if self.superrep != other.superrep:
-            msg = (
-                "incompatible superoperator representations"
-                + self.superrep + " and " + other.superrep
-            )
-            raise ValueError(msg)
-        return method(self, other)
-    return out
-
-
-def _latex_real(x):
-    if not x:
-        return "0"
-    if not 0.001 <= abs(x) < 1000:
-        base, exp = "{:.3e}".format(x).split('e')
-        return base + r"\times10^{{ {:d} }}".format(int(exp))
-    if abs(x - int(x)) < 0.001:
-        return "{:d}".format(round(x))
-    return "{:.3f}".format(x)
-
-
-def _latex_complex(x):
-    if abs(x.imag) < 0.001:
-        return _latex_real(x.real)
-    if abs(x.real) < 0.001:
-        return _latex_real(x.imag) + "j"
-    sign = "+" if x.imag > 0 else "-"
-    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
-
-
-def _latex_row(row, cols, data):
-    if row is None:
-        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
-    else:
-        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
-                for col in cols)
-    return " & ".join(bits)
-
-
-class Qobj:
-    """
-    A class for representing quantum objects, such as quantum operators and
-    states.
-
-    The Qobj class is the QuTiP representation of quantum operators and state
-    vectors. This class also implements math operations +,-,* between Qobj
-    instances (and / by a C-number), as well as a collection of common
-    operator/state operations.  The Qobj constructor optionally takes a
-    dimension ``list`` and/or shape ``list`` as arguments.
-
-    Parameters
-    ----------
-    inpt: array_like
-        Data for vector/matrix representation of the quantum object.
-    dims: list
-        Dimensions of object used for tensor products.
-    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
-        The type of quantum object to be represented.
-    shape: list
-        Shape of underlying data structure (matrix shape).
-    copy: bool
-        Flag specifying whether Qobj should get a copy of the
-        input data, or use the original.
-
-
-    Attributes
-    ----------
-    data : array_like
-        Sparse matrix characterizing the quantum object.
-    dims : list
-        List of dimensions keeping track of the tensor structure.
-    shape : list
-        Shape of the underlying `data` array.
-    type : str
-        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
-        'operator-bra', or 'super'.
-    superrep : str
-        Representation used if `type` is 'super'. One of 'super'
-        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
-    isherm : bool
-        Indicates if quantum object represents Hermitian operator.
-    isunitary : bool
-        Indictaes if quantum object represents unitary operator.
-    iscp : bool
-        Indicates if the quantum object represents a map, and if that map is
-        completely positive (CP).
-    ishp : bool
-        Indicates if the quantum object represents a map, and if that map is
-        hermicity preserving (HP).
-    istp : bool
-        Indicates if the quantum object represents a map, and if that map is
-        trace preserving (TP).
-    iscptp : bool
-        Indicates if the quantum object represents a map that is completely
-        positive and trace preserving (CPTP).
-    isket : bool
-        Indicates if the quantum object represents a ket.
-    isbra : bool
-        Indicates if the quantum object represents a bra.
-    isoper : bool
-        Indicates if the quantum object represents an operator.
-    issuper : bool
-        Indicates if the quantum object represents a superoperator.
-    isoperket : bool
-        Indicates if the quantum object represents an operator in column vector
-        form.
-    isoperbra : bool
-        Indicates if the quantum object represents an operator in row vector
-        form.
-
-    Methods
-    -------
-    copy()
-        Create copy of Qobj
-    conj()
-        Conjugate of quantum object.
-    cosm()
-        Cosine of quantum object.
-    dag()
-        Adjoint (dagger) of quantum object.
-    dnorm()
-        Diamond norm of quantum operator.
-    dual_chan()
-        Dual channel of quantum object representing a CP map.
-    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
-        Returns eigenenergies (eigenvalues) of a quantum object.
-    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
-        Returns eigenenergies and eigenstates of quantum object.
-    expm()
-        Matrix exponential of quantum object.
-    full(order='C')
-        Returns dense array of quantum object `data` attribute.
-    groundstate(sparse=False, tol=0, maxiter=100000)
-        Returns eigenvalue and eigenket for the groundstate of a quantum
-        object.
-    inv()
-        Return a Qobj corresponding to the matrix inverse of the operator.
-    matrix_element(bra, ket)
-        Returns the matrix element of operator between `bra` and `ket` vectors.
-    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
-        Returns norm of a ket or an operator.
-    permute(order)
-        Returns composite qobj with indices reordered.
-    proj()
-        Computes the projector for a ket or bra vector.
-    ptrace(sel)
-        Returns quantum object for selected dimensions after performing
-        partial trace.
-    sinm()
-        Sine of quantum object.
-    sqrtm()
-        Matrix square root of quantum object.
-    tidyup(atol=1e-12)
-        Removes small elements from quantum object.
-    tr()
-        Trace of quantum object.
-    trans()
-        Transpose of quantum object.
-    transform(inpt, inverse=False)
-        Performs a basis transformation defined by `inpt` matrix.
-    trunc_neg(method='clip')
-        Removes negative eigenvalues and returns a new Qobj that is
-        a valid density operator.
-    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
-        Returns normalized quantum object.
-
-    """
-    # Disable ufuncs from acting directly on Qobj.
-    __array_ufunc__ = None
-
-    def _initialize_data(self, arg, dims, copy):
-        if isinstance(arg, _data.Data):
-            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
-            self._data = arg.copy() if copy else arg
-        elif isinstance(arg, Qobj):
-            self.dims = dims or arg.dims.copy()
-            self._data = arg.data.copy() if copy else arg.data
-        elif arg is None or isinstance(arg, numbers.Number):
-            self.dims = dims or [[1], [1]]
-            size = np.prod(self.dims[0])
-            if arg is None:
-                self._data = _data.zeros(size, size)
-            else:
-                self._data = _data.identity(size, scale=complex(arg))
-        else:
-            self._data = _data.create(arg, copy=copy)
-            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
-
-    def __init__(self, arg=None, dims=None, type=None,
-                 copy=True, superrep=None, isherm=None, isunitary=None):
-        self._initialize_data(arg, dims, copy)
-        self.type = type or type_from_dims(self.dims)
-        self._isherm = isherm
-        self._isunitary = isunitary
-
-        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
-            if self._data.shape[0] != self._data.shape[1]:
-                raise ValueError("".join([
-                    "cannot build superoperator from nonsquare data of shape ",
-                    repr(self._data.shape),
-                ]))
-            root = int(np.sqrt(self._data.shape[0]))
-            if root * root != self._data.shape[0]:
-                raise ValueError("".join([
-                    "cannot build superoperator from nonsquare subspaces ",
-                    "of size ",
-                    repr(self._data.shape[0]),
-                ]))
-            self.dims = [[[root]]*2]*2
-        if self.type in ['super', 'operator-ket', 'operator-bra']:
-            superrep = superrep or 'super'
-        self.superrep = superrep
-
-    def copy(self):
-        """Create identical copy"""
-        return Qobj(arg=self._data,
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=True)
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        if not isinstance(data, _data.Data):
-            raise TypeError('Qobj data must be a data-layer format.')
-        self._data = data
-
-    def to(self, data_type):
-        """
-        Convert the underlying data store of this `Qobj` into a different
-        storage representation.
-
-        The different storage representations available are the "data-layer
-        types" which are known to `qutip.data.to`.  By default, these are
-        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
-        dense matrix store and a compressed sparse row one.  Certain algorithms
-        and operations may be faster or more accurate when using a more
-        appropriate data store.
-
-        If the data store is already in the format requested, the function
-        returns `self`.  Otherwise, it returns a copy of itself with the data
-        store in the new type.
-
-        Parameters
-        ----------
-        data_type : type
-            The data-layer type that the data of this `Qobj` should be
-            converted to.
-
-        Returns
-        -------
-        Qobj
-            A new `Qobj` if a type conversion took place with the data stored
-            in the requested format, or `self` if not.
-        """
-        try:
-            converter = _data.to[data_type]
-        except (KeyError, TypeError):
-            raise ValueError("Unknown conversion type: " + str(data_type))
-        if type(self.data) is data_type:
-            return self
-        return Qobj(converter(self._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    @_require_equal_type
-    def __add__(self, other):
-        if other == 0:
-            return self.copy()
-        isherm = (self._isherm and other._isherm) or None
-        return Qobj(_data.add(self._data, other._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=isherm,
-                    copy=False)
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    @_require_equal_type
-    def __sub__(self, other):
-        if other == 0:
-            return self.copy()
-        isherm = (self._isherm and other._isherm) or None
-        return Qobj(_data.sub(self._data, other._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=isherm,
-                    copy=False)
-
-    def __rsub__(self, other):
-        return self.__neg__().__add__(other)
-
-    def __mul__(self, other):
-        """
-        If other is a Qobj, we dispatch to __matmul__. If not, we
-        check that other is a valid complex scalar, i.e., we can do
-        complex(other). Otherwise, we return NotImplemented.
-        """
-
-        if isinstance(other, Qobj):
-            return self.__matmul__(other)
-
-        # We send other to mul instead of complex(other) to be more flexible.
-        # The dispatcher can then decide how to handle other and return
-        # TypeError if it does not know what to do with the type of other.
-        try:
-            out = _data.mul(self._data, other)
-        except TypeError:
-            return NotImplemented
-
-        # Infer isherm and isunitary if possible
-        try:
-            multiplier = complex(other)
-            isherm = (self._isherm and multiplier.imag == 0) or None
-            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
-                         if self._isunitary else None)
-        except TypeError:
-            isherm = None
-            isunitary = None
-
-        return Qobj(out,
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=isherm,
-                    isunitary=isunitary,
-                    copy=False)
-
-    def __rmul__(self, other):
-        # Shouldn't be here unless `other.__mul__` has already been tried, so
-        # we _shouldn't_ check that `other` is `Qobj`.
-        return self.__mul__(other)
-
-    def __matmul__(self, other):
-        if not isinstance(other, Qobj):
-            try:
-                other = Qobj(other)
-            except TypeError:
-                return NotImplemented
-        if self.dims[1] != other.dims[0]:
-            raise TypeError("".join([
-                "incompatible dimensions ",
-                repr(self.dims),
-                " and ",
-                repr(other.dims),
-            ]))
-        if self.superrep != other.superrep:
-            raise TypeError("".join([
-                "incompatible superoperator representations ",
-                repr(self.superrep),
-                " and ",
-                repr(other.superrep),
-            ]))
-        if (
-            (self.isbra and other.isket)
-            or (self.isoperbra and other.isoperket)
-        ):
-            return _data.inner(self.data, other.data)
-
-        try:
-            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
-        except KeyError:
-            raise TypeError(
-                "incompatible matmul types "
-                + repr(self.type) + " and " + repr(other.type)
-            ) from None
-        return Qobj(_data.matmul(self.data, other.data),
-                    dims=[self.dims[0], other.dims[1]],
-                    type=type_,
-                    isunitary=self._isunitary and other._isunitary,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def __truediv__(self, other):
-        return self.__mul__(1 / other)
-
-    def __neg__(self):
-        return Qobj(_data.neg(self._data),
-                    dims=self.dims.copy(),
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def __getitem__(self, ind):
-        # TODO: should we require that data-layer types implement this?  This
-        # isn't the right way of handling it, for sure.
-        if isinstance(self._data, _data.CSR):
-            data = self._data.as_scipy()
-        elif isinstance(self._data, _data.Dense):
-            data = self._data.as_ndarray()
-        else:
-            data = self._data
-        try:
-            out = data[ind]
-            return out.toarray() if scipy.sparse.issparse(out) else out
-        except TypeError:
-            pass
-        return data.to_array()[ind]
-
-    def __eq__(self, other):
-        if self is other:
-            return True
-        if not isinstance(other, Qobj) or self.dims != other.dims:
-            return False
-        return _data.iszero(_data.sub(self._data, other._data),
-                            tol=settings.core['atol'])
-
-    def __pow__(self, n, m=None):  # calculates powers of Qobj
-        if (
-            self.type not in ('oper', 'super')
-            or self.dims[0] != self.dims[1]
-            or m is not None
-            or not isinstance(n, numbers.Integral)
-            or n < 0
-        ):
-            return NotImplemented
-        return Qobj(_data.pow(self._data, n),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def _str_header(self):
-        out = ", ".join([
-            "Quantum object: dims=" + str(self.dims),
-            "shape=" + str(self.data.shape),
-            "type=" + repr(self.type),
-        ])
-        if self.type in ('oper', 'super'):
-            out += ", isherm=" + str(self.isherm)
-        if self.issuper and self.superrep != 'super':
-            out += ", superrep=" + repr(self.superrep)
-        return out
-
-    def __str__(self):
-        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
-            # If the system is huge, don't attempt to convert to a dense matrix
-            # and then to string, because it is pointless and is likely going
-            # to produce memory errors. Instead print the sparse data string
-            # representation.
-            data = _data.to(_data.CSR, self.data).as_scipy()
-        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
-            data = np.real(self.full())
-        else:
-            data = self.full()
-        return self._str_header() + "\nQobj data =\n" + str(data)
-
-    def __repr__(self):
-        # give complete information on Qobj without print statement in
-        # command-line we cant realistically serialize a Qobj into a string,
-        # so we simply return the informal __str__ representation instead.)
-        return self.__str__()
-
-    def __call__(self, other):
-        """
-        Acts this Qobj on another Qobj either by left-multiplication,
-        or by vectorization and devectorization, as
-        appropriate.
-        """
-        if not isinstance(other, Qobj):
-            raise TypeError("Only defined for quantum objects.")
-        if (self.type, other.type) not in _CALL_ALLOWED:
-            raise TypeError(self.type + " cannot act on " + other.type)
-        if self.issuper:
-            if other.isket:
-                other = other.proj()
-            return vector_to_operator(self @ operator_to_vector(other))
-        return self.__matmul__(other)
-
-    def __getstate__(self):
-        # defines what happens when Qobj object gets pickled
-        self.__dict__.update({'qutip_version': __version__[:5]})
-        return self.__dict__
-
-    def __setstate__(self, state):
-        # defines what happens when loading a pickled Qobj
-        if 'qutip_version' in state.keys():
-            del state['qutip_version']
-        (self.__dict__).update(state)
-
-    def _repr_latex_(self):
-        """
-        Generate a LaTeX representation of the Qobj instance. Can be used for
-        formatted output in ipython notebook.
-        """
-        half_length = 5
-        n_rows, n_cols = self.data.shape
-        # Choose which rows and columns we're going to output, or None if that
-        # element should be truncated.
-        rows = list(range(min((half_length, n_rows))))
-        if n_rows <= half_length * 2:
-            rows += list(range(half_length, min((2*half_length, n_rows))))
-        else:
-            rows.append(None)
-            rows += list(range(n_rows - half_length, n_rows))
-        cols = list(range(min((half_length, n_cols))))
-        if n_cols <= half_length * 2:
-            cols += list(range(half_length, min((2*half_length, n_cols))))
-        else:
-            cols.append(None)
-            cols += list(range(n_cols - half_length, n_cols))
-        # Make the data array.
-        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
-        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
-                           for row in rows)
-        data += r'\end{array}\right)\end{equation*}'
-        return self._str_header() + data
-
-    def __and__(self, other):
-        """
-        Syntax shortcut for tensor:
-        A & B ==> tensor(A, B)
-        """
-        return tensor(self, other)
-
-    def dag(self):
-        """Get the Hermitian adjoint of the quantum object."""
-        if self._isherm:
-            return self.copy()
-        return Qobj(_data.adjoint(self._data),
-                    dims=[self.dims[1], self.dims[0]],
-                    type=_ADJOINT_TYPE_LOOKUP[self.type],
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def conj(self):
-        """Get the element-wise conjugation of the quantum object."""
-        return Qobj(_data.conj(self._data),
-                    dims=self.dims.copy(),
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def trans(self):
-        """Get the matrix transpose of the quantum operator.
-
-        Returns
-        -------
-        oper : :class:`.Qobj`
-            Transpose of input operator.
-        """
-        return Qobj(_data.transpose(self._data),
-                    dims=[self.dims[1], self.dims[0]],
-                    type=_ADJOINT_TYPE_LOOKUP[self.type],
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    isunitary=self._isunitary,
-                    copy=False)
-
-    def dual_chan(self):
-        """Dual channel of quantum object representing a completely positive
-        map.
-        """
-        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
-        # is only valid for completely positive maps.
-        if not self.iscp:
-            raise ValueError("Dual channels are only implemented for CP maps.")
-        J = to_choi(self)
-        tensor_idxs = enumerate_flat(J.dims)
-        J_dual = tensor_swap(J, *(
-                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
-                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
-        )).trans()
-        J_dual.superrep = 'choi'
-        return J_dual
-
-    def norm(self, norm=None, kwargs=None):
-        """
-        Norm of a quantum object.
-
-        Default norm is L2-norm for kets and trace-norm for operators.  Other
-        ket and operator norms may be specified using the `norm` parameter.
-
-        Parameters
-        ----------
-        norm : str
-            Which type of norm to use.  Allowed values for vectors are 'l2' and
-            'max'.  Allowed values for matrices are 'tr' for the trace norm,
-            'fro' for the Frobenius norm, 'one' and 'max'.
-
-        kwargs : dict
-            Additional keyword arguments to pass on to the relevant norm
-            solver.  See details for each norm function in :mod:`.data.norm`.
-
-        Returns
-        -------
-        norm : float
-            The requested norm of the operator or state quantum object.
-        """
-        if self.type in ('oper', 'super'):
-            norm = norm or 'tr'
-            if norm not in _NORM_ALLOWED_MATRIX:
-                raise ValueError(
-                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
-                )
-        else:
-            norm = norm or 'l2'
-            if norm not in _NORM_ALLOWED_VECTOR:
-                raise ValueError(
-                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
-                )
-        kwargs = kwargs or {}
-        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
-
-    def proj(self):
-        """Form the projector from a given ket or bra vector.
-
-        Parameters
-        ----------
-        Q : :class:`qutip.Qobj`
-            Input bra or ket vector
-
-        Returns
-        -------
-        P : :class:`qutip.Qobj`
-            Projection operator.
-        """
-        if not (self.isket or self.isbra):
-            raise TypeError("projection is only defined for bras and kets")
-        dims = ([self.dims[0], self.dims[0]] if self.isket
-                else [self.dims[1], self.dims[1]])
-        return Qobj(_data.project(self._data),
-                    dims=dims,
-                    type='oper',
-                    isherm=True,
-                    copy=False)
-
-    def tr(self):
-        """Trace of a quantum object.
-
-        Returns
-        -------
-        trace : float
-            Returns the trace of the quantum object.
-
-        """
-        out = _data.trace(self._data)
-        # This ensures that trace can return something that is not a number such
-        # as a `tensorflow.Tensor` in qutip-tensorflow.
-        return out.real if (self.isherm
-                        and hasattr(out, "real")
-                        ) else out
-
-    def purity(self):
-        """Calculate purity of a quantum object.
-
-        Returns
-        -------
-        state_purity : float
-            Returns the purity of a quantum object.
-            For a pure state, the purity is 1.
-            For a mixed state of dimension `d`, 1/d<=purity<1.
-
-        """
-        if self.type in ("super", "operator-ket", "operator-bra"):
-            raise TypeError('purity is only defined for states.')
-        if self.isket or self.isbra:
-            return _data.norm.l2(self.data)**2
-        return _data.trace(_data.matmul(self.data, self.data)).real
-
-    def full(self, order='C', squeeze=False):
-        """Dense array from quantum object.
-
-        Parameters
-        ----------
-        order : str {'C', 'F'}
-            Return array in C (default) or Fortran ordering.
-        squeeze : bool {False, True}
-            Squeeze output array.
-
-        Returns
-        -------
-        data : array
-            Array of complex data from quantum objects `data` attribute.
-        """
-        out = np.asarray(self.data.to_array(), order=order)
-        return out.squeeze() if squeeze else out
-
-    def diag(self):
-        """Diagonal elements of quantum object.
-
-        Returns
-        -------
-        diags : array
-            Returns array of ``real`` values if operators is Hermitian,
-            otherwise ``complex`` values are returned.
-        """
-        # TODO: add a `diagonal` method to the data layer?
-        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
-        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
-            return out
-        else:
-            return np.real(out)
-
-    def expm(self, dtype=_data.Dense):
-        """Matrix exponential of quantum operator.
-
-        Input operator must be square.
-
-        Parameters
-        ----------
-        dtype : type
-            The data-layer type that should be output.  As the matrix
-            exponential is almost dense, this defaults to outputting dense
-            matrices.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Exponentiated quantum operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum operator is not square.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError("expm is only valid for square operators")
-        return Qobj(_data.expm(self._data, dtype=dtype),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    copy=False)
-
-    def logm(self):
-        """Matrix logarithm of quantum operator.
-
-        Input operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Logarithm of the quantum operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum operator is not square.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError("expm is only valid for square operators")
-        return Qobj(_data.logm(self._data),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    isherm=self._isherm,
-                    copy=False)
-
-    def check_herm(self):
-        """Check if the quantum object is hermitian.
-
-        Returns
-        -------
-        isherm : bool
-            Returns the new value of isherm property.
-        """
-        self._isherm = None
-        return self.isherm
-
-    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
-        """
-        Sqrt of a quantum operator.  Operator must be square.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse eigenvalue/vector solver.
-        tol : float
-            Tolerance used by sparse solver (0 = machine precision).
-        maxiter : int
-            Maximum number of iterations used by sparse solver.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix square root of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError('sqrt only valid on square matrices')
-        if isinstance(self.data, _data.CSR) and sparse:
-            evals, evecs = _data.eigs_csr(self.data,
-                                          isherm=self._isherm,
-                                          tol=tol, maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
-            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
-                                      isherm=self._isherm)
-        else:
-            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
-
-        numevals = len(evals)
-        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
-        if self.isherm:
-            spDv = _data.matmul(dV, evecs.conj().transpose())
-        else:
-            spDv = _data.matmul(dV, _data.inv(evecs))
-        return Qobj(_data.matmul(evecs, spDv),
-                    dims=self.dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def cosm(self):
-        """Cosine of a quantum operator.
-
-        Operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix cosine of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-
-        Notes
-        -----
-        Uses the Q.expm() method.
-
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError('invalid operand for matrix cosine')
-        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
-
-    def sinm(self):
-        """Sine of a quantum operator.
-
-        Operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix sine of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-
-        Notes
-        -----
-        Uses the Q.expm() method.
-        """
-        if self.dims[0] != self.dims[1]:
-            raise TypeError('invalid operand for matrix sine')
-        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
-
-    def inv(self, sparse=False):
-        """Matrix inverse of a quantum operator
-
-        Operator must be square.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Matrix inverse of operator.
-
-        Raises
-        ------
-        TypeError
-            Quantum object is not square.
-        """
-        if self.data.shape[0] != self.data.shape[1]:
-            raise TypeError('Invalid operand for matrix inverse')
-        if isinstance(self.data, _data.CSR) and not sparse:
-            data = _data.to(_data.Dense, self.data)
-        else:
-            data = self.data
-
-        return Qobj(_data.inv(data),
-                    dims=[self.dims[1], self.dims[0]],
-                    type=self.type,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def unit(self, inplace=False, norm=None, kwargs=None):
-        """
-        Operator or state normalized to unity.  Uses norm from Qobj.norm().
-
-        Parameters
-        ----------
-        inplace : bool
-            Do an in-place normalization
-        norm : str
-            Requested norm for states / operators.
-        kwargs : dict
-            Additional key-word arguments to be passed on to the relevant norm
-            function (see :meth:`.norm` for more details).
-
-        Returns
-        -------
-        obj : :class:`qutip.Qobj`
-            Normalized quantum object.  Will be the `self` object if in place.
-        """
-        norm = self.norm(norm=norm, kwargs=kwargs)
-        if inplace:
-            self.data = _data.mul(self.data, 1 / norm)
-            self._isherm = self._isherm if norm.imag == 0 else None
-            self._isunitary = (self._isunitary
-                               if abs(norm) - 1 < settings.core['atol']
-                               else None)
-            out = self
-        else:
-            out = self / norm
-        return out
-
-    def ptrace(self, sel, dtype=None):
-        """
-        Take the partial trace of the quantum object leaving the selected
-        subspaces.  In other words, trace out all subspaces which are _not_
-        passed.
-
-        This is typically a function which acts on operators; bras and kets
-        will be promoted to density matrices before the operation takes place
-        since the partial trace is inherently undefined on pure states.
-
-        For operators which are currently being represented as states in the
-        superoperator formalism (i.e. the object has type `operator-ket` or
-        `operator-bra`), the partial trace is applied as if the operator were
-        in the conventional form.  This means that for any operator `x`,
-        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
-        and similar for `operator-bra`.
-
-        The story is different for full superoperators.  In the formalism that
-        QuTiP uses, if an operator has dimensions (`dims`) of
-        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
-        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
-        operator which acts on this joint space.  This function performs the
-        partial trace on superoperators by letting the selected components
-        refer to elements of the _joint_ _space_, and then returns a regular
-        operator (of type `oper`).
-
-        Parameters
-        ----------
-        sel : int or iterable of int
-            An ``int`` or ``list`` of components to keep after partial trace.
-            The selected subspaces will _not_ be reordered, no matter order
-            they are supplied to `ptrace`.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Quantum object representing partial trace with selected components
-            remaining.
-        """
-        try:
-            sel = sorted(sel)
-        except TypeError:
-            if not isinstance(sel, numbers.Integral):
-                raise TypeError(
-                    "selection must be an integer or list of integers"
-                ) from None
-            sel = [sel]
-        if self.isoperket:
-            dims = self.dims[0]
-            data = vector_to_operator(self).data
-        elif self.isoperbra:
-            dims = self.dims[1]
-            data = vector_to_operator(self.dag()).data
-        elif self.issuper or self.isoper:
-            dims = self.dims
-            data = self.data
-        else:
-            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
-            data = _data.project(self.data)
-        if dims[0] != dims[1]:
-            raise ValueError("partial trace is not defined on non-square maps")
-        dims = flatten(dims[0])
-        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
-        new_dims = [[dims[x] for x in sel]] * 2
-        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
-        if self.isoperket:
-            return operator_to_vector(out)
-        if self.isoperbra:
-            return operator_to_vector(out).dag()
-        return out
-
-    def contract(self, inplace=False):
-        """
-        Contract subspaces of the tensor structure which are 1D.  Not defined
-        on superoperators.  If all dimensions are scalar, a Qobj of dimension
-        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
-        contracted, but one is left.
-
-        Parameters
-        ----------
-        inplace: bool, optional
-            If ``True``, modify the dimensions in place.  If ``False``, return
-            a copied object.
-
-        Returns
-        -------
-        out: :class:`.Qobj`
-            Quantum object with dimensions contracted.  Will be ``self`` if
-            ``inplace`` is ``True``.
-        """
-        if self.isket:
-            sub = [x for x in self.dims[0] if x > 1] or [1]
-            dims = [sub, [1]*len(sub)]
-        elif self.isbra:
-            sub = [x for x in self.dims[1] if x > 1] or [1]
-            dims = [[1]*len(sub), sub]
-        elif self.isoper or self.isoperket or self.isoperbra:
-            if self.isoper:
-                oper_dims = self.dims
-            elif self.isoperket:
-                oper_dims = self.dims[0]
-            else:
-                oper_dims = self.dims[1]
-            if len(oper_dims[0]) != len(oper_dims[1]):
-                raise ValueError("cannot parse Qobj dimensions: "
-                                 + repr(self.dims))
-            dims_ = [
-                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
-                if x > 1 or y > 1
-            ] or [(1, 1)]
-            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
-            if self.isoperket:
-                dims = [dims, [1]]
-            elif self.isoperbra:
-                dims = [[1], dims]
-        else:
-            raise TypeError("not defined for superoperators")
-        if inplace:
-            self.dims = dims
-            return self
-        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
-
-    def permute(self, order):
-        """
-        Permute the tensor structure of a quantum object.  For example,
-        ``qutip.tensor(x, y).permute([1, 0])``
-        will give the same result as
-        ``qutip.tensor(y, x)``
-        and
-        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
-        will be the same as
-        ``qutip.tensor(b, c, a)``
-
-        For regular objects (bras, kets and operators) we expect ``order`` to
-        be a flat list of integers, which specifies the new order of the tensor
-        product.
-
-        For superoperators, we expect ``order`` to be something like
-        ``[[0, 2], [1, 3]]``
-        which tells us to permute according to [0, 2, 1, 3], and then group
-        indices according to the length of each sublist.  As another example,
-        permuting a superoperator with dimensions of
-        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
-        by an ``order``
-        ``[[0, 3], [1, 4], [2, 5]]``
-        should give a new object with dimensions
-        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
-
-        Parameters
-        ----------
-        order : list
-            List of indices specifying the new tensor order.
-
-        Returns
-        -------
-        P : :class:`qutip.Qobj`
-            Permuted quantum object.
-        """
-        if self.type in ('bra', 'ket', 'oper'):
-            structure = self.dims[1] if self.isbra else self.dims[0]
-            new_structure = [structure[x] for x in order]
-            if self.isbra:
-                dims = [self.dims[0], new_structure]
-            elif self.isket:
-                dims = [new_structure, self.dims[1]]
-            else:
-                if self.dims[0] != self.dims[1]:
-                    raise TypeError("undefined for non-square operators")
-                dims = [new_structure, new_structure]
-            data = _data.permute.dimensions(self.data, structure, order)
-            return Qobj(data,
-                        dims=dims,
-                        type=self.type,
-                        isherm=self._isherm,
-                        isunitary=self._isunitary,
-                        copy=False)
-        # If we've got here, we're some form of superoperator, so we work with
-        # the flattened structure.
-        flat_order = flatten(order)
-        flat_structure = flatten(self.dims[1] if self.isoperbra
-                                 else self.dims[0])
-        new_structure = unflatten([flat_structure[x] for x in flat_order],
-                                  enumerate_flat(order))
-        if self.isoperbra:
-            dims = [self.dims[0], new_structure]
-        elif self.isoperket:
-            dims = [new_structure, self.dims[1]]
-        else:
-            if self.dims[0] != self.dims[1]:
-                raise TypeError("undefined for non-square operators")
-            dims = [new_structure, new_structure]
-        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
-        return Qobj(data,
-                    dims=dims,
-                    type=self.type,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def tidyup(self, atol=None):
-        """
-        Removes small elements from the quantum object.
-
-        Parameters
-        ----------
-        atol : float
-            Absolute tolerance used by tidyup. Default is set
-            via qutip global settings parameters.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Quantum object with small elements removed.
-        """
-        atol = atol or settings.core['auto_tidyup_atol']
-        self.data = _data.tidyup(self.data, atol)
-        return self
-
-    def transform(self, inpt, inverse=False):
-        """Basis transform defined by input array.
-
-        Input array can be a ``matrix`` defining the transformation,
-        or a ``list`` of kets that defines the new basis.
-
-        Parameters
-        ----------
-        inpt : array_like
-            A ``matrix`` or ``list`` of kets defining the transformation.
-        inverse : bool
-            Whether to return inverse transformation.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            Operator in new basis.
-
-        Notes
-        -----
-        This function is still in development.
-        """
-        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
-                                      inpt.ndim == 1):
-            if len(inpt) != max(self.shape):
-                raise TypeError(
-                    'Invalid size of ket list for basis transformation')
-            base = np.hstack([psi.full() for psi in inpt])
-            S = _data.adjoint(_data.create(base))
-        elif isinstance(inpt, Qobj) and inpt.isoper:
-            S = inpt.data
-        elif isinstance(inpt, np.ndarray):
-            S = _data.create(inpt).conj()
-        else:
-            raise TypeError('Invalid operand for basis transformation')
-
-        # transform data
-        if inverse:
-            if self.isket:
-                data = _data.matmul(S.adjoint(), self.data)
-            elif self.isbra:
-                data = _data.matmul(self.data, S)
-            else:
-                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
-        else:
-            if self.isket:
-                data = _data.matmul(S, self.data)
-            elif self.isbra:
-                data = _data.matmul(self.data, S.adjoint())
-            else:
-                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
-        return Qobj(data,
-                    dims=self.dims,
-                    type=self.type,
-                    isherm=self._isherm,
-                    superrep=self.superrep,
-                    copy=False)
-
-    def trunc_neg(self, method="clip"):
-        """Truncates negative eigenvalues and renormalizes.
-
-        Returns a new Qobj by removing the negative eigenvalues
-        of this instance, then renormalizing to obtain a valid density
-        operator.
-
-
-        Parameters
-        ----------
-        method : str
-            Algorithm to use to remove negative eigenvalues. "clip"
-            simply discards negative eigenvalues, then renormalizes.
-            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
-            positive operator that is nearest in the Shatten 2-norm.
-
-        Returns
-        -------
-        oper : :class:`qutip.Qobj`
-            A valid density operator.
-        """
-        if not self.isherm:
-            raise ValueError("Must be a Hermitian operator to remove negative "
-                             "eigenvalues.")
-        if method not in ('clip', 'sgs'):
-            raise ValueError("Method {} not recognized.".format(method))
-
-        eigvals, eigstates = self.eigenstates()
-        if all(eigval >= 0 for eigval in eigvals):
-            # All positive, so just renormalize.
-            return self.unit()
-        idx_nonzero = eigvals != 0
-        eigvals = eigvals[idx_nonzero]
-        eigstates = eigstates[idx_nonzero]
-
-        if method == 'clip':
-            eigvals[eigvals < 0] = 0
-        elif method == 'sgs':
-            eigvals = eigvals[::-1]
-            eigstates = eigstates[::-1]
-            acc = 0.0
-            n_eigs = len(eigvals)
-            for idx in reversed(range(n_eigs)):
-                if eigvals[idx] + acc / (idx + 1) >= 0:
-                    break
-                acc += eigvals[idx]
-                eigvals[idx] = 0.0
-            eigvals[:idx+1] += acc / (idx + 1)
-        out_data = _data.zeros(*self.shape)
-        for value, state in zip(eigvals, eigstates):
-            if value:
-                # add in 3-argument form is fused-add-multiply
-                out_data = _data.add(out_data,
-                                     _data.project(state.data),
-                                     value)
-        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
-        return Qobj(out_data,
-                    dims=self.dims.copy(),
-                    type=self.type,
-                    isherm=True,
-                    copy=False)
-
-    def matrix_element(self, bra, ket):
-        """Calculates a matrix element.
-
-        Gives the matrix element for the quantum object sandwiched between a
-        `bra` and `ket` vector.
-
-        Parameters
-        ----------
-        bra : :class:`qutip.Qobj`
-            Quantum object of type 'bra' or 'ket'
-
-        ket : :class:`qutip.Qobj`
-            Quantum object of type 'ket'.
-
-        Returns
-        -------
-        elem : complex
-            Complex valued matrix element.
-
-        Notes
-        -----
-        It is slightly more computationally efficient to use a ket
-        vector for the 'bra' input.
-
-        """
-        if not self.isoper:
-            raise TypeError("Can only get matrix elements for an operator.")
-        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
-            msg = "Can only calculate matrix elements between a bra and a ket."
-            raise TypeError(msg)
-        left, op, right = bra.data, self.data, ket.data
-        if ket.isbra:
-            right = right.adjoint()
-        return _data.inner_op(left, op, right, bra.isket)
-
-    def overlap(self, other):
-        """
-        Overlap between two state vectors or two operators.
-
-        Gives the overlap (inner product) between the current bra or ket Qobj
-        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
-        when one of the Qobj is an operator/density matrix.
-
-        Parameters
-        ----------
-        other : :class:`qutip.Qobj`
-            Quantum object for a state vector of type 'ket', 'bra' or density
-            matrix.
-
-        Returns
-        -------
-        overlap : complex
-            Complex valued overlap.
-
-        Raises
-        ------
-        TypeError
-            Can only calculate overlap between a bra, ket and density matrix
-            quantum objects.
-        """
-        if not isinstance(other, Qobj):
-            raise TypeError("".join([
-                "cannot calculate overlap with non-quantum object ",
-                repr(other),
-            ]))
-        if (
-            self.type not in ('ket', 'bra', 'oper')
-            or other.type not in ('ket', 'bra', 'oper')
-        ):
-            msg = "only bras, kets and density matrices have defined overlaps"
-            raise TypeError(msg)
-        left, right = self._data.adjoint(), other.data
-        if self.isoper or other.isoper:
-            if not self.isoper:
-                left = _data.project(left)
-            if not other.isoper:
-                right = _data.project(right)
-            return _data.trace(_data.matmul(left, right))
-        if other.isbra:
-            right = right.adjoint()
-        out = _data.inner(left, right, self.isket)
-        if self.isket and other.isbra:
-            # In this particular case, we've basically doing
-            #   conj(other.overlap(self))
-            # so we take care to conjugate the output.
-            out = np.conj(out)
-        return out
-
-    def eigenstates(self, sparse=False, sort='low', eigvals=0,
-                    tol=0, maxiter=100000, phase_fix=None):
-        """Eigenstates and eigenenergies.
-
-        Eigenstates and eigenenergies are defined for operators and
-        superoperators only.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse Eigensolver
-
-        sort : str
-            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
-
-        eigvals : int
-            Number of requested eigenvalues. Default is all eigenvalues.
-
-        tol : float
-            Tolerance used by sparse Eigensolver (0 = machine precision).
-            The sparse solver may not converge if the tolerance is set too low.
-
-        maxiter : int
-            Maximum number of iterations performed by sparse solver (if used).
-
-        phase_fix : int, None
-            If not None, set the phase of each kets so that ket[phase_fix,0]
-            is real positive.
-
-        Returns
-        -------
-        eigvals : array
-            Array of eigenvalues for operator.
-
-        eigvecs : array
-            Array of quantum operators representing the oprator eigenkets.
-            Order of eigenkets is determined by order of eigenvalues.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-
-        """
-        if isinstance(self.data, _data.CSR) and sparse:
-            evals, evecs = _data.eigs_csr(self.data,
-                                          isherm=self._isherm,
-                                          sort=sort, eigvals=eigvals, tol=tol,
-                                          maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
-            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
-                                      isherm=self._isherm,
-                                      sort=sort, eigvals=eigvals)
-        else:
-            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
-                                      sort=sort, eigvals=eigvals)
-
-        if self.type == 'super':
-            new_dims = [self.dims[0], [1]]
-            new_type = 'operator-ket'
-        else:
-            new_dims = [self.dims[0], [1]*len(self.dims[0])]
-            new_type = 'ket'
-        ekets = np.empty((evecs.shape[1],), dtype=object)
-        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
-                    for vec in _data.split_columns(evecs, False)]
-        norms = np.array([ket.norm() for ket in ekets])
-        if phase_fix is None:
-            phase = np.array([1] * len(ekets))
-        else:
-            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
-                              if ket[phase_fix, 0] else 1
-                              for ket in ekets])
-        return evals, ekets / norms * phase
-
-    def eigenenergies(self, sparse=False, sort='low',
-                      eigvals=0, tol=0, maxiter=100000):
-        """Eigenenergies of a quantum object.
-
-        Eigenenergies (eigenvalues) are defined for operators or superoperators
-        only.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse Eigensolver
-        sort : str
-            Sort eigenvalues 'low' to high, or 'high' to low.
-        eigvals : int
-            Number of requested eigenvalues. Default is all eigenvalues.
-        tol : float
-            Tolerance used by sparse Eigensolver (0=machine precision).
-            The sparse solver may not converge if the tolerance is set too low.
-        maxiter : int
-            Maximum number of iterations performed by sparse solver (if used).
-
-        Returns
-        -------
-        eigvals : array
-            Array of eigenvalues for operator.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-
-        """
-        # TODO: consider another way of handling the dispatch here.
-        if isinstance(self.data, _data.CSR) and sparse:
-            return _data.eigs_csr(self.data,
-                                  vecs=False,
-                                  isherm=self._isherm,
-                                  sort=sort, eigvals=eigvals,
-                                  tol=tol, maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
-            return _data.eigs(_data.to(_data.Dense, self.data),
-                              vecs=False, isherm=self._isherm,
-                              sort=sort, eigvals=eigvals)
-
-        return _data.eigs(self.data,
-                          vecs=False,
-                          isherm=self._isherm, sort=sort, eigvals=eigvals)
-
-    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
-        """Ground state Eigenvalue and Eigenvector.
-
-        Defined for quantum operators or superoperators only.
-
-        Parameters
-        ----------
-        sparse : bool
-            Use sparse Eigensolver
-        tol : float
-            Tolerance used by sparse Eigensolver (0 = machine precision).
-            The sparse solver may not converge if the tolerance is set too low.
-        maxiter : int
-            Maximum number of iterations performed by sparse solver (if used).
-        safe : bool (default=True)
-            Check for degenerate ground state
-
-        Returns
-        -------
-        eigval : float
-            Eigenvalue for the ground state of quantum operator.
-        eigvec : :class:`qutip.Qobj`
-            Eigenket for the ground state of quantum operator.
-
-        Notes
-        -----
-        The sparse eigensolver is much slower than the dense version.
-        Use sparse only if memory requirements demand it.
-        """
-        eigvals = 2 if safe else 1
-        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
-                                        tol=tol, maxiter=maxiter)
-
-        if safe:
-            tol = tol or settings.core['atol']
-            # This tol should be less strick than the tol for the eigensolver
-            # so it's numerical errors are not seens as degenerate states.
-            if (evals[1]-evals[0]) <= 10 * tol:
-                warnings.warn("Ground state may be degenerate.", UserWarning)
-        return evals[0], evecs[0]
-
-    def dnorm(self, B=None):
-        """Calculates the diamond norm, or the diamond distance to another
-        operator.
-
-        Parameters
-        ----------
-        B : :class:`qutip.Qobj` or None
-            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
-            between this operator and B is returned instead of the diamond norm.
-
-        Returns
-        -------
-        d : float
-            Either the diamond norm of this operator, or the diamond distance
-            from this operator to B.
-
-        """
-        return mts.dnorm(self, B)
-
-    @property
-    def ishp(self):
-        # FIXME: this needs to be cached in the same ways as isherm.
-        if self.type in ["super", "oper"]:
-            try:
-                J = to_choi(self)
-                return J.isherm
-            except:
-                return False
-        else:
-            return False
-
-    @property
-    def iscp(self):
-        # FIXME: this needs to be cached in the same ways as isherm.
-        if self.type not in ["super", "oper"]:
-            return False
-        # We can test with either Choi or chi, since the basis
-        # transformation between them is unitary and hence preserves
-        # the CP and TP conditions.
-        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
-        # If J isn't hermitian, then that could indicate either that J is not
-        # normal, or is normal, but has complex eigenvalues.  In either case,
-        # it makes no sense to then demand that the eigenvalues be
-        # non-negative.
-        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
-
-    @property
-    def istp(self):
-        if self.type not in ['super', 'oper']:
-            return False
-        # Normalize to a super of type choi or chi.
-        # We can test with either Choi or chi, since the basis
-        # transformation between them is unitary and hence
-        # preserves the CP and TP conditions.
-        if self.issuper and self.superrep in ('choi', 'chi'):
-            qobj = self
-        else:
-            qobj = to_choi(self)
-        # Possibly collapse dims.
-        if any([len(index) > 1
-                for super_index in qobj.dims
-                for index in super_index]):
-            qobj = Qobj(qobj.data,
-                        dims=collapse_dims_super(qobj.dims),
-                        type=qobj.type,
-                        superrep=qobj.superrep,
-                        copy=False)
-        # We use the condition from John Watrous' lecture notes,
-        # Tr_1(J(Phi)) = identity_2.
-        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
-        # Theory of Quantum Information (Fall 2011), theorem 5.4.
-        tr_oper = qobj.ptrace([0])
-        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
-                           atol=settings.core['atol'])
-
-    @property
-    def iscptp(self):
-        if not (self.issuper or self.isoper):
-            return False
-        reps = ('choi', 'chi')
-        q_oper = to_choi(self) if self.superrep not in reps else self
-        return q_oper.iscp and q_oper.istp
-
-    @property
-    def isherm(self):
-        if self._isherm is not None:
-            return self._isherm
-        self._isherm = _data.isherm(self._data)
-        return self._isherm
-
-    @isherm.setter
-    def isherm(self, isherm):
-        self._isherm = isherm
-
-    def _calculate_isunitary(self):
-        """
-        Checks whether qobj is a unitary matrix
-        """
-        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
-            return False
-        cmp = _data.matmul(self._data, self._data.adjoint())
-        iden = _data.identity(self.shape[0], dtype=type(cmp))
-        return _data.iszero(_data.sub(cmp, iden),
-                            tol=settings.core['atol'])
-
-    @property
-    def isunitary(self):
-        if self._isunitary is not None:
-            return self._isunitary
-        self._isunitary = self._calculate_isunitary()
-        return self._isunitary
-
-    @property
-    def shape(self): return self.data.shape
-
-    isbra = property(isbra)
-    isket = property(isket)
-    isoper = property(isoper)
-    issuper = property(issuper)
-    isoperbra = property(isoperbra)
-    isoperket = property(isoperket)
-
-
-def ptrace(Q, sel):
-    """
-    Partial trace of the Qobj with selected components remaining.
-
-    Parameters
-    ----------
-    Q : :class:`qutip.Qobj`
-        Composite quantum object.
-    sel : int/list
-        An ``int`` or ``list`` of components to keep after partial trace.
-
-    Returns
-    -------
-    oper : :class:`qutip.Qobj`
-        Quantum object representing partial trace with selected components
-        remaining.
-
-    Notes
-    -----
-    This function is for legacy compatibility only. It is recommended to use
-    the ``ptrace()`` Qobj method.
-    """
-    if not isinstance(Q, Qobj):
-        raise TypeError("Input is not a quantum object")
-    return Q.ptrace(sel)
-
-
-# TRAILING IMPORTS
-# We do a few imports here to avoid circular dependencies.
-from qutip.core.superop_reps import to_choi
-from qutip.core.superoperator import vector_to_operator, operator_to_vector
-from qutip.core.tensor import tensor_swap, tensor
-from qutip.core import metrics as mts
+"""The Quantum Object (Qobj) class, for representing quantum states and
+operators, and related functions.
+"""
+
+__all__ = [
+    'Qobj', 'isbra', 'isket', 'isoper', 'issuper', 'isoperbra', 'isoperket',
+    'isherm', 'ptrace',
+]
+
+import functools
+import numbers
+import warnings
+
+import numpy as np
+import scipy.sparse
+
+from .. import __version__
+from ..settings import settings
+from . import data as _data
+from .dimensions import (
+    type_from_dims, enumerate_flat, collapse_dims_super, flatten, unflatten,
+)
+
+
+_ADJOINT_TYPE_LOOKUP = {
+    'oper': 'oper',
+    'super': 'super',
+    'ket': 'bra',
+    'bra': 'ket',
+    'operator-ket': 'operator-bra',
+    'operator-bra': 'operator-ket',
+}
+
+_MATMUL_TYPE_LOOKUP = {
+    ('oper', 'ket'): 'ket',
+    ('oper', 'oper'): 'oper',
+    ('ket', 'bra'): 'oper',
+    ('bra', 'oper'): 'bra',
+    ('super', 'super'): 'super',
+    ('super', 'operator-ket'): 'operator-ket',
+    ('operator-bra', 'super'): 'operator-bra',
+    ('operator-ket', 'operator-bra'): 'super',
+}
+
+_NORM_FUNCTION_LOOKUP = {
+    'tr': _data.norm.trace,
+    'one': _data.norm.one,
+    'max': _data.norm.max,
+    'fro': _data.norm.frobenius,
+    'l2': _data.norm.l2,
+}
+_NORM_ALLOWED_MATRIX = {'tr', 'fro', 'one', 'max'}
+_NORM_ALLOWED_VECTOR = {'l2', 'max'}
+
+_CALL_ALLOWED = {
+    ('super', 'oper'),
+    ('super', 'ket'),
+    ('oper', 'ket'),
+}
+
+
+def isbra(x):
+    return isinstance(x, Qobj) and x.type == 'bra'
+
+
+def isket(x):
+    return isinstance(x, Qobj) and x.type == 'ket'
+
+
+def isoper(x):
+    return isinstance(x, Qobj) and x.type == 'oper'
+
+
+def isoperbra(x):
+    return isinstance(x, Qobj) and x.type == 'operator-bra'
+
+
+def isoperket(x):
+    return isinstance(x, Qobj) and x.type == 'operator-ket'
+
+
+def issuper(x):
+    return isinstance(x, Qobj) and x.type == 'super'
+
+
+def isherm(x):
+    return isinstance(x, Qobj) and x.isherm
+
+
+def _require_equal_type(method):
+    """
+    Decorate a binary Qobj method to ensure both operands are Qobj and of the
+    same type and dimensions.  Promote numeric scalar to identity matrices of
+    the same type and shape.
+    """
+    @functools.wraps(method)
+    def out(self, other):
+        if other == 0:
+            return method(self, other)
+        if (
+            self.type in ('oper', 'super')
+            and self.dims[0] == self.dims[1]
+            and isinstance(other, numbers.Number)
+        ):
+            scale = complex(other)
+            other = Qobj(_data.identity(self.shape[0], scale,
+                                        dtype=type(self.data)),
+                         dims=self.dims,
+                         type=self.type,
+                         superrep=self.superrep,
+                         isherm=(scale.imag == 0),
+                         isunitary=(abs(abs(scale)-1) < settings.core['atol']),
+                         copy=False)
+        if not isinstance(other, Qobj):
+            try:
+                other = Qobj(other, type=self.type)
+            except TypeError:
+                return NotImplemented
+        if self.dims != other.dims:
+            msg = (
+                "incompatible dimensions "
+                + repr(self.dims) + " and " + repr(other.dims)
+            )
+            raise ValueError(msg)
+        if self.type != other.type:
+            msg = "incompatible types " + self.type + " and " + other.type
+            raise ValueError(msg)
+        if self.superrep != other.superrep:
+            msg = (
+                "incompatible superoperator representations"
+                + self.superrep + " and " + other.superrep
+            )
+            raise ValueError(msg)
+        return method(self, other)
+    return out
+
+
+def _latex_real(x):
+    if not x:
+        return "0"
+    if not 0.001 <= abs(x) < 1000:
+        base, exp = "{:.3e}".format(x).split('e')
+        return base + r"\times10^{{ {:d} }}".format(int(exp))
+    if abs(x - int(x)) < 0.001:
+        return "{:d}".format(round(x))
+    return "{:.3f}".format(x)
+
+
+def _latex_complex(x):
+    if abs(x.imag) < 0.001:
+        return _latex_real(x.real)
+    if abs(x.real) < 0.001:
+        return _latex_real(x.imag) + "j"
+    sign = "+" if x.imag > 0 else "-"
+    return "(" + _latex_real(x.real) + sign + _latex_real(abs(x.imag)) + "j)"
+
+
+def _latex_row(row, cols, data):
+    if row is None:
+        bits = (r"\ddots" if col is None else r"\vdots" for col in cols)
+    else:
+        bits = (r"\cdots" if col is None else _latex_complex(data[row, col])
+                for col in cols)
+    return " & ".join(bits)
+
+
+class Qobj:
+    """
+    A class for representing quantum objects, such as quantum operators and
+    states.
+
+    The Qobj class is the QuTiP representation of quantum operators and state
+    vectors. This class also implements math operations +,-,* between Qobj
+    instances (and / by a C-number), as well as a collection of common
+    operator/state operations.  The Qobj constructor optionally takes a
+    dimension ``list`` and/or shape ``list`` as arguments.
+
+    Parameters
+    ----------
+    inpt: array_like
+        Data for vector/matrix representation of the quantum object.
+    dims: list
+        Dimensions of object used for tensor products.
+    type: {'bra', 'ket', 'oper', 'operator-ket', 'operator-bra', 'super'}
+        The type of quantum object to be represented.
+    shape: list
+        Shape of underlying data structure (matrix shape).
+    copy: bool
+        Flag specifying whether Qobj should get a copy of the
+        input data, or use the original.
+
+
+    Attributes
+    ----------
+    data : array_like
+        Sparse matrix characterizing the quantum object.
+    dims : list
+        List of dimensions keeping track of the tensor structure.
+    shape : list
+        Shape of the underlying `data` array.
+    type : str
+        Type of quantum object: 'bra', 'ket', 'oper', 'operator-ket',
+        'operator-bra', or 'super'.
+    superrep : str
+        Representation used if `type` is 'super'. One of 'super'
+        (Liouville form) or 'choi' (Choi matrix with tr = dimension).
+    isherm : bool
+        Indicates if quantum object represents Hermitian operator.
+    isunitary : bool
+        Indictaes if quantum object represents unitary operator.
+    iscp : bool
+        Indicates if the quantum object represents a map, and if that map is
+        completely positive (CP).
+    ishp : bool
+        Indicates if the quantum object represents a map, and if that map is
+        hermicity preserving (HP).
+    istp : bool
+        Indicates if the quantum object represents a map, and if that map is
+        trace preserving (TP).
+    iscptp : bool
+        Indicates if the quantum object represents a map that is completely
+        positive and trace preserving (CPTP).
+    isket : bool
+        Indicates if the quantum object represents a ket.
+    isbra : bool
+        Indicates if the quantum object represents a bra.
+    isoper : bool
+        Indicates if the quantum object represents an operator.
+    issuper : bool
+        Indicates if the quantum object represents a superoperator.
+    isoperket : bool
+        Indicates if the quantum object represents an operator in column vector
+        form.
+    isoperbra : bool
+        Indicates if the quantum object represents an operator in row vector
+        form.
+
+    Methods
+    -------
+    copy()
+        Create copy of Qobj
+    conj()
+        Conjugate of quantum object.
+    cosm()
+        Cosine of quantum object.
+    dag()
+        Adjoint (dagger) of quantum object.
+    dnorm()
+        Diamond norm of quantum operator.
+    dual_chan()
+        Dual channel of quantum object representing a CP map.
+    eigenenergies(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
+        Returns eigenenergies (eigenvalues) of a quantum object.
+    eigenstates(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)
+        Returns eigenenergies and eigenstates of quantum object.
+    expm()
+        Matrix exponential of quantum object.
+    full(order='C')
+        Returns dense array of quantum object `data` attribute.
+    groundstate(sparse=False, tol=0, maxiter=100000)
+        Returns eigenvalue and eigenket for the groundstate of a quantum
+        object.
+    inv()
+        Return a Qobj corresponding to the matrix inverse of the operator.
+    matrix_element(bra, ket)
+        Returns the matrix element of operator between `bra` and `ket` vectors.
+    norm(norm='tr', sparse=False, tol=0, maxiter=100000)
+        Returns norm of a ket or an operator.
+    permute(order)
+        Returns composite qobj with indices reordered.
+    proj()
+        Computes the projector for a ket or bra vector.
+    ptrace(sel)
+        Returns quantum object for selected dimensions after performing
+        partial trace.
+    sinm()
+        Sine of quantum object.
+    sqrtm()
+        Matrix square root of quantum object.
+    tidyup(atol=1e-12)
+        Removes small elements from quantum object.
+    tr()
+        Trace of quantum object.
+    trans()
+        Transpose of quantum object.
+    transform(inpt, inverse=False)
+        Performs a basis transformation defined by `inpt` matrix.
+    trunc_neg(method='clip')
+        Removes negative eigenvalues and returns a new Qobj that is
+        a valid density operator.
+    unit(norm='tr', sparse=False, tol=0, maxiter=100000)
+        Returns normalized quantum object.
+
+    """
+    # Disable ufuncs from acting directly on Qobj.
+    __array_ufunc__ = None
+
+    def _initialize_data(self, arg, dims, copy):
+        if isinstance(arg, _data.Data):
+            self.dims = dims or [[arg.shape[0]], [arg.shape[1]]]
+            self._data = arg.copy() if copy else arg
+        elif isinstance(arg, Qobj):
+            self.dims = dims or arg.dims.copy()
+            self._data = arg.data.copy() if copy else arg.data
+        elif arg is None or isinstance(arg, numbers.Number):
+            self.dims = dims or [[1], [1]]
+            size = np.prod(self.dims[0])
+            if arg is None:
+                self._data = _data.zeros(size, size)
+            else:
+                self._data = _data.identity(size, scale=complex(arg))
+        else:
+            self._data = _data.create(arg, copy=copy)
+            self.dims = dims or [[self._data.shape[0]], [self._data.shape[1]]]
+
+    def __init__(self, arg=None, dims=None, type=None,
+                 copy=True, superrep=None, isherm=None, isunitary=None):
+        self._initialize_data(arg, dims, copy)
+        self.type = type or type_from_dims(self.dims)
+        self._isherm = isherm
+        self._isunitary = isunitary
+
+        if self.type == 'super' and type_from_dims(self.dims) == 'oper':
+            if self._data.shape[0] != self._data.shape[1]:
+                raise ValueError("".join([
+                    "cannot build superoperator from nonsquare data of shape ",
+                    repr(self._data.shape),
+                ]))
+            root = int(np.sqrt(self._data.shape[0]))
+            if root * root != self._data.shape[0]:
+                raise ValueError("".join([
+                    "cannot build superoperator from nonsquare subspaces ",
+                    "of size ",
+                    repr(self._data.shape[0]),
+                ]))
+            self.dims = [[[root]]*2]*2
+        if self.type in ['super', 'operator-ket', 'operator-bra']:
+            superrep = superrep or 'super'
+        self.superrep = superrep
+
+    def copy(self):
+        """Create identical copy"""
+        return Qobj(arg=self._data,
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=True)
+
+    @property
+    def data(self):
+        return self._data
+
+    @data.setter
+    def data(self, data):
+        if not isinstance(data, _data.Data):
+            raise TypeError('Qobj data must be a data-layer format.')
+        self._data = data
+
+    def to(self, data_type):
+        """
+        Convert the underlying data store of this `Qobj` into a different
+        storage representation.
+
+        The different storage representations available are the "data-layer
+        types" which are known to `qutip.data.to`.  By default, these are
+        `qutip.data.Dense` and `qutip.data.CSR`, which respectively construct a
+        dense matrix store and a compressed sparse row one.  Certain algorithms
+        and operations may be faster or more accurate when using a more
+        appropriate data store.
+
+        If the data store is already in the format requested, the function
+        returns `self`.  Otherwise, it returns a copy of itself with the data
+        store in the new type.
+
+        Parameters
+        ----------
+        data_type : type
+            The data-layer type that the data of this `Qobj` should be
+            converted to.
+
+        Returns
+        -------
+        Qobj
+            A new `Qobj` if a type conversion took place with the data stored
+            in the requested format, or `self` if not.
+        """
+        try:
+            converter = _data.to[data_type]
+        except (KeyError, TypeError):
+            raise ValueError("Unknown conversion type: " + str(data_type))
+        if type(self.data) is data_type:
+            return self
+        return Qobj(converter(self._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    @_require_equal_type
+    def __add__(self, other):
+        if other == 0:
+            return self.copy()
+        isherm = (self._isherm and other._isherm) or None
+        return Qobj(_data.add(self._data, other._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=isherm,
+                    copy=False)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    @_require_equal_type
+    def __sub__(self, other):
+        if other == 0:
+            return self.copy()
+        isherm = (self._isherm and other._isherm) or None
+        return Qobj(_data.sub(self._data, other._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=isherm,
+                    copy=False)
+
+    def __rsub__(self, other):
+        return self.__neg__().__add__(other)
+
+    def __mul__(self, other):
+        """
+        If other is a Qobj, we dispatch to __matmul__. If not, we
+        check that other is a valid complex scalar, i.e., we can do
+        complex(other). Otherwise, we return NotImplemented.
+        """
+
+        if isinstance(other, Qobj):
+            return self.__matmul__(other)
+
+        # We send other to mul instead of complex(other) to be more flexible.
+        # The dispatcher can then decide how to handle other and return
+        # TypeError if it does not know what to do with the type of other.
+        try:
+            out = _data.mul(self._data, other)
+        except TypeError:
+            return NotImplemented
+
+        # Infer isherm and isunitary if possible
+        try:
+            multiplier = complex(other)
+            isherm = (self._isherm and multiplier.imag == 0) or None
+            isunitary = (abs(abs(multiplier) - 1) < settings.core['atol']
+                         if self._isunitary else None)
+        except TypeError:
+            isherm = None
+            isunitary = None
+
+        return Qobj(out,
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=isherm,
+                    isunitary=isunitary,
+                    copy=False)
+
+    def __rmul__(self, other):
+        # Shouldn't be here unless `other.__mul__` has already been tried, so
+        # we _shouldn't_ check that `other` is `Qobj`.
+        return self.__mul__(other)
+
+    def __matmul__(self, other):
+        if not isinstance(other, Qobj):
+            try:
+                other = Qobj(other)
+            except TypeError:
+                return NotImplemented
+        if self.dims[1] != other.dims[0]:
+            raise TypeError("".join([
+                "incompatible dimensions ",
+                repr(self.dims),
+                " and ",
+                repr(other.dims),
+            ]))
+        if self.superrep != other.superrep:
+            raise TypeError("".join([
+                "incompatible superoperator representations ",
+                repr(self.superrep),
+                " and ",
+                repr(other.superrep),
+            ]))
+        if (
+            (self.isbra and other.isket)
+            or (self.isoperbra and other.isoperket)
+        ):
+            return _data.inner(self.data, other.data)
+
+        try:
+            type_ = _MATMUL_TYPE_LOOKUP[(self.type, other.type)]
+        except KeyError:
+            raise TypeError(
+                "incompatible matmul types "
+                + repr(self.type) + " and " + repr(other.type)
+            ) from None
+        return Qobj(_data.matmul(self.data, other.data),
+                    dims=[self.dims[0], other.dims[1]],
+                    type=type_,
+                    isunitary=self._isunitary and other._isunitary,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def __truediv__(self, other):
+        return self.__mul__(1 / other)
+
+    def __neg__(self):
+        return Qobj(_data.neg(self._data),
+                    dims=self.dims.copy(),
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def __getitem__(self, ind):
+        # TODO: should we require that data-layer types implement this?  This
+        # isn't the right way of handling it, for sure.
+        if isinstance(self._data, _data.CSR):
+            data = self._data.as_scipy()
+        elif isinstance(self._data, _data.Dense):
+            data = self._data.as_ndarray()
+        else:
+            data = self._data
+        try:
+            out = data[ind]
+            return out.toarray() if scipy.sparse.issparse(out) else out
+        except TypeError:
+            pass
+        return data.to_array()[ind]
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        if not isinstance(other, Qobj) or self.dims != other.dims:
+            return False
+        return _data.iszero(_data.sub(self._data, other._data),
+                            tol=settings.core['atol'])
+
+    def __pow__(self, n, m=None):  # calculates powers of Qobj
+        if (
+            self.type not in ('oper', 'super')
+            or self.dims[0] != self.dims[1]
+            or m is not None
+            or not isinstance(n, numbers.Integral)
+            or n < 0
+        ):
+            return NotImplemented
+        return Qobj(_data.pow(self._data, n),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def _str_header(self):
+        out = ", ".join([
+            "Quantum object: dims=" + str(self.dims),
+            "shape=" + str(self.data.shape),
+            "type=" + repr(self.type),
+        ])
+        if self.type in ('oper', 'super'):
+            out += ", isherm=" + str(self.isherm)
+        if self.issuper and self.superrep != 'super':
+            out += ", superrep=" + repr(self.superrep)
+        return out
+
+    def __str__(self):
+        if self.data.shape[0] * self.data.shape[0] > 100_000_000:
+            # If the system is huge, don't attempt to convert to a dense matrix
+            # and then to string, because it is pointless and is likely going
+            # to produce memory errors. Instead print the sparse data string
+            # representation.
+            data = _data.to(_data.CSR, self.data).as_scipy()
+        elif _data.iszero(_data.sub(self.data.conj(), self.data)):
+            data = np.real(self.full())
+        else:
+            data = self.full()
+        return self._str_header() + "\nQobj data =\n" + str(data)
+
+    def __repr__(self):
+        # give complete information on Qobj without print statement in
+        # command-line we cant realistically serialize a Qobj into a string,
+        # so we simply return the informal __str__ representation instead.)
+        return self.__str__()
+
+    def __call__(self, other):
+        """
+        Acts this Qobj on another Qobj either by left-multiplication,
+        or by vectorization and devectorization, as
+        appropriate.
+        """
+        if not isinstance(other, Qobj):
+            raise TypeError("Only defined for quantum objects.")
+        if (self.type, other.type) not in _CALL_ALLOWED:
+            raise TypeError(self.type + " cannot act on " + other.type)
+        if self.issuper:
+            if other.isket:
+                other = other.proj()
+            return vector_to_operator(self @ operator_to_vector(other))
+        return self.__matmul__(other)
+
+    def __getstate__(self):
+        # defines what happens when Qobj object gets pickled
+        self.__dict__.update({'qutip_version': __version__[:5]})
+        return self.__dict__
+
+    def __setstate__(self, state):
+        # defines what happens when loading a pickled Qobj
+        if 'qutip_version' in state.keys():
+            del state['qutip_version']
+        (self.__dict__).update(state)
+
+    def _repr_latex_(self):
+        """
+        Generate a LaTeX representation of the Qobj instance. Can be used for
+        formatted output in ipython notebook.
+        """
+        half_length = 5
+        n_rows, n_cols = self.data.shape
+        # Choose which rows and columns we're going to output, or None if that
+        # element should be truncated.
+        rows = list(range(min((half_length, n_rows))))
+        if n_rows <= half_length * 2:
+            rows += list(range(half_length, min((2*half_length, n_rows))))
+        else:
+            rows.append(None)
+            rows += list(range(n_rows - half_length, n_rows))
+        cols = list(range(min((half_length, n_cols))))
+        if n_cols <= half_length * 2:
+            cols += list(range(half_length, min((2*half_length, n_cols))))
+        else:
+            cols.append(None)
+            cols += list(range(n_cols - half_length, n_cols))
+        # Make the data array.
+        data = r'\begin{equation*}\left(\begin{array}{*{11}c}'
+        data += r"\\".join(_latex_row(row, cols, self.data.to_array())
+                           for row in rows)
+        data += r'\end{array}\right)\end{equation*}'
+        return self._str_header() + data
+
+    def __and__(self, other):
+        """
+        Syntax shortcut for tensor:
+        A & B ==> tensor(A, B)
+        """
+        return tensor(self, other)
+
+    def dag(self):
+        """Get the Hermitian adjoint of the quantum object."""
+        if self._isherm:
+            return self.copy()
+        return Qobj(_data.adjoint(self._data),
+                    dims=[self.dims[1], self.dims[0]],
+                    type=_ADJOINT_TYPE_LOOKUP[self.type],
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def conj(self):
+        """Get the element-wise conjugation of the quantum object."""
+        return Qobj(_data.conj(self._data),
+                    dims=self.dims.copy(),
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def trans(self):
+        """Get the matrix transpose of the quantum operator.
+
+        Returns
+        -------
+        oper : :class:`.Qobj`
+            Transpose of input operator.
+        """
+        return Qobj(_data.transpose(self._data),
+                    dims=[self.dims[1], self.dims[0]],
+                    type=_ADJOINT_TYPE_LOOKUP[self.type],
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    isunitary=self._isunitary,
+                    copy=False)
+
+    def dual_chan(self):
+        """Dual channel of quantum object representing a completely positive
+        map.
+        """
+        # Uses the technique of Johnston and Kribs (arXiv:1102.0948), which
+        # is only valid for completely positive maps.
+        if not self.iscp:
+            raise ValueError("Dual channels are only implemented for CP maps.")
+        J = to_choi(self)
+        tensor_idxs = enumerate_flat(J.dims)
+        J_dual = tensor_swap(J, *(
+                list(zip(tensor_idxs[0][1], tensor_idxs[0][0])) +
+                list(zip(tensor_idxs[1][1], tensor_idxs[1][0]))
+        )).trans()
+        J_dual.superrep = 'choi'
+        return J_dual
+
+    def norm(self, norm=None, kwargs=None):
+        """
+        Norm of a quantum object.
+
+        Default norm is L2-norm for kets and trace-norm for operators.  Other
+        ket and operator norms may be specified using the `norm` parameter.
+
+        Parameters
+        ----------
+        norm : str
+            Which type of norm to use.  Allowed values for vectors are 'l2' and
+            'max'.  Allowed values for matrices are 'tr' for the trace norm,
+            'fro' for the Frobenius norm, 'one' and 'max'.
+
+        kwargs : dict
+            Additional keyword arguments to pass on to the relevant norm
+            solver.  See details for each norm function in :mod:`.data.norm`.
+
+        Returns
+        -------
+        norm : float
+            The requested norm of the operator or state quantum object.
+        """
+        if self.type in ('oper', 'super'):
+            norm = norm or 'tr'
+            if norm not in _NORM_ALLOWED_MATRIX:
+                raise ValueError(
+                    "matrix norm must be in " + repr(_NORM_ALLOWED_MATRIX)
+                )
+        else:
+            norm = norm or 'l2'
+            if norm not in _NORM_ALLOWED_VECTOR:
+                raise ValueError(
+                    "vector norm must be in " + repr(_NORM_ALLOWED_VECTOR)
+                )
+        kwargs = kwargs or {}
+        return _NORM_FUNCTION_LOOKUP[norm](self.data, **kwargs)
+
+    def proj(self):
+        """Form the projector from a given ket or bra vector.
+
+        Parameters
+        ----------
+        Q : :class:`qutip.Qobj`
+            Input bra or ket vector
+
+        Returns
+        -------
+        P : :class:`qutip.Qobj`
+            Projection operator.
+        """
+        if not (self.isket or self.isbra):
+            raise TypeError("projection is only defined for bras and kets")
+        dims = ([self.dims[0], self.dims[0]] if self.isket
+                else [self.dims[1], self.dims[1]])
+        return Qobj(_data.project(self._data),
+                    dims=dims,
+                    type='oper',
+                    isherm=True,
+                    copy=False)
+
+    def tr(self):
+        """Trace of a quantum object.
+
+        Returns
+        -------
+        trace : float
+            Returns the trace of the quantum object.
+
+        """
+        out = _data.trace(self._data)
+        # This ensures that trace can return something that is not a number such
+        # as a `tensorflow.Tensor` in qutip-tensorflow.
+        return out.real if (self.isherm
+                        and hasattr(out, "real")
+                        ) else out
+
+    def purity(self):
+        """Calculate purity of a quantum object.
+
+        Returns
+        -------
+        state_purity : float
+            Returns the purity of a quantum object.
+            For a pure state, the purity is 1.
+            For a mixed state of dimension `d`, 1/d<=purity<1.
+
+        """
+        if self.type in ("super", "operator-ket", "operator-bra"):
+            raise TypeError('purity is only defined for states.')
+        if self.isket or self.isbra:
+            return _data.norm.l2(self.data)**2
+        return _data.trace(_data.matmul(self.data, self.data)).real
+
+    def full(self, order='C', squeeze=False):
+        """Dense array from quantum object.
+
+        Parameters
+        ----------
+        order : str {'C', 'F'}
+            Return array in C (default) or Fortran ordering.
+        squeeze : bool {False, True}
+            Squeeze output array.
+
+        Returns
+        -------
+        data : array
+            Array of complex data from quantum objects `data` attribute.
+        """
+        out = np.asarray(self.data.to_array(), order=order)
+        return out.squeeze() if squeeze else out
+
+    def diag(self):
+        """Diagonal elements of quantum object.
+
+        Returns
+        -------
+        diags : array
+            Returns array of ``real`` values if operators is Hermitian,
+            otherwise ``complex`` values are returned.
+        """
+        # TODO: add a `diagonal` method to the data layer?
+        out = _data.to(_data.CSR, self.data).as_scipy().diagonal()
+        if np.any(np.imag(out) > settings.core['atol']) or not self.isherm:
+            return out
+        else:
+            return np.real(out)
+
+    def expm(self, dtype=_data.Dense):
+        """Matrix exponential of quantum operator.
+
+        Input operator must be square.
+
+        Parameters
+        ----------
+        dtype : type
+            The data-layer type that should be output.  As the matrix
+            exponential is almost dense, this defaults to outputting dense
+            matrices.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Exponentiated quantum operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum operator is not square.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError("expm is only valid for square operators")
+        return Qobj(_data.expm(self._data, dtype=dtype),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    copy=False)
+
+    def logm(self):
+        """Matrix logarithm of quantum operator.
+
+        Input operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Logarithm of the quantum operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum operator is not square.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError("expm is only valid for square operators")
+        return Qobj(_data.logm(self._data),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    isherm=self._isherm,
+                    copy=False)
+
+    def check_herm(self):
+        """Check if the quantum object is hermitian.
+
+        Returns
+        -------
+        isherm : bool
+            Returns the new value of isherm property.
+        """
+        self._isherm = None
+        return self.isherm
+
+    def sqrtm(self, sparse=False, tol=0, maxiter=100000):
+        """
+        Sqrt of a quantum operator.  Operator must be square.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse eigenvalue/vector solver.
+        tol : float
+            Tolerance used by sparse solver (0 = machine precision).
+        maxiter : int
+            Maximum number of iterations used by sparse solver.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix square root of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError('sqrt only valid on square matrices')
+        if isinstance(self.data, _data.CSR) and sparse:
+            evals, evecs = _data.eigs_csr(self.data,
+                                          isherm=self._isherm,
+                                          tol=tol, maxiter=maxiter)
+        elif isinstance(self.data, _data.CSR):
+            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
+                                      isherm=self._isherm)
+        else:
+            evals, evecs = _data.eigs(self.data, isherm=self._isherm)
+
+        numevals = len(evals)
+        dV = _data.diag([np.sqrt(evals, dtype=complex)], 0)
+        if self.isherm:
+            spDv = _data.matmul(dV, evecs.conj().transpose())
+        else:
+            spDv = _data.matmul(dV, _data.inv(evecs))
+        return Qobj(_data.matmul(evecs, spDv),
+                    dims=self.dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def cosm(self):
+        """Cosine of a quantum operator.
+
+        Operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix cosine of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+
+        Notes
+        -----
+        Uses the Q.expm() method.
+
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError('invalid operand for matrix cosine')
+        return 0.5 * ((1j * self).expm() + (-1j * self).expm())
+
+    def sinm(self):
+        """Sine of a quantum operator.
+
+        Operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix sine of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+
+        Notes
+        -----
+        Uses the Q.expm() method.
+        """
+        if self.dims[0] != self.dims[1]:
+            raise TypeError('invalid operand for matrix sine')
+        return -0.5j * ((1j * self).expm() - (-1j * self).expm())
+
+    def inv(self, sparse=False):
+        """Matrix inverse of a quantum operator
+
+        Operator must be square.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Matrix inverse of operator.
+
+        Raises
+        ------
+        TypeError
+            Quantum object is not square.
+        """
+        if self.data.shape[0] != self.data.shape[1]:
+            raise TypeError('Invalid operand for matrix inverse')
+        if isinstance(self.data, _data.CSR) and not sparse:
+            data = _data.to(_data.Dense, self.data)
+        else:
+            data = self.data
+
+        return Qobj(_data.inv(data),
+                    dims=[self.dims[1], self.dims[0]],
+                    type=self.type,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def unit(self, inplace=False, norm=None, kwargs=None):
+        """
+        Operator or state normalized to unity.  Uses norm from Qobj.norm().
+
+        Parameters
+        ----------
+        inplace : bool
+            Do an in-place normalization
+        norm : str
+            Requested norm for states / operators.
+        kwargs : dict
+            Additional key-word arguments to be passed on to the relevant norm
+            function (see :meth:`.norm` for more details).
+
+        Returns
+        -------
+        obj : :class:`qutip.Qobj`
+            Normalized quantum object.  Will be the `self` object if in place.
+        """
+        norm = self.norm(norm=norm, kwargs=kwargs)
+        if inplace:
+            self.data = _data.mul(self.data, 1 / norm)
+            self._isherm = self._isherm if norm.imag == 0 else None
+            self._isunitary = (self._isunitary
+                               if abs(norm) - 1 < settings.core['atol']
+                               else None)
+            out = self
+        else:
+            out = self / norm
+        return out
+
+    def ptrace(self, sel, dtype=None):
+        """
+        Take the partial trace of the quantum object leaving the selected
+        subspaces.  In other words, trace out all subspaces which are _not_
+        passed.
+
+        This is typically a function which acts on operators; bras and kets
+        will be promoted to density matrices before the operation takes place
+        since the partial trace is inherently undefined on pure states.
+
+        For operators which are currently being represented as states in the
+        superoperator formalism (i.e. the object has type `operator-ket` or
+        `operator-bra`), the partial trace is applied as if the operator were
+        in the conventional form.  This means that for any operator `x`,
+        ``operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))``
+        and similar for `operator-bra`.
+
+        The story is different for full superoperators.  In the formalism that
+        QuTiP uses, if an operator has dimensions (`dims`) of
+        `[[2, 3], [2, 3]]` then it can be represented as a state on a Hilbert
+        space of dimensions `[2, 3, 2, 3]`, and a superoperator would be an
+        operator which acts on this joint space.  This function performs the
+        partial trace on superoperators by letting the selected components
+        refer to elements of the _joint_ _space_, and then returns a regular
+        operator (of type `oper`).
+
+        Parameters
+        ----------
+        sel : int or iterable of int
+            An ``int`` or ``list`` of components to keep after partial trace.
+            The selected subspaces will _not_ be reordered, no matter order
+            they are supplied to `ptrace`.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Quantum object representing partial trace with selected components
+            remaining.
+        """
+        try:
+            sel = sorted(sel)
+        except TypeError:
+            if not isinstance(sel, numbers.Integral):
+                raise TypeError(
+                    "selection must be an integer or list of integers"
+                ) from None
+            sel = [sel]
+        if self.isoperket:
+            dims = self.dims[0]
+            data = vector_to_operator(self).data
+        elif self.isoperbra:
+            dims = self.dims[1]
+            data = vector_to_operator(self.dag()).data
+        elif self.issuper or self.isoper:
+            dims = self.dims
+            data = self.data
+        else:
+            dims = [self.dims[0] if self.isket else self.dims[1]] * 2
+            data = _data.project(self.data)
+        if dims[0] != dims[1]:
+            raise ValueError("partial trace is not defined on non-square maps")
+        dims = flatten(dims[0])
+        new_data = _data.ptrace(data, dims, sel, dtype=dtype)
+        new_dims = [[dims[x] for x in sel]] * 2
+        out = Qobj(new_data, dims=new_dims, type='oper', copy=False)
+        if self.isoperket:
+            return operator_to_vector(out)
+        if self.isoperbra:
+            return operator_to_vector(out).dag()
+        return out
+
+    def contract(self, inplace=False):
+        """
+        Contract subspaces of the tensor structure which are 1D.  Not defined
+        on superoperators.  If all dimensions are scalar, a Qobj of dimension
+        [[1], [1]] is returned, i.e. _multiple_ scalar dimensions are
+        contracted, but one is left.
+
+        Parameters
+        ----------
+        inplace: bool, optional
+            If ``True``, modify the dimensions in place.  If ``False``, return
+            a copied object.
+
+        Returns
+        -------
+        out: :class:`.Qobj`
+            Quantum object with dimensions contracted.  Will be ``self`` if
+            ``inplace`` is ``True``.
+        """
+        if self.isket:
+            sub = [x for x in self.dims[0] if x > 1] or [1]
+            dims = [sub, [1]*len(sub)]
+        elif self.isbra:
+            sub = [x for x in self.dims[1] if x > 1] or [1]
+            dims = [[1]*len(sub), sub]
+        elif self.isoper or self.isoperket or self.isoperbra:
+            if self.isoper:
+                oper_dims = self.dims
+            elif self.isoperket:
+                oper_dims = self.dims[0]
+            else:
+                oper_dims = self.dims[1]
+            if len(oper_dims[0]) != len(oper_dims[1]):
+                raise ValueError("cannot parse Qobj dimensions: "
+                                 + repr(self.dims))
+            dims_ = [
+                (x, y) for x, y in zip(oper_dims[0], oper_dims[1])
+                if x > 1 or y > 1
+            ] or [(1, 1)]
+            dims = [[x for x, _ in dims_], [y for _, y in dims_]]
+            if self.isoperket:
+                dims = [dims, [1]]
+            elif self.isoperbra:
+                dims = [[1], dims]
+        else:
+            raise TypeError("not defined for superoperators")
+        if inplace:
+            self.dims = dims
+            return self
+        return Qobj(self.data.copy(), dims=dims, type=self.type, copy=False)
+
+    def permute(self, order):
+        """
+        Permute the tensor structure of a quantum object.  For example,
+        ``qutip.tensor(x, y).permute([1, 0])``
+        will give the same result as
+        ``qutip.tensor(y, x)``
+        and
+        ``qutip.tensor(a, b, c).permute([1, 2, 0])``
+        will be the same as
+        ``qutip.tensor(b, c, a)``
+
+        For regular objects (bras, kets and operators) we expect ``order`` to
+        be a flat list of integers, which specifies the new order of the tensor
+        product.
+
+        For superoperators, we expect ``order`` to be something like
+        ``[[0, 2], [1, 3]]``
+        which tells us to permute according to [0, 2, 1, 3], and then group
+        indices according to the length of each sublist.  As another example,
+        permuting a superoperator with dimensions of
+        ``[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]``
+        by an ``order``
+        ``[[0, 3], [1, 4], [2, 5]]``
+        should give a new object with dimensions
+        ``[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]]``.
+
+        Parameters
+        ----------
+        order : list
+            List of indices specifying the new tensor order.
+
+        Returns
+        -------
+        P : :class:`qutip.Qobj`
+            Permuted quantum object.
+        """
+        if self.type in ('bra', 'ket', 'oper'):
+            structure = self.dims[1] if self.isbra else self.dims[0]
+            new_structure = [structure[x] for x in order]
+            if self.isbra:
+                dims = [self.dims[0], new_structure]
+            elif self.isket:
+                dims = [new_structure, self.dims[1]]
+            else:
+                if self.dims[0] != self.dims[1]:
+                    raise TypeError("undefined for non-square operators")
+                dims = [new_structure, new_structure]
+            data = _data.permute.dimensions(self.data, structure, order)
+            return Qobj(data,
+                        dims=dims,
+                        type=self.type,
+                        isherm=self._isherm,
+                        isunitary=self._isunitary,
+                        copy=False)
+        # If we've got here, we're some form of superoperator, so we work with
+        # the flattened structure.
+        flat_order = flatten(order)
+        flat_structure = flatten(self.dims[1] if self.isoperbra
+                                 else self.dims[0])
+        new_structure = unflatten([flat_structure[x] for x in flat_order],
+                                  enumerate_flat(order))
+        if self.isoperbra:
+            dims = [self.dims[0], new_structure]
+        elif self.isoperket:
+            dims = [new_structure, self.dims[1]]
+        else:
+            if self.dims[0] != self.dims[1]:
+                raise TypeError("undefined for non-square operators")
+            dims = [new_structure, new_structure]
+        data = _data.permute.dimensions(self.data, flat_structure, flat_order)
+        return Qobj(data,
+                    dims=dims,
+                    type=self.type,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def tidyup(self, atol=None):
+        """
+        Removes small elements from the quantum object.
+
+        Parameters
+        ----------
+        atol : float
+            Absolute tolerance used by tidyup. Default is set
+            via qutip global settings parameters.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Quantum object with small elements removed.
+        """
+        atol = atol or settings.core['auto_tidyup_atol']
+        self.data = _data.tidyup(self.data, atol)
+        return self
+
+    def transform(self, inpt, inverse=False):
+        """Basis transform defined by input array.
+
+        Input array can be a ``matrix`` defining the transformation,
+        or a ``list`` of kets that defines the new basis.
+
+        Parameters
+        ----------
+        inpt : array_like
+            A ``matrix`` or ``list`` of kets defining the transformation.
+        inverse : bool
+            Whether to return inverse transformation.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            Operator in new basis.
+
+        Notes
+        -----
+        This function is still in development.
+        """
+        if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and
+                                      inpt.ndim == 1):
+            if len(inpt) != max(self.shape):
+                raise TypeError(
+                    'Invalid size of ket list for basis transformation')
+            base = np.hstack([psi.full() for psi in inpt])
+            S = _data.adjoint(_data.create(base))
+        elif isinstance(inpt, Qobj) and inpt.isoper:
+            S = inpt.data
+        elif isinstance(inpt, np.ndarray):
+            S = _data.create(inpt).conj()
+        else:
+            raise TypeError('Invalid operand for basis transformation')
+
+        # transform data
+        if inverse:
+            if self.isket:
+                data = _data.matmul(S.adjoint(), self.data)
+            elif self.isbra:
+                data = _data.matmul(self.data, S)
+            else:
+                data = _data.matmul(_data.matmul(S.adjoint(), self.data), S)
+        else:
+            if self.isket:
+                data = _data.matmul(S, self.data)
+            elif self.isbra:
+                data = _data.matmul(self.data, S.adjoint())
+            else:
+                data = _data.matmul(_data.matmul(S, self.data), S.adjoint())
+        return Qobj(data,
+                    dims=self.dims,
+                    type=self.type,
+                    isherm=self._isherm,
+                    superrep=self.superrep,
+                    copy=False)
+
+    def trunc_neg(self, method="clip"):
+        """Truncates negative eigenvalues and renormalizes.
+
+        Returns a new Qobj by removing the negative eigenvalues
+        of this instance, then renormalizing to obtain a valid density
+        operator.
+
+
+        Parameters
+        ----------
+        method : str
+            Algorithm to use to remove negative eigenvalues. "clip"
+            simply discards negative eigenvalues, then renormalizes.
+            "sgs" uses the SGS algorithm (doi:10/bb76) to find the
+            positive operator that is nearest in the Shatten 2-norm.
+
+        Returns
+        -------
+        oper : :class:`qutip.Qobj`
+            A valid density operator.
+        """
+        if not self.isherm:
+            raise ValueError("Must be a Hermitian operator to remove negative "
+                             "eigenvalues.")
+        if method not in ('clip', 'sgs'):
+            raise ValueError("Method {} not recognized.".format(method))
+
+        eigvals, eigstates = self.eigenstates()
+        if all(eigval >= 0 for eigval in eigvals):
+            # All positive, so just renormalize.
+            return self.unit()
+        idx_nonzero = eigvals != 0
+        eigvals = eigvals[idx_nonzero]
+        eigstates = eigstates[idx_nonzero]
+
+        if method == 'clip':
+            eigvals[eigvals < 0] = 0
+        elif method == 'sgs':
+            eigvals = eigvals[::-1]
+            eigstates = eigstates[::-1]
+            acc = 0.0
+            n_eigs = len(eigvals)
+            for idx in reversed(range(n_eigs)):
+                if eigvals[idx] + acc / (idx + 1) >= 0:
+                    break
+                acc += eigvals[idx]
+                eigvals[idx] = 0.0
+            eigvals[:idx+1] += acc / (idx + 1)
+        out_data = _data.zeros(*self.shape)
+        for value, state in zip(eigvals, eigstates):
+            if value:
+                # add in 3-argument form is fused-add-multiply
+                out_data = _data.add(out_data,
+                                     _data.project(state.data),
+                                     value)
+        out_data = _data.mul(out_data, 1/_data.norm.trace(out_data))
+        return Qobj(out_data,
+                    dims=self.dims.copy(),
+                    type=self.type,
+                    isherm=True,
+                    copy=False)
+
+    def matrix_element(self, bra, ket):
+        """Calculates a matrix element.
+
+        Gives the matrix element for the quantum object sandwiched between a
+        `bra` and `ket` vector.
+
+        Parameters
+        ----------
+        bra : :class:`qutip.Qobj`
+            Quantum object of type 'bra' or 'ket'
+
+        ket : :class:`qutip.Qobj`
+            Quantum object of type 'ket'.
+
+        Returns
+        -------
+        elem : complex
+            Complex valued matrix element.
+
+        Notes
+        -----
+        It is slightly more computationally efficient to use a ket
+        vector for the 'bra' input.
+
+        """
+        if not self.isoper:
+            raise TypeError("Can only get matrix elements for an operator.")
+        if bra.type not in ('bra', 'ket') or ket.type not in ('bra', 'ket'):
+            msg = "Can only calculate matrix elements between a bra and a ket."
+            raise TypeError(msg)
+        left, op, right = bra.data, self.data, ket.data
+        if ket.isbra:
+            right = right.adjoint()
+        return _data.inner_op(left, op, right, bra.isket)
+
+    def overlap(self, other):
+        """
+        Overlap between two state vectors or two operators.
+
+        Gives the overlap (inner product) between the current bra or ket Qobj
+        and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap
+        when one of the Qobj is an operator/density matrix.
+
+        Parameters
+        ----------
+        other : :class:`qutip.Qobj`
+            Quantum object for a state vector of type 'ket', 'bra' or density
+            matrix.
+
+        Returns
+        -------
+        overlap : complex
+            Complex valued overlap.
+
+        Raises
+        ------
+        TypeError
+            Can only calculate overlap between a bra, ket and density matrix
+            quantum objects.
+        """
+        if not isinstance(other, Qobj):
+            raise TypeError("".join([
+                "cannot calculate overlap with non-quantum object ",
+                repr(other),
+            ]))
+        if (
+            self.type not in ('ket', 'bra', 'oper')
+            or other.type not in ('ket', 'bra', 'oper')
+        ):
+            msg = "only bras, kets and density matrices have defined overlaps"
+            raise TypeError(msg)
+        left, right = self._data.adjoint(), other.data
+        if self.isoper or other.isoper:
+            if not self.isoper:
+                left = _data.project(left)
+            if not other.isoper:
+                right = _data.project(right)
+            return _data.trace(_data.matmul(left, right))
+        if other.isbra:
+            right = right.adjoint()
+        out = _data.inner(left, right, self.isket)
+        if self.isket and other.isbra:
+            # In this particular case, we've basically doing
+            #   conj(other.overlap(self))
+            # so we take care to conjugate the output.
+            out = np.conj(out)
+        return out
+
+    def eigenstates(self, sparse=False, sort='low', eigvals=0,
+                    tol=0, maxiter=100000, phase_fix=None):
+        """Eigenstates and eigenenergies.
+
+        Eigenstates and eigenenergies are defined for operators and
+        superoperators only.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse Eigensolver
+
+        sort : str
+            Sort eigenvalues (and vectors) 'low' to high, or 'high' to low.
+
+        eigvals : int
+            Number of requested eigenvalues. Default is all eigenvalues.
+
+        tol : float
+            Tolerance used by sparse Eigensolver (0 = machine precision).
+            The sparse solver may not converge if the tolerance is set too low.
+
+        maxiter : int
+            Maximum number of iterations performed by sparse solver (if used).
+
+        phase_fix : int, None
+            If not None, set the phase of each kets so that ket[phase_fix,0]
+            is real positive.
+
+        Returns
+        -------
+        eigvals : array
+            Array of eigenvalues for operator.
+
+        eigvecs : array
+            Array of quantum operators representing the oprator eigenkets.
+            Order of eigenkets is determined by order of eigenvalues.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+
+        """
+        if isinstance(self.data, _data.CSR) and sparse:
+            evals, evecs = _data.eigs_csr(self.data,
+                                          isherm=self._isherm,
+                                          sort=sort, eigvals=eigvals, tol=tol,
+                                          maxiter=maxiter)
+        elif isinstance(self.data, _data.CSR):
+            evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
+                                      isherm=self._isherm,
+                                      sort=sort, eigvals=eigvals)
+        else:
+            evals, evecs = _data.eigs(self.data, isherm=self._isherm,
+                                      sort=sort, eigvals=eigvals)
+
+        if self.type == 'super':
+            new_dims = [self.dims[0], [1]]
+            new_type = 'operator-ket'
+        else:
+            new_dims = [self.dims[0], [1]*len(self.dims[0])]
+            new_type = 'ket'
+        ekets = np.empty((evecs.shape[1],), dtype=object)
+        ekets[:] = [Qobj(vec, dims=new_dims, type=new_type, copy=False)
+                    for vec in _data.split_columns(evecs, False)]
+        norms = np.array([ket.norm() for ket in ekets])
+        if phase_fix is None:
+            phase = np.array([1] * len(ekets))
+        else:
+            phase = np.array([np.abs(ket[phase_fix, 0]) / ket[phase_fix, 0]
+                              if ket[phase_fix, 0] else 1
+                              for ket in ekets])
+        return evals, ekets / norms * phase
+
+    def eigenenergies(self, sparse=False, sort='low',
+                      eigvals=0, tol=0, maxiter=100000):
+        """Eigenenergies of a quantum object.
+
+        Eigenenergies (eigenvalues) are defined for operators or superoperators
+        only.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse Eigensolver
+        sort : str
+            Sort eigenvalues 'low' to high, or 'high' to low.
+        eigvals : int
+            Number of requested eigenvalues. Default is all eigenvalues.
+        tol : float
+            Tolerance used by sparse Eigensolver (0=machine precision).
+            The sparse solver may not converge if the tolerance is set too low.
+        maxiter : int
+            Maximum number of iterations performed by sparse solver (if used).
+
+        Returns
+        -------
+        eigvals : array
+            Array of eigenvalues for operator.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+
+        """
+        # TODO: consider another way of handling the dispatch here.
+        if isinstance(self.data, _data.CSR) and sparse:
+            return _data.eigs_csr(self.data,
+                                  vecs=False,
+                                  isherm=self._isherm,
+                                  sort=sort, eigvals=eigvals,
+                                  tol=tol, maxiter=maxiter)
+        elif isinstance(self.data, _data.CSR):
+            return _data.eigs(_data.to(_data.Dense, self.data),
+                              vecs=False, isherm=self._isherm,
+                              sort=sort, eigvals=eigvals)
+
+        return _data.eigs(self.data,
+                          vecs=False,
+                          isherm=self._isherm, sort=sort, eigvals=eigvals)
+
+    def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True):
+        """Ground state Eigenvalue and Eigenvector.
+
+        Defined for quantum operators or superoperators only.
+
+        Parameters
+        ----------
+        sparse : bool
+            Use sparse Eigensolver
+        tol : float
+            Tolerance used by sparse Eigensolver (0 = machine precision).
+            The sparse solver may not converge if the tolerance is set too low.
+        maxiter : int
+            Maximum number of iterations performed by sparse solver (if used).
+        safe : bool (default=True)
+            Check for degenerate ground state
+
+        Returns
+        -------
+        eigval : float
+            Eigenvalue for the ground state of quantum operator.
+        eigvec : :class:`qutip.Qobj`
+            Eigenket for the ground state of quantum operator.
+
+        Notes
+        -----
+        The sparse eigensolver is much slower than the dense version.
+        Use sparse only if memory requirements demand it.
+        """
+        eigvals = 2 if safe else 1
+        evals, evecs = self.eigenstates(sparse=sparse, eigvals=eigvals,
+                                        tol=tol, maxiter=maxiter)
+
+        if safe:
+            tol = tol or settings.core['atol']
+            # This tol should be less strick than the tol for the eigensolver
+            # so it's numerical errors are not seens as degenerate states.
+            if (evals[1]-evals[0]) <= 10 * tol:
+                warnings.warn("Ground state may be degenerate.", UserWarning)
+        return evals[0], evecs[0]
+
+    def dnorm(self, B=None):
+        """Calculates the diamond norm, or the diamond distance to another
+        operator.
+
+        Parameters
+        ----------
+        B : :class:`qutip.Qobj` or None
+            If B is not None, the diamond distance d(A, B) = dnorm(A - B)
+            between this operator and B is returned instead of the diamond norm.
+
+        Returns
+        -------
+        d : float
+            Either the diamond norm of this operator, or the diamond distance
+            from this operator to B.
+
+        """
+        return mts.dnorm(self, B)
+
+    @property
+    def ishp(self):
+        # FIXME: this needs to be cached in the same ways as isherm.
+        if self.type in ["super", "oper"]:
+            try:
+                J = to_choi(self)
+                return J.isherm
+            except:
+                return False
+        else:
+            return False
+
+    @property
+    def iscp(self):
+        # FIXME: this needs to be cached in the same ways as isherm.
+        if self.type not in ["super", "oper"]:
+            return False
+        # We can test with either Choi or chi, since the basis
+        # transformation between them is unitary and hence preserves
+        # the CP and TP conditions.
+        J = self if self.superrep in ('choi', 'chi') else to_choi(self)
+        # If J isn't hermitian, then that could indicate either that J is not
+        # normal, or is normal, but has complex eigenvalues.  In either case,
+        # it makes no sense to then demand that the eigenvalues be
+        # non-negative.
+        return J.isherm and np.all(J.eigenenergies() >= -settings.core['atol'])
+
+    @property
+    def istp(self):
+        if self.type not in ['super', 'oper']:
+            return False
+        # Normalize to a super of type choi or chi.
+        # We can test with either Choi or chi, since the basis
+        # transformation between them is unitary and hence
+        # preserves the CP and TP conditions.
+        if self.issuper and self.superrep in ('choi', 'chi'):
+            qobj = self
+        else:
+            qobj = to_choi(self)
+        # Possibly collapse dims.
+        if any([len(index) > 1
+                for super_index in qobj.dims
+                for index in super_index]):
+            qobj = Qobj(qobj.data,
+                        dims=collapse_dims_super(qobj.dims),
+                        type=qobj.type,
+                        superrep=qobj.superrep,
+                        copy=False)
+        # We use the condition from John Watrous' lecture notes,
+        # Tr_1(J(Phi)) = identity_2.
+        # See: https://cs.uwaterloo.ca/~watrous/LectureNotes.html,
+        # Theory of Quantum Information (Fall 2011), theorem 5.4.
+        tr_oper = qobj.ptrace([0])
+        return np.allclose(tr_oper.full(), np.eye(tr_oper.shape[0]),
+                           atol=settings.core['atol'])
+
+    @property
+    def iscptp(self):
+        if not (self.issuper or self.isoper):
+            return False
+        reps = ('choi', 'chi')
+        q_oper = to_choi(self) if self.superrep not in reps else self
+        return q_oper.iscp and q_oper.istp
+
+    @property
+    def isherm(self):
+        if self._isherm is not None:
+            return self._isherm
+        self._isherm = _data.isherm(self._data)
+        return self._isherm
+
+    @isherm.setter
+    def isherm(self, isherm):
+        self._isherm = isherm
+
+    def _calculate_isunitary(self):
+        """
+        Checks whether qobj is a unitary matrix
+        """
+        if not self.isoper or self._data.shape[0] != self._data.shape[1]:
+            return False
+        cmp = _data.matmul(self._data, self._data.adjoint())
+        iden = _data.identity(self.shape[0], dtype=type(cmp))
+        return _data.iszero(_data.sub(cmp, iden),
+                            tol=settings.core['atol'])
+
+    @property
+    def isunitary(self):
+        if self._isunitary is not None:
+            return self._isunitary
+        self._isunitary = self._calculate_isunitary()
+        return self._isunitary
+
+    @property
+    def shape(self): return self.data.shape
+
+    isbra = property(isbra)
+    isket = property(isket)
+    isoper = property(isoper)
+    issuper = property(issuper)
+    isoperbra = property(isoperbra)
+    isoperket = property(isoperket)
+
+
+def ptrace(Q, sel):
+    """
+    Partial trace of the Qobj with selected components remaining.
+
+    Parameters
+    ----------
+    Q : :class:`qutip.Qobj`
+        Composite quantum object.
+    sel : int/list
+        An ``int`` or ``list`` of components to keep after partial trace.
+
+    Returns
+    -------
+    oper : :class:`qutip.Qobj`
+        Quantum object representing partial trace with selected components
+        remaining.
+
+    Notes
+    -----
+    This function is for legacy compatibility only. It is recommended to use
+    the ``ptrace()`` Qobj method.
+    """
+    if not isinstance(Q, Qobj):
+        raise TypeError("Input is not a quantum object")
+    return Q.ptrace(sel)
+
+
+# TRAILING IMPORTS
+# We do a few imports here to avoid circular dependencies.
+from qutip.core.superop_reps import to_choi
+from qutip.core.superoperator import vector_to_operator, operator_to_vector
+from qutip.core.tensor import tensor_swap, tensor
+from qutip.core import metrics as mts
diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index 6d4be82b1d..c6d3762f22 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -1,208 +1,208 @@
-# -*- coding: utf-8 -*-
-
-"""
-This module implements internal-use functions for semidefinite programming.
-"""
-
-__all__ = [
-    'dnorm_problem',
-    'dnorm_sparse_problem',
-]
-
-import collections
-import functools
-
-import numpy as np
-import scipy.sparse as sp
-# Conditionally import CVXPY
-try:
-    import cvxpy
-except ImportError:
-    cvxpy = None
-
-from .tensor import tensor_swap
-from .operators import qeye
-from ..logging_utils import get_logger
-logger = get_logger('qutip.core.semidefinite')
-
-Complex = collections.namedtuple('Complex', ['re', 'im'])
-
-
-def complex_var(rows=1, cols=1, name=None):
-    return Complex(
-        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
-        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
-    )
-
-
-def herm(*Xs):
-    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
-
-
-def pos_noherm(*Xs):
-    return [
-        cvxpy.bmat([
-            [X.re, -X.im],
-            [X.im, X.re]
-        ]) >> 0
-        for X in Xs
-    ]
-
-
-def pos(*Xs):
-    return pos_noherm(*Xs) + herm(*Xs)
-
-
-def dens(*rhos):
-    return pos(*rhos) + [
-        cvxpy.trace(rho.re) == 1
-        for rho in rhos
-    ]
-
-
-def _arr_to_complex(A):
-    if np.iscomplex(A).any():
-        return Complex(re=A.real, im=A.imag)
-    return Complex(re=A, im=np.zeros_like(A))
-
-
-def kron(A, B):
-    if isinstance(A, np.ndarray):
-        A = _arr_to_complex(A)
-    if isinstance(B, np.ndarray):
-        B = _arr_to_complex(B)
-
-    return Complex(
-        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
-        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
-    )
-
-
-def conj(W, A):
-    U, V = W.re, W.im
-    A, B = A.re, A.im
-    return Complex(
-        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
-        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
-    )
-
-
-def bmat(B):
-    return Complex(
-        re=cvxpy.bmat([[element.re for element in row] for row in B]),
-        im=cvxpy.bmat([[element.re for element in row] for row in B]),
-    )
-
-
-def dag(X):
-    return Complex(re=X.re.T, im=-X.im.T)
-
-
-def memoize(fn):
-    cache = {}
-
-    @functools.wraps(fn)
-    def memoized(*args):
-        if args in cache:
-            return cache[args]
-        else:
-            ret = fn(*args)
-            cache[args] = ret
-            return ret
-
-    memoized.reset_cache = cache.clear
-    return memoized
-
-
-def qudit_swap(dim):
-    # We should likely generalize this and include it in qip.gates.
-    W = qeye([dim, dim])
-    return tensor_swap(W, (0, 1))
-
-
-@memoize
-def initialize_constraints_on_dnorm_problem(dim):
-    # Start assembling constraints and variables.
-    constraints = []
-
-    # Make a complex variable for X.
-    X = complex_var(dim ** 2, dim ** 2, "X")
-
-    # Make complex variables for rho0 and rho1.
-    rho0 = complex_var(dim, dim, "rho0")
-    rho1 = complex_var(dim, dim, "rho1")
-    constraints += dens(rho0, rho1)
-
-    # Finally, add the tricky positive semidefinite constraint.
-    # Since we're using column-stacking, but Watrous used row-stacking,
-    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
-    # as CVXPY requires that the constant be the first argument. To solve this,
-    # We conjugate by SWAP.
-    W = qudit_swap(dim).full()
-    W = Complex(re=W.real, im=W.imag)
-    Rho0 = conj(W, kron(np.eye(dim), rho0))
-    Rho1 = conj(W, kron(np.eye(dim), rho1))
-
-    Y = cvxpy.bmat([
-        [Rho0.re, X.re,      -Rho0.im, -X.im],
-        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
-
-        [Rho0.im, X.im,      Rho0.re, X.re],
-        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
-    ])
-    constraints += [Y >> 0]
-
-    logger.debug("Using %d constraints.", len(constraints))
-
-    return X, constraints
-
-
-def dnorm_problem(dim):
-    X, constraints = initialize_constraints_on_dnorm_problem(dim)
-    Jr = cvxpy.Parameter((dim**2, dim**2))
-    Ji = cvxpy.Parameter((dim**2, dim**2))
-    # The objective, however, depends on J.
-    objective = cvxpy.Maximize(cvxpy.trace(
-        Jr.T @ X.re + Ji.T @ X.im
-    ))
-    problem = cvxpy.Problem(objective, constraints)
-    return problem, Jr, Ji
-
-
-def dnorm_sparse_problem(dim, J_dat):
-    X, constraints = initialize_constraints_on_dnorm_problem(dim)
-    J_val = J_dat.tocoo()
-
-    def adapt_sparse_params(A_val, dim):
-        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
-        # can not solve with parameters that aresparse matrices directly.
-        # Solutions have to be made through calling cvxpy.reshape on
-        # the original sparse matrix.
-        side_size = dim**2
-        A_nnz = cvxpy.Parameter(A_val.nnz)
-
-        A_data = np.ones(A_nnz.size)
-        A_rows = A_val.row * side_size + A_val.col
-        A_cols = np.arange(A_nnz.size)
-        # We are pushing the data on the location of the nonzero elements
-        # to the nonzero rows of A_indexer
-        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
-                                  shape=(side_size**2, A_nnz.size))
-        # We get finaly the sparse matrix A which we wanted
-        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
-        A_nnz.value = A_val.data
-        return A
-
-    Jr_val = J_val.real
-    Jr = adapt_sparse_params(Jr_val, dim)
-
-    Ji_val = J_val.imag
-    Ji = adapt_sparse_params(Ji_val, dim)
-
-    # The objective, however, depends on J.
-    objective = cvxpy.Maximize(cvxpy.trace(
-        Jr.T @ X.re + Ji.T @ X.im
-    ))
-
-    problem = cvxpy.Problem(objective, constraints)
-    return problem
+# -*- coding: utf-8 -*-
+
+"""
+This module implements internal-use functions for semidefinite programming.
+"""
+
+__all__ = [
+    'dnorm_problem',
+    'dnorm_sparse_problem',
+]
+
+import collections
+import functools
+
+import numpy as np
+import scipy.sparse as sp
+# Conditionally import CVXPY
+try:
+    import cvxpy
+except ImportError:
+    cvxpy = None
+
+from .tensor import tensor_swap
+from .operators import qeye
+from ..logging_utils import get_logger
+logger = get_logger('qutip.core.semidefinite')
+
+Complex = collections.namedtuple('Complex', ['re', 'im'])
+
+
+def complex_var(rows=1, cols=1, name=None):
+    return Complex(
+        re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
+        im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
+    )
+
+
+def herm(*Xs):
+    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
+
+
+def pos_noherm(*Xs):
+    return [
+        cvxpy.bmat([
+            [X.re, -X.im],
+            [X.im, X.re]
+        ]) >> 0
+        for X in Xs
+    ]
+
+
+def pos(*Xs):
+    return pos_noherm(*Xs) + herm(*Xs)
+
+
+def dens(*rhos):
+    return pos(*rhos) + [
+        cvxpy.trace(rho.re) == 1
+        for rho in rhos
+    ]
+
+
+def _arr_to_complex(A):
+    if np.iscomplex(A).any():
+        return Complex(re=A.real, im=A.imag)
+    return Complex(re=A, im=np.zeros_like(A))
+
+
+def kron(A, B):
+    if isinstance(A, np.ndarray):
+        A = _arr_to_complex(A)
+    if isinstance(B, np.ndarray):
+        B = _arr_to_complex(B)
+
+    return Complex(
+        re=(cvxpy.kron(A.re, B.re) - cvxpy.kron(A.im, B.im)),
+        im=(cvxpy.kron(A.im, B.re) + cvxpy.kron(A.re, B.im)),
+    )
+
+
+def conj(W, A):
+    U, V = W.re, W.im
+    A, B = A.re, A.im
+    return Complex(
+        re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
+        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
+    )
+
+
+def bmat(B):
+    return Complex(
+        re=cvxpy.bmat([[element.re for element in row] for row in B]),
+        im=cvxpy.bmat([[element.re for element in row] for row in B]),
+    )
+
+
+def dag(X):
+    return Complex(re=X.re.T, im=-X.im.T)
+
+
+def memoize(fn):
+    cache = {}
+
+    @functools.wraps(fn)
+    def memoized(*args):
+        if args in cache:
+            return cache[args]
+        else:
+            ret = fn(*args)
+            cache[args] = ret
+            return ret
+
+    memoized.reset_cache = cache.clear
+    return memoized
+
+
+def qudit_swap(dim):
+    # We should likely generalize this and include it in qip.gates.
+    W = qeye([dim, dim])
+    return tensor_swap(W, (0, 1))
+
+
+@memoize
+def initialize_constraints_on_dnorm_problem(dim):
+    # Start assembling constraints and variables.
+    constraints = []
+
+    # Make a complex variable for X.
+    X = complex_var(dim ** 2, dim ** 2, "X")
+
+    # Make complex variables for rho0 and rho1.
+    rho0 = complex_var(dim, dim, "rho0")
+    rho1 = complex_var(dim, dim, "rho1")
+    constraints += dens(rho0, rho1)
+
+    # Finally, add the tricky positive semidefinite constraint.
+    # Since we're using column-stacking, but Watrous used row-stacking,
+    # we need to swap the order in Rho0 and Rho1. This is not straightforward,
+    # as CVXPY requires that the constant be the first argument. To solve this,
+    # We conjugate by SWAP.
+    W = qudit_swap(dim).full()
+    W = Complex(re=W.real, im=W.imag)
+    Rho0 = conj(W, kron(np.eye(dim), rho0))
+    Rho1 = conj(W, kron(np.eye(dim), rho1))
+
+    Y = cvxpy.bmat([
+        [Rho0.re, X.re,      -Rho0.im, -X.im],
+        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
+
+        [Rho0.im, X.im,      Rho0.re, X.re],
+        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
+    ])
+    constraints += [Y >> 0]
+
+    logger.debug("Using %d constraints.", len(constraints))
+
+    return X, constraints
+
+
+def dnorm_problem(dim):
+    X, constraints = initialize_constraints_on_dnorm_problem(dim)
+    Jr = cvxpy.Parameter((dim**2, dim**2))
+    Ji = cvxpy.Parameter((dim**2, dim**2))
+    # The objective, however, depends on J.
+    objective = cvxpy.Maximize(cvxpy.trace(
+        Jr.T @ X.re + Ji.T @ X.im
+    ))
+    problem = cvxpy.Problem(objective, constraints)
+    return problem, Jr, Ji
+
+
+def dnorm_sparse_problem(dim, J_dat):
+    X, constraints = initialize_constraints_on_dnorm_problem(dim)
+    J_val = J_dat.tocoo()
+
+    def adapt_sparse_params(A_val, dim):
+        # This detour is needed as pointed out in cvxgrp/cvxpy#1159, as cvxpy
+        # can not solve with parameters that aresparse matrices directly.
+        # Solutions have to be made through calling cvxpy.reshape on
+        # the original sparse matrix.
+        side_size = dim**2
+        A_nnz = cvxpy.Parameter(A_val.nnz)
+
+        A_data = np.ones(A_nnz.size)
+        A_rows = A_val.row * side_size + A_val.col
+        A_cols = np.arange(A_nnz.size)
+        # We are pushing the data on the location of the nonzero elements
+        # to the nonzero rows of A_indexer
+        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
+                                  shape=(side_size**2, A_nnz.size))
+        # We get finaly the sparse matrix A which we wanted
+        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
+        A_nnz.value = A_val.data
+        return A
+
+    Jr_val = J_val.real
+    Jr = adapt_sparse_params(Jr_val, dim)
+
+    Ji_val = J_val.imag
+    Ji = adapt_sparse_params(Ji_val, dim)
+
+    # The objective, however, depends on J.
+    objective = cvxpy.Maximize(cvxpy.trace(
+        Jr.T @ X.re + Ji.T @ X.im
+    ))
+
+    problem = cvxpy.Problem(objective, constraints)
+    return problem
diff --git a/qutip/core/states.py b/qutip/core/states.py
index 10d5788ca5..c030e33d0b 100644
--- a/qutip/core/states.py
+++ b/qutip/core/states.py
@@ -1,1342 +1,1342 @@
-__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
-           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
-           'qstate', 'ket', 'bra', 'state_number_enumerate',
-           'state_number_index', 'state_index_number', 'state_number_qobj',
-           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
-           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
-           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
-           'enr_thermal_dm']
-
-import itertools
-import numbers
-import warnings
-
-import numpy as np
-import scipy.sparse as sp
-import itertools
-
-from . import data as _data
-from .qobj import Qobj
-from .operators import jmat, displace, qdiags
-from .tensor import tensor
-from .. import settings
-
-def _promote_to_zero_list(arg, length):
-    """
-    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
-    to `[0]*length`.  All other inputs are checked that they match the correct
-    form.
-
-    Returns
-    -------
-    list_ : list
-        A list of integers of length `length`.
-    """
-    if arg is None:
-        arg = [0]*length
-    elif not isinstance(arg, list):
-        arg = [arg]
-    if not len(arg) == length:
-        raise ValueError("All list inputs must be the same length.")
-    if all(isinstance(x, numbers.Integral) for x in arg):
-        return arg
-    raise TypeError("Dimensions must be an integer or list of integers.")
-
-
-def basis(dimensions, n=None, offset=None, *, dtype=None):
-    """Generates the vector representation of a Fock state.
-
-    Parameters
-    ----------
-    dimensions : int or list of ints
-        Number of Fock states in Hilbert space.  If a list, then the resultant
-        object will be a tensor product over spaces with those dimensions.
-
-    n : int or list of ints, optional (default 0 for all dimensions)
-        Integer corresponding to desired number state, defaults to 0 for all
-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-        of equal length.
-
-    offset : int or list of ints, optional (default 0 for all dimensions)
-        The lowest number state that is included in the finite number state
-        representation of the state in the relevant dimension.
-
-    dtype : type or str
-        storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : :class:`qutip.Qobj`
-      Qobj representing the requested number state ``|n>``.
-
-    Examples
-    --------
-    >>> basis(5,2) # doctest: +SKIP
-    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
-    Qobj data =
-    [[ 0.+0.j]
-     [ 0.+0.j]
-     [ 1.+0.j]
-     [ 0.+0.j]
-     [ 0.+0.j]]
-    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
-    Qobj data =
-    [[0.]
-     [0.]
-     [1.]
-     [0.]
-     [0.]
-     [0.]
-     [0.]
-     [0.]]
-
-
-    Notes
-    -----
-    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
-
-        basis(N, 0) = ground state
-
-    but in the qotoolbox::
-
-        basis(N, 1) = ground state
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    # Promote all parameters to lists to simplify later logic.
-    if not isinstance(dimensions, list):
-        dimensions = [dimensions]
-    n_dimensions = len(dimensions)
-    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
-                                  _promote_to_zero_list(offset, n_dimensions))]
-    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
-        raise ValueError("All dimensions must be >= 0.")
-    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
-        raise ValueError("All basis indices must be "
-                         "`offset <= n < dimension+offset`.")
-    location, size = 0, 1
-    for m, dimension in zip(reversed(ns), reversed(dimensions)):
-        location += m*size
-        size *= dimension
-
-    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
-    return Qobj(data,
-                dims=[dimensions, [1]*n_dimensions],
-                type='ket',
-                isherm=False,
-                isunitary=False,
-                copy=False)
-
-
-def qutrit_basis(*, dtype=None):
-    """Basis states for a three level system (qutrit)
-
-    dtype : type or str
-        storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    qstates : array
-        Array of qutrit basis vectors
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    out = np.empty((3,), dtype=object)
-    out[:] = [
-        basis(3, 0, dtype=dtype),
-        basis(3, 1, dtype=dtype),
-        basis(3, 2, dtype=dtype),
-    ]
-    return out
-
-_COHERENT_METHODS = ('operator', 'analytic')
-
-
-def coherent(N, alpha, offset=0, method=None, *, dtype=None):
-    """Generates a coherent state with eigenvalue alpha.
-
-    Constructed using displacement operator on vacuum state.
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    alpha : float/complex
-        Eigenvalue of coherent state.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the state. Using a non-zero offset will make the
-        default method 'analytic'.
-
-    method : string {'operator', 'analytic'}
-        Method for generating coherent state.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Qobj quantum object for coherent state
-
-    Examples
-    --------
-    >>> coherent(5,0.25j) # doctest: +SKIP
-    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
-    Qobj data =
-    [[  9.69233235e-01+0.j        ]
-     [  0.00000000e+00+0.24230831j]
-     [ -4.28344935e-02+0.j        ]
-     [  0.00000000e+00-0.00618204j]
-     [  7.80904967e-04+0.j        ]]
-
-    Notes
-    -----
-    Select method 'operator' (default) or 'analytic'. With the
-    'operator' method, the coherent state is generated by displacing
-    the vacuum state using the displacement operator defined in the
-    truncated Hilbert space of size 'N'. This method guarantees that the
-    resulting state is normalized. With 'analytic' method the coherent state
-    is generated using the analytical formula for the coherent state
-    coefficients in the Fock basis. This method does not guarantee that the
-    state is normalized if truncated to a small number of Fock states,
-    but would in that case give more accurate coefficients.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    if offset < 0:
-        raise ValueError('Offset must be non-negative')
-
-    if method is None:
-        method = "operator" if offset == 0 else "analytic"
-
-    if method == "operator":
-        if offset != 0:
-            raise ValueError(
-                "The method 'operator' does not support offset != 0. Please"
-                " select another method or set the offset to zero."
-            )
-        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
-
-    elif method == "analytic":
-        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
-        sqrtn[0] = 1  # Get rid of divide by zero warning
-        data = alpha / sqrtn
-        if offset == 0:
-            data[0] = np.exp(-abs(alpha)**2 / 2.0)
-        else:
-            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
-            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
-        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
-        return Qobj(sqrtn,
-                    dims=[[N], [1]],
-                    type='ket',
-                    copy=False).to(dtype)
-    raise TypeError(
-        "The method option can only take values in " + repr(_COHERENT_METHODS)
-    )
-
-
-def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
-    """Density matrix representation of a coherent state.
-
-    Constructed via outer product of :func:`qutip.states.coherent`
-
-    Parameters
-    ----------
-    N : int
-        Number of Fock states in Hilbert space.
-
-    alpha : float/complex
-        Eigenvalue for coherent state.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the state.
-
-    method : string {'operator', 'analytic'}
-        Method for generating coherent density matrix.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Density matrix representation of coherent state.
-
-    Examples
-    --------
-    >>> coherent_dm(3,0.25j) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
-     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
-     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
-        ]]
-
-    Notes
-    -----
-    Select method 'operator' (default) or 'analytic'. With the
-    'operator' method, the coherent density matrix is generated by displacing
-    the vacuum state using the displacement operator defined in the
-    truncated Hilbert space of size 'N'. This method guarantees that the
-    resulting density matrix is normalized. With 'analytic' method the coherent
-    density matrix is generated using the analytical formula for the coherent
-    state coefficients in the Fock basis. This method does not guarantee that
-    the state is normalized if truncated to a small number of Fock states,
-    but would in that case give more accurate coefficients.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
-
-
-def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
-    """Density matrix representation of a Fock state
-
-    Constructed via outer product of :func:`qutip.states.fock`.
-
-    Parameters
-    ----------
-    dimensions : int or list of ints
-        Number of Fock states in Hilbert space.  If a list, then the resultant
-        object will be a tensor product over spaces with those dimensions.
-
-    n : int or list of ints, optional (default 0 for all dimensions)
-        Integer corresponding to desired number state, defaults to 0 for all
-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-        of equal length.
-
-    offset : int or list of ints, optional (default 0 for all dimensions)
-        The lowest number state that is included in the finite number state
-        representation of the state in the relevant dimension.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Density matrix representation of Fock state.
-
-    Examples
-    --------
-     >>> fock_dm(3,1) # doctest: +SKIP
-     Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-     Qobj data =
-     [[ 0.+0.j  0.+0.j  0.+0.j]
-      [ 0.+0.j  1.+0.j  0.+0.j]
-      [ 0.+0.j  0.+0.j  0.+0.j]]
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
-
-
-def fock(dimensions, n=None, offset=None, *, dtype=None):
-    """Bosonic Fock (number) state.
-
-    Same as :func:`qutip.states.basis`.
-
-    Parameters
-    ----------
-    dimensions : int or list of ints
-        Number of Fock states in Hilbert space.  If a list, then the resultant
-        object will be a tensor product over spaces with those dimensions.
-
-    n : int or list of ints, optional (default 0 for all dimensions)
-        Integer corresponding to desired number state, defaults to 0 for all
-        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
-        ``dimensions`` is a list, then ``n`` must either be omitted or a list
-        of equal length.
-
-    offset : int or list of ints, optional (default 0 for all dimensions)
-        The lowest number state that is included in the finite number state
-        representation of the state in the relevant dimension.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-        Requested number state :math:`\\left|n\\right>`.
-
-    Examples
-    --------
-    >>> fock(4,3) # doctest: +SKIP
-    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
-    Qobj data =
-    [[ 0.+0.j]
-     [ 0.+0.j]
-     [ 0.+0.j]
-     [ 1.+0.j]]
-
-    """
-    return basis(dimensions, n, offset=offset, dtype=dtype)
-
-
-def thermal_dm(N, n, method='operator', *, dtype=None):
-    """Density matrix for a thermal state of n particles
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    n : float
-        Expectation value for number of particles in thermal state.
-
-    method : string {'operator', 'analytic'}
-        ``string`` that sets the method used to generate the
-        thermal state probabilities
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Thermal state density matrix.
-
-    Examples
-    --------
-    >>> thermal_dm(5, 1) # doctest: +SKIP
-    Quantum object: dims = [[5], [5]], \
-shape = [5, 5], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.51612903  0.          0.          0.          0.        ]
-     [ 0.          0.25806452  0.          0.          0.        ]
-     [ 0.          0.          0.12903226  0.          0.        ]
-     [ 0.          0.          0.          0.06451613  0.        ]
-     [ 0.          0.          0.          0.          0.03225806]]
-
-
-    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
-    Quantum object: dims = [[5], [5]], \
-shape = [5, 5], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.5      0.       0.       0.       0.     ]
-     [ 0.       0.25     0.       0.       0.     ]
-     [ 0.       0.       0.125    0.       0.     ]
-     [ 0.       0.       0.       0.0625   0.     ]
-     [ 0.       0.       0.       0.       0.03125]]
-
-    Notes
-    -----
-    The 'operator' method (default) generates
-    the thermal state using the truncated number operator ``num(N)``. This
-    is the method that should be used in computations. The
-    'analytic' method uses the analytic coefficients derived in
-    an infinite Hilbert space. The analytic form is not necessarily normalized,
-    if truncated too aggressively.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if n == 0:
-        return fock_dm(N, 0, dtype=dtype)
-    else:
-        i = np.arange(N)
-        if method == 'operator':
-            beta = np.log(1.0 / n + 1.0)
-            diags = np.exp(-beta * i)
-            diags = diags / np.sum(diags)
-            # populates diagonal terms using truncated operator expression
-
-        elif method == 'analytic':
-            # populates diagonal terms using analytic values
-            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
-        else:
-            raise ValueError("The method option can only take "
-                             "values 'operator' or 'analytic'")
-        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
-        out._isherm = True
-        return out
-
-
-def maximally_mixed_dm(N, *, dtype=None):
-    """
-    Returns the maximally mixed density matrix for a Hilbert space of
-    dimension N.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : qobj
-        Thermal state density matrix.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    if not isinstance(N, numbers.Integral) or N <= 0:
-        raise ValueError("N must be integer N > 0")
-    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
-                type='oper', isherm=True, isunitary=(N == 1), copy=False)
-
-
-def ket2dm(Q):
-    """
-    Takes input ket or bra vector and returns density matrix formed by outer
-    product.  This is completely identical to calling `Q.proj()`.
-
-    Parameters
-    ----------
-    Q : qobj
-        Ket or bra type quantum object.
-
-    Returns
-    -------
-    dm : qobj
-        Density matrix formed by outer product of `Q`.
-
-    Examples
-    --------
-    >>> x=basis(3,2)
-    >>> ket2dm(x) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], \
-shape = [3, 3], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j  0.+0.j  0.+0.j]
-     [ 0.+0.j  0.+0.j  0.+0.j]
-     [ 0.+0.j  0.+0.j  1.+0.j]]
-
-    """
-    if Q.isket or Q.isbra:
-        return Q.proj()
-    raise TypeError("Input is not a ket or bra vector.")
-
-
-def projection(N, n, m, offset=None, *, dtype=None):
-    r"""
-    The projection operator that projects state :math:`\lvert m\rangle` on
-    state :math:`\lvert n\rangle`.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis states in Hilbert space.
-
-    n, m : float
-        The number states in the projection.
-
-    offset : int (default 0)
-        The lowest number state that is included in the finite number state
-        representation of the projector.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-         Requested projection operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    return basis(N, n, offset=offset, dtype=dtype) @ \
-           basis(N, m, offset=offset, dtype=dtype).dag()
-
-
-def qstate(string, *, dtype=None):
-    r"""Creates a tensor product for a set of qubits in either
-    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
-
-    Parameters
-    ----------
-    string : str
-        String containing 'u' or 'd' for each qubit (ex. 'ududd')
-
-    Returns
-    -------
-    qstate : qobj
-        Qobj for tensor product corresponding to input string.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Notes
-    -----
-    Look at ket and bra for more general functions
-    creating multiparticle states.
-
-    Examples
-    --------
-    >>> qstate('udu') # doctest: +SKIP
-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    n = len(string)
-    if n != (string.count('u') + string.count('d')):
-        raise TypeError('String input to QSTATE must consist ' +
-                        'of "u" and "d" elements only')
-    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
-
-
-#
-# different qubit notation dictionary
-#
-_qubit_dict = {
-    'g': 0,  # ground state
-    'e': 1,  # excited state
-    'u': 0,  # spin up
-    'd': 1,  # spin down
-    'H': 0,  # horizontal polarization
-    'V': 1,  # vertical polarization
-}
-
-
-def _character_to_qudit(x):
-    """
-    Converts a character representing a one-particle state into int.
-    """
-    return _qubit_dict[x] if x in _qubit_dict else int(x)
-
-
-def ket(seq, dim=2, *, dtype=None):
-    """
-    Produces a multiparticle ket state for a list or string,
-    where each element stands for state of the respective particle.
-
-    Parameters
-    ----------
-    seq : str / list of ints or characters
-        Each element defines state of the respective particle.
-        (e.g. [1,1,0,1] or a string "1101").
-        For qubits it is also possible to use the following conventions:
-        - 'g'/'e' (ground and excited state)
-        - 'u'/'d' (spin up and down)
-        - 'H'/'V' (horizontal and vertical polarization)
-        Note: for dimension > 9 you need to use a list.
-
-
-    dim : int (default: 2) / list of ints
-        Space dimension for each particle:
-        int if there are the same, list if they are different.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    ket : qobj
-
-    Examples
-    --------
-    >>> ket("10") # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]]
-
-    >>> ket("Hue") # doctest: +SKIP
-    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]]
-
-    >>> ket("12", 3) # doctest: +SKIP
-    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]
-     [ 0.]]
-
-    >>> ket("31", [5, 2]) # doctest: +SKIP
-    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
-    Qobj data =
-    [[ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 0.]
-     [ 1.]
-     [ 0.]
-     [ 0.]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    ns = [_character_to_qudit(x) for x in seq]
-    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
-    return basis(dim, ns, dtype=dtype)
-
-
-def bra(seq, dim=2, *, dtype=None):
-    """
-    Produces a multiparticle bra state for a list or string,
-    where each element stands for state of the respective particle.
-
-    Parameters
-    ----------
-    seq : str / list of ints or characters
-        Each element defines state of the respective particle.
-        (e.g. [1,1,0,1] or a string "1101").
-        For qubits it is also possible to use the following conventions:
-
-        - 'g'/'e' (ground and excited state)
-        - 'u'/'d' (spin up and down)
-        - 'H'/'V' (horizontal and vertical polarization)
-
-        Note: for dimension > 9 you need to use a list.
-
-
-    dim : int (default: 2) / list of ints
-        Space dimension for each particle:
-        int if there are the same, list if they are different.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    bra : qobj
-
-    Examples
-    --------
-    >>> bra("10") # doctest: +SKIP
-    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
-    Qobj data =
-    [[ 0.  0.  1.  0.]]
-
-    >>> bra("Hue") # doctest: +SKIP
-    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
-    Qobj data =
-    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
-
-    >>> bra("12", 3) # doctest: +SKIP
-    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
-    Qobj data =
-    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
-
-
-    >>> bra("31", [5, 2]) # doctest: +SKIP
-    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
-    Qobj data =
-    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return ket(seq, dim=dim, dtype=dtype).dag()
-
-
-def state_number_enumerate(dims, excitations=None):
-    """
-    An iterator that enumerates all the state number tuples (quantum numbers of
-    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
-
-    Example:
-
-        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
-        >>>     print(state) # doctest: +SKIP
-        ( 0  0 )
-        ( 0  1 )
-        ( 1  0 )
-        ( 1  1 )
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    excitations : integer (None)
-        Restrict state space to states with excitation numbers below or
-        equal to this value.
-
-    Returns
-    -------
-    state_number : tuple
-        Successive state number tuples that can be used in loops and other
-        iterations, using standard state enumeration *by definition*.
-
-    """
-
-    if excitations is None:
-        # in this case, state numbers are a direct product
-        yield from itertools.product(*(range(d) for d in dims))
-        return
-
-    # From here on, excitations is not None
-
-    # General idea of algorithm: add excitations one by one in last mode (idx =
-    # len(dims)-1), and carry over to the next index when the limit is reached.
-    # Keep track of the number of excitations while doing so to avoid having to
-    # do explicit sums over the states.
-    state = (0,)*len(dims)
-    nexc = 0
-    while True:
-        yield state
-        idx = len(dims) - 1
-        state = state[:idx] + (state[idx]+1,)
-        nexc += 1
-        while nexc > excitations or state[idx] >= dims[idx]:
-            # remove all excitations in mode idx, add one in idx-1
-            idx -= 1
-            if idx < 0:
-                return
-            nexc -= state[idx+1] - 1
-            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
-
-
-def state_number_index(dims, state):
-    """
-    Return the index of a quantum state corresponding to state,
-    given a system with dimensions given by dims.
-
-    Example:
-
-        >>> state_number_index([2, 2, 2], [1, 1, 0])
-        6
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    state : list
-        State number array.
-
-    Returns
-    -------
-    idx : int
-        The index of the state given by `state` in standard enumeration
-        ordering.
-
-    """
-    return np.ravel_multi_index(state, dims)
-
-
-def state_index_number(dims, index):
-    """
-    Return a quantum number representation given a state index, for a system
-    of composite structure defined by dims.
-
-    Example:
-
-        >>> state_index_number([2, 2, 2], 6)
-        [1, 1, 0]
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    index : integer
-        The index of the state in standard enumeration ordering.
-
-    Returns
-    -------
-    state : tuple
-        The state number tuple corresponding to index `index` in standard
-        enumeration ordering.
-
-    """
-    return np.unravel_index(index, dims)
-
-
-def state_number_qobj(dims, state, *, dtype=None):
-    """
-    Return a Qobj representation of a quantum state specified by the state
-    array `state`.
-
-    Example:
-
-        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
-        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
-shape = [8, 1], type = ket
-        Qobj data =
-        [[ 0.]
-         [ 0.]
-         [ 0.]
-         [ 0.]
-         [ 0.]
-         [ 1.]
-         [ 0.]
-         [ 0.]]
-
-    Parameters
-    ----------
-    dims : list or array
-        The quantum state dimensions array, as it would appear in a Qobj.
-
-    state : list
-        State number array.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : :class:`qutip.Qobj`
-        The state as a :class:`qutip.Qobj` instance.
-
-    .. note::
-        Deprecated in QuTiP 5.0, use :func:`basis` instead.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    warnings.warn("basis() is a drop-in replacement for this",
-                  DeprecationWarning)
-    return basis(dims, state, dtype=dtype)
-
-
-# Excitation-number restricted (enr) states
-
-def enr_state_dictionaries(dims, excitations):
-    """
-    Return the number of states, and lookup-dictionaries for translating
-    a state tuple to a state index, and vice versa, for a system with a given
-    number of components and maximum number of excitations.
-
-    Parameters
-    ----------
-    dims: list
-        A list with the number of states in each sub-system.
-
-    excitations : integer
-        The maximum numbers of dimension
-
-    Returns
-    -------
-    nstates, state2idx, idx2state: integer, dict, list
-        The number of states `nstates`, a dictionary for looking up state
-        indices from a state tuple, and a list containing the state tuples
-        ordered by state indices. state2idx and idx2state are reverses of
-        each other, i.e., state2idx[idx2state[idx]] = idx and
-        idx2state[state2idx[state]] = state.
-    """
-    idx2state = list(state_number_enumerate(dims, excitations))
-    state2idx = {state: idx for idx, state in enumerate(idx2state)}
-    nstates = len(idx2state)
-
-    return nstates, state2idx, idx2state
-
-
-def enr_fock(dims, excitations, state, *, dtype=None):
-    """
-    Generate the Fock state representation in a excitation-number restricted
-    state space. The `dims` argument is a list of integers that define the
-    number of quantums states of each component of a composite quantum system,
-    and the `excitations` specifies the maximum number of excitations for
-    the basis states that are to be included in the state space. The `state`
-    argument is a tuple of integers that specifies the state (in the number
-    basis representation) for which to generate the Fock state representation.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    state : list of integers
-        The state in the number basis representation.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    ket : Qobj
-        A Qobj instance that represent a Fock state in the exication-number-
-        restricted state space defined by `dims` and `exciations`.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
-    try:
-        data =_data.one_element[dtype]((nstates, 1),
-                                       (state2idx[tuple(state)], 0), 1)
-    except KeyError:
-        msg = (
-            "The state tuple " + str(tuple(state))
-            + " is not in the restricted state space."
-        )
-        raise ValueError(msg) from None
-    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
-
-
-def enr_thermal_dm(dims, excitations, n, *, dtype=None):
-    """
-    Generate the density operator for a thermal state in the excitation-number-
-    restricted state space defined by the `dims` and `exciations` arguments.
-    See the documentation for enr_fock for a more detailed description of
-    these arguments. The temperature of each mode in dims is specified by
-    the average number of excitatons `n`.
-
-    Parameters
-    ----------
-    dims : list
-        A list of the dimensions of each subsystem of a composite quantum
-        system.
-
-    excitations : integer
-        The maximum number of excitations that are to be included in the
-        state space.
-
-    n : integer
-        The average number of exciations in the thermal state. `n` can be
-        a float (which then applies to each mode), or a list/array of the same
-        length as dims, in which each element corresponds specifies the
-        temperature of the corresponding mode.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    dm : Qobj
-        Thermal state density matrix.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
-    if not isinstance(n, (list, np.ndarray)):
-        n = np.ones(len(dims)) * n
-    else:
-        n = np.asarray(n)
-
-    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
-    diags /= np.sum(diags)
-    out = qdiags(diags, 0, dims=[dims, dims],
-                 shape=(nstates, nstates), dtype=dtype)
-    out._isherm = True
-    return out
-
-
-def phase_basis(N, m, phi0=0, *, dtype=None):
-    """
-    Basis vector for the mth phase of the Pegg-Barnett phase operator.
-
-    Parameters
-    ----------
-    N : int
-        Number of basis vectors in Hilbert space.
-
-    m : int
-        Integer corresponding to the mth discrete phase
-        phi_m = phi0 + 2 * pi * m / N
-
-    phi0 : float (default=0)
-        Reference phase angle.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Ket vector for mth Pegg-Barnett phase operator basis state.
-
-    Notes
-    -----
-    The Pegg-Barnett basis states form a complete set over the truncated
-    Hilbert space.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    phim = phi0 + (2.0 * np.pi * m) / N
-    n = np.arange(N)[:, np.newaxis]
-    data = np.exp(1.0j * n * phim) / np.sqrt(N)
-    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
-
-
-def zero_ket(N, dims=None, *, dtype=None):
-    """
-    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
-
-    Parameters
-    ----------
-    N : int
-        Hilbert space dimensionality
-    dims : list
-        Optional dimensions if ket corresponds to
-        a composite Hilbert space.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    zero_ket : qobj
-        Zero ket on given Hilbert space.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
-
-
-def spin_state(j, m, type='ket', *, dtype=None):
-    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
-    eigenstate of the spin-j Sz operator with eigenvalue m.
-
-    Parameters
-    ----------
-    j : float
-        The spin of the state ().
-
-    m : int
-        Eigenvalue of the spin-j Sz operator.
-
-    type : string {'ket', 'bra', 'dm'}
-        Type of state to generate.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Qobj quantum object for spin state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    J = 2*j + 1
-
-    if type == 'ket':
-        return basis(int(J), int(j - m), dtype=dtype)
-    elif type == 'bra':
-        return basis(int(J), int(j - m), dtype=dtype).dag()
-    elif type == 'dm':
-        return fock_dm(int(J), int(j - m), dtype=dtype)
-    else:
-        raise ValueError(f"Invalid value keyword argument type='{type}'")
-
-
-def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
-    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
-
-    Parameters
-    ----------
-    j : float
-        The spin of the state.
-
-    theta : float
-        Angle from z axis.
-
-    phi : float
-        Angle from x axis.
-
-    type : string {'ket', 'bra', 'dm'}
-        Type of state to generate.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    state : qobj
-        Qobj quantum object for spin coherent state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    if type not in ['ket', 'bra', 'dm']:
-        raise ValueError("Invalid value keyword argument 'type'")
-    Sp = jmat(j, '+')
-    Sm = jmat(j, '-')
-    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
-           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
-           spin_state(j, j)
-
-    if type == 'bra':
-        psi = psi.dag()
-    elif type == 'dm':
-        psi = ket2dm(psi)
-    return psi.to(dtype)
-
-
-_BELL_STATES = {
-    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
-    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
-    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
-    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
-}
-
-def bell_state(state='00', *, dtype=None):
-    r"""
-    Returns the selected Bell state:
-
-    .. math::
-
-        \begin{aligned}
-        \lvert B_{00}\rangle &=
-            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
-        \lvert B_{01}\rangle &=
-            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
-        \lvert B_{10}\rangle &=
-            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
-        \lvert B_{11}\rangle &=
-            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
-        \end{aligned}
-
-
-    Parameters
-    ----------
-    state : str ['00', '01', `10`, `11`]
-        Which bell state to return
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    Bell_state : qobj
-        Bell state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return _BELL_STATES[state].copy().to(dtype)
-
-
-def singlet_state(*, dtype=None):
-    r"""
-    Returns the two particle singlet-state:
-
-    .. math::
-
-        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
-
-    that is identical to the fourth bell state.
-
-    Parameters
-    ----------
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    Bell_state : qobj
-        :math:`\lvert B_{11}\rangle` Bell state
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    return bell_state('11').to(dtype)
-
-
-def triplet_states(*, dtype=None):
-    r"""
-    Returns a list of the two particle triplet-states:
-
-    .. math::
-
-        \lvert T_1\rangle = \lvert11\rangle
-        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
-        \lvert T_3\rangle = \lvert00\rangle
-
-    Parameters
-    ----------
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    trip_states : list
-        2 particle triplet states
-    """
-    return [
-        basis([2, 2], [1, 1], dtype=dtype),
-        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
-                        basis([2, 2], [1, 0], dtype=dtype)),
-        basis([2, 2], [0, 0], dtype=dtype),
-    ]
-
-
-def w_state(N=3, *, dtype=None):
-    """
-    Returns the N-qubit W-state:
-        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
-
-    Parameters
-    ----------
-    N : int (default=3)
-        Number of qubits in state
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    W : :obj:`~Qobj`
-        N-qubit W-state
-    """
-    inds = np.zeros(N, dtype=int)
-    inds[0] = 1
-    state = basis([2]*N, list(inds), dtype=dtype)
-    for kk in range(1, N):
-        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
-    return np.sqrt(1 / N) * state
-
-
-def ghz_state(N=3, *, dtype=None):
-    """
-    Returns the N-qubit GHZ-state:
-        ``[ |00...00> + |11...11> ] / sqrt(2)``
-
-    Parameters
-    ----------
-    N : int (default=3)
-        Number of qubits in state
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    G : qobj
-        N-qubit GHZ-state
-    """
-    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
-                           basis([2]*N, [1]*N, dtype=dtype))
+__all__ = ['basis', 'qutrit_basis', 'coherent', 'coherent_dm', 'fock_dm',
+           'fock', 'thermal_dm', 'maximally_mixed_dm', 'ket2dm', 'projection',
+           'qstate', 'ket', 'bra', 'state_number_enumerate',
+           'state_number_index', 'state_index_number', 'state_number_qobj',
+           'phase_basis', 'zero_ket', 'spin_state', 'spin_coherent',
+           'bell_state', 'singlet_state', 'triplet_states', 'w_state',
+           'ghz_state', 'enr_state_dictionaries', 'enr_fock',
+           'enr_thermal_dm']
+
+import itertools
+import numbers
+import warnings
+
+import numpy as np
+import scipy.sparse as sp
+import itertools
+
+from . import data as _data
+from .qobj import Qobj
+from .operators import jmat, displace, qdiags
+from .tensor import tensor
+from .. import settings
+
+def _promote_to_zero_list(arg, length):
+    """
+    Ensure `arg` is a list of length `length`.  If `arg` is None it is promoted
+    to `[0]*length`.  All other inputs are checked that they match the correct
+    form.
+
+    Returns
+    -------
+    list_ : list
+        A list of integers of length `length`.
+    """
+    if arg is None:
+        arg = [0]*length
+    elif not isinstance(arg, list):
+        arg = [arg]
+    if not len(arg) == length:
+        raise ValueError("All list inputs must be the same length.")
+    if all(isinstance(x, numbers.Integral) for x in arg):
+        return arg
+    raise TypeError("Dimensions must be an integer or list of integers.")
+
+
+def basis(dimensions, n=None, offset=None, *, dtype=None):
+    """Generates the vector representation of a Fock state.
+
+    Parameters
+    ----------
+    dimensions : int or list of ints
+        Number of Fock states in Hilbert space.  If a list, then the resultant
+        object will be a tensor product over spaces with those dimensions.
+
+    n : int or list of ints, optional (default 0 for all dimensions)
+        Integer corresponding to desired number state, defaults to 0 for all
+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+        of equal length.
+
+    offset : int or list of ints, optional (default 0 for all dimensions)
+        The lowest number state that is included in the finite number state
+        representation of the state in the relevant dimension.
+
+    dtype : type or str
+        storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : :class:`qutip.Qobj`
+      Qobj representing the requested number state ``|n>``.
+
+    Examples
+    --------
+    >>> basis(5,2) # doctest: +SKIP
+    Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
+    Qobj data =
+    [[ 0.+0.j]
+     [ 0.+0.j]
+     [ 1.+0.j]
+     [ 0.+0.j]
+     [ 0.+0.j]]
+    >>> basis([2,2,2], [0,1,0]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
+    Qobj data =
+    [[0.]
+     [0.]
+     [1.]
+     [0.]
+     [0.]
+     [0.]
+     [0.]
+     [0.]]
+
+
+    Notes
+    -----
+    A subtle incompatibility with the quantum optics toolbox: In QuTiP::
+
+        basis(N, 0) = ground state
+
+    but in the qotoolbox::
+
+        basis(N, 1) = ground state
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    # Promote all parameters to lists to simplify later logic.
+    if not isinstance(dimensions, list):
+        dimensions = [dimensions]
+    n_dimensions = len(dimensions)
+    ns = [m-off for m, off in zip(_promote_to_zero_list(n, n_dimensions),
+                                  _promote_to_zero_list(offset, n_dimensions))]
+    if any((not isinstance(x, numbers.Integral)) or x < 0 for x in dimensions):
+        raise ValueError("All dimensions must be >= 0.")
+    if not all(0 <= n < dimension for n, dimension in zip(ns, dimensions)):
+        raise ValueError("All basis indices must be "
+                         "`offset <= n < dimension+offset`.")
+    location, size = 0, 1
+    for m, dimension in zip(reversed(ns), reversed(dimensions)):
+        location += m*size
+        size *= dimension
+
+    data = _data.one_element[dtype]((size, 1), (location, 0), 1)
+    return Qobj(data,
+                dims=[dimensions, [1]*n_dimensions],
+                type='ket',
+                isherm=False,
+                isunitary=False,
+                copy=False)
+
+
+def qutrit_basis(*, dtype=None):
+    """Basis states for a three level system (qutrit)
+
+    dtype : type or str
+        storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    qstates : array
+        Array of qutrit basis vectors
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    out = np.empty((3,), dtype=object)
+    out[:] = [
+        basis(3, 0, dtype=dtype),
+        basis(3, 1, dtype=dtype),
+        basis(3, 2, dtype=dtype),
+    ]
+    return out
+
+_COHERENT_METHODS = ('operator', 'analytic')
+
+
+def coherent(N, alpha, offset=0, method=None, *, dtype=None):
+    """Generates a coherent state with eigenvalue alpha.
+
+    Constructed using displacement operator on vacuum state.
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    alpha : float/complex
+        Eigenvalue of coherent state.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the state. Using a non-zero offset will make the
+        default method 'analytic'.
+
+    method : string {'operator', 'analytic'}
+        Method for generating coherent state.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Qobj quantum object for coherent state
+
+    Examples
+    --------
+    >>> coherent(5,0.25j) # doctest: +SKIP
+    Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
+    Qobj data =
+    [[  9.69233235e-01+0.j        ]
+     [  0.00000000e+00+0.24230831j]
+     [ -4.28344935e-02+0.j        ]
+     [  0.00000000e+00-0.00618204j]
+     [  7.80904967e-04+0.j        ]]
+
+    Notes
+    -----
+    Select method 'operator' (default) or 'analytic'. With the
+    'operator' method, the coherent state is generated by displacing
+    the vacuum state using the displacement operator defined in the
+    truncated Hilbert space of size 'N'. This method guarantees that the
+    resulting state is normalized. With 'analytic' method the coherent state
+    is generated using the analytical formula for the coherent state
+    coefficients in the Fock basis. This method does not guarantee that the
+    state is normalized if truncated to a small number of Fock states,
+    but would in that case give more accurate coefficients.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    if offset < 0:
+        raise ValueError('Offset must be non-negative')
+
+    if method is None:
+        method = "operator" if offset == 0 else "analytic"
+
+    if method == "operator":
+        if offset != 0:
+            raise ValueError(
+                "The method 'operator' does not support offset != 0. Please"
+                " select another method or set the offset to zero."
+            )
+        return (displace(N, alpha, dtype=dtype) * basis(N, 0)).to(dtype)
+
+    elif method == "analytic":
+        sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex))
+        sqrtn[0] = 1  # Get rid of divide by zero warning
+        data = alpha / sqrtn
+        if offset == 0:
+            data[0] = np.exp(-abs(alpha)**2 / 2.0)
+        else:
+            s = np.prod(np.sqrt(np.arange(1, offset + 1)))  # sqrt factorial
+            data[0] = np.exp(-abs(alpha)**2 * 0.5) * alpha**offset / s
+        np.cumprod(data, out=sqrtn)  # Reuse sqrtn array
+        return Qobj(sqrtn,
+                    dims=[[N], [1]],
+                    type='ket',
+                    copy=False).to(dtype)
+    raise TypeError(
+        "The method option can only take values in " + repr(_COHERENT_METHODS)
+    )
+
+
+def coherent_dm(N, alpha, offset=0, method='operator', *, dtype=None):
+    """Density matrix representation of a coherent state.
+
+    Constructed via outer product of :func:`qutip.states.coherent`
+
+    Parameters
+    ----------
+    N : int
+        Number of Fock states in Hilbert space.
+
+    alpha : float/complex
+        Eigenvalue for coherent state.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the state.
+
+    method : string {'operator', 'analytic'}
+        Method for generating coherent density matrix.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Density matrix representation of coherent state.
+
+    Examples
+    --------
+    >>> coherent_dm(3,0.25j) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
+     [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
+     [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j\
+        ]]
+
+    Notes
+    -----
+    Select method 'operator' (default) or 'analytic'. With the
+    'operator' method, the coherent density matrix is generated by displacing
+    the vacuum state using the displacement operator defined in the
+    truncated Hilbert space of size 'N'. This method guarantees that the
+    resulting density matrix is normalized. With 'analytic' method the coherent
+    density matrix is generated using the analytical formula for the coherent
+    state coefficients in the Fock basis. This method does not guarantee that
+    the state is normalized if truncated to a small number of Fock states,
+    but would in that case give more accurate coefficients.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return coherent(N, alpha, offset=offset, method=method, dtype=dtype).proj()
+
+
+def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
+    """Density matrix representation of a Fock state
+
+    Constructed via outer product of :func:`qutip.states.fock`.
+
+    Parameters
+    ----------
+    dimensions : int or list of ints
+        Number of Fock states in Hilbert space.  If a list, then the resultant
+        object will be a tensor product over spaces with those dimensions.
+
+    n : int or list of ints, optional (default 0 for all dimensions)
+        Integer corresponding to desired number state, defaults to 0 for all
+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+        of equal length.
+
+    offset : int or list of ints, optional (default 0 for all dimensions)
+        The lowest number state that is included in the finite number state
+        representation of the state in the relevant dimension.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Density matrix representation of Fock state.
+
+    Examples
+    --------
+     >>> fock_dm(3,1) # doctest: +SKIP
+     Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+     Qobj data =
+     [[ 0.+0.j  0.+0.j  0.+0.j]
+      [ 0.+0.j  1.+0.j  0.+0.j]
+      [ 0.+0.j  0.+0.j  0.+0.j]]
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    return basis(dimensions, n, offset=offset, dtype=dtype).proj()
+
+
+def fock(dimensions, n=None, offset=None, *, dtype=None):
+    """Bosonic Fock (number) state.
+
+    Same as :func:`qutip.states.basis`.
+
+    Parameters
+    ----------
+    dimensions : int or list of ints
+        Number of Fock states in Hilbert space.  If a list, then the resultant
+        object will be a tensor product over spaces with those dimensions.
+
+    n : int or list of ints, optional (default 0 for all dimensions)
+        Integer corresponding to desired number state, defaults to 0 for all
+        dimensions if omitted.  The shape must match ``dimensions``, e.g. if
+        ``dimensions`` is a list, then ``n`` must either be omitted or a list
+        of equal length.
+
+    offset : int or list of ints, optional (default 0 for all dimensions)
+        The lowest number state that is included in the finite number state
+        representation of the state in the relevant dimension.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+        Requested number state :math:`\\left|n\\right>`.
+
+    Examples
+    --------
+    >>> fock(4,3) # doctest: +SKIP
+    Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
+    Qobj data =
+    [[ 0.+0.j]
+     [ 0.+0.j]
+     [ 0.+0.j]
+     [ 1.+0.j]]
+
+    """
+    return basis(dimensions, n, offset=offset, dtype=dtype)
+
+
+def thermal_dm(N, n, method='operator', *, dtype=None):
+    """Density matrix for a thermal state of n particles
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    n : float
+        Expectation value for number of particles in thermal state.
+
+    method : string {'operator', 'analytic'}
+        ``string`` that sets the method used to generate the
+        thermal state probabilities
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Thermal state density matrix.
+
+    Examples
+    --------
+    >>> thermal_dm(5, 1) # doctest: +SKIP
+    Quantum object: dims = [[5], [5]], \
+shape = [5, 5], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.51612903  0.          0.          0.          0.        ]
+     [ 0.          0.25806452  0.          0.          0.        ]
+     [ 0.          0.          0.12903226  0.          0.        ]
+     [ 0.          0.          0.          0.06451613  0.        ]
+     [ 0.          0.          0.          0.          0.03225806]]
+
+
+    >>> thermal_dm(5, 1, 'analytic') # doctest: +SKIP
+    Quantum object: dims = [[5], [5]], \
+shape = [5, 5], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.5      0.       0.       0.       0.     ]
+     [ 0.       0.25     0.       0.       0.     ]
+     [ 0.       0.       0.125    0.       0.     ]
+     [ 0.       0.       0.       0.0625   0.     ]
+     [ 0.       0.       0.       0.       0.03125]]
+
+    Notes
+    -----
+    The 'operator' method (default) generates
+    the thermal state using the truncated number operator ``num(N)``. This
+    is the method that should be used in computations. The
+    'analytic' method uses the analytic coefficients derived in
+    an infinite Hilbert space. The analytic form is not necessarily normalized,
+    if truncated too aggressively.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if n == 0:
+        return fock_dm(N, 0, dtype=dtype)
+    else:
+        i = np.arange(N)
+        if method == 'operator':
+            beta = np.log(1.0 / n + 1.0)
+            diags = np.exp(-beta * i)
+            diags = diags / np.sum(diags)
+            # populates diagonal terms using truncated operator expression
+
+        elif method == 'analytic':
+            # populates diagonal terms using analytic values
+            diags = (1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i)
+        else:
+            raise ValueError("The method option can only take "
+                             "values 'operator' or 'analytic'")
+        out = qdiags(diags, 0, dims=[[N], [N]], shape=(N, N), dtype=dtype)
+        out._isherm = True
+        return out
+
+
+def maximally_mixed_dm(N, *, dtype=None):
+    """
+    Returns the maximally mixed density matrix for a Hilbert space of
+    dimension N.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : qobj
+        Thermal state density matrix.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    if not isinstance(N, numbers.Integral) or N <= 0:
+        raise ValueError("N must be integer N > 0")
+    return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],
+                type='oper', isherm=True, isunitary=(N == 1), copy=False)
+
+
+def ket2dm(Q):
+    """
+    Takes input ket or bra vector and returns density matrix formed by outer
+    product.  This is completely identical to calling `Q.proj()`.
+
+    Parameters
+    ----------
+    Q : qobj
+        Ket or bra type quantum object.
+
+    Returns
+    -------
+    dm : qobj
+        Density matrix formed by outer product of `Q`.
+
+    Examples
+    --------
+    >>> x=basis(3,2)
+    >>> ket2dm(x) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], \
+shape = [3, 3], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j  0.+0.j  0.+0.j]
+     [ 0.+0.j  0.+0.j  0.+0.j]
+     [ 0.+0.j  0.+0.j  1.+0.j]]
+
+    """
+    if Q.isket or Q.isbra:
+        return Q.proj()
+    raise TypeError("Input is not a ket or bra vector.")
+
+
+def projection(N, n, m, offset=None, *, dtype=None):
+    r"""
+    The projection operator that projects state :math:`\lvert m\rangle` on
+    state :math:`\lvert n\rangle`.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis states in Hilbert space.
+
+    n, m : float
+        The number states in the projection.
+
+    offset : int (default 0)
+        The lowest number state that is included in the finite number state
+        representation of the projector.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+         Requested projection operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    return basis(N, n, offset=offset, dtype=dtype) @ \
+           basis(N, m, offset=offset, dtype=dtype).dag()
+
+
+def qstate(string, *, dtype=None):
+    r"""Creates a tensor product for a set of qubits in either
+    the 'up' :math:`\lvert0\rangle` or 'down' :math:`\lvert1\rangle` state.
+
+    Parameters
+    ----------
+    string : str
+        String containing 'u' or 'd' for each qubit (ex. 'ududd')
+
+    Returns
+    -------
+    qstate : qobj
+        Qobj for tensor product corresponding to input string.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Notes
+    -----
+    Look at ket and bra for more general functions
+    creating multiparticle states.
+
+    Examples
+    --------
+    >>> qstate('udu') # doctest: +SKIP
+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    n = len(string)
+    if n != (string.count('u') + string.count('d')):
+        raise TypeError('String input to QSTATE must consist ' +
+                        'of "u" and "d" elements only')
+    return basis([2]*n, [1 if x == 'u' else 0 for x in string], dtype=dtype)
+
+
+#
+# different qubit notation dictionary
+#
+_qubit_dict = {
+    'g': 0,  # ground state
+    'e': 1,  # excited state
+    'u': 0,  # spin up
+    'd': 1,  # spin down
+    'H': 0,  # horizontal polarization
+    'V': 1,  # vertical polarization
+}
+
+
+def _character_to_qudit(x):
+    """
+    Converts a character representing a one-particle state into int.
+    """
+    return _qubit_dict[x] if x in _qubit_dict else int(x)
+
+
+def ket(seq, dim=2, *, dtype=None):
+    """
+    Produces a multiparticle ket state for a list or string,
+    where each element stands for state of the respective particle.
+
+    Parameters
+    ----------
+    seq : str / list of ints or characters
+        Each element defines state of the respective particle.
+        (e.g. [1,1,0,1] or a string "1101").
+        For qubits it is also possible to use the following conventions:
+        - 'g'/'e' (ground and excited state)
+        - 'u'/'d' (spin up and down)
+        - 'H'/'V' (horizontal and vertical polarization)
+        Note: for dimension > 9 you need to use a list.
+
+
+    dim : int (default: 2) / list of ints
+        Space dimension for each particle:
+        int if there are the same, list if they are different.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    ket : qobj
+
+    Examples
+    --------
+    >>> ket("10") # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]]
+
+    >>> ket("Hue") # doctest: +SKIP
+    Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]]
+
+    >>> ket("12", 3) # doctest: +SKIP
+    Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]
+     [ 0.]]
+
+    >>> ket("31", [5, 2]) # doctest: +SKIP
+    Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
+    Qobj data =
+    [[ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 0.]
+     [ 1.]
+     [ 0.]
+     [ 0.]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    ns = [_character_to_qudit(x) for x in seq]
+    dim = [dim]*len(ns) if isinstance(dim, numbers.Integral) else dim
+    return basis(dim, ns, dtype=dtype)
+
+
+def bra(seq, dim=2, *, dtype=None):
+    """
+    Produces a multiparticle bra state for a list or string,
+    where each element stands for state of the respective particle.
+
+    Parameters
+    ----------
+    seq : str / list of ints or characters
+        Each element defines state of the respective particle.
+        (e.g. [1,1,0,1] or a string "1101").
+        For qubits it is also possible to use the following conventions:
+
+        - 'g'/'e' (ground and excited state)
+        - 'u'/'d' (spin up and down)
+        - 'H'/'V' (horizontal and vertical polarization)
+
+        Note: for dimension > 9 you need to use a list.
+
+
+    dim : int (default: 2) / list of ints
+        Space dimension for each particle:
+        int if there are the same, list if they are different.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    bra : qobj
+
+    Examples
+    --------
+    >>> bra("10") # doctest: +SKIP
+    Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
+    Qobj data =
+    [[ 0.  0.  1.  0.]]
+
+    >>> bra("Hue") # doctest: +SKIP
+    Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
+    Qobj data =
+    [[ 0.  1.  0.  0.  0.  0.  0.  0.]]
+
+    >>> bra("12", 3) # doctest: +SKIP
+    Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
+    Qobj data =
+    [[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]
+
+
+    >>> bra("31", [5, 2]) # doctest: +SKIP
+    Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
+    Qobj data =
+    [[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return ket(seq, dim=dim, dtype=dtype).dag()
+
+
+def state_number_enumerate(dims, excitations=None):
+    """
+    An iterator that enumerates all the state number tuples (quantum numbers of
+    the form (n1, n2, n3, ...)) for a system with dimensions given by dims.
+
+    Example:
+
+        >>> for state in state_number_enumerate([2,2]): # doctest: +SKIP
+        >>>     print(state) # doctest: +SKIP
+        ( 0  0 )
+        ( 0  1 )
+        ( 1  0 )
+        ( 1  1 )
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    excitations : integer (None)
+        Restrict state space to states with excitation numbers below or
+        equal to this value.
+
+    Returns
+    -------
+    state_number : tuple
+        Successive state number tuples that can be used in loops and other
+        iterations, using standard state enumeration *by definition*.
+
+    """
+
+    if excitations is None:
+        # in this case, state numbers are a direct product
+        yield from itertools.product(*(range(d) for d in dims))
+        return
+
+    # From here on, excitations is not None
+
+    # General idea of algorithm: add excitations one by one in last mode (idx =
+    # len(dims)-1), and carry over to the next index when the limit is reached.
+    # Keep track of the number of excitations while doing so to avoid having to
+    # do explicit sums over the states.
+    state = (0,)*len(dims)
+    nexc = 0
+    while True:
+        yield state
+        idx = len(dims) - 1
+        state = state[:idx] + (state[idx]+1,)
+        nexc += 1
+        while nexc > excitations or state[idx] >= dims[idx]:
+            # remove all excitations in mode idx, add one in idx-1
+            idx -= 1
+            if idx < 0:
+                return
+            nexc -= state[idx+1] - 1
+            state = state[:idx] + (state[idx]+1, 0) + state[idx+2:]
+
+
+def state_number_index(dims, state):
+    """
+    Return the index of a quantum state corresponding to state,
+    given a system with dimensions given by dims.
+
+    Example:
+
+        >>> state_number_index([2, 2, 2], [1, 1, 0])
+        6
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    state : list
+        State number array.
+
+    Returns
+    -------
+    idx : int
+        The index of the state given by `state` in standard enumeration
+        ordering.
+
+    """
+    return np.ravel_multi_index(state, dims)
+
+
+def state_index_number(dims, index):
+    """
+    Return a quantum number representation given a state index, for a system
+    of composite structure defined by dims.
+
+    Example:
+
+        >>> state_index_number([2, 2, 2], 6)
+        [1, 1, 0]
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    index : integer
+        The index of the state in standard enumeration ordering.
+
+    Returns
+    -------
+    state : tuple
+        The state number tuple corresponding to index `index` in standard
+        enumeration ordering.
+
+    """
+    return np.unravel_index(index, dims)
+
+
+def state_number_qobj(dims, state, *, dtype=None):
+    """
+    Return a Qobj representation of a quantum state specified by the state
+    array `state`.
+
+    Example:
+
+        >>> state_number_qobj([2, 2, 2], [1, 0, 1]) # doctest: +SKIP
+        Quantum object: dims = [[2, 2, 2], [1, 1, 1]], \
+shape = [8, 1], type = ket
+        Qobj data =
+        [[ 0.]
+         [ 0.]
+         [ 0.]
+         [ 0.]
+         [ 0.]
+         [ 1.]
+         [ 0.]
+         [ 0.]]
+
+    Parameters
+    ----------
+    dims : list or array
+        The quantum state dimensions array, as it would appear in a Qobj.
+
+    state : list
+        State number array.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : :class:`qutip.Qobj`
+        The state as a :class:`qutip.Qobj` instance.
+
+    .. note::
+        Deprecated in QuTiP 5.0, use :func:`basis` instead.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    warnings.warn("basis() is a drop-in replacement for this",
+                  DeprecationWarning)
+    return basis(dims, state, dtype=dtype)
+
+
+# Excitation-number restricted (enr) states
+
+def enr_state_dictionaries(dims, excitations):
+    """
+    Return the number of states, and lookup-dictionaries for translating
+    a state tuple to a state index, and vice versa, for a system with a given
+    number of components and maximum number of excitations.
+
+    Parameters
+    ----------
+    dims: list
+        A list with the number of states in each sub-system.
+
+    excitations : integer
+        The maximum numbers of dimension
+
+    Returns
+    -------
+    nstates, state2idx, idx2state: integer, dict, list
+        The number of states `nstates`, a dictionary for looking up state
+        indices from a state tuple, and a list containing the state tuples
+        ordered by state indices. state2idx and idx2state are reverses of
+        each other, i.e., state2idx[idx2state[idx]] = idx and
+        idx2state[state2idx[state]] = state.
+    """
+    idx2state = list(state_number_enumerate(dims, excitations))
+    state2idx = {state: idx for idx, state in enumerate(idx2state)}
+    nstates = len(idx2state)
+
+    return nstates, state2idx, idx2state
+
+
+def enr_fock(dims, excitations, state, *, dtype=None):
+    """
+    Generate the Fock state representation in a excitation-number restricted
+    state space. The `dims` argument is a list of integers that define the
+    number of quantums states of each component of a composite quantum system,
+    and the `excitations` specifies the maximum number of excitations for
+    the basis states that are to be included in the state space. The `state`
+    argument is a tuple of integers that specifies the state (in the number
+    basis representation) for which to generate the Fock state representation.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    state : list of integers
+        The state in the number basis representation.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    ket : Qobj
+        A Qobj instance that represent a Fock state in the exication-number-
+        restricted state space defined by `dims` and `exciations`.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    nstates, state2idx, _ = enr_state_dictionaries(dims, excitations)
+    try:
+        data =_data.one_element[dtype]((nstates, 1),
+                                       (state2idx[tuple(state)], 0), 1)
+    except KeyError:
+        msg = (
+            "The state tuple " + str(tuple(state))
+            + " is not in the restricted state space."
+        )
+        raise ValueError(msg) from None
+    return Qobj(data, dims=[dims, [1]*len(dims)], type='ket', copy=False)
+
+
+def enr_thermal_dm(dims, excitations, n, *, dtype=None):
+    """
+    Generate the density operator for a thermal state in the excitation-number-
+    restricted state space defined by the `dims` and `exciations` arguments.
+    See the documentation for enr_fock for a more detailed description of
+    these arguments. The temperature of each mode in dims is specified by
+    the average number of excitatons `n`.
+
+    Parameters
+    ----------
+    dims : list
+        A list of the dimensions of each subsystem of a composite quantum
+        system.
+
+    excitations : integer
+        The maximum number of excitations that are to be included in the
+        state space.
+
+    n : integer
+        The average number of exciations in the thermal state. `n` can be
+        a float (which then applies to each mode), or a list/array of the same
+        length as dims, in which each element corresponds specifies the
+        temperature of the corresponding mode.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    dm : Qobj
+        Thermal state density matrix.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    nstates, _, idx2state = enr_state_dictionaries(dims, excitations)
+    if not isinstance(n, (list, np.ndarray)):
+        n = np.ones(len(dims)) * n
+    else:
+        n = np.asarray(n)
+
+    diags = [np.prod((n / (n + 1)) ** np.array(state)) for state in idx2state]
+    diags /= np.sum(diags)
+    out = qdiags(diags, 0, dims=[dims, dims],
+                 shape=(nstates, nstates), dtype=dtype)
+    out._isherm = True
+    return out
+
+
+def phase_basis(N, m, phi0=0, *, dtype=None):
+    """
+    Basis vector for the mth phase of the Pegg-Barnett phase operator.
+
+    Parameters
+    ----------
+    N : int
+        Number of basis vectors in Hilbert space.
+
+    m : int
+        Integer corresponding to the mth discrete phase
+        phi_m = phi0 + 2 * pi * m / N
+
+    phi0 : float (default=0)
+        Reference phase angle.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Ket vector for mth Pegg-Barnett phase operator basis state.
+
+    Notes
+    -----
+    The Pegg-Barnett basis states form a complete set over the truncated
+    Hilbert space.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    phim = phi0 + (2.0 * np.pi * m) / N
+    n = np.arange(N)[:, np.newaxis]
+    data = np.exp(1.0j * n * phim) / np.sqrt(N)
+    return Qobj(data, dims=[[N], [1]], type='ket', copy=False).to(dtype)
+
+
+def zero_ket(N, dims=None, *, dtype=None):
+    """
+    Creates the zero ket vector with shape Nx1 and dimensions `dims`.
+
+    Parameters
+    ----------
+    N : int
+        Hilbert space dimensionality
+    dims : list
+        Optional dimensions if ket corresponds to
+        a composite Hilbert space.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    zero_ket : qobj
+        Zero ket on given Hilbert space.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return Qobj(_data.zeros[dtype](N, 1), dims=dims, type='ket', copy=False)
+
+
+def spin_state(j, m, type='ket', *, dtype=None):
+    r"""Generates the spin state :math:`\lvert j, m\rangle`, i.e. the
+    eigenstate of the spin-j Sz operator with eigenvalue m.
+
+    Parameters
+    ----------
+    j : float
+        The spin of the state ().
+
+    m : int
+        Eigenvalue of the spin-j Sz operator.
+
+    type : string {'ket', 'bra', 'dm'}
+        Type of state to generate.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Qobj quantum object for spin state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    J = 2*j + 1
+
+    if type == 'ket':
+        return basis(int(J), int(j - m), dtype=dtype)
+    elif type == 'bra':
+        return basis(int(J), int(j - m), dtype=dtype).dag()
+    elif type == 'dm':
+        return fock_dm(int(J), int(j - m), dtype=dtype)
+    else:
+        raise ValueError(f"Invalid value keyword argument type='{type}'")
+
+
+def spin_coherent(j, theta, phi, type='ket', *, dtype=None):
+    r"""Generate the coherent spin state :math:`\lvert \theta, \phi\rangle`.
+
+    Parameters
+    ----------
+    j : float
+        The spin of the state.
+
+    theta : float
+        Angle from z axis.
+
+    phi : float
+        Angle from x axis.
+
+    type : string {'ket', 'bra', 'dm'}
+        Type of state to generate.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    state : qobj
+        Qobj quantum object for spin coherent state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    if type not in ['ket', 'bra', 'dm']:
+        raise ValueError("Invalid value keyword argument 'type'")
+    Sp = jmat(j, '+')
+    Sm = jmat(j, '-')
+    psi = (0.5 * theta * np.exp(1j * phi) * Sm -
+           0.5 * theta * np.exp(-1j * phi) * Sp).expm() * \
+           spin_state(j, j)
+
+    if type == 'bra':
+        psi = psi.dag()
+    elif type == 'dm':
+        psi = ket2dm(psi)
+    return psi.to(dtype)
+
+
+_BELL_STATES = {
+    '00': np.sqrt(0.5) * (basis([2, 2], [0, 0]) + basis([2, 2], [1, 1])),
+    '01': np.sqrt(0.5) * (basis([2, 2], [0, 0]) - basis([2, 2], [1, 1])),
+    '10': np.sqrt(0.5) * (basis([2, 2], [0, 1]) + basis([2, 2], [1, 0])),
+    '11': np.sqrt(0.5) * (basis([2, 2], [0, 1]) - basis([2, 2], [1, 0])),
+}
+
+def bell_state(state='00', *, dtype=None):
+    r"""
+    Returns the selected Bell state:
+
+    .. math::
+
+        \begin{aligned}
+        \lvert B_{00}\rangle &=
+            \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\
+        \lvert B_{01}\rangle &=
+            \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\
+        \lvert B_{10}\rangle &=
+            \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\
+        \lvert B_{11}\rangle &=
+            \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\
+        \end{aligned}
+
+
+    Parameters
+    ----------
+    state : str ['00', '01', `10`, `11`]
+        Which bell state to return
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    Bell_state : qobj
+        Bell state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return _BELL_STATES[state].copy().to(dtype)
+
+
+def singlet_state(*, dtype=None):
+    r"""
+    Returns the two particle singlet-state:
+
+    .. math::
+
+        \lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)
+
+    that is identical to the fourth bell state.
+
+    Parameters
+    ----------
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    Bell_state : qobj
+        :math:`\lvert B_{11}\rangle` Bell state
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    return bell_state('11').to(dtype)
+
+
+def triplet_states(*, dtype=None):
+    r"""
+    Returns a list of the two particle triplet-states:
+
+    .. math::
+
+        \lvert T_1\rangle = \lvert11\rangle
+        \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle)
+        \lvert T_3\rangle = \lvert00\rangle
+
+    Parameters
+    ----------
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    trip_states : list
+        2 particle triplet states
+    """
+    return [
+        basis([2, 2], [1, 1], dtype=dtype),
+        np.sqrt(0.5) * (basis([2, 2], [0, 1], dtype=dtype) +
+                        basis([2, 2], [1, 0], dtype=dtype)),
+        basis([2, 2], [0, 0], dtype=dtype),
+    ]
+
+
+def w_state(N=3, *, dtype=None):
+    """
+    Returns the N-qubit W-state:
+        ``[ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)``
+
+    Parameters
+    ----------
+    N : int (default=3)
+        Number of qubits in state
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    W : :obj:`~Qobj`
+        N-qubit W-state
+    """
+    inds = np.zeros(N, dtype=int)
+    inds[0] = 1
+    state = basis([2]*N, list(inds), dtype=dtype)
+    for kk in range(1, N):
+        state += basis([2]*N, list(np.roll(inds, kk)), dtype=dtype)
+    return np.sqrt(1 / N) * state
+
+
+def ghz_state(N=3, *, dtype=None):
+    """
+    Returns the N-qubit GHZ-state:
+        ``[ |00...00> + |11...11> ] / sqrt(2)``
+
+    Parameters
+    ----------
+    N : int (default=3)
+        Number of qubits in state
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    G : qobj
+        N-qubit GHZ-state
+    """
+    return np.sqrt(0.5) * (basis([2]*N, [0]*N, dtype=dtype) +
+                           basis([2]*N, [1]*N, dtype=dtype))
diff --git a/qutip/core/subsystem_apply.py b/qutip/core/subsystem_apply.py
index ecc237dd6f..013bcbc7d2 100644
--- a/qutip/core/subsystem_apply.py
+++ b/qutip/core/subsystem_apply.py
@@ -1,210 +1,210 @@
-#
-# This code was contributed by Ben Criger. Resemblance to
-# partial_transpose is intentional, and meant to enhance legibility.
-#
-
-__all__ = ['subsystem_apply']
-
-import itertools
-
-import numpy as np
-
-from . import Qobj, qeye, to_kraus, tensor
-from . import data as _data
-
-
-def subsystem_apply(state, channel, mask, reference=False):
-    """
-    Returns the result of applying the propagator `channel` to the
-    subsystems indicated in `mask`, which comprise the density operator
-    `state`.
-
-    Parameters
-    ----------
-    state : :class:`qutip.qobj`
-        A density matrix or ket.
-
-    channel : :class:`qutip.qobj`
-        A propagator, either an `oper` or `super`.
-
-    mask : *list* / *array*
-        A mask that selects which subsystems should be subjected to the
-        channel.
-
-    reference : bool
-        Decides whether explicit Kraus map should be used to evaluate action
-        of channel.
-
-    Returns
-    -------
-    rho_out: :class:`qutip.qobj`
-        A density matrix with the selected subsystems transformed
-        according to the specified channel.
-    """
-    # TODO: Include sparse/dense methods a la partial_transpose.
-    if not (state.isket or state.isoper):
-        raise ValueError("input state must be a ket or oper")
-    if not (channel.issuper or channel.isoper):
-        raise ValueError("input channel must be a super or oper")
-    # Since there's only one channel, all affected subsystems must have
-    # the same dimensions:
-    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
-    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
-           for j in range(len(aff_subs_dim_ar))):
-        raise ValueError("affected subsystems must have the same dimension")
-    # If the map is on the Hilbert space, it must have the same dimension
-    # as the affected subsystem. If it is on the Liouville space, it must
-    # exist on a space as large as the square of the Hilbert dimension.
-    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
-                      else aff_subs_dim_ar[0])
-    if tuple(required_shape) != channel.shape:
-        raise ValueError(
-            "superoperator dimension must be the subsystem dimension squared"
-        )
-    mask = np.asarray(mask)
-    if reference:
-        return _subsystem_apply_reference(state, channel, mask)
-    if state.isoper:
-        return _subsystem_apply_dm(state, channel, mask)
-    return _subsystem_apply_ket(state, channel, mask)
-
-
-def _subsystem_apply_ket(state, channel, mask):
-    # TODO Write more efficient code for single-matrix map on pure states
-    # TODO Write more efficient code for single-subsystem map . . .
-    return _subsystem_apply_dm(state.proj(), channel, mask)
-
-
-def _subsystem_apply_dm(state, channel, mask):
-    """
-    Applies a channel to every subsystem indicated by a mask, by
-    repeatedly applying the channel to each affected subsystem.
-    """
-    # Initialize Output Matrix
-    rho_out = state
-    # checked affected subsystems print arange(len(state.dims[0]))[mask]
-    for subsystem in np.arange(len(state.dims[0]))[mask]:
-        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
-    return rho_out
-
-
-def _one_subsystem_apply(state, channel, idx):
-    """
-    Applies a channel to a state on one subsystem, by breaking it into
-    blocks and applying a reduced channel to each block.
-    """
-    subs_dim_ar = np.array(state.dims).T
-
-    # Calculate number of blocks
-    n_blks = 1
-    for mul_idx in range(idx):
-        n_blks = n_blks * subs_dim_ar[mul_idx][0]
-    blk_sz = state.shape[0] // n_blks
-
-    # Apply channel to top subsystem of each block in matrix
-    full_data_matrix = state.full()
-    for blk_r in range(n_blks):
-        for blk_c in range(n_blks):
-            # Apply channel to high-level blocks of matrix:
-            blk_rx = blk_r * blk_sz
-            blk_cx = blk_c * blk_sz
-
-            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
-                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
-                                              blk_cx : blk_cx+blk_sz],
-                             channel)
-    return Qobj(full_data_matrix, dims=state.dims)
-
-
-def _block_apply(block, channel):
-    return (_top_apply_U(block, channel) if channel.isoper
-            else _top_apply_S(block, channel))
-
-
-def _top_apply_U(block, channel):
-    """
-    Uses scalar-matrix multiplication to efficiently apply a channel to
-    the leftmost register in the tensor product, given a unitary matrix
-    for a channel.
-    """
-    split_mat = _block_split(block, *channel.shape)
-    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
-    for dm_row_idx in range(channel.shape[0]):
-        for dm_col_idx in range(channel.shape[1]):
-            for op_row_idx in range(channel.shape[0]):
-                for op_col_idx in range(channel.shape[1]):
-                    temp_split_mat[dm_row_idx][dm_col_idx] += (
-                        channel[dm_row_idx, op_col_idx]
-                        * channel[dm_col_idx, op_row_idx].conjugate()
-                        * split_mat[op_col_idx][op_row_idx]
-                    )
-    return _block_join(temp_split_mat)
-
-
-def _top_apply_S(block, channel):
-    # If the channel is a super-operator, perform second block decomposition;
-    # block-size matches Hilbert space of affected subsystem:
-    # FIXME use state shape?
-    n_v = int(np.sqrt(channel.shape[0]))
-    n_h = int(np.sqrt(channel.shape[1]))
-    column = _block_col(block, n_v, n_h)
-    chan_mat = channel.full()
-    temp_col = np.zeros(np.shape(column)).astype(complex)
-    for i, row in enumerate(chan_mat):
-        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
-    return _block_stack(temp_col, n_v, n_h)
-
-
-def _block_split(mat_in, n_v, n_h):
-    """
-    Returns a 4D array of matrices, splitting mat_in into
-    n_v * n_h square sub-arrays.
-    """
-    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
-
-
-def _block_join(mat_in):
-    return np.hstack(np.hstack(mat_in))
-
-
-def _block_col(mat_in, n_v, n_h):
-    """
-    Returns a 3D array of matrices, splitting mat_in into
-    n_v * n_h square sub-arrays.
-    """
-    rows, cols = np.shape(mat_in)
-    return np.reshape(
-        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
-        (n_v * n_h, rows // n_v, cols // n_h)
-    )
-
-
-def _block_stack(arr_in, n_v, n_h):
-    """
-    Inverse of _block_split
-    """
-    rs, cs = np.shape(arr_in)[-2:]
-    temp = list(map(np.transpose, arr_in))
-    # print shape(arr_in)
-    temp = np.reshape(temp, (n_v, n_h, rs, cs))
-    return np.hstack(np.hstack(temp)).T
-
-
-def _subsystem_apply_reference(state, channel, mask):
-    state = state.proj() if state.isket else state
-    if channel.isoper:
-        full_oper = tensor([channel if mask_ else qeye(size)
-                            for size, mask_ in zip(state.dims[0], mask)])
-        return full_oper @ state @ full_oper.dag()
-    kraus_list = to_kraus(channel)
-    # Kraus operators to be padded with identities:
-    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
-    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
-    for operator_iter in k_qubit_kraus_list:
-        operator_iter = iter(operator_iter)
-        op_iter_list = [next(operator_iter) if mask[j]
-                        else qeye(state.dims[0][j])
-                        for j in range(len(state.dims[0]))]
-        full_oper = tensor(list(map(Qobj, op_iter_list)))
-        rho_out = rho_out + full_oper * state * full_oper.dag()
-    return rho_out
+#
+# This code was contributed by Ben Criger. Resemblance to
+# partial_transpose is intentional, and meant to enhance legibility.
+#
+
+__all__ = ['subsystem_apply']
+
+import itertools
+
+import numpy as np
+
+from . import Qobj, qeye, to_kraus, tensor
+from . import data as _data
+
+
+def subsystem_apply(state, channel, mask, reference=False):
+    """
+    Returns the result of applying the propagator `channel` to the
+    subsystems indicated in `mask`, which comprise the density operator
+    `state`.
+
+    Parameters
+    ----------
+    state : :class:`qutip.qobj`
+        A density matrix or ket.
+
+    channel : :class:`qutip.qobj`
+        A propagator, either an `oper` or `super`.
+
+    mask : *list* / *array*
+        A mask that selects which subsystems should be subjected to the
+        channel.
+
+    reference : bool
+        Decides whether explicit Kraus map should be used to evaluate action
+        of channel.
+
+    Returns
+    -------
+    rho_out: :class:`qutip.qobj`
+        A density matrix with the selected subsystems transformed
+        according to the specified channel.
+    """
+    # TODO: Include sparse/dense methods a la partial_transpose.
+    if not (state.isket or state.isoper):
+        raise ValueError("input state must be a ket or oper")
+    if not (channel.issuper or channel.isoper):
+        raise ValueError("input channel must be a super or oper")
+    # Since there's only one channel, all affected subsystems must have
+    # the same dimensions:
+    aff_subs_dim_ar = np.transpose(np.array(state.dims))[np.array(mask)]
+    if any((aff_subs_dim_ar[j] != aff_subs_dim_ar[0]).any()
+           for j in range(len(aff_subs_dim_ar))):
+        raise ValueError("affected subsystems must have the same dimension")
+    # If the map is on the Hilbert space, it must have the same dimension
+    # as the affected subsystem. If it is on the Liouville space, it must
+    # exist on a space as large as the square of the Hilbert dimension.
+    required_shape = ([x**2 for x in aff_subs_dim_ar[0]] if channel.issuper
+                      else aff_subs_dim_ar[0])
+    if tuple(required_shape) != channel.shape:
+        raise ValueError(
+            "superoperator dimension must be the subsystem dimension squared"
+        )
+    mask = np.asarray(mask)
+    if reference:
+        return _subsystem_apply_reference(state, channel, mask)
+    if state.isoper:
+        return _subsystem_apply_dm(state, channel, mask)
+    return _subsystem_apply_ket(state, channel, mask)
+
+
+def _subsystem_apply_ket(state, channel, mask):
+    # TODO Write more efficient code for single-matrix map on pure states
+    # TODO Write more efficient code for single-subsystem map . . .
+    return _subsystem_apply_dm(state.proj(), channel, mask)
+
+
+def _subsystem_apply_dm(state, channel, mask):
+    """
+    Applies a channel to every subsystem indicated by a mask, by
+    repeatedly applying the channel to each affected subsystem.
+    """
+    # Initialize Output Matrix
+    rho_out = state
+    # checked affected subsystems print arange(len(state.dims[0]))[mask]
+    for subsystem in np.arange(len(state.dims[0]))[mask]:
+        rho_out = _one_subsystem_apply(rho_out, channel, subsystem)
+    return rho_out
+
+
+def _one_subsystem_apply(state, channel, idx):
+    """
+    Applies a channel to a state on one subsystem, by breaking it into
+    blocks and applying a reduced channel to each block.
+    """
+    subs_dim_ar = np.array(state.dims).T
+
+    # Calculate number of blocks
+    n_blks = 1
+    for mul_idx in range(idx):
+        n_blks = n_blks * subs_dim_ar[mul_idx][0]
+    blk_sz = state.shape[0] // n_blks
+
+    # Apply channel to top subsystem of each block in matrix
+    full_data_matrix = state.full()
+    for blk_r in range(n_blks):
+        for blk_c in range(n_blks):
+            # Apply channel to high-level blocks of matrix:
+            blk_rx = blk_r * blk_sz
+            blk_cx = blk_c * blk_sz
+
+            full_data_matrix[blk_rx : blk_rx+blk_sz, blk_cx : blk_cx+blk_sz] =\
+                _block_apply(full_data_matrix[blk_rx : blk_rx+blk_sz,
+                                              blk_cx : blk_cx+blk_sz],
+                             channel)
+    return Qobj(full_data_matrix, dims=state.dims)
+
+
+def _block_apply(block, channel):
+    return (_top_apply_U(block, channel) if channel.isoper
+            else _top_apply_S(block, channel))
+
+
+def _top_apply_U(block, channel):
+    """
+    Uses scalar-matrix multiplication to efficiently apply a channel to
+    the leftmost register in the tensor product, given a unitary matrix
+    for a channel.
+    """
+    split_mat = _block_split(block, *channel.shape)
+    temp_split_mat = np.zeros(np.shape(split_mat)).astype(complex)
+    for dm_row_idx in range(channel.shape[0]):
+        for dm_col_idx in range(channel.shape[1]):
+            for op_row_idx in range(channel.shape[0]):
+                for op_col_idx in range(channel.shape[1]):
+                    temp_split_mat[dm_row_idx][dm_col_idx] += (
+                        channel[dm_row_idx, op_col_idx]
+                        * channel[dm_col_idx, op_row_idx].conjugate()
+                        * split_mat[op_col_idx][op_row_idx]
+                    )
+    return _block_join(temp_split_mat)
+
+
+def _top_apply_S(block, channel):
+    # If the channel is a super-operator, perform second block decomposition;
+    # block-size matches Hilbert space of affected subsystem:
+    # FIXME use state shape?
+    n_v = int(np.sqrt(channel.shape[0]))
+    n_h = int(np.sqrt(channel.shape[1]))
+    column = _block_col(block, n_v, n_h)
+    chan_mat = channel.full()
+    temp_col = np.zeros(np.shape(column)).astype(complex)
+    for i, row in enumerate(chan_mat):
+        temp_col[i] = sum(s * mat for s, mat in zip(row.T, column))
+    return _block_stack(temp_col, n_v, n_h)
+
+
+def _block_split(mat_in, n_v, n_h):
+    """
+    Returns a 4D array of matrices, splitting mat_in into
+    n_v * n_h square sub-arrays.
+    """
+    return [np.hsplit(x, n_h) for x in np.vsplit(mat_in, n_v)]
+
+
+def _block_join(mat_in):
+    return np.hstack(np.hstack(mat_in))
+
+
+def _block_col(mat_in, n_v, n_h):
+    """
+    Returns a 3D array of matrices, splitting mat_in into
+    n_v * n_h square sub-arrays.
+    """
+    rows, cols = np.shape(mat_in)
+    return np.reshape(
+        np.array(_block_split(mat_in, n_v, n_h)).transpose(1, 0, 2, 3),
+        (n_v * n_h, rows // n_v, cols // n_h)
+    )
+
+
+def _block_stack(arr_in, n_v, n_h):
+    """
+    Inverse of _block_split
+    """
+    rs, cs = np.shape(arr_in)[-2:]
+    temp = list(map(np.transpose, arr_in))
+    # print shape(arr_in)
+    temp = np.reshape(temp, (n_v, n_h, rs, cs))
+    return np.hstack(np.hstack(temp)).T
+
+
+def _subsystem_apply_reference(state, channel, mask):
+    state = state.proj() if state.isket else state
+    if channel.isoper:
+        full_oper = tensor([channel if mask_ else qeye(size)
+                            for size, mask_ in zip(state.dims[0], mask)])
+        return full_oper @ state @ full_oper.dag()
+    kraus_list = to_kraus(channel)
+    # Kraus operators to be padded with identities:
+    k_qubit_kraus_list = itertools.product(kraus_list, repeat=np.sum(mask))
+    rho_out = Qobj(_data.csr.zeros(*state.shape), dims=state.dims)
+    for operator_iter in k_qubit_kraus_list:
+        operator_iter = iter(operator_iter)
+        op_iter_list = [next(operator_iter) if mask[j]
+                        else qeye(state.dims[0][j])
+                        for j in range(len(state.dims[0]))]
+        full_oper = tensor(list(map(Qobj, op_iter_list)))
+        rho_out = rho_out + full_oper * state * full_oper.dag()
+    return rho_out
diff --git a/qutip/core/superop_reps.py b/qutip/core/superop_reps.py
index 10fdda0fdb..c48f05fd1a 100644
--- a/qutip/core/superop_reps.py
+++ b/qutip/core/superop_reps.py
@@ -1,522 +1,522 @@
-# -*- coding: utf-8 -*-
-#
-# This module was initially contributed by Ben Criger.
-#
-"""
-This module implements transformations between superoperator representations,
-including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
-"""
-
-__all__ = [
-    'kraus_to_choi', 'kraus_to_super',
-    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
-]
-
-import itertools
-import numbers
-
-import numpy as np
-import scipy.linalg
-
-from . import data as _data
-from .superoperator import stack_columns, unstack_columns, sprepost
-from .tensor import tensor
-from .dimensions import flatten
-from .qobj import Qobj
-from .operators import identity, sigmax, sigmay, sigmaz
-from .states import basis
-
-
-# TODO: revisit when creation routines have dispatching.
-_SINGLE_QUBIT_PAULI_BASIS = (
-    identity(2).to(_data.CSR),
-    sigmax().to(_data.CSR),
-    sigmay().to(_data.CSR),
-    sigmaz().to(_data.CSR),
-)
-
-
-def _superpauli_basis(nq=1):
-    dims = [[[2] * nq] * 2] * 2
-    nnz = 8**nq
-    data = _data.csr.empty(4**nq, 4**nq, nnz)
-    sci = data.as_scipy(full=True)
-    ptr, ptr_inc = 0, 2**nq
-    # Construct the Pauli basis by vertically stacking rows in sparse format.
-    # The CSR format is much more efficient at handling row-stacking, so we
-    # actually have to do a little dance through adjoint/transpose to get it
-    # into the right format.
-    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
-                                                 repeat=nq)):
-        basis = paulis[0].data
-        for pauli in paulis[1:]:
-            basis = _data.kron_csr(basis, pauli.data)
-        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
-        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
-        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
-        sci.indptr[i] = ptr
-        ptr += ptr_inc
-    sci.indptr[-1] = nnz
-    return Qobj(data.adjoint(),
-                dims=dims,
-                type='super',
-                superrep='super',
-                isherm=False,
-                isunitary=False,
-                copy=False)
-
-
-def _int_log_two(x):
-    return int(x).bit_length() - 1
-
-
-def _is_power_of_two(x):
-    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
-
-
-def _nq(dims):
-    dim = np.prod(dims[0][0])
-    nq = _int_log_two(dim)
-    if 2 ** nq != dim:
-        raise ValueError("{} is not an integer power of 2.".format(dim))
-    return nq
-
-
-def isqubitdims(dims):
-    """
-    Checks whether all entries in a dims list are integer powers of 2.
-
-    Parameters
-    ----------
-    dims : nested list of ints
-        Dimensions to be checked.
-
-    Returns
-    -------
-    isqubitdims : bool
-        True if and only if every member of the flattened dims
-        list is an integer power of 2.
-    """
-    return all(_is_power_of_two(dim) for dim in flatten(dims))
-
-
-def _to_superpauli(q_oper):
-    """
-    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
-
-    This is an internal function, as QuTiP does not currently have
-    a way to mark that superoperators are represented in the Pauli
-    basis as opposed to the column-stacking basis; a Pauli-basis
-    ``type='super'`` would thus break other conversion functions.
-    """
-    # Ensure we start with a column-stacking-basis superoperator.
-    sqobj = to_super(q_oper)
-    if not isqubitdims(sqobj.dims):
-        raise ValueError("Pauli basis is only defined for qubits.")
-    nq = _int_log_two(sqobj.shape[0]) // 2
-    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
-    # To do this, we have to hack a bit and force the dims to match,
-    # since the superpauli_basis function makes different assumptions
-    # about indices than we need here.
-    B.dims = sqobj.dims
-    return B.dag() @ sqobj @ B
-
-
-def _choi_to_kraus(q_oper, tol=1e-9):
-    """
-    Takes a Choi matrix and returns a list of Kraus operators.
-    TODO: Create a new class structure for quantum channels, perhaps as a
-    strict sub-class of Qobj.
-    """
-    vals, vecs = q_oper.eigenstates()
-    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
-    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
-    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
-                 dims=dims, type='oper', copy='False')
-            for val, vec in zip(vals, vecs) if abs(val) >= tol]
-
-
-# Individual conversions from Kraus operators are public because the output
-# list of Kraus operators is not itself a quantum object.
-
-def kraus_to_choi(kraus_list):
-    """
-    Take a list of Kraus operators and returns the Choi matrix for the channel
-    represented by the Kraus operators in `kraus_list`
-    """
-    kraus_mat_list = [k.full() for k in kraus_list]
-    op_rng = list(range(kraus_mat_list[0].shape[1]))
-    choi_blocks = np.array(
-        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
-              for op in kraus_mat_list)
-          for r_ix in op_rng]
-         for c_ix in op_rng]
-    )
-    return Qobj(np.hstack(np.hstack(choi_blocks)),
-                dims=[kraus_list[0].dims[::-1]]*2,
-                type='super',
-                superrep='choi',
-                copy=False)
-
-
-def kraus_to_super(kraus_list):
-    """
-    Convert a list of Kraus operators to a superoperator.
-    """
-    return to_super(kraus_to_choi(kraus_list))
-
-
-def _super_tofrom_choi(q_oper):
-    """
-    We exploit that the basis transformation between Choi and supermatrix
-    representations squares to the identity, so that if we munge Qobj.type,
-    we can use the same function.
-    """
-    if not q_oper.issuper:
-        raise ValueError("needs to be a superoperator")
-    if q_oper.superrep not in ('super', 'choi'):
-        raise ValueError("operator is not in super or choi format")
-    data = q_oper.data.to_array()
-    dims = q_oper.dims
-    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
-    d0 = np.prod(flatten(new_dims[0]))
-    d1 = np.prod(flatten(new_dims[1]))
-    s0 = np.prod(dims[0][0])
-    s1 = np.prod(dims[1][1])
-    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
-    return Qobj(data,
-                dims=new_dims,
-                type='super',
-                superrep='super' if q_oper.superrep == 'choi' else 'choi',
-                copy=False)
-
-
-def _choi_to_chi(q_oper):
-    """
-    Converts a Choi matrix to a Chi matrix in the Pauli basis.
-
-    NOTE: this is only supported for qubits right now. Need to extend to
-    Heisenberg-Weyl for other subsystem dimensions.
-    """
-    nq = _nq(q_oper.dims)
-    B = _superpauli_basis(nq).data
-    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
-                dims=q_oper.dims,
-                type='super',
-                superrep='chi',
-                copy=False)
-
-
-def _chi_to_choi(q_oper):
-    """
-    Converts a Chi matrix to a Choi matrix.
-
-    NOTE: this is only supported for qubits right now. Need to extend to
-    Heisenberg-Weyl for other subsystem dimensions.
-    """
-    nq = _nq(q_oper.dims)
-    B = _superpauli_basis(nq).data
-    # The Chi matrix has tr(chi) == d², so we need to divide out
-    # by that to get back to the Choi form.
-    return Qobj(_data.mul(
-                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
-                    1 / q_oper.shape[0]
-                ),
-                dims=q_oper.dims,
-                type='super',
-                superrep='choi',
-                copy=False)
-
-
-def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
-    """
-    Given a partial isometry U and a vector of square-roots of singular values
-    S obtained from a SVD, produces the Kraus operators represented by U.
-
-    Returns
-    -------
-    Ks : list of Qobj
-        Quantum objects represnting each of the Kraus operators.
-    """
-    # We use U * S since S is 1-index, such that this is equivalent to
-    # U . diag(S), but easier to write down.
-    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
-    return [
-        Qobj(x,
-             dims=[outdims, indims],
-             type='oper',
-             copy=False)
-        for x in data
-    ]
-
-
-def _generalized_kraus(q_oper, threshold=1e-10):
-    # TODO: document!
-    # TODO: use this to generalize to_kraus to the case where U != V.
-    #       This is critical for non-CP maps, as appear in (for example)
-    #       diamond norm differences between two CP maps.
-    if not q_oper.issuper or q_oper.superrep != "choi":
-        raise ValueError("".join([
-            "Expected a Choi matrix, got a ", repr(q_oper.type),
-            " (superrep ", repr(q_oper.superrep), ")."
-        ]))
-
-    # Remember the shape of the underlying space,
-    # as we'll need this to make Kraus operators later.
-    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
-    # Also remember the dims breakout.
-    out_dims, in_dims = q_oper.dims
-    out_left, out_right = out_dims
-    in_left, in_right = in_dims
-
-    # Find the SVD.
-    U, S, V = scipy.linalg.svd(q_oper.full())
-
-    # Truncate away the zero singular values, up to a threshold.
-    nonzero_idxs = S > threshold
-    dK = nonzero_idxs.sum()
-    U = np.array(U)[:, nonzero_idxs]
-    # We also want S to be a single index array, which np.matrix
-    # doesn't allow for. This is stripped by calling array() on it.
-    S = np.sqrt(np.array(S)[nonzero_idxs])
-    # Since NumPy returns V and not V+, we need to take the dagger
-    # to get back to quantum info notation for Stinespring pairs.
-    V = np.array(V.conj().T)[:, nonzero_idxs]
-
-    # Next, we convert each of U and V into Kraus operators.
-    # Finally, we want the Kraus index to be left-most so that we
-    # can map over it when making Qobjs.
-    # FIXME: does not preserve dims!
-    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
-    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
-
-    return kU, kV
-
-
-def _choi_to_stinespring(q_oper, threshold=1e-10):
-    # TODO: document!
-    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
-
-    assert len(kU) == len(kV)
-    dK = len(kU)
-    dL = kU[0].shape[0]
-    dR = kV[0].shape[1]
-    # Also remember the dims breakout.
-    out_dims, in_dims = q_oper.dims
-    out_left, out_right = out_dims
-    in_left, in_right = in_dims
-
-    A = Qobj(_data.zeros(dK * dL, dL),
-             dims=[out_left + [dK], out_right + [1]],
-             type='oper',
-             isherm=True,
-             isunitary=False,
-             copy=False)
-    B = Qobj(_data.zeros(dK * dR, dR),
-             dims=[in_left + [dK], in_right + [1]],
-             type='oper',
-             isherm=True,
-             isunitary=False,
-             copy=False)
-
-    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
-        A += tensor(KL, basis(dK, idx_kraus))
-        B += tensor(KR, basis(dK, idx_kraus))
-
-    # There is no input (right) Kraus index, so strip that off.
-    del A.dims[1][-1]
-    del B.dims[1][-1]
-
-    return A, B
-
-
-def to_choi(q_oper):
-    """
-    Converts a Qobj representing a quantum map to the Choi representation,
-    such that the trace of the returned operator is equal to the dimension
-    of the system.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to Choi representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
-
-    Returns
-    -------
-    choi : Qobj
-        A quantum object representing the same map as ``q_oper``, such that
-        ``choi.superrep == "choi"``.
-
-    Raises
-    ------
-    TypeError: if the given quantum object is not a map, or cannot be converted
-        to Choi representation.
-    """
-    if q_oper.type == 'super':
-        if q_oper.superrep == 'choi':
-            return q_oper
-        if q_oper.superrep == 'super':
-            return _super_tofrom_choi(q_oper)
-        if q_oper.superrep == 'chi':
-            return _chi_to_choi(q_oper)
-        else:
-            raise TypeError(q_oper.superrep)
-    elif q_oper.type == 'oper':
-        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
-    else:
-        raise TypeError(
-            "Conversion of Qobj with type = {0.type} "
-            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
-        )
-
-
-def to_chi(q_oper):
-    """
-    Converts a Qobj representing a quantum map to a representation as a chi
-    (process) matrix in the Pauli basis, such that the trace of the returned
-    operator is equal to the dimension of the system.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to Chi representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
-
-    Returns
-    -------
-    chi : Qobj
-        A quantum object representing the same map as ``q_oper``, such that
-        ``chi.superrep == "chi"``.
-
-    Raises
-    ------
-    TypeError: if the given quantum object is not a map, or cannot be converted
-        to Chi representation.
-    """
-    if q_oper.type == 'super':
-        if q_oper.superrep == 'chi':
-            return q_oper
-        elif q_oper.superrep == 'choi':
-            return _choi_to_chi(q_oper)
-        elif q_oper.superrep == 'super':
-            return _choi_to_chi(to_choi(q_oper))
-        else:
-            raise TypeError(q_oper.superrep)
-    elif q_oper.type == 'oper':
-        return to_chi(sprepost(q_oper, q_oper.dag()))
-    else:
-        raise TypeError(
-            "Conversion of Qobj with type = {0.type} "
-            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
-        )
-
-
-def to_super(q_oper):
-    """
-    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
-    representation.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to supermatrix representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_super(A) == sprepost(A, A.dag())``.
-
-    Returns
-    -------
-    superop : Qobj
-        A quantum object representing the same map as ``q_oper``, such that
-        ``superop.superrep == "super"``.
-
-    Raises
-    ------
-    TypeError
-        If the given quantum object is not a map, or cannot be converted
-        to supermatrix representation.
-    """
-    if q_oper.type == 'super':
-        if q_oper.superrep == "super":
-            return q_oper
-        elif q_oper.superrep == 'choi':
-            return _super_tofrom_choi(q_oper)
-        elif q_oper.superrep == 'chi':
-            return to_super(to_choi(q_oper))
-        else:
-            raise ValueError(
-                "Unrecognized superrep '{}'.".format(q_oper.superrep))
-    elif q_oper.type == 'oper':  # Assume unitary
-        return sprepost(q_oper, q_oper.dag())
-    else:
-        raise TypeError(
-            "Conversion of Qobj with type = {0.type} "
-            "and superrep = {0.superrep} to supermatrix not "
-            "supported.".format(q_oper)
-        )
-
-
-def to_kraus(q_oper, tol=1e-9):
-    """
-    Converts a Qobj representing a quantum map to a list of quantum objects,
-    each representing an operator in the Kraus decomposition of the given map.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to Kraus representation. If
-        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
-        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
-
-    tol : Float
-        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
-        The default is to=1e-9.
-
-    Returns
-    -------
-    kraus_ops : list of Qobj
-        A list of quantum objects, each representing a Kraus operator in the
-        decomposition of ``q_oper``.
-
-    Raises
-    ------
-    TypeError: if the given quantum object is not a map, or cannot be
-        decomposed into Kraus operators.
-    """
-    if q_oper.issuper:
-        if q_oper.superrep != 'choi':
-            q_oper = to_choi(q_oper)
-        return _choi_to_kraus(q_oper, tol)
-    elif q_oper.isoper:  # Assume unitary
-        return [q_oper]
-    raise TypeError(
-        "Conversion of Qobj with type={0.type} "
-        "and superrep={0.superrep} to Kraus decomposition not "
-        "supported.".format(q_oper)
-    )
-
-
-def to_stinespring(q_oper, threshold=1e-10):
-    r"""
-    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
-    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
-    all inputs $X$, where the partial trace is taken over a a new index on the
-    output dimensions of $A$ and $B$.
-
-    For completely positive inputs, $A$ will always equal $B$ up to precision
-    errors.
-
-    Parameters
-    ----------
-    q_oper : Qobj
-        Superoperator to be converted to a Stinespring pair.
-
-    Returns
-    -------
-    A, B : Qobj
-        Quantum objects representing each of the Stinespring matrices for the
-        input Qobj.
-    """
-    return _choi_to_stinespring(to_choi(q_oper), threshold)
+# -*- coding: utf-8 -*-
+#
+# This module was initially contributed by Ben Criger.
+#
+"""
+This module implements transformations between superoperator representations,
+including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.
+"""
+
+__all__ = [
+    'kraus_to_choi', 'kraus_to_super',
+    'to_choi', 'to_chi', 'to_super', 'to_kraus', 'to_stinespring',
+]
+
+import itertools
+import numbers
+
+import numpy as np
+import scipy.linalg
+
+from . import data as _data
+from .superoperator import stack_columns, unstack_columns, sprepost
+from .tensor import tensor
+from .dimensions import flatten
+from .qobj import Qobj
+from .operators import identity, sigmax, sigmay, sigmaz
+from .states import basis
+
+
+# TODO: revisit when creation routines have dispatching.
+_SINGLE_QUBIT_PAULI_BASIS = (
+    identity(2).to(_data.CSR),
+    sigmax().to(_data.CSR),
+    sigmay().to(_data.CSR),
+    sigmaz().to(_data.CSR),
+)
+
+
+def _superpauli_basis(nq=1):
+    dims = [[[2] * nq] * 2] * 2
+    nnz = 8**nq
+    data = _data.csr.empty(4**nq, 4**nq, nnz)
+    sci = data.as_scipy(full=True)
+    ptr, ptr_inc = 0, 2**nq
+    # Construct the Pauli basis by vertically stacking rows in sparse format.
+    # The CSR format is much more efficient at handling row-stacking, so we
+    # actually have to do a little dance through adjoint/transpose to get it
+    # into the right format.
+    for i, paulis in enumerate(itertools.product(_SINGLE_QUBIT_PAULI_BASIS,
+                                                 repeat=nq)):
+        basis = paulis[0].data
+        for pauli in paulis[1:]:
+            basis = _data.kron_csr(basis, pauli.data)
+        basis_ket_sci = _data.column_stack_csr(basis).transpose().as_scipy()
+        sci.data[ptr : ptr+ptr_inc] = basis_ket_sci.data
+        sci.indices[ptr : ptr+ptr_inc] = basis_ket_sci.indices
+        sci.indptr[i] = ptr
+        ptr += ptr_inc
+    sci.indptr[-1] = nnz
+    return Qobj(data.adjoint(),
+                dims=dims,
+                type='super',
+                superrep='super',
+                isherm=False,
+                isunitary=False,
+                copy=False)
+
+
+def _int_log_two(x):
+    return int(x).bit_length() - 1
+
+
+def _is_power_of_two(x):
+    return isinstance(x, numbers.Integral) and x == 2**_int_log_two(x)
+
+
+def _nq(dims):
+    dim = np.prod(dims[0][0])
+    nq = _int_log_two(dim)
+    if 2 ** nq != dim:
+        raise ValueError("{} is not an integer power of 2.".format(dim))
+    return nq
+
+
+def isqubitdims(dims):
+    """
+    Checks whether all entries in a dims list are integer powers of 2.
+
+    Parameters
+    ----------
+    dims : nested list of ints
+        Dimensions to be checked.
+
+    Returns
+    -------
+    isqubitdims : bool
+        True if and only if every member of the flattened dims
+        list is an integer power of 2.
+    """
+    return all(_is_power_of_two(dim) for dim in flatten(dims))
+
+
+def _to_superpauli(q_oper):
+    """
+    Convert a superoperator to the Pauli basis (assuming qubit dimensions).
+
+    This is an internal function, as QuTiP does not currently have
+    a way to mark that superoperators are represented in the Pauli
+    basis as opposed to the column-stacking basis; a Pauli-basis
+    ``type='super'`` would thus break other conversion functions.
+    """
+    # Ensure we start with a column-stacking-basis superoperator.
+    sqobj = to_super(q_oper)
+    if not isqubitdims(sqobj.dims):
+        raise ValueError("Pauli basis is only defined for qubits.")
+    nq = _int_log_two(sqobj.shape[0]) // 2
+    B = _superpauli_basis(nq) * 2**(-0.5 * nq)
+    # To do this, we have to hack a bit and force the dims to match,
+    # since the superpauli_basis function makes different assumptions
+    # about indices than we need here.
+    B.dims = sqobj.dims
+    return B.dag() @ sqobj @ B
+
+
+def _choi_to_kraus(q_oper, tol=1e-9):
+    """
+    Takes a Choi matrix and returns a list of Kraus operators.
+    TODO: Create a new class structure for quantum channels, perhaps as a
+    strict sub-class of Qobj.
+    """
+    vals, vecs = q_oper.eigenstates()
+    dims = [q_oper.dims[0][1], q_oper.dims[0][0]]
+    shape = (np.prod(q_oper.dims[0][1]), np.prod(q_oper.dims[0][0]))
+    return [Qobj(_data.mul(unstack_columns(vec.data, shape=shape), np.sqrt(val)),
+                 dims=dims, type='oper', copy='False')
+            for val, vec in zip(vals, vecs) if abs(val) >= tol]
+
+
+# Individual conversions from Kraus operators are public because the output
+# list of Kraus operators is not itself a quantum object.
+
+def kraus_to_choi(kraus_list):
+    """
+    Take a list of Kraus operators and returns the Choi matrix for the channel
+    represented by the Kraus operators in `kraus_list`
+    """
+    kraus_mat_list = [k.full() for k in kraus_list]
+    op_rng = list(range(kraus_mat_list[0].shape[1]))
+    choi_blocks = np.array(
+        [[sum(op[:, c_ix, None] @ np.conj(op[None, :, r_ix])
+              for op in kraus_mat_list)
+          for r_ix in op_rng]
+         for c_ix in op_rng]
+    )
+    return Qobj(np.hstack(np.hstack(choi_blocks)),
+                dims=[kraus_list[0].dims[::-1]]*2,
+                type='super',
+                superrep='choi',
+                copy=False)
+
+
+def kraus_to_super(kraus_list):
+    """
+    Convert a list of Kraus operators to a superoperator.
+    """
+    return to_super(kraus_to_choi(kraus_list))
+
+
+def _super_tofrom_choi(q_oper):
+    """
+    We exploit that the basis transformation between Choi and supermatrix
+    representations squares to the identity, so that if we munge Qobj.type,
+    we can use the same function.
+    """
+    if not q_oper.issuper:
+        raise ValueError("needs to be a superoperator")
+    if q_oper.superrep not in ('super', 'choi'):
+        raise ValueError("operator is not in super or choi format")
+    data = q_oper.data.to_array()
+    dims = q_oper.dims
+    new_dims = [[dims[1][1], dims[0][1]], [dims[1][0], dims[0][0]]]
+    d0 = np.prod(flatten(new_dims[0]))
+    d1 = np.prod(flatten(new_dims[1]))
+    s0 = np.prod(dims[0][0])
+    s1 = np.prod(dims[1][1])
+    data = data.reshape([s0, s1, s0, s1]).transpose(3, 1, 2, 0).reshape(d0, d1)
+    return Qobj(data,
+                dims=new_dims,
+                type='super',
+                superrep='super' if q_oper.superrep == 'choi' else 'choi',
+                copy=False)
+
+
+def _choi_to_chi(q_oper):
+    """
+    Converts a Choi matrix to a Chi matrix in the Pauli basis.
+
+    NOTE: this is only supported for qubits right now. Need to extend to
+    Heisenberg-Weyl for other subsystem dimensions.
+    """
+    nq = _nq(q_oper.dims)
+    B = _superpauli_basis(nq).data
+    return Qobj(_data.matmul(_data.matmul(B.adjoint(), q_oper.data), B),
+                dims=q_oper.dims,
+                type='super',
+                superrep='chi',
+                copy=False)
+
+
+def _chi_to_choi(q_oper):
+    """
+    Converts a Chi matrix to a Choi matrix.
+
+    NOTE: this is only supported for qubits right now. Need to extend to
+    Heisenberg-Weyl for other subsystem dimensions.
+    """
+    nq = _nq(q_oper.dims)
+    B = _superpauli_basis(nq).data
+    # The Chi matrix has tr(chi) == d², so we need to divide out
+    # by that to get back to the Choi form.
+    return Qobj(_data.mul(
+                    _data.matmul(_data.matmul(B, q_oper.data), B.adjoint()),
+                    1 / q_oper.shape[0]
+                ),
+                dims=q_oper.dims,
+                type='super',
+                superrep='choi',
+                copy=False)
+
+
+def _svd_u_to_kraus(U, S, d, dK, indims, outdims):
+    """
+    Given a partial isometry U and a vector of square-roots of singular values
+    S obtained from a SVD, produces the Kraus operators represented by U.
+
+    Returns
+    -------
+    Ks : list of Qobj
+        Quantum objects represnting each of the Kraus operators.
+    """
+    # We use U * S since S is 1-index, such that this is equivalent to
+    # U . diag(S), but easier to write down.
+    data = np.array(U * S).reshape((d, d, dK), order='F').transpose((2, 0, 1))
+    return [
+        Qobj(x,
+             dims=[outdims, indims],
+             type='oper',
+             copy=False)
+        for x in data
+    ]
+
+
+def _generalized_kraus(q_oper, threshold=1e-10):
+    # TODO: document!
+    # TODO: use this to generalize to_kraus to the case where U != V.
+    #       This is critical for non-CP maps, as appear in (for example)
+    #       diamond norm differences between two CP maps.
+    if not q_oper.issuper or q_oper.superrep != "choi":
+        raise ValueError("".join([
+            "Expected a Choi matrix, got a ", repr(q_oper.type),
+            " (superrep ", repr(q_oper.superrep), ")."
+        ]))
+
+    # Remember the shape of the underlying space,
+    # as we'll need this to make Kraus operators later.
+    dL, dR = int(np.sqrt(q_oper.shape[0])), int(np.sqrt(q_oper.shape[1]))
+    # Also remember the dims breakout.
+    out_dims, in_dims = q_oper.dims
+    out_left, out_right = out_dims
+    in_left, in_right = in_dims
+
+    # Find the SVD.
+    U, S, V = scipy.linalg.svd(q_oper.full())
+
+    # Truncate away the zero singular values, up to a threshold.
+    nonzero_idxs = S > threshold
+    dK = nonzero_idxs.sum()
+    U = np.array(U)[:, nonzero_idxs]
+    # We also want S to be a single index array, which np.matrix
+    # doesn't allow for. This is stripped by calling array() on it.
+    S = np.sqrt(np.array(S)[nonzero_idxs])
+    # Since NumPy returns V and not V+, we need to take the dagger
+    # to get back to quantum info notation for Stinespring pairs.
+    V = np.array(V.conj().T)[:, nonzero_idxs]
+
+    # Next, we convert each of U and V into Kraus operators.
+    # Finally, we want the Kraus index to be left-most so that we
+    # can map over it when making Qobjs.
+    # FIXME: does not preserve dims!
+    kU = _svd_u_to_kraus(U, S, dL, dK, out_right, out_left)
+    kV = _svd_u_to_kraus(V, S, dL, dK, in_right, in_left)
+
+    return kU, kV
+
+
+def _choi_to_stinespring(q_oper, threshold=1e-10):
+    # TODO: document!
+    kU, kV = _generalized_kraus(q_oper, threshold=threshold)
+
+    assert len(kU) == len(kV)
+    dK = len(kU)
+    dL = kU[0].shape[0]
+    dR = kV[0].shape[1]
+    # Also remember the dims breakout.
+    out_dims, in_dims = q_oper.dims
+    out_left, out_right = out_dims
+    in_left, in_right = in_dims
+
+    A = Qobj(_data.zeros(dK * dL, dL),
+             dims=[out_left + [dK], out_right + [1]],
+             type='oper',
+             isherm=True,
+             isunitary=False,
+             copy=False)
+    B = Qobj(_data.zeros(dK * dR, dR),
+             dims=[in_left + [dK], in_right + [1]],
+             type='oper',
+             isherm=True,
+             isunitary=False,
+             copy=False)
+
+    for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
+        A += tensor(KL, basis(dK, idx_kraus))
+        B += tensor(KR, basis(dK, idx_kraus))
+
+    # There is no input (right) Kraus index, so strip that off.
+    del A.dims[1][-1]
+    del B.dims[1][-1]
+
+    return A, B
+
+
+def to_choi(q_oper):
+    """
+    Converts a Qobj representing a quantum map to the Choi representation,
+    such that the trace of the returned operator is equal to the dimension
+    of the system.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to Choi representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_choi(A) == to_choi(sprepost(A, A.dag()))``.
+
+    Returns
+    -------
+    choi : Qobj
+        A quantum object representing the same map as ``q_oper``, such that
+        ``choi.superrep == "choi"``.
+
+    Raises
+    ------
+    TypeError: if the given quantum object is not a map, or cannot be converted
+        to Choi representation.
+    """
+    if q_oper.type == 'super':
+        if q_oper.superrep == 'choi':
+            return q_oper
+        if q_oper.superrep == 'super':
+            return _super_tofrom_choi(q_oper)
+        if q_oper.superrep == 'chi':
+            return _chi_to_choi(q_oper)
+        else:
+            raise TypeError(q_oper.superrep)
+    elif q_oper.type == 'oper':
+        return _super_tofrom_choi(sprepost(q_oper, q_oper.dag()))
+    else:
+        raise TypeError(
+            "Conversion of Qobj with type = {0.type} "
+            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
+        )
+
+
+def to_chi(q_oper):
+    """
+    Converts a Qobj representing a quantum map to a representation as a chi
+    (process) matrix in the Pauli basis, such that the trace of the returned
+    operator is equal to the dimension of the system.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to Chi representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_chi(A) == to_chi(sprepost(A, A.dag()))``.
+
+    Returns
+    -------
+    chi : Qobj
+        A quantum object representing the same map as ``q_oper``, such that
+        ``chi.superrep == "chi"``.
+
+    Raises
+    ------
+    TypeError: if the given quantum object is not a map, or cannot be converted
+        to Chi representation.
+    """
+    if q_oper.type == 'super':
+        if q_oper.superrep == 'chi':
+            return q_oper
+        elif q_oper.superrep == 'choi':
+            return _choi_to_chi(q_oper)
+        elif q_oper.superrep == 'super':
+            return _choi_to_chi(to_choi(q_oper))
+        else:
+            raise TypeError(q_oper.superrep)
+    elif q_oper.type == 'oper':
+        return to_chi(sprepost(q_oper, q_oper.dag()))
+    else:
+        raise TypeError(
+            "Conversion of Qobj with type = {0.type} "
+            "and superrep = {0.choi} to Choi not supported.".format(q_oper)
+        )
+
+
+def to_super(q_oper):
+    """
+    Converts a Qobj representing a quantum map to the supermatrix (Liouville)
+    representation.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to supermatrix representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_super(A) == sprepost(A, A.dag())``.
+
+    Returns
+    -------
+    superop : Qobj
+        A quantum object representing the same map as ``q_oper``, such that
+        ``superop.superrep == "super"``.
+
+    Raises
+    ------
+    TypeError
+        If the given quantum object is not a map, or cannot be converted
+        to supermatrix representation.
+    """
+    if q_oper.type == 'super':
+        if q_oper.superrep == "super":
+            return q_oper
+        elif q_oper.superrep == 'choi':
+            return _super_tofrom_choi(q_oper)
+        elif q_oper.superrep == 'chi':
+            return to_super(to_choi(q_oper))
+        else:
+            raise ValueError(
+                "Unrecognized superrep '{}'.".format(q_oper.superrep))
+    elif q_oper.type == 'oper':  # Assume unitary
+        return sprepost(q_oper, q_oper.dag())
+    else:
+        raise TypeError(
+            "Conversion of Qobj with type = {0.type} "
+            "and superrep = {0.superrep} to supermatrix not "
+            "supported.".format(q_oper)
+        )
+
+
+def to_kraus(q_oper, tol=1e-9):
+    """
+    Converts a Qobj representing a quantum map to a list of quantum objects,
+    each representing an operator in the Kraus decomposition of the given map.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to Kraus representation. If
+        ``q_oper`` is ``type="oper"``, then it is taken to act by conjugation,
+        such that ``to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]``.
+
+    tol : Float
+        Optional threshold parameter for eigenvalues/Kraus ops to be discarded.
+        The default is to=1e-9.
+
+    Returns
+    -------
+    kraus_ops : list of Qobj
+        A list of quantum objects, each representing a Kraus operator in the
+        decomposition of ``q_oper``.
+
+    Raises
+    ------
+    TypeError: if the given quantum object is not a map, or cannot be
+        decomposed into Kraus operators.
+    """
+    if q_oper.issuper:
+        if q_oper.superrep != 'choi':
+            q_oper = to_choi(q_oper)
+        return _choi_to_kraus(q_oper, tol)
+    elif q_oper.isoper:  # Assume unitary
+        return [q_oper]
+    raise TypeError(
+        "Conversion of Qobj with type={0.type} "
+        "and superrep={0.superrep} to Kraus decomposition not "
+        "supported.".format(q_oper)
+    )
+
+
+def to_stinespring(q_oper, threshold=1e-10):
+    r"""
+    Converts a Qobj representing a quantum map $\Lambda$ to a pair of partial
+    isometries $A$ and $B$ such that $\Lambda(X) = \Tr_2(A X B^\dagger)$ for
+    all inputs $X$, where the partial trace is taken over a a new index on the
+    output dimensions of $A$ and $B$.
+
+    For completely positive inputs, $A$ will always equal $B$ up to precision
+    errors.
+
+    Parameters
+    ----------
+    q_oper : Qobj
+        Superoperator to be converted to a Stinespring pair.
+
+    Returns
+    -------
+    A, B : Qobj
+        Quantum objects representing each of the Stinespring matrices for the
+        input Qobj.
+    """
+    return _choi_to_stinespring(to_choi(q_oper), threshold)
diff --git a/qutip/core/superoperator.py b/qutip/core/superoperator.py
index 2a990868e0..328862b8f3 100644
--- a/qutip/core/superoperator.py
+++ b/qutip/core/superoperator.py
@@ -1,412 +1,412 @@
-__all__ = [
-    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
-    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
-    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
-]
-
-import functools
-
-import numpy as np
-
-from .qobj import Qobj
-from . import data as _data
-
-def _map_over_compound_operators(f):
-    """
-    Convert a function which takes Qobj into one that can also take compound
-    operators like QobjEvo, and applies itself over all the components.
-    """
-    @functools.wraps(f)
-    def out(qobj):
-        # To avoid circular dependencies
-        from .cy.qobjevo import QobjEvo
-        if isinstance(qobj, QobjEvo):
-            return qobj.linear_map(f, _skip_check=True)
-        if not isinstance(qobj, Qobj):
-            raise TypeError("expected a quantum object")
-        return f(qobj)
-    return out
-
-
-def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
-    """Assembles the Liouvillian superoperator from a Hamiltonian
-    and a ``list`` of collapse operators.
-
-    Parameters
-    ----------
-    H : Qobj or QobjEvo (optional)
-        System Hamiltonian or Hamiltonian component of a Liouvillian.
-        Considered `0` if not given.
-
-    c_ops : array_like of Qobj or QobjEvo
-        A ``list`` or ``array`` of collapse operators.
-
-    data_only :  bool [False]
-        Return the data object instead of a Qobj
-
-    chi : array_like of float [None]
-        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
-        probability distributions of occupation of various states by numerically evaluating the derivatives
-        of the steady state occupation probability as a function of artificial phase parameters ``chi``
-        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
-        the documentation of :func:`lindblad_dissipator` for references and further details.
-        This parameter is deprecated and may be removed in QuTiP 5.
-
-    Returns
-    -------
-    L : Qobj or QobjEvo
-        Liouvillian superoperator.
-
-    """
-    # To avoid circular dependencies
-    from .cy.qobjevo import QobjEvo
-    if (
-        data_only
-        and (isinstance(H, QobjEvo)
-             or any(isinstance(op, QobjEvo) for op in c_ops))
-    ):
-        raise ValueError("Cannot return the data object when computing the"
-                         " liouvillian with QobjEvo")
-
-    c_ops = c_ops or []
-    if isinstance(c_ops, (Qobj, QobjEvo)):
-        c_ops = [c_ops]
-    if chi and len(chi) != len(c_ops):
-        raise ValueError('chi must be a list with same length as c_ops')
-    chi = chi or [0] * len(c_ops)
-
-    if H is None:
-        # No Hamiltonian, add the lindblad_dissipator of c_ops:
-        if not c_ops:
-            raise ValueError("The liouvillian need an Hamiltonian"
-                             " and/or c_ops")
-        out = sum(lindblad_dissipator(c_op, chi=chi_)
-                  for c_op, chi_ in zip(c_ops, chi))
-        return out.data if data_only else out
-    elif not H.isoper:
-        raise TypeError("Invalid type for Hamiltonian.")
-
-    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
-        # With QobjEvo, faster computation using Data is not used
-        L = -1.0j * (spre(H) - spost(H))
-        L += sum(lindblad_dissipator(c_op, chi=chi_)
-                 for c_op, chi_ in zip(c_ops, chi))
-        return L
-
-    op_dims = H.dims
-    op_shape = H.shape
-    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
-    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
-    spI = _data.identity(op_shape[0], dtype=type(H.data))
-
-    data = _data.mul(_data.kron(spI, H.data), -1j)
-    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
-
-    for c_op, chi_ in zip(c_ops, chi):
-        c = c_op.data
-        cd = c.adjoint()
-        cdc = _data.matmul(cd, c)
-        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
-        data = _data.add(data, _data.kron(spI, cdc), -0.5)
-        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
-
-    if data_only:
-        return data
-    else:
-        return Qobj(data,
-                    dims=sop_dims,
-                    type='super',
-                    superrep='super',
-                    copy=False)
-
-
-def lindblad_dissipator(a, b=None, data_only=False, chi=None):
-    """
-    Lindblad dissipator (generalized) for a single pair of collapse operators
-    (a, b), or for a single collapse operator (a) when b is not specified:
-
-    .. math::
-
-        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
-        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
-
-    Parameters
-    ----------
-    a : Qobj or QobjEvo
-        Left part of collapse operator.
-
-    b : Qobj or QobjEvo (optional)
-        Right part of collapse operator. If not specified, b defaults to a.
-
-    chi : float [None]
-        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
-        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
-        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
-        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
-        is introduced via the generating function of the statistical moments. For examples of the technique,
-        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
-        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
-        This parameter is deprecated and may be removed in QuTiP 5.
-
-    data_only :  bool [False]
-        Return the data object instead of a Qobj
-
-    Returns
-    -------
-    D : qobj, QobjEvo
-        Lindblad dissipator superoperator.
-    """
-    # To avoid circular dependencies
-    from .cy.qobjevo import QobjEvo
-    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
-        raise ValueError("Cannot return the data object when computing the"
-                         " collapse of a QobjEvo")
-    if b is None:
-        b = a
-    ad_b = a.dag() * b
-    if chi:
-        D = (
-            spre(a) * spost(b.dag()) * np.exp(1j * chi)
-            - 0.5 * spre(ad_b)
-            - 0.5 * spost(ad_b)
-        )
-    else:
-        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
-
-    return D.data if data_only else D
-
-
-@_map_over_compound_operators
-def operator_to_vector(op):
-    """
-    Create a vector representation given a quantum operator in matrix form.
-    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
-    function is not designed for general-purpose matrix reshaping.
-
-    Parameters
-    ----------
-    op : Qobj or QobjEvo
-        Quantum operator in matrix form.  This must have a type of 'oper' or
-        'super'.
-
-    Returns
-    -------
-    Qobj or QobjEvo
-        The same object, but re-cast into a column-stacked-vector form of type
-        'operator-ket'.  The output is the same type as the passed object.
-    """
-    if op.type in ['super', 'operator-ket', 'operator-bra']:
-        raise TypeError("Cannot convert object already "
-                        "in super representation")
-    return Qobj(stack_columns(op.data),
-                dims=[op.dims, [1]],
-                type='operator-ket',
-                superrep="super",
-                copy=False)
-
-
-@_map_over_compound_operators
-def vector_to_operator(op):
-    """
-    Create a matrix representation given a quantum operator in vector form.
-    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
-    function is not designed for general-purpose matrix reshaping.
-
-    Parameters
-    ----------
-    op : Qobj or QobjEvo
-        Quantum operator in column-stacked-vector form.  This must have a type
-        of 'operator-ket'.
-
-    Returns
-    -------
-    Qobj or QobjEvo
-        The same object, but re-cast into "standard" operator form.  The output
-        is the same type as the passed object.
-    """
-    if not op.isoperket:
-        raise TypeError("only defined for operator-kets")
-    if op.superrep != "super":
-        raise TypeError("only defined for operator-kets in super format")
-    dims = op.dims[0]
-    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
-                dims=dims,
-                copy=False)
-
-
-def stack_columns(matrix):
-    """
-    Stack the columns in a data-layer type, useful for converting an operator
-    into a superoperator representation.
-    """
-    if not isinstance(matrix, (_data.Data, np.ndarray)):
-        raise TypeError(
-            "input " + repr(type(matrix)) + " is not data-layer type"
-        )
-    if isinstance(matrix, np.ndarray):
-        return matrix.ravel('F')[:, None]
-    return _data.column_stack(matrix)
-
-
-def unstack_columns(vector, shape=None):
-    """
-    Unstack the columns in a data-layer type back into a 2D shape, useful for
-    converting an operator in vector form back into a regular operator.  If
-    `shape` is not passed, the output operator will be assumed to be square.
-    """
-    if not isinstance(vector, (_data.Data, np.ndarray)):
-        raise TypeError(
-            "input " + repr(type(vector)) + " is not data-layer type"
-        )
-    if (
-        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
-        or (isinstance(vector, np.ndarray)
-            and ((vector.ndim == 2 and vector.shape[1] != 1)
-                 or vector.ndim > 2))
-    ):
-        raise TypeError("input is not a single column")
-    if shape is None:
-        n = int(np.sqrt(vector.shape[0]))
-        if n * n != vector.shape[0]:
-            raise ValueError(
-                "input cannot be made square, but no specific shape given"
-            )
-        shape = (n, n)
-    if isinstance(vector, np.ndarray):
-        return vector.reshape(shape, order='F')
-    return _data.column_unstack(vector, shape[0])
-
-
-def unstacked_index(size, index):
-    """
-    Convert an index into a column-stacked square operator with `size` rows and
-    columns, into a pair of indices into the unstacked operator.
-    """
-    return index % size, index // size
-
-
-def stacked_index(size, row, col):
-    """
-    Convert a pair of indices into a square operator of `size` into a single
-    index into the column-stacked version of the operator.
-    """
-    return row + size*col
-
-
-@_map_over_compound_operators
-def spost(A):
-    """
-    Superoperator formed from post-multiplication by operator A
-
-    Parameters
-    ----------
-    A : Qobj or QobjEvo
-        Quantum operator for post multiplication.
-
-    Returns
-    -------
-    super : Qobj or QobjEvo
-        Superoperator formed from input qauntum object.
-    """
-    if not A.isoper:
-        raise TypeError('Input is not a quantum operator')
-    data = _data.kron(A.data.transpose(),
-                      _data.identity(A.shape[0], dtype=type(A.data)))
-    return Qobj(data,
-                dims=[A.dims, A.dims],
-                type='super',
-                superrep='super',
-                isherm=A._isherm,
-                copy=False)
-
-
-@_map_over_compound_operators
-def spre(A):
-    """Superoperator formed from pre-multiplication by operator A.
-
-    Parameters
-    ----------
-    A : Qobj or QobjEvo
-        Quantum operator for pre-multiplication.
-
-    Returns
-    -------
-    super :Qobj or QobjEvo
-        Superoperator formed from input quantum object.
-    """
-    if not A.isoper:
-        raise TypeError('Input is not a quantum operator')
-    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
-    return Qobj(data,
-                dims=[A.dims, A.dims],
-                type='super',
-                superrep='super',
-                isherm=A._isherm,
-                copy=False)
-
-
-def _drop_projected_dims(dims):
-    """
-    Eliminate subsystems that has been collapsed to only one state due to
-    a projection.
-    """
-    return [d for d in dims if d != 1]
-
-
-def sprepost(A, B):
-    """
-    Superoperator formed from pre-multiplication by A and post-multiplication
-    by B.
-
-    Parameters
-    ----------
-    A : Qobj or QobjEvo
-        Quantum operator for pre-multiplication.
-
-    B : Qobj or QobjEvo
-        Quantum operator for post-multiplication.
-
-    Returns
-    -------
-    super : Qobj or QobjEvo
-        Superoperator formed from input quantum objects.
-    """
-    # To avoid circular dependencies
-    from .cy.qobjevo import QobjEvo
-    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
-        return spre(A) * spost(B)
-    dims = [[_drop_projected_dims(A.dims[0]),
-             _drop_projected_dims(B.dims[1])],
-            [_drop_projected_dims(A.dims[1]),
-             _drop_projected_dims(B.dims[0])]]
-    return Qobj(_data.kron(B.data.transpose(), A.data),
-                dims=dims,
-                type='super',
-                superrep='super',
-                isherm=A._isherm and B._isherm,
-                copy=False)
-
-
-def reshuffle(q_oper):
-    """
-    Column-reshuffles a ``type="super"`` Qobj.
-    """
-    if q_oper.type not in ('super', 'operator-ket'):
-        raise TypeError("Reshuffling is only supported on type='super' "
-                        "or type='operator-ket'.")
-    # How many indices are there, and how many subsystems can we decompose
-    # each index into?
-    n_indices = len(q_oper.dims[0])
-    n_subsystems = len(q_oper.dims[0][0])
-    # Generate a list of lists (lol) that represents the permutation order we
-    # need. It's easiest to do so if we make an array, then turn it into a lol
-    # by using map(list, ...). That array is generated by using reshape and
-    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
-    # [a, a, ..., a, b, b, ..., b].
-    perm_idxs = map(list,
-                    np.arange(n_subsystems * n_indices)[
-                        np.arange(n_subsystems * n_indices).reshape(
-                            (n_indices, n_subsystems)).T.flatten()
-                    ].reshape((n_subsystems, n_indices))
-                    )
-    return q_oper.permute(list(perm_idxs))
+__all__ = [
+    'liouvillian', 'lindblad_dissipator', 'operator_to_vector',
+    'vector_to_operator', 'stack_columns', 'unstack_columns', 'stacked_index',
+    'unstacked_index', 'spost', 'spre', 'sprepost', 'reshuffle',
+]
+
+import functools
+
+import numpy as np
+
+from .qobj import Qobj
+from . import data as _data
+
+def _map_over_compound_operators(f):
+    """
+    Convert a function which takes Qobj into one that can also take compound
+    operators like QobjEvo, and applies itself over all the components.
+    """
+    @functools.wraps(f)
+    def out(qobj):
+        # To avoid circular dependencies
+        from .cy.qobjevo import QobjEvo
+        if isinstance(qobj, QobjEvo):
+            return qobj.linear_map(f, _skip_check=True)
+        if not isinstance(qobj, Qobj):
+            raise TypeError("expected a quantum object")
+        return f(qobj)
+    return out
+
+
+def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
+    """Assembles the Liouvillian superoperator from a Hamiltonian
+    and a ``list`` of collapse operators.
+
+    Parameters
+    ----------
+    H : Qobj or QobjEvo (optional)
+        System Hamiltonian or Hamiltonian component of a Liouvillian.
+        Considered `0` if not given.
+
+    c_ops : array_like of Qobj or QobjEvo
+        A ``list`` or ``array`` of collapse operators.
+
+    data_only :  bool [False]
+        Return the data object instead of a Qobj
+
+    chi : array_like of float [None]
+        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
+        probability distributions of occupation of various states by numerically evaluating the derivatives
+        of the steady state occupation probability as a function of artificial phase parameters ``chi``
+        which are included in the :func:`lindblad_dissipator` for each collapse operator. See
+        the documentation of :func:`lindblad_dissipator` for references and further details.
+        This parameter is deprecated and may be removed in QuTiP 5.
+
+    Returns
+    -------
+    L : Qobj or QobjEvo
+        Liouvillian superoperator.
+
+    """
+    # To avoid circular dependencies
+    from .cy.qobjevo import QobjEvo
+    if (
+        data_only
+        and (isinstance(H, QobjEvo)
+             or any(isinstance(op, QobjEvo) for op in c_ops))
+    ):
+        raise ValueError("Cannot return the data object when computing the"
+                         " liouvillian with QobjEvo")
+
+    c_ops = c_ops or []
+    if isinstance(c_ops, (Qobj, QobjEvo)):
+        c_ops = [c_ops]
+    if chi and len(chi) != len(c_ops):
+        raise ValueError('chi must be a list with same length as c_ops')
+    chi = chi or [0] * len(c_ops)
+
+    if H is None:
+        # No Hamiltonian, add the lindblad_dissipator of c_ops:
+        if not c_ops:
+            raise ValueError("The liouvillian need an Hamiltonian"
+                             " and/or c_ops")
+        out = sum(lindblad_dissipator(c_op, chi=chi_)
+                  for c_op, chi_ in zip(c_ops, chi))
+        return out.data if data_only else out
+    elif not H.isoper:
+        raise TypeError("Invalid type for Hamiltonian.")
+
+    if isinstance(H, QobjEvo) or any(isinstance(op, QobjEvo) for op in c_ops):
+        # With QobjEvo, faster computation using Data is not used
+        L = -1.0j * (spre(H) - spost(H))
+        L += sum(lindblad_dissipator(c_op, chi=chi_)
+                 for c_op, chi_ in zip(c_ops, chi))
+        return L
+
+    op_dims = H.dims
+    op_shape = H.shape
+    sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]]
+    sop_shape = [np.prod(op_dims), np.prod(op_dims)]
+    spI = _data.identity(op_shape[0], dtype=type(H.data))
+
+    data = _data.mul(_data.kron(spI, H.data), -1j)
+    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
+
+    for c_op, chi_ in zip(c_ops, chi):
+        c = c_op.data
+        cd = c.adjoint()
+        cdc = _data.matmul(cd, c)
+        data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
+        data = _data.add(data, _data.kron(spI, cdc), -0.5)
+        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
+
+    if data_only:
+        return data
+    else:
+        return Qobj(data,
+                    dims=sop_dims,
+                    type='super',
+                    superrep='super',
+                    copy=False)
+
+
+def lindblad_dissipator(a, b=None, data_only=False, chi=None):
+    """
+    Lindblad dissipator (generalized) for a single pair of collapse operators
+    (a, b), or for a single collapse operator (a) when b is not specified:
+
+    .. math::
+
+        \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger -
+        \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b
+
+    Parameters
+    ----------
+    a : Qobj or QobjEvo
+        Left part of collapse operator.
+
+    b : Qobj or QobjEvo (optional)
+        Right part of collapse operator. If not specified, b defaults to a.
+
+    chi : float [None]
+        In some systems it is possible to determine the statistical moments (mean, variance, etc) of the
+        probability distribution of the occupation numbers of states by numerically evaluating the derivatives
+        of the steady state occupation probability as a function of an artificial phase parameter ``chi``
+        which multiplies the ``a \\rho a^dagger`` term of the dissipator by ``e ^ (i * chi)``. The factor ``e ^ (i * chi)``
+        is introduced via the generating function of the statistical moments. For examples of the technique,
+        see `Full counting statistics of nano-electromechanical systems <https://arxiv.org/abs/cond-mat/0410322>`_
+        and `Photon-mediated electron transport in hybrid circuit-QED <https://arxiv.org/abs/1303.7449>`_.
+        This parameter is deprecated and may be removed in QuTiP 5.
+
+    data_only :  bool [False]
+        Return the data object instead of a Qobj
+
+    Returns
+    -------
+    D : qobj, QobjEvo
+        Lindblad dissipator superoperator.
+    """
+    # To avoid circular dependencies
+    from .cy.qobjevo import QobjEvo
+    if data_only and (isinstance(a, QobjEvo) or isinstance(b, QobjEvo)):
+        raise ValueError("Cannot return the data object when computing the"
+                         " collapse of a QobjEvo")
+    if b is None:
+        b = a
+    ad_b = a.dag() * b
+    if chi:
+        D = (
+            spre(a) * spost(b.dag()) * np.exp(1j * chi)
+            - 0.5 * spre(ad_b)
+            - 0.5 * spost(ad_b)
+        )
+    else:
+        D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b)
+
+    return D.data if data_only else D
+
+
+@_map_over_compound_operators
+def operator_to_vector(op):
+    """
+    Create a vector representation given a quantum operator in matrix form.
+    The passed object should have a ``Qobj.type`` of 'oper' or 'super'; this
+    function is not designed for general-purpose matrix reshaping.
+
+    Parameters
+    ----------
+    op : Qobj or QobjEvo
+        Quantum operator in matrix form.  This must have a type of 'oper' or
+        'super'.
+
+    Returns
+    -------
+    Qobj or QobjEvo
+        The same object, but re-cast into a column-stacked-vector form of type
+        'operator-ket'.  The output is the same type as the passed object.
+    """
+    if op.type in ['super', 'operator-ket', 'operator-bra']:
+        raise TypeError("Cannot convert object already "
+                        "in super representation")
+    return Qobj(stack_columns(op.data),
+                dims=[op.dims, [1]],
+                type='operator-ket',
+                superrep="super",
+                copy=False)
+
+
+@_map_over_compound_operators
+def vector_to_operator(op):
+    """
+    Create a matrix representation given a quantum operator in vector form.
+    The passed object should have a ``Qobj.type`` of 'operator-ket'; this
+    function is not designed for general-purpose matrix reshaping.
+
+    Parameters
+    ----------
+    op : Qobj or QobjEvo
+        Quantum operator in column-stacked-vector form.  This must have a type
+        of 'operator-ket'.
+
+    Returns
+    -------
+    Qobj or QobjEvo
+        The same object, but re-cast into "standard" operator form.  The output
+        is the same type as the passed object.
+    """
+    if not op.isoperket:
+        raise TypeError("only defined for operator-kets")
+    if op.superrep != "super":
+        raise TypeError("only defined for operator-kets in super format")
+    dims = op.dims[0]
+    return Qobj(unstack_columns(op.data, (np.prod(dims[0]), np.prod(dims[1]))),
+                dims=dims,
+                copy=False)
+
+
+def stack_columns(matrix):
+    """
+    Stack the columns in a data-layer type, useful for converting an operator
+    into a superoperator representation.
+    """
+    if not isinstance(matrix, (_data.Data, np.ndarray)):
+        raise TypeError(
+            "input " + repr(type(matrix)) + " is not data-layer type"
+        )
+    if isinstance(matrix, np.ndarray):
+        return matrix.ravel('F')[:, None]
+    return _data.column_stack(matrix)
+
+
+def unstack_columns(vector, shape=None):
+    """
+    Unstack the columns in a data-layer type back into a 2D shape, useful for
+    converting an operator in vector form back into a regular operator.  If
+    `shape` is not passed, the output operator will be assumed to be square.
+    """
+    if not isinstance(vector, (_data.Data, np.ndarray)):
+        raise TypeError(
+            "input " + repr(type(vector)) + " is not data-layer type"
+        )
+    if (
+        (isinstance(vector, _data.Data) and vector.shape[1] != 1)
+        or (isinstance(vector, np.ndarray)
+            and ((vector.ndim == 2 and vector.shape[1] != 1)
+                 or vector.ndim > 2))
+    ):
+        raise TypeError("input is not a single column")
+    if shape is None:
+        n = int(np.sqrt(vector.shape[0]))
+        if n * n != vector.shape[0]:
+            raise ValueError(
+                "input cannot be made square, but no specific shape given"
+            )
+        shape = (n, n)
+    if isinstance(vector, np.ndarray):
+        return vector.reshape(shape, order='F')
+    return _data.column_unstack(vector, shape[0])
+
+
+def unstacked_index(size, index):
+    """
+    Convert an index into a column-stacked square operator with `size` rows and
+    columns, into a pair of indices into the unstacked operator.
+    """
+    return index % size, index // size
+
+
+def stacked_index(size, row, col):
+    """
+    Convert a pair of indices into a square operator of `size` into a single
+    index into the column-stacked version of the operator.
+    """
+    return row + size*col
+
+
+@_map_over_compound_operators
+def spost(A):
+    """
+    Superoperator formed from post-multiplication by operator A
+
+    Parameters
+    ----------
+    A : Qobj or QobjEvo
+        Quantum operator for post multiplication.
+
+    Returns
+    -------
+    super : Qobj or QobjEvo
+        Superoperator formed from input qauntum object.
+    """
+    if not A.isoper:
+        raise TypeError('Input is not a quantum operator')
+    data = _data.kron(A.data.transpose(),
+                      _data.identity(A.shape[0], dtype=type(A.data)))
+    return Qobj(data,
+                dims=[A.dims, A.dims],
+                type='super',
+                superrep='super',
+                isherm=A._isherm,
+                copy=False)
+
+
+@_map_over_compound_operators
+def spre(A):
+    """Superoperator formed from pre-multiplication by operator A.
+
+    Parameters
+    ----------
+    A : Qobj or QobjEvo
+        Quantum operator for pre-multiplication.
+
+    Returns
+    -------
+    super :Qobj or QobjEvo
+        Superoperator formed from input quantum object.
+    """
+    if not A.isoper:
+        raise TypeError('Input is not a quantum operator')
+    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
+    return Qobj(data,
+                dims=[A.dims, A.dims],
+                type='super',
+                superrep='super',
+                isherm=A._isherm,
+                copy=False)
+
+
+def _drop_projected_dims(dims):
+    """
+    Eliminate subsystems that has been collapsed to only one state due to
+    a projection.
+    """
+    return [d for d in dims if d != 1]
+
+
+def sprepost(A, B):
+    """
+    Superoperator formed from pre-multiplication by A and post-multiplication
+    by B.
+
+    Parameters
+    ----------
+    A : Qobj or QobjEvo
+        Quantum operator for pre-multiplication.
+
+    B : Qobj or QobjEvo
+        Quantum operator for post-multiplication.
+
+    Returns
+    -------
+    super : Qobj or QobjEvo
+        Superoperator formed from input quantum objects.
+    """
+    # To avoid circular dependencies
+    from .cy.qobjevo import QobjEvo
+    if (isinstance(A, QobjEvo) or isinstance(B, QobjEvo)):
+        return spre(A) * spost(B)
+    dims = [[_drop_projected_dims(A.dims[0]),
+             _drop_projected_dims(B.dims[1])],
+            [_drop_projected_dims(A.dims[1]),
+             _drop_projected_dims(B.dims[0])]]
+    return Qobj(_data.kron(B.data.transpose(), A.data),
+                dims=dims,
+                type='super',
+                superrep='super',
+                isherm=A._isherm and B._isherm,
+                copy=False)
+
+
+def reshuffle(q_oper):
+    """
+    Column-reshuffles a ``type="super"`` Qobj.
+    """
+    if q_oper.type not in ('super', 'operator-ket'):
+        raise TypeError("Reshuffling is only supported on type='super' "
+                        "or type='operator-ket'.")
+    # How many indices are there, and how many subsystems can we decompose
+    # each index into?
+    n_indices = len(q_oper.dims[0])
+    n_subsystems = len(q_oper.dims[0][0])
+    # Generate a list of lists (lol) that represents the permutation order we
+    # need. It's easiest to do so if we make an array, then turn it into a lol
+    # by using map(list, ...). That array is generated by using reshape and
+    # transpose to turn an array like [a, b, a, b, ..., a, b] into one like
+    # [a, a, ..., a, b, b, ..., b].
+    perm_idxs = map(list,
+                    np.arange(n_subsystems * n_indices)[
+                        np.arange(n_subsystems * n_indices).reshape(
+                            (n_indices, n_subsystems)).T.flatten()
+                    ].reshape((n_subsystems, n_indices))
+                    )
+    return q_oper.permute(list(perm_idxs))
diff --git a/qutip/core/tensor.py b/qutip/core/tensor.py
index 7947b3abed..969d2ad842 100644
--- a/qutip/core/tensor.py
+++ b/qutip/core/tensor.py
@@ -1,462 +1,462 @@
-"""
-Module for the creation of composite quantum objects via the tensor product.
-"""
-
-__all__ = [
-    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
-    'expand_operator'
-]
-
-import numpy as np
-from functools import partial
-from .operators import qeye
-from .qobj import Qobj
-from .superoperator import operator_to_vector, reshuffle
-from .dimensions import (
-    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
-    dims_idxs_to_tensor_idxs
-)
-from . import data as _data
-
-
-class _reverse_partial_tensor:
-    """ Picklable lambda op: tensor(op, right) """
-    def __init__(self, right):
-        self.right = right
-
-    def __call__(self, op):
-        return tensor(op, self.right)
-
-
-def tensor(*args):
-    """Calculates the tensor product of input operators.
-
-    Parameters
-    ----------
-    args : array_like
-        ``list`` or ``array`` of quantum objects for tensor product.
-
-    Returns
-    -------
-    obj : qobj
-        A composite quantum object.
-
-    Examples
-    --------
-    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], \
-shape = [4, 4], type = oper, isHerm = True
-    Qobj data =
-    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
-     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
-     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
-     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
-    """
-    from .cy.qobjevo import QobjEvo
-    if not args:
-        raise TypeError("Requires at least one input argument")
-    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
-        return args[0].copy()
-    if len(args) == 1:
-        try:
-            args = tuple(args[0])
-        except TypeError:
-            raise TypeError("requires Qobj or QobjEvo operands") from None
-    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
-        raise TypeError("requires Qobj or QobjEvo operands")
-    if any(isinstance(q, QobjEvo) for q in args):
-        # First make tensor from pairs only
-        if len(args) >= 3:
-            return tensor(args[0], tensor(args[1:]))
-
-        left, right = args
-        if isinstance(left, Qobj):
-            return right.linear_map(partial(tensor, left))
-        if isinstance(right, Qobj):
-            return left.linear_map(_reverse_partial_tensor(right))
-        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
-        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
-        return left_t @ right_t
-
-    if not all(q.superrep == args[0].superrep for q in args[1:]):
-        raise TypeError("".join([
-            "In tensor products of superroperators,",
-            " all must have the same representation"
-        ]))
-    type = args[0].type
-    isherm = args[0]._isherm
-    isunitary = args[0]._isunitary
-    out_data = args[0].data
-    dims_l = [d for arg in args for d in arg.dims[0]]
-    dims_r = [d for arg in args for d in arg.dims[1]]
-    for arg in args[1:]:
-        out_data = _data.kron(out_data, arg.data)
-        # If both _are_ Hermitian and/or unitary, then so is the output, but if
-        # both _aren't_, then output still can be.
-        isherm = (isherm and arg._isherm) or None
-        isunitary = (isunitary and arg._isunitary) or None
-        if arg.type != type:
-            type = None
-    return Qobj(out_data,
-                dims=[dims_l, dims_r],
-                type=type,
-                isherm=isherm,
-                isunitary=isunitary,
-                superrep=args[0].superrep,
-                copy=False)
-
-
-def super_tensor(*args):
-    """
-    Calculate the tensor product of input superoperators, by tensoring together
-    the underlying Hilbert spaces on which each vectorized operator acts.
-
-    Parameters
-    ----------
-    args : array_like
-        ``list`` or ``array`` of quantum objects with ``type="super"``.
-
-    Returns
-    -------
-    obj : qobj
-        A composite quantum object.
-    """
-    if isinstance(args[0], list):
-        args = args[0]
-
-    # Check if we're tensoring vectors or superoperators.
-    if all(arg.issuper for arg in args):
-        if not all(arg.superrep == "super" for arg in args):
-            raise TypeError(
-                "super_tensor on type='super' is only implemented for "
-                "superrep='super'."
-            )
-
-        # Reshuffle the superoperators.
-        shuffled_ops = list(map(reshuffle, args))
-
-        # Tensor the result.
-        shuffled_tensor = tensor(shuffled_ops)
-
-        # Unshuffle and return.
-        out = reshuffle(shuffled_tensor)
-        out.superrep = args[0].superrep
-        return out
-    if all(arg.isoperket for arg in args):
-
-        # Reshuffle the superoperators.
-        shuffled_ops = list(map(reshuffle, args))
-
-        # Tensor the result.
-        shuffled_tensor = tensor(shuffled_ops)
-
-        # Unshuffle and return.
-        out = reshuffle(shuffled_tensor)
-        return out
-
-    if all(arg.isoperbra for arg in args):
-        return super_tensor(*(arg.dag() for arg in args)).dag()
-    raise TypeError(
-        "All arguments must be the same type, "
-        "either super, operator-ket or operator-bra."
-    )
-
-
-def _isoperlike(q):
-    return q.isoper or q.issuper
-
-
-def _isketlike(q):
-    return q.isket or q.isoperket
-
-
-def _isbralike(q):
-    return q.isbra or q.isoperbra
-
-
-def composite(*args):
-    """
-    Given two or more operators, kets or bras, returns the Qobj
-    corresponding to a composite system over each argument.
-    For ordinary operators and vectors, this is the tensor product,
-    while for superoperators and vectorized operators, this is
-    the column-reshuffled tensor product.
-
-    If a mix of Qobjs supported on Hilbert and Liouville spaces
-    are passed in, the former are promoted. Ordinary operators
-    are assumed to be unitaries, and are promoted using ``to_super``,
-    while kets and bras are promoted by taking their projectors and
-    using ``operator_to_vector(ket2dm(arg))``.
-    """
-    import qutip.core.superop_reps
-    # First step will be to ensure everything is a Qobj at all.
-    if not all(isinstance(arg, Qobj) for arg in args):
-        raise TypeError("All arguments must be Qobjs.")
-
-    # Next, figure out if we have something oper-like (isoper or issuper),
-    # or something ket-like (isket or isoperket). Bra-like we'll deal with
-    # by turning things into ket-likes and back.
-    if all(map(_isoperlike, args)):
-        if any(arg.issuper for arg in args):
-            # to_super will promote 'oper' and leave 'super' untouched
-            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
-        return tensor(*args)
-    if all(map(_isketlike, args)):
-        if any(arg.isoperket for arg in args):
-            return super_tensor(*(
-                arg if arg.isoperket else operator_to_vector(arg.proj())
-                for arg in args
-            ))
-        return tensor(*args)
-    if all(map(_isbralike, args)):
-        # Turn into ket-likes and recurse.
-        return composite(*(arg.dag() for arg in args)).dag()
-    raise TypeError("Unsupported Qobj types [{}].".format(
-        ", ".join(arg.type for arg in args)
-    ))
-
-
-def _tensor_contract_single(arr, i, j):
-    """
-    Contracts a dense tensor along a single index pair.
-    """
-    if arr.shape[i] != arr.shape[j]:
-        raise ValueError("Cannot contract over indices of different length.")
-    idxs = np.arange(arr.shape[i])
-    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
-               for idx in range(arr.ndim))
-    contract_at = i if j == i + 1 else 0
-    return np.sum(arr[sl], axis=contract_at)
-
-
-def _tensor_contract_dense(arr, *pairs):
-    """
-    Contracts a dense tensor along one or more index pairs,
-    keeping track of how the indices are relabeled by the removal
-    of other indices.
-    """
-    axis_idxs = list(range(arr.ndim))
-    for pair in pairs:
-        # axis_idxs.index effectively evaluates the mapping from original index
-        # labels to the labels after contraction.
-        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
-        axis_idxs.remove(pair[0])
-        axis_idxs.remove(pair[1])
-    return arr
-
-
-def tensor_swap(q_oper, *pairs):
-    """Transposes one or more pairs of indices of a Qobj.
-    Note that this uses dense representations and thus
-    should *not* be used for very large Qobjs.
-
-    Parameters
-    ----------
-
-    pairs : tuple
-        One or more tuples ``(i, j)`` indicating that the
-        ``i`` and ``j`` dimensions of the original qobj
-        should be swapped.
-
-    Returns
-    -------
-
-    sqobj : Qobj
-        The original Qobj with all named index pairs swapped with each other
-    """
-    dims = q_oper.dims
-    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
-    data = q_oper.full()
-    # Reshape into tensor indices
-    data = data.reshape(dims_to_tensor_shape(dims))
-    # Now permute the dims list so we know how to get back.
-    flat_dims = flatten(dims)
-    perm = list(range(len(flat_dims)))
-    for i, j in pairs:
-        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
-    for i, j in tensor_pairs:
-        perm[i], perm[j] = perm[j], perm[i]
-    dims = unflatten(flat_dims, enumerate_flat(dims))
-    # Next, permute the actual indices of the dense tensor.
-    data = data.transpose(perm)
-    # Reshape back, using the left and right of dims.
-    data = data.reshape(list(map(np.prod, dims)))
-    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
-
-
-def tensor_contract(qobj, *pairs):
-    """Contracts a qobj along one or more index pairs.
-    Note that this uses dense representations and thus
-    should *not* be used for very large Qobjs.
-
-    Parameters
-    ----------
-
-    pairs : tuple
-        One or more tuples ``(i, j)`` indicating that the
-        ``i`` and ``j`` dimensions of the original qobj
-        should be contracted.
-
-    Returns
-    -------
-
-    cqobj : Qobj
-        The original Qobj with all named index pairs contracted
-        away.
-
-    """
-    # Record and label the original dims.
-    dims = qobj.dims
-    dims_idxs = enumerate_flat(dims)
-    tensor_dims = dims_to_tensor_shape(dims)
-
-    # Convert to dense first, since sparse won't support the reshaping we need.
-    qtens = qobj.data.to_array()
-
-    # Reshape by the flattened dims.
-    qtens = qtens.reshape(tensor_dims)
-
-    # Contract out the indices from the flattened object.
-    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
-    # to ensure that we are contracting the right indices.
-    qtens = _tensor_contract_dense(qtens,
-                                   *dims_idxs_to_tensor_idxs(dims, pairs))
-
-    # Remove the contracted indexes from dims so we know how to
-    # reshape back.
-    # This concerns dims, and not the tensor indices, so we need
-    # to make sure to use the original dims indices and not the ones
-    # generated by dims_to_* functions.
-    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
-    contracted_dims = unflatten(flatten(dims), contracted_idxs)
-
-    # We don't need to check for tensor idxs versus dims idxs here,
-    # as column- versus row-stacking will never move an index for the
-    # vectorized operator spaces all the way from the left to the right.
-    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
-
-    # Reshape back into a 2D matrix.
-    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
-
-    # Return back as a qobj.
-    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
-
-
-def _check_oper_dims(oper, dims=None, targets=None):
-    """
-    Check if the given operator is valid.
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`
-        The quantum object to be checked.
-    dims : list, optional
-        A list of integer for the dimension of each composite system.
-        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
-    targets : int or list of int, optional
-        The indices of subspace that are acted on.
-    """
-    # if operator matches N
-    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
-        raise ValueError(
-            "The operator is not an "
-            "Qobj with the same input and output dimensions.")
-    # if operator dims matches the target dims
-    if dims is not None and targets is not None:
-        targ_dims = [dims[t] for t in targets]
-        if oper.dims[0] != targ_dims:
-            raise ValueError(
-                "The operator dims {} do not match "
-                "the target dims {}.".format(
-                    oper.dims[0], targ_dims))
-
-
-def _targets_to_list(targets, oper=None, N=None):
-    """
-    transform targets to a list and check validity.
-
-    Parameters
-    ----------
-    targets : int or list of int
-        The indices of subspace that are acted on.
-    oper : :class:`qutip.Qobj`, optional
-        An operator, the type of the :class:`qutip.Qobj`
-        has to be an operator
-        and the dimension matches the tensored qubit Hilbert space
-        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
-    N : int, optional
-        The number of subspace in the system.
-    """
-    # if targets is a list of integer
-    if targets is None:
-        targets = list(range(len(oper.dims[0])))
-    if not hasattr(targets, '__iter__'):
-        targets = [targets]
-    if not all([isinstance(t, int) for t in targets]):
-        raise TypeError(
-            "targets should be "
-            "an integer or a list of integer")
-    # if targets has correct length
-    if oper is not None:
-        req_num = len(oper.dims[0])
-        if len(targets) != req_num:
-            raise ValueError(
-                "The given operator needs {} "
-                "target qutbis, "
-                "but {} given.".format(
-                    req_num, len(targets)))
-    # if targets is smaller than N
-    if N is not None:
-        if not all([t < N for t in targets]):
-            raise ValueError("Targets must be smaller than N={}.".format(N))
-    return targets
-
-
-def expand_operator(oper, dims, targets):
-    """
-    Expand an operator to one that acts on a system with desired dimensions.
-    e.g.
-    ```
-    expand_operator(oper, [2, 3, 4, 5], 2) ==
-        tensor(qeye(2), qeye(3), oper, qeye(5))
-    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
-        tensor(oper2, qeye(3), oper1, qeye(5))
-    ```
-
-    Parameters
-    ----------
-    oper : :class:`qutip.Qobj`
-        An operator that act on the subsystem, has to be an operator and the
-        dimension matches the tensored dims Hilbert space
-        e.g. oper.dims = ``[[2, 3], [2, 3]]``
-    dims : list
-        A list of integer for the dimension of each composite system.
-        E.g ``[2, 3, 2, 3, 4]``.
-    targets : int or list of int
-        The indices of subspace that are acted on.
-
-    Returns
-    -------
-    expanded_oper : :class:`qutip.Qobj`
-        The expanded operator acting on a system with desired dimension.
-    """
-    from .operators import identity
-    N = len(dims)
-    targets = _targets_to_list(targets, oper=oper, N=N)
-    _check_oper_dims(oper, dims=dims, targets=targets)
-
-    # Generate the correct order for permutation,
-    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
-    # If the operator is cnot,
-    # this order means that the 3rd qubit controls the 0th qubit.
-    new_order = [0] * N
-    for i, t in enumerate(targets):
-        new_order[t] = i
-    # allocate the rest qutbits (not targets) to the empty
-    # position in new_order
-    rest_pos = [q for q in list(range(N)) if q not in targets]
-    rest_qubits = list(range(len(targets), N))
-    for i, ind in enumerate(rest_pos):
-        new_order[ind] = rest_qubits[i]
-    id_list = [identity(dims[i]) for i in rest_pos]
-    return tensor([oper] + id_list).permute(new_order)
+"""
+Module for the creation of composite quantum objects via the tensor product.
+"""
+
+__all__ = [
+    'tensor', 'super_tensor', 'composite', 'tensor_swap', 'tensor_contract',
+    'expand_operator'
+]
+
+import numpy as np
+from functools import partial
+from .operators import qeye
+from .qobj import Qobj
+from .superoperator import operator_to_vector, reshuffle
+from .dimensions import (
+    flatten, enumerate_flat, unflatten, deep_remove, dims_to_tensor_shape,
+    dims_idxs_to_tensor_idxs
+)
+from . import data as _data
+
+
+class _reverse_partial_tensor:
+    """ Picklable lambda op: tensor(op, right) """
+    def __init__(self, right):
+        self.right = right
+
+    def __call__(self, op):
+        return tensor(op, self.right)
+
+
+def tensor(*args):
+    """Calculates the tensor product of input operators.
+
+    Parameters
+    ----------
+    args : array_like
+        ``list`` or ``array`` of quantum objects for tensor product.
+
+    Returns
+    -------
+    obj : qobj
+        A composite quantum object.
+
+    Examples
+    --------
+    >>> tensor([sigmax(), sigmax()]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [2, 2]], \
+shape = [4, 4], type = oper, isHerm = True
+    Qobj data =
+    [[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
+     [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
+     [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
+     [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]
+    """
+    from .cy.qobjevo import QobjEvo
+    if not args:
+        raise TypeError("Requires at least one input argument")
+    if len(args) == 1 and isinstance(args[0], (Qobj, QobjEvo)):
+        return args[0].copy()
+    if len(args) == 1:
+        try:
+            args = tuple(args[0])
+        except TypeError:
+            raise TypeError("requires Qobj or QobjEvo operands") from None
+    if not all(isinstance(q, (Qobj, QobjEvo)) for q in args):
+        raise TypeError("requires Qobj or QobjEvo operands")
+    if any(isinstance(q, QobjEvo) for q in args):
+        # First make tensor from pairs only
+        if len(args) >= 3:
+            return tensor(args[0], tensor(args[1:]))
+
+        left, right = args
+        if isinstance(left, Qobj):
+            return right.linear_map(partial(tensor, left))
+        if isinstance(right, Qobj):
+            return left.linear_map(_reverse_partial_tensor(right))
+        left_t = left.linear_map(_reverse_partial_tensor(qeye(right.dims[0])))
+        right_t = right.linear_map(partial(tensor, qeye(left.dims[1])))
+        return left_t @ right_t
+
+    if not all(q.superrep == args[0].superrep for q in args[1:]):
+        raise TypeError("".join([
+            "In tensor products of superroperators,",
+            " all must have the same representation"
+        ]))
+    type = args[0].type
+    isherm = args[0]._isherm
+    isunitary = args[0]._isunitary
+    out_data = args[0].data
+    dims_l = [d for arg in args for d in arg.dims[0]]
+    dims_r = [d for arg in args for d in arg.dims[1]]
+    for arg in args[1:]:
+        out_data = _data.kron(out_data, arg.data)
+        # If both _are_ Hermitian and/or unitary, then so is the output, but if
+        # both _aren't_, then output still can be.
+        isherm = (isherm and arg._isherm) or None
+        isunitary = (isunitary and arg._isunitary) or None
+        if arg.type != type:
+            type = None
+    return Qobj(out_data,
+                dims=[dims_l, dims_r],
+                type=type,
+                isherm=isherm,
+                isunitary=isunitary,
+                superrep=args[0].superrep,
+                copy=False)
+
+
+def super_tensor(*args):
+    """
+    Calculate the tensor product of input superoperators, by tensoring together
+    the underlying Hilbert spaces on which each vectorized operator acts.
+
+    Parameters
+    ----------
+    args : array_like
+        ``list`` or ``array`` of quantum objects with ``type="super"``.
+
+    Returns
+    -------
+    obj : qobj
+        A composite quantum object.
+    """
+    if isinstance(args[0], list):
+        args = args[0]
+
+    # Check if we're tensoring vectors or superoperators.
+    if all(arg.issuper for arg in args):
+        if not all(arg.superrep == "super" for arg in args):
+            raise TypeError(
+                "super_tensor on type='super' is only implemented for "
+                "superrep='super'."
+            )
+
+        # Reshuffle the superoperators.
+        shuffled_ops = list(map(reshuffle, args))
+
+        # Tensor the result.
+        shuffled_tensor = tensor(shuffled_ops)
+
+        # Unshuffle and return.
+        out = reshuffle(shuffled_tensor)
+        out.superrep = args[0].superrep
+        return out
+    if all(arg.isoperket for arg in args):
+
+        # Reshuffle the superoperators.
+        shuffled_ops = list(map(reshuffle, args))
+
+        # Tensor the result.
+        shuffled_tensor = tensor(shuffled_ops)
+
+        # Unshuffle and return.
+        out = reshuffle(shuffled_tensor)
+        return out
+
+    if all(arg.isoperbra for arg in args):
+        return super_tensor(*(arg.dag() for arg in args)).dag()
+    raise TypeError(
+        "All arguments must be the same type, "
+        "either super, operator-ket or operator-bra."
+    )
+
+
+def _isoperlike(q):
+    return q.isoper or q.issuper
+
+
+def _isketlike(q):
+    return q.isket or q.isoperket
+
+
+def _isbralike(q):
+    return q.isbra or q.isoperbra
+
+
+def composite(*args):
+    """
+    Given two or more operators, kets or bras, returns the Qobj
+    corresponding to a composite system over each argument.
+    For ordinary operators and vectors, this is the tensor product,
+    while for superoperators and vectorized operators, this is
+    the column-reshuffled tensor product.
+
+    If a mix of Qobjs supported on Hilbert and Liouville spaces
+    are passed in, the former are promoted. Ordinary operators
+    are assumed to be unitaries, and are promoted using ``to_super``,
+    while kets and bras are promoted by taking their projectors and
+    using ``operator_to_vector(ket2dm(arg))``.
+    """
+    import qutip.core.superop_reps
+    # First step will be to ensure everything is a Qobj at all.
+    if not all(isinstance(arg, Qobj) for arg in args):
+        raise TypeError("All arguments must be Qobjs.")
+
+    # Next, figure out if we have something oper-like (isoper or issuper),
+    # or something ket-like (isket or isoperket). Bra-like we'll deal with
+    # by turning things into ket-likes and back.
+    if all(map(_isoperlike, args)):
+        if any(arg.issuper for arg in args):
+            # to_super will promote 'oper' and leave 'super' untouched
+            return super_tensor(*map(qutip.core.superop_reps.to_super, args))
+        return tensor(*args)
+    if all(map(_isketlike, args)):
+        if any(arg.isoperket for arg in args):
+            return super_tensor(*(
+                arg if arg.isoperket else operator_to_vector(arg.proj())
+                for arg in args
+            ))
+        return tensor(*args)
+    if all(map(_isbralike, args)):
+        # Turn into ket-likes and recurse.
+        return composite(*(arg.dag() for arg in args)).dag()
+    raise TypeError("Unsupported Qobj types [{}].".format(
+        ", ".join(arg.type for arg in args)
+    ))
+
+
+def _tensor_contract_single(arr, i, j):
+    """
+    Contracts a dense tensor along a single index pair.
+    """
+    if arr.shape[i] != arr.shape[j]:
+        raise ValueError("Cannot contract over indices of different length.")
+    idxs = np.arange(arr.shape[i])
+    sl = tuple(slice(None, None, None) if idx not in (i, j) else idxs
+               for idx in range(arr.ndim))
+    contract_at = i if j == i + 1 else 0
+    return np.sum(arr[sl], axis=contract_at)
+
+
+def _tensor_contract_dense(arr, *pairs):
+    """
+    Contracts a dense tensor along one or more index pairs,
+    keeping track of how the indices are relabeled by the removal
+    of other indices.
+    """
+    axis_idxs = list(range(arr.ndim))
+    for pair in pairs:
+        # axis_idxs.index effectively evaluates the mapping from original index
+        # labels to the labels after contraction.
+        arr = _tensor_contract_single(arr, *map(axis_idxs.index, pair))
+        axis_idxs.remove(pair[0])
+        axis_idxs.remove(pair[1])
+    return arr
+
+
+def tensor_swap(q_oper, *pairs):
+    """Transposes one or more pairs of indices of a Qobj.
+    Note that this uses dense representations and thus
+    should *not* be used for very large Qobjs.
+
+    Parameters
+    ----------
+
+    pairs : tuple
+        One or more tuples ``(i, j)`` indicating that the
+        ``i`` and ``j`` dimensions of the original qobj
+        should be swapped.
+
+    Returns
+    -------
+
+    sqobj : Qobj
+        The original Qobj with all named index pairs swapped with each other
+    """
+    dims = q_oper.dims
+    tensor_pairs = dims_idxs_to_tensor_idxs(dims, pairs)
+    data = q_oper.full()
+    # Reshape into tensor indices
+    data = data.reshape(dims_to_tensor_shape(dims))
+    # Now permute the dims list so we know how to get back.
+    flat_dims = flatten(dims)
+    perm = list(range(len(flat_dims)))
+    for i, j in pairs:
+        flat_dims[i], flat_dims[j] = flat_dims[j], flat_dims[i]
+    for i, j in tensor_pairs:
+        perm[i], perm[j] = perm[j], perm[i]
+    dims = unflatten(flat_dims, enumerate_flat(dims))
+    # Next, permute the actual indices of the dense tensor.
+    data = data.transpose(perm)
+    # Reshape back, using the left and right of dims.
+    data = data.reshape(list(map(np.prod, dims)))
+    return Qobj(data, dims=dims, superrep=q_oper.superrep, copy=False)
+
+
+def tensor_contract(qobj, *pairs):
+    """Contracts a qobj along one or more index pairs.
+    Note that this uses dense representations and thus
+    should *not* be used for very large Qobjs.
+
+    Parameters
+    ----------
+
+    pairs : tuple
+        One or more tuples ``(i, j)`` indicating that the
+        ``i`` and ``j`` dimensions of the original qobj
+        should be contracted.
+
+    Returns
+    -------
+
+    cqobj : Qobj
+        The original Qobj with all named index pairs contracted
+        away.
+
+    """
+    # Record and label the original dims.
+    dims = qobj.dims
+    dims_idxs = enumerate_flat(dims)
+    tensor_dims = dims_to_tensor_shape(dims)
+
+    # Convert to dense first, since sparse won't support the reshaping we need.
+    qtens = qobj.data.to_array()
+
+    # Reshape by the flattened dims.
+    qtens = qtens.reshape(tensor_dims)
+
+    # Contract out the indices from the flattened object.
+    # Note that we need to feed pairs through dims_idxs_to_tensor_idxs
+    # to ensure that we are contracting the right indices.
+    qtens = _tensor_contract_dense(qtens,
+                                   *dims_idxs_to_tensor_idxs(dims, pairs))
+
+    # Remove the contracted indexes from dims so we know how to
+    # reshape back.
+    # This concerns dims, and not the tensor indices, so we need
+    # to make sure to use the original dims indices and not the ones
+    # generated by dims_to_* functions.
+    contracted_idxs = deep_remove(dims_idxs, *flatten(list(map(list, pairs))))
+    contracted_dims = unflatten(flatten(dims), contracted_idxs)
+
+    # We don't need to check for tensor idxs versus dims idxs here,
+    # as column- versus row-stacking will never move an index for the
+    # vectorized operator spaces all the way from the left to the right.
+    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
+
+    # Reshape back into a 2D matrix.
+    qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
+
+    # Return back as a qobj.
+    return Qobj(qmtx, dims=contracted_dims, superrep=qobj.superrep, copy=False)
+
+
+def _check_oper_dims(oper, dims=None, targets=None):
+    """
+    Check if the given operator is valid.
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`
+        The quantum object to be checked.
+    dims : list, optional
+        A list of integer for the dimension of each composite system.
+        e.g ``[2, 2, 2, 2, 2]`` for 5 qubits system.
+    targets : int or list of int, optional
+        The indices of subspace that are acted on.
+    """
+    # if operator matches N
+    if not isinstance(oper, Qobj) or oper.dims[0] != oper.dims[1]:
+        raise ValueError(
+            "The operator is not an "
+            "Qobj with the same input and output dimensions.")
+    # if operator dims matches the target dims
+    if dims is not None and targets is not None:
+        targ_dims = [dims[t] for t in targets]
+        if oper.dims[0] != targ_dims:
+            raise ValueError(
+                "The operator dims {} do not match "
+                "the target dims {}.".format(
+                    oper.dims[0], targ_dims))
+
+
+def _targets_to_list(targets, oper=None, N=None):
+    """
+    transform targets to a list and check validity.
+
+    Parameters
+    ----------
+    targets : int or list of int
+        The indices of subspace that are acted on.
+    oper : :class:`qutip.Qobj`, optional
+        An operator, the type of the :class:`qutip.Qobj`
+        has to be an operator
+        and the dimension matches the tensored qubit Hilbert space
+        e.g. dims = ``[[2, 2, 2], [2, 2, 2]]``
+    N : int, optional
+        The number of subspace in the system.
+    """
+    # if targets is a list of integer
+    if targets is None:
+        targets = list(range(len(oper.dims[0])))
+    if not hasattr(targets, '__iter__'):
+        targets = [targets]
+    if not all([isinstance(t, int) for t in targets]):
+        raise TypeError(
+            "targets should be "
+            "an integer or a list of integer")
+    # if targets has correct length
+    if oper is not None:
+        req_num = len(oper.dims[0])
+        if len(targets) != req_num:
+            raise ValueError(
+                "The given operator needs {} "
+                "target qutbis, "
+                "but {} given.".format(
+                    req_num, len(targets)))
+    # if targets is smaller than N
+    if N is not None:
+        if not all([t < N for t in targets]):
+            raise ValueError("Targets must be smaller than N={}.".format(N))
+    return targets
+
+
+def expand_operator(oper, dims, targets):
+    """
+    Expand an operator to one that acts on a system with desired dimensions.
+    e.g.
+    ```
+    expand_operator(oper, [2, 3, 4, 5], 2) ==
+        tensor(qeye(2), qeye(3), oper, qeye(5))
+    expand_operator(tensor(oper1, oper2), [2, 3, 4, 5], [2, 0]) ==
+        tensor(oper2, qeye(3), oper1, qeye(5))
+    ```
+
+    Parameters
+    ----------
+    oper : :class:`qutip.Qobj`
+        An operator that act on the subsystem, has to be an operator and the
+        dimension matches the tensored dims Hilbert space
+        e.g. oper.dims = ``[[2, 3], [2, 3]]``
+    dims : list
+        A list of integer for the dimension of each composite system.
+        E.g ``[2, 3, 2, 3, 4]``.
+    targets : int or list of int
+        The indices of subspace that are acted on.
+
+    Returns
+    -------
+    expanded_oper : :class:`qutip.Qobj`
+        The expanded operator acting on a system with desired dimension.
+    """
+    from .operators import identity
+    N = len(dims)
+    targets = _targets_to_list(targets, oper=oper, N=N)
+    _check_oper_dims(oper, dims=dims, targets=targets)
+
+    # Generate the correct order for permutation,
+    # eg. if N = 5, targets = [3,0], the order is [1,2,3,0,4].
+    # If the operator is cnot,
+    # this order means that the 3rd qubit controls the 0th qubit.
+    new_order = [0] * N
+    for i, t in enumerate(targets):
+        new_order[t] = i
+    # allocate the rest qutbits (not targets) to the empty
+    # position in new_order
+    rest_pos = [q for q in list(range(N)) if q not in targets]
+    rest_qubits = list(range(len(targets), N))
+    for i, ind in enumerate(rest_pos):
+        new_order[ind] = rest_qubits[i]
+    id_list = [identity(dims[i]) for i in rest_pos]
+    return tensor([oper] + id_list).permute(new_order)
diff --git a/qutip/distributions.py b/qutip/distributions.py
index e85b0b00e6..b291d51c1f 100644
--- a/qutip/distributions.py
+++ b/qutip/distributions.py
@@ -1,422 +1,422 @@
-"""
-This module provides classes and functions for working with spatial
-distributions, such as Wigner distributions, etc.
-
-.. note::
-
-    Experimental.
-
-"""
-
-__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
-           'TwoModeQuadratureCorrelation',
-           'HarmonicOscillatorWaveFunction',
-           'HarmonicOscillatorProbabilityFunction']
-
-import numpy as np
-from numpy import pi, exp, sqrt
-
-from scipy.special import hermite, factorial
-
-from . import isket, ket2dm, state_number_index
-from .wigner import wigner, qfunc
-
-try:
-    import matplotlib as mpl
-    import matplotlib.pyplot as plt
-    from mpl_toolkits.mplot3d import Axes3D
-except:
-    pass
-
-
-class Distribution:
-    """A class for representation spatial distribution functions.
-
-    The Distribution class can be used to prepresent spatial distribution
-    functions of arbitray dimension (although only 1D and 2D distributions
-    are used so far).
-
-    It is indented as a base class for specific distribution function, and
-    provide implementation of basic functions that are shared among all
-    Distribution functions, such as visualization, calculating marginal
-    distributions, etc.
-
-    Parameters
-    ----------
-    data : array_like
-        Data for the distribution. The dimensions must match the lengths of
-        the coordinate arrays in xvecs.
-    xvecs : list
-        List of arrays that spans the space for each coordinate.
-    xlabels : list
-        List of labels for each coordinate.
-
-    """
-
-    def __init__(self, data=None, xvecs=[], xlabels=[]):
-        self.data = data
-        self.xvecs = xvecs
-        self.xlabels = xlabels
-
-    def visualize(self, fig=None, ax=None, figsize=(8, 6),
-                  colorbar=True, cmap=None, style="colormap",
-                  show_xlabel=True, show_ylabel=True):
-        """
-        Visualize the data of the distribution in 1D or 2D, depending
-        on the dimensionality of the underlaying distribution.
-
-        Parameters:
-
-        fig : matplotlib Figure instance
-            If given, use this figure instance for the visualization,
-
-        ax : matplotlib Axes instance
-            If given, render the visualization using this axis instance.
-
-        figsize : tuple
-            Size of the new Figure instance, if one needs to be created.
-
-        colorbar: Bool
-            Whether or not the colorbar (in 2D visualization) should be used.
-
-        cmap: matplotlib colormap instance
-            If given, use this colormap for 2D visualizations.
-
-        style : string
-            Type of visualization: 'colormap' (default) or 'surface'.
-
-        Returns
-        -------
-
-        fig, ax : tuple
-            A tuple of matplotlib figure and axes instances.
-
-        """
-        n = len(self.xvecs)
-        if n == 2:
-            if style == "colormap":
-                return self.visualize_2d_colormap(fig=fig, ax=ax,
-                                                  figsize=figsize,
-                                                  colorbar=colorbar,
-                                                  cmap=cmap,
-                                                  show_xlabel=show_xlabel,
-                                                  show_ylabel=show_ylabel)
-            else:
-                return self.visualize_2d_surface(fig=fig, ax=ax,
-                                                 figsize=figsize,
-                                                 colorbar=colorbar,
-                                                 cmap=cmap,
-                                                 show_xlabel=show_xlabel,
-                                                 show_ylabel=show_ylabel)
-
-        elif n == 1:
-            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
-                                     show_xlabel=show_xlabel,
-                                     show_ylabel=show_ylabel)
-        else:
-            raise NotImplementedError("Distribution visualization in " +
-                                      "%d dimensions is not implemented." % n)
-
-    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
-                              colorbar=True, cmap=None,
-                              show_xlabel=True, show_ylabel=True):
-
-        if not fig and not ax:
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-        if cmap is None:
-            cmap = mpl.cm.get_cmap('RdBu')
-
-        lim = abs(self.data).max()
-
-        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
-                         norm=mpl.colors.Normalize(-lim, lim),
-                         cmap=cmap)
-
-        if show_xlabel:
-            ax.set_xlabel(self.xlabels[0], fontsize=12)
-        if show_ylabel:
-            ax.set_ylabel(self.xlabels[1], fontsize=12)
-
-        if colorbar:
-            cb = fig.colorbar(cf, ax=ax)
-
-        return fig, ax
-
-    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
-                             colorbar=True, cmap=None,
-                             show_xlabel=True, show_ylabel=True):
-
-        if not fig and not ax:
-            fig = plt.figure(figsize=figsize)
-            ax = Axes3D(fig, azim=-62, elev=25)
-
-        if cmap is None:
-            cmap = mpl.cm.get_cmap('RdBu')
-
-        lim = abs(self.data).max()
-
-        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
-        s = ax.plot_surface(X, Y, self.data,
-                            norm=mpl.colors.Normalize(-lim, lim),
-                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
-
-        if show_xlabel:
-            ax.set_xlabel(self.xlabels[0], fontsize=12)
-        if show_ylabel:
-            ax.set_ylabel(self.xlabels[1], fontsize=12)
-
-        if colorbar:
-            cb = fig.colorbar(s, ax=ax, shrink=0.5)
-
-        return fig, ax
-
-    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
-                     show_xlabel=True, show_ylabel=True):
-
-        if not fig and not ax:
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-        p = ax.plot(self.xvecs[0], self.data)
-
-        if show_xlabel:
-            ax.set_xlabel(self.xlabels[0], fontsize=12)
-        if show_ylabel:
-            ax.set_ylabel("Marginal distribution", fontsize=12)
-
-        return fig, ax
-
-    def marginal(self, dim=0):
-        """
-        Calculate the marginal distribution function along the dimension
-        `dim`. Return a new Distribution instance describing this reduced-
-        dimensionality distribution.
-
-        Parameters
-        ----------
-        dim : int
-            The dimension (coordinate index) along which to obtain the
-            marginal distribution.
-
-        Returns
-        -------
-
-        d : Distributions
-            A new instances of Distribution that describes the marginal
-            distribution.
-
-        """
-        return Distribution(data=self.data.mean(axis=dim),
-                            xvecs=[self.xvecs[dim]],
-                            xlabels=[self.xlabels[dim]])
-
-    def project(self, dim=0):
-        """
-        Calculate the projection (max value) distribution function along the
-        dimension `dim`. Return a new Distribution instance describing this
-        reduced-dimensionality distribution.
-
-        Parameters
-        ----------
-        dim : int
-            The dimension (coordinate index) along which to obtain the
-            projected distribution.
-
-        Returns
-        -------
-        d : Distributions
-            A new instances of Distribution that describes the projection.
-
-        """
-        return Distribution(data=self.data.max(axis=dim),
-                            xvecs=[self.xvecs[dim]],
-                            xlabels=[self.xlabels[dim]])
-
-
-class WignerDistribution(Distribution):
-
-    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
-
-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-                      np.linspace(extent[1][0], extent[1][1], steps)]
-
-        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
-
-        if rho:
-            self.update(rho)
-
-    def update(self, rho):
-
-        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
-
-
-class QDistribution(Distribution):
-
-    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
-
-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-                      np.linspace(extent[1][0], extent[1][1], steps)]
-
-        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
-
-        if rho:
-            self.update(rho)
-
-    def update(self, rho):
-
-        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
-
-
-class TwoModeQuadratureCorrelation(Distribution):
-
-    def __init__(self, state=None, theta1=0.0, theta2=0.0,
-                 extent=[[-5, 5], [-5, 5]], steps=250):
-
-        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
-                      np.linspace(extent[1][0], extent[1][1], steps)]
-
-        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
-
-        self.theta1 = theta1
-        self.theta2 = theta2
-
-        self.update(state)
-
-    def update(self, state):
-        """
-        calculate probability distribution for quadrature measurement
-        outcomes given a two-mode wavefunction or density matrix
-        """
-        if isket(state):
-            self.update_psi(state)
-        else:
-            self.update_rho(state)
-
-    def update_psi(self, psi):
-        """
-        calculate probability distribution for quadrature measurement
-        outcomes given a two-mode wavefunction
-        """
-
-        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
-
-        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-        N = psi.dims[0][0]
-
-        for n1 in range(N):
-            kn1 = exp(-1j * self.theta1 * n1) / \
-                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
-                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
-
-            for n2 in range(N):
-                kn2 = exp(-1j * self.theta2 * n2) / \
-                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
-                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
-                i = state_number_index([N, N], [n1, n2])
-                p += kn1 * kn2 * psi.data[i, 0]
-
-        self.data = abs(p) ** 2
-
-    def update_rho(self, rho):
-        """
-        calculate probability distribution for quadrature measurement
-        outcomes given a two-mode density matrix
-        """
-
-        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
-
-        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-        N = rho.dims[0][0]
-
-        M1 = np.zeros(
-            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-        M2 = np.zeros(
-            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
-
-        for m in range(N):
-            for n in range(N):
-                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
-                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
-                    exp(-X1 ** 2) * np.polyval(
-                        hermite(m), X1) * np.polyval(hermite(n), X1)
-                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
-                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
-                    exp(-X2 ** 2) * np.polyval(
-                        hermite(m), X2) * np.polyval(hermite(n), X2)
-
-        for n1 in range(N):
-            for n2 in range(N):
-                i = state_number_index([N, N], [n1, n2])
-                for p1 in range(N):
-                    for p2 in range(N):
-                        j = state_number_index([N, N], [p1, p2])
-                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
-
-        self.data = p
-
-
-class HarmonicOscillatorWaveFunction(Distribution):
-
-    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
-
-        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
-        self.xlabels = [r'$x$']
-        self.omega = omega
-
-        if psi:
-            self.update(psi)
-
-    def update(self, psi):
-        """
-        Calculate the wavefunction for the given state of an harmonic
-        oscillator
-        """
-
-        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
-        N = psi.shape[0]
-
-        for n in range(N):
-            k = pow(self.omega / pi, 0.25) / \
-                sqrt(2 ** n * factorial(n)) * \
-                exp(-self.xvecs[0] ** 2 / 2.0) * \
-                np.polyval(hermite(n), self.xvecs[0])
-
-            self.data += k * psi.data[n, 0]
-
-
-class HarmonicOscillatorProbabilityFunction(Distribution):
-
-    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
-
-        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
-        self.xlabels = [r'$x$']
-        self.omega = omega
-
-        if rho:
-            self.update(rho)
-
-    def update(self, rho):
-        """
-        Calculate the probability function for the given state of an harmonic
-        oscillator (as density matrix)
-        """
-
-        if isket(rho):
-            rho = ket2dm(rho)
-
-        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
-        M, N = rho.shape
-
-        for m in range(M):
-            k_m = pow(self.omega / pi, 0.25) / \
-                sqrt(2 ** m * factorial(m)) * \
-                exp(-self.xvecs[0] ** 2 / 2.0) * \
-                np.polyval(hermite(m), self.xvecs[0])
-
-            for n in range(N):
-                k_n = pow(self.omega / pi, 0.25) / \
-                    sqrt(2 ** n * factorial(n)) * \
-                    exp(-self.xvecs[0] ** 2 / 2.0) * \
-                    np.polyval(hermite(n), self.xvecs[0])
-
-                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
+"""
+This module provides classes and functions for working with spatial
+distributions, such as Wigner distributions, etc.
+
+.. note::
+
+    Experimental.
+
+"""
+
+__all__ = ['Distribution', 'WignerDistribution', 'QDistribution',
+           'TwoModeQuadratureCorrelation',
+           'HarmonicOscillatorWaveFunction',
+           'HarmonicOscillatorProbabilityFunction']
+
+import numpy as np
+from numpy import pi, exp, sqrt
+
+from scipy.special import hermite, factorial
+
+from . import isket, ket2dm, state_number_index
+from .wigner import wigner, qfunc
+
+try:
+    import matplotlib as mpl
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d import Axes3D
+except:
+    pass
+
+
+class Distribution:
+    """A class for representation spatial distribution functions.
+
+    The Distribution class can be used to prepresent spatial distribution
+    functions of arbitray dimension (although only 1D and 2D distributions
+    are used so far).
+
+    It is indented as a base class for specific distribution function, and
+    provide implementation of basic functions that are shared among all
+    Distribution functions, such as visualization, calculating marginal
+    distributions, etc.
+
+    Parameters
+    ----------
+    data : array_like
+        Data for the distribution. The dimensions must match the lengths of
+        the coordinate arrays in xvecs.
+    xvecs : list
+        List of arrays that spans the space for each coordinate.
+    xlabels : list
+        List of labels for each coordinate.
+
+    """
+
+    def __init__(self, data=None, xvecs=[], xlabels=[]):
+        self.data = data
+        self.xvecs = xvecs
+        self.xlabels = xlabels
+
+    def visualize(self, fig=None, ax=None, figsize=(8, 6),
+                  colorbar=True, cmap=None, style="colormap",
+                  show_xlabel=True, show_ylabel=True):
+        """
+        Visualize the data of the distribution in 1D or 2D, depending
+        on the dimensionality of the underlaying distribution.
+
+        Parameters:
+
+        fig : matplotlib Figure instance
+            If given, use this figure instance for the visualization,
+
+        ax : matplotlib Axes instance
+            If given, render the visualization using this axis instance.
+
+        figsize : tuple
+            Size of the new Figure instance, if one needs to be created.
+
+        colorbar: Bool
+            Whether or not the colorbar (in 2D visualization) should be used.
+
+        cmap: matplotlib colormap instance
+            If given, use this colormap for 2D visualizations.
+
+        style : string
+            Type of visualization: 'colormap' (default) or 'surface'.
+
+        Returns
+        -------
+
+        fig, ax : tuple
+            A tuple of matplotlib figure and axes instances.
+
+        """
+        n = len(self.xvecs)
+        if n == 2:
+            if style == "colormap":
+                return self.visualize_2d_colormap(fig=fig, ax=ax,
+                                                  figsize=figsize,
+                                                  colorbar=colorbar,
+                                                  cmap=cmap,
+                                                  show_xlabel=show_xlabel,
+                                                  show_ylabel=show_ylabel)
+            else:
+                return self.visualize_2d_surface(fig=fig, ax=ax,
+                                                 figsize=figsize,
+                                                 colorbar=colorbar,
+                                                 cmap=cmap,
+                                                 show_xlabel=show_xlabel,
+                                                 show_ylabel=show_ylabel)
+
+        elif n == 1:
+            return self.visualize_1d(fig=fig, ax=ax, figsize=figsize,
+                                     show_xlabel=show_xlabel,
+                                     show_ylabel=show_ylabel)
+        else:
+            raise NotImplementedError("Distribution visualization in " +
+                                      "%d dimensions is not implemented." % n)
+
+    def visualize_2d_colormap(self, fig=None, ax=None, figsize=(8, 6),
+                              colorbar=True, cmap=None,
+                              show_xlabel=True, show_ylabel=True):
+
+        if not fig and not ax:
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+        if cmap is None:
+            cmap = mpl.cm.get_cmap('RdBu')
+
+        lim = abs(self.data).max()
+
+        cf = ax.contourf(self.xvecs[0], self.xvecs[1], self.data, 100,
+                         norm=mpl.colors.Normalize(-lim, lim),
+                         cmap=cmap)
+
+        if show_xlabel:
+            ax.set_xlabel(self.xlabels[0], fontsize=12)
+        if show_ylabel:
+            ax.set_ylabel(self.xlabels[1], fontsize=12)
+
+        if colorbar:
+            cb = fig.colorbar(cf, ax=ax)
+
+        return fig, ax
+
+    def visualize_2d_surface(self, fig=None, ax=None, figsize=(8, 6),
+                             colorbar=True, cmap=None,
+                             show_xlabel=True, show_ylabel=True):
+
+        if not fig and not ax:
+            fig = plt.figure(figsize=figsize)
+            ax = Axes3D(fig, azim=-62, elev=25)
+
+        if cmap is None:
+            cmap = mpl.cm.get_cmap('RdBu')
+
+        lim = abs(self.data).max()
+
+        X, Y = np.meshgrid(self.xvecs[0], self.xvecs[1])
+        s = ax.plot_surface(X, Y, self.data,
+                            norm=mpl.colors.Normalize(-lim, lim),
+                            rstride=5, cstride=5, cmap=cmap, lw=0.1)
+
+        if show_xlabel:
+            ax.set_xlabel(self.xlabels[0], fontsize=12)
+        if show_ylabel:
+            ax.set_ylabel(self.xlabels[1], fontsize=12)
+
+        if colorbar:
+            cb = fig.colorbar(s, ax=ax, shrink=0.5)
+
+        return fig, ax
+
+    def visualize_1d(self, fig=None, ax=None, figsize=(8, 6),
+                     show_xlabel=True, show_ylabel=True):
+
+        if not fig and not ax:
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+        p = ax.plot(self.xvecs[0], self.data)
+
+        if show_xlabel:
+            ax.set_xlabel(self.xlabels[0], fontsize=12)
+        if show_ylabel:
+            ax.set_ylabel("Marginal distribution", fontsize=12)
+
+        return fig, ax
+
+    def marginal(self, dim=0):
+        """
+        Calculate the marginal distribution function along the dimension
+        `dim`. Return a new Distribution instance describing this reduced-
+        dimensionality distribution.
+
+        Parameters
+        ----------
+        dim : int
+            The dimension (coordinate index) along which to obtain the
+            marginal distribution.
+
+        Returns
+        -------
+
+        d : Distributions
+            A new instances of Distribution that describes the marginal
+            distribution.
+
+        """
+        return Distribution(data=self.data.mean(axis=dim),
+                            xvecs=[self.xvecs[dim]],
+                            xlabels=[self.xlabels[dim]])
+
+    def project(self, dim=0):
+        """
+        Calculate the projection (max value) distribution function along the
+        dimension `dim`. Return a new Distribution instance describing this
+        reduced-dimensionality distribution.
+
+        Parameters
+        ----------
+        dim : int
+            The dimension (coordinate index) along which to obtain the
+            projected distribution.
+
+        Returns
+        -------
+        d : Distributions
+            A new instances of Distribution that describes the projection.
+
+        """
+        return Distribution(data=self.data.max(axis=dim),
+                            xvecs=[self.xvecs[dim]],
+                            xlabels=[self.xlabels[dim]])
+
+
+class WignerDistribution(Distribution):
+
+    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
+
+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+                      np.linspace(extent[1][0], extent[1][1], steps)]
+
+        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
+
+        if rho:
+            self.update(rho)
+
+    def update(self, rho):
+
+        self.data = wigner(rho, self.xvecs[0], self.xvecs[1])
+
+
+class QDistribution(Distribution):
+
+    def __init__(self, rho=None, extent=[[-5, 5], [-5, 5]], steps=250):
+
+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+                      np.linspace(extent[1][0], extent[1][1], steps)]
+
+        self.xlabels = [r'$\rm{Re}(\alpha)$', r'$\rm{Im}(\alpha)$']
+
+        if rho:
+            self.update(rho)
+
+    def update(self, rho):
+
+        self.data = qfunc(rho, self.xvecs[0], self.xvecs[1])
+
+
+class TwoModeQuadratureCorrelation(Distribution):
+
+    def __init__(self, state=None, theta1=0.0, theta2=0.0,
+                 extent=[[-5, 5], [-5, 5]], steps=250):
+
+        self.xvecs = [np.linspace(extent[0][0], extent[0][1], steps),
+                      np.linspace(extent[1][0], extent[1][1], steps)]
+
+        self.xlabels = [r'$X_1(\theta_1)$', r'$X_2(\theta_2)$']
+
+        self.theta1 = theta1
+        self.theta2 = theta2
+
+        self.update(state)
+
+    def update(self, state):
+        """
+        calculate probability distribution for quadrature measurement
+        outcomes given a two-mode wavefunction or density matrix
+        """
+        if isket(state):
+            self.update_psi(state)
+        else:
+            self.update_rho(state)
+
+    def update_psi(self, psi):
+        """
+        calculate probability distribution for quadrature measurement
+        outcomes given a two-mode wavefunction
+        """
+
+        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
+
+        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+        N = psi.dims[0][0]
+
+        for n1 in range(N):
+            kn1 = exp(-1j * self.theta1 * n1) / \
+                sqrt(sqrt(pi) * 2 ** n1 * factorial(n1)) * \
+                exp(-X1 ** 2 / 2.0) * np.polyval(hermite(n1), X1)
+
+            for n2 in range(N):
+                kn2 = exp(-1j * self.theta2 * n2) / \
+                    sqrt(sqrt(pi) * 2 ** n2 * factorial(n2)) * \
+                    exp(-X2 ** 2 / 2.0) * np.polyval(hermite(n2), X2)
+                i = state_number_index([N, N], [n1, n2])
+                p += kn1 * kn2 * psi.data[i, 0]
+
+        self.data = abs(p) ** 2
+
+    def update_rho(self, rho):
+        """
+        calculate probability distribution for quadrature measurement
+        outcomes given a two-mode density matrix
+        """
+
+        X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1])
+
+        p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+        N = rho.dims[0][0]
+
+        M1 = np.zeros(
+            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+        M2 = np.zeros(
+            (N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex)
+
+        for m in range(N):
+            for n in range(N):
+                M1[m, n] = exp(-1j * self.theta1 * (m - n)) / \
+                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
+                    exp(-X1 ** 2) * np.polyval(
+                        hermite(m), X1) * np.polyval(hermite(n), X1)
+                M2[m, n] = exp(-1j * self.theta2 * (m - n)) / \
+                    sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \
+                    exp(-X2 ** 2) * np.polyval(
+                        hermite(m), X2) * np.polyval(hermite(n), X2)
+
+        for n1 in range(N):
+            for n2 in range(N):
+                i = state_number_index([N, N], [n1, n2])
+                for p1 in range(N):
+                    for p2 in range(N):
+                        j = state_number_index([N, N], [p1, p2])
+                        p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j]
+
+        self.data = p
+
+
+class HarmonicOscillatorWaveFunction(Distribution):
+
+    def __init__(self, psi=None, omega=1.0, extent=[-5, 5], steps=250):
+
+        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
+        self.xlabels = [r'$x$']
+        self.omega = omega
+
+        if psi:
+            self.update(psi)
+
+    def update(self, psi):
+        """
+        Calculate the wavefunction for the given state of an harmonic
+        oscillator
+        """
+
+        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
+        N = psi.shape[0]
+
+        for n in range(N):
+            k = pow(self.omega / pi, 0.25) / \
+                sqrt(2 ** n * factorial(n)) * \
+                exp(-self.xvecs[0] ** 2 / 2.0) * \
+                np.polyval(hermite(n), self.xvecs[0])
+
+            self.data += k * psi.data[n, 0]
+
+
+class HarmonicOscillatorProbabilityFunction(Distribution):
+
+    def __init__(self, rho=None, omega=1.0, extent=[-5, 5], steps=250):
+
+        self.xvecs = [np.linspace(extent[0], extent[1], steps)]
+        self.xlabels = [r'$x$']
+        self.omega = omega
+
+        if rho:
+            self.update(rho)
+
+    def update(self, rho):
+        """
+        Calculate the probability function for the given state of an harmonic
+        oscillator (as density matrix)
+        """
+
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
+        M, N = rho.shape
+
+        for m in range(M):
+            k_m = pow(self.omega / pi, 0.25) / \
+                sqrt(2 ** m * factorial(m)) * \
+                exp(-self.xvecs[0] ** 2 / 2.0) * \
+                np.polyval(hermite(m), self.xvecs[0])
+
+            for n in range(N):
+                k_n = pow(self.omega / pi, 0.25) / \
+                    sqrt(2 ** n * factorial(n)) * \
+                    exp(-self.xvecs[0] ** 2 / 2.0) * \
+                    np.polyval(hermite(n), self.xvecs[0])
+
+                self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
diff --git a/qutip/entropy.py b/qutip/entropy.py
index 28ff606aa4..cd62a69b76 100644
--- a/qutip/entropy.py
+++ b/qutip/entropy.py
@@ -1,376 +1,376 @@
-__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
-           'concurrence', 'entropy_conditional', 'entangling_power',
-           'entropy_relative']
-
-from numpy import conj, e, inf, imag, inner, real, sort, sqrt
-from numpy.lib.scimath import log, log2
-from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
-               expand_operator)
-from .core import data as _data
-
-
-def entropy_vn(rho, base=e, sparse=False):
-    """
-    Von-Neumann entropy of density matrix
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix.
-    base : {e,2}
-        Base of logarithm.
-    sparse : {False,True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    entropy : float
-        Von-Neumann entropy of `rho`.
-
-    Examples
-    --------
-    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
-    >>> entropy_vn(rho,2)
-    1.0
-
-    """
-    if rho.type == 'ket' or rho.type == 'bra':
-        rho = ket2dm(rho)
-    vals = rho.eigenenergies(sparse=sparse)
-    nzvals = vals[vals != 0]
-    if base == 2:
-        logvals = log2(nzvals)
-    elif base == e:
-        logvals = log(nzvals)
-    else:
-        raise ValueError("Base must be 2 or e.")
-    return float(real(-sum(nzvals * logvals)))
-
-
-def entropy_linear(rho):
-    """
-    Linear entropy of a density matrix.
-
-    Parameters
-    ----------
-    rho : qobj
-        sensity matrix or ket/bra vector.
-
-    Returns
-    -------
-    entropy : float
-        Linear entropy of rho.
-
-    Examples
-    --------
-    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
-    >>> entropy_linear(rho)
-    0.5
-
-    """
-    if rho.type == 'ket' or rho.type == 'bra':
-        rho = ket2dm(rho)
-    return float(real(1.0 - (rho ** 2).tr()))
-
-
-def concurrence(rho):
-    """
-    Calculate the concurrence entanglement measure for a two-qubit state.
-
-    Parameters
-    ----------
-    state : qobj
-        Ket, bra, or density matrix for a two-qubit state.
-
-    Returns
-    -------
-    concur : float
-        Concurrence
-
-    References
-    ----------
-
-    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
-
-    """
-    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
-        raise Exception("Ket must be tensor product of two qubits.")
-
-    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
-        raise Exception("Bra must be tensor product of two qubits.")
-
-    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
-        raise Exception("Density matrix must be tensor product of two qubits.")
-
-    if rho.isket or rho.isbra:
-        rho = ket2dm(rho)
-
-    sysy = tensor(sigmay(), sigmay())
-
-    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
-
-    evals = rho_tilde.eigenenergies()
-
-    # abs to avoid problems with sqrt for very small negative numbers
-    evals = abs(sort(real(evals)))
-
-    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
-
-    return max(0, lsum)
-
-
-def negativity(rho, subsys, method='tracenorm', logarithmic=False):
-    """
-    Compute the negativity for a multipartite quantum system described
-    by the density matrix rho. The subsys argument is an index that
-    indicates which system to compute the negativity for.
-
-    .. note::
-
-        Experimental.
-    """
-    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
-    rho_pt = partial_transpose(rho, mask)
-
-    if method == 'tracenorm':
-        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
-    elif method == 'eigenvalues':
-        l = rho_pt.eigenenergies()
-        N = ((abs(l)-l)/2).sum()
-    else:
-        raise ValueError("Unknown method %s" % method)
-
-    if logarithmic:
-        return log2(2 * N + 1)
-    else:
-        return N
-
-
-def entropy_mutual(rho, selA, selB, base=e, sparse=False):
-    """
-    Calculates the mutual information S(A:B) between selection
-    components of a system density matrix.
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix for composite quantum systems
-    selA : int/list
-        `int` or `list` of first selected density matrix components.
-    selB : int/list
-        `int` or `list` of second selected density matrix components.
-    base : {e,2}
-        Base of logarithm.
-    sparse : {False,True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    ent_mut : float
-       Mutual information between selected components.
-
-    """
-    if isinstance(selA, int):
-        selA = [selA]
-    if isinstance(selB, int):
-        selB = [selB]
-    if rho.type != 'oper':
-        raise TypeError("Input must be a density matrix.")
-    if (len(selA) + len(selB)) != len(rho.dims[0]):
-        raise TypeError("Number of selected components must match " +
-                        "total number.")
-
-    rhoA = ptrace(rho, selA)
-    rhoB = ptrace(rho, selB)
-    out = (entropy_vn(rhoA, base, sparse=sparse) +
-           entropy_vn(rhoB, base, sparse=sparse) -
-           entropy_vn(rho, base, sparse=sparse))
-    return out
-
-
-def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
-    """
-    Calculates the relative entropy S(rho||sigma) between two density
-    matrices.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        First density matrix (or ket which will be converted to a density
-        matrix).
-    sigma : :class:`qutip.Qobj`
-        Second density matrix (or ket which will be converted to a density
-        matrix).
-    base : {e,2}
-        Base of logarithm. Defaults to e.
-    sparse : bool
-        Flag to use sparse solver when determining the eigenvectors
-        of the density matrices. Defaults to False.
-    tol : float
-        Tolerance to use to detect 0 eigenvalues or dot producted between
-        eigenvectors. Defaults to 1e-12.
-
-    Returns
-    -------
-    rel_ent : float
-        Value of relative entropy. Guaranteed to be greater than zero
-        and should equal zero only when rho and sigma are identical.
-
-    Examples
-    --------
-
-    First we define two density matrices:
-
-    >>> rho = qutip.ket2dm(qutip.ket("00"))
-    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
-    >>> sigma = sigma.unit()
-
-    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
-    and base e (i.e. ``log``).
-
-    >>> qutip.entropy_relative(rho, sigma, base=2)
-    1.0
-    >>> qutip.entropy_relative(rho, sigma)
-    0.6931471805599453
-
-    References
-    ----------
-
-    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
-    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
-    entropy.
-    """
-    if rho.isket:
-        rho = ket2dm(rho)
-    if sigma.isket:
-        sigma = ket2dm(sigma)
-    if not rho.isoper or not sigma.isoper:
-        raise TypeError("Inputs must be density matrices.")
-    if rho.dims != sigma.dims:
-        raise ValueError("Inputs must have the same shape and dims.")
-    if base == 2:
-        log_base = log2
-    elif base == e:
-        log_base = log
-    else:
-        raise ValueError("Base must be 2 or e.")
-    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
-    #
-    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
-    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
-    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
-    rvecs = rvecs.to_array().T
-    if any(abs(imag(rvals)) >= tol):
-        raise ValueError("Input rho has non-real eigenvalues.")
-    rvals = real(rvals)
-    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
-    svecs = svecs.to_array().T
-    if any(abs(imag(svals)) >= tol):
-        raise ValueError("Input sigma has non-real eigenvalues.")
-    svals = real(svals)
-    # Calculate inner products of eigenvectors and return +inf if kernel
-    # of sigma overlaps with support of rho.
-    P = abs(inner(rvecs, conj(svecs))) ** 2
-    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
-        return inf
-    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
-    # anyway
-    svals[abs(svals) < tol] = 1
-    nzrvals = rvals[abs(rvals) >= tol]
-    # Calculate S
-    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
-    # the relative entropy is guaranteed to be >= 0, so we clamp the
-    # calculated value to 0 to avoid small violations of the lower bound.
-    return max(0, S)
-
-
-def entropy_conditional(rho, selB, base=e, sparse=False):
-    """
-    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
-    of a selected density matrix component.
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix of composite object
-    selB : int/list
-        Selected components for density matrix B
-    base : {e,2}
-        Base of logarithm.
-    sparse : {False,True}
-        Use sparse eigensolver.
-
-    Returns
-    -------
-    ent_cond : float
-        Value of conditional entropy
-
-    """
-    if rho.type != 'oper':
-        raise TypeError("Input must be density matrix.")
-    if isinstance(selB, int):
-        selB = [selB]
-    B = ptrace(rho, selB)
-    out = (entropy_vn(rho, base, sparse=sparse) -
-           entropy_vn(B, base, sparse=sparse))
-    return out
-
-
-def participation_ratio(rho):
-    """
-    Returns the effective number of states for a density matrix.
-
-    The participation is unity for pure states, and maximally N,
-    where N is the Hilbert space dimensionality, for completely
-    mixed states.
-
-    Parameters
-    ----------
-    rho : qobj
-        Density matrix
-
-    Returns
-    -------
-    pr : float
-        Effective number of states in the density matrix
-
-    """
-    if rho.type == 'ket' or rho.type == 'bra':
-        return 1.0
-    else:
-        return 1.0 / (rho ** 2).tr()
-
-
-def entangling_power(U):
-    """
-    Calculate the entangling power of a two-qubit gate U, which
-    is zero of nonentangling gates and 2/9 for maximally entangling gates.
-
-    Parameters
-    ----------
-    U : qobj
-        Qobj instance representing a two-qubit gate.
-
-    Returns
-    -------
-    ep : float
-        The entanglement power of U (real number between 0 and 2/9)
-
-    References:
-
-        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
-    """
-
-    if not U.isoper:
-        raise Exception("U must be an operator.")
-
-    if U.dims != [[2, 2], [2, 2]]:
-        raise Exception("U must be a two-qubit gate.")
-
-    from qutip.core.gates import swap
-    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
-    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
-    Uswap = swap() * U
-    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
-
-    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
+__all__ = ['entropy_vn', 'entropy_linear', 'entropy_mutual', 'negativity',
+           'concurrence', 'entropy_conditional', 'entangling_power',
+           'entropy_relative']
+
+from numpy import conj, e, inf, imag, inner, real, sort, sqrt
+from numpy.lib.scimath import log, log2
+from . import (ptrace, ket2dm, tensor, sigmay, partial_transpose,
+               expand_operator)
+from .core import data as _data
+
+
+def entropy_vn(rho, base=e, sparse=False):
+    """
+    Von-Neumann entropy of density matrix
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix.
+    base : {e,2}
+        Base of logarithm.
+    sparse : {False,True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    entropy : float
+        Von-Neumann entropy of `rho`.
+
+    Examples
+    --------
+    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
+    >>> entropy_vn(rho,2)
+    1.0
+
+    """
+    if rho.type == 'ket' or rho.type == 'bra':
+        rho = ket2dm(rho)
+    vals = rho.eigenenergies(sparse=sparse)
+    nzvals = vals[vals != 0]
+    if base == 2:
+        logvals = log2(nzvals)
+    elif base == e:
+        logvals = log(nzvals)
+    else:
+        raise ValueError("Base must be 2 or e.")
+    return float(real(-sum(nzvals * logvals)))
+
+
+def entropy_linear(rho):
+    """
+    Linear entropy of a density matrix.
+
+    Parameters
+    ----------
+    rho : qobj
+        sensity matrix or ket/bra vector.
+
+    Returns
+    -------
+    entropy : float
+        Linear entropy of rho.
+
+    Examples
+    --------
+    >>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
+    >>> entropy_linear(rho)
+    0.5
+
+    """
+    if rho.type == 'ket' or rho.type == 'bra':
+        rho = ket2dm(rho)
+    return float(real(1.0 - (rho ** 2).tr()))
+
+
+def concurrence(rho):
+    """
+    Calculate the concurrence entanglement measure for a two-qubit state.
+
+    Parameters
+    ----------
+    state : qobj
+        Ket, bra, or density matrix for a two-qubit state.
+
+    Returns
+    -------
+    concur : float
+        Concurrence
+
+    References
+    ----------
+
+    .. [1] https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)
+
+    """
+    if rho.isket and rho.dims != [[2, 2], [1, 1]]:
+        raise Exception("Ket must be tensor product of two qubits.")
+
+    elif rho.isbra and rho.dims != [[1, 1], [2, 2]]:
+        raise Exception("Bra must be tensor product of two qubits.")
+
+    elif rho.isoper and rho.dims != [[2, 2], [2, 2]]:
+        raise Exception("Density matrix must be tensor product of two qubits.")
+
+    if rho.isket or rho.isbra:
+        rho = ket2dm(rho)
+
+    sysy = tensor(sigmay(), sigmay())
+
+    rho_tilde = (rho * sysy) * (rho.conj() * sysy)
+
+    evals = rho_tilde.eigenenergies()
+
+    # abs to avoid problems with sqrt for very small negative numbers
+    evals = abs(sort(real(evals)))
+
+    lsum = sqrt(evals[3]) - sqrt(evals[2]) - sqrt(evals[1]) - sqrt(evals[0])
+
+    return max(0, lsum)
+
+
+def negativity(rho, subsys, method='tracenorm', logarithmic=False):
+    """
+    Compute the negativity for a multipartite quantum system described
+    by the density matrix rho. The subsys argument is an index that
+    indicates which system to compute the negativity for.
+
+    .. note::
+
+        Experimental.
+    """
+    mask = [idx == subsys for idx, n in enumerate(rho.dims[0])]
+    rho_pt = partial_transpose(rho, mask)
+
+    if method == 'tracenorm':
+        N = ((rho_pt.dag() * rho_pt).sqrtm().tr().real - 1)/2.0
+    elif method == 'eigenvalues':
+        l = rho_pt.eigenenergies()
+        N = ((abs(l)-l)/2).sum()
+    else:
+        raise ValueError("Unknown method %s" % method)
+
+    if logarithmic:
+        return log2(2 * N + 1)
+    else:
+        return N
+
+
+def entropy_mutual(rho, selA, selB, base=e, sparse=False):
+    """
+    Calculates the mutual information S(A:B) between selection
+    components of a system density matrix.
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix for composite quantum systems
+    selA : int/list
+        `int` or `list` of first selected density matrix components.
+    selB : int/list
+        `int` or `list` of second selected density matrix components.
+    base : {e,2}
+        Base of logarithm.
+    sparse : {False,True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    ent_mut : float
+       Mutual information between selected components.
+
+    """
+    if isinstance(selA, int):
+        selA = [selA]
+    if isinstance(selB, int):
+        selB = [selB]
+    if rho.type != 'oper':
+        raise TypeError("Input must be a density matrix.")
+    if (len(selA) + len(selB)) != len(rho.dims[0]):
+        raise TypeError("Number of selected components must match " +
+                        "total number.")
+
+    rhoA = ptrace(rho, selA)
+    rhoB = ptrace(rho, selB)
+    out = (entropy_vn(rhoA, base, sparse=sparse) +
+           entropy_vn(rhoB, base, sparse=sparse) -
+           entropy_vn(rho, base, sparse=sparse))
+    return out
+
+
+def entropy_relative(rho, sigma, base=e, sparse=False, tol=1e-12):
+    """
+    Calculates the relative entropy S(rho||sigma) between two density
+    matrices.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        First density matrix (or ket which will be converted to a density
+        matrix).
+    sigma : :class:`qutip.Qobj`
+        Second density matrix (or ket which will be converted to a density
+        matrix).
+    base : {e,2}
+        Base of logarithm. Defaults to e.
+    sparse : bool
+        Flag to use sparse solver when determining the eigenvectors
+        of the density matrices. Defaults to False.
+    tol : float
+        Tolerance to use to detect 0 eigenvalues or dot producted between
+        eigenvectors. Defaults to 1e-12.
+
+    Returns
+    -------
+    rel_ent : float
+        Value of relative entropy. Guaranteed to be greater than zero
+        and should equal zero only when rho and sigma are identical.
+
+    Examples
+    --------
+
+    First we define two density matrices:
+
+    >>> rho = qutip.ket2dm(qutip.ket("00"))
+    >>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
+    >>> sigma = sigma.unit()
+
+    Then we calculate their relative entropy using base 2 (i.e. ``log2``)
+    and base e (i.e. ``log``).
+
+    >>> qutip.entropy_relative(rho, sigma, base=2)
+    1.0
+    >>> qutip.entropy_relative(rho, sigma)
+    0.6931471805599453
+
+    References
+    ----------
+
+    See Nielsen & Chuang, "Quantum Computation and Quantum Information",
+    Section 11.3.1, pg. 511 for a detailed explanation of quantum relative
+    entropy.
+    """
+    if rho.isket:
+        rho = ket2dm(rho)
+    if sigma.isket:
+        sigma = ket2dm(sigma)
+    if not rho.isoper or not sigma.isoper:
+        raise TypeError("Inputs must be density matrices.")
+    if rho.dims != sigma.dims:
+        raise ValueError("Inputs must have the same shape and dims.")
+    if base == 2:
+        log_base = log2
+    elif base == e:
+        log_base = log
+    else:
+        raise ValueError("Base must be 2 or e.")
+    # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
+    #
+    # S is +inf if the kernel of sigma (i.e. svecs[svals == 0]) has non-trivial
+    # intersection with the support of rho (i.e. rvecs[rvals != 0]).
+    rvals, rvecs = _data.eigs(rho.data, rho.isherm, True)
+    rvecs = rvecs.to_array().T
+    if any(abs(imag(rvals)) >= tol):
+        raise ValueError("Input rho has non-real eigenvalues.")
+    rvals = real(rvals)
+    svals, svecs = _data.eigs(sigma.data, sigma.isherm, True)
+    svecs = svecs.to_array().T
+    if any(abs(imag(svals)) >= tol):
+        raise ValueError("Input sigma has non-real eigenvalues.")
+    svals = real(svals)
+    # Calculate inner products of eigenvectors and return +inf if kernel
+    # of sigma overlaps with support of rho.
+    P = abs(inner(rvecs, conj(svecs))) ** 2
+    if (rvals >= tol) @ (P >= tol) @ (svals < tol):
+        return inf
+    # Avoid -inf from log(0) -- these terms will be multiplied by zero later
+    # anyway
+    svals[abs(svals) < tol] = 1
+    nzrvals = rvals[abs(rvals) >= tol]
+    # Calculate S
+    S = nzrvals @ log_base(nzrvals) - rvals @ P @ log_base(svals)
+    # the relative entropy is guaranteed to be >= 0, so we clamp the
+    # calculated value to 0 to avoid small violations of the lower bound.
+    return max(0, S)
+
+
+def entropy_conditional(rho, selB, base=e, sparse=False):
+    """
+    Calculates the conditional entropy :math:`S(A|B)=S(A,B)-S(B)`
+    of a selected density matrix component.
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix of composite object
+    selB : int/list
+        Selected components for density matrix B
+    base : {e,2}
+        Base of logarithm.
+    sparse : {False,True}
+        Use sparse eigensolver.
+
+    Returns
+    -------
+    ent_cond : float
+        Value of conditional entropy
+
+    """
+    if rho.type != 'oper':
+        raise TypeError("Input must be density matrix.")
+    if isinstance(selB, int):
+        selB = [selB]
+    B = ptrace(rho, selB)
+    out = (entropy_vn(rho, base, sparse=sparse) -
+           entropy_vn(B, base, sparse=sparse))
+    return out
+
+
+def participation_ratio(rho):
+    """
+    Returns the effective number of states for a density matrix.
+
+    The participation is unity for pure states, and maximally N,
+    where N is the Hilbert space dimensionality, for completely
+    mixed states.
+
+    Parameters
+    ----------
+    rho : qobj
+        Density matrix
+
+    Returns
+    -------
+    pr : float
+        Effective number of states in the density matrix
+
+    """
+    if rho.type == 'ket' or rho.type == 'bra':
+        return 1.0
+    else:
+        return 1.0 / (rho ** 2).tr()
+
+
+def entangling_power(U):
+    """
+    Calculate the entangling power of a two-qubit gate U, which
+    is zero of nonentangling gates and 2/9 for maximally entangling gates.
+
+    Parameters
+    ----------
+    U : qobj
+        Qobj instance representing a two-qubit gate.
+
+    Returns
+    -------
+    ep : float
+        The entanglement power of U (real number between 0 and 2/9)
+
+    References:
+
+        Explorations in Quantum Computing, Colin P. Williams (Springer, 2011)
+    """
+
+    if not U.isoper:
+        raise Exception("U must be an operator.")
+
+    if U.dims != [[2, 2], [2, 2]]:
+        raise Exception("U must be a two-qubit gate.")
+
+    from qutip.core.gates import swap
+    swap13 =  expand_operator(swap(), [2, 2, 2, 2], [1, 3])
+    a = tensor(U, U).dag() * swap13 * tensor(U, U) * swap13
+    Uswap = swap() * U
+    b = tensor(Uswap, Uswap).dag() * swap13 * tensor(Uswap, Uswap) * swap13
+
+    return 5.0/9 - 1.0/36 * (a.tr() + b.tr()).real
diff --git a/qutip/fileio.py b/qutip/fileio.py
index 36bb1a5c55..ac94dd41f5 100644
--- a/qutip/fileio.py
+++ b/qutip/fileio.py
@@ -1,257 +1,257 @@
-__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
-
-import pickle
-import numpy as np
-import sys
-from .core import Qobj
-from pathlib import Path
-
-
-# -----------------------------------------------------------------------------
-# Write matrix data to a file
-#
-def file_data_store(filename, data, numtype="complex", numformat="decimal",
-                    sep=","):
-    """Stores a matrix of data to a file to be read by an external program.
-
-    Parameters
-    ----------
-    filename : str or pathlib.Path
-        Name of data file to be stored, including extension.
-    data: array_like
-        Data to be written to file.
-    numtype : str {'complex, 'real'}
-        Type of numerical data.
-    numformat : str {'decimal','exp'}
-        Format for written data.
-    sep : str
-        Single-character field seperator.  Usually a tab, space, comma,
-        or semicolon.
-
-    """
-    if filename is None or data is None:
-        raise ValueError("filename or data is unspecified")
-
-    M, N = np.shape(data)
-
-    f = open(filename, "w")
-
-    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
-            "in %s format ['%s' separated values].\n" % (numformat, sep))
-
-    if numtype == "complex":
-
-        if numformat == "exp":
-
-            for m in range(M):
-                for n in range(N):
-                    if np.imag(data[m, n]) >= 0.0:
-                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
-                                                  np.imag(data[m, n])))
-                    else:
-                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
-                                                 np.imag(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        elif numformat == "decimal":
-
-            for m in range(M):
-                for n in range(N):
-                    if np.imag(data[m, n]) >= 0.0:
-                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
-                                                  np.imag(data[m, n])))
-                    else:
-                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
-                                                 np.imag(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        else:
-            raise ValueError("Illegal numformat value (should be " +
-                             "'exp' or 'decimal')")
-
-    elif numtype == "real":
-
-        if numformat == "exp":
-
-            for m in range(M):
-                for n in range(N):
-                    f.write("%.10e" % (np.real(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        elif numformat == "decimal":
-
-            for m in range(M):
-                for n in range(N):
-                    f.write("%.10f" % (np.real(data[m, n])))
-                    if n != N - 1:
-                        f.write(sep)
-                f.write("\n")
-
-        else:
-            raise ValueError("Illegal numformat value (should be " +
-                             "'exp' or 'decimal')")
-
-    else:
-        raise ValueError("Illegal numtype value (should be " +
-                         "'complex' or 'real')")
-
-    f.close()
-
-
-# -----------------------------------------------------------------------------
-# Read matrix data from a file
-#
-def file_data_read(filename, sep=None):
-    """Retrieves an array of data from the requested file.
-
-    Parameters
-    ----------
-    filename : str or pathlib.Path
-        Name of file containing reqested data.
-    sep : str
-        Seperator used to store data.
-
-    Returns
-    -------
-    data : array_like
-        Data from selected file.
-
-    """
-    if filename is None:
-        raise ValueError("filename is unspecified")
-
-    f = open(filename, "r")
-
-    #
-    # first count lines and numbers of
-    #
-    M = N = 0
-    for line in f:
-        # skip comment lines
-        if line[0] == '#' or line[0] == '%':
-            continue
-        # find delim
-        if N == 0 and sep is None:
-            if len(line.rstrip().split(",")) > 1:
-                sep = ","
-            elif len(line.rstrip().split(";")) > 1:
-                sep = ";"
-            elif len(line.rstrip().split(":")) > 1:
-                sep = ":"
-            elif len(line.rstrip().split("|")) > 1:
-                sep = "|"
-            elif len(line.rstrip().split()) > 1:
-                # sepical case for a mix of white space deliminators
-                sep = None
-            else:
-                raise ValueError("Unrecognized column deliminator")
-        # split the line
-        line_vec = line.split(sep)
-        n = len(line_vec)
-        if N == 0 and n > 0:
-            N = n
-            # check type
-            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
-                numtype = "complex"
-            else:
-                numtype = "np.real"
-
-            # check format
-            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
-                numformat = "exp"
-            else:
-                numformat = "decimal"
-
-        elif N != n:
-            raise ValueError("Badly formatted data file: " +
-                             "unequal number of columns")
-        M += 1
-
-    #
-    # read data and store in a matrix
-    #
-    f.seek(0)
-
-    if numtype == "complex":
-        data = np.zeros((M, N), dtype="complex")
-        m = n = 0
-        for line in f:
-            # skip comment lines
-            if line[0] == '#' or line[0] == '%':
-                continue
-            n = 0
-            for item in line.rstrip().split(sep):
-                data[m, n] = complex(item)
-                n += 1
-            m += 1
-
-    else:
-        data = np.zeros((M, N), dtype="float")
-        m = n = 0
-        for line in f:
-            # skip comment lines
-            if line[0] == '#' or line[0] == '%':
-                continue
-            n = 0
-            for item in line.rstrip().split(sep):
-                data[m, n] = float(item)
-                n += 1
-            m += 1
-
-    f.close()
-
-    return data
-
-
-def qsave(data, name='qutip_data'):
-    """
-    Saves given data to file named 'filename.qu' in current directory.
-
-    Parameters
-    ----------
-    data : instance/array_like
-        Input Python object to be stored.
-    filename : str or pathlib.Path
-        Name of output data file.
-
-    """
-    # open the file for writing
-    path = Path(name)
-    path = path.with_suffix(path.suffix + ".qu")
-
-    with open(path, "wb") as fileObject:
-        # this writes the object a to the file named 'filename.qu'
-        pickle.dump(data, fileObject)
-
-
-def qload(name):
-    """
-    Loads data file from file named 'filename.qu' in current directory.
-
-    Parameters
-    ----------
-    name : str or pathlib.Path
-        Name of data file to be loaded.
-
-    Returns
-    -------
-    qobject : instance / array_like
-        Object retrieved from requested file.
-
-    """
-    path = Path(name)
-    path = path.with_suffix(path.suffix + ".qu")
-
-    with open(path, "rb") as fileObject:
-        if sys.version_info >= (3, 0):
-            out = pickle.load(fileObject, encoding='latin1')
-        else:
-            out = pickle.load(fileObject)
-
-    return out
+__all__ = ['file_data_store', 'file_data_read', 'qsave', 'qload']
+
+import pickle
+import numpy as np
+import sys
+from .core import Qobj
+from pathlib import Path
+
+
+# -----------------------------------------------------------------------------
+# Write matrix data to a file
+#
+def file_data_store(filename, data, numtype="complex", numformat="decimal",
+                    sep=","):
+    """Stores a matrix of data to a file to be read by an external program.
+
+    Parameters
+    ----------
+    filename : str or pathlib.Path
+        Name of data file to be stored, including extension.
+    data: array_like
+        Data to be written to file.
+    numtype : str {'complex, 'real'}
+        Type of numerical data.
+    numformat : str {'decimal','exp'}
+        Format for written data.
+    sep : str
+        Single-character field seperator.  Usually a tab, space, comma,
+        or semicolon.
+
+    """
+    if filename is None or data is None:
+        raise ValueError("filename or data is unspecified")
+
+    M, N = np.shape(data)
+
+    f = open(filename, "w")
+
+    f.write("# Generated by QuTiP: %dx%d %s matrix " % (M, N, numtype) +
+            "in %s format ['%s' separated values].\n" % (numformat, sep))
+
+    if numtype == "complex":
+
+        if numformat == "exp":
+
+            for m in range(M):
+                for n in range(N):
+                    if np.imag(data[m, n]) >= 0.0:
+                        f.write("%.10e+%.10ej" % (np.real(data[m, n]),
+                                                  np.imag(data[m, n])))
+                    else:
+                        f.write("%.10e%.10ej" % (np.real(data[m, n]),
+                                                 np.imag(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        elif numformat == "decimal":
+
+            for m in range(M):
+                for n in range(N):
+                    if np.imag(data[m, n]) >= 0.0:
+                        f.write("%.10f+%.10fj" % (np.real(data[m, n]),
+                                                  np.imag(data[m, n])))
+                    else:
+                        f.write("%.10f%.10fj" % (np.real(data[m, n]),
+                                                 np.imag(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        else:
+            raise ValueError("Illegal numformat value (should be " +
+                             "'exp' or 'decimal')")
+
+    elif numtype == "real":
+
+        if numformat == "exp":
+
+            for m in range(M):
+                for n in range(N):
+                    f.write("%.10e" % (np.real(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        elif numformat == "decimal":
+
+            for m in range(M):
+                for n in range(N):
+                    f.write("%.10f" % (np.real(data[m, n])))
+                    if n != N - 1:
+                        f.write(sep)
+                f.write("\n")
+
+        else:
+            raise ValueError("Illegal numformat value (should be " +
+                             "'exp' or 'decimal')")
+
+    else:
+        raise ValueError("Illegal numtype value (should be " +
+                         "'complex' or 'real')")
+
+    f.close()
+
+
+# -----------------------------------------------------------------------------
+# Read matrix data from a file
+#
+def file_data_read(filename, sep=None):
+    """Retrieves an array of data from the requested file.
+
+    Parameters
+    ----------
+    filename : str or pathlib.Path
+        Name of file containing reqested data.
+    sep : str
+        Seperator used to store data.
+
+    Returns
+    -------
+    data : array_like
+        Data from selected file.
+
+    """
+    if filename is None:
+        raise ValueError("filename is unspecified")
+
+    f = open(filename, "r")
+
+    #
+    # first count lines and numbers of
+    #
+    M = N = 0
+    for line in f:
+        # skip comment lines
+        if line[0] == '#' or line[0] == '%':
+            continue
+        # find delim
+        if N == 0 and sep is None:
+            if len(line.rstrip().split(",")) > 1:
+                sep = ","
+            elif len(line.rstrip().split(";")) > 1:
+                sep = ";"
+            elif len(line.rstrip().split(":")) > 1:
+                sep = ":"
+            elif len(line.rstrip().split("|")) > 1:
+                sep = "|"
+            elif len(line.rstrip().split()) > 1:
+                # sepical case for a mix of white space deliminators
+                sep = None
+            else:
+                raise ValueError("Unrecognized column deliminator")
+        # split the line
+        line_vec = line.split(sep)
+        n = len(line_vec)
+        if N == 0 and n > 0:
+            N = n
+            # check type
+            if ("j" in line_vec[0]) or ("i" in line_vec[0]):
+                numtype = "complex"
+            else:
+                numtype = "np.real"
+
+            # check format
+            if ("e" in line_vec[0]) or ("E" in line_vec[0]):
+                numformat = "exp"
+            else:
+                numformat = "decimal"
+
+        elif N != n:
+            raise ValueError("Badly formatted data file: " +
+                             "unequal number of columns")
+        M += 1
+
+    #
+    # read data and store in a matrix
+    #
+    f.seek(0)
+
+    if numtype == "complex":
+        data = np.zeros((M, N), dtype="complex")
+        m = n = 0
+        for line in f:
+            # skip comment lines
+            if line[0] == '#' or line[0] == '%':
+                continue
+            n = 0
+            for item in line.rstrip().split(sep):
+                data[m, n] = complex(item)
+                n += 1
+            m += 1
+
+    else:
+        data = np.zeros((M, N), dtype="float")
+        m = n = 0
+        for line in f:
+            # skip comment lines
+            if line[0] == '#' or line[0] == '%':
+                continue
+            n = 0
+            for item in line.rstrip().split(sep):
+                data[m, n] = float(item)
+                n += 1
+            m += 1
+
+    f.close()
+
+    return data
+
+
+def qsave(data, name='qutip_data'):
+    """
+    Saves given data to file named 'filename.qu' in current directory.
+
+    Parameters
+    ----------
+    data : instance/array_like
+        Input Python object to be stored.
+    filename : str or pathlib.Path
+        Name of output data file.
+
+    """
+    # open the file for writing
+    path = Path(name)
+    path = path.with_suffix(path.suffix + ".qu")
+
+    with open(path, "wb") as fileObject:
+        # this writes the object a to the file named 'filename.qu'
+        pickle.dump(data, fileObject)
+
+
+def qload(name):
+    """
+    Loads data file from file named 'filename.qu' in current directory.
+
+    Parameters
+    ----------
+    name : str or pathlib.Path
+        Name of data file to be loaded.
+
+    Returns
+    -------
+    qobject : instance / array_like
+        Object retrieved from requested file.
+
+    """
+    path = Path(name)
+    path = path.with_suffix(path.suffix + ".qu")
+
+    with open(path, "rb") as fileObject:
+        if sys.version_info >= (3, 0):
+            out = pickle.load(fileObject, encoding='latin1')
+        else:
+            out = pickle.load(fileObject)
+
+    return out
diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 0cf9d3b481..143a3b1c9d 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -1,326 +1,326 @@
-"""
-This module contains utility functions for using QuTiP with IPython notebooks.
-"""
-from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
-from .settings import _blas_info, available_cpu_count
-import IPython
-
-#IPython parallel routines moved to ipyparallel in V4
-#IPython parallel routines not in Anaconda by default
-if IPython.version_info[0] >= 4:
-    try:
-        from ipyparallel import Client
-        __all__ = ['version_table', 'plot_animation',
-                    'parallel_map']
-    except:
-         __all__ = ['version_table', 'plot_animation']
-else:
-    try:
-        from IPython.parallel import Client
-        __all__ = ['version_table', 'plot_animation',
-                    'parallel_map']
-    except:
-         __all__ = ['version_table', 'plot_animation']
-
-
-from IPython.display import HTML, Javascript, display
-
-import matplotlib.pyplot as plt
-from matplotlib import animation
-from base64 import b64encode
-
-import datetime
-import uuid
-import sys
-import os
-import time
-import inspect
-
-import qutip
-import numpy
-import scipy
-import matplotlib
-import IPython
-
-try:
-    import Cython
-    _cython_available = True
-except ImportError:
-    _cython_available = False
-
-
-def version_table(verbose=False):
-    """
-    Print an HTML-formatted table with version numbers for QuTiP and its
-    dependencies. Use it in a IPython notebook to show which versions of
-    different packages that were used to run the notebook. This should make it
-    possible to reproduce the environment and the calculation later on.
-
-
-    Returns
-    -------
-    version_table: string
-        Return an HTML-formatted string containing version information for
-        QuTiP dependencies.
-
-    """
-
-    html = "<table>"
-    html += "<tr><th>Software</th><th>Version</th></tr>"
-
-    packages = [("QuTiP", qutip.__version__),
-                ("Numpy", numpy.__version__),
-                ("SciPy", scipy.__version__),
-                ("matplotlib", matplotlib.__version__),
-                ("Number of CPUs", available_cpu_count()),
-                ("BLAS Info", _blas_info()),
-                ("IPython", IPython.__version__),
-                ("Python", sys.version),
-                ("OS", "%s [%s]" % (os.name, sys.platform))
-                ]
-    if _cython_available:
-        packages.append(("Cython", Cython.__version__))
-
-    for name, version in packages:
-        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
-
-    if verbose:
-        html += "<tr><th colspan='2'>Additional information</th></tr>"
-        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
-        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
-                 qutip_install_path)
-        try:
-            import getpass
-            html += ("<tr><td>User</td><td>%s</td></tr>" %
-                     getpass.getuser())
-        except:
-            pass
-
-    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
-        '%a %b %d %H:%M:%S %Y %Z')
-    html += "</table>"
-
-    return HTML(html)
-
-
-def _visualize_parfor_data(metadata):
-    """
-    Visualizing the task scheduling meta data collected from AsyncResults.
-    """
-    res = numpy.array(metadata)
-    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
-
-    yticks = []
-    yticklabels = []
-    tmin = min(res[:, 1])
-    for n, pid in enumerate(numpy.unique(res[:, 0])):
-        yticks.append(n)
-        yticklabels.append("%d" % pid)
-        for m in numpy.where(res[:, 0] == pid)[0]:
-            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
-                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
-
-    ax.set_ylim(-.5, n + .5)
-    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
-    ax.set_yticks(yticks)
-    ax.set_yticklabels(yticklabels)
-    ax.set_ylabel("Engine")
-    ax.set_xlabel("seconds")
-    ax.set_title("Task schedule")
-
-
-def parfor(task, task_vec, args=None, client=None, view=None,
-           show_scheduling=False, show_progressbar=False):
-    """
-    Call the function ``tast`` for each value in ``task_vec`` using a cluster
-    of IPython engines. The function ``task`` should have the signature
-    ``task(value, args)`` or ``task(value)`` if ``args=None``.
-
-    The ``client`` and ``view`` are the IPython.parallel client and
-    load-balanced view that will be used in the parfor execution. If these
-    are ``None``, new instances will be created.
-
-    Parameters
-    ----------
-
-    task: a Python function
-        The function that is to be called for each value in ``task_vec``.
-
-    task_vec: array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-
-    args: list / dictionary
-        The optional additional argument to the ``task`` function. For example
-        a dictionary with parameter values.
-
-    client: IPython.parallel.Client
-        The IPython.parallel Client instance that will be used in the
-        parfor execution.
-
-    view: a IPython.parallel.Client view
-        The view that is to be used in scheduling the tasks on the IPython
-        cluster. Preferably a load-balanced view, which is obtained from the
-        IPython.parallel.Client instance client by calling,
-        view = client.load_balanced_view().
-
-    show_scheduling: bool {False, True}, default False
-        Display a graph showing how the tasks (the evaluation of ``task`` for
-        for the value in ``task_vec1``) was scheduled on the IPython engine
-        cluster.
-
-    show_progressbar: bool {False, True}, default False
-        Display a HTML-based progress bar duing the execution of the parfor
-        loop.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of ``task(value, args)`` for each
-        value in ``task_vec``, that is, it should be equivalent to
-        ``[task(v, args) for v in task_vec]``.
-    """
-
-    if show_progressbar:
-        progress_bar = HTMLProgressBar()
-    else:
-        progress_bar = None
-
-    return parallel_map(task, task_vec, task_args=args,
-                        client=client, view=view, progress_bar=progress_bar,
-                        show_scheduling=show_scheduling)
-
-
-def parallel_map(task, values, task_args=None, task_kwargs=None,
-                 client=None, view=None, progress_bar=None,
-                 show_scheduling=False, **kwargs):
-    """
-    Call the function ``task`` for each value in ``values`` using a cluster
-    of IPython engines. The function ``task`` should have the signature
-    ``task(value, *args, **kwargs)``.
-
-    The ``client`` and ``view`` are the IPython.parallel client and
-    load-balanced view that will be used in the parfor execution. If these
-    are ``None``, new instances will be created.
-
-    Parameters
-    ----------
-
-    task: a Python function
-        The function that is to be called for each value in ``task_vec``.
-
-    values: array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-
-    task_args: list / dictionary
-        The optional additional argument to the ``task`` function.
-
-    task_kwargs: list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-
-    client: IPython.parallel.Client
-        The IPython.parallel Client instance that will be used in the
-        parfor execution.
-
-    view: a IPython.parallel.Client view
-        The view that is to be used in scheduling the tasks on the IPython
-        cluster. Preferably a load-balanced view, which is obtained from the
-        IPython.parallel.Client instance client by calling,
-        view = client.load_balanced_view().
-
-    show_scheduling: bool {False, True}, default False
-        Display a graph showing how the tasks (the evaluation of ``task`` for
-        for the value in ``task_vec1``) was scheduled on the IPython engine
-        cluster.
-
-    show_progressbar: bool {False, True}, default False
-        Display a HTML-based progress bar during the execution of the parfor
-        loop.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of
-        ``task(value, task_args, task_kwargs)`` for each
-        value in ``values``.
-
-    """
-    submitted = datetime.datetime.now()
-
-    if task_args is None:
-        task_args = tuple()
-
-    if task_kwargs is None:
-        task_kwargs = {}
-
-    if client is None:
-        client = Client()
-
-        # make sure qutip is available at engines
-        dview = client[:]
-        dview.block = True
-        dview.execute("from qutip import *")
-
-    if view is None:
-        view = client.load_balanced_view()
-
-    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
-               for value in values]
-
-    if progress_bar is None:
-        view.wait(ar_list)
-    else:
-        if progress_bar is True:
-            progress_bar = HTMLProgressBar()
-
-        n = len(ar_list)
-        progress_bar.start(n)
-        while True:
-            n_finished = sum([ar.progress for ar in ar_list])
-            progress_bar.update(n_finished)
-
-            if view.wait(ar_list, timeout=0.5):
-                progress_bar.update(n)
-                break
-        progress_bar.finished()
-
-    if show_scheduling:
-        metadata = [[ar.engine_id,
-                     (ar.started - submitted).total_seconds(),
-                     (ar.completed - submitted).total_seconds()]
-                    for ar in ar_list]
-        _visualize_parfor_data(metadata)
-
-    return [ar.get() for ar in ar_list]
-
-
-def plot_animation(plot_setup_func, plot_func, result, name="movie",
-                   writer="avconv", codec="libx264", verbose=False):
-    """
-    Create an animated plot of a Result object, as returned by one of
-    the qutip evolution solvers.
-
-    .. note :: experimental
-    """
-
-    fig, axes = plot_setup_func(result)
-
-    def update(n):
-        return plot_func(result, n, fig=fig, axes=axes)
-
-    anim = animation.FuncAnimation(
-        fig, update, frames=len(result.times), blit=True)
-
-    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
-
-    plt.close(fig)
-
-    if verbose:
-        print("Created %s.m4v" % name)
-
-    video = open(name + '.mp4', "rb").read()
-    video_encoded = b64encode(video).decode("ascii")
-    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
-        video_encoded)
-    return HTML(video_tag)
+"""
+This module contains utility functions for using QuTiP with IPython notebooks.
+"""
+from qutip.ui.progressbar import BaseProgressBar, HTMLProgressBar
+from .settings import _blas_info, available_cpu_count
+import IPython
+
+#IPython parallel routines moved to ipyparallel in V4
+#IPython parallel routines not in Anaconda by default
+if IPython.version_info[0] >= 4:
+    try:
+        from ipyparallel import Client
+        __all__ = ['version_table', 'plot_animation',
+                    'parallel_map']
+    except:
+         __all__ = ['version_table', 'plot_animation']
+else:
+    try:
+        from IPython.parallel import Client
+        __all__ = ['version_table', 'plot_animation',
+                    'parallel_map']
+    except:
+         __all__ = ['version_table', 'plot_animation']
+
+
+from IPython.display import HTML, Javascript, display
+
+import matplotlib.pyplot as plt
+from matplotlib import animation
+from base64 import b64encode
+
+import datetime
+import uuid
+import sys
+import os
+import time
+import inspect
+
+import qutip
+import numpy
+import scipy
+import matplotlib
+import IPython
+
+try:
+    import Cython
+    _cython_available = True
+except ImportError:
+    _cython_available = False
+
+
+def version_table(verbose=False):
+    """
+    Print an HTML-formatted table with version numbers for QuTiP and its
+    dependencies. Use it in a IPython notebook to show which versions of
+    different packages that were used to run the notebook. This should make it
+    possible to reproduce the environment and the calculation later on.
+
+
+    Returns
+    -------
+    version_table: string
+        Return an HTML-formatted string containing version information for
+        QuTiP dependencies.
+
+    """
+
+    html = "<table>"
+    html += "<tr><th>Software</th><th>Version</th></tr>"
+
+    packages = [("QuTiP", qutip.__version__),
+                ("Numpy", numpy.__version__),
+                ("SciPy", scipy.__version__),
+                ("matplotlib", matplotlib.__version__),
+                ("Number of CPUs", available_cpu_count()),
+                ("BLAS Info", _blas_info()),
+                ("IPython", IPython.__version__),
+                ("Python", sys.version),
+                ("OS", "%s [%s]" % (os.name, sys.platform))
+                ]
+    if _cython_available:
+        packages.append(("Cython", Cython.__version__))
+
+    for name, version in packages:
+        html += "<tr><td>%s</td><td>%s</td></tr>" % (name, version)
+
+    if verbose:
+        html += "<tr><th colspan='2'>Additional information</th></tr>"
+        qutip_install_path = os.path.dirname(inspect.getsourcefile(qutip))
+        html += ("<tr><td>Installation path</td><td>%s</td></tr>" %
+                 qutip_install_path)
+        try:
+            import getpass
+            html += ("<tr><td>User</td><td>%s</td></tr>" %
+                     getpass.getuser())
+        except:
+            pass
+
+    html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime(
+        '%a %b %d %H:%M:%S %Y %Z')
+    html += "</table>"
+
+    return HTML(html)
+
+
+def _visualize_parfor_data(metadata):
+    """
+    Visualizing the task scheduling meta data collected from AsyncResults.
+    """
+    res = numpy.array(metadata)
+    fig, ax = plt.subplots(figsize=(10, res.shape[1]))
+
+    yticks = []
+    yticklabels = []
+    tmin = min(res[:, 1])
+    for n, pid in enumerate(numpy.unique(res[:, 0])):
+        yticks.append(n)
+        yticklabels.append("%d" % pid)
+        for m in numpy.where(res[:, 0] == pid)[0]:
+            ax.add_patch(plt.Rectangle((res[m, 1] - tmin, n - 0.25),
+                         res[m, 2] - res[m, 1], 0.5, color="green", alpha=0.5))
+
+    ax.set_ylim(-.5, n + .5)
+    ax.set_xlim(0, max(res[:, 2]) - tmin + 0.)
+    ax.set_yticks(yticks)
+    ax.set_yticklabels(yticklabels)
+    ax.set_ylabel("Engine")
+    ax.set_xlabel("seconds")
+    ax.set_title("Task schedule")
+
+
+def parfor(task, task_vec, args=None, client=None, view=None,
+           show_scheduling=False, show_progressbar=False):
+    """
+    Call the function ``tast`` for each value in ``task_vec`` using a cluster
+    of IPython engines. The function ``task`` should have the signature
+    ``task(value, args)`` or ``task(value)`` if ``args=None``.
+
+    The ``client`` and ``view`` are the IPython.parallel client and
+    load-balanced view that will be used in the parfor execution. If these
+    are ``None``, new instances will be created.
+
+    Parameters
+    ----------
+
+    task: a Python function
+        The function that is to be called for each value in ``task_vec``.
+
+    task_vec: array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+
+    args: list / dictionary
+        The optional additional argument to the ``task`` function. For example
+        a dictionary with parameter values.
+
+    client: IPython.parallel.Client
+        The IPython.parallel Client instance that will be used in the
+        parfor execution.
+
+    view: a IPython.parallel.Client view
+        The view that is to be used in scheduling the tasks on the IPython
+        cluster. Preferably a load-balanced view, which is obtained from the
+        IPython.parallel.Client instance client by calling,
+        view = client.load_balanced_view().
+
+    show_scheduling: bool {False, True}, default False
+        Display a graph showing how the tasks (the evaluation of ``task`` for
+        for the value in ``task_vec1``) was scheduled on the IPython engine
+        cluster.
+
+    show_progressbar: bool {False, True}, default False
+        Display a HTML-based progress bar duing the execution of the parfor
+        loop.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of ``task(value, args)`` for each
+        value in ``task_vec``, that is, it should be equivalent to
+        ``[task(v, args) for v in task_vec]``.
+    """
+
+    if show_progressbar:
+        progress_bar = HTMLProgressBar()
+    else:
+        progress_bar = None
+
+    return parallel_map(task, task_vec, task_args=args,
+                        client=client, view=view, progress_bar=progress_bar,
+                        show_scheduling=show_scheduling)
+
+
+def parallel_map(task, values, task_args=None, task_kwargs=None,
+                 client=None, view=None, progress_bar=None,
+                 show_scheduling=False, **kwargs):
+    """
+    Call the function ``task`` for each value in ``values`` using a cluster
+    of IPython engines. The function ``task`` should have the signature
+    ``task(value, *args, **kwargs)``.
+
+    The ``client`` and ``view`` are the IPython.parallel client and
+    load-balanced view that will be used in the parfor execution. If these
+    are ``None``, new instances will be created.
+
+    Parameters
+    ----------
+
+    task: a Python function
+        The function that is to be called for each value in ``task_vec``.
+
+    values: array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+
+    task_args: list / dictionary
+        The optional additional argument to the ``task`` function.
+
+    task_kwargs: list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+
+    client: IPython.parallel.Client
+        The IPython.parallel Client instance that will be used in the
+        parfor execution.
+
+    view: a IPython.parallel.Client view
+        The view that is to be used in scheduling the tasks on the IPython
+        cluster. Preferably a load-balanced view, which is obtained from the
+        IPython.parallel.Client instance client by calling,
+        view = client.load_balanced_view().
+
+    show_scheduling: bool {False, True}, default False
+        Display a graph showing how the tasks (the evaluation of ``task`` for
+        for the value in ``task_vec1``) was scheduled on the IPython engine
+        cluster.
+
+    show_progressbar: bool {False, True}, default False
+        Display a HTML-based progress bar during the execution of the parfor
+        loop.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of
+        ``task(value, task_args, task_kwargs)`` for each
+        value in ``values``.
+
+    """
+    submitted = datetime.datetime.now()
+
+    if task_args is None:
+        task_args = tuple()
+
+    if task_kwargs is None:
+        task_kwargs = {}
+
+    if client is None:
+        client = Client()
+
+        # make sure qutip is available at engines
+        dview = client[:]
+        dview.block = True
+        dview.execute("from qutip import *")
+
+    if view is None:
+        view = client.load_balanced_view()
+
+    ar_list = [view.apply_async(task, value, *task_args, **task_kwargs)
+               for value in values]
+
+    if progress_bar is None:
+        view.wait(ar_list)
+    else:
+        if progress_bar is True:
+            progress_bar = HTMLProgressBar()
+
+        n = len(ar_list)
+        progress_bar.start(n)
+        while True:
+            n_finished = sum([ar.progress for ar in ar_list])
+            progress_bar.update(n_finished)
+
+            if view.wait(ar_list, timeout=0.5):
+                progress_bar.update(n)
+                break
+        progress_bar.finished()
+
+    if show_scheduling:
+        metadata = [[ar.engine_id,
+                     (ar.started - submitted).total_seconds(),
+                     (ar.completed - submitted).total_seconds()]
+                    for ar in ar_list]
+        _visualize_parfor_data(metadata)
+
+    return [ar.get() for ar in ar_list]
+
+
+def plot_animation(plot_setup_func, plot_func, result, name="movie",
+                   writer="avconv", codec="libx264", verbose=False):
+    """
+    Create an animated plot of a Result object, as returned by one of
+    the qutip evolution solvers.
+
+    .. note :: experimental
+    """
+
+    fig, axes = plot_setup_func(result)
+
+    def update(n):
+        return plot_func(result, n, fig=fig, axes=axes)
+
+    anim = animation.FuncAnimation(
+        fig, update, frames=len(result.times), blit=True)
+
+    anim.save(name + '.mp4', fps=10, writer=writer, codec=codec)
+
+    plt.close(fig)
+
+    if verbose:
+        print("Created %s.m4v" % name)
+
+    video = open(name + '.mp4', "rb").read()
+    video_encoded = b64encode(video).decode("ascii")
+    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
+        video_encoded)
+    return HTML(video_tag)
diff --git a/qutip/logging_utils.py b/qutip/logging_utils.py
index 915049d999..c91b380b50 100644
--- a/qutip/logging_utils.py
+++ b/qutip/logging_utils.py
@@ -1,109 +1,109 @@
-"""
-This module contains internal-use functions for configuring and writing to
-debug logs, using Python's internal logging functionality by default.
-"""
-
-# IMPORTS
-from __future__ import absolute_import
-import inspect
-import logging
-
-from qutip.settings import settings
-
-# EXPORTS
-NOTSET = logging.NOTSET
-DEBUG_INTENSE = logging.DEBUG - 4
-DEBUG_VERBOSE = logging.DEBUG - 2
-DEBUG = logging.DEBUG
-INFO = logging.INFO
-WARN = logging.WARN
-ERROR = logging.ERROR
-CRITICAL = logging.CRITICAL
-
-__all__ = ['get_logger']
-
-# META-LOGGING
-
-metalogger = logging.getLogger(__name__)
-metalogger.addHandler(logging.NullHandler())
-
-
-# FUNCTIONS
-
-def get_logger(name=None):
-    """
-    Returns a Python logging object with handlers configured
-    in accordance with ~/.qutiprc. By default, this will do
-    something sensible to integrate with IPython when running
-    in that environment, and will print to stdout otherwise.
-
-    Note that this function uses a bit of magic, and thus should
-    not be considered part of the QuTiP API. Rather, this function
-    is for internal use only.
-
-    Parameters
-    ----------
-
-    name : str
-        Name of the logger to be created. If not passed,
-        the name will automatically be set to the name of the
-        calling module.
-    """
-    if name is None:
-        try:
-            calling_frame = inspect.stack()[1][0]
-            calling_module = inspect.getmodule(calling_frame)
-            name = (calling_module.__name__
-                    if calling_module is not None else '<none>')
-
-        except Exception:
-            metalogger.warn('Error creating logger.', exc_info=1)
-            name = '<unknown>'
-
-    logger = logging.getLogger(name)
-
-    policy = settings.log_handler
-
-    if policy == 'default':
-        # Let's try to see if we're in IPython mode.
-        policy = 'basic' if settings.ipython else 'stream'
-
-    metalogger.debug("Creating logger for {} with policy {}.".format(
-        name, policy
-    ))
-
-    if policy == 'basic':
-        # Add no handlers, just let basicConfig do it all.
-        # This is nice for working with IPython, since
-        # it will use its own handlers instead of our StreamHandler
-        # below.
-        if settings.debug:
-            logging.basicConfig(level=logging.DEBUG)
-        else:
-            logging.basicConfig()
-
-    elif policy == 'stream':
-        formatter = logging.Formatter(
-            '[%(asctime)s] %(name)s[%(process)s]: '
-            '%(funcName)s: %(levelname)s: %(message)s',
-            '%Y-%m-%d %H:%M:%S')
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        # We're handling things here, so no propagation out.
-        logger.propagate = False
-
-    elif policy == 'null':
-        # We need to add a NullHandler so that debugging works
-        # at all, but this policy leaves it to the user to
-        # make their own handlers. This is particularly useful
-        # for capturing to logfiles.
-        logger.addHandler(logging.NullHandler())
-
-    if settings.debug:
-        logger.setLevel(logging.DEBUG)
-    else:
-        logger.setLevel(logging.WARN)
-
-    return logger
+"""
+This module contains internal-use functions for configuring and writing to
+debug logs, using Python's internal logging functionality by default.
+"""
+
+# IMPORTS
+from __future__ import absolute_import
+import inspect
+import logging
+
+from qutip.settings import settings
+
+# EXPORTS
+NOTSET = logging.NOTSET
+DEBUG_INTENSE = logging.DEBUG - 4
+DEBUG_VERBOSE = logging.DEBUG - 2
+DEBUG = logging.DEBUG
+INFO = logging.INFO
+WARN = logging.WARN
+ERROR = logging.ERROR
+CRITICAL = logging.CRITICAL
+
+__all__ = ['get_logger']
+
+# META-LOGGING
+
+metalogger = logging.getLogger(__name__)
+metalogger.addHandler(logging.NullHandler())
+
+
+# FUNCTIONS
+
+def get_logger(name=None):
+    """
+    Returns a Python logging object with handlers configured
+    in accordance with ~/.qutiprc. By default, this will do
+    something sensible to integrate with IPython when running
+    in that environment, and will print to stdout otherwise.
+
+    Note that this function uses a bit of magic, and thus should
+    not be considered part of the QuTiP API. Rather, this function
+    is for internal use only.
+
+    Parameters
+    ----------
+
+    name : str
+        Name of the logger to be created. If not passed,
+        the name will automatically be set to the name of the
+        calling module.
+    """
+    if name is None:
+        try:
+            calling_frame = inspect.stack()[1][0]
+            calling_module = inspect.getmodule(calling_frame)
+            name = (calling_module.__name__
+                    if calling_module is not None else '<none>')
+
+        except Exception:
+            metalogger.warn('Error creating logger.', exc_info=1)
+            name = '<unknown>'
+
+    logger = logging.getLogger(name)
+
+    policy = settings.log_handler
+
+    if policy == 'default':
+        # Let's try to see if we're in IPython mode.
+        policy = 'basic' if settings.ipython else 'stream'
+
+    metalogger.debug("Creating logger for {} with policy {}.".format(
+        name, policy
+    ))
+
+    if policy == 'basic':
+        # Add no handlers, just let basicConfig do it all.
+        # This is nice for working with IPython, since
+        # it will use its own handlers instead of our StreamHandler
+        # below.
+        if settings.debug:
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig()
+
+    elif policy == 'stream':
+        formatter = logging.Formatter(
+            '[%(asctime)s] %(name)s[%(process)s]: '
+            '%(funcName)s: %(levelname)s: %(message)s',
+            '%Y-%m-%d %H:%M:%S')
+        handler = logging.StreamHandler()
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+        # We're handling things here, so no propagation out.
+        logger.propagate = False
+
+    elif policy == 'null':
+        # We need to add a NullHandler so that debugging works
+        # at all, but this policy leaves it to the user to
+        # make their own handlers. This is particularly useful
+        # for capturing to logfiles.
+        logger.addHandler(logging.NullHandler())
+
+    if settings.debug:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.WARN)
+
+    return logger
diff --git a/qutip/matplotlib_utilities.py b/qutip/matplotlib_utilities.py
index 816a4eb1cb..3181b29192 100644
--- a/qutip/matplotlib_utilities.py
+++ b/qutip/matplotlib_utilities.py
@@ -1,154 +1,154 @@
-"""
-This module contains utility functions that enhance Matplotlib
-in one way or another.
-"""
-
-__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
-
-import numpy as np
-
-try:
-    import matplotlib as mpl
-    from matplotlib import cm
-    from matplotlib.colors import (Normalize, ColorConverter)
-except:
-    class Normalize(object):
-        def __init__(self, vmin=None, vmax=None, clip=False):
-            pass
-
-
-def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
-                mid_color='#FFFFFF', min_color='#530017',
-                neg_color='#FF97D4', invert=False):
-    """A custom colormap that emphasizes negative values by creating a
-    nonlinear colormap.
-
-    Parameters
-    ----------
-    W : array
-        Wigner function array, or any array.
-    levels : int
-        Number of color levels to create.
-    shift : float
-        Shifts the value at which Wigner elements are emphasized.
-        This parameter should typically be negative and small (i.e -1e-5).
-    max_color : str
-        String for color corresponding to maximum value of data.  Accepts
-        any string format compatible with the Matplotlib.colors.ColorConverter.
-    mid_color : str
-        Color corresponding to zero values.  Accepts any string format
-        compatible with the Matplotlib.colors.ColorConverter.
-    min_color : str
-        Color corresponding to minimum data values.  Accepts any string format
-        compatible with the Matplotlib.colors.ColorConverter.
-    neg_color : str
-        Color that starts highlighting negative values.  Accepts any string
-        format compatible with the Matplotlib.colors.ColorConverter.
-    invert : bool
-        Invert the color scheme for negative values so that smaller negative
-        values have darker color.
-
-    Returns
-    -------
-    Returns a Matplotlib colormap instance for use in plotting.
-
-    Notes
-    -----
-    The 'shift' parameter allows you to vary where the colormap begins
-    to highlight negative colors. This is beneficial in cases where there
-    are small negative Wigner elements due to numerical round-off and/or
-    truncation.
-
-    """
-    cc = ColorConverter()
-    max_color = np.array(cc.to_rgba(max_color), dtype=float)
-    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
-    if invert:
-        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
-        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
-    else:
-        min_color = np.array(cc.to_rgba(min_color), dtype=float)
-        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
-    # get min and max values from Wigner function
-    bounds = [W.min(), W.max()]
-    # create empty array for RGBA colors
-    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
-    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
-                        / (bounds[1] - bounds[0])))
-    num_pos = levels - zero_pos
-    num_neg = zero_pos - 1
-    # set zero values to mid_color
-    adjust_RGBA[zero_pos] = mid_color
-    # interpolate colors
-    for k in range(0, levels):
-        if k < zero_pos:
-            interp = k / (num_neg + 1.0)
-            adjust_RGBA[k][0:3] = (1.0 - interp) * \
-                min_color[0:3] + interp * neg_color[0:3]
-        elif k > zero_pos:
-            interp = (k - zero_pos) / (num_pos + 1.0)
-            adjust_RGBA[k][0:3] = (1.0 - interp) * \
-                mid_color[0:3] + interp * max_color[0:3]
-    # create colormap
-    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
-                                                            adjust_RGBA,
-                                                            N=levels)
-    return wig_cmap
-
-
-def complex_phase_cmap():
-    """
-    Create a cyclic colormap for representing the phase of complex variables
-
-    Returns
-    -------
-    cmap :
-        A matplotlib linear segmented colormap.
-    """
-    cdict = {'blue': ((0.00, 0.0, 0.0),
-                      (0.25, 0.0, 0.0),
-                      (0.50, 1.0, 1.0),
-                      (0.75, 1.0, 1.0),
-                      (1.00, 0.0, 0.0)),
-             'green': ((0.00, 0.0, 0.0),
-                       (0.25, 1.0, 1.0),
-                       (0.50, 0.0, 0.0),
-                       (0.75, 1.0, 1.0),
-                       (1.00, 0.0, 0.0)),
-             'red': ((0.00, 1.0, 1.0),
-                     (0.25, 0.5, 0.5),
-                     (0.50, 0.0, 0.0),
-                     (0.75, 0.0, 0.0),
-                     (1.00, 1.0, 1.0))}
-
-    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
-
-    return cmap
-
-
-class MidpointNorm(Normalize):
-    """Normalization for a colormap centered about a given midpoint.
-
-    Parameters
-    ----------
-    midpoint : float (optional, default=0)
-        Midpoint about which colormap is centered.
-    vmin: float (optional)
-        Minimal value for colormap. Calculated from data by default.
-    vmax: float (optional)
-        Maximal value for colormap. Calculated from data by default.
-
-    Returns
-    -------
-    Returns a Matplotlib colormap normalization that can be used
-    with any colormap.
-
-    """
-
-    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
-        self.midpoint = midpoint
-        Normalize.__init__(self, vmin, vmax, clip)
-
-    def __call__(self, value, clip=None):
-        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
-        return np.ma.masked_array(np.interp(value, x, y))
+"""
+This module contains utility functions that enhance Matplotlib
+in one way or another.
+"""
+
+__all__ = ['wigner_cmap', 'MidpointNorm', 'complex_phase_cmap']
+
+import numpy as np
+
+try:
+    import matplotlib as mpl
+    from matplotlib import cm
+    from matplotlib.colors import (Normalize, ColorConverter)
+except:
+    class Normalize(object):
+        def __init__(self, vmin=None, vmax=None, clip=False):
+            pass
+
+
+def wigner_cmap(W, levels=1024, shift=0, max_color='#09224F',
+                mid_color='#FFFFFF', min_color='#530017',
+                neg_color='#FF97D4', invert=False):
+    """A custom colormap that emphasizes negative values by creating a
+    nonlinear colormap.
+
+    Parameters
+    ----------
+    W : array
+        Wigner function array, or any array.
+    levels : int
+        Number of color levels to create.
+    shift : float
+        Shifts the value at which Wigner elements are emphasized.
+        This parameter should typically be negative and small (i.e -1e-5).
+    max_color : str
+        String for color corresponding to maximum value of data.  Accepts
+        any string format compatible with the Matplotlib.colors.ColorConverter.
+    mid_color : str
+        Color corresponding to zero values.  Accepts any string format
+        compatible with the Matplotlib.colors.ColorConverter.
+    min_color : str
+        Color corresponding to minimum data values.  Accepts any string format
+        compatible with the Matplotlib.colors.ColorConverter.
+    neg_color : str
+        Color that starts highlighting negative values.  Accepts any string
+        format compatible with the Matplotlib.colors.ColorConverter.
+    invert : bool
+        Invert the color scheme for negative values so that smaller negative
+        values have darker color.
+
+    Returns
+    -------
+    Returns a Matplotlib colormap instance for use in plotting.
+
+    Notes
+    -----
+    The 'shift' parameter allows you to vary where the colormap begins
+    to highlight negative colors. This is beneficial in cases where there
+    are small negative Wigner elements due to numerical round-off and/or
+    truncation.
+
+    """
+    cc = ColorConverter()
+    max_color = np.array(cc.to_rgba(max_color), dtype=float)
+    mid_color = np.array(cc.to_rgba(mid_color), dtype=float)
+    if invert:
+        min_color = np.array(cc.to_rgba(neg_color), dtype=float)
+        neg_color = np.array(cc.to_rgba(min_color), dtype=float)
+    else:
+        min_color = np.array(cc.to_rgba(min_color), dtype=float)
+        neg_color = np.array(cc.to_rgba(neg_color), dtype=float)
+    # get min and max values from Wigner function
+    bounds = [W.min(), W.max()]
+    # create empty array for RGBA colors
+    adjust_RGBA = np.hstack((np.zeros((levels, 3)), np.ones((levels, 1))))
+    zero_pos = int(np.round(levels * np.abs(shift - bounds[0])
+                        / (bounds[1] - bounds[0])))
+    num_pos = levels - zero_pos
+    num_neg = zero_pos - 1
+    # set zero values to mid_color
+    adjust_RGBA[zero_pos] = mid_color
+    # interpolate colors
+    for k in range(0, levels):
+        if k < zero_pos:
+            interp = k / (num_neg + 1.0)
+            adjust_RGBA[k][0:3] = (1.0 - interp) * \
+                min_color[0:3] + interp * neg_color[0:3]
+        elif k > zero_pos:
+            interp = (k - zero_pos) / (num_pos + 1.0)
+            adjust_RGBA[k][0:3] = (1.0 - interp) * \
+                mid_color[0:3] + interp * max_color[0:3]
+    # create colormap
+    wig_cmap = mpl.colors.LinearSegmentedColormap.from_list('wigner_cmap',
+                                                            adjust_RGBA,
+                                                            N=levels)
+    return wig_cmap
+
+
+def complex_phase_cmap():
+    """
+    Create a cyclic colormap for representing the phase of complex variables
+
+    Returns
+    -------
+    cmap :
+        A matplotlib linear segmented colormap.
+    """
+    cdict = {'blue': ((0.00, 0.0, 0.0),
+                      (0.25, 0.0, 0.0),
+                      (0.50, 1.0, 1.0),
+                      (0.75, 1.0, 1.0),
+                      (1.00, 0.0, 0.0)),
+             'green': ((0.00, 0.0, 0.0),
+                       (0.25, 1.0, 1.0),
+                       (0.50, 0.0, 0.0),
+                       (0.75, 1.0, 1.0),
+                       (1.00, 0.0, 0.0)),
+             'red': ((0.00, 1.0, 1.0),
+                     (0.25, 0.5, 0.5),
+                     (0.50, 0.0, 0.0),
+                     (0.75, 0.0, 0.0),
+                     (1.00, 1.0, 1.0))}
+
+    cmap = mpl.colors.LinearSegmentedColormap('phase_colormap', cdict, 256)
+
+    return cmap
+
+
+class MidpointNorm(Normalize):
+    """Normalization for a colormap centered about a given midpoint.
+
+    Parameters
+    ----------
+    midpoint : float (optional, default=0)
+        Midpoint about which colormap is centered.
+    vmin: float (optional)
+        Minimal value for colormap. Calculated from data by default.
+    vmax: float (optional)
+        Maximal value for colormap. Calculated from data by default.
+
+    Returns
+    -------
+    Returns a Matplotlib colormap normalization that can be used
+    with any colormap.
+
+    """
+
+    def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
+        self.midpoint = midpoint
+        Normalize.__init__(self, vmin, vmax, clip)
+
+    def __call__(self, value, clip=None):
+        x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+        return np.ma.masked_array(np.interp(value, x, y))
diff --git a/qutip/measurement.py b/qutip/measurement.py
index 65e2f1ca83..da90387dd0 100644
--- a/qutip/measurement.py
+++ b/qutip/measurement.py
@@ -1,381 +1,381 @@
-"""
-Module for measuring quantum objects.
-"""
-
-__all__ = [
-    'measurement_statistics_povm',
-    'measurement_statistics_observable',
-    'measure_observable',
-    'measure_povm',
-    'measurement_statistics',
-    'measure'
-]
-
-import numpy as np
-
-from . import Qobj, expect, identity, tensor
-
-
-def _verify_input(op, state):
-    if not isinstance(op, Qobj):
-        raise TypeError("op must be a Qobj")
-    if not op.isoper:
-        raise ValueError("op must be all operators or all kets")
-    if not isinstance(state, Qobj):
-        raise TypeError("state must be a Qobj")
-    if state.isket:
-        if op.dims[-1] != state.dims[0]:
-            raise ValueError(
-                "op and state dims should be compatible when state is a ket")
-    elif state.isoper:
-        if op.dims != state.dims:
-            raise ValueError(
-                "op and state dims should match"
-                " when state is a density matrix")
-    else:
-        raise ValueError("state must be a ket or a density matrix")
-
-
-def _measurement_statistics_povm_ket(state, ops):
-    r"""
-    Returns measurement statistics (resultant states and probabilities)
-    for a measurements specified by a set of positive operator valued
-    measurements on a specified ket.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj` (ket)
-            The ket specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-      List of measurement operators :math:`M_i` (specifying a POVM such that
-      :math:`E_i = M_i^\dagger M_i`).
-
-
-    Returns
-    -------
-    collapsed_states : list of :class:`.Qobj` (kets)
-        The collapsed states (kets) obtained after measuring the qubits and
-        obtaining the qubit specified by the target in the state specified by
-        the index.
-
-    probabilities : list of floats
-        The probability of measuring a state in a the state specified by the
-        index.
-    """
-    probabilities = []
-    collapsed_states = []
-
-    for i, op in enumerate(ops):
-        p = np.absolute((state.dag() * op.dag() * op * state))
-        probabilities.append(p)
-        if p != 0:
-            collapsed_states.append((op * state) / np.sqrt(p))
-        else:
-            collapsed_states.append(None)
-
-    return collapsed_states, probabilities
-
-
-def _measurement_statistics_povm_dm(density_mat, ops):
-    r"""
-    Returns measurement statistics (resultant states and probabilities)
-    for a measurements specified by a set of positive operator valued
-    measurements on a specified ket or density matrix.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj` (density matrix)
-        The ket or density matrix specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-        List of measurement operators :math:`M_i` (specifying a POVM s.t.
-        :mathm:`E_i = M_i^\dagger M_i`)
-
-    Returns
-    -------
-    collapsed_states : list of :class:`.Qobj`
-        The collapsed states (density matrices) obtained after measuring the
-        qubits and obtaining the qubit specified by the target in the state
-        specified by the index.
-
-    probabilities : list of float
-        The probability of measuring a state in a the state specified by the
-        index.
-    """
-    probabilities = []
-    collapsed_states = []
-
-    for i, op in enumerate(ops):
-        st = op * density_mat * op.dag()
-        p = st.tr()
-        probabilities.append(p)
-        if p != 0:
-            collapsed_states.append(st/p)
-        else:
-            collapsed_states.append(None)
-
-    return collapsed_states, probabilities
-
-
-def measurement_statistics_povm(state, ops):
-    r"""
-    Returns measurement statistics (resultant states and probabilities) for a
-    measurement specified by a set of positive operator valued measurements on
-    a specified ket or density matrix.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-        List of measurement operators :math:`M_i` or kets.  Either:
-
-        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-        2. projection operators if ops correspond to
-           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
-        3. kets (transformed to projectors)
-
-    Returns
-    -------
-    collapsed_states : list of :class:`.Qobj`
-        The collapsed states obtained after measuring the qubits and obtaining
-        the qubit specified by the target in the state specified by the index.
-
-    probabilities : list of floats
-        The probability of measuring a state in a the state specified by the
-        index.
-    """
-    if all(map(lambda x: x.isket, ops)):
-        ops = [op * op.dag() for op in ops]
-
-    for op in ops:
-        _verify_input(op, state)
-
-    E = [op.dag() * op for op in ops]
-
-    is_ID = sum(E)
-    if not is_ID == identity(is_ID.dims[0]):
-        raise ValueError("measurement operators must sum to identity")
-
-    if state.isket:
-        return _measurement_statistics_povm_ket(state, ops)
-    else:
-        return _measurement_statistics_povm_dm(state, ops)
-
-
-def measurement_statistics_observable(state, op):
-    """
-    Return the measurement eigenvalues, eigenstates (or projectors) and
-    measurement probabilities for the given state and measurement operator.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    op : :class:`.Qobj`
-        The measurement operator.
-
-    Returns
-    -------
-    eigenvalues: list of float
-        The list of eigenvalues of the measurement operator.
-
-    eigenstates_or_projectors: list of :class:`.Qobj`
-        If the state was a ket, return the eigenstates of the measurement
-        operator. Otherwise return the projectors onto the eigenstates.
-
-    probabilities: list of float
-        The probability of measuring the state as being in the corresponding
-        eigenstate (and the measurement result being the corresponding
-        eigenvalue).
-    """
-    _verify_input(op, state)
-
-    eigenvalues, eigenstates = op.eigenstates()
-    if state.isket:
-        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
-        return eigenvalues, eigenstates, probabilities
-    else:
-        projectors = [e.proj() for e in eigenstates]
-        probabilities = [expect(v, state) for v in projectors]
-        return eigenvalues, projectors, probabilities
-
-
-def measure_observable(state, op):
-    """
-    Perform a measurement specified by an operator on the given state.
-
-    This function simulates the classic quantum measurement described in many
-    introductory texts on quantum mechanics. The measurement collapses the
-    state to one of the eigenstates of the given operator and the result of the
-    measurement is the corresponding eigenvalue.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    op : :class:`.Qobj`
-        The measurement operator.
-
-    Returns
-    -------
-    measured_value : float
-        The result of the measurement (one of the eigenvalues of op).
-
-    state : :class:`.Qobj`
-        The new state (a ket if a ket was given, otherwise a density matrix).
-
-    Examples
-    --------
-
-    Measure the z-component of the spin of the spin-up basis state:
-
-    >>> measure_observable(basis(2, 0), sigmaz())
-    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
-    Qobj data =
-    [[-1.]
-     [ 0.]])
-
-    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
-    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
-    and the original state (up to a global phase).
-
-    Measure the x-component of the spin of the spin-down basis state:
-
-    >>> measure_observable(basis(2, 1), sigmax())
-    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
-    Qobj data =
-    [[-0.70710678]
-     [ 0.70710678]])
-
-    This measurement returns 1 fifty percent of the time and -1 the other fifty
-    percent of the time. The new state returned is the corresponding eigenstate
-    of sigmax.
-
-    One may also perform a measurement on a density matrix. Below we perform
-    the same measurement as above, but on the density matrix representing the
-    pure spin-down state:
-
-    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
-    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
-    Qobj data =
-    [[ 0.5 -0.5]
-     [-0.5  0.5]])
-
-    The measurement result is the same, but the new state is returned as a
-    density matrix.
-    """
-    eigenvalues, eigenstates_or_projectors, probabilities = (
-        measurement_statistics_observable(state, op))
-    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
-    if state.isket:
-        eigenstates = eigenstates_or_projectors
-        state = eigenstates[i]
-    else:
-        projectors = eigenstates_or_projectors
-        state = (projectors[i] * state * projectors[i]) / probabilities[i]
-    return eigenvalues[i], state
-
-
-def measure_povm(state, ops):
-    r"""
-    Perform a measurement specified by list of POVMs.
-
-    This function simulates a POVM measurement. The measurement collapses the
-    state to one of the resultant states of the measurement and returns the
-    index of the operator corresponding to the collapsed state as well as the
-    collapsed state.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : list of :class:`.Qobj`
-        List of measurement operators :math:`M_i` or kets.  Either:
-
-        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-        2. projection operators if ops correspond to projectors (s.t.
-           :math:`E_i = M_i^\dagger = M_i`)
-        3. kets (transformed to projectors)
-
-    Returns
-    -------
-    index : float
-        The resultant index of the measurement.
-
-    state : :class:`.Qobj`
-        The new state (a ket if a ket was given, otherwise a density matrix).
-    """
-    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
-    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
-    state = collapsed_states[index]
-    return index, state
-
-
-def measurement_statistics(state, ops):
-    r"""
-    A dispatch method that provides measurement statistics handling both
-    observable style measurements and projector style measurements(POVMs and
-    PVMs).
-
-    For return signatures, please check:
-
-    - :func:`~measurement_statistics_observable` for observable measurements.
-    - :func:`~measurement_statistics_povm` for POVM measurements.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : :class:`.Qobj` or list of :class:`.Qobj`
-        - measurement observable (:class:.Qobj); or
-        - list of measurement operators :math:`M_i` or kets (list of
-          :class:`.Qobj`) Either:
-
-          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
-          2. projection operators if ops correspond to projectors (s.t.
-             :math:`E_i = M_i^\dagger = M_i`)
-          3. kets (transformed to projectors)
-    """
-    if isinstance(ops, list):
-        return measurement_statistics_povm(state, ops)
-    else:
-        return measurement_statistics_observable(state, ops)
-
-
-def measure(state, ops):
-    r"""
-    A dispatch method that provides measurement results handling both
-    observable style measurements and projector style measurements (POVMs and
-    PVMs).
-
-    For return signatures, please check:
-
-    - :func:`~measure_observable` for observable measurements.
-    - :func:`~measure_povm` for POVM measurements.
-
-    Parameters
-    ----------
-    state : :class:`.Qobj`
-        The ket or density matrix specifying the state to measure.
-
-    ops : :class:`.Qobj` or list of :class:`.Qobj`
-        - measurement observable (:class:`.Qobj`); or
-        - list of measurement operators :math:`M_i` or kets (list of
-          :class:`.Qobj`) Either:
-
-          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
-          2. projection operators if ops correspond to projectors (s.t.
-             :math:`E_i = M_i^\dagger = M_i`)
-          3. kets (transformed to projectors)
-    """
-    if isinstance(ops, list):
-        return measure_povm(state, ops)
-    else:
-        return measure_observable(state, ops)
+"""
+Module for measuring quantum objects.
+"""
+
+__all__ = [
+    'measurement_statistics_povm',
+    'measurement_statistics_observable',
+    'measure_observable',
+    'measure_povm',
+    'measurement_statistics',
+    'measure'
+]
+
+import numpy as np
+
+from . import Qobj, expect, identity, tensor
+
+
+def _verify_input(op, state):
+    if not isinstance(op, Qobj):
+        raise TypeError("op must be a Qobj")
+    if not op.isoper:
+        raise ValueError("op must be all operators or all kets")
+    if not isinstance(state, Qobj):
+        raise TypeError("state must be a Qobj")
+    if state.isket:
+        if op.dims[-1] != state.dims[0]:
+            raise ValueError(
+                "op and state dims should be compatible when state is a ket")
+    elif state.isoper:
+        if op.dims != state.dims:
+            raise ValueError(
+                "op and state dims should match"
+                " when state is a density matrix")
+    else:
+        raise ValueError("state must be a ket or a density matrix")
+
+
+def _measurement_statistics_povm_ket(state, ops):
+    r"""
+    Returns measurement statistics (resultant states and probabilities)
+    for a measurements specified by a set of positive operator valued
+    measurements on a specified ket.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj` (ket)
+            The ket specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+      List of measurement operators :math:`M_i` (specifying a POVM such that
+      :math:`E_i = M_i^\dagger M_i`).
+
+
+    Returns
+    -------
+    collapsed_states : list of :class:`.Qobj` (kets)
+        The collapsed states (kets) obtained after measuring the qubits and
+        obtaining the qubit specified by the target in the state specified by
+        the index.
+
+    probabilities : list of floats
+        The probability of measuring a state in a the state specified by the
+        index.
+    """
+    probabilities = []
+    collapsed_states = []
+
+    for i, op in enumerate(ops):
+        p = np.absolute((state.dag() * op.dag() * op * state))
+        probabilities.append(p)
+        if p != 0:
+            collapsed_states.append((op * state) / np.sqrt(p))
+        else:
+            collapsed_states.append(None)
+
+    return collapsed_states, probabilities
+
+
+def _measurement_statistics_povm_dm(density_mat, ops):
+    r"""
+    Returns measurement statistics (resultant states and probabilities)
+    for a measurements specified by a set of positive operator valued
+    measurements on a specified ket or density matrix.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj` (density matrix)
+        The ket or density matrix specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+        List of measurement operators :math:`M_i` (specifying a POVM s.t.
+        :mathm:`E_i = M_i^\dagger M_i`)
+
+    Returns
+    -------
+    collapsed_states : list of :class:`.Qobj`
+        The collapsed states (density matrices) obtained after measuring the
+        qubits and obtaining the qubit specified by the target in the state
+        specified by the index.
+
+    probabilities : list of float
+        The probability of measuring a state in a the state specified by the
+        index.
+    """
+    probabilities = []
+    collapsed_states = []
+
+    for i, op in enumerate(ops):
+        st = op * density_mat * op.dag()
+        p = st.tr()
+        probabilities.append(p)
+        if p != 0:
+            collapsed_states.append(st/p)
+        else:
+            collapsed_states.append(None)
+
+    return collapsed_states, probabilities
+
+
+def measurement_statistics_povm(state, ops):
+    r"""
+    Returns measurement statistics (resultant states and probabilities) for a
+    measurement specified by a set of positive operator valued measurements on
+    a specified ket or density matrix.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+        List of measurement operators :math:`M_i` or kets.  Either:
+
+        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+        2. projection operators if ops correspond to
+           projectors (s.t. :math:`E_i = M_i^\dagger = M_i`)
+        3. kets (transformed to projectors)
+
+    Returns
+    -------
+    collapsed_states : list of :class:`.Qobj`
+        The collapsed states obtained after measuring the qubits and obtaining
+        the qubit specified by the target in the state specified by the index.
+
+    probabilities : list of floats
+        The probability of measuring a state in a the state specified by the
+        index.
+    """
+    if all(map(lambda x: x.isket, ops)):
+        ops = [op * op.dag() for op in ops]
+
+    for op in ops:
+        _verify_input(op, state)
+
+    E = [op.dag() * op for op in ops]
+
+    is_ID = sum(E)
+    if not is_ID == identity(is_ID.dims[0]):
+        raise ValueError("measurement operators must sum to identity")
+
+    if state.isket:
+        return _measurement_statistics_povm_ket(state, ops)
+    else:
+        return _measurement_statistics_povm_dm(state, ops)
+
+
+def measurement_statistics_observable(state, op):
+    """
+    Return the measurement eigenvalues, eigenstates (or projectors) and
+    measurement probabilities for the given state and measurement operator.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    op : :class:`.Qobj`
+        The measurement operator.
+
+    Returns
+    -------
+    eigenvalues: list of float
+        The list of eigenvalues of the measurement operator.
+
+    eigenstates_or_projectors: list of :class:`.Qobj`
+        If the state was a ket, return the eigenstates of the measurement
+        operator. Otherwise return the projectors onto the eigenstates.
+
+    probabilities: list of float
+        The probability of measuring the state as being in the corresponding
+        eigenstate (and the measurement result being the corresponding
+        eigenvalue).
+    """
+    _verify_input(op, state)
+
+    eigenvalues, eigenstates = op.eigenstates()
+    if state.isket:
+        probabilities = [abs(e.overlap(state))**2 for e in eigenstates]
+        return eigenvalues, eigenstates, probabilities
+    else:
+        projectors = [e.proj() for e in eigenstates]
+        probabilities = [expect(v, state) for v in projectors]
+        return eigenvalues, projectors, probabilities
+
+
+def measure_observable(state, op):
+    """
+    Perform a measurement specified by an operator on the given state.
+
+    This function simulates the classic quantum measurement described in many
+    introductory texts on quantum mechanics. The measurement collapses the
+    state to one of the eigenstates of the given operator and the result of the
+    measurement is the corresponding eigenvalue.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    op : :class:`.Qobj`
+        The measurement operator.
+
+    Returns
+    -------
+    measured_value : float
+        The result of the measurement (one of the eigenvalues of op).
+
+    state : :class:`.Qobj`
+        The new state (a ket if a ket was given, otherwise a density matrix).
+
+    Examples
+    --------
+
+    Measure the z-component of the spin of the spin-up basis state:
+
+    >>> measure_observable(basis(2, 0), sigmaz())
+    (1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
+    Qobj data =
+    [[-1.]
+     [ 0.]])
+
+    Since the spin-up basis is an eigenstate of sigmaz, this measurement always
+    returns 1 as the measurement result (the eigenvalue of the spin-up basis)
+    and the original state (up to a global phase).
+
+    Measure the x-component of the spin of the spin-down basis state:
+
+    >>> measure_observable(basis(2, 1), sigmax())
+    (-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
+    Qobj data =
+    [[-0.70710678]
+     [ 0.70710678]])
+
+    This measurement returns 1 fifty percent of the time and -1 the other fifty
+    percent of the time. The new state returned is the corresponding eigenstate
+    of sigmax.
+
+    One may also perform a measurement on a density matrix. Below we perform
+    the same measurement as above, but on the density matrix representing the
+    pure spin-down state:
+
+    >>> measure_observable(ket2dm(basis(2, 1)), sigmax())
+    (-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
+    Qobj data =
+    [[ 0.5 -0.5]
+     [-0.5  0.5]])
+
+    The measurement result is the same, but the new state is returned as a
+    density matrix.
+    """
+    eigenvalues, eigenstates_or_projectors, probabilities = (
+        measurement_statistics_observable(state, op))
+    i = np.random.choice(range(len(eigenvalues)), p=probabilities)
+    if state.isket:
+        eigenstates = eigenstates_or_projectors
+        state = eigenstates[i]
+    else:
+        projectors = eigenstates_or_projectors
+        state = (projectors[i] * state * projectors[i]) / probabilities[i]
+    return eigenvalues[i], state
+
+
+def measure_povm(state, ops):
+    r"""
+    Perform a measurement specified by list of POVMs.
+
+    This function simulates a POVM measurement. The measurement collapses the
+    state to one of the resultant states of the measurement and returns the
+    index of the operator corresponding to the collapsed state as well as the
+    collapsed state.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : list of :class:`.Qobj`
+        List of measurement operators :math:`M_i` or kets.  Either:
+
+        1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+        2. projection operators if ops correspond to projectors (s.t.
+           :math:`E_i = M_i^\dagger = M_i`)
+        3. kets (transformed to projectors)
+
+    Returns
+    -------
+    index : float
+        The resultant index of the measurement.
+
+    state : :class:`.Qobj`
+        The new state (a ket if a ket was given, otherwise a density matrix).
+    """
+    collapsed_states, probabilities = measurement_statistics_povm(state, ops)
+    index = np.random.choice(range(len(collapsed_states)), p=probabilities)
+    state = collapsed_states[index]
+    return index, state
+
+
+def measurement_statistics(state, ops):
+    r"""
+    A dispatch method that provides measurement statistics handling both
+    observable style measurements and projector style measurements(POVMs and
+    PVMs).
+
+    For return signatures, please check:
+
+    - :func:`~measurement_statistics_observable` for observable measurements.
+    - :func:`~measurement_statistics_povm` for POVM measurements.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : :class:`.Qobj` or list of :class:`.Qobj`
+        - measurement observable (:class:.Qobj); or
+        - list of measurement operators :math:`M_i` or kets (list of
+          :class:`.Qobj`) Either:
+
+          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger * M_i`
+          2. projection operators if ops correspond to projectors (s.t.
+             :math:`E_i = M_i^\dagger = M_i`)
+          3. kets (transformed to projectors)
+    """
+    if isinstance(ops, list):
+        return measurement_statistics_povm(state, ops)
+    else:
+        return measurement_statistics_observable(state, ops)
+
+
+def measure(state, ops):
+    r"""
+    A dispatch method that provides measurement results handling both
+    observable style measurements and projector style measurements (POVMs and
+    PVMs).
+
+    For return signatures, please check:
+
+    - :func:`~measure_observable` for observable measurements.
+    - :func:`~measure_povm` for POVM measurements.
+
+    Parameters
+    ----------
+    state : :class:`.Qobj`
+        The ket or density matrix specifying the state to measure.
+
+    ops : :class:`.Qobj` or list of :class:`.Qobj`
+        - measurement observable (:class:`.Qobj`); or
+        - list of measurement operators :math:`M_i` or kets (list of
+          :class:`.Qobj`) Either:
+
+          1. specifying a POVM s.t. :math:`E_i = M_i^\dagger M_i`
+          2. projection operators if ops correspond to projectors (s.t.
+             :math:`E_i = M_i^\dagger = M_i`)
+          3. kets (transformed to projectors)
+    """
+    if isinstance(ops, list):
+        return measure_povm(state, ops)
+    else:
+        return measure_observable(state, ops)
diff --git a/qutip/orbital.py b/qutip/orbital.py
index 6d171d881f..209b65b406 100644
--- a/qutip/orbital.py
+++ b/qutip/orbital.py
@@ -1,81 +1,81 @@
-__all__ = ['orbital']
-
-import numpy as np
-from scipy.special import sph_harm
-
-
-def orbital(theta, phi, *args):
-    r"""Calculates an angular wave function on a sphere.
-    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
-    the angular wave function on a sphere at the mesh of points
-    defined by theta and phi which is
-    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
-    coefficients specified by the list of kets. Each ket has 2l+1 components
-    for some integer l. The first entry of the ket defines the coefficient
-    c_{l,-l}, while the last entry of the ket defines the
-    coefficient c_{l, l}.
-
-    Parameters
-    ----------
-    theta : int/float/list/array
-        Polar angles in [0, pi]
-
-    phi : int/float/list/array
-        Azimuthal angles in [0, 2*pi]
-
-    args : list/array
-        ``list`` of ket vectors.
-
-    Returns
-    -------
-    ``array`` for angular wave function evaluated at all
-              possible combinations of theta and phi
-
-    """
-    if isinstance(args[0], list):
-        # use the list in args[0]
-        args = args[0]
-
-    # convert to numpy array
-    theta = np.atleast_1d(theta)
-    phi = np.atleast_1d(phi)
-    # check that arrays are only 1D
-    if len(theta.shape) != 1:
-        raise ValueError('Polar angles theta must be 1D list')
-    if len(phi.shape) != 1:
-        raise ValueError('Azimuthal angles phi must be 1D list')
-
-    # make meshgrid
-    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
-    # setup empty wavefunction
-    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
-    # iterate through provided kets
-    for k in range(len(args)):
-        ket = args[k]
-        if ket.type == 'bra':
-            ket = ket.conj()
-        elif not ket.type == 'ket':
-            raise TypeError('Invalid type for input ket in orbital')
-        # Extract l value from the state
-        l = (ket.shape[0] - 1) / 2.0
-        if l != np.floor(l):
-            raise ValueError(
-                'Kets must have odd number of components in orbital')
-        l = int(l)
-        # get factors from ket
-        factors = ket.full()
-        # iterate through the possible m
-
-        for i in range(len(factors)):
-            # set correct m
-            m = i - l
-            # calculate spherical harmonics
-            # note that theta and phi are interchanged in scipy implementation
-            res = sph_harm(m, l, phi_mesh, theta_mesh)
-            psi += factors[i] * res
-
-    # flatten output if only one row
-    if psi.shape[1] == 1:
-        psi = psi.flatten()
-
-    return psi
+__all__ = ['orbital']
+
+import numpy as np
+from scipy.special import sph_harm
+
+
+def orbital(theta, phi, *args):
+    r"""Calculates an angular wave function on a sphere.
+    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
+    the angular wave function on a sphere at the mesh of points
+    defined by theta and phi which is
+    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
+    coefficients specified by the list of kets. Each ket has 2l+1 components
+    for some integer l. The first entry of the ket defines the coefficient
+    c_{l,-l}, while the last entry of the ket defines the
+    coefficient c_{l, l}.
+
+    Parameters
+    ----------
+    theta : int/float/list/array
+        Polar angles in [0, pi]
+
+    phi : int/float/list/array
+        Azimuthal angles in [0, 2*pi]
+
+    args : list/array
+        ``list`` of ket vectors.
+
+    Returns
+    -------
+    ``array`` for angular wave function evaluated at all
+              possible combinations of theta and phi
+
+    """
+    if isinstance(args[0], list):
+        # use the list in args[0]
+        args = args[0]
+
+    # convert to numpy array
+    theta = np.atleast_1d(theta)
+    phi = np.atleast_1d(phi)
+    # check that arrays are only 1D
+    if len(theta.shape) != 1:
+        raise ValueError('Polar angles theta must be 1D list')
+    if len(phi.shape) != 1:
+        raise ValueError('Azimuthal angles phi must be 1D list')
+
+    # make meshgrid
+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+    # setup empty wavefunction
+    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
+    # iterate through provided kets
+    for k in range(len(args)):
+        ket = args[k]
+        if ket.type == 'bra':
+            ket = ket.conj()
+        elif not ket.type == 'ket':
+            raise TypeError('Invalid type for input ket in orbital')
+        # Extract l value from the state
+        l = (ket.shape[0] - 1) / 2.0
+        if l != np.floor(l):
+            raise ValueError(
+                'Kets must have odd number of components in orbital')
+        l = int(l)
+        # get factors from ket
+        factors = ket.full()
+        # iterate through the possible m
+
+        for i in range(len(factors)):
+            # set correct m
+            m = i - l
+            # calculate spherical harmonics
+            # note that theta and phi are interchanged in scipy implementation
+            res = sph_harm(m, l, phi_mesh, theta_mesh)
+            psi += factors[i] * res
+
+    # flatten output if only one row
+    if psi.shape[1] == 1:
+        psi = psi.flatten()
+
+    return psi
diff --git a/qutip/partial_transpose.py b/qutip/partial_transpose.py
index 4a0b259564..61871369d8 100644
--- a/qutip/partial_transpose.py
+++ b/qutip/partial_transpose.py
@@ -1,122 +1,122 @@
-__all__ = ['partial_transpose']
-
-import numpy as np
-import scipy.sparse as sp
-
-from . import (
-    Qobj, state_index_number, state_number_index, state_number_enumerate,
-)
-from .core.dimensions import flatten
-
-
-def partial_transpose(rho, mask, method='dense'):
-    """
-    Return the partial transpose of a Qobj instance `rho`,
-    where `mask` is an array/list with length that equals
-    the number of components of `rho` (that is, the length of
-    `rho.dims[0]`), and the values in `mask` indicates whether
-    or not the corresponding subsystem is to be transposed.
-    The elements in `mask` can be boolean or integers `0` or `1`,
-    where `True`/`1` indicates that the corresponding subsystem
-    should be tranposed.
-
-    Parameters
-    ----------
-
-    rho : :class:`qutip.qobj`
-        A density matrix.
-
-    mask : *list* / *array*
-        A mask that selects which subsystems should be transposed.
-
-    method : str
-        choice of method, `dense` or `sparse`. The default method
-        is `dense`. The `sparse` implementation can be faster for
-        large and sparse systems (hundreds of quantum states).
-
-    Returns
-    -------
-
-    rho_pr: :class:`qutip.qobj`
-
-        A density matrix with the selected subsystems transposed.
-
-    """
-
-    mask = [int(i) for i in mask]
-
-    if method == 'sparse':
-        return _partial_transpose_sparse(rho, mask)
-    else:
-        return _partial_transpose_dense(rho, mask)
-
-
-def _partial_transpose_dense(rho, mask):
-    """
-    Based on Jonas' implementation using numpy.
-    Very fast for dense problems.
-    """
-    nsys = len(mask)
-    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
-    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
-                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
-
-    data = (rho.full()
-            .reshape(flatten(rho.dims))
-            .transpose(pt_idx)
-            .reshape(rho.shape))
-    return Qobj(data, dims=rho.dims)
-
-
-def _partial_transpose_sparse(rho, mask):
-    """
-    Implement the partial transpose using the CSR sparse matrix.
-    """
-
-    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
-    rho_data = rho.to("CSR").data.as_scipy()
-
-    for m in range(len(rho_data.indptr) - 1):
-
-        n1 = rho_data.indptr[m]
-        n2 = rho_data.indptr[m + 1]
-
-        psi_A = state_index_number(rho.dims[0], m)
-
-        for idx, n in enumerate(rho_data.indices[n1:n2]):
-
-            psi_B = state_index_number(rho.dims[1], n)
-
-            m_pt = state_number_index(
-                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
-            n_pt = state_number_index(
-                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
-
-            data[m_pt, n_pt] = rho_data.data[n1 + idx]
-
-    return Qobj(data.tocsr(), dims=rho.dims)
-
-
-def _partial_transpose_reference(rho, mask):
-    """
-    This is a reference implementation that explicitly loops over
-    all states and performs the transpose. It's slow but easy to
-    understand and useful for testing.
-    """
-
-    A_pt = np.zeros(rho.shape, dtype=complex)
-
-    for psi_A in state_number_enumerate(rho.dims[0]):
-        m = state_number_index(rho.dims[0], psi_A)
-
-        for psi_B in state_number_enumerate(rho.dims[1]):
-            n = state_number_index(rho.dims[1], psi_B)
-
-            m_pt = state_number_index(
-                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
-            n_pt = state_number_index(
-                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
-
-            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
-
-    return Qobj(A_pt, dims=rho.dims)
+__all__ = ['partial_transpose']
+
+import numpy as np
+import scipy.sparse as sp
+
+from . import (
+    Qobj, state_index_number, state_number_index, state_number_enumerate,
+)
+from .core.dimensions import flatten
+
+
+def partial_transpose(rho, mask, method='dense'):
+    """
+    Return the partial transpose of a Qobj instance `rho`,
+    where `mask` is an array/list with length that equals
+    the number of components of `rho` (that is, the length of
+    `rho.dims[0]`), and the values in `mask` indicates whether
+    or not the corresponding subsystem is to be transposed.
+    The elements in `mask` can be boolean or integers `0` or `1`,
+    where `True`/`1` indicates that the corresponding subsystem
+    should be tranposed.
+
+    Parameters
+    ----------
+
+    rho : :class:`qutip.qobj`
+        A density matrix.
+
+    mask : *list* / *array*
+        A mask that selects which subsystems should be transposed.
+
+    method : str
+        choice of method, `dense` or `sparse`. The default method
+        is `dense`. The `sparse` implementation can be faster for
+        large and sparse systems (hundreds of quantum states).
+
+    Returns
+    -------
+
+    rho_pr: :class:`qutip.qobj`
+
+        A density matrix with the selected subsystems transposed.
+
+    """
+
+    mask = [int(i) for i in mask]
+
+    if method == 'sparse':
+        return _partial_transpose_sparse(rho, mask)
+    else:
+        return _partial_transpose_dense(rho, mask)
+
+
+def _partial_transpose_dense(rho, mask):
+    """
+    Based on Jonas' implementation using numpy.
+    Very fast for dense problems.
+    """
+    nsys = len(mask)
+    pt_dims = np.arange(2 * nsys).reshape(2, nsys).T
+    pt_idx = np.concatenate([[pt_dims[n, mask[n]] for n in range(nsys)],
+                            [pt_dims[n, 1 - mask[n]] for n in range(nsys)]])
+
+    data = (rho.full()
+            .reshape(flatten(rho.dims))
+            .transpose(pt_idx)
+            .reshape(rho.shape))
+    return Qobj(data, dims=rho.dims)
+
+
+def _partial_transpose_sparse(rho, mask):
+    """
+    Implement the partial transpose using the CSR sparse matrix.
+    """
+
+    data = sp.lil_matrix((rho.shape[0], rho.shape[1]), dtype=complex)
+    rho_data = rho.to("CSR").data.as_scipy()
+
+    for m in range(len(rho_data.indptr) - 1):
+
+        n1 = rho_data.indptr[m]
+        n2 = rho_data.indptr[m + 1]
+
+        psi_A = state_index_number(rho.dims[0], m)
+
+        for idx, n in enumerate(rho_data.indices[n1:n2]):
+
+            psi_B = state_index_number(rho.dims[1], n)
+
+            m_pt = state_number_index(
+                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
+            n_pt = state_number_index(
+                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
+
+            data[m_pt, n_pt] = rho_data.data[n1 + idx]
+
+    return Qobj(data.tocsr(), dims=rho.dims)
+
+
+def _partial_transpose_reference(rho, mask):
+    """
+    This is a reference implementation that explicitly loops over
+    all states and performs the transpose. It's slow but easy to
+    understand and useful for testing.
+    """
+
+    A_pt = np.zeros(rho.shape, dtype=complex)
+
+    for psi_A in state_number_enumerate(rho.dims[0]):
+        m = state_number_index(rho.dims[0], psi_A)
+
+        for psi_B in state_number_enumerate(rho.dims[1]):
+            n = state_number_index(rho.dims[1], psi_B)
+
+            m_pt = state_number_index(
+                rho.dims[1], np.choose(mask, [psi_A, psi_B]))
+            n_pt = state_number_index(
+                rho.dims[0], np.choose(mask, [psi_B, psi_A]))
+
+            A_pt[m_pt, n_pt] = rho.to("CSR").data.as_scipy()[m, n]
+
+    return Qobj(A_pt, dims=rho.dims)
diff --git a/qutip/qip.py b/qutip/qip.py
index 69cfc8564d..392b835a94 100644
--- a/qutip/qip.py
+++ b/qutip/qip.py
@@ -1,13 +1,13 @@
-"""Module replicating the qutip_qip package from within qutip."""
-import sys
-
-try:
-    import qutip_qip
-    del qutip_qip
-    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
-except ImportError:
-    raise ImportError(
-        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
-        "with `pip install qutip-qip` (for more details, go to "
-        "https://qutip-qip.readthedocs.io/)."
-    )
+"""Module replicating the qutip_qip package from within qutip."""
+import sys
+
+try:
+    import qutip_qip
+    del qutip_qip
+    sys.modules["qutip.qip"] = sys.modules["qutip_qip"]
+except ImportError:
+    raise ImportError(
+        "Importing 'qutip.qip' requires the 'qutip_qip' package. Install it "
+        "with `pip install qutip-qip` (for more details, go to "
+        "https://qutip-qip.readthedocs.io/)."
+    )
diff --git a/qutip/random_objects.py b/qutip/random_objects.py
index 5e8f010bd3..be759ae9db 100644
--- a/qutip/random_objects.py
+++ b/qutip/random_objects.py
@@ -1,868 +1,868 @@
-"""
-This module is a collection of random state and operator generators.
-"""
-
-__all__ = [
-    'rand_herm',
-    'rand_unitary',
-    'rand_dm',
-    'rand_stochastic',
-    'rand_ket',
-    'rand_kraus_map',
-    'rand_super',
-    "rand_super_bcsz",
-]
-
-import numbers
-
-import numpy as np
-from numpy.random import Generator, SeedSequence, default_rng
-import scipy.linalg
-import scipy.sparse as sp
-
-from . import (Qobj, create, destroy, jmat, basis,
-               to_super, to_choi, to_chi, to_kraus, to_stinespring)
-from .core import data as _data
-from .core.dimensions import flatten
-from . import settings
-
-
-_RAND = default_rng()
-_UNITS = np.array([1, 1j])
-
-
-def _implicit_tensor_dimensions(dimensions, superoper=False):
-    """
-    Total flattened size and operator dimensions for operator creation routines
-    that automatically perform tensor products.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        First dimension of an operator which can create an implicit tensor
-        product.  If the type is `int`, it is promoted first to `[dimensions]`.
-        From there, it should be one of the two-elements `dims` parameter of a
-        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
-        products.
-
-    Returns
-    -------
-    size : int
-        Dimension of backing matrix required to represent operator.
-    dimensions : list
-        Dimension list in the form required by ``Qobj`` creation.
-    """
-    if not isinstance(dimensions, list):
-        dimensions = [dimensions]
-    flat = flatten(dimensions)
-    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
-        raise ValueError("All dimensions must be integers >= 0")
-    N = np.prod(flat)
-    if superoper:
-        if isinstance(dimensions[0], numbers.Integral):
-            dimensions = [dimensions, dimensions]
-        else:
-            N = int(N**0.5)
-    return N, [dimensions, dimensions]
-
-
-def _get_generator(seed):
-    """
-    Obtain a random generator from a seed or generator.
-
-    Parameters
-    ----------
-    seed: int, SeedSequence, Generator, NoneType
-        Seed to create the generator. If it's already a generator return it.
-        When ``None`` is suplied, a default generator is provided.
-    """
-    if seed is None:
-        gen = _RAND
-    elif isinstance(seed, Generator):
-        gen = seed
-    else:
-        gen = default_rng(seed)
-    return gen
-
-
-def _randnz(shape, generator, norm=np.sqrt(0.5)):
-    """
-    Returns an array of standard normal complex random variates.
-    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
-
-    Parameters
-    ----------
-    shape : tuple
-        Shape of the returned array of random variates.
-
-    generator : Generator
-        Random number generator.
-
-    norm : float
-        Scale of the returned random variates, or 'ginibre' to draw
-        from the Ginibre ensemble.
-    """
-    # This function is intended for internal use.
-    if norm == 'ginibre':
-        norm = 1
-    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
-
-
-def _rand_jacobi_rotation(A, generator):
-    """Random Jacobi rotation of a matrix.
-
-    Parameters
-    ----------
-    A : qutip.data.Data
-        Matrix to rotate as a data layer object.
-
-    generator : numpy.random.generator
-        Random number generator.
-
-    Returns
-    -------
-    qutip.data.Data
-        Rotated sparse matrix.
-    """
-    if A.shape[0] != A.shape[1]:
-        raise ValueError('Input matrix must be square.')
-    n = A.shape[0]
-    angle = 2 * generator.random() * np.pi
-    a = np.sqrt(0.5) * np.exp(-1j * angle)
-    b = np.conj(a)
-    i = generator.integers(n)
-    j = i
-    while i == j:
-        j = generator.integers(n)
-    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
-                      np.ones(n - 2, dtype=complex)))
-    diag = np.delete(np.arange(n), [i, j])
-    rows = np.hstack(([i, i, j, j], diag))
-    cols = np.hstack(([i, j, i, j], diag))
-    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
-    R = _data.create(R.tocsr())
-    return _data.matmul(_data.matmul(R, A), R.adjoint())
-
-
-def _get_block_sizes(N, density, generator):
-    """
-    Obtain a list of matrix block sizes in such a way that an NxN matrix
-    composed of full matrices of these sizes along the diagonal would be of
-    desired density.
-    """
-    if density <= 0:
-        return [1] * N
-    elif density >= 1:
-        return [N]
-    max_block_size = int((N**2 * density)**0.5)
-    min_block_size = 1
-    if density >= 0.5:
-        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
-
-    if min_block_size >= max_block_size:
-        M = min(min_block_size, max_block_size)
-    else:
-        M = generator.integers(min_block_size, max_block_size) + 1
-    M += generator.integers(-1, 2)
-    M = min(max(M, 1), N)
-
-    other_blocks = []
-    if M < N:
-        other_N = N - M
-        other_density = (density * N**2 - M**2) / other_N**2
-        other_blocks = _get_block_sizes(other_N, other_density, generator)
-
-    return [M] + other_blocks
-
-
-def _merge_shuffle_blocks(blocks, generator):
-    """
-    For a list of block, merge them in one matrix along the diagonal and
-    shuffle the rows and columns.
-    """
-    N = sum(block.shape[0] for block in blocks)
-    D = sum(block.shape[0]**2 for block in blocks) / N**2
-    idx = generator.permutation(N)
-    end = 0
-    if D < 0.1:
-        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
-        row = []
-        col = []
-        data = []
-        for block in blocks:
-            start = end
-            end = end + block.shape[0]
-            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
-            row.append(brow.ravel())
-            col.append(bcol.ravel())
-            data.append(block.ravel())
-        data = np.hstack(data)
-        row = np.hstack(row)
-        col = np.hstack(col)
-        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
-    else:
-        matrix = np.zeros((N,N), dtype=complex)
-        for block in blocks:
-            start = end
-            end = end + block.shape[0]
-            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
-            matrix[brow, bcol] = block
-    return _data.create(matrix, copy=False)
-
-
-def rand_herm(dimensions, density=0.30, distribution="fill", *,
-              eigenvalues=(), seed=None, dtype=None):
-    """Creates a random sparse Hermitian quantum object.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [0.30]
-        Density between [0,1] of output Hermitian operator.
-
-    distribution : str {"fill", "pos_def", "eigen"}
-        Method used to obtain the density matrices.
-
-        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
-          generated quantum operator with elements uniformly distributed
-          between ``[-1, 1] + [-1j, 1j]``.
-        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
-          random complex Jacobi rotations to shuffle the operator.
-        - "pos_def" : Return a positive semi-definite matrix by diagonal
-          dominance.
-
-    eigenvalues : array_like, optional
-        Eigenvalues of the output Hermitian matrix. The len must match the
-        shape of the matrix.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : :class:`qobj`
-        Hermitian quantum operator.
-
-    Notes
-    -----
-    If given a list of eigenvalues the object is created using complex Jacobi
-    rotations.  While this method is fast for small matrices, it should not be
-    repeatedly used for generating matrices larger than ~1000x1000.
-    """
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    generator = _get_generator(seed)
-    if distribution not in ["eigen", "fill", "pos_def"]:
-        raise ValueError("distribution must be one of {'eigen', 'fill', "
-                         "'pos_def'}")
-
-    if distribution == "eigen":
-        if N != len(eigenvalues):
-            raise ValueError("The number of eigenvalues does not match the "
-                             "desired shape.")
-        out = _data.diag[_data.CSR](eigenvalues, 0)
-        nvals = max([N**2 * density, 1])
-        out = _rand_jacobi_rotation(out, generator)
-        while _data.csr.nnz(out) < 0.95 * nvals:
-            out = _rand_jacobi_rotation(out, generator)
-        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
-        dtype = dtype or settings.core["default_dtype"] or _data.CSR
-
-    else:
-        pos_def = distribution == "pos_def"
-        if density < 0.5:
-            M = _rand_herm_sparse(N, density, pos_def, generator)
-            dtype = dtype or settings.core["default_dtype"] or _data.CSR
-        else:
-            M = _rand_herm_dense(N, density, pos_def, generator)
-            dtype = dtype or settings.core["default_dtype"] or _data.Dense
-
-        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
-
-    return out.to(dtype)
-
-
-def _rand_herm_sparse(N, density, pos_def, generator):
-    target = (1 - (1 - density)**0.5)
-    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
-    num_elems = max([num_elems, 1])
-    num_elems = int(num_elems)
-    data = (2 * generator.random(num_elems) - 1) + \
-           (2 * generator.random(num_elems) - 1) * 1j
-    row_idx, col_idx = zip(*[
-        divmod(index, N)
-        for index in generator.choice(N*N, num_elems, replace=False)
-    ])
-    M = sp.coo_matrix((data, (row_idx, col_idx)),
-                      dtype=complex, shape=(N, N))
-    M = 0.5 * (M + M.conj().transpose())
-    M.sort_indices()
-    rand_mat = _data.create(M)
-    if pos_def:
-        rand_mat = _data.add(
-            rand_mat,
-            _data.diag(np.ones(N, dtype=complex)),
-            np.sqrt(2) * N + 1
-        )
-    return rand_mat
-
-
-def _rand_herm_dense(N, density, pos_def, generator):
-    M = (
-        (2*generator.random((N, N)) - 1)
-        + 1j*(2*generator.random((N, N)) - 1)
-    )
-    M = 0.5 * (M + M.conj().transpose())
-    target = 1 - density**0.5
-    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
-    num_remove = max([num_remove, 1])
-    num_remove = int(num_remove)
-    for index in generator.choice(N*N, num_remove, replace=False):
-        row, col = divmod(index, N)
-        M[col, row] = 0
-        M[row, col] = 0
-    if pos_def:
-        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
-    return _data.create(M)
-
-
-def rand_unitary(dimensions, density=1, distribution="haar", *,
-                 seed=None, dtype=None):
-    r"""Creates a random sparse unitary quantum object.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [1]
-        Density between [0,1] of output unitary operator.
-
-    distribution : ["haar", "exp"]
-        Method used to obtain the unitary matrices.
-
-        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
-        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
-          Hermitian operator.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Unitary quantum operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    if distribution not in ["haar", "exp"]:
-        raise ValueError("distribution must be one of {'haar', 'exp'}")
-    generator = _get_generator(seed)
-    block_sizes = _get_block_sizes(N, density, generator)
-
-    blocks = []
-    for block in block_sizes:
-        if distribution == "haar":
-            mat = _rand_unitary_haar(block, generator)
-        elif distribution == "exp":
-            mat = scipy.linalg.expm(
-                -1.0j *
-                _rand_herm_dense(block, 1, False, generator).as_ndarray()
-            )
-        blocks.append(mat)
-
-    merged = _merge_shuffle_blocks(blocks, generator)
-
-    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
-    return mat.to(dtype)
-
-
-def _rand_unitary_haar(N, generator):
-    """
-    Returns a Haar random unitary matrix of dimension
-    ``dim``, using the algorithm of [Mez07]_.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of the unitary to be returned.
-
-    generator : numpy.random.generator
-        Random number generator.
-
-    Returns
-    -------
-    U : qutip.core.data.Dense
-        Unitary of shape ``(N, N)`` drawn from the Haar measure.
-    """
-    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
-    #               normal random variates.
-    Z = _randnz((N, N), generator)
-
-    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
-    Q, R = scipy.linalg.qr(Z)
-
-    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
-    #               the diagonal elements of R.
-    Lambda = np.diag(R).copy()
-    Lambda /= np.abs(Lambda)
-
-    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
-    #               strictly positive elements, such that
-    #               Q' = Q · Λ is Haar distributed.
-    # NOTE: Λ is a diagonal matrix, represented as a vector
-    #       of the diagonal entries. Thus, the matrix dot product
-    #       is represented nicely by the NumPy broadcasting of
-    #       the *scalar* multiplication. In particular,
-    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
-    #       As NumPy arrays, Q has shape (N, N) and
-    #       Lambda has shape (N, ), such that the broadcasting
-    #       represents precisely Q_ij λ_j.
-    return Q * Lambda
-
-
-def rand_ket(dimensions, density=1, distribution="haar", *,
-             seed=None, dtype=None):
-    """Creates a random ket vector.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [1]
-        Density between [0,1] of output ket state when using the ``fill``
-        method.
-
-    distribution : str {"haar", "fill"}
-        Method used to obtain the kets.
-
-        - haar : Haar random pure state obtained by applying a Haar random
-          unitary to a fixed pure state.
-        - fill : Fill the ket with uniformly distributed random complex number.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Ket quantum state vector.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    if distribution not in ["haar", "fill"]:
-        raise ValueError("distribution must be one of {'haar', 'fill'}")
-
-    if distribution == "haar":
-        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
-    else:
-        X = scipy.sparse.rand(N, 1, density, format='csr',
-                              random_state=generator)
-        while X.nnz == 0:
-            # ensure that the ket is not all zeros.
-            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
-                                  random_state=generator)
-        X.data = X.data - 0.5
-        Y = X.copy()
-        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
-        X = _data.csr.CSR(X + Y)
-        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
-                   copy=False, type="ket", isherm=False, isunitary=False)
-    ket.dims = [dims[0], [1]]
-    return ket.to(dtype)
-
-
-def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
-            eigenvalues=(), rank=None, seed=None,
-            dtype=None):
-    r"""Creates a random density matrix of the desired dimensions.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either ``oper`` or
-        ``super`` depending on the passed ``dimensions``.
-
-    density : float
-        Density between [0,1] of output density matrix. Used by the "pure",
-        "eigen" and "herm".
-
-    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
-        Method used to obtain the density matrices.
-
-        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
-          the algorithm of [BCSZ08]_.
-        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
-          operator.
-        - "pure" : Density matrix created from a random ket.
-        - "eigen" : A density matrix with the given ``eigenvalues``.
-        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
-
-    eigenvalues : array_like, optional
-        Eigenvalues of the output Hermitian matrix. The len must match the
-        shape of the matrix.
-
-    rank : int, optional
-        When using the "ginibre" distribution, rank of the density matrix.
-        Will default to a full rank operator when not provided.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Density matrix quantum operator.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
-    if distribution not in distributions:
-        raise ValueError(f"distribution must be one of {distributions}")
-
-    if distribution == "eigen":
-        if len(eigenvalues) != N:
-            raise ValueError("Number of eigenvalues does not match the shape.")
-        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
-            raise ValueError('Eigenvalues of a density matrix '
-                             f'must sum to one, not {np.sum(eigenvalues)}')
-        H = _data.diag(eigenvalues, 0)
-        nvals = N**2 * density
-        H = _rand_jacobi_rotation(H, generator)
-        while _data.csr.nnz(H) < 0.95*nvals:
-            H = _rand_jacobi_rotation(H, generator)
-    elif distribution == "ginibre":
-        H = _rand_dm_ginibre(N, rank, generator)
-    elif distribution == "hs":
-        H = _rand_dm_ginibre(N, N, generator)
-    elif distribution == "pure":
-        dm_density = np.sqrt(density)
-        psi = rand_ket(N, density=dm_density,
-                       distribution="fill", seed=generator)
-        H = psi.proj().data
-    elif distribution == "herm":
-        block_sizes = _get_block_sizes(N, density, generator)
-        blocks = []
-        first = True
-        for block in block_sizes:
-            if block != 1:
-                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
-            else:
-                mat = np.ones((1,1))
-                if not first:
-                    mat *= max(generator.random() - 0.5, 0)
-                first = False
-            blocks.append(mat.T.conj() @ mat)
-        H = _merge_shuffle_blocks(blocks, generator)
-        H /= H.trace()
-
-    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
-
-
-def _rand_dm_ginibre(N, rank, generator):
-    """
-    Returns a Ginibre random density operator of  rank ``rank`` by using the
-    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
-    (Hilbert-Schmidt ensemble) random density operator will be
-    returned.
-
-    Parameters
-    ----------
-    N : int
-        Dimension of the density operator to be returned.
-
-    rank : int or None
-        Rank of the sampled density operator. If None, a full-rank
-        density operator is generated.
-
-    Returns
-    -------
-    rho : Qobj
-        An N × N density operator sampled from the Ginibre
-        or Hilbert-Schmidt distribution.
-    """
-    if not rank:
-        rank = N
-    if rank > N:
-        raise ValueError("Rank cannot exceed dimension.")
-
-    X = _randnz((N, rank), generator, norm='ginibre')
-    rho = np.dot(X, X.T.conj())
-    rho /= np.trace(rho)
-
-    return rho
-
-
-def rand_kraus_map(dimensions, *, seed=None,
-                   dtype=None):
-    """
-    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
-    form.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper_list : list of qobj
-        N^2 x N x N qobj operators.
-
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    N, dims = _implicit_tensor_dimensions(dimensions)
-
-    # Random unitary (Stinespring Dilation)
-    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
-    orthog_cols = np.array(big_unitary[:, :N])
-    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
-    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
-            for x in oper_list]
-
-
-def rand_super(dimensions, *, superrep="super", seed=None,
-               dtype=None):
-    """
-    Returns a randomly drawn superoperator acting on operators acting on
-    N dimensions.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    superrop : str, optional, {"super"}
-        Representation of the super operator
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    from .solver.propagator import propagator
-    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
-    H = rand_herm(N, seed=generator, dtype=dtype)
-    S = propagator(H, generator.random(), [
-        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
-    ])
-    S.dims = dims
-    out = {
-            "choi" : to_choi,
-            "chi" : to_chi,
-            "super": to_super,
-        }[superrep](S).to(dtype)
-    return out
-
-
-def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
-                    superrep="super", seed=None,
-                    dtype=None):
-    """
-    Returns a random superoperator drawn from the Bruzda
-    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
-    finite numerical precision, for ranks less than full-rank,
-    zero eigenvalues may become slightly negative, such that the
-    returned operator is not actually completely positive.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If an int is provided, it is understood as
-        the Square root of the dimension of the superoperator to be returned,
-        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
-        as a list of ints, then the dimensions is understood as the space of
-        density matrices this superoperator is applied to: ``dimensions=[2,2]``
-        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
-
-    enforce_tp : bool
-        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
-        otherwise only complete positivity is enforced.
-
-    rank : int or None
-        Rank of the sampled superoperator. If None, a full-rank
-        superoperator is generated.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    superrop : str, optional, {"super"}
-        representation of the
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    rho : Qobj
-        A superoperator acting on vectorized dim × dim density operators,
-        sampled from the BCSZ distribution.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
-
-    if rank is None:
-        rank = N**2
-    if rank > N**2:
-        raise ValueError("Rank cannot exceed superoperator dimension.")
-
-    # We use mainly dense matrices here for speed in low
-    # dimensions. In the future, it would likely be better to switch off
-    # between sparse and dense matrices as the dimension grows.
-
-    # We start with a Ginibre uniform matrix X of the appropriate rank,
-    # and use it to construct a positive semidefinite matrix X X⁺.
-    X = _randnz((N**2, rank), generator, norm='ginibre')
-
-    # Precompute X X⁺, as we'll need it in two different places.
-    XXdag = np.dot(X, X.T.conj())
-    tmp_dims = [[[N], [N]], [[N], [N]]]
-
-    if enforce_tp:
-        # We do the partial trace over the first index by using dense reshape
-        # operations, so that we can avoid bouncing to a sparse representation
-        # and back.
-        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
-
-        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
-        # the square root and the inverse separately. As a possible
-        # improvement, iterative methods exist to find inverse square root
-        # matrices directly, as this is important in statistics.
-        Z = np.kron(
-            np.eye(N),
-            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
-        )
-
-        # Finally, we dot everything together and pack it into a Qobj,
-        # marking the dimensions as that of a type=super (that is,
-        # with left and right compound indices, each representing
-        # left and right indices on the underlying Hilbert space).
-        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
-    else:
-        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
-
-    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
-    # expects a column-stacking Choi matrix, we must permute the indices.
-    D = D.permute([[1], [0]])
-
-    # Mark that we've made a Choi matrix.
-    D.superrep = 'choi'
-    D.dims = dims
-    out = {
-            "choi" : to_choi,
-            "chi" : to_chi,
-            "super": to_super,
-        }[superrep](D).to(dtype)
-    return out
-
-
-def rand_stochastic(dimensions, density=0.75, kind='left',
-                    *, seed=None, dtype=None):
-    """Generates a random stochastic matrix.
-
-    Parameters
-    ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    density : float, [0.75]
-        Density between [0,1] of output density matrix.
-
-    kind : str (Default = 'left')
-        Generate 'left' or 'right' stochastic matrix.
-
-    seed : int, SeedSequence, Generator, optional
-        Seed to create the random number generator or a pre prepared
-        generator. When none is suplied, a default generator is used.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
-
-    Returns
-    -------
-    oper : qobj
-        Quantum operator form of stochastic matrix.
-    """
-    dtype = dtype or settings.core["default_dtype"] or _data.Dense
-    generator = _get_generator(seed)
-    N, dims = _implicit_tensor_dimensions(dimensions)
-    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
-    data = generator.random(num_elems)
-    # Ensure an element on every row and column
-    row_idx = np.hstack([generator.permutation(N),
-                         generator.choice(N, num_elems-N)])
-    col_idx = np.hstack([generator.permutation(N),
-                         generator.choice(N, num_elems-N)])
-    M = sp.coo_matrix((data, (row_idx, col_idx)),
-                      dtype=np.complex128, shape=(N, N)).tocsr()
-    M = 0.5 * (M + M.conj().transpose())
-    num_rows = M.indptr.shape[0] - 1
-    for row in range(num_rows):
-        row_start = M.indptr[row]
-        row_end = M.indptr[row+1]
-        row_sum = np.sum(M.data[row_start:row_end])
-        M.data[row_start:row_end] /= row_sum
-    if kind == 'left':
-        M = M.transpose()
-    return Qobj(M, dims=dims).to(dtype)
+"""
+This module is a collection of random state and operator generators.
+"""
+
+__all__ = [
+    'rand_herm',
+    'rand_unitary',
+    'rand_dm',
+    'rand_stochastic',
+    'rand_ket',
+    'rand_kraus_map',
+    'rand_super',
+    "rand_super_bcsz",
+]
+
+import numbers
+
+import numpy as np
+from numpy.random import Generator, SeedSequence, default_rng
+import scipy.linalg
+import scipy.sparse as sp
+
+from . import (Qobj, create, destroy, jmat, basis,
+               to_super, to_choi, to_chi, to_kraus, to_stinespring)
+from .core import data as _data
+from .core.dimensions import flatten
+from . import settings
+
+
+_RAND = default_rng()
+_UNITS = np.array([1, 1j])
+
+
+def _implicit_tensor_dimensions(dimensions, superoper=False):
+    """
+    Total flattened size and operator dimensions for operator creation routines
+    that automatically perform tensor products.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        First dimension of an operator which can create an implicit tensor
+        product.  If the type is `int`, it is promoted first to `[dimensions]`.
+        From there, it should be one of the two-elements `dims` parameter of a
+        `qutip.Qobj` representing an `oper` or `super`, with possible tensor
+        products.
+
+    Returns
+    -------
+    size : int
+        Dimension of backing matrix required to represent operator.
+    dimensions : list
+        Dimension list in the form required by ``Qobj`` creation.
+    """
+    if not isinstance(dimensions, list):
+        dimensions = [dimensions]
+    flat = flatten(dimensions)
+    if not all(isinstance(x, numbers.Integral) and x >= 0 for x in flat):
+        raise ValueError("All dimensions must be integers >= 0")
+    N = np.prod(flat)
+    if superoper:
+        if isinstance(dimensions[0], numbers.Integral):
+            dimensions = [dimensions, dimensions]
+        else:
+            N = int(N**0.5)
+    return N, [dimensions, dimensions]
+
+
+def _get_generator(seed):
+    """
+    Obtain a random generator from a seed or generator.
+
+    Parameters
+    ----------
+    seed: int, SeedSequence, Generator, NoneType
+        Seed to create the generator. If it's already a generator return it.
+        When ``None`` is suplied, a default generator is provided.
+    """
+    if seed is None:
+        gen = _RAND
+    elif isinstance(seed, Generator):
+        gen = seed
+    else:
+        gen = default_rng(seed)
+    return gen
+
+
+def _randnz(shape, generator, norm=np.sqrt(0.5)):
+    """
+    Returns an array of standard normal complex random variates.
+    The Ginibre ensemble corresponds to setting ``norm = 1`` [Mis12]_.
+
+    Parameters
+    ----------
+    shape : tuple
+        Shape of the returned array of random variates.
+
+    generator : Generator
+        Random number generator.
+
+    norm : float
+        Scale of the returned random variates, or 'ginibre' to draw
+        from the Ginibre ensemble.
+    """
+    # This function is intended for internal use.
+    if norm == 'ginibre':
+        norm = 1
+    return np.sum(generator.normal(size=(shape + (2,))) * _UNITS, axis=-1) * norm
+
+
+def _rand_jacobi_rotation(A, generator):
+    """Random Jacobi rotation of a matrix.
+
+    Parameters
+    ----------
+    A : qutip.data.Data
+        Matrix to rotate as a data layer object.
+
+    generator : numpy.random.generator
+        Random number generator.
+
+    Returns
+    -------
+    qutip.data.Data
+        Rotated sparse matrix.
+    """
+    if A.shape[0] != A.shape[1]:
+        raise ValueError('Input matrix must be square.')
+    n = A.shape[0]
+    angle = 2 * generator.random() * np.pi
+    a = np.sqrt(0.5) * np.exp(-1j * angle)
+    b = np.conj(a)
+    i = generator.integers(n)
+    j = i
+    while i == j:
+        j = generator.integers(n)
+    data = np.hstack((np.array([a, -b, a, b], dtype=complex),
+                      np.ones(n - 2, dtype=complex)))
+    diag = np.delete(np.arange(n), [i, j])
+    rows = np.hstack(([i, i, j, j], diag))
+    cols = np.hstack(([i, j, i, j], diag))
+    R = sp.coo_matrix((data, (rows, cols)), shape=(n, n), dtype=complex)
+    R = _data.create(R.tocsr())
+    return _data.matmul(_data.matmul(R, A), R.adjoint())
+
+
+def _get_block_sizes(N, density, generator):
+    """
+    Obtain a list of matrix block sizes in such a way that an NxN matrix
+    composed of full matrices of these sizes along the diagonal would be of
+    desired density.
+    """
+    if density <= 0:
+        return [1] * N
+    elif density >= 1:
+        return [N]
+    max_block_size = int((N**2 * density)**0.5)
+    min_block_size = 1
+    if density >= 0.5:
+        min_block_size = int(N / 2 * (1 + (2 * density - 1)**0.5))
+
+    if min_block_size >= max_block_size:
+        M = min(min_block_size, max_block_size)
+    else:
+        M = generator.integers(min_block_size, max_block_size) + 1
+    M += generator.integers(-1, 2)
+    M = min(max(M, 1), N)
+
+    other_blocks = []
+    if M < N:
+        other_N = N - M
+        other_density = (density * N**2 - M**2) / other_N**2
+        other_blocks = _get_block_sizes(other_N, other_density, generator)
+
+    return [M] + other_blocks
+
+
+def _merge_shuffle_blocks(blocks, generator):
+    """
+    For a list of block, merge them in one matrix along the diagonal and
+    shuffle the rows and columns.
+    """
+    N = sum(block.shape[0] for block in blocks)
+    D = sum(block.shape[0]**2 for block in blocks) / N**2
+    idx = generator.permutation(N)
+    end = 0
+    if D < 0.1:
+        # TODO: coo_array from sicpy 1.8 would allow to simplify this.
+        row = []
+        col = []
+        data = []
+        for block in blocks:
+            start = end
+            end = end + block.shape[0]
+            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
+            row.append(brow.ravel())
+            col.append(bcol.ravel())
+            data.append(block.ravel())
+        data = np.hstack(data)
+        row = np.hstack(row)
+        col = np.hstack(col)
+        matrix = sp.coo_matrix((data, (row, col)), shape=(N, N))
+    else:
+        matrix = np.zeros((N,N), dtype=complex)
+        for block in blocks:
+            start = end
+            end = end + block.shape[0]
+            brow, bcol = np.meshgrid(idx[start:end], idx[start:end])
+            matrix[brow, bcol] = block
+    return _data.create(matrix, copy=False)
+
+
+def rand_herm(dimensions, density=0.30, distribution="fill", *,
+              eigenvalues=(), seed=None, dtype=None):
+    """Creates a random sparse Hermitian quantum object.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [0.30]
+        Density between [0,1] of output Hermitian operator.
+
+    distribution : str {"fill", "pos_def", "eigen"}
+        Method used to obtain the density matrices.
+
+        - "fill" : Uses :math:`H=0.5*(X+X^{+})` where :math:`X` is a randomly
+          generated quantum operator with elements uniformly distributed
+          between ``[-1, 1] + [-1j, 1j]``.
+        - "eigen" : A density matrix with the given ``eigenvalues``. It uses
+          random complex Jacobi rotations to shuffle the operator.
+        - "pos_def" : Return a positive semi-definite matrix by diagonal
+          dominance.
+
+    eigenvalues : array_like, optional
+        Eigenvalues of the output Hermitian matrix. The len must match the
+        shape of the matrix.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : :class:`qobj`
+        Hermitian quantum operator.
+
+    Notes
+    -----
+    If given a list of eigenvalues the object is created using complex Jacobi
+    rotations.  While this method is fast for small matrices, it should not be
+    repeatedly used for generating matrices larger than ~1000x1000.
+    """
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    generator = _get_generator(seed)
+    if distribution not in ["eigen", "fill", "pos_def"]:
+        raise ValueError("distribution must be one of {'eigen', 'fill', "
+                         "'pos_def'}")
+
+    if distribution == "eigen":
+        if N != len(eigenvalues):
+            raise ValueError("The number of eigenvalues does not match the "
+                             "desired shape.")
+        out = _data.diag[_data.CSR](eigenvalues, 0)
+        nvals = max([N**2 * density, 1])
+        out = _rand_jacobi_rotation(out, generator)
+        while _data.csr.nnz(out) < 0.95 * nvals:
+            out = _rand_jacobi_rotation(out, generator)
+        out = Qobj(out, type='oper', dims=dims, isherm=True, copy=False)
+        dtype = dtype or settings.core["default_dtype"] or _data.CSR
+
+    else:
+        pos_def = distribution == "pos_def"
+        if density < 0.5:
+            M = _rand_herm_sparse(N, density, pos_def, generator)
+            dtype = dtype or settings.core["default_dtype"] or _data.CSR
+        else:
+            M = _rand_herm_dense(N, density, pos_def, generator)
+            dtype = dtype or settings.core["default_dtype"] or _data.Dense
+
+        out = Qobj(M, type='oper', dims=dims, isherm=True, copy=False)
+
+    return out.to(dtype)
+
+
+def _rand_herm_sparse(N, density, pos_def, generator):
+    target = (1 - (1 - density)**0.5)
+    num_elems = (N**2 - 0.666 * N) * target + 0.666 * N * density
+    num_elems = max([num_elems, 1])
+    num_elems = int(num_elems)
+    data = (2 * generator.random(num_elems) - 1) + \
+           (2 * generator.random(num_elems) - 1) * 1j
+    row_idx, col_idx = zip(*[
+        divmod(index, N)
+        for index in generator.choice(N*N, num_elems, replace=False)
+    ])
+    M = sp.coo_matrix((data, (row_idx, col_idx)),
+                      dtype=complex, shape=(N, N))
+    M = 0.5 * (M + M.conj().transpose())
+    M.sort_indices()
+    rand_mat = _data.create(M)
+    if pos_def:
+        rand_mat = _data.add(
+            rand_mat,
+            _data.diag(np.ones(N, dtype=complex)),
+            np.sqrt(2) * N + 1
+        )
+    return rand_mat
+
+
+def _rand_herm_dense(N, density, pos_def, generator):
+    M = (
+        (2*generator.random((N, N)) - 1)
+        + 1j*(2*generator.random((N, N)) - 1)
+    )
+    M = 0.5 * (M + M.conj().transpose())
+    target = 1 - density**0.5
+    num_remove = N * (N - 0.666) * target + 0.666 * N * (1 - density)
+    num_remove = max([num_remove, 1])
+    num_remove = int(num_remove)
+    for index in generator.choice(N*N, num_remove, replace=False):
+        row, col = divmod(index, N)
+        M[col, row] = 0
+        M[row, col] = 0
+    if pos_def:
+        np.fill_diagonal(M, np.abs(M.diagonal()) + np.sqrt(2) * N )
+    return _data.create(M)
+
+
+def rand_unitary(dimensions, density=1, distribution="haar", *,
+                 seed=None, dtype=None):
+    r"""Creates a random sparse unitary quantum object.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [1]
+        Density between [0,1] of output unitary operator.
+
+    distribution : ["haar", "exp"]
+        Method used to obtain the unitary matrices.
+
+        - haar : Haar random unitary matrix using the algorithm of [Mez07]_.
+        - exp : Uses :math:`\exp(-iH)`, where H is a randomly generated
+          Hermitian operator.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Unitary quantum operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    if distribution not in ["haar", "exp"]:
+        raise ValueError("distribution must be one of {'haar', 'exp'}")
+    generator = _get_generator(seed)
+    block_sizes = _get_block_sizes(N, density, generator)
+
+    blocks = []
+    for block in block_sizes:
+        if distribution == "haar":
+            mat = _rand_unitary_haar(block, generator)
+        elif distribution == "exp":
+            mat = scipy.linalg.expm(
+                -1.0j *
+                _rand_herm_dense(block, 1, False, generator).as_ndarray()
+            )
+        blocks.append(mat)
+
+    merged = _merge_shuffle_blocks(blocks, generator)
+
+    mat = Qobj(merged, type='oper', dims=dims, isunitary=True, copy=False)
+    return mat.to(dtype)
+
+
+def _rand_unitary_haar(N, generator):
+    """
+    Returns a Haar random unitary matrix of dimension
+    ``dim``, using the algorithm of [Mez07]_.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of the unitary to be returned.
+
+    generator : numpy.random.generator
+        Random number generator.
+
+    Returns
+    -------
+    U : qutip.core.data.Dense
+        Unitary of shape ``(N, N)`` drawn from the Haar measure.
+    """
+    # Mez01 STEP 1: Generate an N × N matrix Z of complex standard
+    #               normal random variates.
+    Z = _randnz((N, N), generator)
+
+    # Mez01 STEP 2: Find a QR decomposition Z = Q · R.
+    Q, R = scipy.linalg.qr(Z)
+
+    # Mez01 STEP 3: Create a diagonal matrix Lambda by rescaling
+    #               the diagonal elements of R.
+    Lambda = np.diag(R).copy()
+    Lambda /= np.abs(Lambda)
+
+    # Mez01 STEP 4: Note that R' := Λ¯¹ · R has real and
+    #               strictly positive elements, such that
+    #               Q' = Q · Λ is Haar distributed.
+    # NOTE: Λ is a diagonal matrix, represented as a vector
+    #       of the diagonal entries. Thus, the matrix dot product
+    #       is represented nicely by the NumPy broadcasting of
+    #       the *scalar* multiplication. In particular,
+    #       Q · Λ = Q_ij Λ_jk = Q_ij δ_jk λ_k = Q_ij λ_j.
+    #       As NumPy arrays, Q has shape (N, N) and
+    #       Lambda has shape (N, ), such that the broadcasting
+    #       represents precisely Q_ij λ_j.
+    return Q * Lambda
+
+
+def rand_ket(dimensions, density=1, distribution="haar", *,
+             seed=None, dtype=None):
+    """Creates a random ket vector.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [1]
+        Density between [0,1] of output ket state when using the ``fill``
+        method.
+
+    distribution : str {"haar", "fill"}
+        Method used to obtain the kets.
+
+        - haar : Haar random pure state obtained by applying a Haar random
+          unitary to a fixed pure state.
+        - fill : Fill the ket with uniformly distributed random complex number.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Ket quantum state vector.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    if distribution not in ["haar", "fill"]:
+        raise ValueError("distribution must be one of {'haar', 'fill'}")
+
+    if distribution == "haar":
+        ket = rand_unitary(N, density, "haar", seed=generator) @ basis(N, 0)
+    else:
+        X = scipy.sparse.rand(N, 1, density, format='csr',
+                              random_state=generator)
+        while X.nnz == 0:
+            # ensure that the ket is not all zeros.
+            X = scipy.sparse.rand(N, 1, density+1/N, format='csr',
+                                  random_state=generator)
+        X.data = X.data - 0.5
+        Y = X.copy()
+        Y.data = 1.0j * (generator.random(len(X.data)) - 0.5)
+        X = _data.csr.CSR(X + Y)
+        ket = Qobj(_data.mul(X, 1 / _data.norm.l2(X)),
+                   copy=False, type="ket", isherm=False, isunitary=False)
+    ket.dims = [dims[0], [1]]
+    return ket.to(dtype)
+
+
+def rand_dm(dimensions, density=0.75, distribution="ginibre", *,
+            eigenvalues=(), rank=None, seed=None,
+            dtype=None):
+    r"""Creates a random density matrix of the desired dimensions.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either ``oper`` or
+        ``super`` depending on the passed ``dimensions``.
+
+    density : float
+        Density between [0,1] of output density matrix. Used by the "pure",
+        "eigen" and "herm".
+
+    distribution : str {"ginibre", "hs", "pure", "eigen", "uniform"}
+        Method used to obtain the density matrices.
+
+        - "ginibre" : Ginibre random density operator of rank ``rank`` by using
+          the algorithm of [BCSZ08]_.
+        - "hs" : Hilbert-Schmidt ensemble, equivalent to a full rank ginibre
+          operator.
+        - "pure" : Density matrix created from a random ket.
+        - "eigen" : A density matrix with the given ``eigenvalues``.
+        - "herm" : Build from a random hermitian matrix using ``rand_herm``.
+
+    eigenvalues : array_like, optional
+        Eigenvalues of the output Hermitian matrix. The len must match the
+        shape of the matrix.
+
+    rank : int, optional
+        When using the "ginibre" distribution, rank of the density matrix.
+        Will default to a full rank operator when not provided.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Density matrix quantum operator.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    distributions = set(["eigen", "ginibre", "hs", "pure", "herm"])
+    if distribution not in distributions:
+        raise ValueError(f"distribution must be one of {distributions}")
+
+    if distribution == "eigen":
+        if len(eigenvalues) != N:
+            raise ValueError("Number of eigenvalues does not match the shape.")
+        if np.abs(np.sum(eigenvalues)-1.0) > 1e-15 * N:
+            raise ValueError('Eigenvalues of a density matrix '
+                             f'must sum to one, not {np.sum(eigenvalues)}')
+        H = _data.diag(eigenvalues, 0)
+        nvals = N**2 * density
+        H = _rand_jacobi_rotation(H, generator)
+        while _data.csr.nnz(H) < 0.95*nvals:
+            H = _rand_jacobi_rotation(H, generator)
+    elif distribution == "ginibre":
+        H = _rand_dm_ginibre(N, rank, generator)
+    elif distribution == "hs":
+        H = _rand_dm_ginibre(N, N, generator)
+    elif distribution == "pure":
+        dm_density = np.sqrt(density)
+        psi = rand_ket(N, density=dm_density,
+                       distribution="fill", seed=generator)
+        H = psi.proj().data
+    elif distribution == "herm":
+        block_sizes = _get_block_sizes(N, density, generator)
+        blocks = []
+        first = True
+        for block in block_sizes:
+            if block != 1:
+                mat = rand_herm(block, 1, seed=generator, dtype="dense").full()
+            else:
+                mat = np.ones((1,1))
+                if not first:
+                    mat *= max(generator.random() - 0.5, 0)
+                first = False
+            blocks.append(mat.T.conj() @ mat)
+        H = _merge_shuffle_blocks(blocks, generator)
+        H /= H.trace()
+
+    return Qobj(H, dims=dims, type='oper', isherm=True, copy=False).to(dtype)
+
+
+def _rand_dm_ginibre(N, rank, generator):
+    """
+    Returns a Ginibre random density operator of  rank ``rank`` by using the
+    algorithm of [BCSZ08]_. If ``rank`` is `None`, a full-rank
+    (Hilbert-Schmidt ensemble) random density operator will be
+    returned.
+
+    Parameters
+    ----------
+    N : int
+        Dimension of the density operator to be returned.
+
+    rank : int or None
+        Rank of the sampled density operator. If None, a full-rank
+        density operator is generated.
+
+    Returns
+    -------
+    rho : Qobj
+        An N × N density operator sampled from the Ginibre
+        or Hilbert-Schmidt distribution.
+    """
+    if not rank:
+        rank = N
+    if rank > N:
+        raise ValueError("Rank cannot exceed dimension.")
+
+    X = _randnz((N, rank), generator, norm='ginibre')
+    rho = np.dot(X, X.T.conj())
+    rho /= np.trace(rho)
+
+    return rho
+
+
+def rand_kraus_map(dimensions, *, seed=None,
+                   dtype=None):
+    """
+    Creates a random CPTP map on an N-dimensional Hilbert space in Kraus
+    form.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper_list : list of qobj
+        N^2 x N x N qobj operators.
+
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    N, dims = _implicit_tensor_dimensions(dimensions)
+
+    # Random unitary (Stinespring Dilation)
+    big_unitary = rand_unitary(N ** 3, seed=seed, dtype=dtype).full()
+    orthog_cols = np.array(big_unitary[:, :N])
+    oper_list = np.reshape(orthog_cols, (N ** 2, N, N))
+    return [Qobj(x, dims=dims, type='oper', copy=False).to(dtype)
+            for x in oper_list]
+
+
+def rand_super(dimensions, *, superrep="super", seed=None,
+               dtype=None):
+    """
+    Returns a randomly drawn superoperator acting on operators acting on
+    N dimensions.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    superrop : str, optional, {"super"}
+        Representation of the super operator
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    from .solver.propagator import propagator
+    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
+    H = rand_herm(N, seed=generator, dtype=dtype)
+    S = propagator(H, generator.random(), [
+        create(N), destroy(N), jmat(float(N - 1) / 2.0, 'z')
+    ])
+    S.dims = dims
+    out = {
+            "choi" : to_choi,
+            "chi" : to_chi,
+            "super": to_super,
+        }[superrep](S).to(dtype)
+    return out
+
+
+def rand_super_bcsz(dimensions, enforce_tp=True, rank=None, *,
+                    superrep="super", seed=None,
+                    dtype=None):
+    """
+    Returns a random superoperator drawn from the Bruzda
+    et al ensemble for CPTP maps [BCSZ08]_. Note that due to
+    finite numerical precision, for ranks less than full-rank,
+    zero eigenvalues may become slightly negative, such that the
+    returned operator is not actually completely positive.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If an int is provided, it is understood as
+        the Square root of the dimension of the superoperator to be returned,
+        with the corresponding dims as ``[[[N],[N]], [[N],[N]]]``. If provided
+        as a list of ints, then the dimensions is understood as the space of
+        density matrices this superoperator is applied to: ``dimensions=[2,2]``
+        ``dims=[[[2,2],[2,2]], [[2,2],[2,2]]]``.
+
+    enforce_tp : bool
+        If True, the trace-preserving condition of [BCSZ08]_ is enforced;
+        otherwise only complete positivity is enforced.
+
+    rank : int or None
+        Rank of the sampled superoperator. If None, a full-rank
+        superoperator is generated.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    superrop : str, optional, {"super"}
+        representation of the
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    rho : Qobj
+        A superoperator acting on vectorized dim × dim density operators,
+        sampled from the BCSZ distribution.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions, superoper=True)
+
+    if rank is None:
+        rank = N**2
+    if rank > N**2:
+        raise ValueError("Rank cannot exceed superoperator dimension.")
+
+    # We use mainly dense matrices here for speed in low
+    # dimensions. In the future, it would likely be better to switch off
+    # between sparse and dense matrices as the dimension grows.
+
+    # We start with a Ginibre uniform matrix X of the appropriate rank,
+    # and use it to construct a positive semidefinite matrix X X⁺.
+    X = _randnz((N**2, rank), generator, norm='ginibre')
+
+    # Precompute X X⁺, as we'll need it in two different places.
+    XXdag = np.dot(X, X.T.conj())
+    tmp_dims = [[[N], [N]], [[N], [N]]]
+
+    if enforce_tp:
+        # We do the partial trace over the first index by using dense reshape
+        # operations, so that we can avoid bouncing to a sparse representation
+        # and back.
+        Y = np.einsum('ijik->jk', XXdag.reshape((N, N, N, N)))
+
+        # Now we have the matrix 𝟙 ⊗ Y^{-1/2}, which we can find by doing
+        # the square root and the inverse separately. As a possible
+        # improvement, iterative methods exist to find inverse square root
+        # matrices directly, as this is important in statistics.
+        Z = np.kron(
+            np.eye(N),
+            scipy.linalg.sqrtm(scipy.linalg.inv(Y))
+        )
+
+        # Finally, we dot everything together and pack it into a Qobj,
+        # marking the dimensions as that of a type=super (that is,
+        # with left and right compound indices, each representing
+        # left and right indices on the underlying Hilbert space).
+        D = Qobj(np.dot(Z, np.dot(XXdag, Z)), dims=tmp_dims, type='super')
+    else:
+        D = N * Qobj(XXdag / np.trace(XXdag), dims=tmp_dims, type='super')
+
+    # Since [BCSZ08] gives a row-stacking Choi matrix, but QuTiP
+    # expects a column-stacking Choi matrix, we must permute the indices.
+    D = D.permute([[1], [0]])
+
+    # Mark that we've made a Choi matrix.
+    D.superrep = 'choi'
+    D.dims = dims
+    out = {
+            "choi" : to_choi,
+            "chi" : to_chi,
+            "super": to_super,
+        }[superrep](D).to(dtype)
+    return out
+
+
+def rand_stochastic(dimensions, density=0.75, kind='left',
+                    *, seed=None, dtype=None):
+    """Generates a random stochastic matrix.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    density : float, [0.75]
+        Density between [0,1] of output density matrix.
+
+    kind : str (Default = 'left')
+        Generate 'left' or 'right' stochastic matrix.
+
+    seed : int, SeedSequence, Generator, optional
+        Seed to create the random number generator or a pre prepared
+        generator. When none is suplied, a default generator is used.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Quantum operator form of stochastic matrix.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.Dense
+    generator = _get_generator(seed)
+    N, dims = _implicit_tensor_dimensions(dimensions)
+    num_elems = max([int(np.ceil(N*(N+1)*density)/2), N])
+    data = generator.random(num_elems)
+    # Ensure an element on every row and column
+    row_idx = np.hstack([generator.permutation(N),
+                         generator.choice(N, num_elems-N)])
+    col_idx = np.hstack([generator.permutation(N),
+                         generator.choice(N, num_elems-N)])
+    M = sp.coo_matrix((data, (row_idx, col_idx)),
+                      dtype=np.complex128, shape=(N, N)).tocsr()
+    M = 0.5 * (M + M.conj().transpose())
+    num_rows = M.indptr.shape[0] - 1
+    for row in range(num_rows):
+        row_start = M.indptr[row]
+        row_end = M.indptr[row+1]
+        row_sum = np.sum(M.data[row_start:row_end])
+        M.data[row_start:row_end] /= row_sum
+    if kind == 'left':
+        M = M.transpose()
+    return Qobj(M, dims=dims).to(dtype)
diff --git a/qutip/settings.py b/qutip/settings.py
index ccf303714a..29ee053b75 100644
--- a/qutip/settings.py
+++ b/qutip/settings.py
@@ -1,293 +1,293 @@
-"""
-This module contains settings for the QuTiP graphics, multiprocessing, and
-tidyup functionality, etc.
-"""
-import os
-import sys
-from ctypes import cdll
-import platform
-import numpy as np
-
-__all__ = ['settings']
-
-
-def _blas_info():
-    config = np.__config__
-    if hasattr(config, 'blas_ilp64_opt_info'):
-        blas_info = config.blas_ilp64_opt_info
-    elif hasattr(config, 'blas_opt_info'):
-        blas_info = config.blas_opt_info
-    else:
-        blas_info = {}
-
-    def _in_libaries(name):
-        return any(name in lib for lib in blas_info.get('libraries', []))
-
-    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
-        blas = 'INTEL MKL'
-    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
-        blas = 'OPENBLAS'
-    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
-        blas = 'Accelerate'
-    else:
-        blas = 'Generic'
-    return blas
-
-
-def available_cpu_count():
-    """
-    Get the number of cpus.
-    It tries to only get the number available to qutip.
-    """
-    import os
-    import multiprocessing
-    try:
-        import psutil
-    except ImportError:
-        psutil = None
-    num_cpu = 0
-
-    if 'QUTIP_NUM_PROCESSES' in os.environ:
-        # We consider QUTIP_NUM_PROCESSES=0 as unset.
-        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
-
-    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
-        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
-
-    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
-        num_cpu = len(os.sched_getaffinity(0))
-
-    if (
-        num_cpu == 0
-        and psutil is not None
-        and hasattr(psutil.Process(), "cpu_affinity")
-    ):
-        num_cpu = len(psutil.Process().cpu_affinity())
-
-    if num_cpu == 0:
-        try:
-            num_cpu = multiprocessing.cpu_count()
-        except NotImplementedError:
-            pass
-
-    return num_cpu or 1
-
-
-def _find_mkl():
-    """
-    Finds the MKL runtime library for the Anaconda and Intel Python
-    distributions.
-    """
-    mkl_lib = None
-    if _blas_info() == 'INTEL MKL':
-        plat = sys.platform
-        python_dir = os.path.dirname(sys.executable)
-        if plat in ['darwin', 'linux2', 'linux']:
-            python_dir = os.path.dirname(python_dir)
-
-        if plat == 'darwin':
-            lib = '/libmkl_rt.dylib'
-        elif plat == 'win32':
-            lib = r'\mkl_rt.dll'
-        elif plat in ['linux2', 'linux']:
-            lib = '/libmkl_rt.so'
-        else:
-            raise Exception('Unknown platfrom.')
-
-        if plat in ['darwin', 'linux2', 'linux']:
-            lib_dir = '/lib'
-        else:
-            lib_dir = r'\Library\bin'
-        # Try in default Anaconda location first
-        try:
-            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
-        except Exception:
-            pass
-
-        # Look in Intel Python distro location
-        if mkl_lib is None:
-            if plat in ['darwin', 'linux2', 'linux']:
-                lib_dir = '/ext/lib'
-            else:
-                lib_dir = r'\ext\lib'
-            try:
-                mkl_lib = \
-                    cdll.LoadLibrary(python_dir + lib_dir + lib)
-            except Exception:
-                pass
-    return mkl_lib
-
-
-class Settings:
-    """
-    Qutip's settings and options.
-    """
-    def __init__(self):
-        self._mkl_lib = ""
-        try:
-            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
-        except OSError:
-            self._tmproot = "."
-        self.core = None  # set in qutip.core.options
-        self.compile = None  # set in qutip.core.coefficient
-        self._debug = False
-        self._log_handler = "default"
-        self._colorblind_safe = False
-
-    @property
-    def has_mkl(self):
-        """ Whether qutip found an mkl installation. """
-        return self.mkl_lib is not None
-
-    @property
-    def mkl_lib(self):
-        """ Location of the mkl installation. """
-        if self._mkl_lib == "":
-            self._mkl_lib = _find_mkl()
-        return _find_mkl()
-
-    @property
-    def ipython(self):
-        """ Whether qutip is running in ipython. """
-        try:
-            __IPYTHON__
-            return True
-        except NameError:
-            return False
-
-    @property
-    def eigh_unsafe(self):
-        """
-        Whether `eigh` call is reliable.
-        Some implementation of blas have some issues on some OS.
-        """
-        from packaging import version as pac_version
-        import scipy
-        is_old_scipy = (
-            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
-        )
-        return (
-            # macOS OpenBLAS eigh is unstable, see #1288
-            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
-            # The combination of scipy<1.5 and MKL causes wrong results when
-            # calling eigh for big matrices.  See #1495, #1491 and #1498.
-            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
-        )
-
-    @property
-    def tmproot(self):
-        """
-        Location in which qutip place cython string coefficient folders.
-        The default is "$HOME/.qutip".
-        Can be updated.
-        """
-        return self._tmproot
-
-    @tmproot.setter
-    def tmproot(self, root):
-        if not os.path.exists(root):
-            os.mkdir(root)
-        self._tmproot = root
-
-    @property
-    def coeffroot(self):
-        """
-        Location in which qutip save cython string coefficient files.
-        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
-        Can be updated.
-        """
-        return self._coeffroot
-
-    @coeffroot.setter
-    def coeffroot(self, root):
-        if not os.path.exists(root):
-            os.mkdir(root)
-        if root not in sys.path:
-            sys.path.insert(0, root)
-        self._coeffroot = root
-
-    @property
-    def coeff_write_ok(self):
-        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
-        return os.access(self.coeffroot, os.W_OK)
-
-    @property
-    def has_openmp(self):
-        return False
-        # We keep this as a reminder for when openmp is restored: see Pull #652
-        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-
-    @property
-    def idxint_size(self):
-        """
-        Integer type used by ``CSR`` data.
-        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
-        non-zeros elements.
-        """
-        from .core import data
-        return data.base.idxint_size
-
-    @property
-    def num_cpus(self):
-        """
-        Number of cpu detected.
-        Use the solver options to control the number of cpus used.
-        """
-        if 'QUTIP_NUM_PROCESSES' in os.environ:
-            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
-        else:
-            num_cpus = available_cpu_count()
-            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
-        return num_cpus
-
-    @property
-    def debug(self):
-        """
-        Debug mode for development.
-        """
-        return self._debug
-
-    @debug.setter
-    def debug(self, value):
-        self._debug = value
-
-    @property
-    def log_handler(self):
-        """
-        Define whether log handler should be:
-        - default: switch based on IPython detection
-        - stream: set up non-propagating StreamHandler
-        - basic: call basicConfig
-        - null: leave logging to the user
-        """
-        return self._log_handler
-
-    @log_handler.setter
-    def log_handler(self, value):
-        self._log_handler = value
-
-    @property
-    def colorblind_safe(self):
-        """
-        Allow for a colorblind mode that uses different colormaps
-        and plotting options by default.
-        """
-        return self._colorblind_safe
-
-    @colorblind_safe.setter
-    def colorblind_safe(self, value):
-        self._colorblind_safe = value
-
-    def __str__(self):
-        lines = ["Qutip settings:"]
-        for attr in self.__dir__():
-            if not attr.startswith('_') and attr not in ["core", "compile"]:
-                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
-        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
-        return '\n'.join(lines)
-
-    def __repr__(self):
-        return self.__str__()
-
-
-settings = Settings()
+"""
+This module contains settings for the QuTiP graphics, multiprocessing, and
+tidyup functionality, etc.
+"""
+import os
+import sys
+from ctypes import cdll
+import platform
+import numpy as np
+
+__all__ = ['settings']
+
+
+def _blas_info():
+    config = np.__config__
+    if hasattr(config, 'blas_ilp64_opt_info'):
+        blas_info = config.blas_ilp64_opt_info
+    elif hasattr(config, 'blas_opt_info'):
+        blas_info = config.blas_opt_info
+    else:
+        blas_info = {}
+
+    def _in_libaries(name):
+        return any(name in lib for lib in blas_info.get('libraries', []))
+
+    if getattr(config, 'mkl_info', False) or _in_libaries("mkl"):
+        blas = 'INTEL MKL'
+    elif getattr(config, 'openblas_info', False) or _in_libaries('openblas'):
+        blas = 'OPENBLAS'
+    elif '-Wl,Accelerate' in blas_info.get('extra_link_args', []):
+        blas = 'Accelerate'
+    else:
+        blas = 'Generic'
+    return blas
+
+
+def available_cpu_count():
+    """
+    Get the number of cpus.
+    It tries to only get the number available to qutip.
+    """
+    import os
+    import multiprocessing
+    try:
+        import psutil
+    except ImportError:
+        psutil = None
+    num_cpu = 0
+
+    if 'QUTIP_NUM_PROCESSES' in os.environ:
+        # We consider QUTIP_NUM_PROCESSES=0 as unset.
+        num_cpu = int(os.environ['QUTIP_NUM_PROCESSES'])
+
+    if num_cpu == 0 and 'SLURM_CPUS_PER_TASK' in os.environ:
+        num_cpu = int(os.environ['SLURM_CPUS_PER_TASK'])
+
+    if num_cpu == 0 and hasattr(os, 'sched_getaffinity'):
+        num_cpu = len(os.sched_getaffinity(0))
+
+    if (
+        num_cpu == 0
+        and psutil is not None
+        and hasattr(psutil.Process(), "cpu_affinity")
+    ):
+        num_cpu = len(psutil.Process().cpu_affinity())
+
+    if num_cpu == 0:
+        try:
+            num_cpu = multiprocessing.cpu_count()
+        except NotImplementedError:
+            pass
+
+    return num_cpu or 1
+
+
+def _find_mkl():
+    """
+    Finds the MKL runtime library for the Anaconda and Intel Python
+    distributions.
+    """
+    mkl_lib = None
+    if _blas_info() == 'INTEL MKL':
+        plat = sys.platform
+        python_dir = os.path.dirname(sys.executable)
+        if plat in ['darwin', 'linux2', 'linux']:
+            python_dir = os.path.dirname(python_dir)
+
+        if plat == 'darwin':
+            lib = '/libmkl_rt.dylib'
+        elif plat == 'win32':
+            lib = r'\mkl_rt.dll'
+        elif plat in ['linux2', 'linux']:
+            lib = '/libmkl_rt.so'
+        else:
+            raise Exception('Unknown platfrom.')
+
+        if plat in ['darwin', 'linux2', 'linux']:
+            lib_dir = '/lib'
+        else:
+            lib_dir = r'\Library\bin'
+        # Try in default Anaconda location first
+        try:
+            mkl_lib = cdll.LoadLibrary(python_dir+lib_dir+lib)
+        except Exception:
+            pass
+
+        # Look in Intel Python distro location
+        if mkl_lib is None:
+            if plat in ['darwin', 'linux2', 'linux']:
+                lib_dir = '/ext/lib'
+            else:
+                lib_dir = r'\ext\lib'
+            try:
+                mkl_lib = \
+                    cdll.LoadLibrary(python_dir + lib_dir + lib)
+            except Exception:
+                pass
+    return mkl_lib
+
+
+class Settings:
+    """
+    Qutip's settings and options.
+    """
+    def __init__(self):
+        self._mkl_lib = ""
+        try:
+            self.tmproot = os.path.join(os.path.expanduser("~"), '.qutip')
+        except OSError:
+            self._tmproot = "."
+        self.core = None  # set in qutip.core.options
+        self.compile = None  # set in qutip.core.coefficient
+        self._debug = False
+        self._log_handler = "default"
+        self._colorblind_safe = False
+
+    @property
+    def has_mkl(self):
+        """ Whether qutip found an mkl installation. """
+        return self.mkl_lib is not None
+
+    @property
+    def mkl_lib(self):
+        """ Location of the mkl installation. """
+        if self._mkl_lib == "":
+            self._mkl_lib = _find_mkl()
+        return _find_mkl()
+
+    @property
+    def ipython(self):
+        """ Whether qutip is running in ipython. """
+        try:
+            __IPYTHON__
+            return True
+        except NameError:
+            return False
+
+    @property
+    def eigh_unsafe(self):
+        """
+        Whether `eigh` call is reliable.
+        Some implementation of blas have some issues on some OS.
+        """
+        from packaging import version as pac_version
+        import scipy
+        is_old_scipy = (
+            pac_version.parse(scipy.__version__) < pac_version.parse("1.5")
+        )
+        return (
+            # macOS OpenBLAS eigh is unstable, see #1288
+            (_blas_info() == "OPENBLAS" and platform.system() == 'Darwin')
+            # The combination of scipy<1.5 and MKL causes wrong results when
+            # calling eigh for big matrices.  See #1495, #1491 and #1498.
+            or (is_old_scipy and (_blas_info() == 'INTEL MKL'))
+        )
+
+    @property
+    def tmproot(self):
+        """
+        Location in which qutip place cython string coefficient folders.
+        The default is "$HOME/.qutip".
+        Can be updated.
+        """
+        return self._tmproot
+
+    @tmproot.setter
+    def tmproot(self, root):
+        if not os.path.exists(root):
+            os.mkdir(root)
+        self._tmproot = root
+
+    @property
+    def coeffroot(self):
+        """
+        Location in which qutip save cython string coefficient files.
+        Usually "{qutip.settings.tmproot}/qutip_coeffs_X.X".
+        Can be updated.
+        """
+        return self._coeffroot
+
+    @coeffroot.setter
+    def coeffroot(self, root):
+        if not os.path.exists(root):
+            os.mkdir(root)
+        if root not in sys.path:
+            sys.path.insert(0, root)
+        self._coeffroot = root
+
+    @property
+    def coeff_write_ok(self):
+        """ Whether qutip has write acces to ``qutip.settings.coeffroot``."""
+        return os.access(self.coeffroot, os.W_OK)
+
+    @property
+    def has_openmp(self):
+        return False
+        # We keep this as a reminder for when openmp is restored: see Pull #652
+        # os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+
+    @property
+    def idxint_size(self):
+        """
+        Integer type used by ``CSR`` data.
+        Sparse ``CSR`` matrices can contain at most ``2**idxint_size``
+        non-zeros elements.
+        """
+        from .core import data
+        return data.base.idxint_size
+
+    @property
+    def num_cpus(self):
+        """
+        Number of cpu detected.
+        Use the solver options to control the number of cpus used.
+        """
+        if 'QUTIP_NUM_PROCESSES' in os.environ:
+            num_cpus = int(os.environ['QUTIP_NUM_PROCESSES'])
+        else:
+            num_cpus = available_cpu_count()
+            os.environ['QUTIP_NUM_PROCESSES'] = str(num_cpus)
+        return num_cpus
+
+    @property
+    def debug(self):
+        """
+        Debug mode for development.
+        """
+        return self._debug
+
+    @debug.setter
+    def debug(self, value):
+        self._debug = value
+
+    @property
+    def log_handler(self):
+        """
+        Define whether log handler should be:
+        - default: switch based on IPython detection
+        - stream: set up non-propagating StreamHandler
+        - basic: call basicConfig
+        - null: leave logging to the user
+        """
+        return self._log_handler
+
+    @log_handler.setter
+    def log_handler(self, value):
+        self._log_handler = value
+
+    @property
+    def colorblind_safe(self):
+        """
+        Allow for a colorblind mode that uses different colormaps
+        and plotting options by default.
+        """
+        return self._colorblind_safe
+
+    @colorblind_safe.setter
+    def colorblind_safe(self, value):
+        self._colorblind_safe = value
+
+    def __str__(self):
+        lines = ["Qutip settings:"]
+        for attr in self.__dir__():
+            if not attr.startswith('_') and attr not in ["core", "compile"]:
+                lines.append(f"    {attr}: {self.__getattribute__(attr)}")
+        lines.append(f"    compile: {self.compile.__repr__(full=False)}")
+        return '\n'.join(lines)
+
+    def __repr__(self):
+        return self.__str__()
+
+
+settings = Settings()
diff --git a/qutip/simdiag.py b/qutip/simdiag.py
index a0105eee5d..370ade6552 100644
--- a/qutip/simdiag.py
+++ b/qutip/simdiag.py
@@ -1,120 +1,120 @@
-__all__ = ['simdiag']
-
-import numpy as np
-import scipy.linalg as la
-from . import Qobj
-from .core import data as _data
-
-
-def _degen(tol, vecs, ops, i=0):
-    """
-    Private function that finds eigen vals and vecs for degenerate matrices..
-    """
-    if len(ops) == i:
-        return vecs
-
-    # New eigenvectors are sometime not orthogonal.
-    for j in range(1, vecs.shape[1]):
-        for k in range(j):
-            dot = vecs[:, j].dot(vecs[:, k].conj())
-            if np.abs(dot) > tol:
-                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
-                              / (1 - np.abs(dot)**2)**0.5)
-
-    subspace = vecs.conj().T @ ops[i].full() @ vecs
-    eigvals, eigvecs = la.eig(subspace)
-
-    perm = np.argsort(eigvals)
-    eigvals = eigvals[perm]
-
-    vecs_new = vecs @ eigvecs[:, perm]
-    for k in range(len(eigvals)):
-        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
-
-    k = 0
-    while k < len(eigvals):
-        ttol = max(tol, tol * abs(eigvals[k]))
-        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
-        if len(inds) > 1:  # if at least 2 eigvals are degenerate
-            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
-        k = inds[-1] + 1
-    return vecs_new
-
-
-def simdiag(ops, evals: bool = True, *,
-            tol: float = 1e-14, safe_mode: bool = True):
-    """Simultaneous diagonalization of commuting Hermitian matrices.
-
-    Parameters
-    ----------
-    ops : list/array
-        ``list`` or ``array`` of qobjs representing commuting Hermitian
-        operators.
-
-    evals : bool [True]
-        Whether to return the eigenvalues for each ops and eigenvectors or just
-        the eigenvectors.
-
-    tol : float [1e-14]
-        Tolerance for detecting degenerate eigenstates.
-
-    safe_mode : bool [True]
-        Whether to check that all ops are Hermitian and commuting. If set to
-        ``False`` and operators are not commuting, the eigenvectors returned
-        will often be eigenvectors of only the first operator.
-
-    Returns
-    --------
-    eigs : tuple
-        Tuple of arrays representing eigvecs and eigvals of quantum objects
-        corresponding to simultaneous eigenvectors and eigenvalues for each
-        operator.
-
-    """
-    if not ops:
-        raise ValueError("No input matrices.")
-    N = ops[0].shape[0]
-    num_ops = len(ops) if safe_mode else 0
-    for jj in range(num_ops):
-        A = ops[jj]
-        shape = A.shape
-        if shape[0] != shape[1]:
-            raise TypeError('Matricies must be square.')
-        if shape[0] != N:
-            raise TypeError('All matrices. must be the same shape')
-        if not A.isherm:
-            raise TypeError('Matricies must be Hermitian')
-        for kk in range(jj):
-            B = ops[kk]
-            if (A * B - B * A).norm() / (A * B).norm() > tol:
-                raise TypeError('Matricies must commute.')
-
-    # TODO: rewrite using Data object
-    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
-    eigvecs = eigvecs.to_array()
-
-    k = 0
-    while k < N:
-        # find degenerate eigenvalues, get indicies of degenerate eigvals
-        ttol = max(tol, tol * abs(eigvals[k]))
-        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
-        if len(inds) > 1:  # if at least 2 eigvals are degenerate
-            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
-        k = inds[-1] + 1
-
-    for k in range(N):
-        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
-
-    kets_out = [
-        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
-        for j in range(N)
-    ]
-    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
-    if not evals:
-        return kets_out
-    else:
-        for kk in range(len(ops)):
-            for j in range(N):
-                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
-                                                            kets_out[j]).real
-        return eigvals_out, kets_out
+__all__ = ['simdiag']
+
+import numpy as np
+import scipy.linalg as la
+from . import Qobj
+from .core import data as _data
+
+
+def _degen(tol, vecs, ops, i=0):
+    """
+    Private function that finds eigen vals and vecs for degenerate matrices..
+    """
+    if len(ops) == i:
+        return vecs
+
+    # New eigenvectors are sometime not orthogonal.
+    for j in range(1, vecs.shape[1]):
+        for k in range(j):
+            dot = vecs[:, j].dot(vecs[:, k].conj())
+            if np.abs(dot) > tol:
+                vecs[:, j] = ((vecs[:, j] - dot * vecs[:, k])
+                              / (1 - np.abs(dot)**2)**0.5)
+
+    subspace = vecs.conj().T @ ops[i].full() @ vecs
+    eigvals, eigvecs = la.eig(subspace)
+
+    perm = np.argsort(eigvals)
+    eigvals = eigvals[perm]
+
+    vecs_new = vecs @ eigvecs[:, perm]
+    for k in range(len(eigvals)):
+        vecs_new[:, k] = vecs_new[:, k] / la.norm(vecs_new[:, k])
+
+    k = 0
+    while k < len(eigvals):
+        ttol = max(tol, tol * abs(eigvals[k]))
+        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
+        if len(inds) > 1:  # if at least 2 eigvals are degenerate
+            vecs_new[:, inds] = _degen(tol, vecs_new[:, inds], ops, i+1)
+        k = inds[-1] + 1
+    return vecs_new
+
+
+def simdiag(ops, evals: bool = True, *,
+            tol: float = 1e-14, safe_mode: bool = True):
+    """Simultaneous diagonalization of commuting Hermitian matrices.
+
+    Parameters
+    ----------
+    ops : list/array
+        ``list`` or ``array`` of qobjs representing commuting Hermitian
+        operators.
+
+    evals : bool [True]
+        Whether to return the eigenvalues for each ops and eigenvectors or just
+        the eigenvectors.
+
+    tol : float [1e-14]
+        Tolerance for detecting degenerate eigenstates.
+
+    safe_mode : bool [True]
+        Whether to check that all ops are Hermitian and commuting. If set to
+        ``False`` and operators are not commuting, the eigenvectors returned
+        will often be eigenvectors of only the first operator.
+
+    Returns
+    --------
+    eigs : tuple
+        Tuple of arrays representing eigvecs and eigvals of quantum objects
+        corresponding to simultaneous eigenvectors and eigenvalues for each
+        operator.
+
+    """
+    if not ops:
+        raise ValueError("No input matrices.")
+    N = ops[0].shape[0]
+    num_ops = len(ops) if safe_mode else 0
+    for jj in range(num_ops):
+        A = ops[jj]
+        shape = A.shape
+        if shape[0] != shape[1]:
+            raise TypeError('Matricies must be square.')
+        if shape[0] != N:
+            raise TypeError('All matrices. must be the same shape')
+        if not A.isherm:
+            raise TypeError('Matricies must be Hermitian')
+        for kk in range(jj):
+            B = ops[kk]
+            if (A * B - B * A).norm() / (A * B).norm() > tol:
+                raise TypeError('Matricies must commute.')
+
+    # TODO: rewrite using Data object
+    eigvals, eigvecs = _data.eigs(ops[0].data, True, True)
+    eigvecs = eigvecs.to_array()
+
+    k = 0
+    while k < N:
+        # find degenerate eigenvalues, get indicies of degenerate eigvals
+        ttol = max(tol, tol * abs(eigvals[k]))
+        inds, = np.where(abs(eigvals - eigvals[k]) < ttol)
+        if len(inds) > 1:  # if at least 2 eigvals are degenerate
+            eigvecs[:, inds] = _degen(tol, eigvecs[:, inds], ops, 1)
+        k = inds[-1] + 1
+
+    for k in range(N):
+        eigvecs[:, k] = eigvecs[:, k] / la.norm(eigvecs[:, k])
+
+    kets_out = [
+        Qobj(eigvecs[:, j], dims=[ops[0].dims[0], [1]])
+        for j in range(N)
+    ]
+    eigvals_out = np.zeros((len(ops), N), dtype=np.float64)
+    if not evals:
+        return kets_out
+    else:
+        for kk in range(len(ops)):
+            for j in range(N):
+                eigvals_out[kk, j] = ops[kk].matrix_element(kets_out[j],
+                                                            kets_out[j]).real
+        return eigvals_out, kets_out
diff --git a/qutip/solve/_piqs.pyx b/qutip/solve/_piqs.pyx
index 4836237343..fcb614dccd 100644
--- a/qutip/solve/_piqs.pyx
+++ b/qutip/solve/_piqs.pyx
@@ -1,641 +1,641 @@
-#cython: language_level=3
-
-"""
-Cythonized code for permutationally invariant Lindbladian generation
-"""
-import numpy as np
-
-from scipy.sparse import csr_matrix, dok_matrix
-from qutip.core import Qobj
-
-cimport numpy as cnp
-cimport cython
-
-
-def _num_dicke_states(N):
-    """
-    Calculate the number of Dicke states.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    nds: int
-        The number of Dicke states.
-    """
-    if (not float(N).is_integer()):
-        raise ValueError("Number of TLS should be an integer")
-
-    if (N < 1):
-        raise ValueError("Number of TLS should be non-negative")
-
-    nds = (N/2 + 1)**2 - (N % 2)/4
-    return int(nds)
-
-def _num_dicke_ladders(N):
-    """
-    Calculate the total number of Dicke ladders in the Dicke space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    Nj: int
-        The number of Dicke ladders.
-    """
-    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
-    return int(Nj)
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef list get_blocks(int N):
-    """
-    Calculate the number of cumulative elements at each block boundary.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    blocks: np.ndarray
-        An array with the number of cumulative elements at the boundary of
-        each block.
-    """
-    cdef int num_blocks = _num_dicke_ladders(N)
-    cdef list blocks
-    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
-    return blocks
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef float j_min(N):
-    """
-    Calculate the minimum value of j for given N.
-
-    Parameters
-    ----------
-    N: int
-        Number of two-level systems.
-
-    Returns
-    -------
-    jmin: float
-        The minimum value of j for odd or even number of two
-        level systems.
-    """
-    if N % 2 == 0:
-        return 0
-    else:
-        return 0.5
-
-def j_vals(N):
-    """
-    Get the valid values of j for given N.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    jvals: np.ndarray
-        The j values for given N as a 1D array.
-    """
-    j = np.arange(j_min(N), N/2 + 1, 1)
-    return j
-
-def m_vals(j):
-    """
-    Get all the possible values of m or m1 for given j.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    mvals: np.ndarray
-        The m values for given j as a 1D array.
-    """
-    return np.arange(-j, j+1, 1)
-
-def get_index(N, j, m, m1, blocks):
-    """
-    Get the index in the density matrix for this j, m, m1 value.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    j, m, m1: float
-        The j, m, m1 values.
-
-    blocks: np.ndarray
-        An 1D array with the number of cumulative elements at the boundary of
-        each block.
-
-    Returns
-    -------
-    mvals: array
-        The m values for given j.
-    """
-    _k = int(j-m1)
-    _k_prime = int(j-m)
-    block_number = int(N/2 - j)
-    offset = 0
-    if block_number > 0:
-        offset = blocks[block_number-1]
-    i = _k_prime + offset
-    k = _k + offset
-    return (i, k)
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef list jmm1_dictionary(int N):
-    """
-    Get the index in the density matrix for this j, m, m1 value.
-
-    The (j, m, m1) values are mapped to the (i, k) index of a block
-    diagonal matrix which has the structure to capture the permutationally
-    symmetric part of the density matrix. For each (j, m, m1) value, first
-    we get the block by using the "j" value and then the addition in the
-    row/column due to the m and m1 is determined. Four dictionaries are
-    returned giving a map from the (j, m, m1) values to (i, k), the inverse
-    map, a flattened map and the inverse of the flattened map.
-    """
-    cdef long i
-    cdef long k
-    cdef dict jmm1_dict = {}
-    cdef dict jmm1_inv = {}
-    cdef dict jmm1_flat = {}
-    cdef dict jmm1_flat_inv = {}
-    cdef int l
-    cdef int nds = _num_dicke_states(N)
-    cdef list blocks = get_blocks(N)
-
-    jvalues = j_vals(N)
-    for j in jvalues:
-        mvalues = m_vals(j)
-        for m in mvalues:
-            for m1 in mvalues:
-                i, k = get_index(N, j, m, m1, blocks)
-                jmm1_dict[(i, k)] = (j, m, m1)
-                jmm1_inv[(j, m, m1)] = (i, k)
-                l = nds * i+k
-                jmm1_flat[l] = (j, m, m1)
-                jmm1_flat_inv[(j, m, m1)] = l
-    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cdef class Dicke(object):
-    """
-    A faster Cythonized Dicke state class to build the Lindbladian.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Attributes
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-    """
-    cdef int N
-    cdef float emission, dephasing, pumping
-    cdef float collective_emission, collective_dephasing, collective_pumping
-
-    def __init__(self, int N, float emission=0., float dephasing=0.,
-                 float pumping=0., float collective_emission=0.,
-                 collective_dephasing=0., collective_pumping=0.):
-        self.N = N
-        self.emission = emission
-        self.dephasing = dephasing
-        self.pumping = pumping
-        self.collective_emission = collective_emission
-        self.collective_dephasing = collective_dephasing
-        self.collective_pumping = collective_pumping
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef object lindbladian(self):
-        """
-        Build the Lindbladian superoperator of the dissipative dynamics as a
-        sparse matrix.
-
-        Returns
-        ----------
-        lindblad_qobj: :class: qutip.Qobj
-            The matrix size is (nds**2, nds**2) where nds is the number of
-            Dicke states.
-        """
-        N = self.N
-        cdef int nds = _num_dicke_states(N)
-        cdef int num_ladders = _num_dicke_ladders(N)
-
-        cdef list lindblad_row = []
-        cdef list lindblad_col = []
-        cdef list lindblad_data = []
-        cdef tuple jmm1_1
-        cdef tuple jmm1_2
-        cdef tuple jmm1_3
-        cdef tuple jmm1_4
-        cdef tuple jmm1_5
-        cdef tuple jmm1_6
-        cdef tuple jmm1_7
-        cdef tuple jmm1_8
-        cdef tuple jmm1_9
-
-        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
-
-        # perform loop in each row of matrix
-        for r in jmm1_row:
-            j, m, m1 = jmm1_row[r]
-            jmm1_1 = (j, m, m1)
-            jmm1_2 = (j, m+1, m1+1)
-            jmm1_3 = (j+1, m+1, m1+1)
-            jmm1_4 = (j-1, m+1, m1+1)
-            jmm1_5 = (j+1, m, m1)
-            jmm1_6 = (j-1, m, m1)
-            jmm1_7 = (j+1, m-1, m1-1)
-            jmm1_8 = (j, m-1, m1-1)
-            jmm1_9 = (j-1, m-1, m1-1)
-
-            g1 = self.gamma1(jmm1_1)
-            c1 = jmm1_inv[jmm1_1]
-
-            lindblad_row.append(int(r))
-            lindblad_col.append(int(c1))
-            lindblad_data.append(g1)
-
-            # generate gammas in the given row
-            # check if the gammas exist
-            # load gammas in the lindbladian in the correct position
-
-            if jmm1_2 in jmm1_inv:
-                g2 = self.gamma2(jmm1_2)
-                c2 = jmm1_inv[jmm1_2]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c2))
-                lindblad_data.append(g2)
-
-            if jmm1_3 in jmm1_inv:
-                g3 = self.gamma3(jmm1_3)
-                c3 = jmm1_inv[jmm1_3]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c3))
-                lindblad_data.append(g3)
-
-            if jmm1_4 in jmm1_inv:
-                g4 = self.gamma4(jmm1_4)
-                c4 = jmm1_inv[jmm1_4]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c4))
-                lindblad_data.append(g4)
-
-            if jmm1_5 in jmm1_inv:
-                g5 = self.gamma5(jmm1_5)
-                c5 = jmm1_inv[jmm1_5]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c5))
-                lindblad_data.append(g5)
-
-            if jmm1_6 in jmm1_inv:
-                g6 = self.gamma6(jmm1_6)
-                c6 = jmm1_inv[jmm1_6]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c6))
-                lindblad_data.append(g6)
-
-            if jmm1_7 in jmm1_inv:
-                g7 = self.gamma7(jmm1_7)
-                c7 = jmm1_inv[jmm1_7]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c7))
-                lindblad_data.append(g7)
-
-            if jmm1_8 in jmm1_inv:
-                g8 = self.gamma8(jmm1_8)
-                c8 = jmm1_inv[jmm1_8]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c8))
-                lindblad_data.append(g8)
-
-            if jmm1_9 in jmm1_inv:
-                g9 = self.gamma9(jmm1_9)
-                c9 = jmm1_inv[jmm1_9]
-
-                lindblad_row.append(int(r))
-                lindblad_col.append(int(c9))
-                lindblad_data.append(g9)
-
-        cdef lindblad_matrix = csr_matrix((lindblad_data,
-                                          (lindblad_row, lindblad_col)),
-                                          shape=(nds**2, nds**2),
-                                          dtype=np.complex128)
-
-        # make matrix a Qobj superoperator with expected dims
-        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
-        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
-        return lindblad_qobj
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma1(self, tuple jmm1):
-        """
-        Calculate gamma1 for value of j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yCE, yE, yD, yP, yCP, yCD
-        cdef float N
-        cdef float spontaneous, losses, pump, collective_pump
-        cdef float dephase, collective_dephase, g1
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-
-        yE = self.emission
-        yD = self.dephasing
-        yP = self.pumping
-        yCE = self.collective_emission
-        yCP = self.collective_pumping
-        yCD = self.collective_dephasing
-
-        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
-        losses = (yE/2) * (N+m+m1)
-        pump = yP/2 * (N-m-m1)
-        collective_pump = yCP/2 * \
-            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
-        collective_dephase = yCD/2 * (m-m1)**2
-
-        if j <= 0:
-            dephase = yD*N/4
-        else:
-            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
-
-        g1 = spontaneous + losses + pump + dephase + \
-            collective_pump + collective_dephase
-
-        return -g1
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma2(self, tuple jmm1):
-        """
-        Calculate gamma2 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yCE, yE, yD, yP, yCP, yCD, g2
-        cdef float N
-        cdef float spontaneous, losses, pump, collective_pump
-        cdef float dephase, collective_dephase
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yCE = self.collective_emission
-        yE = self.emission
-
-        if yCE == 0:
-            spontaneous = 0.0
-        else:
-            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
-
-        if (yE == 0) or (j <= 0):
-            losses = 0.0
-        else:
-            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
-                                                      (N/2 + 1)/(j*(j+1))
-        g2 = spontaneous + losses
-        return g2
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma3(self, tuple jmm1):
-        """
-        Calculate gamma3 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yE
-        cdef float N
-        cdef float spontaneous, losses, pump, collective_pump
-        cdef float dephase, collective_dephase
-
-        cdef complex g3
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yE = self.emission
-
-        if (yE == 0) or (j <= 0):
-            g3 = 0.0
-        else:
-            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
-                 (N/2 + j+1)/(j*(2*j + 1))
-        return g3
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma4(self, tuple jmm1):
-        """
-        Calculate gamma4 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef complex g4
-        cdef float yE
-        cdef float N
-
-        N = float(self.N)
-        j, m, m1 = jmm1
-        yE = self.emission
-        if (yE == 0) or ((j+1) <= 0):
-            g4 = 0.0
-        else:
-            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
-                                (j-m1+2)) * (N/2 - j)/((j+1) *
-                                                       (2*j + 1))
-        return g4
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma5(self, tuple jmm1):
-        """
-        Calculate gamma5 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef complex g5
-        j, m, m1 = jmm1
-        cdef float yD
-        cdef float N
-
-        N = float(self.N)
-        yD = self.dephasing
-
-        if (yD == 0) or (j <= 0):
-            g5 = 0.0
-        else:
-            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
-                (N/2 + j + 1)/(j*(2*j + 1))
-
-        return g5
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma6(self, tuple jmm1):
-        """
-        Calculate gamma6 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yD
-        cdef float N
-        cdef complex g6
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-
-        yD = self.dephasing
-        if yD == 0:
-            g6 = 0.0
-        else:
-            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
-                                                   2-m1**2)) * \
-                                                   (N/2 - j)/((j+1) * (2*j+1))
-        return g6
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma7(self, tuple jmm1):
-        """
-        Calculate gamma7 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yP
-        cdef float N
-        cdef complex g7
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yP = self.pumping
-
-        if (yP == 0) or (j <= 0):
-            g7 = 0.0
-        else:
-            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
-                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
-        return g7
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma8(self, tuple jmm1):
-        """
-        Calculate gamma8 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yP, yCP
-        cdef float N
-        cdef complex g8
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yP = self.pumping
-        yCP = self.collective_pumping
-        if (yP == 0) or (j <= 0):
-            pump = 0.0
-        else:
-            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
-                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
-        if yCP == 0:
-            collective_pump = 0.0
-        else:
-            collective_pump = yCP * \
-                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
-        g8 = pump + collective_pump
-        return g8
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cpdef complex gamma9(self, tuple jmm1):
-        """
-        Calculate gamma9 for given j, m, m'.
-        """
-        cdef float j, m, m1
-        cdef float yP
-        cdef float N
-        cdef complex g9
-
-        j, m, m1 = jmm1
-        N = float(self.N)
-        yP = self.pumping
-
-        if (yP == 0):
-            g9 = 0.0
-        else:
-            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
-                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
-        return g9
+#cython: language_level=3
+
+"""
+Cythonized code for permutationally invariant Lindbladian generation
+"""
+import numpy as np
+
+from scipy.sparse import csr_matrix, dok_matrix
+from qutip.core import Qobj
+
+cimport numpy as cnp
+cimport cython
+
+
+def _num_dicke_states(N):
+    """
+    Calculate the number of Dicke states.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    nds: int
+        The number of Dicke states.
+    """
+    if (not float(N).is_integer()):
+        raise ValueError("Number of TLS should be an integer")
+
+    if (N < 1):
+        raise ValueError("Number of TLS should be non-negative")
+
+    nds = (N/2 + 1)**2 - (N % 2)/4
+    return int(nds)
+
+def _num_dicke_ladders(N):
+    """
+    Calculate the total number of Dicke ladders in the Dicke space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    Nj: int
+        The number of Dicke ladders.
+    """
+    Nj = (N+1) * 0.5 + (1-np.mod(N, 2)) * 0.5
+    return int(Nj)
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef list get_blocks(int N):
+    """
+    Calculate the number of cumulative elements at each block boundary.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    blocks: np.ndarray
+        An array with the number of cumulative elements at the boundary of
+        each block.
+    """
+    cdef int num_blocks = _num_dicke_ladders(N)
+    cdef list blocks
+    blocks = [i * (N+2-i) for i in range(1, num_blocks+1)]
+    return blocks
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef float j_min(N):
+    """
+    Calculate the minimum value of j for given N.
+
+    Parameters
+    ----------
+    N: int
+        Number of two-level systems.
+
+    Returns
+    -------
+    jmin: float
+        The minimum value of j for odd or even number of two
+        level systems.
+    """
+    if N % 2 == 0:
+        return 0
+    else:
+        return 0.5
+
+def j_vals(N):
+    """
+    Get the valid values of j for given N.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    jvals: np.ndarray
+        The j values for given N as a 1D array.
+    """
+    j = np.arange(j_min(N), N/2 + 1, 1)
+    return j
+
+def m_vals(j):
+    """
+    Get all the possible values of m or m1 for given j.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    mvals: np.ndarray
+        The m values for given j as a 1D array.
+    """
+    return np.arange(-j, j+1, 1)
+
+def get_index(N, j, m, m1, blocks):
+    """
+    Get the index in the density matrix for this j, m, m1 value.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    j, m, m1: float
+        The j, m, m1 values.
+
+    blocks: np.ndarray
+        An 1D array with the number of cumulative elements at the boundary of
+        each block.
+
+    Returns
+    -------
+    mvals: array
+        The m values for given j.
+    """
+    _k = int(j-m1)
+    _k_prime = int(j-m)
+    block_number = int(N/2 - j)
+    offset = 0
+    if block_number > 0:
+        offset = blocks[block_number-1]
+    i = _k_prime + offset
+    k = _k + offset
+    return (i, k)
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef list jmm1_dictionary(int N):
+    """
+    Get the index in the density matrix for this j, m, m1 value.
+
+    The (j, m, m1) values are mapped to the (i, k) index of a block
+    diagonal matrix which has the structure to capture the permutationally
+    symmetric part of the density matrix. For each (j, m, m1) value, first
+    we get the block by using the "j" value and then the addition in the
+    row/column due to the m and m1 is determined. Four dictionaries are
+    returned giving a map from the (j, m, m1) values to (i, k), the inverse
+    map, a flattened map and the inverse of the flattened map.
+    """
+    cdef long i
+    cdef long k
+    cdef dict jmm1_dict = {}
+    cdef dict jmm1_inv = {}
+    cdef dict jmm1_flat = {}
+    cdef dict jmm1_flat_inv = {}
+    cdef int l
+    cdef int nds = _num_dicke_states(N)
+    cdef list blocks = get_blocks(N)
+
+    jvalues = j_vals(N)
+    for j in jvalues:
+        mvalues = m_vals(j)
+        for m in mvalues:
+            for m1 in mvalues:
+                i, k = get_index(N, j, m, m1, blocks)
+                jmm1_dict[(i, k)] = (j, m, m1)
+                jmm1_inv[(j, m, m1)] = (i, k)
+                l = nds * i+k
+                jmm1_flat[l] = (j, m, m1)
+                jmm1_flat_inv[(j, m, m1)] = l
+    return [jmm1_dict, jmm1_inv, jmm1_flat, jmm1_flat_inv]
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef class Dicke(object):
+    """
+    A faster Cythonized Dicke state class to build the Lindbladian.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Attributes
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+    """
+    cdef int N
+    cdef float emission, dephasing, pumping
+    cdef float collective_emission, collective_dephasing, collective_pumping
+
+    def __init__(self, int N, float emission=0., float dephasing=0.,
+                 float pumping=0., float collective_emission=0.,
+                 collective_dephasing=0., collective_pumping=0.):
+        self.N = N
+        self.emission = emission
+        self.dephasing = dephasing
+        self.pumping = pumping
+        self.collective_emission = collective_emission
+        self.collective_dephasing = collective_dephasing
+        self.collective_pumping = collective_pumping
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef object lindbladian(self):
+        """
+        Build the Lindbladian superoperator of the dissipative dynamics as a
+        sparse matrix.
+
+        Returns
+        ----------
+        lindblad_qobj: :class: qutip.Qobj
+            The matrix size is (nds**2, nds**2) where nds is the number of
+            Dicke states.
+        """
+        N = self.N
+        cdef int nds = _num_dicke_states(N)
+        cdef int num_ladders = _num_dicke_ladders(N)
+
+        cdef list lindblad_row = []
+        cdef list lindblad_col = []
+        cdef list lindblad_data = []
+        cdef tuple jmm1_1
+        cdef tuple jmm1_2
+        cdef tuple jmm1_3
+        cdef tuple jmm1_4
+        cdef tuple jmm1_5
+        cdef tuple jmm1_6
+        cdef tuple jmm1_7
+        cdef tuple jmm1_8
+        cdef tuple jmm1_9
+
+        _1, _2, jmm1_row, jmm1_inv = jmm1_dictionary(N)
+
+        # perform loop in each row of matrix
+        for r in jmm1_row:
+            j, m, m1 = jmm1_row[r]
+            jmm1_1 = (j, m, m1)
+            jmm1_2 = (j, m+1, m1+1)
+            jmm1_3 = (j+1, m+1, m1+1)
+            jmm1_4 = (j-1, m+1, m1+1)
+            jmm1_5 = (j+1, m, m1)
+            jmm1_6 = (j-1, m, m1)
+            jmm1_7 = (j+1, m-1, m1-1)
+            jmm1_8 = (j, m-1, m1-1)
+            jmm1_9 = (j-1, m-1, m1-1)
+
+            g1 = self.gamma1(jmm1_1)
+            c1 = jmm1_inv[jmm1_1]
+
+            lindblad_row.append(int(r))
+            lindblad_col.append(int(c1))
+            lindblad_data.append(g1)
+
+            # generate gammas in the given row
+            # check if the gammas exist
+            # load gammas in the lindbladian in the correct position
+
+            if jmm1_2 in jmm1_inv:
+                g2 = self.gamma2(jmm1_2)
+                c2 = jmm1_inv[jmm1_2]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c2))
+                lindblad_data.append(g2)
+
+            if jmm1_3 in jmm1_inv:
+                g3 = self.gamma3(jmm1_3)
+                c3 = jmm1_inv[jmm1_3]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c3))
+                lindblad_data.append(g3)
+
+            if jmm1_4 in jmm1_inv:
+                g4 = self.gamma4(jmm1_4)
+                c4 = jmm1_inv[jmm1_4]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c4))
+                lindblad_data.append(g4)
+
+            if jmm1_5 in jmm1_inv:
+                g5 = self.gamma5(jmm1_5)
+                c5 = jmm1_inv[jmm1_5]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c5))
+                lindblad_data.append(g5)
+
+            if jmm1_6 in jmm1_inv:
+                g6 = self.gamma6(jmm1_6)
+                c6 = jmm1_inv[jmm1_6]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c6))
+                lindblad_data.append(g6)
+
+            if jmm1_7 in jmm1_inv:
+                g7 = self.gamma7(jmm1_7)
+                c7 = jmm1_inv[jmm1_7]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c7))
+                lindblad_data.append(g7)
+
+            if jmm1_8 in jmm1_inv:
+                g8 = self.gamma8(jmm1_8)
+                c8 = jmm1_inv[jmm1_8]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c8))
+                lindblad_data.append(g8)
+
+            if jmm1_9 in jmm1_inv:
+                g9 = self.gamma9(jmm1_9)
+                c9 = jmm1_inv[jmm1_9]
+
+                lindblad_row.append(int(r))
+                lindblad_col.append(int(c9))
+                lindblad_data.append(g9)
+
+        cdef lindblad_matrix = csr_matrix((lindblad_data,
+                                          (lindblad_row, lindblad_col)),
+                                          shape=(nds**2, nds**2),
+                                          dtype=np.complex128)
+
+        # make matrix a Qobj superoperator with expected dims
+        llind_dims = [[[nds], [nds]], [[nds], [nds]]]
+        cdef object lindblad_qobj = Qobj(lindblad_matrix, dims=llind_dims)
+        return lindblad_qobj
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma1(self, tuple jmm1):
+        """
+        Calculate gamma1 for value of j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yCE, yE, yD, yP, yCP, yCD
+        cdef float N
+        cdef float spontaneous, losses, pump, collective_pump
+        cdef float dephase, collective_dephase, g1
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+
+        yE = self.emission
+        yD = self.dephasing
+        yP = self.pumping
+        yCE = self.collective_emission
+        yCP = self.collective_pumping
+        yCD = self.collective_dephasing
+
+        spontaneous = yCE/2 * (2*j*(j+1) - m * (m-1) - m1 * (m1 - 1))
+        losses = (yE/2) * (N+m+m1)
+        pump = yP/2 * (N-m-m1)
+        collective_pump = yCP/2 * \
+            (2*j * (j+1) - m*(m+1) - m1*(m1+1))
+        collective_dephase = yCD/2 * (m-m1)**2
+
+        if j <= 0:
+            dephase = yD*N/4
+        else:
+            dephase = yD/2*(N/2 - m*m1 * (N/2 + 1)/j/(j+1))
+
+        g1 = spontaneous + losses + pump + dephase + \
+            collective_pump + collective_dephase
+
+        return -g1
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma2(self, tuple jmm1):
+        """
+        Calculate gamma2 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yCE, yE, yD, yP, yCP, yCD, g2
+        cdef float N
+        cdef float spontaneous, losses, pump, collective_pump
+        cdef float dephase, collective_dephase
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yCE = self.collective_emission
+        yE = self.emission
+
+        if yCE == 0:
+            spontaneous = 0.0
+        else:
+            spontaneous = yCE * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1))
+
+        if (yE == 0) or (j <= 0):
+            losses = 0.0
+        else:
+            losses = yE/2 * np.sqrt((j+m) * (j-m+1) * (j+m1) * (j-m1+1)) * \
+                                                      (N/2 + 1)/(j*(j+1))
+        g2 = spontaneous + losses
+        return g2
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma3(self, tuple jmm1):
+        """
+        Calculate gamma3 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yE
+        cdef float N
+        cdef float spontaneous, losses, pump, collective_pump
+        cdef float dephase, collective_dephase
+
+        cdef complex g3
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yE = self.emission
+
+        if (yE == 0) or (j <= 0):
+            g3 = 0.0
+        else:
+            g3 = yE/2 * np.sqrt((j+m) * (j+m-1) * (j+m1) * (j+m1-1)) * \
+                 (N/2 + j+1)/(j*(2*j + 1))
+        return g3
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma4(self, tuple jmm1):
+        """
+        Calculate gamma4 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef complex g4
+        cdef float yE
+        cdef float N
+
+        N = float(self.N)
+        j, m, m1 = jmm1
+        yE = self.emission
+        if (yE == 0) or ((j+1) <= 0):
+            g4 = 0.0
+        else:
+            g4 = yE/2 * np.sqrt((j-m+1) * (j-m+2) * (j-m1+1) *
+                                (j-m1+2)) * (N/2 - j)/((j+1) *
+                                                       (2*j + 1))
+        return g4
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma5(self, tuple jmm1):
+        """
+        Calculate gamma5 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef complex g5
+        j, m, m1 = jmm1
+        cdef float yD
+        cdef float N
+
+        N = float(self.N)
+        yD = self.dephasing
+
+        if (yD == 0) or (j <= 0):
+            g5 = 0.0
+        else:
+            g5 = yD/2 * np.sqrt((j**2 - m**2)*(j**2 - m1**2)) * \
+                (N/2 + j + 1)/(j*(2*j + 1))
+
+        return g5
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma6(self, tuple jmm1):
+        """
+        Calculate gamma6 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yD
+        cdef float N
+        cdef complex g6
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+
+        yD = self.dephasing
+        if yD == 0:
+            g6 = 0.0
+        else:
+            g6 = yD/2 * np.sqrt(((j+1)**2 - m**2)*((j+1) **
+                                                   2-m1**2)) * \
+                                                   (N/2 - j)/((j+1) * (2*j+1))
+        return g6
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma7(self, tuple jmm1):
+        """
+        Calculate gamma7 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yP
+        cdef float N
+        cdef complex g7
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yP = self.pumping
+
+        if (yP == 0) or (j <= 0):
+            g7 = 0.0
+        else:
+            g7 = yP/2 * np.sqrt((j-m-1)*(j-m)*(j-m1-1) *
+                                (j-m1)) * (N/2 + j + 1)/(j * (2*j+1))
+        return g7
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma8(self, tuple jmm1):
+        """
+        Calculate gamma8 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yP, yCP
+        cdef float N
+        cdef complex g8
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yP = self.pumping
+        yCP = self.collective_pumping
+        if (yP == 0) or (j <= 0):
+            pump = 0.0
+        else:
+            pump = yP/2 * np.sqrt((j+m+1) * (j-m) * (j+m1+1) *
+                                  (j-m1)) * (N/2 + 1)/(j*(j+1))
+        if yCP == 0:
+            collective_pump = 0.0
+        else:
+            collective_pump = yCP * \
+                np.sqrt((j-m) * (j+m+1) * (j+m1+1) * (j-m1))
+        g8 = pump + collective_pump
+        return g8
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cpdef complex gamma9(self, tuple jmm1):
+        """
+        Calculate gamma9 for given j, m, m'.
+        """
+        cdef float j, m, m1
+        cdef float yP
+        cdef float N
+        cdef complex g9
+
+        j, m, m1 = jmm1
+        N = float(self.N)
+        yP = self.pumping
+
+        if (yP == 0):
+            g9 = 0.0
+        else:
+            g9 = yP/2 * np.sqrt((j+m+1) * (j+m+2) * (j+m1+1) *
+                                (j+m1+2)) * (N/2 - j)/((j+1) * (2*j+1))
+        return g9
diff --git a/qutip/solve/_stochastic.pyx b/qutip/solve/_stochastic.pyx
index 4257fb2b86..91799251bf 100644
--- a/qutip/solve/_stochastic.pyx
+++ b/qutip/solve/_stochastic.pyx
@@ -1,2345 +1,2345 @@
-#cython: language_level=3
-
-import numpy as np
-cimport numpy as np
-cimport cython
-from cpython.exc cimport PyErr_CheckSignals
-from libc.math cimport fabs
-from qutip.core.cy.qobjevo cimport QobjEvo
-from .. import Qobj, unstack_columns
-import scipy.sparse as sp
-from scipy.sparse.linalg import LinearOperator
-from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
-from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
-
-from qutip.core.data cimport dense, Dense
-import qutip.core.data as _data
-
-cdef extern from "<complex>" namespace "std" nogil:
-    double complex conj(double complex x)
-
-cdef int ZERO=0
-cdef double DZERO=0
-cdef complex ZZERO=0j
-cdef int ONE=1
-
-"""Some of blas wrapper"""
-@cython.boundscheck(False)
-cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
-    """ y += a*x"""
-    cdef int l = x.shape[0]
-    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void copy(complex[::1] x, complex[::1] y):
-    """ y = x """
-    cdef int l = x.shape[0]
-    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef complex _dot(complex[::1] x, complex[::1] y):
-    """ = x_i * y_i """
-    cdef int l = x.shape[0]
-    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef complex _dotc(complex[::1] x, complex[::1] y):
-    """ = conj(x_i) * y_i """
-    cdef int l = x.shape[0]
-    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
-
-@cython.boundscheck(False)
-cdef double _dznrm2(complex[::1] vec):
-    """ = sqrt( x_i**2 ) """
-    cdef int l = vec.shape[0]
-    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _scale(double a, complex[::1] x):
-    """ x *= a """
-    cdef int l = x.shape[0]
-    zdscal(&l, &a, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zscale(complex a, complex[::1] x):
-    """ x *= a """
-    cdef int l = x.shape[0]
-    zscal(&l, &a, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero(complex[::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]
-    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero_2d(complex[:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]
-    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero_3d(complex[:,:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
-    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
-
-@cython.boundscheck(False)
-cdef void _zero_4d(complex[:,:,:,::1] x):
-    """ x *= 0 """
-    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
-    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
-
-@cython.boundscheck(False)
-@cython.initializedcheck(False)
-cdef Dense _dense_wrap(double complex [::1] x):
-    return dense.wrap(&x[0], x.shape[0], 1)
-
-# %%%%%%%%%%%%%%%%%%%%%%%%%
-# functions for ensuring that the states stay physical
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cdef void _normalize_inplace(complex[::1] vec):
-    """ make norm of vec equal to 1"""
-    cdef int l = vec.shape[0]
-    cdef double norm = 1.0/_dznrm2(vec)
-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-
-# to move eventually, 10x faster than scipy's norm.
-@cython.cdivision(True)
-@cython.boundscheck(False)
-def normalize_inplace(complex[::1] vec):
-    """ make norm of vec equal to 1"""
-    cdef int l = vec.shape[0]
-    cdef double norm = 1.0/_dznrm2(vec)
-    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
-    return fabs(norm-1)
-
-@cython.cdivision(True)
-@cython.boundscheck(False)
-cdef void _normalize_rho(complex[::1] rho):
-    """ Ensure that the density matrix trace is one and
-    that the composing states are normalized.
-    """
-    cdef int l = rho.shape[0]
-    cdef int N = np.sqrt(l)
-    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
-    cdef complex[::1,:] eivec
-    cdef double[::1] eival = np.zeros(N)
-    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
-
-    _zero(rho)
-    cdef int i, j, k
-    cdef double sum
-
-    sum = 0.
-    for i in range(N):
-        _normalize_inplace(eivec[:,i])
-        if eival[i] < 0:
-            eival[i] = 0.
-        sum += eival[i]
-    if sum != 1.:
-        for i in range(N):
-            eival[i] /= sum
-
-    for i in range(N):
-        for j in range(N):
-            for k in range(N):
-                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
-
-# Available solvers:
-cpdef enum Solvers:
-  # order 0.5
-  EULER_SOLVER           =  50
-  # order 0.5 strong, 1.0 weak?
-  PC_SOLVER              = 101
-  PC_2_SOLVER            = 104
-  # order 1.0
-  PLATEN_SOLVER          = 100
-  MILSTEIN_SOLVER        = 102
-  MILSTEIN_IMP_SOLVER    = 103
-  # order 1.5
-  EXPLICIT1_5_SOLVER     = 150
-  TAYLOR1_5_SOLVER       = 152
-  TAYLOR1_5_IMP_SOLVER   = 153
-  # order 2.0
-  TAYLOR2_0_SOLVER       = 202
-
-  # Special solvers
-  PHOTOCURRENT_SOLVER    =  60
-  PHOTOCURRENT_PC_SOLVER = 110
-  ROUCHON_SOLVER         = 120
-
-  # For initialisation
-  SOLVER_NOT_SET         =   0
-
-
-cdef class TaylorNoise:
-    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
-    Complex enough that I fell it should be kept separated from the main solver.
-    """
-    cdef:
-      int p
-      double rho, alpha
-      double aFactor, bFactor
-      double BFactor, CFactor
-      double dt, dt_sqrt
-
-    @cython.cdivision(True)
-    def __init__(self, int p, double dt):
-        self.p = p
-        self.dt = dt
-        self.dt_sqrt = dt**.5
-        cdef double pi = np.pi
-        cdef int i
-
-        cdef double rho = 0.
-        for i in range(1,p+1):
-            rho += (i+0.)**-2
-        rho = 1./3.-2*rho/(pi**2)
-        self.rho = (rho)**.5
-        self.aFactor = -(2)**.5/pi
-
-        cdef double alpha = 0.
-        for i in range(1,p+1):
-            alpha += (i+0.)**-4
-        alpha = pi/180-alpha/(2*pi**2)/pi
-        self.alpha = (alpha)**.5
-        self.bFactor = (0.5)**.5/pi**2
-
-        self.BFactor = 1/(4*pi**2)
-        self.CFactor = -1/(2*pi**2)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cpdef void order2(self, double[::1] noise, double[::1] dws):
-        cdef int p = self.p
-        cdef int r, l
-        cdef double s = 1/6.
-        cdef double a = 0
-        cdef double b = 0
-        cdef double AA = 0
-        cdef double BB = 0
-        cdef double CC = 0
-
-        for r in range(p):
-            a += noise[3+r]/(r+1.)
-            b += noise[3+r+p]/(r+1.)/(r+1.)
-            BB += (1/(r+1.)/(r+1.)) *\
-                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
-            for l in range(p):
-                if r != l:
-                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
-                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
-                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
-
-        a = self.aFactor * a + self.rho * noise[1]
-        b = self.bFactor * b + self.alpha * noise[2]
-        AA = 0.25*a*a
-        BB *= self.BFactor
-        CC *= self.CFactor
-
-        dws[0] = noise[0]                       # dw
-        dws[1] = 0.5*(noise[0]+a)               # dz
-        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
-        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
-        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
-
-
-cdef class StochasticSolver:
-    """ stochastic solver class base
-    Does most of the initialisation, drive the simulation and contain the
-    stochastic integration algorythm that do not depend on the physics.
-
-    This class is not to be used as is, the function computing the evolution's
-    derivative are specified in it's child class which define the deterministic
-    and stochastic contributions.
-
-    PYTHON METHODS:
-    set_solver:
-      Receive the data for the integration.
-      Prepare buffers
-
-    cy_sesolve_single_trajectory:
-      Run one trajectory.
-
-
-    INTERNAL METHODS
-    make_noise:
-      create the stochastic noise
-    run:
-      evolution between timestep (substep)
-    solver's method:
-      stochastic integration algorithm
-        euler
-        milstein
-        taylor
-        ...
-
-    CHILD:
-    SSESolver: stochastic schrodinger evolution
-    SMESolver: stochastic master evolution
-    PcSSESolver: photocurrent stochastic schrodinger evolution
-    PcSMESolver: photocurrent stochastic master evolution
-    PmSMESolver: positive map stochastic master evolution
-    GenericSSolver: general (user defined) stochastic evolution
-
-    CHILD METHODS:
-    set_data:
-      Read data about the system
-    d1:
-      deterministic part
-    d2:
-      non-deterministic part
-    derivatives:
-      d1, d2 and their derivatives up to dt**1.5
-      multiple sc_ops
-    derivativesO2:
-      d1, d2 and there derivatives up to dt**2.0
-      one sc_ops
-    """
-    cdef int l_vec, num_ops
-    cdef Solvers solver
-    cdef int num_step, num_substeps, num_dw
-    cdef int normalize
-    cdef double dt
-    cdef int noise_type
-    cdef object custom_noise
-    cdef double[::1] dW_factor
-    cdef unsigned int[::1] seed
-    cdef object sso
-
-    # buffer to not redo the initialisation at each substep
-    cdef complex[:, ::1] buffer_1d
-    cdef complex[:, :, ::1] buffer_2d
-    cdef complex[:, :, :, ::1] buffer_3d
-    cdef complex[:, :, :, ::1] buffer_4d
-    cdef complex[:, ::1] expect_buffer_1d
-    cdef complex[:, ::1] expect_buffer_2d
-    cdef complex[:, :, ::1] expect_buffer_3d
-    cdef complex[:, ::1] func_buffer_1d
-    cdef complex[:, ::1] func_buffer_2d
-    cdef complex[:, :, ::1] func_buffer_3d
-
-    cdef TaylorNoise order2noise
-
-    def __init__(self):
-        self.l_vec = 0
-        self.num_ops = 0
-        self.solver = SOLVER_NOT_SET
-
-    def set_solver(self, sso):
-        """ Prepare the solver from the info in StochasticSolverOptions
-
-        Parameters
-        ----------
-        sso : StochasticSolverOptions
-            Data of the stochastic system
-        """
-        self.set_data(sso)
-        self.sso = sso
-
-        self.solver = sso.solver_code
-        self.dt = sso.dt
-        self.num_substeps = sso.nsubsteps
-        self.normalize = sso.normalize
-        self.num_step = len(sso.times)
-        self.num_dw = len(sso.sops)
-        if self.solver in [EXPLICIT1_5_SOLVER,
-                           TAYLOR1_5_SOLVER,
-                           TAYLOR1_5_IMP_SOLVER]:
-            self.num_dw *= 2
-        if self.solver in [TAYLOR2_0_SOLVER]:
-            self.num_dw *= 3 + 2*sso.p
-            self.order2noise = TaylorNoise(sso.p, self.dt)
-        # prepare buffers for the solvers
-        nb_solver = [0,0,0,0]
-        nb_func = [0,0,0]
-        nb_expect = [0,0,0]
-
-        # %%%%%%%%%%%%%%%%%%%%%%%%%
-        # Depending on the solver, determine the numbers of buffers of each
-        # shape to prepare. (~30% slower when not preallocating buffer)
-        # nb_solver : buffer to contain the states used by solver
-        # nb_func : buffer for states used used by d1, d2 and derivative functions
-        # nb_expect : buffer to store expectation values.
-        if self.solver is EULER_SOLVER:
-            nb_solver = [0,1,0,0]
-        elif self.solver is PHOTOCURRENT_SOLVER:
-            nb_solver = [1,0,0,0]
-            nb_func = [1,0,0]
-        elif self.solver is PLATEN_SOLVER:
-            nb_solver = [2,5,0,0]
-        elif self.solver is PC_SOLVER:
-            nb_solver = [4,1,1,0]
-        elif self.solver is MILSTEIN_SOLVER:
-            nb_solver = [0,1,1,0]
-        elif self.solver is MILSTEIN_IMP_SOLVER:
-            nb_solver = [1,1,1,0]
-        elif self.solver is PC_2_SOLVER:
-            nb_solver = [5,1,1,0]
-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-            nb_solver = [1,1,0,0]
-            nb_func = [1,0,0]
-        elif self.solver is ROUCHON_SOLVER:
-            nb_solver = [2,0,0,0]
-        elif self.solver is EXPLICIT1_5_SOLVER:
-            nb_solver = [5,8,3,0]
-        elif self.solver is TAYLOR1_5_SOLVER:
-            nb_solver = [2,3,1,1]
-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-            nb_solver = [2,3,1,1]
-        elif self.solver is TAYLOR2_0_SOLVER:
-            nb_solver = [11,0,0,0]
-
-        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
-                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-          if sso.me:
-            nb_func = [1,0,0]
-            nb_expect = [1,1,0]
-          else:
-            nb_func = [2,1,1]
-            nb_expect = [2,1,1]
-        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
-            nb_expect = [1,0,0]
-        elif self.solver is TAYLOR2_0_SOLVER:
-          if sso.me:
-            nb_func = [2,0,0]
-            nb_expect = [2,0,0]
-          else:
-            nb_func = [14,0,0]
-            nb_expect = [0,0,0]
-        elif self.solver is ROUCHON_SOLVER:
-            nb_expect = [1,0,0]
-        else:
-          if not sso.me:
-            nb_func = [1,0,0]
-
-        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
-        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
-                                  dtype=complex)
-        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
-                                        dtype=complex)
-        if nb_solver[3]:
-          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
-                                        dtype=complex)
-
-        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
-        if nb_expect[1]:
-          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
-        if nb_expect[2]:
-          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
-
-        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
-        if nb_func[1]:
-          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
-        if nb_func[2]:
-          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
-
-        self.noise_type = sso.noise_type
-        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
-        if self.noise_type == 1:
-            self.custom_noise = sso.noise
-        elif self.noise_type == 0:
-            self.seed = sso.noise
-
-    def set_data(self, sso):
-        """Set solver specific operator"""
-        pass
-
-    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
-        """Create the random numbers for the stochastic process"""
-        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
-            # photocurrent, just seed,
-            np.random.seed(self.seed[n])
-            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
-        if self.noise_type == 0:
-            np.random.seed(self.seed[n])
-            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
-                                   np.sqrt(self.dt)
-        elif self.noise_type == 1:
-            return self.custom_noise[n,:,:,:]
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    def cy_sesolve_single_trajectory(self, int n):
-        """ Run the one of the trajectories of the stochastic system.
-
-        Parameters
-        ----------
-        n : int
-            Number of the iterations
-
-        sso : StochasticSolverOptions
-            Data of the stochastic system
-
-        Returns
-        -------
-        states_list : list of qobj
-            State of the system at each time
-
-        noise : array
-            noise at each step of the solver
-
-        measurements : array
-            measurements value at each timestep for each m_ops
-
-        expect : array
-            expectation value at each timestep for each e_ops
-
-        """
-        sso = self.sso
-        cdef double[::1] times = sso.times
-        cdef complex[::1] rho_t
-        cdef double t
-        cdef int m_idx, t_idx, e_idx
-        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
-        cdef int tlast = times.shape[0]
-
-        rho_t = sso.rho0.copy()
-        dims = sso.state0.dims
-
-        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
-        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
-        states_list = []
-        for t_idx, t in enumerate(times):
-            PyErr_CheckSignals()
-            if sso.ce_ops:
-                for e_idx, e in enumerate(sso.ce_ops):
-                    s = e.expect_data(t, _dense_wrap(rho_t))
-                    expect[e_idx, t_idx] = s
-            if sso.store_states or not sso.ce_ops:
-                if sso.me:
-                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
-                        dims=dims))
-                else:
-                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
-
-            if t_idx != tlast-1:
-                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
-                                 rho_t, self.num_substeps)
-
-            if sso.store_measurement:
-                for m_idx, m in enumerate(sso.cm_ops):
-                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
-                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
-                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
-
-        if sso.method == 'heterodyne':
-            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
-
-        return states_list, noise, measurements, expect
-
-    @cython.boundscheck(False)
-    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
-                          complex[::1] vec, int num_substeps):
-        """ Do one time full step"""
-        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
-        cdef int i
-        if self.solver is EULER_SOLVER:
-            for i in range(num_substeps):
-                self.euler(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PHOTOCURRENT_SOLVER:
-            for i in range(num_substeps):
-                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PLATEN_SOLVER:
-            for i in range(num_substeps):
-                self.platen(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PC_SOLVER:
-            for i in range(num_substeps):
-                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is MILSTEIN_SOLVER:
-            for i in range(num_substeps):
-                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is MILSTEIN_IMP_SOLVER:
-            for i in range(num_substeps):
-                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PC_2_SOLVER:
-            for i in range(num_substeps):
-                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is PHOTOCURRENT_PC_SOLVER:
-            for i in range(num_substeps):
-                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is ROUCHON_SOLVER:
-            for i in range(num_substeps):
-                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is EXPLICIT1_5_SOLVER:
-            for i in range(num_substeps):
-                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR1_5_SOLVER:
-            for i in range(num_substeps):
-                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR1_5_IMP_SOLVER:
-            for i in range(num_substeps):
-                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        elif self.solver is TAYLOR2_0_SOLVER:
-            for i in range(num_substeps):
-                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
-                out, vec = vec, out
-
-        if self.normalize:
-            self._normalize_inplace(vec)
-        return vec
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_inplace(vec)
-
-    # Dummy functions
-    # Needed for compilation since ssesolve is not stand-alone
-    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
-        """ deterministic part of the evolution
-        depend on schrodinger vs master vs photocurrent
-        """
-        pass
-
-    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
-        """ stochastic part of the evolution
-        depend on schrodinger vs master vs photocurrent
-        """
-        pass
-
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
-        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
-        pass
-
-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
-                              complex[::1] a, complex[:, ::1] b,
-                              complex[:, :, ::1] Lb, complex[:,::1] La,
-                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                              complex[::1] L0a):
-        """ Obtain the multiple terms for stochastic taylor expension
-        Up to order 1.5
-        multiple sc_ops
-        """
-        pass
-
-    cdef void derivativesO2(self, double t, complex[::1] rho,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """ Obtain the multiple terms for stochastic taylor expension
-        Up to order 2.0
-        One sc_ops
-        """
-        pass
-
-    cdef void photocurrent(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        photocurrent collapse + euler evolution
-        """
-        pass
-
-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        photocurrent collapse + predictor-corrector evolution
-        """
-        pass
-
-    cdef void rouchon(self, double t, double dt, double[:] noise,
-                      complex[::1] vec, complex[::1] out):
-        """Special integration scheme:
-        Force valid density matrix using positive map
-        Pierre Rouchon, Jason F. Ralph
-        arXiv:1410.5345 [quant-ph]
-        """
-        pass
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void euler(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """Integration scheme:
-        Basic Euler order 0.5
-        dV = d1 dt + d2_i dW_i
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        _zero_2d(d2)
-        copy(vec, out)
-        self.d1(t, vec, out)
-        self.d2(t, vec, d2)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void platen(self, double t, double dt, double[:] noise,
-                       complex[::1] vec, complex[::1] out):
-        """
-        Platen rhs function for both master eq and schrodinger eq.
-        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
-             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
-             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
-
-        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
-        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
-        The Theory of Open Quantum Systems
-        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
-        """
-        cdef int i, j, k
-        cdef double sqrt_dt = np.sqrt(dt)
-        cdef double sqrt_dt_inv = 0.25/sqrt_dt
-        cdef double dw, dw2
-        cdef complex[::1] d1 = self.buffer_1d[0,:]
-        cdef complex[::1] Vt = self.buffer_1d[1,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
-        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
-        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
-        _zero(d1)
-        _zero_2d(d2)
-
-        self.d1(t, vec, d1)
-        self.d2(t, vec, d2)
-        _axpy(1.0,vec,d1)
-        copy(d1,Vt)
-        copy(d1,out)
-        _scale(0.5,out)
-        for i in range(self.num_ops):
-            copy(d1,Vp[i,:])
-            copy(d1,Vm[i,:])
-            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
-            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
-            _axpy(noise[i],d2[i,:],Vt)
-        _zero(d1)
-        self.d1(t, Vt, d1)
-        _axpy(0.5,d1,out)
-        _axpy(0.5,vec,out)
-        for i in range(self.num_ops):
-            _zero_2d(d2p)
-            _zero_2d(d2m)
-            self.d2(t, Vp[i,:], d2p)
-            self.d2(t, Vm[i,:], d2m)
-            dw = noise[i] * 0.25
-            _axpy(dw,d2m[i,:],out)
-            _axpy(2*dw,d2[i,:],out)
-            _axpy(dw,d2p[i,:],out)
-            for j in range(self.num_ops):
-                if i == j:
-                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
-                else:
-                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
-                _axpy(dw2,d2p[j,:],out)
-                _axpy(-dw2,d2m[j,:],out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void pred_corr(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 15.5 Eq. (5.4)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        # a=0. b=0.5
-        cdef double dt_2 = dt*0.5
-        cdef complex[::1] euler = self.buffer_1d[0,:]
-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-        cdef complex[::1] b_pred = self.buffer_1d[2,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero(a_pred)
-        _zero(b_pred)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-        copy(vec, euler)
-        copy(vec, out)
-        _axpy(1.0, a_pred, euler)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], b_pred)
-            _axpy(-dt_2, dd2[i,i,:], a_pred)
-        _axpy(1.0, a_pred, out)
-        _axpy(1.0, b_pred, euler)
-        _axpy(0.5, b_pred, out)
-        _zero_2d(d2)
-        self.d2(t + dt, euler, d2)
-        for i in range(self.num_ops):
-            _axpy(noise[i]*0.5, d2[i,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 15.5 Eq. (5.4)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        # a=0.5, b=0.5
-        cdef int i, j, k
-        cdef complex[::1] euler = self.buffer_1d[0,:]
-        cdef complex[::1] a_pred = self.buffer_1d[1,:]
-        _zero(a_pred)
-        cdef complex[::1] a_corr = self.buffer_1d[2,:]
-        _zero(a_corr)
-        cdef complex[::1] b_pred = self.buffer_1d[3,:]
-        _zero(b_pred)
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        _zero_2d(d2)
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero_3d(dd2)
-
-        cdef double dt_2 = dt*0.5
-        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
-        copy(vec, euler)
-        _axpy(1.0, a_pred, euler)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], b_pred)
-            _axpy(-dt_2, dd2[i,i,:], a_pred)
-        _axpy(1.0, b_pred, euler)
-        copy(vec, out)
-        _axpy(0.5, a_pred, out)
-        _axpy(0.5, b_pred, out)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
-        for i in range(self.num_ops):
-            _axpy(noise[i]*0.5, d2[i,:], out)
-            _axpy(-dt_2, dd2[i,i,:], a_corr)
-        _axpy(0.5, a_corr, out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void milstein(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 10.3 Eq. (3.1)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-
-        dV = -iH*V*dt + d1*dt + d2_i*dW_i
-             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
-        """
-        cdef int i, j, k
-        cdef double dw
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        copy(vec,out)
-        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
-        for i in range(self.num_ops):
-            _axpy(noise[i],d2[i,:],out)
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                if (i == j):
-                    dw = (noise[i] * noise[i] - dt) * 0.5
-                else:
-                    dw = (noise[i] * noise[j])
-                _axpy(dw,dd2[i,j,:],out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void milstein_imp(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out) except *:
-        """
-        Chapter 12.2 Eq. (2.9)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j, k
-        cdef double dw
-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-                                                          dtype=complex)
-        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
-                                                         dtype=complex)
-        cdef complex[::1] a = self.buffer_1d[0,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
-        _zero(a)
-        _zero_2d(d2)
-        _zero_3d(dd2)
-        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
-        copy(vec, dvec)
-        _axpy(0.5, a, dvec)
-        for i in range(self.num_ops):
-            _axpy(noise[i], d2[i,:], dvec)
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                if (i == j):
-                    dw = (noise[i] * noise[i] - dt) * 0.5
-                else:
-                    dw = (noise[i] * noise[j])
-                _axpy(dw, dd2[i,j,:], dvec)
-        copy(dvec, guess)
-        _axpy(0.5, a, guess)
-        self.implicit(t+dt, dvec, out, guess)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void taylor15(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        """
-        Chapter 12.2 Eq. (2.18),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-        cdef complex[::1] L0a = self.buffer_1d[1, :]
-        _zero(a)
-        _zero_2d(b)
-        _zero_3d(Lb)
-        _zero_2d(L0b)
-        _zero_2d(La)
-        _zero_4d(LLb)
-        _zero(L0a)
-        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
-
-        cdef int i,j,k
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-        copy(vec,out)
-        _axpy(1.0, a, out)
-        _axpy(0.5, L0a, out)
-
-        for i in range(self.num_ops):
-            _axpy(dw[i], b[i,:], out)
-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
-            _axpy(dz[i], La[i,:], out)
-            _axpy(dw[i]-dz[i], L0b[i,:], out)
-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-                        LLb[i,i,i,:], out)
-            for j in range(i+1,self.num_ops):
-                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
-                for k in range(j+1,self.num_ops):
-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out) except *:
-        """
-        Chapter 12.2 Eq. (2.18),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
-        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
-        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
-        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
-        cdef complex[::1] L0a = self.buffer_1d[1, :]
-        _zero(a)
-        _zero_2d(b)
-        _zero_3d(Lb)
-        _zero_2d(L0b)
-        _zero_2d(La)
-        _zero_4d(LLb)
-        _zero(L0a)
-        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
-                   dtype=complex)
-        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
-                  dtype=complex)
-        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
-
-        cdef int i,j,k
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-        copy(vec, vec_t)
-        _axpy(0.5, a, vec_t)
-        for i in range(self.num_ops):
-            _axpy(dw[i], b[i,:], vec_t)
-            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
-            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
-            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
-            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
-                        LLb[i,i,i,:], vec_t)
-            for j in range(i+1,self.num_ops):
-                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
-                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
-                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
-                for k in range(j+1,self.num_ops):
-                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
-        copy(vec_t, guess)
-        _axpy(0.5, a, guess)
-
-        self.implicit(t+dt, vec_t, out, guess)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void platen15(self, double t, double dt, double[:] noise,
-                    complex[::1] vec, complex[::1] out):
-        """
-        Chapter 11.2 Eq. (2.13)
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef int i, j, k
-        cdef double sqrt_dt = np.sqrt(dt)
-        cdef double sqrt_dt_inv = 1./sqrt_dt
-        cdef double ddz, ddw, ddd
-        cdef double[::1] dz, dw
-        dw = np.empty(self.num_ops)
-        dz = np.empty(self.num_ops)
-        for i in range(self.num_ops):
-            dw[i] = noise[i]
-            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
-
-        cdef complex[::1] d1 = self.buffer_1d[0,:]
-        cdef complex[::1] d1p = self.buffer_1d[1,:]
-        cdef complex[::1] d1m = self.buffer_1d[2,:]
-        cdef complex[::1] V = self.buffer_1d[3,:]
-        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
-        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
-        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
-        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
-        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
-        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
-        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
-        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
-        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
-        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
-
-        _zero(d1)
-        _zero_2d(d2)
-        _zero_2d(dd2)
-        self.d1(t, vec, d1)
-        self.d2(t, vec, d2)
-        self.d2(t + dt, vec, dd2)
-        # Euler part
-        copy(vec,out)
-        _axpy(1., d1, out)
-        for i in range(self.num_ops):
-            _axpy(dw[i], d2[i,:], out)
-
-        _zero(V)
-        _axpy(1., vec, V)
-        _axpy(1./self.num_ops, d1, V)
-
-        _zero_2d(v2p)
-        _zero_2d(v2m)
-        for i in range(self.num_ops):
-            _axpy(1., V, v2p[i,:])
-            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
-            _axpy(1., V, v2m[i,:])
-            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
-
-        _zero_3d(p2p)
-        _zero_3d(p2m)
-        for i in range(self.num_ops):
-            _zero_2d(d2p)
-            _zero_2d(d2m)
-            self.d2(t, v2p[i,:], d2p)
-            self.d2(t, v2m[i,:], d2m)
-            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
-            _axpy( ddw, d2p[i,:], out)
-            _axpy(-ddw, d2m[i,:], out)
-            for j in range(self.num_ops):
-                _axpy(      1., v2p[i,:], p2p[i,j,:])
-                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
-                _axpy(      1., v2p[i,:], p2m[i,j,:])
-                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
-
-        _axpy(-0.5*(self.num_ops), d1, out)
-        for i in range(self.num_ops):
-            ddz = dz[i]*0.5/sqrt_dt  # 1.5
-            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
-            _zero(d1p)
-            _zero(d1m)
-            _zero_2d(d2m)
-            _zero_2d(d2p)
-            _zero_2d(d2pp)
-            _zero_2d(d2mm)
-            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
-            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
-            self.d2(t, v2p[i,:], d2p)
-            self.d2(t, v2m[i,:], d2m)
-            self.d2(t, p2p[i,i,:], d2pp)
-            self.d2(t, p2m[i,i,:], d2mm)
-
-            _axpy( ddz+0.25, d1p, out)
-            _axpy(-ddz+0.25, d1m, out)
-
-            _axpy((dw[i]-dz[i]), dd2[i,:], out)
-            _axpy((dz[i]-dw[i]), d2[i,:], out)
-
-            _axpy( ddd, d2pp[i,:], out)
-            _axpy(-ddd, d2mm[i,:], out)
-            _axpy(-ddd, d2p[i,:], out)
-            _axpy( ddd, d2m[i,:], out)
-
-            for j in range(self.num_ops):
-              ddw = 0.5*(dw[j]-dz[j]) # 1.5
-              _axpy(ddw, d2p[j,:], out)
-              _axpy(-2*ddw, d2[j,:], out)
-              _axpy(ddw, d2m[j,:], out)
-
-              if j>i:
-                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
-                _axpy( ddw, d2p[j,:], out)
-                _axpy(-ddw, d2m[j,:], out)
-
-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-                _zero_2d(d2pp)
-                _zero_2d(d2mm)
-                self.d2(t, p2p[j,i,:], d2pp)
-                self.d2(t, p2m[j,i,:], d2mm)
-                _axpy( ddw, d2pp[j,:], out)
-                _axpy(-ddw, d2mm[j,:], out)
-                _axpy(-ddw, d2p[j,:], out)
-                _axpy( ddw, d2m[j,:], out)
-
-                for k in range(j+1,self.num_ops):
-                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
-                    _axpy( ddw, d2pp[k,:], out)
-                    _axpy(-ddw, d2mm[k,:], out)
-                    _axpy(-ddw, d2p[k,:], out)
-                    _axpy( ddw, d2m[k,:], out)
-
-              if j<i:
-                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
-                _zero_2d(d2pp)
-                _zero_2d(d2mm)
-                self.d2(t, p2p[j,i,:], d2pp)
-                self.d2(t, p2m[j,i,:], d2mm)
-                _axpy( ddw, d2pp[j,:], out)
-                _axpy(-ddw, d2mm[j,:], out)
-                _axpy(-ddw, d2p[j,:], out)
-                _axpy( ddw, d2m[j,:], out)
-
-    @cython.wraparound(False)
-    @cython.boundscheck(False)
-    @cython.cdivision(True)
-    cdef void taylor20(self, double t, double dt, double[::1] noise,
-                           complex[::1] vec, complex[::1] out):
-        """
-        Chapter 10.5 Eq. (5.1),
-        Numerical Solution of Stochastic Differential Equations
-        By Peter E. Kloeden, Eckhard Platen
-        """
-        cdef double[::1] noises = np.empty(5)
-        cdef double dwn
-        self.order2noise.order2(noise,noises)
-        cdef complex[::1] a = self.buffer_1d[0, :]
-        cdef complex[::1] b = self.buffer_1d[1, :]
-        cdef complex[::1] Lb = self.buffer_1d[2, :]
-        cdef complex[::1] La = self.buffer_1d[3, :]
-        cdef complex[::1] L0b = self.buffer_1d[4, :]
-        cdef complex[::1] LLb = self.buffer_1d[5, :]
-        cdef complex[::1] L0a = self.buffer_1d[6, :]
-        cdef complex[::1] LLa = self.buffer_1d[7, :]
-        cdef complex[::1] LL0b = self.buffer_1d[8, :]
-        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
-        cdef complex[::1] LLLb = self.buffer_1d[10, :]
-        _zero(a)
-        _zero(b)
-        _zero(Lb)
-        _zero(La)
-        _zero(L0b)
-        _zero(LLb)
-        _zero(L0a)
-        _zero(LLa)
-        _zero(LL0b)
-        _zero(L0Lb)
-        _zero(LLLb)
-        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
-                           L0a, LLa, LL0b, L0Lb, LLLb)
-
-        copy(vec,out)
-        _axpy(1.0, a, out)
-
-        _axpy(noises[0], b, out)
-        dwn = noises[0]*noises[0]*0.5
-        _axpy(dwn, Lb, out)
-
-        _axpy(noises[1], La, out)
-        _axpy(noises[0]-noises[1], L0b, out)
-        dwn *= noises[0]*(1/3.)
-        _axpy(dwn, LLb, out)
-        _axpy(0.5, L0a, out)
-
-        _axpy(noises[2], L0Lb, out)
-        _axpy(noises[3], LL0b, out)
-        _axpy(noises[4], LLa, out)
-        dwn *= noises[0]*0.25
-        _axpy(dwn, LLLb, out)
-
-
-cdef class SSESolver(StochasticSolver):
-    """stochastic Schrodinger system"""
-    cdef QobjEvo L
-    cdef object c_ops
-    cdef object cpcd_ops
-    cdef object imp
-    cdef double tol, imp_t
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.cpcd_ops = []
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op[0])
-            self.cpcd_ops.append(op[1])
-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-            self.tol = sso.tol
-            self.imp = LinearOperator( (self.l_vec,self.l_vec),
-                                      matvec=self.implicit_op, dtype=complex)
-
-    def implicit_op(self, vec):
-        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
-        self.d1(self.imp_t, vec, out)
-        cdef int i
-        _scale(-0.5,out)
-        _axpy(1.,vec,out)
-        return out
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
-        cdef int i
-        cdef complex e
-        cdef QobjEvo c_op
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        _zero(temp)
-        for i in range(self.num_ops):
-            c_op = self.cpcd_ops[i]
-            e = c_op.expect_data(t, _dense_wrap(vec))
-            _zero(temp)
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
-            _axpy(-0.125 * e * e * self.dt, vec, out)
-            _axpy(0.5 * e * self.dt, temp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-        cdef int i, k
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
-            c_op = self.cpcd_ops[i]
-            expect = c_op.expect_data(t, _dense_wrap(vec))
-            _axpy(-0.5*expect,vec,out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivatives(self, double t, int deg, complex[::1] vec,
-                          complex[::1] a, complex[:, ::1] b,
-                          complex[:, :, ::1] Lb, complex[:,::1] La,
-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                          complex[::1] L0a):
-        """
-        combinaisons of a and b derivatives for taylor order 1.5
-        dY ~ a dt + bi dwi
-                                         deg   use        noise
-        b[i.:]       bi                   >=0   d2 euler   dwi
-        a[:]         a                    >=0   d1 euler   dt
-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-
-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-        La[i,:]      ba'                  >=2   taylor15   dzi
-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-        """
-        cdef int i, j, k, l
-        cdef double dt = self.dt
-        cdef QobjEvo c_op
-        cdef complex e, de_bb
-
-        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
-        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
-        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
-        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
-        _zero_3d(dde_bb)
-        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
-        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-        _zero(temp)
-        _zero(temp2)
-        _zero_2d(Cvec)
-        _zero_3d(Cb)
-
-        # a b
-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
-            e = _dotc(vec,Cvec[i,:])
-            e_real[i] = e.real
-            _axpy(1., Cvec[i,:], b[i,:])
-            _axpy(-e_real[i], vec, b[i,:])
-            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
-            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
-
-        #Lb bb'
-        if deg >= 1:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            for j in range(self.num_ops):
-              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
-              for k in range(self.l_vec):
-                  temp[k] = conj(b[j,k])
-                  temp2[k] = 0.
-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
-                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-              _axpy(1., Cb[i,j,:], Lb[i,j,:])
-              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
-              _axpy(-de_b[i,j], vec, Lb[i,j,:])
-
-              for k in range(self.num_ops):
-                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
-                                  _dot(b[k,:], Cb[i,j,:]) + \
-                                  conj(_dotc(b[k,:], temp2)))*.5
-                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
-
-        #L0b La LLb
-        if deg >= 2:
-          for i in range(self.num_ops):
-              #ba'
-              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-              for j in range(self.num_ops):
-                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
-                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
-                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
-                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
-
-              #ab' + db/dt + bbb"/2
-              c_op = self.c_ops[i]
-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
-              for k in range(self.l_vec):
-                  temp[k] = conj(a[k])
-                  temp2[k] = 0.
-              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
-                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
-              _axpy(-e_real[i], a, L0b[i,:])
-              _axpy(-de_a[i], vec, L0b[i,:])
-
-              temp = np.zeros(self.l_vec, dtype=complex)
-              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
-              e = _dotc(vec,temp)
-              _axpy(1., temp, L0b[i,:])
-              _axpy(-e.real, vec, L0b[i,:])
-              _axpy(-1., b[i,:], L0b[i,:])
-
-              for j in range(self.num_ops):
-                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
-                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
-
-              #b(bb"+b'b')
-              for j in range(i,self.num_ops):
-                  for k in range(j, self.num_ops):
-                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
-                                  _dense_wrap(LLb[i,j,k,:]))
-                      for l in range(self.l_vec):
-                          temp[l] = conj(Lb[j,k,l])
-                          temp2[l] = 0.
-                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
-                               _dot(Lb[j,k,:], Cvec[i,:]) + \
-                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
-                               _dotc(vec, temp2)))*0.5
-                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
-                      _axpy(-de_bb, vec, LLb[i,j,k,:])
-                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
-                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
-                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
-
-        #da/dt + aa' + bba"
-        if deg == 2:
-          self.d1(t + dt, vec, L0a)
-          _axpy(-1.0, a, L0a)
-          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-          for j in range(self.num_ops):
-              c_op = self.c_ops[j]
-              temp = np.zeros(self.l_vec, dtype=complex)
-              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
-              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
-              _axpy(e_real[j] * dt, temp, L0a[:])
-              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
-              for i in range(self.num_ops):
-                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
-                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
-                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
-                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
-                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
-                         complex[::1] vec, complex[::1] out):
-        cdef int k
-        cdef complex[::1] temp = self.func_buffer_1d[13,:]
-        for k in range(self.l_vec):
-            temp[k] = conj(vec[k])
-            out[k] = 0.
-        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivativesO2(self, double t, complex[::1] psi,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """
-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-        Use Stratonovich-Taylor expansion.
-        One one sc_ops
-        dY ~ a dt + bi dwi
-
-        b[:]     b                        d2 euler    dw
-        a[:]     a- Lb/2                  d1 euler    dt
-        Lb[:]    b'b                      milstein    dw^2/2
-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-
-        LLa[:]   ...                      taylor2.0   dwdt-dz
-        LL0b[:]  ...                      taylor2.0   dz
-        L0Lb[:]  ...                      taylor2.0   dw^3/6
-        LLLb[:]  ...                      taylor2.0   dt^2/2
-        """
-        cdef double dt = self.dt
-        cdef QobjEvo c_op = self.c_ops[0]
-        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
-        cdef complex de_a, dde_ba, de_La, de_L0b
-
-        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
-        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
-        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
-        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
-        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
-        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
-        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
-        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
-        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
-        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
-        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
-        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
-        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
-        _zero(Cpsi)
-        _zero(Cb)
-        _zero(CLb)
-        _zero(CLLb)
-        _zero(Ca)
-        _zero(CLa)
-        _zero(CL0b)
-
-        # b
-        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
-        e = _dotc(psi, Cpsi).real
-        _axpy(1., Cpsi, b)
-        _axpy(-e, psi, b)
-
-        # Lb
-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
-        self._c_vec_conj(t, c_op, b, Cbc)
-        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
-                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
-        _axpy(1., Cb, Lb)
-        _axpy(-e, b, Lb)
-        _axpy(-de_b, psi, Lb)
-
-        # LLb = b'b'b + b"bb
-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
-        self._c_vec_conj(t, c_op, Lb, CLbc)
-        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
-                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
-        _axpy(1, CLb, LLb)      # b'b'b
-        _axpy(-e, Lb, LLb)      # b'b'b
-        _axpy(-de_Lb, psi, LLb) # b'b'b
-        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
-        _axpy(-dde_bb, psi, LLb) # b"bb
-        _axpy(-de_b*2, b, LLb)   # b"bb
-
-        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
-        self._c_vec_conj(t, c_op, LLb, CLLbc)
-        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
-                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
-        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
-                    conj(_dotc(b, CLbc)))*.5
-        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
-        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
-        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
-        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
-        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
-        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
-        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
-
-        # a
-        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
-        _axpy(-0.5 * e * e * dt, psi, a)
-        _axpy(e * dt, Cpsi, a)
-        _axpy(-0.5 * dt, Lb, a)
-
-        #La
-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-        _axpy(-0.5 * e * e * dt, b, La)
-        _axpy(-e * de_b * dt, psi, La)
-        _axpy(e * dt, Cb, La)
-        _axpy(de_b * dt, Cpsi, La)
-        _axpy(-0.5 * dt, LLb, La)
-
-        #LLa
-        _axpy(-2 * e * de_b * dt, b, LLa)
-        _axpy(-de_b * de_b * dt, psi, LLa)
-        _axpy(-e * dde_bb * dt, psi, LLa)
-        _axpy( 2 * de_b * dt, Cb, LLa)
-        _axpy( dde_bb * dt, Cpsi, LLa)
-
-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-        _axpy(-de_Lb * e * dt, psi, LLa)
-        _axpy(-0.5 * e * e * dt, Lb, LLa)
-        _axpy( de_Lb * dt, Cpsi, LLa)
-        _axpy( e * dt, CLb, LLa)
-
-        _axpy(-0.5 * dt, LLLb, LLa)
-
-        # L0b = b'a
-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
-        self._c_vec_conj(t, c_op, a, Cac)
-        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
-                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
-        _axpy(1.0, Ca, L0b)
-        _axpy(-e, a, L0b)
-        _axpy(-de_a, psi, L0b)
-
-        # LL0b = b"ba + b'La
-        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
-                    conj(_dotc(b, Cac)))*.5
-        _axpy(-dde_ba, psi, LL0b)
-        _axpy(-de_a, b, LL0b)
-        _axpy(-de_b, a, LL0b)
-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
-        self._c_vec_conj(t, c_op, La, CLac)
-        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
-                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
-        _axpy(1., CLa, LL0b)
-        _axpy(-e, La, LL0b)
-        _axpy(-de_La, psi, LL0b)
-
-        # L0Lb = b"ba + b'L0b
-        _axpy(-dde_ba, psi, L0Lb)
-        _axpy(-de_a, b, L0Lb)
-        _axpy(-de_b, a, L0Lb)
-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
-        self._c_vec_conj(t, c_op, L0b, CL0bc)
-        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
-                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
-        _axpy(1., CL0b, L0Lb)
-        _axpy(-e, L0b, L0Lb)
-        _axpy(-de_L0b, psi, L0Lb)
-
-        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
-        self.d1(t + dt, psi, L0a) # da/dt
-        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
-        _axpy(-1.0, a, L0a)        # da/dt
-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
-        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
-        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
-        _axpy(e * dt, Ca, L0a)              # a'_a_
-        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
-        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
-
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                                        complex[::1] out,
-                                        np.ndarray[complex, ndim=1] guess) except *:
-        # np.ndarray to memoryview is OK but not the reverse
-        # scipy function only take np array, not memoryview
-        self.imp_t = t
-        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
-                                          tol=self.tol, atol=1e-12)
-        cdef int i
-        copy(spout, out)
-
-
-cdef class SMESolver(StochasticSolver):
-    """stochastic master equation system"""
-    cdef QobjEvo L
-    cdef object imp
-    cdef object c_ops
-    cdef int N_root
-    cdef double tol
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.N_root = np.sqrt(self.l_vec)
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op)
-        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
-            self.tol = sso.tol
-            self.imp = sso.imp
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-    @cython.boundscheck(False)
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef int i, k
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-            expect = self.expect(out[i,:])
-            _axpy(-expect, rho, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivatives(self, double t, int deg, complex[::1] rho,
-                          complex[::1] a, complex[:, ::1] b,
-                          complex[:, :, ::1] Lb, complex[:,::1] La,
-                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
-                          complex[::1] L0a):
-        """
-        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
-        dY ~ a dt + bi dwi
-                                         deg   use        noise
-        b[i.:]       bi                   >=0   d2 euler   dwi
-        a[:]         a                    >=0   d1 euler   dt
-        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
-        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
-        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
-        La[i,:]      ba'                  >=2   taylor15   dzi
-        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
-        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
-        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
-        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
-        """
-        cdef int i, j, k
-        cdef QobjEvo c_op
-        cdef QobjEvo c_opj
-        cdef complex trApp, trAbb, trAa
-        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
-        cdef complex[:, ::1] trAb = self.expect_buffer_2d
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        #_zero(temp)
-
-        # a
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-
-        # b
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            # bi
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
-            trAp[i] = self.expect(b[i,:])
-            _axpy(-trAp[i], rho, b[i,:])
-
-        # Libj = bibj', i<=j
-        # sc_ops must commute (Libj = Ljbi)
-        if deg >= 1:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            for j in range(i, self.num_ops):
-                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
-                trAb[i,j] = self.expect(Lb[i,j,:])
-                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
-                _axpy(-trAb[i,j], rho, Lb[i,j,:])
-
-        # L0b La LLb
-        if deg >= 2:
-          for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            # Lia = bia'
-            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
-
-            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
-            # db/dt
-            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
-            trApp = self.expect(L0b[i,:])
-            _axpy(-trApp, rho, L0b[i,:])
-            _axpy(-1, b[i,:], L0b[i,:])
-            # ab'
-            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
-            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
-            trAa = self.expect(temp)
-            _axpy(1., temp, L0b[i,:])
-            _axpy(-trAp[i], a[:], L0b[i,:])
-            _axpy(-trAa, rho, L0b[i,:])
-            # bbb" : trAb[i,j] only defined for j>=i
-            for j in range(i):
-                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-            for j in range(i,self.num_ops):
-                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
-
-            # LLb
-            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
-            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
-            for j in range(i,self.num_ops):
-              for k in range(j,self.num_ops):
-                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
-                trAbb = self.expect(LLb[i,j,k,:])
-                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
-                _axpy(-trAbb, rho, LLb[i,j,k,:])
-                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
-                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
-
-        # L0a = a'a + da/dt + bba"/2  (a" = 0)
-        if deg == 2:
-            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-            _axpy(-1, a, L0a)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void derivativesO2(self, double t, complex[::1] rho,
-                            complex[::1] a, complex[::1] b, complex[::1] Lb,
-                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
-                            complex[::1] L0a,
-                            complex[::1] LLa, complex[::1] LL0b,
-                            complex[::1] L0Lb, complex[::1] LLLb):
-        """
-        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
-        Use Stratonovich-Taylor expansion.
-        One one sc_ops
-        dY ~ a dt + bi dwi
-
-        b[:]     b                        d2 euler    dw
-        a[:]     a- Lb/2                  d1 euler    dt
-        Lb[:]    b'b                      milstein    dw^2/2
-        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
-        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
-        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
-        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
-
-        LLa[:]   ...                      taylor2.0   dwdt-dz
-        LL0b[:]  ...                      taylor2.0   dz
-        L0Lb[:]  ...                      taylor2.0   dw^3/6
-        LLLb[:]  ...                      taylor2.0   dt^2/2
-        """
-        cdef int i, j, k
-        cdef QobjEvo c_op = self.c_ops[0]
-        cdef QobjEvo c_opj
-        cdef complex trAp, trApt
-        cdef complex trAb, trALb, trALLb
-        cdef complex trAa, trALa
-        cdef complex trAL0b
-
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
-
-        # b
-        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
-        trAp = self.expect(b)
-        _axpy(-trAp, rho, b)
-
-        # Lb = b'b
-        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
-        trAb = self.expect(Lb)
-        _axpy(-trAp, b, Lb)
-        _axpy(-trAb, rho, Lb)
-
-        # LLb = b'Lb+b"bb
-        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
-        trALb = self.expect(LLb)
-        _axpy(-trAp, Lb, LLb)
-        _axpy(-trALb, rho, LLb)
-        _axpy(-trAb*2, b, LLb)
-
-        # LLLb = b'LLb + 3 b"bLb + b"'bbb
-        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
-        trALLb = self.expect(LLLb)
-        _axpy(-trAp, LLb, LLLb)
-        _axpy(-trALLb, rho, LLLb)
-        _axpy(-trALb*3, b, LLLb)
-        _axpy(-trAb*3, Lb, LLLb)
-
-        # _a_ = a - Lb/2
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
-        _axpy(-0.5*self.dt, Lb, a)
-
-        # L_a_ = ba' - LLb/2
-        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
-        _axpy(-0.5*self.dt, LLb, La)
-
-        # LL_a_ = b(La)' - LLLb/2
-        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
-        _axpy(-0.5*self.dt, LLLb, LLa)
-
-        # _L0_b = b'(_a_)
-        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
-        trAa = self.expect(L0b)
-        _axpy(-trAp, a, L0b)
-        _axpy(-trAa, rho, L0b)
-
-        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
-        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
-        trAL0b = self.expect(L0Lb)
-        _axpy(-trAp, L0b, L0Lb)
-        _axpy(-trAL0b, rho, L0Lb)
-        _axpy(-trAa, b, L0Lb)
-        _axpy(-trAb, a, L0Lb)
-
-        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
-        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
-        trAL0b = self.expect(LL0b)
-        _axpy(-trAp, La, LL0b)
-        _axpy(-trAL0b, rho, LL0b)
-        _axpy(-trAa, b, LL0b)
-        _axpy(-trAb, a, LL0b)
-
-        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
-        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
-        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
-        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
-        _axpy(-1, a, L0a)
-        _axpy(-self.dt*0.5, L0Lb, L0a)
-
-
-    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
-                                        complex[::1] out,
-                                        np.ndarray[complex, ndim=1] guess) except *:
-        # np.ndarray to memoryview is OK but not the reverse
-        # scipy function only take np array, not memoryview
-        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
-                                          dvec, x0=guess,
-                                          tol=self.tol, atol=1e-12)
-        cdef int i
-        copy(spout,out)
-
-
-cdef class PcSSESolver(StochasticSolver):
-    """photocurrent for Schrodinger equation"""
-    cdef QobjEvo L
-    cdef object c_ops
-    cdef object cdc_ops
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.c_ops = []
-        self.cdc_ops = []
-        for i, op in enumerate(c_ops):
-            self.c_ops.append(op[0])
-            self.cdc_ops.append(op[1])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double rand
-        cdef int i, which = -1
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] d2 = self.buffer_1d[0,:]
-
-        copy(vec, out)
-        self.d1(t, vec, out)
-        rand = np.random.rand()
-        for i in range(self.num_ops):
-            c_op = self.cdc_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-            if expects[i].real * dt >= 1e-15:
-                rand -= expects[i].real *dt
-            if rand < 0:
-                which = i
-                noise[i] = 1.
-                break
-
-        if which >= 0:
-            self.collapse(t, which, expects[which].real, vec, d2)
-            _axpy(1, d2, out)
-            _axpy(-1, vec, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double expect
-        cdef int i, which=0, num_coll=0, did_collapse=0
-        cdef complex[::1] tmp = self.buffer_1d[0,:]
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef np.ndarray[int, ndim=1] colls
-
-        # Collapses are computed first
-        for i in range(self.num_ops):
-            c_op = self.cdc_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-            if expects[i].real > 0:
-                did_collapse = np.random.poisson(expects[i].real * dt)
-                num_coll += did_collapse
-                if did_collapse:
-                    which = i
-                noise[i] = did_collapse * 1.
-            else:
-                noise[i] = 0.
-
-        if num_coll == 0:
-            pass
-        elif num_coll == 1:
-            # Do one collapse
-            self.collapse(t, which, expects[which].real, vec, out)
-            copy(out, vec)
-        elif num_coll and noise[which] == num_coll:
-            # Do many collapse of one sc_ops.
-            # Recompute the expectation value, but only to check for zero.
-            c_op = self.cdc_ops[which]
-            for i in range(num_coll):
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, which, expect, vec, out)
-                    copy(out,vec)
-        elif num_coll >= 2:
-            # 2 or more collapses of different operators
-            # Ineficient, should be rare
-            coll = []
-            for i in range(self.num_ops):
-                coll += [i]*int(noise[i])
-            np.random.shuffle(coll)
-            for i in coll:
-                c_op = self.cdc_ops[i]
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, i, expect, vec, out)
-                    copy(out,vec)
-        copy(vec,tmp)
-        copy(vec,out)
-        self.d1(t, vec, tmp)
-        self.d1(t+dt, tmp, out)
-        _scale(0.5, out)
-        _axpy(0.5, tmp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
-        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        cdef int i
-        cdef complex e
-        cdef QobjEvo c_op
-        cdef complex[::1] temp = self.func_buffer_1d[0,:]
-        for i in range(self.num_ops):
-            _zero(temp)
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-            e = _dznrm2(temp)
-            _axpy(0.5 * e * e * self.dt, vec, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.c_ops[i]
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
-            expect = _dznrm2(out[i,:])
-            if expect.real >= 1e-15:
-                _zscale(1/expect, out[i,:])
-            else:
-                _zero(out[i,:])
-            _axpy(-1, vec, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void collapse(self, double t, int which, double expect,
-                       complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        c_op = self.c_ops[which]
-        _zero(out)
-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        _zscale(1/expect, out)
-
-
-cdef class PcSMESolver(StochasticSolver):
-    """photocurrent for master equation"""
-    cdef QobjEvo L
-    cdef object cdcr_cdcl_ops
-    cdef object cdcl_ops
-    cdef object clcdr_ops
-    cdef int N_root
-
-    def set_data(self, sso):
-        L = sso.LH
-        c_ops = sso.sops
-        self.l_vec = L.shape[0]
-        self.num_ops = len(c_ops)
-        self.L = L
-        self.cdcr_cdcl_ops = []
-        self.cdcl_ops = []
-        self.clcdr_ops = []
-        self.N_root = np.sqrt(self.l_vec)
-        for i, op in enumerate(c_ops):
-            self.cdcr_cdcl_ops.append(op[0])
-            self.cdcl_ops.append(op[1])
-            self.clcdr_ops.append(op[2])
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent(self, double t, double dt,  double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef double rand
-        cdef int i, which = -1
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] d2 = self.buffer_1d[0,:]
-
-        copy(vec, out)
-        self.d1(t, vec, out)
-        rand = np.random.rand()
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
-            if expects[i].real * dt >= 1e-15:
-                rand -= expects[i].real *dt
-            if rand < 0:
-                which = i
-                noise[i] = 1.
-                break
-
-        if which >= 0:
-            self.collapse(t, which, expects[which].real, vec, d2)
-            _axpy(1, d2, out)
-            _axpy(-1, vec, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        cdef int i, which, num_coll=0, did_collapse
-        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
-        cdef complex[::1] tmp = self.buffer_1d[0,:]
-        cdef double expect
-        cdef np.ndarray[int, ndim=1] colls
-
-        # Collapses are computed first
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
-            if expects[i].real > 0:
-                did_collapse = np.random.poisson(expects[i].real* dt)
-                num_coll += did_collapse
-                if did_collapse:
-                    which = i
-                noise[i] = did_collapse * 1.
-            else:
-                noise[i] = 0.
-
-        if num_coll == 0:
-            pass
-        elif num_coll == 1:
-            # Do one collapse
-            self.collapse(t, which, expects[which].real, vec, out)
-            copy(out,vec)
-        elif noise[which] == num_coll:
-            # Do many collapse of one sc_ops.
-            # Recompute the expectation value, but only to check for zero.
-            c_op = self.clcdr_ops[which]
-            for i in range(num_coll):
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, which, expect, vec, out)
-                    copy(out,vec)
-        elif num_coll >= 2:
-            # 2 or more collapses of different operators
-            # Ineficient, should be rare
-            coll = []
-            for i in range(self.num_ops):
-                coll += [i] * int(noise[i])
-            np.random.shuffle(coll)
-            for i in coll:
-                c_op = self.clcdr_ops[i]
-                expect = c_op.expect_data(t, _dense_wrap(vec)).real
-                if expect * dt >= 1e-15:
-                    self.collapse(t, i, expect, vec, out)
-                    copy(out,vec)
-
-        copy(vec,tmp)
-        copy(vec,out)
-        self.d1(t, vec, tmp)
-        self.d1(t+dt, tmp, out)
-        _scale(0.5, out)
-        _axpy(0.5, tmp, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-    @cython.boundscheck(False)
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex[::1] crho = self.func_buffer_1d[0,:]
-        cdef complex expect
-        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
-        for i in range(self.num_ops):
-            c_op = self.cdcr_cdcl_ops[i]
-            _zero(crho)
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
-            expect = self.expect(crho)
-            _axpy(0.5*expect* self.dt, rho, out)
-            _axpy(-0.5* self.dt, crho, out)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef int i
-        cdef QobjEvo c_op
-        cdef complex expect
-        for i in range(self.num_ops):
-            c_op = self.clcdr_ops[i]
-            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
-            expect = self.expect(out[i,:])
-            if expect.real >= 1e-15:
-                _zscale((1.+0j)/expect, out[i,:])
-            else:
-                _zero(out[i,:])
-            _axpy(-1, rho, out[i,:])
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef void collapse(self, double t, int which, double expect,
-                       complex[::1] vec, complex[::1] out):
-        cdef QobjEvo c_op
-        c_op = self.clcdr_ops[which]
-        _zero(out)
-        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        _zscale(1./expect, out)
-
-cdef class PmSMESolver(StochasticSolver):
-    """positive map for master equation"""
-    cdef object L
-    cdef QobjEvo pp_ops
-    cdef QobjEvo preLH
-    cdef QobjEvo postLH
-    cdef object sops
-    cdef object preops
-    cdef object postops
-    cdef object preops2
-    cdef object postops2
-    cdef int N_root
-
-    def set_data(self, sso):
-        c_ops = sso.sops
-        self.l_vec = sso.pp.shape[0]
-        self.num_ops = len(c_ops)
-        self.preLH = sso.preLH
-        self.postLH = sso.postLH
-        self.pp_ops = sso.pp
-        self.sops = [op for op in sso.sops]
-        self.preops = [op for op in sso.preops]
-        self.postops = [op for op in sso.postops]
-        self.preops2 = [op for op in sso.preops2]
-        self.postops2 = [op for op in sso.postops2]
-        self.N_root = np.sqrt(self.l_vec)
-
-    cdef void _normalize_inplace(self, complex[::1] vec):
-        _normalize_rho(vec)
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    cdef void rouchon(self, double t, double dt, double[:] noise,
-                           complex[::1] vec, complex[::1] out):
-        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
-        cdef complex[::1] temp = self.buffer_1d[0,:]
-        cdef complex[::1] temp2 = self.buffer_1d[1,:]
-        cdef int i, j, k
-        cdef QobjEvo c_op, c_opj
-        cdef complex ddw, tr
-        _zero(out)
-        _zero(temp)
-        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
-        for i in range(self.num_ops):
-            c_op = self.sops[i]
-            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
-            c_op = self.preops[i]
-            _zero(temp2)
-            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-            _axpy(dy[i], temp2, temp)
-
-        k = 0
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                c_op = self.preops2[k]
-                if i == j:
-                    ddw = (dy[i]*dy[j] - dt) *0.5
-                else:
-                    ddw = (dy[i]*dy[j])
-
-                _zero(temp2)
-                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
-                _axpy(ddw, temp2, temp)
-                k += 1
-
-        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
-        for i in range(self.num_ops):
-            dy[i] = conj(dy[i])
-            c_op = self.postops[i]
-            _zero(temp2)
-            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-            _axpy(dy[i], temp2, out)
-
-        k = 0
-        for i in range(self.num_ops):
-            for j in range(i, self.num_ops):
-                c_op = self.postops2[k]
-                if i == j:
-                    ddw = (dy[i]*dy[j] - dt) *0.5
-                else:
-                    ddw = (dy[i]*dy[j])
-                _zero(temp2)
-                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
-                _axpy(ddw, temp2, out)
-                k += 1
-
-        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
-        tr = self.expect(out)
-        _zscale(1./tr, out)
-
-
-    @cython.boundscheck(False)
-    @cython.wraparound(False)
-    @cython.cdivision(True)
-    cdef complex expect(self, complex[::1] rho):
-        cdef complex e = 0.
-        cdef int k
-        for k in range(self.N_root):
-            e += rho[k*(self.N_root+1)]
-        return e
-
-
-cdef class GenericSSolver(StochasticSolver):
-    """support for user defined system"""
-    cdef object d1_func, d2_func
-
-    def set_data(self, sso):
-        self.l_vec = sso.rho0.shape[0]
-        self.num_ops = len(sso.sops)
-        self.d1_func = sso.d1
-        self.d2_func = sso.d2
-
-
-    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
-        cdef np.ndarray[complex, ndim=1] in_np
-        cdef np.ndarray[complex, ndim=1] out_np
-        in_np = np.zeros((self.l_vec, ), dtype=complex)
-        copy(rho, in_np)
-        out_np = self.d1_func(t, in_np)
-        _axpy(self.dt, out_np, out) # d1 is += and * dt
-
-    @cython.boundscheck(False)
-    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
-        cdef np.ndarray[complex, ndim=1] in_np
-        cdef np.ndarray[complex, ndim=2] out_np
-        cdef int i
-        in_np = np.zeros((self.l_vec, ), dtype=complex)
-        copy(rho, in_np)
-        out_np = self.d2_func(t, in_np)
-        for i in range(self.num_ops):
-            copy(out_np[i,:], out[i,:])
+#cython: language_level=3
+
+import numpy as np
+cimport numpy as np
+cimport cython
+from cpython.exc cimport PyErr_CheckSignals
+from libc.math cimport fabs
+from qutip.core.cy.qobjevo cimport QobjEvo
+from .. import Qobj, unstack_columns
+import scipy.sparse as sp
+from scipy.sparse.linalg import LinearOperator
+from scipy.linalg.cython_blas cimport zaxpy, zdotu, zdotc, zcopy, zdscal, zscal
+from scipy.linalg.cython_blas cimport dznrm2 as raw_dznrm2
+
+from qutip.core.data cimport dense, Dense
+import qutip.core.data as _data
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double complex conj(double complex x)
+
+cdef int ZERO=0
+cdef double DZERO=0
+cdef complex ZZERO=0j
+cdef int ONE=1
+
+"""Some of blas wrapper"""
+@cython.boundscheck(False)
+cdef void _axpy(complex a, complex[::1] x, complex[::1] y):
+    """ y += a*x"""
+    cdef int l = x.shape[0]
+    zaxpy(&l, &a, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void copy(complex[::1] x, complex[::1] y):
+    """ y = x """
+    cdef int l = x.shape[0]
+    zcopy(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef complex _dot(complex[::1] x, complex[::1] y):
+    """ = x_i * y_i """
+    cdef int l = x.shape[0]
+    return zdotu(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef complex _dotc(complex[::1] x, complex[::1] y):
+    """ = conj(x_i) * y_i """
+    cdef int l = x.shape[0]
+    return zdotc(&l, <complex*>&x[0], &ONE, <complex*>&y[0], &ONE)
+
+@cython.boundscheck(False)
+cdef double _dznrm2(complex[::1] vec):
+    """ = sqrt( x_i**2 ) """
+    cdef int l = vec.shape[0]
+    return raw_dznrm2(&l, <complex*>&vec[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _scale(double a, complex[::1] x):
+    """ x *= a """
+    cdef int l = x.shape[0]
+    zdscal(&l, &a, <complex*>&x[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zscale(complex a, complex[::1] x):
+    """ x *= a """
+    cdef int l = x.shape[0]
+    zscal(&l, &a, <complex*>&x[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero(complex[::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]
+    zdscal(&l, &DZERO, <complex*>&x[0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero_2d(complex[:,::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]*x.shape[1]
+    zdscal(&l, &DZERO, <complex*>&x[0,0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero_3d(complex[:,:,::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]
+    zdscal(&l, &DZERO, <complex*>&x[0,0,0], &ONE)
+
+@cython.boundscheck(False)
+cdef void _zero_4d(complex[:,:,:,::1] x):
+    """ x *= 0 """
+    cdef int l = x.shape[0]*x.shape[1]*x.shape[2]*x.shape[3]
+    zdscal(&l, &DZERO, <complex*>&x[0,0,0,0], &ONE)
+
+@cython.boundscheck(False)
+@cython.initializedcheck(False)
+cdef Dense _dense_wrap(double complex [::1] x):
+    return dense.wrap(&x[0], x.shape[0], 1)
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%
+# functions for ensuring that the states stay physical
+@cython.cdivision(True)
+@cython.boundscheck(False)
+cdef void _normalize_inplace(complex[::1] vec):
+    """ make norm of vec equal to 1"""
+    cdef int l = vec.shape[0]
+    cdef double norm = 1.0/_dznrm2(vec)
+    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
+
+# to move eventually, 10x faster than scipy's norm.
+@cython.cdivision(True)
+@cython.boundscheck(False)
+def normalize_inplace(complex[::1] vec):
+    """ make norm of vec equal to 1"""
+    cdef int l = vec.shape[0]
+    cdef double norm = 1.0/_dznrm2(vec)
+    zdscal(&l, &norm, <complex*>&vec[0], &ONE)
+    return fabs(norm-1)
+
+@cython.cdivision(True)
+@cython.boundscheck(False)
+cdef void _normalize_rho(complex[::1] rho):
+    """ Ensure that the density matrix trace is one and
+    that the composing states are normalized.
+    """
+    cdef int l = rho.shape[0]
+    cdef int N = np.sqrt(l)
+    cdef complex[::1,:] mat = np.reshape(rho, (N,N), order="F")
+    cdef complex[::1,:] eivec
+    cdef double[::1] eival = np.zeros(N)
+    eivec = _data.eigs(Dense(mat, copy=False), True, True)[1].full()
+
+    _zero(rho)
+    cdef int i, j, k
+    cdef double sum
+
+    sum = 0.
+    for i in range(N):
+        _normalize_inplace(eivec[:,i])
+        if eival[i] < 0:
+            eival[i] = 0.
+        sum += eival[i]
+    if sum != 1.:
+        for i in range(N):
+            eival[i] /= sum
+
+    for i in range(N):
+        for j in range(N):
+            for k in range(N):
+                rho[j+N*k] += conj(eivec[k,i])*eivec[j,i]*eival[i]
+
+# Available solvers:
+cpdef enum Solvers:
+  # order 0.5
+  EULER_SOLVER           =  50
+  # order 0.5 strong, 1.0 weak?
+  PC_SOLVER              = 101
+  PC_2_SOLVER            = 104
+  # order 1.0
+  PLATEN_SOLVER          = 100
+  MILSTEIN_SOLVER        = 102
+  MILSTEIN_IMP_SOLVER    = 103
+  # order 1.5
+  EXPLICIT1_5_SOLVER     = 150
+  TAYLOR1_5_SOLVER       = 152
+  TAYLOR1_5_IMP_SOLVER   = 153
+  # order 2.0
+  TAYLOR2_0_SOLVER       = 202
+
+  # Special solvers
+  PHOTOCURRENT_SOLVER    =  60
+  PHOTOCURRENT_PC_SOLVER = 110
+  ROUCHON_SOLVER         = 120
+
+  # For initialisation
+  SOLVER_NOT_SET         =   0
+
+
+cdef class TaylorNoise:
+    """ Object to build the Stratonovich integral for order 2.0 strong taylor.
+    Complex enough that I fell it should be kept separated from the main solver.
+    """
+    cdef:
+      int p
+      double rho, alpha
+      double aFactor, bFactor
+      double BFactor, CFactor
+      double dt, dt_sqrt
+
+    @cython.cdivision(True)
+    def __init__(self, int p, double dt):
+        self.p = p
+        self.dt = dt
+        self.dt_sqrt = dt**.5
+        cdef double pi = np.pi
+        cdef int i
+
+        cdef double rho = 0.
+        for i in range(1,p+1):
+            rho += (i+0.)**-2
+        rho = 1./3.-2*rho/(pi**2)
+        self.rho = (rho)**.5
+        self.aFactor = -(2)**.5/pi
+
+        cdef double alpha = 0.
+        for i in range(1,p+1):
+            alpha += (i+0.)**-4
+        alpha = pi/180-alpha/(2*pi**2)/pi
+        self.alpha = (alpha)**.5
+        self.bFactor = (0.5)**.5/pi**2
+
+        self.BFactor = 1/(4*pi**2)
+        self.CFactor = -1/(2*pi**2)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cpdef void order2(self, double[::1] noise, double[::1] dws):
+        cdef int p = self.p
+        cdef int r, l
+        cdef double s = 1/6.
+        cdef double a = 0
+        cdef double b = 0
+        cdef double AA = 0
+        cdef double BB = 0
+        cdef double CC = 0
+
+        for r in range(p):
+            a += noise[3+r]/(r+1.)
+            b += noise[3+r+p]/(r+1.)/(r+1.)
+            BB += (1/(r+1.)/(r+1.)) *\
+                 (noise[3+r]*noise[3+r]+noise[3+r+p]*noise[3+r+p])
+            for l in range(p):
+                if r != l:
+                    CC += (r+1.)/((r+1.)*(r+1.)-(l+1.)*(l+1.)) *\
+                         (1/(l+1.)*noise[3+r]*noise[3+l] - \
+                         (l+1.)/(r+1.)*noise[3+r+p]*noise[3+l+p])
+
+        a = self.aFactor * a + self.rho * noise[1]
+        b = self.bFactor * b + self.alpha * noise[2]
+        AA = 0.25*a*a
+        BB *= self.BFactor
+        CC *= self.CFactor
+
+        dws[0] = noise[0]                       # dw
+        dws[1] = 0.5*(noise[0]+a)               # dz
+        dws[2] = noise[0]*(noise[0]*s -0.25*a -0.5*b) +BB +CC  # j011
+        dws[3] = noise[0]*(noise[0]*s          +   b) -AA -BB  # j101
+        dws[4] = noise[0]*(noise[0]*s +0.25*a -0.5*b) +AA -CC  # j110
+
+
+cdef class StochasticSolver:
+    """ stochastic solver class base
+    Does most of the initialisation, drive the simulation and contain the
+    stochastic integration algorythm that do not depend on the physics.
+
+    This class is not to be used as is, the function computing the evolution's
+    derivative are specified in it's child class which define the deterministic
+    and stochastic contributions.
+
+    PYTHON METHODS:
+    set_solver:
+      Receive the data for the integration.
+      Prepare buffers
+
+    cy_sesolve_single_trajectory:
+      Run one trajectory.
+
+
+    INTERNAL METHODS
+    make_noise:
+      create the stochastic noise
+    run:
+      evolution between timestep (substep)
+    solver's method:
+      stochastic integration algorithm
+        euler
+        milstein
+        taylor
+        ...
+
+    CHILD:
+    SSESolver: stochastic schrodinger evolution
+    SMESolver: stochastic master evolution
+    PcSSESolver: photocurrent stochastic schrodinger evolution
+    PcSMESolver: photocurrent stochastic master evolution
+    PmSMESolver: positive map stochastic master evolution
+    GenericSSolver: general (user defined) stochastic evolution
+
+    CHILD METHODS:
+    set_data:
+      Read data about the system
+    d1:
+      deterministic part
+    d2:
+      non-deterministic part
+    derivatives:
+      d1, d2 and their derivatives up to dt**1.5
+      multiple sc_ops
+    derivativesO2:
+      d1, d2 and there derivatives up to dt**2.0
+      one sc_ops
+    """
+    cdef int l_vec, num_ops
+    cdef Solvers solver
+    cdef int num_step, num_substeps, num_dw
+    cdef int normalize
+    cdef double dt
+    cdef int noise_type
+    cdef object custom_noise
+    cdef double[::1] dW_factor
+    cdef unsigned int[::1] seed
+    cdef object sso
+
+    # buffer to not redo the initialisation at each substep
+    cdef complex[:, ::1] buffer_1d
+    cdef complex[:, :, ::1] buffer_2d
+    cdef complex[:, :, :, ::1] buffer_3d
+    cdef complex[:, :, :, ::1] buffer_4d
+    cdef complex[:, ::1] expect_buffer_1d
+    cdef complex[:, ::1] expect_buffer_2d
+    cdef complex[:, :, ::1] expect_buffer_3d
+    cdef complex[:, ::1] func_buffer_1d
+    cdef complex[:, ::1] func_buffer_2d
+    cdef complex[:, :, ::1] func_buffer_3d
+
+    cdef TaylorNoise order2noise
+
+    def __init__(self):
+        self.l_vec = 0
+        self.num_ops = 0
+        self.solver = SOLVER_NOT_SET
+
+    def set_solver(self, sso):
+        """ Prepare the solver from the info in StochasticSolverOptions
+
+        Parameters
+        ----------
+        sso : StochasticSolverOptions
+            Data of the stochastic system
+        """
+        self.set_data(sso)
+        self.sso = sso
+
+        self.solver = sso.solver_code
+        self.dt = sso.dt
+        self.num_substeps = sso.nsubsteps
+        self.normalize = sso.normalize
+        self.num_step = len(sso.times)
+        self.num_dw = len(sso.sops)
+        if self.solver in [EXPLICIT1_5_SOLVER,
+                           TAYLOR1_5_SOLVER,
+                           TAYLOR1_5_IMP_SOLVER]:
+            self.num_dw *= 2
+        if self.solver in [TAYLOR2_0_SOLVER]:
+            self.num_dw *= 3 + 2*sso.p
+            self.order2noise = TaylorNoise(sso.p, self.dt)
+        # prepare buffers for the solvers
+        nb_solver = [0,0,0,0]
+        nb_func = [0,0,0]
+        nb_expect = [0,0,0]
+
+        # %%%%%%%%%%%%%%%%%%%%%%%%%
+        # Depending on the solver, determine the numbers of buffers of each
+        # shape to prepare. (~30% slower when not preallocating buffer)
+        # nb_solver : buffer to contain the states used by solver
+        # nb_func : buffer for states used used by d1, d2 and derivative functions
+        # nb_expect : buffer to store expectation values.
+        if self.solver is EULER_SOLVER:
+            nb_solver = [0,1,0,0]
+        elif self.solver is PHOTOCURRENT_SOLVER:
+            nb_solver = [1,0,0,0]
+            nb_func = [1,0,0]
+        elif self.solver is PLATEN_SOLVER:
+            nb_solver = [2,5,0,0]
+        elif self.solver is PC_SOLVER:
+            nb_solver = [4,1,1,0]
+        elif self.solver is MILSTEIN_SOLVER:
+            nb_solver = [0,1,1,0]
+        elif self.solver is MILSTEIN_IMP_SOLVER:
+            nb_solver = [1,1,1,0]
+        elif self.solver is PC_2_SOLVER:
+            nb_solver = [5,1,1,0]
+        elif self.solver is PHOTOCURRENT_PC_SOLVER:
+            nb_solver = [1,1,0,0]
+            nb_func = [1,0,0]
+        elif self.solver is ROUCHON_SOLVER:
+            nb_solver = [2,0,0,0]
+        elif self.solver is EXPLICIT1_5_SOLVER:
+            nb_solver = [5,8,3,0]
+        elif self.solver is TAYLOR1_5_SOLVER:
+            nb_solver = [2,3,1,1]
+        elif self.solver is TAYLOR1_5_IMP_SOLVER:
+            nb_solver = [2,3,1,1]
+        elif self.solver is TAYLOR2_0_SOLVER:
+            nb_solver = [11,0,0,0]
+
+        if self.solver in [PC_SOLVER, MILSTEIN_SOLVER, MILSTEIN_IMP_SOLVER,
+                           PC_2_SOLVER, TAYLOR1_5_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+          if sso.me:
+            nb_func = [1,0,0]
+            nb_expect = [1,1,0]
+          else:
+            nb_func = [2,1,1]
+            nb_expect = [2,1,1]
+        elif self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER]:
+            nb_expect = [1,0,0]
+        elif self.solver is TAYLOR2_0_SOLVER:
+          if sso.me:
+            nb_func = [2,0,0]
+            nb_expect = [2,0,0]
+          else:
+            nb_func = [14,0,0]
+            nb_expect = [0,0,0]
+        elif self.solver is ROUCHON_SOLVER:
+            nb_expect = [1,0,0]
+        else:
+          if not sso.me:
+            nb_func = [1,0,0]
+
+        self.buffer_1d = np.zeros((nb_solver[0], self.l_vec), dtype=complex)
+        self.buffer_2d = np.zeros((nb_solver[1], self.num_ops, self.l_vec),
+                                  dtype=complex)
+        self.buffer_3d = np.zeros((nb_solver[2], self.num_ops, self.num_ops, self.l_vec),
+                                        dtype=complex)
+        if nb_solver[3]:
+          self.buffer_4d = np.zeros((self.num_ops, self.num_ops, self.num_ops, self.l_vec),
+                                        dtype=complex)
+
+        self.expect_buffer_1d = np.zeros((nb_expect[0], self.num_ops), dtype=complex)
+        if nb_expect[1]:
+          self.expect_buffer_2d = np.zeros((self.num_ops, self.num_ops), dtype=complex)
+        if nb_expect[2]:
+          self.expect_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.num_ops), dtype=complex)
+
+        self.func_buffer_1d = np.zeros((nb_func[0], self.l_vec), dtype=complex)
+        if nb_func[1]:
+          self.func_buffer_2d = np.zeros((self.num_ops, self.l_vec), dtype=complex)
+        if nb_func[2]:
+          self.func_buffer_3d = np.zeros((self.num_ops, self.num_ops, self.l_vec), dtype=complex)
+
+        self.noise_type = sso.noise_type
+        self.dW_factor = np.array(sso.dW_factors, dtype=np.float64)
+        if self.noise_type == 1:
+            self.custom_noise = sso.noise
+        elif self.noise_type == 0:
+            self.seed = sso.noise
+
+    def set_data(self, sso):
+        """Set solver specific operator"""
+        pass
+
+    cdef np.ndarray[double, ndim=3] make_noise(self, int n):
+        """Create the random numbers for the stochastic process"""
+        if self.solver in [PHOTOCURRENT_SOLVER, PHOTOCURRENT_PC_SOLVER] and self.noise_type == 0:
+            # photocurrent, just seed,
+            np.random.seed(self.seed[n])
+            return np.zeros((self.num_step, self.num_substeps, self.num_dw))
+        if self.noise_type == 0:
+            np.random.seed(self.seed[n])
+            return np.random.randn(self.num_step, self.num_substeps, self.num_dw) *\
+                                   np.sqrt(self.dt)
+        elif self.noise_type == 1:
+            return self.custom_noise[n,:,:,:]
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    def cy_sesolve_single_trajectory(self, int n):
+        """ Run the one of the trajectories of the stochastic system.
+
+        Parameters
+        ----------
+        n : int
+            Number of the iterations
+
+        sso : StochasticSolverOptions
+            Data of the stochastic system
+
+        Returns
+        -------
+        states_list : list of qobj
+            State of the system at each time
+
+        noise : array
+            noise at each step of the solver
+
+        measurements : array
+            measurements value at each timestep for each m_ops
+
+        expect : array
+            expectation value at each timestep for each e_ops
+
+        """
+        sso = self.sso
+        cdef double[::1] times = sso.times
+        cdef complex[::1] rho_t
+        cdef double t
+        cdef int m_idx, t_idx, e_idx
+        cdef np.ndarray[double, ndim=3] noise = self.make_noise(n)
+        cdef int tlast = times.shape[0]
+
+        rho_t = sso.rho0.copy()
+        dims = sso.state0.dims
+
+        expect = np.zeros((len(sso.ce_ops), len(sso.times)), dtype=complex)
+        measurements = np.zeros((len(times), len(sso.cm_ops)), dtype=complex)
+        states_list = []
+        for t_idx, t in enumerate(times):
+            PyErr_CheckSignals()
+            if sso.ce_ops:
+                for e_idx, e in enumerate(sso.ce_ops):
+                    s = e.expect_data(t, _dense_wrap(rho_t))
+                    expect[e_idx, t_idx] = s
+            if sso.store_states or not sso.ce_ops:
+                if sso.me:
+                    states_list.append(Qobj(unstack_columns(np.asarray(rho_t)),
+                        dims=dims))
+                else:
+                    states_list.append(Qobj(np.asarray(rho_t), dims=dims))
+
+            if t_idx != tlast-1:
+                rho_t = self.run(t, self.dt, noise[t_idx, :, :],
+                                 rho_t, self.num_substeps)
+
+            if sso.store_measurement:
+                for m_idx, m in enumerate(sso.cm_ops):
+                    m_expt = m.expect_data(t, _dense_wrap(rho_t))
+                    measurements[t_idx, m_idx] = m_expt + self.dW_factor[m_idx] * \
+                        sum(noise[t_idx, :, m_idx]) / (self.dt * self.num_substeps)
+
+        if sso.method == 'heterodyne':
+            measurements = measurements.reshape(len(times), len(sso.cm_ops)//2, 2)
+
+        return states_list, noise, measurements, expect
+
+    @cython.boundscheck(False)
+    cdef complex[::1] run(self, double t, double dt, double[:, ::1] noise,
+                          complex[::1] vec, int num_substeps):
+        """ Do one time full step"""
+        cdef complex[::1] out = np.zeros(self.l_vec, dtype=complex)
+        cdef int i
+        if self.solver is EULER_SOLVER:
+            for i in range(num_substeps):
+                self.euler(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PHOTOCURRENT_SOLVER:
+            for i in range(num_substeps):
+                self.photocurrent(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PLATEN_SOLVER:
+            for i in range(num_substeps):
+                self.platen(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PC_SOLVER:
+            for i in range(num_substeps):
+                self.pred_corr(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is MILSTEIN_SOLVER:
+            for i in range(num_substeps):
+                self.milstein(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is MILSTEIN_IMP_SOLVER:
+            for i in range(num_substeps):
+                self.milstein_imp(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PC_2_SOLVER:
+            for i in range(num_substeps):
+                self.pred_corr_a(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is PHOTOCURRENT_PC_SOLVER:
+            for i in range(num_substeps):
+                self.photocurrent_pc(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is ROUCHON_SOLVER:
+            for i in range(num_substeps):
+                self.rouchon(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is EXPLICIT1_5_SOLVER:
+            for i in range(num_substeps):
+                self.platen15(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is TAYLOR1_5_SOLVER:
+            for i in range(num_substeps):
+                self.taylor15(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is TAYLOR1_5_IMP_SOLVER:
+            for i in range(num_substeps):
+                self.taylor15_imp(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        elif self.solver is TAYLOR2_0_SOLVER:
+            for i in range(num_substeps):
+                self.taylor20(t + i*dt, dt, noise[i, :], vec, out)
+                out, vec = vec, out
+
+        if self.normalize:
+            self._normalize_inplace(vec)
+        return vec
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_inplace(vec)
+
+    # Dummy functions
+    # Needed for compilation since ssesolve is not stand-alone
+    cdef void d1(self, double t, complex[::1] v, complex[::1] out):
+        """ deterministic part of the evolution
+        depend on schrodinger vs master vs photocurrent
+        """
+        pass
+
+    cdef void d2(self, double t, complex[::1] v, complex[:, ::1] out):
+        """ stochastic part of the evolution
+        depend on schrodinger vs master vs photocurrent
+        """
+        pass
+
+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+                       complex[::1] out, np.ndarray[complex, ndim=1] guess) except *:
+        """ Do the step X(t+dt) = f(X(t+dt)) + g(X(t)) """
+        pass
+
+    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+                              complex[::1] a, complex[:, ::1] b,
+                              complex[:, :, ::1] Lb, complex[:,::1] La,
+                              complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+                              complex[::1] L0a):
+        """ Obtain the multiple terms for stochastic taylor expension
+        Up to order 1.5
+        multiple sc_ops
+        """
+        pass
+
+    cdef void derivativesO2(self, double t, complex[::1] rho,
+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+                            complex[::1] L0a,
+                            complex[::1] LLa, complex[::1] LL0b,
+                            complex[::1] L0Lb, complex[::1] LLLb):
+        """ Obtain the multiple terms for stochastic taylor expension
+        Up to order 2.0
+        One sc_ops
+        """
+        pass
+
+    cdef void photocurrent(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        """Special integration scheme:
+        photocurrent collapse + euler evolution
+        """
+        pass
+
+    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        """Special integration scheme:
+        photocurrent collapse + predictor-corrector evolution
+        """
+        pass
+
+    cdef void rouchon(self, double t, double dt, double[:] noise,
+                      complex[::1] vec, complex[::1] out):
+        """Special integration scheme:
+        Force valid density matrix using positive map
+        Pierre Rouchon, Jason F. Ralph
+        arXiv:1410.5345 [quant-ph]
+        """
+        pass
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void euler(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """Integration scheme:
+        Basic Euler order 0.5
+        dV = d1 dt + d2_i dW_i
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i, j
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        _zero_2d(d2)
+        copy(vec, out)
+        self.d1(t, vec, out)
+        self.d2(t, vec, d2)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void platen(self, double t, double dt, double[:] noise,
+                       complex[::1] vec, complex[::1] out):
+        """
+        Platen rhs function for both master eq and schrodinger eq.
+        dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
+             + (2*d2_i(V)+d2_i(V+)+d2_i(V-))/4 * dW_i
+             + (d2_i(V+)-d2_i(V-))/4 * (dW_i**2 -dt) * dt**(-.5)
+
+        Vt = V -iH*V*dt + d1*dt + d2_i*dW_i
+        V+/- = V -iH*V*dt + d1*dt +/- d2_i*dt**.5
+        The Theory of Open Quantum Systems
+        Chapter 7 Eq. (7.47), H.-P Breuer, F. Petruccione
+        """
+        cdef int i, j, k
+        cdef double sqrt_dt = np.sqrt(dt)
+        cdef double sqrt_dt_inv = 0.25/sqrt_dt
+        cdef double dw, dw2
+        cdef complex[::1] d1 = self.buffer_1d[0,:]
+        cdef complex[::1] Vt = self.buffer_1d[1,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, ::1] Vm = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] Vp = self.buffer_2d[2,:,:]
+        cdef complex[:, ::1] d2p = self.buffer_2d[3,:,:]
+        cdef complex[:, ::1] d2m = self.buffer_2d[4,:,:]
+        _zero(d1)
+        _zero_2d(d2)
+
+        self.d1(t, vec, d1)
+        self.d2(t, vec, d2)
+        _axpy(1.0,vec,d1)
+        copy(d1,Vt)
+        copy(d1,out)
+        _scale(0.5,out)
+        for i in range(self.num_ops):
+            copy(d1,Vp[i,:])
+            copy(d1,Vm[i,:])
+            _axpy( sqrt_dt,d2[i,:],Vp[i,:])
+            _axpy(-sqrt_dt,d2[i,:],Vm[i,:])
+            _axpy(noise[i],d2[i,:],Vt)
+        _zero(d1)
+        self.d1(t, Vt, d1)
+        _axpy(0.5,d1,out)
+        _axpy(0.5,vec,out)
+        for i in range(self.num_ops):
+            _zero_2d(d2p)
+            _zero_2d(d2m)
+            self.d2(t, Vp[i,:], d2p)
+            self.d2(t, Vm[i,:], d2m)
+            dw = noise[i] * 0.25
+            _axpy(dw,d2m[i,:],out)
+            _axpy(2*dw,d2[i,:],out)
+            _axpy(dw,d2p[i,:],out)
+            for j in range(self.num_ops):
+                if i == j:
+                    dw2 = sqrt_dt_inv * (noise[i]*noise[i] - dt)
+                else:
+                    dw2 = sqrt_dt_inv * noise[i] * noise[j]
+                _axpy(dw2,d2p[j,:],out)
+                _axpy(-dw2,d2m[j,:],out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void pred_corr(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 15.5 Eq. (5.4)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        # a=0. b=0.5
+        cdef double dt_2 = dt*0.5
+        cdef complex[::1] euler = self.buffer_1d[0,:]
+        cdef complex[::1] a_pred = self.buffer_1d[1,:]
+        cdef complex[::1] b_pred = self.buffer_1d[2,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero(a_pred)
+        _zero(b_pred)
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
+        copy(vec, euler)
+        copy(vec, out)
+        _axpy(1.0, a_pred, euler)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], b_pred)
+            _axpy(-dt_2, dd2[i,i,:], a_pred)
+        _axpy(1.0, a_pred, out)
+        _axpy(1.0, b_pred, euler)
+        _axpy(0.5, b_pred, out)
+        _zero_2d(d2)
+        self.d2(t + dt, euler, d2)
+        for i in range(self.num_ops):
+            _axpy(noise[i]*0.5, d2[i,:], out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void pred_corr_a(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 15.5 Eq. (5.4)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        # a=0.5, b=0.5
+        cdef int i, j, k
+        cdef complex[::1] euler = self.buffer_1d[0,:]
+        cdef complex[::1] a_pred = self.buffer_1d[1,:]
+        _zero(a_pred)
+        cdef complex[::1] a_corr = self.buffer_1d[2,:]
+        _zero(a_corr)
+        cdef complex[::1] b_pred = self.buffer_1d[3,:]
+        _zero(b_pred)
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        _zero_2d(d2)
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero_3d(dd2)
+
+        cdef double dt_2 = dt*0.5
+        self.derivatives(t, 1, vec, a_pred, d2, dd2, None, None, None, None)
+        copy(vec, euler)
+        _axpy(1.0, a_pred, euler)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], b_pred)
+            _axpy(-dt_2, dd2[i,i,:], a_pred)
+        _axpy(1.0, b_pred, euler)
+        copy(vec, out)
+        _axpy(0.5, a_pred, out)
+        _axpy(0.5, b_pred, out)
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        self.derivatives(t, 1, euler, a_corr, d2, dd2, None, None, None, None)
+        for i in range(self.num_ops):
+            _axpy(noise[i]*0.5, d2[i,:], out)
+            _axpy(-dt_2, dd2[i,i,:], a_corr)
+        _axpy(0.5, a_corr, out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void milstein(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 10.3 Eq. (3.1)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+
+        dV = -iH*V*dt + d1*dt + d2_i*dW_i
+             + 0.5*d2_i' d2_j*(dW_i*dw_j -dt*delta_ij)
+        """
+        cdef int i, j, k
+        cdef double dw
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        copy(vec,out)
+        self.derivatives(t, 1, vec, out, d2, dd2, None, None, None, None)
+        for i in range(self.num_ops):
+            _axpy(noise[i],d2[i,:],out)
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                if (i == j):
+                    dw = (noise[i] * noise[i] - dt) * 0.5
+                else:
+                    dw = (noise[i] * noise[j])
+                _axpy(dw,dd2[i,j,:],out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void milstein_imp(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out) except *:
+        """
+        Chapter 12.2 Eq. (2.9)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i, j, k
+        cdef double dw
+        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
+                                                          dtype=complex)
+        cdef np.ndarray[complex, ndim=1] dvec = np.zeros((self.l_vec, ),
+                                                         dtype=complex)
+        cdef complex[::1] a = self.buffer_1d[0,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, :, ::1] dd2 = self.buffer_3d[0,:,:,:]
+        _zero(a)
+        _zero_2d(d2)
+        _zero_3d(dd2)
+        self.derivatives(t, 1, vec, a, d2, dd2, None, None, None, None)
+        copy(vec, dvec)
+        _axpy(0.5, a, dvec)
+        for i in range(self.num_ops):
+            _axpy(noise[i], d2[i,:], dvec)
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                if (i == j):
+                    dw = (noise[i] * noise[i] - dt) * 0.5
+                else:
+                    dw = (noise[i] * noise[j])
+                _axpy(dw, dd2[i,j,:], dvec)
+        copy(dvec, guess)
+        _axpy(0.5, a, guess)
+        self.implicit(t+dt, dvec, out, guess)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void taylor15(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        """
+        Chapter 12.2 Eq. (2.18),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef complex[::1] a = self.buffer_1d[0, :]
+        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
+        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
+        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
+        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
+        cdef complex[::1] L0a = self.buffer_1d[1, :]
+        _zero(a)
+        _zero_2d(b)
+        _zero_3d(Lb)
+        _zero_2d(L0b)
+        _zero_2d(La)
+        _zero_4d(LLb)
+        _zero(L0a)
+        self.derivatives(t, 2, vec, a, b, Lb, La, L0b, LLb, L0a)
+
+        cdef int i,j,k
+        cdef double[::1] dz, dw
+        dw = np.empty(self.num_ops)
+        dz = np.empty(self.num_ops)
+        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
+        for i in range(self.num_ops):
+            dw[i] = noise[i]
+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+        copy(vec,out)
+        _axpy(1.0, a, out)
+        _axpy(0.5, L0a, out)
+
+        for i in range(self.num_ops):
+            _axpy(dw[i], b[i,:], out)
+            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], out)
+            _axpy(dz[i], La[i,:], out)
+            _axpy(dw[i]-dz[i], L0b[i,:], out)
+            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
+                        LLb[i,i,i,:], out)
+            for j in range(i+1,self.num_ops):
+                _axpy((dw[i]*dw[j]), Lb[i,j,:], out)
+                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], out)
+                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], out)
+                for k in range(j+1,self.num_ops):
+                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void taylor15_imp(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out) except *:
+        """
+        Chapter 12.2 Eq. (2.18),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef complex[::1] a = self.buffer_1d[0, :]
+        cdef complex[:, ::1] b = self.buffer_2d[0, :, :]
+        cdef complex[:, :, ::1] Lb = self.buffer_3d[0, :, :, :]
+        cdef complex[:, ::1] L0b = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] La = self.buffer_2d[2,:,:]
+        cdef complex[:, :, :, ::1] LLb = self.buffer_4d[:, :, :, :]
+        cdef complex[::1] L0a = self.buffer_1d[1, :]
+        _zero(a)
+        _zero_2d(b)
+        _zero_3d(Lb)
+        _zero_2d(L0b)
+        _zero_2d(La)
+        _zero_4d(LLb)
+        _zero(L0a)
+        cdef np.ndarray[complex, ndim=1] guess = np.zeros((self.l_vec, ),
+                   dtype=complex)
+        cdef np.ndarray[complex, ndim=1] vec_t = np.zeros((self.l_vec, ),
+                  dtype=complex)
+        self.derivatives(t, 3, vec, a, b, Lb, La, L0b, LLb, L0a)
+
+        cdef int i,j,k
+        cdef double[::1] dz, dw
+        dw = np.empty(self.num_ops)
+        dz = np.empty(self.num_ops)
+        # The dt of dz is included in the d1 part (Ldt) and the noise (dt**.5)
+        for i in range(self.num_ops):
+            dw[i] = noise[i]
+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+        copy(vec, vec_t)
+        _axpy(0.5, a, vec_t)
+        for i in range(self.num_ops):
+            _axpy(dw[i], b[i,:], vec_t)
+            _axpy(0.5*(dw[i]*dw[i]-dt), Lb[i,i,:], vec_t)
+            _axpy(dz[i]-dw[i]*0.5, La[i,:], vec_t)
+            _axpy(dw[i]-dz[i] , L0b[i,:], vec_t)
+            _axpy(0.5 * ((1/3.) * dw[i] * dw[i] - dt) * dw[i],
+                        LLb[i,i,i,:], vec_t)
+            for j in range(i+1,self.num_ops):
+                _axpy((dw[i]*dw[j]), Lb[i,j,:], vec_t)
+                _axpy(0.5*(dw[j]*dw[j]-dt)*dw[i], LLb[i,j,j,:], vec_t)
+                _axpy(0.5*(dw[i]*dw[i]-dt)*dw[j], LLb[i,i,j,:], vec_t)
+                for k in range(j+1,self.num_ops):
+                    _axpy(dw[i]*dw[j]*dw[k], LLb[i,j,k,:], vec_t)
+        copy(vec_t, guess)
+        _axpy(0.5, a, guess)
+
+        self.implicit(t+dt, vec_t, out, guess)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void platen15(self, double t, double dt, double[:] noise,
+                    complex[::1] vec, complex[::1] out):
+        """
+        Chapter 11.2 Eq. (2.13)
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef int i, j, k
+        cdef double sqrt_dt = np.sqrt(dt)
+        cdef double sqrt_dt_inv = 1./sqrt_dt
+        cdef double ddz, ddw, ddd
+        cdef double[::1] dz, dw
+        dw = np.empty(self.num_ops)
+        dz = np.empty(self.num_ops)
+        for i in range(self.num_ops):
+            dw[i] = noise[i]
+            dz[i] = 0.5 *(noise[i] + 1./np.sqrt(3) * noise[i+self.num_ops])
+
+        cdef complex[::1] d1 = self.buffer_1d[0,:]
+        cdef complex[::1] d1p = self.buffer_1d[1,:]
+        cdef complex[::1] d1m = self.buffer_1d[2,:]
+        cdef complex[::1] V = self.buffer_1d[3,:]
+        cdef complex[:, ::1] d2 = self.buffer_2d[0,:,:]
+        cdef complex[:, ::1] dd2 = self.buffer_2d[1,:,:]
+        cdef complex[:, ::1] d2p = self.buffer_2d[2,:,:]
+        cdef complex[:, ::1] d2m = self.buffer_2d[3,:,:]
+        cdef complex[:, ::1] d2pp = self.buffer_2d[4,:,:]
+        cdef complex[:, ::1] d2mm = self.buffer_2d[5,:,:]
+        cdef complex[:, ::1] v2p = self.buffer_2d[6,:,:]
+        cdef complex[:, ::1] v2m = self.buffer_2d[7,:,:]
+        cdef complex[:, :, ::1] p2p = self.buffer_3d[0,:,:,:]
+        cdef complex[:, : ,::1] p2m = self.buffer_3d[1,:,:,:]
+
+        _zero(d1)
+        _zero_2d(d2)
+        _zero_2d(dd2)
+        self.d1(t, vec, d1)
+        self.d2(t, vec, d2)
+        self.d2(t + dt, vec, dd2)
+        # Euler part
+        copy(vec,out)
+        _axpy(1., d1, out)
+        for i in range(self.num_ops):
+            _axpy(dw[i], d2[i,:], out)
+
+        _zero(V)
+        _axpy(1., vec, V)
+        _axpy(1./self.num_ops, d1, V)
+
+        _zero_2d(v2p)
+        _zero_2d(v2m)
+        for i in range(self.num_ops):
+            _axpy(1., V, v2p[i,:])
+            _axpy(sqrt_dt, d2[i,:], v2p[i,:])
+            _axpy(1., V, v2m[i,:])
+            _axpy(-sqrt_dt, d2[i,:], v2m[i,:])
+
+        _zero_3d(p2p)
+        _zero_3d(p2m)
+        for i in range(self.num_ops):
+            _zero_2d(d2p)
+            _zero_2d(d2m)
+            self.d2(t, v2p[i,:], d2p)
+            self.d2(t, v2m[i,:], d2m)
+            ddw = (dw[i]*dw[i]-dt)*0.25/sqrt_dt  # 1.0
+            _axpy( ddw, d2p[i,:], out)
+            _axpy(-ddw, d2m[i,:], out)
+            for j in range(self.num_ops):
+                _axpy(      1., v2p[i,:], p2p[i,j,:])
+                _axpy( sqrt_dt, d2p[j,:], p2p[i,j,:])
+                _axpy(      1., v2p[i,:], p2m[i,j,:])
+                _axpy(-sqrt_dt, d2p[j,:], p2m[i,j,:])
+
+        _axpy(-0.5*(self.num_ops), d1, out)
+        for i in range(self.num_ops):
+            ddz = dz[i]*0.5/sqrt_dt  # 1.5
+            ddd = 0.25*(dw[i]*dw[i]/3-dt)*dw[i]/dt  # 1.5
+            _zero(d1p)
+            _zero(d1m)
+            _zero_2d(d2m)
+            _zero_2d(d2p)
+            _zero_2d(d2pp)
+            _zero_2d(d2mm)
+            self.d1(t + dt/self.num_ops, v2p[i,:], d1p)
+            self.d1(t + dt/self.num_ops, v2m[i,:], d1m)
+            self.d2(t, v2p[i,:], d2p)
+            self.d2(t, v2m[i,:], d2m)
+            self.d2(t, p2p[i,i,:], d2pp)
+            self.d2(t, p2m[i,i,:], d2mm)
+
+            _axpy( ddz+0.25, d1p, out)
+            _axpy(-ddz+0.25, d1m, out)
+
+            _axpy((dw[i]-dz[i]), dd2[i,:], out)
+            _axpy((dz[i]-dw[i]), d2[i,:], out)
+
+            _axpy( ddd, d2pp[i,:], out)
+            _axpy(-ddd, d2mm[i,:], out)
+            _axpy(-ddd, d2p[i,:], out)
+            _axpy( ddd, d2m[i,:], out)
+
+            for j in range(self.num_ops):
+              ddw = 0.5*(dw[j]-dz[j]) # 1.5
+              _axpy(ddw, d2p[j,:], out)
+              _axpy(-2*ddw, d2[j,:], out)
+              _axpy(ddw, d2m[j,:], out)
+
+              if j>i:
+                ddw = 0.5*(dw[i]*dw[j])/sqrt_dt # 1.0
+                _axpy( ddw, d2p[j,:], out)
+                _axpy(-ddw, d2m[j,:], out)
+
+                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
+                _zero_2d(d2pp)
+                _zero_2d(d2mm)
+                self.d2(t, p2p[j,i,:], d2pp)
+                self.d2(t, p2m[j,i,:], d2mm)
+                _axpy( ddw, d2pp[j,:], out)
+                _axpy(-ddw, d2mm[j,:], out)
+                _axpy(-ddw, d2p[j,:], out)
+                _axpy( ddw, d2m[j,:], out)
+
+                for k in range(j+1,self.num_ops):
+                    ddw = 0.5*dw[i]*dw[j]*dw[k]/dt # 1.5
+                    _axpy( ddw, d2pp[k,:], out)
+                    _axpy(-ddw, d2mm[k,:], out)
+                    _axpy(-ddw, d2p[k,:], out)
+                    _axpy( ddw, d2m[k,:], out)
+
+              if j<i:
+                ddw = 0.25*(dw[j]*dw[j]-dt)*dw[i]/dt # 1.5
+                _zero_2d(d2pp)
+                _zero_2d(d2mm)
+                self.d2(t, p2p[j,i,:], d2pp)
+                self.d2(t, p2m[j,i,:], d2mm)
+                _axpy( ddw, d2pp[j,:], out)
+                _axpy(-ddw, d2mm[j,:], out)
+                _axpy(-ddw, d2p[j,:], out)
+                _axpy( ddw, d2m[j,:], out)
+
+    @cython.wraparound(False)
+    @cython.boundscheck(False)
+    @cython.cdivision(True)
+    cdef void taylor20(self, double t, double dt, double[::1] noise,
+                           complex[::1] vec, complex[::1] out):
+        """
+        Chapter 10.5 Eq. (5.1),
+        Numerical Solution of Stochastic Differential Equations
+        By Peter E. Kloeden, Eckhard Platen
+        """
+        cdef double[::1] noises = np.empty(5)
+        cdef double dwn
+        self.order2noise.order2(noise,noises)
+        cdef complex[::1] a = self.buffer_1d[0, :]
+        cdef complex[::1] b = self.buffer_1d[1, :]
+        cdef complex[::1] Lb = self.buffer_1d[2, :]
+        cdef complex[::1] La = self.buffer_1d[3, :]
+        cdef complex[::1] L0b = self.buffer_1d[4, :]
+        cdef complex[::1] LLb = self.buffer_1d[5, :]
+        cdef complex[::1] L0a = self.buffer_1d[6, :]
+        cdef complex[::1] LLa = self.buffer_1d[7, :]
+        cdef complex[::1] LL0b = self.buffer_1d[8, :]
+        cdef complex[::1] L0Lb = self.buffer_1d[9, :]
+        cdef complex[::1] LLLb = self.buffer_1d[10, :]
+        _zero(a)
+        _zero(b)
+        _zero(Lb)
+        _zero(La)
+        _zero(L0b)
+        _zero(LLb)
+        _zero(L0a)
+        _zero(LLa)
+        _zero(LL0b)
+        _zero(L0Lb)
+        _zero(LLLb)
+        self.derivativesO2(t, vec, a, b, Lb, La, L0b, LLb,
+                           L0a, LLa, LL0b, L0Lb, LLLb)
+
+        copy(vec,out)
+        _axpy(1.0, a, out)
+
+        _axpy(noises[0], b, out)
+        dwn = noises[0]*noises[0]*0.5
+        _axpy(dwn, Lb, out)
+
+        _axpy(noises[1], La, out)
+        _axpy(noises[0]-noises[1], L0b, out)
+        dwn *= noises[0]*(1/3.)
+        _axpy(dwn, LLb, out)
+        _axpy(0.5, L0a, out)
+
+        _axpy(noises[2], L0Lb, out)
+        _axpy(noises[3], LL0b, out)
+        _axpy(noises[4], LLa, out)
+        dwn *= noises[0]*0.25
+        _axpy(dwn, LLLb, out)
+
+
+cdef class SSESolver(StochasticSolver):
+    """stochastic Schrodinger system"""
+    cdef QobjEvo L
+    cdef object c_ops
+    cdef object cpcd_ops
+    cdef object imp
+    cdef double tol, imp_t
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.c_ops = []
+        self.cpcd_ops = []
+        for i, op in enumerate(c_ops):
+            self.c_ops.append(op[0])
+            self.cpcd_ops.append(op[1])
+        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+            self.tol = sso.tol
+            self.imp = LinearOperator( (self.l_vec,self.l_vec),
+                                      matvec=self.implicit_op, dtype=complex)
+
+    def implicit_op(self, vec):
+        cdef np.ndarray[complex, ndim=1] out = np.zeros(self.l_vec, dtype=complex)
+        self.d1(self.imp_t, vec, out)
+        cdef int i
+        _scale(-0.5,out)
+        _axpy(1.,vec,out)
+        return out
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+        self.L.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out))
+        cdef int i
+        cdef complex e
+        cdef QobjEvo c_op
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        _zero(temp)
+        for i in range(self.num_ops):
+            c_op = self.cpcd_ops[i]
+            e = c_op.expect_data(t, _dense_wrap(vec))
+            _zero(temp)
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(temp))
+            _axpy(-0.125 * e * e * self.dt, vec, out)
+            _axpy(0.5 * e * self.dt, temp, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+        cdef int i, k
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), out=_dense_wrap(out[i, :]))
+            c_op = self.cpcd_ops[i]
+            expect = c_op.expect_data(t, _dense_wrap(vec))
+            _axpy(-0.5*expect,vec,out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivatives(self, double t, int deg, complex[::1] vec,
+                          complex[::1] a, complex[:, ::1] b,
+                          complex[:, :, ::1] Lb, complex[:,::1] La,
+                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+                          complex[::1] L0a):
+        """
+        combinaisons of a and b derivatives for taylor order 1.5
+        dY ~ a dt + bi dwi
+                                         deg   use        noise
+        b[i.:]       bi                   >=0   d2 euler   dwi
+        a[:]         a                    >=0   d1 euler   dt
+        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
+        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
+
+        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
+        La[i,:]      ba'                  >=2   taylor15   dzi
+        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
+        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
+        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
+        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
+        """
+        cdef int i, j, k, l
+        cdef double dt = self.dt
+        cdef QobjEvo c_op
+        cdef complex e, de_bb
+
+        cdef complex[::1] e_real = self.expect_buffer_1d[0,:]
+        cdef complex[:, ::1] de_b = self.expect_buffer_2d[:,:]
+        cdef complex[::1] de_a = self.expect_buffer_1d[1,:]
+        cdef complex[:, :, ::1] dde_bb = self.expect_buffer_3d[:,:,:]
+        _zero_3d(dde_bb)
+        cdef complex[:, ::1] Cvec = self.func_buffer_2d[:,:]
+        cdef complex[:, :, ::1] Cb = self.func_buffer_3d[:,:,:]
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
+        _zero(temp)
+        _zero(temp2)
+        _zero_2d(Cvec)
+        _zero_3d(Cb)
+
+        # a b
+        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(a))
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(Cvec[i, :]))
+            e = _dotc(vec,Cvec[i,:])
+            e_real[i] = e.real
+            _axpy(1., Cvec[i,:], b[i,:])
+            _axpy(-e_real[i], vec, b[i,:])
+            _axpy(-0.5 * e_real[i] * e_real[i] * dt, vec, a[:])
+            _axpy(e_real[i] * dt, Cvec[i,:], a[:])
+
+        #Lb bb'
+        if deg >= 1:
+          for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            for j in range(self.num_ops):
+              c_op.matmul_data(t, _dense_wrap(b[j, :]), _dense_wrap(Cb[i,j,:]))
+              for k in range(self.l_vec):
+                  temp[k] = conj(b[j,k])
+                  temp2[k] = 0.
+              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+              de_b[i,j] = (_dotc(vec, Cb[i,j,:]) + _dot(b[j,:], Cvec[i,:]) + \
+                          conj(_dotc(b[j,:], Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
+              _axpy(1., Cb[i,j,:], Lb[i,j,:])
+              _axpy(-e_real[i], b[j,:], Lb[i,j,:])
+              _axpy(-de_b[i,j], vec, Lb[i,j,:])
+
+              for k in range(self.num_ops):
+                dde_bb[i,j,k] += (_dot(b[j,:], Cb[i,k,:]) + \
+                                  _dot(b[k,:], Cb[i,j,:]) + \
+                                  conj(_dotc(b[k,:], temp2)))*.5
+                dde_bb[i,k,j] += conj(_dotc(b[k,:], temp2))*.5
+
+        #L0b La LLb
+        if deg >= 2:
+          for i in range(self.num_ops):
+              #ba'
+              self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
+              for j in range(self.num_ops):
+                  _axpy(-0.5 * e_real[j] * e_real[j] * dt, b[i,:], La[i,:])
+                  _axpy(-e_real[j] * de_b[i,j] * dt, vec, La[i,:])
+                  _axpy(e_real[j] * dt, Cb[i,j,:], La[i,:])
+                  _axpy(de_b[i,j] * dt, Cvec[i,:], La[i,:])
+
+              #ab' + db/dt + bbb"/2
+              c_op = self.c_ops[i]
+              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b[i,:]))
+              for k in range(self.l_vec):
+                  temp[k] = conj(a[k])
+                  temp2[k] = 0.
+              c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+              de_a[i] = (_dotc(vec, L0b[i,:]) + _dot(a, Cvec[i,:]) + \
+                        conj(_dotc(a, Cvec[i,:]) + _dotc(vec, temp2))) * 0.5
+              _axpy(-e_real[i], a, L0b[i,:])
+              _axpy(-de_a[i], vec, L0b[i,:])
+
+              temp = np.zeros(self.l_vec, dtype=complex)
+              c_op.matmul_data(t + self.dt, _dense_wrap(vec), _dense_wrap(temp))
+              e = _dotc(vec,temp)
+              _axpy(1., temp, L0b[i,:])
+              _axpy(-e.real, vec, L0b[i,:])
+              _axpy(-1., b[i,:], L0b[i,:])
+
+              for j in range(self.num_ops):
+                  _axpy(-de_b[i,j]*dt, b[j,:], L0b[i,:])
+                  _axpy(-dde_bb[i,j,j]*dt, vec, L0b[i,:])
+
+              #b(bb"+b'b')
+              for j in range(i,self.num_ops):
+                  for k in range(j, self.num_ops):
+                      c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]),
+                                  _dense_wrap(LLb[i,j,k,:]))
+                      for l in range(self.l_vec):
+                          temp[l] = conj(Lb[j,k,l])
+                          temp2[l] = 0.
+                      c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+                      de_bb = (_dotc(vec, LLb[i,j,k,:]) + \
+                               _dot(Lb[j,k,:], Cvec[i,:]) + \
+                               conj(_dotc(Lb[j,k,:], Cvec[i,:]) +\
+                               _dotc(vec, temp2)))*0.5
+                      _axpy(-e_real[i], Lb[j,k,:], LLb[i,j,k,:])
+                      _axpy(-de_bb, vec, LLb[i,j,k,:])
+                      _axpy(-dde_bb[i,j,k], vec, LLb[i,j,k,:])
+                      _axpy(-de_b[i,j], b[k,:], LLb[i,j,k,:])
+                      _axpy(-de_b[i,k], b[j,:], LLb[i,j,k,:])
+
+        #da/dt + aa' + bba"
+        if deg == 2:
+          self.d1(t + dt, vec, L0a)
+          _axpy(-1.0, a, L0a)
+          self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+          for j in range(self.num_ops):
+              c_op = self.c_ops[j]
+              temp = np.zeros(self.l_vec, dtype=complex)
+              c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
+              _axpy(-0.5 * e_real[j] * e_real[j] * dt, a[:], L0a[:])
+              _axpy(-e_real[j] * de_a[j] * dt, vec, L0a[:])
+              _axpy(e_real[j] * dt, temp, L0a[:])
+              _axpy(de_a[j] * dt, Cvec[j,:], L0a[:])
+              for i in range(self.num_ops):
+                  _axpy(-0.5*(e_real[i] * dde_bb[i,j,j] +
+                          de_b[i,j] * de_b[i,j]) * dt * dt, vec, L0a[:])
+                  _axpy(-e_real[i] * de_b[i,j] * dt * dt, b[j,:], L0a[:])
+                  _axpy(0.5*dde_bb[i,j,j] * dt * dt, Cvec[i,:], L0a[:])
+                  _axpy(de_b[i,j] * dt * dt, Cb[i,j,:], L0a[:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void _c_vec_conj(self, double t, QobjEvo c_op,
+                         complex[::1] vec, complex[::1] out):
+        cdef int k
+        cdef complex[::1] temp = self.func_buffer_1d[13,:]
+        for k in range(self.l_vec):
+            temp[k] = conj(vec[k])
+            out[k] = 0.
+        c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivativesO2(self, double t, complex[::1] psi,
+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+                            complex[::1] L0a,
+                            complex[::1] LLa, complex[::1] LL0b,
+                            complex[::1] L0Lb, complex[::1] LLLb):
+        """
+        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
+        Use Stratonovich-Taylor expansion.
+        One one sc_ops
+        dY ~ a dt + bi dwi
+
+        b[:]     b                        d2 euler    dw
+        a[:]     a- Lb/2                  d1 euler    dt
+        Lb[:]    b'b                      milstein    dw^2/2
+        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
+        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
+        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
+        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
+
+        LLa[:]   ...                      taylor2.0   dwdt-dz
+        LL0b[:]  ...                      taylor2.0   dz
+        L0Lb[:]  ...                      taylor2.0   dw^3/6
+        LLLb[:]  ...                      taylor2.0   dt^2/2
+        """
+        cdef double dt = self.dt
+        cdef QobjEvo c_op = self.c_ops[0]
+        cdef complex e, de_b, de_Lb, de_LLb, dde_bb, dde_bLb
+        cdef complex de_a, dde_ba, de_La, de_L0b
+
+        cdef complex[::1] Cpsi = self.func_buffer_1d[0,:]
+        cdef complex[::1] Cb = self.func_buffer_1d[1,:]
+        cdef complex[::1] Cbc = self.func_buffer_1d[2,:]
+        cdef complex[::1] CLb = self.func_buffer_1d[3,:]
+        cdef complex[::1] CLbc = self.func_buffer_1d[4,:]
+        cdef complex[::1] CLLb = self.func_buffer_1d[5,:]
+        cdef complex[::1] CLLbc = self.func_buffer_1d[6,:]
+        cdef complex[::1] Ca = self.func_buffer_1d[7,:]
+        cdef complex[::1] Cac = self.func_buffer_1d[8,:]
+        cdef complex[::1] CLa = self.func_buffer_1d[9,:]
+        cdef complex[::1] CLac = self.func_buffer_1d[10,:]
+        cdef complex[::1] CL0b = self.func_buffer_1d[11,:]
+        cdef complex[::1] CL0bc = self.func_buffer_1d[12,:]
+        _zero(Cpsi)
+        _zero(Cb)
+        _zero(CLb)
+        _zero(CLLb)
+        _zero(Ca)
+        _zero(CLa)
+        _zero(CL0b)
+
+        # b
+        c_op.matmul_data(t, _dense_wrap(psi), _dense_wrap(Cpsi))
+        e = _dotc(psi, Cpsi).real
+        _axpy(1., Cpsi, b)
+        _axpy(-e, psi, b)
+
+        # Lb
+        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Cb))
+        self._c_vec_conj(t, c_op, b, Cbc)
+        de_b = (_dotc(psi, Cb) + _dot(b, Cpsi) + \
+                conj(_dotc(b, Cpsi) + _dotc(psi, Cbc))) * 0.5
+        _axpy(1., Cb, Lb)
+        _axpy(-e, b, Lb)
+        _axpy(-de_b, psi, Lb)
+
+        # LLb = b'b'b + b"bb
+        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(CLb))
+        self._c_vec_conj(t, c_op, Lb, CLbc)
+        de_Lb = (_dotc(psi, CLb) + _dot(Lb, Cpsi) + \
+                 conj(_dotc(Lb, Cpsi) + _dotc(psi, CLbc)))*0.5
+        _axpy(1, CLb, LLb)      # b'b'b
+        _axpy(-e, Lb, LLb)      # b'b'b
+        _axpy(-de_Lb, psi, LLb) # b'b'b
+        dde_bb += (_dot(b, Cb) + conj(_dotc(b, Cbc)))
+        _axpy(-dde_bb, psi, LLb) # b"bb
+        _axpy(-de_b*2, b, LLb)   # b"bb
+
+        # LLLb = b"'bbb + 3* b"b'bb + b'(b"bb + b'b'b)
+        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(CLLb))
+        self._c_vec_conj(t, c_op, LLb, CLLbc)
+        de_LLb = (_dotc(psi, CLLb) + _dot(LLb, Cpsi) + \
+                  conj(_dotc(LLb, Cpsi) + _dotc(psi, CLLbc)))*0.5
+        dde_bLb += (_dot(b, CLb) + _dot(Lb, Cb) + conj(_dotc(Lb, Cbc)) + \
+                    conj(_dotc(b, CLbc)))*.5
+        _axpy(1, CLLb, LLLb)          # b'(b"bb + b'b'b)
+        _axpy(-e, LLb, LLLb)          # b'(b"bb + b'b'b)
+        _axpy(-de_LLb, psi, LLLb)     # b'(b"bb + b'b'b)
+        _axpy(-dde_bLb*3, psi, LLLb)  # b"bLb
+        _axpy(-de_Lb*3, b, LLLb)      # b"bLb
+        _axpy(-de_b*3, Lb, LLLb)      # b"bLb
+        _axpy(-dde_bb*3, b, LLLb)       # b"'bbb
+
+        # a
+        self.L.matmul_data(t, _dense_wrap(psi), _dense_wrap(a))
+        _axpy(-0.5 * e * e * dt, psi, a)
+        _axpy(e * dt, Cpsi, a)
+        _axpy(-0.5 * dt, Lb, a)
+
+        #La
+        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
+        _axpy(-0.5 * e * e * dt, b, La)
+        _axpy(-e * de_b * dt, psi, La)
+        _axpy(e * dt, Cb, La)
+        _axpy(de_b * dt, Cpsi, La)
+        _axpy(-0.5 * dt, LLb, La)
+
+        #LLa
+        _axpy(-2 * e * de_b * dt, b, LLa)
+        _axpy(-de_b * de_b * dt, psi, LLa)
+        _axpy(-e * dde_bb * dt, psi, LLa)
+        _axpy( 2 * de_b * dt, Cb, LLa)
+        _axpy( dde_bb * dt, Cpsi, LLa)
+
+        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
+        _axpy(-de_Lb * e * dt, psi, LLa)
+        _axpy(-0.5 * e * e * dt, Lb, LLa)
+        _axpy( de_Lb * dt, Cpsi, LLa)
+        _axpy( e * dt, CLb, LLa)
+
+        _axpy(-0.5 * dt, LLLb, LLa)
+
+        # L0b = b'a
+        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(Ca))
+        self._c_vec_conj(t, c_op, a, Cac)
+        de_a = (_dotc(psi, Ca) + _dot(a, Cpsi) + \
+                conj(_dotc(a, Cpsi) + _dotc(psi, Cac))) * 0.5
+        _axpy(1.0, Ca, L0b)
+        _axpy(-e, a, L0b)
+        _axpy(-de_a, psi, L0b)
+
+        # LL0b = b"ba + b'La
+        dde_ba += (_dot(b, Ca) + _dot(a, Cb) + conj(_dotc(a, Cbc)) + \
+                    conj(_dotc(b, Cac)))*.5
+        _axpy(-dde_ba, psi, LL0b)
+        _axpy(-de_a, b, LL0b)
+        _axpy(-de_b, a, LL0b)
+        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(CLa))
+        self._c_vec_conj(t, c_op, La, CLac)
+        de_La = (_dotc(psi, CLa) + _dot(La, Cpsi) + \
+                conj(_dotc(La, Cpsi) + _dotc(psi, CLac))) * 0.5
+        _axpy(1., CLa, LL0b)
+        _axpy(-e, La, LL0b)
+        _axpy(-de_La, psi, LL0b)
+
+        # L0Lb = b"ba + b'L0b
+        _axpy(-dde_ba, psi, L0Lb)
+        _axpy(-de_a, b, L0Lb)
+        _axpy(-de_b, a, L0Lb)
+        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(CL0b))
+        self._c_vec_conj(t, c_op, L0b, CL0bc)
+        de_L0b = (_dotc(psi, CL0b) + _dot(L0b, Cpsi) + \
+                  conj(_dotc(L0b, Cpsi) + _dotc(psi, CL0bc))) * 0.5
+        _axpy(1., CL0b, L0Lb)
+        _axpy(-e, L0b, L0Lb)
+        _axpy(-de_L0b, psi, L0Lb)
+
+        # _L0_ _a_ = da/dt + a'_a_ -_L0_Lb/2
+        self.d1(t + dt, psi, L0a) # da/dt
+        _axpy(-0.5 * dt, Lb, L0a)  # da/dt
+        _axpy(-1.0, a, L0a)        # da/dt
+        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a)) # a'_a_
+        _axpy(-0.5 * e * e * dt, a, L0a)    # a'_a_
+        _axpy(-e * de_a * dt, psi, L0a)     # a'_a_
+        _axpy(e * dt, Ca, L0a)              # a'_a_
+        _axpy(de_a * dt, Cpsi, L0a)         # a'_a_
+        _axpy(-0.5 * dt, L0Lb, L0a) # _L0_Lb/2
+
+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+                                        complex[::1] out,
+                                        np.ndarray[complex, ndim=1] guess) except *:
+        # np.ndarray to memoryview is OK but not the reverse
+        # scipy function only take np array, not memoryview
+        self.imp_t = t
+        spout, check = sp.linalg.bicgstab(self.imp, dvec, x0=guess,
+                                          tol=self.tol, atol=1e-12)
+        cdef int i
+        copy(spout, out)
+
+
+cdef class SMESolver(StochasticSolver):
+    """stochastic master equation system"""
+    cdef QobjEvo L
+    cdef object imp
+    cdef object c_ops
+    cdef int N_root
+    cdef double tol
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.c_ops = []
+        self.N_root = np.sqrt(self.l_vec)
+        for i, op in enumerate(c_ops):
+            self.c_ops.append(op)
+        if sso.solver_code in [MILSTEIN_IMP_SOLVER, TAYLOR1_5_IMP_SOLVER]:
+            self.tol = sso.tol
+            self.imp = sso.imp
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_rho(vec)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef complex expect(self, complex[::1] rho):
+        cdef complex e = 0.
+        cdef int k
+        for k in range(self.N_root):
+            e += rho[k*(self.N_root+1)]
+        return e
+
+    @cython.boundscheck(False)
+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+        cdef int i, k
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
+            expect = self.expect(out[i,:])
+            _axpy(-expect, rho, out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivatives(self, double t, int deg, complex[::1] rho,
+                          complex[::1] a, complex[:, ::1] b,
+                          complex[:, :, ::1] Lb, complex[:,::1] La,
+                          complex[:, ::1] L0b, complex[:, :, :, ::1] LLb,
+                          complex[::1] L0a):
+        """
+        combinaisons of a and b derivative for m sc_ops up to order dt**1.5
+        dY ~ a dt + bi dwi
+                                         deg   use        noise
+        b[i.:]       bi                   >=0   d2 euler   dwi
+        a[:]         a                    >=0   d1 euler   dt
+        Lb[i,i,:]    bi'bi                >=1   milstein   (dwi^2-dt)/2
+        Lb[i,j,:]    bj'bi                >=1   milstein   dwi*dwj
+        L0b[i,:]     ab' +db/dt +bbb"/2   >=2   taylor15   dwidt-dzi
+        La[i,:]      ba'                  >=2   taylor15   dzi
+        LLb[i,i,i,:] bi(bibi"+bi'bi')     >=2   taylor15   (dwi^2/3-dt)dwi/2
+        LLb[i,j,j,:] bi(bjbj"+bj'bj')     >=2   taylor15   (dwj^2-dt)dwj/2
+        LLb[i,j,k,:] bi(bjbk"+bj'bk')     >=2   taylor15   dwi*dwj*dwk
+        L0a[:]       aa' +da/dt +bba"/2    2    taylor15   dt^2/2
+        """
+        cdef int i, j, k
+        cdef QobjEvo c_op
+        cdef QobjEvo c_opj
+        cdef complex trApp, trAbb, trAa
+        cdef complex[::1] trAp = self.expect_buffer_1d[0,:]
+        cdef complex[:, ::1] trAb = self.expect_buffer_2d
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        #_zero(temp)
+
+        # a
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
+
+        # b
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            # bi
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b[i,:]))
+            trAp[i] = self.expect(b[i,:])
+            _axpy(-trAp[i], rho, b[i,:])
+
+        # Libj = bibj', i<=j
+        # sc_ops must commute (Libj = Ljbi)
+        if deg >= 1:
+          for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            for j in range(i, self.num_ops):
+                c_op.matmul_data(t, _dense_wrap(b[j,:]), _dense_wrap(Lb[i,j,:]))
+                trAb[i,j] = self.expect(Lb[i,j,:])
+                _axpy(-trAp[i], b[j,:], Lb[i,j,:])
+                _axpy(-trAb[i,j], rho, Lb[i,j,:])
+
+        # L0b La LLb
+        if deg >= 2:
+          for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            # Lia = bia'
+            self.L.matmul_data(t, _dense_wrap(b[i,:]), _dense_wrap(La[i,:]))
+
+            # L0bi = abi' + dbi/dt + Sum_j bjbjbi"/2
+            # db/dt
+            c_op.matmul_data(t + self.dt, _dense_wrap(rho), _dense_wrap(L0b[i,:]))
+            trApp = self.expect(L0b[i,:])
+            _axpy(-trApp, rho, L0b[i,:])
+            _axpy(-1, b[i,:], L0b[i,:])
+            # ab'
+            _zero(temp) # = np.zeros((self.l_vec, ), dtype=complex)
+            c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(temp))
+            trAa = self.expect(temp)
+            _axpy(1., temp, L0b[i,:])
+            _axpy(-trAp[i], a[:], L0b[i,:])
+            _axpy(-trAa, rho, L0b[i,:])
+            # bbb" : trAb[i,j] only defined for j>=i
+            for j in range(i):
+                _axpy(-trAb[j,i]*self.dt, b[j,:], L0b[i,:])  # L contain dt
+            for j in range(i,self.num_ops):
+                _axpy(-trAb[i,j]*self.dt, b[j,:], L0b[i,:])  # L contain dt
+
+            # LLb
+            # LiLjbk = bi(bj'bk'+bjbk"), i<=j<=k
+            # sc_ops must commute (LiLjbk = LjLibk = LkLjbi)
+            for j in range(i,self.num_ops):
+              for k in range(j,self.num_ops):
+                c_op.matmul_data(t, _dense_wrap(Lb[j,k,:]), _dense_wrap(LLb[i,j,k,:]))
+                trAbb = self.expect(LLb[i,j,k,:])
+                _axpy(-trAp[i], Lb[j,k,:], LLb[i,j,k,:])
+                _axpy(-trAbb, rho, LLb[i,j,k,:])
+                _axpy(-trAb[i,k], b[j,:], LLb[i,j,k,:])
+                _axpy(-trAb[i,j], b[k,:], LLb[i,j,k,:])
+
+        # L0a = a'a + da/dt + bba"/2  (a" = 0)
+        if deg == 2:
+            self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+            self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
+            _axpy(-1, a, L0a)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void derivativesO2(self, double t, complex[::1] rho,
+                            complex[::1] a, complex[::1] b, complex[::1] Lb,
+                            complex[::1] La, complex[::1] L0b, complex[::1] LLb,
+                            complex[::1] L0a,
+                            complex[::1] LLa, complex[::1] LL0b,
+                            complex[::1] L0Lb, complex[::1] LLLb):
+        """
+        Combinaisons of a and b derivative for m sc_ops up to order dt**2.0
+        Use Stratonovich-Taylor expansion.
+        One one sc_ops
+        dY ~ a dt + bi dwi
+
+        b[:]     b                        d2 euler    dw
+        a[:]     a- Lb/2                  d1 euler    dt
+        Lb[:]    b'b                      milstein    dw^2/2
+        L0b[:]   ab'- b'b'b/2             taylor1.5   dwdt-dz
+        La[:]    ba'- (b'b'b+b"bb)/2      taylor1.5   dz
+        LLb[:]   (b"bb+b'b'b)             taylor1.5   dw^3/6
+        L0a[:]   a_a'_ + da/dt -Lb_a'_/2  taylor1.5   dt^2/2
+
+        LLa[:]   ...                      taylor2.0   dwdt-dz
+        LL0b[:]  ...                      taylor2.0   dz
+        L0Lb[:]  ...                      taylor2.0   dw^3/6
+        LLLb[:]  ...                      taylor2.0   dt^2/2
+        """
+        cdef int i, j, k
+        cdef QobjEvo c_op = self.c_ops[0]
+        cdef QobjEvo c_opj
+        cdef complex trAp, trApt
+        cdef complex trAb, trALb, trALLb
+        cdef complex trAa, trALa
+        cdef complex trAL0b
+
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        cdef complex[::1] temp2 = self.func_buffer_1d[1,:]
+
+        # b
+        c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(b))
+        trAp = self.expect(b)
+        _axpy(-trAp, rho, b)
+
+        # Lb = b'b
+        c_op.matmul_data(t, _dense_wrap(b), _dense_wrap(Lb))
+        trAb = self.expect(Lb)
+        _axpy(-trAp, b, Lb)
+        _axpy(-trAb, rho, Lb)
+
+        # LLb = b'Lb+b"bb
+        c_op.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLb))
+        trALb = self.expect(LLb)
+        _axpy(-trAp, Lb, LLb)
+        _axpy(-trALb, rho, LLb)
+        _axpy(-trAb*2, b, LLb)
+
+        # LLLb = b'LLb + 3 b"bLb + b"'bbb
+        c_op.matmul_data(t, _dense_wrap(LLb), _dense_wrap(LLLb))
+        trALLb = self.expect(LLLb)
+        _axpy(-trAp, LLb, LLLb)
+        _axpy(-trALLb, rho, LLLb)
+        _axpy(-trALb*3, b, LLLb)
+        _axpy(-trAb*3, Lb, LLLb)
+
+        # _a_ = a - Lb/2
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(a))
+        _axpy(-0.5*self.dt, Lb, a)
+
+        # L_a_ = ba' - LLb/2
+        self.L.matmul_data(t, _dense_wrap(b), _dense_wrap(La))
+        _axpy(-0.5*self.dt, LLb, La)
+
+        # LL_a_ = b(La)' - LLLb/2
+        self.L.matmul_data(t, _dense_wrap(Lb), _dense_wrap(LLa))
+        _axpy(-0.5*self.dt, LLLb, LLa)
+
+        # _L0_b = b'(_a_)
+        c_op.matmul_data(t, _dense_wrap(a), _dense_wrap(L0b))
+        trAa = self.expect(L0b)
+        _axpy(-trAp, a, L0b)
+        _axpy(-trAa, rho, L0b)
+
+        # _L0_Lb = b'(b'(_a_))+b"(_a_,b)
+        c_op.matmul_data(t, _dense_wrap(L0b), _dense_wrap(L0Lb))
+        trAL0b = self.expect(L0Lb)
+        _axpy(-trAp, L0b, L0Lb)
+        _axpy(-trAL0b, rho, L0Lb)
+        _axpy(-trAa, b, L0Lb)
+        _axpy(-trAb, a, L0Lb)
+
+        # L_L0_b = b'(_a_'(b))+b"(_a_,b)
+        c_op.matmul_data(t, _dense_wrap(La), _dense_wrap(LL0b))
+        trAL0b = self.expect(LL0b)
+        _axpy(-trAp, La, LL0b)
+        _axpy(-trAL0b, rho, LL0b)
+        _axpy(-trAa, b, LL0b)
+        _axpy(-trAb, a, LL0b)
+
+        # _L0_ _a_ = _L0_a - _L0_Lb/2 + da/dt
+        self.L.matmul_data(t, _dense_wrap(a), _dense_wrap(L0a))
+        self.L.matmul_data(t+self.dt, _dense_wrap(rho), _dense_wrap(L0a))
+        _axpy(-0.5*self.dt, Lb, L0a) # _a_(t+dt) = a(t+dt)-0.5*Lb
+        _axpy(-1, a, L0a)
+        _axpy(-self.dt*0.5, L0Lb, L0a)
+
+
+    cdef void implicit(self, double t,  np.ndarray[complex, ndim=1] dvec,
+                                        complex[::1] out,
+                                        np.ndarray[complex, ndim=1] guess) except *:
+        # np.ndarray to memoryview is OK but not the reverse
+        # scipy function only take np array, not memoryview
+        spout, check = sp.linalg.bicgstab(self.imp(t).data.as_scipy(),
+                                          dvec, x0=guess,
+                                          tol=self.tol, atol=1e-12)
+        cdef int i
+        copy(spout,out)
+
+
+cdef class PcSSESolver(StochasticSolver):
+    """photocurrent for Schrodinger equation"""
+    cdef QobjEvo L
+    cdef object c_ops
+    cdef object cdc_ops
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.c_ops = []
+        self.cdc_ops = []
+        for i, op in enumerate(c_ops):
+            self.c_ops.append(op[0])
+            self.cdc_ops.append(op[1])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef double rand
+        cdef int i, which = -1
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef complex[::1] d2 = self.buffer_1d[0,:]
+
+        copy(vec, out)
+        self.d1(t, vec, out)
+        rand = np.random.rand()
+        for i in range(self.num_ops):
+            c_op = self.cdc_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
+            if expects[i].real * dt >= 1e-15:
+                rand -= expects[i].real *dt
+            if rand < 0:
+                which = i
+                noise[i] = 1.
+                break
+
+        if which >= 0:
+            self.collapse(t, which, expects[which].real, vec, d2)
+            _axpy(1, d2, out)
+            _axpy(-1, vec, out)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent_pc(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef double expect
+        cdef int i, which=0, num_coll=0, did_collapse=0
+        cdef complex[::1] tmp = self.buffer_1d[0,:]
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef np.ndarray[int, ndim=1] colls
+
+        # Collapses are computed first
+        for i in range(self.num_ops):
+            c_op = self.cdc_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
+            if expects[i].real > 0:
+                did_collapse = np.random.poisson(expects[i].real * dt)
+                num_coll += did_collapse
+                if did_collapse:
+                    which = i
+                noise[i] = did_collapse * 1.
+            else:
+                noise[i] = 0.
+
+        if num_coll == 0:
+            pass
+        elif num_coll == 1:
+            # Do one collapse
+            self.collapse(t, which, expects[which].real, vec, out)
+            copy(out, vec)
+        elif num_coll and noise[which] == num_coll:
+            # Do many collapse of one sc_ops.
+            # Recompute the expectation value, but only to check for zero.
+            c_op = self.cdc_ops[which]
+            for i in range(num_coll):
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, which, expect, vec, out)
+                    copy(out,vec)
+        elif num_coll >= 2:
+            # 2 or more collapses of different operators
+            # Ineficient, should be rare
+            coll = []
+            for i in range(self.num_ops):
+                coll += [i]*int(noise[i])
+            np.random.shuffle(coll)
+            for i in coll:
+                c_op = self.cdc_ops[i]
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, i, expect, vec, out)
+                    copy(out,vec)
+        copy(vec,tmp)
+        copy(vec,out)
+        self.d1(t, vec, tmp)
+        self.d1(t+dt, tmp, out)
+        _scale(0.5, out)
+        _axpy(0.5, tmp, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d1(self, double t, complex[::1] vec, complex[::1] out):
+        self.L.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        cdef int i
+        cdef complex e
+        cdef QobjEvo c_op
+        cdef complex[::1] temp = self.func_buffer_1d[0,:]
+        for i in range(self.num_ops):
+            _zero(temp)
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
+            e = _dznrm2(temp)
+            _axpy(0.5 * e * e * self.dt, vec, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] vec, complex[:, ::1] out):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.c_ops[i]
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out[i,:]))
+            expect = _dznrm2(out[i,:])
+            if expect.real >= 1e-15:
+                _zscale(1/expect, out[i,:])
+            else:
+                _zero(out[i,:])
+            _axpy(-1, vec, out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void collapse(self, double t, int which, double expect,
+                       complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        c_op = self.c_ops[which]
+        _zero(out)
+        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        _zscale(1/expect, out)
+
+
+cdef class PcSMESolver(StochasticSolver):
+    """photocurrent for master equation"""
+    cdef QobjEvo L
+    cdef object cdcr_cdcl_ops
+    cdef object cdcl_ops
+    cdef object clcdr_ops
+    cdef int N_root
+
+    def set_data(self, sso):
+        L = sso.LH
+        c_ops = sso.sops
+        self.l_vec = L.shape[0]
+        self.num_ops = len(c_ops)
+        self.L = L
+        self.cdcr_cdcl_ops = []
+        self.cdcl_ops = []
+        self.clcdr_ops = []
+        self.N_root = np.sqrt(self.l_vec)
+        for i, op in enumerate(c_ops):
+            self.cdcr_cdcl_ops.append(op[0])
+            self.cdcl_ops.append(op[1])
+            self.clcdr_ops.append(op[2])
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_rho(vec)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent(self, double t, double dt,  double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef double rand
+        cdef int i, which = -1
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef complex[::1] d2 = self.buffer_1d[0,:]
+
+        copy(vec, out)
+        self.d1(t, vec, out)
+        rand = np.random.rand()
+        for i in range(self.num_ops):
+            c_op = self.clcdr_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec))
+            if expects[i].real * dt >= 1e-15:
+                rand -= expects[i].real *dt
+            if rand < 0:
+                which = i
+                noise[i] = 1.
+                break
+
+        if which >= 0:
+            self.collapse(t, which, expects[which].real, vec, d2)
+            _axpy(1, d2, out)
+            _axpy(-1, vec, out)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void photocurrent_pc(self, double t, double dt,  double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        cdef int i, which, num_coll=0, did_collapse
+        cdef complex[::1] expects = self.expect_buffer_1d[0,:]
+        cdef complex[::1] tmp = self.buffer_1d[0,:]
+        cdef double expect
+        cdef np.ndarray[int, ndim=1] colls
+
+        # Collapses are computed first
+        for i in range(self.num_ops):
+            c_op = self.clcdr_ops[i]
+            expects[i] = c_op.expect_data(t, _dense_wrap(vec)).real
+            if expects[i].real > 0:
+                did_collapse = np.random.poisson(expects[i].real* dt)
+                num_coll += did_collapse
+                if did_collapse:
+                    which = i
+                noise[i] = did_collapse * 1.
+            else:
+                noise[i] = 0.
+
+        if num_coll == 0:
+            pass
+        elif num_coll == 1:
+            # Do one collapse
+            self.collapse(t, which, expects[which].real, vec, out)
+            copy(out,vec)
+        elif noise[which] == num_coll:
+            # Do many collapse of one sc_ops.
+            # Recompute the expectation value, but only to check for zero.
+            c_op = self.clcdr_ops[which]
+            for i in range(num_coll):
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, which, expect, vec, out)
+                    copy(out,vec)
+        elif num_coll >= 2:
+            # 2 or more collapses of different operators
+            # Ineficient, should be rare
+            coll = []
+            for i in range(self.num_ops):
+                coll += [i] * int(noise[i])
+            np.random.shuffle(coll)
+            for i in coll:
+                c_op = self.clcdr_ops[i]
+                expect = c_op.expect_data(t, _dense_wrap(vec)).real
+                if expect * dt >= 1e-15:
+                    self.collapse(t, i, expect, vec, out)
+                    copy(out,vec)
+
+        copy(vec,tmp)
+        copy(vec,out)
+        self.d1(t, vec, tmp)
+        self.d1(t+dt, tmp, out)
+        _scale(0.5, out)
+        _axpy(0.5, tmp, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef complex expect(self, complex[::1] rho):
+        cdef complex e = 0.
+        cdef int k
+        for k in range(self.N_root):
+            e += rho[k*(self.N_root+1)]
+        return e
+
+    @cython.boundscheck(False)
+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef complex[::1] crho = self.func_buffer_1d[0,:]
+        cdef complex expect
+        self.L.matmul_data(t, _dense_wrap(rho), _dense_wrap(out))
+        for i in range(self.num_ops):
+            c_op = self.cdcr_cdcl_ops[i]
+            _zero(crho)
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(crho))
+            expect = self.expect(crho)
+            _axpy(0.5*expect* self.dt, rho, out)
+            _axpy(-0.5* self.dt, crho, out)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+        cdef int i
+        cdef QobjEvo c_op
+        cdef complex expect
+        for i in range(self.num_ops):
+            c_op = self.clcdr_ops[i]
+            c_op.matmul_data(t, _dense_wrap(rho), _dense_wrap(out[i,:]))
+            expect = self.expect(out[i,:])
+            if expect.real >= 1e-15:
+                _zscale((1.+0j)/expect, out[i,:])
+            else:
+                _zero(out[i,:])
+            _axpy(-1, rho, out[i,:])
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef void collapse(self, double t, int which, double expect,
+                       complex[::1] vec, complex[::1] out):
+        cdef QobjEvo c_op
+        c_op = self.clcdr_ops[which]
+        _zero(out)
+        c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        _zscale(1./expect, out)
+
+cdef class PmSMESolver(StochasticSolver):
+    """positive map for master equation"""
+    cdef object L
+    cdef QobjEvo pp_ops
+    cdef QobjEvo preLH
+    cdef QobjEvo postLH
+    cdef object sops
+    cdef object preops
+    cdef object postops
+    cdef object preops2
+    cdef object postops2
+    cdef int N_root
+
+    def set_data(self, sso):
+        c_ops = sso.sops
+        self.l_vec = sso.pp.shape[0]
+        self.num_ops = len(c_ops)
+        self.preLH = sso.preLH
+        self.postLH = sso.postLH
+        self.pp_ops = sso.pp
+        self.sops = [op for op in sso.sops]
+        self.preops = [op for op in sso.preops]
+        self.postops = [op for op in sso.postops]
+        self.preops2 = [op for op in sso.preops2]
+        self.postops2 = [op for op in sso.postops2]
+        self.N_root = np.sqrt(self.l_vec)
+
+    cdef void _normalize_inplace(self, complex[::1] vec):
+        _normalize_rho(vec)
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    cdef void rouchon(self, double t, double dt, double[:] noise,
+                           complex[::1] vec, complex[::1] out):
+        cdef complex[::1] dy = self.expect_buffer_1d[0,:]
+        cdef complex[::1] temp = self.buffer_1d[0,:]
+        cdef complex[::1] temp2 = self.buffer_1d[1,:]
+        cdef int i, j, k
+        cdef QobjEvo c_op, c_opj
+        cdef complex ddw, tr
+        _zero(out)
+        _zero(temp)
+        self.preLH.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp))
+        for i in range(self.num_ops):
+            c_op = self.sops[i]
+            dy[i] = c_op.expect_data(t, _dense_wrap(vec)) + noise[i]
+            c_op = self.preops[i]
+            _zero(temp2)
+            c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
+            _axpy(dy[i], temp2, temp)
+
+        k = 0
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                c_op = self.preops2[k]
+                if i == j:
+                    ddw = (dy[i]*dy[j] - dt) *0.5
+                else:
+                    ddw = (dy[i]*dy[j])
+
+                _zero(temp2)
+                c_op.matmul_data(t, _dense_wrap(vec), _dense_wrap(temp2))
+                _axpy(ddw, temp2, temp)
+                k += 1
+
+        self.postLH.matmul_data(t, _dense_wrap(temp), _dense_wrap(out))
+        for i in range(self.num_ops):
+            dy[i] = conj(dy[i])
+            c_op = self.postops[i]
+            _zero(temp2)
+            c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+            _axpy(dy[i], temp2, out)
+
+        k = 0
+        for i in range(self.num_ops):
+            for j in range(i, self.num_ops):
+                c_op = self.postops2[k]
+                if i == j:
+                    ddw = (dy[i]*dy[j] - dt) *0.5
+                else:
+                    ddw = (dy[i]*dy[j])
+                _zero(temp2)
+                c_op.matmul_data(t, _dense_wrap(temp), _dense_wrap(temp2))
+                _axpy(ddw, temp2, out)
+                k += 1
+
+        self.pp_ops.matmul_data(t, _dense_wrap(vec), _dense_wrap(out))
+        tr = self.expect(out)
+        _zscale(1./tr, out)
+
+
+    @cython.boundscheck(False)
+    @cython.wraparound(False)
+    @cython.cdivision(True)
+    cdef complex expect(self, complex[::1] rho):
+        cdef complex e = 0.
+        cdef int k
+        for k in range(self.N_root):
+            e += rho[k*(self.N_root+1)]
+        return e
+
+
+cdef class GenericSSolver(StochasticSolver):
+    """support for user defined system"""
+    cdef object d1_func, d2_func
+
+    def set_data(self, sso):
+        self.l_vec = sso.rho0.shape[0]
+        self.num_ops = len(sso.sops)
+        self.d1_func = sso.d1
+        self.d2_func = sso.d2
+
+
+    cdef void d1(self, double t, complex[::1] rho, complex[::1] out):
+        cdef np.ndarray[complex, ndim=1] in_np
+        cdef np.ndarray[complex, ndim=1] out_np
+        in_np = np.zeros((self.l_vec, ), dtype=complex)
+        copy(rho, in_np)
+        out_np = self.d1_func(t, in_np)
+        _axpy(self.dt, out_np, out) # d1 is += and * dt
+
+    @cython.boundscheck(False)
+    cdef void d2(self, double t, complex[::1] rho, complex[:, ::1] out):
+        cdef np.ndarray[complex, ndim=1] in_np
+        cdef np.ndarray[complex, ndim=2] out_np
+        cdef int i
+        in_np = np.zeros((self.l_vec, ), dtype=complex)
+        copy(rho, in_np)
+        out_np = self.d2_func(t, in_np)
+        for i in range(self.num_ops):
+            copy(out_np[i,:], out[i,:])
diff --git a/qutip/solve/nonmarkov/memorycascade.py b/qutip/solve/nonmarkov/memorycascade.py
index 488b2515c4..35996d21cd 100644
--- a/qutip/solve/nonmarkov/memorycascade.py
+++ b/qutip/solve/nonmarkov/memorycascade.py
@@ -1,405 +1,405 @@
-# -*- coding: utf-8 -*-
-
-# @author: Arne L. Grimsmo
-# @email1: arne.grimsmo@gmail.com
-# @organization: University of Sherbrooke
-
-"""
-This module is an implementation of the method introduced in [1], for
-solving open quantum systems subject to coherent feedback with a single
-discrete time-delay. This method is referred to as the ``memory cascade''
-method in qutip.
-
-[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
-"""
-
-import numpy as np
-import warnings
-
-import qutip as qt
-
-
-class MemoryCascade:
-    """Class for running memory cascade simulations of open quantum systems
-    with time-delayed coherent feedback.
-
-    Attributes
-    ----------
-    H_S : :class:`qutip.Qobj`
-        System Hamiltonian (can also be a Liouvillian)
-
-    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-        System operators coupling into the feedback loop. Can be a single
-        operator or a list of operators.
-
-    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-        System operators coupling out of the feedback loop. Can be a single
-        operator or a list of operators. L2 must have the same length as L1.
-
-    S_matrix: *array*
-        S matrix describing which operators in L1 are coupled to which
-        operators in L2 by the feedback channel. Defaults to an n by n identity
-        matrix where n is the number of elements in L1/L2.
-
-    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
-        Decay operators describing conventional Markovian decay channels.
-        Can be a single operator or a list of operators.
-
-    integrator : str {'propagator', 'mesolve'}
-        Integrator method to use. Defaults to 'propagator' which tends to be
-        faster for long times (i.e., large Hilbert space).
-
-    parallel : bool
-        Run integrator in parallel if True. Only implemented for 'propagator'
-        as the integrator method.
-
-    options : dict
-        Generic solver options.
-    """
-
-    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
-                 integrator='propagator', parallel=False, options=None):
-
-        if options is None:
-            self.options = {}
-        else:
-            self.options = options
-
-        self.H_S = H_S
-        self.sysdims = H_S.dims
-        if isinstance(L1, qt.Qobj):
-            self.L1 = [L1]
-        else:
-            self.L1 = L1
-        if isinstance(L2, qt.Qobj):
-            self.L2 = [L2]
-        else:
-            self.L2 = L2
-        if not len(self.L1) == len(self.L2):
-            raise ValueError('L1 and L2 has to be of equal length.')
-        if isinstance(c_ops_markov, qt.Qobj):
-            self.c_ops_markov = [c_ops_markov]
-        else:
-            self.c_ops_markov = c_ops_markov
-
-        if S_matrix is None:
-            self.S_matrix = np.identity(len(self.L1))
-        else:
-            self.S_matrix = S_matrix
-        # create system identity superoperator
-        self.Id = qt.qeye(H_S.shape[0])
-        self.Id.dims = self.sysdims
-        self.Id = qt.sprepost(self.Id, self.Id)
-        self.store_states = self.options['store_states']
-        self.integrator = integrator
-        self.parallel = parallel
-
-    def propagator(self, t, tau, notrace=False):
-        """
-        Compute propagator for time t and time-delay tau
-
-        Parameters
-        ----------
-        t : *float*
-            current time
-
-        tau : *float*
-            time-delay
-
-        notrace : *bool* {False}
-            If this optional is set to True, a propagator is returned for a
-            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
-            If set to False (default), a generalized partial trace is performed
-            and a propagator for a single system is returned.
-        Returns
-        -------
-        : :class:`qutip.Qobj`
-            time-propagator for reduced system dynamics
-        """
-        k = int(t/tau)+1
-        s = t-(k-1)*tau
-        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
-                            self.c_ops_markov)
-        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
-                       parallel=self.parallel, opt=self.options)
-        if k > 1:
-            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
-                                  self.S_matrix, self.c_ops_markov)
-            G2 = qt.composite(G2, self.Id)
-            E = _integrate(G2, E, s, tau, integrator=self.integrator,
-                    parallel=self.parallel, opt=self.options)
-        E.dims = E0.dims
-        if not notrace:
-            E = _genptrace(E, k)
-        return E
-
-    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
-                           notrace=False):
-        r"""
-        Compute propagator for computing output field expectation values
-        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
-        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
-
-        Parameters
-        ----------
-        blist : array_like
-            List of integers specifying the field operators:
-            0: I (nothing)
-            1: b_out
-            2: b_out^\dagger
-            3: b_loop
-            4: b_loop^\dagger
-
-        tlist : array_like
-            list of corresponding times t1,..,tn at which to evaluate the field
-            operators
-
-        tau : float
-            time-delay
-
-        c1 : :class:`qutip.Qobj`
-            system collapse operator that couples to the in-loop field in
-            question (only needs to be specified if self.L1 has more than one
-            element)
-
-        c2 : :class:`qutip.Qobj`
-            system collapse operator that couples to the output field in
-            question (only needs to be specified if self.L2 has more than one
-            element)
-
-        notrace : bool {False}
-            If this optional is set to True, a propagator is returned for a
-            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
-            If set to False (default), a generalized partial trace is performed
-            and a propagator for a single system is returned.
-
-        Returns
-        -------
-        : :class:`qutip.Qobj`
-            time-propagator for computing field correlation function
-        """
-        if c1 is None and len(self.L1) == 1:
-            c1 = self.L1[0]
-        else:
-            raise ValueError('Argument c1 has to be specified when more than' +
-                             'one collapse operator couples to the feedback' +
-                             'loop.')
-        if c2 is None and len(self.L2) == 1:
-            c2 = self.L2[0]
-        else:
-            raise ValueError('Argument c1 has to be specified when more than' +
-                             'one collapse operator couples to the feedback' +
-                             'loop.')
-        klist = []
-        slist = []
-        for t in tlist:
-            klist.append(int(t/tau)+1)
-            slist.append(t-(klist[-1]-1)*tau)
-        kmax = max(klist)
-        zipped = sorted(zip(slist, klist, blist))
-        slist = [s for (s, k, b) in zipped]
-        klist = [k for (s, k, b) in zipped]
-        blist = [b for (s, k, b) in zipped]
-
-        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
-                            self.c_ops_markov)
-        sprev = 0.
-        E = E0
-        for i, s in enumerate(slist):
-            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
-                    parallel=self.parallel, opt=self.options)
-            if klist[i] == 1:
-                l1 = 0.*qt.Qobj()
-            else:
-                l1 = _localop(c1, klist[i]-1, kmax)
-            l2 = _localop(c2, klist[i], kmax)
-            if blist[i] == 0:
-                superop = self.Id
-            elif blist[i] == 1:
-                superop = qt.spre(l1+l2)
-            elif blist[i] == 2:
-                superop = qt.spost(l1.dag()+l2.dag())
-            elif blist[i] == 3:
-                superop = qt.spre(l1)
-            elif blist[i] == 4:
-                superop = qt.spost(l1.dag())
-            else:
-                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
-                                 'and 4.')
-            superop.dims = E.dims
-            E = superop*E
-            sprev = s
-        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
-                parallel=self.parallel, opt=self.options)
-
-        E.dims = E0.dims
-        if not notrace:
-            E = _genptrace(E, kmax)
-        return E
-
-    def rhot(self, rho0, t, tau):
-        """
-        Compute the reduced system density matrix :math:`\\rho(t)`
-
-        Parameters
-        ----------
-        rho0 : :class:`qutip.Qobj`
-            initial density matrix or state vector (ket)
-
-        t : float
-            current time
-
-        tau : float
-            time-delay
-
-        Returns
-        -------
-        : :class:`qutip.Qobj`
-            density matrix at time :math:`t`
-        """
-        if qt.isket(rho0):
-            rho0 = qt.ket2dm(rho0)
-
-        E = self.propagator(t, tau)
-        rhovec = qt.operator_to_vector(rho0)
-        return qt.vector_to_operator(E*rhovec)
-
-    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
-        r"""
-        Compute output field expectation value
-        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
-        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
-
-
-        Parameters
-        ----------
-        rho0 : :class:`qutip.Qobj`
-            initial density matrix or state vector (ket).
-
-        blist : array_like
-            List of integers specifying the field operators:
-            0: I (nothing)
-            1: b_out
-            2: b_out^\dagger
-            3: b_loop
-            4: b_loop^\dagger
-
-        tlist : array_like
-            list of corresponding times t1,..,tn at which to evaluate the field
-            operators
-
-        tau : float
-            time-delay
-
-        c1 : :class:`qutip.Qobj`
-            system collapse operator that couples to the in-loop field in
-            question (only needs to be specified if self.L1 has more than one
-            element)
-
-        c2 : :class:`qutip.Qobj`
-            system collapse operator that couples to the output field in
-            question (only needs to be specified if self.L2 has more than one
-            element)
-
-        Returns
-        -------
-        : complex
-            expectation value of field correlation function
-        """
-        E = self.outfieldpropagator(blist, tlist, tau)
-        rhovec = qt.operator_to_vector(rho0)
-        return (qt.vector_to_operator(E*rhovec)).tr()
-
-
-def _localop(op, l, k):
-    """
-    Create a local operator on the l'th system by tensoring
-    with identity operators on all the other k-1 systems
-    """
-    if l < 1 or l > k:
-        raise IndexError('index l out of range')
-    h = op
-    I = qt.qeye(op.shape[0])
-    I.dims = op.dims
-    for i in range(1, l):
-        h = qt.tensor(I, h)
-    for i in range(l+1, k+1):
-        h = qt.tensor(h, I)
-    return h
-
-
-def _genptrace(E, k):
-    """
-    Perform a gneralized partial trace on a superoperator E, tracing out all
-    subsystems but one.
-    """
-    for l in range(k-1):
-        nsys = len(E.dims[0][0])
-        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
-    return E
-
-
-def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
-    """
-    Create a Liouvillian for a cascaded chain of k system copies
-    """
-    id = qt.qeye(H.dims[0][0])
-    Id = qt.sprepost(id, id)
-    if S is None:
-        S = np.identity(len(L1))
-    # create Lindbladian
-    L = qt.Qobj()
-    E0 = Id
-    # first system
-    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
-    for l in range(1, k):
-        # Identiy superoperator
-        E0 = qt.composite(E0, Id)
-        # Bare Hamiltonian
-        Hl = _localop(H, l, k)
-        L += qt.liouvillian(Hl, [])
-        # Markovian Decay channels
-        if c_ops_markov is not None:
-            for c in c_ops_markov:
-                cl = _localop(c, l, k)
-                L += qt.liouvillian(None, [cl])
-        # Cascade coupling
-        c1 = np.array([_localop(c, l, k) for c in L1])
-        c2 = np.array([_localop(c, l+1, k) for c in L2])
-        c2dag = np.array([c.dag() for c in c2])
-        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
-        Hcasc += Hcasc.dag()
-        Lvec = c2 + np.dot(S, c1)
-        L += qt.liouvillian(Hcasc, [c for c in Lvec])
-    # last system
-    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
-    if c_ops_markov is not None:
-        for c in c_ops_markov:
-            cl = _localop(c, k, k)
-            L += qt.liouvillian(None, [cl])
-    E0.dims = L.dims
-    # return generator and identity superop E0
-    return L, E0
-
-
-def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
-        opt=None):
-    """
-    Basic ode integrator
-    """
-    opt = opt or {}
-    if tf > ti:
-        if integrator == 'mesolve':
-            if parallel:
-                warnings.warn('parallelization not implemented for "mesolve"')
-            opt.store_final_state = True
-            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
-            return sol.final_state
-        elif integrator == 'propagator':
-            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
-                                 options=opt)*E0
-        else:
-            raise ValueError('integrator keyword must be either "propagator"' +
-                              'or "mesolve"')
-    else:
-        return E0
+# -*- coding: utf-8 -*-
+
+# @author: Arne L. Grimsmo
+# @email1: arne.grimsmo@gmail.com
+# @organization: University of Sherbrooke
+
+"""
+This module is an implementation of the method introduced in [1], for
+solving open quantum systems subject to coherent feedback with a single
+discrete time-delay. This method is referred to as the ``memory cascade''
+method in qutip.
+
+[1] Arne L. Grimsmo, Phys. Rev. Lett 115, 060402 (2015)
+"""
+
+import numpy as np
+import warnings
+
+import qutip as qt
+
+
+class MemoryCascade:
+    """Class for running memory cascade simulations of open quantum systems
+    with time-delayed coherent feedback.
+
+    Attributes
+    ----------
+    H_S : :class:`qutip.Qobj`
+        System Hamiltonian (can also be a Liouvillian)
+
+    L1 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+        System operators coupling into the feedback loop. Can be a single
+        operator or a list of operators.
+
+    L2 : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+        System operators coupling out of the feedback loop. Can be a single
+        operator or a list of operators. L2 must have the same length as L1.
+
+    S_matrix: *array*
+        S matrix describing which operators in L1 are coupled to which
+        operators in L2 by the feedback channel. Defaults to an n by n identity
+        matrix where n is the number of elements in L1/L2.
+
+    c_ops_markov : :class:`qutip.Qobj` / list of :class:`qutip.Qobj`
+        Decay operators describing conventional Markovian decay channels.
+        Can be a single operator or a list of operators.
+
+    integrator : str {'propagator', 'mesolve'}
+        Integrator method to use. Defaults to 'propagator' which tends to be
+        faster for long times (i.e., large Hilbert space).
+
+    parallel : bool
+        Run integrator in parallel if True. Only implemented for 'propagator'
+        as the integrator method.
+
+    options : dict
+        Generic solver options.
+    """
+
+    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
+                 integrator='propagator', parallel=False, options=None):
+
+        if options is None:
+            self.options = {}
+        else:
+            self.options = options
+
+        self.H_S = H_S
+        self.sysdims = H_S.dims
+        if isinstance(L1, qt.Qobj):
+            self.L1 = [L1]
+        else:
+            self.L1 = L1
+        if isinstance(L2, qt.Qobj):
+            self.L2 = [L2]
+        else:
+            self.L2 = L2
+        if not len(self.L1) == len(self.L2):
+            raise ValueError('L1 and L2 has to be of equal length.')
+        if isinstance(c_ops_markov, qt.Qobj):
+            self.c_ops_markov = [c_ops_markov]
+        else:
+            self.c_ops_markov = c_ops_markov
+
+        if S_matrix is None:
+            self.S_matrix = np.identity(len(self.L1))
+        else:
+            self.S_matrix = S_matrix
+        # create system identity superoperator
+        self.Id = qt.qeye(H_S.shape[0])
+        self.Id.dims = self.sysdims
+        self.Id = qt.sprepost(self.Id, self.Id)
+        self.store_states = self.options['store_states']
+        self.integrator = integrator
+        self.parallel = parallel
+
+    def propagator(self, t, tau, notrace=False):
+        """
+        Compute propagator for time t and time-delay tau
+
+        Parameters
+        ----------
+        t : *float*
+            current time
+
+        tau : *float*
+            time-delay
+
+        notrace : *bool* {False}
+            If this optional is set to True, a propagator is returned for a
+            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
+            If set to False (default), a generalized partial trace is performed
+            and a propagator for a single system is returned.
+        Returns
+        -------
+        : :class:`qutip.Qobj`
+            time-propagator for reduced system dynamics
+        """
+        k = int(t/tau)+1
+        s = t-(k-1)*tau
+        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
+                            self.c_ops_markov)
+        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
+                       parallel=self.parallel, opt=self.options)
+        if k > 1:
+            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
+                                  self.S_matrix, self.c_ops_markov)
+            G2 = qt.composite(G2, self.Id)
+            E = _integrate(G2, E, s, tau, integrator=self.integrator,
+                    parallel=self.parallel, opt=self.options)
+        E.dims = E0.dims
+        if not notrace:
+            E = _genptrace(E, k)
+        return E
+
+    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
+                           notrace=False):
+        r"""
+        Compute propagator for computing output field expectation values
+        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
+        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
+
+        Parameters
+        ----------
+        blist : array_like
+            List of integers specifying the field operators:
+            0: I (nothing)
+            1: b_out
+            2: b_out^\dagger
+            3: b_loop
+            4: b_loop^\dagger
+
+        tlist : array_like
+            list of corresponding times t1,..,tn at which to evaluate the field
+            operators
+
+        tau : float
+            time-delay
+
+        c1 : :class:`qutip.Qobj`
+            system collapse operator that couples to the in-loop field in
+            question (only needs to be specified if self.L1 has more than one
+            element)
+
+        c2 : :class:`qutip.Qobj`
+            system collapse operator that couples to the output field in
+            question (only needs to be specified if self.L2 has more than one
+            element)
+
+        notrace : bool {False}
+            If this optional is set to True, a propagator is returned for a
+            cascade of k systems, where :math:`(k-1) tau < t < k tau`.
+            If set to False (default), a generalized partial trace is performed
+            and a propagator for a single system is returned.
+
+        Returns
+        -------
+        : :class:`qutip.Qobj`
+            time-propagator for computing field correlation function
+        """
+        if c1 is None and len(self.L1) == 1:
+            c1 = self.L1[0]
+        else:
+            raise ValueError('Argument c1 has to be specified when more than' +
+                             'one collapse operator couples to the feedback' +
+                             'loop.')
+        if c2 is None and len(self.L2) == 1:
+            c2 = self.L2[0]
+        else:
+            raise ValueError('Argument c1 has to be specified when more than' +
+                             'one collapse operator couples to the feedback' +
+                             'loop.')
+        klist = []
+        slist = []
+        for t in tlist:
+            klist.append(int(t/tau)+1)
+            slist.append(t-(klist[-1]-1)*tau)
+        kmax = max(klist)
+        zipped = sorted(zip(slist, klist, blist))
+        slist = [s for (s, k, b) in zipped]
+        klist = [k for (s, k, b) in zipped]
+        blist = [b for (s, k, b) in zipped]
+
+        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
+                            self.c_ops_markov)
+        sprev = 0.
+        E = E0
+        for i, s in enumerate(slist):
+            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
+                    parallel=self.parallel, opt=self.options)
+            if klist[i] == 1:
+                l1 = 0.*qt.Qobj()
+            else:
+                l1 = _localop(c1, klist[i]-1, kmax)
+            l2 = _localop(c2, klist[i], kmax)
+            if blist[i] == 0:
+                superop = self.Id
+            elif blist[i] == 1:
+                superop = qt.spre(l1+l2)
+            elif blist[i] == 2:
+                superop = qt.spost(l1.dag()+l2.dag())
+            elif blist[i] == 3:
+                superop = qt.spre(l1)
+            elif blist[i] == 4:
+                superop = qt.spost(l1.dag())
+            else:
+                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
+                                 'and 4.')
+            superop.dims = E.dims
+            E = superop*E
+            sprev = s
+        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
+                parallel=self.parallel, opt=self.options)
+
+        E.dims = E0.dims
+        if not notrace:
+            E = _genptrace(E, kmax)
+        return E
+
+    def rhot(self, rho0, t, tau):
+        """
+        Compute the reduced system density matrix :math:`\\rho(t)`
+
+        Parameters
+        ----------
+        rho0 : :class:`qutip.Qobj`
+            initial density matrix or state vector (ket)
+
+        t : float
+            current time
+
+        tau : float
+            time-delay
+
+        Returns
+        -------
+        : :class:`qutip.Qobj`
+            density matrix at time :math:`t`
+        """
+        if qt.isket(rho0):
+            rho0 = qt.ket2dm(rho0)
+
+        E = self.propagator(t, tau)
+        rhovec = qt.operator_to_vector(rho0)
+        return qt.vector_to_operator(E*rhovec)
+
+    def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
+        r"""
+        Compute output field expectation value
+        <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
+        O_i = I, b_out, b_out^\dagger, b_loop, b_loop^\dagger
+
+
+        Parameters
+        ----------
+        rho0 : :class:`qutip.Qobj`
+            initial density matrix or state vector (ket).
+
+        blist : array_like
+            List of integers specifying the field operators:
+            0: I (nothing)
+            1: b_out
+            2: b_out^\dagger
+            3: b_loop
+            4: b_loop^\dagger
+
+        tlist : array_like
+            list of corresponding times t1,..,tn at which to evaluate the field
+            operators
+
+        tau : float
+            time-delay
+
+        c1 : :class:`qutip.Qobj`
+            system collapse operator that couples to the in-loop field in
+            question (only needs to be specified if self.L1 has more than one
+            element)
+
+        c2 : :class:`qutip.Qobj`
+            system collapse operator that couples to the output field in
+            question (only needs to be specified if self.L2 has more than one
+            element)
+
+        Returns
+        -------
+        : complex
+            expectation value of field correlation function
+        """
+        E = self.outfieldpropagator(blist, tlist, tau)
+        rhovec = qt.operator_to_vector(rho0)
+        return (qt.vector_to_operator(E*rhovec)).tr()
+
+
+def _localop(op, l, k):
+    """
+    Create a local operator on the l'th system by tensoring
+    with identity operators on all the other k-1 systems
+    """
+    if l < 1 or l > k:
+        raise IndexError('index l out of range')
+    h = op
+    I = qt.qeye(op.shape[0])
+    I.dims = op.dims
+    for i in range(1, l):
+        h = qt.tensor(I, h)
+    for i in range(l+1, k+1):
+        h = qt.tensor(h, I)
+    return h
+
+
+def _genptrace(E, k):
+    """
+    Perform a gneralized partial trace on a superoperator E, tracing out all
+    subsystems but one.
+    """
+    for l in range(k-1):
+        nsys = len(E.dims[0][0])
+        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
+    return E
+
+
+def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
+    """
+    Create a Liouvillian for a cascaded chain of k system copies
+    """
+    id = qt.qeye(H.dims[0][0])
+    Id = qt.sprepost(id, id)
+    if S is None:
+        S = np.identity(len(L1))
+    # create Lindbladian
+    L = qt.Qobj()
+    E0 = Id
+    # first system
+    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
+    for l in range(1, k):
+        # Identiy superoperator
+        E0 = qt.composite(E0, Id)
+        # Bare Hamiltonian
+        Hl = _localop(H, l, k)
+        L += qt.liouvillian(Hl, [])
+        # Markovian Decay channels
+        if c_ops_markov is not None:
+            for c in c_ops_markov:
+                cl = _localop(c, l, k)
+                L += qt.liouvillian(None, [cl])
+        # Cascade coupling
+        c1 = np.array([_localop(c, l, k) for c in L1])
+        c2 = np.array([_localop(c, l+1, k) for c in L2])
+        c2dag = np.array([c.dag() for c in c2])
+        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
+        Hcasc += Hcasc.dag()
+        Lvec = c2 + np.dot(S, c1)
+        L += qt.liouvillian(Hcasc, [c for c in Lvec])
+    # last system
+    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
+    if c_ops_markov is not None:
+        for c in c_ops_markov:
+            cl = _localop(c, k, k)
+            L += qt.liouvillian(None, [cl])
+    E0.dims = L.dims
+    # return generator and identity superop E0
+    return L, E0
+
+
+def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
+        opt=None):
+    """
+    Basic ode integrator
+    """
+    opt = opt or {}
+    if tf > ti:
+        if integrator == 'mesolve':
+            if parallel:
+                warnings.warn('parallelization not implemented for "mesolve"')
+            opt.store_final_state = True
+            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
+            return sol.final_state
+        elif integrator == 'propagator':
+            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
+                                 options=opt)*E0
+        else:
+            raise ValueError('integrator keyword must be either "propagator"' +
+                              'or "mesolve"')
+    else:
+        return E0
diff --git a/qutip/solve/nonmarkov/transfertensor.py b/qutip/solve/nonmarkov/transfertensor.py
index ccd1ada8c8..561b7554e1 100644
--- a/qutip/solve/nonmarkov/transfertensor.py
+++ b/qutip/solve/nonmarkov/transfertensor.py
@@ -1,254 +1,254 @@
-# -*- coding: utf-8 -*-
-# @author: Arne L. Grimsmo
-# @email1: arne.grimsmo@gmail.com
-# @organization: University of Sherbrooke
-
-"""
-This module contains an implementation of the non-Markovian transfer tensor
-method (TTM), introduced in [1].
-
-[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
-"""
-
-import numpy as np
-
-
-from qutip import spre, vector_to_operator, operator_to_vector
-from qutip.core import data as _data
-from ..solver import Result, SolverOptions
-
-
-class TTMSolverOptions:
-    """Class of options for the Transfer Tensor Method solver.
-
-    Attributes
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators),
-        or a callback function that returns the
-        superoperator at a given time.
-
-    times : array_like
-        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
-
-    learningtimes : array_like
-        List of times :math:`t_k` to use as learning times if argument
-        `dynmaps` is a callback function.
-
-    thres : float
-        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
-        treshold.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options.
-    """
-
-    def __init__(self, dynmaps=None, times=[], learningtimes=[],
-                 thres=0.0, options=None):
-        if options is None:
-            options = SolverOptions()
-
-        self.dynmaps = dynmaps
-        self.times = times
-        self.learningtimes = learningtimes
-        self.thres = thres
-        self.store_states = options['store_states']
-
-
-def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
-             **kwargs):
-    """
-    Solve time-evolution using the Transfer Tensor Method, based on a set of
-    precomputed dynamical maps.
-
-    Parameters
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators),
-        or a callback function that returns the
-        superoperator at a given time.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : array_like
-        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
-        Must be uniformily spaced.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    learningtimes : array_like
-        list of times :math:`t_k` for which we have knowledge of the dynamical
-        maps :math:`E(t_k)`.
-
-    tensors : array_like
-        optional list of precomputed tensors :math:`T_k`
-
-    kwargs : dictionary
-        Optional keyword arguments. See
-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
-
-    Returns
-    -------
-    output: :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-
-    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
-                           learningtimes=learningtimes, **kwargs)
-
-    diff = None
-
-    if rho0.isket:
-        rho0 = rho0.proj()
-
-    output = Result()
-    e_sops_data = []
-
-    if callable(e_ops):
-        n_expt_op = 0
-        expt_callback = True
-
-    else:
-        try:
-            tmp = e_ops[:]
-            del tmp
-
-            n_expt_op = len(e_ops)
-            expt_callback = False
-
-            if n_expt_op == 0:
-                # fall back on storing states
-                opt.store_states = True
-
-            for op in e_ops:
-                e_sops_data.append(spre(op).data)
-                if op.isherm and rho0.isherm:
-                    output.expect.append(np.zeros(len(times)))
-                else:
-                    output.expect.append(np.zeros(len(times), dtype=complex))
-        except TypeError:
-            raise TypeError("Argument 'e_ops' should be a callable or" +
-                            "list-like.")
-
-    if tensors is None:
-        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
-
-    if rho0.isoper:
-        # vectorize density matrix
-        rho0vec = operator_to_vector(rho0)
-    else:
-        # rho0 might be a super in which case we should not vectorize
-        rho0vec = rho0
-
-    K = len(tensors)
-    states = [rho0vec]
-    for n in range(1, len(times)):
-        # Set current state
-        state = None
-        for j in range(1, min(K, n + 1)):
-            tmp = tensors[j] * states[n - j]
-            state = tmp if state is None else tmp + state
-        # Append state to all states
-        states.append(state)
-    for i, r in enumerate(states):
-        if opt.store_states or expt_callback:
-            if r.type == 'operator-ket':
-                states[i] = vector_to_operator(r)
-            else:
-                states[i] = r
-            if expt_callback:
-                # use callback method
-                e_ops(times[i], states[i])
-        rdata = _data.column_stack(r.data)
-        for m in range(n_expt_op):
-            if output.expect[m].dtype == complex:
-                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
-            else:
-                output.expect[m][i] =\
-                    _data.expect_super(e_sops_data[m], rdata).real
-
-    output.solver = "ttmsolve"
-    output.times = times
-
-    output.ttmconvergence = diff
-
-    if opt.store_states:
-        output.states = states
-
-    return output
-
-
-def _generatetensors(dynmaps, learningtimes=None, **kwargs):
-    r"""
-    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
-    :math:`E(t_k)`.
-
-    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
-
-    Parameters
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators) at the times
-        specified in `learningtimes`, or a callback function that returns the
-        superoperator at a given time.
-
-    learningtimes : array_like
-        list of times :math:`t_k` to use if argument `dynmaps` is a callback
-        function.
-
-    kwargs : dictionary
-        Optional keyword arguments. See
-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
-
-    Returns
-    -------
-    Tlist: list of :class:`qutip.Qobj.`
-        A list of transfer tensors :math:`T_1,\dots,T_K`
-    """
-
-    # Determine if dynmaps is callable or list-like
-    if callable(dynmaps):
-        if learningtimes is None:
-            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
-                            "is a callback function.")
-
-        def dynmapfunc(n):
-            return dynmaps(learningtimes[n])
-
-        Kmax = len(learningtimes)
-    else:
-        try:
-            tmp = dynmaps[:]
-            del tmp
-
-            def dynmapfunc(n):
-                return dynmaps[n]
-
-            Kmax = len(dynmaps)
-        except TypeError:
-            raise TypeError("Argument 'dynmaps' should be a callable or" +
-                            "list-like.")
-
-    if "opt" not in kwargs:
-        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
-                               **kwargs)
-    else:
-        opt = kwargs['opt']
-
-    Tlist = []
-    diff = [0.0]
-    for n in range(Kmax):
-        T = dynmapfunc(n)
-        for m in range(1, n):
-            T -= Tlist[n - m] * dynmapfunc(m)
-        Tlist.append(T)
-        if n > 1:
-            diff.append((Tlist[-1] - Tlist[-2]).norm())
-            if diff[-1] < opt.thres:
-                # Below threshold for truncation
-                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
-                break
-    return Tlist, diff
+# -*- coding: utf-8 -*-
+# @author: Arne L. Grimsmo
+# @email1: arne.grimsmo@gmail.com
+# @organization: University of Sherbrooke
+
+"""
+This module contains an implementation of the non-Markovian transfer tensor
+method (TTM), introduced in [1].
+
+[1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
+"""
+
+import numpy as np
+
+
+from qutip import spre, vector_to_operator, operator_to_vector
+from qutip.core import data as _data
+from ..solver import Result, SolverOptions
+
+
+class TTMSolverOptions:
+    """Class of options for the Transfer Tensor Method solver.
+
+    Attributes
+    ----------
+    dynmaps : list of :class:`qutip.Qobj`
+        List of precomputed dynamical maps (superoperators),
+        or a callback function that returns the
+        superoperator at a given time.
+
+    times : array_like
+        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
+
+    learningtimes : array_like
+        List of times :math:`t_k` to use as learning times if argument
+        `dynmaps` is a callback function.
+
+    thres : float
+        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
+        treshold.
+
+    options : :class:`qutip.solver.SolverOptions`
+        Generic solver options.
+    """
+
+    def __init__(self, dynmaps=None, times=[], learningtimes=[],
+                 thres=0.0, options=None):
+        if options is None:
+            options = SolverOptions()
+
+        self.dynmaps = dynmaps
+        self.times = times
+        self.learningtimes = learningtimes
+        self.thres = thres
+        self.store_states = options['store_states']
+
+
+def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
+             **kwargs):
+    """
+    Solve time-evolution using the Transfer Tensor Method, based on a set of
+    precomputed dynamical maps.
+
+    Parameters
+    ----------
+    dynmaps : list of :class:`qutip.Qobj`
+        List of precomputed dynamical maps (superoperators),
+        or a callback function that returns the
+        superoperator at a given time.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : array_like
+        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
+        Must be uniformily spaced.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    learningtimes : array_like
+        list of times :math:`t_k` for which we have knowledge of the dynamical
+        maps :math:`E(t_k)`.
+
+    tensors : array_like
+        optional list of precomputed tensors :math:`T_k`
+
+    kwargs : dictionary
+        Optional keyword arguments. See
+        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+
+    Returns
+    -------
+    output: :class:`qutip.solver.Result`
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+
+    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
+                           learningtimes=learningtimes, **kwargs)
+
+    diff = None
+
+    if rho0.isket:
+        rho0 = rho0.proj()
+
+    output = Result()
+    e_sops_data = []
+
+    if callable(e_ops):
+        n_expt_op = 0
+        expt_callback = True
+
+    else:
+        try:
+            tmp = e_ops[:]
+            del tmp
+
+            n_expt_op = len(e_ops)
+            expt_callback = False
+
+            if n_expt_op == 0:
+                # fall back on storing states
+                opt.store_states = True
+
+            for op in e_ops:
+                e_sops_data.append(spre(op).data)
+                if op.isherm and rho0.isherm:
+                    output.expect.append(np.zeros(len(times)))
+                else:
+                    output.expect.append(np.zeros(len(times), dtype=complex))
+        except TypeError:
+            raise TypeError("Argument 'e_ops' should be a callable or" +
+                            "list-like.")
+
+    if tensors is None:
+        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
+
+    if rho0.isoper:
+        # vectorize density matrix
+        rho0vec = operator_to_vector(rho0)
+    else:
+        # rho0 might be a super in which case we should not vectorize
+        rho0vec = rho0
+
+    K = len(tensors)
+    states = [rho0vec]
+    for n in range(1, len(times)):
+        # Set current state
+        state = None
+        for j in range(1, min(K, n + 1)):
+            tmp = tensors[j] * states[n - j]
+            state = tmp if state is None else tmp + state
+        # Append state to all states
+        states.append(state)
+    for i, r in enumerate(states):
+        if opt.store_states or expt_callback:
+            if r.type == 'operator-ket':
+                states[i] = vector_to_operator(r)
+            else:
+                states[i] = r
+            if expt_callback:
+                # use callback method
+                e_ops(times[i], states[i])
+        rdata = _data.column_stack(r.data)
+        for m in range(n_expt_op):
+            if output.expect[m].dtype == complex:
+                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
+            else:
+                output.expect[m][i] =\
+                    _data.expect_super(e_sops_data[m], rdata).real
+
+    output.solver = "ttmsolve"
+    output.times = times
+
+    output.ttmconvergence = diff
+
+    if opt.store_states:
+        output.states = states
+
+    return output
+
+
+def _generatetensors(dynmaps, learningtimes=None, **kwargs):
+    r"""
+    Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
+    :math:`E(t_k)`.
+
+    A stationary process is assumed, i.e., :math:`T_{n,k} = T_{n-k}`.
+
+    Parameters
+    ----------
+    dynmaps : list of :class:`qutip.Qobj`
+        List of precomputed dynamical maps (superoperators) at the times
+        specified in `learningtimes`, or a callback function that returns the
+        superoperator at a given time.
+
+    learningtimes : array_like
+        list of times :math:`t_k` to use if argument `dynmaps` is a callback
+        function.
+
+    kwargs : dictionary
+        Optional keyword arguments. See
+        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+
+    Returns
+    -------
+    Tlist: list of :class:`qutip.Qobj.`
+        A list of transfer tensors :math:`T_1,\dots,T_K`
+    """
+
+    # Determine if dynmaps is callable or list-like
+    if callable(dynmaps):
+        if learningtimes is None:
+            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
+                            "is a callback function.")
+
+        def dynmapfunc(n):
+            return dynmaps(learningtimes[n])
+
+        Kmax = len(learningtimes)
+    else:
+        try:
+            tmp = dynmaps[:]
+            del tmp
+
+            def dynmapfunc(n):
+                return dynmaps[n]
+
+            Kmax = len(dynmaps)
+        except TypeError:
+            raise TypeError("Argument 'dynmaps' should be a callable or" +
+                            "list-like.")
+
+    if "opt" not in kwargs:
+        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
+                               **kwargs)
+    else:
+        opt = kwargs['opt']
+
+    Tlist = []
+    diff = [0.0]
+    for n in range(Kmax):
+        T = dynmapfunc(n)
+        for m in range(1, n):
+            T -= Tlist[n - m] * dynmapfunc(m)
+        Tlist.append(T)
+        if n > 1:
+            diff.append((Tlist[-1] - Tlist[-2]).norm())
+            if diff[-1] < opt.thres:
+                # Below threshold for truncation
+                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
+                break
+    return Tlist, diff
diff --git a/qutip/solve/optionsclass.py b/qutip/solve/optionsclass.py
index 73c0e7090b..b82de81217 100644
--- a/qutip/solve/optionsclass.py
+++ b/qutip/solve/optionsclass.py
@@ -1,263 +1,263 @@
-
-
-class AllOptions:
-    """
-    Class that serve as the parent of all other options class.
-    """
-    # Temporary patch to make changes in solver's options minimal.
-    # TODO: Follow up PR based on #1812 should replace this.
-    def __init__(self):
-        self._isDefault = True
-        self._children = []
-        self._fullname = "qutip.settings"
-        self._defaultInstance = self
-
-    def _all_children(self):
-        optcls = []
-        for child in self._children:
-            optcls += child._all_children()
-        return optcls
-
-
-alloptions = AllOptions()
-
-
-def optionsclass(name, parent=alloptions):
-    """
-    Use as a decorator to register the options class to `qutip.settings`.
-    The default will be in added to qutip.setting.[parent].name.
-
-    The options class should contain an `options` dictionary containing the
-    option and their default value. Readonly settings can be defined in
-    `read_only_options` dict.
-
-    ```
-    >>> import qutip
-    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
-    >>> class MyOpt():
-    >>>     options = {"opt1": True}
-    >>>     read_only_options = {"hidden": 1}
-
-    >>> qutip.settings.solver.myopt['opt1'] = False
-    >>> qutip.settings.solver.myopt['hidden']
-    1
-
-    >>> qutip.settings.solver.myopt['hidden'] = 2
-    KeyError: "'hidden': Read-only value"
-
-    >>> print(qutip.settings.solver.myopt)
-    qutip.settings.solver.myopt:
-    opt1   : False
-    hidden : 1
-
-    print(MyOpt(opt1=2))
-    qutip.settings.solver.myopt:
-    opt1   : 2
-    hidden : 1
-    ```
-
-    It add the methods:
-        __init__(file=None, *, option=None... )
-            Allow to create from data in files or from defaults with attributes
-            overwritten by keywords.
-        __repr__():
-            Make a clean print for all 'options' and 'read_only_options'.
-        __getitem__(), __setitem__():
-            Pass through to 'self.options' and 'self.read_only_options'.
-            Option in 'self.read_only_options' can not be set.
-        save(file='qutiprc'):
-            Save the object in a file. 'qutiprc' file is loaded as default when
-            loading qutip.
-        load(file):
-            Overwrite with options previously saved.
-            Loaded options will have the same type as the default from one of:
-                (bool, int, float, complex, str, object)
-        reset():
-            If used on an instance, reset to the default in qutip.settings.
-            If used from qutip.settings..., go back to qutip's defaults.
-
-    """
-    # The real work is in _QtOptionsMaker
-    if isinstance(name, str):
-        # Called as
-        # @QtOptionsClass(name)
-        # class Options:
-        return _QtOptionsMaker(name, parent)
-    else:
-        # Called as
-        # @QtOptionsClass
-        # class Options:
-        return _QtOptionsMaker(name.__name__, parent)(name)
-
-
-class _QtOptionsMaker:
-    """
-    Apply the `optionsclass` decorator.
-    """
-    def __init__(self, name, parent):
-        self.name = name
-        self.parent = parent
-
-    def __call__(self, cls):
-        if hasattr(cls, "_isDefault"):
-            # Already a QtOptionsClass
-            return
-
-        if not hasattr(cls, "read_only_options"):
-            cls.read_only_options = {}
-        # type to used when loading from file.
-        cls._types = {key: type(val) for key, val in cls.options.items()}
-        # Name in settings and in files
-        cls._name = self.name
-        # Name when printing
-        cls._fullname = ".".join([self.parent._fullname, self.name])
-        # Is this instance the default for the other.
-        cls._isDefault = False
-        # Children in the settings tree
-        cls._children = []
-        # Build the default instance
-        # Do it before setting __init__ since it use this default
-        self._make_default(cls)
-
-        cls.__init__ = _make_init(cls.options)
-        cls.__repr__ = _repr
-        cls.__getitem__ = _getitem
-        cls.__setitem__ = _setitem
-        cls.__contains__ = _contains
-        cls.reset = _reset
-        cls.save = _save
-        cls.load = _load
-        cls._all_children = _all_children
-
-        return cls
-
-    def _make_default(self, cls):
-        """ Create the default and add it to the parent.
-        """
-        default = cls()
-        default.options = cls.options.copy()
-        default._isDefault = True
-        default._children = []
-        # The parent has the child twice: attribute and in a list.
-        self.parent._defaultInstance._children.append(default)
-        setattr(self.parent._defaultInstance, self.name, default)
-        cls._defaultInstance = default
-
-
-def _make_init(all_set):
-    attributes_kw = ",\n             ".join(["{}=None".format(key)
-                    for key in all_set])
-    attributes_set = "".join(["    if {0} is not None:\n"
-                              "        self.options['{0}'] = {0}\n".format(key)
-                     for key in all_set])
-    code = f"""
-def __init__(self, file='', *,
-             {attributes_kw},
-             _child_instance=False,
-             **kwargs):
-    self.options = self._defaultInstance.options.copy()
-{attributes_set}
-    if file:
-        self.load(file)
-    if hasattr(self, "extra_options"):
-        other_kw = dict()
-        for kw in kwargs:
-            if kw in self.extra_options:
-                self.options[kw] = kwargs[kw]
-            else:
-                other_kw[kw] = kwargs[kw]
-        kwargs = other_kw
-    self._children = []
-    for child in self._defaultInstance._children:
-        self._children.append(child.__class__(file, _child_instance=True,
-                                              **kwargs))
-        setattr(self, child._name, self._children[-1])
-        kwargs = self._children[-1].left_over_kwargs
-    if _child_instance:
-        self.left_over_kwargs = kwargs
-    elif kwargs:
-        raise KeyError("Unknown options: " +
-                       " ,".join(str(key) for key in kwargs))
-"""
-    ns = {}
-    exec(code, globals(), ns)
-    return ns["__init__"]
-
-
-def _repr(self, _recursive=True):
-    out = self._fullname + ":\n"
-    longest = max(len(key) for key in self.options)
-    if self.read_only_options:
-        longest_readonly = max(len(key) for key in self.read_only_options)
-        longest = max((longest, longest_readonly))
-    for key, val in self.options.items():
-        if isinstance(val, str):
-            out += "{:{width}} : '{}'\n".format(key, val,
-                                                width=longest)
-        else:
-            out += "{:{width}} : {}\n".format(key, val,
-                                              width=longest)
-    for key, val in self.read_only_options.items():
-        out += "{:{width}} : {}\n".format(key, val,
-                                          width=longest)
-    out += "\n"
-    if _recursive:
-         out += "".join([child.__repr__(_recursive)
-                         for child in self._children])
-    return out
-
-
-def _reset(self, _recursive=False):
-    """Reset instance to the default value or the default to Qutip's default"""
-    if self._isDefault:
-        self.options = self.__class__.options.copy()
-        if _recursive:
-            for child in self._children:
-                child.reset()
-    else:
-        self.options = self._defaultInstance.options.copy()
-
-
-def _all_children(self):
-    optcls = [self]
-    for child in self._children:
-         optcls += child._all_children()
-    return optcls
-
-
-def _save(self, file="qutiprc", _recursive=False):
-    """Save to desired file. 'qutiprc' if not specified"""
-    import qutip.configrc as qrc
-    if _recursive:
-        optcls = self._all_children()
-    else:
-        optcls = [self]
-    qrc.write_rc_object(file, optcls)
-
-
-def _load(self, file="qutiprc", _recursive=False):
-    """Load from desired file. 'qutiprc' if not specified"""
-    import qutip.configrc as qrc
-    if _recursive:
-        optcls = self._all_children()
-    else:
-        optcls = [self]
-    qrc.load_rc_object(file, optcls)
-
-
-def _contains(self, key):
-    return key in self.read_only_options or key in self.options
-
-
-def _getitem(self, key):
-    # Let the dict catch the KeyError
-    if key in self.read_only_options:
-        return self.read_only_options[key]
-    return self.options[key]
-
-
-def _setitem(self, key, value):
-    # Let the dict catch the KeyError
-    if key in self.read_only_options:
-        raise KeyError(f"'{key}': Read-only value")
-    self.options[key] = value
+
+
+class AllOptions:
+    """
+    Class that serve as the parent of all other options class.
+    """
+    # Temporary patch to make changes in solver's options minimal.
+    # TODO: Follow up PR based on #1812 should replace this.
+    def __init__(self):
+        self._isDefault = True
+        self._children = []
+        self._fullname = "qutip.settings"
+        self._defaultInstance = self
+
+    def _all_children(self):
+        optcls = []
+        for child in self._children:
+            optcls += child._all_children()
+        return optcls
+
+
+alloptions = AllOptions()
+
+
+def optionsclass(name, parent=alloptions):
+    """
+    Use as a decorator to register the options class to `qutip.settings`.
+    The default will be in added to qutip.setting.[parent].name.
+
+    The options class should contain an `options` dictionary containing the
+    option and their default value. Readonly settings can be defined in
+    `read_only_options` dict.
+
+    ```
+    >>> import qutip
+    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
+    >>> class MyOpt():
+    >>>     options = {"opt1": True}
+    >>>     read_only_options = {"hidden": 1}
+
+    >>> qutip.settings.solver.myopt['opt1'] = False
+    >>> qutip.settings.solver.myopt['hidden']
+    1
+
+    >>> qutip.settings.solver.myopt['hidden'] = 2
+    KeyError: "'hidden': Read-only value"
+
+    >>> print(qutip.settings.solver.myopt)
+    qutip.settings.solver.myopt:
+    opt1   : False
+    hidden : 1
+
+    print(MyOpt(opt1=2))
+    qutip.settings.solver.myopt:
+    opt1   : 2
+    hidden : 1
+    ```
+
+    It add the methods:
+        __init__(file=None, *, option=None... )
+            Allow to create from data in files or from defaults with attributes
+            overwritten by keywords.
+        __repr__():
+            Make a clean print for all 'options' and 'read_only_options'.
+        __getitem__(), __setitem__():
+            Pass through to 'self.options' and 'self.read_only_options'.
+            Option in 'self.read_only_options' can not be set.
+        save(file='qutiprc'):
+            Save the object in a file. 'qutiprc' file is loaded as default when
+            loading qutip.
+        load(file):
+            Overwrite with options previously saved.
+            Loaded options will have the same type as the default from one of:
+                (bool, int, float, complex, str, object)
+        reset():
+            If used on an instance, reset to the default in qutip.settings.
+            If used from qutip.settings..., go back to qutip's defaults.
+
+    """
+    # The real work is in _QtOptionsMaker
+    if isinstance(name, str):
+        # Called as
+        # @QtOptionsClass(name)
+        # class Options:
+        return _QtOptionsMaker(name, parent)
+    else:
+        # Called as
+        # @QtOptionsClass
+        # class Options:
+        return _QtOptionsMaker(name.__name__, parent)(name)
+
+
+class _QtOptionsMaker:
+    """
+    Apply the `optionsclass` decorator.
+    """
+    def __init__(self, name, parent):
+        self.name = name
+        self.parent = parent
+
+    def __call__(self, cls):
+        if hasattr(cls, "_isDefault"):
+            # Already a QtOptionsClass
+            return
+
+        if not hasattr(cls, "read_only_options"):
+            cls.read_only_options = {}
+        # type to used when loading from file.
+        cls._types = {key: type(val) for key, val in cls.options.items()}
+        # Name in settings and in files
+        cls._name = self.name
+        # Name when printing
+        cls._fullname = ".".join([self.parent._fullname, self.name])
+        # Is this instance the default for the other.
+        cls._isDefault = False
+        # Children in the settings tree
+        cls._children = []
+        # Build the default instance
+        # Do it before setting __init__ since it use this default
+        self._make_default(cls)
+
+        cls.__init__ = _make_init(cls.options)
+        cls.__repr__ = _repr
+        cls.__getitem__ = _getitem
+        cls.__setitem__ = _setitem
+        cls.__contains__ = _contains
+        cls.reset = _reset
+        cls.save = _save
+        cls.load = _load
+        cls._all_children = _all_children
+
+        return cls
+
+    def _make_default(self, cls):
+        """ Create the default and add it to the parent.
+        """
+        default = cls()
+        default.options = cls.options.copy()
+        default._isDefault = True
+        default._children = []
+        # The parent has the child twice: attribute and in a list.
+        self.parent._defaultInstance._children.append(default)
+        setattr(self.parent._defaultInstance, self.name, default)
+        cls._defaultInstance = default
+
+
+def _make_init(all_set):
+    attributes_kw = ",\n             ".join(["{}=None".format(key)
+                    for key in all_set])
+    attributes_set = "".join(["    if {0} is not None:\n"
+                              "        self.options['{0}'] = {0}\n".format(key)
+                     for key in all_set])
+    code = f"""
+def __init__(self, file='', *,
+             {attributes_kw},
+             _child_instance=False,
+             **kwargs):
+    self.options = self._defaultInstance.options.copy()
+{attributes_set}
+    if file:
+        self.load(file)
+    if hasattr(self, "extra_options"):
+        other_kw = dict()
+        for kw in kwargs:
+            if kw in self.extra_options:
+                self.options[kw] = kwargs[kw]
+            else:
+                other_kw[kw] = kwargs[kw]
+        kwargs = other_kw
+    self._children = []
+    for child in self._defaultInstance._children:
+        self._children.append(child.__class__(file, _child_instance=True,
+                                              **kwargs))
+        setattr(self, child._name, self._children[-1])
+        kwargs = self._children[-1].left_over_kwargs
+    if _child_instance:
+        self.left_over_kwargs = kwargs
+    elif kwargs:
+        raise KeyError("Unknown options: " +
+                       " ,".join(str(key) for key in kwargs))
+"""
+    ns = {}
+    exec(code, globals(), ns)
+    return ns["__init__"]
+
+
+def _repr(self, _recursive=True):
+    out = self._fullname + ":\n"
+    longest = max(len(key) for key in self.options)
+    if self.read_only_options:
+        longest_readonly = max(len(key) for key in self.read_only_options)
+        longest = max((longest, longest_readonly))
+    for key, val in self.options.items():
+        if isinstance(val, str):
+            out += "{:{width}} : '{}'\n".format(key, val,
+                                                width=longest)
+        else:
+            out += "{:{width}} : {}\n".format(key, val,
+                                              width=longest)
+    for key, val in self.read_only_options.items():
+        out += "{:{width}} : {}\n".format(key, val,
+                                          width=longest)
+    out += "\n"
+    if _recursive:
+         out += "".join([child.__repr__(_recursive)
+                         for child in self._children])
+    return out
+
+
+def _reset(self, _recursive=False):
+    """Reset instance to the default value or the default to Qutip's default"""
+    if self._isDefault:
+        self.options = self.__class__.options.copy()
+        if _recursive:
+            for child in self._children:
+                child.reset()
+    else:
+        self.options = self._defaultInstance.options.copy()
+
+
+def _all_children(self):
+    optcls = [self]
+    for child in self._children:
+         optcls += child._all_children()
+    return optcls
+
+
+def _save(self, file="qutiprc", _recursive=False):
+    """Save to desired file. 'qutiprc' if not specified"""
+    import qutip.configrc as qrc
+    if _recursive:
+        optcls = self._all_children()
+    else:
+        optcls = [self]
+    qrc.write_rc_object(file, optcls)
+
+
+def _load(self, file="qutiprc", _recursive=False):
+    """Load from desired file. 'qutiprc' if not specified"""
+    import qutip.configrc as qrc
+    if _recursive:
+        optcls = self._all_children()
+    else:
+        optcls = [self]
+    qrc.load_rc_object(file, optcls)
+
+
+def _contains(self, key):
+    return key in self.read_only_options or key in self.options
+
+
+def _getitem(self, key):
+    # Let the dict catch the KeyError
+    if key in self.read_only_options:
+        return self.read_only_options[key]
+    return self.options[key]
+
+
+def _setitem(self, key, value):
+    # Let the dict catch the KeyError
+    if key in self.read_only_options:
+        raise KeyError(f"'{key}': Read-only value")
+    self.options[key] = value
diff --git a/qutip/solve/parallel.py b/qutip/solve/parallel.py
index 02f0d8f7c3..36e35b8531 100644
--- a/qutip/solve/parallel.py
+++ b/qutip/solve/parallel.py
@@ -1,241 +1,241 @@
-"""
-This function provides functions for parallel execution of loops and function
-mappings, using the builtin Python module multiprocessing.
-"""
-__all__ = ['parallel_map', 'serial_map']
-
-from scipy import array
-import multiprocessing
-from functools import partial
-import os
-import sys
-import signal
-from qutip.settings import settings as qset
-from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
-
-
-if sys.platform == 'darwin':
-    Pool = multiprocessing.get_context('fork').Pool
-else:
-    Pool = multiprocessing.Pool
-
-
-def _task_wrapper(args):
-    try:
-        return args[0](*args[1])
-    except KeyboardInterrupt:
-        os.kill(args[2], signal.SIGINT)
-        sys.exit(1)
-
-
-def _task_wrapper_with_args(args, user_args):
-    try:
-        return args[0](*args[1], **user_args)
-    except KeyboardInterrupt:
-        os.kill(args[2], signal.SIGINT)
-        sys.exit(1)
-
-
-def parfor(func, *args, **kwargs):
-    """Executes a multi-variable function in parallel on the local machine.
-
-    Parallel execution of a for-loop over function `func` for multiple input
-    arguments and keyword arguments.
-
-    .. note::
-
-        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
-        instead of this function.
-
-    Parameters
-    ----------
-    func : function_type
-        A function to run in parallel on the local machine. The function 'func'
-        accepts a series of arguments that are passed to the function as
-        variables. In general, the function can have multiple input variables,
-        and these arguments must be passed in the same order as they are
-        defined in the function definition.  In addition, the user can pass
-        multiple keyword arguments to the function.
-
-    The following keyword argument is reserved:
-
-    num_cpus : int
-        Number of CPU's to use.  Default uses maximum number of CPU's.
-        Performance degrades if num_cpus is larger than the physical CPU
-        count of your machine.
-
-    Returns
-    -------
-    result : list
-        A ``list`` with length equal to number of input parameters
-        containing the output from `func`.
-
-    """
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    kw = _default_kwargs()
-    if 'num_cpus' in kwargs.keys():
-        kw['num_cpus'] = kwargs['num_cpus']
-        del kwargs['num_cpus']
-    if len(kwargs) != 0:
-        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
-    else:
-        task_func = _task_wrapper
-
-    # if kw['num_cpus'] > qset.num_cpus:
-    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
-    #          "is larger than physical number (%s)." % qset.num_cpus)
-    #    print("Reduce 'num_cpus' for greater performance.")
-
-    pool = Pool(processes=kw['num_cpus'])
-    args = [list(arg) for arg in args]
-    var = [[args[j][i] for j in range(len(args))]
-           for i in range(len(list(args[0])))]
-    try:
-        map_args = ((func, v, os.getpid()) for v in var)
-        par_return = list(pool.map(task_func, map_args))
-
-        pool.terminate()
-        pool.join()
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        if isinstance(par_return[0], tuple):
-            par_return = [elem for elem in par_return]
-            num_elems = len(par_return[0])
-            dt = [type(ii) for ii in par_return[0]]
-            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
-                    for ii in range(num_elems)]
-        else:
-            return par_return
-
-    except KeyboardInterrupt:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        pool.terminate()
-
-
-def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-    """
-    Serial mapping function with the same call signature as parallel_map, for
-    easy switching between serial and parallel execution. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    This function work as a drop-in replacement of
-    :func:`qutip.parallel.parallel_map`.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    progress_bar : ProgressBar
-        Progress bar class instance for showing progress.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for each
-        value in ``values``.
-
-    """
-    try:
-        progress_bar = kwargs['progress_bar']
-        if progress_bar is True:
-            progress_bar = TextProgressBar()
-    except:
-        progress_bar = BaseProgressBar()
-
-    progress_bar.start(len(values))
-    results = []
-    for n, value in enumerate(values):
-        progress_bar.update(n)
-        result = task(value, *task_args, **task_kwargs)
-        results.append(result)
-    progress_bar.finished()
-
-    return results
-
-
-def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    progress_bar : ProgressBar
-        Progress bar class instance for showing progress.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``.
-
-    """
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    kw = _default_kwargs()
-    if 'num_cpus' in kwargs:
-        kw['num_cpus'] = kwargs['num_cpus']
-
-    try:
-        progress_bar = kwargs['progress_bar']
-        if progress_bar is True:
-            progress_bar = TextProgressBar()
-    except:
-        progress_bar = BaseProgressBar()
-
-    progress_bar.start(len(values))
-    nfinished = [0]
-
-    def _update_progress_bar(x):
-        nfinished[0] += 1
-        progress_bar.update(nfinished[0])
-
-    try:
-        pool = Pool(processes=kw['num_cpus'])
-
-        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
-                                      _update_progress_bar)
-                     for value in values]
-
-        while not all([ar.ready() for ar in async_res]):
-            for ar in async_res:
-                ar.wait(timeout=0.1)
-
-        pool.terminate()
-        pool.join()
-
-    except KeyboardInterrupt as e:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-        pool.terminate()
-        pool.join()
-        raise e
-
-    progress_bar.finished()
-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-    return [ar.get() for ar in async_res]
-
-
-def _default_kwargs():
-
-    settings = {'num_cpus': multiprocessing.cpu_count()}
-    return settings
+"""
+This function provides functions for parallel execution of loops and function
+mappings, using the builtin Python module multiprocessing.
+"""
+__all__ = ['parallel_map', 'serial_map']
+
+from scipy import array
+import multiprocessing
+from functools import partial
+import os
+import sys
+import signal
+from qutip.settings import settings as qset
+from qutip.ui.progressbar import BaseProgressBar, TextProgressBar
+
+
+if sys.platform == 'darwin':
+    Pool = multiprocessing.get_context('fork').Pool
+else:
+    Pool = multiprocessing.Pool
+
+
+def _task_wrapper(args):
+    try:
+        return args[0](*args[1])
+    except KeyboardInterrupt:
+        os.kill(args[2], signal.SIGINT)
+        sys.exit(1)
+
+
+def _task_wrapper_with_args(args, user_args):
+    try:
+        return args[0](*args[1], **user_args)
+    except KeyboardInterrupt:
+        os.kill(args[2], signal.SIGINT)
+        sys.exit(1)
+
+
+def parfor(func, *args, **kwargs):
+    """Executes a multi-variable function in parallel on the local machine.
+
+    Parallel execution of a for-loop over function `func` for multiple input
+    arguments and keyword arguments.
+
+    .. note::
+
+        From QuTiP 3.1, we recommend to use :func:`qutip.parallel.parallel_map`
+        instead of this function.
+
+    Parameters
+    ----------
+    func : function_type
+        A function to run in parallel on the local machine. The function 'func'
+        accepts a series of arguments that are passed to the function as
+        variables. In general, the function can have multiple input variables,
+        and these arguments must be passed in the same order as they are
+        defined in the function definition.  In addition, the user can pass
+        multiple keyword arguments to the function.
+
+    The following keyword argument is reserved:
+
+    num_cpus : int
+        Number of CPU's to use.  Default uses maximum number of CPU's.
+        Performance degrades if num_cpus is larger than the physical CPU
+        count of your machine.
+
+    Returns
+    -------
+    result : list
+        A ``list`` with length equal to number of input parameters
+        containing the output from `func`.
+
+    """
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    kw = _default_kwargs()
+    if 'num_cpus' in kwargs.keys():
+        kw['num_cpus'] = kwargs['num_cpus']
+        del kwargs['num_cpus']
+    if len(kwargs) != 0:
+        task_func = partial(_task_wrapper_with_args, user_args=kwargs)
+    else:
+        task_func = _task_wrapper
+
+    # if kw['num_cpus'] > qset.num_cpus:
+    #    print("Requested number of CPUs (%s) " % kw['num_cpus'] +
+    #          "is larger than physical number (%s)." % qset.num_cpus)
+    #    print("Reduce 'num_cpus' for greater performance.")
+
+    pool = Pool(processes=kw['num_cpus'])
+    args = [list(arg) for arg in args]
+    var = [[args[j][i] for j in range(len(args))]
+           for i in range(len(list(args[0])))]
+    try:
+        map_args = ((func, v, os.getpid()) for v in var)
+        par_return = list(pool.map(task_func, map_args))
+
+        pool.terminate()
+        pool.join()
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+        if isinstance(par_return[0], tuple):
+            par_return = [elem for elem in par_return]
+            num_elems = len(par_return[0])
+            dt = [type(ii) for ii in par_return[0]]
+            return [array([elem[ii] for elem in par_return], dtype=dt[ii])
+                    for ii in range(num_elems)]
+        else:
+            return par_return
+
+    except KeyboardInterrupt:
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+        pool.terminate()
+
+
+def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
+    """
+    Serial mapping function with the same call signature as parallel_map, for
+    easy switching between serial and parallel execution. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    This function work as a drop-in replacement of
+    :func:`qutip.parallel.parallel_map`.
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    progress_bar : ProgressBar
+        Progress bar class instance for showing progress.
+
+    Returns
+    --------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for each
+        value in ``values``.
+
+    """
+    try:
+        progress_bar = kwargs['progress_bar']
+        if progress_bar is True:
+            progress_bar = TextProgressBar()
+    except:
+        progress_bar = BaseProgressBar()
+
+    progress_bar.start(len(values))
+    results = []
+    for n, value in enumerate(values):
+        progress_bar.update(n)
+        result = task(value, *task_args, **task_kwargs)
+        results.append(result)
+    progress_bar.finished()
+
+    return results
+
+
+def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    progress_bar : ProgressBar
+        Progress bar class instance for showing progress.
+
+    Returns
+    --------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``.
+
+    """
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    kw = _default_kwargs()
+    if 'num_cpus' in kwargs:
+        kw['num_cpus'] = kwargs['num_cpus']
+
+    try:
+        progress_bar = kwargs['progress_bar']
+        if progress_bar is True:
+            progress_bar = TextProgressBar()
+    except:
+        progress_bar = BaseProgressBar()
+
+    progress_bar.start(len(values))
+    nfinished = [0]
+
+    def _update_progress_bar(x):
+        nfinished[0] += 1
+        progress_bar.update(nfinished[0])
+
+    try:
+        pool = Pool(processes=kw['num_cpus'])
+
+        async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,
+                                      _update_progress_bar)
+                     for value in values]
+
+        while not all([ar.ready() for ar in async_res]):
+            for ar in async_res:
+                ar.wait(timeout=0.1)
+
+        pool.terminate()
+        pool.join()
+
+    except KeyboardInterrupt as e:
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+        pool.terminate()
+        pool.join()
+        raise e
+
+    progress_bar.finished()
+    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+    return [ar.get() for ar in async_res]
+
+
+def _default_kwargs():
+
+    settings = {'num_cpus': multiprocessing.cpu_count()}
+    return settings
diff --git a/qutip/solve/pdpsolve.py b/qutip/solve/pdpsolve.py
index e295b23783..1a1d2964d2 100644
--- a/qutip/solve/pdpsolve.py
+++ b/qutip/solve/pdpsolve.py
@@ -1,575 +1,575 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from numpy.random import RandomState
-
-from .. import (
-    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
-)
-from ..core import data as _data
-from .solver import Result, SolverOptions
-from .parallel import serial_map
-from ..ui.progressbar import TextProgressBar
-from ..settings import settings
-debug = settings.debug
-
-
-class StochasticSolverOptions:
-    """
-    Class of options for stochastic (piecewse deterministic process) PDP
-    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
-    :func:`qutip.pdpsolve.smepdpsolve`.
-    Options can be specified either as arguments to the constructor::
-
-        sso = StochasticSolverOptions(nsubsteps=100, ...)
-
-    or by changing the class attributes after creation::
-
-        sso = StochasticSolverOptions()
-        sso.nsubsteps = 1000
-
-    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
-    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
-    the constructor of these class, and internally they use these arguments to
-    construct an instance of this class, so it is rarely needed to explicitly
-    create an instance of this class.
-
-    Attributes
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        List of deterministic collapse operators.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    m_ops : list of :class:`qutip.Qobj`
-        List of operators representing the measurement operators. The expected
-        format is a nested list with one measurement operator for each
-        stochastic increament, for each stochastic collapse operator.
-
-    args : dict / list
-        List of dictionary of additional problem-specific parameters.
-        Implicit methods can adjust tolerance via args = {'tol':value}
-
-    ntraj : int
-        Number of trajectors.
-
-    nsubsteps : int
-        Number of sub steps between each time-spep given in `times`.
-
-    d1 : function
-        Function for calculating the operator-valued coefficient to the
-        deterministic increment dt.
-
-    d2 : function
-        Function for calculating the operator-valued coefficient to the
-        stochastic increment(s) dW_n, where n is in [0, d2_len[.
-
-    d2_len : int (default 1)
-        The number of stochastic increments in the process.
-
-    dW_factors : array
-        Array of length d2_len, containing scaling factors for each
-        measurement operator in m_ops.
-
-    rhs : function
-        Function for calculating the deterministic and stochastic contributions
-        to the right-hand side of the stochastic differential equation. This
-        only needs to be specified when implementing a custom SDE solver.
-
-    generate_A_ops : function
-        Function that generates a list of pre-computed operators or super-
-        operators. These precomputed operators are used in some d1 and d2
-        functions.
-
-    generate_noise : function
-        Function for generate an array of pre-computed noise signal.
-
-    homogeneous : bool (True)
-        Wheter or not the stochastic process is homogenous. Inhomogenous
-        processes are only supported for poisson distributions.
-
-    solver : string
-        Name of the solver method to use for solving the stochastic
-        equations. Valid values are:
-        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
-        'pc-euler' is a predictor-corrector method which is more
-        stable than explicit methods,
-        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
-        'milstein-imp' is semi-implicit Milstein method,
-        3/2 order algorithms: 'taylor15',
-        'taylor15-imp' is semi-implicit Taylor 1.5 method.
-        Implicit methods can adjust tolerance via args = {'tol':value},
-        default is {'tol':1e-6}
-
-    method : string ('homodyne', 'heterodyne', 'photocurrent')
-        The name of the type of measurement process that give rise to the
-        stochastic equation to solve. Specifying a method with this keyword
-        argument is a short-hand notation for using pre-defined d1 and d2
-        functions for the corresponding stochastic processes.
-
-    distribution : string ('normal', 'poisson')
-        The name of the distribution used for the stochastic increments.
-
-    store_measurements : bool (default False)
-        Whether or not to store the measurement results in the
-        :class:`qutip.solver.Result` instance returned by the solver.
-
-    noise : array
-        Vector specifying the noise.
-
-    normalize : bool (default True)
-        Whether or not to normalize the wave function during the evolution.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options.
-
-    map_func: function
-        A map function or managing the calls to single-trajactory solvers.
-
-    map_kwargs: dictionary
-        Optional keyword arguments to the map_func function function.
-
-    progress_bar : :class:`qutip.ui.BaseProgressBar`
-        Optional progress bar class instance.
-    """
-    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
-                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
-                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
-                 generate_A_ops=None, generate_noise=None, homogeneous=True,
-                 solver=None, method=None, distribution='normal',
-                 store_measurement=False, noise=None, normalize=True,
-                 options=None, progress_bar=None, map_func=None,
-                 map_kwargs=None):
-
-        if options is None:
-            options = SolverOptions()
-
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
-        self.H = H
-        self.d1 = d1
-        self.d2 = d2
-        self.d2_len = d2_len
-        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
-        self.state0 = state0
-        self.times = times
-        self.c_ops = c_ops
-        self.sc_ops = sc_ops
-        self.e_ops = e_ops
-        self.m_ops = m_ops
-
-        self.ntraj = ntraj
-        self.nsubsteps = nsubsteps
-        self.solver = solver
-        self.method = method
-        self.distribution = distribution
-        self.homogeneous = homogeneous
-        self.rhs = rhs
-        self.options = options
-        self.progress_bar = progress_bar
-        self.store_measurement = store_measurement
-        self.store_states = options['store_states']
-        self.noise = noise
-        self.args = args
-        self.normalize = normalize
-
-        self.generate_noise = generate_noise
-        self.generate_A_ops = generate_A_ops
-
-        if self.ntraj > 1 and map_func:
-            self.map_func = map_func
-        else:
-            self.map_func = serial_map
-
-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-
-        # Does any operator depend on time?
-        self.td = False
-        if not isinstance(H, Qobj):
-            self.td = True
-        for ops in c_ops:
-            if not isinstance(ops, Qobj):
-                self.td = True
-        for ops in sc_ops:
-            if not isinstance(ops, Qobj):
-                self.td = True
-
-
-def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-    trajectory simulations.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
-                                  e_ops=e_ops, **kwargs)
-
-    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for density matrix
-    evolution.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
-                                  e_ops=e_ops, **kwargs)
-
-    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-# -----------------------------------------------------------------------------
-# Generic parameterized stochastic SE PDP solver
-#
-def _ssepdpsolve_generic(sso, options, progress_bar):
-    """
-    For internal use. See ssepdpsolve.
-    """
-    N_store = len(sso.times)
-    N_substeps = sso.nsubsteps
-    dt = (sso.times[1] - sso.times[0]) / N_substeps
-    nt = sso.ntraj
-
-    data = Result()
-    data.solver = "sepdpsolve"
-    data.times = sso.tlist
-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.jump_times = []
-    data.jump_op_idx = []
-
-    # effective hamiltonian for deterministic part
-    Heff = sso.H
-    for c in sso.c_ops:
-        Heff += -0.5j * c.dag() * c
-
-    progress_bar.start(sso.ntraj)
-    for n in range(sso.ntraj):
-        progress_bar.update(n)
-        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
-
-        states_list, jump_times, jump_op_idx = \
-            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
-                                           N_store, N_substeps,
-                                           psi_t, sso.state0.dims,
-                                           sso.c_ops, sso.e_ops)
-
-        data.states.append(states_list)
-        data.jump_times.append(jump_times)
-        data.jump_op_idx.append(jump_op_idx)
-
-    progress_bar.finished()
-
-    # average density matrices
-    if options['average_states'] and np.any(data.states):
-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-                       for n in range(len(data.times))]
-
-    # average
-    data.expect = data.expect / nt
-
-    # standard error
-    if nt > 1:
-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-    else:
-        data.se = None
-
-    # convert complex data to real if hermitian
-    data.expect = [np.real(data.expect[n, :])
-                   if e.isherm else data.expect[n, :]
-                   for n, e in enumerate(sso.e_ops)]
-
-    return data
-
-
-def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
-    """
-    Internal function. See ssepdpsolve.
-    """
-    states_list = []
-
-    phi_t = psi_t.copy()
-
-    prng = RandomState()  # todo: seed it
-    r_jump, r_op = prng.rand(2)
-
-    jump_times = []
-    jump_op_idx = []
-
-    for t_idx, t in enumerate(times):
-
-        if e_ops:
-            for e_idx, e in enumerate(e_ops):
-                s = _data.expect(e, psi_t)
-                data.expect[e_idx, t_idx] += s
-                data.ss[e_idx, t_idx] += s ** 2
-        else:
-            states_list.append(Qobj(psi_t.to_array(), dims=dims))
-
-        for j in range(N_substeps):
-
-            if _data.norm.l2(phi_t) ** 2 < r_jump:
-                # jump occurs
-                p = np.array([
-                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-                    for c in c_ops
-                ])
-                p = np.cumsum(p / np.sum(p))
-                n = np.where(p >= r_op)[0][0]
-
-                # apply jump
-                psi_t = _data.matmul(c_ops[n].data, psi_t)
-                psi_t /= _data.norm.l2(psi_t)
-                phi_t = psi_t.copy()
-
-                # store info about jump
-                jump_times.append(times[t_idx] + dt * j)
-                jump_op_idx.append(n)
-
-                # get new random numbers for next jump
-                r_jump, r_op = prng.rand(2)
-
-            # deterministic evolution wihtout correction for norm decay
-            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
-
-            # deterministic evolution with correction for norm decay
-            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
-            A = 0.5 * np.sum([
-                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
-                for c in c_ops
-            ])
-            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
-
-            # increment wavefunctions
-            phi_t = _data.add(phi_t, dphi_t)
-            psi_t = _data.add(psi_t, dpsi_t)
-
-            # ensure that normalized wavefunction remains normalized
-            # this allows larger time step than otherwise would be possible
-            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
-
-    return states_list, jump_times, jump_op_idx
-
-
-# -----------------------------------------------------------------------------
-# Generic parameterized stochastic ME PDP solver
-#
-def _smepdpsolve_generic(sso, options, progress_bar):
-    """
-    For internal use. See smepdpsolve.
-    """
-    N_store = len(sso.times)
-    N_substeps = sso.nsubsteps
-    dt = (sso.times[1] - sso.times[0]) / N_substeps
-    nt = sso.ntraj
-
-    data = Result()
-    data.solver = "smepdpsolve"
-    data.times = sso.times
-    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
-    data.jump_times = []
-    data.jump_op_idx = []
-
-    # Liouvillian for the deterministic part.
-    # needs to be modified for TD systems
-    L = liouvillian(sso.H, sso.c_ops)
-
-    progress_bar.start(sso.ntraj)
-
-    for n in range(sso.ntraj):
-        progress_bar.update(n)
-        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
-        rho_t = _data.column_stack_dense(rho_t)
-
-        states_list, jump_times, jump_op_idx = \
-            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
-                                           N_store, N_substeps,
-                                           rho_t, sso.rho0.dims,
-                                           sso.c_ops, sso.e_ops)
-
-        data.states.append(states_list)
-        data.jump_times.append(jump_times)
-        data.jump_op_idx.append(jump_op_idx)
-
-    progress_bar.finished()
-
-    # average density matrices
-    if options['average_states'] and np.any(data.states):
-        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
-                       for n in range(len(data.times))]
-
-    # average
-    data.expect = data.expect / sso.ntraj
-
-    # standard error
-    if nt > 1:
-        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
-    else:
-        data.se = None
-
-    return data
-
-def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
-    """
-    Internal function. See smepdpsolve.
-    """
-    states_list = []
-
-    rho_t = np.copy(rho_t)
-    sigma_t = np.copy(rho_t)
-
-    prng = RandomState()  # todo: seed it
-    r_jump, r_op = prng.rand(2)
-
-    jump_times = []
-    jump_op_idx = []
-
-    for t_idx, t in enumerate(times):
-
-        if e_ops:
-            for e_idx, e in enumerate(e_ops):
-                data.expect[e_idx, t_idx] +=\
-                    _data.expect_super(e, rho_t)
-        else:
-            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
-
-        for j in range(N_substeps):
-
-            if sigma_t.norm() < r_jump:
-                # jump occurs
-                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
-                p = np.cumsum(p / np.sum(p))
-                n = np.where(p >= r_op)[0][0]
-
-                # apply jump
-                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
-                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
-                sigma_t = np.copy(rho_t)
-
-                # store info about jump
-                jump_times.append(times[t_idx] + dt * j)
-                jump_op_idx.append(n)
-
-                # get new random numbers for next jump
-                r_jump, r_op = prng.rand(2)
-
-            # deterministic evolution wihtout correction for norm decay
-            dsigma_t = _data.matmul(L.data, sigma_t) * dt
-
-            # deterministic evolution with correction for norm decay
-            drho_t = _data.matmul(L.data, rho_t) * dt
-
-            # increment density matrices
-            sigma_t = _data.add(sigma_t, dsigma_t)
-            rho_t = _data.add(rho_t, drho_t)
-
-    return states_list, jump_times, jump_op_idx
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from numpy.random import RandomState
+
+from .. import (
+    Qobj, expect, spre, spost, stack_columns, unstack_columns, liouvillian,
+)
+from ..core import data as _data
+from .solver import Result, SolverOptions
+from .parallel import serial_map
+from ..ui.progressbar import TextProgressBar
+from ..settings import settings
+debug = settings.debug
+
+
+class StochasticSolverOptions:
+    """
+    Class of options for stochastic (piecewse deterministic process) PDP
+    solvers such as :func:`qutip.pdpsolve.ssepdpsolve`,
+    :func:`qutip.pdpsolve.smepdpsolve`.
+    Options can be specified either as arguments to the constructor::
+
+        sso = StochasticSolverOptions(nsubsteps=100, ...)
+
+    or by changing the class attributes after creation::
+
+        sso = StochasticSolverOptions()
+        sso.nsubsteps = 1000
+
+    The stochastic solvers :func:`qutip.pdpsolve.ssepdpsolve` and
+    :func:`qutip.pdpsolve.smepdpsolve` all take the same keyword arguments as
+    the constructor of these class, and internally they use these arguments to
+    construct an instance of this class, so it is rarely needed to explicitly
+    create an instance of this class.
+
+    Attributes
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    state0 : :class:`qutip.Qobj`
+        Initial state vector (ket) or density matrix.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        List of deterministic collapse operators.
+
+    sc_ops : list of :class:`qutip.Qobj`
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the equation of motion according to how the d1 and d2 functions
+        are defined.
+
+    e_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    m_ops : list of :class:`qutip.Qobj`
+        List of operators representing the measurement operators. The expected
+        format is a nested list with one measurement operator for each
+        stochastic increament, for each stochastic collapse operator.
+
+    args : dict / list
+        List of dictionary of additional problem-specific parameters.
+        Implicit methods can adjust tolerance via args = {'tol':value}
+
+    ntraj : int
+        Number of trajectors.
+
+    nsubsteps : int
+        Number of sub steps between each time-spep given in `times`.
+
+    d1 : function
+        Function for calculating the operator-valued coefficient to the
+        deterministic increment dt.
+
+    d2 : function
+        Function for calculating the operator-valued coefficient to the
+        stochastic increment(s) dW_n, where n is in [0, d2_len[.
+
+    d2_len : int (default 1)
+        The number of stochastic increments in the process.
+
+    dW_factors : array
+        Array of length d2_len, containing scaling factors for each
+        measurement operator in m_ops.
+
+    rhs : function
+        Function for calculating the deterministic and stochastic contributions
+        to the right-hand side of the stochastic differential equation. This
+        only needs to be specified when implementing a custom SDE solver.
+
+    generate_A_ops : function
+        Function that generates a list of pre-computed operators or super-
+        operators. These precomputed operators are used in some d1 and d2
+        functions.
+
+    generate_noise : function
+        Function for generate an array of pre-computed noise signal.
+
+    homogeneous : bool (True)
+        Wheter or not the stochastic process is homogenous. Inhomogenous
+        processes are only supported for poisson distributions.
+
+    solver : string
+        Name of the solver method to use for solving the stochastic
+        equations. Valid values are:
+        1/2 order algorithms: 'euler-maruyama', 'fast-euler-maruyama',
+        'pc-euler' is a predictor-corrector method which is more
+        stable than explicit methods,
+        1 order algorithms: 'milstein', 'fast-milstein', 'platen',
+        'milstein-imp' is semi-implicit Milstein method,
+        3/2 order algorithms: 'taylor15',
+        'taylor15-imp' is semi-implicit Taylor 1.5 method.
+        Implicit methods can adjust tolerance via args = {'tol':value},
+        default is {'tol':1e-6}
+
+    method : string ('homodyne', 'heterodyne', 'photocurrent')
+        The name of the type of measurement process that give rise to the
+        stochastic equation to solve. Specifying a method with this keyword
+        argument is a short-hand notation for using pre-defined d1 and d2
+        functions for the corresponding stochastic processes.
+
+    distribution : string ('normal', 'poisson')
+        The name of the distribution used for the stochastic increments.
+
+    store_measurements : bool (default False)
+        Whether or not to store the measurement results in the
+        :class:`qutip.solver.Result` instance returned by the solver.
+
+    noise : array
+        Vector specifying the noise.
+
+    normalize : bool (default True)
+        Whether or not to normalize the wave function during the evolution.
+
+    options : :class:`qutip.solver.SolverOptions`
+        Generic solver options.
+
+    map_func: function
+        A map function or managing the calls to single-trajactory solvers.
+
+    map_kwargs: dictionary
+        Optional keyword arguments to the map_func function function.
+
+    progress_bar : :class:`qutip.ui.BaseProgressBar`
+        Optional progress bar class instance.
+    """
+    def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
+                 e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1,
+                 d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None,
+                 generate_A_ops=None, generate_noise=None, homogeneous=True,
+                 solver=None, method=None, distribution='normal',
+                 store_measurement=False, noise=None, normalize=True,
+                 options=None, progress_bar=None, map_func=None,
+                 map_kwargs=None):
+
+        if options is None:
+            options = SolverOptions()
+
+        if progress_bar is None:
+            progress_bar = TextProgressBar()
+
+        self.H = H
+        self.d1 = d1
+        self.d2 = d2
+        self.d2_len = d2_len
+        self.dW_factors = dW_factors  # if dW_factors else np.ones(d2_len)
+        self.state0 = state0
+        self.times = times
+        self.c_ops = c_ops
+        self.sc_ops = sc_ops
+        self.e_ops = e_ops
+        self.m_ops = m_ops
+
+        self.ntraj = ntraj
+        self.nsubsteps = nsubsteps
+        self.solver = solver
+        self.method = method
+        self.distribution = distribution
+        self.homogeneous = homogeneous
+        self.rhs = rhs
+        self.options = options
+        self.progress_bar = progress_bar
+        self.store_measurement = store_measurement
+        self.store_states = options['store_states']
+        self.noise = noise
+        self.args = args
+        self.normalize = normalize
+
+        self.generate_noise = generate_noise
+        self.generate_A_ops = generate_A_ops
+
+        if self.ntraj > 1 and map_func:
+            self.map_func = map_func
+        else:
+            self.map_func = serial_map
+
+        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
+
+        # Does any operator depend on time?
+        self.td = False
+        if not isinstance(H, Qobj):
+            self.td = True
+        for ops in c_ops:
+            if not isinstance(ops, Qobj):
+                self.td = True
+        for ops in sc_ops:
+            if not isinstance(ops, Qobj):
+                self.td = True
+
+
+def main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for wavefunction
+    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
+    trajectory simulations.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(H=H, state0=psi0, times=times, c_ops=c_ops,
+                                  e_ops=e_ops, **kwargs)
+
+    res = _ssepdpsolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+    return res
+
+
+def main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for density matrix
+    evolution.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    sc_ops : list of :class:`qutip.Qobj`
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the equation of motion according to how the d1 and d2 functions
+        are defined.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(H=H, state0=rho0, times=times, c_ops=c_ops,
+                                  e_ops=e_ops, **kwargs)
+
+    res = _smepdpsolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+    return res
+
+
+# -----------------------------------------------------------------------------
+# Generic parameterized stochastic SE PDP solver
+#
+def _ssepdpsolve_generic(sso, options, progress_bar):
+    """
+    For internal use. See ssepdpsolve.
+    """
+    N_store = len(sso.times)
+    N_substeps = sso.nsubsteps
+    dt = (sso.times[1] - sso.times[0]) / N_substeps
+    nt = sso.ntraj
+
+    data = Result()
+    data.solver = "sepdpsolve"
+    data.times = sso.tlist
+    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+    data.ss = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+    data.jump_times = []
+    data.jump_op_idx = []
+
+    # effective hamiltonian for deterministic part
+    Heff = sso.H
+    for c in sso.c_ops:
+        Heff += -0.5j * c.dag() * c
+
+    progress_bar.start(sso.ntraj)
+    for n in range(sso.ntraj):
+        progress_bar.update(n)
+        psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
+
+        states_list, jump_times, jump_op_idx = \
+            _ssepdpsolve_single_trajectory(data, Heff, dt, sso.times,
+                                           N_store, N_substeps,
+                                           psi_t, sso.state0.dims,
+                                           sso.c_ops, sso.e_ops)
+
+        data.states.append(states_list)
+        data.jump_times.append(jump_times)
+        data.jump_op_idx.append(jump_op_idx)
+
+    progress_bar.finished()
+
+    # average density matrices
+    if options['average_states'] and np.any(data.states):
+        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
+                       for n in range(len(data.times))]
+
+    # average
+    data.expect = data.expect / nt
+
+    # standard error
+    if nt > 1:
+        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
+    else:
+        data.se = None
+
+    # convert complex data to real if hermitian
+    data.expect = [np.real(data.expect[n, :])
+                   if e.isherm else data.expect[n, :]
+                   for n, e in enumerate(sso.e_ops)]
+
+    return data
+
+
+def _ssepdpsolve_single_trajectory(data, Heff, dt, times, N_store, N_substeps, psi_t, dims, c_ops, e_ops):
+    """
+    Internal function. See ssepdpsolve.
+    """
+    states_list = []
+
+    phi_t = psi_t.copy()
+
+    prng = RandomState()  # todo: seed it
+    r_jump, r_op = prng.rand(2)
+
+    jump_times = []
+    jump_op_idx = []
+
+    for t_idx, t in enumerate(times):
+
+        if e_ops:
+            for e_idx, e in enumerate(e_ops):
+                s = _data.expect(e, psi_t)
+                data.expect[e_idx, t_idx] += s
+                data.ss[e_idx, t_idx] += s ** 2
+        else:
+            states_list.append(Qobj(psi_t.to_array(), dims=dims))
+
+        for j in range(N_substeps):
+
+            if _data.norm.l2(phi_t) ** 2 < r_jump:
+                # jump occurs
+                p = np.array([
+                    _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
+                    for c in c_ops
+                ])
+                p = np.cumsum(p / np.sum(p))
+                n = np.where(p >= r_op)[0][0]
+
+                # apply jump
+                psi_t = _data.matmul(c_ops[n].data, psi_t)
+                psi_t /= _data.norm.l2(psi_t)
+                phi_t = psi_t.copy()
+
+                # store info about jump
+                jump_times.append(times[t_idx] + dt * j)
+                jump_op_idx.append(n)
+
+                # get new random numbers for next jump
+                r_jump, r_op = prng.rand(2)
+
+            # deterministic evolution wihtout correction for norm decay
+            dphi_t = (-1j*dt) * _data.matmul(Heff.data, phi_t)
+
+            # deterministic evolution with correction for norm decay
+            dpsi_t = (-1j*dt) * _data.matmul(Heff.data, psi_t)
+            A = 0.5 * np.sum([
+                _data.norm.l2(_data.matmul(c.data, psi_t)) ** 2
+                for c in c_ops
+            ])
+            dpsi_t = _data.add(dpsi_t, psi_t, scale=dt*A)
+
+            # increment wavefunctions
+            phi_t = _data.add(phi_t, dphi_t)
+            psi_t = _data.add(psi_t, dpsi_t)
+
+            # ensure that normalized wavefunction remains normalized
+            # this allows larger time step than otherwise would be possible
+            psi_t = _data.mul(psi_t, 1/_data.norm.l2(psi_t))
+
+    return states_list, jump_times, jump_op_idx
+
+
+# -----------------------------------------------------------------------------
+# Generic parameterized stochastic ME PDP solver
+#
+def _smepdpsolve_generic(sso, options, progress_bar):
+    """
+    For internal use. See smepdpsolve.
+    """
+    N_store = len(sso.times)
+    N_substeps = sso.nsubsteps
+    dt = (sso.times[1] - sso.times[0]) / N_substeps
+    nt = sso.ntraj
+
+    data = Result()
+    data.solver = "smepdpsolve"
+    data.times = sso.times
+    data.expect = np.zeros((len(sso.e_ops), N_store), dtype=complex)
+    data.jump_times = []
+    data.jump_op_idx = []
+
+    # Liouvillian for the deterministic part.
+    # needs to be modified for TD systems
+    L = liouvillian(sso.H, sso.c_ops)
+
+    progress_bar.start(sso.ntraj)
+
+    for n in range(sso.ntraj):
+        progress_bar.update(n)
+        rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
+        rho_t = _data.column_stack_dense(rho_t)
+
+        states_list, jump_times, jump_op_idx = \
+            _smepdpsolve_single_trajectory(data, L, dt, sso.times,
+                                           N_store, N_substeps,
+                                           rho_t, sso.rho0.dims,
+                                           sso.c_ops, sso.e_ops)
+
+        data.states.append(states_list)
+        data.jump_times.append(jump_times)
+        data.jump_op_idx.append(jump_op_idx)
+
+    progress_bar.finished()
+
+    # average density matrices
+    if options['average_states'] and np.any(data.states):
+        data.states = [sum([data.states[m][n] for m in range(nt)]).unit()
+                       for n in range(len(data.times))]
+
+    # average
+    data.expect = data.expect / sso.ntraj
+
+    # standard error
+    if nt > 1:
+        data.se = (data.ss - nt * (data.expect ** 2)) / (nt * (nt - 1))
+    else:
+        data.se = None
+
+    return data
+
+def _smepdpsolve_single_trajectory(data, L, dt, times, N_store, N_substeps, rho_t, dims, c_ops, e_ops):
+    """
+    Internal function. See smepdpsolve.
+    """
+    states_list = []
+
+    rho_t = np.copy(rho_t)
+    sigma_t = np.copy(rho_t)
+
+    prng = RandomState()  # todo: seed it
+    r_jump, r_op = prng.rand(2)
+
+    jump_times = []
+    jump_op_idx = []
+
+    for t_idx, t in enumerate(times):
+
+        if e_ops:
+            for e_idx, e in enumerate(e_ops):
+                data.expect[e_idx, t_idx] +=\
+                    _data.expect_super(e, rho_t)
+        else:
+            states_list.append(Qobj(unstack_columns(rho_t), dims=dims))
+
+        for j in range(N_substeps):
+
+            if sigma_t.norm() < r_jump:
+                # jump occurs
+                p = np.array([expect(c.dag() * c, rho_t) for c in c_ops])
+                p = np.cumsum(p / np.sum(p))
+                n = np.where(p >= r_op)[0][0]
+
+                # apply jump
+                rho_t = c_ops[n] * rho_t * c_ops[n].dag()
+                rho_t /= expect(c_ops[n].dag() * c_ops[n], rho_t)
+                sigma_t = np.copy(rho_t)
+
+                # store info about jump
+                jump_times.append(times[t_idx] + dt * j)
+                jump_op_idx.append(n)
+
+                # get new random numbers for next jump
+                r_jump, r_op = prng.rand(2)
+
+            # deterministic evolution wihtout correction for norm decay
+            dsigma_t = _data.matmul(L.data, sigma_t) * dt
+
+            # deterministic evolution with correction for norm decay
+            drho_t = _data.matmul(L.data, rho_t) * dt
+
+            # increment density matrices
+            sigma_t = _data.add(sigma_t, dsigma_t)
+            rho_t = _data.add(rho_t, drho_t)
+
+    return states_list, jump_times, jump_op_idx
diff --git a/qutip/solve/piqs.py b/qutip/solve/piqs.py
index b475d7d9d6..2784e986cb 100644
--- a/qutip/solve/piqs.py
+++ b/qutip/solve/piqs.py
@@ -1,1926 +1,1926 @@
-"""Permutational Invariant Quantum Solver (PIQS)
-
-This module calculates the Liouvillian for the dynamics of ensembles of
-identical two-level systems (TLS) in the presence of local and collective
-processes by exploiting permutational symmetry and using the Dicke basis.
-It also allows to characterize nonlinear functions of the density matrix.
-"""
-
-# Authors: Nathan Shammah, Shahnawaz Ahmed
-# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
-
-from math import factorial
-from decimal import Decimal
-
-import numpy as np
-from scipy.integrate import odeint
-from scipy.linalg import eigvalsh
-from scipy.special import entr
-from scipy.sparse import dok_matrix, block_diag, lil_matrix
-from .. import (
-    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
-    sigmap, sigmam,
-)
-from ..entropy import entropy_vn
-from .solver import SolverOptions, Result
-from ._piqs import Dicke as _Dicke
-from ._piqs import (
-    jmm1_dictionary,
-    _num_dicke_states,
-    _num_dicke_ladders,
-    get_blocks,
-    j_min,
-    j_vals,
-)
-
-__all__ = [
-    "num_dicke_states",
-    "num_dicke_ladders",
-    "num_tls",
-    "isdiagonal",
-    "dicke_blocks",
-    "dicke_blocks_full",
-    "dicke_function_trace",
-    "purity_dicke",
-    "entropy_vn_dicke",
-    "Dicke",
-    "state_degeneracy",
-    "m_degeneracy",
-    "energy_degeneracy",
-    "ap",
-    "am",
-    "spin_algebra",
-    "jspin",
-    "collapse_uncoupled",
-    "dicke_basis",
-    "dicke",
-    "excited",
-    "superradiant",
-    "css",
-    "ghz",
-    "ground",
-    "identity_uncoupled",
-    "block_matrix",
-    "tau_column",
-    "Pim",
-]
-
-
-def _ensure_int(x):
-    """
-    Ensure that a floating-point value `x` is exactly an integer, and return it
-    as an int.
-    """
-    out = int(x)
-    if out != x:
-        raise ValueError(f"{x} is not an integral value")
-    return out
-
-
-# Functions necessary to generate the Lindbladian/Liouvillian
-def num_dicke_states(N):
-    """Calculate the number of Dicke states.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    nds: int
-        The number of Dicke states.
-    """
-    return _num_dicke_states(N)
-
-
-def num_dicke_ladders(N):
-    """Calculate the total number of ladders in the Dicke space.
-
-    For a collection of N two-level systems it counts how many different
-    "j" exist or the number of blocks in the block-diagonal matrix.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    Nj: int
-        The number of Dicke ladders.
-    """
-    return _num_dicke_ladders(N)
-
-
-def num_tls(nds):
-    """Calculate the number of two-level systems.
-
-    Parameters
-    ----------
-    nds: int
-         The number of Dicke states.
-
-    Returns
-    -------
-    N: int
-        The number of two-level systems.
-    """
-    if np.sqrt(nds).is_integer():
-        # N is even
-        N = 2 * (np.sqrt(nds) - 1)
-    else:
-        # N is odd
-        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
-    return int(N)
-
-
-def isdiagonal(mat):
-    """
-    Check if the input matrix is diagonal.
-
-    Parameters
-    ==========
-    mat: ndarray/Qobj
-        A 2D numpy array
-
-    Returns
-    =======
-    diag: bool
-        True/False depending on whether the input matrix is diagonal.
-    """
-    if isinstance(mat, Qobj):
-        mat = mat.full()
-
-    return np.all(mat == np.diag(np.diagonal(mat)))
-
-
-# nonlinear functions of the density matrix
-def dicke_blocks(rho):
-    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems.
-
-    Returns
-    -------
-    square_blocks: list of np.array
-        Give back the blocks list.
-
-    """
-    shape_dimension = rho.shape[0]
-    N = num_tls(shape_dimension)
-    ladders = num_dicke_ladders(N)
-    # create a list with the sizes of the blocks, in order
-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-    blocks_list = [
-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-        for i in range(blocks_dimensions)
-    ]
-    blocks_list = np.flip(blocks_list, 0)
-    # create a list with each block matrix as element
-    square_blocks = []
-    block_position = 0
-    for block_size in blocks_list:
-        start_m = block_position
-        end_m = block_position + block_size
-        square_block = rho[start_m:end_m, start_m:end_m]
-        block_position = block_position + block_size
-        square_blocks.append(square_block)
-
-    return square_blocks
-
-
-def dicke_blocks_full(rho):
-    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems.
-
-    Returns
-    -------
-    full_blocks : list
-        The list of blocks expanded in the 2^N space for N qubits.
-
-    """
-    shape_dimension = rho.shape[0]
-    N = num_tls(shape_dimension)
-    ladders = num_dicke_ladders(N)
-    # create a list with the sizes of the blocks, in order
-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-    blocks_list = [
-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-        for i in range(blocks_dimensions)
-    ]
-    blocks_list = np.flip(blocks_list, 0)
-    # create a list with each block matrix as element
-    full_blocks = []
-    k = 0
-    block_position = 0
-    for block_size in blocks_list:
-        start_m = block_position
-        end_m = block_position + block_size
-        square_block = rho[start_m:end_m, start_m:end_m]
-        block_position = block_position + block_size
-        j = N / 2 - k
-        djn = state_degeneracy(N, j)
-        for block_counter in range(0, djn):
-            full_blocks.append(square_block / djn)  # preserve trace
-        k = k + 1
-    return full_blocks
-
-
-def dicke_function_trace(f, rho):
-    """Calculate the trace of a function on a Dicke density matrix.
-    Parameters
-    ----------
-    f : function
-        A Taylor-expandable function of `rho`.
-
-    rho : :class:`qutip.Qobj`
-        A density matrix in the Dicke basis.
-
-    Returns
-    -------
-    res : float
-        Trace of a nonlinear function on `rho`.
-    """
-    N = num_tls(rho.shape[0])
-    blocks = dicke_blocks(rho)
-    block_f = []
-    degen_blocks = np.flip(j_vals(N))
-    state_degeneracies = []
-    for j in degen_blocks:
-        dj = state_degeneracy(N, j)
-        state_degeneracies.append(dj)
-    eigenvals_degeneracy = []
-    deg = []
-    for i, block in enumerate(blocks):
-        dj = state_degeneracies[i]
-        normalized_block = block / dj
-        eigenvals_block = eigvalsh(normalized_block)
-        for val in eigenvals_block:
-            eigenvals_degeneracy.append(val)
-            deg.append(dj)
-
-    eigenvalue = np.array(eigenvals_degeneracy)
-    function_array = f(eigenvalue) * deg
-    return sum(function_array)
-
-
-def entropy_vn_dicke(rho):
-    """Von Neumann Entropy of a Dicke-basis density matrix.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        A 2D block-diagonal matrix of ones with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems.
-
-    Returns
-    -------
-    entropy_dm: float
-        Entropy. Use degeneracy to multiply each block.
-
-    """
-    return dicke_function_trace(entr, rho)
-
-
-def purity_dicke(rho):
-    """Calculate purity of a density matrix in the Dicke basis.
-    It accounts for the degenerate blocks in the density matrix.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
-
-    Returns
-    -------
-    purity : float
-        The purity of the quantum state.
-        It's 1 for pure states, 0<=purity<1 for mixed states.
-    """
-    f = lambda x: x * x
-    return dicke_function_trace(f, rho)
-
-
-class Dicke(object):
-    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
-
-    Examples
-    --------
-    >>> from piqs import Dicke, jspin
-    >>> N = 2
-    >>> jx, jy, jz = jspin(N)
-    >>> jp = jspin(N, "+")
-    >>> jm = jspin(N, "-")
-    >>> ensemble = Dicke(N, emission=1.)
-    >>> L = ensemble.liouvillian()
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    hamiltonian : :class:`qutip.Qobj`
-        A Hamiltonian in the Dicke basis.
-
-        The matrix dimensions are (nds, nds),
-        with nds being the number of Dicke states.
-        The Hamiltonian can be built with the operators
-        given by the `jspin` functions.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Attributes
-    ----------
-    N: int
-        The number of two-level systems.
-
-    hamiltonian : :class:`qutip.Qobj`
-        A Hamiltonian in the Dicke basis.
-
-        The matrix dimensions are (nds, nds),
-        with nds being the number of Dicke states.
-        The Hamiltonian can be built with the operators given
-        by the `jspin` function in the "dicke" basis.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    nds: int
-        The number of Dicke states.
-
-    dshape: tuple
-        The shape of the Hilbert space in the Dicke or uncoupled basis.
-        default: (nds, nds).
-    """
-
-    def __init__(
-        self,
-        N,
-        hamiltonian=None,
-        emission=0.0,
-        dephasing=0.0,
-        pumping=0.0,
-        collective_emission=0.0,
-        collective_dephasing=0.0,
-        collective_pumping=0.0,
-    ):
-        self.N = N
-        self.hamiltonian = hamiltonian
-        self.emission = emission
-        self.dephasing = dephasing
-        self.pumping = pumping
-        self.collective_emission = collective_emission
-        self.collective_dephasing = collective_dephasing
-        self.collective_pumping = collective_pumping
-        self.nds = num_dicke_states(self.N)
-        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
-
-    def __repr__(self):
-        """Print the current parameters of the system."""
-        string = []
-        string.append("N = {}".format(self.N))
-        string.append("Hilbert space dim = {}".format(self.dshape))
-        string.append("Number of Dicke states = {}".format(self.nds))
-        string.append(
-            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
-        )
-        if self.emission != 0:
-            string.append("emission = {}".format(self.emission))
-        if self.dephasing != 0:
-            string.append("dephasing = {}".format(self.dephasing))
-        if self.pumping != 0:
-            string.append("pumping = {}".format(self.pumping))
-        if self.collective_emission != 0:
-            string.append(
-                "collective_emission = {}".format(self.collective_emission)
-            )
-        if self.collective_dephasing != 0:
-            string.append(
-                "collective_dephasing = {}".format(self.collective_dephasing)
-            )
-        if self.collective_pumping != 0:
-            string.append(
-                "collective_pumping = {}".format(self.collective_pumping)
-            )
-        return "\n".join(string)
-
-    def lindbladian(self):
-        """Build the Lindbladian superoperator of the dissipative dynamics.
-
-        Returns
-        -------
-        lindbladian : :class:`qutip.Qobj`
-            The Lindbladian matrix as a `qutip.Qobj`.
-        """
-        cythonized_dicke = _Dicke(
-            int(self.N),
-            float(self.emission),
-            float(self.dephasing),
-            float(self.pumping),
-            float(self.collective_emission),
-            float(self.collective_dephasing),
-            float(self.collective_pumping),
-        )
-        return cythonized_dicke.lindbladian()
-
-    def liouvillian(self):
-        """Build the total Liouvillian using the Dicke basis.
-
-        Returns
-        -------
-        liouv : :class:`qutip.Qobj`
-            The Liouvillian matrix for the system.
-        """
-        lindblad = self.lindbladian()
-        if self.hamiltonian is None:
-            liouv = lindblad
-
-        else:
-            hamiltonian = self.hamiltonian
-            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
-                hamiltonian
-            )
-            liouv = lindblad + hamiltonian_superoperator
-        return liouv
-
-    def pisolve(self, initial_state, tlist, options=None):
-        """
-        Solve for diagonal Hamiltonians and initial states faster.
-
-        Parameters
-        ==========
-        initial_state : :class:`qutip.Qobj`
-            An initial state specified as a density matrix of
-            `qutip.Qbj` type.
-
-        tlist: ndarray
-            A 1D numpy array of list of timesteps to integrate
-
-        options : :class:`qutip.solver.SolverOptions`
-            The options for the solver.
-
-        Returns
-        =======
-        result: list
-            A dictionary of the type `qutip.solver.Result` which holds the
-            results of the evolution.
-        """
-        if isdiagonal(initial_state) == False:
-            msg = "`pisolve` requires a diagonal initial density matrix. "
-            msg += "In general construct the Liouvillian using "
-            msg += "`piqs.liouvillian` and use qutip.mesolve."
-            raise ValueError(msg)
-
-        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
-            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
-            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
-            msg += "  use `qutip.mesolve`."
-            raise ValueError(msg)
-
-        if initial_state.full().shape != self.dshape:
-            msg = "Initial density matrix should be diagonal."
-            raise ValueError(msg)
-
-        pim = Pim(
-            self.N,
-            self.emission,
-            self.dephasing,
-            self.pumping,
-            self.collective_emission,
-            self.collective_pumping,
-            self.collective_dephasing,
-        )
-        result = pim.solve(initial_state, tlist, options=None)
-        return result
-
-    def c_ops(self):
-        """Build collapse operators in the full Hilbert space 2^N.
-
-        Returns
-        -------
-        c_ops_list: list
-            The list with the collapse operators in the 2^N Hilbert space.
-        """
-        ce = self.collective_emission
-        cd = self.collective_dephasing
-        cp = self.collective_pumping
-        c_ops_list = collapse_uncoupled(
-            N=self.N,
-            emission=self.emission,
-            dephasing=self.dephasing,
-            pumping=self.pumping,
-            collective_emission=ce,
-            collective_dephasing=cd,
-            collective_pumping=cp,
-        )
-        return c_ops_list
-
-    def coefficient_matrix(self):
-        """Build coefficient matrix for ODE for a diagonal problem.
-
-        Returns
-        -------
-        M: ndarray
-            The matrix M of the coefficients for the ODE dp/dt = Mp.
-            p is the vector of the diagonal matrix elements
-            of the density matrix rho in the Dicke basis.
-        """
-        diagonal_system = Pim(
-            N=self.N,
-            emission=self.emission,
-            dephasing=self.dephasing,
-            pumping=self.pumping,
-            collective_emission=self.collective_emission,
-            collective_dephasing=self.collective_dephasing,
-            collective_pumping=self.collective_pumping,
-        )
-        coef_matrix = diagonal_system.coefficient_matrix()
-        return coef_matrix
-
-
-# Utility functions for properties of the Dicke space
-def energy_degeneracy(N, m):
-    """Calculate the number of Dicke states with same energy.
-
-    The use of the `Decimals` class allows to explore N > 1000,
-    unlike the built-in function `scipy.special.binom`
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    m: float
-        Total spin z-axis projection eigenvalue.
-        This is proportional to the total energy.
-
-    Returns
-    -------
-    degeneracy: int
-        The energy degeneracy
-    """
-    numerator = Decimal(factorial(N))
-    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
-    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
-    degeneracy = numerator / (d1 * d2)
-    return int(degeneracy)
-
-
-def state_degeneracy(N, j):
-    r"""Calculate the degeneracy of the Dicke state.
-
-    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
-    representations :math:`\lvert j, m, \alpha\rangle`.
-
-    Uses Decimals to calculate higher numerator and denominators numbers.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    j: float
-        Total spin eigenvalue (cooperativity).
-
-    Returns
-    -------
-    degeneracy: int
-        The state degeneracy.
-    """
-    if j < 0:
-        raise ValueError("j value should be >= 0")
-    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
-    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
-    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
-    degeneracy = numerator / (denominator_1 * denominator_2)
-    degeneracy = int(np.round(float(degeneracy)))
-    return degeneracy
-
-
-def m_degeneracy(N, m):
-    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
-    same energy.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    m: float
-        Total spin z-axis projection eigenvalue (proportional to the total
-        energy).
-
-    Returns
-    -------
-    degeneracy: int
-        The m-degeneracy.
-    """
-    jvals = j_vals(N)
-    maxj = np.max(jvals)
-    if m < -maxj:
-        e = "m value is incorrect for this N."
-        e += " Minimum m value can be {}".format(-maxj)
-        raise ValueError(e)
-    degeneracy = N / 2 + 1 - abs(m)
-    return int(degeneracy)
-
-
-def ap(j, m):
-    r"""
-    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
-
-    The action of ap is given by:
-    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
-
-    Parameters
-    ----------
-    j, m: float
-        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
-
-    Returns
-    -------
-    a_plus: float
-        The value of :math:`a_{+}`.
-    """
-    a_plus = np.sqrt((j - m) * (j + m + 1))
-    return a_plus
-
-
-def am(j, m):
-    r"""Calculate the operator ``am`` used later.
-
-    The action of ``ap`` is given by:
-    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
-
-    Parameters
-    ----------
-    j: float
-        The value for j.
-
-    m: float
-        The value for m.
-
-    Returns
-    -------
-    a_minus: float
-        The value of :math:`a_{-}`.
-    """
-    a_minus = np.sqrt((j + m) * (j - m + 1))
-    return a_minus
-
-
-def spin_algebra(N, op=None):
-    """Create the list [sx, sy, sz] with the spin operators.
-
-    The operators are constructed for a collection of N two-level systems
-    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
-    objects (spin matrices), as it cointains the list of the SU(2) Pauli
-    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
-    is placed in a :math:`2^N`-dimensional Hilbert space.
-
-    Notes
-    -----
-    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    spin_operators: list or :class: qutip.Qobj
-        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
-        requested operator.
-    """
-    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
-    N = int(N)
-    sx = [0 for i in range(N)]
-    sy = [0 for i in range(N)]
-    sz = [0 for i in range(N)]
-    sp = [0 for i in range(N)]
-    sm = [0 for i in range(N)]
-
-    sx[0] = 0.5 * sigmax()
-    sy[0] = 0.5 * sigmay()
-    sz[0] = 0.5 * sigmaz()
-    sp[0] = sigmap()
-    sm[0] = sigmam()
-
-    # 2. Place operators in total Hilbert space
-    for k in range(N - 1):
-        sx[0] = tensor(sx[0], identity(2))
-        sy[0] = tensor(sy[0], identity(2))
-        sz[0] = tensor(sz[0], identity(2))
-        sp[0] = tensor(sp[0], identity(2))
-        sm[0] = tensor(sm[0], identity(2))
-
-    # 3. Cyclic sequence to create all N operators
-    a = [i for i in range(N)]
-    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
-
-    # 4. Create N operators
-    for i in range(1, N):
-        sx[i] = sx[0].permute(b[i])
-        sy[i] = sy[0].permute(b[i])
-        sz[i] = sz[0].permute(b[i])
-        sp[i] = sp[0].permute(b[i])
-        sm[i] = sm[0].permute(b[i])
-
-    spin_operators = [sx, sy, sz]
-
-    if not op:
-        return spin_operators
-    elif op == "x":
-        return sx
-    elif op == "y":
-        return sy
-    elif op == "z":
-        return sz
-    elif op == "+":
-        return sp
-    elif op == "-":
-        return sm
-    else:
-        raise TypeError("Invalid type")
-
-
-def _jspin_uncoupled(N, op=None):
-    """Construct the the collective spin algebra in the uncoupled basis.
-
-    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
-    two-level system (TLS). Each collective operator is placed in a
-    Hilbert space of dimension 2^N.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    op: str
-        The operator to return 'x','y','z','+','-'.
-        If no operator given, then output is the list of operators
-        for ['x','y','z',].
-
-    Returns
-    -------
-    collective_operators: list or :class: qutip.Qobj
-        A list of `qutip.Qobj` representing all the operators in
-        uncoupled" basis or a single operator requested.
-    """
-    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
-    N = int(N)
-
-    sx, sy, sz = spin_algebra(N)
-    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
-
-    jx = sum(sx)
-    jy = sum(sy)
-    jz = sum(sz)
-    jp = sum(sp)
-    jm = sum(sm)
-
-    collective_operators = [jx, jy, jz]
-
-    if not op:
-        return collective_operators
-    elif op == "x":
-        return jx
-    elif op == "y":
-        return jy
-    elif op == "z":
-        return jz
-    elif op == "+":
-        return jp
-    elif op == "-":
-        return jm
-    else:
-        raise TypeError("Invalid type")
-
-
-def jspin(N, op=None, basis="dicke"):
-    r"""
-    Calculate the list of collective operators of the total algebra.
-
-    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
-    default. Otherwise with "uncoupled" the operators are in a
-    :math:`2^N` space.
-
-    Parameters
-    ----------
-    N: int
-        Number of two-level systems.
-
-    op: str
-        The operator to return 'x','y','z','+','-'.
-        If no operator given, then output is the list of operators
-        for ['x','y','z'].
-
-    basis: str
-        The basis of the operators - "dicke" or "uncoupled"
-        default: "dicke".
-
-    Returns
-    -------
-    j_alg: list or :class: qutip.Qobj
-        A list of `qutip.Qobj` representing all the operators in
-        the "dicke" or "uncoupled" basis or a single operator requested.
-    """
-    if basis == "uncoupled":
-        return _jspin_uncoupled(N, op)
-
-    nds = num_dicke_states(N)
-    num_ladders = num_dicke_ladders(N)
-    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
-    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
-    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
-    s = 0
-
-    for k in range(0, num_ladders):
-        j = 0.5 * N - k
-        mmax = int(2 * j + 1)
-        for i in range(0, mmax):
-            m = j - i
-            jz_operator[s, s] = m
-            if (s + 1) in range(0, nds):
-                jp_operator[s, s + 1] = ap(j, m - 1)
-            if (s - 1) in range(0, nds):
-                jm_operator[s, s - 1] = am(j, m + 1)
-            s = s + 1
-
-    jx_operator = 1 / 2 * (jp_operator + jm_operator)
-    jy_operator = 1j / 2 * (jm_operator - jp_operator)
-    jx = Qobj(jx_operator)
-    jy = Qobj(jy_operator)
-    jz = Qobj(jz_operator)
-    jp = Qobj(jp_operator)
-    jm = Qobj(jm_operator)
-
-    if not op:
-        return [jx, jy, jz]
-    if op == "+":
-        return jp
-    elif op == "-":
-        return jm
-    elif op == "x":
-        return jx
-    elif op == "y":
-        return jy
-    elif op == "z":
-        return jz
-    else:
-        raise TypeError("Invalid type")
-
-
-def collapse_uncoupled(
-    N,
-    emission=0.0,
-    dephasing=0.0,
-    pumping=0.0,
-    collective_emission=0.0,
-    collective_dephasing=0.0,
-    collective_pumping=0.0,
-):
-    """
-    Create the collapse operators (c_ops) of the Lindbladian in the
-    uncoupled basis
-
-    These operators are in the uncoupled basis of the two-level
-    system (TLS) SU(2) Pauli matrices.
-
-    Notes
-    -----
-    The collapse operator list can be given to `qutip.mesolve`.
-    Notice that the operators are placed in a Hilbert space of
-    dimension :math:`2^N`. Thus the method is suitable only for
-    small N (of the order of 10).
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Returns
-    -------
-    c_ops: list
-        The list of collapse operators as `qutip.Qobj` for the system.
-    """
-    N = int(N)
-
-    if N > 10:
-        msg = "N > 10. dim(H) = 2^N. "
-        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
-        msg += "dimension and exploit permutational symmetry."
-        raise Warning(msg)
-
-    [sx, sy, sz] = spin_algebra(N)
-    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
-    [jx, jy, jz] = jspin(N, basis="uncoupled")
-    jp, jm = (
-        jspin(N, "+", basis="uncoupled"),
-        jspin(N, "-", basis="uncoupled"),
-    )
-
-    c_ops = []
-
-    if emission != 0:
-        for i in range(0, N):
-            c_ops.append(np.sqrt(emission) * sm[i])
-
-    if dephasing != 0:
-        for i in range(0, N):
-            c_ops.append(np.sqrt(dephasing) * sz[i])
-
-    if pumping != 0:
-        for i in range(0, N):
-            c_ops.append(np.sqrt(pumping) * sp[i])
-
-    if collective_emission != 0:
-        c_ops.append(np.sqrt(collective_emission) * jm)
-
-    if collective_dephasing != 0:
-        c_ops.append(np.sqrt(collective_dephasing) * jz)
-
-    if collective_pumping != 0:
-        c_ops.append(np.sqrt(collective_pumping) * jp)
-
-    return c_ops
-
-
-# State definitions in the Dicke basis with an option for basis transformation
-def dicke_basis(N, jmm1=None):
-    r"""
-    Initialize the density matrix of a Dicke state for several (j, m, m1).
-
-    This function can be used to build arbitrary states in the Dicke basis
-    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
-    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
-    index of the density matrix to the :math:`\lvert j, m\rangle` values is
-    given by the cythonized function `jmm1_dictionary`. A density matrix is
-    created from the given dictionary of coefficients for each (j, m, m1).
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    jmm1: dict
-        A dictionary of {(j, m, m1): p} that gives a density p for the
-        (j, m, m1) matrix element.
-
-    Returns
-    -------
-    rho: :class: qutip.Qobj
-        The density matrix in the Dicke basis.
-    """
-    if jmm1 is None:
-        msg = "Please specify the jmm1 values as a dictionary"
-        msg += "or use the `excited(N)` function to create an"
-        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
-        raise AttributeError(msg)
-
-    nds = _num_dicke_states(N)
-    rho = np.zeros((nds, nds))
-    jmm1_dict = jmm1_dictionary(N)[1]
-    for key in jmm1:
-        i, k = jmm1_dict[key]
-        rho[i, k] = jmm1[key]
-    return Qobj(rho)
-
-
-def dicke(N, j, m):
-    r"""
-    Generate a Dicke state as a pure density matrix in the Dicke basis.
-
-    For instance, the superradiant state given by
-    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
-    and the state is represented as a density matrix of size (nds, nds) or
-    (4, 4), with the (1, 1) element set to 1.
-
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    j: float
-        The eigenvalue j of the Dicke state (j, m).
-
-    m: float
-        The eigenvalue m of the Dicke state (j, m).
-
-    Returns
-    -------
-    rho: :class: qutip.Qobj
-        The density matrix.
-    """
-    nds = num_dicke_states(N)
-    rho = np.zeros((nds, nds))
-
-    jmm1_dict = jmm1_dictionary(N)[1]
-
-    i, k = jmm1_dict[(j, m, m)]
-    rho[i, k] = 1.0
-    return Qobj(rho)
-
-
-# Uncoupled states in the full Hilbert space. These are returned with the
-# choice of the keyword argument `basis="uncoupled"` in the state functions.
-def _uncoupled_excited(N):
-    """
-    Generate the density matrix of the excited Dicke state in the full
-    :math:`2^N` dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    psi0: :class: qutip.Qobj
-        The density matrix for the excited state in the uncoupled basis.
-    """
-    N = int(N)
-    jz = jspin(N, "z", basis="uncoupled")
-    en, vn = jz.eigenstates()
-    psi0 = vn[2 ** N - 1]
-    return ket2dm(psi0)
-
-
-def _uncoupled_superradiant(N):
-    """
-    Generate the density matrix of a superradiant state in the full
-    :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    psi0: :class: qutip.Qobj
-        The density matrix for the superradiant state in the full Hilbert
-        space.
-    """
-    N = int(N)
-    jz = jspin(N, "z", basis="uncoupled")
-    en, vn = jz.eigenstates()
-    psi0 = vn[2 ** N - (N + 1)]
-    return ket2dm(psi0)
-
-
-def _uncoupled_ground(N):
-    """
-    Generate the density matrix of the ground state in the full\
-    :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    psi0: :class: qutip.Qobj
-        The density matrix for the ground state in the full Hilbert space.
-    """
-    N = int(N)
-    jz = jspin(N, "z", basis="uncoupled")
-    en, vn = jz.eigenstates()
-    psi0 = vn[0]
-    return ket2dm(psi0)
-
-
-def _uncoupled_ghz(N):
-    """
-    Generate the density matrix of the GHZ state in the full 2^N
-    dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    ghz: :class: qutip.Qobj
-        The density matrix for the GHZ state in the full Hilbert space.
-    """
-    N = int(N)
-    rho = np.zeros((2 ** N, 2 ** N))
-    rho[0, 0] = 1 / 2
-    rho[2 ** N - 1, 0] = 1 / 2
-    rho[0, 2 ** N - 1] = 1 / 2
-    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
-    spin_dim = [2 for i in range(0, N)]
-    spins_dims = list((spin_dim, spin_dim))
-    rho = Qobj(rho, dims=spins_dims)
-    return rho
-
-
-def _uncoupled_css(N, a, b):
-    r"""
-    Generate the density matrix of the CSS state in the full 2^N
-    dimensional Hilbert space.
-
-    The CSS states are non-entangled states given by
-    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    a: complex
-        The coefficient of the :math:`\lvert1_i\rangle` state.
-
-    b: complex
-        The coefficient of the :math:`\lvert0_i\rangle` state.
-
-    Returns
-    -------
-    css: :class: qutip.Qobj
-        The density matrix for the CSS state in the full Hilbert space.
-    """
-    N = int(N)
-    # 1. Define i_th factorized density matrix in the uncoupled basis
-    rho_i = np.zeros((2, 2), dtype=complex)
-    rho_i[0, 0] = a * np.conj(a)
-    rho_i[1, 1] = b * np.conj(b)
-    rho_i[0, 1] = a * np.conj(b)
-    rho_i[1, 0] = b * np.conj(a)
-    rho_i = Qobj(rho_i)
-    rho = [0 for i in range(N)]
-    rho[0] = rho_i
-    # 2. Place single-two-level-system density matrices in total Hilbert space
-    for k in range(N - 1):
-        rho[0] = tensor(rho[0], identity(2))
-    # 3. Cyclic sequence to create all N factorized density matrices
-    # |CSS>_i<CSS|_i
-    a = [i for i in range(N)]
-    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
-    # 4. Create all other N-1 factorized density matrices
-    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
-    for i in range(1, N):
-        rho[i] = rho[0].permute(b[i])
-    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
-    rho_tot = identity_i
-    for i in range(0, N):
-        rho_tot = rho_tot * rho[i]
-    return rho_tot
-
-
-def excited(N, basis="dicke"):
-    """
-    Generate the density matrix for the excited state.
-
-    This state is given by (N/2, N/2) in the default Dicke basis. If the
-    argument `basis` is "uncoupled" then it generates the state in a
-    2**N dim Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The excited state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        state = _uncoupled_excited(N)
-        return state
-
-    jmm1 = {(N / 2, N / 2, N / 2): 1}
-    return dicke_basis(N, jmm1)
-
-
-def superradiant(N, basis="dicke"):
-    """
-    Generate the density matrix of the superradiant state.
-
-    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
-    If the argument `basis` is "uncoupled" then it generates the state
-    in a 2**N dim Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The superradiant state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        state = _uncoupled_superradiant(N)
-        return state
-
-    if N % 2 == 0:
-        jmm1 = {(N / 2, 0, 0): 1.0}
-        return dicke_basis(N, jmm1)
-    else:
-        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
-    return dicke_basis(N, jmm1)
-
-
-def css(
-    N,
-    x=1 / np.sqrt(2),
-    y=1 / np.sqrt(2),
-    basis="dicke",
-    coordinates="cartesian",
-):
-    r"""
-    Generate the density matrix of the Coherent Spin State (CSS).
-
-    It can be defined as,
-    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
-    with :math:`a = sin(\frac{\theta}{2})`,
-    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
-    The default basis is that of Dicke space
-    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
-    The default state is the symmetric CSS,
-    :math:`\lvert CSS\rangle = \lvert+\rangle`.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    x, y: float
-        The coefficients of the CSS state.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    coordinates: str
-        Either "cartesian" or "polar". If polar then the coefficients
-        are constructed as sin(x/2), cos(x/2)e^(iy).
-
-    Returns
-    -------
-    rho: :class: qutip.Qobj
-        The CSS state density matrix.
-    """
-    if coordinates == "polar":
-        a = np.cos(0.5 * x) * np.exp(1j * y)
-        b = np.sin(0.5 * x)
-    else:
-        a = x
-        b = y
-    if basis == "uncoupled":
-        return _uncoupled_css(N, a, b)
-    nds = num_dicke_states(N)
-    num_ladders = num_dicke_ladders(N)
-    rho = dok_matrix((nds, nds), dtype=np.complex128)
-
-    # loop in the allowed matrix elements
-    jmm1_dict = jmm1_dictionary(N)[1]
-
-    j = 0.5 * N
-    mmax = int(2 * j + 1)
-    for i in range(0, mmax):
-        m = j - i
-        psi_m = (
-            np.sqrt(float(energy_degeneracy(N, m)))
-            * a ** (N * 0.5 + m)
-            * b ** (N * 0.5 - m)
-        )
-        for i1 in range(0, mmax):
-            m1 = j - i1
-            row_column = jmm1_dict[(j, m, m1)]
-            psi_m1 = (
-                np.sqrt(float(energy_degeneracy(N, m1)))
-                * np.conj(a) ** (N * 0.5 + m1)
-                * np.conj(b) ** (N * 0.5 - m1)
-            )
-            rho[row_column] = psi_m * psi_m1
-    return Qobj(rho)
-
-
-def ghz(N, basis="dicke"):
-    """
-    Generate the density matrix of the GHZ state.
-
-    If the argument `basis` is "uncoupled" then it generates the state
-    in a :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled".
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The GHZ state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        return _uncoupled_ghz(N)
-    nds = _num_dicke_states(N)
-    rho = dok_matrix((nds, nds), dtype=np.complex128)
-    rho[0, 0] = 1 / 2
-    rho[N, N] = 1 / 2
-    rho[N, 0] = 1 / 2
-    rho[0, N] = 1 / 2
-    return Qobj(rho)
-
-
-def ground(N, basis="dicke"):
-    """
-    Generate the density matrix of the ground state.
-
-    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
-    `basis` is "uncoupled" then it generates the state in a
-    :math:`2^N`-dimensional Hilbert space.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    basis: str
-        The basis to use. Either "dicke" or "uncoupled"
-
-    Returns
-    -------
-    state: :class: qutip.Qobj
-        The ground state density matrix in the requested basis.
-    """
-    if basis == "uncoupled":
-        state = _uncoupled_ground(N)
-        return state
-    nds = _num_dicke_states(N)
-    rho = dok_matrix((nds, nds), dtype=np.complex128)
-    rho[N, N] = 1
-    return Qobj(rho)
-
-
-def identity_uncoupled(N):
-    """
-    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
-
-    The identity matrix is formed from the tensor product of N TLSs.
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    Returns
-    -------
-    identity: :class: qutip.Qobj
-        The identity matrix.
-    """
-    N = int(N)
-    rho = np.zeros((2 ** N, 2 ** N))
-    for i in range(0, 2 ** N):
-        rho[i, i] = 1
-    spin_dim = [2 for i in range(0, N)]
-    spins_dims = list((spin_dim, spin_dim))
-    identity = Qobj(rho, dims=spins_dims)
-    return identity
-
-
-def block_matrix(N, elements="ones"):
-    """Construct the block-diagonal matrix for the Dicke basis.
-
-    Parameters
-    ----------
-    N : int
-        Number of two-level systems.
-    elements : str {'ones' (default),'degeneracy'}
-
-    Returns
-    -------
-    block_matr : ndarray
-        A 2D block-diagonal matrix with dimension (nds,nds),
-        where nds is the number of Dicke states for N two-level
-        systems. Filled with ones or the value of degeneracy
-        at each matrix element.
-    """
-    # create a list with the sizes of the blocks, in order
-    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
-    blocks_list = [
-        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
-        for i in range(blocks_dimensions)
-    ]
-    blocks_list = np.flip(blocks_list, 0)
-    # create a list with each block matrix as element
-    square_blocks = []
-    k = 0
-    for i in blocks_list:
-        if elements == "ones":
-            square_blocks.append(np.ones((i, i)))
-        elif elements == "degeneracy":
-            j = N / 2 - k
-            dj = state_degeneracy(N, j)
-            square_blocks.append(dj * np.ones((i, i)))
-        k = k + 1
-    return block_diag(square_blocks)
-
-
-# ============================================================================
-# Adding a faster version to make a Permutational Invariant matrix
-# ============================================================================
-def tau_column(tau, k, j):
-    """
-    Determine the column index for the non-zero elements of the matrix for a
-    particular row `k` and the value of `j` from the Dicke space.
-
-    Parameters
-    ----------
-    tau: str
-        The tau function to check for this `k` and `j`.
-
-    k: int
-        The row of the matrix M for which the non zero elements have
-        to be calculated.
-
-    j: float
-        The value of `j` for this row.
-    """
-    # In the notes, we indexed from k = 1, here we do it from k = 0
-    k = k + 1
-    mapping = {
-        "tau3": k - (2 * j + 3),
-        "tau2": k - 1,
-        "tau4": k + (2 * j - 1),
-        "tau5": k - (2 * j + 2),
-        "tau1": k,
-        "tau6": k + (2 * j),
-        "tau7": k - (2 * j + 1),
-        "tau8": k + 1,
-        "tau9": k + (2 * j + 1),
-    }
-    # we need to decrement k again as indexing is from 0
-    return int(mapping[tau] - 1)
-
-
-class Pim(object):
-    """
-    The Permutation Invariant Matrix class.
-
-    Initialize the class with the parameters for generating a Permutation
-    Invariant matrix which evolves a given diagonal initial state `p` as:
-
-                                dp/dt = Mp
-
-    Parameters
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    Attributes
-    ----------
-    N: int
-        The number of two-level systems.
-
-    emission: float
-        Incoherent emission coefficient (also nonradiative emission).
-        default: 0.0
-
-    dephasing: float
-        Local dephasing coefficient.
-        default: 0.0
-
-    pumping: float
-        Incoherent pumping coefficient.
-        default: 0.0
-
-    collective_emission: float
-        Collective (superradiant) emmission coefficient.
-        default: 0.0
-
-    collective_dephasing: float
-        Collective dephasing coefficient.
-        default: 0.0
-
-    collective_pumping: float
-        Collective pumping coefficient.
-        default: 0.0
-
-    M: dict
-        A nested dictionary of the structure {row: {col: val}} which holds
-        non zero elements of the matrix M
-    """
-
-    def __init__(
-        self,
-        N,
-        emission=0.0,
-        dephasing=0,
-        pumping=0,
-        collective_emission=0,
-        collective_pumping=0,
-        collective_dephasing=0,
-    ):
-        self.N = N
-        self.emission = emission
-        self.dephasing = dephasing
-        self.pumping = pumping
-        self.collective_pumping = collective_pumping
-        self.collective_dephasing = collective_dephasing
-        self.collective_emission = collective_emission
-        self.M = {}
-
-    def isdicke(self, dicke_row, dicke_col):
-        """
-        Check if an element in a matrix is a valid element in the Dicke space.
-        Dicke row: j value index. Dicke column: m value index.
-        The function returns True if the element exists in the Dicke space and
-        False otherwise.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col : int
-            Index of the element in Dicke space which needs to be checked
-        """
-        rows = self.N + 1
-        cols = 0
-
-        if (self.N % 2) == 0:
-            cols = int(self.N / 2 + 1)
-        else:
-            cols = int(self.N / 2 + 1 / 2)
-        if (dicke_row > rows) or (dicke_row < 0):
-            return False
-        if (dicke_col > cols) or (dicke_col < 0):
-            return False
-        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
-            return False
-        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
-            return False
-        else:
-            return True
-
-    def tau_valid(self, dicke_row, dicke_col):
-        """
-        Find the Tau functions which are valid for this value of (dicke_row,
-        dicke_col) given the number of TLS. This calculates the valid tau
-        values and reurns a dictionary specifying the tau function name and
-        the value.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col : int
-            Index of the element in Dicke space which needs to be checked.
-
-        Returns
-        -------
-        taus: dict
-            A dictionary of key, val as {tau: value} consisting of the valid
-            taus for this row and column of the Dicke space element.
-        """
-        tau_functions = [
-            self.tau3,
-            self.tau2,
-            self.tau4,
-            self.tau5,
-            self.tau1,
-            self.tau6,
-            self.tau7,
-            self.tau8,
-            self.tau9,
-        ]
-        N = self.N
-        if self.isdicke(dicke_row, dicke_col) is False:
-            return False
-        # The 3x3 sub matrix surrounding the Dicke space element to
-        # run the tau functions
-        indices = [
-            (dicke_row + x, dicke_col + y)
-            for x in range(-1, 2)
-            for y in range(-1, 2)
-        ]
-        taus = {}
-        for idx, tau in zip(indices, tau_functions):
-            if self.isdicke(idx[0], idx[1]):
-                j, m = self.calculate_j_m(idx[0], idx[1])
-                taus[tau.__name__] = tau(j, m)
-        return taus
-
-    def calculate_j_m(self, dicke_row, dicke_col):
-        """
-        Get the value of j and m for the particular Dicke space element.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col: int
-            The row and column from the Dicke space matrix
-
-        Returns
-        -------
-        j, m: float
-            The j and m values.
-        """
-        N = self.N
-        j = N / 2 - dicke_col
-        m = N / 2 - dicke_row
-        return (j, m)
-
-    def calculate_k(self, dicke_row, dicke_col):
-        """
-        Get k value from the current row and column element in the Dicke space.
-
-        Parameters
-        ----------
-        dicke_row, dicke_col: int
-            The row and column from the Dicke space matrix.
-        Returns
-        -------
-        k: int
-            The row index for the matrix M for given Dicke space
-            element.
-        """
-        N = self.N
-        if dicke_row == 0:
-            k = dicke_col
-        else:
-            k = int(
-                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
-                + (dicke_row - (dicke_col))
-            )
-        return k
-
-    def coefficient_matrix(self):
-        """
-        Generate the matrix M governing the dynamics for diagonal cases.
-
-        If the initial density matrix and the Hamiltonian is diagonal, the
-        evolution of the system is given by the simple ODE: dp/dt = Mp.
-        """
-        N = self.N
-        nds = num_dicke_states(N)
-        rows = self.N + 1
-        cols = 0
-
-        sparse_M = lil_matrix((nds, nds), dtype=float)
-        if (self.N % 2) == 0:
-            cols = int(self.N / 2 + 1)
-        else:
-            cols = int(self.N / 2 + 1 / 2)
-        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
-            if self.isdicke(dicke_row, dicke_col):
-                k = int(self.calculate_k(dicke_row, dicke_col))
-                row = {}
-                taus = self.tau_valid(dicke_row, dicke_col)
-                for tau in taus:
-                    j, m = self.calculate_j_m(dicke_row, dicke_col)
-                    current_col = tau_column(tau, k, j)
-                    sparse_M[k, int(current_col)] = taus[tau]
-        return sparse_M.tocsr()
-
-    def solve(self, rho0, tlist, options=None):
-        """
-        Solve the ODE for the evolution of diagonal states and Hamiltonians.
-        """
-        if options is None:
-            options = SolverOptions()
-        output = Result()
-        output.solver = "pisolve"
-        output.times = tlist
-        output.states = []
-        output.states.append(Qobj(rho0))
-        rhs_generate = lambda y, tt, M: M.dot(y)
-        rho0_flat = np.diag(np.real(rho0.full()))
-        L = self.coefficient_matrix()
-        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
-        for r in rho_t[1:]:
-            diag = np.diag(r)
-            output.states.append(Qobj(diag))
-        return output
-
-    def tau1(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j, m, m).
-        """
-        yS = self.collective_emission
-        yL = self.emission
-        yD = self.dephasing
-        yP = self.pumping
-        yCP = self.collective_pumping
-        N = float(self.N)
-        spontaneous = yS * (1 + j - m) * (j + m)
-        losses = yL * (N / 2 + m)
-        pump = yP * (N / 2 - m)
-        collective_pump = yCP * (1 + j + m) * (j - m)
-        if j == 0:
-            dephase = yD * N / 4
-        else:
-            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
-        t1 = spontaneous + losses + pump + dephase + collective_pump
-        return -t1
-
-    def tau2(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j, m+1, m+1).
-        """
-        yS = self.collective_emission
-        yL = self.emission
-        N = float(self.N)
-        spontaneous = yS * (1 + j - m) * (j + m)
-        losses = yL * (
-            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
-        )
-        t2 = spontaneous + losses
-        return t2
-
-    def tau3(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
-        """
-        yL = self.emission
-        N = float(self.N)
-        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
-        den = 2 * j * (2 * j + 1)
-        t3 = yL * (num / den)
-        return t3
-
-    def tau4(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
-        """
-        yL = self.emission
-        N = float(self.N)
-        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
-        den = 2 * (j + 1) * (2 * j + 1)
-        t4 = yL * (num / den)
-        return t4
-
-    def tau5(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j+1, m, m).
-        """
-        yD = self.dephasing
-        N = float(self.N)
-        num = (j - m) * (j + m) * (j + 1 + N / 2)
-        den = 2 * j * (2 * j + 1)
-        t5 = yD * (num / den)
-        return t5
-
-    def tau6(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j-1, m, m).
-        """
-        yD = self.dephasing
-        N = float(self.N)
-        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
-        den = 2 * (j + 1) * (2 * j + 1)
-        t6 = yD * (num / den)
-        return t6
-
-    def tau7(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
-        """
-        yP = self.pumping
-        N = float(self.N)
-        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
-        den = 2 * j * (2 * j + 1)
-        t7 = yP * (float(num) / den)
-        return t7
-
-    def tau8(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j, m-1, m-1).
-        """
-        yP = self.pumping
-        yCP = self.collective_pumping
-        N = float(self.N)
-
-        num = (1 + N / 2) * (j - m) * (j + m + 1)
-        den = 2 * j * (j + 1)
-        pump = yP * (float(num) / den)
-        collective_pump = yCP * (j - m) * (j + m + 1)
-        t8 = pump + collective_pump
-        return t8
-
-    def tau9(self, j, m):
-        """
-        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
-        """
-        yP = self.pumping
-        N = float(self.N)
-        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
-        den = 2 * (j + 1) * (2 * j + 1)
-        t9 = yP * (float(num) / den)
-        return t9
+"""Permutational Invariant Quantum Solver (PIQS)
+
+This module calculates the Liouvillian for the dynamics of ensembles of
+identical two-level systems (TLS) in the presence of local and collective
+processes by exploiting permutational symmetry and using the Dicke basis.
+It also allows to characterize nonlinear functions of the density matrix.
+"""
+
+# Authors: Nathan Shammah, Shahnawaz Ahmed
+# Contact: nathan.shammah@gmail.com, shahnawaz.ahmed95@gmail.com
+
+from math import factorial
+from decimal import Decimal
+
+import numpy as np
+from scipy.integrate import odeint
+from scipy.linalg import eigvalsh
+from scipy.special import entr
+from scipy.sparse import dok_matrix, block_diag, lil_matrix
+from .. import (
+    Qobj, spre, spost, tensor, identity, ket2dm, sigmax, sigmay, sigmaz,
+    sigmap, sigmam,
+)
+from ..entropy import entropy_vn
+from .solver import SolverOptions, Result
+from ._piqs import Dicke as _Dicke
+from ._piqs import (
+    jmm1_dictionary,
+    _num_dicke_states,
+    _num_dicke_ladders,
+    get_blocks,
+    j_min,
+    j_vals,
+)
+
+__all__ = [
+    "num_dicke_states",
+    "num_dicke_ladders",
+    "num_tls",
+    "isdiagonal",
+    "dicke_blocks",
+    "dicke_blocks_full",
+    "dicke_function_trace",
+    "purity_dicke",
+    "entropy_vn_dicke",
+    "Dicke",
+    "state_degeneracy",
+    "m_degeneracy",
+    "energy_degeneracy",
+    "ap",
+    "am",
+    "spin_algebra",
+    "jspin",
+    "collapse_uncoupled",
+    "dicke_basis",
+    "dicke",
+    "excited",
+    "superradiant",
+    "css",
+    "ghz",
+    "ground",
+    "identity_uncoupled",
+    "block_matrix",
+    "tau_column",
+    "Pim",
+]
+
+
+def _ensure_int(x):
+    """
+    Ensure that a floating-point value `x` is exactly an integer, and return it
+    as an int.
+    """
+    out = int(x)
+    if out != x:
+        raise ValueError(f"{x} is not an integral value")
+    return out
+
+
+# Functions necessary to generate the Lindbladian/Liouvillian
+def num_dicke_states(N):
+    """Calculate the number of Dicke states.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    nds: int
+        The number of Dicke states.
+    """
+    return _num_dicke_states(N)
+
+
+def num_dicke_ladders(N):
+    """Calculate the total number of ladders in the Dicke space.
+
+    For a collection of N two-level systems it counts how many different
+    "j" exist or the number of blocks in the block-diagonal matrix.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    Nj: int
+        The number of Dicke ladders.
+    """
+    return _num_dicke_ladders(N)
+
+
+def num_tls(nds):
+    """Calculate the number of two-level systems.
+
+    Parameters
+    ----------
+    nds: int
+         The number of Dicke states.
+
+    Returns
+    -------
+    N: int
+        The number of two-level systems.
+    """
+    if np.sqrt(nds).is_integer():
+        # N is even
+        N = 2 * (np.sqrt(nds) - 1)
+    else:
+        # N is odd
+        N = 2 * (np.sqrt(nds + 1 / 4) - 1)
+    return int(N)
+
+
+def isdiagonal(mat):
+    """
+    Check if the input matrix is diagonal.
+
+    Parameters
+    ==========
+    mat: ndarray/Qobj
+        A 2D numpy array
+
+    Returns
+    =======
+    diag: bool
+        True/False depending on whether the input matrix is diagonal.
+    """
+    if isinstance(mat, Qobj):
+        mat = mat.full()
+
+    return np.all(mat == np.diag(np.diagonal(mat)))
+
+
+# nonlinear functions of the density matrix
+def dicke_blocks(rho):
+    """Create the list of blocks for block-diagonal density matrix in the Dicke basis.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems.
+
+    Returns
+    -------
+    square_blocks: list of np.array
+        Give back the blocks list.
+
+    """
+    shape_dimension = rho.shape[0]
+    N = num_tls(shape_dimension)
+    ladders = num_dicke_ladders(N)
+    # create a list with the sizes of the blocks, in order
+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+    blocks_list = [
+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+        for i in range(blocks_dimensions)
+    ]
+    blocks_list = np.flip(blocks_list, 0)
+    # create a list with each block matrix as element
+    square_blocks = []
+    block_position = 0
+    for block_size in blocks_list:
+        start_m = block_position
+        end_m = block_position + block_size
+        square_block = rho[start_m:end_m, start_m:end_m]
+        block_position = block_position + block_size
+        square_blocks.append(square_block)
+
+    return square_blocks
+
+
+def dicke_blocks_full(rho):
+    """Give the full (2^N-dimensional) list of blocks for a Dicke-basis matrix.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems.
+
+    Returns
+    -------
+    full_blocks : list
+        The list of blocks expanded in the 2^N space for N qubits.
+
+    """
+    shape_dimension = rho.shape[0]
+    N = num_tls(shape_dimension)
+    ladders = num_dicke_ladders(N)
+    # create a list with the sizes of the blocks, in order
+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+    blocks_list = [
+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+        for i in range(blocks_dimensions)
+    ]
+    blocks_list = np.flip(blocks_list, 0)
+    # create a list with each block matrix as element
+    full_blocks = []
+    k = 0
+    block_position = 0
+    for block_size in blocks_list:
+        start_m = block_position
+        end_m = block_position + block_size
+        square_block = rho[start_m:end_m, start_m:end_m]
+        block_position = block_position + block_size
+        j = N / 2 - k
+        djn = state_degeneracy(N, j)
+        for block_counter in range(0, djn):
+            full_blocks.append(square_block / djn)  # preserve trace
+        k = k + 1
+    return full_blocks
+
+
+def dicke_function_trace(f, rho):
+    """Calculate the trace of a function on a Dicke density matrix.
+    Parameters
+    ----------
+    f : function
+        A Taylor-expandable function of `rho`.
+
+    rho : :class:`qutip.Qobj`
+        A density matrix in the Dicke basis.
+
+    Returns
+    -------
+    res : float
+        Trace of a nonlinear function on `rho`.
+    """
+    N = num_tls(rho.shape[0])
+    blocks = dicke_blocks(rho)
+    block_f = []
+    degen_blocks = np.flip(j_vals(N))
+    state_degeneracies = []
+    for j in degen_blocks:
+        dj = state_degeneracy(N, j)
+        state_degeneracies.append(dj)
+    eigenvals_degeneracy = []
+    deg = []
+    for i, block in enumerate(blocks):
+        dj = state_degeneracies[i]
+        normalized_block = block / dj
+        eigenvals_block = eigvalsh(normalized_block)
+        for val in eigenvals_block:
+            eigenvals_degeneracy.append(val)
+            deg.append(dj)
+
+    eigenvalue = np.array(eigenvals_degeneracy)
+    function_array = f(eigenvalue) * deg
+    return sum(function_array)
+
+
+def entropy_vn_dicke(rho):
+    """Von Neumann Entropy of a Dicke-basis density matrix.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        A 2D block-diagonal matrix of ones with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems.
+
+    Returns
+    -------
+    entropy_dm: float
+        Entropy. Use degeneracy to multiply each block.
+
+    """
+    return dicke_function_trace(entr, rho)
+
+
+def purity_dicke(rho):
+    """Calculate purity of a density matrix in the Dicke basis.
+    It accounts for the degenerate blocks in the density matrix.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        Density matrix in the Dicke basis of qutip.piqs.jspin(N), for N spins.
+
+    Returns
+    -------
+    purity : float
+        The purity of the quantum state.
+        It's 1 for pure states, 0<=purity<1 for mixed states.
+    """
+    f = lambda x: x * x
+    return dicke_function_trace(f, rho)
+
+
+class Dicke(object):
+    """The Dicke class which builds the Lindbladian and Liouvillian matrix.
+
+    Examples
+    --------
+    >>> from piqs import Dicke, jspin
+    >>> N = 2
+    >>> jx, jy, jz = jspin(N)
+    >>> jp = jspin(N, "+")
+    >>> jm = jspin(N, "-")
+    >>> ensemble = Dicke(N, emission=1.)
+    >>> L = ensemble.liouvillian()
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    hamiltonian : :class:`qutip.Qobj`
+        A Hamiltonian in the Dicke basis.
+
+        The matrix dimensions are (nds, nds),
+        with nds being the number of Dicke states.
+        The Hamiltonian can be built with the operators
+        given by the `jspin` functions.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Attributes
+    ----------
+    N: int
+        The number of two-level systems.
+
+    hamiltonian : :class:`qutip.Qobj`
+        A Hamiltonian in the Dicke basis.
+
+        The matrix dimensions are (nds, nds),
+        with nds being the number of Dicke states.
+        The Hamiltonian can be built with the operators given
+        by the `jspin` function in the "dicke" basis.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    nds: int
+        The number of Dicke states.
+
+    dshape: tuple
+        The shape of the Hilbert space in the Dicke or uncoupled basis.
+        default: (nds, nds).
+    """
+
+    def __init__(
+        self,
+        N,
+        hamiltonian=None,
+        emission=0.0,
+        dephasing=0.0,
+        pumping=0.0,
+        collective_emission=0.0,
+        collective_dephasing=0.0,
+        collective_pumping=0.0,
+    ):
+        self.N = N
+        self.hamiltonian = hamiltonian
+        self.emission = emission
+        self.dephasing = dephasing
+        self.pumping = pumping
+        self.collective_emission = collective_emission
+        self.collective_dephasing = collective_dephasing
+        self.collective_pumping = collective_pumping
+        self.nds = num_dicke_states(self.N)
+        self.dshape = (num_dicke_states(self.N), num_dicke_states(self.N))
+
+    def __repr__(self):
+        """Print the current parameters of the system."""
+        string = []
+        string.append("N = {}".format(self.N))
+        string.append("Hilbert space dim = {}".format(self.dshape))
+        string.append("Number of Dicke states = {}".format(self.nds))
+        string.append(
+            "Liouvillian space dim = {}".format((self.nds ** 2, self.nds ** 2))
+        )
+        if self.emission != 0:
+            string.append("emission = {}".format(self.emission))
+        if self.dephasing != 0:
+            string.append("dephasing = {}".format(self.dephasing))
+        if self.pumping != 0:
+            string.append("pumping = {}".format(self.pumping))
+        if self.collective_emission != 0:
+            string.append(
+                "collective_emission = {}".format(self.collective_emission)
+            )
+        if self.collective_dephasing != 0:
+            string.append(
+                "collective_dephasing = {}".format(self.collective_dephasing)
+            )
+        if self.collective_pumping != 0:
+            string.append(
+                "collective_pumping = {}".format(self.collective_pumping)
+            )
+        return "\n".join(string)
+
+    def lindbladian(self):
+        """Build the Lindbladian superoperator of the dissipative dynamics.
+
+        Returns
+        -------
+        lindbladian : :class:`qutip.Qobj`
+            The Lindbladian matrix as a `qutip.Qobj`.
+        """
+        cythonized_dicke = _Dicke(
+            int(self.N),
+            float(self.emission),
+            float(self.dephasing),
+            float(self.pumping),
+            float(self.collective_emission),
+            float(self.collective_dephasing),
+            float(self.collective_pumping),
+        )
+        return cythonized_dicke.lindbladian()
+
+    def liouvillian(self):
+        """Build the total Liouvillian using the Dicke basis.
+
+        Returns
+        -------
+        liouv : :class:`qutip.Qobj`
+            The Liouvillian matrix for the system.
+        """
+        lindblad = self.lindbladian()
+        if self.hamiltonian is None:
+            liouv = lindblad
+
+        else:
+            hamiltonian = self.hamiltonian
+            hamiltonian_superoperator = -1j * spre(hamiltonian) + 1j * spost(
+                hamiltonian
+            )
+            liouv = lindblad + hamiltonian_superoperator
+        return liouv
+
+    def pisolve(self, initial_state, tlist, options=None):
+        """
+        Solve for diagonal Hamiltonians and initial states faster.
+
+        Parameters
+        ==========
+        initial_state : :class:`qutip.Qobj`
+            An initial state specified as a density matrix of
+            `qutip.Qbj` type.
+
+        tlist: ndarray
+            A 1D numpy array of list of timesteps to integrate
+
+        options : :class:`qutip.solver.SolverOptions`
+            The options for the solver.
+
+        Returns
+        =======
+        result: list
+            A dictionary of the type `qutip.solver.Result` which holds the
+            results of the evolution.
+        """
+        if isdiagonal(initial_state) == False:
+            msg = "`pisolve` requires a diagonal initial density matrix. "
+            msg += "In general construct the Liouvillian using "
+            msg += "`piqs.liouvillian` and use qutip.mesolve."
+            raise ValueError(msg)
+
+        if self.hamiltonian and isdiagonal(self.hamiltonian) == False:
+            msg = "`pisolve` should only be used for diagonal Hamiltonians. "
+            msg += "Construct the Liouvillian using `piqs.liouvillian` and"
+            msg += "  use `qutip.mesolve`."
+            raise ValueError(msg)
+
+        if initial_state.full().shape != self.dshape:
+            msg = "Initial density matrix should be diagonal."
+            raise ValueError(msg)
+
+        pim = Pim(
+            self.N,
+            self.emission,
+            self.dephasing,
+            self.pumping,
+            self.collective_emission,
+            self.collective_pumping,
+            self.collective_dephasing,
+        )
+        result = pim.solve(initial_state, tlist, options=None)
+        return result
+
+    def c_ops(self):
+        """Build collapse operators in the full Hilbert space 2^N.
+
+        Returns
+        -------
+        c_ops_list: list
+            The list with the collapse operators in the 2^N Hilbert space.
+        """
+        ce = self.collective_emission
+        cd = self.collective_dephasing
+        cp = self.collective_pumping
+        c_ops_list = collapse_uncoupled(
+            N=self.N,
+            emission=self.emission,
+            dephasing=self.dephasing,
+            pumping=self.pumping,
+            collective_emission=ce,
+            collective_dephasing=cd,
+            collective_pumping=cp,
+        )
+        return c_ops_list
+
+    def coefficient_matrix(self):
+        """Build coefficient matrix for ODE for a diagonal problem.
+
+        Returns
+        -------
+        M: ndarray
+            The matrix M of the coefficients for the ODE dp/dt = Mp.
+            p is the vector of the diagonal matrix elements
+            of the density matrix rho in the Dicke basis.
+        """
+        diagonal_system = Pim(
+            N=self.N,
+            emission=self.emission,
+            dephasing=self.dephasing,
+            pumping=self.pumping,
+            collective_emission=self.collective_emission,
+            collective_dephasing=self.collective_dephasing,
+            collective_pumping=self.collective_pumping,
+        )
+        coef_matrix = diagonal_system.coefficient_matrix()
+        return coef_matrix
+
+
+# Utility functions for properties of the Dicke space
+def energy_degeneracy(N, m):
+    """Calculate the number of Dicke states with same energy.
+
+    The use of the `Decimals` class allows to explore N > 1000,
+    unlike the built-in function `scipy.special.binom`
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    m: float
+        Total spin z-axis projection eigenvalue.
+        This is proportional to the total energy.
+
+    Returns
+    -------
+    degeneracy: int
+        The energy degeneracy
+    """
+    numerator = Decimal(factorial(N))
+    d1 = Decimal(factorial(_ensure_int(N / 2 + m)))
+    d2 = Decimal(factorial(_ensure_int(N / 2 - m)))
+    degeneracy = numerator / (d1 * d2)
+    return int(degeneracy)
+
+
+def state_degeneracy(N, j):
+    r"""Calculate the degeneracy of the Dicke state.
+
+    Each state :math:`\lvert j, m\rangle` includes D(N,j) irreducible
+    representations :math:`\lvert j, m, \alpha\rangle`.
+
+    Uses Decimals to calculate higher numerator and denominators numbers.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    j: float
+        Total spin eigenvalue (cooperativity).
+
+    Returns
+    -------
+    degeneracy: int
+        The state degeneracy.
+    """
+    if j < 0:
+        raise ValueError("j value should be >= 0")
+    numerator = Decimal(factorial(N)) * Decimal(2 * j + 1)
+    denominator_1 = Decimal(factorial(_ensure_int(N / 2 + j + 1)))
+    denominator_2 = Decimal(factorial(_ensure_int(N / 2 - j)))
+    degeneracy = numerator / (denominator_1 * denominator_2)
+    degeneracy = int(np.round(float(degeneracy)))
+    return degeneracy
+
+
+def m_degeneracy(N, m):
+    r"""Calculate the number of Dicke states :math:`\lvert j, m\rangle` with
+    same energy.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    m: float
+        Total spin z-axis projection eigenvalue (proportional to the total
+        energy).
+
+    Returns
+    -------
+    degeneracy: int
+        The m-degeneracy.
+    """
+    jvals = j_vals(N)
+    maxj = np.max(jvals)
+    if m < -maxj:
+        e = "m value is incorrect for this N."
+        e += " Minimum m value can be {}".format(-maxj)
+        raise ValueError(e)
+    degeneracy = N / 2 + 1 - abs(m)
+    return int(degeneracy)
+
+
+def ap(j, m):
+    r"""
+    Calculate the coefficient ``ap`` by applying :math:`J_+\lvert j,m\rangle`.
+
+    The action of ap is given by:
+    :math:`J_{+}\lvert j, m\rangle = A_{+}(j, m) \lvert j, m+1\rangle`
+
+    Parameters
+    ----------
+    j, m: float
+        The value for j and m in the dicke basis :math:`\lvert j, m\rangle`.
+
+    Returns
+    -------
+    a_plus: float
+        The value of :math:`a_{+}`.
+    """
+    a_plus = np.sqrt((j - m) * (j + m + 1))
+    return a_plus
+
+
+def am(j, m):
+    r"""Calculate the operator ``am`` used later.
+
+    The action of ``ap`` is given by:
+    :math:`J_{-}\lvert j,m\rangle = A_{-}(jm)\lvert j,m-1\rangle`
+
+    Parameters
+    ----------
+    j: float
+        The value for j.
+
+    m: float
+        The value for m.
+
+    Returns
+    -------
+    a_minus: float
+        The value of :math:`a_{-}`.
+    """
+    a_minus = np.sqrt((j + m) * (j - m + 1))
+    return a_minus
+
+
+def spin_algebra(N, op=None):
+    """Create the list [sx, sy, sz] with the spin operators.
+
+    The operators are constructed for a collection of N two-level systems
+    (TLSs). Each element of the list, i.e., sx, is a vector of `qutip.Qobj`
+    objects (spin matrices), as it cointains the list of the SU(2) Pauli
+    matrices for the N TLSs. Each TLS operator sx[i], with i = 0, ..., (N-1),
+    is placed in a :math:`2^N`-dimensional Hilbert space.
+
+    Notes
+    -----
+    sx[i] is :math:`\\frac{\\sigma_x}{2}` in the composite Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    spin_operators: list or :class: qutip.Qobj
+        A list of `qutip.Qobj` operators - [sx, sy, sz] or the
+        requested operator.
+    """
+    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
+    N = int(N)
+    sx = [0 for i in range(N)]
+    sy = [0 for i in range(N)]
+    sz = [0 for i in range(N)]
+    sp = [0 for i in range(N)]
+    sm = [0 for i in range(N)]
+
+    sx[0] = 0.5 * sigmax()
+    sy[0] = 0.5 * sigmay()
+    sz[0] = 0.5 * sigmaz()
+    sp[0] = sigmap()
+    sm[0] = sigmam()
+
+    # 2. Place operators in total Hilbert space
+    for k in range(N - 1):
+        sx[0] = tensor(sx[0], identity(2))
+        sy[0] = tensor(sy[0], identity(2))
+        sz[0] = tensor(sz[0], identity(2))
+        sp[0] = tensor(sp[0], identity(2))
+        sm[0] = tensor(sm[0], identity(2))
+
+    # 3. Cyclic sequence to create all N operators
+    a = [i for i in range(N)]
+    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
+
+    # 4. Create N operators
+    for i in range(1, N):
+        sx[i] = sx[0].permute(b[i])
+        sy[i] = sy[0].permute(b[i])
+        sz[i] = sz[0].permute(b[i])
+        sp[i] = sp[0].permute(b[i])
+        sm[i] = sm[0].permute(b[i])
+
+    spin_operators = [sx, sy, sz]
+
+    if not op:
+        return spin_operators
+    elif op == "x":
+        return sx
+    elif op == "y":
+        return sy
+    elif op == "z":
+        return sz
+    elif op == "+":
+        return sp
+    elif op == "-":
+        return sm
+    else:
+        raise TypeError("Invalid type")
+
+
+def _jspin_uncoupled(N, op=None):
+    """Construct the the collective spin algebra in the uncoupled basis.
+
+    jx, jy, jz, jp, jm are constructed in the uncoupled basis of the
+    two-level system (TLS). Each collective operator is placed in a
+    Hilbert space of dimension 2^N.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    op: str
+        The operator to return 'x','y','z','+','-'.
+        If no operator given, then output is the list of operators
+        for ['x','y','z',].
+
+    Returns
+    -------
+    collective_operators: list or :class: qutip.Qobj
+        A list of `qutip.Qobj` representing all the operators in
+        uncoupled" basis or a single operator requested.
+    """
+    # 1. Define N TLS spin-1/2 matrices in the uncoupled basis
+    N = int(N)
+
+    sx, sy, sz = spin_algebra(N)
+    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
+
+    jx = sum(sx)
+    jy = sum(sy)
+    jz = sum(sz)
+    jp = sum(sp)
+    jm = sum(sm)
+
+    collective_operators = [jx, jy, jz]
+
+    if not op:
+        return collective_operators
+    elif op == "x":
+        return jx
+    elif op == "y":
+        return jy
+    elif op == "z":
+        return jz
+    elif op == "+":
+        return jp
+    elif op == "-":
+        return jm
+    else:
+        raise TypeError("Invalid type")
+
+
+def jspin(N, op=None, basis="dicke"):
+    r"""
+    Calculate the list of collective operators of the total algebra.
+
+    The Dicke basis :math:`\lvert j,m\rangle\langle j,m'\rvert` is used by
+    default. Otherwise with "uncoupled" the operators are in a
+    :math:`2^N` space.
+
+    Parameters
+    ----------
+    N: int
+        Number of two-level systems.
+
+    op: str
+        The operator to return 'x','y','z','+','-'.
+        If no operator given, then output is the list of operators
+        for ['x','y','z'].
+
+    basis: str
+        The basis of the operators - "dicke" or "uncoupled"
+        default: "dicke".
+
+    Returns
+    -------
+    j_alg: list or :class: qutip.Qobj
+        A list of `qutip.Qobj` representing all the operators in
+        the "dicke" or "uncoupled" basis or a single operator requested.
+    """
+    if basis == "uncoupled":
+        return _jspin_uncoupled(N, op)
+
+    nds = num_dicke_states(N)
+    num_ladders = num_dicke_ladders(N)
+    jz_operator = dok_matrix((nds, nds), dtype=np.complex128)
+    jp_operator = dok_matrix((nds, nds), dtype=np.complex128)
+    jm_operator = dok_matrix((nds, nds), dtype=np.complex128)
+    s = 0
+
+    for k in range(0, num_ladders):
+        j = 0.5 * N - k
+        mmax = int(2 * j + 1)
+        for i in range(0, mmax):
+            m = j - i
+            jz_operator[s, s] = m
+            if (s + 1) in range(0, nds):
+                jp_operator[s, s + 1] = ap(j, m - 1)
+            if (s - 1) in range(0, nds):
+                jm_operator[s, s - 1] = am(j, m + 1)
+            s = s + 1
+
+    jx_operator = 1 / 2 * (jp_operator + jm_operator)
+    jy_operator = 1j / 2 * (jm_operator - jp_operator)
+    jx = Qobj(jx_operator)
+    jy = Qobj(jy_operator)
+    jz = Qobj(jz_operator)
+    jp = Qobj(jp_operator)
+    jm = Qobj(jm_operator)
+
+    if not op:
+        return [jx, jy, jz]
+    if op == "+":
+        return jp
+    elif op == "-":
+        return jm
+    elif op == "x":
+        return jx
+    elif op == "y":
+        return jy
+    elif op == "z":
+        return jz
+    else:
+        raise TypeError("Invalid type")
+
+
+def collapse_uncoupled(
+    N,
+    emission=0.0,
+    dephasing=0.0,
+    pumping=0.0,
+    collective_emission=0.0,
+    collective_dephasing=0.0,
+    collective_pumping=0.0,
+):
+    """
+    Create the collapse operators (c_ops) of the Lindbladian in the
+    uncoupled basis
+
+    These operators are in the uncoupled basis of the two-level
+    system (TLS) SU(2) Pauli matrices.
+
+    Notes
+    -----
+    The collapse operator list can be given to `qutip.mesolve`.
+    Notice that the operators are placed in a Hilbert space of
+    dimension :math:`2^N`. Thus the method is suitable only for
+    small N (of the order of 10).
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Returns
+    -------
+    c_ops: list
+        The list of collapse operators as `qutip.Qobj` for the system.
+    """
+    N = int(N)
+
+    if N > 10:
+        msg = "N > 10. dim(H) = 2^N. "
+        msg += "Better use `piqs.lindbladian` to reduce Hilbert space "
+        msg += "dimension and exploit permutational symmetry."
+        raise Warning(msg)
+
+    [sx, sy, sz] = spin_algebra(N)
+    sp, sm = spin_algebra(N, "+"), spin_algebra(N, "-")
+    [jx, jy, jz] = jspin(N, basis="uncoupled")
+    jp, jm = (
+        jspin(N, "+", basis="uncoupled"),
+        jspin(N, "-", basis="uncoupled"),
+    )
+
+    c_ops = []
+
+    if emission != 0:
+        for i in range(0, N):
+            c_ops.append(np.sqrt(emission) * sm[i])
+
+    if dephasing != 0:
+        for i in range(0, N):
+            c_ops.append(np.sqrt(dephasing) * sz[i])
+
+    if pumping != 0:
+        for i in range(0, N):
+            c_ops.append(np.sqrt(pumping) * sp[i])
+
+    if collective_emission != 0:
+        c_ops.append(np.sqrt(collective_emission) * jm)
+
+    if collective_dephasing != 0:
+        c_ops.append(np.sqrt(collective_dephasing) * jz)
+
+    if collective_pumping != 0:
+        c_ops.append(np.sqrt(collective_pumping) * jp)
+
+    return c_ops
+
+
+# State definitions in the Dicke basis with an option for basis transformation
+def dicke_basis(N, jmm1=None):
+    r"""
+    Initialize the density matrix of a Dicke state for several (j, m, m1).
+
+    This function can be used to build arbitrary states in the Dicke basis
+    :math:`\lvert j, m\rangle\langle j, m'\rvert`. We create coefficients for
+    each (j, m, m1) value in the dictionary jmm1. The mapping for the (i, k)
+    index of the density matrix to the :math:`\lvert j, m\rangle` values is
+    given by the cythonized function `jmm1_dictionary`. A density matrix is
+    created from the given dictionary of coefficients for each (j, m, m1).
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    jmm1: dict
+        A dictionary of {(j, m, m1): p} that gives a density p for the
+        (j, m, m1) matrix element.
+
+    Returns
+    -------
+    rho: :class: qutip.Qobj
+        The density matrix in the Dicke basis.
+    """
+    if jmm1 is None:
+        msg = "Please specify the jmm1 values as a dictionary"
+        msg += "or use the `excited(N)` function to create an"
+        msg += "excited state where jmm1 = {(N/2, N/2, N/2): 1}"
+        raise AttributeError(msg)
+
+    nds = _num_dicke_states(N)
+    rho = np.zeros((nds, nds))
+    jmm1_dict = jmm1_dictionary(N)[1]
+    for key in jmm1:
+        i, k = jmm1_dict[key]
+        rho[i, k] = jmm1[key]
+    return Qobj(rho)
+
+
+def dicke(N, j, m):
+    r"""
+    Generate a Dicke state as a pure density matrix in the Dicke basis.
+
+    For instance, the superradiant state given by
+    :math:`\lvert  j, m\rangle = \lvert 1, 0\rangle` for N = 2,
+    and the state is represented as a density matrix of size (nds, nds) or
+    (4, 4), with the (1, 1) element set to 1.
+
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    j: float
+        The eigenvalue j of the Dicke state (j, m).
+
+    m: float
+        The eigenvalue m of the Dicke state (j, m).
+
+    Returns
+    -------
+    rho: :class: qutip.Qobj
+        The density matrix.
+    """
+    nds = num_dicke_states(N)
+    rho = np.zeros((nds, nds))
+
+    jmm1_dict = jmm1_dictionary(N)[1]
+
+    i, k = jmm1_dict[(j, m, m)]
+    rho[i, k] = 1.0
+    return Qobj(rho)
+
+
+# Uncoupled states in the full Hilbert space. These are returned with the
+# choice of the keyword argument `basis="uncoupled"` in the state functions.
+def _uncoupled_excited(N):
+    """
+    Generate the density matrix of the excited Dicke state in the full
+    :math:`2^N` dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    psi0: :class: qutip.Qobj
+        The density matrix for the excited state in the uncoupled basis.
+    """
+    N = int(N)
+    jz = jspin(N, "z", basis="uncoupled")
+    en, vn = jz.eigenstates()
+    psi0 = vn[2 ** N - 1]
+    return ket2dm(psi0)
+
+
+def _uncoupled_superradiant(N):
+    """
+    Generate the density matrix of a superradiant state in the full
+    :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    psi0: :class: qutip.Qobj
+        The density matrix for the superradiant state in the full Hilbert
+        space.
+    """
+    N = int(N)
+    jz = jspin(N, "z", basis="uncoupled")
+    en, vn = jz.eigenstates()
+    psi0 = vn[2 ** N - (N + 1)]
+    return ket2dm(psi0)
+
+
+def _uncoupled_ground(N):
+    """
+    Generate the density matrix of the ground state in the full\
+    :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    psi0: :class: qutip.Qobj
+        The density matrix for the ground state in the full Hilbert space.
+    """
+    N = int(N)
+    jz = jspin(N, "z", basis="uncoupled")
+    en, vn = jz.eigenstates()
+    psi0 = vn[0]
+    return ket2dm(psi0)
+
+
+def _uncoupled_ghz(N):
+    """
+    Generate the density matrix of the GHZ state in the full 2^N
+    dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    ghz: :class: qutip.Qobj
+        The density matrix for the GHZ state in the full Hilbert space.
+    """
+    N = int(N)
+    rho = np.zeros((2 ** N, 2 ** N))
+    rho[0, 0] = 1 / 2
+    rho[2 ** N - 1, 0] = 1 / 2
+    rho[0, 2 ** N - 1] = 1 / 2
+    rho[2 ** N - 1, 2 ** N - 1] = 1 / 2
+    spin_dim = [2 for i in range(0, N)]
+    spins_dims = list((spin_dim, spin_dim))
+    rho = Qobj(rho, dims=spins_dims)
+    return rho
+
+
+def _uncoupled_css(N, a, b):
+    r"""
+    Generate the density matrix of the CSS state in the full 2^N
+    dimensional Hilbert space.
+
+    The CSS states are non-entangled states given by
+    :math:`\lvert a,b\rangle = \prod_i(a\lvert1\rangle_i + b\lvert0\rangle_i)`.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    a: complex
+        The coefficient of the :math:`\lvert1_i\rangle` state.
+
+    b: complex
+        The coefficient of the :math:`\lvert0_i\rangle` state.
+
+    Returns
+    -------
+    css: :class: qutip.Qobj
+        The density matrix for the CSS state in the full Hilbert space.
+    """
+    N = int(N)
+    # 1. Define i_th factorized density matrix in the uncoupled basis
+    rho_i = np.zeros((2, 2), dtype=complex)
+    rho_i[0, 0] = a * np.conj(a)
+    rho_i[1, 1] = b * np.conj(b)
+    rho_i[0, 1] = a * np.conj(b)
+    rho_i[1, 0] = b * np.conj(a)
+    rho_i = Qobj(rho_i)
+    rho = [0 for i in range(N)]
+    rho[0] = rho_i
+    # 2. Place single-two-level-system density matrices in total Hilbert space
+    for k in range(N - 1):
+        rho[0] = tensor(rho[0], identity(2))
+    # 3. Cyclic sequence to create all N factorized density matrices
+    # |CSS>_i<CSS|_i
+    a = [i for i in range(N)]
+    b = [[a[i - i2] for i in range(N)] for i2 in range(N)]
+    # 4. Create all other N-1 factorized density matrices
+    # |+><+| = Prod_(i=1)^N |CSS>_i<CSS|_i
+    for i in range(1, N):
+        rho[i] = rho[0].permute(b[i])
+    identity_i = Qobj(np.eye(2 ** N), dims=rho[0].dims)
+    rho_tot = identity_i
+    for i in range(0, N):
+        rho_tot = rho_tot * rho[i]
+    return rho_tot
+
+
+def excited(N, basis="dicke"):
+    """
+    Generate the density matrix for the excited state.
+
+    This state is given by (N/2, N/2) in the default Dicke basis. If the
+    argument `basis` is "uncoupled" then it generates the state in a
+    2**N dim Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The excited state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        state = _uncoupled_excited(N)
+        return state
+
+    jmm1 = {(N / 2, N / 2, N / 2): 1}
+    return dicke_basis(N, jmm1)
+
+
+def superradiant(N, basis="dicke"):
+    """
+    Generate the density matrix of the superradiant state.
+
+    This state is given by (N/2, 0) or (N/2, 0.5) in the Dicke basis.
+    If the argument `basis` is "uncoupled" then it generates the state
+    in a 2**N dim Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The superradiant state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        state = _uncoupled_superradiant(N)
+        return state
+
+    if N % 2 == 0:
+        jmm1 = {(N / 2, 0, 0): 1.0}
+        return dicke_basis(N, jmm1)
+    else:
+        jmm1 = {(N / 2, 0.5, 0.5): 1.0}
+    return dicke_basis(N, jmm1)
+
+
+def css(
+    N,
+    x=1 / np.sqrt(2),
+    y=1 / np.sqrt(2),
+    basis="dicke",
+    coordinates="cartesian",
+):
+    r"""
+    Generate the density matrix of the Coherent Spin State (CSS).
+
+    It can be defined as,
+    :math:`\lvert CSS\rangle = \prod_i^N(a\lvert1\rangle_i+b\lvert0\rangle_i)`
+    with :math:`a = sin(\frac{\theta}{2})`,
+    :math:`b = e^{i \phi}\cos(\frac{\theta}{2})`.
+    The default basis is that of Dicke space
+    :math:`\lvert j, m\rangle \langle j, m'\rvert`.
+    The default state is the symmetric CSS,
+    :math:`\lvert CSS\rangle = \lvert+\rangle`.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    x, y: float
+        The coefficients of the CSS state.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    coordinates: str
+        Either "cartesian" or "polar". If polar then the coefficients
+        are constructed as sin(x/2), cos(x/2)e^(iy).
+
+    Returns
+    -------
+    rho: :class: qutip.Qobj
+        The CSS state density matrix.
+    """
+    if coordinates == "polar":
+        a = np.cos(0.5 * x) * np.exp(1j * y)
+        b = np.sin(0.5 * x)
+    else:
+        a = x
+        b = y
+    if basis == "uncoupled":
+        return _uncoupled_css(N, a, b)
+    nds = num_dicke_states(N)
+    num_ladders = num_dicke_ladders(N)
+    rho = dok_matrix((nds, nds), dtype=np.complex128)
+
+    # loop in the allowed matrix elements
+    jmm1_dict = jmm1_dictionary(N)[1]
+
+    j = 0.5 * N
+    mmax = int(2 * j + 1)
+    for i in range(0, mmax):
+        m = j - i
+        psi_m = (
+            np.sqrt(float(energy_degeneracy(N, m)))
+            * a ** (N * 0.5 + m)
+            * b ** (N * 0.5 - m)
+        )
+        for i1 in range(0, mmax):
+            m1 = j - i1
+            row_column = jmm1_dict[(j, m, m1)]
+            psi_m1 = (
+                np.sqrt(float(energy_degeneracy(N, m1)))
+                * np.conj(a) ** (N * 0.5 + m1)
+                * np.conj(b) ** (N * 0.5 - m1)
+            )
+            rho[row_column] = psi_m * psi_m1
+    return Qobj(rho)
+
+
+def ghz(N, basis="dicke"):
+    """
+    Generate the density matrix of the GHZ state.
+
+    If the argument `basis` is "uncoupled" then it generates the state
+    in a :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled".
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The GHZ state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        return _uncoupled_ghz(N)
+    nds = _num_dicke_states(N)
+    rho = dok_matrix((nds, nds), dtype=np.complex128)
+    rho[0, 0] = 1 / 2
+    rho[N, N] = 1 / 2
+    rho[N, 0] = 1 / 2
+    rho[0, N] = 1 / 2
+    return Qobj(rho)
+
+
+def ground(N, basis="dicke"):
+    """
+    Generate the density matrix of the ground state.
+
+    This state is given by (N/2, -N/2) in the Dicke basis. If the argument
+    `basis` is "uncoupled" then it generates the state in a
+    :math:`2^N`-dimensional Hilbert space.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    basis: str
+        The basis to use. Either "dicke" or "uncoupled"
+
+    Returns
+    -------
+    state: :class: qutip.Qobj
+        The ground state density matrix in the requested basis.
+    """
+    if basis == "uncoupled":
+        state = _uncoupled_ground(N)
+        return state
+    nds = _num_dicke_states(N)
+    rho = dok_matrix((nds, nds), dtype=np.complex128)
+    rho[N, N] = 1
+    return Qobj(rho)
+
+
+def identity_uncoupled(N):
+    """
+    Generate the identity in a :math:`2^N`-dimensional Hilbert space.
+
+    The identity matrix is formed from the tensor product of N TLSs.
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    Returns
+    -------
+    identity: :class: qutip.Qobj
+        The identity matrix.
+    """
+    N = int(N)
+    rho = np.zeros((2 ** N, 2 ** N))
+    for i in range(0, 2 ** N):
+        rho[i, i] = 1
+    spin_dim = [2 for i in range(0, N)]
+    spins_dims = list((spin_dim, spin_dim))
+    identity = Qobj(rho, dims=spins_dims)
+    return identity
+
+
+def block_matrix(N, elements="ones"):
+    """Construct the block-diagonal matrix for the Dicke basis.
+
+    Parameters
+    ----------
+    N : int
+        Number of two-level systems.
+    elements : str {'ones' (default),'degeneracy'}
+
+    Returns
+    -------
+    block_matr : ndarray
+        A 2D block-diagonal matrix with dimension (nds,nds),
+        where nds is the number of Dicke states for N two-level
+        systems. Filled with ones or the value of degeneracy
+        at each matrix element.
+    """
+    # create a list with the sizes of the blocks, in order
+    blocks_dimensions = int(N / 2 + 1 - 0.5 * (N % 2))
+    blocks_list = [
+        (2 * (i + 1 * (N % 2)) + 1 * ((N + 1) % 2))
+        for i in range(blocks_dimensions)
+    ]
+    blocks_list = np.flip(blocks_list, 0)
+    # create a list with each block matrix as element
+    square_blocks = []
+    k = 0
+    for i in blocks_list:
+        if elements == "ones":
+            square_blocks.append(np.ones((i, i)))
+        elif elements == "degeneracy":
+            j = N / 2 - k
+            dj = state_degeneracy(N, j)
+            square_blocks.append(dj * np.ones((i, i)))
+        k = k + 1
+    return block_diag(square_blocks)
+
+
+# ============================================================================
+# Adding a faster version to make a Permutational Invariant matrix
+# ============================================================================
+def tau_column(tau, k, j):
+    """
+    Determine the column index for the non-zero elements of the matrix for a
+    particular row `k` and the value of `j` from the Dicke space.
+
+    Parameters
+    ----------
+    tau: str
+        The tau function to check for this `k` and `j`.
+
+    k: int
+        The row of the matrix M for which the non zero elements have
+        to be calculated.
+
+    j: float
+        The value of `j` for this row.
+    """
+    # In the notes, we indexed from k = 1, here we do it from k = 0
+    k = k + 1
+    mapping = {
+        "tau3": k - (2 * j + 3),
+        "tau2": k - 1,
+        "tau4": k + (2 * j - 1),
+        "tau5": k - (2 * j + 2),
+        "tau1": k,
+        "tau6": k + (2 * j),
+        "tau7": k - (2 * j + 1),
+        "tau8": k + 1,
+        "tau9": k + (2 * j + 1),
+    }
+    # we need to decrement k again as indexing is from 0
+    return int(mapping[tau] - 1)
+
+
+class Pim(object):
+    """
+    The Permutation Invariant Matrix class.
+
+    Initialize the class with the parameters for generating a Permutation
+    Invariant matrix which evolves a given diagonal initial state `p` as:
+
+                                dp/dt = Mp
+
+    Parameters
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    Attributes
+    ----------
+    N: int
+        The number of two-level systems.
+
+    emission: float
+        Incoherent emission coefficient (also nonradiative emission).
+        default: 0.0
+
+    dephasing: float
+        Local dephasing coefficient.
+        default: 0.0
+
+    pumping: float
+        Incoherent pumping coefficient.
+        default: 0.0
+
+    collective_emission: float
+        Collective (superradiant) emmission coefficient.
+        default: 0.0
+
+    collective_dephasing: float
+        Collective dephasing coefficient.
+        default: 0.0
+
+    collective_pumping: float
+        Collective pumping coefficient.
+        default: 0.0
+
+    M: dict
+        A nested dictionary of the structure {row: {col: val}} which holds
+        non zero elements of the matrix M
+    """
+
+    def __init__(
+        self,
+        N,
+        emission=0.0,
+        dephasing=0,
+        pumping=0,
+        collective_emission=0,
+        collective_pumping=0,
+        collective_dephasing=0,
+    ):
+        self.N = N
+        self.emission = emission
+        self.dephasing = dephasing
+        self.pumping = pumping
+        self.collective_pumping = collective_pumping
+        self.collective_dephasing = collective_dephasing
+        self.collective_emission = collective_emission
+        self.M = {}
+
+    def isdicke(self, dicke_row, dicke_col):
+        """
+        Check if an element in a matrix is a valid element in the Dicke space.
+        Dicke row: j value index. Dicke column: m value index.
+        The function returns True if the element exists in the Dicke space and
+        False otherwise.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col : int
+            Index of the element in Dicke space which needs to be checked
+        """
+        rows = self.N + 1
+        cols = 0
+
+        if (self.N % 2) == 0:
+            cols = int(self.N / 2 + 1)
+        else:
+            cols = int(self.N / 2 + 1 / 2)
+        if (dicke_row > rows) or (dicke_row < 0):
+            return False
+        if (dicke_col > cols) or (dicke_col < 0):
+            return False
+        if (dicke_row < int(rows / 2)) and (dicke_col > dicke_row):
+            return False
+        if (dicke_row >= int(rows / 2)) and (rows - dicke_row <= dicke_col):
+            return False
+        else:
+            return True
+
+    def tau_valid(self, dicke_row, dicke_col):
+        """
+        Find the Tau functions which are valid for this value of (dicke_row,
+        dicke_col) given the number of TLS. This calculates the valid tau
+        values and reurns a dictionary specifying the tau function name and
+        the value.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col : int
+            Index of the element in Dicke space which needs to be checked.
+
+        Returns
+        -------
+        taus: dict
+            A dictionary of key, val as {tau: value} consisting of the valid
+            taus for this row and column of the Dicke space element.
+        """
+        tau_functions = [
+            self.tau3,
+            self.tau2,
+            self.tau4,
+            self.tau5,
+            self.tau1,
+            self.tau6,
+            self.tau7,
+            self.tau8,
+            self.tau9,
+        ]
+        N = self.N
+        if self.isdicke(dicke_row, dicke_col) is False:
+            return False
+        # The 3x3 sub matrix surrounding the Dicke space element to
+        # run the tau functions
+        indices = [
+            (dicke_row + x, dicke_col + y)
+            for x in range(-1, 2)
+            for y in range(-1, 2)
+        ]
+        taus = {}
+        for idx, tau in zip(indices, tau_functions):
+            if self.isdicke(idx[0], idx[1]):
+                j, m = self.calculate_j_m(idx[0], idx[1])
+                taus[tau.__name__] = tau(j, m)
+        return taus
+
+    def calculate_j_m(self, dicke_row, dicke_col):
+        """
+        Get the value of j and m for the particular Dicke space element.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col: int
+            The row and column from the Dicke space matrix
+
+        Returns
+        -------
+        j, m: float
+            The j and m values.
+        """
+        N = self.N
+        j = N / 2 - dicke_col
+        m = N / 2 - dicke_row
+        return (j, m)
+
+    def calculate_k(self, dicke_row, dicke_col):
+        """
+        Get k value from the current row and column element in the Dicke space.
+
+        Parameters
+        ----------
+        dicke_row, dicke_col: int
+            The row and column from the Dicke space matrix.
+        Returns
+        -------
+        k: int
+            The row index for the matrix M for given Dicke space
+            element.
+        """
+        N = self.N
+        if dicke_row == 0:
+            k = dicke_col
+        else:
+            k = int(
+                ((dicke_col) / 2) * (2 * (N + 1) - 2 * (dicke_col - 1))
+                + (dicke_row - (dicke_col))
+            )
+        return k
+
+    def coefficient_matrix(self):
+        """
+        Generate the matrix M governing the dynamics for diagonal cases.
+
+        If the initial density matrix and the Hamiltonian is diagonal, the
+        evolution of the system is given by the simple ODE: dp/dt = Mp.
+        """
+        N = self.N
+        nds = num_dicke_states(N)
+        rows = self.N + 1
+        cols = 0
+
+        sparse_M = lil_matrix((nds, nds), dtype=float)
+        if (self.N % 2) == 0:
+            cols = int(self.N / 2 + 1)
+        else:
+            cols = int(self.N / 2 + 1 / 2)
+        for (dicke_row, dicke_col) in np.ndindex(rows, cols):
+            if self.isdicke(dicke_row, dicke_col):
+                k = int(self.calculate_k(dicke_row, dicke_col))
+                row = {}
+                taus = self.tau_valid(dicke_row, dicke_col)
+                for tau in taus:
+                    j, m = self.calculate_j_m(dicke_row, dicke_col)
+                    current_col = tau_column(tau, k, j)
+                    sparse_M[k, int(current_col)] = taus[tau]
+        return sparse_M.tocsr()
+
+    def solve(self, rho0, tlist, options=None):
+        """
+        Solve the ODE for the evolution of diagonal states and Hamiltonians.
+        """
+        if options is None:
+            options = SolverOptions()
+        output = Result()
+        output.solver = "pisolve"
+        output.times = tlist
+        output.states = []
+        output.states.append(Qobj(rho0))
+        rhs_generate = lambda y, tt, M: M.dot(y)
+        rho0_flat = np.diag(np.real(rho0.full()))
+        L = self.coefficient_matrix()
+        rho_t = odeint(rhs_generate, rho0_flat, tlist, args=(L,))
+        for r in rho_t[1:]:
+            diag = np.diag(r)
+            output.states.append(Qobj(diag))
+        return output
+
+    def tau1(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j, m, m).
+        """
+        yS = self.collective_emission
+        yL = self.emission
+        yD = self.dephasing
+        yP = self.pumping
+        yCP = self.collective_pumping
+        N = float(self.N)
+        spontaneous = yS * (1 + j - m) * (j + m)
+        losses = yL * (N / 2 + m)
+        pump = yP * (N / 2 - m)
+        collective_pump = yCP * (1 + j + m) * (j - m)
+        if j == 0:
+            dephase = yD * N / 4
+        else:
+            dephase = yD * (N / 4 - m ** 2 * ((1 + N / 2) / (2 * j * (j + 1))))
+        t1 = spontaneous + losses + pump + dephase + collective_pump
+        return -t1
+
+    def tau2(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j, m+1, m+1).
+        """
+        yS = self.collective_emission
+        yL = self.emission
+        N = float(self.N)
+        spontaneous = yS * (1 + j - m) * (j + m)
+        losses = yL * (
+            ((N / 2 + 1) * (j - m + 1) * (j + m)) / (2 * j * (j + 1))
+        )
+        t2 = spontaneous + losses
+        return t2
+
+    def tau3(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j+1, m+1, m+1).
+        """
+        yL = self.emission
+        N = float(self.N)
+        num = (j + m - 1) * (j + m) * (j + 1 + N / 2)
+        den = 2 * j * (2 * j + 1)
+        t3 = yL * (num / den)
+        return t3
+
+    def tau4(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j-1, m+1, m+1).
+        """
+        yL = self.emission
+        N = float(self.N)
+        num = (j - m + 1) * (j - m + 2) * (N / 2 - j)
+        den = 2 * (j + 1) * (2 * j + 1)
+        t4 = yL * (num / den)
+        return t4
+
+    def tau5(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j+1, m, m).
+        """
+        yD = self.dephasing
+        N = float(self.N)
+        num = (j - m) * (j + m) * (j + 1 + N / 2)
+        den = 2 * j * (2 * j + 1)
+        t5 = yD * (num / den)
+        return t5
+
+    def tau6(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j-1, m, m).
+        """
+        yD = self.dephasing
+        N = float(self.N)
+        num = (j - m + 1) * (j + m + 1) * (N / 2 - j)
+        den = 2 * (j + 1) * (2 * j + 1)
+        t6 = yD * (num / den)
+        return t6
+
+    def tau7(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j+1, m-1, m-1).
+        """
+        yP = self.pumping
+        N = float(self.N)
+        num = (j - m - 1) * (j - m) * (j + 1 + N / 2)
+        den = 2 * j * (2 * j + 1)
+        t7 = yP * (float(num) / den)
+        return t7
+
+    def tau8(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j, m-1, m-1).
+        """
+        yP = self.pumping
+        yCP = self.collective_pumping
+        N = float(self.N)
+
+        num = (1 + N / 2) * (j - m) * (j + m + 1)
+        den = 2 * j * (j + 1)
+        pump = yP * (float(num) / den)
+        collective_pump = yCP * (j - m) * (j + m + 1)
+        t8 = pump + collective_pump
+        return t8
+
+    def tau9(self, j, m):
+        """
+        Calculate coefficient matrix element relative to (j-1, m-1, m-1).
+        """
+        yP = self.pumping
+        N = float(self.N)
+        num = (j + m + 1) * (j + m + 2) * (N / 2 - j)
+        den = 2 * (j + 1) * (2 * j + 1)
+        t9 = yP * (float(num) / den)
+        return t9
diff --git a/qutip/solve/rcsolve.py b/qutip/solve/rcsolve.py
index 7352b978df..b357bc6e02 100644
--- a/qutip/solve/rcsolve.py
+++ b/qutip/solve/rcsolve.py
@@ -1,127 +1,127 @@
-"""
-This module provides exact solvers for a system-bath setup using the
-reaction coordinate method.
-"""
-
-# Author: Neill Lambert, Anubhav Vardhan
-# Contact: nwlambert@gmail.com
-
-__all__ = ['rcsolve']
-
-import warnings
-import numpy as np
-import scipy.sparse as sp
-from numpy import matrix
-from numpy import linalg
-from .. import (
-    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
-    sigmaz, basis, qeye, mesolve
-)
-
-
-def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
-            options=None):
-    """
-    Function to solve for an open quantum system using the
-    reaction coordinate (RC) model.
-
-    Parameters
-    ----------
-    Hsys: Qobj
-        The system hamiltonian.
-    psi0: Qobj
-        Initial state of the system.
-    tlist: List.
-        Time over which system evolves.
-    e_ops: list of :class:`qutip.Qobj` / callback function single
-        Single operator or list of operators for which to evaluate
-        expectation values.
-    Q: Qobj
-        The coupling between system and bath.
-    wc: Float
-        Cutoff frequency.
-    alpha: Float
-        Coupling strength.
-    N: Integer
-        Number of cavity fock states.
-    w_th: Float
-        Temperature.
-    sparse: Boolean
-        Optional argument to call the sparse eigenstates solver if needed.
-    options : dict
-        Options for the solver.
-
-    Returns
-    -------
-    output: Result
-        System evolution.
-    """
-    if options is None:
-        options = {}
-
-    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
-    deltaE = dot_energy[1] - dot_energy[0]
-    if (w_th < deltaE/2):
-        warnings.warn("Given w_th might not provide accurate results")
-    gamma = deltaE / (2 * np.pi * wc)
-    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
-    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
-    nb = (1 / (np.exp(wa/w_th) - 1))
-
-    # Reaction coordinate hamiltonian/operators
-
-    dimensions = Q.dims
-    a = tensor(destroy(N), qeye(dimensions[1]))
-    unit = tensor(qeye(N), qeye(dimensions[1]))
-    Nmax = N * dimensions[1][0]
-    Q_exp = tensor(qeye(N), Q)
-    Hsys_exp = tensor(qeye(N), Hsys)
-    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
-
-    na = a.dag() * a
-    xa = a.dag() + a
-
-    # decoupled Hamiltonian
-    H0 = wa * a.dag() * a + Hsys_exp
-    # interaction
-    H1 = (g * (a.dag() + a) * Q_exp)
-    H = H0 + H1
-    L = 0
-    PsipreEta = 0
-    PsipreX = 0
-
-    all_energy, all_state = H.eigenstates(sparse=sparse)
-    Apre = spre((a + a.dag()))
-    Apost = spost(a + a.dag())
-    for j in range(Nmax):
-        for k in range(Nmax):
-            A = xa.matrix_element(all_state[j].dag(), all_state[k])
-            delE = (all_energy[j] - all_energy[k])
-            if abs(A) > 0.0:
-                if abs(delE) > 0.0:
-                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
-                         * (np.cosh((all_energy[j] - all_energy[k]) /
-                            (2 * w_th))
-                         / (np.sinh((all_energy[j] - all_energy[k]) /
-                            (2 * w_th)))) * A)
-                    eta = (0.5 * np.pi * gamma *
-                           (all_energy[j] - all_energy[k]) * A)
-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-                    PsipreEta = PsipreEta + (eta * all_state[j]
-                                             * all_state[k].dag())
-                else:
-                    X = 0.5 * np.pi * gamma * A * 2 * w_th
-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-
-    A = a + a.dag()
-    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
-         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
-         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
-         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
-
-    # Setup the operators and the Hamiltonian and the master equation
-    # and solve for time steps in tlist
-    rho0 = (tensor(thermal_dm(N, nb), psi0))
-    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
-
-    return output
+"""
+This module provides exact solvers for a system-bath setup using the
+reaction coordinate method.
+"""
+
+# Author: Neill Lambert, Anubhav Vardhan
+# Contact: nwlambert@gmail.com
+
+__all__ = ['rcsolve']
+
+import warnings
+import numpy as np
+import scipy.sparse as sp
+from numpy import matrix
+from numpy import linalg
+from .. import (
+    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
+    sigmaz, basis, qeye, mesolve
+)
+
+
+def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
+            options=None):
+    """
+    Function to solve for an open quantum system using the
+    reaction coordinate (RC) model.
+
+    Parameters
+    ----------
+    Hsys: Qobj
+        The system hamiltonian.
+    psi0: Qobj
+        Initial state of the system.
+    tlist: List.
+        Time over which system evolves.
+    e_ops: list of :class:`qutip.Qobj` / callback function single
+        Single operator or list of operators for which to evaluate
+        expectation values.
+    Q: Qobj
+        The coupling between system and bath.
+    wc: Float
+        Cutoff frequency.
+    alpha: Float
+        Coupling strength.
+    N: Integer
+        Number of cavity fock states.
+    w_th: Float
+        Temperature.
+    sparse: Boolean
+        Optional argument to call the sparse eigenstates solver if needed.
+    options : dict
+        Options for the solver.
+
+    Returns
+    -------
+    output: Result
+        System evolution.
+    """
+    if options is None:
+        options = {}
+
+    dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
+    deltaE = dot_energy[1] - dot_energy[0]
+    if (w_th < deltaE/2):
+        warnings.warn("Given w_th might not provide accurate results")
+    gamma = deltaE / (2 * np.pi * wc)
+    wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
+    g = np.sqrt(np.pi * wa * alpha / 2.0)  # reaction coordinate coupling
+    nb = (1 / (np.exp(wa/w_th) - 1))
+
+    # Reaction coordinate hamiltonian/operators
+
+    dimensions = Q.dims
+    a = tensor(destroy(N), qeye(dimensions[1]))
+    unit = tensor(qeye(N), qeye(dimensions[1]))
+    Nmax = N * dimensions[1][0]
+    Q_exp = tensor(qeye(N), Q)
+    Hsys_exp = tensor(qeye(N), Hsys)
+    e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
+
+    na = a.dag() * a
+    xa = a.dag() + a
+
+    # decoupled Hamiltonian
+    H0 = wa * a.dag() * a + Hsys_exp
+    # interaction
+    H1 = (g * (a.dag() + a) * Q_exp)
+    H = H0 + H1
+    L = 0
+    PsipreEta = 0
+    PsipreX = 0
+
+    all_energy, all_state = H.eigenstates(sparse=sparse)
+    Apre = spre((a + a.dag()))
+    Apost = spost(a + a.dag())
+    for j in range(Nmax):
+        for k in range(Nmax):
+            A = xa.matrix_element(all_state[j].dag(), all_state[k])
+            delE = (all_energy[j] - all_energy[k])
+            if abs(A) > 0.0:
+                if abs(delE) > 0.0:
+                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
+                         * (np.cosh((all_energy[j] - all_energy[k]) /
+                            (2 * w_th))
+                         / (np.sinh((all_energy[j] - all_energy[k]) /
+                            (2 * w_th)))) * A)
+                    eta = (0.5 * np.pi * gamma *
+                           (all_energy[j] - all_energy[k]) * A)
+                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
+                    PsipreEta = PsipreEta + (eta * all_state[j]
+                                             * all_state[k].dag())
+                else:
+                    X = 0.5 * np.pi * gamma * A * 2 * w_th
+                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
+
+    A = a + a.dag()
+    L = ((-spre(A * PsipreX)) + (sprepost(A, PsipreX))
+         + (sprepost(PsipreX, A)) + (-spost(PsipreX * A))
+         + (spre(A * PsipreEta)) + (sprepost(A, PsipreEta))
+         + (-sprepost(PsipreEta, A)) + (-spost(PsipreEta * A)))
+
+    # Setup the operators and the Hamiltonian and the master equation
+    # and solve for time steps in tlist
+    rho0 = (tensor(thermal_dm(N, nb), psi0))
+    output = mesolve(H, rho0, tlist, [L], e_ops_exp, options=options)
+
+    return output
diff --git a/qutip/solve/solver.py b/qutip/solve/solver.py
index e466beb9fb..08a53fb64e 100644
--- a/qutip/solve/solver.py
+++ b/qutip/solve/solver.py
@@ -1,922 +1,922 @@
-from __future__ import print_function
-
-__all__ = ['SolverOptions', 'ExpectOps']
-
-import os
-import sys
-import warnings
-import datetime
-import numpy as np
-from collections import OrderedDict
-from types import FunctionType, BuiltinFunctionType
-
-from .. import __version__, Qobj, QobjEvo
-from .optionsclass import optionsclass
-from ..core import data as _data
-
-solver_safe = {}
-
-
-class SolverSystem():
-    pass
-
-
-class ExpectOps:
-    """
-        Contain and compute expectation values
-    """
-    def __init__(self, e_ops=[], super_=False):
-        # take care of expectation values, if any
-        self.isfunc = False
-        self.e_ops_dict = False
-        self.raw_e_ops = e_ops
-        self.e_ops_qoevo = []
-        self.e_num = 0
-        self.e_ops_isherm = []
-
-        if isinstance(e_ops, (Qobj, QobjEvo)):
-            e_ops = [e_ops]
-        elif isinstance(e_ops, dict):
-            self.e_ops_dict = e_ops
-            e_ops = [e for e in e_ops.values()]
-
-        self.e_ops = e_ops
-        if isinstance(e_ops, list):
-            self.e_num = len(e_ops)
-            self.e_ops_isherm = [e.isherm for e in e_ops]
-            if not super_:
-                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
-                                            dtype=object)
-            else:
-                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
-                                            dtype=object)
-        elif callable(e_ops):
-            self.isfunc = True
-            self.e_num = 1
-
-    def init(self, tlist):
-        self.tlist = tlist
-        if self.isfunc:
-            self.raw_out = []
-        else:
-            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
-
-    def check_dims(self, dims):
-        if not self.isfunc:
-            for op in self.e_ops_qoevo:
-                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
-                    raise TypeError(f"e_ops dims ({op.dims}) are not "
-                                    f"compatible with the system's ({dims})")
-
-    def copy(self):
-        out = ExpectOps.__new__(ExpectOps)
-        out.isfunc = self.isfunc
-        out.e_ops_dict = self.e_ops_dict
-        out.raw_e_ops = self.raw_e_ops
-        out.e_ops = self.e_ops
-        out.e_num = self.e_num
-        out.e_ops_isherm = self.e_ops_isherm
-        out.e_ops_qoevo = self.e_ops_qoevo
-        return out
-
-    def step(self, iter_, state):
-        if self.isfunc:
-            self.raw_out.append(self.e_ops(t, state))
-        else:
-            state = _data.dense.fast_from_numpy(state)
-            t = self.tlist[iter_]
-            for ii in range(self.e_num):
-                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
-                    self.raw_out[ii, iter_] = \
-                        self.e_ops_qoevo[ii].expect_data(t, state)
-                elif callable(self.e_ops_qoevo[ii]):
-                    self.raw_out[ii, iter_] = \
-                        self.e_ops_qoevo[ii](t, state)
-
-    def finish(self):
-        if self.isfunc:
-            result = self.raw_out
-        else:
-            result = []
-            for ii in range(self.e_num):
-                if self.e_ops_isherm[ii]:
-                    result.append(np.real(self.raw_out[ii, :]))
-                else:
-                    result.append(self.raw_out[ii, :])
-            if self.e_ops_dict:
-                result = {e: result[n]
-                          for n, e in enumerate(self.e_ops_dict.keys())}
-        return result
-
-    def __eq__(self, other):
-        if isinstance(other, ExpectOps):
-            other = other.raw_e_ops
-        return self.raw_e_ops == other
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __bool__(self):
-        return bool(self.e_num)
-
-
-@optionsclass("solver")
-class SolverOptions:
-    """
-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-    constructor::
-
-        opts = SolverOptions(order=10, ...)
-
-    or by changing the class attributes after creation::
-
-        opts = SolverOptions()
-        opts.order = 10
-
-    Returns options class to be used as options in evolution solvers.
-
-    The default can be changed by::
-
-        qutip.settings.solver['order'] = 10
-
-    Supported options:
-
-        atol : float {1e-8}
-            Absolute tolerance.
-        rtol : float {1e-6}
-            Relative tolerance.
-        method : str {'adams','bdf'}
-            Integration method.
-        order : int {12}
-            Order of integrator (<=12 'adams', <=5 'bdf')
-        nsteps : int {2500}
-            Max. number of internal steps/call.
-        first_step : float {0}
-            Size of initial step (0 = automatic).
-        min_step : float {0}
-            Minimum step size (0 = automatic).
-        max_step : float {0}
-            Maximum step size (0 = automatic)
-        tidy : bool {True,False}
-            Tidyup Hamiltonian and initial state by removing small terms.
-        average_states : bool {False}
-            Average states values over trajectories in stochastic solvers.
-        average_expect : bool {True}
-            Average expectation values over trajectories for stochastic solvers.
-        ntraj : int {500}
-            Number of trajectories in stochastic solvers.
-        store_final_state : bool {False, True}
-            Whether or not to store the final state of the evolution in the
-            result class.
-        store_states : bool {False, True}
-            Whether or not to store the state vectors or density matrices in the
-            result class, even if expectation values operators are given. If no
-            expectation are provided, then states are stored by default and this
-            option has no effect.
-    """
-    options = {
-        # Absolute tolerance (default = 1e-8)
-        "atol": 1e-8,
-        # Relative tolerance (default = 1e-6)
-        "rtol": 1e-6,
-        # Integration method (default = 'adams', for stiff 'bdf')
-        "method": 'adams',
-        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
-        "order": 12,
-        # Max. number of internal steps/call
-        "nsteps": 1000,
-        # Size of initial step (0 = determined by solver)
-        "first_step": 0,
-        # Max step size (0 = determined by solver)
-        "max_step": 0,
-        # Minimal step size (0 = determined by solver)
-        "min_step": 0,
-        # Average expectation values over trajectories (default = True)
-        "average_expect": True,
-        # average expectation values
-        "average_states": False,
-        # tidyup Hamiltonian before calculation (default = True)
-        "tidy": True,
-        # Number of trajectories (default = 500)
-        "ntraj": 500,
-        "gui": False,
-        # store final state?
-        "store_final_state": False,
-        # store states even if expectation operators are given?
-        "store_states": False,
-        # average mcsolver density matricies assuming steady state evolution
-        "steady_state_average": False,
-        # Normalize output of solvers
-        # (turned off for batch unitary propagator mode)
-        "normalize_output": True
-    }
-
-
-@optionsclass("mcsolve", SolverOptions)
-class McOptions:
-    """
-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-    constructor::
-
-        opts = SolverOptions(norm_tol=1e-3, ...)
-
-    or by changing the class attributes after creation::
-
-        opts = SolverOptions()
-        opts.['norm_tol'] = 1e-3
-
-    Returns options class to be used as options in evolution solvers.
-
-    The default can be changed by::
-
-        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
-
-    Options
-    -------
-
-    norm_tol : float {1e-4}
-        Tolerance used when finding wavefunction norm in mcsolve.
-    norm_t_tol : float {1e-6}
-        Tolerance used when finding wavefunction time in mcsolve.
-    norm_steps : int {5}
-        Max. number of steps used to find wavefunction norm to within norm_tol
-        in mcsolve.
-    mc_corr_eps : float {1e-10}
-        Arbitrarily small value for eliminating any divide-by-zero errors in
-        correlation calculations when using mcsolve.
-    """
-    options = {
-        # Tolerance for wavefunction norm (mcsolve only)
-        "norm_tol": 1e-4,
-        # Tolerance for collapse time precision (mcsolve only)
-        "norm_t_tol": 1e-6,
-        # Max. number of steps taken to find wavefunction norm to within
-        # norm_tol (mcsolve only)
-        "norm_steps": 5,
-        # small value in mc solver for computing correlations
-        "mc_corr_eps": 1e-10,
-    }
-
-
-class Result():
-    """Class for storing simulation results from any of the dynamics solvers.
-
-    Attributes
-    ----------
-
-    solver : str
-        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
-    times : list/array
-        Times at which simulation data was collected.
-    expect : list/array
-        Expectation values (if requested) for simulation.
-    states : array
-        State of the simulation (density matrix or ket) evaluated at ``times``.
-    num_expect : int
-        Number of expectation value operators in simulation.
-    num_collapse : int
-        Number of collapse operators in simualation.
-    ntraj : int/list
-        Number of trajectories (for stochastic solvers). A list indicates
-        that averaging of expectation values was done over a subset of total
-        number of trajectories.
-    col_times : list
-        Times at which state collpase occurred. Only for Monte Carlo solver.
-    col_which : list
-        Which collapse operator was responsible for each collapse in
-        ``col_times``. Only for Monte Carlo solver.
-
-    """
-    def __init__(self):
-        self.solver = None
-        self.times = None
-        self.states = []
-        self.expect = []
-        self.num_expect = 0
-        self.num_collapse = 0
-        self.ntraj = None
-        self.seeds = None
-        self.col_times = None
-        self.col_which = None
-
-    def __str__(self):
-        s = "Result object "
-        if self.solver:
-            s += "with " + self.solver + " data.\n"
-        else:
-            s += "missing solver information.\n"
-        s += "-" * (len(s) - 1) + "\n"
-        if self.states is not None and len(self.states) > 0:
-            s += "states = True\n"
-        elif self.expect is not None and len(self.expect) > 0:
-            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
-        else:
-            s += "states = True, expect = True\n" + \
-                "num_expect = " + str(self.num_expect) + ", "
-        s += "num_collapse = " + str(self.num_collapse)
-        if self.solver == 'mcsolve':
-            s += ", ntraj = " + str(self.ntraj)
-        return s
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __getstate__(self):
-        # defines what happens when Qobj object gets pickled
-        self.__dict__.update({'qutip_version': __version__[:5]})
-        return self.__dict__
-
-    def __setstate__(self, state):
-        # defines what happens when loading a pickled Qobj
-        if 'qutip_version' in state.keys():
-            del state['qutip_version']
-        (self.__dict__).update(state)
-
-
-# %%%%%%%%%%% remove ?
-class SolverConfiguration():
-    def __init__(self):
-
-        self.cgen_num = 0
-
-        self.reset()
-
-    def reset(self):
-        # General stuff
-        self.tlist = None       # evaluations times
-        self.ntraj = None       # number / list of trajectories
-        self.options = None     # options for solvers
-        self.norm_tol = None    # tolerance for wavefunction norm
-        self.norm_steps = None  # max. number of steps to take in finding
-        # Initial state stuff
-        self.psi0 = None        # initial state
-        self.psi0_dims = None   # initial state dims
-        self.psi0_shape = None  # initial state shape
-
-        # flags for setting time-dependence, collapse ops, and number of times
-        # codegen has been run
-        self.cflag = 0     # Flag signaling collapse operators
-        self.tflag = 0     # Flag signaling time-dependent problem
-
-        self.soft_reset()
-
-    def soft_reset(self):
-        # Hamiltonian stuff
-        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
-        self.h_tdterms = []  # List of td strs and funcs
-        self.h_data = None   # List of sparse matrix data
-        self.h_ind = None    # List of sparse matrix indices
-        self.h_ptr = None    # List of sparse matrix ptrs
-
-        # Expectation operator stuff
-        self.e_num = 0        # number of expect ops
-        self.e_ops_data = []  # expect op data
-        self.e_ops_ind = []   # expect op indices
-        self.e_ops_ptr = []   # expect op indptrs
-        self.e_ops_isherm = []  # expect op isherm
-
-        # Collapse operator stuff
-        self.c_num = 0          # number of collapse ops
-        self.c_const_inds = []  # indicies of constant collapse operators
-        self.c_td_inds = []     # indicies of time-dependent collapse operators
-        self.c_ops_data = []    # collapse op data
-        self.c_ops_ind = []     # collapse op indices
-        self.c_ops_ptr = []     # collapse op indptrs
-        self.c_args = []        # store args for time-dependent collapse func.
-
-        # Norm collapse operator stuff
-        self.n_ops_data = []  # norm collapse op data
-        self.n_ops_ind = []   # norm collapse op indices
-        self.n_ops_ptr = []   # norm collapse op indptrs
-
-        # holds executable strings for time-dependent collapse evaluation
-        self.col_expect_code = None
-        self.col_spmv_code = None
-
-        # hold stuff for function list based time dependence
-        self.h_td_inds = []
-        self.h_td_data = []
-        self.h_td_ind = []
-        self.h_td_ptr = []
-        self.h_funcs = None
-        self.h_func_args = None
-        self.c_funcs = None
-        self.c_func_args = None
-
-        # time-dependent (TD) function stuff
-        self.tdfunc = None     # Placeholder for TD RHS function.
-        self.tdname = None     # Name of td .pyx file
-        self.colspmv = None    # Placeholder for TD col-spmv function.
-        self.colexpect = None  # Placeholder for TD col_expect function.
-        self.string = None     # Holds string of variables passed to td solver
-
-
-def _format_time(t, tt=None, ttt=None):
-    time_str = str(datetime.timedelta(seconds=t))
-    if tt is not None and ttt is not None:
-        sect_percent = 100*t/tt
-        solve_percent = 100*t/ttt
-        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
-                                            sect_percent, solve_percent)
-    elif tt is not None:
-        sect_percent = 100*t/tt
-        time_str += " ({:03.2f}% section)".format(sect_percent)
-
-    elif ttt is not None:
-        solve_percent = 100*t/ttt
-        time_str += " ({:03.2f}% total)".format(solve_percent)
-
-    return time_str
-
-
-class Stats:
-    """
-    Statistical information on the solver performance
-    Statistics can be grouped into sections.
-    If no section names are given in the the contructor, then all statistics
-    will be added to one section 'main'
-
-    Parameters
-    ----------
-    section_names : list
-        list of keys that will be used as keys for the sections
-        These keys will also be used as names for the sections
-        The text in the output can be overidden by setting the header property
-        of the section
-        If no names are given then one section called 'main' is created
-
-    Attributes
-    ----------
-    sections : OrderedDict of _StatsSection
-        These are the sections that are created automatically on instantiation
-        or added using add_section
-
-    header : string
-        Some text that will be used as the heading in the report
-        By default there is None
-
-    total_time : float
-        Time in seconds for the solver to complete processing
-        Can be None, meaning that total timing percentages will be reported
-    """
-
-    def __init__(self, section_names=None):
-        self._def_section_name = 'main'
-        self.sections = OrderedDict()
-        self.total_time = None
-        self.header = None
-        if isinstance(section_names, list):
-            c = 0
-            for name in section_names:
-                self.sections[name] = _StatsSection(name, self)
-                if c == 0:
-                    self._def_section_name = name
-                c += 1
-
-        else:
-            self.sections[self._def_section_name] = \
-                        _StatsSection(self._def_section_name)
-
-    def _get_section(self, section):
-        if section is None:
-            return self.sections[self._def_section_name]
-        elif isinstance(section, _StatsSection):
-            return section
-        else:
-            sect = self.sections.get(section, None)
-            if sect is None:
-                raise ValueError("Unknown section {}".format(section))
-            else:
-                return sect
-
-    def add_section(self, name):
-        """
-        Add another section with the given name
-
-        Parameters
-        ----------
-        name : string
-            will be used as key for sections dict
-            will also be the header for the section
-
-        Returns
-        -------
-        section : :class:`_StatsSection`
-            The new section
-        """
-        sect = _StatsSection(name, self)
-        self.sections[name] = sect
-        return sect
-
-    def add_count(self, key, value, section=None):
-        """
-        Add value to count. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be an integer
-
-        Parameters
-        ----------
-        key : string
-            key for the section.counts dictionary
-            reusing a key will result in numerical addition of value
-
-        value : int
-            Initial value of the count, or added to an existing count
-
-        section : string or :class:`_StatsSection`
-            Section which to add the count to.
-            If None given, the default (first) section will be used
-        """
-
-        self._get_section(section).add_count(key, value)
-
-    def add_timing(self, key, value, section=None):
-        """
-        Add value to timing. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be a float, and given in seconds.
-
-        Parameters
-        ----------
-        key : string
-            key for the section.timings dictionary
-            reusing a key will result in numerical addition of value
-
-        value : int
-            Initial value of the timing, or added to an existing timing
-
-        section: string or `class` : _StatsSection
-            Section which to add the timing to.
-            If None given, the default (first) section will be used
-        """
-        self._get_section(section).add_timing(key, value)
-
-    def add_message(self, key, value, section=None, sep=";"):
-        """
-        Add value to message. If key does not already exist in section then
-        it is created with this value.
-        If key already exists the value is added to the message
-        The value will be converted to a string
-
-        Parameters
-        ----------
-        key : string
-            key for the section.messages dictionary
-            reusing a key will result in concatenation of value
-
-        value : int
-            Initial value of the message, or added to an existing message
-
-        sep : string
-            Message will be prefixed with this string when concatenating
-
-        section: string or `class` : _StatsSection
-            Section which to add the message to.
-            If None given, the default (first) section will be used
-        """
-        self._get_section(section).add_message(key, value, sep=sep)
-
-    def set_total_time(self, value, section=None):
-        """
-        Sets the total time for the complete solve or for a specific section
-        value is expected to be a float, and given in seconds
-
-        Parameters
-        ----------
-        value : float
-            Time in seconds to complete the solver section
-
-        section : string or `class` : _StatsSection
-            Section which to set the total_time for
-            If None given, the total_time for complete solve is set
-        """
-        if not isinstance(value, float):
-            try:
-                value = float(value)
-            except:
-                raise TypeError("value is expected to be a float")
-
-        if section is None:
-            self.total_time = value
-        else:
-            sect = self._get_section(section)
-            sect.total_time = value
-
-    def report(self, output=sys.stdout):
-        """
-        Report the counts, timings and messages from the sections.
-        Sections are reported in the order that the names were supplied
-        in the constructor.
-        The counts, timings and messages are reported in the order that they
-        are added to the sections
-        The output can be written to anything that supports a write method,
-        e.g. a file or the console (default)
-        The output is intended to in markdown format
-
-        Parameters
-        ----------
-        output : stream
-            file or console stream - anything that support write - where
-            the output will be written
-        """
-
-        if not hasattr(output, 'write'):
-            raise TypeError("output must have a write method")
-
-        if self.header:
-            output.write("{}\n{}\n".format(self.header,
-                                     ("="*len(self.header))))
-        for name, sect in self.sections.items():
-            sect.report(output)
-
-        if self.total_time is not None:
-            output.write("\nSummary\n-------\n")
-            output.write("{}\t solver total time\n".format(
-                                            _format_time(self.total_time)))
-
-    def clear(self):
-        """
-        Clear counts, timings and messages from all sections
-        """
-        for sect in self.sections.values():
-            sect.clear()
-        self.total_time = None
-
-
-class _StatsSection(object):
-    """
-    Not intended to be directly instantiated
-    This is the type for the SolverStats.sections values
-
-    The method parameter descriptions are the same as for those the parent
-    with the same method name
-
-    Parameters
-    ----------
-    name : string
-        key for the parent sections dictionary
-        will also be used as the header
-
-    parent : `class` :  SolverStats
-        The container for all the sections
-
-    Attributes
-    ----------
-    name : string
-        key for the parent sections dictionary
-        will also be used as the header
-
-    parent : `class` :  SolverStats
-        The container for all the sections
-
-    header : string
-        Used as heading for section in report
-
-    counts : OrderedDict
-        The integer type statistics for the stats section
-
-    timings : OrderedDict
-        The timing type statistics for the stats section
-        Expected to contain float values representing values in seconds
-
-    messages : OrderedDict
-        Text type output to be reported
-
-    total_time : float
-        Total time for processing in the section
-        Can be None, meaning that section timing percentages will be reported
-    """
-    def __init__(self, name, parent):
-        self.parent = parent
-        self.header = str(name)
-        self.name = name
-        self.counts = OrderedDict()
-        self.timings = OrderedDict()
-        self.messages = OrderedDict()
-        self.total_time = None
-
-    def add_count(self, key, value):
-        """
-        Add value to count. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the given value
-        value is expected to be an integer
-        """
-        if not isinstance(value, int):
-            try:
-                value = int(value)
-            except:
-                raise TypeError("value is expected to be an integer")
-
-        if key in self.counts:
-            self.counts[key] += value
-        else:
-            self.counts[key] = value
-
-    def add_timing(self, key, value):
-        """
-        Add value to timing. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be a float, and given in seconds.
-        """
-        if not isinstance(value, float):
-            try:
-                value = float(value)
-            except:
-                raise TypeError("value is expected to be a float")
-
-        if key in self.timings:
-            self.timings[key] += value
-        else:
-            self.timings[key] = value
-
-    def add_message(self, key, value, sep=";"):
-        """
-        Add value to message. If key does not already exist in section then
-        it is created with this value.
-        If key already exists the value is added to the message
-        The value will be converted to a string
-        """
-        value = str(value)
-
-        if key in self.messages:
-            if sep is not None:
-                try:
-                    value = sep + value
-                except:
-                    TypeError("It is not possible to concatenate the value "
-                              "with the given seperator")
-            self.messages[key] += value
-        else:
-            self.messages[key] = value
-
-    def report(self, output=sys.stdout):
-        """
-        Report the counts, timings and messages for this section.
-        Note the percentage of the section and solver total times will be
-        given if the parent and or section total_time is set
-        """
-        if self.header:
-            output.write("\n{}\n{}\n".format(self.header,
-                                     ("-"*len(self.header))))
-
-        # TODO: Make the timings and counts ouput in a table format
-        #       Generally make more pretty
-
-        # Report timings
-        try:
-            ttt = self.parent.total_time
-        except:
-            ttt = None
-
-        tt = self.total_time
-
-        output.write("### Timings:\n")
-        for key, value in self.timings.items():
-            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
-            output.write(l)
-        if tt is not None:
-            output.write(" - {}\t{} total time\n".format(_format_time(tt),
-                                                     self.name))
-
-        # Report counts
-        output.write("### Counts:\n")
-        for key, value in self.counts.items():
-            l = " - {}\t{}\n".format(value, key)
-            output.write(l)
-
-        # Report messages
-        output.write("### Messages:\n")
-        for key, value in self.messages.items():
-            l = " - {}:\t{}\n".format(key, value)
-            output.write(l)
-
-
-    def clear(self):
-        """
-        Clear counts, timings and messages from this section
-        """
-        self.counts.clear()
-        self.timings.clear()
-        self.messages.clear()
-        self.total_time = None
-
-
-def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
-    # Input is std Qobj (Hamiltonian or Liouvillian)
-    if isinstance(H, Qobj):
-        Hdims = H.dims
-        Htype = H.type
-        _structure_check(Hdims, Htype, state)
-    # Input H is function
-    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
-        Hdims = H(0,args).dims
-        Htype = H(0,args).type
-        _structure_check(Hdims, Htype, state)
-    # Input is td-list
-    elif isinstance(H, list):
-        if isinstance(H[0], Qobj):
-            Hdims = H[0].dims
-            Htype = H[0].type
-        elif isinstance(H[0], list):
-            Hdims = H[0][0].dims
-            Htype = H[0][0].type
-        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
-            Hdims = H[0](0,args).dims
-            Htype = H[0](0,args).type
-        else:
-            raise Exception('Invalid td-list element.')
-        # Check all operators in list
-        for ii in range(len(H)):
-            if isinstance(H[ii], Qobj):
-                _temp_dims = H[ii].dims
-                _temp_type = H[ii].type
-            elif isinstance(H[ii], list):
-                _temp_dims = H[ii][0].dims
-                _temp_type = H[ii][0].type
-            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
-                _temp_dims = H[ii](0,args).dims
-                _temp_type = H[ii](0,args).type
-            else:
-                raise Exception('Invalid td-list element.')
-            _structure_check(_temp_dims,_temp_type,state)
-
-    else:
-        raise Exception('Invalid time-dependent format.')
-
-
-    for ii in range(len(c_ops)):
-        do_tests = True
-        if isinstance(c_ops[ii], Qobj):
-            _temp_state = c_ops[ii]
-        elif isinstance(c_ops[ii], list):
-            if isinstance(c_ops[ii][0], Qobj):
-                _temp_state = c_ops[ii][0]
-            elif isinstance(c_ops[ii][0], tuple):
-                do_tests = False
-                for kk in range(len(c_ops[ii][0])):
-                    _temp_state = c_ops[ii][0][kk]
-                    _structure_check(Hdims, Htype, _temp_state)
-        else:
-            raise Exception('Invalid td-list element.')
-        if do_tests:
-            _structure_check(Hdims, Htype, _temp_state)
-
-    if isinstance(e_ops, list):
-        for ii in range(len(e_ops)):
-            if isinstance(e_ops[ii], Qobj):
-                _temp_state = e_ops[ii]
-            elif isinstance(e_ops[ii], list):
-                _temp_state = e_ops[ii][0]
-            else:
-                raise Exception('Invalid td-list element.')
-            _structure_check(Hdims,Htype,_temp_state)
-    elif isinstance(e_ops, FunctionType):
-        pass
-    else:
-        raise Exception('Invalid e_ops specification.')
-
-
-def _structure_check(Hdims, Htype, state):
-    if state is not None:
-        # Input state is a ket vector
-        if state.type == 'ket':
-            # Input is Hamiltonian
-            if Htype == 'oper':
-                if Hdims[1] != state.dims[0]:
-                    raise Exception('Input operator and ket do not '
-                                    'share same structure.')
-            # Input is super and state is ket
-            elif Htype == 'super':
-                if Hdims[1][1] != state.dims[0]:
-                    raise Exception('Input operator and ket do not '
-                                    'share same structure.')
-            else:
-                raise Exception('Invalid input operator.')
-        # Input state is a density matrix
-        elif state.type == 'oper':
-            # Input is Hamiltonian and state is density matrix
-            if Htype == 'oper':
-                if Hdims[1] != state.dims[0]:
-                    raise Exception('Input operators do not '
-                                    'share same structure.')
-            # Input is super op. and state is density matrix
-            elif Htype == 'super':
-                if Hdims[1] != state.dims:
-                    raise Exception('Input operators do not '
-                                    'share same structure.')
-
-
-#
-# create a global instance of the SolverConfiguration class
-#
-config = SolverConfiguration()
-
-# for backwards compatibility
-# Odeoptions = Options
-# Odedata = Result
+from __future__ import print_function
+
+__all__ = ['SolverOptions', 'ExpectOps']
+
+import os
+import sys
+import warnings
+import datetime
+import numpy as np
+from collections import OrderedDict
+from types import FunctionType, BuiltinFunctionType
+
+from .. import __version__, Qobj, QobjEvo
+from .optionsclass import optionsclass
+from ..core import data as _data
+
+solver_safe = {}
+
+
+class SolverSystem():
+    pass
+
+
+class ExpectOps:
+    """
+        Contain and compute expectation values
+    """
+    def __init__(self, e_ops=[], super_=False):
+        # take care of expectation values, if any
+        self.isfunc = False
+        self.e_ops_dict = False
+        self.raw_e_ops = e_ops
+        self.e_ops_qoevo = []
+        self.e_num = 0
+        self.e_ops_isherm = []
+
+        if isinstance(e_ops, (Qobj, QobjEvo)):
+            e_ops = [e_ops]
+        elif isinstance(e_ops, dict):
+            self.e_ops_dict = e_ops
+            e_ops = [e for e in e_ops.values()]
+
+        self.e_ops = e_ops
+        if isinstance(e_ops, list):
+            self.e_num = len(e_ops)
+            self.e_ops_isherm = [e.isherm for e in e_ops]
+            if not super_:
+                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
+                                            dtype=object)
+            else:
+                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
+                                            dtype=object)
+        elif callable(e_ops):
+            self.isfunc = True
+            self.e_num = 1
+
+    def init(self, tlist):
+        self.tlist = tlist
+        if self.isfunc:
+            self.raw_out = []
+        else:
+            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
+
+    def check_dims(self, dims):
+        if not self.isfunc:
+            for op in self.e_ops_qoevo:
+                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
+                    raise TypeError(f"e_ops dims ({op.dims}) are not "
+                                    f"compatible with the system's ({dims})")
+
+    def copy(self):
+        out = ExpectOps.__new__(ExpectOps)
+        out.isfunc = self.isfunc
+        out.e_ops_dict = self.e_ops_dict
+        out.raw_e_ops = self.raw_e_ops
+        out.e_ops = self.e_ops
+        out.e_num = self.e_num
+        out.e_ops_isherm = self.e_ops_isherm
+        out.e_ops_qoevo = self.e_ops_qoevo
+        return out
+
+    def step(self, iter_, state):
+        if self.isfunc:
+            self.raw_out.append(self.e_ops(t, state))
+        else:
+            state = _data.dense.fast_from_numpy(state)
+            t = self.tlist[iter_]
+            for ii in range(self.e_num):
+                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
+                    self.raw_out[ii, iter_] = \
+                        self.e_ops_qoevo[ii].expect_data(t, state)
+                elif callable(self.e_ops_qoevo[ii]):
+                    self.raw_out[ii, iter_] = \
+                        self.e_ops_qoevo[ii](t, state)
+
+    def finish(self):
+        if self.isfunc:
+            result = self.raw_out
+        else:
+            result = []
+            for ii in range(self.e_num):
+                if self.e_ops_isherm[ii]:
+                    result.append(np.real(self.raw_out[ii, :]))
+                else:
+                    result.append(self.raw_out[ii, :])
+            if self.e_ops_dict:
+                result = {e: result[n]
+                          for n, e in enumerate(self.e_ops_dict.keys())}
+        return result
+
+    def __eq__(self, other):
+        if isinstance(other, ExpectOps):
+            other = other.raw_e_ops
+        return self.raw_e_ops == other
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __bool__(self):
+        return bool(self.e_num)
+
+
+@optionsclass("solver")
+class SolverOptions:
+    """
+    Class of options for evolution solvers such as :func:`qutip.mesolve` and
+    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
+    constructor::
+
+        opts = SolverOptions(order=10, ...)
+
+    or by changing the class attributes after creation::
+
+        opts = SolverOptions()
+        opts.order = 10
+
+    Returns options class to be used as options in evolution solvers.
+
+    The default can be changed by::
+
+        qutip.settings.solver['order'] = 10
+
+    Supported options:
+
+        atol : float {1e-8}
+            Absolute tolerance.
+        rtol : float {1e-6}
+            Relative tolerance.
+        method : str {'adams','bdf'}
+            Integration method.
+        order : int {12}
+            Order of integrator (<=12 'adams', <=5 'bdf')
+        nsteps : int {2500}
+            Max. number of internal steps/call.
+        first_step : float {0}
+            Size of initial step (0 = automatic).
+        min_step : float {0}
+            Minimum step size (0 = automatic).
+        max_step : float {0}
+            Maximum step size (0 = automatic)
+        tidy : bool {True,False}
+            Tidyup Hamiltonian and initial state by removing small terms.
+        average_states : bool {False}
+            Average states values over trajectories in stochastic solvers.
+        average_expect : bool {True}
+            Average expectation values over trajectories for stochastic solvers.
+        ntraj : int {500}
+            Number of trajectories in stochastic solvers.
+        store_final_state : bool {False, True}
+            Whether or not to store the final state of the evolution in the
+            result class.
+        store_states : bool {False, True}
+            Whether or not to store the state vectors or density matrices in the
+            result class, even if expectation values operators are given. If no
+            expectation are provided, then states are stored by default and this
+            option has no effect.
+    """
+    options = {
+        # Absolute tolerance (default = 1e-8)
+        "atol": 1e-8,
+        # Relative tolerance (default = 1e-6)
+        "rtol": 1e-6,
+        # Integration method (default = 'adams', for stiff 'bdf')
+        "method": 'adams',
+        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
+        "order": 12,
+        # Max. number of internal steps/call
+        "nsteps": 1000,
+        # Size of initial step (0 = determined by solver)
+        "first_step": 0,
+        # Max step size (0 = determined by solver)
+        "max_step": 0,
+        # Minimal step size (0 = determined by solver)
+        "min_step": 0,
+        # Average expectation values over trajectories (default = True)
+        "average_expect": True,
+        # average expectation values
+        "average_states": False,
+        # tidyup Hamiltonian before calculation (default = True)
+        "tidy": True,
+        # Number of trajectories (default = 500)
+        "ntraj": 500,
+        "gui": False,
+        # store final state?
+        "store_final_state": False,
+        # store states even if expectation operators are given?
+        "store_states": False,
+        # average mcsolver density matricies assuming steady state evolution
+        "steady_state_average": False,
+        # Normalize output of solvers
+        # (turned off for batch unitary propagator mode)
+        "normalize_output": True
+    }
+
+
+@optionsclass("mcsolve", SolverOptions)
+class McOptions:
+    """
+    Class of options for evolution solvers such as :func:`qutip.mesolve` and
+    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
+    constructor::
+
+        opts = SolverOptions(norm_tol=1e-3, ...)
+
+    or by changing the class attributes after creation::
+
+        opts = SolverOptions()
+        opts.['norm_tol'] = 1e-3
+
+    Returns options class to be used as options in evolution solvers.
+
+    The default can be changed by::
+
+        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
+
+    Options
+    -------
+
+    norm_tol : float {1e-4}
+        Tolerance used when finding wavefunction norm in mcsolve.
+    norm_t_tol : float {1e-6}
+        Tolerance used when finding wavefunction time in mcsolve.
+    norm_steps : int {5}
+        Max. number of steps used to find wavefunction norm to within norm_tol
+        in mcsolve.
+    mc_corr_eps : float {1e-10}
+        Arbitrarily small value for eliminating any divide-by-zero errors in
+        correlation calculations when using mcsolve.
+    """
+    options = {
+        # Tolerance for wavefunction norm (mcsolve only)
+        "norm_tol": 1e-4,
+        # Tolerance for collapse time precision (mcsolve only)
+        "norm_t_tol": 1e-6,
+        # Max. number of steps taken to find wavefunction norm to within
+        # norm_tol (mcsolve only)
+        "norm_steps": 5,
+        # small value in mc solver for computing correlations
+        "mc_corr_eps": 1e-10,
+    }
+
+
+class Result():
+    """Class for storing simulation results from any of the dynamics solvers.
+
+    Attributes
+    ----------
+
+    solver : str
+        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
+    times : list/array
+        Times at which simulation data was collected.
+    expect : list/array
+        Expectation values (if requested) for simulation.
+    states : array
+        State of the simulation (density matrix or ket) evaluated at ``times``.
+    num_expect : int
+        Number of expectation value operators in simulation.
+    num_collapse : int
+        Number of collapse operators in simualation.
+    ntraj : int/list
+        Number of trajectories (for stochastic solvers). A list indicates
+        that averaging of expectation values was done over a subset of total
+        number of trajectories.
+    col_times : list
+        Times at which state collpase occurred. Only for Monte Carlo solver.
+    col_which : list
+        Which collapse operator was responsible for each collapse in
+        ``col_times``. Only for Monte Carlo solver.
+
+    """
+    def __init__(self):
+        self.solver = None
+        self.times = None
+        self.states = []
+        self.expect = []
+        self.num_expect = 0
+        self.num_collapse = 0
+        self.ntraj = None
+        self.seeds = None
+        self.col_times = None
+        self.col_which = None
+
+    def __str__(self):
+        s = "Result object "
+        if self.solver:
+            s += "with " + self.solver + " data.\n"
+        else:
+            s += "missing solver information.\n"
+        s += "-" * (len(s) - 1) + "\n"
+        if self.states is not None and len(self.states) > 0:
+            s += "states = True\n"
+        elif self.expect is not None and len(self.expect) > 0:
+            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
+        else:
+            s += "states = True, expect = True\n" + \
+                "num_expect = " + str(self.num_expect) + ", "
+        s += "num_collapse = " + str(self.num_collapse)
+        if self.solver == 'mcsolve':
+            s += ", ntraj = " + str(self.ntraj)
+        return s
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __getstate__(self):
+        # defines what happens when Qobj object gets pickled
+        self.__dict__.update({'qutip_version': __version__[:5]})
+        return self.__dict__
+
+    def __setstate__(self, state):
+        # defines what happens when loading a pickled Qobj
+        if 'qutip_version' in state.keys():
+            del state['qutip_version']
+        (self.__dict__).update(state)
+
+
+# %%%%%%%%%%% remove ?
+class SolverConfiguration():
+    def __init__(self):
+
+        self.cgen_num = 0
+
+        self.reset()
+
+    def reset(self):
+        # General stuff
+        self.tlist = None       # evaluations times
+        self.ntraj = None       # number / list of trajectories
+        self.options = None     # options for solvers
+        self.norm_tol = None    # tolerance for wavefunction norm
+        self.norm_steps = None  # max. number of steps to take in finding
+        # Initial state stuff
+        self.psi0 = None        # initial state
+        self.psi0_dims = None   # initial state dims
+        self.psi0_shape = None  # initial state shape
+
+        # flags for setting time-dependence, collapse ops, and number of times
+        # codegen has been run
+        self.cflag = 0     # Flag signaling collapse operators
+        self.tflag = 0     # Flag signaling time-dependent problem
+
+        self.soft_reset()
+
+    def soft_reset(self):
+        # Hamiltonian stuff
+        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
+        self.h_tdterms = []  # List of td strs and funcs
+        self.h_data = None   # List of sparse matrix data
+        self.h_ind = None    # List of sparse matrix indices
+        self.h_ptr = None    # List of sparse matrix ptrs
+
+        # Expectation operator stuff
+        self.e_num = 0        # number of expect ops
+        self.e_ops_data = []  # expect op data
+        self.e_ops_ind = []   # expect op indices
+        self.e_ops_ptr = []   # expect op indptrs
+        self.e_ops_isherm = []  # expect op isherm
+
+        # Collapse operator stuff
+        self.c_num = 0          # number of collapse ops
+        self.c_const_inds = []  # indicies of constant collapse operators
+        self.c_td_inds = []     # indicies of time-dependent collapse operators
+        self.c_ops_data = []    # collapse op data
+        self.c_ops_ind = []     # collapse op indices
+        self.c_ops_ptr = []     # collapse op indptrs
+        self.c_args = []        # store args for time-dependent collapse func.
+
+        # Norm collapse operator stuff
+        self.n_ops_data = []  # norm collapse op data
+        self.n_ops_ind = []   # norm collapse op indices
+        self.n_ops_ptr = []   # norm collapse op indptrs
+
+        # holds executable strings for time-dependent collapse evaluation
+        self.col_expect_code = None
+        self.col_spmv_code = None
+
+        # hold stuff for function list based time dependence
+        self.h_td_inds = []
+        self.h_td_data = []
+        self.h_td_ind = []
+        self.h_td_ptr = []
+        self.h_funcs = None
+        self.h_func_args = None
+        self.c_funcs = None
+        self.c_func_args = None
+
+        # time-dependent (TD) function stuff
+        self.tdfunc = None     # Placeholder for TD RHS function.
+        self.tdname = None     # Name of td .pyx file
+        self.colspmv = None    # Placeholder for TD col-spmv function.
+        self.colexpect = None  # Placeholder for TD col_expect function.
+        self.string = None     # Holds string of variables passed to td solver
+
+
+def _format_time(t, tt=None, ttt=None):
+    time_str = str(datetime.timedelta(seconds=t))
+    if tt is not None and ttt is not None:
+        sect_percent = 100*t/tt
+        solve_percent = 100*t/ttt
+        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
+                                            sect_percent, solve_percent)
+    elif tt is not None:
+        sect_percent = 100*t/tt
+        time_str += " ({:03.2f}% section)".format(sect_percent)
+
+    elif ttt is not None:
+        solve_percent = 100*t/ttt
+        time_str += " ({:03.2f}% total)".format(solve_percent)
+
+    return time_str
+
+
+class Stats:
+    """
+    Statistical information on the solver performance
+    Statistics can be grouped into sections.
+    If no section names are given in the the contructor, then all statistics
+    will be added to one section 'main'
+
+    Parameters
+    ----------
+    section_names : list
+        list of keys that will be used as keys for the sections
+        These keys will also be used as names for the sections
+        The text in the output can be overidden by setting the header property
+        of the section
+        If no names are given then one section called 'main' is created
+
+    Attributes
+    ----------
+    sections : OrderedDict of _StatsSection
+        These are the sections that are created automatically on instantiation
+        or added using add_section
+
+    header : string
+        Some text that will be used as the heading in the report
+        By default there is None
+
+    total_time : float
+        Time in seconds for the solver to complete processing
+        Can be None, meaning that total timing percentages will be reported
+    """
+
+    def __init__(self, section_names=None):
+        self._def_section_name = 'main'
+        self.sections = OrderedDict()
+        self.total_time = None
+        self.header = None
+        if isinstance(section_names, list):
+            c = 0
+            for name in section_names:
+                self.sections[name] = _StatsSection(name, self)
+                if c == 0:
+                    self._def_section_name = name
+                c += 1
+
+        else:
+            self.sections[self._def_section_name] = \
+                        _StatsSection(self._def_section_name)
+
+    def _get_section(self, section):
+        if section is None:
+            return self.sections[self._def_section_name]
+        elif isinstance(section, _StatsSection):
+            return section
+        else:
+            sect = self.sections.get(section, None)
+            if sect is None:
+                raise ValueError("Unknown section {}".format(section))
+            else:
+                return sect
+
+    def add_section(self, name):
+        """
+        Add another section with the given name
+
+        Parameters
+        ----------
+        name : string
+            will be used as key for sections dict
+            will also be the header for the section
+
+        Returns
+        -------
+        section : :class:`_StatsSection`
+            The new section
+        """
+        sect = _StatsSection(name, self)
+        self.sections[name] = sect
+        return sect
+
+    def add_count(self, key, value, section=None):
+        """
+        Add value to count. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the give value
+        value is expected to be an integer
+
+        Parameters
+        ----------
+        key : string
+            key for the section.counts dictionary
+            reusing a key will result in numerical addition of value
+
+        value : int
+            Initial value of the count, or added to an existing count
+
+        section : string or :class:`_StatsSection`
+            Section which to add the count to.
+            If None given, the default (first) section will be used
+        """
+
+        self._get_section(section).add_count(key, value)
+
+    def add_timing(self, key, value, section=None):
+        """
+        Add value to timing. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the give value
+        value is expected to be a float, and given in seconds.
+
+        Parameters
+        ----------
+        key : string
+            key for the section.timings dictionary
+            reusing a key will result in numerical addition of value
+
+        value : int
+            Initial value of the timing, or added to an existing timing
+
+        section: string or `class` : _StatsSection
+            Section which to add the timing to.
+            If None given, the default (first) section will be used
+        """
+        self._get_section(section).add_timing(key, value)
+
+    def add_message(self, key, value, section=None, sep=";"):
+        """
+        Add value to message. If key does not already exist in section then
+        it is created with this value.
+        If key already exists the value is added to the message
+        The value will be converted to a string
+
+        Parameters
+        ----------
+        key : string
+            key for the section.messages dictionary
+            reusing a key will result in concatenation of value
+
+        value : int
+            Initial value of the message, or added to an existing message
+
+        sep : string
+            Message will be prefixed with this string when concatenating
+
+        section: string or `class` : _StatsSection
+            Section which to add the message to.
+            If None given, the default (first) section will be used
+        """
+        self._get_section(section).add_message(key, value, sep=sep)
+
+    def set_total_time(self, value, section=None):
+        """
+        Sets the total time for the complete solve or for a specific section
+        value is expected to be a float, and given in seconds
+
+        Parameters
+        ----------
+        value : float
+            Time in seconds to complete the solver section
+
+        section : string or `class` : _StatsSection
+            Section which to set the total_time for
+            If None given, the total_time for complete solve is set
+        """
+        if not isinstance(value, float):
+            try:
+                value = float(value)
+            except:
+                raise TypeError("value is expected to be a float")
+
+        if section is None:
+            self.total_time = value
+        else:
+            sect = self._get_section(section)
+            sect.total_time = value
+
+    def report(self, output=sys.stdout):
+        """
+        Report the counts, timings and messages from the sections.
+        Sections are reported in the order that the names were supplied
+        in the constructor.
+        The counts, timings and messages are reported in the order that they
+        are added to the sections
+        The output can be written to anything that supports a write method,
+        e.g. a file or the console (default)
+        The output is intended to in markdown format
+
+        Parameters
+        ----------
+        output : stream
+            file or console stream - anything that support write - where
+            the output will be written
+        """
+
+        if not hasattr(output, 'write'):
+            raise TypeError("output must have a write method")
+
+        if self.header:
+            output.write("{}\n{}\n".format(self.header,
+                                     ("="*len(self.header))))
+        for name, sect in self.sections.items():
+            sect.report(output)
+
+        if self.total_time is not None:
+            output.write("\nSummary\n-------\n")
+            output.write("{}\t solver total time\n".format(
+                                            _format_time(self.total_time)))
+
+    def clear(self):
+        """
+        Clear counts, timings and messages from all sections
+        """
+        for sect in self.sections.values():
+            sect.clear()
+        self.total_time = None
+
+
+class _StatsSection(object):
+    """
+    Not intended to be directly instantiated
+    This is the type for the SolverStats.sections values
+
+    The method parameter descriptions are the same as for those the parent
+    with the same method name
+
+    Parameters
+    ----------
+    name : string
+        key for the parent sections dictionary
+        will also be used as the header
+
+    parent : `class` :  SolverStats
+        The container for all the sections
+
+    Attributes
+    ----------
+    name : string
+        key for the parent sections dictionary
+        will also be used as the header
+
+    parent : `class` :  SolverStats
+        The container for all the sections
+
+    header : string
+        Used as heading for section in report
+
+    counts : OrderedDict
+        The integer type statistics for the stats section
+
+    timings : OrderedDict
+        The timing type statistics for the stats section
+        Expected to contain float values representing values in seconds
+
+    messages : OrderedDict
+        Text type output to be reported
+
+    total_time : float
+        Total time for processing in the section
+        Can be None, meaning that section timing percentages will be reported
+    """
+    def __init__(self, name, parent):
+        self.parent = parent
+        self.header = str(name)
+        self.name = name
+        self.counts = OrderedDict()
+        self.timings = OrderedDict()
+        self.messages = OrderedDict()
+        self.total_time = None
+
+    def add_count(self, key, value):
+        """
+        Add value to count. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the given value
+        value is expected to be an integer
+        """
+        if not isinstance(value, int):
+            try:
+                value = int(value)
+            except:
+                raise TypeError("value is expected to be an integer")
+
+        if key in self.counts:
+            self.counts[key] += value
+        else:
+            self.counts[key] = value
+
+    def add_timing(self, key, value):
+        """
+        Add value to timing. If key does not already exist in section then
+        it is created with this value.
+        If key already exists it is increased by the give value
+        value is expected to be a float, and given in seconds.
+        """
+        if not isinstance(value, float):
+            try:
+                value = float(value)
+            except:
+                raise TypeError("value is expected to be a float")
+
+        if key in self.timings:
+            self.timings[key] += value
+        else:
+            self.timings[key] = value
+
+    def add_message(self, key, value, sep=";"):
+        """
+        Add value to message. If key does not already exist in section then
+        it is created with this value.
+        If key already exists the value is added to the message
+        The value will be converted to a string
+        """
+        value = str(value)
+
+        if key in self.messages:
+            if sep is not None:
+                try:
+                    value = sep + value
+                except:
+                    TypeError("It is not possible to concatenate the value "
+                              "with the given seperator")
+            self.messages[key] += value
+        else:
+            self.messages[key] = value
+
+    def report(self, output=sys.stdout):
+        """
+        Report the counts, timings and messages for this section.
+        Note the percentage of the section and solver total times will be
+        given if the parent and or section total_time is set
+        """
+        if self.header:
+            output.write("\n{}\n{}\n".format(self.header,
+                                     ("-"*len(self.header))))
+
+        # TODO: Make the timings and counts ouput in a table format
+        #       Generally make more pretty
+
+        # Report timings
+        try:
+            ttt = self.parent.total_time
+        except:
+            ttt = None
+
+        tt = self.total_time
+
+        output.write("### Timings:\n")
+        for key, value in self.timings.items():
+            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
+            output.write(l)
+        if tt is not None:
+            output.write(" - {}\t{} total time\n".format(_format_time(tt),
+                                                     self.name))
+
+        # Report counts
+        output.write("### Counts:\n")
+        for key, value in self.counts.items():
+            l = " - {}\t{}\n".format(value, key)
+            output.write(l)
+
+        # Report messages
+        output.write("### Messages:\n")
+        for key, value in self.messages.items():
+            l = " - {}:\t{}\n".format(key, value)
+            output.write(l)
+
+
+    def clear(self):
+        """
+        Clear counts, timings and messages from this section
+        """
+        self.counts.clear()
+        self.timings.clear()
+        self.messages.clear()
+        self.total_time = None
+
+
+def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
+    # Input is std Qobj (Hamiltonian or Liouvillian)
+    if isinstance(H, Qobj):
+        Hdims = H.dims
+        Htype = H.type
+        _structure_check(Hdims, Htype, state)
+    # Input H is function
+    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
+        Hdims = H(0,args).dims
+        Htype = H(0,args).type
+        _structure_check(Hdims, Htype, state)
+    # Input is td-list
+    elif isinstance(H, list):
+        if isinstance(H[0], Qobj):
+            Hdims = H[0].dims
+            Htype = H[0].type
+        elif isinstance(H[0], list):
+            Hdims = H[0][0].dims
+            Htype = H[0][0].type
+        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
+            Hdims = H[0](0,args).dims
+            Htype = H[0](0,args).type
+        else:
+            raise Exception('Invalid td-list element.')
+        # Check all operators in list
+        for ii in range(len(H)):
+            if isinstance(H[ii], Qobj):
+                _temp_dims = H[ii].dims
+                _temp_type = H[ii].type
+            elif isinstance(H[ii], list):
+                _temp_dims = H[ii][0].dims
+                _temp_type = H[ii][0].type
+            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
+                _temp_dims = H[ii](0,args).dims
+                _temp_type = H[ii](0,args).type
+            else:
+                raise Exception('Invalid td-list element.')
+            _structure_check(_temp_dims,_temp_type,state)
+
+    else:
+        raise Exception('Invalid time-dependent format.')
+
+
+    for ii in range(len(c_ops)):
+        do_tests = True
+        if isinstance(c_ops[ii], Qobj):
+            _temp_state = c_ops[ii]
+        elif isinstance(c_ops[ii], list):
+            if isinstance(c_ops[ii][0], Qobj):
+                _temp_state = c_ops[ii][0]
+            elif isinstance(c_ops[ii][0], tuple):
+                do_tests = False
+                for kk in range(len(c_ops[ii][0])):
+                    _temp_state = c_ops[ii][0][kk]
+                    _structure_check(Hdims, Htype, _temp_state)
+        else:
+            raise Exception('Invalid td-list element.')
+        if do_tests:
+            _structure_check(Hdims, Htype, _temp_state)
+
+    if isinstance(e_ops, list):
+        for ii in range(len(e_ops)):
+            if isinstance(e_ops[ii], Qobj):
+                _temp_state = e_ops[ii]
+            elif isinstance(e_ops[ii], list):
+                _temp_state = e_ops[ii][0]
+            else:
+                raise Exception('Invalid td-list element.')
+            _structure_check(Hdims,Htype,_temp_state)
+    elif isinstance(e_ops, FunctionType):
+        pass
+    else:
+        raise Exception('Invalid e_ops specification.')
+
+
+def _structure_check(Hdims, Htype, state):
+    if state is not None:
+        # Input state is a ket vector
+        if state.type == 'ket':
+            # Input is Hamiltonian
+            if Htype == 'oper':
+                if Hdims[1] != state.dims[0]:
+                    raise Exception('Input operator and ket do not '
+                                    'share same structure.')
+            # Input is super and state is ket
+            elif Htype == 'super':
+                if Hdims[1][1] != state.dims[0]:
+                    raise Exception('Input operator and ket do not '
+                                    'share same structure.')
+            else:
+                raise Exception('Invalid input operator.')
+        # Input state is a density matrix
+        elif state.type == 'oper':
+            # Input is Hamiltonian and state is density matrix
+            if Htype == 'oper':
+                if Hdims[1] != state.dims[0]:
+                    raise Exception('Input operators do not '
+                                    'share same structure.')
+            # Input is super op. and state is density matrix
+            elif Htype == 'super':
+                if Hdims[1] != state.dims:
+                    raise Exception('Input operators do not '
+                                    'share same structure.')
+
+
+#
+# create a global instance of the SolverConfiguration class
+#
+config = SolverConfiguration()
+
+# for backwards compatibility
+# Odeoptions = Options
+# Odedata = Result
diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index 63df5c468b..99829ae8ff 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -1,1405 +1,1405 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-import scipy.sparse as sp
-from .. import (
-    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
-    unstack_columns, liouvillian, lindblad_dissipator,
-)
-from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
-from ._stochastic import (
-    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
-    GenericSSolver, Solvers
-)
-from .solver import Result, SolverOptions, _solver_safety_check
-from .parallel import serial_map
-from ..ui.progressbar import TextProgressBar
-from qutip.core import data as _data
-
-__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
-           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
-           'stochastic_solvers', 'general_stochastic']
-
-
-def stochastic_solvers():
-    # This docstring contains several literal backslash characters inside LaTeX
-    # blocks, but it cannot be declared as a raw string because we also need to
-    # use a line continuation.  At one point we need a restructured text
-    # "definition list", where the heading _must_ be entirely on one line,
-    # however it will violate our line-length reporting if we do that.
-    """
-    This function is purely a reference point for documenting the available
-    stochastic solver methods, and takes no actions.
-
-    Notes
-    -----
-    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
-        euler-maruyama
-            A simple generalization of the Euler method for ordinary
-            differential equations to stochastic differential equations.  Only
-            solver which could take non-commuting ``sc_ops``. *not tested*
-
-            - Order 0.5
-            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
-
-        milstein
-            An order 1.0 strong Taylor scheme.  Better approximate numerical
-            solution to stochastic differential equations.  See eq. (2.9) of
-            chapter 12.2 of [1]_.
-
-            - Order strong 1.0
-            - Code: ``'milstein'`` or ``1.0``
-
-        milstein-imp
-            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
-            scheme for the numerical simulation of stiff stochastic
-            differential equations.
-
-            - Order strong 1.0
-            - Code: ``'milstein-imp'``
-
-        predictor-corrector
-            Generalization of the trapezoidal method to stochastic differential
-            equations. More stable than explicit methods.  See eq. (5.4) of
-            chapter 15.5 of [1]_.
-
-            - Order strong 0.5, weak 1.0
-            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
-              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
-              ``'pc-euler'``
-            - Codes to correct both the stochastic and deterministic parts
-              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
-              ``'pc-euler-2'`` or ``'pred-corr-2'``
-
-        platen
-            Explicit scheme, creates the Milstein using finite differences
-            instead of analytic derivatives. Also contains some higher order
-            terms, thus converges better than Milstein while staying strong
-            order 1.0.  Does not require derivatives, therefore usable by
-            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
-
-            - Order strong 1.0, weak 2.0
-            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
-
-        rouchon
-            Scheme keeping the positivity of the density matrix
-            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
-
-            - Order strong 1.0?
-            - Code: ``'rouchon'`` or ``'Rouchon'``
-
-        taylor1.5
-            Order 1.5 strong Taylor scheme.  Solver with more terms of the
-            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
-            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
-
-            - Order strong 1.5
-            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
-
-        taylor1.5-imp
-            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
-            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
-            (2.18) of chapter 12.2 of [1]_.
-
-            - Order strong 1.5
-            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
-
-        explicit1.5
-            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
-            Taylor scheme using finite difference instead of derivatives.
-            Slower than ``taylor15`` but usable by
-            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
-            [1]_.
-
-            - Order strong 1.5
-            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
-
-        taylor2.0
-            Order 2 strong Taylor scheme.  Solver with more terms of the
-            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
-
-            - Order strong 2.0
-            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
-
-        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
-        and for both heterodyne and homodyne. taylor2.0 only works for 1
-        stochastic operator independent of time with the homodyne method.
-        :func:`~general_stochastic` only accepts the derivative-free
-        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
-
-    Available solvers for :obj:`~photocurrent_sesolve` and \
-:obj:`~photocurrent_mesolve`
-        Photocurrent use ordinary differential equations between
-        stochastic "jump/collapse".
-
-        euler
-            Euler method for ordinary differential equations between jumps.
-            Only one jump per time interval.  Default solver.  See eqs. (4.19)
-            and (4.4) of chapter 4 of [4]_.
-
-            - Order 1.0
-            - Code: ``'euler'``
-
-        predictor–corrector
-            predictor–corrector method (PECE) for ordinary differential
-            equations.  Uses the Poisson distribution to obtain the number of
-            jumps at each timestep.
-
-            - Order 2.0
-            - Code: ``'pred-corr'``
-
-    References
-    ----------
-    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
-       Stochastic Differential Equations*.
-    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
-       Systems*.
-    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
-       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
-       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
-       (2015).
-    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
-       control*.
-    """
-
-
-class StochasticSolverOptions:
-    """Class of options for stochastic solvers such as
-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
-
-    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
-    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
-    :func:`qutip.stochastic.photocurrent_sesolve` and
-    :func:`qutip.stochastic.photocurrent_mesolve`
-    all take the same keyword arguments as
-    the constructor of these class, and internally they use these arguments to
-    construct an instance of this class, so it is rarely needed to explicitly
-    create an instance of this class.
-
-    Within the attribute list, a ``time_dependent_object`` is either
-
-    - :class:`~qutip.Qobj`: a constant term
-    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
-      where the ``Qobj`` will be multiplied by the time-dependent scalar.
-
-    For more details on all allowed time-dependent objects, see the
-    documentation for :class:`~qutip.QobjEvo`.
-
-    Attributes
-    ----------
-    H : time_dependent_object or list of time_dependent_object
-        System Hamiltonian in standard time-dependent list format.  This is the
-        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
-        If this is a list of elements, they are summed.
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix.
-
-    times : array_like of float
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of time_dependent_object
-        List of deterministic collapse operators.  Each element of the list is
-        a separate operator; unlike the Hamiltonian, there is no implicit
-        summation over the terms.
-
-    sc_ops : list of time_dependent_object
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the equation of motion according to how the d1 and d2 functions
-        are defined.  Each element of the list is a separate operator, like
-        ``c_ops``.
-
-    e_ops : list of :class:`qutip.Qobj`
-        Single operator or list of operators for which to evaluate
-        expectation values.
-
-    m_ops : list of :class:`qutip.Qobj`
-        List of operators representing the measurement operators. The expected
-        format is a nested list with one measurement operator for each
-        stochastic increament, for each stochastic collapse operator.
-
-    args : dict
-        Dictionary of parameters for time dependent systems.
-
-    tol : float
-        Tolerance of the solver for implicit methods.
-
-    ntraj : int
-        Number of trajectors.
-
-    nsubsteps : int
-        Number of sub steps between each time-spep given in `times`.
-
-    dW_factors : array
-        Array of length len(sc_ops), containing scaling factors for each
-        measurement operator in m_ops.
-
-    solver : string
-        Name of the solver method to use for solving the stochastic
-        equations. Valid values are:
-
-        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
-        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
-        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
-        - order 2 algorithms: 'taylor2.0'
-
-        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
-        for a description of the solvers.  Implicit methods can adjust
-        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
-
-    method : string ('homodyne', 'heterodyne')
-        The name of the type of measurement process that give rise to the
-        stochastic equation to solve.
-
-    store_all_expect : bool (default False)
-        Whether or not to store the e_ops expect values for all paths.
-
-    store_measurement : bool (default False)
-        Whether or not to store the measurement results in the
-        :class:`qutip.solver.Result` instance returned by the solver.
-
-    noise : int, or 1D array of int, or 4D array of float
-        - int : seed of the noise
-        - 1D array : length = ntraj, seeds for each trajectories.
-        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
-          Vector for the noise, the len of the last dimensions is doubled for
-          solvers of order 1.5. This corresponds to results.noise.
-
-    noiseDepth : int
-        Number of terms kept of the truncated series used to create the
-        noise used by taylor2.0 solver.
-
-    normalize : bool
-        (default True for (photo)ssesolve, False for (photo)smesolve)
-        Whether or not to normalize the wave function during the evolution.
-        Normalizing density matrices introduce numerical errors.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options. Only options['average_states'] and
-        options['store_states'] are used.
-
-    map_func: function
-        A map function or managing the calls to single-trajactory solvers.
-
-    map_kwargs: dictionary
-        Optional keyword arguments to the map_func function function.
-
-    progress_bar : :class:`qutip.ui.BaseProgressBar`
-        Optional progress bar class instance.
-    """
-    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
-                 e_ops=[], m_ops=None, store_all_expect=False,
-                 store_measurement=False, dW_factors=None,
-                 solver=None, method="homodyne", normalize=None,
-                 times=None, nsubsteps=1, ntraj=1, tol=None,
-                 generate_noise=None, noise=None,
-                 progress_bar=None, map_func=None, map_kwargs=None,
-                 args={}, options=None, noiseDepth=20):
-
-        if options is None:
-            options = SolverOptions()
-
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
-        # System
-        # Cast to QobjEvo so the code has only one version for both the
-        # constant and time-dependent case.
-        self.me = me
-
-        if H is not None:
-            msg = "The Hamiltonian format is not valid. "
-            try:
-                self.H = QobjEvo(H, args=args, tlist=times)
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.H = H
-
-        if sc_ops:
-            msg = ("The sc_ops format is not valid. Options are "
-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-            try:
-                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
-                               for op in sc_ops]
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.sc_ops = sc_ops
-
-        if c_ops:
-            msg = ("The c_ops format is not valid. Options are "
-                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
-            try:
-                self.c_ops = [QobjEvo(op, args=args, tlist=times)
-                              for op in c_ops]
-            except Exception as e:
-                raise ValueError(msg + str(e)) from e
-        else:
-            self.c_ops = c_ops
-
-        self.state0 = state0
-        self.rho0 = stack_columns(state0.full()).ravel()
-
-        # Observation
-
-        for e_op in e_ops:
-            if (
-                isinstance(e_op, Qobj)
-                and self.H is not None
-                and e_op.dims[1] != self.H.dims[0]
-            ):
-                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
-                                f"with the system's ({self.H.dims})")
-        self.e_ops = e_ops
-        self.m_ops = m_ops
-        self.store_measurement = store_measurement
-        self.store_all_expect = store_all_expect
-        self.store_states = options['store_states']
-        self.dW_factors = dW_factors
-
-        # Solver
-        self.solver = solver
-        self.method = method
-        if normalize is None and me:
-            self.normalize = 0
-        elif normalize is None and not me:
-            self.normalize = 1
-        elif normalize:
-            self.normalize = 1
-        else:
-            self.normalize = 0
-
-        self.times = times
-        self.nsubsteps = nsubsteps
-        self.dt = (times[1] - times[0]) / self.nsubsteps
-        self.ntraj = ntraj
-        if tol is not None:
-            self.tol = tol
-        elif "tol" in args:
-            self.tol = args["tol"]
-        else:
-            self.tol = 1e-7
-
-        # Noise
-        if noise is not None:
-            if isinstance(noise, int):
-                # noise contain a seed
-                np.random.seed(noise)
-                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-            noise = np.array(noise)
-            if len(noise.shape) == 1:
-                if noise.shape[0] < ntraj:
-                    raise ValueError("'noise' does not have enought seeds " +
-                                     "len(noise) >= ntraj")
-                # numpy seed must be between 0 and 2**32-1
-                # 'u4': unsigned 32bit int
-                self.noise = noise.astype("u4")
-                self.noise_type = 0
-
-            elif len(noise.shape) == 4:
-                # taylor case not included
-                dw_len = (2 if method == "heterodyne" else 1)
-                dw_len_str = (" * 2" if method == "heterodyne" else "")
-                msg = "Incorrect shape for 'noise': "
-                if noise.shape[0] < ntraj:
-                    raise ValueError(msg + "shape[0] >= ntraj")
-                if noise.shape[1] < len(times):
-                    raise ValueError(msg + "shape[1] >= len(times)")
-                if noise.shape[2] < nsubsteps:
-                    raise ValueError(msg + "shape[2] >= nsubsteps")
-                if noise.shape[3] < len(self.sc_ops) * dw_len:
-                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
-                                     dw_len_str)
-                self.noise_type = 1
-                self.noise = noise
-
-        else:
-            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
-            self.noise_type = 0
-
-        # Map
-        self.progress_bar = progress_bar
-        if self.ntraj > 1 and map_func:
-            self.map_func = map_func
-        else:
-            self.map_func = serial_map
-        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
-
-        # Other
-        self.options = options
-        self.args = args
-        self.set_solver()
-        self.p = noiseDepth
-
-    def set_solver(self):
-        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
-            self.solver_code = 50
-            self.solver = 'euler-maruyama'
-        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
-            self.solver_code = 100
-            self.solver = 'platen'
-        elif self.solver in ['pred-corr', 'predictor-corrector',
-                             'pc-euler', 101]:
-            self.solver_code = 101
-            self.solver = 'pred-corr'
-        elif self.solver in ['milstein', 102, 1.0]:
-            self.solver_code = 102
-            self.solver = 'milstein'
-        elif self.solver in ['milstein-imp', 103]:
-            self.solver_code = 103
-            self.solver = 'milstein-imp'
-        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
-            self.solver_code = 104
-            self.solver = 'pred-corr-2'
-        elif self.solver in ['Rouchon', 'rouchon', 120]:
-            self.solver_code = 120
-            self.solver = 'rouchon'
-            if not all((op.isconstant for op in self.sc_ops)):
-                raise ValueError("Rouchon only works with constant sc_ops")
-        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
-            self.solver_code = 150
-            self.solver = 'explicit1.5'
-        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
-            self.solver_code = 152
-            self.solver = 'taylor1.5'
-        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
-            self.solver_code = 153
-            self.solver = 'taylor1.5-imp'
-        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
-            self.solver_code = 202
-            self.solver = 'taylor2.0'
-            if not len(self.sc_ops) == 1 or \
-                    not self.sc_ops[0].isconstant or \
-                    not self.method == "homodyne":
-                raise ValueError(
-                    "Taylor2.0 only works with 1 constant sc_ops and for"
-                    " homodyne method"
-                )
-        else:
-            known = [
-                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
-                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
-                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
-            ]
-            raise ValueError("The solver should be one of {!r}".format(known))
-
-
-class StochasticSolverOptionsPhoto(StochasticSolverOptions):
-    """
-    Attributes
-    ----------
-
-    solver : string
-        Name of the solver method to use for solving the evolution
-        of the system.*
-        order 1 algorithms: 'euler'
-        order 2 algorithms: 'pred-corr'
-        In photocurrent evolution
-    """
-    def set_solver(self):
-        if self.solver in [None, 'euler', 1, 60]:
-            self.solver_code = 60
-            self.solver = 'euler'
-        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
-            self.solver_code = 110
-            self.solver = 'pred-corr'
-        else:
-            raise Exception("The solver should be one of " +
-                            "[None, 'euler', 'predictor-corrector']")
-
-
-def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic master equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    if "method" in kwargs and kwargs["method"] == "photocurrent":
-        print("stochastic solver with photocurrent method has been moved to "
-              "it's own function: photocurrent_mesolve")
-        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
-                                    e_ops=e_ops, _safe_mode=_safe_mode,
-                                    args=args, **kwargs)
-    if isket(rho0):
-        rho0 = ket2dm(rho0)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
-                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-                                  args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.solver_code == 120:
-        return _positive_map(sso, e_ops_dict)
-
-    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
-    if sso.method == 'homodyne' or sso.method is None:
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sso.m_ops)
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise Exception("The len of dW_factors is not the same as m_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sso.sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
-                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-        elif len(sso.dW_factors) == len(sso.m_ops):
-            pass
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == "photocurrent":
-        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
-
-    else:
-        raise Exception("The method must be one of None, homodyne, heterodyne")
-
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-
-    if sso.solver_code in [103, 153]:
-        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
-
-    sso.solver_obj = SMESolver
-    sso.solver_name = "smesolve_" + sso.solver
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-    return res
-
-
-def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
-             _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic schrodinger equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    psi0 : :class:`qutip.Qobj`
-        State vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if "method" in kwargs and kwargs["method"] == "photocurrent":
-        print("stochastic solver with photocurrent method has been moved to "
-              "it's own function: photocurrent_sesolve")
-        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
-                                    e_ops=e_ops, _safe_mode=_safe_mode,
-                                    args=args, **kwargs)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
-                                  sc_ops=sc_ops, e_ops=e_ops,
-                                  args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.solver_code == 120:
-        raise Exception("rouchon only work with smesolve")
-
-    if sso.method == 'homodyne' or sso.method is None:
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sso.sops)
-        elif len(sso.dW_factors) != len(sso.sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sso.sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            c1 = c / np.sqrt(2)
-            c2 = c * (-1j / np.sqrt(2))
-            sso.sops += [[c1, c1 + c1.dag()],
-                         [c2, c2 + c2.dag()]]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sso.sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == "photocurrent":
-        NotImplementedError("Moved to 'photocurrent_sesolve'")
-
-    else:
-        raise Exception("The method must be one of None, homodyne, heterodyne")
-
-    sso.LH = sso.H * (-1j * sso.dt)
-    for ops in sso.sops:
-        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
-
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-
-    sso.solver_obj = SSESolver
-    sso.solver_name = "ssesolve_" + sso.solver
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def _positive_map(sso, e_ops_dict):
-    if sso.method == 'homodyne' or sso.method is None:
-        sops = sso.sc_ops
-        if sso.m_ops is None:
-            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [1] * len(sops)
-        elif len(sso.dW_factors) != len(sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    elif sso.method == 'heterodyne':
-        if sso.m_ops is None:
-            m_ops = []
-        sops = []
-        for c in sso.sc_ops:
-            if sso.m_ops is None:
-                m_ops += [c + c.dag(), -1j * (c - c.dag())]
-            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
-        sso.m_ops = m_ops
-        if not isinstance(sso.dW_factors, list):
-            sso.dW_factors = [np.sqrt(2)] * len(sops)
-        elif len(sso.dW_factors) == len(sso.sc_ops):
-            dW_factors = []
-            for fact in sso.dW_factors:
-                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
-            sso.dW_factors = dW_factors
-        elif len(sso.dW_factors) != len(sops):
-            raise Exception("The len of dW_factors is not the same as sc_ops")
-    else:
-        raise Exception("The method must be one of homodyne or heterodyne")
-
-    LH = 1 - (sso.H * 1j * sso.dt)
-    sso.pp = spre(sso.H) * 0
-    sso.sops = []
-    sso.preops = []
-    sso.postops = []
-    sso.preops2 = []
-    sso.postops2 = []
-
-    def _prespostdag(op):
-        return spre(op) * spost(op.dag())
-
-    for op in sso.c_ops:
-        LH += op.dag() @ op * (-sso.dt * 0.5)
-        sso.pp += spre(op) * spost(op.dag()) * sso.dt
-
-    for i, op in enumerate(sops):
-        LH += (-sso.dt * 0.5) * op.dag() @ op
-        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
-        sso.preops += [spre(op)]
-        sso.postops += [spost(op.dag())]
-        for op2 in sops[i:]:
-            sso.preops2 += [spre(op * op2)]
-            sso.postops2 += [spost(op.dag() * op2.dag())]
-
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-    sso.preLH = spre(LH)
-    sso.postLH = spost(LH.dag())
-
-    sso.solver_obj = PmSMESolver
-    sso.solver_name = "smesolve_" + sso.solver
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
-                         _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic master equation using the photocurrent method.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isket(rho0):
-        rho0 = ket2dm(rho0)
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
-                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
-                                       args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.m_ops is None:
-        sso.m_ops = [op * 0 for op in sso.sc_ops]
-    if not isinstance(sso.dW_factors, list):
-        sso.dW_factors = [1] * len(sso.sc_ops)
-    elif len(sso.dW_factors) != len(sso.sc_ops):
-        raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    sso.solver_obj = PcSMESolver
-    sso.solver_name = "photocurrent_mesolve"
-    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
-
-    def _prespostdag(op):
-        return spre(op) * spost(op.dag())
-
-    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
-                 spre(op.dag() @ op),
-                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
-    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
-                         _safe_mode=True, args={}, **kwargs):
-    """
-    Solve stochastic schrodinger equation using the photocurrent method.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`, or time dependent system.
-        System Hamiltonian.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-        Can depend on time, see StochasticSolverOptions help for format.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = list(e_ops.values())
-    else:
-        e_ops_dict = None
-
-    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
-                                       sc_ops=sc_ops, e_ops=e_ops,
-                                       args=args, **kwargs)
-
-    if _safe_mode:
-        _safety_checks(sso)
-
-    if sso.m_ops is None:
-        sso.m_ops = [op * 0 for op in sso.sc_ops]
-    if not isinstance(sso.dW_factors, list):
-        sso.dW_factors = [1] * len(sso.sc_ops)
-    elif len(sso.dW_factors) != len(sso.sc_ops):
-        raise Exception("The len of dW_factors is not the same as sc_ops")
-
-    sso.solver_obj = PcSSESolver
-    sso.solver_name = "photocurrent_sesolve"
-    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
-    sso.LH = sso.H * (-1j*sso.dt)
-    for ops in sso.sops:
-        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
-                       _safe_mode=True, len_d2=1, args={}, **kwargs):
-    """
-    Solve stochastic general equation. Dispatch to specific solvers
-    depending on the value of the `solver` keyword argument.
-
-
-    Parameters
-    ----------
-
-    state0 : :class:`qutip.Qobj`
-        Initial state vector (ket) or density matrix as a vector.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    d1 : function, callable class
-        Function representing the deterministic evolution of the system.
-
-        def d1(time (double), state (as a np.array vector)):
-            return 1d np.array
-
-    d2 : function, callable class
-        Function representing the stochastic evolution of the system.
-
-        def d2(time (double), state (as a np.array vector)):
-            return 2d np.array (N_sc_ops, len(state0))
-
-    len_d2 : int
-        Number of output vector produced by d2
-
-    e_ops : list of :class:`qutip.Qobj`
-        single operator or list of operators for which to evaluate
-        expectation values.
-        Must be a superoperator if the state vector is a density matrix.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`.
-    """
-
-    if isinstance(e_ops, dict):
-        e_ops_dict = e_ops
-        e_ops = [e for e in e_ops.values()]
-    else:
-        e_ops_dict = None
-
-    if "solver" not in kwargs:
-        kwargs["solver"] = 50
-
-    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
-                                  e_ops=e_ops, args=args, **kwargs)
-    if sso.solver_code not in [50, 100, 150]:
-        raise ValueError("Only Euler, platen, platen15 can be " +
-                         "used for the general stochastic solver.")
-
-    sso.d1 = d1
-    sso.d2 = d2
-    if _safe_mode:
-        # This state0_vec is computed as stack_columns(state0.full()).ravel()
-        # in the sso init.
-        state0_vec = sso.rho0
-        l_vec = state0_vec.shape[0]
-        try:
-            out_d1 = d1(0., sso.rho0)
-        except Exception as e:
-            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
-                               str(e)) from e
-        try:
-            out_d2 = d2(0., sso.rho0)
-        except Exception as e:
-            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
-                               str(e)) from e
-
-        msg_d1 = ("d1 must return an 1d numpy array with the same number "
-                  "of elements as the initial state as a vector.")
-        if not isinstance(out_d1, np.ndarray):
-            raise TypeError(msg_d1)
-        if (out_d1.ndim != 1
-                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
-            raise ValueError(msg_d1)
-
-        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
-                  "with the shape (len_d2, len(state0_vec) ).")
-        if not isinstance(out_d2, np.ndarray):
-            raise TypeError(msg_d2)
-        if (out_d2.ndim != 2
-                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
-            raise ValueError(msg_d2)
-        if out_d1.dtype != np.dtype('complex128') or \
-           out_d2.dtype != np.dtype('complex128'):
-            raise ValueError("Safety check: d1 and d2 must return " +
-                             "complex numpy array.")
-        msg_e_ops = ("Safety check: The shape of the e_ops "
-                     "does not fit the intial state.")
-        for op in sso.e_ops:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise ValueError(msg_e_ops)
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise ValueError(msg_e_ops +
-                                     " Expecting e_ops as superoperators.")
-
-    sso.m_ops = []
-    sso.cm_ops = []
-    if sso.store_measurement:
-        if not m_ops:
-            raise ValueError("General stochastic needs explicit " +
-                             "m_ops to store measurement.")
-        sso.m_ops = m_ops
-        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
-        if sso.dW_factors is None:
-            sso.dW_factors = [1.] * len(sso.m_ops)
-        elif len(sso.dW_factors) == 1:
-            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
-        elif len(sso.dW_factors) != len(sso.m_ops):
-            raise ValueError("The number of dW_factors must fit" +
-                             " the number of m_ops.")
-
-    if sso.dW_factors is None:
-        sso.dW_factors = [1.] * len_d2
-    sso.sops = [None] * len_d2
-    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
-
-    sso.solver_obj = GenericSSolver
-    sso.solver_name = "general_stochastic_solver_" + sso.solver
-
-    ssolver = GenericSSolver()
-    # ssolver.set_data(sso)
-    ssolver.set_solver(sso)
-
-    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
-
-    if e_ops_dict:
-        res.expect = {e: res.expect[n]
-                      for n, e in enumerate(e_ops_dict.keys())}
-
-    return res
-
-
-def _safety_checks(sso):
-    l_vec = sso.rho0.shape[0]
-    if sso.H.issuper:
-        if not sso.me:
-            raise ValueError(
-                "Given a Liouvillian for a Schrödinger equation problem."
-            )
-        shape_op = sso.H.shape
-        if shape_op[0] != l_vec or shape_op[1] != l_vec:
-            raise Exception("The size of the hamiltonian does "
-                            "not fit the intial state")
-    else:
-        shape_op = sso.H.shape
-        if sso.me:
-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                raise Exception("The size of the hamiltonian does "
-                                "not fit the intial state")
-        else:
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the hamiltonian does "
-                                "not fit the intial state")
-
-    for op in sso.sc_ops:
-        if op.issuper:
-            if not sso.me:
-                raise ValueError(
-                    "Given a Liouvillian for a Schrödinger equation problem."
-                )
-            shape_op = op.shape
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the sc_ops does "
-                                "not fit the intial state")
-        else:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the sc_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the sc_ops does "
-                                    "not fit the intial state")
-
-    for op in sso.c_ops:
-        if op.issuper:
-            if not sso.me:
-                raise ValueError(
-                    "Given a Liouvillian for a Schrödinger equation problem."
-                )
-            shape_op = op.shape
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the c_ops does "
-                                "not fit the intial state")
-        else:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the c_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the c_ops does "
-                                    "not fit the intial state")
-
-    for op in sso.e_ops:
-        shape_op = op.shape
-        if sso.me:
-            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                raise Exception("The size of the e_ops does "
-                                "not fit the intial state")
-        else:
-            if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                raise Exception("The size of the e_ops does "
-                                "not fit the intial state")
-
-    if sso.m_ops is not None:
-        for op in sso.m_ops:
-            shape_op = op.shape
-            if sso.me:
-                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
-                    raise Exception("The size of the m_ops does "
-                                    "not fit the intial state")
-            else:
-                if shape_op[0] != l_vec or shape_op[1] != l_vec:
-                    raise Exception("The size of the m_ops does "
-                                    "not fit the intial state")
-
-
-def _sesolve_generic(sso, options, progress_bar):
-    """
-    Internal function. See smesolve.
-    """
-    res = Result()
-    res.times = sso.times
-    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
-    res.measurement = []
-    res.solver = sso.solver_name
-    res.ntraj = sso.ntraj
-    res.num_expect = len(sso.e_ops)
-
-    nt = sso.ntraj
-    task = _single_trajectory
-    map_kwargs = {'progress_bar': sso.progress_bar}
-    map_kwargs.update(sso.map_kwargs)
-    task_args = (sso,)
-    task_kwargs = {}
-
-    results = sso.map_func(task, list(range(sso.ntraj)),
-                           task_args, task_kwargs, **map_kwargs)
-    noise = []
-    for result in results:
-        states_list, dW, m, expect = result
-        res.states.append(states_list)
-        noise.append(dW)
-        res.measurement.append(m)
-        res.expect += expect
-        res.ss += expect * expect
-    res.noise = np.stack(noise)
-
-    if sso.store_all_expect:
-        paths_expect = []
-        for result in results:
-            paths_expect.append(result[3])
-        res.runs_expect = np.stack(paths_expect)
-
-    # average density matrices (vectorized maybe)
-    # ajgpitch 2019-10-25: np.any(res.states) seems to error
-    # I guess there may be a potential exception if there are no states?
-    # store individual trajectory states
-    res.traj_states = res.states
-    res.avg_states = None
-    if options['average_states'] and options['store_states']:
-        avg_states_list = []
-        for n in range(len(res.times)):
-            tslot_states = [res.states[mm][n].data for mm in range(nt)]
-            if len(tslot_states) > 0:
-                state = Qobj(np.sum(tslot_states),
-                             dims=res.states[0][n].dims).unit()
-                avg_states_list.append(state)
-        # store average states
-        res.states = res.avg_states = avg_states_list
-
-    # average
-    res.expect = res.expect / nt
-
-    # standard error
-    if nt > 1:
-        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
-    else:
-        res.se = None
-
-    # convert complex data to real if hermitian
-    res.expect = [np.real(res.expect[n, :])
-                  if e.isherm else res.expect[n, :]
-                  for n, e in enumerate(sso.e_ops)]
-
-    return res
-
-
-def _single_trajectory(i, sso):
-    # Only one step?
-    ssolver = sso.solver_obj()
-    ssolver.set_solver(sso)
-    result = ssolver.cy_sesolve_single_trajectory(i)
-    return result
-
-
-# The code for ssepdpsolve have been moved to the file pdpsolve.
-# The call is still in stochastic for consistance.
-def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for wavefunction
-    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
-    trajectory simulations.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    psi0 : :class:`qutip.Qobj`
-        Initial state vector (ket).
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
-
-
-# The code for smepdpsolve have been moved to the file pdpsolve.
-# The call is still in stochastic for consistance.
-def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
-    """
-    A stochastic (piecewse deterministic process) PDP solver for density matrix
-    evolution.
-
-    Parameters
-    ----------
-
-    H : :class:`qutip.Qobj`
-        System Hamiltonian.
-
-    rho0 : :class:`qutip.Qobj`
-        Initial density matrix.
-
-    times : *list* / *array*
-        List of times for :math:`t`. Must be uniformly spaced.
-
-    c_ops : list of :class:`qutip.Qobj`
-        Deterministic collapse operator which will contribute with a standard
-        Lindblad type of dissipation.
-
-    sc_ops : list of :class:`qutip.Qobj`
-        List of stochastic collapse operators. Each stochastic collapse
-        operator will give a deterministic and stochastic contribution
-        to the eqaution of motion according to how the d1 and d2 functions
-        are defined.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function single
-        single operator or list of operators for which to evaluate
-        expectation values.
-
-    kwargs : *dictionary*
-        Optional keyword arguments. See
-        :class:`qutip.stochastic.StochasticSolverOptions`.
-
-    Returns
-    -------
-
-    output: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`.
-
-    """
-    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import scipy.sparse as sp
+from .. import (
+    Qobj, QobjEvo, isket, isoper, issuper, ket2dm, spre, spost, stack_columns,
+    unstack_columns, liouvillian, lindblad_dissipator,
+)
+from .pdpsolve import main_ssepdpsolve, main_smepdpsolve
+from ._stochastic import (
+    SSESolver, SMESolver, PcSSESolver, PcSMESolver, PmSMESolver,
+    GenericSSolver, Solvers
+)
+from .solver import Result, SolverOptions, _solver_safety_check
+from .parallel import serial_map
+from ..ui.progressbar import TextProgressBar
+from qutip.core import data as _data
+
+__all__ = ['ssesolve', 'photocurrent_sesolve', 'smepdpsolve',
+           'smesolve', 'photocurrent_mesolve', 'ssepdpsolve',
+           'stochastic_solvers', 'general_stochastic']
+
+
+def stochastic_solvers():
+    # This docstring contains several literal backslash characters inside LaTeX
+    # blocks, but it cannot be declared as a raw string because we also need to
+    # use a line continuation.  At one point we need a restructured text
+    # "definition list", where the heading _must_ be entirely on one line,
+    # however it will violate our line-length reporting if we do that.
+    """
+    This function is purely a reference point for documenting the available
+    stochastic solver methods, and takes no actions.
+
+    Notes
+    -----
+    Available solvers for :obj:`~ssesolve` and :obj:`~smesolve`
+        euler-maruyama
+            A simple generalization of the Euler method for ordinary
+            differential equations to stochastic differential equations.  Only
+            solver which could take non-commuting ``sc_ops``. *not tested*
+
+            - Order 0.5
+            - Code: ``'euler-maruyama'``, ``'euler'`` or ``0.5``
+
+        milstein
+            An order 1.0 strong Taylor scheme.  Better approximate numerical
+            solution to stochastic differential equations.  See eq. (2.9) of
+            chapter 12.2 of [1]_.
+
+            - Order strong 1.0
+            - Code: ``'milstein'`` or ``1.0``
+
+        milstein-imp
+            An order 1.0 implicit strong Taylor scheme.  Implicit Milstein
+            scheme for the numerical simulation of stiff stochastic
+            differential equations.
+
+            - Order strong 1.0
+            - Code: ``'milstein-imp'``
+
+        predictor-corrector
+            Generalization of the trapezoidal method to stochastic differential
+            equations. More stable than explicit methods.  See eq. (5.4) of
+            chapter 15.5 of [1]_.
+
+            - Order strong 0.5, weak 1.0
+            - Codes to only correct the stochastic part (:math:`\\alpha=0`,
+              :math:`\\eta=1/2`): ``'pred-corr'``, ``'predictor-corrector'`` or
+              ``'pc-euler'``
+            - Codes to correct both the stochastic and deterministic parts
+              (:math:`\\alpha=1/2`, :math:`\\eta=1/2`): ``'pc-euler-imp'``,
+              ``'pc-euler-2'`` or ``'pred-corr-2'``
+
+        platen
+            Explicit scheme, creates the Milstein using finite differences
+            instead of analytic derivatives. Also contains some higher order
+            terms, thus converges better than Milstein while staying strong
+            order 1.0.  Does not require derivatives, therefore usable by
+            :func:`~general_stochastic`.  See eq. (7.47) of chapter 7 of [2]_.
+
+            - Order strong 1.0, weak 2.0
+            - Code: ``'platen'``, ``'platen1'`` or ``'explicit1'``
+
+        rouchon
+            Scheme keeping the positivity of the density matrix
+            (:obj:`~smesolve` only).  See eq. (4) with :math:`\\eta=1` of [3]_.
+
+            - Order strong 1.0?
+            - Code: ``'rouchon'`` or ``'Rouchon'``
+
+        taylor1.5
+            Order 1.5 strong Taylor scheme.  Solver with more terms of the
+            Ito-Taylor expansion.  Default solver for :obj:`~smesolve` and
+            :obj:`~ssesolve`.  See eq. (4.6) of chapter 10.4 of [1]_.
+
+            - Order strong 1.5
+            - Code: ``'taylor1.5'``, ``'taylor15'``, ``1.5``, or ``None``
+
+        taylor1.5-imp
+            Order 1.5 implicit strong Taylor scheme.  Implicit Taylor 1.5
+            (:math:`\\alpha = 1/2`, :math:`\\beta` doesn't matter).  See eq.
+            (2.18) of chapter 12.2 of [1]_.
+
+            - Order strong 1.5
+            - Code: ``'taylor1.5-imp'`` or ``'taylor15-imp'``
+
+        explicit1.5
+            Explicit order 1.5 strong schemes.  Reproduce the order 1.5 strong
+            Taylor scheme using finite difference instead of derivatives.
+            Slower than ``taylor15`` but usable by
+            :func:`~general_stochastic`.  See eq. (2.13) of chapter 11.2 of
+            [1]_.
+
+            - Order strong 1.5
+            - Code: ``'explicit1.5'``, ``'explicit15'`` or ``'platen15'``
+
+        taylor2.0
+            Order 2 strong Taylor scheme.  Solver with more terms of the
+            Stratonovich expansion.  See eq. (5.2) of chapter 10.5 of [1]_.
+
+            - Order strong 2.0
+            - Code: ``'taylor2.0'``, ``'taylor20'`` or ``2.0``
+
+        All solvers, except taylor2.0, are usable in both smesolve and ssesolve
+        and for both heterodyne and homodyne. taylor2.0 only works for 1
+        stochastic operator independent of time with the homodyne method.
+        :func:`~general_stochastic` only accepts the derivative-free
+        solvers: ``'euler'``, ``'platen'`` and ``'explicit1.5'``.
+
+    Available solvers for :obj:`~photocurrent_sesolve` and \
+:obj:`~photocurrent_mesolve`
+        Photocurrent use ordinary differential equations between
+        stochastic "jump/collapse".
+
+        euler
+            Euler method for ordinary differential equations between jumps.
+            Only one jump per time interval.  Default solver.  See eqs. (4.19)
+            and (4.4) of chapter 4 of [4]_.
+
+            - Order 1.0
+            - Code: ``'euler'``
+
+        predictor–corrector
+            predictor–corrector method (PECE) for ordinary differential
+            equations.  Uses the Poisson distribution to obtain the number of
+            jumps at each timestep.
+
+            - Order 2.0
+            - Code: ``'pred-corr'``
+
+    References
+    ----------
+    .. [1] Peter E. Kloeden and Exkhard Platen, *Numerical Solution of
+       Stochastic Differential Equations*.
+    .. [2] H.-P. Breuer and F. Petruccione, *The Theory of Open Quantum
+       Systems*.
+    .. [3] Pierre Rouchon and Jason F. Ralpha, *Efficient Quantum Filtering for
+       Quantum Feedback Control*, `arXiv:1410.5345 [quant-ph]
+       <https://arxiv.org/abs/1410.5345>`_, Phys. Rev. A 91, 012118,
+       (2015).
+    .. [4] Howard M. Wiseman, Gerard J. Milburn, *Quantum measurement and
+       control*.
+    """
+
+
+class StochasticSolverOptions:
+    """Class of options for stochastic solvers such as
+    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`, etc.
+
+    The stochastic solvers :func:`qutip.stochastic.general_stochastic`,
+    :func:`qutip.stochastic.ssesolve`, :func:`qutip.stochastic.smesolve`,
+    :func:`qutip.stochastic.photocurrent_sesolve` and
+    :func:`qutip.stochastic.photocurrent_mesolve`
+    all take the same keyword arguments as
+    the constructor of these class, and internally they use these arguments to
+    construct an instance of this class, so it is rarely needed to explicitly
+    create an instance of this class.
+
+    Within the attribute list, a ``time_dependent_object`` is either
+
+    - :class:`~qutip.Qobj`: a constant term
+    - 2-element list of ``[Qobj, time_dependence]``: a time-dependent term
+      where the ``Qobj`` will be multiplied by the time-dependent scalar.
+
+    For more details on all allowed time-dependent objects, see the
+    documentation for :class:`~qutip.QobjEvo`.
+
+    Attributes
+    ----------
+    H : time_dependent_object or list of time_dependent_object
+        System Hamiltonian in standard time-dependent list format.  This is the
+        same as the argument that (e.g.) :func:`~qutip.mesolve` takes.
+        If this is a list of elements, they are summed.
+
+    state0 : :class:`qutip.Qobj`
+        Initial state vector (ket) or density matrix.
+
+    times : array_like of float
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of time_dependent_object
+        List of deterministic collapse operators.  Each element of the list is
+        a separate operator; unlike the Hamiltonian, there is no implicit
+        summation over the terms.
+
+    sc_ops : list of time_dependent_object
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the equation of motion according to how the d1 and d2 functions
+        are defined.  Each element of the list is a separate operator, like
+        ``c_ops``.
+
+    e_ops : list of :class:`qutip.Qobj`
+        Single operator or list of operators for which to evaluate
+        expectation values.
+
+    m_ops : list of :class:`qutip.Qobj`
+        List of operators representing the measurement operators. The expected
+        format is a nested list with one measurement operator for each
+        stochastic increament, for each stochastic collapse operator.
+
+    args : dict
+        Dictionary of parameters for time dependent systems.
+
+    tol : float
+        Tolerance of the solver for implicit methods.
+
+    ntraj : int
+        Number of trajectors.
+
+    nsubsteps : int
+        Number of sub steps between each time-spep given in `times`.
+
+    dW_factors : array
+        Array of length len(sc_ops), containing scaling factors for each
+        measurement operator in m_ops.
+
+    solver : string
+        Name of the solver method to use for solving the stochastic
+        equations. Valid values are:
+
+        - order 1/2 algorithms: 'euler-maruyama', 'pc-euler', 'pc-euler-imp'
+        - order 1 algorithms: 'milstein', 'platen', 'milstein-imp', 'rouchon'
+        - order 3/2 algorithms: 'taylor1.5', 'taylor1.5-imp', 'explicit1.5'
+        - order 2 algorithms: 'taylor2.0'
+
+        See the documentation of :func:`~qutip.stochastic.stochastic_solvers`
+        for a description of the solvers.  Implicit methods can adjust
+        tolerance via the kw 'tol'. Default is {'tol': 1e-6}
+
+    method : string ('homodyne', 'heterodyne')
+        The name of the type of measurement process that give rise to the
+        stochastic equation to solve.
+
+    store_all_expect : bool (default False)
+        Whether or not to store the e_ops expect values for all paths.
+
+    store_measurement : bool (default False)
+        Whether or not to store the measurement results in the
+        :class:`qutip.solver.Result` instance returned by the solver.
+
+    noise : int, or 1D array of int, or 4D array of float
+        - int : seed of the noise
+        - 1D array : length = ntraj, seeds for each trajectories.
+        - 4D array : ``(ntraj, len(times), nsubsteps, len(sc_ops)*[1|2])``.
+          Vector for the noise, the len of the last dimensions is doubled for
+          solvers of order 1.5. This corresponds to results.noise.
+
+    noiseDepth : int
+        Number of terms kept of the truncated series used to create the
+        noise used by taylor2.0 solver.
+
+    normalize : bool
+        (default True for (photo)ssesolve, False for (photo)smesolve)
+        Whether or not to normalize the wave function during the evolution.
+        Normalizing density matrices introduce numerical errors.
+
+    options : :class:`qutip.solver.SolverOptions`
+        Generic solver options. Only options['average_states'] and
+        options['store_states'] are used.
+
+    map_func: function
+        A map function or managing the calls to single-trajactory solvers.
+
+    map_kwargs: dictionary
+        Optional keyword arguments to the map_func function function.
+
+    progress_bar : :class:`qutip.ui.BaseProgressBar`
+        Optional progress bar class instance.
+    """
+    def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
+                 e_ops=[], m_ops=None, store_all_expect=False,
+                 store_measurement=False, dW_factors=None,
+                 solver=None, method="homodyne", normalize=None,
+                 times=None, nsubsteps=1, ntraj=1, tol=None,
+                 generate_noise=None, noise=None,
+                 progress_bar=None, map_func=None, map_kwargs=None,
+                 args={}, options=None, noiseDepth=20):
+
+        if options is None:
+            options = SolverOptions()
+
+        if progress_bar is None:
+            progress_bar = TextProgressBar()
+
+        # System
+        # Cast to QobjEvo so the code has only one version for both the
+        # constant and time-dependent case.
+        self.me = me
+
+        if H is not None:
+            msg = "The Hamiltonian format is not valid. "
+            try:
+                self.H = QobjEvo(H, args=args, tlist=times)
+            except Exception as e:
+                raise ValueError(msg + str(e)) from e
+        else:
+            self.H = H
+
+        if sc_ops:
+            msg = ("The sc_ops format is not valid. Options are "
+                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
+            try:
+                self.sc_ops = [QobjEvo(op, args=args, tlist=times)
+                               for op in sc_ops]
+            except Exception as e:
+                raise ValueError(msg + str(e)) from e
+        else:
+            self.sc_ops = sc_ops
+
+        if c_ops:
+            msg = ("The c_ops format is not valid. Options are "
+                   "[ Qobj / QobjEvo / [Qobj, coeff]]. ")
+            try:
+                self.c_ops = [QobjEvo(op, args=args, tlist=times)
+                              for op in c_ops]
+            except Exception as e:
+                raise ValueError(msg + str(e)) from e
+        else:
+            self.c_ops = c_ops
+
+        self.state0 = state0
+        self.rho0 = stack_columns(state0.full()).ravel()
+
+        # Observation
+
+        for e_op in e_ops:
+            if (
+                isinstance(e_op, Qobj)
+                and self.H is not None
+                and e_op.dims[1] != self.H.dims[0]
+            ):
+                raise TypeError(f"e_ops dims ({e_op.dims}) are not compatible "
+                                f"with the system's ({self.H.dims})")
+        self.e_ops = e_ops
+        self.m_ops = m_ops
+        self.store_measurement = store_measurement
+        self.store_all_expect = store_all_expect
+        self.store_states = options['store_states']
+        self.dW_factors = dW_factors
+
+        # Solver
+        self.solver = solver
+        self.method = method
+        if normalize is None and me:
+            self.normalize = 0
+        elif normalize is None and not me:
+            self.normalize = 1
+        elif normalize:
+            self.normalize = 1
+        else:
+            self.normalize = 0
+
+        self.times = times
+        self.nsubsteps = nsubsteps
+        self.dt = (times[1] - times[0]) / self.nsubsteps
+        self.ntraj = ntraj
+        if tol is not None:
+            self.tol = tol
+        elif "tol" in args:
+            self.tol = args["tol"]
+        else:
+            self.tol = 1e-7
+
+        # Noise
+        if noise is not None:
+            if isinstance(noise, int):
+                # noise contain a seed
+                np.random.seed(noise)
+                noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
+            noise = np.array(noise)
+            if len(noise.shape) == 1:
+                if noise.shape[0] < ntraj:
+                    raise ValueError("'noise' does not have enought seeds " +
+                                     "len(noise) >= ntraj")
+                # numpy seed must be between 0 and 2**32-1
+                # 'u4': unsigned 32bit int
+                self.noise = noise.astype("u4")
+                self.noise_type = 0
+
+            elif len(noise.shape) == 4:
+                # taylor case not included
+                dw_len = (2 if method == "heterodyne" else 1)
+                dw_len_str = (" * 2" if method == "heterodyne" else "")
+                msg = "Incorrect shape for 'noise': "
+                if noise.shape[0] < ntraj:
+                    raise ValueError(msg + "shape[0] >= ntraj")
+                if noise.shape[1] < len(times):
+                    raise ValueError(msg + "shape[1] >= len(times)")
+                if noise.shape[2] < nsubsteps:
+                    raise ValueError(msg + "shape[2] >= nsubsteps")
+                if noise.shape[3] < len(self.sc_ops) * dw_len:
+                    raise ValueError(msg + "shape[3] >= len(self.sc_ops)" +
+                                     dw_len_str)
+                self.noise_type = 1
+                self.noise = noise
+
+        else:
+            self.noise = np.random.randint(0, 2**32, ntraj, dtype=np.uint32)
+            self.noise_type = 0
+
+        # Map
+        self.progress_bar = progress_bar
+        if self.ntraj > 1 and map_func:
+            self.map_func = map_func
+        else:
+            self.map_func = serial_map
+        self.map_kwargs = map_kwargs if map_kwargs is not None else {}
+
+        # Other
+        self.options = options
+        self.args = args
+        self.set_solver()
+        self.p = noiseDepth
+
+    def set_solver(self):
+        if self.solver in ['euler-maruyama', 'euler', 50, 0.5]:
+            self.solver_code = 50
+            self.solver = 'euler-maruyama'
+        elif self.solver in ['platen', 'platen1', 'explicit1', 100]:
+            self.solver_code = 100
+            self.solver = 'platen'
+        elif self.solver in ['pred-corr', 'predictor-corrector',
+                             'pc-euler', 101]:
+            self.solver_code = 101
+            self.solver = 'pred-corr'
+        elif self.solver in ['milstein', 102, 1.0]:
+            self.solver_code = 102
+            self.solver = 'milstein'
+        elif self.solver in ['milstein-imp', 103]:
+            self.solver_code = 103
+            self.solver = 'milstein-imp'
+        elif self.solver in ['pred-corr-2', 'pc-euler-2', 'pc-euler-imp', 104]:
+            self.solver_code = 104
+            self.solver = 'pred-corr-2'
+        elif self.solver in ['Rouchon', 'rouchon', 120]:
+            self.solver_code = 120
+            self.solver = 'rouchon'
+            if not all((op.isconstant for op in self.sc_ops)):
+                raise ValueError("Rouchon only works with constant sc_ops")
+        elif self.solver in ['platen15', 'explicit1.5', 'explicit15', 150]:
+            self.solver_code = 150
+            self.solver = 'explicit1.5'
+        elif self.solver in ['taylor15', 'taylor1.5', None, 1.5, 152]:
+            self.solver_code = 152
+            self.solver = 'taylor1.5'
+        elif self.solver in ['taylor15-imp', 'taylor1.5-imp', 153]:
+            self.solver_code = 153
+            self.solver = 'taylor1.5-imp'
+        elif self.solver in ['taylor2.0', 'taylor20', 2.0, 202]:
+            self.solver_code = 202
+            self.solver = 'taylor2.0'
+            if not len(self.sc_ops) == 1 or \
+                    not self.sc_ops[0].isconstant or \
+                    not self.method == "homodyne":
+                raise ValueError(
+                    "Taylor2.0 only works with 1 constant sc_ops and for"
+                    " homodyne method"
+                )
+        else:
+            known = [
+                None, 'euler-maruyama', 'platen', 'pc-euler', 'pc-euler-imp',
+                'milstein', 'milstein-imp', 'rouchon', 'taylor1.5',
+                'taylor1.5-imp', 'explicit1.5', 'taylor2.0',
+            ]
+            raise ValueError("The solver should be one of {!r}".format(known))
+
+
+class StochasticSolverOptionsPhoto(StochasticSolverOptions):
+    """
+    Attributes
+    ----------
+
+    solver : string
+        Name of the solver method to use for solving the evolution
+        of the system.*
+        order 1 algorithms: 'euler'
+        order 2 algorithms: 'pred-corr'
+        In photocurrent evolution
+    """
+    def set_solver(self):
+        if self.solver in [None, 'euler', 1, 60]:
+            self.solver_code = 60
+            self.solver = 'euler'
+        elif self.solver in ['pred-corr', 'predictor-corrector', 110, 2]:
+            self.solver_code = 110
+            self.solver = 'pred-corr'
+        else:
+            raise Exception("The solver should be one of " +
+                            "[None, 'euler', 'predictor-corrector']")
+
+
+def smesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
+             _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic master equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj`
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+    if "method" in kwargs and kwargs["method"] == "photocurrent":
+        print("stochastic solver with photocurrent method has been moved to "
+              "it's own function: photocurrent_mesolve")
+        return photocurrent_mesolve(H, rho0, times, c_ops=c_ops, sc_ops=sc_ops,
+                                    e_ops=e_ops, _safe_mode=_safe_mode,
+                                    args=args, **kwargs)
+    if isket(rho0):
+        rho0 = ket2dm(rho0)
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(True, H=H, state0=rho0, times=times,
+                                  c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
+                                  args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.solver_code == 120:
+        return _positive_map(sso, e_ops_dict)
+
+    sso.LH = liouvillian(sso.H, c_ops=sso.sc_ops + sso.c_ops) * sso.dt
+    if sso.method == 'homodyne' or sso.method is None:
+        if sso.m_ops is None:
+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+        sso.sops = [spre(op) + spost(op.dag()) for op in sso.sc_ops]
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [1] * len(sso.m_ops)
+        elif len(sso.dW_factors) != len(sso.m_ops):
+            raise Exception("The len of dW_factors is not the same as m_ops")
+
+    elif sso.method == 'heterodyne':
+        if sso.m_ops is None:
+            m_ops = []
+        sso.sops = []
+        for c in sso.sc_ops:
+            if sso.m_ops is None:
+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+            sso.sops += [(spre(c) + spost(c.dag())) / np.sqrt(2),
+                         (spre(c) - spost(c.dag())) * -1j / np.sqrt(2)]
+        sso.m_ops = m_ops
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
+        elif len(sso.dW_factors) == len(sso.m_ops):
+            pass
+        elif len(sso.dW_factors) == len(sso.sc_ops):
+            dW_factors = []
+            for fact in sso.dW_factors:
+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+            sso.dW_factors = dW_factors
+        elif len(sso.dW_factors) != len(sso.m_ops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == "photocurrent":
+        raise NotImplementedError("Moved to 'photocurrent_mesolve'")
+
+    else:
+        raise Exception("The method must be one of None, homodyne, heterodyne")
+
+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+
+    if sso.solver_code in [103, 153]:
+        sso.imp = (1 - sso.LH * 0.5).to(_data.CSR)
+
+    sso.solver_obj = SMESolver
+    sso.solver_name = "smesolve_" + sso.solver
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+    return res
+
+
+def ssesolve(H, psi0, times, sc_ops=[], e_ops=[],
+             _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic schrodinger equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    psi0 : :class:`qutip.Qobj`
+        State vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj`
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if "method" in kwargs and kwargs["method"] == "photocurrent":
+        print("stochastic solver with photocurrent method has been moved to "
+              "it's own function: photocurrent_sesolve")
+        return photocurrent_sesolve(H, psi0, times, c_ops=c_ops,
+                                    e_ops=e_ops, _safe_mode=_safe_mode,
+                                    args=args, **kwargs)
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptions(False, H=H, state0=psi0, times=times,
+                                  sc_ops=sc_ops, e_ops=e_ops,
+                                  args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.solver_code == 120:
+        raise Exception("rouchon only work with smesolve")
+
+    if sso.method == 'homodyne' or sso.method is None:
+        if sso.m_ops is None:
+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+        sso.sops = [[op, op + op.dag()] for op in sso.sc_ops]
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [1] * len(sso.sops)
+        elif len(sso.dW_factors) != len(sso.sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == 'heterodyne':
+        if sso.m_ops is None:
+            m_ops = []
+        sso.sops = []
+        for c in sso.sc_ops:
+            if sso.m_ops is None:
+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+            c1 = c / np.sqrt(2)
+            c2 = c * (-1j / np.sqrt(2))
+            sso.sops += [[c1, c1 + c1.dag()],
+                         [c2, c2 + c2.dag()]]
+        sso.m_ops = m_ops
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [np.sqrt(2)] * len(sso.sops)
+        elif len(sso.dW_factors) == len(sso.sc_ops):
+            dW_factors = []
+            for fact in sso.dW_factors:
+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+            sso.dW_factors = dW_factors
+        elif len(sso.dW_factors) != len(sso.sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == "photocurrent":
+        NotImplementedError("Moved to 'photocurrent_sesolve'")
+
+    else:
+        raise Exception("The method must be one of None, homodyne, heterodyne")
+
+    sso.LH = sso.H * (-1j * sso.dt)
+    for ops in sso.sops:
+        sso.LH += (-0.5 * sso.dt) * ops[0].dag() @ ops[0]
+
+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+
+    sso.solver_obj = SSESolver
+    sso.solver_name = "ssesolve_" + sso.solver
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def _positive_map(sso, e_ops_dict):
+    if sso.method == 'homodyne' or sso.method is None:
+        sops = sso.sc_ops
+        if sso.m_ops is None:
+            sso.m_ops = [op + op.dag() for op in sso.sc_ops]
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [1] * len(sops)
+        elif len(sso.dW_factors) != len(sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    elif sso.method == 'heterodyne':
+        if sso.m_ops is None:
+            m_ops = []
+        sops = []
+        for c in sso.sc_ops:
+            if sso.m_ops is None:
+                m_ops += [c + c.dag(), -1j * (c - c.dag())]
+            sops += [c / np.sqrt(2), -1j / np.sqrt(2) * c]
+        sso.m_ops = m_ops
+        if not isinstance(sso.dW_factors, list):
+            sso.dW_factors = [np.sqrt(2)] * len(sops)
+        elif len(sso.dW_factors) == len(sso.sc_ops):
+            dW_factors = []
+            for fact in sso.dW_factors:
+                dW_factors += [np.sqrt(2) * fact, np.sqrt(2) * fact]
+            sso.dW_factors = dW_factors
+        elif len(sso.dW_factors) != len(sops):
+            raise Exception("The len of dW_factors is not the same as sc_ops")
+    else:
+        raise Exception("The method must be one of homodyne or heterodyne")
+
+    LH = 1 - (sso.H * 1j * sso.dt)
+    sso.pp = spre(sso.H) * 0
+    sso.sops = []
+    sso.preops = []
+    sso.postops = []
+    sso.preops2 = []
+    sso.postops2 = []
+
+    def _prespostdag(op):
+        return spre(op) * spost(op.dag())
+
+    for op in sso.c_ops:
+        LH += op.dag() @ op * (-sso.dt * 0.5)
+        sso.pp += spre(op) * spost(op.dag()) * sso.dt
+
+    for i, op in enumerate(sops):
+        LH += (-sso.dt * 0.5) * op.dag() @ op
+        sso.sops += [(spre(op) + spost(op.dag())) * sso.dt]
+        sso.preops += [spre(op)]
+        sso.postops += [spost(op.dag())]
+        for op2 in sops[i:]:
+            sso.preops2 += [spre(op * op2)]
+            sso.postops2 += [spost(op.dag() * op2.dag())]
+
+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+    sso.preLH = spre(LH)
+    sso.postLH = spost(LH.dag())
+
+    sso.solver_obj = PmSMESolver
+    sso.solver_name = "smesolve_" + sso.solver
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def photocurrent_mesolve(H, rho0, times, c_ops=[], sc_ops=[], e_ops=[],
+                         _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic master equation using the photocurrent method.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isket(rho0):
+        rho0 = ket2dm(rho0)
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptionsPhoto(True, H=H, state0=rho0, times=times,
+                                       c_ops=c_ops, sc_ops=sc_ops, e_ops=e_ops,
+                                       args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.m_ops is None:
+        sso.m_ops = [op * 0 for op in sso.sc_ops]
+    if not isinstance(sso.dW_factors, list):
+        sso.dW_factors = [1] * len(sso.sc_ops)
+    elif len(sso.dW_factors) != len(sso.sc_ops):
+        raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    sso.solver_obj = PcSMESolver
+    sso.solver_name = "photocurrent_mesolve"
+    sso.LH = liouvillian(sso.H, c_ops=sso.c_ops) * sso.dt
+
+    def _prespostdag(op):
+        return spre(op) * spost(op.dag())
+
+    sso.sops = [[spre(op.dag() @ op) + spost(op.dag() @ op),
+                 spre(op.dag() @ op),
+                 spre(op) * spost(op.dag())] for op in sso.sc_ops]
+    sso.ce_ops = [QobjEvo(spre(op)) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(spre(op)) for op in sso.m_ops]
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def photocurrent_sesolve(H, psi0, times, sc_ops=[], e_ops=[],
+                         _safe_mode=True, args={}, **kwargs):
+    """
+    Solve stochastic schrodinger equation using the photocurrent method.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`, or time dependent system.
+        System Hamiltonian.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    sc_ops : list of :class:`qutip.Qobj`, or time dependent Qobjs.
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+        Can depend on time, see StochasticSolverOptions help for format.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = list(e_ops.values())
+    else:
+        e_ops_dict = None
+
+    sso = StochasticSolverOptionsPhoto(False, H=H, state0=psi0, times=times,
+                                       sc_ops=sc_ops, e_ops=e_ops,
+                                       args=args, **kwargs)
+
+    if _safe_mode:
+        _safety_checks(sso)
+
+    if sso.m_ops is None:
+        sso.m_ops = [op * 0 for op in sso.sc_ops]
+    if not isinstance(sso.dW_factors, list):
+        sso.dW_factors = [1] * len(sso.sc_ops)
+    elif len(sso.dW_factors) != len(sso.sc_ops):
+        raise Exception("The len of dW_factors is not the same as sc_ops")
+
+    sso.solver_obj = PcSSESolver
+    sso.solver_name = "photocurrent_sesolve"
+    sso.sops = [[op, op.dag() @ op] for op in sso.sc_ops]
+    sso.LH = sso.H * (-1j*sso.dt)
+    for ops in sso.sops:
+        sso.LH += ops[0].dag() @ ops[0] * (-0.5 * sso.dt)
+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+    sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+    res.num_collapse = [np.count_nonzero(noise) for noise in res.noise]
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def general_stochastic(state0, times, d1, d2, e_ops=[], m_ops=[],
+                       _safe_mode=True, len_d2=1, args={}, **kwargs):
+    """
+    Solve stochastic general equation. Dispatch to specific solvers
+    depending on the value of the `solver` keyword argument.
+
+
+    Parameters
+    ----------
+
+    state0 : :class:`qutip.Qobj`
+        Initial state vector (ket) or density matrix as a vector.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    d1 : function, callable class
+        Function representing the deterministic evolution of the system.
+
+        def d1(time (double), state (as a np.array vector)):
+            return 1d np.array
+
+    d2 : function, callable class
+        Function representing the stochastic evolution of the system.
+
+        def d2(time (double), state (as a np.array vector)):
+            return 2d np.array (N_sc_ops, len(state0))
+
+    len_d2 : int
+        Number of output vector produced by d2
+
+    e_ops : list of :class:`qutip.Qobj`
+        single operator or list of operators for which to evaluate
+        expectation values.
+        Must be a superoperator if the state vector is a density matrix.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+        An instance of the class :class:`qutip.solver.Result`.
+    """
+
+    if isinstance(e_ops, dict):
+        e_ops_dict = e_ops
+        e_ops = [e for e in e_ops.values()]
+    else:
+        e_ops_dict = None
+
+    if "solver" not in kwargs:
+        kwargs["solver"] = 50
+
+    sso = StochasticSolverOptions(False, H=None, state0=state0, times=times,
+                                  e_ops=e_ops, args=args, **kwargs)
+    if sso.solver_code not in [50, 100, 150]:
+        raise ValueError("Only Euler, platen, platen15 can be " +
+                         "used for the general stochastic solver.")
+
+    sso.d1 = d1
+    sso.d2 = d2
+    if _safe_mode:
+        # This state0_vec is computed as stack_columns(state0.full()).ravel()
+        # in the sso init.
+        state0_vec = sso.rho0
+        l_vec = state0_vec.shape[0]
+        try:
+            out_d1 = d1(0., sso.rho0)
+        except Exception as e:
+            raise RuntimeError("Safety check: d1(0., state0_vec) failed.:\n" +
+                               str(e)) from e
+        try:
+            out_d2 = d2(0., sso.rho0)
+        except Exception as e:
+            raise RuntimeError("Safety check: d2(0., state0_vec) failed:\n" +
+                               str(e)) from e
+
+        msg_d1 = ("d1 must return an 1d numpy array with the same number "
+                  "of elements as the initial state as a vector.")
+        if not isinstance(out_d1, np.ndarray):
+            raise TypeError(msg_d1)
+        if (out_d1.ndim != 1
+                or out_d1.shape[0] != l_vec or len(out_d1.shape) != 1):
+            raise ValueError(msg_d1)
+
+        msg_d2 = ("Safety check: d2 must return a 2d numpy array "
+                  "with the shape (len_d2, len(state0_vec) ).")
+        if not isinstance(out_d2, np.ndarray):
+            raise TypeError(msg_d2)
+        if (out_d2.ndim != 2
+                or out_d2.shape[1] != l_vec or out_d2.shape[0] != len_d2):
+            raise ValueError(msg_d2)
+        if out_d1.dtype != np.dtype('complex128') or \
+           out_d2.dtype != np.dtype('complex128'):
+            raise ValueError("Safety check: d1 and d2 must return " +
+                             "complex numpy array.")
+        msg_e_ops = ("Safety check: The shape of the e_ops "
+                     "does not fit the intial state.")
+        for op in sso.e_ops:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise ValueError(msg_e_ops)
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise ValueError(msg_e_ops +
+                                     " Expecting e_ops as superoperators.")
+
+    sso.m_ops = []
+    sso.cm_ops = []
+    if sso.store_measurement:
+        if not m_ops:
+            raise ValueError("General stochastic needs explicit " +
+                             "m_ops to store measurement.")
+        sso.m_ops = m_ops
+        sso.cm_ops = [QobjEvo(op) for op in sso.m_ops]
+        if sso.dW_factors is None:
+            sso.dW_factors = [1.] * len(sso.m_ops)
+        elif len(sso.dW_factors) == 1:
+            sso.dW_factors = sso.dW_factors * len(sso.m_ops)
+        elif len(sso.dW_factors) != len(sso.m_ops):
+            raise ValueError("The number of dW_factors must fit" +
+                             " the number of m_ops.")
+
+    if sso.dW_factors is None:
+        sso.dW_factors = [1.] * len_d2
+    sso.sops = [None] * len_d2
+    sso.ce_ops = [QobjEvo(op) for op in sso.e_ops]
+
+    sso.solver_obj = GenericSSolver
+    sso.solver_name = "general_stochastic_solver_" + sso.solver
+
+    ssolver = GenericSSolver()
+    # ssolver.set_data(sso)
+    ssolver.set_solver(sso)
+
+    res = _sesolve_generic(sso, sso.options, sso.progress_bar)
+
+    if e_ops_dict:
+        res.expect = {e: res.expect[n]
+                      for n, e in enumerate(e_ops_dict.keys())}
+
+    return res
+
+
+def _safety_checks(sso):
+    l_vec = sso.rho0.shape[0]
+    if sso.H.issuper:
+        if not sso.me:
+            raise ValueError(
+                "Given a Liouvillian for a Schrödinger equation problem."
+            )
+        shape_op = sso.H.shape
+        if shape_op[0] != l_vec or shape_op[1] != l_vec:
+            raise Exception("The size of the hamiltonian does "
+                            "not fit the intial state")
+    else:
+        shape_op = sso.H.shape
+        if sso.me:
+            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                raise Exception("The size of the hamiltonian does "
+                                "not fit the intial state")
+        else:
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the hamiltonian does "
+                                "not fit the intial state")
+
+    for op in sso.sc_ops:
+        if op.issuper:
+            if not sso.me:
+                raise ValueError(
+                    "Given a Liouvillian for a Schrödinger equation problem."
+                )
+            shape_op = op.shape
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the sc_ops does "
+                                "not fit the intial state")
+        else:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise Exception("The size of the sc_ops does "
+                                    "not fit the intial state")
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise Exception("The size of the sc_ops does "
+                                    "not fit the intial state")
+
+    for op in sso.c_ops:
+        if op.issuper:
+            if not sso.me:
+                raise ValueError(
+                    "Given a Liouvillian for a Schrödinger equation problem."
+                )
+            shape_op = op.shape
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the c_ops does "
+                                "not fit the intial state")
+        else:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise Exception("The size of the c_ops does "
+                                    "not fit the intial state")
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise Exception("The size of the c_ops does "
+                                    "not fit the intial state")
+
+    for op in sso.e_ops:
+        shape_op = op.shape
+        if sso.me:
+            if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                raise Exception("The size of the e_ops does "
+                                "not fit the intial state")
+        else:
+            if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                raise Exception("The size of the e_ops does "
+                                "not fit the intial state")
+
+    if sso.m_ops is not None:
+        for op in sso.m_ops:
+            shape_op = op.shape
+            if sso.me:
+                if shape_op[0]**2 != l_vec or shape_op[1]**2 != l_vec:
+                    raise Exception("The size of the m_ops does "
+                                    "not fit the intial state")
+            else:
+                if shape_op[0] != l_vec or shape_op[1] != l_vec:
+                    raise Exception("The size of the m_ops does "
+                                    "not fit the intial state")
+
+
+def _sesolve_generic(sso, options, progress_bar):
+    """
+    Internal function. See smesolve.
+    """
+    res = Result()
+    res.times = sso.times
+    res.expect = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
+    res.ss = np.zeros((len(sso.e_ops), len(sso.times)), dtype=complex)
+    res.measurement = []
+    res.solver = sso.solver_name
+    res.ntraj = sso.ntraj
+    res.num_expect = len(sso.e_ops)
+
+    nt = sso.ntraj
+    task = _single_trajectory
+    map_kwargs = {'progress_bar': sso.progress_bar}
+    map_kwargs.update(sso.map_kwargs)
+    task_args = (sso,)
+    task_kwargs = {}
+
+    results = sso.map_func(task, list(range(sso.ntraj)),
+                           task_args, task_kwargs, **map_kwargs)
+    noise = []
+    for result in results:
+        states_list, dW, m, expect = result
+        res.states.append(states_list)
+        noise.append(dW)
+        res.measurement.append(m)
+        res.expect += expect
+        res.ss += expect * expect
+    res.noise = np.stack(noise)
+
+    if sso.store_all_expect:
+        paths_expect = []
+        for result in results:
+            paths_expect.append(result[3])
+        res.runs_expect = np.stack(paths_expect)
+
+    # average density matrices (vectorized maybe)
+    # ajgpitch 2019-10-25: np.any(res.states) seems to error
+    # I guess there may be a potential exception if there are no states?
+    # store individual trajectory states
+    res.traj_states = res.states
+    res.avg_states = None
+    if options['average_states'] and options['store_states']:
+        avg_states_list = []
+        for n in range(len(res.times)):
+            tslot_states = [res.states[mm][n].data for mm in range(nt)]
+            if len(tslot_states) > 0:
+                state = Qobj(np.sum(tslot_states),
+                             dims=res.states[0][n].dims).unit()
+                avg_states_list.append(state)
+        # store average states
+        res.states = res.avg_states = avg_states_list
+
+    # average
+    res.expect = res.expect / nt
+
+    # standard error
+    if nt > 1:
+        res.se = (res.ss - nt * (res.expect ** 2)) / (nt * (nt - 1))
+    else:
+        res.se = None
+
+    # convert complex data to real if hermitian
+    res.expect = [np.real(res.expect[n, :])
+                  if e.isherm else res.expect[n, :]
+                  for n, e in enumerate(sso.e_ops)]
+
+    return res
+
+
+def _single_trajectory(i, sso):
+    # Only one step?
+    ssolver = sso.solver_obj()
+    ssolver.set_solver(sso)
+    result = ssolver.cy_sesolve_single_trajectory(i)
+    return result
+
+
+# The code for ssepdpsolve have been moved to the file pdpsolve.
+# The call is still in stochastic for consistance.
+def ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for wavefunction
+    evolution. For most purposes, use :func:`qutip.mcsolve` instead for quantum
+    trajectory simulations.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    psi0 : :class:`qutip.Qobj`
+        Initial state vector (ket).
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+    return main_ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)
+
+
+# The code for smepdpsolve have been moved to the file pdpsolve.
+# The call is still in stochastic for consistance.
+def smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs):
+    """
+    A stochastic (piecewse deterministic process) PDP solver for density matrix
+    evolution.
+
+    Parameters
+    ----------
+
+    H : :class:`qutip.Qobj`
+        System Hamiltonian.
+
+    rho0 : :class:`qutip.Qobj`
+        Initial density matrix.
+
+    times : *list* / *array*
+        List of times for :math:`t`. Must be uniformly spaced.
+
+    c_ops : list of :class:`qutip.Qobj`
+        Deterministic collapse operator which will contribute with a standard
+        Lindblad type of dissipation.
+
+    sc_ops : list of :class:`qutip.Qobj`
+        List of stochastic collapse operators. Each stochastic collapse
+        operator will give a deterministic and stochastic contribution
+        to the eqaution of motion according to how the d1 and d2 functions
+        are defined.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function single
+        single operator or list of operators for which to evaluate
+        expectation values.
+
+    kwargs : *dictionary*
+        Optional keyword arguments. See
+        :class:`qutip.stochastic.StochasticSolverOptions`.
+
+    Returns
+    -------
+
+    output: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`.
+
+    """
+    return main_smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)
diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
index 0512198f45..99d84ccd88 100644
--- a/qutip/solver/__init__.py
+++ b/qutip/solver/__init__.py
@@ -1,18 +1,18 @@
-from .result import *
-from .options import *
-import qutip.solver.integrator
-from .integrator import IntegratorException
-from .sesolve import *
-from .mesolve import *
-from .mcsolve import *
-from .propagator import *
-from .scattering import *
-from .correlation import *
-from .spectrum import *
-from .floquet import *
-from .floquet_bwcomp import *
-from .steadystate import *
-from .countstat import *
-from .brmesolve import *
-from .krylovsolve import *
-from .parallel import *
+from .result import *
+from .options import *
+import qutip.solver.integrator
+from .integrator import IntegratorException
+from .sesolve import *
+from .mesolve import *
+from .mcsolve import *
+from .propagator import *
+from .scattering import *
+from .correlation import *
+from .spectrum import *
+from .floquet import *
+from .floquet_bwcomp import *
+from .steadystate import *
+from .countstat import *
+from .brmesolve import *
+from .krylovsolve import *
+from .parallel import *
diff --git a/qutip/solver/brmesolve.py b/qutip/solver/brmesolve.py
index 8da774942d..7bfc8b27ad 100644
--- a/qutip/solver/brmesolve.py
+++ b/qutip/solver/brmesolve.py
@@ -1,362 +1,362 @@
-"""
-This module provides solvers for the Lindblad master equation and von Neumann
-equation.
-"""
-
-__all__ = ['brmesolve', 'BRSolver']
-
-import numpy as np
-import inspect
-from time import time
-from .. import Qobj, QobjEvo, coefficient, Coefficient
-from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
-from ..core.cy.coefficient import InterCoefficient
-from ..core import data as _data
-from .solver_base import Solver
-from .options import _SolverOptions
-
-
-def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
-              args={}, sec_cutoff=0.1, options=None):
-    """
-    Solves for the dynamics of a system using the Bloch-Redfield master
-    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
-    their associated spectral functions, as well as possible Lindblad collapse
-    operators.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    psi0: Qobj
-        Initial density matrix or state vector (ket).
-
-    tlist : array_like
-        List of times for evaluating evolution
-
-    a_ops : list of (a_op, spectra)
-        Nested list of system operators that couple to the environment,
-        and the corresponding bath spectra.
-
-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-            The operator coupling to the environment. Must be hermitian.
-
-        spectra : :class:`Coefficient`, str, func
-            The corresponding bath spectral responce.
-            Can be a `Coefficient` using an 'w' args, a function of the
-            frequence or a string. Coefficient build from a numpy array are
-            understood as a function of ``w`` instead of ``t``. Function are
-            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
-
-            The spectra function can depend on ``t`` if the corresponding
-            ``a_op`` is a :class:`QobjEvo`.
-
-        Example:
-
-        .. code-block::
-
-            a_ops = [
-                (a+a.dag(), ('w>0', args={"w": 0})),
-                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
-                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-            ]
-
-        .. note:
-            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
-                ``spline = qutip.coefficient(array, tlist=times)``
-
-            Whether the ``a_ops`` is time dependent is decided by the type of
-            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
-            of the spectra.
-
-    e_ops : list of :class:`Qobj` / callback function
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation
-
-    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
-        List of collapse operators.
-
-    args : dict
-        Dictionary of parameters for time-dependent Hamiltonians and
-        collapse operators. The key ``w`` is reserved for the spectra function.
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - tensor_type : str ['sparse', 'dense', 'data']
-          Which data type to use when computing the brtensor.
-          With a cutoff 'sparse' is usually the most efficient.
-        - sparse_eigensolver : bool {False}
-          Whether to use the sparse eigensolver
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.solver.Result`
-
-        An instance of the class :class:`qutip.solver.Result`, which contains
-        either an array of expectation values, for operators given in e_ops,
-        or a list of states for the times specified by `tlist`.
-
-    .. note:
-        The option ``operator_data_type`` is used to determine in which format
-        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
-        for dense array. With 'data', it will try to use the same data type as
-        the ``a_ops``, but it is usually less efficient than manually choosing
-        it.
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-
-    c_ops = c_ops if c_ops is not None else []
-    if not isinstance(c_ops, (list, tuple)):
-        c_ops = [c_ops]
-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-
-    new_a_ops = []
-    for (a_op, spectra) in a_ops:
-        aop = QobjEvo(a_op, args=args, tlist=tlist)
-        if isinstance(spectra, str):
-            new_a_ops.append(
-                (aop, coefficient(spectra, args={**args, 'w':0})))
-        elif isinstance(spectra, InterCoefficient):
-            new_a_ops.append((aop, SpectraCoefficient(spectra)))
-        elif isinstance(spectra, Coefficient):
-            new_a_ops.append((aop, spectra))
-        elif callable(spectra):
-            sig = inspect.signature(spectra)
-            if tuple(sig.parameters.keys()) == ("w",):
-                spec = SpectraCoefficient(coefficient(spectra))
-            else:
-                spec = coefficient(spectra, args={**args, 'w':0})
-            new_a_ops.append((aop, spec))
-        else:
-            raise TypeError("a_ops's spectra not known")
-
-    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
-
-    return solver.run(psi0, tlist, e_ops=e_ops)
-
-
-class BRSolver(Solver):
-    """
-    Bloch Redfield equation evolution of a density matrix for a given
-    Hamiltonian and set of bath coupling operators.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    a_ops : list of (a_op, spectra)
-        Nested list of system operators that couple to the environment,
-        and the corresponding bath spectra.
-
-        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
-            The operator coupling to the environment. Must be hermitian.
-
-        spectra : :class:`Coefficient`
-            The corresponding bath spectra. As a `Coefficient` using an 'w'
-            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
-            :class:`SpectraCoefficient` can be used to conver a coefficient
-            depending on ``t`` to one depending on ``w``.
-
-        Example:
-
-        .. code-block::
-
-            a_ops = [
-                (a+a.dag(), coefficient('w>0', args={'w':0})),
-                (QobjEvo([b+b.dag(), lambda t: ...]),
-                 coefficient(lambda t, w: ...), args={"w": 0}),
-                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
-            ]
-
-    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
-        Single collapse operator, or list of collapse operators, or a list
-        of Lindblad dissipator. None is equivalent to an empty list.
-
-    options : dict, optional
-        Options for the solver, see :obj:`BRSolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-
-    sec_cutoff : float {0.1}
-        Cutoff for secular approximation. Use ``-1`` if secular approximation
-        is not used when evaluating bath-coupling terms.
-
-    attributes
-    ----------
-    stats: dict
-        Diverse diagnostic statistics of the evolution.
-    """
-    name = "brmesolve"
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size":10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": False,
-        'method': 'adams',
-        'tensor_type': 'sparse',
-        'sparse_eigensolver': False,
-    }
-    _avail_integrators = {}
-
-    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
-        _time_start = time()
-
-        self.rhs = None
-        self.sec_cutoff = sec_cutoff
-        self.options = options
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-        H = QobjEvo(H)
-
-        c_ops = c_ops or []
-        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
-        for c_op in c_ops:
-            if not isinstance(c_op, (Qobj, QobjEvo)):
-                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
-
-        a_ops = a_ops or []
-        if not hasattr(a_ops, "__iter__"):
-            TypeError("`a_ops` must be a list of (operator, spectra)")
-        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
-            a_ops = [a_ops]
-        for oper, spectra in a_ops:
-            if not isinstance(oper, (Qobj, QobjEvo)):
-                raise TypeError("All `a_ops` operators "
-                                "must be a Qobj or QobjEvo")
-            if not isinstance(spectra, Coefficient):
-                raise TypeError("All `a_ops` spectra "
-                                "must be a Coefficient.")
-
-        self._system = H, a_ops, c_ops
-        self._num_collapse = len(c_ops)
-        self._num_a_ops = len(a_ops)
-        self.rhs = self._prepare_rhs()
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "solver": "Bloch Redfield Equation Evolution",
-            "init time": stats["init time"] + self._init_rhs_time,
-            "num_collapse": self._num_collapse,
-            "num_a_ops": self._num_a_ops,
-        })
-        return stats
-
-    def _prepare_rhs(self):
-        _time_start = time()
-        rhs = bloch_redfield_tensor(
-            *self._system,
-            fock_basis=True,
-            sec_cutoff=self.sec_cutoff,
-            sparse_eigensolver=self.options['sparse_eigensolver'],
-            br_dtype=self.options['tensor_type']
-        )
-        self._init_rhs_time = time() - _time_start
-        return rhs
-
-    @property
-    def options(self):
-        """
-        Options for bloch redfield solver:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        normalize_output: bool, default=False
-            Normalize output state to hide ODE numerical errors.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error if
-            not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size":10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
-            Which data type to use when computing the brtensor.
-            With a cutoff 'sparse' is usually the most efficient.
-
-        sparse_eigensolver: bool, default=False
-            Whether to use the sparse eigensolver
-
-        method: str, default="adams"
-            Which ODE integrator methods are supported.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Solver.options.fset(self, new_options)
-
-    def _apply_options(self, keys):
-        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
-        need_new_rhs &= (
-            'sparse_eigensolver' in keys or 'tensor_type' in keys
-        )
-        if need_new_rhs:
-            self.rhs = self._prepare_rhs()
-
-        if self._integrator is None or not keys:
-            pass
-        elif 'method' in keys or need_new_rhs:
-            state = self._integrator.get_state()
-            self._integrator = self._get_integrator()
-            self._integrator.set_state(*state)
-        else:
-            self._integrator.options = self._options
-            self._integrator.reset(hard=True)
+"""
+This module provides solvers for the Lindblad master equation and von Neumann
+equation.
+"""
+
+__all__ = ['brmesolve', 'BRSolver']
+
+import numpy as np
+import inspect
+from time import time
+from .. import Qobj, QobjEvo, coefficient, Coefficient
+from ..core.blochredfield import bloch_redfield_tensor, SpectraCoefficient
+from ..core.cy.coefficient import InterCoefficient
+from ..core import data as _data
+from .solver_base import Solver
+from .options import _SolverOptions
+
+
+def brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[],
+              args={}, sec_cutoff=0.1, options=None):
+    """
+    Solves for the dynamics of a system using the Bloch-Redfield master
+    equation, given an input Hamiltonian, Hermitian bath-coupling terms and
+    their associated spectral functions, as well as possible Lindblad collapse
+    operators.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    psi0: Qobj
+        Initial density matrix or state vector (ket).
+
+    tlist : array_like
+        List of times for evaluating evolution
+
+    a_ops : list of (a_op, spectra)
+        Nested list of system operators that couple to the environment,
+        and the corresponding bath spectra.
+
+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+            The operator coupling to the environment. Must be hermitian.
+
+        spectra : :class:`Coefficient`, str, func
+            The corresponding bath spectral responce.
+            Can be a `Coefficient` using an 'w' args, a function of the
+            frequence or a string. Coefficient build from a numpy array are
+            understood as a function of ``w`` instead of ``t``. Function are
+            expected to be of the signature ``f(w)`` or ``f(t, w, **args)``.
+
+            The spectra function can depend on ``t`` if the corresponding
+            ``a_op`` is a :class:`QobjEvo`.
+
+        Example:
+
+        .. code-block::
+
+            a_ops = [
+                (a+a.dag(), ('w>0', args={"w": 0})),
+                (QobjEvo(a+a.dag()), 'w > exp(-t)'),
+                (QobjEvo([b+b.dag(), lambda t: ...]), lambda w: ...)),
+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+            ]
+
+        .. note:
+            ``Cubic_Spline`` has been replaced by :class:`Coefficient`:
+                ``spline = qutip.coefficient(array, tlist=times)``
+
+            Whether the ``a_ops`` is time dependent is decided by the type of
+            the operator: :class:`Qobj` vs :class:`QobjEvo` instead of the type
+            of the spectra.
+
+    e_ops : list of :class:`Qobj` / callback function
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation
+
+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        List of collapse operators.
+
+    args : dict
+        Dictionary of parameters for time-dependent Hamiltonians and
+        collapse operators. The key ``w`` is reserved for the spectra function.
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - tensor_type : str ['sparse', 'dense', 'data']
+          Which data type to use when computing the brtensor.
+          With a cutoff 'sparse' is usually the most efficient.
+        - sparse_eigensolver : bool {False}
+          Whether to use the sparse eigensolver
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.solver.Result`
+
+        An instance of the class :class:`qutip.solver.Result`, which contains
+        either an array of expectation values, for operators given in e_ops,
+        or a list of states for the times specified by `tlist`.
+
+    .. note:
+        The option ``operator_data_type`` is used to determine in which format
+        the bloch redfield tensor is computed. Use 'csr' for sparse and 'dense'
+        for dense array. With 'data', it will try to use the same data type as
+        the ``a_ops``, but it is usually less efficient than manually choosing
+        it.
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+
+    c_ops = c_ops if c_ops is not None else []
+    if not isinstance(c_ops, (list, tuple)):
+        c_ops = [c_ops]
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+
+    new_a_ops = []
+    for (a_op, spectra) in a_ops:
+        aop = QobjEvo(a_op, args=args, tlist=tlist)
+        if isinstance(spectra, str):
+            new_a_ops.append(
+                (aop, coefficient(spectra, args={**args, 'w':0})))
+        elif isinstance(spectra, InterCoefficient):
+            new_a_ops.append((aop, SpectraCoefficient(spectra)))
+        elif isinstance(spectra, Coefficient):
+            new_a_ops.append((aop, spectra))
+        elif callable(spectra):
+            sig = inspect.signature(spectra)
+            if tuple(sig.parameters.keys()) == ("w",):
+                spec = SpectraCoefficient(coefficient(spectra))
+            else:
+                spec = coefficient(spectra, args={**args, 'w':0})
+            new_a_ops.append((aop, spec))
+        else:
+            raise TypeError("a_ops's spectra not known")
+
+    solver = BRSolver(H, new_a_ops, c_ops, sec_cutoff, options=options)
+
+    return solver.run(psi0, tlist, e_ops=e_ops)
+
+
+class BRSolver(Solver):
+    """
+    Bloch Redfield equation evolution of a density matrix for a given
+    Hamiltonian and set of bath coupling operators.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    a_ops : list of (a_op, spectra)
+        Nested list of system operators that couple to the environment,
+        and the corresponding bath spectra.
+
+        a_op : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`
+            The operator coupling to the environment. Must be hermitian.
+
+        spectra : :class:`Coefficient`
+            The corresponding bath spectra. As a `Coefficient` using an 'w'
+            args. Can depend on ``t`` only if a_op is a :class:`qutip.QobjEvo`.
+            :class:`SpectraCoefficient` can be used to conver a coefficient
+            depending on ``t`` to one depending on ``w``.
+
+        Example:
+
+        .. code-block::
+
+            a_ops = [
+                (a+a.dag(), coefficient('w>0', args={'w':0})),
+                (QobjEvo([b+b.dag(), lambda t: ...]),
+                 coefficient(lambda t, w: ...), args={"w": 0}),
+                (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
+            ]
+
+    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
+        Single collapse operator, or list of collapse operators, or a list
+        of Lindblad dissipator. None is equivalent to an empty list.
+
+    options : dict, optional
+        Options for the solver, see :obj:`BRSolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+
+    sec_cutoff : float {0.1}
+        Cutoff for secular approximation. Use ``-1`` if secular approximation
+        is not used when evaluating bath-coupling terms.
+
+    attributes
+    ----------
+    stats: dict
+        Diverse diagnostic statistics of the evolution.
+    """
+    name = "brmesolve"
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size":10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": False,
+        'method': 'adams',
+        'tensor_type': 'sparse',
+        'sparse_eigensolver': False,
+    }
+    _avail_integrators = {}
+
+    def __init__(self, H, a_ops, c_ops=None, sec_cutoff=0.1, *, options=None):
+        _time_start = time()
+
+        self.rhs = None
+        self.sec_cutoff = sec_cutoff
+        self.options = options
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+        H = QobjEvo(H)
+
+        c_ops = c_ops or []
+        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
+        for c_op in c_ops:
+            if not isinstance(c_op, (Qobj, QobjEvo)):
+                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
+
+        a_ops = a_ops or []
+        if not hasattr(a_ops, "__iter__"):
+            TypeError("`a_ops` must be a list of (operator, spectra)")
+        if a_ops and isinstance(a_ops[0], (Qobj, QobjEvo)):
+            a_ops = [a_ops]
+        for oper, spectra in a_ops:
+            if not isinstance(oper, (Qobj, QobjEvo)):
+                raise TypeError("All `a_ops` operators "
+                                "must be a Qobj or QobjEvo")
+            if not isinstance(spectra, Coefficient):
+                raise TypeError("All `a_ops` spectra "
+                                "must be a Coefficient.")
+
+        self._system = H, a_ops, c_ops
+        self._num_collapse = len(c_ops)
+        self._num_a_ops = len(a_ops)
+        self.rhs = self._prepare_rhs()
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "solver": "Bloch Redfield Equation Evolution",
+            "init time": stats["init time"] + self._init_rhs_time,
+            "num_collapse": self._num_collapse,
+            "num_a_ops": self._num_a_ops,
+        })
+        return stats
+
+    def _prepare_rhs(self):
+        _time_start = time()
+        rhs = bloch_redfield_tensor(
+            *self._system,
+            fock_basis=True,
+            sec_cutoff=self.sec_cutoff,
+            sparse_eigensolver=self.options['sparse_eigensolver'],
+            br_dtype=self.options['tensor_type']
+        )
+        self._init_rhs_time = time() - _time_start
+        return rhs
+
+    @property
+    def options(self):
+        """
+        Options for bloch redfield solver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        normalize_output: bool, default=False
+            Normalize output state to hide ODE numerical errors.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error if
+            not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size":10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        tensor_type: str ['sparse', 'dense', 'data'], default="sparse"
+            Which data type to use when computing the brtensor.
+            With a cutoff 'sparse' is usually the most efficient.
+
+        sparse_eigensolver: bool, default=False
+            Whether to use the sparse eigensolver
+
+        method: str, default="adams"
+            Which ODE integrator methods are supported.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Solver.options.fset(self, new_options)
+
+    def _apply_options(self, keys):
+        need_new_rhs = self.rhs is not None and not self.rhs.isconstant
+        need_new_rhs &= (
+            'sparse_eigensolver' in keys or 'tensor_type' in keys
+        )
+        if need_new_rhs:
+            self.rhs = self._prepare_rhs()
+
+        if self._integrator is None or not keys:
+            pass
+        elif 'method' in keys or need_new_rhs:
+            state = self._integrator.get_state()
+            self._integrator = self._get_integrator()
+            self._integrator.set_state(*state)
+        else:
+            self._integrator.options = self._options
+            self._integrator.reset(hard=True)
diff --git a/qutip/solver/correlation.py b/qutip/solver/correlation.py
index e3be789f54..b05514c519 100644
--- a/qutip/solver/correlation.py
+++ b/qutip/solver/correlation.py
@@ -1,517 +1,517 @@
-__all__ = [
-    'correlation_3op',
-    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
-    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
-]
-
-import numpy as np
-import scipy.fftpack
-
-from ..core import (
-    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
-    tensor, qzero, expect
-)
-from .mesolve import MESolver
-from .mcsolve import MCSolver
-from .brmesolve import BRSolver
-from .heom.bofin_solvers import HEOMSolver
-
-from .steadystate import steadystate
-from ..ui.progressbar import progess_bars
-
-# -----------------------------------------------------------------------------
-# PUBLIC API
-# -----------------------------------------------------------------------------
-
-# low level correlation
-
-
-def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
-                       solver="me", reverse=False, args={},
-                       options={}):
-    r"""
-    Calculate the two-operator one-time correlation function:
-    :math:`\left<A(\tau)B(0)\right>`
-    along one time axis using the quantum regression theorem and the evolution
-    solver indicated by the `solver` parameter.
-
-    Parameters
-    ----------
-
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    reverse : bool {False}
-        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
-        :math:`\left<A(t+\tau)B(t)\right>`.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_vec : ndarray
-        An array of correlation values for the times specified by `taulist`.
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    if reverse:
-        A_op, B_op, C_op = a_op, b_op, 1
-    else:
-        A_op, B_op, C_op = 1, a_op, b_op
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-
-    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
-
-
-def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
-                       solver="me", reverse=False, args={},
-                       options={}):
-    r"""
-    Calculate the two-operator two-time correlation function:
-    :math:`\left<A(t+\tau)B(t)\right>`
-    along two time axes using the quantum regression theorem and the
-    evolution solver indicated by the ``solver`` parameter.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    tlist : array_like
-        List of times for :math:`t`. tlist must be positive and contain the
-        element `0`. When taking steady-steady correlations only one ``tlist``
-        value is necessary, i.e. when :math:`t \rightarrow \infty`.
-        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    reverse : bool {False}
-        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
-        :math:`\left<A(t+\tau)B(t)\right>`.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_mat : ndarray
-        An 2-dimensional array (matrix) of correlation values for the times
-        specified by `tlist` (first index) and `taulist` (second index).
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-    if tlist is None:
-        tlist = [0]
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-
-    if reverse:
-        A_op, B_op, C_op = a_op, b_op, 1
-    else:
-        A_op, B_op, C_op = 1, a_op, b_op
-
-    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
-
-
-def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
-                       solver="me", args={},
-                       options={}):
-    r"""
-    Calculate the three-operator two-time correlation function:
-    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
-    quantum regression theorem and the evolution solver indicated by the
-    `solver` parameter.
-
-    Note: it is not possibly to calculate a physically meaningful correlation
-    of this form where :math:`\tau<0`.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    c_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator C.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_vec : array
-        An array of correlation values for the times specified by `taulist`.
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
-
-
-def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
-                       solver="me", args={},
-                       options={}):
-    r"""
-    Calculate the three-operator two-time correlation function:
-    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
-    quantum regression theorem and the evolution solver indicated by the
-    `solver` parameter.
-
-    Note: it is not possibly to calculate a physically meaningful correlation
-    of this form where :math:`\tau<0`.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    tlist : array_like
-        List of times for :math:`t`. tlist must be positive and contain the
-        element `0`. When taking steady-steady correlations only one tlist
-        value is necessary, i.e. when :math:`t \rightarrow \infty`.
-        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    b_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator B.
-    c_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator C.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    corr_mat : array
-        An 2-dimensional array (matrix) of correlation values for the times
-        specified by `tlist` (first index) and `taulist` (second index).
-
-    See Also
-    --------
-    :func:`correlation_3op` :
-        Similar function supporting various solver types.
-
-    References
-    ----------
-
-    See, Gardiner, Quantum Noise, Section 5.2.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    if tlist is None:
-        tlist = [0]
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-
-    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
-
-
-# high level correlation
-
-def coherence_function_g1(
-    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
-):
-    r"""
-    Calculate the normalized first-order quantum coherence function:
-
-    .. math::
-
-        g^{(1)}(\tau) =
-        \frac{\langle A^\dagger(\tau)A(0)\rangle}
-        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
-                \langle A^\dagger(0)A(0)\rangle}}
-
-    using the quantum regression theorem and the evolution solver indicated by
-    the `solver` parameter.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
-        List of collapse operators
-    a_op : :class:`Qobj`, :class:`QobjEvo`
-        Operator A.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    g1, G1 : tuple
-        The normalized and unnormalized second-order coherence function.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    # first calculate the photon number
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-        n = np.array([expect(state0, a_op.dag() * a_op)])
-    else:
-        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
-
-    # calculate the correlation function G1 and normalize with n to obtain g1
-    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
-
-    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
-    return g1, G1
-
-
-def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
-                          args={}, options={}):
-    r"""
-    Calculate the normalized second-order quantum coherence function:
-
-    .. math::
-
-         g^{(2)}(\tau) =
-        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
-        {\langle A^\dagger(\tau)A(\tau)\rangle
-         \langle A^\dagger(0)A(0)\rangle}
-
-    using the quantum regression theorem and the evolution solver indicated by
-    the `solver` parameter.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian, may be time-dependent for solver choice of `me`.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
-        be used as the initial state. The 'steady-state' is only implemented
-        if ``c_ops`` are provided and the Hamiltonian is constant.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    c_ops : list
-        List of collapse operators, may be time-dependent for solver choice of
-        `me`.
-    a_op : :class:`Qobj`
-        Operator A.
-    args : dict
-        Dictionary of arguments to be passed to solver.
-    solver : str {'me', 'es'}
-        Choice of solver, `me` for master-equation, and `es` for exponential
-        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
-    options : dict, optional
-        Options for the solver. Only used with `me` solver.
-
-    Returns
-    -------
-    g2, G2 : tuple
-        The normalized and unnormalized second-order coherence function.
-
-    """
-    solver = _make_solver(H, c_ops, args, options, solver)
-
-    # first calculate the photon number
-    if state0 is None:
-        state0 = steadystate(H, c_ops)
-        n = np.array([expect(state0, a_op.dag() * a_op)])
-    else:
-        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
-
-    # calculate the correlation function G2 and normalize with n to obtain g2
-    G2 = correlation_3op(solver, state0, [0], taulist,
-                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
-
-    g2 = G2 / (n[0] * np.array(n))
-    return g2, G2
-
-
-def _make_solver(H, c_ops, args, options, solver):
-    H = QobjEvo(H, args=args)
-    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
-    if solver == "me":
-        solver_instance = MESolver(H, c_ops, options=options)
-    elif solver == "es":
-        options = {"method": "diag"}
-        solver_instance = MESolver(H, c_ops, options=options)
-    elif solver == "mc":
-        raise ValueError("MC solver for correlation has been removed")
-    return solver_instance
-
-
-def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
-    r"""
-    Calculate the three-operator two-time correlation function:
-
-        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
-
-    from a open system :class:`Solver`.
-
-    Note: it is not possible to calculate a physically meaningful correlation
-    where :math:`\tau<0`.
-
-    Parameters
-    ----------
-    solver : :class:`MESolver`, :class:`BRSolver`
-        Qutip solver for an open system.
-    state0 : :class:`Qobj`
-        Initial state density matrix :math:`\rho(t_0)` or state vector
-        :math:`\psi(t_0)`.
-    tlist : array_like
-        List of times for :math:`t`. tlist must be positive and contain the
-        element `0`.
-    taulist : array_like
-        List of times for :math:`\tau`. taulist must be positive and contain
-        the element `0`.
-    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
-        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
-        in the Schrodinger picture. They do not need to be all provided. For
-        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
-
-    Returns
-    -------
-    corr_mat : array
-        An 2-dimensional array (matrix) of correlation values for the times
-        specified by `tlist` (first index) and `taulist` (second index). If
-        `tlist` is `None`, then a 1-dimensional array of correlation values
-        is returned instead.
-    """
-    taulist = np.asarray(taulist)
-
-    dims = state0.dims[0]
-    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
-    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
-    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
-
-    if isinstance(solver, (MESolver, BRSolver)):
-        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
-    elif isinstance(solver, MCSolver):
-        raise TypeError("Monte Carlo support for correlation was removed. "
-                        "Please, tell us on GitHub issues if you need it!")
-    elif isinstance(solver, HEOMSolver):
-        raise TypeError("HEOM is not supported by correlation. "
-                        "Please, tell us on GitHub issues if you need it!")
-    else:
-        raise TypeError("Only solvers able to evolve density matrices"
-                        " are supported.")
-
-    return out
-
-
-def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
-    old_opt = solver.options.copy()
-    try:
-        # We don't want to modify the solver
-        # TODO: Solver could have a ``with`` or ``copy``.
-        solver.options["normalize_output"] = False
-        solver.options["progress_bar"] = False
-
-        progress_bar = progess_bars[old_opt['progress_bar']]()
-        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
-        rho_t = solver.run(state0, tlist).states
-        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
-        progress_bar.update()
-
-        for t_idx, rho in enumerate(rho_t):
-            t = tlist[t_idx]
-            corr_mat[t_idx, :] = solver.run(
-                C(t) @ rho @ A(t),
-                taulist + t,
-                e_ops=B
-            ).expect[0]
-            progress_bar.update()
-        progress_bar.finished()
-
-    finally:
-        solver.options = old_opt
-
-    return corr_mat
+__all__ = [
+    'correlation_3op',
+    'correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
+    'correlation_3op_2t', 'coherence_function_g1', 'coherence_function_g2'
+]
+
+import numpy as np
+import scipy.fftpack
+
+from ..core import (
+    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
+    tensor, qzero, expect
+)
+from .mesolve import MESolver
+from .mcsolve import MCSolver
+from .brmesolve import BRSolver
+from .heom.bofin_solvers import HEOMSolver
+
+from .steadystate import steadystate
+from ..ui.progressbar import progess_bars
+
+# -----------------------------------------------------------------------------
+# PUBLIC API
+# -----------------------------------------------------------------------------
+
+# low level correlation
+
+
+def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
+                       solver="me", reverse=False, args={},
+                       options={}):
+    r"""
+    Calculate the two-operator one-time correlation function:
+    :math:`\left<A(\tau)B(0)\right>`
+    along one time axis using the quantum regression theorem and the evolution
+    solver indicated by the `solver` parameter.
+
+    Parameters
+    ----------
+
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    reverse : bool {False}
+        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
+        :math:`\left<A(t+\tau)B(t)\right>`.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_vec : ndarray
+        An array of correlation values for the times specified by `taulist`.
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    if reverse:
+        A_op, B_op, C_op = a_op, b_op, 1
+    else:
+        A_op, B_op, C_op = 1, a_op, b_op
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+
+    return correlation_3op(solver, state0, [0], taulist, A_op, B_op, C_op)[0]
+
+
+def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
+                       solver="me", reverse=False, args={},
+                       options={}):
+    r"""
+    Calculate the two-operator two-time correlation function:
+    :math:`\left<A(t+\tau)B(t)\right>`
+    along two time axes using the quantum regression theorem and the
+    evolution solver indicated by the ``solver`` parameter.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    tlist : array_like
+        List of times for :math:`t`. tlist must be positive and contain the
+        element `0`. When taking steady-steady correlations only one ``tlist``
+        value is necessary, i.e. when :math:`t \rightarrow \infty`.
+        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    reverse : bool {False}
+        If `True`, calculate :math:`\left<A(t)B(t+\tau)\right>` instead of
+        :math:`\left<A(t+\tau)B(t)\right>`.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_mat : ndarray
+        An 2-dimensional array (matrix) of correlation values for the times
+        specified by `tlist` (first index) and `taulist` (second index).
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+    if tlist is None:
+        tlist = [0]
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+
+    if reverse:
+        A_op, B_op, C_op = a_op, b_op, 1
+    else:
+        A_op, B_op, C_op = 1, a_op, b_op
+
+    return correlation_3op(solver, state0, tlist, taulist, A_op, B_op, C_op)
+
+
+def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
+                       solver="me", args={},
+                       options={}):
+    r"""
+    Calculate the three-operator two-time correlation function:
+    :math:`\left<A(0)B(\tau)C(0)\right>` along one time axis using the
+    quantum regression theorem and the evolution solver indicated by the
+    `solver` parameter.
+
+    Note: it is not possibly to calculate a physically meaningful correlation
+    of this form where :math:`\tau<0`.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    c_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator C.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_vec : array
+        An array of correlation values for the times specified by `taulist`.
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+    return correlation_3op(solver, state0, [0], taulist, a_op, b_op, c_op)[0]
+
+
+def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
+                       solver="me", args={},
+                       options={}):
+    r"""
+    Calculate the three-operator two-time correlation function:
+    :math:`\left<A(t)B(t+\tau)C(t)\right>` along two time axes using the
+    quantum regression theorem and the evolution solver indicated by the
+    `solver` parameter.
+
+    Note: it is not possibly to calculate a physically meaningful correlation
+    of this form where :math:`\tau<0`.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    tlist : array_like
+        List of times for :math:`t`. tlist must be positive and contain the
+        element `0`. When taking steady-steady correlations only one tlist
+        value is necessary, i.e. when :math:`t \rightarrow \infty`.
+        If ``tlist`` is ``None``, ``tlist=[0]`` is assumed.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    b_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator B.
+    c_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator C.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    corr_mat : array
+        An 2-dimensional array (matrix) of correlation values for the times
+        specified by `tlist` (first index) and `taulist` (second index).
+
+    See Also
+    --------
+    :func:`correlation_3op` :
+        Similar function supporting various solver types.
+
+    References
+    ----------
+
+    See, Gardiner, Quantum Noise, Section 5.2.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    if tlist is None:
+        tlist = [0]
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+
+    return correlation_3op(solver, state0, tlist, taulist, a_op, b_op, c_op)
+
+
+# high level correlation
+
+def coherence_function_g1(
+    H, state0, taulist, c_ops, a_op, solver="me", args={}, options={}
+):
+    r"""
+    Calculate the normalized first-order quantum coherence function:
+
+    .. math::
+
+        g^{(1)}(\tau) =
+        \frac{\langle A^\dagger(\tau)A(0)\rangle}
+        {\sqrt{\langle A^\dagger(\tau)A(\tau)\rangle
+                \langle A^\dagger(0)A(0)\rangle}}
+
+    using the quantum regression theorem and the evolution solver indicated by
+    the `solver` parameter.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list of {:class:`Qobj`, :class:`QobjEvo`}
+        List of collapse operators
+    a_op : :class:`Qobj`, :class:`QobjEvo`
+        Operator A.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    g1, G1 : tuple
+        The normalized and unnormalized second-order coherence function.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    # first calculate the photon number
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+        n = np.array([expect(state0, a_op.dag() * a_op)])
+    else:
+        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
+
+    # calculate the correlation function G1 and normalize with n to obtain g1
+    G1 = correlation_3op(solver, state0, [0], taulist, None, a_op.dag(), a_op)[0]
+
+    g1 = G1 / np.sqrt(n[0] * np.array(n))[0]
+    return g1, G1
+
+
+def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me",
+                          args={}, options={}):
+    r"""
+    Calculate the normalized second-order quantum coherence function:
+
+    .. math::
+
+         g^{(2)}(\tau) =
+        \frac{\langle A^\dagger(0)A^\dagger(\tau)A(\tau)A(0)\rangle}
+        {\langle A^\dagger(\tau)A(\tau)\rangle
+         \langle A^\dagger(0)A(0)\rangle}
+
+    using the quantum regression theorem and the evolution solver indicated by
+    the `solver` parameter.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian, may be time-dependent for solver choice of `me`.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`. If 'state0' is 'None', then the steady state will
+        be used as the initial state. The 'steady-state' is only implemented
+        if ``c_ops`` are provided and the Hamiltonian is constant.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    c_ops : list
+        List of collapse operators, may be time-dependent for solver choice of
+        `me`.
+    a_op : :class:`Qobj`
+        Operator A.
+    args : dict
+        Dictionary of arguments to be passed to solver.
+    solver : str {'me', 'es'}
+        Choice of solver, `me` for master-equation, and `es` for exponential
+        series. `es` is equivalent to `me` with ``options={"method": "diag"}``.
+    options : dict, optional
+        Options for the solver. Only used with `me` solver.
+
+    Returns
+    -------
+    g2, G2 : tuple
+        The normalized and unnormalized second-order coherence function.
+
+    """
+    solver = _make_solver(H, c_ops, args, options, solver)
+
+    # first calculate the photon number
+    if state0 is None:
+        state0 = steadystate(H, c_ops)
+        n = np.array([expect(state0, a_op.dag() * a_op)])
+    else:
+        n = solver.run(state0, taulist, e_ops=[a_op.dag() * a_op]).expect[0]
+
+    # calculate the correlation function G2 and normalize with n to obtain g2
+    G2 = correlation_3op(solver, state0, [0], taulist,
+                         a_op.dag(), a_op.dag() * a_op, a_op)[0]
+
+    g2 = G2 / (n[0] * np.array(n))
+    return g2, G2
+
+
+def _make_solver(H, c_ops, args, options, solver):
+    H = QobjEvo(H, args=args)
+    c_ops = [QobjEvo(c_op, args=args) for c_op in c_ops]
+    if solver == "me":
+        solver_instance = MESolver(H, c_ops, options=options)
+    elif solver == "es":
+        options = {"method": "diag"}
+        solver_instance = MESolver(H, c_ops, options=options)
+    elif solver == "mc":
+        raise ValueError("MC solver for correlation has been removed")
+    return solver_instance
+
+
+def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
+    r"""
+    Calculate the three-operator two-time correlation function:
+
+        :math:`\left<A(t)B(t+\tau)C(t)\right>`.
+
+    from a open system :class:`Solver`.
+
+    Note: it is not possible to calculate a physically meaningful correlation
+    where :math:`\tau<0`.
+
+    Parameters
+    ----------
+    solver : :class:`MESolver`, :class:`BRSolver`
+        Qutip solver for an open system.
+    state0 : :class:`Qobj`
+        Initial state density matrix :math:`\rho(t_0)` or state vector
+        :math:`\psi(t_0)`.
+    tlist : array_like
+        List of times for :math:`t`. tlist must be positive and contain the
+        element `0`.
+    taulist : array_like
+        List of times for :math:`\tau`. taulist must be positive and contain
+        the element `0`.
+    A, B, C: :class:`Qobj`, :class:`QobjEvo`, optional, default=None
+        Operators ``A``, ``B``, ``C`` from the equation ``<A(t)B(t+\tau)C(t)>``
+        in the Schrodinger picture. They do not need to be all provided. For
+        exemple, if ``A`` is not provided, ``<B(t+\tau)C(t)>`` is computed.
+
+    Returns
+    -------
+    corr_mat : array
+        An 2-dimensional array (matrix) of correlation values for the times
+        specified by `tlist` (first index) and `taulist` (second index). If
+        `tlist` is `None`, then a 1-dimensional array of correlation values
+        is returned instead.
+    """
+    taulist = np.asarray(taulist)
+
+    dims = state0.dims[0]
+    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
+    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
+    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
+
+    if isinstance(solver, (MESolver, BRSolver)):
+        out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
+    elif isinstance(solver, MCSolver):
+        raise TypeError("Monte Carlo support for correlation was removed. "
+                        "Please, tell us on GitHub issues if you need it!")
+    elif isinstance(solver, HEOMSolver):
+        raise TypeError("HEOM is not supported by correlation. "
+                        "Please, tell us on GitHub issues if you need it!")
+    else:
+        raise TypeError("Only solvers able to evolve density matrices"
+                        " are supported.")
+
+    return out
+
+
+def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
+    old_opt = solver.options.copy()
+    try:
+        # We don't want to modify the solver
+        # TODO: Solver could have a ``with`` or ``copy``.
+        solver.options["normalize_output"] = False
+        solver.options["progress_bar"] = False
+
+        progress_bar = progess_bars[old_opt['progress_bar']]()
+        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
+        rho_t = solver.run(state0, tlist).states
+        corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
+        progress_bar.update()
+
+        for t_idx, rho in enumerate(rho_t):
+            t = tlist[t_idx]
+            corr_mat[t_idx, :] = solver.run(
+                C(t) @ rho @ A(t),
+                taulist + t,
+                e_ops=B
+            ).expect[0]
+            progress_bar.update()
+        progress_bar.finished()
+
+    finally:
+        solver.options = old_opt
+
+    return corr_mat
diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 2237957d01..4d4c60af9a 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -1,217 +1,217 @@
-"""
-This module contains functions for calculating current and current noise using
-the counting statistics formalism.
-"""
-__all__ = ['countstat_current', 'countstat_current_noise']
-
-import numpy as np
-import scipy.sparse as sp
-
-from itertools import product
-from ..core import (
-    sprepost, spre, qeye, tensor, expect, Qobj,
-    operator_to_vector, vector_to_operator
-)
-from ..core import data as _data
-from .steadystate import pseudo_inverse, steadystate
-from ..settings import settings
-
-# Load MKL spsolve if avaiable
-if settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_spsolve
-
-
-def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
-    """
-    Calculate the current corresponding to a system Liouvillian ``L`` and a
-    list of current collapse operators ``c_ops`` or current superoperators
-    ``J_ops``.
-
-    Parameters
-    ----------
-
-    L : :class:`qutip.Qobj`
-        Qobj representing the system Liouvillian.
-
-    c_ops : array / list (optional)
-        List of current collapse operators. Required if either ``rhoss`` or
-        ``J_ops`` is not given.
-
-    rhoss : :class:`qutip.Qobj` (optional)
-        The steadystate density matrix for the given system Liouvillian ``L``
-        and collapse operators. If not given, it defaults to
-        ``steadystate(L, c_ops)``.
-
-    J_ops : array / list (optional)
-        List of current superoperators. If not given, they default to
-        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
-
-    Returns
-    --------
-    I : array
-        The currents ``I`` corresponding to each current collapse operator
-        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
-    """
-
-    if J_ops is None:
-        if c_ops is None:
-            raise ValueError("c_ops must be given if J_ops is not")
-        J_ops = [sprepost(c, c.dag()) for c in c_ops]
-
-    if rhoss is None:
-        if c_ops is None:
-            raise ValueError("c_ops must be given if rhoss is not")
-        rhoss = steadystate(L, c_ops)
-
-    rhoss_vec = _data.column_stack(rhoss.data.copy())
-
-    N = len(J_ops)
-    current = np.zeros(N)
-
-    for i, Ji in enumerate(J_ops):
-        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
-
-    return current
-
-
-def _solve(A, V):
-    try:
-        return _data.solve(A, V)
-    except Exception:
-        return _data.solve(A, V, "lsqr")
-
-
-def _noise_direct(L, wlist, rhoss, J_ops):
-    J_ops = [op.data for op in J_ops]
-    rhoss_vec = operator_to_vector(rhoss).data
-
-    N_j_ops = len(J_ops)
-    current = np.zeros(N_j_ops)
-    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
-
-    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
-    tr_op_vec = operator_to_vector(tr_op)
-
-    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
-    Iop = _data.identity(np.prod(L.dims[0][0])**2)
-    Q = _data.sub(Iop, Pop)
-    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
-
-    for k, w in enumerate(wlist):
-        if w != 0.0:
-            L_temp = 1.0j * w * spre(tr_op) + L
-        else:
-            # At zero frequency some solvers fail for small systems.
-            # Adding a small finite frequency of order 1e-15
-            # helps prevent the solvers from throwing an exception.
-            L_temp = 1e-15j * spre(tr_op) + L
-
-        A = _data.to(_data.CSR, L_temp.data)
-        X_rho = [_solve(A, op) for op in Q_ops]
-
-        for i, j in product(range(N_j_ops), repeat=2):
-            if i == j:
-                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
-                noise[j, i, k] = current[i]
-            noise[j, i, k] -= (
-                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
-                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
-            ).real
-
-    return current, noise
-
-
-def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
-    N_j_ops = len(J_ops)
-    current = np.zeros(N_j_ops)
-    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
-    rhoss_vec = operator_to_vector(rhoss)
-    for k, w in enumerate(wlist):
-        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
-        for i, j in product(range(N_j_ops), repeat=2):
-            if i == j:
-                current[i] = J_ops[i](rhoss).tr().real
-                noise[i, j, k] = current[i]
-            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
-            noise[i, j, k] -= op(rhoss).tr().real
-    return current, noise
-
-
-def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
-                            sparse=True, method='direct'):
-    """
-    Compute the cross-current noise spectrum for a list of collapse operators
-    `c_ops` corresponding to monitored currents, given the system
-    Liouvillian `L`. The current collapse operators `c_ops` should be part
-    of the dissipative processes in `L`, but the `c_ops` given here does not
-    necessarily need to be all collapse operators contributing to dissipation
-    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
-    and the current operators `J_ops` correpsonding to the current collapse
-    operators `c_ops` can also be specified. If either of
-    `rhoss` and `J_ops` are omitted, they will be computed internally.
-    'wlist' is an optional list of frequencies at which to evaluate the noise
-    spectrum.
-
-    Parameters
-    ----------
-
-    L : :class:`qutip.Qobj`
-        Qobj representing the system Liouvillian.
-
-    c_ops : array / list
-        List of current collapse operators.
-
-    rhoss : :class:`qutip.Qobj` (optional)
-        The steadystate density matrix corresponding the system Liouvillian
-        `L`.
-
-    wlist : array / list (optional)
-        List of frequencies at which to evaluate (if none are given, evaluates
-        at zero frequency)
-
-    J_ops : array / list (optional)
-        List of current superoperators.
-
-    sparse : bool [True]
-        Flag that indicates whether to use sparse or dense matrix methods when
-        computing the pseudo inverse. Default is false, as sparse solvers
-        can fail for small systems. For larger systems the sparse solvers
-        are recommended.
-
-    method : str, ['direct']
-        Method used to compute the noise. The default, 'direct' with
-        ``sparse=True``, compute the noise directly. It is the recommended
-        method for larger systems. Otherwise, the pseudo inverse is computed
-        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
-        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
-        ``sparse=False``.
-
-    .. note::
-        The algoryth is described in page 67 of "Electrons in nanostructures"
-        C. Flindt, PhD Thesis, available online:
-        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
-
-    Returns
-    --------
-    I, S : tuple of arrays
-        The currents `I` corresponding to each current collapse operator
-        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
-        zero-frequency cross-current correlation `S`.
-    """
-    if rhoss is None:
-        rhoss = steadystate(L, c_ops)
-
-    if J_ops is None:
-        J_ops = [sprepost(c, c.dag()) for c in c_ops]
-
-    if wlist is None:
-        wlist = [0.]
-
-    if sparse and method == 'direct':
-        # rhoss_vec = operator_to_vector(rhoss).data
-        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
-    else:
-        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
-                                          sparse, method)
-
-    return current, noise
+"""
+This module contains functions for calculating current and current noise using
+the counting statistics formalism.
+"""
+__all__ = ['countstat_current', 'countstat_current_noise']
+
+import numpy as np
+import scipy.sparse as sp
+
+from itertools import product
+from ..core import (
+    sprepost, spre, qeye, tensor, expect, Qobj,
+    operator_to_vector, vector_to_operator
+)
+from ..core import data as _data
+from .steadystate import pseudo_inverse, steadystate
+from ..settings import settings
+
+# Load MKL spsolve if avaiable
+if settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_spsolve
+
+
+def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
+    """
+    Calculate the current corresponding to a system Liouvillian ``L`` and a
+    list of current collapse operators ``c_ops`` or current superoperators
+    ``J_ops``.
+
+    Parameters
+    ----------
+
+    L : :class:`qutip.Qobj`
+        Qobj representing the system Liouvillian.
+
+    c_ops : array / list (optional)
+        List of current collapse operators. Required if either ``rhoss`` or
+        ``J_ops`` is not given.
+
+    rhoss : :class:`qutip.Qobj` (optional)
+        The steadystate density matrix for the given system Liouvillian ``L``
+        and collapse operators. If not given, it defaults to
+        ``steadystate(L, c_ops)``.
+
+    J_ops : array / list (optional)
+        List of current superoperators. If not given, they default to
+        ``sprepost(c, c.dag())`` for each ``c`` from ``c_ops``.
+
+    Returns
+    --------
+    I : array
+        The currents ``I`` corresponding to each current collapse operator
+        ``J_ops`` (or to each ``c_ops`` if ``J_ops`` was not given).
+    """
+
+    if J_ops is None:
+        if c_ops is None:
+            raise ValueError("c_ops must be given if J_ops is not")
+        J_ops = [sprepost(c, c.dag()) for c in c_ops]
+
+    if rhoss is None:
+        if c_ops is None:
+            raise ValueError("c_ops must be given if rhoss is not")
+        rhoss = steadystate(L, c_ops)
+
+    rhoss_vec = _data.column_stack(rhoss.data.copy())
+
+    N = len(J_ops)
+    current = np.zeros(N)
+
+    for i, Ji in enumerate(J_ops):
+        current[i] = _data.expect_super(Ji.data, rhoss_vec).real
+
+    return current
+
+
+def _solve(A, V):
+    try:
+        return _data.solve(A, V)
+    except Exception:
+        return _data.solve(A, V, "lsqr")
+
+
+def _noise_direct(L, wlist, rhoss, J_ops):
+    J_ops = [op.data for op in J_ops]
+    rhoss_vec = operator_to_vector(rhoss).data
+
+    N_j_ops = len(J_ops)
+    current = np.zeros(N_j_ops)
+    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
+
+    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
+    tr_op_vec = operator_to_vector(tr_op)
+
+    Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
+    Iop = _data.identity(np.prod(L.dims[0][0])**2)
+    Q = _data.sub(Iop, Pop)
+    Q_ops = [_data.matmul(Q, _data.matmul(op, rhoss_vec)) for op in J_ops]
+
+    for k, w in enumerate(wlist):
+        if w != 0.0:
+            L_temp = 1.0j * w * spre(tr_op) + L
+        else:
+            # At zero frequency some solvers fail for small systems.
+            # Adding a small finite frequency of order 1e-15
+            # helps prevent the solvers from throwing an exception.
+            L_temp = 1e-15j * spre(tr_op) + L
+
+        A = _data.to(_data.CSR, L_temp.data)
+        X_rho = [_solve(A, op) for op in Q_ops]
+
+        for i, j in product(range(N_j_ops), repeat=2):
+            if i == j:
+                current[i] = _data.expect_super(J_ops[i], rhoss_vec).real
+                noise[j, i, k] = current[i]
+            noise[j, i, k] -= (
+                _data.expect_super(_data.matmul(J_ops[j], Q), X_rho[i]) +
+                _data.expect_super(_data.matmul(J_ops[i], Q), X_rho[j])
+            ).real
+
+    return current, noise
+
+
+def _noise_pseudoinv(L, wlist, rhoss, J_ops, sparse, method):
+    N_j_ops = len(J_ops)
+    current = np.zeros(N_j_ops)
+    noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
+    rhoss_vec = operator_to_vector(rhoss)
+    for k, w in enumerate(wlist):
+        R = pseudo_inverse(L, rhoss=rhoss, w=w, sparse=sparse, method=method)
+        for i, j in product(range(N_j_ops), repeat=2):
+            if i == j:
+                current[i] = J_ops[i](rhoss).tr().real
+                noise[i, j, k] = current[i]
+            op = J_ops[i] @ R @ J_ops[j] + J_ops[j] @ R @ J_ops[i]
+            noise[i, j, k] -= op(rhoss).tr().real
+    return current, noise
+
+
+def countstat_current_noise(L, c_ops, wlist=None, rhoss=None, J_ops=None,
+                            sparse=True, method='direct'):
+    """
+    Compute the cross-current noise spectrum for a list of collapse operators
+    `c_ops` corresponding to monitored currents, given the system
+    Liouvillian `L`. The current collapse operators `c_ops` should be part
+    of the dissipative processes in `L`, but the `c_ops` given here does not
+    necessarily need to be all collapse operators contributing to dissipation
+    in the Liouvillian. Optionally, the steadystate density matrix `rhoss`
+    and the current operators `J_ops` correpsonding to the current collapse
+    operators `c_ops` can also be specified. If either of
+    `rhoss` and `J_ops` are omitted, they will be computed internally.
+    'wlist' is an optional list of frequencies at which to evaluate the noise
+    spectrum.
+
+    Parameters
+    ----------
+
+    L : :class:`qutip.Qobj`
+        Qobj representing the system Liouvillian.
+
+    c_ops : array / list
+        List of current collapse operators.
+
+    rhoss : :class:`qutip.Qobj` (optional)
+        The steadystate density matrix corresponding the system Liouvillian
+        `L`.
+
+    wlist : array / list (optional)
+        List of frequencies at which to evaluate (if none are given, evaluates
+        at zero frequency)
+
+    J_ops : array / list (optional)
+        List of current superoperators.
+
+    sparse : bool [True]
+        Flag that indicates whether to use sparse or dense matrix methods when
+        computing the pseudo inverse. Default is false, as sparse solvers
+        can fail for small systems. For larger systems the sparse solvers
+        are recommended.
+
+    method : str, ['direct']
+        Method used to compute the noise. The default, 'direct' with
+        ``sparse=True``, compute the noise directly. It is the recommended
+        method for larger systems. Otherwise, the pseudo inverse is computed
+        using the given method. Pseudo inverse supports 'splu' and 'spilu' for
+        sparse matrices and 'direct', 'scipy' and 'numpy' methods for
+        ``sparse=False``.
+
+    .. note::
+        The algoryth is described in page 67 of "Electrons in nanostructures"
+        C. Flindt, PhD Thesis, available online:
+        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/file_4732600/content
+
+    Returns
+    --------
+    I, S : tuple of arrays
+        The currents `I` corresponding to each current collapse operator
+        `c_ops` (or, equivalently, each current superopeator `J_ops`) and the
+        zero-frequency cross-current correlation `S`.
+    """
+    if rhoss is None:
+        rhoss = steadystate(L, c_ops)
+
+    if J_ops is None:
+        J_ops = [sprepost(c, c.dag()) for c in c_ops]
+
+    if wlist is None:
+        wlist = [0.]
+
+    if sparse and method == 'direct':
+        # rhoss_vec = operator_to_vector(rhoss).data
+        current, noise = _noise_direct(L, wlist, rhoss, J_ops)
+    else:
+        current, noise = _noise_pseudoinv(L, wlist, rhoss, J_ops,
+                                          sparse, method)
+
+    return current, noise
diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
index 9eea49b97b..7ce6cc4f11 100644
--- a/qutip/solver/floquet.py
+++ b/qutip/solver/floquet.py
@@ -1,931 +1,931 @@
-__all__ = [
-    "FloquetBasis",
-    "floquet_tensor",
-    "fsesolve",
-    "fmmesolve",
-    "FMESolver",
-]
-
-import numpy as np
-from qutip.core import data as _data
-from qutip import Qobj, QobjEvo
-from .propagator import Propagator
-from .mesolve import MESolver
-from .solver_base import Solver
-from .integrator import Integrator
-from .result import Result
-from time import time
-from ..ui.progressbar import progess_bars
-
-
-class FloquetBasis:
-    """
-    Utility to compute floquet modes and states.
-
-    Attributes
-    ----------
-    U : :class:`Propagator`
-        The propagator of the Hamiltonian over one period.
-
-    evecs : :class:`qutip.data.Data`
-        Matrix where each column is an initial Floquet mode.
-
-    e_quasi : np.ndarray[float]
-        The quasi energies of the Hamiltonian.
-    """
-
-    def __init__(
-        self,
-        H,
-        T,
-        args=None,
-        options=None,
-        sparse=False,
-        sort=True,
-        precompute=None,
-    ):
-        """
-        Parameters
-        ----------
-        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
-            System Hamiltonian, with period `T`.
-
-        T : float
-            Period of the Hamiltonian.
-
-        args : None / *dictionary*
-            dictionary of parameters for time-dependent Hamiltonians and
-            collapse operators.
-
-        options : dict [None]
-            Options used by sesolve to compute the floquet modes.
-
-        sparse : bool [False]
-            Whether to use the sparse eigen solver when computing the
-            quasi-energies.
-
-        sort : bool [True]
-            Whether to sort the quasi-energies.
-
-        precompute : list [None]
-            If provided, a list of time at which to store the propagators
-            for later use when computing modes and states. Default is
-            ``linspace(0, T, 101)`` corresponding to the default integration
-            steps used for the floquet tensor computation.
-        """
-        if not T > 0:
-            raise ValueError("The period need to be a positive number.")
-        self.T = T
-        if precompute is not None:
-            tlist = np.unique(np.atleast_1d(precompute) % self.T)
-            memoize = len(tlist)
-            if tlist[0] != 0:
-                memoize += 1
-            if tlist[-1] != T:
-                memoize += 1
-        else:
-            # Default computation
-            tlist = np.linspace(0, T, 101)
-            memoize = 101
-        self.U = Propagator(H, args=args, options=options, memoize=memoize)
-        for t in tlist:
-            # Do the evolution by steps to save the intermediate results.
-            self.U(t)
-        U_T = self.U(self.T)
-        if not sparse and isinstance(U_T.data, _data.CSR):
-            U_T = U_T.to("Dense")
-        evals, evecs = _data.eigs(U_T.data)
-        e_quasi = -np.angle(evals) / T
-        if sort:
-            perm = np.argsort(e_quasi)
-            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
-            self.e_quasi = e_quasi[perm]
-        else:
-            self.evecs = evecs
-            self.e_quasi = e_quasi
-
-    def _as_ketlist(self, kets_mat):
-        """
-        Split the Data array in a list of kets.
-        """
-        dims = [self.U(0).dims[0], [1]]
-        return [
-            Qobj(ket, dims=dims, type="ket")
-            for ket in _data.split_columns(kets_mat)
-        ]
-
-    def mode(self, t, data=False):
-        """
-        Calculate the Floquet modes at time ``t``.
-
-        Parameters
-        ----------
-        t : float
-            The time for which to evaluate the Floquet mode.
-
-        data : bool [False]
-            Whether to return the states as a single data matrix or a list of
-            ket states.
-
-        Returns
-        -------
-        output : list[:class:`Qobj`], :class:`qutip.data.Data`
-            A list of Floquet states for the time ``t`` or the states as column
-            in a single matrix.
-        """
-        t = t % self.T
-        if t == 0.0:
-            kets_mat = self.evecs
-        else:
-            U = self.U(t).data
-            phases = _data.diag(np.exp(1j * t * self.e_quasi))
-            kets_mat = U @ self.evecs @ phases
-        if data:
-            return kets_mat
-        else:
-            return self._as_ketlist(kets_mat)
-
-    def state(self, t, data=False):
-        """
-        Evaluate the floquet states at time t.
-
-        Parameters
-        ----------
-        t : float
-            The time for which to evaluate the Floquet states.
-
-        data : bool [False]
-            Whether to return the states as a single data matrix or a list of
-            ket states.
-
-        Returns
-        -------
-        output : list[:class:`Qobj`], :class:`qutip.data.Data`
-            A list of Floquet states for the time ``t`` or the states as column
-            in a single matrix.
-        """
-        if t:
-            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
-            states_mat = self.mode(t, True) @ phases
-        else:
-            states_mat = self.evecs
-        if data:
-            return states_mat
-        else:
-            return self._as_ketlist(states_mat)
-
-    def from_floquet_basis(self, floquet_basis, t=0):
-        """
-        Transform a ket or density matrix from the Floquet basis at time ``t``
-        to the lab basis.
-
-        Parameters
-        ----------
-        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
-            Initial state in the Floquet basis at time ``t``. May be either a
-            ket or density matrix.
-
-        t : float [0]
-            The time at which to evaluate the Floquet states.
-
-        Returns
-        -------
-        output : :class:`Qobj`, :class:`qutip.data.Data`
-            The state in the lab basis. The return type is the same as the type
-            of the input state.
-        """
-        is_Qobj = isinstance(floquet_basis, Qobj)
-        if is_Qobj:
-            dims = floquet_basis.dims
-            floquet_basis = floquet_basis.data
-            if dims[0] != self.U(0).dims[1]:
-                raise ValueError(
-                    "Dimensions of the state do not match the Hamiltonian"
-                )
-
-        state_mat = self.state(t, True)
-        lab_basis = state_mat @ floquet_basis
-        if floquet_basis.shape[1] != 1:
-            lab_basis = lab_basis @ state_mat.adjoint()
-
-        if is_Qobj:
-            return Qobj(lab_basis, dims=dims)
-        return lab_basis
-
-    def to_floquet_basis(self, lab_basis, t=0):
-        """
-        Transform a ket or density matrix in the lab basis
-        to the Floquet basis at time ``t``.
-
-        Parameters
-        ----------
-        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
-            Initial state in the lab basis.
-
-        t : float [0]
-            The time at which to evaluate the Floquet states.
-
-        Returns
-        -------
-        output : :class:`Qobj`, :class:`qutip.data.Data`
-            The state in the Floquet basis. The return type is the same as the
-            type of the input state.
-        """
-        is_Qobj = isinstance(lab_basis, Qobj)
-        if is_Qobj:
-            dims = lab_basis.dims
-            lab_basis = lab_basis.data
-            if dims[0] != self.U(0).dims[1]:
-                raise ValueError(
-                    "Dimensions of the state do not match the Hamiltonian"
-                )
-
-        state_mat = self.state(t, True)
-        floquet_basis = state_mat.adjoint() @ lab_basis
-        if lab_basis.shape[1] != 1:
-            floquet_basis = floquet_basis @ state_mat
-
-        if is_Qobj:
-            return Qobj(floquet_basis, dims=dims)
-        return floquet_basis
-
-
-def _floquet_delta_tensor(f_energies, kmax, T):
-    """
-    Floquet-Markov master equation X matrices.
-
-    Parameters
-    ----------
-    f_energies : np.ndarray
-        The Floquet energies.
-
-    kmax : int
-        The truncation of the number of sidebands (default 5).
-
-    T : float
-        The period of the time-dependence of the Hamiltonian.
-
-    Returns
-    -------
-    delta : np.ndarray
-        Floquet delta tensor.
-    """
-    delta = np.subtract.outer(f_energies, f_energies)
-    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
-
-
-def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
-    """
-    Floquet-Markov master equation X matrices.
-
-    Parameters
-    ----------
-    floquet_basis : :class:`FloquetBasis`
-        The system Hamiltonian wrapped in a FloquetBasis object.
-
-    c_ops : list of :class:`Qobj`
-        The collapse operators describing the dissipation.
-
-    kmax : int
-        The truncation of the number of sidebands (default 5).
-
-    ntimes : int [100]
-        The number of integration steps (for calculating X) within one period.
-
-    Returns
-    -------
-    X : list of dict of :class:`qutip.data.Data`
-        A dict of the sidebands ``k`` for the X matrices of each c_ops
-    """
-    T = floquet_basis.T
-    N = floquet_basis.U(0).shape[0]
-    omega = (2 * np.pi) / T
-    tlist = np.linspace(T / ntimes, T, ntimes)
-    ks = np.arange(-kmax, kmax + 1)
-    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
-
-    for t in tlist:
-        mode = floquet_basis.mode(t, data=True)
-        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
-        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
-            out[k] = [
-                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
-            ]
-
-    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
-
-
-def _floquet_gamma_matrices(X, delta, J_cb):
-    """
-    Floquet-Markov master equation gamma matrices.
-
-    Parameters
-    ----------
-    X : list of dict of :class:`qutip.data.Data`
-        Floquet X matrices created by :func:`_floquet_X_matrices`.
-
-    delta : np.ndarray
-        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
-
-    J_cb : list of callables
-        A list callback functions that compute the noise power spectrum as
-        a function of frequency. The list should contain one callable for each
-        collapse operator `c_op`, in the same order as the elements of `X`.
-        Each callable should accept a numpy array of frequencies and return a
-        numpy array of corresponding noise power.
-
-    Returns
-    -------
-    gammas : dict of :class:`qutip.data.Data`
-        A dict mapping the sidebands ``k`` to their gamma matrices.
-    """
-    N = delta.shape[0]
-    kmax = (delta.shape[2] - 1) // 2
-    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
-
-    for X_c_op, sp in zip(X, J_cb):
-        response = sp(delta) * ((2 + 0j) * np.pi)
-        response = [
-            _data.Dense(response[:, :, k], copy=False)
-            for k in range(2 * kmax + 1)
-        ]
-        for k in range(-kmax, kmax + 1, 1):
-            gamma[k] = _data.add(
-                gamma[k],
-                _data.multiply(
-                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
-                    response[k + kmax],
-                ),
-            )
-    return gamma
-
-
-def _floquet_A_matrix(delta, gamma, w_th):
-    """
-    Floquet-Markov master equation rate matrix.
-
-    Parameters
-    ----------
-    delta : np.ndarray
-        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
-
-    gamma : dict of :class:`qutip.data.Data`
-        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
-
-    w_th : float
-        The temperature in units of frequency.
-    """
-    kmax = (delta.shape[2] - 1) // 2
-
-    if w_th > 0.0:
-        deltap = np.copy(delta)
-        deltap[deltap == 0.0] = np.inf
-        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
-        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
-
-        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
-        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
-
-        for k in range(1, kmax + 1):
-            g_kk = _data.add(gamma[k], gamma[-k].transpose())
-            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
-            A = _data.add(A, _data.add(gamma[k], thermal_kk))
-            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
-            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
-    else:
-        # w_th is 0, thermal = 0s
-        A = gamma[0]
-        for k in range(1, kmax + 1):
-            A = _data.add(gamma[k], A)
-            A = _data.add(gamma[-k], A)
-
-    return A
-
-
-def _floquet_master_equation_tensor(A):
-    """
-    Construct a tensor that represents the master equation in the floquet
-    basis (with constant Hamiltonian and collapse operators?).
-
-    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
-
-    Parameters
-    ----------
-    A : :class:`qutip.data.Data`
-        Floquet-Markov master equation rate matrix.
-
-    Returns
-    -------
-    output : array
-        The Floquet-Markov master equation tensor `R`.
-    """
-    N = A.shape[0]
-
-    # R[i+N*i, j+N*j] = A[j, i]
-    cols = np.arange(N, dtype=np.int32)
-    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
-    data = np.ones(N, dtype=complex)
-    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
-
-    R = expand @ A.transpose() @ expand.transpose()
-
-    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
-    ket_1 = _data.Dense(np.ones(N, dtype=complex))
-    Asum = A @ ket_1
-    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
-    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
-
-    return _data.add(R, S)
-
-
-def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
-    """
-    Construct a tensor that represents the master equation in the floquet
-    basis.
-
-    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
-
-    Parameters
-    ----------
-    H : :class:`QobjEvo`
-        Periodic Hamiltonian
-
-    T : float
-        The period of the time-dependence of the hamiltonian.
-
-    c_ops : list of :class:`qutip.qobj`
-        list of collapse operators.
-
-    spectra_cb : list callback functions
-        List of callback functions that compute the noise power spectrum as
-        a function of frequency for the collapse operators in `c_ops`.
-
-    w_th : float
-        The temperature in units of frequency.
-
-    kmax : int
-        The truncation of the number of sidebands (default 5).
-
-    Returns
-    -------
-    output : array
-        The Floquet-Markov master equation tensor `R`.
-    """
-    if isinstance(H, FloquetBasis):
-        floquet_basis = H
-        T = H.T
-    else:
-        floquet_basis = FloquetBasis(H, T)
-    energy = floquet_basis.e_quasi
-    delta = _floquet_delta_tensor(energy, kmax, T)
-    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
-    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
-    a = _floquet_A_matrix(delta, gamma, w_th)
-    r = _floquet_master_equation_tensor(a)
-    dims = floquet_basis.U(0).dims
-    return Qobj(
-        r, dims=[dims, dims], type="super", superrep="super", copy=False
-    )
-
-
-def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
-    """
-    Solve the Schrodinger equation using the Floquet formalism.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Periodic system Hamiltonian as :class:`QobjEvo`. List of
-        [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    psi0 : :class:`qutip.qobj`
-        Initial state vector (ket). If an operator is provided,
-
-    tlist : *list* / *array*
-        List of times for :math:`t`.
-
-    e_ops : list of :class:`qutip.qobj` / callback function, optional
-        List of operators for which to evaluate expectation values. If this
-        list is empty, the state vectors for each time in `tlist` will be
-        returned instead of expectation values.
-
-    T : float, default=tlist[-1]
-        The period of the time-dependence of the hamiltonian.
-
-    args : dictionary, optional
-        Dictionary with variables required to evaluate H.
-
-    options : dict, optional
-        Options for the results.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-
-    Returns
-    -------
-    output : :class:`qutip.solver.Result`
-        An instance of the class :class:`qutip.solver.Result`, which
-        contains either an *array* of expectation values or an array of
-        state vectors, for the times specified by `tlist`.
-    """
-    if isinstance(H, FloquetBasis):
-        floquet_basis = H
-    else:
-        T = T or tlist[-1]
-        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
-        # are for the open system evolution.
-        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
-
-    f_coeff = floquet_basis.to_floquet_basis(psi0)
-    result_options = {
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-    }
-    result_options.update(options or {})
-    result = Result(e_ops, result_options, solver="fsesolve")
-    for t in tlist:
-        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
-        result.add(t, state_t)
-
-    return result
-
-
-def fmmesolve(
-    H,
-    rho0,
-    tlist,
-    c_ops=None,
-    e_ops=None,
-    spectra_cb=None,
-    T=0,
-    w_th=0.0,
-    args=None,
-    options=None,
-):
-    """
-    Solve the dynamics for the system using the Floquet-Markov master equation.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Periodic system Hamiltonian as :class:`QobjEvo`. List of
-        [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    rho0 / psi0 : :class:`qutip.Qobj`
-        Initial density matrix or state vector (ket).
-
-    tlist : *list* / *array*
-        List of times for :math:`t`.
-
-    c_ops : list of :class:`qutip.Qobj`
-        List of collapse operators. Time dependent collapse operators are not
-        supported.
-
-    e_ops : list of :class:`qutip.Qobj` / callback function
-        List of operators for which to evaluate expectation values.
-        The states are reverted to the lab basis before applying the
-
-    spectra_cb : list callback functions
-        List of callback functions that compute the noise power spectrum as
-        a function of frequency for the collapse operators in `c_ops`.
-
-    T : float
-        The period of the time-dependence of the hamiltonian. The default value
-        'None' indicates that the 'tlist' spans a single period of the driving.
-
-    w_th : float
-        The temperature of the environment in units of frequency.
-        For example, if the Hamiltonian written in units of 2pi GHz, and the
-        temperature is given in K, use the following conversion:
-
-            temperature = 25e-3 # unit K
-            h = 6.626e-34
-            kB = 1.38e-23
-            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
-
-    args : *dictionary*
-        Dictionary of parameters for time-dependent Hamiltonian
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - store_floquet_states : bool
-          Whether or not to store the density matrices in the floquet basis in
-          ``result.floquet_states``.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        the expectation values for the times specified by `tlist`, and/or the
-        state density matrices corresponding to the times.
-    """
-    if c_ops is None:
-        return fsesolve(
-            H,
-            rho0,
-            tlist,
-            e_ops=e_ops,
-            T=T,
-            w_th=w_th,
-            args=args,
-            options=options,
-        )
-
-    if isinstance(H, FloquetBasis):
-        floquet_basis = H
-    else:
-        T = T or tlist[-1]
-        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
-        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
-        # are for the open system evolution.
-        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
-
-    if not w_th and args:
-        w_th = args.get("w_th", 0.0)
-
-    if isinstance(c_ops, Qobj):
-        c_ops = [c_ops]
-
-    if spectra_cb is None:
-        spectra_cb = [lambda w: (w > 0)]
-    elif callable(spectra_cb):
-        spectra_cb = [spectra_cb]
-    if len(spectra_cb) == 1:
-        spectra_cb = spectra_cb * len(c_ops)
-
-    a_ops = list(zip(c_ops, spectra_cb))
-
-    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
-    return solver.run(rho0, tlist, e_ops=e_ops)
-
-
-class FloquetResult(Result):
-    def _post_init(self, floquet_basis):
-        self.floquet_basis = floquet_basis
-        if self.options["store_floquet_states"]:
-            self.floquet_states = []
-        else:
-            self.floquet_states = None
-        super()._post_init()
-
-    def add(self, t, state):
-        if self.options["store_floquet_states"]:
-            self.floquet_states.append(state)
-
-        state = self.floquet_basis.from_floquet_basis(state, t)
-        super().add(t, state)
-
-
-class FMESolver(MESolver):
-    """
-    Solver for the Floquet-Markov master equation.
-
-    .. note ::
-        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
-
-    Parameters
-    ----------
-    floquet_basis : :class:`qutip.FloquetBasis`
-        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
-        different integrator for the ``floquet_basis`` than for the evolution
-        of the floquet state can improve the performance.
-
-    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
-        List of collapse operators and the corresponding function for the noise
-        power spectrum. The collapse operator must be a :class:`Qobj` and
-        cannot be time dependent. The spectrum function must take and return
-        an numpy array.
-
-    w_th : float
-        The temperature of the environment in units of Hamiltonian frequency.
-
-    kmax : int [5]
-        The truncation of the number of sidebands..
-
-    nT : int [20*kmax]
-        The number of integration steps (for calculating X) within one period.
-
-    options : dict, optional
-        Options for the solver, see :obj:`FMESolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-    """
-
-    name = "fmmesolve"
-    _avail_integrators = {}
-    resultclass = FloquetResult
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-        "method": "adams",
-        "store_floquet_states": False,
-    }
-
-    def __init__(
-        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
-    ):
-        self.options = options
-        if isinstance(floquet_basis, FloquetBasis):
-            self.floquet_basis = floquet_basis
-        else:
-            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
-
-        nT = nT or max(100, 20 * kmax)
-        self._num_collapse = len(a_ops)
-        c_ops, spectra_cb = zip(*a_ops)
-        if not all(
-            isinstance(c_op, Qobj) and callable(spectrum)
-            for c_op, spectrum in a_ops
-        ):
-            raise TypeError("a_ops must be tuple of (Qobj, callable)")
-        self.rhs = QobjEvo(
-            floquet_tensor(
-                self.floquet_basis,
-                c_ops,
-                spectra_cb,
-                w_th=w_th,
-                kmax=kmax,
-                nT=nT,
-            )
-        )
-
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-    def _initialize_stats(self):
-        stats = Solver._initialize_stats(self)
-        stats.update(
-            {
-                "solver": "Floquet-Markov master equation",
-                "num_collapse": self._num_collapse,
-            }
-        )
-        return stats
-
-    def _argument(self, args):
-        if args:
-            raise ValueError("FMESolver cannot update arguments")
-
-    def start(self, state0, t0, *, floquet=False):
-        """
-        Set the initial state and time for a step evolution.
-        ``options`` for the evolutions are read at this step.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        t0 : double
-            Initial time of the evolution.
-
-        floquet : bool, optional {False}
-            Whether the initial state is in the floquet basis or laboratory
-            basis.
-        """
-        if not floquet:
-            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
-        super().start(state0, t0)
-
-    def step(self, t, *, args=None, copy=True, floquet=False):
-        """
-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-
-        Parameters
-        ----------
-        t : double
-            Time to evolve to, must be higher than the last call.
-
-        copy : bool, optional {True}
-            Whether to return a copy of the data or the data in the ODE solver.
-
-        floquet : bool, optional {False}
-            Whether to return the state in the floquet basis or laboratory
-            basis.
-
-        args : dict, optional {None}
-            Not supported
-
-        .. note::
-            The state must be initialized first by calling ``start`` or
-            ``run``. If ``run`` is called, ``step`` will continue from the last
-            time and state obtained.
-        """
-        if args:
-            raise ValueError("FMESolver cannot update arguments")
-        state = super().step(t)
-        if not floquet:
-            state = self.floquet_basis.from_floquet_basis(state, t)
-        elif copy:
-            state = state.copy()
-        return state
-
-    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
-        """
-        Calculate the evolution of the quantum system.
-
-        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
-        ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :class:`Result`. The evolution method and
-        stored results are determined by ``options``.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        tlist : list of double
-            Time for which to save the results (state and/or expect) of the
-            evolution. The first element of the list is the initial time of the
-            evolution. Each times of the list must be increasing, but does not
-            need to be uniformy distributed.
-
-        floquet : bool, optional {False}
-            Whether the initial state in the floquet basis or laboratory basis.
-
-        args : dict, optional {None}
-            Not supported
-
-        e_ops : list {None}
-            List of Qobj, QobjEvo or callable to compute the expectation
-            values. Function[s] must have the signature
-            f(t : float, state : Qobj) -> expect.
-
-        Returns
-        -------
-        results : :class:`qutip.solver.FloquetResult`
-            Results of the evolution. States and/or expect will be saved. You
-            can control the saved data in the options.
-        """
-        if args:
-            raise ValueError("FMESolver cannot update arguments")
-        if not floquet:
-            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
-        _time_start = time()
-        _data0 = self._prepare_state(state0)
-        self._integrator.set_state(tlist[0], _data0)
-        stats = self._initialize_stats()
-        results = self.resultclass(
-            e_ops,
-            self.options,
-            solver=self.name,
-            stats=stats,
-            floquet_basis=self.floquet_basis,
-        )
-        results.add(tlist[0], self._restore_state(_data0, copy=False))
-        stats["preparation time"] += time() - _time_start
-
-        progress_bar = progess_bars[self.options["progress_bar"]]()
-        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
-        for t, state in self._integrator.run(tlist):
-            progress_bar.update()
-            results.add(t, self._restore_state(state, copy=False))
-        progress_bar.finished()
-
-        stats["run time"] = progress_bar.total_time()
-        # TODO: It would be nice if integrator could give evolution statistics
-        # stats.update(_integrator.stats)
-        return results
+__all__ = [
+    "FloquetBasis",
+    "floquet_tensor",
+    "fsesolve",
+    "fmmesolve",
+    "FMESolver",
+]
+
+import numpy as np
+from qutip.core import data as _data
+from qutip import Qobj, QobjEvo
+from .propagator import Propagator
+from .mesolve import MESolver
+from .solver_base import Solver
+from .integrator import Integrator
+from .result import Result
+from time import time
+from ..ui.progressbar import progess_bars
+
+
+class FloquetBasis:
+    """
+    Utility to compute floquet modes and states.
+
+    Attributes
+    ----------
+    U : :class:`Propagator`
+        The propagator of the Hamiltonian over one period.
+
+    evecs : :class:`qutip.data.Data`
+        Matrix where each column is an initial Floquet mode.
+
+    e_quasi : np.ndarray[float]
+        The quasi energies of the Hamiltonian.
+    """
+
+    def __init__(
+        self,
+        H,
+        T,
+        args=None,
+        options=None,
+        sparse=False,
+        sort=True,
+        precompute=None,
+    ):
+        """
+        Parameters
+        ----------
+        H : :class:`Qobj`, :class:`QobjEvo`, QobjEvo compatible format.
+            System Hamiltonian, with period `T`.
+
+        T : float
+            Period of the Hamiltonian.
+
+        args : None / *dictionary*
+            dictionary of parameters for time-dependent Hamiltonians and
+            collapse operators.
+
+        options : dict [None]
+            Options used by sesolve to compute the floquet modes.
+
+        sparse : bool [False]
+            Whether to use the sparse eigen solver when computing the
+            quasi-energies.
+
+        sort : bool [True]
+            Whether to sort the quasi-energies.
+
+        precompute : list [None]
+            If provided, a list of time at which to store the propagators
+            for later use when computing modes and states. Default is
+            ``linspace(0, T, 101)`` corresponding to the default integration
+            steps used for the floquet tensor computation.
+        """
+        if not T > 0:
+            raise ValueError("The period need to be a positive number.")
+        self.T = T
+        if precompute is not None:
+            tlist = np.unique(np.atleast_1d(precompute) % self.T)
+            memoize = len(tlist)
+            if tlist[0] != 0:
+                memoize += 1
+            if tlist[-1] != T:
+                memoize += 1
+        else:
+            # Default computation
+            tlist = np.linspace(0, T, 101)
+            memoize = 101
+        self.U = Propagator(H, args=args, options=options, memoize=memoize)
+        for t in tlist:
+            # Do the evolution by steps to save the intermediate results.
+            self.U(t)
+        U_T = self.U(self.T)
+        if not sparse and isinstance(U_T.data, _data.CSR):
+            U_T = U_T.to("Dense")
+        evals, evecs = _data.eigs(U_T.data)
+        e_quasi = -np.angle(evals) / T
+        if sort:
+            perm = np.argsort(e_quasi)
+            self.evecs = _data.permute.indices(evecs, col_perm=np.argsort(perm))
+            self.e_quasi = e_quasi[perm]
+        else:
+            self.evecs = evecs
+            self.e_quasi = e_quasi
+
+    def _as_ketlist(self, kets_mat):
+        """
+        Split the Data array in a list of kets.
+        """
+        dims = [self.U(0).dims[0], [1]]
+        return [
+            Qobj(ket, dims=dims, type="ket")
+            for ket in _data.split_columns(kets_mat)
+        ]
+
+    def mode(self, t, data=False):
+        """
+        Calculate the Floquet modes at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+            The time for which to evaluate the Floquet mode.
+
+        data : bool [False]
+            Whether to return the states as a single data matrix or a list of
+            ket states.
+
+        Returns
+        -------
+        output : list[:class:`Qobj`], :class:`qutip.data.Data`
+            A list of Floquet states for the time ``t`` or the states as column
+            in a single matrix.
+        """
+        t = t % self.T
+        if t == 0.0:
+            kets_mat = self.evecs
+        else:
+            U = self.U(t).data
+            phases = _data.diag(np.exp(1j * t * self.e_quasi))
+            kets_mat = U @ self.evecs @ phases
+        if data:
+            return kets_mat
+        else:
+            return self._as_ketlist(kets_mat)
+
+    def state(self, t, data=False):
+        """
+        Evaluate the floquet states at time t.
+
+        Parameters
+        ----------
+        t : float
+            The time for which to evaluate the Floquet states.
+
+        data : bool [False]
+            Whether to return the states as a single data matrix or a list of
+            ket states.
+
+        Returns
+        -------
+        output : list[:class:`Qobj`], :class:`qutip.data.Data`
+            A list of Floquet states for the time ``t`` or the states as column
+            in a single matrix.
+        """
+        if t:
+            phases = _data.diag(np.exp(-1j * t * self.e_quasi))
+            states_mat = self.mode(t, True) @ phases
+        else:
+            states_mat = self.evecs
+        if data:
+            return states_mat
+        else:
+            return self._as_ketlist(states_mat)
+
+    def from_floquet_basis(self, floquet_basis, t=0):
+        """
+        Transform a ket or density matrix from the Floquet basis at time ``t``
+        to the lab basis.
+
+        Parameters
+        ----------
+        floquet_basis : :class:`Qobj`, :class:`qutip.data.Data`
+            Initial state in the Floquet basis at time ``t``. May be either a
+            ket or density matrix.
+
+        t : float [0]
+            The time at which to evaluate the Floquet states.
+
+        Returns
+        -------
+        output : :class:`Qobj`, :class:`qutip.data.Data`
+            The state in the lab basis. The return type is the same as the type
+            of the input state.
+        """
+        is_Qobj = isinstance(floquet_basis, Qobj)
+        if is_Qobj:
+            dims = floquet_basis.dims
+            floquet_basis = floquet_basis.data
+            if dims[0] != self.U(0).dims[1]:
+                raise ValueError(
+                    "Dimensions of the state do not match the Hamiltonian"
+                )
+
+        state_mat = self.state(t, True)
+        lab_basis = state_mat @ floquet_basis
+        if floquet_basis.shape[1] != 1:
+            lab_basis = lab_basis @ state_mat.adjoint()
+
+        if is_Qobj:
+            return Qobj(lab_basis, dims=dims)
+        return lab_basis
+
+    def to_floquet_basis(self, lab_basis, t=0):
+        """
+        Transform a ket or density matrix in the lab basis
+        to the Floquet basis at time ``t``.
+
+        Parameters
+        ----------
+        lab_basis : :class:`Qobj`, :class:`qutip.data.Data`
+            Initial state in the lab basis.
+
+        t : float [0]
+            The time at which to evaluate the Floquet states.
+
+        Returns
+        -------
+        output : :class:`Qobj`, :class:`qutip.data.Data`
+            The state in the Floquet basis. The return type is the same as the
+            type of the input state.
+        """
+        is_Qobj = isinstance(lab_basis, Qobj)
+        if is_Qobj:
+            dims = lab_basis.dims
+            lab_basis = lab_basis.data
+            if dims[0] != self.U(0).dims[1]:
+                raise ValueError(
+                    "Dimensions of the state do not match the Hamiltonian"
+                )
+
+        state_mat = self.state(t, True)
+        floquet_basis = state_mat.adjoint() @ lab_basis
+        if lab_basis.shape[1] != 1:
+            floquet_basis = floquet_basis @ state_mat
+
+        if is_Qobj:
+            return Qobj(floquet_basis, dims=dims)
+        return floquet_basis
+
+
+def _floquet_delta_tensor(f_energies, kmax, T):
+    """
+    Floquet-Markov master equation X matrices.
+
+    Parameters
+    ----------
+    f_energies : np.ndarray
+        The Floquet energies.
+
+    kmax : int
+        The truncation of the number of sidebands (default 5).
+
+    T : float
+        The period of the time-dependence of the Hamiltonian.
+
+    Returns
+    -------
+    delta : np.ndarray
+        Floquet delta tensor.
+    """
+    delta = np.subtract.outer(f_energies, f_energies)
+    return np.add.outer(delta, np.arange(-kmax, kmax + 1) * (2 * np.pi / T))
+
+
+def _floquet_X_matrices(floquet_basis, c_ops, kmax, ntimes=100):
+    """
+    Floquet-Markov master equation X matrices.
+
+    Parameters
+    ----------
+    floquet_basis : :class:`FloquetBasis`
+        The system Hamiltonian wrapped in a FloquetBasis object.
+
+    c_ops : list of :class:`Qobj`
+        The collapse operators describing the dissipation.
+
+    kmax : int
+        The truncation of the number of sidebands (default 5).
+
+    ntimes : int [100]
+        The number of integration steps (for calculating X) within one period.
+
+    Returns
+    -------
+    X : list of dict of :class:`qutip.data.Data`
+        A dict of the sidebands ``k`` for the X matrices of each c_ops
+    """
+    T = floquet_basis.T
+    N = floquet_basis.U(0).shape[0]
+    omega = (2 * np.pi) / T
+    tlist = np.linspace(T / ntimes, T, ntimes)
+    ks = np.arange(-kmax, kmax + 1)
+    out = {k: [_data.csr.zeros(N, N)] * len(c_ops) for k in ks}
+
+    for t in tlist:
+        mode = floquet_basis.mode(t, data=True)
+        FFs = [mode.adjoint() @ c_op.data @ mode for c_op in c_ops]
+        for k, phi in zip(ks, np.exp(-1j * ks * omega * t) / ntimes):
+            out[k] = [
+                _data.add(prev, new, phi) for prev, new in zip(out[k], FFs)
+            ]
+
+    return [{k: out[k][i] for k in ks} for i in range(len(c_ops))]
+
+
+def _floquet_gamma_matrices(X, delta, J_cb):
+    """
+    Floquet-Markov master equation gamma matrices.
+
+    Parameters
+    ----------
+    X : list of dict of :class:`qutip.data.Data`
+        Floquet X matrices created by :func:`_floquet_X_matrices`.
+
+    delta : np.ndarray
+        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
+
+    J_cb : list of callables
+        A list callback functions that compute the noise power spectrum as
+        a function of frequency. The list should contain one callable for each
+        collapse operator `c_op`, in the same order as the elements of `X`.
+        Each callable should accept a numpy array of frequencies and return a
+        numpy array of corresponding noise power.
+
+    Returns
+    -------
+    gammas : dict of :class:`qutip.data.Data`
+        A dict mapping the sidebands ``k`` to their gamma matrices.
+    """
+    N = delta.shape[0]
+    kmax = (delta.shape[2] - 1) // 2
+    gamma = {k: _data.csr.zeros(N, N) for k in range(-kmax, kmax + 1, 1)}
+
+    for X_c_op, sp in zip(X, J_cb):
+        response = sp(delta) * ((2 + 0j) * np.pi)
+        response = [
+            _data.Dense(response[:, :, k], copy=False)
+            for k in range(2 * kmax + 1)
+        ]
+        for k in range(-kmax, kmax + 1, 1):
+            gamma[k] = _data.add(
+                gamma[k],
+                _data.multiply(
+                    _data.multiply(X_c_op[k].conj(), X_c_op[k]),
+                    response[k + kmax],
+                ),
+            )
+    return gamma
+
+
+def _floquet_A_matrix(delta, gamma, w_th):
+    """
+    Floquet-Markov master equation rate matrix.
+
+    Parameters
+    ----------
+    delta : np.ndarray
+        Floquet delta tensor created by :func:`_floquet_delta_tensor`.
+
+    gamma : dict of :class:`qutip.data.Data`
+        Floquet gamma matrices created by :func:`_floquet_gamma_matrices`.
+
+    w_th : float
+        The temperature in units of frequency.
+    """
+    kmax = (delta.shape[2] - 1) // 2
+
+    if w_th > 0.0:
+        deltap = np.copy(delta)
+        deltap[deltap == 0.0] = np.inf
+        thermal = 1.0 / (np.exp(np.abs(deltap) / w_th) - 1.0)
+        thermal = [_data.Dense(thermal[:, :, k]) for k in range(2 * kmax + 1)]
+
+        gamma_kk = _data.add(gamma[0], gamma[0].transpose())
+        A = _data.add(gamma[0], _data.multiply(thermal[kmax], gamma_kk))
+
+        for k in range(1, kmax + 1):
+            g_kk = _data.add(gamma[k], gamma[-k].transpose())
+            thermal_kk = _data.multiply(thermal[kmax + k], g_kk)
+            A = _data.add(A, _data.add(gamma[k], thermal_kk))
+            thermal_kk = _data.multiply(thermal[kmax - k], g_kk.transpose())
+            A = _data.add(A, _data.add(gamma[-k], thermal_kk))
+    else:
+        # w_th is 0, thermal = 0s
+        A = gamma[0]
+        for k in range(1, kmax + 1):
+            A = _data.add(gamma[k], A)
+            A = _data.add(gamma[-k], A)
+
+    return A
+
+
+def _floquet_master_equation_tensor(A):
+    """
+    Construct a tensor that represents the master equation in the floquet
+    basis (with constant Hamiltonian and collapse operators?).
+
+    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
+
+    Parameters
+    ----------
+    A : :class:`qutip.data.Data`
+        Floquet-Markov master equation rate matrix.
+
+    Returns
+    -------
+    output : array
+        The Floquet-Markov master equation tensor `R`.
+    """
+    N = A.shape[0]
+
+    # R[i+N*i, j+N*j] = A[j, i]
+    cols = np.arange(N, dtype=np.int32)
+    rows = np.linspace(1 - 1 / (N + 1), N, N**2 + 1, dtype=np.int32)
+    data = np.ones(N, dtype=complex)
+    expand = _data.csr.CSR((data, cols, rows), shape=(N**2, N))
+
+    R = expand @ A.transpose() @ expand.transpose()
+
+    # S[i+N*j, j+N*i] = -1/2 * sum_k(A[i, k] + A[j, k])
+    ket_1 = _data.Dense(np.ones(N, dtype=complex))
+    Asum = A @ ket_1
+    to_super = _data.add(_data.kron(Asum, ket_1), _data.kron(ket_1, Asum))
+    S = _data.diag(to_super.to_array().flatten() * -0.5, 0)
+
+    return _data.add(R, S)
+
+
+def floquet_tensor(H, c_ops, spectra_cb, T=0, w_th=0.0, kmax=5, nT=100):
+    """
+    Construct a tensor that represents the master equation in the floquet
+    basis.
+
+    Simplest RWA approximation [Grifoni et al, Phys.Rep. 304 229 (1998)]
+
+    Parameters
+    ----------
+    H : :class:`QobjEvo`
+        Periodic Hamiltonian
+
+    T : float
+        The period of the time-dependence of the hamiltonian.
+
+    c_ops : list of :class:`qutip.qobj`
+        list of collapse operators.
+
+    spectra_cb : list callback functions
+        List of callback functions that compute the noise power spectrum as
+        a function of frequency for the collapse operators in `c_ops`.
+
+    w_th : float
+        The temperature in units of frequency.
+
+    kmax : int
+        The truncation of the number of sidebands (default 5).
+
+    Returns
+    -------
+    output : array
+        The Floquet-Markov master equation tensor `R`.
+    """
+    if isinstance(H, FloquetBasis):
+        floquet_basis = H
+        T = H.T
+    else:
+        floquet_basis = FloquetBasis(H, T)
+    energy = floquet_basis.e_quasi
+    delta = _floquet_delta_tensor(energy, kmax, T)
+    x = _floquet_X_matrices(floquet_basis, c_ops, kmax, nT)
+    gamma = _floquet_gamma_matrices(x, delta, spectra_cb)
+    a = _floquet_A_matrix(delta, gamma, w_th)
+    r = _floquet_master_equation_tensor(a)
+    dims = floquet_basis.U(0).dims
+    return Qobj(
+        r, dims=[dims, dims], type="super", superrep="super", copy=False
+    )
+
+
+def fsesolve(H, psi0, tlist, e_ops=None, T=0.0, args=None, options=None):
+    """
+    Solve the Schrodinger equation using the Floquet formalism.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Periodic system Hamiltonian as :class:`QobjEvo`. List of
+        [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    psi0 : :class:`qutip.qobj`
+        Initial state vector (ket). If an operator is provided,
+
+    tlist : *list* / *array*
+        List of times for :math:`t`.
+
+    e_ops : list of :class:`qutip.qobj` / callback function, optional
+        List of operators for which to evaluate expectation values. If this
+        list is empty, the state vectors for each time in `tlist` will be
+        returned instead of expectation values.
+
+    T : float, default=tlist[-1]
+        The period of the time-dependence of the hamiltonian.
+
+    args : dictionary, optional
+        Dictionary with variables required to evaluate H.
+
+    options : dict, optional
+        Options for the results.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+
+    Returns
+    -------
+    output : :class:`qutip.solver.Result`
+        An instance of the class :class:`qutip.solver.Result`, which
+        contains either an *array* of expectation values or an array of
+        state vectors, for the times specified by `tlist`.
+    """
+    if isinstance(H, FloquetBasis):
+        floquet_basis = H
+    else:
+        T = T or tlist[-1]
+        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
+        # are for the open system evolution.
+        floquet_basis = FloquetBasis(H, T, args, precompute=tlist)
+
+    f_coeff = floquet_basis.to_floquet_basis(psi0)
+    result_options = {
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+    }
+    result_options.update(options or {})
+    result = Result(e_ops, result_options, solver="fsesolve")
+    for t in tlist:
+        state_t = floquet_basis.from_floquet_basis(f_coeff, t)
+        result.add(t, state_t)
+
+    return result
+
+
+def fmmesolve(
+    H,
+    rho0,
+    tlist,
+    c_ops=None,
+    e_ops=None,
+    spectra_cb=None,
+    T=0,
+    w_th=0.0,
+    args=None,
+    options=None,
+):
+    """
+    Solve the dynamics for the system using the Floquet-Markov master equation.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Periodic system Hamiltonian as :class:`QobjEvo`. List of
+        [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    rho0 / psi0 : :class:`qutip.Qobj`
+        Initial density matrix or state vector (ket).
+
+    tlist : *list* / *array*
+        List of times for :math:`t`.
+
+    c_ops : list of :class:`qutip.Qobj`
+        List of collapse operators. Time dependent collapse operators are not
+        supported.
+
+    e_ops : list of :class:`qutip.Qobj` / callback function
+        List of operators for which to evaluate expectation values.
+        The states are reverted to the lab basis before applying the
+
+    spectra_cb : list callback functions
+        List of callback functions that compute the noise power spectrum as
+        a function of frequency for the collapse operators in `c_ops`.
+
+    T : float
+        The period of the time-dependence of the hamiltonian. The default value
+        'None' indicates that the 'tlist' spans a single period of the driving.
+
+    w_th : float
+        The temperature of the environment in units of frequency.
+        For example, if the Hamiltonian written in units of 2pi GHz, and the
+        temperature is given in K, use the following conversion:
+
+            temperature = 25e-3 # unit K
+            h = 6.626e-34
+            kB = 1.38e-23
+            args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9
+
+    args : *dictionary*
+        Dictionary of parameters for time-dependent Hamiltonian
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - store_floquet_states : bool
+          Whether or not to store the density matrices in the floquet basis in
+          ``result.floquet_states``.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        the expectation values for the times specified by `tlist`, and/or the
+        state density matrices corresponding to the times.
+    """
+    if c_ops is None:
+        return fsesolve(
+            H,
+            rho0,
+            tlist,
+            e_ops=e_ops,
+            T=T,
+            w_th=w_th,
+            args=args,
+            options=options,
+        )
+
+    if isinstance(H, FloquetBasis):
+        floquet_basis = H
+    else:
+        T = T or tlist[-1]
+        t_precompute = np.concatenate([tlist, np.linspace(0, T, 101)])
+        # `fsesolve` is a fallback from `fmmesolve`, for the later, options
+        # are for the open system evolution.
+        floquet_basis = FloquetBasis(H, T, args, precompute=t_precompute)
+
+    if not w_th and args:
+        w_th = args.get("w_th", 0.0)
+
+    if isinstance(c_ops, Qobj):
+        c_ops = [c_ops]
+
+    if spectra_cb is None:
+        spectra_cb = [lambda w: (w > 0)]
+    elif callable(spectra_cb):
+        spectra_cb = [spectra_cb]
+    if len(spectra_cb) == 1:
+        spectra_cb = spectra_cb * len(c_ops)
+
+    a_ops = list(zip(c_ops, spectra_cb))
+
+    solver = FMESolver(floquet_basis, a_ops, w_th=w_th, options=options)
+    return solver.run(rho0, tlist, e_ops=e_ops)
+
+
+class FloquetResult(Result):
+    def _post_init(self, floquet_basis):
+        self.floquet_basis = floquet_basis
+        if self.options["store_floquet_states"]:
+            self.floquet_states = []
+        else:
+            self.floquet_states = None
+        super()._post_init()
+
+    def add(self, t, state):
+        if self.options["store_floquet_states"]:
+            self.floquet_states.append(state)
+
+        state = self.floquet_basis.from_floquet_basis(state, t)
+        super().add(t, state)
+
+
+class FMESolver(MESolver):
+    """
+    Solver for the Floquet-Markov master equation.
+
+    .. note ::
+        Operators (``c_ops`` and ``e_ops``) are in the laboratory basis.
+
+    Parameters
+    ----------
+    floquet_basis : :class:`qutip.FloquetBasis`
+        The system Hamiltonian wrapped in a FloquetBasis object. Choosing a
+        different integrator for the ``floquet_basis`` than for the evolution
+        of the floquet state can improve the performance.
+
+    a_ops : list of tuple(:class:`qutip.Qobj`, callable)
+        List of collapse operators and the corresponding function for the noise
+        power spectrum. The collapse operator must be a :class:`Qobj` and
+        cannot be time dependent. The spectrum function must take and return
+        an numpy array.
+
+    w_th : float
+        The temperature of the environment in units of Hamiltonian frequency.
+
+    kmax : int [5]
+        The truncation of the number of sidebands..
+
+    nT : int [20*kmax]
+        The number of integration steps (for calculating X) within one period.
+
+    options : dict, optional
+        Options for the solver, see :obj:`FMESolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+    """
+
+    name = "fmmesolve"
+    _avail_integrators = {}
+    resultclass = FloquetResult
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+        "method": "adams",
+        "store_floquet_states": False,
+    }
+
+    def __init__(
+        self, floquet_basis, a_ops, w_th=0.0, *, kmax=5, nT=None, options=None
+    ):
+        self.options = options
+        if isinstance(floquet_basis, FloquetBasis):
+            self.floquet_basis = floquet_basis
+        else:
+            raise TypeError("The ``floquet_basis`` must be a FloquetBasis")
+
+        nT = nT or max(100, 20 * kmax)
+        self._num_collapse = len(a_ops)
+        c_ops, spectra_cb = zip(*a_ops)
+        if not all(
+            isinstance(c_op, Qobj) and callable(spectrum)
+            for c_op, spectrum in a_ops
+        ):
+            raise TypeError("a_ops must be tuple of (Qobj, callable)")
+        self.rhs = QobjEvo(
+            floquet_tensor(
+                self.floquet_basis,
+                c_ops,
+                spectra_cb,
+                w_th=w_th,
+                kmax=kmax,
+                nT=nT,
+            )
+        )
+
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+    def _initialize_stats(self):
+        stats = Solver._initialize_stats(self)
+        stats.update(
+            {
+                "solver": "Floquet-Markov master equation",
+                "num_collapse": self._num_collapse,
+            }
+        )
+        return stats
+
+    def _argument(self, args):
+        if args:
+            raise ValueError("FMESolver cannot update arguments")
+
+    def start(self, state0, t0, *, floquet=False):
+        """
+        Set the initial state and time for a step evolution.
+        ``options`` for the evolutions are read at this step.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        t0 : double
+            Initial time of the evolution.
+
+        floquet : bool, optional {False}
+            Whether the initial state is in the floquet basis or laboratory
+            basis.
+        """
+        if not floquet:
+            state0 = self.floquet_basis.to_floquet_basis(state0, t0)
+        super().start(state0, t0)
+
+    def step(self, t, *, args=None, copy=True, floquet=False):
+        """
+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+
+        Parameters
+        ----------
+        t : double
+            Time to evolve to, must be higher than the last call.
+
+        copy : bool, optional {True}
+            Whether to return a copy of the data or the data in the ODE solver.
+
+        floquet : bool, optional {False}
+            Whether to return the state in the floquet basis or laboratory
+            basis.
+
+        args : dict, optional {None}
+            Not supported
+
+        .. note::
+            The state must be initialized first by calling ``start`` or
+            ``run``. If ``run`` is called, ``step`` will continue from the last
+            time and state obtained.
+        """
+        if args:
+            raise ValueError("FMESolver cannot update arguments")
+        state = super().step(t)
+        if not floquet:
+            state = self.floquet_basis.from_floquet_basis(state, t)
+        elif copy:
+            state = state.copy()
+        return state
+
+    def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
+        """
+        Calculate the evolution of the quantum system.
+
+        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
+        ``rhs`` and for each time in ``tlist`` store the state and/or
+        expectation values in a :class:`Result`. The evolution method and
+        stored results are determined by ``options``.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        tlist : list of double
+            Time for which to save the results (state and/or expect) of the
+            evolution. The first element of the list is the initial time of the
+            evolution. Each times of the list must be increasing, but does not
+            need to be uniformy distributed.
+
+        floquet : bool, optional {False}
+            Whether the initial state in the floquet basis or laboratory basis.
+
+        args : dict, optional {None}
+            Not supported
+
+        e_ops : list {None}
+            List of Qobj, QobjEvo or callable to compute the expectation
+            values. Function[s] must have the signature
+            f(t : float, state : Qobj) -> expect.
+
+        Returns
+        -------
+        results : :class:`qutip.solver.FloquetResult`
+            Results of the evolution. States and/or expect will be saved. You
+            can control the saved data in the options.
+        """
+        if args:
+            raise ValueError("FMESolver cannot update arguments")
+        if not floquet:
+            state0 = self.floquet_basis.to_floquet_basis(state0, tlist[0])
+        _time_start = time()
+        _data0 = self._prepare_state(state0)
+        self._integrator.set_state(tlist[0], _data0)
+        stats = self._initialize_stats()
+        results = self.resultclass(
+            e_ops,
+            self.options,
+            solver=self.name,
+            stats=stats,
+            floquet_basis=self.floquet_basis,
+        )
+        results.add(tlist[0], self._restore_state(_data0, copy=False))
+        stats["preparation time"] += time() - _time_start
+
+        progress_bar = progess_bars[self.options["progress_bar"]]()
+        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
+        for t, state in self._integrator.run(tlist):
+            progress_bar.update()
+            results.add(t, self._restore_state(state, copy=False))
+        progress_bar.finished()
+
+        stats["run time"] = progress_bar.total_time()
+        # TODO: It would be nice if integrator could give evolution statistics
+        # stats.update(_integrator.stats)
+        return results
diff --git a/qutip/solver/floquet_bwcomp.py b/qutip/solver/floquet_bwcomp.py
index 6937240fda..8ee683ffd8 100644
--- a/qutip/solver/floquet_bwcomp.py
+++ b/qutip/solver/floquet_bwcomp.py
@@ -1,244 +1,244 @@
-""" Floquet solver compatibility functions that behave like the corresponding
-functions from QuTiP 4.7.
-
-These functions are indented to be used when porting code from QuTiP 4.7 to
-QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
-"""
-
-__all__ = [
-    "floquet_modes",
-    "floquet_modes_t",
-    "floquet_modes_table",
-    "floquet_modes_t_lookup",
-    "floquet_states",
-    "floquet_states_t",
-    "floquet_wavefunction",
-    "floquet_wavefunction_t",
-    "floquet_state_decomposition",
-    "floquet_master_equation_rates",
-]
-
-from .floquet import *
-import numpy as np
-import warnings
-
-
-def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
-    """
-    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
-    period T.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
-    f_mode_0 = fbasis.mode(0)
-    f_energies = fbasis.e_quasi
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
-    f_mode_0 = fbasis.mode(0)
-    f_energies = fbasis.e_quasi
-    return f_mode_0, f_energies
-
-
-def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
-    """
-    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
-    initial Floquet modes Phi_alpha(0).
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_mode_t = fbasis.mode(t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    return fbasis.mode(t)
-
-
-def floquet_modes_table(
-    f_modes_0, f_energies, tlist, H, T, args=None, options=None
-):
-    """
-    Pre-calculate the Floquet modes for a range of times spanning the floquet
-    period. Can later be used as a table to look up the floquet modes for
-    any time.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
-    """
-    raise NotImplementedError("`floquet_modes_table` is deprecated.")
-
-
-def floquet_modes_t_lookup(f_modes_table_t, t, T):
-    """
-    Lookup the floquet mode at time t in the pre-calculated table of floquet
-    modes in the first period of the time-dependence.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    f_modes_table_t = fbasis = FloquetBasis(...)
-    f_mode_t = f_modes_table_t.mode(t)
-    """
-    raise NotImplementedError(
-        "`floquet_modes_t_lookup` is no longer provided. "
-        "Use `FloquetBasis` instead."
-    )
-
-
-def floquet_states(f_modes_t, f_energies, t):
-    """
-    Evaluate the floquet states at time t given the Floquet modes at that time.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_state_t = fbasis.state(t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_states` is deprecated. "
-        "Use `FloquetBasis.state` instead."
-    ))
-    return [
-        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
-        for i in np.arange(len(f_energies))
-    ]
-
-
-def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
-    """
-    Evaluate the floquet states at time t given the initial Floquet modes.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_state_t = fbasis.state(t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_states_t` is deprecated. "
-        "Use `FloquetBasis.state` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    return fbasis.state(t)
-
-
-def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
-    """
-    Evaluate the wavefunction for a time t using the Floquet state
-    decompositon, given the Floquet modes at time `t`.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    psi_t = fbasis.from_floquet_basis(f_coeff, t)
-    """
-    raise NotImplementedError(
-        "`floquet_wavefunction` is not longer provided. "
-        "Use `FloquetBasis.from_floquet_basis` instead."
-    )
-
-
-def floquet_wavefunction_t(
-    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
-):
-    """
-    Evaluate the wavefunction for a time t using the Floquet state
-    decompositon, given the initial Floquet modes.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    psi_t = fbasis.from_floquet_basis(f_coeff, t)
-    """
-    warnings.warn(FutureWarning(
-        "`floquet_wavefunction_t` is deprecated. "
-        "Use `FloquetBasis.from_floquet_basis` instead."
-    ))
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    return fbasis.from_floquet_basis(f_coeff, t)
-
-
-def floquet_state_decomposition(f_states, f_energies, psi):
-    r"""
-    Decompose the wavefunction `psi` (typically an initial state) in terms of
-    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
-
-    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
-
-    fbasis = FloquetBasis(H, T, args=args, options=options)
-    f_coeff = fbasis.to_floquet_basis(psi)
-    """
-    raise NotImplementedError(
-        "`floquet_state_decomposition` is deprecated. "
-        "Use `FloquetBasis.to_floquet_basis` instead."
-    )
-
-
-def floquet_master_equation_rates(
-    f_modes_0,
-    f_energies,
-    c_op,
-    H,
-    T,
-    args,
-    J_cb,
-    w_th,
-    kmax=5,
-    f_modes_table_t=None,
-):
-    """
-    Calculate the rates and matrix elements for the Floquet-Markov master
-    equation.
-
-    .. note ::
-
-        Deprecated. For the Floquet-Markov master equation's tensor, use
-        :func:`floquet_tensor`. For the rates matrices, use
-        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
-        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
-
-    Parameters
-    ----------
-    f_modes_0 : Any
-        No longer used.
-    f_energies : Any
-        No longer used.
-    c_op : :class:`qutip.qobj`
-        The collapse operators describing the dissipation.
-    H : :class:`qutip.qobj`
-        System Hamiltonian, time-dependent with period `T`.
-    T : float
-        The period of the time-dependence of the hamiltonian.
-    args : dictionary
-        Dictionary with variables required to evaluate H.
-    J_cb : callback functions
-        A callback function that computes the noise power spectrum, as
-        a function of frequency, associated with the collapse operator `c_op`.
-    w_th : float
-        The temperature in units of frequency.
-    kmax : int, default=5
-        The truncation of the number of sidebands.
-    f_modes_table_t : Any
-        No longer used.
-
-    Returns
-    -------
-    output : list
-        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
-        and A used in the construction of the Floquet-Markov master equation.
-    """
-    warnings.warn(
-        FutureWarning("`floquet_master_equation_rates` is deprecated.")
-    )
-    floquet_basis = FloquetBasis(H, T, args=args)
-    energy = floquet_basis.e_quasi
-    delta = floquet_delta_tensor(energy, kmax, T)
-    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
-    gamma = floquet_gamma_matrices(x, delta, [J_cb])
-    a = floquet_A_matrix(delta, gamma, w_th)
-    return delta, x[0], gamma, a
+""" Floquet solver compatibility functions that behave like the corresponding
+functions from QuTiP 4.7.
+
+These functions are indented to be used when porting code from QuTiP 4.7 to
+QuTiP 5. They are deprecated and will be removed in QuTiP 5.1.
+"""
+
+__all__ = [
+    "floquet_modes",
+    "floquet_modes_t",
+    "floquet_modes_table",
+    "floquet_modes_t_lookup",
+    "floquet_states",
+    "floquet_states_t",
+    "floquet_wavefunction",
+    "floquet_wavefunction_t",
+    "floquet_state_decomposition",
+    "floquet_master_equation_rates",
+]
+
+from .floquet import *
+import numpy as np
+import warnings
+
+
+def floquet_modes(H, T, args=None, sort=False, U=None, options=None):
+    """
+    Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
+    period T.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
+    f_mode_0 = fbasis.mode(0)
+    f_energies = fbasis.e_quasi
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_modes` is deprecated. Use `FloquetBasis.mode` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options, sort=sort)
+    f_mode_0 = fbasis.mode(0)
+    f_energies = fbasis.e_quasi
+    return f_mode_0, f_energies
+
+
+def floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
+    """
+    Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the
+    initial Floquet modes Phi_alpha(0).
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_mode_t = fbasis.mode(t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_modes_t` is deprecated. Use `FloquetBasis.mode` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    return fbasis.mode(t)
+
+
+def floquet_modes_table(
+    f_modes_0, f_energies, tlist, H, T, args=None, options=None
+):
+    """
+    Pre-calculate the Floquet modes for a range of times spanning the floquet
+    period. Can later be used as a table to look up the floquet modes for
+    any time.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options, precompute=tlist)
+    """
+    raise NotImplementedError("`floquet_modes_table` is deprecated.")
+
+
+def floquet_modes_t_lookup(f_modes_table_t, t, T):
+    """
+    Lookup the floquet mode at time t in the pre-calculated table of floquet
+    modes in the first period of the time-dependence.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    f_modes_table_t = fbasis = FloquetBasis(...)
+    f_mode_t = f_modes_table_t.mode(t)
+    """
+    raise NotImplementedError(
+        "`floquet_modes_t_lookup` is no longer provided. "
+        "Use `FloquetBasis` instead."
+    )
+
+
+def floquet_states(f_modes_t, f_energies, t):
+    """
+    Evaluate the floquet states at time t given the Floquet modes at that time.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_state_t = fbasis.state(t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_states` is deprecated. "
+        "Use `FloquetBasis.state` instead."
+    ))
+    return [
+        (f_modes_t[i] * np.exp(-1j * f_energies[i] * t))
+        for i in np.arange(len(f_energies))
+    ]
+
+
+def floquet_states_t(f_modes_0, f_energies, t, H, T, args=None, options=None):
+    """
+    Evaluate the floquet states at time t given the initial Floquet modes.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_state_t = fbasis.state(t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_states_t` is deprecated. "
+        "Use `FloquetBasis.state` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    return fbasis.state(t)
+
+
+def floquet_wavefunction(f_modes_t, f_energies, f_coeff, t):
+    """
+    Evaluate the wavefunction for a time t using the Floquet state
+    decompositon, given the Floquet modes at time `t`.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    psi_t = fbasis.from_floquet_basis(f_coeff, t)
+    """
+    raise NotImplementedError(
+        "`floquet_wavefunction` is not longer provided. "
+        "Use `FloquetBasis.from_floquet_basis` instead."
+    )
+
+
+def floquet_wavefunction_t(
+    f_modes_0, f_energies, f_coeff, t, H, T, args=None, options=None
+):
+    """
+    Evaluate the wavefunction for a time t using the Floquet state
+    decompositon, given the initial Floquet modes.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    psi_t = fbasis.from_floquet_basis(f_coeff, t)
+    """
+    warnings.warn(FutureWarning(
+        "`floquet_wavefunction_t` is deprecated. "
+        "Use `FloquetBasis.from_floquet_basis` instead."
+    ))
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    return fbasis.from_floquet_basis(f_coeff, t)
+
+
+def floquet_state_decomposition(f_states, f_energies, psi):
+    r"""
+    Decompose the wavefunction `psi` (typically an initial state) in terms of
+    the Floquet states, :math:`\psi = \sum_\alpha c_\alpha \psi_\alpha(0)`.
+
+    Deprecated from qutip v5. Use :class:`FloquetBasis` instead:
+
+    fbasis = FloquetBasis(H, T, args=args, options=options)
+    f_coeff = fbasis.to_floquet_basis(psi)
+    """
+    raise NotImplementedError(
+        "`floquet_state_decomposition` is deprecated. "
+        "Use `FloquetBasis.to_floquet_basis` instead."
+    )
+
+
+def floquet_master_equation_rates(
+    f_modes_0,
+    f_energies,
+    c_op,
+    H,
+    T,
+    args,
+    J_cb,
+    w_th,
+    kmax=5,
+    f_modes_table_t=None,
+):
+    """
+    Calculate the rates and matrix elements for the Floquet-Markov master
+    equation.
+
+    .. note ::
+
+        Deprecated. For the Floquet-Markov master equation's tensor, use
+        :func:`floquet_tensor`. For the rates matrices, use
+        :func:`floquet_delta_tensor`, :func:`floquet_X_matrices`,
+        :func:`floquet_gamma_matrices` and/or s:func:`floquet_A_matrix`.
+
+    Parameters
+    ----------
+    f_modes_0 : Any
+        No longer used.
+    f_energies : Any
+        No longer used.
+    c_op : :class:`qutip.qobj`
+        The collapse operators describing the dissipation.
+    H : :class:`qutip.qobj`
+        System Hamiltonian, time-dependent with period `T`.
+    T : float
+        The period of the time-dependence of the hamiltonian.
+    args : dictionary
+        Dictionary with variables required to evaluate H.
+    J_cb : callback functions
+        A callback function that computes the noise power spectrum, as
+        a function of frequency, associated with the collapse operator `c_op`.
+    w_th : float
+        The temperature in units of frequency.
+    kmax : int, default=5
+        The truncation of the number of sidebands.
+    f_modes_table_t : Any
+        No longer used.
+
+    Returns
+    -------
+    output : list
+        A list (Delta, X, Gamma, A) containing the matrices Delta, X, Gamma
+        and A used in the construction of the Floquet-Markov master equation.
+    """
+    warnings.warn(
+        FutureWarning("`floquet_master_equation_rates` is deprecated.")
+    )
+    floquet_basis = FloquetBasis(H, T, args=args)
+    energy = floquet_basis.e_quasi
+    delta = floquet_delta_tensor(energy, kmax, T)
+    x = floquet_X_matrices(floquet_basis, [c_op], kmax, nT)
+    gamma = floquet_gamma_matrices(x, delta, [J_cb])
+    a = floquet_A_matrix(delta, gamma, w_th)
+    return delta, x[0], gamma, a
diff --git a/qutip/solver/heom/__init__.py b/qutip/solver/heom/__init__.py
index 2ae10e1b41..9a8264b073 100644
--- a/qutip/solver/heom/__init__.py
+++ b/qutip/solver/heom/__init__.py
@@ -1,55 +1,55 @@
-"""
-This module provides solvers for system-bath evoluation using the
-HEOM (hierarchy equations of motion).
-
-See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
-basic introduction to the technique.
-
-The implementation is derived from the BoFiN library (see
-https://github.com/tehruhn/bofin) which was itself derived from an earlier
-implementation in QuTiP itself.
-
-For backwards compatibility with QuTiP 4.6 and below, a new version of
-HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
-implemented on top of the new HEOMSolver but should largely be a drop-in
-replacement for the old HSolverDL.
-"""
-
-__all__ = [
-    "BathExponent",
-    "Bath",
-    "BosonicBath",
-    "DrudeLorentzBath",
-    "DrudeLorentzPadeBath",
-    "UnderDampedBath",
-    "FermionicBath",
-    "LorentzianBath",
-    "LorentzianPadeBath",
-    "heomsolve",
-    "HEOMSolver",
-    "HEOMResult",
-    "HSolverDL",
-    "HierarchyADOs",
-    "HierarchyADOsState",
-]
-
-from .bofin_baths import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-)
-
-from .bofin_solvers import (
-    heomsolve,
-    HEOMSolver,
-    HEOMResult,
-    HSolverDL,
-    HierarchyADOs,
-    HierarchyADOsState,
-)
+"""
+This module provides solvers for system-bath evoluation using the
+HEOM (hierarchy equations of motion).
+
+See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
+basic introduction to the technique.
+
+The implementation is derived from the BoFiN library (see
+https://github.com/tehruhn/bofin) which was itself derived from an earlier
+implementation in QuTiP itself.
+
+For backwards compatibility with QuTiP 4.6 and below, a new version of
+HSolverDL (the Drude-Lorentz specific HEOM solver) is provided. It is
+implemented on top of the new HEOMSolver but should largely be a drop-in
+replacement for the old HSolverDL.
+"""
+
+__all__ = [
+    "BathExponent",
+    "Bath",
+    "BosonicBath",
+    "DrudeLorentzBath",
+    "DrudeLorentzPadeBath",
+    "UnderDampedBath",
+    "FermionicBath",
+    "LorentzianBath",
+    "LorentzianPadeBath",
+    "heomsolve",
+    "HEOMSolver",
+    "HEOMResult",
+    "HSolverDL",
+    "HierarchyADOs",
+    "HierarchyADOsState",
+]
+
+from .bofin_baths import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+)
+
+from .bofin_solvers import (
+    heomsolve,
+    HEOMSolver,
+    HEOMResult,
+    HSolverDL,
+    HierarchyADOs,
+    HierarchyADOsState,
+)
diff --git a/qutip/solver/heom/bofin_baths.py b/qutip/solver/heom/bofin_baths.py
index 0b7f2c2bca..ff64dfc610 100644
--- a/qutip/solver/heom/bofin_baths.py
+++ b/qutip/solver/heom/bofin_baths.py
@@ -1,982 +1,982 @@
-"""
-This module provides utilities for describing baths when using the
-HEOM (hierarchy equations of motion) to model system-bath interactions.
-
-See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
-
-The implementation is derived from the BoFiN library (see
-https://github.com/tehruhn/bofin) which was itself derived from an earlier
-implementation in QuTiP itself.
-"""
-
-import enum
-
-import numpy as np
-from scipy.linalg import eigvalsh
-
-from qutip.core import data as _data
-from qutip.core.qobj import Qobj
-from qutip.core.superoperator import spre, spost
-
-__all__ = [
-    "BathExponent",
-    "Bath",
-    "BosonicBath",
-    "DrudeLorentzBath",
-    "DrudeLorentzPadeBath",
-    "UnderDampedBath",
-    "FermionicBath",
-    "LorentzianBath",
-    "LorentzianPadeBath",
-]
-
-
-def _isequal(Q1, Q2, tol):
-    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
-    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
-
-
-class BathExponent:
-    """
-    Represents a single exponent (naively, an excitation mode) within the
-    decomposition of the correlation functions of a bath.
-
-    Parameters
-    ----------
-    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
-        The type of bath exponent.
-
-        "R" and "I" are bosonic bath exponents that appear in the real and
-        imaginary parts of the correlation expansion.
-
-        "RI" is combined bosonic bath exponent that appears in both the real
-        and imaginary parts of the correlation expansion. The combined exponent
-        has a single ``vk``. The ``ck`` is the coefficient in the real
-        expansion and ``ck2`` is the coefficient in the imaginary expansion.
-
-        "+" and "-" are fermionic bath exponents. These fermionic bath
-        exponents must specify ``sigma_bar_k_offset`` which specifies
-        the amount to add to ``k`` (the exponent index within the bath of this
-        exponent) to determine the ``k`` of the corresponding exponent with
-        the opposite sign (i.e. "-" or "+").
-
-    dim : int or None
-        The dimension (i.e. maximum number of excitations for this exponent).
-        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
-        bosonic exponents.
-
-    Q : Qobj
-        The coupling operator for this excitation mode.
-
-    vk : complex
-        The frequency of the exponent of the excitation term.
-
-    ck : complex
-        The coefficient of the excitation term.
-
-    ck2 : optional, complex
-        For exponents of type "RI" this is the coefficient of the term in the
-        imaginary expansion (and ``ck`` is the coefficient in the real
-        expansion).
-
-    sigma_bar_k_offset : optional, int
-        For exponents of type "+" this gives the offset (within the list of
-        exponents within the bath) of the corresponding "-" bath exponent.
-        For exponents of type "-" it gives the offset of the corresponding
-        "+" exponent.
-
-    tag : optional, str, tuple or any other object
-        A label for the exponent (often the name of the bath). It
-        defaults to None.
-
-    Attributes
-    ----------
-    fermionic : bool
-        True if the type of the exponent is a Fermionic type (i.e. either
-        "+" or "-") and False otherwise.
-
-    All of the parameters are also available as attributes.
-    """
-    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
-
-    def _check_ck2(self, type, ck2):
-        if type == self.types["RI"]:
-            if ck2 is None:
-                raise ValueError("RI bath exponents require ck2")
-        else:
-            if ck2 is not None:
-                raise ValueError(
-                    "Second co-efficient (ck2) should only be specified for RI"
-                    " bath exponents"
-                )
-
-    def _check_sigma_bar_k_offset(self, type, offset):
-        if type in (self.types["+"], self.types["-"]):
-            if offset is None:
-                raise ValueError(
-                    "+ and - bath exponents require sigma_bar_k_offset"
-                )
-        else:
-            if offset is not None:
-                raise ValueError(
-                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
-                    " specified for + and - bath exponents"
-                )
-
-    def _type_is_fermionic(self, type):
-        return type in (self.types["+"], self.types["-"])
-
-    def __init__(
-            self, type, dim, Q, ck, vk, ck2=None,
-            sigma_bar_k_offset=None, tag=None,
-    ):
-        if not isinstance(type, self.types):
-            type = self.types[type]
-        self._check_ck2(type, ck2)
-        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
-        self.type = type
-        self.fermionic = self._type_is_fermionic(type)
-        self.dim = dim
-        self.Q = Q
-        self.ck = ck
-        self.vk = vk
-        self.ck2 = ck2
-        self.sigma_bar_k_offset = sigma_bar_k_offset
-        self.tag = tag
-
-    def __repr__(self):
-        dims = getattr(self.Q, "dims", None)
-        return (
-            f"<{self.__class__.__name__} type={self.type.name}"
-            f" dim={self.dim!r}"
-            f" Q.dims={dims!r}"
-            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
-            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
-            f" fermionic={self.fermionic!r}"
-            f" tag={self.tag!r}>"
-        )
-
-
-class Bath:
-    """
-    Represents a list of bath expansion exponents.
-
-    Parameters
-    ----------
-    exponents : list of BathExponent
-        The exponents of the correlation function describing the bath.
-
-    Attributes
-    ----------
-
-    All of the parameters are available as attributes.
-    """
-    def __init__(self, exponents):
-        self.exponents = exponents
-
-
-class BosonicBath(Bath):
-    """
-    A helper class for constructing a bosonic bath from the expansion
-    coefficients and frequencies for the real and imaginary parts of
-    the bath correlation function.
-
-    If the correlation functions ``C(t)`` is split into real and imaginary
-    parts::
-
-        C(t) = C_real(t) + i * C_imag(t)
-
-    then::
-
-        C_real(t) = sum(ck_real * exp(- vk_real * t))
-        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
-
-    Defines the coefficients ``ck`` and the frequencies ``vk``.
-
-    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
-    and ``C_imag(t)`` (i.e. the sum) is real.
-
-    Parameters
-    ----------
-    Q : Qobj
-        The coupling operator for the bath.
-
-    ck_real : list of complex
-        The coefficients of the expansion terms for the real part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_real.
-
-    vk_real : list of complex
-        The frequencies (exponents) of the expansion terms for the real part of
-        the correlation function. The corresponding ceofficients are passed as
-        ck_real.
-
-    ck_imag : list of complex
-        The coefficients of the expansion terms in the imaginary part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_imag.
-
-    vk_imag : list of complex
-        The frequencies (exponents) of the expansion terms for the imaginary
-        part of the correlation function. The corresponding ceofficients are
-        passed as ck_imag.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
-        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
-            raise ValueError(
-                "The bath exponent lists ck_real and vk_real, and ck_imag and"
-                " vk_imag must be the same length."
-            )
-
-    def _check_coup_op(self, Q):
-        if not isinstance(Q, Qobj):
-            raise ValueError("The coupling operator Q must be a Qobj.")
-
-    def __init__(
-            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
-            tag=None,
-    ):
-        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
-        self._check_coup_op(Q)
-
-        exponents = []
-        exponents.extend(
-            BathExponent("R", None, Q, ck, vk, tag=tag)
-            for ck, vk in zip(ck_real, vk_real)
-        )
-        exponents.extend(
-            BathExponent("I", None, Q, ck, vk, tag=tag)
-            for ck, vk in zip(ck_imag, vk_imag)
-        )
-
-        if combine:
-            exponents = self.combine(exponents)
-
-        super().__init__(exponents)
-
-    @classmethod
-    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
-        """
-        Group bosonic exponents with the same frequency and return a
-        single exponent for each frequency present.
-
-        Exponents with the same frequency are only combined if they share the
-        same coupling operator ``.Q``.
-
-        Note that combined exponents take their tag from the first
-        exponent in the group being combined (i.e. the one that occurs first
-        in the given exponents list).
-
-        Parameters
-        ----------
-        exponents : list of BathExponent
-            The list of exponents to combine.
-
-        rtol : float, default 1e-5
-            The relative tolerance to use to when comparing frequencies and
-            coupling operators.
-
-        atol : float, default 1e-7
-            The absolute tolerance to use to when comparing frequencies and
-            coupling operators.
-
-        Returns
-        -------
-        list of BathExponent
-            The new reduced list of exponents.
-        """
-        groups = []
-        remaining = exponents[:]
-
-        while remaining:
-            e1 = remaining.pop(0)
-            group = [e1]
-            for e2 in remaining[:]:
-                if (
-                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
-                    _isequal(e1.Q, e2.Q, tol=atol)
-                ):
-                    group.append(e2)
-                    remaining.remove(e2)
-            groups.append(group)
-
-        new_exponents = []
-        for combine in groups:
-            exp1 = combine[0]
-            if (exp1.type != exp1.types.RI) and all(
-                exp2.type == exp1.type for exp2 in combine
-            ):
-                # the group is either type I or R
-                ck = sum(exp.ck for exp in combine)
-                new_exponents.append(BathExponent(
-                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
-                ))
-            else:
-                # the group includes both type I and R exponents
-                ck_R = (
-                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
-                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
-                )
-                ck_I = (
-                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
-                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
-                )
-                new_exponents.append(BathExponent(
-                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
-                    tag=exp1.tag,
-                ))
-
-        return new_exponents
-
-
-class DrudeLorentzBath(BosonicBath):
-    """
-    A helper class for constructing a Drude-Lorentz bosonic bath from the
-    bath parameters (see parameters below).
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    lam : float
-        Coupling strength.
-
-    gamma : float
-        Bath spectral density cutoff frequency.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(
-        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
-    ):
-        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
-            lam=lam,
-            gamma=gamma,
-            T=T,
-            Nk=Nk,
-        )
-
-        super().__init__(
-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-        )
-
-        self._dl_terminator = _DrudeLorentzTerminator(
-            Q=Q, lam=lam, gamma=gamma, T=T,
-        )
-
-    def terminator(self):
-        """
-        Return the Matsubara terminator for the bath and the calculated
-        approximation discrepancy.
-
-        Returns
-        -------
-        delta: float
-
-            The approximation discrepancy. That is, the difference between the
-            true correlation function of the Drude-Lorentz bath and the sum of
-            the ``Nk`` exponential terms is approximately ``2 * delta *
-            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
-
-        terminator : Qobj
-
-            The Matsubara terminator -- i.e. a liouvillian term representing
-            the contribution to the system-bath dynamics of all exponential
-            expansion terms beyond ``Nk``. It should be used by adding it to
-            the system liouvillian (i.e. ``liouvillian(H_sys)``).
-        """
-        delta, L = self._dl_terminator.terminator(self.exponents)
-        return delta, L
-
-    def _matsubara_params(self, lam, gamma, T, Nk):
-        """ Calculate the Matsubara coefficents and frequencies. """
-        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
-        ck_real.extend([
-            (8 * lam * gamma * T * np.pi * k * T /
-                ((2 * np.pi * k * T)**2 - gamma**2))
-            for k in range(1, Nk + 1)
-        ])
-        vk_real = [gamma]
-        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
-
-        ck_imag = [lam * gamma * (-1.0)]
-        vk_imag = [gamma]
-
-        return ck_real, vk_real, ck_imag, vk_imag
-
-
-class DrudeLorentzPadeBath(BosonicBath):
-    """
-    A helper class for constructing a Padé expansion for a Drude-Lorentz
-    bosonic bath from the bath parameters (see parameters below).
-
-    A Padé approximant is a sum-over-poles expansion (
-    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
-
-    The application of the Padé method to spectrum decompoisitions is described
-    in "Padé spectrum decompositions of quantum distribution functions and
-    optimal hierarchical equations of motion construction for quantum open
-    systems" [1].
-
-    The implementation here follows the approach in the paper.
-
-    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
-
-    This is an alternative to the :class:`DrudeLorentzBath` which constructs
-    a simpler exponential expansion.
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    lam : float
-        Coupling strength.
-
-    gamma : float
-        Bath spectral density cutoff frequency.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of Padé exponentials terms used to approximate the bath
-        correlation functions.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(
-        self, Q, lam, gamma, T, Nk, combine=True, tag=None
-    ):
-        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
-
-        ck_real = [np.real(eta) for eta in eta_p]
-        vk_real = [gam for gam in gamma_p]
-        # There is only one term in the expansion of the imaginary part of the
-        # Drude-Lorentz correlation function.
-        ck_imag = [np.imag(eta_p[0])]
-        vk_imag = [gamma_p[0]]
-
-        super().__init__(
-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-        )
-
-        self._dl_terminator = _DrudeLorentzTerminator(
-            Q=Q, lam=lam, gamma=gamma, T=T,
-        )
-
-    def terminator(self):
-        """
-        Return the Padé terminator for the bath and the calculated
-        approximation discrepancy.
-
-        Returns
-        -------
-        delta: float
-
-            The approximation discrepancy. That is, the difference between the
-            true correlation function of the Drude-Lorentz bath and the sum of
-            the ``Nk`` exponential terms is approximately ``2 * delta *
-            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
-
-        terminator : Qobj
-
-            The Padé terminator -- i.e. a liouvillian term representing
-            the contribution to the system-bath dynamics of all exponential
-            expansion terms beyond ``Nk``. It should be used by adding it to
-            the system liouvillian (i.e. ``liouvillian(H_sys)``).
-        """
-        delta, L = self._dl_terminator.terminator(self.exponents)
-        return delta, L
-
-    def _corr(self, lam, gamma, T, Nk):
-        beta = 1. / T
-        kappa, epsilon = self._kappa_epsilon(Nk)
-
-        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
-        gamma_p = [gamma]
-
-        for ll in range(1, Nk + 1):
-            eta_p.append(
-                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
-                / ((epsilon[ll]**2 / beta**2) - gamma**2)
-            )
-            gamma_p.append(epsilon[ll] / beta)
-
-        return eta_p, gamma_p
-
-    def _cot(self, x):
-        return 1. / np.tan(x)
-
-    def _kappa_epsilon(self, Nk):
-        eps = self._calc_eps(Nk)
-        chi = self._calc_chi(Nk)
-
-        kappa = [0]
-        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
-        for j in range(Nk):
-            term = prefactor
-            for k in range(Nk - 1):
-                term *= (
-                    (chi[k]**2 - eps[j]**2) /
-                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-                )
-            for k in [Nk - 1]:
-                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-            kappa.append(term)
-
-        epsilon = [0] + eps
-
-        return kappa, epsilon
-
-    def _delta(self, i, j):
-        return 1.0 if i == j else 0.0
-
-    def _calc_eps(self, Nk):
-        alpha = np.diag([
-                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
-                for k in range(2 * Nk - 1)
-        ], k=1)
-        alpha += alpha.transpose()
-        evals = eigvalsh(alpha)
-        eps = [-2. / val for val in evals[0: Nk]]
-        return eps
-
-    def _calc_chi(self, Nk):
-        alpha_p = np.diag([
-                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
-                for k in range(2 * Nk - 2)
-        ], k=1)
-        alpha_p += alpha_p.transpose()
-        evals = eigvalsh(alpha_p)
-        chi = [-2. / val for val in evals[0: Nk - 1]]
-        return chi
-
-
-class _DrudeLorentzTerminator:
-    """ A class for calculating the terminator of a Drude-Lorentz bath
-        expansion.
-    """
-    def __init__(self, Q, lam, gamma, T):
-        self.Q = Q
-        self.lam = lam
-        self.gamma = gamma
-        self.T = T
-
-    def terminator(self, exponents):
-        """ Calculate the terminator for a Drude-Lorentz bath. """
-        Q = self.Q
-        lam = self.lam
-        gamma = self.gamma
-        beta = 1 / self.T
-
-        delta = 2 * lam / (beta * gamma) - 1j * lam
-
-        for exp in exponents:
-            if exp.type == BathExponent.types["R"]:
-                delta -= exp.ck / exp.vk
-            elif exp.type == BathExponent.types["RI"]:
-                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
-            else:
-                delta -= 1j * exp.ck / exp.vk
-
-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-        L_bnd = -delta * op
-
-        return delta, L_bnd
-
-
-class UnderDampedBath(BosonicBath):
-    """
-    A helper class for constructing an under-damped bosonic bath from the
-    bath parameters (see parameters below).
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    lam : float
-        Coupling strength.
-
-    gamma : float
-        Bath spectral density cutoff frequency.
-
-    w0 : float
-        Bath spectral density resonance frequency.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(
-        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
-    ):
-        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
-            lam=lam,
-            gamma=gamma,
-            w0=w0,
-            T=T,
-            Nk=Nk,
-        )
-
-        super().__init__(
-            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
-        )
-
-    def _matsubara_params(self, lam, gamma, w0, T, Nk):
-        """ Calculate the Matsubara coefficents and frequencies. """
-        beta = 1/T
-        Om = np.sqrt(w0**2 - (gamma/2)**2)
-        Gamma = gamma/2.
-
-        ck_real = ([
-            (lam**2 / (4 * Om))
-            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
-            (lam**2 / (4*Om))
-            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
-        ])
-
-        ck_real.extend([
-            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
-            / (
-                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
-                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
-            )
-            for k in range(1, Nk + 1)
-        ])
-
-        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
-        vk_real.extend([
-            2 * np.pi * k * T
-            for k in range(1, Nk + 1)
-        ])
-
-        ck_imag = [
-            1.0j * lam**2 / (4 * Om),
-            -1.0j * lam**2 / (4 * Om),
-        ]
-
-        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
-
-        return ck_real, vk_real, ck_imag, vk_imag
-
-
-class FermionicBath(Bath):
-    """
-    A helper class for constructing a fermionic bath from the expansion
-    coefficients and frequencies for the ``+`` and ``-`` modes of
-    the bath correlation function.
-
-    There must be the same number of ``+`` and ``-`` modes and their
-    coefficients must be specified in the same order so that ``ck_plus[i],
-    vk_plus[i]`` are the plus coefficient and frequency corresponding
-    to the minus mode ``ck_minus[i], vk_minus[i]``.
-
-    In the fermionic case the order in which excitations are created or
-    destroyed is important, resulting in two different correlation functions
-    labelled ``C_plus(t)`` and ``C_plus(t)``::
-
-        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
-        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
-
-    where the expansions above define the coeffiients ``ck`` and the
-    frequencies ``vk``.
-
-    Parameters
-    ----------
-    Q : Qobj
-        The coupling operator for the bath.
-
-    ck_plus : list of complex
-        The coefficients of the expansion terms for the ``+`` part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_plus.
-
-    vk_plus : list of complex
-        The frequencies (exponents) of the expansion terms for the ``+`` part
-        of the correlation function. The corresponding ceofficients are passed
-        as ck_plus.
-
-    ck_minus : list of complex
-        The coefficients of the expansion terms for the ``-`` part of the
-        correlation function. The corresponding frequencies are passed as
-        vk_minus.
-
-    vk_minus : list of complex
-        The frequencies (exponents) of the expansion terms for the ``-`` part
-        of the correlation function. The corresponding ceofficients are passed
-        as ck_minus.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-
-    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
-        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
-            raise ValueError(
-                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-                " vk_minus must be the same length."
-            )
-        if len(ck_plus) != len(ck_minus):
-            raise ValueError(
-                "The must be the same number of plus and minus exponents"
-                " in the bath, and elements of plus and minus arrays"
-                " should be arranged so that ck_plus[i] is the plus mode"
-                " corresponding to ck_minus[i]."
-            )
-
-    def _check_coup_op(self, Q):
-        if not isinstance(Q, Qobj):
-            raise ValueError("The coupling operator Q must be a Qobj.")
-
-    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
-        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
-        self._check_coup_op(Q)
-
-        exponents = []
-        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
-            exponents.append(BathExponent(
-                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
-            ))
-            exponents.append(BathExponent(
-                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
-            ))
-        super().__init__(exponents)
-
-
-class LorentzianBath(FermionicBath):
-    """
-    A helper class for constructing a Lorentzian fermionic bath from the
-    bath parameters (see parameters below).
-
-    .. note::
-
-        This Matsubara expansion used in this bath converges very slowly
-        and ``Nk > 20`` may be required to get good convergence. The
-        Padé expansion used by :class:`LorentzianPadeBath` converges much
-        more quickly.
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    gamma : float
-        The coupling strength between the system and the bath.
-
-    w : float
-        The width of the environment.
-
-    mu : float
-        The chemical potential of the bath.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
-        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
-        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
-
-        super().__init__(
-            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
-        )
-
-    def _corr(self, gamma, w, mu, T, Nk, sigma):
-        beta = 1. / T
-        kappa = [0.]
-        kappa.extend([1. for _ in range(1, Nk + 1)])
-        epsilon = [0]
-        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
-
-        def f(x):
-            return 1 / (np.exp(x) + 1)
-
-        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
-        gamma_list = [w - sigma * 1.0j * mu]
-
-        for ll in range(1, Nk + 1):
-            eta_list.append(
-                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
-                (-(epsilon[ll]**2 / beta**2) + w**2)
-            )
-            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
-
-        return eta_list, gamma_list
-
-
-class LorentzianPadeBath(FermionicBath):
-    """
-    A helper class for constructing a Padé expansion for Lorentzian fermionic
-    bath from the bath parameters (see parameters below).
-
-    A Padé approximant is a sum-over-poles expansion (
-    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
-
-    The application of the Padé method to spectrum decompoisitions is described
-    in "Padé spectrum decompositions of quantum distribution functions and
-    optimal hierarchical equations of motion construction for quantum open
-    systems" [1].
-
-    The implementation here follows the approach in the paper.
-
-    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
-
-    This is an alternative to the :class:`LorentzianBath` which constructs
-    a simpler exponential expansion that converges much more slowly in
-    this particular case.
-
-    Parameters
-    ----------
-    Q : Qobj
-        Operator describing the coupling between system and bath.
-
-    gamma : float
-        The coupling strength between the system and the bath.
-
-    w : float
-        The width of the environment.
-
-    mu : float
-        The chemical potential of the bath.
-
-    T : float
-        Bath temperature.
-
-    Nk : int
-        Number of exponential terms used to approximate the bath correlation
-        functions.
-
-    tag : optional, str, tuple or any other object
-        A label for the bath exponents (for example, the name of the
-        bath). It defaults to None but can be set to help identify which
-        bath an exponent is from.
-    """
-    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
-        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
-        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
-
-        super().__init__(
-            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
-        )
-
-    def _corr(self, gamma, w, mu, T, Nk, sigma):
-        beta = 1. / T
-        kappa, epsilon = self._kappa_epsilon(Nk)
-
-        def f_approx(x):
-            f = 0.5
-            for ll in range(1, Nk + 1):
-                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
-            return f
-
-        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
-        gamma_list = [w - sigma * 1.0j * mu]
-
-        for ll in range(1, Nk + 1):
-            eta_list.append(
-                -1.0j * (kappa[ll] / beta) * gamma * w**2
-                / (-(epsilon[ll]**2 / beta**2) + w**2)
-            )
-            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
-
-        return eta_list, gamma_list
-
-    def _kappa_epsilon(self, Nk):
-        eps = self._calc_eps(Nk)
-        chi = self._calc_chi(Nk)
-
-        kappa = [0]
-        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
-        for j in range(Nk):
-            term = prefactor
-            for k in range(Nk - 1):
-                term *= (
-                    (chi[k]**2 - eps[j]**2) /
-                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-                )
-            for k in [Nk - 1]:
-                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
-            kappa.append(term)
-
-        epsilon = [0] + eps
-
-        return kappa, epsilon
-
-    def _delta(self, i, j):
-        return 1.0 if i == j else 0.0
-
-    def _calc_eps(self, Nk):
-        alpha = np.diag([
-                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
-                for k in range(2 * Nk - 1)
-        ], k=1)
-        alpha += alpha.transpose()
-
-        evals = eigvalsh(alpha)
-        eps = [-2. / val for val in evals[0: Nk]]
-        return eps
-
-    def _calc_chi(self, Nk):
-        alpha_p = np.diag([
-                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
-                for k in range(2 * Nk - 2)
-        ], k=1)
-        alpha_p += alpha_p.transpose()
-        evals = eigvalsh(alpha_p)
-        chi = [-2. / val for val in evals[0: Nk - 1]]
-        return chi
+"""
+This module provides utilities for describing baths when using the
+HEOM (hierarchy equations of motion) to model system-bath interactions.
+
+See the ``qutip.nonmarkov.bofin_solvers`` module for the associated solver.
+
+The implementation is derived from the BoFiN library (see
+https://github.com/tehruhn/bofin) which was itself derived from an earlier
+implementation in QuTiP itself.
+"""
+
+import enum
+
+import numpy as np
+from scipy.linalg import eigvalsh
+
+from qutip.core import data as _data
+from qutip.core.qobj import Qobj
+from qutip.core.superoperator import spre, spost
+
+__all__ = [
+    "BathExponent",
+    "Bath",
+    "BosonicBath",
+    "DrudeLorentzBath",
+    "DrudeLorentzPadeBath",
+    "UnderDampedBath",
+    "FermionicBath",
+    "LorentzianBath",
+    "LorentzianPadeBath",
+]
+
+
+def _isequal(Q1, Q2, tol):
+    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
+    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
+
+
+class BathExponent:
+    """
+    Represents a single exponent (naively, an excitation mode) within the
+    decomposition of the correlation functions of a bath.
+
+    Parameters
+    ----------
+    type : {"R", "I", "RI", "+", "-"} or BathExponent.ExponentType
+        The type of bath exponent.
+
+        "R" and "I" are bosonic bath exponents that appear in the real and
+        imaginary parts of the correlation expansion.
+
+        "RI" is combined bosonic bath exponent that appears in both the real
+        and imaginary parts of the correlation expansion. The combined exponent
+        has a single ``vk``. The ``ck`` is the coefficient in the real
+        expansion and ``ck2`` is the coefficient in the imaginary expansion.
+
+        "+" and "-" are fermionic bath exponents. These fermionic bath
+        exponents must specify ``sigma_bar_k_offset`` which specifies
+        the amount to add to ``k`` (the exponent index within the bath of this
+        exponent) to determine the ``k`` of the corresponding exponent with
+        the opposite sign (i.e. "-" or "+").
+
+    dim : int or None
+        The dimension (i.e. maximum number of excitations for this exponent).
+        Usually ``2`` for fermionic exponents or ``None`` (i.e. unlimited) for
+        bosonic exponents.
+
+    Q : Qobj
+        The coupling operator for this excitation mode.
+
+    vk : complex
+        The frequency of the exponent of the excitation term.
+
+    ck : complex
+        The coefficient of the excitation term.
+
+    ck2 : optional, complex
+        For exponents of type "RI" this is the coefficient of the term in the
+        imaginary expansion (and ``ck`` is the coefficient in the real
+        expansion).
+
+    sigma_bar_k_offset : optional, int
+        For exponents of type "+" this gives the offset (within the list of
+        exponents within the bath) of the corresponding "-" bath exponent.
+        For exponents of type "-" it gives the offset of the corresponding
+        "+" exponent.
+
+    tag : optional, str, tuple or any other object
+        A label for the exponent (often the name of the bath). It
+        defaults to None.
+
+    Attributes
+    ----------
+    fermionic : bool
+        True if the type of the exponent is a Fermionic type (i.e. either
+        "+" or "-") and False otherwise.
+
+    All of the parameters are also available as attributes.
+    """
+    types = enum.Enum("ExponentType", ["R", "I", "RI", "+", "-"])
+
+    def _check_ck2(self, type, ck2):
+        if type == self.types["RI"]:
+            if ck2 is None:
+                raise ValueError("RI bath exponents require ck2")
+        else:
+            if ck2 is not None:
+                raise ValueError(
+                    "Second co-efficient (ck2) should only be specified for RI"
+                    " bath exponents"
+                )
+
+    def _check_sigma_bar_k_offset(self, type, offset):
+        if type in (self.types["+"], self.types["-"]):
+            if offset is None:
+                raise ValueError(
+                    "+ and - bath exponents require sigma_bar_k_offset"
+                )
+        else:
+            if offset is not None:
+                raise ValueError(
+                    "Offset of sigma bar (sigma_bar_k_offset) should only be"
+                    " specified for + and - bath exponents"
+                )
+
+    def _type_is_fermionic(self, type):
+        return type in (self.types["+"], self.types["-"])
+
+    def __init__(
+            self, type, dim, Q, ck, vk, ck2=None,
+            sigma_bar_k_offset=None, tag=None,
+    ):
+        if not isinstance(type, self.types):
+            type = self.types[type]
+        self._check_ck2(type, ck2)
+        self._check_sigma_bar_k_offset(type, sigma_bar_k_offset)
+        self.type = type
+        self.fermionic = self._type_is_fermionic(type)
+        self.dim = dim
+        self.Q = Q
+        self.ck = ck
+        self.vk = vk
+        self.ck2 = ck2
+        self.sigma_bar_k_offset = sigma_bar_k_offset
+        self.tag = tag
+
+    def __repr__(self):
+        dims = getattr(self.Q, "dims", None)
+        return (
+            f"<{self.__class__.__name__} type={self.type.name}"
+            f" dim={self.dim!r}"
+            f" Q.dims={dims!r}"
+            f" ck={self.ck!r} vk={self.vk!r} ck2={self.ck2!r}"
+            f" sigma_bar_k_offset={self.sigma_bar_k_offset!r}"
+            f" fermionic={self.fermionic!r}"
+            f" tag={self.tag!r}>"
+        )
+
+
+class Bath:
+    """
+    Represents a list of bath expansion exponents.
+
+    Parameters
+    ----------
+    exponents : list of BathExponent
+        The exponents of the correlation function describing the bath.
+
+    Attributes
+    ----------
+
+    All of the parameters are available as attributes.
+    """
+    def __init__(self, exponents):
+        self.exponents = exponents
+
+
+class BosonicBath(Bath):
+    """
+    A helper class for constructing a bosonic bath from the expansion
+    coefficients and frequencies for the real and imaginary parts of
+    the bath correlation function.
+
+    If the correlation functions ``C(t)`` is split into real and imaginary
+    parts::
+
+        C(t) = C_real(t) + i * C_imag(t)
+
+    then::
+
+        C_real(t) = sum(ck_real * exp(- vk_real * t))
+        C_imag(t) = sum(ck_imag * exp(- vk_imag * t))
+
+    Defines the coefficients ``ck`` and the frequencies ``vk``.
+
+    Note that the ``ck`` and ``vk`` may be complex, even through ``C_real(t)``
+    and ``C_imag(t)`` (i.e. the sum) is real.
+
+    Parameters
+    ----------
+    Q : Qobj
+        The coupling operator for the bath.
+
+    ck_real : list of complex
+        The coefficients of the expansion terms for the real part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_real.
+
+    vk_real : list of complex
+        The frequencies (exponents) of the expansion terms for the real part of
+        the correlation function. The corresponding ceofficients are passed as
+        ck_real.
+
+    ck_imag : list of complex
+        The coefficients of the expansion terms in the imaginary part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_imag.
+
+    vk_imag : list of complex
+        The frequencies (exponents) of the expansion terms for the imaginary
+        part of the correlation function. The corresponding ceofficients are
+        passed as ck_imag.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def _check_cks_and_vks(self, ck_real, vk_real, ck_imag, vk_imag):
+        if len(ck_real) != len(vk_real) or len(ck_imag) != len(vk_imag):
+            raise ValueError(
+                "The bath exponent lists ck_real and vk_real, and ck_imag and"
+                " vk_imag must be the same length."
+            )
+
+    def _check_coup_op(self, Q):
+        if not isinstance(Q, Qobj):
+            raise ValueError("The coupling operator Q must be a Qobj.")
+
+    def __init__(
+            self, Q, ck_real, vk_real, ck_imag, vk_imag, combine=True,
+            tag=None,
+    ):
+        self._check_cks_and_vks(ck_real, vk_real, ck_imag, vk_imag)
+        self._check_coup_op(Q)
+
+        exponents = []
+        exponents.extend(
+            BathExponent("R", None, Q, ck, vk, tag=tag)
+            for ck, vk in zip(ck_real, vk_real)
+        )
+        exponents.extend(
+            BathExponent("I", None, Q, ck, vk, tag=tag)
+            for ck, vk in zip(ck_imag, vk_imag)
+        )
+
+        if combine:
+            exponents = self.combine(exponents)
+
+        super().__init__(exponents)
+
+    @classmethod
+    def combine(cls, exponents, rtol=1e-5, atol=1e-7):
+        """
+        Group bosonic exponents with the same frequency and return a
+        single exponent for each frequency present.
+
+        Exponents with the same frequency are only combined if they share the
+        same coupling operator ``.Q``.
+
+        Note that combined exponents take their tag from the first
+        exponent in the group being combined (i.e. the one that occurs first
+        in the given exponents list).
+
+        Parameters
+        ----------
+        exponents : list of BathExponent
+            The list of exponents to combine.
+
+        rtol : float, default 1e-5
+            The relative tolerance to use to when comparing frequencies and
+            coupling operators.
+
+        atol : float, default 1e-7
+            The absolute tolerance to use to when comparing frequencies and
+            coupling operators.
+
+        Returns
+        -------
+        list of BathExponent
+            The new reduced list of exponents.
+        """
+        groups = []
+        remaining = exponents[:]
+
+        while remaining:
+            e1 = remaining.pop(0)
+            group = [e1]
+            for e2 in remaining[:]:
+                if (
+                    np.isclose(e1.vk, e2.vk, rtol=rtol, atol=atol) and
+                    _isequal(e1.Q, e2.Q, tol=atol)
+                ):
+                    group.append(e2)
+                    remaining.remove(e2)
+            groups.append(group)
+
+        new_exponents = []
+        for combine in groups:
+            exp1 = combine[0]
+            if (exp1.type != exp1.types.RI) and all(
+                exp2.type == exp1.type for exp2 in combine
+            ):
+                # the group is either type I or R
+                ck = sum(exp.ck for exp in combine)
+                new_exponents.append(BathExponent(
+                    exp1.type, None, exp1.Q, ck, exp1.vk, tag=exp1.tag,
+                ))
+            else:
+                # the group includes both type I and R exponents
+                ck_R = (
+                    sum(exp.ck for exp in combine if exp.type == exp.types.R) +
+                    sum(exp.ck for exp in combine if exp.type == exp.types.RI)
+                )
+                ck_I = (
+                    sum(exp.ck for exp in combine if exp.type == exp.types.I) +
+                    sum(exp.ck2 for exp in combine if exp.type == exp.types.RI)
+                )
+                new_exponents.append(BathExponent(
+                    "RI", None, exp1.Q, ck_R, exp1.vk, ck2=ck_I,
+                    tag=exp1.tag,
+                ))
+
+        return new_exponents
+
+
+class DrudeLorentzBath(BosonicBath):
+    """
+    A helper class for constructing a Drude-Lorentz bosonic bath from the
+    bath parameters (see parameters below).
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    lam : float
+        Coupling strength.
+
+    gamma : float
+        Bath spectral density cutoff frequency.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(
+        self, Q, lam, gamma, T, Nk, combine=True, tag=None,
+    ):
+        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
+            lam=lam,
+            gamma=gamma,
+            T=T,
+            Nk=Nk,
+        )
+
+        super().__init__(
+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+        )
+
+        self._dl_terminator = _DrudeLorentzTerminator(
+            Q=Q, lam=lam, gamma=gamma, T=T,
+        )
+
+    def terminator(self):
+        """
+        Return the Matsubara terminator for the bath and the calculated
+        approximation discrepancy.
+
+        Returns
+        -------
+        delta: float
+
+            The approximation discrepancy. That is, the difference between the
+            true correlation function of the Drude-Lorentz bath and the sum of
+            the ``Nk`` exponential terms is approximately ``2 * delta *
+            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
+
+        terminator : Qobj
+
+            The Matsubara terminator -- i.e. a liouvillian term representing
+            the contribution to the system-bath dynamics of all exponential
+            expansion terms beyond ``Nk``. It should be used by adding it to
+            the system liouvillian (i.e. ``liouvillian(H_sys)``).
+        """
+        delta, L = self._dl_terminator.terminator(self.exponents)
+        return delta, L
+
+    def _matsubara_params(self, lam, gamma, T, Nk):
+        """ Calculate the Matsubara coefficents and frequencies. """
+        ck_real = [lam * gamma / np.tan(gamma / (2 * T))]
+        ck_real.extend([
+            (8 * lam * gamma * T * np.pi * k * T /
+                ((2 * np.pi * k * T)**2 - gamma**2))
+            for k in range(1, Nk + 1)
+        ])
+        vk_real = [gamma]
+        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
+
+        ck_imag = [lam * gamma * (-1.0)]
+        vk_imag = [gamma]
+
+        return ck_real, vk_real, ck_imag, vk_imag
+
+
+class DrudeLorentzPadeBath(BosonicBath):
+    """
+    A helper class for constructing a Padé expansion for a Drude-Lorentz
+    bosonic bath from the bath parameters (see parameters below).
+
+    A Padé approximant is a sum-over-poles expansion (
+    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
+
+    The application of the Padé method to spectrum decompoisitions is described
+    in "Padé spectrum decompositions of quantum distribution functions and
+    optimal hierarchical equations of motion construction for quantum open
+    systems" [1].
+
+    The implementation here follows the approach in the paper.
+
+    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
+
+    This is an alternative to the :class:`DrudeLorentzBath` which constructs
+    a simpler exponential expansion.
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    lam : float
+        Coupling strength.
+
+    gamma : float
+        Bath spectral density cutoff frequency.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of Padé exponentials terms used to approximate the bath
+        correlation functions.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(
+        self, Q, lam, gamma, T, Nk, combine=True, tag=None
+    ):
+        eta_p, gamma_p = self._corr(lam=lam, gamma=gamma, T=T, Nk=Nk)
+
+        ck_real = [np.real(eta) for eta in eta_p]
+        vk_real = [gam for gam in gamma_p]
+        # There is only one term in the expansion of the imaginary part of the
+        # Drude-Lorentz correlation function.
+        ck_imag = [np.imag(eta_p[0])]
+        vk_imag = [gamma_p[0]]
+
+        super().__init__(
+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+        )
+
+        self._dl_terminator = _DrudeLorentzTerminator(
+            Q=Q, lam=lam, gamma=gamma, T=T,
+        )
+
+    def terminator(self):
+        """
+        Return the Padé terminator for the bath and the calculated
+        approximation discrepancy.
+
+        Returns
+        -------
+        delta: float
+
+            The approximation discrepancy. That is, the difference between the
+            true correlation function of the Drude-Lorentz bath and the sum of
+            the ``Nk`` exponential terms is approximately ``2 * delta *
+            dirac(t)``, where ``dirac(t)`` denotes the Dirac delta function.
+
+        terminator : Qobj
+
+            The Padé terminator -- i.e. a liouvillian term representing
+            the contribution to the system-bath dynamics of all exponential
+            expansion terms beyond ``Nk``. It should be used by adding it to
+            the system liouvillian (i.e. ``liouvillian(H_sys)``).
+        """
+        delta, L = self._dl_terminator.terminator(self.exponents)
+        return delta, L
+
+    def _corr(self, lam, gamma, T, Nk):
+        beta = 1. / T
+        kappa, epsilon = self._kappa_epsilon(Nk)
+
+        eta_p = [lam * gamma * (self._cot(gamma * beta / 2.0) - 1.0j)]
+        gamma_p = [gamma]
+
+        for ll in range(1, Nk + 1):
+            eta_p.append(
+                (kappa[ll] / beta) * 4 * lam * gamma * (epsilon[ll] / beta)
+                / ((epsilon[ll]**2 / beta**2) - gamma**2)
+            )
+            gamma_p.append(epsilon[ll] / beta)
+
+        return eta_p, gamma_p
+
+    def _cot(self, x):
+        return 1. / np.tan(x)
+
+    def _kappa_epsilon(self, Nk):
+        eps = self._calc_eps(Nk)
+        chi = self._calc_chi(Nk)
+
+        kappa = [0]
+        prefactor = 0.5 * Nk * (2 * (Nk + 1) + 1)
+        for j in range(Nk):
+            term = prefactor
+            for k in range(Nk - 1):
+                term *= (
+                    (chi[k]**2 - eps[j]**2) /
+                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+                )
+            for k in [Nk - 1]:
+                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+            kappa.append(term)
+
+        epsilon = [0] + eps
+
+        return kappa, epsilon
+
+    def _delta(self, i, j):
+        return 1.0 if i == j else 0.0
+
+    def _calc_eps(self, Nk):
+        alpha = np.diag([
+                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
+                for k in range(2 * Nk - 1)
+        ], k=1)
+        alpha += alpha.transpose()
+        evals = eigvalsh(alpha)
+        eps = [-2. / val for val in evals[0: Nk]]
+        return eps
+
+    def _calc_chi(self, Nk):
+        alpha_p = np.diag([
+                1. / np.sqrt((2 * k + 7) * (2 * k + 5))
+                for k in range(2 * Nk - 2)
+        ], k=1)
+        alpha_p += alpha_p.transpose()
+        evals = eigvalsh(alpha_p)
+        chi = [-2. / val for val in evals[0: Nk - 1]]
+        return chi
+
+
+class _DrudeLorentzTerminator:
+    """ A class for calculating the terminator of a Drude-Lorentz bath
+        expansion.
+    """
+    def __init__(self, Q, lam, gamma, T):
+        self.Q = Q
+        self.lam = lam
+        self.gamma = gamma
+        self.T = T
+
+    def terminator(self, exponents):
+        """ Calculate the terminator for a Drude-Lorentz bath. """
+        Q = self.Q
+        lam = self.lam
+        gamma = self.gamma
+        beta = 1 / self.T
+
+        delta = 2 * lam / (beta * gamma) - 1j * lam
+
+        for exp in exponents:
+            if exp.type == BathExponent.types["R"]:
+                delta -= exp.ck / exp.vk
+            elif exp.type == BathExponent.types["RI"]:
+                delta -= (exp.ck + 1j * exp.ck2) / exp.vk
+            else:
+                delta -= 1j * exp.ck / exp.vk
+
+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+        L_bnd = -delta * op
+
+        return delta, L_bnd
+
+
+class UnderDampedBath(BosonicBath):
+    """
+    A helper class for constructing an under-damped bosonic bath from the
+    bath parameters (see parameters below).
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    lam : float
+        Coupling strength.
+
+    gamma : float
+        Bath spectral density cutoff frequency.
+
+    w0 : float
+        Bath spectral density resonance frequency.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(
+        self, Q, lam, gamma, w0, T, Nk, combine=True, tag=None,
+    ):
+        ck_real, vk_real, ck_imag, vk_imag = self._matsubara_params(
+            lam=lam,
+            gamma=gamma,
+            w0=w0,
+            T=T,
+            Nk=Nk,
+        )
+
+        super().__init__(
+            Q, ck_real, vk_real, ck_imag, vk_imag, combine=combine, tag=tag,
+        )
+
+    def _matsubara_params(self, lam, gamma, w0, T, Nk):
+        """ Calculate the Matsubara coefficents and frequencies. """
+        beta = 1/T
+        Om = np.sqrt(w0**2 - (gamma/2)**2)
+        Gamma = gamma/2.
+
+        ck_real = ([
+            (lam**2 / (4 * Om))
+            * (1 / np.tanh(beta * (Om + 1.0j * Gamma) / 2)),
+            (lam**2 / (4*Om))
+            * (1 / np.tanh(beta * (Om - 1.0j * Gamma) / 2)),
+        ])
+
+        ck_real.extend([
+            (-2 * lam**2 * gamma / beta) * (2 * np.pi * k / beta)
+            / (
+                ((Om + 1.0j * Gamma)**2 + (2 * np.pi * k/beta)**2)
+                * ((Om - 1.0j * Gamma)**2 + (2 * np.pi * k / beta)**2)
+            )
+            for k in range(1, Nk + 1)
+        ])
+
+        vk_real = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
+        vk_real.extend([
+            2 * np.pi * k * T
+            for k in range(1, Nk + 1)
+        ])
+
+        ck_imag = [
+            1.0j * lam**2 / (4 * Om),
+            -1.0j * lam**2 / (4 * Om),
+        ]
+
+        vk_imag = [-1.0j * Om + Gamma, 1.0j * Om + Gamma]
+
+        return ck_real, vk_real, ck_imag, vk_imag
+
+
+class FermionicBath(Bath):
+    """
+    A helper class for constructing a fermionic bath from the expansion
+    coefficients and frequencies for the ``+`` and ``-`` modes of
+    the bath correlation function.
+
+    There must be the same number of ``+`` and ``-`` modes and their
+    coefficients must be specified in the same order so that ``ck_plus[i],
+    vk_plus[i]`` are the plus coefficient and frequency corresponding
+    to the minus mode ``ck_minus[i], vk_minus[i]``.
+
+    In the fermionic case the order in which excitations are created or
+    destroyed is important, resulting in two different correlation functions
+    labelled ``C_plus(t)`` and ``C_plus(t)``::
+
+        C_plus(t) = sum(ck_plus * exp(- vk_plus * t))
+        C_minus(t) = sum(ck_minus * exp(- vk_minus * t))
+
+    where the expansions above define the coeffiients ``ck`` and the
+    frequencies ``vk``.
+
+    Parameters
+    ----------
+    Q : Qobj
+        The coupling operator for the bath.
+
+    ck_plus : list of complex
+        The coefficients of the expansion terms for the ``+`` part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_plus.
+
+    vk_plus : list of complex
+        The frequencies (exponents) of the expansion terms for the ``+`` part
+        of the correlation function. The corresponding ceofficients are passed
+        as ck_plus.
+
+    ck_minus : list of complex
+        The coefficients of the expansion terms for the ``-`` part of the
+        correlation function. The corresponding frequencies are passed as
+        vk_minus.
+
+    vk_minus : list of complex
+        The frequencies (exponents) of the expansion terms for the ``-`` part
+        of the correlation function. The corresponding ceofficients are passed
+        as ck_minus.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+
+    def _check_cks_and_vks(self, ck_plus, vk_plus, ck_minus, vk_minus):
+        if len(ck_plus) != len(vk_plus) or len(ck_minus) != len(vk_minus):
+            raise ValueError(
+                "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+                " vk_minus must be the same length."
+            )
+        if len(ck_plus) != len(ck_minus):
+            raise ValueError(
+                "The must be the same number of plus and minus exponents"
+                " in the bath, and elements of plus and minus arrays"
+                " should be arranged so that ck_plus[i] is the plus mode"
+                " corresponding to ck_minus[i]."
+            )
+
+    def _check_coup_op(self, Q):
+        if not isinstance(Q, Qobj):
+            raise ValueError("The coupling operator Q must be a Qobj.")
+
+    def __init__(self, Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=None):
+        self._check_cks_and_vks(ck_plus, vk_plus, ck_minus, vk_minus)
+        self._check_coup_op(Q)
+
+        exponents = []
+        for ckp, vkp, ckm, vkm in zip(ck_plus, vk_plus, ck_minus, vk_minus):
+            exponents.append(BathExponent(
+                "+", 2, Q, ckp, vkp, sigma_bar_k_offset=1, tag=tag,
+            ))
+            exponents.append(BathExponent(
+                "-", 2, Q, ckm, vkm, sigma_bar_k_offset=-1, tag=tag,
+            ))
+        super().__init__(exponents)
+
+
+class LorentzianBath(FermionicBath):
+    """
+    A helper class for constructing a Lorentzian fermionic bath from the
+    bath parameters (see parameters below).
+
+    .. note::
+
+        This Matsubara expansion used in this bath converges very slowly
+        and ``Nk > 20`` may be required to get good convergence. The
+        Padé expansion used by :class:`LorentzianPadeBath` converges much
+        more quickly.
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    gamma : float
+        The coupling strength between the system and the bath.
+
+    w : float
+        The width of the environment.
+
+    mu : float
+        The chemical potential of the bath.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
+        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
+        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
+
+        super().__init__(
+            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
+        )
+
+    def _corr(self, gamma, w, mu, T, Nk, sigma):
+        beta = 1. / T
+        kappa = [0.]
+        kappa.extend([1. for _ in range(1, Nk + 1)])
+        epsilon = [0]
+        epsilon.extend([(2 * ll - 1) * np.pi for ll in range(1, Nk + 1)])
+
+        def f(x):
+            return 1 / (np.exp(x) + 1)
+
+        eta_list = [0.5 * gamma * w * f(1.0j * beta * w)]
+        gamma_list = [w - sigma * 1.0j * mu]
+
+        for ll in range(1, Nk + 1):
+            eta_list.append(
+                -1.0j * (kappa[ll] / beta) * gamma * w**2 /
+                (-(epsilon[ll]**2 / beta**2) + w**2)
+            )
+            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
+
+        return eta_list, gamma_list
+
+
+class LorentzianPadeBath(FermionicBath):
+    """
+    A helper class for constructing a Padé expansion for Lorentzian fermionic
+    bath from the bath parameters (see parameters below).
+
+    A Padé approximant is a sum-over-poles expansion (
+    see https://en.wikipedia.org/wiki/Pad%C3%A9_approximant).
+
+    The application of the Padé method to spectrum decompoisitions is described
+    in "Padé spectrum decompositions of quantum distribution functions and
+    optimal hierarchical equations of motion construction for quantum open
+    systems" [1].
+
+    The implementation here follows the approach in the paper.
+
+    [1] J. Chem. Phys. 134, 244106 (2011); https://doi.org/10.1063/1.3602466
+
+    This is an alternative to the :class:`LorentzianBath` which constructs
+    a simpler exponential expansion that converges much more slowly in
+    this particular case.
+
+    Parameters
+    ----------
+    Q : Qobj
+        Operator describing the coupling between system and bath.
+
+    gamma : float
+        The coupling strength between the system and the bath.
+
+    w : float
+        The width of the environment.
+
+    mu : float
+        The chemical potential of the bath.
+
+    T : float
+        Bath temperature.
+
+    Nk : int
+        Number of exponential terms used to approximate the bath correlation
+        functions.
+
+    tag : optional, str, tuple or any other object
+        A label for the bath exponents (for example, the name of the
+        bath). It defaults to None but can be set to help identify which
+        bath an exponent is from.
+    """
+    def __init__(self, Q, gamma, w, mu, T, Nk, tag=None):
+        ck_plus, vk_plus = self._corr(gamma, w, mu, T, Nk, sigma=1.0)
+        ck_minus, vk_minus = self._corr(gamma, w, mu, T, Nk, sigma=-1.0)
+
+        super().__init__(
+            Q, ck_plus, vk_plus, ck_minus, vk_minus, tag=tag,
+        )
+
+    def _corr(self, gamma, w, mu, T, Nk, sigma):
+        beta = 1. / T
+        kappa, epsilon = self._kappa_epsilon(Nk)
+
+        def f_approx(x):
+            f = 0.5
+            for ll in range(1, Nk + 1):
+                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
+            return f
+
+        eta_list = [0.5 * gamma * w * f_approx(1.0j * beta * w)]
+        gamma_list = [w - sigma * 1.0j * mu]
+
+        for ll in range(1, Nk + 1):
+            eta_list.append(
+                -1.0j * (kappa[ll] / beta) * gamma * w**2
+                / (-(epsilon[ll]**2 / beta**2) + w**2)
+            )
+            gamma_list.append(epsilon[ll] / beta - sigma * 1.0j * mu)
+
+        return eta_list, gamma_list
+
+    def _kappa_epsilon(self, Nk):
+        eps = self._calc_eps(Nk)
+        chi = self._calc_chi(Nk)
+
+        kappa = [0]
+        prefactor = 0.5 * Nk * (2 * (Nk + 1) - 1)
+        for j in range(Nk):
+            term = prefactor
+            for k in range(Nk - 1):
+                term *= (
+                    (chi[k]**2 - eps[j]**2) /
+                    (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+                )
+            for k in [Nk - 1]:
+                term /= (eps[k]**2 - eps[j]**2 + self._delta(j, k))
+            kappa.append(term)
+
+        epsilon = [0] + eps
+
+        return kappa, epsilon
+
+    def _delta(self, i, j):
+        return 1.0 if i == j else 0.0
+
+    def _calc_eps(self, Nk):
+        alpha = np.diag([
+                1. / np.sqrt((2 * k + 3) * (2 * k + 1))
+                for k in range(2 * Nk - 1)
+        ], k=1)
+        alpha += alpha.transpose()
+
+        evals = eigvalsh(alpha)
+        eps = [-2. / val for val in evals[0: Nk]]
+        return eps
+
+    def _calc_chi(self, Nk):
+        alpha_p = np.diag([
+                1. / np.sqrt((2 * k + 5) * (2 * k + 3))
+                for k in range(2 * Nk - 2)
+        ], k=1)
+        alpha_p += alpha_p.transpose()
+        evals = eigvalsh(alpha_p)
+        chi = [-2. / val for val in evals[0: Nk - 1]]
+        return chi
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 42cc98d1eb..740c2d5d0c 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -1,1322 +1,1322 @@
-"""
-This module provides solvers for system-bath evoluation using the
-HEOM (hierarchy equations of motion).
-
-See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
-basic introduction to the technique.
-
-The implementation is derived from the BoFiN library (see
-https://github.com/tehruhn/bofin) which was itself derived from an earlier
-implementation in QuTiP itself.
-"""
-
-from time import time
-
-import numpy as np
-import scipy.sparse as sp
-from scipy.sparse.linalg import spsolve
-
-from qutip.settings import settings
-from qutip import state_number_enumerate
-from qutip.core import data as _data
-from qutip.core.data import csr as _csr
-from qutip.core import Qobj, QobjEvo
-from qutip.core.superoperator import liouvillian, spre, spost
-from .bofin_baths import (
-    BathExponent, DrudeLorentzBath,
-)
-from ..solver_base import Solver
-from .. import Result
-
-# Load MKL spsolve if avaiable
-if settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_spsolve
-else:
-    mkl_spsolve = None
-
-__all__ = [
-    "heomsolve",
-    "HierarchyADOs",
-    "HierarchyADOsState",
-    "HEOMResult",
-    "HEOMSolver",
-    "HSolverDL",
-]
-
-
-class HierarchyADOs:
-    """
-    A description of ADOs (auxilliary density operators) with the
-    hierarchical equations of motion.
-
-    The list of ADOs is constructed from a list of bath exponents
-    (corresponding to one or more baths). Each ADO is referred to by a label
-    that lists the number of "excitations" of each bath exponent. The
-    level of a label within the hierarchy is the sum of the "excitations"
-    within the label.
-
-    For example the label ``(0, 0, ..., 0)`` represents the density matrix
-    of the system being solved and is the only 0th level label.
-
-    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
-    etc. are the 1st level labels.
-
-    The second level labels all have either two 1s or a single 2, and so on
-    for the third and higher levels of the hierarchy.
-
-    Parameters
-    ----------
-    exponents : list of BathExponent
-        The exponents of the correlation function describing the bath or
-        baths.
-
-    max_depth : int
-        The maximum depth of the hierarchy (i.e. the maximum sum of
-        "excitations" in the hierarchy ADO labels or maximum ADO level).
-
-    Attributes
-    ----------
-    exponents : list of BathExponent
-        The exponents of the correlation function describing the bath or
-        baths.
-
-    max_depth : int
-        The maximum depth of the hierarchy (i.e. the maximum sum of
-        "excitations" in the hierarchy ADO labels).
-
-    dims : list of int
-        The dimensions of each exponent within the bath(s).
-
-    vk : list of complex
-        The frequency of each exponent within the bath(s).
-
-    ck : list of complex
-        The coefficient of each exponent within the bath(s).
-
-    ck2: list of complex
-        For exponents of type "RI", the coefficient of the exponent within
-        the imaginary expansion. For other exponent types, the entry is None.
-
-    sigma_bar_k_offset: list of int
-        For exponents of type "+" or "-" the offset within the list of modes
-        of the corresponding "-" or "+" exponent. For other exponent types,
-        the entry is None.
-
-    labels: list of tuples
-        A list of the ADO labels within the hierarchy.
-    """
-    def __init__(self, exponents, max_depth):
-        self.exponents = exponents
-        self.max_depth = max_depth
-
-        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
-        self.vk = [exp.vk for exp in self.exponents]
-        self.ck = [exp.ck for exp in self.exponents]
-        self.ck2 = [exp.ck2 for exp in self.exponents]
-        self.sigma_bar_k_offset = [
-            exp.sigma_bar_k_offset for exp in self.exponents
-        ]
-
-        self.labels = list(state_number_enumerate(self.dims, max_depth))
-        self._label_idx = {s: i for i, s in enumerate(self.labels)}
-        self.idx = self._label_idx.__getitem__
-
-    def idx(self, label):
-        """
-        Return the index of the ADO label within the list of labels,
-        i.e. within ``self.labels``.
-
-        Parameters
-        ----------
-        label : tuple
-            The label to look up.
-
-        Returns
-        -------
-        int
-            The index of the label within the list of ADO labels.
-
-        Note
-        ----
-        This implementation of the ``.idx(...)`` method is just for
-        reference and documentation. To avoid the cost of a Python
-        function call, it is replaced with
-        ``self._label_idx.__getitem__`` when the instance is created.
-        """
-        return self._label_idx[label]
-
-    def next(self, label, k):
-        """
-        Return the ADO label with one more excitation in the k'th exponent
-        dimension or ``None`` if adding the excitation would exceed the
-        dimension or maximum depth of the hierarchy.
-
-        Parameters
-        ----------
-        label : tuple
-            The ADO label to add an excitation to.
-        k : int
-            The exponent to add the excitation to.
-
-        Returns
-        -------
-        tuple or None
-            The next label.
-        """
-        if label[k] >= self.dims[k] - 1:
-            return None
-        if sum(label) >= self.max_depth:
-            return None
-        return label[:k] + (label[k] + 1,) + label[k + 1:]
-
-    def prev(self, label, k):
-        """
-        Return the ADO label with one fewer excitation in the k'th
-        exponent dimension or ``None`` if the label has no exciations in the
-        k'th exponent.
-
-        Parameters
-        ----------
-        label : tuple
-            The ADO label to remove the excitation from.
-        k : int
-            The exponent to remove the excitation from.
-
-        Returns
-        -------
-        tuple or None
-            The previous label.
-        """
-        if label[k] <= 0:
-            return None
-        return label[:k] + (label[k] - 1,) + label[k + 1:]
-
-    def exps(self, label):
-        """
-        Converts an ADO label into a tuple of exponents, with one exponent
-        for each "excitation" within the label.
-
-        The number of exponents returned is always equal to the level of the
-        label within the hierarchy (i.e. the sum of the indices within the
-        label).
-
-        Parameters
-        ----------
-        label : tuple
-            The ADO label to convert to a list of exponents.
-
-        Returns
-        -------
-        tuple of BathExponent
-            A tuple of BathExponents.
-
-        Examples
-        --------
-
-        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
-
-        ``ados.exps((2, 0, 0))`` would return
-        ``[ados.exponents[0], ados.exponents[0]]``.
-
-        ``ados.exps((1, 2, 1))`` would return
-        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
-           ados.exponents[2]]``.
-        """
-        return sum(
-            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
-            (),
-        )
-
-    def filter(self, level=None, tags=None, dims=None, types=None):
-        """
-        Return a list of ADO labels for ADOs whose "excitations"
-        match the given patterns.
-
-        Each of the filter parameters (tags, dims, types) may be either
-        unspecified (None) or a list. Unspecified parameters are excluded
-        from the filtering.
-
-        All specified filter parameters must be lists of the same length.
-        Each position in the lists describes a particular excitation and
-        any exponent that matches the filters may supply that excitation.
-        The level of all labels returned is thus equal to the length of
-        the filter parameter lists.
-
-        Within a filter parameter list, items that are None represent
-        wildcards and match any value of that exponent attribute
-
-        Parameters
-        ----------
-        level : int
-            The hierarchy depth to return ADOs from.
-
-        tags : list of object or None
-            Filter parameter that matches the ``.tag`` attribute of
-            exponents.
-
-        dims : list of int
-            Filter parameter that matches the ``.dim`` attribute of
-            exponents.
-
-        types : list of BathExponent types or list of str
-            Filter parameter that matches the ``.type`` attribute
-            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
-            instead of by the actual type (e.g. ``BathExponent.types.R``).
-
-        Returns
-        -------
-        list of tuple
-            The ADO label for each ADO whose exponent excitations
-            (i.e. label) match the given filters or level.
-        """
-        if types is not None:
-            types = [
-                t if t is None or isinstance(t, BathExponent.types)
-                else BathExponent.types[t]
-                for t in types
-            ]
-        filters = [("tag", tags), ("type", types), ("dim", dims)]
-        filters = [(attr, f) for attr, f in filters if f is not None]
-        n = max((len(f) for _, f in filters), default=0)
-        if any(len(f) != n for _, f in filters):
-            raise ValueError(
-                "The tags, dims and types filters must all be the same length."
-            )
-        if n > self.max_depth:
-            raise ValueError(
-                f"The maximum depth for the hierarchy is {self.max_depth} but"
-                f" {n} levels of excitation filters were given."
-            )
-        if level is None:
-            if not filters:
-                # fast path for when there are no excitation filters
-                return self.labels[:]
-        else:
-            if not filters:
-                # fast path for when there are no excitation filters
-                return [label for label in self.labels if sum(label) == level]
-            if level != n:
-                raise ValueError(
-                    f"The level parameter is {level} but {n} levels of"
-                    " excitation filters were given."
-                )
-
-        filtered_dims = [1] * len(self.exponents)
-        for lvl in range(n):
-            level_filters = [
-                (attr, f[lvl]) for attr, f in filters
-                if f[lvl] is not None
-            ]
-            for j, exp in enumerate(self.exponents):
-                if any(getattr(exp, attr) != f for attr, f in level_filters):
-                    continue
-                filtered_dims[j] += 1
-                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
-
-        return [
-            label for label in state_number_enumerate(filtered_dims, n)
-            if sum(label) == n
-        ]
-
-
-class HierarchyADOsState:
-    """
-    Provides convenient access to the full hierarchy ADO state at a particular
-    point in time, ``t``.
-
-    Parameters
-    ----------
-    rho : :class:`~qutip.Qobj`
-        The current state of the system (i.e. the 0th component of the
-        hierarchy).
-    ados : :class:`HierarchyADOs`
-        The description of the hierarchy.
-    ado_state : numpy.array
-        The full state of the hierarchy.
-
-    Attributes
-    ----------
-    rho : Qobj
-        The system state.
-
-    In addition, all of the attributes of the hierarchy description,
-    i.e. ``HierarchyADOs``, are provided directly on this class for
-    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
-    call ``.idx(label)`` directly.
-
-    See :class:`HierarchyADOs` for a full list of the available attributes
-    and methods.
-    """
-    def __init__(self, rho, ados, ado_state):
-        self.rho = rho
-        self._ado_state = ado_state
-        self._ados = ados
-
-    def __getattr__(self, name):
-        return getattr(self._ados, name)
-
-    def extract(self, idx_or_label):
-        """
-        Extract a Qobj representing the specified ADO from a full
-        representation of the ADO states.
-
-        Parameters
-        ----------
-        idx : int or label
-            The index of the ADO to extract. If an ADO label, e.g.
-            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
-            is extracted by label instead.
-
-        Returns
-        -------
-        Qobj
-            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
-        """
-        if isinstance(idx_or_label, int):
-            idx = idx_or_label
-        else:
-            idx = self._ados.idx(idx_or_label)
-        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
-
-
-class HEOMResult(Result):
-    def _post_init(self):
-        super()._post_init()
-
-        self.store_ados = self.options["store_ados"]
-        if self.store_ados:
-            self.final_ado_state = None
-            self.ado_states = []
-
-    def _e_op_func(self, e_op):
-        """ Convert an e_op into a function ``f(t, ado_state)``. """
-        if isinstance(e_op, Qobj):
-            return lambda t, ado_state: (ado_state.rho * e_op).tr()
-        elif isinstance(e_op, QobjEvo):
-            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
-        elif callable(e_op):
-            return e_op
-        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
-
-    def _pre_copy(self, state):
-        return state
-
-    def _store_state(self, t, ado_state):
-        self.states.append(ado_state.rho)
-        if self.store_ados:
-            self.ado_states.append(ado_state)
-
-    def _store_final_state(self, t, ado_state):
-        self.final_state = ado_state.rho
-        if self.store_ados:
-            self.final_ado_state = ado_state
-
-
-def heomsolve(
-    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
-):
-    """
-    Hierarchical Equations of Motion (HEOM) solver that supports multiple
-    baths.
-
-    The baths must be all either bosonic or fermionic baths.
-
-    If you need to run many evolutions of the same system and bath, consider
-    using :class:`HEOMSolver` directly to avoid having to continually
-    reconstruct the equation hierarchy for every evolution.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    bath : Bath or list of Bath
-        A :obj:`Bath` containing the exponents of the expansion of the
-        bath correlation funcion and their associated coefficients
-        and coupling operators, or a list of baths.
-
-        If multiple baths are given, they must all be either fermionic
-        or bosonic baths.
-
-    max_depth : int
-        The maximum depth of the heirarchy (i.e. the maximum number of bath
-        exponent "excitations" to retain).
-
-    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
-        If ``rho0`` is a :class:`~Qobj` the it is the initial state
-        of the system (i.e. a :obj:`~Qobj` density matrix).
-
-        If it is a :class:`~HierarchyADOsState` or array-like, then
-        ``rho0`` gives the initial state of all ADOs.
-
-        Usually the state of the ADOs would be determine from a previous
-        call to ``.run(...)`` with the solver results option ``store_ados``
-        set to True. For example, ``result = solver.run(...)`` could be
-        followed by ``solver.run(result.ado_states[-1], tlist)``.
-
-        If a numpy array-like is passed its shape must be
-        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
-        (i.e. shape of the system density matrix) and the ADOs must
-        be in the same order as in ``.ados.labels``.
-
-    tlist : list
-        An ordered list of times at which to return the value of the state.
-
-    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
-        A list or dictionary of operators as :class:`~Qobj`,
-        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
-        a single operator or callable function. For an operator ``op``, the
-        result will be computed using ``(state * op).tr()`` and the state
-        at each time ``t``. For callable functions, ``f``, the result is
-        computed using ``f(t, ado_state)``. The values are stored in the
-        ``expect`` and ``e_data`` attributes of the result (see the return
-        section below).
-
-    args : dict, optional {None}
-        Change the ``args`` of the RHS for the evolution.
-
-    options : dict, optional {None}
-        Generic solver options.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - store_ados : bool {False, True}
-          Whether or not to store the HEOM ADOs.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - state_data_type: str {'dense'}
-          Name of the data type of the state used during the ODE evolution.
-          Use an empty string to keep the input state type. Many integrator can
-          only work with `Dense`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-    Returns
-    -------
-    :class:`~HEOMResult`
-        The results of the simulation run, with the following important
-        attributes:
-
-        * ``times``: the times ``t`` (i.e. the ``tlist``).
-
-        * ``states``: the system state at each time ``t`` (only available
-          if ``e_ops`` was ``None`` or if the solver option
-          ``store_states`` was set to ``True``).
-
-        * ``ado_states``: the full ADO state at each time (only available
-          if the results option ``ado_return`` was set to ``True``).
-          Each element is an instance of :class:`HierarchyADOsState`.
-          The state of a particular ADO may be extracted from
-          ``result.ado_states[i]`` by calling :meth:`.extract`.
-
-        * ``expect``: a list containing the values of each ``e_ops`` at
-          time ``t``.
-
-        * ``e_data``: a dictionary containing the values of each ``e_ops``
-          at tme ``t``. The keys are those given by ``e_ops`` if it was
-          a dict, otherwise they are the indexes of the supplied ``e_ops``.
-
-        See :class:`~HEOMResult` and :class:`~Result` for the complete
-        list of attributes.
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
-    return solver.run(state0, tlist, e_ops=e_ops)
-
-
-class HEOMSolver(Solver):
-    """
-    HEOM solver that supports multiple baths.
-
-    The baths must be all either bosonic or fermionic baths.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    bath : Bath or list of Bath
-        A :obj:`Bath` containing the exponents of the expansion of the
-        bath correlation funcion and their associated coefficients
-        and coupling operators, or a list of baths.
-
-        If multiple baths are given, they must all be either fermionic
-        or bosonic baths.
-
-    max_depth : int
-        The maximum depth of the heirarchy (i.e. the maximum number of bath
-        exponent "excitations" to retain).
-
-    options : dict, optional
-        Generic solver options.
-        If set to None the default options will be used. Keyword only.
-        Default: None.
-
-    Attributes
-    ----------
-    ados : :obj:`HierarchyADOs`
-        The description of the hierarchy constructed from the given bath
-        and maximum depth.
-
-    rhs : :obj:`QobjEvo`
-        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
-        the system and bath coupling operators are converted to
-        :class:`qutip.data.CSR` instances during construction of the RHS,
-        so the operators in the ``rhs`` will all be sparse.
-    """
-
-    name = "heomsolver"
-    resultclass = HEOMResult
-    _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": False,
-        "method": "adams",
-        "store_ados": False,
-        "state_data_type": "dense",
-    }
-
-    def __init__(self, H, bath, max_depth, *, options=None):
-        _time_start = time()
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
-
-        H = QobjEvo(H)
-        self.L_sys = (
-            liouvillian(H) if H.type == "oper"  # hamiltonian
-            else H  # already a liouvillian
-        )
-
-        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
-        self._sup_shape = self.L_sys.shape[0]
-        self._sys_dims = self.L_sys.dims[0]
-
-        self.ados = HierarchyADOs(
-            self._combine_bath_exponents(bath), max_depth,
-        )
-        self._n_ados = len(self.ados.labels)
-        self._n_exponents = len(self.ados.exponents)
-
-        self._init_ados_time = time() - _time_start
-        _time_start = time()
-
-        # pre-calculate identity matrix required by _grad_n
-        self._sId = _data.identity(self._sup_shape, dtype="csr")
-
-        # pre-calculate superoperators required by _grad_prev and _grad_next:
-        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
-        self._spreQ = [spre(op).data for op in Qs]
-        self._spostQ = [spost(op).data for op in Qs]
-        self._s_pre_minus_post_Q = [
-            _data.sub(self._spreQ[k], self._spostQ[k])
-            for k in range(self._n_exponents)
-        ]
-        self._s_pre_plus_post_Q = [
-            _data.add(self._spreQ[k], self._spostQ[k])
-            for k in range(self._n_exponents)
-        ]
-        self._spreQdag = [spre(op.dag()).data for op in Qs]
-        self._spostQdag = [spost(op.dag()).data for op in Qs]
-        self._s_pre_minus_post_Qdag = [
-            _data.sub(self._spreQdag[k], self._spostQdag[k])
-            for k in range(self._n_exponents)
-        ]
-        self._s_pre_plus_post_Qdag = [
-            _data.add(self._spreQdag[k], self._spostQdag[k])
-            for k in range(self._n_exponents)
-        ]
-
-        self._init_superop_cache_time = time() - _time_start
-        _time_start = time()
-
-        rhs = self._calculate_rhs()
-
-        self._init_rhs_time = time() - _time_start
-
-        super().__init__(rhs, options=options)
-
-    @property
-    def sys_dims(self):
-        """
-        Dimensions of the space that the system use, excluding any environment:
-
-        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
-        for this solver.
-        """
-        return self._sys_dims
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "init time": sum([
-                stats["init time"], self._init_ados_time,
-                self._init_superop_cache_time, self._init_rhs_time,
-            ]),
-            "init ados time": self._init_ados_time,
-            "init superop cache time": self._init_superop_cache_time,
-            "init rhs time": self._init_rhs_time,
-            "solver": "Hierarchical Equations of Motion Solver",
-            "max_depth": self.ados.max_depth,
-        })
-        return stats
-
-    def _combine_bath_exponents(self, bath):
-        """ Combine the exponents for the specified baths. """
-        if not isinstance(bath, (list, tuple)):
-            exponents = bath.exponents
-        else:
-            exponents = []
-            for b in bath:
-                exponents.extend(b.exponents)
-        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
-            raise ValueError(
-                "All bath exponents must have system coupling operators"
-                " with the same dimensions but a mixture of dimensions"
-                " was given."
-            )
-        return exponents
-
-    def _grad_n(self, he_n):
-        """ Get the gradient for the hierarchy ADO at level n. """
-        vk = self.ados.vk
-        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
-        op = _data.mul(self._sId, -vk_sum)
-        return op
-
-    def _grad_prev(self, he_n, k):
-        """ Get the previous gradient. """
-        if self.ados.exponents[k].fermionic:
-            return self._grad_prev_fermionic(he_n, k)
-        else:
-            return self._grad_prev_bosonic(he_n, k)
-
-    def _grad_prev_bosonic(self, he_n, k):
-        if self.ados.exponents[k].type == BathExponent.types.R:
-            op = _data.mul(
-                self._s_pre_minus_post_Q[k],
-                -1j * he_n[k] * self.ados.ck[k],
-            )
-        elif self.ados.exponents[k].type == BathExponent.types.I:
-            op = _data.mul(
-                self._s_pre_plus_post_Q[k],
-                -1j * he_n[k] * 1j * self.ados.ck[k],
-            )
-        elif self.ados.exponents[k].type == BathExponent.types.RI:
-            term1 = _data.mul(
-                self._s_pre_minus_post_Q[k],
-                he_n[k] * -1j * self.ados.ck[k],
-            )
-            term2 = _data.mul(
-                self._s_pre_plus_post_Q[k],
-                he_n[k] * self.ados.ck2[k],
-            )
-            op = _data.add(term1, term2)
-        else:
-            raise ValueError(
-                f"Unsupported type {self.ados.exponents[k].type}"
-                f" for exponent {k}"
-            )
-        return op
-
-    def _grad_prev_fermionic(self, he_n, k):
-        ck = self.ados.ck
-        he_fermionic_n = [
-            i * int(exp.fermionic)
-            for i, exp in zip(he_n, self.ados.exponents)
-        ]
-
-        n_excite = sum(he_fermionic_n)
-        sign1 = (-1) ** (n_excite + 1)
-
-        n_excite_before_m = sum(he_fermionic_n[:k])
-        sign2 = (-1) ** (n_excite_before_m)
-
-        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
-
-        if self.ados.exponents[k].type == BathExponent.types["+"]:
-            op = _data.sub(
-                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
-                _data.mul(
-                    self._spostQdag[k],
-                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
-                ),
-            )
-        elif self.ados.exponents[k].type == BathExponent.types["-"]:
-            op = _data.sub(
-                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
-                _data.mul(
-                    self._spostQ[k],
-                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
-                ),
-            )
-        else:
-            raise ValueError(
-                f"Unsupported type {self.ados.exponents[k].type}"
-                f" for exponent {k}"
-            )
-        return op
-
-    def _grad_next(self, he_n, k):
-        """ Get the previous gradient. """
-        if self.ados.exponents[k].fermionic:
-            return self._grad_next_fermionic(he_n, k)
-        else:
-            return self._grad_next_bosonic(he_n, k)
-
-    def _grad_next_bosonic(self, he_n, k):
-        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
-        return op
-
-    def _grad_next_fermionic(self, he_n, k):
-        he_fermionic_n = [
-            i * int(exp.fermionic)
-            for i, exp in zip(he_n, self.ados.exponents)
-        ]
-        n_excite = sum(he_fermionic_n)
-        sign1 = (-1) ** (n_excite + 1)
-
-        n_excite_before_m = sum(he_fermionic_n[:k])
-        sign2 = (-1) ** (n_excite_before_m)
-
-        if self.ados.exponents[k].type == BathExponent.types["+"]:
-            if sign1 == -1:
-                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
-            else:
-                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
-        elif self.ados.exponents[k].type == BathExponent.types["-"]:
-            if sign1 == -1:
-                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
-            else:
-                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
-        else:
-            raise ValueError(
-                f"Unsupported type {self.ados.exponents[k].type}"
-                f" for exponent {k}"
-            )
-        return op
-
-    def _rhs(self):
-        """ Make the RHS for the HEOM. """
-        ops = _GatherHEOMRHS(
-            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
-        )
-
-        for he_n in self.ados.labels:
-            op = self._grad_n(he_n)
-            ops.add_op(he_n, he_n, op)
-            for k in range(len(self.ados.dims)):
-                next_he = self.ados.next(he_n, k)
-                if next_he is not None:
-                    op = self._grad_next(he_n, k)
-                    ops.add_op(he_n, next_he, op)
-                prev_he = self.ados.prev(he_n, k)
-                if prev_he is not None:
-                    op = self._grad_prev(he_n, k)
-                    ops.add_op(he_n, prev_he, op)
-
-        return ops.gather()
-
-    def _calculate_rhs(self):
-        """ Make the full RHS required by the solver. """
-        rhs_mat = self._rhs()
-        rhs_dims = [
-            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
-        ]
-        h_identity = _data.identity(self._n_ados, dtype="csr")
-
-        if self.L_sys.isconstant:
-            # For the constant case, we just add the Liouvillian to the
-            # diagonal blocks of the RHS matrix.
-            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
-            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
-        else:
-            # In the time dependent case, we construct the parameters
-            # for the ODE gradient function under the assumption that
-            #
-            # RHSmat(t) = RHSmat + time dependent terms that only affect the
-            # diagonal blocks of the RHS matrix.
-            #
-            # This assumption holds because only _grad_n dependents on
-            # the system Liouvillian (and not _grad_prev or _grad_next) and
-            # the bath coupling operators are not time-dependent.
-            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
-
-            def _kron(x):
-                return Qobj(
-                    _data.kron(h_identity, x.data),
-                    dims=rhs_dims,
-                ).to("csr")
-
-            rhs += self.L_sys.linear_map(_kron)
-
-        # The assertion that rhs_mat has data type CSR is just a sanity
-        # check on the RHS creation. The base solver class will still
-        # convert the RHS to the type required by the ODE integrator if
-        # needed.
-        assert isinstance(rhs_mat, _csr.CSR)
-        assert isinstance(rhs, QobjEvo)
-        assert rhs.dims == rhs_dims
-
-        return rhs
-
-    def steady_state(
-        self,
-        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
-    ):
-        """
-        Compute the steady state of the system.
-
-        Parameters
-        ----------
-        use_mkl : bool, default=False
-            Whether to use mkl or not. If mkl is not installed or if
-            this is false, use the scipy splu solver instead.
-
-        mkl_max_iter_refine : int
-            Specifies the the maximum number of iterative refinement steps that
-            the MKL PARDISO solver performs.
-
-            For a complete description, see iparm(8) in
-            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
-
-        mkl_weighted_matching : bool
-            MKL PARDISO can use a maximum weighted matching algorithm to
-            permute large elements close the diagonal. This strategy adds an
-            additional level of reliability to the factorization methods.
-
-            For a complete description, see iparm(13) in
-            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
-
-        Returns
-        -------
-        steady_state : Qobj
-            The steady state density matrix of the system.
-
-        steady_ados : :class:`HierarchyADOsState`
-            The steady state of the full ADO hierarchy. A particular ADO may be
-            extracted from the full state by calling :meth:`.extract`.
-        """
-        if not self.L_sys.isconstant:
-            raise ValueError(
-                "A steady state cannot be determined for a time-dependent"
-                " system"
-            )
-        n = self._sys_shape
-
-        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
-        b_mat[0] = 1.0
-
-        L = self.rhs(0).data.copy().as_scipy()
-        L = L.tolil()
-        L[0, 0: n ** 2 * self._n_ados] = 0.0
-        L = L.tocsr()
-        L += sp.csr_matrix((
-            np.ones(n),
-            (np.zeros(n), [num * (n + 1) for num in range(n)])
-        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
-
-        if mkl_spsolve is not None and use_mkl:
-            L.sort_indices()
-            solution = mkl_spsolve(
-                L,
-                b_mat,
-                perm=None,
-                verbose=False,
-                max_iter_refine=mkl_max_iter_refine,
-                scaling_vectors=True,
-                weighted_matching=mkl_weighted_matching,
-            )
-        else:
-            L = L.tocsc()
-            solution = spsolve(L, b_mat)
-
-        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
-        data = _data.mul(_data.add(data, data.conj()), 0.5)
-        steady_state = Qobj(data, dims=self._sys_dims)
-
-        solution = solution.reshape((self._n_ados, n, n))
-        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
-
-        return steady_state, steady_ados
-
-    def run(self, state0, tlist, *, args=None, e_ops=None):
-        """
-        Solve for the time evolution of the system.
-
-        Parameters
-        ----------
-        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
-            If ``rho0`` is a :class:`~Qobj` the it is the initial state
-            of the system (i.e. a :obj:`~Qobj` density matrix).
-
-            If it is a :class:`~HierarchyADOsState` or array-like, then
-            ``rho0`` gives the initial state of all ADOs.
-
-            Usually the state of the ADOs would be determine from a previous
-            call to ``.run(...)`` with the solver results option ``store_ados``
-            set to True. For example, ``result = solver.run(...)`` could be
-            followed by ``solver.run(result.ado_states[-1], tlist)``.
-
-            If a numpy array-like is passed its shape must be
-            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
-            (i.e. shape of the system density matrix) and the ADOs must
-            be in the same order as in ``.ados.labels``.
-
-        tlist : list
-            An ordered list of times at which to return the value of the state.
-
-        args : dict, optional {None}
-            Change the ``args`` of the RHS for the evolution.
-
-        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
-            A list or dictionary of operators as :class:`~Qobj`,
-            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
-            a single operator or callable function. For an operator ``op``, the
-            result will be computed using ``(state * op).tr()`` and the state
-            at each time ``t``. For callable functions, ``f``, the result is
-            computed using ``f(t, ado_state)``. The values are stored in the
-            ``expect`` and ``e_data`` attributes of the result (see the return
-            section below).
-
-        Returns
-        -------
-        :class:`~HEOMResult`
-            The results of the simulation run, with the following important
-            attributes:
-
-            * ``times``: the times ``t`` (i.e. the ``tlist``).
-
-            * ``states``: the system state at each time ``t`` (only available
-              if ``e_ops`` was ``None`` or if the solver option
-              ``store_states`` was set to ``True``).
-
-            * ``ado_states``: the full ADO state at each time (only available
-              if the results option ``ado_return`` was set to ``True``).
-              Each element is an instance of :class:`HierarchyADOsState`.
-              The state of a particular ADO may be extracted from
-              ``result.ado_states[i]`` by calling :meth:`.extract`.
-
-            * ``expect``: a list containing the values of each ``e_ops`` at
-              time ``t``.
-
-            * ``e_data``: a dictionary containing the values of each ``e_ops``
-              at tme ``t``. The keys are those given by ``e_ops`` if it was
-              a dict, otherwise they are the indexes of the supplied ``e_ops``.
-
-            See :class:`~HEOMResult` and :class:`~Result` for the complete
-            list of attributes.
-        """
-        return super().run(state0, tlist, args=args, e_ops=e_ops)
-
-    def _prepare_state(self, state):
-        n = self._sys_shape
-        rho_dims = self._sys_dims
-        hierarchy_shape = (self._n_ados, n, n)
-
-        rho0 = state
-        ado_init = not isinstance(rho0, Qobj)
-
-        if ado_init:
-            if isinstance(rho0, HierarchyADOsState):
-                rho0_he = rho0._ado_state
-            elif hasattr(rho0, "shape"):  # array-like
-                rho0_he = rho0
-            else:
-                raise TypeError(
-                    f"Initial ADOs passed have type {type(rho0)}"
-                    " but a HierarchyADOsState or a numpy array-like instance"
-                    " was expected"
-                )
-            if rho0_he.shape != hierarchy_shape:
-                raise ValueError(
-                    f"Initial ADOs passed have shape {rho0_he.shape}"
-                    f" but the solver hierarchy shape is {hierarchy_shape}"
-                )
-            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
-            rho0_he = _data.create(rho0_he)
-        else:
-            if rho0.dims != rho_dims:
-                raise ValueError(
-                    f"Initial state rho has dims {rho0.dims}"
-                    f" but the system dims are {rho_dims}"
-                )
-            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
-            rho0_he[:n ** 2] = rho0.full().ravel('F')
-            rho0_he = _data.create(rho0_he)
-
-        if self.options["state_data_type"]:
-            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
-
-        return rho0_he
-
-    def _restore_state(self, state, *, copy=True):
-        n = self._sys_shape
-        rho_shape = (n, n)
-        rho_dims = self._sys_dims
-        hierarchy_shape = (self._n_ados, n, n)
-
-        rho = Qobj(
-            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
-            dims=rho_dims,
-        )
-        ado_state = HierarchyADOsState(
-            rho, self.ados, state.to_array().reshape(hierarchy_shape)
-        )
-        return ado_state
-
-    def start(self, state0, t0):
-        """
-        Set the initial state and time for a step evolution.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution. This may provide either just the
-            initial density matrix of the system, or the full set of ADOs
-            for the hierarchy. See the documentation for ``rho0`` in the
-            ``.run(...)`` method for details.
-
-        t0 : double
-            Initial time of the evolution.
-        """
-        super().start(state0, t0)
-
-    @property
-    def options(self):
-        """
-        Options for HEOMSolver:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        normalize_output: bool, default=False
-            Normalize output state to hide ODE numerical errors.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error
-            if not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size": 10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        method: str, default="adams"
-            Which ordinary differential equation integration method to use.
-
-        state_data_type: str, default="dense"
-            Name of the data type of the state used during the ODE evolution.
-            Use an empty string to keep the input state type. Many integrators
-            support only work with `Dense`.
-
-        store_ados : bool, default=False
-            Whether or not to store the HEOM ADOs. Only relevant when using
-            the HEOM solver.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Solver.options.fset(self, new_options)
-
-
-class HSolverDL(HEOMSolver):
-    """
-    A helper class for creating an :class:`HEOMSolver` that is backwards
-    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
-    in QuTiP 4.6 and below.
-
-    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
-    descriptions of the underlying solver and bath construction.
-
-    An exact copy of the QuTiP 4.6 HSolverDL is provided in
-    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
-    the older solver is required. The older solver will be completely
-    removed in QuTiP 5.
-
-    .. note::
-
-        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
-        supports supplying a time-dependent or Liouvillian ``H_sys``.
-
-    .. note::
-
-        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
-        parameter ``N_exp`` specifying the number of exponents to keep in
-        the expansion of the bath correlation function is one more than
-        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
-        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
-        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
-        order to better match common usage in the literature.
-
-    .. note::
-
-        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
-        are no longer supported.
-
-    Parameters
-    ----------
-    H_sys : Qobj or QobjEvo or list
-        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
-        a complete description.
-
-    coup_op : Qobj
-        Operator describing the coupling between system and bath.
-        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
-
-    coup_strength : float
-        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
-
-    temperature : float
-        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
-
-    N_cut : int
-        The maximum depth of the hierarchy. See ``max_depth`` in
-        :class:`HEOMSolver` for a full description.
-
-    N_exp : int
-        Number of exponential terms used to approximate the bath correlation
-        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
-        less than ``N_exp`` (see note above).
-
-    cut_freq : float
-        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
-        :class:`DrudeLorentzBath`.
-
-    bnd_cut_approx : bool
-        Use boundary cut off approximation. If true, the Matsubara
-        terminator is added to the system Liouvillian (and H_sys is
-        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
-        Default: False.
-
-    options : dict, optional
-        Generic solver options.
-        If set to None the default options will be used. Keyword only.
-        Default: None.
-
-    combine : bool, default True
-        Whether to combine exponents with the same frequency (and coupling
-        operator). See :meth:`BosonicBath.combine` for details.
-        Keyword only. Default: True.
-    """
-    def __init__(
-        self, H_sys, coup_op, coup_strength, temperature,
-        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
-        combine=True,
-    ):
-        H_sys = QobjEvo(H_sys)
-        bath = DrudeLorentzBath(
-            Q=coup_op,
-            lam=coup_strength,
-            gamma=cut_freq,
-            Nk=N_exp - 1,
-            T=temperature,
-            combine=combine,
-        )
-
-        if bnd_cut_approx:
-            # upgrade H_sys to a Liouvillian if needed and add the
-            # bath terminator
-            if H_sys.type == "oper":  # H_sys is a Hamiltonian
-                H_sys = liouvillian(H_sys)
-            _, terminator = bath.terminator()
-            H_sys = H_sys + terminator
-
-        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
-
-        # store input parameters as attributes for politeness and compatibility
-        # with HSolverDL in QuTiP 4.6 and below.
-        self.coup_strength = coup_strength
-        self.cut_freq = cut_freq
-        self.temperature = temperature
-        self.N_exp = N_exp
-        self.bnd_cut_approx = bnd_cut_approx
-
-
-class _GatherHEOMRHS:
-    """ A class for collecting elements of the right-hand side matrix
-        of the HEOM.
-
-        Parameters
-        ----------
-        f_idx: function(he_state) -> he_idx
-            A function that returns the index of a hierarchy state
-            (i.e. an ADO label).
-        block : int
-            The size of a single ADO Liovillian operator in the hierarchy.
-        nhe : int
-            The number of ADOs in the hierarchy.
-    """
-    def __init__(self, f_idx, block, nhe):
-        self._block_size = block
-        self._n_blocks = nhe
-        self._f_idx = f_idx
-        self._ops = []
-
-    def add_op(self, row_he, col_he, op):
-        """ Add an block operator to the list. """
-        self._ops.append(
-            (self._f_idx(row_he), self._f_idx(col_he), op)
-        )
-
-    def gather(self):
-        """ Create the HEOM liouvillian from a sorted list of smaller sparse
-            matrices.
-
-            .. note::
-
-                The list of operators contains tuples of the form
-                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
-                *block* row and column for each op. An operator with
-                block indices ``(N, M)`` is placed at position
-                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
-                in the output matrix.
-
-            Returns
-            -------
-            rhs : :obj:`Data`
-                A combined matrix of shape ``(block * nhe, block * ne)``.
-        """
-        self._ops.sort()
-        ops = np.array(self._ops, dtype=[
-            ("row", _data.base.idxint_dtype),
-            ("col", _data.base.idxint_dtype),
-            ("op", _data.CSR),
-        ])
-        return _csr._from_csr_blocks(
-            ops["row"], ops["col"], ops["op"],
-            self._n_blocks, self._block_size,
-        )
+"""
+This module provides solvers for system-bath evoluation using the
+HEOM (hierarchy equations of motion).
+
+See https://en.wikipedia.org/wiki/Hierarchical_equations_of_motion for a very
+basic introduction to the technique.
+
+The implementation is derived from the BoFiN library (see
+https://github.com/tehruhn/bofin) which was itself derived from an earlier
+implementation in QuTiP itself.
+"""
+
+from time import time
+
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.linalg import spsolve
+
+from qutip.settings import settings
+from qutip import state_number_enumerate
+from qutip.core import data as _data
+from qutip.core.data import csr as _csr
+from qutip.core import Qobj, QobjEvo
+from qutip.core.superoperator import liouvillian, spre, spost
+from .bofin_baths import (
+    BathExponent, DrudeLorentzBath,
+)
+from ..solver_base import Solver
+from .. import Result
+
+# Load MKL spsolve if avaiable
+if settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_spsolve
+else:
+    mkl_spsolve = None
+
+__all__ = [
+    "heomsolve",
+    "HierarchyADOs",
+    "HierarchyADOsState",
+    "HEOMResult",
+    "HEOMSolver",
+    "HSolverDL",
+]
+
+
+class HierarchyADOs:
+    """
+    A description of ADOs (auxilliary density operators) with the
+    hierarchical equations of motion.
+
+    The list of ADOs is constructed from a list of bath exponents
+    (corresponding to one or more baths). Each ADO is referred to by a label
+    that lists the number of "excitations" of each bath exponent. The
+    level of a label within the hierarchy is the sum of the "excitations"
+    within the label.
+
+    For example the label ``(0, 0, ..., 0)`` represents the density matrix
+    of the system being solved and is the only 0th level label.
+
+    The labels with a single 1, i.e. ``(1, 0, ..., 0)``, ``(0, 1, 0, ... 0)``,
+    etc. are the 1st level labels.
+
+    The second level labels all have either two 1s or a single 2, and so on
+    for the third and higher levels of the hierarchy.
+
+    Parameters
+    ----------
+    exponents : list of BathExponent
+        The exponents of the correlation function describing the bath or
+        baths.
+
+    max_depth : int
+        The maximum depth of the hierarchy (i.e. the maximum sum of
+        "excitations" in the hierarchy ADO labels or maximum ADO level).
+
+    Attributes
+    ----------
+    exponents : list of BathExponent
+        The exponents of the correlation function describing the bath or
+        baths.
+
+    max_depth : int
+        The maximum depth of the hierarchy (i.e. the maximum sum of
+        "excitations" in the hierarchy ADO labels).
+
+    dims : list of int
+        The dimensions of each exponent within the bath(s).
+
+    vk : list of complex
+        The frequency of each exponent within the bath(s).
+
+    ck : list of complex
+        The coefficient of each exponent within the bath(s).
+
+    ck2: list of complex
+        For exponents of type "RI", the coefficient of the exponent within
+        the imaginary expansion. For other exponent types, the entry is None.
+
+    sigma_bar_k_offset: list of int
+        For exponents of type "+" or "-" the offset within the list of modes
+        of the corresponding "-" or "+" exponent. For other exponent types,
+        the entry is None.
+
+    labels: list of tuples
+        A list of the ADO labels within the hierarchy.
+    """
+    def __init__(self, exponents, max_depth):
+        self.exponents = exponents
+        self.max_depth = max_depth
+
+        self.dims = [exp.dim or (max_depth + 1) for exp in self.exponents]
+        self.vk = [exp.vk for exp in self.exponents]
+        self.ck = [exp.ck for exp in self.exponents]
+        self.ck2 = [exp.ck2 for exp in self.exponents]
+        self.sigma_bar_k_offset = [
+            exp.sigma_bar_k_offset for exp in self.exponents
+        ]
+
+        self.labels = list(state_number_enumerate(self.dims, max_depth))
+        self._label_idx = {s: i for i, s in enumerate(self.labels)}
+        self.idx = self._label_idx.__getitem__
+
+    def idx(self, label):
+        """
+        Return the index of the ADO label within the list of labels,
+        i.e. within ``self.labels``.
+
+        Parameters
+        ----------
+        label : tuple
+            The label to look up.
+
+        Returns
+        -------
+        int
+            The index of the label within the list of ADO labels.
+
+        Note
+        ----
+        This implementation of the ``.idx(...)`` method is just for
+        reference and documentation. To avoid the cost of a Python
+        function call, it is replaced with
+        ``self._label_idx.__getitem__`` when the instance is created.
+        """
+        return self._label_idx[label]
+
+    def next(self, label, k):
+        """
+        Return the ADO label with one more excitation in the k'th exponent
+        dimension or ``None`` if adding the excitation would exceed the
+        dimension or maximum depth of the hierarchy.
+
+        Parameters
+        ----------
+        label : tuple
+            The ADO label to add an excitation to.
+        k : int
+            The exponent to add the excitation to.
+
+        Returns
+        -------
+        tuple or None
+            The next label.
+        """
+        if label[k] >= self.dims[k] - 1:
+            return None
+        if sum(label) >= self.max_depth:
+            return None
+        return label[:k] + (label[k] + 1,) + label[k + 1:]
+
+    def prev(self, label, k):
+        """
+        Return the ADO label with one fewer excitation in the k'th
+        exponent dimension or ``None`` if the label has no exciations in the
+        k'th exponent.
+
+        Parameters
+        ----------
+        label : tuple
+            The ADO label to remove the excitation from.
+        k : int
+            The exponent to remove the excitation from.
+
+        Returns
+        -------
+        tuple or None
+            The previous label.
+        """
+        if label[k] <= 0:
+            return None
+        return label[:k] + (label[k] - 1,) + label[k + 1:]
+
+    def exps(self, label):
+        """
+        Converts an ADO label into a tuple of exponents, with one exponent
+        for each "excitation" within the label.
+
+        The number of exponents returned is always equal to the level of the
+        label within the hierarchy (i.e. the sum of the indices within the
+        label).
+
+        Parameters
+        ----------
+        label : tuple
+            The ADO label to convert to a list of exponents.
+
+        Returns
+        -------
+        tuple of BathExponent
+            A tuple of BathExponents.
+
+        Examples
+        --------
+
+        ``ados.exps((1, 0, 0))`` would return ``[ados.exponents[0]]``
+
+        ``ados.exps((2, 0, 0))`` would return
+        ``[ados.exponents[0], ados.exponents[0]]``.
+
+        ``ados.exps((1, 2, 1))`` would return
+        ``[ados.exponents[0], ados.exponents[1], ados.exponents[1], \
+           ados.exponents[2]]``.
+        """
+        return sum(
+            ((exp,) * n for (n, exp) in zip(label, self.exponents) if n > 0),
+            (),
+        )
+
+    def filter(self, level=None, tags=None, dims=None, types=None):
+        """
+        Return a list of ADO labels for ADOs whose "excitations"
+        match the given patterns.
+
+        Each of the filter parameters (tags, dims, types) may be either
+        unspecified (None) or a list. Unspecified parameters are excluded
+        from the filtering.
+
+        All specified filter parameters must be lists of the same length.
+        Each position in the lists describes a particular excitation and
+        any exponent that matches the filters may supply that excitation.
+        The level of all labels returned is thus equal to the length of
+        the filter parameter lists.
+
+        Within a filter parameter list, items that are None represent
+        wildcards and match any value of that exponent attribute
+
+        Parameters
+        ----------
+        level : int
+            The hierarchy depth to return ADOs from.
+
+        tags : list of object or None
+            Filter parameter that matches the ``.tag`` attribute of
+            exponents.
+
+        dims : list of int
+            Filter parameter that matches the ``.dim`` attribute of
+            exponents.
+
+        types : list of BathExponent types or list of str
+            Filter parameter that matches the ``.type`` attribute
+            of exponents. Types may be supplied by name (e.g. "R", "I", "+")
+            instead of by the actual type (e.g. ``BathExponent.types.R``).
+
+        Returns
+        -------
+        list of tuple
+            The ADO label for each ADO whose exponent excitations
+            (i.e. label) match the given filters or level.
+        """
+        if types is not None:
+            types = [
+                t if t is None or isinstance(t, BathExponent.types)
+                else BathExponent.types[t]
+                for t in types
+            ]
+        filters = [("tag", tags), ("type", types), ("dim", dims)]
+        filters = [(attr, f) for attr, f in filters if f is not None]
+        n = max((len(f) for _, f in filters), default=0)
+        if any(len(f) != n for _, f in filters):
+            raise ValueError(
+                "The tags, dims and types filters must all be the same length."
+            )
+        if n > self.max_depth:
+            raise ValueError(
+                f"The maximum depth for the hierarchy is {self.max_depth} but"
+                f" {n} levels of excitation filters were given."
+            )
+        if level is None:
+            if not filters:
+                # fast path for when there are no excitation filters
+                return self.labels[:]
+        else:
+            if not filters:
+                # fast path for when there are no excitation filters
+                return [label for label in self.labels if sum(label) == level]
+            if level != n:
+                raise ValueError(
+                    f"The level parameter is {level} but {n} levels of"
+                    " excitation filters were given."
+                )
+
+        filtered_dims = [1] * len(self.exponents)
+        for lvl in range(n):
+            level_filters = [
+                (attr, f[lvl]) for attr, f in filters
+                if f[lvl] is not None
+            ]
+            for j, exp in enumerate(self.exponents):
+                if any(getattr(exp, attr) != f for attr, f in level_filters):
+                    continue
+                filtered_dims[j] += 1
+                filtered_dims[j] = min(self.dims[j], filtered_dims[j])
+
+        return [
+            label for label in state_number_enumerate(filtered_dims, n)
+            if sum(label) == n
+        ]
+
+
+class HierarchyADOsState:
+    """
+    Provides convenient access to the full hierarchy ADO state at a particular
+    point in time, ``t``.
+
+    Parameters
+    ----------
+    rho : :class:`~qutip.Qobj`
+        The current state of the system (i.e. the 0th component of the
+        hierarchy).
+    ados : :class:`HierarchyADOs`
+        The description of the hierarchy.
+    ado_state : numpy.array
+        The full state of the hierarchy.
+
+    Attributes
+    ----------
+    rho : Qobj
+        The system state.
+
+    In addition, all of the attributes of the hierarchy description,
+    i.e. ``HierarchyADOs``, are provided directly on this class for
+    convenience. E.g. one can access ``.labels``, or ``.exponents`` or
+    call ``.idx(label)`` directly.
+
+    See :class:`HierarchyADOs` for a full list of the available attributes
+    and methods.
+    """
+    def __init__(self, rho, ados, ado_state):
+        self.rho = rho
+        self._ado_state = ado_state
+        self._ados = ados
+
+    def __getattr__(self, name):
+        return getattr(self._ados, name)
+
+    def extract(self, idx_or_label):
+        """
+        Extract a Qobj representing the specified ADO from a full
+        representation of the ADO states.
+
+        Parameters
+        ----------
+        idx : int or label
+            The index of the ADO to extract. If an ADO label, e.g.
+            ``(0, 1, 0, ...)`` is supplied instead, then the ADO
+            is extracted by label instead.
+
+        Returns
+        -------
+        Qobj
+            A :obj:`~qutip.Qobj` representing the state of the specified ADO.
+        """
+        if isinstance(idx_or_label, int):
+            idx = idx_or_label
+        else:
+            idx = self._ados.idx(idx_or_label)
+        return Qobj(self._ado_state[idx, :].T, dims=self.rho.dims)
+
+
+class HEOMResult(Result):
+    def _post_init(self):
+        super()._post_init()
+
+        self.store_ados = self.options["store_ados"]
+        if self.store_ados:
+            self.final_ado_state = None
+            self.ado_states = []
+
+    def _e_op_func(self, e_op):
+        """ Convert an e_op into a function ``f(t, ado_state)``. """
+        if isinstance(e_op, Qobj):
+            return lambda t, ado_state: (ado_state.rho * e_op).tr()
+        elif isinstance(e_op, QobjEvo):
+            return lambda t, ado_state: e_op.expect(t, ado_state.rho)
+        elif callable(e_op):
+            return e_op
+        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
+
+    def _pre_copy(self, state):
+        return state
+
+    def _store_state(self, t, ado_state):
+        self.states.append(ado_state.rho)
+        if self.store_ados:
+            self.ado_states.append(ado_state)
+
+    def _store_final_state(self, t, ado_state):
+        self.final_state = ado_state.rho
+        if self.store_ados:
+            self.final_ado_state = ado_state
+
+
+def heomsolve(
+    H, bath, max_depth, state0, tlist, *, e_ops=None, args=None, options=None,
+):
+    """
+    Hierarchical Equations of Motion (HEOM) solver that supports multiple
+    baths.
+
+    The baths must be all either bosonic or fermionic baths.
+
+    If you need to run many evolutions of the same system and bath, consider
+    using :class:`HEOMSolver` directly to avoid having to continually
+    reconstruct the equation hierarchy for every evolution.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    bath : Bath or list of Bath
+        A :obj:`Bath` containing the exponents of the expansion of the
+        bath correlation funcion and their associated coefficients
+        and coupling operators, or a list of baths.
+
+        If multiple baths are given, they must all be either fermionic
+        or bosonic baths.
+
+    max_depth : int
+        The maximum depth of the heirarchy (i.e. the maximum number of bath
+        exponent "excitations" to retain).
+
+    state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
+        If ``rho0`` is a :class:`~Qobj` the it is the initial state
+        of the system (i.e. a :obj:`~Qobj` density matrix).
+
+        If it is a :class:`~HierarchyADOsState` or array-like, then
+        ``rho0`` gives the initial state of all ADOs.
+
+        Usually the state of the ADOs would be determine from a previous
+        call to ``.run(...)`` with the solver results option ``store_ados``
+        set to True. For example, ``result = solver.run(...)`` could be
+        followed by ``solver.run(result.ado_states[-1], tlist)``.
+
+        If a numpy array-like is passed its shape must be
+        ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
+        (i.e. shape of the system density matrix) and the ADOs must
+        be in the same order as in ``.ados.labels``.
+
+    tlist : list
+        An ordered list of times at which to return the value of the state.
+
+    e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
+        A list or dictionary of operators as :class:`~Qobj`,
+        :class:`~QobjEvo` and/or callable functions (they can be mixed) or
+        a single operator or callable function. For an operator ``op``, the
+        result will be computed using ``(state * op).tr()`` and the state
+        at each time ``t``. For callable functions, ``f``, the result is
+        computed using ``f(t, ado_state)``. The values are stored in the
+        ``expect`` and ``e_data`` attributes of the result (see the return
+        section below).
+
+    args : dict, optional {None}
+        Change the ``args`` of the RHS for the evolution.
+
+    options : dict, optional {None}
+        Generic solver options.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - store_ados : bool {False, True}
+          Whether or not to store the HEOM ADOs.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - state_data_type: str {'dense'}
+          Name of the data type of the state used during the ODE evolution.
+          Use an empty string to keep the input state type. Many integrator can
+          only work with `Dense`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+    Returns
+    -------
+    :class:`~HEOMResult`
+        The results of the simulation run, with the following important
+        attributes:
+
+        * ``times``: the times ``t`` (i.e. the ``tlist``).
+
+        * ``states``: the system state at each time ``t`` (only available
+          if ``e_ops`` was ``None`` or if the solver option
+          ``store_states`` was set to ``True``).
+
+        * ``ado_states``: the full ADO state at each time (only available
+          if the results option ``ado_return`` was set to ``True``).
+          Each element is an instance of :class:`HierarchyADOsState`.
+          The state of a particular ADO may be extracted from
+          ``result.ado_states[i]`` by calling :meth:`.extract`.
+
+        * ``expect``: a list containing the values of each ``e_ops`` at
+          time ``t``.
+
+        * ``e_data``: a dictionary containing the values of each ``e_ops``
+          at tme ``t``. The keys are those given by ``e_ops`` if it was
+          a dict, otherwise they are the indexes of the supplied ``e_ops``.
+
+        See :class:`~HEOMResult` and :class:`~Result` for the complete
+        list of attributes.
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    solver = HEOMSolver(H, bath=bath, max_depth=max_depth, options=options)
+    return solver.run(state0, tlist, e_ops=e_ops)
+
+
+class HEOMSolver(Solver):
+    """
+    HEOM solver that supports multiple baths.
+
+    The baths must be all either bosonic or fermionic baths.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. list of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    bath : Bath or list of Bath
+        A :obj:`Bath` containing the exponents of the expansion of the
+        bath correlation funcion and their associated coefficients
+        and coupling operators, or a list of baths.
+
+        If multiple baths are given, they must all be either fermionic
+        or bosonic baths.
+
+    max_depth : int
+        The maximum depth of the heirarchy (i.e. the maximum number of bath
+        exponent "excitations" to retain).
+
+    options : dict, optional
+        Generic solver options.
+        If set to None the default options will be used. Keyword only.
+        Default: None.
+
+    Attributes
+    ----------
+    ados : :obj:`HierarchyADOs`
+        The description of the hierarchy constructed from the given bath
+        and maximum depth.
+
+    rhs : :obj:`QobjEvo`
+        The right-hand side (RHS) of the hierarchy evolution ODE. Internally
+        the system and bath coupling operators are converted to
+        :class:`qutip.data.CSR` instances during construction of the RHS,
+        so the operators in the ``rhs`` will all be sparse.
+    """
+
+    name = "heomsolver"
+    resultclass = HEOMResult
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": False,
+        "method": "adams",
+        "store_ados": False,
+        "state_data_type": "dense",
+    }
+
+    def __init__(self, H, bath, max_depth, *, options=None):
+        _time_start = time()
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian (H) must be a Qobj or QobjEvo")
+
+        H = QobjEvo(H)
+        self.L_sys = (
+            liouvillian(H) if H.type == "oper"  # hamiltonian
+            else H  # already a liouvillian
+        )
+
+        self._sys_shape = int(np.sqrt(self.L_sys.shape[0]))
+        self._sup_shape = self.L_sys.shape[0]
+        self._sys_dims = self.L_sys.dims[0]
+
+        self.ados = HierarchyADOs(
+            self._combine_bath_exponents(bath), max_depth,
+        )
+        self._n_ados = len(self.ados.labels)
+        self._n_exponents = len(self.ados.exponents)
+
+        self._init_ados_time = time() - _time_start
+        _time_start = time()
+
+        # pre-calculate identity matrix required by _grad_n
+        self._sId = _data.identity(self._sup_shape, dtype="csr")
+
+        # pre-calculate superoperators required by _grad_prev and _grad_next:
+        Qs = [exp.Q.to("csr") for exp in self.ados.exponents]
+        self._spreQ = [spre(op).data for op in Qs]
+        self._spostQ = [spost(op).data for op in Qs]
+        self._s_pre_minus_post_Q = [
+            _data.sub(self._spreQ[k], self._spostQ[k])
+            for k in range(self._n_exponents)
+        ]
+        self._s_pre_plus_post_Q = [
+            _data.add(self._spreQ[k], self._spostQ[k])
+            for k in range(self._n_exponents)
+        ]
+        self._spreQdag = [spre(op.dag()).data for op in Qs]
+        self._spostQdag = [spost(op.dag()).data for op in Qs]
+        self._s_pre_minus_post_Qdag = [
+            _data.sub(self._spreQdag[k], self._spostQdag[k])
+            for k in range(self._n_exponents)
+        ]
+        self._s_pre_plus_post_Qdag = [
+            _data.add(self._spreQdag[k], self._spostQdag[k])
+            for k in range(self._n_exponents)
+        ]
+
+        self._init_superop_cache_time = time() - _time_start
+        _time_start = time()
+
+        rhs = self._calculate_rhs()
+
+        self._init_rhs_time = time() - _time_start
+
+        super().__init__(rhs, options=options)
+
+    @property
+    def sys_dims(self):
+        """
+        Dimensions of the space that the system use, excluding any environment:
+
+        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
+        for this solver.
+        """
+        return self._sys_dims
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "init time": sum([
+                stats["init time"], self._init_ados_time,
+                self._init_superop_cache_time, self._init_rhs_time,
+            ]),
+            "init ados time": self._init_ados_time,
+            "init superop cache time": self._init_superop_cache_time,
+            "init rhs time": self._init_rhs_time,
+            "solver": "Hierarchical Equations of Motion Solver",
+            "max_depth": self.ados.max_depth,
+        })
+        return stats
+
+    def _combine_bath_exponents(self, bath):
+        """ Combine the exponents for the specified baths. """
+        if not isinstance(bath, (list, tuple)):
+            exponents = bath.exponents
+        else:
+            exponents = []
+            for b in bath:
+                exponents.extend(b.exponents)
+        if not all(exp.Q.dims == exponents[0].Q.dims for exp in exponents):
+            raise ValueError(
+                "All bath exponents must have system coupling operators"
+                " with the same dimensions but a mixture of dimensions"
+                " was given."
+            )
+        return exponents
+
+    def _grad_n(self, he_n):
+        """ Get the gradient for the hierarchy ADO at level n. """
+        vk = self.ados.vk
+        vk_sum = sum(he_n[i] * vk[i] for i in range(len(vk)))
+        op = _data.mul(self._sId, -vk_sum)
+        return op
+
+    def _grad_prev(self, he_n, k):
+        """ Get the previous gradient. """
+        if self.ados.exponents[k].fermionic:
+            return self._grad_prev_fermionic(he_n, k)
+        else:
+            return self._grad_prev_bosonic(he_n, k)
+
+    def _grad_prev_bosonic(self, he_n, k):
+        if self.ados.exponents[k].type == BathExponent.types.R:
+            op = _data.mul(
+                self._s_pre_minus_post_Q[k],
+                -1j * he_n[k] * self.ados.ck[k],
+            )
+        elif self.ados.exponents[k].type == BathExponent.types.I:
+            op = _data.mul(
+                self._s_pre_plus_post_Q[k],
+                -1j * he_n[k] * 1j * self.ados.ck[k],
+            )
+        elif self.ados.exponents[k].type == BathExponent.types.RI:
+            term1 = _data.mul(
+                self._s_pre_minus_post_Q[k],
+                he_n[k] * -1j * self.ados.ck[k],
+            )
+            term2 = _data.mul(
+                self._s_pre_plus_post_Q[k],
+                he_n[k] * self.ados.ck2[k],
+            )
+            op = _data.add(term1, term2)
+        else:
+            raise ValueError(
+                f"Unsupported type {self.ados.exponents[k].type}"
+                f" for exponent {k}"
+            )
+        return op
+
+    def _grad_prev_fermionic(self, he_n, k):
+        ck = self.ados.ck
+        he_fermionic_n = [
+            i * int(exp.fermionic)
+            for i, exp in zip(he_n, self.ados.exponents)
+        ]
+
+        n_excite = sum(he_fermionic_n)
+        sign1 = (-1) ** (n_excite + 1)
+
+        n_excite_before_m = sum(he_fermionic_n[:k])
+        sign2 = (-1) ** (n_excite_before_m)
+
+        sigma_bar_k = k + self.ados.sigma_bar_k_offset[k]
+
+        if self.ados.exponents[k].type == BathExponent.types["+"]:
+            op = _data.sub(
+                _data.mul(self._spreQdag[k], -1j * sign2 * ck[k]),
+                _data.mul(
+                    self._spostQdag[k],
+                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
+                ),
+            )
+        elif self.ados.exponents[k].type == BathExponent.types["-"]:
+            op = _data.sub(
+                _data.mul(self._spreQ[k], -1j * sign2 * ck[k]),
+                _data.mul(
+                    self._spostQ[k],
+                    -1j * sign2 * sign1 * np.conj(ck[sigma_bar_k]),
+                ),
+            )
+        else:
+            raise ValueError(
+                f"Unsupported type {self.ados.exponents[k].type}"
+                f" for exponent {k}"
+            )
+        return op
+
+    def _grad_next(self, he_n, k):
+        """ Get the previous gradient. """
+        if self.ados.exponents[k].fermionic:
+            return self._grad_next_fermionic(he_n, k)
+        else:
+            return self._grad_next_bosonic(he_n, k)
+
+    def _grad_next_bosonic(self, he_n, k):
+        op = _data.mul(self._s_pre_minus_post_Q[k], -1j)
+        return op
+
+    def _grad_next_fermionic(self, he_n, k):
+        he_fermionic_n = [
+            i * int(exp.fermionic)
+            for i, exp in zip(he_n, self.ados.exponents)
+        ]
+        n_excite = sum(he_fermionic_n)
+        sign1 = (-1) ** (n_excite + 1)
+
+        n_excite_before_m = sum(he_fermionic_n[:k])
+        sign2 = (-1) ** (n_excite_before_m)
+
+        if self.ados.exponents[k].type == BathExponent.types["+"]:
+            if sign1 == -1:
+                op = _data.mul(self._s_pre_minus_post_Q[k], -1j * sign2)
+            else:
+                op = _data.mul(self._s_pre_plus_post_Q[k], -1j * sign2)
+        elif self.ados.exponents[k].type == BathExponent.types["-"]:
+            if sign1 == -1:
+                op = _data.mul(self._s_pre_minus_post_Qdag[k], -1j * sign2)
+            else:
+                op = _data.mul(self._s_pre_plus_post_Qdag[k], -1j * sign2)
+        else:
+            raise ValueError(
+                f"Unsupported type {self.ados.exponents[k].type}"
+                f" for exponent {k}"
+            )
+        return op
+
+    def _rhs(self):
+        """ Make the RHS for the HEOM. """
+        ops = _GatherHEOMRHS(
+            self.ados.idx, block=self._sup_shape, nhe=self._n_ados
+        )
+
+        for he_n in self.ados.labels:
+            op = self._grad_n(he_n)
+            ops.add_op(he_n, he_n, op)
+            for k in range(len(self.ados.dims)):
+                next_he = self.ados.next(he_n, k)
+                if next_he is not None:
+                    op = self._grad_next(he_n, k)
+                    ops.add_op(he_n, next_he, op)
+                prev_he = self.ados.prev(he_n, k)
+                if prev_he is not None:
+                    op = self._grad_prev(he_n, k)
+                    ops.add_op(he_n, prev_he, op)
+
+        return ops.gather()
+
+    def _calculate_rhs(self):
+        """ Make the full RHS required by the solver. """
+        rhs_mat = self._rhs()
+        rhs_dims = [
+            self._sup_shape * self._n_ados, self._sup_shape * self._n_ados
+        ]
+        h_identity = _data.identity(self._n_ados, dtype="csr")
+
+        if self.L_sys.isconstant:
+            # For the constant case, we just add the Liouvillian to the
+            # diagonal blocks of the RHS matrix.
+            rhs_mat += _data.kron(h_identity, self.L_sys(0).to("csr").data)
+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
+        else:
+            # In the time dependent case, we construct the parameters
+            # for the ODE gradient function under the assumption that
+            #
+            # RHSmat(t) = RHSmat + time dependent terms that only affect the
+            # diagonal blocks of the RHS matrix.
+            #
+            # This assumption holds because only _grad_n dependents on
+            # the system Liouvillian (and not _grad_prev or _grad_next) and
+            # the bath coupling operators are not time-dependent.
+            rhs = QobjEvo(Qobj(rhs_mat, dims=rhs_dims))
+
+            def _kron(x):
+                return Qobj(
+                    _data.kron(h_identity, x.data),
+                    dims=rhs_dims,
+                ).to("csr")
+
+            rhs += self.L_sys.linear_map(_kron)
+
+        # The assertion that rhs_mat has data type CSR is just a sanity
+        # check on the RHS creation. The base solver class will still
+        # convert the RHS to the type required by the ODE integrator if
+        # needed.
+        assert isinstance(rhs_mat, _csr.CSR)
+        assert isinstance(rhs, QobjEvo)
+        assert rhs.dims == rhs_dims
+
+        return rhs
+
+    def steady_state(
+        self,
+        use_mkl=True, mkl_max_iter_refine=100, mkl_weighted_matching=False
+    ):
+        """
+        Compute the steady state of the system.
+
+        Parameters
+        ----------
+        use_mkl : bool, default=False
+            Whether to use mkl or not. If mkl is not installed or if
+            this is false, use the scipy splu solver instead.
+
+        mkl_max_iter_refine : int
+            Specifies the the maximum number of iterative refinement steps that
+            the MKL PARDISO solver performs.
+
+            For a complete description, see iparm(8) in
+            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
+
+        mkl_weighted_matching : bool
+            MKL PARDISO can use a maximum weighted matching algorithm to
+            permute large elements close the diagonal. This strategy adds an
+            additional level of reliability to the factorization methods.
+
+            For a complete description, see iparm(13) in
+            http://cali2.unilim.fr/intel-xe/mkl/mklman/GUID-264E311E-ACED-4D56-AC31-E9D3B11D1CBF.htm.
+
+        Returns
+        -------
+        steady_state : Qobj
+            The steady state density matrix of the system.
+
+        steady_ados : :class:`HierarchyADOsState`
+            The steady state of the full ADO hierarchy. A particular ADO may be
+            extracted from the full state by calling :meth:`.extract`.
+        """
+        if not self.L_sys.isconstant:
+            raise ValueError(
+                "A steady state cannot be determined for a time-dependent"
+                " system"
+            )
+        n = self._sys_shape
+
+        b_mat = np.zeros(n ** 2 * self._n_ados, dtype=complex)
+        b_mat[0] = 1.0
+
+        L = self.rhs(0).data.copy().as_scipy()
+        L = L.tolil()
+        L[0, 0: n ** 2 * self._n_ados] = 0.0
+        L = L.tocsr()
+        L += sp.csr_matrix((
+            np.ones(n),
+            (np.zeros(n), [num * (n + 1) for num in range(n)])
+        ), shape=(n ** 2 * self._n_ados, n ** 2 * self._n_ados))
+
+        if mkl_spsolve is not None and use_mkl:
+            L.sort_indices()
+            solution = mkl_spsolve(
+                L,
+                b_mat,
+                perm=None,
+                verbose=False,
+                max_iter_refine=mkl_max_iter_refine,
+                scaling_vectors=True,
+                weighted_matching=mkl_weighted_matching,
+            )
+        else:
+            L = L.tocsc()
+            solution = spsolve(L, b_mat)
+
+        data = _data.Dense(solution[:n ** 2].reshape((n, n)))
+        data = _data.mul(_data.add(data, data.conj()), 0.5)
+        steady_state = Qobj(data, dims=self._sys_dims)
+
+        solution = solution.reshape((self._n_ados, n, n))
+        steady_ados = HierarchyADOsState(steady_state, self.ados, solution)
+
+        return steady_state, steady_ados
+
+    def run(self, state0, tlist, *, args=None, e_ops=None):
+        """
+        Solve for the time evolution of the system.
+
+        Parameters
+        ----------
+        state0 : :class:`~Qobj` or :class:`~HierarchyADOsState` or array-like
+            If ``rho0`` is a :class:`~Qobj` the it is the initial state
+            of the system (i.e. a :obj:`~Qobj` density matrix).
+
+            If it is a :class:`~HierarchyADOsState` or array-like, then
+            ``rho0`` gives the initial state of all ADOs.
+
+            Usually the state of the ADOs would be determine from a previous
+            call to ``.run(...)`` with the solver results option ``store_ados``
+            set to True. For example, ``result = solver.run(...)`` could be
+            followed by ``solver.run(result.ado_states[-1], tlist)``.
+
+            If a numpy array-like is passed its shape must be
+            ``(number_of_ados, n, n)`` where ``(n, n)`` is the system shape
+            (i.e. shape of the system density matrix) and the ADOs must
+            be in the same order as in ``.ados.labels``.
+
+        tlist : list
+            An ordered list of times at which to return the value of the state.
+
+        args : dict, optional {None}
+            Change the ``args`` of the RHS for the evolution.
+
+        e_ops : Qobj / QobjEvo / callable / list / dict / None, optional
+            A list or dictionary of operators as :class:`~Qobj`,
+            :class:`~QobjEvo` and/or callable functions (they can be mixed) or
+            a single operator or callable function. For an operator ``op``, the
+            result will be computed using ``(state * op).tr()`` and the state
+            at each time ``t``. For callable functions, ``f``, the result is
+            computed using ``f(t, ado_state)``. The values are stored in the
+            ``expect`` and ``e_data`` attributes of the result (see the return
+            section below).
+
+        Returns
+        -------
+        :class:`~HEOMResult`
+            The results of the simulation run, with the following important
+            attributes:
+
+            * ``times``: the times ``t`` (i.e. the ``tlist``).
+
+            * ``states``: the system state at each time ``t`` (only available
+              if ``e_ops`` was ``None`` or if the solver option
+              ``store_states`` was set to ``True``).
+
+            * ``ado_states``: the full ADO state at each time (only available
+              if the results option ``ado_return`` was set to ``True``).
+              Each element is an instance of :class:`HierarchyADOsState`.
+              The state of a particular ADO may be extracted from
+              ``result.ado_states[i]`` by calling :meth:`.extract`.
+
+            * ``expect``: a list containing the values of each ``e_ops`` at
+              time ``t``.
+
+            * ``e_data``: a dictionary containing the values of each ``e_ops``
+              at tme ``t``. The keys are those given by ``e_ops`` if it was
+              a dict, otherwise they are the indexes of the supplied ``e_ops``.
+
+            See :class:`~HEOMResult` and :class:`~Result` for the complete
+            list of attributes.
+        """
+        return super().run(state0, tlist, args=args, e_ops=e_ops)
+
+    def _prepare_state(self, state):
+        n = self._sys_shape
+        rho_dims = self._sys_dims
+        hierarchy_shape = (self._n_ados, n, n)
+
+        rho0 = state
+        ado_init = not isinstance(rho0, Qobj)
+
+        if ado_init:
+            if isinstance(rho0, HierarchyADOsState):
+                rho0_he = rho0._ado_state
+            elif hasattr(rho0, "shape"):  # array-like
+                rho0_he = rho0
+            else:
+                raise TypeError(
+                    f"Initial ADOs passed have type {type(rho0)}"
+                    " but a HierarchyADOsState or a numpy array-like instance"
+                    " was expected"
+                )
+            if rho0_he.shape != hierarchy_shape:
+                raise ValueError(
+                    f"Initial ADOs passed have shape {rho0_he.shape}"
+                    f" but the solver hierarchy shape is {hierarchy_shape}"
+                )
+            rho0_he = rho0_he.reshape(n ** 2 * self._n_ados)
+            rho0_he = _data.create(rho0_he)
+        else:
+            if rho0.dims != rho_dims:
+                raise ValueError(
+                    f"Initial state rho has dims {rho0.dims}"
+                    f" but the system dims are {rho_dims}"
+                )
+            rho0_he = np.zeros([n ** 2 * self._n_ados], dtype=complex)
+            rho0_he[:n ** 2] = rho0.full().ravel('F')
+            rho0_he = _data.create(rho0_he)
+
+        if self.options["state_data_type"]:
+            rho0_he = _data.to(self.options["state_data_type"], rho0_he)
+
+        return rho0_he
+
+    def _restore_state(self, state, *, copy=True):
+        n = self._sys_shape
+        rho_shape = (n, n)
+        rho_dims = self._sys_dims
+        hierarchy_shape = (self._n_ados, n, n)
+
+        rho = Qobj(
+            state.to_array()[:n ** 2].reshape(rho_shape, order='F'),
+            dims=rho_dims,
+        )
+        ado_state = HierarchyADOsState(
+            rho, self.ados, state.to_array().reshape(hierarchy_shape)
+        )
+        return ado_state
+
+    def start(self, state0, t0):
+        """
+        Set the initial state and time for a step evolution.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution. This may provide either just the
+            initial density matrix of the system, or the full set of ADOs
+            for the hierarchy. See the documentation for ``rho0`` in the
+            ``.run(...)`` method for details.
+
+        t0 : double
+            Initial time of the evolution.
+        """
+        super().start(state0, t0)
+
+    @property
+    def options(self):
+        """
+        Options for HEOMSolver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        normalize_output: bool, default=False
+            Normalize output state to hide ODE numerical errors.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error
+            if not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size": 10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        method: str, default="adams"
+            Which ordinary differential equation integration method to use.
+
+        state_data_type: str, default="dense"
+            Name of the data type of the state used during the ODE evolution.
+            Use an empty string to keep the input state type. Many integrators
+            support only work with `Dense`.
+
+        store_ados : bool, default=False
+            Whether or not to store the HEOM ADOs. Only relevant when using
+            the HEOM solver.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Solver.options.fset(self, new_options)
+
+
+class HSolverDL(HEOMSolver):
+    """
+    A helper class for creating an :class:`HEOMSolver` that is backwards
+    compatible with the ``HSolverDL`` provided in ``qutip.nonmarkov.heom``
+    in QuTiP 4.6 and below.
+
+    See :class:`HEOMSolver` and :class:`DrudeLorentzBath` for more
+    descriptions of the underlying solver and bath construction.
+
+    An exact copy of the QuTiP 4.6 HSolverDL is provided in
+    ``qutip.nonmarkov.dlheom_solver`` for cases where the functionality of
+    the older solver is required. The older solver will be completely
+    removed in QuTiP 5.
+
+    .. note::
+
+        Unlike the version of ``HSolverDL`` in QuTiP 4.6, this solver
+        supports supplying a time-dependent or Liouvillian ``H_sys``.
+
+    .. note::
+
+        For compatibility with ``HSolverDL`` in QuTiP 4.6 and below, the
+        parameter ``N_exp`` specifying the number of exponents to keep in
+        the expansion of the bath correlation function is one more than
+        the equivalent ``Nk`` used in the :class:`DrudeLorentzBath`. I.e.,
+        ``Nk = N_exp - 1``. The ``Nk`` parameter in the
+        :class:`DrudeLorentzBath` does not count the zeroeth exponent in
+        order to better match common usage in the literature.
+
+    .. note::
+
+        The ``stats`` and ``renorm`` arguments accepted in QuTiP 4.6 and below
+        are no longer supported.
+
+    Parameters
+    ----------
+    H_sys : Qobj or QobjEvo or list
+        The system Hamiltonian or Liouvillian. See :class:`HEOMSolver` for
+        a complete description.
+
+    coup_op : Qobj
+        Operator describing the coupling between system and bath.
+        See parameter ``Q`` in :class:`BosonicBath` for a complete description.
+
+    coup_strength : float
+        Coupling strength. Referred to as ``lam`` in :class:`DrudeLorentzBath`.
+
+    temperature : float
+        Bath temperature. Referred to as ``T`` in :class:`DrudeLorentzBath`.
+
+    N_cut : int
+        The maximum depth of the hierarchy. See ``max_depth`` in
+        :class:`HEOMSolver` for a full description.
+
+    N_exp : int
+        Number of exponential terms used to approximate the bath correlation
+        functions. The equivalent ``Nk`` in :class:`DrudeLorentzBath` is one
+        less than ``N_exp`` (see note above).
+
+    cut_freq : float
+        Bath spectral density cutoff frequency. Referred to as ``gamma`` in
+        :class:`DrudeLorentzBath`.
+
+    bnd_cut_approx : bool
+        Use boundary cut off approximation. If true, the Matsubara
+        terminator is added to the system Liouvillian (and H_sys is
+        promoted to a Liouvillian if it was a Hamiltonian). Keyword only.
+        Default: False.
+
+    options : dict, optional
+        Generic solver options.
+        If set to None the default options will be used. Keyword only.
+        Default: None.
+
+    combine : bool, default True
+        Whether to combine exponents with the same frequency (and coupling
+        operator). See :meth:`BosonicBath.combine` for details.
+        Keyword only. Default: True.
+    """
+    def __init__(
+        self, H_sys, coup_op, coup_strength, temperature,
+        N_cut, N_exp, cut_freq, *, bnd_cut_approx=False, options=None,
+        combine=True,
+    ):
+        H_sys = QobjEvo(H_sys)
+        bath = DrudeLorentzBath(
+            Q=coup_op,
+            lam=coup_strength,
+            gamma=cut_freq,
+            Nk=N_exp - 1,
+            T=temperature,
+            combine=combine,
+        )
+
+        if bnd_cut_approx:
+            # upgrade H_sys to a Liouvillian if needed and add the
+            # bath terminator
+            if H_sys.type == "oper":  # H_sys is a Hamiltonian
+                H_sys = liouvillian(H_sys)
+            _, terminator = bath.terminator()
+            H_sys = H_sys + terminator
+
+        super().__init__(H_sys, bath=bath, max_depth=N_cut, options=options)
+
+        # store input parameters as attributes for politeness and compatibility
+        # with HSolverDL in QuTiP 4.6 and below.
+        self.coup_strength = coup_strength
+        self.cut_freq = cut_freq
+        self.temperature = temperature
+        self.N_exp = N_exp
+        self.bnd_cut_approx = bnd_cut_approx
+
+
+class _GatherHEOMRHS:
+    """ A class for collecting elements of the right-hand side matrix
+        of the HEOM.
+
+        Parameters
+        ----------
+        f_idx: function(he_state) -> he_idx
+            A function that returns the index of a hierarchy state
+            (i.e. an ADO label).
+        block : int
+            The size of a single ADO Liovillian operator in the hierarchy.
+        nhe : int
+            The number of ADOs in the hierarchy.
+    """
+    def __init__(self, f_idx, block, nhe):
+        self._block_size = block
+        self._n_blocks = nhe
+        self._f_idx = f_idx
+        self._ops = []
+
+    def add_op(self, row_he, col_he, op):
+        """ Add an block operator to the list. """
+        self._ops.append(
+            (self._f_idx(row_he), self._f_idx(col_he), op)
+        )
+
+    def gather(self):
+        """ Create the HEOM liouvillian from a sorted list of smaller sparse
+            matrices.
+
+            .. note::
+
+                The list of operators contains tuples of the form
+                ``(row_idx, col_idx, op)``. The row_idx and col_idx give the
+                *block* row and column for each op. An operator with
+                block indices ``(N, M)`` is placed at position
+                ``[N * block: (N + 1) * block, M * block: (M + 1) * block]``
+                in the output matrix.
+
+            Returns
+            -------
+            rhs : :obj:`Data`
+                A combined matrix of shape ``(block * nhe, block * ne)``.
+        """
+        self._ops.sort()
+        ops = np.array(self._ops, dtype=[
+            ("row", _data.base.idxint_dtype),
+            ("col", _data.base.idxint_dtype),
+            ("op", _data.CSR),
+        ])
+        return _csr._from_csr_blocks(
+            ops["row"], ops["col"], ops["op"],
+            self._n_blocks, self._block_size,
+        )
diff --git a/qutip/solver/integrator/__init__.py b/qutip/solver/integrator/__init__.py
index 8e404a99a3..987cfcd545 100644
--- a/qutip/solver/integrator/__init__.py
+++ b/qutip/solver/integrator/__init__.py
@@ -1,4 +1,4 @@
-from .integrator import *
-from .scipy_integrator import *
-from .qutip_integrator import *
-from .krylov import *
+from .integrator import *
+from .scipy_integrator import *
+from .qutip_integrator import *
+from .krylov import *
diff --git a/qutip/solver/integrator/explicit_rk.pxd b/qutip/solver/integrator/explicit_rk.pxd
index c149c6c01b..46bbcf9712 100644
--- a/qutip/solver/integrator/explicit_rk.pxd
+++ b/qutip/solver/integrator/explicit_rk.pxd
@@ -1,63 +1,63 @@
-#cython: language_level=3
-from qutip.core.data cimport Data
-from qutip.core.cy.qobjevo cimport QobjEvo
-
-cpdef enum Status:
-    AT_FRONT = 2
-    INTERPOLATED = 1
-    NORMAL = 0
-    TOO_MUCH_WORK = -1
-    DT_UNDERFLOW = -2
-    OUTSIDE_RANGE = -3
-    NOT_INITIATED = -4
-
-cdef class Explicit_RungeKutta:
-    cdef QobjEvo qevo
-
-    # Ode state data, set in set_initial_value
-    cdef list k
-    cdef Data _y_temp, _y, _y_prev, _y_front
-    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
-    cdef double _t, _t_prev, _t_front
-    cdef Status _status
-    cdef dict status_messages
-
-    # options: set in init
-    cdef readonly double rtol, atol, first_step, min_step, max_step
-    cdef readonly int max_numsteps
-    cdef readonly bint interpolate
-    cdef readonly object method
-
-    # Runge Kutta tableau and info
-    cdef int rk_step, rk_extra_step, order, denseout_order
-    cdef bint adaptative_step, can_interpolate
-    cdef object b_factor_np
-    cdef double [:] b
-    cdef double [:] b_factor
-    cdef double [:] c
-    cdef double [:] e
-    cdef double [:, ::1] a
-    cdef double [:, ::1] bi
-
-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
-
-    cpdef void set_initial_value(self, Data y0, double t)
-
-    cdef int _step_in_err(self, double t, int max_step)
-
-    cdef double _compute_step(self, double dt)
-
-    cdef double _error(self, Data y_new, double dt)
-
-    cdef void _prep_dense_out(self)
-
-    cdef Data _interpolate_step(self, double t, Data out)
-
-    cdef inline Data _accumulate(self, Data target, double[:] factors,
-                                 double dt, int size)
-
-    cdef double _estimate_first_step(self, double t, Data y0)
-
-    cdef double _get_timestep(self, double t)
-
-    cdef void _recompute_safe_step(self, double err, double dt)
+#cython: language_level=3
+from qutip.core.data cimport Data
+from qutip.core.cy.qobjevo cimport QobjEvo
+
+cpdef enum Status:
+    AT_FRONT = 2
+    INTERPOLATED = 1
+    NORMAL = 0
+    TOO_MUCH_WORK = -1
+    DT_UNDERFLOW = -2
+    OUTSIDE_RANGE = -3
+    NOT_INITIATED = -4
+
+cdef class Explicit_RungeKutta:
+    cdef QobjEvo qevo
+
+    # Ode state data, set in set_initial_value
+    cdef list k
+    cdef Data _y_temp, _y, _y_prev, _y_front
+    cdef double _norm_front, _norm_prev, _dt_safe, _dt_int
+    cdef double _t, _t_prev, _t_front
+    cdef Status _status
+    cdef dict status_messages
+
+    # options: set in init
+    cdef readonly double rtol, atol, first_step, min_step, max_step
+    cdef readonly int max_numsteps
+    cdef readonly bint interpolate
+    cdef readonly object method
+
+    # Runge Kutta tableau and info
+    cdef int rk_step, rk_extra_step, order, denseout_order
+    cdef bint adaptative_step, can_interpolate
+    cdef object b_factor_np
+    cdef double [:] b
+    cdef double [:] b_factor
+    cdef double [:] c
+    cdef double [:] e
+    cdef double [:, ::1] a
+    cdef double [:, ::1] bi
+
+    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
+
+    cpdef void set_initial_value(self, Data y0, double t)
+
+    cdef int _step_in_err(self, double t, int max_step)
+
+    cdef double _compute_step(self, double dt)
+
+    cdef double _error(self, Data y_new, double dt)
+
+    cdef void _prep_dense_out(self)
+
+    cdef Data _interpolate_step(self, double t, Data out)
+
+    cdef inline Data _accumulate(self, Data target, double[:] factors,
+                                 double dt, int size)
+
+    cdef double _estimate_first_step(self, double t, Data y0)
+
+    cdef double _get_timestep(self, double t)
+
+    cdef void _recompute_safe_step(self, double err, double dt)
diff --git a/qutip/solver/integrator/explicit_rk.pyx b/qutip/solver/integrator/explicit_rk.pyx
index 37dd384df5..17220ea25a 100644
--- a/qutip/solver/integrator/explicit_rk.pyx
+++ b/qutip/solver/integrator/explicit_rk.pyx
@@ -1,510 +1,510 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
-"""
-Provide a cython implimentation for a general Explicit runge-Kutta method.
-"""
-from qutip.core.data cimport Data, Dense, CSR, dense
-from qutip.core.data.add cimport iadd_dense
-from qutip.core.data.add import add
-from qutip.core.data.mul import imul_data
-from qutip.core.data.tidyup import tidyup_csr
-from qutip.core.data.norm import frobenius_data
-from .verner7efficient import vern7_coeff
-from .verner9efficient import vern9_coeff
-cimport cython
-import numpy as np
-
-euler_coeff = {
-    'order': 1,
-    'a': np.array([[0.]], dtype=np.float64),
-    'b': np.array([1.], dtype=np.float64),
-    'c': np.array([0.], dtype=np.float64)
-}
-
-rk4_coeff = {
-    'order': 4,
-    'a': np.array([[0., 0., 0., 0.],
-                   [.5, 0., 0., 0.],
-                   [0., .5, 0., 0.],
-                   [0., 0., 1., 0.]], dtype=np.float64),
-    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
-    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
-}
-
-
-cdef Data copy_to(Data in_, Data out):
-    # Copy while reusing allocated buffer if possible.
-    # Does not check the shape, etc.
-    cdef size_t ptr
-    if type(in_) is Dense:
-        for ptr in range(in_.shape[0] * in_.shape[1]):
-            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
-        return out
-    else:
-        return in_.copy()
-
-
-cdef Data iadd_data(Data left, Data right, double complex factor):
-    # left += right * factor
-    # reusing `left' allocated buffer if possible.
-    # TODO: when/if iadd_csr is added: move to data/add.pyx.
-    if factor == 0:
-        return left
-    if type(left) is Dense:
-        iadd_dense(left, right, factor)
-        return left
-    else:
-        return add(left, right, factor)
-
-
-cdef class Explicit_RungeKutta:
-    """
-    Qutip implementation of Runge Kutta ODE.
-    Works in :class:`Data` allowing solving using sparse and gpu data.
-
-    Parameters
-    ----------
-    qevo : QobjEvo
-        The system to integrate: ```dX = qevo.matmul_data(t, X)``
-
-    rtol, atol : double
-        Relative and absolute tolerance of the integration error respectively.
-
-    nsteps : int
-        Maximum number of steps done during one call of integrate.
-
-    first_step : double
-        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
-        be determined automaticaly.
-
-    min_step, max_step : double
-        Bounds of the step lenght in ``t``. ``0`` means no bounds.
-
-    interpolate : bool
-        Whether to do longer step and interpolate back when the method support
-        it.
-        Example:
-            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
-            safely integrate up to ``t=3``. If ``interpolate=True``, it will
-            integrate up to ``t=3`` and then use interpolation to get the state
-            at ``t=2``. With ``interpolate=False``, it will integrate to
-            ``t=2``.
-
-    method : ['euler', 'rk4', 'vern7', 'vern9']
-        The integration method to use.
-        * It also accept a tuple of runge-kutta coefficients.
-        (See `Explicit_RungeKutta._init_coeff`)
-    """
-    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
-                 int nsteps=1000, double first_step=0, double min_step=0,
-                 double max_step=0, bint interpolate=True, method="euler"):
-        # Function to integrate.
-        self.qevo = qevo
-        # tolerances
-        self.atol = atol
-        self.rtol = rtol
-        self._dt_safe = atol
-        # Number of step to do before giving up
-        self.max_numsteps = nsteps
-
-        # contrain on the step times
-        self.first_step = first_step
-        self.min_step = min_step or 1e-15
-        self.max_step = max_step
-
-        # If True, will do the steps longer that the target and use
-        # interpolation to get the state at the wanted time.
-        self.interpolate = interpolate
-
-        self.k = []
-        if isinstance(method, dict):
-            self._init_coeff(**method)
-        elif "vern7" == method:
-            self._init_coeff(**vern7_coeff)
-        elif "vern9" == method:
-            self._init_coeff(**vern9_coeff)
-        elif "rk4" == method:
-            self._init_coeff(**rk4_coeff)
-        else:
-            self._init_coeff(**euler_coeff)
-        self.method = method
-        self._y_prev = None
-
-    def _init_coeff(self, order, a, b, c, e=None, bi=None):
-        """
-        Read the Butcher tableau.
-
-        Parameters
-        ----------
-        order : int
-            Order of the method
-
-        a, b, c : numpy.ndarray
-            The Butcher tableau:
-            c_0 | a_00 a_01
-            c_1 | a_10 a_11
-            ---------------
-                  b_0  b_1
-            The ``c`` vector should start with `0` and the first line of ``a``
-            is also expected to be zeros.
-            The ``a`` and ``c`` part of the tableau can be larger than the
-            number of step if dense output is available.
-
-        e : numpy.ndarray (optional)
-            The error coefficients. If given, adaptative step length will be
-            used to stay within the given tolerance.
-            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
-
-        bi : numpy.ndarray (optional)
-            The coefficients for the dense output.
-            The dense output is computed as:
-                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
-            with ``k[i]`` the derivative computed from ``a`` and ``c``.
-        """
-        self.order = order
-        self.rk_step = b.shape[0]
-        self.rk_extra_step = c.shape[0]
-        if (
-            self.rk_step > self.rk_extra_step or
-            a.shape[1] != self.rk_extra_step or
-            a.shape[0] != self.rk_extra_step
-        ):
-            raise ValueError("Inconsistant shape between the Butcher tableau "
-                             "parts.")
-
-        self.adaptative_step = e is not None
-        if self.adaptative_step and e.shape[0] != self.rk_step:
-            raise ValueError("The length of the error coefficients must be the"
-                             " same as the number of steps in the Butcher "
-                             f"tableau. Got {e.shape[0]} but expected "
-                             f"{self.rk_step}")
-
-        self.interpolate = bi is not None and self.interpolate
-        if self.interpolate:
-            self.denseout_order = bi.shape[1]
-            if bi.shape[0] != self.rk_extra_step:
-                raise ValueError("The interpolation coefficient's shape must "
-                                 "be (a.shape[0], dense output order)")
-
-        self.a = a
-        self.b = b
-        self.c = c
-        self.e = e
-        self.bi = bi
-        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
-        self.b_factor = self.b_factor_np
-
-    cpdef void set_initial_value(self, Data y0, double t):
-        """
-        Set the initial state and time of the integration.
-        """
-        self._t = t
-        self._t_prev = t
-        self._t_front = t
-        self._dt_int = 0
-        self._y = y0
-        self._norm_prev = frobenius_data(self._y)
-        self._norm_front = self._norm_prev
-
-        #prepare the buffers
-        for i in range(self.rk_extra_step):
-            self.k.append(self._y.copy())
-        self._y_temp = self._y.copy()
-        self._y_front = self._y.copy()
-        self._y_prev = self._y.copy()
-
-        if not self.first_step:
-            self._dt_safe = self._estimate_first_step(t, self._y)
-        else:
-            self._dt_safe = self.first_step
-
-    cdef double _estimate_first_step(self, double t, Data y0):
-        if not self.adaptative_step:
-            return 0.
-
-        cdef double dt1, dt2, dt, factorial = 1, t1
-        cdef double norm = frobenius_data(y0), tmp_norm
-        cdef double tol = self.atol + norm * self.rtol
-        cdef int i
-        self.k[0] = imul_data(<Data> self.k[0], 0)
-        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
-
-        # Ok approximation for linear system. But not in a general case.
-        if norm <= self.atol:
-            norm = 1
-        tmp_norm = frobenius_data(<Data> self.k[0])
-        for i in range(1, self.order+1):
-            factorial *= i
-        if tmp_norm >= (self.atol * 1e-6):
-            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
-                   / tmp_norm)
-        else:
-            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
-
-        t1 = t + dt1 / 100
-        self._y_temp = copy_to(y0, self._y_temp)
-        # below dt1 / 100 is an arbitrary small fraction of dt1:
-        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
-        self.k[1] = imul_data(<Data> self.k[1], 0)
-        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
-        tmp_norm = frobenius_data(<Data> self.k[1])
-        if tmp_norm >= (self.atol * 1e-6):
-            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
-                   / tmp_norm)
-        else:
-            dt2 = dt1
-
-        dt = min(dt1, dt2)
-        if self.max_step:
-            dt = min(self.max_step, dt)
-        if self.min_step:
-            dt = max(self.min_step, dt)
-        return dt
-
-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
-        """
-        Do the integration to t.
-        If ``step`` is True, it will make a maximum 1 step and may not reach
-        ``t``.
-        """
-        cdef int nsteps_left = self.max_numsteps
-        cdef double err = 0
-
-        if self._y_prev is None:
-            self._status = Status.NOT_INITIATED
-            return
-
-        self._status = Status.NORMAL
-
-        if t == self._t:
-            return
-
-        if t < self._t_prev:
-            self._status = Status.OUTSIDE_RANGE
-            return
-
-        if self.interpolate and t < self._t_front:
-             self._y = self._interpolate_step(t, self._y)
-             self._t = t
-
-        if step and self._t < self._t_front and t > self._t_front:
-            # To ensure that the self._t ... t_out interval can be covered.
-            t = self._t_front
-
-        while self._t_front < t:
-            self._y_prev = copy_to(self._y_front, self._y_prev)
-            self._t_prev = self._t_front
-            self._norm_prev = self._norm_front
-            nsteps_left -= self._step_in_err(t, nsteps_left)
-            if step:
-                break
-
-        if self._status < 0:
-            return
-
-        if self._t_front > t:
-            self._prep_dense_out()
-            self._status = Status.INTERPOLATED
-            self._t = t
-            self._y = self._interpolate_step(t, self._y)
-        else:
-            self._status = Status.AT_FRONT
-            self._t = self._t_front
-            self._y = copy_to(self._y_front, self._y)
-
-    cdef int _step_in_err(self, double t, int max_step):
-        """
-        Do compute one step, repeating until the error is within tolerance.
-        """
-        cdef double error = 1
-        cdef int nsteps = 0
-        while error >= 1:
-            dt = self._get_timestep(t)
-            error = self._compute_step(dt)
-            self._dt_int = dt
-            self._recompute_safe_step(error, dt)
-
-            if dt == self.min_step and error > 1:
-                # The tolerance was not reached but the dt is at the minimum.
-                self._status = Status.DT_UNDERFLOW
-                break
-            nsteps += 1
-            if nsteps > max_step:
-                self._status = Status.TOO_MUCH_WORK
-                break
-        return nsteps
-
-    cdef double _compute_step(self, double dt):
-        """
-        Do compute one step with fixed ``dt``, return the error.
-        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
-        """
-        cdef int i
-        for i in range(self.rk_step):
-            self.k[i] = imul_data(<Data> self.k[i], 0.)
-
-        # Compute the derivatives
-        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
-                                          <Data> self.k[0])
-        for i in range(1, self.rk_step):
-            self._y_temp = copy_to(self._y_prev, self._y_temp)
-            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
-            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
-                                              self._y_temp, <Data> self.k[i])
-
-        # Compute the state
-        self._y_front = copy_to(self._y_prev, self._y_front)
-        self._y_front = self._accumulate(self._y_front, self.b, dt,
-                                         self.rk_step)
-        self._t_front = self._t_prev + dt
-
-        if type(self._y_front) is CSR:
-            # issparse() test would be better.
-            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
-
-        return self._error(self._y_front, dt)
-
-    cdef double _error(self, Data y_new, double dt):
-        """ Compute the normalized error. (error/tol) """
-        if not self.adaptative_step:
-            return 0.
-        self._y_temp = imul_data(self._y_temp, 0.)
-        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
-        self._norm_front = frobenius_data(y_new)
-        return frobenius_data(self._y_temp) / (self.atol +
-                max(self._norm_prev, self._norm_front) * self.rtol)
-
-    cdef void _prep_dense_out(self):
-        """
-        Compute derivative for the interpolation step.
-        """
-        cdef double dt = self._dt_int
-
-        for i in range(self.rk_step, self.rk_extra_step):
-            self.k[i] = imul_data(<Data> self.k[i], 0.)
-            self._y_temp = copy_to(self._y_prev, self._y_temp)
-            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
-            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
-                                              self._y_temp, <Data> self.k[i])
-
-    cdef Data _interpolate_step(self, double t, Data out):
-        """
-        Compute the state at any points between _t_prev and _t_front
-        with an error of ~dt**denseout_order.
-        """
-        cdef:
-            int i, j
-            double t0 = self._t_prev
-            double dt = self._dt_int
-            double tau = (t - t0) / dt
-        for i in range(self.rk_extra_step):
-            self.b_factor[i] = 0.
-            for j in range(self.denseout_order-1, -1, -1):
-                self.b_factor[i] += self.bi[i,j]
-                self.b_factor[i] *= tau
-
-        out = copy_to(self._y_prev, out)
-        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
-        return out
-
-    cdef inline Data _accumulate(self, Data target, double[:] factors,
-                         double dt, int size):
-        cdef int i
-        for i in range(size):
-            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
-        return target
-
-    @cython.cdivision(True)
-    cdef double _get_timestep(self, double t):
-        """ Get the dt for the step. """
-        cdef double dt_needed = t - self._t_front
-        if not self.adaptative_step:
-            return dt_needed
-        if self.interpolate:
-            return self._dt_safe
-        if dt_needed <= self._dt_safe:
-            return dt_needed
-        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
-
-    cdef void _recompute_safe_step(self, double err, double dt):
-        """ Get maximum safe step in function of the error."""
-        cdef double factor
-        if not self.adaptative_step:
-            return
-        elif err == 0:
-            factor = 10
-        else:
-            factor = 0.9*err**(-1/(self.order+1))
-            factor = min(10, factor)
-            factor = max(0.2, factor)
-
-        self._dt_safe = dt * factor
-        if self.max_step:
-            self._dt_safe = min(self.max_step, self._dt_safe)
-        if self.min_step:
-            self._dt_safe = max(self.min_step, self._dt_safe)
-
-    def successful(self):
-        return self._status >= 0
-
-    @property
-    def status(self):
-        return self._status
-
-    def status_message(self):
-        "Status of the last step in a human readable format."
-        return {
-            AT_FRONT: "Internal state at the desired time.",
-            INTERPOLATED: (
-                "Internal state past the desired time and "
-                "interpolation to step done."),
-            NORMAL: 'No work done.',
-            TOO_MUCH_WORK: (
-                'Too much work done in one call. Try to increase '
-                'the nsteps parameter or increasing the tolerance.'
-            ),
-            DT_UNDERFLOW:
-                'Step size becomes too small. Try increasing tolerance.',
-            OUTSIDE_RANGE: 'Step outside available range.',
-            NOT_INITIATED: 'Not initialized.'
-        }[self._status]
-
-    @property
-    def y(self):
-        return self._y
-
-    @property
-    def y_prev(self):
-        return self._y_prev
-
-    @property
-    def y_front(self):
-        return self._y_front
-
-    @property
-    def t_front(self):
-        return self._t_front
-
-    @property
-    def t_prev(self):
-        return self._t_prev
-
-    @property
-    def t(self):
-        return self._t
-
-    def _debug_state(self):
-        print("t, y: ", self._t,
-              'None' if self._y is None else self._y.to_array())
-        print("t_prev, y_prev, |y_prev|", self._t_prev,
-              'None' if self._y_prev is None else self._y_prev.to_array(),
-              self._norm_prev)
-        print("t_front, y_front, |y_front|", self._t_front,
-              'None' if self._y_front is None else self._y_front.to_array(),
-              self._norm_front)
-        print("y_temp",
-              'None' if self._y_temp is None else self._y_temp.to_array())
-        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
-        for i in range(self.rk_extra_step):
-            print(f'k[{i}]',
-                  'None' if self.k[i] is None else self.k[i].to_array())
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False, nonecheck=False
+"""
+Provide a cython implimentation for a general Explicit runge-Kutta method.
+"""
+from qutip.core.data cimport Data, Dense, CSR, dense
+from qutip.core.data.add cimport iadd_dense
+from qutip.core.data.add import add
+from qutip.core.data.mul import imul_data
+from qutip.core.data.tidyup import tidyup_csr
+from qutip.core.data.norm import frobenius_data
+from .verner7efficient import vern7_coeff
+from .verner9efficient import vern9_coeff
+cimport cython
+import numpy as np
+
+euler_coeff = {
+    'order': 1,
+    'a': np.array([[0.]], dtype=np.float64),
+    'b': np.array([1.], dtype=np.float64),
+    'c': np.array([0.], dtype=np.float64)
+}
+
+rk4_coeff = {
+    'order': 4,
+    'a': np.array([[0., 0., 0., 0.],
+                   [.5, 0., 0., 0.],
+                   [0., .5, 0., 0.],
+                   [0., 0., 1., 0.]], dtype=np.float64),
+    'b': np.array([1/6, 1/3, 1/3, 1/6], dtype=np.float64),
+    'c': np.array([0., 0.5, 0.5, 1.0], dtype=np.float64)
+}
+
+
+cdef Data copy_to(Data in_, Data out):
+    # Copy while reusing allocated buffer if possible.
+    # Does not check the shape, etc.
+    cdef size_t ptr
+    if type(in_) is Dense:
+        for ptr in range(in_.shape[0] * in_.shape[1]):
+            (<Dense> out).data[ptr] = (<Dense> in_).data[ptr]
+        return out
+    else:
+        return in_.copy()
+
+
+cdef Data iadd_data(Data left, Data right, double complex factor):
+    # left += right * factor
+    # reusing `left' allocated buffer if possible.
+    # TODO: when/if iadd_csr is added: move to data/add.pyx.
+    if factor == 0:
+        return left
+    if type(left) is Dense:
+        iadd_dense(left, right, factor)
+        return left
+    else:
+        return add(left, right, factor)
+
+
+cdef class Explicit_RungeKutta:
+    """
+    Qutip implementation of Runge Kutta ODE.
+    Works in :class:`Data` allowing solving using sparse and gpu data.
+
+    Parameters
+    ----------
+    qevo : QobjEvo
+        The system to integrate: ```dX = qevo.matmul_data(t, X)``
+
+    rtol, atol : double
+        Relative and absolute tolerance of the integration error respectively.
+
+    nsteps : int
+        Maximum number of steps done during one call of integrate.
+
+    first_step : double
+        Lenght in ``t`` of the first step. If ``0``, an appropriate step will
+        be determined automaticaly.
+
+    min_step, max_step : double
+        Bounds of the step lenght in ``t``. ``0`` means no bounds.
+
+    interpolate : bool
+        Whether to do longer step and interpolate back when the method support
+        it.
+        Example:
+            At ``t=1``, the integrator is asked to integrate to ``t=2`` but can
+            safely integrate up to ``t=3``. If ``interpolate=True``, it will
+            integrate up to ``t=3`` and then use interpolation to get the state
+            at ``t=2``. With ``interpolate=False``, it will integrate to
+            ``t=2``.
+
+    method : ['euler', 'rk4', 'vern7', 'vern9']
+        The integration method to use.
+        * It also accept a tuple of runge-kutta coefficients.
+        (See `Explicit_RungeKutta._init_coeff`)
+    """
+    def __init__(self, QobjEvo qevo, double rtol=1e-6, double atol=1e-8,
+                 int nsteps=1000, double first_step=0, double min_step=0,
+                 double max_step=0, bint interpolate=True, method="euler"):
+        # Function to integrate.
+        self.qevo = qevo
+        # tolerances
+        self.atol = atol
+        self.rtol = rtol
+        self._dt_safe = atol
+        # Number of step to do before giving up
+        self.max_numsteps = nsteps
+
+        # contrain on the step times
+        self.first_step = first_step
+        self.min_step = min_step or 1e-15
+        self.max_step = max_step
+
+        # If True, will do the steps longer that the target and use
+        # interpolation to get the state at the wanted time.
+        self.interpolate = interpolate
+
+        self.k = []
+        if isinstance(method, dict):
+            self._init_coeff(**method)
+        elif "vern7" == method:
+            self._init_coeff(**vern7_coeff)
+        elif "vern9" == method:
+            self._init_coeff(**vern9_coeff)
+        elif "rk4" == method:
+            self._init_coeff(**rk4_coeff)
+        else:
+            self._init_coeff(**euler_coeff)
+        self.method = method
+        self._y_prev = None
+
+    def _init_coeff(self, order, a, b, c, e=None, bi=None):
+        """
+        Read the Butcher tableau.
+
+        Parameters
+        ----------
+        order : int
+            Order of the method
+
+        a, b, c : numpy.ndarray
+            The Butcher tableau:
+            c_0 | a_00 a_01
+            c_1 | a_10 a_11
+            ---------------
+                  b_0  b_1
+            The ``c`` vector should start with `0` and the first line of ``a``
+            is also expected to be zeros.
+            The ``a`` and ``c`` part of the tableau can be larger than the
+            number of step if dense output is available.
+
+        e : numpy.ndarray (optional)
+            The error coefficients. If given, adaptative step length will be
+            used to stay within the given tolerance.
+            In some notation 2 sets of b are given, then ``e_i = b_i - b*_i``
+
+        bi : numpy.ndarray (optional)
+            The coefficients for the dense output.
+            The dense output is computed as:
+                ``k[i] * bi[i,j] * ((t-t0) / (t'-t0))**j``
+            with ``k[i]`` the derivative computed from ``a`` and ``c``.
+        """
+        self.order = order
+        self.rk_step = b.shape[0]
+        self.rk_extra_step = c.shape[0]
+        if (
+            self.rk_step > self.rk_extra_step or
+            a.shape[1] != self.rk_extra_step or
+            a.shape[0] != self.rk_extra_step
+        ):
+            raise ValueError("Inconsistant shape between the Butcher tableau "
+                             "parts.")
+
+        self.adaptative_step = e is not None
+        if self.adaptative_step and e.shape[0] != self.rk_step:
+            raise ValueError("The length of the error coefficients must be the"
+                             " same as the number of steps in the Butcher "
+                             f"tableau. Got {e.shape[0]} but expected "
+                             f"{self.rk_step}")
+
+        self.interpolate = bi is not None and self.interpolate
+        if self.interpolate:
+            self.denseout_order = bi.shape[1]
+            if bi.shape[0] != self.rk_extra_step:
+                raise ValueError("The interpolation coefficient's shape must "
+                                 "be (a.shape[0], dense output order)")
+
+        self.a = a
+        self.b = b
+        self.c = c
+        self.e = e
+        self.bi = bi
+        self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
+        self.b_factor = self.b_factor_np
+
+    cpdef void set_initial_value(self, Data y0, double t):
+        """
+        Set the initial state and time of the integration.
+        """
+        self._t = t
+        self._t_prev = t
+        self._t_front = t
+        self._dt_int = 0
+        self._y = y0
+        self._norm_prev = frobenius_data(self._y)
+        self._norm_front = self._norm_prev
+
+        #prepare the buffers
+        for i in range(self.rk_extra_step):
+            self.k.append(self._y.copy())
+        self._y_temp = self._y.copy()
+        self._y_front = self._y.copy()
+        self._y_prev = self._y.copy()
+
+        if not self.first_step:
+            self._dt_safe = self._estimate_first_step(t, self._y)
+        else:
+            self._dt_safe = self.first_step
+
+    cdef double _estimate_first_step(self, double t, Data y0):
+        if not self.adaptative_step:
+            return 0.
+
+        cdef double dt1, dt2, dt, factorial = 1, t1
+        cdef double norm = frobenius_data(y0), tmp_norm
+        cdef double tol = self.atol + norm * self.rtol
+        cdef int i
+        self.k[0] = imul_data(<Data> self.k[0], 0)
+        self.k[0] = self.qevo.matmul_data(t, y0, <Data> self.k[0])
+
+        # Ok approximation for linear system. But not in a general case.
+        if norm <= self.atol:
+            norm = 1
+        tmp_norm = frobenius_data(<Data> self.k[0])
+        for i in range(1, self.order+1):
+            factorial *= i
+        if tmp_norm >= (self.atol * 1e-6):
+            dt1 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
+                   / tmp_norm)
+        else:
+            dt1 = (tol * factorial)**(1 / (self.order+1)) * norm * 0.5
+
+        t1 = t + dt1 / 100
+        self._y_temp = copy_to(y0, self._y_temp)
+        # below dt1 / 100 is an arbitrary small fraction of dt1:
+        self._y_temp = iadd_data(self._y_temp, <Data> self.k[0], dt1 / 100)
+        self.k[1] = imul_data(<Data> self.k[1], 0)
+        self.k[1] = self.qevo.matmul_data(t1, self._y_temp, <Data> self.k[1])
+        tmp_norm = frobenius_data(<Data> self.k[1])
+        if tmp_norm >= (self.atol * 1e-6):
+            dt2 = ((tol * factorial * norm**self.order)**(1 / (self.order+1))
+                   / tmp_norm)
+        else:
+            dt2 = dt1
+
+        dt = min(dt1, dt2)
+        if self.max_step:
+            dt = min(self.max_step, dt)
+        if self.min_step:
+            dt = max(self.min_step, dt)
+        return dt
+
+    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
+        """
+        Do the integration to t.
+        If ``step`` is True, it will make a maximum 1 step and may not reach
+        ``t``.
+        """
+        cdef int nsteps_left = self.max_numsteps
+        cdef double err = 0
+
+        if self._y_prev is None:
+            self._status = Status.NOT_INITIATED
+            return
+
+        self._status = Status.NORMAL
+
+        if t == self._t:
+            return
+
+        if t < self._t_prev:
+            self._status = Status.OUTSIDE_RANGE
+            return
+
+        if self.interpolate and t < self._t_front:
+             self._y = self._interpolate_step(t, self._y)
+             self._t = t
+
+        if step and self._t < self._t_front and t > self._t_front:
+            # To ensure that the self._t ... t_out interval can be covered.
+            t = self._t_front
+
+        while self._t_front < t:
+            self._y_prev = copy_to(self._y_front, self._y_prev)
+            self._t_prev = self._t_front
+            self._norm_prev = self._norm_front
+            nsteps_left -= self._step_in_err(t, nsteps_left)
+            if step:
+                break
+
+        if self._status < 0:
+            return
+
+        if self._t_front > t:
+            self._prep_dense_out()
+            self._status = Status.INTERPOLATED
+            self._t = t
+            self._y = self._interpolate_step(t, self._y)
+        else:
+            self._status = Status.AT_FRONT
+            self._t = self._t_front
+            self._y = copy_to(self._y_front, self._y)
+
+    cdef int _step_in_err(self, double t, int max_step):
+        """
+        Do compute one step, repeating until the error is within tolerance.
+        """
+        cdef double error = 1
+        cdef int nsteps = 0
+        while error >= 1:
+            dt = self._get_timestep(t)
+            error = self._compute_step(dt)
+            self._dt_int = dt
+            self._recompute_safe_step(error, dt)
+
+            if dt == self.min_step and error > 1:
+                # The tolerance was not reached but the dt is at the minimum.
+                self._status = Status.DT_UNDERFLOW
+                break
+            nsteps += 1
+            if nsteps > max_step:
+                self._status = Status.TOO_MUCH_WORK
+                break
+        return nsteps
+
+    cdef double _compute_step(self, double dt):
+        """
+        Do compute one step with fixed ``dt``, return the error.
+        Use (_t_prev, _y_prev) to create (_t_front, _y_front)
+        """
+        cdef int i
+        for i in range(self.rk_step):
+            self.k[i] = imul_data(<Data> self.k[i], 0.)
+
+        # Compute the derivatives
+        self.k[0] = self.qevo.matmul_data(self._t_prev, self._y_prev,
+                                          <Data> self.k[0])
+        for i in range(1, self.rk_step):
+            self._y_temp = copy_to(self._y_prev, self._y_temp)
+            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
+            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
+                                              self._y_temp, <Data> self.k[i])
+
+        # Compute the state
+        self._y_front = copy_to(self._y_prev, self._y_front)
+        self._y_front = self._accumulate(self._y_front, self.b, dt,
+                                         self.rk_step)
+        self._t_front = self._t_prev + dt
+
+        if type(self._y_front) is CSR:
+            # issparse() test would be better.
+            tidyup_csr(self._y_front, self.atol/self._y_front.shape[0], True)
+
+        return self._error(self._y_front, dt)
+
+    cdef double _error(self, Data y_new, double dt):
+        """ Compute the normalized error. (error/tol) """
+        if not self.adaptative_step:
+            return 0.
+        self._y_temp = imul_data(self._y_temp, 0.)
+        self._y_temp = self._accumulate(self._y_temp, self.e, dt, self.rk_step)
+        self._norm_front = frobenius_data(y_new)
+        return frobenius_data(self._y_temp) / (self.atol +
+                max(self._norm_prev, self._norm_front) * self.rtol)
+
+    cdef void _prep_dense_out(self):
+        """
+        Compute derivative for the interpolation step.
+        """
+        cdef double dt = self._dt_int
+
+        for i in range(self.rk_step, self.rk_extra_step):
+            self.k[i] = imul_data(<Data> self.k[i], 0.)
+            self._y_temp = copy_to(self._y_prev, self._y_temp)
+            self._y_temp = self._accumulate(self._y_temp, self.a[i,:], dt, i)
+            self.k[i] = self.qevo.matmul_data(self._t_prev + self.c[i]*dt,
+                                              self._y_temp, <Data> self.k[i])
+
+    cdef Data _interpolate_step(self, double t, Data out):
+        """
+        Compute the state at any points between _t_prev and _t_front
+        with an error of ~dt**denseout_order.
+        """
+        cdef:
+            int i, j
+            double t0 = self._t_prev
+            double dt = self._dt_int
+            double tau = (t - t0) / dt
+        for i in range(self.rk_extra_step):
+            self.b_factor[i] = 0.
+            for j in range(self.denseout_order-1, -1, -1):
+                self.b_factor[i] += self.bi[i,j]
+                self.b_factor[i] *= tau
+
+        out = copy_to(self._y_prev, out)
+        out = self._accumulate(out, self.b_factor, dt, self.rk_extra_step)
+        return out
+
+    cdef inline Data _accumulate(self, Data target, double[:] factors,
+                         double dt, int size):
+        cdef int i
+        for i in range(size):
+            target = iadd_data(target, <Data> self.k[i], dt * factors[i])
+        return target
+
+    @cython.cdivision(True)
+    cdef double _get_timestep(self, double t):
+        """ Get the dt for the step. """
+        cdef double dt_needed = t - self._t_front
+        if not self.adaptative_step:
+            return dt_needed
+        if self.interpolate:
+            return self._dt_safe
+        if dt_needed <= self._dt_safe:
+            return dt_needed
+        return dt_needed / (int(dt_needed / self._dt_safe) + 1)
+
+    cdef void _recompute_safe_step(self, double err, double dt):
+        """ Get maximum safe step in function of the error."""
+        cdef double factor
+        if not self.adaptative_step:
+            return
+        elif err == 0:
+            factor = 10
+        else:
+            factor = 0.9*err**(-1/(self.order+1))
+            factor = min(10, factor)
+            factor = max(0.2, factor)
+
+        self._dt_safe = dt * factor
+        if self.max_step:
+            self._dt_safe = min(self.max_step, self._dt_safe)
+        if self.min_step:
+            self._dt_safe = max(self.min_step, self._dt_safe)
+
+    def successful(self):
+        return self._status >= 0
+
+    @property
+    def status(self):
+        return self._status
+
+    def status_message(self):
+        "Status of the last step in a human readable format."
+        return {
+            AT_FRONT: "Internal state at the desired time.",
+            INTERPOLATED: (
+                "Internal state past the desired time and "
+                "interpolation to step done."),
+            NORMAL: 'No work done.',
+            TOO_MUCH_WORK: (
+                'Too much work done in one call. Try to increase '
+                'the nsteps parameter or increasing the tolerance.'
+            ),
+            DT_UNDERFLOW:
+                'Step size becomes too small. Try increasing tolerance.',
+            OUTSIDE_RANGE: 'Step outside available range.',
+            NOT_INITIATED: 'Not initialized.'
+        }[self._status]
+
+    @property
+    def y(self):
+        return self._y
+
+    @property
+    def y_prev(self):
+        return self._y_prev
+
+    @property
+    def y_front(self):
+        return self._y_front
+
+    @property
+    def t_front(self):
+        return self._t_front
+
+    @property
+    def t_prev(self):
+        return self._t_prev
+
+    @property
+    def t(self):
+        return self._t
+
+    def _debug_state(self):
+        print("t, y: ", self._t,
+              'None' if self._y is None else self._y.to_array())
+        print("t_prev, y_prev, |y_prev|", self._t_prev,
+              'None' if self._y_prev is None else self._y_prev.to_array(),
+              self._norm_prev)
+        print("t_front, y_front, |y_front|", self._t_front,
+              'None' if self._y_front is None else self._y_front.to_array(),
+              self._norm_front)
+        print("y_temp",
+              'None' if self._y_temp is None else self._y_temp.to_array())
+        print("dt_safe: ", self._dt_safe, "dt_int: ", self._dt_int)
+        for i in range(self.rk_extra_step):
+            print(f'k[{i}]',
+                  'None' if self.k[i] is None else self.k[i].to_array())
diff --git a/qutip/solver/integrator/integrator.py b/qutip/solver/integrator/integrator.py
index 4268621f01..44df5546f1 100644
--- a/qutip/solver/integrator/integrator.py
+++ b/qutip/solver/integrator/integrator.py
@@ -1,240 +1,240 @@
-""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
-import numpy as np
-
-__all__ = ['Integrator', 'IntegratorException']
-
-
-class IntegratorException(Exception):
-    """Error from the ODE solver being unable to integrate with the given
-    parameters.
-
-    Example
-    -------
-    - The solver cannot reach the desired tolerance within the maximum number
-    of steps.
-    - The step needed to be within desired tolerance is too small.
-    """
-
-
-class Integrator:
-    """
-    A wrapper around ODE solvers.
-    It ensures a common interface for Solver usage.
-    It takes and return states as :class:`qutip.core.data.Data`, it may return
-    a different data-type than the input type.
-
-    Parameters
-    ----------
-    system: qutip.QobjEvo
-        Quantum system in which states evolve.
-
-    options: dict
-        Options for the integrator.
-
-    Class Attributes
-    ----------------
-    name : str
-        The name of the integrator.
-
-    supports_blackbox : bool
-        If True, then the integrator calls only ``system.matmul``,
-        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
-        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
-        the integrator to modify the system in creative ways. In particular,
-        the solver may modify the system depending on *both* the time ``t``
-        *and* the current ``state`` the system is being applied to.
-
-        If the integrator calls any other methods, set to False.
-
-    supports_time_dependent : bool
-        If True, then the integrator supports time dependent systems. If False,
-        ``supports_blackbox`` should usually be ``False`` too.
-
-    integrator_options : dict
-        A dictionary of options used by the integrator and their default
-        values. Once initiated, ``self.options`` will be a dict with the same
-        keys, not the full options object passed to the solver. Options' keys
-        included here will be supported by the :cls:SolverOdeOptions.
-    """
-    # Dict of used options and their default values
-    integrator_options = {}
-    _options = None
-    # Can evolve time dependent system
-    support_time_dependant = None
-    # Whether the integrator used the system QobjEvo as a blackbox
-    supports_blackbox = None
-    # The name of the integrator
-    name = None
-    method = ""
-
-    def __init__(self, system, options):
-        self.system = system
-        self._is_set = False  # get_state can be used and return a valid state.
-        self._back = (np.inf, None)
-        self._options = self.integrator_options.copy()
-        self.options = options
-        self._prepare()
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        It should also set the name of the solver to be displayed in Result.
-        """
-        raise NotImplementedError
-
-    def set_state(self, t, state0):
-        """
-        Set the state of the ODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        .. note:
-            It should set the flags `_is_set` to True.
-        """
-        raise NotImplementedError
-
-    def integrate(self, t, copy=True):
-        """
-        Evolve to t.
-
-        Before calling `integrate` for the first time, the initial state should
-        be set with `set_state`.
-
-        Parameters
-        ----------
-        t : float
-            Time to integrate to, should be larger than the previous time.
-
-        copy : bool [True]
-            Whether to return a copy of the state or the state itself.
-
-        Returns
-        -------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at ``t``.
-        """
-        raise NotImplementedError
-
-    def mcstep(self, t, copy=True):
-        """
-        Evolve toward the time ``t``.
-
-        If ``t`` is larger than the present state's ``t``, advance the internal
-        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
-        larger than the previous one, it does an interpolation step and returns
-        the state at that time. When advancing the state, it may return it at a
-        time between present time and the asked ``t`` if more efficent for
-        subsequent interpolation step.
-
-        Before calling `mcstep` for the first time, the initial state should
-        be set with `set_state`.
-
-        Parameters
-        ----------
-        t : float
-            Time to integrate to, should be larger than the previous time. If
-            the last integrate call was use with ``step=True``, the time can be
-            between the time at the start of the last call and now.
-
-        copy : bool [True]
-            Whether to return a copy of the state or the state itself.
-
-        Returns
-        -------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at ``t``. The returned time ``t`` can
-            differ from the input time only when ``step=True``.
-
-        .. note:
-            The default implementation may be overridden by integrators that
-            can provide a more efficient one.
-        """
-        t_last, state = self.get_state()
-        if t > t_last:
-            self._back = t_last, state
-        elif t > self._back[0]:
-            self.set_state(*self._back)
-        else:
-            raise IntegratorException(
-                "`t` is outside the integration range: "
-                f"{self._back[0]}..{t_last}."
-            )
-        return self.integrate(t, copy)
-
-    def get_state(self, copy=True):
-        """
-        Obtain the state of the solver as a pair (t, state).
-
-        Parameters
-        ----------
-        copy : bool (True)
-            Whether to return the data stored in the Integrator or a copy.
-
-        Returns
-        -------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at ``t``.
-        """
-        raise NotImplementedError
-
-    def run(self, tlist):
-        """
-        Integrate the system yielding the state for each times in tlist.
-
-        Parameters
-        ----------
-        tlist : *list* / *array*
-            List of times to yield the state.
-
-        Yields
-        ------
-        (t, state) : (float, qutip.Data)
-            The state of the solver at each ``t`` of tlist.
-        """
-        for t in tlist[1:]:
-            yield self.integrate(t, False)
-
-    def reset(self, hard=False):
-        """Reset internal state of the ODE solver."""
-        if self._is_set:
-            state = self.get_state()
-        if hard:
-            self._prepare()
-        if self._is_set:
-            self.set_state(*state)
-
-    def arguments(self, args):
-        """
-        Change the argument of the system.
-        Reset the ODE solver to ensure numerical validity.
-
-        Parameters
-        ----------
-        args : dict
-            New arguments
-        """
-        self.system.arguments(args)
-        self.reset()
-
-    @property
-    def options(self):
-        # Options should be overwritten by each integrators.
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        # This does not apply the new options.
-        self._options = {
-            **self._options,
-            **{
-               key: new_options[key]
-               for key in self.integrator_options.keys()
-               if key in new_options and new_options[key] is not None
-            }
-        }
+""" `Integrator`: ODE solver wrapper to use in qutip's Solver """
+import numpy as np
+
+__all__ = ['Integrator', 'IntegratorException']
+
+
+class IntegratorException(Exception):
+    """Error from the ODE solver being unable to integrate with the given
+    parameters.
+
+    Example
+    -------
+    - The solver cannot reach the desired tolerance within the maximum number
+    of steps.
+    - The step needed to be within desired tolerance is too small.
+    """
+
+
+class Integrator:
+    """
+    A wrapper around ODE solvers.
+    It ensures a common interface for Solver usage.
+    It takes and return states as :class:`qutip.core.data.Data`, it may return
+    a different data-type than the input type.
+
+    Parameters
+    ----------
+    system: qutip.QobjEvo
+        Quantum system in which states evolve.
+
+    options: dict
+        Options for the integrator.
+
+    Class Attributes
+    ----------------
+    name : str
+        The name of the integrator.
+
+    supports_blackbox : bool
+        If True, then the integrator calls only ``system.matmul``,
+        ``system.matmul_data``, ``system.expect``, ``system.expect_data`` and
+        ``isconstant``, ``isoper`` or ``issuper``. This allows the solver using
+        the integrator to modify the system in creative ways. In particular,
+        the solver may modify the system depending on *both* the time ``t``
+        *and* the current ``state`` the system is being applied to.
+
+        If the integrator calls any other methods, set to False.
+
+    supports_time_dependent : bool
+        If True, then the integrator supports time dependent systems. If False,
+        ``supports_blackbox`` should usually be ``False`` too.
+
+    integrator_options : dict
+        A dictionary of options used by the integrator and their default
+        values. Once initiated, ``self.options`` will be a dict with the same
+        keys, not the full options object passed to the solver. Options' keys
+        included here will be supported by the :cls:SolverOdeOptions.
+    """
+    # Dict of used options and their default values
+    integrator_options = {}
+    _options = None
+    # Can evolve time dependent system
+    support_time_dependant = None
+    # Whether the integrator used the system QobjEvo as a blackbox
+    supports_blackbox = None
+    # The name of the integrator
+    name = None
+    method = ""
+
+    def __init__(self, system, options):
+        self.system = system
+        self._is_set = False  # get_state can be used and return a valid state.
+        self._back = (np.inf, None)
+        self._options = self.integrator_options.copy()
+        self.options = options
+        self._prepare()
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        It should also set the name of the solver to be displayed in Result.
+        """
+        raise NotImplementedError
+
+    def set_state(self, t, state0):
+        """
+        Set the state of the ODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        .. note:
+            It should set the flags `_is_set` to True.
+        """
+        raise NotImplementedError
+
+    def integrate(self, t, copy=True):
+        """
+        Evolve to t.
+
+        Before calling `integrate` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+    def mcstep(self, t, copy=True):
+        """
+        Evolve toward the time ``t``.
+
+        If ``t`` is larger than the present state's ``t``, advance the internal
+        state toward ``t``. If  ``t`` is smaller than the present ``t``, but
+        larger than the previous one, it does an interpolation step and returns
+        the state at that time. When advancing the state, it may return it at a
+        time between present time and the asked ``t`` if more efficent for
+        subsequent interpolation step.
+
+        Before calling `mcstep` for the first time, the initial state should
+        be set with `set_state`.
+
+        Parameters
+        ----------
+        t : float
+            Time to integrate to, should be larger than the previous time. If
+            the last integrate call was use with ``step=True``, the time can be
+            between the time at the start of the last call and now.
+
+        copy : bool [True]
+            Whether to return a copy of the state or the state itself.
+
+        Returns
+        -------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at ``t``. The returned time ``t`` can
+            differ from the input time only when ``step=True``.
+
+        .. note:
+            The default implementation may be overridden by integrators that
+            can provide a more efficient one.
+        """
+        t_last, state = self.get_state()
+        if t > t_last:
+            self._back = t_last, state
+        elif t > self._back[0]:
+            self.set_state(*self._back)
+        else:
+            raise IntegratorException(
+                "`t` is outside the integration range: "
+                f"{self._back[0]}..{t_last}."
+            )
+        return self.integrate(t, copy)
+
+    def get_state(self, copy=True):
+        """
+        Obtain the state of the solver as a pair (t, state).
+
+        Parameters
+        ----------
+        copy : bool (True)
+            Whether to return the data stored in the Integrator or a copy.
+
+        Returns
+        -------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at ``t``.
+        """
+        raise NotImplementedError
+
+    def run(self, tlist):
+        """
+        Integrate the system yielding the state for each times in tlist.
+
+        Parameters
+        ----------
+        tlist : *list* / *array*
+            List of times to yield the state.
+
+        Yields
+        ------
+        (t, state) : (float, qutip.Data)
+            The state of the solver at each ``t`` of tlist.
+        """
+        for t in tlist[1:]:
+            yield self.integrate(t, False)
+
+    def reset(self, hard=False):
+        """Reset internal state of the ODE solver."""
+        if self._is_set:
+            state = self.get_state()
+        if hard:
+            self._prepare()
+        if self._is_set:
+            self.set_state(*state)
+
+    def arguments(self, args):
+        """
+        Change the argument of the system.
+        Reset the ODE solver to ensure numerical validity.
+
+        Parameters
+        ----------
+        args : dict
+            New arguments
+        """
+        self.system.arguments(args)
+        self.reset()
+
+    @property
+    def options(self):
+        # Options should be overwritten by each integrators.
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        # This does not apply the new options.
+        self._options = {
+            **self._options,
+            **{
+               key: new_options[key]
+               for key in self.integrator_options.keys()
+               if key in new_options and new_options[key] is not None
+            }
+        }
diff --git a/qutip/solver/integrator/krylov.py b/qutip/solver/integrator/krylov.py
index a05d198b37..d9cf5757ed 100644
--- a/qutip/solver/integrator/krylov.py
+++ b/qutip/solver/integrator/krylov.py
@@ -1,238 +1,238 @@
-from ..integrator import IntegratorException, Integrator
-import numpy as np
-from qutip.core import data as _data
-from scipy.optimize import root_scalar
-from ..sesolve import SESolver
-
-
-__all__ = ["IntegratorKrylov"]
-
-
-class IntegratorKrylov(Integrator):
-    """
-    Evolve the state vector ("psi0") finding an approximation for the time
-    evolution operator of Hamiltonian ("H") by obtaining the projection of
-    the time evolution operator on a set of small dimensional Krylov
-    subspaces (m << dim(H)).
-    """
-    integrator_options = {
-        'atol': 1e-7,
-        'nsteps': 100,
-        'min_step': 1e-5,
-        'max_step': 1e5,
-        'krylov_dim': 0,
-        'sub_system_tol': 1e-7,
-        'always_compute_step': False,
-    }
-    support_time_dependant = False
-    supports_blackbox = False
-    method = 'krylov'
-
-    def _prepare(self):
-        if not self.system.isconstant:
-            raise ValueError("krylov method only support constant system.")
-        self._max_step = -np.inf
-        krylov_dim = self.options["krylov_dim"]
-        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
-            raise ValueError("The options 'krylov_dim', must be a positive "
-                             "integer smaller that the system size")
-
-        if krylov_dim == 0:
-            # TODO: krylov_dim, max_step and error (atol) are related by
-            # err ~= exp(-krylov_dim / dt**(1~2))
-            # We could ask for 2 and determine the third one.
-            N = self.system.shape[0]
-            krylov_dim = min(int((N + 100)**0.5), N-1)
-            self.options["krylov_dim"]  = krylov_dim
-
-        if not self.options["always_compute_step"]:
-            from qutip import rand_ket
-            N = self.system.shape[0]
-            krylov_tridiag, krylov_basis = \
-                self._lanczos_algorithm(rand_ket(N).data)
-            if (
-                krylov_tridiag.shape[0] < self.options["krylov_dim"]
-                or krylov_tridiag.shape[0] == N
-            ):
-                self._max_step = np.inf
-            else:
-                self._max_step = self._compute_max_step(krylov_tridiag,
-                                                        krylov_basis)
-
-    def _lanczos_algorithm(self, psi):
-        """
-        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
-        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
-        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
-
-        Parameters
-        ------------
-        psi: np.ndarray
-            State used to calculate Krylov subspace.
-        """
-        krylov_dim = self.options['krylov_dim']
-        H = (1j * self.system(0)).data
-
-        v = []
-        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
-        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
-
-        w_prime = _data.matmul(H, psi)
-        T_diag[0] = _data.inner(w_prime, psi)
-        v.append(psi)
-        w = _data.add(w_prime, v[-1], -T_diag[0])
-        T_subdiag[0] = _data.norm.l2(w)
-        j = 0
-
-        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
-            j += 1
-            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
-            w_prime = _data.matmul(H, v[-1])
-            T_diag[j] = _data.inner(w_prime, v[-1])
-            w = _data.add(w_prime, v[-1], -T_diag[j])
-            w = _data.add(w, v[-2], -T_subdiag[j-1])
-            T_subdiag[j] = _data.norm.l2(w)
-
-        krylov_tridiag = _data.diag["dense"](
-            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
-            [-1, 0, 1]
-        )
-        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
-
-        return krylov_tridiag, krylov_basis
-
-    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
-        """
-        Compute the eigen energies, basis transformation operator (U) and e0.
-        """
-        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
-        N = eigenvalues.shape[0]
-        U = _data.matmul(krylov_basis, eigenvectors)
-        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
-        return eigenvalues, U, e0
-
-    def _compute_psi(self, dt, eigenvalues, U, e0):
-        """
-        compute the state at time ``t``.
-        """
-        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
-        aux = _data.multiply(phases, e0)
-        return _data.matmul(U, aux)
-
-    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
-        """
-        Compute the maximum step length to stay under the desired tolerance.
-        """
-        if not krylov_state:
-            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
-
-        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
-        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
-        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
-
-        def krylov_error(t):
-            # we divide by atol and take the log so that the error returned is 0
-            # at atol, which is convenient for calling root_scalar with.
-            return np.log(_data.norm.l2(
-                self._compute_psi(t, *krylov_state) -
-                self._compute_psi(t, *reduced_state)
-            ) / self.options["atol"])
-
-        dt = self.options["min_step"]
-        err = krylov_error(dt)
-        if err > 0:
-            ValueError(
-                f"With the krylov dim of {self.options['krylov_dim']}, the "
-                f"error with the minimum step {dt} is {err}, higher than the "
-                f"desired tolerance of {self.options['atol']}."
-            )
-
-        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
-            dt *= 10
-
-        if dt > self.options["max_step"]:
-            return self.options["max_step"]
-
-        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
-                          method="brentq", xtol=self.options['atol'])
-        if sol.converged:
-            return sol.root
-        else:
-            return dt
-
-    def set_state(self, t, state0):
-        self._t_0 = t
-        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
-        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
-
-        if (
-            krylov_tridiag.shape[0] <= self.options['krylov_dim']
-            or krylov_tridiag.shape == self.system.shape
-        ):
-            # happy_breakdown
-            self._max_step = np.inf
-            return
-
-        if (
-            not np.isfinite(self._max_step)
-            or self.options["always_compute_step"]
-        ):
-            self._max_step = self._compute_max_step(
-                krylov_tridiag, krylov_basis, self._krylov_state,
-            )
-
-    def get_state(self, copy=True):
-        return self._t_0, self._compute_psi(0, *self._krylov_state)
-
-    def integrate(self, t, copy=True):
-        step = 0
-        while t > self._t_0 + self._max_step:
-            # The approximation in only valid in the range t_0, t_0 + max step
-            # If outside, advance the range
-            step += 1
-            if step >= self.options["nsteps"]:
-                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
-            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
-            self.set_state(self._t_0 + self._max_step, new_psi)
-
-        delta_t = t - self._t_0
-        out = self._compute_psi(delta_t, *self._krylov_state)
-        return t, out
-
-    @property
-    def options(self):
-        """
-        Supported options by krylov method:
-
-        atol : float, default=1e-7
-            Absolute tolerance.
-
-        nsteps : int, default=100
-            Max. number of internal steps/call.
-
-        min_step, max_step : float, default=(1e-5, 1e5)
-            Minimum and maximum step size.
-
-        krylov_dim: int, default=0
-            Dimension of Krylov approximation subspaces used for the time
-            evolution approximation. If the defaut 0 is given, the dimension is calculated
-            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
-
-        sub_system_tol: float, default=1e-7
-            Tolerance to detect a happy breakdown. A happy breakdown occurs
-            when the initial ket is in a subspace of the Hamiltonian smaller
-            than ``krylov_dim``.
-
-        always_compute_step: bool, default=False
-            If True, the step length is computed each time a new Krylov
-            subspace is computed. Otherwise it is computed only once when
-            creating the integrator.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-SESolver.add_integrator(IntegratorKrylov, 'krylov')
+from ..integrator import IntegratorException, Integrator
+import numpy as np
+from qutip.core import data as _data
+from scipy.optimize import root_scalar
+from ..sesolve import SESolver
+
+
+__all__ = ["IntegratorKrylov"]
+
+
+class IntegratorKrylov(Integrator):
+    """
+    Evolve the state vector ("psi0") finding an approximation for the time
+    evolution operator of Hamiltonian ("H") by obtaining the projection of
+    the time evolution operator on a set of small dimensional Krylov
+    subspaces (m << dim(H)).
+    """
+    integrator_options = {
+        'atol': 1e-7,
+        'nsteps': 100,
+        'min_step': 1e-5,
+        'max_step': 1e5,
+        'krylov_dim': 0,
+        'sub_system_tol': 1e-7,
+        'always_compute_step': False,
+    }
+    support_time_dependant = False
+    supports_blackbox = False
+    method = 'krylov'
+
+    def _prepare(self):
+        if not self.system.isconstant:
+            raise ValueError("krylov method only support constant system.")
+        self._max_step = -np.inf
+        krylov_dim = self.options["krylov_dim"]
+        if krylov_dim < 0 or krylov_dim > self.system.shape[0]:
+            raise ValueError("The options 'krylov_dim', must be a positive "
+                             "integer smaller that the system size")
+
+        if krylov_dim == 0:
+            # TODO: krylov_dim, max_step and error (atol) are related by
+            # err ~= exp(-krylov_dim / dt**(1~2))
+            # We could ask for 2 and determine the third one.
+            N = self.system.shape[0]
+            krylov_dim = min(int((N + 100)**0.5), N-1)
+            self.options["krylov_dim"]  = krylov_dim
+
+        if not self.options["always_compute_step"]:
+            from qutip import rand_ket
+            N = self.system.shape[0]
+            krylov_tridiag, krylov_basis = \
+                self._lanczos_algorithm(rand_ket(N).data)
+            if (
+                krylov_tridiag.shape[0] < self.options["krylov_dim"]
+                or krylov_tridiag.shape[0] == N
+            ):
+                self._max_step = np.inf
+            else:
+                self._max_step = self._compute_max_step(krylov_tridiag,
+                                                        krylov_basis)
+
+    def _lanczos_algorithm(self, psi):
+        """
+        Computes a basis of the Krylov subspace for Hamiltonian 'H', a system
+        state 'psi' and Krylov dimension 'krylov_dim'. The space is spanned
+        by {psi, H psi, H^2 psi, ..., H^(krylov_dim) psi}.
+
+        Parameters
+        ------------
+        psi: np.ndarray
+            State used to calculate Krylov subspace.
+        """
+        krylov_dim = self.options['krylov_dim']
+        H = (1j * self.system(0)).data
+
+        v = []
+        T_diag = np.zeros(krylov_dim + 1, dtype=complex)
+        T_subdiag = np.zeros(krylov_dim + 1, dtype=complex)
+
+        w_prime = _data.matmul(H, psi)
+        T_diag[0] = _data.inner(w_prime, psi)
+        v.append(psi)
+        w = _data.add(w_prime, v[-1], -T_diag[0])
+        T_subdiag[0] = _data.norm.l2(w)
+        j = 0
+
+        while j < krylov_dim and T_subdiag[j] > self.options['sub_system_tol']:
+            j += 1
+            v.append(_data.mul(w, 1 / T_subdiag[j-1]))
+            w_prime = _data.matmul(H, v[-1])
+            T_diag[j] = _data.inner(w_prime, v[-1])
+            w = _data.add(w_prime, v[-1], -T_diag[j])
+            w = _data.add(w, v[-2], -T_subdiag[j-1])
+            T_subdiag[j] = _data.norm.l2(w)
+
+        krylov_tridiag = _data.diag["dense"](
+            [T_subdiag[:j], T_diag[:j+1], T_subdiag[:j]],
+            [-1, 0, 1]
+        )
+        krylov_basis = _data.Dense(np.hstack([psi.to_array() for psi in v]))
+
+        return krylov_tridiag, krylov_basis
+
+    def _compute_krylov_set(self, krylov_tridiag, krylov_basis):
+        """
+        Compute the eigen energies, basis transformation operator (U) and e0.
+        """
+        eigenvalues, eigenvectors = _data.eigs(krylov_tridiag, True)
+        N = eigenvalues.shape[0]
+        U = _data.matmul(krylov_basis, eigenvectors)
+        e0 = eigenvectors.adjoint() @ _data.one_element_dense((N, 1), (0, 0), 1.0)
+        return eigenvalues, U, e0
+
+    def _compute_psi(self, dt, eigenvalues, U, e0):
+        """
+        compute the state at time ``t``.
+        """
+        phases = _data.Dense(np.exp(-1j * dt * eigenvalues))
+        aux = _data.multiply(phases, e0)
+        return _data.matmul(U, aux)
+
+    def _compute_max_step(self, krylov_tridiag, krylov_basis, krylov_state=None):
+        """
+        Compute the maximum step length to stay under the desired tolerance.
+        """
+        if not krylov_state:
+            krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
+
+        small_tridiag = _data.Dense(krylov_tridiag.as_ndarray()[:-1, :-1])
+        small_basis = _data.Dense(krylov_basis.as_ndarray()[:, :-1])
+        reduced_state = self._compute_krylov_set(small_tridiag, small_basis)
+
+        def krylov_error(t):
+            # we divide by atol and take the log so that the error returned is 0
+            # at atol, which is convenient for calling root_scalar with.
+            return np.log(_data.norm.l2(
+                self._compute_psi(t, *krylov_state) -
+                self._compute_psi(t, *reduced_state)
+            ) / self.options["atol"])
+
+        dt = self.options["min_step"]
+        err = krylov_error(dt)
+        if err > 0:
+            ValueError(
+                f"With the krylov dim of {self.options['krylov_dim']}, the "
+                f"error with the minimum step {dt} is {err}, higher than the "
+                f"desired tolerance of {self.options['atol']}."
+            )
+
+        while krylov_error(dt * 10) < 0 and dt < self.options["max_step"]:
+            dt *= 10
+
+        if dt > self.options["max_step"]:
+            return self.options["max_step"]
+
+        sol = root_scalar(f=krylov_error, bracket=[dt, dt * 10],
+                          method="brentq", xtol=self.options['atol'])
+        if sol.converged:
+            return sol.root
+        else:
+            return dt
+
+    def set_state(self, t, state0):
+        self._t_0 = t
+        krylov_tridiag, krylov_basis = self._lanczos_algorithm(state0)
+        self._krylov_state = self._compute_krylov_set(krylov_tridiag, krylov_basis)
+
+        if (
+            krylov_tridiag.shape[0] <= self.options['krylov_dim']
+            or krylov_tridiag.shape == self.system.shape
+        ):
+            # happy_breakdown
+            self._max_step = np.inf
+            return
+
+        if (
+            not np.isfinite(self._max_step)
+            or self.options["always_compute_step"]
+        ):
+            self._max_step = self._compute_max_step(
+                krylov_tridiag, krylov_basis, self._krylov_state,
+            )
+
+    def get_state(self, copy=True):
+        return self._t_0, self._compute_psi(0, *self._krylov_state)
+
+    def integrate(self, t, copy=True):
+        step = 0
+        while t > self._t_0 + self._max_step:
+            # The approximation in only valid in the range t_0, t_0 + max step
+            # If outside, advance the range
+            step += 1
+            if step >= self.options["nsteps"]:
+                raise IntegratorException(f"Maximum number of integration steps ({self.options['nsteps']}) exceeded")
+            new_psi = self._compute_psi(self._max_step, *self._krylov_state)
+            self.set_state(self._t_0 + self._max_step, new_psi)
+
+        delta_t = t - self._t_0
+        out = self._compute_psi(delta_t, *self._krylov_state)
+        return t, out
+
+    @property
+    def options(self):
+        """
+        Supported options by krylov method:
+
+        atol : float, default=1e-7
+            Absolute tolerance.
+
+        nsteps : int, default=100
+            Max. number of internal steps/call.
+
+        min_step, max_step : float, default=(1e-5, 1e5)
+            Minimum and maximum step size.
+
+        krylov_dim: int, default=0
+            Dimension of Krylov approximation subspaces used for the time
+            evolution approximation. If the defaut 0 is given, the dimension is calculated
+            from the system size N, using `min(int((N + 100)**0.5), N-1)`.
+
+        sub_system_tol: float, default=1e-7
+            Tolerance to detect a happy breakdown. A happy breakdown occurs
+            when the initial ket is in a subspace of the Hamiltonian smaller
+            than ``krylov_dim``.
+
+        always_compute_step: bool, default=False
+            If True, the step length is computed each time a new Krylov
+            subspace is computed. Otherwise it is computed only once when
+            creating the integrator.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+SESolver.add_integrator(IntegratorKrylov, 'krylov')
diff --git a/qutip/solver/integrator/qutip_integrator.py b/qutip/solver/integrator/qutip_integrator.py
index eca2da6383..03749a57bd 100644
--- a/qutip/solver/integrator/qutip_integrator.py
+++ b/qutip/solver/integrator/qutip_integrator.py
@@ -1,200 +1,200 @@
-from ..integrator import IntegratorException, Integrator
-from ..solver_base import Solver
-from .explicit_rk import Explicit_RungeKutta
-import numpy as np
-from qutip import data as _data
-
-
-__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
-
-
-class IntegratorVern7(Integrator):
-    """
-    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
-    of order 7. These are Runge-Kutta methods with variable steps and dense
-    output.
-
-    The implementation uses QuTiP's Data objects for the state, allowing
-    sparse, GPU or other data layer objects to be used efficiently by the
-    solver in their native formats.
-
-    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
-    methods.
-
-    Usable with ``method="vern7"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 1000,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-        'interpolate': True,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'vern7'
-
-    def _prepare(self):
-        self._ode_solver = Explicit_RungeKutta(
-            self.system, method=self.method,
-            **self.options
-        )
-        self.name = self.method
-
-    def get_state(self, copy=True):
-        state = self._ode_solver.y
-        return self._ode_solver.t, state.copy() if copy else state
-
-    def set_state(self, t, state):
-        self._ode_solver.set_initial_value(state.copy(), t)
-        self._is_set = True
-
-    def integrate(self, t, copy=True):
-        self._ode_solver.integrate(t, step=False)
-        self._check_failed_integration()
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        self._ode_solver.integrate(t, step=True)
-        self._check_failed_integration()
-        return self.get_state(copy)
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        raise IntegratorException(self._ode_solver.status_message())
-
-    @property
-    def options(self):
-        """
-        Supported options by verner method:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        nsteps : int, default=1000
-            Max. number of internal steps/call.
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        min_step : float, default=0
-            Minimum step size (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-            When using pulses, change to half the thinest pulse otherwise it
-            may be skipped.
-
-        interpolate : bool, default=True
-            Whether to use interpolation step, faster most of the time.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-class IntegratorVern9(IntegratorVern7):
-    """
-    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
-    of order 9. These are Runge-Kutta methods with variable steps and dense
-    output.
-
-    The implementation uses QuTiP's Data objects for the state, allowing
-    sparse, GPU or other data layer objects to be used efficiently by the
-    solver in their native formats.
-
-    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
-    methods.
-
-    Usable with ``method="vern9"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 1000,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-        'interpolate': True,
-    }
-    method = 'vern9'
-
-
-class IntegratorDiag(Integrator):
-    """
-    Integrator solving the ODE by diagonalizing the system and solving
-    analytically. It can only solve constant system and has a long preparation
-    time, but the integration is fast.
-
-    Usable with ``method="diag"``
-    """
-    integrator_options = {"eigensolver_dtype": "dense"}
-    support_time_dependant = False
-    supports_blackbox = False
-    method = 'diag'
-
-    def __init__(self, system, options):
-        if not system.isconstant:
-            raise ValueError("Hamiltonian system must be constant to use "
-                             "diagonalized method")
-        super().__init__(system, options)
-
-    def _prepare(self):
-        self._dt = 0.
-        self._expH = None
-        H0 = self.system(0).to(self.options["eigensolver_dtype"])
-        self.diag, self.U = _data.eigs(H0.data, False)
-        self.diag = self.diag.reshape((-1, 1))
-        self.Uinv = _data.inv(self.U)
-        self.name = "qutip diagonalized"
-
-    def integrate(self, t, copy=True):
-        dt = t - self._t
-        if dt == 0:
-            return self.get_state()
-        elif self._dt != dt:
-            self._expH = np.exp(self.diag * dt)
-            self._dt = dt
-        self._y *= self._expH
-        self._t = t
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        return self.integrate(t, copy=copy)
-
-    def get_state(self, copy=True):
-        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
-
-    def set_state(self, t, state0):
-        self._t = t
-        self._y = _data.matmul(self.Uinv, state0).to_array()
-        self._is_set = True
-
-    @property
-    def options(self):
-        """
-        Supported options by "diag" method:
-
-        eigensolver_dtype : str, default="dense"
-            Qutip data type {"dense", "csr", etc.} to use when computing the
-            eigenstates. The dense eigen solver is usually faster and more
-            stable.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-Solver.add_integrator(IntegratorVern7, 'vern7')
-Solver.add_integrator(IntegratorVern9, 'vern9')
-Solver.add_integrator(IntegratorDiag, 'diag')
+from ..integrator import IntegratorException, Integrator
+from ..solver_base import Solver
+from .explicit_rk import Explicit_RungeKutta
+import numpy as np
+from qutip import data as _data
+
+
+__all__ = ['IntegratorVern7', 'IntegratorVern9', 'IntegratorDiag']
+
+
+class IntegratorVern7(Integrator):
+    """
+    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
+    of order 7. These are Runge-Kutta methods with variable steps and dense
+    output.
+
+    The implementation uses QuTiP's Data objects for the state, allowing
+    sparse, GPU or other data layer objects to be used efficiently by the
+    solver in their native formats.
+
+    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
+    methods.
+
+    Usable with ``method="vern7"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 1000,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+        'interpolate': True,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'vern7'
+
+    def _prepare(self):
+        self._ode_solver = Explicit_RungeKutta(
+            self.system, method=self.method,
+            **self.options
+        )
+        self.name = self.method
+
+    def get_state(self, copy=True):
+        state = self._ode_solver.y
+        return self._ode_solver.t, state.copy() if copy else state
+
+    def set_state(self, t, state):
+        self._ode_solver.set_initial_value(state.copy(), t)
+        self._is_set = True
+
+    def integrate(self, t, copy=True):
+        self._ode_solver.integrate(t, step=False)
+        self._check_failed_integration()
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        self._ode_solver.integrate(t, step=True)
+        self._check_failed_integration()
+        return self.get_state(copy)
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        raise IntegratorException(self._ode_solver.status_message())
+
+    @property
+    def options(self):
+        """
+        Supported options by verner method:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        nsteps : int, default=1000
+            Max. number of internal steps/call.
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        min_step : float, default=0
+            Minimum step size (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+            When using pulses, change to half the thinest pulse otherwise it
+            may be skipped.
+
+        interpolate : bool, default=True
+            Whether to use interpolation step, faster most of the time.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class IntegratorVern9(IntegratorVern7):
+    """
+    QuTiP's implementation of Verner's "most efficient" Runge-Kutta method
+    of order 9. These are Runge-Kutta methods with variable steps and dense
+    output.
+
+    The implementation uses QuTiP's Data objects for the state, allowing
+    sparse, GPU or other data layer objects to be used efficiently by the
+    solver in their native formats.
+
+    See http://people.math.sfu.ca/~jverner/ for a detailed description of the
+    methods.
+
+    Usable with ``method="vern9"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 1000,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+        'interpolate': True,
+    }
+    method = 'vern9'
+
+
+class IntegratorDiag(Integrator):
+    """
+    Integrator solving the ODE by diagonalizing the system and solving
+    analytically. It can only solve constant system and has a long preparation
+    time, but the integration is fast.
+
+    Usable with ``method="diag"``
+    """
+    integrator_options = {"eigensolver_dtype": "dense"}
+    support_time_dependant = False
+    supports_blackbox = False
+    method = 'diag'
+
+    def __init__(self, system, options):
+        if not system.isconstant:
+            raise ValueError("Hamiltonian system must be constant to use "
+                             "diagonalized method")
+        super().__init__(system, options)
+
+    def _prepare(self):
+        self._dt = 0.
+        self._expH = None
+        H0 = self.system(0).to(self.options["eigensolver_dtype"])
+        self.diag, self.U = _data.eigs(H0.data, False)
+        self.diag = self.diag.reshape((-1, 1))
+        self.Uinv = _data.inv(self.U)
+        self.name = "qutip diagonalized"
+
+    def integrate(self, t, copy=True):
+        dt = t - self._t
+        if dt == 0:
+            return self.get_state()
+        elif self._dt != dt:
+            self._expH = np.exp(self.diag * dt)
+            self._dt = dt
+        self._y *= self._expH
+        self._t = t
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        return self.integrate(t, copy=copy)
+
+    def get_state(self, copy=True):
+        return self._t, _data.matmul(self.U, _data.dense.Dense(self._y))
+
+    def set_state(self, t, state0):
+        self._t = t
+        self._y = _data.matmul(self.Uinv, state0).to_array()
+        self._is_set = True
+
+    @property
+    def options(self):
+        """
+        Supported options by "diag" method:
+
+        eigensolver_dtype : str, default="dense"
+            Qutip data type {"dense", "csr", etc.} to use when computing the
+            eigenstates. The dense eigen solver is usually faster and more
+            stable.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+Solver.add_integrator(IntegratorVern7, 'vern7')
+Solver.add_integrator(IntegratorVern9, 'vern9')
+Solver.add_integrator(IntegratorDiag, 'diag')
diff --git a/qutip/solver/integrator/scipy_integrator.py b/qutip/solver/integrator/scipy_integrator.py
index 7c71185f2d..dac1028a61 100644
--- a/qutip/solver/integrator/scipy_integrator.py
+++ b/qutip/solver/integrator/scipy_integrator.py
@@ -1,527 +1,527 @@
-"""ODE integrator from scipy."""
-
-__all__ = [
-    'IntegratorScipyAdams',
-    'IntegratorScipyBDF',
-    'IntegratorScipyDop853',
-    'IntegratorScipylsoda',
-]
-
-import numpy as np
-from scipy.integrate import ode
-from scipy.integrate._ode import zvode
-from qutip.core import data as _data
-from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
-from ..integrator import IntegratorException, Integrator
-from ..solver_base import Solver
-import warnings
-
-
-class IntegratorScipyAdams(Integrator):
-    """
-    Integrator using Scipy `ode` with zvode integrator using adams method.
-    Ordinary Differential Equation solver by netlib
-    (http://www.netlib.org/odepack).
-
-    Usable with ``method="adams"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'order': 12,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'adams'
-
-    class _zvode(zvode):
-        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
-        def step(self, *args):
-            itask = self.call_args[2]
-            self.rwork[0] = args[4]
-            self.call_args[2] = 5
-            r = self.run(*args)
-            self.call_args[2] = itask
-            return r
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        """
-        self._ode_solver = ode(self._mul_np_vec)
-        self._ode_solver.set_integrator('zvode')
-        self._ode_solver._integrator = self._zvode(
-            method=self.method,
-            **self.options,
-        )
-        self.name = "scipy zvode " + self.method
-
-    def _mul_np_vec(self, t, vec):
-        """
-        Interface between scipy which use numpy and the driver, which use data.
-        """
-        state = _data.dense.fast_from_numpy(vec)
-        column_unstack_dense(state, self._size, inplace=True)
-        out = self.system.matmul_data(t, state)
-        column_stack_dense(out, inplace=True)
-        return out.as_ndarray().ravel()
-
-    def set_state(self, t, state0):
-        self._is_set = True
-        self._back = t
-        self._front = t
-        self._mat_state = state0.shape[1] > 1
-        self._size = state0.shape[0]
-        if self._mat_state:
-            state0 = _data.column_stack(state0)
-        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
-
-    def get_state(self, copy=True):
-        if not self._is_set:
-            raise IntegratorException("The state is not initialted")
-        self._check_failed_integration()
-        t = self._ode_solver.t
-        if self._mat_state:
-            state = _data.column_unstack_dense(
-                _data.dense.Dense(self._ode_solver._y, copy=copy),
-                self._size,
-                inplace=True)
-        else:
-            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
-        return t, state
-
-    def _check_handle(self):
-        """
-        Do the check for concurrent use of the integrator and reset if used
-        elsewhere.
-        """
-        integrator = self._ode_solver._integrator
-        if integrator.initialized:
-            if integrator.handle != integrator.__class__.active_global_handle:
-                integrator.reset(len(self._ode_solver._y), False)
-
-    def integrate(self, t, copy=True):
-        self._check_handle()
-        if t != self._ode_solver.t:
-            self._ode_solver.integrate(t)
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        # When working with mcstep, we use the dense output feature:
-        # a range in which the state at any time can be computed with
-        # minimal work. We keep track of the range with _back and _front.
-        self._check_handle()
-        if self._ode_solver.t == t:
-            # Exact same `t` as the last call, nothing to do.
-            pass
-        elif self._back > t:
-            # `t` before the range: not supported.
-            raise IntegratorException(
-                f"`t`={t} is behind the integration limit: "
-                f"{t} < {self._back}."
-            )
-        elif t <= self._front:
-            # In the range, ask for the new state.
-            self._ode_solver.integrate(t)
-        elif self._ode_solver.t < self._front:
-            # `t` after the range but last call (`t_prev`) not at the front.
-            # Advancing the range would make the interval `t_prev`..`_front`
-            # unreachable. Thus advance to _front.
-            self._ode_solver.integrate(self._front)
-        else:
-            # Advance the range.
-            self._back = self._front
-            self._ode_solver.integrate(t, step=True)
-            self._front = self._ode_solver._integrator.rwork[12]
-
-        return self.get_state(copy)
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        messages = {
-            -1: 'Excess work done on this call. Try to increasing '
-                'the nsteps parameter in the Options class',
-            -2: 'Excess accuracy requested. (Tolerances too small.)',
-            -3: 'Illegal input detected.',
-            -4: 'Repeated error test failures. (Check all input.)',
-            -5: 'Repeated convergence failures. (Perhaps bad'
-                ' Jacobian supplied or wrong choice of MF or tolerances.)',
-            -6: 'Error weight became zero during problem. (Solution'
-                ' component i vanished, and ATOL or ATOL(i) = 0.)'
-        }
-        raise IntegratorException(
-            messages[self._ode_solver._integrator.istate]
-        )
-
-    @property
-    def options(self):
-        """
-        Supported options by zvode integrator:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        order : int, default=12, 'adams' or 5, 'bdf'
-            Order of integrator <=12 'adams', <=5 'bdf'
-
-        nsteps : int, default=2500
-            Max. number of internal steps/call.
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        min_step : float, default=0
-            Minimum step size (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-            When using pulses, change to half the thinest pulse otherwise it
-            may be skipped.
-    """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-class IntegratorScipyBDF(IntegratorScipyAdams):
-    """
-    Integrator using Scipy `ode` with zvode integrator using bdf method.
-    Ordinary Differential Equation solver by netlib
-    (http://www.netlib.org/odepack).
-
-    Usable with ``method="bdf"``
-    """
-    method = 'bdf'
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'order': 5,
-        'first_step': 0,
-        'max_step': 0,
-        'min_step': 0,
-    }
-
-
-class IntegratorScipyDop853(Integrator):
-    """
-    Integrator using Scipy `ode` with dop853 integrator. Eight order
-    runge-kutta method by Dormand & Prince. Use fortran implementation
-    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
-    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
-    Computational Mathematics, Springer-Verlag (1993)].
-
-    Usable with ``method="dop853"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'first_step': 0,
-        'max_step': 0,
-        'ifactor': 6.0,
-        'dfactor': 0.3,
-        'beta': 0.0,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'dop853'
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        """
-        self._ode_solver = ode(self._mul_np_vec)
-        self._ode_solver.set_integrator('dop853', **self.options)
-        self.name = "scipy ode dop853"
-
-    def _mul_np_vec(self, t, vec):
-        """
-        Interface between scipy which use numpy and the driver, which use data.
-        """
-        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
-        column_unstack_dense(state, self._size, inplace=True)
-        out = self.system.matmul_data(t, state)
-        column_stack_dense(out, inplace=True)
-        return out.as_ndarray().ravel().view(np.float64)
-
-    def integrate(self, t, copy=True):
-        if t != self._ode_solver.t:
-            self._ode_solver.integrate(t)
-        return self.get_state(copy)
-
-    def mcstep(self, t, copy=True):
-        if self._ode_solver.t <= t:
-            # Scipy's DOP853 does not have a step function.
-            # It has a safe step length, but can be 0 if unknown.
-            dt = self._ode_solver._integrator.work[6]
-            if dt:
-                t = min(self._ode_solver.t + dt, t)
-            self._ode_solver.integrate(t)
-        else:
-            # While DOP853 support changing the direction of the integration,
-            # it does not do so efficiently. We do it manually.
-            self._ode_solver._integrator.work[6] *= -1
-            self._ode_solver.integrate(t)
-            self._ode_solver._integrator.work[6] *= -1
-        return self.get_state(copy)
-
-    def get_state(self, copy=True):
-        if not self._is_set:
-            raise IntegratorException("The state is not initialted")
-        self._check_failed_integration()
-        t = self._ode_solver.t
-        if self._mat_state:
-            state = _data.column_unstack_dense(
-                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
-                                  copy=copy),
-                self._size,
-                inplace=True)
-        else:
-            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
-                                      copy=copy)
-        return t, state
-
-    def set_state(self, t, state0):
-        self._is_set = True
-        self._mat_state = state0.shape[1] > 1
-        self._size = state0.shape[0]
-        if self._mat_state:
-            state0 = _data.column_stack(state0)
-        self._ode_solver.set_initial_value(
-            state0.to_array().ravel().view(np.float64),
-            t
-        )
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        messages = {
-            -1: 'input is not consistent',
-            -2: 'larger nsteps is needed, Try to increase the nsteps '
-                'parameter in the Options class.',
-            -3: 'step size becomes too small. Try increasing tolerance',
-            -4: 'problem is probably stiff (interrupted), try "bdf" '
-                'method instead',
-        }
-        raise IntegratorException(
-            messages[self._ode_solver._integrator.istate]
-        )
-
-    @property
-    def options(self):
-        """
-        Supported options by dop853 integrator:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        nsteps : int, default=2500
-            Max. number of internal steps/call.
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-
-        ifactor, dfactor : float, default=6., 0.3
-            Maximum factor to increase/decrease step size by in one step
-
-        beta : float, default=0
-            Beta parameter for stabilised step size control.
-
-        See scipy.integrate.ode ode for more detail
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-class IntegratorScipylsoda(IntegratorScipyDop853):
-    """
-    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
-    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
-    'BDF' methods to solve both stiff and non-stiff systems.
-
-    Usable with ``method="lsoda"``
-    """
-    integrator_options = {
-        'atol': 1e-8,
-        'rtol': 1e-6,
-        'nsteps': 2500,
-        'max_order_ns': 12,
-        'max_order_s': 5,
-        'first_step': 0.0,
-        'max_step': 0.0,
-        'min_step': 0.0,
-    }
-    support_time_dependant = True
-    supports_blackbox = True
-    method = 'lsoda'
-
-    def _prepare(self):
-        """
-        Initialize the solver
-        """
-        self._ode_solver = ode(self._mul_np_vec)
-        self._ode_solver.set_integrator('lsoda', **self.options)
-        self.name = "scipy lsoda"
-
-    def _check_handle(self):
-        """
-        Do the check for concurrent use of the integrator and reset if used
-        elsewhere.
-        """
-        integrator = self._ode_solver._integrator
-        if integrator.initialized:
-            if integrator.handle != integrator.__class__.active_global_handle:
-                integrator.reset(len(self._ode_solver._y), False)
-
-    def integrate(self, t, copy=True):
-        self._check_handle()
-        return super().integrate(t, copy)
-
-    def set_state(self, t, state0):
-        self._front = t
-        super().set_state(t, state0)
-        self._back = self.get_state()
-
-    def mcstep(self, t, copy=True):
-        # This solver support dense output:
-        # a range in which the state at any time can be computed with
-        # minimal work. We keep track of the range with _back[0] and _front.
-        self._check_handle()
-        if self._ode_solver.t == t:
-            # Exact same `t` as the last call, nothing to do.
-            pass
-        elif self._back[0] <= t <= self._front:
-            # In the range, ask for the new state.
-            self._backstep(t)
-        elif self._front < t:
-            # Advance the range.
-            self._one_step(t)
-        else:
-            raise IntegratorException(
-                f"`t`={t} is behind the integration limit: "
-                f"{t} < {self._back[0]}."
-            )
-        return self.get_state(copy)
-
-    def _one_step(self, t):
-        """
-        Advance up to t by one internal solver step.
-        Should be able to retreive the state at any time between the present
-        time and the resulting time using `backstep`.
-        """
-        # Here we want to advance up to t doing maximum one step.
-        # lsoda officially support step, but sometime it does more work than
-        # needed, so we ask it to advance a fraction of the last step, where it
-        # will advance one internal step of length allowed by the tolerance and
-        # interpolate back to the asked time, effictively getting the single
-        # integration step we want. The first step and abrupt changes in the
-        # `rhs` can cause exceptions to this, but _backstep catch those cases.
-        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
-        t_ode = self._ode_solver.t
-
-        if t > self._front and t_ode >= self._front:
-            # The state is at self._front, do a step
-            self._back = self.get_state()
-            self._ode_solver.integrate(min(self._front + safe_delta, t))
-            self._front = self._ode_solver._integrator.rwork[12]
-            # We asked for a fraction of a step, now complete it.
-            self._ode_solver.integrate(min(self._front, t))
-        elif t > self._front:
-            # The state is at a time before t_front, advance to t_front
-            self._ode_solver.integrate(self._front)
-
-    def _backstep(self, t):
-        """
-        Retreive the state at time t, with t smaller than present ODE time.
-        The time t will always be between the last calls of `one_step`.
-        return the pair t, state.
-        """
-        delta = self._ode_solver._integrator.rwork[11]
-        if t == self._ode_solver.t:
-            pass
-        elif self._front - delta <= t:
-            self._ode_solver.integrate(t)
-        else:
-            self.set_state(*self._back)
-            self._ode_solver.integrate(t)
-
-    def _check_failed_integration(self):
-        if self._ode_solver.successful():
-            return
-        messages = {
-            -1: "Excess work done on this call."
-                "Try to increase the nsteps parameter in the Options class.",
-            -2: "Excess accuracy requested (tolerances too small).",
-            -3: "Illegal input detected (internal error).",
-            -4: "Repeated error test failures (internal error).",
-            -5: "Repeated convergence failures "
-                "(perhaps bad Jacobian or tolerances).",
-            -6: "Error weight became zero during problem.",
-            -7: "Internal workspace insufficient to finish (internal error)."
-        }
-        raise IntegratorException(
-            messages[self._ode_solver._integrator.istate]
-        )
-
-    @property
-    def options(self):
-        """
-        Supported options by lsoda integrator:
-
-        atol : float, default=1e-8
-            Absolute tolerance.
-
-        rtol : float, default=1e-6
-            Relative tolerance.
-
-        nsteps : int, default=2500
-            Max. number of internal steps/call.
-
-        max_order_ns : int, default=12
-            Maximum order used in the nonstiff case (<= 12).
-
-        max_order_s : int, default=5
-            Maximum order used in the stiff case (<= 5).
-
-        first_step : float, default=0
-            Size of initial step (0 = automatic).
-
-        max_step : float, default=0
-            Maximum step size (0 = automatic)
-            When using pulses, change to half the thinest pulse otherwise it
-            may be skipped.
-
-        min_step : float, default=0
-            Minimum step size (0 = automatic)
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Integrator.options.fset(self, new_options)
-
-
-Solver.add_integrator(IntegratorScipyBDF, 'bdf')
-Solver.add_integrator(IntegratorScipyAdams, 'adams')
-Solver.add_integrator(IntegratorScipyDop853, 'dop853')
-Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
+"""ODE integrator from scipy."""
+
+__all__ = [
+    'IntegratorScipyAdams',
+    'IntegratorScipyBDF',
+    'IntegratorScipyDop853',
+    'IntegratorScipylsoda',
+]
+
+import numpy as np
+from scipy.integrate import ode
+from scipy.integrate._ode import zvode
+from qutip.core import data as _data
+from qutip.core.data.reshape import column_unstack_dense, column_stack_dense
+from ..integrator import IntegratorException, Integrator
+from ..solver_base import Solver
+import warnings
+
+
+class IntegratorScipyAdams(Integrator):
+    """
+    Integrator using Scipy `ode` with zvode integrator using adams method.
+    Ordinary Differential Equation solver by netlib
+    (http://www.netlib.org/odepack).
+
+    Usable with ``method="adams"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'order': 12,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'adams'
+
+    class _zvode(zvode):
+        """Overwrite the scipy's zvode to advance to max to ``t`` with step."""
+        def step(self, *args):
+            itask = self.call_args[2]
+            self.rwork[0] = args[4]
+            self.call_args[2] = 5
+            r = self.run(*args)
+            self.call_args[2] = itask
+            return r
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        """
+        self._ode_solver = ode(self._mul_np_vec)
+        self._ode_solver.set_integrator('zvode')
+        self._ode_solver._integrator = self._zvode(
+            method=self.method,
+            **self.options,
+        )
+        self.name = "scipy zvode " + self.method
+
+    def _mul_np_vec(self, t, vec):
+        """
+        Interface between scipy which use numpy and the driver, which use data.
+        """
+        state = _data.dense.fast_from_numpy(vec)
+        column_unstack_dense(state, self._size, inplace=True)
+        out = self.system.matmul_data(t, state)
+        column_stack_dense(out, inplace=True)
+        return out.as_ndarray().ravel()
+
+    def set_state(self, t, state0):
+        self._is_set = True
+        self._back = t
+        self._front = t
+        self._mat_state = state0.shape[1] > 1
+        self._size = state0.shape[0]
+        if self._mat_state:
+            state0 = _data.column_stack(state0)
+        self._ode_solver.set_initial_value(state0.to_array().ravel(), t)
+
+    def get_state(self, copy=True):
+        if not self._is_set:
+            raise IntegratorException("The state is not initialted")
+        self._check_failed_integration()
+        t = self._ode_solver.t
+        if self._mat_state:
+            state = _data.column_unstack_dense(
+                _data.dense.Dense(self._ode_solver._y, copy=copy),
+                self._size,
+                inplace=True)
+        else:
+            state = _data.dense.Dense(self._ode_solver._y, copy=copy)
+        return t, state
+
+    def _check_handle(self):
+        """
+        Do the check for concurrent use of the integrator and reset if used
+        elsewhere.
+        """
+        integrator = self._ode_solver._integrator
+        if integrator.initialized:
+            if integrator.handle != integrator.__class__.active_global_handle:
+                integrator.reset(len(self._ode_solver._y), False)
+
+    def integrate(self, t, copy=True):
+        self._check_handle()
+        if t != self._ode_solver.t:
+            self._ode_solver.integrate(t)
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        # When working with mcstep, we use the dense output feature:
+        # a range in which the state at any time can be computed with
+        # minimal work. We keep track of the range with _back and _front.
+        self._check_handle()
+        if self._ode_solver.t == t:
+            # Exact same `t` as the last call, nothing to do.
+            pass
+        elif self._back > t:
+            # `t` before the range: not supported.
+            raise IntegratorException(
+                f"`t`={t} is behind the integration limit: "
+                f"{t} < {self._back}."
+            )
+        elif t <= self._front:
+            # In the range, ask for the new state.
+            self._ode_solver.integrate(t)
+        elif self._ode_solver.t < self._front:
+            # `t` after the range but last call (`t_prev`) not at the front.
+            # Advancing the range would make the interval `t_prev`..`_front`
+            # unreachable. Thus advance to _front.
+            self._ode_solver.integrate(self._front)
+        else:
+            # Advance the range.
+            self._back = self._front
+            self._ode_solver.integrate(t, step=True)
+            self._front = self._ode_solver._integrator.rwork[12]
+
+        return self.get_state(copy)
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        messages = {
+            -1: 'Excess work done on this call. Try to increasing '
+                'the nsteps parameter in the Options class',
+            -2: 'Excess accuracy requested. (Tolerances too small.)',
+            -3: 'Illegal input detected.',
+            -4: 'Repeated error test failures. (Check all input.)',
+            -5: 'Repeated convergence failures. (Perhaps bad'
+                ' Jacobian supplied or wrong choice of MF or tolerances.)',
+            -6: 'Error weight became zero during problem. (Solution'
+                ' component i vanished, and ATOL or ATOL(i) = 0.)'
+        }
+        raise IntegratorException(
+            messages[self._ode_solver._integrator.istate]
+        )
+
+    @property
+    def options(self):
+        """
+        Supported options by zvode integrator:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        order : int, default=12, 'adams' or 5, 'bdf'
+            Order of integrator <=12 'adams', <=5 'bdf'
+
+        nsteps : int, default=2500
+            Max. number of internal steps/call.
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        min_step : float, default=0
+            Minimum step size (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+            When using pulses, change to half the thinest pulse otherwise it
+            may be skipped.
+    """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class IntegratorScipyBDF(IntegratorScipyAdams):
+    """
+    Integrator using Scipy `ode` with zvode integrator using bdf method.
+    Ordinary Differential Equation solver by netlib
+    (http://www.netlib.org/odepack).
+
+    Usable with ``method="bdf"``
+    """
+    method = 'bdf'
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'order': 5,
+        'first_step': 0,
+        'max_step': 0,
+        'min_step': 0,
+    }
+
+
+class IntegratorScipyDop853(Integrator):
+    """
+    Integrator using Scipy `ode` with dop853 integrator. Eight order
+    runge-kutta method by Dormand & Prince. Use fortran implementation
+    from [E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary Differential
+    Equations i. Nonstiff Problems. 2nd edition. Springer Series in
+    Computational Mathematics, Springer-Verlag (1993)].
+
+    Usable with ``method="dop853"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'first_step': 0,
+        'max_step': 0,
+        'ifactor': 6.0,
+        'dfactor': 0.3,
+        'beta': 0.0,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'dop853'
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        """
+        self._ode_solver = ode(self._mul_np_vec)
+        self._ode_solver.set_integrator('dop853', **self.options)
+        self.name = "scipy ode dop853"
+
+    def _mul_np_vec(self, t, vec):
+        """
+        Interface between scipy which use numpy and the driver, which use data.
+        """
+        state = _data.dense.fast_from_numpy(vec.view(np.complex128))
+        column_unstack_dense(state, self._size, inplace=True)
+        out = self.system.matmul_data(t, state)
+        column_stack_dense(out, inplace=True)
+        return out.as_ndarray().ravel().view(np.float64)
+
+    def integrate(self, t, copy=True):
+        if t != self._ode_solver.t:
+            self._ode_solver.integrate(t)
+        return self.get_state(copy)
+
+    def mcstep(self, t, copy=True):
+        if self._ode_solver.t <= t:
+            # Scipy's DOP853 does not have a step function.
+            # It has a safe step length, but can be 0 if unknown.
+            dt = self._ode_solver._integrator.work[6]
+            if dt:
+                t = min(self._ode_solver.t + dt, t)
+            self._ode_solver.integrate(t)
+        else:
+            # While DOP853 support changing the direction of the integration,
+            # it does not do so efficiently. We do it manually.
+            self._ode_solver._integrator.work[6] *= -1
+            self._ode_solver.integrate(t)
+            self._ode_solver._integrator.work[6] *= -1
+        return self.get_state(copy)
+
+    def get_state(self, copy=True):
+        if not self._is_set:
+            raise IntegratorException("The state is not initialted")
+        self._check_failed_integration()
+        t = self._ode_solver.t
+        if self._mat_state:
+            state = _data.column_unstack_dense(
+                _data.dense.Dense(self._ode_solver._y.view(np.complex128),
+                                  copy=copy),
+                self._size,
+                inplace=True)
+        else:
+            state = _data.dense.Dense(self._ode_solver._y.view(np.complex128),
+                                      copy=copy)
+        return t, state
+
+    def set_state(self, t, state0):
+        self._is_set = True
+        self._mat_state = state0.shape[1] > 1
+        self._size = state0.shape[0]
+        if self._mat_state:
+            state0 = _data.column_stack(state0)
+        self._ode_solver.set_initial_value(
+            state0.to_array().ravel().view(np.float64),
+            t
+        )
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        messages = {
+            -1: 'input is not consistent',
+            -2: 'larger nsteps is needed, Try to increase the nsteps '
+                'parameter in the Options class.',
+            -3: 'step size becomes too small. Try increasing tolerance',
+            -4: 'problem is probably stiff (interrupted), try "bdf" '
+                'method instead',
+        }
+        raise IntegratorException(
+            messages[self._ode_solver._integrator.istate]
+        )
+
+    @property
+    def options(self):
+        """
+        Supported options by dop853 integrator:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        nsteps : int, default=2500
+            Max. number of internal steps/call.
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+
+        ifactor, dfactor : float, default=6., 0.3
+            Maximum factor to increase/decrease step size by in one step
+
+        beta : float, default=0
+            Beta parameter for stabilised step size control.
+
+        See scipy.integrate.ode ode for more detail
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+class IntegratorScipylsoda(IntegratorScipyDop853):
+    """
+    Integrator using Scipy `ode` with lsoda integrator. ODE solver by netlib
+    (http://www.netlib.org/odepack) Automatically choose between 'Adams' and
+    'BDF' methods to solve both stiff and non-stiff systems.
+
+    Usable with ``method="lsoda"``
+    """
+    integrator_options = {
+        'atol': 1e-8,
+        'rtol': 1e-6,
+        'nsteps': 2500,
+        'max_order_ns': 12,
+        'max_order_s': 5,
+        'first_step': 0.0,
+        'max_step': 0.0,
+        'min_step': 0.0,
+    }
+    support_time_dependant = True
+    supports_blackbox = True
+    method = 'lsoda'
+
+    def _prepare(self):
+        """
+        Initialize the solver
+        """
+        self._ode_solver = ode(self._mul_np_vec)
+        self._ode_solver.set_integrator('lsoda', **self.options)
+        self.name = "scipy lsoda"
+
+    def _check_handle(self):
+        """
+        Do the check for concurrent use of the integrator and reset if used
+        elsewhere.
+        """
+        integrator = self._ode_solver._integrator
+        if integrator.initialized:
+            if integrator.handle != integrator.__class__.active_global_handle:
+                integrator.reset(len(self._ode_solver._y), False)
+
+    def integrate(self, t, copy=True):
+        self._check_handle()
+        return super().integrate(t, copy)
+
+    def set_state(self, t, state0):
+        self._front = t
+        super().set_state(t, state0)
+        self._back = self.get_state()
+
+    def mcstep(self, t, copy=True):
+        # This solver support dense output:
+        # a range in which the state at any time can be computed with
+        # minimal work. We keep track of the range with _back[0] and _front.
+        self._check_handle()
+        if self._ode_solver.t == t:
+            # Exact same `t` as the last call, nothing to do.
+            pass
+        elif self._back[0] <= t <= self._front:
+            # In the range, ask for the new state.
+            self._backstep(t)
+        elif self._front < t:
+            # Advance the range.
+            self._one_step(t)
+        else:
+            raise IntegratorException(
+                f"`t`={t} is behind the integration limit: "
+                f"{t} < {self._back[0]}."
+            )
+        return self.get_state(copy)
+
+    def _one_step(self, t):
+        """
+        Advance up to t by one internal solver step.
+        Should be able to retreive the state at any time between the present
+        time and the resulting time using `backstep`.
+        """
+        # Here we want to advance up to t doing maximum one step.
+        # lsoda officially support step, but sometime it does more work than
+        # needed, so we ask it to advance a fraction of the last step, where it
+        # will advance one internal step of length allowed by the tolerance and
+        # interpolate back to the asked time, effictively getting the single
+        # integration step we want. The first step and abrupt changes in the
+        # `rhs` can cause exceptions to this, but _backstep catch those cases.
+        safe_delta = self._ode_solver._integrator.rwork[11]/100 + 1e-15
+        t_ode = self._ode_solver.t
+
+        if t > self._front and t_ode >= self._front:
+            # The state is at self._front, do a step
+            self._back = self.get_state()
+            self._ode_solver.integrate(min(self._front + safe_delta, t))
+            self._front = self._ode_solver._integrator.rwork[12]
+            # We asked for a fraction of a step, now complete it.
+            self._ode_solver.integrate(min(self._front, t))
+        elif t > self._front:
+            # The state is at a time before t_front, advance to t_front
+            self._ode_solver.integrate(self._front)
+
+    def _backstep(self, t):
+        """
+        Retreive the state at time t, with t smaller than present ODE time.
+        The time t will always be between the last calls of `one_step`.
+        return the pair t, state.
+        """
+        delta = self._ode_solver._integrator.rwork[11]
+        if t == self._ode_solver.t:
+            pass
+        elif self._front - delta <= t:
+            self._ode_solver.integrate(t)
+        else:
+            self.set_state(*self._back)
+            self._ode_solver.integrate(t)
+
+    def _check_failed_integration(self):
+        if self._ode_solver.successful():
+            return
+        messages = {
+            -1: "Excess work done on this call."
+                "Try to increase the nsteps parameter in the Options class.",
+            -2: "Excess accuracy requested (tolerances too small).",
+            -3: "Illegal input detected (internal error).",
+            -4: "Repeated error test failures (internal error).",
+            -5: "Repeated convergence failures "
+                "(perhaps bad Jacobian or tolerances).",
+            -6: "Error weight became zero during problem.",
+            -7: "Internal workspace insufficient to finish (internal error)."
+        }
+        raise IntegratorException(
+            messages[self._ode_solver._integrator.istate]
+        )
+
+    @property
+    def options(self):
+        """
+        Supported options by lsoda integrator:
+
+        atol : float, default=1e-8
+            Absolute tolerance.
+
+        rtol : float, default=1e-6
+            Relative tolerance.
+
+        nsteps : int, default=2500
+            Max. number of internal steps/call.
+
+        max_order_ns : int, default=12
+            Maximum order used in the nonstiff case (<= 12).
+
+        max_order_s : int, default=5
+            Maximum order used in the stiff case (<= 5).
+
+        first_step : float, default=0
+            Size of initial step (0 = automatic).
+
+        max_step : float, default=0
+            Maximum step size (0 = automatic)
+            When using pulses, change to half the thinest pulse otherwise it
+            may be skipped.
+
+        min_step : float, default=0
+            Minimum step size (0 = automatic)
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Integrator.options.fset(self, new_options)
+
+
+Solver.add_integrator(IntegratorScipyBDF, 'bdf')
+Solver.add_integrator(IntegratorScipyAdams, 'adams')
+Solver.add_integrator(IntegratorScipyDop853, 'dop853')
+Solver.add_integrator(IntegratorScipylsoda, 'lsoda')
diff --git a/qutip/solver/integrator/verner7efficient.py b/qutip/solver/integrator/verner7efficient.py
index 3bda6a91eb..c49882a221 100644
--- a/qutip/solver/integrator/verner7efficient.py
+++ b/qutip/solver/integrator/verner7efficient.py
@@ -1,333 +1,333 @@
-"""
-Provide a cython implimentation verner 'most-efficient'
-order 7 runge-Kutta method.
-See http://people.math.sfu.ca/~jverner/
-"""
-# Verner 7 Efficient
-# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
-__all__ = ["vern7_coeff"]
-import numpy as np
-order = 7
-rk_step = 10
-rk_extra_step = 16
-denseout_order = 7
-
-bh = np.zeros(rk_step, dtype=np.float64)
-a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
-b = np.zeros(rk_step, dtype=np.float64)
-c = np.zeros(rk_extra_step, dtype=np.float64)
-e = np.zeros(rk_step, dtype=np.float64)
-bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
-
-c[0] = 0.
-c[1] = .5000000000000000000000000000000000000000e-2
-c[2] = .1088888888888888888888888888888888888889
-c[3] = .1633333333333333333333333333333333333333
-c[4] = .4555000000000000000000000000000000000000
-c[5] = .6095094489978381317087004421486024949638
-c[6] = .8840000000000000000000000000000000000000
-c[7] = .9250000000000000000000000000000000000000
-c[8] = 1.
-c[9] = 1.
-
-a[1, 0] = .5000000000000000000000000000000000000000e-2
-
-a[2, 0] = -1.076790123456790123456790123456790123457
-a[2, 1] = 1.185679012345679012345679012345679012346
-
-a[3, 0] = .4083333333333333333333333333333333333333e-1
-a[3, 1] = 0.
-a[3, 2] = .1225000000000000000000000000000000000000
-
-a[4, 0] = .6389139236255726780508121615993336109954
-a[4, 1] = 0.
-a[4, 2] = -2.455672638223656809662640566430653894211
-a[4, 3] = 2.272258714598084131611828404831320283215
-
-a[5, 0] = -2.661577375018757131119259297861818119279
-a[5, 1] = 0.
-a[5, 2] = 10.80451388645613769565396655365532838482
-a[5, 3] = -8.353914657396199411968048547819291691541
-a[5, 4] = .8204875949566569791420417341743839209619
-
-a[6, 0] = 6.067741434696770992718360183877276714679
-a[6, 1] = 0.
-a[6, 2] = -24.71127363591108579734203485290746001803
-a[6, 3] = 20.42751793078889394045773111748346612697
-a[6, 4] = -1.906157978816647150624096784352757010879
-a[6, 5] = 1.006172249242068014790040335899474187268
-
-a[7, 0] = 12.05467007625320299509109452892778311648
-a[7, 1] = 0.
-a[7, 2] = -49.75478495046898932807257615331444758322
-a[7, 3] = 41.14288863860467663259698416710157354209
-a[7, 4] = -4.461760149974004185641911603484815375051
-a[7, 5] = 2.042334822239174959821717077708608543738
-a[7, 6] = -0.9834843665406107379530801693870224403537e-1
-
-a[8, 0] = 10.13814652288180787641845141981689030769
-a[8, 1] = 0.
-a[8, 2] = -42.64113603171750214622846006736635730625
-a[8, 3] = 35.76384003992257007135021178023160054034
-a[8, 4] = -4.348022840392907653340370296908245943710
-a[8, 5] = 2.009862268377035895441943593011827554771
-a[8, 6] = .3487490460338272405953822853053145879140
-a[8, 7] = -.2714390051048312842371587140910297407572
-
-a[9, 0] = -45.03007203429867712435322405073769635151
-a[9, 1] = 0.
-a[9, 2] = 187.3272437654588840752418206154201997384
-a[9, 3] = -154.0288236935018690596728621034510402582
-a[9, 4] = 18.56465306347536233859492332958439136765
-a[9, 5] = -7.141809679295078854925420496823551192821
-a[9, 6] = 1.308808578161378625114762706007696696508
-a[9, 7] = 0.
-a[9, 8] = 0.
-
-b[0] = .4715561848627222170431765108838175679569e-1
-b[1] = 0.
-b[2] = 0.
-b[3] = .2575056429843415189596436101037687580986
-b[4] = .2621665397741262047713863095764527711129
-b[5] = .1521609265673855740323133199165117535523
-b[6] = .4939969170032484246907175893227876844296
-b[7] = -.2943031171403250441557244744092703429139
-b[8] = .8131747232495109999734599440136761892478e-1
-b[9] = 0.
-
-bh[0] = .4460860660634117628731817597479197781432e-1
-bh[1] = 0.
-bh[2] = 0.
-bh[3] = .2671640378571372680509102260943837899738
-bh[4] = .2201018300177293019979715776650753096323
-bh[5] = .2188431703143156830983120833512893824578
-bh[6] = .2289871705411202883378173889763552365362
-bh[7] = 0.
-bh[8] = 0.
-bh[9] = .2029518466335628222767054793810430358554e-1
-
-for i in range(10):
-    e[i] = b[i] - bh[i]
-
-c[10] = 1
-
-a[10, 0] = .4715561848627222170431765108838175679569e-1
-a[10, 1] = 0.
-a[10, 2] = 0.
-a[10, 3] = .2575056429843415189596436101037687580986
-a[10, 4] = .2621665397741262047713863095764527711129
-a[10, 5] = .1521609265673855740323133199165117535523
-a[10, 6] = .4939969170032484246907175893227876844296
-a[10, 7] = -.2943031171403250441557244744092703429139
-a[10, 8] = .8131747232495109999734599440136761892478e-1
-a[10, 9] = 0.
-
-c[11] = 29/100
-
-a[11, 0] = .5232227691599689815470932256735029887614e-1
-a[11, 1] = 0.
-a[11, 2] = 0.
-a[11, 3] = .2249586182670571550244187743667190903405
-a[11, 4] = .1744370924877637539031751304611402542578e-1
-a[11, 5] = -.7669379876829393188009028209348812321417e-2
-a[11, 6] = .3435896044073284645684381456417912794447e-1
-a[11, 7] = -.4102097230093949839125144540100346681769e-1
-a[11, 8] = .2565113300520561655297104906598973655221e-1
-a[11, 9] = 0.
-a[11, 10] = -.1604434570000000000000000000000000000000e-1
-
-c[12] = 1/8
-
-a[12, 0] = .5305334125785908638834747243817578898946e-1
-a[12, 1] = 0.
-a[12, 2] = 0.
-a[12, 3] = .1219530101140188607092225622195251463666
-a[12, 4] = .1774684073760249704011573985936092552347e-1
-a[12, 5] = -.5928372667681494328907467430302313286925e-3
-a[12, 6] = .8381833970853750873624781948796072714855e-2
-a[12, 7] = -.1293369259698611956700998079778496462996e-1
-a[12, 8] = .9412056815253860804791356641605087829772e-2
-a[12, 9] = 0.
-a[12, 10] = -.5353253107275676032399320754008272222345e-2
-a[12, 11] = -.6666729992455811078380186481263955324311e-1
-
-c[13] = 1/4
-
-a[13, 0] = .3887903257436303686399931060834951327899e-1
-a[13, 1] = 0.
-a[13, 2] = 0.
-a[13, 3] = -.2440320330830131517910045090190069290791e-2
-a[13, 4] = -.1392891721467262281273220992320214734208e-2
-a[13, 5] = -.4744629155868013465038358934145339168472e-3
-a[13, 6] = .3920793241315951369383517310870803393356e-3
-a[13, 7] = -.4055473328512800136385880031750264996936e-3
-a[13, 8] = .1989709314771672628794304728258886009267e-3
-a[13, 9] = 0.
-a[13, 10] = -.1027819879317916884712606136811051029682e-3
-a[13, 11] = .3385661513870266715302548402957613704604e-1
-a[13, 12] = .1814893063199928004309543737509423302792
-
-c[14] = 53/100
-
-a[14, 0] = .5723681204690012909606837582140921695189e-1
-a[14, 1] = 0.
-a[14, 2] = 0.
-a[14, 3] = .2226594806676118099285816235023183680020
-a[14, 4] = .1234486420018689904911221497830317287757
-a[14, 5] = .4006332526666490875113688731927762275433e-1
-a[14, 6] = -.5269894848581452066926326838943832327366e-1
-a[14, 7] = .4765971214244522856887315416093212596338e-1
-a[14, 8] = -.2138895885042213036387863538386958914368e-1
-a[14, 9] = 0.
-a[14, 10] = .1519389106403640165459624646184297766866e-1
-a[14, 11] = .1206054671628965554251364472502413614358
-a[14, 12] = -.2277942301618737288237298052574548913451e-1
-a[14, 13] = 0.
-
-c[15] = 79/100
-
-a[15, 0] = .5137203880275681426595607279552927584506e-1
-a[15, 1] = 0.
-a[15, 2] = 0.
-a[15, 3] = .5414214473439405582401399378307410450482
-a[15, 4] = .3503998066921840081154745647747846804810
-a[15, 5] = .1419311226969218216861835872156617148040
-a[15, 6] = .1052737747842942254816302629823570359198
-a[15, 7] = -.3108184780587401700842726199589213259835e-1
-a[15, 8] = -.7401883149519145061791854716430279714483e-2
-a[15, 9] = 0.
-a[15, 10] = -.6377932504865363437569726480040013149706e-2
-a[15, 11] = -.1732549590836186403386348310205265959935
-a[15, 12] = -.1822815677762202619429607513861847306420
-a[15, 13] = 0.
-a[15, 14] = 0.
-
-bi[0, 0] = 1.
-bi[0, 1] = -8.413387198332767469319987751201351965810
-bi[0, 2] = 33.67550888449089654479469983556967202215
-bi[0, 3] = -70.80159089484886164618905961010838757357
-bi[0, 4] = 80.64695108301297872968868805293298389704
-bi[0, 5] = -47.19413969837521580145883430419406103536
-bi[0, 6] = 11.13381344253924186418881142808952641234
-
-bi[1, 0] = 0.
-bi[1, 1] = 0.
-bi[1, 2] = 0.
-bi[1, 3] = 0.
-bi[1, 4] = 0.
-bi[1, 5] = 0.
-bi[1, 6] = 0.
-
-bi[2, 0] = 0.
-bi[2, 1] = 0.
-bi[2, 2] = 0.
-bi[2, 3] = 0.
-bi[2, 4] = 0.
-bi[2, 5] = 0.
-bi[2, 6] = 0.
-
-bi[3, 0] = 0.
-bi[3, 1] = 8.754921980674397160629587282876763437696
-bi[3, 2] = -88.45968286997709426134300934922618655402
-bi[3, 3] = 346.9017638429916309499891288356321692825
-bi[3, 4] = -629.2580030059837046812187141184986252218
-bi[3, 5] = 529.6773755604192983874116479833480529304
-bi[3, 6] = -167.3588698651401860365089970240284051167
-
-bi[4, 0] = 0.
-bi[4, 1] = 8.913387586637921662996190126913331844214
-bi[4, 2] = -90.06081846893217794712014609702916991513
-bi[4, 3] = 353.1807459217057824951538014683541349020
-bi[4, 4] = -640.6476819744374433668701027882567716886
-bi[4, 5] = 539.2646279047155261551781390920363285084
-bi[4, 6] = -170.3880944299154827945664954924414008798
-
-bi[5, 0] = 0.
-bi[5, 1] = 5.173312029847800338889849068990984974299
-bi[5, 2] = -52.27111590005538823385270070373176751689
-bi[5, 3] = 204.9853867374073094711024260808085419491
-bi[5, 4] = -371.8306118563602890875634623992262437796
-bi[5, 5] = 312.9880934374529000210073972654145891826
-bi[5, 6] = -98.89290352172494693555119599233959305606
-
-bi[6, 0] = 0.
-bi[6, 1] = 16.79537744079695986364946329034055578253
-bi[6, 2] = -169.7004000005972744435739149730966805754
-bi[6, 3] = 665.4937727009246303131700313781960584913
-bi[6, 4] = -1207.163889233600728395392916633015853882
-bi[6, 5] = 1016.129151581854603280159105697386989470
-bi[6, 6] = -321.0600155723749421933210511704882816019
-
-bi[7, 0] = 0.
-bi[7, 1] = -10.00599753609866476866352971232058330270
-bi[7, 2] = 101.1005433052275068199636113246449312792
-bi[7, 3] = -396.4739151237843754958939772727577263768
-bi[7, 4] = 719.1787707014182914108130834128646525498
-bi[7, 5] = -605.3681033918824350795711030652978269725
-bi[7, 6] = 191.2743989279793520691961908384572824802
-
-bi[8, 0] = 0.
-bi[8, 1] = 2.764708833638599139713222853969606774131
-bi[8, 2] = -27.93460263739046178114640484830267988046
-bi[8, 3] = 109.5477918613789217803046856340175757800
-bi[8, 4] = -198.7128113064482116421691972646370773711
-bi[8, 5] = 167.2663357164031670694252647113936863857
-bi[8, 6] = -52.85010499525706346613022509203974406942
-
-bi[9, 0] = 0.
-bi[9, 1] = 0.
-bi[9, 2] = 0.
-bi[9, 3] = 0.
-bi[9, 4] = 0.
-bi[9, 5] = 0.
-bi[9, 6] = 0.
-
-bi[10, 0] = 0.
-bi[10, 1] = -2.169632028016350481156919876642428429100
-bi[10, 2] = 22.01669603756987625585768587320929912766
-bi[10, 3] = -86.90152427798948350846176288615482496306
-bi[10, 4] = 159.2238897386147443720253338471077193471
-bi[10, 5] = -135.9618306534587908363115231453760181702
-bi[10, 6] = 43.79240118328000419804718618785625308759
-
-bi[11, 0] = 0.
-bi[11, 1] = -4.890070188793803933769786966428026149549
-bi[11, 2] = 22.75407737425176120799532459991506803585
-bi[11, 3] = -30.78034218537730965082079824005797506535
-bi[11, 4] = -2.797194317207249021142015125037024035537
-bi[11, 5] = 31.36945663750840183161406140272783187147
-bi[11, 6] = -15.65592732038180043387678567111987465689
-
-bi[12, 0] = 0.
-bi[12, 1] = 10.86217092955196715517224349929627754387
-bi[12, 2] = -50.54297141782710697188187875653305700081
-bi[12, 3] = 68.37148040407511827604242008548181691494
-bi[12, 4] = 6.213326521632409162585500428935637861213
-bi[12, 5] = -69.68006323194158104163196358466588618336
-bi[12, 6] = 34.77605679450919341971367832748521086414
-
-bi[13, 0] = 0.
-bi[13, 1] = -11.37286691922922915922346687401389055763
-bi[13, 2] = 130.7905807824671644130452602841032046030
-bi[13, 3] = -488.6511367778560207543260583489312609826
-bi[13, 4] = 832.2148793276440873476229585070779183432
-bi[13, 5] = -664.7743368554426242883314487337054193624
-bi[13, 6] = 201.7928804424166224412127551654694479565
-
-bi[14, 0] = 0.
-bi[14, 1] = -5.919778732715006698693070786679427540601
-bi[14, 2] = 63.27679965889218829298274978013773800731
-bi[14, 3] = -265.4326820887379575820873554556433306580
-bi[14, 4] = 520.1009254140610824835871087519714692468
-bi[14, 5] = -467.4121095339020118993777963241667608460
-bi[14, 6] = 155.3868452824017054035883640343803117904
-
-bi[15, 0] = 0.
-bi[15, 1] = -10.49214619796182281022379415510181241136
-bi[15, 2] = 105.3553852518801101042787230303396283676
-bi[15, 3] = -409.4397501198893846479834816688367917005
-bi[15, 4] = 732.8314489076540326880337353277812147333
-bi[15, 5] = -606.3044574733512377981129469949015057785
-bi[15, 6] = 188.0495196316683024640077644607192667895
-
-vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
+"""
+Provide a cython implimentation verner 'most-efficient'
+order 7 runge-Kutta method.
+See http://people.math.sfu.ca/~jverner/
+"""
+# Verner 7 Efficient
+# http://people.math.sfu.ca/~jverner/RKV76.IIa.Efficient.00001675585.081206.CoeffsOnlyFLOAT
+__all__ = ["vern7_coeff"]
+import numpy as np
+order = 7
+rk_step = 10
+rk_extra_step = 16
+denseout_order = 7
+
+bh = np.zeros(rk_step, dtype=np.float64)
+a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
+b = np.zeros(rk_step, dtype=np.float64)
+c = np.zeros(rk_extra_step, dtype=np.float64)
+e = np.zeros(rk_step, dtype=np.float64)
+bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
+
+c[0] = 0.
+c[1] = .5000000000000000000000000000000000000000e-2
+c[2] = .1088888888888888888888888888888888888889
+c[3] = .1633333333333333333333333333333333333333
+c[4] = .4555000000000000000000000000000000000000
+c[5] = .6095094489978381317087004421486024949638
+c[6] = .8840000000000000000000000000000000000000
+c[7] = .9250000000000000000000000000000000000000
+c[8] = 1.
+c[9] = 1.
+
+a[1, 0] = .5000000000000000000000000000000000000000e-2
+
+a[2, 0] = -1.076790123456790123456790123456790123457
+a[2, 1] = 1.185679012345679012345679012345679012346
+
+a[3, 0] = .4083333333333333333333333333333333333333e-1
+a[3, 1] = 0.
+a[3, 2] = .1225000000000000000000000000000000000000
+
+a[4, 0] = .6389139236255726780508121615993336109954
+a[4, 1] = 0.
+a[4, 2] = -2.455672638223656809662640566430653894211
+a[4, 3] = 2.272258714598084131611828404831320283215
+
+a[5, 0] = -2.661577375018757131119259297861818119279
+a[5, 1] = 0.
+a[5, 2] = 10.80451388645613769565396655365532838482
+a[5, 3] = -8.353914657396199411968048547819291691541
+a[5, 4] = .8204875949566569791420417341743839209619
+
+a[6, 0] = 6.067741434696770992718360183877276714679
+a[6, 1] = 0.
+a[6, 2] = -24.71127363591108579734203485290746001803
+a[6, 3] = 20.42751793078889394045773111748346612697
+a[6, 4] = -1.906157978816647150624096784352757010879
+a[6, 5] = 1.006172249242068014790040335899474187268
+
+a[7, 0] = 12.05467007625320299509109452892778311648
+a[7, 1] = 0.
+a[7, 2] = -49.75478495046898932807257615331444758322
+a[7, 3] = 41.14288863860467663259698416710157354209
+a[7, 4] = -4.461760149974004185641911603484815375051
+a[7, 5] = 2.042334822239174959821717077708608543738
+a[7, 6] = -0.9834843665406107379530801693870224403537e-1
+
+a[8, 0] = 10.13814652288180787641845141981689030769
+a[8, 1] = 0.
+a[8, 2] = -42.64113603171750214622846006736635730625
+a[8, 3] = 35.76384003992257007135021178023160054034
+a[8, 4] = -4.348022840392907653340370296908245943710
+a[8, 5] = 2.009862268377035895441943593011827554771
+a[8, 6] = .3487490460338272405953822853053145879140
+a[8, 7] = -.2714390051048312842371587140910297407572
+
+a[9, 0] = -45.03007203429867712435322405073769635151
+a[9, 1] = 0.
+a[9, 2] = 187.3272437654588840752418206154201997384
+a[9, 3] = -154.0288236935018690596728621034510402582
+a[9, 4] = 18.56465306347536233859492332958439136765
+a[9, 5] = -7.141809679295078854925420496823551192821
+a[9, 6] = 1.308808578161378625114762706007696696508
+a[9, 7] = 0.
+a[9, 8] = 0.
+
+b[0] = .4715561848627222170431765108838175679569e-1
+b[1] = 0.
+b[2] = 0.
+b[3] = .2575056429843415189596436101037687580986
+b[4] = .2621665397741262047713863095764527711129
+b[5] = .1521609265673855740323133199165117535523
+b[6] = .4939969170032484246907175893227876844296
+b[7] = -.2943031171403250441557244744092703429139
+b[8] = .8131747232495109999734599440136761892478e-1
+b[9] = 0.
+
+bh[0] = .4460860660634117628731817597479197781432e-1
+bh[1] = 0.
+bh[2] = 0.
+bh[3] = .2671640378571372680509102260943837899738
+bh[4] = .2201018300177293019979715776650753096323
+bh[5] = .2188431703143156830983120833512893824578
+bh[6] = .2289871705411202883378173889763552365362
+bh[7] = 0.
+bh[8] = 0.
+bh[9] = .2029518466335628222767054793810430358554e-1
+
+for i in range(10):
+    e[i] = b[i] - bh[i]
+
+c[10] = 1
+
+a[10, 0] = .4715561848627222170431765108838175679569e-1
+a[10, 1] = 0.
+a[10, 2] = 0.
+a[10, 3] = .2575056429843415189596436101037687580986
+a[10, 4] = .2621665397741262047713863095764527711129
+a[10, 5] = .1521609265673855740323133199165117535523
+a[10, 6] = .4939969170032484246907175893227876844296
+a[10, 7] = -.2943031171403250441557244744092703429139
+a[10, 8] = .8131747232495109999734599440136761892478e-1
+a[10, 9] = 0.
+
+c[11] = 29/100
+
+a[11, 0] = .5232227691599689815470932256735029887614e-1
+a[11, 1] = 0.
+a[11, 2] = 0.
+a[11, 3] = .2249586182670571550244187743667190903405
+a[11, 4] = .1744370924877637539031751304611402542578e-1
+a[11, 5] = -.7669379876829393188009028209348812321417e-2
+a[11, 6] = .3435896044073284645684381456417912794447e-1
+a[11, 7] = -.4102097230093949839125144540100346681769e-1
+a[11, 8] = .2565113300520561655297104906598973655221e-1
+a[11, 9] = 0.
+a[11, 10] = -.1604434570000000000000000000000000000000e-1
+
+c[12] = 1/8
+
+a[12, 0] = .5305334125785908638834747243817578898946e-1
+a[12, 1] = 0.
+a[12, 2] = 0.
+a[12, 3] = .1219530101140188607092225622195251463666
+a[12, 4] = .1774684073760249704011573985936092552347e-1
+a[12, 5] = -.5928372667681494328907467430302313286925e-3
+a[12, 6] = .8381833970853750873624781948796072714855e-2
+a[12, 7] = -.1293369259698611956700998079778496462996e-1
+a[12, 8] = .9412056815253860804791356641605087829772e-2
+a[12, 9] = 0.
+a[12, 10] = -.5353253107275676032399320754008272222345e-2
+a[12, 11] = -.6666729992455811078380186481263955324311e-1
+
+c[13] = 1/4
+
+a[13, 0] = .3887903257436303686399931060834951327899e-1
+a[13, 1] = 0.
+a[13, 2] = 0.
+a[13, 3] = -.2440320330830131517910045090190069290791e-2
+a[13, 4] = -.1392891721467262281273220992320214734208e-2
+a[13, 5] = -.4744629155868013465038358934145339168472e-3
+a[13, 6] = .3920793241315951369383517310870803393356e-3
+a[13, 7] = -.4055473328512800136385880031750264996936e-3
+a[13, 8] = .1989709314771672628794304728258886009267e-3
+a[13, 9] = 0.
+a[13, 10] = -.1027819879317916884712606136811051029682e-3
+a[13, 11] = .3385661513870266715302548402957613704604e-1
+a[13, 12] = .1814893063199928004309543737509423302792
+
+c[14] = 53/100
+
+a[14, 0] = .5723681204690012909606837582140921695189e-1
+a[14, 1] = 0.
+a[14, 2] = 0.
+a[14, 3] = .2226594806676118099285816235023183680020
+a[14, 4] = .1234486420018689904911221497830317287757
+a[14, 5] = .4006332526666490875113688731927762275433e-1
+a[14, 6] = -.5269894848581452066926326838943832327366e-1
+a[14, 7] = .4765971214244522856887315416093212596338e-1
+a[14, 8] = -.2138895885042213036387863538386958914368e-1
+a[14, 9] = 0.
+a[14, 10] = .1519389106403640165459624646184297766866e-1
+a[14, 11] = .1206054671628965554251364472502413614358
+a[14, 12] = -.2277942301618737288237298052574548913451e-1
+a[14, 13] = 0.
+
+c[15] = 79/100
+
+a[15, 0] = .5137203880275681426595607279552927584506e-1
+a[15, 1] = 0.
+a[15, 2] = 0.
+a[15, 3] = .5414214473439405582401399378307410450482
+a[15, 4] = .3503998066921840081154745647747846804810
+a[15, 5] = .1419311226969218216861835872156617148040
+a[15, 6] = .1052737747842942254816302629823570359198
+a[15, 7] = -.3108184780587401700842726199589213259835e-1
+a[15, 8] = -.7401883149519145061791854716430279714483e-2
+a[15, 9] = 0.
+a[15, 10] = -.6377932504865363437569726480040013149706e-2
+a[15, 11] = -.1732549590836186403386348310205265959935
+a[15, 12] = -.1822815677762202619429607513861847306420
+a[15, 13] = 0.
+a[15, 14] = 0.
+
+bi[0, 0] = 1.
+bi[0, 1] = -8.413387198332767469319987751201351965810
+bi[0, 2] = 33.67550888449089654479469983556967202215
+bi[0, 3] = -70.80159089484886164618905961010838757357
+bi[0, 4] = 80.64695108301297872968868805293298389704
+bi[0, 5] = -47.19413969837521580145883430419406103536
+bi[0, 6] = 11.13381344253924186418881142808952641234
+
+bi[1, 0] = 0.
+bi[1, 1] = 0.
+bi[1, 2] = 0.
+bi[1, 3] = 0.
+bi[1, 4] = 0.
+bi[1, 5] = 0.
+bi[1, 6] = 0.
+
+bi[2, 0] = 0.
+bi[2, 1] = 0.
+bi[2, 2] = 0.
+bi[2, 3] = 0.
+bi[2, 4] = 0.
+bi[2, 5] = 0.
+bi[2, 6] = 0.
+
+bi[3, 0] = 0.
+bi[3, 1] = 8.754921980674397160629587282876763437696
+bi[3, 2] = -88.45968286997709426134300934922618655402
+bi[3, 3] = 346.9017638429916309499891288356321692825
+bi[3, 4] = -629.2580030059837046812187141184986252218
+bi[3, 5] = 529.6773755604192983874116479833480529304
+bi[3, 6] = -167.3588698651401860365089970240284051167
+
+bi[4, 0] = 0.
+bi[4, 1] = 8.913387586637921662996190126913331844214
+bi[4, 2] = -90.06081846893217794712014609702916991513
+bi[4, 3] = 353.1807459217057824951538014683541349020
+bi[4, 4] = -640.6476819744374433668701027882567716886
+bi[4, 5] = 539.2646279047155261551781390920363285084
+bi[4, 6] = -170.3880944299154827945664954924414008798
+
+bi[5, 0] = 0.
+bi[5, 1] = 5.173312029847800338889849068990984974299
+bi[5, 2] = -52.27111590005538823385270070373176751689
+bi[5, 3] = 204.9853867374073094711024260808085419491
+bi[5, 4] = -371.8306118563602890875634623992262437796
+bi[5, 5] = 312.9880934374529000210073972654145891826
+bi[5, 6] = -98.89290352172494693555119599233959305606
+
+bi[6, 0] = 0.
+bi[6, 1] = 16.79537744079695986364946329034055578253
+bi[6, 2] = -169.7004000005972744435739149730966805754
+bi[6, 3] = 665.4937727009246303131700313781960584913
+bi[6, 4] = -1207.163889233600728395392916633015853882
+bi[6, 5] = 1016.129151581854603280159105697386989470
+bi[6, 6] = -321.0600155723749421933210511704882816019
+
+bi[7, 0] = 0.
+bi[7, 1] = -10.00599753609866476866352971232058330270
+bi[7, 2] = 101.1005433052275068199636113246449312792
+bi[7, 3] = -396.4739151237843754958939772727577263768
+bi[7, 4] = 719.1787707014182914108130834128646525498
+bi[7, 5] = -605.3681033918824350795711030652978269725
+bi[7, 6] = 191.2743989279793520691961908384572824802
+
+bi[8, 0] = 0.
+bi[8, 1] = 2.764708833638599139713222853969606774131
+bi[8, 2] = -27.93460263739046178114640484830267988046
+bi[8, 3] = 109.5477918613789217803046856340175757800
+bi[8, 4] = -198.7128113064482116421691972646370773711
+bi[8, 5] = 167.2663357164031670694252647113936863857
+bi[8, 6] = -52.85010499525706346613022509203974406942
+
+bi[9, 0] = 0.
+bi[9, 1] = 0.
+bi[9, 2] = 0.
+bi[9, 3] = 0.
+bi[9, 4] = 0.
+bi[9, 5] = 0.
+bi[9, 6] = 0.
+
+bi[10, 0] = 0.
+bi[10, 1] = -2.169632028016350481156919876642428429100
+bi[10, 2] = 22.01669603756987625585768587320929912766
+bi[10, 3] = -86.90152427798948350846176288615482496306
+bi[10, 4] = 159.2238897386147443720253338471077193471
+bi[10, 5] = -135.9618306534587908363115231453760181702
+bi[10, 6] = 43.79240118328000419804718618785625308759
+
+bi[11, 0] = 0.
+bi[11, 1] = -4.890070188793803933769786966428026149549
+bi[11, 2] = 22.75407737425176120799532459991506803585
+bi[11, 3] = -30.78034218537730965082079824005797506535
+bi[11, 4] = -2.797194317207249021142015125037024035537
+bi[11, 5] = 31.36945663750840183161406140272783187147
+bi[11, 6] = -15.65592732038180043387678567111987465689
+
+bi[12, 0] = 0.
+bi[12, 1] = 10.86217092955196715517224349929627754387
+bi[12, 2] = -50.54297141782710697188187875653305700081
+bi[12, 3] = 68.37148040407511827604242008548181691494
+bi[12, 4] = 6.213326521632409162585500428935637861213
+bi[12, 5] = -69.68006323194158104163196358466588618336
+bi[12, 6] = 34.77605679450919341971367832748521086414
+
+bi[13, 0] = 0.
+bi[13, 1] = -11.37286691922922915922346687401389055763
+bi[13, 2] = 130.7905807824671644130452602841032046030
+bi[13, 3] = -488.6511367778560207543260583489312609826
+bi[13, 4] = 832.2148793276440873476229585070779183432
+bi[13, 5] = -664.7743368554426242883314487337054193624
+bi[13, 6] = 201.7928804424166224412127551654694479565
+
+bi[14, 0] = 0.
+bi[14, 1] = -5.919778732715006698693070786679427540601
+bi[14, 2] = 63.27679965889218829298274978013773800731
+bi[14, 3] = -265.4326820887379575820873554556433306580
+bi[14, 4] = 520.1009254140610824835871087519714692468
+bi[14, 5] = -467.4121095339020118993777963241667608460
+bi[14, 6] = 155.3868452824017054035883640343803117904
+
+bi[15, 0] = 0.
+bi[15, 1] = -10.49214619796182281022379415510181241136
+bi[15, 2] = 105.3553852518801101042787230303396283676
+bi[15, 3] = -409.4397501198893846479834816688367917005
+bi[15, 4] = 732.8314489076540326880337353277812147333
+bi[15, 5] = -606.3044574733512377981129469949015057785
+bi[15, 6] = 188.0495196316683024640077644607192667895
+
+vern7_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
diff --git a/qutip/solver/integrator/verner9efficient.py b/qutip/solver/integrator/verner9efficient.py
index aa331a9109..02b1d92681 100644
--- a/qutip/solver/integrator/verner9efficient.py
+++ b/qutip/solver/integrator/verner9efficient.py
@@ -1,706 +1,706 @@
-"""
-Provide a cython implimentation verner 'most-efficient'
-order 9 runge-Kutta method.
-See http://people.math.sfu.ca/~jverner/
-"""
-# Verner 9 Efficient
-# http://people.math.sfu.ca/~jverner/
-
-__all__ = ["vern9_coeff"]
-import numpy as np
-order = 9
-rk_step = 16
-rk_extra_step = 26
-denseout_order = 9
-
-bh = np.zeros(rk_step, dtype=np.float64)
-a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
-b = np.zeros(rk_step, dtype=np.float64)
-c = np.zeros(rk_extra_step, dtype=np.float64)
-e = np.zeros(rk_step, dtype=np.float64)
-bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
-
-c[0] = 0.
-c[1] = .3462e-1
-c[2] = .9702435063878044594828361677100617517633e-1
-c[3] = .1455365259581706689224254251565092627645
-c[4] = .561
-c[5] = .2290079115904850126662751771814700052182
-c[6] = .5449920884095149873337248228185299947818
-c[7] = .645
-c[8] = .4837500000000000000000000000000000000000
-c[9] = .6757e-1
-c[10] = .2500
-c[11] = .6590650618730998549405331618649220295334
-c[12] = .8206
-c[13] = .9012
-c[14] = 1.
-c[15] = 1.
-
-a[1, 0] = .3462e-1
-
-a[2, 0] = -.389335438857287327017042687229284478532e-1
-a[2, 1] = .1359578945245091786499878854939346230295
-
-a[3, 0] = .3638413148954266723060635628912731569111e-1
-a[3, 1] = 0.
-a[3, 2] = .1091523944686280016918190688673819470733
-
-a[4, 0] = 2.025763914393969636805657604282571047511
-a[4, 1] = 0.
-a[4, 2] = -7.638023836496292020387602153091964592952
-a[4, 3] = 6.173259922102322383581944548809393545442
-
-a[5, 0] = .5112275589406060872792270881648288397197e-1
-a[5, 1] = 0.
-a[5, 2] = 0.
-a[5, 3] = .1770823794555021537929910813839068684087
-a[5, 4] = .80277624092225014536138698108025283759e-3
-
-a[6, 0] = .1316006357975216279279871693164256985334
-a[6, 1] = 0.
-a[6, 2] = 0.
-a[6, 3] = -.2957276252669636417685183174672273730699
-a[6, 4] = .878137803564295237421124704053886667082e-1
-a[6, 5] = .6213052975225274774321435005639430026100
-
-a[7, 0] = .7166666666666666666666666666666666666667e-1
-a[7, 1] = 0.
-a[7, 2] = 0.
-a[7, 3] = 0.
-a[7, 4] = 0.
-a[7, 5] = .3305533578915319409260346730051472207728
-a[7, 6] = .2427799754418013924072986603281861125606
-
-a[8, 0] = .7180664062500000000000000000000000000000e-1
-a[8, 1] = 0.
-a[8, 2] = 0.
-a[8, 3] = 0.
-a[8, 4] = 0.
-a[8, 5] = .3294380283228177160744825466257672816401
-a[8, 6] = .1165190029271822839255174533742327183599
-a[8, 7] = -.3401367187500000000000000000000000000000e-1
-
-a[9, 0] = .4836757646340646986611287718844085773549e-1
-a[9, 1] = 0.
-a[9, 2] = 0.
-a[9, 3] = 0.
-a[9, 4] = 0.
-a[9, 5] = .3928989925676163974333190042057047002852e-1
-a[9, 6] = .1054740945890344608263649267140088017604
-a[9, 7] = -.2143865284648312665982642293830533996214e-1
-a[9, 8] = -.1041229174627194437759832813847147895623
-
-a[10, 0] = -.2664561487201478635337289243849737340534e-1
-a[10, 1] = 0.
-a[10, 2] = 0.
-a[10, 3] = 0.
-a[10, 4] = 0.
-a[10, 5] = .3333333333333333333333333333333333333333e-1
-a[10, 6] = -.1631072244872467239162704487554706387141
-a[10, 7] = .3396081684127761199487954930015522928244e-1
-a[10, 8] = .1572319413814626097110769806810024118077
-a[10, 9] = .2152267478031879552303534778794770376960
-
-a[11, 0] = .3689009248708622334786359863227633989718e-1
-a[11, 1] = 0.
-a[11, 2] = 0.
-a[11, 3] = 0.
-a[11, 4] = 0.
-a[11, 5] = -.1465181576725542928653609891758501156785
-a[11, 6] = .2242577768172024345345469822625833796001
-a[11, 7] = .2294405717066072637090897902753790803034e-1
-a[11, 8] = -.35850052905728761357394424889330334334e-2
-a[11, 9] = .8669223316444385506869203619044453906053e-1
-a[11, 10] = .4383840651968337846196219974168630120572
-
-a[12, 0] = -.4866012215113340846662212357570395295088
-a[12, 1] = 0.
-a[12, 2] = 0.
-a[12, 3] = 0.
-a[12, 4] = 0.
-a[12, 5] = -6.304602650282852990657772792012007122988
-a[12, 6] = -.281245618289472564778284183790118418111
-a[12, 7] = -2.679019236219849057687906597489223155566
-a[12, 8] = .518815663924157511565311164615012522024
-a[12, 9] = 1.365353187603341710683633635235238678626
-a[12, 10] = 5.885091088503946585721274891680604830712
-a[12, 11] = 2.802808786272062889819965117517532194812
-
-a[13, 0] = .4185367457753471441471025246471931649633
-a[13, 1] = 0.
-a[13, 2] = 0.
-a[13, 3] = 0.
-a[13, 4] = 0.
-a[13, 5] = 6.724547581906459363100870806514855026676
-a[13, 6] = -.425444280164611790606983409697113064616
-a[13, 7] = 3.343279153001265577811816947557982637749
-a[13, 8] = .617081663117537759528421117507709784737
-a[13, 9] = -.929966123939932833937749523988800852013
-a[13, 10] = -6.099948804751010722472962837945508844846
-a[13, 11] = -3.002206187889399044804158084895173690015
-a[13, 12] = .2553202529443445472336424602988558373637
-
-a[14, 0] = -.779374086122884664644623040843840506343
-a[14, 1] = 0.
-a[14, 2] = 0.
-a[14, 3] = 0.
-a[14, 4] = 0.
-a[14, 5] = -13.93734253810777678786523664804936051203
-a[14, 6] = 1.252048853379357320949735183924200895136
-a[14, 7] = -14.69150040801686878191527989293072091588
-a[14, 8] = -.494705058533141685655191992136962873577
-a[14, 9] = 2.242974909146236657906984549543692874755
-a[14, 10] = 13.36789380382864375813864978592679139881
-a[14, 11] = 14.39665048665068644512236935340272139005
-a[14, 12] = -.7975813331776800379127866056663258667437
-a[14, 13] = .4409353709534277758753793068298041158235
-
-a[15, 0] = 2.058051337466886442151242368989994043993
-a[15, 1] = 0.
-a[15, 2] = 0.
-a[15, 3] = 0.
-a[15, 4] = 0.
-a[15, 5] = 22.35793772796803295519317565842520212899
-a[15, 6] = .90949810997556332745009198137971890783
-a[15, 7] = 35.89110098240264104710550686568482456493
-a[15, 8] = -3.442515027624453437985000403608480262211
-a[15, 9] = -4.865481358036368826566013387928704014496
-a[15, 10] = -18.90980381354342625688427480879773032857
-a[15, 11] = -34.26354448030451782929251177395134170515
-a[15, 12] = 1.264756521695642578827783499806516664686
-a[15, 13] = 0.
-a[15, 14] = 0.
-
-b[0] = .1461197685842315252051541915018784713459e-1
-b[1] = 0.
-b[2] = 0.
-b[3] = 0.
-b[4] = 0.
-b[5] = 0.
-b[6] = 0.
-b[7] = -.3915211862331339089410228267288242030810
-b[8] = .2310932500289506415909675644868993669908
-b[9] = .1274766769992852382560589467488989175618
-b[10] = .2246434176204157731566981937082069688984
-b[11] = .5684352689748512932705226972873692126743
-b[12] = .5825871557215827200814768021863420902155e-1
-b[13] = .1364317403482215641609022744494239843327
-b[14] = .3057013983082797397721005067920369646664e-1
-b[15] = 0.
-
-bh[0] = .1996996514886773085518508418098868756464e-1
-bh[1] = 0.
-bh[2] = 0.
-bh[3] = 0.
-bh[4] = 0.
-bh[5] = 0.
-bh[6] = 0.
-bh[7] = 2.191499304949330054530747099310837524864
-bh[8] = .8857071848208438030833722031786358862953e-1
-bh[9] = .1140560234865965622484956605091432032674
-bh[10] = .2533163805345107065564577734569651977347
-bh[11] = -2.056564386240941011158999594595981300493
-bh[12] = .3408096799013119935160094894224543812830
-bh[13] = 0.
-bh[14] = 0.
-bh[15] = .4834231373823958314376726739772871714902e-1
-
-for i in range(16):
-    e[i] = b[i] - bh[i]
-
-c[16] = 1.0
-
-a[16, 0] = .1461197685842315252051541915018784713459e-1
-a[16, 1] = 0.
-a[16, 2] = 0.
-a[16, 3] = 0.
-a[16, 4] = 0.
-a[16, 5] = 0.
-a[16, 6] = 0.
-a[16, 7] = -.3915211862331339089410228267288242030810
-a[16, 8] = .2310932500289506415909675644868993669908
-a[16, 9] = .1274766769992852382560589467488989175618
-a[16, 10] = .2246434176204157731566981937082069688984
-a[16, 11] = .5684352689748512932705226972873692126743
-a[16, 12] = .5825871557215827200814768021863420902155e-1
-a[16, 13] = .1364317403482215641609022744494239843327
-a[16, 14] = .3057013983082797397721005067920369646664e-1
-a[16, 15] = 0.
-
-c[17] = .7404185470631561083004100761798676215811
-
-a[17, 0] = .1549973668189559302279946863304789372788e-1
-a[17, 1] = 0.
-a[17, 2] = 0.
-a[17, 3] = 0.
-a[17, 4] = 0.
-a[17, 5] = 0.
-a[17, 6] = 0.
-a[17, 7] = .3355153219059635054403439303177105512242
-a[17, 8] = .2003613944191860651552622660712101217322
-a[17, 9] = .1252060659283549312946162355194540994211
-a[17, 10] = .2298676393184206750544046308957155868736
-a[17, 11] = -.2020250653476181447824906889122391003637
-a[17, 12] = .5917103230665456601422111997583025339897e-1
-a[17, 13] = -.2651834783047638681693835956996437528251e-1
-a[17, 14] = -.2384094602130971415278110567256446033405e-1
-a[17, 15] = 0.
-a[17, 16] = .2718171570208501807097257892166705118335e-1
-
-c[18] = .888
-
-a[18, 0] = .1302453943114338366054520296881099431474e-1
-a[18, 1] = 0.
-a[18, 2] = 0.
-a[18, 3] = 0.
-a[18, 4] = 0.
-a[18, 5] = 0.
-a[18, 6] = 0.
-a[18, 7] = -.7452850902413112085299330666038981625179
-a[18, 8] = .2643867896429300961465132150322749722129
-a[18, 9] = .1313961758372753932588328082078842388890
-a[18, 10] = .2167253815122927263092467187957410643315
-a[18, 11] = .8734117564076052559016338094938888451419
-a[18, 12] = .1185905643935776688228545787724340848142e-1
-a[18, 13] = .5876002941689550612992712203494447529933e-1
-a[18, 14] = .3266518630202087866399279690939423159022e-2
-a[18, 15] = 0.
-a[18, 16] = -.8959308648417929824525368306101792182274e-2
-a[18, 17] = .6941415157202692219907482080827253287034e-1
-
-c[19] = .696
-
-a[19, 0] = .1397089996925942721283716334050740168797e-1
-a[19, 1] = 0.
-a[19, 2] = 0.
-a[19, 3] = 0.
-a[19, 4] = 0.
-a[19, 5] = 0.
-a[19, 6] = 0.
-a[19, 7] = -.4665765335957674596054673402956853940520
-a[19, 8] = .2416372787216257077935214889875485248580
-a[19, 9] = .1290363341345674735721677437066933999929
-a[19, 10] = .2216700671735105311080225734522323922813
-a[19, 11] = .6257275123364644931771253383573999863003
-a[19, 12] = .4355312415679284117869124964829805160429e-1
-a[19, 13] = .1011962491667290833450024852274278874501
-a[19, 14] = .1808582254679721049279369742685497400353e-1
-a[19, 15] = 0.
-a[19, 16] = -.2079875587689169691156509689282083267654e-1
-a[19, 17] = -.9022232517086218976198252891464664868640e-1
-a[19, 18] = -.1212796735622254216011467740438097427634
-
-c[20] = .487
-
-a[20, 0] = .1604638888318112738641232352800290501904e-1
-a[20, 1] = 0.
-a[20, 2] = 0.
-a[20, 3] = 0.
-a[20, 4] = 0.
-a[20, 5] = 0.
-a[20, 6] = 0.
-a[20, 7] = .9517712399458336651642257453589397190702e-1
-a[20, 8] = .1359187264655317806136927180199100622471
-a[20, 9] = .1237765280959854006935081364365637515893
-a[20, 10] = .2335656264102966047058755123098072346246
-a[20, 11] = -.9051508172625873314662090873741762206189e-1
-a[20, 12] = -.2537574270006131028513276914038326155331e-1
-a[20, 13] = -.1359631696887162048002744757083947500478
-a[20, 14] = -.4679214284145113075088049469061349990847e-1
-a[20, 15] = 0.
-a[20, 16] = .5177958859391748239949773879090325427473e-1
-a[20, 17] = .9672595677476773313884172931875718705561e-1
-a[20, 18] = .1477312690340742769720989417101989769314
-a[20, 19] = -.1150750712958503934434410263732282100773
-c[21] = .25e-1
-
-a[21, 0] = .1802918623893620731908165792176564180038e-1
-a[21, 1] = 0.
-a[21, 2] = 0.
-a[21, 3] = 0.
-a[21, 4] = 0.
-a[21, 5] = 0.
-a[21, 6] = 0.
-a[21, 7] = .6983601042028873702545973390560096201728e-1
-a[21, 8] = -.2541247660791663512384395986842781657182e-1
-a[21, 9] = .8487827035463274491721441398893680307535e-2
-a[21, 10] = -.2427525516089801645451101966852425715128e-2
-a[21, 11] = -.1047839752893819879012607694745789515746
-a[21, 12] = -.1473147795248041942353840372690095884761e-1
-a[21, 13] = -.3916338390816177165706892282751065537530e-1
-a[21, 14] = -.1005657343293959419073236542225421561652e-1
-a[21, 15] = 0.
-a[21, 16] = .1102510392204834322538452331445716455061e-1
-a[21, 17] = .5092830749095398308703438556315975226108e-2
-a[21, 18] = .4759715599420644505591133410826632557391e-1
-a[21, 19] = .3386307003288382751110965442296681690349e-1
-a[21, 20] = .2764422831404797700452373965825845732168e-1
-
-c[22] = .15
-
-a[22, 0] = .1677431640522778042988664067637191163626e-1
-a[22, 1] = 0.
-a[22, 2] = 0.
-a[22, 3] = 0.
-a[22, 4] = 0.
-a[22, 5] = 0.
-a[22, 6] = 0.
-a[22, 7] = .6220437408820475326702539861577894278533
-a[22, 8] = -.2060859809768841878234097076241307428139
-a[22, 9] = .1156394989766058889629372195583391792474
-a[22, 10] = .2664101793378358946544219293685167025971e-1
-a[22, 11] = -.9376810793418770527505892794460093668860
-a[22, 12] = -.1367806466702160302637074581619101741312
-a[22, 13] = -.3678480995268296672182605288991379118419
-a[22, 14] = -.9547871314402478902820445838193201497337e-1
-a[22, 15] = 0.
-a[22, 16] = .1013492018422369748729008873270013785313
-a[22, 17] = -.8911323084568593396468400926074881389560e-1
-a[22, 18] = .4664140988974760478895528270623735057521
-a[22, 19] = .4502736292354579812232681662308722738519
-a[22, 20] = .1838522463326818655346135218242696774099
-a[22, 21] = 0.
-
-c[23] = .32
-
-a[23, 0] = .1071149731491444187554380927165768658192e-1
-a[23, 1] = 0.
-a[23, 2] = 0.
-a[23, 3] = 0.
-a[23, 4] = 0.
-a[23, 5] = 0.
-a[23, 6] = 0.
-a[23, 7] = -.7094336118221108191937165464264324417735e-1
-a[23, 8] = .1002164900340091596740582334112699697590
-a[23, 9] = .1383453980468025108839271214703390659581
-a[23, 10] = .1796330633578163411338104055485109917477
-a[23, 11] = .9048246545576180974879274948815422276563e-1
-a[23, 12] = -.5460662294523338383345981122023862069115e-2
-a[23, 13] = -.3000457905119619782973021046143166498567e-1
-a[23, 14] = -.1145192026962799093665613252151017277867e-1
-a[23, 15] = 0.
-a[23, 16] = .1003394686109385076849515422360600302176e-1
-a[23, 17] = -.9506485282809046129031027932806241113157e-1
-a[23, 18] = .4853358804093591445756711642658478691640e-1
-a[23, 19] = .8013325919783924638483373011297347396327e-1
-a[23, 20] = -.1251643326835242045676140618774248455713
-a[23, 21] = 0.
-a[23, 22] = 0.
-
-c[24] = .78
-
-a[24, 0] = .1410172088869221367153586187761994182069e-1
-a[24, 1] = 0.
-a[24, 2] = 0.
-a[24, 3] = 0.
-a[24, 4] = 0.
-a[24, 5] = 0.
-a[24, 6] = 0.
-a[24, 7] = -.3713379753704491105936205420001801316029
-a[24, 8] = .2231265548117180273161442520179150684520
-a[24, 9] = .1287005345918120122888629169443916280865
-a[24, 10] = .2224600659675494761192249831098918110654
-a[24, 11] = .5382853042550701952740528638168708946100
-a[24, 12] = .5417202616988763101781128062036252796548e-1
-a[24, 13] = .1256968791308743925752109039299467082975
-a[24, 14] = .2784492789002054061504430663197543089132e-1
-a[24, 15] = 0.
-a[24, 16] = -.3077409246205059733390460511525401688205e-1
-a[24, 17] = .8569805293689777608077303071761466118035e-2
-a[24, 18] = -.1535174690587044615794997685221990516897
-a[24, 19] = -.2179957030548196497189489878038029238243e-1
-a[24, 20] = .1447128819737186799295514239727801525027e-1
-a[24, 21] = 0.
-a[24, 22] = 0.
-a[24, 23] = 0.
-
-c[25] = .96
-
-a[25, 0] = .1424600411735646609296566581447532773183e-1
-a[25, 1] = 0.
-a[25, 2] = 0.
-a[25, 3] = 0.
-a[25, 4] = 0.
-a[25, 5] = 0.
-a[25, 6] = 0.
-a[25, 7] = -.3767107393295407091303982522049390741260
-a[25, 8] = .2252399780730421480874737297000189000070
-a[25, 9] = .1283603076292529988314451246143633426068
-a[25, 10] = .2230238705261692544876826347415151339678
-a[25, 11] = .5463127827750747224899202176094949607118
-a[25, 12] = .5526190791375779994553849469706124289752e-1
-a[25, 13] = .1285613508749982456581494397108686240388
-a[25, 14] = .2857250681296406482698934635829147899039e-1
-a[25, 15] = 0.
-a[25, 16] = -.2398761886357108720930416967644499057175e-1
-a[25, 17] = .5556224458910509454379297181908734648749e-1
-a[25, 18] = -.1740675650762838674257930398070760254668e-1
-a[25, 19] = -.3815462365996979065575121886854199471011e-1
-a[25, 20] = .1111878504898917877407531966545730451506e-1
-a[25, 21] = 0.
-a[25, 22] = 0.
-a[25, 23] = 0.
-a[25, 24] = 0.
-
-bi[0, 0] = 1.
-bi[0, 1] = -28.33048870061739823290767301658881994700
-bi[0, 2] = 257.6535452078577977252092979905248156497
-bi[0, 3] = -1152.154455743457311528752964691951881858
-bi[0, 4] = 2909.390878345408890936564599116550031880
-bi[0, 5] = -4355.005172868188498048946108887283528629
-bi[0, 6] = 3834.083497036262189455855371796461857871
-bi[0, 7] = -1835.419052683407081215583427992189311730
-bi[0, 8] = 368.7958613829998340610814211036270246107
-
-bi[1, 0] = 0.
-bi[1, 1] = 0.
-bi[1, 2] = 0.
-bi[1, 3] = 0.
-bi[1, 4] = 0.
-bi[1, 5] = 0.
-bi[1, 6] = 0.
-bi[1, 7] = 0.
-bi[1, 8] = 0.
-
-bi[2, 0] = 0.
-bi[2, 1] = 0.
-bi[2, 2] = 0.
-bi[2, 3] = 0.
-bi[2, 4] = 0.
-bi[2, 5] = 0.
-bi[2, 6] = 0.
-bi[2, 7] = 0.
-bi[2, 8] = 0.
-
-bi[3, 0] = 0.
-bi[3, 1] = 0.
-bi[3, 2] = 0.
-bi[3, 3] = 0.
-bi[3, 4] = 0.
-bi[3, 5] = 0.
-bi[3, 6] = 0.
-bi[3, 7] = 0.
-bi[3, 8] = 0.
-
-bi[4, 0] = 0.
-bi[4, 1] = 0.
-bi[4, 2] = 0.
-bi[4, 3] = 0.
-bi[4, 4] = 0.
-bi[4, 5] = 0.
-bi[4, 6] = 0.
-bi[4, 7] = 0.
-bi[4, 8] = 0.
-
-bi[5, 0] = 0.
-bi[5, 1] = 0.
-bi[5, 2] = 0.
-bi[5, 3] = 0.
-bi[5, 4] = 0.
-bi[5, 5] = 0.
-bi[5, 6] = 0.
-bi[5, 7] = 0.
-bi[5, 8] = 0.
-
-bi[6, 0] = 0.
-bi[6, 1] = 0.
-bi[6, 2] = 0.
-bi[6, 3] = 0.
-bi[6, 4] = 0.
-bi[6, 5] = 0.
-bi[6, 6] = 0.
-bi[6, 7] = 0.
-bi[6, 8] = 0.
-
-bi[7, 0] = 0.
-bi[7, 1] = 2.649656243770091212685381903551424676261
-bi[7, 2] = -96.30312807816005963630382777245983513008
-bi[7, 3] = 869.3095462492795755338599928089438369769
-bi[7, 4] = -3395.688567551074115525201961265641584358
-bi[7, 5] = 6796.933987158715680563278170147156885480
-bi[7, 6] = -7340.848417712071304684606060804637321789
-bi[7, 7] = 4082.848896992365666259441580054990759905
-bi[7, 8] = -919.2934944890586676320942978986329899642
-
-bi[8, 0] = 0.
-bi[8, 1] = -1.563945181928732780647121505551017046606
-bi[8, 2] = 56.84239739272860000194549791973820565214
-bi[8, 3] = -513.1052300304284642178552372517916694426
-bi[8, 4] = 2004.286702110323162741493515173880535381
-bi[8, 5] = -4011.853305913929339500285683507736138334
-bi[8, 6] = 4332.895839278586189971336003691596594090
-bi[8, 7] = -2409.879347937144606091337260195738587773
-bi[8, 8] = 542.6079835318221405169412532400889768401
-
-bi[9, 0] = 0.
-bi[9, 1] = -.8627103334967223830653368770735555216700
-bi[9, 2] = 31.35565375185173442495465167501846267906
-bi[9, 3] = -283.0413682227354209126847112083546012674
-bi[9, 4] = 1105.613463426006937052739159664962261462
-bi[9, 5] = -2213.036200678452629288185991597653042989
-bi[9, 6] = 2390.131097754120588994847482867886207858
-bi[9, 7] = -1329.348266146873716496636094950745123424
-bi[9, 8] = 299.3158071265785138462868993727082901209
-
-bi[10, 0] = 0.
-bi[10, 1] = -1.520295337901214839055193576160469820911
-bi[10, 2] = 55.25592121120227100440616045452813504748
-bi[10, 3] = -498.7844190970740738969945498750124435385
-bi[10, 4] = 1948.346888525776056658403461666308795237
-bi[10, 5] = -3899.882136407551390287649940376076923682
-bi[10, 6] = 4211.964345158858030803618536151121927765
-bi[10, 7] = -2342.619408856117128087568672414857706561
-bi[10, 8] = 527.4637482204278644179968961638568925209
-
-bi[11, 0] = 0.
-bi[11, 1] = -3.846938844125523400516071820264700141179
-bi[11, 2] = 139.8189840986840520353362018994734906611
-bi[11, 3] = -1262.118687621600386514715930156791825893
-bi[11, 4] = 4930.075848057311658057235318456802793199
-bi[11, 5] = -9868.219486069539059368988308801366826185
-bi[11, 6] = 10657.90892434886730229746304583865145121
-bi[11, 7] = -5927.738759872814112912292792695856187255
-bi[11, 8] = 1334.688551172190921099749059976639173619
-
-bi[12, 0] = 0.
-bi[12, 1] = -.3942713061200141454309326713125653612517
-bi[12, 2] = 14.32999476067649707020689155180345562459
-bi[12, 3] = -129.3540665994558117853022852051786116929
-bi[12, 4] = 505.2816077002517600897861155496606850457
-bi[12, 5] = -1011.390080139433268878243655218566636574
-bi[12, 6] = 1092.325051781891697669369143688906543465
-bi[12, 7] = -607.5317019302810290917918493845279272648
-bi[12, 8] = 136.7917244480423273434147193694336909663
-
-bi[13, 0] = 0.
-bi[13, 1] = -.9233145622082101394378429409444333268499
-bi[13, 2] = 33.55834582309798808260613735851232640640
-bi[13, 3] = -302.9246397549735936661321348695774835448
-bi[13, 4] = 1183.281306967867553342903125095128753568
-bi[13, 5] = -2368.498986790111516106072390247333149007
-bi[13, 6] = 2558.034559755808027369106332027405169828
-bi[13, 7] = -1422.733175577880214903071122439856598476
-bi[13, 8] = 320.3423358787481875842587982911148385364
-
-bi[14, 0] = 0.
-bi[14, 1] = -.2068862802930053801253649628830330891017
-bi[14, 2] = 7.519388975651662772174695012120581518594
-bi[14, 3] = -67.87605708082904058354114755731111898667
-bi[14, 4] = 265.1367996984150421661637988925923843021
-bi[14, 5] = -530.7074807559025368587558119659212235622
-bi[14, 6] = 573.1765495641490277116961329189087439579
-bi[14, 7] = -318.7905688834868978004500126002971837241
-bi[14, 8] = 71.77882490212657594681492031347005327988
-
-bi[15, 0] = 0.
-bi[15, 1] = 0.
-bi[15, 2] = 0.
-bi[15, 3] = 0.
-bi[15, 4] = 0.
-bi[15, 5] = 0.
-bi[15, 6] = 0.
-bi[15, 7] = 0.
-bi[15, 8] = 0.
-
-bi[16, 0] = 0.
-bi[16, 1] = -.4472441906744099441704338175964823026105
-bi[16, 2] = 16.44684676010503791623763886833381020592
-bi[16, 3] = -154.4086105921295528355180056633078150675
-bi[16, 4] = 641.8986298540248497333509289273669726482
-bi[16, 5] = -1391.939225687982391028602609567895699003
-bi[16, 6] = 1643.890568302952013019278202625162156841
-bi[16, 7] = -1004.065297223317845596795060426393517046
-bi[16, 8] = 248.6243327770222987362193390543305737239
-
-bi[17, 0] = 0.
-bi[17, 1] = -.1507876007899797948720901584434839156279
-bi[17, 2] = 5.527328824824632235316362126620825363280
-bi[17, 3] = -51.33833743084618751433903968701557585387
-bi[17, 4] = 209.6022002703280347991393999433060881829
-bi[17, 5] = -442.7692650421825928714839983614217797969
-bi[17, 6] = 505.0579312588052893780948070449787925777
-bi[17, 7] = -295.6336410615619366143935619944592839974
-bi[17, 8] = 69.70457078142274038253812108643441743987
-
-bi[18, 0] = 0.
-bi[18, 1] = -.6413652207435296452288504944964177537185
-bi[18, 2] = 23.51013248624684600263471193689787394701
-bi[18, 3] = -218.3642683246972281497485359238725613162
-bi[18, 4] = 891.5292818535365634586829868055833114383
-bi[18, 5] = -1883.290177206007885518558760085145850658
-bi[18, 6] = 2148.230954488399755970660772306573864434
-bi[18, 7] = -1257.458401521712336970840850120592935471
-bi[18, 8] = 296.4838434449778148523985255750527153802
-
-bi[19, 0] = 0.
-bi[19, 1] = 1.810729313444845732964058528284532356045
-bi[19, 2] = -66.37479657295337371220255196726289169374
-bi[19, 3] = 616.4952025401106511929691356878863855003
-bi[19, 4] = -2517.003030777322559684753470471663859295
-bi[19, 5] = 5316.984175781033401491488704359579721604
-bi[19, 6] = -6064.976140789574108556866601189158423779
-bi[19, 7] = 3550.109538888391317555902194852386816092
-bi[19, 8] = -837.0456783831301740195014698000522807852
-
-bi[20, 0] = 0.
-bi[20, 1] = .5176008760353717918864555990277480363987e-1
-bi[20, 2] = -1.897337862580348756406065418550014243949
-bi[20, 3] = 17.62264820793629244181715147639285955422
-bi[20, 4] = -71.94907400242465946110661282550878163878
-bi[20, 5] = 151.9871383765666045085018751235590550206
-bi[20, 6] = -173.3686498747860565970136435029707518663
-bi[20, 7] = 101.4806461521468075879782291473158292931
-bi[20, 8] = -23.92713108446217690295957956014097092250
-
-bi[21, 0] = 0.
-bi[21, 1] = 31.32178255668799909977422939838912846070
-bi[21, 2] = -355.6570858339106059687054319211280026146
-bi[21, 3] = 1752.685282489515979253875884672206842255
-bi[21, 4] = -4708.092293138363367969732154806019707156
-bi[21, 5] = 7370.900776193488713149861391844801840850
-bi[21, 6] = -6716.504964764565347011489385051202629762
-bi[21, 7] = 3303.940398161185772296756776169088470785
-bi[21, 8] = -678.5938956640391428503413103061359428182
-
-bi[22, 0] = 0.
-bi[22, 1] = -2.719607334185924760747802644504744092917
-bi[22, 2] = 86.64045615858264001154848875638486632034
-bi[22, 3] = -454.1926030939030807863651114984001402596
-bi[22, 4] = 1014.749221100543425314268817989377200147
-bi[22, 5] = -1133.583456714543865890388885909333783663
-bi[22, 6] = 610.4671827718666569168001429679645990946
-bi[22, 7] = -109.0233499449543802317396567002119357593
-bi[22, 8] = -12.33784294340547057337599296127606178639
-
-bi[23, 0] = 0.
-bi[23, 1] = 3.177214801432923432265738869490200556403
-bi[23, 2] = -113.8098697715142983214434051918276259885
-bi[23, 3] = 978.0935981825675014833003847211971070224
-bi[23, 4] = -3575.129377623670076451027372711378100786
-bi[23, 5] = 6764.361519838450570830405988615992045681
-bi[23, 6] = -6987.161043852012362644872233028628887679
-bi[23, 7] = 3751.905762789571137088934326513342858381
-bi[23, 8] = -821.4378043648253954175634277881875971878
-
-bi[24, 0] = 0.
-bi[24, 1] = .8772843083465530069477626269697233842708
-bi[24, 2] = -31.51810423988375104361582759389916060143
-bi[24, 3] = 273.1229151353221133842213845530391043248
-bi[24, 4] = -993.2198643101781966584366870874238565290
-bi[24, 5] = 1787.888078312663987193988385659681964836
-bi[24, 6] = -1677.394835799640950953367739332661886275
-bi[24, 7] = 781.3579535062687952504707744453846824540
-bi[24, 8] = -141.1134269128985501802080532710905715931
-
-bi[25, 0] = 0.
-bi[25, 1] = 1.719427581798715782378897599231938082126
-bi[25, 2] = -62.89867309250732184389962568482931880335
-bi[25, 3] = 580.3335507873980391019057196688995930872
-bi[25, 4] = -2348.110620506760958600472968113883922730
-bi[25, 5] = 4921.119298612906015908637628774963068611
-bi[25, 6] = -5597.912448707916639109910311016358007839
-bi[25, 7] = 3288.597775149621789973016480733216881572
-bi[25, 8] = -782.8483098245396412116558219612402319811
-
-vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
+"""
+Provide a cython implimentation verner 'most-efficient'
+order 9 runge-Kutta method.
+See http://people.math.sfu.ca/~jverner/
+"""
+# Verner 9 Efficient
+# http://people.math.sfu.ca/~jverner/
+
+__all__ = ["vern9_coeff"]
+import numpy as np
+order = 9
+rk_step = 16
+rk_extra_step = 26
+denseout_order = 9
+
+bh = np.zeros(rk_step, dtype=np.float64)
+a = np.zeros((rk_extra_step, rk_extra_step), dtype=np.float64)
+b = np.zeros(rk_step, dtype=np.float64)
+c = np.zeros(rk_extra_step, dtype=np.float64)
+e = np.zeros(rk_step, dtype=np.float64)
+bi = np.zeros((rk_extra_step, denseout_order), dtype=np.float64)
+
+c[0] = 0.
+c[1] = .3462e-1
+c[2] = .9702435063878044594828361677100617517633e-1
+c[3] = .1455365259581706689224254251565092627645
+c[4] = .561
+c[5] = .2290079115904850126662751771814700052182
+c[6] = .5449920884095149873337248228185299947818
+c[7] = .645
+c[8] = .4837500000000000000000000000000000000000
+c[9] = .6757e-1
+c[10] = .2500
+c[11] = .6590650618730998549405331618649220295334
+c[12] = .8206
+c[13] = .9012
+c[14] = 1.
+c[15] = 1.
+
+a[1, 0] = .3462e-1
+
+a[2, 0] = -.389335438857287327017042687229284478532e-1
+a[2, 1] = .1359578945245091786499878854939346230295
+
+a[3, 0] = .3638413148954266723060635628912731569111e-1
+a[3, 1] = 0.
+a[3, 2] = .1091523944686280016918190688673819470733
+
+a[4, 0] = 2.025763914393969636805657604282571047511
+a[4, 1] = 0.
+a[4, 2] = -7.638023836496292020387602153091964592952
+a[4, 3] = 6.173259922102322383581944548809393545442
+
+a[5, 0] = .5112275589406060872792270881648288397197e-1
+a[5, 1] = 0.
+a[5, 2] = 0.
+a[5, 3] = .1770823794555021537929910813839068684087
+a[5, 4] = .80277624092225014536138698108025283759e-3
+
+a[6, 0] = .1316006357975216279279871693164256985334
+a[6, 1] = 0.
+a[6, 2] = 0.
+a[6, 3] = -.2957276252669636417685183174672273730699
+a[6, 4] = .878137803564295237421124704053886667082e-1
+a[6, 5] = .6213052975225274774321435005639430026100
+
+a[7, 0] = .7166666666666666666666666666666666666667e-1
+a[7, 1] = 0.
+a[7, 2] = 0.
+a[7, 3] = 0.
+a[7, 4] = 0.
+a[7, 5] = .3305533578915319409260346730051472207728
+a[7, 6] = .2427799754418013924072986603281861125606
+
+a[8, 0] = .7180664062500000000000000000000000000000e-1
+a[8, 1] = 0.
+a[8, 2] = 0.
+a[8, 3] = 0.
+a[8, 4] = 0.
+a[8, 5] = .3294380283228177160744825466257672816401
+a[8, 6] = .1165190029271822839255174533742327183599
+a[8, 7] = -.3401367187500000000000000000000000000000e-1
+
+a[9, 0] = .4836757646340646986611287718844085773549e-1
+a[9, 1] = 0.
+a[9, 2] = 0.
+a[9, 3] = 0.
+a[9, 4] = 0.
+a[9, 5] = .3928989925676163974333190042057047002852e-1
+a[9, 6] = .1054740945890344608263649267140088017604
+a[9, 7] = -.2143865284648312665982642293830533996214e-1
+a[9, 8] = -.1041229174627194437759832813847147895623
+
+a[10, 0] = -.2664561487201478635337289243849737340534e-1
+a[10, 1] = 0.
+a[10, 2] = 0.
+a[10, 3] = 0.
+a[10, 4] = 0.
+a[10, 5] = .3333333333333333333333333333333333333333e-1
+a[10, 6] = -.1631072244872467239162704487554706387141
+a[10, 7] = .3396081684127761199487954930015522928244e-1
+a[10, 8] = .1572319413814626097110769806810024118077
+a[10, 9] = .2152267478031879552303534778794770376960
+
+a[11, 0] = .3689009248708622334786359863227633989718e-1
+a[11, 1] = 0.
+a[11, 2] = 0.
+a[11, 3] = 0.
+a[11, 4] = 0.
+a[11, 5] = -.1465181576725542928653609891758501156785
+a[11, 6] = .2242577768172024345345469822625833796001
+a[11, 7] = .2294405717066072637090897902753790803034e-1
+a[11, 8] = -.35850052905728761357394424889330334334e-2
+a[11, 9] = .8669223316444385506869203619044453906053e-1
+a[11, 10] = .4383840651968337846196219974168630120572
+
+a[12, 0] = -.4866012215113340846662212357570395295088
+a[12, 1] = 0.
+a[12, 2] = 0.
+a[12, 3] = 0.
+a[12, 4] = 0.
+a[12, 5] = -6.304602650282852990657772792012007122988
+a[12, 6] = -.281245618289472564778284183790118418111
+a[12, 7] = -2.679019236219849057687906597489223155566
+a[12, 8] = .518815663924157511565311164615012522024
+a[12, 9] = 1.365353187603341710683633635235238678626
+a[12, 10] = 5.885091088503946585721274891680604830712
+a[12, 11] = 2.802808786272062889819965117517532194812
+
+a[13, 0] = .4185367457753471441471025246471931649633
+a[13, 1] = 0.
+a[13, 2] = 0.
+a[13, 3] = 0.
+a[13, 4] = 0.
+a[13, 5] = 6.724547581906459363100870806514855026676
+a[13, 6] = -.425444280164611790606983409697113064616
+a[13, 7] = 3.343279153001265577811816947557982637749
+a[13, 8] = .617081663117537759528421117507709784737
+a[13, 9] = -.929966123939932833937749523988800852013
+a[13, 10] = -6.099948804751010722472962837945508844846
+a[13, 11] = -3.002206187889399044804158084895173690015
+a[13, 12] = .2553202529443445472336424602988558373637
+
+a[14, 0] = -.779374086122884664644623040843840506343
+a[14, 1] = 0.
+a[14, 2] = 0.
+a[14, 3] = 0.
+a[14, 4] = 0.
+a[14, 5] = -13.93734253810777678786523664804936051203
+a[14, 6] = 1.252048853379357320949735183924200895136
+a[14, 7] = -14.69150040801686878191527989293072091588
+a[14, 8] = -.494705058533141685655191992136962873577
+a[14, 9] = 2.242974909146236657906984549543692874755
+a[14, 10] = 13.36789380382864375813864978592679139881
+a[14, 11] = 14.39665048665068644512236935340272139005
+a[14, 12] = -.7975813331776800379127866056663258667437
+a[14, 13] = .4409353709534277758753793068298041158235
+
+a[15, 0] = 2.058051337466886442151242368989994043993
+a[15, 1] = 0.
+a[15, 2] = 0.
+a[15, 3] = 0.
+a[15, 4] = 0.
+a[15, 5] = 22.35793772796803295519317565842520212899
+a[15, 6] = .90949810997556332745009198137971890783
+a[15, 7] = 35.89110098240264104710550686568482456493
+a[15, 8] = -3.442515027624453437985000403608480262211
+a[15, 9] = -4.865481358036368826566013387928704014496
+a[15, 10] = -18.90980381354342625688427480879773032857
+a[15, 11] = -34.26354448030451782929251177395134170515
+a[15, 12] = 1.264756521695642578827783499806516664686
+a[15, 13] = 0.
+a[15, 14] = 0.
+
+b[0] = .1461197685842315252051541915018784713459e-1
+b[1] = 0.
+b[2] = 0.
+b[3] = 0.
+b[4] = 0.
+b[5] = 0.
+b[6] = 0.
+b[7] = -.3915211862331339089410228267288242030810
+b[8] = .2310932500289506415909675644868993669908
+b[9] = .1274766769992852382560589467488989175618
+b[10] = .2246434176204157731566981937082069688984
+b[11] = .5684352689748512932705226972873692126743
+b[12] = .5825871557215827200814768021863420902155e-1
+b[13] = .1364317403482215641609022744494239843327
+b[14] = .3057013983082797397721005067920369646664e-1
+b[15] = 0.
+
+bh[0] = .1996996514886773085518508418098868756464e-1
+bh[1] = 0.
+bh[2] = 0.
+bh[3] = 0.
+bh[4] = 0.
+bh[5] = 0.
+bh[6] = 0.
+bh[7] = 2.191499304949330054530747099310837524864
+bh[8] = .8857071848208438030833722031786358862953e-1
+bh[9] = .1140560234865965622484956605091432032674
+bh[10] = .2533163805345107065564577734569651977347
+bh[11] = -2.056564386240941011158999594595981300493
+bh[12] = .3408096799013119935160094894224543812830
+bh[13] = 0.
+bh[14] = 0.
+bh[15] = .4834231373823958314376726739772871714902e-1
+
+for i in range(16):
+    e[i] = b[i] - bh[i]
+
+c[16] = 1.0
+
+a[16, 0] = .1461197685842315252051541915018784713459e-1
+a[16, 1] = 0.
+a[16, 2] = 0.
+a[16, 3] = 0.
+a[16, 4] = 0.
+a[16, 5] = 0.
+a[16, 6] = 0.
+a[16, 7] = -.3915211862331339089410228267288242030810
+a[16, 8] = .2310932500289506415909675644868993669908
+a[16, 9] = .1274766769992852382560589467488989175618
+a[16, 10] = .2246434176204157731566981937082069688984
+a[16, 11] = .5684352689748512932705226972873692126743
+a[16, 12] = .5825871557215827200814768021863420902155e-1
+a[16, 13] = .1364317403482215641609022744494239843327
+a[16, 14] = .3057013983082797397721005067920369646664e-1
+a[16, 15] = 0.
+
+c[17] = .7404185470631561083004100761798676215811
+
+a[17, 0] = .1549973668189559302279946863304789372788e-1
+a[17, 1] = 0.
+a[17, 2] = 0.
+a[17, 3] = 0.
+a[17, 4] = 0.
+a[17, 5] = 0.
+a[17, 6] = 0.
+a[17, 7] = .3355153219059635054403439303177105512242
+a[17, 8] = .2003613944191860651552622660712101217322
+a[17, 9] = .1252060659283549312946162355194540994211
+a[17, 10] = .2298676393184206750544046308957155868736
+a[17, 11] = -.2020250653476181447824906889122391003637
+a[17, 12] = .5917103230665456601422111997583025339897e-1
+a[17, 13] = -.2651834783047638681693835956996437528251e-1
+a[17, 14] = -.2384094602130971415278110567256446033405e-1
+a[17, 15] = 0.
+a[17, 16] = .2718171570208501807097257892166705118335e-1
+
+c[18] = .888
+
+a[18, 0] = .1302453943114338366054520296881099431474e-1
+a[18, 1] = 0.
+a[18, 2] = 0.
+a[18, 3] = 0.
+a[18, 4] = 0.
+a[18, 5] = 0.
+a[18, 6] = 0.
+a[18, 7] = -.7452850902413112085299330666038981625179
+a[18, 8] = .2643867896429300961465132150322749722129
+a[18, 9] = .1313961758372753932588328082078842388890
+a[18, 10] = .2167253815122927263092467187957410643315
+a[18, 11] = .8734117564076052559016338094938888451419
+a[18, 12] = .1185905643935776688228545787724340848142e-1
+a[18, 13] = .5876002941689550612992712203494447529933e-1
+a[18, 14] = .3266518630202087866399279690939423159022e-2
+a[18, 15] = 0.
+a[18, 16] = -.8959308648417929824525368306101792182274e-2
+a[18, 17] = .6941415157202692219907482080827253287034e-1
+
+c[19] = .696
+
+a[19, 0] = .1397089996925942721283716334050740168797e-1
+a[19, 1] = 0.
+a[19, 2] = 0.
+a[19, 3] = 0.
+a[19, 4] = 0.
+a[19, 5] = 0.
+a[19, 6] = 0.
+a[19, 7] = -.4665765335957674596054673402956853940520
+a[19, 8] = .2416372787216257077935214889875485248580
+a[19, 9] = .1290363341345674735721677437066933999929
+a[19, 10] = .2216700671735105311080225734522323922813
+a[19, 11] = .6257275123364644931771253383573999863003
+a[19, 12] = .4355312415679284117869124964829805160429e-1
+a[19, 13] = .1011962491667290833450024852274278874501
+a[19, 14] = .1808582254679721049279369742685497400353e-1
+a[19, 15] = 0.
+a[19, 16] = -.2079875587689169691156509689282083267654e-1
+a[19, 17] = -.9022232517086218976198252891464664868640e-1
+a[19, 18] = -.1212796735622254216011467740438097427634
+
+c[20] = .487
+
+a[20, 0] = .1604638888318112738641232352800290501904e-1
+a[20, 1] = 0.
+a[20, 2] = 0.
+a[20, 3] = 0.
+a[20, 4] = 0.
+a[20, 5] = 0.
+a[20, 6] = 0.
+a[20, 7] = .9517712399458336651642257453589397190702e-1
+a[20, 8] = .1359187264655317806136927180199100622471
+a[20, 9] = .1237765280959854006935081364365637515893
+a[20, 10] = .2335656264102966047058755123098072346246
+a[20, 11] = -.9051508172625873314662090873741762206189e-1
+a[20, 12] = -.2537574270006131028513276914038326155331e-1
+a[20, 13] = -.1359631696887162048002744757083947500478
+a[20, 14] = -.4679214284145113075088049469061349990847e-1
+a[20, 15] = 0.
+a[20, 16] = .5177958859391748239949773879090325427473e-1
+a[20, 17] = .9672595677476773313884172931875718705561e-1
+a[20, 18] = .1477312690340742769720989417101989769314
+a[20, 19] = -.1150750712958503934434410263732282100773
+c[21] = .25e-1
+
+a[21, 0] = .1802918623893620731908165792176564180038e-1
+a[21, 1] = 0.
+a[21, 2] = 0.
+a[21, 3] = 0.
+a[21, 4] = 0.
+a[21, 5] = 0.
+a[21, 6] = 0.
+a[21, 7] = .6983601042028873702545973390560096201728e-1
+a[21, 8] = -.2541247660791663512384395986842781657182e-1
+a[21, 9] = .8487827035463274491721441398893680307535e-2
+a[21, 10] = -.2427525516089801645451101966852425715128e-2
+a[21, 11] = -.1047839752893819879012607694745789515746
+a[21, 12] = -.1473147795248041942353840372690095884761e-1
+a[21, 13] = -.3916338390816177165706892282751065537530e-1
+a[21, 14] = -.1005657343293959419073236542225421561652e-1
+a[21, 15] = 0.
+a[21, 16] = .1102510392204834322538452331445716455061e-1
+a[21, 17] = .5092830749095398308703438556315975226108e-2
+a[21, 18] = .4759715599420644505591133410826632557391e-1
+a[21, 19] = .3386307003288382751110965442296681690349e-1
+a[21, 20] = .2764422831404797700452373965825845732168e-1
+
+c[22] = .15
+
+a[22, 0] = .1677431640522778042988664067637191163626e-1
+a[22, 1] = 0.
+a[22, 2] = 0.
+a[22, 3] = 0.
+a[22, 4] = 0.
+a[22, 5] = 0.
+a[22, 6] = 0.
+a[22, 7] = .6220437408820475326702539861577894278533
+a[22, 8] = -.2060859809768841878234097076241307428139
+a[22, 9] = .1156394989766058889629372195583391792474
+a[22, 10] = .2664101793378358946544219293685167025971e-1
+a[22, 11] = -.9376810793418770527505892794460093668860
+a[22, 12] = -.1367806466702160302637074581619101741312
+a[22, 13] = -.3678480995268296672182605288991379118419
+a[22, 14] = -.9547871314402478902820445838193201497337e-1
+a[22, 15] = 0.
+a[22, 16] = .1013492018422369748729008873270013785313
+a[22, 17] = -.8911323084568593396468400926074881389560e-1
+a[22, 18] = .4664140988974760478895528270623735057521
+a[22, 19] = .4502736292354579812232681662308722738519
+a[22, 20] = .1838522463326818655346135218242696774099
+a[22, 21] = 0.
+
+c[23] = .32
+
+a[23, 0] = .1071149731491444187554380927165768658192e-1
+a[23, 1] = 0.
+a[23, 2] = 0.
+a[23, 3] = 0.
+a[23, 4] = 0.
+a[23, 5] = 0.
+a[23, 6] = 0.
+a[23, 7] = -.7094336118221108191937165464264324417735e-1
+a[23, 8] = .1002164900340091596740582334112699697590
+a[23, 9] = .1383453980468025108839271214703390659581
+a[23, 10] = .1796330633578163411338104055485109917477
+a[23, 11] = .9048246545576180974879274948815422276563e-1
+a[23, 12] = -.5460662294523338383345981122023862069115e-2
+a[23, 13] = -.3000457905119619782973021046143166498567e-1
+a[23, 14] = -.1145192026962799093665613252151017277867e-1
+a[23, 15] = 0.
+a[23, 16] = .1003394686109385076849515422360600302176e-1
+a[23, 17] = -.9506485282809046129031027932806241113157e-1
+a[23, 18] = .4853358804093591445756711642658478691640e-1
+a[23, 19] = .8013325919783924638483373011297347396327e-1
+a[23, 20] = -.1251643326835242045676140618774248455713
+a[23, 21] = 0.
+a[23, 22] = 0.
+
+c[24] = .78
+
+a[24, 0] = .1410172088869221367153586187761994182069e-1
+a[24, 1] = 0.
+a[24, 2] = 0.
+a[24, 3] = 0.
+a[24, 4] = 0.
+a[24, 5] = 0.
+a[24, 6] = 0.
+a[24, 7] = -.3713379753704491105936205420001801316029
+a[24, 8] = .2231265548117180273161442520179150684520
+a[24, 9] = .1287005345918120122888629169443916280865
+a[24, 10] = .2224600659675494761192249831098918110654
+a[24, 11] = .5382853042550701952740528638168708946100
+a[24, 12] = .5417202616988763101781128062036252796548e-1
+a[24, 13] = .1256968791308743925752109039299467082975
+a[24, 14] = .2784492789002054061504430663197543089132e-1
+a[24, 15] = 0.
+a[24, 16] = -.3077409246205059733390460511525401688205e-1
+a[24, 17] = .8569805293689777608077303071761466118035e-2
+a[24, 18] = -.1535174690587044615794997685221990516897
+a[24, 19] = -.2179957030548196497189489878038029238243e-1
+a[24, 20] = .1447128819737186799295514239727801525027e-1
+a[24, 21] = 0.
+a[24, 22] = 0.
+a[24, 23] = 0.
+
+c[25] = .96
+
+a[25, 0] = .1424600411735646609296566581447532773183e-1
+a[25, 1] = 0.
+a[25, 2] = 0.
+a[25, 3] = 0.
+a[25, 4] = 0.
+a[25, 5] = 0.
+a[25, 6] = 0.
+a[25, 7] = -.3767107393295407091303982522049390741260
+a[25, 8] = .2252399780730421480874737297000189000070
+a[25, 9] = .1283603076292529988314451246143633426068
+a[25, 10] = .2230238705261692544876826347415151339678
+a[25, 11] = .5463127827750747224899202176094949607118
+a[25, 12] = .5526190791375779994553849469706124289752e-1
+a[25, 13] = .1285613508749982456581494397108686240388
+a[25, 14] = .2857250681296406482698934635829147899039e-1
+a[25, 15] = 0.
+a[25, 16] = -.2398761886357108720930416967644499057175e-1
+a[25, 17] = .5556224458910509454379297181908734648749e-1
+a[25, 18] = -.1740675650762838674257930398070760254668e-1
+a[25, 19] = -.3815462365996979065575121886854199471011e-1
+a[25, 20] = .1111878504898917877407531966545730451506e-1
+a[25, 21] = 0.
+a[25, 22] = 0.
+a[25, 23] = 0.
+a[25, 24] = 0.
+
+bi[0, 0] = 1.
+bi[0, 1] = -28.33048870061739823290767301658881994700
+bi[0, 2] = 257.6535452078577977252092979905248156497
+bi[0, 3] = -1152.154455743457311528752964691951881858
+bi[0, 4] = 2909.390878345408890936564599116550031880
+bi[0, 5] = -4355.005172868188498048946108887283528629
+bi[0, 6] = 3834.083497036262189455855371796461857871
+bi[0, 7] = -1835.419052683407081215583427992189311730
+bi[0, 8] = 368.7958613829998340610814211036270246107
+
+bi[1, 0] = 0.
+bi[1, 1] = 0.
+bi[1, 2] = 0.
+bi[1, 3] = 0.
+bi[1, 4] = 0.
+bi[1, 5] = 0.
+bi[1, 6] = 0.
+bi[1, 7] = 0.
+bi[1, 8] = 0.
+
+bi[2, 0] = 0.
+bi[2, 1] = 0.
+bi[2, 2] = 0.
+bi[2, 3] = 0.
+bi[2, 4] = 0.
+bi[2, 5] = 0.
+bi[2, 6] = 0.
+bi[2, 7] = 0.
+bi[2, 8] = 0.
+
+bi[3, 0] = 0.
+bi[3, 1] = 0.
+bi[3, 2] = 0.
+bi[3, 3] = 0.
+bi[3, 4] = 0.
+bi[3, 5] = 0.
+bi[3, 6] = 0.
+bi[3, 7] = 0.
+bi[3, 8] = 0.
+
+bi[4, 0] = 0.
+bi[4, 1] = 0.
+bi[4, 2] = 0.
+bi[4, 3] = 0.
+bi[4, 4] = 0.
+bi[4, 5] = 0.
+bi[4, 6] = 0.
+bi[4, 7] = 0.
+bi[4, 8] = 0.
+
+bi[5, 0] = 0.
+bi[5, 1] = 0.
+bi[5, 2] = 0.
+bi[5, 3] = 0.
+bi[5, 4] = 0.
+bi[5, 5] = 0.
+bi[5, 6] = 0.
+bi[5, 7] = 0.
+bi[5, 8] = 0.
+
+bi[6, 0] = 0.
+bi[6, 1] = 0.
+bi[6, 2] = 0.
+bi[6, 3] = 0.
+bi[6, 4] = 0.
+bi[6, 5] = 0.
+bi[6, 6] = 0.
+bi[6, 7] = 0.
+bi[6, 8] = 0.
+
+bi[7, 0] = 0.
+bi[7, 1] = 2.649656243770091212685381903551424676261
+bi[7, 2] = -96.30312807816005963630382777245983513008
+bi[7, 3] = 869.3095462492795755338599928089438369769
+bi[7, 4] = -3395.688567551074115525201961265641584358
+bi[7, 5] = 6796.933987158715680563278170147156885480
+bi[7, 6] = -7340.848417712071304684606060804637321789
+bi[7, 7] = 4082.848896992365666259441580054990759905
+bi[7, 8] = -919.2934944890586676320942978986329899642
+
+bi[8, 0] = 0.
+bi[8, 1] = -1.563945181928732780647121505551017046606
+bi[8, 2] = 56.84239739272860000194549791973820565214
+bi[8, 3] = -513.1052300304284642178552372517916694426
+bi[8, 4] = 2004.286702110323162741493515173880535381
+bi[8, 5] = -4011.853305913929339500285683507736138334
+bi[8, 6] = 4332.895839278586189971336003691596594090
+bi[8, 7] = -2409.879347937144606091337260195738587773
+bi[8, 8] = 542.6079835318221405169412532400889768401
+
+bi[9, 0] = 0.
+bi[9, 1] = -.8627103334967223830653368770735555216700
+bi[9, 2] = 31.35565375185173442495465167501846267906
+bi[9, 3] = -283.0413682227354209126847112083546012674
+bi[9, 4] = 1105.613463426006937052739159664962261462
+bi[9, 5] = -2213.036200678452629288185991597653042989
+bi[9, 6] = 2390.131097754120588994847482867886207858
+bi[9, 7] = -1329.348266146873716496636094950745123424
+bi[9, 8] = 299.3158071265785138462868993727082901209
+
+bi[10, 0] = 0.
+bi[10, 1] = -1.520295337901214839055193576160469820911
+bi[10, 2] = 55.25592121120227100440616045452813504748
+bi[10, 3] = -498.7844190970740738969945498750124435385
+bi[10, 4] = 1948.346888525776056658403461666308795237
+bi[10, 5] = -3899.882136407551390287649940376076923682
+bi[10, 6] = 4211.964345158858030803618536151121927765
+bi[10, 7] = -2342.619408856117128087568672414857706561
+bi[10, 8] = 527.4637482204278644179968961638568925209
+
+bi[11, 0] = 0.
+bi[11, 1] = -3.846938844125523400516071820264700141179
+bi[11, 2] = 139.8189840986840520353362018994734906611
+bi[11, 3] = -1262.118687621600386514715930156791825893
+bi[11, 4] = 4930.075848057311658057235318456802793199
+bi[11, 5] = -9868.219486069539059368988308801366826185
+bi[11, 6] = 10657.90892434886730229746304583865145121
+bi[11, 7] = -5927.738759872814112912292792695856187255
+bi[11, 8] = 1334.688551172190921099749059976639173619
+
+bi[12, 0] = 0.
+bi[12, 1] = -.3942713061200141454309326713125653612517
+bi[12, 2] = 14.32999476067649707020689155180345562459
+bi[12, 3] = -129.3540665994558117853022852051786116929
+bi[12, 4] = 505.2816077002517600897861155496606850457
+bi[12, 5] = -1011.390080139433268878243655218566636574
+bi[12, 6] = 1092.325051781891697669369143688906543465
+bi[12, 7] = -607.5317019302810290917918493845279272648
+bi[12, 8] = 136.7917244480423273434147193694336909663
+
+bi[13, 0] = 0.
+bi[13, 1] = -.9233145622082101394378429409444333268499
+bi[13, 2] = 33.55834582309798808260613735851232640640
+bi[13, 3] = -302.9246397549735936661321348695774835448
+bi[13, 4] = 1183.281306967867553342903125095128753568
+bi[13, 5] = -2368.498986790111516106072390247333149007
+bi[13, 6] = 2558.034559755808027369106332027405169828
+bi[13, 7] = -1422.733175577880214903071122439856598476
+bi[13, 8] = 320.3423358787481875842587982911148385364
+
+bi[14, 0] = 0.
+bi[14, 1] = -.2068862802930053801253649628830330891017
+bi[14, 2] = 7.519388975651662772174695012120581518594
+bi[14, 3] = -67.87605708082904058354114755731111898667
+bi[14, 4] = 265.1367996984150421661637988925923843021
+bi[14, 5] = -530.7074807559025368587558119659212235622
+bi[14, 6] = 573.1765495641490277116961329189087439579
+bi[14, 7] = -318.7905688834868978004500126002971837241
+bi[14, 8] = 71.77882490212657594681492031347005327988
+
+bi[15, 0] = 0.
+bi[15, 1] = 0.
+bi[15, 2] = 0.
+bi[15, 3] = 0.
+bi[15, 4] = 0.
+bi[15, 5] = 0.
+bi[15, 6] = 0.
+bi[15, 7] = 0.
+bi[15, 8] = 0.
+
+bi[16, 0] = 0.
+bi[16, 1] = -.4472441906744099441704338175964823026105
+bi[16, 2] = 16.44684676010503791623763886833381020592
+bi[16, 3] = -154.4086105921295528355180056633078150675
+bi[16, 4] = 641.8986298540248497333509289273669726482
+bi[16, 5] = -1391.939225687982391028602609567895699003
+bi[16, 6] = 1643.890568302952013019278202625162156841
+bi[16, 7] = -1004.065297223317845596795060426393517046
+bi[16, 8] = 248.6243327770222987362193390543305737239
+
+bi[17, 0] = 0.
+bi[17, 1] = -.1507876007899797948720901584434839156279
+bi[17, 2] = 5.527328824824632235316362126620825363280
+bi[17, 3] = -51.33833743084618751433903968701557585387
+bi[17, 4] = 209.6022002703280347991393999433060881829
+bi[17, 5] = -442.7692650421825928714839983614217797969
+bi[17, 6] = 505.0579312588052893780948070449787925777
+bi[17, 7] = -295.6336410615619366143935619944592839974
+bi[17, 8] = 69.70457078142274038253812108643441743987
+
+bi[18, 0] = 0.
+bi[18, 1] = -.6413652207435296452288504944964177537185
+bi[18, 2] = 23.51013248624684600263471193689787394701
+bi[18, 3] = -218.3642683246972281497485359238725613162
+bi[18, 4] = 891.5292818535365634586829868055833114383
+bi[18, 5] = -1883.290177206007885518558760085145850658
+bi[18, 6] = 2148.230954488399755970660772306573864434
+bi[18, 7] = -1257.458401521712336970840850120592935471
+bi[18, 8] = 296.4838434449778148523985255750527153802
+
+bi[19, 0] = 0.
+bi[19, 1] = 1.810729313444845732964058528284532356045
+bi[19, 2] = -66.37479657295337371220255196726289169374
+bi[19, 3] = 616.4952025401106511929691356878863855003
+bi[19, 4] = -2517.003030777322559684753470471663859295
+bi[19, 5] = 5316.984175781033401491488704359579721604
+bi[19, 6] = -6064.976140789574108556866601189158423779
+bi[19, 7] = 3550.109538888391317555902194852386816092
+bi[19, 8] = -837.0456783831301740195014698000522807852
+
+bi[20, 0] = 0.
+bi[20, 1] = .5176008760353717918864555990277480363987e-1
+bi[20, 2] = -1.897337862580348756406065418550014243949
+bi[20, 3] = 17.62264820793629244181715147639285955422
+bi[20, 4] = -71.94907400242465946110661282550878163878
+bi[20, 5] = 151.9871383765666045085018751235590550206
+bi[20, 6] = -173.3686498747860565970136435029707518663
+bi[20, 7] = 101.4806461521468075879782291473158292931
+bi[20, 8] = -23.92713108446217690295957956014097092250
+
+bi[21, 0] = 0.
+bi[21, 1] = 31.32178255668799909977422939838912846070
+bi[21, 2] = -355.6570858339106059687054319211280026146
+bi[21, 3] = 1752.685282489515979253875884672206842255
+bi[21, 4] = -4708.092293138363367969732154806019707156
+bi[21, 5] = 7370.900776193488713149861391844801840850
+bi[21, 6] = -6716.504964764565347011489385051202629762
+bi[21, 7] = 3303.940398161185772296756776169088470785
+bi[21, 8] = -678.5938956640391428503413103061359428182
+
+bi[22, 0] = 0.
+bi[22, 1] = -2.719607334185924760747802644504744092917
+bi[22, 2] = 86.64045615858264001154848875638486632034
+bi[22, 3] = -454.1926030939030807863651114984001402596
+bi[22, 4] = 1014.749221100543425314268817989377200147
+bi[22, 5] = -1133.583456714543865890388885909333783663
+bi[22, 6] = 610.4671827718666569168001429679645990946
+bi[22, 7] = -109.0233499449543802317396567002119357593
+bi[22, 8] = -12.33784294340547057337599296127606178639
+
+bi[23, 0] = 0.
+bi[23, 1] = 3.177214801432923432265738869490200556403
+bi[23, 2] = -113.8098697715142983214434051918276259885
+bi[23, 3] = 978.0935981825675014833003847211971070224
+bi[23, 4] = -3575.129377623670076451027372711378100786
+bi[23, 5] = 6764.361519838450570830405988615992045681
+bi[23, 6] = -6987.161043852012362644872233028628887679
+bi[23, 7] = 3751.905762789571137088934326513342858381
+bi[23, 8] = -821.4378043648253954175634277881875971878
+
+bi[24, 0] = 0.
+bi[24, 1] = .8772843083465530069477626269697233842708
+bi[24, 2] = -31.51810423988375104361582759389916060143
+bi[24, 3] = 273.1229151353221133842213845530391043248
+bi[24, 4] = -993.2198643101781966584366870874238565290
+bi[24, 5] = 1787.888078312663987193988385659681964836
+bi[24, 6] = -1677.394835799640950953367739332661886275
+bi[24, 7] = 781.3579535062687952504707744453846824540
+bi[24, 8] = -141.1134269128985501802080532710905715931
+
+bi[25, 0] = 0.
+bi[25, 1] = 1.719427581798715782378897599231938082126
+bi[25, 2] = -62.89867309250732184389962568482931880335
+bi[25, 3] = 580.3335507873980391019057196688995930872
+bi[25, 4] = -2348.110620506760958600472968113883922730
+bi[25, 5] = 4921.119298612906015908637628774963068611
+bi[25, 6] = -5597.912448707916639109910311016358007839
+bi[25, 7] = 3288.597775149621789973016480733216881572
+bi[25, 8] = -782.8483098245396412116558219612402319811
+
+vern9_coeff = {'order': order, 'a': a, 'b': b, 'c': c, 'e': e, 'bi': bi}
diff --git a/qutip/solver/krylovsolve.py b/qutip/solver/krylovsolve.py
index 4d14262ca5..99fa78b229 100644
--- a/qutip/solver/krylovsolve.py
+++ b/qutip/solver/krylovsolve.py
@@ -1,102 +1,102 @@
-__all__ = ['krylovsolve']
-
-from .. import QobjEvo
-from .sesolve import SESolver
-
-
-def krylovsolve(
-    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
-):
-    """
-    Schrodinger equation evolution of a state vector for time independent
-    Hamiltonians using Krylov method.
-
-    Evolve the state vector ("psi0") finding an approximation for the time
-    evolution operator of Hamiltonian ("H") by obtaining the projection of
-    the time evolution operator on a set of small dimensional Krylov
-    subspaces (m << dim(H)).
-
-    The output is either the state vector or unitary matrix at arbitrary points
-    in time (`tlist`), or the expectation values of the supplied operators
-    (`e_ops`). If e_ops is a callback function, it is invoked for each
-    time in `tlist` with time and the state as arguments, and the function
-    does not use any return values. e_ops cannot be used in conjunction
-    with solving the Schrodinger operator equation
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    psi0 : :class:`qutip.qobj`
-        initial state vector (ket)
-        or initial unitary operator `psi0 = U`
-
-    tlist : *list* / *array*
-        list of times for :math:`t`.
-
-    krylov_dim: int
-        Dimension of Krylov approximation subspaces used for the time
-        evolution approximation.
-
-    e_ops : :class:`qutip.qobj`, callable, or list.
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation.
-
-    args : None / *dictionary*
-        dictionary of parameters for time-dependent Hamiltonians
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool, [False]
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, [None]
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool, [True]
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict, [{"chunk_size": 10}]
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - atol: float [1e-7]
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps : int [100]
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - min_step, max_step : float, [1e-5, 1e5]
-          Miniumum and maximum lenght of one internal step.
-        - always_compute_step: bool [False]
-          If True, the step lenght is computed each time a new Krylov
-          subspace is computed. Otherwise it is computed only once when
-          creating the integrator.
-        - sub_system_tol: float, [1e-7]
-          Tolerance to detect an happy breakdown. An happy breakdown happens
-          when the initial ket is in a subspace of the Hamiltonian smaller
-          than ``krylov_dim``.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        a *list of array* `result.expect` of expectation values for the times
-        specified by `tlist`, and/or a *list* `result.states` of state vectors
-        or density matrices corresponding to the times in `tlist` [if `e_ops`
-        is an empty list of `store_states=True` in options].
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    options = options or {}
-    options["method"] = "krylov"
-    options["krylov_dim"] = krylov_dim
-    solver = SESolver(H, options=options)
-    return solver.run(psi0, tlist, e_ops=e_ops)
+__all__ = ['krylovsolve']
+
+from .. import QobjEvo
+from .sesolve import SESolver
+
+
+def krylovsolve(
+    H, psi0, tlist, krylov_dim, e_ops=None, args=None, options=None
+):
+    """
+    Schrodinger equation evolution of a state vector for time independent
+    Hamiltonians using Krylov method.
+
+    Evolve the state vector ("psi0") finding an approximation for the time
+    evolution operator of Hamiltonian ("H") by obtaining the projection of
+    the time evolution operator on a set of small dimensional Krylov
+    subspaces (m << dim(H)).
+
+    The output is either the state vector or unitary matrix at arbitrary points
+    in time (`tlist`), or the expectation values of the supplied operators
+    (`e_ops`). If e_ops is a callback function, it is invoked for each
+    time in `tlist` with time and the state as arguments, and the function
+    does not use any return values. e_ops cannot be used in conjunction
+    with solving the Schrodinger operator equation
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    psi0 : :class:`qutip.qobj`
+        initial state vector (ket)
+        or initial unitary operator `psi0 = U`
+
+    tlist : *list* / *array*
+        list of times for :math:`t`.
+
+    krylov_dim: int
+        Dimension of Krylov approximation subspaces used for the time
+        evolution approximation.
+
+    e_ops : :class:`qutip.qobj`, callable, or list.
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
+
+    args : None / *dictionary*
+        dictionary of parameters for time-dependent Hamiltonians
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool, [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, [None]
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool, [True]
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ["text"]
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - atol: float [1e-7]
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps : int [100]
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - min_step, max_step : float, [1e-5, 1e5]
+          Miniumum and maximum lenght of one internal step.
+        - always_compute_step: bool [False]
+          If True, the step lenght is computed each time a new Krylov
+          subspace is computed. Otherwise it is computed only once when
+          creating the integrator.
+        - sub_system_tol: float, [1e-7]
+          Tolerance to detect an happy breakdown. An happy breakdown happens
+          when the initial ket is in a subspace of the Hamiltonian smaller
+          than ``krylov_dim``.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        a *list of array* `result.expect` of expectation values for the times
+        specified by `tlist`, and/or a *list* `result.states` of state vectors
+        or density matrices corresponding to the times in `tlist` [if `e_ops`
+        is an empty list of `store_states=True` in options].
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    options = options or {}
+    options["method"] = "krylov"
+    options["krylov_dim"] = krylov_dim
+    solver = SESolver(H, options=options)
+    return solver.run(psi0, tlist, e_ops=e_ops)
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index f1a55bf216..bc3369b979 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,527 +1,527 @@
-__all__ = ['mcsolve', "MCSolver"]
-
-import warnings
-
-import numpy as np
-from copy import copy
-from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
-from .multitraj import MultiTrajSolver
-from .solver_base import Solver
-from .result import McResult, Result
-from .mesolve import mesolve, MESolver
-import qutip.core.data as _data
-from time import time
-
-
-def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
-            args=None, options=None, seeds=None, target_tol=None, timeout=None):
-    r"""
-    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
-    given Hamiltonian and sets of collapse operators. Options for the
-    underlying ODE solver are given by the Options class.
-
-    Parameters
-    ----------
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
-        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
-        ``H`` can also be a superoperator (liouvillian) if some collapse
-        operators are to be treated deterministically.
-
-    state : :class:`qutip.Qobj`
-        Initial state vector.
-
-    tlist : array_like
-        Times at which results are recorded.
-
-    c_ops : list
-        A ``list`` of collapse operators in any input type that QobjEvo accepts
-        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
-        even if ``H`` is a superoperator. If none are given, the solver will
-        defer to ``sesolve`` or ``mesolve``.
-
-    e_ops : list, [optional]
-        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
-        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
-        are given, the solver will default to save the states.
-
-    ntraj : int
-        Maximum number of trajectories to run. Can be cut short if a time limit
-        is passed with the ``timeout`` keyword or if the target tolerance is
-        reached, see ``target_tol``.
-
-    args : None / dict
-        Arguments for time-dependent Hamiltonian and collapse operator terms.
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool [False]
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, NoneType, [None]
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict, [{"chunk_size": 10}]
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
-          Which differential equation integration method to use.
-        - keep_runs_results : bool, [False]
-          Whether to store results from all trajectories or just store the
-          averages.
-        - map : str {"serial", "parallel", "loky"}, ["serial"]
-          How to run the trajectories. "parallel" uses concurent module to run
-          in parallel while "loky" use the module of the same name to do so.
-        - job_timeout : NoneType, int, [None]
-          Maximum time to compute one trajectory.
-        - num_cpus : NoneType, int, [None]
-          Number of cpus to use when running in parallel. ``None`` detect the
-          number of available cpus.
-        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
-          Parameters used to find the collapse location. ``norm_t_tol`` and
-          ``norm_tol`` are the tolerance in time and norm respectively.
-          An error will be raised if the collapse could not be found within
-          ``norm_steps`` tries.
-        - mc_corr_eps : float, [1e-10]
-          Small number used to detect non-physical collapse caused by numerical
-          imprecision.
-        - atol, rtol : float, [1e-8, 1e-6]
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps : int [2500]
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, [0]
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-    seeds : int, SeedSequence, list, [optional]
-        Seed for the random number generator. It can be a single seed used to
-        spawn seeds for each trajectory or a list of seeds, one for each
-        trajectory. Seeds are saved in the result and they can be reused with::
-
-            seeds=prev_result.seeds
-
-    target_tol : {float, tuple, list}, optional
-        Target tolerance of the evolution. The evolution will compute
-        trajectories until the error on the expectation values is lower than
-        this tolerance. The maximum number of trajectories employed is
-        given by ``ntraj``. The error is computed using jackknife resampling.
-        ``target_tol`` can be an absolute tolerance or a pair of absolute and
-        relative tolerance, in that order. Lastly, it can be a list of pairs of
-        (atol, rtol) for each e_ops.
-
-    timeout : float [optional]
-        Maximum time for the evolution in second. When reached, no more
-        trajectories will be computed. Overwrite the option of the same name.
-
-    Returns
-    -------
-    results : :class:`qutip.solver.Result`
-        Object storing all results from the simulation. Which results is saved
-        depends on the presence of ``e_ops`` and the options used. ``collapse``
-        and ``photocurrent`` is available to Monte Carlo simulation results.
-
-    .. note:
-        The simulation will end when the first end condition is reached between
-        ``ntraj``, ``timeout`` and ``target_tol``.
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    if not isinstance(c_ops, (list, tuple)):
-        c_ops = [c_ops]
-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-
-    if len(c_ops) == 0:
-        if options is None:
-            options = {}
-        options = {
-            key: options[key]
-            for key in options
-            if key in MESolver.solver_options
-        }
-        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
-                       options=options)
-
-    if isinstance(ntraj, (list, tuple)):
-        raise TypeError(
-            "ntraj must be an integer. "
-            "A list of numbers is not longer supported."
-        )
-
-    mc = MCSolver(H, c_ops, options=options)
-    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
-                    seed=seeds, target_tol=target_tol, timeout=timeout)
-    return result
-
-
-class MCIntegrator:
-    """
-    Integrator like object for mcsolve trajectory.
-    """
-    name = "mcsolve"
-
-    def __init__(self, integrator, c_ops, n_ops, options=None):
-        self._integrator = integrator
-        self._c_ops = c_ops
-        self._n_ops = n_ops
-        self.options = options
-        self._generator = None
-        self.method = f"{self.name} {self._integrator.method}"
-        self._is_set = False
-        self.issuper = c_ops[0].issuper
-
-    def set_state(self, t, state0, generator):
-        """
-        Set the state of the ODE solver.
-
-        Parameters
-        ----------
-        t : float
-            Initial time
-
-        state0 : qutip.Data
-            Initial state.
-
-        generator : numpy.random.generator
-            Random number generator.
-        """
-        self.collapses = []
-        self._generator = generator
-        self.target_norm = self._generator.random()
-        self._integrator.set_state(t, state0)
-        self._is_set = True
-
-    def get_state(self, copy=True):
-        return *self._integrator.get_state(copy), self._generator
-
-    def integrate(self, t, copy=False):
-        t_old, y_old = self._integrator.get_state(copy=False)
-        norm_old = self._prob_func(y_old)
-        while t_old < t:
-            t_step, state = self._integrator.mcstep(t, copy=False)
-            norm = self._prob_func(state)
-            if norm <= self.target_norm:
-                t_col, state = self._find_collapse_time(norm_old, norm,
-                                                        t_old, t_step)
-                self._do_collapse(t_col, state)
-                t_old, y_old = self._integrator.get_state(copy=False)
-                norm_old = 1.
-            else:
-                t_old, y_old = t_step, state
-                norm_old = norm
-
-        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
-
-    def run(self, tlist):
-        for t in tlist[1:]:
-            yield self.integrate(t, False)
-
-    def reset(self, hard=False):
-        self._integrator.reset(hard)
-
-    def _prob_func(self, state):
-        if self.issuper:
-            return _data.trace_oper_ket(state).real
-        return _data.norm.l2(state)**2
-
-    def _norm_func(self, state):
-        if self.issuper:
-            return _data.trace_oper_ket(state).real
-        return _data.norm.l2(state)
-
-    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
-        """Find the time of the collapse and state just before it."""
-        tries = 0
-        while tries < self.options['norm_steps']:
-            tries += 1
-            if (t_final - t_prev) < self.options['norm_t_tol']:
-                t_guess = t_final
-                _, state = self._integrator.get_state()
-                break
-            t_guess = (
-                t_prev
-                + ((t_final - t_prev)
-                   * np.log(norm_old / self.target_norm)
-                   / np.log(norm_old / norm))
-            )
-            if (t_guess - t_prev) < self.options['norm_t_tol']:
-                t_guess = t_prev + self.options['norm_t_tol']
-            _, state = self._integrator.mcstep(t_guess, copy=False)
-            norm2_guess = self._prob_func(state)
-            if (
-                np.abs(self.target_norm - norm2_guess) <
-                self.options['norm_tol'] * self.target_norm
-            ):
-                break
-            elif (norm2_guess < self.target_norm):
-                # t_guess is still > t_jump
-                t_final = t_guess
-                norm = norm2_guess
-            else:
-                # t_guess < t_jump
-                t_prev = t_guess
-                norm_old = norm2_guess
-
-        if tries >= self.options['norm_steps']:
-            raise RuntimeError(
-                "Could not find the collapse time within desired tolerance. "
-                "Increase accuracy of the ODE solver or lower the tolerance "
-                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
-
-        return t_guess, state
-
-    def _do_collapse(self, collapse_time, state):
-        """
-        Do the collapse:
-        - Find which operator did the collapse.
-        - Update the state and Integrator.
-        - Next collapse norm location
-        - Store collapse info.
-        """
-        # collapse_time, state is at the collapse
-        if len(self._n_ops) == 1:
-            which = 0
-        else:
-            probs = np.zeros(len(self._n_ops))
-            for i, n_op in enumerate(self._n_ops):
-                probs[i] = n_op.expect_data(collapse_time, state).real
-            probs = np.cumsum(probs)
-            which = np.searchsorted(probs,
-                                    probs[-1] * self._generator.random())
-
-        state_new = self._c_ops[which].matmul_data(collapse_time, state)
-        new_norm = self._norm_func(state_new)
-        if new_norm < self.options['mc_corr_eps']:
-            # This happen when the collapse is caused by numerical error
-            state_new = _data.mul(state, 1 / self._norm_func(state))
-        else:
-            state_new = _data.mul(state_new, 1 / new_norm)
-            self.collapses.append((collapse_time, which))
-            self.target_norm = self._generator.random()
-        self._integrator.set_state(collapse_time, state_new)
-
-    def arguments(self, args):
-        if args:
-            self._integrator.arguments(args)
-            for c_op in self._c_ops:
-                c_op.arguments(args)
-            for n_op in self._n_ops:
-                n_op.arguments(args)
-
-    @property
-    def integrator_options(self):
-        return self._integrator.integrator_options
-
-
-# -----------------------------------------------------------------------------
-# MONTE CARLO CLASS
-# -----------------------------------------------------------------------------
-class MCSolver(MultiTrajSolver):
-    r"""
-    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
-    given Hamiltonian and sets of collapse operators. Options for the
-    underlying ODE solver are given by the Options class.
-
-    Parameters
-    ----------
-    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
-        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
-        ``H`` can also be a superoperator (liouvillian) if some collapse
-        operators are to be treated deterministically.
-
-    c_ops : list
-        A ``list`` of collapse operators in any input type that QobjEvo accepts
-        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
-        even if ``H`` is a superoperator.
-
-    options : dict, [optional]
-        Options for the evolution.
-    """
-    name = "mcsolve"
-    resultclass = McResult
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "keep_runs_results": False,
-        "method": "adams",
-        "map": "serial",
-        "job_timeout": None,
-        "num_cpus": None,
-        "bitgenerator": None,
-        "mc_corr_eps": 1e-10,
-        "norm_steps": 5,
-        "norm_t_tol": 1e-6,
-        "norm_tol": 1e-4,
-    }
-
-    def __init__(self, H, c_ops, *, options=None):
-        _time_start = time()
-
-        if isinstance(c_ops, (Qobj, QobjEvo)):
-            c_ops = [c_ops]
-        c_ops = [QobjEvo(c_op) for c_op in c_ops]
-
-        if H.issuper:
-            self._c_ops = [
-                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
-                for c_op in c_ops
-            ]
-            self._n_ops = self._c_ops
-            rhs = QobjEvo(H)
-            for c_op in c_ops:
-                cdc = c_op.dag() @ c_op
-                rhs -= 0.5 * (spre(cdc) + spost(cdc))
-        else:
-            self._c_ops = c_ops
-            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
-            rhs = -1j * QobjEvo(H)
-            for n_op in self._n_ops:
-                rhs -= 0.5 * n_op
-
-        self._num_collapse = len(self._c_ops)
-
-        super().__init__(rhs, options=options)
-
-    def _restore_state(self, data, *, copy=True):
-        """
-        Retore the Qobj state from its data.
-        """
-        if self._state_metadata['dims'] == self.rhs.dims[1]:
-            state = Qobj(unstack_columns(data),
-                         **self._state_metadata, copy=False)
-        else:
-            state = Qobj(data, **self._state_metadata, copy=copy)
-
-        return state
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "method": self.options["method"],
-            "solver": "Master Equation Evolution",
-            "num_collapse": self._num_collapse,
-        })
-        return stats
-
-    def _argument(self, args):
-        self._integrator.arguments(args)
-        self.rhs.arguments(args)
-        for c_op in self._c_ops:
-            c_op.arguments(args)
-        for n_op in self._n_ops:
-            n_op.arguments(args)
-
-    def _run_one_traj(self, seed, state, tlist, e_ops):
-        """
-        Run one trajectory and return the result.
-        """
-        # The integrators is reused, but non-reentrant. They are are fine for
-        # multiprocessing, but will fail with multithreading.
-        # If a thread base parallel map is created, eahc trajectory should use
-        # a copy of the integrator.
-        result = Result(e_ops, {**self.options, "normalize_output": False})
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
-        for t in tlist[1:]:
-            t, state = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
-        result.collapse = self._integrator.collapses
-        return seed, result
-
-    def _get_integrator(self):
-        _time_start = time()
-        method = self.options["method"]
-        if method in self.avail_integrators():
-            integrator = self.avail_integrators()[method]
-        elif issubclass(method, Integrator):
-            integrator = method
-        else:
-            raise ValueError("Integrator method not supported.")
-        integrator_instance = integrator(self.rhs, self.options)
-        mc_integrator = MCIntegrator(
-            integrator_instance, self._c_ops, self._n_ops, self.options
-        )
-        self._init_integrator_time = time() - _time_start
-        return mc_integrator
-
-    @property
-    def options(self):
-        """
-        Options for monte carlo solver:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error if
-            not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size":10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        keep_runs_results: bool
-          Whether to store results from all trajectories or just store the
-          averages.
-
-        method: str, default="adams"
-            Which ODE integrator methods are supported.
-
-        map: str {"serial", "parallel", "loky"}
-            How to run the trajectories. "parallel" uses concurent module to
-            run in parallel while "loky" use the module of the same name to do
-            so.
-
-        job_timeout: None, int
-            Maximum time to compute one trajectory.
-
-        num_cpus: None, int
-            Number of cpus to use when running in parallel. ``None`` detect the
-            number of available cpus.
-
-        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
-            Which of numpy.random's bitgenerator to use. With ``None``, your
-            numpy version's default is used.
-
-        mc_corr_eps: float
-            Small number used to detect non-physical collapse caused by
-            numerical imprecision.
-
-        norm_t_tol: float
-            Tolerance in time used when finding the collapse.
-
-        norm_tol: float
-            Tolerance in norm used when finding the collapse.
-
-        norm_steps: int
-            Maximum number of tries to find the collapse.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        MultiTrajSolver.options.fset(self, new_options)
-
-    @classmethod
-    def avail_integrators(cls):
-        if cls is Solver:
-            return cls._avail_integrators.copy()
-        return {
-            **Solver.avail_integrators(),
-            **cls._avail_integrators,
-        }
+__all__ = ['mcsolve', "MCSolver"]
+
+import warnings
+
+import numpy as np
+from copy import copy
+from ..core import QobjEvo, spre, spost, Qobj, unstack_columns, liouvillian
+from .multitraj import MultiTrajSolver
+from .solver_base import Solver
+from .result import McResult, Result
+from .mesolve import mesolve, MESolver
+import qutip.core.data as _data
+from time import time
+
+
+def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
+            args=None, options=None, seeds=None, target_tol=None, timeout=None):
+    r"""
+    Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
+    given Hamiltonian and sets of collapse operators. Options for the
+    underlying ODE solver are given by the Options class.
+
+    Parameters
+    ----------
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        ``H`` can also be a superoperator (liouvillian) if some collapse
+        operators are to be treated deterministically.
+
+    state : :class:`qutip.Qobj`
+        Initial state vector.
+
+    tlist : array_like
+        Times at which results are recorded.
+
+    c_ops : list
+        A ``list`` of collapse operators in any input type that QobjEvo accepts
+        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
+        even if ``H`` is a superoperator. If none are given, the solver will
+        defer to ``sesolve`` or ``mesolve``.
+
+    e_ops : list, [optional]
+        A ``list`` of operator as Qobj, QobjEvo or callable with signature of
+        (t, state: Qobj) for calculating expectation values. When no ``e_ops``
+        are given, the solver will default to save the states.
+
+    ntraj : int
+        Maximum number of trajectories to run. Can be cut short if a time limit
+        is passed with the ``timeout`` keyword or if the target tolerance is
+        reached, see ``target_tol``.
+
+    args : None / dict
+        Arguments for time-dependent Hamiltonian and collapse operator terms.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool [False]
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, NoneType, [None]
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict, [{"chunk_size": 10}]
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str {"adams", "bdf", "dop853", "vern9", etc.} ["adams"]
+          Which differential equation integration method to use.
+        - keep_runs_results : bool, [False]
+          Whether to store results from all trajectories or just store the
+          averages.
+        - map : str {"serial", "parallel", "loky"}, ["serial"]
+          How to run the trajectories. "parallel" uses concurent module to run
+          in parallel while "loky" use the module of the same name to do so.
+        - job_timeout : NoneType, int, [None]
+          Maximum time to compute one trajectory.
+        - num_cpus : NoneType, int, [None]
+          Number of cpus to use when running in parallel. ``None`` detect the
+          number of available cpus.
+        - norm_t_tol, norm_tol, norm_steps : float, float, int, [1e-6, 1e-4, 5]
+          Parameters used to find the collapse location. ``norm_t_tol`` and
+          ``norm_tol`` are the tolerance in time and norm respectively.
+          An error will be raised if the collapse could not be found within
+          ``norm_steps`` tries.
+        - mc_corr_eps : float, [1e-10]
+          Small number used to detect non-physical collapse caused by numerical
+          imprecision.
+        - atol, rtol : float, [1e-8, 1e-6]
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps : int [2500]
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, [0]
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+    seeds : int, SeedSequence, list, [optional]
+        Seed for the random number generator. It can be a single seed used to
+        spawn seeds for each trajectory or a list of seeds, one for each
+        trajectory. Seeds are saved in the result and they can be reused with::
+
+            seeds=prev_result.seeds
+
+    target_tol : {float, tuple, list}, optional
+        Target tolerance of the evolution. The evolution will compute
+        trajectories until the error on the expectation values is lower than
+        this tolerance. The maximum number of trajectories employed is
+        given by ``ntraj``. The error is computed using jackknife resampling.
+        ``target_tol`` can be an absolute tolerance or a pair of absolute and
+        relative tolerance, in that order. Lastly, it can be a list of pairs of
+        (atol, rtol) for each e_ops.
+
+    timeout : float [optional]
+        Maximum time for the evolution in second. When reached, no more
+        trajectories will be computed. Overwrite the option of the same name.
+
+    Returns
+    -------
+    results : :class:`qutip.solver.Result`
+        Object storing all results from the simulation. Which results is saved
+        depends on the presence of ``e_ops`` and the options used. ``collapse``
+        and ``photocurrent`` is available to Monte Carlo simulation results.
+
+    .. note:
+        The simulation will end when the first end condition is reached between
+        ``ntraj``, ``timeout`` and ``target_tol``.
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    if not isinstance(c_ops, (list, tuple)):
+        c_ops = [c_ops]
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+
+    if len(c_ops) == 0:
+        if options is None:
+            options = {}
+        options = {
+            key: options[key]
+            for key in options
+            if key in MESolver.solver_options
+        }
+        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
+                       options=options)
+
+    if isinstance(ntraj, (list, tuple)):
+        raise TypeError(
+            "ntraj must be an integer. "
+            "A list of numbers is not longer supported."
+        )
+
+    mc = MCSolver(H, c_ops, options=options)
+    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
+                    seed=seeds, target_tol=target_tol, timeout=timeout)
+    return result
+
+
+class MCIntegrator:
+    """
+    Integrator like object for mcsolve trajectory.
+    """
+    name = "mcsolve"
+
+    def __init__(self, integrator, c_ops, n_ops, options=None):
+        self._integrator = integrator
+        self._c_ops = c_ops
+        self._n_ops = n_ops
+        self.options = options
+        self._generator = None
+        self.method = f"{self.name} {self._integrator.method}"
+        self._is_set = False
+        self.issuper = c_ops[0].issuper
+
+    def set_state(self, t, state0, generator):
+        """
+        Set the state of the ODE solver.
+
+        Parameters
+        ----------
+        t : float
+            Initial time
+
+        state0 : qutip.Data
+            Initial state.
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        self.collapses = []
+        self._generator = generator
+        self.target_norm = self._generator.random()
+        self._integrator.set_state(t, state0)
+        self._is_set = True
+
+    def get_state(self, copy=True):
+        return *self._integrator.get_state(copy), self._generator
+
+    def integrate(self, t, copy=False):
+        t_old, y_old = self._integrator.get_state(copy=False)
+        norm_old = self._prob_func(y_old)
+        while t_old < t:
+            t_step, state = self._integrator.mcstep(t, copy=False)
+            norm = self._prob_func(state)
+            if norm <= self.target_norm:
+                t_col, state = self._find_collapse_time(norm_old, norm,
+                                                        t_old, t_step)
+                self._do_collapse(t_col, state)
+                t_old, y_old = self._integrator.get_state(copy=False)
+                norm_old = 1.
+            else:
+                t_old, y_old = t_step, state
+                norm_old = norm
+
+        return t_old, _data.mul(y_old, 1 / self._norm_func(y_old))
+
+    def run(self, tlist):
+        for t in tlist[1:]:
+            yield self.integrate(t, False)
+
+    def reset(self, hard=False):
+        self._integrator.reset(hard)
+
+    def _prob_func(self, state):
+        if self.issuper:
+            return _data.trace_oper_ket(state).real
+        return _data.norm.l2(state)**2
+
+    def _norm_func(self, state):
+        if self.issuper:
+            return _data.trace_oper_ket(state).real
+        return _data.norm.l2(state)
+
+    def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
+        """Find the time of the collapse and state just before it."""
+        tries = 0
+        while tries < self.options['norm_steps']:
+            tries += 1
+            if (t_final - t_prev) < self.options['norm_t_tol']:
+                t_guess = t_final
+                _, state = self._integrator.get_state()
+                break
+            t_guess = (
+                t_prev
+                + ((t_final - t_prev)
+                   * np.log(norm_old / self.target_norm)
+                   / np.log(norm_old / norm))
+            )
+            if (t_guess - t_prev) < self.options['norm_t_tol']:
+                t_guess = t_prev + self.options['norm_t_tol']
+            _, state = self._integrator.mcstep(t_guess, copy=False)
+            norm2_guess = self._prob_func(state)
+            if (
+                np.abs(self.target_norm - norm2_guess) <
+                self.options['norm_tol'] * self.target_norm
+            ):
+                break
+            elif (norm2_guess < self.target_norm):
+                # t_guess is still > t_jump
+                t_final = t_guess
+                norm = norm2_guess
+            else:
+                # t_guess < t_jump
+                t_prev = t_guess
+                norm_old = norm2_guess
+
+        if tries >= self.options['norm_steps']:
+            raise RuntimeError(
+                "Could not find the collapse time within desired tolerance. "
+                "Increase accuracy of the ODE solver or lower the tolerance "
+                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
+
+        return t_guess, state
+
+    def _do_collapse(self, collapse_time, state):
+        """
+        Do the collapse:
+        - Find which operator did the collapse.
+        - Update the state and Integrator.
+        - Next collapse norm location
+        - Store collapse info.
+        """
+        # collapse_time, state is at the collapse
+        if len(self._n_ops) == 1:
+            which = 0
+        else:
+            probs = np.zeros(len(self._n_ops))
+            for i, n_op in enumerate(self._n_ops):
+                probs[i] = n_op.expect_data(collapse_time, state).real
+            probs = np.cumsum(probs)
+            which = np.searchsorted(probs,
+                                    probs[-1] * self._generator.random())
+
+        state_new = self._c_ops[which].matmul_data(collapse_time, state)
+        new_norm = self._norm_func(state_new)
+        if new_norm < self.options['mc_corr_eps']:
+            # This happen when the collapse is caused by numerical error
+            state_new = _data.mul(state, 1 / self._norm_func(state))
+        else:
+            state_new = _data.mul(state_new, 1 / new_norm)
+            self.collapses.append((collapse_time, which))
+            self.target_norm = self._generator.random()
+        self._integrator.set_state(collapse_time, state_new)
+
+    def arguments(self, args):
+        if args:
+            self._integrator.arguments(args)
+            for c_op in self._c_ops:
+                c_op.arguments(args)
+            for n_op in self._n_ops:
+                n_op.arguments(args)
+
+    @property
+    def integrator_options(self):
+        return self._integrator.integrator_options
+
+
+# -----------------------------------------------------------------------------
+# MONTE CARLO CLASS
+# -----------------------------------------------------------------------------
+class MCSolver(MultiTrajSolver):
+    r"""
+    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
+    given Hamiltonian and sets of collapse operators. Options for the
+    underlying ODE solver are given by the Options class.
+
+    Parameters
+    ----------
+    H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
+        System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
+        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        ``H`` can also be a superoperator (liouvillian) if some collapse
+        operators are to be treated deterministically.
+
+    c_ops : list
+        A ``list`` of collapse operators in any input type that QobjEvo accepts
+        (see :class:`qutip.QobjEvo`'s documentation). They must be operators
+        even if ``H`` is a superoperator.
+
+    options : dict, [optional]
+        Options for the evolution.
+    """
+    name = "mcsolve"
+    resultclass = McResult
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "method": "adams",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+        "mc_corr_eps": 1e-10,
+        "norm_steps": 5,
+        "norm_t_tol": 1e-6,
+        "norm_tol": 1e-4,
+    }
+
+    def __init__(self, H, c_ops, *, options=None):
+        _time_start = time()
+
+        if isinstance(c_ops, (Qobj, QobjEvo)):
+            c_ops = [c_ops]
+        c_ops = [QobjEvo(c_op) for c_op in c_ops]
+
+        if H.issuper:
+            self._c_ops = [
+                spre(c_op) * spost(c_op.dag()) if c_op.isoper else c_op
+                for c_op in c_ops
+            ]
+            self._n_ops = self._c_ops
+            rhs = QobjEvo(H)
+            for c_op in c_ops:
+                cdc = c_op.dag() @ c_op
+                rhs -= 0.5 * (spre(cdc) + spost(cdc))
+        else:
+            self._c_ops = c_ops
+            self._n_ops = [c_op.dag() * c_op for c_op in c_ops]
+            rhs = -1j * QobjEvo(H)
+            for n_op in self._n_ops:
+                rhs -= 0.5 * n_op
+
+        self._num_collapse = len(self._c_ops)
+
+        super().__init__(rhs, options=options)
+
+    def _restore_state(self, data, *, copy=True):
+        """
+        Retore the Qobj state from its data.
+        """
+        if self._state_metadata['dims'] == self.rhs.dims[1]:
+            state = Qobj(unstack_columns(data),
+                         **self._state_metadata, copy=False)
+        else:
+            state = Qobj(data, **self._state_metadata, copy=copy)
+
+        return state
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "method": self.options["method"],
+            "solver": "Master Equation Evolution",
+            "num_collapse": self._num_collapse,
+        })
+        return stats
+
+    def _argument(self, args):
+        self._integrator.arguments(args)
+        self.rhs.arguments(args)
+        for c_op in self._c_ops:
+            c_op.arguments(args)
+        for n_op in self._n_ops:
+            n_op.arguments(args)
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        # The integrators is reused, but non-reentrant. They are are fine for
+        # multiprocessing, but will fail with multithreading.
+        # If a thread base parallel map is created, eahc trajectory should use
+        # a copy of the integrator.
+        result = Result(e_ops, {**self.options, "normalize_output": False})
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
+        result.add(tlist[0], self._restore_state(state, copy=False))
+        for t in tlist[1:]:
+            t, state = self._integrator.integrate(t, copy=False)
+            result.add(t, self._restore_state(state, copy=False))
+        result.collapse = self._integrator.collapses
+        return seed, result
+
+    def _get_integrator(self):
+        _time_start = time()
+        method = self.options["method"]
+        if method in self.avail_integrators():
+            integrator = self.avail_integrators()[method]
+        elif issubclass(method, Integrator):
+            integrator = method
+        else:
+            raise ValueError("Integrator method not supported.")
+        integrator_instance = integrator(self.rhs, self.options)
+        mc_integrator = MCIntegrator(
+            integrator_instance, self._c_ops, self._n_ops, self.options
+        )
+        self._init_integrator_time = time() - _time_start
+        return mc_integrator
+
+    @property
+    def options(self):
+        """
+        Options for monte carlo solver:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, default="text"
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error if
+            not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size":10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        keep_runs_results: bool
+          Whether to store results from all trajectories or just store the
+          averages.
+
+        method: str, default="adams"
+            Which ODE integrator methods are supported.
+
+        map: str {"serial", "parallel", "loky"}
+            How to run the trajectories. "parallel" uses concurent module to
+            run in parallel while "loky" use the module of the same name to do
+            so.
+
+        job_timeout: None, int
+            Maximum time to compute one trajectory.
+
+        num_cpus: None, int
+            Number of cpus to use when running in parallel. ``None`` detect the
+            number of available cpus.
+
+        bitgenerator: {None, "MT19937", "PCG64", "PCG64DXSM", ...}
+            Which of numpy.random's bitgenerator to use. With ``None``, your
+            numpy version's default is used.
+
+        mc_corr_eps: float
+            Small number used to detect non-physical collapse caused by
+            numerical imprecision.
+
+        norm_t_tol: float
+            Tolerance in time used when finding the collapse.
+
+        norm_tol: float
+            Tolerance in norm used when finding the collapse.
+
+        norm_steps: int
+            Maximum number of tries to find the collapse.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        MultiTrajSolver.options.fset(self, new_options)
+
+    @classmethod
+    def avail_integrators(cls):
+        if cls is Solver:
+            return cls._avail_integrators.copy()
+        return {
+            **Solver.avail_integrators(),
+            **cls._avail_integrators,
+        }
diff --git a/qutip/solver/mesolve.py b/qutip/solver/mesolve.py
index fb7ff5c777..5792038af1 100644
--- a/qutip/solver/mesolve.py
+++ b/qutip/solver/mesolve.py
@@ -1,217 +1,217 @@
-"""
-This module provides solvers for the Lindblad master equation and von Neumann
-equation.
-"""
-
-__all__ = ['mesolve', 'MESolver']
-
-import numpy as np
-from time import time
-from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
-from ..core import stack_columns, unstack_columns
-from ..core.data import to
-from .solver_base import Solver
-from .sesolve import sesolve, SESolver
-
-
-def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
-    """
-    Master equation evolution of a density matrix for a given Hamiltonian and
-    set of collapse operators, or a Liouvillian.
-
-    Evolve the state vector or density matrix (`rho0`) using a given
-    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
-    (`c_ops`), by integrating the set of ordinary differential equations
-    that define the system. In the absence of collapse operators the system is
-    evolved according to the unitary evolution of the Hamiltonian.
-
-    The output is either the state vector at arbitrary points in time
-    (`tlist`), or the expectation values of the supplied operators
-    (`e_ops`). If e_ops is a callback function, it is invoked for each
-    time in `tlist` with time and the state as arguments, and the function
-    does not use any return values.
-
-    If either `H` or the Qobj elements in `c_ops` are superoperators, they
-    will be treated as direct contributions to the total system Liouvillian.
-    This allows the solution of master equations that are not in standard
-    Lindblad form.
-
-    **Time-dependent operators**
-
-    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
-    object that can be interpreted as :class:`QobjEvo` such as a list of
-    (Qobj, Coefficient) pairs or a function.
-
-    **Additional options**
-
-    Additional options to mesolve can be set via the `options` argument. Many
-    ODE integration options can be set this way, and the `store_states` and
-    `store_final_state` options can be used to store states even though
-    expectation values are requested via the `e_ops` argument.
-
-    .. note::
-
-        When no collapse operator are given and the `H` is not a superoperator,
-        it will defer to :func:`sesolve`.
-
-    Parameters
-    ----------
-
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    rho0 : :class:`Qobj`
-        initial density matrix or state vector (ket).
-
-    tlist : *list* / *array*
-        list of times for :math:`t`.
-
-    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
-        Single collapse operator, or list of collapse operators, or a list
-        of Liouvillian superoperators. None is equivalent to an empty list.
-
-    e_ops : list of :class:`Qobj` / callback function
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation.
-
-    args : None / *dictionary*
-        dictionary of parameters for time-dependent Hamiltonians and
-        collapse operators.
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        a *list of array* `result.expect` of expectation values for the times
-        specified by `tlist`, and/or a *list* `result.states` of state vectors
-        or density matrices corresponding to the times in `tlist` [if `e_ops`
-        is an empty list of `store_states=True` in options].
-
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-
-    c_ops = c_ops if c_ops is not None else []
-    if not isinstance(c_ops, (list, tuple)):
-        c_ops = [c_ops]
-    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
-
-    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
-
-    if not use_mesolve:
-        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
-                       options=options)
-
-    solver = MESolver(H, c_ops, options=options)
-
-    return solver.run(rho0, tlist, e_ops=e_ops)
-
-
-class MESolver(SESolver):
-    """
-    Master equation evolution of a density matrix for a given Hamiltonian and
-    set of collapse operators, or a Liouvillian.
-
-    Evolve the density matrix (`rho0`) using a given
-    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
-    (`c_ops`), by integrating the set of ordinary differential equations
-    that define the system.
-
-    If either `H` or the Qobj elements in `c_ops` are superoperators, they
-    will be treated as direct contributions to the total system Liouvillian.
-    This allows the solution of master equations that are not in standard
-    Lindblad form.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
-        can be made into :class:`QobjEvo` are also accepted.
-
-    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
-        Single collapse operator, or list of collapse operators, or a list
-        of Liouvillian superoperators. None is equivalent to an empty list.
-
-    options : dict, optional
-        Options for the solver, see :obj:`MESolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-
-    attributes
-    ----------
-    stats: dict
-        Diverse diagnostic statistics of the evolution.
-    """
-    name = "mesolve"
-    _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size":10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-        'method': 'adams',
-    }
-
-    def __init__(self, H, c_ops=None, *, options=None):
-        _time_start = time()
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-        c_ops = c_ops or []
-        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
-        for c_op in c_ops:
-            if not isinstance(c_op, (Qobj, QobjEvo)):
-                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
-
-        self._num_collapse = len(c_ops)
-
-        rhs = H if H.issuper else liouvillian(H)
-        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
-                   for c_op in c_ops)
-
-        Solver.__init__(self, rhs, options=options)
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "solver": "Master Equation Evolution",
-            "num_collapse": self._num_collapse,
-        })
-        return stats
+"""
+This module provides solvers for the Lindblad master equation and von Neumann
+equation.
+"""
+
+__all__ = ['mesolve', 'MESolver']
+
+import numpy as np
+from time import time
+from .. import (Qobj, QobjEvo, isket, liouvillian, ket2dm, lindblad_dissipator)
+from ..core import stack_columns, unstack_columns
+from ..core.data import to
+from .solver_base import Solver
+from .sesolve import sesolve, SESolver
+
+
+def mesolve(H, rho0, tlist, c_ops=None, e_ops=None, args=None, options=None):
+    """
+    Master equation evolution of a density matrix for a given Hamiltonian and
+    set of collapse operators, or a Liouvillian.
+
+    Evolve the state vector or density matrix (`rho0`) using a given
+    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
+    (`c_ops`), by integrating the set of ordinary differential equations
+    that define the system. In the absence of collapse operators the system is
+    evolved according to the unitary evolution of the Hamiltonian.
+
+    The output is either the state vector at arbitrary points in time
+    (`tlist`), or the expectation values of the supplied operators
+    (`e_ops`). If e_ops is a callback function, it is invoked for each
+    time in `tlist` with time and the state as arguments, and the function
+    does not use any return values.
+
+    If either `H` or the Qobj elements in `c_ops` are superoperators, they
+    will be treated as direct contributions to the total system Liouvillian.
+    This allows the solution of master equations that are not in standard
+    Lindblad form.
+
+    **Time-dependent operators**
+
+    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
+    object that can be interpreted as :class:`QobjEvo` such as a list of
+    (Qobj, Coefficient) pairs or a function.
+
+    **Additional options**
+
+    Additional options to mesolve can be set via the `options` argument. Many
+    ODE integration options can be set this way, and the `store_states` and
+    `store_final_state` options can be used to store states even though
+    expectation values are requested via the `e_ops` argument.
+
+    .. note::
+
+        When no collapse operator are given and the `H` is not a superoperator,
+        it will defer to :func:`sesolve`.
+
+    Parameters
+    ----------
+
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    rho0 : :class:`Qobj`
+        initial density matrix or state vector (ket).
+
+    tlist : *list* / *array*
+        list of times for :math:`t`.
+
+    c_ops : list of (:class:`QobjEvo`, :class:`QobjEvo` compatible format)
+        Single collapse operator, or list of collapse operators, or a list
+        of Liouvillian superoperators. None is equivalent to an empty list.
+
+    e_ops : list of :class:`Qobj` / callback function
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
+
+    args : None / *dictionary*
+        dictionary of parameters for time-dependent Hamiltonians and
+        collapse operators.
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        a *list of array* `result.expect` of expectation values for the times
+        specified by `tlist`, and/or a *list* `result.states` of state vectors
+        or density matrices corresponding to the times in `tlist` [if `e_ops`
+        is an empty list of `store_states=True` in options].
+
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+
+    c_ops = c_ops if c_ops is not None else []
+    if not isinstance(c_ops, (list, tuple)):
+        c_ops = [c_ops]
+    c_ops = [QobjEvo(c_op, args=args, tlist=tlist) for c_op in c_ops]
+
+    use_mesolve = len(c_ops) > 0 or (not rho0.isket) or H.issuper
+
+    if not use_mesolve:
+        return sesolve(H, rho0, tlist, e_ops=e_ops, args=args,
+                       options=options)
+
+    solver = MESolver(H, c_ops, options=options)
+
+    return solver.run(rho0, tlist, e_ops=e_ops)
+
+
+class MESolver(SESolver):
+    """
+    Master equation evolution of a density matrix for a given Hamiltonian and
+    set of collapse operators, or a Liouvillian.
+
+    Evolve the density matrix (`rho0`) using a given
+    Hamiltonian or Liouvillian (`H`) and an optional set of collapse operators
+    (`c_ops`), by integrating the set of ordinary differential equations
+    that define the system.
+
+    If either `H` or the Qobj elements in `c_ops` are superoperators, they
+    will be treated as direct contributions to the total system Liouvillian.
+    This allows the solution of master equations that are not in standard
+    Lindblad form.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. List of [:class:`Qobj`, :class:`Coefficient`] or callable that
+        can be made into :class:`QobjEvo` are also accepted.
+
+    c_ops : list of :class:`Qobj`, :class:`QobjEvo`
+        Single collapse operator, or list of collapse operators, or a list
+        of Liouvillian superoperators. None is equivalent to an empty list.
+
+    options : dict, optional
+        Options for the solver, see :obj:`MESolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+
+    attributes
+    ----------
+    stats: dict
+        Diverse diagnostic statistics of the evolution.
+    """
+    name = "mesolve"
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size":10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+        'method': 'adams',
+    }
+
+    def __init__(self, H, c_ops=None, *, options=None):
+        _time_start = time()
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+        c_ops = c_ops or []
+        c_ops = [c_ops] if isinstance(c_ops, (Qobj, QobjEvo)) else c_ops
+        for c_op in c_ops:
+            if not isinstance(c_op, (Qobj, QobjEvo)):
+                raise TypeError("All `c_ops` must be a Qobj or QobjEvo")
+
+        self._num_collapse = len(c_ops)
+
+        rhs = H if H.issuper else liouvillian(H)
+        rhs += sum(c_op if c_op.issuper else lindblad_dissipator(c_op)
+                   for c_op in c_ops)
+
+        Solver.__init__(self, rhs, options=options)
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "solver": "Master Equation Evolution",
+            "num_collapse": self._num_collapse,
+        })
+        return stats
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 3123c72eaf..204178d116 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -1,257 +1,257 @@
-from .. import Qobj, QobjEvo
-from .result import Result, MultiTrajResult
-from .parallel import _get_map
-from time import time
-from .solver_base import Solver
-import numpy as np
-from copy import copy
-
-__all__ = ["MultiTrajSolver", "TrajectorySolver"]
-
-
-class MultiTrajSolver(Solver):
-    """
-    Basic class for multi-trajectory evolutions.
-
-    As :class:`Solver` it can ``run`` or ``step`` evolution.
-    It manages the random seed for each trajectory.
-
-    The actual evolution is done by a single trajectory solver::
-        ``_traj_solver_class``
-
-    Parameters
-    ----------
-    rhs : Qobj, QobjEvo
-        Right hand side of the evolution::
-            d state / dt = rhs @ state
-
-    options : dict
-        Options for the solver.
-    """
-    name = "generic multi trajectory"
-    resultclass = MultiTrajResult
-    _avail_integrators = {}
-
-    # Class of option used by the solver
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "keep_runs_results": False,
-        "normalize_output": False,
-        "method": "",
-        "map": "serial",
-        "job_timeout": None,
-        "num_cpus": None,
-        "bitgenerator": None,
-    }
-
-    def __init__(self, rhs, *, options=None):
-        self.rhs = rhs
-        self.options = options
-        self.seed_sequence = np.random.SeedSequence()
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-    def start(self, state, t0, seed=None):
-        """
-        Set the initial state and time for a step evolution.
-
-        Parameters
-        ----------
-        state : :class:`Qobj`
-            Initial state of the evolution.
-
-        t0 : double
-            Initial time of the evolution.
-
-        seed : int, SeedSequence, list, {None}
-            Seed for the random number generator. It can be a single seed used
-            to spawn seeds for each trajectory or a list of seed, one for each
-            trajectory.
-
-        ..note ::
-            When using step evolution, only one trajectory can be computed at
-            once.
-        """
-        seeds = self._read_seed(seed, 1)
-        generator = self._get_generator(seeds[0])
-        self._integrator.set_state(t0, self._prepare_state(state), generator)
-
-    def step(self, t, *, args=None, copy=True):
-        """
-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-
-        Parameters
-        ----------
-        t : double
-            Time to evolve to, must be higher than the last call.
-
-        args : dict, optional {None}
-            Update the ``args`` of the system.
-            The change is effective from the beginning of the interval.
-            Changing ``args`` can slow the evolution.
-
-        copy : bool, optional {True}
-            Whether to return a copy of the data or the data in the ODE solver.
-        """
-        if not self._integrator._is_set:
-            raise RuntimeError("The `start` method must called first.")
-        self._argument(args)
-        _, state = self._integrator.integrate(t, copy=False)
-        return self._restore_state(state, copy=copy)
-
-    def run(self, state, tlist, ntraj=1, *,
-            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
-        """
-        Do the evolution of the Quantum system.
-
-        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
-        ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :cls:`Result`. The evolution method and stored
-        results are determined by ``options``.
-
-        Parameters
-        ----------
-        state : :class:`Qobj`
-            Initial state of the evolution.
-
-        tlist : list of double
-            Time for which to save the results (state and/or expect) of the
-            evolution. The first element of the list is the initial time of the
-            evolution. Time in the list must be in increasing order, but does
-            not need to be uniformly distributed.
-
-        ntraj : int
-            Number of trajectories to add.
-
-        args : dict, optional {None}
-            Change the ``args`` of the rhs for the evolution.
-
-        e_ops : list
-            list of Qobj or QobjEvo to compute the expectation values.
-            Alternatively, function[s] with the signature f(t, state) -> expect
-            can be used.
-
-        timeout : float, optional [1e8]
-            Maximum time in seconds for the trajectories to run. Once this time
-            is reached, the simulation will end even if the number
-            of trajectories is less than ``ntraj``. The map function, set in
-            options, can interupt the running trajectory or wait for it to
-            finish. Set to an arbitrary high number to disable.
-
-        target_tol : {float, tuple, list}, optional [None]
-            Target tolerance of the evolution. The evolution will compute
-            trajectories until the error on the expectation values is lower
-            than this tolerance. The maximum number of trajectories employed is
-            given by ``ntraj``. The error is computed using jackknife
-            resampling. ``target_tol`` can be an absolute tolerance or a pair
-            of absolute and relative tolerance, in that order. Lastly, it can
-            be a list of pairs of (atol, rtol) for each e_ops.
-
-        seed : {int, SeedSequence, list} optional
-            Seed or list of seeds for each trajectories.
-
-        Return
-        ------
-        results : :class:`qutip.solver.MultiTrajResult`
-            Results of the evolution. States and/or expect will be saved. You
-            can control the saved data in the options.
-
-        .. note:
-            The simulation will end when the first end condition is reached
-            between ``ntraj``, ``timeout`` and ``target_tol``.
-        """
-        start_time = time()
-        self._argument(args)
-        stats = self._initialize_stats()
-        seeds = self._read_seed(seed, ntraj)
-
-        result = self.resultclass(
-            e_ops, self.options, solver=self.name, stats=stats
-        )
-        result.add_end_condition(ntraj, target_tol)
-
-        map_func = _get_map[self.options['map']]
-        map_kw = {
-            'timeout': timeout,
-            'job_timeout': self.options['job_timeout'],
-            'num_cpus': self.options['num_cpus'],
-        }
-        state0 = self._prepare_state(state)
-        stats['preparation time'] += time() - start_time
-
-        start_time = time()
-        map_func(
-            self._run_one_traj, seeds,
-            (state0, tlist, e_ops),
-            reduce_func=result.add, map_kw=map_kw,
-            progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"]
-        )
-        result.stats['run time'] = time() - start_time
-        return result
-
-    def _run_one_traj(self, seed, state, tlist, e_ops):
-        """
-        Run one trajectory and return the result.
-        """
-        result = Result(e_ops, self.options)
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
-        result.add(tlist[0], self._restore_state(state, copy=False))
-        for t in tlist[1:]:
-            t, state = self._integrator.step(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
-        return seed, result
-
-    def _read_seed(self, seed, ntraj):
-        """
-        Read user provided seed(s) and produce one for each trajectory.
-        Let numpy raise error for inputs that cannot be seeds.
-        """
-        if seed is None:
-            seeds = self.seed_sequence.spawn(ntraj)
-        elif isinstance(seed, np.random.SeedSequence):
-            seeds = seed.spawn(ntraj)
-        elif not isinstance(seed, list):
-            seeds = np.random.SeedSequence(seed).spawn(ntraj)
-        elif len(seed) >= ntraj:
-            seeds = [
-                seed_ if (isinstance(seed_, np.random.SeedSequence)
-                          or hasattr(seed_, 'random'))
-                else np.random.SeedSequence(seed_)
-                for seed_ in seed[:ntraj]
-            ]
-        else:
-            raise ValueError("A seed list must be longer than ntraj")
-        return seeds
-
-    def _argument(self, args):
-        """Update the args, for the `rhs` and `c_ops` and other operators."""
-        if args:
-            self.rhs.arguments(args)
-
-    def _get_generator(self, seed):
-        """
-        Read the seed and create the random number generator.
-        If the ``seed`` has a ``random`` method, it will be used as the
-        generator.
-        """
-        if hasattr(seed, 'random'):
-            # We check for the method, not the type to accept pseudo non-random
-            # generator for debug/testing purpose.
-            return seed
-
-        if self.options['bitgenerator']:
-            bit_gen = getattr(np.random, self.options['bitgenerator'])
-            generator = np.random.Generator(bit_gen(seed))
-        else:
-            generator = np.random.default_rng(seed)
-        return generator
-
-    @classmethod
-    def avail_integrators(cls):
-        return cls._avail_integrators
+from .. import Qobj, QobjEvo
+from .result import Result, MultiTrajResult
+from .parallel import _get_map
+from time import time
+from .solver_base import Solver
+import numpy as np
+from copy import copy
+
+__all__ = ["MultiTrajSolver", "TrajectorySolver"]
+
+
+class MultiTrajSolver(Solver):
+    """
+    Basic class for multi-trajectory evolutions.
+
+    As :class:`Solver` it can ``run`` or ``step`` evolution.
+    It manages the random seed for each trajectory.
+
+    The actual evolution is done by a single trajectory solver::
+        ``_traj_solver_class``
+
+    Parameters
+    ----------
+    rhs : Qobj, QobjEvo
+        Right hand side of the evolution::
+            d state / dt = rhs @ state
+
+    options : dict
+        Options for the solver.
+    """
+    name = "generic multi trajectory"
+    resultclass = MultiTrajResult
+    _avail_integrators = {}
+
+    # Class of option used by the solver
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "keep_runs_results": False,
+        "normalize_output": False,
+        "method": "",
+        "map": "serial",
+        "job_timeout": None,
+        "num_cpus": None,
+        "bitgenerator": None,
+    }
+
+    def __init__(self, rhs, *, options=None):
+        self.rhs = rhs
+        self.options = options
+        self.seed_sequence = np.random.SeedSequence()
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+    def start(self, state, t0, seed=None):
+        """
+        Set the initial state and time for a step evolution.
+
+        Parameters
+        ----------
+        state : :class:`Qobj`
+            Initial state of the evolution.
+
+        t0 : double
+            Initial time of the evolution.
+
+        seed : int, SeedSequence, list, {None}
+            Seed for the random number generator. It can be a single seed used
+            to spawn seeds for each trajectory or a list of seed, one for each
+            trajectory.
+
+        ..note ::
+            When using step evolution, only one trajectory can be computed at
+            once.
+        """
+        seeds = self._read_seed(seed, 1)
+        generator = self._get_generator(seeds[0])
+        self._integrator.set_state(t0, self._prepare_state(state), generator)
+
+    def step(self, t, *, args=None, copy=True):
+        """
+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+
+        Parameters
+        ----------
+        t : double
+            Time to evolve to, must be higher than the last call.
+
+        args : dict, optional {None}
+            Update the ``args`` of the system.
+            The change is effective from the beginning of the interval.
+            Changing ``args`` can slow the evolution.
+
+        copy : bool, optional {True}
+            Whether to return a copy of the data or the data in the ODE solver.
+        """
+        if not self._integrator._is_set:
+            raise RuntimeError("The `start` method must called first.")
+        self._argument(args)
+        _, state = self._integrator.integrate(t, copy=False)
+        return self._restore_state(state, copy=copy)
+
+    def run(self, state, tlist, ntraj=1, *,
+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+        """
+        Do the evolution of the Quantum system.
+
+        For a ``state`` at time ``tlist[0]`` do the evolution as directed by
+        ``rhs`` and for each time in ``tlist`` store the state and/or
+        expectation values in a :cls:`Result`. The evolution method and stored
+        results are determined by ``options``.
+
+        Parameters
+        ----------
+        state : :class:`Qobj`
+            Initial state of the evolution.
+
+        tlist : list of double
+            Time for which to save the results (state and/or expect) of the
+            evolution. The first element of the list is the initial time of the
+            evolution. Time in the list must be in increasing order, but does
+            not need to be uniformly distributed.
+
+        ntraj : int
+            Number of trajectories to add.
+
+        args : dict, optional {None}
+            Change the ``args`` of the rhs for the evolution.
+
+        e_ops : list
+            list of Qobj or QobjEvo to compute the expectation values.
+            Alternatively, function[s] with the signature f(t, state) -> expect
+            can be used.
+
+        timeout : float, optional [1e8]
+            Maximum time in seconds for the trajectories to run. Once this time
+            is reached, the simulation will end even if the number
+            of trajectories is less than ``ntraj``. The map function, set in
+            options, can interupt the running trajectory or wait for it to
+            finish. Set to an arbitrary high number to disable.
+
+        target_tol : {float, tuple, list}, optional [None]
+            Target tolerance of the evolution. The evolution will compute
+            trajectories until the error on the expectation values is lower
+            than this tolerance. The maximum number of trajectories employed is
+            given by ``ntraj``. The error is computed using jackknife
+            resampling. ``target_tol`` can be an absolute tolerance or a pair
+            of absolute and relative tolerance, in that order. Lastly, it can
+            be a list of pairs of (atol, rtol) for each e_ops.
+
+        seed : {int, SeedSequence, list} optional
+            Seed or list of seeds for each trajectories.
+
+        Return
+        ------
+        results : :class:`qutip.solver.MultiTrajResult`
+            Results of the evolution. States and/or expect will be saved. You
+            can control the saved data in the options.
+
+        .. note:
+            The simulation will end when the first end condition is reached
+            between ``ntraj``, ``timeout`` and ``target_tol``.
+        """
+        start_time = time()
+        self._argument(args)
+        stats = self._initialize_stats()
+        seeds = self._read_seed(seed, ntraj)
+
+        result = self.resultclass(
+            e_ops, self.options, solver=self.name, stats=stats
+        )
+        result.add_end_condition(ntraj, target_tol)
+
+        map_func = _get_map[self.options['map']]
+        map_kw = {
+            'timeout': timeout,
+            'job_timeout': self.options['job_timeout'],
+            'num_cpus': self.options['num_cpus'],
+        }
+        state0 = self._prepare_state(state)
+        stats['preparation time'] += time() - start_time
+
+        start_time = time()
+        map_func(
+            self._run_one_traj, seeds,
+            (state0, tlist, e_ops),
+            reduce_func=result.add, map_kw=map_kw,
+            progress_bar=self.options["progress_bar"],
+            progress_bar_kwargs=self.options["progress_kwargs"]
+        )
+        result.stats['run time'] = time() - start_time
+        return result
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        result = Result(e_ops, self.options)
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator)
+        result.add(tlist[0], self._restore_state(state, copy=False))
+        for t in tlist[1:]:
+            t, state = self._integrator.step(t, copy=False)
+            result.add(t, self._restore_state(state, copy=False))
+        return seed, result
+
+    def _read_seed(self, seed, ntraj):
+        """
+        Read user provided seed(s) and produce one for each trajectory.
+        Let numpy raise error for inputs that cannot be seeds.
+        """
+        if seed is None:
+            seeds = self.seed_sequence.spawn(ntraj)
+        elif isinstance(seed, np.random.SeedSequence):
+            seeds = seed.spawn(ntraj)
+        elif not isinstance(seed, list):
+            seeds = np.random.SeedSequence(seed).spawn(ntraj)
+        elif len(seed) >= ntraj:
+            seeds = [
+                seed_ if (isinstance(seed_, np.random.SeedSequence)
+                          or hasattr(seed_, 'random'))
+                else np.random.SeedSequence(seed_)
+                for seed_ in seed[:ntraj]
+            ]
+        else:
+            raise ValueError("A seed list must be longer than ntraj")
+        return seeds
+
+    def _argument(self, args):
+        """Update the args, for the `rhs` and `c_ops` and other operators."""
+        if args:
+            self.rhs.arguments(args)
+
+    def _get_generator(self, seed):
+        """
+        Read the seed and create the random number generator.
+        If the ``seed`` has a ``random`` method, it will be used as the
+        generator.
+        """
+        if hasattr(seed, 'random'):
+            # We check for the method, not the type to accept pseudo non-random
+            # generator for debug/testing purpose.
+            return seed
+
+        if self.options['bitgenerator']:
+            bit_gen = getattr(np.random, self.options['bitgenerator'])
+            generator = np.random.Generator(bit_gen(seed))
+        else:
+            generator = np.random.default_rng(seed)
+        return generator
+
+    @classmethod
+    def avail_integrators(cls):
+        return cls._avail_integrators
diff --git a/qutip/solver/options.py b/qutip/solver/options.py
index 737724b92a..207fa89737 100644
--- a/qutip/solver/options.py
+++ b/qutip/solver/options.py
@@ -1,106 +1,106 @@
-__all__ = ["Options", "SolverOptions"]
-
-import warnings
-
-
-def SolverOptions(*args, **kwargs):
-    warnings.warn(
-        "Dedicated options class are no longer needed, "
-        "options should be passed as dict to solvers.",
-        FutureWarning
-    )
-    return kwargs
-
-
-def Options(**kwargs):
-    warnings.warn(
-        "Dedicated options class are no longer needed, "
-        "options should be passed as dict to solvers.",
-        FutureWarning
-    )
-    return kwargs
-
-
-class _SolverOptions(dict):
-    """
-    Class to hold options for solver and integrator.
-
-    Parameters
-    ----------
-    default : dict
-        Default dict, only keys in this will be accepted.
-    feedback : callable, ``f(keys : set) -> None``, optional
-        Function to called when an item is updated.
-    name : str, optional
-        Name of the solver or integrator that use this. Used in __repr__ only.
-    doc : str, optional
-        Overwrite the __doc__ of the instance.
-    """
-    def __init__(
-        self, default, feedback=None, name="", doc="", /, **kwargs
-    ):
-        self._default = default
-        self.__doc__ = doc
-        self._feedback = feedback
-        self._name = name
-        extra_keys = kwargs.keys() - default.keys()
-        if extra_keys:
-            raise KeyError(f"Options {extra_keys} are not supported.")
-        super().__init__(**{**self._default, **kwargs})
-
-    def __setitem__(self, key, val):
-        if key not in self._default:
-            raise KeyError(f"Options {key} is not supported.")
-        if val is None:
-            val = self._default[key]
-        if val == self[key]:
-            return
-        super().__setitem__(key, val)
-        if self._feedback:
-            self._feedback(key)
-
-    def __delitem__(self, key):
-        if key not in self._default:
-            raise KeyError(f"Options {key} is not supported.")
-        super().__setitem__(key, self._default[key])
-        if self._feedback:
-            self._feedback(key)
-
-    def copy(self):
-        return self.__class__(
-            self._default,
-            self._feedback,
-            self._name,
-            self.__doc__,
-            **self
-        )
-
-    def __str__(self):
-        lines = []
-        longest = max(len(key) for key in self.keys())
-        lines.append(f"Options for {self._name}:")
-        for key in self.keys():
-            default = "(default)" if self[key] == self._default[key] else ""
-            lines.append(f"    {key:{longest}} : "
-                         f"{self[key].__repr__():{70-longest}}"
-                         f"{default}")
-        return "\n".join(lines)
-
-    @classmethod
-    def _from_reduced(cls, default, feedback, name, doc, keys, args):
-        return cls(default, feedback, name, doc, **{
-            key: arg for key, arg in zip(keys, args)
-        })
-
-    def __reduce__(self):
-        return (
-            self._from_reduced,
-            (
-                self._default,
-                self._feedback,
-                self._name,
-                self.__doc__,
-                tuple(self.keys()),
-                tuple(self.values())
-                )
-            )
+__all__ = ["Options", "SolverOptions"]
+
+import warnings
+
+
+def SolverOptions(*args, **kwargs):
+    warnings.warn(
+        "Dedicated options class are no longer needed, "
+        "options should be passed as dict to solvers.",
+        FutureWarning
+    )
+    return kwargs
+
+
+def Options(**kwargs):
+    warnings.warn(
+        "Dedicated options class are no longer needed, "
+        "options should be passed as dict to solvers.",
+        FutureWarning
+    )
+    return kwargs
+
+
+class _SolverOptions(dict):
+    """
+    Class to hold options for solver and integrator.
+
+    Parameters
+    ----------
+    default : dict
+        Default dict, only keys in this will be accepted.
+    feedback : callable, ``f(keys : set) -> None``, optional
+        Function to called when an item is updated.
+    name : str, optional
+        Name of the solver or integrator that use this. Used in __repr__ only.
+    doc : str, optional
+        Overwrite the __doc__ of the instance.
+    """
+    def __init__(
+        self, default, feedback=None, name="", doc="", /, **kwargs
+    ):
+        self._default = default
+        self.__doc__ = doc
+        self._feedback = feedback
+        self._name = name
+        extra_keys = kwargs.keys() - default.keys()
+        if extra_keys:
+            raise KeyError(f"Options {extra_keys} are not supported.")
+        super().__init__(**{**self._default, **kwargs})
+
+    def __setitem__(self, key, val):
+        if key not in self._default:
+            raise KeyError(f"Options {key} is not supported.")
+        if val is None:
+            val = self._default[key]
+        if val == self[key]:
+            return
+        super().__setitem__(key, val)
+        if self._feedback:
+            self._feedback(key)
+
+    def __delitem__(self, key):
+        if key not in self._default:
+            raise KeyError(f"Options {key} is not supported.")
+        super().__setitem__(key, self._default[key])
+        if self._feedback:
+            self._feedback(key)
+
+    def copy(self):
+        return self.__class__(
+            self._default,
+            self._feedback,
+            self._name,
+            self.__doc__,
+            **self
+        )
+
+    def __str__(self):
+        lines = []
+        longest = max(len(key) for key in self.keys())
+        lines.append(f"Options for {self._name}:")
+        for key in self.keys():
+            default = "(default)" if self[key] == self._default[key] else ""
+            lines.append(f"    {key:{longest}} : "
+                         f"{self[key].__repr__():{70-longest}}"
+                         f"{default}")
+        return "\n".join(lines)
+
+    @classmethod
+    def _from_reduced(cls, default, feedback, name, doc, keys, args):
+        return cls(default, feedback, name, doc, **{
+            key: arg for key, arg in zip(keys, args)
+        })
+
+    def __reduce__(self):
+        return (
+            self._from_reduced,
+            (
+                self._default,
+                self._feedback,
+                self._name,
+                self.__doc__,
+                tuple(self.keys()),
+                tuple(self.values())
+                )
+            )
diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
index 2c41fb7c06..4ceeb0fc44 100644
--- a/qutip/solver/parallel.py
+++ b/qutip/solver/parallel.py
@@ -1,370 +1,370 @@
-"""
-This module provides functions for parallel execution of loops and function
-mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
-"""
-__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
-
-import multiprocessing
-import os
-import sys
-import time
-import threading
-import concurrent.futures
-from qutip.ui.progressbar import progess_bars
-from qutip.settings import available_cpu_count
-
-if sys.platform == 'darwin':
-    mp_context = multiprocessing.get_context('fork')
-elif sys.platform == 'linux':
-    # forkserver would handle threads better, but is much slower at starting
-    # the executor and spawning tasks
-    mp_context = multiprocessing.get_context('fork')
-else:
-    mp_context = multiprocessing.get_context()
-
-
-default_map_kw = {
-    'job_timeout': threading.TIMEOUT_MAX,
-    'timeout': threading.TIMEOUT_MAX,
-    'num_cpus': available_cpu_count(),
-    'fail_fast': True,
-}
-
-
-def _read_map_kw(options):
-    options = options or {}
-    map_kw = default_map_kw.copy()
-    map_kw.update({k: v for k, v in options.items() if v is not None})
-    return map_kw
-
-
-class MapExceptions(Exception):
-    def __init__(self, msg, errors, results):
-        super().__init__(msg, errors, results)
-        self.errors = errors
-        self.results = results
-
-
-def serial_map(task, values, task_args=None, task_kwargs=None,
-               reduce_func=None, map_kw=None,
-               progress_bar=None, progress_bar_kwargs={}):
-    """
-    Serial mapping function with the same call signature as parallel_map, for
-    easy switching between serial and parallel execution. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    reduce_func : func (optional)
-        If provided, it will be called with the output of each tasks instead of
-        storing a them in a list.
-    progress_bar : string
-        Progress bar options's string for showing progress.
-    progress_bar_kwargs : dict
-        Options for the progress bar.
-    map_kw: dict (optional)
-        Dictionary containing:
-        - timeout: float, Maximum time (sec) for the whole map.
-        - fail_fast: bool, Raise an error at the first.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for each
-        value in ``values``. If a ``reduce_func`` is provided, and empty list
-        will be returned.
-
-    """
-    if task_args is None:
-        task_args = ()
-    if task_kwargs is None:
-        task_kwargs = {}
-    map_kw = _read_map_kw(map_kw)
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
-    end_time = map_kw['timeout'] + time.time()
-    results = None
-    if reduce_func is None:
-        results = [None] * len(values)
-    errors = {}
-    for n, value in enumerate(values):
-        if time.time() > end_time:
-            break
-        progress_bar.update(n)
-        try:
-            result = task(value, *task_args, **task_kwargs)
-        except Exception as err:
-            if map_kw["fail_fast"]:
-                raise err
-            else:
-                errors[n] = err
-        else:
-            if reduce_func is not None:
-                reduce_func(result)
-            else:
-                results[n] = result
-    progress_bar.finished()
-
-    if errors:
-        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
-                            errors, results)
-    return results
-
-
-def parallel_map(task, values, task_args=None, task_kwargs=None,
-                 reduce_func=None, map_kw=None,
-                 progress_bar=None, progress_bar_kwargs={}):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    reduce_func : func (optional)
-        If provided, it will be called with the output of each tasks instead of
-        storing a them in a list. Note that the order in which results are
-        passed to ``reduce_func`` is not defined.
-    progress_bar : string
-        Progress bar options's string for showing progress.
-    progress_bar_kwargs : dict
-        Options for the progress bar.
-    map_kw: dict (optional)
-        Dictionary containing entry for:
-        - timeout: float, Maximum time (sec) for the whole map.
-        - job_timeout: float, Maximum time (sec) for each job in the map.
-        - num_cpus: int, Number of job to run at once.
-        - fail_fast: bool, Raise an error at the first.
-
-    Returns
-    -------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``. If a ``reduce_func`` is provided, and empty
-        list will be returned.
-
-    """
-    if task_args is None:
-        task_args = ()
-    if task_kwargs is None:
-        task_kwargs = {}
-    map_kw = _read_map_kw(map_kw)
-    end_time = map_kw['timeout'] + time.time()
-    job_time = map_kw['job_timeout']
-
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
-
-    errors = {}
-    if reduce_func is not None:
-        results = None
-        result_func = lambda i, value: reduce_func(value)
-    else:
-        results = [None] * len(values)
-        result_func = lambda i, value: results.__setitem__(i, value)
-
-    def _done_callback(future):
-        if not future.cancelled():
-            try:
-                result = future.result()
-            except Exception as e:
-                errors[future._i] = e
-        result_func(future._i, result)
-        progress_bar.update()
-
-    if sys.version_info >= (3, 7):
-        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
-        ctx_kw = {"mp_context": mp_context}
-    else:
-        ctx_kw = {}
-
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    try:
-        with concurrent.futures.ProcessPoolExecutor(
-            max_workers=map_kw['num_cpus'], **ctx_kw,
-        ) as executor:
-            waiting = set()
-            i = 0
-            while i < len(values):
-                # feed values to the executor, ensuring that there is at
-                # most one task per worker at any moment in time so that
-                # we can shutdown without waiting for greater than the time
-                # taken by the longest task
-                if len(waiting) >= map_kw['num_cpus']:
-                    # no space left, wait for a task to complete or
-                    # the time to run out
-                    timeout = max(0, end_time - time.time())
-                    _done, waiting = concurrent.futures.wait(
-                        waiting,
-                        timeout=timeout,
-                        return_when=concurrent.futures.FIRST_COMPLETED,
-                    )
-                if time.time() >= end_time or (errors and map_kw['fail_fast']):
-                    # no time left, exit the loop
-                    break
-                while len(waiting) < map_kw['num_cpus'] and i < len(values):
-                    # space and time available, add tasks
-                    value = values[i]
-                    future = executor.submit(
-                        task, *((value,) + task_args), **task_kwargs,
-                    )
-                    # small hack to avoid add_done_callback not supporting
-                    # extra arguments and closures inside loops retaining
-                    # a reference not a value:
-                    future._i = i
-                    future.add_done_callback(_done_callback)
-                    waiting.add(future)
-                    i += 1
-
-            timeout = max(0, end_time - time.time())
-            concurrent.futures.wait(waiting, timeout=timeout)
-    finally:
-        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-
-    progress_bar.finished()
-    if errors and map_kw["fail_fast"]:
-        raise list(errors.values())[0]
-    elif errors:
-        raise MapExceptions(
-            f"{len(errors)} iterations failed in parallel_map",
-            errors, results
-        )
-
-    return results
-
-
-def loky_pmap(task, values, task_args=None, task_kwargs=None,
-              reduce_func=None, map_kw=None,
-              progress_bar=None, progress_bar_kwargs={}):
-    """
-    Parallel execution of a mapping of `values` to the function `task`. This
-    is functionally equivalent to::
-
-        result = [task(value, *task_args, **task_kwargs) for value in values]
-
-    Use the loky module instead of multiprocessing.
-
-    Parameters
-    ----------
-    task : a Python function
-        The function that is to be called for each value in ``task_vec``.
-    values : array / list
-        The list or array of values for which the ``task`` function is to be
-        evaluated.
-    task_args : list / dictionary
-        The optional additional argument to the ``task`` function.
-    task_kwargs : list / dictionary
-        The optional additional keyword argument to the ``task`` function.
-    reduce_func : func (optional)
-        If provided, it will be called with the output of each tasks instead of
-        storing a them in a list.
-    progress_bar : string
-        Progress bar options's string for showing progress.
-    progress_bar_kwargs : dict
-        Options for the progress bar.
-    map_kw: dict (optional)
-        Dictionary containing entry for:
-        - timeout: float, Maximum time (sec) for the whole map.
-        - job_timeout: float, Maximum time (sec) for each job in the map.
-        - num_cpus: int, Number of job to run at once.
-        - fail_fast: bool, Raise an error at the first.
-
-    Returns
-    --------
-    result : list
-        The result list contains the value of
-        ``task(value, *task_args, **task_kwargs)`` for
-        each value in ``values``. If a ``reduce_func`` is provided, and empty
-        list will be returned.
-
-    """
-    if task_args is None:
-        task_args = ()
-    if task_kwargs is None:
-        task_kwargs = {}
-    map_kw = _read_map_kw(map_kw)
-    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
-    from loky import get_reusable_executor, TimeoutError
-
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
-
-    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
-    end_time = map_kw['timeout'] + time.time()
-    job_time = map_kw['job_timeout']
-    results = None
-    errors = {}
-    if reduce_func is None:
-        results = [None] * len(values)
-
-    try:
-        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
-               for value in values]
-
-        for n, job in enumerate(jobs):
-            remaining_time = min(end_time - time.time(), job_time)
-            try:
-                result = job.result(remaining_time)
-            except Exception as err:
-                if map_kw["fail_fast"]:
-                    raise err
-                else:
-                    errors[n] = err
-            else:
-                if reduce_func is not None:
-                    reduce_func(result)
-                else:
-                    results[n] = result
-            progress_bar.update()
-
-    except KeyboardInterrupt as e:
-        [job.cancel() for job in jobs]
-        raise e
-
-    except TimeoutError:
-        [job.cancel() for job in jobs]
-
-    finally:
-        executor.shutdown()
-    progress_bar.finished()
-    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
-    if errors:
-        raise MapExceptions(
-            f"{len(errors)} iterations failed in loky_pmap",
-            errors, results
-        )
-    return results
-
-
-_get_map = {
-    "parallel_map": parallel_map,
-    "parallel": parallel_map,
-    "serial_map": serial_map,
-    "serial": serial_map,
-    "loky": loky_pmap
-}
+"""
+This module provides functions for parallel execution of loops and function
+mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
+"""
+__all__ = ['parallel_map', 'serial_map', 'loky_pmap']
+
+import multiprocessing
+import os
+import sys
+import time
+import threading
+import concurrent.futures
+from qutip.ui.progressbar import progess_bars
+from qutip.settings import available_cpu_count
+
+if sys.platform == 'darwin':
+    mp_context = multiprocessing.get_context('fork')
+elif sys.platform == 'linux':
+    # forkserver would handle threads better, but is much slower at starting
+    # the executor and spawning tasks
+    mp_context = multiprocessing.get_context('fork')
+else:
+    mp_context = multiprocessing.get_context()
+
+
+default_map_kw = {
+    'job_timeout': threading.TIMEOUT_MAX,
+    'timeout': threading.TIMEOUT_MAX,
+    'num_cpus': available_cpu_count(),
+    'fail_fast': True,
+}
+
+
+def _read_map_kw(options):
+    options = options or {}
+    map_kw = default_map_kw.copy()
+    map_kw.update({k: v for k, v in options.items() if v is not None})
+    return map_kw
+
+
+class MapExceptions(Exception):
+    def __init__(self, msg, errors, results):
+        super().__init__(msg, errors, results)
+        self.errors = errors
+        self.results = results
+
+
+def serial_map(task, values, task_args=None, task_kwargs=None,
+               reduce_func=None, map_kw=None,
+               progress_bar=None, progress_bar_kwargs={}):
+    """
+    Serial mapping function with the same call signature as parallel_map, for
+    easy switching between serial and parallel execution. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    This function work as a drop-in replacement of :func:`qutip.parallel_map`.
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    reduce_func : func (optional)
+        If provided, it will be called with the output of each tasks instead of
+        storing a them in a list.
+    progress_bar : string
+        Progress bar options's string for showing progress.
+    progress_bar_kwargs : dict
+        Options for the progress bar.
+    map_kw: dict (optional)
+        Dictionary containing:
+        - timeout: float, Maximum time (sec) for the whole map.
+        - fail_fast: bool, Raise an error at the first.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for each
+        value in ``values``. If a ``reduce_func`` is provided, and empty list
+        will be returned.
+
+    """
+    if task_args is None:
+        task_args = ()
+    if task_kwargs is None:
+        task_kwargs = {}
+    map_kw = _read_map_kw(map_kw)
+    progress_bar = progess_bars[progress_bar]()
+    progress_bar.start(len(values), **progress_bar_kwargs)
+    end_time = map_kw['timeout'] + time.time()
+    results = None
+    if reduce_func is None:
+        results = [None] * len(values)
+    errors = {}
+    for n, value in enumerate(values):
+        if time.time() > end_time:
+            break
+        progress_bar.update(n)
+        try:
+            result = task(value, *task_args, **task_kwargs)
+        except Exception as err:
+            if map_kw["fail_fast"]:
+                raise err
+            else:
+                errors[n] = err
+        else:
+            if reduce_func is not None:
+                reduce_func(result)
+            else:
+                results[n] = result
+    progress_bar.finished()
+
+    if errors:
+        raise MapExceptions(f"{len(errors)} iterations failed in serial_map",
+                            errors, results)
+    return results
+
+
+def parallel_map(task, values, task_args=None, task_kwargs=None,
+                 reduce_func=None, map_kw=None,
+                 progress_bar=None, progress_bar_kwargs={}):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    reduce_func : func (optional)
+        If provided, it will be called with the output of each tasks instead of
+        storing a them in a list. Note that the order in which results are
+        passed to ``reduce_func`` is not defined.
+    progress_bar : string
+        Progress bar options's string for showing progress.
+    progress_bar_kwargs : dict
+        Options for the progress bar.
+    map_kw: dict (optional)
+        Dictionary containing entry for:
+        - timeout: float, Maximum time (sec) for the whole map.
+        - job_timeout: float, Maximum time (sec) for each job in the map.
+        - num_cpus: int, Number of job to run at once.
+        - fail_fast: bool, Raise an error at the first.
+
+    Returns
+    -------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``. If a ``reduce_func`` is provided, and empty
+        list will be returned.
+
+    """
+    if task_args is None:
+        task_args = ()
+    if task_kwargs is None:
+        task_kwargs = {}
+    map_kw = _read_map_kw(map_kw)
+    end_time = map_kw['timeout'] + time.time()
+    job_time = map_kw['job_timeout']
+
+    progress_bar = progess_bars[progress_bar]()
+    progress_bar.start(len(values), **progress_bar_kwargs)
+
+    errors = {}
+    if reduce_func is not None:
+        results = None
+        result_func = lambda i, value: reduce_func(value)
+    else:
+        results = [None] * len(values)
+        result_func = lambda i, value: results.__setitem__(i, value)
+
+    def _done_callback(future):
+        if not future.cancelled():
+            try:
+                result = future.result()
+            except Exception as e:
+                errors[future._i] = e
+        result_func(future._i, result)
+        progress_bar.update()
+
+    if sys.version_info >= (3, 7):
+        # ProcessPoolExecutor only supports mp_context from 3.7 onwards
+        ctx_kw = {"mp_context": mp_context}
+    else:
+        ctx_kw = {}
+
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    try:
+        with concurrent.futures.ProcessPoolExecutor(
+            max_workers=map_kw['num_cpus'], **ctx_kw,
+        ) as executor:
+            waiting = set()
+            i = 0
+            while i < len(values):
+                # feed values to the executor, ensuring that there is at
+                # most one task per worker at any moment in time so that
+                # we can shutdown without waiting for greater than the time
+                # taken by the longest task
+                if len(waiting) >= map_kw['num_cpus']:
+                    # no space left, wait for a task to complete or
+                    # the time to run out
+                    timeout = max(0, end_time - time.time())
+                    _done, waiting = concurrent.futures.wait(
+                        waiting,
+                        timeout=timeout,
+                        return_when=concurrent.futures.FIRST_COMPLETED,
+                    )
+                if time.time() >= end_time or (errors and map_kw['fail_fast']):
+                    # no time left, exit the loop
+                    break
+                while len(waiting) < map_kw['num_cpus'] and i < len(values):
+                    # space and time available, add tasks
+                    value = values[i]
+                    future = executor.submit(
+                        task, *((value,) + task_args), **task_kwargs,
+                    )
+                    # small hack to avoid add_done_callback not supporting
+                    # extra arguments and closures inside loops retaining
+                    # a reference not a value:
+                    future._i = i
+                    future.add_done_callback(_done_callback)
+                    waiting.add(future)
+                    i += 1
+
+            timeout = max(0, end_time - time.time())
+            concurrent.futures.wait(waiting, timeout=timeout)
+    finally:
+        os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+
+    progress_bar.finished()
+    if errors and map_kw["fail_fast"]:
+        raise list(errors.values())[0]
+    elif errors:
+        raise MapExceptions(
+            f"{len(errors)} iterations failed in parallel_map",
+            errors, results
+        )
+
+    return results
+
+
+def loky_pmap(task, values, task_args=None, task_kwargs=None,
+              reduce_func=None, map_kw=None,
+              progress_bar=None, progress_bar_kwargs={}):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    Use the loky module instead of multiprocessing.
+
+    Parameters
+    ----------
+    task : a Python function
+        The function that is to be called for each value in ``task_vec``.
+    values : array / list
+        The list or array of values for which the ``task`` function is to be
+        evaluated.
+    task_args : list / dictionary
+        The optional additional argument to the ``task`` function.
+    task_kwargs : list / dictionary
+        The optional additional keyword argument to the ``task`` function.
+    reduce_func : func (optional)
+        If provided, it will be called with the output of each tasks instead of
+        storing a them in a list.
+    progress_bar : string
+        Progress bar options's string for showing progress.
+    progress_bar_kwargs : dict
+        Options for the progress bar.
+    map_kw: dict (optional)
+        Dictionary containing entry for:
+        - timeout: float, Maximum time (sec) for the whole map.
+        - job_timeout: float, Maximum time (sec) for each job in the map.
+        - num_cpus: int, Number of job to run at once.
+        - fail_fast: bool, Raise an error at the first.
+
+    Returns
+    --------
+    result : list
+        The result list contains the value of
+        ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``. If a ``reduce_func`` is provided, and empty
+        list will be returned.
+
+    """
+    if task_args is None:
+        task_args = ()
+    if task_kwargs is None:
+        task_kwargs = {}
+    map_kw = _read_map_kw(map_kw)
+    os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
+    from loky import get_reusable_executor, TimeoutError
+
+    progress_bar = progess_bars[progress_bar]()
+    progress_bar.start(len(values), **progress_bar_kwargs)
+
+    executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
+    end_time = map_kw['timeout'] + time.time()
+    job_time = map_kw['job_timeout']
+    results = None
+    errors = {}
+    if reduce_func is None:
+        results = [None] * len(values)
+
+    try:
+        jobs = [executor.submit(task, value, *task_args, **task_kwargs)
+               for value in values]
+
+        for n, job in enumerate(jobs):
+            remaining_time = min(end_time - time.time(), job_time)
+            try:
+                result = job.result(remaining_time)
+            except Exception as err:
+                if map_kw["fail_fast"]:
+                    raise err
+                else:
+                    errors[n] = err
+            else:
+                if reduce_func is not None:
+                    reduce_func(result)
+                else:
+                    results[n] = result
+            progress_bar.update()
+
+    except KeyboardInterrupt as e:
+        [job.cancel() for job in jobs]
+        raise e
+
+    except TimeoutError:
+        [job.cancel() for job in jobs]
+
+    finally:
+        executor.shutdown()
+    progress_bar.finished()
+    os.environ['QUTIP_IN_PARALLEL'] = 'FALSE'
+    if errors:
+        raise MapExceptions(
+            f"{len(errors)} iterations failed in loky_pmap",
+            errors, results
+        )
+    return results
+
+
+_get_map = {
+    "parallel_map": parallel_map,
+    "parallel": parallel_map,
+    "serial_map": serial_map,
+    "serial": serial_map,
+    "loky": loky_pmap
+}
diff --git a/qutip/solver/propagator.py b/qutip/solver/propagator.py
index 5ad10b6c6a..179c0dcef0 100644
--- a/qutip/solver/propagator.py
+++ b/qutip/solver/propagator.py
@@ -1,278 +1,278 @@
-__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
-
-import numbers
-import numpy as np
-
-from .. import Qobj, qeye, unstack_columns, QobjEvo
-from ..core import data as _data
-from .mesolve import mesolve, MESolver
-from .sesolve import sesolve, SESolver
-from .heom.bofin_solvers import HEOMSolver
-from .solver_base import Solver
-from .multitraj import MultiTrajSolver
-
-
-def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
-    r"""
-    Calculate the propagator U(t) for the density matrix or wave function such
-    that :math:`\psi(t) = U(t)\psi(0)` or
-    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
-    where :math:`\rho_{\mathrm vec}` is the vector representation of the
-    density matrix.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
-        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    t : float or array-like
-        Time or list of times for which to evaluate the propagator.
-
-    c_ops : list, optional
-        List of Qobj or QobjEvo collapse operators.
-
-    args : dictionary, optional
-        Parameters to callback functions for time-dependent Hamiltonians and
-        collapse operators.
-
-    options : dict, optional
-        Options for the solver.
-
-    **kwargs :
-        Extra parameters to use when creating the :class:`QobjEvo` from a list
-        format ``H``.
-
-    Returns
-    -------
-    U : qobj, list
-        Instance representing the propagator(s) :math:`U(t)`. Return a single
-        Qobj when ``t`` is a number or a list when ``t`` is a list.
-
-    """
-    if isinstance(t, numbers.Real):
-        tlist = [0, t]
-        list_output = False
-    else:
-        tlist = t
-        list_output = True
-
-    if not isinstance(H, (Qobj, QobjEvo)):
-        H = QobjEvo(H, args=args, **kwargs)
-
-    if H.issuper or c_ops:
-        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
-                      args=args, options=options).states
-    else:
-        out = sesolve(H, qeye(H.dims[0]), tlist,
-                      args=args, options=options).states
-
-    if list_output:
-        return out
-    else:
-        return out[-1]
-
-
-def propagator_steadystate(U):
-    r"""Find the steady state for successive applications of the propagator
-    :math:`U`.
-
-    Parameters
-    ----------
-    U : qobj
-        Operator representing the propagator.
-
-    Returns
-    -------
-    a : qobj
-        Instance representing the steady-state density matrix.
-    """
-    evals, estates = U.eigenstates()
-    shifted_vals = np.abs(evals - 1.0)
-    ev_idx = np.argmin(shifted_vals)
-    rho_data = unstack_columns(estates[ev_idx].data)
-    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
-    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
-                dims=U.dims[0],
-                type='oper',
-                isherm=True,
-                copy=False)
-
-
-class Propagator:
-    """
-    A generator of propagator for a system.
-
-    Usage:
-        U = Propagator(H, c_ops)
-        psi_t = U(t) @ psi_0
-
-    Save some previously computed propagator are stored to speed up subsequent
-    computation. Changing ``args`` will erase these stored probagator.
-
-    Parameters
-    ----------
-    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
-        Possibly time-dependent system driving the evolution, either already
-        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
-        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
-        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
-        be made into :class:`QobjEvo` are also accepted.
-
-        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
-        not supported.
-
-    c_ops : list, optional
-        List of Qobj or QobjEvo collapse operators.
-
-    args : dictionary
-        Parameters to callback functions for time-dependent Hamiltonians and
-        collapse operators.
-
-    options : dict
-        Options for the solver.
-
-    memoize : int [10]
-        Max number of propagator to save.
-
-    tol : float [1e-14]
-        Absolute tolerance for the time. If a previous propagator was computed
-        at a time within tolerance, that propagator will be returned.
-
-    .. note::
-        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
-        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
-        into a :class:`QobjEvo` with ::
-            U = QobjEvo(Propagator(H))
-    """
-    def __init__(self, system, *, c_ops=(), args=None, options=None,
-                 memoize=10, tol=1e-14):
-        if isinstance(system, MultiTrajSolver):
-            raise TypeError("Non-deterministic solvers cannot be used "
-                            "as a propagator system")
-        elif isinstance(system, HEOMSolver):
-            raise NotImplementedError(
-                "HEOM is not supported by Propagator. "
-                "Please, tell us on GitHub issues if you need it!"
-            )
-        elif isinstance(system, Solver):
-            self.solver = system
-        else:
-            Hevo = QobjEvo(system, args=args)
-            c_ops = [QobjEvo(op, args=args) for op in c_ops]
-            if Hevo.issuper or c_ops:
-                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
-            else:
-                self.solver = SESolver(Hevo, options=options)
-
-        self.times = [0]
-        self.invs = [None]
-        self.props = [qeye(self.solver.sys_dims)]
-        self.solver.start(self.props[0], self.times[0])
-        self.cte = self.solver.rhs.isconstant
-        H_0 = self.solver.rhs(0)
-        self.unitary = not H_0.issuper and H_0.isherm
-        self.args = args
-        self.memoize = max(3, int(memoize))
-        self.tol = tol
-
-    def _lookup_or_compute(self, t):
-        """
-        Get U(t) from cache or compute it.
-        """
-        idx = np.searchsorted(self.times, t)
-        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
-            U = self.props[idx]
-        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
-            U = self.props[idx-1]
-        else:
-            U = self._compute(t, idx)
-            self._insert(t, U, idx)
-        return U
-
-    def __call__(self, t, t_start=0, **args):
-        """
-        Get the propagator from ``t_start`` to ``t``.
-
-        Parameters
-        ----------
-        t : float
-            Time at which to compute the propagator.
-        t_start: float [0]
-            Time at which the propagator start such that:
-                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
-        args : dict
-            Argument to pass to a time dependent Hamiltonian.
-            Updating ``args`` take effect since ``t=0`` and the new ``args``
-            will be used in future call.
-        """
-        # We could improve it when the system is constant using U(2t) = U(t)**2
-        if not self.cte and args and args != self.args:
-            self.args = args
-            self.solver._argument(args)
-            self.times = [0]
-            self.props = [qeye(self.props[0].dims[0])]
-            self.solver.start(self.props[0], self.times[0])
-
-        if t_start:
-            if t == t_start:
-                U = self._lookup_or_compute(0)
-            if self.cte:
-                U = self._lookup_or_compute(t - t_start)
-            else:
-                Uinv = self._inv(self._lookup_or_compute(t_start))
-                U = self._lookup_or_compute(t) @ Uinv
-        else:
-            U = self._lookup_or_compute(t)
-        return U
-
-    def inv(self, t, **args):
-        """
-        Get the inverse of the propagator at ``t``, such that
-            ``psi_0 = U.inv(t) @ psi_t``
-
-        Parameters
-        ----------
-        t : float
-            Time at which to compute the propagator.
-        args : dict
-            Argument to pass to a time dependent Hamiltonian.
-            Updating ``args`` take effect since ``t=0`` and the new ``args``
-            will be used in future call.
-        """
-        return self._inv(self(t, **args))
-
-    def _compute(self, t, idx):
-        """
-        Compute the propagator at ``t``, ``idx`` point to a pair of
-        (time, propagator) close to the desired time.
-        """
-        t_last = self.solver._integrator.get_state(copy=False)[0]
-        if self.times[idx-1] <= t_last <= t:
-            U = self.solver.step(t)
-        elif idx > 0:
-            self.solver.start(self.props[idx-1], self.times[idx-1])
-            U = self.solver.step(t)
-        else:
-            # Evolving backward in time is not supported by all integrator.
-            self.solver.start(qeye(self.props[0].dims[0]), t)
-            Uinv = self.solver.step(self.times[idx])
-            U = self._inv(Uinv)
-        return U
-
-    def _inv(self, U):
-        return U.dag() if self.unitary else U.inv()
-
-    def _insert(self, t, U, idx):
-        """
-        Insert a new pair of (time, propagator) to the memorized states.
-        """
-        while len(self.times) >= self.memoize:
-            rm_idx = self.memoize // 2
-            if self.times[rm_idx] < t:
-                idx -= 1
-            del self.times[rm_idx]
-            del self.props[rm_idx]
-        self.times.insert(idx, t)
-        self.props.insert(idx, U)
+__all__ = ['Propagator', 'propagator', 'propagator_steadystate']
+
+import numbers
+import numpy as np
+
+from .. import Qobj, qeye, unstack_columns, QobjEvo
+from ..core import data as _data
+from .mesolve import mesolve, MESolver
+from .sesolve import sesolve, SESolver
+from .heom.bofin_solvers import HEOMSolver
+from .solver_base import Solver
+from .multitraj import MultiTrajSolver
+
+
+def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
+    r"""
+    Calculate the propagator U(t) for the density matrix or wave function such
+    that :math:`\psi(t) = U(t)\psi(0)` or
+    :math:`\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)`
+    where :math:`\rho_{\mathrm vec}` is the vector representation of the
+    density matrix.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        Possibly time-dependent system Liouvillian or Hamiltonian as a Qobj or
+        QobjEvo. ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    t : float or array-like
+        Time or list of times for which to evaluate the propagator.
+
+    c_ops : list, optional
+        List of Qobj or QobjEvo collapse operators.
+
+    args : dictionary, optional
+        Parameters to callback functions for time-dependent Hamiltonians and
+        collapse operators.
+
+    options : dict, optional
+        Options for the solver.
+
+    **kwargs :
+        Extra parameters to use when creating the :class:`QobjEvo` from a list
+        format ``H``.
+
+    Returns
+    -------
+    U : qobj, list
+        Instance representing the propagator(s) :math:`U(t)`. Return a single
+        Qobj when ``t`` is a number or a list when ``t`` is a list.
+
+    """
+    if isinstance(t, numbers.Real):
+        tlist = [0, t]
+        list_output = False
+    else:
+        tlist = t
+        list_output = True
+
+    if not isinstance(H, (Qobj, QobjEvo)):
+        H = QobjEvo(H, args=args, **kwargs)
+
+    if H.issuper or c_ops:
+        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
+                      args=args, options=options).states
+    else:
+        out = sesolve(H, qeye(H.dims[0]), tlist,
+                      args=args, options=options).states
+
+    if list_output:
+        return out
+    else:
+        return out[-1]
+
+
+def propagator_steadystate(U):
+    r"""Find the steady state for successive applications of the propagator
+    :math:`U`.
+
+    Parameters
+    ----------
+    U : qobj
+        Operator representing the propagator.
+
+    Returns
+    -------
+    a : qobj
+        Instance representing the steady-state density matrix.
+    """
+    evals, estates = U.eigenstates()
+    shifted_vals = np.abs(evals - 1.0)
+    ev_idx = np.argmin(shifted_vals)
+    rho_data = unstack_columns(estates[ev_idx].data)
+    rho_data = _data.mul(rho_data, 0.5 / _data.trace(rho_data))
+    return Qobj(_data.add(rho_data, _data.adjoint(rho_data)),
+                dims=U.dims[0],
+                type='oper',
+                isherm=True,
+                copy=False)
+
+
+class Propagator:
+    """
+    A generator of propagator for a system.
+
+    Usage:
+        U = Propagator(H, c_ops)
+        psi_t = U(t) @ psi_0
+
+    Save some previously computed propagator are stored to speed up subsequent
+    computation. Changing ``args`` will erase these stored probagator.
+
+    Parameters
+    ----------
+    system : :class:`Qobj`, :class:`QobjEvo`, :class:`Solver`
+        Possibly time-dependent system driving the evolution, either already
+        packaged in a solver, such as :class:`SESolver` or :class:`BRSolver`,
+        or the Liouvillian or Hamiltonian as a :class:`Qobj`, :class:`QobjEvo`.
+        ``list`` of [:class:`Qobj`, :class:`Coefficient`] or callable that can
+        be made into :class:`QobjEvo` are also accepted.
+
+        Solvers that run non-deterministacilly, such as :class:`MCSolver`, are
+        not supported.
+
+    c_ops : list, optional
+        List of Qobj or QobjEvo collapse operators.
+
+    args : dictionary
+        Parameters to callback functions for time-dependent Hamiltonians and
+        collapse operators.
+
+    options : dict
+        Options for the solver.
+
+    memoize : int [10]
+        Max number of propagator to save.
+
+    tol : float [1e-14]
+        Absolute tolerance for the time. If a previous propagator was computed
+        at a time within tolerance, that propagator will be returned.
+
+    .. note::
+        The :class:`Propagator` is not a :class:`QobjEvo` so it cannot be used
+        for operations with :class:`Qobj` or :class:`QobjEvo`. It can be made
+        into a :class:`QobjEvo` with ::
+            U = QobjEvo(Propagator(H))
+    """
+    def __init__(self, system, *, c_ops=(), args=None, options=None,
+                 memoize=10, tol=1e-14):
+        if isinstance(system, MultiTrajSolver):
+            raise TypeError("Non-deterministic solvers cannot be used "
+                            "as a propagator system")
+        elif isinstance(system, HEOMSolver):
+            raise NotImplementedError(
+                "HEOM is not supported by Propagator. "
+                "Please, tell us on GitHub issues if you need it!"
+            )
+        elif isinstance(system, Solver):
+            self.solver = system
+        else:
+            Hevo = QobjEvo(system, args=args)
+            c_ops = [QobjEvo(op, args=args) for op in c_ops]
+            if Hevo.issuper or c_ops:
+                self.solver = MESolver(Hevo, c_ops=c_ops, options=options)
+            else:
+                self.solver = SESolver(Hevo, options=options)
+
+        self.times = [0]
+        self.invs = [None]
+        self.props = [qeye(self.solver.sys_dims)]
+        self.solver.start(self.props[0], self.times[0])
+        self.cte = self.solver.rhs.isconstant
+        H_0 = self.solver.rhs(0)
+        self.unitary = not H_0.issuper and H_0.isherm
+        self.args = args
+        self.memoize = max(3, int(memoize))
+        self.tol = tol
+
+    def _lookup_or_compute(self, t):
+        """
+        Get U(t) from cache or compute it.
+        """
+        idx = np.searchsorted(self.times, t)
+        if idx < len(self.times) and abs(t-self.times[idx]) <= self.tol:
+            U = self.props[idx]
+        elif idx > 0 and abs(t-self.times[idx-1]) <= self.tol:
+            U = self.props[idx-1]
+        else:
+            U = self._compute(t, idx)
+            self._insert(t, U, idx)
+        return U
+
+    def __call__(self, t, t_start=0, **args):
+        """
+        Get the propagator from ``t_start`` to ``t``.
+
+        Parameters
+        ----------
+        t : float
+            Time at which to compute the propagator.
+        t_start: float [0]
+            Time at which the propagator start such that:
+                ``psi[t] = U.prop(t, t_start) @ psi[t_start]``
+        args : dict
+            Argument to pass to a time dependent Hamiltonian.
+            Updating ``args`` take effect since ``t=0`` and the new ``args``
+            will be used in future call.
+        """
+        # We could improve it when the system is constant using U(2t) = U(t)**2
+        if not self.cte and args and args != self.args:
+            self.args = args
+            self.solver._argument(args)
+            self.times = [0]
+            self.props = [qeye(self.props[0].dims[0])]
+            self.solver.start(self.props[0], self.times[0])
+
+        if t_start:
+            if t == t_start:
+                U = self._lookup_or_compute(0)
+            if self.cte:
+                U = self._lookup_or_compute(t - t_start)
+            else:
+                Uinv = self._inv(self._lookup_or_compute(t_start))
+                U = self._lookup_or_compute(t) @ Uinv
+        else:
+            U = self._lookup_or_compute(t)
+        return U
+
+    def inv(self, t, **args):
+        """
+        Get the inverse of the propagator at ``t``, such that
+            ``psi_0 = U.inv(t) @ psi_t``
+
+        Parameters
+        ----------
+        t : float
+            Time at which to compute the propagator.
+        args : dict
+            Argument to pass to a time dependent Hamiltonian.
+            Updating ``args`` take effect since ``t=0`` and the new ``args``
+            will be used in future call.
+        """
+        return self._inv(self(t, **args))
+
+    def _compute(self, t, idx):
+        """
+        Compute the propagator at ``t``, ``idx`` point to a pair of
+        (time, propagator) close to the desired time.
+        """
+        t_last = self.solver._integrator.get_state(copy=False)[0]
+        if self.times[idx-1] <= t_last <= t:
+            U = self.solver.step(t)
+        elif idx > 0:
+            self.solver.start(self.props[idx-1], self.times[idx-1])
+            U = self.solver.step(t)
+        else:
+            # Evolving backward in time is not supported by all integrator.
+            self.solver.start(qeye(self.props[0].dims[0]), t)
+            Uinv = self.solver.step(self.times[idx])
+            U = self._inv(Uinv)
+        return U
+
+    def _inv(self, U):
+        return U.dag() if self.unitary else U.inv()
+
+    def _insert(self, t, U, idx):
+        """
+        Insert a new pair of (time, propagator) to the memorized states.
+        """
+        while len(self.times) >= self.memoize:
+            rm_idx = self.memoize // 2
+            if self.times[rm_idx] < t:
+                idx -= 1
+            del self.times[rm_idx]
+            del self.props[rm_idx]
+        self.times.insert(idx, t)
+        self.props.insert(idx, U)
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index c6360d4e77..a87ad9206c 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1,972 +1,972 @@
-""" Class for solve function results"""
-import numpy as np
-from ..core import Qobj, QobjEvo, expect, qzero
-
-__all__ = ["Result", "MultiTrajResult", "McResult"]
-
-
-class _QobjExpectEop:
-    """
-    Pickable e_ops callable that calculates the expectation value for a given
-    operator.
-
-    Parameters
-    ----------
-    op : :obj:`~Qobj`
-        The expectation value operator.
-    """
-    def __init__(self, op):
-        self.op = op
-
-    def __call__(self, t, state):
-        return expect(self.op, state)
-
-
-class ExpectOp:
-    """
-    A result e_op (expectation operation).
-
-    Parameters
-    ----------
-    op : object
-        The original object used to define the e_op operation, e.g. a
-        :~obj:`Qobj` or a function ``f(t, state)``.
-
-    f : function
-        A callable ``f(t, state)`` that will return the value of the e_op
-        for the specified state and time.
-
-    append : function
-        A callable ``append(value)``, e.g. ``expect[k].append``, that will
-        store the result of the e_ops function ``f(t, state)``.
-
-    Attributes
-    ----------
-    op : object
-        The original object used to define the e_op operation.
-    """
-    def __init__(self, op, f, append):
-        self.op = op
-        self._f = f
-        self._append = append
-
-    def __call__(self, t, state):
-        """
-        Return the expectation value for the given time, ``t`` and
-        state, ``state``.
-        """
-        return self._f(t, state)
-
-    def _store(self, t, state):
-        """
-        Store the result of the e_op function. Should only be called by
-        :class:`~Result`.
-        """
-        self._append(self._f(t, state))
-
-
-class _BaseResult:
-    """
-    Common method for all ``Result``.
-    """
-    def __init__(self, options, *, solver=None, stats=None):
-        self.solver = solver
-        if stats is None:
-            stats = {}
-        self.stats = stats
-
-        self._state_processors = []
-        self._state_processors_require_copy = False
-
-        self.options = options
-
-    def _e_ops_to_dict(self, e_ops):
-        """ Convert the supplied e_ops to a dictionary of Eop instances. """
-        if e_ops is None:
-            e_ops = {}
-        elif isinstance(e_ops, (list, tuple)):
-            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
-        elif isinstance(e_ops, dict):
-            pass
-        else:
-            e_ops = {0: e_ops}
-        return e_ops
-
-    def add_processor(self, f, requires_copy=False):
-        """
-        Append a processor ``f`` to the list of state processors.
-
-        Parameters
-        ----------
-        f : function, ``f(t, state)``
-            A function to be called each time a state is added to this
-            result object. The state is the state passed to ``.add``, after
-            applying the pre-processors, if any.
-
-        requires_copy : bool, default False
-            Whether this processor requires a copy of the state rather than
-            a reference. A processor must never modify the supplied state, but
-            if a processor stores the state it should set ``require_copy`` to
-            true.
-        """
-        self._state_processors.append(f)
-        self._state_processors_require_copy |= requires_copy
-
-
-class Result(_BaseResult):
-    """
-    Base class for storing solver results.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``e_data`` and ``expect`` attributes of
-        this result object. ``e_data`` is a dictionary and ``expect`` is a
-        list, where each item contains the values of the corresponding
-        ``e_op``.
-
-    options : dict
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Attributes
-    ----------
-    times : list
-        A list of the times at which the expectation values and states were
-        recorded.
-
-    states : list of :obj:`~Qobj`
-        The state at each time ``t`` (if the recording of the state was
-        requested).
-
-    final_state : :obj:`~Qobj`:
-        The final state (if the recording of the final state was requested).
-
-    expect : list of arrays of expectation values
-        A list containing the values of each ``e_op``. The list is in
-        the same order in which the ``e_ops`` were supplied and empty if
-        no ``e_ops`` were given.
-
-        Each element is itself a list and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-        The same lists of values may be accessed via the ``.e_data`` dictionary
-        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
-
-    e_data : dict
-        A dictionary containing the values of each ``e_op``. If the ``e_ops``
-        were supplied as a dictionary, the keys are the same as in
-        that dictionary. Otherwise the keys are the index of the ``e_op``
-        in the ``.expect`` list.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    e_ops : dict
-        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
-        The keys of the dictionary are the same as for ``.e_data``.
-        Each value is object where ``.e_ops[k](t, state)`` calculates the
-        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
-        ``.e_ops[k].op`` is the original object supplied to create the
-        ``e_op``.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results.
-
-    options : dict
-        The options for this result class.
-    """
-    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
-        super().__init__(options, solver=solver, stats=stats)
-        raw_ops = self._e_ops_to_dict(e_ops)
-        self.e_data = {k: [] for k in raw_ops}
-        self.e_ops = {}
-        for k, op in raw_ops.items():
-            f = self._e_op_func(op)
-            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
-            self.add_processor(self.e_ops[k]._store)
-
-        self.times = []
-        self.states = []
-        self.final_state = None
-
-        self._post_init(**kw)
-
-    def _e_op_func(self, e_op):
-        """
-        Convert an e_op entry into a function, ``f(t, state)`` that returns
-        the appropriate value (usually an expectation value).
-
-        Sub-classes may override this function to calculate expectation values
-        in different ways.
-        """
-        if isinstance(e_op, Qobj):
-            return _QobjExpectEop(e_op)
-        elif isinstance(e_op, QobjEvo):
-            return e_op.expect
-        elif callable(e_op):
-            return e_op
-        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
-
-    def _post_init(self):
-        """
-        Perform post __init__ initialisation. In particular, add state
-        processors or pre-processors.
-
-        Sub-class may override this. If the sub-class wishes to register the
-        default processors for storing states, it should call this parent
-        ``.post_init()`` method.
-
-        Sub-class ``.post_init()`` implementation may take additional keyword
-        arguments if required.
-        """
-        store_states = self.options['store_states']
-        store_final_state = self.options['store_final_state']
-
-        if store_states is None:
-            store_states = len(self.e_ops) == 0
-        if store_states:
-            self.add_processor(self._store_state, requires_copy=True)
-
-        if store_states or store_final_state:
-            self.add_processor(self._store_final_state, requires_copy=True)
-
-    def _store_state(self, t, state):
-        """ Processor that stores a state in ``.states``. """
-        self.states.append(state)
-
-    def _store_final_state(self, t, state):
-        """ Processor that writes the state to ``.final_state``. """
-        self.final_state = state
-
-    def _pre_copy(self, state):
-        """ Return a copy of the state. Sub-classes may override this to
-            copy a state in different manner or to skip making a copy
-            altogether if a copy is not necessary.
-        """
-        return state.copy()
-
-    def add(self, t, state):
-        """
-        Add a state to the results for the time ``t`` of the evolution.
-
-        Adding a state calculates the expectation value of the state for
-        each of the supplied ``e_ops`` and stores the result in ``.expect``.
-
-        The state is recorded in ``.states`` and ``.final_state`` if specified
-        by the supplied result options.
-
-        Parameters
-        ----------
-        t : float
-            The time of the added state.
-
-        state : typically a :obj:`~Qobj`
-            The state a time ``t``. Usually this is a :obj:`~Qobj` with
-            suitable dimensions, but it sub-classes of result might support
-            other forms of the state.
-
-        .. note::
-
-           The expectation values, i.e. ``e_ops``, and states are recorded by
-           the state processors (see ``.add_processor``).
-
-           Additional processors may be added by sub-classes.
-        """
-        self.times.append(t)
-
-        if self._state_processors_require_copy:
-            state = self._pre_copy(state)
-
-        for op in self._state_processors:
-            op(t, state)
-
-    def __repr__(self):
-        lines = [
-            f"<{self.__class__.__name__}",
-            f"  Solver: {self.solver}",
-        ]
-        if self.stats:
-            lines.append("  Solver stats:")
-            lines.extend(
-                f"    {k}: {v!r}"
-                for k, v in self.stats.items()
-            )
-        if self.times:
-            lines.append(
-                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
-                f" ({len(self.times)} steps)"
-            )
-        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
-        if self.states:
-            lines.append("  States saved.")
-        elif self.final_state is not None:
-            lines.append("  Final state saved.")
-        else:
-            lines.append("  State not saved.")
-        lines.append(">")
-        return "\n".join(lines)
-
-    @property
-    def expect(self):
-        return [np.array(e_op) for e_op in self.e_data.values()]
-
-
-class MultiTrajResult(_BaseResult):
-    """
-    Base class for storing results for solver using multiple trajectories.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``.expect`` attribute of this result
-        object. ``.expect`` is a list, where each item contains the values
-        of the corresponding ``e_op``.
-
-        Function ``e_ops`` must return a number so the average can be computed.
-
-    options : dict
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Properties
-    ----------
-    times : list
-        A list of the times at which the expectation values and states were
-        recorded.
-
-    average_states : list of :obj:`~Qobj`
-        The state at each time ``t`` (if the recording of the state was
-        requested) averaged over all trajectories as a density matrix.
-
-    runs_states : list of list of :obj:`~Qobj`
-        The state for each trajectory and each time ``t`` (if the recording of
-        the states and trajectories was requested)
-
-    final_state : :obj:`~Qobj:
-        The final state (if the recording of the final state was requested)
-        averaged over all trajectories as a density matrix.
-
-    runs_final_state : list of :obj:`~Qobj`
-        The final state for each trajectory (if the recording of the final
-        state and trajectories was requested).
-
-    average_expect : list of array of expectation values
-        A list containing the values of each ``e_op`` averaged over each
-        trajectories. The list is in the same order in which the ``e_ops`` were
-        supplied and empty if no ``e_ops`` were given.
-
-        Each element is itself an array and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-    std_expect : list of array of expectation values
-        A list containing the standard derivation of each ``e_op`` over each
-        trajectories. The list is in the same order in which the ``e_ops`` were
-        supplied and empty if no ``e_ops`` were given.
-
-        Each element is itself an array and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-    runs_expect : list of array of expectation values
-        A list containing the values of each ``e_op`` for each trajectories.
-        The list is in the same order in which the ``e_ops`` were
-        supplied and empty if no ``e_ops`` were given. Only available if the
-        storing of trajectories was requested.
-
-        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
-
-        Each element is itself an array and contains the values of the
-        corresponding ``e_op``, with one value for each time in ``.times``.
-
-    average_e_data : dict
-        A dictionary containing the values of each ``e_op`` averaged over each
-        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
-        are the same as in that dictionary. Otherwise the keys are the index of
-        the ``e_op`` in the ``.expect`` list.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    average_e_data : dict
-        A dictionary containing the standard derivation of each ``e_op`` over
-        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
-        keys are the same as in that dictionary. Otherwise the keys are the
-        index of the ``e_op`` in the ``.expect`` list.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    runs_e_data : dict
-        A dictionary containing the values of each ``e_op`` for each
-        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
-        are the same as in that dictionary. Otherwise the keys are the index of
-        the ``e_op`` in the ``.expect`` list. Only available if the storing
-        of trajectories was requested.
-
-        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
-
-        The lists of expectation values returned are the *same* lists as
-        those returned by ``.expect``.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict or None
-        The stats generated by the solver while producing these results.
-
-    options : :obj:`~SolverResultsOptions`
-        The options for this result class.
-    """
-    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
-        super().__init__(options, solver=solver, stats=stats)
-        self._raw_ops = self._e_ops_to_dict(e_ops)
-
-        self.times = []
-        self.trajectories = []
-        self.num_trajectories = 0
-        self.seeds = []
-
-        self._sum_states = None
-        self._sum_final_states = None
-        self._sum_expect = None
-        self._sum2_expect = None
-        self._target_tols = None
-
-        self.average_e_data = {}
-        self.e_data = {}
-        self.std_e_data = {}
-        self.runs_e_data = {}
-
-        self._post_init(**kw)
-
-    @staticmethod
-    def _to_dm(state):
-        if state.type == 'ket':
-            state = state.proj()
-        return state
-
-    def _add_first_traj(self, trajectory):
-        """
-        Read the first trajectory, intitializing needed data.
-        """
-        self.times = trajectory.times
-
-        if trajectory.states:
-            state = trajectory.states[0]
-            self._sum_states = [qzero(state.dims[0])
-                                for state in trajectory.states]
-        if trajectory.final_state:
-            state = trajectory.final_state
-            self._sum_final_states = qzero(state.dims[0])
-
-        self._sum_expect = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
-        self._sum2_expect = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
-
-        self.e_ops = trajectory.e_ops
-
-        self.average_e_data = {
-            k: list(avg_expect)
-            for k, avg_expect
-            in zip(self._raw_ops, self._sum_expect)
-        }
-        self.e_data = self.average_e_data
-        if self.options['keep_runs_results']:
-            self.runs_e_data = {k: [] for k in self._raw_ops}
-            self.e_data = self.runs_e_data
-
-    def _store_trajectory(self, trajectory):
-        self.trajectories.append(trajectory)
-
-    def _reduce_states(self, trajectory):
-        self._sum_states = [
-            accu + self._to_dm(state)
-            for accu, state
-            in zip(self._sum_states, trajectory.states)
-        ]
-
-    def _reduce_final_state(self, trajectory):
-        self._sum_final_states += self._to_dm(trajectory.final_state)
-
-    def _reduce_expect(self, trajectory):
-        """
-        Compute the average of the expectation values and store it in it's
-        multiple formats.
-        """
-        for i, k in enumerate(self._raw_ops):
-            expect_traj = trajectory.expect[i]
-
-            self._sum_expect[i] += expect_traj
-            self._sum2_expect[i] += expect_traj**2
-
-            avg = self._sum_expect[i] / self.num_trajectories
-            avg2 = self._sum2_expect[i] / self.num_trajectories
-
-            self.average_e_data[k] = list(avg)
-
-            # mean(expect**2) - mean(expect)**2 can something be very small
-            # negative (-1e-15) which raise an error for float sqrt.
-            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
-
-            if self.runs_e_data:
-                self.runs_e_data[k].append(trajectory.e_data[k])
-
-    def _increment_traj(self, trajectory):
-        if self.num_trajectories == 0:
-            self._add_first_traj(trajectory)
-        self.num_trajectories += 1
-
-    def _no_end(self):
-        """
-        Remaining number of trajectories needed to finish cannot be determined
-        by this object.
-        """
-        return np.inf
-
-    def _fixed_end(self):
-        """
-        Finish at a known number of trajectories.
-        """
-        ntraj_left = self._target_ntraj - self.num_trajectories
-        if ntraj_left == 0:
-            self.stats['end_condition'] = 'ntraj reached'
-        return ntraj_left
-
-    def _target_tolerance_end(self):
-        """
-        Compute the error on the expectation values using jackknife resampling.
-        Return the approximate number of trajectories needed to have this
-        error within the tolerance fot all e_ops and times.
-        """
-        if self.num_trajectories <= 1:
-            return np.inf
-        avg = np.array(self._sum_expect) / self.num_trajectories
-        avg2 = np.array(self._sum2_expect) / self.num_trajectories
-        target = np.array([
-            atol + rtol * mean
-            for mean, (atol, rtol)
-            in zip(avg, self._target_tols)
-        ])
-        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
-
-        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
-        if (self._estimated_ntraj - self.num_trajectories) <= 0:
-            self.stats['end_condition'] = 'target tolerance reached'
-        return self._estimated_ntraj - self.num_trajectories
-
-    def _post_init(self):
-        self.num_trajectories = 0
-        self._target_ntraj = None
-
-        store_states = self.options['store_states']
-        store_final_state = self.options['store_final_state']
-        store_traj = self.options['keep_runs_results']
-
-        self.add_processor(self._increment_traj)
-        if store_traj:
-            self.add_processor(self._store_trajectory)
-        if store_states is None:
-            store_states = len(self._raw_ops) == 0
-        if store_states:
-            self.add_processor(self._reduce_states)
-        if store_states or store_final_state:
-            self.add_processor(self._reduce_final_state)
-        if self._raw_ops:
-            self.add_processor(self._reduce_expect)
-
-        self._early_finish_check = self._no_end
-        self.stats['end_condition'] = 'unknown'
-
-    def add(self, trajectory_info):
-        """
-        Add a trajectory to the evolution.
-
-        Trajectories can be saved or average canbe extracted depending on the
-        options ``keep_runs_results``.
-
-        Parameters
-        ----------
-        trajectory_info : tuple of seed and trajectory
-            - seed: int, SeedSequence
-              Seed used to generate the trajectory.
-            - trajectory : :class:`Result`
-              Run result for one evolution over the times.
-
-        Return
-        ------
-        remaing_traj : number
-            Return the number of trajectories still needed to reach the target
-            tolerance. If no tolerance is provided, return infinity.
-        """
-        seed, trajectory = trajectory_info
-        self.seeds.append(seed)
-
-        for op in self._state_processors:
-            op(trajectory)
-
-        return self._early_finish_check()
-
-    def add_end_condition(self, ntraj, target_tol=None):
-        """
-        Set the condition to stop the computing trajectories when the certain
-        condition are fullfilled.
-        Supported end condition for multi trajectories computation are:
-        - Reaching a number of trajectories.
-        - Error bar on the expectation values reach smaller than a given
-          tolerance.
-
-        Parameters
-        ----------
-        ntraj : int
-            Number of trajectories expected.
-
-        target_tol : float, array_like, [optional]
-            Target tolerance of the evolution. The evolution will compute
-            trajectories until the error on the expectation values is lower
-            than this tolerance. The error is computed using jackknife
-            resampling. ``target_tol`` can be an absolute tolerance, a pair of
-            absolute and relative tolerance, in that order. Lastly, it can be a
-            list of pairs of (atol, rtol) for each e_ops.
-
-            Error estimation is done with jackknife resampling.
-        """
-        self._target_ntraj = ntraj
-        self.stats['end_condition'] = 'timeout'
-
-        if target_tol is None:
-            self._early_finish_check = self._fixed_end
-            return
-
-        num_e_ops = len(self._raw_ops)
-
-        if not num_e_ops:
-            raise ValueError("Cannot target a tolerance without e_ops")
-
-        self._estimated_ntraj = ntraj
-
-        targets = np.array(target_tol)
-        if targets.ndim == 0:
-            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
-        elif targets.shape == (2,):
-            self._target_tols = np.ones((num_e_ops, 2)) * targets
-        elif targets.shape == (num_e_ops, 2):
-            self._target_tols = targets
-        else:
-            raise ValueError("target_tol must be a number, a pair of (atol, "
-                             "rtol) or a list of (atol, rtol) for each e_ops")
-
-        self._early_finish_check = self._target_tolerance_end
-
-    @property
-    def runs_states(self):
-        """
-        States of every runs as ``states[run][t]``.
-        """
-        if self.trajectories and self.trajectories[0].states:
-            return [traj.states for traj in self.trajectories]
-        else:
-            return None
-
-    @property
-    def average_states(self):
-        """
-        States averages as density matrices.
-        """
-        if self._sum_states is None:
-            return None
-        return [final / self.num_trajectories for final in self._sum_states]
-
-    @property
-    def states(self):
-        """
-        Runs final states if available, average otherwise.
-        """
-        return self.runs_states or self.average_states
-
-    @property
-    def runs_final_states(self):
-        """
-        Last states of each trajectories.
-        """
-        if self.trajectories and self.trajectories[0].final_state:
-            return [traj.final_state for traj in self.trajectories]
-        else:
-            return None
-
-    @property
-    def average_final_state(self):
-        """
-        Last states of each trajectories averaged into a density matrix.
-        """
-        if self._sum_final_states is None:
-            return None
-        return self._sum_final_states / self.num_trajectories
-
-    @property
-    def final_state(self):
-        """
-        Runs final states if available, average otherwise.
-        """
-        return self.runs_final_states or self.average_final_state
-
-    @property
-    def average_expect(self):
-        return [np.array(val) for val in self.average_e_data.values()]
-
-    @property
-    def std_expect(self):
-        return [np.array(val) for val in self.std_e_data.values()]
-
-    @property
-    def runs_expect(self):
-        return [np.array(val) for val in self.runs_e_data.values()]
-
-    @property
-    def expect(self):
-        return [np.array(val) for val in self.e_data.values()]
-
-    def steady_state(self, N=0):
-        """
-        Average the states of the last ``N`` times of every runs as a density
-        matrix. Should converge to the steady state in the right circumstances.
-
-        Parameters
-        ----------
-        N : int [optional]
-            Number of states from the end of ``tlist`` to average. Per default
-            all states will be averaged.
-        """
-        N = int(N) or len(self.times)
-        N = len(self.times) if N > len(self.times) else N
-        states = self.average_states
-        if states is not None:
-            return sum(states[-N:]) / N
-        else:
-            return None
-
-    def __repr__(self):
-        lines = [
-            f"<{self.__class__.__name__}",
-            f"  Solver: {self.solver}",
-        ]
-        if self.stats:
-            lines.append("  Solver stats:")
-            lines.extend(
-                f"    {k}: {v!r}"
-                for k, v in self.stats.items()
-            )
-        if self.times:
-            lines.append(
-                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
-                f" ({len(self.times)} steps)"
-            )
-        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
-        if self.states:
-            lines.append("  States saved.")
-        elif self.final_state is not None:
-            lines.append("  Final state saved.")
-        else:
-            lines.append("  State not saved.")
-        lines.append(f"  Number of trajectories: {self.num_trajectories}")
-        if self.trajectories:
-            lines.append("  Trajectories saved.")
-        else:
-            lines.append("  Trajectories not saved.")
-        lines.append(">")
-        return "\n".join(lines)
-
-    def __add__(self, other):
-        if not isinstance(other, MultiTrajResult):
-            return NotImplemented
-        if self._raw_ops != other._raw_ops:
-            raise ValueError("Shared `e_ops` is required to merge results")
-        if self.times != other.times:
-            raise ValueError("Shared `times` are is required to merge results")
-        new = self.__class__(self._raw_ops, self.options,
-                             solver=self.solver, stats=self.stats)
-        if self.trajectories and other.trajectories:
-            new.trajectories = self.trajectories + other.trajectories
-        new.num_trajectories = self.num_trajectories + other.num_trajectories
-        new.times = self.times
-        new.seeds = self.seeds + other.seeds
-
-        if self._sum_states is not None and other._sum_states is not None:
-            new._sum_states = self._sum_states + other._sum_states
-
-        if (
-            self._sum_final_states is not None
-            and other._sum_final_states is not None
-        ):
-            new._sum_final_states = (
-                self._sum_final_states + other._sum_final_states
-            )
-        new._target_tols = None
-
-        new._sum_expect = []
-        new._sum2_expect = []
-        new.average_e_data = {}
-        new.std_e_data = {}
-
-        for i, k in enumerate(self._raw_ops):
-            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
-            new._sum2_expect.append(self._sum2_expect[i]
-                                    + other._sum2_expect[i])
-
-            avg = new._sum_expect[i] / new.num_trajectories
-            avg2 = new._sum2_expect[i] / new.num_trajectories
-
-            new.average_e_data[k] = list(avg)
-            new.e_data = new.average_e_data
-
-            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
-
-            if new.trajectories:
-                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
-                new.e_data = new.runs_e_data
-
-        new.stats["run time"] += other.stats["run time"]
-        new.stats['end_condition'] = "Merged results"
-
-        return new
-
-
-class McResult(MultiTrajResult):
-    """
-    Base class for storing solver results.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``.expect`` attribute of this result
-        object. ``.expect`` is a list, where each item contains the values
-        of the corresponding ``e_op``.
-
-    options : :obj:`~SolverResultsOptions`
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-        Must include a value for "num_collapse".
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Properties
-    ----------
-    collapse : list
-        For each runs, a list of every collapse as a tuple of the time it
-        happened and the corresponding ``c_ops`` index.
-    """
-    # Collapse are only produced by mcsolve.
-
-    def _add_collapse(self, trajectory):
-        self.collapse.append(trajectory.collapse)
-
-    def _post_init(self):
-        super()._post_init()
-        self.num_c_ops = self.stats["num_collapse"]
-        self.collapse = []
-        self.add_processor(self._add_collapse)
-
-    @property
-    def col_times(self):
-        """
-        List of the times of the collapses for each runs.
-        """
-        out = []
-        for col_ in self.collapse:
-            col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[0])
-            out.append(col)
-        return out
-
-    @property
-    def col_which(self):
-        """
-        List of the indexes of the collapses for each runs.
-        """
-        out = []
-        for col_ in self.collapse:
-            col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[1])
-            out.append(col)
-        return out
-
-    @property
-    def photocurrent(self):
-        """
-        Average photocurrent or measurement of the evolution.
-        """
-        cols = [[] for _ in range(self.num_c_ops)]
-        tlist = self.times
-        for collapses in self.collapse:
-            for t, which in collapses:
-                cols[which].append(t)
-        mesurement = [
-            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
-            for i in range(self.num_c_ops)
-        ]
-        return mesurement
-
-    @property
-    def runs_photocurrent(self):
-        """
-        Photocurrent or measurement of each runs.
-        """
-        tlist = self.times
-        measurements = []
-        for collapses in self.collapse:
-            cols = [[] for _ in range(self.num_c_ops)]
-            for t, which in collapses:
-                cols[which].append(t)
-            measurements.append([
-                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
-                for i in range(self.num_c_ops)
-            ])
-        return measurements
+""" Class for solve function results"""
+import numpy as np
+from ..core import Qobj, QobjEvo, expect, qzero
+
+__all__ = ["Result", "MultiTrajResult", "McResult"]
+
+
+class _QobjExpectEop:
+    """
+    Pickable e_ops callable that calculates the expectation value for a given
+    operator.
+
+    Parameters
+    ----------
+    op : :obj:`~Qobj`
+        The expectation value operator.
+    """
+    def __init__(self, op):
+        self.op = op
+
+    def __call__(self, t, state):
+        return expect(self.op, state)
+
+
+class ExpectOp:
+    """
+    A result e_op (expectation operation).
+
+    Parameters
+    ----------
+    op : object
+        The original object used to define the e_op operation, e.g. a
+        :~obj:`Qobj` or a function ``f(t, state)``.
+
+    f : function
+        A callable ``f(t, state)`` that will return the value of the e_op
+        for the specified state and time.
+
+    append : function
+        A callable ``append(value)``, e.g. ``expect[k].append``, that will
+        store the result of the e_ops function ``f(t, state)``.
+
+    Attributes
+    ----------
+    op : object
+        The original object used to define the e_op operation.
+    """
+    def __init__(self, op, f, append):
+        self.op = op
+        self._f = f
+        self._append = append
+
+    def __call__(self, t, state):
+        """
+        Return the expectation value for the given time, ``t`` and
+        state, ``state``.
+        """
+        return self._f(t, state)
+
+    def _store(self, t, state):
+        """
+        Store the result of the e_op function. Should only be called by
+        :class:`~Result`.
+        """
+        self._append(self._f(t, state))
+
+
+class _BaseResult:
+    """
+    Common method for all ``Result``.
+    """
+    def __init__(self, options, *, solver=None, stats=None):
+        self.solver = solver
+        if stats is None:
+            stats = {}
+        self.stats = stats
+
+        self._state_processors = []
+        self._state_processors_require_copy = False
+
+        self.options = options
+
+    def _e_ops_to_dict(self, e_ops):
+        """ Convert the supplied e_ops to a dictionary of Eop instances. """
+        if e_ops is None:
+            e_ops = {}
+        elif isinstance(e_ops, (list, tuple)):
+            e_ops = {k: e_op for k, e_op in enumerate(e_ops)}
+        elif isinstance(e_ops, dict):
+            pass
+        else:
+            e_ops = {0: e_ops}
+        return e_ops
+
+    def add_processor(self, f, requires_copy=False):
+        """
+        Append a processor ``f`` to the list of state processors.
+
+        Parameters
+        ----------
+        f : function, ``f(t, state)``
+            A function to be called each time a state is added to this
+            result object. The state is the state passed to ``.add``, after
+            applying the pre-processors, if any.
+
+        requires_copy : bool, default False
+            Whether this processor requires a copy of the state rather than
+            a reference. A processor must never modify the supplied state, but
+            if a processor stores the state it should set ``require_copy`` to
+            true.
+        """
+        self._state_processors.append(f)
+        self._state_processors_require_copy |= requires_copy
+
+
+class Result(_BaseResult):
+    """
+    Base class for storing solver results.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``e_data`` and ``expect`` attributes of
+        this result object. ``e_data`` is a dictionary and ``expect`` is a
+        list, where each item contains the values of the corresponding
+        ``e_op``.
+
+    options : dict
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Attributes
+    ----------
+    times : list
+        A list of the times at which the expectation values and states were
+        recorded.
+
+    states : list of :obj:`~Qobj`
+        The state at each time ``t`` (if the recording of the state was
+        requested).
+
+    final_state : :obj:`~Qobj`:
+        The final state (if the recording of the final state was requested).
+
+    expect : list of arrays of expectation values
+        A list containing the values of each ``e_op``. The list is in
+        the same order in which the ``e_ops`` were supplied and empty if
+        no ``e_ops`` were given.
+
+        Each element is itself a list and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+        The same lists of values may be accessed via the ``.e_data`` dictionary
+        and the original ``e_ops`` are available via the ``.e_ops`` attribute.
+
+    e_data : dict
+        A dictionary containing the values of each ``e_op``. If the ``e_ops``
+        were supplied as a dictionary, the keys are the same as in
+        that dictionary. Otherwise the keys are the index of the ``e_op``
+        in the ``.expect`` list.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    e_ops : dict
+        A dictionary containing the supplied e_ops as ``ExpectOp`` instances.
+        The keys of the dictionary are the same as for ``.e_data``.
+        Each value is object where ``.e_ops[k](t, state)`` calculates the
+        value of ``e_op`` ``k`` at time ``t`` and the given ``state``, and
+        ``.e_ops[k].op`` is the original object supplied to create the
+        ``e_op``.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results.
+
+    options : dict
+        The options for this result class.
+    """
+    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
+        super().__init__(options, solver=solver, stats=stats)
+        raw_ops = self._e_ops_to_dict(e_ops)
+        self.e_data = {k: [] for k in raw_ops}
+        self.e_ops = {}
+        for k, op in raw_ops.items():
+            f = self._e_op_func(op)
+            self.e_ops[k] = ExpectOp(op, f, self.e_data[k].append)
+            self.add_processor(self.e_ops[k]._store)
+
+        self.times = []
+        self.states = []
+        self.final_state = None
+
+        self._post_init(**kw)
+
+    def _e_op_func(self, e_op):
+        """
+        Convert an e_op entry into a function, ``f(t, state)`` that returns
+        the appropriate value (usually an expectation value).
+
+        Sub-classes may override this function to calculate expectation values
+        in different ways.
+        """
+        if isinstance(e_op, Qobj):
+            return _QobjExpectEop(e_op)
+        elif isinstance(e_op, QobjEvo):
+            return e_op.expect
+        elif callable(e_op):
+            return e_op
+        raise TypeError(f"{e_op!r} has unsupported type {type(e_op)!r}.")
+
+    def _post_init(self):
+        """
+        Perform post __init__ initialisation. In particular, add state
+        processors or pre-processors.
+
+        Sub-class may override this. If the sub-class wishes to register the
+        default processors for storing states, it should call this parent
+        ``.post_init()`` method.
+
+        Sub-class ``.post_init()`` implementation may take additional keyword
+        arguments if required.
+        """
+        store_states = self.options['store_states']
+        store_final_state = self.options['store_final_state']
+
+        if store_states is None:
+            store_states = len(self.e_ops) == 0
+        if store_states:
+            self.add_processor(self._store_state, requires_copy=True)
+
+        if store_states or store_final_state:
+            self.add_processor(self._store_final_state, requires_copy=True)
+
+    def _store_state(self, t, state):
+        """ Processor that stores a state in ``.states``. """
+        self.states.append(state)
+
+    def _store_final_state(self, t, state):
+        """ Processor that writes the state to ``.final_state``. """
+        self.final_state = state
+
+    def _pre_copy(self, state):
+        """ Return a copy of the state. Sub-classes may override this to
+            copy a state in different manner or to skip making a copy
+            altogether if a copy is not necessary.
+        """
+        return state.copy()
+
+    def add(self, t, state):
+        """
+        Add a state to the results for the time ``t`` of the evolution.
+
+        Adding a state calculates the expectation value of the state for
+        each of the supplied ``e_ops`` and stores the result in ``.expect``.
+
+        The state is recorded in ``.states`` and ``.final_state`` if specified
+        by the supplied result options.
+
+        Parameters
+        ----------
+        t : float
+            The time of the added state.
+
+        state : typically a :obj:`~Qobj`
+            The state a time ``t``. Usually this is a :obj:`~Qobj` with
+            suitable dimensions, but it sub-classes of result might support
+            other forms of the state.
+
+        .. note::
+
+           The expectation values, i.e. ``e_ops``, and states are recorded by
+           the state processors (see ``.add_processor``).
+
+           Additional processors may be added by sub-classes.
+        """
+        self.times.append(t)
+
+        if self._state_processors_require_copy:
+            state = self._pre_copy(state)
+
+        for op in self._state_processors:
+            op(t, state)
+
+    def __repr__(self):
+        lines = [
+            f"<{self.__class__.__name__}",
+            f"  Solver: {self.solver}",
+        ]
+        if self.stats:
+            lines.append("  Solver stats:")
+            lines.extend(
+                f"    {k}: {v!r}"
+                for k, v in self.stats.items()
+            )
+        if self.times:
+            lines.append(
+                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
+                f" ({len(self.times)} steps)"
+            )
+        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
+        if self.states:
+            lines.append("  States saved.")
+        elif self.final_state is not None:
+            lines.append("  Final state saved.")
+        else:
+            lines.append("  State not saved.")
+        lines.append(">")
+        return "\n".join(lines)
+
+    @property
+    def expect(self):
+        return [np.array(e_op) for e_op in self.e_data.values()]
+
+
+class MultiTrajResult(_BaseResult):
+    """
+    Base class for storing results for solver using multiple trajectories.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``.expect`` attribute of this result
+        object. ``.expect`` is a list, where each item contains the values
+        of the corresponding ``e_op``.
+
+        Function ``e_ops`` must return a number so the average can be computed.
+
+    options : dict
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Properties
+    ----------
+    times : list
+        A list of the times at which the expectation values and states were
+        recorded.
+
+    average_states : list of :obj:`~Qobj`
+        The state at each time ``t`` (if the recording of the state was
+        requested) averaged over all trajectories as a density matrix.
+
+    runs_states : list of list of :obj:`~Qobj`
+        The state for each trajectory and each time ``t`` (if the recording of
+        the states and trajectories was requested)
+
+    final_state : :obj:`~Qobj:
+        The final state (if the recording of the final state was requested)
+        averaged over all trajectories as a density matrix.
+
+    runs_final_state : list of :obj:`~Qobj`
+        The final state for each trajectory (if the recording of the final
+        state and trajectories was requested).
+
+    average_expect : list of array of expectation values
+        A list containing the values of each ``e_op`` averaged over each
+        trajectories. The list is in the same order in which the ``e_ops`` were
+        supplied and empty if no ``e_ops`` were given.
+
+        Each element is itself an array and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+    std_expect : list of array of expectation values
+        A list containing the standard derivation of each ``e_op`` over each
+        trajectories. The list is in the same order in which the ``e_ops`` were
+        supplied and empty if no ``e_ops`` were given.
+
+        Each element is itself an array and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+    runs_expect : list of array of expectation values
+        A list containing the values of each ``e_op`` for each trajectories.
+        The list is in the same order in which the ``e_ops`` were
+        supplied and empty if no ``e_ops`` were given. Only available if the
+        storing of trajectories was requested.
+
+        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
+
+        Each element is itself an array and contains the values of the
+        corresponding ``e_op``, with one value for each time in ``.times``.
+
+    average_e_data : dict
+        A dictionary containing the values of each ``e_op`` averaged over each
+        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
+        are the same as in that dictionary. Otherwise the keys are the index of
+        the ``e_op`` in the ``.expect`` list.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    average_e_data : dict
+        A dictionary containing the standard derivation of each ``e_op`` over
+        each trajectories. If the ``e_ops`` were supplied as a dictionary, the
+        keys are the same as in that dictionary. Otherwise the keys are the
+        index of the ``e_op`` in the ``.expect`` list.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    runs_e_data : dict
+        A dictionary containing the values of each ``e_op`` for each
+        trajectories. If the ``e_ops`` were supplied as a dictionary, the keys
+        are the same as in that dictionary. Otherwise the keys are the index of
+        the ``e_op`` in the ``.expect`` list. Only available if the storing
+        of trajectories was requested.
+
+        The order of the elements is ``runs_expect[e_ops][trajectory][time]``.
+
+        The lists of expectation values returned are the *same* lists as
+        those returned by ``.expect``.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict or None
+        The stats generated by the solver while producing these results.
+
+    options : :obj:`~SolverResultsOptions`
+        The options for this result class.
+    """
+    def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
+        super().__init__(options, solver=solver, stats=stats)
+        self._raw_ops = self._e_ops_to_dict(e_ops)
+
+        self.times = []
+        self.trajectories = []
+        self.num_trajectories = 0
+        self.seeds = []
+
+        self._sum_states = None
+        self._sum_final_states = None
+        self._sum_expect = None
+        self._sum2_expect = None
+        self._target_tols = None
+
+        self.average_e_data = {}
+        self.e_data = {}
+        self.std_e_data = {}
+        self.runs_e_data = {}
+
+        self._post_init(**kw)
+
+    @staticmethod
+    def _to_dm(state):
+        if state.type == 'ket':
+            state = state.proj()
+        return state
+
+    def _add_first_traj(self, trajectory):
+        """
+        Read the first trajectory, intitializing needed data.
+        """
+        self.times = trajectory.times
+
+        if trajectory.states:
+            state = trajectory.states[0]
+            self._sum_states = [qzero(state.dims[0])
+                                for state in trajectory.states]
+        if trajectory.final_state:
+            state = trajectory.final_state
+            self._sum_final_states = qzero(state.dims[0])
+
+        self._sum_expect = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum2_expect = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+
+        self.e_ops = trajectory.e_ops
+
+        self.average_e_data = {
+            k: list(avg_expect)
+            for k, avg_expect
+            in zip(self._raw_ops, self._sum_expect)
+        }
+        self.e_data = self.average_e_data
+        if self.options['keep_runs_results']:
+            self.runs_e_data = {k: [] for k in self._raw_ops}
+            self.e_data = self.runs_e_data
+
+    def _store_trajectory(self, trajectory):
+        self.trajectories.append(trajectory)
+
+    def _reduce_states(self, trajectory):
+        self._sum_states = [
+            accu + self._to_dm(state)
+            for accu, state
+            in zip(self._sum_states, trajectory.states)
+        ]
+
+    def _reduce_final_state(self, trajectory):
+        self._sum_final_states += self._to_dm(trajectory.final_state)
+
+    def _reduce_expect(self, trajectory):
+        """
+        Compute the average of the expectation values and store it in it's
+        multiple formats.
+        """
+        for i, k in enumerate(self._raw_ops):
+            expect_traj = trajectory.expect[i]
+
+            self._sum_expect[i] += expect_traj
+            self._sum2_expect[i] += expect_traj**2
+
+            avg = self._sum_expect[i] / self.num_trajectories
+            avg2 = self._sum2_expect[i] / self.num_trajectories
+
+            self.average_e_data[k] = list(avg)
+
+            # mean(expect**2) - mean(expect)**2 can something be very small
+            # negative (-1e-15) which raise an error for float sqrt.
+            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
+
+            if self.runs_e_data:
+                self.runs_e_data[k].append(trajectory.e_data[k])
+
+    def _increment_traj(self, trajectory):
+        if self.num_trajectories == 0:
+            self._add_first_traj(trajectory)
+        self.num_trajectories += 1
+
+    def _no_end(self):
+        """
+        Remaining number of trajectories needed to finish cannot be determined
+        by this object.
+        """
+        return np.inf
+
+    def _fixed_end(self):
+        """
+        Finish at a known number of trajectories.
+        """
+        ntraj_left = self._target_ntraj - self.num_trajectories
+        if ntraj_left == 0:
+            self.stats['end_condition'] = 'ntraj reached'
+        return ntraj_left
+
+    def _target_tolerance_end(self):
+        """
+        Compute the error on the expectation values using jackknife resampling.
+        Return the approximate number of trajectories needed to have this
+        error within the tolerance fot all e_ops and times.
+        """
+        if self.num_trajectories <= 1:
+            return np.inf
+        avg = np.array(self._sum_expect) / self.num_trajectories
+        avg2 = np.array(self._sum2_expect) / self.num_trajectories
+        target = np.array([
+            atol + rtol * mean
+            for mean, (atol, rtol)
+            in zip(avg, self._target_tols)
+        ])
+        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
+
+        self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
+        if (self._estimated_ntraj - self.num_trajectories) <= 0:
+            self.stats['end_condition'] = 'target tolerance reached'
+        return self._estimated_ntraj - self.num_trajectories
+
+    def _post_init(self):
+        self.num_trajectories = 0
+        self._target_ntraj = None
+
+        store_states = self.options['store_states']
+        store_final_state = self.options['store_final_state']
+        store_traj = self.options['keep_runs_results']
+
+        self.add_processor(self._increment_traj)
+        if store_traj:
+            self.add_processor(self._store_trajectory)
+        if store_states is None:
+            store_states = len(self._raw_ops) == 0
+        if store_states:
+            self.add_processor(self._reduce_states)
+        if store_states or store_final_state:
+            self.add_processor(self._reduce_final_state)
+        if self._raw_ops:
+            self.add_processor(self._reduce_expect)
+
+        self._early_finish_check = self._no_end
+        self.stats['end_condition'] = 'unknown'
+
+    def add(self, trajectory_info):
+        """
+        Add a trajectory to the evolution.
+
+        Trajectories can be saved or average canbe extracted depending on the
+        options ``keep_runs_results``.
+
+        Parameters
+        ----------
+        trajectory_info : tuple of seed and trajectory
+            - seed: int, SeedSequence
+              Seed used to generate the trajectory.
+            - trajectory : :class:`Result`
+              Run result for one evolution over the times.
+
+        Return
+        ------
+        remaing_traj : number
+            Return the number of trajectories still needed to reach the target
+            tolerance. If no tolerance is provided, return infinity.
+        """
+        seed, trajectory = trajectory_info
+        self.seeds.append(seed)
+
+        for op in self._state_processors:
+            op(trajectory)
+
+        return self._early_finish_check()
+
+    def add_end_condition(self, ntraj, target_tol=None):
+        """
+        Set the condition to stop the computing trajectories when the certain
+        condition are fullfilled.
+        Supported end condition for multi trajectories computation are:
+        - Reaching a number of trajectories.
+        - Error bar on the expectation values reach smaller than a given
+          tolerance.
+
+        Parameters
+        ----------
+        ntraj : int
+            Number of trajectories expected.
+
+        target_tol : float, array_like, [optional]
+            Target tolerance of the evolution. The evolution will compute
+            trajectories until the error on the expectation values is lower
+            than this tolerance. The error is computed using jackknife
+            resampling. ``target_tol`` can be an absolute tolerance, a pair of
+            absolute and relative tolerance, in that order. Lastly, it can be a
+            list of pairs of (atol, rtol) for each e_ops.
+
+            Error estimation is done with jackknife resampling.
+        """
+        self._target_ntraj = ntraj
+        self.stats['end_condition'] = 'timeout'
+
+        if target_tol is None:
+            self._early_finish_check = self._fixed_end
+            return
+
+        num_e_ops = len(self._raw_ops)
+
+        if not num_e_ops:
+            raise ValueError("Cannot target a tolerance without e_ops")
+
+        self._estimated_ntraj = ntraj
+
+        targets = np.array(target_tol)
+        if targets.ndim == 0:
+            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
+        elif targets.shape == (2,):
+            self._target_tols = np.ones((num_e_ops, 2)) * targets
+        elif targets.shape == (num_e_ops, 2):
+            self._target_tols = targets
+        else:
+            raise ValueError("target_tol must be a number, a pair of (atol, "
+                             "rtol) or a list of (atol, rtol) for each e_ops")
+
+        self._early_finish_check = self._target_tolerance_end
+
+    @property
+    def runs_states(self):
+        """
+        States of every runs as ``states[run][t]``.
+        """
+        if self.trajectories and self.trajectories[0].states:
+            return [traj.states for traj in self.trajectories]
+        else:
+            return None
+
+    @property
+    def average_states(self):
+        """
+        States averages as density matrices.
+        """
+        if self._sum_states is None:
+            return None
+        return [final / self.num_trajectories for final in self._sum_states]
+
+    @property
+    def states(self):
+        """
+        Runs final states if available, average otherwise.
+        """
+        return self.runs_states or self.average_states
+
+    @property
+    def runs_final_states(self):
+        """
+        Last states of each trajectories.
+        """
+        if self.trajectories and self.trajectories[0].final_state:
+            return [traj.final_state for traj in self.trajectories]
+        else:
+            return None
+
+    @property
+    def average_final_state(self):
+        """
+        Last states of each trajectories averaged into a density matrix.
+        """
+        if self._sum_final_states is None:
+            return None
+        return self._sum_final_states / self.num_trajectories
+
+    @property
+    def final_state(self):
+        """
+        Runs final states if available, average otherwise.
+        """
+        return self.runs_final_states or self.average_final_state
+
+    @property
+    def average_expect(self):
+        return [np.array(val) for val in self.average_e_data.values()]
+
+    @property
+    def std_expect(self):
+        return [np.array(val) for val in self.std_e_data.values()]
+
+    @property
+    def runs_expect(self):
+        return [np.array(val) for val in self.runs_e_data.values()]
+
+    @property
+    def expect(self):
+        return [np.array(val) for val in self.e_data.values()]
+
+    def steady_state(self, N=0):
+        """
+        Average the states of the last ``N`` times of every runs as a density
+        matrix. Should converge to the steady state in the right circumstances.
+
+        Parameters
+        ----------
+        N : int [optional]
+            Number of states from the end of ``tlist`` to average. Per default
+            all states will be averaged.
+        """
+        N = int(N) or len(self.times)
+        N = len(self.times) if N > len(self.times) else N
+        states = self.average_states
+        if states is not None:
+            return sum(states[-N:]) / N
+        else:
+            return None
+
+    def __repr__(self):
+        lines = [
+            f"<{self.__class__.__name__}",
+            f"  Solver: {self.solver}",
+        ]
+        if self.stats:
+            lines.append("  Solver stats:")
+            lines.extend(
+                f"    {k}: {v!r}"
+                for k, v in self.stats.items()
+            )
+        if self.times:
+            lines.append(
+                f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
+                f" ({len(self.times)} steps)"
+            )
+        lines.append(f"  Number of e_ops: {len(self.e_ops)}")
+        if self.states:
+            lines.append("  States saved.")
+        elif self.final_state is not None:
+            lines.append("  Final state saved.")
+        else:
+            lines.append("  State not saved.")
+        lines.append(f"  Number of trajectories: {self.num_trajectories}")
+        if self.trajectories:
+            lines.append("  Trajectories saved.")
+        else:
+            lines.append("  Trajectories not saved.")
+        lines.append(">")
+        return "\n".join(lines)
+
+    def __add__(self, other):
+        if not isinstance(other, MultiTrajResult):
+            return NotImplemented
+        if self._raw_ops != other._raw_ops:
+            raise ValueError("Shared `e_ops` is required to merge results")
+        if self.times != other.times:
+            raise ValueError("Shared `times` are is required to merge results")
+        new = self.__class__(self._raw_ops, self.options,
+                             solver=self.solver, stats=self.stats)
+        if self.trajectories and other.trajectories:
+            new.trajectories = self.trajectories + other.trajectories
+        new.num_trajectories = self.num_trajectories + other.num_trajectories
+        new.times = self.times
+        new.seeds = self.seeds + other.seeds
+
+        if self._sum_states is not None and other._sum_states is not None:
+            new._sum_states = self._sum_states + other._sum_states
+
+        if (
+            self._sum_final_states is not None
+            and other._sum_final_states is not None
+        ):
+            new._sum_final_states = (
+                self._sum_final_states + other._sum_final_states
+            )
+        new._target_tols = None
+
+        new._sum_expect = []
+        new._sum2_expect = []
+        new.average_e_data = {}
+        new.std_e_data = {}
+
+        for i, k in enumerate(self._raw_ops):
+            new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
+            new._sum2_expect.append(self._sum2_expect[i]
+                                    + other._sum2_expect[i])
+
+            avg = new._sum_expect[i] / new.num_trajectories
+            avg2 = new._sum2_expect[i] / new.num_trajectories
+
+            new.average_e_data[k] = list(avg)
+            new.e_data = new.average_e_data
+
+            new.std_e_data[k] = np.sqrt(np.abs(avg2 - np.abs(avg**2)))
+
+            if new.trajectories:
+                new.runs_e_data[k] = self.runs_e_data[k] + other.runs_e_data[k]
+                new.e_data = new.runs_e_data
+
+        new.stats["run time"] += other.stats["run time"]
+        new.stats['end_condition'] = "Merged results"
+
+        return new
+
+
+class McResult(MultiTrajResult):
+    """
+    Base class for storing solver results.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``.expect`` attribute of this result
+        object. ``.expect`` is a list, where each item contains the values
+        of the corresponding ``e_op``.
+
+    options : :obj:`~SolverResultsOptions`
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+        Must include a value for "num_collapse".
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Properties
+    ----------
+    collapse : list
+        For each runs, a list of every collapse as a tuple of the time it
+        happened and the corresponding ``c_ops`` index.
+    """
+    # Collapse are only produced by mcsolve.
+
+    def _add_collapse(self, trajectory):
+        self.collapse.append(trajectory.collapse)
+
+    def _post_init(self):
+        super()._post_init()
+        self.num_c_ops = self.stats["num_collapse"]
+        self.collapse = []
+        self.add_processor(self._add_collapse)
+
+    @property
+    def col_times(self):
+        """
+        List of the times of the collapses for each runs.
+        """
+        out = []
+        for col_ in self.collapse:
+            col = list(zip(*col_))
+            col = ([] if len(col) == 0 else col[0])
+            out.append(col)
+        return out
+
+    @property
+    def col_which(self):
+        """
+        List of the indexes of the collapses for each runs.
+        """
+        out = []
+        for col_ in self.collapse:
+            col = list(zip(*col_))
+            col = ([] if len(col) == 0 else col[1])
+            out.append(col)
+        return out
+
+    @property
+    def photocurrent(self):
+        """
+        Average photocurrent or measurement of the evolution.
+        """
+        cols = [[] for _ in range(self.num_c_ops)]
+        tlist = self.times
+        for collapses in self.collapse:
+            for t, which in collapses:
+                cols[which].append(t)
+        mesurement = [
+            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
+            for i in range(self.num_c_ops)
+        ]
+        return mesurement
+
+    @property
+    def runs_photocurrent(self):
+        """
+        Photocurrent or measurement of each runs.
+        """
+        tlist = self.times
+        measurements = []
+        for collapses in self.collapse:
+            cols = [[] for _ in range(self.num_c_ops)]
+            for t, which in collapses:
+                cols[which].append(t)
+            measurements.append([
+                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
+                for i in range(self.num_c_ops)
+            ])
+        return measurements
diff --git a/qutip/solver/scattering.py b/qutip/solver/scattering.py
index b7bdd2512a..5855832dbb 100644
--- a/qutip/solver/scattering.py
+++ b/qutip/solver/scattering.py
@@ -1,301 +1,301 @@
-"""
-Photon scattering in quantum optical systems
-
-This module includes a collection of functions for numerically computing photon
-scattering in driven arbitrary systems coupled to some configuration of output
-waveguides. The implementation of these functions closely follows the
-mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
-Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
-"""
-# Author:  Ben Bartlett
-# Contact: benbartlett@stanford.edu
-
-import numpy as np
-from itertools import product, combinations_with_replacement
-from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
-from .propagator import propagator, Propagator
-
-__all__ = ['temporal_basis_vector',
-           'temporal_scattered_state',
-           'scattering_probability']
-
-
-def set_partition(collection, num_sets):
-    """
-    Enumerate all ways of partitioning collection into num_sets different
-    lists, e.g. :
-    list(set_partition([1,2], 2))
-    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
-
-    Parameters
-    ----------
-    collection : iterable
-        Collection to generate a set partition of.
-    num_sets : int
-        Number of sets to partition collection into.
-
-    Returns
-    -------
-    partition : iterable
-        The partitioning of collection into num_sets sets.
-    """
-    for partitioning in product(range(num_sets), repeat=len(collection)):
-        partition = [[] for _ in range(num_sets)]
-        for i, set_index in enumerate(partitioning):
-            partition[set_index].append(collection[i])
-        yield tuple(tuple(indices) for indices in partition)
-
-
-def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
-    """
-    Compute the scattering amplitude for a system emitting into multiple
-    waveguides.
-
-    Parameters
-    ----------
-    propagator : :class:Propagator
-        Propagator
-    c_ops : list
-        list of collapse operators for each waveguide; these are assumed to
-        include spontaneous decay rates, e.g.
-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
-    tlist : array_like
-        List of times starting at the beginning and ending at the end of the
-        evolution.
-    taus : list-like
-        List of (list of emission times) for each waveguide.
-    psi : Qobj
-        State at the start of the evolution
-    psit : Qobj
-        State at the end of the evolution.
-    """
-    # Extract the full list of taus
-    tau_collapse = []
-    for i, tau_wg in enumerate(taus):
-        for t in tau_wg:
-            tau_collapse.append((t, i))
-    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
-
-    tq = tlist[0]
-    # Compute Prod Ueff(tq, tq-1)
-    for tau in tau_collapse:
-        tprev = tq
-        tq, q = tau
-        psi = c_ops[q] * propagator(tq, tprev) * psi
-
-    psi = propagator(tlist[-1], tq) * psi
-    return psit.overlap(psi)
-
-
-def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
-    """
-    Generate a the global index for the excitation.
-    """
-    idx = []
-    for i, wg_indices in enumerate(waveguide_emission_indices):
-        for index in wg_indices:
-            idx += [i * n_time_bins + index]
-    idx = idx or [0]
-    return tuple(idx)
-
-
-def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
-                         n_emissions=None):
-    """
-    Return the dims of the ``temporal_basis_vector``.
-    """
-    num_col = len(waveguide_emission_indices)
-    if n_emissions is None:
-        n_emissions = sum(
-            [len(waveguide_indices)
-             for waveguide_indices in waveguide_emission_indices])
-    n_emissions = n_emissions or 1
-    return [num_col * n_time_bins] * n_emissions
-
-
-def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
-                          n_emissions=None):
-    """
-    Generate a temporal basis vector for emissions at specified time bins into
-    specified waveguides.
-
-    Parameters
-    ----------
-    waveguide_emission_indices : list or tuple
-        List of indices where photon emission occurs for each waveguide,
-        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
-    n_time_bins : int
-        Number of time bins; the range over which each index can vary.
-
-    Returns
-    -------
-    temporal_basis_vector : :class: qutip.Qobj
-        A basis vector representing photon scattering at the specified indices.
-        If there are W waveguides, T times, and N photon emissions, then the
-        basis vector has dimensionality (W*T)^N.
-    """
-    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
-    dims = _temporal_basis_dims(waveguide_emission_indices,
-                                n_time_bins, n_emissions)
-    return basis(dims, list(idx))
-
-
-def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
-                               system_zero_state=None,
-                               construct_effective_hamiltonian=True):
-    """
-    Compute the scattered n-photon state as an ndarray.
-    """
-    T = len(tlist)
-    W = len(c_ops)
-    em_dims = max(n_emissions, 1)
-    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
-
-    if construct_effective_hamiltonian:
-        # Construct an effective Hamiltonian from system hamiltonian and c_ops
-        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
-    else:
-        Heff = H
-
-    evolver = Propagator(Heff, memoize=len(tlist))
-
-    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
-
-    if system_zero_state is None:
-        system_zero_state = psi0
-
-    # Compute <omega_tau> for all combinations of tau
-    for emission_indices in all_emission_indices:
-        # Consider unique partitionings of emission times into waveguides
-        partition = tuple(set(set_partition(emission_indices, W)))
-        # Consider all possible partitionings of time bins by waveguide
-        for indices in partition:
-            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
-            phi_n_amp = photon_scattering_amplitude(
-                evolver, c_ops, tlist,
-                taus, psi0, system_zero_state
-            )
-            # Add scatter amplitude times temporal basis to overall state
-            idx = _temporal_basis_idx(indices, T)
-            phi_n[idx] = phi_n_amp
-    return phi_n
-
-
-def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
-                             system_zero_state=None,
-                             construct_effective_hamiltonian=True):
-    """
-    Compute the scattered n-photon state projected onto the temporal basis.
-
-    Parameters
-    ----------
-    H : :class: qutip.Qobj or list
-        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
-        list-callback format. If construct_effective_hamiltonian is not
-        specified, an effective Hamiltonian is constructed from `H` and
-        `c_ops`.
-    psi0 : :class: qutip.Qobj
-        Initial state density matrix :math:`\\rho(t_0)` or state vector
-        :math:`\\psi(t_0)`.
-    n_emissions : int
-        Number of photon emissions to calculate.
-    c_ops : list
-        List of collapse operators for each waveguide; these are assumed to
-        include spontaneous decay rates, e.g.
-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
-    tlist : array_like
-        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
-        the pulse duration / temporal region of interest.
-    system_zero_state : :class: qutip.Qobj
-        State representing zero excitations in the system. Defaults to
-        :math:`\\psi(t_0)`
-    construct_effective_hamiltonian : bool
-        Whether an effective Hamiltonian should be constructed from H and
-        c_ops:
-        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
-        Default: True.
-
-    Returns
-    -------
-    phi_n : :class: qutip.Qobj
-        The scattered bath state projected onto the temporal basis given by
-        tlist. If there are W waveguides, T times, and N photon emissions, then
-        the state is a tensor product state with dimensionality T^(W*N).
-    """
-    T = len(tlist)
-    W = len(c_ops)
-    em_dims = max(n_emissions, 1)
-    phi_n = _temporal_scattered_matrix(
-        H, psi0, n_emissions, c_ops, tlist,
-        system_zero_state, construct_effective_hamiltonian
-    )
-    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
-
-
-def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
-                           system_zero_state=None,
-                           construct_effective_hamiltonian=True):
-    """
-    Compute the integrated probability of scattering n photons in an arbitrary
-    system. This function accepts a nonlinearly spaced array of times.
-
-    Parameters
-    ----------
-    H : :class: qutip.Qobj or list
-        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
-        list-callback format. If construct_effective_hamiltonian is not
-        specified, an effective Hamiltonian is constructed from H and
-        `c_ops`.
-    psi0 : :class: qutip.Qobj
-        Initial state density matrix :math:`\\rho(t_0)` or state vector
-        :math:`\\psi(t_0)`.
-    n_emissions : int
-        Number of photons emitted by the system (into any combination of
-        waveguides).
-    c_ops : list
-        List of collapse operators for each waveguide; these are assumed to
-        include spontaneous decay rates, e.g.
-        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
-    tlist : array_like
-        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
-        the pulse duration / temporal region of interest; tlist need not be
-        linearly spaced.
-    system_zero_state : :class: qutip.Qobj
-        State representing zero excitations in the system. Defaults to
-        `basis(systemDims, 0)`.
-    construct_effective_hamiltonian : bool
-        Whether an effective Hamiltonian should be constructed from H and
-        c_ops:
-        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
-        Default: True.
-
-    Returns
-    -------
-    scattering_prob : float
-        The probability of scattering n photons from the system over the time
-        range specified.
-    """
-    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
-                                       system_zero_state,
-                                       construct_effective_hamiltonian)
-    T = len(tlist)
-    W = len(c_ops)
-
-    # Compute <omega_tau> for all combinations of tau
-    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
-    probs = np.zeros([T] * n_emissions)
-
-    # Project scattered state onto temporal basis
-    for emit_indices in all_emission_indices:
-        # Consider unique emission time partitionings
-        partition = tuple(set(set_partition(emit_indices, W)))
-        # wg_indices_list = list(set_partition(indices, W))
-        for wg_indices in partition:
-            idx = _temporal_basis_idx(wg_indices, T)
-            amplitude = phi_n[idx]
-            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
-
-    # Iteratively integrate to obtain single value
-    while probs.shape != ():
-        probs = np.trapz(probs, x=tlist)
-    return np.abs(probs)
+"""
+Photon scattering in quantum optical systems
+
+This module includes a collection of functions for numerically computing photon
+scattering in driven arbitrary systems coupled to some configuration of output
+waveguides. The implementation of these functions closely follows the
+mathematical treatment given in K.A. Fischer, et. al., Scattering of Coherent
+Pulses from Quantum Optical Systems (2017, arXiv:1710.02875).
+"""
+# Author:  Ben Bartlett
+# Contact: benbartlett@stanford.edu
+
+import numpy as np
+from itertools import product, combinations_with_replacement
+from ..core import basis, tensor, zero_ket, Qobj, QobjEvo
+from .propagator import propagator, Propagator
+
+__all__ = ['temporal_basis_vector',
+           'temporal_scattered_state',
+           'scattering_probability']
+
+
+def set_partition(collection, num_sets):
+    """
+    Enumerate all ways of partitioning collection into num_sets different
+    lists, e.g. :
+    list(set_partition([1,2], 2))
+    >>> [[[1, 2], []], [[1], [2]], [[2], [1]], [[], [1, 2]]]
+
+    Parameters
+    ----------
+    collection : iterable
+        Collection to generate a set partition of.
+    num_sets : int
+        Number of sets to partition collection into.
+
+    Returns
+    -------
+    partition : iterable
+        The partitioning of collection into num_sets sets.
+    """
+    for partitioning in product(range(num_sets), repeat=len(collection)):
+        partition = [[] for _ in range(num_sets)]
+        for i, set_index in enumerate(partitioning):
+            partition[set_index].append(collection[i])
+        yield tuple(tuple(indices) for indices in partition)
+
+
+def photon_scattering_amplitude(propagator, c_ops, tlist, taus, psi, psit):
+    """
+    Compute the scattering amplitude for a system emitting into multiple
+    waveguides.
+
+    Parameters
+    ----------
+    propagator : :class:Propagator
+        Propagator
+    c_ops : list
+        list of collapse operators for each waveguide; these are assumed to
+        include spontaneous decay rates, e.g.
+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
+    tlist : array_like
+        List of times starting at the beginning and ending at the end of the
+        evolution.
+    taus : list-like
+        List of (list of emission times) for each waveguide.
+    psi : Qobj
+        State at the start of the evolution
+    psit : Qobj
+        State at the end of the evolution.
+    """
+    # Extract the full list of taus
+    tau_collapse = []
+    for i, tau_wg in enumerate(taus):
+        for t in tau_wg:
+            tau_collapse.append((t, i))
+    tau_collapse.sort(key=lambda tup: tup[0])  # sort tau_collapse by time
+
+    tq = tlist[0]
+    # Compute Prod Ueff(tq, tq-1)
+    for tau in tau_collapse:
+        tprev = tq
+        tq, q = tau
+        psi = c_ops[q] * propagator(tq, tprev) * psi
+
+    psi = propagator(tlist[-1], tq) * psi
+    return psit.overlap(psi)
+
+
+def _temporal_basis_idx(waveguide_emission_indices, n_time_bins):
+    """
+    Generate a the global index for the excitation.
+    """
+    idx = []
+    for i, wg_indices in enumerate(waveguide_emission_indices):
+        for index in wg_indices:
+            idx += [i * n_time_bins + index]
+    idx = idx or [0]
+    return tuple(idx)
+
+
+def _temporal_basis_dims(waveguide_emission_indices, n_time_bins,
+                         n_emissions=None):
+    """
+    Return the dims of the ``temporal_basis_vector``.
+    """
+    num_col = len(waveguide_emission_indices)
+    if n_emissions is None:
+        n_emissions = sum(
+            [len(waveguide_indices)
+             for waveguide_indices in waveguide_emission_indices])
+    n_emissions = n_emissions or 1
+    return [num_col * n_time_bins] * n_emissions
+
+
+def temporal_basis_vector(waveguide_emission_indices, n_time_bins,
+                          n_emissions=None):
+    """
+    Generate a temporal basis vector for emissions at specified time bins into
+    specified waveguides.
+
+    Parameters
+    ----------
+    waveguide_emission_indices : list or tuple
+        List of indices where photon emission occurs for each waveguide,
+        e.g. [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]].
+    n_time_bins : int
+        Number of time bins; the range over which each index can vary.
+
+    Returns
+    -------
+    temporal_basis_vector : :class: qutip.Qobj
+        A basis vector representing photon scattering at the specified indices.
+        If there are W waveguides, T times, and N photon emissions, then the
+        basis vector has dimensionality (W*T)^N.
+    """
+    idx = _temporal_basis_idx(waveguide_emission_indices, n_time_bins)
+    dims = _temporal_basis_dims(waveguide_emission_indices,
+                                n_time_bins, n_emissions)
+    return basis(dims, list(idx))
+
+
+def _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
+                               system_zero_state=None,
+                               construct_effective_hamiltonian=True):
+    """
+    Compute the scattered n-photon state as an ndarray.
+    """
+    T = len(tlist)
+    W = len(c_ops)
+    em_dims = max(n_emissions, 1)
+    phi_n = np.zeros([W * T] * em_dims, dtype=complex)
+
+    if construct_effective_hamiltonian:
+        # Construct an effective Hamiltonian from system hamiltonian and c_ops
+        Heff = QobjEvo(H) - 1j / 2 * sum([op.dag() * op for op in c_ops])
+    else:
+        Heff = H
+
+    evolver = Propagator(Heff, memoize=len(tlist))
+
+    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
+
+    if system_zero_state is None:
+        system_zero_state = psi0
+
+    # Compute <omega_tau> for all combinations of tau
+    for emission_indices in all_emission_indices:
+        # Consider unique partitionings of emission times into waveguides
+        partition = tuple(set(set_partition(emission_indices, W)))
+        # Consider all possible partitionings of time bins by waveguide
+        for indices in partition:
+            taus = [[tlist[i] for i in wg_indices] for wg_indices in indices]
+            phi_n_amp = photon_scattering_amplitude(
+                evolver, c_ops, tlist,
+                taus, psi0, system_zero_state
+            )
+            # Add scatter amplitude times temporal basis to overall state
+            idx = _temporal_basis_idx(indices, T)
+            phi_n[idx] = phi_n_amp
+    return phi_n
+
+
+def temporal_scattered_state(H, psi0, n_emissions, c_ops, tlist,
+                             system_zero_state=None,
+                             construct_effective_hamiltonian=True):
+    """
+    Compute the scattered n-photon state projected onto the temporal basis.
+
+    Parameters
+    ----------
+    H : :class: qutip.Qobj or list
+        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
+        list-callback format. If construct_effective_hamiltonian is not
+        specified, an effective Hamiltonian is constructed from `H` and
+        `c_ops`.
+    psi0 : :class: qutip.Qobj
+        Initial state density matrix :math:`\\rho(t_0)` or state vector
+        :math:`\\psi(t_0)`.
+    n_emissions : int
+        Number of photon emissions to calculate.
+    c_ops : list
+        List of collapse operators for each waveguide; these are assumed to
+        include spontaneous decay rates, e.g.
+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`
+    tlist : array_like
+        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
+        the pulse duration / temporal region of interest.
+    system_zero_state : :class: qutip.Qobj
+        State representing zero excitations in the system. Defaults to
+        :math:`\\psi(t_0)`
+    construct_effective_hamiltonian : bool
+        Whether an effective Hamiltonian should be constructed from H and
+        c_ops:
+        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
+        Default: True.
+
+    Returns
+    -------
+    phi_n : :class: qutip.Qobj
+        The scattered bath state projected onto the temporal basis given by
+        tlist. If there are W waveguides, T times, and N photon emissions, then
+        the state is a tensor product state with dimensionality T^(W*N).
+    """
+    T = len(tlist)
+    W = len(c_ops)
+    em_dims = max(n_emissions, 1)
+    phi_n = _temporal_scattered_matrix(
+        H, psi0, n_emissions, c_ops, tlist,
+        system_zero_state, construct_effective_hamiltonian
+    )
+    return Qobj(phi_n.ravel(), dims=[[W * T] * em_dims, [1] * em_dims])
+
+
+def scattering_probability(H, psi0, n_emissions, c_ops, tlist,
+                           system_zero_state=None,
+                           construct_effective_hamiltonian=True):
+    """
+    Compute the integrated probability of scattering n photons in an arbitrary
+    system. This function accepts a nonlinearly spaced array of times.
+
+    Parameters
+    ----------
+    H : :class: qutip.Qobj or list
+        System-waveguide(s) Hamiltonian or effective Hamiltonian in Qobj or
+        list-callback format. If construct_effective_hamiltonian is not
+        specified, an effective Hamiltonian is constructed from H and
+        `c_ops`.
+    psi0 : :class: qutip.Qobj
+        Initial state density matrix :math:`\\rho(t_0)` or state vector
+        :math:`\\psi(t_0)`.
+    n_emissions : int
+        Number of photons emitted by the system (into any combination of
+        waveguides).
+    c_ops : list
+        List of collapse operators for each waveguide; these are assumed to
+        include spontaneous decay rates, e.g.
+        :math:`\\sigma = \\sqrt \\gamma \\cdot a`.
+    tlist : array_like
+        List of times for :math:`\\tau_i`. tlist should contain 0 and exceed
+        the pulse duration / temporal region of interest; tlist need not be
+        linearly spaced.
+    system_zero_state : :class: qutip.Qobj
+        State representing zero excitations in the system. Defaults to
+        `basis(systemDims, 0)`.
+    construct_effective_hamiltonian : bool
+        Whether an effective Hamiltonian should be constructed from H and
+        c_ops:
+        :math:`H_{eff} = H - \\frac{i}{2} \\sum_n \\sigma_n^\\dagger \\sigma_n`
+        Default: True.
+
+    Returns
+    -------
+    scattering_prob : float
+        The probability of scattering n photons from the system over the time
+        range specified.
+    """
+    phi_n = _temporal_scattered_matrix(H, psi0, n_emissions, c_ops, tlist,
+                                       system_zero_state,
+                                       construct_effective_hamiltonian)
+    T = len(tlist)
+    W = len(c_ops)
+
+    # Compute <omega_tau> for all combinations of tau
+    all_emission_indices = combinations_with_replacement(range(T), n_emissions)
+    probs = np.zeros([T] * n_emissions)
+
+    # Project scattered state onto temporal basis
+    for emit_indices in all_emission_indices:
+        # Consider unique emission time partitionings
+        partition = tuple(set(set_partition(emit_indices, W)))
+        # wg_indices_list = list(set_partition(indices, W))
+        for wg_indices in partition:
+            idx = _temporal_basis_idx(wg_indices, T)
+            amplitude = phi_n[idx]
+            probs[emit_indices] += np.real(amplitude.conjugate() * amplitude)
+
+    # Iteratively integrate to obtain single value
+    while probs.shape != ():
+        probs = np.trapz(probs, x=tlist)
+    return np.abs(probs)
diff --git a/qutip/solver/sesolve.py b/qutip/solver/sesolve.py
index 8ed998ba15..0914624232 100644
--- a/qutip/solver/sesolve.py
+++ b/qutip/solver/sesolve.py
@@ -1,189 +1,189 @@
-"""
-This module provides solvers for the unitary Schrodinger equation.
-"""
-
-__all__ = ['sesolve', 'SESolver']
-
-import numpy as np
-from time import time
-from .. import Qobj, QobjEvo
-from .solver_base import Solver
-
-
-def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
-    """
-    Schrodinger equation evolution of a state vector or unitary matrix
-    for a given Hamiltonian.
-
-    Evolve the state vector (`psi0`) using a given
-    Hamiltonian (`H`), by integrating the set of ordinary differential
-    equations that define the system. Alternatively evolve a unitary matrix in
-    solving the Schrodinger operator equation.
-
-    The output is either the state vector or unitary matrix at arbitrary points
-    in time (`tlist`), or the expectation values of the supplied operators
-    (`e_ops`). If e_ops is a callback function, it is invoked for each
-    time in `tlist` with time and the state as arguments, and the function
-    does not use any return values. e_ops cannot be used in conjunction
-    with solving the Schrodinger operator equation
-
-    **Time-dependent operators**
-
-    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
-    object that can be interpreted as :class:`QobjEvo` such as a list of
-    (Qobj, Coefficient) pairs or a function.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    psi0 : :class:`qutip.qobj`
-        initial state vector (ket)
-        or initial unitary operator `psi0 = U`
-
-    tlist : *list* / *array*
-        list of times for :math:`t`.
-
-    e_ops : :class:`qutip.qobj`, callable, or list.
-        Single operator or list of operators for which to evaluate
-        expectation values or callable or list of callable.
-        Callable signature must be, `f(t: float, state: Qobj)`.
-        See :func:`expect` for more detail of operator expectation.
-
-    args : None / *dictionary*
-        dictionary of parameters for time-dependent Hamiltonians
-
-    options : None / dict
-        Dictionary of options for the solver.
-
-        - store_final_state : bool
-          Whether or not to store the final state of the evolution in the
-          result class.
-        - store_states : bool, None
-          Whether or not to store the state vectors or density matrices.
-          On `None` the states will be saved if no expectation operators are
-          given.
-        - normalize_output : bool
-          Normalize output state to hide ODE numerical errors.
-        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
-          How to present the solver progress.
-          'tqdm' uses the python module of the same name and raise an error
-          if not installed. Empty string or False will disable the bar.
-        - progress_kwargs : dict
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
-        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
-          Which differential equation integration method to use.
-        - atol, rtol : float
-          Absolute and relative tolerance of the ODE integrator.
-        - nsteps :
-          Maximum number of (internally defined) steps allowed in one ``tlist``
-          step.
-        - max_step : float, 0
-          Maximum lenght of one internal step. When using pulses, it should be
-          less than half the width of the thinnest pulse.
-
-        Other options could be supported depending on the integration method,
-        see `Integrator <./classes.html#classes-ode>`_.
-
-    Returns
-    -------
-    result: :class:`qutip.Result`
-
-        An instance of the class :class:`qutip.Result`, which contains
-        a *list of array* `result.expect` of expectation values for the times
-        specified by `tlist`, and/or a *list* `result.states` of state vectors
-        or density matrices corresponding to the times in `tlist` [if `e_ops`
-        is an empty list of `store_states=True` in options].
-    """
-    H = QobjEvo(H, args=args, tlist=tlist)
-    solver = SESolver(H, options=options)
-    return solver.run(psi0, tlist, e_ops=e_ops)
-
-
-class SESolver(Solver):
-    """
-    Schrodinger equation evolution of a state vector or unitary matrix
-    for a given Hamiltonian.
-
-    Parameters
-    ----------
-    H : :class:`Qobj`, :class:`QobjEvo`
-        System Hamiltonian as a Qobj or QobjEvo for time-dependent
-        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
-        that can be made into :class:`QobjEvo` are also accepted.
-
-    options : dict, optional
-        Options for the solver, see :obj:`SESolver.options` and
-        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
-
-    attributes
-    ----------
-    stats: dict
-        Diverse diagnostic statistics of the evolution.
-    """
-    name = "sesolve"
-    _avail_integrators = {}
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size":10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": True,
-        'method': 'adams',
-    }
-
-    def __init__(self, H, *, options=None):
-        _time_start = time()
-
-        if not isinstance(H, (Qobj, QobjEvo)):
-            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
-
-        rhs = -1j * H
-        if not rhs.isoper:
-            raise ValueError("The hamiltonian must be an operator")
-        super().__init__(rhs, options=options)
-
-    def _initialize_stats(self):
-        stats = super()._initialize_stats()
-        stats.update({
-            "solver": "Schrodinger Evolution",
-        })
-        return stats
-
-    @property
-    def options(self):
-        """
-        Solver's options:
-
-        store_final_state: bool, default=False
-            Whether or not to store the final state of the evolution in the
-            result class.
-
-        store_states: bool, default=None
-            Whether or not to store the state vectors or density matrices.
-            On `None` the states will be saved if no expectation operators are
-            given.
-
-        normalize_output: bool, default=True
-            Normalize output state to hide ODE numerical errors.
-
-        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
-            How to present the solver progress.
-            'tqdm' uses the python module of the same name and raise an error
-            if not installed. Empty string or False will disable the bar.
-
-        progress_kwargs: dict, default={"chunk_size": 10}
-            Arguments to pass to the progress_bar. Qutip's bars use
-            ``chunk_size``.
-
-        method: str, default="adams"
-            Which ordinary differential equation integration method to use.
-        """
-        return self._options
-
-    @options.setter
-    def options(self, new_options):
-        Solver.options.fset(self, new_options)
+"""
+This module provides solvers for the unitary Schrodinger equation.
+"""
+
+__all__ = ['sesolve', 'SESolver']
+
+import numpy as np
+from time import time
+from .. import Qobj, QobjEvo
+from .solver_base import Solver
+
+
+def sesolve(H, psi0, tlist, e_ops=None, args=None, options=None):
+    """
+    Schrodinger equation evolution of a state vector or unitary matrix
+    for a given Hamiltonian.
+
+    Evolve the state vector (`psi0`) using a given
+    Hamiltonian (`H`), by integrating the set of ordinary differential
+    equations that define the system. Alternatively evolve a unitary matrix in
+    solving the Schrodinger operator equation.
+
+    The output is either the state vector or unitary matrix at arbitrary points
+    in time (`tlist`), or the expectation values of the supplied operators
+    (`e_ops`). If e_ops is a callback function, it is invoked for each
+    time in `tlist` with time and the state as arguments, and the function
+    does not use any return values. e_ops cannot be used in conjunction
+    with solving the Schrodinger operator equation
+
+    **Time-dependent operators**
+
+    For time-dependent problems, `H` and `c_ops` can be a :class:`QobjEvo` or
+    object that can be interpreted as :class:`QobjEvo` such as a list of
+    (Qobj, Coefficient) pairs or a function.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`, :class:`QobjEvo` compatible format.
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    psi0 : :class:`qutip.qobj`
+        initial state vector (ket)
+        or initial unitary operator `psi0 = U`
+
+    tlist : *list* / *array*
+        list of times for :math:`t`.
+
+    e_ops : :class:`qutip.qobj`, callable, or list.
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
+
+    args : None / *dictionary*
+        dictionary of parameters for time-dependent Hamiltonians
+
+    options : None / dict
+        Dictionary of options for the solver.
+
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
+        - progress_bar : str {'text', 'enhanced', 'tqdm', ''}
+          How to present the solver progress.
+          'tqdm' uses the python module of the same name and raise an error
+          if not installed. Empty string or False will disable the bar.
+        - progress_kwargs : dict
+          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+        - method : str ["adams", "bdf", "lsoda", "dop853", "vern9", etc.]
+          Which differential equation integration method to use.
+        - atol, rtol : float
+          Absolute and relative tolerance of the ODE integrator.
+        - nsteps :
+          Maximum number of (internally defined) steps allowed in one ``tlist``
+          step.
+        - max_step : float, 0
+          Maximum lenght of one internal step. When using pulses, it should be
+          less than half the width of the thinnest pulse.
+
+        Other options could be supported depending on the integration method,
+        see `Integrator <./classes.html#classes-ode>`_.
+
+    Returns
+    -------
+    result: :class:`qutip.Result`
+
+        An instance of the class :class:`qutip.Result`, which contains
+        a *list of array* `result.expect` of expectation values for the times
+        specified by `tlist`, and/or a *list* `result.states` of state vectors
+        or density matrices corresponding to the times in `tlist` [if `e_ops`
+        is an empty list of `store_states=True` in options].
+    """
+    H = QobjEvo(H, args=args, tlist=tlist)
+    solver = SESolver(H, options=options)
+    return solver.run(psi0, tlist, e_ops=e_ops)
+
+
+class SESolver(Solver):
+    """
+    Schrodinger equation evolution of a state vector or unitary matrix
+    for a given Hamiltonian.
+
+    Parameters
+    ----------
+    H : :class:`Qobj`, :class:`QobjEvo`
+        System Hamiltonian as a Qobj or QobjEvo for time-dependent
+        Hamiltonians. List of [:class:`Qobj`, :class:`Coefficient`] or callable
+        that can be made into :class:`QobjEvo` are also accepted.
+
+    options : dict, optional
+        Options for the solver, see :obj:`SESolver.options` and
+        `Integrator <./classes.html#classes-ode>`_ for a list of all options.
+
+    attributes
+    ----------
+    stats: dict
+        Diverse diagnostic statistics of the evolution.
+    """
+    name = "sesolve"
+    _avail_integrators = {}
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size":10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": True,
+        'method': 'adams',
+    }
+
+    def __init__(self, H, *, options=None):
+        _time_start = time()
+
+        if not isinstance(H, (Qobj, QobjEvo)):
+            raise TypeError("The Hamiltonian must be a Qobj or QobjEvo")
+
+        rhs = -1j * H
+        if not rhs.isoper:
+            raise ValueError("The hamiltonian must be an operator")
+        super().__init__(rhs, options=options)
+
+    def _initialize_stats(self):
+        stats = super()._initialize_stats()
+        stats.update({
+            "solver": "Schrodinger Evolution",
+        })
+        return stats
+
+    @property
+    def options(self):
+        """
+        Solver's options:
+
+        store_final_state: bool, default=False
+            Whether or not to store the final state of the evolution in the
+            result class.
+
+        store_states: bool, default=None
+            Whether or not to store the state vectors or density matrices.
+            On `None` the states will be saved if no expectation operators are
+            given.
+
+        normalize_output: bool, default=True
+            Normalize output state to hide ODE numerical errors.
+
+        progress_bar: str {'text', 'enhanced', 'tqdm', ''}, {}
+            How to present the solver progress.
+            'tqdm' uses the python module of the same name and raise an error
+            if not installed. Empty string or False will disable the bar.
+
+        progress_kwargs: dict, default={"chunk_size": 10}
+            Arguments to pass to the progress_bar. Qutip's bars use
+            ``chunk_size``.
+
+        method: str, default="adams"
+            Which ordinary differential equation integration method to use.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, new_options):
+        Solver.options.fset(self, new_options)
diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index ae0db23247..953bfab490 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -1,395 +1,395 @@
-__all__ = ['Solver']
-
-from .. import Qobj, QobjEvo, ket2dm
-from .options import _SolverOptions
-from ..core import stack_columns, unstack_columns
-from .result import Result
-from .integrator import Integrator
-from ..ui.progressbar import progess_bars
-from time import time
-
-
-class Solver:
-    """
-    Runner for an evolution.
-    Can run the evolution at once using :method:`run` or step by step using
-    :method:`start` and :method:`step`.
-
-    Parameters
-    ----------
-    rhs : Qobj, QobjEvo
-        Right hand side of the evolution::
-            d state / dt = rhs @ state
-
-    options : dict
-        Options for the solver
-    """
-    name = ""
-
-    # State, time and Integrator of the stepper functionnality
-    _integrator = None
-    _avail_integrators = {}
-
-    # Class of option used by the solver
-    solver_options = {
-        "progress_bar": "text",
-        "progress_kwargs": {"chunk_size": 10},
-        "store_final_state": False,
-        "store_states": None,
-        "normalize_output": "ket",
-        "method": "adams",
-    }
-    resultclass = Result
-
-    def __init__(self, rhs, *, options=None):
-        if isinstance(rhs, (QobjEvo, Qobj)):
-            self.rhs = QobjEvo(rhs)
-        else:
-            TypeError("The rhs must be a QobjEvo")
-        self.options = options
-        self._integrator = self._get_integrator()
-        self._state_metadata = {}
-        self.stats = self._initialize_stats()
-
-    def _initialize_stats(self):
-        """ Return the initial values for the solver stats.
-        """
-        return {
-            "method": self._integrator.name,
-            "init time": self._init_integrator_time,
-            "preparation time": 0.0,
-            "run time": 0.0,
-        }
-
-    def _prepare_state(self, state):
-        """
-        Extract the data of the Qobj state.
-
-        Is responsible for dims checks, preparing the data (stack columns, ...)
-        determining the dims of the output for :method:`_restore_state`.
-
-        Should return the state's data such that it can be used by Integrators.
-        """
-        if self.rhs.issuper and state.isket:
-            state = ket2dm(state)
-
-        if (
-            self.rhs.dims[1] != state.dims[0]
-            and self.rhs.dims[1] != state.dims
-        ):
-            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
-                            f" and {state.dims}")
-
-        self._state_metadata = {
-            'dims': state.dims,
-            'type': state.type,
-            'isherm': state.isherm and not (self.rhs.dims == state.dims)
-        }
-        if self.rhs.dims[1] == state.dims:
-            return stack_columns(state.data)
-        return state.data
-
-    def _restore_state(self, data, *, copy=True):
-        """
-        Retore the Qobj state from its data.
-        """
-        if self._state_metadata['dims'] == self.rhs.dims[1]:
-            state = Qobj(unstack_columns(data),
-                         **self._state_metadata, copy=False)
-        else:
-            state = Qobj(data, **self._state_metadata, copy=copy)
-
-        if data.shape[1] == 1 and self._options['normalize_output']:
-            state = state * (1 / state.norm())
-
-        return state
-
-    def run(self, state0, tlist, *, args=None, e_ops=None):
-        """
-        Do the evolution of the Quantum system.
-
-        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
-        ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :cls:`Result`. The evolution method and stored
-        results are determined by ``options``.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        tlist : list of double
-            Time for which to save the results (state and/or expect) of the
-            evolution. The first element of the list is the initial time of the
-            evolution. Each times of the list must be increasing, but does not
-            need to be uniformy distributed.
-
-        args : dict, optional {None}
-            Change the ``args`` of the rhs for the evolution.
-
-        e_ops : list {None}
-            List of Qobj, QobjEvo or callable to compute the expectation
-            values. Function[s] must have the signature
-            f(t : float, state : Qobj) -> expect.
-
-        Return
-        ------
-        results : :class:`qutip.solver.Result`
-            Results of the evolution. States and/or expect will be saved. You
-            can control the saved data in the options.
-        """
-        _time_start = time()
-        _data0 = self._prepare_state(state0)
-        self._integrator.set_state(tlist[0], _data0)
-        self._argument(args)
-        stats = self._initialize_stats()
-        results = self.resultclass(
-            e_ops, self.options,
-            solver=self.name, stats=stats,
-        )
-        results.add(tlist[0], self._restore_state(_data0, copy=False))
-        stats['preparation time'] += time() - _time_start
-
-        progress_bar = progess_bars[self.options['progress_bar']]()
-        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
-        for t, state in self._integrator.run(tlist):
-            progress_bar.update()
-            results.add(t, self._restore_state(state, copy=False))
-        progress_bar.finished()
-
-        stats['run time'] = progress_bar.total_time()
-        # TODO: It would be nice if integrator could give evolution statistics
-        # stats.update(_integrator.stats)
-        return results
-
-    def start(self, state0, t0):
-        """
-        Set the initial state and time for a step evolution.
-        ``options`` for the evolutions are read at this step.
-
-        Parameters
-        ----------
-        state0 : :class:`Qobj`
-            Initial state of the evolution.
-
-        t0 : double
-            Initial time of the evolution.
-        """
-        _time_start = time()
-        self._integrator.set_state(t0, self._prepare_state(state0))
-        self.stats["preparation time"] += time() - _time_start
-
-    def step(self, t, *, args=None, copy=True):
-        """
-        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
-
-        Parameters
-        ----------
-        t : double
-            Time to evolve to, must be higher than the last call.
-
-        args : dict, optional {None}
-            Update the ``args`` of the system.
-            The change is effective from the beginning of the interval.
-            Changing ``args`` can slow the evolution.
-
-        copy : bool, optional {True}
-            Whether to return a copy of the data or the data in the ODE solver.
-
-        .. note::
-            The state must be initialized first by calling ``start`` or
-            ``run``. If ``run`` is called, ``step`` will continue from the last
-            time and state obtained.
-        """
-        if not self._integrator._is_set:
-            raise RuntimeError("The `start` method must called first")
-        _time_start = time()
-        self._argument(args)
-        _, state = self._integrator.integrate(t, copy=False)
-        self.stats["run time"] += time() - _time_start
-        return self._restore_state(state, copy=copy)
-
-    def _get_integrator(self):
-        """ Return the initialted integrator. """
-        _time_start = time()
-        method = self._options["method"]
-        if method in self.avail_integrators():
-            integrator = self.avail_integrators()[method]
-        elif issubclass(method, Integrator):
-            integrator = method
-        else:
-            raise ValueError("Integrator method not supported.")
-        integrator_instance = integrator(self.rhs, self.options)
-        self._init_integrator_time = time() - _time_start
-        return integrator_instance
-
-    @property
-    def sys_dims(self):
-        """
-        Dimensions of the space that the system use:
-
-        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
-        for this solver.
-        """
-        return self.rhs.dims[0]
-
-    @property
-    def options(self):
-        """
-        method: str
-            Which ordinary differential equation integration method to use.
-        """
-        return self._options
-
-    def _parse_options(self, new_options, default, old_options):
-        """
-        Do a first read through of the options:
-        - Split new options' items included in the default from those that are
-          not.
-        - Replace ``None`` with the default value.
-        - Remove items that are unchanged.
-        """
-        included_options = {
-            key: val
-            for key, val in new_options.items()
-            if key in default
-        }
-        extra_options = {
-            key: val
-            for key, val in new_options.items()
-            if key not in default
-        }
-
-        # First pass: Have ``None`` refert to the default.
-        included_options = {
-            key: (val if val is not None else default[key])
-            for key, val in included_options.items()
-        }
-        # Second pass: Remove options that remain unchanged.
-        included_options = {
-            key: val
-            for key, val in included_options.items()
-            if not (key in old_options and val == old_options[key])
-        }
-        return included_options, extra_options
-
-    @options.setter
-    def options(self, new_options):
-        if not hasattr(self, "_options"):
-            self._options = {}
-        if new_options is None:
-            new_options = {}
-        if not isinstance(new_options, dict):
-            raise TypeError("options most to be a dictionary.")
-        new_solver_options, new_ode_options = self._parse_options(
-            new_options, self.solver_options, self.options
-        )
-        method = new_solver_options.get(
-            "method", self.options.get("method", self.solver_options["method"])
-        )
-        integrator = self.avail_integrators()[method]
-
-        if method == self.options.get("method", None):
-            # If method changed, drop old ode options
-            old_ode_options = self.options
-            old_options = self._options
-        else:
-            old_ode_options = {}
-            old_options, _ = self._parse_options(
-                self._options, self.solver_options, {}
-            )
-
-        new_ode_options, extra_options = self._parse_options(
-            new_ode_options, integrator.integrator_options, self.options
-        )
-        if extra_options:
-            raise KeyError(f"Options {extra_options.keys()} are not supported")
-        if self._options and not (new_solver_options or new_ode_options):
-            return  # Nothing to do
-
-        self._options = _SolverOptions(
-            {**self.solver_options, **integrator.integrator_options},
-            self._apply_options,
-            self.name + " with " + integrator.method + " integrator",
-            self.__class__.options.__doc__ + integrator.options.__doc__,
-            **{**old_options, **new_solver_options, **new_ode_options}
-        )
-
-        self._apply_options(set(new_options.keys()))
-
-    def _apply_options(self, keys):
-        """
-        Method called when options are changed, either through
-        ``solver.options[key] = value`` or ``solver.options = options``.
-        Allow to update the solver with the new options
-        """
-        from_setter = isinstance(keys, (set))
-        if not from_setter:
-            keys = set([keys])
-
-        if not from_setter and "method" in keys:
-            # Drop the ode's options.
-            old_solver_options, _ = self._parse_options(
-                self.options, self.solver_options, {}
-            )
-            method = self.options["method"]
-            integrator = self.avail_integrators()[method]
-
-            self._options = _SolverOptions(
-                {**self.solver_options, **integrator.integrator_options},
-                self._apply_options,
-                self.name + " with " + integrator.method + " integrator",
-                self.__class__.options.__doc__ + integrator.options.__doc__,
-                **old_solver_options
-            )
-
-        if self._integrator is None or not keys:
-            pass
-        elif 'method' in keys and self._integrator._is_set:
-            state = self._integrator.get_state()
-            self._integrator = self._get_integrator()
-            self._integrator.set_state(*state)
-        elif "method" in keys:
-            self._integrator = self._get_integrator()
-        elif keys & self._integrator.integrator_options.keys():
-            # Some of the keys are used by the integrator.
-            self._integrator.options = self._options
-            self._integrator.reset(hard=True)
-
-    def _argument(self, args):
-        """Update the args, for the `rhs` and other operators."""
-        if args:
-            self.rhs.arguments(args)
-            self._integrator.arguments(args)
-
-    @classmethod
-    def avail_integrators(cls):
-        if cls is Solver:
-            return cls._avail_integrators.copy()
-        return {
-            **Solver.avail_integrators(),
-            **cls._avail_integrators,
-        }
-
-    @classmethod
-    def integrator(cls, key):
-        return cls.avail_integrators()[key]
-
-    @classmethod
-    def add_integrator(cls, integrator, key):
-        """
-        Register an integrator.
-
-        Parameters
-        ----------
-        integrator : Integrator
-            The ODE solver to register.
-
-        keys : list of str
-            Values of the method options that refer to this integrator.
-        """
-        if not issubclass(integrator, Integrator):
-            raise TypeError(f"The integrator {integrator} must be a subclass"
-                            " of `qutip.solver.Integrator`")
-
-        cls._avail_integrators[key] = integrator
+__all__ = ['Solver']
+
+from .. import Qobj, QobjEvo, ket2dm
+from .options import _SolverOptions
+from ..core import stack_columns, unstack_columns
+from .result import Result
+from .integrator import Integrator
+from ..ui.progressbar import progess_bars
+from time import time
+
+
+class Solver:
+    """
+    Runner for an evolution.
+    Can run the evolution at once using :method:`run` or step by step using
+    :method:`start` and :method:`step`.
+
+    Parameters
+    ----------
+    rhs : Qobj, QobjEvo
+        Right hand side of the evolution::
+            d state / dt = rhs @ state
+
+    options : dict
+        Options for the solver
+    """
+    name = ""
+
+    # State, time and Integrator of the stepper functionnality
+    _integrator = None
+    _avail_integrators = {}
+
+    # Class of option used by the solver
+    solver_options = {
+        "progress_bar": "text",
+        "progress_kwargs": {"chunk_size": 10},
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": "ket",
+        "method": "adams",
+    }
+    resultclass = Result
+
+    def __init__(self, rhs, *, options=None):
+        if isinstance(rhs, (QobjEvo, Qobj)):
+            self.rhs = QobjEvo(rhs)
+        else:
+            TypeError("The rhs must be a QobjEvo")
+        self.options = options
+        self._integrator = self._get_integrator()
+        self._state_metadata = {}
+        self.stats = self._initialize_stats()
+
+    def _initialize_stats(self):
+        """ Return the initial values for the solver stats.
+        """
+        return {
+            "method": self._integrator.name,
+            "init time": self._init_integrator_time,
+            "preparation time": 0.0,
+            "run time": 0.0,
+        }
+
+    def _prepare_state(self, state):
+        """
+        Extract the data of the Qobj state.
+
+        Is responsible for dims checks, preparing the data (stack columns, ...)
+        determining the dims of the output for :method:`_restore_state`.
+
+        Should return the state's data such that it can be used by Integrators.
+        """
+        if self.rhs.issuper and state.isket:
+            state = ket2dm(state)
+
+        if (
+            self.rhs.dims[1] != state.dims[0]
+            and self.rhs.dims[1] != state.dims
+        ):
+            raise TypeError(f"incompatible dimensions {self.rhs.dims}"
+                            f" and {state.dims}")
+
+        self._state_metadata = {
+            'dims': state.dims,
+            'type': state.type,
+            'isherm': state.isherm and not (self.rhs.dims == state.dims)
+        }
+        if self.rhs.dims[1] == state.dims:
+            return stack_columns(state.data)
+        return state.data
+
+    def _restore_state(self, data, *, copy=True):
+        """
+        Retore the Qobj state from its data.
+        """
+        if self._state_metadata['dims'] == self.rhs.dims[1]:
+            state = Qobj(unstack_columns(data),
+                         **self._state_metadata, copy=False)
+        else:
+            state = Qobj(data, **self._state_metadata, copy=copy)
+
+        if data.shape[1] == 1 and self._options['normalize_output']:
+            state = state * (1 / state.norm())
+
+        return state
+
+    def run(self, state0, tlist, *, args=None, e_ops=None):
+        """
+        Do the evolution of the Quantum system.
+
+        For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
+        ``rhs`` and for each time in ``tlist`` store the state and/or
+        expectation values in a :cls:`Result`. The evolution method and stored
+        results are determined by ``options``.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        tlist : list of double
+            Time for which to save the results (state and/or expect) of the
+            evolution. The first element of the list is the initial time of the
+            evolution. Each times of the list must be increasing, but does not
+            need to be uniformy distributed.
+
+        args : dict, optional {None}
+            Change the ``args`` of the rhs for the evolution.
+
+        e_ops : list {None}
+            List of Qobj, QobjEvo or callable to compute the expectation
+            values. Function[s] must have the signature
+            f(t : float, state : Qobj) -> expect.
+
+        Return
+        ------
+        results : :class:`qutip.solver.Result`
+            Results of the evolution. States and/or expect will be saved. You
+            can control the saved data in the options.
+        """
+        _time_start = time()
+        _data0 = self._prepare_state(state0)
+        self._integrator.set_state(tlist[0], _data0)
+        self._argument(args)
+        stats = self._initialize_stats()
+        results = self.resultclass(
+            e_ops, self.options,
+            solver=self.name, stats=stats,
+        )
+        results.add(tlist[0], self._restore_state(_data0, copy=False))
+        stats['preparation time'] += time() - _time_start
+
+        progress_bar = progess_bars[self.options['progress_bar']]()
+        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
+        for t, state in self._integrator.run(tlist):
+            progress_bar.update()
+            results.add(t, self._restore_state(state, copy=False))
+        progress_bar.finished()
+
+        stats['run time'] = progress_bar.total_time()
+        # TODO: It would be nice if integrator could give evolution statistics
+        # stats.update(_integrator.stats)
+        return results
+
+    def start(self, state0, t0):
+        """
+        Set the initial state and time for a step evolution.
+        ``options`` for the evolutions are read at this step.
+
+        Parameters
+        ----------
+        state0 : :class:`Qobj`
+            Initial state of the evolution.
+
+        t0 : double
+            Initial time of the evolution.
+        """
+        _time_start = time()
+        self._integrator.set_state(t0, self._prepare_state(state0))
+        self.stats["preparation time"] += time() - _time_start
+
+    def step(self, t, *, args=None, copy=True):
+        """
+        Evolve the state to ``t`` and return the state as a :class:`Qobj`.
+
+        Parameters
+        ----------
+        t : double
+            Time to evolve to, must be higher than the last call.
+
+        args : dict, optional {None}
+            Update the ``args`` of the system.
+            The change is effective from the beginning of the interval.
+            Changing ``args`` can slow the evolution.
+
+        copy : bool, optional {True}
+            Whether to return a copy of the data or the data in the ODE solver.
+
+        .. note::
+            The state must be initialized first by calling ``start`` or
+            ``run``. If ``run`` is called, ``step`` will continue from the last
+            time and state obtained.
+        """
+        if not self._integrator._is_set:
+            raise RuntimeError("The `start` method must called first")
+        _time_start = time()
+        self._argument(args)
+        _, state = self._integrator.integrate(t, copy=False)
+        self.stats["run time"] += time() - _time_start
+        return self._restore_state(state, copy=copy)
+
+    def _get_integrator(self):
+        """ Return the initialted integrator. """
+        _time_start = time()
+        method = self._options["method"]
+        if method in self.avail_integrators():
+            integrator = self.avail_integrators()[method]
+        elif issubclass(method, Integrator):
+            integrator = method
+        else:
+            raise ValueError("Integrator method not supported.")
+        integrator_instance = integrator(self.rhs, self.options)
+        self._init_integrator_time = time() - _time_start
+        return integrator_instance
+
+    @property
+    def sys_dims(self):
+        """
+        Dimensions of the space that the system use:
+
+        ``qutip.basis(sovler.dims)`` will create a state with proper dimensions
+        for this solver.
+        """
+        return self.rhs.dims[0]
+
+    @property
+    def options(self):
+        """
+        method: str
+            Which ordinary differential equation integration method to use.
+        """
+        return self._options
+
+    def _parse_options(self, new_options, default, old_options):
+        """
+        Do a first read through of the options:
+        - Split new options' items included in the default from those that are
+          not.
+        - Replace ``None`` with the default value.
+        - Remove items that are unchanged.
+        """
+        included_options = {
+            key: val
+            for key, val in new_options.items()
+            if key in default
+        }
+        extra_options = {
+            key: val
+            for key, val in new_options.items()
+            if key not in default
+        }
+
+        # First pass: Have ``None`` refert to the default.
+        included_options = {
+            key: (val if val is not None else default[key])
+            for key, val in included_options.items()
+        }
+        # Second pass: Remove options that remain unchanged.
+        included_options = {
+            key: val
+            for key, val in included_options.items()
+            if not (key in old_options and val == old_options[key])
+        }
+        return included_options, extra_options
+
+    @options.setter
+    def options(self, new_options):
+        if not hasattr(self, "_options"):
+            self._options = {}
+        if new_options is None:
+            new_options = {}
+        if not isinstance(new_options, dict):
+            raise TypeError("options most to be a dictionary.")
+        new_solver_options, new_ode_options = self._parse_options(
+            new_options, self.solver_options, self.options
+        )
+        method = new_solver_options.get(
+            "method", self.options.get("method", self.solver_options["method"])
+        )
+        integrator = self.avail_integrators()[method]
+
+        if method == self.options.get("method", None):
+            # If method changed, drop old ode options
+            old_ode_options = self.options
+            old_options = self._options
+        else:
+            old_ode_options = {}
+            old_options, _ = self._parse_options(
+                self._options, self.solver_options, {}
+            )
+
+        new_ode_options, extra_options = self._parse_options(
+            new_ode_options, integrator.integrator_options, self.options
+        )
+        if extra_options:
+            raise KeyError(f"Options {extra_options.keys()} are not supported")
+        if self._options and not (new_solver_options or new_ode_options):
+            return  # Nothing to do
+
+        self._options = _SolverOptions(
+            {**self.solver_options, **integrator.integrator_options},
+            self._apply_options,
+            self.name + " with " + integrator.method + " integrator",
+            self.__class__.options.__doc__ + integrator.options.__doc__,
+            **{**old_options, **new_solver_options, **new_ode_options}
+        )
+
+        self._apply_options(set(new_options.keys()))
+
+    def _apply_options(self, keys):
+        """
+        Method called when options are changed, either through
+        ``solver.options[key] = value`` or ``solver.options = options``.
+        Allow to update the solver with the new options
+        """
+        from_setter = isinstance(keys, (set))
+        if not from_setter:
+            keys = set([keys])
+
+        if not from_setter and "method" in keys:
+            # Drop the ode's options.
+            old_solver_options, _ = self._parse_options(
+                self.options, self.solver_options, {}
+            )
+            method = self.options["method"]
+            integrator = self.avail_integrators()[method]
+
+            self._options = _SolverOptions(
+                {**self.solver_options, **integrator.integrator_options},
+                self._apply_options,
+                self.name + " with " + integrator.method + " integrator",
+                self.__class__.options.__doc__ + integrator.options.__doc__,
+                **old_solver_options
+            )
+
+        if self._integrator is None or not keys:
+            pass
+        elif 'method' in keys and self._integrator._is_set:
+            state = self._integrator.get_state()
+            self._integrator = self._get_integrator()
+            self._integrator.set_state(*state)
+        elif "method" in keys:
+            self._integrator = self._get_integrator()
+        elif keys & self._integrator.integrator_options.keys():
+            # Some of the keys are used by the integrator.
+            self._integrator.options = self._options
+            self._integrator.reset(hard=True)
+
+    def _argument(self, args):
+        """Update the args, for the `rhs` and other operators."""
+        if args:
+            self.rhs.arguments(args)
+            self._integrator.arguments(args)
+
+    @classmethod
+    def avail_integrators(cls):
+        if cls is Solver:
+            return cls._avail_integrators.copy()
+        return {
+            **Solver.avail_integrators(),
+            **cls._avail_integrators,
+        }
+
+    @classmethod
+    def integrator(cls, key):
+        return cls.avail_integrators()[key]
+
+    @classmethod
+    def add_integrator(cls, integrator, key):
+        """
+        Register an integrator.
+
+        Parameters
+        ----------
+        integrator : Integrator
+            The ODE solver to register.
+
+        keys : list of str
+            Values of the method options that refer to this integrator.
+        """
+        if not issubclass(integrator, Integrator):
+            raise TypeError(f"The integrator {integrator} must be a subclass"
+                            " of `qutip.solver.Integrator`")
+
+        cls._avail_integrators[key] = integrator
diff --git a/qutip/solver/spectrum.py b/qutip/solver/spectrum.py
index a267ee6451..cb92e1f0e6 100644
--- a/qutip/solver/spectrum.py
+++ b/qutip/solver/spectrum.py
@@ -1,188 +1,188 @@
-__all__ = ['spectrum', 'spectrum_correlation_fft']
-
-import numpy as np
-import scipy.fftpack
-
-from .steadystate import steadystate
-from ..core import liouvillian, spre, expect
-from ..core import data as _data
-from qutip.settings import settings
-
-def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
-    r"""
-    Calculate the spectrum of the correlation function
-    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
-    i.e., the Fourier transform of the correlation function:
-
-    .. math::
-
-        S(\omega) = \int_{-\infty}^{\infty}
-        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
-        e^{-i\omega\tau} d\tau.
-
-    using the solver indicated by the `solver` parameter. Note: this spectrum
-    is only defined for stationary statistics (uses steady state rho0)
-
-    Parameters
-    ----------
-    H : :class:`qutip.qobj`
-        system Hamiltonian.
-    wlist : array_like
-        List of frequencies for :math:`\omega`.
-    c_ops : list
-        List of collapse operators.
-    a_op : Qobj
-        Operator A.
-    b_op : Qobj
-        Operator B.
-    solver : str
-        Choice of solver (`es` for exponential series and
-        `pi` for psuedo-inverse, `solve` for generic solver).
-
-    Returns
-    -------
-    spectrum : array
-        An array with spectrum :math:`S(\omega)` for the frequencies
-        specified in `wlist`.
-
-    """
-    if not H.issuper:
-        L = liouvillian(H, c_ops)
-    else:
-        L = H + sum([lindblad_dissipator(c) for c in c_ops])
-    if solver == "es":
-        return _spectrum_es(L, wlist, a_op, b_op)
-    elif solver in ["pi", "solve"]:
-        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
-    raise ValueError(
-        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
-    )
-
-
-def spectrum_correlation_fft(tlist, y, inverse=False):
-    """
-    Calculate the power spectrum corresponding to a two-time correlation
-    function using FFT.
-
-    Parameters
-    ----------
-    tlist : array_like
-        list/array of times :math:`t` which the correlation function is given.
-    y : array_like
-        list/array of correlations corresponding to time delays :math:`t`.
-    inverse: boolean
-        boolean parameter for using a positive exponent in the Fourier
-        Transform instead. Default is False.
-
-    Returns
-    -------
-    w, S : tuple
-        Returns an array of angular frequencies 'w' and the corresponding
-        two-sided power spectrum 'S(w)'.
-
-    """
-    tlist = np.asarray(tlist)
-    N = tlist.shape[0]
-    dt = tlist[1] - tlist[0]
-    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
-        raise ValueError('tlist must be equally spaced for FFT.')
-    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
-    # calculate the frequencies for the components in F
-    f = scipy.fftpack.fftfreq(N, dt)
-    # re-order frequencies from most negative to most positive (centre on 0)
-    idx = np.array([], dtype='int')
-    idx = np.append(idx, np.where(f < 0.0))
-    idx = np.append(idx, np.where(f >= 0.0))
-    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
-
-
-def _spectrum_es(L, wlist, a_op, b_op):
-    r"""
-    Internal function for calculating the spectrum of the correlation function
-    :math:`\left<A(\tau)B(0)\right>`.
-    """
-    # find the steady state density matrix and a_op and b_op expecation values
-    rho0 = steadystate(L)
-    a_op_ss = expect(a_op, rho0)
-    b_op_ss = expect(b_op, rho0)
-    # eseries solution for (b * rho0)(t)
-    states, rates = _diagonal_evolution(L, b_op * rho0)
-    # correlation
-    ampls = [_data.expect(a_op.data, state) for state in states]
-    # make covariance
-    ampls += [-a_op_ss * b_op_ss]
-    rates += [0]
-    # Tidy up similar rates.
-    order = np.argsort(rates)
-    clean_rates = []
-    clean_ampls = []
-    prev_rate = np.nan
-    for idx in order:
-        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
-            clean_ampls[-1] += ampls[idx]
-        else:
-            clean_rates.append(rates[idx])
-            clean_ampls.append(ampls[idx])
-            prev_rate = rates[idx]
-    # Remove 0 amplitude
-    rates, ampls = zip(*[
-        (rate, ampl)
-        for rate, ampl in zip(clean_rates, clean_ampls)
-        if np.abs(ampl) > settings.core["atol"]
-    ])
-    ampls, rates = np.array(ampls), np.array(rates)
-    LW = np.subtract.outer(1j * np.array(wlist), rates).T
-    return (ampls @ (2 / LW)).real
-
-
-#
-# pseudo-inverse solvers
-def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
-    r"""
-    Internal function for calculating the spectrum of the correlation function
-    :math:`\left<A(\tau)B(0)\right>`.
-    """
-    dtype = type(L.data)
-    rho_ss = steadystate(L)
-    tr_mat = _data.identity[dtype](rho_ss.shape[0])
-    tr_vec = _data.column_stack(tr_mat).transpose()
-    rho = _data.column_stack(rho_ss.data)
-
-    A = L.data
-    ket = spre(b_op).data @ rho
-    bra = tr_vec @ spre(a_op).data
-
-    I = _data.identity[dtype](L.shape[0])
-    P = _data.kron(rho, tr_vec)
-    Q = I - P
-
-    spectrum = np.zeros(len(wlist))
-    for idx, w in enumerate(wlist):
-        if use_pinv and np.abs(w) > settings.core["atol"]:
-            # At w == 0., "L - iw" is singular
-            MMR = _data.inv(-1.0j * w * I + A)
-        else:
-            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
-
-        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
-    return spectrum
-
-
-def _diagonal_evolution(L, rho0, sparse=False):
-    if rho0.norm() < settings.core["atol"]:
-        return [_data.zeros["CSR"](*rho0.shape)], [0]
-    if isinstance(L.data, _data.CSR) and not sparse:
-        L = L.to(_data.Dense)
-    evals, evecs = _data.eigs(L.data)
-    size = rho0.shape[0] * rho0.shape[1]
-    r0 = _data.column_stack(rho0.data)
-    v0 = _data.solve(evecs, r0)
-    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
-    states = []
-    rates = []
-    for ket, rate in zip(_data.split_columns(vv), evals):
-        if _data.norm.l2(ket) < settings.core["atol"]:
-            continue
-        states.append(_data.column_unstack(ket, rho0.shape[0]))
-        rates.append(rate)
-    return states, rates
+__all__ = ['spectrum', 'spectrum_correlation_fft']
+
+import numpy as np
+import scipy.fftpack
+
+from .steadystate import steadystate
+from ..core import liouvillian, spre, expect
+from ..core import data as _data
+from qutip.settings import settings
+
+def spectrum(H, wlist, c_ops, a_op, b_op, solver="es"):
+    r"""
+    Calculate the spectrum of the correlation function
+    :math:`\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>`,
+    i.e., the Fourier transform of the correlation function:
+
+    .. math::
+
+        S(\omega) = \int_{-\infty}^{\infty}
+        \lim_{t \to \infty} \left<A(t+\tau)B(t)\right>
+        e^{-i\omega\tau} d\tau.
+
+    using the solver indicated by the `solver` parameter. Note: this spectrum
+    is only defined for stationary statistics (uses steady state rho0)
+
+    Parameters
+    ----------
+    H : :class:`qutip.qobj`
+        system Hamiltonian.
+    wlist : array_like
+        List of frequencies for :math:`\omega`.
+    c_ops : list
+        List of collapse operators.
+    a_op : Qobj
+        Operator A.
+    b_op : Qobj
+        Operator B.
+    solver : str
+        Choice of solver (`es` for exponential series and
+        `pi` for psuedo-inverse, `solve` for generic solver).
+
+    Returns
+    -------
+    spectrum : array
+        An array with spectrum :math:`S(\omega)` for the frequencies
+        specified in `wlist`.
+
+    """
+    if not H.issuper:
+        L = liouvillian(H, c_ops)
+    else:
+        L = H + sum([lindblad_dissipator(c) for c in c_ops])
+    if solver == "es":
+        return _spectrum_es(L, wlist, a_op, b_op)
+    elif solver in ["pi", "solve"]:
+        return _spectrum_pi(L, wlist, a_op, b_op, use_pinv=solver=="pi")
+    raise ValueError(
+        f"Unrecognized choice of solver {solver} (use 'es', 'pi' or 'solve')."
+    )
+
+
+def spectrum_correlation_fft(tlist, y, inverse=False):
+    """
+    Calculate the power spectrum corresponding to a two-time correlation
+    function using FFT.
+
+    Parameters
+    ----------
+    tlist : array_like
+        list/array of times :math:`t` which the correlation function is given.
+    y : array_like
+        list/array of correlations corresponding to time delays :math:`t`.
+    inverse: boolean
+        boolean parameter for using a positive exponent in the Fourier
+        Transform instead. Default is False.
+
+    Returns
+    -------
+    w, S : tuple
+        Returns an array of angular frequencies 'w' and the corresponding
+        two-sided power spectrum 'S(w)'.
+
+    """
+    tlist = np.asarray(tlist)
+    N = tlist.shape[0]
+    dt = tlist[1] - tlist[0]
+    if not np.allclose(np.diff(tlist), dt * np.ones(N - 1, dtype=float)):
+        raise ValueError('tlist must be equally spaced for FFT.')
+    F = (N * scipy.fftpack.ifft(y)) if inverse else scipy.fftpack.fft(y)
+    # calculate the frequencies for the components in F
+    f = scipy.fftpack.fftfreq(N, dt)
+    # re-order frequencies from most negative to most positive (centre on 0)
+    idx = np.array([], dtype='int')
+    idx = np.append(idx, np.where(f < 0.0))
+    idx = np.append(idx, np.where(f >= 0.0))
+    return 2 * np.pi * f[idx], 2 * dt * np.real(F[idx])
+
+
+def _spectrum_es(L, wlist, a_op, b_op):
+    r"""
+    Internal function for calculating the spectrum of the correlation function
+    :math:`\left<A(\tau)B(0)\right>`.
+    """
+    # find the steady state density matrix and a_op and b_op expecation values
+    rho0 = steadystate(L)
+    a_op_ss = expect(a_op, rho0)
+    b_op_ss = expect(b_op, rho0)
+    # eseries solution for (b * rho0)(t)
+    states, rates = _diagonal_evolution(L, b_op * rho0)
+    # correlation
+    ampls = [_data.expect(a_op.data, state) for state in states]
+    # make covariance
+    ampls += [-a_op_ss * b_op_ss]
+    rates += [0]
+    # Tidy up similar rates.
+    order = np.argsort(rates)
+    clean_rates = []
+    clean_ampls = []
+    prev_rate = np.nan
+    for idx in order:
+        if np.abs(rates[idx] - prev_rate) < settings.core["atol"]:
+            clean_ampls[-1] += ampls[idx]
+        else:
+            clean_rates.append(rates[idx])
+            clean_ampls.append(ampls[idx])
+            prev_rate = rates[idx]
+    # Remove 0 amplitude
+    rates, ampls = zip(*[
+        (rate, ampl)
+        for rate, ampl in zip(clean_rates, clean_ampls)
+        if np.abs(ampl) > settings.core["atol"]
+    ])
+    ampls, rates = np.array(ampls), np.array(rates)
+    LW = np.subtract.outer(1j * np.array(wlist), rates).T
+    return (ampls @ (2 / LW)).real
+
+
+#
+# pseudo-inverse solvers
+def _spectrum_pi(L, wlist, a_op, b_op, use_pinv=False):
+    r"""
+    Internal function for calculating the spectrum of the correlation function
+    :math:`\left<A(\tau)B(0)\right>`.
+    """
+    dtype = type(L.data)
+    rho_ss = steadystate(L)
+    tr_mat = _data.identity[dtype](rho_ss.shape[0])
+    tr_vec = _data.column_stack(tr_mat).transpose()
+    rho = _data.column_stack(rho_ss.data)
+
+    A = L.data
+    ket = spre(b_op).data @ rho
+    bra = tr_vec @ spre(a_op).data
+
+    I = _data.identity[dtype](L.shape[0])
+    P = _data.kron(rho, tr_vec)
+    Q = I - P
+
+    spectrum = np.zeros(len(wlist))
+    for idx, w in enumerate(wlist):
+        if use_pinv and np.abs(w) > settings.core["atol"]:
+            # At w == 0., "L - iw" is singular
+            MMR = _data.inv(-1.0j * w * I + A)
+        else:
+            MMR = Q @ _data.solve(-1.0j * w * I + A, Q)
+
+        spectrum[idx] = -2 * _data.inner_op(bra, MMR, ket).real
+    return spectrum
+
+
+def _diagonal_evolution(L, rho0, sparse=False):
+    if rho0.norm() < settings.core["atol"]:
+        return [_data.zeros["CSR"](*rho0.shape)], [0]
+    if isinstance(L.data, _data.CSR) and not sparse:
+        L = L.to(_data.Dense)
+    evals, evecs = _data.eigs(L.data)
+    size = rho0.shape[0] * rho0.shape[1]
+    r0 = _data.column_stack(rho0.data)
+    v0 = _data.solve(evecs, r0)
+    vv = evecs @ _data.diag(v0.to_array().flatten(), [0])
+    states = []
+    rates = []
+    for ket, rate in zip(_data.split_columns(vv), evals):
+        if _data.norm.l2(ket) < settings.core["atol"]:
+            continue
+        states.append(_data.column_unstack(ket, rho0.shape[0]))
+        rates.append(rate)
+    return states, rates
diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
index 71efa268b1..f576c9f2bb 100644
--- a/qutip/solver/steadystate.py
+++ b/qutip/solver/steadystate.py
@@ -1,537 +1,537 @@
-from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
-from qutip import vector_to_operator, operator_to_vector
-from qutip import settings
-import qutip.core.data as _data
-import numpy as np
-import scipy.sparse.csgraph
-import scipy.sparse.linalg
-from warnings import warn
-
-
-__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
-
-
-def _permute_wbm(L, b):
-    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
-    L = _data.permute.indices(L, perm, None)
-    b = _data.permute.indices(b, perm, None)
-    return L, b
-
-
-def _permute_rcm(L, b):
-    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
-    L = _data.permute.indices(L, perm, perm)
-    b = _data.permute.indices(b, perm, None)
-    return L, b, perm
-
-
-def _reverse_rcm(rho, perm):
-    rev_perm = np.argsort(perm)
-    rho = _data.permute.indices(rho, rev_perm, None)
-    return rho
-
-
-def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
-    """
-    Calculates the steady state for quantum evolution subject to the supplied
-    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
-    collapse operators.
-
-    If the user passes a Hamiltonian then it, along with the list of collapse
-    operators, will be converted into a Liouvillian operator in Lindblad form.
-
-    Parameters
-    ----------
-    A : :obj:`~Qobj`
-        A Hamiltonian or Liouvillian operator.
-
-    c_op_list : list
-        A list of collapse operators.
-
-    method : str, default='direct'
-        The allowed methods are composed of 2 parts, the steadystate method:
-        - "direct": Solving ``L(rho_ss) = 0``
-        - "eigen" : Eigenvalue problem
-        - "svd" : Singular value decomposition
-        - "power" : Inverse-power method
-
-    solver : str, default=None
-        'direct' and 'power' methods only.
-        Solver to use when solving the ``L(rho_ss) = 0`` equation.
-        Default supported solver are:
-
-        - "solve", "lstsq"
-          dense solver from numpy.linalg
-        - "spsolve", "gmres", "lgmres", "bicgstab"
-          sparse solver from scipy.sparse.linalg
-        - "mkl_spsolve"
-          sparse solver by mkl.
-
-        Extension to qutip, such as qutip-tensorflow, can use come with their
-        own solver. When ``A`` and ``c_ops`` use these data backends, see the
-        corresponding libraries ``linalg`` for available solver.
-
-        Extra options for these solver can be passed in ``**kw``.
-
-    use_rcm : bool, default False
-        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
-        factorization of the Liouvillian.
-        Used with 'direct' or 'power' method.
-
-    use_wbm : bool, default False
-        Use Weighted Bipartite Matching reordering to make the Liouvillian
-        diagonally dominant.  This is useful for iterative preconditioners
-        only. Used with 'direct' or 'power' method.
-
-    weight : float, optional
-        Sets the size of the elements used for adding the unity trace condition
-        to the linear solvers.  This is set to the average abs value of the
-        Liouvillian elements if not specified by the user.
-        Used with 'direct' method.
-
-    power_tol : float, default 1e-12
-        Tolerance for the solution when using the 'power' method.
-
-    power_maxiter : int, default 10
-        Maximum number of iteration to use when looking for a solution when
-        using the 'power' method.
-
-    power_eps: double, default 1e-15
-        Small weight used in the "power" method.
-
-    sparse: bool
-        Whether to use the sparse eigen solver with the "eigen" method
-        (default sparse).  With "direct" and "power" method, when the solver is
-        not specified, it is used to set whether "solve" or "spsolve" is
-        used as default solver.
-
-    **kwargs :
-        Extra options to pass to the linear system solver. See the
-        documentation of the used solver in ``numpy.linalg`` or
-        ``scipy.sparse.linalg`` to see what extra arguments are supported.
-
-    Returns
-    -------
-    dm : qobj
-        Steady state density matrix.
-    info : dict, optional
-        Dictionary containing solver-specific information about the solution.
-
-    .. note::
-
-        The SVD method works only for dense operators (i.e. small systems).
-
-    """
-    if not A.issuper and not c_ops:
-        raise TypeError('Cannot calculate the steady state for a ' +
-                        'non-dissipative system.')
-    if not A.issuper:
-        A = liouvillian(A)
-    for op in c_ops:
-        A += lindblad_dissipator(op)
-
-    if "-" in method:
-        # to support v4's "power-gmres" method
-        method, solver = method.split("-")
-
-    if solver == "mkl":
-        solver = "mkl_spsolve"
-
-    # Keys supported in v4, but removed in v5
-    if kwargs.pop("return_info", False):
-        warn("Steadystate no longer supports return_info", DeprecationWarning)
-    if "mtol" in kwargs and "power_tol" not in kwargs:
-        kwargs["power_tol"] = kwargs["mtol"]
-    kwargs.pop("mtol", None)
-
-    if method == "eigen":
-        return _steadystate_eigen(A, **kwargs)
-    if method == "svd":
-        return _steadystate_svd(A, **kwargs)
-
-    # We want to be able to use this without having to know what data type the
-    # liouvillian uses. For extra data types (tensorflow) we can expect
-    # the users to know they are using them and choose an appropriate solver
-    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
-    if not isinstance(A.data, (_data.CSR, _data.Dense)):
-        # Tensorflow, jax, etc. data type
-        pass
-    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
-        A = A.to("dense")
-    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
-        A = A.to("csr")
-    elif solver is None and kwargs.get("sparse", False):
-        A = A.to("csr")
-        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
-    elif solver is None and (kwargs.get("sparse", None) is False):
-        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
-        A = A.to("dense")
-        solver = "solve"
-
-    if method in ["direct", "iterative"]:
-        # Remove unused kwargs, so only used and pass-through ones are included
-        kwargs.pop("power_tol", 0)
-        kwargs.pop("power_maxiter", 0)
-        kwargs.pop("power_eps", 0)
-        kwargs.pop("sparse", 0)
-        return _steadystate_direct(A, kwargs.pop("weight", 0),
-                                   method=solver, **kwargs)
-
-    elif method == "power":
-        # Remove unused kwargs, so only used and pass-through ones are included
-        kwargs.pop("weight", 0)
-        kwargs.pop("sparse", 0)
-        return _steadystate_power(A, method=solver, **kwargs)
-    else:
-        raise ValueError(f"method {method} not supported.")
-
-
-def _steadystate_direct(A, weight, **kw):
-    # Find the weight, no good dispatched function available...
-    if weight:
-        pass
-    elif isinstance(A.data, _data.CSR):
-        weight = np.mean(np.abs(A.data.as_scipy().data))
-    else:
-        A_np = np.abs(A.full())
-        weight = np.mean(A_np[A_np > 0])
-
-    # Add weight to the Liouvillian
-    # A[:, 0] = vectorized(eye * weight)
-    # We don't have a function to overwrite part of an array, so
-    N = A.shape[0]
-    n = int(N**0.5)
-    dtype = type(A.data)
-    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
-    weight_mat = _data.kron(
-        weight_vec.transpose(),
-        _data.one_element[dtype]((N, 1), (0, 0), 1)
-    )
-    L = _data.add(weight_mat, A.data)
-    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
-
-    # Permutation are part of scipy.sparse, thus only supported for CSR.
-    if kw.pop("use_wbm", False):
-        if isinstance(L, _data.CSR):
-            L, b = _permute_wbm(L, b)
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    use_rcm = False
-    if kw.pop("use_rcm", False):
-        if isinstance(L, _data.CSR):
-            L, b, perm = _permute_rcm(L, b)
-            use_rcm = True
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    if kw.pop("use_precond", False):
-        if isinstance(L, _data.CSR):
-            kw["M"] = _compute_precond(L, kw)
-        else:
-            warn("Only sparse solver use preconditioners.", RuntimeWarning)
-
-
-    method = kw.pop("method", None)
-    steadystate = _data.solve(L, b, method, options=kw)
-
-    if use_rcm:
-        steadystate = _reverse_rcm(steadystate, perm)
-
-    rho_ss = _data.column_unstack(steadystate, n)
-    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
-
-    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
-
-
-def _steadystate_eigen(L, **kw):
-    val, vec = (L.dag() @ L).eigenstates(
-        eigvals=1,
-        sort="low",
-        # v4's implementation only uses sparse eigen solver
-        sparse=kw.pop("sparse", True)
-    )
-    rho = vector_to_operator(vec[0])
-    return rho / rho.tr()
-
-
-def _steadystate_svd(L, **kw):
-    u, s, vh = _data.svd(L.data, True)
-    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
-    rho = vector_to_operator(vec)
-    return rho / rho.tr()
-
-
-def _steadystate_power(A, **kw):
-    A += kw.pop("power_eps", 1e-15)
-    L = A.data
-    N = L.shape[1]
-    y = _data.Dense([1]*N)
-
-    # Permutation are part of scipy.sparse, thus only supported for CSR.
-    if kw.pop("use_wbm", False):
-        if isinstance(L, _data.CSR):
-            L, y = _permute_wbm(L, y)
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    use_rcm = False
-    if kw.pop("use_rcm", False):
-        if isinstance(L, _data.CSR):
-            L, y, perm = _permute_rcm(L, y)
-            use_rcm = True
-        else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
-    if kw.pop("use_precond", False):
-        if isinstance(L, _data.CSR):
-            kw["M"] = _compute_precond(L, kw)
-        else:
-            warn("Only sparse solver use preconditioners.", RuntimeWarning)
-
-    it = 0
-    maxiter = kw.pop("power_maxiter", 10)
-    tol = kw.pop("power_tol", 1e-12)
-    method = kw.pop("method", None)
-    while it < maxiter and _data.norm.max(L @ y) > tol:
-        y = _data.solve(L, y, method, options=kw)
-        y = y / _data.norm.max(y)
-        it += 1
-
-    if it >= maxiter:
-        raise Exception('Failed to find steady state after ' +
-                        str(maxiter) + ' iterations')
-
-    if use_rcm:
-        y = _reverse_rcm(y, perm)
-
-    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
-    rho_ss = rho_ss + rho_ss.dag()
-    rho_ss = rho_ss / rho_ss.tr()
-    rho_ss.isherm = True
-    return rho_ss
-
-
-def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
-                        solver=None, **kwargs):
-    """
-    Calculates the effective steady state for a driven
-     system with a time-dependent cosinusoidal term:
-
-    .. math::
-
-        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
-         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
-
-    Parameters
-    ----------
-    H_0 : :obj:`~Qobj`
-        A Hamiltonian or Liouvillian operator.
-
-    c_ops : list
-        A list of collapse operators.
-
-    Op_t : :obj:`~Qobj`
-        The the interaction operator which is multiplied by the cosine
-
-    w_d : float, default 1.0
-        The frequency of the drive
-
-    n_it : int, default 3
-        The number of iterations for the solver
-
-    sparse : bool, default False
-        Solve for the steady state using sparse algorithms.
-
-    solver : str, default=None
-        Solver to use when solving the linear system.
-        Default supported solver are:
-
-        - "solve", "lstsq"
-          dense solver from numpy.linalg
-        - "spsolve", "gmres", "lgmres", "bicgstab"
-          sparse solver from scipy.sparse.linalg
-        - "mkl_spsolve"
-          sparse solver by mkl.
-
-        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
-        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
-        for the names and details of additional solvers they may provide.
-
-    **kwargs:
-        Extra options to pass to the linear system solver. See the
-        documentation of the used solver in ``numpy.linalg`` or
-        ``scipy.sparse.linalg`` to see what extra arguments are supported.
-
-    Returns
-    -------
-    dm : qobj
-        Steady state density matrix.
-
-    .. note::
-
-        See: Sze Meng Tan,
-        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
-        Section (10.16)
-
-    """
-
-    L_0 = liouvillian(H_0, c_ops)
-    L_m = L_p = 0.5 * liouvillian(Op_t)
-    # L_p and L_m correspond to the positive and negative
-    # frequency terms respectively.
-    # They are independent in the model, so we keep both names.
-    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
-    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
-
-    if isinstance(H_0.data, _data.CSR) and not sparse:
-        L_0 = L_0.to("Dense")
-        L_m = L_m.to("Dense")
-        L_p = L_p.to("Dense")
-        Id = Id.to("Dense")
-
-    for n_i in np.arange(n_it, 0, -1):
-        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
-        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
-        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
-        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
-
-    M_subs = L_0 + L_m @ S + L_p @ T
-    return steadystate(M_subs, solver=solver, **kwargs)
-
-
-def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
-                   **kwargs):
-    """
-    Compute the pseudo inverse for a Liouvillian superoperator, optionally
-    given its steady state density matrix (which will be computed if not
-    given).
-
-    Parameters
-    ----------
-    L : Qobj
-        A Liouvillian superoperator for which to compute the pseudo inverse.
-
-    rhoss : Qobj
-        A steadystate density matrix as Qobj instance, for the Liouvillian
-        superoperator L.
-
-    w : double
-        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
-        systems and large sparse systems. Small sparse systems can fail for
-        zero frequencies.
-
-    sparse : bool
-        Flag that indicate whether to use sparse or dense matrix methods when
-        computing the pseudo inverse.
-
-    method : string
-        Method used to compte matrix inverse.
-        Choice are 'pinv' to use scipy's function of the same name, or a linear
-        system solver.
-        Default supported solver are:
-
-        - "solve", "lstsq"
-          dense solver from numpy.linalg
-        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
-          sparse solver from scipy.sparse.linalg
-        - "mkl_spsolve",
-          sparse solver by mkl.
-
-        Extension to qutip, such as qutip-tensorflow, can use come with their
-        own solver. When ``L`` use these data backends, see the corresponding
-        libraries ``linalg`` for available solver.
-
-    kwargs : dictionary
-        Additional keyword arguments for setting parameters for solver methods.
-
-    Returns
-    -------
-    R : Qobj
-        Returns a Qobj instance representing the pseudo inverse of L.
-
-    .. note::
-
-        In general the inverse of a sparse matrix will be dense.  If you
-        are applying the inverse to a density matrix then it is better to
-        cast the problem as an Ax=b type problem where the explicit calculation
-        of the inverse is not required. See page 67 of "Electrons in
-        nanostructures" C. Flindt, PhD Thesis available online:
-        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
-        file_4732600/content
-
-        Note also that the definition of the pseudo-inverse herein is different
-        from numpys pinv() alone, as it includes pre and post projection onto
-        the subspace defined by the projector Q.
-
-    """
-    if rhoss is None:
-        rhoss = steadystate(L)
-
-    sparse = kwargs.pop("sparse", False)
-    if method == "direct":
-        method = "splu" if sparse else "pinv"
-    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
-    dense_solvers = ["solve", "lstsq", "pinv"]
-    if isinstance(L.data, _data.CSR) and method in dense_solvers:
-        L = L.to("dense")
-    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
-        L = L.to("csr")
-
-    N = np.prod(L.dims[0][0])
-    dtype = type(L.data)
-    rhoss_vec = operator_to_vector(rhoss)
-
-    tr_op = qeye(L.dims[0][0])
-    tr_op_vec = operator_to_vector(tr_op)
-
-    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
-    I = _data.csr.identity(N * N)
-    Q = _data.sub(I, P)
-
-    if w in [None, 0.0]:
-        L += 1e-15j
-    else:
-        L += 1.0j*w
-
-    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
-
-    if use_rcm:
-        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
-        A = _data.permute.indices(L.data, perm, perm)
-        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
-    else:
-        A = L.data
-
-    if method in ["pinv", "numpy", "scipy", "scipy2"]:
-        # from scipy 1.7.0, they all use the same algorithm.
-        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
-        LIQ = _data.matmul(LI, Q)
-    elif method == "spilu":
-        if not isinstance(A, _data.CSR):
-            raise TypeError("'spilu' method can only be used with sparse data")
-        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
-        LIQ = _data.Dense(ILU.solve(Q.to_array()))
-    else:
-        LIQ = _data.solve(A, Q, method, options=kwargs)
-
-    R = _data.matmul(Q, LIQ)
-
-    if use_rcm:
-        rev_perm = np.argsort(perm)
-        R = _data.permute.indices(R, rev_perm, rev_perm)
-
-    return Qobj(R, dims=L.dims)
-
-
-def _compute_precond(L, args):
-    spilu_keys = {
-        'permc_spec',
-        'drop_tol',
-        'diag_pivot_thresh',
-        'fill_factor',
-        'options',
-    }
-    ss_args = {
-        key: args.pop(key)
-        for key in spilu_keys
-        if key in args
-    }
-    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
-    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
+from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
+from qutip import vector_to_operator, operator_to_vector
+from qutip import settings
+import qutip.core.data as _data
+import numpy as np
+import scipy.sparse.csgraph
+import scipy.sparse.linalg
+from warnings import warn
+
+
+__all__ = ["steadystate", "steadystate_floquet", "pseudo_inverse"]
+
+
+def _permute_wbm(L, b):
+    perm = scipy.sparse.csgraph.maximum_bipartite_matching(L.as_scipy())
+    L = _data.permute.indices(L, perm, None)
+    b = _data.permute.indices(b, perm, None)
+    return L, b
+
+
+def _permute_rcm(L, b):
+    perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.as_scipy())
+    L = _data.permute.indices(L, perm, perm)
+    b = _data.permute.indices(b, perm, None)
+    return L, b, perm
+
+
+def _reverse_rcm(rho, perm):
+    rev_perm = np.argsort(perm)
+    rho = _data.permute.indices(rho, rev_perm, None)
+    return rho
+
+
+def steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs):
+    """
+    Calculates the steady state for quantum evolution subject to the supplied
+    Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of
+    collapse operators.
+
+    If the user passes a Hamiltonian then it, along with the list of collapse
+    operators, will be converted into a Liouvillian operator in Lindblad form.
+
+    Parameters
+    ----------
+    A : :obj:`~Qobj`
+        A Hamiltonian or Liouvillian operator.
+
+    c_op_list : list
+        A list of collapse operators.
+
+    method : str, default='direct'
+        The allowed methods are composed of 2 parts, the steadystate method:
+        - "direct": Solving ``L(rho_ss) = 0``
+        - "eigen" : Eigenvalue problem
+        - "svd" : Singular value decomposition
+        - "power" : Inverse-power method
+
+    solver : str, default=None
+        'direct' and 'power' methods only.
+        Solver to use when solving the ``L(rho_ss) = 0`` equation.
+        Default supported solver are:
+
+        - "solve", "lstsq"
+          dense solver from numpy.linalg
+        - "spsolve", "gmres", "lgmres", "bicgstab"
+          sparse solver from scipy.sparse.linalg
+        - "mkl_spsolve"
+          sparse solver by mkl.
+
+        Extension to qutip, such as qutip-tensorflow, can use come with their
+        own solver. When ``A`` and ``c_ops`` use these data backends, see the
+        corresponding libraries ``linalg`` for available solver.
+
+        Extra options for these solver can be passed in ``**kw``.
+
+    use_rcm : bool, default False
+        Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU
+        factorization of the Liouvillian.
+        Used with 'direct' or 'power' method.
+
+    use_wbm : bool, default False
+        Use Weighted Bipartite Matching reordering to make the Liouvillian
+        diagonally dominant.  This is useful for iterative preconditioners
+        only. Used with 'direct' or 'power' method.
+
+    weight : float, optional
+        Sets the size of the elements used for adding the unity trace condition
+        to the linear solvers.  This is set to the average abs value of the
+        Liouvillian elements if not specified by the user.
+        Used with 'direct' method.
+
+    power_tol : float, default 1e-12
+        Tolerance for the solution when using the 'power' method.
+
+    power_maxiter : int, default 10
+        Maximum number of iteration to use when looking for a solution when
+        using the 'power' method.
+
+    power_eps: double, default 1e-15
+        Small weight used in the "power" method.
+
+    sparse: bool
+        Whether to use the sparse eigen solver with the "eigen" method
+        (default sparse).  With "direct" and "power" method, when the solver is
+        not specified, it is used to set whether "solve" or "spsolve" is
+        used as default solver.
+
+    **kwargs :
+        Extra options to pass to the linear system solver. See the
+        documentation of the used solver in ``numpy.linalg`` or
+        ``scipy.sparse.linalg`` to see what extra arguments are supported.
+
+    Returns
+    -------
+    dm : qobj
+        Steady state density matrix.
+    info : dict, optional
+        Dictionary containing solver-specific information about the solution.
+
+    .. note::
+
+        The SVD method works only for dense operators (i.e. small systems).
+
+    """
+    if not A.issuper and not c_ops:
+        raise TypeError('Cannot calculate the steady state for a ' +
+                        'non-dissipative system.')
+    if not A.issuper:
+        A = liouvillian(A)
+    for op in c_ops:
+        A += lindblad_dissipator(op)
+
+    if "-" in method:
+        # to support v4's "power-gmres" method
+        method, solver = method.split("-")
+
+    if solver == "mkl":
+        solver = "mkl_spsolve"
+
+    # Keys supported in v4, but removed in v5
+    if kwargs.pop("return_info", False):
+        warn("Steadystate no longer supports return_info", DeprecationWarning)
+    if "mtol" in kwargs and "power_tol" not in kwargs:
+        kwargs["power_tol"] = kwargs["mtol"]
+    kwargs.pop("mtol", None)
+
+    if method == "eigen":
+        return _steadystate_eigen(A, **kwargs)
+    if method == "svd":
+        return _steadystate_svd(A, **kwargs)
+
+    # We want to be able to use this without having to know what data type the
+    # liouvillian uses. For extra data types (tensorflow) we can expect
+    # the users to know they are using them and choose an appropriate solver
+    sparse_solvers = ["spsolve", "mkl_spsolve", "gmres", "lgmres", "bicgstab"]
+    if not isinstance(A.data, (_data.CSR, _data.Dense)):
+        # Tensorflow, jax, etc. data type
+        pass
+    elif isinstance(A.data, _data.CSR) and solver in ["solve", "lstsq"]:
+        A = A.to("dense")
+    elif isinstance(A.data, _data.Dense) and solver in sparse_solvers:
+        A = A.to("csr")
+    elif solver is None and kwargs.get("sparse", False):
+        A = A.to("csr")
+        solver = "mkl_spsolve" if settings.has_mkl else "spsolve"
+    elif solver is None and (kwargs.get("sparse", None) is False):
+        # sparse is explicitly set to false, v4 tag to use `numpy.linalg.solve`
+        A = A.to("dense")
+        solver = "solve"
+
+    if method in ["direct", "iterative"]:
+        # Remove unused kwargs, so only used and pass-through ones are included
+        kwargs.pop("power_tol", 0)
+        kwargs.pop("power_maxiter", 0)
+        kwargs.pop("power_eps", 0)
+        kwargs.pop("sparse", 0)
+        return _steadystate_direct(A, kwargs.pop("weight", 0),
+                                   method=solver, **kwargs)
+
+    elif method == "power":
+        # Remove unused kwargs, so only used and pass-through ones are included
+        kwargs.pop("weight", 0)
+        kwargs.pop("sparse", 0)
+        return _steadystate_power(A, method=solver, **kwargs)
+    else:
+        raise ValueError(f"method {method} not supported.")
+
+
+def _steadystate_direct(A, weight, **kw):
+    # Find the weight, no good dispatched function available...
+    if weight:
+        pass
+    elif isinstance(A.data, _data.CSR):
+        weight = np.mean(np.abs(A.data.as_scipy().data))
+    else:
+        A_np = np.abs(A.full())
+        weight = np.mean(A_np[A_np > 0])
+
+    # Add weight to the Liouvillian
+    # A[:, 0] = vectorized(eye * weight)
+    # We don't have a function to overwrite part of an array, so
+    N = A.shape[0]
+    n = int(N**0.5)
+    dtype = type(A.data)
+    weight_vec = _data.column_stack(_data.diag([weight] * n, 0, dtype=dtype))
+    weight_mat = _data.kron(
+        weight_vec.transpose(),
+        _data.one_element[dtype]((N, 1), (0, 0), 1)
+    )
+    L = _data.add(weight_mat, A.data)
+    b = _data.one_element[dtype]((N, 1), (0, 0), weight)
+
+    # Permutation are part of scipy.sparse, thus only supported for CSR.
+    if kw.pop("use_wbm", False):
+        if isinstance(L, _data.CSR):
+            L, b = _permute_wbm(L, b)
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    use_rcm = False
+    if kw.pop("use_rcm", False):
+        if isinstance(L, _data.CSR):
+            L, b, perm = _permute_rcm(L, b)
+            use_rcm = True
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    if kw.pop("use_precond", False):
+        if isinstance(L, _data.CSR):
+            kw["M"] = _compute_precond(L, kw)
+        else:
+            warn("Only sparse solver use preconditioners.", RuntimeWarning)
+
+
+    method = kw.pop("method", None)
+    steadystate = _data.solve(L, b, method, options=kw)
+
+    if use_rcm:
+        steadystate = _reverse_rcm(steadystate, perm)
+
+    rho_ss = _data.column_unstack(steadystate, n)
+    rho_ss = _data.add(rho_ss, rho_ss.adjoint()) * 0.5
+
+    return Qobj(rho_ss, dims=A.dims[0], isherm=True)
+
+
+def _steadystate_eigen(L, **kw):
+    val, vec = (L.dag() @ L).eigenstates(
+        eigvals=1,
+        sort="low",
+        # v4's implementation only uses sparse eigen solver
+        sparse=kw.pop("sparse", True)
+    )
+    rho = vector_to_operator(vec[0])
+    return rho / rho.tr()
+
+
+def _steadystate_svd(L, **kw):
+    u, s, vh = _data.svd(L.data, True)
+    vec = Qobj(_data.split_columns(vh.adjoint())[-1], dims=[L.dims[0],[1]])
+    rho = vector_to_operator(vec)
+    return rho / rho.tr()
+
+
+def _steadystate_power(A, **kw):
+    A += kw.pop("power_eps", 1e-15)
+    L = A.data
+    N = L.shape[1]
+    y = _data.Dense([1]*N)
+
+    # Permutation are part of scipy.sparse, thus only supported for CSR.
+    if kw.pop("use_wbm", False):
+        if isinstance(L, _data.CSR):
+            L, y = _permute_wbm(L, y)
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    use_rcm = False
+    if kw.pop("use_rcm", False):
+        if isinstance(L, _data.CSR):
+            L, y, perm = _permute_rcm(L, y)
+            use_rcm = True
+        else:
+            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+    if kw.pop("use_precond", False):
+        if isinstance(L, _data.CSR):
+            kw["M"] = _compute_precond(L, kw)
+        else:
+            warn("Only sparse solver use preconditioners.", RuntimeWarning)
+
+    it = 0
+    maxiter = kw.pop("power_maxiter", 10)
+    tol = kw.pop("power_tol", 1e-12)
+    method = kw.pop("method", None)
+    while it < maxiter and _data.norm.max(L @ y) > tol:
+        y = _data.solve(L, y, method, options=kw)
+        y = y / _data.norm.max(y)
+        it += 1
+
+    if it >= maxiter:
+        raise Exception('Failed to find steady state after ' +
+                        str(maxiter) + ' iterations')
+
+    if use_rcm:
+        y = _reverse_rcm(y, perm)
+
+    rho_ss = Qobj(_data.column_unstack(y, N**0.5), dims=A.dims[0])
+    rho_ss = rho_ss + rho_ss.dag()
+    rho_ss = rho_ss / rho_ss.tr()
+    rho_ss.isherm = True
+    return rho_ss
+
+
+def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
+                        solver=None, **kwargs):
+    """
+    Calculates the effective steady state for a driven
+     system with a time-dependent cosinusoidal term:
+
+    .. math::
+
+        \\mathcal{\\hat{H}}(t) = \\hat{H}_0 +
+         \\mathcal{\\hat{O}} \\cos(\\omega_d t)
+
+    Parameters
+    ----------
+    H_0 : :obj:`~Qobj`
+        A Hamiltonian or Liouvillian operator.
+
+    c_ops : list
+        A list of collapse operators.
+
+    Op_t : :obj:`~Qobj`
+        The the interaction operator which is multiplied by the cosine
+
+    w_d : float, default 1.0
+        The frequency of the drive
+
+    n_it : int, default 3
+        The number of iterations for the solver
+
+    sparse : bool, default False
+        Solve for the steady state using sparse algorithms.
+
+    solver : str, default=None
+        Solver to use when solving the linear system.
+        Default supported solver are:
+
+        - "solve", "lstsq"
+          dense solver from numpy.linalg
+        - "spsolve", "gmres", "lgmres", "bicgstab"
+          sparse solver from scipy.sparse.linalg
+        - "mkl_spsolve"
+          sparse solver by mkl.
+
+        Extensions to qutip, such as qutip-tensorflow, may provide their own solvers.
+        When ``H_0`` and ``c_ops`` use these data backends, see their documentation
+        for the names and details of additional solvers they may provide.
+
+    **kwargs:
+        Extra options to pass to the linear system solver. See the
+        documentation of the used solver in ``numpy.linalg`` or
+        ``scipy.sparse.linalg`` to see what extra arguments are supported.
+
+    Returns
+    -------
+    dm : qobj
+        Steady state density matrix.
+
+    .. note::
+
+        See: Sze Meng Tan,
+        https://copilot.caltech.edu/documents/16743/qousersguide.pdf,
+        Section (10.16)
+
+    """
+
+    L_0 = liouvillian(H_0, c_ops)
+    L_m = L_p = 0.5 * liouvillian(Op_t)
+    # L_p and L_m correspond to the positive and negative
+    # frequency terms respectively.
+    # They are independent in the model, so we keep both names.
+    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
+    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
+
+    if isinstance(H_0.data, _data.CSR) and not sparse:
+        L_0 = L_0.to("Dense")
+        L_m = L_m.to("Dense")
+        L_p = L_p.to("Dense")
+        Id = Id.to("Dense")
+
+    for n_i in np.arange(n_it, 0, -1):
+        L = L_0 - 1j * n_i * w_d * Id + L_m @ S
+        S.data = - _data.solve(L.data, L_p.data, solver, kwargs)
+        L = L_0 - 1j * n_i * w_d * Id + L_p @ T
+        T.data = - _data.solve(L.data, L_m.data, solver, kwargs)
+
+    M_subs = L_0 + L_m @ S + L_p @ T
+    return steadystate(M_subs, solver=solver, **kwargs)
+
+
+def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
+                   **kwargs):
+    """
+    Compute the pseudo inverse for a Liouvillian superoperator, optionally
+    given its steady state density matrix (which will be computed if not
+    given).
+
+    Parameters
+    ----------
+    L : Qobj
+        A Liouvillian superoperator for which to compute the pseudo inverse.
+
+    rhoss : Qobj
+        A steadystate density matrix as Qobj instance, for the Liouvillian
+        superoperator L.
+
+    w : double
+        frequency at which to evaluate pseudo-inverse.  Can be zero for dense
+        systems and large sparse systems. Small sparse systems can fail for
+        zero frequencies.
+
+    sparse : bool
+        Flag that indicate whether to use sparse or dense matrix methods when
+        computing the pseudo inverse.
+
+    method : string
+        Method used to compte matrix inverse.
+        Choice are 'pinv' to use scipy's function of the same name, or a linear
+        system solver.
+        Default supported solver are:
+
+        - "solve", "lstsq"
+          dense solver from numpy.linalg
+        - "spsolve", "gmres", "lgmres", "bicgstab", "splu"
+          sparse solver from scipy.sparse.linalg
+        - "mkl_spsolve",
+          sparse solver by mkl.
+
+        Extension to qutip, such as qutip-tensorflow, can use come with their
+        own solver. When ``L`` use these data backends, see the corresponding
+        libraries ``linalg`` for available solver.
+
+    kwargs : dictionary
+        Additional keyword arguments for setting parameters for solver methods.
+
+    Returns
+    -------
+    R : Qobj
+        Returns a Qobj instance representing the pseudo inverse of L.
+
+    .. note::
+
+        In general the inverse of a sparse matrix will be dense.  If you
+        are applying the inverse to a density matrix then it is better to
+        cast the problem as an Ax=b type problem where the explicit calculation
+        of the inverse is not required. See page 67 of "Electrons in
+        nanostructures" C. Flindt, PhD Thesis available online:
+        https://orbit.dtu.dk/fedora/objects/orbit:82314/datastreams/
+        file_4732600/content
+
+        Note also that the definition of the pseudo-inverse herein is different
+        from numpys pinv() alone, as it includes pre and post projection onto
+        the subspace defined by the projector Q.
+
+    """
+    if rhoss is None:
+        rhoss = steadystate(L)
+
+    sparse = kwargs.pop("sparse", False)
+    if method == "direct":
+        method = "splu" if sparse else "pinv"
+    sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
+    dense_solvers = ["solve", "lstsq", "pinv"]
+    if isinstance(L.data, _data.CSR) and method in dense_solvers:
+        L = L.to("dense")
+    elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
+        L = L.to("csr")
+
+    N = np.prod(L.dims[0][0])
+    dtype = type(L.data)
+    rhoss_vec = operator_to_vector(rhoss)
+
+    tr_op = qeye(L.dims[0][0])
+    tr_op_vec = operator_to_vector(tr_op)
+
+    P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
+    I = _data.csr.identity(N * N)
+    Q = _data.sub(I, P)
+
+    if w in [None, 0.0]:
+        L += 1e-15j
+    else:
+        L += 1.0j*w
+
+    use_rcm = use_rcm and isinstance(L.data, _data.CSR)
+
+    if use_rcm:
+        perm = scipy.sparse.csgraph.reverse_cuthill_mckee(L.data.as_scipy())
+        A = _data.permute.indices(L.data, perm, perm)
+        Q = _data.permute.indices(Q, perm, perm, dtype=_data.CSR)
+    else:
+        A = L.data
+
+    if method in ["pinv", "numpy", "scipy", "scipy2"]:
+        # from scipy 1.7.0, they all use the same algorithm.
+        LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
+        LIQ = _data.matmul(LI, Q)
+    elif method == "spilu":
+        if not isinstance(A, _data.CSR):
+            raise TypeError("'spilu' method can only be used with sparse data")
+        ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
+        LIQ = _data.Dense(ILU.solve(Q.to_array()))
+    else:
+        LIQ = _data.solve(A, Q, method, options=kwargs)
+
+    R = _data.matmul(Q, LIQ)
+
+    if use_rcm:
+        rev_perm = np.argsort(perm)
+        R = _data.permute.indices(R, rev_perm, rev_perm)
+
+    return Qobj(R, dims=L.dims)
+
+
+def _compute_precond(L, args):
+    spilu_keys = {
+        'permc_spec',
+        'drop_tol',
+        'diag_pivot_thresh',
+        'fill_factor',
+        'options',
+    }
+    ss_args = {
+        key: args.pop(key)
+        for key in spilu_keys
+        if key in args
+    }
+    P = scipy.sparse.linalg.spilu(L.as_scipy().tocsc(), **ss_args)
+    return scipy.sparse.linalg.LinearOperator(L.shape, matvec=P.solve)
diff --git a/qutip/testing.py b/qutip/testing.py
index fc2d37689c..60eb677f76 100644
--- a/qutip/testing.py
+++ b/qutip/testing.py
@@ -1,34 +1,34 @@
-from .about import about
-from .settings import settings as qset
-
-def run(full=False):
-    """
-    Run the test scripts for QuTiP.
-
-    Parameters
-    ----------
-    full: bool
-        If True run all test (30 min). Otherwise skip few variants of the
-        slowest tests.
-    """
-    # Call about to get all version info printed with tests
-    about()
-    import pytest
-    # real_num_cpu = qset.num_cpus
-    # real_thresh = qset.openmp_thresh
-    # if qset.has_openmp:
-        # For travis which VMs have only 1 cpu.
-        # Make sure the openmp version of the functions are tested.
-    #     qset.num_cpus = 2
-    #     qset.openmp_thresh = 100
-
-    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
-    if not full:
-        test_options += ['-m', 'not slow']
-    pytest.main(test_options + ["qutip"])
-    # runs tests in qutip.tests module only
-
-    # Restore previous settings
-    # if qset.has_openmp:
-    #     qset.num_cpus = real_num_cpu
-    #     qset.openmp_thresh = real_thresh
+from .about import about
+from .settings import settings as qset
+
+def run(full=False):
+    """
+    Run the test scripts for QuTiP.
+
+    Parameters
+    ----------
+    full: bool
+        If True run all test (30 min). Otherwise skip few variants of the
+        slowest tests.
+    """
+    # Call about to get all version info printed with tests
+    about()
+    import pytest
+    # real_num_cpu = qset.num_cpus
+    # real_thresh = qset.openmp_thresh
+    # if qset.has_openmp:
+        # For travis which VMs have only 1 cpu.
+        # Make sure the openmp version of the functions are tested.
+    #     qset.num_cpus = 2
+    #     qset.openmp_thresh = 100
+
+    test_options = ["--verbosity=1", "--disable-pytest-warnings", "--pyargs"]
+    if not full:
+        test_options += ['-m', 'not slow']
+    pytest.main(test_options + ["qutip"])
+    # runs tests in qutip.tests module only
+
+    # Restore previous settings
+    # if qset.has_openmp:
+    #     qset.num_cpus = real_num_cpu
+    #     qset.openmp_thresh = real_thresh
diff --git a/qutip/tests/Hadamard_params.ini b/qutip/tests/Hadamard_params.ini
index 8d4ea5ab04..60dc840fda 100644
--- a/qutip/tests/Hadamard_params.ini
+++ b/qutip/tests/Hadamard_params.ini
@@ -1,19 +1,19 @@
-[optimconfig]
-optim_method=FMIN_L_BFGS_B
-pulse_type = LIN
-
-[dynamics]
-evo_time = 6
-num_tslots = 6
-
-[termconds]
-fid_err_targ = 1e-10
-
-[optimizer]
-amp_lbound = -1.0
-amp_ubound = 1.0
-
-[pulsegen]
-scaling = 1.0
-lbound = -1.0
-ubound = 1.0
+[optimconfig]
+optim_method=FMIN_L_BFGS_B
+pulse_type = LIN
+
+[dynamics]
+evo_time = 6
+num_tslots = 6
+
+[termconds]
+fid_err_targ = 1e-10
+
+[optimizer]
+amp_lbound = -1.0
+amp_ubound = 1.0
+
+[pulsegen]
+scaling = 1.0
+lbound = -1.0
+ubound = 1.0
diff --git a/qutip/tests/conftest.py b/qutip/tests/conftest.py
index 71c90d868f..49d4add02a 100644
--- a/qutip/tests/conftest.py
+++ b/qutip/tests/conftest.py
@@ -1,158 +1,158 @@
-import pytest
-import functools
-import os
-import tempfile
-import numpy as np
-
-
-def _add_repeats_if_marked(metafunc):
-    """
-    If the metafunc is marked with the 'repeat' mark, then add the requisite
-    number of repeats via parametrisation.
-    """
-    marker = metafunc.definition.get_closest_marker('repeat')
-    if marker:
-        count = marker.args[0]
-        metafunc.fixturenames.append('_repeat_count')
-        metafunc.parametrize('_repeat_count',
-                             range(count),
-                             ids=["rep({})".format(x+1) for x in range(count)])
-
-
-def _skip_cython_tests_if_unavailable(item):
-    """
-    Skip the current test item if Cython is unavailable for import, or isn't a
-    high enough version.
-    """
-    if item.get_closest_marker("requires_cython"):
-        # importorskip rather than mark.skipif because this way we get pytest's
-        # version-handling semantics.
-        pytest.importorskip('Cython', minversion='0.14')
-
-
-@pytest.hookimpl(trylast=True)
-def pytest_generate_tests(metafunc):
-    _add_repeats_if_marked(metafunc)
-
-
-def pytest_runtest_setup(item):
-    _skip_cython_tests_if_unavailable(item)
-
-
-def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
-                           verbose=True, names=('ACTUAL', 'DESIRED'),
-                           precision=8):
-    """
-    Taken almost verbatim from `np.testing._private.utils`, except this version
-    doesn't truncate output if it's longer than three lines.
-
-    LICENCE
-    -------
-    Copyright (c) 2005-2020, NumPy Developers.
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    - Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-
-    - Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-
-    - Neither the name of the NumPy Developers nor the names of any
-      contributors may be used to endorse or promote products derived from this
-      software without specific prior written permission.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
-    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-    POSSIBILITY OF SUCH DAMAGE.
-    """
-    msg = ['\n' + header]
-    if err_msg:
-        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
-            msg = [msg[0] + ' ' + err_msg]
-        else:
-            msg.append(err_msg)
-    if verbose:
-        for i, a in enumerate(arrays):
-            if isinstance(a, np.ndarray):
-                # precision argument is only needed if the objects are ndarrays
-                r_func = functools.partial(np.core.array_repr,
-                                           precision=precision)
-            else:
-                r_func = repr
-
-            try:
-                # [diff] Remove truncation threshold from array output.
-                with np.printoptions(threshold=np.inf):
-                    r = r_func(a)
-            except Exception as exc:
-                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
-            # [diff] The original truncates the output to 3 lines here.
-            msg.append(' %s: %s' % (names[i], r))
-    return '\n'.join(msg)
-
-
-# Find the private module used by numpy to store its testing utility functions
-# so that we can monkeypatch the error messages to be more verbose.  QuTiP
-# supports numpy from 1.12 upwards, so we have to search.
-_numpy_private_utils_paths = [
-    ['_private', 'utils'],    # 1.15.0 <= x
-    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
-    ['utils'],                # 1.14.0 > x
-]
-for possible_path in _numpy_private_utils_paths:
-    try:
-        module = np.testing
-        for submodule in possible_path:
-            module = getattr(module, submodule)
-        _numpy_private_utils = module
-        break
-    except NameError:
-        pass
-else:
-    # If we can't locate it for some reason, then we don't attempt to patch.
-    _numpy_private_utils = None
-
-if _numpy_private_utils is not None:
-    @pytest.fixture(autouse=True)
-    def do_not_truncate_numpy_output(monkeypatch):
-        """
-        Monkeypatch the internal numpy function used for printing arrays so
-        that we get full output that isn't cut off after three lines.
-        """
-        with monkeypatch.context() as patch:
-            patch.setattr(np.testing._private.utils, "build_err_msg",
-                          _patched_build_err_msg)
-            # Yield inside context manager just to minimize the amount of time
-            # we've monkeypatched such a core library (and a private function!)
-            yield
-
-
-@pytest.fixture
-def in_temporary_directory():
-    """
-    Creates a temporary directory for the lifetime of the fixture and changes
-    into it.  All relative paths used will be in the temporary directory, and
-    everything will automatically be cleaned up at the end of the fixture's
-    life.
-    """
-    previous_dir = os.getcwd()
-    with tempfile.TemporaryDirectory() as temporary_dir:
-        os.chdir(temporary_dir)
-        yield
-        # pytest should catch exceptions occuring in functions using the
-        # fixture, so this should always be called.  We want it here rather
-        # than outside to prevent the case of the directory failing to be
-        # removed because it is 'busy'.
-        os.chdir(previous_dir)
+import pytest
+import functools
+import os
+import tempfile
+import numpy as np
+
+
+def _add_repeats_if_marked(metafunc):
+    """
+    If the metafunc is marked with the 'repeat' mark, then add the requisite
+    number of repeats via parametrisation.
+    """
+    marker = metafunc.definition.get_closest_marker('repeat')
+    if marker:
+        count = marker.args[0]
+        metafunc.fixturenames.append('_repeat_count')
+        metafunc.parametrize('_repeat_count',
+                             range(count),
+                             ids=["rep({})".format(x+1) for x in range(count)])
+
+
+def _skip_cython_tests_if_unavailable(item):
+    """
+    Skip the current test item if Cython is unavailable for import, or isn't a
+    high enough version.
+    """
+    if item.get_closest_marker("requires_cython"):
+        # importorskip rather than mark.skipif because this way we get pytest's
+        # version-handling semantics.
+        pytest.importorskip('Cython', minversion='0.14')
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_generate_tests(metafunc):
+    _add_repeats_if_marked(metafunc)
+
+
+def pytest_runtest_setup(item):
+    _skip_cython_tests_if_unavailable(item)
+
+
+def _patched_build_err_msg(arrays, err_msg, header='Items are not equal:',
+                           verbose=True, names=('ACTUAL', 'DESIRED'),
+                           precision=8):
+    """
+    Taken almost verbatim from `np.testing._private.utils`, except this version
+    doesn't truncate output if it's longer than three lines.
+
+    LICENCE
+    -------
+    Copyright (c) 2005-2020, NumPy Developers.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    - Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    - Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    - Neither the name of the NumPy Developers nor the names of any
+      contributors may be used to endorse or promote products derived from this
+      software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+    """
+    msg = ['\n' + header]
+    if err_msg:
+        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
+            msg = [msg[0] + ' ' + err_msg]
+        else:
+            msg.append(err_msg)
+    if verbose:
+        for i, a in enumerate(arrays):
+            if isinstance(a, np.ndarray):
+                # precision argument is only needed if the objects are ndarrays
+                r_func = functools.partial(np.core.array_repr,
+                                           precision=precision)
+            else:
+                r_func = repr
+
+            try:
+                # [diff] Remove truncation threshold from array output.
+                with np.printoptions(threshold=np.inf):
+                    r = r_func(a)
+            except Exception as exc:
+                r = '[repr failed for <{}>: {}]'.format(type(a).__name__, exc)
+            # [diff] The original truncates the output to 3 lines here.
+            msg.append(' %s: %s' % (names[i], r))
+    return '\n'.join(msg)
+
+
+# Find the private module used by numpy to store its testing utility functions
+# so that we can monkeypatch the error messages to be more verbose.  QuTiP
+# supports numpy from 1.12 upwards, so we have to search.
+_numpy_private_utils_paths = [
+    ['_private', 'utils'],    # 1.15.0 <= x
+    ['nose_tools', 'utils'],  # 1.14.0 <= x < 1.15.0
+    ['utils'],                # 1.14.0 > x
+]
+for possible_path in _numpy_private_utils_paths:
+    try:
+        module = np.testing
+        for submodule in possible_path:
+            module = getattr(module, submodule)
+        _numpy_private_utils = module
+        break
+    except NameError:
+        pass
+else:
+    # If we can't locate it for some reason, then we don't attempt to patch.
+    _numpy_private_utils = None
+
+if _numpy_private_utils is not None:
+    @pytest.fixture(autouse=True)
+    def do_not_truncate_numpy_output(monkeypatch):
+        """
+        Monkeypatch the internal numpy function used for printing arrays so
+        that we get full output that isn't cut off after three lines.
+        """
+        with monkeypatch.context() as patch:
+            patch.setattr(np.testing._private.utils, "build_err_msg",
+                          _patched_build_err_msg)
+            # Yield inside context manager just to minimize the amount of time
+            # we've monkeypatched such a core library (and a private function!)
+            yield
+
+
+@pytest.fixture
+def in_temporary_directory():
+    """
+    Creates a temporary directory for the lifetime of the fixture and changes
+    into it.  All relative paths used will be in the temporary directory, and
+    everything will automatically be cleaned up at the end of the fixture's
+    life.
+    """
+    previous_dir = os.getcwd()
+    with tempfile.TemporaryDirectory() as temporary_dir:
+        os.chdir(temporary_dir)
+        yield
+        # pytest should catch exceptions occuring in functions using the
+        # fixture, so this should always be called.  We want it here rather
+        # than outside to prevent the case of the directory failing to be
+        # removed because it is 'busy'.
+        os.chdir(previous_dir)
diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
index c46297b1d8..01d05c01e8 100644
--- a/qutip/tests/core/data/conftest.py
+++ b/qutip/tests/core/data/conftest.py
@@ -1,66 +1,66 @@
-import numpy as np
-import scipy.sparse
-
-import qutip
-
-
-def shuffle_indices_scipy_csr(matrix):
-    """
-    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
-    return a new array.  This should represent the same matrix, but in the less
-    efficient, "unsorted" manner.  All mathematical operations should still
-    work the same after this, but may be slower.
-
-    This is not guaranteed to change the order of the indices in every case.
-    If there is at most one value per row, there is no unsorted order.  In
-    general, we attempt to shuffle, and if this returns the same order as
-    before, we just reverse it to ensure it's different.
-    """
-    out = matrix.copy()
-    for row in range(out.shape[0]):
-        ptr = (out.indptr[row], out.indptr[row + 1])
-        if ptr[1] - ptr[0] > 1:
-            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
-            # If sorted, reverse it.
-            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
-            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
-            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
-    return out
-
-
-def random_scipy_csr(shape, density, sorted_):
-    """
-    Generate a random scipy CSR matrix with the given shape, nnz density, and
-    with indices that are either sorted or unsorted.  The nnz elements will
-    always be at least one.
-    """
-    nnz = int(shape[0] * shape[1] * density) or 1
-    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-    rows = np.random.choice(np.arange(shape[0]), nnz)
-    cols = np.random.choice(np.arange(shape[1]), nnz)
-    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
-    if not sorted_:
-        shuffle_indices_scipy_csr(sci)
-    return sci
-
-
-def random_numpy_dense(shape, fortran):
-    """Generate a random numpy dense matrix with the given shape."""
-    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    if fortran:
-        out = np.asfortranarray(out)
-    return out
-
-
-def random_csr(shape, density, sorted_):
-    """
-    Generate a random qutip CSR matrix with the given shape, nnz density, and
-    with indices that are either sorted or unsorted.  The nnz elements will
-    always be at least one (use data.csr.zeros otherwise).
-    """
-    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
-
-
-def random_dense(shape, fortran):
-    """Generate a random qutip Dense matrix of the given shape."""
-    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
+import numpy as np
+import scipy.sparse
+
+import qutip
+
+
+def shuffle_indices_scipy_csr(matrix):
+    """
+    Given a scipy.sparse.csr_matrix, shuffle the indices within each row and
+    return a new array.  This should represent the same matrix, but in the less
+    efficient, "unsorted" manner.  All mathematical operations should still
+    work the same after this, but may be slower.
+
+    This is not guaranteed to change the order of the indices in every case.
+    If there is at most one value per row, there is no unsorted order.  In
+    general, we attempt to shuffle, and if this returns the same order as
+    before, we just reverse it to ensure it's different.
+    """
+    out = matrix.copy()
+    for row in range(out.shape[0]):
+        ptr = (out.indptr[row], out.indptr[row + 1])
+        if ptr[1] - ptr[0] > 1:
+            order = np.argsort(np.random.rand(ptr[1] - ptr[0]))
+            # If sorted, reverse it.
+            order = np.flip(order) if np.all(order[:-1] < order[1:]) else order
+            out.indices[ptr[0]:ptr[1]] = out.indices[ptr[0]:ptr[1]][order]
+            out.data[ptr[0]:ptr[1]] = out.data[ptr[0]:ptr[1]][order]
+    return out
+
+
+def random_scipy_csr(shape, density, sorted_):
+    """
+    Generate a random scipy CSR matrix with the given shape, nnz density, and
+    with indices that are either sorted or unsorted.  The nnz elements will
+    always be at least one.
+    """
+    nnz = int(shape[0] * shape[1] * density) or 1
+    data = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+    rows = np.random.choice(np.arange(shape[0]), nnz)
+    cols = np.random.choice(np.arange(shape[1]), nnz)
+    sci = scipy.sparse.coo_matrix((data, (rows, cols)), shape=shape).tocsr()
+    if not sorted_:
+        shuffle_indices_scipy_csr(sci)
+    return sci
+
+
+def random_numpy_dense(shape, fortran):
+    """Generate a random numpy dense matrix with the given shape."""
+    out = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    if fortran:
+        out = np.asfortranarray(out)
+    return out
+
+
+def random_csr(shape, density, sorted_):
+    """
+    Generate a random qutip CSR matrix with the given shape, nnz density, and
+    with indices that are either sorted or unsorted.  The nnz elements will
+    always be at least one (use data.csr.zeros otherwise).
+    """
+    return qutip.core.data.CSR(random_scipy_csr(shape, density, sorted_))
+
+
+def random_dense(shape, fortran):
+    """Generate a random qutip Dense matrix of the given shape."""
+    return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
index 77cf03cc82..a7be4e6de9 100644
--- a/qutip/tests/core/data/test_convert.py
+++ b/qutip/tests/core/data/test_convert.py
@@ -1,78 +1,78 @@
-import numpy as np
-import pytest
-from scipy import sparse
-from qutip import data
-
-
-def test_init_empty_data():
-    shape = (3, 3)
-    base_data = data.Data(shape)
-    assert base_data.shape[0] == shape[0]
-    assert base_data.shape[1] == shape[1]
-
-
-@pytest.mark.parametrize(['base', 'dtype'], [
-    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
-    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
-    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
-                 id='array'),
-    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
-                 id='sparse'),
-    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
-    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
-                 id='sparse'),
-])
-def test_create(base, dtype):
-    # The test of exactitude is done in test_csr, test_dense.
-    created = data.create(base)
-    assert isinstance(created, dtype)
-
-
-@pytest.mark.parametrize(['from_', 'base'], [
-    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
-    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
-    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
-    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
-    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
-    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
-])
-@pytest.mark.parametrize(['to_', 'dtype'], [
-    pytest.param('dense', data.Dense, id='to Dense str'),
-    pytest.param('Dense', data.Dense, id='to Dense STR'),
-    pytest.param(data.Dense, data.Dense, id='to Dense type'),
-    pytest.param('csr', data.CSR, id='to CSR str'),
-    pytest.param('CSR', data.CSR, id='to CSR STR'),
-    pytest.param(data.CSR, data.CSR, id='to CSR type'),
-])
-def test_converters(from_, base, to_, dtype):
-    converter = data.to[to_, from_]
-    assert isinstance(converter(base), dtype)
-    converter = data.to[to_]
-    assert isinstance(converter(base), dtype)
-    assert isinstance(data.to(to_, base), dtype)
-
-
-dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
-dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
-@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-def test_parse_error(input, type_):
-    assert data.to.parse(input) is type_
-
-
-@pytest.mark.parametrize(['input', 'error', 'msg'], [
-    pytest.param(5, TypeError,
-                  "Invalid dtype is neither a type nor a type name: 5",
-                 id="wrong type"),
-    pytest.param("__this_is_not_a_known_type_name__", ValueError,
-                  "Type name is not known to the data-layer: "
-                  "'__this_is_not_a_known_type_name__'",
-                 id="not alias"),
-    pytest.param(object, ValueError,
-                  "Type is not a data-layer type: <class 'object'>",
-                 id="not Data"),
-])
-def test_parse_error(input, error, msg):
-    with pytest.raises(error) as exc:
-        data.to.parse(input)
-    assert str(exc.value) == msg
+import numpy as np
+import pytest
+from scipy import sparse
+from qutip import data
+
+
+def test_init_empty_data():
+    shape = (3, 3)
+    base_data = data.Data(shape)
+    assert base_data.shape[0] == shape[0]
+    assert base_data.shape[1] == shape[1]
+
+
+@pytest.mark.parametrize(['base', 'dtype'], [
+    pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
+    pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
+    pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
+                 id='array'),
+    pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
+                 id='sparse'),
+    pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
+    pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
+                 id='sparse'),
+])
+def test_create(base, dtype):
+    # The test of exactitude is done in test_csr, test_dense.
+    created = data.create(base)
+    assert isinstance(created, dtype)
+
+
+@pytest.mark.parametrize(['from_', 'base'], [
+    pytest.param('dense', data.dense.zeros(2, 2), id='from Dense str'),
+    pytest.param('Dense', data.dense.zeros(2, 2), id='from Dense STR'),
+    pytest.param(data.Dense, data.dense.zeros(2, 2), id='from Dense type'),
+    pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
+    pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
+    pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
+])
+@pytest.mark.parametrize(['to_', 'dtype'], [
+    pytest.param('dense', data.Dense, id='to Dense str'),
+    pytest.param('Dense', data.Dense, id='to Dense STR'),
+    pytest.param(data.Dense, data.Dense, id='to Dense type'),
+    pytest.param('csr', data.CSR, id='to CSR str'),
+    pytest.param('CSR', data.CSR, id='to CSR STR'),
+    pytest.param(data.CSR, data.CSR, id='to CSR type'),
+])
+def test_converters(from_, base, to_, dtype):
+    converter = data.to[to_, from_]
+    assert isinstance(converter(base), dtype)
+    converter = data.to[to_]
+    assert isinstance(converter(base), dtype)
+    assert isinstance(data.to(to_, base), dtype)
+
+
+dtype_names = list(data.to._str2type.keys()) + list(data.to.dtypes)
+dtype_types = list(data.to._str2type.values()) + list(data.to.dtypes)
+@pytest.mark.parametrize(['input', 'type_'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+def test_parse_error(input, type_):
+    assert data.to.parse(input) is type_
+
+
+@pytest.mark.parametrize(['input', 'error', 'msg'], [
+    pytest.param(5, TypeError,
+                  "Invalid dtype is neither a type nor a type name: 5",
+                 id="wrong type"),
+    pytest.param("__this_is_not_a_known_type_name__", ValueError,
+                  "Type name is not known to the data-layer: "
+                  "'__this_is_not_a_known_type_name__'",
+                 id="not alias"),
+    pytest.param(object, ValueError,
+                  "Type is not a data-layer type: <class 'object'>",
+                 id="not Data"),
+])
+def test_parse_error(input, error, msg):
+    with pytest.raises(error) as exc:
+        data.to.parse(input)
+    assert str(exc.value) == msg
diff --git a/qutip/tests/core/data/test_csr.py b/qutip/tests/core/data/test_csr.py
index 853c762235..834c9febdb 100644
--- a/qutip/tests/core/data/test_csr.py
+++ b/qutip/tests/core/data/test_csr.py
@@ -1,454 +1,454 @@
-import numpy as np
-import scipy.sparse
-import pytest
-
-from qutip.core import data
-from qutip.core.data import csr
-from qutip import qeye, CoreOptions
-
-from . import conftest
-
-# We only choose a small subset of dtypes to test so it isn't crazy.
-_dtype_complex = ['complex128']
-_dtype_float = ['float64']
-_dtype_int = ['int32', 'int64']
-_dtype_uint = ['uint32']
-
-
-# Set up some fixtures for automatic parametrisation.
-
-@pytest.fixture(params=[
-    pytest.param((1, 5), id='bra'),
-    pytest.param((5, 1), id='ket'),
-    pytest.param((5, 5), id='square'),
-    pytest.param((2, 4), id='wide'),
-    pytest.param((4, 2), id='tall'),
-])
-def shape(request): return request.param
-
-
-@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
-def density(request): return request.param
-
-
-@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
-def sorted_(request): return request.param
-
-
-def _valid_scipy():
-    """Arbitrary valid scipy CSR"""
-    return conftest.random_scipy_csr((10, 10), 0.5, True)
-
-
-def _valid_arg():
-    """
-    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
-    """
-    sci = _valid_scipy()
-    return (sci.data, sci.indices, sci.indptr)
-
-
-@pytest.fixture(scope='function')
-def scipy_csr(shape, density, sorted_):
-    return conftest.random_scipy_csr(shape, density, sorted_)
-
-
-@pytest.fixture(scope='function')
-def data_csr(shape, density, sorted_):
-    return conftest.random_csr(shape, density, sorted_)
-
-
-class TestClassMethods:
-    def test_init_from_tuple(self, scipy_csr):
-        """
-        Test that __init__ does not throw when passed a 3-tuple.  Also tests
-        the as_scipy() method succeeds.
-        """
-        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
-        out = data.CSR(arg, shape=scipy_csr.shape)
-        assert out.shape == scipy_csr.shape
-        assert (out.as_scipy() - scipy_csr).nnz == 0
-
-    @pytest.mark.parametrize('d_type', (
-        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
-    ))
-    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
-    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
-    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
-        """
-        Test that initialisation can use a variety of dtypes and converts into
-        the correct type.
-        """
-        sci = _valid_scipy()
-        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
-        col_index = sci.indices.astype(c_type, casting='unsafe')
-        row_index = sci.indptr.astype(r_type, casting='unsafe')
-        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
-                                            shape=sci.shape)
-        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
-        out_scipy = out.as_scipy()
-        assert out.shape == scipy_csr.shape
-        assert out_scipy.data.dtype == np.complex128
-        assert (out_scipy - scipy_csr).nnz == 0
-
-    def test_init_from_scipy(self, scipy_csr):
-        """Test that __init__ can accept a scipy CSR matrix."""
-        out = data.CSR(scipy_csr)
-        assert out.shape == scipy_csr.shape
-        assert (out.as_scipy() - scipy_csr).nnz == 0
-
-    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
-        pytest.param((), {}, ValueError, id="arg 0 tuple"),
-        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
-        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
-        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
-        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
-        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
-                     id="scipy-shape 0 tuple"),
-        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
-                     id="scipy-shape 1 tuple"),
-        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
-                     id="scipy-shape None tuple"),
-        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
-                     id="scipy-shape list"),
-        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
-                     id="scipy-shape 3 tuple"),
-        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
-                     id="arg-shape 0 tuple"),
-        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
-                     id="arg-shape 1 tuple"),
-        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
-                     id="arg-shape None tuple"),
-        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
-                     id="arg-shape list"),
-        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
-                     id="arg-shape 3 tuple"),
-        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
-                     id="arg-negative shape"),
-    ])
-    def test_init_from_wrong_input(self, arg, kwargs, error):
-        """
-        Test that the __init__ method raises a suitable error when passed
-        incorrectly formatted inputs.
-
-        This test also serves as a *partial* check that CSR safely handles
-        deallocation in the presence of exceptions in its __init__ method.  If
-        the tests segfault, it's quite likely that the memory management isn't
-        being done correctly in the hand-off us setting our data buffers up and
-        marking the numpy actually owns the data.
-        """
-        with pytest.raises(error):
-            data.CSR(arg, **kwargs)
-
-    def test_copy_returns_a_correct_copy(self, data_csr):
-        """
-        Test that the copy() method produces an actual copy, and that the
-        result represents the same matrix.
-        """
-        original = data_csr
-        copy = data_csr.copy()
-        assert original is not copy
-        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
-
-    def test_as_scipy_returns_a_view(self, data_csr):
-        """
-        Test that modifying the views in the result of as_scipy() also modifies
-        the underlying data structures.  This is important for allowing minor
-        data modifications from within Python-space.
-        """
-        unmodified_copy = data_csr.copy()
-        data_csr.as_scipy().data[0] += 1
-        modified_copy = data_csr.copy()
-        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
-        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
-
-    def test_as_scipy_caches_result(self, data_csr):
-        """
-        Test that the as_scipy() method always returns the same view, even if
-        called multiple times.
-        """
-        assert data_csr.as_scipy() is data_csr.as_scipy()
-
-    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
-        """
-        Test that we produce a new scipy matrix, regardless of how we have
-        initialised the type.
-        """
-        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
-
-    def test_as_scipy_of_copy_is_different(self, data_csr):
-        """
-        Test that as_scipy() does not return the same array, or the same views
-        if it's not the same input matrix.  We don't want two CSR matrices to
-        be linked.
-        """
-        original = data_csr.as_scipy()
-        copy = data_csr.copy().as_scipy()
-        assert original is not copy
-        assert not np.may_share_memory(original.data, copy.data)
-        assert not np.may_share_memory(original.indices, copy.indices)
-        assert not np.may_share_memory(original.indptr, copy.indptr)
-
-    def test_as_scipy_is_correct_result(self, scipy_csr):
-        """
-        Test that as_scipy is actually giving the matrix we expect for a given
-        input.
-        """
-        data_csr = data.CSR(scipy_csr)
-        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
-        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
-
-    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
-        nnz = int(shape[0] * shape[1] * density) or 1
-        base = csr.empty(shape[0], shape[1], nnz)
-        sci = base.as_scipy()
-        assert sci.nnz == 0
-        assert len(sci.data) == 0
-        assert len(sci.indices) == 0
-
-    def test_to_array_is_correct_result(self, data_csr):
-        test_array = data_csr.to_array()
-        assert isinstance(test_array, np.ndarray)
-        # It's not enough to be accurate within a tolerance here - there's no
-        # mathematics, so they should be _identical_.
-        assert np.all(test_array == data_csr.as_scipy().toarray())
-
-    def test_sorted_indices(self, data_csr):
-        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
-        # per row), so we add in this additional assertion message just to help
-        # out.
-        message = (
-            "Sort on {}sorted indices failed."
-            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
-        )
-        # We test on a copy because scipy attempts to cache
-        # `has_sorted_indices`, but since it's a view, it has no idea what
-        # we've done to the indices behind the scenes and typically would not
-        # notice the change.  The copy will return a difference scipy matrix,
-        # so the cache will not be built.
-        copy = data_csr.copy()
-        copy.sort_indices()
-        assert copy.as_scipy().has_sorted_indices, message
-
-
-class TestFactoryMethods:
-    def test_empty(self, shape, density):
-        nnz = int(shape[0] * shape[1] * density) or 1
-        base = csr.empty(shape[0], shape[1], nnz)
-        sci = base.as_scipy(full=True)
-        assert isinstance(base, data.CSR)
-        assert isinstance(sci, scipy.sparse.csr_matrix)
-        assert base.shape == shape
-        assert sci.data.shape == (nnz,)
-        assert sci.indices.shape == (nnz,)
-        assert sci.indptr.shape == (shape[0] + 1,)
-
-    def test_zeros(self, shape):
-        base = csr.zeros(shape[0], shape[1])
-        sci = base.as_scipy()
-        assert isinstance(base, data.CSR)
-        assert base.shape == shape
-        assert sci.nnz == 0
-        assert sci.indptr.shape == (shape[0] + 1,)
-
-    @pytest.mark.parametrize('dimension', [1, 5, 100])
-    @pytest.mark.parametrize(
-        'scale',
-        [None, 2, -0.1, 1.5, 1.5+1j],
-        ids=['none', 'int', 'negative', 'float', 'complex']
-    )
-    def test_identity(self, dimension, scale):
-        # scale=None is testing that the default value returns the identity.
-        base = (csr.identity(dimension) if scale is None
-                else csr.identity(dimension, scale))
-        sci = base.as_scipy()
-        scipy_test = scipy.sparse.eye(dimension,
-                                      dtype=np.complex128, format='csr')
-        if scale is not None:
-            scipy_test *= scale
-        assert isinstance(base, data.CSR)
-        assert base.shape == (dimension, dimension)
-        assert sci.nnz == dimension
-        assert (sci - scipy_test).nnz == 0
-
-    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
-        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
-        pytest.param([1], None, None, id='1x1'),
-        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
-        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
-        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
-        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
-                     id='two diagonals'),
-        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
-        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
-        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
-                     id='two wide super'),
-        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
-                     id='two tall sub'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
-                     id='out of order'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
-                     id='sum duplicates'),
-    ])
-    def test_diags(self, diagonals, offsets, shape):
-        base = csr.diags(diagonals, offsets, shape)
-        # Build numpy version test.
-        if not isinstance(diagonals[0], list):
-            diagonals = [diagonals]
-        offsets = np.atleast_1d(offsets if offsets is not None else [0])
-        if shape is None:
-            size = len(diagonals[0]) + abs(offsets[0])
-            shape = (size, size)
-        test = np.zeros(shape, dtype=np.complex128)
-        for diagonal, offset in zip(diagonals, offsets):
-            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-        assert isinstance(base, data.CSR)
-        assert base.shape == shape
-        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((1, 1), (0, 0), None, id='minimal'),
-        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
-        pytest.param((10, 10), (1, 5), 1., id='upper'),
-        pytest.param((10, 10), (5, 1), 2., id='lower'),
-        pytest.param((10, 1), (5, 0), None, id='column'),
-        pytest.param((1, 10), (0, 5), -5j, id='row'),
-        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
-        pytest.param((2, 10), (1, 5), 10, id='wide'),
-    ])
-    def test_one_element(self, shape, position, value):
-        test = np.zeros(shape, dtype=np.complex128)
-        if value is None:
-            base = data.one_element_csr(shape, position)
-            test[position] = 1.0+0.0j
-        else:
-            base = data.one_element_csr(shape, position, value)
-            test[position] = value
-        assert isinstance(base, data.CSR)
-        assert base.shape == shape
-        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((0, 0), (0, 0), None, id='zero shape'),
-        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
-        pytest.param((10, 10), (10, 5), 1., id='outside'),
-        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
-    ])
-    def test_one_element_error(self, shape, position, value):
-        with pytest.raises(ValueError) as exc:
-            base = data.one_element_csr(shape, position, value)
-        assert str(exc.value).startswith("Position of the elements"
-                                         " out of bound: ")
-
-
-class TestFromCSRBlocks:
-    class _blocks:
-        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
-            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
-            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
-            if isinstance(ops, int):
-                ops = [csr.zeros(block_size, block_size)] * ops
-            self.ops = np.array(ops, dtype=object)
-            self.n_blocks = n_blocks
-            self.block_size = block_size
-
-        def from_csr_blocks(self):
-            return csr._from_csr_blocks(
-                self.rows, self.cols, self.ops,
-                self.n_blocks, self.block_size,
-            )
-
-    @pytest.mark.parametrize(['blocks'], [
-        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
-        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
-    ])
-    def test_input_length_error(self, blocks):
-        with pytest.raises(ValueError) as exc:
-            blocks.from_csr_blocks()
-        assert str(exc.value) == (
-            "The arrays block_rows, block_cols and block_ops should have"
-            " the same length."
-        )
-
-    def test_op_shape_error(self):
-        blocks = self._blocks(
-            (0, 1), (0, 1),
-            (csr.zeros(2, 2), csr.zeros(3, 3)),
-        )
-        with pytest.raises(ValueError) as exc:
-            blocks.from_csr_blocks()
-        assert str(exc.value) == (
-            "Block operators (block_ops) do not have the correct shape."
-        )
-
-    @pytest.mark.parametrize(['blocks'], [
-        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
-        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
-        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
-    ])
-    def test_op_ordering_error(self, blocks):
-        with pytest.raises(ValueError) as exc:
-            blocks.from_csr_blocks()
-        assert str(exc.value) == (
-            "The arrays block_rows and block_cols must be sorted"
-            " by (row, column)."
-        )
-
-    @pytest.mark.parametrize(['blocks'], [
-        pytest.param(_blocks((), (), ()), id='no ops'),
-        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
-    ])
-    def test_zeros_output_fast_paths(self, blocks):
-        out = blocks.from_csr_blocks()
-        assert out == csr.zeros(2 * 2, 2 * 2)
-        assert csr.nnz(out) == 0
-
-    def test_construct_identity_with_empty(self):
-        # users are not expected to be exposed to
-        # csr.empty directly, but it is good to
-        # avoid segfaults, so we test passing
-        # csr.empty(..) blocks here explicitly
-        blocks = self._blocks(
-            [0, 0, 1, 1], [0, 1, 0, 1], [
-                csr.identity(2), csr.empty(2, 2, 0),
-                csr.empty(2, 2, 0), csr.identity(2),
-            ],
-        )
-        out = blocks.from_csr_blocks()
-        assert out == csr.identity(4)
-        assert csr.nnz(out) == 4
-
-    def test_construct_identity_with_zeros(self):
-        blocks = self._blocks(
-            [0, 0, 1, 1], [0, 1, 0, 1], [
-                csr.identity(2), csr.zeros(2, 2),
-                csr.zeros(2, 2), csr.identity(2),
-            ],
-        )
-        out = blocks.from_csr_blocks()
-        assert out == csr.identity(4)
-        assert csr.nnz(out) == 4
-
-    def test_construct_kron(self):
-        A = np.array([[1, 2], [3, 4]])
-        B = np.array([[0.3, 0.35], [0.4, 0.45]])
-        B_op = data.to("csr", data.Dense(B))
-        blocks = self._blocks(
-            [0, 0, 1, 1], [0, 1, 0, 1], [
-                A[0, 0] * B_op, A[0, 1] * B_op,
-                A[1, 0] * B_op, A[1, 1] * B_op,
-            ]
-        )
-        out = blocks.from_csr_blocks()
-        assert out == data.kron(data.Dense(A), data.Dense(B))
-        assert csr.nnz(out) == 16
-
-
-def test_tidyup():
-    small = qeye(1) * 1e-5
-    with CoreOptions(auto_tidyup_atol=1e-3):
-        assert (small + small).tr() == 0
-    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
-        assert (small + small).tr() == 2e-5
+import numpy as np
+import scipy.sparse
+import pytest
+
+from qutip.core import data
+from qutip.core.data import csr
+from qutip import qeye, CoreOptions
+
+from . import conftest
+
+# We only choose a small subset of dtypes to test so it isn't crazy.
+_dtype_complex = ['complex128']
+_dtype_float = ['float64']
+_dtype_int = ['int32', 'int64']
+_dtype_uint = ['uint32']
+
+
+# Set up some fixtures for automatic parametrisation.
+
+@pytest.fixture(params=[
+    pytest.param((1, 5), id='bra'),
+    pytest.param((5, 1), id='ket'),
+    pytest.param((5, 5), id='square'),
+    pytest.param((2, 4), id='wide'),
+    pytest.param((4, 2), id='tall'),
+])
+def shape(request): return request.param
+
+
+@pytest.fixture(params=[0.001, 1], ids=['sparse', 'dense'])
+def density(request): return request.param
+
+
+@pytest.fixture(params=[True, False], ids=['sorted', 'unsorted'])
+def sorted_(request): return request.param
+
+
+def _valid_scipy():
+    """Arbitrary valid scipy CSR"""
+    return conftest.random_scipy_csr((10, 10), 0.5, True)
+
+
+def _valid_arg():
+    """
+    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
+    """
+    sci = _valid_scipy()
+    return (sci.data, sci.indices, sci.indptr)
+
+
+@pytest.fixture(scope='function')
+def scipy_csr(shape, density, sorted_):
+    return conftest.random_scipy_csr(shape, density, sorted_)
+
+
+@pytest.fixture(scope='function')
+def data_csr(shape, density, sorted_):
+    return conftest.random_csr(shape, density, sorted_)
+
+
+class TestClassMethods:
+    def test_init_from_tuple(self, scipy_csr):
+        """
+        Test that __init__ does not throw when passed a 3-tuple.  Also tests
+        the as_scipy() method succeeds.
+        """
+        arg = (scipy_csr.data, scipy_csr.indices, scipy_csr.indptr)
+        out = data.CSR(arg, shape=scipy_csr.shape)
+        assert out.shape == scipy_csr.shape
+        assert (out.as_scipy() - scipy_csr).nnz == 0
+
+    @pytest.mark.parametrize('d_type', (
+        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
+    ))
+    @pytest.mark.parametrize('c_type', _dtype_int + _dtype_uint)
+    @pytest.mark.parametrize('r_type', _dtype_int + _dtype_uint)
+    def test_init_from_tuple_allowed_dtypes(self, d_type, c_type, r_type):
+        """
+        Test that initialisation can use a variety of dtypes and converts into
+        the correct type.
+        """
+        sci = _valid_scipy()
+        data_nz = np.random.randn(sci.nnz).astype(d_type, casting='unsafe')
+        col_index = sci.indices.astype(c_type, casting='unsafe')
+        row_index = sci.indptr.astype(r_type, casting='unsafe')
+        scipy_csr = scipy.sparse.csr_matrix((data_nz, col_index, row_index),
+                                            shape=sci.shape)
+        out = data.CSR((data_nz, col_index, row_index), shape=sci.shape)
+        out_scipy = out.as_scipy()
+        assert out.shape == scipy_csr.shape
+        assert out_scipy.data.dtype == np.complex128
+        assert (out_scipy - scipy_csr).nnz == 0
+
+    def test_init_from_scipy(self, scipy_csr):
+        """Test that __init__ can accept a scipy CSR matrix."""
+        out = data.CSR(scipy_csr)
+        assert out.shape == scipy_csr.shape
+        assert (out.as_scipy() - scipy_csr).nnz == 0
+
+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+        pytest.param((), {}, ValueError, id="arg 0 tuple"),
+        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
+        pytest.param((None,)*2, {}, ValueError, id="arg 2 tuple"),
+        pytest.param((None,)*3, {}, TypeError, id="arg None tuple"),
+        pytest.param((None,)*4, {}, ValueError, id="arg 4 tuple"),
+        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
+                     id="scipy-shape 0 tuple"),
+        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
+                     id="scipy-shape 1 tuple"),
+        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
+                     id="scipy-shape None tuple"),
+        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
+                     id="scipy-shape list"),
+        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
+                     id="scipy-shape 3 tuple"),
+        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
+                     id="arg-shape 0 tuple"),
+        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
+                     id="arg-shape 1 tuple"),
+        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
+                     id="arg-shape None tuple"),
+        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
+                     id="arg-shape list"),
+        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
+                     id="arg-shape 3 tuple"),
+        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
+                     id="arg-negative shape"),
+    ])
+    def test_init_from_wrong_input(self, arg, kwargs, error):
+        """
+        Test that the __init__ method raises a suitable error when passed
+        incorrectly formatted inputs.
+
+        This test also serves as a *partial* check that CSR safely handles
+        deallocation in the presence of exceptions in its __init__ method.  If
+        the tests segfault, it's quite likely that the memory management isn't
+        being done correctly in the hand-off us setting our data buffers up and
+        marking the numpy actually owns the data.
+        """
+        with pytest.raises(error):
+            data.CSR(arg, **kwargs)
+
+    def test_copy_returns_a_correct_copy(self, data_csr):
+        """
+        Test that the copy() method produces an actual copy, and that the
+        result represents the same matrix.
+        """
+        original = data_csr
+        copy = data_csr.copy()
+        assert original is not copy
+        assert (original.as_scipy() - copy.as_scipy()).nnz == 0
+
+    def test_as_scipy_returns_a_view(self, data_csr):
+        """
+        Test that modifying the views in the result of as_scipy() also modifies
+        the underlying data structures.  This is important for allowing minor
+        data modifications from within Python-space.
+        """
+        unmodified_copy = data_csr.copy()
+        data_csr.as_scipy().data[0] += 1
+        modified_copy = data_csr.copy()
+        assert (data_csr.as_scipy() - unmodified_copy.as_scipy()).nnz != 0
+        assert (data_csr.as_scipy() - modified_copy.as_scipy()).nnz == 0
+
+    def test_as_scipy_caches_result(self, data_csr):
+        """
+        Test that the as_scipy() method always returns the same view, even if
+        called multiple times.
+        """
+        assert data_csr.as_scipy() is data_csr.as_scipy()
+
+    def test_as_scipy_of_csr_from_scipy_is_different(self, scipy_csr):
+        """
+        Test that we produce a new scipy matrix, regardless of how we have
+        initialised the type.
+        """
+        assert data.CSR(scipy_csr).as_scipy() is not scipy_csr
+
+    def test_as_scipy_of_copy_is_different(self, data_csr):
+        """
+        Test that as_scipy() does not return the same array, or the same views
+        if it's not the same input matrix.  We don't want two CSR matrices to
+        be linked.
+        """
+        original = data_csr.as_scipy()
+        copy = data_csr.copy().as_scipy()
+        assert original is not copy
+        assert not np.may_share_memory(original.data, copy.data)
+        assert not np.may_share_memory(original.indices, copy.indices)
+        assert not np.may_share_memory(original.indptr, copy.indptr)
+
+    def test_as_scipy_is_correct_result(self, scipy_csr):
+        """
+        Test that as_scipy is actually giving the matrix we expect for a given
+        input.
+        """
+        data_csr = data.CSR(scipy_csr)
+        assert isinstance(data_csr.as_scipy(), scipy.sparse.csr_matrix)
+        assert (data_csr.as_scipy() - scipy_csr).nnz == 0
+
+    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
+        nnz = int(shape[0] * shape[1] * density) or 1
+        base = csr.empty(shape[0], shape[1], nnz)
+        sci = base.as_scipy()
+        assert sci.nnz == 0
+        assert len(sci.data) == 0
+        assert len(sci.indices) == 0
+
+    def test_to_array_is_correct_result(self, data_csr):
+        test_array = data_csr.to_array()
+        assert isinstance(test_array, np.ndarray)
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(test_array == data_csr.as_scipy().toarray())
+
+    def test_sorted_indices(self, data_csr):
+        # Some matrices _cannot_ be unsorted (e.g. if they have only one entry
+        # per row), so we add in this additional assertion message just to help
+        # out.
+        message = (
+            "Sort on {}sorted indices failed."
+            .format("" if data_csr.as_scipy().has_sorted_indices else "un")
+        )
+        # We test on a copy because scipy attempts to cache
+        # `has_sorted_indices`, but since it's a view, it has no idea what
+        # we've done to the indices behind the scenes and typically would not
+        # notice the change.  The copy will return a difference scipy matrix,
+        # so the cache will not be built.
+        copy = data_csr.copy()
+        copy.sort_indices()
+        assert copy.as_scipy().has_sorted_indices, message
+
+
+class TestFactoryMethods:
+    def test_empty(self, shape, density):
+        nnz = int(shape[0] * shape[1] * density) or 1
+        base = csr.empty(shape[0], shape[1], nnz)
+        sci = base.as_scipy(full=True)
+        assert isinstance(base, data.CSR)
+        assert isinstance(sci, scipy.sparse.csr_matrix)
+        assert base.shape == shape
+        assert sci.data.shape == (nnz,)
+        assert sci.indices.shape == (nnz,)
+        assert sci.indptr.shape == (shape[0] + 1,)
+
+    def test_zeros(self, shape):
+        base = csr.zeros(shape[0], shape[1])
+        sci = base.as_scipy()
+        assert isinstance(base, data.CSR)
+        assert base.shape == shape
+        assert sci.nnz == 0
+        assert sci.indptr.shape == (shape[0] + 1,)
+
+    @pytest.mark.parametrize('dimension', [1, 5, 100])
+    @pytest.mark.parametrize(
+        'scale',
+        [None, 2, -0.1, 1.5, 1.5+1j],
+        ids=['none', 'int', 'negative', 'float', 'complex']
+    )
+    def test_identity(self, dimension, scale):
+        # scale=None is testing that the default value returns the identity.
+        base = (csr.identity(dimension) if scale is None
+                else csr.identity(dimension, scale))
+        sci = base.as_scipy()
+        scipy_test = scipy.sparse.eye(dimension,
+                                      dtype=np.complex128, format='csr')
+        if scale is not None:
+            scipy_test *= scale
+        assert isinstance(base, data.CSR)
+        assert base.shape == (dimension, dimension)
+        assert sci.nnz == dimension
+        assert (sci - scipy_test).nnz == 0
+
+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+        pytest.param([1], None, None, id='1x1'),
+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+                     id='two diagonals'),
+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+                     id='two wide super'),
+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+                     id='two tall sub'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+                     id='out of order'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+                     id='sum duplicates'),
+    ])
+    def test_diags(self, diagonals, offsets, shape):
+        base = csr.diags(diagonals, offsets, shape)
+        # Build numpy version test.
+        if not isinstance(diagonals[0], list):
+            diagonals = [diagonals]
+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+        if shape is None:
+            size = len(diagonals[0]) + abs(offsets[0])
+            shape = (size, size)
+        test = np.zeros(shape, dtype=np.complex128)
+        for diagonal, offset in zip(diagonals, offsets):
+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+        assert isinstance(base, data.CSR)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((1, 1), (0, 0), None, id='minimal'),
+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+        pytest.param((10, 10), (1, 5), 1., id='upper'),
+        pytest.param((10, 10), (5, 1), 2., id='lower'),
+        pytest.param((10, 1), (5, 0), None, id='column'),
+        pytest.param((1, 10), (0, 5), -5j, id='row'),
+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+        pytest.param((2, 10), (1, 5), 10, id='wide'),
+    ])
+    def test_one_element(self, shape, position, value):
+        test = np.zeros(shape, dtype=np.complex128)
+        if value is None:
+            base = data.one_element_csr(shape, position)
+            test[position] = 1.0+0.0j
+        else:
+            base = data.one_element_csr(shape, position, value)
+            test[position] = value
+        assert isinstance(base, data.CSR)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, atol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+        pytest.param((10, 10), (10, 5), 1., id='outside'),
+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+    ])
+    def test_one_element_error(self, shape, position, value):
+        with pytest.raises(ValueError) as exc:
+            base = data.one_element_csr(shape, position, value)
+        assert str(exc.value).startswith("Position of the elements"
+                                         " out of bound: ")
+
+
+class TestFromCSRBlocks:
+    class _blocks:
+        def __init__(self, rows, cols, ops, n_blocks=2, block_size=2):
+            self.rows = np.array(rows, dtype=data.base.idxint_dtype)
+            self.cols = np.array(cols, dtype=data.base.idxint_dtype)
+            if isinstance(ops, int):
+                ops = [csr.zeros(block_size, block_size)] * ops
+            self.ops = np.array(ops, dtype=object)
+            self.n_blocks = n_blocks
+            self.block_size = block_size
+
+        def from_csr_blocks(self):
+            return csr._from_csr_blocks(
+                self.rows, self.cols, self.ops,
+                self.n_blocks, self.block_size,
+            )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((0, 1), (0,), 1), id='rows neq ops'),
+        pytest.param(_blocks((0,), (0, 1), 1), id='cols neq ops'),
+    ])
+    def test_input_length_error(self, blocks):
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "The arrays block_rows, block_cols and block_ops should have"
+            " the same length."
+        )
+
+    def test_op_shape_error(self):
+        blocks = self._blocks(
+            (0, 1), (0, 1),
+            (csr.zeros(2, 2), csr.zeros(3, 3)),
+        )
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "Block operators (block_ops) do not have the correct shape."
+        )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((1, 0), (0, 1), 2), id='rows not ordered'),
+        pytest.param(_blocks((1, 1), (1, 0), 2), id='cols not ordered'),
+        pytest.param(_blocks((1, 0), (1, 0), 2), id='non-unique block'),
+    ])
+    def test_op_ordering_error(self, blocks):
+        with pytest.raises(ValueError) as exc:
+            blocks.from_csr_blocks()
+        assert str(exc.value) == (
+            "The arrays block_rows and block_cols must be sorted"
+            " by (row, column)."
+        )
+
+    @pytest.mark.parametrize(['blocks'], [
+        pytest.param(_blocks((), (), ()), id='no ops'),
+        pytest.param(_blocks((0, 1), (1, 0), 2), id='zero ops'),
+    ])
+    def test_zeros_output_fast_paths(self, blocks):
+        out = blocks.from_csr_blocks()
+        assert out == csr.zeros(2 * 2, 2 * 2)
+        assert csr.nnz(out) == 0
+
+    def test_construct_identity_with_empty(self):
+        # users are not expected to be exposed to
+        # csr.empty directly, but it is good to
+        # avoid segfaults, so we test passing
+        # csr.empty(..) blocks here explicitly
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                csr.identity(2), csr.empty(2, 2, 0),
+                csr.empty(2, 2, 0), csr.identity(2),
+            ],
+        )
+        out = blocks.from_csr_blocks()
+        assert out == csr.identity(4)
+        assert csr.nnz(out) == 4
+
+    def test_construct_identity_with_zeros(self):
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                csr.identity(2), csr.zeros(2, 2),
+                csr.zeros(2, 2), csr.identity(2),
+            ],
+        )
+        out = blocks.from_csr_blocks()
+        assert out == csr.identity(4)
+        assert csr.nnz(out) == 4
+
+    def test_construct_kron(self):
+        A = np.array([[1, 2], [3, 4]])
+        B = np.array([[0.3, 0.35], [0.4, 0.45]])
+        B_op = data.to("csr", data.Dense(B))
+        blocks = self._blocks(
+            [0, 0, 1, 1], [0, 1, 0, 1], [
+                A[0, 0] * B_op, A[0, 1] * B_op,
+                A[1, 0] * B_op, A[1, 1] * B_op,
+            ]
+        )
+        out = blocks.from_csr_blocks()
+        assert out == data.kron(data.Dense(A), data.Dense(B))
+        assert csr.nnz(out) == 16
+
+
+def test_tidyup():
+    small = qeye(1) * 1e-5
+    with CoreOptions(auto_tidyup_atol=1e-3):
+        assert (small + small).tr() == 0
+    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
+        assert (small + small).tr() == 2e-5
diff --git a/qutip/tests/core/data/test_dense.py b/qutip/tests/core/data/test_dense.py
index 198ecf9828..072908115d 100644
--- a/qutip/tests/core/data/test_dense.py
+++ b/qutip/tests/core/data/test_dense.py
@@ -1,297 +1,297 @@
-import numpy as np
-import pytest
-
-from qutip.core import data
-from qutip.core.data import dense, csr
-
-from . import conftest
-
-
-# Set up some fixtures for automatic parametrisation.
-
-@pytest.fixture(params=[
-    pytest.param((1, 5), id='ket'),
-    pytest.param((5, 1), id='bra'),
-    pytest.param((5, 5), id='square'),
-    pytest.param((2, 4), id='wide'),
-    pytest.param((4, 2), id='tall'),
-])
-def shape(request): return request.param
-
-
-@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
-def fortran(request): return request.param
-
-
-def _valid_numpy():
-    # Arbitrary valid numpy array.
-    return conftest.random_numpy_dense((5, 5), False)
-
-
-@pytest.fixture(scope='function')
-def numpy_dense(shape, fortran):
-    return conftest.random_numpy_dense(shape, fortran)
-
-
-@pytest.fixture(scope='function')
-def data_dense(shape, fortran):
-    return conftest.random_dense(shape, fortran)
-
-
-class TestClassMethods:
-    def test_init_from_ndarray(self, numpy_dense):
-        test = data.Dense(numpy_dense)
-        assert test.shape == numpy_dense.shape
-        assert np.all(test.as_ndarray() == numpy_dense)
-
-    @pytest.mark.parametrize('dtype', ['complex128',
-                                       'float64',
-                                       'int32', 'int64',
-                                       'uint32'])
-    def test_init_from_ndarray_other_dtype(self, shape, dtype):
-        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
-        test = data.Dense(numpy_dense)
-        assert test.shape == shape
-        assert test.as_ndarray().dtype == np.complex128
-        assert np.all(test.as_ndarray() == numpy_dense)
-
-    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
-        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
-                     id="numpy-shape 0 tuple"),
-        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
-                     id="numpy-shape 1 tuple"),
-        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
-                     id="numpy-shape None tuple"),
-        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
-                     id="numpy-shape list"),
-        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
-                     id="numpy-shape 3 tuple"),
-        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
-                     id="numpy-negative shape"),
-        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
-                     id="numpy-both negative shape"),
-        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
-                     id="numpy-different shape"),
-    ])
-    def test_init_from_wrong_input(self, arg, kwargs, error):
-        """
-        Test that the __init__ method raises a suitable error when passed
-        incorrectly formatted inputs.
-
-        This test also serves as a *partial* check that Dense safely handles
-        deallocation in the presence of exceptions in its __init__ method.  If
-        the tests segfault, it's quite likely that the memory management isn't
-        being done correctly in the hand-off us setting our data buffers up and
-        marking the numpy actually owns the data.
-        """
-        with pytest.raises(error):
-            data.Dense(arg, **kwargs)
-
-    def test_copy_returns_a_correct_copy(self, data_dense):
-        """
-        Test that the copy() method produces an actual copy, and that the
-        result represents the same matrix.
-        """
-        original = data_dense
-        copy = data_dense.copy()
-        assert original is not copy
-        assert np.all(original.as_ndarray() == copy.as_ndarray())
-
-    def test_as_ndarray_returns_a_view(self, data_dense):
-        """
-        Test that modifying the views in the result of as_ndarray() also
-        modifies the underlying data structures.  This is important for
-        allowing data modification from within Python-space.
-        """
-        unmodified_copy = data_dense.copy()
-        data_dense.as_ndarray()[0, 0] += 1
-        modified_copy = data_dense.copy()
-        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
-        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
-
-    def test_as_ndarray_caches_result(self, data_dense):
-        """
-        Test that the as_ndarray() method always returns the same view, even if
-        called multiple times.
-        """
-        assert data_dense.as_ndarray() is data_dense.as_ndarray()
-
-    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
-        """
-        Test that we produce a new ndarray, regardless of how we have
-        initialised the type.
-        """
-        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
-
-    def test_as_ndarray_of_copy_is_different(self, data_dense):
-        """
-        Test that as_ndarray() does not return the same array or a view to the
-        same data, if it's not the same input matrix.  We don't want two Dense
-        matrices to be linked.
-        """
-        original = data_dense.as_ndarray()
-        copy = data_dense.copy().as_ndarray()
-        assert original is not copy
-        assert not np.may_share_memory(original, copy)
-
-    def test_as_ndarray_is_correct_result(self, numpy_dense):
-        """
-        Test that as_ndarray is actually giving the matrix we expect for a given
-        input.
-        """
-        data_dense = data.Dense(numpy_dense)
-        nd_view = data_dense.as_ndarray()
-        assert isinstance(data_dense.as_ndarray(), np.ndarray)
-        assert nd_view.ndim == 2
-        assert nd_view.shape == numpy_dense.shape
-        assert nd_view.strides == numpy_dense.strides
-        assert np.all(nd_view == numpy_dense)
-        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
-        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
-
-    def test_to_array_is_correct_result(self, data_dense):
-        test_array = data_dense.to_array()
-        nd_view = data_dense.as_ndarray()
-        assert isinstance(test_array, np.ndarray)
-        assert test_array.ndim == 2
-        assert test_array.shape == nd_view.shape
-        assert test_array.strides == nd_view.strides
-        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
-        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
-        # It's not enough to be accurate within a tolerance here - there's no
-        # mathematics, so they should be _identical_.
-        assert np.all(test_array == nd_view)
-
-    @pytest.mark.parametrize('new_fortran', [
-        pytest.param(-1, id='swap'),
-        pytest.param(False, id='C'),
-        pytest.param(True, id='Fortran'),
-    ])
-    def test_reorder(self, data_dense, new_fortran):
-        reordered = data_dense.reorder(new_fortran)
-        assert isinstance(reordered, data.Dense)
-        assert reordered.shape == data_dense.shape
-        orig = data_dense.to_array()
-        test = reordered.to_array()
-        if new_fortran == -1:
-            orig.flags.f_contiguous == test.flags.c_contiguous
-            orig.flags.c_contiguous == test.flags.f_contiguous
-        elif new_fortran is True:
-            assert test.flags.f_contiguous
-        else:
-            assert test.flags.c_contiguous
-        assert np.all(orig == test)
-
-class TestFactoryMethods:
-    def test_empty(self, shape):
-        base = dense.empty(shape[0], shape[1])
-        nd = base.as_ndarray()
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        assert nd.shape == shape
-
-    def test_zeros(self, shape):
-        base = dense.zeros(shape[0], shape[1])
-        nd = base.as_ndarray()
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        assert nd.shape == shape
-        assert np.count_nonzero(nd) == 0
-
-    @pytest.mark.parametrize('dimension', [1, 5, 100])
-    @pytest.mark.parametrize(
-        'scale',
-        [None, 2, -0.1, 1.5, 1.5+1j],
-        ids=['none', 'int', 'negative', 'float', 'complex']
-    )
-    def test_identity(self, dimension, scale):
-        # scale=None is testing that the default value returns the identity.
-        base = (dense.identity(dimension) if scale is None
-                else dense.identity(dimension, scale))
-        nd = base.as_ndarray()
-        numpy_test = np.eye(dimension, dtype=np.complex128)
-        if scale is not None:
-            numpy_test *= scale
-        assert isinstance(base, data.Dense)
-        assert base.shape == (dimension, dimension)
-        assert np.count_nonzero(nd - numpy_test) == 0
-
-    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
-        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
-        pytest.param([1], None, None, id='1x1'),
-        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
-        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
-        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
-        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
-                     id='two diagonals'),
-        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
-        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
-        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
-                     id='two wide super'),
-        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
-        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
-                     id='two tall sub'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
-                     id='out of order'),
-        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
-                     id='sum duplicates'),
-    ])
-    def test_diags(self, diagonals, offsets, shape):
-        base = dense.diags(diagonals, offsets, shape)
-        # Build numpy version test.
-        if not isinstance(diagonals[0], list):
-            diagonals = [diagonals]
-        offsets = np.atleast_1d(offsets if offsets is not None else [0])
-        if shape is None:
-            size = len(diagonals[0]) + abs(offsets[0])
-            shape = (size, size)
-        test = np.zeros(shape, dtype=np.complex128)
-        for diagonal, offset in zip(diagonals, offsets):
-            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((1, 1), (0, 0), None, id='minimal'),
-        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
-        pytest.param((10, 10), (1, 5), 1., id='upper'),
-        pytest.param((10, 10), (5, 1), 2., id='lower'),
-        pytest.param((10, 1), (5, 0), None, id='column'),
-        pytest.param((1, 10), (0, 5), -5.j, id='row'),
-        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
-        pytest.param((2, 10), (1, 5), 10, id='wide'),
-    ])
-    def test_one_element(self, shape, position, value):
-        test = np.zeros(shape, dtype=np.complex128)
-        if value is None:
-            base = data.one_element_dense(shape, position)
-            test[position] = 1.0+0.0j
-        else:
-            base = data.one_element_dense(shape, position, value)
-            test[position] = value
-        assert isinstance(base, data.Dense)
-        assert base.shape == shape
-        assert np.allclose(base.to_array(), test, atol=1e-10)
-
-    @pytest.mark.parametrize(['shape', 'position', 'value'], [
-        pytest.param((0, 0), (0, 0), None, id='zero shape'),
-        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
-        pytest.param((10, 10), (10, 5), 1., id='outside'),
-        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
-    ])
-    def test_one_element_error(self, shape, position, value):
-        with pytest.raises(ValueError) as exc:
-            base = data.one_element_dense(shape, position, value)
-        assert str(exc.value).startswith("Position of the elements"
-                                         " out of bound: ")
-
-
-def test_OrderEfficiencyWarning():
-    N = 5
-    M = csr.identity(N)
-    C_ordered = dense.zeros(N, 1, fortran=False)
-    fortran_ordered = dense.zeros(N, 1, fortran=True)
-    with pytest.warns(dense.OrderEfficiencyWarning):
-        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
+import numpy as np
+import pytest
+
+from qutip.core import data
+from qutip.core.data import dense, csr
+
+from . import conftest
+
+
+# Set up some fixtures for automatic parametrisation.
+
+@pytest.fixture(params=[
+    pytest.param((1, 5), id='ket'),
+    pytest.param((5, 1), id='bra'),
+    pytest.param((5, 5), id='square'),
+    pytest.param((2, 4), id='wide'),
+    pytest.param((4, 2), id='tall'),
+])
+def shape(request): return request.param
+
+
+@pytest.fixture(params=[True, False], ids=['Fortran', 'C'])
+def fortran(request): return request.param
+
+
+def _valid_numpy():
+    # Arbitrary valid numpy array.
+    return conftest.random_numpy_dense((5, 5), False)
+
+
+@pytest.fixture(scope='function')
+def numpy_dense(shape, fortran):
+    return conftest.random_numpy_dense(shape, fortran)
+
+
+@pytest.fixture(scope='function')
+def data_dense(shape, fortran):
+    return conftest.random_dense(shape, fortran)
+
+
+class TestClassMethods:
+    def test_init_from_ndarray(self, numpy_dense):
+        test = data.Dense(numpy_dense)
+        assert test.shape == numpy_dense.shape
+        assert np.all(test.as_ndarray() == numpy_dense)
+
+    @pytest.mark.parametrize('dtype', ['complex128',
+                                       'float64',
+                                       'int32', 'int64',
+                                       'uint32'])
+    def test_init_from_ndarray_other_dtype(self, shape, dtype):
+        numpy_dense = np.random.rand(*shape).astype(dtype, casting='unsafe')
+        test = data.Dense(numpy_dense)
+        assert test.shape == shape
+        assert test.as_ndarray().dtype == np.complex128
+        assert np.all(test.as_ndarray() == numpy_dense)
+
+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+        pytest.param(_valid_numpy(), {'shape': ()}, ValueError,
+                     id="numpy-shape 0 tuple"),
+        pytest.param(_valid_numpy(), {'shape': (1,)}, ValueError,
+                     id="numpy-shape 1 tuple"),
+        pytest.param(_valid_numpy(), {'shape': (None, None)}, ValueError,
+                     id="numpy-shape None tuple"),
+        pytest.param(_valid_numpy(), {'shape': [2, 2]}, ValueError,
+                     id="numpy-shape list"),
+        pytest.param(_valid_numpy(), {'shape': (1, 2, 3)}, ValueError,
+                     id="numpy-shape 3 tuple"),
+        pytest.param(_valid_numpy(), {'shape': (-1, 1)}, ValueError,
+                     id="numpy-negative shape"),
+        pytest.param(_valid_numpy(), {'shape': (-4, -4)}, ValueError,
+                     id="numpy-both negative shape"),
+        pytest.param(_valid_numpy(), {'shape': (1213, 1217)}, ValueError,
+                     id="numpy-different shape"),
+    ])
+    def test_init_from_wrong_input(self, arg, kwargs, error):
+        """
+        Test that the __init__ method raises a suitable error when passed
+        incorrectly formatted inputs.
+
+        This test also serves as a *partial* check that Dense safely handles
+        deallocation in the presence of exceptions in its __init__ method.  If
+        the tests segfault, it's quite likely that the memory management isn't
+        being done correctly in the hand-off us setting our data buffers up and
+        marking the numpy actually owns the data.
+        """
+        with pytest.raises(error):
+            data.Dense(arg, **kwargs)
+
+    def test_copy_returns_a_correct_copy(self, data_dense):
+        """
+        Test that the copy() method produces an actual copy, and that the
+        result represents the same matrix.
+        """
+        original = data_dense
+        copy = data_dense.copy()
+        assert original is not copy
+        assert np.all(original.as_ndarray() == copy.as_ndarray())
+
+    def test_as_ndarray_returns_a_view(self, data_dense):
+        """
+        Test that modifying the views in the result of as_ndarray() also
+        modifies the underlying data structures.  This is important for
+        allowing data modification from within Python-space.
+        """
+        unmodified_copy = data_dense.copy()
+        data_dense.as_ndarray()[0, 0] += 1
+        modified_copy = data_dense.copy()
+        assert np.any(data_dense.as_ndarray() != unmodified_copy.as_ndarray())
+        assert np.all(data_dense.as_ndarray() == modified_copy.as_ndarray())
+
+    def test_as_ndarray_caches_result(self, data_dense):
+        """
+        Test that the as_ndarray() method always returns the same view, even if
+        called multiple times.
+        """
+        assert data_dense.as_ndarray() is data_dense.as_ndarray()
+
+    def test_as_ndarray_of_dense_from_ndarray_is_different(self, numpy_dense):
+        """
+        Test that we produce a new ndarray, regardless of how we have
+        initialised the type.
+        """
+        assert data.Dense(numpy_dense).as_ndarray() is not numpy_dense
+
+    def test_as_ndarray_of_copy_is_different(self, data_dense):
+        """
+        Test that as_ndarray() does not return the same array or a view to the
+        same data, if it's not the same input matrix.  We don't want two Dense
+        matrices to be linked.
+        """
+        original = data_dense.as_ndarray()
+        copy = data_dense.copy().as_ndarray()
+        assert original is not copy
+        assert not np.may_share_memory(original, copy)
+
+    def test_as_ndarray_is_correct_result(self, numpy_dense):
+        """
+        Test that as_ndarray is actually giving the matrix we expect for a given
+        input.
+        """
+        data_dense = data.Dense(numpy_dense)
+        nd_view = data_dense.as_ndarray()
+        assert isinstance(data_dense.as_ndarray(), np.ndarray)
+        assert nd_view.ndim == 2
+        assert nd_view.shape == numpy_dense.shape
+        assert nd_view.strides == numpy_dense.strides
+        assert np.all(nd_view == numpy_dense)
+        assert nd_view.flags.c_contiguous == numpy_dense.flags.c_contiguous
+        assert nd_view.flags.f_contiguous == numpy_dense.flags.f_contiguous
+
+    def test_to_array_is_correct_result(self, data_dense):
+        test_array = data_dense.to_array()
+        nd_view = data_dense.as_ndarray()
+        assert isinstance(test_array, np.ndarray)
+        assert test_array.ndim == 2
+        assert test_array.shape == nd_view.shape
+        assert test_array.strides == nd_view.strides
+        assert test_array.flags.c_contiguous == nd_view.flags.c_contiguous
+        assert test_array.flags.f_contiguous == nd_view.flags.f_contiguous
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(test_array == nd_view)
+
+    @pytest.mark.parametrize('new_fortran', [
+        pytest.param(-1, id='swap'),
+        pytest.param(False, id='C'),
+        pytest.param(True, id='Fortran'),
+    ])
+    def test_reorder(self, data_dense, new_fortran):
+        reordered = data_dense.reorder(new_fortran)
+        assert isinstance(reordered, data.Dense)
+        assert reordered.shape == data_dense.shape
+        orig = data_dense.to_array()
+        test = reordered.to_array()
+        if new_fortran == -1:
+            orig.flags.f_contiguous == test.flags.c_contiguous
+            orig.flags.c_contiguous == test.flags.f_contiguous
+        elif new_fortran is True:
+            assert test.flags.f_contiguous
+        else:
+            assert test.flags.c_contiguous
+        assert np.all(orig == test)
+
+class TestFactoryMethods:
+    def test_empty(self, shape):
+        base = dense.empty(shape[0], shape[1])
+        nd = base.as_ndarray()
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert nd.shape == shape
+
+    def test_zeros(self, shape):
+        base = dense.zeros(shape[0], shape[1])
+        nd = base.as_ndarray()
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert nd.shape == shape
+        assert np.count_nonzero(nd) == 0
+
+    @pytest.mark.parametrize('dimension', [1, 5, 100])
+    @pytest.mark.parametrize(
+        'scale',
+        [None, 2, -0.1, 1.5, 1.5+1j],
+        ids=['none', 'int', 'negative', 'float', 'complex']
+    )
+    def test_identity(self, dimension, scale):
+        # scale=None is testing that the default value returns the identity.
+        base = (dense.identity(dimension) if scale is None
+                else dense.identity(dimension, scale))
+        nd = base.as_ndarray()
+        numpy_test = np.eye(dimension, dtype=np.complex128)
+        if scale is not None:
+            numpy_test *= scale
+        assert isinstance(base, data.Dense)
+        assert base.shape == (dimension, dimension)
+        assert np.count_nonzero(nd - numpy_test) == 0
+
+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+        pytest.param([1], None, None, id='1x1'),
+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+                     id='two diagonals'),
+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+                     id='two wide super'),
+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+                     id='two tall sub'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+                     id='out of order'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+                     id='sum duplicates'),
+    ])
+    def test_diags(self, diagonals, offsets, shape):
+        base = dense.diags(diagonals, offsets, shape)
+        # Build numpy version test.
+        if not isinstance(diagonals[0], list):
+            diagonals = [diagonals]
+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+        if shape is None:
+            size = len(diagonals[0]) + abs(offsets[0])
+            shape = (size, size)
+        test = np.zeros(shape, dtype=np.complex128)
+        for diagonal, offset in zip(diagonals, offsets):
+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((1, 1), (0, 0), None, id='minimal'),
+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+        pytest.param((10, 10), (1, 5), 1., id='upper'),
+        pytest.param((10, 10), (5, 1), 2., id='lower'),
+        pytest.param((10, 1), (5, 0), None, id='column'),
+        pytest.param((1, 10), (0, 5), -5.j, id='row'),
+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+        pytest.param((2, 10), (1, 5), 10, id='wide'),
+    ])
+    def test_one_element(self, shape, position, value):
+        test = np.zeros(shape, dtype=np.complex128)
+        if value is None:
+            base = data.one_element_dense(shape, position)
+            test[position] = 1.0+0.0j
+        else:
+            base = data.one_element_dense(shape, position, value)
+            test[position] = value
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert np.allclose(base.to_array(), test, atol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+        pytest.param((10, 10), (10, 5), 1., id='outside'),
+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+    ])
+    def test_one_element_error(self, shape, position, value):
+        with pytest.raises(ValueError) as exc:
+            base = data.one_element_dense(shape, position, value)
+        assert str(exc.value).startswith("Position of the elements"
+                                         " out of bound: ")
+
+
+def test_OrderEfficiencyWarning():
+    N = 5
+    M = csr.identity(N)
+    C_ordered = dense.zeros(N, 1, fortran=False)
+    fortran_ordered = dense.zeros(N, 1, fortran=True)
+    with pytest.warns(dense.OrderEfficiencyWarning):
+        data.matmul_csr_dense_dense(M, C_ordered, out=fortran_ordered)
diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
index 29eaa5c231..256a703a89 100644
--- a/qutip/tests/core/data/test_expect.py
+++ b/qutip/tests/core/data/test_expect.py
@@ -1,67 +1,67 @@
-"""This file provides tests for expect specialisation. For tests at Qobj level
-see `qutip/tests/core/test_expect.py`"""
-
-from .test_mathematics import BinaryOpMixin
-import pytest
-import numpy as np
-from qutip import data
-from qutip.core.data import CSR, Dense
-from itertools import product
-
-
-class TestExpect(BinaryOpMixin):
-    def op_numpy(self, op, state):
-        is_ket = state.shape[1] == 1
-        if is_ket:
-            return np.conj(state.T)@op@state
-        else:
-            return np.trace(op@state)
-
-    _dim = 100
-    _ket = pytest.param((_dim, 1), id="ket")
-    _dm = pytest.param((_dim, _dim), id="dm")
-    _op = pytest.param((_dim, _dim), id="op")
-    _bra = pytest.param((1, _dim), id="bra")
-    _nonsquare = pytest.param((2, _dim), id="nonsquare")
-    _not_op = [_bra, _ket, _nonsquare]
-
-    shapes = [
-        (_op, _ket),
-        (_op, _dm),
-    ]
-    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
-    bad_shapes += [
-        (_op, _nonsquare),
-        (_op, _bra),
-    ]  # Bad ket/dm
-
-    specialisations = [
-        pytest.param(data.expect_csr, CSR, CSR, complex),
-        pytest.param(data.expect_dense, Dense, Dense, complex),
-        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
-    ]
-
-
-class TestExpectSuper(BinaryOpMixin):
-    def op_numpy(self, op, state):
-        n = np.sqrt(state.shape[0]).astype(int)
-        out_shape = (n, n)
-        return np.trace(np.reshape(op@state, newshape=out_shape))
-
-    _dim = 100
-    _super_ket = pytest.param((_dim, 1), id="super_ket")
-    _super_op = pytest.param((_dim, _dim), id="super_op")
-    _bra = pytest.param((1, _dim), id="row_stacked")
-    _nonsquare = pytest.param((2, _dim), id="nonsquare")
-    _not_super_ket = [_super_op, _bra, _nonsquare]
-    _not_super_op = [_super_ket, _bra, _nonsquare]
-
-    shapes = [(_super_op, _super_ket), ]
-    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
-    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
-
-    specialisations = [
-        pytest.param(data.expect_super_dense, Dense, Dense, complex),
-        pytest.param(data.expect_super_csr, CSR, CSR, complex),
-        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
-    ]
+"""This file provides tests for expect specialisation. For tests at Qobj level
+see `qutip/tests/core/test_expect.py`"""
+
+from .test_mathematics import BinaryOpMixin
+import pytest
+import numpy as np
+from qutip import data
+from qutip.core.data import CSR, Dense
+from itertools import product
+
+
+class TestExpect(BinaryOpMixin):
+    def op_numpy(self, op, state):
+        is_ket = state.shape[1] == 1
+        if is_ket:
+            return np.conj(state.T)@op@state
+        else:
+            return np.trace(op@state)
+
+    _dim = 100
+    _ket = pytest.param((_dim, 1), id="ket")
+    _dm = pytest.param((_dim, _dim), id="dm")
+    _op = pytest.param((_dim, _dim), id="op")
+    _bra = pytest.param((1, _dim), id="bra")
+    _nonsquare = pytest.param((2, _dim), id="nonsquare")
+    _not_op = [_bra, _ket, _nonsquare]
+
+    shapes = [
+        (_op, _ket),
+        (_op, _dm),
+    ]
+    bad_shapes = list(product(_not_op, [_ket, _dm]))  # Bad op
+    bad_shapes += [
+        (_op, _nonsquare),
+        (_op, _bra),
+    ]  # Bad ket/dm
+
+    specialisations = [
+        pytest.param(data.expect_csr, CSR, CSR, complex),
+        pytest.param(data.expect_dense, Dense, Dense, complex),
+        pytest.param(data.expect_csr_dense, CSR, Dense, complex),
+    ]
+
+
+class TestExpectSuper(BinaryOpMixin):
+    def op_numpy(self, op, state):
+        n = np.sqrt(state.shape[0]).astype(int)
+        out_shape = (n, n)
+        return np.trace(np.reshape(op@state, newshape=out_shape))
+
+    _dim = 100
+    _super_ket = pytest.param((_dim, 1), id="super_ket")
+    _super_op = pytest.param((_dim, _dim), id="super_op")
+    _bra = pytest.param((1, _dim), id="row_stacked")
+    _nonsquare = pytest.param((2, _dim), id="nonsquare")
+    _not_super_ket = [_super_op, _bra, _nonsquare]
+    _not_super_op = [_super_ket, _bra, _nonsquare]
+
+    shapes = [(_super_op, _super_ket), ]
+    bad_shapes = list(product(_not_super_op, [_super_ket]))  # Bad super op
+    bad_shapes += list(product([_super_op], _not_super_ket))  # Bad super ket
+
+    specialisations = [
+        pytest.param(data.expect_super_dense, Dense, Dense, complex),
+        pytest.param(data.expect_super_csr, CSR, CSR, complex),
+        pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
+    ]
diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index e1025fc229..50729bba9c 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -1,139 +1,139 @@
-import qutip.settings as settings
-import numpy as np
-import scipy
-import pytest
-import qutip
-
-from qutip.core import data as _data
-from qutip.core.data import Data, Dense, CSR
-
-
-class TestSolve():
-    def op_numpy(self, A, b):
-        return np.linalg.solve(A, b)
-
-    def _gen_op(self, N, dtype):
-        return qutip.rand_unitary(N, dtype=dtype).data
-
-    def _gen_ket(self, N, dtype):
-        return qutip.rand_ket(N, dtype=dtype).data
-
-    @pytest.mark.parametrize(['method', "opt"], [
-        ("spsolve", {}),
-        ("splu", {"csc": True}),
-        ("gmres", {"atol": 1e-8}),
-        ("lsqr", {}),
-        pytest.param(
-            "mkl_spsolve", {},
-            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
-        ),
-    ],
-        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
-    )
-    def test_mathematically_correct_CSR(self, method, opt):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        A = self._gen_op(10, CSR)
-        b = self._gen_ket(10, Dense)
-        expected = self.op_numpy(A.to_array(), b.to_array())
-        test = _data.solve_csr_dense(A, b, method, opt)
-        test1 = _data.solve(A, b, method, opt)
-
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(test1.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-
-    @pytest.mark.parametrize(['method', "opt"], [
-        ("solve", {}),
-        ("lstsq", {}),
-    ])
-    def test_mathematically_correct_Dense(self, method, opt):
-        A = self._gen_op(10, Dense)
-        b = self._gen_ket(10, Dense)
-        expected = self.op_numpy(A.to_array(), b.to_array())
-        test = _data.solve_dense(A, b, method, opt)
-        test1 = _data.solve(A, b, method, opt)
-
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(test1.to_array(), expected,
-                                   atol=1e-7, rtol=1e-7)
-
-
-    def test_incorrect_shape_non_square(self):
-        A = qutip.Qobj(np.random.rand(5, 10)).data
-        b = qutip.Qobj(np.random.rand(10, 1)).data
-        with pytest.raises(ValueError):
-            test1 = _data.solve(A, b)
-
-
-    def test_incorrect_shape_mismatch(self):
-        A = qutip.Qobj(np.random.rand(10, 10)).data
-        b = qutip.Qobj(np.random.rand(9, 1)).data
-        with pytest.raises(ValueError):
-            test1 = _data.solve(A, b)
-
-
-class TestSVD():
-    def op_numpy(self, A):
-        return np.linalg.svd(A)
-
-    def _gen_dm(self, N, rank, dtype):
-        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
-
-    def _gen_non_square(self, N):
-        mat = np.random.randn(N, N//2)
-        for i in range(N//2):
-            # Ensure no zeros singular values
-            mat[i,i] += 5
-        return _data.Dense(mat)
-
-    @pytest.mark.parametrize("shape", ["square", "non-square"])
-    def test_mathematically_correct_svd(self, shape):
-        if shape == "square":
-            matrix = self._gen_dm(10, 6, Dense)
-        else:
-            matrix = self._gen_non_square(12)
-        u, s, v = self.op_numpy(matrix.to_array())
-        test_U, test_S, test_V = _data.svd(matrix, True)
-        only_S = _data.svd(matrix, False)
-
-        assert sum(test_S > 1e-10) == 6
-        # columns are definied up to a sign
-        np.testing.assert_allclose(
-            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
-        )
-        # rows are definied up to a sign
-        np.testing.assert_allclose(
-            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
-        )
-        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
-        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
-
-        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
-
-        np.testing.assert_allclose(
-            matrix.to_array(),
-            (test_U @ s_as_matrix @ test_V).to_array(),
-            atol=1e-7, rtol=1e-7
-        )
-
-    def test_mathematically_correct_svd_csr(self):
-        rank = 5
-        matrix = self._gen_dm(100, rank, CSR)
-        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
-        test_S2 = _data.svd_csr(matrix, False, k=rank)
-
-        assert len(test_S1) == rank
-        assert len(test_S2) == rank
-
-        np.testing.assert_allclose(
-            matrix.to_array(),
-            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
-            atol=1e-7, rtol=1e-7
-        )
+import qutip.settings as settings
+import numpy as np
+import scipy
+import pytest
+import qutip
+
+from qutip.core import data as _data
+from qutip.core.data import Data, Dense, CSR
+
+
+class TestSolve():
+    def op_numpy(self, A, b):
+        return np.linalg.solve(A, b)
+
+    def _gen_op(self, N, dtype):
+        return qutip.rand_unitary(N, dtype=dtype).data
+
+    def _gen_ket(self, N, dtype):
+        return qutip.rand_ket(N, dtype=dtype).data
+
+    @pytest.mark.parametrize(['method', "opt"], [
+        ("spsolve", {}),
+        ("splu", {"csc": True}),
+        ("gmres", {"atol": 1e-8}),
+        ("lsqr", {}),
+        pytest.param(
+            "mkl_spsolve", {},
+            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
+        ),
+    ],
+        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
+    )
+    def test_mathematically_correct_CSR(self, method, opt):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        A = self._gen_op(10, CSR)
+        b = self._gen_ket(10, Dense)
+        expected = self.op_numpy(A.to_array(), b.to_array())
+        test = _data.solve_csr_dense(A, b, method, opt)
+        test1 = _data.solve(A, b, method, opt)
+
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+        np.testing.assert_allclose(test1.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+
+    @pytest.mark.parametrize(['method', "opt"], [
+        ("solve", {}),
+        ("lstsq", {}),
+    ])
+    def test_mathematically_correct_Dense(self, method, opt):
+        A = self._gen_op(10, Dense)
+        b = self._gen_ket(10, Dense)
+        expected = self.op_numpy(A.to_array(), b.to_array())
+        test = _data.solve_dense(A, b, method, opt)
+        test1 = _data.solve(A, b, method, opt)
+
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+        np.testing.assert_allclose(test1.to_array(), expected,
+                                   atol=1e-7, rtol=1e-7)
+
+
+    def test_incorrect_shape_non_square(self):
+        A = qutip.Qobj(np.random.rand(5, 10)).data
+        b = qutip.Qobj(np.random.rand(10, 1)).data
+        with pytest.raises(ValueError):
+            test1 = _data.solve(A, b)
+
+
+    def test_incorrect_shape_mismatch(self):
+        A = qutip.Qobj(np.random.rand(10, 10)).data
+        b = qutip.Qobj(np.random.rand(9, 1)).data
+        with pytest.raises(ValueError):
+            test1 = _data.solve(A, b)
+
+
+class TestSVD():
+    def op_numpy(self, A):
+        return np.linalg.svd(A)
+
+    def _gen_dm(self, N, rank, dtype):
+        return qutip.rand_dm(N, rank=rank, dtype=dtype).data
+
+    def _gen_non_square(self, N):
+        mat = np.random.randn(N, N//2)
+        for i in range(N//2):
+            # Ensure no zeros singular values
+            mat[i,i] += 5
+        return _data.Dense(mat)
+
+    @pytest.mark.parametrize("shape", ["square", "non-square"])
+    def test_mathematically_correct_svd(self, shape):
+        if shape == "square":
+            matrix = self._gen_dm(10, 6, Dense)
+        else:
+            matrix = self._gen_non_square(12)
+        u, s, v = self.op_numpy(matrix.to_array())
+        test_U, test_S, test_V = _data.svd(matrix, True)
+        only_S = _data.svd(matrix, False)
+
+        assert sum(test_S > 1e-10) == 6
+        # columns are definied up to a sign
+        np.testing.assert_allclose(
+            np.abs(test_U.to_array()), np.abs(u), atol=1e-7, rtol=1e-7
+        )
+        # rows are definied up to a sign
+        np.testing.assert_allclose(
+            np.abs(test_V.to_array()), np.abs(v), atol=1e-7, rtol=1e-7
+        )
+        np.testing.assert_allclose(test_S, s, atol=1e-7, rtol=1e-7)
+        np.testing.assert_allclose(only_S, s, atol=1e-7, rtol=1e-7)
+
+        s_as_matrix = _data.diag(test_S, 0, (test_U.shape[1], test_V.shape[0]))
+
+        np.testing.assert_allclose(
+            matrix.to_array(),
+            (test_U @ s_as_matrix @ test_V).to_array(),
+            atol=1e-7, rtol=1e-7
+        )
+
+    def test_mathematically_correct_svd_csr(self):
+        rank = 5
+        matrix = self._gen_dm(100, rank, CSR)
+        test_U, test_S1, test_V = _data.svd_csr(matrix, True, k=rank)
+        test_S2 = _data.svd_csr(matrix, False, k=rank)
+
+        assert len(test_S1) == rank
+        assert len(test_S2) == rank
+
+        np.testing.assert_allclose(
+            matrix.to_array(),
+            (test_U @ _data.diag(test_S1, 0) @ test_V).to_array(),
+            atol=1e-7, rtol=1e-7
+        )
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index dfe3fe8a02..459ab0d467 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -1,952 +1,952 @@
-import itertools
-import numpy as np
-import scipy
-import pytest
-
-from qutip.core import data
-from qutip.core.data import Data, Dense, CSR
-
-from . import conftest
-
-# The ParameterSet is actually a pretty hidden type, so it's easiest to access
-# it like this.
-_ParameterSet = type(pytest.param())
-
-# First set up a bunch of allowable shapes, for different types of functions so
-# we don't have to respecify a whole lot of things on repeat.
-
-
-def shapes_unary(dim=100):
-    """Base shapes to test for unary functions."""
-    # Be sure to test a full spectrum bra-type, ket-type and square and
-    # non-square operators.  Keep the dimension sensible, particularly for
-    # things like kron, since these shapes are reused to build the shapes for
-    # higher-order functions too.
-    return [
-        pytest.param((1, 1), id="scalar"),
-        pytest.param((1, dim), id="bra"),
-        pytest.param((dim, 1), id="ket"),
-        pytest.param((dim, dim), id="square"),
-        pytest.param((2, dim), id="nonsquare"),
-    ]
-
-
-def shapes_binary_identical(dim=100):
-    """
-    Allowed shapes for binary operators that need the two matrices to be the
-    same shape, e.g. addition.
-    """
-    return [(x, x) for x in shapes_unary(dim)]
-
-
-def shapes_binary_bad_identical(dim=100):
-    """
-    Disallowed shapes for binary operators that need the two matrices to be the
-    same shape, e.g. addition.
-    """
-    return [
-        (x, y)
-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-        if x.values[0] != y.values[0]
-    ]
-
-
-def shapes_binary_unrestricted(dim=100):
-    """
-    Allowed shapes for binary operators which can take any shapes, e.g. the
-    Kronecker product.
-    """
-    return list(itertools.product(shapes_unary(dim), repeat=2))
-
-
-def shapes_binary_bad_unrestricted(dim=100):
-    """
-    Disallowed shapes for binary operators which can take any shapes, e.g. the
-    Kronecker product.  There aren't actually any of these, but we keep it just
-    for consistency.
-    """
-    return []
-
-
-def shapes_binary_matmul(dim=100):
-    """
-    Allowed shapes for "matmul"-like operators that require that the "inner"
-    two indices are equal, i.e. the columns on the left equal the rows on the
-    right.
-    """
-    return [
-        (x, y)
-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-        if x.values[0][1] == y.values[0][0]
-    ]
-
-
-def shapes_binary_bad_matmul(dim=100):
-    """
-    Disallowed shapes for "matmul"-like operators that require that the "inner"
-    two indices are equal, i.e. the columns on the left equal the rows on the
-    right.
-    """
-    return [
-        (x, y)
-        for x, y in itertools.product(shapes_unary(dim), repeat=2)
-        if x.values[0][1] != y.values[0][0]
-    ]
-
-
-def shapes_square(dim=100):
-    """Allowed shapes for operations that require square matrices. Examples of
-    these operations are trace, pow, expm and the trace norm."""
-    return [
-        (pytest.param((1, 1), id="1"),),
-        (pytest.param((dim, dim), id=str(dim)),),
-    ]
-
-
-def shapes_not_square(dim=100):
-    """Disallowed shapes for operations that require square matrices. Examples
-    of these operations are trace, pow, expm and the trace norm."""
-    return [
-        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
-    ]
-
-
-# Set up the special cases for each type of matrix that will be tested.  These
-# should be kept low, because mathematical operations will test a Cartesian
-# product of all the cases of the same order as the operation, which can get
-# very large very fast.  The operations should each complete in a small amount
-# of time, so having 10000+ tests in this file still ought to take less than 2
-# minutes, but it's easy to accidentally add orders of magnitude on.
-#
-# There is a layer of indirection---the cases are returned as 0-ary generator
-# closures---for two reasons:
-#   1. we don't have to store huge amounts of data at test collection time, but
-#      the matrices are only generated, and subsequently freed, within in each
-#      individual test.
-#   2. each test can be repeated, and new random matrices will be generated for
-#      each repeat, rather than re-using the same set.  This is somewhat
-#      "defeating" pytest fixtures, but here we're not worried about re-usable
-#      inputs, we just want the managed parametrisation.
-
-def cases_csr(shape):
-    """
-    Return a list of generators of the different special cases for CSR
-    matrices of a given shape.
-    """
-    def factory(density, sort):
-        return lambda: conftest.random_csr(shape, density, sort)
-
-    def zero_factory():
-        return lambda: data.csr.zeros(shape[0], shape[1])
-    return [
-        pytest.param(factory(0.001, True), id="sparse"),
-        pytest.param(factory(0.8, True), id="filled,sorted"),
-        pytest.param(factory(0.8, False), id="filled,unsorted"),
-        pytest.param(zero_factory(), id="zero"),
-    ]
-
-
-def cases_dense(shape):
-    """
-    Return a list of generators of the different special cases for Dense
-    matrices of a given shape.
-    """
-    def factory(fortran):
-        return lambda: conftest.random_dense(shape, fortran)
-    return [
-        pytest.param(factory(False), id="C"),
-        pytest.param(factory(True), id="Fortran"),
-    ]
-
-
-# Factory methods for generating the cases, mapping type to the function.
-# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
-# getting just a single case from each.
-_ALL_CASES = {
-    CSR: cases_csr,
-    Dense: cases_dense,
-}
-_RANDOM = {
-    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
-    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
-}
-
-
-def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
-    """
-    Return a list of `pytest.ParameterSet` which is a flat list of all the
-    special cases that should be tested for this operator specialisation `op`,
-    which takes in several types `types`, where the arguments have shapes taken
-    from the iterable of iterables `shapes`.  If `out_type` is specified, it
-    will be added into the output parameter set and its name added to the id,
-    but is otherwise not used.
-
-    Parameters
-    ----------
-    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
-        Mapping to get the special case generator from.  This is one of
-        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
-        from the case generator should all be closures of the form `() -> Data`
-        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
-        containing exactly one value, which is the same closure type.
-
-    op: Function
-        The specialisation of a mathematical operation that is being tested.
-        This is actually generally unused - it's just added in to the output
-        ParameterSet at the end so that it will get correctly parametrised.
-
-    types: Tuple[Type]
-        A tuple of data.Data subclass types (not instances).  This defines the
-        inputs to this particular specialisation under test.  There should be
-        as many types as there are Data arguments to `op`.
-
-    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
-        An iterable containing several sets of shapes to parameterise over.
-        Each element of the iterable should be s tuple of shapes, or
-        `pytest.ParameterSet` instances each containing a single shape.  A
-        shape is a 2-tuple of integers.  There should be as many elements of
-        this inner tuple as there are `types`, since each individual `shape`
-        goes with a `type`.
-
-    out_type: Type
-        The output type for this specialisation.  Not used other than its name
-        being added to the id, and it being added at the end of the
-        specialisation (if it is given), similarly to `op`.
-
-    Returns
-    -------
-    List[ParameterSet]
-        A list of individual test cases for parametrisation.  Each ParameterSet
-        will be
-            [op, *data_inputs, ?out_type]
-        where `data_inputs` is of the same length as the input parameter
-        `types` and represents the Data arguments to the specialisation `op`.
-        Each element of `data_inputs` is a generator function which takes no
-        arguments and returns a data.Data subclass of the correct type and
-        shape.  `out_type` is present in the output only if it were given as a
-        parameter itself.
-    """
-    def case(type_, shape_case, generator_case):
-        """
-        Build a case parameter for _one_ generator function which will return
-        a given type and shape.
-        """
-        id_ = type_.__name__
-        inner = ""
-        for extra in [shape_case, generator_case]:
-            if hasattr(extra, 'id') and extra.id:
-                inner += ("," if inner else "") + extra.id
-        if inner:
-            id_ += "[" + inner + "]"
-        func = (
-            generator_case.values[0]
-            if isinstance(generator_case, _ParameterSet)
-            else generator_case
-        )
-        return pytest.param(func, id=id_)
-
-    cases = []
-    for shapes_ in shapes:
-        # Convert the list of types into a list of lists of the special cases
-        # needed for each type.
-        matrix_cases = [
-            [case(type_, shape_case, type_case)
-             for type_case in cases_lookup[type_](shape_case.values[0])]
-            for type_, shape_case in zip(types, shapes_)
-        ]
-        # Now Cartesian product all the special cases together to make the full
-        # set of parametrisations.
-        for matrices in itertools.product(*matrix_cases):
-            id_ = ",".join(m.id for m in matrices)
-            args = [m for p_m in matrices for m in p_m.values]
-            if out_type is not None:
-                id_ += "->" + out_type.__name__
-                args += [out_type]
-            cases.append(pytest.param(op, *args, id=id_))
-    return cases
-
-
-# Now we start to actually build up all the test cases.  Since all the
-# mathematical operations are really pretty similar, and most just need the
-# basic testing functionality, we do this with a series of mix-in classes which
-# provide various components of the testing and test-generation infrastructure.
-#
-# In each, we use the idiom that "test_<x>" is a test function which pytest
-# will collect for us, and "generate_<x>" a method which will be called by
-# `pytest_generate_tests` in order to generate all the parametrisations for the
-# given test.
-
-class _GenericOpMixin:
-    """
-    Abstract base mix-in which sets up the test generation for the two basic
-    test operations, and puts in the very generic test generator.  This does
-    not actually define the tests themselves, because subclasses need to define
-    them so the method arguments can be introspected to parametrise over the
-    correct number of arguments.
-
-    The tests `mathematically_correct` and `incorrect_shape_raises` will
-    parametrise Data types over method arguments which have names `data_*`.
-
-    The class arguments defined here are effectively parametrising the
-    mathematical tests.
-
-    Attributes
-    ----------
-    op_numpy: *args -> np.ndarray
-        Function which takes the same arguments as the mathematical operation,
-        but with all data arguments numpy arrays, and returns the expected
-        result.
-
-    atol: float
-        The absolute tolerance to use when comparing the test value with the
-        expected value.  If the output is a Data type, the tolerance is
-        per-element of the output.
-
-    rtol: float
-        The relative tolerance to use when comparing the test value with the
-        expected value.  If the output is a Data type, the tolerance is
-        per-element of the output.
-
-    shapes: list of (list of shapes)
-        A list of the sets of shapes which should be used for the tests of
-        mathematical correctness.  Each element of the list is a set of shapes,
-        each one corresponding to one of the arguments of the operation.
-
-    bad_shapes: list of (list of shapes)
-        Similar to `shapes`, but these should be shapes which are invalid for
-        the given mathematical operation.
-
-    specialisations: list of (function, Type, Type, [Type, ...])
-        The specialisations of each mathematical function, and the types that
-        it takes in and returns.  For example, the function
-            add(CSR, Dense) -> Other
-        would be specified as `(add, CSR, Dense, Other)`.
-    """
-    def op_numpy(self, *args): raise NotImplementedError
-    # With dimensions of around 100, we have to account for floating-point
-    # addition not being associative; the maths on full numpy arrays will often
-    # produce slightly different results to sparse algebra, since the order of
-    # multiplications and additions will be different.
-    atol = 1e-10
-    rtol = 1e-7  # Same default as numpy
-    shapes = []
-    bad_shapes = []
-    specialisations = []
-
-    def generate_mathematically_correct(self, metafunc):
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-            + ['out_type']
-        )
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, out_type = p_op.values
-            args = (op, types, self.shapes, out_type)
-            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
-        metafunc.parametrize(parameters, cases)
-
-    def generate_incorrect_shape_raises(self, metafunc):
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-        )
-        if not self.bad_shapes:
-            reason = "".join([
-                "no shapes are 'incorrect' for ",
-                metafunc.cls.__name__,
-                "::",
-                metafunc.function.__name__,
-            ])
-            false_case = pytest.param(*([None]*len(parameters)),
-                                      marks=pytest.mark.skip(reason),
-                                      id="no test")
-            metafunc.parametrize(parameters, [false_case])
-            return
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, _ = p_op.values
-            args = (op, types, self.bad_shapes)
-            cases.extend(cases_type_shape_product(_RANDOM, *args))
-        metafunc.parametrize(parameters, cases)
-
-    def pytest_generate_tests(self, metafunc):
-        # For every test function "test_xyz", we use the test generator
-        # "generate_xyz" if it exists.  This allows derived classes to add
-        # their own tests and generators without overiding this method, cutting
-        # down on boilerplate, but also that derived classes _may_ override the
-        # generation of tests defined in a base class, say if they have
-        # additional special arguments that need parametrising over.
-        generator_name = (
-            "generate_"
-            + metafunc.function.__name__.replace("test_", "")
-        )
-        try:
-            generator = getattr(self, generator_name)
-        except AttributeError:
-            return
-        generator(metafunc)
-
-
-class UnaryOpMixin(_GenericOpMixin):
-    """
-    Mix-in for unary mathematical operations on Data instances (e.g. unary
-    negation).
-    """
-    shapes = [(x,) for x in shapes_unary()]
-    bad_shapes = []
-
-    def test_mathematically_correct(self, op, data_m, out_type):
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array())
-        test = op(matrix)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        elif out_type is list:
-            for test_, expected_ in zip(test, expected):
-                assert test_.shape == expected_.shape
-                np.testing.assert_allclose(test_.to_array(), expected_,
-                                           atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_m):
-        """
-        Test that the operation produces a suitable error if the shape of the
-        given operand is not compatible with the operation. Useful for
-        operations that require square matrices (trace, pow, ...).
-        """
-        with pytest.raises(ValueError):
-            op(data_m())
-
-
-class UnaryScalarOpMixin(_GenericOpMixin):
-    """
-    Mix-in for unary mathematical operations on Data instances, but that also
-    take in a numeric scalar (e.g. scalar multiplication).  Only generates
-    the test `mathematically_correct`, since there can't be a shape mismatch
-    when there's only one Data argument.
-    """
-    shapes = [(x,) for x in shapes_unary()]
-
-    @pytest.mark.parametrize('scalar', [
-        pytest.param(0, id='zero'),
-        pytest.param(4.5, id='real'),
-        pytest.param(3j, id='complex'),
-    ])
-    def test_mathematically_correct(self, op, data_m, scalar, out_type):
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), scalar)
-        test = op(matrix, scalar)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol,
-                                       rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class BinaryOpMixin(_GenericOpMixin):
-    """
-    Mix-in for binary mathematical operations on Data instances (e.g. binary
-    addition).
-    """
-    def test_mathematically_correct(self, op, data_l, data_r, out_type):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        left, right = data_l(), data_r()
-        expected = self.op_numpy(left.to_array(), right.to_array())
-        test = op(left, right)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_l, data_r):
-        """
-        Test that the operation produces a suitable error if the shapes of the
-        given operands are not compatible.
-        """
-        with pytest.raises(ValueError):
-            op(data_l(), data_r())
-
-
-class TernaryOpMixin(_GenericOpMixin):
-    """
-    Mix-in for ternary mathematical operations on Data instances (e.g. inner
-    product with an operator in the middle).  This is pretty rare.
-    """
-    def test_mathematically_correct(self, op,
-                                    data_l, data_m, data_r,
-                                    out_type):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        left, mid, right = data_l(), data_m(), data_r()
-        expected = self.op_numpy(left.to_array(),
-                                 mid.to_array(),
-                                 right.to_array())
-        test = op(left, mid, right)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
-        """
-        Test that the operation produces a suitable error if the shapes of the
-        given operands are not compatible.
-        """
-        with pytest.raises(ValueError):
-            op(data_l(), data_m(), data_r())
-
-
-# And now finally we get into the meat of the actual mathematical tests.
-
-class TestAdd(BinaryOpMixin):
-    def op_numpy(self, left, right, scale):
-        return np.add(left, scale * right)
-
-    shapes = shapes_binary_identical()
-    bad_shapes = shapes_binary_bad_identical()
-    specialisations = [
-        pytest.param(data.add_csr, CSR, CSR, CSR),
-        pytest.param(data.add_dense, Dense, Dense, Dense),
-    ]
-
-    # `add` has an additional scalar parameter, because the operation is
-    # actually more like `A + c*B`.  We just parametrise that scalar
-    # separately.
-    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
-                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
-    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
-        """
-        Test that the binary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        left, right = data_l(), data_r()
-        if scale is not None:
-            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
-            test = op(left, right, scale)
-        else:
-            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
-            test = op(left, right)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class TestAdjoint(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.conj(matrix.T)
-
-    specialisations = [
-        pytest.param(data.adjoint_csr, CSR, CSR),
-        pytest.param(data.adjoint_dense, Dense, Dense),
-    ]
-
-
-class TestConj(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.conj(matrix)
-
-    specialisations = [
-        pytest.param(data.conj_csr, CSR, CSR),
-        pytest.param(data.conj_dense, Dense, Dense),
-    ]
-
-
-class TestInner(BinaryOpMixin):
-    # The inner product is a bit more specialist, since it has to handle inputs
-    # in a 1D space specially.  In order to keep things simple, we just
-    # generate those test cases completely separately from the standard
-    # `mathematically_correct`.
-
-    def op_numpy(self, left, right, scalar_is_ket=False):
-        if left.shape[1] == 1:
-            if left.shape[0] != 1 or scalar_is_ket:
-                left = np.conj(left.T)
-        return (left @ right)[0, 0]
-
-    # These shapes are a little more non-standard.
-    _dim = 100
-    _scalar = pytest.param((1, 1), id="scalar")
-    _bra = pytest.param((1, _dim), id="bra")
-    _ket = pytest.param((_dim, 1), id="ket")
-    _op = pytest.param((_dim, _dim), id="square")
-    shapes = [
-        (_bra, _ket),
-        (_ket, _ket),
-    ]
-    bad_shapes = [
-        (_bra, _bra),
-        (_ket, _bra),
-        (_op, _ket),
-        (_op, _bra),
-        (_bra, _op),
-        (_ket, _op),
-    ]
-
-    specialisations = [
-        pytest.param(data.inner_csr, CSR, CSR, complex),
-        pytest.param(data.inner_dense, Dense, Dense, complex),
-    ]
-
-    def generate_scalar_is_ket(self, metafunc):
-        # For 1D subspaces, the special cases don't really matter since there's
-        # only really one type of matrix available, so this is parametrised
-        # with only case for each input argument.
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-            + ['out_type']
-        )
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, out_type = p_op.values
-            args = (op, types, [(self._scalar, self._scalar)], out_type)
-            cases.extend(cases_type_shape_product(_RANDOM, *args))
-        metafunc.parametrize(parameters, cases)
-        metafunc.parametrize('scalar_is_ket',
-                             [True, False],
-                             ids=["ket", "bra"])
-
-    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
-        left, right = data_l(), data_r()
-        expected = self.op_numpy(left.to_array(), right.to_array(),
-                                 scalar_is_ket)
-        test = op(left, right, scalar_is_ket)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol, rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class TestInnerOp(TernaryOpMixin):
-    # This is very very similar to TestInner.
-    def op_numpy(self, left, mid, right, scalar_is_ket=False):
-        if left.shape[1] == 1:
-            if left.shape[0] != 1 or scalar_is_ket:
-                left = np.conj(left.T)
-        return (left @ mid @ right)[0, 0]
-
-    _dim = 100
-    _scalar = pytest.param((1, 1), id="scalar")
-    _bra = pytest.param((1, _dim), id="bra")
-    _ket = pytest.param((_dim, 1), id="ket")
-    _op = pytest.param((_dim, _dim), id="square")
-    shapes = [
-        (_bra, _op, _ket),
-        (_ket, _op, _ket),
-    ]
-    bad_shapes = [
-        (_bra, _op, _bra),
-        (_ket, _op, _bra),
-        (_op, _op, _ket),
-        (_op, _op, _bra),
-        (_bra, _op, _op),
-        (_ket, _op, _op),
-        (_bra, _bra, _ket),
-        (_ket, _bra, _ket),
-        (_bra, _ket, _ket),
-        (_ket, _ket, _ket),
-    ]
-
-    specialisations = [
-        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
-        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
-    ]
-
-    def generate_scalar_is_ket(self, metafunc):
-        parameters = (
-            ['op']
-            + [x for x in metafunc.fixturenames
-               if x.startswith("data_")]
-            + ['out_type']
-        )
-        cases = []
-        for p_op in self.specialisations:
-            op, *types, out_type = p_op.values
-            args = (op, types, [(self._scalar,) * 3], out_type)
-            cases.extend(cases_type_shape_product(_RANDOM, *args))
-        metafunc.parametrize(parameters, cases)
-        metafunc.parametrize('scalar_is_ket',
-                             [True, False], ids=["ket", "bra"])
-
-    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
-                           scalar_is_ket):
-        left, mid, right = data_l(), data_m(), data_r()
-        expected = self.op_numpy(left.to_array(),
-                                 mid.to_array(),
-                                 right.to_array(),
-                                 scalar_is_ket)
-        test = op(left, mid, right, scalar_is_ket)
-        assert isinstance(test, out_type)
-        if issubclass(out_type, Data):
-            assert test.shape == expected.shape
-            np.testing.assert_allclose(test.to_array(), expected,
-                                       atol=self.atol,
-                                       rtol=self.rtol)
-        else:
-            np.testing.assert_allclose(test, expected, atol=self.atol,
-                                       rtol=self.rtol)
-
-
-class TestKron(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return np.kron(left, right)
-
-    # Keep the dimension low because kron can get very expensive.
-    shapes = shapes_binary_unrestricted(dim=5)
-    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
-    specialisations = [
-        pytest.param(data.kron_csr, CSR, CSR, CSR),
-        pytest.param(data.kron_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestMatmul(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return np.matmul(left, right)
-
-    shapes = shapes_binary_matmul()
-    bad_shapes = shapes_binary_bad_matmul()
-    specialisations = [
-        pytest.param(data.matmul_csr, CSR, CSR, CSR),
-        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
-        pytest.param(data.matmul_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestMultiply(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return left * right
-
-    shapes = shapes_binary_identical()
-    bad_shapes = shapes_binary_bad_identical()
-    specialisations = [
-        pytest.param(data.multiply_csr, CSR, CSR, CSR),
-        pytest.param(data.multiply_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestMul(UnaryScalarOpMixin):
-    def op_numpy(self, matrix, scalar):
-        return scalar * matrix
-
-    specialisations = [
-        pytest.param(data.mul_csr, CSR, CSR),
-        pytest.param(data.mul_dense, Dense, Dense),
-    ]
-
-
-class TestNeg(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return -matrix
-
-    specialisations = [
-        pytest.param(data.neg_csr, CSR, CSR),
-        pytest.param(data.neg_dense, Dense, Dense),
-    ]
-
-
-class TestSub(BinaryOpMixin):
-    def op_numpy(self, left, right):
-        return left - right
-
-    shapes = shapes_binary_identical()
-    bad_shapes = shapes_binary_bad_identical()
-    specialisations = [
-        pytest.param(data.sub_csr, CSR, CSR, CSR),
-        pytest.param(data.sub_dense, Dense, Dense, Dense),
-    ]
-
-
-class TestTrace(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.sum(np.diag(matrix))
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.trace_csr, CSR, complex),
-        pytest.param(data.trace_dense, Dense, complex),
-    ]
-
-
-class TestTrace_oper_ket(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        N = int(matrix.shape[0] ** 0.5)
-        return np.sum(np.diag(matrix.reshape((N, N))))
-
-    shapes = [
-        (pytest.param((100, 1), id="oper-ket"),),
-    ]
-    bad_shapes = [
-        (pytest.param((1, 100), id="bra"),),
-        (pytest.param((99, 1), id="ket"),),
-        (pytest.param((99, 99), id="ket"),),
-        (pytest.param((2, 99), id="nonsquare"),),
-    ]
-    specialisations = [
-        pytest.param(data.trace_oper_ket_csr, CSR, complex),
-        pytest.param(data.trace_oper_ket_dense, Dense, complex),
-    ]
-
-
-class TestPow(UnaryOpMixin):
-    def op_numpy(self, matrix, n):
-        return np.linalg.matrix_power(matrix, n)
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.pow_csr, CSR, CSR),
-        pytest.param(data.pow_dense, Dense, Dense),
-    ]
-
-    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
-    def test_mathematically_correct(self, op, data_m, out_type, n):
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), n)
-        test = op(matrix, n)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-                                   rtol=self.rtol)
-
-    # Pow actually does have bad shape, so we put that in too.
-    def test_incorrect_shape_raises(self, op, data_m):
-        """
-        Test that the operation produces a suitable error if the shape is not a
-        square matrix.
-        """
-        with pytest.raises(ValueError):
-            op(data_m(), 10)
-
-
-class TestExpm(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.expm(matrix)
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.expm_csr, CSR, CSR),
-        pytest.param(data.expm_csr_dense, CSR, Dense),
-        pytest.param(data.expm_dense, Dense, Dense),
-    ]
-
-
-class TestLogm(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.logm(matrix)
-
-    shapes = shapes_square()
-    bad_shapes = shapes_not_square()
-    specialisations = [
-        pytest.param(data.logm_dense, Dense, Dense),
-    ]
-
-
-class TestTranspose(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return matrix.T
-
-    specialisations = [
-        pytest.param(data.transpose_csr, CSR, CSR),
-        pytest.param(data.transpose_dense, Dense, Dense),
-    ]
-
-
-class TestProject(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        if matrix.shape[0] == 1:
-            return np.outer(np.conj(matrix), matrix)
-        else:
-            return np.outer(matrix, np.conj(matrix))
-
-    shapes = [
-        (pytest.param((1, 1), id="scalar"),),
-        (pytest.param((1, 100), id="bra"),),
-        (pytest.param((100, 1), id="ket"),),
-    ]
-    bad_shapes = [
-        (pytest.param((10, 10), id="square"),),
-        (pytest.param((2, 10), id="nonsquare"),),
-    ]
-
-    specialisations = [
-        pytest.param(data.project_csr, CSR, CSR),
-        pytest.param(data.project_dense, Dense, Dense),
-    ]
-
-
-def _inv_dense(matrix):
-    # Add a diagonal so `matrix` is not singular
-    return data.inv_dense(
-        data.add(
-            matrix,
-            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
-        )
-    )
-
-
-def _inv_csr(matrix):
-    # Add a diagonal so `matrix` is not singular
-    return data.inv_csr(
-        data.add(
-            matrix,
-            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
-        )
-    )
-
-
-class TestInv(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
-
-    shapes = [
-        (pytest.param((1, 1), id="scalar"),),
-        (pytest.param((10, 10), id="square"),),
-    ]
-    bad_shapes = [
-        (pytest.param((2, 10), id="nonsquare"),),
-        (pytest.param((1, 100), id="bra"),),
-        (pytest.param((100, 1), id="ket"),),
-    ]
-
-    specialisations = [
-        pytest.param(_inv_csr, CSR, CSR),
-        pytest.param(_inv_dense, Dense, Dense),
-    ]
+import itertools
+import numpy as np
+import scipy
+import pytest
+
+from qutip.core import data
+from qutip.core.data import Data, Dense, CSR
+
+from . import conftest
+
+# The ParameterSet is actually a pretty hidden type, so it's easiest to access
+# it like this.
+_ParameterSet = type(pytest.param())
+
+# First set up a bunch of allowable shapes, for different types of functions so
+# we don't have to respecify a whole lot of things on repeat.
+
+
+def shapes_unary(dim=100):
+    """Base shapes to test for unary functions."""
+    # Be sure to test a full spectrum bra-type, ket-type and square and
+    # non-square operators.  Keep the dimension sensible, particularly for
+    # things like kron, since these shapes are reused to build the shapes for
+    # higher-order functions too.
+    return [
+        pytest.param((1, 1), id="scalar"),
+        pytest.param((1, dim), id="bra"),
+        pytest.param((dim, 1), id="ket"),
+        pytest.param((dim, dim), id="square"),
+        pytest.param((2, dim), id="nonsquare"),
+    ]
+
+
+def shapes_binary_identical(dim=100):
+    """
+    Allowed shapes for binary operators that need the two matrices to be the
+    same shape, e.g. addition.
+    """
+    return [(x, x) for x in shapes_unary(dim)]
+
+
+def shapes_binary_bad_identical(dim=100):
+    """
+    Disallowed shapes for binary operators that need the two matrices to be the
+    same shape, e.g. addition.
+    """
+    return [
+        (x, y)
+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+        if x.values[0] != y.values[0]
+    ]
+
+
+def shapes_binary_unrestricted(dim=100):
+    """
+    Allowed shapes for binary operators which can take any shapes, e.g. the
+    Kronecker product.
+    """
+    return list(itertools.product(shapes_unary(dim), repeat=2))
+
+
+def shapes_binary_bad_unrestricted(dim=100):
+    """
+    Disallowed shapes for binary operators which can take any shapes, e.g. the
+    Kronecker product.  There aren't actually any of these, but we keep it just
+    for consistency.
+    """
+    return []
+
+
+def shapes_binary_matmul(dim=100):
+    """
+    Allowed shapes for "matmul"-like operators that require that the "inner"
+    two indices are equal, i.e. the columns on the left equal the rows on the
+    right.
+    """
+    return [
+        (x, y)
+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+        if x.values[0][1] == y.values[0][0]
+    ]
+
+
+def shapes_binary_bad_matmul(dim=100):
+    """
+    Disallowed shapes for "matmul"-like operators that require that the "inner"
+    two indices are equal, i.e. the columns on the left equal the rows on the
+    right.
+    """
+    return [
+        (x, y)
+        for x, y in itertools.product(shapes_unary(dim), repeat=2)
+        if x.values[0][1] != y.values[0][0]
+    ]
+
+
+def shapes_square(dim=100):
+    """Allowed shapes for operations that require square matrices. Examples of
+    these operations are trace, pow, expm and the trace norm."""
+    return [
+        (pytest.param((1, 1), id="1"),),
+        (pytest.param((dim, dim), id=str(dim)),),
+    ]
+
+
+def shapes_not_square(dim=100):
+    """Disallowed shapes for operations that require square matrices. Examples
+    of these operations are trace, pow, expm and the trace norm."""
+    return [
+        (x,) for x in shapes_unary(dim) if x.values[0][0] != x.values[0][1]
+    ]
+
+
+# Set up the special cases for each type of matrix that will be tested.  These
+# should be kept low, because mathematical operations will test a Cartesian
+# product of all the cases of the same order as the operation, which can get
+# very large very fast.  The operations should each complete in a small amount
+# of time, so having 10000+ tests in this file still ought to take less than 2
+# minutes, but it's easy to accidentally add orders of magnitude on.
+#
+# There is a layer of indirection---the cases are returned as 0-ary generator
+# closures---for two reasons:
+#   1. we don't have to store huge amounts of data at test collection time, but
+#      the matrices are only generated, and subsequently freed, within in each
+#      individual test.
+#   2. each test can be repeated, and new random matrices will be generated for
+#      each repeat, rather than re-using the same set.  This is somewhat
+#      "defeating" pytest fixtures, but here we're not worried about re-usable
+#      inputs, we just want the managed parametrisation.
+
+def cases_csr(shape):
+    """
+    Return a list of generators of the different special cases for CSR
+    matrices of a given shape.
+    """
+    def factory(density, sort):
+        return lambda: conftest.random_csr(shape, density, sort)
+
+    def zero_factory():
+        return lambda: data.csr.zeros(shape[0], shape[1])
+    return [
+        pytest.param(factory(0.001, True), id="sparse"),
+        pytest.param(factory(0.8, True), id="filled,sorted"),
+        pytest.param(factory(0.8, False), id="filled,unsorted"),
+        pytest.param(zero_factory(), id="zero"),
+    ]
+
+
+def cases_dense(shape):
+    """
+    Return a list of generators of the different special cases for Dense
+    matrices of a given shape.
+    """
+    def factory(fortran):
+        return lambda: conftest.random_dense(shape, fortran)
+    return [
+        pytest.param(factory(False), id="C"),
+        pytest.param(factory(True), id="Fortran"),
+    ]
+
+
+# Factory methods for generating the cases, mapping type to the function.
+# _ALL_CASES is for getting all the special cases to test, _RANDOM is for
+# getting just a single case from each.
+_ALL_CASES = {
+    CSR: cases_csr,
+    Dense: cases_dense,
+}
+_RANDOM = {
+    CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
+    Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
+}
+
+
+def cases_type_shape_product(cases_lookup, op, types, shapes, out_type=None):
+    """
+    Return a list of `pytest.ParameterSet` which is a flat list of all the
+    special cases that should be tested for this operator specialisation `op`,
+    which takes in several types `types`, where the arguments have shapes taken
+    from the iterable of iterables `shapes`.  If `out_type` is specified, it
+    will be added into the output parameter set and its name added to the id,
+    but is otherwise not used.
+
+    Parameters
+    ----------
+    cases_lookup: Map[Type, (shape: 2-tuple) -> list]
+        Mapping to get the special case generator from.  This is one of
+        _ALL_CASES or _RANDOM (or similar).  The elements of the list returned
+        from the case generator should all be closures of the form `() -> Data`
+        (e.g. `lambda: data.csr.identity(10)`), or a `pytest.ParameterSet`
+        containing exactly one value, which is the same closure type.
+
+    op: Function
+        The specialisation of a mathematical operation that is being tested.
+        This is actually generally unused - it's just added in to the output
+        ParameterSet at the end so that it will get correctly parametrised.
+
+    types: Tuple[Type]
+        A tuple of data.Data subclass types (not instances).  This defines the
+        inputs to this particular specialisation under test.  There should be
+        as many types as there are Data arguments to `op`.
+
+    shapes: Iterable[Tuple[(int, int) | ParameterSet[(int, int)]]]
+        An iterable containing several sets of shapes to parameterise over.
+        Each element of the iterable should be s tuple of shapes, or
+        `pytest.ParameterSet` instances each containing a single shape.  A
+        shape is a 2-tuple of integers.  There should be as many elements of
+        this inner tuple as there are `types`, since each individual `shape`
+        goes with a `type`.
+
+    out_type: Type
+        The output type for this specialisation.  Not used other than its name
+        being added to the id, and it being added at the end of the
+        specialisation (if it is given), similarly to `op`.
+
+    Returns
+    -------
+    List[ParameterSet]
+        A list of individual test cases for parametrisation.  Each ParameterSet
+        will be
+            [op, *data_inputs, ?out_type]
+        where `data_inputs` is of the same length as the input parameter
+        `types` and represents the Data arguments to the specialisation `op`.
+        Each element of `data_inputs` is a generator function which takes no
+        arguments and returns a data.Data subclass of the correct type and
+        shape.  `out_type` is present in the output only if it were given as a
+        parameter itself.
+    """
+    def case(type_, shape_case, generator_case):
+        """
+        Build a case parameter for _one_ generator function which will return
+        a given type and shape.
+        """
+        id_ = type_.__name__
+        inner = ""
+        for extra in [shape_case, generator_case]:
+            if hasattr(extra, 'id') and extra.id:
+                inner += ("," if inner else "") + extra.id
+        if inner:
+            id_ += "[" + inner + "]"
+        func = (
+            generator_case.values[0]
+            if isinstance(generator_case, _ParameterSet)
+            else generator_case
+        )
+        return pytest.param(func, id=id_)
+
+    cases = []
+    for shapes_ in shapes:
+        # Convert the list of types into a list of lists of the special cases
+        # needed for each type.
+        matrix_cases = [
+            [case(type_, shape_case, type_case)
+             for type_case in cases_lookup[type_](shape_case.values[0])]
+            for type_, shape_case in zip(types, shapes_)
+        ]
+        # Now Cartesian product all the special cases together to make the full
+        # set of parametrisations.
+        for matrices in itertools.product(*matrix_cases):
+            id_ = ",".join(m.id for m in matrices)
+            args = [m for p_m in matrices for m in p_m.values]
+            if out_type is not None:
+                id_ += "->" + out_type.__name__
+                args += [out_type]
+            cases.append(pytest.param(op, *args, id=id_))
+    return cases
+
+
+# Now we start to actually build up all the test cases.  Since all the
+# mathematical operations are really pretty similar, and most just need the
+# basic testing functionality, we do this with a series of mix-in classes which
+# provide various components of the testing and test-generation infrastructure.
+#
+# In each, we use the idiom that "test_<x>" is a test function which pytest
+# will collect for us, and "generate_<x>" a method which will be called by
+# `pytest_generate_tests` in order to generate all the parametrisations for the
+# given test.
+
+class _GenericOpMixin:
+    """
+    Abstract base mix-in which sets up the test generation for the two basic
+    test operations, and puts in the very generic test generator.  This does
+    not actually define the tests themselves, because subclasses need to define
+    them so the method arguments can be introspected to parametrise over the
+    correct number of arguments.
+
+    The tests `mathematically_correct` and `incorrect_shape_raises` will
+    parametrise Data types over method arguments which have names `data_*`.
+
+    The class arguments defined here are effectively parametrising the
+    mathematical tests.
+
+    Attributes
+    ----------
+    op_numpy: *args -> np.ndarray
+        Function which takes the same arguments as the mathematical operation,
+        but with all data arguments numpy arrays, and returns the expected
+        result.
+
+    atol: float
+        The absolute tolerance to use when comparing the test value with the
+        expected value.  If the output is a Data type, the tolerance is
+        per-element of the output.
+
+    rtol: float
+        The relative tolerance to use when comparing the test value with the
+        expected value.  If the output is a Data type, the tolerance is
+        per-element of the output.
+
+    shapes: list of (list of shapes)
+        A list of the sets of shapes which should be used for the tests of
+        mathematical correctness.  Each element of the list is a set of shapes,
+        each one corresponding to one of the arguments of the operation.
+
+    bad_shapes: list of (list of shapes)
+        Similar to `shapes`, but these should be shapes which are invalid for
+        the given mathematical operation.
+
+    specialisations: list of (function, Type, Type, [Type, ...])
+        The specialisations of each mathematical function, and the types that
+        it takes in and returns.  For example, the function
+            add(CSR, Dense) -> Other
+        would be specified as `(add, CSR, Dense, Other)`.
+    """
+    def op_numpy(self, *args): raise NotImplementedError
+    # With dimensions of around 100, we have to account for floating-point
+    # addition not being associative; the maths on full numpy arrays will often
+    # produce slightly different results to sparse algebra, since the order of
+    # multiplications and additions will be different.
+    atol = 1e-10
+    rtol = 1e-7  # Same default as numpy
+    shapes = []
+    bad_shapes = []
+    specialisations = []
+
+    def generate_mathematically_correct(self, metafunc):
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+            + ['out_type']
+        )
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, out_type = p_op.values
+            args = (op, types, self.shapes, out_type)
+            cases.extend(cases_type_shape_product(_ALL_CASES, *args))
+        metafunc.parametrize(parameters, cases)
+
+    def generate_incorrect_shape_raises(self, metafunc):
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+        )
+        if not self.bad_shapes:
+            reason = "".join([
+                "no shapes are 'incorrect' for ",
+                metafunc.cls.__name__,
+                "::",
+                metafunc.function.__name__,
+            ])
+            false_case = pytest.param(*([None]*len(parameters)),
+                                      marks=pytest.mark.skip(reason),
+                                      id="no test")
+            metafunc.parametrize(parameters, [false_case])
+            return
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, _ = p_op.values
+            args = (op, types, self.bad_shapes)
+            cases.extend(cases_type_shape_product(_RANDOM, *args))
+        metafunc.parametrize(parameters, cases)
+
+    def pytest_generate_tests(self, metafunc):
+        # For every test function "test_xyz", we use the test generator
+        # "generate_xyz" if it exists.  This allows derived classes to add
+        # their own tests and generators without overiding this method, cutting
+        # down on boilerplate, but also that derived classes _may_ override the
+        # generation of tests defined in a base class, say if they have
+        # additional special arguments that need parametrising over.
+        generator_name = (
+            "generate_"
+            + metafunc.function.__name__.replace("test_", "")
+        )
+        try:
+            generator = getattr(self, generator_name)
+        except AttributeError:
+            return
+        generator(metafunc)
+
+
+class UnaryOpMixin(_GenericOpMixin):
+    """
+    Mix-in for unary mathematical operations on Data instances (e.g. unary
+    negation).
+    """
+    shapes = [(x,) for x in shapes_unary()]
+    bad_shapes = []
+
+    def test_mathematically_correct(self, op, data_m, out_type):
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array())
+        test = op(matrix)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        elif out_type is list:
+            for test_, expected_ in zip(test, expected):
+                assert test_.shape == expected_.shape
+                np.testing.assert_allclose(test_.to_array(), expected_,
+                                           atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_m):
+        """
+        Test that the operation produces a suitable error if the shape of the
+        given operand is not compatible with the operation. Useful for
+        operations that require square matrices (trace, pow, ...).
+        """
+        with pytest.raises(ValueError):
+            op(data_m())
+
+
+class UnaryScalarOpMixin(_GenericOpMixin):
+    """
+    Mix-in for unary mathematical operations on Data instances, but that also
+    take in a numeric scalar (e.g. scalar multiplication).  Only generates
+    the test `mathematically_correct`, since there can't be a shape mismatch
+    when there's only one Data argument.
+    """
+    shapes = [(x,) for x in shapes_unary()]
+
+    @pytest.mark.parametrize('scalar', [
+        pytest.param(0, id='zero'),
+        pytest.param(4.5, id='real'),
+        pytest.param(3j, id='complex'),
+    ])
+    def test_mathematically_correct(self, op, data_m, scalar, out_type):
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), scalar)
+        test = op(matrix, scalar)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol,
+                                       rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class BinaryOpMixin(_GenericOpMixin):
+    """
+    Mix-in for binary mathematical operations on Data instances (e.g. binary
+    addition).
+    """
+    def test_mathematically_correct(self, op, data_l, data_r, out_type):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        left, right = data_l(), data_r()
+        expected = self.op_numpy(left.to_array(), right.to_array())
+        test = op(left, right)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_l, data_r):
+        """
+        Test that the operation produces a suitable error if the shapes of the
+        given operands are not compatible.
+        """
+        with pytest.raises(ValueError):
+            op(data_l(), data_r())
+
+
+class TernaryOpMixin(_GenericOpMixin):
+    """
+    Mix-in for ternary mathematical operations on Data instances (e.g. inner
+    product with an operator in the middle).  This is pretty rare.
+    """
+    def test_mathematically_correct(self, op,
+                                    data_l, data_m, data_r,
+                                    out_type):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        left, mid, right = data_l(), data_m(), data_r()
+        expected = self.op_numpy(left.to_array(),
+                                 mid.to_array(),
+                                 right.to_array())
+        test = op(left, mid, right)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_l, data_m, data_r):
+        """
+        Test that the operation produces a suitable error if the shapes of the
+        given operands are not compatible.
+        """
+        with pytest.raises(ValueError):
+            op(data_l(), data_m(), data_r())
+
+
+# And now finally we get into the meat of the actual mathematical tests.
+
+class TestAdd(BinaryOpMixin):
+    def op_numpy(self, left, right, scale):
+        return np.add(left, scale * right)
+
+    shapes = shapes_binary_identical()
+    bad_shapes = shapes_binary_bad_identical()
+    specialisations = [
+        pytest.param(data.add_csr, CSR, CSR, CSR),
+        pytest.param(data.add_dense, Dense, Dense, Dense),
+    ]
+
+    # `add` has an additional scalar parameter, because the operation is
+    # actually more like `A + c*B`.  We just parametrise that scalar
+    # separately.
+    @pytest.mark.parametrize('scale', [None, 0.2, 0.5j],
+                             ids=['unscaled', 'scale[real]', 'scale[complex]'])
+    def test_mathematically_correct(self, op, data_l, data_r, out_type, scale):
+        """
+        Test that the binary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        left, right = data_l(), data_r()
+        if scale is not None:
+            expected = self.op_numpy(left.to_array(), right.to_array(), scale)
+            test = op(left, right, scale)
+        else:
+            expected = self.op_numpy(left.to_array(), right.to_array(), 1)
+            test = op(left, right)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class TestAdjoint(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.conj(matrix.T)
+
+    specialisations = [
+        pytest.param(data.adjoint_csr, CSR, CSR),
+        pytest.param(data.adjoint_dense, Dense, Dense),
+    ]
+
+
+class TestConj(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.conj(matrix)
+
+    specialisations = [
+        pytest.param(data.conj_csr, CSR, CSR),
+        pytest.param(data.conj_dense, Dense, Dense),
+    ]
+
+
+class TestInner(BinaryOpMixin):
+    # The inner product is a bit more specialist, since it has to handle inputs
+    # in a 1D space specially.  In order to keep things simple, we just
+    # generate those test cases completely separately from the standard
+    # `mathematically_correct`.
+
+    def op_numpy(self, left, right, scalar_is_ket=False):
+        if left.shape[1] == 1:
+            if left.shape[0] != 1 or scalar_is_ket:
+                left = np.conj(left.T)
+        return (left @ right)[0, 0]
+
+    # These shapes are a little more non-standard.
+    _dim = 100
+    _scalar = pytest.param((1, 1), id="scalar")
+    _bra = pytest.param((1, _dim), id="bra")
+    _ket = pytest.param((_dim, 1), id="ket")
+    _op = pytest.param((_dim, _dim), id="square")
+    shapes = [
+        (_bra, _ket),
+        (_ket, _ket),
+    ]
+    bad_shapes = [
+        (_bra, _bra),
+        (_ket, _bra),
+        (_op, _ket),
+        (_op, _bra),
+        (_bra, _op),
+        (_ket, _op),
+    ]
+
+    specialisations = [
+        pytest.param(data.inner_csr, CSR, CSR, complex),
+        pytest.param(data.inner_dense, Dense, Dense, complex),
+    ]
+
+    def generate_scalar_is_ket(self, metafunc):
+        # For 1D subspaces, the special cases don't really matter since there's
+        # only really one type of matrix available, so this is parametrised
+        # with only case for each input argument.
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+            + ['out_type']
+        )
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, out_type = p_op.values
+            args = (op, types, [(self._scalar, self._scalar)], out_type)
+            cases.extend(cases_type_shape_product(_RANDOM, *args))
+        metafunc.parametrize(parameters, cases)
+        metafunc.parametrize('scalar_is_ket',
+                             [True, False],
+                             ids=["ket", "bra"])
+
+    def test_scalar_is_ket(self, op, data_l, data_r, out_type, scalar_is_ket):
+        left, right = data_l(), data_r()
+        expected = self.op_numpy(left.to_array(), right.to_array(),
+                                 scalar_is_ket)
+        test = op(left, right, scalar_is_ket)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol, rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class TestInnerOp(TernaryOpMixin):
+    # This is very very similar to TestInner.
+    def op_numpy(self, left, mid, right, scalar_is_ket=False):
+        if left.shape[1] == 1:
+            if left.shape[0] != 1 or scalar_is_ket:
+                left = np.conj(left.T)
+        return (left @ mid @ right)[0, 0]
+
+    _dim = 100
+    _scalar = pytest.param((1, 1), id="scalar")
+    _bra = pytest.param((1, _dim), id="bra")
+    _ket = pytest.param((_dim, 1), id="ket")
+    _op = pytest.param((_dim, _dim), id="square")
+    shapes = [
+        (_bra, _op, _ket),
+        (_ket, _op, _ket),
+    ]
+    bad_shapes = [
+        (_bra, _op, _bra),
+        (_ket, _op, _bra),
+        (_op, _op, _ket),
+        (_op, _op, _bra),
+        (_bra, _op, _op),
+        (_ket, _op, _op),
+        (_bra, _bra, _ket),
+        (_ket, _bra, _ket),
+        (_bra, _ket, _ket),
+        (_ket, _ket, _ket),
+    ]
+
+    specialisations = [
+        pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
+        pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
+    ]
+
+    def generate_scalar_is_ket(self, metafunc):
+        parameters = (
+            ['op']
+            + [x for x in metafunc.fixturenames
+               if x.startswith("data_")]
+            + ['out_type']
+        )
+        cases = []
+        for p_op in self.specialisations:
+            op, *types, out_type = p_op.values
+            args = (op, types, [(self._scalar,) * 3], out_type)
+            cases.extend(cases_type_shape_product(_RANDOM, *args))
+        metafunc.parametrize(parameters, cases)
+        metafunc.parametrize('scalar_is_ket',
+                             [True, False], ids=["ket", "bra"])
+
+    def test_scalar_is_ket(self, op, data_l, data_m, data_r, out_type,
+                           scalar_is_ket):
+        left, mid, right = data_l(), data_m(), data_r()
+        expected = self.op_numpy(left.to_array(),
+                                 mid.to_array(),
+                                 right.to_array(),
+                                 scalar_is_ket)
+        test = op(left, mid, right, scalar_is_ket)
+        assert isinstance(test, out_type)
+        if issubclass(out_type, Data):
+            assert test.shape == expected.shape
+            np.testing.assert_allclose(test.to_array(), expected,
+                                       atol=self.atol,
+                                       rtol=self.rtol)
+        else:
+            np.testing.assert_allclose(test, expected, atol=self.atol,
+                                       rtol=self.rtol)
+
+
+class TestKron(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return np.kron(left, right)
+
+    # Keep the dimension low because kron can get very expensive.
+    shapes = shapes_binary_unrestricted(dim=5)
+    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
+    specialisations = [
+        pytest.param(data.kron_csr, CSR, CSR, CSR),
+        pytest.param(data.kron_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestMatmul(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return np.matmul(left, right)
+
+    shapes = shapes_binary_matmul()
+    bad_shapes = shapes_binary_bad_matmul()
+    specialisations = [
+        pytest.param(data.matmul_csr, CSR, CSR, CSR),
+        pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
+        pytest.param(data.matmul_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestMultiply(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return left * right
+
+    shapes = shapes_binary_identical()
+    bad_shapes = shapes_binary_bad_identical()
+    specialisations = [
+        pytest.param(data.multiply_csr, CSR, CSR, CSR),
+        pytest.param(data.multiply_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestMul(UnaryScalarOpMixin):
+    def op_numpy(self, matrix, scalar):
+        return scalar * matrix
+
+    specialisations = [
+        pytest.param(data.mul_csr, CSR, CSR),
+        pytest.param(data.mul_dense, Dense, Dense),
+    ]
+
+
+class TestNeg(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return -matrix
+
+    specialisations = [
+        pytest.param(data.neg_csr, CSR, CSR),
+        pytest.param(data.neg_dense, Dense, Dense),
+    ]
+
+
+class TestSub(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return left - right
+
+    shapes = shapes_binary_identical()
+    bad_shapes = shapes_binary_bad_identical()
+    specialisations = [
+        pytest.param(data.sub_csr, CSR, CSR, CSR),
+        pytest.param(data.sub_dense, Dense, Dense, Dense),
+    ]
+
+
+class TestTrace(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.sum(np.diag(matrix))
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.trace_csr, CSR, complex),
+        pytest.param(data.trace_dense, Dense, complex),
+    ]
+
+
+class TestTrace_oper_ket(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        N = int(matrix.shape[0] ** 0.5)
+        return np.sum(np.diag(matrix.reshape((N, N))))
+
+    shapes = [
+        (pytest.param((100, 1), id="oper-ket"),),
+    ]
+    bad_shapes = [
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((99, 1), id="ket"),),
+        (pytest.param((99, 99), id="ket"),),
+        (pytest.param((2, 99), id="nonsquare"),),
+    ]
+    specialisations = [
+        pytest.param(data.trace_oper_ket_csr, CSR, complex),
+        pytest.param(data.trace_oper_ket_dense, Dense, complex),
+    ]
+
+
+class TestPow(UnaryOpMixin):
+    def op_numpy(self, matrix, n):
+        return np.linalg.matrix_power(matrix, n)
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.pow_csr, CSR, CSR),
+        pytest.param(data.pow_dense, Dense, Dense),
+    ]
+
+    @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
+    def test_mathematically_correct(self, op, data_m, out_type, n):
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), n)
+        test = op(matrix, n)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+                                   rtol=self.rtol)
+
+    # Pow actually does have bad shape, so we put that in too.
+    def test_incorrect_shape_raises(self, op, data_m):
+        """
+        Test that the operation produces a suitable error if the shape is not a
+        square matrix.
+        """
+        with pytest.raises(ValueError):
+            op(data_m(), 10)
+
+
+class TestExpm(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.expm(matrix)
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.expm_csr, CSR, CSR),
+        pytest.param(data.expm_csr_dense, CSR, Dense),
+        pytest.param(data.expm_dense, Dense, Dense),
+    ]
+
+
+class TestLogm(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.logm(matrix)
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+    specialisations = [
+        pytest.param(data.logm_dense, Dense, Dense),
+    ]
+
+
+class TestTranspose(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return matrix.T
+
+    specialisations = [
+        pytest.param(data.transpose_csr, CSR, CSR),
+        pytest.param(data.transpose_dense, Dense, Dense),
+    ]
+
+
+class TestProject(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        if matrix.shape[0] == 1:
+            return np.outer(np.conj(matrix), matrix)
+        else:
+            return np.outer(matrix, np.conj(matrix))
+
+    shapes = [
+        (pytest.param((1, 1), id="scalar"),),
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((100, 1), id="ket"),),
+    ]
+    bad_shapes = [
+        (pytest.param((10, 10), id="square"),),
+        (pytest.param((2, 10), id="nonsquare"),),
+    ]
+
+    specialisations = [
+        pytest.param(data.project_csr, CSR, CSR),
+        pytest.param(data.project_dense, Dense, Dense),
+    ]
+
+
+def _inv_dense(matrix):
+    # Add a diagonal so `matrix` is not singular
+    return data.inv_dense(
+        data.add(
+            matrix,
+            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='dense')
+        )
+    )
+
+
+def _inv_csr(matrix):
+    # Add a diagonal so `matrix` is not singular
+    return data.inv_csr(
+        data.add(
+            matrix,
+            data.diag([1.1]*matrix.shape[0], shape=matrix.shape, dtype='csr')
+        )
+    )
+
+
+class TestInv(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.linalg.inv(matrix + np.eye(matrix.shape[0]) * 1.1)
+
+    shapes = [
+        (pytest.param((1, 1), id="scalar"),),
+        (pytest.param((10, 10), id="square"),),
+    ]
+    bad_shapes = [
+        (pytest.param((2, 10), id="nonsquare"),),
+        (pytest.param((1, 100), id="bra"),),
+        (pytest.param((100, 1), id="ket"),),
+    ]
+
+    specialisations = [
+        pytest.param(_inv_csr, CSR, CSR),
+        pytest.param(_inv_dense, Dense, Dense),
+    ]
diff --git a/qutip/tests/core/data/test_norm.py b/qutip/tests/core/data/test_norm.py
index 7abac8725e..d285bb3ebf 100644
--- a/qutip/tests/core/data/test_norm.py
+++ b/qutip/tests/core/data/test_norm.py
@@ -1,69 +1,69 @@
-from . import test_mathematics as testing
-import numpy as np
-import scipy.linalg
-import pytest
-from qutip import data
-from qutip.core.data import CSR, Dense
-import numbers
-
-
-class TestOneNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.norm(matrix, 1)
-
-    specialisations = [
-        pytest.param(data.norm.one_csr, CSR, numbers.Number),
-        pytest.param(data.norm.one_dense, Dense, numbers.Number),
-    ]
-
-
-class TestFrobeniusNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.norm(matrix, 'fro')
-
-    specialisations = [
-        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
-        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
-    ]
-
-
-class TestMaxNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
-        # works differently for matrices.
-        return np.max(np.abs(matrix))
-
-    specialisations = [
-        pytest.param(data.norm.max_csr, CSR, numbers.Number),
-        pytest.param(data.norm.max_dense, Dense, numbers.Number),
-    ]
-
-
-class TestL2Norm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return scipy.linalg.norm(matrix, 'fro')
-
-    # These shapes correspond to kets or bras
-    shapes = [
-        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
-                                                 or x.values[0][1] == 1)
-    ]
-    # These shapes are everything except for kets and bras
-    bad_shapes = [
-        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
-                                                     or x.values[0][1] == 1)
-    ]
-    specialisations = [
-        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
-        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
-    ]
-
-
-class TestTraceNorm(testing.UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return np.linalg.svd(matrix)[1].sum()
-
-    specialisations = [
-        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
-        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
-    ]
+from . import test_mathematics as testing
+import numpy as np
+import scipy.linalg
+import pytest
+from qutip import data
+from qutip.core.data import CSR, Dense
+import numbers
+
+
+class TestOneNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.norm(matrix, 1)
+
+    specialisations = [
+        pytest.param(data.norm.one_csr, CSR, numbers.Number),
+        pytest.param(data.norm.one_dense, Dense, numbers.Number),
+    ]
+
+
+class TestFrobeniusNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.norm(matrix, 'fro')
+
+    specialisations = [
+        pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
+        pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
+    ]
+
+
+class TestMaxNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        # There is no scipy-equvalent as sc.linalg.norm(matrix, np.inf)
+        # works differently for matrices.
+        return np.max(np.abs(matrix))
+
+    specialisations = [
+        pytest.param(data.norm.max_csr, CSR, numbers.Number),
+        pytest.param(data.norm.max_dense, Dense, numbers.Number),
+    ]
+
+
+class TestL2Norm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return scipy.linalg.norm(matrix, 'fro')
+
+    # These shapes correspond to kets or bras
+    shapes = [
+        (x,) for x in testing.shapes_unary() if (x.values[0][0] == 1
+                                                 or x.values[0][1] == 1)
+    ]
+    # These shapes are everything except for kets and bras
+    bad_shapes = [
+        (x,) for x in testing.shapes_unary() if not (x.values[0][0] == 1
+                                                     or x.values[0][1] == 1)
+    ]
+    specialisations = [
+        pytest.param(data.norm.l2_csr, CSR, numbers.Number),
+        pytest.param(data.norm.l2_dense, Dense, numbers.Number),
+    ]
+
+
+class TestTraceNorm(testing.UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.linalg.svd(matrix)[1].sum()
+
+    specialisations = [
+        pytest.param(data.norm.trace_csr, CSR, numbers.Number),
+        pytest.param(data.norm.trace_dense, Dense, numbers.Number),
+    ]
diff --git a/qutip/tests/core/data/test_operators.py b/qutip/tests/core/data/test_operators.py
index eb2a750708..4416629b9d 100644
--- a/qutip/tests/core/data/test_operators.py
+++ b/qutip/tests/core/data/test_operators.py
@@ -1,69 +1,69 @@
-import pytest
-import numpy
-import qutip
-from qutip.core import data as _data
-from qutip import settings
-
-
-@pytest.mark.parametrize('type_left', _data.to.dtypes)
-@pytest.mark.parametrize('type_right', _data.to.dtypes)
-@pytest.mark.parametrize(['operator', 'dispatch'], [
-    pytest.param(lambda left, right: left + right, _data.add, id="add"),
-    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
-    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
-])
-def test_data_binary_operator(type_left, type_right, operator, dispatch):
-    left = qutip.rand_dm(5, dtype=type_left).data
-    right = qutip.rand_dm(5, dtype=type_right).data
-    numpy.testing.assert_allclose(
-        operator(left, right).to_array(),
-        dispatch(left, right).to_array(),
-        rtol=1e-15
-    )
-
-
-@pytest.mark.parametrize('type_', _data.to.dtypes)
-@pytest.mark.parametrize(['operator', 'dispatch'], [
-    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
-    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
-    pytest.param(lambda data, number: data / number,
-                 lambda data, number: _data.mul(data, 1/number), id="div"),
-])
-def test_data_scalar_operator(type_, operator, dispatch):
-    data = qutip.qeye(2, dtype=type_).data
-    number = 3
-    numpy.testing.assert_allclose(
-        operator(data, number).to_array(),
-        dispatch(data, number).to_array(),
-        rtol=1e-15
-    )
-
-
-@pytest.mark.parametrize('type_', _data.to.dtypes)
-def test_data_neg_operator(type_):
-    data = qutip.qeye(2, dtype=type_).data
-    numpy.testing.assert_allclose(
-        (-data).to_array(), -data.to_array(), rtol=1e-15
-    )
-
-
-@pytest.mark.parametrize('type_left', _data.to.dtypes)
-@pytest.mark.parametrize('type_right', _data.to.dtypes)
-def test_data_eq_operator(type_left, type_right):
-    mat = qutip.rand_dm(5)
-    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
-
-    left = mat.to(type_left).data
-    right = mat.to(type_right).data
-    assert left == right
-    right = (mat + noise).to(type_right).data
-    assert left == right
-
-    right = (mat + noise * 100).to(type_right).data
-    assert left != right
-
-    right = qutip.operator_to_vector(mat).to(type_right).data
-    assert left != right
-
-    assert left != mat
-    assert numpy.all(left != mat.full())
+import pytest
+import numpy
+import qutip
+from qutip.core import data as _data
+from qutip import settings
+
+
+@pytest.mark.parametrize('type_left', _data.to.dtypes)
+@pytest.mark.parametrize('type_right', _data.to.dtypes)
+@pytest.mark.parametrize(['operator', 'dispatch'], [
+    pytest.param(lambda left, right: left + right, _data.add, id="add"),
+    pytest.param(lambda left, right: left - right, _data.sub, id="sub"),
+    pytest.param(lambda left, right: left @ right, _data.matmul, id="matmul"),
+])
+def test_data_binary_operator(type_left, type_right, operator, dispatch):
+    left = qutip.rand_dm(5, dtype=type_left).data
+    right = qutip.rand_dm(5, dtype=type_right).data
+    numpy.testing.assert_allclose(
+        operator(left, right).to_array(),
+        dispatch(left, right).to_array(),
+        rtol=1e-15
+    )
+
+
+@pytest.mark.parametrize('type_', _data.to.dtypes)
+@pytest.mark.parametrize(['operator', 'dispatch'], [
+    pytest.param(lambda data, number: data * number, _data.mul, id="mul"),
+    pytest.param(lambda data, number: number * data, _data.mul, id="rmul"),
+    pytest.param(lambda data, number: data / number,
+                 lambda data, number: _data.mul(data, 1/number), id="div"),
+])
+def test_data_scalar_operator(type_, operator, dispatch):
+    data = qutip.qeye(2, dtype=type_).data
+    number = 3
+    numpy.testing.assert_allclose(
+        operator(data, number).to_array(),
+        dispatch(data, number).to_array(),
+        rtol=1e-15
+    )
+
+
+@pytest.mark.parametrize('type_', _data.to.dtypes)
+def test_data_neg_operator(type_):
+    data = qutip.qeye(2, dtype=type_).data
+    numpy.testing.assert_allclose(
+        (-data).to_array(), -data.to_array(), rtol=1e-15
+    )
+
+
+@pytest.mark.parametrize('type_left', _data.to.dtypes)
+@pytest.mark.parametrize('type_right', _data.to.dtypes)
+def test_data_eq_operator(type_left, type_right):
+    mat = qutip.rand_dm(5)
+    noise = qutip.rand_dm(5) * settings.core["atol"] / 10
+
+    left = mat.to(type_left).data
+    right = mat.to(type_right).data
+    assert left == right
+    right = (mat + noise).to(type_right).data
+    assert left == right
+
+    right = (mat + noise * 100).to(type_right).data
+    assert left != right
+
+    right = qutip.operator_to_vector(mat).to(type_right).data
+    assert left != right
+
+    assert left != mat
+    assert numpy.all(left != mat.full())
diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
index 124d7d2f71..de844baec7 100644
--- a/qutip/tests/core/data/test_properties.py
+++ b/qutip/tests/core/data/test_properties.py
@@ -1,175 +1,175 @@
-import numpy as np
-import pytest
-
-from qutip import data as _data
-
-
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
-def datatype(request):
-    return request.param
-
-
-class Test_isherm:
-    tol = 1e-12
-
-    @pytest.mark.repeat(20)
-    @pytest.mark.parametrize("density", (0.1, 0.8))
-    @pytest.mark.parametrize("size", (10, 100))
-    def test_random_equal_structure(self, datatype, size, density):
-        # This is only going to be approximate, as entries generated onto the
-        # diagonal will fill only one slot, not two, after addition with the
-        # transpose.  The densities are arbitrary, though, so this doesn't
-        # matter much.
-        nnz = int(0.5 * size*size * density) or 1
-        indices = np.triu_indices(size)
-        choice = np.random.choice(indices[0].size, nnz, replace=False)
-        indices = (indices[0][choice], indices[1][choice])
-
-        # Real-symmetric matrices.
-        base = np.zeros((size, size), dtype=np.complex128)
-        base[indices] = np.random.rand(nnz)
-        base += base.T.conj()
-        base = _data.to(datatype, _data.create(base))
-        assert _data.isherm(base)
-
-        # Complex Hermitian matrices
-        base = np.zeros((size, size), dtype=np.complex128)
-        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-        base += base.T.conj()
-        base = _data.to(datatype, _data.create(base))
-        assert _data.isherm(base)
-
-        # Complex skew-Hermitian matrices
-        base = np.zeros((size, size), dtype=np.complex128)
-        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
-        base += base.T
-        base = _data.to(datatype, _data.create(base))
-        assert not _data.isherm(base)
-
-    @pytest.mark.parametrize("cols", (2, 4))
-    @pytest.mark.parametrize("rows", (1, 5))
-    def test_nonsquare_shapes(self, datatype, rows, cols):
-        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
-        assert not _data.isherm(real, self.tol)
-        assert not _data.isherm(real.transpose(), self.tol)
-
-        imag = _data.to(
-            datatype,
-            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
-        )
-        assert not _data.isherm(imag, self.tol)
-        assert not _data.isherm(imag.transpose(), self.tol)
-
-    def test_diagonal_elements(self, datatype):
-        n = 10
-        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
-        assert _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
-
-    def test_compare_implicit_zero_structure(self, datatype):
-        """
-        Regression test for gh-1350, comparing explicitly stored values in the
-        matrix (but below the tolerance for allowable Hermicity) to implicit
-        zeros.
-        """
-
-        base = _data.to(
-            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
-        )
-        # If this first line fails, the zero has been stored explicitly and so
-        # the test is invalid.
-        assert np.count_nonzero(base.to_array()) == 3
-        assert _data.isherm(base, tol=self.tol)
-        assert _data.isherm(base.transpose(), tol=self.tol)
-
-        # A similar test if the structures are different, but it's not
-        # Hermitian.
-        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
-        assert np.count_nonzero(base.to_array()) == 3
-        assert not _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(base.transpose(), tol=self.tol)
-
-        # Catch possible edge case where it shouldn't be Hermitian, but faulty
-        # loop logic doesn't fully compare all rows.
-        base = _data.to(
-            datatype,
-            _data.create(
-                np.array(
-                    [
-                        [0, 0, 0, 0],
-                        [0, 0, 0, 0],
-                        [0, 1, 0, 0],
-                        [0, 0, 0, 0],
-                    ],
-                    dtype=np.complex128,
-                )
-            ),
-        )
-        assert np.count_nonzero(base.to_array()) == 1
-        assert not _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(base.transpose(), tol=self.tol)
-
-    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
-    def test_compare_implicit_zero_random(self, datatype, density):
-        """
-        Regression test of gh-1350.
-
-        Larger matrices where all off-diagonal elements are below the
-        absolute tolerance, so everything should always appear Hermitian, but
-        with random patterns of non-zero elements.  It doesn't matter that it
-        isn't Hermitian if scaled up; everything is below absolute tolerance,
-        so it should appear so.  We also set the diagonal to be larger to the
-        tolerance to ensure isherm can't just compare everything to zero.
-        """
-        n = 10
-        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
-        # Mask some values out to zero.
-        base[np.random.rand(n, n) > density] = 0
-        np.fill_diagonal(base, self.tol * 1000)
-        nnz = np.count_nonzero(base)
-        base = _data.to(datatype, _data.create(base))
-        assert np.count_nonzero(base.to_array()) == nnz
-        assert _data.isherm(base, tol=self.tol)
-        assert _data.isherm(base.transpose(), tol=self.tol)
-
-        # Similar test when it must be non-Hermitian.  We set the diagonal
-        # to be real because we want to test off-diagonal implicit zeros,
-        # and having an imaginary first element would automatically fail.
-        nnz = 0
-        while nnz <= n:
-            # Ensure that we don't just have the real diagonal.
-            base = self.tol * 1000j * np.random.rand(n, n)
-            # Mask some values out to zero.
-            base[np.random.rand(n, n) > density] = 0
-            np.fill_diagonal(base, self.tol * 1000)
-            nnz = np.count_nonzero(base)
-        base = _data.to(datatype, _data.create(base))
-        assert np.count_nonzero(base.to_array()) == nnz
-        assert not _data.isherm(base, tol=self.tol)
-        assert not _data.isherm(base.transpose(), tol=self.tol)
-
-    def test_structure_detection(self, datatype):
-        base = np.array([[1,1,0],
-                         [0,1,1],
-                         [1,0,1]])
-        base = _data.to(datatype, _data.create(base))
-        assert not _data.isherm(base, tol=self.tol)
-
-
-class Test_isdiag:
-    @pytest.mark.parametrize("shape",
-        [(10, 1), (2, 5), (5, 2), (5, 5)]
-    )
-    def test_isdiag(self, shape, datatype):
-        mat = np.zeros(shape)
-        data = _data.to(datatype, _data.Dense(mat))
-        # empty matrices are diagonal
-        assert _data.isdiag(data)
-
-        mat[0, 0] = 1
-        data = _data.to(datatype, _data.Dense(mat))
-        assert _data.isdiag(data)
-
-        mat[1, 0] = 1
-        data = _data.to(datatype, _data.Dense(mat))
-        assert not _data.isdiag(data)
+import numpy as np
+import pytest
+
+from qutip import data as _data
+
+
+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+def datatype(request):
+    return request.param
+
+
+class Test_isherm:
+    tol = 1e-12
+
+    @pytest.mark.repeat(20)
+    @pytest.mark.parametrize("density", (0.1, 0.8))
+    @pytest.mark.parametrize("size", (10, 100))
+    def test_random_equal_structure(self, datatype, size, density):
+        # This is only going to be approximate, as entries generated onto the
+        # diagonal will fill only one slot, not two, after addition with the
+        # transpose.  The densities are arbitrary, though, so this doesn't
+        # matter much.
+        nnz = int(0.5 * size*size * density) or 1
+        indices = np.triu_indices(size)
+        choice = np.random.choice(indices[0].size, nnz, replace=False)
+        indices = (indices[0][choice], indices[1][choice])
+
+        # Real-symmetric matrices.
+        base = np.zeros((size, size), dtype=np.complex128)
+        base[indices] = np.random.rand(nnz)
+        base += base.T.conj()
+        base = _data.to(datatype, _data.create(base))
+        assert _data.isherm(base)
+
+        # Complex Hermitian matrices
+        base = np.zeros((size, size), dtype=np.complex128)
+        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+        base += base.T.conj()
+        base = _data.to(datatype, _data.create(base))
+        assert _data.isherm(base)
+
+        # Complex skew-Hermitian matrices
+        base = np.zeros((size, size), dtype=np.complex128)
+        base[indices] = np.random.rand(nnz) + 1j*np.random.rand(nnz)
+        base += base.T
+        base = _data.to(datatype, _data.create(base))
+        assert not _data.isherm(base)
+
+    @pytest.mark.parametrize("cols", (2, 4))
+    @pytest.mark.parametrize("rows", (1, 5))
+    def test_nonsquare_shapes(self, datatype, rows, cols):
+        real = _data.to(datatype, _data.create(np.random.rand(rows, cols)))
+        assert not _data.isherm(real, self.tol)
+        assert not _data.isherm(real.transpose(), self.tol)
+
+        imag = _data.to(
+            datatype,
+            _data.create(np.random.rand(rows, cols) + 1j * np.random.rand(rows, cols)),
+        )
+        assert not _data.isherm(imag, self.tol)
+        assert not _data.isherm(imag.transpose(), self.tol)
+
+    def test_diagonal_elements(self, datatype):
+        n = 10
+        base = _data.to(datatype, _data.create(np.diag(np.random.rand(n))))
+        assert _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(_data.mul(base, 1j), tol=self.tol)
+
+    def test_compare_implicit_zero_structure(self, datatype):
+        """
+        Regression test for gh-1350, comparing explicitly stored values in the
+        matrix (but below the tolerance for allowable Hermicity) to implicit
+        zeros.
+        """
+
+        base = _data.to(
+            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
+        )
+        # If this first line fails, the zero has been stored explicitly and so
+        # the test is invalid.
+        assert np.count_nonzero(base.to_array()) == 3
+        assert _data.isherm(base, tol=self.tol)
+        assert _data.isherm(base.transpose(), tol=self.tol)
+
+        # A similar test if the structures are different, but it's not
+        # Hermitian.
+        base = _data.to(datatype, _data.create(np.array([[1, 1j], [0, 1]])))
+        assert np.count_nonzero(base.to_array()) == 3
+        assert not _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(base.transpose(), tol=self.tol)
+
+        # Catch possible edge case where it shouldn't be Hermitian, but faulty
+        # loop logic doesn't fully compare all rows.
+        base = _data.to(
+            datatype,
+            _data.create(
+                np.array(
+                    [
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 1, 0, 0],
+                        [0, 0, 0, 0],
+                    ],
+                    dtype=np.complex128,
+                )
+            ),
+        )
+        assert np.count_nonzero(base.to_array()) == 1
+        assert not _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(base.transpose(), tol=self.tol)
+
+    @pytest.mark.parametrize("density", np.linspace(0.2, 1, 17))
+    def test_compare_implicit_zero_random(self, datatype, density):
+        """
+        Regression test of gh-1350.
+
+        Larger matrices where all off-diagonal elements are below the
+        absolute tolerance, so everything should always appear Hermitian, but
+        with random patterns of non-zero elements.  It doesn't matter that it
+        isn't Hermitian if scaled up; everything is below absolute tolerance,
+        so it should appear so.  We also set the diagonal to be larger to the
+        tolerance to ensure isherm can't just compare everything to zero.
+        """
+        n = 10
+        base = self.tol * 1e-2 * (np.random.rand(n, n) + 1j * np.random.rand(n, n))
+        # Mask some values out to zero.
+        base[np.random.rand(n, n) > density] = 0
+        np.fill_diagonal(base, self.tol * 1000)
+        nnz = np.count_nonzero(base)
+        base = _data.to(datatype, _data.create(base))
+        assert np.count_nonzero(base.to_array()) == nnz
+        assert _data.isherm(base, tol=self.tol)
+        assert _data.isherm(base.transpose(), tol=self.tol)
+
+        # Similar test when it must be non-Hermitian.  We set the diagonal
+        # to be real because we want to test off-diagonal implicit zeros,
+        # and having an imaginary first element would automatically fail.
+        nnz = 0
+        while nnz <= n:
+            # Ensure that we don't just have the real diagonal.
+            base = self.tol * 1000j * np.random.rand(n, n)
+            # Mask some values out to zero.
+            base[np.random.rand(n, n) > density] = 0
+            np.fill_diagonal(base, self.tol * 1000)
+            nnz = np.count_nonzero(base)
+        base = _data.to(datatype, _data.create(base))
+        assert np.count_nonzero(base.to_array()) == nnz
+        assert not _data.isherm(base, tol=self.tol)
+        assert not _data.isherm(base.transpose(), tol=self.tol)
+
+    def test_structure_detection(self, datatype):
+        base = np.array([[1,1,0],
+                         [0,1,1],
+                         [1,0,1]])
+        base = _data.to(datatype, _data.create(base))
+        assert not _data.isherm(base, tol=self.tol)
+
+
+class Test_isdiag:
+    @pytest.mark.parametrize("shape",
+        [(10, 1), (2, 5), (5, 2), (5, 5)]
+    )
+    def test_isdiag(self, shape, datatype):
+        mat = np.zeros(shape)
+        data = _data.to(datatype, _data.Dense(mat))
+        # empty matrices are diagonal
+        assert _data.isdiag(data)
+
+        mat[0, 0] = 1
+        data = _data.to(datatype, _data.Dense(mat))
+        assert _data.isdiag(data)
+
+        mat[1, 0] = 1
+        data = _data.to(datatype, _data.Dense(mat))
+        assert not _data.isdiag(data)
diff --git a/qutip/tests/core/data/test_ptrace.py b/qutip/tests/core/data/test_ptrace.py
index 37b28c2936..84fd41015d 100644
--- a/qutip/tests/core/data/test_ptrace.py
+++ b/qutip/tests/core/data/test_ptrace.py
@@ -1,108 +1,108 @@
-from . import test_mathematics as testing
-import numpy as np
-import scipy.linalg
-import pytest
-from qutip import data
-from qutip.core.data import CSR, Dense
-
-
-class TestPtrace(testing.UnaryOpMixin):
-    def op_numpy(self, matrix, dims, sel):
-        sel.sort()
-        ndims = len(dims)
-        dkeep = [dims[x] for x in sel]
-        qtrace = list(set(range(ndims)) - set(sel))
-        dtrace = [dims[x] for x in qtrace]
-
-        matrix = matrix.reshape(dims + dims)
-        matrix = matrix.transpose(
-            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
-        )
-        matrix = matrix.reshape(
-            [
-                np.prod(dtrace, dtype=int),
-                np.prod(dtrace, dtype=int),
-                np.prod(dkeep, dtype=int),
-                np.prod(dkeep, dtype=int),
-            ]
-        )
-        return np.trace(matrix)
-
-    # Custom shapes to have also custom dims and sel arguments.
-    # These values should not be changed.
-    dims = [2] * 7
-    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
-    bad_shapes = testing.shapes_not_square(np.prod(dims))
-
-    specialisations = [
-        pytest.param(data.ptrace_csr, CSR, CSR),
-        pytest.param(data.ptrace_csr_dense, CSR, Dense),
-        pytest.param(data.ptrace_dense, Dense, Dense),
-    ]
-
-    @pytest.mark.parametrize(
-        "sel",
-        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
-        ids=[
-            "keep_one",
-            "keep_multiple_sorted",
-            "keep_multiple_unsorted",
-            "trace_none",
-            "trace_all",
-        ],
-    )
-    def test_mathematically_correct(self, op, data_m, out_type, sel):
-        """
-        Test that the unary operation is mathematically correct for all the
-        known type specialisations.
-        """
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
-        test = op(matrix, self.dims, sel)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(
-            test.to_array(), expected, atol=self.atol, rtol=self.rtol
-        )
-
-    def test_incorrect_shape_raises(self, op, data_m):
-        """
-        Test that the operation produces a suitable error if the shape of the
-        operand is not square.
-        """
-        with pytest.raises(ValueError):
-            op(data_m(), self.dims, sel=[0, 1])
-
-    # `out_type` is included but not used so that
-    # `generate_mathematically_correct` can be re-used.
-    @pytest.mark.parametrize(
-        "dims",
-        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
-        ids=[
-            "dims_different_to_shape",
-            "dims_0",
-            "dims_prod_is_shape_but_negative",
-            "dims_is_not_int",
-        ],
-    )
-    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
-        with pytest.raises(ValueError):
-            op(data_m(), dims, sel=[0, 1])
-
-    def generate_incorrect_dims_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
-
-    @pytest.mark.parametrize(
-        "sel",
-        [[2, 10], [-1, 2]],
-        ids=[
-            "sel_value_larger_than_dims",
-            "sel_value_negative",
-        ],
-    )
-    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
-        with pytest.raises(IndexError):
-            op(data_m(), dims=self.dims, sel=sel)
-
-    def generate_incorrect_sel_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
+from . import test_mathematics as testing
+import numpy as np
+import scipy.linalg
+import pytest
+from qutip import data
+from qutip.core.data import CSR, Dense
+
+
+class TestPtrace(testing.UnaryOpMixin):
+    def op_numpy(self, matrix, dims, sel):
+        sel.sort()
+        ndims = len(dims)
+        dkeep = [dims[x] for x in sel]
+        qtrace = list(set(range(ndims)) - set(sel))
+        dtrace = [dims[x] for x in qtrace]
+
+        matrix = matrix.reshape(dims + dims)
+        matrix = matrix.transpose(
+            qtrace + [ndims + i for i in qtrace] + sel + [ndims + i for i in sel]
+        )
+        matrix = matrix.reshape(
+            [
+                np.prod(dtrace, dtype=int),
+                np.prod(dtrace, dtype=int),
+                np.prod(dkeep, dtype=int),
+                np.prod(dkeep, dtype=int),
+            ]
+        )
+        return np.trace(matrix)
+
+    # Custom shapes to have also custom dims and sel arguments.
+    # These values should not be changed.
+    dims = [2] * 7
+    shapes = [(pytest.param((np.prod(dims), np.prod(dims))),)]
+    bad_shapes = testing.shapes_not_square(np.prod(dims))
+
+    specialisations = [
+        pytest.param(data.ptrace_csr, CSR, CSR),
+        pytest.param(data.ptrace_csr_dense, CSR, Dense),
+        pytest.param(data.ptrace_dense, Dense, Dense),
+    ]
+
+    @pytest.mark.parametrize(
+        "sel",
+        [[0], [0, 3, 6], [0, 6, 3], list(range(len(dims))), []],
+        ids=[
+            "keep_one",
+            "keep_multiple_sorted",
+            "keep_multiple_unsorted",
+            "trace_none",
+            "trace_all",
+        ],
+    )
+    def test_mathematically_correct(self, op, data_m, out_type, sel):
+        """
+        Test that the unary operation is mathematically correct for all the
+        known type specialisations.
+        """
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), self.dims, sel)
+        test = op(matrix, self.dims, sel)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(
+            test.to_array(), expected, atol=self.atol, rtol=self.rtol
+        )
+
+    def test_incorrect_shape_raises(self, op, data_m):
+        """
+        Test that the operation produces a suitable error if the shape of the
+        operand is not square.
+        """
+        with pytest.raises(ValueError):
+            op(data_m(), self.dims, sel=[0, 1])
+
+    # `out_type` is included but not used so that
+    # `generate_mathematically_correct` can be re-used.
+    @pytest.mark.parametrize(
+        "dims",
+        [[2], [0], [-2, -2] + [2] * 5, [1.2, 2.2, 3.3]],
+        ids=[
+            "dims_different_to_shape",
+            "dims_0",
+            "dims_prod_is_shape_but_negative",
+            "dims_is_not_int",
+        ],
+    )
+    def test_incorrect_dims_raises(self, op, data_m, out_type, dims):
+        with pytest.raises(ValueError):
+            op(data_m(), dims, sel=[0, 1])
+
+    def generate_incorrect_dims_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
+
+    @pytest.mark.parametrize(
+        "sel",
+        [[2, 10], [-1, 2]],
+        ids=[
+            "sel_value_larger_than_dims",
+            "sel_value_negative",
+        ],
+    )
+    def test_incorrect_sel_raises(self, op, data_m, out_type, sel):
+        with pytest.raises(IndexError):
+            op(data_m(), dims=self.dims, sel=sel)
+
+    def generate_incorrect_sel_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
diff --git a/qutip/tests/core/data/test_reshape.py b/qutip/tests/core/data/test_reshape.py
index ad863b55e7..e86b327c8f 100644
--- a/qutip/tests/core/data/test_reshape.py
+++ b/qutip/tests/core/data/test_reshape.py
@@ -1,121 +1,121 @@
-from .test_mathematics import UnaryOpMixin
-import pytest
-import numpy as np
-from qutip import data
-from qutip.core.data import CSR, Dense
-
-
-class TestSplitColumns(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        return [column[:, np.newaxis] for column in matrix.T]
-
-    specialisations = [
-        pytest.param(data.split_columns_csr, CSR, list),
-        pytest.param(data.split_columns_dense, Dense, list),
-    ]
-
-
-class TestColumnStack(UnaryOpMixin):
-    def op_numpy(self, matrix):
-        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
-        return np.reshape(matrix, newshape=out_shape, order='F')
-
-    specialisations = [
-        pytest.param(data.column_stack_csr, CSR, CSR),
-        pytest.param(data.column_stack_dense, Dense, Dense),
-    ]
-
-
-class TestColumnUnstack(UnaryOpMixin):
-    def op_numpy(self, matrix, rows):
-        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
-        return np.reshape(matrix, newshape=out_shape, order='F')
-
-    shapes = [
-        (pytest.param((10, 1), id="ket"), ),
-    ]
-
-    bad_shapes = [
-        (pytest.param((1, 10), id="bra"), ),
-        (pytest.param((10, 10), id="square"), ),
-        (pytest.param((2, 10), id="non_square"), ),
-    ]
-
-    specialisations = [
-        pytest.param(data.column_unstack_csr, CSR, CSR),
-        pytest.param(data.column_unstack_dense, Dense, Dense),
-    ]
-
-    @pytest.mark.parametrize('rows', [2, 5])
-    def test_mathematically_correct(self, op, data_m, rows, out_type):
-        """
-        Test that the binary operation is correct for all the known type
-        specialisations.
-        """
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), rows)
-        test = op(matrix, rows)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-                                   rtol=self.rtol)
-
-    def test_incorrect_shape_raises(self, op, data_m):
-        with pytest.raises(ValueError):
-            op(data_m(), 1)  # We set rows to one so that it is always valid
-
-    # `out_type` is included but not used so that
-    # `generate_mathematically_correct` can be re-used.
-    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
-                                                      'invalid'])
-    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
-        with pytest.raises(ValueError):
-            op(data_m(), rows)
-
-    def generate_incorrect_rows_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
-
-
-class TestReshape(UnaryOpMixin):
-    def op_numpy(self, matrix, rows, columns):
-        out_shape = (rows, columns)
-        return np.reshape(matrix, newshape=out_shape, order='C')
-
-    # All matrices should have the same number of elements in total, so we can
-    # use the same (rows, columns) parametrisation for each input.
-    shapes = [
-        (pytest.param((1, 100), id="bra"), ),
-        (pytest.param((100, 1), id="ket"), ),
-        (pytest.param((2, 50), id="non_square"), ),
-        (pytest.param((10, 10), id="square"), ),
-    ]
-
-    specialisations = [
-        pytest.param(data.reshape_dense, Dense, Dense),
-        pytest.param(data.reshape_csr, CSR, CSR),
-    ]
-
-    # `out_type` is included but not used so that
-    # `generate_mathematically_correct` can be re-used.
-    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
-    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
-        """
-        Test that the binary operation is correct for all the known type
-        specialisations.
-        """
-        matrix = data_m()
-        expected = self.op_numpy(matrix.to_array(), rows, columns)
-        test = op(matrix, rows, columns)
-        assert isinstance(test, out_type)
-        assert test.shape == expected.shape
-        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
-                                   rtol=self.rtol)
-
-    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
-                             ids=["negative1", "negative2", "invalid"])
-    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
-        with pytest.raises(ValueError):
-            op(data_m(), rows, columns)
-
-    def generate_incorrect_rows_raises(self, metafunc):
-        self.generate_mathematically_correct(metafunc)
+from .test_mathematics import UnaryOpMixin
+import pytest
+import numpy as np
+from qutip import data
+from qutip.core.data import CSR, Dense
+
+
+class TestSplitColumns(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return [column[:, np.newaxis] for column in matrix.T]
+
+    specialisations = [
+        pytest.param(data.split_columns_csr, CSR, list),
+        pytest.param(data.split_columns_dense, Dense, list),
+    ]
+
+
+class TestColumnStack(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        out_shape = (matrix.shape[0]*matrix.shape[1], 1)
+        return np.reshape(matrix, newshape=out_shape, order='F')
+
+    specialisations = [
+        pytest.param(data.column_stack_csr, CSR, CSR),
+        pytest.param(data.column_stack_dense, Dense, Dense),
+    ]
+
+
+class TestColumnUnstack(UnaryOpMixin):
+    def op_numpy(self, matrix, rows):
+        out_shape = (rows, matrix.shape[0]*matrix.shape[1]//rows)
+        return np.reshape(matrix, newshape=out_shape, order='F')
+
+    shapes = [
+        (pytest.param((10, 1), id="ket"), ),
+    ]
+
+    bad_shapes = [
+        (pytest.param((1, 10), id="bra"), ),
+        (pytest.param((10, 10), id="square"), ),
+        (pytest.param((2, 10), id="non_square"), ),
+    ]
+
+    specialisations = [
+        pytest.param(data.column_unstack_csr, CSR, CSR),
+        pytest.param(data.column_unstack_dense, Dense, Dense),
+    ]
+
+    @pytest.mark.parametrize('rows', [2, 5])
+    def test_mathematically_correct(self, op, data_m, rows, out_type):
+        """
+        Test that the binary operation is correct for all the known type
+        specialisations.
+        """
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), rows)
+        test = op(matrix, rows)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+                                   rtol=self.rtol)
+
+    def test_incorrect_shape_raises(self, op, data_m):
+        with pytest.raises(ValueError):
+            op(data_m(), 1)  # We set rows to one so that it is always valid
+
+    # `out_type` is included but not used so that
+    # `generate_mathematically_correct` can be re-used.
+    @pytest.mark.parametrize('rows', [-1, 0, 3], ids=['negative', 'zero',
+                                                      'invalid'])
+    def test_incorrect_rows_raises(self, op, data_m, out_type, rows):
+        with pytest.raises(ValueError):
+            op(data_m(), rows)
+
+    def generate_incorrect_rows_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
+
+
+class TestReshape(UnaryOpMixin):
+    def op_numpy(self, matrix, rows, columns):
+        out_shape = (rows, columns)
+        return np.reshape(matrix, newshape=out_shape, order='C')
+
+    # All matrices should have the same number of elements in total, so we can
+    # use the same (rows, columns) parametrisation for each input.
+    shapes = [
+        (pytest.param((1, 100), id="bra"), ),
+        (pytest.param((100, 1), id="ket"), ),
+        (pytest.param((2, 50), id="non_square"), ),
+        (pytest.param((10, 10), id="square"), ),
+    ]
+
+    specialisations = [
+        pytest.param(data.reshape_dense, Dense, Dense),
+        pytest.param(data.reshape_csr, CSR, CSR),
+    ]
+
+    # `out_type` is included but not used so that
+    # `generate_mathematically_correct` can be re-used.
+    @pytest.mark.parametrize('rows, columns', [(5, 20), (10, 10)])
+    def test_mathematically_correct(self, op, data_m, rows, columns, out_type):
+        """
+        Test that the binary operation is correct for all the known type
+        specialisations.
+        """
+        matrix = data_m()
+        expected = self.op_numpy(matrix.to_array(), rows, columns)
+        test = op(matrix, rows, columns)
+        assert isinstance(test, out_type)
+        assert test.shape == expected.shape
+        np.testing.assert_allclose(test.to_array(), expected, atol=self.atol,
+                                   rtol=self.rtol)
+
+    @pytest.mark.parametrize('rows, columns', [(-2, -50), (-50, -2), (3, 10)],
+                             ids=["negative1", "negative2", "invalid"])
+    def test_incorrect_rows_raises(self, op, data_m, out_type, rows, columns):
+        with pytest.raises(ValueError):
+            op(data_m(), rows, columns)
+
+    def generate_incorrect_rows_raises(self, metafunc):
+        self.generate_mathematically_correct(metafunc)
diff --git a/qutip/tests/core/test_brtools.py b/qutip/tests/core/test_brtools.py
index c1b4318838..527ca89778 100644
--- a/qutip/tests/core/test_brtools.py
+++ b/qutip/tests/core/test_brtools.py
@@ -1,336 +1,336 @@
-import pytest
-import qutip
-import numpy as np
-from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
-from qutip.core.blochredfield import brterm, bloch_redfield_tensor
-from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
-                                  _br_term_data, _BlochRedfieldElement)
-
-
-def _make_rand_data(shape):
-    np.random.seed(11)
-    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    return qutip.data.Dense(array)
-
-
-transform = {
-    0: lambda x: x,
-    1: qutip.data.transpose,
-    2: qutip.data.conj,
-    3: qutip.data.adjoint
-}
-
-
-@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
-@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
-                         ids=['', 'transpose', 'conj', 'dag'])
-@pytest.mark.parametrize('transright', [0, 1, 2, 3],
-                         ids=['', 'transpose', 'conj', 'dag'])
-def test_matmul_var(datatype, transleft, transright):
-    shape = (5, 5)
-    np.random.seed(11)
-    left = qutip.data.to(datatype, _make_rand_data(shape))
-    right = qutip.data.to(datatype, _make_rand_data(shape))
-
-    expected = qutip.data.matmul(
-        transform[transleft](left),
-        transform[transright](right),
-        ).to_array()
-
-    computed = matmul_var_data(left, right, transleft, transright).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14)
-
-
-@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
-def test_eigen_transform(sparse):
-    a = qutip.destroy(5)
-    f = lambda t: t
-    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
-    eigenT = _EigenBasisTransform(op, sparse=sparse)
-    evecs_qevo = eigenT.as_Qobj()
-
-    for t in [0, 1, 1.5]:
-        eigenvals, ekets = op(t).eigenstates()
-        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
-                                   rtol=1e-14, atol=1e-14)
-        np.testing.assert_allclose(
-            np.abs(np.hstack([eket.full() for eket in ekets])),
-            np.abs(eigenT.evecs(t).to_array()),
-            rtol=1e-14, atol=1e-14
-        )
-        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
-                                   np.abs(eigenT.evecs(t).to_array()),
-                                   rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_ket():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.coherent(N, 1.1)
-
-    expected = (op @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_dm():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.coherent_dm(N, 1.1)
-
-    expected = (op @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_oper_ket():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
-
-    expected = (qutip.spre(op) @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(qutip.spre(op_diag).data,
-                          eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-def test_eigen_transform_super_ops():
-    N = 5
-    a = qutip.destroy(N)
-    op = a*a.dag() + a + a.dag()
-    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
-    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
-
-    state = qutip.sprepost(
-        qutip.coherent_dm(N, 1.1),
-        qutip.thermal_dm(N, 1.1)
-    )
-
-    expected = (qutip.spre(op) @ state).full()
-    computed = eigenT.from_eigbasis(
-        0,
-        qutip.data.matmul(qutip.spre(op_diag).data,
-                          eigenT.to_eigbasis(0, state.data))
-    ).to_array()
-    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('func',
-                         [_br_term_dense, _br_term_sparse, _br_term_data],
-                         ids=['dense', 'sparse', 'data'])
-def test_br_term_linbblad_comp(func):
-    N = 5
-    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
-    A_op = a + a.dag()
-    H = qutip.num(N)
-    diag = H.eigenenergies()
-    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
-    spectrum = (skew > 0) * 1.
-    computation = func(A_op.data, spectrum, skew, 2).to_array()
-    lindblad = qutip.lindblad_dissipator(a).full()
-    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
-@pytest.mark.parametrize('spectra', [
-    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
-    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
-    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
-])
-def test_br_term(cutoff, spectra):
-    N = 5
-    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
-    A_op = a + a.dag()
-    H = qutip.num(N)
-    diag = H.eigenenergies()
-    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
-    spectrum = spectra(skew)
-    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
-    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
-    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
-    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
-    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_brterm(cutoff):
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
-    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
-    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
-    assert isinstance(R, qutip.Qobj)
-    assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
-    state = qutip.operator_to_vector(qutip.rand_dm(N))
-    fock_computed = R @ state
-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
-                               rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_td_brterm(cutoff):
-    N = 5
-    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
-    a = qutip.destroy(N)
-    A_op = qutip.QobjEvo([a + a.dag(), "t"])
-    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
-    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
-    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
-    assert isinstance(R, qutip.QobjEvo)
-    assert isinstance(R_eigs, qutip.QobjEvo)
-    assert isinstance(evecs, qutip.QobjEvo)
-    state = qutip.operator_to_vector(qutip.rand_dm(N))
-    fock_computed = R @ state
-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-    for t in [0, 0.5, 1.0]:
-        np.testing.assert_allclose(
-            (R(t) @ state).full(),
-            R.matmul(t, state).full(),
-            rtol=1e-14, atol=1e-14
-        )
-        np.testing.assert_allclose(fock_computed(t).full(),
-                                   eig_computed(t).full(),
-                                   rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_bloch_redfield_tensor_basis(cutoff):
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-    R = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        sec_cutoff=cutoff,
-        fock_basis=True
-    )
-    R_eigs, evecs = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        sec_cutoff=cutoff,
-        fock_basis=False
-    )
-    assert isinstance(R, qutip.Qobj)
-    assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
-    state = qutip.operator_to_vector(qutip.rand_dm(N))
-    fock_computed = R @ state
-    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
-    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
-    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
-                               rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_bloch_redfield_tensor(cutoff):
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-    R = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        sec_cutoff=cutoff,
-        fock_basis=True
-    )
-    R_expected = qutip.liouvillian(H, [a**2])
-    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
-
-    assert isinstance(R, qutip.Qobj)
-    assert isinstance(R_expected, qutip.Qobj)
-    np.testing.assert_allclose(R.full(), R_expected.full(),
-                               rtol=1e-14, atol=1e-14)
-
-
-@pytest.mark.parametrize('fock_basis', [True, False])
-@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
-def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
-    N = 3
-    H = qutip.QobjEvo([qutip.num(N), "t"])
-    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
-    A_op = a + a.dag()
-    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
-    R = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[qutip.destroy(N)],
-        sec_cutoff=cutoff,
-        fock_basis=fock_basis
-    )
-    R = R[0] if not fock_basis else R
-    assert isinstance(R, qutip.QobjEvo)
-    for t in [0, 0.5, 1.0, 1.5]:
-        R_expected = bloch_redfield_tensor(
-            H=H(t),
-            a_ops=[(A_op(t), spectra)],
-            c_ops=[qutip.destroy(N)],
-            sec_cutoff=cutoff,
-            fock_basis=fock_basis
-        )
-        R_expected = R_expected[0] if not fock_basis else R_expected
-        np.testing.assert_allclose(R(t).full(), R_expected.full(),
-                                   rtol=1e-14, atol=1e-14)
-
-
-def test_bloch_redfield_tensor_spectral_string():
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = "(w>0) * 0.5"
-    R_eigs, evecs = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        fock_basis=False
-    )
-    assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
-
-def test_bloch_redfield_tensor_spectral_callable():
-    N = 5
-    H = qutip.num(N)
-    a = qutip.destroy(N)
-    A_op = a + a.dag()
-    spectra = lambda w: (w>0) * 0.5
-    R_eigs, evecs = bloch_redfield_tensor(
-        H=H,
-        a_ops=[(A_op, spectra)],
-        c_ops=[a**2],
-        fock_basis=False
-    )
-    assert isinstance(R_eigs, qutip.Qobj)
+import pytest
+import qutip
+import numpy as np
+from qutip.core._brtools import matmul_var_data, _EigenBasisTransform
+from qutip.core.blochredfield import brterm, bloch_redfield_tensor
+from qutip.core._brtensor import (_br_term_dense, _br_term_sparse,
+                                  _br_term_data, _BlochRedfieldElement)
+
+
+def _make_rand_data(shape):
+    np.random.seed(11)
+    array = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    return qutip.data.Dense(array)
+
+
+transform = {
+    0: lambda x: x,
+    1: qutip.data.transpose,
+    2: qutip.data.conj,
+    3: qutip.data.adjoint
+}
+
+
+@pytest.mark.parametrize('datatype', qutip.data.to.dtypes)
+@pytest.mark.parametrize('transleft', [0, 1, 2, 3],
+                         ids=['', 'transpose', 'conj', 'dag'])
+@pytest.mark.parametrize('transright', [0, 1, 2, 3],
+                         ids=['', 'transpose', 'conj', 'dag'])
+def test_matmul_var(datatype, transleft, transright):
+    shape = (5, 5)
+    np.random.seed(11)
+    left = qutip.data.to(datatype, _make_rand_data(shape))
+    right = qutip.data.to(datatype, _make_rand_data(shape))
+
+    expected = qutip.data.matmul(
+        transform[transleft](left),
+        transform[transright](right),
+        ).to_array()
+
+    computed = matmul_var_data(left, right, transleft, transright).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14)
+
+
+@pytest.mark.parametrize('sparse', [False, True], ids=['Dense', 'Sparse'])
+def test_eigen_transform(sparse):
+    a = qutip.destroy(5)
+    f = lambda t: t
+    op = qutip.QobjEvo([a*a.dag(), [a+a.dag(), f]])
+    eigenT = _EigenBasisTransform(op, sparse=sparse)
+    evecs_qevo = eigenT.as_Qobj()
+
+    for t in [0, 1, 1.5]:
+        eigenvals, ekets = op(t).eigenstates()
+        np.testing.assert_allclose(eigenvals, eigenT.eigenvalues(t),
+                                   rtol=1e-14, atol=1e-14)
+        np.testing.assert_allclose(
+            np.abs(np.hstack([eket.full() for eket in ekets])),
+            np.abs(eigenT.evecs(t).to_array()),
+            rtol=1e-14, atol=1e-14
+        )
+        np.testing.assert_allclose(np.abs(evecs_qevo(t).full()),
+                                   np.abs(eigenT.evecs(t).to_array()),
+                                   rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_ket():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.coherent(N, 1.1)
+
+    expected = (op @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_dm():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.coherent_dm(N, 1.1)
+
+    expected = (op @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(op_diag.data, eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_oper_ket():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.operator_to_vector(qutip.coherent_dm(N, 1.1))
+
+    expected = (qutip.spre(op) @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(qutip.spre(op_diag).data,
+                          eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+def test_eigen_transform_super_ops():
+    N = 5
+    a = qutip.destroy(N)
+    op = a*a.dag() + a + a.dag()
+    eigenT = _EigenBasisTransform(qutip.QobjEvo(op))
+    op_diag = qutip.qdiags(eigenT.eigenvalues(0), [0])
+
+    state = qutip.sprepost(
+        qutip.coherent_dm(N, 1.1),
+        qutip.thermal_dm(N, 1.1)
+    )
+
+    expected = (qutip.spre(op) @ state).full()
+    computed = eigenT.from_eigbasis(
+        0,
+        qutip.data.matmul(qutip.spre(op_diag).data,
+                          eigenT.to_eigbasis(0, state.data))
+    ).to_array()
+    np.testing.assert_allclose(computed, expected, rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('func',
+                         [_br_term_dense, _br_term_sparse, _br_term_data],
+                         ids=['dense', 'sparse', 'data'])
+def test_br_term_linbblad_comp(func):
+    N = 5
+    a = qutip.destroy(N) + qutip.destroy(N)**2 / 2
+    A_op = a + a.dag()
+    H = qutip.num(N)
+    diag = H.eigenenergies()
+    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
+    spectrum = (skew > 0) * 1.
+    computation = func(A_op.data, spectrum, skew, 2).to_array()
+    lindblad = qutip.lindblad_dissipator(a).full()
+    np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, np.inf])
+@pytest.mark.parametrize('spectra', [
+    pytest.param(lambda skew: (skew > 0) * 1., id='pos_filter'),
+    pytest.param(lambda skew: np.ones_like(skew), id='no_filter'),
+    pytest.param(lambda skew: np.exp(skew)/10, id='smooth_filter'),
+])
+def test_br_term(cutoff, spectra):
+    N = 5
+    a = qutip.destroy(N) @ qutip.coherent_dm(N, 0.5) * 0.5
+    A_op = a + a.dag()
+    H = qutip.num(N)
+    diag = H.eigenenergies()
+    skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
+    spectrum = spectra(skew)
+    R_dense = _br_term_dense(A_op.data, spectrum, skew, cutoff).to_array()
+    R_sparse = _br_term_sparse(A_op.data, spectrum, skew, cutoff).to_array()
+    R_data = _br_term_data(A_op.data, spectrum, skew, cutoff).to_array()
+    np.testing.assert_allclose(R_dense, R_sparse, rtol=1e-14, atol=1e-14)
+    np.testing.assert_allclose(R_dense, R_data, rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_brterm(cutoff):
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
+    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
+    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
+    assert isinstance(R, qutip.Qobj)
+    assert isinstance(R_eigs, qutip.Qobj)
+    assert isinstance(evecs, qutip.Qobj)
+    state = qutip.operator_to_vector(qutip.rand_dm(N))
+    fock_computed = R @ state
+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
+                               rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_td_brterm(cutoff):
+    N = 5
+    H = qutip.QobjEvo([qutip.num(N), "0.5+t**2"])
+    a = qutip.destroy(N)
+    A_op = qutip.QobjEvo([a + a.dag(), "t"])
+    spectra = qutip.coefficient("(w>0)*0.5", args={'w':0})
+    R = brterm(H, A_op, spectra, cutoff, fock_basis=True)
+    R_eigs, evecs = brterm(H, A_op, spectra, cutoff, fock_basis=False)
+    assert isinstance(R, qutip.QobjEvo)
+    assert isinstance(R_eigs, qutip.QobjEvo)
+    assert isinstance(evecs, qutip.QobjEvo)
+    state = qutip.operator_to_vector(qutip.rand_dm(N))
+    fock_computed = R @ state
+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+    for t in [0, 0.5, 1.0]:
+        np.testing.assert_allclose(
+            (R(t) @ state).full(),
+            R.matmul(t, state).full(),
+            rtol=1e-14, atol=1e-14
+        )
+        np.testing.assert_allclose(fock_computed(t).full(),
+                                   eig_computed(t).full(),
+                                   rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_bloch_redfield_tensor_basis(cutoff):
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+    R = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        sec_cutoff=cutoff,
+        fock_basis=True
+    )
+    R_eigs, evecs = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        sec_cutoff=cutoff,
+        fock_basis=False
+    )
+    assert isinstance(R, qutip.Qobj)
+    assert isinstance(R_eigs, qutip.Qobj)
+    assert isinstance(evecs, qutip.Qobj)
+    state = qutip.operator_to_vector(qutip.rand_dm(N))
+    fock_computed = R @ state
+    eig_computed = R_eigs @ qutip.sprepost(evecs.dag(), evecs) @ state
+    eig_computed = qutip.sprepost(evecs, evecs.dag()) @ eig_computed
+    np.testing.assert_allclose(fock_computed.full(), eig_computed.full(),
+                               rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_bloch_redfield_tensor(cutoff):
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+    R = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        sec_cutoff=cutoff,
+        fock_basis=True
+    )
+    R_expected = qutip.liouvillian(H, [a**2])
+    R_expected += brterm(H, A_op, spectra, cutoff, fock_basis=True)
+
+    assert isinstance(R, qutip.Qobj)
+    assert isinstance(R_expected, qutip.Qobj)
+    np.testing.assert_allclose(R.full(), R_expected.full(),
+                               rtol=1e-14, atol=1e-14)
+
+
+@pytest.mark.parametrize('fock_basis', [True, False])
+@pytest.mark.parametrize('cutoff', [0, 0.1, 1, 3, -1])
+def test_bloch_redfield_tensor_time_dependence(cutoff, fock_basis):
+    N = 3
+    H = qutip.QobjEvo([qutip.num(N), "t"])
+    a = qutip.QobjEvo([qutip.destroy(N), "t/2+0.5"])
+    A_op = a + a.dag()
+    spectra = qutip.coefficient("(w>0) * 0.5", args={'w':0})
+    R = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[qutip.destroy(N)],
+        sec_cutoff=cutoff,
+        fock_basis=fock_basis
+    )
+    R = R[0] if not fock_basis else R
+    assert isinstance(R, qutip.QobjEvo)
+    for t in [0, 0.5, 1.0, 1.5]:
+        R_expected = bloch_redfield_tensor(
+            H=H(t),
+            a_ops=[(A_op(t), spectra)],
+            c_ops=[qutip.destroy(N)],
+            sec_cutoff=cutoff,
+            fock_basis=fock_basis
+        )
+        R_expected = R_expected[0] if not fock_basis else R_expected
+        np.testing.assert_allclose(R(t).full(), R_expected.full(),
+                                   rtol=1e-14, atol=1e-14)
+
+
+def test_bloch_redfield_tensor_spectral_string():
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = "(w>0) * 0.5"
+    R_eigs, evecs = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        fock_basis=False
+    )
+    assert isinstance(R_eigs, qutip.Qobj)
+    assert isinstance(evecs, qutip.Qobj)
+
+def test_bloch_redfield_tensor_spectral_callable():
+    N = 5
+    H = qutip.num(N)
+    a = qutip.destroy(N)
+    A_op = a + a.dag()
+    spectra = lambda w: (w>0) * 0.5
+    R_eigs, evecs = bloch_redfield_tensor(
+        H=H,
+        a_ops=[(A_op, spectra)],
+        c_ops=[a**2],
+        fock_basis=False
+    )
+    assert isinstance(R_eigs, qutip.Qobj)
     assert isinstance(evecs, qutip.Qobj)
\ No newline at end of file
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 5c2807ac95..2fe5ff0b6d 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -1,397 +1,397 @@
-import pytest
-import pickle
-import qutip
-import numpy as np
-import scipy.interpolate as interp
-from functools import partial
-from qutip.core.coefficient import (coefficient, norm, conj,
-                                    CompilationOptions, Coefficient,
-                                    clean_compiled_coefficient
-                                   )
-from qutip.core.options import CoreOptions
-
-# Ensure the latest version is tested
-clean_compiled_coefficient(True)
-
-
-def f(t, w):
-    return np.exp(w * t * np.pi)
-
-
-def g(t, w):
-    return np.cos(w * t * np.pi)
-
-
-def h(t, a, b):
-    return a + b + t
-
-
-def f_kw(t, w, **args):
-    return f(t, w)
-
-
-def g_kw(t, w, **args):
-    return g(t, w)
-
-
-def h_kw(t, a, b, **args):
-    return h(t, a, b)
-
-
-def f_qtv4(t, args):
-    return f(t, args["w"])
-
-
-def g_qtv4(t, args):
-    return g(t, args["w"])
-
-
-def h_qtv4(t, args):
-    return h(t, args["a"], args["b"])
-
-
-def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
-    "assert coeff1 == coeff2"
-    "inside refer to the range covered by tlistlog: [0.01, 1]"
-    ts = np.linspace(0.01, 1, 20)
-    eps = 1e-12
-    crit_times = [0.01+eps, 0.95, 1-eps]
-    if not inside:
-        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
-    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
-    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
-    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
-
-
-args = {"w": 1j}
-tlist = np.linspace(0, 1, 101)
-f_asarray = f(tlist, **args)
-g_asarray = g(tlist, **args)
-tlistlog = np.logspace(-2, 0, 501)
-f_asarraylog = f(tlistlog, **args)
-
-
-def coeff_generator(style, func):
-    """Make a Coefficient"""
-    if func == "f":
-        base = f
-    else:
-        base = g
-
-    if style == "func":
-        return coefficient(base, args=args)
-    if style == "array":
-        return coefficient(base(tlist, **args), tlist=tlist)
-    if style == "arraylog":
-        return coefficient(base(tlistlog, **args), tlist=tlistlog)
-    if style == "string" and func == "f":
-        return coefficient("exp(w * t * pi)", args=args)
-    if style == "string" and func == "g":
-        return coefficient("cos(w * t * pi)", args=args)
-    if style == "steparray":
-        return coefficient(base(tlist, **args), tlist=tlist,
-                           order=0)
-    if style == "steparraylog":
-        return coefficient(base(tlistlog, **args), tlist=tlistlog,
-                           order=0)
-
-
-@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
-    pytest.param(f, {'args': args},
-                 1e-10, id="func"),
-    pytest.param(f_kw, {'args': args},
-                 1e-10, id="func_keywords"),
-    pytest.param(f_qtv4, {'args': args},
-                 1e-10, id="func_qutip_v4"),
-    pytest.param(f_asarray, {'tlist': tlist},
-                 1e-6,  id="array"),
-    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
-                 1e-1, id="step_array"),
-    pytest.param(f_asarraylog, {'tlist': tlistlog},
-                 1e-6, id="nonlinear_array"),
-    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
-                 1e-1, id="nonlinear_step_array"),
-    pytest.param("exp(w * t * pi)", {'args': args},
-                 1e-10, id="string")
-])
-def test_CoeffCreationCall(base, kwargs, tol):
-    opt = CompilationOptions(recompile=True)
-    expected = lambda t: np.exp(1j * t * np.pi)
-    coeff = coefficient(base, **kwargs, compile_opt=opt)
-    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
-
-
-@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
-    pytest.param(f, {'args': args},
-                 1e-10, id="func"),
-    pytest.param(f_kw, {'args': args},
-                 1e-10, id="func_keywords"),
-    pytest.param(f_qtv4, {'args': args},
-                 1e-10, id="func_qutip_v4"),
-    pytest.param("exp(w * t * pi)", {'args': args},
-                 1e-10, id="string")
-])
-def test_CoeffCallArgs(base, kwargs, tol):
-    w = np.e + 0.5j
-    expected = lambda t: np.exp(w * t * np.pi)
-    coeff = coefficient(base, **kwargs)
-    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
-
-
-@pytest.mark.parametrize(['base', 'tol'], [
-    pytest.param(h, 1e-10, id="func"),
-    pytest.param(h_kw, 1e-10, id="func_keywords"),
-    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
-    pytest.param("a + b + t", 1e-10, id="string")
-])
-def test_CoeffCallArguments(base, tol):
-    # Partial args update
-    args = {"a": 1, "b": 1}
-    a = np.e
-    expected = lambda t: a + 1 + t
-    coeff = coefficient(base, args=args)
-    coeff = coeff.replace_arguments({"a": a})
-    _assert_eq_over_interval(coeff, expected, rtol=tol)
-    b = np.pi
-    expected = lambda t: a + b + t
-    coeff = coeff.replace_arguments(b=b)
-    _assert_eq_over_interval(coeff, expected, rtol=tol)
-
-
-@pytest.mark.parametrize(['style'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['transform', 'expected'], [
-    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
-    pytest.param(conj, lambda val: np.conj(val), id="conj"),
-])
-def test_CoeffUnitaryTransform(style, transform, expected):
-    coeff = coeff_generator(style, "f")
-    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
-
-
-@pytest.mark.parametrize(['style_left'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['style_right'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['oper'], [
-    pytest.param(lambda a, b: a+b, id="sum"),
-    pytest.param(lambda a, b: a*b, id="prod"),
-])
-def test_CoeffOperation(style_left, style_right, oper):
-    coeff_left = coeff_generator(style_left, "f")
-    coeff_right = coeff_generator(style_right, "g")
-    _assert_eq_over_interval(
-        oper(coeff_left, coeff_right),
-        lambda t: oper(coeff_left(t), coeff_right(t))
-    )
-
-
-@pytest.mark.requires_cython
-def test_CoeffReuse():
-    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
-    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
-    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
-    assert isinstance(coeff2, coeff1.__class__)
-    assert isinstance(coeff3, coeff1.__class__)
-
-
-@pytest.mark.requires_cython
-def test_CoeffOptions():
-    from itertools import combinations
-    base = "1 + 1. + 1j"
-    options = []
-    options.append(CompilationOptions(accept_int=True))
-    options.append(CompilationOptions(accept_float=False))
-    options.append(CompilationOptions(static_types=True))
-    options.append(CompilationOptions(try_parse=False))
-    options.append(CompilationOptions(use_cython=False))
-    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
-    for coeff in coeffs:
-        assert coeff(0) == 2+1j
-    for coeff1, coeff2 in combinations(coeffs, 2):
-        assert not isinstance(coeff1, coeff2.__class__)
-
-
-@pytest.mark.requires_cython
-@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
-    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
-                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
-                 lambda t: 0, id="long"),
-    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
-                 lambda t: t + 1, id="lots_of_ctes"),
-    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
-                 lambda t: np.cos(t), id="real_array_subscript"),
-    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
-                 lambda t: 1, id="cplx_array_subscript"),
-    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
-                 lambda t: np.cos(t), id="dictargs"),
-    pytest.param("cos(t*a); print(a)", {'a': 1},
-                 lambda t: np.cos(t), id="print"),
-    pytest.param("t + (0 if not 'something' else 1)", {},
-                 lambda t: t + 1, id="branch")
-])
-@pytest.mark.filterwarnings(
-    "ignore::qutip.core.coefficient.StringParsingWarning"
-)
-def test_CoeffParsingStressTest(codestring, args, reference):
-    opt = CompilationOptions(recompile=True)
-    coeff = coefficient(codestring, args=args, compile_opt=opt)
-    _assert_eq_over_interval(coeff, reference)
-
-
-@pytest.mark.requires_cython
-@pytest.mark.filterwarnings("error")
-def test_manual_typing():
-    opt = CompilationOptions(recompile=True)
-    coeff = coefficient("my_list[0] + my_dict[5]",
-                        args={"my_list": [1], "my_dict": {5: 2}},
-                        args_ctypes={"my_list": "list", "my_dict": "dict"},
-                        compile_opt=opt)
-    assert coeff(0) == 3
-
-
-@pytest.mark.requires_cython
-def test_advance_use():
-    opt = CompilationOptions(recompile=True, extra_import="""
-from qutip import basis
-from qutip.core.data cimport CSR
-from qutip.core.data.expect cimport expect_csr
-""")
-    csr = qutip.num(3).data
-    coeff = coefficient("expect_csr(op, op)",
-                        args={"op": csr},
-                        args_ctypes={"op": "CSR"},
-                        compile_opt=opt)
-    assert coeff(0) == 5.
-
-
-def _add(coeff):
-    return coeff + coeff
-
-
-def _pass(coeff):
-    return coeff
-
-
-def _mul(coeff):
-    return coeff * coeff
-
-
-@pytest.mark.parametrize(['style'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['transform'], [
-    pytest.param(_pass, id="single"),
-    pytest.param(_add, id="sum"),
-    pytest.param(_mul, id="prod"),
-    pytest.param(norm, id="norm"),
-    pytest.param(conj, id="conj"),
-])
-def test_Coeffpickle(style, transform):
-    coeff = coeff_generator(style, "f")
-    coeff = transform(coeff)
-    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
-    _assert_eq_over_interval(coeff, coeff_pick)
-
-
-@pytest.mark.parametrize(['style'], [
-    pytest.param("func", id="func"),
-    pytest.param("array", id="array"),
-    pytest.param("arraylog", id="logarray"),
-    pytest.param("string", id="string"),
-    pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
-])
-@pytest.mark.parametrize(['transform'], [
-    pytest.param(_pass, id="single"),
-    pytest.param(_add, id="sum"),
-    pytest.param(_mul, id="prod"),
-    pytest.param(norm, id="norm"),
-    pytest.param(conj, id="conj"),
-])
-def test_Coeffcopy(style, transform):
-    coeff = coeff_generator(style, "f")
-    coeff = transform(coeff)
-    coeff_cp = coeff.copy()
-    _assert_eq_over_interval(coeff, coeff_cp)
-
-
-@pytest.mark.parametrize('order', [0, 1, 2, 3])
-def test_CoeffArray(order):
-    tlist = np.linspace(0, 1, 101)
-    y = np.exp((-1 + 1j) * tlist)
-    coeff = coefficient(y, tlist=tlist, order=order)
-    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
-    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
-                             inside=True)
-    dt = 1e-4
-    t = 0.0225
-    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
-    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
-    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
-             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
-    derrs = [derr, derr2, derr3]
-    for i in range(order):
-        assert derrs[i] != 0
-    for i in range(order, 3):
-        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
-
-
-def test_CoeffFromScipy():
-    tlist = np.linspace(0, 1.01, 101)
-    y = np.exp((-1 + 1j) * tlist)
-
-    coeff = coefficient(y, tlist=tlist, order=3)
-    from_scipy = coefficient(interp.CubicSpline(tlist, y))
-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-
-    coeff = coefficient(y, tlist=tlist, order=3)
-    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-
-    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
-    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
-    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
-
-
-@pytest.mark.parametrize('map_func', [
-    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
-    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
-])
-@pytest.mark.requires_cython
-def test_coefficient_parallel(map_func):
-    otherwise_never_used = "np.log(np.exp(t + t + t))"
-    expected = coefficient(lambda t: 3 * t)
-
-    if map_func is qutip.solver.parallel.loky_pmap:
-        loky = pytest.importorskip("loky")
-        otherwise_never_used += " + 0"
-
-    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
-
-    for coeff in coeffs:
-        assert isinstance(coeff, Coefficient)
-        _assert_eq_over_interval(coeff, expected)
+import pytest
+import pickle
+import qutip
+import numpy as np
+import scipy.interpolate as interp
+from functools import partial
+from qutip.core.coefficient import (coefficient, norm, conj,
+                                    CompilationOptions, Coefficient,
+                                    clean_compiled_coefficient
+                                   )
+from qutip.core.options import CoreOptions
+
+# Ensure the latest version is tested
+clean_compiled_coefficient(True)
+
+
+def f(t, w):
+    return np.exp(w * t * np.pi)
+
+
+def g(t, w):
+    return np.cos(w * t * np.pi)
+
+
+def h(t, a, b):
+    return a + b + t
+
+
+def f_kw(t, w, **args):
+    return f(t, w)
+
+
+def g_kw(t, w, **args):
+    return g(t, w)
+
+
+def h_kw(t, a, b, **args):
+    return h(t, a, b)
+
+
+def f_qtv4(t, args):
+    return f(t, args["w"])
+
+
+def g_qtv4(t, args):
+    return g(t, args["w"])
+
+
+def h_qtv4(t, args):
+    return h(t, args["a"], args["b"])
+
+
+def _assert_eq_over_interval(coeff1, coeff2, rtol=1e-12, inside=False):
+    "assert coeff1 == coeff2"
+    "inside refer to the range covered by tlistlog: [0.01, 1]"
+    ts = np.linspace(0.01, 1, 20)
+    eps = 1e-12
+    crit_times = [0.01+eps, 0.95, 1-eps]
+    if not inside:
+        crit_times += [-0.1, 0, eps, -eps, 1+eps, 1.1]
+    c1 = [coeff1(t) for t in ts] + [coeff1(t) for t in crit_times]
+    c2 = [coeff2(t) for t in ts] + [coeff2(t) for t in crit_times]
+    np.testing.assert_allclose(c1, c2, rtol=rtol, atol=1e-15)
+
+
+args = {"w": 1j}
+tlist = np.linspace(0, 1, 101)
+f_asarray = f(tlist, **args)
+g_asarray = g(tlist, **args)
+tlistlog = np.logspace(-2, 0, 501)
+f_asarraylog = f(tlistlog, **args)
+
+
+def coeff_generator(style, func):
+    """Make a Coefficient"""
+    if func == "f":
+        base = f
+    else:
+        base = g
+
+    if style == "func":
+        return coefficient(base, args=args)
+    if style == "array":
+        return coefficient(base(tlist, **args), tlist=tlist)
+    if style == "arraylog":
+        return coefficient(base(tlistlog, **args), tlist=tlistlog)
+    if style == "string" and func == "f":
+        return coefficient("exp(w * t * pi)", args=args)
+    if style == "string" and func == "g":
+        return coefficient("cos(w * t * pi)", args=args)
+    if style == "steparray":
+        return coefficient(base(tlist, **args), tlist=tlist,
+                           order=0)
+    if style == "steparraylog":
+        return coefficient(base(tlistlog, **args), tlist=tlistlog,
+                           order=0)
+
+
+@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
+    pytest.param(f, {'args': args},
+                 1e-10, id="func"),
+    pytest.param(f_kw, {'args': args},
+                 1e-10, id="func_keywords"),
+    pytest.param(f_qtv4, {'args': args},
+                 1e-10, id="func_qutip_v4"),
+    pytest.param(f_asarray, {'tlist': tlist},
+                 1e-6,  id="array"),
+    pytest.param(f_asarray, {'tlist': tlist, 'order': 0},
+                 1e-1, id="step_array"),
+    pytest.param(f_asarraylog, {'tlist': tlistlog},
+                 1e-6, id="nonlinear_array"),
+    pytest.param(f_asarraylog, {'tlist': tlistlog, 'order': 0},
+                 1e-1, id="nonlinear_step_array"),
+    pytest.param("exp(w * t * pi)", {'args': args},
+                 1e-10, id="string")
+])
+def test_CoeffCreationCall(base, kwargs, tol):
+    opt = CompilationOptions(recompile=True)
+    expected = lambda t: np.exp(1j * t * np.pi)
+    coeff = coefficient(base, **kwargs, compile_opt=opt)
+    _assert_eq_over_interval(coeff, expected, rtol=tol, inside=True)
+
+
+@pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
+    pytest.param(f, {'args': args},
+                 1e-10, id="func"),
+    pytest.param(f_kw, {'args': args},
+                 1e-10, id="func_keywords"),
+    pytest.param(f_qtv4, {'args': args},
+                 1e-10, id="func_qutip_v4"),
+    pytest.param("exp(w * t * pi)", {'args': args},
+                 1e-10, id="string")
+])
+def test_CoeffCallArgs(base, kwargs, tol):
+    w = np.e + 0.5j
+    expected = lambda t: np.exp(w * t * np.pi)
+    coeff = coefficient(base, **kwargs)
+    _assert_eq_over_interval(partial(coeff, w=w), expected, rtol=tol)
+
+
+@pytest.mark.parametrize(['base', 'tol'], [
+    pytest.param(h, 1e-10, id="func"),
+    pytest.param(h_kw, 1e-10, id="func_keywords"),
+    pytest.param(h_qtv4, 1e-10, id="func_qutip_v4"),
+    pytest.param("a + b + t", 1e-10, id="string")
+])
+def test_CoeffCallArguments(base, tol):
+    # Partial args update
+    args = {"a": 1, "b": 1}
+    a = np.e
+    expected = lambda t: a + 1 + t
+    coeff = coefficient(base, args=args)
+    coeff = coeff.replace_arguments({"a": a})
+    _assert_eq_over_interval(coeff, expected, rtol=tol)
+    b = np.pi
+    expected = lambda t: a + b + t
+    coeff = coeff.replace_arguments(b=b)
+    _assert_eq_over_interval(coeff, expected, rtol=tol)
+
+
+@pytest.mark.parametrize(['style'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['transform', 'expected'], [
+    pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
+    pytest.param(conj, lambda val: np.conj(val), id="conj"),
+])
+def test_CoeffUnitaryTransform(style, transform, expected):
+    coeff = coeff_generator(style, "f")
+    _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
+
+
+@pytest.mark.parametrize(['style_left'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['style_right'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['oper'], [
+    pytest.param(lambda a, b: a+b, id="sum"),
+    pytest.param(lambda a, b: a*b, id="prod"),
+])
+def test_CoeffOperation(style_left, style_right, oper):
+    coeff_left = coeff_generator(style_left, "f")
+    coeff_right = coeff_generator(style_right, "g")
+    _assert_eq_over_interval(
+        oper(coeff_left, coeff_right),
+        lambda t: oper(coeff_left(t), coeff_right(t))
+    )
+
+
+@pytest.mark.requires_cython
+def test_CoeffReuse():
+    coeff1 = coefficient("cos(w * t * pi)", args={'w': 3.})
+    coeff2 = coefficient("cos(w2*t * pi)", args={'w2': 1.2})
+    coeff3 = coefficient("cos(  my_var * t*pi)", args={'my_var': -1.2})
+    assert isinstance(coeff2, coeff1.__class__)
+    assert isinstance(coeff3, coeff1.__class__)
+
+
+@pytest.mark.requires_cython
+def test_CoeffOptions():
+    from itertools import combinations
+    base = "1 + 1. + 1j"
+    options = []
+    options.append(CompilationOptions(accept_int=True))
+    options.append(CompilationOptions(accept_float=False))
+    options.append(CompilationOptions(static_types=True))
+    options.append(CompilationOptions(try_parse=False))
+    options.append(CompilationOptions(use_cython=False))
+    coeffs = [coefficient(base, compile_opt=opt) for opt in options]
+    for coeff in coeffs:
+        assert coeff(0) == 2+1j
+    for coeff1, coeff2 in combinations(coeffs, 2):
+        assert not isinstance(coeff1, coeff2.__class__)
+
+
+@pytest.mark.requires_cython
+@pytest.mark.parametrize(['codestring', 'args', 'reference'], [
+    pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"
+                 "- abs(exp(w1*w2*pi*0.25j)) ", {"w1": 2, "w2": 2},
+                 lambda t: 0, id="long"),
+    pytest.param("t*0.5 * (2) + 5j * -0.2j", {},
+                 lambda t: t + 1, id="lots_of_ctes"),
+    pytest.param("cos(t*vec[1])", {'vec': np.ones(2)},
+                 lambda t: np.cos(t), id="real_array_subscript"),
+    pytest.param("cos(t*vec[0])", {'vec': np.zeros(2)*1j},
+                 lambda t: 1, id="cplx_array_subscript"),
+    pytest.param("cos(t*dictionary['key'])", {'dictionary': {'key': 1}},
+                 lambda t: np.cos(t), id="dictargs"),
+    pytest.param("cos(t*a); print(a)", {'a': 1},
+                 lambda t: np.cos(t), id="print"),
+    pytest.param("t + (0 if not 'something' else 1)", {},
+                 lambda t: t + 1, id="branch")
+])
+@pytest.mark.filterwarnings(
+    "ignore::qutip.core.coefficient.StringParsingWarning"
+)
+def test_CoeffParsingStressTest(codestring, args, reference):
+    opt = CompilationOptions(recompile=True)
+    coeff = coefficient(codestring, args=args, compile_opt=opt)
+    _assert_eq_over_interval(coeff, reference)
+
+
+@pytest.mark.requires_cython
+@pytest.mark.filterwarnings("error")
+def test_manual_typing():
+    opt = CompilationOptions(recompile=True)
+    coeff = coefficient("my_list[0] + my_dict[5]",
+                        args={"my_list": [1], "my_dict": {5: 2}},
+                        args_ctypes={"my_list": "list", "my_dict": "dict"},
+                        compile_opt=opt)
+    assert coeff(0) == 3
+
+
+@pytest.mark.requires_cython
+def test_advance_use():
+    opt = CompilationOptions(recompile=True, extra_import="""
+from qutip import basis
+from qutip.core.data cimport CSR
+from qutip.core.data.expect cimport expect_csr
+""")
+    csr = qutip.num(3).data
+    coeff = coefficient("expect_csr(op, op)",
+                        args={"op": csr},
+                        args_ctypes={"op": "CSR"},
+                        compile_opt=opt)
+    assert coeff(0) == 5.
+
+
+def _add(coeff):
+    return coeff + coeff
+
+
+def _pass(coeff):
+    return coeff
+
+
+def _mul(coeff):
+    return coeff * coeff
+
+
+@pytest.mark.parametrize(['style'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['transform'], [
+    pytest.param(_pass, id="single"),
+    pytest.param(_add, id="sum"),
+    pytest.param(_mul, id="prod"),
+    pytest.param(norm, id="norm"),
+    pytest.param(conj, id="conj"),
+])
+def test_Coeffpickle(style, transform):
+    coeff = coeff_generator(style, "f")
+    coeff = transform(coeff)
+    coeff_pick = pickle.loads(pickle.dumps(coeff, -1))
+    _assert_eq_over_interval(coeff, coeff_pick)
+
+
+@pytest.mark.parametrize(['style'], [
+    pytest.param("func", id="func"),
+    pytest.param("array", id="array"),
+    pytest.param("arraylog", id="logarray"),
+    pytest.param("string", id="string"),
+    pytest.param("steparray", id="steparray"),
+    pytest.param("steparraylog", id="steparraylog")
+])
+@pytest.mark.parametrize(['transform'], [
+    pytest.param(_pass, id="single"),
+    pytest.param(_add, id="sum"),
+    pytest.param(_mul, id="prod"),
+    pytest.param(norm, id="norm"),
+    pytest.param(conj, id="conj"),
+])
+def test_Coeffcopy(style, transform):
+    coeff = coeff_generator(style, "f")
+    coeff = transform(coeff)
+    coeff_cp = coeff.copy()
+    _assert_eq_over_interval(coeff, coeff_cp)
+
+
+@pytest.mark.parametrize('order', [0, 1, 2, 3])
+def test_CoeffArray(order):
+    tlist = np.linspace(0, 1, 101)
+    y = np.exp((-1 + 1j) * tlist)
+    coeff = coefficient(y, tlist=tlist, order=order)
+    expected = coefficient(lambda t: np.exp((-1 + 1j) * t))
+    _assert_eq_over_interval(coeff, expected, rtol=0.01**(order+0.8),
+                             inside=True)
+    dt = 1e-4
+    t = 0.0225
+    derr = (coeff(t+dt) - coeff(t-dt)) / (2*dt)
+    derr2 = (coeff(t+dt) + coeff(t-dt) - 2 * coeff(t)) / (dt**2)
+    derr3 = (coeff(t + 2*dt) - 2*coeff(t + dt)
+             + 2*coeff(t - dt) -coeff(t - 2*dt)) / (12 * dt**3)
+    derrs = [derr, derr2, derr3]
+    for i in range(order):
+        assert derrs[i] != 0
+    for i in range(order, 3):
+        assert derrs[i] == pytest.approx(0.0,  abs=0.0001)
+
+
+def test_CoeffFromScipy():
+    tlist = np.linspace(0, 1.01, 101)
+    y = np.exp((-1 + 1j) * tlist)
+
+    coeff = coefficient(y, tlist=tlist, order=3)
+    from_scipy = coefficient(interp.CubicSpline(tlist, y))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
+    coeff = coefficient(y, tlist=tlist, order=3)
+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
+    coeff = coefficient(y, tlist=tlist, order=3, boundary_conditions="natural")
+    from_scipy = coefficient(interp.make_interp_spline(tlist, y, k=3, bc_type="natural"))
+    _assert_eq_over_interval(coeff, from_scipy, rtol=1e-8, inside=True)
+
+
+@pytest.mark.parametrize('map_func', [
+    pytest.param(qutip.solver.parallel.parallel_map, id='parallel_map'),
+    pytest.param(qutip.solver.parallel.loky_pmap, id='loky_pmap'),
+])
+@pytest.mark.requires_cython
+def test_coefficient_parallel(map_func):
+    otherwise_never_used = "np.log(np.exp(t + t + t))"
+    expected = coefficient(lambda t: 3 * t)
+
+    if map_func is qutip.solver.parallel.loky_pmap:
+        loky = pytest.importorskip("loky")
+        otherwise_never_used += " + 0"
+
+    coeffs = map_func(coefficient, [otherwise_never_used] * 10)
+
+    for coeff in coeffs:
+        assert isinstance(coeff, Coefficient)
+        _assert_eq_over_interval(coeff, expected)
diff --git a/qutip/tests/core/test_dimensions.py b/qutip/tests/core/test_dimensions.py
index d21f298385..a32c302941 100644
--- a/qutip/tests/core/test_dimensions.py
+++ b/qutip/tests/core/test_dimensions.py
@@ -1,201 +1,201 @@
-# -*- coding: utf-8 -*-
-
-import pytest
-import collections
-import qutip
-from qutip.core.dimensions import (
-    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
-    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
-    collapse_dims_super, collapse_dims_oper,
-)
-
-_v = "vector"
-_vo = "vectorized_oper"
-
-
-@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
-    pytest.param([1], _v, True, id="scalar"),
-    pytest.param([1, 1], _v, True, id="tensor scalar"),
-    pytest.param([[1]], _vo, True, id="nested scalar"),
-    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
-    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
-    pytest.param([2], _v, False, id="vector"),
-    pytest.param([2, 3], _v, False, id="tensor vector"),
-    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
-    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
-    pytest.param([[2]], _vo, False, id="vectorised operator"),
-    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
-    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
-])
-@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
-def test_rank_type_detection(rank, actual_type, scalar, test_type):
-    """
-    Test the rank detection tests `is_scalar`, `is_vector` and
-    `is_vectorized_oper` for a range of different test cases.  These tests are
-    designed to be called on individual elements of the two-element `dims`
-    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
-
-    It's possible to be both a scalar and something else, but "vector" and
-    "vectorized_oper" are mutually exclusive.
-
-    These functions aren't properly specified for improper dimension setups, so
-    there are no tests for those.
-    """
-    expected = scalar if test_type == "scalar" else (actual_type == test_type)
-    function = getattr(qutip.dimensions, "is_" + test_type)
-    assert function(rank) == expected
-
-
-@pytest.mark.parametrize(["base", "flat"], [
-    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
-    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
-                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
-    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
-    pytest.param([], [], id="empty list"),
-    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
-])
-class TestFlattenUnflatten:
-    def test_flatten(self, base, flat):
-        assert flatten(base) == flat
-
-    def test_unflatten(self, base, flat):
-        labels = enumerate_flat(base)
-        assert unflatten(flat, labels) == base
-
-
-@pytest.mark.parametrize(["base", "expected"], [
-    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
-    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
-    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
-    pytest.param([], [], id="empty"),
-    pytest.param([[], [], [[[], [], []]]],
-                 [[], [], [[[], [], []]]], id="nested empty lists"),
-])
-def test_enumerate_flat(base, expected):
-    assert enumerate_flat(base) == expected
-
-
-@pytest.mark.parametrize(["base", "to_remove", "expected"], [
-    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
-    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
-                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
-    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
-    pytest.param([], (), [], id="empty"),
-])
-def test_deep_remove(base, to_remove, expected):
-    assert deep_remove(base, *to_remove) == expected
-
-
-@pytest.mark.parametrize("mapping", [
-    pytest.param(lambda x: x*2, id="(x -> 2x)"),
-    pytest.param(lambda x: [x], id="(x -> [x])"),
-])
-@pytest.mark.parametrize("base", [
-    pytest.param([[[0], 1], 2], id="standard"),
-    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
-    pytest.param([1, 2, 3], id="flat"),
-    pytest.param([], id="empty list"),
-    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
-])
-def test_deep_map(base, mapping):
-    """
-    Test the deep mapping.  To simplify generation of edge-cases, this tests
-    against an equivalent (but slower) operation of flattening and unflattening
-    the list.  We can get false negatives if the `flatten` or `unflatten`
-    functions are broken, but other tests should catch those.
-    """
-    # This function might not need to be public, and consequently might not
-    # need to be tested here.
-    labels = enumerate_flat(base)
-    expected = unflatten([mapping(x) for x in flatten(base)], labels)
-    assert deep_map(mapping, base) == expected
-
-
-_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
-
-
-@pytest.mark.parametrize("indices", [
-    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
-    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
-                 id="tensor-ket preserved"),
-    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
-    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
-                 id="tensor-bra preserved"),
-    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
-    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
-                 id="tensor-oper preserved"),
-    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
-                          [2, 3, 0, 1, 6, 7, 4, 5],
-                          (6, 8, 2, 4, 5, 7, 1, 3)),
-                 id="super-oper"),
-    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
-                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
-                 id="operator-ket"),
-    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
-                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
-                 id="operator-bra"),
-])
-class TestSuperOperatorDimsModification:
-    def test_dims_to_tensor_perm(self, indices):
-        # This function might not need to be public, and consequently might not
-        # need to be tested here.
-        assert dims_to_tensor_perm(indices.base) == indices.permutation
-
-    def test_dims_idxs_to_tensor_idxs(self, indices):
-        test_indices = list(range(len(flatten(indices.base))))
-        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
-                == indices.permutation)
-
-    def test_dims_to_tensor_shape(self, indices):
-        assert dims_to_tensor_shape(indices.base) == indices.shape
-
-
-class TestTypeFromDims:
-    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
-        pytest.param([[2], [2]], 'oper', True),
-        pytest.param([[2, 3], [2, 3]], 'oper', True),
-        pytest.param([[2], [3]], 'other', True),
-        pytest.param([[2], [3]], 'oper', False),
-        pytest.param([[2], [1]], 'ket', True),
-        pytest.param([[1], [2]], 'bra', True),
-        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
-        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
-        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
-        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
-        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
-    ])
-    def test_type_from_dims(self, base, expected, enforce_square):
-        assert type_from_dims(base, enforce_square=enforce_square) == expected
-
-    @pytest.mark.parametrize("qobj", [
-        pytest.param(qutip.rand_ket(10), id='ket'),
-        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
-        pytest.param(qutip.rand_dm(10), id='oper'),
-        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
-    ])
-    def test_qobj_dims_match_qobj(self, qobj):
-        assert type_from_dims(qobj.dims) == qobj.type
-
-
-class TestCollapseDims:
-    @pytest.mark.parametrize(["base", "expected"], [
-        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
-        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
-        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
-        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
-        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
-        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
-    ])
-    def test_oper(self, base, expected):
-        assert collapse_dims_oper(base) == expected
-
-    @pytest.mark.parametrize(["base", "expected"], [
-        pytest.param([[[1]], [[2, 3], [2, 3]]],
-                     [[[1]], [[6], [6]]], id="operator-ket"),
-        pytest.param([[[2, 3], [2, 3]], [[1]]],
-                     [[[6], [6]], [[1]]], id="operator-bra"),
-        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
-                     [[[6], [6]], [[6], [6]]], id="super"),
-    ])
-    def test_super(self, base, expected):
-        assert collapse_dims_super(base) == expected
+# -*- coding: utf-8 -*-
+
+import pytest
+import collections
+import qutip
+from qutip.core.dimensions import (
+    type_from_dims, flatten, unflatten, enumerate_flat, deep_remove, deep_map,
+    dims_idxs_to_tensor_idxs, dims_to_tensor_shape, dims_to_tensor_perm,
+    collapse_dims_super, collapse_dims_oper,
+)
+
+_v = "vector"
+_vo = "vectorized_oper"
+
+
+@pytest.mark.parametrize(["rank", "actual_type", "scalar"], [
+    pytest.param([1], _v, True, id="scalar"),
+    pytest.param([1, 1], _v, True, id="tensor scalar"),
+    pytest.param([[1]], _vo, True, id="nested scalar"),
+    pytest.param([[1], [1]], _vo, True, id="nested tensor scalar 1"),
+    pytest.param([[1, 1]], _vo, True, id="nested tensor scalar 2"),
+    pytest.param([2], _v, False, id="vector"),
+    pytest.param([2, 3], _v, False, id="tensor vector"),
+    pytest.param([1, 2, 3], _v, False, id="tensor vector with 1d subspace 1"),
+    pytest.param([2, 1, 1], _v, False, id="tensor vector with 1d subspace 2"),
+    pytest.param([[2]], _vo, False, id="vectorised operator"),
+    pytest.param([[2, 3]], _vo, False, id="vector tensor operator"),
+    pytest.param([[1, 3]], _vo, False, id="vector tensor operator with 1d"),
+])
+@pytest.mark.parametrize("test_type", ["scalar", _v, _vo])
+def test_rank_type_detection(rank, actual_type, scalar, test_type):
+    """
+    Test the rank detection tests `is_scalar`, `is_vector` and
+    `is_vectorized_oper` for a range of different test cases.  These tests are
+    designed to be called on individual elements of the two-element `dims`
+    parameter of `Qobj`s, so they're testing the row-rank and column-rank.
+
+    It's possible to be both a scalar and something else, but "vector" and
+    "vectorized_oper" are mutually exclusive.
+
+    These functions aren't properly specified for improper dimension setups, so
+    there are no tests for those.
+    """
+    expected = scalar if test_type == "scalar" else (actual_type == test_type)
+    function = getattr(qutip.dimensions, "is_" + test_type)
+    assert function(rank) == expected
+
+
+@pytest.mark.parametrize(["base", "flat"], [
+    pytest.param([[[0], 1], 2], [0, 1, 2], id="standard"),
+    pytest.param([1, 2, [3, [4]], [5, 6], [7, [[[[[[[8]]]]]]]]],
+                 [1, 2, 3, 4, 5, 6, 7, 8], id="standard"),
+    pytest.param([1, 2, 3], [1, 2, 3], id="already flat"),
+    pytest.param([], [], id="empty list"),
+    pytest.param([[], [], [[[], [], []]]], [], id="nested empty lists"),
+])
+class TestFlattenUnflatten:
+    def test_flatten(self, base, flat):
+        assert flatten(base) == flat
+
+    def test_unflatten(self, base, flat):
+        labels = enumerate_flat(base)
+        assert unflatten(flat, labels) == base
+
+
+@pytest.mark.parametrize(["base", "expected"], [
+    pytest.param([1, 2, 3], [0, 1, 2], id="flat"),
+    pytest.param([[1], [2], [3]], [[0], [1], [2]], id="nested"),
+    pytest.param([[[1], [2, 3]], 4], [[[0], [1, 2]], 3], id="nested"),
+    pytest.param([], [], id="empty"),
+    pytest.param([[], [], [[[], [], []]]],
+                 [[], [], [[[], [], []]]], id="nested empty lists"),
+])
+def test_enumerate_flat(base, expected):
+    assert enumerate_flat(base) == expected
+
+
+@pytest.mark.parametrize(["base", "to_remove", "expected"], [
+    pytest.param([[[0], 1], 2], (1,), [[[0]], 2], id="simple"),
+    pytest.param([[[[0, 1, 2]], [3, 4], [5], [6, 7]]], (0, 5),
+                 [[[[1, 2]], [3, 4], [], [6, 7]]], id="harder"),
+    pytest.param([1, 2, 3], (), [1, 2, 3], id="no-op"),
+    pytest.param([], (), [], id="empty"),
+])
+def test_deep_remove(base, to_remove, expected):
+    assert deep_remove(base, *to_remove) == expected
+
+
+@pytest.mark.parametrize("mapping", [
+    pytest.param(lambda x: x*2, id="(x -> 2x)"),
+    pytest.param(lambda x: [x], id="(x -> [x])"),
+])
+@pytest.mark.parametrize("base", [
+    pytest.param([[[0], 1], 2], id="standard"),
+    pytest.param([1, 2, [3, [4]], [7, [[[[[[[8]]]]]]]]], id="standard"),
+    pytest.param([1, 2, 3], id="flat"),
+    pytest.param([], id="empty list"),
+    pytest.param([[], [], [[[], [], []]]], id="nested empty lists"),
+])
+def test_deep_map(base, mapping):
+    """
+    Test the deep mapping.  To simplify generation of edge-cases, this tests
+    against an equivalent (but slower) operation of flattening and unflattening
+    the list.  We can get false negatives if the `flatten` or `unflatten`
+    functions are broken, but other tests should catch those.
+    """
+    # This function might not need to be public, and consequently might not
+    # need to be tested here.
+    labels = enumerate_flat(base)
+    expected = unflatten([mapping(x) for x in flatten(base)], labels)
+    assert deep_map(mapping, base) == expected
+
+
+_Indices = collections.namedtuple('_Indices', ['base', 'permutation', 'shape'])
+
+
+@pytest.mark.parametrize("indices", [
+    pytest.param(_Indices([[2], [1]], [0, 1], (2, 1)), id="ket preserved"),
+    pytest.param(_Indices([[2, 3], [1, 1]], [0, 1, 2, 3], (2, 3, 1, 1)),
+                 id="tensor-ket preserved"),
+    pytest.param(_Indices([[1], [2]], [0, 1], (1, 2)), id="bra preserved"),
+    pytest.param(_Indices([[1, 1], [2, 2]], [0, 1, 2, 3], (1, 1, 2, 2)),
+                 id="tensor-bra preserved"),
+    pytest.param(_Indices([[2], [3]], [0, 1], (2, 3)), id="oper preserved"),
+    pytest.param(_Indices([[2, 3], [1, 0]], [0, 1, 2, 3], (2, 3, 1, 0)),
+                 id="tensor-oper preserved"),
+    pytest.param(_Indices([[[2, 4], [6, 8]], [[1, 3], [5, 7]]],
+                          [2, 3, 0, 1, 6, 7, 4, 5],
+                          (6, 8, 2, 4, 5, 7, 1, 3)),
+                 id="super-oper"),
+    pytest.param(_Indices([[[2, 4], [6, 8]], [1]],
+                          [0, 1, 2, 3, 4], (2, 4, 6, 8, 1)),
+                 id="operator-ket"),
+    pytest.param(_Indices([[1], [[2, 4], [6, 8]]],
+                          [0, 1, 2, 3, 4], (1, 2, 4, 6, 8)),
+                 id="operator-bra"),
+])
+class TestSuperOperatorDimsModification:
+    def test_dims_to_tensor_perm(self, indices):
+        # This function might not need to be public, and consequently might not
+        # need to be tested here.
+        assert dims_to_tensor_perm(indices.base) == indices.permutation
+
+    def test_dims_idxs_to_tensor_idxs(self, indices):
+        test_indices = list(range(len(flatten(indices.base))))
+        assert (dims_idxs_to_tensor_idxs(indices.base, test_indices)
+                == indices.permutation)
+
+    def test_dims_to_tensor_shape(self, indices):
+        assert dims_to_tensor_shape(indices.base) == indices.shape
+
+
+class TestTypeFromDims:
+    @pytest.mark.parametrize(["base", "expected", "enforce_square"], [
+        pytest.param([[2], [2]], 'oper', True),
+        pytest.param([[2, 3], [2, 3]], 'oper', True),
+        pytest.param([[2], [3]], 'other', True),
+        pytest.param([[2], [3]], 'oper', False),
+        pytest.param([[2], [1]], 'ket', True),
+        pytest.param([[1], [2]], 'bra', True),
+        pytest.param([[[2, 3], [2, 3]], [1]], 'operator-ket', True),
+        pytest.param([[1], [[2, 3], [2, 3]]], 'operator-bra', True),
+        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'other', True),
+        pytest.param([[[3], [3]], [[2, 3], [2, 3]]], 'super', False),
+        pytest.param([[[2], [3, 3]], [[3], [2, 3]]], 'other', True),
+    ])
+    def test_type_from_dims(self, base, expected, enforce_square):
+        assert type_from_dims(base, enforce_square=enforce_square) == expected
+
+    @pytest.mark.parametrize("qobj", [
+        pytest.param(qutip.rand_ket(10), id='ket'),
+        pytest.param(qutip.rand_ket(10).dag(), id='bra'),
+        pytest.param(qutip.rand_dm(10), id='oper'),
+        pytest.param(qutip.to_super(qutip.rand_dm(10)), id='super'),
+    ])
+    def test_qobj_dims_match_qobj(self, qobj):
+        assert type_from_dims(qobj.dims) == qobj.type
+
+
+class TestCollapseDims:
+    @pytest.mark.parametrize(["base", "expected"], [
+        pytest.param([[1], [3]], [[1], [3]], id="ket trivial"),
+        pytest.param([[1, 1], [2, 3]], [[1], [6]], id="ket tensor"),
+        pytest.param([[2], [1]], [[2], [1]], id="bra trivial"),
+        pytest.param([[2, 3], [1, 1]], [[6], [1]], id="bra tensor"),
+        pytest.param([[5], [5]], [[5], [5]], id="oper trivial"),
+        pytest.param([[2, 3], [2, 3]], [[6], [6]], id="oper tensor"),
+    ])
+    def test_oper(self, base, expected):
+        assert collapse_dims_oper(base) == expected
+
+    @pytest.mark.parametrize(["base", "expected"], [
+        pytest.param([[[1]], [[2, 3], [2, 3]]],
+                     [[[1]], [[6], [6]]], id="operator-ket"),
+        pytest.param([[[2, 3], [2, 3]], [[1]]],
+                     [[[6], [6]], [[1]]], id="operator-bra"),
+        pytest.param([[[2, 3], [2, 3]], [[2, 3], [2, 3]]],
+                     [[[6], [6]], [[6], [6]]], id="super"),
+    ])
+    def test_super(self, base, expected):
+        assert collapse_dims_super(base) == expected
diff --git a/qutip/tests/core/test_eigen.py b/qutip/tests/core/test_eigen.py
index 05e06db0fc..ecf6f6093c 100644
--- a/qutip/tests/core/test_eigen.py
+++ b/qutip/tests/core/test_eigen.py
@@ -1,118 +1,118 @@
-import scipy
-import numpy as np
-import pytest
-import qutip
-
-
-def is_eigen_set(oper, vals, vecs):
-    for val, vec in zip(vals, vecs):
-        assert abs(vec.norm() - 1) < 1e-13
-        assert abs(qutip.expect(oper, vec) - val) < 1e-13
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-def test_eigen_known_oper(sparse, dtype):
-    N = qutip.num(10, dtype=dtype)
-    spvals, spvecs = N.eigenstates(sparse=sparse)
-    expected = np.arange(10)
-    is_eigen_set(N, spvals, spvecs)
-    np.testing.assert_allclose(spvals, expected, atol=1e-13)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-@pytest.mark.parametrize(["rand"], [
-    pytest.param(qutip.rand_herm, id="hermitian"),
-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-])
-@pytest.mark.parametrize("order", ['low', 'high'])
-def test_eigen_rand_oper(rand, sparse, dtype, order):
-    H = rand(10, dtype=dtype)
-    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
-    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
-    if order == 'low':
-        assert np.all(np.diff(spvals).real >= 0)
-    else:
-        assert np.all(np.diff(spvals).real <= 0)
-    is_eigen_set(H, spvals, spvecs)
-    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-@pytest.mark.parametrize("rand", [
-    pytest.param(qutip.rand_herm, id="hermitian"),
-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-])
-@pytest.mark.parametrize("order", ['low', 'high'])
-@pytest.mark.parametrize("N", [1, 5, 8, 9])
-def test_FewState(rand, sparse, dtype, order, N):
-    H = rand(10, dtype=dtype)
-    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
-    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
-    assert np.allclose(all_spvals[:N], spvals)
-    is_eigen_set(H, spvals, spvecs)
-    if order == 'low':
-        assert np.all(np.diff(spvals).real >= 0)
-    else:
-        assert np.all(np.diff(spvals).real <= 0)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-@pytest.mark.parametrize(["rand"], [
-    pytest.param(qutip.rand_herm, id="hermitian"),
-    pytest.param(qutip.rand_unitary, id="non-hermitian"),
-])
-@pytest.mark.parametrize("order", ['low', 'high'])
-@pytest.mark.parametrize("N", [1, 5, 8, 9])
-def test_ValsOnly(rand, sparse, dtype, order, N):
-    H = rand(10, dtype=dtype)
-    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
-    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
-    assert np.allclose(all_spvals[:N], spvals)
-    if order == 'low':
-        assert np.all(np.diff(spvals).real >= 0)
-    else:
-        assert np.all(np.diff(spvals).real <= 0)
-
-
-@pytest.mark.parametrize(["sparse", 'dtype'], [
-    pytest.param(True, 'csr', id="sparse"),
-    pytest.param(False, 'csr', id="sparse2dense"),
-    pytest.param(False, 'dense', id="dense"),
-])
-def test_eigen_small(sparse, dtype):
-    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
-    all_spvals = H.eigenenergies(sparse=sparse)
-    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
-    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
-    is_eigen_set(H, spvals, spvecs)
-
-
-def test_BigDenseValsOnly():
-    """
-    This checks eigenvalue calculation for large dense matrices, which
-    historically have had instabilities with certain OS and BLAS combinations
-    (see e.g. #1288 and #1495).
-    """
-    dimension = 2000
-    # Allow an average absolute tolerance for each eigenvalue; we expect
-    # uncertainty in the sum to add in quadrature.
-    tol = 1e-12 * np.sqrt(dimension)
-    H = qutip.rand_herm(dimension, density=1e-2)
-    spvals = H.eigenenergies()
-    assert abs(H.tr() - spvals.sum()) < tol
+import scipy
+import numpy as np
+import pytest
+import qutip
+
+
+def is_eigen_set(oper, vals, vecs):
+    for val, vec in zip(vals, vecs):
+        assert abs(vec.norm() - 1) < 1e-13
+        assert abs(qutip.expect(oper, vec) - val) < 1e-13
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+def test_eigen_known_oper(sparse, dtype):
+    N = qutip.num(10, dtype=dtype)
+    spvals, spvecs = N.eigenstates(sparse=sparse)
+    expected = np.arange(10)
+    is_eigen_set(N, spvals, spvecs)
+    np.testing.assert_allclose(spvals, expected, atol=1e-13)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+@pytest.mark.parametrize(["rand"], [
+    pytest.param(qutip.rand_herm, id="hermitian"),
+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+])
+@pytest.mark.parametrize("order", ['low', 'high'])
+def test_eigen_rand_oper(rand, sparse, dtype, order):
+    H = rand(10, dtype=dtype)
+    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order)
+    sp_energies = H.eigenenergies(sparse=sparse, sort=order)
+    if order == 'low':
+        assert np.all(np.diff(spvals).real >= 0)
+    else:
+        assert np.all(np.diff(spvals).real <= 0)
+    is_eigen_set(H, spvals, spvecs)
+    np.testing.assert_allclose(spvals, sp_energies, atol=5e-15)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+@pytest.mark.parametrize("rand", [
+    pytest.param(qutip.rand_herm, id="hermitian"),
+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+])
+@pytest.mark.parametrize("order", ['low', 'high'])
+@pytest.mark.parametrize("N", [1, 5, 8, 9])
+def test_FewState(rand, sparse, dtype, order, N):
+    H = rand(10, dtype=dtype)
+    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
+    spvals, spvecs = H.eigenstates(sparse=sparse, sort=order, eigvals=N)
+    assert np.allclose(all_spvals[:N], spvals)
+    is_eigen_set(H, spvals, spvecs)
+    if order == 'low':
+        assert np.all(np.diff(spvals).real >= 0)
+    else:
+        assert np.all(np.diff(spvals).real <= 0)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+@pytest.mark.parametrize(["rand"], [
+    pytest.param(qutip.rand_herm, id="hermitian"),
+    pytest.param(qutip.rand_unitary, id="non-hermitian"),
+])
+@pytest.mark.parametrize("order", ['low', 'high'])
+@pytest.mark.parametrize("N", [1, 5, 8, 9])
+def test_ValsOnly(rand, sparse, dtype, order, N):
+    H = rand(10, dtype=dtype)
+    all_spvals = H.eigenenergies(sparse=sparse, sort=order)
+    spvals = H.eigenenergies(sparse=sparse, sort=order, eigvals=N)
+    assert np.allclose(all_spvals[:N], spvals)
+    if order == 'low':
+        assert np.all(np.diff(spvals).real >= 0)
+    else:
+        assert np.all(np.diff(spvals).real <= 0)
+
+
+@pytest.mark.parametrize(["sparse", 'dtype'], [
+    pytest.param(True, 'csr', id="sparse"),
+    pytest.param(False, 'csr', id="sparse2dense"),
+    pytest.param(False, 'dense', id="dense"),
+])
+def test_eigen_small(sparse, dtype):
+    H = (qutip.sigmax() + qutip.sigmaz()).to(dtype)
+    all_spvals = H.eigenenergies(sparse=sparse)
+    spvals, spvecs = H.eigenstates(sparse=sparse, eigvals=1)
+    assert np.abs(all_spvals[0] - spvals[0]) <= 1e-14
+    is_eigen_set(H, spvals, spvecs)
+
+
+def test_BigDenseValsOnly():
+    """
+    This checks eigenvalue calculation for large dense matrices, which
+    historically have had instabilities with certain OS and BLAS combinations
+    (see e.g. #1288 and #1495).
+    """
+    dimension = 2000
+    # Allow an average absolute tolerance for each eigenvalue; we expect
+    # uncertainty in the sum to add in quadrature.
+    tol = 1e-12 * np.sqrt(dimension)
+    H = qutip.rand_herm(dimension, density=1e-2)
+    spvals = H.eigenenergies()
+    assert abs(H.tr() - spvals.sum()) < tol
diff --git a/qutip/tests/core/test_eigenstates.py b/qutip/tests/core/test_eigenstates.py
index bbd00c2281..e03add4be1 100644
--- a/qutip/tests/core/test_eigenstates.py
+++ b/qutip/tests/core/test_eigenstates.py
@@ -1,98 +1,98 @@
-import pytest
-import numpy as np
-import qutip
-from itertools import combinations
-
-
-def _canonicalise_eigenvector(vec):
-    """
-    Normalise an eigenvector so that the first non-zero value is equal to one,
-    and the array is flattened.  Just normalising based on vector magnitude
-    isn't enough to fully fix the gauge because the vectors could still be
-    multiplied by a unit complex number.
-    """
-    vec = vec.flatten()
-    nonzero = vec != 0
-    if not np.any(nonzero):
-        return vec
-    return vec / vec[np.argmax(nonzero)]
-
-
-# Random diagonal Hamiltonian.
-_diagonal_dimension = 10
-_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
-_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
-                                  for n in range(_diagonal_dimension)])
-_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
-
-# Arbitrary known non-diagonal complex Hamiltonian.
-_nondiagonal_hamiltonian = qutip.Qobj(np.array([
-    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
-    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
-    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
-_nondiagonal_eigenvalues = np.array([
-    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
-_nondiagonal_eigenstates = np.array([
-    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
-     0.009793118179759598+0.3029065489313791j],
-    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
-     -0.3741560255426259+0.6067259021655438j],
-    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
-     -0.5593181579625106+0.2953063897306936j]])
-
-
-@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
-    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
-    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
-                 _diagonal_eigenstates,
-                 id="diagonal-"+str(_diagonal_dimension)),
-    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
-    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
-                 _nondiagonal_eigenstates, id="non-diagonal"),
-])
-def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
-    test_values, test_states = hamiltonian.eigenstates()
-    eigenvalues = np.array(eigenvalues)
-    eigenstates = np.array(eigenstates)
-    test_order = np.argsort(test_values)
-    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
-                    for i in test_order]
-    expected_order = np.argsort(eigenvalues)
-    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
-                        for i in expected_order]
-    np.testing.assert_allclose(test_values[test_order],
-                               eigenvalues[expected_order],
-                               atol=1e-10)
-    for test, expected in zip(test_vectors, expected_vectors):
-        np.testing.assert_allclose(test, expected, atol=1e-10)
-
-
-# Specify parametrisation over a random Hamiltonian by specifying the
-# dimensions, rather than duplicating that logic.
-@pytest.fixture(params=[
-    pytest.param([10], id="simple"),
-    pytest.param([5, 3, 4], id="tensor"),
-    pytest.param([3, 3, 3], id="degenerate")])
-def random_hamiltonian(request):
-    dimensions = request.param
-    eigen = None
-    dist = "fill"
-    if dimensions == [3, 3, 3]:
-        eigen = [0, 1, 1] * 9
-        dist = "eigen"
-    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
-
-
-@pytest.mark.parametrize('sparse', [True, False])
-@pytest.mark.parametrize('dtype', ['csr', 'dense'])
-def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
-    random_hamiltonian = random_hamiltonian.to(dtype)
-    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
-    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
-        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
-                                   (eigenvalue * eigenstate).full(),
-                                   atol=1e-10)
-        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
-    errors = [evec1.overlap(evec2)
-              for evec1, evec2 in combinations(eigenstates, 2)]
-    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
+import pytest
+import numpy as np
+import qutip
+from itertools import combinations
+
+
+def _canonicalise_eigenvector(vec):
+    """
+    Normalise an eigenvector so that the first non-zero value is equal to one,
+    and the array is flattened.  Just normalising based on vector magnitude
+    isn't enough to fully fix the gauge because the vectors could still be
+    multiplied by a unit complex number.
+    """
+    vec = vec.flatten()
+    nonzero = vec != 0
+    if not np.any(nonzero):
+        return vec
+    return vec / vec[np.argmax(nonzero)]
+
+
+# Random diagonal Hamiltonian.
+_diagonal_dimension = 10
+_diagonal_eigenvalues = np.sort(np.random.rand(_diagonal_dimension))
+_diagonal_eigenstates = np.array([[0]*n + [1] + [0]*(_diagonal_dimension-n-1)
+                                  for n in range(_diagonal_dimension)])
+_diagonal_hamiltonian = qutip.qdiags(_diagonal_eigenvalues, 0)
+
+# Arbitrary known non-diagonal complex Hamiltonian.
+_nondiagonal_hamiltonian = qutip.Qobj(np.array([
+    [0.16252356,             0.27696416+0.0405202j,  0.19577420+0.07815636j],
+    [0.27696416-0.0405202j,  0.45859633,             0.36222915+0.17372725j],
+    [0.19577420-0.07815636j, 0.36222915-0.17372725j, 0.44149665]]))
+_nondiagonal_eigenvalues = np.array([
+    -0.022062710138316392, 0.08888141616526818, 0.995797833973048])
+_nondiagonal_eigenstates = np.array([
+    [-0.737511505546763, 0.5270680510449308-0.29398599661318j,
+     0.009793118179759598+0.3029065489313791j],
+    [0.5552814080417957, 0.23570050756381764 - 0.3577691669342573j,
+     -0.3741560255426259+0.6067259021655438j],
+    [-0.3843687514214284, -0.670810624386174+0.04723455831286158j,
+     -0.5593181579625106+0.2953063897306936j]])
+
+
+@pytest.mark.parametrize(["hamiltonian", "eigenvalues", "eigenstates"], [
+    pytest.param(qutip.sigmaz(), [-1, 1], [[0, 1], [1, 0]], id="diagonal-2"),
+    pytest.param(_diagonal_hamiltonian, _diagonal_eigenvalues,
+                 _diagonal_eigenstates,
+                 id="diagonal-"+str(_diagonal_dimension)),
+    pytest.param(qutip.sigmax(), [-1, 1], [[-1, 1], [1, 1]], id="sigmax"),
+    pytest.param(_nondiagonal_hamiltonian, _nondiagonal_eigenvalues,
+                 _nondiagonal_eigenstates, id="non-diagonal"),
+])
+def test_known_eigensystem(hamiltonian, eigenvalues, eigenstates):
+    test_values, test_states = hamiltonian.eigenstates()
+    eigenvalues = np.array(eigenvalues)
+    eigenstates = np.array(eigenstates)
+    test_order = np.argsort(test_values)
+    test_vectors = [_canonicalise_eigenvector(test_states[i].full())
+                    for i in test_order]
+    expected_order = np.argsort(eigenvalues)
+    expected_vectors = [_canonicalise_eigenvector(eigenstates[i])
+                        for i in expected_order]
+    np.testing.assert_allclose(test_values[test_order],
+                               eigenvalues[expected_order],
+                               atol=1e-10)
+    for test, expected in zip(test_vectors, expected_vectors):
+        np.testing.assert_allclose(test, expected, atol=1e-10)
+
+
+# Specify parametrisation over a random Hamiltonian by specifying the
+# dimensions, rather than duplicating that logic.
+@pytest.fixture(params=[
+    pytest.param([10], id="simple"),
+    pytest.param([5, 3, 4], id="tensor"),
+    pytest.param([3, 3, 3], id="degenerate")])
+def random_hamiltonian(request):
+    dimensions = request.param
+    eigen = None
+    dist = "fill"
+    if dimensions == [3, 3, 3]:
+        eigen = [0, 1, 1] * 9
+        dist = "eigen"
+    return qutip.rand_herm(dimensions, distribution=dist, eigenvalues=eigen)
+
+
+@pytest.mark.parametrize('sparse', [True, False])
+@pytest.mark.parametrize('dtype', ['csr', 'dense'])
+def test_satisfy_eigenvalue_equation(random_hamiltonian, sparse, dtype):
+    random_hamiltonian = random_hamiltonian.to(dtype)
+    eigenvalues, eigenstates = random_hamiltonian.eigenstates(sparse=sparse)
+    for eigenvalue, eigenstate in zip(eigenvalues, eigenstates):
+        np.testing.assert_allclose((random_hamiltonian * eigenstate).full(),
+                                   (eigenvalue * eigenstate).full(),
+                                   atol=1e-10)
+        assert eigenstate.norm() == pytest.approx(1., abs=1e-10)
+    errors = [evec1.overlap(evec2)
+              for evec1, evec2 in combinations(eigenstates, 2)]
+    assert np.max(np.abs(errors)) == pytest.approx(0., abs=1e-8)
diff --git a/qutip/tests/core/test_expect.py b/qutip/tests/core/test_expect.py
index 96e7ff0fbd..906880ceca 100644
--- a/qutip/tests/core/test_expect.py
+++ b/qutip/tests/core/test_expect.py
@@ -1,179 +1,179 @@
-import pytest
-import collections
-import functools
-import numpy as np
-import qutip
-from qutip.core.data import CSR, Dense
-import qutip.core.data as _data
-
-# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
-# of different systems, without having to repeatedly specify the systems over
-# and over again.  We first store a small number of test cases for known
-# expectation value in the most bundled-up form, because it's easier to unroll
-# these by applying the expected broadcasting rules explicitly ourselves than
-# performing the inverse operation.
-#
-# We store a single test case in a record type, just to keep things neatly
-# together while we're munging them, so it's clear at all times what
-# constitutes a valid test case.
-
-_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
-
-
-def _case_to_dm(case):
-    return case._replace(state=[x.proj() for x in case.state])
-
-
-def _unwrap(list_):
-    """Unwrap lists until we reach the first non-list element."""
-    out = list_
-    while isinstance(out, list):
-        out = out[0]
-    return out
-
-
-def _case_id(case):
-    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
-    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
-    return op_part + "-" + state_part
-
-
-# This is the minimal set of test cases, with a Fock system and a qubit system
-# both in ket form and dm form.  The reference expectations are a 2D array
-# which would be found by broadcasting `operator` against `state` and applying
-# `qutip.expect` to the pairs.
-_dim = 5
-_num, _a = qutip.num(_dim), qutip.destroy(_dim)
-_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
-_known_fock = _Case([_num, _a],
-                    [qutip.fock(_dim, n) for n in range(_dim)],
-                    np.array([np.arange(_dim), np.zeros(_dim)]))
-_known_qubit = _Case([_sx, _sz, _sp],
-                     [qutip.basis(2, 0), qutip.basis(2, 1)],
-                     np.array([[0, 0], [1, -1], [0, 0]]))
-_known_cases = [_known_fock, _case_to_dm(_known_fock),
-                _known_qubit, _case_to_dm(_known_qubit)]
-
-
-class TestKnownExpectation:
-    def pytest_generate_tests(self, metafunc):
-        """
-        Perform the parametrisation over the test cases, performing the
-        explicit broadcasting into separate test cases when required.
-
-        We detect whether to perform explicit broadcasting over one of the
-        arguments of the `_Case` by looking for a singular/plural name of the
-        parameter in the test.  If the parameter is singular, then we manually
-        perform the broadcasting rule for that fixture, and parametrise over
-        the resulting list, taking care to pick out the correct parts of the
-        reference array.
-        """
-        cases = _known_cases
-        op_name, state_name = 'operator', 'state'
-        if op_name not in metafunc.fixturenames:
-            op_name += 's'
-        else:
-            cases = [_Case(op, case.state, expected)
-                     for case in cases
-                     for op, expected in zip(case.operator, case.expected)]
-        if state_name not in metafunc.fixturenames:
-            state_name += 's'
-        else:
-            cases = [_Case(case.operator, state, expected)
-                     for case in cases
-                     for state, expected in zip(case.state, case.expected.T)]
-        metafunc.parametrize([op_name, state_name, 'expected'], cases,
-                             ids=[_case_id(case) for case in cases])
-
-    def test_operator_by_basis(self, operator, state, expected):
-        result = qutip.expect(operator, state)
-        assert result == expected
-        assert isinstance(result, float if operator.isherm else complex)
-
-    def test_broadcast_operator_list(self, operators, state, expected):
-        result = qutip.expect(operators, state)
-        expected_dtype = (np.float64 if all(op.isherm for op in operators)
-                          else np.complex128)
-        assert isinstance(result, np.ndarray)
-        assert result.dtype == expected_dtype
-        assert list(result) == list(expected)
-
-    def test_broadcast_state_list(self, operator, states, expected):
-        result = qutip.expect(operator, states)
-        expected_dtype = np.float64 if operator.isherm else np.complex128
-        assert isinstance(result, np.ndarray)
-        assert result.dtype == expected_dtype
-        assert list(result) == list(expected)
-
-    def test_broadcast_both_lists(self, operators, states, expected):
-        result = qutip.expect(operators, states)
-        assert len(result) == len(operators)
-        for part, operator, expected_part in zip(result, operators, expected):
-            expected_dtype = np.float64 if operator.isherm else np.complex128
-            assert isinstance(part, np.ndarray)
-            assert part.dtype == expected_dtype
-            assert list(part) == list(expected_part)
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
-@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
-@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
-def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
-    dimension = 20
-    state = qutip.rand_ket(dimension, 0.3).to(op_type)
-    op = qutip.rand_herm(dimension, 0.2).to(state_type)
-    if not hermitian:
-        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
-    expected = state.dag() * op * state
-    assert abs(qutip.expect(op, state) - expected) < 1e-14
-
-
-@pytest.mark.parametrize("solve", [
-    pytest.param(qutip.sesolve, id="sesolve"),
-    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
-                 id="mesolve"),
-])
-def test_compatibility_with_solver(solve):
-    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
-    e_ops += [lambda t, psi: np.sin(t)]
-    h = qutip.sigmax()
-    state = qutip.basis(2, 0)
-    times = np.linspace(0, 10, 101)
-    options = {"store_states":True}
-    result = solve(h, state, times, e_ops=e_ops, options=options)
-    direct, states = result.expect, result.states
-    indirect = qutip.expect(e_ops[:-1], states)
-    # check measurement operators based on quantum objects
-    assert len(direct)-1 == len(indirect)
-    for direct_, indirect_ in zip(direct, indirect):
-        assert len(direct_) == len(indirect_)
-        assert isinstance(direct_, np.ndarray)
-        assert isinstance(indirect_, np.ndarray)
-        assert direct_.dtype == indirect_.dtype
-        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
-        # test measurement operators based on lambda functions
-        direct_ = direct[-1]
-        indirect_ = np.sin(times)
-        assert len(direct_) == len(indirect_)
-        assert isinstance(direct_, np.ndarray)
-        assert isinstance(indirect_, np.ndarray)
-        assert direct_.dtype == indirect_.dtype
-        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
-
-
-def test_no_real_attribute(monkeypatch):
-    """This tests ensures that expect still works even if the output of a
-    specialisation does not have the ``real`` attribute. This is the case for
-    the tensorflow and cupy data layers."""
-
-    def mocker_expect_return(oper, state):
-        """
-        We simply return None which does not have the `real` attribute.
-        """
-        return "object without .real"
-
-    monkeypatch.setattr(_data, "expect", mocker_expect_return)
-
-    sz = qutip.sigmaz() # the choice of the matrix does not matter
-    assert "object without .real" == qutip.expect(sz, sz)
+import pytest
+import collections
+import functools
+import numpy as np
+import qutip
+from qutip.core.data import CSR, Dense
+import qutip.core.data as _data
+
+# We want to test the broadcasting rules for `qutip.expect` for a whole bunch
+# of different systems, without having to repeatedly specify the systems over
+# and over again.  We first store a small number of test cases for known
+# expectation value in the most bundled-up form, because it's easier to unroll
+# these by applying the expected broadcasting rules explicitly ourselves than
+# performing the inverse operation.
+#
+# We store a single test case in a record type, just to keep things neatly
+# together while we're munging them, so it's clear at all times what
+# constitutes a valid test case.
+
+_Case = collections.namedtuple('_Case', ['operator', 'state', 'expected'])
+
+
+def _case_to_dm(case):
+    return case._replace(state=[x.proj() for x in case.state])
+
+
+def _unwrap(list_):
+    """Unwrap lists until we reach the first non-list element."""
+    out = list_
+    while isinstance(out, list):
+        out = out[0]
+    return out
+
+
+def _case_id(case):
+    op_part = 'qubit' if _unwrap(case.operator).dims[0][0] == 2 else 'basis'
+    state_part = 'ket' if _unwrap(case.state).dims[1][0] == 1 else 'dm'
+    return op_part + "-" + state_part
+
+
+# This is the minimal set of test cases, with a Fock system and a qubit system
+# both in ket form and dm form.  The reference expectations are a 2D array
+# which would be found by broadcasting `operator` against `state` and applying
+# `qutip.expect` to the pairs.
+_dim = 5
+_num, _a = qutip.num(_dim), qutip.destroy(_dim)
+_sx, _sz, _sp = qutip.sigmax(), qutip.sigmaz(), qutip.sigmap()
+_known_fock = _Case([_num, _a],
+                    [qutip.fock(_dim, n) for n in range(_dim)],
+                    np.array([np.arange(_dim), np.zeros(_dim)]))
+_known_qubit = _Case([_sx, _sz, _sp],
+                     [qutip.basis(2, 0), qutip.basis(2, 1)],
+                     np.array([[0, 0], [1, -1], [0, 0]]))
+_known_cases = [_known_fock, _case_to_dm(_known_fock),
+                _known_qubit, _case_to_dm(_known_qubit)]
+
+
+class TestKnownExpectation:
+    def pytest_generate_tests(self, metafunc):
+        """
+        Perform the parametrisation over the test cases, performing the
+        explicit broadcasting into separate test cases when required.
+
+        We detect whether to perform explicit broadcasting over one of the
+        arguments of the `_Case` by looking for a singular/plural name of the
+        parameter in the test.  If the parameter is singular, then we manually
+        perform the broadcasting rule for that fixture, and parametrise over
+        the resulting list, taking care to pick out the correct parts of the
+        reference array.
+        """
+        cases = _known_cases
+        op_name, state_name = 'operator', 'state'
+        if op_name not in metafunc.fixturenames:
+            op_name += 's'
+        else:
+            cases = [_Case(op, case.state, expected)
+                     for case in cases
+                     for op, expected in zip(case.operator, case.expected)]
+        if state_name not in metafunc.fixturenames:
+            state_name += 's'
+        else:
+            cases = [_Case(case.operator, state, expected)
+                     for case in cases
+                     for state, expected in zip(case.state, case.expected.T)]
+        metafunc.parametrize([op_name, state_name, 'expected'], cases,
+                             ids=[_case_id(case) for case in cases])
+
+    def test_operator_by_basis(self, operator, state, expected):
+        result = qutip.expect(operator, state)
+        assert result == expected
+        assert isinstance(result, float if operator.isherm else complex)
+
+    def test_broadcast_operator_list(self, operators, state, expected):
+        result = qutip.expect(operators, state)
+        expected_dtype = (np.float64 if all(op.isherm for op in operators)
+                          else np.complex128)
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == expected_dtype
+        assert list(result) == list(expected)
+
+    def test_broadcast_state_list(self, operator, states, expected):
+        result = qutip.expect(operator, states)
+        expected_dtype = np.float64 if operator.isherm else np.complex128
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == expected_dtype
+        assert list(result) == list(expected)
+
+    def test_broadcast_both_lists(self, operators, states, expected):
+        result = qutip.expect(operators, states)
+        assert len(result) == len(operators)
+        for part, operator, expected_part in zip(result, operators, expected):
+            expected_dtype = np.float64 if operator.isherm else np.complex128
+            assert isinstance(part, np.ndarray)
+            assert part.dtype == expected_dtype
+            assert list(part) == list(expected_part)
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize("hermitian", [False, True], ids=['complex', 'real'])
+@pytest.mark.parametrize("op_type", [CSR, Dense], ids=['csr', 'dense'])
+@pytest.mark.parametrize("state_type", [CSR, Dense], ids=['csr', 'dense'])
+def test_equivalent_to_matrix_element(hermitian, op_type, state_type):
+    dimension = 20
+    state = qutip.rand_ket(dimension, 0.3).to(op_type)
+    op = qutip.rand_herm(dimension, 0.2).to(state_type)
+    if not hermitian:
+        op = op + 1j*qutip.rand_herm(dimension, 0.1).to(state_type)
+    expected = state.dag() * op * state
+    assert abs(qutip.expect(op, state) - expected) < 1e-14
+
+
+@pytest.mark.parametrize("solve", [
+    pytest.param(qutip.sesolve, id="sesolve"),
+    pytest.param(functools.partial(qutip.mesolve, c_ops=[qutip.qzero(2)]),
+                 id="mesolve"),
+])
+def test_compatibility_with_solver(solve):
+    e_ops = [getattr(qutip, 'sigma'+x)() for x in 'xyzmp']
+    e_ops += [lambda t, psi: np.sin(t)]
+    h = qutip.sigmax()
+    state = qutip.basis(2, 0)
+    times = np.linspace(0, 10, 101)
+    options = {"store_states":True}
+    result = solve(h, state, times, e_ops=e_ops, options=options)
+    direct, states = result.expect, result.states
+    indirect = qutip.expect(e_ops[:-1], states)
+    # check measurement operators based on quantum objects
+    assert len(direct)-1 == len(indirect)
+    for direct_, indirect_ in zip(direct, indirect):
+        assert len(direct_) == len(indirect_)
+        assert isinstance(direct_, np.ndarray)
+        assert isinstance(indirect_, np.ndarray)
+        assert direct_.dtype == indirect_.dtype
+        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
+        # test measurement operators based on lambda functions
+        direct_ = direct[-1]
+        indirect_ = np.sin(times)
+        assert len(direct_) == len(indirect_)
+        assert isinstance(direct_, np.ndarray)
+        assert isinstance(indirect_, np.ndarray)
+        assert direct_.dtype == indirect_.dtype
+        np.testing.assert_allclose(np.array(direct_), indirect_, atol=1e-12)
+
+
+def test_no_real_attribute(monkeypatch):
+    """This tests ensures that expect still works even if the output of a
+    specialisation does not have the ``real`` attribute. This is the case for
+    the tensorflow and cupy data layers."""
+
+    def mocker_expect_return(oper, state):
+        """
+        We simply return None which does not have the `real` attribute.
+        """
+        return "object without .real"
+
+    monkeypatch.setattr(_data, "expect", mocker_expect_return)
+
+    sz = qutip.sigmaz() # the choice of the matrix does not matter
+    assert "object without .real" == qutip.expect(sz, sz)
diff --git a/qutip/tests/core/test_gates.py b/qutip/tests/core/test_gates.py
index 92f81c7f5c..7b3795b50d 100644
--- a/qutip/tests/core/test_gates.py
+++ b/qutip/tests/core/test_gates.py
@@ -1,144 +1,144 @@
-import pytest
-import numpy as np
-import qutip
-from qutip.core import gates
-
-
-def _infidelity(a, b):
-    """Infidelity between two kets."""
-    return 1 - abs(a.overlap(b))
-
-
-def _remove_global_phase(qobj):
-    """
-    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
-    we set the first non-zero element to be purely real-positive.
-    """
-    flat = qobj.tidyup(1e-14).full().flat.copy()
-    for phase in flat:
-        if phase != 0:
-            # Fix the gauge for any global phase.
-            flat = flat * np.exp(-1j * np.angle(phase))
-            break
-    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
-
-
-def _make_random_three_qubit_gate():
-    """Create a random three-qubit gate."""
-    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
-
-    def gate(N=None, controls=None, target=None):
-        if N is None:
-            return operation
-        return gates.gate_expand_3toN(operation, N, controls, target)
-    return gate
-
-
-def _make_controled(op):
-    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
-    out += qutip.tensor(qutip.fock_dm(2, 1), op)
-    return out
-
-
-class TestExplicitForm:
-    def test_swap(self):
-        states = [qutip.rand_ket(2) for _ in [None]*2]
-        start = qutip.tensor(states)
-        swapped = qutip.tensor(states[::-1])
-        swap = gates.swap()
-        assert _infidelity(swapped, swap*start) < 1e-12
-        assert _infidelity(start, swap*swap*start) < 1e-12
-
-    @pytest.mark.parametrize(["gate", "cgate", "args"], [
-        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
-        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
-        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
-        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
-        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
-        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
-        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
-        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
-        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
-    ])
-    def test_controled(self, gate, cgate, args):
-        expected = _make_controled(gate(*args))
-        assert cgate(*args) == expected
-
-    @pytest.mark.parametrize(["gate", "power", "expected"], [
-        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
-        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
-        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
-        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
-                     id="berkeley"),
-        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
-        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
-        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
-    ])
-    def gate_power_relation(self, gate, expected, power):
-        assert gate()**power == expected()
-
-    @pytest.mark.parametrize(['angle', 'expected'], [
-        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
-                     id="pi"),
-        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
-    ])
-    def test_molmer_sorensen(self, angle, expected):
-        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
-                                   expected.full(), atol=1e-15)
-
-    @pytest.mark.parametrize(["gate", "n_angles"], [
-        pytest.param(gates.rx, 1, id="Rx"),
-        pytest.param(gates.ry, 1, id="Ry"),
-        pytest.param(gates.rz, 1, id="Rz"),
-        pytest.param(gates.phasegate, 1, id="phase"),
-        pytest.param(gates.qrot, 2, id="Rabi rotation"),
-    ])
-    def test_zero_rotations_are_identity(self, gate, n_angles):
-        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
-                                   atol=1e-15)
-
-    def test_hadamard(self):
-        N = 3
-        expected = qutip.tensor([gates.snot()] * N)
-        assert gates.hadamard_transform(N) == expected
-
-    def test_globalphase(self):
-        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
-
-
-class TestCliffordGroup:
-    """
-    Test a sufficient set of conditions to prove that we have a full Clifford
-    group for a single qubit.
-    """
-    clifford = gates.qubit_clifford_group()
-    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-
-    def test_single_qubit_group_dimension_is_24(self):
-        assert len(self.clifford) == 24
-
-    def test_all_elements_different(self):
-        clifford = [_remove_global_phase(gate) for gate in self.clifford]
-        for i, gate in enumerate(clifford):
-            for other in clifford[i+1:]:
-                # Big tolerance because we actually want to test the inverse.
-                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
-
-    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
-    def test_gate_normalises_pauli_group(self, gate):
-        """
-        Test the fundamental definition of the Clifford group, i.e. that it
-        normalises the Pauli group.
-        """
-        # Assert that each Clifford gate maps the set of Pauli gates back onto
-        # itself (though not necessarily in order).  This condition is no
-        # stronger than simply considering each (gate, Pauli) pair separately.
-        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
-        normalised = [_remove_global_phase(gate * pauli * gate.dag())
-                      for pauli in self.pauli]
-        for gate in normalised:
-            for i, pauli in enumerate(pauli_gates):
-                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
-                    del pauli_gates[i]
-                    break
-        assert len(pauli_gates) == 0
+import pytest
+import numpy as np
+import qutip
+from qutip.core import gates
+
+
+def _infidelity(a, b):
+    """Infidelity between two kets."""
+    return 1 - abs(a.overlap(b))
+
+
+def _remove_global_phase(qobj):
+    """
+    Return a new Qobj with the gauge fixed for the global phase.  Explicitly,
+    we set the first non-zero element to be purely real-positive.
+    """
+    flat = qobj.tidyup(1e-14).full().flat.copy()
+    for phase in flat:
+        if phase != 0:
+            # Fix the gauge for any global phase.
+            flat = flat * np.exp(-1j * np.angle(phase))
+            break
+    return qutip.Qobj(flat.reshape(qobj.shape), dims=qobj.dims)
+
+
+def _make_random_three_qubit_gate():
+    """Create a random three-qubit gate."""
+    operation = qutip.rand_unitary(8, dims=[[2]*3]*2)
+
+    def gate(N=None, controls=None, target=None):
+        if N is None:
+            return operation
+        return gates.gate_expand_3toN(operation, N, controls, target)
+    return gate
+
+
+def _make_controled(op):
+    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
+    out += qutip.tensor(qutip.fock_dm(2, 1), op)
+    return out
+
+
+class TestExplicitForm:
+    def test_swap(self):
+        states = [qutip.rand_ket(2) for _ in [None]*2]
+        start = qutip.tensor(states)
+        swapped = qutip.tensor(states[::-1])
+        swap = gates.swap()
+        assert _infidelity(swapped, swap*start) < 1e-12
+        assert _infidelity(start, swap*swap*start) < 1e-12
+
+    @pytest.mark.parametrize(["gate", "cgate", "args"], [
+        pytest.param(qutip.sigmax, gates.cnot, (), id="cnot"),
+        pytest.param(qutip.sigmay, gates.cy_gate, (), id="cy_gate"),
+        pytest.param(qutip.sigmaz, gates.cz_gate, (), id="cz_gate"),
+        pytest.param(gates.s_gate, gates.cs_gate, (), id="cs_gate"),
+        pytest.param(gates.t_gate, gates.ct_gate, (), id="ct_gate"),
+        pytest.param(gates.phasegate, gates.cphase, (0.1,), id="cphase"),
+        pytest.param(qutip.sigmaz, gates.csign, (), id="csign"),
+        pytest.param(gates.swap, gates.fredkin, (), id="fredkin"),
+        pytest.param(gates.cnot, gates.toffoli, (), id="toffoli"),
+    ])
+    def test_controled(self, gate, cgate, args):
+        expected = _make_controled(gate(*args))
+        assert cgate(*args) == expected
+
+    @pytest.mark.parametrize(["gate", "power", "expected"], [
+        pytest.param(gates.snot, 2, lambda : qutip.qeye(2), id="snot"),
+        pytest.param(gates.s_gate, 4, lambda : qutip.qeye(2), id="s_gate"),
+        pytest.param(gates.t_gate, 8, lambda : qutip.qeye(2), id="t_gate"),
+        pytest.param(gates.berkeley, 8, lambda : -qutip.qeye([2, 2]),
+                     id="berkeley"),
+        pytest.param(gates.sqrtnot, 2, qutip.sigmax, id="sqrtnot"),
+        pytest.param(gates.sqrtswap, 2, gates.swap, id="cs_gate"),
+        pytest.param(gates.sqrtiswap, 2, gates.iswap, id="ct_gate"),
+    ])
+    def gate_power_relation(self, gate, expected, power):
+        assert gate()**power == expected()
+
+    @pytest.mark.parametrize(['angle', 'expected'], [
+        pytest.param(np.pi, -1j*qutip.tensor(qutip.sigmax(), qutip.sigmax()),
+                     id="pi"),
+        pytest.param(2*np.pi, -qutip.qeye([2, 2]), id="2pi"),
+    ])
+    def test_molmer_sorensen(self, angle, expected):
+        np.testing.assert_allclose(gates.molmer_sorensen(angle).full(),
+                                   expected.full(), atol=1e-15)
+
+    @pytest.mark.parametrize(["gate", "n_angles"], [
+        pytest.param(gates.rx, 1, id="Rx"),
+        pytest.param(gates.ry, 1, id="Ry"),
+        pytest.param(gates.rz, 1, id="Rz"),
+        pytest.param(gates.phasegate, 1, id="phase"),
+        pytest.param(gates.qrot, 2, id="Rabi rotation"),
+    ])
+    def test_zero_rotations_are_identity(self, gate, n_angles):
+        np.testing.assert_allclose(np.eye(2), gate(*([0]*n_angles)).full(),
+                                   atol=1e-15)
+
+    def test_hadamard(self):
+        N = 3
+        expected = qutip.tensor([gates.snot()] * N)
+        assert gates.hadamard_transform(N) == expected
+
+    def test_globalphase(self):
+        assert gates.globalphase(1, 3) * np.exp(-1j) == qutip.qeye([2] * 3)
+
+
+class TestCliffordGroup:
+    """
+    Test a sufficient set of conditions to prove that we have a full Clifford
+    group for a single qubit.
+    """
+    clifford = gates.qubit_clifford_group()
+    pauli = [qutip.qeye(2), qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+
+    def test_single_qubit_group_dimension_is_24(self):
+        assert len(self.clifford) == 24
+
+    def test_all_elements_different(self):
+        clifford = [_remove_global_phase(gate) for gate in self.clifford]
+        for i, gate in enumerate(clifford):
+            for other in clifford[i+1:]:
+                # Big tolerance because we actually want to test the inverse.
+                assert not np.allclose(gate.full(), other.full(), atol=1e-3)
+
+    @pytest.mark.parametrize("gate", gates.qubit_clifford_group())
+    def test_gate_normalises_pauli_group(self, gate):
+        """
+        Test the fundamental definition of the Clifford group, i.e. that it
+        normalises the Pauli group.
+        """
+        # Assert that each Clifford gate maps the set of Pauli gates back onto
+        # itself (though not necessarily in order).  This condition is no
+        # stronger than simply considering each (gate, Pauli) pair separately.
+        pauli_gates = [_remove_global_phase(x) for x in self.pauli]
+        normalised = [_remove_global_phase(gate * pauli * gate.dag())
+                      for pauli in self.pauli]
+        for gate in normalised:
+            for i, pauli in enumerate(pauli_gates):
+                if np.allclose(gate.full(), pauli.full(), atol=1e-10):
+                    del pauli_gates[i]
+                    break
+        assert len(pauli_gates) == 0
diff --git a/qutip/tests/core/test_metrics.py b/qutip/tests/core/test_metrics.py
index 945c1cfb66..e52a074b32 100644
--- a/qutip/tests/core/test_metrics.py
+++ b/qutip/tests/core/test_metrics.py
@@ -1,551 +1,551 @@
-# -*- coding: utf-8 -*-
-
-import platform
-
-import numpy as np
-import pytest
-
-from qutip import (
-    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
-    qeye, rand_ket, rand_super_bcsz, rand_dm,
-    rand_unitary, to_super, to_choi, kraus_to_choi,
-    to_chi, to_kraus,
-)
-from qutip.core.gates import snot, swap
-
-try:
-    import cvxpy
-    import cvxopt
-except ImportError:
-    cvxpy, cvxopt = None, None
-
-# These ones are the metrics functions that we actually want to test.
-from qutip import (
-    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
-    unitarity, hilbert_dist, bures_dist, process_fidelity,
-)
-from qutip.core.metrics import _hilbert_space_dims
-
-
-@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
-def dimension(request):
-    # There are also some cases in the file where this fixture is explicitly
-    # overridden by a more local mark.  That is deliberate; this dimension is
-    # intended for non-superoperators, and may cause inordinantly long tests if
-    # (for example) something uses dimension=100 then makes a superoperator out
-    # of it.
-    return request.param
-
-
-@pytest.fixture(scope="function", params=[
-    pytest.param(rand_ket, id="pure"),
-    pytest.param(rand_dm, id="mixed"),
-])
-def state(request, dimension):
-    return request.param(dimension)
-
-
-# Also parametrise left, right as if they're the names of two states for tests
-# that need to take two states.
-left = right = state
-
-
-# The class names have an unusual naming convention to make them more
-# convenient to use with the `pytest -k "expr"` selection syntax.  They start
-# with the standard `Test`, but then are the name of the function they are
-# testing in the function naming convention, so it's easy to remember the
-# selector to choose a particular function.
-
-class Test_fidelity:
-    def test_mixed_state_inequality(self, dimension):
-        tol = 1e-7
-        rho1 = rand_dm(dimension, density=0.25)
-        rho2 = rand_dm(dimension, density=0.25)
-        F = fidelity(rho1, rho2)
-        assert 1 - F <= np.sqrt(1 - F*F) + tol
-
-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-    def test_orthogonal(self, left_dm, right_dm, dimension):
-        left = basis(dimension, 0)
-        right = basis(dimension, dimension//2)
-        if left_dm:
-            left = left.proj()
-        if right_dm:
-            right = right.proj()
-        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
-
-    def test_invariant_under_unitary_transformation(self, dimension):
-        rho1 = rand_dm(dimension, density=0.25)
-        rho2 = rand_dm(dimension, density=0.25)
-        U = rand_unitary(dimension)
-        F = fidelity(rho1, rho2)
-        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
-        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
-
-    def test_state_with_itself(self, state):
-        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
-
-    def test_bounded(self, left, right, dimension):
-        """Test that fidelity is bounded on [0, 1]."""
-        tol = 1e-7
-        assert -tol <= fidelity(left, right) <= 1 + tol
-
-    def test_pure_state_equivalent_to_overlap(self, dimension):
-        """Check fidelity against pure-state overlap, see gh-361."""
-        psi = rand_ket(dimension)
-        phi = rand_ket(dimension)
-        overlap = np.abs(psi.overlap(phi))
-        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
-
-    ket_0 = basis(2, 0)
-    ket_1 = basis(2, 1)
-    ket_p = (ket_0 + ket_1).unit()
-    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
-    max_mixed = qeye(2).unit()
-
-    @pytest.mark.parametrize(['left', 'right', 'expected'], [
-        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
-        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
-        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
-        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
-                     id="|+>,|+'>"),
-    ])
-    def test_known_cases(self, left, right, expected):
-        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
-
-
-class Test_tracedist:
-    def test_state_with_itself(self, state):
-        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
-
-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-    def test_orthogonal(self, left_dm, right_dm, dimension):
-        left = basis(dimension, 0)
-        right = basis(dimension, dimension//2)
-        if left_dm:
-            left = left.proj()
-        if right_dm:
-            right = right.proj()
-        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
-
-    def test_invariant_under_unitary_transformation(self, dimension):
-        rho1 = rand_dm(dimension, density=0.25)
-        rho2 = rand_dm(dimension, density=0.25)
-        U = rand_unitary(dimension)
-        D = tracedist(rho1, rho2)
-        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
-        assert D == pytest.approx(DU, rel=1e-5)
-
-
-class Test_hellinger_dist:
-    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
-    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
-    def test_orthogonal(self, left_dm, right_dm, dimension):
-        left = basis(dimension, 0)
-        right = basis(dimension, dimension//2)
-        if left_dm:
-            left = left.proj()
-        if right_dm:
-            right = right.proj()
-        expected = np.sqrt(2)
-        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
-
-    def test_state_with_itself(self, state):
-        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
-
-    def test_known_cases_pure_states(self, dimension):
-        left = rand_ket(dimension)
-        right = rand_ket(dimension)
-        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
-        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
-
-    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
-    def test_monotonicity(self, dimension):
-        """
-        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
-        arXiv:1611.03449v2:
-            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
-            >= hellinger_dist(rhoA, sigmaA)
-        with equality iff sigmaB = rhoB where '&' is the tensor product.
-        """
-        tol = 1e-5
-        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
-        rho = tensor(rhoA, rhoB)
-        rho_sim = tensor(rhoA, sigmaB)
-        sigma = tensor(sigmaA, sigmaB)
-        dist = hellinger_dist(rhoA, sigmaA)
-        assert hellinger_dist(rho, sigma) + tol > dist
-        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
-
-
-class Test_average_gate_fidelity:
-    def test_identity(self, dimension):
-        id = qeye(dimension)
-        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
-
-    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
-    def test_bounded(self, dimension):
-        tol = 1e-7
-        channel = rand_super_bcsz(dimension)
-        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
-
-    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
-    def test_unitaries_equal_1(self, dimension):
-        """Tests that for random unitaries U, AGF(U, U) = 1."""
-        tol = 1e-7
-        U = rand_unitary(dimension)
-        SU = to_super(U)
-        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
-
-    def test_average_gate_fidelity_against_legacy_implementation(self):
-        """
-        Metrics: Test that AGF coincides with pre-5.0 implementation
-        """
-        def agf_pre_50(oper, target=None):
-            kraus = to_kraus(oper)
-            d = kraus[0].shape[0]
-
-            if kraus[0].shape[1] != d:
-                return TypeError(
-                    "Average gate fidelity only implemented for square "
-                    "superoperators.")
-
-            if target is None:
-                return (
-                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
-                    (d * d + d)
-                )
-            return (
-                (d + np.sum([
-                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
-                ])) / (d * d + d)
-            )
-
-        oper = rand_super_bcsz(16)
-        target = rand_unitary(16)
-        np.testing.assert_almost_equal(
-            average_gate_fidelity(oper, target),
-            agf_pre_50(oper, target)
-        )
-
-
-class Test_hilbert_dist:
-    def test_known_cases(self):
-        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
-        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
-        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
-
-
-paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
-
-
-class Test_unitarity:
-    @pytest.mark.parametrize(['operator', 'expected'], [
-        pytest.param(to_super(sigmax()), 1, id="sigmax"),
-        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
-        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
-                     id="id+sigmax"),
-    ])
-    def test_known_cases(self, operator, expected):
-        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
-
-    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
-    def test_bounded(self, n_qubits):
-        tol = 1e-7
-        operator = rand_super_bcsz(2**n_qubits)
-        assert -tol <= unitarity(operator) <= 1 + tol
-
-
-class TestComparisons:
-    """Test some known inequalities between two different metrics."""
-
-    def test_inequality_tracedist_to_fidelity(self, left, right):
-        tol = 1e-7
-        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
-
-    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
-        tol = 1e-7
-        hellinger = hellinger_dist(left, right)
-        bures = bures_dist(left, right)
-        assert bures <= hellinger + tol
-
-
-def overrotation(x):
-    return to_super((1j * np.pi * x * sigmax() / 2).expm())
-
-
-def had_mixture(x):
-    id_chan = to_choi(qeye(2))
-    S_eye = to_super(id_chan)
-    S_H = to_super(snot())
-    return (1 - x) * S_eye + x * S_H
-
-
-def swap_map(x):
-    base = (1j * x * swap()).expm()
-    dims = [[[2], [2]], [[2], [2]]]
-    return Qobj(base, dims=dims, type='super', superrep='super')
-
-
-def adc_choi(x):
-    kraus = [
-        np.sqrt(1 - x) * qeye(2),
-        np.sqrt(x) * destroy(2),
-        np.sqrt(x) * fock_dm(2, 0),
-    ]
-    return kraus_to_choi(kraus)
-
-
-# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
-# to solve the problem, and this can cause an entire test-suite failure.  As
-# long as we are using random tests (perhaps not ideal), this will happen
-# occasionally.  This isn't entirely a bug, it's just a reality of using a
-# one-size-fits-all solver; we've historically assumed users who come up
-# against this sort of thing will be accepting of the fact that dnorm
-# calculation is nontrivial, and isn't always entirely feasible.
-#
-# To deal with it, we allow each test to be rerun twice, using
-# pytest-rerunfailures.  This should forbid pathological cases where the test
-# is failing every time, but not penalise one-off failures.  As far as we know,
-# the failing tests always involve a random step, so triggering a re-run will
-# have them choose new variables as well.
-#
-# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
-# which is deprecated as of numpy 1.20.
-#
-# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
-# depends on them.
-@pytest.mark.skipif(cvxpy is None or cvxopt is None,
-                    reason="Skipping dnorm tests because dnorm requires cvxpy"
-                    " and cvxopt which are not installed.")
-@pytest.mark.skipif("Windows" in platform.system(),
-                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
-                    " installed on Windows but fail to correctly solve"
-                    " the given optimization problems.")
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.filterwarnings(
-    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
-)
-class Test_dnorm:
-    @pytest.fixture(params=[2, 3])
-    def dimension(self, request):
-        return request.param
-
-    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
-    def sparse(self, request):
-        return request.param
-
-    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
-    def test_sparse_against_dense_adc(self, variable):
-        """
-        Test sparse versus dense dnorm calculation for a sample of
-        amplitude-damping channels.
-        """
-        # Choi matrix for identity channel on 1 qubit
-        A = kraus_to_choi([qeye(2)])
-        B = adc_choi(variable)
-        dense = dnorm(A, B, force_solve=True, sparse=False)
-        sparse = dnorm(A, B, force_solve=True, sparse=True)
-        assert dense == pytest.approx(sparse, abs=1e-7)
-
-    @pytest.mark.repeat(3)
-    def test_sparse_against_dense_random(self, dimension):
-        """
-        Test sparse versus dense dnorm calculation for random superoperators.
-        """
-        A = rand_super_bcsz(dimension)
-        dense_run_result = dnorm(A, force_solve=True, sparse=False)
-        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
-        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
-
-    def test_bounded(self, dimension, sparse):
-        """dnorm(A - B) in [0, 2] for random superops A, B."""
-        tol = 1e-7
-        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
-        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
-
-    def test_qubit_simple_known_cases(self, sparse):
-        """Check agreement for known qubit channels."""
-        id_chan = to_choi(qeye(2))
-        X_chan = to_choi(sigmax())
-        depol = to_choi(Qobj(
-            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
-        ))
-        # We need to restrict the number of iterations for things on the
-        # boundary, such as perfectly distinguishable channels.
-        assert (
-            dnorm(id_chan, X_chan, sparse=sparse)
-            == pytest.approx(2, abs=1e-7)
-        )
-        assert (
-            dnorm(id_chan, depol, sparse=sparse)
-            == pytest.approx(1.5, abs=1e-7)
-        )
-        # Finally, we add a known case from Johnston's QETLAB documentation,
-        #   || Phi - I ||_♢,
-        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
-        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
-        assert (
-            dnorm(U, qeye(2), sparse=sparse)
-            == pytest.approx(np.sqrt(2), abs=1e-7)
-        )
-
-    @pytest.mark.parametrize(["variable", "expected", "generator"], [
-        [1.0e-3, 3.141591e-03, overrotation],
-        [3.1e-3, 9.738899e-03, overrotation],
-        [1.0e-2, 3.141463e-02, overrotation],
-        [3.1e-2, 9.735089e-02, overrotation],
-        [1.0e-1, 3.128689e-01, overrotation],
-        [3.1e-1, 9.358596e-01, overrotation],
-        [1.0e-3, 2.000000e-03, had_mixture],
-        [3.1e-3, 6.200000e-03, had_mixture],
-        [1.0e-2, 2.000000e-02, had_mixture],
-        [3.1e-2, 6.200000e-02, had_mixture],
-        [1.0e-1, 2.000000e-01, had_mixture],
-        [3.1e-1, 6.200000e-01, had_mixture],
-        [1.0e-3, 2.000000e-03, swap_map],
-        [3.1e-3, 6.199997e-03, swap_map],
-        [1.0e-2, 1.999992e-02, swap_map],
-        [3.1e-2, 6.199752e-02, swap_map],
-        [1.0e-1, 1.999162e-01, swap_map],
-        [3.1e-1, 6.173918e-01, swap_map],
-    ])
-    def test_qubit_known_cases(self, variable, expected, generator, sparse):
-        """
-        Test cases based on comparisons to pre-existing dnorm implementations.
-        In particular, the targets for the following test cases were generated
-        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
-        """
-        id_chan = to_choi(qeye(2))
-        channel = generator(variable)
-        assert (
-            dnorm(channel, id_chan, sparse=sparse)
-            == pytest.approx(expected, abs=1e-7)
-        )
-
-    def test_qubit_scalar(self, dimension):
-        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
-        a = np.random.random()
-        A = rand_super_bcsz(dimension)
-        B = rand_super_bcsz(dimension)
-        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
-
-    def test_qubit_triangle(self, dimension):
-        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
-        A = rand_super_bcsz(dimension)
-        B = rand_super_bcsz(dimension)
-        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
-
-    @pytest.mark.repeat(3)
-    @pytest.mark.parametrize("generator", [
-        pytest.param(rand_super_bcsz, id="super"),
-        pytest.param(rand_unitary, id="unitary"),
-    ])
-    def test_force_solve(self, dimension, generator):
-        """
-        Metrics: checks that special cases for dnorm agree with SDP solutions.
-        """
-        A, B = generator(dimension), generator(dimension)
-        assert (
-            dnorm(A, B, force_solve=False)
-            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
-        )
-
-    @pytest.mark.repeat(3)
-    def test_cptp(self, dimension, sparse):
-        """Check that the diamond norm is one for CPTP maps."""
-        A = rand_super_bcsz(dimension)
-        assert A.iscptp
-        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
-
-
-@pytest.mark.parametrize('superrep_conversion',
-                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
-def test_process_fidelity_of_identity(superrep_conversion):
-    """
-    Metrics: process fidelity of identity map is 1
-    """
-    num_qubits = 3
-    oper = qeye(num_qubits*[2])
-    f = process_fidelity(superrep_conversion(oper))
-    assert np.isrealobj(f)
-    assert f == pytest.approx(1)
-
-
-@pytest.mark.parametrize('superrep_conversion',
-                         [to_super, to_choi, to_chi, to_kraus])
-def test_process_fidelity_identical_channels(superrep_conversion):
-    """
-    Metrics: process fidelity of a map to itself is 1
-    """
-    num_qubits = 2
-    for k in range(10):
-        oper = rand_super_bcsz(num_qubits*[2])
-        oper = superrep_conversion(oper)
-        f = process_fidelity(oper, oper)
-        assert f == pytest.approx(1)
-
-
-def test_process_fidelity_identical_unitaries():
-    """
-    Metrics: process fidelity of a unitary to itself is 1
-    """
-    num_qubits = 3
-    for k in range(10):
-        oper = rand_unitary(num_qubits * [2])
-        f = process_fidelity(oper, oper)
-        assert f == pytest.approx(1)
-
-
-def test_process_fidelity_consistency():
-    """
-    Metrics: process fidelity independent of how channels are represented
-    """
-    num_qubits = 2
-    for k in range(10):
-        fidelities_u_to_u = []
-        fidelities_u_to_id = []
-        u1 = rand_unitary(num_qubits * [2])
-        u2 = rand_unitary(num_qubits * [2])
-        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
-            fidelities_u_to_id.append(process_fidelity(map1(u1)))
-            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
-                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
-        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
-        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
-
-
-def test_process_fidelity_unitary_invariance():
-    """
-    Metrics: process fidelity, invariance under unitary trans.
-    """
-    for k in range(10):
-        op1 = rand_super_bcsz(10)
-        op2 = rand_super_bcsz(10)
-        u = to_super(rand_unitary(10))
-        assert abs(
-            process_fidelity(op1, op2)
-            - process_fidelity(u*op1, u*op2)
-        ) < 1e-8
-
-
-@pytest.mark.parametrize('superrep_conversion',
-                         [lambda x: x, to_super, to_choi, to_kraus])
-def test_hilbert_space_dims(superrep_conversion):
-    """
-    Metrics: check _hilbert_space_dims
-    """
-    dims = [[2, 3], [4, 5]]
-    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
-    assert _hilbert_space_dims(superrep_conversion(u)) == dims
-
-
-def test_hilbert_space_dims_chi():
-    """
-    Metrics: check _hilbert_space_dims for a chi channel
-    """
-    dims = [[2, 2], [2, 2]]
-    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
-    assert _hilbert_space_dims(to_chi(u)) == dims
+# -*- coding: utf-8 -*-
+
+import platform
+
+import numpy as np
+import pytest
+
+from qutip import (
+    Qobj, tensor, fock_dm, basis, destroy, qdiags, sigmax, sigmay, sigmaz,
+    qeye, rand_ket, rand_super_bcsz, rand_dm,
+    rand_unitary, to_super, to_choi, kraus_to_choi,
+    to_chi, to_kraus,
+)
+from qutip.core.gates import snot, swap
+
+try:
+    import cvxpy
+    import cvxopt
+except ImportError:
+    cvxpy, cvxopt = None, None
+
+# These ones are the metrics functions that we actually want to test.
+from qutip import (
+    fidelity, tracedist, hellinger_dist, dnorm, average_gate_fidelity,
+    unitarity, hilbert_dist, bures_dist, process_fidelity,
+)
+from qutip.core.metrics import _hilbert_space_dims
+
+
+@pytest.fixture(scope="function", params=[2, 5, 10, 15, 25, 100])
+def dimension(request):
+    # There are also some cases in the file where this fixture is explicitly
+    # overridden by a more local mark.  That is deliberate; this dimension is
+    # intended for non-superoperators, and may cause inordinantly long tests if
+    # (for example) something uses dimension=100 then makes a superoperator out
+    # of it.
+    return request.param
+
+
+@pytest.fixture(scope="function", params=[
+    pytest.param(rand_ket, id="pure"),
+    pytest.param(rand_dm, id="mixed"),
+])
+def state(request, dimension):
+    return request.param(dimension)
+
+
+# Also parametrise left, right as if they're the names of two states for tests
+# that need to take two states.
+left = right = state
+
+
+# The class names have an unusual naming convention to make them more
+# convenient to use with the `pytest -k "expr"` selection syntax.  They start
+# with the standard `Test`, but then are the name of the function they are
+# testing in the function naming convention, so it's easy to remember the
+# selector to choose a particular function.
+
+class Test_fidelity:
+    def test_mixed_state_inequality(self, dimension):
+        tol = 1e-7
+        rho1 = rand_dm(dimension, density=0.25)
+        rho2 = rand_dm(dimension, density=0.25)
+        F = fidelity(rho1, rho2)
+        assert 1 - F <= np.sqrt(1 - F*F) + tol
+
+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+    def test_orthogonal(self, left_dm, right_dm, dimension):
+        left = basis(dimension, 0)
+        right = basis(dimension, dimension//2)
+        if left_dm:
+            left = left.proj()
+        if right_dm:
+            right = right.proj()
+        assert fidelity(left, right) == pytest.approx(0, abs=1e-6)
+
+    def test_invariant_under_unitary_transformation(self, dimension):
+        rho1 = rand_dm(dimension, density=0.25)
+        rho2 = rand_dm(dimension, density=0.25)
+        U = rand_unitary(dimension)
+        F = fidelity(rho1, rho2)
+        FU = fidelity(U*rho1*U.dag(), U*rho2*U.dag())
+        assert F == pytest.approx(FU, rel=1e-5, abs=1e-7)
+
+    def test_state_with_itself(self, state):
+        assert fidelity(state, state) == pytest.approx(1, abs=1e-6)
+
+    def test_bounded(self, left, right, dimension):
+        """Test that fidelity is bounded on [0, 1]."""
+        tol = 1e-7
+        assert -tol <= fidelity(left, right) <= 1 + tol
+
+    def test_pure_state_equivalent_to_overlap(self, dimension):
+        """Check fidelity against pure-state overlap, see gh-361."""
+        psi = rand_ket(dimension)
+        phi = rand_ket(dimension)
+        overlap = np.abs(psi.overlap(phi))
+        assert fidelity(psi, phi) == pytest.approx(overlap, abs=1e-7)
+
+    ket_0 = basis(2, 0)
+    ket_1 = basis(2, 1)
+    ket_p = (ket_0 + ket_1).unit()
+    ket_py = (ket_0 + np.exp(0.25j*np.pi)*ket_1).unit()
+    max_mixed = qeye(2).unit()
+
+    @pytest.mark.parametrize(['left', 'right', 'expected'], [
+        pytest.param(ket_0, ket_p, np.sqrt(0.5), id="|0>,|+>"),
+        pytest.param(ket_0, ket_1, 0, id="|0>,|1>"),
+        pytest.param(ket_0, max_mixed, np.sqrt(0.5), id="|0>,id/2"),
+        pytest.param(ket_p, ket_py, np.sqrt(0.125 + (0.5+np.sqrt(0.125))**2),
+                     id="|+>,|+'>"),
+    ])
+    def test_known_cases(self, left, right, expected):
+        assert fidelity(left, right) == pytest.approx(expected, abs=1e-7)
+
+
+class Test_tracedist:
+    def test_state_with_itself(self, state):
+        assert tracedist(state, state) == pytest.approx(0, abs=1e-6)
+
+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+    def test_orthogonal(self, left_dm, right_dm, dimension):
+        left = basis(dimension, 0)
+        right = basis(dimension, dimension//2)
+        if left_dm:
+            left = left.proj()
+        if right_dm:
+            right = right.proj()
+        assert tracedist(left, right) == pytest.approx(1, abs=1e-6)
+
+    def test_invariant_under_unitary_transformation(self, dimension):
+        rho1 = rand_dm(dimension, density=0.25)
+        rho2 = rand_dm(dimension, density=0.25)
+        U = rand_unitary(dimension)
+        D = tracedist(rho1, rho2)
+        DU = tracedist(U*rho1*U.dag(), U*rho2*U.dag())
+        assert D == pytest.approx(DU, rel=1e-5)
+
+
+class Test_hellinger_dist:
+    @pytest.mark.parametrize('right_dm', [True, False], ids=['mixed', 'pure'])
+    @pytest.mark.parametrize('left_dm', [True, False], ids=['mixed', 'pure'])
+    def test_orthogonal(self, left_dm, right_dm, dimension):
+        left = basis(dimension, 0)
+        right = basis(dimension, dimension//2)
+        if left_dm:
+            left = left.proj()
+        if right_dm:
+            right = right.proj()
+        expected = np.sqrt(2)
+        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-6)
+
+    def test_state_with_itself(self, state):
+        assert hellinger_dist(state, state) == pytest.approx(0, abs=1e-6)
+
+    def test_known_cases_pure_states(self, dimension):
+        left = rand_ket(dimension)
+        right = rand_ket(dimension)
+        expected = np.sqrt(2 * (1 - np.abs(left.overlap(right))**2))
+        assert hellinger_dist(left, right) == pytest.approx(expected, abs=1e-7)
+
+    @pytest.mark.parametrize('dimension', [2, 5, 10, 25])
+    def test_monotonicity(self, dimension):
+        """
+        Check monotonicity w.r.t. tensor product, see. Eq. (45) in
+        arXiv:1611.03449v2:
+            hellinger_dist(rhoA & rhoB, sigmaA & sigmaB)
+            >= hellinger_dist(rhoA, sigmaA)
+        with equality iff sigmaB = rhoB where '&' is the tensor product.
+        """
+        tol = 1e-5
+        rhoA, rhoB, sigmaA, sigmaB = [rand_dm(dimension) for _ in [None]*4]
+        rho = tensor(rhoA, rhoB)
+        rho_sim = tensor(rhoA, sigmaB)
+        sigma = tensor(sigmaA, sigmaB)
+        dist = hellinger_dist(rhoA, sigmaA)
+        assert hellinger_dist(rho, sigma) + tol > dist
+        assert hellinger_dist(rho_sim, sigma) == pytest.approx(dist, abs=tol)
+
+
+class Test_average_gate_fidelity:
+    def test_identity(self, dimension):
+        id = qeye(dimension)
+        assert average_gate_fidelity(id) == pytest.approx(1, abs=1e-12)
+
+    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
+    def test_bounded(self, dimension):
+        tol = 1e-7
+        channel = rand_super_bcsz(dimension)
+        assert -tol <= average_gate_fidelity(channel) <= 1 + tol
+
+    @pytest.mark.parametrize('dimension', [2, 5, 10, 20])
+    def test_unitaries_equal_1(self, dimension):
+        """Tests that for random unitaries U, AGF(U, U) = 1."""
+        tol = 1e-7
+        U = rand_unitary(dimension)
+        SU = to_super(U)
+        assert average_gate_fidelity(SU, target=U) == pytest.approx(1, abs=tol)
+
+    def test_average_gate_fidelity_against_legacy_implementation(self):
+        """
+        Metrics: Test that AGF coincides with pre-5.0 implementation
+        """
+        def agf_pre_50(oper, target=None):
+            kraus = to_kraus(oper)
+            d = kraus[0].shape[0]
+
+            if kraus[0].shape[1] != d:
+                return TypeError(
+                    "Average gate fidelity only implemented for square "
+                    "superoperators.")
+
+            if target is None:
+                return (
+                    (d + np.sum([np.abs(A_k.tr()) ** 2 for A_k in kraus])) /
+                    (d * d + d)
+                )
+            return (
+                (d + np.sum([
+                    np.abs((A_k * target.dag()).tr()) ** 2 for A_k in kraus
+                ])) / (d * d + d)
+            )
+
+        oper = rand_super_bcsz(16)
+        target = rand_unitary(16)
+        np.testing.assert_almost_equal(
+            average_gate_fidelity(oper, target),
+            agf_pre_50(oper, target)
+        )
+
+
+class Test_hilbert_dist:
+    def test_known_cases(self):
+        r1 = qdiags(np.array([0.5, 0.5, 0, 0]), 0)
+        r2 = qdiags(np.array([0, 0, 0.5, 0.5]), 0)
+        assert hilbert_dist(r1, r2) == pytest.approx(1, abs=1e-6)
+
+
+paulis = [qeye(2), sigmax(), sigmay(), sigmaz()]
+
+
+class Test_unitarity:
+    @pytest.mark.parametrize(['operator', 'expected'], [
+        pytest.param(to_super(sigmax()), 1, id="sigmax"),
+        pytest.param(0.25 * sum(to_super(x) for x in paulis), 0, id="paulis"),
+        pytest.param(0.5 * (to_super(qeye(2)) + to_super(sigmax())), 1/3,
+                     id="id+sigmax"),
+    ])
+    def test_known_cases(self, operator, expected):
+        assert unitarity(operator) == pytest.approx(expected, abs=1e-7)
+
+    @pytest.mark.parametrize('n_qubits', [1, 2, 3, 4, 5])
+    def test_bounded(self, n_qubits):
+        tol = 1e-7
+        operator = rand_super_bcsz(2**n_qubits)
+        assert -tol <= unitarity(operator) <= 1 + tol
+
+
+class TestComparisons:
+    """Test some known inequalities between two different metrics."""
+
+    def test_inequality_tracedist_to_fidelity(self, left, right):
+        tol = 1e-7
+        assert 1 - fidelity(left, right) <= tracedist(left, right) + tol
+
+    def test_inequality_hellinger_dist_to_bures_dist(self, left, right):
+        tol = 1e-7
+        hellinger = hellinger_dist(left, right)
+        bures = bures_dist(left, right)
+        assert bures <= hellinger + tol
+
+
+def overrotation(x):
+    return to_super((1j * np.pi * x * sigmax() / 2).expm())
+
+
+def had_mixture(x):
+    id_chan = to_choi(qeye(2))
+    S_eye = to_super(id_chan)
+    S_H = to_super(snot())
+    return (1 - x) * S_eye + x * S_H
+
+
+def swap_map(x):
+    base = (1j * x * swap()).expm()
+    dims = [[[2], [2]], [[2], [2]]]
+    return Qobj(base, dims=dims, type='super', superrep='super')
+
+
+def adc_choi(x):
+    kraus = [
+        np.sqrt(1 - x) * qeye(2),
+        np.sqrt(x) * destroy(2),
+        np.sqrt(x) * fock_dm(2, 0),
+    ]
+    return kraus_to_choi(kraus)
+
+
+# dnorm tests have always been slightly flaky; in some cases, cvxpy will fail
+# to solve the problem, and this can cause an entire test-suite failure.  As
+# long as we are using random tests (perhaps not ideal), this will happen
+# occasionally.  This isn't entirely a bug, it's just a reality of using a
+# one-size-fits-all solver; we've historically assumed users who come up
+# against this sort of thing will be accepting of the fact that dnorm
+# calculation is nontrivial, and isn't always entirely feasible.
+#
+# To deal with it, we allow each test to be rerun twice, using
+# pytest-rerunfailures.  This should forbid pathological cases where the test
+# is failing every time, but not penalise one-off failures.  As far as we know,
+# the failing tests always involve a random step, so triggering a re-run will
+# have them choose new variables as well.
+#
+# The warning filter is to account for cvxpy < 1.1.10 which uses np.complex,
+# which is deprecated as of numpy 1.20.
+#
+# Skip dnorm tests if we don't have cvxpy or cvxopt available, since dnorm
+# depends on them.
+@pytest.mark.skipif(cvxpy is None or cvxopt is None,
+                    reason="Skipping dnorm tests because dnorm requires cvxpy"
+                    " and cvxopt which are not installed.")
+@pytest.mark.skipif("Windows" in platform.system(),
+                    reason="Skipping dnorm tests -- cvxpy and cvxopt can be"
+                    " installed on Windows but fail to correctly solve"
+                    " the given optimization problems.")
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.filterwarnings(
+    "ignore:`np.complex` is a deprecated alias:DeprecationWarning:cvxpy"
+)
+class Test_dnorm:
+    @pytest.fixture(params=[2, 3])
+    def dimension(self, request):
+        return request.param
+
+    @pytest.fixture(params=[True, False], ids=['sparse', 'dense'])
+    def sparse(self, request):
+        return request.param
+
+    @pytest.mark.parametrize("variable", [0.1, 0.5, 0.9])
+    def test_sparse_against_dense_adc(self, variable):
+        """
+        Test sparse versus dense dnorm calculation for a sample of
+        amplitude-damping channels.
+        """
+        # Choi matrix for identity channel on 1 qubit
+        A = kraus_to_choi([qeye(2)])
+        B = adc_choi(variable)
+        dense = dnorm(A, B, force_solve=True, sparse=False)
+        sparse = dnorm(A, B, force_solve=True, sparse=True)
+        assert dense == pytest.approx(sparse, abs=1e-7)
+
+    @pytest.mark.repeat(3)
+    def test_sparse_against_dense_random(self, dimension):
+        """
+        Test sparse versus dense dnorm calculation for random superoperators.
+        """
+        A = rand_super_bcsz(dimension)
+        dense_run_result = dnorm(A, force_solve=True, sparse=False)
+        sparse_run_result = dnorm(A, force_solve=True, sparse=True)
+        assert dense_run_result == pytest.approx(sparse_run_result, abs=1e-7)
+
+    def test_bounded(self, dimension, sparse):
+        """dnorm(A - B) in [0, 2] for random superops A, B."""
+        tol = 1e-7
+        A, B = rand_super_bcsz(dimension), rand_super_bcsz(dimension)
+        assert -tol <= dnorm(A, B, sparse=sparse) <= 2 + tol
+
+    def test_qubit_simple_known_cases(self, sparse):
+        """Check agreement for known qubit channels."""
+        id_chan = to_choi(qeye(2))
+        X_chan = to_choi(sigmax())
+        depol = to_choi(Qobj(
+            qeye(4), dims=[[[2], [2]], [[2], [2]]], superrep='chi',
+        ))
+        # We need to restrict the number of iterations for things on the
+        # boundary, such as perfectly distinguishable channels.
+        assert (
+            dnorm(id_chan, X_chan, sparse=sparse)
+            == pytest.approx(2, abs=1e-7)
+        )
+        assert (
+            dnorm(id_chan, depol, sparse=sparse)
+            == pytest.approx(1.5, abs=1e-7)
+        )
+        # Finally, we add a known case from Johnston's QETLAB documentation,
+        #   || Phi - I ||_♢,
+        # where Phi(X) = UXU⁺ and U = [[1, 1], [-1, 1]] / sqrt(2).
+        U = np.sqrt(0.5) * Qobj([[1, 1], [-1, 1]])
+        assert (
+            dnorm(U, qeye(2), sparse=sparse)
+            == pytest.approx(np.sqrt(2), abs=1e-7)
+        )
+
+    @pytest.mark.parametrize(["variable", "expected", "generator"], [
+        [1.0e-3, 3.141591e-03, overrotation],
+        [3.1e-3, 9.738899e-03, overrotation],
+        [1.0e-2, 3.141463e-02, overrotation],
+        [3.1e-2, 9.735089e-02, overrotation],
+        [1.0e-1, 3.128689e-01, overrotation],
+        [3.1e-1, 9.358596e-01, overrotation],
+        [1.0e-3, 2.000000e-03, had_mixture],
+        [3.1e-3, 6.200000e-03, had_mixture],
+        [1.0e-2, 2.000000e-02, had_mixture],
+        [3.1e-2, 6.200000e-02, had_mixture],
+        [1.0e-1, 2.000000e-01, had_mixture],
+        [3.1e-1, 6.200000e-01, had_mixture],
+        [1.0e-3, 2.000000e-03, swap_map],
+        [3.1e-3, 6.199997e-03, swap_map],
+        [1.0e-2, 1.999992e-02, swap_map],
+        [3.1e-2, 6.199752e-02, swap_map],
+        [1.0e-1, 1.999162e-01, swap_map],
+        [3.1e-1, 6.173918e-01, swap_map],
+    ])
+    def test_qubit_known_cases(self, variable, expected, generator, sparse):
+        """
+        Test cases based on comparisons to pre-existing dnorm implementations.
+        In particular, the targets for the following test cases were generated
+        using QuantumUtils for MATLAB (https://goo.gl/oWXhO9).
+        """
+        id_chan = to_choi(qeye(2))
+        channel = generator(variable)
+        assert (
+            dnorm(channel, id_chan, sparse=sparse)
+            == pytest.approx(expected, abs=1e-7)
+        )
+
+    def test_qubit_scalar(self, dimension):
+        """dnorm(a * A) == a * dnorm(A) for scalar a, qobj A."""
+        a = np.random.random()
+        A = rand_super_bcsz(dimension)
+        B = rand_super_bcsz(dimension)
+        assert dnorm(a*A, a*B) == pytest.approx(a*dnorm(A, B), abs=1e-7)
+
+    def test_qubit_triangle(self, dimension):
+        """Check that dnorm(A + B) <= dnorm(A) + dnorm(B)."""
+        A = rand_super_bcsz(dimension)
+        B = rand_super_bcsz(dimension)
+        assert dnorm(A + B) <= dnorm(A) + dnorm(B) + 1e-7
+
+    @pytest.mark.repeat(3)
+    @pytest.mark.parametrize("generator", [
+        pytest.param(rand_super_bcsz, id="super"),
+        pytest.param(rand_unitary, id="unitary"),
+    ])
+    def test_force_solve(self, dimension, generator):
+        """
+        Metrics: checks that special cases for dnorm agree with SDP solutions.
+        """
+        A, B = generator(dimension), generator(dimension)
+        assert (
+            dnorm(A, B, force_solve=False)
+            == pytest.approx(dnorm(A, B, force_solve=True), abs=1e-5)
+        )
+
+    @pytest.mark.repeat(3)
+    def test_cptp(self, dimension, sparse):
+        """Check that the diamond norm is one for CPTP maps."""
+        A = rand_super_bcsz(dimension)
+        assert A.iscptp
+        assert dnorm(A, sparse=sparse) == pytest.approx(1, abs=1e-7)
+
+
+@pytest.mark.parametrize('superrep_conversion',
+                         [lambda x: x, to_super, to_choi, to_chi, to_kraus])
+def test_process_fidelity_of_identity(superrep_conversion):
+    """
+    Metrics: process fidelity of identity map is 1
+    """
+    num_qubits = 3
+    oper = qeye(num_qubits*[2])
+    f = process_fidelity(superrep_conversion(oper))
+    assert np.isrealobj(f)
+    assert f == pytest.approx(1)
+
+
+@pytest.mark.parametrize('superrep_conversion',
+                         [to_super, to_choi, to_chi, to_kraus])
+def test_process_fidelity_identical_channels(superrep_conversion):
+    """
+    Metrics: process fidelity of a map to itself is 1
+    """
+    num_qubits = 2
+    for k in range(10):
+        oper = rand_super_bcsz(num_qubits*[2])
+        oper = superrep_conversion(oper)
+        f = process_fidelity(oper, oper)
+        assert f == pytest.approx(1)
+
+
+def test_process_fidelity_identical_unitaries():
+    """
+    Metrics: process fidelity of a unitary to itself is 1
+    """
+    num_qubits = 3
+    for k in range(10):
+        oper = rand_unitary(num_qubits * [2])
+        f = process_fidelity(oper, oper)
+        assert f == pytest.approx(1)
+
+
+def test_process_fidelity_consistency():
+    """
+    Metrics: process fidelity independent of how channels are represented
+    """
+    num_qubits = 2
+    for k in range(10):
+        fidelities_u_to_u = []
+        fidelities_u_to_id = []
+        u1 = rand_unitary(num_qubits * [2])
+        u2 = rand_unitary(num_qubits * [2])
+        for map1 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
+            fidelities_u_to_id.append(process_fidelity(map1(u1)))
+            for map2 in [lambda x:x, to_super, to_choi, to_chi, to_kraus]:
+                fidelities_u_to_u.append(process_fidelity(map1(u1), map2(u2)))
+        assert all(abs(fidelities_u_to_id - fidelities_u_to_id[0]) < 1e-6)
+        assert all(abs(fidelities_u_to_u - fidelities_u_to_u[0]) < 1e-6)
+
+
+def test_process_fidelity_unitary_invariance():
+    """
+    Metrics: process fidelity, invariance under unitary trans.
+    """
+    for k in range(10):
+        op1 = rand_super_bcsz(10)
+        op2 = rand_super_bcsz(10)
+        u = to_super(rand_unitary(10))
+        assert abs(
+            process_fidelity(op1, op2)
+            - process_fidelity(u*op1, u*op2)
+        ) < 1e-8
+
+
+@pytest.mark.parametrize('superrep_conversion',
+                         [lambda x: x, to_super, to_choi, to_kraus])
+def test_hilbert_space_dims(superrep_conversion):
+    """
+    Metrics: check _hilbert_space_dims
+    """
+    dims = [[2, 3], [4, 5]]
+    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
+    assert _hilbert_space_dims(superrep_conversion(u)) == dims
+
+
+def test_hilbert_space_dims_chi():
+    """
+    Metrics: check _hilbert_space_dims for a chi channel
+    """
+    dims = [[2, 2], [2, 2]]
+    u = Qobj(np.ones((np.prod(dims[0]), np.prod(dims[1]))), dims=dims)
+    assert _hilbert_space_dims(to_chi(u)) == dims
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index f59dce8f24..c8e6d72f0a 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -1,295 +1,295 @@
-import numbers
-import numpy as np
-import pytest
-import qutip
-
-
-N = 5
-
-
-def test_jmat_12():
-    spinhalf = qutip.jmat(1 / 2.)
-
-    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
-    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
-    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
-    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
-    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
-
-    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
-    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
-    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
-    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
-    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
-
-    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
-    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
-    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
-    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
-    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
-
-    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
-    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
-    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
-    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
-    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
-
-    spin_set = qutip.spin_J_set(0.5)
-    for i in range(3):
-        assert spinhalf[i] == spin_set[i]
-
-
-
-def test_jmat_32():
-    spin32 = qutip.jmat(3 / 2.)
-
-    paulix32 = np.array(
-        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
-         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
-         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
-         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
-
-    pauliy32 = np.array(
-        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
-         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
-         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
-         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
-
-    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
-                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
-                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
-                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
-
-    np.testing.assert_allclose(spin32[0].full(), paulix32)
-    np.testing.assert_allclose(spin32[1].full(), pauliy32)
-    np.testing.assert_allclose(spin32[2].full(), pauliz32)
-
-
-@pytest.mark.parametrize(['spin', 'N'], [
-    pytest.param(3/2., 4, id="1.5"),
-    pytest.param(5/2., 6, id="2.5"),
-    pytest.param(3.0, 7, id="3.0"),
-])
-def test_jmat_dims(spin, N):
-    spin_mat = qutip.jmat(spin, '+')
-    assert spin_mat.dims == [[N], [N]]
-    assert spin_mat.shape == (N, N)
-
-
-def test_jmat_raise():
-    with pytest.raises(ValueError) as e:
-        qutip.jmat(0.25)
-    assert str(e.value) == 'j must be a non-negative integer or half-integer'
-
-    with pytest.raises(ValueError) as e:
-        qutip.jmat(0.5, 'zx+')
-    assert "Invalid spin operator" in str(e.value)
-
-
-@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
-    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
-    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
-    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
-    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
-                 id="destroy_offset"),
-    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
-    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
-                 id="create_offset"),
-    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
-    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
-    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
-    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
-                 id="charge_args"),
-])
-def test_diagonal_operators(oper_func, diag, offset, args):
-    oper = oper_func(N, *args)
-    assert oper == qutip.Qobj(np.diag(diag, offset))
-
-
-@pytest.mark.parametrize(['function', 'message'], [
-    (qutip.qeye, "All dimensions must be integers >= 0"),
-    (qutip.destroy, "Hilbert space dimension must be integer value"),
-    (qutip.create, "Hilbert space dimension must be integer value"),
-], ids=["qeye", "destroy", "create"])
-def test_diagonal_raise(function, message):
-    with pytest.raises(ValueError) as e:
-        function(2.5)
-    assert str(e.value) == message
-
-
-@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
-@pytest.mark.parametrize("dimensions", [
-        2,
-        [2],
-        [2, 3, 4],
-        1,
-        [1],
-        [1, 1],
-    ])
-def test_implicit_tensor_creation(to_test, dimensions):
-    implicit = to_test(dimensions)
-    if isinstance(dimensions, numbers.Integral):
-        dimensions = [dimensions]
-    assert implicit.dims == [dimensions, dimensions]
-
-
-@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
-def test_super_operator_creation(to_test):
-    size = 2
-    implicit = to_test([[size], [size]])
-    explicit = qutip.to_super(to_test(size))
-    assert implicit == explicit
-
-
-def test_position():
-    operator = qutip.position(N)
-    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
-                np.diag((np.arange(1, N) / 2)**0.5, k=1))
-    np.testing.assert_allclose(operator.full(), expected)
-    assert operator._isherm == True
-
-
-def test_momentum():
-    operator = qutip.momentum(N)
-    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
-                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
-    np.testing.assert_allclose(operator.full(), expected)
-    assert operator._isherm == True
-
-
-def test_squeeze():
-    sq = qutip.squeeze(4, 0.1 + 0.1j)
-    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
-                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
-                         [0.00000000 + 0.j, 0.98503746 + 0.j,
-                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
-                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
-                          0.99500417 + 0.j, 0.00000000 + 0.j],
-                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
-                          0.00000000 + 0.j, 0.98503746 + 0.j]])
-    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
-
-
-def test_squeezing():
-    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
-    a = qutip.destroy(4)
-    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
-    assert squeeze == squeezing
-
-
-def test_displace():
-    dp = qutip.displace(4, 0.25)
-    dpmatrix = np.array(
-        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
-          0.00626025 + 0.j],
-         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
-          0.j, 0.07418172 + 0.j],
-         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
-          0.j, -0.41083747 + 0.j],
-         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
-          0.90866411 + 0.j]])
-    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
-
-
-@pytest.mark.parametrize("shift", [1, 2])
-def test_tunneling(shift):
-    N = 10
-    tn = qutip.tunneling(N, shift)
-    tn_matrix = np.diag(np.ones(N - shift), k=shift)
-    tn_matrix += tn_matrix.T
-    np.testing.assert_allclose(tn.full(), tn_matrix)
-
-
-def test_commutator():
-    A = qutip.qeye(N)
-    B = qutip.destroy(N)
-    assert qutip.commutator(A, B) == qutip.qzero(N)
-
-    sx = qutip.sigmax()
-    sy = qutip.sigmay()
-    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
-
-    A = qutip.qeye(N)
-    B = qutip.destroy(N)
-    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
-
-    sx = qutip.sigmax()
-    sy = qutip.sigmay()
-    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
-
-    with pytest.raises(TypeError) as e:
-        qutip.commutator(sx, sy, 'something')
-    assert str(e.value).startswith("Unknown commutator kind")
-
-def test_qutrit_ops():
-    ops = qutip.qutrit_ops()
-    assert qutip.qeye(3) == sum(ops[:3])
-    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
-    expected = np.zeros((3, 3))
-    expected[2, 0] = 1
-    np.testing.assert_allclose(expected, ops[5].full())
-
-
-def _id_func(val):
-    "ids generated from the function only"
-    if isinstance(val, tuple):
-        return ""
-
-
-# random object accept `str` and base.Data
-# Obtain all valid dtype from `to`
-dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
-dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-@pytest.mark.parametrize(['func', 'args'], [
-    (qutip.qdiags, ([0, 1, 2], 1)),
-    (qutip.jmat, (1,)),
-    (qutip.spin_Jx, (1,)),
-    (qutip.spin_Jy, (1,)),
-    (qutip.spin_Jz, (1,)),
-    (qutip.spin_Jp, (1,)),
-    (qutip.destroy, (5,)),
-    (qutip.create, (5,)),
-    (qutip.qzero, (5,)),
-    (qutip.qeye, (5,)),
-    (qutip.position, (5,)),
-    (qutip.momentum, (5,)),
-    (qutip.num, (5,)),
-    (qutip.squeeze, (5, 0.5)),
-    (qutip.displace, (5, 1.0)),
-    (qutip.qutrit_ops, ()),
-    (qutip.phase, (5,)),
-    (qutip.charge, (5,)),
-    (qutip.tunneling, (5,)),
-    (qutip.enr_destroy, ([3, 3, 3], 4)),
-    (qutip.enr_identity, ([3, 3, 3], 4)),
-], ids=_id_func)
-def test_operator_type(func, args, alias, dtype):
-    object = func(*args, dtype=alias)
-    if isinstance(object, qutip.Qobj):
-        assert isinstance(object.data, dtype)
-    else:
-        for obj in object:
-            assert isinstance(obj.data, dtype)
-
-    with qutip.CoreOptions(default_dtype=alias):
-        object = func(*args)
-        if isinstance(object, qutip.Qobj):
-            assert isinstance(object.data, dtype)
-        else:
-            for obj in object:
-                assert isinstance(obj.data, dtype)
-
-
-@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
-def test_qft(dims):
-    N = np.prod(dims)
-    qft = qutip.qft(N).full()
-    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
-    for i in range(N):
-        target = np.zeros(N)
-        target[i] = 1
-        fft = np.fft.fft(qft[:,i])
-        fft /= np.sum(fft)
-        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
+import numbers
+import numpy as np
+import pytest
+import qutip
+
+
+N = 5
+
+
+def test_jmat_12():
+    spinhalf = qutip.jmat(1 / 2.)
+
+    paulix = np.array([[0. + 0.j, 1. + 0.j], [1. + 0.j, 0. + 0.j]])
+    pauliy = np.array([[0. + 0.j, 0. - 1.j], [0. + 1.j, 0. + 0.j]])
+    pauliz = np.array([[1. + 0.j, 0. + 0.j], [0. + 0.j, -1. + 0.j]])
+    sigmap = np.array([[0. + 0.j, 1. + 0.j], [0. + 0.j, 0. + 0.j]])
+    sigmam = np.array([[0. + 0.j, 0. + 0.j], [1. + 0.j, 0. + 0.j]])
+
+    np.testing.assert_allclose(spinhalf[0].full() * 2, paulix)
+    np.testing.assert_allclose(spinhalf[1].full() * 2, pauliy)
+    np.testing.assert_allclose(spinhalf[2].full() * 2, pauliz)
+    np.testing.assert_allclose(qutip.jmat(1 / 2., '+').full(), sigmap)
+    np.testing.assert_allclose(qutip.jmat(1 / 2., '-').full(), sigmam)
+
+    np.testing.assert_allclose(qutip.spin_Jx(1 / 2.).full() * 2, paulix)
+    np.testing.assert_allclose(qutip.spin_Jy(1 / 2.).full() * 2, pauliy)
+    np.testing.assert_allclose(qutip.spin_Jz(1 / 2.).full() * 2, pauliz)
+    np.testing.assert_allclose(qutip.spin_Jp(1 / 2.).full(), sigmap)
+    np.testing.assert_allclose(qutip.spin_Jm(1 / 2.).full(), sigmam)
+
+    np.testing.assert_allclose(qutip.sigmax().full(), paulix)
+    np.testing.assert_allclose(qutip.sigmay().full(), pauliy)
+    np.testing.assert_allclose(qutip.sigmaz().full(), pauliz)
+    np.testing.assert_allclose(qutip.sigmap().full(), sigmap)
+    np.testing.assert_allclose(qutip.sigmam().full(), sigmam)
+
+    spin_set = qutip.spin_J_set(0.5)
+    for i in range(3):
+        assert spinhalf[i] == spin_set[i]
+
+
+
+def test_jmat_32():
+    spin32 = qutip.jmat(3 / 2.)
+
+    paulix32 = np.array(
+        [[0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j, 0.0000000 + 0.j],
+         [0.8660254 + 0.j, 0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j],
+         [0.0000000 + 0.j, 1.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j],
+         [0.0000000 + 0.j, 0.0000000 + 0.j, 0.8660254 + 0.j, 0.0000000 + 0.j]])
+
+    pauliy32 = np.array(
+        [[0. + 0.j, 0. - 0.8660254j, 0. + 0.j, 0. + 0.j],
+         [0. + 0.8660254j, 0. + 0.j, 0. - 1.j, 0. + 0.j],
+         [0. + 0.j, 0. + 1.j, 0. + 0.j, 0. - 0.8660254j],
+         [0. + 0.j, 0. + 0.j, 0. + 0.8660254j, 0. + 0.j]])
+
+    pauliz32 = np.array([[1.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
+                         [0.0 + 0.j, 0.5 + 0.j, 0.0 + 0.j, 0.0 + 0.j],
+                         [0.0 + 0.j, 0.0 + 0.j, -0.5 + 0.j, 0.0 + 0.j],
+                         [0.0 + 0.j, 0.0 + 0.j, 0.0 + 0.j, -1.5 + 0.j]])
+
+    np.testing.assert_allclose(spin32[0].full(), paulix32)
+    np.testing.assert_allclose(spin32[1].full(), pauliy32)
+    np.testing.assert_allclose(spin32[2].full(), pauliz32)
+
+
+@pytest.mark.parametrize(['spin', 'N'], [
+    pytest.param(3/2., 4, id="1.5"),
+    pytest.param(5/2., 6, id="2.5"),
+    pytest.param(3.0, 7, id="3.0"),
+])
+def test_jmat_dims(spin, N):
+    spin_mat = qutip.jmat(spin, '+')
+    assert spin_mat.dims == [[N], [N]]
+    assert spin_mat.shape == (N, N)
+
+
+def test_jmat_raise():
+    with pytest.raises(ValueError) as e:
+        qutip.jmat(0.25)
+    assert str(e.value) == 'j must be a non-negative integer or half-integer'
+
+    with pytest.raises(ValueError) as e:
+        qutip.jmat(0.5, 'zx+')
+    assert "Invalid spin operator" in str(e.value)
+
+
+@pytest.mark.parametrize(['oper_func', 'diag', 'offset', 'args'], [
+    pytest.param(qutip.qeye, np.ones(N), 0, (), id="qeye"),
+    pytest.param(qutip.qzero, np.zeros(N), 0, (), id="zeros"),
+    pytest.param(qutip.destroy, np.arange(1, N)**0.5, 1, (), id="destroy"),
+    pytest.param(qutip.destroy, np.arange(6, N+5)**0.5, 1, (5,),
+                 id="destroy_offset"),
+    pytest.param(qutip.create, np.arange(1, N)**0.5, -1, (), id="create"),
+    pytest.param(qutip.create, np.arange(6, N+5)**0.5, -1, (5,),
+                 id="create_offset"),
+    pytest.param(qutip.num, np.arange(N), 0, (), id="num"),
+    pytest.param(qutip.num, np.arange(5, N+5), 0, (5,), id="num_offset"),
+    pytest.param(qutip.charge, np.arange(-N, N+1), 0, (), id="charge"),
+    pytest.param(qutip.charge, np.arange(2, N+1)/3, 0, (2, 1/3),
+                 id="charge_args"),
+])
+def test_diagonal_operators(oper_func, diag, offset, args):
+    oper = oper_func(N, *args)
+    assert oper == qutip.Qobj(np.diag(diag, offset))
+
+
+@pytest.mark.parametrize(['function', 'message'], [
+    (qutip.qeye, "All dimensions must be integers >= 0"),
+    (qutip.destroy, "Hilbert space dimension must be integer value"),
+    (qutip.create, "Hilbert space dimension must be integer value"),
+], ids=["qeye", "destroy", "create"])
+def test_diagonal_raise(function, message):
+    with pytest.raises(ValueError) as e:
+        function(2.5)
+    assert str(e.value) == message
+
+
+@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
+@pytest.mark.parametrize("dimensions", [
+        2,
+        [2],
+        [2, 3, 4],
+        1,
+        [1],
+        [1, 1],
+    ])
+def test_implicit_tensor_creation(to_test, dimensions):
+    implicit = to_test(dimensions)
+    if isinstance(dimensions, numbers.Integral):
+        dimensions = [dimensions]
+    assert implicit.dims == [dimensions, dimensions]
+
+
+@pytest.mark.parametrize("to_test", [qutip.qzero, qutip.qeye, qutip.identity])
+def test_super_operator_creation(to_test):
+    size = 2
+    implicit = to_test([[size], [size]])
+    explicit = qutip.to_super(to_test(size))
+    assert implicit == explicit
+
+
+def test_position():
+    operator = qutip.position(N)
+    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) +
+                np.diag((np.arange(1, N) / 2)**0.5, k=1))
+    np.testing.assert_allclose(operator.full(), expected)
+    assert operator._isherm == True
+
+
+def test_momentum():
+    operator = qutip.momentum(N)
+    expected = (np.diag((np.arange(1, N) / 2)**0.5, k=-1) -
+                np.diag((np.arange(1, N) / 2)**0.5, k=1)) * 1j
+    np.testing.assert_allclose(operator.full(), expected)
+    assert operator._isherm == True
+
+
+def test_squeeze():
+    sq = qutip.squeeze(4, 0.1 + 0.1j)
+    sqmatrix = np.array([[0.99500417 + 0.j, 0.00000000 + 0.j,
+                          0.07059289 - 0.07059289j, 0.00000000 + 0.j],
+                         [0.00000000 + 0.j, 0.98503746 + 0.j,
+                          0.00000000 + 0.j, 0.12186303 - 0.12186303j],
+                         [-0.07059289 - 0.07059289j, 0.00000000 + 0.j,
+                          0.99500417 + 0.j, 0.00000000 + 0.j],
+                         [0.00000000 + 0.j, -0.12186303 - 0.12186303j,
+                          0.00000000 + 0.j, 0.98503746 + 0.j]])
+    np.testing.assert_allclose(sq.full(), sqmatrix, atol=1e-8)
+
+
+def test_squeezing():
+    squeeze = qutip.squeeze(4, 0.1 + 0.1j)
+    a = qutip.destroy(4)
+    squeezing = qutip.squeezing(a, a, 0.1 + 0.1j)
+    assert squeeze == squeezing
+
+
+def test_displace():
+    dp = qutip.displace(4, 0.25)
+    dpmatrix = np.array(
+        [[0.96923323 + 0.j, -0.24230859 + 0.j, 0.04282883 + 0.j, -
+          0.00626025 + 0.j],
+         [0.24230859 + 0.j, 0.90866411 + 0.j, -0.33183303 +
+          0.j, 0.07418172 + 0.j],
+         [0.04282883 + 0.j, 0.33183303 + 0.j, 0.84809499 +
+          0.j, -0.41083747 + 0.j],
+         [0.00626025 + 0.j, 0.07418172 + 0.j, 0.41083747 + 0.j,
+          0.90866411 + 0.j]])
+    np.testing.assert_allclose(dp.full(), dpmatrix, atol=1e-8)
+
+
+@pytest.mark.parametrize("shift", [1, 2])
+def test_tunneling(shift):
+    N = 10
+    tn = qutip.tunneling(N, shift)
+    tn_matrix = np.diag(np.ones(N - shift), k=shift)
+    tn_matrix += tn_matrix.T
+    np.testing.assert_allclose(tn.full(), tn_matrix)
+
+
+def test_commutator():
+    A = qutip.qeye(N)
+    B = qutip.destroy(N)
+    assert qutip.commutator(A, B) == qutip.qzero(N)
+
+    sx = qutip.sigmax()
+    sy = qutip.sigmay()
+    assert qutip.commutator(sx, sy) / 2 == (qutip.sigmaz() * 1j)
+
+    A = qutip.qeye(N)
+    B = qutip.destroy(N)
+    assert qutip.commutator(A, B, 'anti') == qutip.destroy(N) * 2
+
+    sx = qutip.sigmax()
+    sy = qutip.sigmay()
+    assert qutip.commutator(sx, sy, 'anti') == qutip.qzero(2)
+
+    with pytest.raises(TypeError) as e:
+        qutip.commutator(sx, sy, 'something')
+    assert str(e.value).startswith("Unknown commutator kind")
+
+def test_qutrit_ops():
+    ops = qutip.qutrit_ops()
+    assert qutip.qeye(3) == sum(ops[:3])
+    np.testing.assert_allclose(np.diag([1, 1], k=1), sum(ops[3:5]).full())
+    expected = np.zeros((3, 3))
+    expected[2, 0] = 1
+    np.testing.assert_allclose(expected, ops[5].full())
+
+
+def _id_func(val):
+    "ids generated from the function only"
+    if isinstance(val, tuple):
+        return ""
+
+
+# random object accept `str` and base.Data
+# Obtain all valid dtype from `to`
+dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
+dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize(['func', 'args'], [
+    (qutip.qdiags, ([0, 1, 2], 1)),
+    (qutip.jmat, (1,)),
+    (qutip.spin_Jx, (1,)),
+    (qutip.spin_Jy, (1,)),
+    (qutip.spin_Jz, (1,)),
+    (qutip.spin_Jp, (1,)),
+    (qutip.destroy, (5,)),
+    (qutip.create, (5,)),
+    (qutip.qzero, (5,)),
+    (qutip.qeye, (5,)),
+    (qutip.position, (5,)),
+    (qutip.momentum, (5,)),
+    (qutip.num, (5,)),
+    (qutip.squeeze, (5, 0.5)),
+    (qutip.displace, (5, 1.0)),
+    (qutip.qutrit_ops, ()),
+    (qutip.phase, (5,)),
+    (qutip.charge, (5,)),
+    (qutip.tunneling, (5,)),
+    (qutip.enr_destroy, ([3, 3, 3], 4)),
+    (qutip.enr_identity, ([3, 3, 3], 4)),
+], ids=_id_func)
+def test_operator_type(func, args, alias, dtype):
+    object = func(*args, dtype=alias)
+    if isinstance(object, qutip.Qobj):
+        assert isinstance(object.data, dtype)
+    else:
+        for obj in object:
+            assert isinstance(obj.data, dtype)
+
+    with qutip.CoreOptions(default_dtype=alias):
+        object = func(*args)
+        if isinstance(object, qutip.Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
+
+
+@pytest.mark.parametrize('dims', [8, 15, [2] * 4])
+def test_qft(dims):
+    N = np.prod(dims)
+    qft = qutip.qft(N).full()
+    np.testing.assert_allclose(np.abs(qft)**2, 1/N)
+    for i in range(N):
+        target = np.zeros(N)
+        target[i] = 1
+        fft = np.fft.fft(qft[:,i])
+        fft /= np.sum(fft)
+        np.testing.assert_allclose(fft, target, atol=1e-16 * N)
diff --git a/qutip/tests/core/test_ptrace.py b/qutip/tests/core/test_ptrace.py
index 8ae26d52ad..40efd15109 100644
--- a/qutip/tests/core/test_ptrace.py
+++ b/qutip/tests/core/test_ptrace.py
@@ -1,130 +1,130 @@
-import itertools
-
-import numpy as np
-import pytest
-
-import qutip
-from qutip.core import data as _data
-
-
-def expected(qobj, sel):
-    if qobj.isbra or qobj.isket:
-        qobj = qobj.proj()
-    sel = sorted(sel)
-    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
-    new_shape = (np.prod(dims[0], dtype=int),) * 2
-    out = qobj.full()
-    before, after = 1, qobj.shape[0]
-    for i, dim in enumerate(qobj.dims[0]):
-        after //= dim
-        if i in sel:
-            before = before * dim
-            continue
-        tmp_dims = (before, dim, after) * 2
-        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
-    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
-
-
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
-def dtype(request):
-    return request.param
-
-
-@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
-def dm(request):
-    return request.param
-
-
-@pytest.fixture
-def state(dtype, dm):
-    dims = [2, 3, 4]
-    state = qutip.rand_ket(dims)
-    if dm:
-        state = state.proj()
-    return state.to(dtype)
-
-
-def test_ptrace_noncompound_rand(dtype, dm):
-    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
-    for _ in range(5):
-        state = qutip.rand_ket(5)
-        if dm:
-            state = state.proj()
-        state = state.to(dtype)
-        assert state.ptrace(0) == (state if dm else state.proj())
-
-
-@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
-def test_ptrace_unsorted_selection_subset(state, pair):
-    """
-    Regression test for gh-1325.  ptrace should work the same independently of
-    the order of the input; no transposition in done in the trace operation.
-    """
-    # pair is always sorted.
-    state_ordered = state.ptrace(pair)
-    state_reversed = state.ptrace(pair[::-1])
-    assert state_ordered.dims == state_reversed.dims
-    assert state_ordered == state_reversed
-
-
-@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
-def test_ptrace_unsorted_selection_all(state, permutation):
-    state_ptraced = state.ptrace(permutation)
-    if state.isket:
-        state = state.proj()
-    assert state.dims == state_ptraced.dims
-    assert state == state_ptraced
-
-
-@pytest.mark.parametrize(['selection', 'exception'], [
-    pytest.param(4, IndexError, id='too big'),
-    pytest.param(-1, IndexError, id='too small'),
-    pytest.param([0, 0], ValueError, id='duplicate'),
-    # 'too many' may throw either from duplication or invalid index.
-    pytest.param([0, 1, 2, 3], Exception, id='too many'),
-])
-def test_ptrace_fails_on_invalid_input(state, selection, exception):
-    with pytest.raises(exception):
-        state.ptrace(selection)
-
-
-@pytest.mark.parametrize('dims, sel',
-                         [
-                             ([5, 2, 3], [2, 1]),
-                             ([5, 2, 3], [0, 2]),
-                             ([5, 2, 3], [0, 1]),
-                             ([2]*6, [3, 2]),
-                             ([2]*6, [0, 2]),
-                             ([2]*6, [0, 1]),
-                         ])
-def test_ptrace_rand_ket(dtype, dims, sel):
-    A = qutip.rand_ket(dims)
-    assert A.ptrace(sel) == expected(A, sel)
-
-
-@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
-                         ids=['trace_all',
-                              'trace_none',
-                              'trace_one',
-                              'trace_one_2',
-                              'trace_multiple',
-                              'trace_multiple_not_sorted',
-                              ])
-def test_ptrace_rand_dm(dtype, sel):
-    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
-    assert A.ptrace(sel) == expected(A, sel)
-
-
-@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
-                         ids=['trace_all',
-                              'trace_none',
-                              'trace_one',
-                              'trace_one_2',
-                              'trace_multiple',
-                              'trace_multiple_not_sorted',
-                              ])
-def test_ptrace_operator(dtype, sel):
-    A = qutip.tensor(
-        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
-    ).to(dtype)
-    assert A.ptrace(sel) == expected(A, sel)
+import itertools
+
+import numpy as np
+import pytest
+
+import qutip
+from qutip.core import data as _data
+
+
+def expected(qobj, sel):
+    if qobj.isbra or qobj.isket:
+        qobj = qobj.proj()
+    sel = sorted(sel)
+    dims = [[x for i, x in enumerate(qobj.dims[0]) if i in sel]]*2
+    new_shape = (np.prod(dims[0], dtype=int),) * 2
+    out = qobj.full()
+    before, after = 1, qobj.shape[0]
+    for i, dim in enumerate(qobj.dims[0]):
+        after //= dim
+        if i in sel:
+            before = before * dim
+            continue
+        tmp_dims = (before, dim, after) * 2
+        out = np.einsum('aibcid->abcd', out.reshape(tmp_dims))
+    return qutip.Qobj(out.reshape(new_shape), dims=dims, type='oper')
+
+
+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=['CSR', 'Dense'])
+def dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False], ids=['dm', 'ket'])
+def dm(request):
+    return request.param
+
+
+@pytest.fixture
+def state(dtype, dm):
+    dims = [2, 3, 4]
+    state = qutip.rand_ket(dims)
+    if dm:
+        state = state.proj()
+    return state.to(dtype)
+
+
+def test_ptrace_noncompound_rand(dtype, dm):
+    """Test `A.ptrace(0) == A` when `A` is in a non-tensored Hilbert space."""
+    for _ in range(5):
+        state = qutip.rand_ket(5)
+        if dm:
+            state = state.proj()
+        state = state.to(dtype)
+        assert state.ptrace(0) == (state if dm else state.proj())
+
+
+@pytest.mark.parametrize('pair', list(itertools.combinations(range(3), 2)))
+def test_ptrace_unsorted_selection_subset(state, pair):
+    """
+    Regression test for gh-1325.  ptrace should work the same independently of
+    the order of the input; no transposition in done in the trace operation.
+    """
+    # pair is always sorted.
+    state_ordered = state.ptrace(pair)
+    state_reversed = state.ptrace(pair[::-1])
+    assert state_ordered.dims == state_reversed.dims
+    assert state_ordered == state_reversed
+
+
+@pytest.mark.parametrize('permutation', list(itertools.permutations(range(3))))
+def test_ptrace_unsorted_selection_all(state, permutation):
+    state_ptraced = state.ptrace(permutation)
+    if state.isket:
+        state = state.proj()
+    assert state.dims == state_ptraced.dims
+    assert state == state_ptraced
+
+
+@pytest.mark.parametrize(['selection', 'exception'], [
+    pytest.param(4, IndexError, id='too big'),
+    pytest.param(-1, IndexError, id='too small'),
+    pytest.param([0, 0], ValueError, id='duplicate'),
+    # 'too many' may throw either from duplication or invalid index.
+    pytest.param([0, 1, 2, 3], Exception, id='too many'),
+])
+def test_ptrace_fails_on_invalid_input(state, selection, exception):
+    with pytest.raises(exception):
+        state.ptrace(selection)
+
+
+@pytest.mark.parametrize('dims, sel',
+                         [
+                             ([5, 2, 3], [2, 1]),
+                             ([5, 2, 3], [0, 2]),
+                             ([5, 2, 3], [0, 1]),
+                             ([2]*6, [3, 2]),
+                             ([2]*6, [0, 2]),
+                             ([2]*6, [0, 1]),
+                         ])
+def test_ptrace_rand_ket(dtype, dims, sel):
+    A = qutip.rand_ket(dims)
+    assert A.ptrace(sel) == expected(A, sel)
+
+
+@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
+                         ids=['trace_all',
+                              'trace_none',
+                              'trace_one',
+                              'trace_one_2',
+                              'trace_multiple',
+                              'trace_multiple_not_sorted',
+                              ])
+def test_ptrace_rand_dm(dtype, sel):
+    A = qutip.rand_dm([4, 4, 4], density=0.5).to(dtype)
+    assert A.ptrace(sel) == expected(A, sel)
+
+
+@pytest.mark.parametrize('sel', [[], [0, 1, 2], [0], [1], [1, 0], [0, 2]],
+                         ids=['trace_all',
+                              'trace_none',
+                              'trace_one',
+                              'trace_one_2',
+                              'trace_multiple',
+                              'trace_multiple_not_sorted',
+                              ])
+def test_ptrace_operator(dtype, sel):
+    A = qutip.tensor(
+        qutip.rand_dm(2), qutip.thermal_dm(10, 1), qutip.rand_unitary(3),
+    ).to(dtype)
+    assert A.ptrace(sel) == expected(A, sel)
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 9c1aa1566d..85e091b608 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1,1228 +1,1228 @@
-import numbers
-import operator
-import pytest
-
-import numpy as np
-import scipy.sparse
-import scipy.linalg
-
-import qutip
-from qutip.core import data as _data
-
-
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
-def datatype(request):
-    return request.param
-
-
-def _random_not_singular(N):
-    """
-    return a N*N complex array with determinant not 0.
-    """
-    data = np.zeros((1, 1))
-    while np.linalg.det(data) == 0:
-        data = np.random.random((N, N)) + \
-               1j * np.random.random((N, N)) - (0.5 + 0.5j)
-    return data
-
-
-def assert_hermicity(oper, hermicity):
-    # Check the cached isherm, if any exists.
-    assert oper.isherm == hermicity
-    # Force a reset of the cached value for isherm.
-    oper._isherm = None
-    # Force a recalculation of isherm.
-    assert oper.isherm == hermicity
-
-
-def test_QobjData():
-    "qutip.Qobj data"
-    N = 10
-    data1 = _random_not_singular(N)
-    q1 = qutip.Qobj(data1)
-    assert isinstance(q1.data, qutip.core.data.Data)
-    assert np.all(q1.data.to_array() == data1)
-
-    data2 = _random_not_singular(N)
-    data2 = scipy.sparse.csr_matrix(data2)
-    q2 = qutip.Qobj(data2)
-    assert isinstance(q2.data, qutip.core.data.Data)
-
-
-@pytest.mark.parametrize("original_data",
-                         [
-                            qutip.data.Dense(_random_not_singular(2)),
-                            qutip.data.csr.identity(2),
-                            qutip.Qobj(_random_not_singular(2)),
-                            _random_not_singular(2),
-                         ],
-                         ids=[
-                             "Dense",
-                             "CSR",
-                             "Qobj",
-                             "ndarray",
-                         ])
-@pytest.mark.parametrize("copy", [True, False],
-                         ids=["copy=True", "copy=False"])
-def test_QobjCopyArgument(original_data, copy):
-    """Tests that Qobj copy argument works properly when instantiating Qobj."""
-    qobj_data = qutip.Qobj(original_data, copy=copy).data
-
-    if isinstance(original_data, qutip.Qobj):
-        # Qobj copies the data of another Qobj, so we take `data` if
-        # original_data was a Qobj
-        original_data = original_data.data
-
-    if isinstance(original_data, np.ndarray):
-        # For numpy object we compare with data's data. This should be dense so
-        # we get its data as ndarray.
-        qobj_data = qobj_data.as_ndarray()
-
-        # We look at the memory and see if it is shared or not to asses wether
-        # copy argument worked or not.
-        assert np.shares_memory(qobj_data, original_data) != copy
-
-    else:
-        assert (original_data is qobj_data) != copy
-
-
-def test_QobjType():
-    "qutip.Qobj type"
-    N = int(np.ceil(10.0 * np.random.random())) + 5
-
-    ket_data = np.random.random((N, 1))
-    ket_qobj = qutip.Qobj(ket_data)
-    assert ket_qobj.type == 'ket'
-    assert ket_qobj.isket
-
-    bra_data = np.random.random((1, N))
-    bra_qobj = qutip.Qobj(bra_data)
-    assert bra_qobj.type == 'bra'
-    assert bra_qobj.isbra
-
-    oper_data = np.random.random((N, N))
-    oper_qobj = qutip.Qobj(oper_data)
-    assert oper_qobj.type == 'oper'
-    assert oper_qobj.isoper
-
-    N = 9
-    super_data = np.random.random((N, N))
-    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
-    assert super_qobj.type == 'super'
-    assert super_qobj.issuper
-    assert super_qobj.superrep == 'super'
-
-    super_data = np.random.random(N)
-    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
-    assert super_qobj.type == 'operator-ket'
-    assert super_qobj.isoperket
-    assert super_qobj.superrep == 'super'
-
-    super_data = np.random.random(N)
-    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
-    assert super_qobj.type == 'operator-bra'
-    assert super_qobj.isoperbra
-    assert super_qobj.superrep == 'super'
-
-    operket_qobj = qutip.operator_to_vector(oper_qobj)
-    assert operket_qobj.isoperket
-    assert operket_qobj.dag().isoperbra
-
-
-class TestQobjHermicity:
-    def test_standard(self):
-        base = _random_not_singular(10)
-        assert_hermicity(qutip.Qobj(base), False)
-        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
-        assert_hermicity(qutip.destroy(5), False)
-        assert_hermicity(qutip.create(5), False)
-
-    def test_addition(self):
-        q_a, q_ad = qutip.destroy(5), qutip.create(5)
-        # test addition of two nonhermitian operators adding up to be hermitian
-        q_x = q_a + q_ad
-        assert_hermicity(q_x, True)
-        # test addition of one hermitan and one nonhermitian operator
-        assert_hermicity(q_x + q_a, False)
-        # test addition of two hermitan operators
-        assert_hermicity(q_x + q_x, True)
-
-    def test_multiplication(self):
-        # Test multiplication of two Hermitian operators.  This results in a
-        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
-        # set wrong metadata.
-        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
-        # Similarly, we need to check that -Z = X * iY is correctly identified
-        # as Hermitian.
-        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
-
-
-def assert_unitarity(oper, unitarity):
-    # Check the cached isunitary.
-    assert oper.isunitary == unitarity
-
-    # Force a reset of the cached value for isunitary.
-    oper._isunitary = None
-    # Force a recalculation of isunitary.
-    assert oper.isunitary == unitarity
-
-
-def test_QobjUnitaryOper():
-    "qutip.Qobj unitarity"
-    # Check some standard operators
-    Sx = qutip.sigmax()
-    Sy = qutip.sigmay()
-    assert_unitarity(qutip.qeye(4), True)
-    assert_unitarity(Sx, True)
-    assert_unitarity(Sy, True)
-    assert_unitarity(qutip.sigmam(), False)
-    assert_unitarity(qutip.destroy(10), False)
-    # Check multiplcation of unitary is unitary
-    assert_unitarity(Sx*Sy, True)
-    # Check some other operations clear unitarity
-    assert_unitarity(Sx+Sy, False)
-    assert_unitarity(4*Sx, False)
-    assert_unitarity(Sx*4, False)
-    assert_unitarity(4+Sx, False)
-    assert_unitarity(Sx+4, False)
-    # Check that when multipliying scalar numbers with absolute value 1 we
-    # maintain unitarity.
-    assert_unitarity(Sx*np.exp(5j), True)
-    assert_unitarity(Sx*1j, True)
-    assert_unitarity(Sx*1, True)
-    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
-    # We do not know if it is unitary until we check the whole matrix again.
-    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
-    # This may be removed in the future as if scalar has abs value of 1 and
-    # matrix is not unitary, output wont be unitary.
-    assert (qutip.sigmam()*1)._isunitary == None
-
-
-def test_QobjDimsShape():
-    "qutip.Qobj shape"
-    N = 10
-    data = _random_not_singular(N)
-
-    q1 = qutip.Qobj(data)
-    assert q1.dims == [[10], [10]]
-    assert q1.shape == (10, 10)
-
-    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
-
-    q1 = qutip.Qobj(data)
-    assert q1.dims == [[10], [1]]
-    assert q1.shape == (10, 1)
-
-    data = _random_not_singular(4)
-
-    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
-    assert q1.dims == [[2, 2], [2, 2]]
-    assert q1.shape == (4, 4)
-
-
-def test_QobjMulNonsquareDims():
-    """
-    qutip.Qobj: multiplication w/ non-square qobj.dims
-
-    Checks for regression of #331.
-    """
-    data = np.array([[0, 1], [1, 0]])
-
-    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
-    q2 = qutip.Qobj(data, dims=[[2], [2]])
-
-    assert (q1 * q2).dims == [[2, 1], [2]]
-    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
-    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
-
-    # Because of the above, we also need to check for extra indices
-    # that aren't of length 1.
-    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
-                     [0.+0.j,  1.+0.j],
-                     [0.+0.j,  1.+0.j],
-                     [1.+0.j,  0.+0.j],
-                     [0.+0.j,  0.-1.j],
-                     [0.+1.j,  0.+0.j],
-                     [1.+0.j,  0.+0.j],
-                     [0.+0.j, -1.+0.j]],
-                    dims=[[4, 2], [2]])
-    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
-
-
-def test_QobjAddition():
-    "qutip.Qobj addition"
-    data1 = np.array([[1, 2], [3, 4]])
-    data2 = np.array([[5, 6], [7, 8]])
-    data3 = data1 + data2
-
-    q1 = qutip.Qobj(data1)
-    q2 = qutip.Qobj(data2)
-    q3 = qutip.Qobj(data3)
-
-    q4 = q1 + q2
-    q4_type = q4.type
-    q4_isherm = q4.isherm
-    q4._type = None
-    q4._isherm = None  # clear cached values
-    assert q4_type == q4.type
-    assert q4_isherm == q4.isherm
-
-    # check elementwise addition/subtraction
-    assert q3 == q4
-
-    # check that addition is commutative
-    assert q1 + q2 == q2 + q1
-
-    data = np.random.random((5, 5))
-    q = qutip.Qobj(data)
-    x1 = q + 5
-    x2 = 5 + q
-    data = data + np.eye(5) * 5
-    assert np.all(x1.full() == data)
-    assert np.all(x2.full() == data)
-
-
-def test_QobjSubtraction():
-    "qutip.Qobj subtraction"
-    data1 = _random_not_singular(5)
-    q1 = qutip.Qobj(data1)
-
-    data2 = _random_not_singular(5)
-    q2 = qutip.Qobj(data2)
-
-    q3 = q1 - q2
-    data3 = data1 - data2
-    assert np.all(q3.full() == data3)
-
-    q4 = q2 - q1
-    data4 = data2 - data1
-    assert np.all(q4.full() == data4)
-
-
-def test_QobjMultiplication():
-    "qutip.Qobj multiplication"
-    data1 = np.array([[1, 2], [3, 4]])
-    data2 = np.array([[5, 6], [7, 8]])
-
-    data3 = np.dot(data1, data2)
-
-    q1 = qutip.Qobj(data1)
-    q2 = qutip.Qobj(data2)
-    q3 = qutip.Qobj(data3)
-
-    q4 = q1 * q2
-
-    assert q3 == q4
-
-
-# Allowed mul operations (scalar)
-@pytest.mark.parametrize("scalar",
-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
-                         ids=[
-                             "python_number",
-                             "scalar_like_array_shape_0",
-                             "scalar_like_array_shape_1",
-                         ])
-def test_QobjMulValidScalar(scalar):
-    "Tests multiplication of Qobj times scalar."
-    data = np.array([[1, 2], [3, 4]])
-    q = qutip.Qobj(data)
-    expect = data * (2+2j)
-
-    # Check __mul__
-    result = q * scalar
-    assert np.all(result.full() == expect)
-
-    # Check __rmul__
-    result = scalar * q
-    assert np.all(result.full() == expect)
-
-
-# We do not allow yet qobj being multiplied by a numpy array that does not
-# represent a scalar. If we include the feature of numpy broadcasting an qobj
-# as scalar, this test should be removed.
-@pytest.mark.parametrize("not_scalar",
-                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
-                         ids=[
-                             "not_scalar_like_vector",
-                             "not_scalar_like_matrix",
-                         ])
-def test_QobjMulNotValidScalar(not_scalar):
-    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-
-    with pytest.raises(TypeError):
-        not_scalar * q1
-
-    with pytest.raises(TypeError):
-        q1 * not_scalar
-
-
-# Allowed division operations (scalar)
-@pytest.mark.parametrize("scalar",
-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
-                         ids=[
-                             "python_number",
-                             "scalar_like_array_shape_0",
-                             "scalar_like_array_shape_1",
-                         ])
-def test_QobjDivisionValidScalar(scalar):
-    "Tests multiplication of Qobj times scalar."
-    data = np.array([[1, 2], [3, 4]])
-    q = qutip.Qobj(data)
-    expect = data / (2+2j)
-
-    # Check __truediv__
-    result = q / scalar
-    assert np.all(result.full() == expect)
-
-
-# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
-# non scalar numpy values. This should also be removed in case of implementing
-# broadcasting rules for Qobj.
-@pytest.mark.parametrize("not_scalar",
-                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
-                         ids=[
-                             "not_scalar_like_vector",
-                             "not_scalar_like_matrix",
-                         ])
-def test_QobjDivisionNotValidScalar(not_scalar):
-    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-
-    with pytest.raises(TypeError):
-        q1 / not_scalar
-
-
-def test_QobjNotImplemented():
-    class MockerScalar():
-        def __mul__(self, other):
-            return "object not accepted by _data.mul, mul"
-
-        def __rmul__(self, other):
-            return "object not accepted by _data.mul, rmul"
-
-        def __rtruediv__(self, other):
-            return "object not accepted by _data.mul, rtruediv"
-
-    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
-    scalar = MockerScalar()
-    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
-    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
-    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
-
-def test_QobjDivision():
-    "qutip.Qobj division"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    randN = 10 * np.random.random()
-    q = q / randN
-    assert np.allclose(q.full(), data/randN)
-
-
-def test_QobjPower():
-    "qutip.Qobj power"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
-    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
-
-
-def test_QobjNeg():
-    "qutip.Qobj negation"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    x = -q
-    assert np.all(x.full() == -data)
-    assert q.isherm == x.isherm
-    assert q.type == x.type
-
-
-def test_QobjEquals():
-    "qutip.Qobj equals"
-    data = _random_not_singular(5)
-    q1 = qutip.Qobj(data)
-    q2 = qutip.Qobj(data)
-    assert q1 == q2
-
-    q1 = qutip.Qobj(data)
-    q2 = qutip.Qobj(-data)
-    assert q1 != q2
-
-
-def test_QobjGetItem():
-    "qutip.Qobj getitem"
-    data = _random_not_singular(5)
-    q = qutip.Qobj(data)
-    assert q[0, 0] == data[0, 0]
-    assert q[-1, 2] == data[-1, 2]
-
-
-def test_CheckMulType():
-    "qutip.Qobj multiplication type"
-    # ket-bra and bra-ket multiplication
-    psi = qutip.basis(5, 0)
-    dm = psi * psi.dag()
-    assert dm.isoper
-    assert dm.isherm
-
-    nrm = psi.dag() * psi
-    assert isinstance(nrm, numbers.Complex)
-    assert abs(nrm) == 1
-
-    # operator-operator multiplication
-    H1 = qutip.rand_herm(3)
-    H2 = qutip.rand_herm(3)
-    out = H1 * H2
-    assert out.isoper
-    out = H1 * H1
-    assert out.isoper
-    assert out.isherm
-    out = H2 * H2
-    assert out.isoper
-    assert out.isherm
-
-    U = qutip.rand_unitary(5)
-    out = U.dag() * U
-    assert out.isoper
-    assert out.isherm
-
-    N = qutip.num(5)
-
-    out = N * N
-    assert out.isoper
-    assert out.isherm
-
-    # operator-ket and bra-operator multiplication
-    op = qutip.sigmax()
-    ket1 = qutip.basis(2, 0)
-    ket2 = op * ket1
-    assert ket2.isket
-
-    bra1 = qutip.basis(2, 0).dag()
-    bra2 = bra1 * op
-    assert bra2.isbra
-
-    assert bra2.dag() == ket2
-
-    # superoperator-operket and operbra-superoperator multiplication
-    sop = qutip.to_super(qutip.sigmax())
-    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
-    opket2 = sop * opket1
-    assert opket2.isoperket
-
-    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
-    opbra2 = opbra1 * sop
-    assert opbra2.isoperbra
-
-    assert opbra2.dag() == opket2
-
-
-def test_operator_ket_superrep():
-    sop = qutip.to_super(qutip.sigmax())
-    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
-    opket2 = sop * opket1
-    assert opket1.superrep == opket2.superrep
-
-    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
-    opbra2 = opbra1 * sop
-    assert opbra1.superrep == opbra2.superrep
-
-
-def test_QobjConjugate():
-    "qutip.Qobj conjugate"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.conj()
-    assert np.all(B.full() == data.conj())
-    assert A.isherm == B.isherm
-    assert A.type == B.type
-    assert A.superrep == B.superrep
-
-
-def test_QobjDagger():
-    "qutip.Qobj adjoint (dagger)"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.dag()
-    assert np.all(B.full() == data.conj().T)
-    assert A.isherm == B.isherm
-    assert A.type == B.type
-    assert A.superrep == B.superrep
-
-
-def test_QobjDiagonals():
-    "qutip.Qobj diagonals"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    b = A.diag()
-    assert np.all(b == np.diag(data))
-
-
-def test_QobjEigenEnergies():
-    "qutip.Qobj eigenenergies"
-    data = np.eye(5)
-    A = qutip.Qobj(data)
-    b = A.eigenenergies()
-    assert np.all(b == np.ones(5))
-
-    data = np.diag(np.arange(10))
-    A = qutip.Qobj(data)
-    b = A.eigenenergies()
-    assert np.all(b == np.arange(10))
-
-    data = np.diag(np.arange(10))
-    A = 5 * qutip.Qobj(data)
-    b = A.eigenenergies()
-    assert np.all(b == 5*np.arange(10))
-
-
-def test_QobjEigenStates():
-    "qutip.Qobj eigenstates"
-    data = np.eye(5)
-    A = qutip.Qobj(data)
-    b, c = A.eigenstates()
-    assert np.all(b == np.ones(5))
-    kets = [qutip.basis(5, k) for k in range(5)]
-    for k in range(5):
-        assert c[k] == kets[k]
-
-
-def test_QobjExpm():
-    "qutip.Qobj expm (dense)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    B = A.expm()
-    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
-
-
-def test_QobjExpmExplicitlySparse():
-    "qutip.Qobj expm (sparse)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    B = A.expm(dtype=qutip.data.CSR)
-    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
-
-
-def test_QobjExpmZeroOper():
-    "qutip.Qobj expm zero_oper (#493)"
-    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
-    B = A.expm()
-    assert B == qutip.qeye(5)
-
-
-def test_QobjLogm():
-    "qutip.Qobj expm (dense)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    B = A.logm()
-    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
-
-
-def test_QobjLogmExplicitlySparse():
-    "qutip.Qobj logm (sparse)"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data).to("csr")
-    B = A.logm()
-    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
-
-
-def test_QobjLogmZeroOper():
-    "qutip.Qobj logm zero_oper (#493)"
-    A = qutip.qeye(5)
-    B = A.logm()
-    assert B == qutip.qzero(5)
-
-
-def test_Qobj_sqrtm():
-    "qutip.Qobj sqrtm"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.sqrtm()
-    assert A == B * B
-
-
-def test_Qobj_inv():
-    "qutip.Qobj inv"
-    data = _random_not_singular(5)
-    A = qutip.Qobj(data)
-    B = A.inv()
-    assert qutip.qeye(5) == A * B
-    assert qutip.qeye(5) == B * A
-    B = A.inv(sparse=True)
-    assert qutip.qeye(5) == A * B
-    assert qutip.qeye(5) == B * A
-
-
-def test_QobjFull():
-    "qutip.Qobj full"
-    data = _random_not_singular(15)
-    A = qutip.Qobj(data)
-    b = A.full()
-    assert np.all(b == data)
-
-
-def test_QobjNorm():
-    "qutip.Qobj norm"
-    # vector L2-norm test
-    N = 20
-    x = np.random.random(N) + 1j*np.random.random(N)
-    A = qutip.Qobj(x)
-    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
-    # vector max (inf) norm test
-    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
-                               atol=1e-12)
-    # operator frobius norm
-    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
-    A = qutip.Qobj(x)
-    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
-                               atol=1e-12)
-    # operator trace norm
-    a = qutip.rand_herm(10, density=0.25)
-    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
-    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
-    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
-
-
-def test_QobjPurity():
-    "Tests the purity method of `qutip.Qobj`"
-    psi = qutip.basis(2, 1)
-    # check purity of pure ket state
-    np.testing.assert_allclose(psi.purity(), 1)
-    # check purity of pure ket state (superposition)
-    psi2 = qutip.basis(2, 0)
-    psi_tot = (psi+psi2).unit()
-    np.testing.assert_allclose(psi_tot.purity(), 1)
-    # check purity of density matrix of pure state
-    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
-    # check purity of maximally mixed density matrix
-    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
-    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
-
-
-def test_QobjPermute(datatype):
-    "qutip.Qobj permute"
-    A = qutip.basis(3, 0, dtype=datatype)
-    B = qutip.basis(5, 4, dtype=datatype)
-    C = qutip.basis(4, 2, dtype=datatype)
-    psi = qutip.tensor(A, B, C)
-    psi2 = psi.permute([2, 0, 1])
-    assert psi2 == qutip.tensor(C, A, B)
-
-    psi_bra = psi.dag()
-    psi2_bra = psi_bra.permute([2, 0, 1])
-    assert psi2_bra == qutip.tensor(C, A, B).dag()
-
-    A = qutip.fock_dm(3, 0, dtype=datatype)
-    B = qutip.fock_dm(5, 4, dtype=datatype)
-    C = qutip.fock_dm(4, 2, dtype=datatype)
-    rho = qutip.tensor(A, B, C)
-    rho2 = rho.permute([2, 0, 1])
-    assert rho2 == qutip.tensor(C, A, B)
-
-    for _ in range(3):
-        A = qutip.rand_ket(3, dtype=datatype)
-        B = qutip.rand_ket(4, dtype=datatype)
-        C = qutip.rand_ket(5, dtype=datatype)
-        psi = qutip.tensor(A, B, C)
-        psi2 = psi.permute([1, 0, 2])
-        assert psi2 == qutip.tensor(B, A, C)
-
-        psi_bra = psi.dag()
-        psi2_bra = psi_bra.permute([1, 0, 2])
-        assert psi2_bra == qutip.tensor(B, A, C).dag()
-
-    for _ in range(3):
-        A = qutip.rand_dm(3, dtype=datatype)
-        B = qutip.rand_dm(4, dtype=datatype)
-        C = qutip.rand_dm(5, dtype=datatype)
-        rho = qutip.tensor(A, B, C)
-        rho2 = rho.permute([1, 0, 2])
-        assert rho2 == qutip.tensor(B, A, C)
-
-        rho_vec = qutip.operator_to_vector(rho)
-        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
-        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
-
-        rho_vec_bra = qutip.operator_to_vector(rho).dag()
-        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
-        assert (rho2_vec_bra
-                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
-
-    for _ in range(3):
-        super_dims = [3, 5, 4]
-        U = qutip.rand_unitary(super_dims, dtype=datatype)
-        Unew = U.permute([2, 1, 0])
-        S_tens = qutip.to_super(U)
-        S_tens_new = qutip.to_super(Unew)
-        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
-
-
-def test_KetType():
-    "qutip.Qobj ket type"
-
-    psi = qutip.basis(2, 1)
-
-    assert psi.isket
-    assert not psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
-
-    assert psi.isket
-    assert not psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-
-def test_BraType():
-    "qutip.Qobj bra type"
-
-    psi = qutip.basis(2, 1).dag()
-    assert not psi.isket
-    assert psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
-    assert not psi.isket
-    assert psi.isbra
-    assert not psi.isoper
-    assert not psi.issuper
-
-
-def test_OperType():
-    "qutip.Qobj operator type"
-
-    psi = qutip.basis(2, 1)
-    rho = psi * psi.dag()
-
-    assert not rho.isket
-    assert not rho.isbra
-    assert rho.isoper
-    assert not rho.issuper
-
-
-def test_SuperType():
-    "qutip.Qobj superoperator type"
-
-    psi = qutip.basis(2, 1)
-    rho = psi * psi.dag()
-
-    sop = qutip.spre(rho)
-
-    assert not sop.isket
-    assert not sop.isbra
-    assert not sop.isoper
-    assert sop.issuper
-
-    sop = qutip.spost(rho)
-
-    assert not sop.isket
-    assert not sop.isbra
-    assert not sop.isoper
-    assert sop.issuper
-
-
-@pytest.mark.parametrize("dimension", [2, 4, 8])
-@pytest.mark.parametrize("conversion", [
-    pytest.param(qutip.to_super, id='to_super'),
-    pytest.param(qutip.to_choi, id='to_choi'),
-    pytest.param(qutip.to_chi, id='to_chi'),
-])
-def test_dag_preserves_superrep(dimension, conversion):
-    """
-    Checks that dag() preserves superrep.
-    """
-    qobj = conversion(qutip.rand_super_bcsz(dimension))
-    assert qobj.superrep == qobj.dag().superrep
-
-
-@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
-@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
-    pytest.param(operator.add, True, True, id='add'),
-    pytest.param(operator.sub, True, True, id='sub'),
-    pytest.param(operator.mul, True, True, id='mul'),
-    pytest.param(operator.truediv, False, True, id='div'),
-    pytest.param(qutip.tensor, True, False, id='tensor'),
-])
-def test_arithmetic_preserves_superrep(superrep,
-                                       operation, check_op, check_scalar):
-    """
-    Checks that binary ops preserve 'superrep'.
-
-    .. note::
-
-        The random superoperators are not chosen in a way that reflects the
-        structure of that superrep, but are simply random matrices.
-    """
-    dims = [[[2], [2]], [[2], [2]]]
-    shape = (4, 4)
-    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
-    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
-    x = np.random.random()
-
-    check_list = []
-    if check_op:
-        check_list.append(operation(S1, S2))
-    if check_scalar:
-        check_list.append(operation(S1, x))
-    if check_op and check_scalar:
-        check_list.append(operation(x, S2))
-
-    for S in check_list:
-        assert S.issuper
-        assert S.type == "super"
-        assert S.superrep == superrep
-
-
-def test_isherm_skew():
-    """
-    mul and tensor of skew-Hermitian operators report ``isherm = True``.
-    """
-    iH = 1j * qutip.rand_herm(5)
-    assert_hermicity(iH, False)
-    assert_hermicity(iH * iH, True)
-    assert_hermicity(qutip.tensor(iH, iH), True)
-
-
-def test_super_tensor_operket():
-    """
-    Tensor: Checks that super_tensor respects states.
-    """
-    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
-    qutip.operator_to_vector(rho1)
-    qutip.operator_to_vector(rho2)
-
-
-def test_super_tensor_property():
-    """
-    Tensor: Super_tensor correctly tensors on underlying spaces.
-    """
-    U1 = qutip.rand_unitary(3)
-    U2 = qutip.rand_unitary(5)
-    U = qutip.tensor(U1, U2)
-    S_tens = qutip.to_super(U)
-    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
-    assert S_tens == S_supertens
-    assert S_supertens.superrep == 'super'
-
-
-def test_composite_oper():
-    """
-    Composite: Tests compositing unitaries and superoperators.
-    """
-    U1 = qutip.rand_unitary(3)
-    U2 = qutip.rand_unitary(5)
-    S1 = qutip.to_super(U1)
-    S2 = qutip.to_super(U2)
-    S3 = qutip.rand_super(4)
-    S4 = qutip.rand_super(7)
-
-    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
-    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
-    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
-    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
-
-
-def test_composite_vec():
-    """
-    Composite: Tests compositing states and density operators.
-    """
-    k1 = qutip.rand_ket(5)
-    k2 = qutip.rand_ket(7)
-    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
-    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
-
-    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
-    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
-
-    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
-    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
-    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
-    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
-
-# TODO: move out to a more appropriate module.
-
-
-def trunc_neg_case(qobj, method, expected=None):
-    pos_qobj = qobj.trunc_neg(method=method)
-    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
-    np.testing.assert_allclose(pos_qobj.tr(), 1)
-    if expected is not None:
-        test_array = pos_qobj.full()
-        exp_array = expected.full()
-        np.testing.assert_allclose(test_array, exp_array)
-
-
-class TestTruncNeg:
-    """Test qutip.Qobj.trunc_neg for several different cases."""
-    def test_positive_operator(self):
-        trunc_neg_case(qutip.rand_dm(5), 'clip')
-        trunc_neg_case(qutip.rand_dm(5), 'sgs')
-
-    def test_diagonal_operator(self):
-        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
-        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
-        trunc_neg_case(to_test, 'clip', expected)
-        trunc_neg_case(to_test, 'sgs', expected)
-
-    def test_nondiagonal_operator(self):
-        U = qutip.rand_unitary(3)
-        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
-        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
-        trunc_neg_case(to_test, 'clip', expected)
-        trunc_neg_case(to_test, 'sgs', expected)
-
-    def test_sgs_known_good(self):
-        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
-                       'sgs',
-                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
-
-
-def test_cosm():
-    """
-    Test qutip.Qobj: cosm
-    """
-    A = qutip.rand_herm(5)
-    B = A.cosm().full()
-    C = scipy.linalg.cosm(A.full())
-    np.testing.assert_allclose(B, C, atol=1e-14)
-
-
-def test_sinm():
-    """
-    Test qutip.Qobj: sinm
-    """
-    A = qutip.rand_herm(5)
-    B = A.sinm().full()
-    C = scipy.linalg.sinm(A.full())
-    np.testing.assert_allclose(B, C, atol=1e-14)
-
-
-@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
-def test_dual_channel(sub_dimensions, n_trials=50):
-    """
-    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
-    """
-    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
-    S.dims = [[sub_dimensions, sub_dimensions],
-              [sub_dimensions, sub_dimensions]]
-    S = qutip.to_super(S)
-    left_dims, right_dims = S.dims
-
-    # Assume for the purposes of the test that S maps square operators to
-    # square operators.
-    in_dim = np.prod(right_dims[0])
-    out_dim = np.prod(left_dims[0])
-
-    S_dual = qutip.to_super(S.dual_chan())
-
-    primals = []
-    duals = []
-
-    for _ in [None]*n_trials:
-        X = qutip.rand_dm(out_dim)
-        X.dims = left_dims
-        X = qutip.operator_to_vector(X)
-        Y = qutip.rand_dm(in_dim)
-        Y.dims = right_dims
-        Y = qutip.operator_to_vector(Y)
-
-        primals.append(X.dag() * S * Y)
-        duals.append(X.dag() * S_dual.dag() * Y)
-
-    np.testing.assert_allclose(primals, duals)
-
-
-def test_call():
-    """
-    Test qutip.Qobj: Call
-    """
-    # Make test objects.
-    psi = qutip.rand_ket(3)
-    rho = qutip.rand_dm(3)
-    U = qutip.rand_unitary(3)
-    S = qutip.rand_super_bcsz(3)
-
-    # Case 0: oper(ket).
-    assert U(psi) == U * psi
-    # Case 1: oper(oper). Should raise TypeError.
-    with pytest.raises(TypeError):
-        U(rho)
-    # Case 2: super(ket).
-    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
-    assert S(psi) == expected
-    # Case 3: super(oper).
-    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
-    assert S(rho) == expected
-    # Case 4: super(super). Should raise TypeError.
-    with pytest.raises(TypeError):
-        S(S)
-
-
-def test_mat_elem():
-    """
-    Test qutip.Qobj: Compute matrix elements
-    """
-    for _ in range(10):
-        N = 20
-        H = qutip.rand_herm(N, density=0.2)
-        L = qutip.rand_ket(N, density=0.3)
-        Ld = L.dag()
-        R = qutip.rand_ket(N, density=0.3)
-        ans = Ld * H * R
-        # bra-ket
-        out1 = H.matrix_element(Ld, R)
-        # ket-ket
-        out2 = H.matrix_element(Ld, R)
-        assert abs(ans - out1) < 1e-14
-        assert abs(ans - out2) < 1e-14
-
-
-def test_projection():
-    """
-    Test qutip.Qobj: Projection operator
-    """
-    for _ in range(10):
-        N = 5
-        K = qutip.rand_ket([N, N], density=0.75)
-        B = K.dag()
-        ans = K * K.dag()
-        out1 = K.proj()
-        out2 = B.proj()
-        assert out1 == ans
-        assert out2 == ans
-
-
-def test_overlap():
-    """
-    Test qutip.Qobj: Overlap (inner product)
-    """
-    for _ in range(10):
-        N = 10
-        A = qutip.rand_ket(N, density=0.75)
-        Ad = A.dag()
-        B = qutip.rand_ket(N, density=0.75)
-        Bd = B.dag()
-        ans = A.dag() * B
-        np.testing.assert_allclose(A.overlap(B), ans)
-        np.testing.assert_allclose(Ad.overlap(B), ans)
-        np.testing.assert_allclose(Ad.overlap(Bd), ans)
-        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
-
-
-def test_unit():
-    """
-    Test qutip.Qobj: unit
-    """
-    psi = (10*np.random.randn()*qutip.basis(2, 0)
-           - 10j*np.random.randn()*qutip.basis(2, 1))
-    psi2 = psi.unit()
-    psi.unit(inplace=True)
-    assert psi == psi2
-    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
-
-
-def test_trace():
-    sz = qutip.sigmaz()
-    assert sz.tr() == 0
-
-
-def test_no_real_attribute(monkeypatch):
-    """This tests ensures that trace still works even if the output of a
-    specialisation does not have the ``real`` attribute. This is the case for
-    the tensorflow and cupy data layers."""
-
-    def mocker_trace_return(oper):
-        """
-        We simply return a string which does not have the `real` attribute.
-        """
-        return "object without .real"
-
-    monkeypatch.setattr(_data, "trace", mocker_trace_return)
-
-    sz = qutip.sigmaz() # the choice of the matrix does not matter
-    assert "object without .real" == sz.tr()
-
-
-@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
-@pytest.mark.parametrize(['expanded', 'contracted'], [
-    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
-    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
-    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
-    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
-    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
-                 id='mixed'),
-    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
-                 id='mixed,unchanged'),
-    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
-                 id='mixed,unchanged'),
-    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
-    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
-    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
-                 id='ket,unchanged'),
-    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
-    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
-    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
-                 id='bra,unchanged'),
-    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
-                 id='operket'),
-    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
-                 id='operbra'),
-])
-def test_contract(expanded, contracted, inplace):
-    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    qobj = qutip.Qobj(data, dims=expanded)
-    assert qobj.dims == expanded
-    out = qobj.contract(inplace=inplace)
-    if inplace:
-        assert out is qobj
-    else:
-        assert out is not qobj
-    assert out.dims == contracted
-    assert out.shape == qobj.shape
-    assert np.all(out.full() == qobj.full())
-
-
-@pytest.mark.parametrize(["shape"], [
-    pytest.param((5, 1), id='ket'),
-    pytest.param((5, 2), id='tall'),
-    pytest.param((1, 5), id='bra'),
-    pytest.param((2, 5), id='wide'),
-    pytest.param((3, 3), id='oper'),
-])
-def test_sum_zero(shape):
-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    qobj = qutip.Qobj(data)
-    assert qobj + 0 == qobj
-    assert qobj - 0 == qobj
-    assert 0 + qobj == qobj
-    assert 0 - qobj == -qobj
-
-
-@pytest.mark.parametrize(["shape"], [
-    pytest.param((5, 1), id='ket'),
-    pytest.param((5, 2), id='tall'),
-    pytest.param((1, 5), id='bra'),
-    pytest.param((2, 5), id='wide'),
-    pytest.param((3, 3), id='oper'),
-])
-def test_sum_buildin(shape):
-    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
-    qobj = qutip.Qobj(data)
-    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
-
-
-def test_groundstate():
-    eigenvals = np.sort(np.random.rand(10))
-    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
-    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
-    groundenergy, groundstate = qobj.groundstate()
-    assert groundenergy == pytest.approx(eigenvals[0])
-    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
-    assert groundstate.overlap(groundstate) == pytest.approx(1)
-
-    with pytest.warns(UserWarning) as warning:
-        qutip.qeye(5).groundstate()
-    assert "degenerate" in warning[0].message.args[0]
+import numbers
+import operator
+import pytest
+
+import numpy as np
+import scipy.sparse
+import scipy.linalg
+
+import qutip
+from qutip.core import data as _data
+
+
+@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+def datatype(request):
+    return request.param
+
+
+def _random_not_singular(N):
+    """
+    return a N*N complex array with determinant not 0.
+    """
+    data = np.zeros((1, 1))
+    while np.linalg.det(data) == 0:
+        data = np.random.random((N, N)) + \
+               1j * np.random.random((N, N)) - (0.5 + 0.5j)
+    return data
+
+
+def assert_hermicity(oper, hermicity):
+    # Check the cached isherm, if any exists.
+    assert oper.isherm == hermicity
+    # Force a reset of the cached value for isherm.
+    oper._isherm = None
+    # Force a recalculation of isherm.
+    assert oper.isherm == hermicity
+
+
+def test_QobjData():
+    "qutip.Qobj data"
+    N = 10
+    data1 = _random_not_singular(N)
+    q1 = qutip.Qobj(data1)
+    assert isinstance(q1.data, qutip.core.data.Data)
+    assert np.all(q1.data.to_array() == data1)
+
+    data2 = _random_not_singular(N)
+    data2 = scipy.sparse.csr_matrix(data2)
+    q2 = qutip.Qobj(data2)
+    assert isinstance(q2.data, qutip.core.data.Data)
+
+
+@pytest.mark.parametrize("original_data",
+                         [
+                            qutip.data.Dense(_random_not_singular(2)),
+                            qutip.data.csr.identity(2),
+                            qutip.Qobj(_random_not_singular(2)),
+                            _random_not_singular(2),
+                         ],
+                         ids=[
+                             "Dense",
+                             "CSR",
+                             "Qobj",
+                             "ndarray",
+                         ])
+@pytest.mark.parametrize("copy", [True, False],
+                         ids=["copy=True", "copy=False"])
+def test_QobjCopyArgument(original_data, copy):
+    """Tests that Qobj copy argument works properly when instantiating Qobj."""
+    qobj_data = qutip.Qobj(original_data, copy=copy).data
+
+    if isinstance(original_data, qutip.Qobj):
+        # Qobj copies the data of another Qobj, so we take `data` if
+        # original_data was a Qobj
+        original_data = original_data.data
+
+    if isinstance(original_data, np.ndarray):
+        # For numpy object we compare with data's data. This should be dense so
+        # we get its data as ndarray.
+        qobj_data = qobj_data.as_ndarray()
+
+        # We look at the memory and see if it is shared or not to asses wether
+        # copy argument worked or not.
+        assert np.shares_memory(qobj_data, original_data) != copy
+
+    else:
+        assert (original_data is qobj_data) != copy
+
+
+def test_QobjType():
+    "qutip.Qobj type"
+    N = int(np.ceil(10.0 * np.random.random())) + 5
+
+    ket_data = np.random.random((N, 1))
+    ket_qobj = qutip.Qobj(ket_data)
+    assert ket_qobj.type == 'ket'
+    assert ket_qobj.isket
+
+    bra_data = np.random.random((1, N))
+    bra_qobj = qutip.Qobj(bra_data)
+    assert bra_qobj.type == 'bra'
+    assert bra_qobj.isbra
+
+    oper_data = np.random.random((N, N))
+    oper_qobj = qutip.Qobj(oper_data)
+    assert oper_qobj.type == 'oper'
+    assert oper_qobj.isoper
+
+    N = 9
+    super_data = np.random.random((N, N))
+    super_qobj = qutip.Qobj(super_data, dims=[[[3]], [[3]]])
+    assert super_qobj.type == 'super'
+    assert super_qobj.issuper
+    assert super_qobj.superrep == 'super'
+
+    super_data = np.random.random(N)
+    super_qobj = qutip.Qobj(super_data, dims=[[[3], [3]], [[1]]])
+    assert super_qobj.type == 'operator-ket'
+    assert super_qobj.isoperket
+    assert super_qobj.superrep == 'super'
+
+    super_data = np.random.random(N)
+    super_qobj = qutip.Qobj(super_data, dims=[[[1]], [[3], [3]]])
+    assert super_qobj.type == 'operator-bra'
+    assert super_qobj.isoperbra
+    assert super_qobj.superrep == 'super'
+
+    operket_qobj = qutip.operator_to_vector(oper_qobj)
+    assert operket_qobj.isoperket
+    assert operket_qobj.dag().isoperbra
+
+
+class TestQobjHermicity:
+    def test_standard(self):
+        base = _random_not_singular(10)
+        assert_hermicity(qutip.Qobj(base), False)
+        assert_hermicity(qutip.Qobj(base + base.conj().T), True)
+        assert_hermicity(qutip.destroy(5), False)
+        assert_hermicity(qutip.create(5), False)
+
+    def test_addition(self):
+        q_a, q_ad = qutip.destroy(5), qutip.create(5)
+        # test addition of two nonhermitian operators adding up to be hermitian
+        q_x = q_a + q_ad
+        assert_hermicity(q_x, True)
+        # test addition of one hermitan and one nonhermitian operator
+        assert_hermicity(q_x + q_a, False)
+        # test addition of two hermitan operators
+        assert_hermicity(q_x + q_x, True)
+
+    def test_multiplication(self):
+        # Test multiplication of two Hermitian operators.  This results in a
+        # skew-Hermitian operator, so we're checking here that __mul__ doesn't
+        # set wrong metadata.
+        assert_hermicity(qutip.sigmax() * qutip.sigmay(), False)
+        # Similarly, we need to check that -Z = X * iY is correctly identified
+        # as Hermitian.
+        assert_hermicity(1j * qutip.sigmax() * qutip.sigmay(), True)
+
+
+def assert_unitarity(oper, unitarity):
+    # Check the cached isunitary.
+    assert oper.isunitary == unitarity
+
+    # Force a reset of the cached value for isunitary.
+    oper._isunitary = None
+    # Force a recalculation of isunitary.
+    assert oper.isunitary == unitarity
+
+
+def test_QobjUnitaryOper():
+    "qutip.Qobj unitarity"
+    # Check some standard operators
+    Sx = qutip.sigmax()
+    Sy = qutip.sigmay()
+    assert_unitarity(qutip.qeye(4), True)
+    assert_unitarity(Sx, True)
+    assert_unitarity(Sy, True)
+    assert_unitarity(qutip.sigmam(), False)
+    assert_unitarity(qutip.destroy(10), False)
+    # Check multiplcation of unitary is unitary
+    assert_unitarity(Sx*Sy, True)
+    # Check some other operations clear unitarity
+    assert_unitarity(Sx+Sy, False)
+    assert_unitarity(4*Sx, False)
+    assert_unitarity(Sx*4, False)
+    assert_unitarity(4+Sx, False)
+    assert_unitarity(Sx+4, False)
+    # Check that when multipliying scalar numbers with absolute value 1 we
+    # maintain unitarity.
+    assert_unitarity(Sx*np.exp(5j), True)
+    assert_unitarity(Sx*1j, True)
+    assert_unitarity(Sx*1, True)
+    # Chech that if qobj is _not_ unitary, operation by scalar set it to `None`
+    # We do not know if it is unitary until we check the whole matrix again.
+    assert (qutip.sigmam()*4)._isunitary == None  # Non unitary
+    # This may be removed in the future as if scalar has abs value of 1 and
+    # matrix is not unitary, output wont be unitary.
+    assert (qutip.sigmam()*1)._isunitary == None
+
+
+def test_QobjDimsShape():
+    "qutip.Qobj shape"
+    N = 10
+    data = _random_not_singular(N)
+
+    q1 = qutip.Qobj(data)
+    assert q1.dims == [[10], [10]]
+    assert q1.shape == (10, 10)
+
+    data = np.random.random((N, 1)) + 1j*np.random.random((N, 1)) - (0.5+0.5j)
+
+    q1 = qutip.Qobj(data)
+    assert q1.dims == [[10], [1]]
+    assert q1.shape == (10, 1)
+
+    data = _random_not_singular(4)
+
+    q1 = qutip.Qobj(data, dims=[[2, 2], [2, 2]])
+    assert q1.dims == [[2, 2], [2, 2]]
+    assert q1.shape == (4, 4)
+
+
+def test_QobjMulNonsquareDims():
+    """
+    qutip.Qobj: multiplication w/ non-square qobj.dims
+
+    Checks for regression of #331.
+    """
+    data = np.array([[0, 1], [1, 0]])
+
+    q1 = qutip.Qobj(data, dims=[[2, 1], [2]])
+    q2 = qutip.Qobj(data, dims=[[2], [2]])
+
+    assert (q1 * q2).dims == [[2, 1], [2]]
+    assert (q2 * q1.dag()).dims == [[2], [2, 1]]
+    assert (q1 * q2 * q1.dag()).dims == [[2, 1], [2, 1]]
+
+    # Because of the above, we also need to check for extra indices
+    # that aren't of length 1.
+    q1 = qutip.Qobj([[1.+0.j,  0.+0.j],
+                     [0.+0.j,  1.+0.j],
+                     [0.+0.j,  1.+0.j],
+                     [1.+0.j,  0.+0.j],
+                     [0.+0.j,  0.-1.j],
+                     [0.+1.j,  0.+0.j],
+                     [1.+0.j,  0.+0.j],
+                     [0.+0.j, -1.+0.j]],
+                    dims=[[4, 2], [2]])
+    assert (q1 * q2 * q1.dag()).dims == [[4, 2], [4, 2]]
+
+
+def test_QobjAddition():
+    "qutip.Qobj addition"
+    data1 = np.array([[1, 2], [3, 4]])
+    data2 = np.array([[5, 6], [7, 8]])
+    data3 = data1 + data2
+
+    q1 = qutip.Qobj(data1)
+    q2 = qutip.Qobj(data2)
+    q3 = qutip.Qobj(data3)
+
+    q4 = q1 + q2
+    q4_type = q4.type
+    q4_isherm = q4.isherm
+    q4._type = None
+    q4._isherm = None  # clear cached values
+    assert q4_type == q4.type
+    assert q4_isherm == q4.isherm
+
+    # check elementwise addition/subtraction
+    assert q3 == q4
+
+    # check that addition is commutative
+    assert q1 + q2 == q2 + q1
+
+    data = np.random.random((5, 5))
+    q = qutip.Qobj(data)
+    x1 = q + 5
+    x2 = 5 + q
+    data = data + np.eye(5) * 5
+    assert np.all(x1.full() == data)
+    assert np.all(x2.full() == data)
+
+
+def test_QobjSubtraction():
+    "qutip.Qobj subtraction"
+    data1 = _random_not_singular(5)
+    q1 = qutip.Qobj(data1)
+
+    data2 = _random_not_singular(5)
+    q2 = qutip.Qobj(data2)
+
+    q3 = q1 - q2
+    data3 = data1 - data2
+    assert np.all(q3.full() == data3)
+
+    q4 = q2 - q1
+    data4 = data2 - data1
+    assert np.all(q4.full() == data4)
+
+
+def test_QobjMultiplication():
+    "qutip.Qobj multiplication"
+    data1 = np.array([[1, 2], [3, 4]])
+    data2 = np.array([[5, 6], [7, 8]])
+
+    data3 = np.dot(data1, data2)
+
+    q1 = qutip.Qobj(data1)
+    q2 = qutip.Qobj(data2)
+    q3 = qutip.Qobj(data3)
+
+    q4 = q1 * q2
+
+    assert q3 == q4
+
+
+# Allowed mul operations (scalar)
+@pytest.mark.parametrize("scalar",
+                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+                         ids=[
+                             "python_number",
+                             "scalar_like_array_shape_0",
+                             "scalar_like_array_shape_1",
+                         ])
+def test_QobjMulValidScalar(scalar):
+    "Tests multiplication of Qobj times scalar."
+    data = np.array([[1, 2], [3, 4]])
+    q = qutip.Qobj(data)
+    expect = data * (2+2j)
+
+    # Check __mul__
+    result = q * scalar
+    assert np.all(result.full() == expect)
+
+    # Check __rmul__
+    result = scalar * q
+    assert np.all(result.full() == expect)
+
+
+# We do not allow yet qobj being multiplied by a numpy array that does not
+# represent a scalar. If we include the feature of numpy broadcasting an qobj
+# as scalar, this test should be removed.
+@pytest.mark.parametrize("not_scalar",
+                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
+                         ids=[
+                             "not_scalar_like_vector",
+                             "not_scalar_like_matrix",
+                         ])
+def test_QobjMulNotValidScalar(not_scalar):
+    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+
+    with pytest.raises(TypeError):
+        not_scalar * q1
+
+    with pytest.raises(TypeError):
+        q1 * not_scalar
+
+
+# Allowed division operations (scalar)
+@pytest.mark.parametrize("scalar",
+                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+                         ids=[
+                             "python_number",
+                             "scalar_like_array_shape_0",
+                             "scalar_like_array_shape_1",
+                         ])
+def test_QobjDivisionValidScalar(scalar):
+    "Tests multiplication of Qobj times scalar."
+    data = np.array([[1, 2], [3, 4]])
+    q = qutip.Qobj(data)
+    expect = data / (2+2j)
+
+    # Check __truediv__
+    result = q / scalar
+    assert np.all(result.full() == expect)
+
+
+# Similar as in test_QobjMulNotValidScalar, we do not allow multiplication by
+# non scalar numpy values. This should also be removed in case of implementing
+# broadcasting rules for Qobj.
+@pytest.mark.parametrize("not_scalar",
+                         [np.array([2j, 1]), np.array([[1, 2], [3, 4]])],
+                         ids=[
+                             "not_scalar_like_vector",
+                             "not_scalar_like_matrix",
+                         ])
+def test_QobjDivisionNotValidScalar(not_scalar):
+    q1 = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+
+    with pytest.raises(TypeError):
+        q1 / not_scalar
+
+
+def test_QobjNotImplemented():
+    class MockerScalar():
+        def __mul__(self, other):
+            return "object not accepted by _data.mul, mul"
+
+        def __rmul__(self, other):
+            return "object not accepted by _data.mul, rmul"
+
+        def __rtruediv__(self, other):
+            return "object not accepted by _data.mul, rtruediv"
+
+    qobj = qutip.Qobj(np.array([[1, 2], [3, 4]]))
+    scalar = MockerScalar()
+    assert (qobj*scalar) == "object not accepted by _data.mul, rmul"
+    assert (scalar*qobj) == "object not accepted by _data.mul, mul"
+    assert (qobj/scalar) == "object not accepted by _data.mul, rtruediv"
+
+def test_QobjDivision():
+    "qutip.Qobj division"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    randN = 10 * np.random.random()
+    q = q / randN
+    assert np.allclose(q.full(), data/randN)
+
+
+def test_QobjPower():
+    "qutip.Qobj power"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    np.testing.assert_allclose((q**2).full(), data @ data, atol=1e-12)
+    np.testing.assert_allclose((q**3).full(), data @ data @ data, atol=1e-12)
+
+
+def test_QobjNeg():
+    "qutip.Qobj negation"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    x = -q
+    assert np.all(x.full() == -data)
+    assert q.isherm == x.isherm
+    assert q.type == x.type
+
+
+def test_QobjEquals():
+    "qutip.Qobj equals"
+    data = _random_not_singular(5)
+    q1 = qutip.Qobj(data)
+    q2 = qutip.Qobj(data)
+    assert q1 == q2
+
+    q1 = qutip.Qobj(data)
+    q2 = qutip.Qobj(-data)
+    assert q1 != q2
+
+
+def test_QobjGetItem():
+    "qutip.Qobj getitem"
+    data = _random_not_singular(5)
+    q = qutip.Qobj(data)
+    assert q[0, 0] == data[0, 0]
+    assert q[-1, 2] == data[-1, 2]
+
+
+def test_CheckMulType():
+    "qutip.Qobj multiplication type"
+    # ket-bra and bra-ket multiplication
+    psi = qutip.basis(5, 0)
+    dm = psi * psi.dag()
+    assert dm.isoper
+    assert dm.isherm
+
+    nrm = psi.dag() * psi
+    assert isinstance(nrm, numbers.Complex)
+    assert abs(nrm) == 1
+
+    # operator-operator multiplication
+    H1 = qutip.rand_herm(3)
+    H2 = qutip.rand_herm(3)
+    out = H1 * H2
+    assert out.isoper
+    out = H1 * H1
+    assert out.isoper
+    assert out.isherm
+    out = H2 * H2
+    assert out.isoper
+    assert out.isherm
+
+    U = qutip.rand_unitary(5)
+    out = U.dag() * U
+    assert out.isoper
+    assert out.isherm
+
+    N = qutip.num(5)
+
+    out = N * N
+    assert out.isoper
+    assert out.isherm
+
+    # operator-ket and bra-operator multiplication
+    op = qutip.sigmax()
+    ket1 = qutip.basis(2, 0)
+    ket2 = op * ket1
+    assert ket2.isket
+
+    bra1 = qutip.basis(2, 0).dag()
+    bra2 = bra1 * op
+    assert bra2.isbra
+
+    assert bra2.dag() == ket2
+
+    # superoperator-operket and operbra-superoperator multiplication
+    sop = qutip.to_super(qutip.sigmax())
+    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
+    opket2 = sop * opket1
+    assert opket2.isoperket
+
+    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
+    opbra2 = opbra1 * sop
+    assert opbra2.isoperbra
+
+    assert opbra2.dag() == opket2
+
+
+def test_operator_ket_superrep():
+    sop = qutip.to_super(qutip.sigmax())
+    opket1 = qutip.operator_to_vector(qutip.fock_dm(2, 0))
+    opket2 = sop * opket1
+    assert opket1.superrep == opket2.superrep
+
+    opbra1 = qutip.operator_to_vector(qutip.fock_dm(2, 0)).dag()
+    opbra2 = opbra1 * sop
+    assert opbra1.superrep == opbra2.superrep
+
+
+def test_QobjConjugate():
+    "qutip.Qobj conjugate"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.conj()
+    assert np.all(B.full() == data.conj())
+    assert A.isherm == B.isherm
+    assert A.type == B.type
+    assert A.superrep == B.superrep
+
+
+def test_QobjDagger():
+    "qutip.Qobj adjoint (dagger)"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.dag()
+    assert np.all(B.full() == data.conj().T)
+    assert A.isherm == B.isherm
+    assert A.type == B.type
+    assert A.superrep == B.superrep
+
+
+def test_QobjDiagonals():
+    "qutip.Qobj diagonals"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    b = A.diag()
+    assert np.all(b == np.diag(data))
+
+
+def test_QobjEigenEnergies():
+    "qutip.Qobj eigenenergies"
+    data = np.eye(5)
+    A = qutip.Qobj(data)
+    b = A.eigenenergies()
+    assert np.all(b == np.ones(5))
+
+    data = np.diag(np.arange(10))
+    A = qutip.Qobj(data)
+    b = A.eigenenergies()
+    assert np.all(b == np.arange(10))
+
+    data = np.diag(np.arange(10))
+    A = 5 * qutip.Qobj(data)
+    b = A.eigenenergies()
+    assert np.all(b == 5*np.arange(10))
+
+
+def test_QobjEigenStates():
+    "qutip.Qobj eigenstates"
+    data = np.eye(5)
+    A = qutip.Qobj(data)
+    b, c = A.eigenstates()
+    assert np.all(b == np.ones(5))
+    kets = [qutip.basis(5, k) for k in range(5)]
+    for k in range(5):
+        assert c[k] == kets[k]
+
+
+def test_QobjExpm():
+    "qutip.Qobj expm (dense)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    B = A.expm()
+    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
+
+
+def test_QobjExpmExplicitlySparse():
+    "qutip.Qobj expm (sparse)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    B = A.expm(dtype=qutip.data.CSR)
+    np.testing.assert_allclose(B.full(), scipy.linalg.expm(data), atol=1e-10)
+
+
+def test_QobjExpmZeroOper():
+    "qutip.Qobj expm zero_oper (#493)"
+    A = qutip.Qobj(np.zeros((5, 5), dtype=complex))
+    B = A.expm()
+    assert B == qutip.qeye(5)
+
+
+def test_QobjLogm():
+    "qutip.Qobj expm (dense)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    B = A.logm()
+    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
+
+
+def test_QobjLogmExplicitlySparse():
+    "qutip.Qobj logm (sparse)"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data).to("csr")
+    B = A.logm()
+    np.testing.assert_allclose(B.full(), scipy.linalg.logm(data), atol=1e-10)
+
+
+def test_QobjLogmZeroOper():
+    "qutip.Qobj logm zero_oper (#493)"
+    A = qutip.qeye(5)
+    B = A.logm()
+    assert B == qutip.qzero(5)
+
+
+def test_Qobj_sqrtm():
+    "qutip.Qobj sqrtm"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.sqrtm()
+    assert A == B * B
+
+
+def test_Qobj_inv():
+    "qutip.Qobj inv"
+    data = _random_not_singular(5)
+    A = qutip.Qobj(data)
+    B = A.inv()
+    assert qutip.qeye(5) == A * B
+    assert qutip.qeye(5) == B * A
+    B = A.inv(sparse=True)
+    assert qutip.qeye(5) == A * B
+    assert qutip.qeye(5) == B * A
+
+
+def test_QobjFull():
+    "qutip.Qobj full"
+    data = _random_not_singular(15)
+    A = qutip.Qobj(data)
+    b = A.full()
+    assert np.all(b == data)
+
+
+def test_QobjNorm():
+    "qutip.Qobj norm"
+    # vector L2-norm test
+    N = 20
+    x = np.random.random(N) + 1j*np.random.random(N)
+    A = qutip.Qobj(x)
+    np.testing.assert_allclose(A.norm(), scipy.linalg.norm(x, 2), atol=1e-12)
+    # vector max (inf) norm test
+    np.testing.assert_allclose(A.norm('max'), scipy.linalg.norm(x, np.inf),
+                               atol=1e-12)
+    # operator frobius norm
+    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
+    A = qutip.Qobj(x)
+    np.testing.assert_allclose(A.norm('fro'), scipy.linalg.norm(x, 'fro'),
+                               atol=1e-12)
+    # operator trace norm
+    a = qutip.rand_herm(10, density=0.25)
+    np.testing.assert_allclose(a.norm(), (a*a.dag()).sqrtm().tr().real)
+    b = qutip.rand_herm(10, density=0.25) - 1j*qutip.rand_herm(10, density=0.25)
+    np.testing.assert_allclose(b.norm(), (b*b.dag()).sqrtm().tr().real)
+
+
+def test_QobjPurity():
+    "Tests the purity method of `qutip.Qobj`"
+    psi = qutip.basis(2, 1)
+    # check purity of pure ket state
+    np.testing.assert_allclose(psi.purity(), 1)
+    # check purity of pure ket state (superposition)
+    psi2 = qutip.basis(2, 0)
+    psi_tot = (psi+psi2).unit()
+    np.testing.assert_allclose(psi_tot.purity(), 1)
+    # check purity of density matrix of pure state
+    np.testing.assert_allclose(qutip.ket2dm(psi_tot).purity(), 1)
+    # check purity of maximally mixed density matrix
+    rho_mixed = (qutip.ket2dm(psi) + qutip.ket2dm(psi2)).unit()
+    np.testing.assert_allclose(rho_mixed.purity(), 0.5)
+
+
+def test_QobjPermute(datatype):
+    "qutip.Qobj permute"
+    A = qutip.basis(3, 0, dtype=datatype)
+    B = qutip.basis(5, 4, dtype=datatype)
+    C = qutip.basis(4, 2, dtype=datatype)
+    psi = qutip.tensor(A, B, C)
+    psi2 = psi.permute([2, 0, 1])
+    assert psi2 == qutip.tensor(C, A, B)
+
+    psi_bra = psi.dag()
+    psi2_bra = psi_bra.permute([2, 0, 1])
+    assert psi2_bra == qutip.tensor(C, A, B).dag()
+
+    A = qutip.fock_dm(3, 0, dtype=datatype)
+    B = qutip.fock_dm(5, 4, dtype=datatype)
+    C = qutip.fock_dm(4, 2, dtype=datatype)
+    rho = qutip.tensor(A, B, C)
+    rho2 = rho.permute([2, 0, 1])
+    assert rho2 == qutip.tensor(C, A, B)
+
+    for _ in range(3):
+        A = qutip.rand_ket(3, dtype=datatype)
+        B = qutip.rand_ket(4, dtype=datatype)
+        C = qutip.rand_ket(5, dtype=datatype)
+        psi = qutip.tensor(A, B, C)
+        psi2 = psi.permute([1, 0, 2])
+        assert psi2 == qutip.tensor(B, A, C)
+
+        psi_bra = psi.dag()
+        psi2_bra = psi_bra.permute([1, 0, 2])
+        assert psi2_bra == qutip.tensor(B, A, C).dag()
+
+    for _ in range(3):
+        A = qutip.rand_dm(3, dtype=datatype)
+        B = qutip.rand_dm(4, dtype=datatype)
+        C = qutip.rand_dm(5, dtype=datatype)
+        rho = qutip.tensor(A, B, C)
+        rho2 = rho.permute([1, 0, 2])
+        assert rho2 == qutip.tensor(B, A, C)
+
+        rho_vec = qutip.operator_to_vector(rho)
+        rho2_vec = rho_vec.permute([[1, 0, 2], [4, 3, 5]])
+        assert rho2_vec == qutip.operator_to_vector(qutip.tensor(B, A, C))
+
+        rho_vec_bra = qutip.operator_to_vector(rho).dag()
+        rho2_vec_bra = rho_vec_bra.permute([[1, 0, 2], [4, 3, 5]])
+        assert (rho2_vec_bra
+                == qutip.operator_to_vector(qutip.tensor(B, A, C)).dag())
+
+    for _ in range(3):
+        super_dims = [3, 5, 4]
+        U = qutip.rand_unitary(super_dims, dtype=datatype)
+        Unew = U.permute([2, 1, 0])
+        S_tens = qutip.to_super(U)
+        S_tens_new = qutip.to_super(Unew)
+        assert S_tens_new == S_tens.permute([[2, 1, 0], [5, 4, 3]])
+
+
+def test_KetType():
+    "qutip.Qobj ket type"
+
+    psi = qutip.basis(2, 1)
+
+    assert psi.isket
+    assert not psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+    psi = qutip.tensor(qutip.basis(2, 1), qutip.basis(2, 0))
+
+    assert psi.isket
+    assert not psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+
+def test_BraType():
+    "qutip.Qobj bra type"
+
+    psi = qutip.basis(2, 1).dag()
+    assert not psi.isket
+    assert psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+    psi = qutip.tensor(qutip.basis(2, 1).dag(), qutip.basis(2, 0).dag())
+    assert not psi.isket
+    assert psi.isbra
+    assert not psi.isoper
+    assert not psi.issuper
+
+
+def test_OperType():
+    "qutip.Qobj operator type"
+
+    psi = qutip.basis(2, 1)
+    rho = psi * psi.dag()
+
+    assert not rho.isket
+    assert not rho.isbra
+    assert rho.isoper
+    assert not rho.issuper
+
+
+def test_SuperType():
+    "qutip.Qobj superoperator type"
+
+    psi = qutip.basis(2, 1)
+    rho = psi * psi.dag()
+
+    sop = qutip.spre(rho)
+
+    assert not sop.isket
+    assert not sop.isbra
+    assert not sop.isoper
+    assert sop.issuper
+
+    sop = qutip.spost(rho)
+
+    assert not sop.isket
+    assert not sop.isbra
+    assert not sop.isoper
+    assert sop.issuper
+
+
+@pytest.mark.parametrize("dimension", [2, 4, 8])
+@pytest.mark.parametrize("conversion", [
+    pytest.param(qutip.to_super, id='to_super'),
+    pytest.param(qutip.to_choi, id='to_choi'),
+    pytest.param(qutip.to_chi, id='to_chi'),
+])
+def test_dag_preserves_superrep(dimension, conversion):
+    """
+    Checks that dag() preserves superrep.
+    """
+    qobj = conversion(qutip.rand_super_bcsz(dimension))
+    assert qobj.superrep == qobj.dag().superrep
+
+
+@pytest.mark.parametrize("superrep", ["super", "choi", "chi"])
+@pytest.mark.parametrize(["operation", "check_op", "check_scalar"], [
+    pytest.param(operator.add, True, True, id='add'),
+    pytest.param(operator.sub, True, True, id='sub'),
+    pytest.param(operator.mul, True, True, id='mul'),
+    pytest.param(operator.truediv, False, True, id='div'),
+    pytest.param(qutip.tensor, True, False, id='tensor'),
+])
+def test_arithmetic_preserves_superrep(superrep,
+                                       operation, check_op, check_scalar):
+    """
+    Checks that binary ops preserve 'superrep'.
+
+    .. note::
+
+        The random superoperators are not chosen in a way that reflects the
+        structure of that superrep, but are simply random matrices.
+    """
+    dims = [[[2], [2]], [[2], [2]]]
+    shape = (4, 4)
+    S1 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
+    S2 = qutip.Qobj(np.random.random(shape), superrep=superrep, dims=dims)
+    x = np.random.random()
+
+    check_list = []
+    if check_op:
+        check_list.append(operation(S1, S2))
+    if check_scalar:
+        check_list.append(operation(S1, x))
+    if check_op and check_scalar:
+        check_list.append(operation(x, S2))
+
+    for S in check_list:
+        assert S.issuper
+        assert S.type == "super"
+        assert S.superrep == superrep
+
+
+def test_isherm_skew():
+    """
+    mul and tensor of skew-Hermitian operators report ``isherm = True``.
+    """
+    iH = 1j * qutip.rand_herm(5)
+    assert_hermicity(iH, False)
+    assert_hermicity(iH * iH, True)
+    assert_hermicity(qutip.tensor(iH, iH), True)
+
+
+def test_super_tensor_operket():
+    """
+    Tensor: Checks that super_tensor respects states.
+    """
+    rho1, rho2 = qutip.rand_dm(5), qutip.rand_dm(7)
+    qutip.operator_to_vector(rho1)
+    qutip.operator_to_vector(rho2)
+
+
+def test_super_tensor_property():
+    """
+    Tensor: Super_tensor correctly tensors on underlying spaces.
+    """
+    U1 = qutip.rand_unitary(3)
+    U2 = qutip.rand_unitary(5)
+    U = qutip.tensor(U1, U2)
+    S_tens = qutip.to_super(U)
+    S_supertens = qutip.super_tensor(qutip.to_super(U1), qutip.to_super(U2))
+    assert S_tens == S_supertens
+    assert S_supertens.superrep == 'super'
+
+
+def test_composite_oper():
+    """
+    Composite: Tests compositing unitaries and superoperators.
+    """
+    U1 = qutip.rand_unitary(3)
+    U2 = qutip.rand_unitary(5)
+    S1 = qutip.to_super(U1)
+    S2 = qutip.to_super(U2)
+    S3 = qutip.rand_super(4)
+    S4 = qutip.rand_super(7)
+
+    assert qutip.composite(U1, U2) == qutip.tensor(U1, U2)
+    assert qutip.composite(S3, S4) == qutip.super_tensor(S3, S4)
+    assert qutip.composite(U1, S4) == qutip.super_tensor(S1, S4)
+    assert qutip.composite(S3, U2) == qutip.super_tensor(S3, S2)
+
+
+def test_composite_vec():
+    """
+    Composite: Tests compositing states and density operators.
+    """
+    k1 = qutip.rand_ket(5)
+    k2 = qutip.rand_ket(7)
+    r1 = qutip.operator_to_vector(qutip.ket2dm(k1))
+    r2 = qutip.operator_to_vector(qutip.ket2dm(k2))
+
+    r3 = qutip.operator_to_vector(qutip.rand_dm(3))
+    r4 = qutip.operator_to_vector(qutip.rand_dm(4))
+
+    assert qutip.composite(k1, k2) == qutip.tensor(k1, k2)
+    assert qutip.composite(r3, r4) == qutip.super_tensor(r3, r4)
+    assert qutip.composite(k1, r4) == qutip.super_tensor(r1, r4)
+    assert qutip.composite(r3, k2) == qutip.super_tensor(r3, r2)
+
+# TODO: move out to a more appropriate module.
+
+
+def trunc_neg_case(qobj, method, expected=None):
+    pos_qobj = qobj.trunc_neg(method=method)
+    assert all(energy > -1e-8 for energy in pos_qobj.eigenenergies())
+    np.testing.assert_allclose(pos_qobj.tr(), 1)
+    if expected is not None:
+        test_array = pos_qobj.full()
+        exp_array = expected.full()
+        np.testing.assert_allclose(test_array, exp_array)
+
+
+class TestTruncNeg:
+    """Test qutip.Qobj.trunc_neg for several different cases."""
+    def test_positive_operator(self):
+        trunc_neg_case(qutip.rand_dm(5), 'clip')
+        trunc_neg_case(qutip.rand_dm(5), 'sgs')
+
+    def test_diagonal_operator(self):
+        to_test = qutip.Qobj(np.diag([1.1, 0, -0.1]))
+        expected = qutip.Qobj(np.diag([1.0, 0.0, 0.0]))
+        trunc_neg_case(to_test, 'clip', expected)
+        trunc_neg_case(to_test, 'sgs', expected)
+
+    def test_nondiagonal_operator(self):
+        U = qutip.rand_unitary(3)
+        to_test = U * qutip.Qobj(np.diag([1.1, 0, -0.1])) * U.dag()
+        expected = U * qutip.Qobj(np.diag([1.0, 0.0, 0.0])) * U.dag()
+        trunc_neg_case(to_test, 'clip', expected)
+        trunc_neg_case(to_test, 'sgs', expected)
+
+    def test_sgs_known_good(self):
+        trunc_neg_case(qutip.Qobj(np.diag([3./5, 1./2, 7./20, 1./10, -11./20])),
+                       'sgs',
+                       qutip.Qobj(np.diag([9./20, 7./20, 1./5, 0, 0])))
+
+
+def test_cosm():
+    """
+    Test qutip.Qobj: cosm
+    """
+    A = qutip.rand_herm(5)
+    B = A.cosm().full()
+    C = scipy.linalg.cosm(A.full())
+    np.testing.assert_allclose(B, C, atol=1e-14)
+
+
+def test_sinm():
+    """
+    Test qutip.Qobj: sinm
+    """
+    A = qutip.rand_herm(5)
+    B = A.sinm().full()
+    C = scipy.linalg.sinm(A.full())
+    np.testing.assert_allclose(B, C, atol=1e-14)
+
+
+@pytest.mark.parametrize("sub_dimensions", ([2], [2, 2], [2, 3], [3, 5, 2]))
+def test_dual_channel(sub_dimensions, n_trials=50):
+    """
+    qutip.Qobj: dual_chan() preserves inner products with arbitrary density ops.
+    """
+    S = qutip.rand_super_bcsz(np.prod(sub_dimensions))
+    S.dims = [[sub_dimensions, sub_dimensions],
+              [sub_dimensions, sub_dimensions]]
+    S = qutip.to_super(S)
+    left_dims, right_dims = S.dims
+
+    # Assume for the purposes of the test that S maps square operators to
+    # square operators.
+    in_dim = np.prod(right_dims[0])
+    out_dim = np.prod(left_dims[0])
+
+    S_dual = qutip.to_super(S.dual_chan())
+
+    primals = []
+    duals = []
+
+    for _ in [None]*n_trials:
+        X = qutip.rand_dm(out_dim)
+        X.dims = left_dims
+        X = qutip.operator_to_vector(X)
+        Y = qutip.rand_dm(in_dim)
+        Y.dims = right_dims
+        Y = qutip.operator_to_vector(Y)
+
+        primals.append(X.dag() * S * Y)
+        duals.append(X.dag() * S_dual.dag() * Y)
+
+    np.testing.assert_allclose(primals, duals)
+
+
+def test_call():
+    """
+    Test qutip.Qobj: Call
+    """
+    # Make test objects.
+    psi = qutip.rand_ket(3)
+    rho = qutip.rand_dm(3)
+    U = qutip.rand_unitary(3)
+    S = qutip.rand_super_bcsz(3)
+
+    # Case 0: oper(ket).
+    assert U(psi) == U * psi
+    # Case 1: oper(oper). Should raise TypeError.
+    with pytest.raises(TypeError):
+        U(rho)
+    # Case 2: super(ket).
+    expected = qutip.vector_to_operator(S*qutip.operator_to_vector(psi.proj()))
+    assert S(psi) == expected
+    # Case 3: super(oper).
+    expected = qutip.vector_to_operator(S * qutip.operator_to_vector(rho))
+    assert S(rho) == expected
+    # Case 4: super(super). Should raise TypeError.
+    with pytest.raises(TypeError):
+        S(S)
+
+
+def test_mat_elem():
+    """
+    Test qutip.Qobj: Compute matrix elements
+    """
+    for _ in range(10):
+        N = 20
+        H = qutip.rand_herm(N, density=0.2)
+        L = qutip.rand_ket(N, density=0.3)
+        Ld = L.dag()
+        R = qutip.rand_ket(N, density=0.3)
+        ans = Ld * H * R
+        # bra-ket
+        out1 = H.matrix_element(Ld, R)
+        # ket-ket
+        out2 = H.matrix_element(Ld, R)
+        assert abs(ans - out1) < 1e-14
+        assert abs(ans - out2) < 1e-14
+
+
+def test_projection():
+    """
+    Test qutip.Qobj: Projection operator
+    """
+    for _ in range(10):
+        N = 5
+        K = qutip.rand_ket([N, N], density=0.75)
+        B = K.dag()
+        ans = K * K.dag()
+        out1 = K.proj()
+        out2 = B.proj()
+        assert out1 == ans
+        assert out2 == ans
+
+
+def test_overlap():
+    """
+    Test qutip.Qobj: Overlap (inner product)
+    """
+    for _ in range(10):
+        N = 10
+        A = qutip.rand_ket(N, density=0.75)
+        Ad = A.dag()
+        B = qutip.rand_ket(N, density=0.75)
+        Bd = B.dag()
+        ans = A.dag() * B
+        np.testing.assert_allclose(A.overlap(B), ans)
+        np.testing.assert_allclose(Ad.overlap(B), ans)
+        np.testing.assert_allclose(Ad.overlap(Bd), ans)
+        np.testing.assert_allclose(A.overlap(Bd), np.conj(ans))
+
+
+def test_unit():
+    """
+    Test qutip.Qobj: unit
+    """
+    psi = (10*np.random.randn()*qutip.basis(2, 0)
+           - 10j*np.random.randn()*qutip.basis(2, 1))
+    psi2 = psi.unit()
+    psi.unit(inplace=True)
+    assert psi == psi2
+    np.testing.assert_allclose(np.linalg.norm(psi.full()), 1.0)
+
+
+def test_trace():
+    sz = qutip.sigmaz()
+    assert sz.tr() == 0
+
+
+def test_no_real_attribute(monkeypatch):
+    """This tests ensures that trace still works even if the output of a
+    specialisation does not have the ``real`` attribute. This is the case for
+    the tensorflow and cupy data layers."""
+
+    def mocker_trace_return(oper):
+        """
+        We simply return a string which does not have the `real` attribute.
+        """
+        return "object without .real"
+
+    monkeypatch.setattr(_data, "trace", mocker_trace_return)
+
+    sz = qutip.sigmaz() # the choice of the matrix does not matter
+    assert "object without .real" == sz.tr()
+
+
+@pytest.mark.parametrize('inplace', [True, False], ids=['inplace', 'new'])
+@pytest.mark.parametrize(['expanded', 'contracted'], [
+    pytest.param([[1, 2, 2], [1, 2, 2]], [[2, 2], [2, 2]], id='op'),
+    pytest.param([[2, 1, 1], [2, 1, 1]], [[2], [2]], id='op'),
+    pytest.param([[5, 5], [5, 5]], [[5, 5], [5, 5]], id='op,unchanged'),
+    pytest.param([[5], [5]], [[5], [5]], id='op,unchanged'),
+    pytest.param([[5, 1, 3, 1], [5, 2, 3, 1]], [[5, 1, 3], [5, 2, 3]],
+                 id='mixed'),
+    pytest.param([[2, 1, 2], [2, 2, 2]], [[2, 1, 2], [2, 2, 2]],
+                 id='mixed,unchanged'),
+    pytest.param([[2, 2, 2], [1, 2, 2]], [[2, 2, 2], [1, 2, 2]],
+                 id='mixed,unchanged'),
+    pytest.param([[2, 2, 1], [1, 1, 1]], [[2, 2], [1, 1]], id='ket'),
+    pytest.param([[1, 2, 1], [1, 1, 1]], [[2], [1]], id='ket'),
+    pytest.param([[2, 3, 4], [1, 1, 1]], [[2, 3, 4], [1, 1, 1]],
+                 id='ket,unchanged'),
+    pytest.param([[1, 1, 1], [2, 2, 1]], [[1, 1], [2, 2]], id='bra'),
+    pytest.param([[1, 1, 1], [1, 2, 1]], [[1], [2]], id='bra'),
+    pytest.param([[1, 1, 1], [2, 3, 4]], [[1, 1, 1], [2, 3, 4]],
+                 id='bra,unchanged'),
+    pytest.param([[[2, 1, 1], [2, 1, 1]], [1]], [[[2], [2]], [1]],
+                 id='operket'),
+    pytest.param([[1], [[2, 1, 1], [2, 1, 1]]], [[1], [[2], [2]]],
+                 id='operbra'),
+])
+def test_contract(expanded, contracted, inplace):
+    shape = (np.prod(contracted[0]), np.prod(contracted[1]))
+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    qobj = qutip.Qobj(data, dims=expanded)
+    assert qobj.dims == expanded
+    out = qobj.contract(inplace=inplace)
+    if inplace:
+        assert out is qobj
+    else:
+        assert out is not qobj
+    assert out.dims == contracted
+    assert out.shape == qobj.shape
+    assert np.all(out.full() == qobj.full())
+
+
+@pytest.mark.parametrize(["shape"], [
+    pytest.param((5, 1), id='ket'),
+    pytest.param((5, 2), id='tall'),
+    pytest.param((1, 5), id='bra'),
+    pytest.param((2, 5), id='wide'),
+    pytest.param((3, 3), id='oper'),
+])
+def test_sum_zero(shape):
+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    qobj = qutip.Qobj(data)
+    assert qobj + 0 == qobj
+    assert qobj - 0 == qobj
+    assert 0 + qobj == qobj
+    assert 0 - qobj == -qobj
+
+
+@pytest.mark.parametrize(["shape"], [
+    pytest.param((5, 1), id='ket'),
+    pytest.param((5, 2), id='tall'),
+    pytest.param((1, 5), id='bra'),
+    pytest.param((2, 5), id='wide'),
+    pytest.param((3, 3), id='oper'),
+])
+def test_sum_buildin(shape):
+    data = np.random.rand(*shape) + 1j*np.random.rand(*shape)
+    qobj = qutip.Qobj(data)
+    assert sum([qobj, 2 * qobj, -qobj]) == 2 * qobj
+
+
+def test_groundstate():
+    eigenvals = np.sort(np.random.rand(10))
+    eigenvals[1:] += 0.1  # Ensure no degenerate groundstate
+    qobj = qutip.rand_herm(10, distribution="eigen", eigenvalues=eigenvals)
+    groundenergy, groundstate = qobj.groundstate()
+    assert groundenergy == pytest.approx(eigenvals[0])
+    assert qutip.expect(qobj, groundstate) == pytest.approx(eigenvals[0])
+    assert groundstate.overlap(groundstate) == pytest.approx(1)
+
+    with pytest.warns(UserWarning) as warning:
+        qutip.qeye(5).groundstate()
+    assert "degenerate" in warning[0].message.args[0]
diff --git a/qutip/tests/core/test_qobjevo.py b/qutip/tests/core/test_qobjevo.py
index dbcb397903..77fe8fba93 100644
--- a/qutip/tests/core/test_qobjevo.py
+++ b/qutip/tests/core/test_qobjevo.py
@@ -1,515 +1,515 @@
-import operator
-
-import pytest
-from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
-                   rand_stochastic, rand_herm, rand_ket, liouvillian,
-                   basis, spre, spost, to_choi)
-import numpy as np
-from numpy.testing import assert_allclose
-
-from qutip.core import data as _data
-
-# prepare coefficient
-class Pseudo_qevo:
-    # Mimic QobjEvo on __call__
-    # and can return parameter to create the equivalent QobjEvo
-    # for each coefficient type
-    def __init__(self, cte, qobj, func, string, args):
-        self.cte = cte
-        self.qobj = qobj
-        self.func = func
-        self.str = string
-        self.args = args
-
-    def array(self):
-        tlist = np.linspace(0, 10, 10001)
-        coeff = self.func(tlist, self.args)
-        return ([self.cte, [self.qobj, coeff]], {}, tlist)
-
-    def logarray(self):
-        tlist = np.logspace(-3, 1, 10001)
-        coeff = self.func(tlist, self.args)
-        return ([self.cte, [self.qobj, coeff]], {}, tlist)
-
-    def func_coeff(self):
-        return ([self.cte, [self.qobj, self.func]], self.args)
-
-    def string(self):
-        return ([self.cte, [self.qobj, self.str]], self.args)
-
-    def func_call(self):
-        return (self.__call__, self.args)
-
-    def __call__(self, t, args={}):
-        args = args or self.args
-        return self.cte + self.qobj * self.func(t, args)
-
-    def __getitem__(self, which):
-        return getattr(self, which)()
-
-
-N = 3
-args = {'w1': 1, "w2": 2}
-TESTTIMES = np.linspace(0.001, 1.0, 10)
-
-
-def _real(t, args):
-    return np.sin(t*args['w1'])
-
-
-def _cplx(t, args):
-    return np.exp(1j*t*args['w2'])
-
-
-real_qevo = Pseudo_qevo(
-    rand_stochastic(N).to(_data.CSR),
-    rand_stochastic(N).to(_data.CSR),
-    _real, "sin(t*w1)", args)
-
-herm_qevo = Pseudo_qevo(
-    rand_herm(N).to(_data.Dense),
-    rand_herm(N).to(_data.Dense),
-    _real, "sin(t*w1)", args)
-
-cplx_qevo = Pseudo_qevo(
-    rand_stochastic(N).to(_data.Dense),
-    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
-    _cplx, "exp(1j*t*w2)", args)
-
-
-@pytest.fixture(params=['func_coeff', 'string',
-                        'array', 'logarray', 'func_call'])
-def coeff_type(request):
-    # all available QobjEvo types
-    return request.param
-
-
-@pytest.fixture(params=[
-    pytest.param(real_qevo, id="real"),
-    pytest.param(herm_qevo, id="hermitian"),
-    pytest.param(cplx_qevo, id="complex"),
-])
-def pseudo_qevo(request):
-    return request.param
-
-
-@pytest.fixture
-def all_qevo(pseudo_qevo, coeff_type):
-    return QobjEvo(*pseudo_qevo[coeff_type])
-
-
-@pytest.fixture
-def other_qevo(all_qevo):
-    return all_qevo
-
-
-def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
-
-
-def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
-    assert obj1.dims == obj2.dims
-    assert obj1.shape == obj2.shape
-    assert obj1.type == obj2.type
-    assert _data.iszero((obj1 - obj2).data, tol)
-
-
-def _assert_qobjevo_different(obj1, obj2):
-    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
-
-
-def _div(a, b):
-    return a / b
-
-
-def test_call(pseudo_qevo, coeff_type):
-    # test creation of QobjEvo and call
-    qevo = QobjEvo(*pseudo_qevo[coeff_type])
-    assert isinstance(qevo(0), Qobj)
-    assert qevo.isoper
-    assert not qevo.isconstant
-    assert not qevo.issuper
-    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
-
-
-# Test the QobjEvo.__repr__()
-def test_QobjEvo_repr():
-    # case_n: cases with Objects of QobjEvo with unique __repr__
-    # expected_repr_n: are the Expected result from the __repr__
-
-    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
-    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
-    expected_repr_1 += 'type = oper, superrep = None, '
-    expected_repr_1 += 'isconstant = False, num_elements = 1'
-    assert case_1 == expected_repr_1
-
-    case_2 = repr(QobjEvo(qeye(2)))
-    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
-    expected_repr_2 += 'type = oper, superrep = None, '
-    expected_repr_2 += 'isconstant = True, num_elements = 1'
-    assert case_2 == expected_repr_2
-
-    case_3 = repr(QobjEvo(basis(5, 2)))
-    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
-    expected_repr_3 += 'type = ket, superrep = None, '
-    expected_repr_3 += 'isconstant = True, num_elements = 1'
-    assert case_3 == expected_repr_3
-
-    X = sigmax()
-    S = spre(X) * spost(X.dag())
-    case_4 = repr(QobjEvo(to_choi(S)))
-    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
-    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
-    expected_repr_4 += 'isconstant = True, num_elements = 1'
-    assert case_4 == expected_repr_4
-
-    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
-                           [qeye(4), lambda t: t]], compress=False))
-    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
-    expected_repr_5 += 'type = oper, superrep = None, '
-    expected_repr_5 += 'isconstant = False, num_elements = 2'
-    assert case_5 == expected_repr_5
-
-
-@pytest.mark.parametrize('coeff_type',
-                         ['func_coeff', 'string', 'array', 'logarray'])
-def test_product_coeff(pseudo_qevo, coeff_type):
-    # test creation of QobjEvo with Qobj * Coefficient
-    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
-    base = pseudo_qevo[coeff_type]
-    cte, [qobj, coeff] = base[0]
-    args = base[1] if len(base) >= 2 else {}
-    tlist = base[2] if len(base) >= 3 else None
-    coeff = coefficient(coeff, args=args, tlist=tlist)
-    created = cte + qobj * coeff
-    _assert_qobjevo_equivalent(pseudo_qevo, created)
-
-def test_copy(all_qevo):
-    qevo = all_qevo
-    copy = qevo.copy()
-    _assert_qobjevo_equivalent(copy, qevo)
-    assert copy is not qevo
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(lambda a, b: a + b, id="add"),
-    pytest.param(lambda a, b: a - b, id="sub"),
-    pytest.param(lambda a, b: a * b, id="mul"),
-    pytest.param(lambda a, b: a @ b, id="matmul"),
-    pytest.param(lambda a, b: a & b, id="tensor"),
-])
-def test_binopt(all_qevo, other_qevo, bin_op):
-    "QobjEvo arithmetic"
-    obj1 = all_qevo
-    obj2 = other_qevo
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj1, obj2)(t)
-        as_qobj = bin_op(obj1(t), obj2(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(operator.iadd, id="add"),
-    pytest.param(operator.isub, id="sub"),
-    pytest.param(operator.imul, id="mul"),
-    pytest.param(operator.imatmul, id="matmul"),
-    pytest.param(operator.iand, id="tensor"),
-])
-def test_binopt_inplace(all_qevo, other_qevo, bin_op):
-    obj1 = all_qevo
-    obj2 = other_qevo
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj1.copy(), obj2)(t)
-        as_qobj = bin_op(obj1(t).copy(), obj2(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(lambda a, b: a + b, id="add"),
-    pytest.param(lambda a, b: a - b, id="sub"),
-    pytest.param(lambda a, b: a * b, id="mul"),
-    pytest.param(lambda a, b: a @ b, id="matmul"),
-    pytest.param(lambda a, b: a & b, id="tensor"),
-])
-def test_binopt_qobj(all_qevo, bin_op):
-    "QobjEvo arithmetic"
-    obj = all_qevo
-    qobj = rand_herm(N)
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj, qobj)(t)
-        as_qobj = bin_op(obj(t), qobj)
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-        as_qevo = bin_op(qobj, obj)(t)
-        as_qobj = bin_op(qobj, obj(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('bin_op', [
-    pytest.param(lambda a, b: a + b, id="add"),
-    pytest.param(lambda a, b: a - b, id="sub"),
-    pytest.param(lambda a, b: a * b, id="mul"),
-    pytest.param(_div, id="div"),
-])
-def test_binopt_scalar(all_qevo, bin_op):
-    "QobjEvo arithmetic"
-    obj = all_qevo
-    scalar = 0.5 + 1j
-    for t in TESTTIMES:
-        as_qevo = bin_op(obj, scalar)(t)
-        as_qobj = bin_op(obj(t), scalar)
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-        if bin_op is not _div:
-            as_qevo = bin_op(scalar, obj)(t)
-            as_qobj = bin_op(scalar, obj(t))
-            _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-def binop_coeff(all_qevo):
-    obj = all_qevo
-    coeff = coeffient("t")
-    created = obj * coeff_t
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(created(t), obj(t) * t)
-
-
-@pytest.mark.parametrize('unary_op', [
-    pytest.param(lambda a: a.conj(), id="conj"),
-    pytest.param(lambda a: a.dag(), id="dag"),
-    pytest.param(lambda a: a.trans(), id="trans"),
-    pytest.param(lambda a: -a, id="neg"),
-])
-def test_unary(all_qevo, unary_op):
-    "QobjEvo arithmetic"
-    obj = all_qevo
-    for t in TESTTIMES:
-        as_qevo = unary_op(obj)(t)
-        as_qobj = unary_op(obj(t))
-        _assert_qobj_almost_eq(as_qevo, as_qobj)
-
-
-@pytest.mark.parametrize('args_coeff_type',
-                         ['func_coeff', 'string', 'func_call'])
-def test_args(pseudo_qevo, args_coeff_type):
-    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
-    args = {'w1': 3, "w2": 3}
-
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
-        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
-
-    # Did it modify original args
-    _assert_qobjevo_equivalent(obj, pseudo_qevo)
-
-    obj.arguments(args)
-    _assert_qobjevo_different(obj, pseudo_qevo)
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
-
-    args = {'w1': 4, "w2": 4}
-    obj.arguments(**args)
-    _assert_qobjevo_different(obj, pseudo_qevo)
-    for t in TESTTIMES:
-        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
-
-
-def test_copy_side_effects(all_qevo):
-    t = 0.2
-    qevo = all_qevo
-    copy = qevo.copy()
-    before = qevo(t)
-    # Ensure inplace modification of the copy do not affect the original
-    copy *= 2
-    copy += rand_herm(N)
-    copy *= rand_herm(N)
-    copy.arguments({'w1': 3, "w2": 3})
-    after = qevo(t)
-    _assert_qobj_almost_eq(before, after)
-
-
-@pytest.mark.parametrize('coeff_type',
-    ['func_coeff', 'string', 'array', 'logarray']
-)
-def test_tidyup(all_qevo):
-    "QobjEvo tidyup"
-    obj = all_qevo
-    obj *= 1e-12
-    obj.tidyup(atol=1e-8)
-    t = 0.2
-    # check that the Qobj are cleaned
-    assert_allclose(obj(t).full(), 0)
-
-
-def test_QobjEvo_pickle(all_qevo):
-    "QobjEvo pickle"
-    # used in parallel_map
-    import pickle
-    obj = all_qevo
-    pickled = pickle.dumps(obj, -1)
-    recreated = pickle.loads(pickled)
-    _assert_qobjevo_equivalent(recreated, obj)
-
-
-def test_QobjEvo_restore(all_qevo):
-    "QobjEvo pickle"
-    # used in parallel_map
-    obj = all_qevo
-    state = obj._getstate()
-    recreated = QobjEvo._restore(**state)
-    _assert_qobjevo_equivalent(recreated, obj)
-
-
-def test_mul_vec(all_qevo):
-    "QobjEvo matmul ket"
-    vec = Qobj(np.arange(N)*.5+.5j)
-    op = all_qevo
-    for t in TESTTIMES:
-        assert_allclose((op(t) @ vec).full(),
-                        op.matmul(t, vec).full(), atol=1e-14)
-
-
-def test_matmul(all_qevo):
-    "QobjEvo matmul oper"
-    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
-    matDense = Qobj(mat).to(_data.Dense)
-    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
-    matCSR = Qobj(mat).to(_data.CSR)
-    op = all_qevo
-    for t in TESTTIMES:
-        Qo1 = op(t)
-        assert_allclose((Qo1 @ mat).full(),
-                        op.matmul(t, matF).full(), atol=1e-14)
-        assert_allclose((Qo1 @ mat).full(),
-                        op.matmul(t, matDense).full(), atol=1e-14)
-        assert_allclose((Qo1 @ mat).full(),
-                        op.matmul(t, matCSR).full(), atol=1e-14)
-
-
-def test_expect_psi(all_qevo):
-    "QobjEvo expect psi"
-    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
-    qobj = Qobj(vec)
-    op = all_qevo
-    for t in TESTTIMES:
-        Qo1 = op(t)
-        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
-                        atol=1e-14)
-
-
-def test_expect_rho(all_qevo):
-    "QobjEvo expect rho"
-    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
-                                      + 1j * np.random.rand(N*N))
-    mat = _data.column_unstack_dense(vec, N)
-    qobj = Qobj(mat)
-    op = liouvillian(all_qevo)
-    for t in TESTTIMES:
-        Qo1 = op(t)
-        assert abs(_data.expect_super(Qo1.data, vec)
-                   - op.expect(t, qobj)) < 1e-14
-
-
-@pytest.mark.parametrize('dtype',
-[pytest.param(dtype, id=dtype.__name__)
-     for dtype in _data.to.dtypes])
-def test_convert(all_qevo, dtype):
-    "QobjEvo expect rho"
-    op = all_qevo.to(dtype)
-    assert isinstance(op(0.5).data, dtype)
-
-
-def test_compress():
-    "QobjEvo compress"
-    obj1 = QobjEvo(
-        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
-    assert obj1.num_elements == 1
-    obj2 = QobjEvo(
-        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
-    assert obj2.num_elements == 3
-    _assert_qobjevo_equivalent(obj1, obj2)
-    obj3 = obj2.copy()
-    assert obj3.num_elements == 3
-    obj3.compress()
-    assert obj3.num_elements == 1
-    _assert_qobjevo_equivalent(obj2, obj3)
-
-
-@pytest.mark.parametrize(['qobjdtype'],
-    [pytest.param(dtype, id=dtype.__name__)
-     for dtype in _data.to.dtypes])
-@pytest.mark.parametrize(['statedtype'],
-    [pytest.param(dtype, id=dtype.__name__)
-     for dtype in _data.to.dtypes])
-def test_layer_support(qobjdtype, statedtype):
-    N = 10
-    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
-    state_dense = rand_ket(N).to(_data.Dense)
-    state = state_dense.to(statedtype).data
-    state_dense = state_dense.data
-    exp_any = qevo.expect_data(0, state)
-    exp_dense = qevo.expect_data(0, state_dense)
-    assert_allclose(exp_any, exp_dense)
-    mul_any = qevo.matmul_data(0, state).to_array()
-    mul_dense = qevo.matmul_data(0, state_dense).to_array()
-    assert_allclose(mul_any, mul_dense)
-
-
-def test_QobjEvo_step_coeff():
-    "QobjEvo step interpolation"
-    coeff1 = np.random.rand(6)
-    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
-    # uniform t
-    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
-    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
-                      tlist=tlist, order=0)
-    assert qobjevo(2.0)[0,0] == coeff1[0]
-    assert qobjevo(7.0)[0,0] == coeff1[5]
-    assert qobjevo(5.0001)[0,0] == coeff1[3]
-    assert qobjevo(3.9999)[0,0] == coeff1[1]
-
-    assert qobjevo(2.0)[0,1] == coeff2[0]
-    assert qobjevo(7.0)[0,1] == coeff2[5]
-    assert qobjevo(5.0001)[0,1] == coeff2[3]
-    assert qobjevo(3.9999)[0,1] == coeff2[1]
-
-    # non-uniform t
-    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
-    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
-        tlist=tlist, order=0)
-    assert qobjevo(1.0)[0,0] == coeff1[0]
-    assert qobjevo(8.0)[0,0] == coeff1[5]
-    assert qobjevo(3.9999)[0,0] == coeff1[1]
-    assert qobjevo(4.23)[0,0] == coeff1[2]
-    assert qobjevo(1.23)[0,0] == coeff1[0]
-
-    assert qobjevo(1.0)[0,1] == coeff2[0]
-    assert qobjevo(8.0)[0,1] == coeff2[5]
-    assert qobjevo(6.7)[0,1] == coeff2[4]
-    assert qobjevo(7.9999)[0,1] == coeff2[4]
-    assert qobjevo(3.9999)[0,1] == coeff2[1]
-
-
-def test_QobjEvo_isherm_flag_knowcase():
-    assert QobjEvo(sigmax())(0)._isherm is True
-    non_hermitian = sigmax() + 1j
-    non_hermitian.isherm  # set flag
-    assert QobjEvo(non_hermitian)(0)._isherm is False
-    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
-    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
-    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
-    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
-    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
-
-
-@pytest.mark.parametrize(
-    "coeff_type",
-    ['func_coeff', 'string', 'array', 'logarray']
-)
-def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
-    qevo = QobjEvo(*pseudo_qevo[coeff_type])
-    as_list = qevo.to_list()
-    assert len(as_list) == 2
-    restored = QobjEvo(as_list)
-    _assert_qobjevo_equivalent(qevo, restored)
+import operator
+
+import pytest
+from qutip import (Qobj, QobjEvo, coefficient, qeye, sigmax, sigmaz,
+                   rand_stochastic, rand_herm, rand_ket, liouvillian,
+                   basis, spre, spost, to_choi)
+import numpy as np
+from numpy.testing import assert_allclose
+
+from qutip.core import data as _data
+
+# prepare coefficient
+class Pseudo_qevo:
+    # Mimic QobjEvo on __call__
+    # and can return parameter to create the equivalent QobjEvo
+    # for each coefficient type
+    def __init__(self, cte, qobj, func, string, args):
+        self.cte = cte
+        self.qobj = qobj
+        self.func = func
+        self.str = string
+        self.args = args
+
+    def array(self):
+        tlist = np.linspace(0, 10, 10001)
+        coeff = self.func(tlist, self.args)
+        return ([self.cte, [self.qobj, coeff]], {}, tlist)
+
+    def logarray(self):
+        tlist = np.logspace(-3, 1, 10001)
+        coeff = self.func(tlist, self.args)
+        return ([self.cte, [self.qobj, coeff]], {}, tlist)
+
+    def func_coeff(self):
+        return ([self.cte, [self.qobj, self.func]], self.args)
+
+    def string(self):
+        return ([self.cte, [self.qobj, self.str]], self.args)
+
+    def func_call(self):
+        return (self.__call__, self.args)
+
+    def __call__(self, t, args={}):
+        args = args or self.args
+        return self.cte + self.qobj * self.func(t, args)
+
+    def __getitem__(self, which):
+        return getattr(self, which)()
+
+
+N = 3
+args = {'w1': 1, "w2": 2}
+TESTTIMES = np.linspace(0.001, 1.0, 10)
+
+
+def _real(t, args):
+    return np.sin(t*args['w1'])
+
+
+def _cplx(t, args):
+    return np.exp(1j*t*args['w2'])
+
+
+real_qevo = Pseudo_qevo(
+    rand_stochastic(N).to(_data.CSR),
+    rand_stochastic(N).to(_data.CSR),
+    _real, "sin(t*w1)", args)
+
+herm_qevo = Pseudo_qevo(
+    rand_herm(N).to(_data.Dense),
+    rand_herm(N).to(_data.Dense),
+    _real, "sin(t*w1)", args)
+
+cplx_qevo = Pseudo_qevo(
+    rand_stochastic(N).to(_data.Dense),
+    rand_stochastic(N).to(_data.CSR) + rand_stochastic(N).to(_data.CSR) * 1j,
+    _cplx, "exp(1j*t*w2)", args)
+
+
+@pytest.fixture(params=['func_coeff', 'string',
+                        'array', 'logarray', 'func_call'])
+def coeff_type(request):
+    # all available QobjEvo types
+    return request.param
+
+
+@pytest.fixture(params=[
+    pytest.param(real_qevo, id="real"),
+    pytest.param(herm_qevo, id="hermitian"),
+    pytest.param(cplx_qevo, id="complex"),
+])
+def pseudo_qevo(request):
+    return request.param
+
+
+@pytest.fixture
+def all_qevo(pseudo_qevo, coeff_type):
+    return QobjEvo(*pseudo_qevo[coeff_type])
+
+
+@pytest.fixture
+def other_qevo(all_qevo):
+    return all_qevo
+
+
+def _assert_qobjevo_equivalent(obj1, obj2, tol=1e-8):
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj1(t), obj2(t), tol)
+
+
+def _assert_qobj_almost_eq(obj1, obj2, tol=1e-10):
+    assert obj1.dims == obj2.dims
+    assert obj1.shape == obj2.shape
+    assert obj1.type == obj2.type
+    assert _data.iszero((obj1 - obj2).data, tol)
+
+
+def _assert_qobjevo_different(obj1, obj2):
+    assert any(obj1(t) != obj2(t) for t in np.random.rand(10) * .9 + 0.05)
+
+
+def _div(a, b):
+    return a / b
+
+
+def test_call(pseudo_qevo, coeff_type):
+    # test creation of QobjEvo and call
+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+    assert isinstance(qevo(0), Qobj)
+    assert qevo.isoper
+    assert not qevo.isconstant
+    assert not qevo.issuper
+    _assert_qobjevo_equivalent(pseudo_qevo, qevo)
+
+
+# Test the QobjEvo.__repr__()
+def test_QobjEvo_repr():
+    # case_n: cases with Objects of QobjEvo with unique __repr__
+    # expected_repr_n: are the Expected result from the __repr__
+
+    case_1 = repr(QobjEvo([qeye(3), lambda t: t]))
+    expected_repr_1 = 'QobjEvo: dims = [[3], [3]], shape = (3, 3), '
+    expected_repr_1 += 'type = oper, superrep = None, '
+    expected_repr_1 += 'isconstant = False, num_elements = 1'
+    assert case_1 == expected_repr_1
+
+    case_2 = repr(QobjEvo(qeye(2)))
+    expected_repr_2 = 'QobjEvo: dims = [[2], [2]], shape = (2, 2), '
+    expected_repr_2 += 'type = oper, superrep = None, '
+    expected_repr_2 += 'isconstant = True, num_elements = 1'
+    assert case_2 == expected_repr_2
+
+    case_3 = repr(QobjEvo(basis(5, 2)))
+    expected_repr_3 = 'QobjEvo: dims = [[5], [1]], shape = (5, 1), '
+    expected_repr_3 += 'type = ket, superrep = None, '
+    expected_repr_3 += 'isconstant = True, num_elements = 1'
+    assert case_3 == expected_repr_3
+
+    X = sigmax()
+    S = spre(X) * spost(X.dag())
+    case_4 = repr(QobjEvo(to_choi(S)))
+    expected_repr_4 = 'QobjEvo: dims = [[[2], [2]], [[2], [2]]], '
+    expected_repr_4 += 'shape = (4, 4), type = super, superrep = choi, '
+    expected_repr_4 += 'isconstant = True, num_elements = 1'
+    assert case_4 == expected_repr_4
+
+    case_5 = repr(QobjEvo([[qeye(4), lambda t: t],
+                           [qeye(4), lambda t: t]], compress=False))
+    expected_repr_5 = 'QobjEvo: dims = [[4], [4]], shape = (4, 4), '
+    expected_repr_5 += 'type = oper, superrep = None, '
+    expected_repr_5 += 'isconstant = False, num_elements = 2'
+    assert case_5 == expected_repr_5
+
+
+@pytest.mark.parametrize('coeff_type',
+                         ['func_coeff', 'string', 'array', 'logarray'])
+def test_product_coeff(pseudo_qevo, coeff_type):
+    # test creation of QobjEvo with Qobj * Coefficient
+    # Skip pure func: QobjEvo(f(t, args) -> Qobj)
+    base = pseudo_qevo[coeff_type]
+    cte, [qobj, coeff] = base[0]
+    args = base[1] if len(base) >= 2 else {}
+    tlist = base[2] if len(base) >= 3 else None
+    coeff = coefficient(coeff, args=args, tlist=tlist)
+    created = cte + qobj * coeff
+    _assert_qobjevo_equivalent(pseudo_qevo, created)
+
+def test_copy(all_qevo):
+    qevo = all_qevo
+    copy = qevo.copy()
+    _assert_qobjevo_equivalent(copy, qevo)
+    assert copy is not qevo
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(lambda a, b: a + b, id="add"),
+    pytest.param(lambda a, b: a - b, id="sub"),
+    pytest.param(lambda a, b: a * b, id="mul"),
+    pytest.param(lambda a, b: a @ b, id="matmul"),
+    pytest.param(lambda a, b: a & b, id="tensor"),
+])
+def test_binopt(all_qevo, other_qevo, bin_op):
+    "QobjEvo arithmetic"
+    obj1 = all_qevo
+    obj2 = other_qevo
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj1, obj2)(t)
+        as_qobj = bin_op(obj1(t), obj2(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(operator.iadd, id="add"),
+    pytest.param(operator.isub, id="sub"),
+    pytest.param(operator.imul, id="mul"),
+    pytest.param(operator.imatmul, id="matmul"),
+    pytest.param(operator.iand, id="tensor"),
+])
+def test_binopt_inplace(all_qevo, other_qevo, bin_op):
+    obj1 = all_qevo
+    obj2 = other_qevo
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj1.copy(), obj2)(t)
+        as_qobj = bin_op(obj1(t).copy(), obj2(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(lambda a, b: a + b, id="add"),
+    pytest.param(lambda a, b: a - b, id="sub"),
+    pytest.param(lambda a, b: a * b, id="mul"),
+    pytest.param(lambda a, b: a @ b, id="matmul"),
+    pytest.param(lambda a, b: a & b, id="tensor"),
+])
+def test_binopt_qobj(all_qevo, bin_op):
+    "QobjEvo arithmetic"
+    obj = all_qevo
+    qobj = rand_herm(N)
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj, qobj)(t)
+        as_qobj = bin_op(obj(t), qobj)
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+        as_qevo = bin_op(qobj, obj)(t)
+        as_qobj = bin_op(qobj, obj(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('bin_op', [
+    pytest.param(lambda a, b: a + b, id="add"),
+    pytest.param(lambda a, b: a - b, id="sub"),
+    pytest.param(lambda a, b: a * b, id="mul"),
+    pytest.param(_div, id="div"),
+])
+def test_binopt_scalar(all_qevo, bin_op):
+    "QobjEvo arithmetic"
+    obj = all_qevo
+    scalar = 0.5 + 1j
+    for t in TESTTIMES:
+        as_qevo = bin_op(obj, scalar)(t)
+        as_qobj = bin_op(obj(t), scalar)
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+        if bin_op is not _div:
+            as_qevo = bin_op(scalar, obj)(t)
+            as_qobj = bin_op(scalar, obj(t))
+            _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+def binop_coeff(all_qevo):
+    obj = all_qevo
+    coeff = coeffient("t")
+    created = obj * coeff_t
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(created(t), obj(t) * t)
+
+
+@pytest.mark.parametrize('unary_op', [
+    pytest.param(lambda a: a.conj(), id="conj"),
+    pytest.param(lambda a: a.dag(), id="dag"),
+    pytest.param(lambda a: a.trans(), id="trans"),
+    pytest.param(lambda a: -a, id="neg"),
+])
+def test_unary(all_qevo, unary_op):
+    "QobjEvo arithmetic"
+    obj = all_qevo
+    for t in TESTTIMES:
+        as_qevo = unary_op(obj)(t)
+        as_qobj = unary_op(obj(t))
+        _assert_qobj_almost_eq(as_qevo, as_qobj)
+
+
+@pytest.mark.parametrize('args_coeff_type',
+                         ['func_coeff', 'string', 'func_call'])
+def test_args(pseudo_qevo, args_coeff_type):
+    obj = QobjEvo(*pseudo_qevo[args_coeff_type])
+    args = {'w1': 3, "w2": 3}
+
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj(t, args), pseudo_qevo(t, args))
+        _assert_qobj_almost_eq(obj(t, **args), pseudo_qevo(t, args))
+
+    # Did it modify original args
+    _assert_qobjevo_equivalent(obj, pseudo_qevo)
+
+    obj.arguments(args)
+    _assert_qobjevo_different(obj, pseudo_qevo)
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
+
+    args = {'w1': 4, "w2": 4}
+    obj.arguments(**args)
+    _assert_qobjevo_different(obj, pseudo_qevo)
+    for t in TESTTIMES:
+        _assert_qobj_almost_eq(obj(t), pseudo_qevo(t, args))
+
+
+def test_copy_side_effects(all_qevo):
+    t = 0.2
+    qevo = all_qevo
+    copy = qevo.copy()
+    before = qevo(t)
+    # Ensure inplace modification of the copy do not affect the original
+    copy *= 2
+    copy += rand_herm(N)
+    copy *= rand_herm(N)
+    copy.arguments({'w1': 3, "w2": 3})
+    after = qevo(t)
+    _assert_qobj_almost_eq(before, after)
+
+
+@pytest.mark.parametrize('coeff_type',
+    ['func_coeff', 'string', 'array', 'logarray']
+)
+def test_tidyup(all_qevo):
+    "QobjEvo tidyup"
+    obj = all_qevo
+    obj *= 1e-12
+    obj.tidyup(atol=1e-8)
+    t = 0.2
+    # check that the Qobj are cleaned
+    assert_allclose(obj(t).full(), 0)
+
+
+def test_QobjEvo_pickle(all_qevo):
+    "QobjEvo pickle"
+    # used in parallel_map
+    import pickle
+    obj = all_qevo
+    pickled = pickle.dumps(obj, -1)
+    recreated = pickle.loads(pickled)
+    _assert_qobjevo_equivalent(recreated, obj)
+
+
+def test_QobjEvo_restore(all_qevo):
+    "QobjEvo pickle"
+    # used in parallel_map
+    obj = all_qevo
+    state = obj._getstate()
+    recreated = QobjEvo._restore(**state)
+    _assert_qobjevo_equivalent(recreated, obj)
+
+
+def test_mul_vec(all_qevo):
+    "QobjEvo matmul ket"
+    vec = Qobj(np.arange(N)*.5+.5j)
+    op = all_qevo
+    for t in TESTTIMES:
+        assert_allclose((op(t) @ vec).full(),
+                        op.matmul(t, vec).full(), atol=1e-14)
+
+
+def test_matmul(all_qevo):
+    "QobjEvo matmul oper"
+    mat = np.random.rand(N, N) + 1 + 1j * np.random.rand(N, N)
+    matDense = Qobj(mat).to(_data.Dense)
+    matF = Qobj(np.asfortranarray(mat)).to(_data.Dense)
+    matCSR = Qobj(mat).to(_data.CSR)
+    op = all_qevo
+    for t in TESTTIMES:
+        Qo1 = op(t)
+        assert_allclose((Qo1 @ mat).full(),
+                        op.matmul(t, matF).full(), atol=1e-14)
+        assert_allclose((Qo1 @ mat).full(),
+                        op.matmul(t, matDense).full(), atol=1e-14)
+        assert_allclose((Qo1 @ mat).full(),
+                        op.matmul(t, matCSR).full(), atol=1e-14)
+
+
+def test_expect_psi(all_qevo):
+    "QobjEvo expect psi"
+    vec = _data.dense.fast_from_numpy(np.arange(N)*.5 + .5j)
+    qobj = Qobj(vec)
+    op = all_qevo
+    for t in TESTTIMES:
+        Qo1 = op(t)
+        assert_allclose(_data.expect(Qo1.data, vec), op.expect(t, qobj),
+                        atol=1e-14)
+
+
+def test_expect_rho(all_qevo):
+    "QobjEvo expect rho"
+    vec = _data.dense.fast_from_numpy(np.random.rand(N*N) + 1
+                                      + 1j * np.random.rand(N*N))
+    mat = _data.column_unstack_dense(vec, N)
+    qobj = Qobj(mat)
+    op = liouvillian(all_qevo)
+    for t in TESTTIMES:
+        Qo1 = op(t)
+        assert abs(_data.expect_super(Qo1.data, vec)
+                   - op.expect(t, qobj)) < 1e-14
+
+
+@pytest.mark.parametrize('dtype',
+[pytest.param(dtype, id=dtype.__name__)
+     for dtype in _data.to.dtypes])
+def test_convert(all_qevo, dtype):
+    "QobjEvo expect rho"
+    op = all_qevo.to(dtype)
+    assert isinstance(op(0.5).data, dtype)
+
+
+def test_compress():
+    "QobjEvo compress"
+    obj1 = QobjEvo(
+        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]])
+    assert obj1.num_elements == 1
+    obj2 = QobjEvo(
+        [[qeye(N), "t"], [qeye(N), "t"], [qeye(N), "t"]], compress=False)
+    assert obj2.num_elements == 3
+    _assert_qobjevo_equivalent(obj1, obj2)
+    obj3 = obj2.copy()
+    assert obj3.num_elements == 3
+    obj3.compress()
+    assert obj3.num_elements == 1
+    _assert_qobjevo_equivalent(obj2, obj3)
+
+
+@pytest.mark.parametrize(['qobjdtype'],
+    [pytest.param(dtype, id=dtype.__name__)
+     for dtype in _data.to.dtypes])
+@pytest.mark.parametrize(['statedtype'],
+    [pytest.param(dtype, id=dtype.__name__)
+     for dtype in _data.to.dtypes])
+def test_layer_support(qobjdtype, statedtype):
+    N = 10
+    qevo = QobjEvo(rand_herm(N).to(qobjdtype))
+    state_dense = rand_ket(N).to(_data.Dense)
+    state = state_dense.to(statedtype).data
+    state_dense = state_dense.data
+    exp_any = qevo.expect_data(0, state)
+    exp_dense = qevo.expect_data(0, state_dense)
+    assert_allclose(exp_any, exp_dense)
+    mul_any = qevo.matmul_data(0, state).to_array()
+    mul_dense = qevo.matmul_data(0, state_dense).to_array()
+    assert_allclose(mul_any, mul_dense)
+
+
+def test_QobjEvo_step_coeff():
+    "QobjEvo step interpolation"
+    coeff1 = np.random.rand(6)
+    coeff2 = np.random.rand(6) + np.random.rand(6) * 1.j
+    # uniform t
+    tlist = np.array([2, 3, 4, 5, 6, 7], dtype=float)
+    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
+                      tlist=tlist, order=0)
+    assert qobjevo(2.0)[0,0] == coeff1[0]
+    assert qobjevo(7.0)[0,0] == coeff1[5]
+    assert qobjevo(5.0001)[0,0] == coeff1[3]
+    assert qobjevo(3.9999)[0,0] == coeff1[1]
+
+    assert qobjevo(2.0)[0,1] == coeff2[0]
+    assert qobjevo(7.0)[0,1] == coeff2[5]
+    assert qobjevo(5.0001)[0,1] == coeff2[3]
+    assert qobjevo(3.9999)[0,1] == coeff2[1]
+
+    # non-uniform t
+    tlist = np.array([1, 2, 4, 5, 6, 8], dtype=float)
+    qobjevo = QobjEvo([[sigmaz(), coeff1], [sigmax(), coeff2]],
+        tlist=tlist, order=0)
+    assert qobjevo(1.0)[0,0] == coeff1[0]
+    assert qobjevo(8.0)[0,0] == coeff1[5]
+    assert qobjevo(3.9999)[0,0] == coeff1[1]
+    assert qobjevo(4.23)[0,0] == coeff1[2]
+    assert qobjevo(1.23)[0,0] == coeff1[0]
+
+    assert qobjevo(1.0)[0,1] == coeff2[0]
+    assert qobjevo(8.0)[0,1] == coeff2[5]
+    assert qobjevo(6.7)[0,1] == coeff2[4]
+    assert qobjevo(7.9999)[0,1] == coeff2[4]
+    assert qobjevo(3.9999)[0,1] == coeff2[1]
+
+
+def test_QobjEvo_isherm_flag_knowcase():
+    assert QobjEvo(sigmax())(0)._isherm is True
+    non_hermitian = sigmax() + 1j
+    non_hermitian.isherm  # set flag
+    assert QobjEvo(non_hermitian)(0)._isherm is False
+    assert QobjEvo([sigmax(), sigmaz()])(0)._isherm is True
+    assert QobjEvo([sigmax(), "t"])(0)._isherm is True
+    assert QobjEvo([sigmax(), "1j"])(0)._isherm is None
+    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1"]])(0)._isherm is True
+    assert QobjEvo([[sigmax(), "t"], [sigmaz(), "1j"]])(0)._isherm is None
+
+
+@pytest.mark.parametrize(
+    "coeff_type",
+    ['func_coeff', 'string', 'array', 'logarray']
+)
+def test_QobjEvo_to_list(coeff_type, pseudo_qevo):
+    qevo = QobjEvo(*pseudo_qevo[coeff_type])
+    as_list = qevo.to_list()
+    assert len(as_list) == 2
+    restored = QobjEvo(as_list)
+    _assert_qobjevo_equivalent(qevo, restored)
diff --git a/qutip/tests/core/test_states.py b/qutip/tests/core/test_states.py
index edacd7d684..be17941dec 100644
--- a/qutip/tests/core/test_states.py
+++ b/qutip/tests/core/test_states.py
@@ -1,318 +1,318 @@
-import pytest
-import numpy as np
-import qutip
-from functools import partial
-from itertools import combinations
-
-
-@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
-def test_basis_simple(size, n):
-    qobj = qutip.basis(size, n)
-    numpy = np.zeros((size, 1), dtype=complex)
-    numpy[n, 0] = 1
-    assert np.array_equal(qobj.full(), numpy)
-
-
-@pytest.mark.parametrize("to_test", [
-    qutip.basis, qutip.fock, qutip.fock_dm,
-])
-@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
-def test_implicit_tensor_basis_like(to_test, size, n):
-    implicit = to_test(size, n)
-    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
-    assert implicit == explicit
-
-
-@pytest.mark.parametrize("size, n, offset, msg", [
-    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
-    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
-    (-1, 0, 0, "All dimensions must be >= 0."),
-    (1.5, 0, 0, "All dimensions must be >= 0."),
-    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
-    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
-], ids=["n too long", "offset too long", "neg dims",
-        "fraction dims", "n too large", "n too small"]
-)
-def test_basis_error(size, n, offset, msg):
-    with pytest.raises(ValueError) as e:
-        qutip.basis(size, n, offset)
-    assert str(e.value) == msg
-
-
-def test_basis_error_type():
-    with pytest.raises(TypeError) as e:
-        qutip.basis(5, 3.5)
-    assert str(e.value) == ("Dimensions must be an integer "
-                            "or list of integers.")
-
-
-@pytest.mark.parametrize("size, n, m", [
-        ([2, 2], [0, 0], [1, 1]),
-        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
-    ])
-def test_implicit_tensor_projection(size, n, m):
-    implicit = qutip.projection(size, n, m)
-    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
-                              for ss, nn, mm in zip(size, n, m)])
-    assert implicit == explicit
-
-
-@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
-    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
-                 id="basis"),
-    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
-                 id="basis,offset"),
-    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
-                 id="fock"),
-    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
-                 id="fock_dm"),
-    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
-                 id="fock_dm,offset"),
-    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
-                 id="coherent"),
-    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
-                 id="coherent,offset"),
-    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
-                 id="coherent_dm"),
-    pytest.param(qutip.phase_basis, qutip.phase,
-                 (10, 3), (10,), 3 * 2 * np.pi / 10,
-                 id="phase_basis"),
-    pytest.param(qutip.phase_basis, qutip.phase,
-                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
-                 id="phase_basis,phi0"),
-    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
-                 id="spin_state"),
-    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
-                 id="zero_ket"),
-])
-def test_diverse_basis(base, operator, args, opargs, eigenval):
-    # For state which are supposed to eigenvector of an operator
-    # Verify that correspondance
-    state = base(*args)
-    oper = operator(*opargs)
-    assert qutip.expect(oper, state) == pytest.approx(eigenval)
-
-
-@pytest.mark.parametrize('dm', [
-    partial(qutip.thermal_dm, n=1.),
-    qutip.maximally_mixed_dm,
-    partial(qutip.coherent_dm, alpha=0.5),
-    partial(qutip.fock_dm, n=1),
-    partial(qutip.spin_state, m=2, type='dm'),
-    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
-], ids=[
-    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
-    'fock_dm', 'spin_state', 'spin_coherent'
-])
-def test_dm(dm):
-    N = 5
-    rho = dm(N)
-    # make sure rho has trace close to 1.0
-    assert rho.tr() == pytest.approx(1.0)
-
-
-def test_CoherentState():
-    N = 10
-    alpha = 0.5
-    c1 = qutip.coherent(N, alpha)  # displacement method
-    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
-    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
-    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
-    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
-    with pytest.raises(TypeError) as e:
-        qutip.coherent(N, alpha, method="other")
-    assert all(method in str(e.value) for method in ["operator", "analytic"])
-    with pytest.raises(ValueError) as e:
-        qutip.coherent(N, alpha, offset=-1)
-    assert str(e.value) == ("Offset must be non-negative")
-    with pytest.raises(ValueError) as e:
-        qutip.coherent(N, alpha, offset=1, method="operator")
-    assert str(e.value) == (
-        "The method 'operator' does not support offset != 0. Please"
-        " select another method or set the offset to zero."
-    )
-
-
-def test_CoherentDensityMatrix():
-    N = 10
-    rho = qutip.coherent_dm(N, 1)
-    assert rho.tr() == pytest.approx(1.0)
-    with pytest.raises(TypeError) as e:
-        qutip.coherent_dm(N, 1, method="other")
-    assert all(method in str(e.value) for method in ["operator", "analytic"])
-    with pytest.raises(ValueError) as e:
-        qutip.coherent_dm(N, 1, offset=-1)
-    assert str(e.value) == ("Offset must be non-negative")
-    with pytest.raises(ValueError) as e:
-        qutip.coherent_dm(N, 1, offset=1, method="operator")
-    assert str(e.value) == (
-        "The method 'operator' does not support offset != 0. Please"
-        " select another method or set the offset to zero."
-    )
-
-
-def test_thermal():
-    N = 10
-    beta = 0.5
-    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
-
-    thermal_operator = qutip.thermal_dm(N, beta)
-    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
-    np.testing.assert_allclose(thermal_operator.full(),
-                               thermal_analytic.full(), atol=2e-5)
-
-    with pytest.raises(ValueError) as e:
-        qutip.thermal_dm(N, beta, method="other")
-    assert all(method in str(e.value) for method in ["operator", "analytic"])
-
-
-@pytest.mark.parametrize('func', [
-    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
-])
-def test_spin_output(func):
-    assert qutip.isket(func(1.0, 0, type='ket'))
-    assert qutip.isbra(func(1.0, 0, type='bra'))
-    assert qutip.isoper(func(1.0, 0, type='dm'))
-
-    with pytest.raises(ValueError) as e:
-        func(1.0, 0, type='something')
-    assert str(e.value).startswith("Invalid value keyword argument")
-
-
-@pytest.mark.parametrize('N', [2.5, -1])
-def test_maximally_mixed_dm_error(N):
-    with pytest.raises(ValueError) as e:
-        qutip.maximally_mixed_dm(N)
-    assert str(e.value) == "N must be integer N > 0"
-
-
-def test_TripletStateNorm():
-    for triplet in qutip.triplet_states():
-        assert triplet.norm() == pytest.approx(1.)
-    for t1, t2 in combinations(qutip.triplet_states(), 2):
-        assert t1.overlap(t2) == pytest.approx(0.)
-
-
-def test_ket2dm():
-    N = 5
-    ket = qutip.coherent(N, 2)
-    bra = ket.dag()
-    oper = qutip.ket2dm(ket)
-    oper_from_bra = qutip.ket2dm(bra)
-    assert qutip.expect(oper, ket) == pytest.approx(1.)
-    assert qutip.isoper(oper)
-    assert oper == ket * bra
-    assert oper == oper_from_bra
-    with pytest.raises(TypeError) as e:
-        qutip.ket2dm(oper)
-    assert str(e.value) == "Input is not a ket or bra vector."
-
-
-@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
-def test_qstate(state):
-    from_basis = qutip.basis([2] * len(state), state)
-    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
-    assert from_basis == from_qstate
-
-
-def test_qstate_error():
-    with pytest.raises(TypeError) as e:
-        qutip.qstate("eeggg")
-    assert str(e.value) == ('String input to QSTATE must consist ' +
-                            'of "u" and "d" elements only')
-
-
-@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
-def test_bra_ket(state):
-    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
-    from_ket = qutip.ket(state)
-    from_bra = qutip.bra(state).dag()
-    assert from_basis == from_ket
-    assert from_basis == from_bra
-
-
-def test_w_states():
-    state = (
-        qutip.qstate("uddd") +
-        qutip.qstate("dudd") +
-        qutip.qstate("ddud") +
-        qutip.qstate("dddu")
-    ) / 2
-    assert state == qutip.w_state(4)
-
-
-def test_ghz_states():
-    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
-    assert state == qutip.ghz_state(3)
-
-
-def test_bell_state():
-    states = [
-        qutip.bell_state('00'),
-        qutip.bell_state('01'),
-        qutip.bell_state('10'),
-        qutip.bell_state('11')
-    ]
-    exited = qutip.basis([2, 2], [1, 1])
-    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
-        assert state.norm() == pytest.approx(1.0)
-        assert state.overlap(exited) == pytest.approx(overlap)
-
-    for state1, state2 in combinations(states, 2):
-        assert state1.overlap(state2) == pytest.approx(0.0)
-
-    assert qutip.singlet_state() == qutip.bell_state('11')
-
-
-def _id_func(val):
-    "ids generated from the function only"
-    if isinstance(val, tuple):
-        return ""
-
-
-# random object accept `str` and base.Data
-# Obtain all valid dtype from `to`
-dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
-dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-@pytest.mark.parametrize(['func', 'args'], [
-    (qutip.basis, (5, 1)),
-    (qutip.fock, (5, 1)),
-    (qutip.fock_dm, (5, 1)),
-    (qutip.coherent, (5, 1)),
-    (qutip.coherent_dm, (5, 1)),
-    (qutip.thermal_dm, (5, 1)),
-    (qutip.maximally_mixed_dm, (5,)),
-    (qutip.phase_basis, (5, 1)),
-    (qutip.zero_ket, (5,)),
-    (qutip.spin_state, (5, 1)),
-    (qutip.spin_coherent, (5, 1, 0.5)),
-    (qutip.projection, (5, 1, 2)),
-    (qutip.ket, ("001",)),
-    (qutip.bra, ('010',)),
-    (qutip.qstate, ("uud",)),
-    (qutip.w_state, (5,)),
-    (qutip.ghz_state, (5,)),
-    (qutip.qutrit_basis, ()),
-    (qutip.triplet_states, ()),
-    (qutip.singlet_state, ()),
-    (qutip.bell_state, ('10',)),
-    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
-    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
-], ids=_id_func)
-def test_state_type(func, args, alias, dtype):
-    object = func(*args, dtype=alias)
-    if isinstance(object, qutip.Qobj):
-        assert isinstance(object.data, dtype)
-    else:
-        for obj in object:
-            assert isinstance(obj.data, dtype)
-
-    with qutip.CoreOptions(default_dtype=alias):
-        object = func(*args)
-        if isinstance(object, qutip.Qobj):
-            assert isinstance(object.data, dtype)
-        else:
-            for obj in object:
-                assert isinstance(obj.data, dtype)
+import pytest
+import numpy as np
+import qutip
+from functools import partial
+from itertools import combinations
+
+
+@pytest.mark.parametrize("size, n", [(2, 0), (2, 1), (100, 99)])
+def test_basis_simple(size, n):
+    qobj = qutip.basis(size, n)
+    numpy = np.zeros((size, 1), dtype=complex)
+    numpy[n, 0] = 1
+    assert np.array_equal(qobj.full(), numpy)
+
+
+@pytest.mark.parametrize("to_test", [
+    qutip.basis, qutip.fock, qutip.fock_dm,
+])
+@pytest.mark.parametrize("size, n", [([2, 2], [0, 1]), ([2, 3, 4], [1, 2, 0])])
+def test_implicit_tensor_basis_like(to_test, size, n):
+    implicit = to_test(size, n)
+    explicit = qutip.tensor(*[to_test([ss], [nn]) for ss, nn in zip(size, n)])
+    assert implicit == explicit
+
+
+@pytest.mark.parametrize("size, n, offset, msg", [
+    ([2, 2], [0, 1, 1], [0, 0], "All list inputs must be the same length."),
+    ([2, 2], [0, 1], 0, "All list inputs must be the same length."),
+    (-1, 0, 0, "All dimensions must be >= 0."),
+    (1.5, 0, 0, "All dimensions must be >= 0."),
+    (5, 5, 0, "All basis indices must be `offset <= n < dimension+offset`."),
+    (5, 0, 2, "All basis indices must be `offset <= n < dimension+offset`."),
+], ids=["n too long", "offset too long", "neg dims",
+        "fraction dims", "n too large", "n too small"]
+)
+def test_basis_error(size, n, offset, msg):
+    with pytest.raises(ValueError) as e:
+        qutip.basis(size, n, offset)
+    assert str(e.value) == msg
+
+
+def test_basis_error_type():
+    with pytest.raises(TypeError) as e:
+        qutip.basis(5, 3.5)
+    assert str(e.value) == ("Dimensions must be an integer "
+                            "or list of integers.")
+
+
+@pytest.mark.parametrize("size, n, m", [
+        ([2, 2], [0, 0], [1, 1]),
+        ([2, 3, 4], [1, 2, 0], [0, 1, 3]),
+    ])
+def test_implicit_tensor_projection(size, n, m):
+    implicit = qutip.projection(size, n, m)
+    explicit = qutip.tensor(*[qutip.projection(ss, nn, mm)
+                              for ss, nn, mm in zip(size, n, m)])
+    assert implicit == explicit
+
+
+@pytest.mark.parametrize("base, operator, args, opargs, eigenval", [
+    pytest.param(qutip.basis, qutip.num, (10, 3), (10,), 3,
+                 id="basis"),
+    pytest.param(qutip.basis, qutip.num, (10, 3, 1), (10, 1), 3,
+                 id="basis,offset"),
+    pytest.param(qutip.fock, qutip.num, (10, 3), (10,), 3,
+                 id="fock"),
+    pytest.param(qutip.fock_dm, qutip.num, (10, 3), (10,), 3,
+                 id="fock_dm"),
+    pytest.param(qutip.fock_dm, qutip.num, (10, 3, 1), (10, 1), 3,
+                 id="fock_dm,offset"),
+    pytest.param(qutip.coherent, qutip.destroy, (20, 0.75), (20,), 0.75,
+                 id="coherent"),
+    pytest.param(qutip.coherent, qutip.destroy, (50, 4.25, 1), (50, 1), 4.25,
+                 id="coherent,offset"),
+    pytest.param(qutip.coherent_dm, qutip.destroy, (25, 1.25), (25,), 1.25,
+                 id="coherent_dm"),
+    pytest.param(qutip.phase_basis, qutip.phase,
+                 (10, 3), (10,), 3 * 2 * np.pi / 10,
+                 id="phase_basis"),
+    pytest.param(qutip.phase_basis, qutip.phase,
+                 (10, 3, 1), (10, 1), 3 * 2 * np.pi / 10 + 1,
+                 id="phase_basis,phi0"),
+    pytest.param(qutip.spin_state, qutip.spin_Jz, (3, 2), (3,), 2,
+                 id="spin_state"),
+    pytest.param(qutip.zero_ket, qutip.qeye, (10,), (10,), 0,
+                 id="zero_ket"),
+])
+def test_diverse_basis(base, operator, args, opargs, eigenval):
+    # For state which are supposed to eigenvector of an operator
+    # Verify that correspondance
+    state = base(*args)
+    oper = operator(*opargs)
+    assert qutip.expect(oper, state) == pytest.approx(eigenval)
+
+
+@pytest.mark.parametrize('dm', [
+    partial(qutip.thermal_dm, n=1.),
+    qutip.maximally_mixed_dm,
+    partial(qutip.coherent_dm, alpha=0.5),
+    partial(qutip.fock_dm, n=1),
+    partial(qutip.spin_state, m=2, type='dm'),
+    partial(qutip.spin_coherent, theta=1, phi=2, type='dm'),
+], ids=[
+    'thermal_dm', 'maximally_mixed_dm', 'coherent_dm',
+    'fock_dm', 'spin_state', 'spin_coherent'
+])
+def test_dm(dm):
+    N = 5
+    rho = dm(N)
+    # make sure rho has trace close to 1.0
+    assert rho.tr() == pytest.approx(1.0)
+
+
+def test_CoherentState():
+    N = 10
+    alpha = 0.5
+    c1 = qutip.coherent(N, alpha)  # displacement method
+    c2 = qutip.coherent(7, alpha, offset=3)  # analytic method
+    c3 = qutip.coherent(N, alpha, offset=0, method="analytic")
+    np.testing.assert_allclose(c1.full()[3:], c2.full(), atol=1e-7)
+    np.testing.assert_allclose(c1.full(), c3.full(), atol=1e-7)
+    with pytest.raises(TypeError) as e:
+        qutip.coherent(N, alpha, method="other")
+    assert all(method in str(e.value) for method in ["operator", "analytic"])
+    with pytest.raises(ValueError) as e:
+        qutip.coherent(N, alpha, offset=-1)
+    assert str(e.value) == ("Offset must be non-negative")
+    with pytest.raises(ValueError) as e:
+        qutip.coherent(N, alpha, offset=1, method="operator")
+    assert str(e.value) == (
+        "The method 'operator' does not support offset != 0. Please"
+        " select another method or set the offset to zero."
+    )
+
+
+def test_CoherentDensityMatrix():
+    N = 10
+    rho = qutip.coherent_dm(N, 1)
+    assert rho.tr() == pytest.approx(1.0)
+    with pytest.raises(TypeError) as e:
+        qutip.coherent_dm(N, 1, method="other")
+    assert all(method in str(e.value) for method in ["operator", "analytic"])
+    with pytest.raises(ValueError) as e:
+        qutip.coherent_dm(N, 1, offset=-1)
+    assert str(e.value) == ("Offset must be non-negative")
+    with pytest.raises(ValueError) as e:
+        qutip.coherent_dm(N, 1, offset=1, method="operator")
+    assert str(e.value) == (
+        "The method 'operator' does not support offset != 0. Please"
+        " select another method or set the offset to zero."
+    )
+
+
+def test_thermal():
+    N = 10
+    beta = 0.5
+    assert qutip.thermal_dm(N, 0) == qutip.fock_dm(N, 0)
+
+    thermal_operator = qutip.thermal_dm(N, beta)
+    thermal_analytic = qutip.thermal_dm(N, beta, method="analytic")
+    np.testing.assert_allclose(thermal_operator.full(),
+                               thermal_analytic.full(), atol=2e-5)
+
+    with pytest.raises(ValueError) as e:
+        qutip.thermal_dm(N, beta, method="other")
+    assert all(method in str(e.value) for method in ["operator", "analytic"])
+
+
+@pytest.mark.parametrize('func', [
+    qutip.spin_state, partial(qutip.spin_coherent, phi=0.5)
+])
+def test_spin_output(func):
+    assert qutip.isket(func(1.0, 0, type='ket'))
+    assert qutip.isbra(func(1.0, 0, type='bra'))
+    assert qutip.isoper(func(1.0, 0, type='dm'))
+
+    with pytest.raises(ValueError) as e:
+        func(1.0, 0, type='something')
+    assert str(e.value).startswith("Invalid value keyword argument")
+
+
+@pytest.mark.parametrize('N', [2.5, -1])
+def test_maximally_mixed_dm_error(N):
+    with pytest.raises(ValueError) as e:
+        qutip.maximally_mixed_dm(N)
+    assert str(e.value) == "N must be integer N > 0"
+
+
+def test_TripletStateNorm():
+    for triplet in qutip.triplet_states():
+        assert triplet.norm() == pytest.approx(1.)
+    for t1, t2 in combinations(qutip.triplet_states(), 2):
+        assert t1.overlap(t2) == pytest.approx(0.)
+
+
+def test_ket2dm():
+    N = 5
+    ket = qutip.coherent(N, 2)
+    bra = ket.dag()
+    oper = qutip.ket2dm(ket)
+    oper_from_bra = qutip.ket2dm(bra)
+    assert qutip.expect(oper, ket) == pytest.approx(1.)
+    assert qutip.isoper(oper)
+    assert oper == ket * bra
+    assert oper == oper_from_bra
+    with pytest.raises(TypeError) as e:
+        qutip.ket2dm(oper)
+    assert str(e.value) == "Input is not a ket or bra vector."
+
+
+@pytest.mark.parametrize('state', [[0, 1], [0, 0], [0, 1, 0, 1]])
+def test_qstate(state):
+    from_basis = qutip.basis([2] * len(state), state)
+    from_qstate = qutip.qstate("".join({0: "d", 1: "u"}[i] for i in state))
+    assert from_basis == from_qstate
+
+
+def test_qstate_error():
+    with pytest.raises(TypeError) as e:
+        qutip.qstate("eeggg")
+    assert str(e.value) == ('String input to QSTATE must consist ' +
+                            'of "u" and "d" elements only')
+
+
+@pytest.mark.parametrize('state', ["11000", "eeggg", "dduuu", "VVHHH"])
+def test_bra_ket(state):
+    from_basis = qutip.basis([2, 2, 2, 2, 2], [1, 1, 0, 0, 0])
+    from_ket = qutip.ket(state)
+    from_bra = qutip.bra(state).dag()
+    assert from_basis == from_ket
+    assert from_basis == from_bra
+
+
+def test_w_states():
+    state = (
+        qutip.qstate("uddd") +
+        qutip.qstate("dudd") +
+        qutip.qstate("ddud") +
+        qutip.qstate("dddu")
+    ) / 2
+    assert state == qutip.w_state(4)
+
+
+def test_ghz_states():
+    state = (qutip.qstate("uuu") + qutip.qstate("ddd")).unit()
+    assert state == qutip.ghz_state(3)
+
+
+def test_bell_state():
+    states = [
+        qutip.bell_state('00'),
+        qutip.bell_state('01'),
+        qutip.bell_state('10'),
+        qutip.bell_state('11')
+    ]
+    exited = qutip.basis([2, 2], [1, 1])
+    for state, overlap in zip(states, [0.5**0.5, -0.5**0.5, 0, 0]):
+        assert state.norm() == pytest.approx(1.0)
+        assert state.overlap(exited) == pytest.approx(overlap)
+
+    for state1, state2 in combinations(states, 2):
+        assert state1.overlap(state2) == pytest.approx(0.0)
+
+    assert qutip.singlet_state() == qutip.bell_state('11')
+
+
+def _id_func(val):
+    "ids generated from the function only"
+    if isinstance(val, tuple):
+        return ""
+
+
+# random object accept `str` and base.Data
+# Obtain all valid dtype from `to`
+dtype_names = list(qutip.data.to._str2type.keys()) + list(qutip.data.to.dtypes)
+dtype_types = list(qutip.data.to._str2type.values()) + list(qutip.data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize(['func', 'args'], [
+    (qutip.basis, (5, 1)),
+    (qutip.fock, (5, 1)),
+    (qutip.fock_dm, (5, 1)),
+    (qutip.coherent, (5, 1)),
+    (qutip.coherent_dm, (5, 1)),
+    (qutip.thermal_dm, (5, 1)),
+    (qutip.maximally_mixed_dm, (5,)),
+    (qutip.phase_basis, (5, 1)),
+    (qutip.zero_ket, (5,)),
+    (qutip.spin_state, (5, 1)),
+    (qutip.spin_coherent, (5, 1, 0.5)),
+    (qutip.projection, (5, 1, 2)),
+    (qutip.ket, ("001",)),
+    (qutip.bra, ('010',)),
+    (qutip.qstate, ("uud",)),
+    (qutip.w_state, (5,)),
+    (qutip.ghz_state, (5,)),
+    (qutip.qutrit_basis, ()),
+    (qutip.triplet_states, ()),
+    (qutip.singlet_state, ()),
+    (qutip.bell_state, ('10',)),
+    (qutip.enr_fock, ([3, 3, 3], 4, [1, 1, 0])),
+    (qutip.enr_thermal_dm, ([3, 3, 3], 4, 2)),
+], ids=_id_func)
+def test_state_type(func, args, alias, dtype):
+    object = func(*args, dtype=alias)
+    if isinstance(object, qutip.Qobj):
+        assert isinstance(object.data, dtype)
+    else:
+        for obj in object:
+            assert isinstance(obj.data, dtype)
+
+    with qutip.CoreOptions(default_dtype=alias):
+        object = func(*args)
+        if isinstance(object, qutip.Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
diff --git a/qutip/tests/core/test_superop_reps.py b/qutip/tests/core/test_superop_reps.py
index 7e04579c3b..31c538d118 100644
--- a/qutip/tests/core/test_superop_reps.py
+++ b/qutip/tests/core/test_superop_reps.py
@@ -1,347 +1,347 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Wed May 29 11:23:46 2013
-
-@author: dcriger
-"""
-
-from __future__ import division
-
-import numpy as np
-import pytest
-
-from qutip import (
-    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
-    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
-    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
-    vector_to_operator, sprepost, destroy
-)
-from qutip.core.gates import swap
-
-
-tol = 1e-8
-
-
-def assert_kraus_equivalence(a, b, tol=tol):
-    assert a.shape == b.shape
-    assert a.dims == b.dims
-    assert a.type == b.type
-    # Kraus operators may vary by a global phase.  Let's find the first
-    # non-zero element, set the phase such that that element has the same phase
-    # in both, and then compare.  We have to take care to find the first
-    # element.
-    a, b = a.full(), b.full()
-    a_nz = np.nonzero(np.abs(a) > tol)
-    if len(a_nz[0]) == 0:
-        np.testing.assert_allclose(b, 0, atol=tol)
-    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
-    assert b_el != 0
-    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
-    np.testing.assert_allclose(a, b)
-
-
-@pytest.fixture(scope="function", params=[2, 3, 7])
-def dimension(request):
-    # There are also some cases in the file where this fixture is explicitly
-    # overridden by a more local mark.  That is deliberate.
-    return request.param
-
-
-@pytest.fixture(scope="function", params=[
-    pytest.param(rand_super, id="super"),
-    pytest.param(rand_super_bcsz, id="super_bcz")
-])
-def superoperator(request, dimension):
-    return request.param(dimension)
-
-
-class TestSuperopReps:
-    """
-    A test class for the QuTiP function for applying superoperators to
-    subsystems.
-    """
-
-    def test_SuperChoiSuper(self, superoperator):
-        """
-        Superoperator: Converting superoperator to Choi matrix and back.
-        """
-        choi_matrix = to_choi(superoperator)
-        test_supe = to_super(choi_matrix)
-
-        # Assert both that the result is close to expected, and has the right
-        # type.
-        assert (test_supe - superoperator).norm() < tol
-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-        assert test_supe.type == "super" and test_supe.superrep == "super"
-
-    @pytest.mark.parametrize('dimension', [2, 4])
-    def test_SuperChoiChiSuper(self, dimension):
-        """
-        Superoperator: Converting two-qubit superoperator through
-        Choi and chi representations goes back to right superoperator.
-        """
-        superoperator = super_tensor(
-            rand_super(dimension), rand_super(dimension),
-        )
-
-        choi_matrix = to_choi(superoperator)
-        chi_matrix = to_chi(choi_matrix)
-        test_supe = to_super(chi_matrix)
-
-        # Assert both that the result is close to expected, and has the right
-        # type.
-        assert (test_supe - superoperator).norm() < tol
-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
-        assert test_supe.type == "super" and test_supe.superrep == "super"
-
-    def test_ChoiKrausChoi(self, superoperator):
-        """
-        Superoperator: Convert superoperator to Choi matrix and back.
-        """
-        choi_matrix = to_choi(superoperator)
-        kraus_ops = to_kraus(choi_matrix)
-        test_choi = kraus_to_choi(kraus_ops)
-
-        # Assert both that the result is close to expected, and has the right
-        # type.
-        assert (test_choi - choi_matrix).norm() < tol
-        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
-        assert test_choi.type == "super" and test_choi.superrep == "choi"
-
-    def test_NonSquareKrausSuperChoi(self):
-        """
-        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
-        and back.
-        """
-        zero = np.array([[1], [0]], dtype=complex)
-        one = np.array([[0], [1]], dtype=complex)
-        zero_log = np.kron(np.kron(zero, zero), zero)
-        one_log = np.kron(np.kron(one, one), one)
-        # non-square Kraus operator (isometry)
-        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
-        super = sprepost(kraus, kraus.dag())
-        choi = to_choi(super)
-        op1 = to_kraus(super)
-        op2 = to_kraus(choi)
-        op3 = to_super(choi)
-        assert choi.type == "super" and choi.superrep == "choi"
-        assert super.type == "super" and super.superrep == "super"
-        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
-        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
-        assert abs((op3 - super).norm()) < 1e-8
-
-    def test_NeglectSmallKraus(self):
-        """
-        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
-        Kraus operators.
-        """
-        zero = np.array([[1], [0]], dtype=complex)
-        one = np.array([[0], [1]], dtype=complex)
-        zero_log = np.kron(np.kron(zero, zero), zero)
-        one_log = np.kron(np.kron(one, one), one)
-        # non-square Kraus operator (isometry)
-        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
-        super = sprepost(kraus, kraus.dag())
-        # 1 non-zero Kraus operator the rest are zero
-        sixteen_kraus_ops = to_kraus(super, tol=0.0)
-        # default is tol=1e-9
-        one_kraus_op = to_kraus(super)
-        assert len(sixteen_kraus_ops) == 16
-        assert len(one_kraus_op) == 1
-        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
-
-    def test_SuperPreservesSelf(self, superoperator):
-        """
-        Superoperator: to_super(q) returns q if q is already a
-        supermatrix.
-        """
-
-        assert superoperator is to_super(superoperator)
-
-    def test_ChoiPreservesSelf(self, superoperator):
-        """
-        Superoperator: to_choi(q) returns q if q is already Choi.
-        """
-        choi = to_choi(superoperator)
-        assert choi is to_choi(choi)
-
-    def test_random_iscptp(self, superoperator):
-        """
-        Superoperator: Randomly generated superoperators are
-        correctly reported as CPTP and HP.
-        """
-        assert superoperator.iscptp
-        assert superoperator.ishp
-
-    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
-        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
-        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
-        pytest.param(qeye(2), True, True, True),
-        pytest.param(sigmax(), True, True, True),
-        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
-        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
-                            + to_super(tensor(qeye(2), sigmay()))),
-                     True, True, True,
-                     id="linear combination of bipartite unitaries"),
-        pytest.param(Qobj(swap(), type='super', superrep='choi'),
-                     True, False, True,
-                     id="partial transpose map"),
-        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
-                     id="subnormalized map"),
-        pytest.param(basis(2, 0), False, False, False, id="ket"),
-    ])
-    def test_known_iscptp(self, qobj, hp, cp, tp):
-        """
-        Superoperator: ishp, iscp, istp and iscptp known cases.
-        """
-        assert qobj.ishp == hp
-        assert qobj.iscp == cp
-        assert qobj.istp == tp
-        assert qobj.iscptp == (cp and tp)
-
-    def test_choi_tr(self):
-        """
-        Superoperator: Trace returned by to_choi matches docstring.
-        """
-        for dims in range(2, 5):
-            assert abs(to_choi(identity(dims)).tr() - dims) < tol
-
-
-    # Conjugation by a creation operator
-    a = create(2).dag()
-    S = sprepost(a, a.dag())
-
-    # A single off-diagonal element
-    S_ = sprepost(a, a)
-
-    # Check that a linear combination of bipartite unitaries is CPTP and HP.
-    S_U = (
-        to_super(tensor(sigmax(), identity(2))) +
-        to_super(tensor(identity(2), sigmay()))
-    ) / 2
-
-    # The partial transpose map, whose Choi matrix is SWAP
-    ptr_swap = Qobj(swap(), type='super', superrep='choi')
-
-    # Subnormalized maps (representing erasure channels, for instance)
-    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
-
-    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
-        pytest.param(S, True, True, False, id="conjugatio by create op"),
-        pytest.param(S_, False, False, False, id="single off-diag"),
-        pytest.param(identity(2), True, True, True, id="Identity"),
-        pytest.param(sigmax(), True, True, True, id="Pauli X"),
-        pytest.param(
-            tensor(sigmax(), identity(2)), True, True, True,
-            id="bipartite system",
-        ),
-        pytest.param(
-            S_U, True, True, True, id="linear combination of bip. unitaries",
-        ),
-        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
-        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
-        pytest.param(basis(2), False, False, False, id="not an operator"),
-
-    ])
-    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
-        """
-        Superoperator: ishp, iscp, istp and iscptp known cases.
-        """
-        assert qobj.ishp == shouldhp
-        assert qobj.iscp == shouldcp
-        assert qobj.istp == shouldtp
-        assert qobj.iscptp == (shouldcp and shouldtp)
-
-    def test_choi_tr(self, dimension):
-        """
-        Superoperator: Trace returned by to_choi matches docstring.
-        """
-        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
-
-    def test_stinespring_cp(self, dimension):
-        """
-        Stinespring: A and B match for CP maps.
-        """
-        superop = rand_super_bcsz(dimension)
-        A, B = to_stinespring(superop)
-
-        assert (A - B).norm() < tol
-
-    @pytest.mark.repeat(3)
-    def test_stinespring_agrees(self, dimension):
-        """
-        Stinespring: Partial Tr over pair agrees w/ supermatrix.
-        """
-
-        map = rand_super_bcsz(dimension)
-        state = rand_dm(dimension)
-
-        S = to_super(map)
-        A, B = to_stinespring(map)
-
-        q1 = vector_to_operator(
-            S * operator_to_vector(state)
-        )
-        # FIXME: problem if Kraus index is implicitly
-        #        ptraced!
-        q2 = (A * state * B.dag()).ptrace((0,))
-
-        assert (q1 - q2).norm('tr') <= tol
-
-    def test_stinespring_dims(self, dimension):
-        """
-        Stinespring: Check that dims of channels are preserved.
-        """
-        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
-        A, B = to_stinespring(chan)
-        assert A.dims == [[2, dimension, 1], [2, dimension]]
-        assert B.dims == [[2, dimension, 1], [2, dimension]]
-
-    @pytest.mark.parametrize('dimension', [2, 4, 8])
-    def test_chi_choi_roundtrip(self, dimension):
-
-        superop = rand_super_bcsz(dimension)
-        superop = to_chi(superop)
-        rt_superop = to_chi(to_choi(superop))
-        dif = (rt_superop - superop).norm()
-
-        assert dif == pytest.approx(0, abs=1e-7)
-        assert rt_superop.type == superop.type
-        assert rt_superop.dims == superop.dims
-
-    chi_sigmax = [
-        [0, 0, 0, 0],
-        [0, 4, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0]
-    ]
-    chi_diag2 = [
-        [4, 0, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0]
-    ]
-    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
-    chi_rotX_pi_4 = [
-        [2, 2j, 0, 0],
-        [-2j, 2, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0]
-    ]
-
-    @pytest.mark.parametrize(['superop', 'chi_expected'], [
-        pytest.param(sigmax(), chi_sigmax),
-        pytest.param(to_super(sigmax()), chi_sigmax),
-        pytest.param(qeye(2), chi_diag2),
-        pytest.param(rotX_pi_4, chi_rotX_pi_4)
-    ])
-    def test_chi_known(self, superop, chi_expected):
-        """
-        Superoperator: Chi-matrix for known cases is correct.
-        """
-        chi_actual = to_chi(superop)
-        chiq = Qobj(
-            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
-        )
-        assert (chi_actual - chiq).norm() < tol
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 29 11:23:46 2013
+
+@author: dcriger
+"""
+
+from __future__ import division
+
+import numpy as np
+import pytest
+
+from qutip import (
+    Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
+    rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
+    to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
+    vector_to_operator, sprepost, destroy
+)
+from qutip.core.gates import swap
+
+
+tol = 1e-8
+
+
+def assert_kraus_equivalence(a, b, tol=tol):
+    assert a.shape == b.shape
+    assert a.dims == b.dims
+    assert a.type == b.type
+    # Kraus operators may vary by a global phase.  Let's find the first
+    # non-zero element, set the phase such that that element has the same phase
+    # in both, and then compare.  We have to take care to find the first
+    # element.
+    a, b = a.full(), b.full()
+    a_nz = np.nonzero(np.abs(a) > tol)
+    if len(a_nz[0]) == 0:
+        np.testing.assert_allclose(b, 0, atol=tol)
+    a_el, b_el = a[a_nz[0][0], a_nz[1][0]], b[a_nz[0][0], a_nz[1][0]]
+    assert b_el != 0
+    b *= (a_el / np.abs(a_el)) / (b_el / np.abs(b_el))
+    np.testing.assert_allclose(a, b)
+
+
+@pytest.fixture(scope="function", params=[2, 3, 7])
+def dimension(request):
+    # There are also some cases in the file where this fixture is explicitly
+    # overridden by a more local mark.  That is deliberate.
+    return request.param
+
+
+@pytest.fixture(scope="function", params=[
+    pytest.param(rand_super, id="super"),
+    pytest.param(rand_super_bcsz, id="super_bcz")
+])
+def superoperator(request, dimension):
+    return request.param(dimension)
+
+
+class TestSuperopReps:
+    """
+    A test class for the QuTiP function for applying superoperators to
+    subsystems.
+    """
+
+    def test_SuperChoiSuper(self, superoperator):
+        """
+        Superoperator: Converting superoperator to Choi matrix and back.
+        """
+        choi_matrix = to_choi(superoperator)
+        test_supe = to_super(choi_matrix)
+
+        # Assert both that the result is close to expected, and has the right
+        # type.
+        assert (test_supe - superoperator).norm() < tol
+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+        assert test_supe.type == "super" and test_supe.superrep == "super"
+
+    @pytest.mark.parametrize('dimension', [2, 4])
+    def test_SuperChoiChiSuper(self, dimension):
+        """
+        Superoperator: Converting two-qubit superoperator through
+        Choi and chi representations goes back to right superoperator.
+        """
+        superoperator = super_tensor(
+            rand_super(dimension), rand_super(dimension),
+        )
+
+        choi_matrix = to_choi(superoperator)
+        chi_matrix = to_chi(choi_matrix)
+        test_supe = to_super(chi_matrix)
+
+        # Assert both that the result is close to expected, and has the right
+        # type.
+        assert (test_supe - superoperator).norm() < tol
+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+        assert chi_matrix.type == "super" and chi_matrix.superrep == "chi"
+        assert test_supe.type == "super" and test_supe.superrep == "super"
+
+    def test_ChoiKrausChoi(self, superoperator):
+        """
+        Superoperator: Convert superoperator to Choi matrix and back.
+        """
+        choi_matrix = to_choi(superoperator)
+        kraus_ops = to_kraus(choi_matrix)
+        test_choi = kraus_to_choi(kraus_ops)
+
+        # Assert both that the result is close to expected, and has the right
+        # type.
+        assert (test_choi - choi_matrix).norm() < tol
+        assert choi_matrix.type == "super" and choi_matrix.superrep == "choi"
+        assert test_choi.type == "super" and test_choi.superrep == "choi"
+
+    def test_NonSquareKrausSuperChoi(self):
+        """
+        Superoperator: Convert non-square Kraus operator to Super + Choi matrix
+        and back.
+        """
+        zero = np.array([[1], [0]], dtype=complex)
+        one = np.array([[0], [1]], dtype=complex)
+        zero_log = np.kron(np.kron(zero, zero), zero)
+        one_log = np.kron(np.kron(one, one), one)
+        # non-square Kraus operator (isometry)
+        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
+        super = sprepost(kraus, kraus.dag())
+        choi = to_choi(super)
+        op1 = to_kraus(super)
+        op2 = to_kraus(choi)
+        op3 = to_super(choi)
+        assert choi.type == "super" and choi.superrep == "choi"
+        assert super.type == "super" and super.superrep == "super"
+        assert_kraus_equivalence(op1[0], kraus, tol=1e-8)
+        assert_kraus_equivalence(op2[0], kraus, tol=1e-8)
+        assert abs((op3 - super).norm()) < 1e-8
+
+    def test_NeglectSmallKraus(self):
+        """
+        Superoperator: Convert Kraus to Choi matrix and back. Neglect tiny
+        Kraus operators.
+        """
+        zero = np.array([[1], [0]], dtype=complex)
+        one = np.array([[0], [1]], dtype=complex)
+        zero_log = np.kron(np.kron(zero, zero), zero)
+        one_log = np.kron(np.kron(one, one), one)
+        # non-square Kraus operator (isometry)
+        kraus = Qobj(zero_log @ zero.T + one_log @ one.T)
+        super = sprepost(kraus, kraus.dag())
+        # 1 non-zero Kraus operator the rest are zero
+        sixteen_kraus_ops = to_kraus(super, tol=0.0)
+        # default is tol=1e-9
+        one_kraus_op = to_kraus(super)
+        assert len(sixteen_kraus_ops) == 16
+        assert len(one_kraus_op) == 1
+        assert_kraus_equivalence(one_kraus_op[0], kraus, tol=tol)
+
+    def test_SuperPreservesSelf(self, superoperator):
+        """
+        Superoperator: to_super(q) returns q if q is already a
+        supermatrix.
+        """
+
+        assert superoperator is to_super(superoperator)
+
+    def test_ChoiPreservesSelf(self, superoperator):
+        """
+        Superoperator: to_choi(q) returns q if q is already Choi.
+        """
+        choi = to_choi(superoperator)
+        assert choi is to_choi(choi)
+
+    def test_random_iscptp(self, superoperator):
+        """
+        Superoperator: Randomly generated superoperators are
+        correctly reported as CPTP and HP.
+        """
+        assert superoperator.iscptp
+        assert superoperator.ishp
+
+    @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
+        pytest.param(sprepost(destroy(2), create(2)), True, True, False),
+        pytest.param(sprepost(destroy(2), destroy(2)), False, False, False),
+        pytest.param(qeye(2), True, True, True),
+        pytest.param(sigmax(), True, True, True),
+        pytest.param(tensor(sigmax(), qeye(2)), True, True, True),
+        pytest.param(0.5 * (to_super(tensor(sigmax(), qeye(2)))
+                            + to_super(tensor(qeye(2), sigmay()))),
+                     True, True, True,
+                     id="linear combination of bipartite unitaries"),
+        pytest.param(Qobj(swap(), type='super', superrep='choi'),
+                     True, False, True,
+                     id="partial transpose map"),
+        pytest.param(Qobj(qeye(4)*0.9, type='super'), True, True, False,
+                     id="subnormalized map"),
+        pytest.param(basis(2, 0), False, False, False, id="ket"),
+    ])
+    def test_known_iscptp(self, qobj, hp, cp, tp):
+        """
+        Superoperator: ishp, iscp, istp and iscptp known cases.
+        """
+        assert qobj.ishp == hp
+        assert qobj.iscp == cp
+        assert qobj.istp == tp
+        assert qobj.iscptp == (cp and tp)
+
+    def test_choi_tr(self):
+        """
+        Superoperator: Trace returned by to_choi matches docstring.
+        """
+        for dims in range(2, 5):
+            assert abs(to_choi(identity(dims)).tr() - dims) < tol
+
+
+    # Conjugation by a creation operator
+    a = create(2).dag()
+    S = sprepost(a, a.dag())
+
+    # A single off-diagonal element
+    S_ = sprepost(a, a)
+
+    # Check that a linear combination of bipartite unitaries is CPTP and HP.
+    S_U = (
+        to_super(tensor(sigmax(), identity(2))) +
+        to_super(tensor(identity(2), sigmay()))
+    ) / 2
+
+    # The partial transpose map, whose Choi matrix is SWAP
+    ptr_swap = Qobj(swap(), type='super', superrep='choi')
+
+    # Subnormalized maps (representing erasure channels, for instance)
+    subnorm_map = Qobj(identity(4) * 0.9, type='super', superrep='super')
+
+    @pytest.mark.parametrize(['qobj',  'shouldhp', 'shouldcp', 'shouldtp'], [
+        pytest.param(S, True, True, False, id="conjugatio by create op"),
+        pytest.param(S_, False, False, False, id="single off-diag"),
+        pytest.param(identity(2), True, True, True, id="Identity"),
+        pytest.param(sigmax(), True, True, True, id="Pauli X"),
+        pytest.param(
+            tensor(sigmax(), identity(2)), True, True, True,
+            id="bipartite system",
+        ),
+        pytest.param(
+            S_U, True, True, True, id="linear combination of bip. unitaries",
+        ),
+        pytest.param(ptr_swap,  True, False, True, id="partial transpose map"),
+        pytest.param(subnorm_map, True, True, False, id="subnorm map"),
+        pytest.param(basis(2), False, False, False, id="not an operator"),
+
+    ])
+    def test_known_iscptp(self, qobj, shouldhp, shouldcp, shouldtp):
+        """
+        Superoperator: ishp, iscp, istp and iscptp known cases.
+        """
+        assert qobj.ishp == shouldhp
+        assert qobj.iscp == shouldcp
+        assert qobj.istp == shouldtp
+        assert qobj.iscptp == (shouldcp and shouldtp)
+
+    def test_choi_tr(self, dimension):
+        """
+        Superoperator: Trace returned by to_choi matches docstring.
+        """
+        assert abs(to_choi(identity(dimension)).tr() - dimension) <= tol
+
+    def test_stinespring_cp(self, dimension):
+        """
+        Stinespring: A and B match for CP maps.
+        """
+        superop = rand_super_bcsz(dimension)
+        A, B = to_stinespring(superop)
+
+        assert (A - B).norm() < tol
+
+    @pytest.mark.repeat(3)
+    def test_stinespring_agrees(self, dimension):
+        """
+        Stinespring: Partial Tr over pair agrees w/ supermatrix.
+        """
+
+        map = rand_super_bcsz(dimension)
+        state = rand_dm(dimension)
+
+        S = to_super(map)
+        A, B = to_stinespring(map)
+
+        q1 = vector_to_operator(
+            S * operator_to_vector(state)
+        )
+        # FIXME: problem if Kraus index is implicitly
+        #        ptraced!
+        q2 = (A * state * B.dag()).ptrace((0,))
+
+        assert (q1 - q2).norm('tr') <= tol
+
+    def test_stinespring_dims(self, dimension):
+        """
+        Stinespring: Check that dims of channels are preserved.
+        """
+        chan = super_tensor(to_super(sigmax()), to_super(qeye(dimension)))
+        A, B = to_stinespring(chan)
+        assert A.dims == [[2, dimension, 1], [2, dimension]]
+        assert B.dims == [[2, dimension, 1], [2, dimension]]
+
+    @pytest.mark.parametrize('dimension', [2, 4, 8])
+    def test_chi_choi_roundtrip(self, dimension):
+
+        superop = rand_super_bcsz(dimension)
+        superop = to_chi(superop)
+        rt_superop = to_chi(to_choi(superop))
+        dif = (rt_superop - superop).norm()
+
+        assert dif == pytest.approx(0, abs=1e-7)
+        assert rt_superop.type == superop.type
+        assert rt_superop.dims == superop.dims
+
+    chi_sigmax = [
+        [0, 0, 0, 0],
+        [0, 4, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]
+    ]
+    chi_diag2 = [
+        [4, 0, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]
+    ]
+    rotX_pi_4 = (-1j * sigmax() * np.pi / 4).expm()
+    chi_rotX_pi_4 = [
+        [2, 2j, 0, 0],
+        [-2j, 2, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]
+    ]
+
+    @pytest.mark.parametrize(['superop', 'chi_expected'], [
+        pytest.param(sigmax(), chi_sigmax),
+        pytest.param(to_super(sigmax()), chi_sigmax),
+        pytest.param(qeye(2), chi_diag2),
+        pytest.param(rotX_pi_4, chi_rotX_pi_4)
+    ])
+    def test_chi_known(self, superop, chi_expected):
+        """
+        Superoperator: Chi-matrix for known cases is correct.
+        """
+        chi_actual = to_chi(superop)
+        chiq = Qobj(
+            chi_expected, dims=[[[2], [2]], [[2], [2]]], superrep='chi',
+        )
+        assert (chi_actual - chiq).norm() < tol
diff --git a/qutip/tests/core/test_superoper.py b/qutip/tests/core/test_superoper.py
index bbeeb68257..b5ba6fd105 100644
--- a/qutip/tests/core/test_superoper.py
+++ b/qutip/tests/core/test_superoper.py
@@ -1,269 +1,269 @@
-import numpy as np
-import scipy.linalg
-
-import qutip
-from qutip.core import data as _data
-import pytest
-
-
-def f(t, args):
-    return t * (1 - 0.5j)
-
-
-def liouvillian_ref(H, c_ops=()):
-    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
-    for c in c_ops:
-        if c.issuper:
-            L += c
-        else:
-            cdc = c.dag() * c
-            L += qutip.sprepost(c, c.dag())
-            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
-    return L
-
-
-class TestMatVec:
-    """
-    A test class for the QuTiP function for matrix/vector conversion.
-    """
-    def testOperatorVector(self):
-        """
-        Superoperator: Operator - vector - operator conversion.
-        """
-        N = 3
-        rho1 = qutip.rand_dm(N)
-        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testsuperrep(self):
-        N = 3
-        rho1 = qutip.rand_dm(N)
-        as_vec = qutip.operator_to_vector(rho1)
-        assert as_vec.superrep == 'super'
-
-        with pytest.raises(TypeError) as err:
-            bad_vec = as_vec.copy()
-            bad_vec.superrep = ""
-            qutip.vector_to_operator(bad_vec)
-        assert err.value.args[0] == ("only defined for operator-kets "
-                                     "in super format")
-
-        with pytest.raises(TypeError) as err:
-            qutip.operator_to_vector(as_vec)
-        assert err.value.args[0] == ("Cannot convert object already "
-                                     "in super representation")
-
-    def testOperatorVectorTensor(self):
-        """
-        Superoperator: Operator - vector - operator conversion with a tensor
-        product state.
-        """
-        Na = 3
-        Nb = 2
-        rhoa = qutip.rand_dm(Na)
-        rhob = qutip.rand_dm(Nb)
-        rho1 = qutip.tensor(rhoa, rhob)
-        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testOperatorVectorNotSquare(self):
-        """
-        Superoperator: Operator - vector - operator conversion for non-square
-        matrix.
-        """
-        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
-        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
-        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
-
-    def testOperatorSpreAppl(self):
-        """
-        Superoperator: apply operator and superoperator from left (spre)
-        """
-        N = 3
-        rho = qutip.rand_dm(N)
-        U = qutip.rand_unitary(N)
-        rho1 = U * rho
-        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
-        rho2 = qutip.vector_to_operator(rho2_vec)
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testOperatorSpostAppl(self):
-        """
-        Superoperator: apply operator and superoperator from right (spost)
-        """
-        N = 3
-        rho = qutip.rand_dm(N)
-        U = qutip.rand_unitary(N)
-        rho1 = rho * U
-        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
-        rho2 = qutip.vector_to_operator(rho2_vec)
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testOperatorUnitaryTransform(self):
-        """
-        Superoperator: Unitary transformation with operators and superoperators
-        """
-        N = 3
-        rho = qutip.rand_dm(N)
-        U = qutip.rand_unitary(N)
-        rho1 = U * rho * U.dag()
-        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
-        rho2 = qutip.vector_to_operator(rho2_vec)
-        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
-
-    def testMatrixVecMat(self):
-        """
-        Superoperator: Conversion matrix to vector to matrix
-        """
-        M = _data.create(np.random.rand(10, 10))
-        V = qutip.stack_columns(M)
-        M2 = qutip.unstack_columns(V)
-        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
-
-    def testVecMatVec(self):
-        """
-        Superoperator: Conversion vector to matrix to vector
-        """
-        V = _data.create(np.random.rand(100, 1))
-        M = qutip.unstack_columns(V)
-        V2 = qutip.stack_columns(M)
-        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
-
-    def testVecMatIndexConversion(self):
-        """
-        Superoperator: Conversion between matrix and vector indices
-        """
-        N = 10
-        for i in range(N * N):
-            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
-
-    def testVecMatIndexCompability(self):
-        """
-        Superoperator: Compatibility between matrix/vector and
-        corresponding index conversions.
-        """
-        N = 10
-        M = _data.create(np.random.rand(N, N))
-        V = qutip.stack_columns(M)
-        for idx in range(N * N):
-            i, j = qutip.unstacked_index(N, idx)
-            assert V.to_array()[idx, 0] == M.to_array()[i, j]
-
-    def test_reshuffle(self):
-        U1 = qutip.rand_unitary(2)
-        U2 = qutip.rand_unitary(3)
-        U3 = qutip.rand_unitary(4)
-        U = qutip.tensor(U1, U2, U3)
-        S = qutip.to_super(U)
-        S_col = qutip.reshuffle(S)
-        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
-        assert qutip.reshuffle(S_col) == S
-
-    def test_sprepost(self):
-        U1 = qutip.rand_unitary(3)
-        U2 = qutip.rand_unitary(3)
-        S1 = qutip.spre(U1) * qutip.spost(U2)
-        S2 = qutip.sprepost(U1, U2)
-        assert S1 == S2
-
-    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
-    @pytest.mark.parametrize("operation", [qutip.spre,
-                                           qutip.spost,
-                                           qutip.liouvillian,
-                                           qutip.lindblad_dissipator])
-    def test_operation_dtype(self, dtype, operation):
-        """This test checks that the dtype is properly kept with the
-        `operation` function."""
-        U1 = qutip.rand_unitary(3).to(dtype)
-        result = operation(U1)
-        assert type(result.data) == dtype
-
-    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
-    def test_sprepost_dtype(self, dtype):
-        """This test checks that the dtype is properly kept with `sprepost`
-        function."""
-        U1 = qutip.rand_unitary(3).to(dtype)
-        result = qutip.sprepost(U1, U1)
-        assert type(result.data) == dtype
-
-    def testLiouvillianImplem(self):
-        """
-        Superoperator: Randomized comparison of standard and reference
-        Liouvillian functions.
-        """
-        N1, N2, N3 = 3, 4, 5
-        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
-                          qutip.qeye([N2, N3]))
-        a2 = qutip.tensor(qutip.qeye(N1),
-                          qutip.rand_dm(N2, density=0.75),
-                          qutip.qeye(N3))
-        a3 = qutip.tensor(qutip.qeye([N1, N2]),
-                          qutip.rand_dm(N3, density=0.75))
-        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
-        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
-        L1 = qutip.liouvillian(H, c_ops)
-        L2 = liouvillian_ref(H, c_ops)
-        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
-
-
-class TestSuper_td:
-    """
-    A test class for the QuTiP superoperator functions.
-    """
-    N = 3
-    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
-                        [qutip.create(N) * (1 - 0.1j), f]])
-    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
-    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
-    q1 = qutip.qeye(N) * (1 + 0.3j)
-    q2 = qutip.destroy(N) * (1 - 0.3j)
-    q3 = qutip.num(N) * (1 + 0.4j)
-
-    def test_spre_td(self):
-        "Superoperator: spre, time-dependent"
-        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
-
-    def test_spost_td(self):
-        "Superoperator: spre, time-dependent"
-        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
-
-    def test_sprepost_td(self):
-        "Superoperator: sprepost, time-dependent"
-        # left QobjEvo
-        assert (qutip.sprepost(self.t1, self.q2)(0.5)
-                == qutip.sprepost(self.t1(0.5), self.q2))
-        # left QobjEvo
-        assert (qutip.sprepost(self.q2, self.t1)(0.5)
-                == qutip.sprepost(self.q2, self.t1(0.5)))
-        # left 2 QobjEvo, one cte
-        assert (qutip.sprepost(self.t1, self.t2)(0.5)
-                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
-
-    def test_operator_vector_td(self):
-        "Superoperator: operator_to_vector, time-dependent"
-        assert (qutip.operator_to_vector(self.t1)(0.5)
-                == qutip.operator_to_vector(self.t1(0.5)))
-        vec = qutip.operator_to_vector(self.t1)
-        assert (qutip.vector_to_operator(vec)(0.5)
-                == qutip.vector_to_operator(vec(0.5)))
-
-    def test_liouvillian_td(self):
-        "Superoperator: liouvillian, time-dependent"
-        assert (qutip.liouvillian(self.t1)(0.5)
-                == qutip.liouvillian(self.t1(0.5)))
-        assert (qutip.liouvillian(None, [self.t2])(0.5)
-                == qutip.liouvillian(None, [self.t2(0.5)]))
-        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
-                                  chi=[1, 2, 3])(0.5)
-                == qutip.liouvillian(self.t1(0.5),
-                                     [self.t2(0.5), self.q1, self.t3(0.5)],
-                                     chi=[1, 2, 3]))
-
-    def test_lindblad_dissipator_td(self):
-        "Superoperator: lindblad_dissipator, time-dependent"
-        assert (qutip.lindblad_dissipator(self.t2)(0.5)
-                == qutip.lindblad_dissipator(self.t2(0.5)))
-        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
-                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
-        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
-                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
+import numpy as np
+import scipy.linalg
+
+import qutip
+from qutip.core import data as _data
+import pytest
+
+
+def f(t, args):
+    return t * (1 - 0.5j)
+
+
+def liouvillian_ref(H, c_ops=()):
+    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0
+    for c in c_ops:
+        if c.issuper:
+            L += c
+        else:
+            cdc = c.dag() * c
+            L += qutip.sprepost(c, c.dag())
+            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))
+    return L
+
+
+class TestMatVec:
+    """
+    A test class for the QuTiP function for matrix/vector conversion.
+    """
+    def testOperatorVector(self):
+        """
+        Superoperator: Operator - vector - operator conversion.
+        """
+        N = 3
+        rho1 = qutip.rand_dm(N)
+        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testsuperrep(self):
+        N = 3
+        rho1 = qutip.rand_dm(N)
+        as_vec = qutip.operator_to_vector(rho1)
+        assert as_vec.superrep == 'super'
+
+        with pytest.raises(TypeError) as err:
+            bad_vec = as_vec.copy()
+            bad_vec.superrep = ""
+            qutip.vector_to_operator(bad_vec)
+        assert err.value.args[0] == ("only defined for operator-kets "
+                                     "in super format")
+
+        with pytest.raises(TypeError) as err:
+            qutip.operator_to_vector(as_vec)
+        assert err.value.args[0] == ("Cannot convert object already "
+                                     "in super representation")
+
+    def testOperatorVectorTensor(self):
+        """
+        Superoperator: Operator - vector - operator conversion with a tensor
+        product state.
+        """
+        Na = 3
+        Nb = 2
+        rhoa = qutip.rand_dm(Na)
+        rhob = qutip.rand_dm(Nb)
+        rho1 = qutip.tensor(rhoa, rhob)
+        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testOperatorVectorNotSquare(self):
+        """
+        Superoperator: Operator - vector - operator conversion for non-square
+        matrix.
+        """
+        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))
+        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))
+        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)
+
+    def testOperatorSpreAppl(self):
+        """
+        Superoperator: apply operator and superoperator from left (spre)
+        """
+        N = 3
+        rho = qutip.rand_dm(N)
+        U = qutip.rand_unitary(N)
+        rho1 = U * rho
+        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)
+        rho2 = qutip.vector_to_operator(rho2_vec)
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testOperatorSpostAppl(self):
+        """
+        Superoperator: apply operator and superoperator from right (spost)
+        """
+        N = 3
+        rho = qutip.rand_dm(N)
+        U = qutip.rand_unitary(N)
+        rho1 = rho * U
+        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)
+        rho2 = qutip.vector_to_operator(rho2_vec)
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testOperatorUnitaryTransform(self):
+        """
+        Superoperator: Unitary transformation with operators and superoperators
+        """
+        N = 3
+        rho = qutip.rand_dm(N)
+        U = qutip.rand_unitary(N)
+        rho1 = U * rho * U.dag()
+        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)
+        rho2 = qutip.vector_to_operator(rho2_vec)
+        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)
+
+    def testMatrixVecMat(self):
+        """
+        Superoperator: Conversion matrix to vector to matrix
+        """
+        M = _data.create(np.random.rand(10, 10))
+        V = qutip.stack_columns(M)
+        M2 = qutip.unstack_columns(V)
+        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)
+
+    def testVecMatVec(self):
+        """
+        Superoperator: Conversion vector to matrix to vector
+        """
+        V = _data.create(np.random.rand(100, 1))
+        M = qutip.unstack_columns(V)
+        V2 = qutip.stack_columns(M)
+        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)
+
+    def testVecMatIndexConversion(self):
+        """
+        Superoperator: Conversion between matrix and vector indices
+        """
+        N = 10
+        for i in range(N * N):
+            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))
+
+    def testVecMatIndexCompability(self):
+        """
+        Superoperator: Compatibility between matrix/vector and
+        corresponding index conversions.
+        """
+        N = 10
+        M = _data.create(np.random.rand(N, N))
+        V = qutip.stack_columns(M)
+        for idx in range(N * N):
+            i, j = qutip.unstacked_index(N, idx)
+            assert V.to_array()[idx, 0] == M.to_array()[i, j]
+
+    def test_reshuffle(self):
+        U1 = qutip.rand_unitary(2)
+        U2 = qutip.rand_unitary(3)
+        U3 = qutip.rand_unitary(4)
+        U = qutip.tensor(U1, U2, U3)
+        S = qutip.to_super(U)
+        S_col = qutip.reshuffle(S)
+        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]
+        assert qutip.reshuffle(S_col) == S
+
+    def test_sprepost(self):
+        U1 = qutip.rand_unitary(3)
+        U2 = qutip.rand_unitary(3)
+        S1 = qutip.spre(U1) * qutip.spost(U2)
+        S2 = qutip.sprepost(U1, U2)
+        assert S1 == S2
+
+    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
+    @pytest.mark.parametrize("operation", [qutip.spre,
+                                           qutip.spost,
+                                           qutip.liouvillian,
+                                           qutip.lindblad_dissipator])
+    def test_operation_dtype(self, dtype, operation):
+        """This test checks that the dtype is properly kept with the
+        `operation` function."""
+        U1 = qutip.rand_unitary(3).to(dtype)
+        result = operation(U1)
+        assert type(result.data) == dtype
+
+    @pytest.mark.parametrize("dtype", [_data.CSR, _data.Dense])
+    def test_sprepost_dtype(self, dtype):
+        """This test checks that the dtype is properly kept with `sprepost`
+        function."""
+        U1 = qutip.rand_unitary(3).to(dtype)
+        result = qutip.sprepost(U1, U1)
+        assert type(result.data) == dtype
+
+    def testLiouvillianImplem(self):
+        """
+        Superoperator: Randomized comparison of standard and reference
+        Liouvillian functions.
+        """
+        N1, N2, N3 = 3, 4, 5
+        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),
+                          qutip.qeye([N2, N3]))
+        a2 = qutip.tensor(qutip.qeye(N1),
+                          qutip.rand_dm(N2, density=0.75),
+                          qutip.qeye(N3))
+        a3 = qutip.tensor(qutip.qeye([N1, N2]),
+                          qutip.rand_dm(N3, density=0.75))
+        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3
+        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]
+        L1 = qutip.liouvillian(H, c_ops)
+        L2 = liouvillian_ref(H, c_ops)
+        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)
+
+
+class TestSuper_td:
+    """
+    A test class for the QuTiP superoperator functions.
+    """
+    N = 3
+    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),
+                        [qutip.create(N) * (1 - 0.1j), f]])
+    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])
+    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])
+    q1 = qutip.qeye(N) * (1 + 0.3j)
+    q2 = qutip.destroy(N) * (1 - 0.3j)
+    q3 = qutip.num(N) * (1 + 0.4j)
+
+    def test_spre_td(self):
+        "Superoperator: spre, time-dependent"
+        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))
+
+    def test_spost_td(self):
+        "Superoperator: spre, time-dependent"
+        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))
+
+    def test_sprepost_td(self):
+        "Superoperator: sprepost, time-dependent"
+        # left QobjEvo
+        assert (qutip.sprepost(self.t1, self.q2)(0.5)
+                == qutip.sprepost(self.t1(0.5), self.q2))
+        # left QobjEvo
+        assert (qutip.sprepost(self.q2, self.t1)(0.5)
+                == qutip.sprepost(self.q2, self.t1(0.5)))
+        # left 2 QobjEvo, one cte
+        assert (qutip.sprepost(self.t1, self.t2)(0.5)
+                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))
+
+    def test_operator_vector_td(self):
+        "Superoperator: operator_to_vector, time-dependent"
+        assert (qutip.operator_to_vector(self.t1)(0.5)
+                == qutip.operator_to_vector(self.t1(0.5)))
+        vec = qutip.operator_to_vector(self.t1)
+        assert (qutip.vector_to_operator(vec)(0.5)
+                == qutip.vector_to_operator(vec(0.5)))
+
+    def test_liouvillian_td(self):
+        "Superoperator: liouvillian, time-dependent"
+        assert (qutip.liouvillian(self.t1)(0.5)
+                == qutip.liouvillian(self.t1(0.5)))
+        assert (qutip.liouvillian(None, [self.t2])(0.5)
+                == qutip.liouvillian(None, [self.t2(0.5)]))
+        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],
+                                  chi=[1, 2, 3])(0.5)
+                == qutip.liouvillian(self.t1(0.5),
+                                     [self.t2(0.5), self.q1, self.t3(0.5)],
+                                     chi=[1, 2, 3]))
+
+    def test_lindblad_dissipator_td(self):
+        "Superoperator: lindblad_dissipator, time-dependent"
+        assert (qutip.lindblad_dissipator(self.t2)(0.5)
+                == qutip.lindblad_dissipator(self.t2(0.5)))
+        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)
+                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))
+        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)
+                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))
diff --git a/qutip/tests/core/test_tensor.py b/qutip/tests/core/test_tensor.py
index 41ba5672ea..10e493e46f 100644
--- a/qutip/tests/core/test_tensor.py
+++ b/qutip/tests/core/test_tensor.py
@@ -1,257 +1,257 @@
-import numpy as np
-
-from numpy.testing import assert_equal, assert_
-import pytest
-import functools
-import itertools
-import qutip
-from qutip import (
-    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
-    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
-    expand_operator
-)
-
-
-def test_tensor_contract_ident():
-    qobj = identity([2, 3, 4])
-    ans = 3 * identity([2, 4])
-
-    assert_(ans == tensor_contract(qobj, (1, 4)))
-
-    # Now try for superoperators.
-    # For now, we just ensure the dims are correct.
-    sqobj = to_super(qobj)
-    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
-    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
-
-
-def case_tensor_contract_other(left, right, pairs,
-                               expected_dims, expected_data):
-    dat = np.arange(np.prod(left) * np.prod(right))
-    dat = dat.reshape((np.prod(left), np.prod(right)))
-
-    qobj = Qobj(dat, dims=[left, right])
-    cqobj = tensor_contract(qobj, *pairs)
-    assert_equal(cqobj.dims, expected_dims)
-    assert_equal(cqobj.full(), expected_data)
-
-
-def test_tensor_contract_other():
-    case_tensor_contract_other(
-        [2, 3], [3, 4], [(1, 2)],
-        [[2], [4]],
-        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
-    )
-
-    case_tensor_contract_other(
-        [2, 3], [4, 3], [(1, 3)],
-        [[2], [4]],
-        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
-    )
-
-    case_tensor_contract_other(
-        [2, 3], [4, 3], [(1, 3)],
-        [[2], [4]],
-        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
-    )
-
-    # Make non-rectangular outputs in a column-/row-symmetric fashion.
-    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
-
-    case_tensor_contract_other(
-        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
-        [[[3], [3]], [[2, 3], [2, 3]]],
-        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
-
-    case_tensor_contract_other(
-        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
-        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
-        # We separate einsum into two calls due to a bug internal to
-        # einsum.
-        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
-
-    # Now we try collapsing in a way that's sensitive to column- and row-
-    # stacking conventions.
-    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
-    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
-    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
-    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
-
-    # Let's try a weird tensor contraction; this will likely never come up in
-    # practice, but it should serve as a good canary for more reasonable
-    # contractions.
-    case_tensor_contract_other(
-        big_dims[0], big_dims[1], [(0, 4)],
-        [[[2], [3, 3]], [[3], [2, 3]]],
-        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
-
-
-def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
-    sqobj = tensor_swap(qobj, *pairs)
-
-    assert_equal(sqobj.dims, expected_dims)
-    assert_equal(sqobj.full(), expected_data.full())
-
-
-def test_tensor_swap_other():
-    dims = (2, 3, 4, 5, 7)
-    for dim in dims:
-        S = to_super(rand_super_bcsz(dim))
-        # Swapping the inner indices on a superoperator should give a Choi
-        # matrix.
-        J = to_choi(S)
-        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
-
-
-def test_tensor_qobjevo():
-    N = 5
-    t = 1.5
-    left = QobjEvo([num(N),[destroy(N),"t"]])
-    right = QobjEvo([identity(2),[sigmax(),"t"]])
-    assert tensor(left, right)(t) == tensor(left(t), right(t))
-    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
-    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
-
-
-def test_tensor_qobjevo_non_square():
-    N = 5
-    t = 1.5
-    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
-    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
-    assert tensor(left, right)(t) == tensor(left(t), right(t))
-
-
-def test_tensor_qobjevo_multiple():
-    N = 5
-    t = 1.5
-    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
-    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
-    right = QobjEvo([sigmax()])
-    as_QobjEvo = tensor(left, center, right)(t)
-    as_Qobj = tensor(left(t), center(t), right(t))
-    assert as_QobjEvo == as_Qobj
-
-
-def test_tensor_and():
-    N = 5
-    t = 1.5
-    sx = sigmax()
-    evo = QobjEvo([num(N),[destroy(N),"t"]])
-    assert tensor([sx, sx, sx]) == sx & sx & sx
-    assert tensor(evo, sx)(t) == (evo & sx)(t)
-    assert tensor(sx, evo)(t) == (sx & evo)(t)
-    assert tensor(evo, evo)(t) == (evo & evo)(t)
-
-
-def _permutation_id(permutation):
-    return str(len(permutation)) + "-" + "".join(map(str, permutation))
-
-
-def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
-    """
-    Create a full tensor product when a subspace component is already in an
-    entangled state.  The locations in `all_qubits` which are the entangled
-    points in the output are ignored and can take any value.
-
-    For example,
-        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
-    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
-    in the final output are entangled, but the others are still separable.
-
-    Parameters:
-        all_qubits: list of kets --
-            A list of separable parts to tensor together.  States that are in
-            the locations referred to by `entangled_locations` are completely
-            ignored.
-        entangled: tensor-product ket -- the full entangled subspace
-        entangled_locations: list of int --
-            The locations that the qubits in the entangled subspace should be
-            in in the final tensor-product space.
-    """
-    n_entangled = len(entangled.dims[0])
-    n_separable = len(all_qubits) - n_entangled
-    separable = all_qubits.copy()
-    # Remove in reverse order so subsequent deletion locations don't change.
-    for location in sorted(entangled_locations, reverse=True):
-        del separable[location]
-    # Can't separate out entangled states to pass to tensor in the right places
-    # immediately, so tensor in at one end and then permute into place.
-    out = qutip.tensor(*separable, entangled)
-    permutation = list(range(n_separable))
-    current_locations = range(n_separable, n_separable + n_entangled)
-    # Sort to prevert later insertions changing previous locations.
-    insertions = sorted(zip(entangled_locations, current_locations),
-                        key=lambda x: x[0])
-    for out_location, current_location in insertions:
-        permutation.insert(out_location, current_location)
-    return out.permute(permutation)
-
-
-def _apply_permutation(permutation):
-    """
-    Permute the given permutation into the order denoted by its elements, i.e.
-        out[0] = permutation[permutation[0]]
-        out[1] = permutation[permutation[1]]
-        ...
-
-    This function is its own inverse.
-    """
-    out = [None] * len(permutation)
-    for value, location in enumerate(permutation):
-        out[location] = value
-    return out
-
-
-class Test_expand_operator:
-    @pytest.mark.parametrize(
-        'permutation',
-        tuple(itertools.chain(*[
-            itertools.permutations(range(k)) for k in [2, 3, 4]
-        ])),
-        ids=_permutation_id)
-    def test_permutation_without_expansion(self, permutation):
-        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
-        test = expand_operator(base, [2] * len(permutation), permutation)
-        expected = base.permute(_apply_permutation(permutation))
-        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
-
-    @pytest.mark.parametrize('n_targets', range(1, 5))
-    def test_general_qubit_expansion(self, n_targets):
-        # Test all permutations with the given number of targets.
-        n_qubits = 5
-        operation = qutip.rand_unitary([2]*n_targets)
-        for targets in itertools.permutations(range(n_qubits), n_targets):
-            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
-                                                 operation, targets)
-            test = expand_operator(operation, [2] * 5, targets)
-            np.testing.assert_allclose(test.full(), expected.full(),
-                                       atol=1e-15)
-
-    def test_cnot_explicit(self):
-        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
-        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
-                             [0, 0, 0, 0, 0, 1, 0, 0],
-                             [0, 0, 1, 0, 0, 0, 0, 0],
-                             [0, 0, 0, 0, 0, 0, 0, 1],
-                             [0, 0, 0, 0, 1, 0, 0, 0],
-                             [0, 1, 0, 0, 0, 0, 0, 0],
-                             [0, 0, 0, 0, 0, 0, 1, 0],
-                             [0, 0, 0, 1, 0, 0, 0, 0]])
-        np.testing.assert_allclose(test, expected, atol=1e-15)
-
-    @pytest.mark.parametrize('dimensions', [
-        pytest.param([3, 4, 5], id="standard"),
-        pytest.param([3, 3, 4, 4, 2], id="standard"),
-        pytest.param([1, 2, 3], id="1D space"),
-    ])
-    def test_non_qubit_systems(self, dimensions):
-        n_qubits = len(dimensions)
-        for targets in itertools.permutations(range(n_qubits), 2):
-            operators = [qutip.rand_unitary(dimension) if n in targets
-                         else qutip.qeye(dimension)
-                         for n, dimension in enumerate(dimensions)]
-            expected = qutip.tensor(*operators)
-            base_test = qutip.tensor(*[operators[x] for x in targets])
-            test = expand_operator(base_test, dims=dimensions, targets=targets)
-            assert test.dims == expected.dims
-            np.testing.assert_allclose(test.full(), expected.full())
+import numpy as np
+
+from numpy.testing import assert_equal, assert_
+import pytest
+import functools
+import itertools
+import qutip
+from qutip import (
+    Qobj, identity, sigmax, to_super, to_choi, rand_super_bcsz, basis,
+    tensor_contract, tensor_swap, num, QobjEvo, destroy, tensor,
+    expand_operator
+)
+
+
+def test_tensor_contract_ident():
+    qobj = identity([2, 3, 4])
+    ans = 3 * identity([2, 4])
+
+    assert_(ans == tensor_contract(qobj, (1, 4)))
+
+    # Now try for superoperators.
+    # For now, we just ensure the dims are correct.
+    sqobj = to_super(qobj)
+    correct_dims = [[[2, 4], [2, 4]], [[2, 4], [2, 4]]]
+    assert_equal(correct_dims, tensor_contract(sqobj, (1, 4), (7, 10)).dims)
+
+
+def case_tensor_contract_other(left, right, pairs,
+                               expected_dims, expected_data):
+    dat = np.arange(np.prod(left) * np.prod(right))
+    dat = dat.reshape((np.prod(left), np.prod(right)))
+
+    qobj = Qobj(dat, dims=[left, right])
+    cqobj = tensor_contract(qobj, *pairs)
+    assert_equal(cqobj.dims, expected_dims)
+    assert_equal(cqobj.full(), expected_data)
+
+
+def test_tensor_contract_other():
+    case_tensor_contract_other(
+        [2, 3], [3, 4], [(1, 2)],
+        [[2], [4]],
+        np.einsum('abbc', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 3, 4)))
+    )
+
+    case_tensor_contract_other(
+        [2, 3], [4, 3], [(1, 3)],
+        [[2], [4]],
+        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
+    )
+
+    case_tensor_contract_other(
+        [2, 3], [4, 3], [(1, 3)],
+        [[2], [4]],
+        np.einsum('abcb', np.arange(2 * 3 * 3 * 4).reshape((2, 3, 4, 3)))
+    )
+
+    # Make non-rectangular outputs in a column-/row-symmetric fashion.
+    big_dat = np.arange(2 * 3 * 2 * 3 * 2 * 3 * 2 * 3).reshape((2, 3) * 4)
+
+    case_tensor_contract_other(
+        [[2, 3], [2, 3]], [[2, 3], [2, 3]], [(0, 2)],
+        [[[3], [3]], [[2, 3], [2, 3]]],
+        np.einsum('ibidwxyz', big_dat).reshape((3 * 3, 3 * 2 * 3 * 2)))
+
+    case_tensor_contract_other(
+        [[2, 3], [2, 3]], [[2, 3], [2, 3]],
+        [(0, 2), (5, 7)], [[[3], [3]], [[2], [2]]],
+        # We separate einsum into two calls due to a bug internal to
+        # einsum.
+        np.einsum('ibidwy', np.einsum('abcdwjyj', big_dat)).reshape(3*3, 2*2))
+
+    # Now we try collapsing in a way that's sensitive to column- and row-
+    # stacking conventions.
+    big_dat = np.arange(2 * 2 * 3 * 3 * 2 * 3 * 2 * 3)
+    big_dat = big_dat.reshape((3, 3, 2, 2, 2, 3, 2, 3))
+    # Note that the order of [2, 2] and [3, 3] is swapped on the left!
+    big_dims = [[[2, 2], [3, 3]], [[2, 3], [2, 3]]]
+
+    # Let's try a weird tensor contraction; this will likely never come up in
+    # practice, but it should serve as a good canary for more reasonable
+    # contractions.
+    case_tensor_contract_other(
+        big_dims[0], big_dims[1], [(0, 4)],
+        [[[2], [3, 3]], [[3], [2, 3]]],
+        np.einsum('abidwxiz', big_dat).reshape((2 * 3 * 3, 3 * 2 * 3)))
+
+
+def case_tensor_swap(qobj, pairs, expected_dims, expected_data=None):
+    sqobj = tensor_swap(qobj, *pairs)
+
+    assert_equal(sqobj.dims, expected_dims)
+    assert_equal(sqobj.full(), expected_data.full())
+
+
+def test_tensor_swap_other():
+    dims = (2, 3, 4, 5, 7)
+    for dim in dims:
+        S = to_super(rand_super_bcsz(dim))
+        # Swapping the inner indices on a superoperator should give a Choi
+        # matrix.
+        J = to_choi(S)
+        case_tensor_swap(S, [(1, 2)], [[[dim], [dim]], [[dim], [dim]]], J)
+
+
+def test_tensor_qobjevo():
+    N = 5
+    t = 1.5
+    left = QobjEvo([num(N),[destroy(N),"t"]])
+    right = QobjEvo([identity(2),[sigmax(),"t"]])
+    assert tensor(left, right)(t) == tensor(left(t), right(t))
+    assert tensor(left, sigmax())(t) == tensor(left(t), sigmax())
+    assert tensor(num(N), right)(t) == tensor(num(N), right(t))
+
+
+def test_tensor_qobjevo_non_square():
+    N = 5
+    t = 1.5
+    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
+    right = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
+    assert tensor(left, right)(t) == tensor(left(t), right(t))
+
+
+def test_tensor_qobjevo_multiple():
+    N = 5
+    t = 1.5
+    left = QobjEvo([basis(N, 0), [basis(N, 1), "t"]])
+    center = QobjEvo([basis(2, 0).dag(), [basis(2, 1).dag(), "t"]])
+    right = QobjEvo([sigmax()])
+    as_QobjEvo = tensor(left, center, right)(t)
+    as_Qobj = tensor(left(t), center(t), right(t))
+    assert as_QobjEvo == as_Qobj
+
+
+def test_tensor_and():
+    N = 5
+    t = 1.5
+    sx = sigmax()
+    evo = QobjEvo([num(N),[destroy(N),"t"]])
+    assert tensor([sx, sx, sx]) == sx & sx & sx
+    assert tensor(evo, sx)(t) == (evo & sx)(t)
+    assert tensor(sx, evo)(t) == (sx & evo)(t)
+    assert tensor(evo, evo)(t) == (evo & evo)(t)
+
+
+def _permutation_id(permutation):
+    return str(len(permutation)) + "-" + "".join(map(str, permutation))
+
+
+def _tensor_with_entanglement(all_qubits, entangled, entangled_locations):
+    """
+    Create a full tensor product when a subspace component is already in an
+    entangled state.  The locations in `all_qubits` which are the entangled
+    points in the output are ignored and can take any value.
+
+    For example,
+        _tensor_with_entanglement([|a>, |b>, |c>, |d>], (|00> + |11>), [0, 2])
+    should product a tensor product like (|0b0d> + |1b1d>), i.e. qubits 0 and 2
+    in the final output are entangled, but the others are still separable.
+
+    Parameters:
+        all_qubits: list of kets --
+            A list of separable parts to tensor together.  States that are in
+            the locations referred to by `entangled_locations` are completely
+            ignored.
+        entangled: tensor-product ket -- the full entangled subspace
+        entangled_locations: list of int --
+            The locations that the qubits in the entangled subspace should be
+            in in the final tensor-product space.
+    """
+    n_entangled = len(entangled.dims[0])
+    n_separable = len(all_qubits) - n_entangled
+    separable = all_qubits.copy()
+    # Remove in reverse order so subsequent deletion locations don't change.
+    for location in sorted(entangled_locations, reverse=True):
+        del separable[location]
+    # Can't separate out entangled states to pass to tensor in the right places
+    # immediately, so tensor in at one end and then permute into place.
+    out = qutip.tensor(*separable, entangled)
+    permutation = list(range(n_separable))
+    current_locations = range(n_separable, n_separable + n_entangled)
+    # Sort to prevert later insertions changing previous locations.
+    insertions = sorted(zip(entangled_locations, current_locations),
+                        key=lambda x: x[0])
+    for out_location, current_location in insertions:
+        permutation.insert(out_location, current_location)
+    return out.permute(permutation)
+
+
+def _apply_permutation(permutation):
+    """
+    Permute the given permutation into the order denoted by its elements, i.e.
+        out[0] = permutation[permutation[0]]
+        out[1] = permutation[permutation[1]]
+        ...
+
+    This function is its own inverse.
+    """
+    out = [None] * len(permutation)
+    for value, location in enumerate(permutation):
+        out[location] = value
+    return out
+
+
+class Test_expand_operator:
+    @pytest.mark.parametrize(
+        'permutation',
+        tuple(itertools.chain(*[
+            itertools.permutations(range(k)) for k in [2, 3, 4]
+        ])),
+        ids=_permutation_id)
+    def test_permutation_without_expansion(self, permutation):
+        base = qutip.tensor([qutip.rand_unitary(2) for _ in permutation])
+        test = expand_operator(base, [2] * len(permutation), permutation)
+        expected = base.permute(_apply_permutation(permutation))
+        np.testing.assert_allclose(test.full(), expected.full(), atol=1e-15)
+
+    @pytest.mark.parametrize('n_targets', range(1, 5))
+    def test_general_qubit_expansion(self, n_targets):
+        # Test all permutations with the given number of targets.
+        n_qubits = 5
+        operation = qutip.rand_unitary([2]*n_targets)
+        for targets in itertools.permutations(range(n_qubits), n_targets):
+            expected = _tensor_with_entanglement([qutip.qeye(2)] * n_qubits,
+                                                 operation, targets)
+            test = expand_operator(operation, [2] * 5, targets)
+            np.testing.assert_allclose(test.full(), expected.full(),
+                                       atol=1e-15)
+
+    def test_cnot_explicit(self):
+        test = expand_operator(qutip.gates.cnot(), [2]*3, [2, 0]).full()
+        expected = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
+                             [0, 0, 0, 0, 0, 1, 0, 0],
+                             [0, 0, 1, 0, 0, 0, 0, 0],
+                             [0, 0, 0, 0, 0, 0, 0, 1],
+                             [0, 0, 0, 0, 1, 0, 0, 0],
+                             [0, 1, 0, 0, 0, 0, 0, 0],
+                             [0, 0, 0, 0, 0, 0, 1, 0],
+                             [0, 0, 0, 1, 0, 0, 0, 0]])
+        np.testing.assert_allclose(test, expected, atol=1e-15)
+
+    @pytest.mark.parametrize('dimensions', [
+        pytest.param([3, 4, 5], id="standard"),
+        pytest.param([3, 3, 4, 4, 2], id="standard"),
+        pytest.param([1, 2, 3], id="1D space"),
+    ])
+    def test_non_qubit_systems(self, dimensions):
+        n_qubits = len(dimensions)
+        for targets in itertools.permutations(range(n_qubits), 2):
+            operators = [qutip.rand_unitary(dimension) if n in targets
+                         else qutip.qeye(dimension)
+                         for n, dimension in enumerate(dimensions)]
+            expected = qutip.tensor(*operators)
+            base_test = qutip.tensor(*[operators[x] for x in targets])
+            test = expand_operator(base_test, dims=dimensions, targets=targets)
+            assert test.dims == expected.dims
+            np.testing.assert_allclose(test.full(), expected.full())
diff --git a/qutip/tests/pytest.ini b/qutip/tests/pytest.ini
index 97561c1575..02ffbe592c 100644
--- a/qutip/tests/pytest.ini
+++ b/qutip/tests/pytest.ini
@@ -1,5 +1,5 @@
-[pytest]
-markers =
-    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
-    repeat(n): Repeat the given test 'n' times.
-    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
+[pytest]
+markers =
+    slow: Mark a test as taking a long time to run, and so can be skipped with `pytest -m "not slow"`.
+    repeat(n): Repeat the given test 'n' times.
+    requires_cython: Mark that the given test requires Cython to be installed.  Such tests will be skipped if Cython is not available.
diff --git a/qutip/tests/solve/test_piqs.py b/qutip/tests/solve/test_piqs.py
index 293cd586e6..a069a2905b 100644
--- a/qutip/tests/solve/test_piqs.py
+++ b/qutip/tests/solve/test_piqs.py
@@ -1,1536 +1,1536 @@
-"""
-Tests for Permutational Invariant Quantum solver (PIQS).
-"""
-import numpy as np
-from numpy.testing import (
-    assert_,
-    run_module_suite,
-    assert_raises,
-    assert_array_equal,
-    assert_array_almost_equal,
-    assert_almost_equal,
-    assert_equal,
-)
-from scipy.sparse import block_diag
-from qutip import Qobj, entropy_vn, sigmax, sigmaz
-from qutip.solve._piqs import (
-    get_blocks,
-    j_min,
-    j_vals,
-    m_vals,
-    _num_dicke_states,
-    _num_dicke_ladders,
-    get_index,
-    jmm1_dictionary,
-)
-from qutip.solve._piqs import Dicke as _Dicke
-from qutip.solve.piqs import *
-
-import sys
-import unittest
-
-
-# Disable tests for python2 as qutip.piqs does not support python2.
-if sys.version_info[0] < 3:
-    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
-
-
-class TestDicke:
-    """
-    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
-    """
-
-    def test_num_dicke_states(self):
-        """
-        PIQS: Test the `num_dicke_state` function.
-        """
-        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
-        dicke_states = [num_dicke_states(i) for i in N_list]
-        assert_array_equal(
-            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
-        )
-        N = -1
-        assert_raises(ValueError, num_dicke_states, N)
-        N = 0.2
-        assert_raises(ValueError, num_dicke_states, N)
-
-    def test_num_tls(self):
-        """
-        PIQS: Test the `num_two_level` function.
-        """
-        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
-        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
-        calculated_N = [num_tls(i) for i in N_dicke]
-        assert_array_equal(calculated_N, N)
-
-    def test_num_dicke_ladders(self):
-        """
-        PIQS: Test the `_num_dicke_ladders` function.
-        """
-        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
-        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
-        assert_array_equal(ndl, ndl_true)
-
-    def test_get_blocks(self):
-        """
-        PIQS: Test the function to get blocks.
-        """
-        N_list = [1, 2, 5, 7]
-        blocks = [
-            np.array([2]),
-            np.array([3, 4]),
-            np.array([6, 10, 12]),
-            np.array([8, 14, 18, 20]),
-        ]
-        calculated_blocks = [get_blocks(i) for i in N_list]
-        for (i, j) in zip(calculated_blocks, blocks):
-            assert_array_equal(i, j)
-
-    def test_j_vals(self):
-        """
-        PIQS: Test calculation of j values for given N.
-        """
-        N_list = [1, 2, 3, 4, 7]
-        j_vals_real = [
-            np.array([0.5]),
-            np.array([0.0, 1.0]),
-            np.array([0.5, 1.5]),
-            np.array([0.0, 1.0, 2.0]),
-            np.array([0.5, 1.5, 2.5, 3.5]),
-        ]
-        j_vals_calc = [j_vals(i) for i in N_list]
-
-        for (i, j) in zip(j_vals_calc, j_vals_real):
-            assert_array_equal(i, j)
-
-    def test_m_vals(self):
-        """
-        PIQS: Test calculation of m values for a particular j.
-        """
-        j_list = [0.5, 1, 1.5, 2, 2.5]
-        m_real = [
-            np.array([-0.5, 0.5]),
-            np.array([-1, 0, 1]),
-            np.array([-1.5, -0.5, 0.5, 1.5]),
-            np.array([-2, -1, 0, 1, 2]),
-            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
-        ]
-
-        m_calc = [m_vals(i) for i in j_list]
-        for (i, j) in zip(m_real, m_calc):
-            assert_array_equal(i, j)
-
-    def test_dicke_blocks(self):
-        """
-        PIQS: Test the `dicke_blocks` function.
-        """
-        # test 1
-        # mixed state with non-symmetrical block matrix elements
-        N = 3
-        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        test_blocks = dicke_blocks(true_matrix)
-        test_matrix = Qobj(block_diag(test_blocks))
-        assert_(test_matrix == true_matrix)
-        # test 2
-        # all elements in block-diagonal matrix
-        N = 4
-        true_matrix = Qobj(block_matrix(N)).unit()
-        test_blocks = dicke_blocks(true_matrix)
-        test_matrix = Qobj(block_diag(test_blocks))
-        assert_(test_matrix == true_matrix)
-
-    def test_dicke_blocks_full(self):
-        """
-        PIQS: Test the `dicke_blocks_full` function.
-        """
-        N = 3
-        test_blocks = dicke_blocks_full(excited(3))
-        test_matrix = Qobj(block_diag(test_blocks))
-        true_expanded = np.zeros((8, 8))
-        true_expanded[0, 0] = 1.0
-        assert_(test_matrix == Qobj(true_expanded))
-
-    def test_dicke_function_trace(self):
-        """
-        PIQS: Test the `dicke_function_trace` function.
-        """
-        ## test for N odd
-        N = 3
-        # test trace
-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        f = lambda x: x
-        test_val = dicke_function_trace(f, rho_mixed)
-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
-        true_val2 = (rho_mixed).tr()
-        # test with linear function (trace)
-        assert_almost_equal(test_val, true_val)
-        assert_almost_equal(test_val, true_val2)
-        # test with nonlinear function
-        f = lambda rho: rho ** 3
-        test_val3 = dicke_function_trace(f, rho_mixed)
-        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
-        assert_almost_equal(test_val3, true_val3)
-        ## test for N even
-        N = 4
-        # test trace
-        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
-        f = lambda x: x
-        test_val = dicke_function_trace(f, rho_mixed)
-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
-        true_val2 = (rho_mixed).tr()
-        # test with linear function (trace)
-        assert_almost_equal(test_val, true_val)
-        assert_almost_equal(test_val, true_val2)
-        # test with nonlinear function
-        f = lambda rho: rho ** 3
-        test_val3 = dicke_function_trace(f, rho_mixed)
-        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
-        assert np.allclose(test_val3, true_val3)
-
-    def test_entropy_vn_dicke(self):
-        """
-        PIQS: Test the `entropy_vn_dicke` function.
-        """
-        N = 3
-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        test_val = entropy_vn_dicke(rho_mixed)
-        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
-        assert np.allclose(test_val, true_val)
-
-    def test_purity_dicke(self):
-        """
-        PIQS: Test the `purity_dicke` function.
-        """
-        N = 3
-        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
-        test_val = purity_dicke(rho_mixed)
-        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
-        assert np.allclose(test_val, true_val)
-
-    def test_get_index(self):
-        """
-        PIQS: Test the index fetching function for given j, m, m1 value.
-        """
-        N = 1
-        jmm1_list = [
-            (0.5, 0.5, 0.5),
-            (0.5, 0.5, -0.5),
-            (0.5, -0.5, 0.5),
-            (0.5, -0.5, -0.5),
-        ]
-        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
-
-        blocks = get_blocks(N)
-        calculated_indices = [
-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-            for jmm1 in jmm1_list
-        ]
-        assert_array_almost_equal(calculated_indices, indices)
-        N = 2
-        blocks = get_blocks(N)
-        jmm1_list = [
-            (1, 1, 1),
-            (1, 1, 0),
-            (1, 1, -1),
-            (1, 0, 1),
-            (1, 0, 0),
-            (1, 0, -1),
-            (1, -1, 1),
-            (1, -1, 0),
-            (1, -1, -1),
-            (0, 0, 0),
-        ]
-        indices = [
-            (0, 0),
-            (0, 1),
-            (0, 2),
-            (1, 0),
-            (1, 1),
-            (1, 2),
-            (2, 0),
-            (2, 1),
-            (2, 2),
-            (3, 3),
-        ]
-        calculated_indices = [
-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-            for jmm1 in jmm1_list
-        ]
-        assert_array_almost_equal(calculated_indices, indices)
-        N = 3
-        blocks = get_blocks(N)
-        jmm1_list = [
-            (1.5, 1.5, 1.5),
-            (1.5, 1.5, 0.5),
-            (1.5, 1.5, -0.5),
-            (1.5, 1.5, -1.5),
-            (1.5, 0.5, 0.5),
-            (1.5, -0.5, -0.5),
-            (1.5, -1.5, -1.5),
-            (1.5, -1.5, 1.5),
-            (0.5, 0.5, 0.5),
-            (0.5, 0.5, -0.5),
-            (0.5, -0.5, 0.5),
-            (0.5, -0.5, -0.5),
-        ]
-
-        indices = [
-            (0, 0),
-            (0, 1),
-            (0, 2),
-            (0, 3),
-            (1, 1),
-            (2, 2),
-            (3, 3),
-            (3, 0),
-            (4, 4),
-            (4, 5),
-            (5, 4),
-            (5, 5),
-        ]
-
-        calculated_indices = [
-            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
-            for jmm1 in jmm1_list
-        ]
-        assert_array_almost_equal(calculated_indices, indices)
-
-    def test_jmm1_dictionary(self):
-        """
-        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
-        """
-        d1, d2, d3, d4 = jmm1_dictionary(1)
-
-        d1_correct = {
-            (0, 0): (0.5, 0.5, 0.5),
-            (0, 1): (0.5, 0.5, -0.5),
-            (1, 0): (0.5, -0.5, 0.5),
-            (1, 1): (0.5, -0.5, -0.5),
-        }
-
-        d2_correct = {
-            (0.5, -0.5, -0.5): (1, 1),
-            (0.5, -0.5, 0.5): (1, 0),
-            (0.5, 0.5, -0.5): (0, 1),
-            (0.5, 0.5, 0.5): (0, 0),
-        }
-
-        d3_correct = {
-            0: (0.5, 0.5, 0.5),
-            1: (0.5, 0.5, -0.5),
-            2: (0.5, -0.5, 0.5),
-            3: (0.5, -0.5, -0.5),
-        }
-
-        d4_correct = {
-            (0.5, -0.5, -0.5): 3,
-            (0.5, -0.5, 0.5): 2,
-            (0.5, 0.5, -0.5): 1,
-            (0.5, 0.5, 0.5): 0,
-        }
-
-        assert_equal(d1, d1_correct)
-        assert_equal(d2, d2_correct)
-        assert_equal(d3, d3_correct)
-        assert_equal(d4, d4_correct)
-
-        d1, d2, d3, d4 = jmm1_dictionary(2)
-
-        d1_correct = {
-            (3, 3): (0.0, -0.0, -0.0),
-            (2, 2): (1.0, -1.0, -1.0),
-            (2, 1): (1.0, -1.0, 0.0),
-            (2, 0): (1.0, -1.0, 1.0),
-            (1, 2): (1.0, 0.0, -1.0),
-            (1, 1): (1.0, 0.0, 0.0),
-            (1, 0): (1.0, 0.0, 1.0),
-            (0, 2): (1.0, 1.0, -1.0),
-            (0, 1): (1.0, 1.0, 0.0),
-            (0, 0): (1.0, 1.0, 1.0),
-        }
-
-        d2_correct = {
-            (0.0, -0.0, -0.0): (3, 3),
-            (1.0, -1.0, -1.0): (2, 2),
-            (1.0, -1.0, 0.0): (2, 1),
-            (1.0, -1.0, 1.0): (2, 0),
-            (1.0, 0.0, -1.0): (1, 2),
-            (1.0, 0.0, 0.0): (1, 1),
-            (1.0, 0.0, 1.0): (1, 0),
-            (1.0, 1.0, -1.0): (0, 2),
-            (1.0, 1.0, 0.0): (0, 1),
-            (1.0, 1.0, 1.0): (0, 0),
-        }
-
-        d3_correct = {
-            15: (0.0, -0.0, -0.0),
-            10: (1.0, -1.0, -1.0),
-            9: (1.0, -1.0, 0.0),
-            8: (1.0, -1.0, 1.0),
-            6: (1.0, 0.0, -1.0),
-            5: (1.0, 0.0, 0.0),
-            4: (1.0, 0.0, 1.0),
-            2: (1.0, 1.0, -1.0),
-            1: (1.0, 1.0, 0.0),
-            0: (1.0, 1.0, 1.0),
-        }
-
-        d4_correct = {
-            (0.0, -0.0, -0.0): 15,
-            (1.0, -1.0, -1.0): 10,
-            (1.0, -1.0, 0.0): 9,
-            (1.0, -1.0, 1.0): 8,
-            (1.0, 0.0, -1.0): 6,
-            (1.0, 0.0, 0.0): 5,
-            (1.0, 0.0, 1.0): 4,
-            (1.0, 1.0, -1.0): 2,
-            (1.0, 1.0, 0.0): 1,
-            (1.0, 1.0, 1.0): 0,
-        }
-
-        assert_equal(d1, d1_correct)
-        assert_equal(d2, d2_correct)
-        assert_equal(d3, d3_correct)
-        assert_equal(d4, d4_correct)
-
-    def test_lindbladian(self):
-        """
-        PIQS: Test the generation of the Lindbladian matrix.
-        """
-        N = 1
-        gCE = 0.5
-        gCD = 0.5
-        gCP = 0.5
-        gE = 0.1
-        gD = 0.1
-        gP = 0.1
-
-        system = Dicke(
-            N=N,
-            emission=gE,
-            pumping=gP,
-            dephasing=gD,
-            collective_emission=gCE,
-            collective_pumping=gCP,
-            collective_dephasing=gCD,
-        )
-
-        lindbladian = system.lindbladian()
-        Ldata = np.zeros((4, 4), dtype="complex")
-        Ldata[0] = [-0.6, 0, 0, 0.6]
-        Ldata[1] = [0, -0.9, 0, 0]
-        Ldata[2] = [0, 0, -0.9, 0]
-        Ldata[3] = [0.6, 0, 0, -0.6]
-
-        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
-        assert_array_almost_equal(lindbladian.full(), Ldata)
-        N = 2
-        gCE = 0.5
-        gCD = 0.5
-        gCP = 0.5
-        gE = 0.1
-        gD = 0.1
-        gP = 0.1
-        system = Dicke(
-            N=N,
-            emission=gE,
-            pumping=gP,
-            dephasing=gD,
-            collective_emission=gCE,
-            collective_pumping=gCP,
-            collective_dephasing=gCD,
-        )
-
-        lindbladian = system.lindbladian()
-
-        Ldata = np.zeros((16, 16), dtype="complex")
-        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
-        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
-        Ldata[2, 2] = -2.2999999999999998
-        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
-        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
-            1.1,
-            -2.25,
-            1.1,
-            0.05,
-        )
-        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
-        Ldata[8, 8] = -2.2999999999999998
-        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
-        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
-        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
-            0.1,
-            0.05,
-            0.1,
-            -0.25,
-        )
-        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
-        assert_array_almost_equal(lindbladian.full(), Ldata)
-
-    def test_gamma(self):
-        """
-        PIQS: Test the calculation of various gamma values for diagonal system.
-
-        For N = 6 |j, m> would be :
-
-        | 3, 3>
-        | 3, 2> | 2, 2>
-        | 3, 1> | 2, 1> | 1, 1>
-        | 3, 0> | 2, 0> | 1, 0> |0, 0>
-        | 3,-1> | 2,-1> | 1,-1>
-        | 3,-2> | 2,-2>
-        | 3,-3>
-        """
-        N = 6
-        collective_emission = 1.0
-        emission = 1.0
-        dephasing = 1.0
-        pumping = 1.0
-        collective_pumping = 1.0
-        model = _Dicke(
-            N,
-            collective_emission=collective_emission,
-            emission=emission,
-            dephasing=dephasing,
-            pumping=pumping,
-            collective_pumping=collective_pumping,
-        )
-        tau_calculated = [
-            model.gamma3((3, 1, 1)),
-            model.gamma2((2, 1, 1)),
-            model.gamma4((1, 1, 1)),
-            model.gamma5((3, 0, 0)),
-            model.gamma1((2, 0, 0)),
-            model.gamma6((1, 0, 0)),
-            model.gamma7((3, -1, -1)),
-            model.gamma8((2, -1, -1)),
-            model.gamma9((1, -1, -1)),
-        ]
-        tau_real = [
-            2.0,
-            8.0,
-            0.333333,
-            1.5,
-            -19.5,
-            0.666667,
-            2.0,
-            8.0,
-            0.333333,
-        ]
-        assert_array_almost_equal(tau_calculated, tau_real)
-
-    def test_jspin(self):
-        """
-        PIQS: Test calculation of the j algebra relation for the total operators.
-
-        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
-        basis should follow the following algebra
-        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
-        """
-        N_list = [1, 2, 3, 4, 7]
-
-        for nn in N_list:
-            # tests 1
-            [jx, jy, jz] = jspin(nn)
-            jp, jm = jspin(nn, "+"), jspin(nn, "-")
-            test_jxjy = jx * jy - jy * jx
-            true_jxjy = 1j * jz
-            test_jpjm = jp * jm - jm * jp
-            true_jpjm = 2 * jz
-
-            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
-            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
-
-            # tests 2
-            [jx, jy, jz] = jspin(nn)
-            jp, jm = jspin(nn, "+"), jspin(nn, "-")
-            test_jxjy = jx * jy - jy * jx
-            true_jxjy = 1j * jz
-            test_jpjm = jp * jm - jm * jp
-            true_jpjm = 2 * jz
-
-            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
-            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
-
-            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
-            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
-            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
-            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
-            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
-            assert_raises(TypeError, jspin, nn, "q")
-
-    def test_j_min_(self):
-        """
-        PIQS: Test the `j_min` function.
-        """
-        even = [2, 4, 6, 8]
-        odd = [1, 3, 5, 7]
-
-        for i in even:
-            assert_(j_min(i) == 0)
-
-        for i in odd:
-            assert_(j_min(i) == 0.5)
-
-    def test_energy_degeneracy(self):
-        """
-        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
-        """
-        true_en_deg = [1, 1, 1, 1, 1]
-        true_en_deg_even = [2, 6, 20]
-        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
-        test_en_deg = []
-        test_en_deg_even = []
-        test_en_deg_odd = []
-
-        for nn in [1, 2, 3, 4, 7]:
-            test_en_deg.append(energy_degeneracy(nn, nn / 2))
-
-        for nn in [2, 4, 6]:
-            test_en_deg_even.append(energy_degeneracy(nn, 0))
-
-        for nn in [1, 3, 7]:
-            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
-            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
-
-        assert_array_equal(test_en_deg, true_en_deg)
-        assert_array_equal(test_en_deg_even, true_en_deg_even)
-        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
-
-    def test_state_degeneracy(self):
-        """
-        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
-        state_degeneracy(N, j).
-        """
-        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
-        state_deg = []
-        state_deg = []
-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-            state_deg.append(state_degeneracy(nn, nn / 2))
-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
-        assert_array_equal(state_deg, true_state_deg)
-
-        # check error
-        assert_raises(ValueError, state_degeneracy, 2, -1)
-
-    def test_m_degeneracy(self):
-        """
-        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
-        """
-        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
-        m_deg = []
-        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
-            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
-        assert_array_equal(m_deg, true_m_deg)
-
-        # check error
-        assert_raises(ValueError, m_degeneracy, 6, -6)
-
-    def test_ap(self):
-        """
-        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
-
-        For given values of j, m. For a Dicke state,
-        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
-        """
-        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
-        ap_list = []
-        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
-            ap_list.append(ap(10, m) ** 2)
-
-        assert_almost_equal(ap_list, true_ap_list)
-
-    def test_am(self):
-        """
-        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
-
-        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
-        """
-        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
-        am_list = []
-        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
-            am_list.append(am(10, m) ** 2)
-
-        assert_almost_equal(am_list, true_am_list)
-
-    def test_spin_algebra(self):
-        """
-        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
-        The list [sx, sy, sz, sp, sm] is checked for N = 2.
-        """
-        sx1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sx2 = [
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sy1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sy2 = [
-            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
-        ]
-
-        sz1 = [
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
-        ]
-
-        sz2 = [
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
-        ]
-
-        sp1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sp2 = [
-            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sm1 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        sm2 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
-        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
-        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
-        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
-        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
-        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
-        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
-        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
-        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
-        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
-
-        # test error
-        assert_raises(TypeError, spin_algebra, 2, "q")
-
-    def test_collective_algebra(self):
-        """
-        PIQS: Test the generation of the collective algebra in uncoupled basis.
-
-        The list [jx, jy, jz] created in the 2^N Hilbert space is
-        checked for N = 2.
-        """
-
-        jx_n2 = [
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
-            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        jy_n2 = [
-            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
-            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
-        ]
-
-        jz_n2 = [
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
-        ]
-
-        jp_n2 = [
-            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        jm_n2 = [
-            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
-            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
-        ]
-
-        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
-        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
-        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
-        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
-        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
-
-        # error
-        assert_raises(TypeError, spin_algebra, 2, "q")
-
-    def test_block_matrix(self):
-        """
-        PIQS: Test the calculation of the block-diagonal matrix for given N.
-
-        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
-        """
-        # N = 1 TLSs
-        block_1 = [[1.0, 1.0], [1.0, 1.0]]
-
-        # N = 2 TLSs
-        block_2 = [
-            [1.0, 1.0, 1.0, 0.0],
-            [1.0, 1.0, 1.0, 0.0],
-            [1.0, 1.0, 1.0, 0.0],
-            [0.0, 0.0, 0.0, 1.0],
-        ]
-
-        # N = 3 TLSs
-        block_3 = [
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
-            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
-            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
-        ]
-
-        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
-        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
-        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
-
-    def test_dicke_basis(self):
-        """
-        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
-
-        We test the state with for N = 2,
-
-        0   0   0.3 0
-        0   0.5 0   0
-        0.3 0   0   0
-        0   0   0   0.5
-        """
-        N = 2
-        true_dicke_basis = np.zeros((4, 4))
-        true_dicke_basis[1, 1] = 0.5
-        true_dicke_basis[-1, -1] = 0.5
-        true_dicke_basis[0, 2] = 0.3
-        true_dicke_basis[2, 0] = 0.3
-        true_dicke_basis = Qobj(true_dicke_basis)
-        jmm1_1 = {(N / 2, 0, 0): 0.5}
-        jmm1_2 = {(0, 0, 0): 0.5}
-        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
-        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
-        db1 = dicke_basis(2, jmm1_1)
-        db2 = dicke_basis(2, jmm1_2)
-        db3 = dicke_basis(2, jmm1_3)
-        db4 = dicke_basis(2, jmm1_4)
-        test_dicke_basis = db1 + db2 + db3 + db4
-        assert_equal(test_dicke_basis, true_dicke_basis)
-
-        # error
-        assert_raises(AttributeError, dicke_basis, N)
-
-    def test_dicke(self):
-        """
-        PIQS: Test the calculation of the Dicke state as a pure state.
-        """
-        true_excited = np.zeros((4, 4))
-        true_excited[0, 0] = 1
-
-        true_superradiant = np.zeros((4, 4))
-        true_superradiant[1, 1] = 1
-
-        true_subradiant = np.zeros((4, 4))
-        true_subradiant[-1, -1] = 1
-
-        test_excited = dicke(2, 1, 1)
-        test_superradiant = dicke(2, 1, 0)
-        test_subradiant = dicke(2, 0, 0)
-
-        assert_equal(test_excited, Qobj(true_excited))
-        assert_equal(test_superradiant, Qobj(true_superradiant))
-        assert_equal(test_subradiant, Qobj(true_subradiant))
-
-    def test_excited(self):
-        """
-        PIQS: Test the calculation of the totally excited state density matrix.
-
-        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
-        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
-        """
-        N = 3
-        true_state = np.zeros((6, 6))
-        true_state[0, 0] = 1
-        true_state = Qobj(true_state)
-
-        test_state = excited(N)
-        assert_equal(test_state, true_state)
-
-        N = 4
-        true_state = np.zeros((9, 9))
-        true_state[0, 0] = 1
-        true_state = Qobj(true_state)
-
-        test_state = excited(N)
-        assert_equal(test_state, true_state)
-
-        # uncoupled
-        test_state_uncoupled = excited(2, basis="uncoupled")
-        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
-        assert_array_equal(test_state_uncoupled.shape, (4, 4))
-        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
-
-    def test_superradiant(self):
-        """
-        PIQS: Test the calculation of the superradiant state density matrix.
-
-        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
-        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
-        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
-        """
-        N = 3
-        true_state = np.zeros((6, 6))
-        true_state[1, 1] = 1
-        true_state = Qobj(true_state)
-        test_state = superradiant(N)
-        assert_equal(test_state, true_state)
-        N = 4
-        true_state = np.zeros((9, 9))
-        true_state[2, 2] = 1
-        true_state = Qobj(true_state)
-        test_state = superradiant(N)
-        assert_equal(test_state, true_state)
-
-        # uncoupled
-        test_state_uncoupled = superradiant(2, basis="uncoupled")
-        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
-        assert_array_equal(test_state_uncoupled.shape, (4, 4))
-        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
-
-    def test_ghz(self):
-        """
-        PIQS: Test the calculation of the density matrix of the GHZ state.
-
-        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
-        """
-        ghz_dicke = Qobj(
-            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
-        )
-        ghz_uncoupled = Qobj(
-            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
-        )
-        ghz_uncoupled.dims = [[2, 2], [2, 2]]
-        assert_equal(ghz(2), ghz_dicke)
-        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
-
-    def test_ground(self):
-        """
-        PIQS: Test the calculation of the density matrix of the ground state.
-
-        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
-        """
-        zeros = np.zeros((4, 4), dtype=np.complex128)
-        gdicke = zeros.copy()
-        guncoupled = zeros.copy()
-        gdicke[2, 2] = 1
-        guncoupled[3, 3] = 1
-
-        dim_dicke = [[4], [4]]
-        dim_uncoupled = [[2, 2], [2, 2]]
-
-        test_ground_dicke = ground(2)
-        test_ground_uncoupled = ground(2, "uncoupled")
-
-        assert_array_equal(test_ground_dicke.full(), gdicke)
-        assert_array_equal(test_ground_dicke.dims, dim_dicke)
-        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
-        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
-
-    def test_identity_uncoupled(self):
-        """
-        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
-        """
-        test_identity = identity_uncoupled(4)
-        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
-        assert_array_equal(
-            np.diag(test_identity.full()), np.ones(16, np.complex128)
-        )
-
-    def test_css(self):
-        """
-        PIQS: Test the calculation of the CSS state.
-        """
-        test_css_uncoupled = css(2, basis="uncoupled")
-        test_css_dicke = css(2)
-        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
-        css_dicke = np.array(
-            [
-                [
-                    0.25000000 + 0.0j,
-                    0.35355339 + 0.0j,
-                    0.25000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-                [
-                    0.35355339 + 0.0j,
-                    0.50000000 + 0.0j,
-                    0.35355339 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-                [
-                    0.25000000 + 0.0j,
-                    0.35355339 + 0.0j,
-                    0.25000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-                [
-                    0.00000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                    0.00000000 + 0.0j,
-                ],
-            ]
-        )
-        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
-        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
-
-    def test_collapse_uncoupled(self):
-        """
-        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
-
-        In the "uncoupled" basis of N two-level system (TLS).
-        The test is performed for N = 2 and emission = 1.
-        """
-        c1 = Qobj(
-            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
-            dims=[[2, 2], [2, 2]],
-        )
-        c2 = Qobj(
-            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
-            dims=[[2, 2], [2, 2]],
-        )
-        true_c_ops = [c1, c2]
-        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
-        system = Dicke(N=2, emission=1)
-        assert_equal(true_c_ops, system.c_ops())
-
-    def test_get_blocks(self):
-        """
-        PIQS: Test the calculation of list of cumulative elements at each block.
-
-        For N = 4
-
-        1 1 1 1 1
-        1 1 1 1 1
-        1 1 1 1 1
-        1 1 1 1 1
-        1 1 1 1 1
-                1 1 1
-                1 1 1
-                1 1 1
-                     1
-        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
-        elements have been accounted for and so on.
-        """
-        trueb1 = [2]
-        trueb2 = [3, 4]
-        trueb3 = [4, 6]
-        trueb4 = [5, 8, 9]
-
-        test_b1 = get_blocks(1)
-        test_b2 = get_blocks(2)
-        test_b3 = get_blocks(3)
-        test_b4 = get_blocks(4)
-
-        assert_equal(test_b1, trueb1)
-        assert_equal(test_b2, trueb2)
-        assert_equal(test_b3, trueb3)
-
-    def test_lindbladian_dims(self):
-        """
-        PIQS: Test the calculation of the lindbladian matrix.
-        """
-        true_L = [
-            [-4, 0, 0, 3],
-            [0, -3.54999995, 0, 0],
-            [0, 0, -3.54999995, 0],
-            [4, 0, 0, -3],
-        ]
-        true_L = Qobj(true_L)
-        true_L.dims = [[[2], [2]], [[2], [2]]]
-        N = 1
-        test_dicke = _Dicke(
-            N=N,
-            pumping=1,
-            collective_pumping=2,
-            emission=1,
-            collective_emission=3,
-            dephasing=0.1,
-        )
-        test_L = test_dicke.lindbladian()
-        assert_array_almost_equal(test_L.full(), true_L.full())
-        assert_array_equal(test_L.dims, true_L.dims)
-
-    def test_liouvillian(self):
-        """
-        PIQS: Test the calculation of the liouvillian matrix.
-        """
-        true_L = [
-            [-4, 0, 0, 3],
-            [0, -3.54999995, 0, 0],
-            [0, 0, -3.54999995, 0],
-            [4, 0, 0, -3],
-        ]
-        true_L = Qobj(true_L)
-        true_L.dims = [[[2], [2]], [[2], [2]]]
-        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
-        true_H = Qobj(true_H)
-        true_H.dims = [[[2], [2]]]
-        true_liouvillian = [
-            [-4, -1.0j, 1.0j, 3],
-            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
-            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
-            [4, +1.0j, -1.0j, -3],
-        ]
-        true_liouvillian = Qobj(true_liouvillian)
-        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
-        N = 1
-        test_piqs = Dicke(
-            hamiltonian=sigmaz() + sigmax(),
-            N=N,
-            pumping=1,
-            collective_pumping=2,
-            emission=1,
-            collective_emission=3,
-            dephasing=0.1,
-        )
-        test_liouvillian = test_piqs.liouvillian()
-        test_hamiltonian = test_piqs.hamiltonian
-        assert_array_almost_equal(
-            test_liouvillian.full(), true_liouvillian.full()
-        )
-        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
-        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
-
-        # no Hamiltonian
-        test_piqs = Dicke(
-            N=N,
-            pumping=1,
-            collective_pumping=2,
-            emission=1,
-            collective_emission=3,
-            dephasing=0.1,
-        )
-        liouv = test_piqs.liouvillian()
-        lindblad = test_piqs.lindbladian()
-        assert_equal(liouv, lindblad)
-
-    def test_gamma1(self):
-        """
-        PIQS: Test the calculation of gamma1.
-        """
-        true_gamma_1 = -2
-        true_gamma_2 = -3
-        true_gamma_3 = -7
-        true_gamma_4 = -1
-        true_gamma_5 = 0
-        true_gamma_6 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, collective_emission=1)
-        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1)
-        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, dephasing=4)
-        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_pumping=2)
-        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_dephasing=2)
-        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-        assert_almost_equal(true_gamma_5, test_gamma_5)
-        assert_almost_equal(true_gamma_6, test_gamma_6)
-
-    def test_gamma2(self):
-        """
-        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 2
-        true_gamma_2 = 1.5
-        true_gamma_3 = 5.5
-        true_gamma_4 = 0
-        true_gamma_5 = 0
-        true_gamma_6 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, collective_emission=1)
-        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1)
-        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, dephasing=4)
-        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_pumping=2)
-        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_dephasing=2)
-        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-        assert_almost_equal(true_gamma_5, test_gamma_5)
-        assert_almost_equal(true_gamma_6, test_gamma_6)
-
-    def test_gamma3(self):
-        """
-        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 1.3333333730697632
-        true_gamma_3 = 1.3333333730697632
-        true_gamma_4 = 0
-        true_gamma_5 = 0
-        true_gamma_6 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, collective_emission=1)
-        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1)
-        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, dephasing=4)
-        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_pumping=2)
-        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
-        test_dicke = _Dicke(N=N, collective_dephasing=2)
-        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
-        #
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-        assert_almost_equal(true_gamma_5, test_gamma_5)
-        assert_almost_equal(true_gamma_6, test_gamma_6)
-
-    def test_gamma4(self):
-        """
-        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0.1666666716337204
-        true_gamma_2 = 2
-        true_gamma_3 = 0
-        true_gamma_4 = 0.40824830532073975
-
-        N = 4
-        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
-        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
-        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
-        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma5(self):
-        """
-        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 0
-        true_gamma_3 = 0.75
-        true_gamma_4 = 0
-
-        N = 4
-        test_dicke = _Dicke(N=N, dephasing=1)
-        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
-        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
-        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma6(self):
-        """
-        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0.25
-        true_gamma_2 = 1
-        true_gamma_3 = 0
-        true_gamma_4 = 0.25
-
-        N = 4
-        test_dicke = _Dicke(N=N, dephasing=1)
-        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
-        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
-        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma7(self):
-        """
-        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 0.5
-        true_gamma_3 = 0
-        true_gamma_4 = 1.5
-
-        N = 4
-        test_dicke = _Dicke(N=N, pumping=1)
-        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
-        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
-        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma8(self):
-        """
-        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 0
-        true_gamma_2 = 13.5
-        true_gamma_3 = 5.5
-        true_gamma_4 = 13.5
-
-        N = 4
-        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
-        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
-        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
-        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
-
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-    def test_gamma9(self):
-        """
-        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
-        """
-        true_gamma_1 = 1
-        true_gamma_2 = 0
-        true_gamma_3 = 0.5
-        true_gamma_4 = 0
-        N = 4
-        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
-        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
-        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
-        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
-        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
-        assert_almost_equal(true_gamma_1, test_gamma_1)
-        assert_almost_equal(true_gamma_2, test_gamma_2)
-        assert_almost_equal(true_gamma_3, test_gamma_3)
-        assert_almost_equal(true_gamma_4, test_gamma_4)
-
-
-class TestPim:
-    """
-    Tests for the `qutip.piqs.Pim` class.
-    """
-
-    def test_gamma(self):
-        """
-        PIQS: Test the calculation of various gamma values for diagonal system.
-
-        For N = 6 |j, m> would be :
-
-        | 3, 3>
-        | 3, 2> | 2, 2>
-        | 3, 1> | 2, 1> | 1, 1>
-        | 3, 0> | 2, 0> | 1, 0> |0, 0>
-        | 3,-1> | 2,-1> | 1,-1>
-        | 3,-2> | 2,-2>
-        | 3,-3>
-        """
-        N = 6
-        collective_emission = 1.0
-        emission = 1.0
-        dephasing = 1.0
-        pumping = 1.0
-        collective_pumping = 1.0
-        model = Pim(
-            N,
-            collective_emission=collective_emission,
-            emission=emission,
-            dephasing=dephasing,
-            pumping=pumping,
-            collective_pumping=collective_pumping,
-        )
-        tau_calculated = [
-            model.tau3(3, 1),
-            model.tau2(2, 1),
-            model.tau4(1, 1),
-            model.tau5(3, 0),
-            model.tau1(2, 0),
-            model.tau6(1, 0),
-            model.tau7(3, -1),
-            model.tau8(2, -1),
-            model.tau9(1, -1),
-        ]
-        tau_real = [
-            2.0,
-            8.0,
-            0.333333,
-            1.5,
-            -19.5,
-            0.666667,
-            2.0,
-            8.0,
-            0.333333,
-        ]
-        assert_array_almost_equal(tau_calculated, tau_real)
-
-    def test_isdicke(self):
-        """
-        PIQS: Test the `isdicke` function
-        """
-        N1 = 1
-        g0 = 0.01
-        nth = 0.01
-        gP = g0 * nth
-        gL = g0 * (0.1 + nth)
-        gS = 0.1
-        gD = 0.1
-
-        pim1 = Pim(N1, gS, gL, gD, gP)
-
-        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
-        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
-
-        N2 = 4
-
-        pim2 = Pim(N2, gS, gL, gD, gP)
-        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
-        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
-
-        assert_array_equal(dicke_labels, [True, False, True, False, True])
-
-    def test_isdiagonal(self):
-        """
-        PIQS: Test the isdiagonal function.
-        """
-        mat1 = np.array([[1, 2], [3, 4]])
-        mat2 = np.array([[1, 0.0], [0.0, 2]])
-        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
-        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
-        assert_equal(isdiagonal(mat1), False)
-        assert_equal(isdiagonal(mat2), True)
-        assert_equal(isdiagonal(mat3), False)
-        assert_equal(isdiagonal(mat4), True)
-
-    def test_pisolve(self):
-        """
-        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
-        """
-        jx, jy, jz = jspin(4)
-        jp, jm = jspin(4, "+"), jspin(4, "-")
-
-    def test_coefficient_matrix(self):
-        """
-        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
-        """
-        N = 2
-        ensemble = Pim(N, emission=1)
-        test_matrix = ensemble.coefficient_matrix().toarray()
-        ensemble2 = Dicke(N, emission=1)
-        test_matrix2 = ensemble.coefficient_matrix().toarray()
-        true_matrix = [
-            [-2, 0, 0, 0],
-            [1, -1, 0, 0],
-            [0, 1, 0, 1.0],
-            [1, 0, 0, -1.0],
-        ]
-
-        assert_array_almost_equal(test_matrix, true_matrix)
-        assert_array_almost_equal(test_matrix2, true_matrix)
-
-    def test_pisolve(self):
-        """
-        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
-        """
-        jx, jy, jz = jspin(4)
-        jp, jm = jspin(4, "+"), jspin(4, "-")
-        non_diag_hamiltonian = jx
-        diag_hamiltonian = jz
-
-        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
-        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
-
-        diag_initial_state = dicke(4, 1, 0)
-        non_diag_initial_state = ghz(4)
-        tlist = np.linspace(0, 10, 100)
-
-        assert_raises(
-            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
-        )
-        assert_raises(
-            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
-        )
-        assert_raises(
-            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
-        )
-
-        non_dicke_initial_state = excited(4, basis="uncoupled")
-        assert_raises(
-            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
-        )
-
-        # no Hamiltonian
-        no_hamiltonian_system = Dicke(4, emission=0.1)
-        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
-        assert_equal(True, len(result.states) > 0)
-
-
-if __name__ == "__main__":
-    run_module_suite()
+"""
+Tests for Permutational Invariant Quantum solver (PIQS).
+"""
+import numpy as np
+from numpy.testing import (
+    assert_,
+    run_module_suite,
+    assert_raises,
+    assert_array_equal,
+    assert_array_almost_equal,
+    assert_almost_equal,
+    assert_equal,
+)
+from scipy.sparse import block_diag
+from qutip import Qobj, entropy_vn, sigmax, sigmaz
+from qutip.solve._piqs import (
+    get_blocks,
+    j_min,
+    j_vals,
+    m_vals,
+    _num_dicke_states,
+    _num_dicke_ladders,
+    get_index,
+    jmm1_dictionary,
+)
+from qutip.solve._piqs import Dicke as _Dicke
+from qutip.solve.piqs import *
+
+import sys
+import unittest
+
+
+# Disable tests for python2 as qutip.piqs does not support python2.
+if sys.version_info[0] < 3:
+    raise unittest.SkipTest("qutip.piqs module is not tested for Python 2")
+
+
+class TestDicke:
+    """
+    Tests for `qutip.piqs.Dicke` class and auxiliary functions.
+    """
+
+    def test_num_dicke_states(self):
+        """
+        PIQS: Test the `num_dicke_state` function.
+        """
+        N_list = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
+        dicke_states = [num_dicke_states(i) for i in N_list]
+        assert_array_equal(
+            dicke_states, [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
+        )
+        N = -1
+        assert_raises(ValueError, num_dicke_states, N)
+        N = 0.2
+        assert_raises(ValueError, num_dicke_states, N)
+
+    def test_num_tls(self):
+        """
+        PIQS: Test the `num_two_level` function.
+        """
+        N_dicke = [2, 4, 6, 9, 12, 16, 30, 36, 121, 2601, 3906]
+        N = [1, 2, 3, 4, 5, 6, 9, 10, 20, 100, 123]
+        calculated_N = [num_tls(i) for i in N_dicke]
+        assert_array_equal(calculated_N, N)
+
+    def test_num_dicke_ladders(self):
+        """
+        PIQS: Test the `_num_dicke_ladders` function.
+        """
+        ndl_true = [1, 2, 2, 3, 3, 4, 4, 5, 5]
+        ndl = [num_dicke_ladders(N) for N in range(1, 10)]
+        assert_array_equal(ndl, ndl_true)
+
+    def test_get_blocks(self):
+        """
+        PIQS: Test the function to get blocks.
+        """
+        N_list = [1, 2, 5, 7]
+        blocks = [
+            np.array([2]),
+            np.array([3, 4]),
+            np.array([6, 10, 12]),
+            np.array([8, 14, 18, 20]),
+        ]
+        calculated_blocks = [get_blocks(i) for i in N_list]
+        for (i, j) in zip(calculated_blocks, blocks):
+            assert_array_equal(i, j)
+
+    def test_j_vals(self):
+        """
+        PIQS: Test calculation of j values for given N.
+        """
+        N_list = [1, 2, 3, 4, 7]
+        j_vals_real = [
+            np.array([0.5]),
+            np.array([0.0, 1.0]),
+            np.array([0.5, 1.5]),
+            np.array([0.0, 1.0, 2.0]),
+            np.array([0.5, 1.5, 2.5, 3.5]),
+        ]
+        j_vals_calc = [j_vals(i) for i in N_list]
+
+        for (i, j) in zip(j_vals_calc, j_vals_real):
+            assert_array_equal(i, j)
+
+    def test_m_vals(self):
+        """
+        PIQS: Test calculation of m values for a particular j.
+        """
+        j_list = [0.5, 1, 1.5, 2, 2.5]
+        m_real = [
+            np.array([-0.5, 0.5]),
+            np.array([-1, 0, 1]),
+            np.array([-1.5, -0.5, 0.5, 1.5]),
+            np.array([-2, -1, 0, 1, 2]),
+            np.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5]),
+        ]
+
+        m_calc = [m_vals(i) for i in j_list]
+        for (i, j) in zip(m_real, m_calc):
+            assert_array_equal(i, j)
+
+    def test_dicke_blocks(self):
+        """
+        PIQS: Test the `dicke_blocks` function.
+        """
+        # test 1
+        # mixed state with non-symmetrical block matrix elements
+        N = 3
+        true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        test_blocks = dicke_blocks(true_matrix)
+        test_matrix = Qobj(block_diag(test_blocks))
+        assert_(test_matrix == true_matrix)
+        # test 2
+        # all elements in block-diagonal matrix
+        N = 4
+        true_matrix = Qobj(block_matrix(N)).unit()
+        test_blocks = dicke_blocks(true_matrix)
+        test_matrix = Qobj(block_diag(test_blocks))
+        assert_(test_matrix == true_matrix)
+
+    def test_dicke_blocks_full(self):
+        """
+        PIQS: Test the `dicke_blocks_full` function.
+        """
+        N = 3
+        test_blocks = dicke_blocks_full(excited(3))
+        test_matrix = Qobj(block_diag(test_blocks))
+        true_expanded = np.zeros((8, 8))
+        true_expanded[0, 0] = 1.0
+        assert_(test_matrix == Qobj(true_expanded))
+
+    def test_dicke_function_trace(self):
+        """
+        PIQS: Test the `dicke_function_trace` function.
+        """
+        ## test for N odd
+        N = 3
+        # test trace
+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        f = lambda x: x
+        test_val = dicke_function_trace(f, rho_mixed)
+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
+        true_val2 = (rho_mixed).tr()
+        # test with linear function (trace)
+        assert_almost_equal(test_val, true_val)
+        assert_almost_equal(test_val, true_val2)
+        # test with nonlinear function
+        f = lambda rho: rho ** 3
+        test_val3 = dicke_function_trace(f, rho_mixed)
+        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
+        assert_almost_equal(test_val3, true_val3)
+        ## test for N even
+        N = 4
+        # test trace
+        rho_mixed = (excited(N) + dicke(N, 0, 0)).unit()
+        f = lambda x: x
+        test_val = dicke_function_trace(f, rho_mixed)
+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).tr()
+        true_val2 = (rho_mixed).tr()
+        # test with linear function (trace)
+        assert_almost_equal(test_val, true_val)
+        assert_almost_equal(test_val, true_val2)
+        # test with nonlinear function
+        f = lambda rho: rho ** 3
+        test_val3 = dicke_function_trace(f, rho_mixed)
+        true_val3 = (Qobj(block_diag(dicke_blocks_full(rho_mixed))) ** 3).tr()
+        assert np.allclose(test_val3, true_val3)
+
+    def test_entropy_vn_dicke(self):
+        """
+        PIQS: Test the `entropy_vn_dicke` function.
+        """
+        N = 3
+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        test_val = entropy_vn_dicke(rho_mixed)
+        true_val = entropy_vn(Qobj(block_diag(dicke_blocks_full(rho_mixed))))
+        assert np.allclose(test_val, true_val)
+
+    def test_purity_dicke(self):
+        """
+        PIQS: Test the `purity_dicke` function.
+        """
+        N = 3
+        rho_mixed = (excited(N) + dicke(N, 0.5, 0.5)).unit()
+        test_val = purity_dicke(rho_mixed)
+        true_val = (Qobj(block_diag(dicke_blocks_full(rho_mixed)))).purity()
+        assert np.allclose(test_val, true_val)
+
+    def test_get_index(self):
+        """
+        PIQS: Test the index fetching function for given j, m, m1 value.
+        """
+        N = 1
+        jmm1_list = [
+            (0.5, 0.5, 0.5),
+            (0.5, 0.5, -0.5),
+            (0.5, -0.5, 0.5),
+            (0.5, -0.5, -0.5),
+        ]
+        indices = [(0, 0), (0, 1), (1, 0), (1, 1)]
+
+        blocks = get_blocks(N)
+        calculated_indices = [
+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+            for jmm1 in jmm1_list
+        ]
+        assert_array_almost_equal(calculated_indices, indices)
+        N = 2
+        blocks = get_blocks(N)
+        jmm1_list = [
+            (1, 1, 1),
+            (1, 1, 0),
+            (1, 1, -1),
+            (1, 0, 1),
+            (1, 0, 0),
+            (1, 0, -1),
+            (1, -1, 1),
+            (1, -1, 0),
+            (1, -1, -1),
+            (0, 0, 0),
+        ]
+        indices = [
+            (0, 0),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 1),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+            (2, 2),
+            (3, 3),
+        ]
+        calculated_indices = [
+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+            for jmm1 in jmm1_list
+        ]
+        assert_array_almost_equal(calculated_indices, indices)
+        N = 3
+        blocks = get_blocks(N)
+        jmm1_list = [
+            (1.5, 1.5, 1.5),
+            (1.5, 1.5, 0.5),
+            (1.5, 1.5, -0.5),
+            (1.5, 1.5, -1.5),
+            (1.5, 0.5, 0.5),
+            (1.5, -0.5, -0.5),
+            (1.5, -1.5, -1.5),
+            (1.5, -1.5, 1.5),
+            (0.5, 0.5, 0.5),
+            (0.5, 0.5, -0.5),
+            (0.5, -0.5, 0.5),
+            (0.5, -0.5, -0.5),
+        ]
+
+        indices = [
+            (0, 0),
+            (0, 1),
+            (0, 2),
+            (0, 3),
+            (1, 1),
+            (2, 2),
+            (3, 3),
+            (3, 0),
+            (4, 4),
+            (4, 5),
+            (5, 4),
+            (5, 5),
+        ]
+
+        calculated_indices = [
+            get_index(N, jmm1[0], jmm1[1], jmm1[2], blocks)
+            for jmm1 in jmm1_list
+        ]
+        assert_array_almost_equal(calculated_indices, indices)
+
+    def test_jmm1_dictionary(self):
+        """
+        PIQS: Test the function to generate the mapping from jmm1 to ik matrix.
+        """
+        d1, d2, d3, d4 = jmm1_dictionary(1)
+
+        d1_correct = {
+            (0, 0): (0.5, 0.5, 0.5),
+            (0, 1): (0.5, 0.5, -0.5),
+            (1, 0): (0.5, -0.5, 0.5),
+            (1, 1): (0.5, -0.5, -0.5),
+        }
+
+        d2_correct = {
+            (0.5, -0.5, -0.5): (1, 1),
+            (0.5, -0.5, 0.5): (1, 0),
+            (0.5, 0.5, -0.5): (0, 1),
+            (0.5, 0.5, 0.5): (0, 0),
+        }
+
+        d3_correct = {
+            0: (0.5, 0.5, 0.5),
+            1: (0.5, 0.5, -0.5),
+            2: (0.5, -0.5, 0.5),
+            3: (0.5, -0.5, -0.5),
+        }
+
+        d4_correct = {
+            (0.5, -0.5, -0.5): 3,
+            (0.5, -0.5, 0.5): 2,
+            (0.5, 0.5, -0.5): 1,
+            (0.5, 0.5, 0.5): 0,
+        }
+
+        assert_equal(d1, d1_correct)
+        assert_equal(d2, d2_correct)
+        assert_equal(d3, d3_correct)
+        assert_equal(d4, d4_correct)
+
+        d1, d2, d3, d4 = jmm1_dictionary(2)
+
+        d1_correct = {
+            (3, 3): (0.0, -0.0, -0.0),
+            (2, 2): (1.0, -1.0, -1.0),
+            (2, 1): (1.0, -1.0, 0.0),
+            (2, 0): (1.0, -1.0, 1.0),
+            (1, 2): (1.0, 0.0, -1.0),
+            (1, 1): (1.0, 0.0, 0.0),
+            (1, 0): (1.0, 0.0, 1.0),
+            (0, 2): (1.0, 1.0, -1.0),
+            (0, 1): (1.0, 1.0, 0.0),
+            (0, 0): (1.0, 1.0, 1.0),
+        }
+
+        d2_correct = {
+            (0.0, -0.0, -0.0): (3, 3),
+            (1.0, -1.0, -1.0): (2, 2),
+            (1.0, -1.0, 0.0): (2, 1),
+            (1.0, -1.0, 1.0): (2, 0),
+            (1.0, 0.0, -1.0): (1, 2),
+            (1.0, 0.0, 0.0): (1, 1),
+            (1.0, 0.0, 1.0): (1, 0),
+            (1.0, 1.0, -1.0): (0, 2),
+            (1.0, 1.0, 0.0): (0, 1),
+            (1.0, 1.0, 1.0): (0, 0),
+        }
+
+        d3_correct = {
+            15: (0.0, -0.0, -0.0),
+            10: (1.0, -1.0, -1.0),
+            9: (1.0, -1.0, 0.0),
+            8: (1.0, -1.0, 1.0),
+            6: (1.0, 0.0, -1.0),
+            5: (1.0, 0.0, 0.0),
+            4: (1.0, 0.0, 1.0),
+            2: (1.0, 1.0, -1.0),
+            1: (1.0, 1.0, 0.0),
+            0: (1.0, 1.0, 1.0),
+        }
+
+        d4_correct = {
+            (0.0, -0.0, -0.0): 15,
+            (1.0, -1.0, -1.0): 10,
+            (1.0, -1.0, 0.0): 9,
+            (1.0, -1.0, 1.0): 8,
+            (1.0, 0.0, -1.0): 6,
+            (1.0, 0.0, 0.0): 5,
+            (1.0, 0.0, 1.0): 4,
+            (1.0, 1.0, -1.0): 2,
+            (1.0, 1.0, 0.0): 1,
+            (1.0, 1.0, 1.0): 0,
+        }
+
+        assert_equal(d1, d1_correct)
+        assert_equal(d2, d2_correct)
+        assert_equal(d3, d3_correct)
+        assert_equal(d4, d4_correct)
+
+    def test_lindbladian(self):
+        """
+        PIQS: Test the generation of the Lindbladian matrix.
+        """
+        N = 1
+        gCE = 0.5
+        gCD = 0.5
+        gCP = 0.5
+        gE = 0.1
+        gD = 0.1
+        gP = 0.1
+
+        system = Dicke(
+            N=N,
+            emission=gE,
+            pumping=gP,
+            dephasing=gD,
+            collective_emission=gCE,
+            collective_pumping=gCP,
+            collective_dephasing=gCD,
+        )
+
+        lindbladian = system.lindbladian()
+        Ldata = np.zeros((4, 4), dtype="complex")
+        Ldata[0] = [-0.6, 0, 0, 0.6]
+        Ldata[1] = [0, -0.9, 0, 0]
+        Ldata[2] = [0, 0, -0.9, 0]
+        Ldata[3] = [0.6, 0, 0, -0.6]
+
+        lindbladian_correct = Qobj(Ldata, dims=[[[2], [2]], [[2], [2]]])
+        assert_array_almost_equal(lindbladian.full(), Ldata)
+        N = 2
+        gCE = 0.5
+        gCD = 0.5
+        gCP = 0.5
+        gE = 0.1
+        gD = 0.1
+        gP = 0.1
+        system = Dicke(
+            N=N,
+            emission=gE,
+            pumping=gP,
+            dephasing=gD,
+            collective_emission=gCE,
+            collective_pumping=gCP,
+            collective_dephasing=gCD,
+        )
+
+        lindbladian = system.lindbladian()
+
+        Ldata = np.zeros((16, 16), dtype="complex")
+        Ldata[0][0], Ldata[0][5], Ldata[0][15] = -1.2, 1.1, 0.1
+        Ldata[1, 1], Ldata[1, 6] = -2, 1.1
+        Ldata[2, 2] = -2.2999999999999998
+        Ldata[4, 4], Ldata[4, 9] = -2, 1.1
+        Ldata[5, 0], Ldata[5, 5], Ldata[5, 10], Ldata[5, 15] = (
+            1.1,
+            -2.25,
+            1.1,
+            0.05,
+        )
+        Ldata[6, 1], Ldata[6, 6] = 1.1, -2
+        Ldata[8, 8] = -2.2999999999999998
+        Ldata[9, 4], Ldata[9, 9] = 1.1, -2
+        Ldata[10, 5], Ldata[10, 10], Ldata[10, 15] = 1.1, -1.2, 0.1
+        Ldata[15, 0], Ldata[15, 5], Ldata[15, 10], Ldata[15, 15] = (
+            0.1,
+            0.05,
+            0.1,
+            -0.25,
+        )
+        lindbladian_correct = Qobj(Ldata, dims=[[[4], [4]], [[4], [4]]])
+        assert_array_almost_equal(lindbladian.full(), Ldata)
+
+    def test_gamma(self):
+        """
+        PIQS: Test the calculation of various gamma values for diagonal system.
+
+        For N = 6 |j, m> would be :
+
+        | 3, 3>
+        | 3, 2> | 2, 2>
+        | 3, 1> | 2, 1> | 1, 1>
+        | 3, 0> | 2, 0> | 1, 0> |0, 0>
+        | 3,-1> | 2,-1> | 1,-1>
+        | 3,-2> | 2,-2>
+        | 3,-3>
+        """
+        N = 6
+        collective_emission = 1.0
+        emission = 1.0
+        dephasing = 1.0
+        pumping = 1.0
+        collective_pumping = 1.0
+        model = _Dicke(
+            N,
+            collective_emission=collective_emission,
+            emission=emission,
+            dephasing=dephasing,
+            pumping=pumping,
+            collective_pumping=collective_pumping,
+        )
+        tau_calculated = [
+            model.gamma3((3, 1, 1)),
+            model.gamma2((2, 1, 1)),
+            model.gamma4((1, 1, 1)),
+            model.gamma5((3, 0, 0)),
+            model.gamma1((2, 0, 0)),
+            model.gamma6((1, 0, 0)),
+            model.gamma7((3, -1, -1)),
+            model.gamma8((2, -1, -1)),
+            model.gamma9((1, -1, -1)),
+        ]
+        tau_real = [
+            2.0,
+            8.0,
+            0.333333,
+            1.5,
+            -19.5,
+            0.666667,
+            2.0,
+            8.0,
+            0.333333,
+        ]
+        assert_array_almost_equal(tau_calculated, tau_real)
+
+    def test_jspin(self):
+        """
+        PIQS: Test calculation of the j algebra relation for the total operators.
+
+        The jx, jy, jz, jp and jm for a given N in the (j, m, m1)
+        basis should follow the following algebra
+        [jx, jy] == 1j * jz, [jp, jm] == 2 * jz, jx^2 + jy^2 + jz^2 == j2^2.
+        """
+        N_list = [1, 2, 3, 4, 7]
+
+        for nn in N_list:
+            # tests 1
+            [jx, jy, jz] = jspin(nn)
+            jp, jm = jspin(nn, "+"), jspin(nn, "-")
+            test_jxjy = jx * jy - jy * jx
+            true_jxjy = 1j * jz
+            test_jpjm = jp * jm - jm * jp
+            true_jpjm = 2 * jz
+
+            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
+            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
+
+            # tests 2
+            [jx, jy, jz] = jspin(nn)
+            jp, jm = jspin(nn, "+"), jspin(nn, "-")
+            test_jxjy = jx * jy - jy * jx
+            true_jxjy = 1j * jz
+            test_jpjm = jp * jm - jm * jp
+            true_jpjm = 2 * jz
+
+            assert_array_almost_equal(test_jxjy.full(), true_jxjy.full())
+            assert_array_almost_equal(test_jpjm.full(), true_jpjm.full())
+
+            assert_array_almost_equal(jspin(nn, "x").full(), jx.full())
+            assert_array_almost_equal(jspin(nn, "y").full(), jy.full())
+            assert_array_almost_equal(jspin(nn, "z").full(), jz.full())
+            assert_array_almost_equal(jspin(nn, "+").full(), jp.full())
+            assert_array_almost_equal(jspin(nn, "-").full(), jm.full())
+            assert_raises(TypeError, jspin, nn, "q")
+
+    def test_j_min_(self):
+        """
+        PIQS: Test the `j_min` function.
+        """
+        even = [2, 4, 6, 8]
+        odd = [1, 3, 5, 7]
+
+        for i in even:
+            assert_(j_min(i) == 0)
+
+        for i in odd:
+            assert_(j_min(i) == 0.5)
+
+    def test_energy_degeneracy(self):
+        """
+        PIQS: Test the energy degeneracy (m) of Dicke state | j, m >.
+        """
+        true_en_deg = [1, 1, 1, 1, 1]
+        true_en_deg_even = [2, 6, 20]
+        true_en_deg_odd = [1, 1, 3, 3, 35, 35]
+        test_en_deg = []
+        test_en_deg_even = []
+        test_en_deg_odd = []
+
+        for nn in [1, 2, 3, 4, 7]:
+            test_en_deg.append(energy_degeneracy(nn, nn / 2))
+
+        for nn in [2, 4, 6]:
+            test_en_deg_even.append(energy_degeneracy(nn, 0))
+
+        for nn in [1, 3, 7]:
+            test_en_deg_odd.append(energy_degeneracy(nn, 1 / 2))
+            test_en_deg_odd.append(energy_degeneracy(nn, -1 / 2))
+
+        assert_array_equal(test_en_deg, true_en_deg)
+        assert_array_equal(test_en_deg_even, true_en_deg_even)
+        assert_array_equal(test_en_deg_odd, true_en_deg_odd)
+
+    def test_state_degeneracy(self):
+        """
+        PIQS: Test the calculation of the degeneracy of the Dicke state |j, m>,
+        state_degeneracy(N, j).
+        """
+        true_state_deg = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 14, 14, 42, 42]
+        state_deg = []
+        state_deg = []
+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+            state_deg.append(state_degeneracy(nn, nn / 2))
+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+            state_deg.append(state_degeneracy(nn, (nn / 2) % 1))
+        assert_array_equal(state_deg, true_state_deg)
+
+        # check error
+        assert_raises(ValueError, state_degeneracy, 2, -1)
+
+    def test_m_degeneracy(self):
+        """
+        PIQS: Test the degeneracy of TLS states with same m eigenvalue.
+        """
+        true_m_deg = [1, 2, 2, 3, 4, 5, 5, 6]
+        m_deg = []
+        for nn in [1, 2, 3, 4, 7, 8, 9, 10]:
+            m_deg.append(m_degeneracy(nn, -(nn / 2) % 1))
+        assert_array_equal(m_deg, true_m_deg)
+
+        # check error
+        assert_raises(ValueError, m_degeneracy, 6, -6)
+
+    def test_ap(self):
+        """
+        PIQS: Test the calculation of the real coefficient A_{+}(j,m).
+
+        For given values of j, m. For a Dicke state,
+        J_{+} |j, m> = A_{+}(j,m) |j, m + 1>.
+        """
+        true_ap_list = [110, 108, 104, 98, 90, 54, 38, 20, 0]
+        ap_list = []
+        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
+            ap_list.append(ap(10, m) ** 2)
+
+        assert_almost_equal(ap_list, true_ap_list)
+
+    def test_am(self):
+        """
+        PIQS: Test the calculation of the real coefficient A_{-}(j,m).
+
+        For a Dicke state,  J_{-} |j, m> = A_{+}(j,m) |j, m - 1>.
+        """
+        true_am_list = [110, 110, 108, 104, 98, 68, 54, 38, 20]
+        am_list = []
+        for m in [0, 1, 2, 3, 4, 7, 8, 9, 10]:
+            am_list.append(am(10, m) ** 2)
+
+        assert_almost_equal(am_list, true_am_list)
+
+    def test_spin_algebra(self):
+        """
+        PIQS: Test the function that creates the SU2 algebra in uncoupled basis.
+        The list [sx, sy, sz, sp, sm] is checked for N = 2.
+        """
+        sx1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sx2 = [
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sy1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sy2 = [
+            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.0j],
+        ]
+
+        sz1 = [
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
+        ]
+
+        sz2 = [
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, -0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -0.5 + 0.0j],
+        ]
+
+        sp1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sp2 = [
+            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sm1 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        sm2 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        assert_array_equal(spin_algebra(2, "x")[0].full(), sx1)
+        assert_array_equal(spin_algebra(2, "x")[1].full(), sx2)
+        assert_array_equal(spin_algebra(2, "y")[0].full(), sy1)
+        assert_array_equal(spin_algebra(2, "y")[1].full(), sy2)
+        assert_array_equal(spin_algebra(2, "z")[0].full(), sz1)
+        assert_array_equal(spin_algebra(2, "z")[1].full(), sz2)
+        assert_array_equal(spin_algebra(2, "+")[0].full(), sp1)
+        assert_array_equal(spin_algebra(2, "+")[1].full(), sp2)
+        assert_array_equal(spin_algebra(2, "-")[0].full(), sm1)
+        assert_array_equal(spin_algebra(2, "-")[1].full(), sm2)
+
+        # test error
+        assert_raises(TypeError, spin_algebra, 2, "q")
+
+    def test_collective_algebra(self):
+        """
+        PIQS: Test the generation of the collective algebra in uncoupled basis.
+
+        The list [jx, jy, jz] created in the 2^N Hilbert space is
+        checked for N = 2.
+        """
+
+        jx_n2 = [
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.5 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.5 + 0.0j],
+            [0.0 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        jy_n2 = [
+            [0.0 + 0.0j, 0.0 - 0.5j, 0.0 - 0.5j, 0.0 + 0.0j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.5j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 - 0.5j],
+            [0.0 + 0.0j, 0.0 + 0.5j, 0.0 + 0.5j, 0.0 + 0.0j],
+        ]
+
+        jz_n2 = [
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j],
+        ]
+
+        jp_n2 = [
+            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j],
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        jm_n2 = [
+            [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j],
+            [0.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j],
+        ]
+
+        assert_array_equal(jspin(2, "x", basis="uncoupled").full(), jx_n2)
+        assert_array_equal(jspin(2, "y", basis="uncoupled").full(), jy_n2)
+        assert_array_equal(jspin(2, "z", basis="uncoupled").full(), jz_n2)
+        assert_array_equal(jspin(2, "+", basis="uncoupled").full(), jp_n2)
+        assert_array_equal(jspin(2, "-", basis="uncoupled").full(), jm_n2)
+
+        # error
+        assert_raises(TypeError, spin_algebra, 2, "q")
+
+    def test_block_matrix(self):
+        """
+        PIQS: Test the calculation of the block-diagonal matrix for given N.
+
+        If the matrix element |j,m><j,m'| is allowed it is 1, otherwise 0.
+        """
+        # N = 1 TLSs
+        block_1 = [[1.0, 1.0], [1.0, 1.0]]
+
+        # N = 2 TLSs
+        block_2 = [
+            [1.0, 1.0, 1.0, 0.0],
+            [1.0, 1.0, 1.0, 0.0],
+            [1.0, 1.0, 1.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0],
+        ]
+
+        # N = 3 TLSs
+        block_3 = [
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0, 0.0, 1.0, 1.0],
+        ]
+
+        assert_equal(Qobj(block_1), Qobj(block_matrix(1)))
+        assert_equal(Qobj(block_2), Qobj(block_matrix(2)))
+        assert_equal(Qobj(block_3), Qobj(block_matrix(3)))
+
+    def test_dicke_basis(self):
+        """
+        PIQS: Test if the Dicke basis (j, m, m') is constructed correctly.
+
+        We test the state with for N = 2,
+
+        0   0   0.3 0
+        0   0.5 0   0
+        0.3 0   0   0
+        0   0   0   0.5
+        """
+        N = 2
+        true_dicke_basis = np.zeros((4, 4))
+        true_dicke_basis[1, 1] = 0.5
+        true_dicke_basis[-1, -1] = 0.5
+        true_dicke_basis[0, 2] = 0.3
+        true_dicke_basis[2, 0] = 0.3
+        true_dicke_basis = Qobj(true_dicke_basis)
+        jmm1_1 = {(N / 2, 0, 0): 0.5}
+        jmm1_2 = {(0, 0, 0): 0.5}
+        jmm1_3 = {(N / 2, N / 2, N / 2 - 2): 0.3}
+        jmm1_4 = {(N / 2, N / 2 - 2, N / 2): 0.3}
+        db1 = dicke_basis(2, jmm1_1)
+        db2 = dicke_basis(2, jmm1_2)
+        db3 = dicke_basis(2, jmm1_3)
+        db4 = dicke_basis(2, jmm1_4)
+        test_dicke_basis = db1 + db2 + db3 + db4
+        assert_equal(test_dicke_basis, true_dicke_basis)
+
+        # error
+        assert_raises(AttributeError, dicke_basis, N)
+
+    def test_dicke(self):
+        """
+        PIQS: Test the calculation of the Dicke state as a pure state.
+        """
+        true_excited = np.zeros((4, 4))
+        true_excited[0, 0] = 1
+
+        true_superradiant = np.zeros((4, 4))
+        true_superradiant[1, 1] = 1
+
+        true_subradiant = np.zeros((4, 4))
+        true_subradiant[-1, -1] = 1
+
+        test_excited = dicke(2, 1, 1)
+        test_superradiant = dicke(2, 1, 0)
+        test_subradiant = dicke(2, 0, 0)
+
+        assert_equal(test_excited, Qobj(true_excited))
+        assert_equal(test_superradiant, Qobj(true_superradiant))
+        assert_equal(test_subradiant, Qobj(true_subradiant))
+
+    def test_excited(self):
+        """
+        PIQS: Test the calculation of the totally excited state density matrix.
+
+        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
+        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
+        """
+        N = 3
+        true_state = np.zeros((6, 6))
+        true_state[0, 0] = 1
+        true_state = Qobj(true_state)
+
+        test_state = excited(N)
+        assert_equal(test_state, true_state)
+
+        N = 4
+        true_state = np.zeros((9, 9))
+        true_state[0, 0] = 1
+        true_state = Qobj(true_state)
+
+        test_state = excited(N)
+        assert_equal(test_state, true_state)
+
+        # uncoupled
+        test_state_uncoupled = excited(2, basis="uncoupled")
+        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
+        assert_array_equal(test_state_uncoupled.shape, (4, 4))
+        assert_almost_equal(test_state_uncoupled.full()[0, 0], 1 + 0j)
+
+    def test_superradiant(self):
+        """
+        PIQS: Test the calculation of the superradiant state density matrix.
+
+        The state is |N/2, 0> for N even and |N/2, 0.5> for N odd.
+        The matrix has size (O(N^2), O(N^2)) in Dicke basis ('dicke').
+        The matrix has size (2^N, 2^N) in the uncoupled basis ('uncoupled').
+        """
+        N = 3
+        true_state = np.zeros((6, 6))
+        true_state[1, 1] = 1
+        true_state = Qobj(true_state)
+        test_state = superradiant(N)
+        assert_equal(test_state, true_state)
+        N = 4
+        true_state = np.zeros((9, 9))
+        true_state[2, 2] = 1
+        true_state = Qobj(true_state)
+        test_state = superradiant(N)
+        assert_equal(test_state, true_state)
+
+        # uncoupled
+        test_state_uncoupled = superradiant(2, basis="uncoupled")
+        assert_array_equal(test_state_uncoupled.dims, [[2, 2], [2, 2]])
+        assert_array_equal(test_state_uncoupled.shape, (4, 4))
+        assert_almost_equal(test_state_uncoupled.full()[1, 1], 1 + 0j)
+
+    def test_ghz(self):
+        """
+        PIQS: Test the calculation of the density matrix of the GHZ state.
+
+        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
+        """
+        ghz_dicke = Qobj(
+            [[0.5, 0, 0.5, 0], [0, 0, 0, 0], [0.5, 0, 0.5, 0], [0, 0, 0, 0]]
+        )
+        ghz_uncoupled = Qobj(
+            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
+        )
+        ghz_uncoupled.dims = [[2, 2], [2, 2]]
+        assert_equal(ghz(2), ghz_dicke)
+        assert_equal(ghz(2, "uncoupled"), ghz_uncoupled)
+
+    def test_ground(self):
+        """
+        PIQS: Test the calculation of the density matrix of the ground state.
+
+        PIQS: Test for N = 2 in the 'dicke' and in the 'uncoupled' basis.
+        """
+        zeros = np.zeros((4, 4), dtype=np.complex128)
+        gdicke = zeros.copy()
+        guncoupled = zeros.copy()
+        gdicke[2, 2] = 1
+        guncoupled[3, 3] = 1
+
+        dim_dicke = [[4], [4]]
+        dim_uncoupled = [[2, 2], [2, 2]]
+
+        test_ground_dicke = ground(2)
+        test_ground_uncoupled = ground(2, "uncoupled")
+
+        assert_array_equal(test_ground_dicke.full(), gdicke)
+        assert_array_equal(test_ground_dicke.dims, dim_dicke)
+        assert_array_equal(test_ground_uncoupled.full(), guncoupled)
+        assert_array_equal(test_ground_uncoupled.dims, dim_uncoupled)
+
+    def test_identity_uncoupled(self):
+        """
+        PIQS: Test the calculation of the identity in a 2^N dim Hilbert space.
+        """
+        test_identity = identity_uncoupled(4)
+        assert_equal(test_identity.dims, [[2, 2, 2, 2], [2, 2, 2, 2]])
+        assert_array_equal(
+            np.diag(test_identity.full()), np.ones(16, np.complex128)
+        )
+
+    def test_css(self):
+        """
+        PIQS: Test the calculation of the CSS state.
+        """
+        test_css_uncoupled = css(2, basis="uncoupled")
+        test_css_dicke = css(2)
+        css_uncoupled = 0.25 * np.ones((4, 4), dtype=np.complex128)
+        css_dicke = np.array(
+            [
+                [
+                    0.25000000 + 0.0j,
+                    0.35355339 + 0.0j,
+                    0.25000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+                [
+                    0.35355339 + 0.0j,
+                    0.50000000 + 0.0j,
+                    0.35355339 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+                [
+                    0.25000000 + 0.0j,
+                    0.35355339 + 0.0j,
+                    0.25000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+                [
+                    0.00000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                    0.00000000 + 0.0j,
+                ],
+            ]
+        )
+        assert_array_almost_equal(test_css_uncoupled.full(), css_uncoupled)
+        assert_array_almost_equal(test_css_dicke.full(), css_dicke)
+
+    def test_collapse_uncoupled(self):
+        """
+        PIQS: Test the calculation of the correct collapse operators (c_ops) list.
+
+        In the "uncoupled" basis of N two-level system (TLS).
+        The test is performed for N = 2 and emission = 1.
+        """
+        c1 = Qobj(
+            [[0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]],
+            dims=[[2, 2], [2, 2]],
+        )
+        c2 = Qobj(
+            [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0]],
+            dims=[[2, 2], [2, 2]],
+        )
+        true_c_ops = [c1, c2]
+        assert_equal(true_c_ops, collapse_uncoupled(N=2, emission=1))
+        system = Dicke(N=2, emission=1)
+        assert_equal(true_c_ops, system.c_ops())
+
+    def test_get_blocks(self):
+        """
+        PIQS: Test the calculation of list of cumulative elements at each block.
+
+        For N = 4
+
+        1 1 1 1 1
+        1 1 1 1 1
+        1 1 1 1 1
+        1 1 1 1 1
+        1 1 1 1 1
+                1 1 1
+                1 1 1
+                1 1 1
+                     1
+        Thus, the blocks are [5, 8, 9] denoting that after the first block 5
+        elements have been accounted for and so on.
+        """
+        trueb1 = [2]
+        trueb2 = [3, 4]
+        trueb3 = [4, 6]
+        trueb4 = [5, 8, 9]
+
+        test_b1 = get_blocks(1)
+        test_b2 = get_blocks(2)
+        test_b3 = get_blocks(3)
+        test_b4 = get_blocks(4)
+
+        assert_equal(test_b1, trueb1)
+        assert_equal(test_b2, trueb2)
+        assert_equal(test_b3, trueb3)
+
+    def test_lindbladian_dims(self):
+        """
+        PIQS: Test the calculation of the lindbladian matrix.
+        """
+        true_L = [
+            [-4, 0, 0, 3],
+            [0, -3.54999995, 0, 0],
+            [0, 0, -3.54999995, 0],
+            [4, 0, 0, -3],
+        ]
+        true_L = Qobj(true_L)
+        true_L.dims = [[[2], [2]], [[2], [2]]]
+        N = 1
+        test_dicke = _Dicke(
+            N=N,
+            pumping=1,
+            collective_pumping=2,
+            emission=1,
+            collective_emission=3,
+            dephasing=0.1,
+        )
+        test_L = test_dicke.lindbladian()
+        assert_array_almost_equal(test_L.full(), true_L.full())
+        assert_array_equal(test_L.dims, true_L.dims)
+
+    def test_liouvillian(self):
+        """
+        PIQS: Test the calculation of the liouvillian matrix.
+        """
+        true_L = [
+            [-4, 0, 0, 3],
+            [0, -3.54999995, 0, 0],
+            [0, 0, -3.54999995, 0],
+            [4, 0, 0, -3],
+        ]
+        true_L = Qobj(true_L)
+        true_L.dims = [[[2], [2]], [[2], [2]]]
+        true_H = [[1.0 + 0.0j, 1.0 + 0.0j], [1.0 + 0.0j, -1.0 + 0.0j]]
+        true_H = Qobj(true_H)
+        true_H.dims = [[[2], [2]]]
+        true_liouvillian = [
+            [-4, -1.0j, 1.0j, 3],
+            [-1.0j, -3.54999995 + 2.0j, 0, 1.0j],
+            [1.0j, 0, -3.54999995 - 2.0j, -1.0j],
+            [4, +1.0j, -1.0j, -3],
+        ]
+        true_liouvillian = Qobj(true_liouvillian)
+        true_liouvillian.dims = [[[2], [2]], [[2], [2]]]
+        N = 1
+        test_piqs = Dicke(
+            hamiltonian=sigmaz() + sigmax(),
+            N=N,
+            pumping=1,
+            collective_pumping=2,
+            emission=1,
+            collective_emission=3,
+            dephasing=0.1,
+        )
+        test_liouvillian = test_piqs.liouvillian()
+        test_hamiltonian = test_piqs.hamiltonian
+        assert_array_almost_equal(
+            test_liouvillian.full(), true_liouvillian.full()
+        )
+        assert_array_almost_equal(test_hamiltonian.full(), true_H.full())
+        assert_array_equal(test_liouvillian.dims, test_liouvillian.dims)
+
+        # no Hamiltonian
+        test_piqs = Dicke(
+            N=N,
+            pumping=1,
+            collective_pumping=2,
+            emission=1,
+            collective_emission=3,
+            dephasing=0.1,
+        )
+        liouv = test_piqs.liouvillian()
+        lindblad = test_piqs.lindbladian()
+        assert_equal(liouv, lindblad)
+
+    def test_gamma1(self):
+        """
+        PIQS: Test the calculation of gamma1.
+        """
+        true_gamma_1 = -2
+        true_gamma_2 = -3
+        true_gamma_3 = -7
+        true_gamma_4 = -1
+        true_gamma_5 = 0
+        true_gamma_6 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, collective_emission=1)
+        test_gamma_1 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1)
+        test_gamma_2 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_3 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, dephasing=4)
+        test_gamma_4 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_pumping=2)
+        test_gamma_5 = test_dicke.gamma1((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_dephasing=2)
+        test_gamma_6 = test_dicke.gamma1((1, 1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+        assert_almost_equal(true_gamma_5, test_gamma_5)
+        assert_almost_equal(true_gamma_6, test_gamma_6)
+
+    def test_gamma2(self):
+        """
+        PIQS: Test the calculation of gamma2. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 2
+        true_gamma_2 = 1.5
+        true_gamma_3 = 5.5
+        true_gamma_4 = 0
+        true_gamma_5 = 0
+        true_gamma_6 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, collective_emission=1)
+        test_gamma_1 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1)
+        test_gamma_2 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_3 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, dephasing=4)
+        test_gamma_4 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_pumping=2)
+        test_gamma_5 = test_dicke.gamma2((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_dephasing=2)
+        test_gamma_6 = test_dicke.gamma2((1, 1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+        assert_almost_equal(true_gamma_5, test_gamma_5)
+        assert_almost_equal(true_gamma_6, test_gamma_6)
+
+    def test_gamma3(self):
+        """
+        PIQS: Test the calculation of gamma3. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 1.3333333730697632
+        true_gamma_3 = 1.3333333730697632
+        true_gamma_4 = 0
+        true_gamma_5 = 0
+        true_gamma_6 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, collective_emission=1)
+        test_gamma_1 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1)
+        test_gamma_2 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_3 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, dephasing=4)
+        test_gamma_4 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_pumping=2)
+        test_gamma_5 = test_dicke.gamma3((1, 1, 1))
+        test_dicke = _Dicke(N=N, collective_dephasing=2)
+        test_gamma_6 = test_dicke.gamma3((1, 1, 1))
+        #
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+        assert_almost_equal(true_gamma_5, test_gamma_5)
+        assert_almost_equal(true_gamma_6, test_gamma_6)
+
+    def test_gamma4(self):
+        """
+        PIQS: Test the calculation of gamma4. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0.1666666716337204
+        true_gamma_2 = 2
+        true_gamma_3 = 0
+        true_gamma_4 = 0.40824830532073975
+
+        N = 4
+        test_dicke = _Dicke(N=N, emission=1, collective_emission=2)
+        test_gamma_1 = test_dicke.gamma4((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma4((0, 0, 0))
+        test_gamma_3 = test_dicke.gamma4((2, 1, 1))
+        test_gamma_4 = test_dicke.gamma4((1, -1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma5(self):
+        """
+        PIQS: Test the calculation of gamma5. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 0
+        true_gamma_3 = 0.75
+        true_gamma_4 = 0
+
+        N = 4
+        test_dicke = _Dicke(N=N, dephasing=1)
+        test_gamma_1 = test_dicke.gamma5((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma5((0, 0, 0))
+        test_gamma_3 = test_dicke.gamma5((2, 1, 1))
+        test_gamma_4 = test_dicke.gamma5((1, -1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma6(self):
+        """
+        PIQS: Test the calculation of gamma6. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0.25
+        true_gamma_2 = 1
+        true_gamma_3 = 0
+        true_gamma_4 = 0.25
+
+        N = 4
+        test_dicke = _Dicke(N=N, dephasing=1)
+        test_gamma_1 = test_dicke.gamma6((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma6((0, 0, 0))
+        test_gamma_3 = test_dicke.gamma6((2, 1, 1))
+        test_gamma_4 = test_dicke.gamma6((1, -1, 1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma7(self):
+        """
+        PIQS: Test the calculation of gamma7. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 0.5
+        true_gamma_3 = 0
+        true_gamma_4 = 1.5
+
+        N = 4
+        test_dicke = _Dicke(N=N, pumping=1)
+        test_gamma_1 = test_dicke.gamma7((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma7((2, 0, 0))
+        test_gamma_3 = test_dicke.gamma7((1, 0, 0))
+        test_gamma_4 = test_dicke.gamma7((2, -1, -1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma8(self):
+        """
+        PIQS: Test the calculation of gamma8. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 0
+        true_gamma_2 = 13.5
+        true_gamma_3 = 5.5
+        true_gamma_4 = 13.5
+
+        N = 4
+        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
+        test_gamma_1 = test_dicke.gamma8((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma8((2, 0, 0))
+        test_gamma_3 = test_dicke.gamma8((1, 0, 0))
+        test_gamma_4 = test_dicke.gamma8((2, -1, -1))
+
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+    def test_gamma9(self):
+        """
+        PIQS: Test the calculation of gamma9. PIQS: Test performed for N = 4.
+        """
+        true_gamma_1 = 1
+        true_gamma_2 = 0
+        true_gamma_3 = 0.5
+        true_gamma_4 = 0
+        N = 4
+        test_dicke = _Dicke(N=N, pumping=1, collective_pumping=2)
+        test_gamma_1 = test_dicke.gamma9((1, 1, 1))
+        test_gamma_2 = test_dicke.gamma9((2, 0, 0))
+        test_gamma_3 = test_dicke.gamma9((1, 0, 0))
+        test_gamma_4 = test_dicke.gamma9((2, -1, -1))
+        assert_almost_equal(true_gamma_1, test_gamma_1)
+        assert_almost_equal(true_gamma_2, test_gamma_2)
+        assert_almost_equal(true_gamma_3, test_gamma_3)
+        assert_almost_equal(true_gamma_4, test_gamma_4)
+
+
+class TestPim:
+    """
+    Tests for the `qutip.piqs.Pim` class.
+    """
+
+    def test_gamma(self):
+        """
+        PIQS: Test the calculation of various gamma values for diagonal system.
+
+        For N = 6 |j, m> would be :
+
+        | 3, 3>
+        | 3, 2> | 2, 2>
+        | 3, 1> | 2, 1> | 1, 1>
+        | 3, 0> | 2, 0> | 1, 0> |0, 0>
+        | 3,-1> | 2,-1> | 1,-1>
+        | 3,-2> | 2,-2>
+        | 3,-3>
+        """
+        N = 6
+        collective_emission = 1.0
+        emission = 1.0
+        dephasing = 1.0
+        pumping = 1.0
+        collective_pumping = 1.0
+        model = Pim(
+            N,
+            collective_emission=collective_emission,
+            emission=emission,
+            dephasing=dephasing,
+            pumping=pumping,
+            collective_pumping=collective_pumping,
+        )
+        tau_calculated = [
+            model.tau3(3, 1),
+            model.tau2(2, 1),
+            model.tau4(1, 1),
+            model.tau5(3, 0),
+            model.tau1(2, 0),
+            model.tau6(1, 0),
+            model.tau7(3, -1),
+            model.tau8(2, -1),
+            model.tau9(1, -1),
+        ]
+        tau_real = [
+            2.0,
+            8.0,
+            0.333333,
+            1.5,
+            -19.5,
+            0.666667,
+            2.0,
+            8.0,
+            0.333333,
+        ]
+        assert_array_almost_equal(tau_calculated, tau_real)
+
+    def test_isdicke(self):
+        """
+        PIQS: Test the `isdicke` function
+        """
+        N1 = 1
+        g0 = 0.01
+        nth = 0.01
+        gP = g0 * nth
+        gL = g0 * (0.1 + nth)
+        gS = 0.1
+        gD = 0.1
+
+        pim1 = Pim(N1, gS, gL, gD, gP)
+
+        test_indices1 = [(0, 0), (0, 1), (1, 0), (-1, -1), (2, -1)]
+        dicke_labels = [pim1.isdicke(x[0], x[1]) for x in test_indices1]
+
+        N2 = 4
+
+        pim2 = Pim(N2, gS, gL, gD, gP)
+        test_indices2 = [(0, 0), (4, 4), (2, 0), (1, 3), (2, 2)]
+        dicke_labels = [pim2.isdicke(x[0], x[1]) for x in test_indices2]
+
+        assert_array_equal(dicke_labels, [True, False, True, False, True])
+
+    def test_isdiagonal(self):
+        """
+        PIQS: Test the isdiagonal function.
+        """
+        mat1 = np.array([[1, 2], [3, 4]])
+        mat2 = np.array([[1, 0.0], [0.0, 2]])
+        mat3 = np.array([[1 + 1j, 0.0], [0.0 - 2j, 2 - 2j]])
+        mat4 = np.array([[1 + 1j, 0.0], [0.0, 2 - 2j]])
+        assert_equal(isdiagonal(mat1), False)
+        assert_equal(isdiagonal(mat2), True)
+        assert_equal(isdiagonal(mat3), False)
+        assert_equal(isdiagonal(mat4), True)
+
+    def test_pisolve(self):
+        """
+        PIQS: Test the warning for diagonal Hamiltonians to use internal solver
+        """
+        jx, jy, jz = jspin(4)
+        jp, jm = jspin(4, "+"), jspin(4, "-")
+
+    def test_coefficient_matrix(self):
+        """
+        PIQS: Test the coefficient matrix used by 'pisolve' for diagonal problems.
+        """
+        N = 2
+        ensemble = Pim(N, emission=1)
+        test_matrix = ensemble.coefficient_matrix().toarray()
+        ensemble2 = Dicke(N, emission=1)
+        test_matrix2 = ensemble.coefficient_matrix().toarray()
+        true_matrix = [
+            [-2, 0, 0, 0],
+            [1, -1, 0, 0],
+            [0, 1, 0, 1.0],
+            [1, 0, 0, -1.0],
+        ]
+
+        assert_array_almost_equal(test_matrix, true_matrix)
+        assert_array_almost_equal(test_matrix2, true_matrix)
+
+    def test_pisolve(self):
+        """
+        PIQS: Test the warning for diagonal Hamiltonians to use internal solver.
+        """
+        jx, jy, jz = jspin(4)
+        jp, jm = jspin(4, "+"), jspin(4, "-")
+        non_diag_hamiltonian = jx
+        diag_hamiltonian = jz
+
+        non_diag_system = Dicke(4, non_diag_hamiltonian, emission=0.1)
+        diag_system = Dicke(4, diag_hamiltonian, emission=0.1)
+
+        diag_initial_state = dicke(4, 1, 0)
+        non_diag_initial_state = ghz(4)
+        tlist = np.linspace(0, 10, 100)
+
+        assert_raises(
+            ValueError, non_diag_system.pisolve, diag_initial_state, tlist
+        )
+        assert_raises(
+            ValueError, non_diag_system.pisolve, non_diag_initial_state, tlist
+        )
+        assert_raises(
+            ValueError, diag_system.pisolve, non_diag_initial_state, tlist
+        )
+
+        non_dicke_initial_state = excited(4, basis="uncoupled")
+        assert_raises(
+            ValueError, diag_system.pisolve, non_dicke_initial_state, tlist
+        )
+
+        # no Hamiltonian
+        no_hamiltonian_system = Dicke(4, emission=0.1)
+        result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
+        assert_equal(True, len(result.states) > 0)
+
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/solve/test_qubit_evolution.py b/qutip/tests/solve/test_qubit_evolution.py
index 7157e3ffac..d75697f9df 100644
--- a/qutip/tests/solve/test_qubit_evolution.py
+++ b/qutip/tests/solve/test_qubit_evolution.py
@@ -1,124 +1,124 @@
-import numpy as np
-import pytest
-from qutip import (
-    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
-)
-
-
-def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
-
-    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
-
-    c_op_list = []
-
-    rate = g1
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sigmam())
-
-    rate = g2
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sigmaz())
-
-    e_ops = [sigmax(), sigmay(), sigmaz()]
-
-    if solver == "me":
-        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
-    elif solver == "mc":
-        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
-    else:
-        raise ValueError("unknown solver")
-
-    return output.expect[0], output.expect[1], output.expect[2]
-
-
-def test_MESolverCase1():
-    """
-    Test mesolve qubit, with dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi   # cavity frequency
-    delta = 1.0 * 2 * np.pi   # atom frequency
-    g2 = 0.1
-    g1 = 0.0
-    psi0 = basis(2, 0)        # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.05
-    assert max(abs(sy - sy_analytic)) < 0.05
-    assert max(abs(sz - sz_analytic)) < 0.05
-
-
-def test_MESolverCase2():
-    """
-    Test mesolve qubit, no dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi   # cavity frequency
-    delta = 1.0 * 2 * np.pi   # atom frequency
-    g2 = 0.0
-    g1 = 0.0
-    psi0 = basis(2, 0)        # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.05
-    assert max(abs(sy - sy_analytic)) < 0.05
-    assert max(abs(sz - sz_analytic)) < 0.05
-
-
-def test_MCSolverCase1():
-    """
-    Test mcsolve qubit, with dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi      # cavity frequency
-    delta = 1.0 * 2 * np.pi        # atom frequency
-    g2 = 0.1
-    g1 = 0.0
-    psi0 = basis(2, 0)          # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.25
-    assert max(abs(sy - sy_analytic)) < 0.25
-    assert max(abs(sz - sz_analytic)) < 0.25
-
-
-@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
-def test_MCSolverCase2():
-    """
-    Test mcsolve qubit, no dissipation
-    """
-
-    epsilon = 0.0 * 2 * np.pi      # cavity frequency
-    delta = 1.0 * 2 * np.pi        # atom frequency
-    g2 = 0.0
-    g1 = 0.0
-    psi0 = basis(2, 0)          # initial state
-    tlist = np.linspace(0, 5, 200)
-
-    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
-
-    sx_analytic = np.zeros(np.shape(tlist))
-    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-    assert max(abs(sx - sx_analytic)) < 0.25
-    assert max(abs(sy - sy_analytic)) < 0.25
-    assert max(abs(sz - sz_analytic)) < 0.25
+import numpy as np
+import pytest
+from qutip import (
+    sigmax, sigmay, sigmaz, sigmam, mesolve, mcsolve, basis,
+)
+
+
+def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):
+
+    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()
+
+    c_op_list = []
+
+    rate = g1
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sigmam())
+
+    rate = g2
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sigmaz())
+
+    e_ops = [sigmax(), sigmay(), sigmaz()]
+
+    if solver == "me":
+        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
+    elif solver == "mc":
+        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
+    else:
+        raise ValueError("unknown solver")
+
+    return output.expect[0], output.expect[1], output.expect[2]
+
+
+def test_MESolverCase1():
+    """
+    Test mesolve qubit, with dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi   # cavity frequency
+    delta = 1.0 * 2 * np.pi   # atom frequency
+    g2 = 0.1
+    g1 = 0.0
+    psi0 = basis(2, 0)        # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.05
+    assert max(abs(sy - sy_analytic)) < 0.05
+    assert max(abs(sz - sz_analytic)) < 0.05
+
+
+def test_MESolverCase2():
+    """
+    Test mesolve qubit, no dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi   # cavity frequency
+    delta = 1.0 * 2 * np.pi   # atom frequency
+    g2 = 0.0
+    g1 = 0.0
+    psi0 = basis(2, 0)        # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "me")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.05
+    assert max(abs(sy - sy_analytic)) < 0.05
+    assert max(abs(sz - sz_analytic)) < 0.05
+
+
+def test_MCSolverCase1():
+    """
+    Test mcsolve qubit, with dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi      # cavity frequency
+    delta = 1.0 * 2 * np.pi        # atom frequency
+    g2 = 0.1
+    g1 = 0.0
+    psi0 = basis(2, 0)          # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.25
+    assert max(abs(sy - sy_analytic)) < 0.25
+    assert max(abs(sz - sz_analytic)) < 0.25
+
+
+@pytest.mark.filterwarnings("ignore:No c_ops, using sesolve:UserWarning")
+def test_MCSolverCase2():
+    """
+    Test mcsolve qubit, no dissipation
+    """
+
+    epsilon = 0.0 * 2 * np.pi      # cavity frequency
+    delta = 1.0 * 2 * np.pi        # atom frequency
+    g2 = 0.0
+    g1 = 0.0
+    psi0 = basis(2, 0)          # initial state
+    tlist = np.linspace(0, 5, 200)
+
+    sx, sy, sz = _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, "mc")
+
+    sx_analytic = np.zeros(np.shape(tlist))
+    sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+    sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+    assert max(abs(sx - sx_analytic)) < 0.25
+    assert max(abs(sy - sy_analytic)) < 0.25
+    assert max(abs(sz - sz_analytic)) < 0.25
diff --git a/qutip/tests/solve/test_stochastic_me.py b/qutip/tests/solve/test_stochastic_me.py
index f282254bc7..27ac7c821a 100644
--- a/qutip/tests/solve/test_stochastic_me.py
+++ b/qutip/tests/solve/test_stochastic_me.py
@@ -1,309 +1,309 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-
-from qutip import (
-    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
-    destroy, coherent, qeye, fock_dm, general_stochastic, num,
-)
-from qutip.solve.parallel import parallel_map
-from qutip.core import data as _data
-def f(t, args):
-    return args["a"] * t
-
-
-@pytest.mark.slow
-def test_smesolve_homodyne_methods():
-    "Stochastic: smesolve: homodyne methods with single jump operator"
-
-    def arccoth(x):
-        return 0.5*np.log((1.+x)/(x-1.))
-
-    th = 0.1 # Interaction parameter
-    alpha = np.cos(th)
-    beta = np.sin(th)
-    gamma = 1.
-
-    N = 30                 # number of Fock states
-    Id = qeye(N)
-    a = destroy(N)
-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-    x = (a + a.dag()) * 2**-0.5
-    H = Id
-    c_op = [gamma**0.5 * a]
-    sc_op = [s]
-    e_op = [x, x*x]
-    rho0 = fock_dm(N,0)      # initial vacuum state
-
-    T = 3.                   # final time
-    # number of time steps for which we save the expectation values
-    N_store = 121
-    Nsub = 10
-    tlist = np.linspace(0, T, N_store)
-    ddt = (tlist[1]-tlist[0])
-
-    #### Analytic solution
-    y0 = 0.5
-    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
-    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
-    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
-
-
-    list_methods_tol = [['euler-maruyama', 2e-2],
-                        ['pc-euler', 2e-3],
-                        ['pc-euler-2', 2e-3],
-                        ['platen', 1e-3],
-                        ['milstein', 1e-3],
-                        ['milstein-imp', 1e-3],
-                        ['rouchon', 1e-3],
-                        ['taylor1.5', 1e-4],
-                        ['taylor1.5-imp', 1e-4],
-                        ['explicit1.5', 1e-4],
-                        ['taylor2.0', 1e-4]]
-    for n_method in list_methods_tol:
-        # Comparisons of error between sol and sol3 depend on the stochastic
-        # noise, thus the seed, fixing the seed remove random fails.
-        np.random.seed(1)
-        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
-        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
-                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
-                       noise = sol.noise)
-        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
-                        nsubsteps=Nsub*5, method='homodyne',
-                        solver = n_method[0], tol=1e-8)
-        err = 1/T * np.sum(np.abs(y_an - \
-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-        err3 = 1/T * np.sum(np.abs(y_an - \
-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
-        assert_(err < n_method[1])
-        # 5* more substep should decrease the error
-        assert_(err3 < err)
-        # just to check that noise is not affected by smesolve
-        assert_(np.all(sol.noise == sol2.noise))
-        assert_(np.all(sol.expect[0] == sol2.expect[0]))
-
-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=1)
-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=0)
-    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the same seed, sol3 differ.
-    assert_(np.all(sol.noise == sol2.noise))
-    assert_(np.all(sol.noise != sol3.noise))
-    assert_(not np.all(sol.measurement[0] == 0.+0j))
-    assert_(np.all(sol2.measurement[0] == 0.+0j))
-    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the seed of traj 1 and 2 reversed.
-    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
-    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
-
-
-def test_smesolve_photocurrent():
-    "Stochastic: photocurrent_mesolve"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
-                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
-                   map_func=parallel_map)
-
-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                 for idx in range(len(e_ops))]))
-    assert_(len(res.measurement) == ntraj)
-    assert_(all([m.shape == (len(times), len(sc_ops))
-                 for m in res.measurement]))
-
-
-def test_smesolve_homodyne():
-    "Stochastic: smesolve: homodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'pc-euler',
-                        'pc-euler-2',
-                        'platen',
-                        'milstein',
-                        'milstein-imp',
-                        'rouchon',
-                        'taylor15',
-                        'taylor15-imp',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-                       method='homodyne', store_measurement=True,
-                       solver=solver, map_func=parallel_map)
-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                     for idx in range(len(e_ops))]))
-        assert_(len(res.measurement) == ntraj)
-        assert_(all([m.shape == (len(times), len(sc_ops))
-                     for m in res.measurement]))
-
-
-@pytest.mark.slow
-def test_smesolve_heterodyne():
-    "Stochastic: smesolve: heterodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a, f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 1.0, 21)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'pc-euler',
-                        'pc-euler-2',
-                        'platen',
-                        'milstein',
-                        'milstein-imp',
-                        'rouchon',
-                        'taylor15',
-                        'taylor15-imp',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
-                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
-                       method='heterodyne', store_measurement=True,
-                       solver=solver, map_func=parallel_map)
-        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                     for idx in range(len(e_ops))]))
-        assert_(len(res.measurement) == ntraj)
-        assert_(all([m.shape == (len(times), len(sc_ops), 2)
-                     for m in res.measurement]))
-
-
-@pytest.mark.slow
-def test_general_stochastic():
-    "Stochastic: general_stochastic"
-    "Reproduce smesolve homodyne"
-    tol = 0.025
-    N = 4
-    gamma = 0.25
-    ntraj = 20
-    nsubsteps = 50
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
-    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
-    e_opsM = [spre(op) for op in e_ops]
-
-    def d1(t, vec):
-        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
-
-    def d2(t, vec):
-        out = []
-        vec_d = _data.Dense(vec)
-        for op in sc_opsM:
-            scale = -op.expect_data(t,vec_d)
-            out.append(
-                _data.add(op.matmul_data(t,vec_d),
-                          vec_d, scale)
-                )
-        return np.stack([o.to_array().ravel() for o in out])
-
-    times = np.linspace(0, 0.5, 13)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    list_methods_tol = ['euler-maruyama',
-                        'platen',
-                        'explicit15']
-    for solver in list_methods_tol:
-        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
-                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
-                                 nsubsteps=nsubsteps, solver=solver)
-    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
-                 for idx in range(len(e_ops))]))
-    assert_(len(res.measurement) == ntraj)
-
-
-def f_dargs(a, args):
-    return args["expect_op_3"] - 1
-
-
-@pytest.mark.xfail(reason="not working yet")
-def test_ssesolve_feedback():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [[a + a.dag(), f_dargs]]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-
-    times = np.linspace(0, 10, 101)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-                      args={"expect_op_3":qeye(N)})
-    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
-
-    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
-
-
-def test_smesolve_bad_e_ops():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [a + a.dag()]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
-
-    times = np.linspace(0, 10, 101)
-    with pytest.raises(TypeError) as exc:
-        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                       map_func=parallel_map)
+import pytest
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+
+from qutip import (
+    smesolve, mesolve, photocurrent_mesolve, liouvillian, QobjEvo, spre, spost,
+    destroy, coherent, qeye, fock_dm, general_stochastic, num,
+)
+from qutip.solve.parallel import parallel_map
+from qutip.core import data as _data
+def f(t, args):
+    return args["a"] * t
+
+
+@pytest.mark.slow
+def test_smesolve_homodyne_methods():
+    "Stochastic: smesolve: homodyne methods with single jump operator"
+
+    def arccoth(x):
+        return 0.5*np.log((1.+x)/(x-1.))
+
+    th = 0.1 # Interaction parameter
+    alpha = np.cos(th)
+    beta = np.sin(th)
+    gamma = 1.
+
+    N = 30                 # number of Fock states
+    Id = qeye(N)
+    a = destroy(N)
+    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
+    x = (a + a.dag()) * 2**-0.5
+    H = Id
+    c_op = [gamma**0.5 * a]
+    sc_op = [s]
+    e_op = [x, x*x]
+    rho0 = fock_dm(N,0)      # initial vacuum state
+
+    T = 3.                   # final time
+    # number of time steps for which we save the expectation values
+    N_store = 121
+    Nsub = 10
+    tlist = np.linspace(0, T, N_store)
+    ddt = (tlist[1]-tlist[0])
+
+    #### Analytic solution
+    y0 = 0.5
+    A = (gamma**2 + alpha**2 * (beta**2 + 4*gamma) - 2*alpha*beta*gamma)**0.5
+    B = arccoth((-4*alpha**2*y0 + alpha*beta - gamma)/A)
+    y_an = (alpha*beta - gamma + A / np.tanh(0.5*A*tlist - B))/(4*alpha**2)
+
+
+    list_methods_tol = [['euler-maruyama', 2e-2],
+                        ['pc-euler', 2e-3],
+                        ['pc-euler-2', 2e-3],
+                        ['platen', 1e-3],
+                        ['milstein', 1e-3],
+                        ['milstein-imp', 1e-3],
+                        ['rouchon', 1e-3],
+                        ['taylor1.5', 1e-4],
+                        ['taylor1.5-imp', 1e-4],
+                        ['explicit1.5', 1e-4],
+                        ['taylor2.0', 1e-4]]
+    for n_method in list_methods_tol:
+        # Comparisons of error between sol and sol3 depend on the stochastic
+        # noise, thus the seed, fixing the seed remove random fails.
+        np.random.seed(1)
+        sol = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
+                       nsubsteps=Nsub, method='homodyne', solver = n_method[0])
+        sol2 = smesolve(H, rho0, tlist, c_op, sc_op, e_op, store_measurement=0,
+                       nsubsteps=Nsub, method='homodyne', solver = n_method[0],
+                       noise = sol.noise)
+        sol3 = smesolve(H, rho0, tlist, c_op, sc_op, e_op,
+                        nsubsteps=Nsub*5, method='homodyne',
+                        solver = n_method[0], tol=1e-8)
+        err = 1/T * np.sum(np.abs(y_an - \
+                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
+        err3 = 1/T * np.sum(np.abs(y_an - \
+                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
+        print(n_method[0], ': deviation =', err, ', tol =', n_method[1])
+        assert_(err < n_method[1])
+        # 5* more substep should decrease the error
+        assert_(err3 < err)
+        # just to check that noise is not affected by smesolve
+        assert_(np.all(sol.noise == sol2.noise))
+        assert_(np.all(sol.expect[0] == sol2.expect[0]))
+
+    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=1)
+    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=0)
+    sol3 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=11, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the same seed, sol3 differ.
+    assert_(np.all(sol.noise == sol2.noise))
+    assert_(np.all(sol.noise != sol3.noise))
+    assert_(not np.all(sol.measurement[0] == 0.+0j))
+    assert_(np.all(sol2.measurement[0] == 0.+0j))
+    sol = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([1,2]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    sol2 = smesolve(H, rho0, tlist[:2], c_op, sc_op, e_op, noise=np.array([2,1]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the seed of traj 1 and 2 reversed.
+    assert_(np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:]))
+    assert_(np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:]))
+
+
+def test_smesolve_photocurrent():
+    "Stochastic: photocurrent_mesolve"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = photocurrent_mesolve(H, psi0, times, [], sc_ops, e_ops, args={"a":2},
+                   ntraj=ntraj, nsubsteps=nsubsteps,  store_measurement=True,
+                   map_func=parallel_map)
+
+    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                 for idx in range(len(e_ops))]))
+    assert_(len(res.measurement) == ntraj)
+    assert_(all([m.shape == (len(times), len(sc_ops))
+                 for m in res.measurement]))
+
+
+def test_smesolve_homodyne():
+    "Stochastic: smesolve: homodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    list_methods_tol = ['euler-maruyama',
+                        'pc-euler',
+                        'pc-euler-2',
+                        'platen',
+                        'milstein',
+                        'milstein-imp',
+                        'rouchon',
+                        'taylor15',
+                        'taylor15-imp',
+                        'explicit15']
+    for solver in list_methods_tol:
+        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
+                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
+                       method='homodyne', store_measurement=True,
+                       solver=solver, map_func=parallel_map)
+        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                     for idx in range(len(e_ops))]))
+        assert_(len(res.measurement) == ntraj)
+        assert_(all([m.shape == (len(times), len(sc_ops))
+                     for m in res.measurement]))
+
+
+@pytest.mark.slow
+def test_smesolve_heterodyne():
+    "Stochastic: smesolve: heterodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a, f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 1.0, 21)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    list_methods_tol = ['euler-maruyama',
+                        'pc-euler',
+                        'pc-euler-2',
+                        'platen',
+                        'milstein',
+                        'milstein-imp',
+                        'rouchon',
+                        'taylor15',
+                        'taylor15-imp',
+                        'explicit15']
+    for solver in list_methods_tol:
+        res = smesolve(H, psi0, times, [], sc_ops, e_ops,
+                       ntraj=ntraj, nsubsteps=nsubsteps, args={"a":2},
+                       method='heterodyne', store_measurement=True,
+                       solver=solver, map_func=parallel_map)
+        assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                     for idx in range(len(e_ops))]))
+        assert_(len(res.measurement) == ntraj)
+        assert_(all([m.shape == (len(times), len(sc_ops), 2)
+                     for m in res.measurement]))
+
+
+@pytest.mark.slow
+def test_general_stochastic():
+    "Stochastic: general_stochastic"
+    "Reproduce smesolve homodyne"
+    tol = 0.025
+    N = 4
+    gamma = 0.25
+    ntraj = 20
+    nsubsteps = 50
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops)
+    sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops]
+    e_opsM = [spre(op) for op in e_ops]
+
+    def d1(t, vec):
+        return L.matmul_data(t, _data.Dense(vec)).to_array().ravel()
+
+    def d2(t, vec):
+        out = []
+        vec_d = _data.Dense(vec)
+        for op in sc_opsM:
+            scale = -op.expect_data(t,vec_d)
+            out.append(
+                _data.add(op.matmul_data(t,vec_d),
+                          vec_d, scale)
+                )
+        return np.stack([o.to_array().ravel() for o in out])
+
+    times = np.linspace(0, 0.5, 13)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    list_methods_tol = ['euler-maruyama',
+                        'platen',
+                        'explicit15']
+    for solver in list_methods_tol:
+        res = general_stochastic(psi0.proj(), times, d1, d2, len_d2=2,
+                                 e_ops=e_opsM, normalize=False, ntraj=ntraj,
+                                 nsubsteps=nsubsteps, solver=solver)
+    assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol
+                 for idx in range(len(e_ops))]))
+    assert_(len(res.measurement) == ntraj)
+
+
+def f_dargs(a, args):
+    return args["expect_op_3"] - 1
+
+
+@pytest.mark.xfail(reason="not working yet")
+def test_ssesolve_feedback():
+    "Stochastic: ssesolve: time-dependent H with feedback"
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [[a + a.dag(), f_dargs]]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
+
+    times = np.linspace(0, 10, 101)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
+                      args={"expect_op_3":qeye(N)})
+    res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
+                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                   map_func=parallel_map, args={"expect_op_3":qeye(N)})
+
+    assert res.expect == pytest.approx(res_ref.expect, abs=tol)
+
+
+def test_smesolve_bad_e_ops():
+    "Stochastic: ssesolve: time-dependent H with feedback"
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [a + a.dag()]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N+1)]
+
+    times = np.linspace(0, 10, 101)
+    with pytest.raises(TypeError) as exc:
+        res = smesolve(H, psi0, times, sc_ops=sc_ops, e_ops=e_ops, noise=1,
+                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                       map_func=parallel_map)
diff --git a/qutip/tests/solve/test_stochastic_se.py b/qutip/tests/solve/test_stochastic_se.py
index e18ec023d5..8a40f2d756 100644
--- a/qutip/tests/solve/test_stochastic_se.py
+++ b/qutip/tests/solve/test_stochastic_se.py
@@ -1,230 +1,230 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_
-
-from qutip import (
-    ssesolve, destroy, coherent, mesolve, fock, qeye,
-    photocurrent_sesolve, num,
-)
-from qutip.solve.parallel import parallel_map
-
-def f(t, args):
-    return args["a"] * t
-
-
-@pytest.mark.slow
-def test_ssesolve_homodyne_methods():
-    "Stochastic: ssesolve: homodyne methods with single jump operator"
-
-    def arccoth(x):
-        return 0.5*np.log((1.+x)/(x-1.))
-
-    th = 0.1 # Interaction parameter
-    alpha = np.cos(th)
-    beta = np.sin(th)
-    gamma = 1.
-
-    N = 30                 # number of Fock states
-    Id = qeye(N)
-    a = destroy(N)
-    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
-    x = (a + a.dag()) * 2**-0.5
-    H = Id + gamma * a * a.dag()
-    sc_op = [s]
-    e_op = [x, x*x]
-    rho0 = fock(N,0)      # initial vacuum state
-
-    T = 6.                   # final time
-    # number of time steps for which we save the expectation values
-    N_store = 200
-    Nsub = 10
-    tlist = np.linspace(0, T, N_store)
-    ddt = (tlist[1]-tlist[0])
-
-    #### No analytic solution for ssesolve, taylor15 with 500 substep
-    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
-    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
-
-
-    list_methods_tol = [['euler-maruyama', 3e-2],
-                        ['pc-euler', 5e-3],
-                        ['pc-euler-2', 5e-3],
-                        ['platen', 5e-3],
-                        ['milstein', 5e-3],
-                        ['milstein-imp', 5e-3],
-                        ['taylor1.5', 5e-4],
-                        ['taylor1.5-imp', 5e-4],
-                        ['explicit1.5', 5e-4],
-                        ['taylor2.0', 5e-4]]
-    for n_method in list_methods_tol:
-        # Comparisons of error between sol and sol3 depend on the stochastic
-        # noise, thus the seed, fixing the seed remove random fails.
-        np.random.seed(1)
-        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
-        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
-                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
-                       noise = sol.noise)
-        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
-                        nsubsteps=Nsub*10, method='homodyne',
-                        solver=n_method[0], tol=1e-8)
-        err = 1/T * np.sum(np.abs(y_an - \
-                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
-        err3 = 1/T * np.sum(np.abs(y_an - \
-                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
-        assert err < n_method[1]
-        # 5* more substep should decrease the error
-        assert err3 < err
-        # just to check that noise is not affected by ssesolve
-        assert np.all(sol.noise == sol2.noise)
-        assert np.all(sol.expect[0] == sol2.expect[0])
-
-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=1)
-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler',
-                    store_measurement=0)
-    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
-                    nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the same seed, sol3 differ.
-    assert np.all(sol.noise == sol2.noise)
-    assert np.all(sol.noise != sol3.noise)
-    assert not np.all(sol.measurement[0] == 0.+0j)
-    assert np.all(sol2.measurement[0] == 0.+0j)
-    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
-                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
-    # sol and sol2 have the seed of traj 1 and 2 reversed.
-    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
-    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
-
-
-def test_ssesolve_photocurrent():
-    "Stochastic: photocurrent_sesolve"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
-                              nsubsteps=nsubsteps, store_measurement=True,
-                              map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
-
-
-def test_ssesolve_homodyne():
-    "Stochastic: ssesolve: homodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-                   ntraj=ntraj, nsubsteps=nsubsteps,
-                   method='homodyne', store_measurement=True,
-                   map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
-
-
-@pytest.mark.slow
-def test_ssesolve_heterodyne():
-    "Stochastic: ssesolve: heterodyne, time-dependent H"
-    tol = 0.01
-
-    N = 4
-    gamma = 0.25
-    ntraj = 25
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [[a.dag() * a,f]]
-    psi0 = coherent(N, 0.5)
-    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
-
-    times = np.linspace(0, 2.5, 50)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops,
-                   ntraj=ntraj, nsubsteps=nsubsteps,
-                   method='heterodyne', store_measurement=True,
-                   map_func=parallel_map, args={"a":2})
-
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-    assert len(res.measurement) == ntraj
-    assert all(m.shape == (len(times), len(sc_ops), 2)
-               for m in res.measurement)
-
-
-def f_dargs(t, args):
-    return args["expect_op_3"] - 1
-
-
-@pytest.mark.xfail(reason="not yet working")
-def test_ssesolve_feedback():
-    "Stochastic: ssesolve: time-dependent H with feedback"
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [[a + a.dag(), f_dargs]]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
-
-    times = np.linspace(0, 10, 101)
-    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
-                      args={"expect_op_3": qeye(N)})
-    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
-    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
-
-
-def test_ssesolve_bad_e_ops():
-    tol = 0.01
-    N = 4
-    ntraj = 10
-    nsubsteps = 100
-    a = destroy(N)
-    b = destroy(N-1)
-
-    H = [num(N)]
-    psi0 = coherent(N, 2.5)
-    sc_ops = [a + a.dag()]
-    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
-    times = np.linspace(0, 10, 101)
-    with pytest.raises(TypeError) as exc:
-        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
-                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
-                       map_func=parallel_map)
+import pytest
+import numpy as np
+from numpy.testing import assert_
+
+from qutip import (
+    ssesolve, destroy, coherent, mesolve, fock, qeye,
+    photocurrent_sesolve, num,
+)
+from qutip.solve.parallel import parallel_map
+
+def f(t, args):
+    return args["a"] * t
+
+
+@pytest.mark.slow
+def test_ssesolve_homodyne_methods():
+    "Stochastic: ssesolve: homodyne methods with single jump operator"
+
+    def arccoth(x):
+        return 0.5*np.log((1.+x)/(x-1.))
+
+    th = 0.1 # Interaction parameter
+    alpha = np.cos(th)
+    beta = np.sin(th)
+    gamma = 1.
+
+    N = 30                 # number of Fock states
+    Id = qeye(N)
+    a = destroy(N)
+    s = 0.5*((alpha+beta)*a + (alpha-beta)*a.dag())
+    x = (a + a.dag()) * 2**-0.5
+    H = Id + gamma * a * a.dag()
+    sc_op = [s]
+    e_op = [x, x*x]
+    rho0 = fock(N,0)      # initial vacuum state
+
+    T = 6.                   # final time
+    # number of time steps for which we save the expectation values
+    N_store = 200
+    Nsub = 10
+    tlist = np.linspace(0, T, N_store)
+    ddt = (tlist[1]-tlist[0])
+
+    #### No analytic solution for ssesolve, taylor15 with 500 substep
+    sol = ssesolve(H, rho0, tlist, sc_op, e_op,
+                   nsubsteps=1000, method='homodyne', solver='taylor1.5')
+    y_an = (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())
+
+
+    list_methods_tol = [['euler-maruyama', 3e-2],
+                        ['pc-euler', 5e-3],
+                        ['pc-euler-2', 5e-3],
+                        ['platen', 5e-3],
+                        ['milstein', 5e-3],
+                        ['milstein-imp', 5e-3],
+                        ['taylor1.5', 5e-4],
+                        ['taylor1.5-imp', 5e-4],
+                        ['explicit1.5', 5e-4],
+                        ['taylor2.0', 5e-4]]
+    for n_method in list_methods_tol:
+        # Comparisons of error between sol and sol3 depend on the stochastic
+        # noise, thus the seed, fixing the seed remove random fails.
+        np.random.seed(1)
+        sol = ssesolve(H, rho0, tlist, sc_op, e_op,
+                       nsubsteps=Nsub, method='homodyne', solver=n_method[0])
+        sol2 = ssesolve(H, rho0, tlist, sc_op, e_op, store_measurement=0,
+                       nsubsteps=Nsub, method='homodyne', solver=n_method[0],
+                       noise = sol.noise)
+        sol3 = ssesolve(H, rho0, tlist, sc_op, e_op,
+                        nsubsteps=Nsub*10, method='homodyne',
+                        solver=n_method[0], tol=1e-8)
+        err = 1/T * np.sum(np.abs(y_an - \
+                    (sol.expect[1]-sol.expect[0]*sol.expect[0].conj())))*ddt
+        err3 = 1/T * np.sum(np.abs(y_an - \
+                    (sol3.expect[1]-sol3.expect[0]*sol3.expect[0].conj())))*ddt
+        assert err < n_method[1]
+        # 5* more substep should decrease the error
+        assert err3 < err
+        # just to check that noise is not affected by ssesolve
+        assert np.all(sol.noise == sol2.noise)
+        assert np.all(sol.expect[0] == sol2.expect[0])
+
+    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=1)
+    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=10, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler',
+                    store_measurement=0)
+    sol3 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=11, ntraj=2,
+                    nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the same seed, sol3 differ.
+    assert np.all(sol.noise == sol2.noise)
+    assert np.all(sol.noise != sol3.noise)
+    assert not np.all(sol.measurement[0] == 0.+0j)
+    assert np.all(sol2.measurement[0] == 0.+0j)
+    sol = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([1,2]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    sol2 = ssesolve(H, rho0, tlist[:2], sc_op, e_op, noise=np.array([2,1]),
+                   ntraj=2, nsubsteps=Nsub, method='homodyne', solver='euler')
+    # sol and sol2 have the seed of traj 1 and 2 reversed.
+    assert np.all(sol.noise[0,:,:,:] == sol2.noise[1,:,:,:])
+    assert np.all(sol.noise[1,:,:,:] == sol2.noise[0,:,:,:])
+
+
+def test_ssesolve_photocurrent():
+    "Stochastic: photocurrent_sesolve"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 25
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 2.5, 50)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = photocurrent_sesolve(H, psi0, times, sc_ops, e_ops, ntraj=ntraj,
+                              nsubsteps=nsubsteps, store_measurement=True,
+                              map_func=parallel_map, args={"a":2})
+
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+    assert len(res.measurement) == ntraj
+    assert all([m.shape == (len(times), len(sc_ops)) for m in res.measurement])
+
+
+def test_ssesolve_homodyne():
+    "Stochastic: ssesolve: homodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 25
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 2.5, 50)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = ssesolve(H, psi0, times, sc_ops, e_ops,
+                   ntraj=ntraj, nsubsteps=nsubsteps,
+                   method='homodyne', store_measurement=True,
+                   map_func=parallel_map, args={"a":2})
+
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+    assert len(res.measurement) == ntraj
+    assert all(m.shape == (len(times), len(sc_ops)) for m in res.measurement)
+
+
+@pytest.mark.slow
+def test_ssesolve_heterodyne():
+    "Stochastic: ssesolve: heterodyne, time-dependent H"
+    tol = 0.01
+
+    N = 4
+    gamma = 0.25
+    ntraj = 25
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [[a.dag() * a,f]]
+    psi0 = coherent(N, 0.5)
+    sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a*0.5]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())]
+
+    times = np.linspace(0, 2.5, 50)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2})
+    res = ssesolve(H, psi0, times, sc_ops, e_ops,
+                   ntraj=ntraj, nsubsteps=nsubsteps,
+                   method='heterodyne', store_measurement=True,
+                   map_func=parallel_map, args={"a":2})
+
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+    assert len(res.measurement) == ntraj
+    assert all(m.shape == (len(times), len(sc_ops), 2)
+               for m in res.measurement)
+
+
+def f_dargs(t, args):
+    return args["expect_op_3"] - 1
+
+
+@pytest.mark.xfail(reason="not yet working")
+def test_ssesolve_feedback():
+    "Stochastic: ssesolve: time-dependent H with feedback"
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [[a + a.dag(), f_dargs]]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag()), qeye(N)]
+
+    times = np.linspace(0, 10, 101)
+    res_ref = mesolve(H, psi0, times, sc_ops, e_ops,
+                      args={"expect_op_3": qeye(N)})
+    res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
+                   ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                   map_func=parallel_map, args={"expect_op_3": qeye(N)})
+    np.testing.assert_allclose(res.expect, res_ref.expect, atol=tol)
+
+
+def test_ssesolve_bad_e_ops():
+    tol = 0.01
+    N = 4
+    ntraj = 10
+    nsubsteps = 100
+    a = destroy(N)
+    b = destroy(N-1)
+
+    H = [num(N)]
+    psi0 = coherent(N, 2.5)
+    sc_ops = [a + a.dag()]
+    e_ops = [a.dag() * a, a + a.dag(), (-1j)*(b - b.dag()), qeye(N+1)]
+    times = np.linspace(0, 10, 101)
+    with pytest.raises(TypeError) as exc:
+        res = ssesolve(H, psi0, times, sc_ops, e_ops, solver=None, noise=1,
+                       ntraj=ntraj, nsubsteps=nsubsteps, method='homodyne',
+                       map_func=parallel_map)
diff --git a/qutip/tests/solver/heom/test_bofin_baths.py b/qutip/tests/solver/heom/test_bofin_baths.py
index 32a4eca261..c6c5c80fc1 100644
--- a/qutip/tests/solver/heom/test_bofin_baths.py
+++ b/qutip/tests/solver/heom/test_bofin_baths.py
@@ -1,465 +1,465 @@
-"""
-Tests for qutip.nonmarkov.bofin_baths.
-"""
-
-import numpy as np
-import pytest
-
-from qutip import spre, spost, sigmax, sigmaz
-from qutip.core import data as _data
-from qutip.solver.heom.bofin_baths import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-)
-
-
-def isequal(Q1, Q2, tol):
-    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
-    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
-
-
-def check_exponent(
-    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
-):
-    """ Check the attributes of a BathExponent. """
-    assert exp.type is BathExponent.types[type]
-    assert exp.fermionic == (type in ["+", "-"])
-    assert exp.dim == dim
-    assert exp.Q == Q
-    assert exp.ck == pytest.approx(ck)
-    assert exp.vk == pytest.approx(vk)
-    assert exp.ck2 == pytest.approx(ck2)
-    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
-    assert exp.tag == tag
-
-
-class TestBathExponent:
-    def test_create(self):
-        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
-        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
-
-        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
-        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
-
-        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
-        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
-
-        exp_p = BathExponent(
-            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-        )
-        check_exponent(
-            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-        )
-
-        exp_m = BathExponent(
-            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
-        )
-        check_exponent(
-            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
-        )
-
-        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
-        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
-
-        for exp_type, kw in [
-            ("R", {}),
-            ("I", {}),
-            ("+", {"sigma_bar_k_offset": 1}),
-            ("-", {"sigma_bar_k_offset": -1}),
-        ]:
-            with pytest.raises(ValueError) as err:
-                BathExponent(
-                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
-                )
-            assert str(err.value) == (
-                "Second co-efficient (ck2) should only be specified for RI"
-                " bath exponents"
-            )
-
-        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
-            with pytest.raises(ValueError) as err:
-                BathExponent(
-                    exp_type, None, Q=None, ck=1.0, vk=2.0,
-                    sigma_bar_k_offset=1, **kw,
-                )
-            assert str(err.value) == (
-                "Offset of sigma bar (sigma_bar_k_offset) should only be"
-                " specified for + and - bath exponents"
-            )
-
-    def test_repr(self):
-        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
-        assert repr(exp1) == (
-            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
-            " ck=1.0 vk=2.0 ck2=None"
-            " sigma_bar_k_offset=None fermionic=False tag=None>"
-        )
-        exp2 = BathExponent(
-            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
-            tag="bath1",
-        )
-        assert repr(exp2) == (
-            "<BathExponent type=+ dim=None Q.dims=None"
-            " ck=1.0 vk=2.0 ck2=None"
-            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
-        )
-
-
-class TestBath:
-    def test_create(self):
-        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
-        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
-        bath = Bath([exp_r, exp_i])
-        assert bath.exponents == [exp_r, exp_i]
-
-
-class TestBosonicBath:
-    def test_create(self):
-        Q = sigmaz()
-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
-        exp_r, exp_i = bath.exponents
-        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
-        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
-
-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
-        [exp_ri] = bath.exponents
-        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
-
-        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
-        exp_r, exp_i = bath.exponents
-        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
-        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
-
-        with pytest.raises(ValueError) as err:
-            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
-        assert str(err.value) == "The coupling operator Q must be a Qobj."
-
-        with pytest.raises(ValueError) as err:
-            BosonicBath(Q, [1.], [], [2.], [0.6])
-        assert str(err.value) == (
-            "The bath exponent lists ck_real and vk_real, and ck_imag and"
-            " vk_imag must be the same length."
-        )
-
-        with pytest.raises(ValueError) as err:
-            BosonicBath(Q, [1.], [0.5], [2.], [])
-        assert str(err.value) == (
-            "The bath exponent lists ck_real and vk_real, and ck_imag and"
-            " vk_imag must be the same length."
-        )
-
-    def test_combine(self):
-        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
-        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
-        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
-        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_rx, exp_rx])
-        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_ix, exp_ix])
-        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_rix, exp_rix])
-        check_exponent(
-            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
-        )
-
-        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
-        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
-        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
-
-        [exp] = BosonicBath.combine([exp_rx, exp_ix])
-        check_exponent(
-            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
-        )
-
-        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
-        check_exponent(
-            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
-        )
-
-
-class TestDrudeLorentzBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_real = [0.05262168274189053, 0.0007958201977617107]
-        vk_real = [0.05, 6.613879270715354]
-        ck_imag = [-0.0012500000000000002]
-        vk_imag = [0.05]
-
-        bath = DrudeLorentzBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
-        )
-        [exp1, exp2] = bath.exponents
-        check_exponent(
-            exp1, "RI", dim=None, Q=Q,
-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-            tag="bath1",
-        )
-        check_exponent(
-            exp2, "R", dim=None, Q=Q,
-            ck=ck_real[1], vk=vk_real[1],
-            tag="bath1",
-        )
-
-        bath = DrudeLorentzBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
-        )
-        [exp1, exp2, exp3] = bath.exponents
-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-
-    @pytest.mark.parametrize(['combine'], [
-        pytest.param(True, id="combine"),
-        pytest.param(False, id="no-combine"),
-    ])
-    def test_terminator(self, combine):
-        Q = sigmaz()
-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-
-        bath = DrudeLorentzBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
-        )
-        delta, terminator = bath.terminator()
-
-        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
-        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
-
-
-class TestDrudeLorentzPadeBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_real = [0.05262168274189053, 0.0016138037466648136]
-        vk_real = [0.05, 8.153649149910352]
-        ck_imag = [-0.0012500000000000002]
-        vk_imag = [0.05]
-
-        bath = DrudeLorentzPadeBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
-        )
-        [exp1, exp2] = bath.exponents
-        check_exponent(
-            exp1, "RI", dim=None, Q=Q,
-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-            tag="bath1",
-        )
-        check_exponent(
-            exp2, "R", dim=None, Q=Q,
-            ck=ck_real[1], vk=vk_real[1],
-            tag="bath1",
-        )
-
-        bath = DrudeLorentzPadeBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
-        )
-        [exp1, exp2, exp3] = bath.exponents
-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-
-    @pytest.mark.parametrize(['combine'], [
-        pytest.param(True, id="combine"),
-        pytest.param(False, id="no-combine"),
-    ])
-    def test_terminator(self, combine):
-        Q = sigmaz()
-        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
-
-        bath = DrudeLorentzPadeBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
-        )
-        delta, terminator = bath.terminator()
-
-        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
-        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
-
-
-class TestUnderDampedBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_real = [
-            0.0003533235200322013-7.634500355085952e-06j,
-            0.0003533235200322013+7.634500355085952e-06j,
-            -2.173594134367819e-07+0j,
-        ]
-        vk_real = [
-            0.025-0.9996874511566103j,
-            0.025+0.9996874511566103j,
-            6.613879270715354,
-        ]
-        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
-        vk_imag = [
-            0.025-0.9996874511566103j,
-            0.025+0.9996874511566103j,
-        ]
-
-        bath = UnderDampedBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
-        )
-        [exp1, exp2, exp3] = bath.exponents
-        check_exponent(
-            exp1, "RI", dim=None, Q=Q,
-            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
-            tag="bath1",
-        )
-        check_exponent(
-            exp2, "RI", dim=None, Q=Q,
-            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
-            tag="bath1",
-        )
-        check_exponent(
-            exp3, "R", dim=None, Q=Q,
-            ck=ck_real[2], vk=vk_real[2],
-            tag="bath1",
-        )
-
-        bath = UnderDampedBath(
-            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
-        )
-        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
-        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
-        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
-        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
-        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
-        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
-
-
-class TestFermionicBath:
-    def test_create(self):
-        Q = 1j * sigmaz()
-        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
-        exp_p, exp_m = bath.exponents
-        check_exponent(
-            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
-        )
-        check_exponent(
-            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
-        )
-
-        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
-        exp_p, exp_m = bath.exponents
-        check_exponent(
-            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
-            tag="bath1",
-        )
-        check_exponent(
-            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
-            tag="bath1",
-        )
-
-        with pytest.raises(ValueError) as err:
-            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
-        assert str(err.value) == "The coupling operator Q must be a Qobj."
-
-        with pytest.raises(ValueError) as err:
-            FermionicBath(Q, [1.], [], [2.], [0.6])
-        assert str(err.value) == (
-            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-            " vk_minus must be the same length."
-        )
-
-        with pytest.raises(ValueError) as err:
-            FermionicBath(Q, [1.], [0.5], [2.], [])
-        assert str(err.value) == (
-            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
-            " vk_minus must be the same length."
-        )
-
-
-class TestLorentzianBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_plus = [
-            0.0025-0.0013376935246402686j,
-            -0.00026023645770006167j,
-            -0.0002748355116913478j,
-        ]
-        vk_plus = [
-            1+1j,
-            0.08121642500626945+1j,
-            0.24364927501880834+1j,
-        ]
-        ck_minus = [
-            0.0025-0.0013376935246402686j,
-            -0.00026023645770006167j,
-            -0.0002748355116913478j,
-        ]
-        vk_minus = [
-            1-1j,
-            0.08121642500626945-1j,
-            0.24364927501880834-1j,
-        ]
-
-        bath = LorentzianBath(
-            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
-        )
-        assert len(bath.exponents) == 6
-        for i in range(len(ck_plus)):
-            exp_p = bath.exponents[2 * i]
-            exp_m = bath.exponents[2 * i + 1]
-            check_exponent(
-                exp_p, "+", dim=2, Q=Q,
-                ck=ck_plus[i], vk=vk_plus[i],
-                sigma_bar_k_offset=1,
-                tag="bath1",
-            )
-            check_exponent(
-                exp_m, "-", dim=2, Q=Q,
-                ck=ck_minus[i], vk=vk_minus[i],
-                sigma_bar_k_offset=-1,
-                tag="bath1",
-            )
-
-
-class TestLorentzianPadeBath:
-    def test_create(self):
-        Q = sigmaz()
-        ck_plus = [
-            0.0025+0.0014269000277373958j,
-            -0.0002608459250597002j,
-            -0.0011660541026776957j,
-        ]
-        vk_plus = [
-            1+1j,
-            0.08123902308117874+1j,
-            0.3371925267385835+1j,
-        ]
-        ck_minus = [
-            0.0025+0.0014269000277373958j,
-            -0.0002608459250597002j,
-            -0.0011660541026776957j,
-        ]
-        vk_minus = [
-            1-1j,
-            0.08123902308117874-1j,
-            0.3371925267385835-1j,
-        ]
-
-        bath = LorentzianPadeBath(
-            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
-        )
-        assert len(bath.exponents) == 6
-        for i in range(len(ck_plus)):
-            exp_p = bath.exponents[2 * i]
-            exp_m = bath.exponents[2 * i + 1]
-            check_exponent(
-                exp_p, "+", dim=2, Q=Q,
-                ck=ck_plus[i], vk=vk_plus[i],
-                sigma_bar_k_offset=1,
-                tag="bath1",
-            )
-            check_exponent(
-                exp_m, "-", dim=2, Q=Q,
-                ck=ck_minus[i], vk=vk_minus[i],
-                sigma_bar_k_offset=-1,
-                tag="bath1",
-            )
+"""
+Tests for qutip.nonmarkov.bofin_baths.
+"""
+
+import numpy as np
+import pytest
+
+from qutip import spre, spost, sigmax, sigmaz
+from qutip.core import data as _data
+from qutip.solver.heom.bofin_baths import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+)
+
+
+def isequal(Q1, Q2, tol):
+    """ Return true if Q1 and Q2 are equal to within the given tolerance. """
+    return _data.iszero(_data.sub(Q1.data, Q2.data), tol=tol)
+
+
+def check_exponent(
+    exp, type, dim, Q, ck, vk, ck2=None, sigma_bar_k_offset=None, tag=None,
+):
+    """ Check the attributes of a BathExponent. """
+    assert exp.type is BathExponent.types[type]
+    assert exp.fermionic == (type in ["+", "-"])
+    assert exp.dim == dim
+    assert exp.Q == Q
+    assert exp.ck == pytest.approx(ck)
+    assert exp.vk == pytest.approx(vk)
+    assert exp.ck2 == pytest.approx(ck2)
+    assert exp.sigma_bar_k_offset == sigma_bar_k_offset
+    assert exp.tag == tag
+
+
+class TestBathExponent:
+    def test_create(self):
+        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
+        check_exponent(exp_r, "R", None, Q=None, ck=1.0, vk=2.0)
+
+        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
+        check_exponent(exp_i, "I", None, Q=None, ck=1.0, vk=2.0)
+
+        exp_ri = BathExponent("RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
+        check_exponent(exp_ri, "RI", None, Q=None, ck=1.0, vk=2.0, ck2=3.0)
+
+        exp_p = BathExponent(
+            "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+        )
+        check_exponent(
+            exp_p, "+", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+        )
+
+        exp_m = BathExponent(
+            "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
+        )
+        check_exponent(
+            exp_m, "-", 2, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=+1,
+        )
+
+        exp_tag = BathExponent("R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
+        check_exponent(exp_tag, "R", None, Q=None, ck=1.0, vk=2.0, tag="tag1")
+
+        for exp_type, kw in [
+            ("R", {}),
+            ("I", {}),
+            ("+", {"sigma_bar_k_offset": 1}),
+            ("-", {"sigma_bar_k_offset": -1}),
+        ]:
+            with pytest.raises(ValueError) as err:
+                BathExponent(
+                    exp_type, None, Q=None, ck=1.0, vk=2.0, ck2=3.0, **kw,
+                )
+            assert str(err.value) == (
+                "Second co-efficient (ck2) should only be specified for RI"
+                " bath exponents"
+            )
+
+        for exp_type, kw in [("R", {}), ("I", {}), ("RI", {"ck2": 3.0})]:
+            with pytest.raises(ValueError) as err:
+                BathExponent(
+                    exp_type, None, Q=None, ck=1.0, vk=2.0,
+                    sigma_bar_k_offset=1, **kw,
+                )
+            assert str(err.value) == (
+                "Offset of sigma bar (sigma_bar_k_offset) should only be"
+                " specified for + and - bath exponents"
+            )
+
+    def test_repr(self):
+        exp1 = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=2.0)
+        assert repr(exp1) == (
+            "<BathExponent type=R dim=None Q.dims=[[2], [2]]"
+            " ck=1.0 vk=2.0 ck2=None"
+            " sigma_bar_k_offset=None fermionic=False tag=None>"
+        )
+        exp2 = BathExponent(
+            "+", None, Q=None, ck=1.0, vk=2.0, sigma_bar_k_offset=-1,
+            tag="bath1",
+        )
+        assert repr(exp2) == (
+            "<BathExponent type=+ dim=None Q.dims=None"
+            " ck=1.0 vk=2.0 ck2=None"
+            " sigma_bar_k_offset=-1 fermionic=True tag='bath1'>"
+        )
+
+
+class TestBath:
+    def test_create(self):
+        exp_r = BathExponent("R", None, Q=None, ck=1.0, vk=2.0)
+        exp_i = BathExponent("I", None, Q=None, ck=1.0, vk=2.0)
+        bath = Bath([exp_r, exp_i])
+        assert bath.exponents == [exp_r, exp_i]
+
+
+class TestBosonicBath:
+    def test_create(self):
+        Q = sigmaz()
+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6])
+        exp_r, exp_i = bath.exponents
+        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5)
+        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6)
+
+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.5])
+        [exp_ri] = bath.exponents
+        check_exponent(exp_ri, "RI", dim=None, Q=Q, ck=1.0, vk=0.5, ck2=2.0)
+
+        bath = BosonicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
+        exp_r, exp_i = bath.exponents
+        check_exponent(exp_r, "R", dim=None, Q=Q, ck=1.0, vk=0.5, tag="bath1")
+        check_exponent(exp_i, "I", dim=None, Q=Q, ck=2.0, vk=0.6, tag="bath1")
+
+        with pytest.raises(ValueError) as err:
+            BosonicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
+        assert str(err.value) == "The coupling operator Q must be a Qobj."
+
+        with pytest.raises(ValueError) as err:
+            BosonicBath(Q, [1.], [], [2.], [0.6])
+        assert str(err.value) == (
+            "The bath exponent lists ck_real and vk_real, and ck_imag and"
+            " vk_imag must be the same length."
+        )
+
+        with pytest.raises(ValueError) as err:
+            BosonicBath(Q, [1.], [0.5], [2.], [])
+        assert str(err.value) == (
+            "The bath exponent lists ck_real and vk_real, and ck_imag and"
+            " vk_imag must be the same length."
+        )
+
+    def test_combine(self):
+        exp_ix = BathExponent("I", None, Q=sigmax(), ck=2.0, vk=0.5)
+        exp_rx = BathExponent("R", None, Q=sigmax(), ck=1.0, vk=0.5)
+        exp_rix = BathExponent("RI", None, Q=sigmax(), ck=0.1, vk=0.5, ck2=0.2)
+        exp_rz = BathExponent("R", None, Q=sigmaz(), ck=1.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_rx, exp_rx])
+        check_exponent(exp, "R", dim=None, Q=sigmax(), ck=2.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_ix, exp_ix])
+        check_exponent(exp, "I", dim=None, Q=sigmax(), ck=4.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_rix, exp_rix])
+        check_exponent(
+            exp, "RI", dim=None, Q=sigmax(), ck=0.2, vk=0.5, ck2=0.4,
+        )
+
+        [exp1, exp2] = BosonicBath.combine([exp_rx, exp_rz])
+        check_exponent(exp1, "R", dim=None, Q=sigmax(), ck=1.0, vk=0.5)
+        check_exponent(exp2, "R", dim=None, Q=sigmaz(), ck=1.0, vk=0.5)
+
+        [exp] = BosonicBath.combine([exp_rx, exp_ix])
+        check_exponent(
+            exp, "RI", dim=None, Q=sigmax(), ck=1.0, vk=0.5, ck2=2.0,
+        )
+
+        [exp] = BosonicBath.combine([exp_rx, exp_ix, exp_rix])
+        check_exponent(
+            exp, "RI", dim=None, Q=sigmax(), ck=1.1, vk=0.5, ck2=2.2,
+        )
+
+
+class TestDrudeLorentzBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_real = [0.05262168274189053, 0.0007958201977617107]
+        vk_real = [0.05, 6.613879270715354]
+        ck_imag = [-0.0012500000000000002]
+        vk_imag = [0.05]
+
+        bath = DrudeLorentzBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
+        )
+        [exp1, exp2] = bath.exponents
+        check_exponent(
+            exp1, "RI", dim=None, Q=Q,
+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+            tag="bath1",
+        )
+        check_exponent(
+            exp2, "R", dim=None, Q=Q,
+            ck=ck_real[1], vk=vk_real[1],
+            tag="bath1",
+        )
+
+        bath = DrudeLorentzBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
+        )
+        [exp1, exp2, exp3] = bath.exponents
+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+
+    @pytest.mark.parametrize(['combine'], [
+        pytest.param(True, id="combine"),
+        pytest.param(False, id="no-combine"),
+    ])
+    def test_terminator(self, combine):
+        Q = sigmaz()
+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+
+        bath = DrudeLorentzBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
+        )
+        delta, terminator = bath.terminator()
+
+        assert np.abs(delta - (0.00031039 / 4.0)) < 1e-8
+        assert isequal(terminator, - (0.00031039 / 4.0) * op, tol=1e-8)
+
+
+class TestDrudeLorentzPadeBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_real = [0.05262168274189053, 0.0016138037466648136]
+        vk_real = [0.05, 8.153649149910352]
+        ck_imag = [-0.0012500000000000002]
+        vk_imag = [0.05]
+
+        bath = DrudeLorentzPadeBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, tag="bath1",
+        )
+        [exp1, exp2] = bath.exponents
+        check_exponent(
+            exp1, "RI", dim=None, Q=Q,
+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+            tag="bath1",
+        )
+        check_exponent(
+            exp2, "R", dim=None, Q=Q,
+            ck=ck_real[1], vk=vk_real[1],
+            tag="bath1",
+        )
+
+        bath = DrudeLorentzPadeBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=False,
+        )
+        [exp1, exp2, exp3] = bath.exponents
+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+        check_exponent(exp3, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+
+    @pytest.mark.parametrize(['combine'], [
+        pytest.param(True, id="combine"),
+        pytest.param(False, id="no-combine"),
+    ])
+    def test_terminator(self, combine):
+        Q = sigmaz()
+        op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
+
+        bath = DrudeLorentzPadeBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, combine=combine,
+        )
+        delta, terminator = bath.terminator()
+
+        assert np.abs(delta - (0.0 / 4.0)) < 1e-8
+        assert isequal(terminator, - (0.0 / 4.0) * op, tol=1e-8)
+
+
+class TestUnderDampedBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_real = [
+            0.0003533235200322013-7.634500355085952e-06j,
+            0.0003533235200322013+7.634500355085952e-06j,
+            -2.173594134367819e-07+0j,
+        ]
+        vk_real = [
+            0.025-0.9996874511566103j,
+            0.025+0.9996874511566103j,
+            6.613879270715354,
+        ]
+        ck_imag = [0.00015629885102511106j, -0.00015629885102511106j]
+        vk_imag = [
+            0.025-0.9996874511566103j,
+            0.025+0.9996874511566103j,
+        ]
+
+        bath = UnderDampedBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, tag="bath1",
+        )
+        [exp1, exp2, exp3] = bath.exponents
+        check_exponent(
+            exp1, "RI", dim=None, Q=Q,
+            ck=ck_real[0], vk=vk_real[0], ck2=ck_imag[0],
+            tag="bath1",
+        )
+        check_exponent(
+            exp2, "RI", dim=None, Q=Q,
+            ck=ck_real[1], vk=vk_real[1], ck2=ck_imag[1],
+            tag="bath1",
+        )
+        check_exponent(
+            exp3, "R", dim=None, Q=Q,
+            ck=ck_real[2], vk=vk_real[2],
+            tag="bath1",
+        )
+
+        bath = UnderDampedBath(
+            Q=Q, lam=0.025, T=1 / 0.95, Nk=1, gamma=0.05, w0=1, combine=False,
+        )
+        [exp1, exp2, exp3, exp4, exp5] = bath.exponents
+        check_exponent(exp1, "R", dim=None, Q=Q, ck=ck_real[0], vk=vk_real[0])
+        check_exponent(exp2, "R", dim=None, Q=Q, ck=ck_real[1], vk=vk_real[1])
+        check_exponent(exp3, "R", dim=None, Q=Q, ck=ck_real[2], vk=vk_real[2])
+        check_exponent(exp4, "I", dim=None, Q=Q, ck=ck_imag[0], vk=vk_imag[0])
+        check_exponent(exp5, "I", dim=None, Q=Q, ck=ck_imag[1], vk=vk_imag[1])
+
+
+class TestFermionicBath:
+    def test_create(self):
+        Q = 1j * sigmaz()
+        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6])
+        exp_p, exp_m = bath.exponents
+        check_exponent(
+            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
+        )
+        check_exponent(
+            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
+        )
+
+        bath = FermionicBath(Q, [1.], [0.5], [2.], [0.6], tag="bath1")
+        exp_p, exp_m = bath.exponents
+        check_exponent(
+            exp_p, "+", dim=2, Q=Q, ck=1.0, vk=0.5, sigma_bar_k_offset=1,
+            tag="bath1",
+        )
+        check_exponent(
+            exp_m, "-", dim=2, Q=Q, ck=2.0, vk=0.6, sigma_bar_k_offset=-1,
+            tag="bath1",
+        )
+
+        with pytest.raises(ValueError) as err:
+            FermionicBath("not-a-qobj", [1.], [0.5], [2.], [0.6])
+        assert str(err.value) == "The coupling operator Q must be a Qobj."
+
+        with pytest.raises(ValueError) as err:
+            FermionicBath(Q, [1.], [], [2.], [0.6])
+        assert str(err.value) == (
+            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+            " vk_minus must be the same length."
+        )
+
+        with pytest.raises(ValueError) as err:
+            FermionicBath(Q, [1.], [0.5], [2.], [])
+        assert str(err.value) == (
+            "The bath exponent lists ck_plus and vk_plus, and ck_minus and"
+            " vk_minus must be the same length."
+        )
+
+
+class TestLorentzianBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_plus = [
+            0.0025-0.0013376935246402686j,
+            -0.00026023645770006167j,
+            -0.0002748355116913478j,
+        ]
+        vk_plus = [
+            1+1j,
+            0.08121642500626945+1j,
+            0.24364927501880834+1j,
+        ]
+        ck_minus = [
+            0.0025-0.0013376935246402686j,
+            -0.00026023645770006167j,
+            -0.0002748355116913478j,
+        ]
+        vk_minus = [
+            1-1j,
+            0.08121642500626945-1j,
+            0.24364927501880834-1j,
+        ]
+
+        bath = LorentzianBath(
+            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
+        )
+        assert len(bath.exponents) == 6
+        for i in range(len(ck_plus)):
+            exp_p = bath.exponents[2 * i]
+            exp_m = bath.exponents[2 * i + 1]
+            check_exponent(
+                exp_p, "+", dim=2, Q=Q,
+                ck=ck_plus[i], vk=vk_plus[i],
+                sigma_bar_k_offset=1,
+                tag="bath1",
+            )
+            check_exponent(
+                exp_m, "-", dim=2, Q=Q,
+                ck=ck_minus[i], vk=vk_minus[i],
+                sigma_bar_k_offset=-1,
+                tag="bath1",
+            )
+
+
+class TestLorentzianPadeBath:
+    def test_create(self):
+        Q = sigmaz()
+        ck_plus = [
+            0.0025+0.0014269000277373958j,
+            -0.0002608459250597002j,
+            -0.0011660541026776957j,
+        ]
+        vk_plus = [
+            1+1j,
+            0.08123902308117874+1j,
+            0.3371925267385835+1j,
+        ]
+        ck_minus = [
+            0.0025+0.0014269000277373958j,
+            -0.0002608459250597002j,
+            -0.0011660541026776957j,
+        ]
+        vk_minus = [
+            1-1j,
+            0.08123902308117874-1j,
+            0.3371925267385835-1j,
+        ]
+
+        bath = LorentzianPadeBath(
+            Q=Q, gamma=0.01, w=1, mu=-1, T=0.025851991, Nk=2, tag="bath1",
+        )
+        assert len(bath.exponents) == 6
+        for i in range(len(ck_plus)):
+            exp_p = bath.exponents[2 * i]
+            exp_m = bath.exponents[2 * i + 1]
+            check_exponent(
+                exp_p, "+", dim=2, Q=Q,
+                ck=ck_plus[i], vk=vk_plus[i],
+                sigma_bar_k_offset=1,
+                tag="bath1",
+            )
+            check_exponent(
+                exp_m, "-", dim=2, Q=Q,
+                ck=ck_minus[i], vk=vk_minus[i],
+                sigma_bar_k_offset=-1,
+                tag="bath1",
+            )
diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index 69935d0177..72b737a91c 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -1,1396 +1,1396 @@
-"""
-Tests for qutip.nonmarkov.bofin_solvers.
-"""
-
-import numpy as np
-import pytest
-from numpy.linalg import eigvalsh
-from scipy.integrate import quad
-
-from qutip import (
-    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
-    tensor, Qobj, QobjEvo
-)
-from qutip.core import data as _data
-from qutip.solver.heom.bofin_baths import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-)
-from qutip.solver.heom.bofin_solvers import (
-    heomsolve,
-    HierarchyADOs,
-    HierarchyADOsState,
-    HEOMResult,
-    HEOMSolver,
-    HSolverDL,
-    _GatherHEOMRHS,
-)
-from qutip.solver import (
-    IntegratorException,
-)
-
-
-def fill_options(**kwargs):
-    """Fill the options with minimal entries needed by HEOMResult."""
-    return {
-        "store_final_state": False,
-        "store_states": None,
-        "store_ados": False,
-        **kwargs
-    }
-
-
-def assert_raises_steady_state_time_dependent(hsolver):
-    """ Assert that calling .steady_state() on a HEOMSolver with
-        a time-dependent Hamiltonian raises the appropriate exception.
-    """
-    with pytest.raises(ValueError) as err:
-        hsolver.steady_state()
-    assert str(err.value) == (
-       "A steady state cannot be determined for a time-dependent"
-       " system"
-    )
-
-
-class TestHierarchyADOs:
-    def mk_exponents(self, dims):
-        return [
-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
-        ]
-
-    def test_create(self):
-        exponents = self.mk_exponents([2, 3])
-        ados = HierarchyADOs(exponents, max_depth=2)
-
-        assert ados.exponents == exponents
-        assert ados.max_depth == 2
-
-        assert ados.dims == [2, 3]
-        assert ados.vk == [2.0, 2.0]
-        assert ados.ck == [1.0, 1.0]
-        assert ados.ck2 == [None, None]
-        assert ados.sigma_bar_k_offset == [None, None]
-
-        assert ados.labels == [
-            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
-        ]
-
-    def test_state_idx(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.idx((0, 0)) == 0
-        assert ados.idx((0, 1)) == 1
-        assert ados.idx((0, 2)) == 2
-        assert ados.idx((1, 0)) == 3
-        assert ados.idx((1, 1)) == 4
-
-    def test_next(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.next((0, 0), 0) == (1, 0)
-        assert ados.next((0, 0), 1) == (0, 1)
-        assert ados.next((1, 0), 0) is None
-        assert ados.next((1, 0), 1) == (1, 1)
-        assert ados.next((1, 1), 1) is None
-
-    def test_prev(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.prev((0, 0), 0) is None
-        assert ados.prev((0, 0), 1) is None
-        assert ados.prev((1, 0), 0) == (0, 0)
-        assert ados.prev((0, 1), 1) == (0, 0)
-        assert ados.prev((1, 1), 1) == (1, 0)
-        assert ados.prev((0, 2), 1) == (0, 1)
-
-    def test_exps(self):
-        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
-        assert ados.exps((0, 0, 0)) == ()
-        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
-        assert ados.exps((2, 0, 0)) == (
-            ados.exponents[0], ados.exponents[0],
-        )
-        assert ados.exps((1, 2, 1)) == (
-            ados.exponents[0],
-            ados.exponents[1], ados.exponents[1],
-            ados.exponents[2],
-        )
-
-    def test_filter_by_nothing(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.filter() == [
-            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
-        ]
-
-    def test_filter_by_level(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.filter(level=0) == [
-            (0, 0),
-        ]
-        assert ados.filter(level=1) == [
-            (0, 1),
-            (1, 0),
-        ]
-        assert ados.filter(level=2) == [
-            (0, 2),
-            (1, 1),
-        ]
-        assert ados.filter(level=3) == []
-
-    def test_filter_by_exponents(self):
-        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
-        assert ados.filter(dims=[]) == [
-            (0, 0),
-        ]
-        assert ados.filter(dims=[2]) == [
-            (1, 0),
-        ]
-        assert ados.filter(level=1, dims=[2]) == [
-            (1, 0),
-        ]
-        assert ados.filter(dims=[3]) == [
-            (0, 1),
-        ]
-        assert ados.filter(dims=[2, 3]) == [
-            (1, 1),
-        ]
-        assert ados.filter(level=2, dims=[2, 3]) == [
-            (1, 1),
-        ]
-        assert ados.filter(dims=[3, 3]) == [
-            (0, 2),
-        ]
-        assert ados.filter(types=["I"]) == [
-            (0, 1),
-            (1, 0),
-        ]
-        assert ados.filter(types=["I", "I"]) == [
-            (0, 2),
-            (1, 1),
-        ]
-
-        with pytest.raises(ValueError) as err:
-            ados.filter(types=[], dims=[2])
-        assert str(err.value) == (
-            "The tags, dims and types filters must all be the same length."
-        )
-
-        with pytest.raises(ValueError) as err:
-            ados.filter(dims=[2, 2, 2])
-        assert str(err.value) == (
-            "The maximum depth for the hierarchy is 2 but 3 levels of"
-            " excitation filters were given."
-        )
-
-        with pytest.raises(ValueError) as err:
-            ados.filter(level=0, dims=[2])
-        assert str(err.value) == (
-            "The level parameter is 0 but 1 levels of excitation filters"
-            " were given."
-        )
-
-
-class TestHierarchyADOsState:
-    def mk_ados(self, bath_dims, max_depth):
-        exponents = [
-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
-        ]
-        ados = HierarchyADOs(exponents, max_depth=max_depth)
-        return ados
-
-    def mk_rho_and_soln(self, ados, rho_dims):
-        n_ados = len(ados.labels)
-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
-        rho = Qobj(ado_soln[0, :], dims=rho_dims)
-        return rho, ado_soln
-
-    def test_create(self):
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-        assert ado_state.rho == rho
-        assert ado_state.labels == ados.labels
-        assert ado_state.exponents == ados.exponents
-        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
-        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
-
-    def test_extract(self):
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-        ado_state.extract((0, 0)) == rho
-        ado_state.extract(0) == rho
-        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
-        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
-
-
-class DrudeLorentzPureDephasingModel:
-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
-        solver.
-    """
-    def __init__(self, lam, gamma, T, Nk):
-        self.lam = lam
-        self.gamma = gamma
-        self.T = T
-        self.Nk = Nk
-        # we add a very weak system hamiltonian here to avoid having
-        # singular system that causes problems for the scipy.sparse.linalg
-        # superLU solver used in spsolve.
-        self.H = Qobj(1e-5 * np.ones((2, 2)))
-        self.Q = sigmaz()
-
-    def rho(self):
-        """ Initial state. """
-        return 0.5 * Qobj(np.ones((2, 2)))
-
-    def state_results(self, states):
-        projector = basis(2, 0) * basis(2, 1).dag()
-        return expect(states, projector)
-
-    def analytic_results(self, tlist):
-        lam, gamma, T = self.lam, self.gamma, self.T
-        lam_c = lam / np.pi
-
-        def _integrand(omega, t):
-            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
-            return (-4 * J * (1 - np.cos(omega*t))
-                    / (np.tanh(0.5*omega / T) * omega**2))
-
-        # Calculate the analytical results by numerical integration
-        return [
-            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-            for t in tlist
-        ]
-
-    def bath_coefficients(self):
-        """ Correlation function expansion coefficients for the Drude-Lorentz
-            bath.
-        """
-        lam, gamma, T = self.lam, self.gamma, self.T
-        Nk = self.Nk
-        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
-        ck_real.extend([
-            (4 * lam * gamma * T * 2 * np.pi * k * T /
-                ((2 * np.pi * k * T)**2 - gamma**2))
-            for k in range(1, Nk + 1)
-        ])
-        vk_real = [gamma]
-        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
-        ck_imag = [lam * gamma * (-1.0)]
-        vk_imag = [gamma]
-        return ck_real, vk_real, ck_imag, vk_imag
-
-
-class UnderdampedPureDephasingModel:
-    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
-        solver.
-    """
-    def __init__(self, lam,  gamma, w0, T, Nk):
-        self.lam = lam
-        self.gamma = gamma
-        self.w0 = w0
-        self.T = T
-        self.Nk = Nk
-        # we add a very weak system hamiltonian here to avoid having
-        # singular system that causes problems for the scipy.sparse.linalg
-        # superLU solver used in spsolve.
-        self.H = Qobj(1e-5 * np.ones((2, 2)))
-        self.Q = sigmaz()
-
-    def rho(self):
-        """ Initial state. """
-        return 0.5 * Qobj(np.ones((2, 2)))
-
-    def state_results(self, states):
-        projector = basis(2, 0) * basis(2, 1).dag()
-        return expect(states, projector)
-
-    def analytic_results(self, tlist):
-        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
-        lam_c = lam**2 / np.pi
-
-        def _integrand(omega, t):
-            Jw = (
-                lam_c * omega * gamma /
-                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
-            )
-            return (-4 * Jw * (1 - np.cos(omega*t))
-                    / (np.tanh(0.5*omega / T) * omega**2))
-
-        return [
-            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-            for t in tlist
-        ]
-
-
-class BosonicMode:
-    """ A description of a bosonic mode for inclusion in a
-        DiscreteLevelCurrentModel.
-    """
-    def __init__(self, N, Lambda, Omega, gamma_b):
-        self.N = N
-        self.Lambda = Lambda
-        self.Omega = Omega
-        self.gamma_b = gamma_b
-
-    def bath_coefficients(self):
-        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
-        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
-
-        ck_imag = [
-            -1.0j * self.Omega + self.gamma_b / 2,
-            1.0j * self.Omega + self.gamma_b / 2,
-        ]
-        vk_imag = [
-            -1.0j * self.Omega + self.gamma_b / 2,
-            1.0j * self.Omega + self.gamma_b / 2,
-        ]
-        return ck_real, ck_imag, vk_real, vk_imag
-
-
-class DiscreteLevelCurrentModel:
-    """ Analytic discrete level current model for testing the HEOM solver
-        with a fermionic bath (and optionally a bosonic mode).
-    """
-    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
-        # single fermion
-        self.e1 = e1  # energy
-
-        # parameters for the fermionic leads
-        self.gamma = gamma
-        self.W = W
-        self.T = T
-        self.lmax = lmax  # Pade cut-off
-        self.beta = 1. / T
-        self.theta = theta  # bias
-
-        # bosonic_mode
-        self.bosonic_mode = bosonic_mode
-
-        # Construct Hamiltonian and coupling operator
-        if self.bosonic_mode is None:
-            d1 = destroy(2)
-            self.H = self.e1 * d1.dag() @ d1
-            self.Q = d1
-            self._sys_occupation_op = d1.dag() @ d1
-        else:
-            d1 = destroy(2) & qeye(self.bosonic_mode.N)
-            a = qeye(2) & destroy(self.bosonic_mode.N)
-            self.H = (
-                self.e1 * d1.dag() @ d1 +
-                self.bosonic_mode.Omega * a.dag() @ a +
-                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
-            )
-            if self.bosonic_mode.gamma_b != 0:
-                # apply phenomenological damping:
-                self.H = liouvillian(
-                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
-                )
-            self.Q = d1
-            self._sys_occupation_op = d1.dag() @ d1
-
-    def rho(self, rho_fermion=None):
-        """ Return initial system density matrix given the density matrix for
-            the single Fermionic mode.
-        """
-        if rho_fermion is None:
-            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
-        elif rho_fermion.isket:
-            rho_fermion = rho_fermion.proj()
-        if self.bosonic_mode is None:
-            rho = rho_fermion
-        else:
-            bm0 = basis(self.bosonic_mode.N, 0)
-            rho = rho_fermion & (bm0 @ bm0.dag())
-        return rho
-
-    def sys_occupation(self, state):
-        return expect(state, self._sys_occupation_op)
-
-    def state_current(self, ado_state, tags=None):
-        level_1_aux = [
-            (ado_state.extract(label), ado_state.exps(label)[0])
-            for label in ado_state.filter(level=1, tags=tags)
-        ]
-
-        def exp_sign(exp):
-            return 1 if exp.type == exp.types["+"] else -1
-
-        def exp_op(exp):
-            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
-
-        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
-        # and thus the first 2 * k exponents
-        k = self.lmax + 1
-        return 1.0j * sum(
-            exp_sign(exp) * (exp_op(exp) * aux).tr()
-            for aux, exp in level_1_aux[:2 * k]
-        )
-
-    def analytic_current(self):
-        if self.bosonic_mode is not None:
-            raise RuntimeError(
-                "Analytic calculation of the current is not implemented in the"
-                " case where a bosonic mode is present."
-            )
-
-        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
-        mu_l = self.theta / 2.
-        mu_r = - self.theta / 2.
-
-        def f(x):
-            return 1 / (np.exp(x) + 1.)
-
-        def Gamma_w(w, mu):
-            return Gamma * W**2 / ((w-mu)**2 + W**2)
-
-        def lamshift(w, mu):
-            return (w-mu)*Gamma_w(w, mu)/(2*W)
-
-        def integrand(w):
-            return (
-                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
-                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
-                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
-                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
-            )
-
-        def real_func(x):
-            return np.real(integrand(x))
-
-        def imag_func(x):
-            return np.imag(integrand(x))
-
-        # These integral bounds should be checked to be wide enough if the
-        # parameters are changed
-        a = -2
-        b = 2
-        real_integral = quad(real_func, a, b)
-        imag_integral = quad(imag_func, a, b)
-
-        return real_integral[0] + 1.0j * imag_integral[0]
-
-    def bath_coefficients(self):
-        """ Correlation function expansion coefficients for the fermionic bath.
-        """
-        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
-        mu_l = self.theta / 2.
-        mu_r = - self.theta / 2.
-
-        def deltafun(j, k):
-            return 1. if j == k else 0.
-
-        Alpha = np.zeros((2 * lmax, 2 * lmax))
-        for j in range(2*lmax):
-            for k in range(2*lmax):
-                Alpha[j][k] = (
-                    (deltafun(j, k + 1) + deltafun(j, k - 1))
-                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
-                )
-
-        eigvalsA = eigvalsh(Alpha)
-
-        eps = []
-        for val in eigvalsA[0:lmax]:
-            eps.append(-2 / val)
-
-        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
-        for j in range(2 * lmax - 1):
-            for k in range(2 * lmax - 1):
-                AlphaP[j][k] = (
-                    (deltafun(j, k + 1) + deltafun(j, k - 1))
-                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
-                )
-
-        eigvalsAP = eigvalsh(AlphaP)
-
-        chi = []
-        for val in eigvalsAP[0:lmax - 1]:
-            chi.append(-2/val)
-
-        eta_list = [
-            0.5 * lmax * (2 * (lmax + 1) - 1) * (
-                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
-                np.prod([
-                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
-                ])
-            )
-            for j in range(lmax)
-        ]
-
-        kappa = [0] + eta_list
-        epsilon = [0] + eps
-
-        def f_approx(x):
-            f = 0.5
-            for ll in range(1, lmax + 1):
-                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
-            return f
-
-        def C(sigma, mu):
-            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
-            gamma_0 = W - sigma*1.0j*mu
-            eta_list = [eta_0]
-            gamma_list = [gamma_0]
-            if lmax > 0:
-                for ll in range(1, lmax + 1):
-                    eta_list.append(
-                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
-                        / (-(epsilon[ll]**2 / beta**2) + W**2)
-                    )
-                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
-            return eta_list, gamma_list
-
-        etapL, gampL = C(1.0, mu_l)
-        etamL, gammL = C(-1.0, mu_l)
-
-        etapR, gampR = C(1.0, mu_r)
-        etamR, gammR = C(-1.0, mu_r)
-
-        ck_plus = etapR + etapL
-        vk_plus = gampR + gampL
-        ck_minus = etamR + etamL
-        vk_minus = gammR + gammL
-
-        return ck_plus, vk_plus, ck_minus, vk_minus
-
-
-_HAMILTONIAN_EVO_KINDS = {
-    "qobj": lambda H: H,
-    "qobjevo_const": lambda H: QobjEvo([H]),
-    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
-    "listevo_const": lambda H: [H],
-}
-
-
-def hamiltonian_to_sys(H, evo, liouvillianize):
-    if liouvillianize:
-        H = liouvillian(H)
-    H = _HAMILTONIAN_EVO_KINDS[evo](H)
-    return H
-
-
-class TestHEOMSolver:
-    def test_create_bosonic(self):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
-            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
-            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
-        ]
-        bath = Bath(exponents)
-
-        hsolver = HEOMSolver(H, bath, 2)
-        assert hsolver.ados.exponents == exponents
-        assert hsolver.ados.max_depth == 2
-
-        hsolver = HEOMSolver(H, [bath] * 3, 2)
-        assert hsolver.ados.exponents == exponents * 3
-        assert hsolver.ados.max_depth == 2
-
-    def test_create_fermionic(self):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
-            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
-        ]
-        bath = Bath(exponents)
-
-        hsolver = HEOMSolver(H, bath, 2)
-        assert hsolver.ados.exponents == exponents
-        assert hsolver.ados.max_depth == 2
-
-        hsolver = HEOMSolver(H, [bath] * 3, 2)
-        assert hsolver.ados.exponents == exponents * 3
-        assert hsolver.ados.max_depth == 2
-
-    def test_create_mixed_bosonic_and_fermionic(self):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
-            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
-            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
-        ]
-        bath = Bath(exponents)
-
-        hsolver = HEOMSolver(H, bath, 2)
-        assert hsolver.ados.exponents == exponents
-        assert hsolver.ados.max_depth == 2
-
-        hsolver = HEOMSolver(H, [bath] * 3, 2)
-        assert hsolver.ados.exponents == exponents * 3
-        assert hsolver.ados.max_depth == 2
-
-    def test_create_bath_errors(self):
-        Q = sigmaz()
-        H = sigmax()
-        mixed_q_dims = [
-            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
-            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
-        ]
-
-        with pytest.raises(ValueError) as err:
-            HEOMSolver(H, Bath(mixed_q_dims), 2)
-        assert str(err.value) == (
-            "All bath exponents must have system coupling operators with the"
-            " same dimensions but a mixture of dimensions was given."
-        )
-
-    def test_create_h_sys_errors(self):
-        H = object()
-        with pytest.raises(TypeError) as err:
-            HEOMSolver(H, Bath([]), 2)
-        assert str(err.value) == (
-            "The Hamiltonian (H) must be a Qobj or QobjEvo"
-        )
-
-        H = [sigmax()]
-        with pytest.raises(TypeError) as err:
-            HEOMSolver([H], Bath([]), 2)
-        assert str(err.value) == (
-            "The Hamiltonian (H) must be a Qobj or QobjEvo"
-        )
-
-    @pytest.mark.parametrize(['method'], [
-        pytest.param("run", id="run"),
-        pytest.param("start", id="start"),
-    ])
-    def test_invalid_rho0_errors(self, method):
-        Q = sigmaz()
-        H = sigmax()
-        exponents = [
-            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
-            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
-            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
-        ]
-        bath = Bath(exponents)
-        hsolver = HEOMSolver(H, bath, 2)
-
-        if method == "run":
-            def solve_method(rho0):
-                return hsolver.run(rho0, [0, 1])
-        elif method == "start":
-            def solve_method(rho0):
-                return hsolver.start(rho0, 0)
-        else:
-            assert False, f"method {method} not supported by test"
-
-        with pytest.raises(ValueError) as err:
-            solve_method(basis(3, 0))
-        assert str(err.value) == (
-            "Initial state rho has dims [[3], [1]]"
-            " but the system dims are [[2], [2]]"
-        )
-
-        with pytest.raises(TypeError) as err:
-            solve_method("batman")
-        assert str(err.value) == (
-            "Initial ADOs passed have type <class 'str'> but a "
-            "HierarchyADOsState or a numpy array-like instance was expected"
-        )
-
-        with pytest.raises(ValueError) as err:
-            solve_method(np.array([1, 2, 3]))
-        assert str(err.value) == (
-            "Initial ADOs passed have shape (3,) but the solver hierarchy"
-            " shape is (10, 2, 2)"
-        )
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj", id="qobj"),
-        pytest.param("qobjevo_const", id="qobjevo_const"),
-        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_pure_dephasing_model_bosonic_bath(
-        self, evo, liouvillianize, atol=1e-3
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 15000, "store_states": True}
-        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(dlm.rho(), tlist)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            test = dlm.state_results([rho_final])
-            expected = dlm.analytic_results([100])
-            np.testing.assert_allclose(test, expected, atol=atol)
-            assert rho_final == ado_state.extract(0)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['terminator'], [
-        pytest.param(True, id="terminator"),
-        pytest.param(False, id="noterminator"),
-    ])
-    @pytest.mark.parametrize(['bath_cls'], [
-        pytest.param(DrudeLorentzBath, id="matsubara"),
-        pytest.param(DrudeLorentzPadeBath, id="pade"),
-    ])
-    def test_pure_dephasing_model_drude_lorentz_baths(
-        self, terminator, bath_cls, atol=1e-3
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        bath = bath_cls(
-            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
-        )
-        if terminator:
-            _, terminator_op = bath.terminator()
-            H_sys = liouvillian(dlm.H) + terminator_op
-        else:
-            H_sys = dlm.H
-
-        options = {"nsteps": 15000, "store_states": True}
-        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(dlm.rho(), tlist)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        rho_final, ado_state = hsolver.steady_state()
-        test = dlm.state_results([rho_final])
-        expected = dlm.analytic_results([100])
-        np.testing.assert_allclose(test, expected, atol=atol)
-        assert rho_final == ado_state.extract(0)
-
-    def test_underdamped_pure_dephasing_model_underdamped_bath(
-        self, atol=1e-3
-    ):
-        udm = UnderdampedPureDephasingModel(
-            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
-        )
-        bath = UnderDampedBath(
-            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
-            w0=udm.w0,
-        )
-
-        options = {"nsteps": 15000, "store_states": True}
-        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(udm.rho(), tlist)
-
-        test = udm.state_results(result.states)
-        expected = udm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        rho_final, ado_state = hsolver.steady_state()
-        test = udm.state_results([rho_final])
-        expected = udm.analytic_results([5000])
-        np.testing.assert_allclose(test, expected, atol=atol)
-        assert rho_final == ado_state.extract(0)
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj"),
-        pytest.param("qobjevo_const"),
-        pytest.param("qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.025851991, lmax=10,
-        )
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
-
-        options = {
-            "store_states": True,
-            "store_ados": True,
-            "nsteps": 15_000,
-            "rtol": 1e-7,
-            "atol": 1e-7,
-        }
-        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
-        # for a single impurity we converge with max_depth = 2
-        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
-
-        tlist = [0, 600]
-        result = hsolver.run(dlm.rho(), tlist)
-        current = dlm.state_current(result.ado_states[-1])
-        analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            current = dlm.state_current(ado_state)
-            analytic_current = dlm.analytic_current()
-            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
-        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
-        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
-    ])
-    def test_discrete_level_model_lorentzian_baths(
-        self, bath_cls, analytic_current, atol=1e-3
-    ):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.025851991, lmax=10,
-        )
-
-        options = {
-            "nsteps": 15_000, "store_states": True, "store_ados": True,
-            "rtol": 1e-7, "atol": 1e-7,
-        }
-        bath_l = bath_cls(
-            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
-            Nk=dlm.lmax,
-        )
-        bath_r = bath_cls(
-            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
-            Nk=dlm.lmax,
-        )
-        # for a single impurity we converge with max_depth = 2
-        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
-
-        tlist = [0, 600]
-        result = hsolver.run(dlm.rho(), tlist)
-        current = dlm.state_current(result.ado_states[-1])
-        # analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-        rho_final, ado_state = hsolver.steady_state()
-        current = dlm.state_current(ado_state)
-        # analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj"),
-        pytest.param("qobjevo_const"),
-        pytest.param("qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
-        self, evo, liouvillianize
-    ):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.025851991, lmax=10,
-        )
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
-
-        options = {
-            "store_states": True,
-            "store_ados": True,
-            "nsteps": 15_000,
-            "rtol": 1e-7,
-            "atol": 1e-7,
-        }
-        fermionic_bath = FermionicBath(
-            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
-        )
-        # very weak bosonic coupling which should not affect the dynamics of
-        # the interaction between the system and the fermionic bath:
-        eps = [1e-10] * 5
-        bosonic_Q = sigmax()
-        bosonic_bath = BosonicBath(
-            bosonic_Q, eps, eps, eps, eps, combine=False,
-        )
-        # for a single impurity we converge with max_depth = 2
-        # we specify the bosonic bath first to ensure that the test checks
-        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
-        # mode is before the fermionic ones
-        hsolver = HEOMSolver(
-            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
-        )
-
-        tlist = [0, 600]
-        result = hsolver.run(dlm.rho(), tlist)
-        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
-        analytic_current = dlm.analytic_current()
-        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            current = dlm.state_current(ado_state)
-            analytic_current = dlm.analytic_current()
-            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj"),
-        pytest.param("qobjevo_const"),
-        pytest.param("qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
-        self, evo, liouvillianize
-    ):
-        dlm = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
-        )
-        bosonic_mode = BosonicMode(
-            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
-        )
-
-        dlm_ref = DiscreteLevelCurrentModel(
-            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
-            bosonic_mode=bosonic_mode,
-        )
-
-        options = {
-            "store_states": True,
-            "store_ados": True,
-            "nsteps": 15_000,
-            "rtol": 1e-7,
-            "atol": 1e-7,
-        }
-
-        # First we construct a solver with the boson modelled as part of the
-        # system and only a single Fermionic bath. This will provide the
-        # reference result for the test:
-        fermionic_bath_ref = FermionicBath(
-            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
-        )
-
-        hsolver_ref = HEOMSolver(
-            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
-        )
-
-        # Then we construct a solver for the same system, but with the
-        # bosonic mode as a bath This is the result we would like to check:
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        fermionic_bath = FermionicBath(
-            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
-        )
-
-        bosonic_bath = BosonicBath(
-            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
-            combine=True, tag="bosonic",
-        )
-
-        hsolver = HEOMSolver(
-            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
-        )
-
-        # Calculate currents and occupations:
-        tlist = np.linspace(0, 1000, 300)
-        psi0 = basis(2, 0)
-
-        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
-        current_ref = [
-            dlm_ref.state_current(ado_state, tags=["fermionic"])
-            for ado_state in result_ref.ado_states
-        ]
-        sys_occupation_ref = dlm_ref.sys_occupation(
-            result_ref.states
-        )
-
-        result = hsolver.run(dlm.rho(psi0), tlist)
-        current = [
-            dlm.state_current(ado_state, tags=["fermionic"])
-            for ado_state in result.ado_states
-        ]
-        sys_occupation = dlm.sys_occupation(result.states)
-
-        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
-        np.testing.assert_allclose(
-            sys_occupation_ref, sys_occupation, rtol=1e-3,
-        )
-
-        if evo != "qobjevo_timedep":
-            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
-            current_ss_ref = dlm_ref.state_current(ado_state_ref)
-            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
-
-            rho_final, ado_state = hsolver.steady_state()
-            current_ss = dlm.state_current(ado_state)
-            sys_occupation_ss = dlm.sys_occupation(rho_final)
-
-            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
-            np.testing.assert_allclose(
-                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
-            )
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['ado_format'], [
-        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
-        pytest.param("numpy", id="numpy"),
-    ])
-    def test_ado_input_and_return(self, ado_format):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {
-            "nsteps": 15_000, "store_states": True, "store_ados": True,
-        }
-        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
-
-        tlist_1 = [0, 1, 2]
-        result_1 = hsolver.run(dlm.rho(), tlist_1)
-
-        tlist_2 = [2, 3, 4]
-        rho0 = result_1.ado_states[-1]
-        if ado_format == "numpy":
-            rho0 = rho0._ado_state  # extract the raw numpy array
-        result_2 = hsolver.run(rho0, tlist_2)
-
-        tlist_full = tlist_1 + tlist_2[1:]
-        result_full = hsolver.run(dlm.rho(), tlist_full)
-
-        times_12 = result_1.times + result_2.times[1:]
-        times_full = result_full.times
-        assert times_12 == tlist_full
-        assert times_full == tlist_full
-
-        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
-        ado_states_full = result_full.ado_states
-        assert len(ado_states_12) == len(tlist_full)
-        assert len(ado_states_full) == len(tlist_full)
-        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
-            for label in hsolver.ados.labels:
-                np.testing.assert_allclose(
-                    ado_12.extract(label).full(),
-                    ado_full.extract(label).full(),
-                    atol=1e-6,
-                )
-
-        states_12 = result_1.states + result_2.states[1:]
-        states_full = result_full.states
-        assert len(states_12) == len(tlist_full)
-        assert len(states_full) == len(tlist_full)
-        for ado_12, state_12 in zip(ado_states_12, states_12):
-            assert ado_12.rho == state_12
-        for ado_full, state_full in zip(ado_states_full, states_full):
-            assert ado_full.rho == state_full
-
-        expected = dlm.analytic_results(tlist_full)
-        test_12 = dlm.state_results(states_12)
-        np.testing.assert_allclose(test_12, expected, atol=1e-3)
-        test_full = dlm.state_results(states_full)
-        np.testing.assert_allclose(test_full, expected, atol=1e-3)
-
-    def test_solving_with_step(self):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 15_000, "store_ados": True}
-        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
-
-        tlist = np.linspace(0, 10, 21)
-        ado_state = None
-        states = [dlm.rho()]
-        hsolver.start(states[0], 0)
-        for t in tlist[1:]:
-            ado_state = hsolver.step(t)
-            states.append(ado_state.rho)
-
-        test = dlm.state_results(states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=1e-3)
-
-        assert states[-1] == ado_state.extract(0)
-
-
-class TestHeomsolveFunction:
-    @pytest.mark.parametrize(['evo'], [
-        pytest.param("qobj", id="qobj"),
-        pytest.param("listevo_const", id="listevo_const"),
-        pytest.param("qobjevo_const", id="qobjevo_const"),
-        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_heomsolve_with_pure_dephasing_model(
-        self, evo, liouvillianize, atol=1e-3
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 15000, "store_states": True}
-
-        e_ops = {
-            "11": basis(2, 0) * basis(2, 0).dag(),
-            "22": basis(2, 1) * basis(2, 1).dag(),
-        }
-
-        tlist = np.linspace(0, 10, 21)
-        result = heomsolve(
-            H_sys, bath, 14, dlm.rho(), tlist,
-            e_ops=e_ops, args={"foo": 1}, options=options)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        for label in ["11", "22"]:
-            np.testing.assert_allclose(
-                result.e_data[label],
-                [expect(rho, e_ops[label]) for rho in result.states],
-                atol=atol,
-            )
-
-
-class TestHSolverDL:
-    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
-        pytest.param(True, 1e-4, id="bnd_cut_approx"),
-        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
-    ])
-    @pytest.mark.parametrize(['evo', 'combine'], [
-        pytest.param("qobj", True, id="qobj-combined"),
-        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
-        pytest.param("listevo_const", True, id="listevo-const-combined"),
-        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
-        pytest.param(
-            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
-        ),
-    ])
-    @pytest.mark.parametrize(['liouvillianize'], [
-        pytest.param(False, id="hamiltonian"),
-        pytest.param(True, id="liouvillian"),
-    ])
-    def test_pure_dephasing_model(
-        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
-    ):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
-
-        options = {"nsteps": 15_000, "store_states": True}
-        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
-                            14, 2, dlm.gamma,
-                            bnd_cut_approx=bnd_cut_approx,
-                            options=options, combine=combine)
-
-        tlist = np.linspace(0, 10, 21)
-        result = hsolver.run(dlm.rho(), tlist)
-
-        test = dlm.state_results(result.states)
-        expected = dlm.analytic_results(tlist)
-        np.testing.assert_allclose(test, expected, atol=atol)
-
-        if evo != "qobjevo_timedep":
-            rho_final, ado_state = hsolver.steady_state()
-            test = dlm.state_results([rho_final])
-            expected = dlm.analytic_results([100])
-            np.testing.assert_allclose(test, expected, atol=atol)
-            assert rho_final == ado_state.extract(0)
-        else:
-            assert_raises_steady_state_time_dependent(hsolver)
-
-    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
-        pytest.param(True, 1e-4, id="bnd_cut_approx"),
-        pytest.param(False, 1e-3, id="renorm"),
-    ])
-    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
-        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
-        # is repeated here to ensure the new HSolverDL remains compatibile
-        # with the old one until it is removed.
-        cut_frequency = 0.05
-        coupling_strength = 0.025
-        lam_c = coupling_strength / np.pi
-        temperature = 1 / 0.95
-        times = np.linspace(0, 10, 21)
-
-        def _integrand(omega, t):
-            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
-            return (-4 * J * (1 - np.cos(omega*t))
-                    / (np.tanh(0.5*omega / temperature) * omega**2))
-
-        # Calculate the analytical results by numerical integration
-        expected = [
-            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
-            for t in times
-        ]
-
-        H_sys = Qobj(np.zeros((2, 2)))
-        Q = sigmaz()
-        initial_state = 0.5*Qobj(np.ones((2, 2)))
-        projector = basis(2, 0) * basis(2, 1).dag()
-        options = {"nsteps": 15_000, "store_states": True}
-        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
-                            20, 2, cut_frequency,
-                            bnd_cut_approx=bnd_cut_approx,
-                            options=options)
-        test = expect(hsolver.run(initial_state, times).states, projector)
-        np.testing.assert_allclose(test, expected, atol=tol)
-
-    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
-    def test_integration_error(self):
-        dlm = DrudeLorentzPureDephasingModel(
-            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
-        )
-        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
-
-        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
-        options = {"nsteps": 10}
-        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
-
-        with pytest.raises(IntegratorException) as err:
-            hsolver.run(dlm.rho(), tlist=[0, 10])
-
-        assert str(err.value) == (
-            "Excess work done on this call. Try to increasing the nsteps"
-            " parameter in the Options class"
-        )
-
-
-class TestHEOMResult:
-    def mk_ados(self, bath_dims, max_depth):
-        exponents = [
-            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
-        ]
-        ados = HierarchyADOs(exponents, max_depth=max_depth)
-        return ados
-
-    def mk_rho_and_soln(self, ados, rho_dims):
-        n_ados = len(ados.labels)
-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
-        rho = Qobj(ado_soln[0, :], dims=rho_dims)
-        return rho, ado_soln
-
-    def test_create_ado_states_attribute(self):
-        options = fill_options()
-        result = HEOMResult(e_ops=[], options=options)
-        assert not hasattr(result, "final_ado_state")
-        assert not hasattr(result, "ado_states")
-        assert result.store_ados is False
-
-        options = fill_options(store_ados=True)
-        result = HEOMResult(e_ops=[], options=options)
-        assert result.final_ado_state is None
-        assert result.ado_states == []
-        assert result.store_ados is True
-
-    @pytest.mark.parametrize(['e_op_type'], [
-        pytest.param("qobj", id="qobj"),
-        pytest.param("qobjevo", id="qobjevo"),
-        pytest.param("callable", id="callable"),
-    ])
-    def test_e_ops(self, e_op_type):
-        op = Qobj([[1, 0], [0, 0]])
-        if e_op_type == "qobj":
-            e_op = op
-        elif e_op_type == "qobjevo":
-            e_op = QobjEvo(op)
-        elif e_op_type == "callable":
-            def e_op(f, ado_state):
-                return expect(op, ado_state.rho)
-        else:
-            assert False, f"unknown e_op_type {e_op_type!r}"
-
-        options = fill_options()
-        result = HEOMResult(e_ops=e_op, options=options)
-
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        e_op_value = expect(op, rho)
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-
-        result.add(0.1, ado_state)
-
-        assert result.expect[0] == [e_op_value]
-        assert result.e_data[0] == [e_op_value]
-
-    def test_store_state(self):
-        options = fill_options()
-        result = HEOMResult(e_ops=[], options=options)
-
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-
-        result.add(0.1, ado_state)
-
-        assert result.times == [0.1]
-        assert result.states == [rho]
-        assert result.final_state is rho
-
-    def test_store_ados(self):
-        options = fill_options(store_ados=True)
-        result = HEOMResult(e_ops=[], options=options)
-
-        ados = self.mk_ados([2, 3], max_depth=2)
-        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
-        ado_state = HierarchyADOsState(rho, ados, ado_soln)
-
-        result.add(0.1, ado_state)
-        assert result.times == [0.1]
-        assert result.states == [rho]
-        assert result.final_state is rho
-        assert result.ado_states == [ado_state]
-        assert result.final_ado_state is ado_state
-
-
-class Test_GatherHEOMRHS:
-    def test_simple_gather(self):
-        def f(label):
-            return int(label.lstrip("o"))
-
-        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
-
-        for i in range(3):
-            for j in range(3):
-                base = 10 * (j * 2) + (i * 2)
-                block_op = _data.to(
-                    _data.CSR,
-                    _data.create(np.array([
-                        [base, base + 10],
-                        [base + 1, base + 11],
-                    ]))
-                )
-                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
-
-        op = gather_heoms.gather()
-
-        expected_op = np.array([
-            [10 * i + j for i in range(2 * 3)]
-            for j in range(2 * 3)
-        ], dtype=np.complex128)
-
-        np.testing.assert_array_equal(op.to_array(), expected_op)
-        assert isinstance(op, _data.CSR)
+"""
+Tests for qutip.nonmarkov.bofin_solvers.
+"""
+
+import numpy as np
+import pytest
+from numpy.linalg import eigvalsh
+from scipy.integrate import quad
+
+from qutip import (
+    basis, destroy, expect, liouvillian, qeye, sigmax, sigmaz,
+    tensor, Qobj, QobjEvo
+)
+from qutip.core import data as _data
+from qutip.solver.heom.bofin_baths import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+)
+from qutip.solver.heom.bofin_solvers import (
+    heomsolve,
+    HierarchyADOs,
+    HierarchyADOsState,
+    HEOMResult,
+    HEOMSolver,
+    HSolverDL,
+    _GatherHEOMRHS,
+)
+from qutip.solver import (
+    IntegratorException,
+)
+
+
+def fill_options(**kwargs):
+    """Fill the options with minimal entries needed by HEOMResult."""
+    return {
+        "store_final_state": False,
+        "store_states": None,
+        "store_ados": False,
+        **kwargs
+    }
+
+
+def assert_raises_steady_state_time_dependent(hsolver):
+    """ Assert that calling .steady_state() on a HEOMSolver with
+        a time-dependent Hamiltonian raises the appropriate exception.
+    """
+    with pytest.raises(ValueError) as err:
+        hsolver.steady_state()
+    assert str(err.value) == (
+       "A steady state cannot be determined for a time-dependent"
+       " system"
+    )
+
+
+class TestHierarchyADOs:
+    def mk_exponents(self, dims):
+        return [
+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in dims
+        ]
+
+    def test_create(self):
+        exponents = self.mk_exponents([2, 3])
+        ados = HierarchyADOs(exponents, max_depth=2)
+
+        assert ados.exponents == exponents
+        assert ados.max_depth == 2
+
+        assert ados.dims == [2, 3]
+        assert ados.vk == [2.0, 2.0]
+        assert ados.ck == [1.0, 1.0]
+        assert ados.ck2 == [None, None]
+        assert ados.sigma_bar_k_offset == [None, None]
+
+        assert ados.labels == [
+            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
+        ]
+
+    def test_state_idx(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.idx((0, 0)) == 0
+        assert ados.idx((0, 1)) == 1
+        assert ados.idx((0, 2)) == 2
+        assert ados.idx((1, 0)) == 3
+        assert ados.idx((1, 1)) == 4
+
+    def test_next(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.next((0, 0), 0) == (1, 0)
+        assert ados.next((0, 0), 1) == (0, 1)
+        assert ados.next((1, 0), 0) is None
+        assert ados.next((1, 0), 1) == (1, 1)
+        assert ados.next((1, 1), 1) is None
+
+    def test_prev(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.prev((0, 0), 0) is None
+        assert ados.prev((0, 0), 1) is None
+        assert ados.prev((1, 0), 0) == (0, 0)
+        assert ados.prev((0, 1), 1) == (0, 0)
+        assert ados.prev((1, 1), 1) == (1, 0)
+        assert ados.prev((0, 2), 1) == (0, 1)
+
+    def test_exps(self):
+        ados = HierarchyADOs(self.mk_exponents([3, 3, 2]), max_depth=4)
+        assert ados.exps((0, 0, 0)) == ()
+        assert ados.exps((1, 0, 0)) == (ados.exponents[0],)
+        assert ados.exps((2, 0, 0)) == (
+            ados.exponents[0], ados.exponents[0],
+        )
+        assert ados.exps((1, 2, 1)) == (
+            ados.exponents[0],
+            ados.exponents[1], ados.exponents[1],
+            ados.exponents[2],
+        )
+
+    def test_filter_by_nothing(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.filter() == [
+            (0, 0), (0, 1), (0, 2), (1, 0), (1, 1),
+        ]
+
+    def test_filter_by_level(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.filter(level=0) == [
+            (0, 0),
+        ]
+        assert ados.filter(level=1) == [
+            (0, 1),
+            (1, 0),
+        ]
+        assert ados.filter(level=2) == [
+            (0, 2),
+            (1, 1),
+        ]
+        assert ados.filter(level=3) == []
+
+    def test_filter_by_exponents(self):
+        ados = HierarchyADOs(self.mk_exponents([2, 3]), max_depth=2)
+        assert ados.filter(dims=[]) == [
+            (0, 0),
+        ]
+        assert ados.filter(dims=[2]) == [
+            (1, 0),
+        ]
+        assert ados.filter(level=1, dims=[2]) == [
+            (1, 0),
+        ]
+        assert ados.filter(dims=[3]) == [
+            (0, 1),
+        ]
+        assert ados.filter(dims=[2, 3]) == [
+            (1, 1),
+        ]
+        assert ados.filter(level=2, dims=[2, 3]) == [
+            (1, 1),
+        ]
+        assert ados.filter(dims=[3, 3]) == [
+            (0, 2),
+        ]
+        assert ados.filter(types=["I"]) == [
+            (0, 1),
+            (1, 0),
+        ]
+        assert ados.filter(types=["I", "I"]) == [
+            (0, 2),
+            (1, 1),
+        ]
+
+        with pytest.raises(ValueError) as err:
+            ados.filter(types=[], dims=[2])
+        assert str(err.value) == (
+            "The tags, dims and types filters must all be the same length."
+        )
+
+        with pytest.raises(ValueError) as err:
+            ados.filter(dims=[2, 2, 2])
+        assert str(err.value) == (
+            "The maximum depth for the hierarchy is 2 but 3 levels of"
+            " excitation filters were given."
+        )
+
+        with pytest.raises(ValueError) as err:
+            ados.filter(level=0, dims=[2])
+        assert str(err.value) == (
+            "The level parameter is 0 but 1 levels of excitation filters"
+            " were given."
+        )
+
+
+class TestHierarchyADOsState:
+    def mk_ados(self, bath_dims, max_depth):
+        exponents = [
+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
+        ]
+        ados = HierarchyADOs(exponents, max_depth=max_depth)
+        return ados
+
+    def mk_rho_and_soln(self, ados, rho_dims):
+        n_ados = len(ados.labels)
+        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+        rho = Qobj(ado_soln[0, :], dims=rho_dims)
+        return rho, ado_soln
+
+    def test_create(self):
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+        assert ado_state.rho == rho
+        assert ado_state.labels == ados.labels
+        assert ado_state.exponents == ados.exponents
+        assert ado_state.idx((0, 0)) == ados.idx((0, 0))
+        assert ado_state.idx((0, 1)) == ados.idx((0, 1))
+
+    def test_extract(self):
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+        ado_state.extract((0, 0)) == rho
+        ado_state.extract(0) == rho
+        ado_state.extract((0, 1)) == Qobj(ado_soln[1, :], dims=rho.dims)
+        ado_state.extract(1) == Qobj(ado_soln[1, :], dims=rho.dims)
+
+
+class DrudeLorentzPureDephasingModel:
+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+        solver.
+    """
+    def __init__(self, lam, gamma, T, Nk):
+        self.lam = lam
+        self.gamma = gamma
+        self.T = T
+        self.Nk = Nk
+        # we add a very weak system hamiltonian here to avoid having
+        # singular system that causes problems for the scipy.sparse.linalg
+        # superLU solver used in spsolve.
+        self.H = Qobj(1e-5 * np.ones((2, 2)))
+        self.Q = sigmaz()
+
+    def rho(self):
+        """ Initial state. """
+        return 0.5 * Qobj(np.ones((2, 2)))
+
+    def state_results(self, states):
+        projector = basis(2, 0) * basis(2, 1).dag()
+        return expect(states, projector)
+
+    def analytic_results(self, tlist):
+        lam, gamma, T = self.lam, self.gamma, self.T
+        lam_c = lam / np.pi
+
+        def _integrand(omega, t):
+            J = 2 * lam_c * omega * gamma / (omega**2 + gamma**2)
+            return (-4 * J * (1 - np.cos(omega*t))
+                    / (np.tanh(0.5*omega / T) * omega**2))
+
+        # Calculate the analytical results by numerical integration
+        return [
+            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+            for t in tlist
+        ]
+
+    def bath_coefficients(self):
+        """ Correlation function expansion coefficients for the Drude-Lorentz
+            bath.
+        """
+        lam, gamma, T = self.lam, self.gamma, self.T
+        Nk = self.Nk
+        ck_real = [lam * gamma * (1 / np.tan(gamma / (2 * T)))]
+        ck_real.extend([
+            (4 * lam * gamma * T * 2 * np.pi * k * T /
+                ((2 * np.pi * k * T)**2 - gamma**2))
+            for k in range(1, Nk + 1)
+        ])
+        vk_real = [gamma]
+        vk_real.extend([2 * np.pi * k * T for k in range(1, Nk + 1)])
+        ck_imag = [lam * gamma * (-1.0)]
+        vk_imag = [gamma]
+        return ck_real, vk_real, ck_imag, vk_imag
+
+
+class UnderdampedPureDephasingModel:
+    """ Analytic Drude-Lorentz pure-dephasing model for testing the HEOM
+        solver.
+    """
+    def __init__(self, lam,  gamma, w0, T, Nk):
+        self.lam = lam
+        self.gamma = gamma
+        self.w0 = w0
+        self.T = T
+        self.Nk = Nk
+        # we add a very weak system hamiltonian here to avoid having
+        # singular system that causes problems for the scipy.sparse.linalg
+        # superLU solver used in spsolve.
+        self.H = Qobj(1e-5 * np.ones((2, 2)))
+        self.Q = sigmaz()
+
+    def rho(self):
+        """ Initial state. """
+        return 0.5 * Qobj(np.ones((2, 2)))
+
+    def state_results(self, states):
+        projector = basis(2, 0) * basis(2, 1).dag()
+        return expect(states, projector)
+
+    def analytic_results(self, tlist):
+        lam, gamma, w0, T = self.lam, self.gamma, self.w0, self.T
+        lam_c = lam**2 / np.pi
+
+        def _integrand(omega, t):
+            Jw = (
+                lam_c * omega * gamma /
+                ((w0**2 - omega**2)**2 + gamma**2 * omega**2)
+            )
+            return (-4 * Jw * (1 - np.cos(omega*t))
+                    / (np.tanh(0.5*omega / T) * omega**2))
+
+        return [
+            0.5 * np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+            for t in tlist
+        ]
+
+
+class BosonicMode:
+    """ A description of a bosonic mode for inclusion in a
+        DiscreteLevelCurrentModel.
+    """
+    def __init__(self, N, Lambda, Omega, gamma_b):
+        self.N = N
+        self.Lambda = Lambda
+        self.Omega = Omega
+        self.gamma_b = gamma_b
+
+    def bath_coefficients(self):
+        ck_real = [0.5 * self.Lambda**2, 0.5 * self.Lambda**2]
+        vk_real = [0.5 * 1.0j * self.Lambda**2, -0.5 * 1.0j * self.Lambda**2]
+
+        ck_imag = [
+            -1.0j * self.Omega + self.gamma_b / 2,
+            1.0j * self.Omega + self.gamma_b / 2,
+        ]
+        vk_imag = [
+            -1.0j * self.Omega + self.gamma_b / 2,
+            1.0j * self.Omega + self.gamma_b / 2,
+        ]
+        return ck_real, ck_imag, vk_real, vk_imag
+
+
+class DiscreteLevelCurrentModel:
+    """ Analytic discrete level current model for testing the HEOM solver
+        with a fermionic bath (and optionally a bosonic mode).
+    """
+    def __init__(self, gamma, W, T, lmax, theta=2., e1=1., bosonic_mode=None):
+        # single fermion
+        self.e1 = e1  # energy
+
+        # parameters for the fermionic leads
+        self.gamma = gamma
+        self.W = W
+        self.T = T
+        self.lmax = lmax  # Pade cut-off
+        self.beta = 1. / T
+        self.theta = theta  # bias
+
+        # bosonic_mode
+        self.bosonic_mode = bosonic_mode
+
+        # Construct Hamiltonian and coupling operator
+        if self.bosonic_mode is None:
+            d1 = destroy(2)
+            self.H = self.e1 * d1.dag() @ d1
+            self.Q = d1
+            self._sys_occupation_op = d1.dag() @ d1
+        else:
+            d1 = destroy(2) & qeye(self.bosonic_mode.N)
+            a = qeye(2) & destroy(self.bosonic_mode.N)
+            self.H = (
+                self.e1 * d1.dag() @ d1 +
+                self.bosonic_mode.Omega * a.dag() @ a +
+                self.bosonic_mode.Lambda * (a + a.dag()) @ d1.dag() @ d1
+            )
+            if self.bosonic_mode.gamma_b != 0:
+                # apply phenomenological damping:
+                self.H = liouvillian(
+                    self.H, [np.sqrt(bosonic_mode.gamma_b) * a],
+                )
+            self.Q = d1
+            self._sys_occupation_op = d1.dag() @ d1
+
+    def rho(self, rho_fermion=None):
+        """ Return initial system density matrix given the density matrix for
+            the single Fermionic mode.
+        """
+        if rho_fermion is None:
+            rho_fermion = 0.5 * Qobj(np.ones((2, 2)))
+        elif rho_fermion.isket:
+            rho_fermion = rho_fermion.proj()
+        if self.bosonic_mode is None:
+            rho = rho_fermion
+        else:
+            bm0 = basis(self.bosonic_mode.N, 0)
+            rho = rho_fermion & (bm0 @ bm0.dag())
+        return rho
+
+    def sys_occupation(self, state):
+        return expect(state, self._sys_occupation_op)
+
+    def state_current(self, ado_state, tags=None):
+        level_1_aux = [
+            (ado_state.extract(label), ado_state.exps(label)[0])
+            for label in ado_state.filter(level=1, tags=tags)
+        ]
+
+        def exp_sign(exp):
+            return 1 if exp.type == exp.types["+"] else -1
+
+        def exp_op(exp):
+            return exp.Q if exp.type == exp.types["+"] else exp.Q.dag()
+
+        # right hand modes are the first k modes in ck/vk_plus and ck/vk_minus
+        # and thus the first 2 * k exponents
+        k = self.lmax + 1
+        return 1.0j * sum(
+            exp_sign(exp) * (exp_op(exp) * aux).tr()
+            for aux, exp in level_1_aux[:2 * k]
+        )
+
+    def analytic_current(self):
+        if self.bosonic_mode is not None:
+            raise RuntimeError(
+                "Analytic calculation of the current is not implemented in the"
+                " case where a bosonic mode is present."
+            )
+
+        Gamma, W, beta, e1 = self.gamma, self.W, self.beta, self.e1
+        mu_l = self.theta / 2.
+        mu_r = - self.theta / 2.
+
+        def f(x):
+            return 1 / (np.exp(x) + 1.)
+
+        def Gamma_w(w, mu):
+            return Gamma * W**2 / ((w-mu)**2 + W**2)
+
+        def lamshift(w, mu):
+            return (w-mu)*Gamma_w(w, mu)/(2*W)
+
+        def integrand(w):
+            return (
+                ((2 / (np.pi)) * Gamma_w(w, mu_l) * Gamma_w(w, mu_r) *
+                    (f(beta * (w - mu_l)) - f(beta * (w - mu_r)))) /
+                ((Gamma_w(w, mu_l) + Gamma_w(w, mu_r))**2 + 4 *
+                    (w - e1 - lamshift(w, mu_l) - lamshift(w, mu_r))**2)
+            )
+
+        def real_func(x):
+            return np.real(integrand(x))
+
+        def imag_func(x):
+            return np.imag(integrand(x))
+
+        # These integral bounds should be checked to be wide enough if the
+        # parameters are changed
+        a = -2
+        b = 2
+        real_integral = quad(real_func, a, b)
+        imag_integral = quad(imag_func, a, b)
+
+        return real_integral[0] + 1.0j * imag_integral[0]
+
+    def bath_coefficients(self):
+        """ Correlation function expansion coefficients for the fermionic bath.
+        """
+        Gamma, W, beta, lmax = self.gamma, self.W, self.beta, self.lmax
+        mu_l = self.theta / 2.
+        mu_r = - self.theta / 2.
+
+        def deltafun(j, k):
+            return 1. if j == k else 0.
+
+        Alpha = np.zeros((2 * lmax, 2 * lmax))
+        for j in range(2*lmax):
+            for k in range(2*lmax):
+                Alpha[j][k] = (
+                    (deltafun(j, k + 1) + deltafun(j, k - 1))
+                    / np.sqrt((2 * (j + 1) - 1) * (2 * (k + 1) - 1))
+                )
+
+        eigvalsA = eigvalsh(Alpha)
+
+        eps = []
+        for val in eigvalsA[0:lmax]:
+            eps.append(-2 / val)
+
+        AlphaP = np.zeros((2 * lmax - 1, 2 * lmax - 1))
+        for j in range(2 * lmax - 1):
+            for k in range(2 * lmax - 1):
+                AlphaP[j][k] = (
+                    (deltafun(j, k + 1) + deltafun(j, k - 1))
+                    / np.sqrt((2 * (j + 1) + 1) * (2 * (k + 1) + 1))
+                )
+
+        eigvalsAP = eigvalsh(AlphaP)
+
+        chi = []
+        for val in eigvalsAP[0:lmax - 1]:
+            chi.append(-2/val)
+
+        eta_list = [
+            0.5 * lmax * (2 * (lmax + 1) - 1) * (
+                np.prod([chi[k]**2 - eps[j]**2 for k in range(lmax - 1)]) /
+                np.prod([
+                    eps[k]**2 - eps[j]**2 + deltafun(j, k) for k in range(lmax)
+                ])
+            )
+            for j in range(lmax)
+        ]
+
+        kappa = [0] + eta_list
+        epsilon = [0] + eps
+
+        def f_approx(x):
+            f = 0.5
+            for ll in range(1, lmax + 1):
+                f = f - 2 * kappa[ll] * x / (x**2 + epsilon[ll]**2)
+            return f
+
+        def C(sigma, mu):
+            eta_0 = 0.5 * Gamma * W * f_approx(1.0j * beta * W)
+            gamma_0 = W - sigma*1.0j*mu
+            eta_list = [eta_0]
+            gamma_list = [gamma_0]
+            if lmax > 0:
+                for ll in range(1, lmax + 1):
+                    eta_list.append(
+                        -1.0j * (kappa[ll] / beta) * Gamma * W**2
+                        / (-(epsilon[ll]**2 / beta**2) + W**2)
+                    )
+                    gamma_list.append(epsilon[ll]/beta - sigma*1.0j*mu)
+            return eta_list, gamma_list
+
+        etapL, gampL = C(1.0, mu_l)
+        etamL, gammL = C(-1.0, mu_l)
+
+        etapR, gampR = C(1.0, mu_r)
+        etamR, gammR = C(-1.0, mu_r)
+
+        ck_plus = etapR + etapL
+        vk_plus = gampR + gampL
+        ck_minus = etamR + etamL
+        vk_minus = gammR + gammL
+
+        return ck_plus, vk_plus, ck_minus, vk_minus
+
+
+_HAMILTONIAN_EVO_KINDS = {
+    "qobj": lambda H: H,
+    "qobjevo_const": lambda H: QobjEvo([H]),
+    "qobjevo_timedep": lambda H: QobjEvo([H, lambda t: 1.0]),
+    "listevo_const": lambda H: [H],
+}
+
+
+def hamiltonian_to_sys(H, evo, liouvillianize):
+    if liouvillianize:
+        H = liouvillian(H)
+    H = _HAMILTONIAN_EVO_KINDS[evo](H)
+    return H
+
+
+class TestHEOMSolver:
+    def test_create_bosonic(self):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
+            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
+            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
+        ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_fermionic(self):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
+            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
+        ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_mixed_bosonic_and_fermionic(self):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("+", 2, Q=Q, ck=1.1, vk=2.1, sigma_bar_k_offset=1),
+            BathExponent("-", 2, Q=Q, ck=1.2, vk=2.2, sigma_bar_k_offset=-1),
+            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
+        ]
+        bath = Bath(exponents)
+
+        hsolver = HEOMSolver(H, bath, 2)
+        assert hsolver.ados.exponents == exponents
+        assert hsolver.ados.max_depth == 2
+
+        hsolver = HEOMSolver(H, [bath] * 3, 2)
+        assert hsolver.ados.exponents == exponents * 3
+        assert hsolver.ados.max_depth == 2
+
+    def test_create_bath_errors(self):
+        Q = sigmaz()
+        H = sigmax()
+        mixed_q_dims = [
+            BathExponent("I", 2, Q=tensor(Q, Q), ck=1.2, vk=2.2),
+            BathExponent("R", 2, Q=Q, ck=1.2, vk=2.2),
+        ]
+
+        with pytest.raises(ValueError) as err:
+            HEOMSolver(H, Bath(mixed_q_dims), 2)
+        assert str(err.value) == (
+            "All bath exponents must have system coupling operators with the"
+            " same dimensions but a mixture of dimensions was given."
+        )
+
+    def test_create_h_sys_errors(self):
+        H = object()
+        with pytest.raises(TypeError) as err:
+            HEOMSolver(H, Bath([]), 2)
+        assert str(err.value) == (
+            "The Hamiltonian (H) must be a Qobj or QobjEvo"
+        )
+
+        H = [sigmax()]
+        with pytest.raises(TypeError) as err:
+            HEOMSolver([H], Bath([]), 2)
+        assert str(err.value) == (
+            "The Hamiltonian (H) must be a Qobj or QobjEvo"
+        )
+
+    @pytest.mark.parametrize(['method'], [
+        pytest.param("run", id="run"),
+        pytest.param("start", id="start"),
+    ])
+    def test_invalid_rho0_errors(self, method):
+        Q = sigmaz()
+        H = sigmax()
+        exponents = [
+            BathExponent("R", None, Q=Q, ck=1.1, vk=2.1),
+            BathExponent("I", None, Q=Q, ck=1.2, vk=2.2),
+            BathExponent("RI", None, Q=Q, ck=1.3, vk=2.3, ck2=3.3),
+        ]
+        bath = Bath(exponents)
+        hsolver = HEOMSolver(H, bath, 2)
+
+        if method == "run":
+            def solve_method(rho0):
+                return hsolver.run(rho0, [0, 1])
+        elif method == "start":
+            def solve_method(rho0):
+                return hsolver.start(rho0, 0)
+        else:
+            assert False, f"method {method} not supported by test"
+
+        with pytest.raises(ValueError) as err:
+            solve_method(basis(3, 0))
+        assert str(err.value) == (
+            "Initial state rho has dims [[3], [1]]"
+            " but the system dims are [[2], [2]]"
+        )
+
+        with pytest.raises(TypeError) as err:
+            solve_method("batman")
+        assert str(err.value) == (
+            "Initial ADOs passed have type <class 'str'> but a "
+            "HierarchyADOsState or a numpy array-like instance was expected"
+        )
+
+        with pytest.raises(ValueError) as err:
+            solve_method(np.array([1, 2, 3]))
+        assert str(err.value) == (
+            "Initial ADOs passed have shape (3,) but the solver hierarchy"
+            " shape is (10, 2, 2)"
+        )
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj", id="qobj"),
+        pytest.param("qobjevo_const", id="qobjevo_const"),
+        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_pure_dephasing_model_bosonic_bath(
+        self, evo, liouvillianize, atol=1e-3
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 15000, "store_states": True}
+        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(dlm.rho(), tlist)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            test = dlm.state_results([rho_final])
+            expected = dlm.analytic_results([100])
+            np.testing.assert_allclose(test, expected, atol=atol)
+            assert rho_final == ado_state.extract(0)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['terminator'], [
+        pytest.param(True, id="terminator"),
+        pytest.param(False, id="noterminator"),
+    ])
+    @pytest.mark.parametrize(['bath_cls'], [
+        pytest.param(DrudeLorentzBath, id="matsubara"),
+        pytest.param(DrudeLorentzPadeBath, id="pade"),
+    ])
+    def test_pure_dephasing_model_drude_lorentz_baths(
+        self, terminator, bath_cls, atol=1e-3
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        bath = bath_cls(
+            Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk,
+        )
+        if terminator:
+            _, terminator_op = bath.terminator()
+            H_sys = liouvillian(dlm.H) + terminator_op
+        else:
+            H_sys = dlm.H
+
+        options = {"nsteps": 15000, "store_states": True}
+        hsolver = HEOMSolver(H_sys, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(dlm.rho(), tlist)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        rho_final, ado_state = hsolver.steady_state()
+        test = dlm.state_results([rho_final])
+        expected = dlm.analytic_results([100])
+        np.testing.assert_allclose(test, expected, atol=atol)
+        assert rho_final == ado_state.extract(0)
+
+    def test_underdamped_pure_dephasing_model_underdamped_bath(
+        self, atol=1e-3
+    ):
+        udm = UnderdampedPureDephasingModel(
+            lam=0.1, gamma=0.05, w0=1, T=1/0.95, Nk=2,
+        )
+        bath = UnderDampedBath(
+            Q=udm.Q, lam=udm.lam, T=udm.T, Nk=udm.Nk, gamma=udm.gamma,
+            w0=udm.w0,
+        )
+
+        options = {"nsteps": 15000, "store_states": True}
+        hsolver = HEOMSolver(udm.H, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(udm.rho(), tlist)
+
+        test = udm.state_results(result.states)
+        expected = udm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        rho_final, ado_state = hsolver.steady_state()
+        test = udm.state_results([rho_final])
+        expected = udm.analytic_results([5000])
+        np.testing.assert_allclose(test, expected, atol=atol)
+        assert rho_final == ado_state.extract(0)
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath(self, evo, liouvillianize):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+        bath = FermionicBath(dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus)
+        # for a single impurity we converge with max_depth = 2
+        hsolver = HEOMSolver(H_sys, bath, 2, options=options)
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1])
+        analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            current = dlm.state_current(ado_state)
+            analytic_current = dlm.analytic_current()
+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['bath_cls', 'analytic_current'], [
+        pytest.param(LorentzianBath, 0.001101, id="matsubara"),
+        pytest.param(LorentzianPadeBath, 0.000813, id="pade"),
+    ])
+    def test_discrete_level_model_lorentzian_baths(
+        self, bath_cls, analytic_current, atol=1e-3
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+
+        options = {
+            "nsteps": 15_000, "store_states": True, "store_ados": True,
+            "rtol": 1e-7, "atol": 1e-7,
+        }
+        bath_l = bath_cls(
+            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=dlm.theta / 2,
+            Nk=dlm.lmax,
+        )
+        bath_r = bath_cls(
+            dlm.Q, gamma=dlm.gamma, w=dlm.W, T=dlm.T, mu=- dlm.theta / 2,
+            Nk=dlm.lmax,
+        )
+        # for a single impurity we converge with max_depth = 2
+        hsolver = HEOMSolver(dlm.H, [bath_r, bath_l], 2, options=options)
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1])
+        # analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        rho_final, ado_state = hsolver.steady_state()
+        current = dlm.state_current(ado_state)
+        # analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath_with_decoupled_bosonic_bath(
+        self, evo, liouvillianize
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.025851991, lmax=10,
+        )
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+        ck_plus, vk_plus, ck_minus, vk_minus = dlm.bath_coefficients()
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+        fermionic_bath = FermionicBath(
+            dlm.Q, ck_plus, vk_plus, ck_minus, vk_minus, tag="fermionic",
+        )
+        # very weak bosonic coupling which should not affect the dynamics of
+        # the interaction between the system and the fermionic bath:
+        eps = [1e-10] * 5
+        bosonic_Q = sigmax()
+        bosonic_bath = BosonicBath(
+            bosonic_Q, eps, eps, eps, eps, combine=False,
+        )
+        # for a single impurity we converge with max_depth = 2
+        # we specify the bosonic bath first to ensure that the test checks
+        # that the sums inside HEOMSolver grad-next/prev work when the bosonic
+        # mode is before the fermionic ones
+        hsolver = HEOMSolver(
+            H_sys, [bosonic_bath, fermionic_bath], 2, options=options,
+        )
+
+        tlist = [0, 600]
+        result = hsolver.run(dlm.rho(), tlist)
+        current = dlm.state_current(result.ado_states[-1], tags=["fermionic"])
+        analytic_current = dlm.analytic_current()
+        np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            current = dlm.state_current(ado_state)
+            analytic_current = dlm.analytic_current()
+            np.testing.assert_allclose(analytic_current, current, rtol=1e-3)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj"),
+        pytest.param("qobjevo_const"),
+        pytest.param("qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_discrete_level_model_fermionic_bath_with_coupled_bosonic_bath(
+        self, evo, liouvillianize
+    ):
+        dlm = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+        )
+        bosonic_mode = BosonicMode(
+            N=4, Omega=0.2, Lambda=0.1, gamma_b=0.1,
+        )
+
+        dlm_ref = DiscreteLevelCurrentModel(
+            gamma=0.01, W=1, T=0.5, lmax=1, e1=0.3, theta=0.5,
+            bosonic_mode=bosonic_mode,
+        )
+
+        options = {
+            "store_states": True,
+            "store_ados": True,
+            "nsteps": 15_000,
+            "rtol": 1e-7,
+            "atol": 1e-7,
+        }
+
+        # First we construct a solver with the boson modelled as part of the
+        # system and only a single Fermionic bath. This will provide the
+        # reference result for the test:
+        fermionic_bath_ref = FermionicBath(
+            dlm_ref.Q, *dlm_ref.bath_coefficients(), tag="fermionic",
+        )
+
+        hsolver_ref = HEOMSolver(
+            dlm_ref.H, [fermionic_bath_ref], 2, options=options,
+        )
+
+        # Then we construct a solver for the same system, but with the
+        # bosonic mode as a bath This is the result we would like to check:
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        fermionic_bath = FermionicBath(
+            dlm.Q, *dlm.bath_coefficients(), tag="fermionic",
+        )
+
+        bosonic_bath = BosonicBath(
+            dlm.Q.dag() @ dlm.Q, *bosonic_mode.bath_coefficients(),
+            combine=True, tag="bosonic",
+        )
+
+        hsolver = HEOMSolver(
+            H_sys, [bosonic_bath, fermionic_bath], 4, options=options,
+        )
+
+        # Calculate currents and occupations:
+        tlist = np.linspace(0, 1000, 300)
+        psi0 = basis(2, 0)
+
+        result_ref = hsolver_ref.run(dlm_ref.rho(psi0), tlist)
+        current_ref = [
+            dlm_ref.state_current(ado_state, tags=["fermionic"])
+            for ado_state in result_ref.ado_states
+        ]
+        sys_occupation_ref = dlm_ref.sys_occupation(
+            result_ref.states
+        )
+
+        result = hsolver.run(dlm.rho(psi0), tlist)
+        current = [
+            dlm.state_current(ado_state, tags=["fermionic"])
+            for ado_state in result.ado_states
+        ]
+        sys_occupation = dlm.sys_occupation(result.states)
+
+        np.testing.assert_allclose(current_ref, current, rtol=1e-3)
+        np.testing.assert_allclose(
+            sys_occupation_ref, sys_occupation, rtol=1e-3,
+        )
+
+        if evo != "qobjevo_timedep":
+            rho_final_ref, ado_state_ref = hsolver_ref.steady_state()
+            current_ss_ref = dlm_ref.state_current(ado_state_ref)
+            sys_occupation_ss_ref = dlm_ref.sys_occupation(rho_final_ref)
+
+            rho_final, ado_state = hsolver.steady_state()
+            current_ss = dlm.state_current(ado_state)
+            sys_occupation_ss = dlm.sys_occupation(rho_final)
+
+            np.testing.assert_allclose(current_ss_ref, current_ss, rtol=1e-3)
+            np.testing.assert_allclose(
+                sys_occupation_ss_ref, sys_occupation_ss, rtol=1e-3,
+            )
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['ado_format'], [
+        pytest.param("hierarchy-ados-state", id="hierarchy-ados-state"),
+        pytest.param("numpy", id="numpy"),
+    ])
+    def test_ado_input_and_return(self, ado_format):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {
+            "nsteps": 15_000, "store_states": True, "store_ados": True,
+        }
+        hsolver = HEOMSolver(dlm.H, bath, 6, options=options)
+
+        tlist_1 = [0, 1, 2]
+        result_1 = hsolver.run(dlm.rho(), tlist_1)
+
+        tlist_2 = [2, 3, 4]
+        rho0 = result_1.ado_states[-1]
+        if ado_format == "numpy":
+            rho0 = rho0._ado_state  # extract the raw numpy array
+        result_2 = hsolver.run(rho0, tlist_2)
+
+        tlist_full = tlist_1 + tlist_2[1:]
+        result_full = hsolver.run(dlm.rho(), tlist_full)
+
+        times_12 = result_1.times + result_2.times[1:]
+        times_full = result_full.times
+        assert times_12 == tlist_full
+        assert times_full == tlist_full
+
+        ado_states_12 = result_1.ado_states + result_2.ado_states[1:]
+        ado_states_full = result_full.ado_states
+        assert len(ado_states_12) == len(tlist_full)
+        assert len(ado_states_full) == len(tlist_full)
+        for ado_12, ado_full in zip(ado_states_12, ado_states_full):
+            for label in hsolver.ados.labels:
+                np.testing.assert_allclose(
+                    ado_12.extract(label).full(),
+                    ado_full.extract(label).full(),
+                    atol=1e-6,
+                )
+
+        states_12 = result_1.states + result_2.states[1:]
+        states_full = result_full.states
+        assert len(states_12) == len(tlist_full)
+        assert len(states_full) == len(tlist_full)
+        for ado_12, state_12 in zip(ado_states_12, states_12):
+            assert ado_12.rho == state_12
+        for ado_full, state_full in zip(ado_states_full, states_full):
+            assert ado_full.rho == state_full
+
+        expected = dlm.analytic_results(tlist_full)
+        test_12 = dlm.state_results(states_12)
+        np.testing.assert_allclose(test_12, expected, atol=1e-3)
+        test_full = dlm.state_results(states_full)
+        np.testing.assert_allclose(test_full, expected, atol=1e-3)
+
+    def test_solving_with_step(self):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 15_000, "store_ados": True}
+        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
+
+        tlist = np.linspace(0, 10, 21)
+        ado_state = None
+        states = [dlm.rho()]
+        hsolver.start(states[0], 0)
+        for t in tlist[1:]:
+            ado_state = hsolver.step(t)
+            states.append(ado_state.rho)
+
+        test = dlm.state_results(states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=1e-3)
+
+        assert states[-1] == ado_state.extract(0)
+
+
+class TestHeomsolveFunction:
+    @pytest.mark.parametrize(['evo'], [
+        pytest.param("qobj", id="qobj"),
+        pytest.param("listevo_const", id="listevo_const"),
+        pytest.param("qobjevo_const", id="qobjevo_const"),
+        pytest.param("qobjevo_timedep", id="qobjevo_timedep"),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_heomsolve_with_pure_dephasing_model(
+        self, evo, liouvillianize, atol=1e-3
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 15000, "store_states": True}
+
+        e_ops = {
+            "11": basis(2, 0) * basis(2, 0).dag(),
+            "22": basis(2, 1) * basis(2, 1).dag(),
+        }
+
+        tlist = np.linspace(0, 10, 21)
+        result = heomsolve(
+            H_sys, bath, 14, dlm.rho(), tlist,
+            e_ops=e_ops, args={"foo": 1}, options=options)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        for label in ["11", "22"]:
+            np.testing.assert_allclose(
+                result.e_data[label],
+                [expect(rho, e_ops[label]) for rho in result.states],
+                atol=atol,
+            )
+
+
+class TestHSolverDL:
+    @pytest.mark.parametrize(['bnd_cut_approx', 'atol'], [
+        pytest.param(True, 1e-4, id="bnd_cut_approx"),
+        pytest.param(False,  1e-3, id="no_bnd_cut_approx"),
+    ])
+    @pytest.mark.parametrize(['evo', 'combine'], [
+        pytest.param("qobj", True, id="qobj-combined"),
+        pytest.param("qobjevo_const", True, id="qobjevo-const-combined"),
+        pytest.param("listevo_const", True, id="listevo-const-combined"),
+        pytest.param("qobjevo_timedep", True, id="qobjevo-timedep-combined"),
+        pytest.param(
+            "qobjevo_timedep", False, id="qobjevo-timedep-uncombined",
+        ),
+    ])
+    @pytest.mark.parametrize(['liouvillianize'], [
+        pytest.param(False, id="hamiltonian"),
+        pytest.param(True, id="liouvillian"),
+    ])
+    def test_pure_dephasing_model(
+        self, bnd_cut_approx, atol, evo, combine, liouvillianize,
+    ):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+        H_sys = hamiltonian_to_sys(dlm.H, evo, liouvillianize)
+
+        options = {"nsteps": 15_000, "store_states": True}
+        hsolver = HSolverDL(H_sys, dlm.Q, dlm.lam, dlm.T,
+                            14, 2, dlm.gamma,
+                            bnd_cut_approx=bnd_cut_approx,
+                            options=options, combine=combine)
+
+        tlist = np.linspace(0, 10, 21)
+        result = hsolver.run(dlm.rho(), tlist)
+
+        test = dlm.state_results(result.states)
+        expected = dlm.analytic_results(tlist)
+        np.testing.assert_allclose(test, expected, atol=atol)
+
+        if evo != "qobjevo_timedep":
+            rho_final, ado_state = hsolver.steady_state()
+            test = dlm.state_results([rho_final])
+            expected = dlm.analytic_results([100])
+            np.testing.assert_allclose(test, expected, atol=atol)
+            assert rho_final == ado_state.extract(0)
+        else:
+            assert_raises_steady_state_time_dependent(hsolver)
+
+    @pytest.mark.parametrize(['bnd_cut_approx', 'tol'], [
+        pytest.param(True, 1e-4, id="bnd_cut_approx"),
+        pytest.param(False, 1e-3, id="renorm"),
+    ])
+    def test_hsolverdl_backwards_compatibility(self, bnd_cut_approx, tol):
+        # This is an exact copy of the pre-4.7 QuTiP HSolverDL test and
+        # is repeated here to ensure the new HSolverDL remains compatibile
+        # with the old one until it is removed.
+        cut_frequency = 0.05
+        coupling_strength = 0.025
+        lam_c = coupling_strength / np.pi
+        temperature = 1 / 0.95
+        times = np.linspace(0, 10, 21)
+
+        def _integrand(omega, t):
+            J = 2*lam_c * omega * cut_frequency / (omega**2 + cut_frequency**2)
+            return (-4 * J * (1 - np.cos(omega*t))
+                    / (np.tanh(0.5*omega / temperature) * omega**2))
+
+        # Calculate the analytical results by numerical integration
+        expected = [
+            0.5*np.exp(quad(_integrand, 0, np.inf, args=(t,), limit=5000)[0])
+            for t in times
+        ]
+
+        H_sys = Qobj(np.zeros((2, 2)))
+        Q = sigmaz()
+        initial_state = 0.5*Qobj(np.ones((2, 2)))
+        projector = basis(2, 0) * basis(2, 1).dag()
+        options = {"nsteps": 15_000, "store_states": True}
+        hsolver = HSolverDL(H_sys, Q, coupling_strength, temperature,
+                            20, 2, cut_frequency,
+                            bnd_cut_approx=bnd_cut_approx,
+                            options=options)
+        test = expect(hsolver.run(initial_state, times).states, projector)
+        np.testing.assert_allclose(test, expected, atol=tol)
+
+    @pytest.mark.filterwarnings("ignore:_zvode.*Excess work done:UserWarning")
+    def test_integration_error(self):
+        dlm = DrudeLorentzPureDephasingModel(
+            lam=0.025, gamma=0.05, T=1/0.95, Nk=2,
+        )
+        ck_real, vk_real, ck_imag, vk_imag = dlm.bath_coefficients()
+
+        bath = BosonicBath(dlm.Q, ck_real, vk_real, ck_imag, vk_imag)
+        options = {"nsteps": 10}
+        hsolver = HEOMSolver(dlm.H, bath, 14, options=options)
+
+        with pytest.raises(IntegratorException) as err:
+            hsolver.run(dlm.rho(), tlist=[0, 10])
+
+        assert str(err.value) == (
+            "Excess work done on this call. Try to increasing the nsteps"
+            " parameter in the Options class"
+        )
+
+
+class TestHEOMResult:
+    def mk_ados(self, bath_dims, max_depth):
+        exponents = [
+            BathExponent("I", dim, Q=None, ck=1.0, vk=2.0) for dim in bath_dims
+        ]
+        ados = HierarchyADOs(exponents, max_depth=max_depth)
+        return ados
+
+    def mk_rho_and_soln(self, ados, rho_dims):
+        n_ados = len(ados.labels)
+        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+        rho = Qobj(ado_soln[0, :], dims=rho_dims)
+        return rho, ado_soln
+
+    def test_create_ado_states_attribute(self):
+        options = fill_options()
+        result = HEOMResult(e_ops=[], options=options)
+        assert not hasattr(result, "final_ado_state")
+        assert not hasattr(result, "ado_states")
+        assert result.store_ados is False
+
+        options = fill_options(store_ados=True)
+        result = HEOMResult(e_ops=[], options=options)
+        assert result.final_ado_state is None
+        assert result.ado_states == []
+        assert result.store_ados is True
+
+    @pytest.mark.parametrize(['e_op_type'], [
+        pytest.param("qobj", id="qobj"),
+        pytest.param("qobjevo", id="qobjevo"),
+        pytest.param("callable", id="callable"),
+    ])
+    def test_e_ops(self, e_op_type):
+        op = Qobj([[1, 0], [0, 0]])
+        if e_op_type == "qobj":
+            e_op = op
+        elif e_op_type == "qobjevo":
+            e_op = QobjEvo(op)
+        elif e_op_type == "callable":
+            def e_op(f, ado_state):
+                return expect(op, ado_state.rho)
+        else:
+            assert False, f"unknown e_op_type {e_op_type!r}"
+
+        options = fill_options()
+        result = HEOMResult(e_ops=e_op, options=options)
+
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        e_op_value = expect(op, rho)
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+
+        result.add(0.1, ado_state)
+
+        assert result.expect[0] == [e_op_value]
+        assert result.e_data[0] == [e_op_value]
+
+    def test_store_state(self):
+        options = fill_options()
+        result = HEOMResult(e_ops=[], options=options)
+
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+
+        result.add(0.1, ado_state)
+
+        assert result.times == [0.1]
+        assert result.states == [rho]
+        assert result.final_state is rho
+
+    def test_store_ados(self):
+        options = fill_options(store_ados=True)
+        result = HEOMResult(e_ops=[], options=options)
+
+        ados = self.mk_ados([2, 3], max_depth=2)
+        rho, ado_soln = self.mk_rho_and_soln(ados, [[2], [2]])
+        ado_state = HierarchyADOsState(rho, ados, ado_soln)
+
+        result.add(0.1, ado_state)
+        assert result.times == [0.1]
+        assert result.states == [rho]
+        assert result.final_state is rho
+        assert result.ado_states == [ado_state]
+        assert result.final_ado_state is ado_state
+
+
+class Test_GatherHEOMRHS:
+    def test_simple_gather(self):
+        def f(label):
+            return int(label.lstrip("o"))
+
+        gather_heoms = _GatherHEOMRHS(f, block=2, nhe=3)
+
+        for i in range(3):
+            for j in range(3):
+                base = 10 * (j * 2) + (i * 2)
+                block_op = _data.to(
+                    _data.CSR,
+                    _data.create(np.array([
+                        [base, base + 10],
+                        [base + 1, base + 11],
+                    ]))
+                )
+                gather_heoms.add_op(f"o{i}", f"o{j}", block_op)
+
+        op = gather_heoms.gather()
+
+        expected_op = np.array([
+            [10 * i + j for i in range(2 * 3)]
+            for j in range(2 * 3)
+        ], dtype=np.complex128)
+
+        np.testing.assert_array_equal(op.to_array(), expected_op)
+        assert isinstance(op, _data.CSR)
diff --git a/qutip/tests/solver/heom/test_heom.py b/qutip/tests/solver/heom/test_heom.py
index ad5680b6bf..c8988a168a 100644
--- a/qutip/tests/solver/heom/test_heom.py
+++ b/qutip/tests/solver/heom/test_heom.py
@@ -1,46 +1,46 @@
-"""
-Tests for qutip.nonmarkov.heom.
-"""
-
-import pytest
-from qutip.solver.heom import (
-    BathExponent,
-    Bath,
-    BosonicBath,
-    DrudeLorentzBath,
-    DrudeLorentzPadeBath,
-    UnderDampedBath,
-    FermionicBath,
-    LorentzianBath,
-    LorentzianPadeBath,
-    heomsolve,
-    HEOMSolver,
-    HEOMResult,
-    HSolverDL,
-    HierarchyADOs,
-    HierarchyADOsState,
-)
-
-class TestBathAPI:
-    def test_api(self):
-        # just assert that the baths are importable
-        assert BathExponent
-        assert Bath
-        assert BosonicBath
-        assert DrudeLorentzBath
-        assert DrudeLorentzPadeBath
-        assert UnderDampedBath
-        assert FermionicBath
-        assert LorentzianBath
-        assert LorentzianPadeBath
-
-
-class TestSolverAPI:
-    def test_api(self):
-        # just assert that the solvers and associated classes are importable
-        assert heomsolve
-        assert HEOMSolver
-        assert HEOMResult
-        assert HSolverDL
-        assert HierarchyADOs
-        assert HierarchyADOsState
+"""
+Tests for qutip.nonmarkov.heom.
+"""
+
+import pytest
+from qutip.solver.heom import (
+    BathExponent,
+    Bath,
+    BosonicBath,
+    DrudeLorentzBath,
+    DrudeLorentzPadeBath,
+    UnderDampedBath,
+    FermionicBath,
+    LorentzianBath,
+    LorentzianPadeBath,
+    heomsolve,
+    HEOMSolver,
+    HEOMResult,
+    HSolverDL,
+    HierarchyADOs,
+    HierarchyADOsState,
+)
+
+class TestBathAPI:
+    def test_api(self):
+        # just assert that the baths are importable
+        assert BathExponent
+        assert Bath
+        assert BosonicBath
+        assert DrudeLorentzBath
+        assert DrudeLorentzPadeBath
+        assert UnderDampedBath
+        assert FermionicBath
+        assert LorentzianBath
+        assert LorentzianPadeBath
+
+
+class TestSolverAPI:
+    def test_api(self):
+        # just assert that the solvers and associated classes are importable
+        assert heomsolve
+        assert HEOMSolver
+        assert HEOMResult
+        assert HSolverDL
+        assert HierarchyADOs
+        assert HierarchyADOsState
diff --git a/qutip/tests/solver/test_brmesolve.py b/qutip/tests/solver/test_brmesolve.py
index bc5b4c6dfb..7b1aef0663 100644
--- a/qutip/tests/solver/test_brmesolve.py
+++ b/qutip/tests/solver/test_brmesolve.py
@@ -1,296 +1,296 @@
-import pytest
-import numpy as np
-import qutip
-from qutip.solver.brmesolve import brmesolve
-
-
-def pauli_spin_operators():
-    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-
-
-_simple_qubit_gamma = 0.25
-coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
-                          args={'w':0})
-_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
-_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
-_x_a_op = [qutip.sigmax(), coeff]
-
-
-@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
-    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
-    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
-    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
-                 id="me collapse-br collapse-br coupling"),
-])
-def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
-    """
-    Test that the BR solver handles collapse and coupling operators correctly
-    relative to the standard ME solver.
-    """
-    delta = 0.0
-    epsilon = 0.5 * 2 * np.pi
-    e_ops = pauli_spin_operators()
-    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
-    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-    times = np.linspace(0, 10, 100)
-    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
-    opt = {"tensor_type": "dense"}
-    brme = brmesolve(
-        H, psi0, times,
-        a_ops=brme_a_ops, c_ops=brme_c_ops,
-        e_ops=e_ops, options=opt
-    )
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
-
-
-def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
-    if n_th == 0:
-        return lambda w: kappa * (w >= 0)
-
-    w_th = w0 / np.log(1 + 1/n_th)
-
-    def f(t, w):
-        scale = np.exp(w / w_th) if w < 0 else 1
-        return (n_th + 1) * kappa * scale
-    return f
-
-
-def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
-    a = qutip.destroy(dimension)
-    if n_th == 0:
-        return [np.sqrt(kappa) * a]
-    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
-
-
-@pytest.mark.parametrize("n_th", [0, 0.15])
-def test_harmonic_oscillator(n_th):
-    N = 10
-    w0 = 1.0 * 2*np.pi
-    g = 0.05 * w0
-    kappa = 0.15
-    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
-
-    a = qutip.destroy(N)
-    H = w0*a.dag()*a + g*(a+a.dag())
-    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
-    psi0 = qutip.ket2dm(psi0)
-    times = np.linspace(0, 20, 1000)
-
-    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
-    a_ops = [[a + a.dag(), S_w]]
-    e_ops = [a.dag()*a, a+a.dag()]
-
-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
-
-    num = qutip.num(N)
-    me_num = qutip.expect(num, me.states)
-    brme_num = qutip.expect(num, brme.states)
-    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
-
-
-def test_jaynes_cummings_zero_temperature_spectral_callable():
-    """
-    brmesolve: Jaynes-Cummings model, zero temperature
-    """
-    N = 10
-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
-    kappa = 0.05
-    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
-    e_ops = [a.dag()*a, sp.dag()*sp]
-
-    w0 = 1.0 * 2*np.pi
-    g = 0.05 * 2*np.pi
-    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
-
-    c_ops = [np.sqrt(kappa) * a]
-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-
-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        # Accept 5% error.
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
-
-
-def test_tensor_system():
-    """
-    brmesolve: Check for #572 bug.
-    """
-    w1, w2, w3 = 1, 2, 3
-    gamma2, gamma3 = 0.1, 0.1
-    id2 = qutip.qeye(2)
-
-    # Hamiltonian for three uncoupled qubits
-    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
-         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
-         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
-
-    # White noise
-    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
-    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
-
-    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
-    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
-
-    # Initial state : first qubit is excited
-    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
-    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
-    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
-
-    # Projector on the excited state of qubit 1
-    proj_up1 = qutip.tensor(exc2, id2, id2)
-    times = np.linspace(0, 10./gamma3, 1000)
-
-    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
-                    e_ops=[proj_up1]).expect[0]
-
-    np.testing.assert_allclose(sol, np.ones_like(times))
-
-
-def test_solver_accepts_list_hamiltonian():
-    """
-    brmesolve: input list of Qobj
-    """
-    delta = 0.0 * 2 * np.pi
-    epsilon = 0.5 * 2 * np.pi
-    gamma = 0.25
-    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
-    e_ops = pauli_spin_operators()
-    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
-    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-    times = np.linspace(0, 10, 100)
-    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
-    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
-    for me_expectation, brme_expectation in zip(me, brme):
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
-
-
-def test_jaynes_cummings_zero_temperature_spectral_str():
-    N = 10
-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
-    kappa = 0.05
-    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
-    e_ops = [a.dag()*a, sp.dag()*sp]
-
-    w0 = 1.0 * 2*np.pi
-    g = 0.05 * 2*np.pi
-    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
-
-    c_ops = [np.sqrt(kappa) * a]
-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-
-    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
-    brme = brmesolve(H, psi0, times, a_ops, e_ops)
-    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
-        # Accept 5% error.
-        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
-
-
-def _mixed_string(kappa, _):
-    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
-
-
-def _separate_strings(kappa, _):
-    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
-
-
-def _string_w_interpolating_t(kappa, times):
-    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
-    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
-
-
-@pytest.mark.slow
-@pytest.mark.parametrize("time_dependence_tuple", [
-        _mixed_string,
-        _separate_strings,
-        _string_w_interpolating_t,
-    ])
-def test_time_dependence_tuples(time_dependence_tuple):
-    N = 10
-    a = qutip.destroy(N)
-    H = a.dag()*a
-    psi0 = qutip.basis(N, 9)
-    times = np.linspace(0, 10, 100)
-    kappa = 0.2
-    spectra, coeff = time_dependence_tuple(kappa, times)
-    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
-    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
-    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
-    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
-
-
-def test_time_dependent_spline_in_c_ops():
-    N = 10
-    a = qutip.destroy(N)
-    H = a.dag()*a
-    psi0 = qutip.basis(N, 9)
-    times = np.linspace(0, 10, 100)
-    kappa = 0.2
-    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
-    spectra, coeff = _string_w_interpolating_t(kappa, times)
-    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
-    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
-    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
-    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
-    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
-
-
-@pytest.mark.slow
-def test_nonhermitian_e_ops():
-    N = 5
-    a = qutip.destroy(N)
-    coefficient = np.random.random() + 1j*np.random.random()
-    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
-    H_brme = [[H, '1']]
-    psi0 = qutip.basis(N, 2)
-    times = np.linspace(0, 10, 10)
-    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
-    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
-    np.testing.assert_allclose(me, brme, atol=1e-4)
-
-
-@pytest.mark.slow
-def test_result_states():
-    N = 5
-    a = qutip.destroy(N)
-    coefficient = np.random.random() + 1j*np.random.random()
-    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
-    H_brme = [[H, '1']]
-    psi0 = qutip.fock_dm(N, 2)
-    times = np.linspace(0, 10, 10)
-    me = qutip.mesolve(H, psi0, times).states
-    brme = brmesolve(H_brme, psi0, times).states
-    assert max(np.abs((me_state - brme_state).full()).max()
-               for me_state, brme_state in zip(me, brme)) < 1e-5
-
-
-@pytest.mark.slow
-def test_hamiltonian_taking_arguments():
-    N = 10
-    w0 = 1.0 * 2*np.pi
-    g = 0.75 * 2*np.pi
-    kappa = 0.05
-    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
-    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
-    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
-    psi0 = qutip.ket2dm(psi0)
-    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
-
-    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
-    e_ops = [a.dag()*a, sp.dag()*sp]
-
-    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
-    args = {'ii': 1}
-
-    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
-    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
-    for arg, no_arg in zip(args.expect, no_args.expect):
-        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
+import pytest
+import numpy as np
+import qutip
+from qutip.solver.brmesolve import brmesolve
+
+
+def pauli_spin_operators():
+    return [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+
+
+_simple_qubit_gamma = 0.25
+coeff = qutip.coefficient(lambda t, w: _simple_qubit_gamma * (w >= 0),
+                          args={'w':0})
+_m_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmam()
+_z_c_op = np.sqrt(_simple_qubit_gamma) * qutip.sigmaz()
+_x_a_op = [qutip.sigmax(), coeff]
+
+
+@pytest.mark.parametrize("me_c_ops, brme_c_ops, brme_a_ops", [
+    pytest.param([_m_c_op], [], [_x_a_op], id="me collapse-br coupling"),
+    pytest.param([_m_c_op], [_m_c_op], [], id="me collapse-br collapse"),
+    pytest.param([_m_c_op, _z_c_op], [_z_c_op], [_x_a_op],
+                 id="me collapse-br collapse-br coupling"),
+])
+def test_simple_qubit_system(me_c_ops, brme_c_ops, brme_a_ops):
+    """
+    Test that the BR solver handles collapse and coupling operators correctly
+    relative to the standard ME solver.
+    """
+    delta = 0.0
+    epsilon = 0.5 * 2 * np.pi
+    e_ops = pauli_spin_operators()
+    H = delta * 0.5 * qutip.sigmax() + epsilon * 0.5 * qutip.sigmaz()
+    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    times = np.linspace(0, 10, 100)
+    me = qutip.mesolve(H, psi0, times, c_ops=me_c_ops, e_ops=e_ops)
+    opt = {"tensor_type": "dense"}
+    brme = brmesolve(
+        H, psi0, times,
+        a_ops=brme_a_ops, c_ops=brme_c_ops,
+        e_ops=e_ops, options=opt
+    )
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
+
+
+def _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa):
+    if n_th == 0:
+        return lambda w: kappa * (w >= 0)
+
+    w_th = w0 / np.log(1 + 1/n_th)
+
+    def f(t, w):
+        scale = np.exp(w / w_th) if w < 0 else 1
+        return (n_th + 1) * kappa * scale
+    return f
+
+
+def _harmonic_oscillator_c_ops(n_th, kappa, dimension):
+    a = qutip.destroy(dimension)
+    if n_th == 0:
+        return [np.sqrt(kappa) * a]
+    return [np.sqrt(kappa * (n_th+1)) * a, np.sqrt(kappa * n_th) * a.dag()]
+
+
+@pytest.mark.parametrize("n_th", [0, 0.15])
+def test_harmonic_oscillator(n_th):
+    N = 10
+    w0 = 1.0 * 2*np.pi
+    g = 0.05 * w0
+    kappa = 0.15
+    S_w = _harmonic_oscillator_spectrum_frequency(n_th, w0, kappa)
+
+    a = qutip.destroy(N)
+    H = w0*a.dag()*a + g*(a+a.dag())
+    psi0 = (qutip.basis(N, 4) + qutip.basis(N, 2) + qutip.basis(N, 0)).unit()
+    psi0 = qutip.ket2dm(psi0)
+    times = np.linspace(0, 20, 1000)
+
+    c_ops = _harmonic_oscillator_c_ops(n_th, kappa, N)
+    a_ops = [[a + a.dag(), S_w]]
+    e_ops = [a.dag()*a, a+a.dag()]
+
+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-2)
+
+    num = qutip.num(N)
+    me_num = qutip.expect(num, me.states)
+    brme_num = qutip.expect(num, brme.states)
+    np.testing.assert_allclose(me_num, brme_num, atol=1e-2)
+
+
+def test_jaynes_cummings_zero_temperature_spectral_callable():
+    """
+    brmesolve: Jaynes-Cummings model, zero temperature
+    """
+    N = 10
+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
+    kappa = 0.05
+    a_ops = [(a + a.dag(), lambda w: kappa * (w >= 0))]
+    e_ops = [a.dag()*a, sp.dag()*sp]
+
+    w0 = 1.0 * 2*np.pi
+    g = 0.05 * 2*np.pi
+    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
+
+    c_ops = [np.sqrt(kappa) * a]
+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+
+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        # Accept 5% error.
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
+
+
+def test_tensor_system():
+    """
+    brmesolve: Check for #572 bug.
+    """
+    w1, w2, w3 = 1, 2, 3
+    gamma2, gamma3 = 0.1, 0.1
+    id2 = qutip.qeye(2)
+
+    # Hamiltonian for three uncoupled qubits
+    H = (w1/2. * qutip.tensor(qutip.sigmaz(), id2, id2)
+         + w2/2. * qutip.tensor(id2, qutip.sigmaz(), id2)
+         + w3/2. * qutip.tensor(id2, id2, qutip.sigmaz()))
+
+    # White noise
+    S2 = qutip.coefficient(lambda t, w: gamma2, args={'w':0})
+    S3 = qutip.coefficient(lambda t, w: gamma3, args={'w':0})
+
+    qubit_2_x = qutip.tensor(id2, qutip.sigmax(), id2)
+    qubit_3_x = qutip.tensor(id2, id2, qutip.sigmax())
+
+    # Initial state : first qubit is excited
+    grnd2 = qutip.sigmam() * qutip.sigmap()  # 2x2 ground
+    exc2 = qutip.sigmap() * qutip.sigmam()   # 2x2 excited state
+    ini = qutip.tensor(exc2, grnd2, grnd2)   # Full system
+
+    # Projector on the excited state of qubit 1
+    proj_up1 = qutip.tensor(exc2, id2, id2)
+    times = np.linspace(0, 10./gamma3, 1000)
+
+    sol = brmesolve(H, ini, times, [[qubit_2_x, S2], [qubit_3_x, S3]],
+                    e_ops=[proj_up1]).expect[0]
+
+    np.testing.assert_allclose(sol, np.ones_like(times))
+
+
+def test_solver_accepts_list_hamiltonian():
+    """
+    brmesolve: input list of Qobj
+    """
+    delta = 0.0 * 2 * np.pi
+    epsilon = 0.5 * 2 * np.pi
+    gamma = 0.25
+    c_ops = [np.sqrt(gamma) * qutip.sigmam()]
+    e_ops = pauli_spin_operators()
+    H = [delta * 0.5 * qutip.sigmax(), epsilon * 0.5 * qutip.sigmaz()]
+    psi0 = (2 * qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    times = np.linspace(0, 10, 100)
+    me = qutip.mesolve(H, psi0, times, c_ops=c_ops, e_ops=e_ops).expect
+    brme = brmesolve(H, psi0, times, [], e_ops=e_ops, c_ops=c_ops).expect
+    for me_expectation, brme_expectation in zip(me, brme):
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=1e-8)
+
+
+def test_jaynes_cummings_zero_temperature_spectral_str():
+    N = 10
+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+    psi0 = qutip.ket2dm(qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0)))
+    kappa = 0.05
+    a_ops = [[(a + a.dag()), "{kappa} * (w >= 0)".format(kappa=kappa)]]
+    e_ops = [a.dag()*a, sp.dag()*sp]
+
+    w0 = 1.0 * 2*np.pi
+    g = 0.05 * 2*np.pi
+    times = np.linspace(0, 2 * 2*np.pi / g, 1000)
+
+    c_ops = [np.sqrt(kappa) * a]
+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+
+    me = qutip.mesolve(H, psi0, times, c_ops, e_ops)
+    brme = brmesolve(H, psi0, times, a_ops, e_ops)
+    for me_expectation, brme_expectation in zip(me.expect, brme.expect):
+        # Accept 5% error.
+        np.testing.assert_allclose(me_expectation, brme_expectation, atol=5e-2)
+
+
+def _mixed_string(kappa, _):
+    return "{kappa} * exp(-t) * (w >= 0)".format(kappa=kappa), "1"
+
+
+def _separate_strings(kappa, _):
+    return ("{kappa} * (w >= 0)".format(kappa=kappa), "exp(-t/2)")
+
+
+def _string_w_interpolating_t(kappa, times):
+    spline = qutip.coefficient(np.exp(-times/2), tlist=times)
+    return ("{kappa} * (w >= 0)".format(kappa=kappa), spline)
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("time_dependence_tuple", [
+        _mixed_string,
+        _separate_strings,
+        _string_w_interpolating_t,
+    ])
+def test_time_dependence_tuples(time_dependence_tuple):
+    N = 10
+    a = qutip.destroy(N)
+    H = a.dag()*a
+    psi0 = qutip.basis(N, 9)
+    times = np.linspace(0, 10, 100)
+    kappa = 0.2
+    spectra, coeff = time_dependence_tuple(kappa, times)
+    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
+    exact = 9 * np.exp(-kappa * (1 - np.exp(-times)))
+    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a])
+    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
+
+
+def test_time_dependent_spline_in_c_ops():
+    N = 10
+    a = qutip.destroy(N)
+    H = a.dag()*a
+    psi0 = qutip.basis(N, 9)
+    times = np.linspace(0, 10, 100)
+    kappa = 0.2
+    exact = 9 * np.exp(-2 * kappa * (1 - np.exp(-times)))
+    spectra, coeff = _string_w_interpolating_t(kappa, times)
+    a_ops = [[qutip.QobjEvo([a + a.dag(), coeff]), spectra]]
+    collapse_points = np.sqrt(kappa) * np.exp(-0.5*times)
+    c_ops = [[a, qutip.coefficient(collapse_points, tlist=times)]]
+    brme = brmesolve(H, psi0, times, a_ops, e_ops=[a.dag()*a], c_ops=c_ops)
+    assert np.mean(np.abs(brme.expect[0] - exact) / exact) < 1e-5
+
+
+@pytest.mark.slow
+def test_nonhermitian_e_ops():
+    N = 5
+    a = qutip.destroy(N)
+    coefficient = np.random.random() + 1j*np.random.random()
+    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
+    H_brme = [[H, '1']]
+    psi0 = qutip.basis(N, 2)
+    times = np.linspace(0, 10, 10)
+    me = qutip.mesolve(H, psi0, times, c_ops=[], e_ops=[a]).expect[0]
+    brme = brmesolve(H_brme, psi0, times, a_ops=[], e_ops=[a]).expect[0]
+    np.testing.assert_allclose(me, brme, atol=1e-4)
+
+
+@pytest.mark.slow
+def test_result_states():
+    N = 5
+    a = qutip.destroy(N)
+    coefficient = np.random.random() + 1j*np.random.random()
+    H = a.dag()*a + coefficient*a + np.conj(coefficient)*a.dag()
+    H_brme = [[H, '1']]
+    psi0 = qutip.fock_dm(N, 2)
+    times = np.linspace(0, 10, 10)
+    me = qutip.mesolve(H, psi0, times).states
+    brme = brmesolve(H_brme, psi0, times).states
+    assert max(np.abs((me_state - brme_state).full()).max()
+               for me_state, brme_state in zip(me, brme)) < 1e-5
+
+
+@pytest.mark.slow
+def test_hamiltonian_taking_arguments():
+    N = 10
+    w0 = 1.0 * 2*np.pi
+    g = 0.75 * 2*np.pi
+    kappa = 0.05
+    a = qutip.tensor(qutip.destroy(N), qutip.qeye(2))
+    sp = qutip.tensor(qutip.qeye(N), qutip.sigmap())
+    psi0 = qutip.tensor(qutip.basis(N, 1), qutip.basis(2, 0))
+    psi0 = qutip.ket2dm(psi0)
+    times = np.linspace(0, 5 * 2*np.pi / g, 1000)
+
+    a_ops = [[(a + a.dag()), "{kappa}*(w > 0)".format(kappa=kappa)]]
+    e_ops = [a.dag()*a, sp.dag()*sp]
+
+    H = w0*a.dag()*a + w0*sp.dag()*sp + g*(a+a.dag())*(sp+sp.dag())
+    args = {'ii': 1}
+
+    no_args = brmesolve(H, psi0, times, a_ops, e_ops)
+    args = brmesolve([[H, 'ii']], psi0, times, a_ops, e_ops, args=args)
+    for arg, no_arg in zip(args.expect, no_args.expect):
+        np.testing.assert_allclose(arg, no_arg, atol=1e-10)
diff --git a/qutip/tests/solver/test_correlation.py b/qutip/tests/solver/test_correlation.py
index f2af197dcf..bf96b045da 100644
--- a/qutip/tests/solver/test_correlation.py
+++ b/qutip/tests/solver/test_correlation.py
@@ -1,329 +1,329 @@
-import pytest
-import functools
-from itertools import product
-import numpy as np
-import qutip
-
-pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
-
-_equivalence_dimension = 15
-_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
-_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
-
-
-@pytest.mark.filterwarnings("ignore::FutureWarning")
-@pytest.mark.parametrize(["solver", "start"], [
-    pytest.param("es", _equivalence_coherent, id="es"),
-    pytest.param("es", None, id="es-steady state"),
-])
-def test_correlation_solver_equivalence(solver, start):
-    """
-    Test that all of the correlation solvers give the same results for a given
-    system.
-    """
-    a = qutip.destroy(_equivalence_dimension)
-    x = ( a + a.dag() ) / np.sqrt(2)
-    H = a.dag() * a
-    G1 = 0.75
-    n_th = 2
-    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
-             np.sqrt(G1 * n_th) * a.dag()]
-    times = np.linspace(0, 3, 61)
-    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
-    # long simulation time.
-    tol = 0.25 if solver == "mc" else 1e-4
-    # We use the master equation version as a base, but it doesn't actually
-    # matter - if all the tests fail, it implies that the "me" solver might be
-    # broken, whereas if only one fails, then it implies that only that one is
-    # broken.  We test that all solvers are equivalent by transitive equality
-    # to the "me" solver.
-    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
-                                    a.dag(), a, solver="me")
-    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
-                                   a.dag(), a, solver=solver)
-    np.testing.assert_allclose(base, cmp, atol=tol)
-
-
-def _spectrum_wrapper(solver):
-    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
-    @functools.wraps(qutip.spectrum)
-    def out(H, c_ops, a, b):
-        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
-                frequencies)
-    return out
-
-
-def _spectrum_fft(H, c_ops, a, b):
-    times = np.linspace(0, 100, 2500)
-    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
-    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
-    return spectrum, frequencies
-
-
-@pytest.mark.parametrize("spectrum", [
-    pytest.param(_spectrum_fft, id="fft"),
-    pytest.param(_spectrum_wrapper("es"), id="es"),
-    pytest.param(_spectrum_wrapper("pi"), id="pi"),
-    pytest.param(_spectrum_wrapper("solve"), id="solve"),
-])
-def test_spectrum_solver_equivalence_to_es(spectrum):
-    """Test equivalence of the spectrum solvers to the base "es" method."""
-    # Jaynes--Cummings model.
-    dimension = 4
-    wc = wa = 1.0 * 2*np.pi
-    g = 0.1 * 2*np.pi
-    kappa = 0.75
-    gamma = 0.25
-    n_th = 0.01
-
-    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
-    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
-    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
-    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
-             np.sqrt(kappa * n_th) * a.dag(),
-             np.sqrt(gamma) * sm.dag()]
-
-    test, frequencies = spectrum(H, c_ops, a.dag(), a)
-    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
-    np.testing.assert_allclose(base, test, atol=1e-3)
-
-
-def _trapz_2d(z, xy):
-    """2D trapezium-method integration assuming a square grid."""
-    dx = xy[1] - xy[0]
-    return dx*dx * np.trapz(np.trapz(z, axis=0))
-
-
-def _n_correlation(times, n):
-    """
-    Numerical integration of the correlation function given an array of
-    expectation values.
-    """
-    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
-                     for t in range(times.shape[0])])
-
-
-def _coefficient_function(t, args):
-    t_off, tp = args['t_off'], args['tp']
-    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
-
-
-_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
-
-
-def _h_qobj_function(t, args):
-    return args['H0'] * _coefficient_function(t, args)
-
-
-# 2LS and 3LS stand for two- and three-level system respectively.
-
-_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
-_2ls_times = np.linspace(0, 5, 51)
-_3ls_args = {'t_off': 2, 'tp': 1}
-_3ls_times = np.linspace(0, 6, 20)
-
-
-def _2ls_g2_0(H, c_ops):
-    sp = qutip.sigmap()
-    start = qutip.basis(2, 0)
-    times = _2ls_times
-    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
-    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
-                                           sp.dag(), sp.dag()*sp, sp,
-                                           args=_2ls_args)
-    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
-                                  e_ops=[qutip.num(2)],
-                                  args=_2ls_args).expect[0]
-    integral_correlation = _trapz_2d(np.real(correlation), times)
-    integral_n_expectation = np.trapz(n_expectation, times)
-    # Factor of two from negative time correlations.
-    return 2 * integral_correlation / integral_n_expectation**2
-
-
-@pytest.fixture(params=[
-    pytest.param(_coefficient_string, id="string"),
-    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
-    pytest.param(_coefficient_function, id="function"),
-])
-def dependence_2ls(request):
-    return request.param
-
-
-class TestTimeDependence:
-    """
-    Test correlations with time-dependent operators using a two-level system
-    (2LS) or a three-level system (3LS).
-    """
-    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
-        H = [[_2ls_args['H0'], dependence_2ls]]
-        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
-
-    def test_hamiltonian_from_function_2ls(self):
-        H = _h_qobj_function
-        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
-
-    @pytest.mark.slow
-    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
-        H = [[_2ls_args['H0'], dependence_2ls]]
-        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
-        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
-
-    @pytest.mark.slow
-    @pytest.mark.parametrize("dependence_3ls", [
-        pytest.param(_coefficient_string, id="string"),
-        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
-        pytest.param(_coefficient_function, id="function"),
-    ])
-    def test_coefficient_c_ops_3ls(self, dependence_3ls):
-        # Calculate zero-delay HOM cross-correlation for incoherently pumped
-        # three-level system, g2_ab[0] with gamma = 1.
-        dimension = 3
-        H = qutip.qzero(dimension)
-        start = qutip.basis(dimension, 2)
-        times = _3ls_times
-        project_0_1 = qutip.projection(dimension, 0, 1)
-        project_1_2 = qutip.projection(dimension, 1, 2)
-        population_1 = qutip.projection(dimension, 1, 1)
-        # Define the pi pulse to be when 99% of the population is transferred.
-        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
-        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
-                                      args=_3ls_args)
-        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
-        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
-                                            project_0_1.dag(), project_0_1,
-                                            args=_3ls_args)
-        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
-                                             project_0_1.dag(), project_0_1,
-                                             args=_3ls_args, reverse=True)
-        times2 = np.concatenate([times, times[1:] + times[-1]])
-        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
-                                 e_ops=[population_1]).expect[0]
-        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
-        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
-        assert abs(g2_ab_0 - 0.185) < 1e-2
-
-
-def _step(t):
-    return np.arctan(t)/np.pi + 0.5
-
-
-def test_hamiltonian_order_unimportant():
-    # Testing for regression on issue 1048.
-    sp = qutip.sigmap()
-    H = [[qutip.sigmax(), lambda t: _step(t-2)],
-         [qutip.qeye(2), lambda t: _step(-(t-2))]]
-    start = qutip.basis(2, 0)
-    times = np.linspace(0, 5, 6)
-    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
-                                        sp.dag(), sp)
-    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
-                                         sp.dag(), sp)
-    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
-
-
-@pytest.mark.parametrize(['solver', 'state'], [
-    pytest.param('me', _equivalence_fock, id="me-ket"),
-    pytest.param('me', _equivalence_coherent, id="me-dm"),
-    pytest.param('me', None, id="me-steady"),
-    pytest.param('es', _equivalence_fock, id="es-ket"),
-    pytest.param('es', _equivalence_coherent, id="es-dm"),
-    pytest.param('es', None, id="es-steady"),
-])
-@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
-                         ids=["hermitian", "nonhermitian"])
-@pytest.mark.parametrize("w", [1, 2])
-@pytest.mark.parametrize("gamma", [1, 10])
-def test_correlation_2op_1t_known_cases(solver,
-                                        state,
-                                        is_e_op_hermitian,
-                                        w,
-                                        gamma,
-                                       ):
-    """This test compares the output correlation_2op_1 solution to an analytical
-    solution."""
-
-    a = qutip.destroy(_equivalence_dimension)
-    x = (a + a.dag())/np.sqrt(2)
-
-    H = w * a.dag() * a
-
-    a_op = x if is_e_op_hermitian else a
-    b_op = x if is_e_op_hermitian else a.dag()
-    c_ops = [np.sqrt(gamma) * a]
-
-    times = np.linspace(0, 1, 30)
-
-    # Handle the case state==None when computing expt values
-    rho0 = state if state else qutip.steadystate(H, c_ops)
-    if is_e_op_hermitian:
-        # Analitycal solution for x,x as operators.
-        base = 0
-        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
-        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
-        base /= np.sqrt(2)
-    else:
-        # Analitycal solution for a,adag as operators.
-        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
-
-    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
-
-    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
-
-
-def test_correlation_timedependant_op():
-    num = qutip.num(2)
-    a = qutip.destroy(2)
-    sx = qutip.sigmax()
-    sz = qutip.sigmaz()
-    times = np.arange(4)
-    # switch between sx and sz at t=1.5
-    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
-
-    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
-    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
-    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
-    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
-    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
-
-
-def test_alternative_solver():
-    from qutip.solver.mesolve import MESolver
-    from qutip.solver.brmesolve import BRSolver
-
-    H = qutip.num(5)
-    a = qutip.destroy(5)
-    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
-
-    br = BRSolver(H, a_ops)
-    me = MESolver(H, [a])
-    times = np.arange(4)
-
-    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
-    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
-
-    np.testing.assert_allclose(br_corr, me_corr)
-
-
-def test_G1():
-    H = qutip.Qobj([[0,1], [1,0]])
-    psi0 = qutip.basis(2)
-    taus = np.linspace(0, 1, 11)
-    scale = 2
-    a_op = qutip.sigmaz() * scale
-    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
-    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
-    np.testing.assert_allclose(g1, expected, rtol=2e-5)
-    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
-
-
-def test_G2():
-    N = 10
-    H = qutip.rand_dm(N)
-    psi0 = qutip.rand_ket(N)
-    taus = np.linspace(0, 1, 11)
-    scale = 2
-    a_op = qutip.rand_unitary(N) * scale
-    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
-    expected = np.ones(11)
-    np.testing.assert_allclose(g1, expected, rtol=2e-5)
-    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
+import pytest
+import functools
+from itertools import product
+import numpy as np
+import qutip
+
+pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
+
+_equivalence_dimension = 15
+_equivalence_fock = qutip.fock(_equivalence_dimension, 1)
+_equivalence_coherent = qutip.coherent_dm(_equivalence_dimension, 2)
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+@pytest.mark.parametrize(["solver", "start"], [
+    pytest.param("es", _equivalence_coherent, id="es"),
+    pytest.param("es", None, id="es-steady state"),
+])
+def test_correlation_solver_equivalence(solver, start):
+    """
+    Test that all of the correlation solvers give the same results for a given
+    system.
+    """
+    a = qutip.destroy(_equivalence_dimension)
+    x = ( a + a.dag() ) / np.sqrt(2)
+    H = a.dag() * a
+    G1 = 0.75
+    n_th = 2
+    c_ops = [np.sqrt(G1 * (n_th+1)) * a,
+             np.sqrt(G1 * n_th) * a.dag()]
+    times = np.linspace(0, 3, 61)
+    # Massively relax the tolerance for the Monte-Carlo approach to avoid a
+    # long simulation time.
+    tol = 0.25 if solver == "mc" else 1e-4
+    # We use the master equation version as a base, but it doesn't actually
+    # matter - if all the tests fail, it implies that the "me" solver might be
+    # broken, whereas if only one fails, then it implies that only that one is
+    # broken.  We test that all solvers are equivalent by transitive equality
+    # to the "me" solver.
+    base = qutip.correlation_2op_2t(H, start, None, times, c_ops,
+                                    a.dag(), a, solver="me")
+    cmp = qutip.correlation_2op_2t(H, start, None, times, c_ops,
+                                   a.dag(), a, solver=solver)
+    np.testing.assert_allclose(base, cmp, atol=tol)
+
+
+def _spectrum_wrapper(solver):
+    frequencies = 2*np.pi * np.linspace(0.5, 1.5, 101)
+    @functools.wraps(qutip.spectrum)
+    def out(H, c_ops, a, b):
+        return (qutip.spectrum(H, frequencies, c_ops, a, b, solver=solver),
+                frequencies)
+    return out
+
+
+def _spectrum_fft(H, c_ops, a, b):
+    times = np.linspace(0, 100, 2500)
+    correlation = qutip.correlation_2op_1t(H, None, times, c_ops, a, b)
+    frequencies, spectrum = qutip.spectrum_correlation_fft(times, correlation)
+    return spectrum, frequencies
+
+
+@pytest.mark.parametrize("spectrum", [
+    pytest.param(_spectrum_fft, id="fft"),
+    pytest.param(_spectrum_wrapper("es"), id="es"),
+    pytest.param(_spectrum_wrapper("pi"), id="pi"),
+    pytest.param(_spectrum_wrapper("solve"), id="solve"),
+])
+def test_spectrum_solver_equivalence_to_es(spectrum):
+    """Test equivalence of the spectrum solvers to the base "es" method."""
+    # Jaynes--Cummings model.
+    dimension = 4
+    wc = wa = 1.0 * 2*np.pi
+    g = 0.1 * 2*np.pi
+    kappa = 0.75
+    gamma = 0.25
+    n_th = 0.01
+
+    a = qutip.tensor(qutip.destroy(dimension), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(dimension), qutip.sigmam())
+    H = wc*a.dag()*a + wa*sm*sm.dag() + g*(a.dag()*sm.dag() + a*sm)
+    c_ops = [np.sqrt(kappa * (n_th+1)) * a,
+             np.sqrt(kappa * n_th) * a.dag(),
+             np.sqrt(gamma) * sm.dag()]
+
+    test, frequencies = spectrum(H, c_ops, a.dag(), a)
+    base = qutip.spectrum(H, frequencies, c_ops, a.dag(), a, solver="es")
+    np.testing.assert_allclose(base, test, atol=1e-3)
+
+
+def _trapz_2d(z, xy):
+    """2D trapezium-method integration assuming a square grid."""
+    dx = xy[1] - xy[0]
+    return dx*dx * np.trapz(np.trapz(z, axis=0))
+
+
+def _n_correlation(times, n):
+    """
+    Numerical integration of the correlation function given an array of
+    expectation values.
+    """
+    return np.array([[n[t] * n[t+tau] for tau in range(times.shape[0])]
+                     for t in range(times.shape[0])])
+
+
+def _coefficient_function(t, args):
+    t_off, tp = args['t_off'], args['tp']
+    return np.exp(-(t-t_off)*(t-t_off) / (2*tp*tp))
+
+
+_coefficient_string = "exp(-(t-t_off)**2 / (2 * tp*tp))"
+
+
+def _h_qobj_function(t, args):
+    return args['H0'] * _coefficient_function(t, args)
+
+
+# 2LS and 3LS stand for two- and three-level system respectively.
+
+_2ls_args = {'H0': 2*qutip.sigmax(), 't_off': 1, 'tp': 0.5}
+_2ls_times = np.linspace(0, 5, 51)
+_3ls_args = {'t_off': 2, 'tp': 1}
+_3ls_times = np.linspace(0, 6, 20)
+
+
+def _2ls_g2_0(H, c_ops):
+    sp = qutip.sigmap()
+    start = qutip.basis(2, 0)
+    times = _2ls_times
+    H = qutip.QobjEvo(H, args=_2ls_args, tlist=times)
+    correlation = qutip.correlation_3op_2t(H, start, times, times, [sp],
+                                           sp.dag(), sp.dag()*sp, sp,
+                                           args=_2ls_args)
+    n_expectation = qutip.mesolve(H, start, times, [sp] + c_ops,
+                                  e_ops=[qutip.num(2)],
+                                  args=_2ls_args).expect[0]
+    integral_correlation = _trapz_2d(np.real(correlation), times)
+    integral_n_expectation = np.trapz(n_expectation, times)
+    # Factor of two from negative time correlations.
+    return 2 * integral_correlation / integral_n_expectation**2
+
+
+@pytest.fixture(params=[
+    pytest.param(_coefficient_string, id="string"),
+    pytest.param(_coefficient_function(_2ls_times, _2ls_args), id="numpy"),
+    pytest.param(_coefficient_function, id="function"),
+])
+def dependence_2ls(request):
+    return request.param
+
+
+class TestTimeDependence:
+    """
+    Test correlations with time-dependent operators using a two-level system
+    (2LS) or a three-level system (3LS).
+    """
+    def test_varying_coefficient_hamiltonian_2ls(self, dependence_2ls):
+        H = [[_2ls_args['H0'], dependence_2ls]]
+        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
+
+    def test_hamiltonian_from_function_2ls(self):
+        H = _h_qobj_function
+        assert abs(_2ls_g2_0(H, []) - 0.575) < 1e-2
+
+    @pytest.mark.slow
+    def test_varying_coefficient_hamiltonian_c_ops_2ls(self, dependence_2ls):
+        H = [[_2ls_args['H0'], dependence_2ls]]
+        c_ops = [[2*qutip.sigmam()*qutip.sigmap(), dependence_2ls]]
+        assert abs(_2ls_g2_0(H, c_ops) - 0.824) < 1e-2
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("dependence_3ls", [
+        pytest.param(_coefficient_string, id="string"),
+        pytest.param(_coefficient_function(_3ls_times, _3ls_args), id="numpy"),
+        pytest.param(_coefficient_function, id="function"),
+    ])
+    def test_coefficient_c_ops_3ls(self, dependence_3ls):
+        # Calculate zero-delay HOM cross-correlation for incoherently pumped
+        # three-level system, g2_ab[0] with gamma = 1.
+        dimension = 3
+        H = qutip.qzero(dimension)
+        start = qutip.basis(dimension, 2)
+        times = _3ls_times
+        project_0_1 = qutip.projection(dimension, 0, 1)
+        project_1_2 = qutip.projection(dimension, 1, 2)
+        population_1 = qutip.projection(dimension, 1, 1)
+        # Define the pi pulse to be when 99% of the population is transferred.
+        rabi = np.sqrt(-np.log(0.01) / (_3ls_args['tp']*np.sqrt(np.pi)))
+        coeff_3ls = qutip.coefficient(dependence_3ls, tlist=times,
+                                      args=_3ls_args)
+        c_ops = [project_0_1, [rabi*project_1_2, coeff_3ls]]
+        forwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
+                                            project_0_1.dag(), project_0_1,
+                                            args=_3ls_args)
+        backwards = qutip.correlation_2op_2t(H, start, times, times, c_ops,
+                                             project_0_1.dag(), project_0_1,
+                                             args=_3ls_args, reverse=True)
+        times2 = np.concatenate([times, times[1:] + times[-1]])
+        n_expect = qutip.mesolve(H, start, times2, c_ops, args=_3ls_args,
+                                 e_ops=[population_1]).expect[0]
+        correlation_ab = -forwards*backwards + _n_correlation(times, n_expect)
+        g2_ab_0 = _trapz_2d(np.real(correlation_ab), times)
+        assert abs(g2_ab_0 - 0.185) < 1e-2
+
+
+def _step(t):
+    return np.arctan(t)/np.pi + 0.5
+
+
+def test_hamiltonian_order_unimportant():
+    # Testing for regression on issue 1048.
+    sp = qutip.sigmap()
+    H = [[qutip.sigmax(), lambda t: _step(t-2)],
+         [qutip.qeye(2), lambda t: _step(-(t-2))]]
+    start = qutip.basis(2, 0)
+    times = np.linspace(0, 5, 6)
+    forwards = qutip.correlation_2op_2t(H, start, times, times, [sp],
+                                        sp.dag(), sp)
+    backwards = qutip.correlation_2op_2t(H[::-1], start, times, times, [sp],
+                                         sp.dag(), sp)
+    np.testing.assert_allclose(forwards, backwards, atol=1e-6)
+
+
+@pytest.mark.parametrize(['solver', 'state'], [
+    pytest.param('me', _equivalence_fock, id="me-ket"),
+    pytest.param('me', _equivalence_coherent, id="me-dm"),
+    pytest.param('me', None, id="me-steady"),
+    pytest.param('es', _equivalence_fock, id="es-ket"),
+    pytest.param('es', _equivalence_coherent, id="es-dm"),
+    pytest.param('es', None, id="es-steady"),
+])
+@pytest.mark.parametrize("is_e_op_hermitian", [True, False],
+                         ids=["hermitian", "nonhermitian"])
+@pytest.mark.parametrize("w", [1, 2])
+@pytest.mark.parametrize("gamma", [1, 10])
+def test_correlation_2op_1t_known_cases(solver,
+                                        state,
+                                        is_e_op_hermitian,
+                                        w,
+                                        gamma,
+                                       ):
+    """This test compares the output correlation_2op_1 solution to an analytical
+    solution."""
+
+    a = qutip.destroy(_equivalence_dimension)
+    x = (a + a.dag())/np.sqrt(2)
+
+    H = w * a.dag() * a
+
+    a_op = x if is_e_op_hermitian else a
+    b_op = x if is_e_op_hermitian else a.dag()
+    c_ops = [np.sqrt(gamma) * a]
+
+    times = np.linspace(0, 1, 30)
+
+    # Handle the case state==None when computing expt values
+    rho0 = state if state else qutip.steadystate(H, c_ops)
+    if is_e_op_hermitian:
+        # Analitycal solution for x,x as operators.
+        base = 0
+        base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
+        base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
+        base /= np.sqrt(2)
+    else:
+        # Analitycal solution for a,adag as operators.
+        base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
+
+    cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
+
+    np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
+
+
+def test_correlation_timedependant_op():
+    num = qutip.num(2)
+    a = qutip.destroy(2)
+    sx = qutip.sigmax()
+    sz = qutip.sigmaz()
+    times = np.arange(4)
+    # switch between sx and sz at t=1.5
+    A_op = qutip.QobjEvo([[sx, lambda t: t<=1.5], [sz, lambda t: t>1.5]])
+
+    cmp_sx = qutip.correlation_2op_1t(num, None, times, [a], sx, sx)
+    cmp_sz = qutip.correlation_2op_1t(num, None, times, [a], sz, sx)
+    cmp_switch = qutip.correlation_2op_1t(num, None, times, [a], A_op, sx)
+    np.testing.assert_allclose(cmp_sx[:2], cmp_switch[:2])
+    np.testing.assert_allclose(cmp_sz[-2:], cmp_switch[-2:])
+
+
+def test_alternative_solver():
+    from qutip.solver.mesolve import MESolver
+    from qutip.solver.brmesolve import BRSolver
+
+    H = qutip.num(5)
+    a = qutip.destroy(5)
+    a_ops = [(a+a.dag(), qutip.coefficient(lambda _, w: w>0, args={"w":0}))]
+
+    br = BRSolver(H, a_ops)
+    me = MESolver(H, [a])
+    times = np.arange(4)
+
+    br_corr = qutip.correlation_3op(br, qutip.basis(5), [0], times, a, a.dag())
+    me_corr = qutip.correlation_3op(me, qutip.basis(5), [0], times, a, a.dag())
+
+    np.testing.assert_allclose(br_corr, me_corr)
+
+
+def test_G1():
+    H = qutip.Qobj([[0,1], [1,0]])
+    psi0 = qutip.basis(2)
+    taus = np.linspace(0, 1, 11)
+    scale = 2
+    a_op = qutip.sigmaz() * scale
+    g1, G1 = qutip.coherence_function_g1(H, psi0, taus, [], a_op)
+    expected = np.array([np.cos(t)**2 - np.sin(t)**2 for t in taus])
+    np.testing.assert_allclose(g1, expected, rtol=2e-5)
+    np.testing.assert_allclose(G1, expected * scale**2, rtol=2e-5)
+
+
+def test_G2():
+    N = 10
+    H = qutip.rand_dm(N)
+    psi0 = qutip.rand_ket(N)
+    taus = np.linspace(0, 1, 11)
+    scale = 2
+    a_op = qutip.rand_unitary(N) * scale
+    g1, G1 = qutip.coherence_function_g2(H, psi0, taus, [], a_op)
+    expected = np.ones(11)
+    np.testing.assert_allclose(g1, expected, rtol=2e-5)
+    np.testing.assert_allclose(G1, expected * scale**4, rtol=2e-5)
diff --git a/qutip/tests/solver/test_countstat.py b/qutip/tests/solver/test_countstat.py
index 130afec6de..6d389b20d1 100644
--- a/qutip/tests/solver/test_countstat.py
+++ b/qutip/tests/solver/test_countstat.py
@@ -1,90 +1,90 @@
-import numpy as np
-import qutip
-import pytest
-
-
-@pytest.mark.filterwarnings("ignore::FutureWarning")
-def test_dqd_current():
-    "Counting statistics: current and current noise in a DQD model"
-
-    G = 0
-    L = 1
-    R = 2
-
-    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
-    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
-    sR = qutip.projection(3, G, R)
-    sL = qutip.projection(3, G, L)
-
-    w0 = 1
-    tc = 0.6 * w0
-    GammaR = 0.0075 * w0
-    GammaL = 0.0075 * w0
-    nth = 0.00
-    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
-
-    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
-
-    c_ops = [
-        np.sqrt(GammaR * (1 + nth)) * sR,
-        np.sqrt(GammaR * (nth)) * sR.dag(),
-        np.sqrt(GammaL * (nth)) * sL,
-        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
-    ]
-
-    current = np.zeros(len(eps_vec))
-    noise = np.zeros(len(eps_vec))
-
-    for n, eps in enumerate(eps_vec):
-        H = eps / 2 * sz + tc * sx
-        L0 = qutip.liouvillian(H)
-        L = qutip.liouvillian(H, c_ops)
-        rhoss = qutip.steadystate(L)
-        current_1, noise_1 = qutip.countstat_current_noise(
-            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
-        )
-        current[n] = current_1[0]
-        noise[n] = noise_1[0, 0, 0]
-
-        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
-        assert abs(current_1[0] - current_2[0]) < 1e-8
-
-        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
-        assert abs(current_1[0] - current_2[0]) < 1e-8
-
-        current_2 = qutip.countstat_current(H, c_ops)
-        assert abs(current_1[0] - current_2[0]) < 1e-8
-
-        current_3, noise_3 = qutip.countstat_current_noise(
-            L, c_ops, wlist=[0, 1], sparse=False
-        )
-        assert abs(current_1[0] - current_3[0]) < 1e-6
-        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
-                                   atol=1e-6)
-
-    current_target = (
-        tc**2
-        * GammaR
-        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
-    )
-    noise_target = current_target * (
-        1
-        - (
-            8
-            * GammaL
-            * tc**2
-            * (
-                4 * eps_vec**2 * (GammaR - GammaL)
-                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
-            )
-            / (
-                4 * tc**2 * (2 * GammaL + GammaR)
-                + GammaL * GammaR**2
-                + 4 * eps_vec**2 * GammaL
-            )
-            ** 2
-        )
-    )
-
-    np.testing.assert_allclose(current, current_target, atol=1e-4)
-    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
+import numpy as np
+import qutip
+import pytest
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_dqd_current():
+    "Counting statistics: current and current noise in a DQD model"
+
+    G = 0
+    L = 1
+    R = 2
+
+    sz = qutip.projection(3, L, L) - qutip.projection(3, R, R)
+    sx = qutip.projection(3, L, R) + qutip.projection(3, R, L)
+    sR = qutip.projection(3, G, R)
+    sL = qutip.projection(3, G, L)
+
+    w0 = 1
+    tc = 0.6 * w0
+    GammaR = 0.0075 * w0
+    GammaL = 0.0075 * w0
+    nth = 0.00
+    eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20)
+
+    J_ops = [GammaR * qutip.sprepost(sR, sR.dag())]
+
+    c_ops = [
+        np.sqrt(GammaR * (1 + nth)) * sR,
+        np.sqrt(GammaR * (nth)) * sR.dag(),
+        np.sqrt(GammaL * (nth)) * sL,
+        np.sqrt(GammaL * (1 + nth)) * sL.dag(),
+    ]
+
+    current = np.zeros(len(eps_vec))
+    noise = np.zeros(len(eps_vec))
+
+    for n, eps in enumerate(eps_vec):
+        H = eps / 2 * sz + tc * sx
+        L0 = qutip.liouvillian(H)
+        L = qutip.liouvillian(H, c_ops)
+        rhoss = qutip.steadystate(L)
+        current_1, noise_1 = qutip.countstat_current_noise(
+            L, [], wlist=[0, 1], rhoss=rhoss, J_ops=J_ops
+        )
+        current[n] = current_1[0]
+        noise[n] = noise_1[0, 0, 0]
+
+        current_2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops)
+        assert abs(current_1[0] - current_2[0]) < 1e-8
+
+        current_2 = qutip.countstat_current(L0, c_ops, J_ops=J_ops)
+        assert abs(current_1[0] - current_2[0]) < 1e-8
+
+        current_2 = qutip.countstat_current(H, c_ops)
+        assert abs(current_1[0] - current_2[0]) < 1e-8
+
+        current_3, noise_3 = qutip.countstat_current_noise(
+            L, c_ops, wlist=[0, 1], sparse=False
+        )
+        assert abs(current_1[0] - current_3[0]) < 1e-6
+        np.testing.assert_allclose(noise_1[0, 0, :], noise_3[0, 0, :],
+                                   atol=1e-6)
+
+    current_target = (
+        tc**2
+        * GammaR
+        / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)
+    )
+    noise_target = current_target * (
+        1
+        - (
+            8
+            * GammaL
+            * tc**2
+            * (
+                4 * eps_vec**2 * (GammaR - GammaL)
+                + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)
+            )
+            / (
+                4 * tc**2 * (2 * GammaL + GammaR)
+                + GammaL * GammaR**2
+                + 4 * eps_vec**2 * GammaL
+            )
+            ** 2
+        )
+    )
+
+    np.testing.assert_allclose(current, current_target, atol=1e-4)
+    np.testing.assert_allclose(noise, noise_target, atol=1e-4)
diff --git a/qutip/tests/solver/test_floquet.py b/qutip/tests/solver/test_floquet.py
index 723bf68467..be90e6fab2 100644
--- a/qutip/tests/solver/test_floquet.py
+++ b/qutip/tests/solver/test_floquet.py
@@ -1,333 +1,333 @@
-import numpy as np
-from qutip import (
-    sigmax, sigmay, sigmaz,  sigmap, sigmam,
-    rand_ket, num, destroy,
-    mesolve, expect, sesolve,
-    Qobj, QobjEvo, coefficient
- )
-
-from qutip.solver.floquet import (
-    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
-    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
-)
-import pytest
-
-
-def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
-    """
-    Convert e_ops for fmmesolve to mesolve
-    """
-    c_op_mesolve = []
-    N = len(vp)
-    for i in range(N):
-        for j in range(N):
-            if i != j:
-                # caclculate the rate
-                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
-                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
-                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
-
-                # add c_op for mesolve
-                c_op_mesolve.append(
-                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
-                )
-    return c_op_mesolve
-
-
-class TestFloquet:
-    """
-    A test class for the QuTiP functions for Floquet formalism.
-    """
-
-    def testFloquetBasis(self):
-        N = 10
-        a = destroy(N)
-        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
-        T = 2 * np.pi
-        floquet_basis = FloquetBasis(H, T)
-        psi0 = rand_ket(N)
-        tlist = np.linspace(0, 10, 11)
-        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
-        states = sesolve(H, psi0, tlist).states
-        for t, state in zip(tlist, states):
-            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
-            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
-
-    def testFloquetUnitary(self):
-        N = 10
-        a = destroy(N)
-        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
-        T = 2 * np.pi
-        psi0 = rand_ket(N)
-        tlist = np.linspace(0, 10, 11)
-        states_se = sesolve(H, psi0, tlist).states
-        states_fse = fsesolve(H, psi0, tlist, T=T).states
-        for state_se, state_fse in zip(states_se, states_fse):
-            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
-
-
-    def testFloquetMasterEquation1(self):
-        """
-        Test Floquet-Markov Master Equation for a driven two-level system
-        without dissipation.
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.5 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
-        e_ops = [num(2)]
-        gamma1 = 0
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_op_fmmesolve = sigmax()
-
-        # Collapse operators for Lindblad Master Equation
-        def spectrum(omega):
-            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-
-        # Solve the floquet-markov master equation
-        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
-                         [spectrum], T, args=args).expect[0]
-
-        # Compare with mesolve
-        p_ex_ref = mesolve(
-            H, psi0, tlist, c_op_mesolve, [num(2)], args
-        ).expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-
-    def testFloquetMasterEquation2(self):
-        """
-        Test Floquet-Markov Master Equation for a two-level system
-        subject to dissipation.
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.0 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-                    args=args)
-        e_ops = [num(2)]
-        gamma1 = 1
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_op_fmmesolve = sigmax()
-
-        # Collapse operator for Lindblad Master Equation
-        def spectrum(omega):
-            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-
-        # Solve the floquet-markov master equation
-        p_ex = fmmesolve(
-            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
-            [spectrum], T, args=args
-        ).expect[0]
-
-        # Compare with mesolve
-        p_ex_ref = mesolve(
-            H, psi0, tlist, c_op_mesolve, [num(2)], args
-        ).expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-
-    @pytest.mark.parametrize("kmax", [5, 25, 100])
-    def testFloquetMasterEquation3(self, kmax):
-        """
-        Test Floquet-Markov Master Equation for a two-level system
-        subject to dissipation with internal transform of fmmesolve
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.0 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-                    args=args)
-        e_ops = [num(2)]
-        gamma1 = 1
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_op_fmmesolve = sigmax()
-
-        # Collapse operator for Lindblad Master Equation
-        def spectrum(omega):
-            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
-
-        # Solve the floquet-markov master equation
-        floquet_basis = FloquetBasis(H, T)
-        solver = FMESolver(
-            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
-        )
-        solver.start(psi0, tlist[0])
-        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
-
-        # Compare with mesolve
-        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
-        p_ex_ref = output2.expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
-                                   atol=5 * 1e-4)
-
-    def testFloquetMasterEquation_multiple_coupling(self):
-        """
-        Test Floquet-Markov Master Equation for a two-level system
-        subject to dissipation with multiple coupling operators
-        """
-        delta = 1.0 * 2 * np.pi
-        eps0 = 1.0 * 2 * np.pi
-        A = 0.0 * 2 * np.pi
-        omega = np.sqrt(delta ** 2 + eps0 ** 2)
-        T = (2 * np.pi) / omega
-        tlist = np.linspace(0.0, 2 * T, 101)
-        psi0 = rand_ket(2)
-        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
-        H1 = A / 2.0 * sigmax()
-        args = {'w': omega}
-        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
-                    args=args)
-        e_ops = [num(2)]
-        gamma1 = 1
-
-        # Collapse operator for Floquet-Markov Master Equation
-        c_ops_fmmesolve = [sigmax(), sigmay()]
-
-        # Collapse operator for Lindblad Master Equation
-        def noise_spectrum1(omega):
-            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
-
-        def noise_spectrum2(omega):
-            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
-
-        noise_spectra = [noise_spectrum1, noise_spectrum2]
-
-        ep, vp = H0.eigenstates()
-        op0 = vp[0]*vp[0].dag()
-        op1 = vp[1]*vp[1].dag()
-
-        c_op_mesolve = []
-
-        # Convert the c_ops for fmmesolve to c_ops for mesolve
-        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
-                                                   noise_spectra):
-            c_op_mesolve += _convert_c_ops(
-                c_op_fmmesolve, noise_spectrum, vp, ep
-            )
-
-        # Solve the floquet-markov master equation
-        output1 = fmmesolve(
-            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
-        )
-        p_ex = output1.expect[0]
-        # Compare with mesolve
-        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
-        p_ex_ref = output2.expect[0]
-
-        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
-
-    def testFloquetRates(self):
-        """
-        Compare rate transition and frequency transitions to analytical
-        results for a driven two-level system, for different drive amplitudes.
-        """
-        # Parameters
-        wq = 5.4 * 2 * np.pi
-        wd = 6.7 * 2 * np.pi
-        delta = wq - wd
-        T = 2 * np.pi / wd
-        tlist = np.linspace(0.0, 2 * T, 101)
-        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
-        H0 = Qobj(wq / 2 * sigmaz())
-        args = {'wd': wd}
-        c_ops = sigmax()
-        gamma1 = 1
-        kmax = 5
-
-        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
-        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
-        array_ana_delta = [
-            2 * np.sqrt((delta / 2)**2 + a**2)
-            for a in array_A
-        ]
-
-        def noise_spectrum(omega):
-            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
-
-        idx = 0
-        for a in array_A:
-            # Hamiltonian
-            H1_p = a * sigmap()
-            H1_m = a * sigmam()
-            H = QobjEvo(
-                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
-                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
-            )
-
-            floquet_basis = FloquetBasis(H, T)
-            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
-            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
-
-            # Check energies
-            deltas = np.ndarray.flatten(DeltaMatrix)
-
-            # deltas and array_ana_delta have at least 1 value in common.
-            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
-
-            # Check matrix elements
-            Xs = np.concatenate(
-                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
-            ).flatten()
-
-            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
-            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
-
-            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
-            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
-            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
-            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
-            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
-            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
-            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
-            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
-            Xpm_p1 = (a / (normMinus * normPlus)
-                      * (array_ana_E0[idx]- delta / 2))
-            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
-            Xpm_m1 = (a / (normMinus * normPlus)
-                      * (array_ana_E1[idx] - delta / 2))
-            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
-            idx += 1
+import numpy as np
+from qutip import (
+    sigmax, sigmay, sigmaz,  sigmap, sigmam,
+    rand_ket, num, destroy,
+    mesolve, expect, sesolve,
+    Qobj, QobjEvo, coefficient
+ )
+
+from qutip.solver.floquet import (
+    FloquetBasis, floquet_tensor, fmmesolve, FMESolver,
+    _floquet_delta_tensor, _floquet_X_matrices, fsesolve
+)
+import pytest
+
+
+def _convert_c_ops(c_op_fmmesolve, noise_spectrum, vp, ep):
+    """
+    Convert e_ops for fmmesolve to mesolve
+    """
+    c_op_mesolve = []
+    N = len(vp)
+    for i in range(N):
+        for j in range(N):
+            if i != j:
+                # caclculate the rate
+                gamma = 2 * np.pi * c_op_fmmesolve.matrix_element(
+                    vp[j], vp[i]) * c_op_fmmesolve.matrix_element(
+                    vp[i], vp[j]) * noise_spectrum(ep[j] - ep[i])
+
+                # add c_op for mesolve
+                c_op_mesolve.append(
+                    np.sqrt(gamma) * (vp[i] * vp[j].dag())
+                )
+    return c_op_mesolve
+
+
+class TestFloquet:
+    """
+    A test class for the QuTiP functions for Floquet formalism.
+    """
+
+    def testFloquetBasis(self):
+        N = 10
+        a = destroy(N)
+        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
+        T = 2 * np.pi
+        floquet_basis = FloquetBasis(H, T)
+        psi0 = rand_ket(N)
+        tlist = np.linspace(0, 10, 11)
+        floquet_psi0 = floquet_basis.to_floquet_basis(psi0)
+        states = sesolve(H, psi0, tlist).states
+        for t, state in zip(tlist, states):
+            from_floquet = floquet_basis.from_floquet_basis(floquet_psi0, t)
+            assert state.overlap(from_floquet) == pytest.approx(1., abs=5e-5)
+
+    def testFloquetUnitary(self):
+        N = 10
+        a = destroy(N)
+        H = num(N) + (a+a.dag()) * coefficient(lambda t: np.cos(t))
+        T = 2 * np.pi
+        psi0 = rand_ket(N)
+        tlist = np.linspace(0, 10, 11)
+        states_se = sesolve(H, psi0, tlist).states
+        states_fse = fsesolve(H, psi0, tlist, T=T).states
+        for state_se, state_fse in zip(states_se, states_fse):
+            assert state_se.overlap(state_fse) == pytest.approx(1., abs=5e-5)
+
+
+    def testFloquetMasterEquation1(self):
+        """
+        Test Floquet-Markov Master Equation for a driven two-level system
+        without dissipation.
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.5 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = [H0, [H1, lambda t, args: np.sin(args['w'] * t)]]
+        e_ops = [num(2)]
+        gamma1 = 0
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_op_fmmesolve = sigmax()
+
+        # Collapse operators for Lindblad Master Equation
+        def spectrum(omega):
+            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+
+        # Solve the floquet-markov master equation
+        p_ex = fmmesolve(H, psi0, tlist, [c_op_fmmesolve], [num(2)],
+                         [spectrum], T, args=args).expect[0]
+
+        # Compare with mesolve
+        p_ex_ref = mesolve(
+            H, psi0, tlist, c_op_mesolve, [num(2)], args
+        ).expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+
+    def testFloquetMasterEquation2(self):
+        """
+        Test Floquet-Markov Master Equation for a two-level system
+        subject to dissipation.
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.0 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+                    args=args)
+        e_ops = [num(2)]
+        gamma1 = 1
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_op_fmmesolve = sigmax()
+
+        # Collapse operator for Lindblad Master Equation
+        def spectrum(omega):
+            return (omega > 0) * omega * 0.5 * gamma1 / (2 * np.pi)
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+
+        # Solve the floquet-markov master equation
+        p_ex = fmmesolve(
+            H, psi0, tlist, [c_op_fmmesolve], [num(2)],
+            [spectrum], T, args=args
+        ).expect[0]
+
+        # Compare with mesolve
+        p_ex_ref = mesolve(
+            H, psi0, tlist, c_op_mesolve, [num(2)], args
+        ).expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+
+    @pytest.mark.parametrize("kmax", [5, 25, 100])
+    def testFloquetMasterEquation3(self, kmax):
+        """
+        Test Floquet-Markov Master Equation for a two-level system
+        subject to dissipation with internal transform of fmmesolve
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.0 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+                    args=args)
+        e_ops = [num(2)]
+        gamma1 = 1
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_op_fmmesolve = sigmax()
+
+        # Collapse operator for Lindblad Master Equation
+        def spectrum(omega):
+            return (omega > 0) * 0.5 * gamma1 * omega / (2 * np.pi)
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = _convert_c_ops(c_op_fmmesolve, spectrum, vp, ep)
+
+        # Solve the floquet-markov master equation
+        floquet_basis = FloquetBasis(H, T)
+        solver = FMESolver(
+            floquet_basis, [(c_op_fmmesolve, spectrum)], kmax=kmax
+        )
+        solver.start(psi0, tlist[0])
+        p_ex = [expect(num(2), solver.step(t)) for t in tlist]
+
+        # Compare with mesolve
+        output2 = mesolve(H, psi0, tlist, c_op_mesolve, [num(2)], args)
+        p_ex_ref = output2.expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref),
+                                   atol=5 * 1e-4)
+
+    def testFloquetMasterEquation_multiple_coupling(self):
+        """
+        Test Floquet-Markov Master Equation for a two-level system
+        subject to dissipation with multiple coupling operators
+        """
+        delta = 1.0 * 2 * np.pi
+        eps0 = 1.0 * 2 * np.pi
+        A = 0.0 * 2 * np.pi
+        omega = np.sqrt(delta ** 2 + eps0 ** 2)
+        T = (2 * np.pi) / omega
+        tlist = np.linspace(0.0, 2 * T, 101)
+        psi0 = rand_ket(2)
+        H0 = - eps0 / 2.0 * sigmaz() - delta / 2.0 * sigmax()
+        H1 = A / 2.0 * sigmax()
+        args = {'w': omega}
+        H = QobjEvo([H0, [H1, lambda t, w: np.sin(w * t)]],
+                    args=args)
+        e_ops = [num(2)]
+        gamma1 = 1
+
+        # Collapse operator for Floquet-Markov Master Equation
+        c_ops_fmmesolve = [sigmax(), sigmay()]
+
+        # Collapse operator for Lindblad Master Equation
+        def noise_spectrum1(omega):
+            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
+
+        def noise_spectrum2(omega):
+            return (omega > 0) * 0.5 * gamma1 / (2 * np.pi)
+
+        noise_spectra = [noise_spectrum1, noise_spectrum2]
+
+        ep, vp = H0.eigenstates()
+        op0 = vp[0]*vp[0].dag()
+        op1 = vp[1]*vp[1].dag()
+
+        c_op_mesolve = []
+
+        # Convert the c_ops for fmmesolve to c_ops for mesolve
+        for c_op_fmmesolve, noise_spectrum in zip(c_ops_fmmesolve,
+                                                   noise_spectra):
+            c_op_mesolve += _convert_c_ops(
+                c_op_fmmesolve, noise_spectrum, vp, ep
+            )
+
+        # Solve the floquet-markov master equation
+        output1 = fmmesolve(
+            H, psi0, tlist, c_ops_fmmesolve, e_ops, noise_spectra, T
+        )
+        p_ex = output1.expect[0]
+        # Compare with mesolve
+        output2 = mesolve(H, psi0, tlist, c_op_mesolve, e_ops, args)
+        p_ex_ref = output2.expect[0]
+
+        np.testing.assert_allclose(np.real(p_ex), np.real(p_ex_ref), atol=1e-4)
+
+    def testFloquetRates(self):
+        """
+        Compare rate transition and frequency transitions to analytical
+        results for a driven two-level system, for different drive amplitudes.
+        """
+        # Parameters
+        wq = 5.4 * 2 * np.pi
+        wd = 6.7 * 2 * np.pi
+        delta = wq - wd
+        T = 2 * np.pi / wd
+        tlist = np.linspace(0.0, 2 * T, 101)
+        array_A = np.linspace(0.001, 3 * 2 * np.pi, 10, endpoint=False)
+        H0 = Qobj(wq / 2 * sigmaz())
+        args = {'wd': wd}
+        c_ops = sigmax()
+        gamma1 = 1
+        kmax = 5
+
+        array_ana_E0 = [-np.sqrt((delta / 2)**2 + a**2) for a in array_A]
+        array_ana_E1 = [np.sqrt((delta / 2)**2 + a**2) for a in array_A]
+        array_ana_delta = [
+            2 * np.sqrt((delta / 2)**2 + a**2)
+            for a in array_A
+        ]
+
+        def noise_spectrum(omega):
+            return (omega > 0) * 0.5 * gamma1 * omega/(2*np.pi)
+
+        idx = 0
+        for a in array_A:
+            # Hamiltonian
+            H1_p = a * sigmap()
+            H1_m = a * sigmam()
+            H = QobjEvo(
+                [H0, [H1_p, lambda t, wd: np.exp(-1j * wd * t)],
+                [H1_m, lambda t, wd: np.exp(1j * wd * t)]], args=args
+            )
+
+            floquet_basis = FloquetBasis(H, T)
+            DeltaMatrix = _floquet_delta_tensor(floquet_basis.e_quasi, kmax, T)
+            X = _floquet_X_matrices(floquet_basis, [c_ops], kmax)
+
+            # Check energies
+            deltas = np.ndarray.flatten(DeltaMatrix)
+
+            # deltas and array_ana_delta have at least 1 value in common.
+            assert (min(abs(deltas - array_ana_delta[idx])) < 1e-4)
+
+            # Check matrix elements
+            Xs = np.concatenate(
+                [X[0][k].to_array() for k in range(-kmax, kmax+1)]
+            ).flatten()
+
+            normPlus = np.sqrt(a**2 + (array_ana_E1[idx] - delta / 2)**2)
+            normMinus = np.sqrt(a**2 + (array_ana_E0[idx] - delta / 2)**2)
+
+            Xpp_p1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
+            assert (min(abs(Xs - Xpp_p1)) < 1e-4)
+            Xpp_m1 = (a / normPlus**2) * (array_ana_E1[idx] - delta / 2)
+            assert (min(abs(Xs - Xpp_m1)) < 1e-4)
+            Xmm_p1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
+            assert (min(abs(Xs - Xmm_p1)) < 1e-4)
+            Xmm_m1 = (a / normMinus**2) * (array_ana_E0[idx] - delta / 2)
+            assert (min(abs(Xs - Xmm_m1)) < 1e-4)
+            Xpm_p1 = (a / (normMinus * normPlus)
+                      * (array_ana_E0[idx]- delta / 2))
+            assert (min(abs(Xs - Xpm_p1)) < 1e-4)
+            Xpm_m1 = (a / (normMinus * normPlus)
+                      * (array_ana_E1[idx] - delta / 2))
+            assert (min(abs(Xs - Xpm_m1)) < 1e-4)
+            idx += 1
diff --git a/qutip/tests/solver/test_integrator.py b/qutip/tests/solver/test_integrator.py
index 5c46c8f39b..8779ea76a2 100644
--- a/qutip/tests/solver/test_integrator.py
+++ b/qutip/tests/solver/test_integrator.py
@@ -1,164 +1,164 @@
-from qutip.solver.sesolve import SESolver
-from qutip.solver.mesolve import MESolver
-from qutip.solver.mcsolve import MCSolver
-from qutip.solver.solver_base import Solver
-from qutip.solver.integrator import *
-import qutip
-import numpy as np
-from numpy.testing import assert_allclose
-import pytest
-
-
-class TestIntegratorCte():
-    _analytical_se = lambda _, t: np.cos(t * np.pi)
-    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
-    _analytical_me = lambda _, t: 1 - np.exp(-t)
-    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
-                                  c_ops=[qutip.destroy(2)])
-
-    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
-    def se_method(self, request):
-        return request.param
-
-    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
-    def me_method(self, request):
-        return request.param
-
-    # TODO: Change when the MCSolver is added
-    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
-    def mc_method(self, request):
-        return request.param
-
-    def test_se_integration(self, se_method):
-        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
-        state0 = qutip.basis(2, 0).data
-        evol.set_state(0, state0)
-        for t, state in evol.run(np.linspace(0, 2, 21)):
-            assert_allclose(self._analytical_se(t),
-                            state.to_array()[0, 0], atol=2e-5)
-            assert state.shape == (2, 1)
-
-    def test_me_integration(self, me_method):
-        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
-        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
-        evol.set_state(0, state0)
-        for t in np.linspace(0, 2, 21):
-            t_, state = evol.integrate(t)
-            assert t_ == t
-            assert_allclose(self._analytical_me(t),
-                            state.to_array()[0, 0], atol=2e-5)
-
-    def test_mc_integration(self, mc_method):
-        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
-        state = qutip.basis(2,0).data
-        evol.set_state(0, state)
-        t = 0
-        for i in range(1, 21):
-            t_target = i * 0.05
-            while t < t_target:
-                t_old, y_old = evol.get_state()
-                t, state = evol.mcstep(t_target)
-                assert t <= t_target
-                assert t > t_old
-                assert_allclose(self._analytical_se(t),
-                                state.to_array()[0, 0], atol=2e-5)
-                t_back = (t + t_old) / 2
-                t_got, bstate = evol.mcstep(t_back)
-                assert t_back == t_got
-                assert_allclose(self._analytical_se(t),
-                                state.to_array()[0, 0], atol=2e-5)
-                t, state = evol.mcstep(t)
-
-
-    @pytest.mark.parametrize('start', [1, -1])
-    def test_mc_integration_mixed(self, start, mc_method):
-        system = qutip.QobjEvo(qutip.qeye(1))
-        evol = Solver.avail_integrators()[mc_method](system, {})
-
-        state = qutip.basis(1,0).data
-        evol.set_state(start, state)
-        t = start
-        t_target = start + .1
-        while t < t_target:
-            t, _ = evol.mcstep(start + .1)
-        _ = evol.mcstep(start + .2)
-        t_target = (start + .1 + t) / 2
-        t, state = evol.mcstep(t_target)
-        assert (
-            state.to_array()[0, 0]
-            == pytest.approx(np.exp(t - start), abs=1e-5)
-        )
-
-
-class TestIntegrator(TestIntegratorCte):
-    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
-    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
-    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
-    me_system = qutip.liouvillian(
-        qutip.QobjEvo(qutip.qeye(2)),
-        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
-    )
-
-    @pytest.fixture(
-        params=[key for key, integrator in SESolver.avail_integrators().items()
-                if integrator.support_time_dependant]
-    )
-    def se_method(self, request):
-        return request.param
-
-    @pytest.fixture(
-        params=[key for key, integrator in MESolver.avail_integrators().items()
-                if integrator.support_time_dependant]
-    )
-    def me_method(self, request):
-        return request.param
-
-    @pytest.fixture(
-        params=[key for key, integrator in MCSolver.avail_integrators().items()
-                if integrator.support_time_dependant]
-    )
-    def mc_method(self, request):
-        return request.param
-
-
-@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
-                     ids=["large", "multiple subspaces", "diagonal"])
-def test_krylov(sizes):
-    # Krylov solve act differently for large systems composed tensored
-    # sub systems.
-    N, M = sizes
-    H = qutip.qeye(N)
-    if M:
-        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
-    H = qutip.QobjEvo(-1j * H)
-    integrator = IntegratorKrylov(H, {})
-    ref_integrator = IntegratorDiag(H, {})
-    psi = qutip.basis(100, 95).data
-    integrator.set_state(0, psi)
-    ref_integrator.set_state(0, psi)
-    for t in np.linspace(0.25, 1, 4):
-        out = integrator.integrate(t)[1]
-        ref = ref_integrator.integrate(t)[1]
-        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
-
-
-@pytest.mark.parametrize('integrator',
-    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
-    ids=["adams", 'bdf', "lsoda"]
-)
-def test_concurent_usage(integrator):
-    opt = {'atol':1e-10, 'rtol':1e-7}
-
-    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
-    inter1 = integrator(sys1, opt)
-    inter1.set_state(0, qutip.basis(1,0).data)
-
-    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
-    inter2 = integrator(sys2, opt)
-    inter2.set_state(0, qutip.basis(1,0).data)
-
-    for t in np.linspace(0,1,6):
-        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
-        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
-        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
-        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
+from qutip.solver.sesolve import SESolver
+from qutip.solver.mesolve import MESolver
+from qutip.solver.mcsolve import MCSolver
+from qutip.solver.solver_base import Solver
+from qutip.solver.integrator import *
+import qutip
+import numpy as np
+from numpy.testing import assert_allclose
+import pytest
+
+
+class TestIntegratorCte():
+    _analytical_se = lambda _, t: np.cos(t * np.pi)
+    se_system = qutip.QobjEvo(-1j * qutip.sigmax() * np.pi)
+    _analytical_me = lambda _, t: 1 - np.exp(-t)
+    me_system = qutip.liouvillian(qutip.QobjEvo(qutip.qeye(2)),
+                                  c_ops=[qutip.destroy(2)])
+
+    @pytest.fixture(params=list(SESolver.avail_integrators().keys()))
+    def se_method(self, request):
+        return request.param
+
+    @pytest.fixture(params=list(MESolver.avail_integrators().keys()))
+    def me_method(self, request):
+        return request.param
+
+    # TODO: Change when the MCSolver is added
+    @pytest.fixture(params=list(MCSolver.avail_integrators().keys()))
+    def mc_method(self, request):
+        return request.param
+
+    def test_se_integration(self, se_method):
+        evol = SESolver.avail_integrators()[se_method](self.se_system, {})
+        state0 = qutip.basis(2, 0).data
+        evol.set_state(0, state0)
+        for t, state in evol.run(np.linspace(0, 2, 21)):
+            assert_allclose(self._analytical_se(t),
+                            state.to_array()[0, 0], atol=2e-5)
+            assert state.shape == (2, 1)
+
+    def test_me_integration(self, me_method):
+        evol = MESolver.avail_integrators()[me_method](self.me_system, {})
+        state0 = qutip.operator_to_vector(qutip.fock_dm(2,1)).data
+        evol.set_state(0, state0)
+        for t in np.linspace(0, 2, 21):
+            t_, state = evol.integrate(t)
+            assert t_ == t
+            assert_allclose(self._analytical_me(t),
+                            state.to_array()[0, 0], atol=2e-5)
+
+    def test_mc_integration(self, mc_method):
+        evol = MCSolver.avail_integrators()[mc_method](self.se_system, {})
+        state = qutip.basis(2,0).data
+        evol.set_state(0, state)
+        t = 0
+        for i in range(1, 21):
+            t_target = i * 0.05
+            while t < t_target:
+                t_old, y_old = evol.get_state()
+                t, state = evol.mcstep(t_target)
+                assert t <= t_target
+                assert t > t_old
+                assert_allclose(self._analytical_se(t),
+                                state.to_array()[0, 0], atol=2e-5)
+                t_back = (t + t_old) / 2
+                t_got, bstate = evol.mcstep(t_back)
+                assert t_back == t_got
+                assert_allclose(self._analytical_se(t),
+                                state.to_array()[0, 0], atol=2e-5)
+                t, state = evol.mcstep(t)
+
+
+    @pytest.mark.parametrize('start', [1, -1])
+    def test_mc_integration_mixed(self, start, mc_method):
+        system = qutip.QobjEvo(qutip.qeye(1))
+        evol = Solver.avail_integrators()[mc_method](system, {})
+
+        state = qutip.basis(1,0).data
+        evol.set_state(start, state)
+        t = start
+        t_target = start + .1
+        while t < t_target:
+            t, _ = evol.mcstep(start + .1)
+        _ = evol.mcstep(start + .2)
+        t_target = (start + .1 + t) / 2
+        t, state = evol.mcstep(t_target)
+        assert (
+            state.to_array()[0, 0]
+            == pytest.approx(np.exp(t - start), abs=1e-5)
+        )
+
+
+class TestIntegrator(TestIntegratorCte):
+    _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
+    se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
+    _analytical_me = lambda _, t: 1 - np.exp(-(t**3) / 3)
+    me_system = qutip.liouvillian(
+        qutip.QobjEvo(qutip.qeye(2)),
+        c_ops=[qutip.QobjEvo([qutip.destroy(2), 't'])]
+    )
+
+    @pytest.fixture(
+        params=[key for key, integrator in SESolver.avail_integrators().items()
+                if integrator.support_time_dependant]
+    )
+    def se_method(self, request):
+        return request.param
+
+    @pytest.fixture(
+        params=[key for key, integrator in MESolver.avail_integrators().items()
+                if integrator.support_time_dependant]
+    )
+    def me_method(self, request):
+        return request.param
+
+    @pytest.fixture(
+        params=[key for key, integrator in MCSolver.avail_integrators().items()
+                if integrator.support_time_dependant]
+    )
+    def mc_method(self, request):
+        return request.param
+
+
+@pytest.mark.parametrize('sizes', [(1, 100), (10, 10), (100, 0)],
+                     ids=["large", "multiple subspaces", "diagonal"])
+def test_krylov(sizes):
+    # Krylov solve act differently for large systems composed tensored
+    # sub systems.
+    N, M = sizes
+    H = qutip.qeye(N)
+    if M:
+        H = H & (qutip.num(M) + qutip.create(M) + qutip.destroy(M))
+    H = qutip.QobjEvo(-1j * H)
+    integrator = IntegratorKrylov(H, {})
+    ref_integrator = IntegratorDiag(H, {})
+    psi = qutip.basis(100, 95).data
+    integrator.set_state(0, psi)
+    ref_integrator.set_state(0, psi)
+    for t in np.linspace(0.25, 1, 4):
+        out = integrator.integrate(t)[1]
+        ref = ref_integrator.integrate(t)[1]
+        assert qutip.data.norm.l2(out - ref) == pytest.approx(0, abs=1e-6)
+
+
+@pytest.mark.parametrize('integrator',
+    [IntegratorScipyAdams, IntegratorScipyBDF, IntegratorScipylsoda],
+    ids=["adams", 'bdf', "lsoda"]
+)
+def test_concurent_usage(integrator):
+    opt = {'atol':1e-10, 'rtol':1e-7}
+
+    sys1 = qutip.QobjEvo(0.5*qutip.qeye(1))
+    inter1 = integrator(sys1, opt)
+    inter1.set_state(0, qutip.basis(1,0).data)
+
+    sys2 = qutip.QobjEvo(-0.5*qutip.qeye(1))
+    inter2 = integrator(sys2, opt)
+    inter2.set_state(0, qutip.basis(1,0).data)
+
+    for t in np.linspace(0,1,6):
+        expected1 = pytest.approx(np.exp(t/2), abs=1e-5)
+        assert inter1.integrate(t)[1].to_array()[0, 0] == expected1
+        expected2 = pytest.approx(np.exp(-t/2), abs=1e-5)
+        assert inter2.integrate(t)[1].to_array()[0, 0] == expected2
diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index 840f733706..be5b5b3bad 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -1,439 +1,439 @@
-import pytest
-import numpy as np
-import qutip
-from copy import copy
-from qutip.solver.mcsolve import mcsolve, MCSolver
-from qutip.solver.solver_base import Solver
-
-def _return_constant(t, args):
-    return args['constant']
-
-
-def _return_decay(t, args):
-    return args['constant'] * np.exp(-args['rate'] * t)
-
-
-class callable_qobj:
-    def __init__(self, oper, coeff=None):
-        self.oper = oper
-        self.coeff = coeff
-
-    def __call__(self, t, args):
-        if self.coeff is not None:
-            return self.oper * self.coeff(t, args)
-        return self.oper
-
-
-@pytest.mark.usefixtures("in_temporary_directory")
-class StatesAndExpectOutputCase:
-    """
-    Mixin class to test the states and expectation values from ``mcsolve``.
-    """
-    size = 10
-    h = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 1, 101)
-    e_ops = [qutip.num(size)]
-    ntraj = 2000
-
-    def _assert_states(self, result, expected, tol):
-        assert hasattr(result, 'states')
-        assert len(result.states) == len(self.times)
-        assert len(self.e_ops) == len(expected)
-        for test_operator, expected_part in zip(self.e_ops, expected):
-            test = qutip.expect(test_operator, result.states)
-            np.testing.assert_allclose(test, expected_part, rtol=tol)
-
-    def _assert_expect(self, result, expected, tol):
-        assert hasattr(result, 'expect')
-        assert len(result.expect) == len(self.e_ops)
-        assert len(self.e_ops) == len(expected)
-        for test, expected_part in zip(result.expect, expected):
-            np.testing.assert_allclose(test, expected_part, rtol=tol)
-
-    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
-        options = {"store_states": True, "map": "serial"}
-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options=options, target_tol=0.05)
-        self._assert_expect(result, expected, tol)
-        self._assert_states(result, expected, tol)
-
-
-class TestNoCollapse(StatesAndExpectOutputCase):
-    """
-    Test that `mcsolve` correctly solves the system when there is a constant
-    Hamiltonian and no collapses.
-    """
-    def pytest_generate_tests(self, metafunc):
-        tol = 1e-8
-        expect = (qutip.expect(self.e_ops[0], self.state)
-                  * np.ones_like(self.times))
-        hamiltonian_types = [
-            (self.h, "Qobj"),
-            ([self.h], "list"),
-            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
-                           args= {'constant': 0}), "QobjEvo"),
-            (callable_qobj(self.h), "callable"),
-        ]
-        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
-                 for hamiltonian, id in hamiltonian_types]
-        metafunc.parametrize(
-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-            cases)
-
-    # Previously the "states_only" and "expect_only" tests were mixed in to
-    # every other test case.  We move them out into the simplest set so that
-    # their behaviour remains tested, but isn't repeated as often to keep test
-    # runtimes shorter.  The known-good cases are still tested in the other
-    # test cases, this is just testing the single-output behaviour.
-
-    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
-        options = {"store_states": True, "map": "serial"}
-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
-                         options=options)
-        self._assert_states(result, expected, tol)
-
-    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
-        result = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options={'map': 'serial'})
-        self._assert_expect(result, expected, tol)
-
-
-class TestConstantCollapse(StatesAndExpectOutputCase):
-    """
-    Test that `mcsolve` correctly solves the system when there is a constant
-    collapse operator.
-    """
-    def pytest_generate_tests(self, metafunc):
-        tol = 0.25
-        coupling = 0.2
-        expect = (qutip.expect(self.e_ops[0], self.state)
-                  * np.exp(-coupling * self.times))
-        collapse_op = qutip.destroy(self.size)
-        c_op_types = [
-            (np.sqrt(coupling)*collapse_op, {}, "constant"),
-            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
-            (callable_qobj(collapse_op, _return_constant),
-             {'constant': np.sqrt(coupling)}, "function"),
-        ]
-        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
-                 for c_op, args, id in c_op_types]
-        metafunc.parametrize(
-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-            cases)
-
-
-class TestTimeDependentCollapse(StatesAndExpectOutputCase):
-    """
-    Test that `mcsolve` correctly solves the system when the collapse operators
-    are time-dependent.
-    """
-    def pytest_generate_tests(self, metafunc):
-        tol = 0.25
-        coupling = 0.2
-        expect = (qutip.expect(self.e_ops[0], self.state)
-                  * np.exp(-coupling * (1 - np.exp(-self.times))))
-        collapse_op = qutip.destroy(self.size)
-        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
-        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
-        c_op_types = [
-            ([collapse_op, _return_decay], collapse_args, "function"),
-            ([collapse_op, collapse_string], {}, "string"),
-        ]
-        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
-                 for c_op, args, id in c_op_types]
-        metafunc.parametrize(
-            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
-            cases)
-
-
-def test_stored_collapse_operators_and_times():
-    """
-    Test that the output contains information on which collapses happened and
-    at what times, and make sure that this information makes sense.
-    """
-    size = 10
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 10, 100)
-    c_ops = [a, a]
-    result = mcsolve(H, state, times, c_ops, ntraj=3,
-                     options={'map': 'serial'})
-    assert len(result.col_times[0]) > 0
-    assert len(result.col_which) == len(result.col_times)
-    assert all(col in [0, 1] for col in result.col_which[0])
-
-
-@pytest.mark.parametrize('keep_runs_results', [True, False])
-def test_states_outputs(keep_runs_results):
-    # We're just testing the output value, so it's important whether certain
-    # things are complex or real, but not what the magnitudes of constants are.
-    focks = 5
-    ntraj = 5
-    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
-    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
-    H = 1j*a.dag()*sm + a
-    H = H + H.dag()
-    state = qutip.basis([focks, 2], [0, 1])
-    times = np.linspace(0, 10, 21)
-    c_ops = [a, sm]
-    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
-                   options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'})
-
-    assert len(data.average_states) == len(times)
-    assert isinstance(data.average_states[0], qutip.Qobj)
-    assert data.average_states[0].norm() == pytest.approx(1.)
-    assert data.average_states[0].isoper
-
-    assert isinstance(data.average_final_state, qutip.Qobj)
-    assert data.average_final_state.norm() == pytest.approx(1.)
-    assert data.average_final_state.isoper
-
-    assert isinstance(data.photocurrent[0][1], float)
-    assert isinstance(data.photocurrent[1][1], float)
-    assert (np.array(data.runs_photocurrent).shape
-        == (ntraj, len(c_ops), len(times)-1))
-
-    if keep_runs_results:
-        assert len(data.runs_states) == ntraj
-        assert len(data.runs_states[0]) == len(times)
-        assert isinstance(data.runs_states[0][0], qutip.Qobj)
-        assert data.runs_states[0][0].norm() == pytest.approx(1.)
-        assert data.runs_states[0][0].isket
-
-        assert len(data.runs_final_states) == ntraj
-        assert isinstance(data.runs_final_states[0], qutip.Qobj)
-        assert data.runs_final_states[0].norm() == pytest.approx(1.)
-        assert data.runs_final_states[0].isket
-
-    assert isinstance(data.steady_state(), qutip.Qobj)
-    assert data.steady_state().norm() == pytest.approx(1.)
-    assert data.steady_state().isoper
-
-    np.testing.assert_allclose(times, data.times)
-    assert data.num_trajectories == ntraj
-    assert len(data.e_ops) == 0
-    assert data.stats["num_collapse"] == len(c_ops)
-    assert len(data.col_times) == ntraj
-    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
-    assert data.stats['end_condition'] == "ntraj reached"
-
-
-@pytest.mark.parametrize('keep_runs_results', [True, False])
-def test_expectation_outputs(keep_runs_results):
-    # We're just testing the output value, so it's important whether certain
-    # things are complex or real, but not what the magnitudes of constants are.
-    focks = 5
-    ntraj = 5
-    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
-    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
-    H = 1j*a.dag()*sm + a
-    H = H + H.dag()
-    state = qutip.basis([focks, 2], [0, 1])
-    times = np.linspace(0, 10, 5)
-    c_ops = [a, sm]
-    e_ops = [a.dag()*a, sm.dag()*sm, a]
-    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                   options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'})
-    assert isinstance(data.average_expect[0][1], float)
-    assert isinstance(data.average_expect[1][1], float)
-    assert isinstance(data.average_expect[2][1], complex)
-    assert isinstance(data.std_expect[0][1], float)
-    assert isinstance(data.std_expect[1][1], float)
-    assert isinstance(data.std_expect[2][1], float)
-    if keep_runs_results:
-        assert len(data.runs_expect) == len(e_ops)
-        assert len(data.runs_expect[0]) == ntraj
-        assert isinstance(data.runs_expect[0][0][1], float)
-        assert isinstance(data.runs_expect[1][0][1], float)
-        assert isinstance(data.runs_expect[2][0][1], complex)
-    assert isinstance(data.photocurrent[0][0], float)
-    assert isinstance(data.photocurrent[1][0], float)
-    assert (np.array(data.runs_photocurrent).shape
-            == (ntraj, len(c_ops), len(times)-1))
-    np.testing.assert_allclose(times, data.times)
-    assert data.num_trajectories == ntraj
-    assert len(data.e_ops) == len(e_ops)
-    assert data.stats["num_collapse"] == len(c_ops)
-    assert len(data.col_times) == ntraj
-    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
-    assert data.stats['end_condition'] == "ntraj reached"
-
-
-class TestSeeds:
-    sizes = [6, 6, 6]
-    dampings = [0.1, 0.4, 0.1]
-    ntraj = 25  # Big enough to ensure there are differences without being slow
-    a = [qutip.destroy(size) for size in sizes]
-    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
-              - qutip.tensor(a[0].dag(), a[1], a[2]))
-    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
-                         qutip.basis(sizes[1:], [0, 0]))
-    times = np.linspace(0, 10, 2)
-    c_ops = [
-        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
-        (np.sqrt(2*dampings[1])
-         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
-        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
-    ]
-
-    def test_seeds_can_be_reused(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, **kwargs)
-        second = mcsolve(*args, seeds=first.seeds, **kwargs)
-        for first_t, second_t in zip(first.col_times, second.col_times):
-            np.testing.assert_equal(first_t, second_t)
-        for first_w, second_w in zip(first.col_which, second.col_which):
-            np.testing.assert_equal(first_w, second_w)
-
-    def test_seeds_are_not_reused_by_default(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, **kwargs)
-        second = mcsolve(*args, **kwargs)
-        assert not all(np.array_equal(first_t, second_t)
-                       for first_t, second_t in zip(first.col_times,
-                                                    second.col_times))
-        assert not all(np.array_equal(first_w, second_w)
-                       for first_w, second_w in zip(first.col_which,
-                                                    second.col_which))
-
-    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
-    def test_seed_type(self, seed):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, seeds=copy(seed), **kwargs)
-        second = mcsolve(*args, seeds=copy(seed), **kwargs)
-        for f_seed, s_seed in zip(first.seeds, second.seeds):
-            assert f_seed.state == s_seed.state
-
-    def test_bad_seed(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        with pytest.raises(ValueError):
-            first = mcsolve(*args, seeds=[1], **kwargs)
-
-    def test_generator(self):
-        args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
-        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
-                        **kwargs)
-        second = mcsolve(*args, seeds=1, **kwargs)
-        for f_seed, s_seed in zip(first.seeds, second.seeds):
-            assert f_seed.state == s_seed.state
-        assert not all(np.array_equal(first_t, second_t)
-                       for first_t, second_t in zip(first.col_times,
-                                                    second.col_times))
-        assert not all(np.array_equal(first_w, second_w)
-                       for first_w, second_w in zip(first.col_which,
-                                                    second.col_which))
-
-    def test_stepping(self):
-        size = 10
-        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
-        H = qutip.num(size)
-        mcsolver = MCSolver(H, a, options={'map': 'serial'})
-        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-        state_1 = mcsolver.step(1, args={'alpha':1})
-
-        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-        state_2 = mcsolver.step(1, args={'alpha':1})
-        assert state_1 == state_2
-
-
-def test_timeout():
-    size = 10
-    ntraj = 1000
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 1.0, 100)
-    coupling = 0.5
-    n_th = 0.05
-    c_ops = np.sqrt(coupling * (n_th + 1)) * a
-    e_ops = [qutip.num(size)]
-    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                  options={'map': 'serial'}, timeout=1e-6)
-    assert res.stats['end_condition'] == 'timeout'
-
-
-def test_super_H():
-    size = 10
-    ntraj = 1000
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    state = qutip.basis(size, size-1)
-    times = np.linspace(0, 1.0, 100)
-    # Arbitrary coupling and bath temperature.
-    coupling = 0.5
-    n_th = 0.05
-    c_ops = np.sqrt(coupling * (n_th + 1)) * a
-    e_ops = [qutip.num(size)]
-    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                          target_tol=0.1, options={'map': 'serial'})
-    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
-                 target_tol=0.1, options={'map': 'serial'})
-    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
-
-
-def test_MCSolver_run():
-    size = 10
-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
-    H = qutip.num(size)
-    solver = MCSolver(H, a)
-    solver.options = {'store_final_state': True}
-    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
-                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
-    assert res.final_state is not None
-    assert len(res.collapse[0]) != 0
-    assert res.num_trajectories == 1
-    np.testing.assert_allclose(res.expect[0], np.ones(11))
-    res += solver.run(
-        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
-        e_ops=[qutip.qeye(size)], args={'coupling': 1},
-        ntraj=1000, target_tol=0.1
-    )
-    assert res.num_trajectories == 1001
-
-
-def test_MCSolver_stepping():
-    size = 10
-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
-    H = qutip.num(size)
-    solver = MCSolver(H, a)
-    solver.start(qutip.basis(size, size-1), 0, seed=0)
-    solver.options = {'method': 'lsoda'}
-    state = solver.step(1)
-    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
-    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
-    assert state.isket
-    state = solver.step(5, args={'coupling': 5})
-    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
-    assert qutip.expect(qutip.num(size), state) <= size - 1
-    assert state.isket
-
-
-# Defined in module-scope so it's pickleable.
-def _dynamic(t, args):
-    return 0 if args["collapse"] else 1
-
-
-@pytest.mark.xfail(reason="current limitation of McSolve")
-def test_dynamic_arguments():
-    """Test dynamically updated arguments are usable."""
-    size = 5
-    a = qutip.destroy(size)
-    H = qutip.num(size)
-    times = np.linspace(0, 1, 11)
-    state = qutip.basis(size, 2)
-
-    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
-    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
-    assert all(len(collapses) <= 1 for collapses in mc.col_which)
+import pytest
+import numpy as np
+import qutip
+from copy import copy
+from qutip.solver.mcsolve import mcsolve, MCSolver
+from qutip.solver.solver_base import Solver
+
+def _return_constant(t, args):
+    return args['constant']
+
+
+def _return_decay(t, args):
+    return args['constant'] * np.exp(-args['rate'] * t)
+
+
+class callable_qobj:
+    def __init__(self, oper, coeff=None):
+        self.oper = oper
+        self.coeff = coeff
+
+    def __call__(self, t, args):
+        if self.coeff is not None:
+            return self.oper * self.coeff(t, args)
+        return self.oper
+
+
+@pytest.mark.usefixtures("in_temporary_directory")
+class StatesAndExpectOutputCase:
+    """
+    Mixin class to test the states and expectation values from ``mcsolve``.
+    """
+    size = 10
+    h = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1, 101)
+    e_ops = [qutip.num(size)]
+    ntraj = 2000
+
+    def _assert_states(self, result, expected, tol):
+        assert hasattr(result, 'states')
+        assert len(result.states) == len(self.times)
+        assert len(self.e_ops) == len(expected)
+        for test_operator, expected_part in zip(self.e_ops, expected):
+            test = qutip.expect(test_operator, result.states)
+            np.testing.assert_allclose(test, expected_part, rtol=tol)
+
+    def _assert_expect(self, result, expected, tol):
+        assert hasattr(result, 'expect')
+        assert len(result.expect) == len(self.e_ops)
+        assert len(self.e_ops) == len(expected)
+        for test, expected_part in zip(result.expect, expected):
+            np.testing.assert_allclose(test, expected_part, rtol=tol)
+
+    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
+        options = {"store_states": True, "map": "serial"}
+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+                         options=options, target_tol=0.05)
+        self._assert_expect(result, expected, tol)
+        self._assert_states(result, expected, tol)
+
+
+class TestNoCollapse(StatesAndExpectOutputCase):
+    """
+    Test that `mcsolve` correctly solves the system when there is a constant
+    Hamiltonian and no collapses.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 1e-8
+        expect = (qutip.expect(self.e_ops[0], self.state)
+                  * np.ones_like(self.times))
+        hamiltonian_types = [
+            (self.h, "Qobj"),
+            ([self.h], "list"),
+            (qutip.QobjEvo([self.h, [self.h, _return_constant]],
+                           args= {'constant': 0}), "QobjEvo"),
+            (callable_qobj(self.h), "callable"),
+        ]
+        cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
+                 for hamiltonian, id in hamiltonian_types]
+        metafunc.parametrize(
+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+            cases)
+
+    # Previously the "states_only" and "expect_only" tests were mixed in to
+    # every other test case.  We move them out into the simplest set so that
+    # their behaviour remains tested, but isn't repeated as often to keep test
+    # runtimes shorter.  The known-good cases are still tested in the other
+    # test cases, this is just testing the single-output behaviour.
+
+    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
+        options = {"store_states": True, "map": "serial"}
+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
+                         options=options)
+        self._assert_states(result, expected, tol)
+
+    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
+        result = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+                         options={'map': 'serial'})
+        self._assert_expect(result, expected, tol)
+
+
+class TestConstantCollapse(StatesAndExpectOutputCase):
+    """
+    Test that `mcsolve` correctly solves the system when there is a constant
+    collapse operator.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 0.25
+        coupling = 0.2
+        expect = (qutip.expect(self.e_ops[0], self.state)
+                  * np.exp(-coupling * self.times))
+        collapse_op = qutip.destroy(self.size)
+        c_op_types = [
+            (np.sqrt(coupling)*collapse_op, {}, "constant"),
+            ([collapse_op, 'sqrt({})'.format(coupling)], {}, "string"),
+            (callable_qobj(collapse_op, _return_constant),
+             {'constant': np.sqrt(coupling)}, "function"),
+        ]
+        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
+                 for c_op, args, id in c_op_types]
+        metafunc.parametrize(
+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+            cases)
+
+
+class TestTimeDependentCollapse(StatesAndExpectOutputCase):
+    """
+    Test that `mcsolve` correctly solves the system when the collapse operators
+    are time-dependent.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 0.25
+        coupling = 0.2
+        expect = (qutip.expect(self.e_ops[0], self.state)
+                  * np.exp(-coupling * (1 - np.exp(-self.times))))
+        collapse_op = qutip.destroy(self.size)
+        collapse_args = {'constant': np.sqrt(coupling), 'rate': 0.5}
+        collapse_string = 'sqrt({} * exp(-t))'.format(coupling)
+        c_op_types = [
+            ([collapse_op, _return_decay], collapse_args, "function"),
+            ([collapse_op, collapse_string], {}, "string"),
+        ]
+        cases = [pytest.param(self.h, args, [c_op], [expect], tol, id=id)
+                 for c_op, args, id in c_op_types]
+        metafunc.parametrize(
+            ['hamiltonian', 'args', 'c_ops', 'expected', 'tol'],
+            cases)
+
+
+def test_stored_collapse_operators_and_times():
+    """
+    Test that the output contains information on which collapses happened and
+    at what times, and make sure that this information makes sense.
+    """
+    size = 10
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 10, 100)
+    c_ops = [a, a]
+    result = mcsolve(H, state, times, c_ops, ntraj=3,
+                     options={'map': 'serial'})
+    assert len(result.col_times[0]) > 0
+    assert len(result.col_which) == len(result.col_times)
+    assert all(col in [0, 1] for col in result.col_which[0])
+
+
+@pytest.mark.parametrize('keep_runs_results', [True, False])
+def test_states_outputs(keep_runs_results):
+    # We're just testing the output value, so it's important whether certain
+    # things are complex or real, but not what the magnitudes of constants are.
+    focks = 5
+    ntraj = 5
+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+    H = 1j*a.dag()*sm + a
+    H = H + H.dag()
+    state = qutip.basis([focks, 2], [0, 1])
+    times = np.linspace(0, 10, 21)
+    c_ops = [a, sm]
+    data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
+                   options={"keep_runs_results": keep_runs_results,
+                            'map': 'serial'})
+
+    assert len(data.average_states) == len(times)
+    assert isinstance(data.average_states[0], qutip.Qobj)
+    assert data.average_states[0].norm() == pytest.approx(1.)
+    assert data.average_states[0].isoper
+
+    assert isinstance(data.average_final_state, qutip.Qobj)
+    assert data.average_final_state.norm() == pytest.approx(1.)
+    assert data.average_final_state.isoper
+
+    assert isinstance(data.photocurrent[0][1], float)
+    assert isinstance(data.photocurrent[1][1], float)
+    assert (np.array(data.runs_photocurrent).shape
+        == (ntraj, len(c_ops), len(times)-1))
+
+    if keep_runs_results:
+        assert len(data.runs_states) == ntraj
+        assert len(data.runs_states[0]) == len(times)
+        assert isinstance(data.runs_states[0][0], qutip.Qobj)
+        assert data.runs_states[0][0].norm() == pytest.approx(1.)
+        assert data.runs_states[0][0].isket
+
+        assert len(data.runs_final_states) == ntraj
+        assert isinstance(data.runs_final_states[0], qutip.Qobj)
+        assert data.runs_final_states[0].norm() == pytest.approx(1.)
+        assert data.runs_final_states[0].isket
+
+    assert isinstance(data.steady_state(), qutip.Qobj)
+    assert data.steady_state().norm() == pytest.approx(1.)
+    assert data.steady_state().isoper
+
+    np.testing.assert_allclose(times, data.times)
+    assert data.num_trajectories == ntraj
+    assert len(data.e_ops) == 0
+    assert data.stats["num_collapse"] == len(c_ops)
+    assert len(data.col_times) == ntraj
+    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
+    assert data.stats['end_condition'] == "ntraj reached"
+
+
+@pytest.mark.parametrize('keep_runs_results', [True, False])
+def test_expectation_outputs(keep_runs_results):
+    # We're just testing the output value, so it's important whether certain
+    # things are complex or real, but not what the magnitudes of constants are.
+    focks = 5
+    ntraj = 5
+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+    H = 1j*a.dag()*sm + a
+    H = H + H.dag()
+    state = qutip.basis([focks, 2], [0, 1])
+    times = np.linspace(0, 10, 5)
+    c_ops = [a, sm]
+    e_ops = [a.dag()*a, sm.dag()*sm, a]
+    data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+                   options={"keep_runs_results": keep_runs_results,
+                            'map': 'serial'})
+    assert isinstance(data.average_expect[0][1], float)
+    assert isinstance(data.average_expect[1][1], float)
+    assert isinstance(data.average_expect[2][1], complex)
+    assert isinstance(data.std_expect[0][1], float)
+    assert isinstance(data.std_expect[1][1], float)
+    assert isinstance(data.std_expect[2][1], float)
+    if keep_runs_results:
+        assert len(data.runs_expect) == len(e_ops)
+        assert len(data.runs_expect[0]) == ntraj
+        assert isinstance(data.runs_expect[0][0][1], float)
+        assert isinstance(data.runs_expect[1][0][1], float)
+        assert isinstance(data.runs_expect[2][0][1], complex)
+    assert isinstance(data.photocurrent[0][0], float)
+    assert isinstance(data.photocurrent[1][0], float)
+    assert (np.array(data.runs_photocurrent).shape
+            == (ntraj, len(c_ops), len(times)-1))
+    np.testing.assert_allclose(times, data.times)
+    assert data.num_trajectories == ntraj
+    assert len(data.e_ops) == len(e_ops)
+    assert data.stats["num_collapse"] == len(c_ops)
+    assert len(data.col_times) == ntraj
+    assert np.max(np.hstack(data.col_which)) <= len(c_ops)
+    assert data.stats['end_condition'] == "ntraj reached"
+
+
+class TestSeeds:
+    sizes = [6, 6, 6]
+    dampings = [0.1, 0.4, 0.1]
+    ntraj = 25  # Big enough to ensure there are differences without being slow
+    a = [qutip.destroy(size) for size in sizes]
+    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
+              - qutip.tensor(a[0].dag(), a[1], a[2]))
+    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
+                         qutip.basis(sizes[1:], [0, 0]))
+    times = np.linspace(0, 10, 2)
+    c_ops = [
+        np.sqrt(2*dampings[0]) * qutip.tensor(a[0], qutip.qeye(sizes[1:])),
+        (np.sqrt(2*dampings[1])
+         * qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2]))),
+        np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
+    ]
+
+    def test_seeds_can_be_reused(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, **kwargs)
+        second = mcsolve(*args, seeds=first.seeds, **kwargs)
+        for first_t, second_t in zip(first.col_times, second.col_times):
+            np.testing.assert_equal(first_t, second_t)
+        for first_w, second_w in zip(first.col_which, second.col_which):
+            np.testing.assert_equal(first_w, second_w)
+
+    def test_seeds_are_not_reused_by_default(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, **kwargs)
+        second = mcsolve(*args, **kwargs)
+        assert not all(np.array_equal(first_t, second_t)
+                       for first_t, second_t in zip(first.col_times,
+                                                    second.col_times))
+        assert not all(np.array_equal(first_w, second_w)
+                       for first_w, second_w in zip(first.col_which,
+                                                    second.col_which))
+
+    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
+    def test_seed_type(self, seed):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, seeds=copy(seed), **kwargs)
+        second = mcsolve(*args, seeds=copy(seed), **kwargs)
+        for f_seed, s_seed in zip(first.seeds, second.seeds):
+            assert f_seed.state == s_seed.state
+
+    def test_bad_seed(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        with pytest.raises(ValueError):
+            first = mcsolve(*args, seeds=[1], **kwargs)
+
+    def test_generator(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
+                        **kwargs)
+        second = mcsolve(*args, seeds=1, **kwargs)
+        for f_seed, s_seed in zip(first.seeds, second.seeds):
+            assert f_seed.state == s_seed.state
+        assert not all(np.array_equal(first_t, second_t)
+                       for first_t, second_t in zip(first.col_times,
+                                                    second.col_times))
+        assert not all(np.array_equal(first_w, second_w)
+                       for first_w, second_w in zip(first.col_which,
+                                                    second.col_which))
+
+    def test_stepping(self):
+        size = 10
+        a = qutip.QobjEvo([qutip.destroy(size), 'alpha'], args={'alpha': 0})
+        H = qutip.num(size)
+        mcsolver = MCSolver(H, a, options={'map': 'serial'})
+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+        state_1 = mcsolver.step(1, args={'alpha':1})
+
+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+        state_2 = mcsolver.step(1, args={'alpha':1})
+        assert state_1 == state_2
+
+
+def test_timeout():
+    size = 10
+    ntraj = 1000
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1.0, 100)
+    coupling = 0.5
+    n_th = 0.05
+    c_ops = np.sqrt(coupling * (n_th + 1)) * a
+    e_ops = [qutip.num(size)]
+    res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+                  options={'map': 'serial'}, timeout=1e-6)
+    assert res.stats['end_condition'] == 'timeout'
+
+
+def test_super_H():
+    size = 10
+    ntraj = 1000
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1.0, 100)
+    # Arbitrary coupling and bath temperature.
+    coupling = 0.5
+    n_th = 0.05
+    c_ops = np.sqrt(coupling * (n_th + 1)) * a
+    e_ops = [qutip.num(size)]
+    mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
+                          target_tol=0.1, options={'map': 'serial'})
+    mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
+                 target_tol=0.1, options={'map': 'serial'})
+    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
+
+
+def test_MCSolver_run():
+    size = 10
+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+    H = qutip.num(size)
+    solver = MCSolver(H, a)
+    solver.options = {'store_final_state': True}
+    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
+    assert res.final_state is not None
+    assert len(res.collapse[0]) != 0
+    assert res.num_trajectories == 1
+    np.testing.assert_allclose(res.expect[0], np.ones(11))
+    res += solver.run(
+        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+        e_ops=[qutip.qeye(size)], args={'coupling': 1},
+        ntraj=1000, target_tol=0.1
+    )
+    assert res.num_trajectories == 1001
+
+
+def test_MCSolver_stepping():
+    size = 10
+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+    H = qutip.num(size)
+    solver = MCSolver(H, a)
+    solver.start(qutip.basis(size, size-1), 0, seed=0)
+    solver.options = {'method': 'lsoda'}
+    state = solver.step(1)
+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
+    assert state.isket
+    state = solver.step(5, args={'coupling': 5})
+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+    assert qutip.expect(qutip.num(size), state) <= size - 1
+    assert state.isket
+
+
+# Defined in module-scope so it's pickleable.
+def _dynamic(t, args):
+    return 0 if args["collapse"] else 1
+
+
+@pytest.mark.xfail(reason="current limitation of McSolve")
+def test_dynamic_arguments():
+    """Test dynamically updated arguments are usable."""
+    size = 5
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    times = np.linspace(0, 1, 11)
+    state = qutip.basis(size, 2)
+
+    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
+    mc = mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
+    assert all(len(collapses) <= 1 for collapses in mc.col_which)
diff --git a/qutip/tests/solver/test_mesolve.py b/qutip/tests/solver/test_mesolve.py
index deb1247964..6f6bbab6c7 100644
--- a/qutip/tests/solver/test_mesolve.py
+++ b/qutip/tests/solver/test_mesolve.py
@@ -1,677 +1,677 @@
-import numpy as np
-from types import FunctionType
-
-import qutip
-from qutip.solver.mesolve import mesolve, MESolver
-from qutip.solver.solver_base import Solver
-import pickle
-import pytest
-
-all_ode_method = [
-    method for method, integrator in MESolver.avail_integrators().items()
-    if integrator.support_time_dependant
-]
-
-def fidelitycheck(out1, out2, rho0vec):
-    fid = np.zeros(len(out1.states))
-    for i, E in enumerate(out2.states):
-        rhot = qutip.vector_to_operator(E*rho0vec)
-        fid[i] = qutip.fidelity(out1.states[i], rhot)
-    return fid
-
-
-class TestMESolveDecay:
-    N = 10
-    a = qutip.destroy(N)
-    kappa = 0.2
-    tlist = np.linspace(0, 10, 201)
-    ada = a.dag() * a
-
-    @pytest.fixture(params=[
-        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
-        pytest.param([ada, '1'], id='Hlist_str'),
-        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
-        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
-        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
-                     id='func'),
-    ])
-    def H(self, request):
-        return request.param
-
-    @pytest.fixture(params=[
-        pytest.param(np.sqrt(kappa) * a,
-                     id='const'),
-        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
-                                      * qutip.destroy(10)),
-                     id='func'),
-        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
-                     id='list_func'),
-        pytest.param([a, 'sqrt(kappa)'],
-                     id='list_str'),
-        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
-                     id='list_array'),
-        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
-                     id='QobjEvo'),
-    ])
-    def cte_c_ops(self, request):
-        return request.param
-
-    @pytest.fixture(params=[
-        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
-                  id='list_func'),
-        pytest.param([a, 'sqrt(kappa * exp(-t))'],
-                  id='list_str'),
-        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
-                  id='list_array'),
-        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
-                          args={'kappa': kappa}),
-                  id='QobjEvo'),
-        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
-                                      qutip.destroy(10)),
-                     id='func'),
-    ])
-    def c_ops(self, request):
-        return request.param
-
-    c_ops_1 = c_ops
-
-    def testME_CteDecay(self, cte_c_ops):
-        "mesolve: simple constant decay"
-        me_error = 1e-6
-        H = self.a.dag() * self.a
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [cte_c_ops]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    @pytest.mark.parametrize('method',
-                             all_ode_method, ids=all_ode_method)
-    def testME_TDDecay(self, c_ops, method):
-        "mesolve: time-dependence as function list"
-        me_error = 1e-5
-        H = self.a.dag() * self.a
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [c_ops]
-        options = {"method": method, "progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-                         args={"kappa": self.kappa}, options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
-
-    def testME_2TDDecay(self, c_ops, c_ops_1):
-        "mesolve: time-dependence as function list"
-        me_error = 1e-5
-        H = self.a.dag() * self.a
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [c_ops, c_ops_1]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-2 * self.kappa *
-                                     (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    def testME_TDH_TDDecay(self, H, c_ops):
-        "mesolve: time-dependence as function list"
-        me_error = 5e-6
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        c_op_list = [c_ops]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-self.kappa *
-                                     (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    def testME_TDH_longTDDecay(self, H, c_ops):
-        "mesolve: time-dependence as function list"
-        me_error = 2e-5
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        if isinstance(c_ops, FunctionType):
-            return
-        if isinstance(c_ops, qutip.QobjEvo):
-            c_op_list = [c_ops + c_ops]
-        else:
-            c_op_list = [[c_ops, c_ops]]
-        options = {"progress_bar": None}
-        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
-                         args={"kappa": self.kappa},
-                         options=options)
-        expt = medata.expect[0]
-        actual_answer = 9.0 * np.exp(-4 * self.kappa *
-                                     (1.0 - np.exp(-self.tlist)))
-        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
-
-    def testME_TDDecayUnitary(self, c_ops):
-        "mesolve: time-dependence as function list with super as init cond"
-        me_error = 5e-6
-
-        H = self.ada
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
-        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
-        options = {"progress_bar": None}
-        c_op_list = [c_ops]
-        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-
-        fid = fidelitycheck(out1, out2, rho0vec)
-        assert fid == pytest.approx(1., abs=me_error)
-
-    def testME_TDDecayliouvillian(self, c_ops):
-        "mesolve: time-dependence as function list with super as init cond"
-        me_error = 5e-6
-
-        H = self.ada
-        L = qutip.liouvillian(H)
-        psi0 = qutip.basis(self.N, 9)  # initial state
-        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
-        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
-        options = {"progress_bar": None}
-        c_op_list = [c_ops]
-        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
-                       args={"kappa": self.kappa},
-                       options=options)
-
-        fid = fidelitycheck(out1, out2, rho0vec)
-        assert fid == pytest.approx(1., abs=me_error)
-
-    @pytest.mark.parametrize(['state_type'], [
-        pytest.param("ket", id="ket"),
-        pytest.param("dm", id="dm"),
-        pytest.param("unitary", id="unitary"),
-    ])
-    def test_mesolve_normalization(self, state_type):
-        # non-hermitean H causes state to evolve non-unitarily
-        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
-        H = qutip.sprepost(H, H) # ensure use of MeSolve
-        psi0 = qutip.basis(2, 0)
-        options = {"normalize_output": True, "progress_bar": None}
-
-        if state_type in {"ket", "dm"}:
-            if state_type == "dm":
-                psi0 = qutip.ket2dm(psi0)
-            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            np.testing.assert_allclose(
-                norms, [1.0 for _ in self.tlist], atol=1e-15,
-            )
-        else:
-            # evolution of unitaries should not be normalized
-            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
-            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            assert all(norm > 4 for norm in norms[1:])
-
-    def test_mesolver_pickling(self):
-        options = {"progress_bar": None}
-        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
-        solver_copy = pickle.loads(pickle.dumps(solver_obj))
-        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
-                            e_ops=[self.ada]).expect[0]
-        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
-                            e_ops=[self.ada]).expect[0]
-        np.testing.assert_allclose(e1, e2)
-
-    @pytest.mark.parametrize('method',
-                             all_ode_method, ids=all_ode_method)
-    def test_mesolver_stepping(self, method):
-        options = {"method": method, "progress_bar": None}
-        solver_obj = MESolver(
-            self.ada,
-            c_ops=qutip.QobjEvo(
-                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
-                args={'kappa': 1.}
-            ),
-            options=options
-        )
-        solver_obj.start(qutip.basis(self.N, 9), 0)
-        state1 = solver_obj.step(1)
-        assert qutip.expect(self.ada, state1) != (
-            qutip.expect(self.ada, qutip.basis(self.N, 9))
-        )
-        state2 = solver_obj.step(2, args={"kappa":0.})
-        np.testing.assert_allclose(qutip.expect(self.ada, state1),
-                                   qutip.expect(self.ada, state2), 1e-6)
-
-
-@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
-                         ids=["ket", "dm", "liouvillian"])
-def testME_SesolveFallback(super_):
-    "mesolve: final_state has correct dims"
-    N = 5
-    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
-    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
-    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
-    psi0 = qutip.tensor(qutip.basis(N+1,0),
-                        qutip.basis(N+1,0),
-                        qutip.basis(N+1,N))
-    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
-    if super_ == "dm":
-        state0 = qutip.ket2dm(psi0)
-    else:
-        state0 = psi0
-    if super_ == "liouvillian":
-        H = qutip.liouvillian(H)
-
-    times = np.linspace(0.0, 0.1, 3)
-    options = {
-        "store_states": False,
-        "store_final_state": True,
-        "progress_bar": None
-    }
-    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
-    if super_ == "ket":
-        assert result.final_state.dims == psi0.dims
-    else:
-        assert result.final_state.dims == qutip.ket2dm(psi0).dims
-
-
-class TestJCModelEvolution:
-    """
-    A test class for the QuTiP functions for the evolution of JC model
-    """
-    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
-
-        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
-
-        c_op_list = []
-
-        rate = g1
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
-
-        rate = g2
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
-
-        output = mesolve(H, psi0, tlist, c_op_list,
-            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-        )
-
-        return output.expect[0], output.expect[1], output.expect[2]
-
-    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
-                       pump, psi0, use_rwa, tlist):
-
-        # Hamiltonian
-        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
-        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
-
-        if use_rwa:
-            # use the rotating wave approxiation
-            H = (wc * a.dag() * a + wa * sm.dag() * sm
-                 + g * (a.dag() * sm + a * sm.dag()))
-        else:
-            H = (wc * a.dag() * a + wa * sm.dag() * sm
-                 + g * (a.dag() + a) * (sm + sm.dag()))
-
-        # collapse operators
-        c_op_list = []
-
-        n_th_a = 0.0  # zero temperature
-
-        rate = kappa * (1 + n_th_a)
-        c_op_list.append(np.sqrt(rate) * a)
-
-        rate = kappa * n_th_a
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * a.dag())
-
-        rate = gamma
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm)
-
-        rate = pump
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm.dag())
-
-        # find the steady state
-        rho_ss = qutip.steadystate(H, c_op_list)
-
-        return (qutip.expect(a.dag() * a, rho_ss),
-                qutip.expect(sm.dag() * sm, rho_ss))
-
-    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
-                     pump, psi0, use_rwa, tlist, oper_evo=False):
-
-        # Hamiltonian
-        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
-        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
-
-        # Identity super-operator
-        E0 = qutip.sprepost(
-            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
-            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
-        )
-
-        if use_rwa:
-            # use the rotating wave approxiation
-            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
-                a.dag() * sm + a * sm.dag())
-        else:
-            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
-                a.dag() + a) * (sm + sm.dag())
-
-        # collapse operators
-        c_op_list = []
-
-        n_th_a = 0.0  # zero temperature
-
-        rate = kappa * (1 + n_th_a)
-        c_op_list.append(np.sqrt(rate) * a)
-
-        rate = kappa * n_th_a
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * a.dag())
-
-        rate = gamma
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm)
-
-        rate = pump
-        if rate > 0.0:
-            c_op_list.append(np.sqrt(rate) * sm.dag())
-
-        options = {"store_states": True, "progress_bar": None}
-
-        # evolve and calculate expectation values
-        output = mesolve(
-            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
-            options=options)
-        if oper_evo:
-            output2 = mesolve(H, E0, tlist, c_op_list, [])
-            return output, output2
-        return output.expect[0], output.expect[1]
-
-    def testSuperJC(self):
-        "mesolve: super vs. density matrix as initial condition"
-        me_error = 1e-6
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.1   # coupling strength
-        kappa = 0.05    # cavity dissipation rate
-        gamma = 0.001   # atom dissipation rate
-        pump = 0.25    # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.basis([N, 2], [n, 1])
-        rho0vec = qutip.operator_to_vector(psi0.proj())
-        tlist = np.linspace(0, 100, 50)
-
-        out1, out2 = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
-
-        fid = fidelitycheck(out1, out2, rho0vec)
-        assert fid == pytest.approx(1., abs=me_error)
-
-    def testQubitDynamics1(self):
-        "mesolve: qubit with dissipation"
-
-        epsilon = 0.0 * 2 * np.pi   # cavity frequency
-        delta = 1.0 * 2 * np.pi   # atom frequency
-        g2 = 0.1
-        g1 = 0.0
-        psi0 = qutip.basis(2, 0)        # initial state
-        tlist = np.linspace(0, 5, 200)
-
-        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
-
-        sx_analytic = np.zeros(np.shape(tlist))
-        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
-        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
-        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
-
-    def testQubitDynamics2(self):
-        "mesolve: qubit without dissipation"
-
-        epsilon = 0.0 * 2 * np.pi   # cavity frequency
-        delta = 1.0 * 2 * np.pi   # atom frequency
-        g2 = 0.0
-        g1 = 0.0
-        psi0 = qutip.basis(2, 0)        # initial state
-        tlist = np.linspace(0, 5, 200)
-
-        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
-
-        sx_analytic = np.zeros(np.shape(tlist))
-        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
-        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
-        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
-        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
-
-    def testCavity1(self):
-        "mesolve: cavity-qubit interaction, no dissipation"
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.01   # coupling strength
-        kappa = 0.0     # cavity dissipation rate
-        gamma = 0.0     # atom dissipation rate
-        pump = 0.0      # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-        tlist = np.linspace(0, 1000, 2000)
-
-        nc, na = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
-        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
-
-        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
-        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
-
-    def testCavity2(self):
-        "mesolve: cavity-qubit without interaction, decay"
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.0    # coupling strength
-        kappa = 0.005   # cavity dissipation rate
-        gamma = 0.01    # atom dissipation rate
-        pump = 0.0      # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-        tlist = np.linspace(0, 1000, 2000)
-
-        nc, na = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
-            np.exp(-kappa * tlist)
-        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
-            np.exp(-gamma * tlist)
-
-        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
-        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
-
-    def testCavity3(self):
-        "mesolve: cavity-qubit with interaction, decay"
-
-        use_rwa = True
-        N = 4           # number of cavity fock states
-        wc = 2 * np.pi * 1.0   # cavity frequency
-        wa = 2 * np.pi * 1.0   # atom frequency
-        g = 2 * np.pi * 0.1   # coupling strength
-        kappa = 0.05    # cavity dissipation rate
-        gamma = 0.001   # atom dissipation rate
-        pump = 0.25    # atom pump rate
-
-        # start with an excited atom and maximum number of photons
-        n = N - 2
-        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
-        tlist = np.linspace(0, 200, 500)
-
-        nc, na = self.jc_integrate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        # we don't have any analytics for this parameters, so
-        # compare with the steady state
-        nc_ss, na_ss = self.jc_steadystate(
-            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
-
-        nc_ss = nc_ss * np.ones(np.shape(nc))
-        na_ss = na_ss * np.ones(np.shape(na))
-
-        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
-        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
-
-
-class TestMESolveStepFuncCoeff:
-    """
-    A Test class for using time-dependent array coefficients
-    as step functions instead of doing interpolation
-    """
-    # Runge-Kutta method (dop853) behave better with step function evolution
-    # than multi-step methods (adams, qutip 4's default)
-    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
-
-    def python_coeff(self, t, args):
-        if t < np.pi/2:
-            return 1.
-        else:
-            return 0.
-
-    @pytest.mark.parametrize('method',
-                             all_ode_method, ids=all_ode_method)
-    def test_py_coeff(self, method):
-        """
-        Test for Python function as coefficient as step function coeff
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0, np.pi/2])
-        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
-        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
-                     tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_cte_coeff(self):
-        """
-        Test for Array coefficient with uniform tlist as step function coeff
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
-        npcoeff = np.array([0.25, 0.75, 0.75])
-        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_t_coeff(self):
-        """
-        Test for Array with non-uniform tlist as step function coeff
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
-        npcoeff = np.array([0.5, 0.25, 0.25])
-        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_str_coeff(self):
-        """
-        Test for Array and string as step function coeff.
-        qobjevo_codegen is used and uniform tlist
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
-        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
-        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
-        strcoeff = "1."
-        qu = qutip.QobjEvo(
-            [[qutip.sigmax(), npcoeff1],
-             [qutip.sigmax(), strcoeff],
-             [qutip.sigmax(), npcoeff2]],
-            tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-    def test_array_str_py_coeff(self):
-        """
-        Test for Array, string and Python function as step function coeff.
-        qobjevo_codegen is used and non non-uniform tlist
-        """
-        rho0 = qutip.rand_ket(2)
-        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
-        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
-        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
-        strcoeff = "1."
-        qu = qutip.QobjEvo(
-            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
-             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
-            tlist=tlist, order=0)
-        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
-        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
-        assert fid == pytest.approx(1)
-
-
-def test_num_collapse_set():
-    H = qutip.sigmaz()
-    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
-    ts = [0, 1]
-    for c_ops in (
-        qutip.sigmax(),
-        [qutip.sigmax()],
-        [qutip.sigmay(), qutip.sigmax()],
-    ):
-        res = mesolve(H, psi, ts, c_ops=c_ops)
-        if not isinstance(c_ops, list):
-            c_ops = [c_ops]
-        assert res.stats["num_collapse"] == len(c_ops)
-
-
-def test_mesolve_bad_H():
-    with pytest.raises(TypeError):
-        MESolver([qutip.qeye(3), 't'], [])
-    with pytest.raises(TypeError):
-        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
-
-
-def test_mesolve_bad_state():
-    solver = MESolver(qutip.qeye(4), [])
-    with pytest.raises(TypeError):
-        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
-
-
-def test_mesolve_bad_options():
-    with pytest.raises(TypeError):
-        MESolver(qutip.qeye(4), [], options=False)
+import numpy as np
+from types import FunctionType
+
+import qutip
+from qutip.solver.mesolve import mesolve, MESolver
+from qutip.solver.solver_base import Solver
+import pickle
+import pytest
+
+all_ode_method = [
+    method for method, integrator in MESolver.avail_integrators().items()
+    if integrator.support_time_dependant
+]
+
+def fidelitycheck(out1, out2, rho0vec):
+    fid = np.zeros(len(out1.states))
+    for i, E in enumerate(out2.states):
+        rhot = qutip.vector_to_operator(E*rho0vec)
+        fid[i] = qutip.fidelity(out1.states[i], rhot)
+    return fid
+
+
+class TestMESolveDecay:
+    N = 10
+    a = qutip.destroy(N)
+    kappa = 0.2
+    tlist = np.linspace(0, 10, 201)
+    ada = a.dag() * a
+
+    @pytest.fixture(params=[
+        pytest.param([ada, lambda t, args: 1], id='Hlist_func'),
+        pytest.param([ada, '1'], id='Hlist_str'),
+        pytest.param([ada, np.ones_like(tlist)], id='Hlist_array'),
+        pytest.param(qutip.QobjEvo([ada, '1']), id='HQobjEvo'),
+        pytest.param(lambda t, args: qutip.create(10) * qutip.destroy(10),
+                     id='func'),
+    ])
+    def H(self, request):
+        return request.param
+
+    @pytest.fixture(params=[
+        pytest.param(np.sqrt(kappa) * a,
+                     id='const'),
+        pytest.param(lambda t, args: (np.sqrt(args['kappa'])
+                                      * qutip.destroy(10)),
+                     id='func'),
+        pytest.param([a, lambda t, args: np.sqrt(args['kappa'])],
+                     id='list_func'),
+        pytest.param([a, 'sqrt(kappa)'],
+                     id='list_str'),
+        pytest.param([a, np.sqrt(kappa) * np.ones_like(tlist)],
+                     id='list_array'),
+        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa)'], args={'kappa': kappa}),
+                     id='QobjEvo'),
+    ])
+    def cte_c_ops(self, request):
+        return request.param
+
+    @pytest.fixture(params=[
+        pytest.param([a, lambda t, args: np.sqrt(args['kappa'] * np.exp(-t))],
+                  id='list_func'),
+        pytest.param([a, 'sqrt(kappa * exp(-t))'],
+                  id='list_str'),
+        pytest.param([a, np.sqrt(kappa * np.exp(-tlist))],
+                  id='list_array'),
+        pytest.param(qutip.QobjEvo([a, 'sqrt(kappa * exp(-t))'],
+                          args={'kappa': kappa}),
+                  id='QobjEvo'),
+        pytest.param(lambda t, args: (np.sqrt(args['kappa'] * np.exp(-t)) *
+                                      qutip.destroy(10)),
+                     id='func'),
+    ])
+    def c_ops(self, request):
+        return request.param
+
+    c_ops_1 = c_ops
+
+    def testME_CteDecay(self, cte_c_ops):
+        "mesolve: simple constant decay"
+        me_error = 1e-6
+        H = self.a.dag() * self.a
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [cte_c_ops]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-self.kappa * self.tlist)
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    @pytest.mark.parametrize('method',
+                             all_ode_method, ids=all_ode_method)
+    def testME_TDDecay(self, c_ops, method):
+        "mesolve: time-dependence as function list"
+        me_error = 1e-5
+        H = self.a.dag() * self.a
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [c_ops]
+        options = {"method": method, "progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+                         args={"kappa": self.kappa}, options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-self.kappa * (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, rtol=me_error)
+
+    def testME_2TDDecay(self, c_ops, c_ops_1):
+        "mesolve: time-dependence as function list"
+        me_error = 1e-5
+        H = self.a.dag() * self.a
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [c_ops, c_ops_1]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [H],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-2 * self.kappa *
+                                     (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    def testME_TDH_TDDecay(self, H, c_ops):
+        "mesolve: time-dependence as function list"
+        me_error = 5e-6
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        c_op_list = [c_ops]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-self.kappa *
+                                     (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    def testME_TDH_longTDDecay(self, H, c_ops):
+        "mesolve: time-dependence as function list"
+        me_error = 2e-5
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        if isinstance(c_ops, FunctionType):
+            return
+        if isinstance(c_ops, qutip.QobjEvo):
+            c_op_list = [c_ops + c_ops]
+        else:
+            c_op_list = [[c_ops, c_ops]]
+        options = {"progress_bar": None}
+        medata = mesolve(H, psi0, self.tlist, c_op_list, [self.ada],
+                         args={"kappa": self.kappa},
+                         options=options)
+        expt = medata.expect[0]
+        actual_answer = 9.0 * np.exp(-4 * self.kappa *
+                                     (1.0 - np.exp(-self.tlist)))
+        np.testing.assert_allclose(actual_answer, expt, atol=me_error)
+
+    def testME_TDDecayUnitary(self, c_ops):
+        "mesolve: time-dependence as function list with super as init cond"
+        me_error = 5e-6
+
+        H = self.ada
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
+        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
+        options = {"progress_bar": None}
+        c_op_list = [c_ops]
+        out1 = mesolve(H, psi0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+        out2 = mesolve(H, E0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+
+        fid = fidelitycheck(out1, out2, rho0vec)
+        assert fid == pytest.approx(1., abs=me_error)
+
+    def testME_TDDecayliouvillian(self, c_ops):
+        "mesolve: time-dependence as function list with super as init cond"
+        me_error = 5e-6
+
+        H = self.ada
+        L = qutip.liouvillian(H)
+        psi0 = qutip.basis(self.N, 9)  # initial state
+        rho0vec = qutip.operator_to_vector(psi0*psi0.dag())
+        E0 = qutip.sprepost(qutip.qeye(self.N), qutip.qeye(self.N))
+        options = {"progress_bar": None}
+        c_op_list = [c_ops]
+        out1 = mesolve(L, psi0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+        out2 = mesolve(L, E0, self.tlist, c_op_list, [],
+                       args={"kappa": self.kappa},
+                       options=options)
+
+        fid = fidelitycheck(out1, out2, rho0vec)
+        assert fid == pytest.approx(1., abs=me_error)
+
+    @pytest.mark.parametrize(['state_type'], [
+        pytest.param("ket", id="ket"),
+        pytest.param("dm", id="dm"),
+        pytest.param("unitary", id="unitary"),
+    ])
+    def test_mesolve_normalization(self, state_type):
+        # non-hermitean H causes state to evolve non-unitarily
+        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
+        H = qutip.sprepost(H, H) # ensure use of MeSolve
+        psi0 = qutip.basis(2, 0)
+        options = {"normalize_output": True, "progress_bar": None}
+
+        if state_type in {"ket", "dm"}:
+            if state_type == "dm":
+                psi0 = qutip.ket2dm(psi0)
+            output = mesolve(H, psi0, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            np.testing.assert_allclose(
+                norms, [1.0 for _ in self.tlist], atol=1e-15,
+            )
+        else:
+            # evolution of unitaries should not be normalized
+            U = qutip.sprepost(qutip.qeye(2), qutip.qeye(2))
+            output = mesolve(H, U, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            assert all(norm > 4 for norm in norms[1:])
+
+    def test_mesolver_pickling(self):
+        options = {"progress_bar": None}
+        solver_obj = MESolver(self.ada, c_ops=[self.a], options=options)
+        solver_copy = pickle.loads(pickle.dumps(solver_obj))
+        e1 = solver_obj.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
+                            e_ops=[self.ada]).expect[0]
+        e2 = solver_copy.run(qutip.basis(self.N, 9), [0, 1, 2, 3],
+                            e_ops=[self.ada]).expect[0]
+        np.testing.assert_allclose(e1, e2)
+
+    @pytest.mark.parametrize('method',
+                             all_ode_method, ids=all_ode_method)
+    def test_mesolver_stepping(self, method):
+        options = {"method": method, "progress_bar": None}
+        solver_obj = MESolver(
+            self.ada,
+            c_ops=qutip.QobjEvo(
+                [self.a, lambda t, kappa: np.sqrt(kappa * np.exp(-t))],
+                args={'kappa': 1.}
+            ),
+            options=options
+        )
+        solver_obj.start(qutip.basis(self.N, 9), 0)
+        state1 = solver_obj.step(1)
+        assert qutip.expect(self.ada, state1) != (
+            qutip.expect(self.ada, qutip.basis(self.N, 9))
+        )
+        state2 = solver_obj.step(2, args={"kappa":0.})
+        np.testing.assert_allclose(qutip.expect(self.ada, state1),
+                                   qutip.expect(self.ada, state2), 1e-6)
+
+
+@pytest.mark.parametrize('super_', ["ket", "dm", "liouvillian"],
+                         ids=["ket", "dm", "liouvillian"])
+def testME_SesolveFallback(super_):
+    "mesolve: final_state has correct dims"
+    N = 5
+    a = qutip.tensor(qutip.destroy(N+1), qutip.qeye(N+1), qutip.qeye(N+1))
+    b = qutip.tensor(qutip.qeye(N+1), qutip.destroy(N+1), qutip.qeye(N+1))
+    c = qutip.tensor(qutip.qeye(N+1), qutip.qeye(N+1), qutip.destroy(N+1))
+    psi0 = qutip.tensor(qutip.basis(N+1,0),
+                        qutip.basis(N+1,0),
+                        qutip.basis(N+1,N))
+    H = a * b * c.dag() * c.dag() + a.dag() * b.dag() * c * c
+    if super_ == "dm":
+        state0 = qutip.ket2dm(psi0)
+    else:
+        state0 = psi0
+    if super_ == "liouvillian":
+        H = qutip.liouvillian(H)
+
+    times = np.linspace(0.0, 0.1, 3)
+    options = {
+        "store_states": False,
+        "store_final_state": True,
+        "progress_bar": None
+    }
+    result = mesolve(H, state0, times, [], e_ops=[a], options=options)
+    if super_ == "ket":
+        assert result.final_state.dims == psi0.dims
+    else:
+        assert result.final_state.dims == qutip.ket2dm(psi0).dims
+
+
+class TestJCModelEvolution:
+    """
+    A test class for the QuTiP functions for the evolution of JC model
+    """
+    def qubit_integrate(self, tlist, psi0, epsilon, delta, g1, g2):
+
+        H = epsilon / 2.0 * qutip.sigmaz() + delta / 2.0 * qutip.sigmax()
+
+        c_op_list = []
+
+        rate = g1
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * qutip.sigmam())
+
+        rate = g2
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * qutip.sigmaz())
+
+        output = mesolve(H, psi0, tlist, c_op_list,
+            e_ops=[qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+        )
+
+        return output.expect[0], output.expect[1], output.expect[2]
+
+    def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
+                       pump, psi0, use_rwa, tlist):
+
+        # Hamiltonian
+        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
+        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
+
+        if use_rwa:
+            # use the rotating wave approxiation
+            H = (wc * a.dag() * a + wa * sm.dag() * sm
+                 + g * (a.dag() * sm + a * sm.dag()))
+        else:
+            H = (wc * a.dag() * a + wa * sm.dag() * sm
+                 + g * (a.dag() + a) * (sm + sm.dag()))
+
+        # collapse operators
+        c_op_list = []
+
+        n_th_a = 0.0  # zero temperature
+
+        rate = kappa * (1 + n_th_a)
+        c_op_list.append(np.sqrt(rate) * a)
+
+        rate = kappa * n_th_a
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * a.dag())
+
+        rate = gamma
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm)
+
+        rate = pump
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm.dag())
+
+        # find the steady state
+        rho_ss = qutip.steadystate(H, c_op_list)
+
+        return (qutip.expect(a.dag() * a, rho_ss),
+                qutip.expect(sm.dag() * sm, rho_ss))
+
+    def jc_integrate(self, N, wc, wa, g, kappa, gamma,
+                     pump, psi0, use_rwa, tlist, oper_evo=False):
+
+        # Hamiltonian
+        a = qutip.tensor(qutip.destroy(N), qutip.identity(2))
+        sm = qutip.tensor(qutip.identity(N), qutip.destroy(2))
+
+        # Identity super-operator
+        E0 = qutip.sprepost(
+            qutip.tensor(qutip.qeye(N), qutip.qeye(2)),
+            qutip.tensor(qutip.qeye(N), qutip.qeye(2))
+        )
+
+        if use_rwa:
+            # use the rotating wave approxiation
+            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
+                a.dag() * sm + a * sm.dag())
+        else:
+            H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
+                a.dag() + a) * (sm + sm.dag())
+
+        # collapse operators
+        c_op_list = []
+
+        n_th_a = 0.0  # zero temperature
+
+        rate = kappa * (1 + n_th_a)
+        c_op_list.append(np.sqrt(rate) * a)
+
+        rate = kappa * n_th_a
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * a.dag())
+
+        rate = gamma
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm)
+
+        rate = pump
+        if rate > 0.0:
+            c_op_list.append(np.sqrt(rate) * sm.dag())
+
+        options = {"store_states": True, "progress_bar": None}
+
+        # evolve and calculate expectation values
+        output = mesolve(
+            H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm],
+            options=options)
+        if oper_evo:
+            output2 = mesolve(H, E0, tlist, c_op_list, [])
+            return output, output2
+        return output.expect[0], output.expect[1]
+
+    def testSuperJC(self):
+        "mesolve: super vs. density matrix as initial condition"
+        me_error = 1e-6
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.1   # coupling strength
+        kappa = 0.05    # cavity dissipation rate
+        gamma = 0.001   # atom dissipation rate
+        pump = 0.25    # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.basis([N, 2], [n, 1])
+        rho0vec = qutip.operator_to_vector(psi0.proj())
+        tlist = np.linspace(0, 100, 50)
+
+        out1, out2 = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist, True)
+
+        fid = fidelitycheck(out1, out2, rho0vec)
+        assert fid == pytest.approx(1., abs=me_error)
+
+    def testQubitDynamics1(self):
+        "mesolve: qubit with dissipation"
+
+        epsilon = 0.0 * 2 * np.pi   # cavity frequency
+        delta = 1.0 * 2 * np.pi   # atom frequency
+        g2 = 0.1
+        g1 = 0.0
+        psi0 = qutip.basis(2, 0)        # initial state
+        tlist = np.linspace(0, 5, 200)
+
+        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
+
+        sx_analytic = np.zeros(np.shape(tlist))
+        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
+        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
+        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
+
+    def testQubitDynamics2(self):
+        "mesolve: qubit without dissipation"
+
+        epsilon = 0.0 * 2 * np.pi   # cavity frequency
+        delta = 1.0 * 2 * np.pi   # atom frequency
+        g2 = 0.0
+        g1 = 0.0
+        psi0 = qutip.basis(2, 0)        # initial state
+        tlist = np.linspace(0, 5, 200)
+
+        sx, sy, sz = self.qubit_integrate(tlist, psi0, epsilon, delta, g1, g2)
+
+        sx_analytic = np.zeros(np.shape(tlist))
+        sy_analytic = -np.sin(2 * np.pi * tlist) * np.exp(-tlist * g2)
+        sz_analytic = np.cos(2 * np.pi * tlist) * np.exp(-tlist * g2)
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=0.05)
+        np.testing.assert_allclose(sy, sy_analytic, atol=0.05)
+        np.testing.assert_allclose(sz, sz_analytic, atol=0.05)
+
+    def testCavity1(self):
+        "mesolve: cavity-qubit interaction, no dissipation"
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.01   # coupling strength
+        kappa = 0.0     # cavity dissipation rate
+        gamma = 0.0     # atom dissipation rate
+        pump = 0.0      # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+        tlist = np.linspace(0, 1000, 2000)
+
+        nc, na = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        nc_ex = 0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n
+        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist))
+
+        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
+        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
+
+    def testCavity2(self):
+        "mesolve: cavity-qubit without interaction, decay"
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.0    # coupling strength
+        kappa = 0.005   # cavity dissipation rate
+        gamma = 0.01    # atom dissipation rate
+        pump = 0.0      # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+        tlist = np.linspace(0, 1000, 2000)
+
+        nc, na = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        nc_ex = (0.5 * (1 - np.cos(2 * g * np.sqrt(n + 1) * tlist)) + n) * \
+            np.exp(-kappa * tlist)
+        na_ex = 0.5 * (1 + np.cos(2 * g * np.sqrt(n + 1) * tlist)) * \
+            np.exp(-gamma * tlist)
+
+        np.testing.assert_allclose(nc[-1], nc_ex[-1], atol=0.005)
+        np.testing.assert_allclose(na[-1], na_ex[-1], atol=0.005)
+
+    def testCavity3(self):
+        "mesolve: cavity-qubit with interaction, decay"
+
+        use_rwa = True
+        N = 4           # number of cavity fock states
+        wc = 2 * np.pi * 1.0   # cavity frequency
+        wa = 2 * np.pi * 1.0   # atom frequency
+        g = 2 * np.pi * 0.1   # coupling strength
+        kappa = 0.05    # cavity dissipation rate
+        gamma = 0.001   # atom dissipation rate
+        pump = 0.25    # atom pump rate
+
+        # start with an excited atom and maximum number of photons
+        n = N - 2
+        psi0 = qutip.tensor(qutip.basis(N, n), qutip.basis(2, 1))
+        tlist = np.linspace(0, 200, 500)
+
+        nc, na = self.jc_integrate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        # we don't have any analytics for this parameters, so
+        # compare with the steady state
+        nc_ss, na_ss = self.jc_steadystate(
+            N, wc, wa, g, kappa, gamma, pump, psi0, use_rwa, tlist)
+
+        nc_ss = nc_ss * np.ones(np.shape(nc))
+        na_ss = na_ss * np.ones(np.shape(na))
+
+        np.testing.assert_allclose(nc[-1], nc_ss[-1], atol=0.005)
+        np.testing.assert_allclose(na[-1], na_ss[-1], atol=0.005)
+
+
+class TestMESolveStepFuncCoeff:
+    """
+    A Test class for using time-dependent array coefficients
+    as step functions instead of doing interpolation
+    """
+    # Runge-Kutta method (dop853) behave better with step function evolution
+    # than multi-step methods (adams, qutip 4's default)
+    options = {"method": "dop853", "nsteps": 1e8, "progress_bar": None}
+
+    def python_coeff(self, t, args):
+        if t < np.pi/2:
+            return 1.
+        else:
+            return 0.
+
+    @pytest.mark.parametrize('method',
+                             all_ode_method, ids=all_ode_method)
+    def test_py_coeff(self, method):
+        """
+        Test for Python function as coefficient as step function coeff
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0, np.pi/2])
+        options = {"method": method, "nsteps": 1e5, "rtol": 1e-7}
+        qu = qutip.QobjEvo([[qutip.sigmax(), self.python_coeff]],
+                     tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_cte_coeff(self):
+        """
+        Test for Array coefficient with uniform tlist as step function coeff
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
+        npcoeff = np.array([0.25, 0.75, 0.75])
+        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_t_coeff(self):
+        """
+        Test for Array with non-uniform tlist as step function coeff
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/2, np.pi*3/2], dtype=float)
+        npcoeff = np.array([0.5, 0.25, 0.25])
+        qu = qutip.QobjEvo([[qutip.sigmax(), npcoeff]], tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_str_coeff(self):
+        """
+        Test for Array and string as step function coeff.
+        qobjevo_codegen is used and uniform tlist
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/2, np.pi], dtype=float)
+        npcoeff1 = np.array([0.25, 0.75, 0.75], dtype=complex)
+        npcoeff2 = np.array([0.5, 1.5, 1.5], dtype=float)
+        strcoeff = "1."
+        qu = qutip.QobjEvo(
+            [[qutip.sigmax(), npcoeff1],
+             [qutip.sigmax(), strcoeff],
+             [qutip.sigmax(), npcoeff2]],
+            tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+    def test_array_str_py_coeff(self):
+        """
+        Test for Array, string and Python function as step function coeff.
+        qobjevo_codegen is used and non non-uniform tlist
+        """
+        rho0 = qutip.rand_ket(2)
+        tlist = np.array([0., np.pi/4, np.pi/2, np.pi], dtype=float)
+        npcoeff1 = np.array([0.4, 1.6, 1.0, 1.0], dtype=complex)
+        npcoeff2 = np.array([0.4, 1.6, 1.0, 1.0], dtype=float)
+        strcoeff = "1."
+        qu = qutip.QobjEvo(
+            [[qutip.sigmax(), npcoeff1], [qutip.sigmax(), npcoeff2],
+             [qutip.sigmax(), self.python_coeff], [qutip.sigmax(), strcoeff]],
+            tlist=tlist, order=0)
+        result = mesolve(qu, rho0=rho0, tlist=tlist, options=self.options)
+        fid = qutip.fidelity(result.states[-1], qutip.sigmax()*rho0)
+        assert fid == pytest.approx(1)
+
+
+def test_num_collapse_set():
+    H = qutip.sigmaz()
+    psi = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    ts = [0, 1]
+    for c_ops in (
+        qutip.sigmax(),
+        [qutip.sigmax()],
+        [qutip.sigmay(), qutip.sigmax()],
+    ):
+        res = mesolve(H, psi, ts, c_ops=c_ops)
+        if not isinstance(c_ops, list):
+            c_ops = [c_ops]
+        assert res.stats["num_collapse"] == len(c_ops)
+
+
+def test_mesolve_bad_H():
+    with pytest.raises(TypeError):
+        MESolver([qutip.qeye(3), 't'], [])
+    with pytest.raises(TypeError):
+        MESolver(qutip.qeye(3), [[qutip.qeye(3), 't']])
+
+
+def test_mesolve_bad_state():
+    solver = MESolver(qutip.qeye(4), [])
+    with pytest.raises(TypeError):
+        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
+
+
+def test_mesolve_bad_options():
+    with pytest.raises(TypeError):
+        MESolver(qutip.qeye(4), [], options=False)
diff --git a/qutip/tests/solver/test_options.py b/qutip/tests/solver/test_options.py
index 7337db1c92..5f75405b1c 100644
--- a/qutip/tests/solver/test_options.py
+++ b/qutip/tests/solver/test_options.py
@@ -1,142 +1,142 @@
-import pytest
-import qutip
-import numpy as np
-from qutip.solver.options import _SolverOptions
-
-
-default = {
-    "opt1": False,
-    "opt2": True,
-    "opt3": None,
-}
-
-
-def test_default():
-    opt = _SolverOptions(default)
-    assert opt
-    assert default.keys() == opt.keys()
-    assert opt["opt1"] is False
-    assert opt["opt2"] is True
-    assert opt["opt3"] is None
-
-
-def test_SolverOptions_dictlike():
-    opt_dict = {
-        "opt1": True,
-        "opt2": None,
-    }
-    opt = _SolverOptions(default, **opt_dict)
-    assert opt
-    assert default.keys() == opt.keys()
-    assert opt["opt1"] is True
-    assert opt["opt2"] is None
-    assert opt["opt3"] is None
-
-    copy = opt.copy()
-    assert opt.items() == copy.items()
-    copy['opt3'] = 2
-    assert opt.items() != copy.items()
-
-    assert len(opt.values()) == 3
-    assert len(opt.items()) == 3
-    assert len(opt.keys()) == 3
-
-
-def test_del():
-    opt_dict = {
-        "opt1": True,
-    }
-    opt = _SolverOptions(default, opt1=True)
-    del opt["opt1"]
-    assert opt["opt1"] is False
-
-
-def test_SolverOptions_Feedback():
-    called = []
-
-    def _catch(keys):
-        assert isinstance(keys, (set, str))
-        called.append(keys)
-
-    opt = _SolverOptions(default, _catch)
-    opt["opt1"] = 2
-    opt["opt2"] = 1e-5
-
-    assert "opt1" in called
-    assert "opt2" in called
-    assert len(called) == 2
-
-
-def test_error():
-    with pytest.raises(KeyError) as err:
-        _SolverOptions(default, opt4=4)
-    assert "opt4" in str(err.value)
-
-    with pytest.raises(KeyError) as err:
-        opt = _SolverOptions(default)
-        opt["opt4"] = 4
-    assert "opt4" in str(err.value)
-
-
-def test_print():
-    opt = _SolverOptions(default, None, "Test options", "Custom doc")
-    assert "Test options" in opt.__str__()
-    assert "opt1 : False" in opt.__str__()
-    assert "opt2 : True" in opt.__str__()
-    assert "opt3 : None" in opt.__str__()
-    assert opt.__doc__ == "Custom doc"
-
-
-def test_in_solver():
-    opt = {"method": "adams", "store_states": True, "atol": 1}
-    solver = qutip.SESolver(qutip.qeye(1), options=opt)
-    adams = qutip.integrator.IntegratorScipyAdams
-    lsoda = qutip.integrator.IntegratorScipylsoda
-    bdf = qutip.integrator.IntegratorScipyBDF
-    assert solver.options["store_states"] is True
-    assert solver.options["method"] == "adams"
-    assert solver.options["atol"] == 1
-    assert solver.options["order"] == adams.integrator_options["order"]
-
-    solver.options["method"] = "bdf"
-    assert solver.options["store_states"] is True
-    assert solver.options["method"] == "bdf"
-    assert solver.options["atol"] == bdf.integrator_options["atol"]
-    assert solver.options["order"] == bdf.integrator_options["order"]
-
-    solver.options = {
-        "method": "vern7",
-        "store_final_state": True,
-        "atol": 0.01
-    }
-    assert solver.options["store_states"] is True
-    assert solver.options["store_final_state"] is True
-    assert solver.options["method"] == "vern7"
-    assert solver.options["atol"] == 0.01
-    assert "order" not in solver.options
-    assert "interpolate" in solver.options
-
-
-def test_options_update_solver():
-    opt = {"method": "adams", "normalize_output": False}
-    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
-
-    solver.start(qutip.basis(1), 0)
-    err_atol_def = (solver.step(1) - np.exp(1)).norm()
-
-    solver.options["atol"] = 1
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
-
-    del solver.options["atol"]
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
-
-    solver.options["atol"] = 1
-    solver.options["atol"] = None
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
-
-    solver.options["method"] = "diag"
-    solver.start(qutip.basis(1), 0)
-    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
+import pytest
+import qutip
+import numpy as np
+from qutip.solver.options import _SolverOptions
+
+
+default = {
+    "opt1": False,
+    "opt2": True,
+    "opt3": None,
+}
+
+
+def test_default():
+    opt = _SolverOptions(default)
+    assert opt
+    assert default.keys() == opt.keys()
+    assert opt["opt1"] is False
+    assert opt["opt2"] is True
+    assert opt["opt3"] is None
+
+
+def test_SolverOptions_dictlike():
+    opt_dict = {
+        "opt1": True,
+        "opt2": None,
+    }
+    opt = _SolverOptions(default, **opt_dict)
+    assert opt
+    assert default.keys() == opt.keys()
+    assert opt["opt1"] is True
+    assert opt["opt2"] is None
+    assert opt["opt3"] is None
+
+    copy = opt.copy()
+    assert opt.items() == copy.items()
+    copy['opt3'] = 2
+    assert opt.items() != copy.items()
+
+    assert len(opt.values()) == 3
+    assert len(opt.items()) == 3
+    assert len(opt.keys()) == 3
+
+
+def test_del():
+    opt_dict = {
+        "opt1": True,
+    }
+    opt = _SolverOptions(default, opt1=True)
+    del opt["opt1"]
+    assert opt["opt1"] is False
+
+
+def test_SolverOptions_Feedback():
+    called = []
+
+    def _catch(keys):
+        assert isinstance(keys, (set, str))
+        called.append(keys)
+
+    opt = _SolverOptions(default, _catch)
+    opt["opt1"] = 2
+    opt["opt2"] = 1e-5
+
+    assert "opt1" in called
+    assert "opt2" in called
+    assert len(called) == 2
+
+
+def test_error():
+    with pytest.raises(KeyError) as err:
+        _SolverOptions(default, opt4=4)
+    assert "opt4" in str(err.value)
+
+    with pytest.raises(KeyError) as err:
+        opt = _SolverOptions(default)
+        opt["opt4"] = 4
+    assert "opt4" in str(err.value)
+
+
+def test_print():
+    opt = _SolverOptions(default, None, "Test options", "Custom doc")
+    assert "Test options" in opt.__str__()
+    assert "opt1 : False" in opt.__str__()
+    assert "opt2 : True" in opt.__str__()
+    assert "opt3 : None" in opt.__str__()
+    assert opt.__doc__ == "Custom doc"
+
+
+def test_in_solver():
+    opt = {"method": "adams", "store_states": True, "atol": 1}
+    solver = qutip.SESolver(qutip.qeye(1), options=opt)
+    adams = qutip.integrator.IntegratorScipyAdams
+    lsoda = qutip.integrator.IntegratorScipylsoda
+    bdf = qutip.integrator.IntegratorScipyBDF
+    assert solver.options["store_states"] is True
+    assert solver.options["method"] == "adams"
+    assert solver.options["atol"] == 1
+    assert solver.options["order"] == adams.integrator_options["order"]
+
+    solver.options["method"] = "bdf"
+    assert solver.options["store_states"] is True
+    assert solver.options["method"] == "bdf"
+    assert solver.options["atol"] == bdf.integrator_options["atol"]
+    assert solver.options["order"] == bdf.integrator_options["order"]
+
+    solver.options = {
+        "method": "vern7",
+        "store_final_state": True,
+        "atol": 0.01
+    }
+    assert solver.options["store_states"] is True
+    assert solver.options["store_final_state"] is True
+    assert solver.options["method"] == "vern7"
+    assert solver.options["atol"] == 0.01
+    assert "order" not in solver.options
+    assert "interpolate" in solver.options
+
+
+def test_options_update_solver():
+    opt = {"method": "adams", "normalize_output": False}
+    solver = qutip.SESolver(1j * qutip.qeye(1), options=opt)
+
+    solver.start(qutip.basis(1), 0)
+    err_atol_def = (solver.step(1) - np.exp(1)).norm()
+
+    solver.options["atol"] = 1
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() > err_atol_def * 10
+
+    del solver.options["atol"]
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
+
+    solver.options["atol"] = 1
+    solver.options["atol"] = None
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(err_atol_def)
+
+    solver.options["method"] = "diag"
+    solver.start(qutip.basis(1), 0)
+    assert (solver.step(1) - np.exp(1)).norm() == pytest.approx(0., abs=-1e10)
diff --git a/qutip/tests/solver/test_parallel.py b/qutip/tests/solver/test_parallel.py
index 9d18a70ded..416369175e 100644
--- a/qutip/tests/solver/test_parallel.py
+++ b/qutip/tests/solver/test_parallel.py
@@ -1,121 +1,121 @@
-import numpy as np
-import time
-import pytest
-import threading
-
-from qutip.solver.parallel import (
-    parallel_map, serial_map, loky_pmap, MapExceptions
-)
-
-
-def _func1(x):
-    return x**2
-
-
-def _func2(x, a, b, c, d=0, e=0, f=0):
-    assert d > 0
-    assert e > 0
-    assert f > 0
-    time.sleep(np.random.rand() * 0.1)  # random delay
-    return x**2
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-@pytest.mark.parametrize('num_cpus',
-                         [1, 2],
-                         ids=['1', '2'])
-def test_map(map, num_cpus):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-
-    args = (1, 2, 3)
-    kwargs = {'d': 4, 'e': 5, 'f': 6}
-    map_kw = {
-        'job_timeout': threading.TIMEOUT_MAX,
-        'timeout': threading.TIMEOUT_MAX,
-        'num_cpus': num_cpus,
-    }
-
-    x = np.arange(10)
-    y1 = [_func1(xx) for xx in x]
-
-    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
-    assert ((np.array(y1) == np.array(y2)).all())
-
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-@pytest.mark.parametrize('num_cpus',
-                         [1, 2],
-                         ids=['1', '2'])
-def test_map_accumulator(map, num_cpus):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-    args = (1, 2, 3)
-    kwargs = {'d': 4, 'e': 5, 'f': 6}
-    map_kw = {
-        'job_timeout': threading.TIMEOUT_MAX,
-        'timeout': threading.TIMEOUT_MAX,
-        'num_cpus': num_cpus,
-    }
-    y2 = []
-
-    x = np.arange(10)
-    y1 = [_func1(xx) for xx in x]
-
-    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
-    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
-
-
-class CustomException(Exception):
-    pass
-
-
-def func(i):
-    if i % 2 == 1:
-        raise CustomException(f"Error in subprocess {i}")
-    return i
-
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-def test_map_pass_error(map):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-
-    with pytest.raises(CustomException) as err:
-        map(func, range(10))
-    assert "Error in subprocess" in str(err.value)
-
-
-@pytest.mark.parametrize('map', [
-    pytest.param(parallel_map, id='parallel_map'),
-    pytest.param(loky_pmap, id='loky_pmap'),
-    pytest.param(serial_map, id='serial_map'),
-])
-def test_map_store_error(map):
-    if map is loky_pmap:
-        loky = pytest.importorskip("loky")
-
-    with pytest.raises(MapExceptions) as err:
-        map(func, range(10), map_kw={"fail_fast": False})
-    map_error = err.value
-    assert "iterations failed" in str(map_error)
-    for iter, error in map_error.errors.items():
-        assert isinstance(error, CustomException)
-        assert f"Error in subprocess {iter}" == str(error)
-    for n, result in enumerate(map_error.results):
-        if n % 2 == 0:
-            # Passed
-            assert result == n
-        else:
-            assert result is None
+import numpy as np
+import time
+import pytest
+import threading
+
+from qutip.solver.parallel import (
+    parallel_map, serial_map, loky_pmap, MapExceptions
+)
+
+
+def _func1(x):
+    return x**2
+
+
+def _func2(x, a, b, c, d=0, e=0, f=0):
+    assert d > 0
+    assert e > 0
+    assert f > 0
+    time.sleep(np.random.rand() * 0.1)  # random delay
+    return x**2
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+@pytest.mark.parametrize('num_cpus',
+                         [1, 2],
+                         ids=['1', '2'])
+def test_map(map, num_cpus):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    args = (1, 2, 3)
+    kwargs = {'d': 4, 'e': 5, 'f': 6}
+    map_kw = {
+        'job_timeout': threading.TIMEOUT_MAX,
+        'timeout': threading.TIMEOUT_MAX,
+        'num_cpus': num_cpus,
+    }
+
+    x = np.arange(10)
+    y1 = [_func1(xx) for xx in x]
+
+    y2 = map(_func2, x, args, kwargs, map_kw=map_kw)
+    assert ((np.array(y1) == np.array(y2)).all())
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+@pytest.mark.parametrize('num_cpus',
+                         [1, 2],
+                         ids=['1', '2'])
+def test_map_accumulator(map, num_cpus):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+    args = (1, 2, 3)
+    kwargs = {'d': 4, 'e': 5, 'f': 6}
+    map_kw = {
+        'job_timeout': threading.TIMEOUT_MAX,
+        'timeout': threading.TIMEOUT_MAX,
+        'num_cpus': num_cpus,
+    }
+    y2 = []
+
+    x = np.arange(10)
+    y1 = [_func1(xx) for xx in x]
+
+    map(_func2, x, args, kwargs, reduce_func=y2.append, map_kw=map_kw)
+    assert ((np.array(sorted(y1)) == np.array(sorted(y2))).all())
+
+
+class CustomException(Exception):
+    pass
+
+
+def func(i):
+    if i % 2 == 1:
+        raise CustomException(f"Error in subprocess {i}")
+    return i
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+def test_map_pass_error(map):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    with pytest.raises(CustomException) as err:
+        map(func, range(10))
+    assert "Error in subprocess" in str(err.value)
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+def test_map_store_error(map):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    with pytest.raises(MapExceptions) as err:
+        map(func, range(10), map_kw={"fail_fast": False})
+    map_error = err.value
+    assert "iterations failed" in str(map_error)
+    for iter, error in map_error.errors.items():
+        assert isinstance(error, CustomException)
+        assert f"Error in subprocess {iter}" == str(error)
+    for n, result in enumerate(map_error.results):
+        if n % 2 == 0:
+            # Passed
+            assert result == n
+        else:
+            assert result is None
diff --git a/qutip/tests/solver/test_propagator.py b/qutip/tests/solver/test_propagator.py
index 0a7393ecfa..2d36d9f977 100644
--- a/qutip/tests/solver/test_propagator.py
+++ b/qutip/tests/solver/test_propagator.py
@@ -1,140 +1,140 @@
-import numpy as np
-from qutip import (destroy, propagator, Propagator, propagator_steadystate,
-                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
-import qutip
-import pytest
-from qutip.solver.brmesolve import BRSolver
-from qutip.solver.mesolve import MESolver
-from qutip.solver.sesolve import SESolver
-from qutip.solver.mcsolve import MCSolver
-
-
-def testPropHOB():
-    a = destroy(5)
-    H = a.dag()*a
-    U = propagator(H, 1)
-    U2 = (-1j * H).expm()
-    assert (U - U2).norm('max') < 1e-4
-
-
-def testPropObj():
-    opt = {"method": "dop853"}
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
-    # Few call to fill the stored propagators.
-    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
-    assert len(U.times) == 5
-    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
-    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
-    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
-    # Within tol, should use the precomupted value at U(0.5)
-    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
-
-
-def func(t):
-    return np.cos(t)
-
-
-def testPropHOTd():
-    "Propagator: func td format"
-    a = destroy(5)
-    H = a.dag()*a
-    Htd = [H, [H, func]]
-    U = propagator(Htd, 1)
-    ts = np.linspace(0, 1, 101)
-    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
-    assert (U - U2).norm('max') < 1e-4
-
-
-def testPropObjTd():
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
-    assert (
-        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
-    ).norm('max') < 1e-4
-    assert (
-        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
-    ).norm('max') < 1e-4
-    assert (
-        U(1.5, 0.5, w=1.5)
-        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
-    ).norm('max') < 1e-4
-
-
-def testPropHOSteady():
-    "Propagator: steady state"
-    a = destroy(5)
-    H = a.dag()*a
-    c_op_list = []
-    kappa = 0.1
-    n_th = 2
-    rate = kappa * (1 + n_th)
-    c_op_list.append(np.sqrt(rate) * a)
-    rate = kappa * n_th
-    c_op_list.append(np.sqrt(rate) * a.dag())
-    U = propagator(H, 2*np.pi, c_op_list)
-    rho_prop = propagator_steadystate(U)
-    rho_ss = steadystate(H, c_op_list)
-    assert (rho_prop - rho_ss).norm('max') < 1e-4
-
-
-def testPropHDims():
-    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
-    H = tensor([qeye(2), qeye(2)])
-    U = propagator(H, 1)
-    assert U.dims == H.dims
-
-
-def testPropEvo():
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
-    psi = QobjEvo(U) @ basis(5, 4)
-    tlist = np.linspace(0, 1, 6)
-    psi_expected = sesolve(
-        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
-    ).states
-    for t, psi_t in zip(tlist, psi_expected):
-        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
-
-
-def _make_se(H, a):
-    return SESolver(H)
-
-
-def _make_me(H, a):
-    return MESolver(H, [a])
-
-
-def _make_br(H, a):
-    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
-    return BRSolver(H, [(a+a.dag(), spectra)])
-
-
-@pytest.mark.parametrize('solver', [
-    pytest.param(_make_se, id='SESolver'),
-    pytest.param(_make_me, id='MESolver'),
-    pytest.param(_make_br, id='BRSolver'),
-])
-def testPropSolver(solver):
-    a = destroy(5)
-    H = a.dag()*a
-    U = Propagator(solver(H, a))
-    c_ops = []
-    if solver is not _make_se:
-        c_ops = [a]
-
-    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
-    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
-    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
-
-
-def testPropMCSolver():
-    a = destroy(5)
-    H = a.dag()*a
-    solver = MCSolver(H, [a])
-    with pytest.raises(TypeError) as err:
-        Propagator(solver)
-    assert str(err.value).startswith("Non-deterministic")
+import numpy as np
+from qutip import (destroy, propagator, Propagator, propagator_steadystate,
+                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
+import qutip
+import pytest
+from qutip.solver.brmesolve import BRSolver
+from qutip.solver.mesolve import MESolver
+from qutip.solver.sesolve import SESolver
+from qutip.solver.mcsolve import MCSolver
+
+
+def testPropHOB():
+    a = destroy(5)
+    H = a.dag()*a
+    U = propagator(H, 1)
+    U2 = (-1j * H).expm()
+    assert (U - U2).norm('max') < 1e-4
+
+
+def testPropObj():
+    opt = {"method": "dop853"}
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator(H, c_ops=[a], options=opt, memoize=5, tol=1e-5)
+    # Few call to fill the stored propagators.
+    U(0.5), U(0.25), U(0.75), U(1), U(-1), U(-.5)
+    assert len(U.times) == 5
+    assert (U(1) - propagator(H, 1, [a])).norm('max') < 1e-4
+    assert (U(0.5) - propagator(H, 0.5, [a])).norm('max') < 1e-4
+    assert (U(1.5, 0.5) - propagator(H, 1, [a])).norm('max') < 1e-4
+    # Within tol, should use the precomupted value at U(0.5)
+    assert (U(0.5) - U(0.5 + 1e-6)).norm('max') < 1e-10
+
+
+def func(t):
+    return np.cos(t)
+
+
+def testPropHOTd():
+    "Propagator: func td format"
+    a = destroy(5)
+    H = a.dag()*a
+    Htd = [H, [H, func]]
+    U = propagator(Htd, 1)
+    ts = np.linspace(0, 1, 101)
+    U2 = (-1j * H * np.trapz(1 + func(ts), ts)).expm()
+    assert (U - U2).norm('max') < 1e-4
+
+
+def testPropObjTd():
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator([H, [H, "w*t"]], c_ops=[a], args={'w': 1})
+    assert (
+        U(1) - propagator([H, [H, "w*t"]], 1, [a], args={'w': 1})
+    ).norm('max') < 1e-4
+    assert (
+        U(0.5, w=2) - propagator([H, [H, "w*t"]], 0.5, [a], args={'w': 2})
+    ).norm('max') < 1e-4
+    assert (
+        U(1.5, 0.5, w=1.5)
+        - propagator([H, [H, "w*t"]], [0.5, 1.5], [a], args={'w': 1.5})[1]
+    ).norm('max') < 1e-4
+
+
+def testPropHOSteady():
+    "Propagator: steady state"
+    a = destroy(5)
+    H = a.dag()*a
+    c_op_list = []
+    kappa = 0.1
+    n_th = 2
+    rate = kappa * (1 + n_th)
+    c_op_list.append(np.sqrt(rate) * a)
+    rate = kappa * n_th
+    c_op_list.append(np.sqrt(rate) * a.dag())
+    U = propagator(H, 2*np.pi, c_op_list)
+    rho_prop = propagator_steadystate(U)
+    rho_ss = steadystate(H, c_op_list)
+    assert (rho_prop - rho_ss).norm('max') < 1e-4
+
+
+def testPropHDims():
+    "Propagator: preserve H dims (unitary_mode='single', parallel=False)"
+    H = tensor([qeye(2), qeye(2)])
+    U = propagator(H, 1)
+    assert U.dims == H.dims
+
+
+def testPropEvo():
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator([H, [a + a.dag(), "w*t"]], args={'w': 1})
+    psi = QobjEvo(U) @ basis(5, 4)
+    tlist = np.linspace(0, 1, 6)
+    psi_expected = sesolve(
+        [H, [a + a.dag(), "w*t"]], basis(5,4), tlist=tlist, args={'w': 1}
+    ).states
+    for t, psi_t in zip(tlist, psi_expected):
+        assert abs(psi(t).overlap(psi_t)) > 1-1e-6
+
+
+def _make_se(H, a):
+    return SESolver(H)
+
+
+def _make_me(H, a):
+    return MESolver(H, [a])
+
+
+def _make_br(H, a):
+    spectra = qutip.coefficient(lambda t, w: w >= 0, args={"w": 0})
+    return BRSolver(H, [(a+a.dag(), spectra)])
+
+
+@pytest.mark.parametrize('solver', [
+    pytest.param(_make_se, id='SESolver'),
+    pytest.param(_make_me, id='MESolver'),
+    pytest.param(_make_br, id='BRSolver'),
+])
+def testPropSolver(solver):
+    a = destroy(5)
+    H = a.dag()*a
+    U = Propagator(solver(H, a))
+    c_ops = []
+    if solver is not _make_se:
+        c_ops = [a]
+
+    assert (U(1) - propagator(H, 1, c_ops)).norm('max') < 1e-4
+    assert (U(0.5) - propagator(H, 0.5, c_ops)).norm('max') < 1e-4
+    assert (U(1.5, 0.5) - propagator(H, 1, c_ops)).norm('max') < 1e-4
+
+
+def testPropMCSolver():
+    a = destroy(5)
+    H = a.dag()*a
+    solver = MCSolver(H, [a])
+    with pytest.raises(TypeError) as err:
+        Propagator(solver)
+    assert str(err.value).startswith("Non-deterministic")
diff --git a/qutip/tests/solver/test_results.py b/qutip/tests/solver/test_results.py
index 2bcfa2e904..3aa46982c9 100644
--- a/qutip/tests/solver/test_results.py
+++ b/qutip/tests/solver/test_results.py
@@ -1,352 +1,352 @@
-import numpy as np
-import pytest
-
-import qutip
-from qutip.solver.result import Result, MultiTrajResult, McResult
-
-
-def fill_options(**kwargs):
-    return {
-        "store_states": None,
-        "store_final_state": False,
-        "keep_runs_results": False,
-        **kwargs
-    }
-
-
-def e_op_state_by_time(t, state):
-    """ An e_ops function that returns the state multiplied by the time. """
-    return t * state
-
-
-class TestResult:
-    @pytest.mark.parametrize(["N", "e_ops", "options"], [
-        pytest.param(10, (), {}, id="no-e-ops"),
-        pytest.param(
-            10, qutip.create(10), {"store_states": True}, id="store-states",
-        )
-    ])
-    def test_states(self, N, e_ops, options):
-        res = Result(e_ops, fill_options(**options))
-        for i in range(N):
-            res.add(i, qutip.basis(N, i))
-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-        assert res.states == [qutip.basis(N, i) for i in range(N)]
-        assert res.final_state == qutip.basis(N, N-1)
-
-    @pytest.mark.parametrize(["N", "e_ops", "options"], [
-        pytest.param(10, (), {
-            "store_states": False, "store_final_state": True
-        }, id="no-e-ops"),
-        pytest.param(10, qutip.create(10), {
-            "store_final_state": True,
-        }, id="with-eops"),
-    ])
-    def test_final_state_only(self, N, e_ops, options):
-        res = Result(e_ops, fill_options(**options))
-        for i in range(N):
-            res.add(i, qutip.basis(N, i))
-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-        assert res.states == []
-        assert res.final_state == qutip.basis(N, N-1)
-
-    @pytest.mark.parametrize(["N", "e_ops", "results"], [
-        pytest.param(
-            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
-        ),
-        pytest.param(
-            10,
-            [qutip.num(10), qutip.qeye(10)],
-            {0: np.arange(10), 1: np.ones(10)},
-            id="list-e-ops",
-        ),
-        pytest.param(
-            10,
-            {"a": qutip.num(10), "b": qutip.qeye(10)},
-            {"a": np.arange(10), "b": np.ones(10)},
-            id="dict-e-ops",
-        ),
-        pytest.param(
-            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
-        ),
-        pytest.param(
-            5, e_op_state_by_time,
-            {0: [i * qutip.basis(5, i) for i in range(5)]},
-            id="function",
-        )
-    ])
-    def test_expect_and_e_ops(self, N, e_ops, results):
-        res = Result(
-            e_ops,
-            fill_options(
-                store_final_state=False,
-                store_states=False),
-        )
-        if isinstance(e_ops, dict):
-            raw_ops = e_ops
-        elif isinstance(e_ops, (list, tuple)):
-            raw_ops = dict(enumerate(e_ops))
-        else:
-            raw_ops = {0: e_ops}
-        for i in range(N):
-            res.add(i, qutip.basis(N, i))
-        np.testing.assert_allclose(np.array(res.times), np.arange(N))
-        assert res.final_state is None
-        assert not res.states
-        for i, k in enumerate(results):
-            assert res.e_ops[k].op is raw_ops[k]
-            e_op_call_values = [
-                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
-            ]
-            if isinstance(res.expect[i][0], qutip.Qobj):
-                assert (res.expect[i] == results[k]).all()
-                assert res.e_data[k] == results[k]
-                assert e_op_call_values == results[k]
-            else:
-                np.testing.assert_allclose(res.expect[i], results[k])
-                np.testing.assert_allclose(res.e_data[k], results[k])
-                np.testing.assert_allclose(e_op_call_values, results[k])
-
-    def test_add_processor(self):
-        res = Result([], fill_options(store_states=False))
-        a = []
-        b = []
-        states = [{"t": 0}, {"t": 1}]
-
-        res.add_processor(lambda t, state: a.append((t, state)))
-        res.add(0, states[0])
-        res.add_processor(
-            lambda t, state: b.append((t, state)),
-            requires_copy=True,
-        )
-        res.add(1, states[1])
-
-        assert a == [(0, {"t": 0}), (1, {"t": 1})]
-        assert a[0][1] is states[0]  # no copy made
-        assert a[1][1] is not states[1]  # copy made (for b)
-        assert b == [(1, {"t": 1})]
-        assert b[0][1] is not states[1]  # copy made
-
-    def test_repr_minimal(self):
-        res = Result(
-            [],
-            fill_options(store_final_state=False, store_states=False),
-        )
-        assert repr(res) == "\n".join([
-            "<Result",
-            "  Solver: None",
-            "  Number of e_ops: 0",
-            "  State not saved.",
-            ">",
-        ])
-
-    def test_repr_full(self):
-        res = Result(
-            [qutip.num(5), qutip.qeye(5)],
-            fill_options(store_states=True),
-            solver="test-solver",
-            stats={"stat-a": 1, "stat-b": 2},
-        )
-        for i in range(5):
-            res.add(i, qutip.basis(5, i))
-        assert repr(res) == "\n".join([
-            "<Result",
-            "  Solver: test-solver",
-            "  Solver stats:",
-            "    stat-a: 1",
-            "    stat-b: 2",
-            "  Time interval: [0, 4] (5 steps)",
-            "  Number of e_ops: 2",
-            "  States saved.",
-            ">",
-        ])
-
-
-def e_op_num(t, state):
-    """ An e_ops function that returns the ground state occupation. """
-    return state.dag() @ qutip.num(5) @ state
-
-
-class TestMultiTrajResult:
-    def _fill_trajectories(self, multiresult, N, ntraj,
-                           collapse=False, noise=0, dm=False):
-        for _ in range(ntraj):
-            result = Result(multiresult._raw_ops, multiresult.options)
-            result.collapse = []
-            for t in range(N):
-                delta = 1 + noise * np.random.randn()
-                state = qutip.basis(N, t) * delta
-                if dm:
-                    state = state.proj()
-                result.add(t, state)
-                if collapse:
-                    result.collapse.append((t+0.1, 0))
-                    result.collapse.append((t+0.2, 1))
-                    result.collapse.append((t+0.3, 1))
-            if multiresult.add((0, result)) <= 0:
-                break
-
-    def _expect_check_types(self, multiresult):
-        assert isinstance(multiresult.std_expect, list)
-        assert isinstance(multiresult.average_e_data, dict)
-        assert isinstance(multiresult.std_expect, list)
-        assert isinstance(multiresult.average_e_data, dict)
-
-        if multiresult.trajectories:
-            assert isinstance(multiresult.runs_expect, list)
-            assert isinstance(multiresult.runs_e_data, dict)
-        else:
-            assert multiresult.runs_expect == []
-            assert multiresult.runs_e_data == {}
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize('dm', [True, False])
-    def test_McResult(self, dm, keep_runs_results):
-        N = 10
-        ntraj = 5
-        e_ops = [qutip.num(N), qutip.qeye(N)]
-        opt = fill_options(keep_runs_results=keep_runs_results)
-
-        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
-        m_res.add_end_condition(ntraj, None)
-        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
-
-        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
-        assert m_res.stats['end_condition'] == "ntraj reached"
-        self._expect_check_types(m_res)
-
-        assert np.all(np.array(m_res.col_which) < 2)
-        assert isinstance(m_res.collapse, list)
-        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
-        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
-        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize(["e_ops", "results"], [
-        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
-        pytest.param(
-            {"a": qutip.num(5), "b": qutip.qeye(5)},
-            [np.arange(5), np.ones(5)],
-            id="dict-e-ops",
-        ),
-        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
-        pytest.param(e_op_num, [np.arange(5)], id="function"),
-        pytest.param(
-            [qutip.num(5), e_op_num],
-            [np.arange(5), np.arange(5)],
-            id="list-e-ops",
-        ),
-    ])
-    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
-        N = 5
-        ntraj = 25
-        opt = fill_options(keep_runs_results=keep_runs_results)
-        m_res = MultiTrajResult(e_ops, opt, stats={})
-        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
-
-        for expect, expected in zip(m_res.average_expect, results):
-            np.testing.assert_allclose(expect, expected,
-                                       atol=1e-14, rtol=0.02)
-
-        for variance, expected in zip(m_res.std_expect, results):
-            np.testing.assert_allclose(variance, 0.02 * expected,
-                                       atol=1e-14, rtol=0.9)
-
-        if keep_runs_results:
-            for runs_expect, expected in zip(m_res.runs_expect, results):
-                for expect in runs_expect:
-                    np.testing.assert_allclose(expect, expected,
-                                               atol=1e-14, rtol=0.1)
-
-        self._expect_check_types(m_res)
-
-        assert m_res.stats['end_condition'] == "unknown"
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize('dm', [True, False])
-    def test_multitraj_state(self, keep_runs_results, dm):
-        N = 5
-        ntraj = 25
-        opt = fill_options(keep_runs_results=keep_runs_results)
-        m_res = MultiTrajResult([], opt)
-        self._fill_trajectories(m_res, N, ntraj, dm=dm)
-
-        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
-
-        for i in range(N):
-            assert m_res.average_states[i] == qutip.fock_dm(N, i)
-        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
-
-        if keep_runs_results:
-            assert len(m_res.runs_states) == 25
-            assert len(m_res.runs_states[0]) == N
-            for i in range(ntraj):
-                expected = qutip.basis(N, N-1)
-                if dm:
-                    expected = expected.proj()
-                assert m_res.runs_final_states[i] == expected
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    @pytest.mark.parametrize('targettol', [
-        pytest.param(0.1, id='atol'),
-        pytest.param([0.001, 0.1], id='rtol'),
-        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
-    ])
-    def test_multitraj_targettol(self, keep_runs_results, targettol):
-        N = 10
-        ntraj = 1000
-        opt = fill_options(
-            keep_runs_results=keep_runs_results, store_states=True
-        )
-        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
-        m_res.add_end_condition(ntraj, targettol)
-        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
-
-        assert m_res.stats['end_condition'] == "target tolerance reached"
-        assert m_res.num_trajectories <= 1000
-
-    def test_multitraj_steadystate(self):
-        N = 5
-        ntraj = 100
-        opt = fill_options()
-        m_res = MultiTrajResult([], opt, stats={})
-        m_res.add_end_condition(1000)
-        self._fill_trajectories(m_res, N, ntraj)
-        assert m_res.stats['end_condition'] == "timeout"
-        assert m_res.steady_state() == qutip.qeye(5) / 5
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    def test_repr(self, keep_runs_results):
-        N = 10
-        ntraj = 10
-        opt = fill_options(keep_runs_results=keep_runs_results)
-        m_res = MultiTrajResult([], opt)
-        self._fill_trajectories(m_res, N, ntraj)
-        repr = m_res.__repr__()
-        assert "Number of trajectories: 10" in repr
-        if keep_runs_results:
-            assert "Trajectories saved." in repr
-
-    @pytest.mark.parametrize('keep_runs_results', [True, False])
-    def test_merge_result(self, keep_runs_results):
-        N = 10
-        opt = fill_options(
-            keep_runs_results=keep_runs_results, store_states=True
-        )
-        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
-        self._fill_trajectories(m_res1, N, 10, noise=0.1)
-
-        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
-        self._fill_trajectories(m_res2, N, 30, noise=0.1)
-
-        merged_res = m_res1 + m_res2
-        assert merged_res.num_trajectories == 40
-        np.testing.assert_allclose(merged_res.average_expect[0],
-                                   np.arange(10), rtol=0.1)
-        np.testing.assert_allclose(
-            np.diag(sum(merged_res.average_states).full()),
-            np.ones(N),
-            rtol=0.1
-        )
-        assert bool(merged_res.trajectories) == keep_runs_results
-        assert merged_res.stats["run time"] == 3
+import numpy as np
+import pytest
+
+import qutip
+from qutip.solver.result import Result, MultiTrajResult, McResult
+
+
+def fill_options(**kwargs):
+    return {
+        "store_states": None,
+        "store_final_state": False,
+        "keep_runs_results": False,
+        **kwargs
+    }
+
+
+def e_op_state_by_time(t, state):
+    """ An e_ops function that returns the state multiplied by the time. """
+    return t * state
+
+
+class TestResult:
+    @pytest.mark.parametrize(["N", "e_ops", "options"], [
+        pytest.param(10, (), {}, id="no-e-ops"),
+        pytest.param(
+            10, qutip.create(10), {"store_states": True}, id="store-states",
+        )
+    ])
+    def test_states(self, N, e_ops, options):
+        res = Result(e_ops, fill_options(**options))
+        for i in range(N):
+            res.add(i, qutip.basis(N, i))
+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+        assert res.states == [qutip.basis(N, i) for i in range(N)]
+        assert res.final_state == qutip.basis(N, N-1)
+
+    @pytest.mark.parametrize(["N", "e_ops", "options"], [
+        pytest.param(10, (), {
+            "store_states": False, "store_final_state": True
+        }, id="no-e-ops"),
+        pytest.param(10, qutip.create(10), {
+            "store_final_state": True,
+        }, id="with-eops"),
+    ])
+    def test_final_state_only(self, N, e_ops, options):
+        res = Result(e_ops, fill_options(**options))
+        for i in range(N):
+            res.add(i, qutip.basis(N, i))
+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+        assert res.states == []
+        assert res.final_state == qutip.basis(N, N-1)
+
+    @pytest.mark.parametrize(["N", "e_ops", "results"], [
+        pytest.param(
+            10, qutip.num(10), {0: np.arange(10)}, id="single-e-op",
+        ),
+        pytest.param(
+            10,
+            [qutip.num(10), qutip.qeye(10)],
+            {0: np.arange(10), 1: np.ones(10)},
+            id="list-e-ops",
+        ),
+        pytest.param(
+            10,
+            {"a": qutip.num(10), "b": qutip.qeye(10)},
+            {"a": np.arange(10), "b": np.ones(10)},
+            id="dict-e-ops",
+        ),
+        pytest.param(
+            5, qutip.QobjEvo(qutip.num(5)), {0: np.arange(5)}, id="qobjevo",
+        ),
+        pytest.param(
+            5, e_op_state_by_time,
+            {0: [i * qutip.basis(5, i) for i in range(5)]},
+            id="function",
+        )
+    ])
+    def test_expect_and_e_ops(self, N, e_ops, results):
+        res = Result(
+            e_ops,
+            fill_options(
+                store_final_state=False,
+                store_states=False),
+        )
+        if isinstance(e_ops, dict):
+            raw_ops = e_ops
+        elif isinstance(e_ops, (list, tuple)):
+            raw_ops = dict(enumerate(e_ops))
+        else:
+            raw_ops = {0: e_ops}
+        for i in range(N):
+            res.add(i, qutip.basis(N, i))
+        np.testing.assert_allclose(np.array(res.times), np.arange(N))
+        assert res.final_state is None
+        assert not res.states
+        for i, k in enumerate(results):
+            assert res.e_ops[k].op is raw_ops[k]
+            e_op_call_values = [
+                res.e_ops[k](i, qutip.basis(N, i)) for i in range(N)
+            ]
+            if isinstance(res.expect[i][0], qutip.Qobj):
+                assert (res.expect[i] == results[k]).all()
+                assert res.e_data[k] == results[k]
+                assert e_op_call_values == results[k]
+            else:
+                np.testing.assert_allclose(res.expect[i], results[k])
+                np.testing.assert_allclose(res.e_data[k], results[k])
+                np.testing.assert_allclose(e_op_call_values, results[k])
+
+    def test_add_processor(self):
+        res = Result([], fill_options(store_states=False))
+        a = []
+        b = []
+        states = [{"t": 0}, {"t": 1}]
+
+        res.add_processor(lambda t, state: a.append((t, state)))
+        res.add(0, states[0])
+        res.add_processor(
+            lambda t, state: b.append((t, state)),
+            requires_copy=True,
+        )
+        res.add(1, states[1])
+
+        assert a == [(0, {"t": 0}), (1, {"t": 1})]
+        assert a[0][1] is states[0]  # no copy made
+        assert a[1][1] is not states[1]  # copy made (for b)
+        assert b == [(1, {"t": 1})]
+        assert b[0][1] is not states[1]  # copy made
+
+    def test_repr_minimal(self):
+        res = Result(
+            [],
+            fill_options(store_final_state=False, store_states=False),
+        )
+        assert repr(res) == "\n".join([
+            "<Result",
+            "  Solver: None",
+            "  Number of e_ops: 0",
+            "  State not saved.",
+            ">",
+        ])
+
+    def test_repr_full(self):
+        res = Result(
+            [qutip.num(5), qutip.qeye(5)],
+            fill_options(store_states=True),
+            solver="test-solver",
+            stats={"stat-a": 1, "stat-b": 2},
+        )
+        for i in range(5):
+            res.add(i, qutip.basis(5, i))
+        assert repr(res) == "\n".join([
+            "<Result",
+            "  Solver: test-solver",
+            "  Solver stats:",
+            "    stat-a: 1",
+            "    stat-b: 2",
+            "  Time interval: [0, 4] (5 steps)",
+            "  Number of e_ops: 2",
+            "  States saved.",
+            ">",
+        ])
+
+
+def e_op_num(t, state):
+    """ An e_ops function that returns the ground state occupation. """
+    return state.dag() @ qutip.num(5) @ state
+
+
+class TestMultiTrajResult:
+    def _fill_trajectories(self, multiresult, N, ntraj,
+                           collapse=False, noise=0, dm=False):
+        for _ in range(ntraj):
+            result = Result(multiresult._raw_ops, multiresult.options)
+            result.collapse = []
+            for t in range(N):
+                delta = 1 + noise * np.random.randn()
+                state = qutip.basis(N, t) * delta
+                if dm:
+                    state = state.proj()
+                result.add(t, state)
+                if collapse:
+                    result.collapse.append((t+0.1, 0))
+                    result.collapse.append((t+0.2, 1))
+                    result.collapse.append((t+0.3, 1))
+            if multiresult.add((0, result)) <= 0:
+                break
+
+    def _expect_check_types(self, multiresult):
+        assert isinstance(multiresult.std_expect, list)
+        assert isinstance(multiresult.average_e_data, dict)
+        assert isinstance(multiresult.std_expect, list)
+        assert isinstance(multiresult.average_e_data, dict)
+
+        if multiresult.trajectories:
+            assert isinstance(multiresult.runs_expect, list)
+            assert isinstance(multiresult.runs_e_data, dict)
+        else:
+            assert multiresult.runs_expect == []
+            assert multiresult.runs_e_data == {}
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize('dm', [True, False])
+    def test_McResult(self, dm, keep_runs_results):
+        N = 10
+        ntraj = 5
+        e_ops = [qutip.num(N), qutip.qeye(N)]
+        opt = fill_options(keep_runs_results=keep_runs_results)
+
+        m_res = McResult(e_ops, opt, stats={"num_collapse": 2})
+        m_res.add_end_condition(ntraj, None)
+        self._fill_trajectories(m_res, N, ntraj, collapse=True, dm=dm)
+
+        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
+        assert m_res.stats['end_condition'] == "ntraj reached"
+        self._expect_check_types(m_res)
+
+        assert np.all(np.array(m_res.col_which) < 2)
+        assert isinstance(m_res.collapse, list)
+        assert len(m_res.col_which[0]) == len(m_res.col_times[0])
+        np.testing.assert_allclose(m_res.photocurrent[0], np.ones(N-1))
+        np.testing.assert_allclose(m_res.photocurrent[1], 2 * np.ones(N-1))
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize(["e_ops", "results"], [
+        pytest.param(qutip.num(5), [np.arange(5)], id="single-e-op"),
+        pytest.param(
+            {"a": qutip.num(5), "b": qutip.qeye(5)},
+            [np.arange(5), np.ones(5)],
+            id="dict-e-ops",
+        ),
+        pytest.param(qutip.QobjEvo(qutip.num(5)), [np.arange(5)], id="qobjevo"),
+        pytest.param(e_op_num, [np.arange(5)], id="function"),
+        pytest.param(
+            [qutip.num(5), e_op_num],
+            [np.arange(5), np.arange(5)],
+            id="list-e-ops",
+        ),
+    ])
+    def test_multitraj_expect(self, keep_runs_results, e_ops, results):
+        N = 5
+        ntraj = 25
+        opt = fill_options(keep_runs_results=keep_runs_results)
+        m_res = MultiTrajResult(e_ops, opt, stats={})
+        self._fill_trajectories(m_res, N, ntraj, noise=0.01)
+
+        for expect, expected in zip(m_res.average_expect, results):
+            np.testing.assert_allclose(expect, expected,
+                                       atol=1e-14, rtol=0.02)
+
+        for variance, expected in zip(m_res.std_expect, results):
+            np.testing.assert_allclose(variance, 0.02 * expected,
+                                       atol=1e-14, rtol=0.9)
+
+        if keep_runs_results:
+            for runs_expect, expected in zip(m_res.runs_expect, results):
+                for expect in runs_expect:
+                    np.testing.assert_allclose(expect, expected,
+                                               atol=1e-14, rtol=0.1)
+
+        self._expect_check_types(m_res)
+
+        assert m_res.stats['end_condition'] == "unknown"
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize('dm', [True, False])
+    def test_multitraj_state(self, keep_runs_results, dm):
+        N = 5
+        ntraj = 25
+        opt = fill_options(keep_runs_results=keep_runs_results)
+        m_res = MultiTrajResult([], opt)
+        self._fill_trajectories(m_res, N, ntraj, dm=dm)
+
+        np.testing.assert_allclose(np.array(m_res.times), np.arange(N))
+
+        for i in range(N):
+            assert m_res.average_states[i] == qutip.fock_dm(N, i)
+        assert m_res.average_final_state == qutip.fock_dm(N, N-1)
+
+        if keep_runs_results:
+            assert len(m_res.runs_states) == 25
+            assert len(m_res.runs_states[0]) == N
+            for i in range(ntraj):
+                expected = qutip.basis(N, N-1)
+                if dm:
+                    expected = expected.proj()
+                assert m_res.runs_final_states[i] == expected
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    @pytest.mark.parametrize('targettol', [
+        pytest.param(0.1, id='atol'),
+        pytest.param([0.001, 0.1], id='rtol'),
+        pytest.param([[0.001, 0.1], [0.1, 0]], id='tol_per_e_op'),
+    ])
+    def test_multitraj_targettol(self, keep_runs_results, targettol):
+        N = 10
+        ntraj = 1000
+        opt = fill_options(
+            keep_runs_results=keep_runs_results, store_states=True
+        )
+        m_res = MultiTrajResult([qutip.num(N), qutip.qeye(N)], opt, stats={})
+        m_res.add_end_condition(ntraj, targettol)
+        self._fill_trajectories(m_res, N, ntraj, noise=0.1)
+
+        assert m_res.stats['end_condition'] == "target tolerance reached"
+        assert m_res.num_trajectories <= 1000
+
+    def test_multitraj_steadystate(self):
+        N = 5
+        ntraj = 100
+        opt = fill_options()
+        m_res = MultiTrajResult([], opt, stats={})
+        m_res.add_end_condition(1000)
+        self._fill_trajectories(m_res, N, ntraj)
+        assert m_res.stats['end_condition'] == "timeout"
+        assert m_res.steady_state() == qutip.qeye(5) / 5
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    def test_repr(self, keep_runs_results):
+        N = 10
+        ntraj = 10
+        opt = fill_options(keep_runs_results=keep_runs_results)
+        m_res = MultiTrajResult([], opt)
+        self._fill_trajectories(m_res, N, ntraj)
+        repr = m_res.__repr__()
+        assert "Number of trajectories: 10" in repr
+        if keep_runs_results:
+            assert "Trajectories saved." in repr
+
+    @pytest.mark.parametrize('keep_runs_results', [True, False])
+    def test_merge_result(self, keep_runs_results):
+        N = 10
+        opt = fill_options(
+            keep_runs_results=keep_runs_results, store_states=True
+        )
+        m_res1 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 1})
+        self._fill_trajectories(m_res1, N, 10, noise=0.1)
+
+        m_res2 = MultiTrajResult([qutip.num(10)], opt, stats={"run time": 2})
+        self._fill_trajectories(m_res2, N, 30, noise=0.1)
+
+        merged_res = m_res1 + m_res2
+        assert merged_res.num_trajectories == 40
+        np.testing.assert_allclose(merged_res.average_expect[0],
+                                   np.arange(10), rtol=0.1)
+        np.testing.assert_allclose(
+            np.diag(sum(merged_res.average_states).full()),
+            np.ones(N),
+            rtol=0.1
+        )
+        assert bool(merged_res.trajectories) == keep_runs_results
+        assert merged_res.stats["run time"] == 3
diff --git a/qutip/tests/solver/test_scattering.py b/qutip/tests/solver/test_scattering.py
index 339050677e..0ad7257ec4 100644
--- a/qutip/tests/solver/test_scattering.py
+++ b/qutip/tests/solver/test_scattering.py
@@ -1,92 +1,92 @@
-"""
-This module includes a collection of testing functions for the QuTiP scattering
-module. Tests are approximate with low resolution to minimize runtime.
-"""
-
-# Author:  Ben Bartlett
-# Contact: benbartlett@stanford.edu
-
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-from qutip import create, destroy, basis
-from qutip.solver.scattering import *
-
-
-class TestScattering:
-    """
-    A test class for the QuTiP quantum optical scattering module. These tests
-    only use the two-level system for comparison, since larger systems can
-    take a long time to run.
-    """
-
-    def testScatteringProbability(self):
-        """
-        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
-        """
-        w0 = 1.0 * 2 * np.pi
-        gamma = 1.0
-        sm = np.sqrt(gamma) * destroy(2)
-        pulseArea = np.pi
-        pulseLength = 0.2 / gamma
-        RabiFreq = pulseArea / (2 * pulseLength)
-        psi0 = basis(2, 0)
-        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
-        # Define TLS Hamiltonian
-        H0S = w0 * create(2) * destroy(2)
-        H1S1 = lambda t, args: \
-            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
-        H1S2 = lambda t, args: \
-            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
-        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
-        # Run the test
-        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
-        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
-        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
-        assert P0 < 1e-3
-        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
-
-    def testScatteringAmplitude(self):
-        """
-        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
-        """
-        w0 = 1.0 * 2 * np.pi
-        gamma = 1.0
-        sm = np.sqrt(gamma) * destroy(2)
-        pulseArea = 2 * np.pi
-        pulseLength = 0.2 / gamma
-        RabiFreq = pulseArea / (2 * pulseLength)
-        psi0 = basis(2, 0)
-        T = 50
-        tlist = np.linspace(0, 1 / gamma, T)
-        # Define TLS Hamiltonian
-        H0S = w0 * create(2) * destroy(2)
-        H1S1 = lambda t, args: \
-            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
-        H1S2 = lambda t, args: \
-            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
-        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
-        # Run the test
-        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
-        basisVec = temporal_basis_vector([[40]], T)
-        assert np.abs(basisVec.dag() @ state) < 1e-3
-
-    def testWaveguideSplit(self):
-        """
-        Checks that a trivial splitting of a waveguide collapse operator like
-        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
-        """
-        gamma = 1.0
-        sm = np.sqrt(gamma) * destroy(2)
-        pulseArea = np.pi
-        pulseLength = 0.2 / gamma
-        RabiFreq = pulseArea / (2 * pulseLength)
-        psi0 = basis(2, 0)
-        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
-        # Define TLS Hamiltonian with rotating frame transformation
-        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
-        # Run the test
-        c_ops = [sm]
-        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
-        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
-        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
-        assert np.abs(P1/P1_split - 1) < 1e-7
+"""
+This module includes a collection of testing functions for the QuTiP scattering
+module. Tests are approximate with low resolution to minimize runtime.
+"""
+
+# Author:  Ben Bartlett
+# Contact: benbartlett@stanford.edu
+
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+from qutip import create, destroy, basis
+from qutip.solver.scattering import *
+
+
+class TestScattering:
+    """
+    A test class for the QuTiP quantum optical scattering module. These tests
+    only use the two-level system for comparison, since larger systems can
+    take a long time to run.
+    """
+
+    def testScatteringProbability(self):
+        """
+        Asserts that pi pulse in TLS has P0 ~ 0 and P0+P1+P2 ~ 1
+        """
+        w0 = 1.0 * 2 * np.pi
+        gamma = 1.0
+        sm = np.sqrt(gamma) * destroy(2)
+        pulseArea = np.pi
+        pulseLength = 0.2 / gamma
+        RabiFreq = pulseArea / (2 * pulseLength)
+        psi0 = basis(2, 0)
+        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
+        # Define TLS Hamiltonian
+        H0S = w0 * create(2) * destroy(2)
+        H1S1 = lambda t, args: \
+            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
+        H1S2 = lambda t, args: \
+            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
+        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
+        # Run the test
+        P0 = scattering_probability(Htls, psi0, 0, [sm], tlist)
+        P1 = scattering_probability(Htls, psi0, 1, [sm], tlist)
+        P2 = scattering_probability(Htls, psi0, 2, [sm], tlist)
+        assert P0 < 1e-3
+        assert np.abs(P0 + P1 + P2 - 1) < 1e-3
+
+    def testScatteringAmplitude(self):
+        """
+        Asserts that a 2pi pulse in TLS has ~0 amplitude after pulse
+        """
+        w0 = 1.0 * 2 * np.pi
+        gamma = 1.0
+        sm = np.sqrt(gamma) * destroy(2)
+        pulseArea = 2 * np.pi
+        pulseLength = 0.2 / gamma
+        RabiFreq = pulseArea / (2 * pulseLength)
+        psi0 = basis(2, 0)
+        T = 50
+        tlist = np.linspace(0, 1 / gamma, T)
+        # Define TLS Hamiltonian
+        H0S = w0 * create(2) * destroy(2)
+        H1S1 = lambda t, args: \
+            RabiFreq * 1j * np.exp(-1j * w0 * t) * (t < pulseLength)
+        H1S2 = lambda t, args: \
+            RabiFreq * -1j * np.exp(1j * w0 * t) * (t < pulseLength)
+        Htls = [H0S, [sm.dag(), H1S1], [sm, H1S2]]
+        # Run the test
+        state = temporal_scattered_state(Htls, psi0, 1, [sm], tlist)
+        basisVec = temporal_basis_vector([[40]], T)
+        assert np.abs(basisVec.dag() @ state) < 1e-3
+
+    def testWaveguideSplit(self):
+        """
+        Checks that a trivial splitting of a waveguide collapse operator like
+        [sm] -> [sm/sqrt2, sm/sqrt2] doesn't affect the normalization or result
+        """
+        gamma = 1.0
+        sm = np.sqrt(gamma) * destroy(2)
+        pulseArea = np.pi
+        pulseLength = 0.2 / gamma
+        RabiFreq = pulseArea / (2 * pulseLength)
+        psi0 = basis(2, 0)
+        tlist = np.geomspace(gamma, 10 * gamma, 40) - gamma
+        # Define TLS Hamiltonian with rotating frame transformation
+        Htls = [[sm.dag() + sm, lambda t, args: RabiFreq * (t < pulseLength)]]
+        # Run the test
+        c_ops = [sm]
+        c_ops_split = [sm / np.sqrt(2), sm / np.sqrt(2)]
+        P1 = scattering_probability(Htls, psi0, 1, c_ops, tlist)
+        P1_split = scattering_probability(Htls, psi0, 1, c_ops_split, tlist)
+        assert np.abs(P1/P1_split - 1) < 1e-7
diff --git a/qutip/tests/solver/test_sesolve.py b/qutip/tests/solver/test_sesolve.py
index 1814b0ca3f..5ca744f973 100644
--- a/qutip/tests/solver/test_sesolve.py
+++ b/qutip/tests/solver/test_sesolve.py
@@ -1,301 +1,301 @@
-import pytest
-import pickle
-import qutip
-import numpy as np
-from qutip.solver.sesolve import sesolve, SESolver
-from qutip.solver.krylovsolve import krylovsolve
-from qutip.solver.solver_base import Solver
-
-all_ode_method = [
-    method for method, integrator in SESolver.avail_integrators().items()
-    if integrator.support_time_dependant
-]
-
-def _analytic(t, alpha):
-    return ((1 - np.exp(-alpha * t)) / alpha)
-
-
-class TestSeSolve():
-    H0 = 0.2 * np.pi * qutip.sigmaz()
-    H1 = np.pi * qutip.sigmax()
-    tlist = np.linspace(0, 20, 200)
-    args = {'alpha': 0.5}
-    w_a = 0.35
-    a = 0.5
-
-    @pytest.mark.parametrize(['unitary_op'], [
-        pytest.param(None, id="state"),
-        pytest.param(qutip.qeye(2), id="unitary"),
-    ])
-    @pytest.mark.parametrize(['H', 'analytical'], [
-        pytest.param(H1, lambda t, _: t, id='const_H'),
-        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
-                                       * np.exp(-alpha * t)),
-                     _analytic, id='func_H'),
-        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
-                     _analytic, id='list_func_H'),
-        pytest.param([[H1, 'exp(-alpha*t)']],
-                     _analytic, id='list_str_H'),
-        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
-                     _analytic, id='list_array_H'),
-        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
-                     _analytic, id='QobjEvo_H'),
-    ])
-    def test_sesolve(self, H, analytical, unitary_op):
-        """
-        Compare integrated evolution with analytical result
-        If U0 is not None then operator evo is checked
-        Otherwise state evo
-        """
-        tol = 5e-3
-        psi0 = qutip.basis(2, 0)
-        options = {"progress_bar": None}
-
-        if unitary_op is None:
-            output = sesolve(H, psi0, self.tlist,
-                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
-                             args=self.args, options=options)
-            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
-        else:
-            output = sesolve(H, unitary_op, self.tlist, args=self.args,
-                             options=options)
-            sx = [qutip.expect(qutip.sigmax(), U * psi0)
-                  for U in output.states]
-            sy = [qutip.expect(qutip.sigmay(), U * psi0)
-                  for U in output.states]
-            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
-                  for U in output.states]
-
-        sx_analytic = np.zeros(np.shape(self.tlist))
-        sy_analytic = np.array(
-            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-        sz_analytic = np.array(
-            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
-        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
-        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
-
-    @pytest.mark.parametrize(['state_type'], [
-        pytest.param("ket", id="ket"),
-        pytest.param("unitary", id="unitary"),
-    ])
-    def test_sesolve_normalization(self, state_type):
-        # non-hermitean H causes state to evolve non-unitarily
-        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
-        psi0 = qutip.basis(2, 0)
-        options = {"normalize_output": True, "progress_bar": None}
-
-        if state_type == "ket":
-            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            np.testing.assert_allclose(
-                norms, [1.0 for _ in self.tlist], atol=1e-15,
-            )
-        else:
-            # evolution of unitaries should not be normalized
-            U = qutip.qeye(2)
-            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
-            norms = [state.norm() for state in output.states]
-            assert all(norm > 2 for norm in norms[1:])
-
-    @pytest.mark.parametrize(['unitary_op'], [
-        pytest.param(None, id="state"),
-        pytest.param(qutip.qeye(2), id="unitary"),
-    ])
-    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
-    def test_sesolve_method(self, method, unitary_op):
-        """
-        Compare integrated evolution with analytical result
-        If U0 is not None then operator evo is checked
-        Otherwise state evo
-        """
-        tol = 5e-3
-        psi0 = qutip.basis(2, 0)
-        options = {"method": method, "progress_bar": None}
-        H = [[self.H1, 'exp(-alpha*t)']]
-
-        if unitary_op is None:
-            output = sesolve(H, psi0, self.tlist,
-                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
-                             args=self.args, options=options)
-            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
-        else:
-            output = sesolve(H, unitary_op, self.tlist,
-                             args=self.args, options=options)
-            sx = [qutip.expect(qutip.sigmax(), U * psi0)
-                  for U in output.states]
-            sy = [qutip.expect(qutip.sigmay(), U * psi0)
-                  for U in output.states]
-            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
-                  for U in output.states]
-
-        sx_analytic = np.zeros(np.shape(self.tlist))
-        sy_analytic = np.array(
-            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-        sz_analytic = np.array(
-            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
-             for t in self.tlist]
-        )
-
-        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
-        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
-        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
-
-    @pytest.mark.parametrize('normalize', [True, False],
-                             ids=['Normalized', ''])
-    @pytest.mark.parametrize(['H', 'args'],
-        [pytest.param(H0 + H1, {}, id='const_H'),
-         pytest.param(lambda t, a, w_a: (
-             a * t * 0.2 * np.pi * qutip.sigmaz() +
-             np.cos(w_a * t) * np.pi * qutip.sigmax()
-         ), {'a':a, 'w_a':w_a}, id='func_H'),
-         pytest.param([
-             [H0, lambda t, args: args['a']*t],
-             [H1, lambda t, args: np.cos(args['w_a']*t)]
-         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
-         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
-    ])
-    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
-        """
-        Compare integrated evolution of unitary operator with state evo
-        """
-        psi0 = qutip.basis(2, 0)
-        U0 = qutip.qeye(2)
-
-        options = {
-            "store_states": True,
-            "normalize_output": normalize,
-            "progress_bar": None
-        }
-        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
-                                              qutip.sigmay(),
-                                              qutip.sigmaz()],
-                        options=options, args=args)
-        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
-        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
-        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
-        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
-
-        np.testing.assert_allclose(xs, xss, atol=tol)
-        np.testing.assert_allclose(ys, yss, atol=tol)
-        np.testing.assert_allclose(zs, zss, atol=tol)
-
-        if normalize:
-            # propagator evolution is not normalized (yet?)
-            tol = 5e-4
-        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
-        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
-        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
-        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
-
-        np.testing.assert_allclose(xs, xu, atol=tol)
-        np.testing.assert_allclose(ys, yu, atol=tol)
-        np.testing.assert_allclose(zs, zu, atol=tol)
-
-    def test_sesolver_args(self):
-        options = {"progress_bar": None}
-        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
-                                            args={'a': 1}),
-                              options=options)
-        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
-                             e_ops=[qutip.num(2)], args={'a':0})
-        np.testing.assert_allclose(res.expect[0], 1)
-
-    def test_sesolver_pickling(self):
-        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
-        options = {"progress_bar": None}
-        solver_obj = SESolver(self.H0 + self.H1,
-                              options=options)
-        solver_copy = pickle.loads(pickle.dumps(solver_obj))
-        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
-                                    e_ops=e_ops).expect
-        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
-                                       e_ops=e_ops).expect
-        np.testing.assert_allclose(sx, csx)
-        np.testing.assert_allclose(sy, csy)
-        np.testing.assert_allclose(sz, csz)
-
-    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
-    def test_sesolver_stepping(self, method):
-        options = {
-            "method": method,
-            "atol": 1e-7,
-            "rtol": 1e-8,
-            "progress_bar": None
-        }
-        solver_obj = SESolver(
-            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
-            options=options
-        )
-        solver_obj.start(qutip.basis(2,0), 0)
-        sr2 = -(2**.5)/2
-        state = solver_obj.step(1)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
-                                   atol=2e-6)
-
-        state = solver_obj.step(2, args={"a":0.125})
-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
-                                   atol=2e-6)
-
-        solver_obj.options = {
-            "method": "adams",
-            "atol": 1e-7,
-            "rtol": 1e-8,
-            "progress_bar": None
-        }
-        state = solver_obj.step(3, args={"a":0})
-        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
-                                   atol=2e-6)
-        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
-                                   atol=2e-6)
-
-
-def test_sesolve_bad_H():
-    with pytest.raises(TypeError):
-        SESolver(np.eye(3))
-    with pytest.raises(ValueError):
-        SESolver(qutip.basis(3,1))
-
-
-def test_sesolve_bad_state():
-    solver = SESolver(qutip.qeye(4))
-    with pytest.raises(TypeError):
-        solver.start(qutip.basis(4,1).dag(), 0)
-    with pytest.raises(TypeError):
-        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
-
-
-def test_sesolve_step_no_start():
-    solver = SESolver(qutip.qeye(4))
-    with pytest.raises(RuntimeError):
-        solver.step(1)
-
-
-@pytest.mark.parametrize("always_compute_step", [True, False])
-def test_krylovsolve(always_compute_step):
-    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
-    psi0 = qutip.basis([2]*8, [1]*8)
-    e_op = qutip.num(256)
-    e_op.dims = H.dims
-    tlist = np.linspace(0, 1, 11)
-    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
-    options = {"always_compute_step", always_compute_step}
-    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
-    np.testing.assert_allclose(ref, krylov_sol)
+import pytest
+import pickle
+import qutip
+import numpy as np
+from qutip.solver.sesolve import sesolve, SESolver
+from qutip.solver.krylovsolve import krylovsolve
+from qutip.solver.solver_base import Solver
+
+all_ode_method = [
+    method for method, integrator in SESolver.avail_integrators().items()
+    if integrator.support_time_dependant
+]
+
+def _analytic(t, alpha):
+    return ((1 - np.exp(-alpha * t)) / alpha)
+
+
+class TestSeSolve():
+    H0 = 0.2 * np.pi * qutip.sigmaz()
+    H1 = np.pi * qutip.sigmax()
+    tlist = np.linspace(0, 20, 200)
+    args = {'alpha': 0.5}
+    w_a = 0.35
+    a = 0.5
+
+    @pytest.mark.parametrize(['unitary_op'], [
+        pytest.param(None, id="state"),
+        pytest.param(qutip.qeye(2), id="unitary"),
+    ])
+    @pytest.mark.parametrize(['H', 'analytical'], [
+        pytest.param(H1, lambda t, _: t, id='const_H'),
+        pytest.param(lambda t, alpha: (np.pi * qutip.sigmax()
+                                       * np.exp(-alpha * t)),
+                     _analytic, id='func_H'),
+        pytest.param([[H1, lambda t, args: np.exp(-args['alpha'] * t)]],
+                     _analytic, id='list_func_H'),
+        pytest.param([[H1, 'exp(-alpha*t)']],
+                     _analytic, id='list_str_H'),
+        pytest.param([[H1, np.exp(-args['alpha'] * tlist)]],
+                     _analytic, id='list_array_H'),
+        pytest.param(qutip.QobjEvo([[H1, 'exp(-alpha*t)']], args=args),
+                     _analytic, id='QobjEvo_H'),
+    ])
+    def test_sesolve(self, H, analytical, unitary_op):
+        """
+        Compare integrated evolution with analytical result
+        If U0 is not None then operator evo is checked
+        Otherwise state evo
+        """
+        tol = 5e-3
+        psi0 = qutip.basis(2, 0)
+        options = {"progress_bar": None}
+
+        if unitary_op is None:
+            output = sesolve(H, psi0, self.tlist,
+                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
+                             args=self.args, options=options)
+            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
+        else:
+            output = sesolve(H, unitary_op, self.tlist, args=self.args,
+                             options=options)
+            sx = [qutip.expect(qutip.sigmax(), U * psi0)
+                  for U in output.states]
+            sy = [qutip.expect(qutip.sigmay(), U * psi0)
+                  for U in output.states]
+            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
+                  for U in output.states]
+
+        sx_analytic = np.zeros(np.shape(self.tlist))
+        sy_analytic = np.array(
+            [-np.sin(2 * np.pi * analytical(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+        sz_analytic = np.array(
+            [np.cos(2 * np.pi * analytical(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
+        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
+        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
+
+    @pytest.mark.parametrize(['state_type'], [
+        pytest.param("ket", id="ket"),
+        pytest.param("unitary", id="unitary"),
+    ])
+    def test_sesolve_normalization(self, state_type):
+        # non-hermitean H causes state to evolve non-unitarily
+        H = qutip.Qobj([[1, -0.1j], [-0.1j, 1]])
+        psi0 = qutip.basis(2, 0)
+        options = {"normalize_output": True, "progress_bar": None}
+
+        if state_type == "ket":
+            output = sesolve(H, psi0, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            np.testing.assert_allclose(
+                norms, [1.0 for _ in self.tlist], atol=1e-15,
+            )
+        else:
+            # evolution of unitaries should not be normalized
+            U = qutip.qeye(2)
+            output = sesolve(H, U, self.tlist, e_ops=[], options=options)
+            norms = [state.norm() for state in output.states]
+            assert all(norm > 2 for norm in norms[1:])
+
+    @pytest.mark.parametrize(['unitary_op'], [
+        pytest.param(None, id="state"),
+        pytest.param(qutip.qeye(2), id="unitary"),
+    ])
+    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
+    def test_sesolve_method(self, method, unitary_op):
+        """
+        Compare integrated evolution with analytical result
+        If U0 is not None then operator evo is checked
+        Otherwise state evo
+        """
+        tol = 5e-3
+        psi0 = qutip.basis(2, 0)
+        options = {"method": method, "progress_bar": None}
+        H = [[self.H1, 'exp(-alpha*t)']]
+
+        if unitary_op is None:
+            output = sesolve(H, psi0, self.tlist,
+                             [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()],
+                             args=self.args, options=options)
+            sx, sy, sz = output.expect[0], output.expect[1], output.expect[2]
+        else:
+            output = sesolve(H, unitary_op, self.tlist,
+                             args=self.args, options=options)
+            sx = [qutip.expect(qutip.sigmax(), U * psi0)
+                  for U in output.states]
+            sy = [qutip.expect(qutip.sigmay(), U * psi0)
+                  for U in output.states]
+            sz = [qutip.expect(qutip.sigmaz(), U * psi0)
+                  for U in output.states]
+
+        sx_analytic = np.zeros(np.shape(self.tlist))
+        sy_analytic = np.array(
+            [np.sin(-2*np.pi * _analytic(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+        sz_analytic = np.array(
+            [np.cos(2*np.pi *_analytic(t, self.args['alpha']))
+             for t in self.tlist]
+        )
+
+        np.testing.assert_allclose(sx, sx_analytic, atol=tol)
+        np.testing.assert_allclose(sy, sy_analytic, atol=tol)
+        np.testing.assert_allclose(sz, sz_analytic, atol=tol)
+
+    @pytest.mark.parametrize('normalize', [True, False],
+                             ids=['Normalized', ''])
+    @pytest.mark.parametrize(['H', 'args'],
+        [pytest.param(H0 + H1, {}, id='const_H'),
+         pytest.param(lambda t, a, w_a: (
+             a * t * 0.2 * np.pi * qutip.sigmaz() +
+             np.cos(w_a * t) * np.pi * qutip.sigmax()
+         ), {'a':a, 'w_a':w_a}, id='func_H'),
+         pytest.param([
+             [H0, lambda t, args: args['a']*t],
+             [H1, lambda t, args: np.cos(args['w_a']*t)]
+         ], {'a':a, 'w_a':w_a}, id='list_func_H'),
+         pytest.param([H0, [H1, 'cos(w_a*t)']], {'w_a':w_a}, id='list_str_H'),
+    ])
+    def test_compare_evolution(self, H, normalize, args, tol=5e-5):
+        """
+        Compare integrated evolution of unitary operator with state evo
+        """
+        psi0 = qutip.basis(2, 0)
+        U0 = qutip.qeye(2)
+
+        options = {
+            "store_states": True,
+            "normalize_output": normalize,
+            "progress_bar": None
+        }
+        out_s = sesolve(H, psi0, self.tlist, [qutip.sigmax(),
+                                              qutip.sigmay(),
+                                              qutip.sigmaz()],
+                        options=options, args=args)
+        xs, ys, zs = out_s.expect[0], out_s.expect[1], out_s.expect[2]
+        xss = [qutip.expect(qutip.sigmax(), U) for U in out_s.states]
+        yss = [qutip.expect(qutip.sigmay(), U) for U in out_s.states]
+        zss = [qutip.expect(qutip.sigmaz(), U) for U in out_s.states]
+
+        np.testing.assert_allclose(xs, xss, atol=tol)
+        np.testing.assert_allclose(ys, yss, atol=tol)
+        np.testing.assert_allclose(zs, zss, atol=tol)
+
+        if normalize:
+            # propagator evolution is not normalized (yet?)
+            tol = 5e-4
+        out_u = sesolve(H, U0, self.tlist, options=options, args=args)
+        xu = [qutip.expect(qutip.sigmax(), U * psi0) for U in out_u.states]
+        yu = [qutip.expect(qutip.sigmay(), U * psi0) for U in out_u.states]
+        zu = [qutip.expect(qutip.sigmaz(), U * psi0) for U in out_u.states]
+
+        np.testing.assert_allclose(xs, xu, atol=tol)
+        np.testing.assert_allclose(ys, yu, atol=tol)
+        np.testing.assert_allclose(zs, zu, atol=tol)
+
+    def test_sesolver_args(self):
+        options = {"progress_bar": None}
+        solver_obj = SESolver(qutip.QobjEvo([self.H0, [self.H1,'a']],
+                                            args={'a': 1}),
+                              options=options)
+        res = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
+                             e_ops=[qutip.num(2)], args={'a':0})
+        np.testing.assert_allclose(res.expect[0], 1)
+
+    def test_sesolver_pickling(self):
+        e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+        options = {"progress_bar": None}
+        solver_obj = SESolver(self.H0 + self.H1,
+                              options=options)
+        solver_copy = pickle.loads(pickle.dumps(solver_obj))
+        sx, sy, sz = solver_obj.run(qutip.basis(2,1), [0, 1, 2, 3],
+                                    e_ops=e_ops).expect
+        csx, csy, csz = solver_copy.run(qutip.basis(2,1), [0, 1, 2, 3],
+                                       e_ops=e_ops).expect
+        np.testing.assert_allclose(sx, csx)
+        np.testing.assert_allclose(sy, csy)
+        np.testing.assert_allclose(sz, csz)
+
+    @pytest.mark.parametrize('method', all_ode_method, ids=all_ode_method)
+    def test_sesolver_stepping(self, method):
+        options = {
+            "method": method,
+            "atol": 1e-7,
+            "rtol": 1e-8,
+            "progress_bar": None
+        }
+        solver_obj = SESolver(
+            qutip.QobjEvo([self.H1, lambda t, a: a], args={"a":0.25}),
+            options=options
+        )
+        solver_obj.start(qutip.basis(2,0), 0)
+        sr2 = -(2**.5)/2
+        state = solver_obj.step(1)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), -1,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), 0.,
+                                   atol=2e-6)
+
+        state = solver_obj.step(2, args={"a":0.125})
+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
+                                   atol=2e-6)
+
+        solver_obj.options = {
+            "method": "adams",
+            "atol": 1e-7,
+            "rtol": 1e-8,
+            "progress_bar": None
+        }
+        state = solver_obj.step(3, args={"a":0})
+        np.testing.assert_allclose(qutip.expect(qutip.sigmax(), state), 0.,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmay(), state), sr2,
+                                   atol=2e-6)
+        np.testing.assert_allclose(qutip.expect(qutip.sigmaz(), state), sr2,
+                                   atol=2e-6)
+
+
+def test_sesolve_bad_H():
+    with pytest.raises(TypeError):
+        SESolver(np.eye(3))
+    with pytest.raises(ValueError):
+        SESolver(qutip.basis(3,1))
+
+
+def test_sesolve_bad_state():
+    solver = SESolver(qutip.qeye(4))
+    with pytest.raises(TypeError):
+        solver.start(qutip.basis(4,1).dag(), 0)
+    with pytest.raises(TypeError):
+        solver.start(qutip.basis(2,1) & qutip.basis(2,0), 0)
+
+
+def test_sesolve_step_no_start():
+    solver = SESolver(qutip.qeye(4))
+    with pytest.raises(RuntimeError):
+        solver.step(1)
+
+
+@pytest.mark.parametrize("always_compute_step", [True, False])
+def test_krylovsolve(always_compute_step):
+    H = qutip.tensor([qutip.rand_herm(2) for _ in range(8)])
+    psi0 = qutip.basis([2]*8, [1]*8)
+    e_op = qutip.num(256)
+    e_op.dims = H.dims
+    tlist = np.linspace(0, 1, 11)
+    ref = sesolve(H, psi0, tlist, e_ops=[e_op]).expect[0]
+    options = {"always_compute_step", always_compute_step}
+    krylov_sol = krylovsolve(H, psi0, tlist, 20, e_ops=[e_op]).expect[0]
+    np.testing.assert_allclose(ref, krylov_sol)
diff --git a/qutip/tests/solver/test_steadystate.py b/qutip/tests/solver/test_steadystate.py
index 38c85dfaa8..6ae02a6489 100644
--- a/qutip/tests/solver/test_steadystate.py
+++ b/qutip/tests/solver/test_steadystate.py
@@ -1,241 +1,241 @@
-import numpy as np
-import pytest
-import qutip
-import warnings
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-                                          reason='MKL extensions not found.')),
-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
-    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
-    pytest.param('eigen', {}, id="eigen"),
-    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
-    pytest.param('svd', {}, id="svd"),
-    pytest.param('power', {'power_tol':1e-5}, id="power"),
-    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-                                          reason='MKL extensions not found.')),
-    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
-    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
-                 id="power-gmres_perm"),
-    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
-    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
-    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
-                 id="iterative-gmres_perm"),
-    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
-                 id="iterative-bicgstab"),
-])
-def test_qubit(method, kwargs):
-    # thermal steadystate of a qubit: compare numerics with analytical formula
-    sz = qutip.sigmaz()
-    sm = qutip.destroy(2)
-
-    H = 0.5 * 2 * np.pi * sz
-    gamma1 = 0.05
-
-    wth_vec = np.linspace(0.1, 3, 20)
-    p_ss = np.zeros(np.shape(wth_vec))
-
-    for idx, wth in enumerate(wth_vec):
-        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
-        c_op_list = []
-        rate = gamma1 * (1 + n_th)
-        c_op_list.append(np.sqrt(rate) * sm)
-        rate = gamma1 * n_th
-        c_op_list.append(np.sqrt(rate) * sm.dag())
-        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
-        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
-
-    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
-    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
-                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
-                                          reason='MKL extensions not found.')),
-    pytest.param('direct', {'sparse': False}, id="direct_dense"),
-    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
-    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
-    pytest.param('eigen', {}, id="eigen"),
-    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
-    pytest.param('svd', {}, id="svd"),
-])
-def test_exact_solution_for_simple_methods(method, kwargs):
-    # this tests that simple methods correctly determine the steadystate
-    # with high accuracy for a small Liouvillian requiring correct weighting.
-    H = qutip.identity(2)
-    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
-    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
-    expected_rho_ss = np.array([
-        [1.e-10+0.j, 0.e+00-0.j],
-        [0.e+00-0.j, 1.e+00+0.j],
-    ])
-    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
-    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-    pytest.param('eigen', {'sparse':False}, id="eigen"),
-    pytest.param('power', {'power_tol':1e-5}, id="power"),
-    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
-    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
-    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
-])
-def test_ho(method, kwargs):
-    # thermal steadystate of an oscillator: compare numerics with analytical
-    # formula
-    a = qutip.destroy(30)
-    H = 0.5 * 2 * np.pi * a.dag() * a
-    gamma1 = 0.05
-
-    wth_vec = np.linspace(0.1, 3, 11)
-    p_ss = np.zeros(np.shape(wth_vec))
-
-    for idx, wth in enumerate(wth_vec):
-
-        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
-        c_op_list = []
-        rate = gamma1 * (1 + n_th)
-        c_op_list.append(np.sqrt(rate) * a)
-        rate = gamma1 * n_th
-        c_op_list.append(np.sqrt(rate) * a.dag())
-        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
-        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
-
-    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
-    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('direct', {}, id="direct"),
-    pytest.param('direct', {'sparse':False}, id="direct_dense"),
-    pytest.param('eigen', {}, id="eigen"),
-    pytest.param('svd', {}, id="svd"),
-    pytest.param('power', {}, id="power"),
-    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
-                 id="power-gmres"),
-    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
-                 id="power-bicgstab"),
-    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
-    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
-])
-def test_driven_cavity(method, kwargs):
-    N = 30
-    Omega = 0.01 * 2 * np.pi
-    Gamma = 0.05
-
-    a = qutip.destroy(N)
-    H = Omega * (a.dag() + a)
-    c_ops = [np.sqrt(Gamma) * a]
-    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
-    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
-
-    np.testing.assert_allclose(
-        rho_ss, rho_ss_analytic, atol=1e-4
-    )
-    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
-
-
-@pytest.mark.parametrize(['method', 'kwargs'], [
-    pytest.param('solve', {}, id="dense_direct"),
-    pytest.param('numpy', {}, id="dense_numpy"),
-    pytest.param('spilu', {},  id="spilu"),
-])
-def test_pseudo_inverse(method, kwargs):
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    L = qutip.liouvillian(H, [a])
-    rho = qutip.steadystate(L)
-    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
-    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
-    np.testing.assert_allclose(
-        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
-    )
-    assert rho.tr() == pytest.approx(1, abs=3e-15)
-
-
-@pytest.mark.parametrize('sparse', [True, False])
-def test_steadystate_floquet(sparse):
-    """
-    Test the steadystate solution for a periodically
-    driven system.
-    """
-    N_c = 20
-
-    a = qutip.destroy(N_c)
-    a_d = a.dag()
-    X_c = a + a_d
-
-    w_c = 1
-
-    A_l = 0.001
-    w_l = w_c
-    gam = 0.01
-
-    H = w_c * a_d * a
-
-    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
-
-    psi0 = qutip.fock(N_c, 0)
-
-    args = {"A_l": A_l, "w_l": w_l}
-
-    c_ops = []
-    c_ops.append(np.sqrt(gam) * a)
-
-    t_l = np.linspace(0, 20 / gam, 2000)
-
-    expect_me = qutip.mesolve(H_t, psi0, t_l,
-                        c_ops, [a_d * a], args=args).expect[0]
-
-    rho_ss = qutip.steadystate_floquet(H, c_ops,
-                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
-    expect_ss = qutip.expect(a_d * a, rho_ss)
-
-    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
-    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
-
-
-def test_bad_options_steadystate():
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    c_ops = [a]
-    with pytest.raises(ValueError):
-        qutip.steadystate(H, c_ops, method='not a method')
-    with pytest.raises(TypeError):
-        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
-    with pytest.raises(ValueError):
-        qutip.steadystate(H, c_ops, method='direct', solver='Error')
-
-
-def test_bad_options_pseudo_inverse():
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    L = qutip.liouvillian(H, [a])
-    with pytest.raises(TypeError):
-        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
-    with pytest.raises(ValueError):
-        qutip.pseudo_inverse(L, method='not a method', sparse=False)
-    with pytest.raises(ValueError):
-        qutip.pseudo_inverse(L, method='not a method')
-
-
-def test_bad_system():
-    N = 4
-    a = qutip.destroy(N)
-    H = (a.dag() + a)
-    with pytest.raises(TypeError):
-        qutip.steadystate(H, [], method='direct')
-    with pytest.raises(TypeError):
-        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
+import numpy as np
+import pytest
+import qutip
+import warnings
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'solver':'mkl'}, id="direct_mkl",
+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+                                          reason='MKL extensions not found.')),
+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+    pytest.param('direct', {'use_rcm':True}, id="direct_rcm"),
+    pytest.param('direct', {'use_wbm':True}, id="direct_wbm"),
+    pytest.param('eigen', {}, id="eigen"),
+    pytest.param('eigen', {'use_rcm':True},  id="eigen_rcm"),
+    pytest.param('svd', {}, id="svd"),
+    pytest.param('power', {'power_tol':1e-5}, id="power"),
+    pytest.param('power', {'power_tol':1e-5, 'solver':'mkl'}, id="power_mkl",
+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+                                          reason='MKL extensions not found.')),
+    pytest.param('power-gmres', {'tol':1e-1, 'atol': 1e-12}, id="power-gmres"),
+    pytest.param('power-gmres', {'tol':1e-1, 'use_rcm':True, 'use_wbm':True, 'atol': 1e-12},
+                 id="power-gmres_perm"),
+    pytest.param('power-bicgstab', {"atol": 1e-10, "tol": 1e-10, 'use_precond':1}, id="power-bicgstab"),
+    pytest.param('iterative-gmres', {'tol': 1e-12, 'atol': 1e-12}, id="iterative-gmres"),
+    pytest.param('iterative-gmres', {'use_rcm':True, 'use_wbm':True, 'tol': 1e-12, 'atol': 1e-12},
+                 id="iterative-gmres_perm"),
+    pytest.param('iterative-bicgstab', {'atol': 1e-12, "tol": 1e-10},
+                 id="iterative-bicgstab"),
+])
+def test_qubit(method, kwargs):
+    # thermal steadystate of a qubit: compare numerics with analytical formula
+    sz = qutip.sigmaz()
+    sm = qutip.destroy(2)
+
+    H = 0.5 * 2 * np.pi * sz
+    gamma1 = 0.05
+
+    wth_vec = np.linspace(0.1, 3, 20)
+    p_ss = np.zeros(np.shape(wth_vec))
+
+    for idx, wth in enumerate(wth_vec):
+        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
+        c_op_list = []
+        rate = gamma1 * (1 + n_th)
+        c_op_list.append(np.sqrt(rate) * sm)
+        rate = gamma1 * n_th
+        c_op_list.append(np.sqrt(rate) * sm.dag())
+        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
+        p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
+
+    p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
+    np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'solver': 'mkl'}, id="direct_mkl",
+                 marks=pytest.mark.skipif(not qutip.settings.has_mkl,
+                                          reason='MKL extensions not found.')),
+    pytest.param('direct', {'sparse': False}, id="direct_dense"),
+    pytest.param('direct', {'use_rcm': True}, id="direct_rcm"),
+    pytest.param('direct', {'use_wbm': True}, id="direct_wbm"),
+    pytest.param('eigen', {}, id="eigen"),
+    pytest.param('eigen', {'use_rcm': True},  id="eigen_rcm"),
+    pytest.param('svd', {}, id="svd"),
+])
+def test_exact_solution_for_simple_methods(method, kwargs):
+    # this tests that simple methods correctly determine the steadystate
+    # with high accuracy for a small Liouvillian requiring correct weighting.
+    H = qutip.identity(2)
+    c_ops = [qutip.sigmam(), 1e-5 * qutip.sigmap()]
+    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
+    expected_rho_ss = np.array([
+        [1.e-10+0.j, 0.e+00-0.j],
+        [0.e+00-0.j, 1.e+00+0.j],
+    ])
+    np.testing.assert_allclose(expected_rho_ss, rho_ss.full(), atol=1e-14)
+    assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+    pytest.param('eigen', {'sparse':False}, id="eigen"),
+    pytest.param('power', {'power_tol':1e-5}, id="power"),
+    pytest.param('iterative-lgmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-lgmres"),
+    pytest.param('iterative-gmres', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-gmres"),
+    pytest.param('iterative-bicgstab', {'tol': 1e-7, 'atol': 1e-7}, id="iterative-bicgstab"),
+])
+def test_ho(method, kwargs):
+    # thermal steadystate of an oscillator: compare numerics with analytical
+    # formula
+    a = qutip.destroy(30)
+    H = 0.5 * 2 * np.pi * a.dag() * a
+    gamma1 = 0.05
+
+    wth_vec = np.linspace(0.1, 3, 11)
+    p_ss = np.zeros(np.shape(wth_vec))
+
+    for idx, wth in enumerate(wth_vec):
+
+        n_th = 1.0 / (np.exp(1.0 / wth) - 1)  # bath temperature
+        c_op_list = []
+        rate = gamma1 * (1 + n_th)
+        c_op_list.append(np.sqrt(rate) * a)
+        rate = gamma1 * n_th
+        c_op_list.append(np.sqrt(rate) * a.dag())
+        rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
+        p_ss[idx] = np.real(qutip.expect(a.dag() * a, rho_ss))
+
+    p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
+    np.testing.assert_allclose(p_ss_analytic, p_ss, rtol=1e-3, atol=1e-3)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('direct', {}, id="direct"),
+    pytest.param('direct', {'sparse':False}, id="direct_dense"),
+    pytest.param('eigen', {}, id="eigen"),
+    pytest.param('svd', {}, id="svd"),
+    pytest.param('power', {}, id="power"),
+    pytest.param('power-gmres', {"atol": 1e-5, 'tol':1e-1, 'use_precond':1},
+                 id="power-gmres"),
+    pytest.param('power', {"solver": "bicgstab", "atol": 1e-6, "tol": 1e-6, 'use_precond':1},
+                 id="power-bicgstab"),
+    pytest.param('iterative-gmres', {"atol": 1e-10, "tol": 1e-10}, id="iterative-gmres"),
+    pytest.param('iterative-bicgstab', {"atol": 1e-10, "tol": 1e-10}, id="iterative-bicgstab"),
+])
+def test_driven_cavity(method, kwargs):
+    N = 30
+    Omega = 0.01 * 2 * np.pi
+    Gamma = 0.05
+
+    a = qutip.destroy(N)
+    H = Omega * (a.dag() + a)
+    c_ops = [np.sqrt(Gamma) * a]
+    rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs).full()
+    rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega)/(Gamma/2)).full()
+
+    np.testing.assert_allclose(
+        rho_ss, rho_ss_analytic, atol=1e-4
+    )
+    assert rho_ss.trace() == pytest.approx(1, abs=1e-10)
+
+
+@pytest.mark.parametrize(['method', 'kwargs'], [
+    pytest.param('solve', {}, id="dense_direct"),
+    pytest.param('numpy', {}, id="dense_numpy"),
+    pytest.param('spilu', {},  id="spilu"),
+])
+def test_pseudo_inverse(method, kwargs):
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    L = qutip.liouvillian(H, [a])
+    rho = qutip.steadystate(L)
+    Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs)
+    np.testing.assert_allclose((L * Lpinv * L).full(), L.full(), atol=5e-14)
+    np.testing.assert_allclose(
+        (Lpinv * L * Lpinv).full(), Lpinv.full(),  atol=3e-14
+    )
+    assert rho.tr() == pytest.approx(1, abs=3e-15)
+
+
+@pytest.mark.parametrize('sparse', [True, False])
+def test_steadystate_floquet(sparse):
+    """
+    Test the steadystate solution for a periodically
+    driven system.
+    """
+    N_c = 20
+
+    a = qutip.destroy(N_c)
+    a_d = a.dag()
+    X_c = a + a_d
+
+    w_c = 1
+
+    A_l = 0.001
+    w_l = w_c
+    gam = 0.01
+
+    H = w_c * a_d * a
+
+    H_t = [H, [X_c, lambda t, args: args["A_l"] * np.cos(args["w_l"] * t)]]
+
+    psi0 = qutip.fock(N_c, 0)
+
+    args = {"A_l": A_l, "w_l": w_l}
+
+    c_ops = []
+    c_ops.append(np.sqrt(gam) * a)
+
+    t_l = np.linspace(0, 20 / gam, 2000)
+
+    expect_me = qutip.mesolve(H_t, psi0, t_l,
+                        c_ops, [a_d * a], args=args).expect[0]
+
+    rho_ss = qutip.steadystate_floquet(H, c_ops,
+                                       A_l * X_c, w_l, n_it=3, sparse=sparse)
+    expect_ss = qutip.expect(a_d * a, rho_ss)
+
+    np.testing.assert_allclose(expect_me[-20:], expect_ss, atol=1e-3)
+    assert rho_ss.tr() == pytest.approx(1, abs=1e-15)
+
+
+def test_bad_options_steadystate():
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    c_ops = [a]
+    with pytest.raises(ValueError):
+        qutip.steadystate(H, c_ops, method='not a method')
+    with pytest.raises(TypeError):
+        qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
+    with pytest.raises(ValueError):
+        qutip.steadystate(H, c_ops, method='direct', solver='Error')
+
+
+def test_bad_options_pseudo_inverse():
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    L = qutip.liouvillian(H, [a])
+    with pytest.raises(TypeError):
+        qutip.pseudo_inverse(L, method='splu', bad_opt=True)
+    with pytest.raises(ValueError):
+        qutip.pseudo_inverse(L, method='not a method', sparse=False)
+    with pytest.raises(ValueError):
+        qutip.pseudo_inverse(L, method='not a method')
+
+
+def test_bad_system():
+    N = 4
+    a = qutip.destroy(N)
+    H = (a.dag() + a)
+    with pytest.raises(TypeError):
+        qutip.steadystate(H, [], method='direct')
+    with pytest.raises(TypeError):
+        qutip.steadystate(qutip.basis(N, N-1), [], method='direct')
diff --git a/qutip/tests/test_basis_transformation.py b/qutip/tests/test_basis_transformation.py
index 080296a325..1e406e9fa5 100644
--- a/qutip/tests/test_basis_transformation.py
+++ b/qutip/tests/test_basis_transformation.py
@@ -1,55 +1,55 @@
-import numpy as np
-import pytest
-import qutip
-
-
-def real_hermitian(n_levels):
-    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
-    return qobj + qobj.dag()
-
-
-def imaginary_hermitian(n_levels):
-    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
-    return qobj + qobj.dag()
-
-
-def complex_hermitian(n_levels):
-    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
-
-
-def rand_bra(n_levels):
-    return qutip.rand_ket(n_levels).dag()
-
-
-@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
-                                                   imaginary_hermitian,
-                                                   complex_hermitian])
-@pytest.mark.parametrize("n_levels", [2, 10])
-def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
-                                                    n_levels):
-    """Transform n-level real-values to eigenbasis and back"""
-    H1 = hermitian_constructor(n_levels)
-    _, ekets = H1.eigenstates()
-    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
-    H2 = Heb.transform(ekets, True)  # Back to original basis
-    assert (H1 - H2).norm() < 1e-6
-
-
-@pytest.mark.parametrize("n_levels", [4])
-def test_ket_and_dm_transformations_equivalent(n_levels):
-    """Consistency between transformations of kets and density matrices."""
-    psi0 = qutip.rand_ket(n_levels)
-    # Generate a random basis
-    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
-    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
-    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
-    assert (rho1 - rho2).norm() < 1e-6
-
-
-def test_eigenbasis_transformation_makes_diagonal_operator():
-    """Check diagonalization via eigenbasis transformation."""
-    cx, cy, cz = np.random.random_sample((3,))
-    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
-    _, ekets = H.eigenstates()
-    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
-    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
+import numpy as np
+import pytest
+import qutip
+
+
+def real_hermitian(n_levels):
+    qobj = qutip.Qobj(0.5 - np.random.random_sample((n_levels, n_levels)))
+    return qobj + qobj.dag()
+
+
+def imaginary_hermitian(n_levels):
+    qobj = qutip.Qobj(1j*(0.5 - np.random.random_sample((n_levels, n_levels))))
+    return qobj + qobj.dag()
+
+
+def complex_hermitian(n_levels):
+    return real_hermitian(n_levels) + imaginary_hermitian(n_levels)
+
+
+def rand_bra(n_levels):
+    return qutip.rand_ket(n_levels).dag()
+
+
+@pytest.mark.parametrize("hermitian_constructor", [real_hermitian,
+                                                   imaginary_hermitian,
+                                                   complex_hermitian])
+@pytest.mark.parametrize("n_levels", [2, 10])
+def test_transformation_to_eigenbasis_is_reversible(hermitian_constructor,
+                                                    n_levels):
+    """Transform n-level real-values to eigenbasis and back"""
+    H1 = hermitian_constructor(n_levels)
+    _, ekets = H1.eigenstates()
+    Heb = H1.transform(ekets)  # In the eigenbasis (should be diagonal)
+    H2 = Heb.transform(ekets, True)  # Back to original basis
+    assert (H1 - H2).norm() < 1e-6
+
+
+@pytest.mark.parametrize("n_levels", [4])
+def test_ket_and_dm_transformations_equivalent(n_levels):
+    """Consistency between transformations of kets and density matrices."""
+    psi0 = qutip.rand_ket(n_levels)
+    # Generate a random basis
+    _, rand_basis = qutip.rand_dm(n_levels, density=1).eigenstates()
+    rho1 = qutip.ket2dm(psi0).transform(rand_basis, True)
+    rho2 = qutip.ket2dm(psi0.transform(rand_basis, True))
+    assert (rho1 - rho2).norm() < 1e-6
+
+
+def test_eigenbasis_transformation_makes_diagonal_operator():
+    """Check diagonalization via eigenbasis transformation."""
+    cx, cy, cz = np.random.random_sample((3,))
+    H = cx*qutip.sigmax() + cy*qutip.sigmay() + cz*qutip.sigmaz()
+    _, ekets = H.eigenstates()
+    Heb = H.transform(ekets).tidyup()  # Heb should be diagonal
+    assert abs(Heb.full() - np.diag(Heb.full().diagonal())).max() < 1e-6
diff --git a/qutip/tests/test_bloch.py b/qutip/tests/test_bloch.py
index e87517d394..33e8fb2fae 100644
--- a/qutip/tests/test_bloch.py
+++ b/qutip/tests/test_bloch.py
@@ -1,479 +1,479 @@
-import copy
-
-import numpy as np
-import pytest
-
-from qutip.bloch import Bloch
-from qutip import ket, ket2dm
-
-try:
-    import matplotlib.pyplot as plt
-    from matplotlib.testing.decorators import check_figures_equal
-    import IPython
-    check_pngs_equal = check_figures_equal(extensions=["png"])
-except ImportError:
-    plt = None
-    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
-
-
-class RefBloch(Bloch):
-    """ A helper for rendering reference Bloch spheres. """
-    def render(self):
-        raise NotImplementedError("RefBloch disables .render()")
-
-    def render_back(self):
-        old_plot_front = self.plot_front
-        self.plot_front = lambda: None
-        try:
-            Bloch.render(self)
-        finally:
-            self.plot_front = old_plot_front
-
-    def render_front(self):
-        self.plot_front()
-
-
-class TestBloch:
-    def plot_arc_test(self, fig, *args, **kw):
-        b = Bloch(fig=fig)
-        b.add_arc(*args, **kw)
-        b.render()
-
-    def plot_arc_ref(self, fig, start, end, **kw):
-        fmt = kw.pop("fmt", "b")
-        steps = kw.pop("steps", None)
-        start = np.array(start)
-        end = np.array(end)
-        if steps is None:
-            steps = int(np.linalg.norm(start - end) * 100)
-            steps = max(2, steps)
-
-        t = np.linspace(0, 1, steps)
-        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
-        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
-
-        b = RefBloch(fig=fig)
-        b.render_back()
-        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
-        b.render_front()
-
-    @pytest.mark.parametrize([
-        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
-    ], [
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
-        pytest.param(
-            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
-            id="small-radius"),
-        pytest.param(
-            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
-            id="tiny-radius"),
-        pytest.param(
-            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
-            id="large-radius"),
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
-            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
-        ),
-        pytest.param(
-            ket("0"), (0, 0, 1),
-            (ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="kets",
-        ),
-        pytest.param(
-            ket2dm(ket("0")), (0, 0, 1),
-            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="dms",
-        ),
-        pytest.param(
-            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
-            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
-            {}, id="non-unit-dms",
-        ),
-    ])
-    @check_pngs_equal
-    def test_arc(
-        self, start_test, start_ref, end_test, end_ref, kwargs,
-        fig_test, fig_ref,
-    ):
-        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
-        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
-
-    @pytest.mark.parametrize([
-        "start", "end", "err_msg",
-    ], [
-        pytest.param(
-            (0, 0, 0), (0, 1, 0),
-            "Polar and azimuthal angles undefined at origin.",
-            id="start-origin",
-        ),
-        pytest.param(
-            (1, 0, 0), (0, 0, 0),
-            "Polar and azimuthal angles undefined at origin.",
-            id="end-origin",
-        ),
-        pytest.param(
-            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
-            id="different-spheres",
-        ),
-        pytest.param(
-            (1, 0, 0), (1, 0, 0),
-            "Start and end represent the same point. No arc can be formed.",
-            id="same-points",
-        ),
-        pytest.param(
-            (1, 0, 0), (-1, 0, 0),
-            "Start and end are diagonally opposite, no unique arc is"
-            " possible.",
-            id="opposite-points",
-        ),
-    ])
-    def test_arc_errors(self, start, end, err_msg):
-        b = Bloch()
-        with pytest.raises(ValueError) as err:
-            b.add_arc(start, end)
-        assert str(err.value) == err_msg
-
-    def plot_line_test(self, fig, *args, **kw):
-        b = Bloch(fig=fig)
-        b.add_line(*args, **kw)
-        b.render()
-
-    def plot_line_ref(self, fig, start, end, **kw):
-        fmt = kw.pop("fmt", "k")
-
-        x = [start[1], end[1]]
-        y = [-start[0], -end[0]]
-        z = [start[2], end[2]]
-
-        b = RefBloch(fig=fig)
-        b.render_back()
-        b.axes.plot(x, y, z, fmt, **kw)
-        b.render_front()
-
-    @pytest.mark.parametrize([
-        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
-    ], [
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
-        pytest.param(
-            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
-            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
-        ),
-        pytest.param(
-            ket("0"), (0, 0, 1),
-            (ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="kets",
-        ),
-        pytest.param(
-            ket2dm(ket("0")), (0, 0, 1),
-            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
-            {}, id="dms",
-        ),
-        pytest.param(
-            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
-            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
-            {}, id="non-unit-dms",
-        ),
-    ])
-    @check_pngs_equal
-    def test_line(
-        self, start_test, start_ref, end_test, end_ref, kwargs,
-        fig_test, fig_ref,
-    ):
-        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
-        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
-
-    def plot_point_test(self, fig, point_kws):
-        b = Bloch(fig=fig)
-        for kw in point_kws:
-            points = kw.pop("points")
-            b.add_points(points, **kw)
-        b.render()
-
-    def plot_point_ref(self, fig, point_kws):
-        b = RefBloch(fig=fig)
-        b.render_back()
-        point_colors = ['b', 'r', 'g', '#CC6600']
-        point_sizes = [25, 32, 35, 45]
-        point_markers = ["o", "s", "d", "^"]
-
-        for idx, kw in enumerate(point_kws):
-            points = kw.pop("points")
-            if not isinstance(points[0], (list, tuple, np.ndarray)):
-                points = [[points[0]], [points[1]], [points[2]]]
-            points = np.array(points)
-
-            point_style = kw.pop("meth", "s")
-            colors = kw.pop("colors", None)
-            if colors is None and point_style in ['s', 'l']:
-                colors = point_colors[idx % len(point_colors)]
-            elif colors is None and point_style == 'm':
-                colors = np.tile(point_colors,
-                                 np.ceil(points.shape[1]/len(point_colors)
-                                         ).astype(int))
-                colors = colors[:points.shape[1]]
-            point_size = point_sizes[idx % len(point_sizes)]
-            point_marker = point_markers[idx % len(point_markers)]
-            point_alpha = kw.get("alpha", 1.0)
-
-            if len(points[0]) == 1 and point_style == "s":
-                points = np.append(points, points, axis=1)
-
-            if point_style == 's':
-                b.axes.scatter(
-                    np.real(points[1]),
-                    -np.real(points[0]),
-                    np.real(points[2]),
-                    s=point_size,
-                    alpha=point_alpha,
-                    edgecolor=None,
-                    zdir='z',
-                    color=colors,
-                    marker=point_marker)
-            elif point_style == 'l':
-                b.axes.plot(
-                    np.real(points[1]),
-                    -np.real(points[0]),
-                    np.real(points[2]),
-                    alpha=point_alpha,
-                    zdir='z',
-                    color=colors,
-                )
-            elif point_style == 'm':
-                b.axes.scatter(
-                    np.real(points[1]),
-                    -np.real(points[0]),
-                    np.real(points[2]),
-                    s=point_size,
-                    marker=point_marker,
-                    color=colors,
-                    alpha=point_alpha,
-                    edgecolor=None,
-                    zdir='z',
-                )
-            else:
-                raise ValueError(
-                    "Tests currently only support point method 's'"
-                )
-        b.render_front()
-
-    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
-                                                               "scatter",
-                                                               "line",
-                                                               "multicolored"])
-    @pytest.mark.parametrize([
-        "point_kws"
-    ], [
-        pytest.param(
-            dict(points=np.array([
-                [
-                    np.cos(np.pi / 4) * np.cos(t),
-                    np.sin(np.pi / 4) * np.cos(t),
-                    np.sin(t),
-                ]
-                for t in np.linspace(0, 2 * np.pi, 20)
-            ]).T, alpha=0.5), id="circle-of-points"),
-        pytest.param(
-            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
-        pytest.param(
-            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
-        pytest.param(
-            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
-        pytest.param(
-            dict(points=(0, 0, 1)), id="alpha-default"),
-        pytest.param(
-            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
-            id="color-green"),
-        pytest.param([
-            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
-            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
-        ], id="alpha-multiple-point-sets"),
-        pytest.param([
-            dict(points=[(0), (0), (1)], alpha=1.0),
-            dict(points=[(0), (1), (0)], alpha=1.0),
-            dict(points=[(1), (0), (0)], alpha=1.0),
-            dict(points=[(1), (1), (1)], alpha=1.0),
-        ], id="alpha-multiple-point-sets-all_sizes_markers"),
-    ])
-    @check_pngs_equal
-    def test_point(self, point_kws, meth, fig_test, fig_ref):
-        if meth and isinstance(point_kws, dict):
-            point_kws["meth"] = meth
-
-        elif meth and isinstance(point_kws, list):
-            for point_kw in point_kws:
-                point_kw["meth"] = meth
-
-        if isinstance(point_kws, dict):
-            point_kws = [point_kws]
-
-        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
-        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
-
-    def test_point_errors_meth(self):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_points((0, 0, 1), meth='k')
-            b.render()
-
-        err_msg = ("The value for meth = k is not valid."
-                   " Please use 's', 'l' or 'm'.")
-        assert str(err.value) == err_msg
-
-    @pytest.mark.parametrize("points",
-                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
-                              np.arange(12).reshape((3, 2, 2))],
-                             ids=["long_tuple", "short_tuple", "short_list",
-                                  "short_numpy", "wrong_shape_numpy"]
-                             )
-    def test_point_errors_wrong_points(self, points):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_points(points)
-            b.render()
-
-        err_msg = ("The included points are not valid. Points must "
-                   "be equivalent to a 2D array where the first "
-                   "index represents the x,y,z values and the "
-                   "second index iterates over the points.")
-        assert str(err.value) == err_msg
-
-    def plot_vector_test(self, fig, vector_kws):
-        b = Bloch(fig=fig)
-        for kw in vector_kws:
-            vectors = kw.pop("vectors")
-            b.add_vectors(vectors, **kw)
-        b.render()
-
-    def plot_vector_ref(self, fig, vector_kws):
-        from qutip.bloch import Arrow3D
-        b = RefBloch(fig=fig)
-        b.render_back()
-        vector_colors = ['g', '#CC6600', 'b', 'r']
-        idx = 0
-
-        for kw in vector_kws:
-            vectors = kw.pop("vectors")
-
-            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
-                vectors = [vectors]
-
-            colors = kw.pop("colors", None)
-            for k, v in enumerate(vectors):
-                if colors is None:
-                    color = vector_colors[idx % len(vector_colors)]
-                else:
-                    color = colors[k]
-
-                alpha = kw.get("alpha", 1.0)
-                idx += 1
-
-                xs3d = v[1] * np.array([0, 1])
-                ys3d = -v[0] * np.array([0, 1])
-                zs3d = v[2] * np.array([0, 1])
-                a = Arrow3D(
-                    xs3d, ys3d, zs3d,
-                    mutation_scale=20, lw=3, arrowstyle="-|>",
-                    color=color, alpha=alpha)
-                b.axes.add_artist(a)
-        b.render_front()
-
-    @pytest.mark.parametrize([
-        "vector_kws"
-    ], [
-        pytest.param(
-            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
-        pytest.param(
-            dict(vectors=[0, 0, 1]), id="single-vector-list"),
-        pytest.param(
-            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
-        pytest.param(
-            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
-        pytest.param(
-            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
-        pytest.param(
-            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
-        pytest.param(
-            dict(vectors=[
-                [
-                    np.cos(np.pi / 4) * np.cos(t),
-                    np.sin(np.pi / 4) * np.cos(t),
-                    np.sin(t),
-                ]
-                for t in np.linspace(0, 2 * np.pi, 20)
-            ], alpha=0.5), id="circle-of-vectors"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
-        pytest.param(
-            dict(vectors=(0, 0, 1)), id="alpha-default"),
-        pytest.param([
-            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
-            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
-        ], id="alpha-multiple-vector-sets"),
-        pytest.param(
-            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
-        pytest.param(
-            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
-            id="color-two-y"),
-        pytest.param([
-            dict(vectors=[(0, 0, 1)], colors=['y']),
-            dict(vectors=[(1, 0, 1)], colors=['g']),
-        ], id="color-yg"),
-    ])
-    @check_pngs_equal
-    def test_vector(self, vector_kws, fig_test, fig_ref):
-        if isinstance(vector_kws, dict):
-            vector_kws = [vector_kws]
-        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
-        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
-
-    @pytest.mark.parametrize("vectors",
-                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
-                              np.arange(12).reshape((3, 2, 2))],
-                             ids=["long_tuple", "short_tuple", "short_list",
-                                  "short_numpy", "wrong_shape_numpy"]
-                             )
-    def test_vector_errors_wrong_vectors(self, vectors):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_vectors(vectors)
-            b.render()
-
-        err_msg = ("The included vectors are not valid. Vectors must "
-                   "be equivalent to a 2D array where the first "
-                   "index represents the iteration over the vectors and the "
-                   "second index represents the position in 3D of vector "
-                   "head.")
-        assert str(err.value) == err_msg
-
-    @pytest.mark.parametrize("vectors, colors",
-                             [([0, 0, 1], ['g', 'y']),
-                              ([[0, 0, 1], [0, 1, 0]], ['y']),
-                              ([0, 0, 1], [['g', 'y']])],
-                             ids=["one-vec-two-colors", "two-vec-one-color",
-                                  "wrong-dimension-list"]
-                             )
-    def test_vector_errors_color_length(self, vectors, colors):
-        with pytest.raises(ValueError) as err:
-            b = Bloch()
-            b.add_vectors(vectors, colors=colors)
-            b.render()
-
-        err_msg = ("The included colors are not valid. colors must "
-                   "be equivalent to a 1D array with the same "
-                   "size as the number of vectors. ")
-        assert str(err.value) == err_msg
-
-
-def test_repr_svg():
-    pytest.importorskip("matplotlib")
-    pytest.importorskip("ipython")
-    svg = Bloch()._repr_svg_()
-    assert isinstance(svg, str)
-    assert svg.startswith("<?xml")
-    assert svg.endswith("</svg>\n")
+import copy
+
+import numpy as np
+import pytest
+
+from qutip.bloch import Bloch
+from qutip import ket, ket2dm
+
+try:
+    import matplotlib.pyplot as plt
+    from matplotlib.testing.decorators import check_figures_equal
+    import IPython
+    check_pngs_equal = check_figures_equal(extensions=["png"])
+except ImportError:
+    plt = None
+    check_pngs_equal = pytest.mark.skip(reason="matplotlib not installed")
+
+
+class RefBloch(Bloch):
+    """ A helper for rendering reference Bloch spheres. """
+    def render(self):
+        raise NotImplementedError("RefBloch disables .render()")
+
+    def render_back(self):
+        old_plot_front = self.plot_front
+        self.plot_front = lambda: None
+        try:
+            Bloch.render(self)
+        finally:
+            self.plot_front = old_plot_front
+
+    def render_front(self):
+        self.plot_front()
+
+
+class TestBloch:
+    def plot_arc_test(self, fig, *args, **kw):
+        b = Bloch(fig=fig)
+        b.add_arc(*args, **kw)
+        b.render()
+
+    def plot_arc_ref(self, fig, start, end, **kw):
+        fmt = kw.pop("fmt", "b")
+        steps = kw.pop("steps", None)
+        start = np.array(start)
+        end = np.array(end)
+        if steps is None:
+            steps = int(np.linalg.norm(start - end) * 100)
+            steps = max(2, steps)
+
+        t = np.linspace(0, 1, steps)
+        line = start[:, np.newaxis] * t + end[:, np.newaxis] * (1 - t)
+        arc = line * np.linalg.norm(start) / np.linalg.norm(line, axis=0)
+
+        b = RefBloch(fig=fig)
+        b.render_back()
+        b.axes.plot(arc[1, :], -arc[0, :], arc[2, :], fmt, **kw)
+        b.render_front()
+
+    @pytest.mark.parametrize([
+        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
+    ], [
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
+        pytest.param(
+            (0.1, 0, 0), (0.1, 0, 0), (0, 0.1, 0), (0, 0.1, 0), {},
+            id="small-radius"),
+        pytest.param(
+            (1e-5, 0, 0), (1e-5, 0, 0), (0, 1e-5, 0), (0, 1e-5, 0), {},
+            id="tiny-radius"),
+        pytest.param(
+            (1.2, 0, 0), (1.2, 0, 0), (0, 1.2, 0), (0, 1.2, 0), {},
+            id="large-radius"),
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
+            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
+        ),
+        pytest.param(
+            ket("0"), (0, 0, 1),
+            (ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="kets",
+        ),
+        pytest.param(
+            ket2dm(ket("0")), (0, 0, 1),
+            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="dms",
+        ),
+        pytest.param(
+            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
+            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
+            {}, id="non-unit-dms",
+        ),
+    ])
+    @check_pngs_equal
+    def test_arc(
+        self, start_test, start_ref, end_test, end_ref, kwargs,
+        fig_test, fig_ref,
+    ):
+        self.plot_arc_test(fig_test, start_test, end_test, **kwargs)
+        self.plot_arc_ref(fig_ref, start_ref, end_ref, **kwargs)
+
+    @pytest.mark.parametrize([
+        "start", "end", "err_msg",
+    ], [
+        pytest.param(
+            (0, 0, 0), (0, 1, 0),
+            "Polar and azimuthal angles undefined at origin.",
+            id="start-origin",
+        ),
+        pytest.param(
+            (1, 0, 0), (0, 0, 0),
+            "Polar and azimuthal angles undefined at origin.",
+            id="end-origin",
+        ),
+        pytest.param(
+            (0.9, 0, 0), (0, 1, 0), "Points not on the same sphere.",
+            id="different-spheres",
+        ),
+        pytest.param(
+            (1, 0, 0), (1, 0, 0),
+            "Start and end represent the same point. No arc can be formed.",
+            id="same-points",
+        ),
+        pytest.param(
+            (1, 0, 0), (-1, 0, 0),
+            "Start and end are diagonally opposite, no unique arc is"
+            " possible.",
+            id="opposite-points",
+        ),
+    ])
+    def test_arc_errors(self, start, end, err_msg):
+        b = Bloch()
+        with pytest.raises(ValueError) as err:
+            b.add_arc(start, end)
+        assert str(err.value) == err_msg
+
+    def plot_line_test(self, fig, *args, **kw):
+        b = Bloch(fig=fig)
+        b.add_line(*args, **kw)
+        b.render()
+
+    def plot_line_ref(self, fig, start, end, **kw):
+        fmt = kw.pop("fmt", "k")
+
+        x = [start[1], end[1]]
+        y = [-start[0], -end[0]]
+        z = [start[2], end[2]]
+
+        b = RefBloch(fig=fig)
+        b.render_back()
+        b.axes.plot(x, y, z, fmt, **kw)
+        b.render_front()
+
+    @pytest.mark.parametrize([
+        "start_test", "start_ref", "end_test", "end_ref", "kwargs",
+    ], [
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), {}, id="arrays"),
+        pytest.param(
+            (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0),
+            {"fmt": "r", "linestyle": "-"}, id="fmt-and-kwargs",
+        ),
+        pytest.param(
+            ket("0"), (0, 0, 1),
+            (ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="kets",
+        ),
+        pytest.param(
+            ket2dm(ket("0")), (0, 0, 1),
+            ket2dm(ket("0") + ket("1")).unit(), (1, 0, 0),
+            {}, id="dms",
+        ),
+        pytest.param(
+            ket2dm(ket("0")) * 0.5, (0, 0, 0.5),
+            ket2dm(ket("0") + ket("1")).unit() * 0.5, (0.5, 0, 0),
+            {}, id="non-unit-dms",
+        ),
+    ])
+    @check_pngs_equal
+    def test_line(
+        self, start_test, start_ref, end_test, end_ref, kwargs,
+        fig_test, fig_ref,
+    ):
+        self.plot_line_test(fig_test, start_test, end_test, **kwargs)
+        self.plot_line_ref(fig_ref, start_ref, end_ref, **kwargs)
+
+    def plot_point_test(self, fig, point_kws):
+        b = Bloch(fig=fig)
+        for kw in point_kws:
+            points = kw.pop("points")
+            b.add_points(points, **kw)
+        b.render()
+
+    def plot_point_ref(self, fig, point_kws):
+        b = RefBloch(fig=fig)
+        b.render_back()
+        point_colors = ['b', 'r', 'g', '#CC6600']
+        point_sizes = [25, 32, 35, 45]
+        point_markers = ["o", "s", "d", "^"]
+
+        for idx, kw in enumerate(point_kws):
+            points = kw.pop("points")
+            if not isinstance(points[0], (list, tuple, np.ndarray)):
+                points = [[points[0]], [points[1]], [points[2]]]
+            points = np.array(points)
+
+            point_style = kw.pop("meth", "s")
+            colors = kw.pop("colors", None)
+            if colors is None and point_style in ['s', 'l']:
+                colors = point_colors[idx % len(point_colors)]
+            elif colors is None and point_style == 'm':
+                colors = np.tile(point_colors,
+                                 np.ceil(points.shape[1]/len(point_colors)
+                                         ).astype(int))
+                colors = colors[:points.shape[1]]
+            point_size = point_sizes[idx % len(point_sizes)]
+            point_marker = point_markers[idx % len(point_markers)]
+            point_alpha = kw.get("alpha", 1.0)
+
+            if len(points[0]) == 1 and point_style == "s":
+                points = np.append(points, points, axis=1)
+
+            if point_style == 's':
+                b.axes.scatter(
+                    np.real(points[1]),
+                    -np.real(points[0]),
+                    np.real(points[2]),
+                    s=point_size,
+                    alpha=point_alpha,
+                    edgecolor=None,
+                    zdir='z',
+                    color=colors,
+                    marker=point_marker)
+            elif point_style == 'l':
+                b.axes.plot(
+                    np.real(points[1]),
+                    -np.real(points[0]),
+                    np.real(points[2]),
+                    alpha=point_alpha,
+                    zdir='z',
+                    color=colors,
+                )
+            elif point_style == 'm':
+                b.axes.scatter(
+                    np.real(points[1]),
+                    -np.real(points[0]),
+                    np.real(points[2]),
+                    s=point_size,
+                    marker=point_marker,
+                    color=colors,
+                    alpha=point_alpha,
+                    edgecolor=None,
+                    zdir='z',
+                )
+            else:
+                raise ValueError(
+                    "Tests currently only support point method 's'"
+                )
+        b.render_front()
+
+    @pytest.mark.parametrize("meth", ["", "s", "l", "m"], ids=["default",
+                                                               "scatter",
+                                                               "line",
+                                                               "multicolored"])
+    @pytest.mark.parametrize([
+        "point_kws"
+    ], [
+        pytest.param(
+            dict(points=np.array([
+                [
+                    np.cos(np.pi / 4) * np.cos(t),
+                    np.sin(np.pi / 4) * np.cos(t),
+                    np.sin(t),
+                ]
+                for t in np.linspace(0, 2 * np.pi, 20)
+            ]).T, alpha=0.5), id="circle-of-points"),
+        pytest.param(
+            dict(points=(0, 0, 1), alpha=1), id="alpha-opaque"),
+        pytest.param(
+            dict(points=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
+        pytest.param(
+            dict(points=(0, 0, 1), alpha=0), id="alpha-invisible"),
+        pytest.param(
+            dict(points=(0, 0, 1)), id="alpha-default"),
+        pytest.param(
+            dict(points=[(0, 0), (0, 1), (1, 0)], colors='g'),
+            id="color-green"),
+        pytest.param([
+            dict(points=[(0, 0), (0, 1), (1, 0)], alpha=1.0),
+            dict(points=[(1, 1), (0, 1), (1, 0)], alpha=0.5),
+        ], id="alpha-multiple-point-sets"),
+        pytest.param([
+            dict(points=[(0), (0), (1)], alpha=1.0),
+            dict(points=[(0), (1), (0)], alpha=1.0),
+            dict(points=[(1), (0), (0)], alpha=1.0),
+            dict(points=[(1), (1), (1)], alpha=1.0),
+        ], id="alpha-multiple-point-sets-all_sizes_markers"),
+    ])
+    @check_pngs_equal
+    def test_point(self, point_kws, meth, fig_test, fig_ref):
+        if meth and isinstance(point_kws, dict):
+            point_kws["meth"] = meth
+
+        elif meth and isinstance(point_kws, list):
+            for point_kw in point_kws:
+                point_kw["meth"] = meth
+
+        if isinstance(point_kws, dict):
+            point_kws = [point_kws]
+
+        self.plot_point_test(fig_test, copy.deepcopy(point_kws))
+        self.plot_point_ref(fig_ref, copy.deepcopy(point_kws))
+
+    def test_point_errors_meth(self):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_points((0, 0, 1), meth='k')
+            b.render()
+
+        err_msg = ("The value for meth = k is not valid."
+                   " Please use 's', 'l' or 'm'.")
+        assert str(err.value) == err_msg
+
+    @pytest.mark.parametrize("points",
+                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
+                              np.arange(12).reshape((3, 2, 2))],
+                             ids=["long_tuple", "short_tuple", "short_list",
+                                  "short_numpy", "wrong_shape_numpy"]
+                             )
+    def test_point_errors_wrong_points(self, points):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_points(points)
+            b.render()
+
+        err_msg = ("The included points are not valid. Points must "
+                   "be equivalent to a 2D array where the first "
+                   "index represents the x,y,z values and the "
+                   "second index iterates over the points.")
+        assert str(err.value) == err_msg
+
+    def plot_vector_test(self, fig, vector_kws):
+        b = Bloch(fig=fig)
+        for kw in vector_kws:
+            vectors = kw.pop("vectors")
+            b.add_vectors(vectors, **kw)
+        b.render()
+
+    def plot_vector_ref(self, fig, vector_kws):
+        from qutip.bloch import Arrow3D
+        b = RefBloch(fig=fig)
+        b.render_back()
+        vector_colors = ['g', '#CC6600', 'b', 'r']
+        idx = 0
+
+        for kw in vector_kws:
+            vectors = kw.pop("vectors")
+
+            if not isinstance(vectors[0], (list, tuple, np.ndarray)):
+                vectors = [vectors]
+
+            colors = kw.pop("colors", None)
+            for k, v in enumerate(vectors):
+                if colors is None:
+                    color = vector_colors[idx % len(vector_colors)]
+                else:
+                    color = colors[k]
+
+                alpha = kw.get("alpha", 1.0)
+                idx += 1
+
+                xs3d = v[1] * np.array([0, 1])
+                ys3d = -v[0] * np.array([0, 1])
+                zs3d = v[2] * np.array([0, 1])
+                a = Arrow3D(
+                    xs3d, ys3d, zs3d,
+                    mutation_scale=20, lw=3, arrowstyle="-|>",
+                    color=color, alpha=alpha)
+                b.axes.add_artist(a)
+        b.render_front()
+
+    @pytest.mark.parametrize([
+        "vector_kws"
+    ], [
+        pytest.param(
+            dict(vectors=(0, 0, 1)), id="single-vector-tuple"),
+        pytest.param(
+            dict(vectors=[0, 0, 1]), id="single-vector-list"),
+        pytest.param(
+            dict(vectors=np.array([0, 0, 1])), id="single-vector-numpy"),
+        pytest.param(
+            dict(vectors=[(0, 0, 1), (0, 1, 0)]), id="list-vectors-tuple"),
+        pytest.param(
+            dict(vectors=[[0, 0, 1]]), id="list-vectors-list"),
+        pytest.param(
+            dict(vectors=[np.array([0, 0, 1])]), id="list-vectors-numpy"),
+        pytest.param(
+            dict(vectors=[
+                [
+                    np.cos(np.pi / 4) * np.cos(t),
+                    np.sin(np.pi / 4) * np.cos(t),
+                    np.sin(t),
+                ]
+                for t in np.linspace(0, 2 * np.pi, 20)
+            ], alpha=0.5), id="circle-of-vectors"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), alpha=1), id="alpha-opaque"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), alpha=0.3), id="alpha-transparent"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), alpha=0), id="alpha-invisible"),
+        pytest.param(
+            dict(vectors=(0, 0, 1)), id="alpha-default"),
+        pytest.param([
+            dict(vectors=[(0, 0, 1), (0, 1, 0)], alpha=1.0),
+            dict(vectors=[(1, 0, 1), (1, 1, 0)], alpha=0.5),
+        ], id="alpha-multiple-vector-sets"),
+        pytest.param(
+            dict(vectors=(0, 0, 1), colors=['y']), id="color-y"),
+        pytest.param(
+            dict(vectors=[(0, 0, 1), (0, 1, 0)], colors=['y', 'y']),
+            id="color-two-y"),
+        pytest.param([
+            dict(vectors=[(0, 0, 1)], colors=['y']),
+            dict(vectors=[(1, 0, 1)], colors=['g']),
+        ], id="color-yg"),
+    ])
+    @check_pngs_equal
+    def test_vector(self, vector_kws, fig_test, fig_ref):
+        if isinstance(vector_kws, dict):
+            vector_kws = [vector_kws]
+        self.plot_vector_test(fig_test, copy.deepcopy(vector_kws))
+        self.plot_vector_ref(fig_ref, copy.deepcopy(vector_kws))
+
+    @pytest.mark.parametrize("vectors",
+                             [(0, 1, 0, 1), (0, 1), [0, 1], np.array((0, 1)),
+                              np.arange(12).reshape((3, 2, 2))],
+                             ids=["long_tuple", "short_tuple", "short_list",
+                                  "short_numpy", "wrong_shape_numpy"]
+                             )
+    def test_vector_errors_wrong_vectors(self, vectors):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_vectors(vectors)
+            b.render()
+
+        err_msg = ("The included vectors are not valid. Vectors must "
+                   "be equivalent to a 2D array where the first "
+                   "index represents the iteration over the vectors and the "
+                   "second index represents the position in 3D of vector "
+                   "head.")
+        assert str(err.value) == err_msg
+
+    @pytest.mark.parametrize("vectors, colors",
+                             [([0, 0, 1], ['g', 'y']),
+                              ([[0, 0, 1], [0, 1, 0]], ['y']),
+                              ([0, 0, 1], [['g', 'y']])],
+                             ids=["one-vec-two-colors", "two-vec-one-color",
+                                  "wrong-dimension-list"]
+                             )
+    def test_vector_errors_color_length(self, vectors, colors):
+        with pytest.raises(ValueError) as err:
+            b = Bloch()
+            b.add_vectors(vectors, colors=colors)
+            b.render()
+
+        err_msg = ("The included colors are not valid. colors must "
+                   "be equivalent to a 1D array with the same "
+                   "size as the number of vectors. ")
+        assert str(err.value) == err_msg
+
+
+def test_repr_svg():
+    pytest.importorskip("matplotlib")
+    pytest.importorskip("ipython")
+    svg = Bloch()._repr_svg_()
+    assert isinstance(svg, str)
+    assert svg.startswith("<?xml")
+    assert svg.endswith("</svg>\n")
diff --git a/qutip/tests/test_enr_state_operator.py b/qutip/tests/test_enr_state_operator.py
index d07b7ebbec..9002c3759b 100644
--- a/qutip/tests/test_enr_state_operator.py
+++ b/qutip/tests/test_enr_state_operator.py
@@ -1,116 +1,116 @@
-import pytest
-import itertools
-import random
-import numpy as np
-import qutip
-
-
-def _n_enr_states(dimensions, n_excitations):
-    """
-    Calculate the total number of distinct ENR states for a given set of
-    subspaces.  This method is not intended to be fast or efficient, it's
-    intended to be obviously correct for testing purposes.
-    """
-    count = 0
-    for excitations in itertools.product(*map(range, dimensions)):
-        count += int(sum(excitations) <= n_excitations)
-    return count
-
-
-@pytest.fixture(params=[
-    pytest.param([4], id="single"),
-    pytest.param([4]*2, id="tensor-equal-2"),
-    pytest.param([4]*3, id="tensor-equal-3"),
-    pytest.param([4]*4, id="tensor-equal-4"),
-    pytest.param([2, 3, 4], id="tensor-not-equal"),
-])
-def dimensions(request):
-    return request.param
-
-
-@pytest.fixture(params=[1, 2, 3, 1_000_000])
-def n_excitations(request):
-    return request.param
-
-
-class TestOperator:
-    def test_no_restrictions(self, dimensions):
-        """
-        Test that the restricted-excitation operators are equal to the standard
-        operators when there aren't any restrictions.
-        """
-        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
-        a = [qutip.destroy(n) for n in dimensions]
-        iden = [qutip.qeye(n) for n in dimensions]
-        for i, test in enumerate(test_operators):
-            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
-            assert test == expected
-            assert test.dims == [dimensions, dimensions]
-
-    def test_space_size_reduction(self, dimensions, n_excitations):
-        test_operators = qutip.enr_destroy(dimensions, n_excitations)
-        expected_size = _n_enr_states(dimensions, n_excitations)
-        expected_shape = (expected_size, expected_size)
-        for test in test_operators:
-            assert test.shape == expected_shape
-            assert test.dims == [dimensions, dimensions]
-
-    def test_identity(self, dimensions, n_excitations):
-        iden = qutip.enr_identity(dimensions, n_excitations)
-        expected_size = _n_enr_states(dimensions, n_excitations)
-        expected_shape = (expected_size, expected_size)
-        assert np.all(iden.diag() == 1)
-        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
-        assert iden.shape == expected_shape
-        assert iden.dims == [dimensions, dimensions]
-
-
-def test_fock_state(dimensions, n_excitations):
-    """
-    Test Fock state creation agrees with the number operators implied by the
-    existence of the ENR annihiliation operators.
-    """
-    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
-    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
-    n_samples = min((len(bases), 5))
-    for basis in random.sample(bases, n_samples):
-        state = qutip.enr_fock(dimensions, n_excitations, basis)
-        for n, x in zip(number, basis):
-            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
-
-
-def test_fock_state_error():
-    with pytest.raises(ValueError) as e:
-        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
-    assert str(e.value).startswith("The state tuple ")
-
-
-def _reference_dm(dimensions, n_excitations, nbars):
-    """
-    Get the reference density matrix explicitly, to compare to the direct ENR
-    construction.
-    """
-    if np.isscalar(nbars):
-        nbars = [nbars] * len(dimensions)
-    keep = np.array([
-        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
-        if sum(state) <= n_excitations
-    ])
-    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
-                       for dimension, nbar in zip(dimensions, nbars)])
-    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
-    return out / out.tr()
-
-
-@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
-def test_thermal_dm(dimensions, n_excitations, nbar_type):
-    # Ensure that the average number of excitations over all the states is
-    # much less than the total number of allowed excitations.
-    if nbar_type == "scalar":
-        nbars = 0.1 * n_excitations / len(dimensions)
-    else:
-        nbars = np.random.rand(len(dimensions))
-        nbars *= (0.1 * n_excitations) / np.sum(nbars)
-    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
-    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
-    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
+import pytest
+import itertools
+import random
+import numpy as np
+import qutip
+
+
+def _n_enr_states(dimensions, n_excitations):
+    """
+    Calculate the total number of distinct ENR states for a given set of
+    subspaces.  This method is not intended to be fast or efficient, it's
+    intended to be obviously correct for testing purposes.
+    """
+    count = 0
+    for excitations in itertools.product(*map(range, dimensions)):
+        count += int(sum(excitations) <= n_excitations)
+    return count
+
+
+@pytest.fixture(params=[
+    pytest.param([4], id="single"),
+    pytest.param([4]*2, id="tensor-equal-2"),
+    pytest.param([4]*3, id="tensor-equal-3"),
+    pytest.param([4]*4, id="tensor-equal-4"),
+    pytest.param([2, 3, 4], id="tensor-not-equal"),
+])
+def dimensions(request):
+    return request.param
+
+
+@pytest.fixture(params=[1, 2, 3, 1_000_000])
+def n_excitations(request):
+    return request.param
+
+
+class TestOperator:
+    def test_no_restrictions(self, dimensions):
+        """
+        Test that the restricted-excitation operators are equal to the standard
+        operators when there aren't any restrictions.
+        """
+        test_operators = qutip.enr_destroy(dimensions, sum(dimensions))
+        a = [qutip.destroy(n) for n in dimensions]
+        iden = [qutip.qeye(n) for n in dimensions]
+        for i, test in enumerate(test_operators):
+            expected = qutip.tensor(iden[:i] + [a[i]] + iden[i+1:])
+            assert test == expected
+            assert test.dims == [dimensions, dimensions]
+
+    def test_space_size_reduction(self, dimensions, n_excitations):
+        test_operators = qutip.enr_destroy(dimensions, n_excitations)
+        expected_size = _n_enr_states(dimensions, n_excitations)
+        expected_shape = (expected_size, expected_size)
+        for test in test_operators:
+            assert test.shape == expected_shape
+            assert test.dims == [dimensions, dimensions]
+
+    def test_identity(self, dimensions, n_excitations):
+        iden = qutip.enr_identity(dimensions, n_excitations)
+        expected_size = _n_enr_states(dimensions, n_excitations)
+        expected_shape = (expected_size, expected_size)
+        assert np.all(iden.diag() == 1)
+        assert np.all(iden.full() - np.diag(iden.diag()) == 0)
+        assert iden.shape == expected_shape
+        assert iden.dims == [dimensions, dimensions]
+
+
+def test_fock_state(dimensions, n_excitations):
+    """
+    Test Fock state creation agrees with the number operators implied by the
+    existence of the ENR annihiliation operators.
+    """
+    number = [a.dag()*a for a in qutip.enr_destroy(dimensions, n_excitations)]
+    bases = list(qutip.state_number_enumerate(dimensions, n_excitations))
+    n_samples = min((len(bases), 5))
+    for basis in random.sample(bases, n_samples):
+        state = qutip.enr_fock(dimensions, n_excitations, basis)
+        for n, x in zip(number, basis):
+            assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
+
+
+def test_fock_state_error():
+    with pytest.raises(ValueError) as e:
+        state = qutip.enr_fock([2, 2, 2], 1, [1, 1, 1])
+    assert str(e.value).startswith("The state tuple ")
+
+
+def _reference_dm(dimensions, n_excitations, nbars):
+    """
+    Get the reference density matrix explicitly, to compare to the direct ENR
+    construction.
+    """
+    if np.isscalar(nbars):
+        nbars = [nbars] * len(dimensions)
+    keep = np.array([
+        i for i, state in enumerate(qutip.state_number_enumerate(dimensions))
+        if sum(state) <= n_excitations
+    ])
+    dm = qutip.tensor([qutip.thermal_dm(dimension, nbar)
+                       for dimension, nbar in zip(dimensions, nbars)])
+    out = qutip.Qobj(dm.full()[keep[:, None], keep[None, :]])
+    return out / out.tr()
+
+
+@pytest.mark.parametrize("nbar_type", ["scalar", "vector"])
+def test_thermal_dm(dimensions, n_excitations, nbar_type):
+    # Ensure that the average number of excitations over all the states is
+    # much less than the total number of allowed excitations.
+    if nbar_type == "scalar":
+        nbars = 0.1 * n_excitations / len(dimensions)
+    else:
+        nbars = np.random.rand(len(dimensions))
+        nbars *= (0.1 * n_excitations) / np.sum(nbars)
+    test_dm = qutip.enr_thermal_dm(dimensions, n_excitations, nbars)
+    expect_dm = _reference_dm(dimensions, n_excitations, nbars)
+    np.testing.assert_allclose(test_dm.full(), expect_dm.full(), atol=1e-12)
diff --git a/qutip/tests/test_entropy.py b/qutip/tests/test_entropy.py
index ea0f0c3543..ecf465c9bf 100644
--- a/qutip/tests/test_entropy.py
+++ b/qutip/tests/test_entropy.py
@@ -1,212 +1,212 @@
-import pytest
-import numpy as np
-import qutip
-
-
-class TestVonNeumannEntropy:
-    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
-    def test_binary(self, p):
-        dm = qutip.qdiags([p, 1 - p], 0)
-        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
-        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
-
-    @pytest.mark.repeat(10)
-    def test_pure_state(self):
-        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
-
-
-class TestLinearEntropy:
-    @pytest.mark.repeat(10)
-    def test_less_than_von_neumann(self):
-        dm = qutip.rand_dm(10)
-        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
-
-    @pytest.mark.repeat(10)
-    def test_pure_state(self):
-        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
-
-
-class TestConcurrence:
-    @pytest.mark.parametrize("dm", [
-        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
-        for x in ['00', '01', '10', '11']
-    ])
-    def test_maximally_entangled(self, dm):
-        assert abs(qutip.concurrence(dm) - 1) < 1e-12
-
-    @pytest.mark.repeat(10)
-    def test_nonzero(self):
-        dm = qutip.rand_dm([2, 2])
-        assert qutip.concurrence(dm) >= 0
-
-
-@pytest.mark.repeat(10)
-class TestMutualInformation:
-    def test_pure_state_additive(self):
-        # Verify mutual information = S(A) + S(B) for pure states.
-        dm = qutip.rand_dm([5, 5], distribution="pure")
-        expect = (qutip.entropy_vn(dm.ptrace(0))
-                  + qutip.entropy_vn(dm.ptrace(1)))
-        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
-
-    def test_component_selection(self):
-        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
-        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
-                  + qutip.entropy_vn(dm.ptrace(1)))
-        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
-
-
-class TestRelativeEntropy:
-    def _simple_relative_entropy_implementation(
-            self, rho, sigma, log_base=np.log, tol=1e-12):
-        """ A simplified relative entropy implementation for use in
-            double-checking the optimised implementation within
-            QuTiP itself.
-        """
-        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
-        rvals, rvecs = rho.eigenstates()
-        svals, svecs = sigma.eigenstates()
-        rvecs = np.hstack([vec.full() for vec in rvecs]).T
-        svecs = np.hstack([vec.full() for vec in svecs]).T
-        # Calculate S
-        S = 0
-        for i in range(len(rvals)):
-            if abs(rvals[i]) >= tol:
-                S += rvals[i] * log_base(rvals[i])
-            for j in range(len(svals)):
-                P_ij = (
-                    np.dot(rvecs[i], svecs[j].conjugate()) *
-                    np.dot(svecs[j], rvecs[i].conjugate())
-                )
-                if abs(svals[j]) < tol and not (
-                        abs(rvals[i]) < tol or abs(P_ij) < tol):
-                    # kernel of sigma intersects support of rho
-                    return np.inf
-                if abs(svals[j]) >= tol:
-                    S -= rvals[i] * P_ij * log_base(svals[j])
-        return np.real(S)
-
-    def test_rho_or_sigma_not_oper(self):
-        rho = qutip.bra("00")
-        sigma = qutip.bra("01")
-        with pytest.raises(TypeError) as exc:
-            qutip.entropy_relative(rho.dag(), sigma)
-        assert str(exc.value) == "Inputs must be density matrices."
-        with pytest.raises(TypeError) as exc:
-            qutip.entropy_relative(rho, sigma.dag())
-        assert str(exc.value) == "Inputs must be density matrices."
-        with pytest.raises(TypeError) as exc:
-            qutip.entropy_relative(rho, sigma)
-        assert str(exc.value) == "Inputs must be density matrices."
-
-    def test_rho_and_sigma_have_different_shape_and_dims(self):
-        # test different shape and dims
-        rho = qutip.ket("00")
-        sigma = qutip.ket("0")
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma)
-        assert str(exc.value) == "Inputs must have the same shape and dims."
-        # test same shape, difference dims
-        rho = qutip.basis([2, 3], [0, 0])
-        sigma = qutip.basis([3, 2], [0, 0])
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma)
-        assert str(exc.value) == "Inputs must have the same shape and dims."
-
-    def test_base_not_2_or_e(self):
-        rho = qutip.ket("00")
-        sigma = qutip.ket("01")
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma, base=3)
-        assert str(exc.value) == "Base must be 2 or e."
-
-    def test_infinite_relative_entropy(self):
-        rho = qutip.ket("00")
-        sigma = qutip.ket("01")
-        assert qutip.entropy_relative(rho, sigma) == np.inf
-
-    def test_base_2_or_e(self):
-        rho = qutip.ket2dm(qutip.ket("00"))
-        sigma = rho + qutip.ket2dm(qutip.ket("01"))
-        sigma = sigma.unit()
-        assert (
-            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
-        )
-        assert (
-            qutip.entropy_relative(rho, sigma, base=np.e)
-            == pytest.approx(0.69314718)
-        )
-        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
-
-    def test_pure_vs_maximally_mixed_state(self):
-        rho = qutip.ket("00")
-        sigma = sum(
-            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
-        ).unit()
-        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
-
-    def test_density_matrices_with_non_real_eigenvalues(self):
-        rho = qutip.ket2dm(qutip.ket("00"))
-        sigma = qutip.ket2dm(qutip.ket("01"))
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho + 1j, sigma)
-        assert str(exc.value) == "Input rho has non-real eigenvalues."
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho - 1j, sigma)
-        assert str(exc.value) == "Input rho has non-real eigenvalues."
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma + 1j)
-        assert str(exc.value) == "Input sigma has non-real eigenvalues."
-        with pytest.raises(ValueError) as exc:
-            qutip.entropy_relative(rho, sigma - 1j)
-        assert str(exc.value) == "Input sigma has non-real eigenvalues."
-
-    @pytest.mark.repeat(20)
-    def test_random_dm_with_self(self):
-        rho = qutip.rand_dm(8)
-        rel = qutip.entropy_relative(rho, rho)
-        assert abs(rel) < 1e-13
-
-    @pytest.mark.repeat(20)
-    def test_random_rho_sigma(self):
-        rho = qutip.rand_dm(8)
-        sigma = qutip.rand_dm(8)
-        rel = qutip.entropy_relative(rho, sigma)
-        assert rel >= 0
-        assert rel == pytest.approx(
-            self._simple_relative_entropy_implementation(rho, sigma, np.log)
-        )
-
-
-@pytest.mark.repeat(20)
-class TestConditionalEntropy:
-    def test_inequality_3_qubits(self):
-        # S(A | B,C) <= S(A|B)
-        full = qutip.rand_dm([2]*3, distribution="pure")
-        ab = full.ptrace([0, 1])
-        assert (qutip.entropy_conditional(full, [1, 2])
-                <= qutip.entropy_conditional(ab, 1))
-
-    def test_triangle_inequality_4_qubits(self):
-        # S(A,B | C,D) <= S(A|C) + S(B|D)
-        full = qutip.rand_dm([2]*4, distribution="pure")
-        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
-        assert (qutip.entropy_conditional(full, [2, 3])
-                <= (qutip.entropy_conditional(ac, 1)
-                    + qutip.entropy_conditional(bd, 1)))
-
-
-_alpha = 2*np.pi * np.random.rand()
-
-
-@pytest.mark.parametrize(["gate", "expected"], [
-    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
-    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
-    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
-    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
-    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
-    pytest.param(qutip.gates.swapalpha(_alpha),
-                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
-])
-def test_entangling_power(gate, expected):
-    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
+import pytest
+import numpy as np
+import qutip
+
+
+class TestVonNeumannEntropy:
+    @pytest.mark.parametrize("p", np.linspace(0, 1, 17))
+    def test_binary(self, p):
+        dm = qutip.qdiags([p, 1 - p], 0)
+        expected = 0 if p in [0, 1] else p*np.log2(p) + (1-p)*np.log2(1-p)
+        assert abs(-qutip.entropy_vn(dm, 2) - expected) < 1e-12
+
+    @pytest.mark.repeat(10)
+    def test_pure_state(self):
+        assert abs(qutip.entropy_vn(qutip.rand_ket(10))) < 1e-12
+
+
+class TestLinearEntropy:
+    @pytest.mark.repeat(10)
+    def test_less_than_von_neumann(self):
+        dm = qutip.rand_dm(10)
+        assert qutip.entropy_linear(dm) <= qutip.entropy_vn(dm)
+
+    @pytest.mark.repeat(10)
+    def test_pure_state(self):
+        assert abs(qutip.entropy_linear(qutip.rand_ket(10))) < 1e-12
+
+
+class TestConcurrence:
+    @pytest.mark.parametrize("dm", [
+        pytest.param(qutip.bell_state(x).proj(), id='bell'+x)
+        for x in ['00', '01', '10', '11']
+    ])
+    def test_maximally_entangled(self, dm):
+        assert abs(qutip.concurrence(dm) - 1) < 1e-12
+
+    @pytest.mark.repeat(10)
+    def test_nonzero(self):
+        dm = qutip.rand_dm([2, 2])
+        assert qutip.concurrence(dm) >= 0
+
+
+@pytest.mark.repeat(10)
+class TestMutualInformation:
+    def test_pure_state_additive(self):
+        # Verify mutual information = S(A) + S(B) for pure states.
+        dm = qutip.rand_dm([5, 5], distribution="pure")
+        expect = (qutip.entropy_vn(dm.ptrace(0))
+                  + qutip.entropy_vn(dm.ptrace(1)))
+        assert abs(qutip.entropy_mutual(dm, [0], [1]) - expect) < 1e-13
+
+    def test_component_selection(self):
+        dm = qutip.rand_dm([2, 2, 2], distribution="pure")
+        expect = (qutip.entropy_vn(dm.ptrace([0, 2]))
+                  + qutip.entropy_vn(dm.ptrace(1)))
+        assert abs(qutip.entropy_mutual(dm, [0, 2], [1]) - expect) < 1e-13
+
+
+class TestRelativeEntropy:
+    def _simple_relative_entropy_implementation(
+            self, rho, sigma, log_base=np.log, tol=1e-12):
+        """ A simplified relative entropy implementation for use in
+            double-checking the optimised implementation within
+            QuTiP itself.
+        """
+        # S(rho || sigma) = sum_i(p_i log p_i) - sum_ij(p_i P_ij log q_i)
+        rvals, rvecs = rho.eigenstates()
+        svals, svecs = sigma.eigenstates()
+        rvecs = np.hstack([vec.full() for vec in rvecs]).T
+        svecs = np.hstack([vec.full() for vec in svecs]).T
+        # Calculate S
+        S = 0
+        for i in range(len(rvals)):
+            if abs(rvals[i]) >= tol:
+                S += rvals[i] * log_base(rvals[i])
+            for j in range(len(svals)):
+                P_ij = (
+                    np.dot(rvecs[i], svecs[j].conjugate()) *
+                    np.dot(svecs[j], rvecs[i].conjugate())
+                )
+                if abs(svals[j]) < tol and not (
+                        abs(rvals[i]) < tol or abs(P_ij) < tol):
+                    # kernel of sigma intersects support of rho
+                    return np.inf
+                if abs(svals[j]) >= tol:
+                    S -= rvals[i] * P_ij * log_base(svals[j])
+        return np.real(S)
+
+    def test_rho_or_sigma_not_oper(self):
+        rho = qutip.bra("00")
+        sigma = qutip.bra("01")
+        with pytest.raises(TypeError) as exc:
+            qutip.entropy_relative(rho.dag(), sigma)
+        assert str(exc.value) == "Inputs must be density matrices."
+        with pytest.raises(TypeError) as exc:
+            qutip.entropy_relative(rho, sigma.dag())
+        assert str(exc.value) == "Inputs must be density matrices."
+        with pytest.raises(TypeError) as exc:
+            qutip.entropy_relative(rho, sigma)
+        assert str(exc.value) == "Inputs must be density matrices."
+
+    def test_rho_and_sigma_have_different_shape_and_dims(self):
+        # test different shape and dims
+        rho = qutip.ket("00")
+        sigma = qutip.ket("0")
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma)
+        assert str(exc.value) == "Inputs must have the same shape and dims."
+        # test same shape, difference dims
+        rho = qutip.basis([2, 3], [0, 0])
+        sigma = qutip.basis([3, 2], [0, 0])
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma)
+        assert str(exc.value) == "Inputs must have the same shape and dims."
+
+    def test_base_not_2_or_e(self):
+        rho = qutip.ket("00")
+        sigma = qutip.ket("01")
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma, base=3)
+        assert str(exc.value) == "Base must be 2 or e."
+
+    def test_infinite_relative_entropy(self):
+        rho = qutip.ket("00")
+        sigma = qutip.ket("01")
+        assert qutip.entropy_relative(rho, sigma) == np.inf
+
+    def test_base_2_or_e(self):
+        rho = qutip.ket2dm(qutip.ket("00"))
+        sigma = rho + qutip.ket2dm(qutip.ket("01"))
+        sigma = sigma.unit()
+        assert (
+            qutip.entropy_relative(rho, sigma) == pytest.approx(np.log(2))
+        )
+        assert (
+            qutip.entropy_relative(rho, sigma, base=np.e)
+            == pytest.approx(0.69314718)
+        )
+        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(1)
+
+    def test_pure_vs_maximally_mixed_state(self):
+        rho = qutip.ket("00")
+        sigma = sum(
+            qutip.ket2dm(qutip.ket(psi)) for psi in ["00", "01", "10", "11"]
+        ).unit()
+        assert qutip.entropy_relative(rho, sigma, base=2) == pytest.approx(2)
+
+    def test_density_matrices_with_non_real_eigenvalues(self):
+        rho = qutip.ket2dm(qutip.ket("00"))
+        sigma = qutip.ket2dm(qutip.ket("01"))
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho + 1j, sigma)
+        assert str(exc.value) == "Input rho has non-real eigenvalues."
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho - 1j, sigma)
+        assert str(exc.value) == "Input rho has non-real eigenvalues."
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma + 1j)
+        assert str(exc.value) == "Input sigma has non-real eigenvalues."
+        with pytest.raises(ValueError) as exc:
+            qutip.entropy_relative(rho, sigma - 1j)
+        assert str(exc.value) == "Input sigma has non-real eigenvalues."
+
+    @pytest.mark.repeat(20)
+    def test_random_dm_with_self(self):
+        rho = qutip.rand_dm(8)
+        rel = qutip.entropy_relative(rho, rho)
+        assert abs(rel) < 1e-13
+
+    @pytest.mark.repeat(20)
+    def test_random_rho_sigma(self):
+        rho = qutip.rand_dm(8)
+        sigma = qutip.rand_dm(8)
+        rel = qutip.entropy_relative(rho, sigma)
+        assert rel >= 0
+        assert rel == pytest.approx(
+            self._simple_relative_entropy_implementation(rho, sigma, np.log)
+        )
+
+
+@pytest.mark.repeat(20)
+class TestConditionalEntropy:
+    def test_inequality_3_qubits(self):
+        # S(A | B,C) <= S(A|B)
+        full = qutip.rand_dm([2]*3, distribution="pure")
+        ab = full.ptrace([0, 1])
+        assert (qutip.entropy_conditional(full, [1, 2])
+                <= qutip.entropy_conditional(ab, 1))
+
+    def test_triangle_inequality_4_qubits(self):
+        # S(A,B | C,D) <= S(A|C) + S(B|D)
+        full = qutip.rand_dm([2]*4, distribution="pure")
+        ac, bd = full.ptrace([0, 2]), full.ptrace([1, 3])
+        assert (qutip.entropy_conditional(full, [2, 3])
+                <= (qutip.entropy_conditional(ac, 1)
+                    + qutip.entropy_conditional(bd, 1)))
+
+
+_alpha = 2*np.pi * np.random.rand()
+
+
+@pytest.mark.parametrize(["gate", "expected"], [
+    pytest.param(qutip.gates.cnot(), 2/9, id="CNOT"),
+    pytest.param(qutip.gates.iswap(), 2/9, id="ISWAP"),
+    pytest.param(qutip.gates.berkeley(), 2/9, id="Berkeley"),
+    pytest.param(qutip.gates.swap(), 0, id="SWAP"),
+    pytest.param(qutip.gates.sqrtswap(), 1/6, id="sqrt(SWAP)"),
+    pytest.param(qutip.gates.swapalpha(_alpha),
+                 np.sin(np.pi*_alpha)**2 / 6, id="SWAP(alpha)"),
+])
+def test_entangling_power(gate, expected):
+    assert abs(qutip.entangling_power(gate) - expected) < 1e-12
diff --git a/qutip/tests/test_fileio.py b/qutip/tests/test_fileio.py
index 13e2045893..7433760684 100644
--- a/qutip/tests/test_fileio.py
+++ b/qutip/tests/test_fileio.py
@@ -1,62 +1,62 @@
-import pytest
-import numpy as np
-import uuid
-import qutip
-from pathlib import Path
-
-# qsave _always_ appends a suffix to the file name at the time of writing, but
-# in case this changes in the future, to ensure that we never leak a temporary
-# file into the user's folders, we simply apply these tests in a temporary
-# directory.  Windows also does not allow temporary files to be opened multiple
-# times, so using a temporary directory is best.
-pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
-
-_dimension = 10
-
-
-def _random_file_name():
-    return "_" + str(uuid.uuid4())
-
-
-class Test_file_data_store_file_data_read:
-    # Tests parametrised seprately to give nicer descriptions in verbose mode.
-
-    def case(self, filename, kwargs):
-        data = 1 - 2*np.random.rand(_dimension, _dimension)
-        if kwargs.get('numtype', 'complex') == 'complex':
-            data = data * (0.5*0.5j)
-        qutip.file_data_store(filename, data, **kwargs)
-        out = qutip.file_data_read(filename)
-        np.testing.assert_allclose(data, out, atol=1e-8)
-
-    def test_defaults(self):
-        return self.case(_random_file_name(), {})
-
-    @pytest.mark.parametrize("type_", ["real", "complex"])
-    @pytest.mark.parametrize("format_", ["decimal", "exp"])
-    def test_type_format(self, type_, format_):
-
-        kwargs = {'numtype': type_, 'numformat': format_}
-        return self.case(_random_file_name(), kwargs)
-
-    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
-                             ids=lambda x: "'" + x + "'")
-    def test_separator_detection(self, separator):
-        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
-        return self.case(_random_file_name(), kwargs)
-
-
-@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
-@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
-def test_qsave_qload(use_path, suffix):
-    ops_in = [qutip.sigmax(),
-              qutip.num(_dimension),
-              qutip.coherent_dm(_dimension, 1j)]
-    filename = _random_file_name() + suffix
-    if use_path:
-        filename = Path.cwd() / filename
-    qutip.qsave(ops_in, filename)
-    ops_out = qutip.qload(filename)
-    assert ops_in == ops_out
-    # check that the file was saved with the correct name:
-    assert Path(str(filename) + ".qu").exists()
+import pytest
+import numpy as np
+import uuid
+import qutip
+from pathlib import Path
+
+# qsave _always_ appends a suffix to the file name at the time of writing, but
+# in case this changes in the future, to ensure that we never leak a temporary
+# file into the user's folders, we simply apply these tests in a temporary
+# directory.  Windows also does not allow temporary files to be opened multiple
+# times, so using a temporary directory is best.
+pytestmark = [pytest.mark.usefixtures("in_temporary_directory")]
+
+_dimension = 10
+
+
+def _random_file_name():
+    return "_" + str(uuid.uuid4())
+
+
+class Test_file_data_store_file_data_read:
+    # Tests parametrised seprately to give nicer descriptions in verbose mode.
+
+    def case(self, filename, kwargs):
+        data = 1 - 2*np.random.rand(_dimension, _dimension)
+        if kwargs.get('numtype', 'complex') == 'complex':
+            data = data * (0.5*0.5j)
+        qutip.file_data_store(filename, data, **kwargs)
+        out = qutip.file_data_read(filename)
+        np.testing.assert_allclose(data, out, atol=1e-8)
+
+    def test_defaults(self):
+        return self.case(_random_file_name(), {})
+
+    @pytest.mark.parametrize("type_", ["real", "complex"])
+    @pytest.mark.parametrize("format_", ["decimal", "exp"])
+    def test_type_format(self, type_, format_):
+
+        kwargs = {'numtype': type_, 'numformat': format_}
+        return self.case(_random_file_name(), kwargs)
+
+    @pytest.mark.parametrize("separator", [",", ";", "\t", " ", " \t "],
+                             ids=lambda x: "'" + x + "'")
+    def test_separator_detection(self, separator):
+        kwargs = {'numtype': 'complex', 'numformat': 'exp', 'sep': separator}
+        return self.case(_random_file_name(), kwargs)
+
+
+@pytest.mark.parametrize('use_path', [True, False], ids=['Path', 'str'])
+@pytest.mark.parametrize('suffix', ['', '.qu', '.dat'])
+def test_qsave_qload(use_path, suffix):
+    ops_in = [qutip.sigmax(),
+              qutip.num(_dimension),
+              qutip.coherent_dm(_dimension, 1j)]
+    filename = _random_file_name() + suffix
+    if use_path:
+        filename = Path.cwd() / filename
+    qutip.qsave(ops_in, filename)
+    ops_out = qutip.qload(filename)
+    assert ops_in == ops_out
+    # check that the file was saved with the correct name:
+    assert Path(str(filename) + ".qu").exists()
diff --git a/qutip/tests/test_ipynbtools.py b/qutip/tests/test_ipynbtools.py
index 25f3ec165b..2b1c76559a 100644
--- a/qutip/tests/test_ipynbtools.py
+++ b/qutip/tests/test_ipynbtools.py
@@ -1,24 +1,24 @@
-from qutip.ipynbtools import version_table
-import pytest
-
-
-@pytest.mark.parametrize('verbose', [False, True])
-def test_version_table(verbose):
-    html_data = version_table(verbose=verbose).data
-    assert "<th>Software</th>" in html_data
-    assert "<th>Version</th>" in html_data
-    assert "<td>QuTiP</td>" in html_data
-    assert "<td>Numpy</td>" in html_data
-    assert "<td>SciPy</td>" in html_data
-    assert "<td>matplotlib</td>" in html_data
-    assert "<td>IPython</td>" in html_data
-    if verbose:
-        assert "<td>Installation path</td>" in html_data
-        if pytest.importorskip("getpass") is not None:
-            assert "<td>User</td>" in html_data
-
-
-@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
-def test_version_table_with_cython():
-    html_data = version_table().data
-    assert "<td>Cython</td>" in html_data
+from qutip.ipynbtools import version_table
+import pytest
+
+
+@pytest.mark.parametrize('verbose', [False, True])
+def test_version_table(verbose):
+    html_data = version_table(verbose=verbose).data
+    assert "<th>Software</th>" in html_data
+    assert "<th>Version</th>" in html_data
+    assert "<td>QuTiP</td>" in html_data
+    assert "<td>Numpy</td>" in html_data
+    assert "<td>SciPy</td>" in html_data
+    assert "<td>matplotlib</td>" in html_data
+    assert "<td>IPython</td>" in html_data
+    if verbose:
+        assert "<td>Installation path</td>" in html_data
+        if pytest.importorskip("getpass") is not None:
+            assert "<td>User</td>" in html_data
+
+
+@pytest.mark.skipif(not pytest.importorskip("Cython"), reason="cython not installed")
+def test_version_table_with_cython():
+    html_data = version_table().data
+    assert "<td>Cython</td>" in html_data
diff --git a/qutip/tests/test_measurement.py b/qutip/tests/test_measurement.py
index b904e2c3bf..6bccd1a35c 100644
--- a/qutip/tests/test_measurement.py
+++ b/qutip/tests/test_measurement.py
@@ -1,324 +1,324 @@
-import numpy as np
-import scipy
-import pytest
-from math import sqrt
-from qutip import (
-    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
-    rand_ket,
-)
-from qutip.measurement import (
-    measure_povm, measurement_statistics_povm, measure_observable,
-    measurement_statistics_observable,
-)
-
-
-class EigenPairs:
-    """ Manage pairs of eigenvalues and eigenstates for an operator. """
-    def __init__(self, pairs):
-        self.pairs = pairs
-        self.eigenvalues = [p[0] for p in pairs]
-        self.eigenstates = [p[1] for p in pairs]
-        self.projectors = [v * v.dag() for v in self.eigenstates]
-
-    def __getitem__(self, i):
-        return self.pairs[i]
-
-    def __contains__(self, other):
-        for i, val in enumerate(self.eigenvalues):
-            if abs(val - other[0]) < 1e-8:
-                break
-        else:
-            return False
-        return _equivalent(other[1], self.eigenstates[i])
-
-
-def pairs2dm(pairs):
-    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
-    return [(v, e.proj()) for v, e in pairs]
-
-
-SIGMAZ = EigenPairs([
-    (-1.0, -basis(2, 1)),
-    (1.0, -basis(2, 0)),
-])
-
-SIGMAX = EigenPairs([
-    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
-    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
-])
-
-SIGMAY = EigenPairs([
-    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
-    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
-])
-
-state0 = basis(2, 0)
-state1 = basis(2, 1)
-stateplus = (basis(2, 0) + basis(2, 1)).unit()
-stateminus = (basis(2, 0) - basis(2, 1)).unit()
-stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
-stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
-PZ = [ket2dm(state0), ket2dm(state1)]
-PX = [ket2dm(stateplus), ket2dm(stateminus)]
-PY = [ket2dm(stateR), ket2dm(stateL)]
-PZ_ket = [state0, state1]
-
-
-def _equivalent(left, right, tol=1e-8):
-    """ Equal up to a phase """
-    return 1 - abs(left.overlap(right)) < tol
-
-
-@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
-    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
-    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
-    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
-    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
-                 id="sigmax_dm"),
-    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
-    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
-                 id="sigmay_dm"),
-])
-def test_measurement_statistics_observable(op, state, pairs, probabilities):
-    """ measurement_statistics_observable: observables on basis states. """
-
-    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
-    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
-    if state.isket:
-        ess = ess_or_projs
-        assert len(ess) == len(pairs.eigenstates)
-        for a, b in zip(ess, pairs.eigenstates):
-            assert _equivalent(a, b)
-    else:
-        projs = ess_or_projs
-        assert len(projs) == len(pairs.projectors)
-        for a, b in zip(projs, pairs.projectors):
-            assert _equivalent(a, b)
-    np.testing.assert_almost_equal(probs, probabilities)
-
-
-@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
-    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
-    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
-                 id="PZ_dm"),
-    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
-    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
-                 id="PZket_dm"),
-    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
-                 id="PX_ket"),
-    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
-                 [0.5, 0.5], id="PX_dm"),
-    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
-    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
-                 [0.5, 0.5], id="PY_dm")])
-def test_measurement_statistics_povm(ops, state, final_states, probabilities):
-    """ measurement_statistics_povm: projectors applied to basis states. """
-
-    collapsed_states, probs = measurement_statistics_povm(state, ops)
-    for i, final_state in enumerate(final_states):
-        collapsed_state = collapsed_states[i]
-        if final_state:
-            assert collapsed_state == final_state
-        else:
-            assert collapsed_state is None
-    np.testing.assert_almost_equal(probs, probabilities)
-
-
-def test_measurement_statistics_povm_input_errors():
-    """ measurement_statistics_povm: check input errors """
-
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measurement_statistics_povm,
-        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measurement_statistics_povm, "notqobj", [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measurement_statistics_povm, basis(3, 0), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
-
-
-def test_measurement_statistics_observable_input_errors():
-    """ measurement_statistics_observable: check input errors """
-
-    np.testing.assert_raises_regex(
-        TypeError, "op must be a Qobj",
-        measurement_statistics_observable, basis(2, 0), "notqobj")
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measurement_statistics_observable, basis(2, 0), basis(2, 1))
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measurement_statistics_observable, "notqobj",  sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measurement_statistics_observable, basis(3, 0), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
-
-
-@pytest.mark.parametrize(["op", "state"], [
-                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
-                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
-                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
-                                 id="sigmaz_dm1"),
-                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
-                                 id="sigmaz_dm2"),
-
-                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
-                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
-                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
-                                 id="sigmax_dm"),
-
-                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
-                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
-                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
-                                 id="sigmay_dm")])
-def test_measure_observable(op, state):
-    """ measure_observable: basis states using different observables """
-    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
-
-    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
-    for _ in range(10):
-        assert (measure_observable(state, op) in expected_measurements)
-
-
-@pytest.mark.parametrize(["ops", "state"], [
-
-                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
-                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
-                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
-                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
-
-                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
-                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
-                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
-                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
-
-                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
-                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
-                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
-
-                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
-                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
-                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
-def test_measure(ops, state):
-    """measure_povm: test on basis states using different projectors """
-
-    collapsed_states, _ = measurement_statistics_povm(state, ops)
-    for _ in range(10):
-        index, final_state = measure_povm(state, ops)
-        assert final_state == collapsed_states[index]
-
-
-def test_measure_input_errors():
-    """ measure_povm: check input errors """
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measure_povm, "notqobj", [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measure_povm, basis(2, 0).dag(), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measure_povm, basis(3, 0), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measure_povm, basis(2, 0), [basis(2, 0)])
-    np.testing.assert_raises_regex(
-        ValueError,
-        "measurement operators must sum to identity",
-        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
-
-
-def test_measure_observable_input_errors():
-    """ measure_observable: check input errors """
-    np.testing.assert_raises_regex(
-        TypeError, "op must be a Qobj",
-        measure_observable, basis(2, 0), "notqobj")
-    np.testing.assert_raises_regex(
-        ValueError, "op must be all operators or all kets",
-        measure_observable, basis(2, 0),  basis(2, 1))
-    np.testing.assert_raises_regex(
-        TypeError, "state must be a Qobj",
-        measure_observable, "notqobj", sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError, "state must be a ket or a density matrix",
-        measure_observable, basis(2, 0).dag(), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should be compatible when state is a ket",
-        measure_observable, basis(3, 0), sigmaz())
-    np.testing.assert_raises_regex(
-        ValueError,
-        "op and state dims should match when state is a density matrix",
-        measure_observable, ket2dm(basis(3, 0)), sigmaz())
-
-
-def test_povm():
-    """
-    Test if povm formulation works correctly by checking probabilities for
-    the quantum state discrimination example
-    """
-
-    coeff = (sqrt(2)/(1+sqrt(2)))
-
-    E_1 = coeff * ket2dm(basis(2, 1))
-    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
-    E_3 = identity(2) - E_1 - E_2
-
-    M_1 = E_1.sqrtm()
-    M_2 = E_2.sqrtm()
-    M_3 = E_3.sqrtm()
-
-    ket1 = basis(2, 0)
-    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
-
-    dm1 = ket2dm(ket1)
-    dm2 = ket2dm(ket2)
-
-    M = [M_1, M_2, M_3]
-
-    _, probabilities = measurement_statistics_povm(ket1, M)
-    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
-
-    _, probabilities = measurement_statistics_povm(ket2, M)
-    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
-
-    _, probabilities = measurement_statistics_povm(dm1, M)
-    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
-
-    _, probabilities = measurement_statistics_povm(dm2, M)
-    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
+import numpy as np
+import scipy
+import pytest
+from math import sqrt
+from qutip import (
+    Qobj, basis, ket2dm, sigmax, sigmay, sigmaz, identity, tensor,
+    rand_ket,
+)
+from qutip.measurement import (
+    measure_povm, measurement_statistics_povm, measure_observable,
+    measurement_statistics_observable,
+)
+
+
+class EigenPairs:
+    """ Manage pairs of eigenvalues and eigenstates for an operator. """
+    def __init__(self, pairs):
+        self.pairs = pairs
+        self.eigenvalues = [p[0] for p in pairs]
+        self.eigenstates = [p[1] for p in pairs]
+        self.projectors = [v * v.dag() for v in self.eigenstates]
+
+    def __getitem__(self, i):
+        return self.pairs[i]
+
+    def __contains__(self, other):
+        for i, val in enumerate(self.eigenvalues):
+            if abs(val - other[0]) < 1e-8:
+                break
+        else:
+            return False
+        return _equivalent(other[1], self.eigenstates[i])
+
+
+def pairs2dm(pairs):
+    """ Convert eigenpair entries into eigenvalue and density matrix pairs. """
+    return [(v, e.proj()) for v, e in pairs]
+
+
+SIGMAZ = EigenPairs([
+    (-1.0, -basis(2, 1)),
+    (1.0, -basis(2, 0)),
+])
+
+SIGMAX = EigenPairs([
+    (-1.0, (-basis(2, 0) + basis(2, 1)).unit()),
+    (1.0, (basis(2, 0) + basis(2, 1)).unit()),
+])
+
+SIGMAY = EigenPairs([
+    (-1.0, (-basis(2, 0) + 1j * basis(2, 1)).unit()),
+    (1.0, (-basis(2, 0) - 1j * basis(2, 1)).unit()),
+])
+
+state0 = basis(2, 0)
+state1 = basis(2, 1)
+stateplus = (basis(2, 0) + basis(2, 1)).unit()
+stateminus = (basis(2, 0) - basis(2, 1)).unit()
+stateR = (basis(2, 0) + 1j * basis(2, 1)).unit()
+stateL = (basis(2, 0) - 1j * basis(2, 1)).unit()
+PZ = [ket2dm(state0), ket2dm(state1)]
+PX = [ket2dm(stateplus), ket2dm(stateminus)]
+PY = [ket2dm(stateR), ket2dm(stateL)]
+PZ_ket = [state0, state1]
+
+
+def _equivalent(left, right, tol=1e-8):
+    """ Equal up to a phase """
+    return 1 - abs(left.overlap(right)) < tol
+
+
+@pytest.mark.parametrize(["op", "state", "pairs", "probabilities"], [
+    pytest.param(sigmaz(), basis(2, 0), SIGMAZ, [0, 1], id="sigmaz_ket"),
+    pytest.param(sigmaz(), basis(2, 0).proj(), SIGMAZ, [0, 1], id="sigmaz_dm"),
+    pytest.param(sigmax(), basis(2, 0), SIGMAX, [0.5, 0.5], id="sigmax_ket"),
+    pytest.param(sigmax(), basis(2, 0).proj(), SIGMAX, [0.5, 0.5],
+                 id="sigmax_dm"),
+    pytest.param(sigmay(), basis(2, 0), SIGMAY, [0.5, 0.5], id="sigmay_ket"),
+    pytest.param(sigmay(), basis(2, 0).proj(), SIGMAY, [0.5, 0.5],
+                 id="sigmay_dm"),
+])
+def test_measurement_statistics_observable(op, state, pairs, probabilities):
+    """ measurement_statistics_observable: observables on basis states. """
+
+    evs, ess_or_projs, probs = measurement_statistics_observable(state, op)
+    np.testing.assert_almost_equal(evs, pairs.eigenvalues)
+    if state.isket:
+        ess = ess_or_projs
+        assert len(ess) == len(pairs.eigenstates)
+        for a, b in zip(ess, pairs.eigenstates):
+            assert _equivalent(a, b)
+    else:
+        projs = ess_or_projs
+        assert len(projs) == len(pairs.projectors)
+        for a, b in zip(projs, pairs.projectors):
+            assert _equivalent(a, b)
+    np.testing.assert_almost_equal(probs, probabilities)
+
+
+@pytest.mark.parametrize(["ops", "state", "final_states", "probabilities"], [
+    pytest.param(PZ, basis(2, 0), [state0, None], [1, 0], id="PZ_ket"),
+    pytest.param(PZ, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
+                 id="PZ_dm"),
+    pytest.param(PZ_ket, basis(2, 0), [state0, None], [1, 0], id="PZket_ket"),
+    pytest.param(PZ_ket, basis(2, 0).proj(), [state0.proj(), None], [1, 0],
+                 id="PZket_dm"),
+    pytest.param(PX, basis(2, 0), [stateplus, stateminus], [0.5, 0.5],
+                 id="PX_ket"),
+    pytest.param(PX, basis(2, 0).proj(), [stateplus.proj(), stateminus.proj()],
+                 [0.5, 0.5], id="PX_dm"),
+    pytest.param(PY, basis(2, 0), [stateR, stateL], [0.5, 0.5], id="PY_ket"),
+    pytest.param(PY, basis(2, 0).proj(), [stateR.proj(), stateL.proj()],
+                 [0.5, 0.5], id="PY_dm")])
+def test_measurement_statistics_povm(ops, state, final_states, probabilities):
+    """ measurement_statistics_povm: projectors applied to basis states. """
+
+    collapsed_states, probs = measurement_statistics_povm(state, ops)
+    for i, final_state in enumerate(final_states):
+        collapsed_state = collapsed_states[i]
+        if final_state:
+            assert collapsed_state == final_state
+        else:
+            assert collapsed_state is None
+    np.testing.assert_almost_equal(probs, probabilities)
+
+
+def test_measurement_statistics_povm_input_errors():
+    """ measurement_statistics_povm: check input errors """
+
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measurement_statistics_povm,
+        basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measurement_statistics_povm, "notqobj", [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measurement_statistics_povm, basis(2, 0).dag(), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measurement_statistics_povm, basis(3, 0), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measurement_statistics_povm, ket2dm(basis(3, 0)), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measurement_statistics_povm, basis(2, 0), [basis(2, 0)])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measurement_statistics_povm, basis(2, 0), [ket2dm(basis(2, 0))])
+
+
+def test_measurement_statistics_observable_input_errors():
+    """ measurement_statistics_observable: check input errors """
+
+    np.testing.assert_raises_regex(
+        TypeError, "op must be a Qobj",
+        measurement_statistics_observable, basis(2, 0), "notqobj")
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measurement_statistics_observable, basis(2, 0), basis(2, 1))
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measurement_statistics_observable, "notqobj",  sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measurement_statistics_observable, basis(2, 0).dag(), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measurement_statistics_observable, basis(3, 0), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measurement_statistics_observable, ket2dm(basis(3, 0)), sigmaz())
+
+
+@pytest.mark.parametrize(["op", "state"], [
+                    pytest.param(sigmaz(), basis(2, 0), id="sigmaz_ket1"),
+                    pytest.param(sigmaz(), basis(2, 1), id="sigmaz_ket2"),
+                    pytest.param(sigmaz(), ket2dm(basis(2, 0)),
+                                 id="sigmaz_dm1"),
+                    pytest.param(sigmaz(), ket2dm(basis(2, 1)),
+                                 id="sigmaz_dm2"),
+
+                    pytest.param(sigmax(), basis(2, 0), id="sigmax_ket1"),
+                    pytest.param(sigmax(), basis(2, 1), id="sigmax_ket2"),
+                    pytest.param(sigmax(), ket2dm(basis(2, 0)),
+                                 id="sigmax_dm"),
+
+                    pytest.param(sigmay(), basis(2, 0), id="sigmay_ket1"),
+                    pytest.param(sigmay(), basis(2, 1), id="sigmax_ket2"),
+                    pytest.param(sigmay(), ket2dm(basis(2, 1)),
+                                 id="sigmay_dm")])
+def test_measure_observable(op, state):
+    """ measure_observable: basis states using different observables """
+    evs, ess_or_projs, prob = measurement_statistics_observable(state, op)
+
+    expected_measurements = EigenPairs(list(zip(evs, ess_or_projs)))
+    for _ in range(10):
+        assert (measure_observable(state, op) in expected_measurements)
+
+
+@pytest.mark.parametrize(["ops", "state"], [
+
+                    pytest.param(PZ, basis(2, 0), id="PZ_ket1"),
+                    pytest.param(PZ, basis(2, 1), id="PZ_ket2"),
+                    pytest.param(PZ, ket2dm(basis(2, 0)), id="PZ_dm1"),
+                    pytest.param(PZ, ket2dm(basis(2, 1)), id="PZ_dm2"),
+
+                    pytest.param(PZ_ket, basis(2, 0), id="PZket_ket1"),
+                    pytest.param(PZ_ket, basis(2, 1), id="PZket_ket2"),
+                    pytest.param(PZ_ket, ket2dm(basis(2, 0)), id="PZket_dm1"),
+                    pytest.param(PZ_ket, ket2dm(basis(2, 1)), id="PZket_dm2"),
+
+                    pytest.param(PX, basis(2, 0), id="PX_ket1"),
+                    pytest.param(PX, basis(2, 1), id="PX_ket2"),
+                    pytest.param(PX, ket2dm(basis(2, 0)), id="PX_dm"),
+
+                    pytest.param(PY, basis(2, 0), id="PY_ket1"),
+                    pytest.param(PY, basis(2, 1), id="PY_ket2"),
+                    pytest.param(PY, ket2dm(basis(2, 1)), id="PY_dm")])
+def test_measure(ops, state):
+    """measure_povm: test on basis states using different projectors """
+
+    collapsed_states, _ = measurement_statistics_povm(state, ops)
+    for _ in range(10):
+        index, final_state = measure_povm(state, ops)
+        assert final_state == collapsed_states[index]
+
+
+def test_measure_input_errors():
+    """ measure_povm: check input errors """
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measure_povm, basis(2, 0), [basis(2, 0), ket2dm(basis(2, 0))])
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measure_povm, "notqobj", [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measure_povm, basis(2, 0).dag(), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measure_povm, basis(3, 0), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measure_povm, ket2dm(basis(3, 0)), [sigmaz()])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measure_povm, basis(2, 0), [basis(2, 0)])
+    np.testing.assert_raises_regex(
+        ValueError,
+        "measurement operators must sum to identity",
+        measure_povm, basis(2, 0), [ket2dm(basis(2, 0))])
+
+
+def test_measure_observable_input_errors():
+    """ measure_observable: check input errors """
+    np.testing.assert_raises_regex(
+        TypeError, "op must be a Qobj",
+        measure_observable, basis(2, 0), "notqobj")
+    np.testing.assert_raises_regex(
+        ValueError, "op must be all operators or all kets",
+        measure_observable, basis(2, 0),  basis(2, 1))
+    np.testing.assert_raises_regex(
+        TypeError, "state must be a Qobj",
+        measure_observable, "notqobj", sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError, "state must be a ket or a density matrix",
+        measure_observable, basis(2, 0).dag(), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should be compatible when state is a ket",
+        measure_observable, basis(3, 0), sigmaz())
+    np.testing.assert_raises_regex(
+        ValueError,
+        "op and state dims should match when state is a density matrix",
+        measure_observable, ket2dm(basis(3, 0)), sigmaz())
+
+
+def test_povm():
+    """
+    Test if povm formulation works correctly by checking probabilities for
+    the quantum state discrimination example
+    """
+
+    coeff = (sqrt(2)/(1+sqrt(2)))
+
+    E_1 = coeff * ket2dm(basis(2, 1))
+    E_2 = coeff * ket2dm((basis(2, 0) - basis(2, 1))/(sqrt(2)))
+    E_3 = identity(2) - E_1 - E_2
+
+    M_1 = E_1.sqrtm()
+    M_2 = E_2.sqrtm()
+    M_3 = E_3.sqrtm()
+
+    ket1 = basis(2, 0)
+    ket2 = (basis(2, 0) + basis(2, 1))/(sqrt(2))
+
+    dm1 = ket2dm(ket1)
+    dm2 = ket2dm(ket2)
+
+    M = [M_1, M_2, M_3]
+
+    _, probabilities = measurement_statistics_povm(ket1, M)
+    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
+
+    _, probabilities = measurement_statistics_povm(ket2, M)
+    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
+
+    _, probabilities = measurement_statistics_povm(dm1, M)
+    np.testing.assert_allclose(probabilities, [0, 0.293, 0.707], atol=0.001)
+
+    _, probabilities = measurement_statistics_povm(dm2, M)
+    np.testing.assert_allclose(probabilities, [0.293, 0, 0.707], atol=0.001)
diff --git a/qutip/tests/test_mkl.py b/qutip/tests/test_mkl.py
index 3eeb83f17b..734f33e25e 100644
--- a/qutip/tests/test_mkl.py
+++ b/qutip/tests/test_mkl.py
@@ -1,116 +1,116 @@
-import pytest
-import numpy as np
-import scipy.linalg
-import scipy.sparse
-
-import qutip
-if qutip.settings.has_mkl:
-    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
-
-pytestmark = [
-    pytest.mark.skipif(not qutip.settings.has_mkl,
-                       reason='MKL extensions not found.'),
-]
-
-
-class Test_spsolve:
-    def test_single_rhs_vector_real(self):
-        Adense = np.array([[0, 1, 1],
-                           [1, 0, 1],
-                           [0, 0, 1]])
-        As = scipy.sparse.csr_matrix(Adense)
-        np.random.seed(1234)
-        x = np.random.randn(3)
-        b = As * x
-        x2 = mkl_spsolve(As, b, verbose=True)
-        np.testing.assert_allclose(x, x2)
-
-    def test_single_rhs_vector_complex(self):
-        A = qutip.rand_herm(10, density=0.8, dtype='csr')
-        x = qutip.rand_ket(10).full()
-        b = A.full() @ x
-        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
-        np.testing.assert_allclose(x, y)
-
-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-    def test_multi_rhs_vector(self, dtype):
-        M = np.array([
-            [1, 0, 2],
-            [0, 0, 3],
-            [-4, 5, 6],
-        ], dtype=dtype)
-        sM = scipy.sparse.csr_matrix(M)
-        N = np.array([
-            [3, 0, 1],
-            [0, 2, 0],
-            [0, 0, 0],
-        ], dtype=dtype)
-        sX = mkl_spsolve(sM, N, verbose=True)
-        X = scipy.linalg.solve(M, N)
-        np.testing.assert_allclose(X, sX)
-
-    def test_rhs_shape_is_maintained(self):
-        A = scipy.sparse.csr_matrix(np.array([
-            [1, 0, 2],
-            [0, 0, 3],
-            [-4, 5, 6],
-        ], dtype=np.complex128))
-        b = np.array([0, 2, 0], dtype=np.complex128)
-        out = mkl_spsolve(A, b, verbose=True)
-        assert b.shape == out.shape
-
-        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
-        out = mkl_spsolve(A, b, verbose=True)
-        assert b.shape == out.shape
-
-    def test_sparse_rhs(self):
-        A = scipy.sparse.csr_matrix([
-            [1, 2, 0],
-            [0, 3, 0],
-            [0, 0, 5],
-        ])
-        b = scipy.sparse.csr_matrix([
-            [0, 1],
-            [1, 0],
-            [0, 0],
-        ])
-        x = mkl_spsolve(A, b, verbose=True)
-        ans = np.array([[-0.66666667, 1],
-                        [0.33333333, 0],
-                        [0, 0]])
-        np.testing.assert_allclose(x.toarray(), ans)
-
-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-    def test_symmetric_solver(self, dtype):
-        A = qutip.rand_herm(10, distribution="eigen",
-                            eigenvalues=np.arange(1, 11),
-                            dtype='csr').data.as_scipy()
-        if dtype == np.float64:
-            A = A.real
-        x = np.ones(10, dtype=dtype)
-        b = A.dot(x)
-        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
-        np.testing.assert_allclose(x, y)
-
-
-class Test_splu:
-    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
-    def test_repeated_rhs_solve(self, dtype):
-        M = np.array([
-            [1, 0, 2],
-            [0, 0, 3],
-            [-4, 5, 6],
-        ], dtype=dtype)
-        sM = scipy.sparse.csr_matrix(M)
-        N = np.array([
-            [3, 0, 1],
-            [0, 2, 0],
-            [0, 0, 0],
-        ], dtype=dtype)
-        test_X = np.zeros((3, 3), dtype=dtype)
-        lu = mkl_splu(sM, verbose=True)
-        for k in range(3):
-            test_X[:, k] = lu.solve(N[:, k])
-        lu.delete()
-        expected_X = scipy.linalg.solve(M, N)
-        np.testing.assert_allclose(test_X, expected_X)
+import pytest
+import numpy as np
+import scipy.linalg
+import scipy.sparse
+
+import qutip
+if qutip.settings.has_mkl:
+    from qutip._mkl.spsolve import mkl_splu, mkl_spsolve
+
+pytestmark = [
+    pytest.mark.skipif(not qutip.settings.has_mkl,
+                       reason='MKL extensions not found.'),
+]
+
+
+class Test_spsolve:
+    def test_single_rhs_vector_real(self):
+        Adense = np.array([[0, 1, 1],
+                           [1, 0, 1],
+                           [0, 0, 1]])
+        As = scipy.sparse.csr_matrix(Adense)
+        np.random.seed(1234)
+        x = np.random.randn(3)
+        b = As * x
+        x2 = mkl_spsolve(As, b, verbose=True)
+        np.testing.assert_allclose(x, x2)
+
+    def test_single_rhs_vector_complex(self):
+        A = qutip.rand_herm(10, density=0.8, dtype='csr')
+        x = qutip.rand_ket(10).full()
+        b = A.full() @ x
+        y = mkl_spsolve(A.data.as_scipy(), b, verbose=True)
+        np.testing.assert_allclose(x, y)
+
+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+    def test_multi_rhs_vector(self, dtype):
+        M = np.array([
+            [1, 0, 2],
+            [0, 0, 3],
+            [-4, 5, 6],
+        ], dtype=dtype)
+        sM = scipy.sparse.csr_matrix(M)
+        N = np.array([
+            [3, 0, 1],
+            [0, 2, 0],
+            [0, 0, 0],
+        ], dtype=dtype)
+        sX = mkl_spsolve(sM, N, verbose=True)
+        X = scipy.linalg.solve(M, N)
+        np.testing.assert_allclose(X, sX)
+
+    def test_rhs_shape_is_maintained(self):
+        A = scipy.sparse.csr_matrix(np.array([
+            [1, 0, 2],
+            [0, 0, 3],
+            [-4, 5, 6],
+        ], dtype=np.complex128))
+        b = np.array([0, 2, 0], dtype=np.complex128)
+        out = mkl_spsolve(A, b, verbose=True)
+        assert b.shape == out.shape
+
+        b = np.array([0, 2, 0], dtype=np.complex128).reshape((3, 1))
+        out = mkl_spsolve(A, b, verbose=True)
+        assert b.shape == out.shape
+
+    def test_sparse_rhs(self):
+        A = scipy.sparse.csr_matrix([
+            [1, 2, 0],
+            [0, 3, 0],
+            [0, 0, 5],
+        ])
+        b = scipy.sparse.csr_matrix([
+            [0, 1],
+            [1, 0],
+            [0, 0],
+        ])
+        x = mkl_spsolve(A, b, verbose=True)
+        ans = np.array([[-0.66666667, 1],
+                        [0.33333333, 0],
+                        [0, 0]])
+        np.testing.assert_allclose(x.toarray(), ans)
+
+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+    def test_symmetric_solver(self, dtype):
+        A = qutip.rand_herm(10, distribution="eigen",
+                            eigenvalues=np.arange(1, 11),
+                            dtype='csr').data.as_scipy()
+        if dtype == np.float64:
+            A = A.real
+        x = np.ones(10, dtype=dtype)
+        b = A.dot(x)
+        y = mkl_spsolve(A, b, hermitian=1, verbose=True)
+        np.testing.assert_allclose(x, y)
+
+
+class Test_splu:
+    @pytest.mark.parametrize('dtype', [np.float64, np.complex128])
+    def test_repeated_rhs_solve(self, dtype):
+        M = np.array([
+            [1, 0, 2],
+            [0, 0, 3],
+            [-4, 5, 6],
+        ], dtype=dtype)
+        sM = scipy.sparse.csr_matrix(M)
+        N = np.array([
+            [3, 0, 1],
+            [0, 2, 0],
+            [0, 0, 0],
+        ], dtype=dtype)
+        test_X = np.zeros((3, 3), dtype=dtype)
+        lu = mkl_splu(sM, verbose=True)
+        for k in range(3):
+            test_X[:, k] = lu.solve(N[:, k])
+        lu.delete()
+        expected_X = scipy.linalg.solve(M, N)
+        np.testing.assert_allclose(test_X, expected_X)
diff --git a/qutip/tests/test_openmp.py b/qutip/tests/test_openmp.py
index 604df3c6ec..05804ca5e9 100644
--- a/qutip/tests/test_openmp.py
+++ b/qutip/tests/test_openmp.py
@@ -1,111 +1,111 @@
-import numpy as np
-from numpy.testing import assert_equal, assert_, run_module_suite
-import unittest
-from qutip import *
-from qutip.settings import settings as qset
-# if qset.has_openmp:
-#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
-
-
-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-@unittest.skipIf(True, 'OPENMP disabled.')
-def test_openmp_spmv():
-    "OPENMP : spmvpy_openmp == spmvpy"
-    for k in range(100):
-        L = rand_herm(10,0.25).data
-        vec = rand_ket(L.shape[0],0.25).full().ravel()
-        out = np.zeros_like(vec)
-        out_openmp = np.zeros_like(vec)
-        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
-        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
-        assert_(np.allclose(out, out_openmp, 1e-15))
-
-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-@unittest.skipIf(True, 'OPENMP disabled.')
-def test_openmp_mesolve():
-    "OPENMP : mesolve"
-    N = 100
-    wc = 1.0  * 2 * np.pi  # cavity frequency
-    wa = 1.0  * 2 * np.pi  # atom frequency
-    g  = 0.05 * 2 * np.pi  # coupling strength
-    kappa = 0.005          # cavity dissipation rate
-    gamma = 0.05           # atom dissipation rate
-    n_th_a = 1           # temperature in frequency units
-    use_rwa = 0
-    # operators
-    a  = tensor(destroy(N), qeye(2))
-    sm = tensor(qeye(N), destroy(2))
-    # Hamiltonian
-    if use_rwa:
-        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
-    else:
-        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
-    c_op_list = []
-
-    rate = kappa * (1 + n_th_a)
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a)
-
-    rate = kappa * n_th_a
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a.dag())
-
-    rate = gamma
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sm)
-
-    n = N - 2
-    psi0 = tensor(basis(N, n), basis(2, 1))
-    tlist = np.linspace(0, 1, 100)
-    opts = SolverOptions(use_openmp=False)
-    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    opts = SolverOptions(use_openmp=True)
-    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
-
-
-# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
-@unittest.skipIf(True, 'OPENMP disabled.')
-def test_openmp_mesolve_td():
-    "OPENMP : mesolve (td)"
-    N = 100
-    wc = 1.0  * 2 * np.pi  # cavity frequency
-    wa = 1.0  * 2 * np.pi  # atom frequency
-    g  = 0.5 * 2 * np.pi  # coupling strength
-    kappa = 0.005          # cavity dissipation rate
-    gamma = 0.05           # atom dissipation rate
-    n_th_a = 1           # temperature in frequency units
-    use_rwa = 0
-    # operators
-    a  = tensor(destroy(N), qeye(2))
-    sm = tensor(qeye(N), destroy(2))
-    # Hamiltonian
-    H0 = wc * a.dag() * a + wa * sm.dag() * sm
-    H1 = g * (a.dag() + a) * (sm + sm.dag())
-
-    H = [H0, [H1,'sin(t)']]
-
-    c_op_list = []
-
-    rate = kappa * (1 + n_th_a)
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a)
-
-    rate = kappa * n_th_a
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * a.dag())
-
-    rate = gamma
-    if rate > 0.0:
-        c_op_list.append(np.sqrt(rate) * sm)
-
-    n = N - 10
-    psi0 = tensor(basis(N, n), basis(2, 1))
-    tlist = np.linspace(0, 1, 100)
-    opts = SolverOptions(use_openmp=True)
-    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    opts = SolverOptions(use_openmp=False)
-    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+import numpy as np
+from numpy.testing import assert_equal, assert_, run_module_suite
+import unittest
+from qutip import *
+from qutip.settings import settings as qset
+# if qset.has_openmp:
+#    from qutip.core.cy.openmp.benchmark import _spmvpy, _spmvpy_openmp
+
+
+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+@unittest.skipIf(True, 'OPENMP disabled.')
+def test_openmp_spmv():
+    "OPENMP : spmvpy_openmp == spmvpy"
+    for k in range(100):
+        L = rand_herm(10,0.25).data
+        vec = rand_ket(L.shape[0],0.25).full().ravel()
+        out = np.zeros_like(vec)
+        out_openmp = np.zeros_like(vec)
+        _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
+        _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
+        assert_(np.allclose(out, out_openmp, 1e-15))
+
+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+@unittest.skipIf(True, 'OPENMP disabled.')
+def test_openmp_mesolve():
+    "OPENMP : mesolve"
+    N = 100
+    wc = 1.0  * 2 * np.pi  # cavity frequency
+    wa = 1.0  * 2 * np.pi  # atom frequency
+    g  = 0.05 * 2 * np.pi  # coupling strength
+    kappa = 0.005          # cavity dissipation rate
+    gamma = 0.05           # atom dissipation rate
+    n_th_a = 1           # temperature in frequency units
+    use_rwa = 0
+    # operators
+    a  = tensor(destroy(N), qeye(2))
+    sm = tensor(qeye(N), destroy(2))
+    # Hamiltonian
+    if use_rwa:
+        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
+    else:
+        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() + a) * (sm + sm.dag())
+    c_op_list = []
+
+    rate = kappa * (1 + n_th_a)
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a)
+
+    rate = kappa * n_th_a
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a.dag())
+
+    rate = gamma
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sm)
+
+    n = N - 2
+    psi0 = tensor(basis(N, n), basis(2, 1))
+    tlist = np.linspace(0, 1, 100)
+    opts = SolverOptions(use_openmp=False)
+    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    opts = SolverOptions(use_openmp=True)
+    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
+    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+
+
+# @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
+@unittest.skipIf(True, 'OPENMP disabled.')
+def test_openmp_mesolve_td():
+    "OPENMP : mesolve (td)"
+    N = 100
+    wc = 1.0  * 2 * np.pi  # cavity frequency
+    wa = 1.0  * 2 * np.pi  # atom frequency
+    g  = 0.5 * 2 * np.pi  # coupling strength
+    kappa = 0.005          # cavity dissipation rate
+    gamma = 0.05           # atom dissipation rate
+    n_th_a = 1           # temperature in frequency units
+    use_rwa = 0
+    # operators
+    a  = tensor(destroy(N), qeye(2))
+    sm = tensor(qeye(N), destroy(2))
+    # Hamiltonian
+    H0 = wc * a.dag() * a + wa * sm.dag() * sm
+    H1 = g * (a.dag() + a) * (sm + sm.dag())
+
+    H = [H0, [H1,'sin(t)']]
+
+    c_op_list = []
+
+    rate = kappa * (1 + n_th_a)
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a)
+
+    rate = kappa * n_th_a
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * a.dag())
+
+    rate = gamma
+    if rate > 0.0:
+        c_op_list.append(np.sqrt(rate) * sm)
+
+    n = N - 10
+    psi0 = tensor(basis(N, n), basis(2, 1))
+    tlist = np.linspace(0, 1, 100)
+    opts = SolverOptions(use_openmp=True)
+    out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    opts = SolverOptions(use_openmp=False)
+    out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
+    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
+    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
diff --git a/qutip/tests/test_orbital.py b/qutip/tests/test_orbital.py
index 0fe0fb3fce..e5a1829766 100644
--- a/qutip/tests/test_orbital.py
+++ b/qutip/tests/test_orbital.py
@@ -1,55 +1,55 @@
-import pytest
-from scipy.special import sph_harm
-from qutip.orbital import orbital
-import qutip
-import numpy as np
-
-
-def test_orbital_single_ket():
-    """ Checks output for a single ket as input"""
-    # setup mesh for theta and phi
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    for theta, phi in zip(theta_list, phi_list):
-        # set l and m
-        for l in range(0, 5):
-            for m in range(-l, l + 1):
-                q = qutip.basis(2 * l + 1, l + m)
-                # check that outputs are the same,
-                # note that theta and phi are interchanged for scipy
-                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
-
-
-def test_orbital_multiple_ket():
-    """ Checks if the combination of multiple kets works """
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    l, m = 5, 2
-    q1 = qutip.basis(2 * l + 1, l + m)
-    l, m = 3, -1
-    q2 = qutip.basis(2 * l + 1, l + m)
-    for theta, phi in zip(theta_list, phi_list):
-        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
-        assert orbital(theta, phi, q1, q2) ==  exp
-
-
-def test_orbital_explicit():
-    """ Checks explicit configurations of orbital functions"""
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    # Constant function
-    l, m = 0, 0
-    q = qutip.basis(2 * l + 1, l + m)
-    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
-    # cosine function
-    l, m = 1, 0
-    q = qutip.basis(2 * l + 1, l + m)
-    assert np.allclose(orbital(theta_list, 0, q),
-                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
-    # cosine with phase
-    l, m = 1, 1
-    q = qutip.basis(2 * l + 1, l + m)
-    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
-    assert np.allclose(orbital(theta_list, phi_list, q),
-                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
-                           theta_mesh) * np.exp(1j * phi_mesh))
+import pytest
+from scipy.special import sph_harm
+from qutip.orbital import orbital
+import qutip
+import numpy as np
+
+
+def test_orbital_single_ket():
+    """ Checks output for a single ket as input"""
+    # setup mesh for theta and phi
+    theta_list = np.linspace(0, np.pi, num=50)
+    phi_list = np.linspace(0, 2 * np.pi, num=100)
+    for theta, phi in zip(theta_list, phi_list):
+        # set l and m
+        for l in range(0, 5):
+            for m in range(-l, l + 1):
+                q = qutip.basis(2 * l + 1, l + m)
+                # check that outputs are the same,
+                # note that theta and phi are interchanged for scipy
+                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
+
+
+def test_orbital_multiple_ket():
+    """ Checks if the combination of multiple kets works """
+    theta_list = np.linspace(0, np.pi, num=50)
+    phi_list = np.linspace(0, 2 * np.pi, num=100)
+    l, m = 5, 2
+    q1 = qutip.basis(2 * l + 1, l + m)
+    l, m = 3, -1
+    q2 = qutip.basis(2 * l + 1, l + m)
+    for theta, phi in zip(theta_list, phi_list):
+        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
+        assert orbital(theta, phi, q1, q2) ==  exp
+
+
+def test_orbital_explicit():
+    """ Checks explicit configurations of orbital functions"""
+    theta_list = np.linspace(0, np.pi, num=50)
+    phi_list = np.linspace(0, 2 * np.pi, num=100)
+    # Constant function
+    l, m = 0, 0
+    q = qutip.basis(2 * l + 1, l + m)
+    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
+    # cosine function
+    l, m = 1, 0
+    q = qutip.basis(2 * l + 1, l + m)
+    assert np.allclose(orbital(theta_list, 0, q),
+                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
+    # cosine with phase
+    l, m = 1, 1
+    q = qutip.basis(2 * l + 1, l + m)
+    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
+    assert np.allclose(orbital(theta_list, phi_list, q),
+                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
+                           theta_mesh) * np.exp(1j * phi_mesh))
diff --git a/qutip/tests/test_partial_transpose.py b/qutip/tests/test_partial_transpose.py
index 26dffb3a70..02d3fec328 100644
--- a/qutip/tests/test_partial_transpose.py
+++ b/qutip/tests/test_partial_transpose.py
@@ -1,78 +1,78 @@
-"""
-Unit tests for QuTiP partial transpose functions.
-"""
-
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-
-from qutip import Qobj, partial_transpose, tensor, rand_dm
-from qutip.partial_transpose import _partial_transpose_reference
-
-
-def test_partial_transpose_bipartite():
-    """partial transpose of bipartite systems"""
-
-    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
-
-    # no transpose
-    rho_pt = partial_transpose(rho, [0, 0])
-    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
-
-    # partial transpose subsystem 1
-    rho_pt = partial_transpose(rho, [1, 0])
-    rho_pt_expected = np.array([[0, 1,  8,  9],
-                                [4, 5, 12, 13],
-                                [2, 3, 10, 11],
-                                [6, 7, 14, 15]])
-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
-
-    # partial transpose subsystem 2
-    rho_pt = partial_transpose(rho, [0, 1])
-    rho_pt_expected = np.array([[0, 4, 2, 6],
-                                [1, 5, 3, 7],
-                                [8, 12, 10, 14],
-                                [9, 13, 11, 15]])
-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
-
-    # full transpose
-    rho_pt = partial_transpose(rho, [1, 1])
-    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
-
-
-def test_partial_transpose_comparison():
-    """partial transpose: comparing sparse and dense implementations"""
-
-    N = 10
-    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
-
-    # partial transpose of system 1
-    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
-    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
-    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
-
-    # partial transpose of system 2
-    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
-    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
-    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
-
-
-def test_partial_transpose_randomized():
-    """partial transpose: randomized tests on tripartite system"""
-
-    rho = tensor(rand_dm(2, density=1),
-                 rand_dm(2, density=1),
-                 rand_dm(2, density=1))
-
-    mask = np.random.randint(2, size=3)
-
-    rho_pt_ref = _partial_transpose_reference(rho, mask)
-
-    rho_pt1 = partial_transpose(rho, mask, method="dense")
-    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
-
-    rho_pt2 = partial_transpose(rho, mask, method="sparse")
-    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
-
-
-if __name__ == "__main__":
-    run_module_suite()
+"""
+Unit tests for QuTiP partial transpose functions.
+"""
+
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+
+from qutip import Qobj, partial_transpose, tensor, rand_dm
+from qutip.partial_transpose import _partial_transpose_reference
+
+
+def test_partial_transpose_bipartite():
+    """partial transpose of bipartite systems"""
+
+    rho = Qobj(np.arange(16).reshape(4, 4), dims=[[2, 2], [2, 2]])
+
+    # no transpose
+    rho_pt = partial_transpose(rho, [0, 0])
+    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
+
+    # partial transpose subsystem 1
+    rho_pt = partial_transpose(rho, [1, 0])
+    rho_pt_expected = np.array([[0, 1,  8,  9],
+                                [4, 5, 12, 13],
+                                [2, 3, 10, 11],
+                                [6, 7, 14, 15]])
+    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+
+    # partial transpose subsystem 2
+    rho_pt = partial_transpose(rho, [0, 1])
+    rho_pt_expected = np.array([[0, 4, 2, 6],
+                                [1, 5, 3, 7],
+                                [8, 12, 10, 14],
+                                [9, 13, 11, 15]])
+    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+
+    # full transpose
+    rho_pt = partial_transpose(rho, [1, 1])
+    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
+
+
+def test_partial_transpose_comparison():
+    """partial transpose: comparing sparse and dense implementations"""
+
+    N = 10
+    rho = tensor(rand_dm(N, density=0.5), rand_dm(N, density=0.5))
+
+    # partial transpose of system 1
+    rho_pt1 = partial_transpose(rho, [1, 0], method="dense")
+    rho_pt2 = partial_transpose(rho, [1, 0], method="sparse")
+    np.abs(np.max(rho_pt1.full() - rho_pt1.full())) < 1e-12
+
+    # partial transpose of system 2
+    rho_pt1 = partial_transpose(rho, [0, 1], method="dense")
+    rho_pt2 = partial_transpose(rho, [0, 1], method="sparse")
+    np.abs(np.max(rho_pt1.full() - rho_pt2.full())) < 1e-12
+
+
+def test_partial_transpose_randomized():
+    """partial transpose: randomized tests on tripartite system"""
+
+    rho = tensor(rand_dm(2, density=1),
+                 rand_dm(2, density=1),
+                 rand_dm(2, density=1))
+
+    mask = np.random.randint(2, size=3)
+
+    rho_pt_ref = _partial_transpose_reference(rho, mask)
+
+    rho_pt1 = partial_transpose(rho, mask, method="dense")
+    np.abs(np.max(rho_pt1.full() - rho_pt_ref.full())) < 1e-12
+
+    rho_pt2 = partial_transpose(rho, mask, method="sparse")
+    np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
+
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/test_qip.py b/qutip/tests/test_qip.py
index 3f34d4f052..d016878710 100644
--- a/qutip/tests/test_qip.py
+++ b/qutip/tests/test_qip.py
@@ -1,46 +1,46 @@
-import sys
-
-import pytest
-
-
-@pytest.fixture
-def without_qutip_qip(monkeypatch):
-    monkeypatch.setitem(sys.modules, "qutip_qip", None)
-    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
-
-
-@pytest.fixture
-def with_qutip_qip_stub(tmp_path, monkeypatch):
-    pkg_dir = tmp_path / "qutip_qip"
-    pkg_dir.mkdir()
-    init_file = pkg_dir / "__init__.py"
-    init_file.write_text("__version__ = 'x.y.z'")
-    circuit_file = pkg_dir / "circuit.py"
-    circuit_file.write_text("class QubitCircuit:\n    pass")
-
-    monkeypatch.syspath_prepend(tmp_path)
-    # Make sure the stub modules is the one imported
-    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
-    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
-
-
-def test_failed_import(without_qutip_qip):
-    # Ensure 'qutip.qip' is not imported yet
-    assert "qutip.qip" not in sys.modules
-    with pytest.raises(
-        ImportError,
-        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
-    ):
-        import qutip.qip
-
-
-def test_with_qip(with_qutip_qip_stub):
-    import qutip.qip
-    import qutip.qip.circuit as circuit
-    from qutip.qip.circuit import QubitCircuit
-    import qutip_qip
-
-    assert qutip.qip.__version__ == "x.y.z"
-    assert qutip.qip is qutip_qip
-    assert circuit is qutip_qip.circuit
-    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
+import sys
+
+import pytest
+
+
+@pytest.fixture
+def without_qutip_qip(monkeypatch):
+    monkeypatch.setitem(sys.modules, "qutip_qip", None)
+    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
+
+
+@pytest.fixture
+def with_qutip_qip_stub(tmp_path, monkeypatch):
+    pkg_dir = tmp_path / "qutip_qip"
+    pkg_dir.mkdir()
+    init_file = pkg_dir / "__init__.py"
+    init_file.write_text("__version__ = 'x.y.z'")
+    circuit_file = pkg_dir / "circuit.py"
+    circuit_file.write_text("class QubitCircuit:\n    pass")
+
+    monkeypatch.syspath_prepend(tmp_path)
+    # Make sure the stub modules is the one imported
+    monkeypatch.delitem(sys.modules, "qutip_qip", raising=False)
+    monkeypatch.delitem(sys.modules, "qutip.qip", raising=False)
+
+
+def test_failed_import(without_qutip_qip):
+    # Ensure 'qutip.qip' is not imported yet
+    assert "qutip.qip" not in sys.modules
+    with pytest.raises(
+        ImportError,
+        match="Importing 'qutip.qip' requires the 'qutip_qip' package.",
+    ):
+        import qutip.qip
+
+
+def test_with_qip(with_qutip_qip_stub):
+    import qutip.qip
+    import qutip.qip.circuit as circuit
+    from qutip.qip.circuit import QubitCircuit
+    import qutip_qip
+
+    assert qutip.qip.__version__ == "x.y.z"
+    assert qutip.qip is qutip_qip
+    assert circuit is qutip_qip.circuit
+    assert QubitCircuit is qutip_qip.circuit.QubitCircuit
diff --git a/qutip/tests/test_qpt.py b/qutip/tests/test_qpt.py
index 896a8da936..c2d092e207 100644
--- a/qutip/tests/test_qpt.py
+++ b/qutip/tests/test_qpt.py
@@ -1,50 +1,50 @@
-import numpy as np
-from numpy.testing import assert_, run_module_suite
-import scipy.linalg as la
-
-from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
-from qutip.core.gates import snot, cnot
-
-
-def test_qpt_snot():
-    "quantum process tomography for snot gate"
-
-    U_psi = snot()
-    U_rho = spre(U_psi) * spost(U_psi.dag())
-    N = 1
-    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
-    # op_label = [["i", "x", "y", "z"] for i in range(N)]
-    chi1 = qpt(U_rho, op_basis)
-
-    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
-    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
-
-    assert_(la.norm(chi2 - chi1) < 1e-8)
-
-
-def test_qpt_cnot():
-    "quantum process tomography for cnot gate"
-
-    U_psi = cnot()
-    U_rho = spre(U_psi) * spost(U_psi.dag())
-    N = 2
-    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
-    # op_label = [["i", "x", "y", "z"] for i in range(N)]
-    chi1 = qpt(U_rho, op_basis)
-
-    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
-    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
-
-    chi2[12, 0] = chi2[12, 1] = 0.25
-    chi2[13, 0] = chi2[13, 1] = -0.25
-
-    chi2[0, 12] = chi2[1, 12] = 0.25
-    chi2[0, 13] = chi2[1, 13] = -0.25
-
-    chi2[12, 12] = chi2[13, 13] = 0.25
-    chi2[13, 12] = chi2[12, 13] = -0.25
-
-    assert_(la.norm(chi2 - chi1) < 1e-8)
-
-if __name__ == "__main__":
-    run_module_suite()
+import numpy as np
+from numpy.testing import assert_, run_module_suite
+import scipy.linalg as la
+
+from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
+from qutip.core.gates import snot, cnot
+
+
+def test_qpt_snot():
+    "quantum process tomography for snot gate"
+
+    U_psi = snot()
+    U_rho = spre(U_psi) * spost(U_psi.dag())
+    N = 1
+    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
+    # op_label = [["i", "x", "y", "z"] for i in range(N)]
+    chi1 = qpt(U_rho, op_basis)
+
+    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
+    chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
+
+    assert_(la.norm(chi2 - chi1) < 1e-8)
+
+
+def test_qpt_cnot():
+    "quantum process tomography for cnot gate"
+
+    U_psi = cnot()
+    U_rho = spre(U_psi) * spost(U_psi.dag())
+    N = 2
+    op_basis = [[qeye(2), sigmax(), 1j * sigmay(), sigmaz()] for i in range(N)]
+    # op_label = [["i", "x", "y", "z"] for i in range(N)]
+    chi1 = qpt(U_rho, op_basis)
+
+    chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
+    chi2[0, 0] = chi2[0, 1] = chi2[1, 0] = chi2[1, 1] = 0.25
+
+    chi2[12, 0] = chi2[12, 1] = 0.25
+    chi2[13, 0] = chi2[13, 1] = -0.25
+
+    chi2[0, 12] = chi2[1, 12] = 0.25
+    chi2[0, 13] = chi2[1, 13] = -0.25
+
+    chi2[12, 12] = chi2[13, 13] = 0.25
+    chi2[13, 12] = chi2[12, 13] = -0.25
+
+    assert_(la.norm(chi2 - chi1) < 1e-8)
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/test_random.py b/qutip/tests/test_random.py
index 8b70029650..13f9554bbf 100644
--- a/qutip/tests/test_random.py
+++ b/qutip/tests/test_random.py
@@ -1,311 +1,311 @@
-import numpy as np
-from numpy.random import SeedSequence, default_rng
-import scipy.sparse as sp
-import scipy.linalg as la
-import pytest
-
-from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
-from qutip import data as _data
-from qutip.random_objects import (
-    rand_herm,
-    rand_unitary,
-    rand_dm,
-    rand_ket,
-    rand_stochastic,
-    rand_super,
-    rand_super_bcsz,
-    rand_kraus_map,
-)
-
-
-@pytest.fixture(params=[
-    12,
-    [8],
-    [2, 2, 3],
-    [[2], [2]]
-], ids=["int", "list", "tensor", "super"])
-def dimensions(request):
-    return request.param
-
-
-@pytest.fixture(
-    params=list(_data.to.dtypes),
-    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
-)
-def dtype(request):
-    return request.param
-
-
-def _assert_density(qobj, density):
-    N = np.sum(qobj.full() != 0)
-    density = N / np.prod(qobj.shape)
-    assert density == pytest.approx(density, abs=0.2)
-
-
-def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
-    if isinstance(dims, int):
-        dims = [dims]
-    N = np.prod(dims)
-    if super and not isinstance(dims[0], list):
-        target_dims_0 = [dims, dims]
-        shape0 = N**2
-    else:
-        target_dims_0 = dims
-        shape0 = N
-
-    if ket:
-        target_dims_1 = [1]
-        shape1 = 1
-    else:
-        target_dims_1 = target_dims_0
-        shape1 = shape0
-
-    assert random_qobj.dims[0] == target_dims_0
-    assert random_qobj.dims[1] == target_dims_1
-    assert random_qobj.shape == (shape0, shape1)
-
-    if dtype:
-        assert isinstance(random_qobj.data, dtype)
-
-
-@pytest.mark.repeat(3)
-@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
-@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
-def test_rand_herm(dimensions, density, distribution, dtype):
-    """
-    Random Qobjs: Hermitian matrix
-    """
-    random_qobj = rand_herm(
-        dimensions,
-        density=density,
-        distribution=distribution,
-        dtype=dtype
-    )
-    if distribution == "pos_def":
-        assert all(random_qobj.eigenenergies() > -1e14)
-    assert random_qobj.isherm
-    assert _data.isherm(random_qobj.data)
-    _assert_metadata(random_qobj, dimensions, dtype)
-    _assert_density(random_qobj, density)
-
-
-@pytest.mark.repeat(3)
-@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
-def test_rand_herm_Eigs(dimensions, density):
-    """
-    Random Qobjs: Hermitian matrix - Eigs given
-    """
-    N = np.prod(dimensions)
-    eigs = np.random.random(N)
-    eigs /= np.sum(eigs)
-    eigs.sort()
-    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
-    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
-    # verify hermitian
-    assert random_qobj.isherm
-    assert _data.isherm(random_qobj.data)
-    _assert_metadata(random_qobj, dimensions)
-    _assert_density(random_qobj, density)
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize('distribution', ["haar", "exp"])
-@pytest.mark.parametrize('density', [0.2, 0.8])
-def test_rand_unitary(dimensions, distribution, density, dtype):
-    """
-    Random Qobjs: Tests that unitaries are actually unitary.
-    """
-    N = np.prod(dimensions)
-    random_qobj = rand_unitary(
-        dimensions, distribution=distribution,
-        density=density, dtype=dtype
-    )
-    I = qeye(dimensions)
-    assert random_qobj * random_qobj.dag() == I
-    _assert_metadata(random_qobj, dimensions, dtype)
-    if distribution == "exp":
-        _assert_density(random_qobj, density)
-
-
-@pytest.mark.repeat(3)
-@pytest.mark.parametrize(["distribution", "kw"], [
-    pytest.param("ginibre", {"rank": 3}),
-    pytest.param("ginibre", {"rank": 1}),
-    pytest.param("hs", {"rank": 0}),
-    pytest.param("pure", {"rank": 1, "density": 0.5}),
-    pytest.param("eigen", {"eigenvalues": True}),
-    pytest.param("herm", {"density": 0.7}),
-    pytest.param("herm", {"density": 0.3}),
-])
-def test_rand_dm(dimensions, kw, dtype, distribution):
-    """
-    Random Qobjs: Density matrix
-    """
-    N = np.prod(dimensions)
-    print(N, kw)
-    if "eigenvalues" in kw:
-        eigs = np.random.random(N)
-        eigs /= np.sum(eigs)
-        eigs.sort()
-        kw["eigenvalues"] = eigs
-
-    random_qobj = rand_dm(
-        dimensions,
-        distribution=distribution,
-        dtype=dtype,
-        **kw
-    )
-    assert abs(random_qobj.tr() - 1.0) < 1e-14
-    # verify all eigvals are >=0
-    assert all(random_qobj.eigenenergies() >= -1e-14)
-    # verify hermitian
-    assert random_qobj.isherm
-    assert _data.isherm(random_qobj.data)
-
-    _assert_metadata(random_qobj, dimensions, dtype)
-
-    eigenvalues = random_qobj.eigenenergies()
-
-    if "rank" in kw:
-        print(kw["rank"], N, kw["rank"] or N)
-        desired_rank = kw["rank"] or N  # 'hs' is full rank.
-        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
-        assert rank == desired_rank
-
-    if "eigenvalues" in kw:
-        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
-
-    if "density" in kw:
-        _assert_density(random_qobj, kw["density"])
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize('kind', ["left", "right"])
-def test_rand_stochastic(dimensions, kind, dtype):
-    """
-    Random Qobjs: Test random stochastic
-    """
-    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
-    axis = {"left":0, "right":1}[kind]
-    np.testing.assert_allclose(
-        np.sum(random_qobj.full(), axis=axis),
-        1, atol=1e-14
-    )
-    _assert_metadata(random_qobj, dimensions, dtype)
-
-
-@pytest.mark.repeat(5)
-@pytest.mark.parametrize('distribution', ["haar", "fill"])
-def test_rand_ket(dimensions, distribution, dtype):
-    """
-    Random Qobjs: Test random ket type and norm.
-    """
-    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
-
-    assert random_qobj.type == 'ket'
-    assert abs(random_qobj.norm() - 1) < 1e-14
-
-    if isinstance(dimensions, int):
-        dims = [dimensions]
-    N = np.prod(dimensions)
-    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
-
-
-@pytest.mark.repeat(2)
-@pytest.mark.parametrize('superrep', ["choi", "super"])
-def test_rand_super(dimensions, dtype, superrep):
-    """
-    Random Qobjs: Super operator.
-    """
-    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
-    assert random_qobj.issuper
-    with CoreOptions(atol=1e-9):
-        assert random_qobj.iscptp
-    assert random_qobj.superrep == superrep
-    _assert_metadata(random_qobj, dimensions, dtype, super=True)
-
-
-@pytest.mark.repeat(2)
-@pytest.mark.parametrize('rank', [None, 4])
-@pytest.mark.parametrize('superrep', ["choi", "super"])
-def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
-    """
-    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
-    """
-
-    random_qobj = rand_super_bcsz(dimensions, rank=rank,
-                                  dtype=dtype, superrep=superrep)
-    assert random_qobj.issuper
-    with CoreOptions(atol=1e-9):
-        assert random_qobj.iscptp
-    assert random_qobj.superrep == superrep
-    _assert_metadata(random_qobj, dimensions, dtype, super=True)
-    if (
-        not rank
-        and isinstance(dimensions, list)
-        and isinstance(dimensions[0], list)
-    ):
-        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
-        rank = np.prod(dimensions)
-    elif not rank:
-        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
-        rank = np.prod(dimensions)**2
-    rank = rank or N
-    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
-    assert obtained_rank == rank
-
-
-@pytest.mark.parametrize("function", [
-    pytest.param(rand_herm, id="rand_herm"),
-    pytest.param(rand_unitary, id="rand_unitary"),
-    pytest.param(rand_dm, id="rand_dm"),
-    pytest.param(rand_ket, id="rand_ket"),
-    pytest.param(rand_stochastic, id="rand_stochastic"),
-    pytest.param(rand_super, id="rand_super"),
-    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
-])
-@pytest.mark.parametrize("seed", [
-    pytest.param(lambda : 123, id="int"),
-    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
-    pytest.param(lambda : default_rng(123), id="Generator")
-])
-def test_random_seeds(function, seed):
-    """
-    Random Qobjs: Random number generator seed
-    """
-    U0 = function(5, seed=seed())
-    U1 = function(5, seed=None)
-    U2 = function(5, seed=seed())
-    assert U0 != U1
-    assert U0 == U2
-
-
-def test_kraus_map(dimensions, dtype):
-    kmap = rand_kraus_map(dimensions, dtype=dtype)
-    _assert_metadata(kmap[0], dimensions, dtype)
-    with CoreOptions(atol=1e-9):
-        assert kraus_to_choi(kmap).iscptp
-
-
-dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
-dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
-@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
-                         ids=[str(dtype) for dtype in dtype_names])
-@pytest.mark.parametrize('func', [
-    rand_herm,
-    rand_unitary,
-    rand_dm,
-    rand_ket,
-    rand_stochastic,
-    rand_super,
-    rand_super_bcsz,
-    rand_kraus_map,
-])
-def test_random_dtype(func, alias, dtype):
-    with CoreOptions(default_dtype=alias):
-        object = func(2)
-        if isinstance(object, Qobj):
-            assert isinstance(object.data, dtype)
-        else:
-            for obj in object:
-                assert isinstance(obj.data, dtype)
+import numpy as np
+from numpy.random import SeedSequence, default_rng
+import scipy.sparse as sp
+import scipy.linalg as la
+import pytest
+
+from qutip import qeye, num, to_kraus, kraus_to_choi, CoreOptions, Qobj
+from qutip import data as _data
+from qutip.random_objects import (
+    rand_herm,
+    rand_unitary,
+    rand_dm,
+    rand_ket,
+    rand_stochastic,
+    rand_super,
+    rand_super_bcsz,
+    rand_kraus_map,
+)
+
+
+@pytest.fixture(params=[
+    12,
+    [8],
+    [2, 2, 3],
+    [[2], [2]]
+], ids=["int", "list", "tensor", "super"])
+def dimensions(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=list(_data.to.dtypes),
+    ids=lambda dtype: str(dtype)[:-2].split(".")[-1]
+)
+def dtype(request):
+    return request.param
+
+
+def _assert_density(qobj, density):
+    N = np.sum(qobj.full() != 0)
+    density = N / np.prod(qobj.shape)
+    assert density == pytest.approx(density, abs=0.2)
+
+
+def _assert_metadata(random_qobj, dims, dtype=None, super=False, ket=False):
+    if isinstance(dims, int):
+        dims = [dims]
+    N = np.prod(dims)
+    if super and not isinstance(dims[0], list):
+        target_dims_0 = [dims, dims]
+        shape0 = N**2
+    else:
+        target_dims_0 = dims
+        shape0 = N
+
+    if ket:
+        target_dims_1 = [1]
+        shape1 = 1
+    else:
+        target_dims_1 = target_dims_0
+        shape1 = shape0
+
+    assert random_qobj.dims[0] == target_dims_0
+    assert random_qobj.dims[1] == target_dims_1
+    assert random_qobj.shape == (shape0, shape1)
+
+    if dtype:
+        assert isinstance(random_qobj.data, dtype)
+
+
+@pytest.mark.repeat(3)
+@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
+@pytest.mark.parametrize('distribution', ["fill", "pos_def"])
+def test_rand_herm(dimensions, density, distribution, dtype):
+    """
+    Random Qobjs: Hermitian matrix
+    """
+    random_qobj = rand_herm(
+        dimensions,
+        density=density,
+        distribution=distribution,
+        dtype=dtype
+    )
+    if distribution == "pos_def":
+        assert all(random_qobj.eigenenergies() > -1e14)
+    assert random_qobj.isherm
+    assert _data.isherm(random_qobj.data)
+    _assert_metadata(random_qobj, dimensions, dtype)
+    _assert_density(random_qobj, density)
+
+
+@pytest.mark.repeat(3)
+@pytest.mark.parametrize('density', [0.2, 0.8], ids=["sparse", "dense"])
+def test_rand_herm_Eigs(dimensions, density):
+    """
+    Random Qobjs: Hermitian matrix - Eigs given
+    """
+    N = np.prod(dimensions)
+    eigs = np.random.random(N)
+    eigs /= np.sum(eigs)
+    eigs.sort()
+    random_qobj = rand_herm(dimensions, density, "eigen", eigenvalues=eigs)
+    np.testing.assert_allclose(random_qobj.eigenenergies(), eigs)
+    # verify hermitian
+    assert random_qobj.isherm
+    assert _data.isherm(random_qobj.data)
+    _assert_metadata(random_qobj, dimensions)
+    _assert_density(random_qobj, density)
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize('distribution', ["haar", "exp"])
+@pytest.mark.parametrize('density', [0.2, 0.8])
+def test_rand_unitary(dimensions, distribution, density, dtype):
+    """
+    Random Qobjs: Tests that unitaries are actually unitary.
+    """
+    N = np.prod(dimensions)
+    random_qobj = rand_unitary(
+        dimensions, distribution=distribution,
+        density=density, dtype=dtype
+    )
+    I = qeye(dimensions)
+    assert random_qobj * random_qobj.dag() == I
+    _assert_metadata(random_qobj, dimensions, dtype)
+    if distribution == "exp":
+        _assert_density(random_qobj, density)
+
+
+@pytest.mark.repeat(3)
+@pytest.mark.parametrize(["distribution", "kw"], [
+    pytest.param("ginibre", {"rank": 3}),
+    pytest.param("ginibre", {"rank": 1}),
+    pytest.param("hs", {"rank": 0}),
+    pytest.param("pure", {"rank": 1, "density": 0.5}),
+    pytest.param("eigen", {"eigenvalues": True}),
+    pytest.param("herm", {"density": 0.7}),
+    pytest.param("herm", {"density": 0.3}),
+])
+def test_rand_dm(dimensions, kw, dtype, distribution):
+    """
+    Random Qobjs: Density matrix
+    """
+    N = np.prod(dimensions)
+    print(N, kw)
+    if "eigenvalues" in kw:
+        eigs = np.random.random(N)
+        eigs /= np.sum(eigs)
+        eigs.sort()
+        kw["eigenvalues"] = eigs
+
+    random_qobj = rand_dm(
+        dimensions,
+        distribution=distribution,
+        dtype=dtype,
+        **kw
+    )
+    assert abs(random_qobj.tr() - 1.0) < 1e-14
+    # verify all eigvals are >=0
+    assert all(random_qobj.eigenenergies() >= -1e-14)
+    # verify hermitian
+    assert random_qobj.isherm
+    assert _data.isherm(random_qobj.data)
+
+    _assert_metadata(random_qobj, dimensions, dtype)
+
+    eigenvalues = random_qobj.eigenenergies()
+
+    if "rank" in kw:
+        print(kw["rank"], N, kw["rank"] or N)
+        desired_rank = kw["rank"] or N  # 'hs' is full rank.
+        rank = sum([abs(E) >= 1e-10 for E in eigenvalues])
+        assert rank == desired_rank
+
+    if "eigenvalues" in kw:
+        np.testing.assert_allclose(eigenvalues, kw["eigenvalues"])
+
+    if "density" in kw:
+        _assert_density(random_qobj, kw["density"])
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize('kind', ["left", "right"])
+def test_rand_stochastic(dimensions, kind, dtype):
+    """
+    Random Qobjs: Test random stochastic
+    """
+    random_qobj = rand_stochastic(dimensions, kind=kind, dtype=dtype)
+    axis = {"left":0, "right":1}[kind]
+    np.testing.assert_allclose(
+        np.sum(random_qobj.full(), axis=axis),
+        1, atol=1e-14
+    )
+    _assert_metadata(random_qobj, dimensions, dtype)
+
+
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize('distribution', ["haar", "fill"])
+def test_rand_ket(dimensions, distribution, dtype):
+    """
+    Random Qobjs: Test random ket type and norm.
+    """
+    random_qobj = rand_ket(dimensions, distribution=distribution, dtype=dtype)
+
+    assert random_qobj.type == 'ket'
+    assert abs(random_qobj.norm() - 1) < 1e-14
+
+    if isinstance(dimensions, int):
+        dims = [dimensions]
+    N = np.prod(dimensions)
+    _assert_metadata(random_qobj, dimensions, dtype, ket=True)
+
+
+@pytest.mark.repeat(2)
+@pytest.mark.parametrize('superrep', ["choi", "super"])
+def test_rand_super(dimensions, dtype, superrep):
+    """
+    Random Qobjs: Super operator.
+    """
+    random_qobj = rand_super(dimensions, dtype=dtype, superrep=superrep)
+    assert random_qobj.issuper
+    with CoreOptions(atol=1e-9):
+        assert random_qobj.iscptp
+    assert random_qobj.superrep == superrep
+    _assert_metadata(random_qobj, dimensions, dtype, super=True)
+
+
+@pytest.mark.repeat(2)
+@pytest.mark.parametrize('rank', [None, 4])
+@pytest.mark.parametrize('superrep', ["choi", "super"])
+def test_rand_super_bcsz(dimensions, dtype, rank, superrep):
+    """
+    Random Qobjs: Tests that BCSZ-random superoperators are CPTP.
+    """
+
+    random_qobj = rand_super_bcsz(dimensions, rank=rank,
+                                  dtype=dtype, superrep=superrep)
+    assert random_qobj.issuper
+    with CoreOptions(atol=1e-9):
+        assert random_qobj.iscptp
+    assert random_qobj.superrep == superrep
+    _assert_metadata(random_qobj, dimensions, dtype, super=True)
+    if (
+        not rank
+        and isinstance(dimensions, list)
+        and isinstance(dimensions[0], list)
+    ):
+        # dimensions = [[a], [a]], qobj.dims = [[[a], [a]], [[a], [a]]]
+        rank = np.prod(dimensions)
+    elif not rank:
+        # dimensions = [a], qobj.dims = [[[a], [a]], [[a], [a]]]
+        rank = np.prod(dimensions)**2
+    rank = rank or N
+    obtained_rank = len(to_kraus(random_qobj, tol=1e-13))
+    assert obtained_rank == rank
+
+
+@pytest.mark.parametrize("function", [
+    pytest.param(rand_herm, id="rand_herm"),
+    pytest.param(rand_unitary, id="rand_unitary"),
+    pytest.param(rand_dm, id="rand_dm"),
+    pytest.param(rand_ket, id="rand_ket"),
+    pytest.param(rand_stochastic, id="rand_stochastic"),
+    pytest.param(rand_super, id="rand_super"),
+    pytest.param(rand_super_bcsz, id="rand_super_bcsz"),
+])
+@pytest.mark.parametrize("seed", [
+    pytest.param(lambda : 123, id="int"),
+    pytest.param(lambda : SeedSequence(123), id="SeedSequence"),
+    pytest.param(lambda : default_rng(123), id="Generator")
+])
+def test_random_seeds(function, seed):
+    """
+    Random Qobjs: Random number generator seed
+    """
+    U0 = function(5, seed=seed())
+    U1 = function(5, seed=None)
+    U2 = function(5, seed=seed())
+    assert U0 != U1
+    assert U0 == U2
+
+
+def test_kraus_map(dimensions, dtype):
+    kmap = rand_kraus_map(dimensions, dtype=dtype)
+    _assert_metadata(kmap[0], dimensions, dtype)
+    with CoreOptions(atol=1e-9):
+        assert kraus_to_choi(kmap).iscptp
+
+
+dtype_names = list(_data.to._str2type.keys()) + list(_data.to.dtypes)
+dtype_types = list(_data.to._str2type.values()) + list(_data.to.dtypes)
+@pytest.mark.parametrize(['alias', 'dtype'], zip(dtype_names, dtype_types),
+                         ids=[str(dtype) for dtype in dtype_names])
+@pytest.mark.parametrize('func', [
+    rand_herm,
+    rand_unitary,
+    rand_dm,
+    rand_ket,
+    rand_stochastic,
+    rand_super,
+    rand_super_bcsz,
+    rand_kraus_map,
+])
+def test_random_dtype(func, alias, dtype):
+    with CoreOptions(default_dtype=alias):
+        object = func(2)
+        if isinstance(object, Qobj):
+            assert isinstance(object.data, dtype)
+        else:
+            for obj in object:
+                assert isinstance(obj.data, dtype)
diff --git a/qutip/tests/test_simdiag.py b/qutip/tests/test_simdiag.py
index b388ad336d..a45076fd60 100644
--- a/qutip/tests/test_simdiag.py
+++ b/qutip/tests/test_simdiag.py
@@ -1,92 +1,92 @@
-import pytest
-import numpy as np
-import qutip
-
-
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
-def test_simdiag(num_mat):
-    N = 10
-
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
-                          for _ in range(num_mat)]
-    all_evals, evecs = qutip.simdiag(commuting_matrices)
-
-    for matrix, evals in zip(commuting_matrices, all_evals):
-        for eval, evec in zip(evals, evecs):
-            assert matrix * evec == evec * eval
-
-
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
-def test_simdiag_no_evals(num_mat):
-    N = 10
-
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
-                          for _ in range(num_mat)]
-    evecs = qutip.simdiag(commuting_matrices, evals=False)
-
-    for matrix in commuting_matrices:
-        for evec in evecs:
-            Mvec = matrix * evec
-            eval = Mvec.norm() / evec.norm()
-            assert matrix * evec == evec * eval
-
-
-@pytest.mark.flaky(reruns=2)
-def test_simdiag_degen():
-    N = 10
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [
-        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
-        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
-        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
-    ]
-    all_evals, evecs = qutip.simdiag(commuting_matrices)
-
-    for matrix, evals in zip(commuting_matrices, all_evals):
-        for eval, evec in zip(evals, evecs):
-            np.testing.assert_allclose(
-                (matrix * evec).full(),
-                (evec * eval).full(),
-                atol=3e-14
-            )
-
-@pytest.mark.flaky(reruns=2)
-@pytest.mark.repeat(2)
-def test_simdiag_degen_large():
-    N = 20
-    U = qutip.rand_unitary(N)
-    commuting_matrices = [
-        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
-        for _ in range(5)
-    ]
-    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
-
-    for matrix, evals in zip(commuting_matrices, all_evals):
-        for eval, evec in zip(evals, evecs):
-            np.testing.assert_allclose(
-                (matrix * evec).full(),
-                (evec * eval).full(),
-                atol=1e-13
-            )
-
-
-def test_simdiag_no_input():
-    with pytest.raises(ValueError):
-        qutip.simdiag([])
-
-
-@pytest.mark.parametrize(['ops', 'error'], [
-    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
-    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
-    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
-    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
-                 id="Not commuting"),
-])
-def test_simdiag_errors(ops, error):
-    with pytest.raises(TypeError) as err:
-        qutip.simdiag(ops)
-    assert error in str(err.value)
+import pytest
+import numpy as np
+import qutip
+
+
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
+def test_simdiag(num_mat):
+    N = 10
+
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
+                          for _ in range(num_mat)]
+    all_evals, evecs = qutip.simdiag(commuting_matrices)
+
+    for matrix, evals in zip(commuting_matrices, all_evals):
+        for eval, evec in zip(evals, evecs):
+            assert matrix * evec == evec * eval
+
+
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.parametrize('num_mat', [1, 2, 3, 5])
+def test_simdiag_no_evals(num_mat):
+    N = 10
+
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [U * qutip.qdiags(np.random.rand(N), 0) * U.dag()
+                          for _ in range(num_mat)]
+    evecs = qutip.simdiag(commuting_matrices, evals=False)
+
+    for matrix in commuting_matrices:
+        for evec in evecs:
+            Mvec = matrix * evec
+            eval = Mvec.norm() / evec.norm()
+            assert matrix * evec == evec * eval
+
+
+@pytest.mark.flaky(reruns=2)
+def test_simdiag_degen():
+    N = 10
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [
+        U * qutip.qdiags([0, 0, 0, 1, 1, 1, 2, 2, 3, 4], 0) * U.dag(),
+        U * qutip.qdiags([0, 0, 0, 1, 2, 2, 2, 2, 2, 2], 0) * U.dag(),
+        U * qutip.qdiags([0, 0, 2, 1, 1, 2, 2, 3, 3, 4], 0) * U.dag(),
+    ]
+    all_evals, evecs = qutip.simdiag(commuting_matrices)
+
+    for matrix, evals in zip(commuting_matrices, all_evals):
+        for eval, evec in zip(evals, evecs):
+            np.testing.assert_allclose(
+                (matrix * evec).full(),
+                (evec * eval).full(),
+                atol=3e-14
+            )
+
+@pytest.mark.flaky(reruns=2)
+@pytest.mark.repeat(2)
+def test_simdiag_degen_large():
+    N = 20
+    U = qutip.rand_unitary(N)
+    commuting_matrices = [
+        U * qutip.qdiags(np.random.randint(0, 3, N), 0) * U.dag()
+        for _ in range(5)
+    ]
+    all_evals, evecs = qutip.simdiag(commuting_matrices, tol=1e-12)
+
+    for matrix, evals in zip(commuting_matrices, all_evals):
+        for eval, evec in zip(evals, evecs):
+            np.testing.assert_allclose(
+                (matrix * evec).full(),
+                (evec * eval).full(),
+                atol=1e-13
+            )
+
+
+def test_simdiag_no_input():
+    with pytest.raises(ValueError):
+        qutip.simdiag([])
+
+
+@pytest.mark.parametrize(['ops', 'error'], [
+    pytest.param([qutip.basis(5, 0)], 'square', id="Not square"),
+    pytest.param([qutip.qeye(5), qutip.qeye(3)], 'shape', id="shape mismatch"),
+    pytest.param([qutip.destroy(5)], 'Hermitian', id="Non Hermitian"),
+    pytest.param([qutip.sigmax(), qutip.sigmay()], 'commute',
+                 id="Not commuting"),
+])
+def test_simdiag_errors(ops, error):
+    with pytest.raises(TypeError) as err:
+        qutip.simdiag(ops)
+    assert error in str(err.value)
diff --git a/qutip/tests/test_subsys_apply.py b/qutip/tests/test_subsys_apply.py
index 0c73ff12df..ed85466625 100644
--- a/qutip/tests/test_subsys_apply.py
+++ b/qutip/tests/test_subsys_apply.py
@@ -1,141 +1,141 @@
-from numpy.linalg import norm
-from numpy.testing import assert_, run_module_suite
-
-from qutip import (
-    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
-    subsystem_apply, rand_dm, rand_unitary,
-)
-from qutip.random_objects import rand_kraus_map
-
-
-class TestSubsysApply(object):
-    """
-    A test class for the QuTiP function for applying superoperators to
-    subsystems.
-    The four tests below determine whether efficient numerics, naive numerics
-    and semi-analytic results are identical.
-    """
-
-    def test_SimpleSingleApply(self):
-        """
-        Non-composite system, operator on Hilbert space.
-        """
-        tol = 1e-12
-        rho_3 = rand_dm(3)
-        single_op = rand_unitary(3)
-        analytic_result = single_op * rho_3 * single_op.dag()
-        naive_result = subsystem_apply(rho_3, single_op, [True],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="SimpleSingle: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_3, single_op, [True])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="SimpleSingle: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
-
-    def test_SimpleSuperApply(self):
-        """
-        Non-composite system, operator on Liouville space.
-        """
-        tol = 1e-12
-        rho_3 = rand_dm(3)
-        superop = kraus_to_super(rand_kraus_map(3))
-        analytic_result = vector_to_operator(superop @
-                                             operator_to_vector(rho_3))
-        naive_result = subsystem_apply(rho_3, superop, [True],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="SimpleSuper: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_3, superop, [True])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="SimpleSuper: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
-
-    def test_ComplexSingleApply(self):
-        """
-        Composite system, operator on Hilbert space.
-        """
-        tol = 1e-12
-        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
-        rho_input = tensor(rho_list)
-        single_op = rand_unitary(3)
-
-        analytic_result = rho_list
-        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
-        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
-        analytic_result = tensor(analytic_result)
-
-        naive_result = subsystem_apply(rho_input, single_op,
-                                       [False, True, False, True, False],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="ComplexSingle: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_input, single_op,
-                                           [False, True, False, True, False])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="ComplexSingle: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
-
-    def test_ComplexSuperApply(self):
-        """
-        Superoperator: Efficient numerics and reference return same result,
-        acting on non-composite system
-        """
-        tol = 1e-10
-        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
-        rho_input = tensor(rho_list)
-        superop = kraus_to_super(rand_kraus_map(3))
-
-        analytic_result = rho_list
-        analytic_result[1] = Qobj(
-            vector_to_operator(
-                superop @ operator_to_vector(analytic_result[1])
-            ))
-        analytic_result[3] = Qobj(
-            vector_to_operator(
-                superop @ operator_to_vector(analytic_result[3])
-            ))
-        analytic_result = tensor(analytic_result)
-
-        naive_result = subsystem_apply(rho_input, superop,
-                                       [False, True, False, True, False],
-                                       reference=True)
-        naive_diff = (analytic_result - naive_result).full()
-        naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
-                msg="ComplexSuper: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
-
-        efficient_result = subsystem_apply(rho_input, superop,
-                                           [False, True, False, True, False])
-        efficient_diff = (efficient_result - analytic_result).full()
-        efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
-                msg="ComplexSuper: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
+from numpy.linalg import norm
+from numpy.testing import assert_, run_module_suite
+
+from qutip import (
+    Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
+    subsystem_apply, rand_dm, rand_unitary,
+)
+from qutip.random_objects import rand_kraus_map
+
+
+class TestSubsysApply(object):
+    """
+    A test class for the QuTiP function for applying superoperators to
+    subsystems.
+    The four tests below determine whether efficient numerics, naive numerics
+    and semi-analytic results are identical.
+    """
+
+    def test_SimpleSingleApply(self):
+        """
+        Non-composite system, operator on Hilbert space.
+        """
+        tol = 1e-12
+        rho_3 = rand_dm(3)
+        single_op = rand_unitary(3)
+        analytic_result = single_op * rho_3 * single_op.dag()
+        naive_result = subsystem_apply(rho_3, single_op, [True],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="SimpleSingle: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_3, single_op, [True])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="SimpleSingle: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
+
+    def test_SimpleSuperApply(self):
+        """
+        Non-composite system, operator on Liouville space.
+        """
+        tol = 1e-12
+        rho_3 = rand_dm(3)
+        superop = kraus_to_super(rand_kraus_map(3))
+        analytic_result = vector_to_operator(superop @
+                                             operator_to_vector(rho_3))
+        naive_result = subsystem_apply(rho_3, superop, [True],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="SimpleSuper: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_3, superop, [True])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="SimpleSuper: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
+
+    def test_ComplexSingleApply(self):
+        """
+        Composite system, operator on Hilbert space.
+        """
+        tol = 1e-12
+        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
+        rho_input = tensor(rho_list)
+        single_op = rand_unitary(3)
+
+        analytic_result = rho_list
+        analytic_result[1] = single_op * analytic_result[1] * single_op.dag()
+        analytic_result[3] = single_op * analytic_result[3] * single_op.dag()
+        analytic_result = tensor(analytic_result)
+
+        naive_result = subsystem_apply(rho_input, single_op,
+                                       [False, True, False, True, False],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="ComplexSingle: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_input, single_op,
+                                           [False, True, False, True, False])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="ComplexSingle: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
+
+    def test_ComplexSuperApply(self):
+        """
+        Superoperator: Efficient numerics and reference return same result,
+        acting on non-composite system
+        """
+        tol = 1e-10
+        rho_list = list(map(rand_dm, [2, 3, 2, 3, 2]))
+        rho_input = tensor(rho_list)
+        superop = kraus_to_super(rand_kraus_map(3))
+
+        analytic_result = rho_list
+        analytic_result[1] = Qobj(
+            vector_to_operator(
+                superop @ operator_to_vector(analytic_result[1])
+            ))
+        analytic_result[3] = Qobj(
+            vector_to_operator(
+                superop @ operator_to_vector(analytic_result[3])
+            ))
+        analytic_result = tensor(analytic_result)
+
+        naive_result = subsystem_apply(rho_input, superop,
+                                       [False, True, False, True, False],
+                                       reference=True)
+        naive_diff = (analytic_result - naive_result).full()
+        naive_diff_norm = norm(naive_diff)
+        assert_(naive_diff_norm < tol,
+                msg="ComplexSuper: naive_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        naive_diff_norm, tol))
+
+        efficient_result = subsystem_apply(rho_input, superop,
+                                           [False, True, False, True, False])
+        efficient_diff = (efficient_result - analytic_result).full()
+        efficient_diff_norm = norm(efficient_diff)
+        assert_(efficient_diff_norm < tol,
+                msg="ComplexSuper: efficient_diff_norm {} "
+                    "is beyond tolerance {}".format(
+                        efficient_diff_norm, tol))
diff --git a/qutip/tests/test_three_level.py b/qutip/tests/test_three_level.py
index 372605d784..6aee63c071 100644
--- a/qutip/tests/test_three_level.py
+++ b/qutip/tests/test_three_level.py
@@ -1,27 +1,27 @@
-import numpy as np
-from numpy.testing import assert_, assert_equal, run_module_suite
-from qutip import basis
-from qutip.three_level_atom import *
-
-
-three_states = three_level_basis()
-three_check = np.empty((3,), dtype=object)
-three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
-three_ops = three_level_ops()
-
-
-def testThreeStates():
-    "Three-level atom: States"
-    assert_equal(np.all(three_states == three_check), True)
-
-
-def testThreeOps():
-    "Three-level atom: Operators"
-    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
-    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
-    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
-    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
-    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
-
-if __name__ == "__main__":
-    run_module_suite()
+import numpy as np
+from numpy.testing import assert_, assert_equal, run_module_suite
+from qutip import basis
+from qutip.three_level_atom import *
+
+
+three_states = three_level_basis()
+three_check = np.empty((3,), dtype=object)
+three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
+three_ops = three_level_ops()
+
+
+def testThreeStates():
+    "Three-level atom: States"
+    assert_equal(np.all(three_states == three_check), True)
+
+
+def testThreeOps():
+    "Three-level atom: Operators"
+    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
+    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
+    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
+    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
+    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/tests/test_transfertensor.py b/qutip/tests/test_transfertensor.py
index 34cacd2c1f..c736ef04ac 100644
--- a/qutip/tests/test_transfertensor.py
+++ b/qutip/tests/test_transfertensor.py
@@ -1,45 +1,45 @@
-import pytest
-import qutip as qt
-import numpy as np
-from qutip.solve.nonmarkov.transfertensor import ttmsolve
-
-
-def test_ttmsolve_jc_model():
-    """
-    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
-    which can also be found in the qutip-notebooks repository.
-    """
-    # Define Hamiltonian and states
-    N, kappa, g = 3, 1.0, 10
-    a = qt.tensor(qt.qeye(2), qt.destroy(N))
-    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
-    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
-    H = g * (a.dag() * sm + a * sm.dag())
-    c_ops = [np.sqrt(kappa) * a]
-    # identity superoperator
-    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
-    E0 = qt.sprepost(Id, Id)
-    # partial trace superoperator
-    ptracesuper = qt.tensor_contract(E0, (1, N))
-    # initial states
-    rho0a = qt.ket2dm(qt.basis(2, 0))
-    psi0c = qt.basis(N, 0)
-    rho0c = qt.ket2dm(psi0c)
-    rho0 = qt.tensor(rho0a, rho0c)
-    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
-                               qt.tensor(qt.qeye(2), psi0c.dag()))
-
-    # calculate exact solution using mesolve
-    times = np.arange(0, 5.0, 0.1)
-    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
-    exact_z = qt.expect(sz, exactsol.states)
-
-    # solve using transfer method
-    learning_times = np.arange(0, 2.0, 0.1)
-    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
-    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
-    ttmsol = ttmsolve(learning_maps, rho0a, times)
-    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
-
-    # check that ttm result and exact solution are close in the learning times
-    assert np.allclose(ttm_z, exact_z, atol=1e-5)
+import pytest
+import qutip as qt
+import numpy as np
+from qutip.solve.nonmarkov.transfertensor import ttmsolve
+
+
+def test_ttmsolve_jc_model():
+    """
+    Checks the output of ttmsolve using an example from Jaynes-Cumming model,
+    which can also be found in the qutip-notebooks repository.
+    """
+    # Define Hamiltonian and states
+    N, kappa, g = 3, 1.0, 10
+    a = qt.tensor(qt.qeye(2), qt.destroy(N))
+    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
+    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
+    H = g * (a.dag() * sm + a * sm.dag())
+    c_ops = [np.sqrt(kappa) * a]
+    # identity superoperator
+    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
+    E0 = qt.sprepost(Id, Id)
+    # partial trace superoperator
+    ptracesuper = qt.tensor_contract(E0, (1, N))
+    # initial states
+    rho0a = qt.ket2dm(qt.basis(2, 0))
+    psi0c = qt.basis(N, 0)
+    rho0c = qt.ket2dm(psi0c)
+    rho0 = qt.tensor(rho0a, rho0c)
+    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
+                               qt.tensor(qt.qeye(2), psi0c.dag()))
+
+    # calculate exact solution using mesolve
+    times = np.arange(0, 5.0, 0.1)
+    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
+    exact_z = qt.expect(sz, exactsol.states)
+
+    # solve using transfer method
+    learning_times = np.arange(0, 2.0, 0.1)
+    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
+    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
+    ttmsol = ttmsolve(learning_maps, rho0a, times)
+    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
+
+    # check that ttm result and exact solution are close in the learning times
+    assert np.allclose(ttm_z, exact_z, atol=1e-5)
diff --git a/qutip/tests/test_utilities.py b/qutip/tests/test_utilities.py
index 648d6a4dc3..f29d8224c6 100644
--- a/qutip/tests/test_utilities.py
+++ b/qutip/tests/test_utilities.py
@@ -1,121 +1,121 @@
-import numpy as np
-from qutip import convert_unit, clebsch, n_thermal
-import qutip.utilities as utils
-from functools import partial
-import pytest
-
-
-@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
-    pytest.param(np.log(2), 1, 1, id='log(2)'),
-    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
-    pytest.param(0, 1, 0, id="0_energy"),
-    pytest.param(1, -1, 0, id="neg_temp"),
-    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
-                 np.array([1, 1/2, 1/3]), id="array"),
-])
-def test_n_thermal(w, w_th, expected):
-    np.testing.assert_allclose(n_thermal(w, w_th), expected)
-
-
-def _get_converter(orig, target):
-    """get funtion 'convert_{}_to_{}' when available for coverage """
-    try:
-        func = getattr(utils, f'convert_{orig}_to_{target}')
-    except AttributeError:
-        func = partial(convert_unit, orig=orig, to=target)
-    return func
-
-
-@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
-@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
-def test_unit_conversions(orig, target):
-    T = np.random.rand() * 100.0
-    T_converted = convert_unit(T, orig=orig, to=target)
-    T_back = convert_unit(T_converted, orig=target, to=orig)
-
-    assert T == pytest.approx(T_back)
-
-    T_converted = _get_converter(orig=orig, target=target)(T)
-    T_back = _get_converter(orig=target, target=orig)(T_converted)
-
-    assert T == pytest.approx(T_back)
-
-
-@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
-@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
-@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
-def test_unit_conversions_loop(orig, middle, target):
-    T = np.random.rand() * 100.0
-    T_middle = convert_unit(T, orig=orig, to=middle)
-    T_converted = convert_unit(T_middle, orig=middle, to=target)
-    T_back = convert_unit(T_converted, orig=target, to=orig)
-
-    assert T == pytest.approx(T_back)
-
-
-def test_unit_conversions_bad_unit():
-    with pytest.raises(TypeError):
-        convert_unit(10, orig="bad", to="J")
-    with pytest.raises(TypeError):
-        convert_unit(10, orig="J", to="bad")
-
-
-@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-def test_unit_clebsch_delta_j(j1, j2):
-    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
-    delta j3,j3' delta m3,m3'"""
-    for _ in range(10):
-        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
-        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
-        m3 = np.random.choice(np.arange(-j3, j3+1))
-        m3p = np.random.choice(np.arange(-j3p, j3p+1))
-
-        sum_match = 0
-        sum_differ = 0
-        for m1 in np.arange(-j1, j1+1):
-            for m2 in np.arange(-j2, j2+1):
-                c1 = clebsch(j1, j2, j3, m1, m2, m3)
-                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
-                sum_match += c1**2
-                sum_differ += c1*c2
-        assert sum_match == pytest.approx(1)
-        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
-
-
-@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
-def test_unit_clebsch_delta_m(j1, j2):
-    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
-    delta m1,m1' delta m2,m2'"""
-    for _ in range(10):
-        m1 = np.random.choice(np.arange(-j1, j1+1))
-        m1p = np.random.choice(np.arange(-j1, j1+1))
-        m2 = np.random.choice(np.arange(-j2, j2+1))
-        m2p = np.random.choice(np.arange(-j2, j2+1))
-
-        sum_match = 0
-        sum_differ = 0
-        for j3 in np.arange(abs(j1-j2), j1+j2+1):
-            for m3 in np.arange(-j3, j3+1):
-                c1 = clebsch(j1, j2, j3, m1, m2, m3)
-                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
-                sum_match += c1**2
-                sum_differ += c1*c2
-        assert sum_match == pytest.approx(1)
-        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
-
-
-def test_cpu_count(monkeypatch):
-    from qutip.settings import available_cpu_count
-    ncpus = available_cpu_count()
-    assert isinstance(ncpus, int)
-    assert ncpus >= 1
-
-    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
-    new_ncpus = available_cpu_count()
-    assert new_ncpus == ncpus + 2
-
-    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
-    new_ncpus = available_cpu_count()
-    assert new_ncpus >= 1
+import numpy as np
+from qutip import convert_unit, clebsch, n_thermal
+import qutip.utilities as utils
+from functools import partial
+import pytest
+
+
+@pytest.mark.parametrize(['w', 'w_th', 'expected'], [
+    pytest.param(np.log(2), 1, 1, id='log(2)'),
+    pytest.param(np.log(2)*5, 5, 1, id='5*log(2)'),
+    pytest.param(0, 1, 0, id="0_energy"),
+    pytest.param(1, -1, 0, id="neg_temp"),
+    pytest.param(np.array([np.log(2), np.log(3), np.log(4)]), 1,
+                 np.array([1, 1/2, 1/3]), id="array"),
+])
+def test_n_thermal(w, w_th, expected):
+    np.testing.assert_allclose(n_thermal(w, w_th), expected)
+
+
+def _get_converter(orig, target):
+    """get funtion 'convert_{}_to_{}' when available for coverage """
+    try:
+        func = getattr(utils, f'convert_{orig}_to_{target}')
+    except AttributeError:
+        func = partial(convert_unit, orig=orig, to=target)
+    return func
+
+
+@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
+@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
+def test_unit_conversions(orig, target):
+    T = np.random.rand() * 100.0
+    T_converted = convert_unit(T, orig=orig, to=target)
+    T_back = convert_unit(T_converted, orig=target, to=orig)
+
+    assert T == pytest.approx(T_back)
+
+    T_converted = _get_converter(orig=orig, target=target)(T)
+    T_back = _get_converter(orig=target, target=orig)(T_converted)
+
+    assert T == pytest.approx(T_back)
+
+
+@pytest.mark.parametrize('orig', ["J", "eV", "meV", "GHz", "mK"])
+@pytest.mark.parametrize('middle', ["J", "eV", "meV", "GHz", "mK"])
+@pytest.mark.parametrize('target', ["J", "eV", "meV", "GHz", "mK"])
+def test_unit_conversions_loop(orig, middle, target):
+    T = np.random.rand() * 100.0
+    T_middle = convert_unit(T, orig=orig, to=middle)
+    T_converted = convert_unit(T_middle, orig=middle, to=target)
+    T_back = convert_unit(T_converted, orig=target, to=orig)
+
+    assert T == pytest.approx(T_back)
+
+
+def test_unit_conversions_bad_unit():
+    with pytest.raises(TypeError):
+        convert_unit(10, orig="bad", to="J")
+    with pytest.raises(TypeError):
+        convert_unit(10, orig="J", to="bad")
+
+
+@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+def test_unit_clebsch_delta_j(j1, j2):
+    """sum_m1 sum_m2 C(j1,j2,j3,m1,m2,m3) * C(j1,j2,j3',m1,m2,m3') =
+    delta j3,j3' delta m3,m3'"""
+    for _ in range(10):
+        j3 = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
+        j3p = np.random.choice(np.arange(abs(j1-j2), j1+j2+1))
+        m3 = np.random.choice(np.arange(-j3, j3+1))
+        m3p = np.random.choice(np.arange(-j3p, j3p+1))
+
+        sum_match = 0
+        sum_differ = 0
+        for m1 in np.arange(-j1, j1+1):
+            for m2 in np.arange(-j2, j2+1):
+                c1 = clebsch(j1, j2, j3, m1, m2, m3)
+                c2 = clebsch(j1, j2, j3p, m1, m2, m3p)
+                sum_match += c1**2
+                sum_differ += c1*c2
+        assert sum_match == pytest.approx(1)
+        assert sum_differ == pytest.approx(int(j3 == j3p and m3 == m3p))
+
+
+@pytest.mark.parametrize('j1', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+@pytest.mark.parametrize('j2', [0.5, 1.0, 1.5, 2.0, 5, 7.5, 10, 12.5])
+def test_unit_clebsch_delta_m(j1, j2):
+    """sum_j3 sum_m3 C(j1,j2,j3,m1,m2,m3)*C(j1,j2,j3,m1',m2',m3) =
+    delta m1,m1' delta m2,m2'"""
+    for _ in range(10):
+        m1 = np.random.choice(np.arange(-j1, j1+1))
+        m1p = np.random.choice(np.arange(-j1, j1+1))
+        m2 = np.random.choice(np.arange(-j2, j2+1))
+        m2p = np.random.choice(np.arange(-j2, j2+1))
+
+        sum_match = 0
+        sum_differ = 0
+        for j3 in np.arange(abs(j1-j2), j1+j2+1):
+            for m3 in np.arange(-j3, j3+1):
+                c1 = clebsch(j1, j2, j3, m1, m2, m3)
+                c2 = clebsch(j1, j2, j3, m1p, m2p, m3)
+                sum_match += c1**2
+                sum_differ += c1*c2
+        assert sum_match == pytest.approx(1)
+        assert sum_differ == pytest.approx(int(m1 == m1p and m2 == m2p))
+
+
+def test_cpu_count(monkeypatch):
+    from qutip.settings import available_cpu_count
+    ncpus = available_cpu_count()
+    assert isinstance(ncpus, int)
+    assert ncpus >= 1
+
+    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(ncpus + 2))
+    new_ncpus = available_cpu_count()
+    assert new_ncpus == ncpus + 2
+
+    monkeypatch.setenv("QUTIP_NUM_PROCESSES", str(0))
+    new_ncpus = available_cpu_count()
+    assert new_ncpus >= 1
diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
index 5dd34556b8..78c5714845 100644
--- a/qutip/tests/test_wigner.py
+++ b/qutip/tests/test_wigner.py
@@ -1,693 +1,693 @@
-import pytest
-import numpy as np
-import itertools
-from scipy.special import laguerre
-from numpy.random import rand
-from numpy.testing import assert_, run_module_suite, assert_equal, \
-    assert_almost_equal, assert_allclose
-
-import qutip
-from qutip.core.states import coherent, fock, ket, bell_state
-from qutip.wigner import wigner, wigner_transform, _parity
-from qutip.random_objects import rand_dm, rand_ket
-
-
-class TestHusimiQ:
-    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
-    def test_failure_if_non_arraylike_coordinates(self, xs):
-        state = qutip.rand_ket(4)
-        valid = np.linspace(-1, 1, 5)
-        with pytest.raises(TypeError) as e:
-            qutip.qfunc(state, xs, valid)
-        assert "must be array-like" in e.value.args[0]
-        with pytest.raises(TypeError) as e:
-            qutip.qfunc(state, valid, xs)
-        assert "must be array-like" in e.value.args[0]
-        with pytest.raises(TypeError) as e:
-            qutip.QFunc(xs, valid)
-        assert "must be array-like" in e.value.args[0]
-        with pytest.raises(TypeError) as e:
-            qutip.QFunc(valid, xs)
-        assert "must be array-like" in e.value.args[0]
-
-    @pytest.mark.parametrize('ndim', [2, 3])
-    def test_failure_if_coordinates_not_1d(self, ndim):
-        state = qutip.rand_ket(4)
-        valid = np.linspace(-1, 1, 5)
-        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, bad, valid)
-        assert "must be 1D" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, valid, bad)
-        assert "must be 1D" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.QFunc(bad, valid)
-        assert "must be 1D" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.QFunc(valid, bad)
-        assert "must be 1D" in e.value.args[0]
-
-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-    def test_failure_if_tensor_hilbert_space(self, dm):
-        if dm:
-            state = qutip.rand_dm([2, 2])
-        else:
-            state = qutip.rand_ket([2, 2])
-        xs = np.linspace(-1, 1, 5)
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, xs, xs)
-        assert "must not have tensor structure" in e.value.args[0]
-        with pytest.raises(ValueError) as e:
-            qutip.QFunc(xs, xs)(state)
-        assert "must not have tensor structure" in e.value.args[0]
-
-    def test_QFunc_raises_if_insufficient_memory(self):
-        xs = np.linspace(-1, 1, 11)
-        state = qutip.rand_ket(4)
-        qfunc = qutip.QFunc(xs, xs, memory=0)
-        with pytest.raises(MemoryError) as e:
-            qfunc(state)
-        assert e.value.args[0].startswith("Refusing to precompute")
-
-    def test_qfunc_warns_if_insufficient_memory(self):
-        xs = np.linspace(-1, 1, 11)
-        state = qutip.rand_dm(4)
-        with pytest.warns(UserWarning) as e:
-            qutip.qfunc(state, xs, xs, precompute_memory=0)
-        assert (
-            e[0].message.args[0]
-            .startswith("Falling back to iterative algorithm")
-        )
-
-    @pytest.mark.parametrize('obj', [
-        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
-        pytest.param([[1, 0], [0, 1]], id='list'),
-        pytest.param(1, id='int'),
-    ])
-    def test_failure_if_not_a_Qobj(self, obj):
-        xs = np.linspace(-1, 1, 11)
-        with pytest.raises(TypeError) as e:
-            qutip.qfunc(obj, xs, xs)
-        assert e.value.args[0].startswith("state must be Qobj")
-        qfunc = qutip.QFunc(xs, xs)
-        with pytest.raises(TypeError) as e:
-            qfunc(obj)
-        assert e.value.args[0].startswith("state must be Qobj")
-
-    # Use indirection so that the tests can still be collected if there's a bug
-    # in the generating QuTiP functions.
-    @pytest.mark.parametrize('state', [
-        pytest.param(lambda: qutip.rand_super(2), id='super'),
-        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
-        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
-        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
-                     id='nonsquare dm'),
-        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
-                     id='operator-ket'),
-        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
-                     id='operator-bra'),
-    ])
-    def test_failure_if_not_a_state(self, state):
-        xs = np.linspace(-1, 1, 11)
-        state = state()
-        with pytest.raises(ValueError) as e:
-            qutip.qfunc(state, xs, xs)
-        assert (
-            e.value.args[0].startswith("state must be a ket or density matrix")
-        )
-        qfunc = qutip.QFunc(xs, xs)
-        with pytest.raises(ValueError) as e:
-            qfunc(state)
-        assert (
-            e.value.args[0].startswith("state must be a ket or density matrix")
-        )
-
-    @pytest.mark.parametrize('g', [
-        pytest.param(np.sqrt(2), id='natural units'),
-        pytest.param(1, id='arb units'),
-    ])
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-    @pytest.mark.parametrize('size', [5, 32])
-    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(0, 2, n_ys)
-        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
-        function = qutip.qfunc(state, xs, ys, g)
-        class_ = qutip.QFunc(xs, ys, g)(state)
-        np.testing.assert_allclose(function, class_)
-
-    @pytest.mark.parametrize('g', [
-        pytest.param(np.sqrt(2), id='natural units'),
-        pytest.param(1, id='arb units'),
-    ])
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('size', [5, 32])
-    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(0, 2, n_ys)
-        state = qutip.rand_dm(size)
-        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
-        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
-        np.testing.assert_allclose(iterate, precompute)
-
-    @pytest.mark.parametrize('initial_size', [5, 8])
-    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
-    def test_same_class_can_take_many_sizes(self, dm, initial_size):
-        xs = np.linspace(-1, 1, 11)
-        ys = np.linspace(0, 2, 11)
-        shape = np.meshgrid(xs, ys)[0].shape
-        sizes = initial_size + np.array([0, 1, -1, 4])
-        qfunc = qutip.QFunc(xs, ys)
-        for size in sizes:
-            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
-            out = qfunc(state)
-            assert isinstance(out, np.ndarray)
-            assert out.shape == shape
-
-    @pytest.mark.parametrize('dm_first', [True, False])
-    def test_same_class_can_mix_ket_and_dm(self, dm_first):
-        dms = [True, False, True, False]
-        if not dm_first:
-            dms = dms[::-1]
-        xs = np.linspace(-1, 1, 11)
-        ys = np.linspace(0, 2, 11)
-        shape = np.meshgrid(xs, ys)[0].shape
-        qfunc = qutip.QFunc(xs, ys)
-        for dm in dms:
-            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
-            out = qfunc(state)
-            assert isinstance(out, np.ndarray)
-            assert out.shape == shape
-
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('mix', [0.1, 0.5])
-    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(-1, 1, n_ys)
-        qfunc = qutip.QFunc(xs, ys)
-        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
-        qleft, qright = qfunc(left), qfunc(right)
-        qboth = qfunc(mix*left + (1-mix)*right)
-        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
-
-    @pytest.mark.parametrize('n_ys', [5, 101])
-    @pytest.mark.parametrize('n_xs', [5, 101])
-    @pytest.mark.parametrize('size', [5, 32])
-    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
-        xs = np.linspace(-1, 1, n_xs)
-        ys = np.linspace(-1, 1, n_ys)
-        state = qutip.rand_ket(size)
-        qfunc = qutip.QFunc(xs, ys)
-        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
-
-    @pytest.mark.parametrize('g', [
-        pytest.param(np.sqrt(2), id='natural units'),
-        pytest.param(1, id='arb units'),
-    ])
-    @pytest.mark.parametrize('ys', [
-        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
-        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
-    ])
-    @pytest.mark.parametrize('xs', [
-        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
-        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
-    ])
-    @pytest.mark.parametrize('size', [3, 5])
-    def test_against_naive_implementation(self, xs, ys, g, size):
-        state = qutip.rand_dm(size)
-        state_np = state.full()
-        x, y = np.meshgrid(xs, ys)
-        alphas = 0.5*g * (x + 1j*y)
-        naive = np.empty(alphas.shape, dtype=np.float64)
-        for i, alpha in enumerate(alphas.flat):
-            coh = qutip.coherent(size, alpha, method='analytic').full()
-            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
-        naive *= (0.5*g)**2 / np.pi
-        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
-        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
-
-
-def test_wigner_bell1_su2parity():
-    """wigner: testing the SU2 parity of the first Bell state.
-    """
-    psi = bell_state('00')
-
-    steps = 25
-    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
-    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
-    slicearray = ['l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
-                                            * np.cos(theta[0, t]))
-                                           * (1 + np.sqrt(3)
-                                           * np.cos(theta[1, t]))
-                                           + 3 * (np.sin(theta[0, t])
-                                           * np.exp(-1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(-1j * phi[1, p])
-                                           + np.sin(theta[0, t])
-                                           * np.exp(1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(1j * phi[1, p]))
-                                           + (1 - np.sqrt(3)
-                                           * np.cos(theta[0, t]))
-                                           * (1 - np.sqrt(3)
-                                           * np.cos(theta[1, t]))) / 8.)
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_bell4_su2parity():
-    """wigner: testing the SU2 parity of the fourth Bell state.
-    """
-    psi = bell_state('11')
-
-    steps = 25
-    slicearray = ['l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = -0.5
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_bell4_fullparity():
-    """wigner: testing the parity of the fourth Bell state using the parity of
-    the full space.
-    """
-    psi = bell_state('11')
-
-    steps = 25
-    slicearray = ['l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = -0.30901699
-
-    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
-
-
-def test_parity():
-    """wigner: testing the parity function.
-    """
-    j = 0.5
-    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
-    assert_(_parity(2, j)[0, 1] < 1e-11)
-    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
-    assert_(_parity(2, j)[1, 0] < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_pure_su2():
-    """wigner: testing the SU2 wigner transformation of a pure state.
-    """
-    psi = (ket([1]))
-    steps = 25
-    theta = np.linspace(0, np.pi, steps)
-    phi = np.linspace(0, 2 * np.pi, steps)
-    theta = theta[None, :]
-    phi = phi[None, :]
-    slicearray = ['l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_wigner_ghz_su2parity():
-    """wigner: testing the SU2 wigner transformation of the GHZ state.
-    """
-    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
-
-    steps = 25
-    N = 3
-    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
-    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
-    slicearray = ['l', 'l', 'l']
-
-    wigner_analyt = np.zeros((steps, steps))
-    for t in range(steps):
-        for p in range(steps):
-            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
-                                           * (1 + np.sqrt(3)
-                                           * np.cos(theta[1, t]))
-                                           * (1 + np.sqrt(3)
-                                           * np.cos(theta[2, t]))
-                                           + 3**(3 / 2) * (np.sin(theta[0, t])
-                                           * np.exp(-1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(-1j * phi[1, p])
-                                           * np.sin(theta[2, t])
-                                           * np.exp(-1j * phi[2, p])
-                                           + np.sin(theta[0, t])
-                                           * np.exp(1j * phi[0, p])
-                                           * np.sin(theta[1, t])
-                                           * np.exp(1j * phi[1, p])
-                                           * np.sin(theta[2, t])
-                                           * np.exp(1j * phi[2, p]))
-                                           + (1 - np.sqrt(3)
-                                           * np.cos(theta[0, t]))
-                                           * (1 - np.sqrt(3)
-                                           * np.cos(theta[1, t]))
-                                           * (1 - np.sqrt(3)
-                                           * np.cos(theta[2, t]))) / 16.)
-
-    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
-
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
-
-
-@pytest.mark.slow
-def test_angle_slicing():
-    """wigner: tests angle slicing.
-    """
-    psi1 = bell_state('00')
-    psi2 = bell_state('01')
-    psi3 = bell_state('10')
-    psi4 = bell_state('11')
-
-    steps = 25
-    j = 0.5
-
-    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
-    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
-    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
-    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
-
-    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
-    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
-    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
-    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
-
-
-def test_wigner_coherent():
-    "wigner: test wigner function calculation for coherent states"
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 20
-    beta = rand() + rand() * 1.0j
-    psi = coherent(N, beta)
-
-    # calculate the wigner function using qutip and analytic formula
-    W_qutip = wigner(psi, xvec, yvec, g=2)
-    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
-    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
-
-    # check difference
-    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
-    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
-
-    # check normalization
-    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_fock():
-    "wigner: test wigner function calculation for Fock states"
-
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 15
-
-    for n in [2, 3, 4, 5, 6]:
-
-        psi = fock(N, n)
-
-        # calculate the wigner function using qutip and analytic formula
-        W_qutip = wigner(psi, xvec, yvec, g=2)
-        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
-        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
-        W_analytic = 2 / np.pi * (-1) ** n * \
-            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
-
-        # check difference
-        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
-        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
-        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
-
-        # check normalization
-        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_compare_methods_dm():
-    "wigner: compare wigner methods for random density matrices"
-
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    # a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 15
-
-    for n in range(10):
-        # try ten different random density matrices
-
-        rho = rand_dm(N, density=0.5 + rand() / 2)
-
-        # calculate the wigner function using qutip and analytic formula
-        W_qutip1 = wigner(rho, xvec, yvec, g=2)
-        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
-
-        # check difference
-        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
-
-        # check normalization
-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_compare_methods_ket():
-    "wigner: compare wigner methods for random state vectors"
-
-    xvec = np.linspace(-5.0, 5.0, 100)
-    yvec = xvec
-
-    X, Y = np.meshgrid(xvec, yvec)
-
-    # a = X + 1j * Y  # consistent with g=2 option to wigner function
-
-    dx = xvec[1] - xvec[0]
-    dy = yvec[1] - yvec[0]
-
-    N = 15
-
-    for n in range(10):
-        # try ten different random density matrices
-
-        psi = rand_ket(N, density=0.5 + rand() / 2)
-
-        # calculate the wigner function using qutip and analytic formula
-        W_qutip1 = wigner(psi, xvec, yvec, g=2)
-        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
-
-        # check difference
-        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
-
-        # check normalization
-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
-
-
-def test_wigner_fft_comparse_ket():
-    "Wigner: Compare Wigner fft and iterative for rand. ket"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_ket(N)
-
-        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
-        W = wigner(rho, xvec, yvec, method='iterative')
-
-        Wdiff = abs(W - Wfft)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-
-def test_wigner_fft_comparse_dm():
-    "Wigner: Compare Wigner fft and iterative for rand. dm"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_dm(N)
-
-        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
-        W = wigner(rho, xvec, yvec, method='iterative')
-
-        Wdiff = abs(W - Wfft)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-
-def test_wigner_clenshaw_iter_dm():
-    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_dm(N)
-
-        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
-        W = wigner(rho, xvec, xvec, method='iterative')
-
-        Wdiff = abs(W - Wclen)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-
-def test_wigner_clenshaw_sp_iter_dm():
-    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
-    N = 20
-    xvec = np.linspace(-10, 10, 128)
-    for i in range(3):
-        rho = rand_dm(N)
-
-        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
-        W = wigner(rho, xvec, xvec, method='iterative')
-
-        Wdiff = abs(W - Wclen)
-        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
-
-@pytest.mark.parametrize(['spin'], [
-    pytest.param(1/2, id="spin-one-half"),
-    pytest.param(3, id="spin-three"),
-    pytest.param(13/2, id="spin-thirteen-half"),
-    pytest.param(7, id="spin-seven")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_q_function(spin, pure):
-    d = int(2*spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Q function
-    theta = np.linspace(0, np.pi, 16, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
-    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
-
-    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
-        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
-        direct_Q = abs(state.dag() * rho * state)
-        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
-
-@pytest.mark.parametrize(['spin'], [
-    pytest.param(1/2, id="spin-one-half"),
-    pytest.param(3, id="spin-three"),
-    pytest.param(13/2, id="spin-thirteen-half"),
-    pytest.param(7, id="spin-seven")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_q_function_normalized(spin, pure):
-    d = int(2 * spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Q function
-    theta = np.linspace(0, np.pi, 128, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
-    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
-
-    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
-    assert_almost_equal(norm, 1, decimal=4)
-
-
-@pytest.mark.parametrize(["spin"], [
-    pytest.param(1/2, id="spin-one-half"),
-    pytest.param(1, id="spin-one"),
-    pytest.param(3/2, id="spin-three-half"),
-    pytest.param(2, id="spin-two")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_wigner_normalized(spin, pure):
-    d = int(2*spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Wigner function
-    theta = np.linspace(0, np.pi, 256, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
-    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
-
-    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
-    assert_almost_equal(norm, 1, decimal=4)
-
-@pytest.mark.parametrize(['spin'], [
-    pytest.param(1 / 2, id="spin-one-half"),
-    pytest.param(1, id="spin-one"),
-    pytest.param(3 / 2, id="spin-three-half"),
-    pytest.param(2, id="spin-two")
-])
-@pytest.mark.parametrize("pure", [
-    pytest.param("pure", id="pure"),
-    pytest.param("herm", id="mixed")
-])
-def test_spin_wigner_overlap(spin, pure, n=5):
-    d = int(2*spin + 1)
-    rho = rand_dm(d, distribution=pure)
-
-    # Points at which to evaluate the spin Wigner function
-    theta = np.linspace(0, np.pi, 256, endpoint=True)
-    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
-    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
-
-    for k in range(n):
-        test_state = rand_dm(d)
-        state_overlap = (test_state*rho).tr().real
-
-        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
-        W_overlap = np.trapz(
-            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
-        assert_almost_equal(W_overlap, state_overlap, decimal=4)
-
-if __name__ == "__main__":
-    run_module_suite()
+import pytest
+import numpy as np
+import itertools
+from scipy.special import laguerre
+from numpy.random import rand
+from numpy.testing import assert_, run_module_suite, assert_equal, \
+    assert_almost_equal, assert_allclose
+
+import qutip
+from qutip.core.states import coherent, fock, ket, bell_state
+from qutip.wigner import wigner, wigner_transform, _parity
+from qutip.random_objects import rand_dm, rand_ket
+
+
+class TestHusimiQ:
+    @pytest.mark.parametrize('xs', ["", 1, None], ids=['str', 'int', 'none'])
+    def test_failure_if_non_arraylike_coordinates(self, xs):
+        state = qutip.rand_ket(4)
+        valid = np.linspace(-1, 1, 5)
+        with pytest.raises(TypeError) as e:
+            qutip.qfunc(state, xs, valid)
+        assert "must be array-like" in e.value.args[0]
+        with pytest.raises(TypeError) as e:
+            qutip.qfunc(state, valid, xs)
+        assert "must be array-like" in e.value.args[0]
+        with pytest.raises(TypeError) as e:
+            qutip.QFunc(xs, valid)
+        assert "must be array-like" in e.value.args[0]
+        with pytest.raises(TypeError) as e:
+            qutip.QFunc(valid, xs)
+        assert "must be array-like" in e.value.args[0]
+
+    @pytest.mark.parametrize('ndim', [2, 3])
+    def test_failure_if_coordinates_not_1d(self, ndim):
+        state = qutip.rand_ket(4)
+        valid = np.linspace(-1, 1, 5)
+        bad = valid.reshape((-1,) + (1,)*(ndim - 1))
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, bad, valid)
+        assert "must be 1D" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, valid, bad)
+        assert "must be 1D" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.QFunc(bad, valid)
+        assert "must be 1D" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.QFunc(valid, bad)
+        assert "must be 1D" in e.value.args[0]
+
+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+    def test_failure_if_tensor_hilbert_space(self, dm):
+        if dm:
+            state = qutip.rand_dm([2, 2])
+        else:
+            state = qutip.rand_ket([2, 2])
+        xs = np.linspace(-1, 1, 5)
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, xs, xs)
+        assert "must not have tensor structure" in e.value.args[0]
+        with pytest.raises(ValueError) as e:
+            qutip.QFunc(xs, xs)(state)
+        assert "must not have tensor structure" in e.value.args[0]
+
+    def test_QFunc_raises_if_insufficient_memory(self):
+        xs = np.linspace(-1, 1, 11)
+        state = qutip.rand_ket(4)
+        qfunc = qutip.QFunc(xs, xs, memory=0)
+        with pytest.raises(MemoryError) as e:
+            qfunc(state)
+        assert e.value.args[0].startswith("Refusing to precompute")
+
+    def test_qfunc_warns_if_insufficient_memory(self):
+        xs = np.linspace(-1, 1, 11)
+        state = qutip.rand_dm(4)
+        with pytest.warns(UserWarning) as e:
+            qutip.qfunc(state, xs, xs, precompute_memory=0)
+        assert (
+            e[0].message.args[0]
+            .startswith("Falling back to iterative algorithm")
+        )
+
+    @pytest.mark.parametrize('obj', [
+        pytest.param(np.eye(2, dtype=np.complex128), id='ndarray'),
+        pytest.param([[1, 0], [0, 1]], id='list'),
+        pytest.param(1, id='int'),
+    ])
+    def test_failure_if_not_a_Qobj(self, obj):
+        xs = np.linspace(-1, 1, 11)
+        with pytest.raises(TypeError) as e:
+            qutip.qfunc(obj, xs, xs)
+        assert e.value.args[0].startswith("state must be Qobj")
+        qfunc = qutip.QFunc(xs, xs)
+        with pytest.raises(TypeError) as e:
+            qfunc(obj)
+        assert e.value.args[0].startswith("state must be Qobj")
+
+    # Use indirection so that the tests can still be collected if there's a bug
+    # in the generating QuTiP functions.
+    @pytest.mark.parametrize('state', [
+        pytest.param(lambda: qutip.rand_super(2), id='super'),
+        pytest.param(lambda: qutip.rand_ket(2).dag(), id='bra'),
+        pytest.param(lambda: 1j*qutip.rand_dm(2), id='non-dm operator'),
+        pytest.param(lambda: qutip.Qobj([[1, 0], [0, 0]], dims=[[2], [2, 1]]),
+                     id='nonsquare dm'),
+        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)),
+                     id='operator-ket'),
+        pytest.param(lambda: qutip.operator_to_vector(qutip.qeye(2)).dag(),
+                     id='operator-bra'),
+    ])
+    def test_failure_if_not_a_state(self, state):
+        xs = np.linspace(-1, 1, 11)
+        state = state()
+        with pytest.raises(ValueError) as e:
+            qutip.qfunc(state, xs, xs)
+        assert (
+            e.value.args[0].startswith("state must be a ket or density matrix")
+        )
+        qfunc = qutip.QFunc(xs, xs)
+        with pytest.raises(ValueError) as e:
+            qfunc(state)
+        assert (
+            e.value.args[0].startswith("state must be a ket or density matrix")
+        )
+
+    @pytest.mark.parametrize('g', [
+        pytest.param(np.sqrt(2), id='natural units'),
+        pytest.param(1, id='arb units'),
+    ])
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+    @pytest.mark.parametrize('size', [5, 32])
+    def test_function_and_class_are_equivalent(self, size, dm, n_xs, n_ys, g):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(0, 2, n_ys)
+        state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
+        function = qutip.qfunc(state, xs, ys, g)
+        class_ = qutip.QFunc(xs, ys, g)(state)
+        np.testing.assert_allclose(function, class_)
+
+    @pytest.mark.parametrize('g', [
+        pytest.param(np.sqrt(2), id='natural units'),
+        pytest.param(1, id='arb units'),
+    ])
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('size', [5, 32])
+    def test_iterate_and_precompute_are_equivalent(self, size, n_xs, n_ys, g):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(0, 2, n_ys)
+        state = qutip.rand_dm(size)
+        iterate = qutip.qfunc(state, xs, ys, g, precompute_memory=None)
+        precompute = qutip.qfunc(state, xs, ys, g, precompute_memory=np.inf)
+        np.testing.assert_allclose(iterate, precompute)
+
+    @pytest.mark.parametrize('initial_size', [5, 8])
+    @pytest.mark.parametrize('dm', [True, False], ids=['dm', 'ket'])
+    def test_same_class_can_take_many_sizes(self, dm, initial_size):
+        xs = np.linspace(-1, 1, 11)
+        ys = np.linspace(0, 2, 11)
+        shape = np.meshgrid(xs, ys)[0].shape
+        sizes = initial_size + np.array([0, 1, -1, 4])
+        qfunc = qutip.QFunc(xs, ys)
+        for size in sizes:
+            state = qutip.rand_dm(size) if dm else qutip.rand_ket(size)
+            out = qfunc(state)
+            assert isinstance(out, np.ndarray)
+            assert out.shape == shape
+
+    @pytest.mark.parametrize('dm_first', [True, False])
+    def test_same_class_can_mix_ket_and_dm(self, dm_first):
+        dms = [True, False, True, False]
+        if not dm_first:
+            dms = dms[::-1]
+        xs = np.linspace(-1, 1, 11)
+        ys = np.linspace(0, 2, 11)
+        shape = np.meshgrid(xs, ys)[0].shape
+        qfunc = qutip.QFunc(xs, ys)
+        for dm in dms:
+            state = qutip.rand_dm(4) if dm else qutip.rand_ket(4)
+            out = qfunc(state)
+            assert isinstance(out, np.ndarray)
+            assert out.shape == shape
+
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('mix', [0.1, 0.5])
+    def test_qfunc_is_linear(self, n_xs, n_ys, mix):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(-1, 1, n_ys)
+        qfunc = qutip.QFunc(xs, ys)
+        left, right = qutip.rand_dm(5), qutip.rand_dm(5)
+        qleft, qright = qfunc(left), qfunc(right)
+        qboth = qfunc(mix*left + (1-mix)*right)
+        np.testing.assert_allclose(mix*qleft + (1-mix)*qright, qboth)
+
+    @pytest.mark.parametrize('n_ys', [5, 101])
+    @pytest.mark.parametrize('n_xs', [5, 101])
+    @pytest.mark.parametrize('size', [5, 32])
+    def test_ket_and_dm_give_same_result(self, n_xs, n_ys, size):
+        xs = np.linspace(-1, 1, n_xs)
+        ys = np.linspace(-1, 1, n_ys)
+        state = qutip.rand_ket(size)
+        qfunc = qutip.QFunc(xs, ys)
+        np.testing.assert_allclose(qfunc(state), qfunc(state.proj()))
+
+    @pytest.mark.parametrize('g', [
+        pytest.param(np.sqrt(2), id='natural units'),
+        pytest.param(1, id='arb units'),
+    ])
+    @pytest.mark.parametrize('ys', [
+        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
+        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
+    ])
+    @pytest.mark.parametrize('xs', [
+        pytest.param(np.linspace(-1, 1, 5), id='(-1,1,5)'),
+        pytest.param(np.linspace(0, 2, 3), id='(0,2,3)'),
+    ])
+    @pytest.mark.parametrize('size', [3, 5])
+    def test_against_naive_implementation(self, xs, ys, g, size):
+        state = qutip.rand_dm(size)
+        state_np = state.full()
+        x, y = np.meshgrid(xs, ys)
+        alphas = 0.5*g * (x + 1j*y)
+        naive = np.empty(alphas.shape, dtype=np.float64)
+        for i, alpha in enumerate(alphas.flat):
+            coh = qutip.coherent(size, alpha, method='analytic').full()
+            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
+        naive *= (0.5*g)**2 / np.pi
+        np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
+        np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))
+
+
+def test_wigner_bell1_su2parity():
+    """wigner: testing the SU2 parity of the first Bell state.
+    """
+    psi = bell_state('00')
+
+    steps = 25
+    theta = np.tile(np.linspace(0, np.pi, steps), 2).reshape(2, steps)
+    phi = np.tile(np.linspace(0, 2 * np.pi, steps), 2).reshape(2, steps)
+    slicearray = ['l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)
+                                            * np.cos(theta[0, t]))
+                                           * (1 + np.sqrt(3)
+                                           * np.cos(theta[1, t]))
+                                           + 3 * (np.sin(theta[0, t])
+                                           * np.exp(-1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(-1j * phi[1, p])
+                                           + np.sin(theta[0, t])
+                                           * np.exp(1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(1j * phi[1, p]))
+                                           + (1 - np.sqrt(3)
+                                           * np.cos(theta[0, t]))
+                                           * (1 - np.sqrt(3)
+                                           * np.cos(theta[1, t]))) / 8.)
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_bell4_su2parity():
+    """wigner: testing the SU2 parity of the fourth Bell state.
+    """
+    psi = bell_state('11')
+
+    steps = 25
+    slicearray = ['l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = -0.5
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_bell4_fullparity():
+    """wigner: testing the parity of the fourth Bell state using the parity of
+    the full space.
+    """
+    psi = bell_state('11')
+
+    steps = 25
+    slicearray = ['l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = -0.30901699
+
+    wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
+
+
+def test_parity():
+    """wigner: testing the parity function.
+    """
+    j = 0.5
+    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
+    assert_(_parity(2, j)[0, 1] < 1e-11)
+    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
+    assert_(_parity(2, j)[1, 0] < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_pure_su2():
+    """wigner: testing the SU2 wigner transformation of a pure state.
+    """
+    psi = (ket([1]))
+    steps = 25
+    theta = np.linspace(0, np.pi, steps)
+    phi = np.linspace(0, 2 * np.pi, steps)
+    theta = theta[None, :]
+    phi = phi[None, :]
+    slicearray = ['l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = (1 + np.sqrt(3) * np.cos(theta[0, t])) / 2.
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_wigner_ghz_su2parity():
+    """wigner: testing the SU2 wigner transformation of the GHZ state.
+    """
+    psi = (ket([0, 0, 0]) + ket([1, 1, 1])) / np.sqrt(2)
+
+    steps = 25
+    N = 3
+    theta = np.tile(np.linspace(0, np.pi, steps), N).reshape(N, steps)
+    phi = np.tile(np.linspace(0, 2 * np.pi, steps), N).reshape(N, steps)
+    slicearray = ['l', 'l', 'l']
+
+    wigner_analyt = np.zeros((steps, steps))
+    for t in range(steps):
+        for p in range(steps):
+            wigner_analyt[t, p] = np.real(((1 + np.sqrt(3)*np.cos(theta[0, t]))
+                                           * (1 + np.sqrt(3)
+                                           * np.cos(theta[1, t]))
+                                           * (1 + np.sqrt(3)
+                                           * np.cos(theta[2, t]))
+                                           + 3**(3 / 2) * (np.sin(theta[0, t])
+                                           * np.exp(-1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(-1j * phi[1, p])
+                                           * np.sin(theta[2, t])
+                                           * np.exp(-1j * phi[2, p])
+                                           + np.sin(theta[0, t])
+                                           * np.exp(1j * phi[0, p])
+                                           * np.sin(theta[1, t])
+                                           * np.exp(1j * phi[1, p])
+                                           * np.sin(theta[2, t])
+                                           * np.exp(1j * phi[2, p]))
+                                           + (1 - np.sqrt(3)
+                                           * np.cos(theta[0, t]))
+                                           * (1 - np.sqrt(3)
+                                           * np.cos(theta[1, t]))
+                                           * (1 - np.sqrt(3)
+                                           * np.cos(theta[2, t]))) / 16.)
+
+    wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
+
+    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+
+
+@pytest.mark.slow
+def test_angle_slicing():
+    """wigner: tests angle slicing.
+    """
+    psi1 = bell_state('00')
+    psi2 = bell_state('01')
+    psi3 = bell_state('10')
+    psi4 = bell_state('11')
+
+    steps = 25
+    j = 0.5
+
+    wigner1 = wigner_transform(psi1, j, False, steps, ['l', 'l'])
+    wigner2 = wigner_transform(psi2, j, False, steps, ['l', 'z'])
+    wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
+    wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
+
+    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
+    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
+    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
+    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
+
+
+def test_wigner_coherent():
+    "wigner: test wigner function calculation for coherent states"
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 20
+    beta = rand() + rand() * 1.0j
+    psi = coherent(N, beta)
+
+    # calculate the wigner function using qutip and analytic formula
+    W_qutip = wigner(psi, xvec, yvec, g=2)
+    W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
+    W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
+
+    # check difference
+    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
+    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
+
+    # check normalization
+    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_fock():
+    "wigner: test wigner function calculation for Fock states"
+
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 15
+
+    for n in [2, 3, 4, 5, 6]:
+
+        psi = fock(N, n)
+
+        # calculate the wigner function using qutip and analytic formula
+        W_qutip = wigner(psi, xvec, yvec, g=2)
+        W_qutip_cl = wigner(psi, xvec, yvec, g=2, method='clenshaw')
+        W_qutip_sparse = wigner(psi, xvec, yvec, g=2, sparse=True, method='clenshaw')
+        W_analytic = 2 / np.pi * (-1) ** n * \
+            np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
+
+        # check difference
+        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
+        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
+        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
+
+        # check normalization
+        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_compare_methods_dm():
+    "wigner: compare wigner methods for random density matrices"
+
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    # a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 15
+
+    for n in range(10):
+        # try ten different random density matrices
+
+        rho = rand_dm(N, density=0.5 + rand() / 2)
+
+        # calculate the wigner function using qutip and analytic formula
+        W_qutip1 = wigner(rho, xvec, yvec, g=2)
+        W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
+
+        # check difference
+        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
+
+        # check normalization
+        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_compare_methods_ket():
+    "wigner: compare wigner methods for random state vectors"
+
+    xvec = np.linspace(-5.0, 5.0, 100)
+    yvec = xvec
+
+    X, Y = np.meshgrid(xvec, yvec)
+
+    # a = X + 1j * Y  # consistent with g=2 option to wigner function
+
+    dx = xvec[1] - xvec[0]
+    dy = yvec[1] - yvec[0]
+
+    N = 15
+
+    for n in range(10):
+        # try ten different random density matrices
+
+        psi = rand_ket(N, density=0.5 + rand() / 2)
+
+        # calculate the wigner function using qutip and analytic formula
+        W_qutip1 = wigner(psi, xvec, yvec, g=2)
+        W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
+
+        # check difference
+        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
+
+        # check normalization
+        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+
+
+def test_wigner_fft_comparse_ket():
+    "Wigner: Compare Wigner fft and iterative for rand. ket"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_ket(N)
+
+        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
+        W = wigner(rho, xvec, yvec, method='iterative')
+
+        Wdiff = abs(W - Wfft)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+
+def test_wigner_fft_comparse_dm():
+    "Wigner: Compare Wigner fft and iterative for rand. dm"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_dm(N)
+
+        Wfft, yvec = wigner(rho, xvec, xvec, method='fft')
+        W = wigner(rho, xvec, yvec, method='iterative')
+
+        Wdiff = abs(W - Wfft)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+
+def test_wigner_clenshaw_iter_dm():
+    "Wigner: Compare Wigner clenshaw and iterative for rand. dm"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_dm(N)
+
+        Wclen = wigner(rho, xvec, xvec, method='clenshaw')
+        W = wigner(rho, xvec, xvec, method='iterative')
+
+        Wdiff = abs(W - Wclen)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+
+def test_wigner_clenshaw_sp_iter_dm():
+    "Wigner: Compare Wigner sparse clenshaw and iterative for rand. dm"
+    N = 20
+    xvec = np.linspace(-10, 10, 128)
+    for i in range(3):
+        rho = rand_dm(N)
+
+        Wclen = wigner(rho, xvec, xvec, method='clenshaw', sparse=True)
+        W = wigner(rho, xvec, xvec, method='iterative')
+
+        Wdiff = abs(W - Wclen)
+        assert_equal(np.sum(abs(Wdiff)) < 1e-7, True)
+
+@pytest.mark.parametrize(['spin'], [
+    pytest.param(1/2, id="spin-one-half"),
+    pytest.param(3, id="spin-three"),
+    pytest.param(13/2, id="spin-thirteen-half"),
+    pytest.param(7, id="spin-seven")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_q_function(spin, pure):
+    d = int(2*spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Q function
+    theta = np.linspace(0, np.pi, 16, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 32, endpoint=True)
+    Q, _, _ = qutip.spin_q_function(rho, theta, phi)
+
+    for k, (phi_prime, theta_prime) in enumerate(itertools.product(phi, theta)):
+        state = qutip.spin_coherent(spin, theta_prime, phi_prime)
+        direct_Q = abs(state.dag() * rho * state)
+        assert_almost_equal(Q.flat[k], direct_Q, decimal=9)
+
+@pytest.mark.parametrize(['spin'], [
+    pytest.param(1/2, id="spin-one-half"),
+    pytest.param(3, id="spin-three"),
+    pytest.param(13/2, id="spin-thirteen-half"),
+    pytest.param(7, id="spin-seven")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_q_function_normalized(spin, pure):
+    d = int(2 * spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Q function
+    theta = np.linspace(0, np.pi, 128, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 256, endpoint=True)
+    Q, THETA, _ = qutip.spin_q_function(rho, theta, phi)
+
+    norm = d / (4 * np.pi) * np.trapz(np.trapz(Q * np.sin(THETA), theta), phi)
+    assert_almost_equal(norm, 1, decimal=4)
+
+
+@pytest.mark.parametrize(["spin"], [
+    pytest.param(1/2, id="spin-one-half"),
+    pytest.param(1, id="spin-one"),
+    pytest.param(3/2, id="spin-three-half"),
+    pytest.param(2, id="spin-two")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_wigner_normalized(spin, pure):
+    d = int(2*spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Wigner function
+    theta = np.linspace(0, np.pi, 256, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
+    W, THETA, PHI = qutip.spin_wigner(rho, theta, phi)
+
+    norm = np.trapz(np.trapz(W * np.sin(THETA) * np.sqrt(d / (4*np.pi)), theta), phi)
+    assert_almost_equal(norm, 1, decimal=4)
+
+@pytest.mark.parametrize(['spin'], [
+    pytest.param(1 / 2, id="spin-one-half"),
+    pytest.param(1, id="spin-one"),
+    pytest.param(3 / 2, id="spin-three-half"),
+    pytest.param(2, id="spin-two")
+])
+@pytest.mark.parametrize("pure", [
+    pytest.param("pure", id="pure"),
+    pytest.param("herm", id="mixed")
+])
+def test_spin_wigner_overlap(spin, pure, n=5):
+    d = int(2*spin + 1)
+    rho = rand_dm(d, distribution=pure)
+
+    # Points at which to evaluate the spin Wigner function
+    theta = np.linspace(0, np.pi, 256, endpoint=True)
+    phi = np.linspace(-np.pi, np.pi, 512, endpoint=True)
+    W, THETA, _ = qutip.spin_wigner(rho, theta, phi)
+
+    for k in range(n):
+        test_state = rand_dm(d)
+        state_overlap = (test_state*rho).tr().real
+
+        W_state, _, _ = qutip.spin_wigner(test_state, theta, phi)
+        W_overlap = np.trapz(
+            np.trapz(W_state * W * np.sin(THETA), theta), phi).real
+        assert_almost_equal(W_overlap, state_overlap, decimal=4)
+
+if __name__ == "__main__":
+    run_module_suite()
diff --git a/qutip/three_level_atom.py b/qutip/three_level_atom.py
index 8db037df9c..eee506ef56 100644
--- a/qutip/three_level_atom.py
+++ b/qutip/three_level_atom.py
@@ -1,74 +1,74 @@
-r'''
-This module provides functions that are useful for simulating the
-three level atom with QuTiP.  A three level atom (qutrit) has three states,
-which are linked by dipole transitions so that 1 <-> 2 <-> 3.
-Depending on there relative energies they are in the ladder, lambda or
-vee configuration. The structure of the relevant operators is the same
-for any of the three configurations::
-
-    Ladder:          Lambda:                 Vee:
-                                |two>                       |three>
-      -------|three>           -------                      -------
-         |                       / \             |one>         /
-         |                      /   \           -------       /
-         |                     /     \             \         /
-      -------|two>            /       \             \       /
-         |                   /         \             \     /
-         |                  /           \             \   /
-         |                 /        --------           \ /
-      -------|one>      -------      |three>         -------
-                         |one>                       |two>
-
-References
-----------
-The naming of qutip operators follows the convention in [1]_ .
-
-.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
-   Wiley, 1990.
-
-Notes
------
-Contributed by Markus Baden, Oct. 07, 2011
-
-'''
-
-__all__ = ['three_level_basis', 'three_level_ops']
-
-import numpy as np
-from . import qutrit_basis
-
-
-def three_level_basis():
-    ''' Basis states for a three level atom.
-
-    Returns
-    -------
-    states : np.array
-        :obj:`numpy.ndarray` of three level atom basis vectors.
-    '''
-    # A three level atom has the same representation as a qutrit, i.e.
-    # three states
-    return qutrit_basis()
-
-
-def three_level_ops():
-    """
-    Operators for a three level system (qutrit)
-
-    Returns
-    -------
-    ops : np.array
-        :obj:`numpy.ndarray` of three level operators.
-    """
-    out = np.empty((5,), dtype=object)
-    one, two, three = qutrit_basis()
-    # Note that the three level operators are different
-    # from the qutrit operators. A three level atom only
-    # has transitions 1 <-> 2 <-> 3, so we define the
-    # operators seperately from the qutrit code
-    out[0] = one * one.dag()
-    out[1] = two * two.dag()
-    out[2] = three * three.dag()
-    out[3] = one * two.dag()
-    out[4] = three * two.dag()
-    return out
+r'''
+This module provides functions that are useful for simulating the
+three level atom with QuTiP.  A three level atom (qutrit) has three states,
+which are linked by dipole transitions so that 1 <-> 2 <-> 3.
+Depending on there relative energies they are in the ladder, lambda or
+vee configuration. The structure of the relevant operators is the same
+for any of the three configurations::
+
+    Ladder:          Lambda:                 Vee:
+                                |two>                       |three>
+      -------|three>           -------                      -------
+         |                       / \             |one>         /
+         |                      /   \           -------       /
+         |                     /     \             \         /
+      -------|two>            /       \             \       /
+         |                   /         \             \     /
+         |                  /           \             \   /
+         |                 /        --------           \ /
+      -------|one>      -------      |three>         -------
+                         |one>                       |two>
+
+References
+----------
+The naming of qutip operators follows the convention in [1]_ .
+
+.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
+   Wiley, 1990.
+
+Notes
+-----
+Contributed by Markus Baden, Oct. 07, 2011
+
+'''
+
+__all__ = ['three_level_basis', 'three_level_ops']
+
+import numpy as np
+from . import qutrit_basis
+
+
+def three_level_basis():
+    ''' Basis states for a three level atom.
+
+    Returns
+    -------
+    states : np.array
+        :obj:`numpy.ndarray` of three level atom basis vectors.
+    '''
+    # A three level atom has the same representation as a qutrit, i.e.
+    # three states
+    return qutrit_basis()
+
+
+def three_level_ops():
+    """
+    Operators for a three level system (qutrit)
+
+    Returns
+    -------
+    ops : np.array
+        :obj:`numpy.ndarray` of three level operators.
+    """
+    out = np.empty((5,), dtype=object)
+    one, two, three = qutrit_basis()
+    # Note that the three level operators are different
+    # from the qutrit operators. A three level atom only
+    # has transitions 1 <-> 2 <-> 3, so we define the
+    # operators seperately from the qutrit code
+    out[0] = one * one.dag()
+    out[1] = two * two.dag()
+    out[2] = three * three.dag()
+    out[3] = one * two.dag()
+    out[4] = three * two.dag()
+    return out
diff --git a/qutip/tomography.py b/qutip/tomography.py
index bf83020e83..a663ee30b4 100644
--- a/qutip/tomography.py
+++ b/qutip/tomography.py
@@ -1,190 +1,190 @@
-__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
-
-from numpy import hstack, real, imag
-import scipy.linalg as la
-from . import tensor, spre, spost, stack_columns, unstack_columns
-from .visualization import matrix_histogram, matrix_histogram_complex
-
-try:
-    import matplotlib.pyplot as plt
-except:
-    pass
-
-
-def _index_permutations(size_list, perm=[]):
-    """
-    Generate a list with all index permutations.
-
-    Parameters
-    ----------
-    size_list : list
-        A list that contains the sizes for each composite system.
-    perm : list
-        A list of permutations
-
-    Returns
-    -------
-    perm_idx : list
-        List containing index permutations.
-
-
-    """
-    if len(size_list) == 0:
-        yield perm
-    else:
-        for n in range(size_list[0]):
-            for ip in _index_permutations(size_list[1:], perm + [n]):
-                yield ip
-
-
-def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
-    """
-    Visualize the quantum process tomography chi matrix. Plot the real and
-    imaginary parts separately.
-
-    Parameters
-    ----------
-    chi : array
-        Input QPT chi matrix.
-    lbls_list : list
-        List of labels for QPT plot axes.
-    title : string
-        Plot title.
-    fig : figure instance
-        User defined figure instance used for generating QPT plot.
-    axes : list of figure axis instance
-        User defined figure axis instance (list of two axes) used for
-        generating QPT plot.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    if axes is None or len(axes) != 2:
-        if fig is None:
-            fig = plt.figure(figsize=(16, 8))
-
-        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
-        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
-
-        axes = [ax1, ax2]
-
-    xlabels = []
-    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
-        xlabels.append("".join([lbls_list[k][inds[k]]
-                                for k in range(len(lbls_list))]))
-
-    matrix_histogram(real(chi), xlabels, xlabels,
-                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
-    matrix_histogram(imag(chi), xlabels, xlabels,
-                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
-
-    if title and fig:
-        fig.suptitle(title)
-
-    return fig, axes
-
-
-def qpt_plot_combined(chi, lbls_list, title=None,
-                      fig=None, ax=None, figsize=(8, 6),
-                      threshold=None):
-    """
-    Visualize the quantum process tomography chi matrix. Plot bars with
-    height and color corresponding to the absolute value and phase,
-    respectively.
-
-    Parameters
-    ----------
-    chi : array
-        Input QPT chi matrix.
-
-    lbls_list : list
-        List of labels for QPT plot axes.
-
-    title : string
-        Plot title.
-
-    fig : figure instance
-        User defined figure instance used for generating QPT plot.
-
-    ax : figure axis instance
-        User defined figure axis instance used for generating QPT plot
-        (alternative to the fig argument).
-
-    threshold: float (None)
-        Threshold for when bars of smaller height should be transparent. If
-        not set, all bars are colored according to the color map.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if ax is None:
-        if fig is None:
-            fig = plt.figure(figsize=figsize)
-        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
-
-    xlabels = []
-    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
-        xlabels.append("".join(
-            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
-
-    if not title:
-        title = r"$\chi$"
-
-    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
-                             threshold=threshold)
-
-    return fig, ax
-
-
-def qpt(U, op_basis_list):
-    """
-    Calculate the quantum process tomography chi matrix for a given (possibly
-    nonunitary) transformation matrix U, which transforms a density matrix in
-    vector form according to:
-
-        vec(rho) = U * vec(rho0)
-
-        or
-
-        rho = unstack_columns(U * stack_columns(rho0))
-
-    U can be calculated for an open quantum system using the QuTiP propagator
-    function.
-
-    Parameters
-    ----------
-    U : Qobj
-        Transformation operator. Can be calculated using QuTiP propagator
-        function.
-
-    op_basis_list : list
-        A list of Qobj's representing the basis states.
-
-    Returns
-    -------
-    chi : array
-        QPT chi matrix
-
-    """
-
-    E_ops = []
-    # loop over all index permutations
-    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
-        # loop over all composite systems
-        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
-            op_basis_list))]
-        E_ops.append(tensor(E_op_list))
-    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
-    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
-    Uvec = U.full().ravel('F')
-    chi_vec = la.solve(M, Uvec)
-    return chi_vec.reshape(U.shape).T
+__all__ = ['qpt_plot', 'qpt_plot_combined', 'qpt']
+
+from numpy import hstack, real, imag
+import scipy.linalg as la
+from . import tensor, spre, spost, stack_columns, unstack_columns
+from .visualization import matrix_histogram, matrix_histogram_complex
+
+try:
+    import matplotlib.pyplot as plt
+except:
+    pass
+
+
+def _index_permutations(size_list, perm=[]):
+    """
+    Generate a list with all index permutations.
+
+    Parameters
+    ----------
+    size_list : list
+        A list that contains the sizes for each composite system.
+    perm : list
+        A list of permutations
+
+    Returns
+    -------
+    perm_idx : list
+        List containing index permutations.
+
+
+    """
+    if len(size_list) == 0:
+        yield perm
+    else:
+        for n in range(size_list[0]):
+            for ip in _index_permutations(size_list[1:], perm + [n]):
+                yield ip
+
+
+def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
+    """
+    Visualize the quantum process tomography chi matrix. Plot the real and
+    imaginary parts separately.
+
+    Parameters
+    ----------
+    chi : array
+        Input QPT chi matrix.
+    lbls_list : list
+        List of labels for QPT plot axes.
+    title : string
+        Plot title.
+    fig : figure instance
+        User defined figure instance used for generating QPT plot.
+    axes : list of figure axis instance
+        User defined figure axis instance (list of two axes) used for
+        generating QPT plot.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+
+    if axes is None or len(axes) != 2:
+        if fig is None:
+            fig = plt.figure(figsize=(16, 8))
+
+        ax1 = fig.add_subplot(1, 2, 1, projection='3d', position=[0, 0, 1, 1])
+        ax2 = fig.add_subplot(1, 2, 2, projection='3d', position=[0, 0, 1, 1])
+
+        axes = [ax1, ax2]
+
+    xlabels = []
+    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
+        xlabels.append("".join([lbls_list[k][inds[k]]
+                                for k in range(len(lbls_list))]))
+
+    matrix_histogram(real(chi), xlabels, xlabels,
+                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
+    matrix_histogram(imag(chi), xlabels, xlabels,
+                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
+
+    if title and fig:
+        fig.suptitle(title)
+
+    return fig, axes
+
+
+def qpt_plot_combined(chi, lbls_list, title=None,
+                      fig=None, ax=None, figsize=(8, 6),
+                      threshold=None):
+    """
+    Visualize the quantum process tomography chi matrix. Plot bars with
+    height and color corresponding to the absolute value and phase,
+    respectively.
+
+    Parameters
+    ----------
+    chi : array
+        Input QPT chi matrix.
+
+    lbls_list : list
+        List of labels for QPT plot axes.
+
+    title : string
+        Plot title.
+
+    fig : figure instance
+        User defined figure instance used for generating QPT plot.
+
+    ax : figure axis instance
+        User defined figure axis instance used for generating QPT plot
+        (alternative to the fig argument).
+
+    threshold: float (None)
+        Threshold for when bars of smaller height should be transparent. If
+        not set, all bars are colored according to the color map.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if ax is None:
+        if fig is None:
+            fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(1, 1, 1, projection='3d', position=[0, 0, 1, 1])
+
+    xlabels = []
+    for inds in _index_permutations([len(lbls) for lbls in lbls_list]):
+        xlabels.append("".join(
+            [lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
+
+    if not title:
+        title = r"$\chi$"
+
+    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
+                             threshold=threshold)
+
+    return fig, ax
+
+
+def qpt(U, op_basis_list):
+    """
+    Calculate the quantum process tomography chi matrix for a given (possibly
+    nonunitary) transformation matrix U, which transforms a density matrix in
+    vector form according to:
+
+        vec(rho) = U * vec(rho0)
+
+        or
+
+        rho = unstack_columns(U * stack_columns(rho0))
+
+    U can be calculated for an open quantum system using the QuTiP propagator
+    function.
+
+    Parameters
+    ----------
+    U : Qobj
+        Transformation operator. Can be calculated using QuTiP propagator
+        function.
+
+    op_basis_list : list
+        A list of Qobj's representing the basis states.
+
+    Returns
+    -------
+    chi : array
+        QPT chi matrix
+
+    """
+
+    E_ops = []
+    # loop over all index permutations
+    for inds in _index_permutations([len(ops) for ops in op_basis_list]):
+        # loop over all composite systems
+        E_op_list = [op_basis_list[k][inds[k]] for k in range(len(
+            op_basis_list))]
+        E_ops.append(tensor(E_op_list))
+    EE_ops = [spre(E1) * spost(E2.dag()) for E1 in E_ops for E2 in E_ops]
+    M = hstack([EE.full().ravel('F')[:, None] for EE in EE_ops])
+    Uvec = U.full().ravel('F')
+    chi_vec = la.solve(M, Uvec)
+    return chi_vec.reshape(U.shape).T
diff --git a/qutip/ui/__init__.py b/qutip/ui/__init__.py
index a640ed1f53..d9fdd46838 100644
--- a/qutip/ui/__init__.py
+++ b/qutip/ui/__init__.py
@@ -1 +1 @@
-from qutip.ui.progressbar import *
+from qutip.ui.progressbar import *
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index a862a24d98..8bebca7038 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -1,212 +1,212 @@
-__all__ = ['BaseProgressBar', 'TextProgressBar',
-           'EnhancedTextProgressBar', 'TqdmProgressBar',
-           'HTMLProgressBar', 'progess_bars']
-
-import time
-import datetime
-import sys
-
-
-class BaseProgressBar(object):
-    """
-    An abstract progress bar with some shared functionality.
-
-    Example usage:
-
-        n_vec = linspace(0, 10, 100)
-        pbar = TextProgressBar(len(n_vec))
-        for n in n_vec:
-            pbar.update(n)
-            compute_with_n(n)
-        pbar.finished()
-
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        self.N = float(iterations)
-        self.n = 0
-        self.p_chunk_size = chunk_size
-        self.p_chunk = chunk_size
-        self.t_start = time.time()
-        self.t_done = self.t_start - 1
-
-    def update(self, n=None):
-        pass
-
-    def total_time(self):
-        return self.t_done - self.t_start
-
-    def time_elapsed(self):
-        return "%6.2fs" % (time.time() - self.t_start)
-
-    def time_remaining_est(self, p):
-        if p > 0.0:
-            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
-        else:
-            t_r_est = 0
-
-        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
-        time_string = "%02d:%02d:%02d:%02d" % \
-            (dd.day - 1, dd.hour, dd.minute, dd.second)
-
-        return time_string
-
-    def finished(self):
-        self.t_done = time.time()
-
-
-class TextProgressBar(BaseProgressBar):
-    """
-    A simple text-based progress bar.
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-        # super(TextProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        super(TextProgressBar, self).start(iterations, chunk_size)
-
-    def update(self, n=None):
-        self.n += 1
-        n = self.n
-        p = (n / self.N) * 100.0
-        if p >= self.p_chunk:
-            print("%4.1f%%." % p +
-                  " Run time: %s." % self.time_elapsed() +
-                  " Est. time left: %s" % self.time_remaining_est(p))
-            sys.stdout.flush()
-            self.p_chunk += self.p_chunk_size
-
-    def finished(self):
-        self.t_done = time.time()
-        print("Total run time: %s" % self.time_elapsed())
-
-
-class EnhancedTextProgressBar(BaseProgressBar):
-    """
-    An enhanced text-based progress bar.
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-        self.fill_char = '*'
-        self.width = 25
-
-    def update(self, n=None):
-        self.n += 1
-        n = self.n
-        percent_done = int(round(n / self.N * 100.0))
-        all_full = self.width - 2
-        num_hashes = int(round((percent_done / 100.0) * all_full))
-        prog_bar = ('[' + self.fill_char * num_hashes +
-                    ' ' * (all_full - num_hashes) + ']')
-        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
-        pct_string = '%d%%' % percent_done
-        prog_bar = (prog_bar[0:pct_place] +
-                    (pct_string + prog_bar[pct_place + len(pct_string):]))
-        prog_bar += ' Elapsed %s / Remaining %s' % (
-            self.time_elapsed().strip(),
-            self.time_remaining_est(percent_done))
-        print('\r', prog_bar, end='')
-        sys.stdout.flush()
-
-    def finished(self):
-        self.t_done = time.time()
-        print("\r", "Total run time: %s" % self.time_elapsed())
-
-
-class TqdmProgressBar(BaseProgressBar):
-    """
-    A progress bar using tqdm module
-    """
-
-    def __init__(self, iterations=0, chunk_size=10):
-        from tqdm.auto import tqdm
-        self.tqdm = tqdm
-
-    def start(self, iterations, **kwargs):
-        self.pbar = self.tqdm(total=iterations, **kwargs)
-        self.t_start = time.time()
-        self.t_done = self.t_start - 1
-
-    def update(self, n=None):
-        self.pbar.update()
-
-    def finished(self):
-        self.pbar.close()
-        self.t_done = time.time()
-
-
-class HTMLProgressBar(BaseProgressBar):
-    """
-    A simple HTML progress bar for using in IPython notebooks. Based on
-    IPython ProgressBar demo notebook:
-    https://github.com/ipython/ipython/tree/master/examples/notebooks
-
-    Example usage:
-
-        n_vec = linspace(0, 10, 100)
-        pbar = HTMLProgressBar(len(n_vec))
-        for n in n_vec:
-            pbar.update(n)
-            compute_with_n(n)
-    """
-
-    def __init__(self, iterations=0, chunk_size=1.0):
-        self.divid = str(uuid.uuid4())
-        self.textid = str(uuid.uuid4())
-        self.pb = HTML("""\
-<div style="border: 2px solid grey; width: 600px">
-  <div id="%s" \
-style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
-</div>
-<p id="%s"></p>
-""" % (self.divid, self.textid))
-        display(self.pb)
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations=0, chunk_size=1.0):
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def update(self, n):
-        p = (n / self.N) * 100.0
-        if p >= self.p_chunk:
-            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
-                   "Est. remaining time: %s." % self.time_remaining_est(p))
-            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
-                       "$('p#%s').text('%s');" % (self.textid, lbl))
-            display(Javascript(js_code))
-            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
-            # p)))
-            self.p_chunk += self.p_chunk_size
-
-    def finished(self):
-        self.t_done = time.time()
-        lbl = "Elapsed time: %s" % self.time_elapsed()
-        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
-                   "$('p#%s').text('%s');" % (self.textid, lbl))
-        display(Javascript(js_code))
-
-
-progess_bars = {
-    "Enhanced": EnhancedTextProgressBar,
-    "enhanced": EnhancedTextProgressBar,
-    "Text": TextProgressBar,
-    "text": TextProgressBar,
-    True: TextProgressBar,
-    "Tqdm": TqdmProgressBar,
-    "tqdm": TqdmProgressBar,
-    "Html": HTMLProgressBar,
-    "html": HTMLProgressBar,
-    "": BaseProgressBar,
-    False: BaseProgressBar,
-    None: BaseProgressBar,
-}
+__all__ = ['BaseProgressBar', 'TextProgressBar',
+           'EnhancedTextProgressBar', 'TqdmProgressBar',
+           'HTMLProgressBar', 'progess_bars']
+
+import time
+import datetime
+import sys
+
+
+class BaseProgressBar(object):
+    """
+    An abstract progress bar with some shared functionality.
+
+    Example usage:
+
+        n_vec = linspace(0, 10, 100)
+        pbar = TextProgressBar(len(n_vec))
+        for n in n_vec:
+            pbar.update(n)
+            compute_with_n(n)
+        pbar.finished()
+
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        pass
+
+    def start(self, iterations, chunk_size=10, **kwargs):
+        self.N = float(iterations)
+        self.n = 0
+        self.p_chunk_size = chunk_size
+        self.p_chunk = chunk_size
+        self.t_start = time.time()
+        self.t_done = self.t_start - 1
+
+    def update(self, n=None):
+        pass
+
+    def total_time(self):
+        return self.t_done - self.t_start
+
+    def time_elapsed(self):
+        return "%6.2fs" % (time.time() - self.t_start)
+
+    def time_remaining_est(self, p):
+        if p > 0.0:
+            t_r_est = (time.time() - self.t_start) * (100.0 - p) / p
+        else:
+            t_r_est = 0
+
+        dd = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
+        time_string = "%02d:%02d:%02d:%02d" % \
+            (dd.day - 1, dd.hour, dd.minute, dd.second)
+
+        return time_string
+
+    def finished(self):
+        self.t_done = time.time()
+
+
+class TextProgressBar(BaseProgressBar):
+    """
+    A simple text-based progress bar.
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        pass
+        # super(TextProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations, chunk_size=10, **kwargs):
+        super(TextProgressBar, self).start(iterations, chunk_size)
+
+    def update(self, n=None):
+        self.n += 1
+        n = self.n
+        p = (n / self.N) * 100.0
+        if p >= self.p_chunk:
+            print("%4.1f%%." % p +
+                  " Run time: %s." % self.time_elapsed() +
+                  " Est. time left: %s" % self.time_remaining_est(p))
+            sys.stdout.flush()
+            self.p_chunk += self.p_chunk_size
+
+    def finished(self):
+        self.t_done = time.time()
+        print("Total run time: %s" % self.time_elapsed())
+
+
+class EnhancedTextProgressBar(BaseProgressBar):
+    """
+    An enhanced text-based progress bar.
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        pass
+        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations, chunk_size=10, **kwargs):
+        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+        self.fill_char = '*'
+        self.width = 25
+
+    def update(self, n=None):
+        self.n += 1
+        n = self.n
+        percent_done = int(round(n / self.N * 100.0))
+        all_full = self.width - 2
+        num_hashes = int(round((percent_done / 100.0) * all_full))
+        prog_bar = ('[' + self.fill_char * num_hashes +
+                    ' ' * (all_full - num_hashes) + ']')
+        pct_place = (len(prog_bar) // 2) - len(str(percent_done))
+        pct_string = '%d%%' % percent_done
+        prog_bar = (prog_bar[0:pct_place] +
+                    (pct_string + prog_bar[pct_place + len(pct_string):]))
+        prog_bar += ' Elapsed %s / Remaining %s' % (
+            self.time_elapsed().strip(),
+            self.time_remaining_est(percent_done))
+        print('\r', prog_bar, end='')
+        sys.stdout.flush()
+
+    def finished(self):
+        self.t_done = time.time()
+        print("\r", "Total run time: %s" % self.time_elapsed())
+
+
+class TqdmProgressBar(BaseProgressBar):
+    """
+    A progress bar using tqdm module
+    """
+
+    def __init__(self, iterations=0, chunk_size=10):
+        from tqdm.auto import tqdm
+        self.tqdm = tqdm
+
+    def start(self, iterations, **kwargs):
+        self.pbar = self.tqdm(total=iterations, **kwargs)
+        self.t_start = time.time()
+        self.t_done = self.t_start - 1
+
+    def update(self, n=None):
+        self.pbar.update()
+
+    def finished(self):
+        self.pbar.close()
+        self.t_done = time.time()
+
+
+class HTMLProgressBar(BaseProgressBar):
+    """
+    A simple HTML progress bar for using in IPython notebooks. Based on
+    IPython ProgressBar demo notebook:
+    https://github.com/ipython/ipython/tree/master/examples/notebooks
+
+    Example usage:
+
+        n_vec = linspace(0, 10, 100)
+        pbar = HTMLProgressBar(len(n_vec))
+        for n in n_vec:
+            pbar.update(n)
+            compute_with_n(n)
+    """
+
+    def __init__(self, iterations=0, chunk_size=1.0):
+        self.divid = str(uuid.uuid4())
+        self.textid = str(uuid.uuid4())
+        self.pb = HTML("""\
+<div style="border: 2px solid grey; width: 600px">
+  <div id="%s" \
+style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
+</div>
+<p id="%s"></p>
+""" % (self.divid, self.textid))
+        display(self.pb)
+        super(HTMLProgressBar, self).start(iterations, chunk_size)
+
+    def start(self, iterations=0, chunk_size=1.0):
+        super(HTMLProgressBar, self).start(iterations, chunk_size)
+
+    def update(self, n):
+        p = (n / self.N) * 100.0
+        if p >= self.p_chunk:
+            lbl = ("Elapsed time: %s. " % self.time_elapsed() +
+                   "Est. remaining time: %s." % self.time_remaining_est(p))
+            js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
+                       "$('p#%s').text('%s');" % (self.textid, lbl))
+            display(Javascript(js_code))
+            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
+            # p)))
+            self.p_chunk += self.p_chunk_size
+
+    def finished(self):
+        self.t_done = time.time()
+        lbl = "Elapsed time: %s" % self.time_elapsed()
+        js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
+                   "$('p#%s').text('%s');" % (self.textid, lbl))
+        display(Javascript(js_code))
+
+
+progess_bars = {
+    "Enhanced": EnhancedTextProgressBar,
+    "enhanced": EnhancedTextProgressBar,
+    "Text": TextProgressBar,
+    "text": TextProgressBar,
+    True: TextProgressBar,
+    "Tqdm": TqdmProgressBar,
+    "tqdm": TqdmProgressBar,
+    "Html": HTMLProgressBar,
+    "html": HTMLProgressBar,
+    "": BaseProgressBar,
+    False: BaseProgressBar,
+    None: BaseProgressBar,
+}
diff --git a/qutip/utilities.py b/qutip/utilities.py
index 5413730a4e..8d6383071a 100644
--- a/qutip/utilities.py
+++ b/qutip/utilities.py
@@ -1,332 +1,332 @@
-"""
-This module contains utility functions that are commonly needed in other
-qutip modules.
-"""
-
-__all__ = ['n_thermal', 'clebsch', 'convert_unit']
-
-import numpy as np
-
-def n_thermal(w, w_th):
-    """
-    Return the number of photons in thermal equilibrium for an harmonic
-    oscillator mode with frequency 'w', at the temperature described by
-    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
-
-    Parameters
-    ----------
-
-    w : *float* or *array*
-        Frequency of the oscillator.
-
-    w_th : *float*
-        The temperature in units of frequency (or the same units as `w`).
-
-
-    Returns
-    -------
-
-    n_avg : *float* or *array*
-
-        Return the number of average photons in thermal equilibrium for a
-        an oscillator with the given frequency and temperature.
-
-
-    """
-
-    if isinstance(w, np.ndarray):
-        return 1.0 / (np.exp(w / w_th) - 1.0)
-
-    else:
-        if (w_th > 0) and np.exp(w / w_th) != 1.0:
-            return 1.0 / (np.exp(w / w_th) - 1.0)
-        else:
-            return 0.0
-
-
-def _factorial_prod(N, arr):
-    arr[:int(N)] += 1
-
-
-def _factorial_div(N, arr):
-    arr[:int(N)] -= 1
-
-
-def _to_long(arr):
-    prod = 1
-    for i, v in enumerate(arr):
-        prod *= (i+1)**int(v)
-    return prod
-
-
-def clebsch(j1, j2, j3, m1, m2, m3):
-    """Calculates the Clebsch-Gordon coefficient
-    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
-
-    Parameters
-    ----------
-    j1 : float
-        Total angular momentum 1.
-
-    j2 : float
-        Total angular momentum 2.
-
-    j3 : float
-        Total angular momentum 3.
-
-    m1 : float
-        z-component of angular momentum 1.
-
-    m2 : float
-        z-component of angular momentum 2.
-
-    m3 : float
-        z-component of angular momentum 3.
-
-    Returns
-    -------
-    cg_coeff : float
-        Requested Clebsch-Gordan coefficient.
-
-    """
-    if m3 != m1 + m2:
-        return 0
-    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
-    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
-
-    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
-    _factorial_prod(j3 + j1 - j2, c_factor)
-    _factorial_prod(j3 - j1 + j2, c_factor)
-    _factorial_prod(j1 + j2 - j3, c_factor)
-    _factorial_prod(j3 + m3, c_factor)
-    _factorial_prod(j3 - m3, c_factor)
-    _factorial_div(j1 + j2 + j3 + 1, c_factor)
-    _factorial_div(j1 - m1, c_factor)
-    _factorial_div(j1 + m1, c_factor)
-    _factorial_div(j2 - m2, c_factor)
-    _factorial_div(j2 + m2, c_factor)
-    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
-
-    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
-    sign = (-1) ** (vmin + j2 + m2)
-    for i,v in enumerate(range(vmin, vmax + 1)):
-        factor = s_factors[i,:]
-        _factorial_prod(j2 + j3 + m1 - v, factor)
-        _factorial_prod(j1 - m1 + v, factor)
-        _factorial_div(j3 - j1 + j2 - v, factor)
-        _factorial_div(j3 + m3 - v, factor)
-        _factorial_div(v + j1 - j2 - m3, factor)
-        _factorial_div(v, factor)
-    common_denominator = -np.min(s_factors, axis=0)
-    numerators = s_factors + common_denominator
-    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
-        sign / _to_long(common_denominator)
-    return C * S
-
-
-# -----------------------------------------------------------------------------
-# Functions for unit conversions
-#
-_e = 1.602176565e-19  # C
-_kB = 1.3806488e-23   # J/K
-_h = 6.62606957e-34   # Js
-
-_unit_factor_tbl = {
-    #   "unit": "factor that convert argument from unit 'unit' to Joule"
-    "J": 1.0,
-    "eV": _e,
-    "meV": 1.0e-3 * _e,
-    "GHz": 1.0e9 * _h,
-    "mK": 1.0e-3 * _kB,
-}
-
-
-def convert_unit(value, orig="meV", to="GHz"):
-    """
-    Convert an energy from unit `orig` to unit `to`.
-
-    Parameters
-    ----------
-    value : float / array
-        The energy in the old unit.
-
-    orig : string
-        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
-
-    to : string
-        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
-
-    Returns
-    -------
-    value_new_unit : float / array
-        The energy in the new unit.
-    """
-    if orig not in _unit_factor_tbl:
-        raise TypeError("Unsupported unit %s" % orig)
-
-    if to not in _unit_factor_tbl:
-        raise TypeError("Unsupported unit %s" % to)
-
-    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
-
-
-def convert_GHz_to_meV(w):
-    """
-    Convert an energy from unit GHz to unit meV.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
-    w_meV = w * 4.1357e-3
-    return w_meV
-
-
-def convert_meV_to_GHz(w):
-    """
-    Convert an energy from unit meV to unit GHz.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 meV = 1.0/4.1357e-3 GHz
-    w_GHz = w / 4.1357e-3
-    return w_GHz
-
-
-def convert_J_to_meV(w):
-    """
-    Convert an energy from unit J to unit meV.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 eV = 1.602e-19 J
-    w_meV = 1000.0 * w / _e
-    return w_meV
-
-
-def convert_meV_to_J(w):
-    """
-    Convert an energy from unit meV to unit J.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 eV = 1.602e-19 J
-    w_J = 0.001 * w * _e
-    return w_J
-
-
-def convert_meV_to_mK(w):
-    """
-    Convert an energy from unit meV to unit mK.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 mK = 0.0000861740 meV
-    w_mK = w / 0.0000861740
-    return w_mK
-
-
-def convert_mK_to_meV(w):
-    """
-    Convert an energy from unit mK to unit meV.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # 1 mK = 0.0000861740 meV
-    w_meV = w * 0.0000861740
-    return w_meV
-
-
-def convert_GHz_to_mK(w):
-    """
-    Convert an energy from unit GHz to unit mK.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-    """
-    # h v [Hz] = kB T [K]
-    # h 1e9 v [GHz] = kB 1e-3 T [mK]
-    # T [mK] = 1e12 * (h/kB) * v [GHz]
-    w_mK = w * 1.0e12 * (_h / _kB)
-    return w_mK
-
-
-def convert_mK_to_GHz(w):
-    """
-    Convert an energy from unit mK to unit GHz.
-
-    Parameters
-    ----------
-    w : float / array
-        The energy in the old unit.
-
-    Returns
-    -------
-    w_new_unit : float / array
-        The energy in the new unit.
-
-    """
-    w_GHz = w * 1.0e-12 * (_kB / _h)
-    return w_GHz
-
-
-def _version2int(version_string):
-    str_list = version_string.split(
-        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
-        "post")[0].split('.')
-    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
-                for n, d in enumerate(str_list[:3])])
+"""
+This module contains utility functions that are commonly needed in other
+qutip modules.
+"""
+
+__all__ = ['n_thermal', 'clebsch', 'convert_unit']
+
+import numpy as np
+
+def n_thermal(w, w_th):
+    """
+    Return the number of photons in thermal equilibrium for an harmonic
+    oscillator mode with frequency 'w', at the temperature described by
+    'w_th' where :math:`\\omega_{\\rm th} = k_BT/\\hbar`.
+
+    Parameters
+    ----------
+
+    w : *float* or *array*
+        Frequency of the oscillator.
+
+    w_th : *float*
+        The temperature in units of frequency (or the same units as `w`).
+
+
+    Returns
+    -------
+
+    n_avg : *float* or *array*
+
+        Return the number of average photons in thermal equilibrium for a
+        an oscillator with the given frequency and temperature.
+
+
+    """
+
+    if isinstance(w, np.ndarray):
+        return 1.0 / (np.exp(w / w_th) - 1.0)
+
+    else:
+        if (w_th > 0) and np.exp(w / w_th) != 1.0:
+            return 1.0 / (np.exp(w / w_th) - 1.0)
+        else:
+            return 0.0
+
+
+def _factorial_prod(N, arr):
+    arr[:int(N)] += 1
+
+
+def _factorial_div(N, arr):
+    arr[:int(N)] -= 1
+
+
+def _to_long(arr):
+    prod = 1
+    for i, v in enumerate(arr):
+        prod *= (i+1)**int(v)
+    return prod
+
+
+def clebsch(j1, j2, j3, m1, m2, m3):
+    """Calculates the Clebsch-Gordon coefficient
+    for coupling (j1,m1) and (j2,m2) to give (j3,m3).
+
+    Parameters
+    ----------
+    j1 : float
+        Total angular momentum 1.
+
+    j2 : float
+        Total angular momentum 2.
+
+    j3 : float
+        Total angular momentum 3.
+
+    m1 : float
+        z-component of angular momentum 1.
+
+    m2 : float
+        z-component of angular momentum 2.
+
+    m3 : float
+        z-component of angular momentum 3.
+
+    Returns
+    -------
+    cg_coeff : float
+        Requested Clebsch-Gordan coefficient.
+
+    """
+    if m3 != m1 + m2:
+        return 0
+    vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0]))
+    vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3]))
+
+    c_factor = np.zeros((int(j1 + j2 + j3 + 1)), np.int32)
+    _factorial_prod(j3 + j1 - j2, c_factor)
+    _factorial_prod(j3 - j1 + j2, c_factor)
+    _factorial_prod(j1 + j2 - j3, c_factor)
+    _factorial_prod(j3 + m3, c_factor)
+    _factorial_prod(j3 - m3, c_factor)
+    _factorial_div(j1 + j2 + j3 + 1, c_factor)
+    _factorial_div(j1 - m1, c_factor)
+    _factorial_div(j1 + m1, c_factor)
+    _factorial_div(j2 - m2, c_factor)
+    _factorial_div(j2 + m2, c_factor)
+    C = np.sqrt((2.0 * j3 + 1.0)*_to_long(c_factor))
+
+    s_factors = np.zeros(((vmax + 1 - vmin), (int(j1 + j2 + j3))), np.int32)
+    sign = (-1) ** (vmin + j2 + m2)
+    for i,v in enumerate(range(vmin, vmax + 1)):
+        factor = s_factors[i,:]
+        _factorial_prod(j2 + j3 + m1 - v, factor)
+        _factorial_prod(j1 - m1 + v, factor)
+        _factorial_div(j3 - j1 + j2 - v, factor)
+        _factorial_div(j3 + m3 - v, factor)
+        _factorial_div(v + j1 - j2 - m3, factor)
+        _factorial_div(v, factor)
+    common_denominator = -np.min(s_factors, axis=0)
+    numerators = s_factors + common_denominator
+    S = sum([(-1)**i * _to_long(vec) for i,vec in enumerate(numerators)]) * \
+        sign / _to_long(common_denominator)
+    return C * S
+
+
+# -----------------------------------------------------------------------------
+# Functions for unit conversions
+#
+_e = 1.602176565e-19  # C
+_kB = 1.3806488e-23   # J/K
+_h = 6.62606957e-34   # Js
+
+_unit_factor_tbl = {
+    #   "unit": "factor that convert argument from unit 'unit' to Joule"
+    "J": 1.0,
+    "eV": _e,
+    "meV": 1.0e-3 * _e,
+    "GHz": 1.0e9 * _h,
+    "mK": 1.0e-3 * _kB,
+}
+
+
+def convert_unit(value, orig="meV", to="GHz"):
+    """
+    Convert an energy from unit `orig` to unit `to`.
+
+    Parameters
+    ----------
+    value : float / array
+        The energy in the old unit.
+
+    orig : string
+        The name of the original unit ("J", "eV", "meV", "GHz", "mK")
+
+    to : string
+        The name of the new unit ("J", "eV", "meV", "GHz", "mK")
+
+    Returns
+    -------
+    value_new_unit : float / array
+        The energy in the new unit.
+    """
+    if orig not in _unit_factor_tbl:
+        raise TypeError("Unsupported unit %s" % orig)
+
+    if to not in _unit_factor_tbl:
+        raise TypeError("Unsupported unit %s" % to)
+
+    return value * (_unit_factor_tbl[orig] / _unit_factor_tbl[to])
+
+
+def convert_GHz_to_meV(w):
+    """
+    Convert an energy from unit GHz to unit meV.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 GHz = 4.1357e-6 eV = 4.1357e-3 meV
+    w_meV = w * 4.1357e-3
+    return w_meV
+
+
+def convert_meV_to_GHz(w):
+    """
+    Convert an energy from unit meV to unit GHz.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 meV = 1.0/4.1357e-3 GHz
+    w_GHz = w / 4.1357e-3
+    return w_GHz
+
+
+def convert_J_to_meV(w):
+    """
+    Convert an energy from unit J to unit meV.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 eV = 1.602e-19 J
+    w_meV = 1000.0 * w / _e
+    return w_meV
+
+
+def convert_meV_to_J(w):
+    """
+    Convert an energy from unit meV to unit J.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 eV = 1.602e-19 J
+    w_J = 0.001 * w * _e
+    return w_J
+
+
+def convert_meV_to_mK(w):
+    """
+    Convert an energy from unit meV to unit mK.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 mK = 0.0000861740 meV
+    w_mK = w / 0.0000861740
+    return w_mK
+
+
+def convert_mK_to_meV(w):
+    """
+    Convert an energy from unit mK to unit meV.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # 1 mK = 0.0000861740 meV
+    w_meV = w * 0.0000861740
+    return w_meV
+
+
+def convert_GHz_to_mK(w):
+    """
+    Convert an energy from unit GHz to unit mK.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+    """
+    # h v [Hz] = kB T [K]
+    # h 1e9 v [GHz] = kB 1e-3 T [mK]
+    # T [mK] = 1e12 * (h/kB) * v [GHz]
+    w_mK = w * 1.0e12 * (_h / _kB)
+    return w_mK
+
+
+def convert_mK_to_GHz(w):
+    """
+    Convert an energy from unit mK to unit GHz.
+
+    Parameters
+    ----------
+    w : float / array
+        The energy in the old unit.
+
+    Returns
+    -------
+    w_new_unit : float / array
+        The energy in the new unit.
+
+    """
+    w_GHz = w * 1.0e-12 * (_kB / _h)
+    return w_GHz
+
+
+def _version2int(version_string):
+    str_list = version_string.split(
+        "-dev")[0].split("rc")[0].split("a")[0].split("b")[0].split(
+        "post")[0].split('.')
+    return sum([int(d if len(d) > 0 else 0) * (100 ** (3 - n))
+                for n, d in enumerate(str_list[:3])])
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 3262da1882..27fe62c60a 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1,1819 +1,1819 @@
-"""
-Functions for visualizing results of quantum dynamics simulations,
-visualizations of quantum states and processes.
-"""
-
-__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
-           'plot_energy_levels', 'fock_distribution',
-           'plot_fock_distribution', 'wigner_fock_distribution',
-           'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution_2d',
-           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
-           'complex_array_to_rgb', 'matrix_histogram',
-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
-
-import warnings
-import itertools as it
-import numpy as np
-from numpy import pi, array, sin, cos, angle, log2
-
-from packaging.version import parse as parse_version
-
-from . import (
-    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
-)
-from .core.dimensions import flatten
-from .core.superop_reps import _to_superpauli, isqubitdims
-from .wigner import wigner
-from .matplotlib_utilities import complex_phase_cmap
-
-try:
-    import matplotlib.pyplot as plt
-    import matplotlib as mpl
-    from matplotlib import cm
-    from mpl_toolkits.mplot3d import Axes3D
-
-    # Define a custom _axes3D function based on the matplotlib version.
-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-    if parse_version(mpl.__version__) >= parse_version('3.4'):
-        def _axes3D(fig, *args, **kwargs):
-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-            return fig.add_axes(ax)
-    else:
-        def _axes3D(*args, **kwargs):
-            return Axes3D(*args, **kwargs)
-except:
-    pass
-
-
-def plot_wigner_sphere(fig, ax, wigner, reflections):
-    """Plots a coloured Bloch sphere.
-
-    Parameters
-    ----------
-    fig : :obj:`matplotlib.figure.Figure`
-        An instance of :obj:`~matplotlib.figure.Figure`.
-    ax : :obj:`matplotlib.axes.Axes`
-        An axes instance in the given figure.
-    wigner : list of float
-        The wigner transformation at `steps` different theta and phi.
-    reflections : bool
-        If the reflections of the sphere should be plotted as well.
-
-    Notes
-    -----
-    Special thanks to Russell P Rundle for writing this function.
-    """
-    ax.set_xlabel("x")
-    ax.set_ylabel("y")
-    ax.set_zlabel("z")
-
-    steps = len(wigner)
-
-    theta = np.linspace(0, np.pi, steps)
-    phi = np.linspace(0, 2 * np.pi, steps)
-    x = np.outer(np.sin(theta), np.cos(phi))
-    y = np.outer(np.sin(theta), np.sin(phi))
-    z = np.outer(np.cos(theta), np.ones(steps))
-    wigner = np.real(wigner)
-    wigner_max = np.real(np.amax(np.abs(wigner)))
-
-    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
-
-    # Plot coloured Bloch sphere:
-    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
-                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
-                    zorder=0.5, antialiased=None)
-
-    if reflections:
-        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # bottom
-        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # side
-        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # back
-
-        # Plot bottom reflection:
-        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
-                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-        # Plot side reflection:
-        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
-                        z[0:steps, 0:steps], facecolors=wigner_c3,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-        # Plot back reflection:
-        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
-                        z[0:steps, 0:steps], facecolors=wigner_c4,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-    # Create colourbar:
-    m = cm.ScalarMappable(cmap=cm.seismic_r)
-    m.set_array([-wigner_max, wigner_max])
-    plt.colorbar(m, shrink=0.5, aspect=10)
-
-    plt.show()
-
-
-# Adopted from the SciPy Cookbook.
-def _blob(x, y, w, w_max, area, color_fn, ax=None):
-    """
-    Draws a square-shaped blob with the given area (< 1) at
-    the given coordinates.
-    """
-    hs = np.sqrt(area) / 2
-    xcorners = array([x - hs, x + hs, x + hs, x - hs])
-    ycorners = array([y - hs, y - hs, y + hs, y + hs])
-
-    if ax is not None:
-        handle = ax
-    else:
-        handle = plt
-
-    handle.fill(xcorners, ycorners,
-             color=color_fn(w))
-
-
-def _cb_labels(left_dims):
-    """Creates plot labels for matrix elements in the computational basis.
-
-    Parameters
-    ----------
-    left_dims : flat list of ints
-        Dimensions of the left index of a density operator. E. g.
-        [2, 3] for a qubit tensored with a qutrit.
-
-    Returns
-    -------
-    left_labels, right_labels : lists of strings
-        Labels for the left and right indices of a density operator
-        (kets and bras, respectively).
-    """
-    # FIXME: assumes dims, such that we only need left_dims == dims[0].
-    basis_labels = list(map(",".join, it.product(*[
-        map(str, range(dim))
-        for dim in left_dims
-    ])))
-    return [
-        map(fmt.format, basis_labels) for fmt in
-        (
-            r"$\langle{}|$",
-            r"$|{}\rangle$",
-        )
-    ]
-
-
-# Adopted from the SciPy Cookbook.
-def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
-           label_top=True, color_style="scaled"):
-    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
-
-    Parameters
-    ----------
-    rho : qobj
-        Input density matrix or superoperator.
-
-    xlabels : list of strings or False
-        list of x labels
-
-    ylabels : list of strings or False
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    cmap : a matplotlib colormap instance
-        Color map to use when plotting.
-
-    label_top : bool
-        If True, x-axis labels will be placed on top, otherwise
-        they will appear below the plot.
-
-    color_style : string
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"scaled"`` (default), each color is chosen by
-           passing the absolute value of the corresponding matrix
-           element into `cmap` with the sign of the real part.
-        -  If set to ``"threshold"``, each square is plotted as
-           the maximum of `cmap` for the positive real part and as
-           the minimum for the negative part of the matrix element;
-           note that this generalizes `"threshold"` to complex numbers.
-        -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not a quantum object.
-
-    Examples
-    --------
-    >>> import qutip
-    >>>
-    >>> dm = qutip.rand_dm(4)
-    >>> fig, ax = qutip.hinton(dm)
-    >>> fig.show()
-    >>>
-    >>> qutip.settings.colorblind_safe = True
-    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
-    >>> fig.show()
-    >>> qutip.settings.colorblind_safe = False
-    >>>
-    >>> fig, ax = qutip.hinton(dm, color_style="phase")
-    >>> fig.show()
-    """
-
-    # Apply default colormaps.
-    # TODO: abstract this away into something that makes default
-    #       colormaps.
-    cmap = (
-        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
-        if cmap is None else cmap
-    )
-
-    # Extract plotting data W from the input.
-    if isinstance(rho, Qobj):
-        if rho.isoper:
-            W = rho.full()
-
-            # Create default labels if none are given.
-            if xlabels is None or ylabels is None:
-                labels = _cb_labels(rho.dims[0])
-                xlabels = xlabels if xlabels is not None else list(labels[0])
-                ylabels = ylabels if ylabels is not None else list(labels[1])
-
-        elif rho.isoperket:
-            W = vector_to_operator(rho).full()
-        elif rho.isoperbra:
-            W = vector_to_operator(rho.dag()).full()
-        elif rho.issuper:
-            if not isqubitdims(rho.dims):
-                raise ValueError("Hinton plots of superoperators are "
-                                 "currently only supported for qubits.")
-            # Convert to a superoperator in the Pauli basis,
-            # so that all the elements are real.
-            sqobj = _to_superpauli(rho)
-            nq = int(log2(sqobj.shape[0]) / 2)
-            W = sqobj.full().T
-            # Create default labels, too.
-            if (xlabels is None) or (ylabels is None):
-                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                xlabels = xlabels if xlabels is not None else labels
-                ylabels = ylabels if ylabels is not None else labels
-
-        else:
-            raise ValueError(
-                "Input quantum object must be an operator or superoperator."
-            )
-
-    else:
-        W = rho
-
-    if ax is None:
-        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
-    else:
-        fig = None
-
-    if not (xlabels or ylabels):
-        ax.axis('off')
-    if title:
-        ax.set_title(title)
-
-    ax.axis('equal')
-    ax.set_frame_on(False)
-
-    height, width = W.shape
-
-    w_max = 1.25 * max(abs(np.array(W)).flatten())
-    if w_max <= 0.0:
-        w_max = 1.0
-
-    # Set color_fn here.
-    if color_style == "scaled":
-        def color_fn(w):
-            w = np.abs(w) * np.sign(np.real(w))
-            return cmap(int((w + w_max) * 256 / (2 * w_max)))
-    elif color_style == "threshold":
-        def color_fn(w):
-            w = np.real(w)
-            return cmap(255 if w > 0 else 0)
-    elif color_style == "phase":
-        def color_fn(w):
-            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
-    else:
-        raise ValueError(
-            "Unknown color style {} for Hinton diagrams.".format(color_style)
-        )
-
-    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
-            color=cmap(128))
-    for x in range(width):
-        for y in range(height):
-            _x = x + 1
-            _y = y + 1
-            _blob(
-                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
-                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
-
-    # color axis
-    vmax = np.pi if color_style == "phase" else abs(W).max()
-    norm = mpl.colors.Normalize(-vmax, vmax)
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-
-    xtics = 0.5 + np.arange(width)
-    # x axis
-    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-        if label_top:
-            ax.xaxis.tick_top()
-    ax.tick_params(axis='x', labelsize=14)
-
-    # y axis
-    ytics = 0.5 + np.arange(height)
-    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(list(reversed(ylabels)))
-    ax.tick_params(axis='y', labelsize=14)
-
-    return fig, ax
-
-
-def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    theta : float
-        Angle with respect to z-axis
-
-    phi : float
-        Angle in x-y plane
-
-    values : array
-        Data set to be plotted
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    save : bool {False , True}
-        Whether to save the figure or not
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-    if fig is None or ax is None:
-        fig = plt.figure()
-        ax = _axes3D(fig)
-
-    thetam, phim = np.meshgrid(theta, phi)
-    xx = sin(thetam) * cos(phim)
-    yy = sin(thetam) * sin(phim)
-    zz = cos(thetam)
-    r = array(abs(values))
-    ph = angle(values)
-    # normalize color range based on phase angles in list ph
-    nrm = mpl.colors.Normalize(ph.min(), ph.max())
-
-    # plot with facecolors set to cm.jet colormap normalized to nrm
-    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
-                    facecolors=cm.jet(nrm(ph)), linewidth=0)
-    # create new axes on plot for colorbar and shrink it a bit.
-    # pad shifts location of bar with repsect to the main plot
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-
-    # create new colorbar in axes cax with cm jet and normalized to nrm like
-    # our facecolors
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
-    # add our colorbar label
-    cb1.set_label('Angle')
-
-    if save:
-        plt.savefig("sphereplot.png")
-
-    return fig, ax
-
-
-def _remove_margins(axis):
-    """
-    removes margins about z = 0 and improves the style
-    by monkey patching
-    """
-    def _get_coord_info_new(renderer):
-        mins, maxs, centers, deltas, tc, highs = \
-            _get_coord_info_old(renderer)
-        mins += deltas / 4
-        maxs -= deltas / 4
-        return mins, maxs, centers, deltas, tc, highs
-
-    _get_coord_info_old = axis._get_coord_info
-    axis._get_coord_info = _get_coord_info_new
-
-
-def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
-    """
-    truncates portion of a colormap and returns the new one
-    """
-    if isinstance(cmap, str):
-        cmap = plt.get_cmap(cmap)
-    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
-        'trunc({n},{a:.2f},{b:.2f})'.format(
-            n=cmap.name, a=minval, b=maxval),
-        cmap(np.linspace(minval, maxval, n)))
-    return new_cmap
-
-
-def _stick_to_planes(stick, azim, ax, M, spacing):
-    """adjusts xlim and ylim in way that bars will
-    Stick to xz and yz planes
-    """
-    if stick is True:
-        azim = azim % 360
-        if 0 <= azim <= 90:
-            ax.set_ylim(1 - .5,)
-            ax.set_xlim(1 - .5,)
-        elif 90 < azim <= 180:
-            ax.set_ylim(1 - .5,)
-            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
-        elif 180 < azim <= 270:
-            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
-            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
-        elif 270 < azim < 360:
-            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
-            ax.set_xlim(1 - .5,)
-
-
-def _update_yaxis(spacing, M, ax, ylabels):
-    """
-    updates the y-axis
-    """
-    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(ylabels)
-    else:
-        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
-        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
-    ax.tick_params(axis='y', labelsize=14)
-    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
-
-
-def _update_xaxis(spacing, M, ax, xlabels):
-    """
-    updates the x-axis
-    """
-    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-    else:
-        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
-        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
-    ax.tick_params(axis='x', labelsize=14)
-    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
-
-
-def _update_zaxis(ax, z_min, z_max, zticks):
-    """
-    updates the z-axis
-    """
-    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
-    if isinstance(zticks, list):
-        ax.set_zticks(zticks)
-    ax.set_zlim3d([min(z_min, 0), z_max])
-
-
-def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
-                     colorbar=True, fig=None, ax=None, options=None):
-    """
-    Draw a histogram for the matrix M, with the given x and y labels and title.
-
-    Parameters
-    ----------
-    M : Matrix of Qobj
-        The matrix to visualize
-
-    xlabels : list of strings
-        list of x labels
-
-    ylabels : list of strings
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    colorbar : bool (default: True)
-        show colorbar
-
-    options : dict
-        A dictionary containing extra options for the plot.
-        The names (keys) and values of the options are
-        described below:
-
-        'zticks' : list of numbers
-            A list of z-axis tick locations.
-
-        'cmap' : string (default: 'jet')
-            The name of the color map to use.
-
-        'cmap_min' : float (default: 0.0)
-            The lower bound to truncate the color map at.
-            A value in range 0 - 1. The default, 0, leaves the lower
-            bound of the map unchanged.
-
-        'cmap_max' : float (default: 1.0)
-            The upper bound to truncate the color map at.
-            A value in range 0 - 1. The default, 1, leaves the upper
-            bound of the map unchanged.
-
-        'bars_spacing' : float (default: 0.1)
-            spacing between bars.
-
-        'bars_alpha' : float (default: 1.)
-            transparency of bars, should be in range 0 - 1
-
-        'bars_lw' : float (default: 0.5)
-            linewidth of bars' edges.
-
-        'bars_edgecolor' : color (default: 'k')
-            The colors of the bars' edges.
-            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
-
-        'shade' : bool (default: True)
-            Whether to shade the dark sides of the bars (True) or not (False).
-            The shading is relative to plot's source of light.
-
-        'azim' : float
-            The azimuthal viewing angle.
-
-        'elev' : float
-            The elevation viewing angle.
-
-        'proj_type' : string (default: 'ortho' if ax is not passed)
-            The type of projection ('ortho' or 'persp')
-
-        'stick' : bool (default: False)
-            Changes xlim and ylim in such a way that bars next to
-            XZ and YZ planes will stick to those planes.
-            This option has no effect if ``ax`` is passed as a parameter.
-
-        'cbar_pad' : float (default: 0.04)
-            The fraction of the original axes between the colorbar
-            and the new image axes.
-            (i.e. the padding between the 3D figure and the colorbar).
-
-        'cbar_to_z' : bool (default: False)
-            Whether to set the color of maximum and minimum z-values to the
-            maximum and minimum colors in the colorbar (True) or not (False).
-
-        'figsize' : tuple of two numbers
-            The size of the figure.
-
-    Returns :
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not valid.
-
-    """
-
-    # default options
-    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
-                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
-                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-                    'shade': False, 'azim': -35, 'elev': 35,
-                    'proj_type': 'ortho', 'stick': False,
-                    'cbar_pad': 0.04, 'cbar_to_z': False}
-
-    # update default_opts from input options
-    if options is None:
-        pass
-    elif isinstance(options, dict):
-        # check if keys in options dict are valid
-        if set(options) - set(default_opts):
-            raise ValueError("invalid key(s) found in options: "
-                             f"{', '.join(set(options) - set(default_opts))}")
-        else:
-            # updating default options
-            default_opts.update(options)
-    else:
-        raise ValueError("options must be a dictionary")
-
-    if isinstance(M, Qobj):
-        # extract matrix data from Qobj
-        M = M.full()
-
-    n = np.size(M)
-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-    xpos = xpos.T.flatten() + 0.5
-    ypos = ypos.T.flatten() + 0.5
-    zpos = np.zeros(n)
-    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
-    dz = np.real(M.flatten())
-
-    if isinstance(limits, list) and len(limits) == 2:
-        z_min = limits[0]
-        z_max = limits[1]
-    else:
-        z_min = min(dz)
-        z_max = max(dz)
-        if z_min == z_max:
-            z_min -= 0.1
-            z_max += 0.1
-
-    if default_opts['cbar_to_z']:
-        norm = mpl.colors.Normalize(min(dz), max(dz))
-    else:
-        norm = mpl.colors.Normalize(z_min, z_max)
-    cmap = _truncate_colormap(default_opts['cmap'],
-                              default_opts['cmap_min'],
-                              default_opts['cmap_max'])
-    colors = cmap(norm(dz))
-
-    if ax is None:
-        fig = plt.figure(figsize=default_opts['figsize'])
-        ax = _axes3D(fig,
-                     azim=default_opts['azim'] % 360,
-                     elev=default_opts['elev'] % 360)
-        ax.set_proj_type(default_opts['proj_type'])
-
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
-             edgecolors=default_opts['bars_edgecolor'],
-             linewidths=default_opts['bars_lw'],
-             alpha=default_opts['bars_alpha'],
-             shade=default_opts['shade'])
-    # remove vertical lines on xz and yz plane
-    ax.yaxis._axinfo["grid"]['linewidth'] = 0
-    ax.xaxis._axinfo["grid"]['linewidth'] = 0
-
-    if title:
-        ax.set_title(title)
-
-    # x axis
-    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
-
-    # y axis
-    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
-
-    # z axis
-    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
-
-    # stick to xz and yz plane
-    _stick_to_planes(default_opts['stick'],
-                     default_opts['azim'], ax, M,
-                     default_opts['bars_spacing'])
-
-    # color axis
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=default_opts['cbar_pad'])
-        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-
-    # removing margins
-    _remove_margins(ax.xaxis)
-    _remove_margins(ax.yaxis)
-    _remove_margins(ax.zaxis)
-
-    return fig, ax
-
-
-def matrix_histogram_complex(M, xlabels=None, ylabels=None,
-                             title=None, limits=None, phase_limits=None,
-                             colorbar=True, fig=None, ax=None,
-                             threshold=None):
-    """
-    Draw a histogram for the amplitudes of matrix M, using the argument
-    of each element for coloring the bars, with the given x and y labels
-    and title.
-
-    Parameters
-    ----------
-    M : Matrix of Qobj
-        The matrix to visualize
-
-    xlabels : list of strings
-        list of x labels
-
-    ylabels : list of strings
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
-
-    phase_limits : list/array with two float numbers
-        The phase-axis (colorbar) limits [min, max] (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    threshold: float (None)
-        Threshold for when bars of smaller height should be transparent. If
-        not set, all bars are colored according to the color map.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not valid.
-
-    """
-
-    if isinstance(M, Qobj):
-        # extract matrix data from Qobj
-        M = M.full()
-
-    n = np.size(M)
-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-    xpos = xpos.T.flatten() - 0.5
-    ypos = ypos.T.flatten() - 0.5
-    zpos = np.zeros(n)
-    dx = dy = 0.8 * np.ones(n)
-    Mvec = M.flatten()
-    dz = abs(Mvec)
-
-    # make small numbers real, to avoid random colors
-    idx, = np.where(abs(Mvec) < 0.001)
-    Mvec[idx] = abs(Mvec[idx])
-
-    if phase_limits:  # check that limits is a list type
-        phase_min = phase_limits[0]
-        phase_max = phase_limits[1]
-    else:
-        phase_min = -pi
-        phase_max = pi
-
-    norm = mpl.colors.Normalize(phase_min, phase_max)
-    cmap = complex_phase_cmap()
-
-    colors = cmap(norm(angle(Mvec)))
-    if threshold is not None:
-        colors[:, 3] = 1 * (dz > threshold)
-
-    if ax is None:
-        fig = plt.figure()
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
-
-    if title:
-        ax.set_title(title)
-
-    # x axis
-    xtics = -0.5 + np.arange(M.shape[0])
-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-    ax.tick_params(axis='x', labelsize=12)
-
-    # y axis
-    ytics = -0.5 + np.arange(M.shape[1])
-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(ylabels)
-    ax.tick_params(axis='y', labelsize=12)
-
-    # z axis
-    if limits and isinstance(limits, list):
-        ax.set_zlim3d(limits)
-    else:
-        ax.set_zlim3d([0, 1])  # use min/max
-    # ax.set_zlabel('abs')
-
-    # color axis
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
-        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-        cb.set_ticklabels(
-            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
-        cb.set_label('arg')
-
-    return fig, ax
-
-
-def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
-                       figsize=(8, 12), fig=None, ax=None):
-    """
-    Plot the energy level diagrams for a list of Hamiltonians. Include
-    up to N energy levels. For each element in H_list, the energy
-    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
-    where n is the index of an element in H_list.
-
-    Parameters
-    ----------
-
-        H_list : List of Qobj
-            A list of Hamiltonians.
-
-        labels : List of string
-            A list of labels for each Hamiltonian
-
-        show_ylabels : Bool (default False)
-            Show y labels to the left of energy levels of the initial
-            Hamiltonian.
-
-        N : int
-            The number of energy levels to plot
-
-        figsize : tuple (int,int)
-            The size of the figure (width, height).
-
-        fig : a matplotlib Figure instance
-            The Figure canvas in which the plot will be drawn.
-
-        ax : a matplotlib axes instance
-            The axes context in which the plot will be drawn.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-
-        ValueError
-            Input argument is not valid.
-
-    """
-
-    if not isinstance(H_list, list):
-        raise ValueError("H_list must be a list of Qobj instances")
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    H = H_list[0]
-    N = H.shape[0] if N == 0 else min(H.shape[0], N)
-
-    xticks = []
-    yticks = []
-
-    x = 0
-    evals0 = H.eigenenergies(eigvals=N)
-    for e_idx, e in enumerate(evals0[:N]):
-        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
-        yticks.append(e)
-    xticks.append(x + 1)
-    x += 2
-
-    for H1 in H_list[1:]:
-
-        H = H + H1
-        evals1 = H.eigenenergies()
-
-        for e_idx, e in enumerate(evals1[:N]):
-            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
-        x += 1
-
-        for e_idx, e in enumerate(evals1[:N]):
-            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
-        xticks.append(x + 1)
-        x += 2
-
-        evals0 = evals1
-
-    ax.set_frame_on(False)
-
-    if show_ylabels:
-        yticks = np.unique(np.around(yticks, 1))
-        ax.set_yticks(yticks)
-    else:
-        ax.axes.get_yaxis().set_visible(False)
-
-    if labels:
-        ax.get_xaxis().tick_bottom()
-        ax.set_xticks(xticks)
-        ax.set_xticklabels(labels, fontsize=16)
-    else:
-        ax.axes.get_xaxis().set_visible(False)
-
-    return fig, ax
-
-
-def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
-                         figsize=(8, 12), fig=None, ax=None):
-    warnings.warn("Deprecated: Use plot_energy_levels")
-    return plot_energy_levels(H_list, N=N, labels=labels,
-                              show_ylabels=show_ylabels,
-                              figsize=figsize, fig=fig, ax=ax)
-
-
-def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
-                           figsize=(8, 6), title=None, unit_y_range=True):
-    """
-    Plot the Fock distribution for a density matrix (or ket) that describes
-    an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    title : string
-        An optional title for the figure.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    N = rho.shape[0]
-
-    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
-           color="green", alpha=0.6, width=0.8)
-    if unit_y_range:
-        ax.set_ylim(0, 1)
-
-    ax.set_xlim(-.5 + offset, N + offset)
-    ax.set_xlabel('Fock number', fontsize=12)
-    ax.set_ylabel('Occupation probability', fontsize=12)
-
-    if title:
-        ax.set_title(title)
-
-    return fig, ax
-
-
-def fock_distribution(rho, offset=0, fig=None, ax=None,
-                      figsize=(8, 6), title=None, unit_y_range=True):
-    warnings.warn("Deprecated: Use plot_fock_distribution")
-    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
-                                  figsize=figsize, title=title,
-                                  unit_y_range=unit_y_range)
-
-
-def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
-                cmap=None, alpha_max=7.5, colorbar=False,
-                method='clenshaw', projection='2d'):
-    """
-    Plot the the Wigner function for a density matrix (or ket) that describes
-    an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    cmap : a matplotlib cmap instance
-        The colormap.
-
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
-    colorbar : bool
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig and not ax:
-        if projection == '2d':
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-        elif projection == '3d':
-            fig = plt.figure(figsize=figsize)
-            ax = fig.add_subplot(1, 1, 1, projection='3d')
-        else:
-            raise ValueError('Unexpected value of projection keyword argument')
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    xvec = np.linspace(-alpha_max, alpha_max, 200)
-    W0 = wigner(rho, xvec, xvec, method=method)
-
-    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
-
-    wlim = abs(W).max()
-
-    if cmap is None:
-        cmap = cm.get_cmap('RdBu')
-
-    if projection == '2d':
-        cf = ax.contourf(xvec, yvec, W, 100,
-                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-    elif projection == '3d':
-        X, Y = np.meshgrid(xvec, xvec)
-        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
-                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-    else:
-        raise ValueError('Unexpected value of projection keyword argument.')
-
-    if xvec is not yvec:
-        ax.set_ylim(xvec.min(), xvec.max())
-
-    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
-    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
-
-    if colorbar:
-        fig.colorbar(cf, ax=ax)
-
-    ax.set_title("Wigner function", fontsize=12)
-
-    return fig, ax
-
-
-def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-                                  cmap=None, alpha_max=7.5, colorbar=False,
-                                  method='iterative', projection='2d'):
-    """
-    Plot the Fock distribution and the Wigner function for a density matrix
-    (or ket) that describes an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    axes : a list of two matplotlib axes instances
-        The axes context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    cmap : a matplotlib cmap instance
-        The colormap.
-
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
-    colorbar : bool
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    method : string {'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig and not axes:
-        if projection == '2d':
-            fig, axes = plt.subplots(1, 2, figsize=figsize)
-        elif projection == '3d':
-            fig = plt.figure(figsize=figsize)
-            axes = [fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2, projection='3d')]
-        else:
-            raise ValueError('Unexpected value of projection keyword argument')
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    plot_fock_distribution(rho, fig=fig, ax=axes[0])
-    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
-                alpha_max=alpha_max, colorbar=colorbar, method=method,
-                projection=projection)
-
-    return fig, axes
-
-
-def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-                             cmap=None, alpha_max=7.5, colorbar=False,
-                             method='iterative'):
-    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
-    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
-                                         figsize=figsize, cmap=cmap,
-                                         alpha_max=alpha_max,
-                                         colorbar=colorbar,
-                                         method=method)
-
-
-def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
-                            fig=None, axes=None, figsize=(8, 4)):
-    """
-    Visualize the results (expectation values) for an evolution solver.
-    `results` is assumed to be an instance of Result, or a list of Result
-    instances.
-
-    Parameters
-    ----------
-    results : (list of) :class:`qutip.solver.Result`
-        List of results objects returned by any of the QuTiP evolution solvers.
-
-    ylabels : list of strings
-        The y-axis labels. List should be of the same length as `results`.
-
-    title : string
-        The title of the figure.
-
-    show_legend : bool
-        Whether or not to show the legend.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    axes : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-    if not isinstance(results, list):
-        results = [results]
-
-    n_e_ops = max([len(result.expect) for result in results])
-
-    if not fig or not axes:
-        if not figsize:
-            figsize = (12, 3 * n_e_ops)
-        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
-                                 figsize=figsize, squeeze=False)
-
-    for r_idx, result in enumerate(results):
-        for e_idx, e in enumerate(result.expect):
-            axes[e_idx, 0].plot(result.times, e,
-                                label="%s [%d]" % (result.solver, e_idx))
-
-    if title:
-        fig.suptitle(title)
-
-    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
-    for n in range(n_e_ops):
-        if show_legend:
-            axes[n, 0].legend()
-        if ylabels:
-            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
-
-    return fig, axes
-
-
-def plot_spin_distribution_2d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 8)):
-    """
-    Plot a spin distribution function (given as meshgrid data) with a 2D
-    projection where the surface of the unit sphere is mapped on the unit disk.
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig or not ax:
-        if not figsize:
-            figsize = (8, 8)
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    Y = (THETA - pi / 2) / (pi / 2)
-    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-    else:
-        cmap = cm.RdYlBu
-
-    ax.pcolor(X, Y, P.real, cmap=cmap)
-    ax.set_xlabel(r'$\varphi$', fontsize=18)
-    ax.set_ylabel(r'$\theta$', fontsize=18)
-
-    ax.set_xticks([-1, 0, 1])
-    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
-    ax.set_yticks([-1, 0, 1])
-    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-
-    return fig, ax
-
-
-def plot_spin_distribution_3d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 6)):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    if fig is None or ax is None:
-        fig = plt.figure(figsize=figsize)
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    xx = sin(THETA) * cos(PHI)
-    yy = sin(THETA) * sin(PHI)
-    zz = cos(THETA)
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-        norm = mpl.colors.Normalize(-P.max(), P.max())
-    else:
-        cmap = cm.RdYlBu
-        norm = mpl.colors.Normalize(P.min(), P.max())
-
-    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-                    facecolors=cmap(norm(P)), linewidth=0)
-
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-    cb1.set_label('magnitude')
-
-    return fig, ax
-
-
-#
-# Qubism and other qubistic visualizations
-#
-def complex_array_to_rgb(X, theme='light', rmax=None):
-    """
-    Makes an array of complex number and converts it to an array of [r, g, b],
-    where phase gives hue and saturation/value are given by the absolute value.
-    Especially for use with imshow for complex plots.
-
-    For more info on coloring, see:
-        Emilia Petrisor,
-        Visualizing complex-valued functions with Matplotlib and Mayavi
-        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
-
-    Parameters
-    ----------
-    X : array
-        Array (of any dimension) of complex numbers.
-
-    theme : 'light' (default) or 'dark'
-        Set coloring theme for mapping complex values into colors.
-
-    rmax : float
-        Maximal abs value for color normalization.
-        If None (default), uses np.abs(X).max().
-
-    Returns
-    -------
-    Y : array
-        Array of colors (of shape X.shape + (3,)).
-
-    """
-
-    absmax = rmax or np.abs(X).max()
-    if absmax == 0.:
-        absmax = 1.
-    Y = np.zeros(X.shape + (3,), dtype='float')
-    Y[..., 0] = np.angle(X) / (2 * pi) % 1
-    if theme == 'light':
-        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
-        Y[..., 2] = 1
-    elif theme == 'dark':
-        Y[..., 1] = 1
-        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
-    Y = mpl.colors.hsv_to_rgb(Y)
-    return Y
-
-
-def _index_to_sequence(i, dim_list):
-    """
-    For a matrix entry with index i it returns state it corresponds to.
-    In particular, for dim_list=[2]*n it returns i written as a binary number.
-
-    Parameters
-    ----------
-    i : int
-        Index in a matrix.
-
-    dim_list : list of int
-        List of dimensions of consecutive particles.
-
-    Returns
-    -------
-    seq : list
-        List of coordinates for each particle.
-
-    """
-    res = []
-    j = i
-    for d in reversed(dim_list):
-        j, s = divmod(j, d)
-        res.append(s)
-    return list(reversed(res))
-
-
-def _sequence_to_index(seq, dim_list):
-    """
-    Inverse of _index_to_sequence.
-
-    Parameters
-    ----------
-    seq : list of ints
-        List of coordinates for each particle.
-
-    dim_list : list of int
-        List of dimensions of consecutive particles.
-
-    Returns
-    -------
-    i : list
-        Index in a matrix.
-
-    """
-    i = 0
-    for s, d in zip(seq, dim_list):
-        i *= d
-        i += s
-
-    return i
-
-
-def _to_qubism_index_pair(i, dim_list, how='pairs'):
-    """
-    For a matrix entry with index i
-    it returns x, y coordinates in qubism mapping.
-
-    Parameters
-    ----------
-    i : int
-        Index in a matrix.
-
-    dim_list : list of int
-        List of dimensions of consecutive particles.
-
-    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
-        Type of qubistic plot.
-
-    Returns
-    -------
-    x, y : tuple of ints
-        List of coordinates for each particle.
-
-    """
-    seq = _index_to_sequence(i, dim_list)
-
-    if how == 'pairs':
-        y = _sequence_to_index(seq[::2], dim_list[::2])
-        x = _sequence_to_index(seq[1::2], dim_list[1::2])
-    elif how == 'pairs_skewed':
-        dim_list2 = dim_list[::2]
-        y = _sequence_to_index(seq[::2], dim_list2)
-        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
-        x = _sequence_to_index(seq2, dim_list2)
-    elif how == 'before_after':
-        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
-        n = len(dim_list)
-        y = _sequence_to_index(reversed(seq[:(n // 2)]),
-                               reversed(dim_list[:(n // 2)]))
-        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
-    else:
-        raise Exception("No such 'how'.")
-
-    return x, y
-
-
-def _sequence_to_latex(seq, style='ket'):
-    """
-    For a sequence of particle states generate LaTeX code.
-
-    Parameters
-    ----------
-    seq : list of ints
-        List of coordinates for each particle.
-
-    style : 'ket' (default), 'bra' or 'bare'
-        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
-
-    Returns
-    -------
-    latex : str
-        LaTeX output.
-
-    """
-    if style == 'ket':
-        latex = "$\\left|{0}\\right\\rangle$"
-    elif style == 'bra':
-        latex = "$\\left\\langle{0}\\right|$"
-    elif style == 'bare':
-        latex = "${0}$"
-    else:
-        raise Exception("No such style.")
-    return latex.format("".join(map(str, seq)))
-
-
-def plot_qubism(ket, theme='light', how='pairs',
-                grid_iteration=1, legend_iteration=0,
-                fig=None, ax=None, figsize=(6, 6)):
-    """
-    Qubism plot for pure states of many qudits.  Works best for spin chains,
-    especially with even number of particles of the same dimension.  Allows to
-    see entanglement between first 2k particles and the rest.
-
-    Parameters
-    ----------
-    ket : Qobj
-        Pure state for plotting.
-
-    theme : 'light' (default) or 'dark'
-        Set coloring theme for mapping complex values into colors.
-        See: complex_array_to_rgb.
-
-    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
-        Type of Qubism plotting.  Options:
-
-        - 'pairs' - typical coordinates,
-        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
-        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
-
-    grid_iteration : int (default 1)
-        Helper lines to be drawn on plot.
-        Show tiles for 2*grid_iteration particles vs all others.
-
-    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
-        Show labels for first ``2*legend_iteration`` particles.  Option
-        'grid_iteration' sets the same number of particles as for
-        grid_iteration.  Option 'all' makes label for all particles.  Typically
-        it should be 0, 1, 2 or perhaps 3.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Notes
-    -----
-    See also [1]_.
-
-    References
-    ----------
-    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
-       and G. Sierra, *Qubism: self-similar visualization of many-body
-       wavefunctions*, `New J. Phys. 14 053028
-       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
-       (2012), open access.
-    """
-
-    if not isket(ket):
-        raise Exception("Qubism works only for pure states, i.e. kets.")
-        # add for dm? (perhaps a separate function, plot_qubism_dm)
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    dim_list = ket.dims[0]
-    n = len(dim_list)
-
-    # for odd number of particles - pixels are rectangular
-    if n % 2 == 1:
-        ket = tensor(ket, Qobj([1] * dim_list[-1]))
-        dim_list = ket.dims[0]
-        n += 1
-
-    ketdata = ket.full()
-
-    if how == 'pairs':
-        dim_list_y = dim_list[::2]
-        dim_list_x = dim_list[1::2]
-    elif how == 'pairs_skewed':
-        dim_list_y = dim_list[::2]
-        dim_list_x = dim_list[1::2]
-        if dim_list_x != dim_list_y:
-            raise Exception("For 'pairs_skewed' pairs " +
-                            "of dimensions need to be the same.")
-    elif how == 'before_after':
-        dim_list_y = list(reversed(dim_list[:(n // 2)]))
-        dim_list_x = dim_list[(n // 2):]
-    else:
-        raise Exception("No such 'how'.")
-
-    size_x = np.prod(dim_list_x)
-    size_y = np.prod(dim_list_y)
-
-    qub = np.zeros([size_x, size_y], dtype=complex)
-    for i in range(ketdata.size):
-        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
-    qub = qub.transpose()
-
-    quadrants_x = np.prod(dim_list_x[:grid_iteration])
-    quadrants_y = np.prod(dim_list_y[:grid_iteration])
-
-    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
-    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
-
-    ax.set_xticks(ticks_x)
-    ax.set_xticklabels([""] * (quadrants_x - 1))
-    ax.set_yticks(ticks_y)
-    ax.set_yticklabels([""] * (quadrants_y - 1))
-    theme2color_of_lines = {'light': '#000000',
-                            'dark': '#FFFFFF'}
-    ax.grid(True, color=theme2color_of_lines[theme])
-    ax.imshow(complex_array_to_rgb(qub, theme=theme),
-              interpolation="none",
-              extent=(0, size_x, 0, size_y))
-
-    if legend_iteration == 'all':
-        label_n = n // 2
-    elif legend_iteration == 'grid_iteration':
-        label_n = grid_iteration
-    else:
-        try:
-            label_n = int(legend_iteration)
-        except:
-            raise Exception("No such option for legend_iteration keyword " +
-                            "argument. Use 'all', 'grid_iteration' or an " +
-                            "integer.")
-
-    if label_n:
-
-        if how == 'before_after':
-            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
-                + dim_list_x[:label_n]
-        else:
-            dim_list_small = []
-            for j in range(label_n):
-                dim_list_small.append(dim_list_y[j])
-                dim_list_small.append(dim_list_x[j])
-
-        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
-        shift_x = 0.5 * scale_x
-        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
-        shift_y = 0.5 * scale_y
-
-        bbox = ax.get_window_extent().transformed(
-            fig.dpi_scale_trans.inverted())
-        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
-        opts = {'fontsize': fontsize,
-                'color': theme2color_of_lines[theme],
-                'horizontalalignment': 'center',
-                'verticalalignment': 'center'}
-        for i in range(np.prod(dim_list_small)):
-            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
-            seq = _index_to_sequence(i, dim_list=dim_list_small)
-            ax.text(scale_x * x + shift_x,
-                    size_y - (scale_y * y + shift_y),
-                    _sequence_to_latex(seq),
-                    **opts)
-    return fig, ax
-
-
-def plot_schmidt(ket, splitting=None,
-                 labels_iteration=(3, 2),
-                 theme='light',
-                 fig=None, ax=None, figsize=(6, 6)):
-    """
-    Plotting scheme related to Schmidt decomposition.
-    Converts a state into a matrix (A_ij -> A_i^j),
-    where rows are first particles and columns - last.
-
-    See also: plot_qubism with how='before_after' for a similar plot.
-
-    Parameters
-    ----------
-    ket : Qobj
-        Pure state for plotting.
-
-    splitting : int
-        Plot for a number of first particles versus the rest.
-        If not given, it is (number of particles + 1) // 2.
-
-    theme : 'light' (default) or 'dark'
-        Set coloring theme for mapping complex values into colors.
-        See: complex_array_to_rgb.
-
-    labels_iteration : int or pair of ints (default (3,2))
-        Number of particles to be shown as tick labels,
-        for first (vertical) and last (horizontal) particles, respectively.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-    if not isket(ket):
-        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
-
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    dim_list = ket.dims[0]
-
-    if splitting is None:
-        splitting = (len(dim_list) + 1) // 2
-
-    if isinstance(labels_iteration, int):
-        labels_iteration = labels_iteration, labels_iteration
-
-    ketdata = ket.full()
-
-    dim_list_y = dim_list[:splitting]
-    dim_list_x = dim_list[splitting:]
-
-    size_x = np.prod(dim_list_x)
-    size_y = np.prod(dim_list_y)
-
-    ketdata = ketdata.reshape((size_y, size_x))
-
-    dim_list_small_x = dim_list_x[:labels_iteration[1]]
-    dim_list_small_y = dim_list_y[:labels_iteration[0]]
-
-    quadrants_x = np.prod(dim_list_small_x)
-    quadrants_y = np.prod(dim_list_small_y)
-
-    ticks_x = [size_x / quadrants_x * (i + 0.5)
-               for i in range(quadrants_x)]
-    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
-               for i in range(quadrants_y)]
-
-    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
-                                                      dim_list=dim_list_x))
-                for i in range(quadrants_x)]
-    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
-                                                      dim_list=dim_list_y))
-                for i in range(quadrants_y)]
-
-    ax.set_xticks(ticks_x)
-    ax.set_xticklabels(labels_x)
-    ax.set_yticks(ticks_y)
-    ax.set_yticklabels(labels_y)
-    ax.set_xlabel("last particles")
-    ax.set_ylabel("first particles")
-
-    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
-              interpolation="none",
-              extent=(0, size_x, 0, size_y))
-
-    return fig, ax
+"""
+Functions for visualizing results of quantum dynamics simulations,
+visualizations of quantum states and processes.
+"""
+
+__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
+           'plot_energy_levels', 'fock_distribution',
+           'plot_fock_distribution', 'wigner_fock_distribution',
+           'plot_wigner_fock_distribution', 'plot_wigner',
+           'plot_expectation_values', 'plot_spin_distribution_2d',
+           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
+           'complex_array_to_rgb', 'matrix_histogram',
+           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
+
+import warnings
+import itertools as it
+import numpy as np
+from numpy import pi, array, sin, cos, angle, log2
+
+from packaging.version import parse as parse_version
+
+from . import (
+    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
+)
+from .core.dimensions import flatten
+from .core.superop_reps import _to_superpauli, isqubitdims
+from .wigner import wigner
+from .matplotlib_utilities import complex_phase_cmap
+
+try:
+    import matplotlib.pyplot as plt
+    import matplotlib as mpl
+    from matplotlib import cm
+    from mpl_toolkits.mplot3d import Axes3D
+
+    # Define a custom _axes3D function based on the matplotlib version.
+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+    if parse_version(mpl.__version__) >= parse_version('3.4'):
+        def _axes3D(fig, *args, **kwargs):
+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+            return fig.add_axes(ax)
+    else:
+        def _axes3D(*args, **kwargs):
+            return Axes3D(*args, **kwargs)
+except:
+    pass
+
+
+def plot_wigner_sphere(fig, ax, wigner, reflections):
+    """Plots a coloured Bloch sphere.
+
+    Parameters
+    ----------
+    fig : :obj:`matplotlib.figure.Figure`
+        An instance of :obj:`~matplotlib.figure.Figure`.
+    ax : :obj:`matplotlib.axes.Axes`
+        An axes instance in the given figure.
+    wigner : list of float
+        The wigner transformation at `steps` different theta and phi.
+    reflections : bool
+        If the reflections of the sphere should be plotted as well.
+
+    Notes
+    -----
+    Special thanks to Russell P Rundle for writing this function.
+    """
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+    steps = len(wigner)
+
+    theta = np.linspace(0, np.pi, steps)
+    phi = np.linspace(0, 2 * np.pi, steps)
+    x = np.outer(np.sin(theta), np.cos(phi))
+    y = np.outer(np.sin(theta), np.sin(phi))
+    z = np.outer(np.cos(theta), np.ones(steps))
+    wigner = np.real(wigner)
+    wigner_max = np.real(np.amax(np.abs(wigner)))
+
+    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
+
+    # Plot coloured Bloch sphere:
+    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
+                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
+                    zorder=0.5, antialiased=None)
+
+    if reflections:
+        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+                                 (2*wigner_max))  # bottom
+        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+                                 (2*wigner_max))  # side
+        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+                                 (2*wigner_max))  # back
+
+        # Plot bottom reflection:
+        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
+                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+                        ccount=steps/2, linewidth=0, zorder=0.5,
+                        antialiased=False)
+
+        # Plot side reflection:
+        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
+                        z[0:steps, 0:steps], facecolors=wigner_c3,
+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+                        ccount=steps/2, linewidth=0, zorder=0.5,
+                        antialiased=False)
+
+        # Plot back reflection:
+        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
+                        z[0:steps, 0:steps], facecolors=wigner_c4,
+                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
+                        ccount=steps/2, linewidth=0, zorder=0.5,
+                        antialiased=False)
+
+    # Create colourbar:
+    m = cm.ScalarMappable(cmap=cm.seismic_r)
+    m.set_array([-wigner_max, wigner_max])
+    plt.colorbar(m, shrink=0.5, aspect=10)
+
+    plt.show()
+
+
+# Adopted from the SciPy Cookbook.
+def _blob(x, y, w, w_max, area, color_fn, ax=None):
+    """
+    Draws a square-shaped blob with the given area (< 1) at
+    the given coordinates.
+    """
+    hs = np.sqrt(area) / 2
+    xcorners = array([x - hs, x + hs, x + hs, x - hs])
+    ycorners = array([y - hs, y - hs, y + hs, y + hs])
+
+    if ax is not None:
+        handle = ax
+    else:
+        handle = plt
+
+    handle.fill(xcorners, ycorners,
+             color=color_fn(w))
+
+
+def _cb_labels(left_dims):
+    """Creates plot labels for matrix elements in the computational basis.
+
+    Parameters
+    ----------
+    left_dims : flat list of ints
+        Dimensions of the left index of a density operator. E. g.
+        [2, 3] for a qubit tensored with a qutrit.
+
+    Returns
+    -------
+    left_labels, right_labels : lists of strings
+        Labels for the left and right indices of a density operator
+        (kets and bras, respectively).
+    """
+    # FIXME: assumes dims, such that we only need left_dims == dims[0].
+    basis_labels = list(map(",".join, it.product(*[
+        map(str, range(dim))
+        for dim in left_dims
+    ])))
+    return [
+        map(fmt.format, basis_labels) for fmt in
+        (
+            r"$\langle{}|$",
+            r"$|{}\rangle$",
+        )
+    ]
+
+
+# Adopted from the SciPy Cookbook.
+def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
+           label_top=True, color_style="scaled"):
+    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
+
+    Parameters
+    ----------
+    rho : qobj
+        Input density matrix or superoperator.
+
+    xlabels : list of strings or False
+        list of x labels
+
+    ylabels : list of strings or False
+        list of y labels
+
+    title : string
+        title of the plot (optional)
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    cmap : a matplotlib colormap instance
+        Color map to use when plotting.
+
+    label_top : bool
+        If True, x-axis labels will be placed on top, otherwise
+        they will appear below the plot.
+
+    color_style : string
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"scaled"`` (default), each color is chosen by
+           passing the absolute value of the corresponding matrix
+           element into `cmap` with the sign of the real part.
+        -  If set to ``"threshold"``, each square is plotted as
+           the maximum of `cmap` for the positive real part and as
+           the minimum for the negative part of the matrix element;
+           note that this generalizes `"threshold"` to complex numbers.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not a quantum object.
+
+    Examples
+    --------
+    >>> import qutip
+    >>>
+    >>> dm = qutip.rand_dm(4)
+    >>> fig, ax = qutip.hinton(dm)
+    >>> fig.show()
+    >>>
+    >>> qutip.settings.colorblind_safe = True
+    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
+    >>> fig.show()
+    >>> qutip.settings.colorblind_safe = False
+    >>>
+    >>> fig, ax = qutip.hinton(dm, color_style="phase")
+    >>> fig.show()
+    """
+
+    # Apply default colormaps.
+    # TODO: abstract this away into something that makes default
+    #       colormaps.
+    cmap = (
+        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
+        if cmap is None else cmap
+    )
+
+    # Extract plotting data W from the input.
+    if isinstance(rho, Qobj):
+        if rho.isoper:
+            W = rho.full()
+
+            # Create default labels if none are given.
+            if xlabels is None or ylabels is None:
+                labels = _cb_labels(rho.dims[0])
+                xlabels = xlabels if xlabels is not None else list(labels[0])
+                ylabels = ylabels if ylabels is not None else list(labels[1])
+
+        elif rho.isoperket:
+            W = vector_to_operator(rho).full()
+        elif rho.isoperbra:
+            W = vector_to_operator(rho.dag()).full()
+        elif rho.issuper:
+            if not isqubitdims(rho.dims):
+                raise ValueError("Hinton plots of superoperators are "
+                                 "currently only supported for qubits.")
+            # Convert to a superoperator in the Pauli basis,
+            # so that all the elements are real.
+            sqobj = _to_superpauli(rho)
+            nq = int(log2(sqobj.shape[0]) / 2)
+            W = sqobj.full().T
+            # Create default labels, too.
+            if (xlabels is None) or (ylabels is None):
+                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+                xlabels = xlabels if xlabels is not None else labels
+                ylabels = ylabels if ylabels is not None else labels
+
+        else:
+            raise ValueError(
+                "Input quantum object must be an operator or superoperator."
+            )
+
+    else:
+        W = rho
+
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
+    else:
+        fig = None
+
+    if not (xlabels or ylabels):
+        ax.axis('off')
+    if title:
+        ax.set_title(title)
+
+    ax.axis('equal')
+    ax.set_frame_on(False)
+
+    height, width = W.shape
+
+    w_max = 1.25 * max(abs(np.array(W)).flatten())
+    if w_max <= 0.0:
+        w_max = 1.0
+
+    # Set color_fn here.
+    if color_style == "scaled":
+        def color_fn(w):
+            w = np.abs(w) * np.sign(np.real(w))
+            return cmap(int((w + w_max) * 256 / (2 * w_max)))
+    elif color_style == "threshold":
+        def color_fn(w):
+            w = np.real(w)
+            return cmap(255 if w > 0 else 0)
+    elif color_style == "phase":
+        def color_fn(w):
+            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
+    else:
+        raise ValueError(
+            "Unknown color style {} for Hinton diagrams.".format(color_style)
+        )
+
+    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
+            color=cmap(128))
+    for x in range(width):
+        for y in range(height):
+            _x = x + 1
+            _y = y + 1
+            _blob(
+                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
+                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
+
+    # color axis
+    vmax = np.pi if color_style == "phase" else abs(W).max()
+    norm = mpl.colors.Normalize(-vmax, vmax)
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+
+    xtics = 0.5 + np.arange(width)
+    # x axis
+    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        ax.set_xticklabels(xlabels)
+        if label_top:
+            ax.xaxis.tick_top()
+    ax.tick_params(axis='x', labelsize=14)
+
+    # y axis
+    ytics = 0.5 + np.arange(height)
+    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        ax.set_yticklabels(list(reversed(ylabels)))
+    ax.tick_params(axis='y', labelsize=14)
+
+    return fig, ax
+
+
+def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
+    """Plots a matrix of values on a sphere
+
+    Parameters
+    ----------
+    theta : float
+        Angle with respect to z-axis
+
+    phi : float
+        Angle in x-y plane
+
+    values : array
+        Data set to be plotted
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    save : bool {False , True}
+        Whether to save the figure or not
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+    if fig is None or ax is None:
+        fig = plt.figure()
+        ax = _axes3D(fig)
+
+    thetam, phim = np.meshgrid(theta, phi)
+    xx = sin(thetam) * cos(phim)
+    yy = sin(thetam) * sin(phim)
+    zz = cos(thetam)
+    r = array(abs(values))
+    ph = angle(values)
+    # normalize color range based on phase angles in list ph
+    nrm = mpl.colors.Normalize(ph.min(), ph.max())
+
+    # plot with facecolors set to cm.jet colormap normalized to nrm
+    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
+                    facecolors=cm.jet(nrm(ph)), linewidth=0)
+    # create new axes on plot for colorbar and shrink it a bit.
+    # pad shifts location of bar with repsect to the main plot
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+
+    # create new colorbar in axes cax with cm jet and normalized to nrm like
+    # our facecolors
+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
+    # add our colorbar label
+    cb1.set_label('Angle')
+
+    if save:
+        plt.savefig("sphereplot.png")
+
+    return fig, ax
+
+
+def _remove_margins(axis):
+    """
+    removes margins about z = 0 and improves the style
+    by monkey patching
+    """
+    def _get_coord_info_new(renderer):
+        mins, maxs, centers, deltas, tc, highs = \
+            _get_coord_info_old(renderer)
+        mins += deltas / 4
+        maxs -= deltas / 4
+        return mins, maxs, centers, deltas, tc, highs
+
+    _get_coord_info_old = axis._get_coord_info
+    axis._get_coord_info = _get_coord_info_new
+
+
+def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
+    """
+    truncates portion of a colormap and returns the new one
+    """
+    if isinstance(cmap, str):
+        cmap = plt.get_cmap(cmap)
+    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
+        'trunc({n},{a:.2f},{b:.2f})'.format(
+            n=cmap.name, a=minval, b=maxval),
+        cmap(np.linspace(minval, maxval, n)))
+    return new_cmap
+
+
+def _stick_to_planes(stick, azim, ax, M, spacing):
+    """adjusts xlim and ylim in way that bars will
+    Stick to xz and yz planes
+    """
+    if stick is True:
+        azim = azim % 360
+        if 0 <= azim <= 90:
+            ax.set_ylim(1 - .5,)
+            ax.set_xlim(1 - .5,)
+        elif 90 < azim <= 180:
+            ax.set_ylim(1 - .5,)
+            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
+        elif 180 < azim <= 270:
+            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
+            ax.set_xlim(0, M.shape[0] + (.5 - spacing))
+        elif 270 < azim < 360:
+            ax.set_ylim(0, M.shape[1] + (.5 - spacing))
+            ax.set_xlim(1 - .5,)
+
+
+def _update_yaxis(spacing, M, ax, ylabels):
+    """
+    updates the y-axis
+    """
+    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        ax.set_yticklabels(ylabels)
+    else:
+        ax.set_yticklabels([str(y + 1) for y in range(M.shape[1])])
+        ax.set_yticklabels([str(i) for i in range(M.shape[1])])
+    ax.tick_params(axis='y', labelsize=14)
+    ax.set_yticks([y + (1 - (spacing / 2)) for y in range(M.shape[1])])
+
+
+def _update_xaxis(spacing, M, ax, xlabels):
+    """
+    updates the x-axis
+    """
+    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        ax.set_xticklabels(xlabels)
+    else:
+        ax.set_xticklabels([str(x + 1) for x in range(M.shape[0])])
+        ax.set_xticklabels([str(i) for i in range(M.shape[0])])
+    ax.tick_params(axis='x', labelsize=14)
+    ax.set_xticks([x + (1 - (spacing / 2)) for x in range(M.shape[0])])
+
+
+def _update_zaxis(ax, z_min, z_max, zticks):
+    """
+    updates the z-axis
+    """
+    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
+    if isinstance(zticks, list):
+        ax.set_zticks(zticks)
+    ax.set_zlim3d([min(z_min, 0), z_max])
+
+
+def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
+                     colorbar=True, fig=None, ax=None, options=None):
+    """
+    Draw a histogram for the matrix M, with the given x and y labels and title.
+
+    Parameters
+    ----------
+    M : Matrix of Qobj
+        The matrix to visualize
+
+    xlabels : list of strings
+        list of x labels
+
+    ylabels : list of strings
+        list of y labels
+
+    title : string
+        title of the plot (optional)
+
+    limits : list/array with two float numbers
+        The z-axis limits [min, max] (optional)
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    colorbar : bool (default: True)
+        show colorbar
+
+    options : dict
+        A dictionary containing extra options for the plot.
+        The names (keys) and values of the options are
+        described below:
+
+        'zticks' : list of numbers
+            A list of z-axis tick locations.
+
+        'cmap' : string (default: 'jet')
+            The name of the color map to use.
+
+        'cmap_min' : float (default: 0.0)
+            The lower bound to truncate the color map at.
+            A value in range 0 - 1. The default, 0, leaves the lower
+            bound of the map unchanged.
+
+        'cmap_max' : float (default: 1.0)
+            The upper bound to truncate the color map at.
+            A value in range 0 - 1. The default, 1, leaves the upper
+            bound of the map unchanged.
+
+        'bars_spacing' : float (default: 0.1)
+            spacing between bars.
+
+        'bars_alpha' : float (default: 1.)
+            transparency of bars, should be in range 0 - 1
+
+        'bars_lw' : float (default: 0.5)
+            linewidth of bars' edges.
+
+        'bars_edgecolor' : color (default: 'k')
+            The colors of the bars' edges.
+            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
+
+        'shade' : bool (default: True)
+            Whether to shade the dark sides of the bars (True) or not (False).
+            The shading is relative to plot's source of light.
+
+        'azim' : float
+            The azimuthal viewing angle.
+
+        'elev' : float
+            The elevation viewing angle.
+
+        'proj_type' : string (default: 'ortho' if ax is not passed)
+            The type of projection ('ortho' or 'persp')
+
+        'stick' : bool (default: False)
+            Changes xlim and ylim in such a way that bars next to
+            XZ and YZ planes will stick to those planes.
+            This option has no effect if ``ax`` is passed as a parameter.
+
+        'cbar_pad' : float (default: 0.04)
+            The fraction of the original axes between the colorbar
+            and the new image axes.
+            (i.e. the padding between the 3D figure and the colorbar).
+
+        'cbar_to_z' : bool (default: False)
+            Whether to set the color of maximum and minimum z-values to the
+            maximum and minimum colors in the colorbar (True) or not (False).
+
+        'figsize' : tuple of two numbers
+            The size of the figure.
+
+    Returns :
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not valid.
+
+    """
+
+    # default options
+    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
+                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
+                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
+                    'shade': False, 'azim': -35, 'elev': 35,
+                    'proj_type': 'ortho', 'stick': False,
+                    'cbar_pad': 0.04, 'cbar_to_z': False}
+
+    # update default_opts from input options
+    if options is None:
+        pass
+    elif isinstance(options, dict):
+        # check if keys in options dict are valid
+        if set(options) - set(default_opts):
+            raise ValueError("invalid key(s) found in options: "
+                             f"{', '.join(set(options) - set(default_opts))}")
+        else:
+            # updating default options
+            default_opts.update(options)
+    else:
+        raise ValueError("options must be a dictionary")
+
+    if isinstance(M, Qobj):
+        # extract matrix data from Qobj
+        M = M.full()
+
+    n = np.size(M)
+    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+    xpos = xpos.T.flatten() + 0.5
+    ypos = ypos.T.flatten() + 0.5
+    zpos = np.zeros(n)
+    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
+    dz = np.real(M.flatten())
+
+    if isinstance(limits, list) and len(limits) == 2:
+        z_min = limits[0]
+        z_max = limits[1]
+    else:
+        z_min = min(dz)
+        z_max = max(dz)
+        if z_min == z_max:
+            z_min -= 0.1
+            z_max += 0.1
+
+    if default_opts['cbar_to_z']:
+        norm = mpl.colors.Normalize(min(dz), max(dz))
+    else:
+        norm = mpl.colors.Normalize(z_min, z_max)
+    cmap = _truncate_colormap(default_opts['cmap'],
+                              default_opts['cmap_min'],
+                              default_opts['cmap_max'])
+    colors = cmap(norm(dz))
+
+    if ax is None:
+        fig = plt.figure(figsize=default_opts['figsize'])
+        ax = _axes3D(fig,
+                     azim=default_opts['azim'] % 360,
+                     elev=default_opts['elev'] % 360)
+        ax.set_proj_type(default_opts['proj_type'])
+
+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
+             edgecolors=default_opts['bars_edgecolor'],
+             linewidths=default_opts['bars_lw'],
+             alpha=default_opts['bars_alpha'],
+             shade=default_opts['shade'])
+    # remove vertical lines on xz and yz plane
+    ax.yaxis._axinfo["grid"]['linewidth'] = 0
+    ax.xaxis._axinfo["grid"]['linewidth'] = 0
+
+    if title:
+        ax.set_title(title)
+
+    # x axis
+    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
+
+    # y axis
+    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
+
+    # z axis
+    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
+
+    # stick to xz and yz plane
+    _stick_to_planes(default_opts['stick'],
+                     default_opts['azim'], ax, M,
+                     default_opts['bars_spacing'])
+
+    # color axis
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
+                                         pad=default_opts['cbar_pad'])
+        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+
+    # removing margins
+    _remove_margins(ax.xaxis)
+    _remove_margins(ax.yaxis)
+    _remove_margins(ax.zaxis)
+
+    return fig, ax
+
+
+def matrix_histogram_complex(M, xlabels=None, ylabels=None,
+                             title=None, limits=None, phase_limits=None,
+                             colorbar=True, fig=None, ax=None,
+                             threshold=None):
+    """
+    Draw a histogram for the amplitudes of matrix M, using the argument
+    of each element for coloring the bars, with the given x and y labels
+    and title.
+
+    Parameters
+    ----------
+    M : Matrix of Qobj
+        The matrix to visualize
+
+    xlabels : list of strings
+        list of x labels
+
+    ylabels : list of strings
+        list of y labels
+
+    title : string
+        title of the plot (optional)
+
+    limits : list/array with two float numbers
+        The z-axis limits [min, max] (optional)
+
+    phase_limits : list/array with two float numbers
+        The phase-axis (colorbar) limits [min, max] (optional)
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    threshold: float (None)
+        Threshold for when bars of smaller height should be transparent. If
+        not set, all bars are colored according to the color map.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not valid.
+
+    """
+
+    if isinstance(M, Qobj):
+        # extract matrix data from Qobj
+        M = M.full()
+
+    n = np.size(M)
+    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+    xpos = xpos.T.flatten() - 0.5
+    ypos = ypos.T.flatten() - 0.5
+    zpos = np.zeros(n)
+    dx = dy = 0.8 * np.ones(n)
+    Mvec = M.flatten()
+    dz = abs(Mvec)
+
+    # make small numbers real, to avoid random colors
+    idx, = np.where(abs(Mvec) < 0.001)
+    Mvec[idx] = abs(Mvec[idx])
+
+    if phase_limits:  # check that limits is a list type
+        phase_min = phase_limits[0]
+        phase_max = phase_limits[1]
+    else:
+        phase_min = -pi
+        phase_max = pi
+
+    norm = mpl.colors.Normalize(phase_min, phase_max)
+    cmap = complex_phase_cmap()
+
+    colors = cmap(norm(angle(Mvec)))
+    if threshold is not None:
+        colors[:, 3] = 1 * (dz > threshold)
+
+    if ax is None:
+        fig = plt.figure()
+        ax = _axes3D(fig, azim=-35, elev=35)
+
+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
+
+    if title:
+        ax.set_title(title)
+
+    # x axis
+    xtics = -0.5 + np.arange(M.shape[0])
+    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        ax.set_xticklabels(xlabels)
+    ax.tick_params(axis='x', labelsize=12)
+
+    # y axis
+    ytics = -0.5 + np.arange(M.shape[1])
+    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        ax.set_yticklabels(ylabels)
+    ax.tick_params(axis='y', labelsize=12)
+
+    # z axis
+    if limits and isinstance(limits, list):
+        ax.set_zlim3d(limits)
+    else:
+        ax.set_zlim3d([0, 1])  # use min/max
+    # ax.set_zlabel('abs')
+
+    # color axis
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
+        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+        cb.set_ticklabels(
+            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
+        cb.set_label('arg')
+
+    return fig, ax
+
+
+def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
+                       figsize=(8, 12), fig=None, ax=None):
+    """
+    Plot the energy level diagrams for a list of Hamiltonians. Include
+    up to N energy levels. For each element in H_list, the energy
+    levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted,
+    where n is the index of an element in H_list.
+
+    Parameters
+    ----------
+
+        H_list : List of Qobj
+            A list of Hamiltonians.
+
+        labels : List of string
+            A list of labels for each Hamiltonian
+
+        show_ylabels : Bool (default False)
+            Show y labels to the left of energy levels of the initial
+            Hamiltonian.
+
+        N : int
+            The number of energy levels to plot
+
+        figsize : tuple (int,int)
+            The size of the figure (width, height).
+
+        fig : a matplotlib Figure instance
+            The Figure canvas in which the plot will be drawn.
+
+        ax : a matplotlib axes instance
+            The axes context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+
+        ValueError
+            Input argument is not valid.
+
+    """
+
+    if not isinstance(H_list, list):
+        raise ValueError("H_list must be a list of Qobj instances")
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    H = H_list[0]
+    N = H.shape[0] if N == 0 else min(H.shape[0], N)
+
+    xticks = []
+    yticks = []
+
+    x = 0
+    evals0 = H.eigenenergies(eigvals=N)
+    for e_idx, e in enumerate(evals0[:N]):
+        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+        yticks.append(e)
+    xticks.append(x + 1)
+    x += 2
+
+    for H1 in H_list[1:]:
+
+        H = H + H1
+        evals1 = H.eigenenergies()
+
+        for e_idx, e in enumerate(evals1[:N]):
+            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
+        x += 1
+
+        for e_idx, e in enumerate(evals1[:N]):
+            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+        xticks.append(x + 1)
+        x += 2
+
+        evals0 = evals1
+
+    ax.set_frame_on(False)
+
+    if show_ylabels:
+        yticks = np.unique(np.around(yticks, 1))
+        ax.set_yticks(yticks)
+    else:
+        ax.axes.get_yaxis().set_visible(False)
+
+    if labels:
+        ax.get_xaxis().tick_bottom()
+        ax.set_xticks(xticks)
+        ax.set_xticklabels(labels, fontsize=16)
+    else:
+        ax.axes.get_xaxis().set_visible(False)
+
+    return fig, ax
+
+
+def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
+                         figsize=(8, 12), fig=None, ax=None):
+    warnings.warn("Deprecated: Use plot_energy_levels")
+    return plot_energy_levels(H_list, N=N, labels=labels,
+                              show_ylabels=show_ylabels,
+                              figsize=figsize, fig=fig, ax=ax)
+
+
+def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
+                           figsize=(8, 6), title=None, unit_y_range=True):
+    """
+    Plot the Fock distribution for a density matrix (or ket) that describes
+    an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    title : string
+        An optional title for the figure.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    if isket(rho):
+        rho = ket2dm(rho)
+
+    N = rho.shape[0]
+
+    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
+           color="green", alpha=0.6, width=0.8)
+    if unit_y_range:
+        ax.set_ylim(0, 1)
+
+    ax.set_xlim(-.5 + offset, N + offset)
+    ax.set_xlabel('Fock number', fontsize=12)
+    ax.set_ylabel('Occupation probability', fontsize=12)
+
+    if title:
+        ax.set_title(title)
+
+    return fig, ax
+
+
+def fock_distribution(rho, offset=0, fig=None, ax=None,
+                      figsize=(8, 6), title=None, unit_y_range=True):
+    warnings.warn("Deprecated: Use plot_fock_distribution")
+    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
+                                  figsize=figsize, title=title,
+                                  unit_y_range=unit_y_range)
+
+
+def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
+                cmap=None, alpha_max=7.5, colorbar=False,
+                method='clenshaw', projection='2d'):
+    """
+    Plot the the Wigner function for a density matrix (or ket) that describes
+    an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    cmap : a matplotlib cmap instance
+        The colormap.
+
+    alpha_max : float
+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig and not ax:
+        if projection == '2d':
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+        elif projection == '3d':
+            fig = plt.figure(figsize=figsize)
+            ax = fig.add_subplot(1, 1, 1, projection='3d')
+        else:
+            raise ValueError('Unexpected value of projection keyword argument')
+
+    if isket(rho):
+        rho = ket2dm(rho)
+
+    xvec = np.linspace(-alpha_max, alpha_max, 200)
+    W0 = wigner(rho, xvec, xvec, method=method)
+
+    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
+
+    wlim = abs(W).max()
+
+    if cmap is None:
+        cmap = cm.get_cmap('RdBu')
+
+    if projection == '2d':
+        cf = ax.contourf(xvec, yvec, W, 100,
+                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
+    elif projection == '3d':
+        X, Y = np.meshgrid(xvec, xvec)
+        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
+                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
+    else:
+        raise ValueError('Unexpected value of projection keyword argument.')
+
+    if xvec is not yvec:
+        ax.set_ylim(xvec.min(), xvec.max())
+
+    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
+    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+
+    if colorbar:
+        fig.colorbar(cf, ax=ax)
+
+    ax.set_title("Wigner function", fontsize=12)
+
+    return fig, ax
+
+
+def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
+                                  cmap=None, alpha_max=7.5, colorbar=False,
+                                  method='iterative', projection='2d'):
+    """
+    Plot the Fock distribution and the Wigner function for a density matrix
+    (or ket) that describes an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    axes : a list of two matplotlib axes instances
+        The axes context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    cmap : a matplotlib cmap instance
+        The colormap.
+
+    alpha_max : float
+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    method : string {'iterative', 'laguerre', 'fft'}
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig and not axes:
+        if projection == '2d':
+            fig, axes = plt.subplots(1, 2, figsize=figsize)
+        elif projection == '3d':
+            fig = plt.figure(figsize=figsize)
+            axes = [fig.add_subplot(1, 2, 1),
+                    fig.add_subplot(1, 2, 2, projection='3d')]
+        else:
+            raise ValueError('Unexpected value of projection keyword argument')
+
+    if isket(rho):
+        rho = ket2dm(rho)
+
+    plot_fock_distribution(rho, fig=fig, ax=axes[0])
+    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
+                alpha_max=alpha_max, colorbar=colorbar, method=method,
+                projection=projection)
+
+    return fig, axes
+
+
+def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
+                             cmap=None, alpha_max=7.5, colorbar=False,
+                             method='iterative'):
+    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
+    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
+                                         figsize=figsize, cmap=cmap,
+                                         alpha_max=alpha_max,
+                                         colorbar=colorbar,
+                                         method=method)
+
+
+def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
+                            fig=None, axes=None, figsize=(8, 4)):
+    """
+    Visualize the results (expectation values) for an evolution solver.
+    `results` is assumed to be an instance of Result, or a list of Result
+    instances.
+
+    Parameters
+    ----------
+    results : (list of) :class:`qutip.solver.Result`
+        List of results objects returned by any of the QuTiP evolution solvers.
+
+    ylabels : list of strings
+        The y-axis labels. List should be of the same length as `results`.
+
+    title : string
+        The title of the figure.
+
+    show_legend : bool
+        Whether or not to show the legend.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    axes : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+    if not isinstance(results, list):
+        results = [results]
+
+    n_e_ops = max([len(result.expect) for result in results])
+
+    if not fig or not axes:
+        if not figsize:
+            figsize = (12, 3 * n_e_ops)
+        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
+                                 figsize=figsize, squeeze=False)
+
+    for r_idx, result in enumerate(results):
+        for e_idx, e in enumerate(result.expect):
+            axes[e_idx, 0].plot(result.times, e,
+                                label="%s [%d]" % (result.solver, e_idx))
+
+    if title:
+        fig.suptitle(title)
+
+    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
+    for n in range(n_e_ops):
+        if show_legend:
+            axes[n, 0].legend()
+        if ylabels:
+            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
+
+    return fig, axes
+
+
+def plot_spin_distribution_2d(P, THETA, PHI,
+                              fig=None, ax=None, figsize=(8, 8)):
+    """
+    Plot a spin distribution function (given as meshgrid data) with a 2D
+    projection where the surface of the unit sphere is mapped on the unit disk.
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig or not ax:
+        if not figsize:
+            figsize = (8, 8)
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    Y = (THETA - pi / 2) / (pi / 2)
+    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+    else:
+        cmap = cm.RdYlBu
+
+    ax.pcolor(X, Y, P.real, cmap=cmap)
+    ax.set_xlabel(r'$\varphi$', fontsize=18)
+    ax.set_ylabel(r'$\theta$', fontsize=18)
+
+    ax.set_xticks([-1, 0, 1])
+    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
+    ax.set_yticks([-1, 0, 1])
+    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
+
+    return fig, ax
+
+
+def plot_spin_distribution_3d(P, THETA, PHI,
+                              fig=None, ax=None, figsize=(8, 6)):
+    """Plots a matrix of values on a sphere
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+
+    if fig is None or ax is None:
+        fig = plt.figure(figsize=figsize)
+        ax = _axes3D(fig, azim=-35, elev=35)
+
+    xx = sin(THETA) * cos(PHI)
+    yy = sin(THETA) * sin(PHI)
+    zz = cos(THETA)
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+        norm = mpl.colors.Normalize(-P.max(), P.max())
+    else:
+        cmap = cm.RdYlBu
+        norm = mpl.colors.Normalize(P.min(), P.max())
+
+    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+                    facecolors=cmap(norm(P)), linewidth=0)
+
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+    cb1.set_label('magnitude')
+
+    return fig, ax
+
+
+#
+# Qubism and other qubistic visualizations
+#
+def complex_array_to_rgb(X, theme='light', rmax=None):
+    """
+    Makes an array of complex number and converts it to an array of [r, g, b],
+    where phase gives hue and saturation/value are given by the absolute value.
+    Especially for use with imshow for complex plots.
+
+    For more info on coloring, see:
+        Emilia Petrisor,
+        Visualizing complex-valued functions with Matplotlib and Mayavi
+        https://nbviewer.ipython.org/github/empet/Math/blob/master/DomainColoring.ipynb
+
+    Parameters
+    ----------
+    X : array
+        Array (of any dimension) of complex numbers.
+
+    theme : 'light' (default) or 'dark'
+        Set coloring theme for mapping complex values into colors.
+
+    rmax : float
+        Maximal abs value for color normalization.
+        If None (default), uses np.abs(X).max().
+
+    Returns
+    -------
+    Y : array
+        Array of colors (of shape X.shape + (3,)).
+
+    """
+
+    absmax = rmax or np.abs(X).max()
+    if absmax == 0.:
+        absmax = 1.
+    Y = np.zeros(X.shape + (3,), dtype='float')
+    Y[..., 0] = np.angle(X) / (2 * pi) % 1
+    if theme == 'light':
+        Y[..., 1] = np.clip(np.abs(X) / absmax, 0, 1)
+        Y[..., 2] = 1
+    elif theme == 'dark':
+        Y[..., 1] = 1
+        Y[..., 2] = np.clip(np.abs(X) / absmax, 0, 1)
+    Y = mpl.colors.hsv_to_rgb(Y)
+    return Y
+
+
+def _index_to_sequence(i, dim_list):
+    """
+    For a matrix entry with index i it returns state it corresponds to.
+    In particular, for dim_list=[2]*n it returns i written as a binary number.
+
+    Parameters
+    ----------
+    i : int
+        Index in a matrix.
+
+    dim_list : list of int
+        List of dimensions of consecutive particles.
+
+    Returns
+    -------
+    seq : list
+        List of coordinates for each particle.
+
+    """
+    res = []
+    j = i
+    for d in reversed(dim_list):
+        j, s = divmod(j, d)
+        res.append(s)
+    return list(reversed(res))
+
+
+def _sequence_to_index(seq, dim_list):
+    """
+    Inverse of _index_to_sequence.
+
+    Parameters
+    ----------
+    seq : list of ints
+        List of coordinates for each particle.
+
+    dim_list : list of int
+        List of dimensions of consecutive particles.
+
+    Returns
+    -------
+    i : list
+        Index in a matrix.
+
+    """
+    i = 0
+    for s, d in zip(seq, dim_list):
+        i *= d
+        i += s
+
+    return i
+
+
+def _to_qubism_index_pair(i, dim_list, how='pairs'):
+    """
+    For a matrix entry with index i
+    it returns x, y coordinates in qubism mapping.
+
+    Parameters
+    ----------
+    i : int
+        Index in a matrix.
+
+    dim_list : list of int
+        List of dimensions of consecutive particles.
+
+    how : 'pairs' ('default'), 'pairs_skewed' or 'before_after'
+        Type of qubistic plot.
+
+    Returns
+    -------
+    x, y : tuple of ints
+        List of coordinates for each particle.
+
+    """
+    seq = _index_to_sequence(i, dim_list)
+
+    if how == 'pairs':
+        y = _sequence_to_index(seq[::2], dim_list[::2])
+        x = _sequence_to_index(seq[1::2], dim_list[1::2])
+    elif how == 'pairs_skewed':
+        dim_list2 = dim_list[::2]
+        y = _sequence_to_index(seq[::2], dim_list2)
+        seq2 = [(b - a) % d for a, b, d in zip(seq[::2], seq[1::2], dim_list2)]
+        x = _sequence_to_index(seq2, dim_list2)
+    elif how == 'before_after':
+        # https://en.wikipedia.org/wiki/File:Ising-tartan.png
+        n = len(dim_list)
+        y = _sequence_to_index(reversed(seq[:(n // 2)]),
+                               reversed(dim_list[:(n // 2)]))
+        x = _sequence_to_index(seq[(n // 2):], dim_list[(n // 2):])
+    else:
+        raise Exception("No such 'how'.")
+
+    return x, y
+
+
+def _sequence_to_latex(seq, style='ket'):
+    """
+    For a sequence of particle states generate LaTeX code.
+
+    Parameters
+    ----------
+    seq : list of ints
+        List of coordinates for each particle.
+
+    style : 'ket' (default), 'bra' or 'bare'
+        Style of LaTeX (i.e. |01> or <01| or 01, respectively).
+
+    Returns
+    -------
+    latex : str
+        LaTeX output.
+
+    """
+    if style == 'ket':
+        latex = "$\\left|{0}\\right\\rangle$"
+    elif style == 'bra':
+        latex = "$\\left\\langle{0}\\right|$"
+    elif style == 'bare':
+        latex = "${0}$"
+    else:
+        raise Exception("No such style.")
+    return latex.format("".join(map(str, seq)))
+
+
+def plot_qubism(ket, theme='light', how='pairs',
+                grid_iteration=1, legend_iteration=0,
+                fig=None, ax=None, figsize=(6, 6)):
+    """
+    Qubism plot for pure states of many qudits.  Works best for spin chains,
+    especially with even number of particles of the same dimension.  Allows to
+    see entanglement between first 2k particles and the rest.
+
+    Parameters
+    ----------
+    ket : Qobj
+        Pure state for plotting.
+
+    theme : 'light' (default) or 'dark'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
+        Type of Qubism plotting.  Options:
+
+        - 'pairs' - typical coordinates,
+        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
+        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
+
+    grid_iteration : int (default 1)
+        Helper lines to be drawn on plot.
+        Show tiles for 2*grid_iteration particles vs all others.
+
+    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
+        Show labels for first ``2*legend_iteration`` particles.  Option
+        'grid_iteration' sets the same number of particles as for
+        grid_iteration.  Option 'all' makes label for all particles.  Typically
+        it should be 0, 1, 2 or perhaps 3.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Notes
+    -----
+    See also [1]_.
+
+    References
+    ----------
+    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
+       and G. Sierra, *Qubism: self-similar visualization of many-body
+       wavefunctions*, `New J. Phys. 14 053028
+       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
+       (2012), open access.
+    """
+
+    if not isket(ket):
+        raise Exception("Qubism works only for pure states, i.e. kets.")
+        # add for dm? (perhaps a separate function, plot_qubism_dm)
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    dim_list = ket.dims[0]
+    n = len(dim_list)
+
+    # for odd number of particles - pixels are rectangular
+    if n % 2 == 1:
+        ket = tensor(ket, Qobj([1] * dim_list[-1]))
+        dim_list = ket.dims[0]
+        n += 1
+
+    ketdata = ket.full()
+
+    if how == 'pairs':
+        dim_list_y = dim_list[::2]
+        dim_list_x = dim_list[1::2]
+    elif how == 'pairs_skewed':
+        dim_list_y = dim_list[::2]
+        dim_list_x = dim_list[1::2]
+        if dim_list_x != dim_list_y:
+            raise Exception("For 'pairs_skewed' pairs " +
+                            "of dimensions need to be the same.")
+    elif how == 'before_after':
+        dim_list_y = list(reversed(dim_list[:(n // 2)]))
+        dim_list_x = dim_list[(n // 2):]
+    else:
+        raise Exception("No such 'how'.")
+
+    size_x = np.prod(dim_list_x)
+    size_y = np.prod(dim_list_y)
+
+    qub = np.zeros([size_x, size_y], dtype=complex)
+    for i in range(ketdata.size):
+        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
+    qub = qub.transpose()
+
+    quadrants_x = np.prod(dim_list_x[:grid_iteration])
+    quadrants_y = np.prod(dim_list_y[:grid_iteration])
+
+    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
+    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+
+    ax.set_xticks(ticks_x)
+    ax.set_xticklabels([""] * (quadrants_x - 1))
+    ax.set_yticks(ticks_y)
+    ax.set_yticklabels([""] * (quadrants_y - 1))
+    theme2color_of_lines = {'light': '#000000',
+                            'dark': '#FFFFFF'}
+    ax.grid(True, color=theme2color_of_lines[theme])
+    ax.imshow(complex_array_to_rgb(qub, theme=theme),
+              interpolation="none",
+              extent=(0, size_x, 0, size_y))
+
+    if legend_iteration == 'all':
+        label_n = n // 2
+    elif legend_iteration == 'grid_iteration':
+        label_n = grid_iteration
+    else:
+        try:
+            label_n = int(legend_iteration)
+        except:
+            raise Exception("No such option for legend_iteration keyword " +
+                            "argument. Use 'all', 'grid_iteration' or an " +
+                            "integer.")
+
+    if label_n:
+
+        if how == 'before_after':
+            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
+                + dim_list_x[:label_n]
+        else:
+            dim_list_small = []
+            for j in range(label_n):
+                dim_list_small.append(dim_list_y[j])
+                dim_list_small.append(dim_list_x[j])
+
+        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
+        shift_x = 0.5 * scale_x
+        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
+        shift_y = 0.5 * scale_y
+
+        bbox = ax.get_window_extent().transformed(
+            fig.dpi_scale_trans.inverted())
+        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
+        opts = {'fontsize': fontsize,
+                'color': theme2color_of_lines[theme],
+                'horizontalalignment': 'center',
+                'verticalalignment': 'center'}
+        for i in range(np.prod(dim_list_small)):
+            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
+            seq = _index_to_sequence(i, dim_list=dim_list_small)
+            ax.text(scale_x * x + shift_x,
+                    size_y - (scale_y * y + shift_y),
+                    _sequence_to_latex(seq),
+                    **opts)
+    return fig, ax
+
+
+def plot_schmidt(ket, splitting=None,
+                 labels_iteration=(3, 2),
+                 theme='light',
+                 fig=None, ax=None, figsize=(6, 6)):
+    """
+    Plotting scheme related to Schmidt decomposition.
+    Converts a state into a matrix (A_ij -> A_i^j),
+    where rows are first particles and columns - last.
+
+    See also: plot_qubism with how='before_after' for a similar plot.
+
+    Parameters
+    ----------
+    ket : Qobj
+        Pure state for plotting.
+
+    splitting : int
+        Plot for a number of first particles versus the rest.
+        If not given, it is (number of particles + 1) // 2.
+
+    theme : 'light' (default) or 'dark'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    labels_iteration : int or pair of ints (default (3,2))
+        Number of particles to be shown as tick labels,
+        for first (vertical) and last (horizontal) particles, respectively.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+    if not isket(ket):
+        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
+
+    if not fig and not ax:
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    dim_list = ket.dims[0]
+
+    if splitting is None:
+        splitting = (len(dim_list) + 1) // 2
+
+    if isinstance(labels_iteration, int):
+        labels_iteration = labels_iteration, labels_iteration
+
+    ketdata = ket.full()
+
+    dim_list_y = dim_list[:splitting]
+    dim_list_x = dim_list[splitting:]
+
+    size_x = np.prod(dim_list_x)
+    size_y = np.prod(dim_list_y)
+
+    ketdata = ketdata.reshape((size_y, size_x))
+
+    dim_list_small_x = dim_list_x[:labels_iteration[1]]
+    dim_list_small_y = dim_list_y[:labels_iteration[0]]
+
+    quadrants_x = np.prod(dim_list_small_x)
+    quadrants_y = np.prod(dim_list_small_y)
+
+    ticks_x = [size_x / quadrants_x * (i + 0.5)
+               for i in range(quadrants_x)]
+    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
+               for i in range(quadrants_y)]
+
+    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
+                                                      dim_list=dim_list_x))
+                for i in range(quadrants_x)]
+    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
+                                                      dim_list=dim_list_y))
+                for i in range(quadrants_y)]
+
+    ax.set_xticks(ticks_x)
+    ax.set_xticklabels(labels_x)
+    ax.set_yticks(ticks_y)
+    ax.set_yticklabels(labels_y)
+    ax.set_xlabel("last particles")
+    ax.set_ylabel("first particles")
+
+    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
+              interpolation="none",
+              extent=(0, size_x, 0, size_y))
+
+    return fig, ax
diff --git a/qutip/wigner.py b/qutip/wigner.py
index cc0a130fbd..48abd66385 100644
--- a/qutip/wigner.py
+++ b/qutip/wigner.py
@@ -1,1003 +1,1003 @@
-__all__ = [
-    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
-    'wigner_transform',
-]
-
-import numpy as np
-import warnings
-from numpy import (
-    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
-)
-import scipy.sparse as sp
-import scipy.fftpack as ft
-import scipy.linalg as la
-import scipy.special
-from scipy.special import genlaguerre, binom, sph_harm, factorial
-
-import qutip
-from qutip import Qobj, ket2dm, jmat
-from .solver.parallel import parallel_map
-from .utilities import clebsch
-from .core import data as _data
-from .core.data.eigen import eigh
-
-
-def wigner_transform(psi, j, fullparity, steps, slicearray):
-    """takes the density matrix or state vector of any finite state and
-    generates the Wigner function for that state on a sphere, generating a spin
-    Wigner function useful for displaying the quasi-probability for a qubit or
-    any qudit. For the standard, continuous-variable Wigner function for
-    position and momentum variables, wigner() should be used.
-
-    Parameters
-    ----------
-        psi : qobj
-              a state vector or density matrix.
-        j : int
-            the total angular momentum of the quantum state.
-        fullparity : bool
-                     should the parity of the full SU space be used?
-        steps : int
-                number of points at which the Wigner transform is calculated.
-        slicearray : list of str
-                     the angle slice to be used for each particle in case of a
-                     multi-particle quantum state. 'l' yields an equal angle
-                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
-
-    Returns
-    ----------
-        wigner : list of float
-                 the wigner transformation at `steps` different theta and phi.
-
-    Raises
-    ------
-    ComplexWarning
-        This can be ignored as it is caused due to rounding errors.
-
-    Notes
-    ------
-    See example notebook wigner_visualisation.
-
-    References
-    ------
-    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
-        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
-    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
-        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
-    """
-    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
-        raise TypeError('Input state is not a valid operator.')
-
-    if psi.isket or psi.isbra:
-        rho = psi.proj()
-    else:
-        rho = psi
-
-    sun = 2   # The order of the SU group
-
-    # calculate total number of particles in quantum state:
-    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
-
-    theta = np.zeros((N, steps))
-    phi = np.zeros((N, steps))
-
-    for i in range(N):
-        theta[i, :] = np.linspace(0, np.pi, steps)
-        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
-
-    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
-
-    wigner = np.zeros((steps, steps))
-    if fullparity:
-        pari = _parity(sun**N, j)
-    else:
-        pari = _parity(sun, j)
-    for t in range(steps):
-        for p in range(steps):
-            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
-            kernel = _data.dense.fast_from_numpy(kernel)
-            wigner[t, p] = _data.expect(rho.data, kernel).real
-    return wigner
-
-
-def _parity(N, j):
-    """Private function to calculate the parity of the quantum system.
-    """
-    if j == 0.5:
-        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
-        return pi / N
-    elif j > 0.5:
-        mult = np.int32(2 * j + 1)
-        matrix = np.zeros((mult, mult))
-        foo = np.ones(mult)
-        for n in np.arange(-j, j + 1, 1):
-            for l in np.arange(0, mult, 1):
-                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
-            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
-        return matrix / mult
-
-
-def _lambda_f(N):
-    """Private function needed for the calculation of the parity.
-    """
-    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
-    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
-    return matrix
-
-
-def _kernelsu2(theta, phi, N, j, parity, fullparity):
-    """Private function that calculates the kernel for the SU2 unitary group.
-    """
-    U = np.ones(1)
-    # calculate the total rotation matrix (tensor product for each particle):
-    for i in range(0, N):
-        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
-    if not fullparity:
-        op_parity = parity   # The parity for a one particle system
-        for i in range(1, N):
-            parity = np.kron(parity, op_parity)
-    matrix = U @ parity @ U.conj().T
-    return matrix
-
-
-def _rotation_matrix(theta, phi, j):
-    """Private function to calculate the rotation operator for the SU2 kernel.
-    """
-    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
-           la.expm(1j * theta * jmat(j, 'y').full())
-
-
-def _angle_slice(slicearray, theta, phi):
-    """Private function to modify theta and phi for angle slicing.
-    """
-    xind = np.where(slicearray == 'x')
-    theta[xind, :] = np.pi - theta[xind, :]
-    phi[xind, :] = -phi[xind, :]
-    yind = np.where(slicearray == 'y')
-    theta[yind, :] = np.pi - theta[yind, :]
-    phi[yind, :] = np.pi - phi[yind, :]
-    zind = np.where(slicearray == 'z')
-    phi[zind, :] = phi[zind, :] + np.pi
-    return theta, phi
-
-
-def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
-           sparse=False, parfor=False):
-    """Wigner function for a state vector or density matrix at points
-    `xvec + i * yvec`.
-
-    Parameters
-    ----------
-
-    state : qobj
-        A state vector or density matrix.
-
-    xvec : array_like
-        x-coordinates at which to calculate the Wigner function.
-
-    yvec : array_like
-        y-coordinates at which to calculate the Wigner function.  Does not
-        apply to the 'fft' method.
-
-    g : float
-        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
-        The value of `g` is related to the value of `hbar` in the commutation
-        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
-        value `hbar=1`.
-
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
-        and 'iterative' use an iterative method to evaluate the Wigner functions for density
-        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
-        in scipy for the same task. The 'fft' method evaluates the Fourier
-        transform of the density matrix. The 'iterative' method is default, and
-        in general recommended, but the 'laguerre' method is more efficient for
-        very sparse density matrices (e.g., superpositions of Fock states in a
-        large Hilbert space). The 'clenshaw' method is the preferred method for
-        dealing with density matrices that have a large number of excitations
-        (>~50). 'clenshaw' is a fast and numerically stable method.
-
-    sparse : bool {False, True}
-        Tells the default solver whether or not to keep the input density
-        matrix in sparse format.  As the dimensions of the density matrix
-        grow, setthing this flag can result in increased performance.
-
-    parfor : bool {False, True}
-        Flag for calculating the Laguerre polynomial based Wigner function
-        method='laguerre' in parallel using the parfor function.
-
-
-    Returns
-    -------
-
-    W : array
-        Values representing the Wigner function calculated over the specified
-        range [xvec,yvec].
-
-    yvex : array
-        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
-        transform.
-
-    Notes
-    -----
-    The 'fft' method accepts only an xvec input for the x-coordinate.
-    The y-coordinates are calculated internally.
-
-    References
-    ----------
-
-    Ulf Leonhardt,
-    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
-
-    """
-
-    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
-        raise TypeError('Input state is not a valid operator.')
-
-    if method == 'fft':
-        return _wigner_fourier(psi, xvec, g)
-
-    if psi.isket or psi.isbra:
-        rho = psi.proj()
-    else:
-        rho = psi
-
-    if method == 'iterative':
-        return _wigner_iterative(rho, xvec, yvec, g)
-
-    elif method == 'laguerre':
-        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
-
-    elif method == 'clenshaw':
-        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
-
-    else:
-        raise TypeError(
-            "method must be either 'iterative', 'laguerre', or 'fft'.")
-
-
-def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
-    r"""
-    Using an iterative method to evaluate the wigner functions for the Fock
-    state :math:`|m><n|`.
-
-    The Wigner function is calculated as
-    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
-    function for the density matrix :math:`|m><n|`.
-
-    In this implementation, for each row m, Wlist contains the Wigner functions
-    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
-    calculated, the corresponding contribution is added to the total Wigner
-    function, weighted by the corresponding element in the density matrix
-    :math:`rho_{mn}`.
-    """
-
-    M = np.prod(rho.shape[0])
-    X, Y = meshgrid(xvec, yvec)
-    A = 0.5 * g * (X + 1.0j * Y)
-
-    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
-    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
-
-    W = real(rho[0, 0]) * real(Wlist[0])
-    for n in range(1, M):
-        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
-        W += 2 * real(rho[0, n] * Wlist[n])
-
-    for m in range(1, M):
-        temp = copy(Wlist[m])
-        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
-
-        # Wlist[m] = Wigner function for |m><m|
-        W += real(rho[m, m] * Wlist[m])
-
-        for n in range(m + 1, M):
-            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
-            temp = copy(Wlist[n])
-            Wlist[n] = temp2
-
-            # Wlist[n] = Wigner function for |m><n|
-            W += 2 * real(rho[m, n] * Wlist[n])
-
-    return 0.5 * W * g ** 2
-
-
-def _wigner_laguerre(rho, xvec, yvec, g, parallel):
-    r"""
-    Using Laguerre polynomials from scipy to evaluate the Wigner function for
-    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
-    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
-    """
-
-    M = np.prod(rho.shape[0])
-    X, Y = meshgrid(xvec, yvec)
-    A = 0.5 * g * (X + 1.0j * Y)
-    W = zeros(np.shape(A))
-
-    # compute wigner functions for density matrices |m><n| and
-    # weight by all the elements in the density matrix
-    B = 4 * abs(A) ** 2
-    if sp.isspmatrix_csr(rho.data):
-        # for compress sparse row matrices
-        if parallel:
-            iterator = (
-                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
-            W1_out = parallel_map(_par_wig_eval, iterator)
-            W += sum(W1_out)
-        else:
-            for m in range(len(rho.data.indptr) - 1):
-                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
-                    n = rho.data.indices[jj]
-
-                    if m == n:
-                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-
-                    elif n > m:
-                        W += 2.0 * real(rho[m, n] * (-1) ** m *
-                                        (2 * A) ** (n - m) *
-                                        sqrt(factorial(m) / factorial(n)) *
-                                        genlaguerre(m, n - m)(B))
-    else:
-        # for dense density matrices
-        B = 4 * abs(A) ** 2
-        for m in range(M):
-            if abs(rho[m, m]) > 0.0:
-                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-            for n in range(m + 1, M):
-                if abs(rho[m, n]) > 0.0:
-                    W += 2.0 * real(rho[m, n] * (-1) ** m *
-                                    (2 * A) ** (n - m) *
-                                    sqrt(factorial(m) / factorial(n)) *
-                                    genlaguerre(m, n - m)(B))
-
-    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
-
-
-def _par_wig_eval(args):
-    """
-    Private function for calculating terms of Laguerre Wigner function
-    using parfor.
-    """
-    m, rho, A, B = args
-    W1 = zeros(np.shape(A))
-    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
-        n = rho.data.indices[jj]
-
-        if m == n:
-            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
-
-        elif n > m:
-            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
-                             (2 * A) ** (n - m) *
-                             sqrt(factorial(m) / factorial(n)) *
-                             genlaguerre(m, n - m)(B))
-    return W1
-
-
-def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
-    """
-    Evaluate the Wigner function via the Fourier transform.
-    """
-    if psi.type == 'bra':
-        psi = psi.dag()
-    if psi.type == 'ket':
-        return _psi_wigner_fft(psi.full(), xvec, g)
-    elif psi.type == 'oper':
-        eig_vals, eig_vecs = eigh(psi.full())
-        W = 0
-        for ii in range(psi.shape[0]):
-            W1, yvec = _psi_wigner_fft(
-                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
-            W += eig_vals[ii] * W1
-        return W, yvec
-
-
-def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
-    """
-    FFT method for a single state vector.  Called multiple times when the
-    input is a density matrix.
-    """
-    n = len(psi)
-    A = _osc_eigen(n, xvec * g / np.sqrt(2))
-    xpsi = np.dot(psi.T, A)
-    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
-    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
-
-
-def _wigner_fft(psi, xvec):
-    """
-    Evaluates the Fourier transformation of a given state vector.
-    Returns the corresponding density matrix and range
-    """
-    n = 2*len(psi.T)
-    r1 = np.concatenate((np.array([[0]]),
-                        np.fliplr(psi.conj()),
-                        np.zeros((1, n//2 - 1))), axis=1)
-    r2 = np.concatenate((np.array([[0]]), psi,
-                        np.zeros((1, n//2 - 1))), axis=1)
-    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
-        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
-    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
-    w = ft.fft(w)
-    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
-    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
-    w = w / (p[1] - p[0]) / n
-    return w, p
-
-
-def _osc_eigen(N, pnts):
-    """
-    Vector of and N-dim oscillator eigenfunctions evaluated
-    at the points in pnts.
-    """
-    pnts = np.asarray(pnts)
-    lpnts = len(pnts)
-    A = np.zeros((N, lpnts))
-    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
-    if N == 1:
-        return A
-    else:
-        A[1, :] = np.sqrt(2) * pnts * A[0, :]
-        for k in range(2, N):
-            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
-                np.sqrt((k - 1.0) / k) * A[k - 2, :]
-        return A
-
-
-def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
-    r"""
-    Using Clenshaw summation - numerically stable and efficient
-    iterative algorithm to evaluate polynomial series.
-
-    The Wigner function is calculated as
-    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
-    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
-    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
-    """
-
-    M = np.prod(rho.shape[0])
-    X,Y = np.meshgrid(xvec, yvec)
-    #A = 0.5 * g * (X + 1.0j * Y)
-    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
-
-    B = np.abs(A2)
-    B *= B
-    w0 = (2*rho[0, -1])*np.ones_like(A2)
-    L = M-1
-    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
-    #using Horner's method
-    if not sparse:
-        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
-        while L > 0:
-            L -= 1
-            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
-            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
-    else:
-        # TODO: fix dispatch.
-        _rho = _data.to(_data.CSR, rho.data).as_scipy()
-        while L > 0:
-            L -= 1
-            diag = _rho.diagonal(L)
-            if L != 0:
-                diag *= 2
-            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
-            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
-
-    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
-
-
-def _wig_laguerre_val(L, x, c):
-    r"""
-    this is evaluation of polynomial series inspired by hermval from numpy.
-    Returns polynomial series
-
-    .. math:
-        \sum_n b_n LL_n^L,
-
-    where
-
-    .. math:
-        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
-
-    The evaluation uses Clenshaw recursion.
-    """
-
-    if len(c) == 1:
-        y0 = c[0]
-        y1 = 0
-    elif len(c) == 2:
-        y0 = c[0]
-        y1 = c[1]
-    else:
-        k = len(c)
-        y0 = c[-2]
-        y1 = c[-1]
-        for i in range(3, len(c) + 1):
-            k -= 1
-            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
-            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
-
-    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
-
-
-# -----------------------------------------------------------------------------
-# Q FUNCTION
-#
-def _qfunc_check_state(state: Qobj):
-    if not isinstance(state, Qobj):
-        raise TypeError(f"state must be Qobj, but is {state}")
-    # This is only approximate, but it's enough for our purposes; doing more
-    # than this would take computational effort we don't _need_ to do.
-    isdm = (
-        state.isoper
-        and state.dims[0] == state.dims[1]
-        and state.isherm
-        and abs(state.tr() - 1) < qutip.settings.core['atol']
-    )
-    if not (state.isket or isdm):
-        raise ValueError(
-            f"state must be a ket or density matrix, but is {state}"
-        )
-    if len(state.dims[0]) != 1:
-        raise ValueError(
-            "state must not have tensor structure, but has dimensions:"
-            f" {state.dims}"
-        )
-    return state
-
-
-def _qfunc_check_coordinates(xvec, yvec):
-    if np.isscalar(xvec) or xvec is None:
-        raise TypeError("xvec must be array-like, but is " + repr(xvec))
-    if np.isscalar(yvec) or yvec is None:
-        raise TypeError("yvec must be array-like, but is " + repr(yvec))
-    xvec = np.asarray(xvec, dtype=np.float64)
-    yvec = np.asarray(yvec, dtype=np.float64)
-    if xvec.ndim != 1 or yvec.ndim != 1:
-        raise ValueError(
-            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
-        )
-    return xvec, yvec
-
-
-class _QFuncCoherentGrid:
-    """
-    Internal function to compute coherent state operators corresponding to a
-    grid of complex values in phase space.  For efficiency reasons, this class
-    produces the adjoint of the coherent states, to save allocations when
-    calculating inner products later.
-
-    Examples
-    --------
-    Initialise the grid calculator.
-
-    >>> xvec = yvec = np.linspace(-1, 1, 21)
-    >>> g = np.sqrt(0.5)
-    >>> max_ns = 10
-    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
-
-    The naive construction of the grid is
-
-    >>> xs, ys = np.meshgrid(xvec, yvec)
-    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
-    >>> naive = np.array([
-    ...     [
-    ...         qutip.coherent(max_ns, alpha, method='analytic')
-    ...             .dag().full().ravel()
-    ...         for alpha in x_alphas
-    ...     ]
-    ...     for y_alphas in all_alphas
-    ... ])
-
-    The naive approach is typically several of orders of magnitude slower than
-    this class, which uses much simpler vectorised operations.  The outputs are
-    within close tolerance, however:
-
-    >>> np.allclose(naive, grid(max_ns))
-    True
-    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
-    True
-    """
-    def __init__(self, xvec, yvec, g: float):
-        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
-        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
-        self.grid = np.empty(x.shape, dtype=np.complex128)
-        self.grid.real = x
-        # We produce the adjoint of the coherent states to save an operation
-        # later when computing dot products, hence the negative imaginary part.
-        self.grid.imag = -y
-        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
-
-    def _start(self, first: int):
-        """
-        Get the coherent state matrix corresponding to the first needed Fock
-        state.
-        """
-        if first == 0:
-            return self.prefactor.copy()
-        out = np.power(self.grid, first)
-        out *= self.prefactor
-        return out
-
-    def __call__(self, first: int, last: int = None):
-        """
-        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
-        coherent-state vectors for all the Fock states in the range ``first``
-        to ``last``, excluding the end point.  The first two axes are the y-
-        and x-coordinates of phase space (i.e. Cartesian indexing, like
-        ``numpy.meshgrid``), and the last runs over the selected range of
-        Fock-space dimensions.
-        """
-        ns = np.arange(first, last).reshape(1, 1, -1)
-        # Technically we could avoid hitting the limits of floating-point
-        # exponents for longer by doing all this in logarithmic space (using
-        # scipy.special.gammaln), but that ends up involving more
-        # floating-point operations overall, and needs special care around the
-        # point alpha = 0 to avoid nan appearing, due to how Python handles
-        # mixed-width arithmetic operations.
-        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
-        out[:, :, 0] = self._start(ns.flat[0])
-        for i in range(ns.size - 1):
-            out[:, :, i+1] = out[:, :, i] * self.grid
-        out /= np.sqrt(scipy.special.factorial(ns))
-        return out
-
-
-class QFunc:
-    r"""
-    Class-based method of calculating the Husimi-Q function of many different
-    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
-    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
-    subsequent operations will be several times faster. However, it can require
-    quite a lot of memory. Call the created object as a function to retrieve
-    the Husimi-Q function.
-
-    Parameters
-    ----------
-    xvec, yvec : array_like
-        x- and y-coordinates at which to calculate the Husimi-Q function.
-
-    g : float, default sqrt(2)
-        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
-        related to the value of `hbar` in the commutation relation
-        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
-        corresponds to :math:`\hbar=1`.
-
-    memory : real, default 1024
-        Size in MB that may be used internally as workspace.  This class will
-        raise ``MemoryError`` if subsequently passed a state of sufficiently
-        large dimension that this bound would be exceeded.  In those cases, use
-        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
-        the slower, more memory-efficient algorithm.
-
-    Examples
-    --------
-    Initialise the class for a square set of coordinates, with some states we
-    want to investigate.
-
-    >>> xvec = np.linspace(-2, 2, 101)
-    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
-    >>> qfunc = qutip.QFunc(xvec, xvec)
-
-    Now we can calculate the Husimi-Q function over each of the states more
-    efficiently with:
-
-    >>> husimiq = np.array([qfunc(state) for state in states])
-
-    See Also
-    --------
-    :obj:`.qfunc` :
-        a single function version, which will involve computing several
-        quantities multiple times in order to use less memory.
-    """
-
-    def __init__(
-        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
-    ):
-        self._g = g
-        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
-        # 16 bytes per complex, 1024**2 bytes per MB.
-        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
-        self._memory_mb = memory
-        self._max_size = int(self._memory_mb // self._size_mb)
-        self._current_size = 0
-        self._cache = None
-
-    def _alphas(self, size: int):
-        r"""
-        Retrive the full tensor of (the conjugate of) coherent states over all
-        values of :math:`\alpha`, for states of dimension ``size``.
-        """
-        if self._current_size >= size:
-            return self._cache[:, :, :size]
-        if size > self._max_size:
-            requirement = self._size_mb * size
-            raise MemoryError(
-                f"Refusing to precompute up to {size} basis states."
-                f" This would require {requirement:.2f} MB,"
-                f" but only {self._memory_mb} MB is allowed."
-            )
-        if self._cache is None:
-            self._cache = self._coherent_grid(self._current_size, size)
-        else:
-            self._cache = np.dstack(
-                [self._cache, self._coherent_grid(self._current_size, size)]
-            )
-        self._current_size = size
-        return self._cache
-
-    def _single(self, vector: np.ndarray, alphas: np.ndarray):
-        r"""
-        Get the Q function (without the :math:`\pi` scaling factor) of a single
-        state vector.
-        """
-        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
-
-    def __call__(self, state: Qobj):
-        """
-        Get the Husimi-Q function for the given state vector or density matrix,
-        over the coordinates used to initialise the class.  If called multiple
-        times, the states do not need to have the same dimensions, but none of
-        them can have tensor-product structure.
-        """
-        state = _qfunc_check_state(state)
-        alphas = self._alphas(state.shape[0])
-        if state.isket:
-            return self._single(state.full().ravel(), alphas) / np.pi
-        # We don't use Qobj.eigenstates() to avoid building many unnecessary
-        # CSR versions of dense matrices.
-        values, vectors = eigh(state.full())
-        vectors = vectors.T
-        out = values[0] * self._single(vectors[0], alphas)
-        for value, vector in zip(values[1:], vectors[1:]):
-            out += value * self._single(vector, alphas)
-        return out / np.pi
-
-
-def _qfunc_iterative_single(
-    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
-):
-    r"""
-    Get the Q function (without the :math:`\pi` scaling factor) of a single
-    state vector, using the iterative algorithm which recomputes the powers of
-    the coherent-state matrix.
-    """
-    ns = np.arange(vector.shape[0])
-    out = np.polyval(
-        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
-        alpha_grid.grid,
-    )
-    out *= alpha_grid.prefactor
-    return np.abs(out)**2
-
-
-def qfunc(
-    state: Qobj,
-    xvec,
-    yvec,
-    g: float = sqrt(2),
-    precompute_memory: float = 1024,
-):
-    r"""
-    Husimi-Q function of a given state vector or density matrix at phase-space
-    points ``0.5 * g * (xvec + i*yvec)``.
-
-    Parameters
-    ----------
-    state : :obj:`.Qobj`
-        A state vector or density matrix.  This cannot have tensor-product
-        structure.
-
-    xvec, yvec : array_like
-        x- and y-coordinates at which to calculate the Husimi-Q function.
-
-    g : float, default sqrt(2)
-        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
-        related to the value of :math:`\hbar` in the commutation relation
-        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
-        corresponds to :math:`\hbar=1`.
-
-    precompute_memory : real, default 1024
-        Size in MB that may be used during calculations as working space when
-        dealing with density-matrix inputs.  This is ignored for state-vector
-        inputs.  The bound is not quite exact due to other, order-of-magnitude
-        smaller, intermediaries being necessary, but is a good approximation.
-        If you want to use the same iterative algorithm for density matrices
-        that is used for single kets, set ``precompute_memory=None``.
-
-    Returns
-    -------
-    ndarray
-        Values representing the Husimi-Q function calculated over the specified
-        range ``[xvec, yvec]``.
-
-    See Also
-    --------
-    :obj:`.QFunc` :
-        a class-based version, more efficient if you want to calculate the
-        Husimi-Q function for several states over the same coordinates.
-    """
-    state = _qfunc_check_state(state)
-    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
-    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
-    enough_memory = (
-        precompute_memory is not None
-        and precompute_memory > required_memory
-    )
-    if state.isoper and enough_memory:
-        return QFunc(xvec, yvec, g)(state)
-    if precompute_memory is not None and state.isoper:
-        warnings.warn(
-            "Falling back to iterative algorithm due to lack of memory."
-            f" Needed {required_memory:.2f} MB, but only allowed to use"
-            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
-            " raise limit, or set to `None` to suppress warning."
-        )
-    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
-    if state.isket:
-        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
-        out /= np.pi
-        return out
-    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
-    # versions of dense matrices.
-    values, vectors = eigh(state.full())
-    vectors = vectors.T
-    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
-    for value, vector in zip(values[1:], vectors[1:]):
-        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
-    out /= np.pi
-    return out
-
-
-# -----------------------------------------------------------------------------
-# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
-#
-def spin_q_function(rho, theta, phi):
-    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
-    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
-    j, theta, phi)`` where j is the spin length.
-    The implementation here is more efficient as it doesn't
-    generate all of the SCS at theta and phi (see references).
-
-    The spin Q function is normal when integrated over the surface of the
-    sphere
-
-    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
-              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
-
-    Parameters
-    ----------
-    state : qobj
-        A state vector or density matrix for a spin-j quantum system.
-    theta : array_like
-        Polar (colatitude) angle at which to calculate the Husimi-Q function.
-    phi : array_like
-        Azimuthal angle at which to calculate the Husimi-Q function.
-
-    Returns
-    -------
-    Q, THETA, PHI : 2d-array
-        Values representing the spin Husimi Q function at the values specified
-        by THETA and PHI.
-
-    References
-    ----------
-    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
-    https://doi.org/10.1119/1.4898595
-
-    """
-
-    if rho.isket or rho.isbra:
-        rho = rho.proj()
-
-    J = rho.shape[0]
-    j = (J - 1) / 2
-
-    THETA, PHI = meshgrid(theta, phi)
-
-    Q = np.zeros_like(THETA, dtype=complex)
-    data = rho.full()
-
-    for m1 in arange(-j, j + 1):
-        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
-             sin(THETA / 2) ** (2 * (j - m1)) * \
-             data[int(j - m1), int(j - m1)]
-
-        for m2 in arange(m1 + 1, j + 1):
-            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
-                  cos(THETA / 2) ** (2 * j + m1 + m2) *
-                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
-             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
-              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
-
-    return Q.real, THETA, PHI
-
-
-def _rho_kq(rho, j, k, q):
-    """
-    This calculates the trace of the multipole operator T_kq and the density
-    matrix rho for use in the spin Wigner quasiprobability distribution.
-
-    Parameters
-    ----------
-    rho : qobj
-        A density matrix for a spin-j quantum system.
-    j : float
-        The spin length of the system.
-    k : int
-        Spherical harmonic degree
-    q : int
-        Spherical harmonic order
-
-    Returns
-    -------
-    v : float
-        Overlap of state with multipole operator T_kq
-    """
-
-    v = 0j
-    data = rho.full()
-    for m1 in arange(-j, j+1):
-        for m2 in arange(-j, j+1):
-            v += (
-                    (-1) ** (2 * j - k - m1 - m2)
-                    * np.sqrt((2 * k + 1) / (2 * j + 1))
-                    * clebsch(j, k, j, -m1, q, -m2)
-                    * data[int(j - m1), int(j - m2)]
-            )
-    return v
-
-
-def spin_wigner(rho, theta, phi):
-    r"""Wigner function for a spin-j system.
-
-    The spin W function is normal when integrated over the surface of the
-    sphere
-
-    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
-              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
-
-
-    Parameters
-    ----------
-    state : qobj
-        A state vector or density matrix for a spin-j quantum system.
-    theta : array_like
-        Polar (colatitude) angle at which to calculate the W function.
-    phi : array_like
-        Azimuthal angle at which to calculate the W function.
-
-    Returns
-    -------
-    W, THETA, PHI : 2d-array
-        Values representing the spin Wigner function at the values specified
-        by THETA and PHI.
-
-    References
-    ----------
-    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
-    https://doi.org/10.1103/PhysRevA.24.2889
-
-    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
-    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
-
-    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
-    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
-
-    """
-    if rho.isket or rho.isbra:
-        rho = rho.proj()
-
-    J = rho.shape[0]
-    j = (J - 1) / 2
-
-    THETA, PHI = meshgrid(theta, phi)
-
-    W = np.zeros_like(THETA, dtype=complex)
-
-    for k in range(int(2 * j)+1):
-        for q in arange(-k, k+1):
-            # sph_harm takes azimuthal angle then polar angle as arguments
-            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
-
-    return W.real, THETA, PHI
+__all__ = [
+    'wigner', 'qfunc', 'QFunc', 'spin_q_function', 'spin_wigner',
+    'wigner_transform',
+]
+
+import numpy as np
+import warnings
+from numpy import (
+    zeros, array, arange, exp, real, conj, pi, copy, sqrt, meshgrid, cos, sin,
+)
+import scipy.sparse as sp
+import scipy.fftpack as ft
+import scipy.linalg as la
+import scipy.special
+from scipy.special import genlaguerre, binom, sph_harm, factorial
+
+import qutip
+from qutip import Qobj, ket2dm, jmat
+from .solver.parallel import parallel_map
+from .utilities import clebsch
+from .core import data as _data
+from .core.data.eigen import eigh
+
+
+def wigner_transform(psi, j, fullparity, steps, slicearray):
+    """takes the density matrix or state vector of any finite state and
+    generates the Wigner function for that state on a sphere, generating a spin
+    Wigner function useful for displaying the quasi-probability for a qubit or
+    any qudit. For the standard, continuous-variable Wigner function for
+    position and momentum variables, wigner() should be used.
+
+    Parameters
+    ----------
+        psi : qobj
+              a state vector or density matrix.
+        j : int
+            the total angular momentum of the quantum state.
+        fullparity : bool
+                     should the parity of the full SU space be used?
+        steps : int
+                number of points at which the Wigner transform is calculated.
+        slicearray : list of str
+                     the angle slice to be used for each particle in case of a
+                     multi-particle quantum state. 'l' yields an equal angle
+                     slice. 'x', 'y' and 'z' angle slices can also be chosen.
+
+    Returns
+    ----------
+        wigner : list of float
+                 the wigner transformation at `steps` different theta and phi.
+
+    Raises
+    ------
+    ComplexWarning
+        This can be ignored as it is caused due to rounding errors.
+
+    Notes
+    ------
+    See example notebook wigner_visualisation.
+
+    References
+    ------
+    [1] T. Tilma, M. J. Everitt, J. H. Samson, W. J. Munro,
+        and K. Nemoto, Phys. Rev. Lett. 117, 180401 (2016).
+    [2] R. P. Rundle, P. W. Mills, T. Tilma, J. H. Samson, and
+        M. J. Everitt, Phys. Rev. A 96, 022117 (2017).
+    """
+    if not (psi.type == 'ket' or psi.type == 'operator' or psi.type == 'bra'):
+        raise TypeError('Input state is not a valid operator.')
+
+    if psi.isket or psi.isbra:
+        rho = psi.proj()
+    else:
+        rho = psi
+
+    sun = 2   # The order of the SU group
+
+    # calculate total number of particles in quantum state:
+    N = np.int32(np.log(np.shape(rho)[0]) / np.log(2 * j + 1))
+
+    theta = np.zeros((N, steps))
+    phi = np.zeros((N, steps))
+
+    for i in range(N):
+        theta[i, :] = np.linspace(0, np.pi, steps)
+        phi[i, :] = np.linspace(0, 2 * np.pi, steps)
+
+    theta, phi = _angle_slice(np.array(slicearray, dtype=str), theta, phi)
+
+    wigner = np.zeros((steps, steps))
+    if fullparity:
+        pari = _parity(sun**N, j)
+    else:
+        pari = _parity(sun, j)
+    for t in range(steps):
+        for p in range(steps):
+            kernel = _kernelsu2(theta[:, t], phi[:, p], N, j, pari, fullparity)
+            kernel = _data.dense.fast_from_numpy(kernel)
+            wigner[t, p] = _data.expect(rho.data, kernel).real
+    return wigner
+
+
+def _parity(N, j):
+    """Private function to calculate the parity of the quantum system.
+    """
+    if j == 0.5:
+        pi = np.identity(N) - np.sqrt((N - 1) * N * (N + 1) / 2) * _lambda_f(N)
+        return pi / N
+    elif j > 0.5:
+        mult = np.int32(2 * j + 1)
+        matrix = np.zeros((mult, mult))
+        foo = np.ones(mult)
+        for n in np.arange(-j, j + 1, 1):
+            for l in np.arange(0, mult, 1):
+                foo[l] = (2 * l + 1) * clebsch(j, l, j, n, 0, n)
+            matrix[np.int32(n + j), np.int32(n + j)] = np.sum(foo)
+        return matrix / mult
+
+
+def _lambda_f(N):
+    """Private function needed for the calculation of the parity.
+    """
+    matrix = np.sqrt(2 / (N * (N - 1))) * np.identity(N)
+    matrix[-1, -1] = - np.sqrt(2 * (N - 1) / N)
+    return matrix
+
+
+def _kernelsu2(theta, phi, N, j, parity, fullparity):
+    """Private function that calculates the kernel for the SU2 unitary group.
+    """
+    U = np.ones(1)
+    # calculate the total rotation matrix (tensor product for each particle):
+    for i in range(0, N):
+        U = np.kron(U, _rotation_matrix(theta[i], phi[i], j))
+    if not fullparity:
+        op_parity = parity   # The parity for a one particle system
+        for i in range(1, N):
+            parity = np.kron(parity, op_parity)
+    matrix = U @ parity @ U.conj().T
+    return matrix
+
+
+def _rotation_matrix(theta, phi, j):
+    """Private function to calculate the rotation operator for the SU2 kernel.
+    """
+    return la.expm(1j * phi * jmat(j, 'z').full()) @ \
+           la.expm(1j * theta * jmat(j, 'y').full())
+
+
+def _angle_slice(slicearray, theta, phi):
+    """Private function to modify theta and phi for angle slicing.
+    """
+    xind = np.where(slicearray == 'x')
+    theta[xind, :] = np.pi - theta[xind, :]
+    phi[xind, :] = -phi[xind, :]
+    yind = np.where(slicearray == 'y')
+    theta[yind, :] = np.pi - theta[yind, :]
+    phi[yind, :] = np.pi - phi[yind, :]
+    zind = np.where(slicearray == 'z')
+    phi[zind, :] = phi[zind, :] + np.pi
+    return theta, phi
+
+
+def wigner(psi, xvec, yvec, method='clenshaw', g=sqrt(2),
+           sparse=False, parfor=False):
+    """Wigner function for a state vector or density matrix at points
+    `xvec + i * yvec`.
+
+    Parameters
+    ----------
+
+    state : qobj
+        A state vector or density matrix.
+
+    xvec : array_like
+        x-coordinates at which to calculate the Wigner function.
+
+    yvec : array_like
+        y-coordinates at which to calculate the Wigner function.  Does not
+        apply to the 'fft' method.
+
+    g : float
+        Scaling factor for `a = 0.5 * g * (x + iy)`, default `g = sqrt(2)`.
+        The value of `g` is related to the value of `hbar` in the commutation
+        relation `[x, y] = i * hbar` via `hbar=2/g^2` giving the default
+        value `hbar=1`.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+        Select method 'clenshaw' 'iterative', 'laguerre', or 'fft', where 'clenshaw'
+        and 'iterative' use an iterative method to evaluate the Wigner functions for density
+        matrices :math:`|m><n|`, while 'laguerre' uses the Laguerre polynomials
+        in scipy for the same task. The 'fft' method evaluates the Fourier
+        transform of the density matrix. The 'iterative' method is default, and
+        in general recommended, but the 'laguerre' method is more efficient for
+        very sparse density matrices (e.g., superpositions of Fock states in a
+        large Hilbert space). The 'clenshaw' method is the preferred method for
+        dealing with density matrices that have a large number of excitations
+        (>~50). 'clenshaw' is a fast and numerically stable method.
+
+    sparse : bool {False, True}
+        Tells the default solver whether or not to keep the input density
+        matrix in sparse format.  As the dimensions of the density matrix
+        grow, setthing this flag can result in increased performance.
+
+    parfor : bool {False, True}
+        Flag for calculating the Laguerre polynomial based Wigner function
+        method='laguerre' in parallel using the parfor function.
+
+
+    Returns
+    -------
+
+    W : array
+        Values representing the Wigner function calculated over the specified
+        range [xvec,yvec].
+
+    yvex : array
+        FFT ONLY. Returns the y-coordinate values calculated via the Fourier
+        transform.
+
+    Notes
+    -----
+    The 'fft' method accepts only an xvec input for the x-coordinate.
+    The y-coordinates are calculated internally.
+
+    References
+    ----------
+
+    Ulf Leonhardt,
+    Measuring the Quantum State of Light, (Cambridge University Press, 1997)
+
+    """
+
+    if not (psi.type == 'ket' or psi.type == 'oper' or psi.type == 'bra'):
+        raise TypeError('Input state is not a valid operator.')
+
+    if method == 'fft':
+        return _wigner_fourier(psi, xvec, g)
+
+    if psi.isket or psi.isbra:
+        rho = psi.proj()
+    else:
+        rho = psi
+
+    if method == 'iterative':
+        return _wigner_iterative(rho, xvec, yvec, g)
+
+    elif method == 'laguerre':
+        return _wigner_laguerre(rho, xvec, yvec, g, parfor)
+
+    elif method == 'clenshaw':
+        return _wigner_clenshaw(rho, xvec, yvec, g, sparse=sparse)
+
+    else:
+        raise TypeError(
+            "method must be either 'iterative', 'laguerre', or 'fft'.")
+
+
+def _wigner_iterative(rho, xvec, yvec, g=sqrt(2)):
+    r"""
+    Using an iterative method to evaluate the wigner functions for the Fock
+    state :math:`|m><n|`.
+
+    The Wigner function is calculated as
+    :math:`W = \sum_{mn} \rho_{mn} W_{mn}` where :math:`W_{mn}` is the Wigner
+    function for the density matrix :math:`|m><n|`.
+
+    In this implementation, for each row m, Wlist contains the Wigner functions
+    Wlist = [0, ..., W_mm, ..., W_mN]. As soon as one W_mn Wigner function is
+    calculated, the corresponding contribution is added to the total Wigner
+    function, weighted by the corresponding element in the density matrix
+    :math:`rho_{mn}`.
+    """
+
+    M = np.prod(rho.shape[0])
+    X, Y = meshgrid(xvec, yvec)
+    A = 0.5 * g * (X + 1.0j * Y)
+
+    Wlist = array([zeros(np.shape(A), dtype=complex) for k in range(M)])
+    Wlist[0] = exp(-2.0 * abs(A) ** 2) / pi
+
+    W = real(rho[0, 0]) * real(Wlist[0])
+    for n in range(1, M):
+        Wlist[n] = (2.0 * A * Wlist[n - 1]) / sqrt(n)
+        W += 2 * real(rho[0, n] * Wlist[n])
+
+    for m in range(1, M):
+        temp = copy(Wlist[m])
+        Wlist[m] = (2 * conj(A) * temp - sqrt(m) * Wlist[m - 1]) / sqrt(m)
+
+        # Wlist[m] = Wigner function for |m><m|
+        W += real(rho[m, m] * Wlist[m])
+
+        for n in range(m + 1, M):
+            temp2 = (2 * A * Wlist[n - 1] - sqrt(m) * temp) / sqrt(n)
+            temp = copy(Wlist[n])
+            Wlist[n] = temp2
+
+            # Wlist[n] = Wigner function for |m><n|
+            W += 2 * real(rho[m, n] * Wlist[n])
+
+    return 0.5 * W * g ** 2
+
+
+def _wigner_laguerre(rho, xvec, yvec, g, parallel):
+    r"""
+    Using Laguerre polynomials from scipy to evaluate the Wigner function for
+    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
+    function is calculated as :math:`W = \sum_{mn} \rho_{mn} W_{mn}`.
+    """
+
+    M = np.prod(rho.shape[0])
+    X, Y = meshgrid(xvec, yvec)
+    A = 0.5 * g * (X + 1.0j * Y)
+    W = zeros(np.shape(A))
+
+    # compute wigner functions for density matrices |m><n| and
+    # weight by all the elements in the density matrix
+    B = 4 * abs(A) ** 2
+    if sp.isspmatrix_csr(rho.data):
+        # for compress sparse row matrices
+        if parallel:
+            iterator = (
+                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
+            W1_out = parallel_map(_par_wig_eval, iterator)
+            W += sum(W1_out)
+        else:
+            for m in range(len(rho.data.indptr) - 1):
+                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
+                    n = rho.data.indices[jj]
+
+                    if m == n:
+                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+
+                    elif n > m:
+                        W += 2.0 * real(rho[m, n] * (-1) ** m *
+                                        (2 * A) ** (n - m) *
+                                        sqrt(factorial(m) / factorial(n)) *
+                                        genlaguerre(m, n - m)(B))
+    else:
+        # for dense density matrices
+        B = 4 * abs(A) ** 2
+        for m in range(M):
+            if abs(rho[m, m]) > 0.0:
+                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+            for n in range(m + 1, M):
+                if abs(rho[m, n]) > 0.0:
+                    W += 2.0 * real(rho[m, n] * (-1) ** m *
+                                    (2 * A) ** (n - m) *
+                                    sqrt(factorial(m) / factorial(n)) *
+                                    genlaguerre(m, n - m)(B))
+
+    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
+
+
+def _par_wig_eval(args):
+    """
+    Private function for calculating terms of Laguerre Wigner function
+    using parfor.
+    """
+    m, rho, A, B = args
+    W1 = zeros(np.shape(A))
+    for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
+        n = rho.data.indices[jj]
+
+        if m == n:
+            W1 += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
+
+        elif n > m:
+            W1 += 2.0 * real(rho[m, n] * (-1) ** m *
+                             (2 * A) ** (n - m) *
+                             sqrt(factorial(m) / factorial(n)) *
+                             genlaguerre(m, n - m)(B))
+    return W1
+
+
+def _wigner_fourier(psi, xvec, g=np.sqrt(2)):
+    """
+    Evaluate the Wigner function via the Fourier transform.
+    """
+    if psi.type == 'bra':
+        psi = psi.dag()
+    if psi.type == 'ket':
+        return _psi_wigner_fft(psi.full(), xvec, g)
+    elif psi.type == 'oper':
+        eig_vals, eig_vecs = eigh(psi.full())
+        W = 0
+        for ii in range(psi.shape[0]):
+            W1, yvec = _psi_wigner_fft(
+                np.reshape(eig_vecs[:, ii], (psi.shape[0], 1)), xvec, g)
+            W += eig_vals[ii] * W1
+        return W, yvec
+
+
+def _psi_wigner_fft(psi, xvec, g=sqrt(2)):
+    """
+    FFT method for a single state vector.  Called multiple times when the
+    input is a density matrix.
+    """
+    n = len(psi)
+    A = _osc_eigen(n, xvec * g / np.sqrt(2))
+    xpsi = np.dot(psi.T, A)
+    W, yvec = _wigner_fft(xpsi, xvec * g / np.sqrt(2))
+    return (0.5 * g ** 2) * np.real(W.T), yvec * np.sqrt(2) / g
+
+
+def _wigner_fft(psi, xvec):
+    """
+    Evaluates the Fourier transformation of a given state vector.
+    Returns the corresponding density matrix and range
+    """
+    n = 2*len(psi.T)
+    r1 = np.concatenate((np.array([[0]]),
+                        np.fliplr(psi.conj()),
+                        np.zeros((1, n//2 - 1))), axis=1)
+    r2 = np.concatenate((np.array([[0]]), psi,
+                        np.zeros((1, n//2 - 1))), axis=1)
+    w = la.toeplitz(np.zeros((n//2, 1)), r1) * \
+        np.flipud(la.toeplitz(np.zeros((n//2, 1)), r2))
+    w = np.concatenate((w[:, n//2:n], w[:, 0:n//2]), axis=1)
+    w = ft.fft(w)
+    w = np.real(np.concatenate((w[:, 3*n//4:n+1], w[:, 0:n//4]), axis=1))
+    p = np.arange(-n/4, n/4)*np.pi / (n*(xvec[1] - xvec[0]))
+    w = w / (p[1] - p[0]) / n
+    return w, p
+
+
+def _osc_eigen(N, pnts):
+    """
+    Vector of and N-dim oscillator eigenfunctions evaluated
+    at the points in pnts.
+    """
+    pnts = np.asarray(pnts)
+    lpnts = len(pnts)
+    A = np.zeros((N, lpnts))
+    A[0, :] = np.exp(-pnts ** 2 / 2.0) / pi ** 0.25
+    if N == 1:
+        return A
+    else:
+        A[1, :] = np.sqrt(2) * pnts * A[0, :]
+        for k in range(2, N):
+            A[k, :] = np.sqrt(2.0 / k) * pnts * A[k - 1, :] - \
+                np.sqrt((k - 1.0) / k) * A[k - 2, :]
+        return A
+
+
+def _wigner_clenshaw(rho, xvec, yvec, g=sqrt(2), sparse=False):
+    r"""
+    Using Clenshaw summation - numerically stable and efficient
+    iterative algorithm to evaluate polynomial series.
+
+    The Wigner function is calculated as
+    :math:`W = e^(-0.5*x^2)/pi * \sum_{L} c_L (2x)^L / \sqrt(L!)` where
+    :math:`c_L = \sum_n \rho_{n,L+n} LL_n^L` where
+    :math:`LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]`
+    """
+
+    M = np.prod(rho.shape[0])
+    X,Y = np.meshgrid(xvec, yvec)
+    #A = 0.5 * g * (X + 1.0j * Y)
+    A2 = g * (X + 1.0j * Y) #this is A2 = 2*A
+
+    B = np.abs(A2)
+    B *= B
+    w0 = (2*rho[0, -1])*np.ones_like(A2)
+    L = M-1
+    #calculation of \sum_{L} c_L (2x)^L / \sqrt(L!)
+    #using Horner's method
+    if not sparse:
+        rho = rho.full() * (2*np.ones((M,M)) - np.diag(np.ones(M)))
+        while L > 0:
+            L -= 1
+            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
+            w0 = _wig_laguerre_val(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5
+    else:
+        # TODO: fix dispatch.
+        _rho = _data.to(_data.CSR, rho.data).as_scipy()
+        while L > 0:
+            L -= 1
+            diag = _rho.diagonal(L)
+            if L != 0:
+                diag *= 2
+            #here c_L = _wig_laguerre_val(L, B, np.diag(rho, L))
+            w0 = _wig_laguerre_val(L, B, diag) + w0 * A2 * (L+1)**-0.5
+
+    return w0.real * np.exp(-B*0.5) * (g*g*0.5 / pi)
+
+
+def _wig_laguerre_val(L, x, c):
+    r"""
+    this is evaluation of polynomial series inspired by hermval from numpy.
+    Returns polynomial series
+
+    .. math:
+        \sum_n b_n LL_n^L,
+
+    where
+
+    .. math:
+        LL_n^L = (-1)^n \sqrt(L!n!/(L+n)!) LaguerreL[n,L,x]
+
+    The evaluation uses Clenshaw recursion.
+    """
+
+    if len(c) == 1:
+        y0 = c[0]
+        y1 = 0
+    elif len(c) == 2:
+        y0 = c[0]
+        y1 = c[1]
+    else:
+        k = len(c)
+        y0 = c[-2]
+        y1 = c[-1]
+        for i in range(3, len(c) + 1):
+            k -= 1
+            y0,    y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \
+            y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5
+
+    return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5
+
+
+# -----------------------------------------------------------------------------
+# Q FUNCTION
+#
+def _qfunc_check_state(state: Qobj):
+    if not isinstance(state, Qobj):
+        raise TypeError(f"state must be Qobj, but is {state}")
+    # This is only approximate, but it's enough for our purposes; doing more
+    # than this would take computational effort we don't _need_ to do.
+    isdm = (
+        state.isoper
+        and state.dims[0] == state.dims[1]
+        and state.isherm
+        and abs(state.tr() - 1) < qutip.settings.core['atol']
+    )
+    if not (state.isket or isdm):
+        raise ValueError(
+            f"state must be a ket or density matrix, but is {state}"
+        )
+    if len(state.dims[0]) != 1:
+        raise ValueError(
+            "state must not have tensor structure, but has dimensions:"
+            f" {state.dims}"
+        )
+    return state
+
+
+def _qfunc_check_coordinates(xvec, yvec):
+    if np.isscalar(xvec) or xvec is None:
+        raise TypeError("xvec must be array-like, but is " + repr(xvec))
+    if np.isscalar(yvec) or yvec is None:
+        raise TypeError("yvec must be array-like, but is " + repr(yvec))
+    xvec = np.asarray(xvec, dtype=np.float64)
+    yvec = np.asarray(yvec, dtype=np.float64)
+    if xvec.ndim != 1 or yvec.ndim != 1:
+        raise ValueError(
+            f"xvec and yvec must be 1D, but have shapes {xvec.shape} and {yvec.shape}."
+        )
+    return xvec, yvec
+
+
+class _QFuncCoherentGrid:
+    """
+    Internal function to compute coherent state operators corresponding to a
+    grid of complex values in phase space.  For efficiency reasons, this class
+    produces the adjoint of the coherent states, to save allocations when
+    calculating inner products later.
+
+    Examples
+    --------
+    Initialise the grid calculator.
+
+    >>> xvec = yvec = np.linspace(-1, 1, 21)
+    >>> g = np.sqrt(0.5)
+    >>> max_ns = 10
+    >>> grid = _QFuncCoherentGrid(xvec, yvec, g)
+
+    The naive construction of the grid is
+
+    >>> xs, ys = np.meshgrid(xvec, yvec)
+    >>> all_alphas = 0.5 * g * (xs + 1j*ys)
+    >>> naive = np.array([
+    ...     [
+    ...         qutip.coherent(max_ns, alpha, method='analytic')
+    ...             .dag().full().ravel()
+    ...         for alpha in x_alphas
+    ...     ]
+    ...     for y_alphas in all_alphas
+    ... ])
+
+    The naive approach is typically several of orders of magnitude slower than
+    this class, which uses much simpler vectorised operations.  The outputs are
+    within close tolerance, however:
+
+    >>> np.allclose(naive, grid(max_ns))
+    True
+    >>> np.allclose(naive[:, :, 4:7], grid(4, 7))
+    True
+    """
+    def __init__(self, xvec, yvec, g: float):
+        self.xvec, self.yvec = _qfunc_check_coordinates(xvec, yvec)
+        x, y = np.meshgrid(0.5 * g * self.xvec, 0.5 * g * self.yvec)
+        self.grid = np.empty(x.shape, dtype=np.complex128)
+        self.grid.real = x
+        # We produce the adjoint of the coherent states to save an operation
+        # later when computing dot products, hence the negative imaginary part.
+        self.grid.imag = -y
+        self.prefactor = np.exp(-0.5 * (x * x + y * y)).astype(np.complex128)
+
+    def _start(self, first: int):
+        """
+        Get the coherent state matrix corresponding to the first needed Fock
+        state.
+        """
+        if first == 0:
+            return self.prefactor.copy()
+        out = np.power(self.grid, first)
+        out *= self.prefactor
+        return out
+
+    def __call__(self, first: int, last: int = None):
+        """
+        Get a 3D array of shape ``(yvec.size, xvec.size, last - first)`` of the
+        coherent-state vectors for all the Fock states in the range ``first``
+        to ``last``, excluding the end point.  The first two axes are the y-
+        and x-coordinates of phase space (i.e. Cartesian indexing, like
+        ``numpy.meshgrid``), and the last runs over the selected range of
+        Fock-space dimensions.
+        """
+        ns = np.arange(first, last).reshape(1, 1, -1)
+        # Technically we could avoid hitting the limits of floating-point
+        # exponents for longer by doing all this in logarithmic space (using
+        # scipy.special.gammaln), but that ends up involving more
+        # floating-point operations overall, and needs special care around the
+        # point alpha = 0 to avoid nan appearing, due to how Python handles
+        # mixed-width arithmetic operations.
+        out = np.empty(self.grid.shape + (ns.size,), dtype=np.complex128)
+        out[:, :, 0] = self._start(ns.flat[0])
+        for i in range(ns.size - 1):
+            out[:, :, i+1] = out[:, :, i] * self.grid
+        out /= np.sqrt(scipy.special.factorial(ns))
+        return out
+
+
+class QFunc:
+    r"""
+    Class-based method of calculating the Husimi-Q function of many different
+    quantum states at fixed phase-space points ``0.5*g* (xvec + i*yvec)``.
+    This class has slightly higher first-usage costs than :obj:`.qfunc`, but
+    subsequent operations will be several times faster. However, it can require
+    quite a lot of memory. Call the created object as a function to retrieve
+    the Husimi-Q function.
+
+    Parameters
+    ----------
+    xvec, yvec : array_like
+        x- and y-coordinates at which to calculate the Husimi-Q function.
+
+    g : float, default sqrt(2)
+        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
+        related to the value of `hbar` in the commutation relation
+        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
+        corresponds to :math:`\hbar=1`.
+
+    memory : real, default 1024
+        Size in MB that may be used internally as workspace.  This class will
+        raise ``MemoryError`` if subsequently passed a state of sufficiently
+        large dimension that this bound would be exceeded.  In those cases, use
+        :obj:`.qfunc` with ``precompute_memory=None`` instead to force using
+        the slower, more memory-efficient algorithm.
+
+    Examples
+    --------
+    Initialise the class for a square set of coordinates, with some states we
+    want to investigate.
+
+    >>> xvec = np.linspace(-2, 2, 101)
+    >>> states = [qutip.rand_dm(10) for _ in [None]*10]
+    >>> qfunc = qutip.QFunc(xvec, xvec)
+
+    Now we can calculate the Husimi-Q function over each of the states more
+    efficiently with:
+
+    >>> husimiq = np.array([qfunc(state) for state in states])
+
+    See Also
+    --------
+    :obj:`.qfunc` :
+        a single function version, which will involve computing several
+        quantities multiple times in order to use less memory.
+    """
+
+    def __init__(
+        self, xvec, yvec, g: float = np.sqrt(2), memory: float = 1024
+    ):
+        self._g = g
+        self._coherent_grid = _QFuncCoherentGrid(xvec, yvec, g)
+        # 16 bytes per complex, 1024**2 bytes per MB.
+        self._size_mb = self._coherent_grid.grid.size * 16 / (1024 ** 2)
+        self._memory_mb = memory
+        self._max_size = int(self._memory_mb // self._size_mb)
+        self._current_size = 0
+        self._cache = None
+
+    def _alphas(self, size: int):
+        r"""
+        Retrive the full tensor of (the conjugate of) coherent states over all
+        values of :math:`\alpha`, for states of dimension ``size``.
+        """
+        if self._current_size >= size:
+            return self._cache[:, :, :size]
+        if size > self._max_size:
+            requirement = self._size_mb * size
+            raise MemoryError(
+                f"Refusing to precompute up to {size} basis states."
+                f" This would require {requirement:.2f} MB,"
+                f" but only {self._memory_mb} MB is allowed."
+            )
+        if self._cache is None:
+            self._cache = self._coherent_grid(self._current_size, size)
+        else:
+            self._cache = np.dstack(
+                [self._cache, self._coherent_grid(self._current_size, size)]
+            )
+        self._current_size = size
+        return self._cache
+
+    def _single(self, vector: np.ndarray, alphas: np.ndarray):
+        r"""
+        Get the Q function (without the :math:`\pi` scaling factor) of a single
+        state vector.
+        """
+        return np.abs(np.dot(alphas, (self._g * 0.5) * vector)) ** 2
+
+    def __call__(self, state: Qobj):
+        """
+        Get the Husimi-Q function for the given state vector or density matrix,
+        over the coordinates used to initialise the class.  If called multiple
+        times, the states do not need to have the same dimensions, but none of
+        them can have tensor-product structure.
+        """
+        state = _qfunc_check_state(state)
+        alphas = self._alphas(state.shape[0])
+        if state.isket:
+            return self._single(state.full().ravel(), alphas) / np.pi
+        # We don't use Qobj.eigenstates() to avoid building many unnecessary
+        # CSR versions of dense matrices.
+        values, vectors = eigh(state.full())
+        vectors = vectors.T
+        out = values[0] * self._single(vectors[0], alphas)
+        for value, vector in zip(values[1:], vectors[1:]):
+            out += value * self._single(vector, alphas)
+        return out / np.pi
+
+
+def _qfunc_iterative_single(
+    vector: np.ndarray, alpha_grid: _QFuncCoherentGrid, g: float,
+):
+    r"""
+    Get the Q function (without the :math:`\pi` scaling factor) of a single
+    state vector, using the iterative algorithm which recomputes the powers of
+    the coherent-state matrix.
+    """
+    ns = np.arange(vector.shape[0])
+    out = np.polyval(
+        (0.5*g * vector / np.sqrt(scipy.special.factorial(ns)))[::-1],
+        alpha_grid.grid,
+    )
+    out *= alpha_grid.prefactor
+    return np.abs(out)**2
+
+
+def qfunc(
+    state: Qobj,
+    xvec,
+    yvec,
+    g: float = sqrt(2),
+    precompute_memory: float = 1024,
+):
+    r"""
+    Husimi-Q function of a given state vector or density matrix at phase-space
+    points ``0.5 * g * (xvec + i*yvec)``.
+
+    Parameters
+    ----------
+    state : :obj:`.Qobj`
+        A state vector or density matrix.  This cannot have tensor-product
+        structure.
+
+    xvec, yvec : array_like
+        x- and y-coordinates at which to calculate the Husimi-Q function.
+
+    g : float, default sqrt(2)
+        Scaling factor for ``a = 0.5 * g * (x + iy)``.  The value of `g` is
+        related to the value of :math:`\hbar` in the commutation relation
+        :math:`[x,\,y] = i\hbar` via :math:`\hbar=2/g^2`, so the default
+        corresponds to :math:`\hbar=1`.
+
+    precompute_memory : real, default 1024
+        Size in MB that may be used during calculations as working space when
+        dealing with density-matrix inputs.  This is ignored for state-vector
+        inputs.  The bound is not quite exact due to other, order-of-magnitude
+        smaller, intermediaries being necessary, but is a good approximation.
+        If you want to use the same iterative algorithm for density matrices
+        that is used for single kets, set ``precompute_memory=None``.
+
+    Returns
+    -------
+    ndarray
+        Values representing the Husimi-Q function calculated over the specified
+        range ``[xvec, yvec]``.
+
+    See Also
+    --------
+    :obj:`.QFunc` :
+        a class-based version, more efficient if you want to calculate the
+        Husimi-Q function for several states over the same coordinates.
+    """
+    state = _qfunc_check_state(state)
+    xvec, yvec = _qfunc_check_coordinates(xvec, yvec)
+    required_memory = state.shape[0] * xvec.size * yvec.size * 16 / (1024 ** 2)
+    enough_memory = (
+        precompute_memory is not None
+        and precompute_memory > required_memory
+    )
+    if state.isoper and enough_memory:
+        return QFunc(xvec, yvec, g)(state)
+    if precompute_memory is not None and state.isoper:
+        warnings.warn(
+            "Falling back to iterative algorithm due to lack of memory."
+            f" Needed {required_memory:.2f} MB, but only allowed to use"
+            f" {precompute_memory:.2f} MB.  Increase `precompute_memory` to"
+            " raise limit, or set to `None` to suppress warning."
+        )
+    alpha_grid = _QFuncCoherentGrid(xvec, yvec, g)
+    if state.isket:
+        out = _qfunc_iterative_single(state.full().ravel(), alpha_grid, g)
+        out /= np.pi
+        return out
+    # We don't use Qobj.eigenstates() to avoid building many unnecessary CSR
+    # versions of dense matrices.
+    values, vectors = eigh(state.full())
+    vectors = vectors.T
+    out = values[0] * _qfunc_iterative_single(vectors[0], alpha_grid, g)
+    for value, vector in zip(values[1:], vectors[1:]):
+        out += value * _qfunc_iterative_single(vector, alpha_grid, g)
+    out /= np.pi
+    return out
+
+
+# -----------------------------------------------------------------------------
+# PSEUDO DISTRIBUTION FUNCTIONS FOR SPINS
+#
+def spin_q_function(rho, theta, phi):
+    r"""The Husimi Q function for spins is defined as ``Q(theta, phi) =
+    SCS.dag() * rho * SCS`` for the spin coherent state ``SCS = spin_coherent(
+    j, theta, phi)`` where j is the spin length.
+    The implementation here is more efficient as it doesn't
+    generate all of the SCS at theta and phi (see references).
+
+    The spin Q function is normal when integrated over the surface of the
+    sphere
+
+    .. math:: \frac{4 \pi}{2j + 1}\int_\phi \int_\theta
+              Q(\theta, \phi) \sin(\theta) d\theta d\phi = 1
+
+    Parameters
+    ----------
+    state : qobj
+        A state vector or density matrix for a spin-j quantum system.
+    theta : array_like
+        Polar (colatitude) angle at which to calculate the Husimi-Q function.
+    phi : array_like
+        Azimuthal angle at which to calculate the Husimi-Q function.
+
+    Returns
+    -------
+    Q, THETA, PHI : 2d-array
+        Values representing the spin Husimi Q function at the values specified
+        by THETA and PHI.
+
+    References
+    ----------
+    [1] Lee Loh, Y., & Kim, M. (2015). American J. of Phys., 83(1), 30–35.
+    https://doi.org/10.1119/1.4898595
+
+    """
+
+    if rho.isket or rho.isbra:
+        rho = rho.proj()
+
+    J = rho.shape[0]
+    j = (J - 1) / 2
+
+    THETA, PHI = meshgrid(theta, phi)
+
+    Q = np.zeros_like(THETA, dtype=complex)
+    data = rho.full()
+
+    for m1 in arange(-j, j + 1):
+        Q += binom(2 * j, j + m1) * cos(THETA / 2) ** (2 * (j + m1)) * \
+             sin(THETA / 2) ** (2 * (j - m1)) * \
+             data[int(j - m1), int(j - m1)]
+
+        for m2 in arange(m1 + 1, j + 1):
+            Q += (sqrt(binom(2 * j, j + m1)) * sqrt(binom(2 * j, j + m2)) *
+                  cos(THETA / 2) ** (2 * j + m1 + m2) *
+                  sin(THETA / 2) ** (2 * j - m1 - m2)) * \
+             (exp(1j * (m1 - m2) * PHI) * data[int(j - m1), int(j - m2)] +
+              exp(1j * (m2 - m1) * PHI) * data[int(j - m2), int(j - m1)])
+
+    return Q.real, THETA, PHI
+
+
+def _rho_kq(rho, j, k, q):
+    """
+    This calculates the trace of the multipole operator T_kq and the density
+    matrix rho for use in the spin Wigner quasiprobability distribution.
+
+    Parameters
+    ----------
+    rho : qobj
+        A density matrix for a spin-j quantum system.
+    j : float
+        The spin length of the system.
+    k : int
+        Spherical harmonic degree
+    q : int
+        Spherical harmonic order
+
+    Returns
+    -------
+    v : float
+        Overlap of state with multipole operator T_kq
+    """
+
+    v = 0j
+    data = rho.full()
+    for m1 in arange(-j, j+1):
+        for m2 in arange(-j, j+1):
+            v += (
+                    (-1) ** (2 * j - k - m1 - m2)
+                    * np.sqrt((2 * k + 1) / (2 * j + 1))
+                    * clebsch(j, k, j, -m1, q, -m2)
+                    * data[int(j - m1), int(j - m2)]
+            )
+    return v
+
+
+def spin_wigner(rho, theta, phi):
+    r"""Wigner function for a spin-j system.
+
+    The spin W function is normal when integrated over the surface of the
+    sphere
+
+    .. math:: \sqrt{\frac{4 \pi}{2j + 1}}\int_\phi \int_\theta
+              W(\theta,\phi) \sin(\theta) d\theta d\phi = 1
+
+
+    Parameters
+    ----------
+    state : qobj
+        A state vector or density matrix for a spin-j quantum system.
+    theta : array_like
+        Polar (colatitude) angle at which to calculate the W function.
+    phi : array_like
+        Azimuthal angle at which to calculate the W function.
+
+    Returns
+    -------
+    W, THETA, PHI : 2d-array
+        Values representing the spin Wigner function at the values specified
+        by THETA and PHI.
+
+    References
+    ----------
+    [1] Agarwal, G. S. (1981). Phys. Rev. A, 24(6), 2889–2896.
+    https://doi.org/10.1103/PhysRevA.24.2889
+
+    [2] Dowling, J. P., Agarwal, G. S., & Schleich, W. P. (1994).
+    Phys. Rev. A, 49(5), 4101–4109. https://doi.org/10.1103/PhysRevA.49.4101
+
+    [3] Conversion between Wigner 3-j symbol and Clebsch-Gordan coefficients
+    taken from Wikipedia (https://en.wikipedia.org/wiki/3-j_symbol)
+
+    """
+    if rho.isket or rho.isbra:
+        rho = rho.proj()
+
+    J = rho.shape[0]
+    j = (J - 1) / 2
+
+    THETA, PHI = meshgrid(theta, phi)
+
+    W = np.zeros_like(THETA, dtype=complex)
+
+    for k in range(int(2 * j)+1):
+        for q in arange(-k, k+1):
+            # sph_harm takes azimuthal angle then polar angle as arguments
+            W += _rho_kq(rho, j, k, q) * sph_harm(q, k, PHI, THETA)
+
+    return W.real, THETA, PHI
diff --git a/requirements.txt b/requirements.txt
index ce27f29833..41d2c09a1b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
-cython>=0.29.20
-numpy>=1.16.6
-scipy>=1.5
-packaging
+cython>=0.29.20
+numpy>=1.16.6
+scipy>=1.5
+packaging
diff --git a/setup.cfg b/setup.cfg
index d5d6815f21..1eb1f11cd2 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,70 +1,70 @@
-[metadata]
-name = qutip
-url = https://qutip.org
-description = QuTiP: The Quantum Toolbox in Python
-long_description = file: README.md
-long_description_content_type = text/markdown; variant=GFM
-keywords = quantum, physics, dynamics
-license = BSD 3-Clause License
-license_files = LICENSE.txt
-project_urls =
-    Bug Tracker = https://github.com/qutip/qutip/issues
-    Documentation = https://qutip.org/docs/latest/
-    Source Code = https://github.com/qutip/qutip
-classifiers =
-    Development Status :: 2 - Pre-Alpha
-    Intended Audience :: Science/Research
-    License :: OSI Approved :: BSD License
-    Programming Language :: Python
-    Programming Language :: Python :: 3
-    Topic :: Scientific/Engineering
-    Operating System :: MacOS
-    Operating System :: POSIX
-    Operating System :: Unix
-    Operating System :: Microsoft :: Windows
-author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
-author_email = qutip-admin@googlegroups.com
-platforms = Linux, Mac OSX, Unix, Windows
-
-[options]
-packages = find:
-include_package_data = True
-zip_safe = False
-install_requires =
-    numpy>=1.16.6
-    scipy>=1.0
-    packaging
-setup_requires =
-    numpy>=1.13.3
-    scipy>=1.0
-    cython>=0.29.20
-    packaging
-
-[options.packages.find]
-include = qutip*
-
-[options.extras_require]
-graphics = matplotlib>=1.2.1
-runtime_compilation =
-    cython>=0.29.20
-    filelock
-semidefinite =
-    cvxpy>=1.0
-    cvxopt
-tests =
-    pytest>=5.2
-    pytest-rerunfailures
-ipython =
-    ipython
-extras =
-    loky
-    tqdm
-; This uses ConfigParser's string interpolation to include all the above
-; dependencies into one single target, convenient for testing full builds.
-full =
-    %(graphics)s
-    %(runtime_compilation)s
-    %(semidefinite)s
-    %(tests)s
-    %(ipython)s
-    %(extras)s
+[metadata]
+name = qutip
+url = https://qutip.org
+description = QuTiP: The Quantum Toolbox in Python
+long_description = file: README.md
+long_description_content_type = text/markdown; variant=GFM
+keywords = quantum, physics, dynamics
+license = BSD 3-Clause License
+license_files = LICENSE.txt
+project_urls =
+    Bug Tracker = https://github.com/qutip/qutip/issues
+    Documentation = https://qutip.org/docs/latest/
+    Source Code = https://github.com/qutip/qutip
+classifiers =
+    Development Status :: 2 - Pre-Alpha
+    Intended Audience :: Science/Research
+    License :: OSI Approved :: BSD License
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Topic :: Scientific/Engineering
+    Operating System :: MacOS
+    Operating System :: POSIX
+    Operating System :: Unix
+    Operating System :: Microsoft :: Windows
+author = Alexander Pitchford, Paul D. Nation, Robert J. Johansson, Chris Granade, Arne Grimsmo, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguere, Boxi Li, Jake Lishman, Simon Cross
+author_email = qutip-admin@googlegroups.com
+platforms = Linux, Mac OSX, Unix, Windows
+
+[options]
+packages = find:
+include_package_data = True
+zip_safe = False
+install_requires =
+    numpy>=1.16.6
+    scipy>=1.0
+    packaging
+setup_requires =
+    numpy>=1.13.3
+    scipy>=1.0
+    cython>=0.29.20
+    packaging
+
+[options.packages.find]
+include = qutip*
+
+[options.extras_require]
+graphics = matplotlib>=1.2.1
+runtime_compilation =
+    cython>=0.29.20
+    filelock
+semidefinite =
+    cvxpy>=1.0
+    cvxopt
+tests =
+    pytest>=5.2
+    pytest-rerunfailures
+ipython =
+    ipython
+extras =
+    loky
+    tqdm
+; This uses ConfigParser's string interpolation to include all the above
+; dependencies into one single target, convenient for testing full builds.
+full =
+    %(graphics)s
+    %(runtime_compilation)s
+    %(semidefinite)s
+    %(tests)s
+    %(ipython)s
+    %(extras)s
diff --git a/setup.py b/setup.py
index ddde76588e..0bf5b8def4 100755
--- a/setup.py
+++ b/setup.py
@@ -1,312 +1,312 @@
-#!/usr/bin/env python
-
-import collections
-import os
-import pathlib
-import subprocess
-import sys
-import sysconfig
-import warnings
-
-# Required third-party imports, must be specified in pyproject.toml.
-import packaging.version
-from setuptools import setup, Extension
-import distutils.sysconfig
-import numpy as np
-from Cython.Build import cythonize
-from Cython.Distutils import build_ext
-
-
-def process_options():
-    """
-    Determine all runtime options, returning a dictionary of the results.  The
-    keys are:
-        'rootdir': str
-            The root directory of the setup.  Almost certainly the directory
-            that this setup.py file is contained in.
-        'release': bool
-            Is this a release build (True) or a local development build (False)
-        'openmp': bool
-            Should we build our OpenMP extensions and attempt to link in OpenMP
-            libraries? (Not supported in this version.)
-        'cflags': list of str
-            Flags to be passed to the C++ compiler.
-        'ldflags': list of str
-            Flags to be passed to the linker.
-        'include': list of str
-            Additional directories to be added to the header files include
-            path.  These files will be detected by Cython as dependencies, so
-            changes to them will trigger recompilation of .pyx files, whereas
-            includes added in 'cflags' as '-I/path/to/include' may not.
-    """
-    options = {}
-    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
-    options = _determine_user_arguments(options)
-    options = _determine_version(options)
-    options = _determine_compilation_options(options)
-    options = _determine_cythonize_options(options)
-    return options
-
-
-def _get_environment_bool(var, default=False):
-    """
-    Get a boolean value from the environment variable `var`.  This evalutes to
-    `default` if the environment variable is not present.  The false-y values
-    are '0', 'false', 'none' and empty string, insensitive to case.  All other
-    values are truth-y.
-    """
-    from_env = os.environ.get(var)
-    if from_env is None:
-        return default
-    return from_env.lower() not in {'0', 'false', 'none', ''}
-
-
-def _parse_bool_user_argument(options, name):
-    """
-    Parse a single boolean option from the commandline or environment.
-    """
-    cmd_flag = "--with-" + name.lower().replace("_", "-")
-    env_var = "CI_QUTIP_WITH_" + name.upper()
-    options[name] = (
-        cmd_flag in sys.argv
-        or _get_environment_bool(env_var)
-    )
-    if cmd_flag in sys.argv:
-        sys.argv.remove(cmd_flag)
-    return options
-
-
-def _determine_user_arguments(options):
-    """
-    Add the 'openmp' option to the collection, based on the passed command-line
-    arguments or environment variables.
-
-    If using PEP517 builds, one can pass these options on the command-line
-    using, for example:
-
-        python -m build \
-            --wheel \
-            --config-setting="--global-option=--with-openmp"
-    """
-    # options = _parse_bool_user_argument(options, 'openmp')
-    options['openmp'] = False  # Not supported yet
-    options = _parse_bool_user_argument(options, 'idxint_64')
-    return options
-
-
-def _determine_compilation_options(options):
-    """
-    Add additional options specific to C/C++ compilation.  These are 'cflags',
-    'ldflags' and 'include'.
-    """
-    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
-    # process uses in addition to user-specified ones; the flag is not valid
-    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
-    config = distutils.sysconfig.get_config_vars()
-    if "CFLAGS" in config:
-        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
-    options['cflags'] = []
-    options['ldflags'] = []
-    options['include'] = [np.get_include()]
-    if (
-        sysconfig.get_platform().startswith("win")
-        and os.environ.get('MSYSTEM') is None
-    ):
-        # Visual Studio
-        options['cflags'].extend(['/w', '/Ox'])
-        if options['openmp']:
-            options['cflags'].append('/openmp')
-    else:
-        # Everything else
-        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
-        if options['openmp']:
-            options['cflags'].append('-fopenmp')
-            options['ldflags'].append('-fopenmp')
-    if sysconfig.get_platform().startswith("macos"):
-        # These are needed for compiling on OSX 10.14+
-        options['cflags'].append('-mmacosx-version-min=10.9')
-        options['ldflags'].append('-mmacosx-version-min=10.9')
-        if options['openmp']:
-            options['cflags'].append('-fopenmp')
-            options['ldflags'].append('-fopenmp')
-    return options
-
-
-def _determine_cythonize_options(options):
-    options["annotate"] = False
-    if "--annotate" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("--annotate")
-    if "-a" in sys.argv:
-        options["annotate"] = True
-        sys.argv.remove("-a")
-    return options
-
-
-def _determine_version(options):
-    """
-    Adds the 'short_version', 'version' and 'release' options.
-
-    Read from the VERSION file to discover the version.  This should be a
-    single line file containing valid Python package public identifier (see PEP
-    440), for example
-      4.5.2rc2
-      5.0.0
-      5.1.1a1
-    We do that here rather than in setup.cfg so we can apply the local
-    versioning number as well.
-    """
-    version_filename = os.path.join(options['rootdir'], 'VERSION')
-    with open(version_filename, "r") as version_file:
-        version_string = version_file.read().strip()
-    version = packaging.version.Version(version_string)
-    options['short_version'] = str(version.public)
-    options['release'] = not version.is_devrelease
-    if not options['release']:
-        # Put the version string into canonical form, if it wasn't already.
-        version_string = str(version)
-        version_string += "+"
-        try:
-            git_out = subprocess.run(
-                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
-                check=True,
-                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            )
-            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
-            version_string += git_hash or "nogit"
-        # CalledProcessError is for if the git command fails for internal
-        # reasons (e.g. we're not in a git repository), OSError is for if
-        # something goes wrong when trying to run git (e.g. it's not installed,
-        # or a permission error).
-        except (subprocess.CalledProcessError, OSError):
-            version_string += "nogit"
-    options['version'] = version_string
-    return options
-
-
-def create_version_py_file(options):
-    """
-    Generate and write out the file qutip/version.py, which is used to produce
-    the '__version__' information for the module.  This function will overwrite
-    an existing file at that location.
-    """
-    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
-    content = "\n".join([
-        f"# This file is automatically generated by QuTiP's setup.py.",
-        f"short_version = '{options['short_version']}'",
-        f"version = '{options['version']}'",
-        f"release = {options['release']}",
-    ])
-    with open(filename, 'w') as file:
-        print(content, file=file)
-
-
-def _extension_extra_sources():
-    """
-    Get a mapping of {module: extra_sources} for all modules to be built.  The
-    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
-    and extra_sources is a list of strings of relative paths to files.  If no
-    extra sources are known for a given module, the mapping will return an
-    empty list.
-    """
-    # For typing brevity we specify sources in Unix-style string form, then
-    # normalise them into the OS-specific form later.
-    extra_sources = {
-        'qutip.core.data.matmul': [
-            'qutip/core/data/src/matmul_csr_vector.cpp',
-        ],
-    }
-    out = collections.defaultdict(list)
-    for module, sources in extra_sources.items():
-        # Normalise the sources into OS-specific form.
-        out[module] = [str(pathlib.Path(source)) for source in sources]
-    return out
-
-
-def _create_int_type_file(options):
-    """
-    Create the `data/src/intdtype.h` file.
-    """
-    if options['idxint_64']:
-        typedef = "typedef int64_t idxint;\n"
-        typedef += "int _idxint_size=64;\n"
-    else:
-        typedef = "typedef int32_t idxint;\n"
-        typedef += "int _idxint_size=32;\n"
-    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
-    file = os.path.join(path, 'intdtype.h')
-    if os.path.exists(file):
-        with open(file, 'r') as source:
-            if source.read() == typedef:
-                # The file is already existing and the same, nothing to do.
-                return
-
-    with open(file, 'w') as source:
-        source.write(typedef)
-
-
-def create_extension_modules(options):
-    """
-    Discover and Cythonise all extension modules that need to be built.  These
-    are returned so they can be passed into the setup command.
-    """
-    out = []
-    root = pathlib.Path(options['rootdir'])
-    _create_int_type_file(options)
-    pyx_files = set(root.glob('qutip/**/*.pyx'))
-    if not options['openmp']:
-        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
-    extra_sources = _extension_extra_sources()
-    # Add Cython files from qutip
-    for pyx_file in pyx_files:
-        pyx_file = pyx_file.relative_to(root)
-        pyx_file_str = str(pyx_file)
-        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
-            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
-            # Cythonised time-dependent coefficients would get dropped in the
-            # qutip directory if you weren't careful - this is just trying to
-            # minimise the occasional developer error.
-            warnings.warn(
-                "skipping generated time-dependent coefficient: "
-                + pyx_file_str
-            )
-            continue
-        # The module name is the same as the folder structure, but with dots in
-        # place of separators ('/' or '\'), and without the '.pyx' extension.
-        pyx_module = ".".join(pyx_file.parts)[:-4]
-        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
-        out.append(Extension(pyx_module,
-                             sources=pyx_sources,
-                             include_dirs=options['include'],
-                             extra_compile_args=options['cflags'],
-                             extra_link_args=options['ldflags'],
-                             language='c++'))
-    return cythonize(out, annotate=options["annotate"])
-
-
-def print_epilogue():
-    """Display a post-setup epilogue."""
-    longbar = "="*80
-    message = "\n".join([
-        longbar,
-        "Installation complete",
-        "Please cite QuTiP in your publication.",
-        longbar,
-        "For your convenience a BibTeX reference can be easily generated with",
-        "`qutip.cite()`",
-    ])
-    print(message)
-
-
-if __name__ == "__main__":
-    options = process_options()
-    create_version_py_file(options)
-    extensions = create_extension_modules(options)
-    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
-    # keep here are ones that we have done some compile-time processing on.
-    setup(
-        version=options['version'],
-        ext_modules=extensions,
-        cmdclass={'build_ext': build_ext},
-    )
-    print_epilogue()
+#!/usr/bin/env python
+
+import collections
+import os
+import pathlib
+import subprocess
+import sys
+import sysconfig
+import warnings
+
+# Required third-party imports, must be specified in pyproject.toml.
+import packaging.version
+from setuptools import setup, Extension
+import distutils.sysconfig
+import numpy as np
+from Cython.Build import cythonize
+from Cython.Distutils import build_ext
+
+
+def process_options():
+    """
+    Determine all runtime options, returning a dictionary of the results.  The
+    keys are:
+        'rootdir': str
+            The root directory of the setup.  Almost certainly the directory
+            that this setup.py file is contained in.
+        'release': bool
+            Is this a release build (True) or a local development build (False)
+        'openmp': bool
+            Should we build our OpenMP extensions and attempt to link in OpenMP
+            libraries? (Not supported in this version.)
+        'cflags': list of str
+            Flags to be passed to the C++ compiler.
+        'ldflags': list of str
+            Flags to be passed to the linker.
+        'include': list of str
+            Additional directories to be added to the header files include
+            path.  These files will be detected by Cython as dependencies, so
+            changes to them will trigger recompilation of .pyx files, whereas
+            includes added in 'cflags' as '-I/path/to/include' may not.
+    """
+    options = {}
+    options['rootdir'] = os.path.dirname(os.path.abspath(__file__))
+    options = _determine_user_arguments(options)
+    options = _determine_version(options)
+    options = _determine_compilation_options(options)
+    options = _determine_cythonize_options(options)
+    return options
+
+
+def _get_environment_bool(var, default=False):
+    """
+    Get a boolean value from the environment variable `var`.  This evalutes to
+    `default` if the environment variable is not present.  The false-y values
+    are '0', 'false', 'none' and empty string, insensitive to case.  All other
+    values are truth-y.
+    """
+    from_env = os.environ.get(var)
+    if from_env is None:
+        return default
+    return from_env.lower() not in {'0', 'false', 'none', ''}
+
+
+def _parse_bool_user_argument(options, name):
+    """
+    Parse a single boolean option from the commandline or environment.
+    """
+    cmd_flag = "--with-" + name.lower().replace("_", "-")
+    env_var = "CI_QUTIP_WITH_" + name.upper()
+    options[name] = (
+        cmd_flag in sys.argv
+        or _get_environment_bool(env_var)
+    )
+    if cmd_flag in sys.argv:
+        sys.argv.remove(cmd_flag)
+    return options
+
+
+def _determine_user_arguments(options):
+    """
+    Add the 'openmp' option to the collection, based on the passed command-line
+    arguments or environment variables.
+
+    If using PEP517 builds, one can pass these options on the command-line
+    using, for example:
+
+        python -m build \
+            --wheel \
+            --config-setting="--global-option=--with-openmp"
+    """
+    # options = _parse_bool_user_argument(options, 'openmp')
+    options['openmp'] = False  # Not supported yet
+    options = _parse_bool_user_argument(options, 'idxint_64')
+    return options
+
+
+def _determine_compilation_options(options):
+    """
+    Add additional options specific to C/C++ compilation.  These are 'cflags',
+    'ldflags' and 'include'.
+    """
+    # Remove -Wstrict-prototypes from the CFLAGS variable that the Python build
+    # process uses in addition to user-specified ones; the flag is not valid
+    # for C++ compiles, but CFLAGS gets appended to those compiles anyway.
+    config = distutils.sysconfig.get_config_vars()
+    if "CFLAGS" in config:
+        config["CFLAGS"] = config["CFLAGS"].replace("-Wstrict-prototypes", "")
+    options['cflags'] = []
+    options['ldflags'] = []
+    options['include'] = [np.get_include()]
+    if (
+        sysconfig.get_platform().startswith("win")
+        and os.environ.get('MSYSTEM') is None
+    ):
+        # Visual Studio
+        options['cflags'].extend(['/w', '/Ox'])
+        if options['openmp']:
+            options['cflags'].append('/openmp')
+    else:
+        # Everything else
+        options['cflags'].extend(['-w', '-O3', '-funroll-loops'])
+        if options['openmp']:
+            options['cflags'].append('-fopenmp')
+            options['ldflags'].append('-fopenmp')
+    if sysconfig.get_platform().startswith("macos"):
+        # These are needed for compiling on OSX 10.14+
+        options['cflags'].append('-mmacosx-version-min=10.9')
+        options['ldflags'].append('-mmacosx-version-min=10.9')
+        if options['openmp']:
+            options['cflags'].append('-fopenmp')
+            options['ldflags'].append('-fopenmp')
+    return options
+
+
+def _determine_cythonize_options(options):
+    options["annotate"] = False
+    if "--annotate" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("--annotate")
+    if "-a" in sys.argv:
+        options["annotate"] = True
+        sys.argv.remove("-a")
+    return options
+
+
+def _determine_version(options):
+    """
+    Adds the 'short_version', 'version' and 'release' options.
+
+    Read from the VERSION file to discover the version.  This should be a
+    single line file containing valid Python package public identifier (see PEP
+    440), for example
+      4.5.2rc2
+      5.0.0
+      5.1.1a1
+    We do that here rather than in setup.cfg so we can apply the local
+    versioning number as well.
+    """
+    version_filename = os.path.join(options['rootdir'], 'VERSION')
+    with open(version_filename, "r") as version_file:
+        version_string = version_file.read().strip()
+    version = packaging.version.Version(version_string)
+    options['short_version'] = str(version.public)
+    options['release'] = not version.is_devrelease
+    if not options['release']:
+        # Put the version string into canonical form, if it wasn't already.
+        version_string = str(version)
+        version_string += "+"
+        try:
+            git_out = subprocess.run(
+                ('git', 'rev-parse', '--verify', '--short=7', 'HEAD'),
+                check=True,
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            )
+            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
+            version_string += git_hash or "nogit"
+        # CalledProcessError is for if the git command fails for internal
+        # reasons (e.g. we're not in a git repository), OSError is for if
+        # something goes wrong when trying to run git (e.g. it's not installed,
+        # or a permission error).
+        except (subprocess.CalledProcessError, OSError):
+            version_string += "nogit"
+    options['version'] = version_string
+    return options
+
+
+def create_version_py_file(options):
+    """
+    Generate and write out the file qutip/version.py, which is used to produce
+    the '__version__' information for the module.  This function will overwrite
+    an existing file at that location.
+    """
+    filename = os.path.join(options['rootdir'], 'qutip', 'version.py')
+    content = "\n".join([
+        f"# This file is automatically generated by QuTiP's setup.py.",
+        f"short_version = '{options['short_version']}'",
+        f"version = '{options['version']}'",
+        f"release = {options['release']}",
+    ])
+    with open(filename, 'w') as file:
+        print(content, file=file)
+
+
+def _extension_extra_sources():
+    """
+    Get a mapping of {module: extra_sources} for all modules to be built.  The
+    module is the fully qualified Python module (e.g. 'qutip.cy.spmatfuncs'),
+    and extra_sources is a list of strings of relative paths to files.  If no
+    extra sources are known for a given module, the mapping will return an
+    empty list.
+    """
+    # For typing brevity we specify sources in Unix-style string form, then
+    # normalise them into the OS-specific form later.
+    extra_sources = {
+        'qutip.core.data.matmul': [
+            'qutip/core/data/src/matmul_csr_vector.cpp',
+        ],
+    }
+    out = collections.defaultdict(list)
+    for module, sources in extra_sources.items():
+        # Normalise the sources into OS-specific form.
+        out[module] = [str(pathlib.Path(source)) for source in sources]
+    return out
+
+
+def _create_int_type_file(options):
+    """
+    Create the `data/src/intdtype.h` file.
+    """
+    if options['idxint_64']:
+        typedef = "typedef int64_t idxint;\n"
+        typedef += "int _idxint_size=64;\n"
+    else:
+        typedef = "typedef int32_t idxint;\n"
+        typedef += "int _idxint_size=32;\n"
+    path = os.path.join(options['rootdir'], 'qutip', 'core', 'data', 'src')
+    file = os.path.join(path, 'intdtype.h')
+    if os.path.exists(file):
+        with open(file, 'r') as source:
+            if source.read() == typedef:
+                # The file is already existing and the same, nothing to do.
+                return
+
+    with open(file, 'w') as source:
+        source.write(typedef)
+
+
+def create_extension_modules(options):
+    """
+    Discover and Cythonise all extension modules that need to be built.  These
+    are returned so they can be passed into the setup command.
+    """
+    out = []
+    root = pathlib.Path(options['rootdir'])
+    _create_int_type_file(options)
+    pyx_files = set(root.glob('qutip/**/*.pyx'))
+    if not options['openmp']:
+        pyx_files -= set(root.glob('qutip/**/openmp/**/*.pyx'))
+    extra_sources = _extension_extra_sources()
+    # Add Cython files from qutip
+    for pyx_file in pyx_files:
+        pyx_file = pyx_file.relative_to(root)
+        pyx_file_str = str(pyx_file)
+        if 'compiled_coeff' in pyx_file_str or 'qtcoeff_' in pyx_file_str:
+            # In development (at least for QuTiP ~4.5 and ~5.0) sometimes the
+            # Cythonised time-dependent coefficients would get dropped in the
+            # qutip directory if you weren't careful - this is just trying to
+            # minimise the occasional developer error.
+            warnings.warn(
+                "skipping generated time-dependent coefficient: "
+                + pyx_file_str
+            )
+            continue
+        # The module name is the same as the folder structure, but with dots in
+        # place of separators ('/' or '\'), and without the '.pyx' extension.
+        pyx_module = ".".join(pyx_file.parts)[:-4]
+        pyx_sources = [pyx_file_str] + extra_sources[pyx_module]
+        out.append(Extension(pyx_module,
+                             sources=pyx_sources,
+                             include_dirs=options['include'],
+                             extra_compile_args=options['cflags'],
+                             extra_link_args=options['ldflags'],
+                             language='c++'))
+    return cythonize(out, annotate=options["annotate"])
+
+
+def print_epilogue():
+    """Display a post-setup epilogue."""
+    longbar = "="*80
+    message = "\n".join([
+        longbar,
+        "Installation complete",
+        "Please cite QuTiP in your publication.",
+        longbar,
+        "For your convenience a BibTeX reference can be easily generated with",
+        "`qutip.cite()`",
+    ])
+    print(message)
+
+
+if __name__ == "__main__":
+    options = process_options()
+    create_version_py_file(options)
+    extensions = create_extension_modules(options)
+    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
+    # keep here are ones that we have done some compile-time processing on.
+    setup(
+        version=options['version'],
+        ext_modules=extensions,
+        cmdclass={'build_ext': build_ext},
+    )
+    print_epilogue()

From 21a2c651e95037060ce01abb50df303b21583344 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 27 Mar 2023 19:28:04 +0200
Subject: [PATCH 219/602] Update dynamics-bloch-redfield.rst

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 892c0a651a..73db32bc7e 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -283,7 +283,16 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
+.. note::
+    While the example code simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
+    allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting the sec_cutoff 
+    parameter to -1. as well as do a partial secular approximation by setting it to a  float. the default value is 0.1
+    for example 
 
+     output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(),ohmic_spectrum]], e_ops=e_ops,sec_cutoff=-1)
+
+    Note that using the non-secular version may lead to negativity issues.
+    
 .. _td-bloch-redfield:
 
 Time-dependent Bloch-Redfield Dynamics

From 5a034bccc7e4dfcc24ab749a9bd323722c32dd70 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 27 Mar 2023 19:34:31 +0200
Subject: [PATCH 220/602] Update dynamics-bloch-redfield.rst

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 73db32bc7e..b22e194b77 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -287,12 +287,12 @@ where the resulting `output` is an instance of the class :class:`qutip.Result`.
     While the example code simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
     allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting the sec_cutoff 
     parameter to -1. as well as do a partial secular approximation by setting it to a  float. the default value is 0.1
-    for example 
+    for example the command
 
      output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(),ohmic_spectrum]], e_ops=e_ops,sec_cutoff=-1)
 
-    Note that using the non-secular version may lead to negativity issues.
-    
+    Will simulate the same example as above without the secular approximation.Note that using the non-secular version may lead to negativity issues.
+
 .. _td-bloch-redfield:
 
 Time-dependent Bloch-Redfield Dynamics

From c0e80329d0b334b328cd5ec77bc8a6185fab6911 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 27 Mar 2023 19:36:11 +0200
Subject: [PATCH 221/602] spaces and caps for aesthetic reasons

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index b22e194b77..cdd9f5b691 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -291,7 +291,7 @@ where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
      output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(),ohmic_spectrum]], e_ops=e_ops,sec_cutoff=-1)
 
-    Will simulate the same example as above without the secular approximation.Note that using the non-secular version may lead to negativity issues.
+    will simulate the same example as above without the secular approximation. Note that using the non-secular version may lead to negativity issues.
 
 .. _td-bloch-redfield:
 

From 785b3fd842159e570b4ba75cfb0fba7bae897a29 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 27 Mar 2023 19:38:18 +0200
Subject: [PATCH 222/602] grammar fix

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index cdd9f5b691..1eaf80cd06 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -284,7 +284,7 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
 .. note::
-    While the example code simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
+    While the code example  simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
     allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting the sec_cutoff 
     parameter to -1. as well as do a partial secular approximation by setting it to a  float. the default value is 0.1
     for example the command

From 8387f4e70fddc39dc6f56cb289f31b7821b275c5 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 28 Mar 2023 17:17:08 +0200
Subject: [PATCH 223/602] Fix formatting in docstrings.

---
 qutip/solver/multitraj.py  |  6 +++---
 qutip/solver/nm_mcsolve.py | 11 ++++++-----
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index de06a19325..a7292d710a 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -109,7 +109,7 @@ def run(self, state, tlist, ntraj=1, *,
 
         For a ``state`` at time ``tlist[0]`` do the evolution as directed by
         ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :cls:`Result`. The evolution method and stored
+        expectation values in a :class:`Result`. The evolution method and stored
         results are determined by ``options``.
 
         Parameters
@@ -153,8 +153,8 @@ def run(self, state, tlist, ntraj=1, *,
         seed : {int, SeedSequence, list} optional
             Seed or list of seeds for each trajectories.
 
-        Return
-        ------
+        Returns
+        -------
         results : :class:`qutip.solver.MultiTrajResult`
             Results of the evolution. States and/or expect will be saved. You
             can control the saved data in the options.
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index f03bf8d9a1..80dd68db5d 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -59,14 +59,14 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
           result class.
         - store_states : bool, NoneType, [None]
           Whether or not to store the state density matrices.
-          On `None` the states will be saved if no expectation operators are
+          On ``None`` the states will be saved if no expectation operators are
           given.
         - progress_bar : str {'text', 'enhanced', 'tqdm', ''}, ['text']
           How to present the solver progress.
           'tqdm' uses the python module of the same name and raise an error
           if not installed. Empty string or False will disable the bar.
         - progress_kwargs : dict, [{"chunk_size": 10}]
-          kwargs to pass to the progress_bar. Qutip's bars use `chunk_size`.
+          kwargs to pass to the progress_bar. Qutip's bars use ``chunk_size``.
         - method : str {"adams", "bdf", "dop853", "vern9", etc.}, ["adams"]
           Which differential equation integration method to use.
         - keep_runs_results : bool, [False]
@@ -161,7 +161,7 @@ class NonMarkovianMCSolver(MCSolver):
     ----------
     H : :class:`qutip.Qobj`, :class:`qutip.QobjEvo`, ``list``, callable.
         System Hamiltonian as a Qobj, QobjEvo. It can also be any input type
-        that QobjEvo accepts (see :class:`qutip.QobjEvo`'s documentation).
+        that QobjEvo accepts (see :class:`qutip.QobjEvo` documentation).
         ``H`` can also be a superoperator (liouvillian) if some collapse
         operators are to be treated deterministically.
 
@@ -179,6 +179,7 @@ class NonMarkovianMCSolver(MCSolver):
         Seed for the random number generator. It can be a single seed used to
         spawn seeds for each trajectory or a list of seed, one for each
         trajectory. Seeds are saved in the result and can be reused with::
+
             seeds=prev_result.seeds
     """
     name = "nm_mcsolve"
@@ -209,7 +210,7 @@ def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
 
     def _check_completeness(self, ops_and_rates):
         """
-        Checks whether sum(Li.dag() * Li) is proportional to the identity
+        Checks whether ``sum(Li.dag() * Li)`` is proportional to the identity
         operator. If not, creates an extra Lindblad operator so that it is.
 
         Returns the proportionality factor a, and the extra Lindblad operator
@@ -261,7 +262,7 @@ def _continuous_martingale(self, t):
         in self._mu_c.
         """
         if self._mu_c is None:
-            raise RuntimeError("The `start` method must called first.")
+            raise RuntimeError("The .start() method must called first.")
         if t in self._mu_c:
             return self._mu_c[t]
 

From d24119b7cbd8bfef2c5b820e62fdec40f570383f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Mar 2023 13:27:27 -0400
Subject: [PATCH 224/602] Fix imatmul dtype

---
 qutip/core/data/matmul.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 1d05387961..19559a5937 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -471,4 +471,4 @@ cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense
     elif type(left) is Dense:
         matmul_dense(left, right, scale, out)
     else:
-        iadd_dense(out, matmul(left, right), scale)
+        iadd_dense(out, matmul(left, right, dtype=Dense), scale)

From cced86123fd6a0ce61b08039f5d3afda8caed596 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Mar 2023 15:50:25 -0400
Subject: [PATCH 225/602] Clean semidefinite

---
 qutip/core/metrics.py              |   9 ---
 qutip/core/operators.py            |  27 ++++++-
 qutip/core/semidefinite.py         | 112 ++++++++++-------------------
 qutip/tests/core/test_operators.py |   9 +++
 4 files changed, 72 insertions(+), 85 deletions(-)

diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
index 08c635326c..2708efeb56 100644
--- a/qutip/core/metrics.py
+++ b/qutip/core/metrics.py
@@ -540,16 +540,10 @@ def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
     # Assume square...
     dim = np.prod(J.dims[0][0])
 
-    # The constraints only depend on the dimension, so
-    # we can cache them efficiently.
-    problem, Jr, Ji, *_ = dnorm_problem(dim)
-
     # Load the parameters with the Choi matrix passed in.
     J_dat = _data.to('csr', J.data).as_scipy()
 
     if not sparse:
-        # The parameters and constraints only depend on the dimension, so
-        # we can cache them efficiently.
         problem, Jr, Ji = dnorm_problem(dim)
 
         # Load the parameters with the Choi matrix passed in.
@@ -561,9 +555,6 @@ def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
                                   J_dat.indptr),
                                  shape=J_dat.shape).toarray()
     else:
-
-        # The parameters do not depend solely on the dimension,
-        # so we can not cache them efficiently.
         problem = dnorm_sparse_problem(dim, J_dat)
 
     problem.solve(solver=solver, verbose=verbose)
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index f2921882a9..c61e6d09c6 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -6,7 +6,7 @@
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
            'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
-           'num', 'squeeze', 'squeezing', 'displace', 'commutator',
+           'num', 'squeeze', 'squeezing', 'swap', 'displace', 'commutator',
            'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
            'enr_identity', 'charge', 'tunneling', 'qft']
 
@@ -1071,3 +1071,28 @@ def qft(dimensions, *, dtype="dense"):
     L, M = np.meshgrid(arr, arr)
     data = np.exp(phase * (L * M)) / np.sqrt(N2)
     return Qobj(data, dims=dimensions).to(dtype)
+
+
+def swap(N, M, *, dtype=None):
+    """
+    Operator that exchange the order of tensored spaces:
+
+        swap(N, M) @ tensor(ketN, ketM) == tensor(ketM, ketN)
+
+    parameters
+    ----------
+    N : int
+        Number of basis states in the first Hilbert space.
+
+    M : int
+        Number of basis states in the second Hilbert space.
+    """
+    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    data = np.ones(N * M)
+    rows = np.arange(N * M)
+    cols = (np.arange(N * M) * M) % (N * M - 1)
+    cols[-1] += (M * N - 1)
+    return Qobj(
+        scipy.sparse.coo_matrix((data, (rows, cols))),
+        dims=[[M, N], [N, M]]
+    ).to(dtype)
diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index c6d3762f22..536257caa4 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -3,12 +3,6 @@
 """
 This module implements internal-use functions for semidefinite programming.
 """
-
-__all__ = [
-    'dnorm_problem',
-    'dnorm_sparse_problem',
-]
-
 import collections
 import functools
 
@@ -17,47 +11,44 @@
 # Conditionally import CVXPY
 try:
     import cvxpy
+    __all__ = ['dnorm_problem', 'dnorm_sparse_problem']
 except ImportError:
     cvxpy = None
+    __all__ = []
 
-from .tensor import tensor_swap
-from .operators import qeye
-from ..logging_utils import get_logger
-logger = get_logger('qutip.core.semidefinite')
+from .operators import qeye, swap
 
 Complex = collections.namedtuple('Complex', ['re', 'im'])
 
 
-def complex_var(rows=1, cols=1, name=None):
+def _complex_var(rows=1, cols=1, name=None):
     return Complex(
         re=cvxpy.Variable((rows, cols), name=(name + "_re") if name else None),
         im=cvxpy.Variable((rows, cols), name=(name + "_im") if name else None),
     )
 
 
-def herm(*Xs):
-    return sum([[X.re == X.re.T, X.im == -X.im.T] for X in Xs], [])
-
-
-def pos_noherm(*Xs):
-    return [
+def _make_constraints(*rhos):
+    """
+    Create constraints to ensure definied density operators.
+    """
+    # rhos traces are 1
+    constraints = [
+        cvxpy.trace(rho.re) == 1
+        for rho in rhos
+    ]
+    # rhos are Hermitian
+    for rho in rhos:
+        constraints += [rho.re == rho.re.T] + [rho.im == -rho.im.T]
+    # Non negative
+    constraints += [
         cvxpy.bmat([
-            [X.re, -X.im],
-            [X.im, X.re]
+            [rho.re, -rho.im],
+            [rho.im, rho.re]
         ]) >> 0
-        for X in Xs
-    ]
-
-
-def pos(*Xs):
-    return pos_noherm(*Xs) + herm(*Xs)
-
-
-def dens(*rhos):
-    return pos(*rhos) + [
-        cvxpy.trace(rho.re) == 1
         for rho in rhos
     ]
+    return constraints
 
 
 def _arr_to_complex(A):
@@ -66,7 +57,7 @@ def _arr_to_complex(A):
     return Complex(re=A, im=np.zeros_like(A))
 
 
-def kron(A, B):
+def _kron(A, B):
     if isinstance(A, np.ndarray):
         A = _arr_to_complex(A)
     if isinstance(B, np.ndarray):
@@ -78,7 +69,7 @@ def kron(A, B):
     )
 
 
-def conj(W, A):
+def _conj(W, A):
     U, V = W.re, W.im
     A, B = A.re, A.im
     return Complex(
@@ -87,61 +78,28 @@ def conj(W, A):
     )
 
 
-def bmat(B):
-    return Complex(
-        re=cvxpy.bmat([[element.re for element in row] for row in B]),
-        im=cvxpy.bmat([[element.re for element in row] for row in B]),
-    )
-
-
-def dag(X):
-    return Complex(re=X.re.T, im=-X.im.T)
-
-
-def memoize(fn):
-    cache = {}
-
-    @functools.wraps(fn)
-    def memoized(*args):
-        if args in cache:
-            return cache[args]
-        else:
-            ret = fn(*args)
-            cache[args] = ret
-            return ret
-
-    memoized.reset_cache = cache.clear
-    return memoized
-
-
-def qudit_swap(dim):
-    # We should likely generalize this and include it in qip.gates.
-    W = qeye([dim, dim])
-    return tensor_swap(W, (0, 1))
-
-
-@memoize
+@functools.cache
 def initialize_constraints_on_dnorm_problem(dim):
     # Start assembling constraints and variables.
     constraints = []
 
     # Make a complex variable for X.
-    X = complex_var(dim ** 2, dim ** 2, "X")
+    X = _complex_var(dim ** 2, dim ** 2, "X")
 
     # Make complex variables for rho0 and rho1.
-    rho0 = complex_var(dim, dim, "rho0")
-    rho1 = complex_var(dim, dim, "rho1")
-    constraints += dens(rho0, rho1)
+    rho0 = _complex_var(dim, dim, "rho0")
+    rho1 = _complex_var(dim, dim, "rho1")
+    constraints += _make_constraints(rho0, rho1)
 
     # Finally, add the tricky positive semidefinite constraint.
     # Since we're using column-stacking, but Watrous used row-stacking,
     # we need to swap the order in Rho0 and Rho1. This is not straightforward,
     # as CVXPY requires that the constant be the first argument. To solve this,
     # We conjugate by SWAP.
-    W = qudit_swap(dim).full()
+    W = swap(dim, dim).full()
     W = Complex(re=W.real, im=W.imag)
-    Rho0 = conj(W, kron(np.eye(dim), rho0))
-    Rho1 = conj(W, kron(np.eye(dim), rho1))
+    Rho0 = _conj(W, _kron(np.eye(dim), rho0))
+    Rho1 = _conj(W, _kron(np.eye(dim), rho1))
 
     Y = cvxpy.bmat([
         [Rho0.re, X.re,      -Rho0.im, -X.im],
@@ -152,12 +110,13 @@ def initialize_constraints_on_dnorm_problem(dim):
     ])
     constraints += [Y >> 0]
 
-    logger.debug("Using %d constraints.", len(constraints))
-
     return X, constraints
 
 
 def dnorm_problem(dim):
+    """
+    Creade the cvxpy ``Problem`` for the dnorm metric using dense arrays
+    """
     X, constraints = initialize_constraints_on_dnorm_problem(dim)
     Jr = cvxpy.Parameter((dim**2, dim**2))
     Ji = cvxpy.Parameter((dim**2, dim**2))
@@ -170,6 +129,9 @@ def dnorm_problem(dim):
 
 
 def dnorm_sparse_problem(dim, J_dat):
+    """
+    Creade the cvxpy ``Problem`` for the dnorm metric using sparse arrays
+    """
     X, constraints = initialize_constraints_on_dnorm_problem(dim)
     J_val = J_dat.tocoo()
 
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index c8e6d72f0a..cdbc4bf646 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -293,3 +293,12 @@ def test_qft(dims):
         fft = np.fft.fft(qft[:,i])
         fft /= np.sum(fft)
         np.testing.assert_allclose(fft, target, atol=1e-16 * N)
+
+
+@pytest.mark.parametrize('N', [1, 3, 5, 8])
+@pytest.mark.parametrize('M', [1, 3, 5, 8])
+def test_qft(N, M):
+    ket1 = qutip.rand_ket(N)
+    ket2 = qutip.rand_ket(M)
+
+    assert swap(N, M) @ (ket1 & ket2) == (ket2 & ket1)

From 74b0bc824790ea7906b794a7c16936d668e75750 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Mar 2023 16:30:42 -0400
Subject: [PATCH 226/602] black semidefinite

---
 qutip/core/semidefinite.py | 53 +++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 30 deletions(-)

diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index 536257caa4..2441d3b7dc 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -8,17 +8,19 @@
 
 import numpy as np
 import scipy.sparse as sp
+
 # Conditionally import CVXPY
 try:
     import cvxpy
-    __all__ = ['dnorm_problem', 'dnorm_sparse_problem']
+
+    __all__ = ["dnorm_problem", "dnorm_sparse_problem"]
 except ImportError:
     cvxpy = None
     __all__ = []
 
-from .operators import qeye, swap
+from .operators import swap
 
-Complex = collections.namedtuple('Complex', ['re', 'im'])
+Complex = collections.namedtuple("Complex", ["re", "im"])
 
 
 def _complex_var(rows=1, cols=1, name=None):
@@ -33,20 +35,13 @@ def _make_constraints(*rhos):
     Create constraints to ensure definied density operators.
     """
     # rhos traces are 1
-    constraints = [
-        cvxpy.trace(rho.re) == 1
-        for rho in rhos
-    ]
+    constraints = [cvxpy.trace(rho.re) == 1 for rho in rhos]
     # rhos are Hermitian
     for rho in rhos:
         constraints += [rho.re == rho.re.T] + [rho.im == -rho.im.T]
     # Non negative
     constraints += [
-        cvxpy.bmat([
-            [rho.re, -rho.im],
-            [rho.im, rho.re]
-        ]) >> 0
-        for rho in rhos
+        cvxpy.bmat([[rho.re, -rho.im], [rho.im, rho.re]]) >> 0 for rho in rhos
     ]
     return constraints
 
@@ -74,7 +69,7 @@ def _conj(W, A):
     A, B = A.re, A.im
     return Complex(
         re=(U @ A @ U.T - U @ B @ V.T - V @ A @ V.T - V @ B @ U.T),
-        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T)
+        im=(U @ A @ V.T + U @ B @ U.T + V @ A @ U.T - V @ B @ V.T),
     )
 
 
@@ -84,7 +79,7 @@ def initialize_constraints_on_dnorm_problem(dim):
     constraints = []
 
     # Make a complex variable for X.
-    X = _complex_var(dim ** 2, dim ** 2, "X")
+    X = _complex_var(dim**2, dim**2, "X")
 
     # Make complex variables for rho0 and rho1.
     rho0 = _complex_var(dim, dim, "rho0")
@@ -101,13 +96,14 @@ def initialize_constraints_on_dnorm_problem(dim):
     Rho0 = _conj(W, _kron(np.eye(dim), rho0))
     Rho1 = _conj(W, _kron(np.eye(dim), rho1))
 
-    Y = cvxpy.bmat([
-        [Rho0.re, X.re,      -Rho0.im, -X.im],
-        [X.re.T, Rho1.re,    X.im.T, -Rho1.im],
-
-        [Rho0.im, X.im,      Rho0.re, X.re],
-        [-X.im.T, Rho1.im,   X.re.T, Rho1.re],
-    ])
+    Y = cvxpy.bmat(
+        [
+            [Rho0.re, X.re, -Rho0.im, -X.im],
+            [X.re.T, Rho1.re, X.im.T, -Rho1.im],
+            [Rho0.im, X.im, Rho0.re, X.re],
+            [-X.im.T, Rho1.im, X.re.T, Rho1.re],
+        ]
+    )
     constraints += [Y >> 0]
 
     return X, constraints
@@ -121,9 +117,7 @@ def dnorm_problem(dim):
     Jr = cvxpy.Parameter((dim**2, dim**2))
     Ji = cvxpy.Parameter((dim**2, dim**2))
     # The objective, however, depends on J.
-    objective = cvxpy.Maximize(cvxpy.trace(
-        Jr.T @ X.re + Ji.T @ X.im
-    ))
+    objective = cvxpy.Maximize(cvxpy.trace(Jr.T @ X.re + Ji.T @ X.im))
     problem = cvxpy.Problem(objective, constraints)
     return problem, Jr, Ji
 
@@ -148,10 +142,11 @@ def adapt_sparse_params(A_val, dim):
         A_cols = np.arange(A_nnz.size)
         # We are pushing the data on the location of the nonzero elements
         # to the nonzero rows of A_indexer
-        A_Indexer = sp.coo_matrix((A_data, (A_rows, A_cols)),
-                                  shape=(side_size**2, A_nnz.size))
+        A_Indexer = sp.coo_matrix(
+            (A_data, (A_rows, A_cols)), shape=(side_size**2, A_nnz.size)
+        )
         # We get finaly the sparse matrix A which we wanted
-        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order='C')
+        A = cvxpy.reshape(A_Indexer @ A_nnz, (side_size, side_size), order="C")
         A_nnz.value = A_val.data
         return A
 
@@ -162,9 +157,7 @@ def adapt_sparse_params(A_val, dim):
     Ji = adapt_sparse_params(Ji_val, dim)
 
     # The objective, however, depends on J.
-    objective = cvxpy.Maximize(cvxpy.trace(
-        Jr.T @ X.re + Ji.T @ X.im
-    ))
+    objective = cvxpy.Maximize(cvxpy.trace(Jr.T @ X.re + Ji.T @ X.im))
 
     problem = cvxpy.Problem(objective, constraints)
     return problem

From 1d8d5597f99a1856d92c0caca683644072c615b6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Mar 2023 16:37:13 -0400
Subject: [PATCH 227/602] Test for swap

---
 qutip/core/operators.py            | 4 ++++
 qutip/tests/core/test_operators.py | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index c61e6d09c6..3f9cd6779a 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -1088,6 +1088,10 @@ def swap(N, M, *, dtype=None):
         Number of basis states in the second Hilbert space.
     """
     dtype = dtype or settings.core["default_dtype"] or _data.CSR
+
+    if N == 1 and M == 1:
+        return qeye([1, 1], dtype=dtype)
+
     data = np.ones(N * M)
     rows = np.arange(N * M)
     cols = (np.arange(N * M) * M) % (N * M - 1)
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index cdbc4bf646..848cd9eddd 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -297,8 +297,8 @@ def test_qft(dims):
 
 @pytest.mark.parametrize('N', [1, 3, 5, 8])
 @pytest.mark.parametrize('M', [1, 3, 5, 8])
-def test_qft(N, M):
+def test_swap(N, M):
     ket1 = qutip.rand_ket(N)
     ket2 = qutip.rand_ket(M)
 
-    assert swap(N, M) @ (ket1 & ket2) == (ket2 & ket1)
+    assert qutip.swap(N, M) @ (ket1 & ket2) == (ket2 & ket1)

From 1f8abc0822fefc21f9079d4c979655e32201fe96 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Mar 2023 16:45:06 -0400
Subject: [PATCH 228/602] lru_cache instead of cache

---
 qutip/core/semidefinite.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/semidefinite.py b/qutip/core/semidefinite.py
index 2441d3b7dc..ce8fcabf89 100644
--- a/qutip/core/semidefinite.py
+++ b/qutip/core/semidefinite.py
@@ -73,7 +73,7 @@ def _conj(W, A):
     )
 
 
-@functools.cache
+@functools.lru_cache
 def initialize_constraints_on_dnorm_problem(dim):
     # Start assembling constraints and variables.
     constraints = []

From ba44e8cb33db4de573407fe3980d104f53a976db Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 28 Mar 2023 18:41:15 -0400
Subject: [PATCH 229/602] Add towncrier entry

---
 doc/changes/2138.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2138.misc

diff --git a/doc/changes/2138.misc b/doc/changes/2138.misc
new file mode 100644
index 0000000000..556c742378
--- /dev/null
+++ b/doc/changes/2138.misc
@@ -0,0 +1 @@
+Clean semidefinite

From 5fdee143366460071f89ef2690b395a5222fe00c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 29 Mar 2023 09:04:09 -0400
Subject: [PATCH 230/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/operators.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 3f9cd6779a..2dad36676d 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -1075,7 +1075,7 @@ def qft(dimensions, *, dtype="dense"):
 
 def swap(N, M, *, dtype=None):
     """
-    Operator that exchange the order of tensored spaces:
+    Operator that exchanges the order of tensored spaces:
 
         swap(N, M) @ tensor(ketN, ketM) == tensor(ketM, ketN)
 
@@ -1093,10 +1093,10 @@ def swap(N, M, *, dtype=None):
         return qeye([1, 1], dtype=dtype)
 
     data = np.ones(N * M)
-    rows = np.arange(N * M)
+    rows = np.arange(N * M + 1)  # last entry is nnz
     cols = (np.arange(N * M) * M) % (N * M - 1)
     cols[-1] += (M * N - 1)
     return Qobj(
-        scipy.sparse.coo_matrix((data, (rows, cols))),
+        _data.CSR((data, cols, rows), (N * M, N * M)),
         dims=[[M, N], [N, M]]
     ).to(dtype)

From ae53685195a6c1bf9d8969a23b5b79b310e53392 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 29 Mar 2023 09:09:38 -0400
Subject: [PATCH 231/602] Update swap from suggestion

---
 qutip/core/operators.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 2dad36676d..b14f52651d 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -1094,8 +1094,7 @@ def swap(N, M, *, dtype=None):
 
     data = np.ones(N * M)
     rows = np.arange(N * M + 1)  # last entry is nnz
-    cols = (np.arange(N * M) * M) % (N * M - 1)
-    cols[-1] += (M * N - 1)
+    cols = np.ravel(M * np.arange(N)[None, :] + np.arange(M)[:, None])
     return Qobj(
         _data.CSR((data, cols, rows), (N * M, N * M)),
         dims=[[M, N], [N, M]]

From 1d4f18a2b578dd796afce64ede1f68d81c24fcd0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 29 Mar 2023 09:26:18 -0400
Subject: [PATCH 232/602] Add Qobj.get to obtain the data in normal type

---
 qutip/core/data/__init__.py   |  1 +
 qutip/core/data/extract.py    | 52 +++++++++++++++++++++++++++++++++++
 qutip/core/qobj.py            | 15 ++++++++++
 qutip/tests/core/test_qobj.py | 21 ++++++++++++++
 4 files changed, 89 insertions(+)
 create mode 100644 qutip/core/data/extract.py

diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index 557aff5c04..ad50f1fced 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -25,6 +25,7 @@
 from .tidyup import *
 from .trace import *
 from .solve import *
+from .extract import *
 # For operations with mulitple related versions, we just import the module.
 from . import norm, permute
 
diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
new file mode 100644
index 0000000000..a97d35b887
--- /dev/null
+++ b/qutip/core/data/extract.py
@@ -0,0 +1,52 @@
+from . import dense, csr, Dense, CSR
+from .dispatch import Dispatcher as _Dispatcher
+import inspect as _inspect
+
+
+def get_dense(matrix, copy=True):
+    if copy:
+        return matrix.to_array()
+    else:
+        return matrix.as_ndarray()
+
+
+def get_csr(matrix, copy=True):
+    data = matrix.as_scipy()
+    if copy:
+        data = data.copy()
+    return data
+
+
+get = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter(
+            'copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True
+        )
+    ]),
+    name='get',
+    module=__name__,
+    inputs=('matrix',),
+    out=False,
+)
+get.__doc__ =\
+    """
+    Return the common representation of the data layer object: scipy's
+    ``csr_matrix`` for ``CSR``, numpy array for ``Dense``, Jax's ``Array`` for
+    ``JaxArray``, etc.
+
+    Parameters
+    ----------
+    matrix : int
+        The matrix to convert to common type.
+
+    copy : bool, default: True
+        Whether to pass a copy of the object.
+    """
+get.add_specialisations([
+    (CSR, get_csr),
+    (Dense, get_dense),
+], _defer=True)
+
+
+del _Dispatcher, _inspect
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index 83a778b052..8adfda1e1a 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -824,6 +824,21 @@ def full(self, order='C', squeeze=False):
         out = np.asarray(self.data.to_array(), order=order)
         return out.squeeze() if squeeze else out
 
+    def get(self, copy=True):
+        """Matrix from quantum object.
+
+        Parameters
+        ----------
+        copy : bool {False, True}
+            Whether to return a copy
+
+        Returns
+        -------
+        data : numpy.ndarray, scipy.sparse.matrix_csr, etc.
+            Matrix in the type of the underlying libraries.
+        """
+        return _data.get(self.data, copy)
+
     def diag(self):
         """Diagonal elements of quantum object.
 
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 85e091b608..8d1fa5a85a 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1226,3 +1226,24 @@ def test_groundstate():
     with pytest.warns(UserWarning) as warning:
         qutip.qeye(5).groundstate()
     assert "degenerate" in warning[0].message.args[0]
+
+
+def test_get():
+    qobj = qutip.qeye(2, dtype="CSR")
+
+    assert scipy.sparse.isspmatrix_csr(qobj.get())
+    assert scipy.sparse.isspmatrix_csr(qobj.get(copy=False))
+
+    qobj.get(copy=False)[0, 0] = 0
+    qobj.get(copy=True)[0, 0] = 1
+    assert qobj == qutip.num(2, dtype="CSR")
+
+
+    qobj = qutip.qeye(2, dtype="Dense")
+
+    assert isinstance(qobj.get(), np.ndarray)
+    assert isinstance(qobj.get(copy=False), np.ndarray)
+    
+    qobj.get(copy=False)[0, 0] = 0
+    qobj.get(copy=True)[0, 0] = 1
+    assert qobj == qutip.num(2, dtype="Dense")

From ea336302547aac7656d89cd5bd2a08f949050bff Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 29 Mar 2023 09:58:31 -0400
Subject: [PATCH 233/602] Convert numpy int to python int

---
 qutip/core/metrics.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
index 2708efeb56..935b01e927 100644
--- a/qutip/core/metrics.py
+++ b/qutip/core/metrics.py
@@ -538,7 +538,7 @@ def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
     # If we're still here, we need to actually solve the problem.
 
     # Assume square...
-    dim = np.prod(J.dims[0][0])
+    dim = int(np.prod(J.dims[0][0]))
 
     # Load the parameters with the Choi matrix passed in.
     J_dat = _data.to('csr', J.data).as_scipy()

From 5ae1b70decbec0ecaf94e2a194d4bfa339696f78 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 29 Mar 2023 10:15:37 -0400
Subject: [PATCH 234/602] Add towncrier entry

---
 doc/changes/2141.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2141.feature

diff --git a/doc/changes/2141.feature b/doc/changes/2141.feature
new file mode 100644
index 0000000000..3e40499694
--- /dev/null
+++ b/doc/changes/2141.feature
@@ -0,0 +1 @@
+Add `Qobj.get` to extract underlying data in original format.

From ac88c6898e6f3ac5d0e3892eb7f2a28ba58e5a73 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 29 Mar 2023 16:48:41 -0400
Subject: [PATCH 235/602] Clean ttmsolve

---
 qutip/solve/nonmarkov/transfertensor.py | 216 +++++++-----------------
 1 file changed, 60 insertions(+), 156 deletions(-)

diff --git a/qutip/solve/nonmarkov/transfertensor.py b/qutip/solve/nonmarkov/transfertensor.py
index 561b7554e1..4eb1386cfd 100644
--- a/qutip/solve/nonmarkov/transfertensor.py
+++ b/qutip/solve/nonmarkov/transfertensor.py
@@ -18,45 +18,8 @@
 from ..solver import Result, SolverOptions
 
 
-class TTMSolverOptions:
-    """Class of options for the Transfer Tensor Method solver.
-
-    Attributes
-    ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators),
-        or a callback function that returns the
-        superoperator at a given time.
-
-    times : array_like
-        List of times :math:`t_n` at which to calculate :math:`\\rho(t_n)`
-
-    learningtimes : array_like
-        List of times :math:`t_k` to use as learning times if argument
-        `dynmaps` is a callback function.
-
-    thres : float
-        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
-        treshold.
-
-    options : :class:`qutip.solver.SolverOptions`
-        Generic solver options.
-    """
-
-    def __init__(self, dynmaps=None, times=[], learningtimes=[],
-                 thres=0.0, options=None):
-        if options is None:
-            options = SolverOptions()
-
-        self.dynmaps = dynmaps
-        self.times = times
-        self.learningtimes = learningtimes
-        self.thres = thres
-        self.store_states = options['store_states']
-
-
-def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
-             **kwargs):
+def ttmsolve(dynmaps, state0, times, e_ops=[], learningtimes=None,
+             options=None):
     """
     Solve time-evolution using the Transfer Tensor Method, based on a set of
     precomputed dynamical maps.
@@ -68,7 +31,7 @@ def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
         or a callback function that returns the
         superoperator at a given time.
 
-    rho0 : :class:`qutip.Qobj`
+    state0 : :class:`qutip.Qobj`
         Initial density matrix or state vector (ket).
 
     times : array_like
@@ -79,16 +42,18 @@ def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
         single operator or list of operators for which to evaluate
         expectation values.
 
-    learningtimes : array_like
-        list of times :math:`t_k` for which we have knowledge of the dynamical
-        maps :math:`E(t_k)`.
+    options : dictionary
+        Dictionary of options for the solver.
 
-    tensors : array_like
-        optional list of precomputed tensors :math:`T_k`
-
-    kwargs : dictionary
-        Optional keyword arguments. See
-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+        - store_final_state : bool
+          Whether or not to store the final state of the evolution in the
+          result class.
+        - store_states : bool, None
+          Whether or not to store the state vectors or density matrices.
+          On `None` the states will be saved if no expectation operators are
+          given.
+        - normalize_output : bool
+          Normalize output state to hide ODE numerical errors.
 
     Returns
     -------
@@ -96,92 +61,62 @@ def ttmsolve(dynmaps, rho0, times, e_ops=[], learningtimes=None, tensors=None,
         An instance of the class :class:`qutip.solver.Result`.
     """
 
-    opt = TTMSolverOptions(dynmaps=dynmaps, times=times,
-                           learningtimes=learningtimes, **kwargs)
-
-    diff = None
-
-    if rho0.isket:
-        rho0 = rho0.proj()
-
-    output = Result()
-    e_sops_data = []
+    options = {
+        "store_final_state": False,
+        "store_states": None,
+        "normalize_output": "ket",
+        "threshold": 0.0,
+        "num_learning": 0,
+    }.update(options)
 
-    if callable(e_ops):
-        n_expt_op = 0
-        expt_callback = True
+    if TEST times
 
-    else:
-        try:
-            tmp = e_ops[:]
-            del tmp
-
-            n_expt_op = len(e_ops)
-            expt_callback = False
-
-            if n_expt_op == 0:
-                # fall back on storing states
-                opt.store_states = True
-
-            for op in e_ops:
-                e_sops_data.append(spre(op).data)
-                if op.isherm and rho0.isherm:
-                    output.expect.append(np.zeros(len(times)))
-                else:
-                    output.expect.append(np.zeros(len(times), dtype=complex))
-        except TypeError:
-            raise TypeError("Argument 'e_ops' should be a callable or" +
-                            "list-like.")
-
-    if tensors is None:
-        tensors, diff = _generatetensors(dynmaps, learningtimes, opt=opt)
-
-    if rho0.isoper:
+    if callable(dynmaps):
+        if not options["num_learning"]:
+            raise ValueError(...)
+        dynmaps = [dynmaps(t) for t in times[:options["num_learning"]]]
+
+    start = time.time()
+    tensors, diff = _generatetensors(dynmaps, options["threshold"])
+    end = time.time()
+
+    stats = {
+        "preparation time": end - start,
+        "run time": 0.0,
+        "ttmconvergence": diff,
+        "num_tensor": len(tensor)
+    }
+
+    if state0.isoper:
         # vectorize density matrix
-        rho0vec = operator_to_vector(rho0)
+        rho0vec = operator_to_vector(state0)
+        restore = vector_to_operator
     else:
-        # rho0 might be a super in which case we should not vectorize
-        rho0vec = rho0
+        # state0 might be a super in which case we should not vectorize
+        rho0vec = state0
+        restore = lambda state: state
 
     K = len(tensors)
+    start = time.time()
+    results = Result(e_ops, options, solver="ttmsolve", stats=stats)
     states = [rho0vec]
+    results.add(times[0], state0)
     for n in range(1, len(times)):
         # Set current state
-        state = None
+        state = 0
         for j in range(1, min(K, n + 1)):
             tmp = tensors[j] * states[n - j]
-            state = tmp if state is None else tmp + state
+            state = tmp + state
         # Append state to all states
         states.append(state)
-    for i, r in enumerate(states):
-        if opt.store_states or expt_callback:
-            if r.type == 'operator-ket':
-                states[i] = vector_to_operator(r)
-            else:
-                states[i] = r
-            if expt_callback:
-                # use callback method
-                e_ops(times[i], states[i])
-        rdata = _data.column_stack(r.data)
-        for m in range(n_expt_op):
-            if output.expect[m].dtype == complex:
-                output.expect[m][i] = _data.expect_super(e_sops_data[m], rdata)
-            else:
-                output.expect[m][i] =\
-                    _data.expect_super(e_sops_data[m], rdata).real
-
-    output.solver = "ttmsolve"
-    output.times = times
-
-    output.ttmconvergence = diff
-
-    if opt.store_states:
-        output.states = states
-
-    return output
-
-
-def _generatetensors(dynmaps, learningtimes=None, **kwargs):
+        results.add(times[n], restore(state))
+    end = time.time()
+    stats["run time"] = end - start
+
+    return results
+
+
+def _generatetensors(dynmaps, threshold):
     r"""
     Generate the tensors :math:`T_1,\dots,T_K` from the dynamical maps
     :math:`E(t_k)`.
@@ -208,47 +143,16 @@ def _generatetensors(dynmaps, learningtimes=None, **kwargs):
     Tlist: list of :class:`qutip.Qobj.`
         A list of transfer tensors :math:`T_1,\dots,T_K`
     """
-
-    # Determine if dynmaps is callable or list-like
-    if callable(dynmaps):
-        if learningtimes is None:
-            raise TypeError("Argument 'learnintimes' required when 'dynmaps'" +
-                            "is a callback function.")
-
-        def dynmapfunc(n):
-            return dynmaps(learningtimes[n])
-
-        Kmax = len(learningtimes)
-    else:
-        try:
-            tmp = dynmaps[:]
-            del tmp
-
-            def dynmapfunc(n):
-                return dynmaps[n]
-
-            Kmax = len(dynmaps)
-        except TypeError:
-            raise TypeError("Argument 'dynmaps' should be a callable or" +
-                            "list-like.")
-
-    if "opt" not in kwargs:
-        opt = TTMSolverOptions(dynmaps=dynmaps, learningtimes=learningtimes,
-                               **kwargs)
-    else:
-        opt = kwargs['opt']
-
     Tlist = []
     diff = [0.0]
     for n in range(Kmax):
-        T = dynmapfunc(n)
+        T = dynmaps[n]
         for m in range(1, n):
-            T -= Tlist[n - m] * dynmapfunc(m)
+            T -= Tlist[n - m] * dynmaps[m]
         Tlist.append(T)
         if n > 1:
             diff.append((Tlist[-1] - Tlist[-2]).norm())
-            if diff[-1] < opt.thres:
+            if diff[-1] < threshold:
                 # Below threshold for truncation
-                print('breaking', (Tlist[-1] - Tlist[-2]).norm(), n)
                 break
     return Tlist, diff

From ad0947d282e87fd4640ae328f24beddf97aba14c Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 12:13:36 -0400
Subject: [PATCH 236/602] Update ttmsolve

---
 doc/apidoc/classes.rst                        |  3 -
 doc/apidoc/functions.rst                      |  2 +-
 .../nonmarkov/transfertensor.py               | 91 +++++++++++--------
 .../tests/{ => solver}/test_transfertensor.py |  0
 4 files changed, 52 insertions(+), 44 deletions(-)
 rename qutip/{solve => solver}/nonmarkov/transfertensor.py (57%)
 rename qutip/tests/{ => solver}/test_transfertensor.py (100%)

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index 052faef01e..478e38571d 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -140,9 +140,6 @@ Non-Markovian Memory Cascade and Transfer Tensor Solvers
 .. autoclass:: qutip.solve.nonmarkov.memorycascade.MemoryCascade
     :members:
 
-.. autoclass:: qutip.solve.nonmarkov.transfertensor.TTMSolverOptions
-    :members:
-
 
 .. _classes-odeoptions:
 
diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index d9bfef677b..2d3769aa07 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -255,7 +255,7 @@ Quantum Process Tomography
 Non-Markovian Solvers
 =====================
 
-.. automodule:: qutip.solve.nonmarkov.transfertensor
+.. automodule:: qutip.solver.transfertensor
     :members: ttmsolve
 
 
diff --git a/qutip/solve/nonmarkov/transfertensor.py b/qutip/solver/nonmarkov/transfertensor.py
similarity index 57%
rename from qutip/solve/nonmarkov/transfertensor.py
rename to qutip/solver/nonmarkov/transfertensor.py
index 4eb1386cfd..f16f501da4 100644
--- a/qutip/solve/nonmarkov/transfertensor.py
+++ b/qutip/solver/nonmarkov/transfertensor.py
@@ -11,36 +11,34 @@
 """
 
 import numpy as np
+import time
+from qutip import spre, vector_to_operator, operator_to_vector, Result
 
 
-from qutip import spre, vector_to_operator, operator_to_vector
-from qutip.core import data as _data
-from ..solver import Result, SolverOptions
-
-
-def ttmsolve(dynmaps, state0, times, e_ops=[], learningtimes=None,
-             options=None):
+def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
     """
-    Solve time-evolution using the Transfer Tensor Method, based on a set of
+    Expand time-evolution using the Transfer Tensor Method [1]_, based on a set of
     precomputed dynamical maps.
 
     Parameters
     ----------
-    dynmaps : list of :class:`qutip.Qobj`
-        List of precomputed dynamical maps (superoperators),
-        or a callback function that returns the
-        superoperator at a given time.
+    dynmaps : list of :class:`qutip.Qobj`, callable
+        List of precomputed dynamical maps (superoperators) for the first times of
+        ``times`` or a callback function that returns the superoperator at a given
+        time.
 
     state0 : :class:`qutip.Qobj`
         Initial density matrix or state vector (ket).
 
     times : array_like
-        list of times :math:`t_n` at which to compute :math:`\\rho(t_n)`.
+        List of times :math:`t_n` at which to compute results.
         Must be uniformily spaced.
 
-    e_ops : list of :class:`qutip.Qobj` / callback function
-        single operator or list of operators for which to evaluate
-        expectation values.
+    e_ops : :class:`qutip.qobj`, callable, or list.
+        Single operator or list of operators for which to evaluate
+        expectation values or callable or list of callable.
+        Callable signature must be, `f(t: float, state: Qobj)`.
+        See :func:`expect` for more detail of operator expectation.
 
     options : dictionary
         Dictionary of options for the solver.
@@ -54,38 +52,56 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], learningtimes=None,
           given.
         - normalize_output : bool
           Normalize output state to hide ODE numerical errors.
+        - threshold : float
+          Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below treshold.
+        - num_learning : int
+          Number of times used to construct the dynmaps operators when ``dynmaps`` is a
+          callable.
 
     Returns
     -------
     output: :class:`qutip.solver.Result`
         An instance of the class :class:`qutip.solver.Result`.
+
+    .. [1] Javier Cerrillo and Jianshu Cao, Phys. Rev. Lett 112, 110401 (2014)
     """
 
-    options = {
+    opt = {
         "store_final_state": False,
         "store_states": None,
         "normalize_output": "ket",
         "threshold": 0.0,
         "num_learning": 0,
-    }.update(options)
+    }
+    if options:
+        opt.update(options)
 
-    if TEST times
+    if not np.allclose(np.diff(times), times[1] - times[0]):
+        raise ValueError
 
     if callable(dynmaps):
         if not options["num_learning"]:
-            raise ValueError(...)
-        dynmaps = [dynmaps(t) for t in times[:options["num_learning"]]]
+            raise ValueError(
+                "When dynmaps is a callable, options['num_learning'] must be the "
+                "number of dynamical maps to compute."
+            )
+        dynmaps = [dynmaps(t) for t in times[: opt["num_learning"]]]
+
+    if not dynmaps[0].issuper:
+        raise ValueError("dynmaps must be super operators.")
 
     start = time.time()
-    tensors, diff = _generatetensors(dynmaps, options["threshold"])
+    tensors, diff = _generatetensors(dynmaps, opt["threshold"])
     end = time.time()
 
     stats = {
         "preparation time": end - start,
         "run time": 0.0,
         "ttmconvergence": diff,
-        "num_tensor": len(tensor)
+        "num_tensor": len(tensors),
     }
+    if state0.isket:
+        state0 = state0.proj()
 
     if state0.isoper:
         # vectorize density matrix
@@ -98,9 +114,10 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], learningtimes=None,
 
     K = len(tensors)
     start = time.time()
-    results = Result(e_ops, options, solver="ttmsolve", stats=stats)
+    results = Result(e_ops, opt, solver="ttmsolve", stats=stats)
     states = [rho0vec]
     results.add(times[0], state0)
+
     for n in range(1, len(times)):
         # Set current state
         state = 0
@@ -127,32 +144,26 @@ def _generatetensors(dynmaps, threshold):
     ----------
     dynmaps : list of :class:`qutip.Qobj`
         List of precomputed dynamical maps (superoperators) at the times
-        specified in `learningtimes`, or a callback function that returns the
-        superoperator at a given time.
-
-    learningtimes : array_like
-        list of times :math:`t_k` to use if argument `dynmaps` is a callback
-        function.
+        specified in `learningtimes`.
 
-    kwargs : dictionary
-        Optional keyword arguments. See
-        :class:`qutip.nonmarkov.transfertensor.TTMSolverOptions`.
+    threshold : float
+        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below treshold.
 
     Returns
     -------
-    Tlist: list of :class:`qutip.Qobj.`
+    Tensors, diffs: list of :class:`qutip.Qobj.`
         A list of transfer tensors :math:`T_1,\dots,T_K`
     """
-    Tlist = []
+    Tensors = []
     diff = [0.0]
-    for n in range(Kmax):
+    for n in range(len(dynmaps)):
         T = dynmaps[n]
         for m in range(1, n):
-            T -= Tlist[n - m] * dynmaps[m]
-        Tlist.append(T)
+            T -= Tensors[n - m] * dynmaps[m]
+        Tensors.append(T)
         if n > 1:
-            diff.append((Tlist[-1] - Tlist[-2]).norm())
+            diff.append((Tensors[-1] - Tensors[-2]).norm())
             if diff[-1] < threshold:
                 # Below threshold for truncation
                 break
-    return Tlist, diff
+    return Tensors, diff
diff --git a/qutip/tests/test_transfertensor.py b/qutip/tests/solver/test_transfertensor.py
similarity index 100%
rename from qutip/tests/test_transfertensor.py
rename to qutip/tests/solver/test_transfertensor.py

From c2aca31e49161dffd0f10ac9a3eaa3a844d574d9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 12:15:20 -0400
Subject: [PATCH 237/602] Clean transfertensor tests

---
 qutip/tests/solver/test_transfertensor.py | 37 +++++++++++------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/qutip/tests/solver/test_transfertensor.py b/qutip/tests/solver/test_transfertensor.py
index c736ef04ac..6d4fd4f070 100644
--- a/qutip/tests/solver/test_transfertensor.py
+++ b/qutip/tests/solver/test_transfertensor.py
@@ -1,5 +1,5 @@
 import pytest
-import qutip as qt
+import qutip
 import numpy as np
 from qutip.solve.nonmarkov.transfertensor import ttmsolve
 
@@ -11,35 +11,34 @@ def test_ttmsolve_jc_model():
     """
     # Define Hamiltonian and states
     N, kappa, g = 3, 1.0, 10
-    a = qt.tensor(qt.qeye(2), qt.destroy(N))
-    sm = qt.tensor(qt.sigmam(), qt.qeye(N))
-    sz = qt.tensor(qt.sigmaz(), qt.qeye(N))
+    a = qutip.tensor(qutip.qeye(2), qutip.destroy(N))
+    sm = qutip.tensor(qutip.sigmam(), qutip.qeye(N))
+    sz = qutip.tensor(qutip.sigmaz(), qutip.qeye(N))
     H = g * (a.dag() * sm + a * sm.dag())
     c_ops = [np.sqrt(kappa) * a]
     # identity superoperator
-    Id = qt.tensor(qt.qeye(2), qt.qeye(N))
-    E0 = qt.sprepost(Id, Id)
+    Id = qutip.tensor(qutip.qeye(2), qutip.qeye(N))
+    E0 = qutip.sprepost(Id, Id)
     # partial trace superoperator
-    ptracesuper = qt.tensor_contract(E0, (1, N))
+    ptracesuper = qutip.tensor_contract(E0, (1, N))
     # initial states
-    rho0a = qt.ket2dm(qt.basis(2, 0))
-    psi0c = qt.basis(N, 0)
-    rho0c = qt.ket2dm(psi0c)
-    rho0 = qt.tensor(rho0a, rho0c)
-    superrho0cav = qt.sprepost(qt.tensor(qt.qeye(2), psi0c),
-                               qt.tensor(qt.qeye(2), psi0c.dag()))
+    rho0a = qutip.ket2dm(qutip.basis(2, 0))
+    psi0c = qutip.basis(N, 0)
+    rho0c = qutip.ket2dm(psi0c)
+    rho0 = qutip.tensor(rho0a, rho0c)
+    superrho0cav = qutip.sprepost(
+        qutip.tensor(qutip.qeye(2), psi0c), qutip.tensor(qutip.qeye(2), psi0c.dag())
+    )
 
     # calculate exact solution using mesolve
     times = np.arange(0, 5.0, 0.1)
-    exactsol = qt.mesolve(H, rho0, times, c_ops, [])
-    exact_z = qt.expect(sz, exactsol.states)
+    exactsol = qutip.mesolve(H, rho0, times, c_ops, [sz])
 
     # solve using transfer method
     learning_times = np.arange(0, 2.0, 0.1)
-    Et_list = qt.mesolve(H, E0, learning_times, c_ops, []).states
+    Et_list = qutip.mesolve(H, E0, learning_times, c_ops, []).states
     learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
-    ttmsol = ttmsolve(learning_maps, rho0a, times)
-    ttm_z = qt.expect(qt.sigmaz(), ttmsol.states)
+    ttmsol = ttmsolve(learning_maps, rho0a, times, e_ops=[sz])
 
     # check that ttm result and exact solution are close in the learning times
-    assert np.allclose(ttm_z, exact_z, atol=1e-5)
+    assert np.allclose(ttmsol.expect[0], exactsol.expect[0], atol=1e-5)

From 045051b1de65a717c53d1c21974e5fc61563d416 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 12:27:52 -0400
Subject: [PATCH 238/602] Add test

---
 qutip/tests/solver/test_transfertensor.py | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/qutip/tests/solver/test_transfertensor.py b/qutip/tests/solver/test_transfertensor.py
index 6d4fd4f070..08687542e5 100644
--- a/qutip/tests/solver/test_transfertensor.py
+++ b/qutip/tests/solver/test_transfertensor.py
@@ -1,10 +1,11 @@
 import pytest
 import qutip
 import numpy as np
-from qutip.solve.nonmarkov.transfertensor import ttmsolve
+from qutip.solver.nonmarkov.transfertensor import ttmsolve
 
 
-def test_ttmsolve_jc_model():
+@pytest.mark.parametrize("call", [True, False])
+def test_ttmsolve_jc_model(call):
     """
     Checks the output of ttmsolve using an example from Jaynes-Cumming model,
     which can also be found in the qutip-notebooks repository.
@@ -34,11 +35,19 @@ def test_ttmsolve_jc_model():
     times = np.arange(0, 5.0, 0.1)
     exactsol = qutip.mesolve(H, rho0, times, c_ops, [sz])
 
+    if call:
+        learning_times = np.arange(0, 2.0, 0.1)
+        Et_list = qutip.mesolve(H, E0, learning_times, c_ops, []).states
+        learning_maps = [ptracesuper @ Et @ superrho0cav for Et in Et_list]
+        opt = {}
+    else:
+        prop = qutip.Propagator(qutip.liouvillian(H, c_ops))
+        opt = {"num_learning": 21}
+        def learning_maps(t):
+            return ptracesuper @ prop(t) @ superrho0cav
+
     # solve using transfer method
-    learning_times = np.arange(0, 2.0, 0.1)
-    Et_list = qutip.mesolve(H, E0, learning_times, c_ops, []).states
-    learning_maps = [ptracesuper * (Et * superrho0cav) for Et in Et_list]
-    ttmsol = ttmsolve(learning_maps, rho0a, times, e_ops=[sz])
+    ttmsol = ttmsolve(learning_maps, rho0a, times, e_ops=[qutip.sigmaz()], options=opt)
 
     # check that ttm result and exact solution are close in the learning times
     assert np.allclose(ttmsol.expect[0], exactsol.expect[0], atol=1e-5)

From 397e4025e1e766e60a0bdfb4456044804bec775d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 12:31:53 -0400
Subject: [PATCH 239/602] Update apidoc link

---
 doc/apidoc/functions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 2d3769aa07..63e9f1e555 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -255,7 +255,7 @@ Quantum Process Tomography
 Non-Markovian Solvers
 =====================
 
-.. automodule:: qutip.solver.transfertensor
+.. automodule:: qutip.solver.nonmarkov.transfertensor
     :members: ttmsolve
 
 

From 7af3dab6e0538c361ef6c64c72ba138ac01e25ed Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 13:59:01 -0400
Subject: [PATCH 240/602] Improve error message

---
 qutip/solver/nonmarkov/transfertensor.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/nonmarkov/transfertensor.py b/qutip/solver/nonmarkov/transfertensor.py
index f16f501da4..b5fcaf8aab 100644
--- a/qutip/solver/nonmarkov/transfertensor.py
+++ b/qutip/solver/nonmarkov/transfertensor.py
@@ -77,7 +77,7 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         opt.update(options)
 
     if not np.allclose(np.diff(times), times[1] - times[0]):
-        raise ValueError
+        raise ValueError("The time should be uniformily distributed.")
 
     if callable(dynmaps):
         if not options["num_learning"]:
@@ -88,7 +88,7 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         dynmaps = [dynmaps(t) for t in times[: opt["num_learning"]]]
 
     if not dynmaps[0].issuper:
-        raise ValueError("dynmaps must be super operators.")
+        raise ValueError("`dynmaps` entries must be super operators.")
 
     start = time.time()
     tensors, diff = _generatetensors(dynmaps, opt["threshold"])

From a4bb1b08e1d91c8c5457c7c6c7f166a337aa3cee Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 14:25:38 -0400
Subject: [PATCH 241/602] Add towncrier entry

---
 doc/changes/2142.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2142.misc

diff --git a/doc/changes/2142.misc b/doc/changes/2142.misc
new file mode 100644
index 0000000000..ad02786d77
--- /dev/null
+++ b/doc/changes/2142.misc
@@ -0,0 +1 @@
+Migrate `transfertensor.py` to solver

From 485fdb73c4f2f06b43a8875a0e1aed90951f5fdb Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 14:30:16 -0400
Subject: [PATCH 242/602] pep8: 80 line width

---
 qutip/solver/nonmarkov/transfertensor.py | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/qutip/solver/nonmarkov/transfertensor.py b/qutip/solver/nonmarkov/transfertensor.py
index b5fcaf8aab..b52bdc25d1 100644
--- a/qutip/solver/nonmarkov/transfertensor.py
+++ b/qutip/solver/nonmarkov/transfertensor.py
@@ -17,15 +17,15 @@
 
 def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
     """
-    Expand time-evolution using the Transfer Tensor Method [1]_, based on a set of
-    precomputed dynamical maps.
+    Expand time-evolution using the Transfer Tensor Method [1]_, based on a set
+    of precomputed dynamical maps.
 
     Parameters
     ----------
     dynmaps : list of :class:`qutip.Qobj`, callable
-        List of precomputed dynamical maps (superoperators) for the first times of
-        ``times`` or a callback function that returns the superoperator at a given
-        time.
+        List of precomputed dynamical maps (superoperators) for the first times
+        of ``times`` or a callback function that returns the superoperator at a
+        given time.
 
     state0 : :class:`qutip.Qobj`
         Initial density matrix or state vector (ket).
@@ -53,10 +53,11 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         - normalize_output : bool
           Normalize output state to hide ODE numerical errors.
         - threshold : float
-          Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below treshold.
+          Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
+          treshold.
         - num_learning : int
-          Number of times used to construct the dynmaps operators when ``dynmaps`` is a
-          callable.
+          Number of times used to construct the dynmaps operators when
+          ``dynmaps`` is a callable.
 
     Returns
     -------
@@ -82,8 +83,8 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
     if callable(dynmaps):
         if not options["num_learning"]:
             raise ValueError(
-                "When dynmaps is a callable, options['num_learning'] must be the "
-                "number of dynamical maps to compute."
+                "When dynmaps is a callable, options['num_learning'] must be "
+                "the number of dynamical maps to compute."
             )
         dynmaps = [dynmaps(t) for t in times[: opt["num_learning"]]]
 
@@ -147,7 +148,8 @@ def _generatetensors(dynmaps, threshold):
         specified in `learningtimes`.
 
     threshold : float
-        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below treshold.
+        Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
+        treshold.
 
     Returns
     -------

From 82feb3df8db9e090ebe6ba70bb8e11de007e4f0a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 30 Mar 2023 16:37:28 -0400
Subject: [PATCH 243/602] Remove run_test_suite, assert_, and add missing
 __all__

---
 qutip/core/cy/coefficient.pyx           |  3 ++
 qutip/core/data/solve.py                |  3 ++
 qutip/solver/integrator/explicit_rk.pyx |  4 ++
 qutip/tests/solve/test_piqs.py          | 16 ++----
 qutip/tests/solver/test_scattering.py   |  1 -
 qutip/tests/test_openmp.py              | 12 ++---
 qutip/tests/test_partial_transpose.py   | 13 ++---
 qutip/tests/test_qpt.py                 |  8 +--
 qutip/tests/test_subsys_apply.py        | 17 +++----
 qutip/tests/test_three_level.py         |  5 +-
 qutip/tests/test_wigner.py              | 67 ++++++++++++-------------
 11 files changed, 68 insertions(+), 81 deletions(-)

diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 79fd84e5ae..1a82de4474 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -13,6 +13,9 @@ cdef extern from "<complex>" namespace "std" nogil:
     double         norm(double complex x)
 
 
+__all__ = []
+
+
 def coefficient_function_parameters(func, style=None):
     """
     Return the function style (either "pythonic" or not) and a list of
diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index a164d4f745..390ff5c800 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -9,6 +9,9 @@
     mkl_spsolve = None
 
 
+__all__ = ["solve_csr_dense", "solve_dense", "solve"]
+
+
 def _splu(A, B, **kwargs):
     lu = splinalg.splu(A, **kwargs)
     return lu.solve(B)
diff --git a/qutip/solver/integrator/explicit_rk.pyx b/qutip/solver/integrator/explicit_rk.pyx
index 17220ea25a..c5758405c1 100644
--- a/qutip/solver/integrator/explicit_rk.pyx
+++ b/qutip/solver/integrator/explicit_rk.pyx
@@ -14,6 +14,10 @@ from .verner9efficient import vern9_coeff
 cimport cython
 import numpy as np
 
+
+__all__ = ["Explicit_RungeKutta"]
+
+
 euler_coeff = {
     'order': 1,
     'a': np.array([[0.]], dtype=np.float64),
diff --git a/qutip/tests/solve/test_piqs.py b/qutip/tests/solve/test_piqs.py
index a069a2905b..d2cdb00047 100644
--- a/qutip/tests/solve/test_piqs.py
+++ b/qutip/tests/solve/test_piqs.py
@@ -3,8 +3,6 @@
 """
 import numpy as np
 from numpy.testing import (
-    assert_,
-    run_module_suite,
     assert_raises,
     assert_array_equal,
     assert_array_almost_equal,
@@ -130,14 +128,14 @@ def test_dicke_blocks(self):
         true_matrix = (excited(N) + dicke(N, 0.5, 0.5)).unit()
         test_blocks = dicke_blocks(true_matrix)
         test_matrix = Qobj(block_diag(test_blocks))
-        assert_(test_matrix == true_matrix)
+        assert (test_matrix == true_matrix)
         # test 2
         # all elements in block-diagonal matrix
         N = 4
         true_matrix = Qobj(block_matrix(N)).unit()
         test_blocks = dicke_blocks(true_matrix)
         test_matrix = Qobj(block_diag(test_blocks))
-        assert_(test_matrix == true_matrix)
+        assert (test_matrix == true_matrix)
 
     def test_dicke_blocks_full(self):
         """
@@ -148,7 +146,7 @@ def test_dicke_blocks_full(self):
         test_matrix = Qobj(block_diag(test_blocks))
         true_expanded = np.zeros((8, 8))
         true_expanded[0, 0] = 1.0
-        assert_(test_matrix == Qobj(true_expanded))
+        assert (test_matrix == Qobj(true_expanded))
 
     def test_dicke_function_trace(self):
         """
@@ -567,10 +565,10 @@ def test_j_min_(self):
         odd = [1, 3, 5, 7]
 
         for i in even:
-            assert_(j_min(i) == 0)
+            assert (j_min(i) == 0)
 
         for i in odd:
-            assert_(j_min(i) == 0.5)
+            assert (j_min(i) == 0.5)
 
     def test_energy_degeneracy(self):
         """
@@ -1530,7 +1528,3 @@ def test_pisolve(self):
         no_hamiltonian_system = Dicke(4, emission=0.1)
         result = no_hamiltonian_system.pisolve(diag_initial_state, tlist)
         assert_equal(True, len(result.states) > 0)
-
-
-if __name__ == "__main__":
-    run_module_suite()
diff --git a/qutip/tests/solver/test_scattering.py b/qutip/tests/solver/test_scattering.py
index 0ad7257ec4..3fa41c4a53 100644
--- a/qutip/tests/solver/test_scattering.py
+++ b/qutip/tests/solver/test_scattering.py
@@ -7,7 +7,6 @@
 # Contact: benbartlett@stanford.edu
 
 import numpy as np
-from numpy.testing import assert_, run_module_suite
 from qutip import create, destroy, basis
 from qutip.solver.scattering import *
 
diff --git a/qutip/tests/test_openmp.py b/qutip/tests/test_openmp.py
index 05804ca5e9..592ab54692 100644
--- a/qutip/tests/test_openmp.py
+++ b/qutip/tests/test_openmp.py
@@ -1,5 +1,5 @@
 import numpy as np
-from numpy.testing import assert_equal, assert_, run_module_suite
+from numpy.testing import assert_equal
 import unittest
 from qutip import *
 from qutip.settings import settings as qset
@@ -18,7 +18,7 @@ def test_openmp_spmv():
         out_openmp = np.zeros_like(vec)
         _spmvpy(L.data, L.indices, L.indptr, vec, 1, out)
         _spmvpy_openmp(L.data, L.indices, L.indptr, vec, 1, out_openmp, 2)
-        assert_(np.allclose(out, out_openmp, 1e-15))
+        assert (np.allclose(out, out_openmp, 1e-15))
 
 # @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
 @unittest.skipIf(True, 'OPENMP disabled.')
@@ -61,8 +61,8 @@ def test_openmp_mesolve():
     out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
     opts = SolverOptions(use_openmp=True)
     out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+    assert (np.allclose(out.expect[0],out_omp.expect[0]))
+    assert (np.allclose(out.expect[1],out_omp.expect[1]))
 
 
 # @unittest.skipIf(qset.has_openmp == False, 'OPENMP not available.')
@@ -107,5 +107,5 @@ def test_openmp_mesolve_td():
     out_omp = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
     opts = SolverOptions(use_openmp=False)
     out = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a, sm.dag() * sm], options=opts)
-    assert_(np.allclose(out.expect[0],out_omp.expect[0]))
-    assert_(np.allclose(out.expect[1],out_omp.expect[1]))
+    assert (np.allclose(out.expect[0],out_omp.expect[0]))
+    assert (np.allclose(out.expect[1],out_omp.expect[1]))
diff --git a/qutip/tests/test_partial_transpose.py b/qutip/tests/test_partial_transpose.py
index 02d3fec328..c9aa1c10ed 100644
--- a/qutip/tests/test_partial_transpose.py
+++ b/qutip/tests/test_partial_transpose.py
@@ -3,7 +3,6 @@
 """
 
 import numpy as np
-from numpy.testing import assert_, run_module_suite
 
 from qutip import Qobj, partial_transpose, tensor, rand_dm
 from qutip.partial_transpose import _partial_transpose_reference
@@ -16,7 +15,7 @@ def test_partial_transpose_bipartite():
 
     # no transpose
     rho_pt = partial_transpose(rho, [0, 0])
-    assert_(np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
+    assert (np.abs(np.max(rho_pt.full() - rho.full())) < 1e-12)
 
     # partial transpose subsystem 1
     rho_pt = partial_transpose(rho, [1, 0])
@@ -24,7 +23,7 @@ def test_partial_transpose_bipartite():
                                 [4, 5, 12, 13],
                                 [2, 3, 10, 11],
                                 [6, 7, 14, 15]])
-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+    assert (np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
 
     # partial transpose subsystem 2
     rho_pt = partial_transpose(rho, [0, 1])
@@ -32,11 +31,11 @@ def test_partial_transpose_bipartite():
                                 [1, 5, 3, 7],
                                 [8, 12, 10, 14],
                                 [9, 13, 11, 15]])
-    assert_(np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
+    assert (np.abs(np.max(rho_pt.full() - rho_pt_expected)) < 1e-12)
 
     # full transpose
     rho_pt = partial_transpose(rho, [1, 1])
-    assert_(np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
+    assert (np.abs(np.max(rho_pt.full() - rho.trans().full())) < 1e-12)
 
 
 def test_partial_transpose_comparison():
@@ -72,7 +71,3 @@ def test_partial_transpose_randomized():
 
     rho_pt2 = partial_transpose(rho, mask, method="sparse")
     np.abs(np.max(rho_pt2.full() - rho_pt_ref.full())) < 1e-12
-
-
-if __name__ == "__main__":
-    run_module_suite()
diff --git a/qutip/tests/test_qpt.py b/qutip/tests/test_qpt.py
index c2d092e207..aada73a324 100644
--- a/qutip/tests/test_qpt.py
+++ b/qutip/tests/test_qpt.py
@@ -1,5 +1,4 @@
 import numpy as np
-from numpy.testing import assert_, run_module_suite
 import scipy.linalg as la
 
 from qutip import spre, spost, qeye, sigmax, sigmay, sigmaz, qpt
@@ -19,7 +18,7 @@ def test_qpt_snot():
     chi2 = np.zeros((2 ** (2 * N), 2 ** (2 * N)), dtype=complex)
     chi2[1, 1] = chi2[1, 3] = chi2[3, 1] = chi2[3, 3] = 0.5
 
-    assert_(la.norm(chi2 - chi1) < 1e-8)
+    assert (la.norm(chi2 - chi1) < 1e-8)
 
 
 def test_qpt_cnot():
@@ -44,7 +43,4 @@ def test_qpt_cnot():
     chi2[12, 12] = chi2[13, 13] = 0.25
     chi2[13, 12] = chi2[12, 13] = -0.25
 
-    assert_(la.norm(chi2 - chi1) < 1e-8)
-
-if __name__ == "__main__":
-    run_module_suite()
+    assert (la.norm(chi2 - chi1) < 1e-8)
diff --git a/qutip/tests/test_subsys_apply.py b/qutip/tests/test_subsys_apply.py
index ed85466625..72756ce460 100644
--- a/qutip/tests/test_subsys_apply.py
+++ b/qutip/tests/test_subsys_apply.py
@@ -1,5 +1,4 @@
 from numpy.linalg import norm
-from numpy.testing import assert_, run_module_suite
 
 from qutip import (
     Qobj, tensor, vector_to_operator, operator_to_vector, kraus_to_super,
@@ -28,7 +27,7 @@ def test_SimpleSingleApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
+        assert (naive_diff_norm < tol,
                 msg="SimpleSingle: naive_diff_norm {} "
                     "is beyond tolerance {}".format(
                         naive_diff_norm, tol))
@@ -36,7 +35,7 @@ def test_SimpleSingleApply(self):
         efficient_result = subsystem_apply(rho_3, single_op, [True])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
+        assert (efficient_diff_norm < tol,
                 msg="SimpleSingle: efficient_diff_norm {} "
                     "is beyond tolerance {}".format(
                         efficient_diff_norm, tol))
@@ -54,7 +53,7 @@ def test_SimpleSuperApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
+        assert (naive_diff_norm < tol,
                 msg="SimpleSuper: naive_diff_norm {} "
                     "is beyond tolerance {}".format(
                         naive_diff_norm, tol))
@@ -62,7 +61,7 @@ def test_SimpleSuperApply(self):
         efficient_result = subsystem_apply(rho_3, superop, [True])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
+        assert (efficient_diff_norm < tol,
                 msg="SimpleSuper: efficient_diff_norm {} "
                     "is beyond tolerance {}".format(
                         efficient_diff_norm, tol))
@@ -86,7 +85,7 @@ def test_ComplexSingleApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
+        assert (naive_diff_norm < tol,
                 msg="ComplexSingle: naive_diff_norm {} "
                     "is beyond tolerance {}".format(
                         naive_diff_norm, tol))
@@ -95,7 +94,7 @@ def test_ComplexSingleApply(self):
                                            [False, True, False, True, False])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
+        assert (efficient_diff_norm < tol,
                 msg="ComplexSingle: efficient_diff_norm {} "
                     "is beyond tolerance {}".format(
                         efficient_diff_norm, tol))
@@ -126,7 +125,7 @@ def test_ComplexSuperApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert_(naive_diff_norm < tol,
+        assert (naive_diff_norm < tol,
                 msg="ComplexSuper: naive_diff_norm {} "
                     "is beyond tolerance {}".format(
                         naive_diff_norm, tol))
@@ -135,7 +134,7 @@ def test_ComplexSuperApply(self):
                                            [False, True, False, True, False])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert_(efficient_diff_norm < tol,
+        assert (efficient_diff_norm < tol,
                 msg="ComplexSuper: efficient_diff_norm {} "
                     "is beyond tolerance {}".format(
                         efficient_diff_norm, tol))
diff --git a/qutip/tests/test_three_level.py b/qutip/tests/test_three_level.py
index 6aee63c071..92b9ca05e1 100644
--- a/qutip/tests/test_three_level.py
+++ b/qutip/tests/test_three_level.py
@@ -1,5 +1,5 @@
 import numpy as np
-from numpy.testing import assert_, assert_equal, run_module_suite
+from numpy.testing import assert_equal
 from qutip import basis
 from qutip.three_level_atom import *
 
@@ -22,6 +22,3 @@ def testThreeOps():
     assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
     assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
     assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
-
-if __name__ == "__main__":
-    run_module_suite()
diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
index 78c5714845..686cc7acb5 100644
--- a/qutip/tests/test_wigner.py
+++ b/qutip/tests/test_wigner.py
@@ -3,7 +3,7 @@
 import itertools
 from scipy.special import laguerre
 from numpy.random import rand
-from numpy.testing import assert_, run_module_suite, assert_equal, \
+from numpy.testing import assert , assert_equal, \
     assert_almost_equal, assert_allclose
 
 import qutip
@@ -264,7 +264,7 @@ def test_wigner_bell1_su2parity():
 
     wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
 
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+    assert (np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
 
 
 @pytest.mark.slow
@@ -283,7 +283,7 @@ def test_wigner_bell4_su2parity():
 
     wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
 
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+    assert (np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
 
 
 @pytest.mark.slow
@@ -302,17 +302,17 @@ def test_wigner_bell4_fullparity():
             wigner_analyt[t, p] = -0.30901699
 
     wigner_theo = wigner_transform(psi, 0.5, True, steps, slicearray)
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
+    assert (np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-4)
 
 
 def test_parity():
     """wigner: testing the parity function.
     """
     j = 0.5
-    assert_(_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
-    assert_(_parity(2, j)[0, 1] < 1e-11)
-    assert_(_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
-    assert_(_parity(2, j)[1, 0] < 1e-11)
+    assert (_parity(2, j)[0, 0] - (1 - np.sqrt(3)) / 2. < 1e-11)
+    assert (_parity(2, j)[0, 1] < 1e-11)
+    assert (_parity(2, j)[1, 1] - (1 + np.sqrt(3)) / 2. < 1e-11)
+    assert (_parity(2, j)[1, 0] < 1e-11)
 
 
 @pytest.mark.slow
@@ -334,7 +334,7 @@ def test_wigner_pure_su2():
 
     wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
 
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+    assert (np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
 
 
 @pytest.mark.slow
@@ -378,7 +378,7 @@ def test_wigner_ghz_su2parity():
 
     wigner_theo = wigner_transform(psi, 0.5, False, steps, slicearray)
 
-    assert_(np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
+    assert (np.sum(np.abs(wigner_analyt - wigner_theo)) < 1e-11)
 
 
 @pytest.mark.slow
@@ -398,10 +398,10 @@ def test_angle_slicing():
     wigner3 = wigner_transform(psi3, j, False, steps, ['l', 'x'])
     wigner4 = wigner_transform(psi4, j, False, steps, ['l', 'y'])
 
-    assert_(np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
-    assert_(np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
-    assert_(np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
-    assert_(np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
+    assert (np.sum(np.abs(wigner2 - wigner1)) < 1e-11)
+    assert (np.sum(np.abs(wigner3 - wigner2)) < 1e-11)
+    assert (np.sum(np.abs(wigner4 - wigner3)) < 1e-11)
+    assert (np.sum(np.abs(wigner4 - wigner1)) < 1e-11)
 
 
 def test_wigner_coherent():
@@ -426,13 +426,13 @@ def test_wigner_coherent():
     W_analytic = 2 / np.pi * np.exp(-2 * abs(a - beta) ** 2)
 
     # check difference
-    assert_(np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
-    assert_(np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
+    assert (np.sum(abs(W_qutip - W_analytic) ** 2) < 1e-4)
+    assert (np.sum(abs(W_qutip_cl - W_analytic) ** 2) < 1e-4)
 
     # check normalization
-    assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-    assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-    assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+    assert (np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+    assert (np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+    assert (np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
 
 
 def test_wigner_fock():
@@ -462,15 +462,15 @@ def test_wigner_fock():
             np.exp(-2 * abs(a) ** 2) * np.polyval(laguerre(n), 4 * abs(a) ** 2)
 
         # check difference
-        assert_(np.sum(abs(W_qutip - W_analytic)) < 1e-4)
-        assert_(np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
-        assert_(np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
+        assert (np.sum(abs(W_qutip - W_analytic)) < 1e-4)
+        assert (np.sum(abs(W_qutip_cl - W_analytic)) < 1e-4)
+        assert (np.sum(abs(W_qutip_sparse - W_analytic)) < 1e-4)
 
         # check normalization
-        assert_(np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip_cl) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip_sparse) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_analytic) * dx * dy - 1.0 < 1e-8)
 
 
 def test_wigner_compare_methods_dm():
@@ -498,11 +498,11 @@ def test_wigner_compare_methods_dm():
         W_qutip2 = wigner(rho, xvec, yvec, g=2, method='laguerre')
 
         # check difference
-        assert_(np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
+        assert (np.sum(abs(W_qutip1 - W_qutip1)) < 1e-4)
 
         # check normalization
-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
 
 
 def test_wigner_compare_methods_ket():
@@ -530,11 +530,11 @@ def test_wigner_compare_methods_ket():
         W_qutip2 = wigner(psi, xvec, yvec, g=2, sparse=True)
 
         # check difference
-        assert_(np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
+        assert (np.sum(abs(W_qutip1 - W_qutip2)) < 1e-4)
 
         # check normalization
-        assert_(np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
-        assert_(np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip1) * dx * dy - 1.0 < 1e-8)
+        assert (np.sum(W_qutip2) * dx * dy - 1.0 < 1e-8)
 
 
 def test_wigner_fft_comparse_ket():
@@ -688,6 +688,3 @@ def test_spin_wigner_overlap(spin, pure, n=5):
         W_overlap = np.trapz(
             np.trapz(W_state * W * np.sin(THETA), theta), phi).real
         assert_almost_equal(W_overlap, state_overlap, decimal=4)
-
-if __name__ == "__main__":
-    run_module_suite()

From 83271d0fc78abd5f4c74fa20d0b5b77a0a4d936b Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Thu, 30 Mar 2023 23:08:13 +0200
Subject: [PATCH 244/602] Example in code block and better formatting

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 1eaf80cd06..7926a25f7f 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -284,13 +284,12 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
 .. note::
-    While the code example  simulates the Bloch-Redfield in the secular approximation, Qutip's implementation
-    allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting the sec_cutoff 
-    parameter to -1. as well as do a partial secular approximation by setting it to a  float. the default value is 0.1
-    for example the command
-
-     output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(),ohmic_spectrum]], e_ops=e_ops,sec_cutoff=-1)
+    While the code example simulates the Bloch-Redfield equation in the secular approximation, qutip's implementation allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting ``sec_cutoff=-1``, as well as do a partial secular approximation by setting it to a  ``float`` meaning a higher cutoff, its default value is 0.1 which corresponds to the secular approximation.
+    For example the command
+    ::
 
+        output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(),ohmic_spectrum]], e_ops=e_ops,sec_cutoff=-1)
+    
     will simulate the same example as above without the secular approximation. Note that using the non-secular version may lead to negativity issues.
 
 .. _td-bloch-redfield:

From 25e1f18723d4688b7e5e9f26e7c7c9b0b7fb9772 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Thu, 30 Mar 2023 23:10:31 +0200
Subject: [PATCH 245/602] capitalization

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 7926a25f7f..938ecb7417 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -284,7 +284,7 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
 .. note::
-    While the code example simulates the Bloch-Redfield equation in the secular approximation, qutip's implementation allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting ``sec_cutoff=-1``, as well as do a partial secular approximation by setting it to a  ``float`` meaning a higher cutoff, its default value is 0.1 which corresponds to the secular approximation.
+    While the code example simulates the Bloch-Redfield equation in the secular approximation, QuTiP's implementation allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting ``sec_cutoff=-1``, as well as do a partial secular approximation by setting it to a  ``float`` meaning a higher cutoff, its default value is 0.1 which corresponds to the secular approximation.
     For example the command
     ::
 

From bd8ce57040b9e06f45dc4ff5890f3db91a1f3174 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 30 Mar 2023 23:42:02 +0200
Subject: [PATCH 246/602] Add a constant coefficient and expose conj, norm and
 const.

---
 qutip/core/coefficient.py     | 14 +++++++++++-
 qutip/core/cy/coefficient.pyx | 40 +++++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index d029461f1a..807cdc22eb 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -24,7 +24,7 @@
 from .data import Data
 from .cy.coefficient import (
     Coefficient, InterCoefficient, FunctionCoefficient, StrFunctionCoefficient,
-    ConjCoefficient, NormCoefficient
+    ConjCoefficient, NormCoefficient, ConstantCoefficient
 )
 
 
@@ -191,6 +191,18 @@ def conj(coeff):
     return ConjCoefficient(coeff)
 
 
+def const(value):
+    """ return a Coefficient with a constant value.
+    """
+    return ConstantCoefficient(value)
+
+
+# XXX: HACKITY HACK
+coefficient.norm = norm
+coefficient.conj = conj
+coefficient.const = const
+
+
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 # %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 79fd84e5ae..c6c86142fe 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -726,3 +726,43 @@ cdef class NormCoefficient(Coefficient):
     cpdef Coefficient copy(self):
         """Return a copy of the :obj:`Coefficient`."""
         return NormCoefficient(self.base.copy())
+
+
+@cython.auto_pickle(True)
+cdef class ConstantCoefficient(Coefficient):
+    """
+    A time-independent coefficient.
+
+    :obj:`ConstantCoefficient` is returned by ``qutip.coefficent.const(value)``.
+    """
+    cdef complex value
+
+    def __init__(self, complex value):
+        self.value = value
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        return self
+
+    cdef complex _call(self, double t) except *:
+        return self.value
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return self

From 3858895dff042ce7c1af5bbb925755df646608e2 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 31 Mar 2023 00:02:43 +0200
Subject: [PATCH 247/602] Add RateShiftCoefficient and
 SqrtShiftedRateCoefficient.

---
 qutip/solver/cy/__init__.py    |   0
 qutip/solver/cy/nm_mcsolve.pxd |  17 ++++
 qutip/solver/cy/nm_mcsolve.pyx | 157 +++++++++++++++++++++++++++++++++
 3 files changed, 174 insertions(+)
 create mode 100644 qutip/solver/cy/__init__.py
 create mode 100644 qutip/solver/cy/nm_mcsolve.pxd
 create mode 100644 qutip/solver/cy/nm_mcsolve.pyx

diff --git a/qutip/solver/cy/__init__.py b/qutip/solver/cy/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/qutip/solver/cy/nm_mcsolve.pxd b/qutip/solver/cy/nm_mcsolve.pxd
new file mode 100644
index 0000000000..284afdb031
--- /dev/null
+++ b/qutip/solver/cy/nm_mcsolve.pxd
@@ -0,0 +1,17 @@
+#cython: language_level=3
+from qutip.core.cy.coefficient cimport Coefficient
+
+
+cdef class RateShiftCoefficient(Coefficient):
+    cdef:
+        Coefficient [:] rate_coeffs
+
+    cpdef double rate_shift(self, double t) except *
+    cpdef Coefficient sqrt_shifted_rate(self, int i)
+    cpdef double discrete_martingale(self, double[:] collapse_times, int[:] collapse_idx) except *
+
+
+cdef class SqrtShiftedRateCoefficient(Coefficient):
+    cdef:
+        int rate_idx
+        RateShiftCoefficient rate_shift
diff --git a/qutip/solver/cy/nm_mcsolve.pyx b/qutip/solver/cy/nm_mcsolve.pyx
new file mode 100644
index 0000000000..ff9448668c
--- /dev/null
+++ b/qutip/solver/cy/nm_mcsolve.pyx
@@ -0,0 +1,157 @@
+#cython: language_level=3
+
+import numpy as np
+
+from qutip.core.cy.coefficient cimport Coefficient
+
+cdef extern from "<complex>" namespace "std" nogil:
+    double real(double complex x)
+
+
+cdef class RateShiftCoefficient(Coefficient):
+    """
+    A coefficient representing the rate shift required by
+    NonMarkovianMCSolver.
+    """
+    def __init__(self, Coefficient[:] rate_coeffs):
+        self.rate_coeffs = rate_coeffs
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        if not kwargs:
+            return self
+        cdef Coefficient[:] new_coeffs = np.array([
+            coeff.replace_arguments(_args, **kwargs)
+            for coeff in self.rate_coeffs
+        ], dtype=Coefficient)
+        return RateShiftCoefficient(new_coeffs)
+
+    cdef complex _call(self, double t) except *:
+        return self.rate_shift(t)
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        cdef Coefficient[:] new_coeffs = np.array([
+            coeff.copy()
+            for coeff in self.rate_coeffs
+        ], dtype=Coefficient)
+        return RateShiftCoefficient(new_coeffs)
+
+    def __reduce__(self):
+        return (RateShiftCoefficient, (self.rates,))
+
+    cpdef double rate_shift(self, double t) except *:
+        """ Calculate the rate shift required to make the shifted rates
+            positive.
+
+            Returns twice the absoluate value of the minimum unshifted rates.
+        """
+        cdef int N = len(self.rate_coeffs)
+        cdef min_rate = 0
+        cdef Coefficient coeff
+
+        for i in range(N):
+            coeff = self.rate_coeffs[i]
+            min_rate = min(min_rate, real(coeff._call(t)))
+
+        return 2 * abs(min_rate)
+
+    cpdef Coefficient sqrt_shifted_rate(self, int i):
+        """ Return a :obj:`Coefficient` to calculate the shifted rate of the i'th
+            Lindblad operator.
+        """
+        return SqrtShiftedRateCoefficient(i, self)
+
+    cpdef double discrete_martingale(self, double[:] collapse_times, int[:] collapse_idx) except *:
+        """
+        Discrete part of the martingale evolution. The collapses that have
+        happened until now must be provided as a list of (t_k, i_k).
+        """
+        cdef int N = len(collapse_times)
+        cdef double martingale = 1.0
+        cdef double t_i
+        cdef double rate_i
+        cdef double shift_i
+        cdef Coefficient coeff
+
+        for i in range(N):
+            t_i = collapse_times[i]
+            coeff = self.rate_coeffs[collapse_idx[i]]
+            shift_i = self.rate_shift(t_i)
+            rate_i = real(coeff._call(t_i))
+            martingale *= rate_i / (rate_i + shift_i)
+
+        return martingale
+
+
+cdef class SqrtShiftedRateCoefficient(Coefficient):
+    """
+    A coefficient representing the square root of the shifted
+    rates used by NonMarkovianMCSolver.
+    """
+    def __init__(self, int rate_idx, RateShiftCoefficient rate_shift):
+        self.rate_idx = rate_idx
+        self.rate_shift = rate_shift
+
+    def replace_arguments(self, _args=None, **kwargs):
+        """
+        Replace the arguments (``args``) of a coefficient.
+
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
+
+        Parameters
+        ----------
+        _args : dict
+            Dictionary of arguments to replace.
+
+        **kwargs
+            Arguments to replace.
+        """
+        if _args:
+            kwargs.update(_args)
+        if not kwargs:
+            return self
+        return SqrtShiftedRateCoefficient(
+            self.rate_idx,
+            self.rate_shift.replace_arguments(_args, **kwargs),
+        )
+
+    cdef complex _call(self, double t) except *:
+        """Return the shifted rate."""
+        cdef Coefficient coeff = self.rate_shift.rate_coeffs[self.rate_idx]
+        return np.sqrt(
+            real(coeff._call(t)) +
+            self.rate_shift.rate_shift(t)
+        )
+
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return SqrtShiftedRateCoefficient(
+            self.rate_idx,
+            self.rate_shift.copy(),
+        )
+
+    def __reduce__(self):
+        return (SqrtShiftedRateCoefficient, (self.rate_idx, self.rate_shift))

From 976a3eb8cae23d7272cc9d80efe10705de697b34 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Fri, 31 Mar 2023 00:04:28 +0200
Subject: [PATCH 248/602] Add support for arguments and coefficients to
 nm_mcsolve.

---
 qutip/solver/nm_mcsolve.py | 118 +++++++++++++++++++++++--------------
 1 file changed, 74 insertions(+), 44 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 80dd68db5d..d5a3a3bb4e 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -1,17 +1,24 @@
 __all__ = ['nm_mcsolve', 'NonMarkovianMCSolver']
 
-from functools import partial
+import functools
+import numbers
+
 import numpy as np
 import scipy
+
 from .multitraj import MultiTrajSolver
 from .mcsolve import MCSolver
 from .mesolve import MESolver, mesolve
 from .result import NmmcResult, NmmcTrajectoryResult
-from ..core import CoreOptions, QobjEvo, isket, ket2dm, qeye
+from .cy.nm_mcsolve import RateShiftCoefficient
+from ..core import (
+    CoreOptions, Qobj, QobjEvo, isket, ket2dm, qeye, coefficient, Coefficient,
+)
 
 
 def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
-               options=None, seeds=None, target_tol=None, timeout=None):
+               args=None, options=None, seeds=None, target_tol=None,
+               timeout=None):
     """
     Monte-Carlo evolution corresponding to a Lindblad equation with "rates"
     that may be negative. Usage of this function is analogous to ``mcsolve``,
@@ -39,7 +46,8 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
         callable. That is, ``Gamma(t)`` returns the rate at time ``t``, which
         is allowed to be negative. The Lindblad operators must be operators
         even if ``H`` is a superoperator. If none are given, the solver will
-        defer to ``sesolve`` or ``mesolve``.
+        defer to ``sesolve`` or ``mesolve``. The ``Gamma(t)`` may be
+        specified using any format accepted by :func:`qutip.coefficient`.
 
     e_ops : list, [optional]
         A ``list`` of operator as Qobj, QobjEvo or callable with signature of
@@ -51,6 +59,9 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
         is passed with the ``timeout`` keyword or if the target tolerance is
         reached, see ``target_tol``.
 
+    args : None / dict
+        Arguments for time-dependent Hamiltonian and collapse operator terms.
+
     options : None / dict
         Dictionary of options for the solver.
 
@@ -131,8 +142,7 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
         field contains the average of their trace, which will converge to one
         in the limit of sufficiently many trajectories.
     """
-    if not isinstance(ops_and_rates, (list, tuple)):
-        ops_and_rates = [ops_and_rates]
+    H = QobjEvo(H, args=args, tlist=tlist)
 
     if len(ops_and_rates) == 0:
         if options is None:
@@ -142,7 +152,14 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
             for key in options
             if key in MESolver.solver_options
         }
-        return mesolve(H, state, tlist, e_ops=e_ops, options=options)
+        return mesolve(
+            H, state, tlist, e_ops=e_ops, args=args, options=options,
+        )
+    else:
+        ops_and_rates = [
+            _parse_op_and_rate(op, rate, tlist=tlist, args=args or {})
+            for op, rate in ops_and_rates
+        ]
 
     nmmc = NonMarkovianMCSolver(H, ops_and_rates, options=options)
     result = nmmc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
@@ -150,6 +167,17 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
     return result
 
 
+def _parse_op_and_rate(op, rate, **kw):
+    """ Sanity check the op and convert rates to coefficients. """
+    if not isinstance(op, Qobj):
+        raise ValueError("NonMarkovianMCSolver ops must be of type Qobj")
+    if isinstance(rate, numbers.Number):
+        rate = coefficient.const(rate)
+    else:
+        rate = coefficient(rate, **kw)
+    return op, rate
+
+
 class NonMarkovianMCSolver(MCSolver):
     """
     Monte Carlo Solver for Lindblad equations with "rates" that may be
@@ -172,6 +200,9 @@ class NonMarkovianMCSolver(MCSolver):
         is allowed to be negative. The Lindblad operators must be operators
         even if ``H`` is a superoperator.
 
+    args : None / dict
+        Arguments for time-dependent Hamiltonian and collapse operator terms.
+
     options : SolverOptions, [optional]
         Options for the evolution.
 
@@ -194,16 +225,28 @@ class NonMarkovianMCSolver(MCSolver):
     trajectory_resultclass = NmmcTrajectoryResult
 
     def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
-        self.trajectory_resultclass = partial(NmmcTrajectoryResult,
-                                              solver=self)
+        # XXX Fix me -- the result class expects solver to be a string
+        #     with the name of the solver, but here it is supplied as
+        #     an object
+        self.trajectory_resultclass = functools.partial(
+            NmmcTrajectoryResult, solver=self,
+        )
+
+        self.ops_and_rates = [
+            _parse_op_and_rate(op, rate)
+            for op, rate in ops_and_rates
+        ]
 
-        self.ops_and_rates = list(ops_and_rates)
         self.options = options
         self._mu_c = None
 
         self._a_parameter, L = self._check_completeness(ops_and_rates)
         if L is not None:
-            self.ops_and_rates.append((L, float))  # float() is zero
+            self.ops_and_rates.append((L, coefficient.const(0)))
+
+        self._rate_shift = RateShiftCoefficient(
+            np.array([f for _, f in self.ops_and_rates], dtype=Coefficient)
+        )
 
         c_ops = self._compute_paired_c_ops()
         super().__init__(H, c_ops, *args, options=options, **kwargs)
@@ -238,21 +281,13 @@ def _compute_paired_c_ops(self):
         as QobjEvo objects.
         """
         c_ops = []
-        for f in self.ops_and_rates:
+        for i, (op, _) in enumerate(self.ops_and_rates):
             # Note that this cannot be done using a lambda expression, since
             # lambda expressions can't be pickled and pickling is required
             # for parallel execution.
-            sqrt_gamma = partial(self._sqrt_gamma, original_rate=f[1])
-            c_ops.append(QobjEvo([f[0], sqrt_gamma]))
+            c_ops.append(QobjEvo([op, self._rate_shift.sqrt_shifted_rate(i)]))
         return c_ops
 
-    def _rate_shift(self, t):
-        min_rate = min(f[1](t) for f in self.ops_and_rates)
-        return 2 * abs(min(0, min_rate))
-
-    def _sqrt_gamma(self, t, original_rate):
-        return np.sqrt(original_rate(t) + self._rate_shift(t))
-
     def _continuous_martingale(self, t):
         """
         Continuous part of the martingale evolution. Checks the stored values
@@ -272,21 +307,11 @@ def _continuous_martingale(self, t):
         except ValueError as exc:
             raise ValueError("Cannot integrate backwards in time.") from exc
 
-        integral = scipy.integrate.quad(self._rate_shift, t0, t)[0]
+        integral = scipy.integrate.quad(self._rate_shift.rate_shift, t0, t)[0]
         result = self._mu_c[t0] * np.exp(self._a_parameter * integral)
         self._mu_c[t] = result
         return result
 
-    def _discrete_martingale(self, collapses):
-        """
-        Discrete part of the martingale evolution. The collapses that have
-        happened until now must be provided as a list of (t_k, i_k).
-        """
-        o_r = self.ops_and_rates
-        factors = [o_r[ik][1](tk) / (o_r[ik][1](tk) + self._rate_shift(tk))
-                   for tk, ik in collapses]
-        return np.prod(factors)
-
     def _current_martingale(self):
         """
         Returns the value of the influence martingale along the current
@@ -295,32 +320,37 @@ def _current_martingale(self):
         collapses that have happened are read out from the internal integrator.
         """
         t, *_ = self._integrator.get_state(copy=False)
-        collapses = self._integrator.collapses
-        return self._continuous_martingale(t) *\
-            self._discrete_martingale(collapses)
+        collapses = np.array(
+            self._integrator.collapses,
+            dtype=[
+                ("time", np.float64),
+                ("idx", np.int32),
+            ]
+        )
+        return (
+            self._continuous_martingale(t) *
+            self._rate_shift.discrete_martingale(
+                collapses["time"], collapses["idx"],
+            )
+        )
 
     # Override "run" and "start" to precompute
     #     continuous part of martingale evolution
     def run(self, state, tlist, *args, **kwargs):
-        if 'args' in kwargs and kwargs['args']:
-            raise RuntimeError("args not supported by nm_mcsolve.")
-
         self._mu_c = {tlist[0]: 1}
-        for t in tlist[1:]:
-            self._continuous_martingale(t)  # precompute self._mu_c
-
         return super().run(state, tlist, *args, **kwargs)
 
     def start(self, state, t0, seed=None):
         self._mu_c = {t0: 1}
         return super().start(state, t0, seed=seed)
 
+    def _argument(self, args):
+        super()._argument(args)
+        self._rate_shift = self._rate_shift.replace_arguments(args)
+
     # Override "step" to include the martingale mu in the state
     # Note that the returned state will be a density matrix with trace=mu
     def step(self, t, *, args=None, copy=True):
-        if args:
-            raise RuntimeError("args not supported by nm_mcsolve.")
-
         state = super().step(t, args=args, copy=copy)
         if isket(state):
             state = ket2dm(state)

From 0871f4ac938332ec0e559d838428b899cdfb4027 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 30 Mar 2023 17:51:15 -0400
Subject: [PATCH 249/602] Fix format

---
 qutip/tests/test_subsys_apply.py | 40 +++++++-------------------------
 qutip/tests/test_wigner.py       |  3 +--
 2 files changed, 9 insertions(+), 34 deletions(-)

diff --git a/qutip/tests/test_subsys_apply.py b/qutip/tests/test_subsys_apply.py
index 72756ce460..bd915d1d9c 100644
--- a/qutip/tests/test_subsys_apply.py
+++ b/qutip/tests/test_subsys_apply.py
@@ -27,18 +27,12 @@ def test_SimpleSingleApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert (naive_diff_norm < tol,
-                msg="SimpleSingle: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
+        assert naive_diff_norm < tol
 
         efficient_result = subsystem_apply(rho_3, single_op, [True])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert (efficient_diff_norm < tol,
-                msg="SimpleSingle: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
+        assert efficient_diff_norm < tol
 
     def test_SimpleSuperApply(self):
         """
@@ -53,18 +47,12 @@ def test_SimpleSuperApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert (naive_diff_norm < tol,
-                msg="SimpleSuper: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
+        assert naive_diff_norm < tol
 
         efficient_result = subsystem_apply(rho_3, superop, [True])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert (efficient_diff_norm < tol,
-                msg="SimpleSuper: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
+        assert efficient_diff_norm < tol
 
     def test_ComplexSingleApply(self):
         """
@@ -85,19 +73,13 @@ def test_ComplexSingleApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert (naive_diff_norm < tol,
-                msg="ComplexSingle: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
+        assert naive_diff_norm < tol
 
         efficient_result = subsystem_apply(rho_input, single_op,
                                            [False, True, False, True, False])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert (efficient_diff_norm < tol,
-                msg="ComplexSingle: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
+        assert efficient_diff_norm < tol
 
     def test_ComplexSuperApply(self):
         """
@@ -125,16 +107,10 @@ def test_ComplexSuperApply(self):
                                        reference=True)
         naive_diff = (analytic_result - naive_result).full()
         naive_diff_norm = norm(naive_diff)
-        assert (naive_diff_norm < tol,
-                msg="ComplexSuper: naive_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        naive_diff_norm, tol))
+        assert naive_diff_norm < tol
 
         efficient_result = subsystem_apply(rho_input, superop,
                                            [False, True, False, True, False])
         efficient_diff = (efficient_result - analytic_result).full()
         efficient_diff_norm = norm(efficient_diff)
-        assert (efficient_diff_norm < tol,
-                msg="ComplexSuper: efficient_diff_norm {} "
-                    "is beyond tolerance {}".format(
-                        efficient_diff_norm, tol))
+        assert efficient_diff_norm < tol
diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
index 686cc7acb5..9ad709a546 100644
--- a/qutip/tests/test_wigner.py
+++ b/qutip/tests/test_wigner.py
@@ -3,8 +3,7 @@
 import itertools
 from scipy.special import laguerre
 from numpy.random import rand
-from numpy.testing import assert , assert_equal, \
-    assert_almost_equal, assert_allclose
+from numpy.testing import assert_equal, assert_almost_equal, assert_allclose
 
 import qutip
 from qutip.core.states import coherent, fock, ket, bell_state

From d596b17665bfda4268080dfa54f8be5a4f5f3206 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 30 Mar 2023 19:06:19 -0400
Subject: [PATCH 250/602] Better coefficient all

---
 qutip/core/cy/coefficient.pyx | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 1a82de4474..0d05d48181 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -13,7 +13,10 @@ cdef extern from "<complex>" namespace "std" nogil:
     double         norm(double complex x)
 
 
-__all__ = []
+__all__ = [
+    "Coefficient",  "InterCoefficient", "FunctionCoefficient",
+    "StrFunctionCoefficient", "ConjCoefficient", "NormCoefficient"
+]
 
 
 def coefficient_function_parameters(func, style=None):

From 57456804fbad34d54b5cbd492338dce31a05044b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 31 Mar 2023 09:59:02 -0400
Subject: [PATCH 251/602] Make data.solve more robust to singular matrices for
 countstats

---
 qutip/core/data/solve.py             | 19 +++++++++++++++++--
 qutip/solver/countstat.py            | 12 ++++++------
 qutip/tests/core/data/test_linalg.py | 23 ++++++++++++++++++-----
 3 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index 390ff5c800..0b731e7670 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -3,6 +3,8 @@
 import scipy.sparse.linalg as splinalg
 import numpy as np
 from qutip.settings import settings
+import warnings
+
 if settings.has_mkl:
     from qutip._mkl.spsolve import mkl_spsolve
 else:
@@ -62,6 +64,10 @@ def solve_csr_dense(matrix: CSR, target: Dense, method=None,
 
     if method == "splu":
         solver = _splu
+    elif method == "lstsq":
+        solver = splinalg.lsqr
+    elif method == "solve":
+        solver = splinalg.spsolve
     elif hasattr(splinalg, method):
         solver = getattr(splinalg, method)
     elif method == "mkl_spsolve" and mkl_spsolve is None:
@@ -76,7 +82,12 @@ def solve_csr_dense(matrix: CSR, target: Dense, method=None,
     if options.pop("csc", False):
         M = M.tocsc()
 
-    out = solver(M, b, **options)
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        try:
+            out = solver(M, b, **options)
+        except splinalg.MatrixRankWarning:
+            raise ValueError("Matrix is singular")
 
     if isinstance(out, tuple) and len(out) == 2:
         # iterative method return a success flag
@@ -138,7 +149,10 @@ def solve_dense(matrix: Dense, target: Data, method=None,
         b = target.to_array()
 
     if method in ["solve", None]:
-        out = np.linalg.solve(matrix.as_ndarray(), b)
+        try:
+            out = np.linalg.solve(matrix.as_ndarray(), b)
+        except np.linalg.LinAlgError:
+            raise ValueError("Matrix is singular")
     elif method == "lstsq":
         out, *_ = np.linalg.lstsq(
             matrix.as_ndarray(),
@@ -185,6 +199,7 @@ def solve_dense(matrix: Dense, target: Data, method=None,
         equation Ax=b from scipy.sparse.linalg (CSR ``matrix``) or
         numpy.linalg (Dense ``matrix``) can be used.
         Sparse cases also accept `splu` and `mkl_spsolve`.
+        `solve` and `lstsq` will work for any data-type.
 
     options : dict
         Keywork options to pass to the solver. Refer to the documenentation
diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 4d4c60af9a..78408058b1 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -10,7 +10,7 @@
 from itertools import product
 from ..core import (
     sprepost, spre, qeye, tensor, expect, Qobj,
-    operator_to_vector, vector_to_operator
+    operator_to_vector, vector_to_operator, CoreOptions
 )
 from ..core import data as _data
 from .steadystate import pseudo_inverse, steadystate
@@ -77,8 +77,8 @@ def countstat_current(L, c_ops=None, rhoss=None, J_ops=None):
 def _solve(A, V):
     try:
         return _data.solve(A, V)
-    except Exception:
-        return _data.solve(A, V, "lsqr")
+    except ValueError:
+        return _data.solve(A, V, "lstsq")
 
 
 def _noise_direct(L, wlist, rhoss, J_ops):
@@ -104,10 +104,10 @@ def _noise_direct(L, wlist, rhoss, J_ops):
             # At zero frequency some solvers fail for small systems.
             # Adding a small finite frequency of order 1e-15
             # helps prevent the solvers from throwing an exception.
-            L_temp = 1e-15j * spre(tr_op) + L
+            with CoreOptions(auto_tidyup=False):
+                L_temp = 1e-15j * spre(tr_op) + L
 
-        A = _data.to(_data.CSR, L_temp.data)
-        X_rho = [_solve(A, op) for op in Q_ops]
+        X_rho = [_solve(L_temp.data, op) for op in Q_ops]
 
         for i, j in product(range(N_j_ops), repeat=2):
             if i == j:
diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index 50729bba9c..fce68580ab 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -8,6 +8,11 @@
 from qutip.core.data import Data, Dense, CSR
 
 
+skip_no_mkl = pytest.mark.skipif(
+    not settings.has_mkl, reason="mkl not available"
+)
+
+
 class TestSolve():
     def op_numpy(self, A, b):
         return np.linalg.solve(A, b)
@@ -23,12 +28,13 @@ def _gen_ket(self, N, dtype):
         ("splu", {"csc": True}),
         ("gmres", {"atol": 1e-8}),
         ("lsqr", {}),
-        pytest.param(
-            "mkl_spsolve", {},
-            marks=pytest.mark.skipif(not settings.has_mkl, reason="mkl not available")
-        ),
+        ("solve", {}),
+        ("lstsq", {}),
+        pytest.param("mkl_spsolve", {}, marks=skip_no_mkl),
     ],
-        ids=["spsolve", "splu", "gmres", "lsqr", "mkl_spsolve"]
+        ids=[
+            "spsolve", "splu", "gmres", "lsqr", "solve", "lstsq", "mkl_spsolve"
+        ]
     )
     def test_mathematically_correct_CSR(self, method, opt):
         """
@@ -65,6 +71,13 @@ def test_mathematically_correct_Dense(self, method, opt):
                                    atol=1e-7, rtol=1e-7)
 
 
+    def test_singular(self):
+        A = qutip.num(2).data
+        b = qutip.basis(2, 1).data
+        with pytest.raises(ValueError):
+            test1 = _data.solve(A, b)
+
+
     def test_incorrect_shape_non_square(self):
         A = qutip.Qobj(np.random.rand(5, 10)).data
         b = qutip.Qobj(np.random.rand(10, 1)).data

From e0b0630e868032a9d0f17a193bc0f7388c5c63e6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 31 Mar 2023 13:51:45 -0400
Subject: [PATCH 252/602] tomography uses itertools

---
 qutip/tomography.py | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/qutip/tomography.py b/qutip/tomography.py
index a663ee30b4..15be67ae19 100644
--- a/qutip/tomography.py
+++ b/qutip/tomography.py
@@ -4,6 +4,7 @@
 import scipy.linalg as la
 from . import tensor, spre, spost, stack_columns, unstack_columns
 from .visualization import matrix_histogram, matrix_histogram_complex
+import itertools
 
 try:
     import matplotlib.pyplot as plt
@@ -11,7 +12,7 @@
     pass
 
 
-def _index_permutations(size_list, perm=[]):
+def _index_permutations(size_list):
     """
     Generate a list with all index permutations.
 
@@ -19,22 +20,14 @@ def _index_permutations(size_list, perm=[]):
     ----------
     size_list : list
         A list that contains the sizes for each composite system.
-    perm : list
-        A list of permutations
 
     Returns
     -------
     perm_idx : list
         List containing index permutations.
 
-
     """
-    if len(size_list) == 0:
-        yield perm
-    else:
-        for n in range(size_list[0]):
-            for ip in _index_permutations(size_list[1:], perm + [n]):
-                yield ip
+    return itertools.product(*[range(N) for N in size_list])
 
 
 def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):

From 050db266d4ef575831f25ceed39782b90b4977db Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 31 Mar 2023 14:34:38 -0400
Subject: [PATCH 253/602] Remove logging utils

---
 qutip/logging_utils.py | 109 -----------------------------------------
 1 file changed, 109 deletions(-)
 delete mode 100644 qutip/logging_utils.py

diff --git a/qutip/logging_utils.py b/qutip/logging_utils.py
deleted file mode 100644
index c91b380b50..0000000000
--- a/qutip/logging_utils.py
+++ /dev/null
@@ -1,109 +0,0 @@
-"""
-This module contains internal-use functions for configuring and writing to
-debug logs, using Python's internal logging functionality by default.
-"""
-
-# IMPORTS
-from __future__ import absolute_import
-import inspect
-import logging
-
-from qutip.settings import settings
-
-# EXPORTS
-NOTSET = logging.NOTSET
-DEBUG_INTENSE = logging.DEBUG - 4
-DEBUG_VERBOSE = logging.DEBUG - 2
-DEBUG = logging.DEBUG
-INFO = logging.INFO
-WARN = logging.WARN
-ERROR = logging.ERROR
-CRITICAL = logging.CRITICAL
-
-__all__ = ['get_logger']
-
-# META-LOGGING
-
-metalogger = logging.getLogger(__name__)
-metalogger.addHandler(logging.NullHandler())
-
-
-# FUNCTIONS
-
-def get_logger(name=None):
-    """
-    Returns a Python logging object with handlers configured
-    in accordance with ~/.qutiprc. By default, this will do
-    something sensible to integrate with IPython when running
-    in that environment, and will print to stdout otherwise.
-
-    Note that this function uses a bit of magic, and thus should
-    not be considered part of the QuTiP API. Rather, this function
-    is for internal use only.
-
-    Parameters
-    ----------
-
-    name : str
-        Name of the logger to be created. If not passed,
-        the name will automatically be set to the name of the
-        calling module.
-    """
-    if name is None:
-        try:
-            calling_frame = inspect.stack()[1][0]
-            calling_module = inspect.getmodule(calling_frame)
-            name = (calling_module.__name__
-                    if calling_module is not None else '<none>')
-
-        except Exception:
-            metalogger.warn('Error creating logger.', exc_info=1)
-            name = '<unknown>'
-
-    logger = logging.getLogger(name)
-
-    policy = settings.log_handler
-
-    if policy == 'default':
-        # Let's try to see if we're in IPython mode.
-        policy = 'basic' if settings.ipython else 'stream'
-
-    metalogger.debug("Creating logger for {} with policy {}.".format(
-        name, policy
-    ))
-
-    if policy == 'basic':
-        # Add no handlers, just let basicConfig do it all.
-        # This is nice for working with IPython, since
-        # it will use its own handlers instead of our StreamHandler
-        # below.
-        if settings.debug:
-            logging.basicConfig(level=logging.DEBUG)
-        else:
-            logging.basicConfig()
-
-    elif policy == 'stream':
-        formatter = logging.Formatter(
-            '[%(asctime)s] %(name)s[%(process)s]: '
-            '%(funcName)s: %(levelname)s: %(message)s',
-            '%Y-%m-%d %H:%M:%S')
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        # We're handling things here, so no propagation out.
-        logger.propagate = False
-
-    elif policy == 'null':
-        # We need to add a NullHandler so that debugging works
-        # at all, but this policy leaves it to the user to
-        # make their own handlers. This is particularly useful
-        # for capturing to logfiles.
-        logger.addHandler(logging.NullHandler())
-
-    if settings.debug:
-        logger.setLevel(logging.DEBUG)
-    else:
-        logger.setLevel(logging.WARN)
-
-    return logger

From 8ddaad44aef7604f7749525d4f50bb5eb9a53375 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 31 Mar 2023 15:27:15 -0400
Subject: [PATCH 254/602] Lower iscptp tolerance

---
 qutip/tests/core/test_superop_reps.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/qutip/tests/core/test_superop_reps.py b/qutip/tests/core/test_superop_reps.py
index 31c538d118..b1e1f1b89e 100644
--- a/qutip/tests/core/test_superop_reps.py
+++ b/qutip/tests/core/test_superop_reps.py
@@ -14,7 +14,7 @@
     Qobj, basis, identity, sigmax, sigmay, qeye, create, rand_super,
     rand_super_bcsz, rand_dm, tensor, super_tensor, kraus_to_choi,
     to_super, to_choi, to_kraus, to_chi, to_stinespring, operator_to_vector,
-    vector_to_operator, sprepost, destroy
+    vector_to_operator, sprepost, destroy, CoreOptions
 )
 from qutip.core.gates import swap
 
@@ -171,8 +171,9 @@ def test_random_iscptp(self, superoperator):
         Superoperator: Randomly generated superoperators are
         correctly reported as CPTP and HP.
         """
-        assert superoperator.iscptp
-        assert superoperator.ishp
+        with CoreOptions(atol=1e-9):
+            assert superoperator.iscptp
+            assert superoperator.ishp
 
     @pytest.mark.parametrize(['qobj', 'hp', 'cp', 'tp'], [
         pytest.param(sprepost(destroy(2), create(2)), True, True, False),

From f084b63790bbf0829f0442641ee049712a655204 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 19:25:49 +0200
Subject: [PATCH 255/602] Add tests for nm_mcsolve.

---
 qutip/tests/solver/test_nm_mcsolve.py | 559 ++++++++++++++++++++++++++
 1 file changed, 559 insertions(+)
 create mode 100644 qutip/tests/solver/test_nm_mcsolve.py

diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
new file mode 100644
index 0000000000..3bec7234d9
--- /dev/null
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -0,0 +1,559 @@
+from copy import copy
+
+import numpy as np
+import pytest
+
+import qutip
+from qutip.solver.nm_mcsolve import nm_mcsolve, NonMarkovianMCSolver
+
+
+def test_rough_agreement_with_mesolve_for_negative_rates():
+    """
+    A rough test that nm_mcsolve agress with mesolve in the
+    presence of negative rates.
+    """
+    times = np.linspace(0, 0.05, 51)
+    psi0 = qutip.basis(2, 1)
+    a0 = qutip.destroy(2)
+    H = a0.dag() * a0
+    e_ops = [
+        a0.dag() * a0,
+        a0 * a0.dag(),
+    ]
+
+    # Rate functions
+    kappa = 1.0 / 0.129
+    nth = 0.063
+    args = {
+        "kappa": kappa,
+        "nth": nth,
+    }
+    gamma1 = "kappa * nth"
+    gamma2 = "kappa * (nth+1) + 12 * exp(-2*t**3) * (-sin(15*t)**2)"
+
+    # nm_mcsolve integration
+    ops_and_rates = [
+        [a0.dag(), gamma1],
+        [a0, gamma2],
+    ]
+    mc_result = nm_mcsolve(
+        H, psi0, times, ops_and_rates,
+        args=args, e_ops=e_ops, ntraj=2500,
+        options={"rtol": 1e-8},
+        seeds=0,
+    )
+
+    # mesolve integration for comparison
+    d_ops = [
+        [qutip.lindblad_dissipator(a0.dag(), a0.dag()), gamma1],
+        [qutip.lindblad_dissipator(a0, a0), gamma2],
+    ]
+    me_result = qutip.mesolve(
+        H, psi0, times, d_ops,
+        args=args, e_ops=e_ops,
+    )
+
+    np.testing.assert_allclose(mc_result.trace, [1.] * len(times))
+    np.testing.assert_allclose(me_result.expect[0], mc_result.expect[0], rtol=0.02)
+    np.testing.assert_allclose(me_result.expect[1], mc_result.expect[1], rtol=0.1)
+
+
+def _return_constant(t, args):
+    return args['constant']
+
+
+def _return_decay(t, args):
+    return args['constant'] * np.exp(-args['rate'] * t)
+
+
+class callable_qobj:
+    def __init__(self, oper, coeff=None):
+        self.oper = oper
+        self.coeff = coeff
+
+    def __call__(self, t, args):
+        if self.coeff is not None:
+            return self.oper * self.coeff(t, args)
+        return self.oper
+
+
+@pytest.mark.usefixtures("in_temporary_directory")
+class StatesAndExpectOutputCase:
+    """
+    Mixin class to test the states and expectation values from nm_mcsolve.
+    """
+    size = 10
+    h = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1, 101)
+    e_ops = [qutip.num(size)]
+    ntraj = 2000
+
+    def _assert_states(self, result, expected, tol):
+        assert hasattr(result, 'states')
+        assert len(result.states) == len(self.times)
+        assert len(self.e_ops) == len(expected)
+        for test_operator, expected_part in zip(self.e_ops, expected):
+            test = qutip.expect(test_operator, result.states)
+            np.testing.assert_allclose(test, expected_part, rtol=tol)
+        np.testing.assert_allclose(
+            result.trace, [1.] * len(result.times), rtol=tol,
+        )
+
+    def _assert_expect(self, result, expected, tol):
+        assert hasattr(result, 'expect')
+        assert len(result.expect) == len(self.e_ops)
+        assert len(self.e_ops) == len(expected)
+        for test, expected_part in zip(result.expect, expected):
+            np.testing.assert_allclose(test, expected_part, rtol=tol)
+
+    def test_states_and_expect(self, hamiltonian, args, ops_and_rates, expected, tol):
+        options = {"store_states": True, "map": "serial"}
+        result = nm_mcsolve(
+            hamiltonian, self.state, self.times, args=args,
+            ops_and_rates=ops_and_rates,
+            e_ops=self.e_ops, ntraj=self.ntraj, options=options,
+            target_tol=0.05,
+        )
+        self._assert_expect(result, expected, tol)
+        self._assert_states(result, expected, tol)
+
+
+class TestNoCollapse(StatesAndExpectOutputCase):
+    """
+    Test that nm_mcsolve correctly solves the system when there is a constant
+    Hamiltonian and no collapses.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 1e-8
+        expect = (
+            qutip.expect(self.e_ops[0], self.state)
+            * np.ones_like(self.times)
+        )
+        hamiltonian_types = [
+            (self.h, "Qobj"),
+            ([self.h], "list"),
+            (qutip.QobjEvo(
+                [self.h, [self.h, _return_constant]],
+                args={'constant': 0}), "QobjEvo"),
+            (callable_qobj(self.h), "callable"),
+        ]
+        cases = [
+            pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
+            for hamiltonian, id in hamiltonian_types
+        ]
+        metafunc.parametrize([
+            'hamiltonian', 'args', 'ops_and_rates', 'expected', 'tol',
+        ], cases)
+
+    # Previously the "states_only" and "expect_only" tests were mixed in to
+    # every other test case.  We move them out into the simplest set so that
+    # their behaviour remains tested, but isn't repeated as often to keep test
+    # runtimes shorter.  The known-good cases are still tested in the other
+    # test cases, this is just testing the single-output behaviour.
+
+    def test_states_only(self, hamiltonian, args, ops_and_rates, expected, tol):
+        options = {"store_states": True, "map": "serial"}
+        result = nm_mcsolve(
+            hamiltonian, self.state, self.times, args=args,
+            ops_and_rates=ops_and_rates,
+            e_ops=[], ntraj=self.ntraj, options=options,
+        )
+        self._assert_states(result, expected, tol)
+
+    def test_expect_only(self, hamiltonian, args, ops_and_rates, expected, tol):
+        result = nm_mcsolve(
+            hamiltonian, self.state, self.times, args=args,
+            ops_and_rates=ops_and_rates,
+            e_ops=self.e_ops, ntraj=self.ntraj, options={'map': 'serial'},
+        )
+        self._assert_expect(result, expected, tol)
+
+
+class TestConstantCollapse(StatesAndExpectOutputCase):
+    """
+    Test that nm_mcsolve correctly solves the system when the
+    collapse rates are constant.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 0.25
+        rate = 0.2
+        expect = (
+            qutip.expect(self.e_ops[0], self.state)
+            * np.exp(-rate * self.times)
+        )
+        op = qutip.destroy(self.size)
+        op_and_rate_types = [
+            ([op, rate], {}, "constant"),
+            ([op, '1 * {}'.format(rate)], {}, "string"),
+            ([op, lambda t: rate], {}, "function"),
+            ([op, lambda t, w: rate], {"w": 1.0}, "function_with_args"),
+        ]
+        cases = [
+            pytest.param(self.h, args, [op_and_rate], [expect], tol, id=id)
+            for op_and_rate, args, id in op_and_rate_types
+        ]
+        metafunc.parametrize([
+            'hamiltonian', 'args', 'ops_and_rates', 'expected', 'tol',
+        ], cases)
+
+
+class TestTimeDependentCollapse(StatesAndExpectOutputCase):
+    """
+    Test that nm_mcsolve correctly solves the system when the
+    collapse rates are time-dependent.
+    """
+    def pytest_generate_tests(self, metafunc):
+        tol = 0.25
+        coupling = 0.2
+        expect = (
+            qutip.expect(self.e_ops[0], self.state)
+            * np.exp(-coupling * (1 - np.exp(-self.times)))
+        )
+        op = qutip.destroy(self.size)
+        rate_args = {'constant': coupling, 'rate': 0.5}
+        rate_string = 'sqrt({} * exp(-t))'.format(coupling)
+        op_and_rate_types = [
+            ([op, rate_string], {}, "string"),
+            ([op, _return_decay], rate_args, "function"),
+        ]
+        cases = [
+            pytest.param(self.h, args, [op_and_rate], [expect], tol, id=id)
+            for op_and_rate, args, id in op_and_rate_types
+        ]
+        metafunc.parametrize([
+            'hamiltonian', 'args', 'ops_and_rates', 'expected', 'tol',
+        ], cases)
+
+
+def test_stored_collapse_operators_and_times():
+    """
+    Test that the output contains information on which collapses happened and
+    at what times, and make sure that this information makes sense.
+    """
+    size = 10
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 10, 100)
+    ops_and_rates = [
+        (a, 1.0),
+        (a, 1.0),
+    ]
+    result = nm_mcsolve(
+        H, state, times, ops_and_rates, ntraj=3,
+        options={"map": "serial"},
+    )
+    assert len(result.col_times[0]) > 0
+    assert len(result.col_which) == len(result.col_times)
+    assert all(col in [0, 1] for col in result.col_which[0])
+
+
+@pytest.mark.parametrize('keep_runs_results', [True, False])
+def test_states_outputs(keep_runs_results):
+    # We're just testing the output value, so it's important whether certain
+    # things are complex or real, but not what the magnitudes of constants are.
+    focks = 5
+    ntraj = 5
+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+    H = 1j*a.dag()*sm + a
+    H = H + H.dag()
+    state = qutip.basis([focks, 2], [0, 1])
+    times = np.linspace(0, 10, 21)
+    ops_and_rates = [
+        (a, 1.0),
+        (sm, 1.0),
+    ]
+    # nm_mcsolve adds one more operator to complete the operator set
+    # which results in the len(ops_and_rates) + 1 below:
+    total_ops = len(ops_and_rates) + 1
+    data = nm_mcsolve(
+        H, state, times, ops_and_rates, ntraj=ntraj,
+        options={
+            "keep_runs_results": keep_runs_results,
+            "map": "serial",
+        },
+    )
+
+    assert len(data.average_states) == len(times)
+    assert isinstance(data.average_states[0], qutip.Qobj)
+    assert data.average_states[0].norm() == pytest.approx(1.)
+    assert data.average_states[0].isoper
+
+    assert isinstance(data.average_final_state, qutip.Qobj)
+    assert data.average_final_state.norm() == pytest.approx(1.)
+    assert data.average_final_state.isoper
+
+    assert isinstance(data.photocurrent[0][1], float)
+    assert isinstance(data.photocurrent[1][1], float)
+    assert (
+        np.array(data.runs_photocurrent).shape
+        == (ntraj, total_ops, len(times)-1)
+    )
+
+    if keep_runs_results:
+        assert len(data.runs_states) == ntraj
+        assert len(data.runs_states[0]) == len(times)
+        assert isinstance(data.runs_states[0][0], qutip.Qobj)
+        assert data.runs_states[0][0].norm() == pytest.approx(1.)
+        assert data.runs_states[0][0].isoper
+
+        assert len(data.runs_final_states) == ntraj
+        assert isinstance(data.runs_final_states[0], qutip.Qobj)
+        assert data.runs_final_states[0].norm() == pytest.approx(1.)
+        assert data.runs_final_states[0].isoper
+
+    assert isinstance(data.steady_state(), qutip.Qobj)
+    assert data.steady_state().norm() == pytest.approx(1.)
+    assert data.steady_state().isoper
+
+    np.testing.assert_allclose(times, data.times)
+    assert data.num_trajectories == ntraj
+    assert len(data.e_ops) == 0
+    assert data.stats["num_collapse"] == total_ops
+    assert len(data.col_times) == ntraj
+    assert np.max(np.hstack(data.col_which)) <= total_ops
+    assert data.stats['end_condition'] == "ntraj reached"
+
+
+@pytest.mark.parametrize('keep_runs_results', [True, False])
+def test_expectation_outputs(keep_runs_results):
+    # We're just testing the output value, so it's important whether certain
+    # things are complex or real, but not what the magnitudes of constants are.
+    focks = 5
+    ntraj = 5
+    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
+    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
+    H = 1j*a.dag()*sm + a
+    H = H + H.dag()
+    state = qutip.basis([focks, 2], [0, 1])
+    times = np.linspace(0, 10, 5)
+    ops_and_rates = [
+        (a, 1.0),
+        (sm, 1.0),
+    ]
+    # nm_mcsolve adds one more operator to complete the operator set
+    # which results in the len(ops_and_rates) + 1 below:
+    total_ops = len(ops_and_rates) + 1
+    e_ops = [a.dag()*a, sm.dag()*sm, a]
+    data = nm_mcsolve(
+        H, state, times, ops_and_rates, e_ops, ntraj=ntraj,
+        options={
+            "keep_runs_results": keep_runs_results,
+            "map": "serial",
+        },
+    )
+    assert isinstance(data.average_expect[0][1], float)
+    assert isinstance(data.average_expect[1][1], float)
+    assert isinstance(data.average_expect[2][1], complex)
+    assert isinstance(data.std_expect[0][1], float)
+    assert isinstance(data.std_expect[1][1], float)
+    assert isinstance(data.std_expect[2][1], float)
+    if keep_runs_results:
+        assert len(data.runs_expect) == len(e_ops)
+        assert len(data.runs_expect[0]) == ntraj
+        assert isinstance(data.runs_expect[0][0][1], float)
+        assert isinstance(data.runs_expect[1][0][1], float)
+        assert isinstance(data.runs_expect[2][0][1], complex)
+    assert isinstance(data.photocurrent[0][0], float)
+    assert isinstance(data.photocurrent[1][0], float)
+    assert (np.array(data.runs_photocurrent).shape
+            == (ntraj, total_ops, len(times)-1))
+    np.testing.assert_allclose(times, data.times)
+    assert data.num_trajectories == ntraj
+    assert len(data.e_ops) == len(e_ops)
+    assert data.stats["num_collapse"] == total_ops
+    assert len(data.col_times) == ntraj
+    assert np.max(np.hstack(data.col_which)) <= total_ops
+    assert data.stats['end_condition'] == "ntraj reached"
+
+
+class TestSeeds:
+    sizes = [6, 6, 6]
+    dampings = [0.1, 0.4, 0.1]
+    ntraj = 25  # Big enough to ensure there are differences without being slow
+    a = [qutip.destroy(size) for size in sizes]
+    H = 1j * (qutip.tensor(a[0], a[1].dag(), a[2].dag())
+              - qutip.tensor(a[0].dag(), a[1], a[2]))
+    state = qutip.tensor(qutip.coherent(sizes[0], np.sqrt(2)),
+                         qutip.basis(sizes[1:], [0, 0]))
+    times = np.linspace(0, 10, 2)
+    ops_and_rates = [
+        (qutip.tensor(a[0], qutip.qeye(sizes[1:])), 2 * dampings[0]),
+        (qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2])), 2 * dampings[1]),
+        (qutip.tensor(qutip.qeye(sizes[:2]), a[2]), 2 * dampings[2]),
+    ]
+
+    def test_seeds_can_be_reused(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'ops_and_rates': self.ops_and_rates, 'ntraj': self.ntraj}
+        first = nm_mcsolve(*args, **kwargs)
+        second = nm_mcsolve(*args, seeds=first.seeds, **kwargs)
+        for first_t, second_t in zip(first.col_times, second.col_times):
+            np.testing.assert_equal(first_t, second_t)
+        for first_w, second_w in zip(first.col_which, second.col_which):
+            np.testing.assert_equal(first_w, second_w)
+
+    def test_seeds_are_not_reused_by_default(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'ops_and_rates': self.ops_and_rates, 'ntraj': self.ntraj}
+        first = nm_mcsolve(*args, **kwargs)
+        second = nm_mcsolve(*args, **kwargs)
+        assert not all(np.array_equal(first_t, second_t)
+                       for first_t, second_t in zip(first.col_times,
+                                                    second.col_times))
+        assert not all(np.array_equal(first_w, second_w)
+                       for first_w, second_w in zip(first.col_which,
+                                                    second.col_which))
+
+    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
+    def test_seed_type(self, seed):
+        args = (self.H, self.state, self.times)
+        kwargs = {'ops_and_rates': self.ops_and_rates, 'ntraj': self.ntraj}
+        first = nm_mcsolve(*args, seeds=copy(seed), **kwargs)
+        second = nm_mcsolve(*args, seeds=copy(seed), **kwargs)
+        for f_seed, s_seed in zip(first.seeds, second.seeds):
+            assert f_seed.state == s_seed.state
+
+    def test_bad_seed(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'ops_and_rates': self.ops_and_rates, 'ntraj': self.ntraj}
+        with pytest.raises(ValueError):
+            nm_mcsolve(*args, seeds=[1], **kwargs)
+
+    def test_generator(self):
+        args = (self.H, self.state, self.times)
+        kwargs = {'ops_and_rates': self.ops_and_rates, 'ntraj': self.ntraj}
+        first = nm_mcsolve(
+            *args, seeds=1, options={'bitgenerator': 'MT19937'},
+            **kwargs,
+        )
+        second = nm_mcsolve(*args, seeds=1, **kwargs)
+        for f_seed, s_seed in zip(first.seeds, second.seeds):
+            assert f_seed.state == s_seed.state
+        assert not all(np.array_equal(first_t, second_t)
+                       for first_t, second_t in zip(first.col_times,
+                                                    second.col_times))
+        assert not all(np.array_equal(first_w, second_w)
+                       for first_w, second_w in zip(first.col_which,
+                                                    second.col_which))
+
+    def test_stepping(self):
+        size = 10
+        a = qutip.destroy(size)
+        H = qutip.num(size)
+        ops_and_rates = [(a, 'alpha')]
+        mcsolver = NonMarkovianMCSolver(H, ops_and_rates, args={'alpha': 0}, options={'map': 'serial'})
+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+        state_1 = mcsolver.step(1, args={'alpha': 1})
+
+        mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
+        state_2 = mcsolver.step(1, args={'alpha': 1})
+        assert state_1 == state_2
+
+
+def test_timeout():
+    size = 10
+    ntraj = 1000
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1.0, 100)
+    coupling = 0.5
+    n_th = 0.05
+    ops_and_rates = [
+        (a, np.sqrt(coupling * (n_th + 1)))
+    ]
+    e_ops = [qutip.num(size)]
+    res = nm_mcsolve(
+        H, state, times, ops_and_rates, e_ops, ntraj=ntraj,
+        options={'map': 'serial'}, timeout=1e-6,
+    )
+    assert res.stats['end_condition'] == 'timeout'
+
+
+def test_super_H():
+    size = 10
+    ntraj = 1000
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    state = qutip.basis(size, size-1)
+    times = np.linspace(0, 1.0, 100)
+    # Arbitrary coupling and bath temperature.
+    coupling = 0.5
+    n_th = 0.05
+    ops_and_rates = [
+        (a, np.sqrt(coupling * (n_th + 1)))
+    ]
+    e_ops = [qutip.num(size)]
+    mc_expected = nm_mcsolve(
+        H, state, times, ops_and_rates, e_ops, ntraj=ntraj,
+        target_tol=0.1, options={'map': 'serial'},
+    )
+    mc = nm_mcsolve(
+        qutip.liouvillian(H), state, times, ops_and_rates, e_ops, ntraj=ntraj,
+        target_tol=0.1, options={'map': 'serial'},
+    )
+    np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
+
+
+def test_NonMarkovianMCSolver_run():
+    size = 10
+    ops_and_rates = [
+        (qutip.destroy(size), 'coupling')
+    ]
+    args = {'coupling': 0}
+    H = qutip.num(size)
+    solver = NonMarkovianMCSolver(H, ops_and_rates, args=args)
+    solver.options = {'store_final_state': True}
+    res = solver.run(qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+                     e_ops=[qutip.qeye(size)], args={'coupling': 1})
+    assert res.final_state is not None
+    assert len(res.collapse[0]) != 0
+    assert res.num_trajectories == 1
+    np.testing.assert_allclose(res.expect[0], np.ones(11))
+    res += solver.run(
+        qutip.basis(size, size-1), np.linspace(0, 5.0, 11),
+        e_ops=[qutip.qeye(size)], args={'coupling': 1},
+        ntraj=1000, target_tol=0.1
+    )
+    assert res.num_trajectories == 1001
+
+
+def test_NonMarkovianMCSolver_stepping():
+    size = 10
+    ops_and_rates = [
+        (qutip.destroy(size), 'coupling')
+    ]
+    args = {'coupling': 0}
+    H = qutip.num(size)
+    solver = NonMarkovianMCSolver(H, ops_and_rates, args=args)
+    solver.start(qutip.basis(size, size-1), 0, seed=0)
+    state = solver.step(1)
+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+    assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
+    assert state.isoper
+    state = solver.step(5, args={'coupling': 5})
+    assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
+    assert qutip.expect(qutip.num(size), state) <= size - 1
+    assert state.isoper
+
+
+# Defined in module-scope so it's pickleable.
+def _dynamic(t, args):
+    return 0 if args["collapse"] else 1
+
+
+@pytest.mark.xfail(reason="current limitation of NonMarkovianMCSolver")
+def test_dynamic_arguments():
+    """Test dynamically updated arguments are usable."""
+    size = 5
+    a = qutip.destroy(size)
+    H = qutip.num(size)
+    times = np.linspace(0, 1, 11)
+    state = qutip.basis(size, 2)
+
+    ops_and_rates = [[a, _dynamic], [a.dag(), _dynamic]]
+    mc = nm_mcsolve(H, state, times, ops_and_rates, ntraj=25, args={"collapse": []})
+    assert all(len(collapses) <= 1 for collapses in mc.col_which)

From 1c6dc879782513c53cec1cb6dfb35bcd9b8af909 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 19:48:08 +0200
Subject: [PATCH 256/602] Update the docstrings for the RateSet.

---
 qutip/solver/cy/nm_mcsolve.pxd |   9 +-
 qutip/solver/cy/nm_mcsolve.pyx | 154 +++++++++++++++++----------------
 2 files changed, 82 insertions(+), 81 deletions(-)

diff --git a/qutip/solver/cy/nm_mcsolve.pxd b/qutip/solver/cy/nm_mcsolve.pxd
index 284afdb031..a803df5dbd 100644
--- a/qutip/solver/cy/nm_mcsolve.pxd
+++ b/qutip/solver/cy/nm_mcsolve.pxd
@@ -2,16 +2,15 @@
 from qutip.core.cy.coefficient cimport Coefficient
 
 
-cdef class RateShiftCoefficient(Coefficient):
+cdef class RateSet:
     cdef:
         Coefficient [:] rate_coeffs
 
-    cpdef double rate_shift(self, double t) except *
-    cpdef Coefficient sqrt_shifted_rate(self, int i)
-    cpdef double discrete_martingale(self, double[:] collapse_times, int[:] collapse_idx) except *
+    cpdef double rate_shift(RateSet self, double t) except *
+    cpdef double rate(RateSet self, double t, int i) except *
 
 
 cdef class SqrtShiftedRateCoefficient(Coefficient):
     cdef:
         int rate_idx
-        RateShiftCoefficient rate_shift
+        RateSet rates
diff --git a/qutip/solver/cy/nm_mcsolve.pyx b/qutip/solver/cy/nm_mcsolve.pyx
index ff9448668c..5c01f23417 100644
--- a/qutip/solver/cy/nm_mcsolve.pyx
+++ b/qutip/solver/cy/nm_mcsolve.pyx
@@ -8,64 +8,90 @@ cdef extern from "<complex>" namespace "std" nogil:
     double real(double complex x)
 
 
-cdef class RateShiftCoefficient(Coefficient):
+cdef class RateSet:
     """
-    A coefficient representing the rate shift required by
-    NonMarkovianMCSolver.
+    A set of possibly negative rate coefficients for the Lindblad operators
+    used by the :class:`NonMarkovianMCSolver`.
+
+    :class:`Rates` exists to solve a few different problems:
+
+    - Calculating the shifted rate is slow in Python because it requires
+      continually looping over the full set of coefficients to calculate
+      the minimum rate.
+
+    - Coefficients return complex numbers, but we have to take the minimum,
+      which requires converting them to floats, and then squaring rooting
+      them. Doing this in Python adds at least two Python function calls
+      to every coefficient call.
+
+    - It's not safe for a solver to expose its internal coefficient instances
+      directly to the user because the coefficients may be replaced by
+      new instances when their arguments are updated. Usually this is solved
+      by the existence of :class:`QobjEvo`, but that solution is awkward in
+      this case because we have mutliple coefficients shared across the
+      :class:`QobjEvo` for each of the collapse operators. We solve this
+      here by returning :class:`SqrtShiftedRateCoefficient` instances
+      which are immutable references to an instance :class:`RateSet`. The
+      small cost is that one must also call ``.arguments()`` on the
+      :class:`RateSet` in addition to the usual call to the ``.arguments()``
+      on all the :class:`QobjEvo` instances.
+
     """
     def __init__(self, Coefficient[:] rate_coeffs):
         self.rate_coeffs = rate_coeffs
 
-    def replace_arguments(self, _args=None, **kwargs):
+    def arguments(self, dict _args=None, **kwargs):
         """
-        Replace the arguments (``args``) of a coefficient.
+        Update the arguments for the rate coefficients.
 
-        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
-        the original coefficient if it does not. Arguments to replace may be
-        supplied either in a dictionary as the first position argument, or
-        passed as keywords, or as a combination of the two. Arguments not
-        replaced retain their previous values.
+        This method behaves as the method ``.arguments`` of :class:`QobjEvo`.
 
         Parameters
         ----------
-        _args : dict
-            Dictionary of arguments to replace.
+        _args : dict [optional]
+            New arguments as a dict. Update args with ``arguments(new_args)``.
 
-        **kwargs
-            Arguments to replace.
+        **kwargs :
+            New arguments as a keywors. Update args with
+            ``arguments(**new_args)``.
+
+        .. note::
+            If both the positional ``_args`` and keywords are passed new values
+            from both will be used. If a key is present with both, the ``_args``
+            dict value will take priority.
         """
-        if _args:
+        if _args is not None:
             kwargs.update(_args)
-        if not kwargs:
-            return self
-        cdef Coefficient[:] new_coeffs = np.array([
-            coeff.replace_arguments(_args, **kwargs)
-            for coeff in self.rate_coeffs
-        ], dtype=Coefficient)
-        return RateShiftCoefficient(new_coeffs)
 
-    cdef complex _call(self, double t) except *:
-        return self.rate_shift(t)
-
-    cpdef Coefficient copy(self):
-        """Return a copy of the :obj:`Coefficient`."""
-        cdef Coefficient[:] new_coeffs = np.array([
-            coeff.copy()
-            for coeff in self.rate_coeffs
-        ], dtype=Coefficient)
-        return RateShiftCoefficient(new_coeffs)
+        cdef Coefficient coeff
+        cache = []
+        for i in range(len(self.rate_coeffs)):
+            coeff = self.rate_coeffs[i].replace_arguments(kwargs, cache=cache)
+            self.rate_coeffs[i] = coeff
 
     def __reduce__(self):
-        return (RateShiftCoefficient, (self.rates,))
+        return (RateSet, (self.rate_coeffs,))
 
-    cpdef double rate_shift(self, double t) except *:
-        """ Calculate the rate shift required to make the shifted rates
-            positive.
+    def sqrt_shifted_rate(self, i):
+        """
+        Return a :obj:`Coefficient` to calculate the shifted rate of the i'th
+        Lindblad operator.
 
-            Returns twice the absoluate value of the minimum unshifted rates.
+        The returned coefficient references this :class:`RateSet` instance.
+        """
+        return SqrtShiftedRateCoefficient(self, i)
+
+    cpdef double rate_shift(RateSet self, double t) except *:
+        """
+        Calculate the rate shift required to make the shifted rates
+        positive.
+
+        Returns twice the absolute value of the minimum unshifted rates or
+        zero if all rates are positive.
         """
         cdef int N = len(self.rate_coeffs)
-        cdef min_rate = 0
+        cdef int i
+        cdef double min_rate = 0
         cdef Coefficient coeff
 
         for i in range(N):
@@ -74,42 +100,25 @@ cdef class RateShiftCoefficient(Coefficient):
 
         return 2 * abs(min_rate)
 
-    cpdef Coefficient sqrt_shifted_rate(self, int i):
-        """ Return a :obj:`Coefficient` to calculate the shifted rate of the i'th
-            Lindblad operator.
-        """
-        return SqrtShiftedRateCoefficient(i, self)
-
-    cpdef double discrete_martingale(self, double[:] collapse_times, int[:] collapse_idx) except *:
+    cpdef double rate(RateSet self, double t, int i) except *:
         """
-        Discrete part of the martingale evolution. The collapses that have
-        happened until now must be provided as a list of (t_k, i_k).
+        Return the unshifted value of rate ``i`` at time ``t``.
         """
-        cdef int N = len(collapse_times)
-        cdef double martingale = 1.0
-        cdef double t_i
-        cdef double rate_i
-        cdef double shift_i
-        cdef Coefficient coeff
-
-        for i in range(N):
-            t_i = collapse_times[i]
-            coeff = self.rate_coeffs[collapse_idx[i]]
-            shift_i = self.rate_shift(t_i)
-            rate_i = real(coeff._call(t_i))
-            martingale *= rate_i / (rate_i + shift_i)
-
-        return martingale
+        cdef Coefficient coeff = self.rate_coeffs[i]
+        return real(coeff._call(t))
 
 
 cdef class SqrtShiftedRateCoefficient(Coefficient):
     """
     A coefficient representing the square root of the shifted
     rates used by NonMarkovianMCSolver.
+
+    Note that a :class:`SqrtShiftedRateCoefficient` is an immutable
+    reference to a particular rate in a :class:`RateSet`.
     """
-    def __init__(self, int rate_idx, RateShiftCoefficient rate_shift):
+    def __init__(self, RateSet rates, int rate_idx):
+        self.rates = rates
         self.rate_idx = rate_idx
-        self.rate_shift = rate_shift
 
     def replace_arguments(self, _args=None, **kwargs):
         """
@@ -129,29 +138,22 @@ cdef class SqrtShiftedRateCoefficient(Coefficient):
         **kwargs
             Arguments to replace.
         """
-        if _args:
-            kwargs.update(_args)
-        if not kwargs:
-            return self
-        return SqrtShiftedRateCoefficient(
-            self.rate_idx,
-            self.rate_shift.replace_arguments(_args, **kwargs),
-        )
+        return self
 
     cdef complex _call(self, double t) except *:
         """Return the shifted rate."""
-        cdef Coefficient coeff = self.rate_shift.rate_coeffs[self.rate_idx]
+        cdef Coefficient coeff = self.rates.rate_coeffs[self.rate_idx]
         return np.sqrt(
             real(coeff._call(t)) +
-            self.rate_shift.rate_shift(t)
+            self.rates.rate_shift(t)
         )
 
     cpdef Coefficient copy(self):
         """Return a copy of the :obj:`Coefficient`."""
         return SqrtShiftedRateCoefficient(
+            self.rates,
             self.rate_idx,
-            self.rate_shift.copy(),
         )
 
     def __reduce__(self):
-        return (SqrtShiftedRateCoefficient, (self.rate_idx, self.rate_shift))
+        return (SqrtShiftedRateCoefficient, (self.rates, self.rate_idx))

From c5437d49c5de5b2836b9658c1a2aa930c52f497f Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 19:49:26 +0200
Subject: [PATCH 257/602] Update nm_mcsolve to use the new RateSet
 implementation and move the martingale calculations into a custom
 MCIntegrator.

---
 qutip/solver/nm_mcsolve.py | 152 +++++++++++++++++++++----------------
 1 file changed, 85 insertions(+), 67 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index d5a3a3bb4e..88a5415368 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -7,10 +7,10 @@
 import scipy
 
 from .multitraj import MultiTrajSolver
-from .mcsolve import MCSolver
+from .mcsolve import MCSolver, MCIntegrator
 from .mesolve import MESolver, mesolve
 from .result import NmmcResult, NmmcTrajectoryResult
-from .cy.nm_mcsolve import RateShiftCoefficient
+from .cy.nm_mcsolve import RateSet
 from ..core import (
     CoreOptions, Qobj, QobjEvo, isket, ket2dm, qeye, coefficient, Coefficient,
 )
@@ -178,6 +178,40 @@ def _parse_op_and_rate(op, rate, **kw):
     return op, rate
 
 
+class NmMCIntegrator(MCIntegrator):
+    def __init__(self, *args, **kwargs):
+        self._nm_solver = kwargs.pop("__nm_solver")
+        super().__init__(*args, **kwargs)
+        self.continuous_martingales = []
+        self.discrete_martingales = []
+        self._t0 = None
+
+    def set_state(self, t, *args, **kwargs):
+        super().set_state(t, *args, **kwargs)
+        self.continuous_martingales = []
+        self.discrete_martingales = []
+        self._t0 = t
+
+    def _do_collapse(self, *args, **kwargs):
+        super()._do_collapse(*args, **kwargs)
+        if len(self.collapses) > len(self.discrete_martingales):
+            # _do_collapse might not append a new collapse, so we
+            # need to check whether one was added before calculating
+            # the martingales.
+            t1, i = self.collapses[-1]
+            if len(self.collapses) > 1:
+                t0, _ = self.collapses[-2]
+            else:
+                assert self._t0 is not None
+                t0 = self._t0
+            self.continuous_martingales.append(
+                self._nm_solver._continuous_martingale(t0, t1)
+            )
+            self.discrete_martingales.append(
+                self._nm_solver._discrete_martingale(t1, i)
+            )
+
+
 class NonMarkovianMCSolver(MCSolver):
     """
     Monte Carlo Solver for Lindblad equations with "rates" that may be
@@ -215,41 +249,43 @@ class NonMarkovianMCSolver(MCSolver):
     """
     name = "nm_mcsolve"
     resultclass = NmmcResult
+    mc_integrator_class = NmMCIntegrator
     solver_options = {
         **MCSolver.solver_options,
         "completeness_rtol": 1e-5,
         "completeness_atol": 1e-8,
+        "martingale_quad_limit": 100,
     }
 
     # "solver" argument will be partially initialized in constructor
     trajectory_resultclass = NmmcTrajectoryResult
 
-    def __init__(self, H, ops_and_rates, *args, options=None, **kwargs):
-        # XXX Fix me -- the result class expects solver to be a string
-        #     with the name of the solver, but here it is supplied as
-        #     an object
+    def __init__(self, H, ops_and_rates, *_args, args=None, options=None, **kwargs):
         self.trajectory_resultclass = functools.partial(
-            NmmcTrajectoryResult, solver=self,
+            NmmcTrajectoryResult, __nm_solver=self,
+        )
+        self.mc_integrator_class = functools.partial(
+           NmMCIntegrator, __nm_solver=self,
         )
 
-        self.ops_and_rates = [
-            _parse_op_and_rate(op, rate)
+        ops_and_rates = [
+            _parse_op_and_rate(op, rate, args=args or {})
             for op, rate in ops_and_rates
         ]
 
         self.options = options
-        self._mu_c = None
 
         self._a_parameter, L = self._check_completeness(ops_and_rates)
         if L is not None:
-            self.ops_and_rates.append((L, coefficient.const(0)))
+            ops_and_rates.append((L, coefficient.const(0)))
 
-        self._rate_shift = RateShiftCoefficient(
-            np.array([f for _, f in self.ops_and_rates], dtype=Coefficient)
+        self.rates = RateSet(
+            np.array([f for _, f in ops_and_rates], dtype=Coefficient)
         )
+        self.ops = [op for op, _ in ops_and_rates]
 
         c_ops = self._compute_paired_c_ops()
-        super().__init__(H, c_ops, *args, options=options, **kwargs)
+        super().__init__(H, c_ops, *_args, options=options, **kwargs)
 
     def _check_completeness(self, ops_and_rates):
         """
@@ -281,72 +317,56 @@ def _compute_paired_c_ops(self):
         as QobjEvo objects.
         """
         c_ops = []
-        for i, (op, _) in enumerate(self.ops_and_rates):
+        for i, op in enumerate(self.ops):
             # Note that this cannot be done using a lambda expression, since
             # lambda expressions can't be pickled and pickling is required
             # for parallel execution.
-            c_ops.append(QobjEvo([op, self._rate_shift.sqrt_shifted_rate(i)]))
+            c_ops.append(QobjEvo([op, self.rates.sqrt_shifted_rate(i)]))
         return c_ops
 
-    def _continuous_martingale(self, t):
+    def _discrete_martingale(self, t, i):
+        """
+        Discrete part of the martingale evolution for time ``t`` and rate ``i``.
         """
-        Continuous part of the martingale evolution. Checks the stored values
-        in self._mu_c for the closest time t0 earlier than the given time t and
-        starts integration from there.
-        Returns the continuous part of the martingale at time t and stores it
-        in self._mu_c.
+        rate = self.rates.rate(t, i)
+        shift = self.rates.rate_shift(t)
+        return rate / (rate + shift)
+
+    def _continuous_martingale(self, t0, t1):
         """
-        if self._mu_c is None:
-            raise RuntimeError("The .start() method must called first.")
-        if t in self._mu_c:
-            return self._mu_c[t]
-
-        earlier_times = filter(lambda t0: t0 < t, self._mu_c.keys())
-        try:
-            t0 = max(earlier_times)
-        except ValueError as exc:
-            raise ValueError("Cannot integrate backwards in time.") from exc
-
-        integral = scipy.integrate.quad(self._rate_shift.rate_shift, t0, t)[0]
-        result = self._mu_c[t0] * np.exp(self._a_parameter * integral)
-        self._mu_c[t] = result
-        return result
-
-    def _current_martingale(self):
+        Continuous part of the martingale evolution for time ``t0`` to ``t1``.
+        """
+        integral, _abserr, *info = scipy.integrate.quad(
+            self.rates.rate_shift, t0, t1,
+            limit=self.options["martingale_quad_limit"],
+            full_output=True,
+        )
+        if len(info) > 1:
+            raise ValueError(
+                f"Failed to integrate the continuous martingale: {info[1]}"
+            )
+        return np.exp(self._a_parameter * integral)
+
+    def _current_martingale(self, t):
         """
         Returns the value of the influence martingale along the current
         trajectory. The value of the martingale is the product of the
         continuous and the discrete contribution. The current time and the
         collapses that have happened are read out from the internal integrator.
         """
-        t, *_ = self._integrator.get_state(copy=False)
-        collapses = np.array(
-            self._integrator.collapses,
-            dtype=[
-                ("time", np.float64),
-                ("idx", np.int32),
-            ]
-        )
-        return (
-            self._continuous_martingale(t) *
-            self._rate_shift.discrete_martingale(
-                collapses["time"], collapses["idx"],
-            )
-        )
-
-    # Override "run" and "start" to precompute
-    #     continuous part of martingale evolution
-    def run(self, state, tlist, *args, **kwargs):
-        self._mu_c = {tlist[0]: 1}
-        return super().run(state, tlist, *args, **kwargs)
-
-    def start(self, state, t0, seed=None):
-        self._mu_c = {t0: 1}
-        return super().start(state, t0, seed=seed)
+        discrete = np.prod(self._integrator.discrete_martingales, initial=1.0)
+        continuous = np.prod(self._integrator.continuous_martingales, initial=1.0)
+        if self._integrator.collapses:
+            tc, _ = self._integrator.collapses[-1]
+            if t > tc:
+                continuous *= self._continuous_martingale(tc, t)
+        return discrete * continuous
 
     def _argument(self, args):
+        # RateSet.arguments() updates the original rate
+        # coefficients
+        self.rates.arguments(args)
         super()._argument(args)
-        self._rate_shift = self._rate_shift.replace_arguments(args)
 
     # Override "step" to include the martingale mu in the state
     # Note that the returned state will be a density matrix with trace=mu
@@ -354,8 +374,6 @@ def step(self, t, *, args=None, copy=True):
         state = super().step(t, args=args, copy=copy)
         if isket(state):
             state = ket2dm(state)
-        return state * self._current_martingale()
+        return state * self._current_martingale(t)
 
-    run.__doc__ = MultiTrajSolver.run.__doc__
-    start.__doc__ = MultiTrajSolver.start.__doc__
     step.__doc__ = MultiTrajSolver.step.__doc__

From 3c0b9c20330172ac6411e43fad832d16d5398029 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 19:49:54 +0200
Subject: [PATCH 258/602] Make the MCIntegrator used by MCSolve configurable.

---
 qutip/solver/mcsolve.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 1f0e5fa37a..a68b92561a 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -342,6 +342,7 @@ class MCSolver(MultiTrajSolver):
     name = "mcsolve"
     resultclass = McResult
     trajectory_resultclass = McTrajectoryResult
+    mc_integrator_class = MCIntegrator
     solver_options = {
         "progress_bar": "text",
         "progress_kwargs": {"chunk_size": 10},
@@ -438,7 +439,7 @@ def _get_integrator(self):
         else:
             raise ValueError("Integrator method not supported.")
         integrator_instance = integrator(self.rhs, self.options)
-        mc_integrator = MCIntegrator(
+        mc_integrator = self.mc_integrator_class(
             integrator_instance, self._c_ops, self._n_ops, self.options
         )
         self._init_integrator_time = time() - _time_start

From 2a8b77bfca6790fd4e22c2e2855184d428953462 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 19:51:01 +0200
Subject: [PATCH 259/602] Use __nm_solver to pass the solver to the result and
 update the nm_mcsolve result class to look a little more like the others.

---
 qutip/solver/result.py | 54 +++++++++++++++++++++---------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 1d11461e9b..4278f24afc 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -989,10 +989,9 @@ class NmmcTrajectoryResult(McTrajectoryResult):
     trajectory.
     """
 
-    def __init__(self, e_ops, options, solver, *args, **kwargs):
+    def __init__(self, e_ops, options, *args, **kwargs):
+        self._nm_solver = kwargs.pop("__nm_solver")
         super().__init__(e_ops, options, *args, **kwargs)
-
-        self._solver = solver
         self.trace = []
 
     # This gets called during the Monte-Carlo simulation of the associated
@@ -1002,7 +1001,7 @@ def __init__(self, e_ops, options, solver, *args, **kwargs):
     def add(self, t, state):
         if isket(state):
             state = ket2dm(state)
-        mu = self._solver._current_martingale()
+        mu = self._nm_solver._current_martingale(t)
         super().add(t, state * mu)
         self.trace.append(mu)
     add.__doc__ = Result.add.__doc__
@@ -1050,40 +1049,41 @@ class NmmcResult(McResult):
     runs_trace : list of lists
         For each recorded trajectory, the trace at each time.
         Only present if ``keep_runs_results`` is set in the options.
-
-    trace : list
-        Refers to ``average_trace`` or ``runs_trace``, depending on whether
-        ``keep_runs_results`` is set in the options.
     """
+    def _post_init(self):
+        super()._post_init()
+
+        self._sum_trace = None
+        self._sum2_trace = None
+        self.average_trace = []
+        self.std_trace = []
+        self.runs_trace = []
+
+        self.add_processor(self._add_trace)
+
+    def _add_first_traj(self, trajectory):
+        super()._add_first_traj(trajectory)
+        self._sum_trace = np.zeros_like(trajectory.times)
+        self._sum2_trace = np.zeros_like(trajectory.times)
 
     def _add_trace(self, trajectory):
         new_trace = np.array(trajectory.trace)
         self._sum_trace += new_trace
-        avg = self._sum_trace / self.num_trajectories
         self._sum2_trace += np.abs(new_trace)**2
+
+        avg = self._sum_trace / self.num_trajectories
         avg2 = self._sum2_trace / self.num_trajectories
 
-        self.trace = avg
         self.average_trace = avg
         self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg)**2))
 
         if self.options['keep_runs_results']:
             self.runs_trace.append(trajectory.trace)
-            self.trace = self.runs_trace
-
-    def _add_first_traj(self, trajectory):
-        super()._add_first_traj(trajectory)
-        self._sum_trace = np.zeros_like(trajectory.times)
-        self._sum2_trace = np.zeros_like(trajectory.times)
-
-    def _post_init(self):
-        super()._post_init()
-
-        self._sum_trace = None
-        self._sum2_trace = None
-        self.trace = []
-        self.average_trace = []
-        self.std_trace = []
-        self.runs_trace = []
 
-        self.add_processor(self._add_trace)
+    @property
+    def trace(self):
+        """
+        Refers to ``average_trace`` or ``runs_trace``, depending on whether
+        ``keep_runs_results`` is set in the options.
+        """
+        return self.runs_trace or self.average_trace

From ef2e9e4f0f07671b3317326b5959ec81381a525d Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 20:34:12 +0200
Subject: [PATCH 260/602] Add test for ConstantCoefficient.

---
 qutip/tests/core/test_coefficient.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 2fe5ff0b6d..a91ab58e87 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -4,11 +4,10 @@
 import numpy as np
 import scipy.interpolate as interp
 from functools import partial
-from qutip.core.coefficient import (coefficient, norm, conj,
+from qutip.core.coefficient import (coefficient, norm, conj, const,
                                     CompilationOptions, Coefficient,
                                     clean_compiled_coefficient
                                    )
-from qutip.core.options import CoreOptions
 
 # Ensure the latest version is tested
 clean_compiled_coefficient(True)
@@ -175,6 +174,11 @@ def test_CoeffUnitaryTransform(style, transform, expected):
     _assert_eq_over_interval(transform(coeff), lambda t: expected(coeff(t)))
 
 
+def test_ConstantCoefficient():
+    coeff = const(5.1)
+    _assert_eq_over_interval(coeff, lambda t: 5.1)
+
+
 @pytest.mark.parametrize(['style_left'], [
     pytest.param("func", id="func"),
     pytest.param("array", id="array"),

From b7a92ed0bf619ca213573fddbcea932763b704ab Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Sun, 2 Apr 2023 21:12:07 +0200
Subject: [PATCH 261/602] Remove check of trace -- the no-collapse tests return
 sesolve results.

---
 qutip/tests/solver/test_nm_mcsolve.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index 3bec7234d9..22e0a02e19 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -96,9 +96,6 @@ def _assert_states(self, result, expected, tol):
         for test_operator, expected_part in zip(self.e_ops, expected):
             test = qutip.expect(test_operator, result.states)
             np.testing.assert_allclose(test, expected_part, rtol=tol)
-        np.testing.assert_allclose(
-            result.trace, [1.] * len(result.times), rtol=tol,
-        )
 
     def _assert_expect(self, result, expected, tol):
         assert hasattr(result, 'expect')

From 4b0dc7039d088b242713ff0d34c4b15d876553b1 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 3 Apr 2023 09:54:18 -0400
Subject: [PATCH 262/602] Add error message check

---
 qutip/tests/core/data/test_linalg.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index fce68580ab..1d553fcd9f 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -74,8 +74,9 @@ def test_mathematically_correct_Dense(self, method, opt):
     def test_singular(self):
         A = qutip.num(2).data
         b = qutip.basis(2, 1).data
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError) as err:
             test1 = _data.solve(A, b)
+        assert "singular" in str(err.value).lower()
 
 
     def test_incorrect_shape_non_square(self):

From acedbeda993b25bb6049bc6d34efad13c8be39ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Mon, 3 Apr 2023 11:12:40 -0400
Subject: [PATCH 263/602] Update qutip/solver/nonmarkov/transfertensor.py

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/solver/nonmarkov/transfertensor.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/nonmarkov/transfertensor.py b/qutip/solver/nonmarkov/transfertensor.py
index b52bdc25d1..7b58e3f886 100644
--- a/qutip/solver/nonmarkov/transfertensor.py
+++ b/qutip/solver/nonmarkov/transfertensor.py
@@ -123,7 +123,7 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         # Set current state
         state = 0
         for j in range(1, min(K, n + 1)):
-            tmp = tensors[j] * states[n - j]
+            tmp = tensors[j] @ states[n - j]
             state = tmp + state
         # Append state to all states
         states.append(state)

From dd4b3923bebff373a49d232f7f1db2f80fc6bf52 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 3 Apr 2023 11:13:19 -0400
Subject: [PATCH 264/602] More complete check

---
 qutip/solver/nonmarkov/transfertensor.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/nonmarkov/transfertensor.py b/qutip/solver/nonmarkov/transfertensor.py
index b52bdc25d1..77f50b8189 100644
--- a/qutip/solver/nonmarkov/transfertensor.py
+++ b/qutip/solver/nonmarkov/transfertensor.py
@@ -88,7 +88,11 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
             )
         dynmaps = [dynmaps(t) for t in times[: opt["num_learning"]]]
 
-    if not dynmaps[0].issuper:
+    if (
+        not dynmaps
+        or not dynmaps[0].issuper
+        or all(dmap.dims == dynmaps[0].dims for dmap in dynmaps)
+    ):
         raise ValueError("`dynmaps` entries must be super operators.")
 
     start = time.time()
@@ -161,7 +165,7 @@ def _generatetensors(dynmaps, threshold):
     for n in range(len(dynmaps)):
         T = dynmaps[n]
         for m in range(1, n):
-            T -= Tensors[n - m] * dynmaps[m]
+            T -= Tensors[n - m] @ dynmaps[m]
         Tensors.append(T)
         if n > 1:
             diff.append((Tensors[-1] - Tensors[-2]).norm())

From 3c54ed3436e0a9f2d176d8f8923e8c0c43e7aea7 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 3 Apr 2023 17:38:19 +0200
Subject: [PATCH 265/602] Fix incorrect Return headers.

---
 qutip/simdiag.py       | 2 +-
 qutip/visualization.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/simdiag.py b/qutip/simdiag.py
index 370ade6552..2f875ff82b 100644
--- a/qutip/simdiag.py
+++ b/qutip/simdiag.py
@@ -64,7 +64,7 @@ def simdiag(ops, evals: bool = True, *,
         will often be eigenvectors of only the first operator.
 
     Returns
-    --------
+    -------
     eigs : tuple
         Tuple of arrays representing eigvecs and eigvals of quantum objects
         corresponding to simultaneous eigenvectors and eigenvalues for each
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 27fe62c60a..10295d2968 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -611,7 +611,7 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
         'figsize' : tuple of two numbers
             The size of the figure.
 
-    Returns :
+    Returns
     -------
     fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce

From 0750101a6305f4880df01b2ec506f782bd854a5a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 3 Apr 2023 11:44:10 -0400
Subject: [PATCH 266/602] num_learning as arguments

---
 qutip/solver/nonmarkov/transfertensor.py  | 15 ++++++++-------
 qutip/tests/solver/test_transfertensor.py |  7 +++----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/qutip/solver/nonmarkov/transfertensor.py b/qutip/solver/nonmarkov/transfertensor.py
index c24caa95d2..fd4f1721c7 100644
--- a/qutip/solver/nonmarkov/transfertensor.py
+++ b/qutip/solver/nonmarkov/transfertensor.py
@@ -15,7 +15,7 @@
 from qutip import spre, vector_to_operator, operator_to_vector, Result
 
 
-def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
+def ttmsolve(dynmaps, state0, times, e_ops=[], num_learning=0, options=None):
     """
     Expand time-evolution using the Transfer Tensor Method [1]_, based on a set
     of precomputed dynamical maps.
@@ -40,6 +40,10 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         Callable signature must be, `f(t: float, state: Qobj)`.
         See :func:`expect` for more detail of operator expectation.
 
+    num_learning : int
+        Number of times used to construct the dynmaps operators when
+        ``dynmaps`` is a callable.
+
     options : dictionary
         Dictionary of options for the solver.
 
@@ -55,9 +59,6 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         - threshold : float
           Threshold for halting. Halts if  :math:`||T_{n}-T_{n-1}||` is below
           treshold.
-        - num_learning : int
-          Number of times used to construct the dynmaps operators when
-          ``dynmaps`` is a callable.
 
     Returns
     -------
@@ -81,17 +82,17 @@ def ttmsolve(dynmaps, state0, times, e_ops=[], options=None):
         raise ValueError("The time should be uniformily distributed.")
 
     if callable(dynmaps):
-        if not options["num_learning"]:
+        if num_learning <= 0:
             raise ValueError(
                 "When dynmaps is a callable, options['num_learning'] must be "
                 "the number of dynamical maps to compute."
             )
-        dynmaps = [dynmaps(t) for t in times[: opt["num_learning"]]]
+        dynmaps = [dynmaps(t) for t in times[:num_learning]]
 
     if (
         not dynmaps
         or not dynmaps[0].issuper
-        or all(dmap.dims == dynmaps[0].dims for dmap in dynmaps)
+        or not all(dmap.dims == dynmaps[0].dims for dmap in dynmaps)
     ):
         raise ValueError("`dynmaps` entries must be super operators.")
 
diff --git a/qutip/tests/solver/test_transfertensor.py b/qutip/tests/solver/test_transfertensor.py
index 08687542e5..775c1f5383 100644
--- a/qutip/tests/solver/test_transfertensor.py
+++ b/qutip/tests/solver/test_transfertensor.py
@@ -35,19 +35,18 @@ def test_ttmsolve_jc_model(call):
     times = np.arange(0, 5.0, 0.1)
     exactsol = qutip.mesolve(H, rho0, times, c_ops, [sz])
 
-    if call:
+    if not call:
         learning_times = np.arange(0, 2.0, 0.1)
         Et_list = qutip.mesolve(H, E0, learning_times, c_ops, []).states
         learning_maps = [ptracesuper @ Et @ superrho0cav for Et in Et_list]
-        opt = {}
     else:
         prop = qutip.Propagator(qutip.liouvillian(H, c_ops))
-        opt = {"num_learning": 21}
         def learning_maps(t):
             return ptracesuper @ prop(t) @ superrho0cav
 
     # solve using transfer method
-    ttmsol = ttmsolve(learning_maps, rho0a, times, e_ops=[qutip.sigmaz()], options=opt)
+    ttmsol = ttmsolve(learning_maps, rho0a, times,
+                      e_ops=[qutip.sigmaz()], num_learning=21)
 
     # check that ttm result and exact solution are close in the learning times
     assert np.allclose(ttmsol.expect[0], exactsol.expect[0], atol=1e-5)

From 06598a8af511a9328df0ddb67e0b5c9f782c395e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 3 Apr 2023 18:01:07 +0200
Subject: [PATCH 267/602] Update Sphinx to 6.1 and matplotlib to 3.7.

---
 doc/requirements.txt    | 76 ++++++++++++++++++++---------------------
 doc/rtd-environment.yml | 75 ++++++++++++++++++++--------------------
 2 files changed, 74 insertions(+), 77 deletions(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index bb52a49954..7ecdc09f42 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -1,50 +1,48 @@
-alabaster==0.7.12
-appnope==0.1.2
-Babel==2.9.1
+alabaster==0.7.13
+Babel==2.12.1
 backcall==0.2.0
 certifi==2022.12.7
 chardet==4.0.0
 cycler==0.10.0
-Cython==0.29.23
-decorator==5.0.7
-docutils==0.16
-idna==2.10
-imagesize==1.2.0
-ipython==8.10.0
-ipython-genutils==0.2.0
-jedi==0.18.0
-Jinja2==2.11.3
-kiwisolver==1.3.1
-MarkupSafe==1.1.1
-matplotlib==3.3.4
-numpy==1.22.0
-numpydoc==1.1.0
-packaging==20.9
-parso==0.8.2
+Cython==0.29.33
+decorator==5.1.1
+docutils==0.18.1
+idna==3.4
+imagesize==1.4.1
+ipython==8.11.0
+jedi==0.18.2
+Jinja2==3.1.2
+kiwisolver==1.4.4
+MarkupSafe==2.1.2
+matplotlib==3.7.1
+numpy==1.24.2
+numpydoc==1.5.0
+packaging==23.0
+parso==0.8.3
 pexpect==4.8.0
 pickleshare==0.7.5
-Pillow==9.3.0
-prompt-toolkit==3.0.36
+Pillow==9.4.0
+prompt-toolkit==3.0.38
 ptyprocess==0.7.0
-Pygments==2.8.1
-pyparsing==2.4.7
-python-dateutil==2.8.1
-pytz==2021.1
+Pygments==2.14.0
+pyparsing==3.0.9
+python-dateutil==2.8.2
+pytz==2023.3
 requests==2.28.2
-scipy==1.10.0
-six==1.15.0
-snowballstemmer==2.1.0
-Sphinx==3.5.4
-sphinx-gallery==0.8.2
-sphinx-rtd-theme==0.5.2
-sphinxcontrib-applehelp==1.0.2
-sphinxcontrib-bibtex==2.4.1
+scipy==1.10.1
+six==1.16.0
+snowballstemmer==2.2.0
+Sphinx==6.1.3
+sphinx-gallery==0.12.2
+sphinx-rtd-theme==1.2.0
+sphinxcontrib-applehelp==1.0.3
+sphinxcontrib-bibtex==2.5.0
 sphinxcontrib-devhelp==1.0.2
-sphinxcontrib-htmlhelp==1.0.3
+sphinxcontrib-htmlhelp==2.0.1
 sphinxcontrib-jsmath==1.0.1
 sphinxcontrib-qthelp==1.0.3
-sphinxcontrib-serializinghtml==1.1.4
-traitlets==5.0.5
-urllib3==1.26.5
-wcwidth==0.2.5
-wheel==0.38.1
+sphinxcontrib-serializinghtml==1.1.5
+traitlets==5.9.0
+urllib3==1.26.14
+wcwidth==0.2.6
+wheel==0.38.4
diff --git a/doc/rtd-environment.yml b/doc/rtd-environment.yml
index 13a0890dd3..dd4e9f26ca 100644
--- a/doc/rtd-environment.yml
+++ b/doc/rtd-environment.yml
@@ -2,56 +2,55 @@ name: rtd-environment
 channels:
 - conda-forge
 dependencies:
-- alabaster==0.7.12
-- appnope==0.1.3
-- Babel==2.9.1
+- alabaster==0.7.13
+- Babel==2.12.1
 - backcall==0.2.0
 - certifi==2022.12.7
 - chardet==4.0.0
 - cycler==0.10.0
-- Cython==0.29.23
-- decorator==5.0.7
-- docutils==0.16
-- idna==2.10
-- imagesize==1.2.0
-- ipython==8.10.0
-- jedi==0.18.0
-- Jinja2==2.11.3
-- kiwisolver==1.3.1
-- MarkupSafe==1.1.1
-- matplotlib==3.3.4
-- numpy==1.22.0
-- numpydoc==1.1.0
-- packaging==20.9
-- parso==0.8.2
+- Cython==0.29.33
+- decorator==5.1.1
+- docutils==0.18.1
+- idna==3.4
+- imagesize==1.4.1
+- ipython==8.11.0
+- jedi==0.18.2
+- Jinja2==3.1.2
+- kiwisolver==1.4.4
+- MarkupSafe==2.1.2
+- matplotlib==3.7.1
+- numpy==1.24.2
+- numpydoc==1.5.0
+- packaging==23.0
+- parso==0.8.3
 - pexpect==4.8.0
 - pickleshare==0.7.5
 - Pillow==9.4.0
-- prompt-toolkit==3.0.36
+- prompt-toolkit==3.0.38
 - ptyprocess==0.7.0
-- Pygments==2.8.1
-- pyparsing==2.4.7
-- python-dateutil==2.8.1
-- pytz==2021.1
+- Pygments==2.14.0
+- pyparsing==3.0.9
+- python-dateutil==2.8.2
+- pytz==2023.3
 - requests==2.28.2
-- scipy==1.10.0
-- six==1.15.0
-- snowballstemmer==2.1.0
-- Sphinx==3.5.4
-- sphinx-gallery==0.8.2
-- sphinx-rtd-theme==1.1.1
-- sphinxcontrib-applehelp==1.0.2
-- sphinxcontrib-bibtex==2.4.1
+- scipy==1.10.1
+- six==1.16.0
+- snowballstemmer==2.2.0
+- Sphinx==6.1.3
+- sphinx-gallery==0.12.2
+- sphinx-rtd-theme==1.2.0
+- sphinxcontrib-applehelp==1.0.4
+- sphinxcontrib-bibtex==2.5.0
 - sphinxcontrib-devhelp==1.0.2
-- sphinxcontrib-htmlhelp==1.0.3
+- sphinxcontrib-htmlhelp==2.0.1
 - sphinxcontrib-jsmath==1.0.1
 - sphinxcontrib-qthelp==1.0.3
-- sphinxcontrib-serializinghtml==1.1.4
+- sphinxcontrib-serializinghtml==1.1.5
 - suitesparse
-- traitlets==5.0.5
-- urllib3==1.26.5
-- wcwidth==0.2.5
-- wheel==0.38.1
+- traitlets==5.9.0
+- urllib3==1.26.14
+- wcwidth==0.2.6
+- wheel==0.38.4
 - pip
 - pip:
-  - ..[full]
\ No newline at end of file
+  - ..[full]

From 5cbd34e00434d3eea1c4fd62f8836772d7df93aa Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 3 Apr 2023 18:01:34 +0200
Subject: [PATCH 268/602] Update configuration to Sphinx 6.

---
 doc/conf.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/conf.py b/doc/conf.py
index 7113e450fc..5f0c8d3779 100755
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -117,7 +117,7 @@ def qutip_version():
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = "en"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -252,7 +252,7 @@ def qutip_version():
 #
 # See:
 # - https://docs.mathjax.org/en/v3.0-latest/input/tex/extensions/physics.html
-mathjax_config = {
+mathjax3_config = {
     'TeX': {
         'Macros': {
             'bra': [r'\left\langle{#1}\right\rvert', 1],
@@ -362,8 +362,8 @@ def qutip_version():
 ## EXTLINKS CONFIGURATION ######################################################
 
 extlinks = {
-    'arxiv': ('https://arxiv.org/abs/%s', 'arXiv:'),
-    'doi': ('https://dx.doi.org/%s', 'doi:'),
+    'arxiv': ('https://arxiv.org/abs/%s', 'arXiv:%s'),
+    'doi': ('https://dx.doi.org/%s', 'doi:%s'),
 }
 
 # configuration declares the location of the examples directory for

From 3afde3a981a9b842fa695afad460aac8aefc98c4 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 3 Apr 2023 18:03:16 +0200
Subject: [PATCH 269/602] Update contributor image rendering to matplotlib 3.7.

---
 doc/contributors.rst | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/doc/contributors.rst b/doc/contributors.rst
index 3ae1aebb3a..d869ef43a9 100644
--- a/doc/contributors.rst
+++ b/doc/contributors.rst
@@ -14,11 +14,12 @@ Developers
     import numpy as np
     import matplotlib.pyplot as plt
 
+    from matplotlib.path import Path
     from matplotlib.patches import PathPatch
     from matplotlib.textpath import TextPath
     from matplotlib.collections import PolyCollection
     from matplotlib.font_manager import FontProperties
-    import matplotlib.image as mpimg
+    import PIL
 
 
     LINK_CONTRIBUTORS = "https://api.github.com/repos/qutip/qutip/contributors"
@@ -39,8 +40,12 @@ Developers
     url_object = urllib.request.urlopen(LINK_CONTRIBUTORS)
     list_contributors = json.loads(url_object.read())
     qutip_contributors = [element["login"] for element in list_contributors]
+    qutip_contributors = [s.lower() for s in qutip_contributors]
     text = " ".join(qutip_contributors)
 
+    # load the QuTiP logo
+    img = PIL.Image.open(urllib.request.urlopen(LINK_LOGO))
+
     # code below was inspired in the following link:
     # https://github.com/dynamicwebpaige/nanowrimo-2021/blob/main/15_VS_Code_contributors.ipynb
 
@@ -56,12 +61,21 @@ Developers
     L = np.zeros(len(T))
     np.cumsum(np.sqrt(((T[1:] - T[:-1]) ** 2).sum(axis=1)), out=L[1:])
 
-    path = TextPath((0, 0), text, size=FONT_SIZE,
-                    prop=FontProperties(family=FONT_FAMILY))
-    Vx, Vy = path.vertices[:, 0], path.vertices[:, 1]
+    path = TextPath(
+        (0, 0), text,
+        size=FONT_SIZE,
+        prop=FontProperties(family=FONT_FAMILY),
+    )
+
+    vertices = path.vertices
+    codes = path.codes
+
+    Vx, Vy = vertices[:, 0], vertices[:, 1]
     X = np.interp(Vx, L, T[:, 0]) + Vy * np.interp(Vx, L, O[:, 0])
     Y = np.interp(Vx, L, T[:, 1]) + Vy * np.interp(Vx, L, O[:, 1])
-    Vx[...], Vy[...] = X, Y
+    vertices = np.stack([X, Y], axis=-1)
+
+    path = Path(vertices, codes, closed=False)
 
     # creating figure
     fig, ax = plt.subplots(figsize=(FIGURE_SIZE, FIGURE_SIZE))
@@ -70,8 +84,7 @@ Developers
     ax.set_xlim(-AXIS_SIZE, AXIS_SIZE), ax.set_xticks([])
     ax.set_ylim(-AXIS_SIZE, AXIS_SIZE), ax.set_yticks([])
 
-    # uncomment lines below to add qutip logo
-    img = mpimg.imread(LINK_LOGO)
+    # add qutip logo
     ax.imshow(img, alpha=LOGO_TRANSPARENCY,
               extent=[-LOGO_SIZE,LOGO_SIZE, -LOGO_SIZE, LOGO_SIZE])
 

From d7621a9d31bd4770e930a8b2f3f55d2bce167c8f Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 3 Apr 2023 18:03:36 +0200
Subject: [PATCH 270/602] Add Asier Galicia to core contributors.

---
 doc/contributors.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/contributors.rst b/doc/contributors.rst
index d869ef43a9..e112abeeee 100644
--- a/doc/contributors.rst
+++ b/doc/contributors.rst
@@ -101,6 +101,7 @@ Lead Developers
 - `Boxi Li <https://github.com/BoxiLi>`_
 - `Jake Lishman <https://binhbar.com>`_
 - `Simon Cross <http://hodgestar.za.net/>`_
+- `Asier Galicia <https://github.com/AGaliciaMartinez>`_
 
 Past Lead Developers
 ====================

From 97596dbf927b20ded1d70ad4d890e377f736dba4 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 3 Apr 2023 18:03:59 +0200
Subject: [PATCH 271/602] Add missing newline to end of file.

---
 doc/guide/dynamics/dynamics-monte.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index 9362bffa92..a4c1f20b3c 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -239,4 +239,4 @@ For example, the following code block plots expectation values for 1, 10 and 100
 .. plot::
     :context: reset
     :include-source: false
-    :nofigs:
\ No newline at end of file
+    :nofigs:

From e32bbe26fba70abfe7f6e0c86fd6c1124f2fd9b3 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 12:58:35 -0400
Subject: [PATCH 272/602] Fix for cython 3.0.0b1

---
 qutip/core/cy/_element.pyx    |  6 +++++-
 qutip/core/cy/coefficient.pyx |  2 ++
 qutip/core/data/add.pyx       |  2 +-
 qutip/core/data/base.pyx      |  1 +
 qutip/core/data/expect.pxd    | 12 ++++++------
 qutip/core/data/expect.pyx    | 30 +++++++++++++++---------------
 qutip/core/data/inner.pxd     |  4 ++--
 qutip/core/data/inner.pyx     | 10 +++++-----
 qutip/core/data/matmul.pyx    |  2 +-
 qutip/core/data/norm.pxd      |  4 ++--
 qutip/core/data/norm.pyx      |  4 ++--
 qutip/core/data/trace.pxd     |  8 ++++----
 qutip/core/data/trace.pyx     | 12 ++++++------
 13 files changed, 52 insertions(+), 45 deletions(-)

diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
index 999d51d06d..427a73cb5c 100644
--- a/qutip/core/cy/_element.pyx
+++ b/qutip/core/cy/_element.pyx
@@ -1,5 +1,9 @@
 #cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False, cdvision=True
+#cython: boundscheck=False
+#cython: wraparound=False
+#cython: initializedcheck=False
+#cython: cdvision=True
+#cython: c_api_binop_methods=True
 
 from .. import data as _data
 from qutip.core.cy.coefficient import coefficient_function_parameters
diff --git a/qutip/core/cy/coefficient.pyx b/qutip/core/cy/coefficient.pyx
index 0d05d48181..0dcae7b14a 100644
--- a/qutip/core/cy/coefficient.pyx
+++ b/qutip/core/cy/coefficient.pyx
@@ -1,4 +1,6 @@
 #cython: language_level=3
+#cython: c_api_binop_methods=True
+
 import inspect
 import pickle
 import scipy
diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index 4a24a193a4..468a76425d 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -31,7 +31,7 @@ __all__ = [
 cdef int _ONE=1
 
 
-cdef void _check_shape(Data left, Data right) nogil except *:
+cdef void _check_shape(Data left, Data right) except * nogil:
     if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
         raise ValueError(
             "incompatible matrix shapes "
diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
index a463bf3834..5802f3b62d 100644
--- a/qutip/core/data/base.pyx
+++ b/qutip/core/data/base.pyx
@@ -1,4 +1,5 @@
 #cython: language_level=3
+#cython: c_api_binop_methods=True
 
 import numpy as np
 cimport numpy as cnp
diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
index 4e7d2af104..b781b7c176 100644
--- a/qutip/core/data/expect.pxd
+++ b/qutip/core/data/expect.pxd
@@ -3,14 +3,14 @@
 
 from qutip.core.data cimport CSR, Dense, Data
 
-cpdef double complex expect_csr(CSR op, CSR state) nogil except *
-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
+cpdef double complex expect_csr(CSR op, CSR state) except * nogil
+cpdef double complex expect_super_csr(CSR op, CSR state) except * nogil
 
-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *
-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
+cpdef double complex expect_csr_dense(CSR op, Dense state) except * nogil
+cpdef double complex expect_super_csr_dense(CSR op, Dense state) except * nogil
 
-cpdef double complex expect_dense(Dense op, Dense state) nogil except *
-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
+cpdef double complex expect_dense(Dense op, Dense state) except * nogil
+cpdef double complex expect_super_dense(Dense op, Dense state) except * nogil
 
 cdef double complex expect_data_dense(Data op, Dense state) except *
 cdef double complex expect_super_data_dense(Data op, Dense state) except *
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 9b2089943e..5da6d07293 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -20,7 +20,7 @@ __all__ = [
     'expect_super_csr_dense', 'expect_super_dense',
 ]
 
-cdef void _check_shape_ket(Data op, Data state) nogil except *:
+cdef void _check_shape_ket(Data op, Data state) except * nogil:
     if (
         op.shape[1] != state.shape[0]  # Matrix multiplication
         or state.shape[1] != 1  # State is ket
@@ -29,7 +29,7 @@ cdef void _check_shape_ket(Data op, Data state) nogil except *:
         raise ValueError("incorrect input shapes "
                          + str(op.shape) + " and " + str(state.shape))
 
-cdef void _check_shape_dm(Data op, Data state) nogil except *:
+cdef void _check_shape_dm(Data op, Data state) except * nogil:
     if (
         op.shape[1] != state.shape[0]  # Matrix multiplication
         or state.shape[0] != state.shape[1]  # State is square 
@@ -38,7 +38,7 @@ cdef void _check_shape_dm(Data op, Data state) nogil except *:
         raise ValueError("incorrect input shapes "
                          + str(op.shape) + " and " + str(state.shape))
 
-cdef void _check_shape_super(Data op, Data state) nogil except *:
+cdef void _check_shape_super(Data op, Data state) except * nogil:
     if state.shape[1] != 1:
         raise ValueError("expected a column-stacked matrix")
     if (
@@ -48,7 +48,7 @@ cdef void _check_shape_super(Data op, Data state) nogil except *:
         raise ValueError("incompatible shapes " + str(op.shape) + ", " + str(state.shape))
 
 
-cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
+cdef double complex _expect_csr_ket(CSR op, CSR state) except * nogil:
     """
     Perform the operation
         state.adjoint() @ op @ state
@@ -71,7 +71,7 @@ cdef double complex _expect_csr_ket(CSR op, CSR state) nogil except *:
         out += mul * sum
     return out
 
-cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
+cdef double complex _expect_csr_dm(CSR op, CSR state) except * nogil:
     """
     Perform the operation
         tr(op @ state)
@@ -90,7 +90,7 @@ cdef double complex _expect_csr_dm(CSR op, CSR state) nogil except *:
     return out
 
 
-cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
+cpdef double complex expect_super_csr(CSR op, CSR state) except * nogil:
     """
     Perform the operation `tr(op @ state)` where `op` is supplied as a
     superoperator, and `state` is a column-stacked operator.
@@ -108,7 +108,7 @@ cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *:
     return out
 
 
-cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
+cpdef double complex expect_csr(CSR op, CSR state) except * nogil:
     """
     Get the expectation value of the operator `op` over the state `state`.  The
     state can be either a ket or a density matrix.
@@ -122,7 +122,7 @@ cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
         return _expect_csr_ket(op, state)
     return _expect_csr_dm(op, state)
 
-cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
+cdef double complex _expect_csr_dense_ket(CSR op, Dense state) except * nogil:
     _check_shape_ket(op, state)
     cdef double complex out=0, sum
     cdef size_t row, ptr
@@ -135,7 +135,7 @@ cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
         out += sum * conj(state.data[row])
     return out
 
-cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
+cdef double complex _expect_csr_dense_dm(CSR op, Dense state) except * nogil:
     _check_shape_dm(op, state)
     cdef double complex out=0
     cdef size_t row, ptr_op, ptr_state=0, row_stride, col_stride
@@ -150,7 +150,7 @@ cdef double complex _expect_csr_dense_dm(CSR op, Dense state) nogil except *:
     return out
 
 
-cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
+cdef double complex _expect_dense_ket(Dense op, Dense state) except * nogil:
     _check_shape_ket(op, state)
     cdef double complex out=0, sum
     cdef size_t row, col, op_row_stride, op_col_stride
@@ -165,7 +165,7 @@ cdef double complex _expect_dense_ket(Dense op, Dense state) nogil except *:
         out += sum * conj(state.data[row])
     return out
 
-cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *:
+cdef double complex _expect_dense_dense_dm(Dense op, Dense state) except * nogil:
     _check_shape_dm(op, state)
     cdef double complex out=0
     cdef size_t row, col, op_row_stride, op_col_stride
@@ -182,7 +182,7 @@ cdef double complex _expect_dense_dense_dm(Dense op, Dense state) nogil except *
     return out
 
 
-cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
+cpdef double complex expect_csr_dense(CSR op, Dense state) except * nogil:
     """
     Get the expectation value of the operator `op` over the state `state`.  The
     state can be either a ket or a density matrix.
@@ -197,7 +197,7 @@ cpdef double complex expect_csr_dense(CSR op, Dense state) nogil except *:
     return _expect_csr_dense_dm(op, state)
 
 
-cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
+cpdef double complex expect_dense(Dense op, Dense state) except * nogil:
     """
     Get the expectation value of the operator `op` over the state `state`.  The
     state can be either a ket or a density matrix.
@@ -212,7 +212,7 @@ cpdef double complex expect_dense(Dense op, Dense state) nogil except *:
     return _expect_dense_dense_dm(op, state)
 
 
-cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
+cpdef double complex expect_super_csr_dense(CSR op, Dense state) except * nogil:
     """
     Perform the operation `tr(op @ state)` where `op` is supplied as a
     superoperator, and `state` is a column-stacked operator.
@@ -228,7 +228,7 @@ cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *:
     return out
 
 
-cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
+cpdef double complex expect_super_dense(Dense op, Dense state) except * nogil:
     """
     Perform the operation `tr(op @ state)` where `op` is supplied as a
     superoperator, and `state` is a column-stacked operator.
diff --git a/qutip/core/data/inner.pxd b/qutip/core/data/inner.pxd
index 1d5000dd7a..5c202060a6 100644
--- a/qutip/core/data/inner.pxd
+++ b/qutip/core/data/inner.pxd
@@ -2,5 +2,5 @@
 
 from qutip.core.data.csr cimport CSR
 
-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) nogil except *
-cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) nogil except *
+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=*) except * nogil
+cpdef double complex inner_op_csr(CSR left, CSR op, CSR right, bint scalar_is_ket=*) except * nogil
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index 9491970044..d5b7f72fba 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -16,7 +16,7 @@ __all__ = [
 ]
 
 
-cdef void _check_shape_inner(Data left, Data right) nogil except *:
+cdef void _check_shape_inner(Data left, Data right) except * nogil:
     if (
         (left.shape[0] != 1 and left.shape[1] != 1)
         or right.shape[1] != 1
@@ -28,7 +28,7 @@ cdef void _check_shape_inner(Data left, Data right) nogil except *:
             + str(right.shape)
         )
 
-cdef void _check_shape_inner_op(Data left, Data op, Data right) nogil except *:
+cdef void _check_shape_inner_op(Data left, Data op, Data right) except * nogil:
     cdef bint left_shape = left.shape[0] == 1 or left.shape[1] == 1
     cdef bint left_op = (
         (left.shape[0] == 1 and left.shape[1] == op.shape[0])
@@ -67,7 +67,7 @@ cdef double complex _inner_csr_ket_ket(CSR left, CSR right) nogil:
             out += conj(left.data[ptr_l]) * right.data[ptr_r]
     return out
 
-cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) nogil except *:
+cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) except * nogil:
     """
     Compute the complex inner product <left|right>.  The shape of `left` is
     used to determine if it has been supplied as a ket or a bra.  The result of
@@ -90,7 +90,7 @@ cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) no
         return _inner_csr_bra_ket(left, right)
     return _inner_csr_ket_ket(left, right)
 
-cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
+cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) except * nogil:
     """
     Compute the complex inner product <left|right>.  The shape of `left` is
     used to determine if it has been supplied as a ket or a bra.  The result of
@@ -150,7 +150,7 @@ cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
     return out
 
 cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
-                                  bint scalar_is_ket=False) nogil except *:
+                                  bint scalar_is_ket=False) except * nogil:
     """
     Compute the complex inner product <left|op|right>.  The shape of `left` is
     used to determine if it has been supplied as a ket or a bra.  The result of
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 19559a5937..57c0b1c839 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -44,7 +44,7 @@ __all__ = [
 ]
 
 
-cdef void _check_shape(Data left, Data right, Data out=None) nogil except *:
+cdef void _check_shape(Data left, Data right, Data out=None) except * nogil:
     if left.shape[1] != right.shape[0]:
         raise ValueError(
             "incompatible matrix shapes "
diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
index 5e1b7ebe0d..223adf0938 100644
--- a/qutip/core/data/norm.pxd
+++ b/qutip/core/data/norm.pxd
@@ -7,9 +7,9 @@ cpdef double one_csr(CSR matrix) except -1
 cpdef double trace_csr(CSR matrix) except -1
 cpdef double max_csr(CSR matrix) nogil
 cpdef double frobenius_csr(CSR matrix) nogil
-cpdef double l2_csr(CSR matrix) nogil except -1
+cpdef double l2_csr(CSR matrix) except -1 nogil
 
 cpdef double frobenius_dense(Dense matrix) nogil
-cpdef double l2_dense(Dense matrix) nogil except -1
+cpdef double l2_dense(Dense matrix) except -1 nogil
 
 cpdef double frobenius_data(Data state)
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 998d49d1d2..2bf910ecf4 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -92,7 +92,7 @@ cpdef double frobenius_csr(CSR matrix) nogil:
     cdef int n=csr.nnz(matrix), inc=1
     return blas.dznrm2(&n, &matrix.data[0], &inc)
 
-cpdef double l2_csr(CSR matrix) nogil except -1:
+cpdef double l2_csr(CSR matrix) except -1 nogil:
     if matrix.shape[0] != 1 and matrix.shape[1] != 1:
         raise ValueError("L2 norm is only defined on vectors")
     return frobenius_csr(matrix)
@@ -128,7 +128,7 @@ cpdef double frobenius_dense(Dense matrix) nogil:
     cdef int inc = 1
     return blas.dznrm2(&n, matrix.data, &inc)
 
-cpdef double l2_dense(Dense matrix) nogil except -1:
+cpdef double l2_dense(Dense matrix) except -1 nogil:
     if matrix.shape[0] != 1 and matrix.shape[1] != 1:
         raise ValueError("L2 norm is only defined on vectors")
     return frobenius_dense(matrix)
diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index e231896f8f..916ce2cc40 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -2,8 +2,8 @@
 
 from qutip.core.data cimport CSR, Dense
 
-cpdef double complex trace_csr(CSR matrix) nogil except *
-cpdef double complex trace_dense(Dense matrix) nogil except *
+cpdef double complex trace_csr(CSR matrix) except * nogil
+cpdef double complex trace_dense(Dense matrix) except * nogil
 
-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
+cpdef double complex trace_oper_ket_csr(CSR matrix) except * nogil
+cpdef double complex trace_oper_ket_dense(Dense matrix) except * nogil
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index c256f537cc..40217246ea 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -13,21 +13,21 @@ __all__ = [
 ]
 
 
-cdef void _check_shape(Data matrix) nogil except *:
+cdef void _check_shape(Data matrix) except * nogil:
     if matrix.shape[0] != matrix.shape[1]:
         raise ValueError("".join([
             "matrix shape ", str(matrix.shape), " is not square.",
         ]))
 
 
-cdef void _check_shape_oper_ket(int N, Data matrix) nogil except *:
+cdef void _check_shape_oper_ket(int N, Data matrix) except * nogil:
     if matrix.shape[0] != N * N or matrix.shape[1] != 1:
         raise ValueError("".join([
             "matrix ", str(matrix.shape), " is not a stacked square matrix."
         ]))
 
 
-cpdef double complex trace_csr(CSR matrix) nogil except *:
+cpdef double complex trace_csr(CSR matrix) except * nogil:
     _check_shape(matrix)
     cdef size_t row, ptr
     cdef double complex trace = 0
@@ -38,7 +38,7 @@ cpdef double complex trace_csr(CSR matrix) nogil except *:
                 break
     return trace
 
-cpdef double complex trace_dense(Dense matrix) nogil except *:
+cpdef double complex trace_dense(Dense matrix) except * nogil:
     _check_shape(matrix)
     cdef double complex trace = 0
     cdef size_t ptr = 0
@@ -49,7 +49,7 @@ cpdef double complex trace_dense(Dense matrix) nogil except *:
     return trace
 
 
-cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
+cpdef double complex trace_oper_ket_csr(CSR matrix) except * nogil:
     cdef size_t N = <size_t>sqrt(matrix.shape[0])
     _check_shape_oper_ket(N, matrix)
     cdef size_t row
@@ -60,7 +60,7 @@ cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
             trace += matrix.data[matrix.row_index[row * stride]]
     return trace
 
-cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
+cpdef double complex trace_oper_ket_dense(Dense matrix) except * nogil:
     cdef size_t N = <size_t>sqrt(matrix.shape[0])
     _check_shape_oper_ket(N, matrix)
     cdef double complex trace = 0

From 2a956e859c5e38201be227547c48869f030c33ec Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 14:04:31 -0400
Subject: [PATCH 273/602] rm unused mul_check

---
 qutip/core/_brtools.pyx | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
index a7e379c964..43941bde52 100644
--- a/qutip/core/_brtools.pyx
+++ b/qutip/core/_brtools.pyx
@@ -54,11 +54,6 @@ cdef class SpectraCoefficient(Coefficient):
         return self
 
 
-@cython.overflowcheck(True)
-cdef size_t _mul_checked(size_t a, size_t b) except? -1:
-    return a * b
-
-
 cdef Data _apply_trans(Data original, int trans):
     """helper function for matmul_var_data, apply transform."""
     cdef Data out

From 8ebd3ea782863a7a64ba8e54d1379fee664399c9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 15:09:52 -0400
Subject: [PATCH 274/602] add format argument

---
 qutip/core/data/csr.pyx    |  7 +++-
 qutip/core/data/extract.py | 76 +++++++++++++++++++++++++++++++++++---
 qutip/core/qobj.py         |  9 ++++-
 3 files changed, 83 insertions(+), 9 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 6cf30b06e6..beeffeb1ad 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -16,7 +16,12 @@ import warnings
 import numpy as np
 cimport numpy as cnp
 import scipy.sparse
-from scipy.sparse import csr_matrix as scipy_csr_matrix
+try:
+    # csr_array is a subclass of csr_matrix that overwrite few operation.
+    # It is the new interface available from 1.8.0
+    from scipy.sparse import csr_array as scipy_csr_matrix
+except ImportError:
+    from scipy.sparse import csr_matrix as scipy_csr_matrix
 try:
     from scipy.sparse.data import _data_matrix as scipy_data_matrix
 except ImportError:
diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index a97d35b887..8280bbf3ce 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -1,25 +1,85 @@
 from . import dense, csr, Dense, CSR
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
+try:
+    from scipy.sparse import csr_array
+except ImportError:
+    csr_array = None
+from scipy.sparse import csr_matrix
 
+def get_dense(matrix, format=None, copy=True):
+    """
+    Return the scipy's object ``csr_array``.
 
-def get_dense(matrix, copy=True):
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to convert to common type.
+
+    format : str, {"csr_array", "csr_matrix"}
+        Type of the output.
+        "csr_array" is available with scipy >= 1.8
+
+    copy : bool, default: True
+        Whether to pass a copy of the object or not.
+    """
+    if format not in [None, "ndarray"]:
+        raise ValueError(
+            "Valid format for Dense is 'ndarray'"
+        )
     if copy:
         return matrix.to_array()
     else:
         return matrix.as_ndarray()
 
 
-def get_csr(matrix, copy=True):
-    data = matrix.as_scipy()
-    if copy:
-        data = data.copy()
+def get_csr(matrix, format=None, copy=True):
+    """
+    Return the scipy's object ``csr_array``.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to convert to common type.
+
+    format : str, {"csr_array", "csr_matrix"}
+        Type of the output.
+        "csr_array" is available with scipy >= 1.8
+
+    copy : bool, default: True
+        Whether to pass a copy of the object or not.
+    """
+    # The requirements do not require scipy>=1.8 so csr_array may not be
+    # available. But as the newest options, it is the default when available.
+    # We could simplify this when support for old version is dropped.
+    if format in "csr_array" and csr_array is not None:
+        base = csr_array
+    elif format in "csr_matrix":
+        base = csr_matrix
+    elif format in [None, "scipy_csr"]:
+        base = csr_array or csr_matrix
+    else:
+        raise ValueError(
+            "Valid format for CSR are 'csr_matrix' and 'csr_array'"
+        )
+
+    csr_mat = matrix.as_scipy()
+    out = base(csr_mat)
+    if not copy:
+        # The __init__ from scipy does a copy.
+        out.data = csr_mat.data
+        out.indices = csr_mat.indices
+        out.indptr = csr_mat.indptr
+
     return data
 
 
 get = _Dispatcher(
     _inspect.Signature([
         _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter(
+            'format', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=None
+        )
         _inspect.Parameter(
             'copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True
         )
@@ -37,9 +97,13 @@ def get_csr(matrix, copy=True):
 
     Parameters
     ----------
-    matrix : int
+    matrix : Data
         The matrix to convert to common type.
 
+    format : str, default: None
+        Type of the output, "ndarray" for ``Dense``, "csr_array" for ``CSR``.
+        A ValueError will be raised if the format is not supported.
+
     copy : bool, default: True
         Whether to pass a copy of the object.
     """
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index 8adfda1e1a..79d937fe47 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -824,11 +824,16 @@ def full(self, order='C', squeeze=False):
         out = np.asarray(self.data.to_array(), order=order)
         return out.squeeze() if squeeze else out
 
-    def get(self, copy=True):
+    def get(self, format=None, copy=True):
         """Matrix from quantum object.
 
         Parameters
         ----------
+        format : str, default: None
+            Type of the output, "ndarray" for ``Dense``, "csr_array" for
+            ``CSR``. A ValueError will be raised if the format is not
+            supported.
+
         copy : bool {False, True}
             Whether to return a copy
 
@@ -837,7 +842,7 @@ def get(self, copy=True):
         data : numpy.ndarray, scipy.sparse.matrix_csr, etc.
             Matrix in the type of the underlying libraries.
         """
-        return _data.get(self.data, copy)
+        return _data.get(self.data, format, copy)
 
     def diag(self):
         """Diagonal elements of quantum object.

From 2b144f64af279fdb6ad2a07d34f9de604fa3bdc6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 15:12:55 -0400
Subject: [PATCH 275/602] appease codeclimat

---
 qutip/core/data/extract.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index 8280bbf3ce..e411ebc1b8 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -7,6 +7,7 @@
     csr_array = None
 from scipy.sparse import csr_matrix
 
+
 def get_dense(matrix, format=None, copy=True):
     """
     Return the scipy's object ``csr_array``.

From 0008b7a8a44bcb28379cb929bebb42ab4efcc602 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 15:23:46 -0400
Subject: [PATCH 276/602] Add format to test

---
 qutip/core/data/extract.py    |  8 ++++----
 qutip/tests/core/test_qobj.py | 18 +++++++++++++-----
 2 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index e411ebc1b8..d42a04c297 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -53,9 +53,9 @@ def get_csr(matrix, format=None, copy=True):
     # The requirements do not require scipy>=1.8 so csr_array may not be
     # available. But as the newest options, it is the default when available.
     # We could simplify this when support for old version is dropped.
-    if format in "csr_array" and csr_array is not None:
+    if format == "csr_array" and csr_array is not None:
         base = csr_array
-    elif format in "csr_matrix":
+    elif format == "csr_matrix":
         base = csr_matrix
     elif format in [None, "scipy_csr"]:
         base = csr_array or csr_matrix
@@ -72,7 +72,7 @@ def get_csr(matrix, format=None, copy=True):
         out.indices = csr_mat.indices
         out.indptr = csr_mat.indptr
 
-    return data
+    return out
 
 
 get = _Dispatcher(
@@ -80,7 +80,7 @@ def get_csr(matrix, format=None, copy=True):
         _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
         _inspect.Parameter(
             'format', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=None
-        )
+        ),
         _inspect.Parameter(
             'copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True
         )
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 8d1fa5a85a..11b4b79dd3 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1231,19 +1231,27 @@ def test_groundstate():
 def test_get():
     qobj = qutip.qeye(2, dtype="CSR")
 
-    assert scipy.sparse.isspmatrix_csr(qobj.get())
+    assert scipy.sparse.isspmatrix_csr(qobj.get("csr_array"))
+    assert scipy.sparse.isspmatrix_csr(qobj.get("csr_matrix"))
     assert scipy.sparse.isspmatrix_csr(qobj.get(copy=False))
+    with pytest.raises(ValueError) as err:
+        qobj.get("ndarray")
+    assert "csr_array" in str(err.value)
 
     qobj.get(copy=False)[0, 0] = 0
-    qobj.get(copy=True)[0, 0] = 1
+    qobj.get(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="CSR")
 
 
+
     qobj = qutip.qeye(2, dtype="Dense")
 
-    assert isinstance(qobj.get(), np.ndarray)
+    assert isinstance(qobj.get("ndarray"), np.ndarray)
     assert isinstance(qobj.get(copy=False), np.ndarray)
-    
+
     qobj.get(copy=False)[0, 0] = 0
-    qobj.get(copy=True)[0, 0] = 1
+    qobj.get(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="Dense")
+    with pytest.raises(ValueError) as err:
+        qobj.get("csr_array")
+    assert "ndarray" in str(err.value)

From 6369d1e5e782c90ae547271872810c9295582092 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 16:52:51 -0400
Subject: [PATCH 277/602] Add format to test

---
 qutip/core/data/csr.pyx       |  7 +------
 qutip/core/data/extract.py    | 27 ++++++---------------------
 qutip/tests/core/test_qobj.py |  5 ++---
 3 files changed, 9 insertions(+), 30 deletions(-)

diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index beeffeb1ad..6cf30b06e6 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -16,12 +16,7 @@ import warnings
 import numpy as np
 cimport numpy as cnp
 import scipy.sparse
-try:
-    # csr_array is a subclass of csr_matrix that overwrite few operation.
-    # It is the new interface available from 1.8.0
-    from scipy.sparse import csr_array as scipy_csr_matrix
-except ImportError:
-    from scipy.sparse import csr_matrix as scipy_csr_matrix
+from scipy.sparse import csr_matrix as scipy_csr_matrix
 try:
     from scipy.sparse.data import _data_matrix as scipy_data_matrix
 except ImportError:
diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index d42a04c297..0cb5c9012e 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -43,36 +43,21 @@ def get_csr(matrix, format=None, copy=True):
     matrix : Data
         The matrix to convert to common type.
 
-    format : str, {"csr_array", "csr_matrix"}
+    format : str, {"csr_matrix"}
         Type of the output.
         "csr_array" is available with scipy >= 1.8
 
     copy : bool, default: True
         Whether to pass a copy of the object or not.
     """
-    # The requirements do not require scipy>=1.8 so csr_array may not be
-    # available. But as the newest options, it is the default when available.
-    # We could simplify this when support for old version is dropped.
-    if format == "csr_array" and csr_array is not None:
-        base = csr_array
-    elif format == "csr_matrix":
-        base = csr_matrix
-    elif format in [None, "scipy_csr"]:
-        base = csr_array or csr_matrix
-    else:
+    if format not in [None, "scipy_csr", "csr_matrix"]:
         raise ValueError(
-            "Valid format for CSR are 'csr_matrix' and 'csr_array'"
+            "Valid format for CSR is 'csr_matrix'"
         )
-
     csr_mat = matrix.as_scipy()
-    out = base(csr_mat)
-    if not copy:
-        # The __init__ from scipy does a copy.
-        out.data = csr_mat.data
-        out.indices = csr_mat.indices
-        out.indptr = csr_mat.indptr
-
-    return out
+    if copy:
+        csr_mat = csr_mat.copy()
+    return csr_mat
 
 
 get = _Dispatcher(
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 11b4b79dd3..232c5007e6 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1231,12 +1231,11 @@ def test_groundstate():
 def test_get():
     qobj = qutip.qeye(2, dtype="CSR")
 
-    assert scipy.sparse.isspmatrix_csr(qobj.get("csr_array"))
     assert scipy.sparse.isspmatrix_csr(qobj.get("csr_matrix"))
     assert scipy.sparse.isspmatrix_csr(qobj.get(copy=False))
     with pytest.raises(ValueError) as err:
         qobj.get("ndarray")
-    assert "csr_array" in str(err.value)
+    assert "csr_matrix" in str(err.value)
 
     qobj.get(copy=False)[0, 0] = 0
     qobj.get(copy=True)[0, 1] = 2
@@ -1253,5 +1252,5 @@ def test_get():
     qobj.get(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="Dense")
     with pytest.raises(ValueError) as err:
-        qobj.get("csr_array")
+        qobj.get("csr_matrix")
     assert "ndarray" in str(err.value)

From 86c085699345ddf860d59ced2e229cc30bffffc0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 4 Apr 2023 16:56:54 -0400
Subject: [PATCH 278/602] Revert to matrix and filterwarnings

---
 qutip/tests/core/test_qobj.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 232c5007e6..0c1a819686 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1228,6 +1228,9 @@ def test_groundstate():
     assert "degenerate" in warning[0].message.args[0]
 
 
+@pytest.mark.filterwarnings(
+    "ignore::scipy.sparse.SparseEfficiencyWarning"
+)
 def test_get():
     qobj = qutip.qeye(2, dtype="CSR")
 

From 19867b12e4dbe2fa5e3427be55a5c59275a05b1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 5 Apr 2023 09:48:42 -0400
Subject: [PATCH 279/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/data/extract.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index 0cb5c9012e..6baa683a2b 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -60,7 +60,7 @@ def get_csr(matrix, format=None, copy=True):
     return csr_mat
 
 
-get = _Dispatcher(
+extract = _Dispatcher(
     _inspect.Signature([
         _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
         _inspect.Parameter(
@@ -70,7 +70,7 @@ def get_csr(matrix, format=None, copy=True):
             'copy', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True
         )
     ]),
-    name='get',
+    name='extract',
     module=__name__,
     inputs=('matrix',),
     out=False,

From d1154d056b8e844f8d955716e8bdd504afcf97a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 5 Apr 2023 09:49:38 -0400
Subject: [PATCH 280/602] Update qutip/core/data/extract.py

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/data/extract.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index 6baa683a2b..cdb97185d2 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -8,25 +8,25 @@
 from scipy.sparse import csr_matrix
 
 
-def get_dense(matrix, format=None, copy=True):
+def extract_dense(matrix, format=None, copy=True):
     """
-    Return the scipy's object ``csr_array``.
+    Return an array representation of the Dense data object.
 
     Parameters
     ----------
     matrix : Data
-        The matrix to convert to common type.
+        The matrix to convert to the given format.
 
-    format : str, {"csr_array", "csr_matrix"}
+    format : str {"ndarray"}, default="ndarray"
         Type of the output.
-        "csr_array" is available with scipy >= 1.8
 
     copy : bool, default: True
-        Whether to pass a copy of the object or not.
+        Whether to return a copy of the data. If False,
+        a view of the data is returned when possible.
     """
     if format not in [None, "ndarray"]:
         raise ValueError(
-            "Valid format for Dense is 'ndarray'"
+            f"Dense data instances do not support being extracted to format {format!r}"
         )
     if copy:
         return matrix.to_array()

From f5e9950bc7f15adecc83138fba42a559465c0834 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 5 Apr 2023 09:57:46 -0400
Subject: [PATCH 281/602] get to extract

---
 qutip/core/data/extract.py    | 14 +++++++-------
 qutip/core/qobj.py            |  4 ++--
 qutip/tests/core/test_qobj.py | 22 +++++++++++-----------
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index cdb97185d2..f429da0041 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -26,7 +26,7 @@ def extract_dense(matrix, format=None, copy=True):
     """
     if format not in [None, "ndarray"]:
         raise ValueError(
-            f"Dense data instances do not support being extracted to format {format!r}"
+            "Dense can only be extracted to 'ndarray'"
         )
     if copy:
         return matrix.to_array()
@@ -34,7 +34,7 @@ def extract_dense(matrix, format=None, copy=True):
         return matrix.as_ndarray()
 
 
-def get_csr(matrix, format=None, copy=True):
+def extract_csr(matrix, format=None, copy=True):
     """
     Return the scipy's object ``csr_array``.
 
@@ -52,7 +52,7 @@ def get_csr(matrix, format=None, copy=True):
     """
     if format not in [None, "scipy_csr", "csr_matrix"]:
         raise ValueError(
-            "Valid format for CSR is 'csr_matrix'"
+            "CSR can only be extracted to 'csr_matrix'"
         )
     csr_mat = matrix.as_scipy()
     if copy:
@@ -75,7 +75,7 @@ def get_csr(matrix, format=None, copy=True):
     inputs=('matrix',),
     out=False,
 )
-get.__doc__ =\
+extract.__doc__ =\
     """
     Return the common representation of the data layer object: scipy's
     ``csr_matrix`` for ``CSR``, numpy array for ``Dense``, Jax's ``Array`` for
@@ -93,9 +93,9 @@ def get_csr(matrix, format=None, copy=True):
     copy : bool, default: True
         Whether to pass a copy of the object.
     """
-get.add_specialisations([
-    (CSR, get_csr),
-    (Dense, get_dense),
+extract.add_specialisations([
+    (CSR, extract_csr),
+    (Dense, extract_dense),
 ], _defer=True)
 
 
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index 79d937fe47..af4f513349 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -824,7 +824,7 @@ def full(self, order='C', squeeze=False):
         out = np.asarray(self.data.to_array(), order=order)
         return out.squeeze() if squeeze else out
 
-    def get(self, format=None, copy=True):
+    def extract(self, format=None, copy=True):
         """Matrix from quantum object.
 
         Parameters
@@ -842,7 +842,7 @@ def get(self, format=None, copy=True):
         data : numpy.ndarray, scipy.sparse.matrix_csr, etc.
             Matrix in the type of the underlying libraries.
         """
-        return _data.get(self.data, format, copy)
+        return _data.extract(self.data, format, copy)
 
     def diag(self):
         """Diagonal elements of quantum object.
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 0c1a819686..549817d302 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1231,29 +1231,29 @@ def test_groundstate():
 @pytest.mark.filterwarnings(
     "ignore::scipy.sparse.SparseEfficiencyWarning"
 )
-def test_get():
+def test_extract():
     qobj = qutip.qeye(2, dtype="CSR")
 
-    assert scipy.sparse.isspmatrix_csr(qobj.get("csr_matrix"))
-    assert scipy.sparse.isspmatrix_csr(qobj.get(copy=False))
+    assert scipy.sparse.isspmatrix_csr(qobj.extract("csr_matrix"))
+    assert scipy.sparse.isspmatrix_csr(qobj.extract(copy=False))
     with pytest.raises(ValueError) as err:
-        qobj.get("ndarray")
+        qobj.extract("ndarray")
     assert "csr_matrix" in str(err.value)
 
-    qobj.get(copy=False)[0, 0] = 0
-    qobj.get(copy=True)[0, 1] = 2
+    qobj.extract(copy=False)[0, 0] = 0
+    qobj.extract(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="CSR")
 
 
 
     qobj = qutip.qeye(2, dtype="Dense")
 
-    assert isinstance(qobj.get("ndarray"), np.ndarray)
-    assert isinstance(qobj.get(copy=False), np.ndarray)
+    assert isinstance(qobj.extract("ndarray"), np.ndarray)
+    assert isinstance(qobj.extract(copy=False), np.ndarray)
 
-    qobj.get(copy=False)[0, 0] = 0
-    qobj.get(copy=True)[0, 1] = 2
+    qobj.extract(copy=False)[0, 0] = 0
+    qobj.extract(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="Dense")
     with pytest.raises(ValueError) as err:
-        qobj.get("csr_matrix")
+        qobj.extract("csr_matrix")
     assert "ndarray" in str(err.value)

From 4721b0f7848b6fef2bb598271a745c572c7685b7 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 5 Apr 2023 13:05:31 -0400
Subject: [PATCH 282/602] fix extract method name collision

---
 qutip/solver/heom/bofin_solvers.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 740c2d5d0c..ec62e39d3e 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -528,7 +528,7 @@ def heomsolve(
           if the results option ``ado_return`` was set to ``True``).
           Each element is an instance of :class:`HierarchyADOsState`.
           The state of a particular ADO may be extracted from
-          ``result.ado_states[i]`` by calling :meth:`.extract`.
+          ``result.ado_states[i]`` by calling :meth:`HEOMSolver.extract`.
 
         * ``expect``: a list containing the values of each ``e_ops`` at
           time ``t``.
@@ -921,7 +921,7 @@ def steady_state(
 
         steady_ados : :class:`HierarchyADOsState`
             The steady state of the full ADO hierarchy. A particular ADO may be
-            extracted from the full state by calling :meth:`.extract`.
+            extracted from the full state by calling :meth:`HEOMSolver.extract`.
         """
         if not self.L_sys.isconstant:
             raise ValueError(
@@ -1021,7 +1021,7 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
               if the results option ``ado_return`` was set to ``True``).
               Each element is an instance of :class:`HierarchyADOsState`.
               The state of a particular ADO may be extracted from
-              ``result.ado_states[i]`` by calling :meth:`.extract`.
+              ``result.ado_states[i]`` by calling :meth:`HEOMSolver.extract`.
 
             * ``expect``: a list containing the values of each ``e_ops`` at
               time ``t``.

From 0aaf4ca38535df402bb2cb45ce57738915eea6d6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 5 Apr 2023 14:21:36 -0400
Subject: [PATCH 283/602] Fix docstring

---
 qutip/core/qobj.py                 | 2 +-
 qutip/solver/heom/bofin_solvers.py | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index af4f513349..b8a05266ae 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -830,7 +830,7 @@ def extract(self, format=None, copy=True):
         Parameters
         ----------
         format : str, default: None
-            Type of the output, "ndarray" for ``Dense``, "csr_array" for
+            Type of the output, "ndarray" for ``Dense``, "csr_matrix" for
             ``CSR``. A ValueError will be raised if the format is not
             supported.
 
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index ec62e39d3e..26bc5183fc 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -921,7 +921,8 @@ def steady_state(
 
         steady_ados : :class:`HierarchyADOsState`
             The steady state of the full ADO hierarchy. A particular ADO may be
-            extracted from the full state by calling :meth:`HEOMSolver.extract`.
+            extracted from the full state by calling
+            :meth:`HEOMSolver.extract`.
         """
         if not self.L_sys.isconstant:
             raise ValueError(

From fac35be0880941fdd550b9919dca6864a33909ef Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 11:10:41 +0200
Subject: [PATCH 284/602] Simply the nm_mcsolve Cython to use coefficients
 directly and add tests.

---
 qutip/solver/cy/nm_mcsolve.pxd           |  12 +-
 qutip/solver/cy/nm_mcsolve.pyx           | 151 ++++++++--------------
 qutip/tests/solver/cy/test_nm_mcsolve.py | 154 +++++++++++++++++++++++
 3 files changed, 210 insertions(+), 107 deletions(-)
 create mode 100644 qutip/tests/solver/cy/test_nm_mcsolve.py

diff --git a/qutip/solver/cy/nm_mcsolve.pxd b/qutip/solver/cy/nm_mcsolve.pxd
index a803df5dbd..d5d4389973 100644
--- a/qutip/solver/cy/nm_mcsolve.pxd
+++ b/qutip/solver/cy/nm_mcsolve.pxd
@@ -2,15 +2,11 @@
 from qutip.core.cy.coefficient cimport Coefficient
 
 
-cdef class RateSet:
+cdef class RateShiftCoefficient(Coefficient):
     cdef:
-        Coefficient [:] rate_coeffs
+        Coefficient [:] coeffs
 
-    cpdef double rate_shift(RateSet self, double t) except *
-    cpdef double rate(RateSet self, double t, int i) except *
 
-
-cdef class SqrtShiftedRateCoefficient(Coefficient):
+cdef class SqrtRealCoefficient(Coefficient):
     cdef:
-        int rate_idx
-        RateSet rates
+        Coefficient base
diff --git a/qutip/solver/cy/nm_mcsolve.pyx b/qutip/solver/cy/nm_mcsolve.pyx
index 5c01f23417..9bf59df932 100644
--- a/qutip/solver/cy/nm_mcsolve.pyx
+++ b/qutip/solver/cy/nm_mcsolve.pyx
@@ -2,123 +2,84 @@
 
 import numpy as np
 
+cimport cython
+
 from qutip.core.cy.coefficient cimport Coefficient
 
+cdef extern from "<math.h>" namespace "std" nogil:
+    double sqrt(double x)
+
 cdef extern from "<complex>" namespace "std" nogil:
     double real(double complex x)
 
 
-cdef class RateSet:
+cdef class RateShiftCoefficient(Coefficient):
     """
-    A set of possibly negative rate coefficients for the Lindblad operators
-    used by the :class:`NonMarkovianMCSolver`.
-
-    :class:`Rates` exists to solve a few different problems:
-
-    - Calculating the shifted rate is slow in Python because it requires
-      continually looping over the full set of coefficients to calculate
-      the minimum rate.
-
-    - Coefficients return complex numbers, but we have to take the minimum,
-      which requires converting them to floats, and then squaring rooting
-      them. Doing this in Python adds at least two Python function calls
-      to every coefficient call.
-
-    - It's not safe for a solver to expose its internal coefficient instances
-      directly to the user because the coefficients may be replaced by
-      new instances when their arguments are updated. Usually this is solved
-      by the existence of :class:`QobjEvo`, but that solution is awkward in
-      this case because we have mutliple coefficients shared across the
-      :class:`QobjEvo` for each of the collapse operators. We solve this
-      here by returning :class:`SqrtShiftedRateCoefficient` instances
-      which are immutable references to an instance :class:`RateSet`. The
-      small cost is that one must also call ``.arguments()`` on the
-      :class:`RateSet` in addition to the usual call to the ``.arguments()``
-      on all the :class:`QobjEvo` instances.
+    A coefficient representing the rate shift of a list of coefficients.
+
+    The rate shift is ``2 * abs(min([0, coeff_1(t), coeff_2(t), ...]))``.
 
+    Parameters
+    ----------
+    coeffs : list of :class:`Coefficient`
+        The list of coefficients to determine the rate shift of.
     """
-    def __init__(self, Coefficient[:] rate_coeffs):
-        self.rate_coeffs = rate_coeffs
+    def __init__(self, list coeffs):
+        self.coeffs = np.array(coeffs, dtype=Coefficient)
 
-    def arguments(self, dict _args=None, **kwargs):
+    def __reduce__(self):
+        return (RateShiftCoefficient, (list(self.coeffs),))
+
+    def replace_arguments(self, _args=None, **kwargs):
         """
-        Update the arguments for the rate coefficients.
+        Replace the arguments (``args``) of a coefficient.
 
-        This method behaves as the method ``.arguments`` of :class:`QobjEvo`.
+        Returns a new :obj:`Coefficient` if the coefficient has arguments, or
+        the original coefficient if it does not. Arguments to replace may be
+        supplied either in a dictionary as the first position argument, or
+        passed as keywords, or as a combination of the two. Arguments not
+        replaced retain their previous values.
 
         Parameters
         ----------
-        _args : dict [optional]
-            New arguments as a dict. Update args with ``arguments(new_args)``.
-
-        **kwargs :
-            New arguments as a keywors. Update args with
-            ``arguments(**new_args)``.
-
-        .. note::
-            If both the positional ``_args`` and keywords are passed new values
-            from both will be used. If a key is present with both, the ``_args``
-            dict value will take priority.
-        """
-        if _args is not None:
-            kwargs.update(_args)
-
-        cdef Coefficient coeff
-        cache = []
-        for i in range(len(self.rate_coeffs)):
-            coeff = self.rate_coeffs[i].replace_arguments(kwargs, cache=cache)
-            self.rate_coeffs[i] = coeff
-
-    def __reduce__(self):
-        return (RateSet, (self.rate_coeffs,))
-
-    def sqrt_shifted_rate(self, i):
-        """
-        Return a :obj:`Coefficient` to calculate the shifted rate of the i'th
-        Lindblad operator.
-
-        The returned coefficient references this :class:`RateSet` instance.
-        """
-        return SqrtShiftedRateCoefficient(self, i)
+        _args : dict
+            Dictionary of arguments to replace.
 
-    cpdef double rate_shift(RateSet self, double t) except *:
+        **kwargs
+            Arguments to replace.
         """
-        Calculate the rate shift required to make the shifted rates
-        positive.
+        return RateShiftCoefficient(
+            [coeff.replace_arguments(_args, **kwargs) for coeff in self.coeffs],
+        )
 
-        Returns twice the absolute value of the minimum unshifted rates or
-        zero if all rates are positive.
-        """
-        cdef int N = len(self.rate_coeffs)
+    cdef complex _call(self, double t) except *:
+        """Return the min value."""
+        cdef int N = len(self.coeffs)
         cdef int i
         cdef double min_rate = 0
         cdef Coefficient coeff
 
         for i in range(N):
-            coeff = self.rate_coeffs[i]
+            coeff = self.coeffs[i]
             min_rate = min(min_rate, real(coeff._call(t)))
 
         return 2 * abs(min_rate)
 
-    cpdef double rate(RateSet self, double t, int i) except *:
-        """
-        Return the unshifted value of rate ``i`` at time ``t``.
-        """
-        cdef Coefficient coeff = self.rate_coeffs[i]
-        return real(coeff._call(t))
+    cpdef Coefficient copy(self):
+        """Return a copy of the :obj:`Coefficient`."""
+        return RateShiftCoefficient(
+            [coeff.copy() for coeff in self.coeffs],
+        )
 
 
-cdef class SqrtShiftedRateCoefficient(Coefficient):
+@cython.auto_pickle(True)
+cdef class SqrtRealCoefficient(Coefficient):
     """
-    A coefficient representing the square root of the shifted
-    rates used by NonMarkovianMCSolver.
-
-    Note that a :class:`SqrtShiftedRateCoefficient` is an immutable
-    reference to a particular rate in a :class:`RateSet`.
+    A coefficient representing the positive square root of the real part of
+    another coefficient.
     """
-    def __init__(self, RateSet rates, int rate_idx):
-        self.rates = rates
-        self.rate_idx = rate_idx
+    def __init__(self, Coefficient base):
+        self.base = base
 
     def replace_arguments(self, _args=None, **kwargs):
         """
@@ -138,22 +99,14 @@ cdef class SqrtShiftedRateCoefficient(Coefficient):
         **kwargs
             Arguments to replace.
         """
-        return self
+        return SqrtRealCoefficient(
+            self.base.replace_arguments(_args, **kwargs)
+        )
 
     cdef complex _call(self, double t) except *:
         """Return the shifted rate."""
-        cdef Coefficient coeff = self.rates.rate_coeffs[self.rate_idx]
-        return np.sqrt(
-            real(coeff._call(t)) +
-            self.rates.rate_shift(t)
-        )
+        return sqrt(real(self.base._call(t)))
 
     cpdef Coefficient copy(self):
         """Return a copy of the :obj:`Coefficient`."""
-        return SqrtShiftedRateCoefficient(
-            self.rates,
-            self.rate_idx,
-        )
-
-    def __reduce__(self):
-        return (SqrtShiftedRateCoefficient, (self.rates, self.rate_idx))
+        return SqrtRealCoefficient(self.base.copy())
diff --git a/qutip/tests/solver/cy/test_nm_mcsolve.py b/qutip/tests/solver/cy/test_nm_mcsolve.py
new file mode 100644
index 0000000000..025b39c093
--- /dev/null
+++ b/qutip/tests/solver/cy/test_nm_mcsolve.py
@@ -0,0 +1,154 @@
+import numbers
+import pickle
+
+import numpy as np
+import pytest
+
+from qutip import coefficient
+from qutip.core.coefficient import ConstantCoefficient
+from qutip.solver.cy.nm_mcsolve import (
+    RateShiftCoefficient, SqrtRealCoefficient,
+)
+
+
+def assert_functions_equal(f, g, tlist, rtol=1e-12, atol=1e-12):
+    """ Assert that to functions of t are equal at a list of specified times.
+    """
+    assert len(tlist) > 0
+    np.testing.assert_allclose(
+        [f(t) for t in tlist],
+        [g(t) for t in tlist],
+        rtol=rtol, atol=atol,
+    )
+
+
+class RateSet:
+    """ A list of coefficients and a tlist of times to test at. """
+    def __init__(self, coeffs, tlist):
+        self.coeffs = coeffs
+        self.tlist = tlist
+
+
+def rate_set(coeffs, *, tlist=np.linspace(0, 1, 20), args=None, **kw):
+    id = kw.pop("id")
+    args = args or {}
+    coeffs = [
+        ConstantCoefficient(c) if isinstance(c, numbers.Number)
+        else coefficient(c, args=args)
+        for c in coeffs
+    ]
+    return pytest.param(RateSet(coeffs, tlist), id=id)
+
+
+@pytest.fixture(params=[
+    rate_set([], id="no_rates"),
+    rate_set([0], id="single_zero_rate"),
+    rate_set([1], id="single_positive_rate"),
+    rate_set([-1], id="single_negative_rate"),
+    rate_set([0, 0, 0], id="multiple_zero_rates"),
+    rate_set([0, 1], id="zero_and_positive_rate"),
+    rate_set([0, -1], id="zero_and_negative_rate"),
+    rate_set([1, -1], id="positive_and_negative_rate"),
+    rate_set(
+        [lambda t: np.sin(t)],
+        tlist=np.linspace(0, 2 * np.pi, 20),
+        id="sin_rate",
+    ),
+    rate_set(
+        [lambda t: np.sin(t), -0.5],
+        tlist=np.linspace(0, 2 * np.pi, 20),
+        id="sin_and_negative_rate",
+    )
+])
+def rates(request):
+    return request.param
+
+
+def sin_t(t):
+    """ Pickle-able and coefficient-able sin(t). """
+    return np.sin(t)
+
+
+class TestRateShiftCoefficient:
+
+    @staticmethod
+    def assert_f_equals_rate_shift(f, coeffs, tlist, **kw):
+        def g(t):
+            return 2 * np.abs(min(
+                [0] + [np.real(c(t)) for c in coeffs]
+            ))
+        assert_functions_equal(f, g, tlist, **kw)
+
+    def test_call(self, rates):
+        rs = RateShiftCoefficient(rates.coeffs)
+        self.assert_f_equals_rate_shift(rs, rates.coeffs, rates.tlist)
+
+    def test_copy(self, rates):
+        rs = RateShiftCoefficient(rates.coeffs)
+        rs = rs.copy()
+        self.assert_f_equals_rate_shift(rs, rates.coeffs, rates.tlist)
+
+    def test_replace_arguments(self):
+        coeff = coefficient(lambda t, w: np.sin(w * t), args={"w": 1.0})
+        tlist = np.linspace(0, 2 * np.pi, 100)
+        rs = RateShiftCoefficient([coeff])
+
+        for w in [0, 1, 2, 3]:
+            rs2 = rs.replace_arguments(w=w)
+            self.assert_f_equals_rate_shift(
+                rs2, [coeff.replace_arguments(w=w)], tlist,
+            )
+
+    def test_reduce(self):
+        coeff = coefficient(sin_t)
+        tlist = np.linspace(0, 2 * np.pi, 20)
+        rs = RateShiftCoefficient([coeff])
+
+        data = pickle.dumps(rs, protocol=-1)
+        rs = pickle.loads(data)
+        self.assert_f_equals_rate_shift(rs, [coeff], tlist)
+
+
+class TestSqrtRealCoefficient:
+
+    @staticmethod
+    def assert_f_equals_sqrt_real(f, coeff, tlist, **kw):
+        def g(t):
+            return np.sqrt(np.real(coeff(t)))
+        assert_functions_equal(f, g, tlist, **kw)
+
+    def test_call(self):
+        coeff = coefficient(lambda t: np.abs(np.sin(t)))
+        tlist = np.linspace(0, 2 * np.pi, 20)
+        sr = SqrtRealCoefficient(coeff)
+        self.assert_f_equals_sqrt_real(sr, coeff, tlist)
+
+    def test_copy(self):
+        coeff = coefficient(lambda t: np.abs(np.sin(t)))
+        tlist = np.linspace(0, 2 * np.pi, 20)
+        sr = SqrtRealCoefficient(coeff)
+        sr = sr.copy()
+        self.assert_f_equals_sqrt_real(sr, coeff, tlist)
+
+    def test_replace_arguments(self):
+        coeff = coefficient(
+            lambda t, w: np.abs(np.sin(w * t)),
+            args={"w": 1.0},
+        )
+        tlist = np.linspace(0, 2 * np.pi, 100)
+        sr = SqrtRealCoefficient(coeff)
+
+        for w in [0, 1, 2, 3]:
+            sr2 = sr.replace_arguments(w=w)
+            self.assert_f_equals_sqrt_real(
+                sr2, coeff.replace_arguments(w=w), tlist,
+            )
+
+    def test_reduce(self):
+        coeff = coefficient(sin_t)
+        tlist = np.linspace(0, np.pi, 10)
+        sr = SqrtRealCoefficient(coeff)
+
+        data = pickle.dumps(sr, protocol=-1)
+        sr = pickle.loads(data)
+        self.assert_f_equals_sqrt_real(sr, coeff, tlist)

From 9295f507025fbf6e3457664db1c633009260d04e Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 11:11:44 +0200
Subject: [PATCH 285/602] Add pickle test for ConstantCoefficient.

---
 qutip/tests/core/test_coefficient.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index a91ab58e87..0906719225 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -93,6 +93,8 @@ def coeff_generator(style, func):
     if style == "steparraylog":
         return coefficient(base(tlistlog, **args), tlist=tlistlog,
                            order=0)
+    if style == "const":
+        return const(2.0)
 
 
 @pytest.mark.parametrize(['base', 'kwargs', 'tol'], [
@@ -305,7 +307,8 @@ def _mul(coeff):
     pytest.param("arraylog", id="logarray"),
     pytest.param("string", id="string"),
     pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
+    pytest.param("steparraylog", id="steparraylog"),
+    pytest.param("const", id="constant"),
 ])
 @pytest.mark.parametrize(['transform'], [
     pytest.param(_pass, id="single"),

From 3a41e794d2cc3a33a95b787ff3a983461331f133 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Thu, 6 Apr 2023 11:50:07 +0200
Subject: [PATCH 286/602] added reference to the relevant equation

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 938ecb7417..60d57c7fbf 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -284,7 +284,8 @@ The two steps of calculating the Bloch-Redfield tensor and evolving according to
 where the resulting `output` is an instance of the class :class:`qutip.Result`.
 
 .. note::
-    While the code example simulates the Bloch-Redfield equation in the secular approximation, QuTiP's implementation allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting ``sec_cutoff=-1``, as well as do a partial secular approximation by setting it to a  ``float`` meaning a higher cutoff, its default value is 0.1 which corresponds to the secular approximation.
+    While the code example simulates the Bloch-Redfield equation in the secular approximation, QuTiP's implementation allows the user to simulate the non-secular version of the Bloch-Redfield equation by setting ``sec_cutoff=-1``, as well as do a partial secular approximation by setting it to a  ``float`` , this float will become the cutoff for the sum in :eq:`br-final` meaning terms with :math:`|\omega_{ab}-\omega_{cd}|` greater than the cutoff will be neglected.
+    Its default value is 0.1 which corresponds to the secular approximation.
     For example the command
     ::
 

From 89e750996453db7753bf258834a9999c261cbcb4 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 12:34:32 +0200
Subject: [PATCH 287/602] Add as_double method to RateShiftCoefficient for use
 with SciPy's integrators.

---
 qutip/solver/cy/nm_mcsolve.pxd           | 2 ++
 qutip/solver/cy/nm_mcsolve.pyx           | 6 +++++-
 qutip/tests/solver/cy/test_nm_mcsolve.py | 7 +++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/qutip/solver/cy/nm_mcsolve.pxd b/qutip/solver/cy/nm_mcsolve.pxd
index d5d4389973..8f5df2ea55 100644
--- a/qutip/solver/cy/nm_mcsolve.pxd
+++ b/qutip/solver/cy/nm_mcsolve.pxd
@@ -6,6 +6,8 @@ cdef class RateShiftCoefficient(Coefficient):
     cdef:
         Coefficient [:] coeffs
 
+    cpdef double as_double(self, double t) except *
+
 
 cdef class SqrtRealCoefficient(Coefficient):
     cdef:
diff --git a/qutip/solver/cy/nm_mcsolve.pyx b/qutip/solver/cy/nm_mcsolve.pyx
index 9bf59df932..41dff11a97 100644
--- a/qutip/solver/cy/nm_mcsolve.pyx
+++ b/qutip/solver/cy/nm_mcsolve.pyx
@@ -53,7 +53,7 @@ cdef class RateShiftCoefficient(Coefficient):
         )
 
     cdef complex _call(self, double t) except *:
-        """Return the min value."""
+        """ Return the rate shift. """
         cdef int N = len(self.coeffs)
         cdef int i
         cdef double min_rate = 0
@@ -65,6 +65,10 @@ cdef class RateShiftCoefficient(Coefficient):
 
         return 2 * abs(min_rate)
 
+    cpdef double as_double(self, double t) except *:
+        """ Return the rate shift as a float. """
+        return real(self._call(t))
+
     cpdef Coefficient copy(self):
         """Return a copy of the :obj:`Coefficient`."""
         return RateShiftCoefficient(
diff --git a/qutip/tests/solver/cy/test_nm_mcsolve.py b/qutip/tests/solver/cy/test_nm_mcsolve.py
index 025b39c093..d37514d6de 100644
--- a/qutip/tests/solver/cy/test_nm_mcsolve.py
+++ b/qutip/tests/solver/cy/test_nm_mcsolve.py
@@ -83,6 +83,13 @@ def test_call(self, rates):
         rs = RateShiftCoefficient(rates.coeffs)
         self.assert_f_equals_rate_shift(rs, rates.coeffs, rates.tlist)
 
+    def test_as_double(self, rates):
+        rs = RateShiftCoefficient(rates.coeffs)
+        self.assert_f_equals_rate_shift(
+            rs.as_double, rates.coeffs, rates.tlist,
+        )
+        assert all(isinstance(rs.as_double(t), float) for t in rates.tlist)
+
     def test_copy(self, rates):
         rs = RateShiftCoefficient(rates.coeffs)
         rs = rs.copy()

From c91c7de6dda53b9c2d27a3c6c2d7838ff30959fd Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 12:38:32 +0200
Subject: [PATCH 288/602] Update nm_mcsolver to use RateShiftCoefficient and
 SqrtRealCoefficient.

---
 qutip/solver/nm_mcsolve.py | 122 ++++++++++++++++++++++++++-----------
 1 file changed, 88 insertions(+), 34 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 88a5415368..ca7dd5eaef 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -10,9 +10,9 @@
 from .mcsolve import MCSolver, MCIntegrator
 from .mesolve import MESolver, mesolve
 from .result import NmmcResult, NmmcTrajectoryResult
-from .cy.nm_mcsolve import RateSet
+from .cy.nm_mcsolve import RateShiftCoefficient, SqrtRealCoefficient
 from ..core import (
-    CoreOptions, Qobj, QobjEvo, isket, ket2dm, qeye, coefficient, Coefficient,
+    CoreOptions, Qobj, QobjEvo, isket, ket2dm, qeye, coefficient,
 )
 
 
@@ -260,7 +260,9 @@ class NonMarkovianMCSolver(MCSolver):
     # "solver" argument will be partially initialized in constructor
     trajectory_resultclass = NmmcTrajectoryResult
 
-    def __init__(self, H, ops_and_rates, *_args, args=None, options=None, **kwargs):
+    def __init__(
+        self, H, ops_and_rates, *_args, args=None, options=None, **kwargs,
+    ):
         self.trajectory_resultclass = functools.partial(
             NmmcTrajectoryResult, __nm_solver=self,
         )
@@ -279,12 +281,22 @@ def __init__(self, H, ops_and_rates, *_args, args=None, options=None, **kwargs):
         if L is not None:
             ops_and_rates.append((L, coefficient.const(0)))
 
-        self.rates = RateSet(
-            np.array([f for _, f in ops_and_rates], dtype=Coefficient)
-        )
-        self.ops = [op for op, _ in ops_and_rates]
+        self._ops = [op for op, _ in ops_and_rates]
+
+        # Many coefficients. These should not be publicly exposed
+        # and will all need to be updated in _arguments():
+        self._rates = [rate for _, rate in ops_and_rates]
+        self._rate_shift = RateShiftCoefficient(self._rates)
+        self._sqrt_shifted_rates = [
+            SqrtRealCoefficient(rate + self._rate_shift)
+            for rate in self._rates
+        ]
 
-        c_ops = self._compute_paired_c_ops()
+        c_ops = [
+            QobjEvo([op, sqrt_shifted_rate])
+            for op, sqrt_shifted_rate
+            in zip(self._ops, self._sqrt_shifted_rates)
+        ]
         super().__init__(H, c_ops, *_args, options=options, **kwargs)
 
     def _check_completeness(self, ops_and_rates):
@@ -307,37 +319,21 @@ def _check_completeness(self, ops_and_rates):
         L = (a * qeye(op.dims[0]) - op).sqrtm()  # new Lindblad operator
         return a, L
 
-    def _compute_paired_c_ops(self):
-        """
-        Shift all given rate functions Gamma_i by the function rate_shift,
-        creating the positive definite rate functions
-            gamma_i = Gamma_i + rate_shift.
-        Returns the collapse operators
-            c_i = L_i * sqrt(gamma_i)
-        as QobjEvo objects.
-        """
-        c_ops = []
-        for i, op in enumerate(self.ops):
-            # Note that this cannot be done using a lambda expression, since
-            # lambda expressions can't be pickled and pickling is required
-            # for parallel execution.
-            c_ops.append(QobjEvo([op, self.rates.sqrt_shifted_rate(i)]))
-        return c_ops
-
     def _discrete_martingale(self, t, i):
         """
-        Discrete part of the martingale evolution for time ``t`` and rate ``i``.
+        Discrete part of the martingale evolution for time ``t`` and
+        rate ``i``.
         """
-        rate = self.rates.rate(t, i)
-        shift = self.rates.rate_shift(t)
-        return rate / (rate + shift)
+        rate = self._rates[i](t)
+        shift = self._rate_shift(t)
+        return np.real(rate / (rate + shift))
 
     def _continuous_martingale(self, t0, t1):
         """
         Continuous part of the martingale evolution for time ``t0`` to ``t1``.
         """
         integral, _abserr, *info = scipy.integrate.quad(
-            self.rates.rate_shift, t0, t1,
+            self._rate_shift.as_double, t0, t1,
             limit=self.options["martingale_quad_limit"],
             full_output=True,
         )
@@ -355,7 +351,9 @@ def _current_martingale(self, t):
         collapses that have happened are read out from the internal integrator.
         """
         discrete = np.prod(self._integrator.discrete_martingales, initial=1.0)
-        continuous = np.prod(self._integrator.continuous_martingales, initial=1.0)
+        continuous = np.prod(
+            self._integrator.continuous_martingales, initial=1.0,
+        )
         if self._integrator.collapses:
             tc, _ = self._integrator.collapses[-1]
             if t > tc:
@@ -363,9 +361,11 @@ def _current_martingale(self, t):
         return discrete * continuous
 
     def _argument(self, args):
-        # RateSet.arguments() updates the original rate
-        # coefficients
-        self.rates.arguments(args)
+        self._rates = [rate.replace_arguments(args) for rate in self._rates]
+        self._rate_shift = self._rate_shift.replace_arguments(args)
+        self._sqrt_shifted_rates = [
+            rate.replace_arguments(args) for rate in self._sqrt_shifted_rates
+        ]
         super()._argument(args)
 
     # Override "step" to include the martingale mu in the state
@@ -377,3 +377,57 @@ def step(self, t, *, args=None, copy=True):
         return state * self._current_martingale(t)
 
     step.__doc__ = MultiTrajSolver.step.__doc__
+
+    def rate_shift(self, t):
+        """
+        Return the rate shift at time ``t``.
+
+        The rate shift is ``2 * abs(min([0, rate_1(t), rate_2(t), ...]))``.
+
+        Parameters
+        ----------
+        t : float
+            The time at which to calculate the rate shift.
+
+        Returns
+        -------
+        rate_shift : float
+            The rate shift amount.
+        """
+        return self._rate_shift.as_double(t)
+
+    def rate(self, t, i):
+        """
+        Return the i'th unshifted rate at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+            The time at which to calculate the rate.
+        i : int
+            Which rate to calculate.
+
+        Returns
+        -------
+        rate : float
+            The value of rate ``i`` at time ``t``.
+        """
+        return np.real(self._rates[i](t))
+
+    def sqrt_shifted_rate(self, t, i):
+        """
+        Return the square root of the i'th unshifted rate at time ``t``.
+
+        Parameters
+        ----------
+        t : float
+            The time at wich to calculate the shifted rate.
+        i : int
+            Which shifted rate to calculate.
+
+        Returns
+        -------
+        rate : float
+            The square root of the shifted value of rate ``i`` at time ``t``.
+        """
+        return np.real(self._sqrt_shifted_rates[i](t))

From 62e4c00c72588b6868417b288a3950c7a5d920aa Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 12:39:09 +0200
Subject: [PATCH 289/602] Add tests for the rate helper methods.

---
 qutip/tests/solver/test_nm_mcsolve.py | 39 +++++++++++++++++++++------
 1 file changed, 31 insertions(+), 8 deletions(-)

diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index 22e0a02e19..59fc07be66 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -54,8 +54,12 @@ def test_rough_agreement_with_mesolve_for_negative_rates():
     )
 
     np.testing.assert_allclose(mc_result.trace, [1.] * len(times))
-    np.testing.assert_allclose(me_result.expect[0], mc_result.expect[0], rtol=0.02)
-    np.testing.assert_allclose(me_result.expect[1], mc_result.expect[1], rtol=0.1)
+    np.testing.assert_allclose(
+        me_result.expect[0], mc_result.expect[0], rtol=0.02,
+    )
+    np.testing.assert_allclose(
+        me_result.expect[1], mc_result.expect[1], rtol=0.1,
+    )
 
 
 def _return_constant(t, args):
@@ -104,7 +108,9 @@ def _assert_expect(self, result, expected, tol):
         for test, expected_part in zip(result.expect, expected):
             np.testing.assert_allclose(test, expected_part, rtol=tol)
 
-    def test_states_and_expect(self, hamiltonian, args, ops_and_rates, expected, tol):
+    def test_states_and_expect(
+        self, hamiltonian, args, ops_and_rates, expected, tol
+    ):
         options = {"store_states": True, "map": "serial"}
         result = nm_mcsolve(
             hamiltonian, self.state, self.times, args=args,
@@ -149,7 +155,9 @@ def pytest_generate_tests(self, metafunc):
     # runtimes shorter.  The known-good cases are still tested in the other
     # test cases, this is just testing the single-output behaviour.
 
-    def test_states_only(self, hamiltonian, args, ops_and_rates, expected, tol):
+    def test_states_only(
+        self, hamiltonian, args, ops_and_rates, expected, tol
+    ):
         options = {"store_states": True, "map": "serial"}
         result = nm_mcsolve(
             hamiltonian, self.state, self.times, args=args,
@@ -158,7 +166,9 @@ def test_states_only(self, hamiltonian, args, ops_and_rates, expected, tol):
         )
         self._assert_states(result, expected, tol)
 
-    def test_expect_only(self, hamiltonian, args, ops_and_rates, expected, tol):
+    def test_expect_only(
+        self, hamiltonian, args, ops_and_rates, expected, tol
+    ):
         result = nm_mcsolve(
             hamiltonian, self.state, self.times, args=args,
             ops_and_rates=ops_and_rates,
@@ -378,7 +388,10 @@ class TestSeeds:
     times = np.linspace(0, 10, 2)
     ops_and_rates = [
         (qutip.tensor(a[0], qutip.qeye(sizes[1:])), 2 * dampings[0]),
-        (qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2])), 2 * dampings[1]),
+        (
+            qutip.tensor(qutip.qeye(sizes[0]), a[1], qutip.qeye(sizes[2])),
+            2 * dampings[1],
+        ),
         (qutip.tensor(qutip.qeye(sizes[:2]), a[2]), 2 * dampings[2]),
     ]
 
@@ -441,7 +454,9 @@ def test_stepping(self):
         a = qutip.destroy(size)
         H = qutip.num(size)
         ops_and_rates = [(a, 'alpha')]
-        mcsolver = NonMarkovianMCSolver(H, ops_and_rates, args={'alpha': 0}, options={'map': 'serial'})
+        mcsolver = NonMarkovianMCSolver(
+            H, ops_and_rates, args={'alpha': 0}, options={'map': 'serial'},
+        )
         mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
         state_1 = mcsolver.step(1, args={'alpha': 1})
 
@@ -531,10 +546,16 @@ def test_NonMarkovianMCSolver_stepping():
     assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
     assert qutip.expect(qutip.num(size), state) == pytest.approx(size - 1)
     assert state.isoper
+    assert solver.rate_shift(1) == 0
+    assert solver.rate(1, 0) == 0
+    assert solver.sqrt_shifted_rate(1, 0) == 0
     state = solver.step(5, args={'coupling': 5})
     assert qutip.expect(qutip.qeye(size), state) == pytest.approx(1)
     assert qutip.expect(qutip.num(size), state) <= size - 1
     assert state.isoper
+    assert solver.rate_shift(5) == 0
+    assert solver.rate(5, 0) == 5
+    assert solver.sqrt_shifted_rate(5, 0) == np.sqrt(5)
 
 
 # Defined in module-scope so it's pickleable.
@@ -552,5 +573,7 @@ def test_dynamic_arguments():
     state = qutip.basis(size, 2)
 
     ops_and_rates = [[a, _dynamic], [a.dag(), _dynamic]]
-    mc = nm_mcsolve(H, state, times, ops_and_rates, ntraj=25, args={"collapse": []})
+    mc = nm_mcsolve(
+        H, state, times, ops_and_rates, ntraj=25, args={"collapse": []},
+    )
     assert all(len(collapses) <= 1 for collapses in mc.col_which)

From d48d66a90c1dc82095b4489129dda3acbf87566c Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 12:42:38 +0200
Subject: [PATCH 290/602] Remove exposing of helpers as attributes of
 coefficient.

---
 qutip/core/coefficient.py | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index 807cdc22eb..b485432d92 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -10,7 +10,6 @@
 import importlib
 import warnings
 import numbers
-from contextlib import contextmanager
 from collections import defaultdict
 from setuptools import setup, Extension
 try:
@@ -197,12 +196,6 @@ def const(value):
     return ConstantCoefficient(value)
 
 
-# XXX: HACKITY HACK
-coefficient.norm = norm
-coefficient.conj = conj
-coefficient.const = const
-
-
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 # %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -391,7 +384,7 @@ def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
         # Previously compiled coefficient not available: create the cython code
         code = make_cy_code(parsed, variables, constants,
                             raw, compile_opt)
-        try :
+        try:
             coeff = compile_code(code, file_name, parsed, compile_opt)
         except PermissionError:
             pass
@@ -783,6 +776,6 @@ class DummySelf:
     loc_env = {"t": 0, 'self': DummySelf}
     try:
         exec(code, str_env, loc_env)
-    except Exception as e:
+    except Exception:
         return False
     return True

From 1aef3d406cb5f73193e1f66cd0071fd8ca4b18c5 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 12:44:20 +0200
Subject: [PATCH 291/602] Replace coefficient.const with direct use of
 ConstantCoefficient.

---
 qutip/solver/nm_mcsolve.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index ca7dd5eaef..f2790f22ff 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -11,6 +11,7 @@
 from .mesolve import MESolver, mesolve
 from .result import NmmcResult, NmmcTrajectoryResult
 from .cy.nm_mcsolve import RateShiftCoefficient, SqrtRealCoefficient
+from ..core.coefficient import ConstantCoefficient
 from ..core import (
     CoreOptions, Qobj, QobjEvo, isket, ket2dm, qeye, coefficient,
 )
@@ -172,7 +173,7 @@ def _parse_op_and_rate(op, rate, **kw):
     if not isinstance(op, Qobj):
         raise ValueError("NonMarkovianMCSolver ops must be of type Qobj")
     if isinstance(rate, numbers.Number):
-        rate = coefficient.const(rate)
+        rate = ConstantCoefficient(rate)
     else:
         rate = coefficient(rate, **kw)
     return op, rate
@@ -279,7 +280,7 @@ def __init__(
 
         self._a_parameter, L = self._check_completeness(ops_and_rates)
         if L is not None:
-            ops_and_rates.append((L, coefficient.const(0)))
+            ops_and_rates.append((L, ConstantCoefficient(0)))
 
         self._ops = [op for op, _ in ops_and_rates]
 

From 5d7644d8e3de8f5e974dc8c5c8103b0f5c14b011 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Thu, 6 Apr 2023 14:10:05 +0200
Subject: [PATCH 292/602] Expose the list of operators as .ops.

---
 qutip/solver/nm_mcsolve.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index f2790f22ff..4ce56b9591 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -282,7 +282,7 @@ def __init__(
         if L is not None:
             ops_and_rates.append((L, ConstantCoefficient(0)))
 
-        self._ops = [op for op, _ in ops_and_rates]
+        self.ops = [op for op, _ in ops_and_rates]
 
         # Many coefficients. These should not be publicly exposed
         # and will all need to be updated in _arguments():
@@ -296,7 +296,7 @@ def __init__(
         c_ops = [
             QobjEvo([op, sqrt_shifted_rate])
             for op, sqrt_shifted_rate
-            in zip(self._ops, self._sqrt_shifted_rates)
+            in zip(self.ops, self._sqrt_shifted_rates)
         ]
         super().__init__(H, c_ops, *_args, options=options, **kwargs)
 

From ff5aabba6386a2050fee045c81f4b8929981d92c Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 6 Apr 2023 17:29:04 -0400
Subject: [PATCH 293/602] Fix memorycascade to work on v5

---
 qutip/solve/nonmarkov/memorycascade.py | 223 +++++++++++++------------
 qutip/solver/propagator.py             |   6 +-
 2 files changed, 125 insertions(+), 104 deletions(-)

diff --git a/qutip/solve/nonmarkov/memorycascade.py b/qutip/solve/nonmarkov/memorycascade.py
index 35996d21cd..1579d9c461 100644
--- a/qutip/solve/nonmarkov/memorycascade.py
+++ b/qutip/solve/nonmarkov/memorycascade.py
@@ -16,7 +16,20 @@
 import numpy as np
 import warnings
 
-import qutip as qt
+from qutip import (
+    sprepost,
+    Qobj,
+    spre,
+    spost,
+    liouvillian,
+    qeye,
+    mesolve,
+    propagator,
+    composite,
+    isket,
+    ket2dm,
+    tensor_contract,
+)
 
 
 class MemoryCascade:
@@ -49,35 +62,39 @@ class MemoryCascade:
         Integrator method to use. Defaults to 'propagator' which tends to be
         faster for long times (i.e., large Hilbert space).
 
-    parallel : bool
-        Run integrator in parallel if True. Only implemented for 'propagator'
-        as the integrator method.
-
     options : dict
         Generic solver options.
     """
 
-    def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
-                 integrator='propagator', parallel=False, options=None):
+    def __init__(
+        self,
+        H_S,
+        L1,
+        L2,
+        S_matrix=None,
+        c_ops_markov=None,
+        integrator="propagator",
+        options=None,
+    ):
 
         if options is None:
-            self.options = {}
+            self.options = {"progress_bar": False}
         else:
             self.options = options
 
         self.H_S = H_S
         self.sysdims = H_S.dims
-        if isinstance(L1, qt.Qobj):
+        if isinstance(L1, Qobj):
             self.L1 = [L1]
         else:
             self.L1 = L1
-        if isinstance(L2, qt.Qobj):
+        if isinstance(L2, Qobj):
             self.L2 = [L2]
         else:
             self.L2 = L2
         if not len(self.L1) == len(self.L2):
-            raise ValueError('L1 and L2 has to be of equal length.')
-        if isinstance(c_ops_markov, qt.Qobj):
+            raise ValueError("L1 and L2 has to be of equal length.")
+        if isinstance(c_ops_markov, Qobj):
             self.c_ops_markov = [c_ops_markov]
         else:
             self.c_ops_markov = c_ops_markov
@@ -87,12 +104,19 @@ def __init__(self, H_S, L1, L2, S_matrix=None, c_ops_markov=None,
         else:
             self.S_matrix = S_matrix
         # create system identity superoperator
-        self.Id = qt.qeye(H_S.shape[0])
+        self.Id = qeye(H_S.shape[0])
         self.Id.dims = self.sysdims
-        self.Id = qt.sprepost(self.Id, self.Id)
-        self.store_states = self.options['store_states']
+        self.Id = sprepost(self.Id, self.Id)
+        self.store_states = self.options.get("store_states", False)
         self.integrator = integrator
-        self.parallel = parallel
+        self._generators = {}
+
+    def generator(self, k):
+        if k not in self._generators:
+            self._generators[k] = _generator(
+                k, self.H_S, self.L1, self.L2, self.S_matrix, self.c_ops_markov
+            )
+        return self._generators[k]
 
     def propagator(self, t, tau, notrace=False):
         """
@@ -116,25 +140,21 @@ def propagator(self, t, tau, notrace=False):
         : :class:`qutip.Qobj`
             time-propagator for reduced system dynamics
         """
-        k = int(t/tau)+1
-        s = t-(k-1)*tau
-        G1, E0 = _generator(k, self.H_S, self.L1, self.L2, self.S_matrix,
-                            self.c_ops_markov)
-        E = _integrate(G1, E0, 0., s, integrator=self.integrator,
-                       parallel=self.parallel, opt=self.options)
+        k = int(t / tau) + 1
+        s = t - (k - 1) * tau
+        G1 = self.generator(k)
+        E0 = qeye(G1.dims[0])
+        E = _integrate(G1, E0, 0.0, s, integrator=self.integrator, opt=self.options)
         if k > 1:
-            G2, null = _generator(k-1, self.H_S, self.L1, self.L2,
-                                  self.S_matrix, self.c_ops_markov)
-            G2 = qt.composite(G2, self.Id)
-            E = _integrate(G2, E, s, tau, integrator=self.integrator,
-                    parallel=self.parallel, opt=self.options)
-        E.dims = E0.dims
+            G2 = self.generator(k - 1)
+            G2 = composite(G2, self.Id)
+            E = _integrate(G2, E, s, tau, integrator=self.integrator, opt=self.options)
+
         if not notrace:
             E = _genptrace(E, k)
         return E
 
-    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
-                           notrace=False):
+    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None, notrace=False):
         r"""
         Compute propagator for computing output field expectation values
         <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
@@ -181,58 +201,62 @@ def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None,
         if c1 is None and len(self.L1) == 1:
             c1 = self.L1[0]
         else:
-            raise ValueError('Argument c1 has to be specified when more than' +
-                             'one collapse operator couples to the feedback' +
-                             'loop.')
+            raise ValueError(
+                "Argument c1 has to be specified when more than"
+                + "one collapse operator couples to the feedback"
+                + "loop."
+            )
         if c2 is None and len(self.L2) == 1:
             c2 = self.L2[0]
         else:
-            raise ValueError('Argument c1 has to be specified when more than' +
-                             'one collapse operator couples to the feedback' +
-                             'loop.')
+            raise ValueError(
+                "Argument c1 has to be specified when more than"
+                + "one collapse operator couples to the feedback"
+                + "loop."
+            )
         klist = []
         slist = []
         for t in tlist:
-            klist.append(int(t/tau)+1)
-            slist.append(t-(klist[-1]-1)*tau)
+            klist.append(int(t / tau) + 1)
+            slist.append(t - (klist[-1] - 1) * tau)
         kmax = max(klist)
         zipped = sorted(zip(slist, klist, blist))
         slist = [s for (s, k, b) in zipped]
         klist = [k for (s, k, b) in zipped]
         blist = [b for (s, k, b) in zipped]
 
-        G1, E0 = _generator(kmax, self.H_S, self.L1, self.L2, self.S_matrix,
-                            self.c_ops_markov)
-        sprev = 0.
+        G1 = self.generator(kmax)
+        sprev = 0.0
+        E0 = qeye(G1.dims[0])
         E = E0
         for i, s in enumerate(slist):
-            E = _integrate(G1, E, sprev, s, integrator=self.integrator,
-                    parallel=self.parallel, opt=self.options)
+            E = _integrate(
+                G1, E, sprev, s, integrator=self.integrator, opt=self.options
+            )
+            l2 = _localop(c2, klist[i], kmax)
             if klist[i] == 1:
-                l1 = 0.*qt.Qobj()
+                l1 = l2 * 0.0
             else:
-                l1 = _localop(c1, klist[i]-1, kmax)
-            l2 = _localop(c2, klist[i], kmax)
+                l1 = _localop(c1, klist[i] - 1, kmax)
             if blist[i] == 0:
                 superop = self.Id
             elif blist[i] == 1:
-                superop = qt.spre(l1+l2)
+                superop = spre(l1 + l2)
             elif blist[i] == 2:
-                superop = qt.spost(l1.dag()+l2.dag())
+                superop = spost(l1.dag() + l2.dag())
             elif blist[i] == 3:
-                superop = qt.spre(l1)
+                superop = spre(l1)
             elif blist[i] == 4:
-                superop = qt.spost(l1.dag())
+                superop = spost(l1.dag())
             else:
-                raise ValueError('Allowed values in blist are 0, 1, 2, 3 ' +
-                                 'and 4.')
-            superop.dims = E.dims
-            E = superop*E
+                raise ValueError("Allowed values in blist are 0, 1, 2, 3 and 4.")
+
+            E = superop @ E
             sprev = s
-        E = _integrate(G1, E, slist[-1], tau, integrator=self.integrator,
-                parallel=self.parallel, opt=self.options)
+        E = _integrate(
+            G1, E, slist[-1], tau, integrator=self.integrator, opt=self.options
+        )
 
-        E.dims = E0.dims
         if not notrace:
             E = _genptrace(E, kmax)
         return E
@@ -257,12 +281,11 @@ def rhot(self, rho0, t, tau):
         : :class:`qutip.Qobj`
             density matrix at time :math:`t`
         """
-        if qt.isket(rho0):
-            rho0 = qt.ket2dm(rho0)
+        if isket(rho0):
+            rho0 = ket2dm(rho0)
 
         E = self.propagator(t, tau)
-        rhovec = qt.operator_to_vector(rho0)
-        return qt.vector_to_operator(E*rhovec)
+        return E(rho0)
 
     def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
         r"""
@@ -306,9 +329,11 @@ def outfieldcorr(self, rho0, blist, tlist, tau, c1=None, c2=None):
         : complex
             expectation value of field correlation function
         """
+        if isket(rho0):
+            rho0 = ket2dm(rho0)
+
         E = self.outfieldpropagator(blist, tlist, tau)
-        rhovec = qt.operator_to_vector(rho0)
-        return (qt.vector_to_operator(E*rhovec)).tr()
+        return (E(rho0)).tr()
 
 
 def _localop(op, l, k):
@@ -317,15 +342,14 @@ def _localop(op, l, k):
     with identity operators on all the other k-1 systems
     """
     if l < 1 or l > k:
-        raise IndexError('index l out of range')
-    h = op
-    I = qt.qeye(op.shape[0])
-    I.dims = op.dims
-    for i in range(1, l):
-        h = qt.tensor(I, h)
-    for i in range(l+1, k+1):
-        h = qt.tensor(h, I)
-    return h
+        raise IndexError("index l out of range")
+    out = op
+    if l > 1:
+        out = qeye(op.dims[0] * (l - 1)) & out
+    if l < k:
+        out = out & qeye(op.dims[0] * (k - l))
+
+    return out
 
 
 def _genptrace(E, k):
@@ -333,9 +357,9 @@ def _genptrace(E, k):
     Perform a gneralized partial trace on a superoperator E, tracing out all
     subsystems but one.
     """
-    for l in range(k-1):
+    for l in range(k - 1):
         nsys = len(E.dims[0][0])
-        E = qt.tensor_contract(E, (0, 2*nsys+1), (nsys, 3*nsys+1))
+        E = tensor_contract(E, (0, 2 * nsys + 1), (nsys, 3 * nsys + 1))
     return E
 
 
@@ -343,63 +367,56 @@ def _generator(k, H, L1, L2, S=None, c_ops_markov=None):
     """
     Create a Liouvillian for a cascaded chain of k system copies
     """
-    id = qt.qeye(H.dims[0][0])
-    Id = qt.sprepost(id, id)
+    id = qeye(H.dims[0][0])
+    Id = sprepost(id, id)
     if S is None:
         S = np.identity(len(L1))
     # create Lindbladian
-    L = qt.Qobj()
-    E0 = Id
+
     # first system
-    L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2])
+    L = liouvillian(None, [_localop(c, 1, k) for c in L2])
     for l in range(1, k):
-        # Identiy superoperator
-        E0 = qt.composite(E0, Id)
         # Bare Hamiltonian
         Hl = _localop(H, l, k)
-        L += qt.liouvillian(Hl, [])
+        L += liouvillian(Hl, [])
         # Markovian Decay channels
         if c_ops_markov is not None:
             for c in c_ops_markov:
                 cl = _localop(c, l, k)
-                L += qt.liouvillian(None, [cl])
+                L += liouvillian(None, [cl])
         # Cascade coupling
         c1 = np.array([_localop(c, l, k) for c in L1])
-        c2 = np.array([_localop(c, l+1, k) for c in L2])
+        c2 = np.array([_localop(c, l + 1, k) for c in L2])
         c2dag = np.array([c.dag() for c in c2])
-        Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1))
+        Hcasc = -0.5j * np.dot(c2dag, np.dot(S, c1))
         Hcasc += Hcasc.dag()
         Lvec = c2 + np.dot(S, c1)
-        L += qt.liouvillian(Hcasc, [c for c in Lvec])
+        L += liouvillian(Hcasc, [c for c in Lvec])
     # last system
-    L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
+    L += liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1])
     if c_ops_markov is not None:
         for c in c_ops_markov:
             cl = _localop(c, k, k)
-            L += qt.liouvillian(None, [cl])
-    E0.dims = L.dims
-    # return generator and identity superop E0
-    return L, E0
+            L += liouvillian(None, [cl])
+    # return generator
+    return L
 
 
-def _integrate(L, E0, ti, tf, integrator='propagator', parallel=False,
-        opt=None):
+def _integrate(L, E0, ti, tf, integrator="propagator", opt=None):
     """
     Basic ode integrator
     """
     opt = opt or {}
     if tf > ti:
-        if integrator == 'mesolve':
-            if parallel:
-                warnings.warn('parallelization not implemented for "mesolve"')
-            opt.store_final_state = True
-            sol = qt.mesolve(L, E0, [ti, tf], [], [], options=opt)
+        if integrator == "mesolve":
+            opt["store_final_state"] = True
+            sol = mesolve(L, E0, [ti, tf], options=opt)
             return sol.final_state
-        elif integrator == 'propagator':
-            return qt.propagator(L, (tf-ti), [], [], parallel=parallel,
-                                 options=opt)*E0
+        elif integrator == "propagator":
+            return propagator(L, (tf - ti), options=opt) @ E0
         else:
-            raise ValueError('integrator keyword must be either "propagator"' +
-                              'or "mesolve"')
+            raise ValueError(
+                'integrator keyword must be either "propagator" or "mesolve"'
+            )
     else:
         return E0
diff --git a/qutip/solver/propagator.py b/qutip/solver/propagator.py
index 179c0dcef0..1933e18a60 100644
--- a/qutip/solver/propagator.py
+++ b/qutip/solver/propagator.py
@@ -62,7 +62,11 @@ def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
         H = QobjEvo(H, args=args, **kwargs)
 
     if H.issuper or c_ops:
-        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
+        if H.issuper:
+            Id = qeye(H.dims[0])
+        else:
+            Id = qeye(H.dims)
+        out = mesolve(H, Id, tlist, c_ops=c_ops,
                       args=args, options=options).states
     else:
         out = sesolve(H, qeye(H.dims[0]), tlist,

From 4d194aef8f1edf40fc872776fe878e7d12b6ecb9 Mon Sep 17 00:00:00 2001
From: Gerardo Jose Suarez <31544007+mcditoos@users.noreply.github.com>
Date: Mon, 10 Apr 2023 17:49:41 +0200
Subject: [PATCH 294/602] Update doc/guide/dynamics/dynamics-bloch-redfield.rst
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Eric Giguère <eric.giguere@calculquebec.ca>
---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 60d57c7fbf..2c705e65f1 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -289,7 +289,7 @@ where the resulting `output` is an instance of the class :class:`qutip.Result`.
     For example the command
     ::
 
-        output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(),ohmic_spectrum]], e_ops=e_ops,sec_cutoff=-1)
+        output = brmesolve(H, psi0, tlist, a_ops=[[sigmax(), ohmic_spectrum]], e_ops=e_ops, sec_cutoff=-1)
     
     will simulate the same example as above without the secular approximation. Note that using the non-secular version may lead to negativity issues.
 

From 99a7830f4ebdde79e7d239c405f7acb2af63a0f2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 11 Apr 2023 08:13:12 -0400
Subject: [PATCH 295/602] remove start

---
 qutip/solver/correlation.py |  7 +--
 qutip/solver/floquet.py     |  7 +--
 qutip/solver/parallel.py    | 19 ++++----
 qutip/solver/solver_base.py |  7 +--
 qutip/ui/progressbar.py     | 91 ++++++++++++++++++-------------------
 5 files changed, 67 insertions(+), 64 deletions(-)

diff --git a/qutip/solver/correlation.py b/qutip/solver/correlation.py
index b05514c519..b51c8d01f3 100644
--- a/qutip/solver/correlation.py
+++ b/qutip/solver/correlation.py
@@ -17,7 +17,7 @@
 from .heom.bofin_solvers import HEOMSolver
 
 from .steadystate import steadystate
-from ..ui.progressbar import progess_bars
+from ..ui.progressbar import progress_bars
 
 # -----------------------------------------------------------------------------
 # PUBLIC API
@@ -495,8 +495,9 @@ def _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C):
         solver.options["normalize_output"] = False
         solver.options["progress_bar"] = False
 
-        progress_bar = progess_bars[old_opt['progress_bar']]()
-        progress_bar.start(len(taulist) + 1, **old_opt['progress_kwargs'])
+        progress_bar = progress_bars[old_opt['progress_bar']](
+            len(taulist) + 1, **old_opt['progress_kwargs']
+        )
         rho_t = solver.run(state0, tlist).states
         corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
         progress_bar.update()
diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
index 7ce6cc4f11..688315d19a 100644
--- a/qutip/solver/floquet.py
+++ b/qutip/solver/floquet.py
@@ -15,7 +15,7 @@
 from .integrator import Integrator
 from .result import Result
 from time import time
-from ..ui.progressbar import progess_bars
+from ..ui.progressbar import progress_bars
 
 
 class FloquetBasis:
@@ -918,8 +918,9 @@ def run(self, state0, tlist, *, floquet=False, args=None, e_ops=None):
         results.add(tlist[0], self._restore_state(_data0, copy=False))
         stats["preparation time"] += time() - _time_start
 
-        progress_bar = progess_bars[self.options["progress_bar"]]()
-        progress_bar.start(len(tlist) - 1, **self.options["progress_kwargs"])
+        progress_bar = progress_bars[self.options["progress_bar"]](
+            len(tlist) - 1, **self.options["progress_kwargs"]
+        )
         for t, state in self._integrator.run(tlist):
             progress_bar.update()
             results.add(t, self._restore_state(state, copy=False))
diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
index 4ceeb0fc44..57d0ed175b 100644
--- a/qutip/solver/parallel.py
+++ b/qutip/solver/parallel.py
@@ -10,7 +10,7 @@
 import time
 import threading
 import concurrent.futures
-from qutip.ui.progressbar import progess_bars
+from qutip.ui.progressbar import progress_bars
 from qutip.settings import available_cpu_count
 
 if sys.platform == 'darwin':
@@ -94,8 +94,9 @@ def serial_map(task, values, task_args=None, task_kwargs=None,
     if task_kwargs is None:
         task_kwargs = {}
     map_kw = _read_map_kw(map_kw)
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
+    progress_bar = progress_bars[progress_bar](
+        len(values), **progress_bar_kwargs
+    )
     end_time = map_kw['timeout'] + time.time()
     results = None
     if reduce_func is None:
@@ -104,7 +105,7 @@ def serial_map(task, values, task_args=None, task_kwargs=None,
     for n, value in enumerate(values):
         if time.time() > end_time:
             break
-        progress_bar.update(n)
+        progress_bar.update()
         try:
             result = task(value, *task_args, **task_kwargs)
         except Exception as err:
@@ -177,8 +178,9 @@ def parallel_map(task, values, task_args=None, task_kwargs=None,
     end_time = map_kw['timeout'] + time.time()
     job_time = map_kw['job_timeout']
 
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
+    progress_bar = progress_bars[progress_bar](
+        len(values), **progress_bar_kwargs
+    )
 
     errors = {}
     if reduce_func is not None:
@@ -311,8 +313,9 @@ def loky_pmap(task, values, task_args=None, task_kwargs=None,
     os.environ['QUTIP_IN_PARALLEL'] = 'TRUE'
     from loky import get_reusable_executor, TimeoutError
 
-    progress_bar = progess_bars[progress_bar]()
-    progress_bar.start(len(values), **progress_bar_kwargs)
+    progress_bar = progress_bars[progress_bar](
+        len(values), **progress_bar_kwargs
+    )
 
     executor = get_reusable_executor(max_workers=map_kw['num_cpus'])
     end_time = map_kw['timeout'] + time.time()
diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index 953bfab490..a87c7f674d 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -5,7 +5,7 @@
 from ..core import stack_columns, unstack_columns
 from .result import Result
 from .integrator import Integrator
-from ..ui.progressbar import progess_bars
+from ..ui.progressbar import progress_bars
 from time import time
 
 
@@ -150,8 +150,9 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
         results.add(tlist[0], self._restore_state(_data0, copy=False))
         stats['preparation time'] += time() - _time_start
 
-        progress_bar = progess_bars[self.options['progress_bar']]()
-        progress_bar.start(len(tlist)-1, **self.options['progress_kwargs'])
+        progress_bar = progress_bars[self.options['progress_bar']](
+            len(tlist)-1, **self.options['progress_kwargs']
+        )
         for t, state in self._integrator.run(tlist):
             progress_bar.update()
             results.add(t, self._restore_state(state, copy=False))
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index 8bebca7038..ac7766fad4 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -1,10 +1,11 @@
 __all__ = ['BaseProgressBar', 'TextProgressBar',
            'EnhancedTextProgressBar', 'TqdmProgressBar',
-           'HTMLProgressBar', 'progess_bars']
+           'HTMLProgressBar', 'progress_bars']
 
 import time
 import datetime
 import sys
+from qutip import settings
 
 
 class BaseProgressBar(object):
@@ -16,16 +17,16 @@ class BaseProgressBar(object):
         n_vec = linspace(0, 10, 100)
         pbar = TextProgressBar(len(n_vec))
         for n in n_vec:
-            pbar.update(n)
+            pbar.update()
             compute_with_n(n)
         pbar.finished()
 
     """
 
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
+    def __init__(self, iterations=0, chunk_size=10, **kwargs):
+        self._start(iterations, chunk_size)
 
-    def start(self, iterations, chunk_size=10, **kwargs):
+    def _start(self, iterations, chunk_size=10, **kwargs):
         self.N = float(iterations)
         self.n = 0
         self.p_chunk_size = chunk_size
@@ -33,7 +34,7 @@ def start(self, iterations, chunk_size=10, **kwargs):
         self.t_start = time.time()
         self.t_done = self.t_start - 1
 
-    def update(self, n=None):
+    def update(self):
         pass
 
     def total_time(self):
@@ -63,14 +64,10 @@ class TextProgressBar(BaseProgressBar):
     A simple text-based progress bar.
     """
 
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-        # super(TextProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        super(TextProgressBar, self).start(iterations, chunk_size)
+    def __init__(self, iterations=0, chunk_size=10, **kwargs):
+        super()._start(iterations, chunk_size)
 
-    def update(self, n=None):
+    def update(self):
         self.n += 1
         n = self.n
         p = (n / self.N) * 100.0
@@ -91,16 +88,12 @@ class EnhancedTextProgressBar(BaseProgressBar):
     An enhanced text-based progress bar.
     """
 
-    def __init__(self, iterations=0, chunk_size=10):
-        pass
-        # super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations, chunk_size=10, **kwargs):
-        super(EnhancedTextProgressBar, self).start(iterations, chunk_size)
+    def __init__(self, iterations=0, chunk_size=10, **kwargs):
+        super()._start(iterations, chunk_size)
         self.fill_char = '*'
         self.width = 25
 
-    def update(self, n=None):
+    def update(self):
         self.n += 1
         n = self.n
         percent_done = int(round(n / self.N * 100.0))
@@ -128,16 +121,13 @@ class TqdmProgressBar(BaseProgressBar):
     A progress bar using tqdm module
     """
 
-    def __init__(self, iterations=0, chunk_size=10):
+    def __init__(self, iterations=0, chunk_size=10, **kwargs):
         from tqdm.auto import tqdm
-        self.tqdm = tqdm
-
-    def start(self, iterations, **kwargs):
-        self.pbar = self.tqdm(total=iterations, **kwargs)
+        self.pbar = tqdm(total=iterations, **kwargs)
         self.t_start = time.time()
         self.t_done = self.t_start - 1
 
-    def update(self, n=None):
+    def update(self):
         self.pbar.update()
 
     def finished(self):
@@ -156,36 +146,43 @@ class HTMLProgressBar(BaseProgressBar):
         n_vec = linspace(0, 10, 100)
         pbar = HTMLProgressBar(len(n_vec))
         for n in n_vec:
-            pbar.update(n)
+            pbar.update()
             compute_with_n(n)
     """
 
-    def __init__(self, iterations=0, chunk_size=1.0):
+    def __init__(self, iterations=0, chunk_size=1.0, **kwargs):
+        if not settings.ipython:
+            raise ValueError(
+                "HTMLProgressBar is only available when using ipython"
+            )
+        from IPython.display import HTML, Javascript, display
+        import uuid
+
+        self.display = display
+        self.Javascript = Javascript
         self.divid = str(uuid.uuid4())
         self.textid = str(uuid.uuid4())
-        self.pb = HTML("""\
-<div style="border: 2px solid grey; width: 600px">
-  <div id="%s" \
-style="background-color: rgba(121,195,106,0.75); width:0%%">&nbsp;</div>
-</div>
-<p id="%s"></p>
-""" % (self.divid, self.textid))
-        display(self.pb)
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def start(self, iterations=0, chunk_size=1.0):
-        super(HTMLProgressBar, self).start(iterations, chunk_size)
-
-    def update(self, n):
+        self.pb = HTML(
+            '<div style="border: 2px solid grey; width: 600px">\n  '
+            f'<div id="{self.divid}" '
+            'style="background-color: rgba(121,195,106,0.75); '
+            'width:0%">&nbsp;</div>\n'
+            '</div>\n'
+            f'<p id="{self.textid}"></p>\n'
+        )
+        self.display(self.pb)
+        super()._start(iterations, chunk_size)
+
+    def update(self):
+        self.n += 1
+        n = self.n
         p = (n / self.N) * 100.0
         if p >= self.p_chunk:
             lbl = ("Elapsed time: %s. " % self.time_elapsed() +
                    "Est. remaining time: %s." % self.time_remaining_est(p))
             js_code = ("$('div#%s').width('%i%%');" % (self.divid, p) +
                        "$('p#%s').text('%s');" % (self.textid, lbl))
-            display(Javascript(js_code))
-            # display(Javascript("$('div#%s').width('%i%%')" % (self.divid,
-            # p)))
+            self.display(self.Javascript(js_code))
             self.p_chunk += self.p_chunk_size
 
     def finished(self):
@@ -193,10 +190,10 @@ def finished(self):
         lbl = "Elapsed time: %s" % self.time_elapsed()
         js_code = ("$('div#%s').width('%i%%');" % (self.divid, 100.0) +
                    "$('p#%s').text('%s');" % (self.textid, lbl))
-        display(Javascript(js_code))
+        self.display(self.Javascript(js_code))
 
 
-progess_bars = {
+progress_bars = {
     "Enhanced": EnhancedTextProgressBar,
     "enhanced": EnhancedTextProgressBar,
     "Text": TextProgressBar,

From 88c3d3972de716b20989f74504a421b5032f3f07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Tue, 11 Apr 2023 09:10:41 -0400
Subject: [PATCH 296/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/data/dispatch.pyx | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 308efe7347..b632fbb751 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -46,9 +46,9 @@ cdef class _constructed_specialisation:
     See `self.__signature__` or `self.__text_signature__` for the call
     signature of this object.
     """
-    cdef readonly Py_ssize_t _output
+    cdef readonly bint _output
     cdef object _call
-    cdef readonly Py_ssize_t _n_input_converters
+    cdef readonly Py_ssize_t _n_inputs
     cdef readonly tuple types
     cdef readonly tuple _converters
     cdef readonly str _short_name
@@ -71,21 +71,21 @@ cdef class _constructed_specialisation:
         self.__module__ = dispatcher.__module__
         self.__signature__ = dispatcher.__signature__
         self.__text_signature__ = dispatcher.__text_signature__
-        self._output = len(types) - 1 if out else -1
+        self._output = out
         self._call = base
         self.types = types
         self.direct = direct
         self._converters = converters
-        self._n_input_converters = len(converters) - out
+        self._n_inputs = len(converters) - out
 
     def __call__(self, *args, **kwargs):
         cdef int i
-        cdef list datas = []
-        for i in range(self._n_input_converters):
-            datas.append(self._converters[i](args[i]))
-        out = self._call(*datas, *args[self._n_input_converters:], **kwargs)
-        if self._output != -1:
-            out = self._converters[self._output](out)
+        cdef list _args = list(args)
+        for i in range(self._n_inputs):
+            _args[i] = self._converters[i](args[i])
+        out = self._call(*_args, **kwargs)
+        if self._output:
+            out = self._converters[-1](out)
         return out
 
     def __repr__(self):
@@ -369,7 +369,7 @@ cdef class Dispatcher:
         return "<dispatcher: " + self.__text_signature__ + ">"
 
     def __call__(self, *args, dtype=None, **kwargs):
-        cdef list dispatch = []
+        cdef list dispatch = [None] * self._n_dispatch
         cdef int i
         if self._pass_on_dtype:
             kwargs['dtype'] = dtype

From 9884dcfacfa6a9109058ccf99cf3b0a4e8b7f169 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 11 Apr 2023 16:29:00 +0200
Subject: [PATCH 297/602] Update imports of cnot, hadamard_transform and
 hinton.

---
 doc/guide/guide-super.rst | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index d88446d964..80f4e42fc5 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -23,10 +23,11 @@ show the real parts of matrix elements as squares whose size and color both corr
 .. plot::
    :context: reset
 
-    from qutip import visualization, identity, Qobj, to_super, sigmaz, tensor, hadamard_transform, cnot, tensor_contract
+    from qutip import hinton, identity, Qobj, to_super, sigmaz, tensor, tensor_contract
+    from qutip.core.gates import cnot, hadamard_transform
 
-    visualization.hinton(identity([2, 3]).unit())
-    visualization.hinton(Qobj([[1, 0.5], [0.5, 1]]).unit())
+    hinton(identity([2, 3]).unit())
+    hinton(Qobj([[1, 0.5], [0.5, 1]]).unit())
 
 
 We show superoperators as matrices in the *Pauli basis*, such that any Hermicity-preserving map is represented by a real-valued matrix. This is especially convienent for use with Hinton diagrams, as the plot thus carries complete information about the channel.
@@ -36,7 +37,7 @@ As an example, conjugation by :math:`\sigma_z` leaves :math:`\mathbb{1}` and :ma
 .. plot::
    :context:
 
-    visualization.hinton(to_super(sigmaz()))
+    hinton(to_super(sigmaz()))
 
 
 As a couple more examples, we also consider the supermatrix for a Hadamard transform and for :math:`\sigma_z \otimes H`.
@@ -44,8 +45,8 @@ As a couple more examples, we also consider the supermatrix for a Hadamard trans
 .. plot::
    :context:
 
-    visualization.hinton(to_super(hadamard_transform()))
-    visualization.hinton(to_super(tensor(sigmaz(), hadamard_transform())))
+    hinton(to_super(hadamard_transform()))
+    hinton(to_super(tensor(sigmaz(), hadamard_transform())))
 
 .. _super-reduced-channels:
 
@@ -86,14 +87,14 @@ For a :math:`\scriptstyle \rm CNOT` system-environment model, the composition of
 .. plot::
    :context:
 
-   visualization.hinton(to_super(cnot()))
+   hinton(to_super(cnot()))
 
 We now complete by multiplying the superunitary :math:`\scriptstyle \rm CNOT` by the preparation channel above, then applying the partial trace channel by contracting the second and fourth index indices. As expected, this gives us a dephasing map.
 
 .. plot::
    :context:
 
-   visualization.hinton(tensor_contract(to_super(cnot()), (1, 3)) * s_prep)
+   hinton(tensor_contract(to_super(cnot()), (1, 3)) * s_prep)
 
 
 .. plot::
@@ -101,4 +102,4 @@ We now complete by multiplying the superunitary :math:`\scriptstyle \rm CNOT` by
     :include-source: false
     :nofigs:
 
-    # reset the context at the end
\ No newline at end of file
+    # reset the context at the end

From 6483b894f8d9cd077087eed4e9749b1229025220 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Tue, 11 Apr 2023 17:00:24 +0200
Subject: [PATCH 298/602] Add missing empty line after plot directive options.

---
 doc/guide/guide-super.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/guide/guide-super.rst b/doc/guide/guide-super.rst
index 80f4e42fc5..76ec70cb19 100644
--- a/doc/guide/guide-super.rst
+++ b/doc/guide/guide-super.rst
@@ -71,6 +71,7 @@ The two tensor wires on the left indicate where we must take a tensor contractio
 .. plot::
    :context:
    :nofigs:
+
    tensor_contract(to_super(identity([2, 2])), (1, 3))
 
 Meanwhile, the :func:`super_tensor` function implements the swap on the right, such that we can quickly find the preparation map.

From d1160dcd83e4457a9f145fcf2cfd55521dc786c7 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 11 Apr 2023 11:24:40 -0400
Subject: [PATCH 299/602] rm direct keyword

---
 qutip/core/data/dispatch.pyx | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index b632fbb751..f12332bbb4 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -1,4 +1,5 @@
 #cython: language_level=3
+#cython: boundscheck=False
 
 import functools
 import inspect
@@ -48,7 +49,7 @@ cdef class _constructed_specialisation:
     """
     cdef readonly bint _output
     cdef object _call
-    cdef readonly Py_ssize_t _n_inputs
+    cdef readonly Py_ssize_t _n_inputs, _n_dispatch
     cdef readonly tuple types
     cdef readonly tuple _converters
     cdef readonly str _short_name
@@ -57,10 +58,8 @@ cdef class _constructed_specialisation:
     cdef public str __module__
     cdef public object __signature__
     cdef readonly str __text_signature__
-    cdef readonly bint direct
 
-    def __init__(self, base, Dispatcher dispatcher, types, converters, out,
-                 direct):
+    def __init__(self, base, Dispatcher dispatcher, types, converters, out):
         self.__doc__ = inspect.getdoc(dispatcher)
         self._short_name = dispatcher.__name__
         self.__name__ = (
@@ -74,10 +73,11 @@ cdef class _constructed_specialisation:
         self._output = out
         self._call = base
         self.types = types
-        self.direct = direct
         self._converters = converters
+        self._n_dispatch = len(converters)
         self._n_inputs = len(converters) - out
 
+    @cython.wraparound(False)
     def __call__(self, *args, **kwargs):
         cdef int i
         cdef list _args = list(args)
@@ -85,7 +85,7 @@ cdef class _constructed_specialisation:
             _args[i] = self._converters[i](args[i])
         out = self._call(*_args, **kwargs)
         if self._output:
-            out = self._converters[-1](out)
+            out = self._converters[self._n_dispatch - 1](out)
         return out
 
     def __repr__(self):
@@ -93,9 +93,8 @@ cdef class _constructed_specialisation:
             spec = self.types[0].__name__
         else:
             spec = "(" + ", ".join(x.__name__ for x in self.types) + ")"
-        direct = ("" if self.direct else "in") + "direct"
         return "".join([
-            "<", direct, " specialisation ", spec, " of ", self._short_name, ">"
+            "<indirect specialisation ", spec, " of ", self._short_name, ">"
         ])
 
 
@@ -320,8 +319,7 @@ cdef class Dispatcher:
                     converters = tuple(_to[pair] for pair in zip(types, in_types))
                 self._lookup[in_types] =\
                     _constructed_specialisation(function, self, in_types,
-                                                converters, self.output,
-                                                weight == 0)
+                                                converters, self.output)
         # Now build the lookup table in the case that we dispatch on the output
         # type as well, but the user has called us without specifying it.
         # TODO: option to control default output type choice if unspecified?
@@ -348,8 +346,7 @@ cdef class Dispatcher:
                     self._lookup[in_types] =\
                         _constructed_specialisation(function, self,
                                                     in_types + (types[-1],),
-                                                    converters, False,
-                                                    weight == 0)
+                                                    converters, False)
 
     def __getitem__(self, types):
         """
@@ -369,7 +366,7 @@ cdef class Dispatcher:
         return "<dispatcher: " + self.__text_signature__ + ">"
 
     def __call__(self, *args, dtype=None, **kwargs):
-        cdef list dispatch = [None] * self._n_dispatch
+        cdef list dispatch = []
         cdef int i
         if self._pass_on_dtype:
             kwargs['dtype'] = dtype

From 9c59faedd2be974ec86a7c58e1b22f2087e064a5 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 11 Apr 2023 12:49:26 -0400
Subject: [PATCH 300/602] Add progressbar test

---
 qutip/tests/test_progressbar.py | 27 +++++++++++++++++++++++++++
 qutip/ui/progressbar.py         |  5 +++--
 2 files changed, 30 insertions(+), 2 deletions(-)
 create mode 100644 qutip/tests/test_progressbar.py

diff --git a/qutip/tests/test_progressbar.py b/qutip/tests/test_progressbar.py
new file mode 100644
index 0000000000..dc0f7e29ac
--- /dev/null
+++ b/qutip/tests/test_progressbar.py
@@ -0,0 +1,27 @@
+from qutip.ui.progressbar import progress_bars
+import pytest
+import time
+
+
+# We offer multiple alias for each progressbar.
+names = []
+bars = []
+for alias, bar in progress_bars.items():
+    if bar not in bars:
+        names.append(alias)
+        bars.append(bar)
+
+
+@pytest.mark.parametrize("pbar", names)
+def test_progressbar(pbar):
+    N = 5
+    try:
+        bar = progress_bars[pbar](N)
+    except ImportError:
+        pytest.skip(reason="module not available")
+    assert bar.total_time() < 0
+    for _ in range(N):
+        time.sleep(0.25)
+        bar.update()
+    bar.finished()
+    assert bar.total_time() > 0
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index ac7766fad4..c528974e6d 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -151,10 +151,10 @@ class HTMLProgressBar(BaseProgressBar):
     """
 
     def __init__(self, iterations=0, chunk_size=1.0, **kwargs):
-        if not settings.ipython:
+        """if not settings.ipython:
             raise ValueError(
                 "HTMLProgressBar is only available when using ipython"
-            )
+            )"""
         from IPython.display import HTML, Javascript, display
         import uuid
 
@@ -203,6 +203,7 @@ def finished(self):
     "tqdm": TqdmProgressBar,
     "Html": HTMLProgressBar,
     "html": HTMLProgressBar,
+    "base": BaseProgressBar,
     "": BaseProgressBar,
     False: BaseProgressBar,
     None: BaseProgressBar,

From c2775a1924f2786d3945f23f7f651c3141db30c6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 11 Apr 2023 14:50:46 -0400
Subject: [PATCH 301/602] rm update args and start everywhere

---
 qutip/ipynbtools.py             |  7 +++----
 qutip/solve/parallel.py         | 14 ++++++--------
 qutip/solve/pdpsolve.py         |  9 +++------
 qutip/solve/stochastic.py       |  5 ++---
 qutip/tests/test_progressbar.py |  9 ++++++++-
 qutip/ui/progressbar.py         |  4 ----
 6 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 143a3b1c9d..13668606ec 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -272,16 +272,15 @@ def parallel_map(task, values, task_args=None, task_kwargs=None,
         view.wait(ar_list)
     else:
         if progress_bar is True:
-            progress_bar = HTMLProgressBar()
+            progress_bar = HTMLProgressBar(len(ar_list))
 
         n = len(ar_list)
-        progress_bar.start(n)
         while True:
             n_finished = sum([ar.progress for ar in ar_list])
-            progress_bar.update(n_finished)
+            progress_bar.update()
 
             if view.wait(ar_list, timeout=0.5):
-                progress_bar.update(n)
+                progress_bar.update()
                 break
         progress_bar.finished()
 
diff --git a/qutip/solve/parallel.py b/qutip/solve/parallel.py
index 36e35b8531..b3fc8473e5 100644
--- a/qutip/solve/parallel.py
+++ b/qutip/solve/parallel.py
@@ -147,14 +147,13 @@ def serial_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
     try:
         progress_bar = kwargs['progress_bar']
         if progress_bar is True:
-            progress_bar = TextProgressBar()
+            progress_bar = TextProgressBar(len(values))
     except:
-        progress_bar = BaseProgressBar()
+        progress_bar = BaseProgressBar(len(values))
 
-    progress_bar.start(len(values))
     results = []
     for n, value in enumerate(values):
-        progress_bar.update(n)
+        progress_bar.update()
         result = task(value, *task_args, **task_kwargs)
         results.append(result)
     progress_bar.finished()
@@ -199,16 +198,15 @@ def parallel_map(task, values, task_args=tuple(), task_kwargs={}, **kwargs):
     try:
         progress_bar = kwargs['progress_bar']
         if progress_bar is True:
-            progress_bar = TextProgressBar()
+            progress_bar = TextProgressBar(len(values))
     except:
-        progress_bar = BaseProgressBar()
+        progress_bar = BaseProgressBar(len(values))
 
-    progress_bar.start(len(values))
     nfinished = [0]
 
     def _update_progress_bar(x):
         nfinished[0] += 1
-        progress_bar.update(nfinished[0])
+        progress_bar.update()
 
     try:
         pool = Pool(processes=kw['num_cpus'])
diff --git a/qutip/solve/pdpsolve.py b/qutip/solve/pdpsolve.py
index 1a1d2964d2..af06fddcb2 100644
--- a/qutip/solve/pdpsolve.py
+++ b/qutip/solve/pdpsolve.py
@@ -162,9 +162,6 @@ def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
         if options is None:
             options = SolverOptions()
 
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
         self.H = H
         self.d1 = d1
         self.d2 = d2
@@ -200,6 +197,9 @@ def __init__(self, H=None, state0=None, times=None, c_ops=[], sc_ops=[],
         else:
             self.map_func = serial_map
 
+        if progress_bar is None:
+            self.progress_bar = TextProgressBar(self.ntraj)
+
         self.map_kwargs = map_kwargs if map_kwargs is not None else {}
 
         # Does any operator depend on time?
@@ -352,7 +352,6 @@ def _ssepdpsolve_generic(sso, options, progress_bar):
     for c in sso.c_ops:
         Heff += -0.5j * c.dag() * c
 
-    progress_bar.start(sso.ntraj)
     for n in range(sso.ntraj):
         progress_bar.update(n)
         psi_t = _data.dense.fast_from_numpy(sso.state0.full().ravel())
@@ -483,8 +482,6 @@ def _smepdpsolve_generic(sso, options, progress_bar):
     # needs to be modified for TD systems
     L = liouvillian(sso.H, sso.c_ops)
 
-    progress_bar.start(sso.ntraj)
-
     for n in range(sso.ntraj):
         progress_bar.update(n)
         rho_t = _data.dense.fast_from_numpy(sso.rho0.full())
diff --git a/qutip/solve/stochastic.py b/qutip/solve/stochastic.py
index 99829ae8ff..cc03f14de1 100644
--- a/qutip/solve/stochastic.py
+++ b/qutip/solve/stochastic.py
@@ -300,9 +300,6 @@ def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
         if options is None:
             options = SolverOptions()
 
-        if progress_bar is None:
-            progress_bar = TextProgressBar()
-
         # System
         # Cast to QobjEvo so the code has only one version for both the
         # constant and time-dependent case.
@@ -420,6 +417,8 @@ def __init__(self, me, H=None, c_ops=[], sc_ops=[], state0=None,
             self.noise_type = 0
 
         # Map
+        if progress_bar is None:
+            progress_bar = TextProgressBar(self.ntraj)
         self.progress_bar = progress_bar
         if self.ntraj > 1 and map_func:
             self.map_func = map_func
diff --git a/qutip/tests/test_progressbar.py b/qutip/tests/test_progressbar.py
index dc0f7e29ac..e85e558c7a 100644
--- a/qutip/tests/test_progressbar.py
+++ b/qutip/tests/test_progressbar.py
@@ -13,11 +13,13 @@
 
 
 @pytest.mark.parametrize("pbar", names)
-def test_progressbar(pbar):
+def test_progressbar(pbar, capsys):
     N = 5
+
     try:
         bar = progress_bars[pbar](N)
     except ImportError:
+        # ipython or tqdm could be missing
         pytest.skip(reason="module not available")
     assert bar.total_time() < 0
     for _ in range(N):
@@ -25,3 +27,8 @@ def test_progressbar(pbar):
         bar.update()
     bar.finished()
     assert bar.total_time() > 0
+    out, err = capsys.readouterr()
+    if pbar.lower() not in ["base"]:
+        # Has an non error output
+        # tqdm use error out
+        assert out != "" or err != ""
diff --git a/qutip/ui/progressbar.py b/qutip/ui/progressbar.py
index c528974e6d..1999d0bf8f 100644
--- a/qutip/ui/progressbar.py
+++ b/qutip/ui/progressbar.py
@@ -151,10 +151,6 @@ class HTMLProgressBar(BaseProgressBar):
     """
 
     def __init__(self, iterations=0, chunk_size=1.0, **kwargs):
-        """if not settings.ipython:
-            raise ValueError(
-                "HTMLProgressBar is only available when using ipython"
-            )"""
         from IPython.display import HTML, Javascript, display
         import uuid
 

From 4606f166f27dd51d82a4bd7752fbf785ba08f526 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 11 Apr 2023 16:36:58 -0400
Subject: [PATCH 302/602] Add towncrier

---
 doc/changes/2150.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2150.misc

diff --git a/doc/changes/2150.misc b/doc/changes/2150.misc
new file mode 100644
index 0000000000..41f6e5b702
--- /dev/null
+++ b/doc/changes/2150.misc
@@ -0,0 +1 @@
+Add a test for progress_bar

From 4f10ea2d6fbe1493ec01d31e06566f0d52dcdff7 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 12 Apr 2023 15:47:33 +0900
Subject: [PATCH 303/602] Updated some comments

---
 qutip/solver/nm_mcsolve.py | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 4ce56b9591..7ed9cad797 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -43,11 +43,11 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
 
     ops_and_rates : list
         A ``list`` of tuples ``(L, Gamma)``, where the Lindblad operator ``L``
-        is a :class:`qutip.Qobj` and the corresponding rate ``Gamma`` is
-        callable. That is, ``Gamma(t)`` returns the rate at time ``t``, which
-        is allowed to be negative. The Lindblad operators must be operators
-        even if ``H`` is a superoperator. If none are given, the solver will
-        defer to ``sesolve`` or ``mesolve``. The ``Gamma(t)`` may be
+        is a :class:`qutip.Qobj` and ``Gamma`` represents the corresponding
+        rate, which is allowed to be negative. The Lindblad operators must be
+        operators even if ``H`` is a superoperator. If none are given, the
+        solver will defer to ``sesolve`` or ``mesolve``. Each rate ``Gamma``
+        may be just a number (in the case of a constant rate) or, otherwise,
         specified using any format accepted by :func:`qutip.coefficient`.
 
     e_ops : list, [optional]
@@ -112,6 +112,9 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
           Parameters used in determining whether the given Lindblad operators
           satisfy a certain completeness relation. If they do not, an
           additional Lindblad operator is added automatically (with zero rate).
+        - martingale_quad_limit : float or int, [100]
+          An upper bound on the number of subintervals used in the adaptive
+          integration of the martingale.
 
     seeds : int, SeedSequence, list, [optional]
         Seed for the random number generator. It can be a single seed used to
@@ -230,10 +233,11 @@ class NonMarkovianMCSolver(MCSolver):
 
     ops_and_rates : list
         A ``list`` of tuples ``(L, Gamma)``, where the Lindblad operator ``L``
-        is a :class:`qutip.Qobj` and the corresponding rate ``Gamma`` is
-        callable. That is, ``Gamma(t)`` returns the rate at time ``t``, which
-        is allowed to be negative. The Lindblad operators must be operators
-        even if ``H`` is a superoperator.
+        is a :class:`qutip.Qobj` and ``Gamma`` represents the corresponding
+        rate, which is allowed to be negative. The Lindblad operators must be
+        operators even if ``H`` is a superoperator. Each rate ``Gamma`` may be
+        just a number (in the case of a constant rate) or, otherwise, specified
+        using any format accepted by :func:`qutip.coefficient`.
 
     args : None / dict
         Arguments for time-dependent Hamiltonian and collapse operator terms.
@@ -250,7 +254,6 @@ class NonMarkovianMCSolver(MCSolver):
     """
     name = "nm_mcsolve"
     resultclass = NmmcResult
-    mc_integrator_class = NmMCIntegrator
     solver_options = {
         **MCSolver.solver_options,
         "completeness_rtol": 1e-5,
@@ -258,8 +261,9 @@ class NonMarkovianMCSolver(MCSolver):
         "martingale_quad_limit": 100,
     }
 
-    # "solver" argument will be partially initialized in constructor
+    # "__nm_solver" argument will be partially initialized in constructor
     trajectory_resultclass = NmmcTrajectoryResult
+    mc_integrator_class = NmMCIntegrator
 
     def __init__(
         self, H, ops_and_rates, *_args, args=None, options=None, **kwargs,
@@ -417,7 +421,7 @@ def rate(self, t, i):
 
     def sqrt_shifted_rate(self, t, i):
         """
-        Return the square root of the i'th unshifted rate at time ``t``.
+        Return the square root of the i'th shifted rate at time ``t``.
 
         Parameters
         ----------

From 990a0e094b2fb668aaa591e0177db1b5125d04a3 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 12 Apr 2023 15:49:53 +0900
Subject: [PATCH 304/602] Added attribution comment

---
 qutip/solver/nm_mcsolve.py | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 7ed9cad797..75a3ad67da 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -17,6 +17,15 @@
 )
 
 
+# The algorithm implemented here is based on the influence martingale approach
+# described in
+#     Nat Commun 13, 4140 (2022)
+#     https://doi.org/10.1038/s41467-022-31533-8
+#     https://arxiv.org/abs/2102.10355
+# and
+#     https://arxiv.org/abs/2209.08958
+
+
 def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
                args=None, options=None, seeds=None, target_tol=None,
                timeout=None):
@@ -159,11 +168,11 @@ def nm_mcsolve(H, state, tlist, ops_and_rates=(), e_ops=None, ntraj=500, *,
         return mesolve(
             H, state, tlist, e_ops=e_ops, args=args, options=options,
         )
-    else:
-        ops_and_rates = [
-            _parse_op_and_rate(op, rate, tlist=tlist, args=args or {})
-            for op, rate in ops_and_rates
-        ]
+
+    ops_and_rates = [
+        _parse_op_and_rate(op, rate, tlist=tlist, args=args or {})
+        for op, rate in ops_and_rates
+    ]
 
     nmmc = NonMarkovianMCSolver(H, ops_and_rates, options=options)
     result = nmmc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,

From 8668c0a1d7a362e6da0aa31689e5a4bc6341bda7 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 12 Apr 2023 18:14:08 +0900
Subject: [PATCH 305/602] Bugfix: continuous martingale was not calculated
 correctly untl the first collapse

---
 qutip/solver/nm_mcsolve.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index 75a3ad67da..ca9be2e54e 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -368,10 +368,14 @@ def _current_martingale(self, t):
         continuous = np.prod(
             self._integrator.continuous_martingales, initial=1.0,
         )
+
         if self._integrator.collapses:
             tc, _ = self._integrator.collapses[-1]
-            if t > tc:
-                continuous *= self._continuous_martingale(tc, t)
+        else:
+            tc = self._integrator._t0
+        if t > tc:
+            continuous *= self._continuous_martingale(tc, t)
+
         return discrete * continuous
 
     def _argument(self, args):

From 041441cb31c4f5800f21d43aa92b2cc1f7445b9b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 10:42:03 -0400
Subject: [PATCH 306/602] Split tests

---
 qutip/ipynbtools.py             |  8 +++---
 qutip/tests/test_progressbar.py | 48 ++++++++++++++++++++-------------
 2 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/qutip/ipynbtools.py b/qutip/ipynbtools.py
index 13668606ec..48e2eeb14b 100644
--- a/qutip/ipynbtools.py
+++ b/qutip/ipynbtools.py
@@ -273,14 +273,14 @@ def parallel_map(task, values, task_args=None, task_kwargs=None,
     else:
         if progress_bar is True:
             progress_bar = HTMLProgressBar(len(ar_list))
-
-        n = len(ar_list)
+        prev_finished = 0
         while True:
             n_finished = sum([ar.progress for ar in ar_list])
-            progress_bar.update()
+            for _ in range(prev_finished, n_finished):
+                progress_bar.update()
+            prev_finished = n_finished
 
             if view.wait(ar_list, timeout=0.5):
-                progress_bar.update()
                 break
         progress_bar.finished()
 
diff --git a/qutip/tests/test_progressbar.py b/qutip/tests/test_progressbar.py
index e85e558c7a..d1fa275f17 100644
--- a/qutip/tests/test_progressbar.py
+++ b/qutip/tests/test_progressbar.py
@@ -3,32 +3,42 @@
 import time
 
 
-# We offer multiple alias for each progressbar.
-names = []
-bars = []
-for alias, bar in progress_bars.items():
-    if bar not in bars:
-        names.append(alias)
-        bars.append(bar)
+bars = ["base", "text", "Enhanced"]
 
+try:
+    import tqdm
+    bars.append("tqdm")
+except ImportError:
+    bars.append(
+        pytest.param("tqdm", marks=pytest.mark.skip("module not installed"))
+    )
+
+try:
+    import IPython
+    bars.append("html")
+except ImportError:
+    bars.append(
+        pytest.param("html", marks=pytest.mark.skip("module not installed"))
+    )
 
-@pytest.mark.parametrize("pbar", names)
-def test_progressbar(pbar, capsys):
-    N = 5
 
-    try:
-        bar = progress_bars[pbar](N)
-    except ImportError:
-        # ipython or tqdm could be missing
-        pytest.skip(reason="module not available")
+@pytest.mark.parametrize("pbar", bars)
+def test_progressbar(pbar):
+    N = 5
+    bar = progress_bars[pbar](N)
     assert bar.total_time() < 0
     for _ in range(N):
         time.sleep(0.25)
         bar.update()
     bar.finished()
     assert bar.total_time() > 0
+
+
+@pytest.mark.parametrize("pbar", bars[1:])
+def test_progressbar_has_print(pbar, capsys):
+    N = 2
+    bar = progress_bars[pbar](N)
+    bar.update()
+    bar.finished()
     out, err = capsys.readouterr()
-    if pbar.lower() not in ["base"]:
-        # Has an non error output
-        # tqdm use error out
-        assert out != "" or err != ""
+    assert out + err != ""

From 0d4824aad1596de0361ca51bc98834f8d761696d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 10:56:55 -0400
Subject: [PATCH 307/602] Add cython 3 case in github actions

---
 .github/workflows/tests.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index dd172510de..0571159086 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -73,6 +73,7 @@ jobs:
             os: ubuntu-latest
             python-version: "3.10"
             condaforge: 1
+            cython3: 1
 
           # Python 3.11 and latest numpy
           # Use conda-forge to provide Python 3.11 and latest numpy
@@ -115,6 +116,9 @@ jobs:
           if [[ -z "${{ matrix.nocython }}" ]]; then
             QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
           fi
+          if [[ -z "${{ matrix.cython3 }}" ]]; then
+            pip install cython --pre
+          fi
           export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
           if [[ -z "${{ matrix.nomkl }}" ]]; then
             conda install blas=*=mkl "numpy${{ matrix.numpy-requirement }}" "scipy${{ matrix.scipy-requirement }}"

From afb526172bf53e30294a97620dae1dee0792989f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 13:05:36 -0400
Subject: [PATCH 308/602] move to legacy

---
 .coveragerc                                        | 2 ++
 doc/apidoc/classes.rst                             | 9 ---------
 qutip/{solve/nonmarkov => legacy}/__init__.py      | 0
 qutip/legacy/nonmarkov/__init__.py                 | 0
 qutip/{solve => legacy}/nonmarkov/memorycascade.py | 0
 5 files changed, 2 insertions(+), 9 deletions(-)
 rename qutip/{solve/nonmarkov => legacy}/__init__.py (100%)
 create mode 100644 qutip/legacy/nonmarkov/__init__.py
 rename qutip/{solve => legacy}/nonmarkov/memorycascade.py (100%)

diff --git a/.coveragerc b/.coveragerc
index 96024441ef..ff81b4d9b5 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -3,6 +3,8 @@ source = qutip
 omit =
     # QuTiP test files
     */qutip/tests/*
+    # Feature we want to remove, hiding them while waiting to see if users will complain.
+    */qutip/legacy/*
 
 [report]
 exclude_lines =
diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index 478e38571d..acccf506f9 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -132,15 +132,6 @@ Integrator
     :members: options
 
 
-.. _classes-non_markov_mc_and_tt:
-
-Non-Markovian Memory Cascade and Transfer Tensor Solvers
---------------------------------------------------------
-
-.. autoclass:: qutip.solve.nonmarkov.memorycascade.MemoryCascade
-    :members:
-
-
 .. _classes-odeoptions:
 
 Solver Options and Results
diff --git a/qutip/solve/nonmarkov/__init__.py b/qutip/legacy/__init__.py
similarity index 100%
rename from qutip/solve/nonmarkov/__init__.py
rename to qutip/legacy/__init__.py
diff --git a/qutip/legacy/nonmarkov/__init__.py b/qutip/legacy/nonmarkov/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/qutip/solve/nonmarkov/memorycascade.py b/qutip/legacy/nonmarkov/memorycascade.py
similarity index 100%
rename from qutip/solve/nonmarkov/memorycascade.py
rename to qutip/legacy/nonmarkov/memorycascade.py

From 38f08d30352f37da24db9f36015c5d395e304594 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 13:07:43 -0400
Subject: [PATCH 309/602] black file

---
 qutip/legacy/nonmarkov/memorycascade.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/qutip/legacy/nonmarkov/memorycascade.py b/qutip/legacy/nonmarkov/memorycascade.py
index 1579d9c461..33e510e0d4 100644
--- a/qutip/legacy/nonmarkov/memorycascade.py
+++ b/qutip/legacy/nonmarkov/memorycascade.py
@@ -144,17 +144,23 @@ def propagator(self, t, tau, notrace=False):
         s = t - (k - 1) * tau
         G1 = self.generator(k)
         E0 = qeye(G1.dims[0])
-        E = _integrate(G1, E0, 0.0, s, integrator=self.integrator, opt=self.options)
+        E = _integrate(
+            G1, E0, 0.0, s, integrator=self.integrator, opt=self.options
+        )
         if k > 1:
             G2 = self.generator(k - 1)
             G2 = composite(G2, self.Id)
-            E = _integrate(G2, E, s, tau, integrator=self.integrator, opt=self.options)
+            E = _integrate(
+                G2, E, s, tau, integrator=self.integrator, opt=self.options
+            )
 
         if not notrace:
             E = _genptrace(E, k)
         return E
 
-    def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None, notrace=False):
+    def outfieldpropagator(
+        self, blist, tlist, tau, c1=None, c2=None, notrace=False
+    ):
         r"""
         Compute propagator for computing output field expectation values
         <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and
@@ -249,7 +255,9 @@ def outfieldpropagator(self, blist, tlist, tau, c1=None, c2=None, notrace=False)
             elif blist[i] == 4:
                 superop = spost(l1.dag())
             else:
-                raise ValueError("Allowed values in blist are 0, 1, 2, 3 and 4.")
+                raise ValueError(
+                    "Allowed values in blist are 0, 1, 2, 3 and 4."
+                )
 
             E = superop @ E
             sprev = s

From e7bcaa15a7d642ec5a5b980aafb2e398a60cca2c Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 13:27:29 -0400
Subject: [PATCH 310/602] Add test for bug in propagator

---
 qutip/__init__.py                     |  2 +-
 qutip/tests/solver/test_propagator.py | 10 +++++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/qutip/__init__.py b/qutip/__init__.py
index fc7f65b409..938ba18db2 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -33,7 +33,7 @@
 
 from .core import *
 from .solver import *
-from .solve import nonmarkov
+from .solver import nonmarkov
 import qutip.solve.piqs as piqs
 from .solve.stochastic import *
 
diff --git a/qutip/tests/solver/test_propagator.py b/qutip/tests/solver/test_propagator.py
index 2d36d9f977..5119fa0d6b 100644
--- a/qutip/tests/solver/test_propagator.py
+++ b/qutip/tests/solver/test_propagator.py
@@ -1,6 +1,7 @@
 import numpy as np
 from qutip import (destroy, propagator, Propagator, propagator_steadystate,
-                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
+                   steadystate, tensor, qeye, basis, QobjEvo, sesolve,
+                   liouvillian)
 import qutip
 import pytest
 from qutip.solver.brmesolve import BRSolver
@@ -87,6 +88,13 @@ def testPropHDims():
     assert U.dims == H.dims
 
 
+def testPropHSuper():
+    "Propagator: preserve super_oper dims"
+    L = liouvillian(qeye(2) & qeye(2), [destroy(2) & destroy(2)])
+    U = propagator(L, 1)
+    assert U.dims == L.dims
+
+
 def testPropEvo():
     a = destroy(5)
     H = a.dag()*a

From 3ffce4edff2c24aeeb90d9858b29bd484165c8c8 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 13:47:14 -0400
Subject: [PATCH 311/602] Rename to data_as

---
 qutip/core/qobj.py                 |  2 +-
 qutip/solver/heom/bofin_solvers.py |  4 ++--
 qutip/tests/core/test_qobj.py      | 24 +++++++++++-------------
 3 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index b8a05266ae..65ea30bf2f 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -824,7 +824,7 @@ def full(self, order='C', squeeze=False):
         out = np.asarray(self.data.to_array(), order=order)
         return out.squeeze() if squeeze else out
 
-    def extract(self, format=None, copy=True):
+    def data_as(self, format=None, copy=True):
         """Matrix from quantum object.
 
         Parameters
diff --git a/qutip/solver/heom/bofin_solvers.py b/qutip/solver/heom/bofin_solvers.py
index 26bc5183fc..d38553c902 100644
--- a/qutip/solver/heom/bofin_solvers.py
+++ b/qutip/solver/heom/bofin_solvers.py
@@ -528,7 +528,7 @@ def heomsolve(
           if the results option ``ado_return`` was set to ``True``).
           Each element is an instance of :class:`HierarchyADOsState`.
           The state of a particular ADO may be extracted from
-          ``result.ado_states[i]`` by calling :meth:`HEOMSolver.extract`.
+          ``result.ado_states[i]`` by calling :meth:`extract`.
 
         * ``expect``: a list containing the values of each ``e_ops`` at
           time ``t``.
@@ -1022,7 +1022,7 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
               if the results option ``ado_return`` was set to ``True``).
               Each element is an instance of :class:`HierarchyADOsState`.
               The state of a particular ADO may be extracted from
-              ``result.ado_states[i]`` by calling :meth:`HEOMSolver.extract`.
+              ``result.ado_states[i]`` by calling :meth:`extract`.
 
             * ``expect``: a list containing the values of each ``e_ops`` at
               time ``t``.
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 549817d302..2668056b0e 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1231,29 +1231,27 @@ def test_groundstate():
 @pytest.mark.filterwarnings(
     "ignore::scipy.sparse.SparseEfficiencyWarning"
 )
-def test_extract():
+def test_data_as():
     qobj = qutip.qeye(2, dtype="CSR")
 
-    assert scipy.sparse.isspmatrix_csr(qobj.extract("csr_matrix"))
-    assert scipy.sparse.isspmatrix_csr(qobj.extract(copy=False))
+    assert scipy.sparse.isspmatrix_csr(qobj.data_as("csr_matrix"))
+    assert scipy.sparse.isspmatrix_csr(qobj.data_as(copy=False))
     with pytest.raises(ValueError) as err:
-        qobj.extract("ndarray")
+        qobj.data_as("ndarray")
     assert "csr_matrix" in str(err.value)
 
-    qobj.extract(copy=False)[0, 0] = 0
-    qobj.extract(copy=True)[0, 1] = 2
+    qobj.data_as(copy=False)[0, 0] = 0
+    qobj.data_as(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="CSR")
 
-
-
     qobj = qutip.qeye(2, dtype="Dense")
 
-    assert isinstance(qobj.extract("ndarray"), np.ndarray)
-    assert isinstance(qobj.extract(copy=False), np.ndarray)
+    assert isinstance(qobj.data_as("ndarray"), np.ndarray)
+    assert isinstance(qobj.data_as(copy=False), np.ndarray)
 
-    qobj.extract(copy=False)[0, 0] = 0
-    qobj.extract(copy=True)[0, 1] = 2
+    qobj.data_as(copy=False)[0, 0] = 0
+    qobj.data_as(copy=True)[0, 1] = 2
     assert qobj == qutip.num(2, dtype="Dense")
     with pytest.raises(ValueError) as err:
-        qobj.extract("csr_matrix")
+        qobj.data_as("csr_matrix")
     assert "ndarray" in str(err.value)

From 45627e0e63bbc2f19c5295545958def87cbf024d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 13:51:26 -0400
Subject: [PATCH 312/602] Update .github/workflows/tests.yml

---
 .github/workflows/tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 0571159086..dcdd5d8e7b 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -117,7 +117,7 @@ jobs:
             QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
           fi
           if [[ -z "${{ matrix.cython3 }}" ]]; then
-            pip install cython --pre
+            pip install cython --pre --upgrade
           fi
           export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
           if [[ -z "${{ matrix.nomkl }}" ]]; then

From fcd936e4e8c3429cdc5d5afda51813e66af350b8 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 14:08:00 -0400
Subject: [PATCH 313/602] positional only dispatched matrix

---
 qutip/core/data/extract.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index f429da0041..b7c71bc2fa 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -62,7 +62,7 @@ def extract_csr(matrix, format=None, copy=True):
 
 extract = _Dispatcher(
     _inspect.Signature([
-        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
         _inspect.Parameter(
             'format', _inspect.Parameter.POSITIONAL_OR_KEYWORD, default=None
         ),

From 2daee0b4a407f4e4c916da84357cb5bd0f67416b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 12 Apr 2023 14:37:15 -0400
Subject: [PATCH 314/602] Fix bash if

---
 .github/workflows/tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index dcdd5d8e7b..2f232226a9 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -116,7 +116,7 @@ jobs:
           if [[ -z "${{ matrix.nocython }}" ]]; then
             QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
           fi
-          if [[ -z "${{ matrix.cython3 }}" ]]; then
+          if [[ "${{ matrix.cython3 }}" ]]; then
             pip install cython --pre --upgrade
           fi
           export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}

From 123ad4e2b39d6dd2971ad522b9d73a79fd1106b4 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Thu, 13 Apr 2023 16:24:55 +0900
Subject: [PATCH 315/602] Refactored NonMarkovianMCSolver: extracted
 martingale-related methods and data into separate InfluenceMartingale class.
 InfluenceMartingale pre-computes martingale values for performance.

---
 qutip/solver/multitraj.py  |   4 +-
 qutip/solver/nm_mcsolve.py | 230 +++++++++++++++++++++++--------------
 qutip/solver/result.py     |   4 +-
 3 files changed, 150 insertions(+), 88 deletions(-)

diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index a7292d710a..e9fdd1d672 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -109,8 +109,8 @@ def run(self, state, tlist, ntraj=1, *,
 
         For a ``state`` at time ``tlist[0]`` do the evolution as directed by
         ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :class:`Result`. The evolution method and stored
-        results are determined by ``options``.
+        expectation values in a :class:`Result`. The evolution method and
+        stored results are determined by ``options``.
 
         Parameters
         ----------
diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index ca9be2e54e..d98ac14f18 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -191,38 +191,88 @@ def _parse_op_and_rate(op, rate, **kw):
     return op, rate
 
 
+class InfluenceMartingale:
+    def __init__(self, nm_solver, a_parameter, quad_limit):
+        self._nm_solver = nm_solver
+        self._quad_limit = quad_limit
+        self._a_parameter = a_parameter
+        self.reset()
+
+    def reset(self):
+        self._t_prev = None
+        self._continuous_martingale_at_t_prev = None
+        self._precomputed_continuous_martingale = {}
+        self._discrete_martingale = None
+
+    def initialize(self, t0, tlist=None):
+        self._t_prev = t0
+        self._continuous_martingale_at_t_prev = 1
+        self._discrete_martingale = 1
+
+        # if a tlist was given, precompute continuous martingale values
+        self._precomputed_continuous_martingale = {}
+        if tlist is not None:
+            mu_c0 = 1
+            for t1 in tlist:
+                mu_c1 = mu_c0 * self._compute_continuous_martingale(t0, t1)
+                self._precomputed_continuous_martingale[t1] = mu_c1
+                t0, mu_c0 = t1, mu_c1
+
+    def add_collapse(self, collapse_time, collapse_channel):
+        if self._t_prev is None:
+            raise RuntimeError("The `start` method must called first.")
+
+        rate = self._nm_solver.rate(collapse_time, collapse_channel)
+        shift = self._nm_solver.rate_shift(collapse_time)
+        factor = rate / (rate + shift)
+        self._discrete_martingale *= factor
+
+    def value(self, t):
+        if self._t_prev is None:
+            raise RuntimeError("The `start` method must called first.")
+
+        # find value of continuous martingale at given time
+        if t in self._precomputed_continuous_martingale:
+            mu_c = self._precomputed_continuous_martingale[t]
+        else:
+            mu_c = (
+                self._continuous_martingale_at_t_prev *
+                self._compute_continuous_martingale(self._t_prev, t)
+            )
+        self._t_prev = t
+        self._continuous_martingale_at_t_prev = mu_c
+
+        return self._discrete_martingale * mu_c
+
+    def _compute_continuous_martingale(self, t1, t2):
+        if t1 == t2:
+            return 1
+
+        integral, _, *info = scipy.integrate.quad(
+            self._nm_solver.rate_shift, t1, t2,
+            limit=self._quad_limit,
+            full_output=True,
+        )
+        if len(info) > 1:
+            raise ValueError(
+                f"Failed to integrate the continuous martingale: {info[1]}"
+            )
+        return np.exp(self._a_parameter * integral)
+
+
 class NmMCIntegrator(MCIntegrator):
     def __init__(self, *args, **kwargs):
-        self._nm_solver = kwargs.pop("__nm_solver")
+        self._martingale = kwargs.pop("__martingale")
         super().__init__(*args, **kwargs)
-        self.continuous_martingales = []
-        self.discrete_martingales = []
-        self._t0 = None
-
-    def set_state(self, t, *args, **kwargs):
-        super().set_state(t, *args, **kwargs)
-        self.continuous_martingales = []
-        self.discrete_martingales = []
-        self._t0 = t
 
     def _do_collapse(self, *args, **kwargs):
+        # _do_collapse might not append a new collapse, so we need to check
+        # whether one was added before calculating the martingales.
+        num_collapse_old = len(self.collapses)
         super()._do_collapse(*args, **kwargs)
-        if len(self.collapses) > len(self.discrete_martingales):
-            # _do_collapse might not append a new collapse, so we
-            # need to check whether one was added before calculating
-            # the martingales.
-            t1, i = self.collapses[-1]
-            if len(self.collapses) > 1:
-                t0, _ = self.collapses[-2]
-            else:
-                assert self._t0 is not None
-                t0 = self._t0
-            self.continuous_martingales.append(
-                self._nm_solver._continuous_martingale(t0, t1)
-            )
-            self.discrete_martingales.append(
-                self._nm_solver._discrete_martingale(t1, i)
-            )
+        if len(self.collapses) > num_collapse_old:
+            collapse_time, collapse_channel = self.collapses[-1]
+            self._martingale.add_collapse(collapse_time, collapse_channel)
 
 
 class NonMarkovianMCSolver(MCSolver):
@@ -270,32 +320,27 @@ class NonMarkovianMCSolver(MCSolver):
         "martingale_quad_limit": 100,
     }
 
-    # "__nm_solver" argument will be partially initialized in constructor
+    # both classes will be partially initialized in constructor
     trajectory_resultclass = NmmcTrajectoryResult
     mc_integrator_class = NmMCIntegrator
 
     def __init__(
         self, H, ops_and_rates, *_args, args=None, options=None, **kwargs,
     ):
-        self.trajectory_resultclass = functools.partial(
-            NmmcTrajectoryResult, __nm_solver=self,
-        )
-        self.mc_integrator_class = functools.partial(
-           NmMCIntegrator, __nm_solver=self,
-        )
+        self.options = options
 
         ops_and_rates = [
             _parse_op_and_rate(op, rate, args=args or {})
             for op, rate in ops_and_rates
         ]
-
-        self.options = options
-
-        self._a_parameter, L = self._check_completeness(ops_and_rates)
+        a_parameter, L = self._check_completeness(ops_and_rates)
         if L is not None:
             ops_and_rates.append((L, ConstantCoefficient(0)))
 
         self.ops = [op for op, _ in ops_and_rates]
+        self._martingale = InfluenceMartingale(
+            self, a_parameter, self.options["martingale_quad_limit"]
+        )
 
         # Many coefficients. These should not be publicly exposed
         # and will all need to be updated in _arguments():
@@ -311,6 +356,12 @@ def __init__(
             for op, sqrt_shifted_rate
             in zip(self.ops, self._sqrt_shifted_rates)
         ]
+        self.trajectory_resultclass = functools.partial(
+            NmmcTrajectoryResult, __nm_solver=self,
+        )
+        self.mc_integrator_class = functools.partial(
+            NmMCIntegrator, __martingale=self._martingale,
+        )
         super().__init__(H, c_ops, *_args, options=options, **kwargs)
 
     def _check_completeness(self, ops_and_rates):
@@ -333,50 +384,15 @@ def _check_completeness(self, ops_and_rates):
         L = (a * qeye(op.dims[0]) - op).sqrtm()  # new Lindblad operator
         return a, L
 
-    def _discrete_martingale(self, t, i):
-        """
-        Discrete part of the martingale evolution for time ``t`` and
-        rate ``i``.
-        """
-        rate = self._rates[i](t)
-        shift = self._rate_shift(t)
-        return np.real(rate / (rate + shift))
-
-    def _continuous_martingale(self, t0, t1):
-        """
-        Continuous part of the martingale evolution for time ``t0`` to ``t1``.
-        """
-        integral, _abserr, *info = scipy.integrate.quad(
-            self._rate_shift.as_double, t0, t1,
-            limit=self.options["martingale_quad_limit"],
-            full_output=True,
-        )
-        if len(info) > 1:
-            raise ValueError(
-                f"Failed to integrate the continuous martingale: {info[1]}"
-            )
-        return np.exp(self._a_parameter * integral)
-
-    def _current_martingale(self, t):
+    def current_martingale(self):
         """
         Returns the value of the influence martingale along the current
         trajectory. The value of the martingale is the product of the
         continuous and the discrete contribution. The current time and the
         collapses that have happened are read out from the internal integrator.
         """
-        discrete = np.prod(self._integrator.discrete_martingales, initial=1.0)
-        continuous = np.prod(
-            self._integrator.continuous_martingales, initial=1.0,
-        )
-
-        if self._integrator.collapses:
-            tc, _ = self._integrator.collapses[-1]
-        else:
-            tc = self._integrator._t0
-        if t > tc:
-            continuous *= self._continuous_martingale(tc, t)
-
-        return discrete * continuous
+        t, *_ = self._integrator.get_state(copy=False)
+        return self._martingale.value(t)
 
     def _argument(self, args):
         self._rates = [rate.replace_arguments(args) for rate in self._rates]
@@ -386,16 +402,6 @@ def _argument(self, args):
         ]
         super()._argument(args)
 
-    # Override "step" to include the martingale mu in the state
-    # Note that the returned state will be a density matrix with trace=mu
-    def step(self, t, *, args=None, copy=True):
-        state = super().step(t, args=args, copy=copy)
-        if isket(state):
-            state = ket2dm(state)
-        return state * self._current_martingale(t)
-
-    step.__doc__ = MultiTrajSolver.step.__doc__
-
     def rate_shift(self, t):
         """
         Return the rate shift at time ``t``.
@@ -449,3 +455,57 @@ def sqrt_shifted_rate(self, t, i):
             The square root of the shifted value of rate ``i`` at time ``t``.
         """
         return np.real(self._sqrt_shifted_rates[i](t))
+
+    # MCSolver (and NonMarkovianMCSolver) offer two interfaces, i.e., two ways
+    # of interacting with them: either call `start` first and then manually
+    # integrate a single trajectory with subsequent calls to `step`, or call
+    # `run` to integrate a large number of trajectories, saving the results in
+    # an `NmmcResult`.
+    # We are responsible for (a) keeping our `_martingale` object in the
+    # correct state throughout and (b) multiplying all state density matrices
+    # with the martingale before passing them on to the user.
+    #
+    # Regarding (a), we firstly assume that start, step and run are only
+    # accessed by a single thread. start and step thus cannot be called while
+    # run is being executed. Secondly, we reset the martingale object at the
+    # beginning and end of run, requiring the user to call start again after
+    # calling run before calling step. Internal state of the martingale
+    # object accumulated by using one interface can thus not influence
+    # computations with the other interface.
+    # Note that the start/step-interface allows updating the `args` dictionary
+    # at each step. This action does not mess up the martingale state since we
+    # do not precompute any martingale values in this interface. In the
+    # run-interface we do precompute the values of the continuous part of the
+    # martingale, but the `args` dictionary cannot be changed in the middle of
+    # the run.
+    #
+    # Regarding (b), in the start/step-interface we just include the martingale
+    # in the step method. In order to include the martingale in the
+    # run-interface, we use a custom trajectory-resultclass that grabs the
+    # martingale value from the NonMarkovianMCSolver whenever a state is added.
+
+    def start(self, state, t0, seed=None):
+        self._martingale.initialize(t0)
+        return super().start(state, t0, seed=seed)
+
+    # The returned state will be a density matrix with trace=mu the martingale
+    def step(self, t, *, args=None, copy=True):
+        state = super().step(t, args=args, copy=copy)
+        if isket(state):
+            state = ket2dm(state)
+        return state * self.current_martingale()
+
+    def run(self, state, tlist, *args, **kwargs):
+        # update `args` dictionary before precomputing martingale
+        if 'args' in kwargs:
+            self._argument(kwargs.pop('args'))
+
+        self._martingale.initialize(tlist[0], tlist=tlist)
+        result = super().run(state, tlist, *args, **kwargs)
+        self._martingale.reset()
+
+        return result
+
+    start.__doc__ = MultiTrajSolver.start.__doc__
+    step.__doc__ = MultiTrajSolver.step.__doc__
+    run.__doc__ = MultiTrajSolver.run.__doc__
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 4278f24afc..c252613dce 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1001,9 +1001,10 @@ def __init__(self, e_ops, options, *args, **kwargs):
     def add(self, t, state):
         if isket(state):
             state = ket2dm(state)
-        mu = self._nm_solver._current_martingale(t)
+        mu = self._nm_solver.current_martingale()
         super().add(t, state * mu)
         self.trace.append(mu)
+
     add.__doc__ = Result.add.__doc__
 
 
@@ -1050,6 +1051,7 @@ class NmmcResult(McResult):
         For each recorded trajectory, the trace at each time.
         Only present if ``keep_runs_results`` is set in the options.
     """
+
     def _post_init(self):
         super()._post_init()
 

From f4237b81a309a9f3d24b94034d158eab14d2b9ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Thu, 13 Apr 2023 13:59:30 -0400
Subject: [PATCH 316/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/solver/sode/_sode.pyx           | 3 ++-
 qutip/solver/stochastic.py            | 2 +-
 qutip/tests/solver/test_stochastic.py | 5 -----
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 84ca745ad9..3ad1cec8ee 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -404,8 +404,9 @@ cdef class Milstein_imp:
         self.prev_dt = 0
         if imp_method == "inv":
             if not self.system.L.isconstant:
-                raise TypeError("")
+                raise TypeError("The 'inv' integration method requires that the system Hamiltonian or Liouvillian be constant.")
             self.use_inv = True
+            self.imp_opt = {}
         else:
             self.use_inv = False
             self.imp_opt = {"method": imp_method, "options": imp_options}
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 31281c5bf8..a7d1e1f6ee 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -322,7 +322,7 @@ def smesolve(
           Number of cpus to use when running in parallel. ``None`` detect the
           number of available cpus.
         - dt : float [0.001]
-          The finite steps lenght for the Stochastic integration method.
+          The finite steps length for the Stochastic integration method.
 
         Other options could be supported depending on the integration method,
         see `SIntegrator <./classes.html#classes-sode>`_.
diff --git a/qutip/tests/solver/test_stochastic.py b/qutip/tests/solver/test_stochastic.py
index 256bd1088a..f6843c997e 100644
--- a/qutip/tests/solver/test_stochastic.py
+++ b/qutip/tests/solver/test_stochastic.py
@@ -43,7 +43,6 @@ def _make_system(N, system):
 ])
 @pytest.mark.parametrize("heterodyne", [True, False])
 def test_smesolve(heterodyne, system):
-    "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.05
     N = 4
     ntraj = 20
@@ -77,7 +76,6 @@ def test_smesolve(heterodyne, system):
 @pytest.mark.parametrize("heterodyne", [True, False])
 @pytest.mark.parametrize("method", SMESolver.avail_integrators().keys())
 def test_smesolve_methods(method, heterodyne):
-    "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.05
     N = 4
     ntraj = 20
@@ -144,7 +142,6 @@ def test_smesolve_methods(method, heterodyne):
 ])
 @pytest.mark.parametrize("heterodyne", [True, False])
 def test_ssesolve(heterodyne, system):
-    "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.1
     N = 4
     ntraj = 20
@@ -243,7 +240,6 @@ def test_ssesolve_method(method, heterodyne):
 
 
 def test_reuse_seeds():
-    "Stochastic: smesolve: homodyne, time-dependent H"
     tol = 0.05
     N = 4
     ntraj = 5
@@ -286,7 +282,6 @@ def test_reuse_seeds():
 
 @pytest.mark.parametrize("heterodyne", [True, False])
 def test_m_ops(heterodyne):
-    "Stochastic: smesolve: homodyne, time-dependent H"
     N = 10
     ntraj = 1
 

From 13767c9197dd0fcc9ad6539dcdcb6cee7f75c38a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 13 Apr 2023 14:00:01 -0400
Subject: [PATCH 317/602] Apply PR comments

---
 qutip/solver/sode/_sode.pyx    |  2 --
 qutip/solver/sode/itotaylor.py |  1 -
 qutip/solver/sode/rouchon.py   |  2 +-
 qutip/solver/sode/ssystem.pyx  | 25 ++++++++++++++++++++-----
 qutip/solver/stochastic.py     |  8 +++++---
 5 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 84ca745ad9..18276fa7c3 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -21,7 +21,6 @@ cdef class Euler:
         double[:, :, ::1] dW, int num_step
     ):
         cdef int i
-        cdef Data out
         for i in range(num_step):
             state = self.step(t + i * dt, state, dt, dW[i, :, :])
         return state
@@ -417,7 +416,6 @@ cdef class Milstein_imp:
         if type(state) != _data.Dense:
             state = _data.to(_data.Dense, state)
         cdef Dense tmp = _data.mul_dense(state, 0)
-        state = state.copy()
 
         if dt != self.prev_dt:
             self.implicit = 1 - self.system.L * (dt / 2)
diff --git a/qutip/solver/sode/itotaylor.py b/qutip/solver/sode/itotaylor.py
index e379cd85f7..040f9e1ec8 100644
--- a/qutip/solver/sode/itotaylor.py
+++ b/qutip/solver/sode/itotaylor.py
@@ -1,4 +1,3 @@
-import numpy as np
 from . import _sode
 from .sode import _Explicit_Simple_Integrator, _Implicit_Simple_Integrator
 from ..stochastic import StochasticSolver, SMESolver
diff --git a/qutip/solver/sode/rouchon.py b/qutip/solver/sode/rouchon.py
index ecaf3fe041..30c48fd0cb 100644
--- a/qutip/solver/sode/rouchon.py
+++ b/qutip/solver/sode/rouchon.py
@@ -4,7 +4,7 @@
 from ..stochastic import StochasticSolver
 from .sode import SIntegrator
 from ..integrator.integrator import Integrator
-import qutip as qt
+
 
 __all__ = ["RouchonSODE"]
 
diff --git a/qutip/solver/sode/ssystem.pyx b/qutip/solver/sode/ssystem.pyx
index 6bf93bb7b7..d02b5724c3 100644
--- a/qutip/solver/sode/ssystem.pyx
+++ b/qutip/solver/sode/ssystem.pyx
@@ -249,21 +249,30 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
     cpdef Data a(self):
         if not self._is_set:
-            raise RuntimeError
+            raise RuntimeError(
+                "Derrivatives set for ito taylor expansion need "
+                "to receive the state with `set_state`."
+            )
         if not self._a_set:
             self._compute_a()
         return self._a
 
     cdef void _compute_a(StochasticOpenSystem self) except *:
         if not self._is_set:
-            raise RuntimeError
+            raise RuntimeError(
+                "Derrivatives set for ito taylor expansion need "
+                "to receive the state with `set_state`."
+            )
         imul_dense(self._a, 0)
         self.L.matmul_data(self.t, self.state, self._a)
         self._a_set = True
 
     cpdef Data bi(self, int i):
         if not self._is_set:
-            raise RuntimeError
+            raise RuntimeError(
+                "Derrivatives set for ito taylor expansion need "
+                "to receive the state with `set_state`."
+            )
         if not self._b_set:
             self._compute_b()
         return _dense_wrap(self._b[i, :])
@@ -272,7 +281,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
     @cython.wraparound(False)
     cdef void _compute_b(self) except *:
         if not self._is_set:
-            raise RuntimeError
+            raise RuntimeError(
+                "Derrivatives set for ito taylor expansion need "
+                "to receive the state with `set_state`."
+            )
         cdef int i
         cdef QobjEvo c_op
         cdef Dense b_vec, state=self.state
@@ -287,7 +299,10 @@ cdef class StochasticOpenSystem(_StochasticSystem):
 
     cpdef Data Libj(self, int i, int j):
         if not self._is_set:
-            raise RuntimeError
+            raise RuntimeError(
+                "Derrivatives set for ito taylor expansion need "
+                "to receive the state with `set_state`."
+            )
         if not self._Lb_set:
             self._compute_Lb()
         # We only support commutative diffusion
diff --git a/qutip/solver/stochastic.py b/qutip/solver/stochastic.py
index 31281c5bf8..ecd9be4b50 100644
--- a/qutip/solver/stochastic.py
+++ b/qutip/solver/stochastic.py
@@ -214,7 +214,7 @@ def __init__(self, issuper, H, sc_ops, c_ops, heterodyne):
     def __call__(self, options):
         if self.issuper:
             return StochasticOpenSystem(
-                self.H, self.sc_ops, self.c_ops, options.get("dt", 1.0 - 6)
+                self.H, self.sc_ops, self.c_ops, options.get("derr_dt", 1e-6)
             )
         else:
             return StochasticClosedSystem(self.H, self.sc_ops)
@@ -321,8 +321,9 @@ def smesolve(
         - num_cpus : NoneType, int, [None]
           Number of cpus to use when running in parallel. ``None`` detect the
           number of available cpus.
-        - dt : float [0.001]
+        - dt : float [0.001~0.0001]
           The finite steps lenght for the Stochastic integration method.
+          Default change depending on the integrator.
 
         Other options could be supported depending on the integration method,
         see `SIntegrator <./classes.html#classes-sode>`_.
@@ -441,8 +442,9 @@ def ssesolve(
         - num_cpus : NoneType, int, [None]
           Number of cpus to use when running in parallel. ``None`` detect the
           number of available cpus.
-        - dt : float [0.001]
+        - dt : float [0.001 ~ 0.0001]
           The finite steps lenght for the Stochastic integration method.
+          Default change depending on the integrator.
 
         Other options could be supported depending on the integration method,
         see `SIntegrator <./classes.html#classes-sode>`_.

From d0b6c14b4c13f8bc60dd0380736f9214ae124425 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 13 Apr 2023 15:59:38 -0400
Subject: [PATCH 318/602] Add photocurrent example in mcsolve documentation
 page

---
 doc/guide/dynamics/dynamics-monte.rst | 35 ++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index a4c1f20b3c..580ba73755 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -102,7 +102,12 @@ When trajectories are stored, ``result.runs_expect`` is a list over the expectat
 The averages are stored in ``result.average_expect`` and the standard derivation of the expectation values in ``result.std_expect``.
 When the states are returned, ``result.runs_states`` will be an array of length ``ntraj``. Each element contains an array of "Qobj" type ket with the same number of elements as ``times``. ``result.average_states`` is a list of density matrices computed as the average of the states at each time step.
 Furthermore, the output will also contain a list of times at which the collapse occurred, and which collapse operators did the collapse. These can be obtained in  ``result.col_times`` and ``result.col_which`` respectively.
-Lastly ``result.photocurrent`` contain the measurement of the evolution.
+
+
+Photocurrent
+------------
+
+The photocurrent, previously computed using the ``photocurrent_sesolve`` and ``photocurrent_sesolve`` functions, are now included in the output of :func:`qutip.solver.mcsolve` as ``result.photocurrent``.
 
 
 .. plot::
@@ -236,6 +241,34 @@ For example, the following code block plots expectation values for 1, 10 and 100
     plt.legend()
     plt.show()
 
+
+.. openmcsolve:
+
+Open Systems
+------------
+
+``mcsolve`` can be used to study system with have measured and dissipative interaction with the bath.
+This is done by using a liouvillian including the dissipative interaction instead of an Hamiltonian.
+
+.. plot::
+    :context: close-figs
+
+    times = np.linspace(0.0, 10.0, 200)
+    psi0 = tensor(fock(2, 0), fock(10, 8))
+    a  = tensor(qeye(2), destroy(10))
+    sm = tensor(destroy(2), qeye(10))
+    H = 2*np.pi*a.dag()*a + 2*np.pi*sm.dag()*sm + 2*np.pi*0.25*(sm*a.dag() + sm.dag()*a)
+    L = liouvillian(H, [0.01 * sm, np.sqrt(0.1) * a])
+    data = mcsolve(L, psi0, times, [np.sqrt(0.1) * a], e_ops=[a.dag() * a, sm.dag() * sm])
+
+    plt.figure()
+    plt.plot((times[:-1] + times[1:])/2, data.photocurrent[0])
+    plt.title('Monte Carlo Photocurrent')
+    plt.xlabel('Time')
+    plt.ylabel('Photon detections')
+    plt.show()
+
+
 .. plot::
     :context: reset
     :include-source: false

From 7e842cd7aa258e901b3f3ca137ee6f600637f93f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 13 Apr 2023 18:03:15 -0400
Subject: [PATCH 319/602] Add dispatch on data

---
 qutip/core/data/base.pxd     |  3 +++
 qutip/core/data/base.pyx     |  4 ++++
 qutip/core/data/convert.pyx  | 18 ++++++++++++++++++
 qutip/core/data/dispatch.pyx | 32 ++++++++++++++++++++++++++++----
 4 files changed, 53 insertions(+), 4 deletions(-)

diff --git a/qutip/core/data/base.pxd b/qutip/core/data/base.pxd
index f34a80ff24..1f03cff362 100644
--- a/qutip/core/data/base.pxd
+++ b/qutip/core/data/base.pxd
@@ -15,3 +15,6 @@ cdef class Data:
     cpdef Data conj(self)
     cpdef Data transpose(self)
     cpdef Data copy(self)
+
+cdef class SameData(Data):
+    pass
diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
index a463bf3834..79c6242bbf 100644
--- a/qutip/core/data/base.pyx
+++ b/qutip/core/data/base.pyx
@@ -85,5 +85,9 @@ cdef class Data:
         return False
 
 
+cdef class SameData(Data):
+    pass
+
+
 class EfficiencyWarning(Warning):
     pass
diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index c2feed3dd1..3aef42ac51 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -19,6 +19,7 @@ import numbers
 import numpy as np
 from scipy.sparse import dok_matrix, csgraph
 cimport cython
+from qutip.core.data.base cimport Data, SameData
 
 __all__ = ['to', 'create']
 
@@ -69,6 +70,10 @@ cdef class _converter:
                 + ">")
 
 
+def dummyconverter(arg):
+    return arg
+
+
 cdef class _partial_converter:
     """Convert from any known data-layer type into the type `x.to`."""
 
@@ -147,6 +152,7 @@ cdef class _to:
     cdef dict _convert
     cdef readonly dict weight
     cdef readonly dict _str2type
+    cdef readonly float anydataweight
 
     def __init__(self):
         self._direct_convert = {}
@@ -155,6 +161,7 @@ cdef class _to:
         self.weight = {}
         self.dispatchers = []
         self._str2type = {}
+        self.anydataweight = 0.001
 
     def add_conversions(self, converters):
         """
@@ -200,6 +207,8 @@ cdef class _to:
                 safe just to leave this blank; it is always at best an
                 approximation.  The currently defined weights are accessible in
                 the `weights` attribute of this object.
+                Weight of ~0.001 are should be used in case when no conversion
+                is needed or ``converter = lambda mat : mat``.
         """
         for arg in converters:
             if len(arg) == 3:
@@ -258,6 +267,15 @@ cdef class _to:
                 self.weight[(to_t, from_t)] = weight
                 self._convert[(to_t, from_t)] =\
                     _converter(convert[::-1], to_t, from_t)
+        for dtype in self.dtypes:
+            self.weight[(dtype, Data)] = self.anydataweight
+            self.weight[(Data, dtype)] = self.anydataweight
+            self.weight[(dtype, SameData)] = self.anydataweight
+            self.weight[(SameData, dtype)] = self.anydataweight
+            self._convert[(dtype, Data)] = dummyconverter
+            self._convert[(Data, dtype)] = dummyconverter
+            self._convert[(dtype, SameData)] = dummyconverter
+            self._convert[(SameData, dtype)] = dummyconverter
         for dispatcher in self.dispatchers:
             dispatcher.rebuild_lookup()
 
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index f12332bbb4..7ec5a0503b 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -11,6 +11,7 @@ from .convert import to as _to
 cimport cython
 from libc cimport math
 from libcpp cimport bool
+from qutip.core.data.base cimport Data, SameData
 
 __all__ = ['Dispatcher']
 
@@ -21,8 +22,12 @@ cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out
     element-wise to the types in `tos`.  `weight_map` is a mapping of
     `(to_type, from_type): real`; it should almost certainly be
     `data.to.weight`.
+
+    Specialisations that support any types input should use ``Data`` if types
+    can be mixed, or ``SameData``, when they cannot be mixed.
     """
-    cdef double weight = 0.0
+    cdef double weight = 0.0, anydataweight = 0.01
+    cdef type sametype = None
     cdef Py_ssize_t i, n=len(froms)
     if len(tos) != n:
         raise ValueError(
@@ -31,7 +36,15 @@ cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out
     if out:
         n = n - 1
         weight += weight_map[froms[n], tos[n]]
+        if tos[n] is SameData:
+            sametype = froms[n]
+
     for i in range(n):
+        if tos[i] is SameData and sametype in [None, froms[i]]:
+            sametype = froms[i]
+        elif tos[i] is SameData:
+            # DataType not matching, can't use the function.
+            weight += math.INFINITY
         weight += weight_map[tos[i], froms[i]]
     return weight
 
@@ -269,7 +282,12 @@ cdef class Dispatcher:
                     + " and a callable"
                 )
             for i in range(self._n_dispatch):
-                if (not _defer) and arg[i] not in _to.dtypes:
+                if (
+                    not _defer
+                    and arg[i] not in _to.dtypes
+                    and arg[i] is not Data
+                    and not isinstance(arg[i], Data)
+                ):
                     raise ValueError(str(arg[i]) + " is not a known data type")
             if not callable(arg[self._n_dispatch]):
                 raise TypeError(str(arg[-1]) + " is not callable")
@@ -307,7 +325,10 @@ cdef class Dispatcher:
                     types = out_types
                     function = out_function
 
-            if weight == 0:
+            if cur == math.INFINITY:
+                raise ValueError("No valid specialisations found")
+
+            if weight <= 0.01:
                 self._lookup[in_types] = function
             else:
                 if self.output:
@@ -336,7 +357,10 @@ cdef class Dispatcher:
                         types = out_types
                         function = out_function
 
-                if weight == 0:
+                if cur == math.INFINITY:
+                    raise ValueError("No valid specialisations found")
+
+                if weight <= 0.01:
                     self._lookup[in_types] = function
                 else:
                     converters = tuple(

From a5ab0771ad2a490c3072935a8742eab51707e69e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 13 Apr 2023 18:03:52 -0400
Subject: [PATCH 320/602] Add zeros_like and identity_like

---
 qutip/core/data/constant.py | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index a60341a364..5a1db4e73f 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -6,10 +6,11 @@
 from . import csr, dense
 from .csr import CSR
 from .dense import Dense
+from .base import Data
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
-__all__ = ['zeros', 'identity']
+__all__ = ['zeros', 'identity', 'zeros_like', 'identity_like']
 
 zeros = _Dispatcher(
     _inspect.Signature([
@@ -70,4 +71,29 @@
     (Dense, dense.identity),
 ], _defer=True)
 
+
+def zeros_like_data(data, /):
+    """
+    Create an zeros matrix of the same type and shape.
+    """
+    return zeros[type(data)](*data.shape)
+
+
+zeros_like = _Dispatcher(zeros_like_data, inputs=('data',), out=False)
+zeros_like.add_specialisations([(Data, zeros_like_data)])
+
+
+def identity_like_data(data, /):
+    """
+    Create an zeros matrix of the same type and shape.
+    """
+    if not data.shape[0] == data.shape[1]:
+        raise ValueError("Can't create and identity like a non square matrix.")
+    return identity[type(data)](*data.shape[0])
+
+
+identity_like = _Dispatcher(identity_like_data, inputs=('data',), out=False)
+identity_like.add_specialisations([(Data, identity_like_data)])
+
+
 del _Dispatcher, _inspect

From 84fbc48cb04763e1e975e97112a1b285c0e01f46 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 13 Apr 2023 18:15:31 -0400
Subject: [PATCH 321/602] Add tests for new functions

---
 qutip/core/data/constant.py               | 10 +++++++---
 qutip/tests/core/data/test_mathematics.py | 23 +++++++++++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 5a1db4e73f..1d6d63c2cd 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -79,7 +79,9 @@ def zeros_like_data(data, /):
     return zeros[type(data)](*data.shape)
 
 
-zeros_like = _Dispatcher(zeros_like_data, inputs=('data',), out=False)
+zeros_like = _Dispatcher(
+    zeros_like_data, name="zeros_like", inputs=('data',), out=False
+)
 zeros_like.add_specialisations([(Data, zeros_like_data)])
 
 
@@ -89,10 +91,12 @@ def identity_like_data(data, /):
     """
     if not data.shape[0] == data.shape[1]:
         raise ValueError("Can't create and identity like a non square matrix.")
-    return identity[type(data)](*data.shape[0])
+    return identity[type(data)](data.shape[0])
 
 
-identity_like = _Dispatcher(identity_like_data, inputs=('data',), out=False)
+identity_like = _Dispatcher(
+    identity_like_data, name="identity_like", inputs=('data',), out=False
+)
 identity_like.add_specialisations([(Data, identity_like_data)])
 
 
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 459ab0d467..a220202c43 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -950,3 +950,26 @@ def op_numpy(self, matrix):
         pytest.param(_inv_csr, CSR, CSR),
         pytest.param(_inv_dense, Dense, Dense),
     ]
+
+
+class TestZeros_like(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.zeros_like(matrix)
+
+    specialisations = [
+        pytest.param(data.zeros_like, CSR, CSR),
+        pytest.param(data.zeros_like, Dense, Dense),
+    ]
+
+
+class TestIdentity_like(UnaryOpMixin):
+    def op_numpy(self, matrix):
+        return np.eye(matrix.shape[0])
+
+    shapes = shapes_square()
+    bad_shapes = shapes_not_square()
+
+    specialisations = [
+        pytest.param(data.identity_like, CSR, CSR),
+        pytest.param(data.identity_like, Dense, Dense),
+    ]

From bdd3da39131b76a96e7491fd15f6a2be8241802a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 08:11:39 -0400
Subject: [PATCH 322/602] Add _like operators

---
 qutip/core/data/constant.py        | 24 +++-------
 qutip/core/operators.py            | 76 ++++++++++++++++++++++++++++--
 qutip/tests/core/test_operators.py | 32 +++++++++++++
 3 files changed, 110 insertions(+), 22 deletions(-)

diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 1d6d63c2cd..179f90028b 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -72,32 +72,20 @@
 ], _defer=True)
 
 
-def zeros_like_data(data, /):
+del _Dispatcher, _inspect
+
+
+def zeros_like(data, /):
     """
     Create an zeros matrix of the same type and shape.
     """
     return zeros[type(data)](*data.shape)
 
 
-zeros_like = _Dispatcher(
-    zeros_like_data, name="zeros_like", inputs=('data',), out=False
-)
-zeros_like.add_specialisations([(Data, zeros_like_data)])
-
-
-def identity_like_data(data, /):
+def identity_like(data, /):
     """
-    Create an zeros matrix of the same type and shape.
+    Create an identity matrix of the same type and shape.
     """
     if not data.shape[0] == data.shape[1]:
         raise ValueError("Can't create and identity like a non square matrix.")
     return identity[type(data)](data.shape[0])
-
-
-identity_like = _Dispatcher(
-    identity_like_data, name="identity_like", inputs=('data',), out=False
-)
-identity_like.add_specialisations([(Data, identity_like_data)])
-
-
-del _Dispatcher, _inspect
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index b14f52651d..b2311c3e4c 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -5,10 +5,11 @@
 
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'qeye', 'identity', 'position', 'momentum',
-           'num', 'squeeze', 'squeezing', 'swap', 'displace', 'commutator',
-           'qutrit_ops', 'qdiags', 'phase', 'qzero', 'enr_destroy',
-           'enr_identity', 'charge', 'tunneling', 'qft']
+           'destroy', 'create', 'qeye', 'qeye_like', 'identity', 'position',
+           'momentum', 'num', 'squeeze', 'squeezing', 'swap', 'displace',
+           'commutator', 'qutrit_ops', 'qdiags', 'phase', 'qzero',
+           'qzero_like', 'enr_destroy', 'enr_identity', 'charge', 'tunneling',
+           'qft']
 
 import numbers
 
@@ -529,6 +530,27 @@ def qzero(dimensions, *, dtype=None):
                 isherm=True, isunitary=False, copy=False)
 
 
+def qzero_like(qobj):
+    """
+    Zero operator of the same dims and type as the original.
+
+    Parameters
+    ----------
+    qobj : Qobj
+        Qobj to copy the dims from.
+
+    Returns
+    -------
+    qzero : qobj
+        Zero operator Qobj.
+
+    """
+    return Qobj(
+        _data.zeros_like(qobj.data), dims=qobj.dims, type=qobj.type,
+        superrep=qobj.superrep, isherm=True, isunitary=False, copy=False
+    )
+
+
 def qeye(dimensions, *, dtype=None):
     """
     Identity operator.
@@ -580,6 +602,52 @@ def qeye(dimensions, *, dtype=None):
 identity = qeye
 
 
+def qeye_like(qobj):
+    """
+    Identity operator.
+
+    Parameters
+    ----------
+    dimensions : (int) or (list of int) or (list of list of int)
+        Dimension of Hilbert space. If provided as a list of ints, then the
+        dimension is the product over this list, but the ``dims`` property of
+        the new Qobj are set to this list.  This can produce either `oper` or
+        `super` depending on the passed `dimensions`.
+
+    dtype : type or str
+        Storage representation. Any data-layer known to `qutip.data.to` is
+        accepted.
+
+    Returns
+    -------
+    oper : qobj
+        Identity operator Qobj.
+
+    Examples
+    --------
+    >>> qeye(3) # doctest: +SKIP
+    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
+    isherm = True
+    Qobj data =
+    [[ 1.  0.  0.]
+     [ 0.  1.  0.]
+     [ 0.  0.  1.]]
+    >>> qeye([2,2]) # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
+    isherm = True
+    Qobj data =
+    [[1. 0. 0. 0.]
+     [0. 1. 0. 0.]
+     [0. 0. 1. 0.]
+     [0. 0. 0. 1.]]
+
+    """
+    return Qobj(
+        _data.identity_like(qobj.data), dims=qobj.dims, type=qobj.type,
+        superrep=qobj.superrep, isherm=True, isunitary=True, copy=False
+    )
+
+
 def position(N, offset=0, *, dtype=None):
     """
     Position operator x=1/sqrt(2)*(a+a.dag())
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index 848cd9eddd..0e452edcbf 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -302,3 +302,35 @@ def test_swap(N, M):
     ket2 = qutip.rand_ket(M)
 
     assert qutip.swap(N, M) @ (ket1 & ket2) == (ket2 & ket1)
+
+
+@pytest.mark.parametrize(["dims", "superrep"], [
+    pytest.param([2], None, id="simple"),
+    pytest.param([2, 3], None, id="tensor"),
+    pytest.param([[2], [2]], None, id="super"),
+    pytest.param([[2], [2]], "chi", id="chi"),
+])
+@pytest.mark.parametrize('dtype', ["CSR", "Dense"])
+def test_qeye_like(dims, superrep, dtype):
+    op = qutip.rand_herm(dims, dtype=dtype)
+    op.superrep = superrep
+    new = qutip.qeye_like(op)
+    expected = qutip.qeye(dims, dtype=dtype)
+    expected.superrep = superrep
+    assert new == expected
+
+
+@pytest.mark.parametrize(["dims", "superrep"], [
+    pytest.param([2], None, id="simple"),
+    pytest.param([2, 3], None, id="tensor"),
+    pytest.param([[2], [2]], None, id="super"),
+    pytest.param([[2], [2]], "chi", id="chi"),
+])
+@pytest.mark.parametrize('dtype', ["CSR", "Dense"])
+def test_qzero_like(dims, superrep, dtype):
+    op = qutip.rand_herm(dims, dtype=dtype)
+    op.superrep = superrep
+    new = qutip.qzero_like(op)
+    expected = qutip.qzero(dims, dtype=dtype)
+    expected.superrep = superrep
+    assert new == expected

From 83108de32ae70efb1a15a32489ae8118a20b372e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 08:29:21 -0400
Subject: [PATCH 323/602] Add towncrier entry

---
 doc/changes/2153.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2153.feature

diff --git a/doc/changes/2153.feature b/doc/changes/2153.feature
new file mode 100644
index 0000000000..84f539b86f
--- /dev/null
+++ b/doc/changes/2153.feature
@@ -0,0 +1 @@
+Add qeye_like and qzero_like

From 47fb07cfb89069cc1239c81d7629fe3be348c7d3 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 10:19:16 -0400
Subject: [PATCH 324/602] Update docstring

---
 qutip/core/operators.py | 36 ++++++------------------------------
 1 file changed, 6 insertions(+), 30 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index b2311c3e4c..5f4202cc4c 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -532,12 +532,12 @@ def qzero(dimensions, *, dtype=None):
 
 def qzero_like(qobj):
     """
-    Zero operator of the same dims and type as the original.
+    Zero operator of the same dims and type as the reference.
 
     Parameters
     ----------
     qobj : Qobj
-        Qobj to copy the dims from.
+        Reference ``Qobj`` to copy the dims from.
 
     Returns
     -------
@@ -604,43 +604,19 @@ def qeye(dimensions, *, dtype=None):
 
 def qeye_like(qobj):
     """
-    Identity operator.
+    Identity operator with the same dims and type as the reference quantum
+    object.
 
     Parameters
     ----------
-    dimensions : (int) or (list of int) or (list of list of int)
-        Dimension of Hilbert space. If provided as a list of ints, then the
-        dimension is the product over this list, but the ``dims`` property of
-        the new Qobj are set to this list.  This can produce either `oper` or
-        `super` depending on the passed `dimensions`.
-
-    dtype : type or str
-        Storage representation. Any data-layer known to `qutip.data.to` is
-        accepted.
+    qobj : Qobj
+        Reference ``Qobj`` to copy the dims from.
 
     Returns
     -------
     oper : qobj
         Identity operator Qobj.
 
-    Examples
-    --------
-    >>> qeye(3) # doctest: +SKIP
-    Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, \
-    isherm = True
-    Qobj data =
-    [[ 1.  0.  0.]
-     [ 0.  1.  0.]
-     [ 0.  0.  1.]]
-    >>> qeye([2,2]) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, \
-    isherm = True
-    Qobj data =
-    [[1. 0. 0. 0.]
-     [0. 1. 0. 0.]
-     [0. 0. 1. 0.]
-     [0. 0. 0. 1.]]
-
     """
     return Qobj(
         _data.identity_like(qobj.data), dims=qobj.dims, type=qobj.type,

From 8d6883da7c373dc65fc3adb88b74c2b27e350db6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 12:49:34 -0400
Subject: [PATCH 325/602] Use qeye_like

---
 qutip/core/cy/qobjevo.pyx             |  6 +++---
 qutip/core/gates.py                   |  4 ++--
 qutip/core/metrics.py                 |  4 ++--
 qutip/core/operators.py               | 14 ++++++++++----
 qutip/core/qobj.py                    |  2 +-
 qutip/core/superoperator.py           |  4 ++--
 qutip/solver/correlation.py           | 13 +++++++------
 qutip/solver/countstat.py             |  2 +-
 qutip/solver/propagator.py            | 19 +++++++++++--------
 qutip/solver/result.py                |  6 +++---
 qutip/solver/steadystate.py           | 10 +++++-----
 qutip/tests/core/test_gates.py        |  2 +-
 qutip/tests/solver/test_propagator.py | 10 +++++++++-
 13 files changed, 57 insertions(+), 39 deletions(-)

diff --git a/qutip/core/cy/qobjevo.pyx b/qutip/core/cy/qobjevo.pyx
index 513d3ae519..388551dd39 100644
--- a/qutip/core/cy/qobjevo.pyx
+++ b/qutip/core/cy/qobjevo.pyx
@@ -248,7 +248,7 @@ cdef class QobjEvo:
         repr_str += f'isconstant = {self.isconstant}, num_elements = {self.num_elements}'
         return repr_str
 
-    def _read_element(self, op, copy, tlist, args, order, function_style, 
+    def _read_element(self, op, copy, tlist, args, order, function_style,
                       boundary_conditions):
         """ Read a Q_object item and return an element for that item. """
         if isinstance(op, Qobj):
@@ -257,7 +257,7 @@ cdef class QobjEvo:
         elif isinstance(op, list):
             out = _EvoElement(
                 op[0].copy() if copy else op[0],
-                coefficient(op[1], tlist=tlist, args=args, order=order, 
+                coefficient(op[1], tlist=tlist, args=args, order=order,
                             boundary_conditions=boundary_conditions)
             )
             qobj = op[0]
@@ -475,7 +475,7 @@ cdef class QobjEvo:
             isinstance(other, numbers.Number) and
             self.dims[0] == self.dims[1]
         ):
-            self.elements.append(_ConstantElement(other * qutip.qeye(self.dims[0])))
+            self.elements.append(_ConstantElement(other * qutip.qeye_like(self)))
         else:
             return NotImplemented
         return self
diff --git a/qutip/core/gates.py b/qutip/core/gates.py
index 28726e292c..5b3d988d10 100644
--- a/qutip/core/gates.py
+++ b/qutip/core/gates.py
@@ -4,7 +4,7 @@
 
 import numpy as np
 import scipy.sparse as sp
-from . import Qobj, qeye, sigmax, fock_dm, qdiags
+from . import Qobj, qeye, sigmax, fock_dm, qdiags, qeye_like
 
 
 __all__ = [
@@ -690,7 +690,7 @@ def _powers(op, N):
     Generator that yields powers of an operator `op`,
     through to `N`.
     """
-    acc = qeye(op.dims[0])
+    acc = qeye_like(op)
     yield acc
 
     for _ in range(N - 1):
diff --git a/qutip/core/metrics.py b/qutip/core/metrics.py
index 935b01e927..acd43eba49 100644
--- a/qutip/core/metrics.py
+++ b/qutip/core/metrics.py
@@ -17,7 +17,7 @@
 from .superop_reps import (to_kraus, to_choi, _to_superpauli, to_super,
                            kraus_to_choi)
 from .superoperator import operator_to_vector, vector_to_operator
-from .operators import qeye
+from .operators import qeye, qeye_like
 from .states import ket2dm
 from .semidefinite import dnorm_problem, dnorm_sparse_problem
 from . import data as _data
@@ -494,7 +494,7 @@ def dnorm(A, B=None, solver="CVXOPT", verbose=False, force_solve=False,
     ):
         # Make an identity the same size as A and B to
         # compare against.
-        I = qeye(A.dims[0])
+        I = qeye_like(A)
         # Compare to B first, so that an error is raised
         # as soon as possible.
         Bd = B.dag()
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 5f4202cc4c..3ee4292efb 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -536,8 +536,8 @@ def qzero_like(qobj):
 
     Parameters
     ----------
-    qobj : Qobj
-        Reference ``Qobj`` to copy the dims from.
+    qobj : Qobj, QobjEvo
+        Reference quantum object to copy the dims from.
 
     Returns
     -------
@@ -545,6 +545,9 @@ def qzero_like(qobj):
         Zero operator Qobj.
 
     """
+    from .cy.qobjevo import QobjEvo
+    if isinstance(qobj, QobjEvo):
+        qobj = qobj(0)
     return Qobj(
         _data.zeros_like(qobj.data), dims=qobj.dims, type=qobj.type,
         superrep=qobj.superrep, isherm=True, isunitary=False, copy=False
@@ -609,8 +612,8 @@ def qeye_like(qobj):
 
     Parameters
     ----------
-    qobj : Qobj
-        Reference ``Qobj`` to copy the dims from.
+    qobj : Qobj, QobjEvo
+        Reference quantum object to copy the dims from.
 
     Returns
     -------
@@ -618,6 +621,9 @@ def qeye_like(qobj):
         Identity operator Qobj.
 
     """
+    from .cy.qobjevo import QobjEvo
+    if isinstance(qobj, QobjEvo):
+        qobj = qobj(0)
     return Qobj(
         _data.identity_like(qobj.data), dims=qobj.dims, type=qobj.type,
         superrep=qobj.superrep, isherm=True, isunitary=True, copy=False
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index 83a778b052..b031f3105e 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -1754,7 +1754,7 @@ def _calculate_isunitary(self):
         if not self.isoper or self._data.shape[0] != self._data.shape[1]:
             return False
         cmp = _data.matmul(self._data, self._data.adjoint())
-        iden = _data.identity(self.shape[0], dtype=type(cmp))
+        iden = _data.identity_like(cmp)
         return _data.iszero(_data.sub(cmp, iden),
                             tol=settings.core['atol'])
 
diff --git a/qutip/core/superoperator.py b/qutip/core/superoperator.py
index 328862b8f3..078413a453 100644
--- a/qutip/core/superoperator.py
+++ b/qutip/core/superoperator.py
@@ -311,7 +311,7 @@ def spost(A):
     if not A.isoper:
         raise TypeError('Input is not a quantum operator')
     data = _data.kron(A.data.transpose(),
-                      _data.identity(A.shape[0], dtype=type(A.data)))
+                      _data.identity_like(A.data))
     return Qobj(data,
                 dims=[A.dims, A.dims],
                 type='super',
@@ -336,7 +336,7 @@ def spre(A):
     """
     if not A.isoper:
         raise TypeError('Input is not a quantum operator')
-    data = _data.kron(_data.identity(A.shape[0], dtype=type(A.data)), A.data)
+    data = _data.kron(_data.identity_like(A.data), A.data)
     return Qobj(data,
                 dims=[A.dims, A.dims],
                 type='super',
diff --git a/qutip/solver/correlation.py b/qutip/solver/correlation.py
index b51c8d01f3..fcbeff8e13 100644
--- a/qutip/solver/correlation.py
+++ b/qutip/solver/correlation.py
@@ -8,8 +8,8 @@
 import scipy.fftpack
 
 from ..core import (
-    qeye, Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
-    tensor, qzero, expect
+    Qobj, QobjEvo, liouvillian, spre, unstack_columns, stack_columns,
+    tensor, expect, qeye_like, isket
 )
 from .mesolve import MESolver
 from .mcsolve import MCSolver
@@ -466,11 +466,12 @@ def correlation_3op(solver, state0, tlist, taulist, A=None, B=None, C=None):
         is returned instead.
     """
     taulist = np.asarray(taulist)
+    if isket(state0):
+        state0 = state0.proj()
 
-    dims = state0.dims[0]
-    A = QobjEvo(qeye(dims) if A in [None, 1] else A)
-    B = QobjEvo(qeye(dims) if B in [None, 1] else B)
-    C = QobjEvo(qeye(dims) if C in [None, 1] else C)
+    A = QobjEvo(qeye_like(state0) if A in [None, 1] else A)
+    B = QobjEvo(qeye_like(state0) if B in [None, 1] else B)
+    C = QobjEvo(qeye_like(state0) if C in [None, 1] else C)
 
     if isinstance(solver, (MESolver, BRSolver)):
         out = _correlation_3op_dm(solver, state0, tlist, taulist, A, B, C)
diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index 78408058b1..ed71dc9ad6 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -89,7 +89,7 @@ def _noise_direct(L, wlist, rhoss, J_ops):
     current = np.zeros(N_j_ops)
     noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
 
-    tr_op = tensor([qeye(n) for n in L.dims[0][0]])
+    tr_op = tensor(qeye(L.dims[0][0]))
     tr_op_vec = operator_to_vector(tr_op)
 
     Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())
diff --git a/qutip/solver/propagator.py b/qutip/solver/propagator.py
index 179c0dcef0..e85ad5c5a0 100644
--- a/qutip/solver/propagator.py
+++ b/qutip/solver/propagator.py
@@ -3,7 +3,7 @@
 import numbers
 import numpy as np
 
-from .. import Qobj, qeye, unstack_columns, QobjEvo
+from .. import Qobj, qeye, qeye_like, unstack_columns, QobjEvo, liouvillian
 from ..core import data as _data
 from .mesolve import mesolve, MESolver
 from .sesolve import sesolve, SESolver
@@ -61,12 +61,15 @@ def propagator(H, t, c_ops=(), args=None, options=None, **kwargs):
     if not isinstance(H, (Qobj, QobjEvo)):
         H = QobjEvo(H, args=args, **kwargs)
 
-    if H.issuper or c_ops:
-        out = mesolve(H, qeye(H.dims), tlist, c_ops=c_ops,
-                      args=args, options=options).states
+    if c_ops:
+        H = liouvillian(H, c_ops)
+
+    U0 = qeye_like(H)
+
+    if H.issuper:
+        out = mesolve(H, U0, tlist, args=args, options=options).states
     else:
-        out = sesolve(H, qeye(H.dims[0]), tlist,
-                      args=args, options=options).states
+        out = sesolve(H, U0, tlist, args=args, options=options).states
 
     if list_output:
         return out
@@ -212,7 +215,7 @@ def __call__(self, t, t_start=0, **args):
             self.args = args
             self.solver._argument(args)
             self.times = [0]
-            self.props = [qeye(self.props[0].dims[0])]
+            self.props = [qeye_like(self.props[0])]
             self.solver.start(self.props[0], self.times[0])
 
         if t_start:
@@ -256,7 +259,7 @@ def _compute(self, t, idx):
             U = self.solver.step(t)
         else:
             # Evolving backward in time is not supported by all integrator.
-            self.solver.start(qeye(self.props[0].dims[0]), t)
+            self.solver.start(qeye_like(self.props[0]), t)
             Uinv = self.solver.step(self.times[idx])
             U = self._inv(Uinv)
         return U
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index a87ad9206c..f2a92578d5 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1,6 +1,6 @@
 """ Class for solve function results"""
 import numpy as np
-from ..core import Qobj, QobjEvo, expect, qzero
+from ..core import Qobj, QobjEvo, expect, qzero_like
 
 __all__ = ["Result", "MultiTrajResult", "McResult"]
 
@@ -486,11 +486,11 @@ def _add_first_traj(self, trajectory):
 
         if trajectory.states:
             state = trajectory.states[0]
-            self._sum_states = [qzero(state.dims[0])
+            self._sum_states = [qzero_like(self._to_dm(state))
                                 for state in trajectory.states]
         if trajectory.final_state:
             state = trajectory.final_state
-            self._sum_final_states = qzero(state.dims[0])
+            self._sum_final_states = qzero_like(self._to_dm(state))
 
         self._sum_expect = [
             np.zeros_like(expect) for expect in trajectory.expect
diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
index f576c9f2bb..60e027792b 100644
--- a/qutip/solver/steadystate.py
+++ b/qutip/solver/steadystate.py
@@ -1,4 +1,4 @@
-from qutip import liouvillian, lindblad_dissipator, Qobj, qeye, qzero
+from qutip import liouvillian, lindblad_dissipator, Qobj, qzero_like, qeye_like
 from qutip import vector_to_operator, operator_to_vector
 from qutip import settings
 import qutip.core.data as _data
@@ -377,8 +377,8 @@ def steadystate_floquet(H_0, c_ops, Op_t, w_d=1.0, n_it=3, sparse=False,
     # L_p and L_m correspond to the positive and negative
     # frequency terms respectively.
     # They are independent in the model, so we keep both names.
-    Id = qeye(L_0.dims[0], dtype=type(L_0.data))
-    S = T = qzero(L_0.dims[0], dtype=type(L_0.data))
+    Id = qeye_like(L_0)
+    S = T = qzero_like(L_0)
 
     if isinstance(H_0.data, _data.CSR) and not sparse:
         L_0 = L_0.to("Dense")
@@ -478,11 +478,11 @@ def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
     dtype = type(L.data)
     rhoss_vec = operator_to_vector(rhoss)
 
-    tr_op = qeye(L.dims[0][0])
+    tr_op = qeye_like(rhoss)
     tr_op_vec = operator_to_vector(tr_op)
 
     P = _data.kron(rhoss_vec.data, tr_op_vec.data.transpose(), dtype=dtype)
-    I = _data.csr.identity(N * N)
+    I = _data.identity_like(P)
     Q = _data.sub(I, P)
 
     if w in [None, 0.0]:
diff --git a/qutip/tests/core/test_gates.py b/qutip/tests/core/test_gates.py
index 7b3795b50d..00f47ffedd 100644
--- a/qutip/tests/core/test_gates.py
+++ b/qutip/tests/core/test_gates.py
@@ -35,7 +35,7 @@ def gate(N=None, controls=None, target=None):
 
 
 def _make_controled(op):
-    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye(op.dims[0]))
+    out = qutip.tensor(qutip.fock_dm(2, 0), qutip.qeye_like(op))
     out += qutip.tensor(qutip.fock_dm(2, 1), op)
     return out
 
diff --git a/qutip/tests/solver/test_propagator.py b/qutip/tests/solver/test_propagator.py
index 2d36d9f977..5119fa0d6b 100644
--- a/qutip/tests/solver/test_propagator.py
+++ b/qutip/tests/solver/test_propagator.py
@@ -1,6 +1,7 @@
 import numpy as np
 from qutip import (destroy, propagator, Propagator, propagator_steadystate,
-                   steadystate, tensor, qeye, basis, QobjEvo, sesolve)
+                   steadystate, tensor, qeye, basis, QobjEvo, sesolve,
+                   liouvillian)
 import qutip
 import pytest
 from qutip.solver.brmesolve import BRSolver
@@ -87,6 +88,13 @@ def testPropHDims():
     assert U.dims == H.dims
 
 
+def testPropHSuper():
+    "Propagator: preserve super_oper dims"
+    L = liouvillian(qeye(2) & qeye(2), [destroy(2) & destroy(2)])
+    U = propagator(L, 1)
+    assert U.dims == L.dims
+
+
 def testPropEvo():
     a = destroy(5)
     H = a.dag()*a

From 581a599c1da8ce6cc74ae60d1ca62cedfb59235d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 13:15:32 -0400
Subject: [PATCH 326/602] Add test for qeye_like with QobjEvo

---
 qutip/tests/core/test_operators.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index 0e452edcbf..58f3f665b1 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -319,6 +319,10 @@ def test_qeye_like(dims, superrep, dtype):
     expected.superrep = superrep
     assert new == expected
 
+    opevo = qutip.QobjEvo(op)
+    new = qutip.qeye_like(op)
+    assert new == expected
+
 
 @pytest.mark.parametrize(["dims", "superrep"], [
     pytest.param([2], None, id="simple"),
@@ -334,3 +338,7 @@ def test_qzero_like(dims, superrep, dtype):
     expected = qutip.qzero(dims, dtype=dtype)
     expected.superrep = superrep
     assert new == expected
+
+    opevo = qutip.QobjEvo(op)
+    new = qutip.qzero_like(op)
+    assert new == expected

From 1c9dd899784d3eca03a5bf16af4c597d3989b759 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 14:44:30 -0400
Subject: [PATCH 327/602] use zeros_like

---
 qutip/core/data/constant.py | 4 ++++
 qutip/core/data/dense.pxd   | 2 +-
 qutip/solver/sode/_sode.pyx | 8 ++++----
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 179f90028b..52f23f413f 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -79,6 +79,8 @@ def zeros_like(data, /):
     """
     Create an zeros matrix of the same type and shape.
     """
+    if type(data) is Dense:
+        return dense.zeros(*data.shape, fortran=data.fortran)
     return zeros[type(data)](*data.shape)
 
 
@@ -88,4 +90,6 @@ def identity_like(data, /):
     """
     if not data.shape[0] == data.shape[1]:
         raise ValueError("Can't create and identity like a non square matrix.")
+    if type(data) is Dense:
+        return dense.identity(data.shape[0], fortran=data.fortran)
     return identity[type(data)](data.shape[0])
diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
index 3c3dad938a..6be9468a4c 100644
--- a/qutip/core/data/dense.pxd
+++ b/qutip/core/data/dense.pxd
@@ -7,7 +7,7 @@ from .csr cimport CSR
 
 cdef class Dense(base.Data):
     cdef double complex *data
-    cdef bint fortran
+    cdef readonly bint fortran
     cdef object _np
     cdef bint _deallocate
     cdef void _fix_flags(Dense self, object array, bint make_owner=*)
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index 41e6766662..eb2052b44f 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -244,7 +244,7 @@ cdef class Milstein:
         cdef int i
         if type(state) != _data.Dense:
             state = _data.to(_data.Dense, state)
-        cdef Dense out = _data.mul_dense(state, 0)
+        cdef Dense out = _data.zeros_like(state)
         state = state.copy()
 
         for i in range(ntraj):
@@ -300,8 +300,8 @@ cdef class PredCorr:
         cdef int i
         if type(state) != _data.Dense:
             state = _data.to(_data.Dense, state)
-        cdef Dense out = _data.mul_dense(state, 0)
-        self.euler = _data.mul_dense(state, 0)
+        cdef Dense out = _data.zeros_like(state)
+        self.euler = _data.zeros_like(state)
         state = state.copy()
 
         for i in range(ntraj):
@@ -416,7 +416,7 @@ cdef class Milstein_imp:
         cdef int i
         if type(state) != _data.Dense:
             state = _data.to(_data.Dense, state)
-        cdef Dense tmp = _data.mul_dense(state, 0)
+        cdef Dense tmp = _data.zeros_like(state)
 
         if dt != self.prev_dt:
             self.implicit = 1 - self.system.L * (dt / 2)

From f472a6df42a0301867e464713497cfd7d8761760 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Fri, 14 Apr 2023 18:01:09 -0400
Subject: [PATCH 328/602] Update qutip/solver/countstat.py

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/solver/countstat.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/countstat.py b/qutip/solver/countstat.py
index ed71dc9ad6..f6a3a4341b 100644
--- a/qutip/solver/countstat.py
+++ b/qutip/solver/countstat.py
@@ -89,7 +89,7 @@ def _noise_direct(L, wlist, rhoss, J_ops):
     current = np.zeros(N_j_ops)
     noise = np.zeros((N_j_ops, N_j_ops, len(wlist)))
 
-    tr_op = tensor(qeye(L.dims[0][0]))
+    tr_op = qeye(L.dims[0][0])
     tr_op_vec = operator_to_vector(tr_op)
 
     Pop = _data.kron(rhoss_vec, tr_op_vec.data.transpose())

From b65be1035d30743254dc17e7298bc1b0be097bb0 Mon Sep 17 00:00:00 2001
From: Simon Cross <hodgestar@gmail.com>
Date: Mon, 17 Apr 2023 17:07:53 +0200
Subject: [PATCH 329/602] Add missing __init__.py to qutip.solver.nonmarkov
 package.

---
 qutip/solver/nonmarkov/__init__.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 qutip/solver/nonmarkov/__init__.py

diff --git a/qutip/solver/nonmarkov/__init__.py b/qutip/solver/nonmarkov/__init__.py
new file mode 100644
index 0000000000..e69de29bb2

From feb713811cb12bc1440f9984f40d53ef50c00988 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 17 Apr 2023 12:11:55 -0400
Subject: [PATCH 330/602] SameData properly supported

---
 qutip/core/data/dispatch.pyx | 108 +++++++++++++++++++++--------------
 1 file changed, 64 insertions(+), 44 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 7ec5a0503b..327fecd3f0 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -26,8 +26,7 @@ cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out
     Specialisations that support any types input should use ``Data`` if types
     can be mixed, or ``SameData``, when they cannot be mixed.
     """
-    cdef double weight = 0.0, anydataweight = 0.01
-    cdef type sametype = None
+    cdef double weight = 0.0
     cdef Py_ssize_t i, n=len(froms)
     if len(tos) != n:
         raise ValueError(
@@ -36,15 +35,7 @@ cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out
     if out:
         n = n - 1
         weight += weight_map[froms[n], tos[n]]
-        if tos[n] is SameData:
-            sametype = froms[n]
-
     for i in range(n):
-        if tos[i] is SameData and sametype in [None, froms[i]]:
-            sametype = froms[i]
-        elif tos[i] is SameData:
-            # DataType not matching, can't use the function.
-            weight += math.INFINITY
         weight += weight_map[tos[i], froms[i]]
     return weight
 
@@ -295,6 +286,64 @@ cdef class Dispatcher:
         if not _defer:
             self.rebuild_lookup()
 
+    cdef object _find_specialization(self, tuple in_type, bint output):
+        # The complexity of building the table here is very poor, but it's a
+        # cost we pay very infrequently, and until it's proved to be a
+        # bottle-neck in real code, we stick with the simple algorithm.
+        cdef double weight, cur
+        cdef tuple types, out_types, dtype, displayed_type
+        cdef object function
+        cdef int n_dispatch
+        weight = math.INFINITY
+        types = None
+        function = None
+        n_dispatch = len(in_type)
+        for out_types, out_function in self._specialisations.items():
+            if SameData in out_types:
+                # Extra loop over all possible ``SameData``
+                for dtype in self._dtypes:
+                    curr_types = (
+                        (type_ if type_ is not SameData else dtype)
+                        for type_ in out_types
+                    )
+                cur = _conversion_weight(
+                    in_types, curr_types[:n_dispatch], _to.weight, out=output)
+                # Extra cost to use ``SameData`` over real specialisations
+                # It ensure (SameData, SameData) lose to (Dense, Dense), etc.
+                cur += 0.001
+                if cur < weight:
+                    weight = cur
+                    types = curr_types
+                    function = out_function
+            else:
+                cur = _conversion_weight(
+                    in_types, out_types[:n_dispatch], _to.weight, out=output)
+                if cur < weight:
+                    weight = cur
+                    types = out_types
+                    function = out_function
+
+        if cur == math.INFINITY:
+            raise ValueError("No valid specialisations found")
+
+        if weight <= 0.01 and not (output and out_types[-1] is Data):
+            self._lookup[in_types] = function
+        else:
+            if output:
+                converters = tuple(
+                    [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
+                    + [_to[in_types[-1], types[-1]]]
+                )
+            else:
+                converters = tuple(_to[pair] for pair in zip(types, in_types))
+            displayed_type = in_types
+            if len(in_dtype) < len(types):
+                displayed_type = displayed_type + (types[-1],)
+            self._lookup[in_types] =\
+                _constructed_specialisation(function, self, displayed_type,
+                                            converters, output)
+
+
     def rebuild_lookup(self):
         """
         Manually trigger a rebuild of the lookup table for this dispatcher.
@@ -304,47 +353,18 @@ cdef class Dispatcher:
 
         You most likely do not need to call this function yourself.
         """
-        cdef double weight, cur
-        cdef tuple types, out_types
-        cdef object function
         if not self._specialisations:
             return
         self._dtypes = _to.dtypes.copy()
-        # The complexity of building the table here is very poor, but it's a
-        # cost we pay very infrequently, and until it's proved to be a
-        # bottle-neck in real code, we stick with the simple algorithm.
         for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch):
-            weight = math.INFINITY
-            types = None
-            function = None
-            for out_types, out_function in self._specialisations.items():
-                cur = _conversion_weight(in_types, out_types, _to.weight,
-                                         out=self.output)
-                if cur < weight:
-                    weight = cur
-                    types = out_types
-                    function = out_function
-
-            if cur == math.INFINITY:
-                raise ValueError("No valid specialisations found")
-
-            if weight <= 0.01:
-                self._lookup[in_types] = function
-            else:
-                if self.output:
-                    converters = tuple(
-                        [_to[pair] for pair in zip(types[:-1], in_types[:-1])]
-                        + [_to[in_types[-1], types[-1]]]
-                    )
-                else:
-                    converters = tuple(_to[pair] for pair in zip(types, in_types))
-                self._lookup[in_types] =\
-                    _constructed_specialisation(function, self, in_types,
-                                                converters, self.output)
+            self._find_specialization(in_types, self.output)
         # Now build the lookup table in the case that we dispatch on the output
         # type as well, but the user has called us without specifying it.
         # TODO: option to control default output type choice if unspecified?
         if self.output:
+            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
+                self._find_specialization(in_types, False)
+            """
             for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
                 weight = math.INFINITY
                 types = None
@@ -370,7 +390,7 @@ cdef class Dispatcher:
                     self._lookup[in_types] =\
                         _constructed_specialisation(function, self,
                                                     in_types + (types[-1],),
-                                                    converters, False)
+                                                    converters, False)"""
 
     def __getitem__(self, types):
         """

From e5231b06dcc8a1233a6b7e53d1d196a8f957ef28 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Tue, 18 Apr 2023 15:25:23 +0900
Subject: [PATCH 331/602] Fixed a bug where the martingale value was not set to
 one at the beginning of trajectories

---
 qutip/solver/nm_mcsolve.py | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/qutip/solver/nm_mcsolve.py b/qutip/solver/nm_mcsolve.py
index d98ac14f18..f97298b390 100644
--- a/qutip/solver/nm_mcsolve.py
+++ b/qutip/solver/nm_mcsolve.py
@@ -204,19 +204,25 @@ def reset(self):
         self._precomputed_continuous_martingale = {}
         self._discrete_martingale = None
 
-    def initialize(self, t0, tlist=None):
+    def initialize(self, t0, cache='clear'):
+        # `cache` may be 'clear', 'keep' or a new list of times for which
+        #  to pre-compute the continuous contribution to the martingale
         self._t_prev = t0
         self._continuous_martingale_at_t_prev = 1
         self._discrete_martingale = 1
 
-        # if a tlist was given, precompute continuous martingale values
+        if np.array_equal(cache, 'clear'):
+            self._precomputed_continuous_martingale = {}
+            return
+        if np.array_equal(cache, 'keep'):
+            return
+
         self._precomputed_continuous_martingale = {}
-        if tlist is not None:
-            mu_c0 = 1
-            for t1 in tlist:
-                mu_c1 = mu_c0 * self._compute_continuous_martingale(t0, t1)
-                self._precomputed_continuous_martingale[t1] = mu_c1
-                t0, mu_c0 = t1, mu_c1
+        mu_c0 = 1
+        for t1 in cache:
+            mu_c1 = mu_c0 * self._compute_continuous_martingale(t0, t1)
+            self._precomputed_continuous_martingale[t1] = mu_c1
+            t0, mu_c0 = t1, mu_c1
 
     def add_collapse(self, collapse_time, collapse_channel):
         if self._t_prev is None:
@@ -274,6 +280,10 @@ def _do_collapse(self, *args, **kwargs):
             collapse_time, collapse_channel = self.collapses[-1]
             self._martingale.add_collapse(collapse_time, collapse_channel)
 
+    def set_state(self, t, *args, **kwargs):
+        super().set_state(t, *args, **kwargs)
+        self._martingale.initialize(t, cache='keep')
+
 
 class NonMarkovianMCSolver(MCSolver):
     """
@@ -485,7 +495,7 @@ def sqrt_shifted_rate(self, t, i):
     # martingale value from the NonMarkovianMCSolver whenever a state is added.
 
     def start(self, state, t0, seed=None):
-        self._martingale.initialize(t0)
+        self._martingale.initialize(t0, cache='clear')
         return super().start(state, t0, seed=seed)
 
     # The returned state will be a density matrix with trace=mu the martingale
@@ -500,7 +510,7 @@ def run(self, state, tlist, *args, **kwargs):
         if 'args' in kwargs:
             self._argument(kwargs.pop('args'))
 
-        self._martingale.initialize(tlist[0], tlist=tlist)
+        self._martingale.initialize(tlist[0], cache=tlist)
         result = super().run(state, tlist, *args, **kwargs)
         self._martingale.reset()
 

From daf31407a737a4fd338fce98c760f317c0ee13f3 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Tue, 18 Apr 2023 15:25:52 +0900
Subject: [PATCH 332/602] Minor docs update (monte carlo solver guide)

---
 doc/guide/dynamics/dynamics-monte.rst | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index f0a82e16db..ea03ccd5bf 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -303,7 +303,7 @@ The only difference is how the collapse operators and rate functions should be d
 Note that we give the actual rate and not its square root, and that ``nm_mcsolve`` automatically computes associated jump rates :math:`\Gamma_n(t)\geq0` appropriate for simulation.
 
 We conclude with a simple example demonstrating the usage of the ``nm_mcsolve`` function.
-For more elaborate, physically motivated examples, we refer to example notebook 1 [TODO] and example notebook 2 [TODO].
+For more elaborate, physically motivated examples, we refer to the accompanying tutorial notebook [TODO].
 
 
 .. plot::
@@ -327,10 +327,11 @@ For more elaborate, physically motivated examples, we refer to example notebook
 
     # nm_mcsolve integration
     ops_and_rates = []
-    ops_and_rates.append( [a0.dag(), gamma1] )
-    ops_and_rates.append( [a0,       gamma2] )
+    ops_and_rates.append([a0.dag(), gamma1])
+    ops_and_rates.append([a0,       gamma2])
     MCSol = qt.nm_mcsolve(H, psi0, times, ops_and_rates,
-                          e_ops=[a0.dag() * a0, a0 * a0.dag()], ntraj=2500)
+                          e_ops=[a0.dag() * a0, a0 * a0.dag()],
+                          options={'map': 'parallel'}, ntraj=2500)
 
     # mesolve integration for comparison
     d_ops = [[qt.lindblad_dissipator(a0.dag(), a0.dag()), gamma1],
@@ -338,8 +339,11 @@ For more elaborate, physically motivated examples, we refer to example notebook
     MESol = qt.mesolve(H, psi0, times, d_ops, e_ops=[a0.dag() * a0, a0 * a0.dag()])
 
     plt.figure()
-    plt.plot(times, MCSol.expect[0], 'g', times, MCSol.expect[1], 'b', times, MCSol.trace, 'r')
-    plt.plot(times, MESol.expect[0], 'g--', times, MESol.expect[1], 'b--')
+    plt.plot(times, MCSol.expect[0], 'g',
+             times, MCSol.expect[1], 'b',
+             times, MCSol.trace, 'r')
+    plt.plot(times, MESol.expect[0], 'g--',
+             times, MESol.expect[1], 'b--')
     plt.title('Monte Carlo time evolution')
     plt.xlabel('Time')
     plt.ylabel('Expectation values')

From f7d58d26a075836738dff2f641c7250d79921816 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 18 Apr 2023 09:17:32 -0400
Subject: [PATCH 333/602] Add dispatcher test

---
 qutip/core/data/convert.pyx            |  27 +++---
 qutip/core/data/dispatch.pyx           |  14 +--
 qutip/tests/core/data/test_dispatch.py | 128 +++++++++++++++++++++++++
 3 files changed, 147 insertions(+), 22 deletions(-)
 create mode 100644 qutip/tests/core/data/test_dispatch.py

diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index 3aef42ac51..b53888899f 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -77,16 +77,16 @@ def dummyconverter(arg):
 cdef class _partial_converter:
     """Convert from any known data-layer type into the type `x.to`."""
 
-    cdef dict converters
+    cdef object converter
     cdef readonly type to
 
-    def __init__(self, converters, to_type):
-        self.converters = dict(converters)
+    def __init__(self, converter, to_type):
+        self.converter = converter
         self.to = to_type
 
     def __call__(self, arg):
         try:
-            return self.converters[type(arg)](arg)
+            return self.converter[self.to, type(arg)](arg)
         except KeyError:
             raise TypeError("unknown type of input: " + str(arg)) from None
 
@@ -268,14 +268,14 @@ cdef class _to:
                 self._convert[(to_t, from_t)] =\
                     _converter(convert[::-1], to_t, from_t)
         for dtype in self.dtypes:
-            self.weight[(dtype, Data)] = self.anydataweight
+            self.weight[(dtype, Data)] = 1.
             self.weight[(Data, dtype)] = self.anydataweight
-            self.weight[(dtype, SameData)] = self.anydataweight
-            self.weight[(SameData, dtype)] = self.anydataweight
-            self._convert[(dtype, Data)] = dummyconverter
+            # self.weight[(dtype, SameData)] = self.anydataweight
+            # self.weight[(SameData, dtype)] = 1.
+            self._convert[(dtype, Data)] = _partial_converter(self, dtype)
             self._convert[(Data, dtype)] = dummyconverter
-            self._convert[(dtype, SameData)] = dummyconverter
-            self._convert[(SameData, dtype)] = dummyconverter
+            # self._convert[(dtype, SameData)] = dummyconverter
+            # self._convert[(SameData, dtype)] = dummyconverter
         for dispatcher in self.dispatchers:
             dispatcher.rebuild_lookup()
 
@@ -327,7 +327,7 @@ cdef class _to:
             type.
         """
         if type(dtype) is type:
-            if dtype not in self.dtypes:
+            if dtype not in self.dtypes and dtype is not Data:
                 raise ValueError(
                     "Type is not a data-layer type: " + repr(dtype))
             return dtype
@@ -351,10 +351,7 @@ cdef class _to:
             raise KeyError(arg)
         to_t = self.parse(arg[0])
         if len(arg) == 1:
-            converters = {
-                from_t: self._convert[to_t, from_t] for from_t in self.dtypes
-            }
-            return _partial_converter(converters, to_t)
+            return _partial_converter(self, to_t)
         from_t = self.parse(arg[1])
         return self._convert[to_t, from_t]
 
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 327fecd3f0..1492e76438 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -276,8 +276,7 @@ cdef class Dispatcher:
                 if (
                     not _defer
                     and arg[i] not in _to.dtypes
-                    and arg[i] is not Data
-                    and not isinstance(arg[i], Data)
+                    and arg[i] not in [Data, SameData]
                 ):
                     raise ValueError(str(arg[i]) + " is not a known data type")
             if not callable(arg[self._n_dispatch]):
@@ -286,23 +285,24 @@ cdef class Dispatcher:
         if not _defer:
             self.rebuild_lookup()
 
-    cdef object _find_specialization(self, tuple in_type, bint output):
+    cdef object _find_specialization(self, tuple in_types, bint output):
         # The complexity of building the table here is very poor, but it's a
         # cost we pay very infrequently, and until it's proved to be a
         # bottle-neck in real code, we stick with the simple algorithm.
         cdef double weight, cur
-        cdef tuple types, out_types, dtype, displayed_type
+        cdef tuple types, out_types, displayed_type
+        cdef type dtype
         cdef object function
         cdef int n_dispatch
         weight = math.INFINITY
         types = None
         function = None
-        n_dispatch = len(in_type)
+        n_dispatch = len(in_types)
         for out_types, out_function in self._specialisations.items():
             if SameData in out_types:
                 # Extra loop over all possible ``SameData``
                 for dtype in self._dtypes:
-                    curr_types = (
+                    curr_types = tuple(
                         (type_ if type_ is not SameData else dtype)
                         for type_ in out_types
                     )
@@ -337,7 +337,7 @@ cdef class Dispatcher:
             else:
                 converters = tuple(_to[pair] for pair in zip(types, in_types))
             displayed_type = in_types
-            if len(in_dtype) < len(types):
+            if len(in_types) < len(types):
                 displayed_type = displayed_type + (types[-1],)
             self._lookup[in_types] =\
                 _constructed_specialisation(function, self, displayed_type,
diff --git a/qutip/tests/core/data/test_dispatch.py b/qutip/tests/core/data/test_dispatch.py
new file mode 100644
index 0000000000..8bca4bf5dd
--- /dev/null
+++ b/qutip/tests/core/data/test_dispatch.py
@@ -0,0 +1,128 @@
+import pytest
+import itertools
+import qutip
+from qutip.core.data.dispatch import Dispatcher
+from qutip.core.data.base import SameData
+import qutip.core.data as _data
+
+
+
+class pseudo_dipatched:
+    def __init__(self, types, output):
+        self.use_samedata = SameData in types
+        if output:
+            self.output = types[-1]
+            self.inputs = types[:-1]
+        else:
+            self.output = False
+            self.inputs = types
+
+    def __call__(self, *args, **kwargs):
+        print(args)
+        assert len(args) == len(self.inputs)
+        assert not kwargs
+        samedata = None
+        for got, expected in zip(args, self.inputs):
+            if expected is SameData and samedata is None:
+                samedata = type(got)
+                expected = type(got)
+            elif expected is SameData:
+                expected = samedata
+            print(expected)
+            assert isinstance(got, expected)
+
+        if not self.output:
+            return
+        elif self.output is SameData:
+            return _data.zeros[samedata](1,1)
+        elif self.output is _data.Data:
+            return _data.zeros(1,1)
+        else:
+            return _data.zeros[self.output](1,1)
+
+
+def _gen_dispatcher(specialisations, output=False):
+    def f(a=None, b=None, c=None, /):
+        """
+        Doc
+        """
+
+    n_inputs = len(specialisations[0]) - output
+    dispatched = Dispatcher(f, ("a", "b", "c")[:n_inputs], output)
+    dispatched.add_specialisations(
+        [spec + (pseudo_dipatched(spec, output),) for spec in specialisations]
+    )
+    return dispatched
+
+
+def _assert_usable_all_mix(dispatched, n_input, output):
+    """
+    Call the dispatched function with all mixes of data types, with and without
+    output specification.
+    """
+    for in_types in itertools.product(_data.to.dtypes, repeat=n_input):
+        ins = tuple(_data.zeros[dtype](1, 1) for dtype in in_types)
+
+        if not output:
+            out = dispatched(*ins)
+            out = dispatched[in_types](*ins)
+            continue
+
+        out = dispatched(*ins)
+        assert out is not None
+
+        out = dispatched[in_types](*ins)
+        assert out is not None
+
+        if output:
+            for out_dtype in _data.to.dtypes:
+
+                out = dispatched[in_types + (out_dtype,)](*ins)
+                if output:
+                    assert isinstance(out, out_dtype)
+
+                out = dispatched(*ins, dtype=out_dtype)
+                if output:
+                    assert isinstance(out, out_dtype)
+
+
+def _test_name(arg):
+    if isinstance(arg, bool):
+        return str(arg)
+    return ", ".join(spec.__name__ for spec in arg)
+
+
+@pytest.mark.parametrize(['specialisation', "output"], [
+    ((_data.Dense,), True),
+    ((_data.Data,), True),
+    ((_data.Dense,), False),
+    ((_data.Data,), False),
+    ((_data.Dense, _data.Dense), True),
+    ((_data.Dense, _data.CSR), True),
+    ((_data.Data, _data.Data), True),
+    ((_data.Data, _data.Dense), True),
+    ((_data.Dense, _data.Data), True),
+    ((SameData, SameData), True),
+    ((_data.Dense, _data.Dense), False),
+    ((_data.Dense, _data.CSR), False),
+    ((_data.Data, _data.Data), False),
+    ((_data.Data, _data.Dense), False),
+    ((_data.Dense, _data.Data), False),
+    ((SameData, SameData), False),
+    ((_data.Dense, _data.Dense, _data.Dense), True),
+    ((_data.Dense, _data.CSR, _data.CSR), True),
+    ((_data.Data, _data.Data, _data.Data), True),
+    ((_data.Data, _data.Dense, _data.Dense), True),
+    ((_data.Dense, _data.Data, _data.Data), True),
+    ((SameData, SameData, SameData), True),
+    ((SameData, SameData, _data.Dense), True),
+    ((SameData, SameData, _data.Data), True),
+    ((SameData, _data.Dense, SameData), True),
+    ((SameData, _data.Data, SameData), True),
+], ids=_test_name)
+def test_build_full(specialisation, output):
+    """
+    Test that the dispatched function can always be called with any input type.
+    """
+    dispatched = _gen_dispatcher([specialisation], output)
+    _assert_usable_all_mix(dispatched, len(specialisation) - output, output)

From d637991933cc70f700380552e9bd4f6ed06684ea Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 18 Apr 2023 11:15:26 -0400
Subject: [PATCH 334/602] Add a dispatcher test

---
 qutip/core/data/dispatch.pyx           |  33 +----
 qutip/tests/core/data/test_dispatch.py | 170 +++++++++++++++++--------
 2 files changed, 125 insertions(+), 78 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 1492e76438..44da5b5588 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -326,7 +326,11 @@ cdef class Dispatcher:
         if cur == math.INFINITY:
             raise ValueError("No valid specialisations found")
 
-        if weight <= 0.01 and not (output and out_types[-1] is Data):
+        print(in_types)
+        print(types)
+        print(weight, output, types[-1])
+        print(output and types[-1] is Data)
+        if weight <= 0.01 and not (output and types[-1] is Data):
             self._lookup[in_types] = function
         else:
             if output:
@@ -364,33 +368,6 @@ cdef class Dispatcher:
         if self.output:
             for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
                 self._find_specialization(in_types, False)
-            """
-            for in_types in itertools.product(self._dtypes, repeat=self._n_dispatch-1):
-                weight = math.INFINITY
-                types = None
-                function = None
-                for out_types, out_function in self._specialisations.items():
-                    cur = _conversion_weight(in_types, out_types[:-1],
-                                             _to.weight, out=False)
-                    if cur < weight:
-                        weight = cur
-                        types = out_types
-                        function = out_function
-
-                if cur == math.INFINITY:
-                    raise ValueError("No valid specialisations found")
-
-                if weight <= 0.01:
-                    self._lookup[in_types] = function
-                else:
-                    converters = tuple(
-                        _to[pair]
-                        for pair in zip(types, in_types)
-                    )
-                    self._lookup[in_types] =\
-                        _constructed_specialisation(function, self,
-                                                    in_types + (types[-1],),
-                                                    converters, False)"""
 
     def __getitem__(self, types):
         """
diff --git a/qutip/tests/core/data/test_dispatch.py b/qutip/tests/core/data/test_dispatch.py
index 8bca4bf5dd..6d582f28db 100644
--- a/qutip/tests/core/data/test_dispatch.py
+++ b/qutip/tests/core/data/test_dispatch.py
@@ -1,12 +1,11 @@
 import pytest
 import itertools
 import qutip
-from qutip.core.data.dispatch import Dispatcher
+from qutip.core.data.dispatch import Dispatcher, _constructed_specialisation
 from qutip.core.data.base import SameData
 import qutip.core.data as _data
 
 
-
 class pseudo_dipatched:
     def __init__(self, types, output):
         self.use_samedata = SameData in types
@@ -28,7 +27,6 @@ def __call__(self, *args, **kwargs):
                 expected = type(got)
             elif expected is SameData:
                 expected = samedata
-            print(expected)
             assert isinstance(got, expected)
 
         if not self.output:
@@ -41,51 +39,6 @@ def __call__(self, *args, **kwargs):
             return _data.zeros[self.output](1,1)
 
 
-def _gen_dispatcher(specialisations, output=False):
-    def f(a=None, b=None, c=None, /):
-        """
-        Doc
-        """
-
-    n_inputs = len(specialisations[0]) - output
-    dispatched = Dispatcher(f, ("a", "b", "c")[:n_inputs], output)
-    dispatched.add_specialisations(
-        [spec + (pseudo_dipatched(spec, output),) for spec in specialisations]
-    )
-    return dispatched
-
-
-def _assert_usable_all_mix(dispatched, n_input, output):
-    """
-    Call the dispatched function with all mixes of data types, with and without
-    output specification.
-    """
-    for in_types in itertools.product(_data.to.dtypes, repeat=n_input):
-        ins = tuple(_data.zeros[dtype](1, 1) for dtype in in_types)
-
-        if not output:
-            out = dispatched(*ins)
-            out = dispatched[in_types](*ins)
-            continue
-
-        out = dispatched(*ins)
-        assert out is not None
-
-        out = dispatched[in_types](*ins)
-        assert out is not None
-
-        if output:
-            for out_dtype in _data.to.dtypes:
-
-                out = dispatched[in_types + (out_dtype,)](*ins)
-                if output:
-                    assert isinstance(out, out_dtype)
-
-                out = dispatched(*ins, dtype=out_dtype)
-                if output:
-                    assert isinstance(out, out_dtype)
-
-
 def _test_name(arg):
     if isinstance(arg, bool):
         return str(arg)
@@ -124,5 +77,122 @@ def test_build_full(specialisation, output):
     """
     Test that the dispatched function can always be called with any input type.
     """
-    dispatched = _gen_dispatcher([specialisation], output)
-    _assert_usable_all_mix(dispatched, len(specialisation) - output, output)
+    def f(a=None, b=None, c=None, /):
+        """
+        Doc
+        """
+
+
+    n_input = len(specialisation) - output
+    dispatched = Dispatcher(f, ("a", "b", "c")[:n_input], output)
+    dispatched.add_specialisations(
+        [specialisation + (pseudo_dipatched(specialisation, output),)]
+    )
+
+    for in_types in itertools.product(_data.to.dtypes, repeat=n_input):
+        ins = tuple(_data.zeros[dtype](1, 1) for dtype in in_types)
+
+        if not output:
+            out = dispatched(*ins)
+            out = dispatched[in_types](*ins)
+            continue
+
+        out = dispatched(*ins)
+        assert out is not None
+
+        out = dispatched[in_types](*ins)
+        assert out is not None
+
+        if output:
+            for out_dtype in _data.to.dtypes:
+
+                out = dispatched[in_types + (out_dtype,)](*ins)
+                if output:
+                    assert isinstance(out, out_dtype)
+
+                out = dispatched(*ins, dtype=out_dtype)
+                if output:
+                    assert isinstance(out, out_dtype)
+
+
+def test_Data_low_priority_one_dispatch():
+    class func():
+        __name__ = ""
+        def __call__(self, a, /):
+            return _data.zeros[_data.Dense](1, 1)
+
+    f_dense = func()
+    f_data = func()
+
+    dispatched = Dispatcher(f_dense, ("a",), False)
+    dispatched.add_specialisations([
+        (_data.Dense, f_dense), (_data.Data, f_data)]
+    )
+
+    assert dispatched[_data.Dense] is f_dense
+    assert dispatched[_data.CSR] is f_data
+
+    dispatched = Dispatcher(f_dense, (), True)
+    dispatched.add_specialisations([
+        (_data.Dense, f_dense), (_data.Data, f_data)]
+    )
+
+    assert dispatched[_data.Dense] is f_dense
+    assert isinstance(dispatched[_data.CSR], _constructed_specialisation)
+
+
+def test_Data_low_priority_two_dispatch():
+    class func():
+        __name__ = ""
+        def __init__(self):
+            self.count = 0
+
+        def __call__(self, a=None, b=None, /):
+            self.count += 1
+            return _data.zeros[_data.Dense](1, 1)
+
+    f_dense = func()
+    f_mixed = func()
+    f_data = func()
+
+    dispatched = Dispatcher(f_dense, ("a", "b"), False)
+    dispatched.add_specialisations([
+        (_data.Dense, _data.Dense, f_dense),
+        (_data.Dense, _data.Data, f_mixed),
+        (_data.Data, _data.Data, f_data),
+    ])
+
+    assert dispatched[_data.Dense, _data.Dense] is f_dense
+    assert dispatched[_data.Dense, _data.CSR] is f_mixed
+    assert dispatched[_data.CSR, _data.Dense] is f_data
+    assert dispatched[_data.CSR, _data.CSR] is f_data
+
+    dispatched = Dispatcher(f_dense, ("a",), True)
+    dispatched.add_specialisations([
+        (_data.Dense, _data.Dense, f_dense),
+        (_data.Dense, _data.Data, f_mixed),
+        (_data.Data, _data.Data, f_data),
+    ])
+
+    assert dispatched[_data.Dense, _data.Dense] is f_dense
+    assert dispatched[_data.CSR] is f_data
+    assert dispatched[_data.Dense] is f_dense
+    assert isinstance(
+        dispatched[_data.Dense, _data.CSR], _constructed_specialisation
+    )
+
+    assert f_mixed.count == 0
+    dispatched[_data.Dense, _data.CSR](_data.zeros[_data.Dense](1, 1))
+    assert f_mixed.count == 1
+
+    assert isinstance(
+        dispatched[_data.CSR, _data.Dense], _constructed_specialisation
+    )
+    assert isinstance(
+        dispatched[_data.CSR, _data.CSR], _constructed_specialisation
+    )
+
+    assert f_data.count == 0
+    dispatched[_data.CSR, _data.Dense](_data.zeros[_data.CSR](1, 1))
+    dispatched[_data.CSR, _data.CSR](_data.zeros[_data.CSR](1, 1))
+    assert f_data.count == 1

From 6c009e50d7cc71c3f69714a57448db9a6ed7e0d1 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 18 Apr 2023 11:35:26 -0400
Subject: [PATCH 335/602] rm samedata

---
 qutip/core/data/base.pxd               |  3 --
 qutip/core/data/base.pyx               |  4 ---
 qutip/core/data/convert.pyx            |  6 +---
 qutip/core/data/dispatch.pyx           | 40 ++++++--------------------
 qutip/tests/core/data/test_dispatch.py | 18 ------------
 5 files changed, 10 insertions(+), 61 deletions(-)

diff --git a/qutip/core/data/base.pxd b/qutip/core/data/base.pxd
index 1f03cff362..f34a80ff24 100644
--- a/qutip/core/data/base.pxd
+++ b/qutip/core/data/base.pxd
@@ -15,6 +15,3 @@ cdef class Data:
     cpdef Data conj(self)
     cpdef Data transpose(self)
     cpdef Data copy(self)
-
-cdef class SameData(Data):
-    pass
diff --git a/qutip/core/data/base.pyx b/qutip/core/data/base.pyx
index 79c6242bbf..a463bf3834 100644
--- a/qutip/core/data/base.pyx
+++ b/qutip/core/data/base.pyx
@@ -85,9 +85,5 @@ cdef class Data:
         return False
 
 
-cdef class SameData(Data):
-    pass
-
-
 class EfficiencyWarning(Warning):
     pass
diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index b53888899f..3d14e563da 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -19,7 +19,7 @@ import numbers
 import numpy as np
 from scipy.sparse import dok_matrix, csgraph
 cimport cython
-from qutip.core.data.base cimport Data, SameData
+from qutip.core.data.base cimport Data
 
 __all__ = ['to', 'create']
 
@@ -270,12 +270,8 @@ cdef class _to:
         for dtype in self.dtypes:
             self.weight[(dtype, Data)] = 1.
             self.weight[(Data, dtype)] = self.anydataweight
-            # self.weight[(dtype, SameData)] = self.anydataweight
-            # self.weight[(SameData, dtype)] = 1.
             self._convert[(dtype, Data)] = _partial_converter(self, dtype)
             self._convert[(Data, dtype)] = dummyconverter
-            # self._convert[(dtype, SameData)] = dummyconverter
-            # self._convert[(SameData, dtype)] = dummyconverter
         for dispatcher in self.dispatchers:
             dispatcher.rebuild_lookup()
 
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 44da5b5588..7f0ba6ad80 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -11,7 +11,7 @@ from .convert import to as _to
 cimport cython
 from libc cimport math
 from libcpp cimport bool
-from qutip.core.data.base cimport Data, SameData
+from qutip.core.data.base cimport Data
 
 __all__ = ['Dispatcher']
 
@@ -23,8 +23,7 @@ cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out
     `(to_type, from_type): real`; it should almost certainly be
     `data.to.weight`.
 
-    Specialisations that support any types input should use ``Data`` if types
-    can be mixed, or ``SameData``, when they cannot be mixed.
+    Specialisations that support any types input should use ``Data``.
     """
     cdef double weight = 0.0
     cdef Py_ssize_t i, n=len(froms)
@@ -276,7 +275,7 @@ cdef class Dispatcher:
                 if (
                     not _defer
                     and arg[i] not in _to.dtypes
-                    and arg[i] not in [Data, SameData]
+                    and arg[i] is not Data
                 ):
                     raise ValueError(str(arg[i]) + " is not a known data type")
             if not callable(arg[self._n_dispatch]):
@@ -299,37 +298,16 @@ cdef class Dispatcher:
         function = None
         n_dispatch = len(in_types)
         for out_types, out_function in self._specialisations.items():
-            if SameData in out_types:
-                # Extra loop over all possible ``SameData``
-                for dtype in self._dtypes:
-                    curr_types = tuple(
-                        (type_ if type_ is not SameData else dtype)
-                        for type_ in out_types
-                    )
-                cur = _conversion_weight(
-                    in_types, curr_types[:n_dispatch], _to.weight, out=output)
-                # Extra cost to use ``SameData`` over real specialisations
-                # It ensure (SameData, SameData) lose to (Dense, Dense), etc.
-                cur += 0.001
-                if cur < weight:
-                    weight = cur
-                    types = curr_types
-                    function = out_function
-            else:
-                cur = _conversion_weight(
-                    in_types, out_types[:n_dispatch], _to.weight, out=output)
-                if cur < weight:
-                    weight = cur
-                    types = out_types
-                    function = out_function
+            cur = _conversion_weight(
+                in_types, out_types[:n_dispatch], _to.weight, out=output)
+            if cur < weight:
+                weight = cur
+                types = out_types
+                function = out_function
 
         if cur == math.INFINITY:
             raise ValueError("No valid specialisations found")
 
-        print(in_types)
-        print(types)
-        print(weight, output, types[-1])
-        print(output and types[-1] is Data)
         if weight <= 0.01 and not (output and types[-1] is Data):
             self._lookup[in_types] = function
         else:
diff --git a/qutip/tests/core/data/test_dispatch.py b/qutip/tests/core/data/test_dispatch.py
index 6d582f28db..e45f351ff1 100644
--- a/qutip/tests/core/data/test_dispatch.py
+++ b/qutip/tests/core/data/test_dispatch.py
@@ -2,13 +2,11 @@
 import itertools
 import qutip
 from qutip.core.data.dispatch import Dispatcher, _constructed_specialisation
-from qutip.core.data.base import SameData
 import qutip.core.data as _data
 
 
 class pseudo_dipatched:
     def __init__(self, types, output):
-        self.use_samedata = SameData in types
         if output:
             self.output = types[-1]
             self.inputs = types[:-1]
@@ -17,22 +15,13 @@ def __init__(self, types, output):
             self.inputs = types
 
     def __call__(self, *args, **kwargs):
-        print(args)
         assert len(args) == len(self.inputs)
         assert not kwargs
-        samedata = None
         for got, expected in zip(args, self.inputs):
-            if expected is SameData and samedata is None:
-                samedata = type(got)
-                expected = type(got)
-            elif expected is SameData:
-                expected = samedata
             assert isinstance(got, expected)
 
         if not self.output:
             return
-        elif self.output is SameData:
-            return _data.zeros[samedata](1,1)
         elif self.output is _data.Data:
             return _data.zeros(1,1)
         else:
@@ -55,23 +44,16 @@ def _test_name(arg):
     ((_data.Data, _data.Data), True),
     ((_data.Data, _data.Dense), True),
     ((_data.Dense, _data.Data), True),
-    ((SameData, SameData), True),
     ((_data.Dense, _data.Dense), False),
     ((_data.Dense, _data.CSR), False),
     ((_data.Data, _data.Data), False),
     ((_data.Data, _data.Dense), False),
     ((_data.Dense, _data.Data), False),
-    ((SameData, SameData), False),
     ((_data.Dense, _data.Dense, _data.Dense), True),
     ((_data.Dense, _data.CSR, _data.CSR), True),
     ((_data.Data, _data.Data, _data.Data), True),
     ((_data.Data, _data.Dense, _data.Dense), True),
     ((_data.Dense, _data.Data, _data.Data), True),
-    ((SameData, SameData, SameData), True),
-    ((SameData, SameData, _data.Dense), True),
-    ((SameData, SameData, _data.Data), True),
-    ((SameData, _data.Dense, SameData), True),
-    ((SameData, _data.Data, SameData), True),
 ], ids=_test_name)
 def test_build_full(specialisation, output):
     """

From 2833fdc18d8a96eeb3b38c1311633acba725b8df Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 18 Apr 2023 16:37:35 -0400
Subject: [PATCH 336/602] kron_transpose

---
 qutip/core/_brtools.pyx     |  4 ++--
 qutip/core/data/kron.pyx    | 36 ++++++++++++++++++++++++++++++++++--
 qutip/core/superoperator.py | 10 +++++-----
 3 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
index a7e379c964..14710ffea8 100644
--- a/qutip/core/_brtools.pyx
+++ b/qutip/core/_brtools.pyx
@@ -250,10 +250,10 @@ cdef class _EigenBasisTransform:
         return self._evecs_inv
 
     cdef Data _S_converter(self, double t):
-        return _data.kron(self.evecs(t).transpose(), self._inv(t))
+        return _data.kron_transpose(self.evecs(t), self._inv(t))
 
     cdef Data _S_converter_inverse(self, double t):
-        return _data.kron(self._inv(t).transpose(), self.evecs(t))
+        return _data.kron_transpose(self._inv(t), self.evecs(t))
 
     cpdef Data to_eigbasis(self, double t, Data fock):
         """
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index 262d74add7..0890c02d4b 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -3,14 +3,16 @@
 
 cimport cython
 
-from qutip.core.data.base cimport idxint
+from qutip.core.data.base cimport idxint, Data
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
 from qutip.core.data cimport csr
+from .adjoint import transpose
 import numpy
 
 __all__ = [
-    'kron', 'kron_csr', 'kron_dense'
+    'kron', 'kron_csr', 'kron_dense',
+    'kron_transpose', 'kron_transpose_dense', 'kron_transpose_data',
 ]
 
 
@@ -88,4 +90,34 @@ kron.add_specialisations([
     (Dense, Dense, Dense, kron_dense),
 ], _defer=True)
 
+
+cpdef Data kron_transpose_data(Data left, Data right):
+    return kron(transpose(left), right)
+
+
+cpdef Dense kron_transpose_dense(Dense left, Dense right):
+    return Dense(numpy.kron(left.as_ndarray().T, right.as_ndarray()), copy=False)
+
+
+kron_transpose = _Dispatcher(
+    _inspect.Signature([
+        _inspect.Parameter('left', _inspect.Parameter.POSITIONAL_ONLY),
+        _inspect.Parameter('right', _inspect.Parameter.POSITIONAL_ONLY),
+    ]),
+    name='kron_transpose',
+    module=__name__,
+    inputs=('left', 'right'),
+    out=True,
+)
+kron_transpose.__doc__ =\
+    """
+    Compute the Kronecker product of two matrices with transposing the first
+    one.  This is used to represent superoperator.
+    """
+kron_transpose.add_specialisations([
+    (Data, Data, Data, kron_transpose_data),
+    (Dense, Dense, Dense, kron_transpose_dense),
+], _defer=True)
+
+
 del _inspect, _Dispatcher
diff --git a/qutip/core/superoperator.py b/qutip/core/superoperator.py
index 328862b8f3..2486d0c1b2 100644
--- a/qutip/core/superoperator.py
+++ b/qutip/core/superoperator.py
@@ -100,7 +100,7 @@ def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
     spI = _data.identity(op_shape[0], dtype=type(H.data))
 
     data = _data.mul(_data.kron(spI, H.data), -1j)
-    data = _data.add(data, _data.kron(H.data.transpose(), spI), scale=1j)
+    data = _data.add(data, _data.kron_transpose(H.data, spI), scale=1j)
 
     for c_op, chi_ in zip(c_ops, chi):
         c = c_op.data
@@ -108,7 +108,7 @@ def liouvillian(H=None, c_ops=None, data_only=False, chi=None):
         cdc = _data.matmul(cd, c)
         data = _data.add(data, _data.kron(c.conj(), c), np.exp(1j*chi_))
         data = _data.add(data, _data.kron(spI, cdc), -0.5)
-        data = _data.add(data, _data.kron(cdc.transpose(), spI), -0.5)
+        data = _data.add(data, _data.kron_transpose(cdc, spI), -0.5)
 
     if data_only:
         return data
@@ -310,8 +310,8 @@ def spost(A):
     """
     if not A.isoper:
         raise TypeError('Input is not a quantum operator')
-    data = _data.kron(A.data.transpose(),
-                      _data.identity(A.shape[0], dtype=type(A.data)))
+    Id = _data.identity(A.shape[0], dtype=type(A.data))
+    data = _data.kron_transpose(A.data, Id)
     return Qobj(data,
                 dims=[A.dims, A.dims],
                 type='super',
@@ -379,7 +379,7 @@ def sprepost(A, B):
              _drop_projected_dims(B.dims[1])],
             [_drop_projected_dims(A.dims[1]),
              _drop_projected_dims(B.dims[0])]]
-    return Qobj(_data.kron(B.data.transpose(), A.data),
+    return Qobj(_data.kron_transpose(B.data, A.data),
                 dims=dims,
                 type='super',
                 superrep='super',

From aeeccbd16da4986354c35edce586d5d5d0c455c1 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 18 Apr 2023 19:21:10 -0400
Subject: [PATCH 337/602] Data varians of complex function

---
 qutip/core/data/expect.pyx                | 37 +++++++++++++++--
 qutip/core/data/inner.pyx                 | 48 ++++++++++++++++++++++-
 qutip/core/data/trace.pyx                 |  8 ++++
 qutip/tests/core/data/test_expect.py      |  2 +
 qutip/tests/core/data/test_mathematics.py | 18 +++++++++
 5 files changed, 108 insertions(+), 5 deletions(-)

diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 1ab6c9ce2f..8e887dbbc2 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -13,11 +13,14 @@ cdef extern from "<complex>" namespace "std" nogil:
 
 from qutip.core.data.base cimport idxint, Data
 from qutip.core.data cimport csr, CSR, Dense
+from .inner import inner
+from .trace import trace, trace_oper_ket
+from .matmul import matmul
 
 __all__ = [
-    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
+    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense', 'expect_data',
     'expect_super', 'expect_super_csr',
-    'expect_super_csr_dense', 'expect_super_dense',
+    'expect_super_csr_dense', 'expect_super_dense', 'expect_super_data',
 ]
 
 cdef void _check_shape_ket(Data op, Data state) nogil except *:
@@ -32,7 +35,7 @@ cdef void _check_shape_ket(Data op, Data state) nogil except *:
 cdef void _check_shape_dm(Data op, Data state) nogil except *:
     if (
         op.shape[1] != state.shape[0]  # Matrix multiplication
-        or state.shape[0] != state.shape[1]  # State is square 
+        or state.shape[0] != state.shape[1]  # State is square
         or op.shape[0] != op.shape[1]  # Op is square
     ):
         raise ValueError("incorrect input shapes "
@@ -249,6 +252,32 @@ cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
     return out
 
 
+def expect_data(Data op, Data state):
+    """
+    Get the expectation value of the operator `op` over the state `state`.  The
+    state can be either a ket or a density matrix.
+
+    The expectation of a state is defined as the operation:
+        state.adjoint() @ op @ state
+    and of a density matrix:
+        tr(op @ state)
+    """
+    if state.shape[1] == 1:
+        _check_shape_ket(op, state)
+        return inner(state, matmul(op, state))
+    _check_shape_dm(op, state)
+    return trace(matmul(op, state))
+
+
+def expect_super_data(Data op, Data state):
+    """
+    Perform the operation `tr(op @ state)` where `op` is supplied as a
+    superoperator, and `state` is a column-stacked operator.
+    """
+    _check_shape_super(op, state)
+    return trace_oper_ket(matmul(op, state))
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -276,6 +305,7 @@ expect.add_specialisations([
     (CSR, CSR, expect_csr),
     (CSR, Dense, expect_csr_dense),
     (Dense, Dense, expect_dense),
+    (Data, Data, expect_data),
 ], _defer=True)
 
 expect_super = _Dispatcher(
@@ -298,6 +328,7 @@ expect_super.add_specialisations([
     (CSR, CSR, expect_super_csr),
     (CSR, Dense, expect_super_csr_dense),
     (Dense, Dense, expect_super_dense),
+    (Data, Data, expect_super_data),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index 14b35a403c..f4712e7327 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -9,10 +9,13 @@ from qutip.core.data cimport csr, dense
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.matmul cimport matmul_dense
+from .matmul import matmul
+from .trace import trace
+from .adjoint import adjoint
 
 __all__ = [
-    'inner', 'inner_csr', 'inner_dense',
-    'inner_op', 'inner_op_csr', 'inner_op_dense',
+    'inner', 'inner_csr', 'inner_dense', 'inner_data',
+    'inner_op', 'inner_op_csr', 'inner_op_dense', 'inner_op_data',
 ]
 
 
@@ -188,6 +191,45 @@ cpdef double complex inner_op_dense(Dense left, Dense op, Dense right,
     return inner_dense(left, matmul_dense(op, right), scalar_is_ket)
 
 
+cpdef inner_data(Data left, Data right, bint scalar_is_ket=False):
+    """
+    Compute the complex inner product <left|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner(left, right)
+    if left.shape[0] == left.shape[1] == right.shape[1] == 1:
+        return (
+            trace(left).conjugate() * trace(right) if scalar_is_ket
+            else trace(left) * trace(right)
+        )
+
+    if left.shape[0] != 1:
+        left = adjoint(left)
+    # We use trace so we don't force convertion to complex.
+    return trace(matmul(left, right))
+
+
+cpdef inner_op_data(Data left, Data op, Data right, bint scalar_is_ket=False):
+    """
+    Compute the complex inner product <left|op|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner_op(left, op, right)
+    return inner_data(left, matmul(op, right), scalar_is_ket)
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -232,6 +274,7 @@ inner.__doc__ =\
 inner.add_specialisations([
     (CSR, CSR, inner_csr),
     (Dense, Dense, inner_dense),
+    (Data, Data, inner_data),
 ], _defer=True)
 
 inner_op = _Dispatcher(
@@ -281,6 +324,7 @@ inner_op.__doc__ =\
 inner_op.add_specialisations([
     (CSR, CSR, CSR, inner_op_csr),
     (Dense, Dense, Dense, inner_op_dense),
+    (Data, Data, Data, inner_op_data),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index d8f5cbf88b..203c64294e 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -6,10 +6,12 @@ from libc.math cimport sqrt
 
 from qutip.core.data cimport Data, CSR, Dense
 from qutip.core.data cimport base
+from .reshape import column_unstack
 
 __all__ = [
     'trace', 'trace_csr', 'trace_dense',
     'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
+    'trace_oper_ket_data',
 ]
 
 
@@ -70,6 +72,11 @@ cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
         trace += matrix.data[ptr * stride]
     return trace
 
+cpdef trace_oper_ket_data(Data matrix):
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    return trace(column_unstack(matrix, N))
+
 
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
@@ -104,6 +111,7 @@ trace_oper_ket.__doc__ =\
 trace_oper_ket.add_specialisations([
     (CSR, trace_oper_ket_csr),
     (Dense, trace_oper_ket_dense),
+    (Data, trace_oper_ket_data),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
index 256a703a89..f063645851 100644
--- a/qutip/tests/core/data/test_expect.py
+++ b/qutip/tests/core/data/test_expect.py
@@ -39,6 +39,7 @@ def op_numpy(self, op, state):
         pytest.param(data.expect_csr, CSR, CSR, complex),
         pytest.param(data.expect_dense, Dense, Dense, complex),
         pytest.param(data.expect_csr_dense, CSR, Dense, complex),
+        pytest.param(data.expect_data, Dense, CSR, complex),
     ]
 
 
@@ -64,4 +65,5 @@ def op_numpy(self, op, state):
         pytest.param(data.expect_super_dense, Dense, Dense, complex),
         pytest.param(data.expect_super_csr, CSR, CSR, complex),
         pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
+        pytest.param(data.expect_super_data, CSR, Dense, complex),
     ]
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 459ab0d467..cfa546dbe7 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -615,6 +615,8 @@ def op_numpy(self, left, right, scalar_is_ket=False):
     specialisations = [
         pytest.param(data.inner_csr, CSR, CSR, complex),
         pytest.param(data.inner_dense, Dense, Dense, complex),
+        pytest.param(data.inner_data, Dense, Dense, complex),
+        pytest.param(data.inner_data, CSR, CSR, complex),
     ]
 
     def generate_scalar_is_ket(self, metafunc):
@@ -685,6 +687,7 @@ def op_numpy(self, left, mid, right, scalar_is_ket=False):
     specialisations = [
         pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
         pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
+        pytest.param(data.inner_op_data, Dense, CSR, Dense, complex),
     ]
 
     def generate_scalar_is_ket(self, metafunc):
@@ -735,6 +738,19 @@ def op_numpy(self, left, right):
     ]
 
 
+class TestKronT(BinaryOpMixin):
+    def op_numpy(self, left, right):
+        return np.kron(left.T, right)
+
+    # Keep the dimension low because kron can get very expensive.
+    shapes = shapes_binary_unrestricted(dim=5)
+    bad_shapes = shapes_binary_bad_unrestricted(dim=5)
+    specialisations = [
+        pytest.param(data.kron_transpose_data, CSR, CSR, CSR),
+        pytest.param(data.kron_transpose_dense, Dense, Dense, Dense),
+    ]
+
+
 class TestMatmul(BinaryOpMixin):
     def op_numpy(self, left, right):
         return np.matmul(left, right)
@@ -821,6 +837,8 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.trace_oper_ket_csr, CSR, complex),
         pytest.param(data.trace_oper_ket_dense, Dense, complex),
+        pytest.param(data.trace_oper_ket_data, CSR, complex),
+        pytest.param(data.trace_oper_ket_data, Dense, complex),
     ]
 
 

From 75a46a8e97be642a4b6cbfb0ab189c66651be3ec Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 19 Apr 2023 15:23:26 +0900
Subject: [PATCH 338/602] Added more constant coefficient tests

---
 qutip/tests/core/test_coefficient.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 0906719225..9738181d39 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -7,7 +7,7 @@
 from qutip.core.coefficient import (coefficient, norm, conj, const,
                                     CompilationOptions, Coefficient,
                                     clean_compiled_coefficient
-                                   )
+                                    )
 
 # Ensure the latest version is tested
 clean_compiled_coefficient(True)
@@ -165,7 +165,8 @@ def test_CoeffCallArguments(base, tol):
     pytest.param("arraylog", id="logarray"),
     pytest.param("string", id="string"),
     pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
+    pytest.param("steparraylog", id="steparraylog"),
+    pytest.param("const", id="constant"),
 ])
 @pytest.mark.parametrize(['transform', 'expected'], [
     pytest.param(norm, lambda val: np.abs(val)**2, id="norm"),
@@ -187,7 +188,8 @@ def test_ConstantCoefficient():
     pytest.param("arraylog", id="logarray"),
     pytest.param("string", id="string"),
     pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
+    pytest.param("steparraylog", id="steparraylog"),
+    pytest.param("const", id="constant"),
 ])
 @pytest.mark.parametrize(['style_right'], [
     pytest.param("func", id="func"),
@@ -195,7 +197,8 @@ def test_ConstantCoefficient():
     pytest.param("arraylog", id="logarray"),
     pytest.param("string", id="string"),
     pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
+    pytest.param("steparraylog", id="steparraylog"),
+    pytest.param("const", id="constant"),
 ])
 @pytest.mark.parametrize(['oper'], [
     pytest.param(lambda a, b: a+b, id="sum"),
@@ -330,7 +333,8 @@ def test_Coeffpickle(style, transform):
     pytest.param("arraylog", id="logarray"),
     pytest.param("string", id="string"),
     pytest.param("steparray", id="steparray"),
-    pytest.param("steparraylog", id="steparraylog")
+    pytest.param("steparraylog", id="steparraylog"),
+    pytest.param("const", id="constant"),
 ])
 @pytest.mark.parametrize(['transform'], [
     pytest.param(_pass, id="single"),

From e2e780d783ef1bce08391b299f188bcf5af76413 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 19 Apr 2023 16:29:20 +0900
Subject: [PATCH 339/602] Extended time interval used for nm_mcsolve test in
 order to include negative rates. Note that the new ntraj and tolerance are
 the same like in mcsolve tests.

---
 qutip/tests/solver/test_nm_mcsolve.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index 59fc07be66..a478f79afc 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -12,7 +12,7 @@ def test_rough_agreement_with_mesolve_for_negative_rates():
     A rough test that nm_mcsolve agress with mesolve in the
     presence of negative rates.
     """
-    times = np.linspace(0, 0.05, 51)
+    times = np.linspace(0, 0.25, 51)
     psi0 = qutip.basis(2, 1)
     a0 = qutip.destroy(2)
     H = a0.dag() * a0
@@ -38,7 +38,7 @@ def test_rough_agreement_with_mesolve_for_negative_rates():
     ]
     mc_result = nm_mcsolve(
         H, psi0, times, ops_and_rates,
-        args=args, e_ops=e_ops, ntraj=2500,
+        args=args, e_ops=e_ops, ntraj=2000,
         options={"rtol": 1e-8},
         seeds=0,
     )
@@ -53,12 +53,12 @@ def test_rough_agreement_with_mesolve_for_negative_rates():
         args=args, e_ops=e_ops,
     )
 
-    np.testing.assert_allclose(mc_result.trace, [1.] * len(times))
+    np.testing.assert_allclose(mc_result.trace, [1.] * len(times), rtol=0.25)
     np.testing.assert_allclose(
-        me_result.expect[0], mc_result.expect[0], rtol=0.02,
+        me_result.expect[0], mc_result.expect[0], rtol=0.25,
     )
     np.testing.assert_allclose(
-        me_result.expect[1], mc_result.expect[1], rtol=0.1,
+        me_result.expect[1], mc_result.expect[1], rtol=0.25,
     )
 
 
@@ -127,6 +127,7 @@ class TestNoCollapse(StatesAndExpectOutputCase):
     Test that nm_mcsolve correctly solves the system when there is a constant
     Hamiltonian and no collapses.
     """
+
     def pytest_generate_tests(self, metafunc):
         tol = 1e-8
         expect = (
@@ -182,6 +183,7 @@ class TestConstantCollapse(StatesAndExpectOutputCase):
     Test that nm_mcsolve correctly solves the system when the
     collapse rates are constant.
     """
+
     def pytest_generate_tests(self, metafunc):
         tol = 0.25
         rate = 0.2
@@ -210,6 +212,7 @@ class TestTimeDependentCollapse(StatesAndExpectOutputCase):
     Test that nm_mcsolve correctly solves the system when the
     collapse rates are time-dependent.
     """
+
     def pytest_generate_tests(self, metafunc):
         tol = 0.25
         coupling = 0.2

From 66a48a1ccc05315111289f616131d4b4eb0e9833 Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Wed, 19 Apr 2023 17:06:04 +0900
Subject: [PATCH 340/602] Added changelog

---
 doc/changes/2070.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2070.feature

diff --git a/doc/changes/2070.feature b/doc/changes/2070.feature
new file mode 100644
index 0000000000..5a97836272
--- /dev/null
+++ b/doc/changes/2070.feature
@@ -0,0 +1 @@
+Added nm_mcsolve to provide support for Monte-Carlo simulations of master equations with possibly negative rates. The method implemented here is described in arXiv:2209.08958 [quant-ph].

From 8cee3c263de864fd06d67b3727b3c85bde9d8dd9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 19 Apr 2023 10:59:46 -0400
Subject: [PATCH 341/602] Fix solver namespace

---
 qutip/solver/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/__init__.py b/qutip/solver/__init__.py
index db39f53e86..d7491c1e3c 100644
--- a/qutip/solver/__init__.py
+++ b/qutip/solver/__init__.py
@@ -1,6 +1,6 @@
 from .result import *
 from .options import *
-import qutip.solver.integrator
+import qutip.solver.integrator as integrator
 from .integrator import IntegratorException
 from .sesolve import *
 from .mesolve import *
@@ -16,5 +16,5 @@
 from .brmesolve import *
 from .krylovsolve import *
 from .parallel import *
-import qutip.solver.sode
+import qutip.solver.sode as sode
 from .stochastic import *

From 357673b07593f0ce675d1851adde63c240843399 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 19 Apr 2023 12:57:28 -0400
Subject: [PATCH 342/602] Fix merge conflict

---
 qutip/core/data/constant.py  | 4 ----
 qutip/core/data/dispatch.pyx | 2 --
 2 files changed, 6 deletions(-)

diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 7e94594a46..4524f08bb1 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -78,8 +78,6 @@ def zeros_like_data(data, /):
     """
     Create an zeros matrix of the same type and shape.
     """
-    if type(data) is Dense:
-        return dense.zeros(*data.shape, fortran=data.fortran)
     return zeros[type(data)](*data.shape)
 
 
@@ -96,8 +94,6 @@ def identity_like_data(data, /):
     """
     if not data.shape[0] == data.shape[1]:
         raise ValueError("Can't create and identity like a non square matrix.")
-    if type(data) is Dense:
-        return dense.identity(data.shape[0], fortran=data.fortran)
     return identity[type(data)](data.shape[0])
 
 
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 7f0ba6ad80..10132877fc 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -290,7 +290,6 @@ cdef class Dispatcher:
         # bottle-neck in real code, we stick with the simple algorithm.
         cdef double weight, cur
         cdef tuple types, out_types, displayed_type
-        cdef type dtype
         cdef object function
         cdef int n_dispatch
         weight = math.INFINITY
@@ -325,7 +324,6 @@ cdef class Dispatcher:
                 _constructed_specialisation(function, self, displayed_type,
                                             converters, output)
 
-
     def rebuild_lookup(self):
         """
         Manually trigger a rebuild of the lookup table for this dispatcher.

From 0bcd59f122eaea7c4cb077521c8becb01490aad9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 19 Apr 2023 15:40:02 -0400
Subject: [PATCH 343/602] Add towncrier

---
 doc/changes/2157.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2157.feature

diff --git a/doc/changes/2157.feature b/doc/changes/2157.feature
new file mode 100644
index 0000000000..dc5af0dc4f
--- /dev/null
+++ b/doc/changes/2157.feature
@@ -0,0 +1 @@
+Add capacity to dispatch on ``Data``

From 25586837eb2c77f60526a40264b48563ae947f06 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 20 Apr 2023 13:38:00 -0400
Subject: [PATCH 344/602] Move rcsolve to legacy

---
 qutip/legacy/__init__.py           |  0
 qutip/{solve => legacy}/rcsolve.py | 35 ++++++++++++------------------
 2 files changed, 14 insertions(+), 21 deletions(-)
 create mode 100644 qutip/legacy/__init__.py
 rename qutip/{solve => legacy}/rcsolve.py (77%)

diff --git a/qutip/legacy/__init__.py b/qutip/legacy/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/qutip/solve/rcsolve.py b/qutip/legacy/rcsolve.py
similarity index 77%
rename from qutip/solve/rcsolve.py
rename to qutip/legacy/rcsolve.py
index b357bc6e02..bc52ce04d9 100644
--- a/qutip/solve/rcsolve.py
+++ b/qutip/legacy/rcsolve.py
@@ -56,12 +56,15 @@ def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
     output: Result
         System evolution.
     """
+    if psi0.isket:
+        psi0 = psi0.proj()
+
     if options is None:
         options = {}
 
     dot_energy, dot_state = Hsys.eigenstates(sparse=sparse)
     deltaE = dot_energy[1] - dot_energy[0]
-    if (w_th < deltaE/2):
+    if (w_th < deltaE / 2):
         warnings.warn("Given w_th might not provide accurate results")
     gamma = deltaE / (2 * np.pi * wc)
     wa = 2 * np.pi * gamma * wc  # reaction coordinate frequency
@@ -69,11 +72,8 @@ def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
     nb = (1 / (np.exp(wa/w_th) - 1))
 
     # Reaction coordinate hamiltonian/operators
-
-    dimensions = Q.dims
-    a = tensor(destroy(N), qeye(dimensions[1]))
-    unit = tensor(qeye(N), qeye(dimensions[1]))
-    Nmax = N * dimensions[1][0]
+    a = tensor(destroy(N), qeye_like(Hsys))
+    unit = tensor(qeye(N), qeye_like(Hsys))
     Q_exp = tensor(qeye(N), Q)
     Hsys_exp = tensor(qeye(N), Hsys)
     e_ops_exp = [tensor(qeye(N), kk) for kk in e_ops]
@@ -86,29 +86,22 @@ def rcsolve(Hsys, psi0, tlist, e_ops, Q, wc, alpha, N, w_th, sparse=False,
     # interaction
     H1 = (g * (a.dag() + a) * Q_exp)
     H = H0 + H1
-    L = 0
-    PsipreEta = 0
-    PsipreX = 0
+    PsipreEta = qzero_like(H)
+    PsipreX = qzero_like(H)
 
     all_energy, all_state = H.eigenstates(sparse=sparse)
-    Apre = spre((a + a.dag()))
-    Apost = spost(a + a.dag())
+    Nmax = len(all_energy)
     for j in range(Nmax):
         for k in range(Nmax):
             A = xa.matrix_element(all_state[j].dag(), all_state[k])
             delE = (all_energy[j] - all_energy[k])
             if abs(A) > 0.0:
                 if abs(delE) > 0.0:
-                    X = (0.5 * np.pi * gamma*(all_energy[j] - all_energy[k])
-                         * (np.cosh((all_energy[j] - all_energy[k]) /
-                            (2 * w_th))
-                         / (np.sinh((all_energy[j] - all_energy[k]) /
-                            (2 * w_th)))) * A)
-                    eta = (0.5 * np.pi * gamma *
-                           (all_energy[j] - all_energy[k]) * A)
-                    PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()
-                    PsipreEta = PsipreEta + (eta * all_state[j]
-                                             * all_state[k].dag())
+                    eta = 0.5 * np.pi * gamma * delE * A
+                    X = eta / np.tanh(delE / (2 * w_th))
+                    proj = all_state[j] * all_state[k].dag()
+                    PsipreX = PsipreX + X * proj
+                    PsipreEta = PsipreEta + eta * proj
                 else:
                     X = 0.5 * np.pi * gamma * A * 2 * w_th
                     PsipreX = PsipreX + X * all_state[j] * all_state[k].dag()

From c552d7c020919361a8f6029e676a7f5c343b38cf Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 20 Apr 2023 14:00:14 -0400
Subject: [PATCH 345/602] Some cleaning in rcsolve

---
 qutip/legacy/rcsolve.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/legacy/rcsolve.py b/qutip/legacy/rcsolve.py
index bc52ce04d9..b171946ba2 100644
--- a/qutip/legacy/rcsolve.py
+++ b/qutip/legacy/rcsolve.py
@@ -14,8 +14,8 @@
 from numpy import matrix
 from numpy import linalg
 from .. import (
-    spre, spost, sprepost, thermal_dm, tensor, identity, destroy, sigmax,
-    sigmaz, basis, qeye, mesolve
+    spre, spost, sprepost, thermal_dm, tensor, destroy,
+    qeye, mesolve, qeye_like, qzero_like
 )
 
 

From f2ac12c1235d7601e70ca99ea5c4f600f980c643 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 20 Apr 2023 17:28:03 -0400
Subject: [PATCH 346/602] Start Diag data layer

---
 qutip/core/data/diag.pxd |  30 +++++
 qutip/core/data/diag.pyx | 233 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 263 insertions(+)
 create mode 100644 qutip/core/data/diag.pxd
 create mode 100644 qutip/core/data/diag.pyx

diff --git a/qutip/core/data/diag.pxd b/qutip/core/data/diag.pxd
new file mode 100644
index 0000000000..f8689c8a53
--- /dev/null
+++ b/qutip/core/data/diag.pxd
@@ -0,0 +1,30 @@
+#cython: language_level=3
+
+# from cpython cimport mem
+# from libcpp.algorithm cimport sort
+# from libc.math cimport fabs
+
+# cdef extern from *:
+#     void *PyMem_Calloc(size_t n, size_t elsize)
+
+# import numpy as np
+# cimport numpy as cnp
+
+from qutip.core.data cimport base
+# from qutip.core.data.dense cimport Dense
+
+cdef class Diag(base.Data):
+    cdef double complex *data
+    cdef base.idxint *col_index
+    cdef base.idxint *row_index
+    cdef size_t num_diag
+    cdef size_t size
+    cdef object _scipy
+    cdef bint _deallocate
+    cpdef Diag copy(Diag self)
+    cpdef object as_scipy(Diag self, bint full=*)
+    cpdef Diag sort_indices(Diag self)
+    cpdef double complex trace(Diag self)
+    cpdef Diag adjoint(Diag self)
+    cpdef Diag conj(Diag self)
+    cpdef Diag transpose(Diag self)
diff --git a/qutip/core/data/diag.pyx b/qutip/core/data/diag.pyx
new file mode 100644
index 0000000000..ee9c0d33a8
--- /dev/null
+++ b/qutip/core/data/diag.pyx
@@ -0,0 +1,233 @@
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+
+from libcpp cimport bool
+from libcpp.algorithm cimport sort
+
+cimport cython
+
+from cpython cimport mem
+
+import numbers
+import warnings
+
+import numpy as np
+cimport numpy as cnp
+import scipy.sparse
+from scipy.sparse import dia_array as scipy_dia_array
+try:
+    from scipy.sparse.data import _data_matrix as scipy_data_matrix
+except ImportError:
+    # The file data was renamed to _data from scipy 1.8.0
+    from scipy.sparse._data import _data_matrix as scipy_data_matrix
+from scipy.linalg cimport cython_blas as blas
+
+from qutip.core.data cimport base, Dense
+from qutip.core.data.adjoint cimport adjoint_diag, transpose_diag, conj_diag
+from qutip.core.data.trace cimport trace_diag
+from qutip.core.data.tidyup cimport tidyup_diag
+from .base import idxint_dtype
+from qutip.settings import settings
+
+cnp.import_array()
+
+cdef extern from *:
+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+    void *PyDataMem_NEW(size_t size)
+    void PyDataMem_FREE(void *ptr)
+
+__all__ = ['Diag']
+
+cdef int _ONE = 1
+
+cdef object _dia_matrix(data, offsets, shape):
+    """
+    Factory method of scipy diag_matrix: we skip all the index type-checking
+    because this takes tens of microseconds, and we already know we're in
+    a sensible format.
+    """
+    cdef object out = scipy_dia_array.__new__(scipy_diag_matrix)
+    # `_data_matrix` is the first object in the inheritance chain which
+    # doesn't have a really slow __init__.
+    scipy_data_matrix.__init__(out)
+    out.data = data
+    out.offsets = offsets
+    out._shape = shape
+    return out
+
+
+cdef class Diag(base.Data):
+    def __cinit__(self, *args, **kwargs):
+        self._deallocate = True
+
+    def __init__(self, arg=None, shape=None, bint=True, bint=tidyup=False):
+        cdef size_t ptr
+        cdef base.idxint col
+        cdef object data, col_index, row_index
+
+        if isinstance(arg, scipy.sparse.spmatrix):
+            arg = arg.todia()
+            if shape is not None and shape != arg.shape:
+                raise ValueError("".join([
+                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
+                ]))
+            shape = arg.shape
+            arg = (arg.data, arg.offsets)
+        if not isinstance(arg, tuple):
+            raise TypeError("arg must be a scipy matrix or tuple")
+        if len(arg) != 2:
+            raise ValueError("arg must be a (data, offsets) tuple")
+        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
+        offsets = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
+
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
+        self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
+        self.num_diag = self.offsets.shape[0]
+        self.size = self.data.shape[0]
+
+        if shape is None:
+            warnings.warn("instantiating Diag matrix of unknown shape")
+            nrows = 0
+            ncols = 0
+            for i in self.num_diag:
+                if self.offsets[i] >= 0:
+                    j = 0
+                    while self.data[i, j] == 0.0:
+                        j += 1
+                    nrows = max(nrows, j)
+                    ncols = max(ncols, self.offsets[i] + j)
+                else:
+                    j = 0
+                    while self.data[i, self.size -j - 1] == 0.0:
+                        j += 1
+                    nrows = max(nrows, j - self.offsets[i])
+                    ncols = max(ncols, j)
+            self.shape = (nrows, ncols)
+        else:
+            if not isinstance(shape, tuple):
+                raise TypeError("shape must be a 2-tuple of positive ints")
+            if not (len(shape) == 2
+                    and isinstance(shape[0], int)
+                    and isinstance(shape[1], int)
+                    and shape[0] > 0
+                    and shape[1] > 0):
+                raise ValueError("shape must be a 2-tuple of positive ints")
+            self.shape = shape
+
+        self._scipy = _dia_matrix(data, col_index, row_index, self.shape)
+        if tidyup:
+            tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
+
+    def __reduce__(self):
+        return (fast_from_scipy, (self.as_scipy(),))
+
+    cpdef Diag copy(self):
+        """
+        Return a complete (deep) copy of this object.
+
+        If the type currently has a scipy backing, such as that produced by
+        `as_scipy`, this will not be copied.  The backing is a view onto our
+        data, and a straight copy of this view would be incorrect.  We do not
+        create a new view at copy time, since the user may only access this
+        through a creation method, and creating it ahead of time would incur an
+        unnecessary speed penalty for users who do not need it (including
+        low-level C code).
+        """
+        cdef Diag out = empty_like(self)
+        memcpy(out.data, self.data, self.num_diag * self.size * sizeof(double complex))
+        memcpy(out.col_index, self.offsets, self.num_diag*sizeof(base.idxint))
+
+        return out
+
+    cpdef object to_array(self):
+        """
+        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
+        is not a view onto the data, and changes to new array will not affect
+        the original data structure.
+        """
+        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
+        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
+        cdef double complex [:, ::1] buffer = out
+        cdef size_t diag, n
+        for diag in range(self.num_diag):
+            for n in range(max(self.offsets[diag], 0), min(self.size + self.offsets[diag], self.size)):
+                buffer[self.offsets[diag] + n, self.offsets[diag] + n] = self.data[diag, n]
+        return out
+
+    cpdef object as_scipy(self):
+        """
+        Get a view onto this object as a `scipy.sparse.dia_matrix`.  The
+        underlying data structures are exposed, such that modifications to the
+        `data`, `indices` and `indptr` buffers in the resulting object will
+        modify this object too.
+        """
+        # We store a reference to the scipy matrix not only for caching this
+        # relatively expensive method, but also because we transferred
+        # ownership of our data to the numpy arrays, and we can't allow them to
+        # be collected while we're alive.
+        if self._scipy is not None:
+            return self._scipy
+        cdef cnp.npy_intp num_diag = self.num_diag
+        cdef cnp.npy_intp size = self.size
+        data = cnp.PyArray_SimpleNewFromData(1, [num_diag, size],
+                                             cnp.NPY_COMPLEX128,
+                                             self.data)
+        offsets = cnp.PyArray_SimpleNewFromData(1, [num_diag],
+                                                base.idxint_DTYPE,
+                                                self.offsets)
+        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
+        PyArray_ENABLEFLAGS(offsets, cnp.NPY_ARRAY_OWNDATA)
+        self._deallocate = False
+        self._scipy = _dia_matrix(data, offsets, self.shape)
+        return self._scipy
+
+    cpdef double complex trace(self):
+        return trace_diag(self)
+
+    cpdef Diag adjoint(self):
+        return adjoint_diag(self)
+
+    cpdef Diag conj(self):
+        return conj_diag(self)
+
+    cpdef Diag transpose(self):
+        return transpose_diag(self)
+
+    def __repr__(self):
+        return "".join([
+            "Diag(shape=", str(self.shape), ", num_diag=", str(self.num_diag), ")",
+        ])
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __dealloc__(self):
+        # If we have a reference to a scipy type, then we've passed ownership
+        # of the data to numpy, so we let it handle refcounting and we don't
+        # need to deallocate anything ourselves.
+        if not self._deallocate:
+            return
+        if self.data != NULL:
+            PyDataMem_FREE(self.data)
+        if self.col_index != NULL:
+            PyDataMem_FREE(self.offsets)
+
+
+cpdef Diag fast_from_scipy(object sci):
+    """
+    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
+    checking on any of the inputs, and should consequently be considered very
+    unsafe.  This is primarily for use in the unpickling operation.
+    """
+    cdef Diag out = Diag.__new__(Diag)
+    out.shape = sci.shape
+    out._deallocate = False
+    out._scipy = sci
+    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
+    out.offsets = <base.idxint *> cnp.PyArray_GETPTR1(sci.offsets, 0)
+    out.num_diag  = sci.offsets.shape[0]
+    out.size = sci.data.shape[1]
+    return out

From 9cd4ecaa78dbc9ecb2a2ed6760cc875d1b06f6e1 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 24 Apr 2023 18:44:09 -0400
Subject: [PATCH 347/602] to from dense

---
 qutip/core/data/diag.pxd |   4 +-
 qutip/core/data/diag.pyx | 289 ++++++++++++++++++++++++++++++++++++---
 2 files changed, 272 insertions(+), 21 deletions(-)

diff --git a/qutip/core/data/diag.pxd b/qutip/core/data/diag.pxd
index f8689c8a53..e4b9428b57 100644
--- a/qutip/core/data/diag.pxd
+++ b/qutip/core/data/diag.pxd
@@ -15,10 +15,8 @@ from qutip.core.data cimport base
 
 cdef class Diag(base.Data):
     cdef double complex *data
-    cdef base.idxint *col_index
-    cdef base.idxint *row_index
+    cdef base.idxint *offsets
     cdef size_t num_diag
-    cdef size_t size
     cdef object _scipy
     cdef bint _deallocate
     cpdef Diag copy(Diag self)
diff --git a/qutip/core/data/diag.pyx b/qutip/core/data/diag.pyx
index ee9c0d33a8..4b13e543c3 100644
--- a/qutip/core/data/diag.pyx
+++ b/qutip/core/data/diag.pyx
@@ -25,9 +25,9 @@ except ImportError:
 from scipy.linalg cimport cython_blas as blas
 
 from qutip.core.data cimport base, Dense
-from qutip.core.data.adjoint cimport adjoint_diag, transpose_diag, conj_diag
-from qutip.core.data.trace cimport trace_diag
-from qutip.core.data.tidyup cimport tidyup_diag
+from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag#********************************
+from qutip.core.data.trace import trace_diag#********************************
+from qutip.core.data.tidyup import tidyup_diag #********************************
 from .base import idxint_dtype
 from qutip.settings import settings
 
@@ -62,10 +62,10 @@ cdef class Diag(base.Data):
     def __cinit__(self, *args, **kwargs):
         self._deallocate = True
 
-    def __init__(self, arg=None, shape=None, bint=True, bint=tidyup=False):
+    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
         cdef size_t ptr
         cdef base.idxint col
-        cdef object data, col_index, row_index
+        cdef object data, offsets
 
         if isinstance(arg, scipy.sparse.spmatrix):
             arg = arg.todia()
@@ -86,7 +86,6 @@ cdef class Diag(base.Data):
         self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
         self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
         self.num_diag = self.offsets.shape[0]
-        self.size = self.data.shape[0]
 
         if shape is None:
             warnings.warn("instantiating Diag matrix of unknown shape")
@@ -95,13 +94,13 @@ cdef class Diag(base.Data):
             for i in self.num_diag:
                 if self.offsets[i] >= 0:
                     j = 0
-                    while self.data[i, j] == 0.0:
+                    while self.data[i + j * self.shape[1]] == 0.0:
                         j += 1
                     nrows = max(nrows, j)
-                    ncols = max(ncols, self.offsets[i] + j)
+                    ncols = max(ncols, (self.offsets[i] + j))
                 else:
                     j = 0
-                    while self.data[i, self.size -j - 1] == 0.0:
+                    while self.data[i + (self.shape[1] -j - 1) * self.shape[1]] == 0.0:
                         j += 1
                     nrows = max(nrows, j - self.offsets[i])
                     ncols = max(ncols, j)
@@ -117,7 +116,7 @@ cdef class Diag(base.Data):
                 raise ValueError("shape must be a 2-tuple of positive ints")
             self.shape = shape
 
-        self._scipy = _dia_matrix(data, col_index, row_index, self.shape)
+        self._scipy = _dia_matrix(self.data, self.offsets, self.shape)
         if tidyup:
             tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
 
@@ -137,8 +136,8 @@ cdef class Diag(base.Data):
         low-level C code).
         """
         cdef Diag out = empty_like(self)
-        memcpy(out.data, self.data, self.num_diag * self.size * sizeof(double complex))
-        memcpy(out.col_index, self.offsets, self.num_diag*sizeof(base.idxint))
+        memcpy(out.data, self.data, self.num_diag * self.shape[1] * sizeof(double complex))
+        memcpy(out.offsets, self.offsets, self.num_diag * sizeof(base.idxint))
 
         return out
 
@@ -150,11 +149,20 @@ cdef class Diag(base.Data):
         """
         cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
         cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
+        cdef size_t diag, col, nrows = self.shape[0]
         cdef double complex [:, ::1] buffer = out
-        cdef size_t diag, n
         for diag in range(self.num_diag):
-            for n in range(max(self.offsets[diag], 0), min(self.size + self.offsets[diag], self.size)):
-                buffer[self.offsets[diag] + n, self.offsets[diag] + n] = self.data[diag, n]
+            for col in range(data.shape[1]):
+                if col - diag < 0 or col - diag >= nrows:
+                    continue
+                out[(col-diag), col] = self.data[diag * self.shape[1] + col]
+        return out
+
+
+
+        for diag in range(self.num_diag):
+            for n in range(max(self.offsets[diag], 0), min(self.shape[1 + self.offsets[diag], self.shape[1)):
+                buffer[self.offsets[diag] + n, self.offsets[diag] + n] = self.data[diag + n* self.shape[1]
         return out
 
     cpdef object as_scipy(self):
@@ -171,7 +179,7 @@ cdef class Diag(base.Data):
         if self._scipy is not None:
             return self._scipy
         cdef cnp.npy_intp num_diag = self.num_diag
-        cdef cnp.npy_intp size = self.size
+        cdef cnp.npy_intp size = self.shape[1]
         data = cnp.PyArray_SimpleNewFromData(1, [num_diag, size],
                                              cnp.NPY_COMPLEX128,
                                              self.data)
@@ -184,6 +192,7 @@ cdef class Diag(base.Data):
         self._scipy = _dia_matrix(data, offsets, self.shape)
         return self._scipy
 
+    """
     cpdef double complex trace(self):
         return trace_diag(self)
 
@@ -195,6 +204,7 @@ cdef class Diag(base.Data):
 
     cpdef Diag transpose(self):
         return transpose_diag(self)
+    """
 
     def __repr__(self):
         return "".join([
@@ -212,7 +222,7 @@ cdef class Diag(base.Data):
             return
         if self.data != NULL:
             PyDataMem_FREE(self.data)
-        if self.col_index != NULL:
+        if self.offsets != NULL:
             PyDataMem_FREE(self.offsets)
 
 
@@ -229,5 +239,248 @@ cpdef Diag fast_from_scipy(object sci):
     out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
     out.offsets = <base.idxint *> cnp.PyArray_GETPTR1(sci.offsets, 0)
     out.num_diag  = sci.offsets.shape[0]
-    out.size = sci.data.shape[1]
     return out
+
+
+cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
+    """
+    Allocate an empty Diag matrix of the given shape, ``with num_diag``
+    diagonals.
+
+    This does not initialise any of the memory returned.
+    """
+    if num_diag < 0:
+        raise ValueError("num_diag must be a positive integer.")
+    cdef CSR out = Diag.__new__(Diag)
+    out.shape = (rows, cols)
+    out.num_diag = num_diag
+    # Python doesn't like allocating nothing.
+    if num_diag == 0:
+        num_diag += 1
+    out.data =\
+        <double complex *> PyDataMem_NEW(out.shape[1] * num_diag * sizeof(double complex))
+    out.offsets =\
+        <base.idxint *> PyDataMem_NEW(num_diag * sizeof(base.idxint))
+    return out
+
+
+cpdef Diag empty_like(Diag other):
+    return empty(other.shape[0], other.shape[1], other.num_diag)
+
+
+cpdef Diag zeros(base.idxint rows, base.idxint cols):
+    """
+    Allocate the zero matrix with a given shape.  There will not be any room in
+    the `data` and `col_index` buffers to add new elements.
+    """
+    # We always allocate matrices with at least one element to ensure that we
+    # actually _are_ asking for memory (Python doesn't like allocating nothing)
+    cdef Diag out = empty(rows, cols, 1)
+    memset(out.data, 0, out.shape[1] * sizeof(double complex))
+    out.offsets[0] = 0
+    out.num_diag = 0
+    return out
+
+
+cpdef Diag identity(base.idxint dimension, double complex scale=1):
+    """
+    Return a square matrix of the specified dimension, with a constant along
+    the diagonal.  By default this will be the identity matrix, but if `scale`
+    is passed, then the result will be `scale` times the identity.
+    """
+    cdef Diag out = empty(dimension, dimension, 1)
+    memset(out.data, 0, out.shape[1] * sizeof(double complex))
+    out.offsets[0] = 0
+    return out
+
+
+cpdef Diag from_dense(Dense matrix):
+    # Assume worst-case scenario for non-zero.
+    cdef Diag out = zeros(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
+    cdef size_t diag_, ptr_in, ptr_out=0, stride
+    cdef row, col
+
+    out.data = np.zeros((matrix.shape[0] + matrix.shape[1] - 1, matrix.shape[1]))
+    offsets = np.arange(-matrix.shape[0] + 1, matrix.shape[1])
+    strideR = matrix.shape[0] if matrix.fortran else 1
+    strideC = matrix.shape[1] if not matrix.fortran else 1
+
+    for row in range(matrix.shape[0]):
+        for col in range(matrix.shape[1]):
+            data[-(-col+row) -matrix.shape[1], col] = matrix.data[row * strideR + col * strideC]
+
+    return tidyup_diag(data, offsets)
+
+
+cpdef tidyup_diag(data, offsets, atol=1e-5, inplace=False):
+    new_offsets = []
+    diags = []
+    for diag, line in zip(offsets, data):
+        has_data = False
+        for val in line:
+            has_data |= abs(val) > atol
+            if has_data:
+                break
+        if not has_data:
+            continue
+        new_offsets.append(diag)
+        diags.append(line)
+    data = np.vstack(diags)
+    offsets = np.array(new_offsets)
+    return data, offsets
+
+
+cdef CSR diags_(
+    list diagonals, base.idxint[:] offsets,
+    base.idxint n_rows, base.idxint n_cols,
+):
+    """
+    Construct a CSR matrix from a list of diagonals and their offsets.  The
+    offsets are assumed to be in sorted order.  This is the C-only interface to
+    csr.diags, and inputs are not sanity checked (use the Python interface for
+    that).
+
+    Parameters
+    ----------
+    diagonals : list of indexable of double complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal (not checked).
+
+    offsets : idxint[:]
+        The indices of the diagonals.  These should be sorted and without
+        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
+        An offset of 0 is the main diagonal, positive values are above the main
+        diagonal and negative ones are below the main diagonal.
+
+    n_rows, n_cols : idxint
+        The shape of the output.  The result does not need to be square, but
+        the diagonals must be of the correct length to fit in.
+    """
+    cdef size_t n_diagonals = len(diagonals)
+    if n_diagonals == 0:
+        return zeros(n_rows, n_cols)
+    cdef base.idxint k, row, start_row, offset, nnz=0,
+    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
+    cdef double complex value
+    for k in range(n_diagonals):
+        offset = offsets[k]
+        if offset >= 0 and min_k > k:
+            min_k = k
+        nnz += _diagonal_length(offset, n_rows, n_cols)
+    cdef CSR out = empty(n_rows, n_cols, nnz)
+    nnz = 0
+    out.row_index[0] = 0
+    for row in range(n_rows):
+        if min_k > 0:
+            offset = offsets[min_k - 1]
+            start_row = 0 if offset >= 0 else -offset
+            if start_row == row:
+                min_k -= 1
+        if max_k > 0:
+            offset = offsets[max_k - 1]
+            start_row = 0 if offset >= 0 else -offset
+            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
+                max_k -= 1
+        for k in range(min_k, max_k):
+            offset = offsets[k]
+            value = diagonals[k][row if offset >= 0 else row + offset]
+            if value == 0:
+                continue
+            out.data[nnz] = value
+            out.col_index[nnz] = row + offset
+            nnz += 1
+        out.row_index[row + 1] = nnz
+    return out
+
+@cython.wraparound(True)
+def diags(diagonals, offsets=None, shape=None):
+    """
+    Construct a CSR matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements.  Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    cdef base.idxint n_rows, n_cols, offset
+    try:
+        diagonals = list(diagonals)
+        if diagonals and np.isscalar(diagonals[0]):
+            # Catch the case where we're being called as (for example)
+            #   diags([1, 2, 3], 0)
+            # with a single diagonal and offset.
+            diagonals = [diagonals]
+    except TypeError:
+        raise TypeError("diagonals must be a list of arrays of complex") from None
+    if offsets is None:
+        if len(diagonals) == 0:
+            offsets = []
+        elif len(diagonals) == 1:
+            offsets = [0]
+        else:
+            raise TypeError("offsets must be supplied if passing more than one diagonal")
+    offsets = np.atleast_1d(offsets)
+    if offsets.ndim > 1:
+        raise ValueError("offsets must be a 1D array of integers")
+    if len(diagonals) != len(offsets):
+        raise ValueError("number of diagonals does not match number of offsets")
+    if len(diagonals) == 0:
+        if shape is None:
+            raise ValueError("cannot construct matrix with no diagonals without a shape")
+        else:
+            n_rows, n_cols = shape
+        return zeros(n_rows, n_cols)
+    order = np.argsort(offsets)
+    diagonals_ = []
+    offsets_ = []
+    prev, cur = None, None
+    for i in order:
+        cur = offsets[i]
+        if cur == prev:
+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+        else:
+            offsets_.append(cur)
+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+        prev = cur
+    if shape is None:
+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+    else:
+        try:
+            n_rows, n_cols = shape
+        except (TypeError, ValueError):
+            raise TypeError("shape must be a 2-tuple of positive integers")
+        if n_rows < 0 or n_cols < 0:
+            raise ValueError("shape must be a 2-tuple of positive integers")
+    for i in range(len(diagonals_)):
+        offset = offsets_[i]
+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+            raise ValueError("given diagonals do not have the correct lengths")
+    if n_rows == 0 and n_cols == 0:
+        raise ValueError("can't produce a 0x0 matrix")
+    if len(offsets) == 1:
+        # Fast path for a single diagonal.
+        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
+    return diags_(
+        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
+    )

From d99fb2a87a8513af84636685a2c8b52c85eb938e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 25 Apr 2023 11:06:11 -0400
Subject: [PATCH 348/602] comiling

---
 qutip/core/data/diag.pxd | 11 ++---
 qutip/core/data/diag.pyx | 99 +++++++++++++++-------------------------
 2 files changed, 42 insertions(+), 68 deletions(-)

diff --git a/qutip/core/data/diag.pxd b/qutip/core/data/diag.pxd
index e4b9428b57..04861fca73 100644
--- a/qutip/core/data/diag.pxd
+++ b/qutip/core/data/diag.pxd
@@ -20,9 +20,8 @@ cdef class Diag(base.Data):
     cdef object _scipy
     cdef bint _deallocate
     cpdef Diag copy(Diag self)
-    cpdef object as_scipy(Diag self, bint full=*)
-    cpdef Diag sort_indices(Diag self)
-    cpdef double complex trace(Diag self)
-    cpdef Diag adjoint(Diag self)
-    cpdef Diag conj(Diag self)
-    cpdef Diag transpose(Diag self)
+    cpdef object as_scipy(Diag self)
+    #cpdef double complex trace(Diag self)
+    #cpdef Diag adjoint(Diag self)
+    #cpdef Diag conj(Diag self)
+    #cpdef Diag transpose(Diag self)
diff --git a/qutip/core/data/diag.pyx b/qutip/core/data/diag.pyx
index 4b13e543c3..d8894e212b 100644
--- a/qutip/core/data/diag.pyx
+++ b/qutip/core/data/diag.pyx
@@ -25,9 +25,9 @@ except ImportError:
 from scipy.linalg cimport cython_blas as blas
 
 from qutip.core.data cimport base, Dense
-from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag#********************************
-from qutip.core.data.trace import trace_diag#********************************
-from qutip.core.data.tidyup import tidyup_diag #********************************
+# from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag#********************************
+# from qutip.core.data.trace import trace_diag#********************************
+# from qutip.core.data.tidyup import tidyup_diag #********************************
 from .base import idxint_dtype
 from qutip.settings import settings
 
@@ -48,7 +48,7 @@ cdef object _dia_matrix(data, offsets, shape):
     because this takes tens of microseconds, and we already know we're in
     a sensible format.
     """
-    cdef object out = scipy_dia_array.__new__(scipy_diag_matrix)
+    cdef object out = scipy_dia_array.__new__(scipy_dia_array)
     # `_data_matrix` is the first object in the inheritance chain which
     # doesn't have a really slow __init__.
     scipy_data_matrix.__init__(out)
@@ -85,7 +85,7 @@ cdef class Diag(base.Data):
         self._deallocate = False
         self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
         self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
-        self.num_diag = self.offsets.shape[0]
+        self.num_diag = offsets.shape[0]
 
         if shape is None:
             warnings.warn("instantiating Diag matrix of unknown shape")
@@ -116,7 +116,7 @@ cdef class Diag(base.Data):
                 raise ValueError("shape must be a 2-tuple of positive ints")
             self.shape = shape
 
-        self._scipy = _dia_matrix(self.data, self.offsets, self.shape)
+        self._scipy = _dia_matrix(data, offsets, self.shape)
         if tidyup:
             tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
 
@@ -152,19 +152,12 @@ cdef class Diag(base.Data):
         cdef size_t diag, col, nrows = self.shape[0]
         cdef double complex [:, ::1] buffer = out
         for diag in range(self.num_diag):
-            for col in range(data.shape[1]):
+            for col in range(self.shape[1]):
                 if col - diag < 0 or col - diag >= nrows:
                     continue
                 out[(col-diag), col] = self.data[diag * self.shape[1] + col]
         return out
 
-
-
-        for diag in range(self.num_diag):
-            for n in range(max(self.offsets[diag], 0), min(self.shape[1 + self.offsets[diag], self.shape[1)):
-                buffer[self.offsets[diag] + n, self.offsets[diag] + n] = self.data[diag + n* self.shape[1]
-        return out
-
     cpdef object as_scipy(self):
         """
         Get a view onto this object as a `scipy.sparse.dia_matrix`.  The
@@ -251,7 +244,7 @@ cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
     """
     if num_diag < 0:
         raise ValueError("num_diag must be a positive integer.")
-    cdef CSR out = Diag.__new__(Diag)
+    cdef Diag out = Diag.__new__(Diag)
     out.shape = (rows, cols)
     out.num_diag = num_diag
     # Python doesn't like allocating nothing.
@@ -289,30 +282,32 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
     is passed, then the result will be `scale` times the identity.
     """
     cdef Diag out = empty(dimension, dimension, 1)
-    memset(out.data, 0, out.shape[1] * sizeof(double complex))
+    memset(out.data, 1, out.shape[1] * sizeof(double complex))
     out.offsets[0] = 0
     return out
 
 
 cpdef Diag from_dense(Dense matrix):
     # Assume worst-case scenario for non-zero.
-    cdef Diag out = zeros(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
+    cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
     cdef size_t diag_, ptr_in, ptr_out=0, stride
     cdef row, col
 
-    out.data = np.zeros((matrix.shape[0] + matrix.shape[1] - 1, matrix.shape[1]))
-    offsets = np.arange(-matrix.shape[0] + 1, matrix.shape[1])
+    for i in range(matrix.shape[0] + matrix.shape[1] - 1):
+        out.offsets[i] = i -matrix.shape[0] + 1
     strideR = matrix.shape[0] if matrix.fortran else 1
     strideC = matrix.shape[1] if not matrix.fortran else 1
 
     for row in range(matrix.shape[0]):
         for col in range(matrix.shape[1]):
-            data[-(-col+row) -matrix.shape[1], col] = matrix.data[row * strideR + col * strideC]
+            out.data[(-(-col+row) -matrix.shape[1]) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
 
-    return tidyup_diag(data, offsets)
+    return tidyup_diag(out)
 
 
-cpdef tidyup_diag(data, offsets, atol=1e-5, inplace=False):
+cpdef tidyup_diag(mat, atol=1e-5, inplace=False):
+    data = mat.data
+    offsets = mat.offsets
     new_offsets = []
     diags = []
     for diag, line in zip(offsets, data):
@@ -330,14 +325,22 @@ cpdef tidyup_diag(data, offsets, atol=1e-5, inplace=False):
     return data, offsets
 
 
-cdef CSR diags_(
+cdef inline base.idxint _diagonal_length(
+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+) nogil:
+    if offset > 0:
+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+    return n_cols if offset > n_cols - n_rows else n_rows + offset
+
+
+cdef Diag diags_(
     list diagonals, base.idxint[:] offsets,
     base.idxint n_rows, base.idxint n_cols,
 ):
     """
-    Construct a CSR matrix from a list of diagonals and their offsets.  The
+    Construct a Diag matrix from a list of diagonals and their offsets.  The
     offsets are assumed to be in sorted order.  This is the C-only interface to
-    csr.diags, and inputs are not sanity checked (use the Python interface for
+    diag.diags, and inputs are not sanity checked (use the Python interface for
     that).
 
     Parameters
@@ -357,46 +360,18 @@ cdef CSR diags_(
         The shape of the output.  The result does not need to be square, but
         the diagonals must be of the correct length to fit in.
     """
-    cdef size_t n_diagonals = len(diagonals)
-    if n_diagonals == 0:
-        return zeros(n_rows, n_cols)
-    cdef base.idxint k, row, start_row, offset, nnz=0,
-    cdef base.idxint min_k=n_diagonals, max_k=n_diagonals
-    cdef double complex value
-    for k in range(n_diagonals):
-        offset = offsets[k]
-        if offset >= 0 and min_k > k:
-            min_k = k
-        nnz += _diagonal_length(offset, n_rows, n_cols)
-    cdef CSR out = empty(n_rows, n_cols, nnz)
-    nnz = 0
-    out.row_index[0] = 0
-    for row in range(n_rows):
-        if min_k > 0:
-            offset = offsets[min_k - 1]
-            start_row = 0 if offset >= 0 else -offset
-            if start_row == row:
-                min_k -= 1
-        if max_k > 0:
-            offset = offsets[max_k - 1]
-            start_row = 0 if offset >= 0 else -offset
-            if start_row + _diagonal_length(offset, n_rows, n_cols) - 1 < row:
-                max_k -= 1
-        for k in range(min_k, max_k):
-            offset = offsets[k]
-            value = diagonals[k][row if offset >= 0 else row + offset]
-            if value == 0:
-                continue
-            out.data[nnz] = value
-            out.col_index[nnz] = row + offset
-            nnz += 1
-        out.row_index[row + 1] = nnz
+    out = empty(n_rows, n_cols, len(offsets))
+    for i in range(len(offsets)):
+        out.offsets[i] = offsets[i]
+        offset = max(offsets[i], 0)
+        for col in range(len(diagonals[i])):
+            out.data[i, col + offset] = diagonals[i][col]
     return out
 
 @cython.wraparound(True)
 def diags(diagonals, offsets=None, shape=None):
     """
-    Construct a CSR matrix from diagonals and their offsets.  Using this
+    Construct a Diag matrix from diagonals and their offsets.  Using this
     function in single-argument form produces a square matrix with the given
     values on the main diagonal.
 
@@ -478,9 +453,9 @@ def diags(diagonals, offsets=None, shape=None):
             raise ValueError("given diagonals do not have the correct lengths")
     if n_rows == 0 and n_cols == 0:
         raise ValueError("can't produce a 0x0 matrix")
-    if len(offsets) == 1:
+    #if len(offsets) == 1:
         # Fast path for a single diagonal.
-        return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
+        #return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
     return diags_(
         diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
     )

From 1e38b71bb999365386e31152ee370a8af306e84d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 25 Apr 2023 17:17:55 -0400
Subject: [PATCH 349/602] Test running

---
 qutip/core/data/diag.pxd |  27 ---
 qutip/core/data/diag.pyx | 461 ---------------------------------------
 2 files changed, 488 deletions(-)
 delete mode 100644 qutip/core/data/diag.pxd
 delete mode 100644 qutip/core/data/diag.pyx

diff --git a/qutip/core/data/diag.pxd b/qutip/core/data/diag.pxd
deleted file mode 100644
index 04861fca73..0000000000
--- a/qutip/core/data/diag.pxd
+++ /dev/null
@@ -1,27 +0,0 @@
-#cython: language_level=3
-
-# from cpython cimport mem
-# from libcpp.algorithm cimport sort
-# from libc.math cimport fabs
-
-# cdef extern from *:
-#     void *PyMem_Calloc(size_t n, size_t elsize)
-
-# import numpy as np
-# cimport numpy as cnp
-
-from qutip.core.data cimport base
-# from qutip.core.data.dense cimport Dense
-
-cdef class Diag(base.Data):
-    cdef double complex *data
-    cdef base.idxint *offsets
-    cdef size_t num_diag
-    cdef object _scipy
-    cdef bint _deallocate
-    cpdef Diag copy(Diag self)
-    cpdef object as_scipy(Diag self)
-    #cpdef double complex trace(Diag self)
-    #cpdef Diag adjoint(Diag self)
-    #cpdef Diag conj(Diag self)
-    #cpdef Diag transpose(Diag self)
diff --git a/qutip/core/data/diag.pyx b/qutip/core/data/diag.pyx
deleted file mode 100644
index d8894e212b..0000000000
--- a/qutip/core/data/diag.pyx
+++ /dev/null
@@ -1,461 +0,0 @@
-#cython: language_level=3
-#cython: boundscheck=False, wraparound=False, initializedcheck=False
-
-from libc.string cimport memset, memcpy
-
-from libcpp cimport bool
-from libcpp.algorithm cimport sort
-
-cimport cython
-
-from cpython cimport mem
-
-import numbers
-import warnings
-
-import numpy as np
-cimport numpy as cnp
-import scipy.sparse
-from scipy.sparse import dia_array as scipy_dia_array
-try:
-    from scipy.sparse.data import _data_matrix as scipy_data_matrix
-except ImportError:
-    # The file data was renamed to _data from scipy 1.8.0
-    from scipy.sparse._data import _data_matrix as scipy_data_matrix
-from scipy.linalg cimport cython_blas as blas
-
-from qutip.core.data cimport base, Dense
-# from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag#********************************
-# from qutip.core.data.trace import trace_diag#********************************
-# from qutip.core.data.tidyup import tidyup_diag #********************************
-from .base import idxint_dtype
-from qutip.settings import settings
-
-cnp.import_array()
-
-cdef extern from *:
-    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
-    void *PyDataMem_NEW(size_t size)
-    void PyDataMem_FREE(void *ptr)
-
-__all__ = ['Diag']
-
-cdef int _ONE = 1
-
-cdef object _dia_matrix(data, offsets, shape):
-    """
-    Factory method of scipy diag_matrix: we skip all the index type-checking
-    because this takes tens of microseconds, and we already know we're in
-    a sensible format.
-    """
-    cdef object out = scipy_dia_array.__new__(scipy_dia_array)
-    # `_data_matrix` is the first object in the inheritance chain which
-    # doesn't have a really slow __init__.
-    scipy_data_matrix.__init__(out)
-    out.data = data
-    out.offsets = offsets
-    out._shape = shape
-    return out
-
-
-cdef class Diag(base.Data):
-    def __cinit__(self, *args, **kwargs):
-        self._deallocate = True
-
-    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
-        cdef size_t ptr
-        cdef base.idxint col
-        cdef object data, offsets
-
-        if isinstance(arg, scipy.sparse.spmatrix):
-            arg = arg.todia()
-            if shape is not None and shape != arg.shape:
-                raise ValueError("".join([
-                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
-                ]))
-            shape = arg.shape
-            arg = (arg.data, arg.offsets)
-        if not isinstance(arg, tuple):
-            raise TypeError("arg must be a scipy matrix or tuple")
-        if len(arg) != 2:
-            raise ValueError("arg must be a (data, offsets) tuple")
-        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
-        offsets = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
-
-        self._deallocate = False
-        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
-        self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
-        self.num_diag = offsets.shape[0]
-
-        if shape is None:
-            warnings.warn("instantiating Diag matrix of unknown shape")
-            nrows = 0
-            ncols = 0
-            for i in self.num_diag:
-                if self.offsets[i] >= 0:
-                    j = 0
-                    while self.data[i + j * self.shape[1]] == 0.0:
-                        j += 1
-                    nrows = max(nrows, j)
-                    ncols = max(ncols, (self.offsets[i] + j))
-                else:
-                    j = 0
-                    while self.data[i + (self.shape[1] -j - 1) * self.shape[1]] == 0.0:
-                        j += 1
-                    nrows = max(nrows, j - self.offsets[i])
-                    ncols = max(ncols, j)
-            self.shape = (nrows, ncols)
-        else:
-            if not isinstance(shape, tuple):
-                raise TypeError("shape must be a 2-tuple of positive ints")
-            if not (len(shape) == 2
-                    and isinstance(shape[0], int)
-                    and isinstance(shape[1], int)
-                    and shape[0] > 0
-                    and shape[1] > 0):
-                raise ValueError("shape must be a 2-tuple of positive ints")
-            self.shape = shape
-
-        self._scipy = _dia_matrix(data, offsets, self.shape)
-        if tidyup:
-            tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
-
-    def __reduce__(self):
-        return (fast_from_scipy, (self.as_scipy(),))
-
-    cpdef Diag copy(self):
-        """
-        Return a complete (deep) copy of this object.
-
-        If the type currently has a scipy backing, such as that produced by
-        `as_scipy`, this will not be copied.  The backing is a view onto our
-        data, and a straight copy of this view would be incorrect.  We do not
-        create a new view at copy time, since the user may only access this
-        through a creation method, and creating it ahead of time would incur an
-        unnecessary speed penalty for users who do not need it (including
-        low-level C code).
-        """
-        cdef Diag out = empty_like(self)
-        memcpy(out.data, self.data, self.num_diag * self.shape[1] * sizeof(double complex))
-        memcpy(out.offsets, self.offsets, self.num_diag * sizeof(base.idxint))
-
-        return out
-
-    cpdef object to_array(self):
-        """
-        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
-        is not a view onto the data, and changes to new array will not affect
-        the original data structure.
-        """
-        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
-        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
-        cdef size_t diag, col, nrows = self.shape[0]
-        cdef double complex [:, ::1] buffer = out
-        for diag in range(self.num_diag):
-            for col in range(self.shape[1]):
-                if col - diag < 0 or col - diag >= nrows:
-                    continue
-                out[(col-diag), col] = self.data[diag * self.shape[1] + col]
-        return out
-
-    cpdef object as_scipy(self):
-        """
-        Get a view onto this object as a `scipy.sparse.dia_matrix`.  The
-        underlying data structures are exposed, such that modifications to the
-        `data`, `indices` and `indptr` buffers in the resulting object will
-        modify this object too.
-        """
-        # We store a reference to the scipy matrix not only for caching this
-        # relatively expensive method, but also because we transferred
-        # ownership of our data to the numpy arrays, and we can't allow them to
-        # be collected while we're alive.
-        if self._scipy is not None:
-            return self._scipy
-        cdef cnp.npy_intp num_diag = self.num_diag
-        cdef cnp.npy_intp size = self.shape[1]
-        data = cnp.PyArray_SimpleNewFromData(1, [num_diag, size],
-                                             cnp.NPY_COMPLEX128,
-                                             self.data)
-        offsets = cnp.PyArray_SimpleNewFromData(1, [num_diag],
-                                                base.idxint_DTYPE,
-                                                self.offsets)
-        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
-        PyArray_ENABLEFLAGS(offsets, cnp.NPY_ARRAY_OWNDATA)
-        self._deallocate = False
-        self._scipy = _dia_matrix(data, offsets, self.shape)
-        return self._scipy
-
-    """
-    cpdef double complex trace(self):
-        return trace_diag(self)
-
-    cpdef Diag adjoint(self):
-        return adjoint_diag(self)
-
-    cpdef Diag conj(self):
-        return conj_diag(self)
-
-    cpdef Diag transpose(self):
-        return transpose_diag(self)
-    """
-
-    def __repr__(self):
-        return "".join([
-            "Diag(shape=", str(self.shape), ", num_diag=", str(self.num_diag), ")",
-        ])
-
-    def __str__(self):
-        return self.__repr__()
-
-    def __dealloc__(self):
-        # If we have a reference to a scipy type, then we've passed ownership
-        # of the data to numpy, so we let it handle refcounting and we don't
-        # need to deallocate anything ourselves.
-        if not self._deallocate:
-            return
-        if self.data != NULL:
-            PyDataMem_FREE(self.data)
-        if self.offsets != NULL:
-            PyDataMem_FREE(self.offsets)
-
-
-cpdef Diag fast_from_scipy(object sci):
-    """
-    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
-    checking on any of the inputs, and should consequently be considered very
-    unsafe.  This is primarily for use in the unpickling operation.
-    """
-    cdef Diag out = Diag.__new__(Diag)
-    out.shape = sci.shape
-    out._deallocate = False
-    out._scipy = sci
-    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
-    out.offsets = <base.idxint *> cnp.PyArray_GETPTR1(sci.offsets, 0)
-    out.num_diag  = sci.offsets.shape[0]
-    return out
-
-
-cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
-    """
-    Allocate an empty Diag matrix of the given shape, ``with num_diag``
-    diagonals.
-
-    This does not initialise any of the memory returned.
-    """
-    if num_diag < 0:
-        raise ValueError("num_diag must be a positive integer.")
-    cdef Diag out = Diag.__new__(Diag)
-    out.shape = (rows, cols)
-    out.num_diag = num_diag
-    # Python doesn't like allocating nothing.
-    if num_diag == 0:
-        num_diag += 1
-    out.data =\
-        <double complex *> PyDataMem_NEW(out.shape[1] * num_diag * sizeof(double complex))
-    out.offsets =\
-        <base.idxint *> PyDataMem_NEW(num_diag * sizeof(base.idxint))
-    return out
-
-
-cpdef Diag empty_like(Diag other):
-    return empty(other.shape[0], other.shape[1], other.num_diag)
-
-
-cpdef Diag zeros(base.idxint rows, base.idxint cols):
-    """
-    Allocate the zero matrix with a given shape.  There will not be any room in
-    the `data` and `col_index` buffers to add new elements.
-    """
-    # We always allocate matrices with at least one element to ensure that we
-    # actually _are_ asking for memory (Python doesn't like allocating nothing)
-    cdef Diag out = empty(rows, cols, 1)
-    memset(out.data, 0, out.shape[1] * sizeof(double complex))
-    out.offsets[0] = 0
-    out.num_diag = 0
-    return out
-
-
-cpdef Diag identity(base.idxint dimension, double complex scale=1):
-    """
-    Return a square matrix of the specified dimension, with a constant along
-    the diagonal.  By default this will be the identity matrix, but if `scale`
-    is passed, then the result will be `scale` times the identity.
-    """
-    cdef Diag out = empty(dimension, dimension, 1)
-    memset(out.data, 1, out.shape[1] * sizeof(double complex))
-    out.offsets[0] = 0
-    return out
-
-
-cpdef Diag from_dense(Dense matrix):
-    # Assume worst-case scenario for non-zero.
-    cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
-    cdef size_t diag_, ptr_in, ptr_out=0, stride
-    cdef row, col
-
-    for i in range(matrix.shape[0] + matrix.shape[1] - 1):
-        out.offsets[i] = i -matrix.shape[0] + 1
-    strideR = matrix.shape[0] if matrix.fortran else 1
-    strideC = matrix.shape[1] if not matrix.fortran else 1
-
-    for row in range(matrix.shape[0]):
-        for col in range(matrix.shape[1]):
-            out.data[(-(-col+row) -matrix.shape[1]) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
-
-    return tidyup_diag(out)
-
-
-cpdef tidyup_diag(mat, atol=1e-5, inplace=False):
-    data = mat.data
-    offsets = mat.offsets
-    new_offsets = []
-    diags = []
-    for diag, line in zip(offsets, data):
-        has_data = False
-        for val in line:
-            has_data |= abs(val) > atol
-            if has_data:
-                break
-        if not has_data:
-            continue
-        new_offsets.append(diag)
-        diags.append(line)
-    data = np.vstack(diags)
-    offsets = np.array(new_offsets)
-    return data, offsets
-
-
-cdef inline base.idxint _diagonal_length(
-    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
-) nogil:
-    if offset > 0:
-        return n_rows if offset <= n_cols - n_rows else n_cols - offset
-    return n_cols if offset > n_cols - n_rows else n_rows + offset
-
-
-cdef Diag diags_(
-    list diagonals, base.idxint[:] offsets,
-    base.idxint n_rows, base.idxint n_cols,
-):
-    """
-    Construct a Diag matrix from a list of diagonals and their offsets.  The
-    offsets are assumed to be in sorted order.  This is the C-only interface to
-    diag.diags, and inputs are not sanity checked (use the Python interface for
-    that).
-
-    Parameters
-    ----------
-    diagonals : list of indexable of double complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal (not checked).
-
-    offsets : idxint[:]
-        The indices of the diagonals.  These should be sorted and without
-        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
-        An offset of 0 is the main diagonal, positive values are above the main
-        diagonal and negative ones are below the main diagonal.
-
-    n_rows, n_cols : idxint
-        The shape of the output.  The result does not need to be square, but
-        the diagonals must be of the correct length to fit in.
-    """
-    out = empty(n_rows, n_cols, len(offsets))
-    for i in range(len(offsets)):
-        out.offsets[i] = offsets[i]
-        offset = max(offsets[i], 0)
-        for col in range(len(diagonals[i])):
-            out.data[i, col + offset] = diagonals[i][col]
-    return out
-
-@cython.wraparound(True)
-def diags(diagonals, offsets=None, shape=None):
-    """
-    Construct a Diag matrix from diagonals and their offsets.  Using this
-    function in single-argument form produces a square matrix with the given
-    values on the main diagonal.
-
-    With lists of diagonals and offsets, the matrix will be the smallest
-    possible square matrix if shape is not given, but in all cases the
-    diagonals must fit exactly with no extra or missing elements.  Duplicated
-    diagonals will be summed together in the output.
-
-    Parameters
-    ----------
-    diagonals : sequence of array_like of complex or array_like of complex
-        The entries (including zeros) that should be placed on the diagonals in
-        the output matrix.  Each entry must have enough entries in it to fill
-        the relevant diagonal and no more.
-
-    offsets : sequence of integer or integer, optional
-        The indices of the diagonals.  `offsets[i]` is the location of the
-        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
-        values are above the main diagonal and negative ones are below the main
-        diagonal.
-
-    shape : tuple, optional
-        The shape of the output as (``rows``, ``columns``).  The result does
-        not need to be square, but the diagonals must be of the correct length
-        to fit in exactly.
-    """
-    cdef base.idxint n_rows, n_cols, offset
-    try:
-        diagonals = list(diagonals)
-        if diagonals and np.isscalar(diagonals[0]):
-            # Catch the case where we're being called as (for example)
-            #   diags([1, 2, 3], 0)
-            # with a single diagonal and offset.
-            diagonals = [diagonals]
-    except TypeError:
-        raise TypeError("diagonals must be a list of arrays of complex") from None
-    if offsets is None:
-        if len(diagonals) == 0:
-            offsets = []
-        elif len(diagonals) == 1:
-            offsets = [0]
-        else:
-            raise TypeError("offsets must be supplied if passing more than one diagonal")
-    offsets = np.atleast_1d(offsets)
-    if offsets.ndim > 1:
-        raise ValueError("offsets must be a 1D array of integers")
-    if len(diagonals) != len(offsets):
-        raise ValueError("number of diagonals does not match number of offsets")
-    if len(diagonals) == 0:
-        if shape is None:
-            raise ValueError("cannot construct matrix with no diagonals without a shape")
-        else:
-            n_rows, n_cols = shape
-        return zeros(n_rows, n_cols)
-    order = np.argsort(offsets)
-    diagonals_ = []
-    offsets_ = []
-    prev, cur = None, None
-    for i in order:
-        cur = offsets[i]
-        if cur == prev:
-            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
-        else:
-            offsets_.append(cur)
-            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
-        prev = cur
-    if shape is None:
-        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
-    else:
-        try:
-            n_rows, n_cols = shape
-        except (TypeError, ValueError):
-            raise TypeError("shape must be a 2-tuple of positive integers")
-        if n_rows < 0 or n_cols < 0:
-            raise ValueError("shape must be a 2-tuple of positive integers")
-    for i in range(len(diagonals_)):
-        offset = offsets_[i]
-        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
-            raise ValueError("given diagonals do not have the correct lengths")
-    if n_rows == 0 and n_cols == 0:
-        raise ValueError("can't produce a 0x0 matrix")
-    #if len(offsets) == 1:
-        # Fast path for a single diagonal.
-        #return diag(diagonals_[0], offsets_[0], n_rows, n_cols)
-    return diags_(
-        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
-    )

From 8bec7207ed58a0cbf0205577cae8c37f48d514c9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 25 Apr 2023 17:29:30 -0400
Subject: [PATCH 350/602] More test passing

---
 qutip/core/data/dia.pxd            |  27 ++
 qutip/core/data/dia.pyx            | 472 +++++++++++++++++++++++++++++
 qutip/tests/core/data/test_diag.py | 328 ++++++++++++++++++++
 3 files changed, 827 insertions(+)
 create mode 100644 qutip/core/data/dia.pxd
 create mode 100644 qutip/core/data/dia.pyx
 create mode 100644 qutip/tests/core/data/test_diag.py

diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
new file mode 100644
index 0000000000..7e05f1b66d
--- /dev/null
+++ b/qutip/core/data/dia.pxd
@@ -0,0 +1,27 @@
+#cython: language_level=3
+
+# from cpython cimport mem
+# from libcpp.algorithm cimport sort
+# from libc.math cimport fabs
+
+# cdef extern from *:
+#     void *PyMem_Calloc(size_t n, size_t elsize)
+
+# import numpy as np
+# cimport numpy as cnp
+
+from qutip.core.data cimport base
+# from qutip.core.data.dense cimport Dense
+
+cdef class Diag(base.Data):
+    cdef double complex *data
+    cdef base.idxint *offsets
+    cdef size_t num_diag, size
+    cdef object _scipy
+    cdef bint _deallocate
+    cpdef Diag copy(Diag self)
+    cpdef object as_scipy(Diag self)
+    #cpdef double complex trace(Diag self)
+    #cpdef Diag adjoint(Diag self)
+    #cpdef Diag conj(Diag self)
+    #cpdef Diag transpose(Diag self)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
new file mode 100644
index 0000000000..3fac4026c2
--- /dev/null
+++ b/qutip/core/data/dia.pyx
@@ -0,0 +1,472 @@
+#cython: language_level=3
+#cython: boundscheck=False, wraparound=False, initializedcheck=False
+
+from libc.string cimport memset, memcpy
+
+from libcpp cimport bool
+from libcpp.algorithm cimport sort
+
+cimport cython
+
+from cpython cimport mem
+
+import numbers
+import warnings
+
+import numpy as np
+cimport numpy as cnp
+import scipy.sparse
+from scipy.sparse import dia_array as scipy_dia_array
+try:
+    from scipy.sparse.data import _data_matrix as scipy_data_matrix
+except ImportError:
+    # The file data was renamed to _data from scipy 1.8.0
+    from scipy.sparse._data import _data_matrix as scipy_data_matrix
+from scipy.linalg cimport cython_blas as blas
+
+from qutip.core.data cimport base, Dense
+# from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag#********************************
+# from qutip.core.data.trace import trace_diag#********************************
+# from qutip.core.data.tidyup import tidyup_diag #********************************
+from .base import idxint_dtype
+from qutip.settings import settings
+
+cnp.import_array()
+
+cdef extern from *:
+    void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags)
+    void *PyDataMem_NEW(size_t size)
+    void PyDataMem_FREE(void *ptr)
+
+__all__ = ['Diag']
+
+cdef int _ONE = 1
+
+cdef object _dia_matrix(data, offsets, shape):
+    """
+    Factory method of scipy diag_matrix: we skip all the index type-checking
+    because this takes tens of microseconds, and we already know we're in
+    a sensible format.
+    """
+    cdef object out = scipy_dia_array.__new__(scipy_dia_array)
+    # `_data_matrix` is the first object in the inheritance chain which
+    # doesn't have a really slow __init__.
+    scipy_data_matrix.__init__(out)
+    out.data = data
+    out.offsets = offsets
+    out._shape = shape
+    return out
+
+
+cdef tuple _count_element(complex[:] line, size_t length):
+    cdef size_t pre = 0, post = length
+    while pre < length and line[pre] == 0.:
+        pre += 1
+    while post and line[post-1] == 0.:
+        post -= 1
+    return (post, length - pre)
+
+
+cdef class Diag(base.Data):
+    def __cinit__(self, *args, **kwargs):
+        self._deallocate = True
+
+    def __init__(self, arg=None, shape=None, bint copy=True, bint tidyup=False):
+        cdef size_t ptr
+        cdef base.idxint col
+        cdef object data, offsets
+
+        if isinstance(arg, scipy.sparse.spmatrix):
+            arg = arg.todia()
+            if shape is not None and shape != arg.shape:
+                raise ValueError("".join([
+                    "shapes do not match: ", str(shape), " and ", str(arg.shape),
+                ]))
+            shape = arg.shape
+            arg = (arg.data, arg.offsets)
+        if not isinstance(arg, tuple):
+            raise TypeError("arg must be a scipy matrix or tuple")
+        if len(arg) != 2:
+            raise ValueError("arg must be a (data, offsets) tuple")
+        data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
+        offsets = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
+
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
+        self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
+        self.num_diag = offsets.shape[0]
+        self.size = data.shape[1]
+
+        if shape is None:
+            warnings.warn("instantiating Diag matrix of unknown shape")
+            nrows = 0
+            ncols = 0
+            for i in range(self.num_diag):
+                pre, post = _count_element(data[i], data.shape[1])
+                if self.offsets[i] >= 0:
+                    row = post
+                    col = post + self.offsets[i]
+                else:
+                    row = pre - self.offsets[i]
+                    col = pre
+                nrows = nrows if nrows > row else row
+                ncols = ncols if ncols > col else col
+            self.shape = (nrows, ncols)
+        else:
+            if not isinstance(shape, tuple):
+                raise TypeError("shape must be a 2-tuple of positive ints")
+            if not (len(shape) == 2
+                    and isinstance(shape[0], int)
+                    and isinstance(shape[1], int)
+                    and shape[0] > 0
+                    and shape[1] > 0):
+                raise ValueError("shape must be a 2-tuple of positive ints")
+            self.shape = shape
+
+        self._scipy = _dia_matrix(data, offsets, self.shape)
+        if tidyup:
+            tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
+
+    def __reduce__(self):
+        return (fast_from_scipy, (self.as_scipy(),))
+
+    cpdef Diag copy(self):
+        """
+        Return a complete (deep) copy of this object.
+
+        If the type currently has a scipy backing, such as that produced by
+        `as_scipy`, this will not be copied.  The backing is a view onto our
+        data, and a straight copy of this view would be incorrect.  We do not
+        create a new view at copy time, since the user may only access this
+        through a creation method, and creating it ahead of time would incur an
+        unnecessary speed penalty for users who do not need it (including
+        low-level C code).
+        """
+        cdef Diag out = empty_like(self)
+        memcpy(out.data, self.data, self.num_diag * self.size * sizeof(double complex))
+        memcpy(out.offsets, self.offsets, self.num_diag * sizeof(base.idxint))
+
+        return out
+
+    cpdef object to_array(self):
+        """
+        Get a copy of this data as a full 2D, C-contiguous NumPy array.  This
+        is not a view onto the data, and changes to new array will not affect
+        the original data structure.
+        """
+        cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
+        cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
+        cdef size_t col, i, nrows = self.shape[0]
+        cdef base.idxint diag
+        for i in range(self.num_diag):
+            diag = self.offsets[i]
+            for col in range(self.size):
+                if col - diag < 0 or col - diag >= nrows:
+                    continue
+                out[(col-diag), col] = self.data[i * self.size + col]
+        return out
+
+    cpdef object as_scipy(self):
+        """
+        Get a view onto this object as a `scipy.sparse.dia_matrix`.  The
+        underlying data structures are exposed, such that modifications to the
+        `data`, `indices` and `indptr` buffers in the resulting object will
+        modify this object too.
+        """
+        # We store a reference to the scipy matrix not only for caching this
+        # relatively expensive method, but also because we transferred
+        # ownership of our data to the numpy arrays, and we can't allow them to
+        # be collected while we're alive.
+        if self._scipy is not None:
+            return self._scipy
+        cdef cnp.npy_intp num_diag = self.num_diag
+        cdef cnp.npy_intp size = self.size
+        data = cnp.PyArray_SimpleNewFromData(2, [num_diag, size],
+                                             cnp.NPY_COMPLEX128,
+                                             self.data)
+        offsets = cnp.PyArray_SimpleNewFromData(1, [num_diag],
+                                                base.idxint_DTYPE,
+                                                self.offsets)
+        PyArray_ENABLEFLAGS(data, cnp.NPY_ARRAY_OWNDATA)
+        PyArray_ENABLEFLAGS(offsets, cnp.NPY_ARRAY_OWNDATA)
+        self._deallocate = False
+        self._scipy = _dia_matrix(data, offsets, self.shape)
+        return self._scipy
+
+    """
+    cpdef double complex trace(self):
+        return trace_diag(self)
+
+    cpdef Diag adjoint(self):
+        return adjoint_diag(self)
+
+    cpdef Diag conj(self):
+        return conj_diag(self)
+
+    cpdef Diag transpose(self):
+        return transpose_diag(self)
+    """
+
+    def __repr__(self):
+        return "".join([
+            "Diag(shape=", str(self.shape), ", num_diag=", str(self.num_diag), ")",
+        ])
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __dealloc__(self):
+        # If we have a reference to a scipy type, then we've passed ownership
+        # of the data to numpy, so we let it handle refcounting and we don't
+        # need to deallocate anything ourselves.
+        if not self._deallocate:
+            return
+        if self.data != NULL:
+            PyDataMem_FREE(self.data)
+        if self.offsets != NULL:
+            PyDataMem_FREE(self.offsets)
+
+
+cpdef Diag fast_from_scipy(object sci):
+    """
+    Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
+    checking on any of the inputs, and should consequently be considered very
+    unsafe.  This is primarily for use in the unpickling operation.
+    """
+    cdef Diag out = Diag.__new__(Diag)
+    out.shape = sci.shape
+    out._deallocate = False
+    out._scipy = sci
+    out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
+    out.offsets = <base.idxint *> cnp.PyArray_GETPTR1(sci.offsets, 0)
+    out.num_diag  = sci.offsets.shape[0]
+    out.size = sci.data.shape[1]
+    return out
+
+
+cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.idxint size):
+    """
+    Allocate an empty Diag matrix of the given shape, ``with num_diag``
+    diagonals.
+
+    This does not initialise any of the memory returned.
+    """
+    if num_diag < 0:
+        raise ValueError("num_diag must be a positive integer.")
+    cdef Diag out = Diag.__new__(Diag)
+    out.shape = (rows, cols)
+    out.num_diag = num_diag
+    out.size = size
+    # Python doesn't like allocating nothing.
+    if size == 0:
+        size += 1
+    if num_diag == 0:
+        num_diag += 1
+    out.data =\
+        <double complex *> PyDataMem_NEW(size * num_diag * sizeof(double complex))
+    out.offsets =\
+        <base.idxint *> PyDataMem_NEW(num_diag * sizeof(base.idxint))
+    return out
+
+
+cpdef Diag empty_like(Diag other):
+    return empty(other.shape[0], other.shape[1], other.num_diag, other.size)
+
+
+cpdef Diag zeros(base.idxint rows, base.idxint cols):
+    """
+    Allocate the zero matrix with a given shape.  There will not be any room in
+    the `data` and `col_index` buffers to add new elements.
+    """
+    # We always allocate matrices with at least one element to ensure that we
+    # actually _are_ asking for memory (Python doesn't like allocating nothing)
+    cdef Diag out = empty(rows, cols, 1, 1)
+    memset(out.data, 0, out.size * sizeof(double complex))
+    out.offsets[0] = 0
+    out.num_diag = 0
+    return out
+
+
+cpdef Diag identity(base.idxint dimension, double complex scale=1):
+    """
+    Return a square matrix of the specified dimension, with a constant along
+    the diagonal.  By default this will be the identity matrix, but if `scale`
+    is passed, then the result will be `scale` times the identity.
+    """
+    cdef Diag out = empty(dimension, dimension, 1, dimension)
+    memset(out.data, 1, out.shape[1] * sizeof(double complex))
+    out.offsets[0] = 0
+    return out
+
+
+cpdef Diag from_dense(Dense matrix):
+    # Assume worst-case scenario for non-zero.
+    cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1, matrix.shape[1])
+    cdef size_t diag_, ptr_in, ptr_out=0, stride
+    cdef row, col
+
+    for i in range(matrix.shape[0] + matrix.shape[1] - 1):
+        out.offsets[i] = i -matrix.shape[0] + 1
+    strideR = matrix.shape[0] if matrix.fortran else 1
+    strideC = matrix.shape[1] if not matrix.fortran else 1
+
+    for row in range(matrix.shape[0]):
+        for col in range(matrix.shape[1]):
+            out.data[(-(-col+row) -matrix.shape[1]) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
+
+    return tidyup_diag(out)
+
+
+cpdef tidyup_diag(mat, atol=1e-5, inplace=False):
+    if inplace:
+        raise Exception()
+    data = mat.data
+    offsets = mat.offsets
+    new_offsets = []
+    diags = []
+    for diag, line in zip(offsets, data):
+        has_data = False
+        for val in line:
+            has_data |= abs(val) > atol
+            if has_data:
+                break
+        if not has_data:
+            continue
+        new_offsets.append(diag)
+        diags.append(line)
+    data = np.vstack(diags)
+    offsets = np.array(new_offsets)
+    return data, offsets
+
+
+cdef inline base.idxint _diagonal_length(
+    base.idxint offset, base.idxint n_rows, base.idxint n_cols,
+) nogil:
+    if offset > 0:
+        return n_rows if offset <= n_cols - n_rows else n_cols - offset
+    return n_cols if offset > n_cols - n_rows else n_rows + offset
+
+
+cdef Diag diags_(
+    list diagonals, base.idxint[:] offsets,
+    base.idxint n_rows, base.idxint n_cols,
+):
+    """
+    Construct a Diag matrix from a list of diagonals and their offsets.  The
+    offsets are assumed to be in sorted order.  This is the C-only interface to
+    diag.diags, and inputs are not sanity checked (use the Python interface for
+    that).
+
+    Parameters
+    ----------
+    diagonals : list of indexable of double complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal (not checked).
+
+    offsets : idxint[:]
+        The indices of the diagonals.  These should be sorted and without
+        duplicates.  `offsets[i]` is the location of the values `diagonals[i]`.
+        An offset of 0 is the main diagonal, positive values are above the main
+        diagonal and negative ones are below the main diagonal.
+
+    n_rows, n_cols : idxint
+        The shape of the output.  The result does not need to be square, but
+        the diagonals must be of the correct length to fit in.
+    """
+    out = empty(n_rows, n_cols, len(offsets), n_cols)
+    for i in range(len(offsets)):
+        out.offsets[i] = offsets[i]
+        offset = max(offsets[i], 0)
+        for col in range(len(diagonals[i])):
+            out.data[i * out.size + col + offset] = diagonals[i][col]
+    return out
+
+@cython.wraparound(True)
+def diags(diagonals, offsets=None, shape=None):
+    """
+    Construct a Diag matrix from diagonals and their offsets.  Using this
+    function in single-argument form produces a square matrix with the given
+    values on the main diagonal.
+
+    With lists of diagonals and offsets, the matrix will be the smallest
+    possible square matrix if shape is not given, but in all cases the
+    diagonals must fit exactly with no extra or missing elements.  Duplicated
+    diagonals will be summed together in the output.
+
+    Parameters
+    ----------
+    diagonals : sequence of array_like of complex or array_like of complex
+        The entries (including zeros) that should be placed on the diagonals in
+        the output matrix.  Each entry must have enough entries in it to fill
+        the relevant diagonal and no more.
+
+    offsets : sequence of integer or integer, optional
+        The indices of the diagonals.  `offsets[i]` is the location of the
+        values `diagonals[i]`.  An offset of 0 is the main diagonal, positive
+        values are above the main diagonal and negative ones are below the main
+        diagonal.
+
+    shape : tuple, optional
+        The shape of the output as (``rows``, ``columns``).  The result does
+        not need to be square, but the diagonals must be of the correct length
+        to fit in exactly.
+    """
+    cdef base.idxint n_rows, n_cols, offset
+    try:
+        diagonals = list(diagonals)
+        if diagonals and np.isscalar(diagonals[0]):
+            # Catch the case where we're being called as (for example)
+            #   diags([1, 2, 3], 0)
+            # with a single diagonal and offset.
+            diagonals = [diagonals]
+    except TypeError:
+        raise TypeError("diagonals must be a list of arrays of complex") from None
+    if offsets is None:
+        if len(diagonals) == 0:
+            offsets = []
+        elif len(diagonals) == 1:
+            offsets = [0]
+        else:
+            raise TypeError("offsets must be supplied if passing more than one diagonal")
+    offsets = np.atleast_1d(offsets)
+    if offsets.ndim > 1:
+        raise ValueError("offsets must be a 1D array of integers")
+    if len(diagonals) != len(offsets):
+        raise ValueError("number of diagonals does not match number of offsets")
+    if len(diagonals) == 0:
+        if shape is None:
+            raise ValueError("cannot construct matrix with no diagonals without a shape")
+        else:
+            n_rows, n_cols = shape
+        return zeros(n_rows, n_cols)
+    order = np.argsort(offsets)
+    diagonals_ = []
+    offsets_ = []
+    prev, cur = None, None
+    for i in order:
+        cur = offsets[i]
+        if cur == prev:
+            diagonals_[-1] += np.asarray(diagonals[i], dtype=np.complex128)
+        else:
+            offsets_.append(cur)
+            diagonals_.append(np.asarray(diagonals[i], dtype=np.complex128))
+        prev = cur
+    if shape is None:
+        n_rows = n_cols = abs(offsets_[0]) + len(diagonals_[0])
+    else:
+        try:
+            n_rows, n_cols = shape
+        except (TypeError, ValueError):
+            raise TypeError("shape must be a 2-tuple of positive integers")
+        if n_rows < 0 or n_cols < 0:
+            raise ValueError("shape must be a 2-tuple of positive integers")
+    for i in range(len(diagonals_)):
+        offset = offsets_[i]
+        if len(diagonals_[i]) != _diagonal_length(offset, n_rows, n_cols):
+            raise ValueError("given diagonals do not have the correct lengths")
+    if n_rows == 0 and n_cols == 0:
+        raise ValueError("can't produce a 0x0 matrix")
+    return diags_(
+        diagonals_, np.array(offsets_, dtype=idxint_dtype), n_rows, n_cols,
+    )
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
new file mode 100644
index 0000000000..2dad7da47c
--- /dev/null
+++ b/qutip/tests/core/data/test_diag.py
@@ -0,0 +1,328 @@
+import numpy as np
+import scipy.sparse
+import pytest
+
+from qutip.core import data
+from qutip.core.data import dense, dia
+
+from . import conftest
+
+# We only choose a small subset of dtypes to test so it isn't crazy.
+_dtype_complex = ['complex128']
+_dtype_float = ['float64']
+_dtype_int = ['int32', 'int64']
+_dtype_uint = ['uint32']
+
+
+# Set up some fixtures for automatic parametrisation.
+
+@pytest.fixture(params=[
+    pytest.param((1, 5), id='ket'),
+    pytest.param((5, 1), id='bra'),
+    pytest.param((5, 5), id='square'),
+    pytest.param((2, 4), id='wide'),
+    pytest.param((4, 2), id='tall'),
+])
+def shape(request): return request.param
+
+
+def random_scipy_dia(shape, density):
+    num_diag = int(density * (shape[0] + shape[1] - 1)) or 1
+    offsets = []
+    data = []
+    for diag in np.random.choice(np.arange(-shape[0] + 1, shape[1]), num_diag, replace=False):
+        offsets.append(diag)
+        num_elements = min(shape[0]+diag, shape[1]-diag)
+        data.append(np.random.rand(num_elements) + 1j*np.random.rand(num_elements))
+    return scipy.sparse.diags(data, offsets).todia()
+
+
+@pytest.fixture(scope='function')
+def scipy_dia(shape, density):
+    return random_scipy_dia(shape, density)
+
+
+def _valid_scipy():
+    """Arbitrary valid scipy Diag"""
+    return random_scipy_dia((10, 10), 0.5)
+
+
+def _valid_arg():
+    """
+    Arbitrary valid 3-tuple which is a valid `arg` parameter for __init__.
+    """
+    sci = _valid_scipy()
+    return (sci.data, sci.offsets)
+
+
+@pytest.fixture(scope='function')
+def data_diag(shape, density):
+    return dia.Diag(random_scipy_dia(shape, density))
+
+
+class TestClassMethods:
+    def test_init_from_scipy(self, scipy_dia):
+        """Test that __init__ can accept a scipy dia matrix."""
+        out = dia.Diag(scipy_dia)
+        assert out.shape == scipy_dia.shape
+        assert (out.as_scipy() - scipy_dia).nnz == 0
+
+    def test_init_from_tuple(self, scipy_dia):
+        """
+        Test that __init__ does not throw when passed a 3-tuple.  Also tests
+        the as_scipy() method succeeds.
+        """
+        arg = (scipy_dia.data, scipy_dia.offsets)
+        out = data.Diag(arg, shape=scipy_dia.shape)
+        assert out.shape == scipy_dia.shape
+        assert (out.as_scipy() - scipy_dia).nnz == 0
+
+    @pytest.mark.parametrize('d_type', (
+        _dtype_complex + _dtype_float + _dtype_int + _dtype_uint
+    ))
+    @pytest.mark.parametrize('o_type', _dtype_int + _dtype_uint)
+    def test_init_from_tuple_allowed_dtypes(self, d_type, o_type):
+        """
+        Test that initialisation can use a variety of dtypes and converts into
+        the correct type.
+        """
+        sci = _valid_scipy()
+        data = sci.data.astype(d_type, casting='unsafe')
+        offsets = sci.offsets.astype(o_type, casting='unsafe')
+        scipy_dia = scipy.sparse.dia_matrix((data, offsets), shape=sci.shape)
+        out = dia.Diag((data, offsets), shape=sci.shape)
+        out_scipy = out.as_scipy()
+        assert out.shape == scipy_dia.shape
+        assert out_scipy.data.dtype == np.complex128
+        assert (out_scipy - scipy_dia).nnz == 0
+
+    @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
+        pytest.param((), {}, ValueError, id="arg 0 tuple"),
+        pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
+        pytest.param((None,)*2, {}, ValueError, id="arg None tuple"),
+        pytest.param((None,)*3, {}, TypeError, id="arg 3 tuple"),
+        pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
+                     id="scipy-shape 0 tuple"),
+        pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
+                     id="scipy-shape 1 tuple"),
+        pytest.param(_valid_scipy(), {'shape': (None, None)}, ValueError,
+                     id="scipy-shape None tuple"),
+        pytest.param(_valid_scipy(), {'shape': [2, 2]}, ValueError,
+                     id="scipy-shape list"),
+        pytest.param(_valid_scipy(), {'shape': (1, 2, 3)}, ValueError,
+                     id="scipy-shape 3 tuple"),
+        pytest.param(_valid_arg(), {'shape': ()}, ValueError,
+                     id="arg-shape 0 tuple"),
+        pytest.param(_valid_arg(), {'shape': (1,)}, ValueError,
+                     id="arg-shape 1 tuple"),
+        pytest.param(_valid_arg(), {'shape': (None, None)}, ValueError,
+                     id="arg-shape None tuple"),
+        pytest.param(_valid_arg(), {'shape': [2, 2]}, TypeError,
+                     id="arg-shape list"),
+        pytest.param(_valid_arg(), {'shape': (1, 2, 3)}, ValueError,
+                     id="arg-shape 3 tuple"),
+        pytest.param(_valid_arg(), {'shape': (-1, -1)}, ValueError,
+                     id="arg-negative shape"),
+    ])
+    def test_init_from_wrong_input(self, arg, kwargs, error):
+        """
+        Test that the __init__ method raises a suitable error when passed
+        incorrectly formatted inputs.
+
+        This test also serves as a *partial* check that Diag safely handles
+        deallocation in the presence of exceptions in its __init__ method.  If
+        the tests segfault, it's quite likely that the memory management isn't
+        being done correctly in the hand-off us setting our data buffers up and
+        marking the numpy actually owns the data.
+        """
+        with pytest.raises(error):
+            dia.Diag(arg, **kwargs)
+
+    def test_copy_returns_a_correct_copy(self, data_diag):
+        """
+        Test that the copy() method produces an actual copy, and that the
+        result represents the same matrix.
+        """
+        original = data_diag
+        copy = data_diag.copy()
+        assert original is not copy
+        assert original.data is not copy.data
+        assert original.offsets is not copy.offsets
+        assert np.all(original.to_array() == copy.to_array())
+
+    def test_as_scipy_returns_a_view(self, data_diag):
+        """
+        Test that modifying the views in the result of as_scipy() also modifies
+        the underlying data structures.  This is important for allowing minor
+        data modifications from within Python-space.
+        """
+        unmodified_copy = data_diag.copy()
+        data_diag.as_scipy().data += 1
+        modified_copy = data_diag.copy()
+        assert np.any(data_diag.as_ndarray() != unmodified_copy.as_ndarray())
+        assert np.all(data_diag.as_ndarray() == modified_copy.as_ndarray())
+
+    def test_as_scipy_caches_result(self, data_diag):
+        """
+        Test that the as_scipy() method always returns the same view, even if
+        called multiple times.
+        """
+        assert data_diag.as_scipy() is data_diag.as_scipy()
+
+    def test_as_scipy_of_dia_from_scipy_is_different(self, scipy_dia):
+        """
+        Test that we produce a new scipy matrix, regardless of how we have
+        initialised the type.
+        """
+        assert dia.Diag(scipy_dia).as_scipy() is not scipy_dia
+
+    def test_as_scipy_of_copy_is_different(self, data_diag):
+        """
+        Test that as_scipy() does not return the same array, or the same views
+        if it's not the same input matrix.  We don't want two Diag matrices to
+        be linked.
+        """
+        original = data_diag.as_scipy()
+        copy = data_diag.copy().as_scipy()
+        assert original is not copy
+        assert not np.may_share_memory(original.data, copy.data)
+        assert not np.may_share_memory(original.offsets, copy.offsets)
+
+    def test_as_ndarray_is_correct_result(self, scipy_dia):
+        """
+        Test that as_ndarray is actually giving the matrix we expect for a given
+        input.
+        """
+        data_diag = dia.Diag(scipy_dia)
+        assert isinstance(data_diag.as_scipy(), scipy.sparse.dia_matrix)
+        assert (data_diag.as_scipy() - scipy_dia).nnz == 0
+
+    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
+        ndiag = int(shape[0] * shape[1] * density) or 1
+        base = dia.empty(shape[0], shape[1], ndiag, shape[1])
+        sci = base.as_scipy()
+        assert sci.num_diag == 0
+        assert len(sci.data) == 0
+        assert len(sci.offsets) == 0
+
+    def test_to_array_is_correct_result(self, data_diag):
+        test_array = data_diag.to_array()
+        assert isinstance(test_array, np.ndarray)
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(test_array == data_diag.as_scipy().toarray())
+
+
+class TestFactoryMethods:
+    def test_empty(self, shape, density):
+        ndiag = int(shape[0] * shape[1] * density) or 1
+        size = np.random.randint(shape[1]) or 1
+        base = dia.empty(shape[0], shape[1], nnz, size)
+        sci = base.as_scipy()
+        assert isinstance(base, dia.Diag)
+        assert isinstance(sci, scipy.sparse.dia_matrix)
+        assert base.shape == shape
+        assert sci.data.shape == (ndiag, size)
+        assert sci.offsets.shape == (ndiag,)
+
+    def test_zeros(self, shape):
+        base = dia.zeros(shape[0], shape[1])
+        sci = base.as_scipy()
+        assert isinstance(base, dia.Diag)
+        assert base.shape == shape
+        assert sci.nnz == 0
+        assert np.all(base.to_array() == 0)
+
+    @pytest.mark.parametrize('dimension', [1, 5, 100])
+    @pytest.mark.parametrize(
+        'scale',
+        [None, 2, -0.1, 1.5, 1.5+1j],
+        ids=['none', 'int', 'negative', 'float', 'complex']
+    )
+    def test_identity(self, dimension, scale):
+        # scale=None is testing that the default value returns the identity.
+        base = (dia.identity(dimension) if scale is None
+                else dia.identity(dimension, scale))
+        sci = base.as_scipy()
+        scipy_test = scipy.sparse.eye(dimension,
+                                      dtype=np.complex128, format='dia')
+        if scale is not None:
+            scipy_test *= scale
+        assert isinstance(base, dia.Diag)
+        assert base.shape == (dimension, dimension)
+        assert sci.nnz == dimension
+        assert (sci - scipy_test).nnz == 0
+
+
+    @pytest.mark.parametrize(['diagonals', 'offsets', 'shape'], [
+        pytest.param([2j, 3, 5, 9], None, None, id='main diagonal'),
+        pytest.param([1], None, None, id='1x1'),
+        pytest.param([[0.2j, 0.3]], None, None, id='main diagonal list'),
+        pytest.param([0.2j, 0.3], 2, None, id='superdiagonal'),
+        pytest.param([0.2j, 0.3], -2, None, id='subdiagonal'),
+        pytest.param([[0.2, 0.3, 0.4], [0.1, 0.9]], [-2, 3], None,
+                     id='two diagonals'),
+        pytest.param([1, 2, 3], 0, (3, 5), id='main wide'),
+        pytest.param([1, 2, 3], 0, (5, 3), id='main tall'),
+        pytest.param([[1, 2, 3], [4, 5]], [-1, -2], (4, 8), id='two wide sub'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [1, 2], (4, 8),
+                     id='two wide super'),
+        pytest.param([[1, 2, 3], [4, 5]], [1, 2], (8, 4), id='two tall super'),
+        pytest.param([[1, 2, 3, 4], [4, 5, 4j, 1j]], [-1, -2], (8, 4),
+                     id='two tall sub'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, -1, -2], (4, 4),
+                     id='out of order'),
+        pytest.param([[1, 2, 3], [4, 5, 6], [1, 2]], [1, 1, -2], (4, 4),
+                     id='sum duplicates'),
+    ])
+    def test_diags(self, diagonals, offsets, shape):
+        base = dia.diags(diagonals, offsets, shape)
+        # Build numpy version test.
+        if not isinstance(diagonals[0], list):
+            diagonals = [diagonals]
+        offsets = np.atleast_1d(offsets if offsets is not None else [0])
+        if shape is None:
+            size = len(diagonals[0]) + abs(offsets[0])
+            shape = (size, size)
+        test = np.zeros(shape, dtype=np.complex128)
+        for diagonal, offset in zip(diagonals, offsets):
+            test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
+        assert isinstance(base, dia.Diag)
+        assert base.shape == shape
+        np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
+
+    """
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((1, 1), (0, 0), None, id='minimal'),
+        pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
+        pytest.param((10, 10), (1, 5), 1., id='upper'),
+        pytest.param((10, 10), (5, 1), 2., id='lower'),
+        pytest.param((10, 1), (5, 0), None, id='column'),
+        pytest.param((1, 10), (0, 5), -5.j, id='row'),
+        pytest.param((10, 2), (5, 1), 1+2j, id='tall'),
+        pytest.param((2, 10), (1, 5), 10, id='wide'),
+    ])
+    def test_one_element(self, shape, position, value):
+        test = np.zeros(shape, dtype=np.complex128)
+        if value is None:
+            base = data.one_element_dense(shape, position)
+            test[position] = 1.0+0.0j
+        else:
+            base = data.one_element_dense(shape, position, value)
+            test[position] = value
+        assert isinstance(base, data.Dense)
+        assert base.shape == shape
+        assert np.allclose(base.to_array(), test, atol=1e-10)
+
+    @pytest.mark.parametrize(['shape', 'position', 'value'], [
+        pytest.param((0, 0), (0, 0), None, id='zero shape'),
+        pytest.param((10, -2), (5, 0), 1.j, id='neg shape'),
+        pytest.param((10, 10), (10, 5), 1., id='outside'),
+        pytest.param((10, 10), (5, -1), 2., id='outside neg'),
+    ])
+    def test_one_element_error(self, shape, position, value):
+        with pytest.raises(ValueError) as exc:
+            base = data.one_element_dense(shape, position, value)
+        assert str(exc.value).startswith("Position of the elements"
+                                         " out of bound: ")
+    """

From 9ec4655ea13b02c7708211163f4d28ca8690c33d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 25 Apr 2023 17:32:14 -0400
Subject: [PATCH 351/602] More test passing

---
 qutip/core/data/dia.pyx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 3fac4026c2..7ea29e3d76 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -294,7 +294,8 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
     is passed, then the result will be `scale` times the identity.
     """
     cdef Diag out = empty(dimension, dimension, 1, dimension)
-    memset(out.data, 1, out.shape[1] * sizeof(double complex))
+    for i in range(dimension):
+        out.data[i] = scale
     out.offsets[0] = 0
     return out
 

From 52bda3b2daa387ce9c5810694360921769ab0491 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 26 Apr 2023 13:18:35 -0400
Subject: [PATCH 352/602] All tests passes

---
 qutip/core/data/dia.pxd            |  2 +-
 qutip/core/data/dia.pyx            |  6 ++++--
 qutip/tests/core/data/test_diag.py | 34 +++++++++++++++++-------------
 3 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index 7e05f1b66d..8904da08e0 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -16,7 +16,7 @@ from qutip.core.data cimport base
 cdef class Diag(base.Data):
     cdef double complex *data
     cdef base.idxint *offsets
-    cdef size_t num_diag, size
+    cdef readonly size_t num_diag, size
     cdef object _scipy
     cdef bint _deallocate
     cpdef Diag copy(Diag self)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 7ea29e3d76..43fdcaae6c 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -83,6 +83,7 @@ cdef class Diag(base.Data):
                     "shapes do not match: ", str(shape), " and ", str(arg.shape),
                 ]))
             shape = arg.shape
+            #
             arg = (arg.data, arg.offsets)
         if not isinstance(arg, tuple):
             raise TypeError("arg must be a scipy matrix or tuple")
@@ -157,10 +158,11 @@ cdef class Diag(base.Data):
         cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
         cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
         cdef size_t col, i, nrows = self.shape[0]
-        cdef base.idxint diag
+        cdef base.idxint diag, size
+        size = self.size if self.size < self.shape[1] else self.shape[1]
         for i in range(self.num_diag):
             diag = self.offsets[i]
-            for col in range(self.size):
+            for col in range(size):
                 if col - diag < 0 or col - diag >= nrows:
                     continue
                 out[(col-diag), col] = self.data[i * self.size + col]
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 2dad7da47c..be4248448a 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -25,6 +25,13 @@
 ])
 def shape(request): return request.param
 
+@pytest.fixture(params=[
+    pytest.param(0, id='empty'),
+    pytest.param(1, id='full'),
+    pytest.param(0.2, id='sparse'),
+])
+def density(request): return request.param
+
 
 def random_scipy_dia(shape, density):
     num_diag = int(density * (shape[0] + shape[1] - 1)) or 1
@@ -32,9 +39,9 @@ def random_scipy_dia(shape, density):
     data = []
     for diag in np.random.choice(np.arange(-shape[0] + 1, shape[1]), num_diag, replace=False):
         offsets.append(diag)
-        num_elements = min(shape[0]+diag, shape[1]-diag)
+        num_elements = min(shape[0], shape[1], shape[0] + diag, shape[1] - diag)
         data.append(np.random.rand(num_elements) + 1j*np.random.rand(num_elements))
-    return scipy.sparse.diags(data, offsets).todia()
+    return scipy.sparse.diags(data, offsets, shape=shape).todia()
 
 
 @pytest.fixture(scope='function')
@@ -73,7 +80,7 @@ def test_init_from_tuple(self, scipy_dia):
         the as_scipy() method succeeds.
         """
         arg = (scipy_dia.data, scipy_dia.offsets)
-        out = data.Diag(arg, shape=scipy_dia.shape)
+        out = dia.Diag(arg, shape=scipy_dia.shape)
         assert out.shape == scipy_dia.shape
         assert (out.as_scipy() - scipy_dia).nnz == 0
 
@@ -99,8 +106,8 @@ def test_init_from_tuple_allowed_dtypes(self, d_type, o_type):
     @pytest.mark.parametrize(['arg', 'kwargs', 'error'], [
         pytest.param((), {}, ValueError, id="arg 0 tuple"),
         pytest.param((None,), {}, ValueError, id="arg 1 tuple"),
-        pytest.param((None,)*2, {}, ValueError, id="arg None tuple"),
-        pytest.param((None,)*3, {}, TypeError, id="arg 3 tuple"),
+        pytest.param((None,)*2, {}, TypeError, id="arg None tuple"),
+        pytest.param((None,)*3, {}, ValueError, id="arg 3 tuple"),
         pytest.param(_valid_scipy(), {'shape': ()}, ValueError,
                      id="scipy-shape 0 tuple"),
         pytest.param(_valid_scipy(), {'shape': (1,)}, ValueError,
@@ -146,8 +153,6 @@ def test_copy_returns_a_correct_copy(self, data_diag):
         original = data_diag
         copy = data_diag.copy()
         assert original is not copy
-        assert original.data is not copy.data
-        assert original.offsets is not copy.offsets
         assert np.all(original.to_array() == copy.to_array())
 
     def test_as_scipy_returns_a_view(self, data_diag):
@@ -159,8 +164,8 @@ def test_as_scipy_returns_a_view(self, data_diag):
         unmodified_copy = data_diag.copy()
         data_diag.as_scipy().data += 1
         modified_copy = data_diag.copy()
-        assert np.any(data_diag.as_ndarray() != unmodified_copy.as_ndarray())
-        assert np.all(data_diag.as_ndarray() == modified_copy.as_ndarray())
+        assert np.any(data_diag.to_array() != unmodified_copy.to_array())
+        assert np.all(data_diag.to_array() == modified_copy.to_array())
 
     def test_as_scipy_caches_result(self, data_diag):
         """
@@ -188,20 +193,19 @@ def test_as_scipy_of_copy_is_different(self, data_diag):
         assert not np.may_share_memory(original.data, copy.data)
         assert not np.may_share_memory(original.offsets, copy.offsets)
 
-    def test_as_ndarray_is_correct_result(self, scipy_dia):
+    def test_as_scipy_is_correct_result(self, scipy_dia):
         """
-        Test that as_ndarray is actually giving the matrix we expect for a given
+        Test that as_scipy is actually giving the matrix we expect for a given
         input.
         """
         data_diag = dia.Diag(scipy_dia)
         assert isinstance(data_diag.as_scipy(), scipy.sparse.dia_matrix)
         assert (data_diag.as_scipy() - scipy_dia).nnz == 0
 
-    def test_as_scipy_of_uninitialised_is_empty(self, shape, density):
-        ndiag = int(shape[0] * shape[1] * density) or 1
+    def test_as_scipy_of_uninitialised_is_empty(self, shape):
+        ndiag = 0
         base = dia.empty(shape[0], shape[1], ndiag, shape[1])
         sci = base.as_scipy()
-        assert sci.num_diag == 0
         assert len(sci.data) == 0
         assert len(sci.offsets) == 0
 
@@ -217,7 +221,7 @@ class TestFactoryMethods:
     def test_empty(self, shape, density):
         ndiag = int(shape[0] * shape[1] * density) or 1
         size = np.random.randint(shape[1]) or 1
-        base = dia.empty(shape[0], shape[1], nnz, size)
+        base = dia.empty(shape[0], shape[1], ndiag, size)
         sci = base.as_scipy()
         assert isinstance(base, dia.Diag)
         assert isinstance(sci, scipy.sparse.dia_matrix)

From cd27cf2d8a923f67099f16faa467ab0213ff5736 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 26 Apr 2023 16:18:45 -0400
Subject: [PATCH 353/602] Add first specializations

---
 qutip/core/data/__init__.pxd              |  1 +
 qutip/core/data/__init__.py               |  5 ++
 qutip/core/data/_creator_utils.py         |  2 +-
 qutip/core/data/adjoint.pxd               |  5 ++
 qutip/core/data/adjoint.pyx               | 57 +++++++++++++++++++++--
 qutip/core/data/dia.pxd                   | 16 +++++--
 qutip/core/data/dia.pyx                   | 10 ++--
 qutip/core/data/trace.pxd                 |  4 +-
 qutip/core/data/trace.pyx                 | 28 +++++++++--
 qutip/tests/core/data/conftest.py         | 19 ++++++++
 qutip/tests/core/data/test_diag.py        | 17 ++-----
 qutip/tests/core/data/test_mathematics.py | 27 ++++++++++-
 12 files changed, 159 insertions(+), 32 deletions(-)

diff --git a/qutip/core/data/__init__.pxd b/qutip/core/data/__init__.pxd
index c1b4e6809d..cbd9ce5856 100644
--- a/qutip/core/data/__init__.pxd
+++ b/qutip/core/data/__init__.pxd
@@ -5,6 +5,7 @@ from qutip.core.data cimport dense, csr
 from qutip.core.data.base cimport Data, idxint
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.csr cimport CSR
+from qutip.core.data.dia cimport Diag
 
 from qutip.core.data.add cimport *
 from qutip.core.data.adjoint cimport *
diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index ad50f1fced..386c9b6750 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -3,6 +3,7 @@
 from . import dense, csr
 from .dense import Dense
 from .csr import CSR
+from .dia import Diag
 from .base import Data
 
 from .add import *
@@ -37,9 +38,12 @@
 to.add_conversions([
     (Dense, CSR, dense.from_csr, 1),
     (CSR, Dense, csr.from_dense, 1.4),
+    (Diag, Dense, dia.from_dense, 1.4),
+    (Dense, Diag, dia.to_dense, 1),
 ])
 to.register_aliases(['csr', 'CSR'], CSR)
 to.register_aliases(['Dense', 'dense'], Dense)
+to.register_aliases(['Diag', 'dia', 'diag'], Diag)
 
 
 from . import _creator_utils
@@ -47,6 +51,7 @@
 create.add_creators([
     (_creator_utils.is_data, _creator_utils.data_copy, 100),
     (_creator_utils.isspmatrix_csr, CSR, 80),
+    (_creator_utils.isspmatrix_dia, Diag, 80),
     (_creator_utils.is_nparray, Dense, 80),
     (_creator_utils.issparse, CSR, 20),
     (_creator_utils.true, Dense, -np.inf),
diff --git a/qutip/core/data/_creator_utils.py b/qutip/core/data/_creator_utils.py
index 3f3779e219..c90b2aa8e6 100644
--- a/qutip/core/data/_creator_utils.py
+++ b/qutip/core/data/_creator_utils.py
@@ -2,7 +2,7 @@
 Define functions to use as Data creator for `create` in `convert.py`.
 """
 
-from scipy.sparse import isspmatrix_csr, issparse
+from scipy.sparse import isspmatrix_csr, issparse, isspmatrix_dia
 import numpy as np
 from .csr import CSR
 from .base import Data
diff --git a/qutip/core/data/adjoint.pxd b/qutip/core/data/adjoint.pxd
index 793aac6409..4e61c1a24e 100644
--- a/qutip/core/data/adjoint.pxd
+++ b/qutip/core/data/adjoint.pxd
@@ -2,6 +2,7 @@
 
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.dia cimport Diag
 
 cpdef CSR adjoint_csr(CSR matrix)
 cpdef CSR transpose_csr(CSR matrix)
@@ -10,3 +11,7 @@ cpdef CSR conj_csr(CSR matrix)
 cpdef Dense adjoint_dense(Dense matrix)
 cpdef Dense transpose_dense(Dense matrix)
 cpdef Dense conj_dense(Dense matrix)
+
+cpdef Diag adjoint_diag(Diag matrix)
+cpdef Diag transpose_diag(Diag matrix)
+cpdef Diag conj_diag(Diag matrix)
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index 9facfffcc3..356bc03470 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -8,16 +8,17 @@ cimport cython
 from qutip.core.data.base cimport idxint
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data cimport csr, dense
+from qutip.core.data.dia cimport Diag
+from qutip.core.data cimport csr, dense, dia
 
 # Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
 cdef extern from "<complex>" namespace "std" nogil:
     double complex _conj "conj"(double complex x)
 
 __all__ = [
-    'adjoint', 'adjoint_csr', 'adjoint_dense',
-    'conj', 'conj_csr', 'conj_dense',
-    'transpose', 'transpose_csr', 'transpose_dense',
+    'adjoint', 'adjoint_csr', 'adjoint_dense', 'adjoint_diag',
+    'conj', 'conj_csr', 'conj_dense', 'conj_diag',
+    'transpose', 'transpose_csr', 'transpose_dense', 'transpose_diag',
 ]
 
 
@@ -109,6 +110,51 @@ cpdef Dense conj_dense(Dense matrix):
     return out
 
 
+cpdef Diag adjoint_diag(Diag matrix):
+    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag, matrix.shape[0])
+    cdef size_t i, new_i,
+    cdef idxint new_offset, j
+    with nogil:
+        for i in range(matrix.num_diag):
+            new_i = matrix.num_diag - i - 1
+            new_offset = out.offsets[new_i] = -matrix.offsets[i]
+            for j in range(out.size):
+                if (j < new_offset):
+                    out.data[new_i * out.size + j] = 0.
+                elif (j - new_offset >= matrix.size):
+                    out.data[new_i * out.size + j] = 0.
+                else:
+                    out.data[new_i * out.size + j] = _conj(matrix.data[i * matrix.size + j - new_offset])
+    return out
+
+
+cpdef Diag transpose_diag(Diag matrix):
+    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag, matrix.shape[0])
+    cdef size_t i, new_i,
+    cdef idxint new_offset, j
+    with nogil:
+        for i in range(matrix.num_diag):
+            new_i = matrix.num_diag - i - 1
+            new_offset = out.offsets[new_i] = -matrix.offsets[i]
+            for j in range(out.size):
+                if (j < new_offset) or (j - new_offset >= matrix.size):
+                    out.data[new_i * out.size + j] = 0.
+                else:
+                    out.data[new_i * out.size + j] = matrix.data[i * matrix.size + j - new_offset]
+    return out
+
+
+cpdef Diag conj_diag(Diag matrix):
+    cdef Diag out = dia.empty_like(matrix)
+    cdef size_t i, j
+    with nogil:
+        for i in range(matrix.num_diag):
+            out.offsets[i] = matrix.offsets[i]
+            for j in range(matrix.size):
+                out.data[i * matrix.size + j] = _conj(matrix.data[i * matrix.size + j])
+    return out
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -125,6 +171,7 @@ adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
 adjoint.add_specialisations([
     (Dense, Dense, adjoint_dense),
     (CSR, CSR, adjoint_csr),
+    (Diag, Diag, adjoint_diag),
 ], _defer=True)
 
 transpose = _Dispatcher(
@@ -140,6 +187,7 @@ transpose.__doc__ = """Transpose of a matrix."""
 transpose.add_specialisations([
     (Dense, Dense, transpose_dense),
     (CSR, CSR, transpose_csr),
+    (Diag, Diag, transpose_diag),
 ], _defer=True)
 
 conj = _Dispatcher(
@@ -155,6 +203,7 @@ conj.__doc__ = """Element-wise conjugation of a matrix."""
 conj.add_specialisations([
     (Dense, Dense, conj_dense),
     (CSR, CSR, conj_csr),
+    (Diag, Diag, conj_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index 8904da08e0..518dda541a 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -11,7 +11,7 @@
 # cimport numpy as cnp
 
 from qutip.core.data cimport base
-# from qutip.core.data.dense cimport Dense
+from qutip.core.data.dense cimport Dense
 
 cdef class Diag(base.Data):
     cdef double complex *data
@@ -22,6 +22,14 @@ cdef class Diag(base.Data):
     cpdef Diag copy(Diag self)
     cpdef object as_scipy(Diag self)
     #cpdef double complex trace(Diag self)
-    #cpdef Diag adjoint(Diag self)
-    #cpdef Diag conj(Diag self)
-    #cpdef Diag transpose(Diag self)
+    cpdef Diag adjoint(Diag self)
+    cpdef Diag conj(Diag self)
+    cpdef Diag transpose(Diag self)
+
+cpdef Diag fast_from_scipy(object sci)
+cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.idxint size)
+cpdef Diag empty_like(Diag other)
+cpdef Diag zeros(base.idxint rows, base.idxint cols)
+cpdef Diag identity(base.idxint dimension, double complex scale=*)
+cpdef Diag from_dense(Dense matrix)
+cpdef Dense to_dense(Diag matrix)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 43fdcaae6c..e8bc35793d 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -25,8 +25,8 @@ except ImportError:
 from scipy.linalg cimport cython_blas as blas
 
 from qutip.core.data cimport base, Dense
-# from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag#********************************
-# from qutip.core.data.trace import trace_diag#********************************
+from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag
+from qutip.core.data.trace import trace_diag
 # from qutip.core.data.tidyup import tidyup_diag #********************************
 from .base import idxint_dtype
 from qutip.settings import settings
@@ -195,7 +195,6 @@ cdef class Diag(base.Data):
         self._scipy = _dia_matrix(data, offsets, self.shape)
         return self._scipy
 
-    """
     cpdef double complex trace(self):
         return trace_diag(self)
 
@@ -207,7 +206,6 @@ cdef class Diag(base.Data):
 
     cpdef Diag transpose(self):
         return transpose_diag(self)
-    """
 
     def __repr__(self):
         return "".join([
@@ -320,6 +318,10 @@ cpdef Diag from_dense(Dense matrix):
     return tidyup_diag(out)
 
 
+cpdef Dense to_dense(Diag matrix):
+    return Dense(matrix.to_array(), copy=False)
+
+
 cpdef tidyup_diag(mat, atol=1e-5, inplace=False):
     if inplace:
         raise Exception()
diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index e231896f8f..25532dfc70 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -1,9 +1,11 @@
 #cython: language_level=3
 
-from qutip.core.data cimport CSR, Dense
+from qutip.core.data cimport CSR, Dense, Diag
 
 cpdef double complex trace_csr(CSR matrix) nogil except *
 cpdef double complex trace_dense(Dense matrix) nogil except *
+cpdef double complex trace_diag(Diag matrix) except * nogil
 
 cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
 cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
+cpdef double complex trace_oper_ket_diag(Diag matrix) except * nogil
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index d8f5cbf88b..211e716b29 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -4,12 +4,12 @@
 cimport cython
 from libc.math cimport sqrt
 
-from qutip.core.data cimport Data, CSR, Dense
+from qutip.core.data cimport Data, CSR, Dense, Diag
 from qutip.core.data cimport base
 
 __all__ = [
-    'trace', 'trace_csr', 'trace_dense',
-    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense',
+    'trace', 'trace_csr', 'trace_dense', 'trace_diag',
+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense', 'trace_oper_ket_diag',
 ]
 
 
@@ -48,6 +48,17 @@ cpdef double complex trace_dense(Dense matrix) nogil except *:
         ptr += stride
     return trace
 
+cpdef double complex trace_diag(Diag matrix) except * nogil:
+    _check_shape(matrix)
+    cdef double complex trace = 0
+    cdef size_t diag, j
+    for diag in range(matrix.num_diag):
+        if matrix.offsets[diag] == 0:
+            for j in range(matrix.size):
+                trace += matrix.data[diag * matrix.size + j]
+            break
+    return trace
+
 
 cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *:
     cdef size_t N = <size_t>sqrt(matrix.shape[0])
@@ -70,6 +81,17 @@ cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
         trace += matrix.data[ptr * stride]
     return trace
 
+cpdef double complex trace_oper_ket_diag(Diag matrix) except * nogil:
+    cdef size_t N = <size_t>sqrt(matrix.shape[0])
+    _check_shape_oper_ket(N, matrix)
+    cdef double complex trace = 0
+    cdef size_t diag = 0
+    cdef size_t stride = N + 1
+    for diag in range(matrix.num_diag):
+        if -matrix.offsets[diag] % stride == 0:
+            trace += matrix.data[diag * matrix.size]
+    return trace
+
 
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
index 01d05c01e8..d64f61e837 100644
--- a/qutip/tests/core/data/conftest.py
+++ b/qutip/tests/core/data/conftest.py
@@ -28,6 +28,20 @@ def shuffle_indices_scipy_csr(matrix):
     return out
 
 
+def random_scipy_dia(shape, density):
+    """
+    Generate a random scipy dia matrix with the given shape, density.
+    """
+    num_diag = int(density * (shape[0] + shape[1] - 1)) or 1
+    offsets = []
+    data = []
+    for diag in np.random.choice(np.arange(-shape[0] + 1, shape[1]), num_diag, replace=False):
+        offsets.append(diag)
+        num_elements = min(shape[0], shape[1], shape[0] + diag, shape[1] - diag)
+        data.append(np.random.rand(num_elements) + 1j*np.random.rand(num_elements))
+    return scipy.sparse.diags(data, offsets, shape=shape).todia()
+
+
 def random_scipy_csr(shape, density, sorted_):
     """
     Generate a random scipy CSR matrix with the given shape, nnz density, and
@@ -64,3 +78,8 @@ def random_csr(shape, density, sorted_):
 def random_dense(shape, fortran):
     """Generate a random qutip Dense matrix of the given shape."""
     return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
+
+
+def random_diag(shape, density):
+    """Generate a random qutip Diag matrix of the given shape and density"""
+    return qutip.core.data.Diag(random_scipy_dia(shape, density))
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index be4248448a..9f8509e977 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -33,25 +33,14 @@ def shape(request): return request.param
 def density(request): return request.param
 
 
-def random_scipy_dia(shape, density):
-    num_diag = int(density * (shape[0] + shape[1] - 1)) or 1
-    offsets = []
-    data = []
-    for diag in np.random.choice(np.arange(-shape[0] + 1, shape[1]), num_diag, replace=False):
-        offsets.append(diag)
-        num_elements = min(shape[0], shape[1], shape[0] + diag, shape[1] - diag)
-        data.append(np.random.rand(num_elements) + 1j*np.random.rand(num_elements))
-    return scipy.sparse.diags(data, offsets, shape=shape).todia()
-
-
 @pytest.fixture(scope='function')
 def scipy_dia(shape, density):
-    return random_scipy_dia(shape, density)
+    return conftest.random_scipy_dia(shape, density)
 
 
 def _valid_scipy():
     """Arbitrary valid scipy Diag"""
-    return random_scipy_dia((10, 10), 0.5)
+    return conftest.random_scipy_dia((10, 10), 0.5)
 
 
 def _valid_arg():
@@ -64,7 +53,7 @@ def _valid_arg():
 
 @pytest.fixture(scope='function')
 def data_diag(shape, density):
-    return dia.Diag(random_scipy_dia(shape, density))
+    return conftest.random_diag(shape, density)
 
 
 class TestClassMethods:
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index a220202c43..9774643b62 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -4,7 +4,7 @@
 import pytest
 
 from qutip.core import data
-from qutip.core.data import Data, Dense, CSR
+from qutip.core.data import Data, Dense, CSR, Diag
 
 from . import conftest
 
@@ -159,16 +159,36 @@ def factory(fortran):
     ]
 
 
+def cases_diag(shape):
+    """
+    Return a list of generators of the different special cases for Dense
+    matrices of a given shape.
+    """
+    def factory(density):
+        return lambda: conftest.random_diag(shape, density)
+
+    def zero_factory():
+        return lambda: data.dia.zeros(shape[0], shape[1])
+
+    return [
+        pytest.param(factory(0.001), id="sparse"),
+        pytest.param(factory(0.8), id="filled"),
+        pytest.param(zero_factory(), id="zero"),
+    ]
+
+
 # Factory methods for generating the cases, mapping type to the function.
 # _ALL_CASES is for getting all the special cases to test, _RANDOM is for
 # getting just a single case from each.
 _ALL_CASES = {
     CSR: cases_csr,
+    Diag: cases_diag,
     Dense: cases_dense,
 }
 _RANDOM = {
     CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
     Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
+    Diag: lambda shape: [lambda: conftest.random_diag(shape, 0.5)],
 }
 
 
@@ -568,6 +588,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.adjoint_csr, CSR, CSR),
         pytest.param(data.adjoint_dense, Dense, Dense),
+        pytest.param(data.adjoint_diag, Diag, Diag),
     ]
 
 
@@ -578,6 +599,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.conj_csr, CSR, CSR),
         pytest.param(data.conj_dense, Dense, Dense),
+        pytest.param(data.conj_diag, Diag, Diag),
     ]
 
 
@@ -801,6 +823,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.trace_csr, CSR, complex),
         pytest.param(data.trace_dense, Dense, complex),
+        pytest.param(data.trace_diag, Diag, complex),
     ]
 
 
@@ -821,6 +844,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.trace_oper_ket_csr, CSR, complex),
         pytest.param(data.trace_oper_ket_dense, Dense, complex),
+        pytest.param(data.trace_oper_ket_diag, Diag, complex),
     ]
 
 
@@ -886,6 +910,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.transpose_csr, CSR, CSR),
         pytest.param(data.transpose_dense, Dense, Dense),
+        pytest.param(data.transpose_diag, Diag, Diag),
     ]
 
 

From 796999ac0886ee317b5a8af2867d5533379b60a3 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 27 Apr 2023 13:20:36 -0400
Subject: [PATCH 354/602] Add temtative

---
 qutip/core/data/add.pxd                   |   3 +
 qutip/core/data/add.pyx                   |  99 ++++++++++++++-
 qutip/core/data/adjoint.pyx               |  25 ++--
 qutip/core/data/dia.pxd                   |   8 +-
 qutip/core/data/dia.pyx                   | 144 ++++++++++++++++------
 qutip/core/data/trace.pyx                 |   6 +-
 qutip/tests/core/data/test_diag.py        |   2 +-
 qutip/tests/core/data/test_mathematics.py |   2 +
 8 files changed, 229 insertions(+), 60 deletions(-)

diff --git a/qutip/core/data/add.pxd b/qutip/core/data/add.pxd
index edb30f14ae..1c207062ed 100644
--- a/qutip/core/data/add.pxd
+++ b/qutip/core/data/add.pxd
@@ -2,11 +2,14 @@
 
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.dia cimport Diag
 
 cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
 cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
 cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
+cpdef Diag add_diag(Diag left, Diag right, double complex scale=*)
 cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
 
 cpdef CSR sub_csr(CSR left, CSR right)
 cpdef Dense sub_dense(Dense left, Dense right)
+cpdef Diag sub_diag(Diag left, Diag right)
diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index e32ce46ca8..af5c061876 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -9,10 +9,11 @@ from qutip.settings import settings
 
 from qutip.core.data.base cimport idxint, Data
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.dia cimport Diag
 from qutip.core.data.csr cimport (
     CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
 )
-from qutip.core.data cimport csr, dense
+from qutip.core.data cimport csr, dense, dia
 
 cnp.import_array()
 
@@ -23,8 +24,8 @@ cdef extern from *:
 
 
 __all__ = [
-    'add', 'add_csr', 'add_dense', 'iadd_dense',
-    'sub', 'sub_csr', 'sub_dense',
+    'add', 'add_csr', 'add_dense', 'iadd_dense', 'add_diag',
+    'sub', 'sub_csr', 'sub_dense', 'sub_diag',
 ]
 
 
@@ -217,6 +218,92 @@ cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
     return left
 
 
+cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
+    _check_shape(left, right)
+    cdef idxint diag_left=0, diag_right=0, out_diag=0, i
+    cdef double complex *ptr_out,
+    cdef double complex *ptr_left
+    cdef double complex *ptr_right
+    cdef bint sorted=True
+    cdef Diag out = dia.empty(left.shape[0], left.shape[1], left.num_diag + right.num_diag, max(left._size, right._size))
+    cdef int length, size_left = left._size, size_right = right._size
+
+    ptr_out = out.data
+    ptr_left = left.data
+    ptr_right = right.data
+
+    with nogil:
+        while diag_left < left.num_diag and diag_right < right.num_diag:
+            if left.offsets[diag_left] == right.offsets[diag_right]:
+                out.offsets[out_diag] = left.offsets[diag_left]
+                blas.zcopy(&size_left, ptr_left, &_ONE, ptr_out, &_ONE)
+                blas.zaxpy(&size_right, &scale, ptr_right, &_ONE, ptr_out, &_ONE)
+                ptr_left += size_left
+                diag_left += 1
+                ptr_right += size_right
+                diag_right += 1
+            elif left.offsets[diag_left] <= right.offsets[diag_right]:
+                out.offsets[out_diag] = left.offsets[diag_left]
+                length = min(out._size, size_left)
+                blas.zcopy(&length, ptr_left, &_ONE, ptr_out, &_ONE)
+                ptr_left += size_left
+                diag_left += 1
+            else:
+                out.offsets[out_diag] = right.offsets[diag_right]
+                length = min(out._size, size_right)
+                blas.zcopy(&length, ptr_right, &_ONE, ptr_out, &_ONE)
+                if scale != 1:
+                    blas.zscal(&length, &scale, ptr_out, &_ONE)
+                ptr_right += size_right
+                diag_right += 1
+            if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
+                sorted=False
+            ptr_out += out._size
+            out_diag += 1
+
+        if diag_left < left.num_diag:
+            for i in range(left.num_diag - diag_left):
+                out.offsets[out_diag] = left.offsets[diag_left + i]
+                if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
+                    sorted=False
+                out_diag += 1
+            if left._size == out._size:
+                length = left._size * (left.num_diag - diag_left)
+                blas.zcopy(&length, ptr_left, &_ONE, ptr_out, &_ONE)
+            else:
+                for i in range(left.num_diag - diag_left):
+                    blas.zcopy(&size_left, ptr_left, &_ONE, ptr_out, &_ONE)
+                    ptr_out += out._size
+                    ptr_left += left._size
+
+        elif diag_right < right.num_diag:
+            for i in range(right.num_diag - diag_right):
+                out.offsets[out_diag] = right.offsets[diag_right + i]
+                if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
+                    sorted=False
+                out_diag += 1
+            if right._size == out._size:
+                length = right._size * (right.num_diag - diag_right)
+                blas.zcopy(&length, ptr_right, &_ONE, ptr_out, &_ONE)
+                if scale != 1:
+                    blas.zscal(&length, &scale, ptr_out, &_ONE)
+            else:
+                for i in range(right.num_diag - diag_right):
+                    blas.zcopy(&size_right, ptr_right, &_ONE, ptr_out, &_ONE)
+                    if scale != 1:
+                        blas.zscal(&size_right, &scale, ptr_out, &_ONE)
+                    ptr_out += out._size
+                    ptr_right += right._size
+
+        out.num_diag = out_diag
+
+    if not sorted:
+        dia.clean_diag(out, True)
+    elif settings.core['auto_tidyup']:
+        dia.tidyup_diag(out, settings.core['auto_tidyup_atol'], True)
+    return out
+
+
 cpdef CSR sub_csr(CSR left, CSR right):
     return add_csr(left, right, -1)
 
@@ -225,6 +312,10 @@ cpdef Dense sub_dense(Dense left, Dense right):
     return add_dense(left, right, -1)
 
 
+cpdef Diag sub_diag(Diag left, Diag right):
+    return add_diag(left, right, -1)
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -250,6 +341,7 @@ add.__doc__ =\
 add.add_specialisations([
     (Dense, Dense, Dense, add_dense),
     (CSR, CSR, CSR, add_csr),
+    (Diag, Diag, Diag, add_diag),
 ], _defer=True)
 
 sub = _Dispatcher(
@@ -271,6 +363,7 @@ sub.__doc__ =\
 sub.add_specialisations([
     (Dense, Dense, Dense, sub_dense),
     (CSR, CSR, CSR, sub_csr),
+    (Diag, Diag, Diag, sub_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index 356bc03470..31e58be706 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -115,16 +115,17 @@ cpdef Diag adjoint_diag(Diag matrix):
     cdef size_t i, new_i,
     cdef idxint new_offset, j
     with nogil:
+        out.num_diag = matrix.num_diag
         for i in range(matrix.num_diag):
             new_i = matrix.num_diag - i - 1
             new_offset = out.offsets[new_i] = -matrix.offsets[i]
-            for j in range(out.size):
+            for j in range(out._size):
                 if (j < new_offset):
-                    out.data[new_i * out.size + j] = 0.
-                elif (j - new_offset >= matrix.size):
-                    out.data[new_i * out.size + j] = 0.
+                    out.data[new_i * out._size + j] = 0.
+                elif (j - new_offset >= matrix._size):
+                    out.data[new_i * out._size + j] = 0.
                 else:
-                    out.data[new_i * out.size + j] = _conj(matrix.data[i * matrix.size + j - new_offset])
+                    out.data[new_i * out._size + j] = _conj(matrix.data[i * matrix._size + j - new_offset])
     return out
 
 
@@ -133,14 +134,15 @@ cpdef Diag transpose_diag(Diag matrix):
     cdef size_t i, new_i,
     cdef idxint new_offset, j
     with nogil:
+        out.num_diag = matrix.num_diag
         for i in range(matrix.num_diag):
             new_i = matrix.num_diag - i - 1
             new_offset = out.offsets[new_i] = -matrix.offsets[i]
-            for j in range(out.size):
-                if (j < new_offset) or (j - new_offset >= matrix.size):
-                    out.data[new_i * out.size + j] = 0.
+            for j in range(out._size):
+                if (j < new_offset) or (j - new_offset >= matrix._size):
+                    out.data[new_i * out._size + j] = 0.
                 else:
-                    out.data[new_i * out.size + j] = matrix.data[i * matrix.size + j - new_offset]
+                    out.data[new_i * out._size + j] = matrix.data[i * matrix._size + j - new_offset]
     return out
 
 
@@ -148,10 +150,11 @@ cpdef Diag conj_diag(Diag matrix):
     cdef Diag out = dia.empty_like(matrix)
     cdef size_t i, j
     with nogil:
+        out.num_diag = matrix.num_diag
         for i in range(matrix.num_diag):
             out.offsets[i] = matrix.offsets[i]
-            for j in range(matrix.size):
-                out.data[i * matrix.size + j] = _conj(matrix.data[i * matrix.size + j])
+            for j in range(matrix._size):
+                out.data[i * matrix._size + j] = _conj(matrix.data[i * matrix._size + j])
     return out
 
 
diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index 518dda541a..379aa549e0 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -16,12 +16,12 @@ from qutip.core.data.dense cimport Dense
 cdef class Diag(base.Data):
     cdef double complex *data
     cdef base.idxint *offsets
-    cdef readonly size_t num_diag, size
+    cdef readonly size_t num_diag, _size, _max_diag
     cdef object _scipy
     cdef bint _deallocate
     cpdef Diag copy(Diag self)
-    cpdef object as_scipy(Diag self)
-    #cpdef double complex trace(Diag self)
+    cpdef object as_scipy(Diag self, bint full=*)
+    cpdef double complex trace(Diag self)
     cpdef Diag adjoint(Diag self)
     cpdef Diag conj(Diag self)
     cpdef Diag transpose(Diag self)
@@ -33,3 +33,5 @@ cpdef Diag zeros(base.idxint rows, base.idxint cols)
 cpdef Diag identity(base.idxint dimension, double complex scale=*)
 cpdef Diag from_dense(Dense matrix)
 cpdef Dense to_dense(Diag matrix)
+cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=*)
+cpdef Diag clean_diag(Diag matrix, bint inplace=*)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index e8bc35793d..1d97d23537 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -5,7 +5,7 @@ from libc.string cimport memset, memcpy
 
 from libcpp cimport bool
 from libcpp.algorithm cimport sort
-
+from libc.math cimport fabs
 cimport cython
 
 from cpython cimport mem
@@ -27,7 +27,7 @@ from scipy.linalg cimport cython_blas as blas
 from qutip.core.data cimport base, Dense
 from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag
 from qutip.core.data.trace import trace_diag
-# from qutip.core.data.tidyup import tidyup_diag #********************************
+# from qutip.core.data.tidyup import tidyup_diag
 from .base import idxint_dtype
 from qutip.settings import settings
 
@@ -40,8 +40,6 @@ cdef extern from *:
 
 __all__ = ['Diag']
 
-cdef int _ONE = 1
-
 cdef object _dia_matrix(data, offsets, shape):
     """
     Factory method of scipy diag_matrix: we skip all the index type-checking
@@ -96,7 +94,8 @@ cdef class Diag(base.Data):
         self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
         self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
         self.num_diag = offsets.shape[0]
-        self.size = data.shape[1]
+        self._max_diag = self.num_diag
+        self._size = data.shape[1]
 
         if shape is None:
             warnings.warn("instantiating Diag matrix of unknown shape")
@@ -144,7 +143,8 @@ cdef class Diag(base.Data):
         low-level C code).
         """
         cdef Diag out = empty_like(self)
-        memcpy(out.data, self.data, self.num_diag * self.size * sizeof(double complex))
+        out.num_diag = self.num_diag
+        memcpy(out.data, self.data, self.num_diag * self._size * sizeof(double complex))
         memcpy(out.offsets, self.offsets, self.num_diag * sizeof(base.idxint))
 
         return out
@@ -159,20 +159,20 @@ cdef class Diag(base.Data):
         cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
         cdef size_t col, i, nrows = self.shape[0]
         cdef base.idxint diag, size
-        size = self.size if self.size < self.shape[1] else self.shape[1]
+        size = min(self._size, self.shape[1])
         for i in range(self.num_diag):
             diag = self.offsets[i]
             for col in range(size):
                 if col - diag < 0 or col - diag >= nrows:
                     continue
-                out[(col-diag), col] = self.data[i * self.size + col]
+                out[(col-diag), col] = self.data[i * self._size + col]
         return out
 
-    cpdef object as_scipy(self):
+    cpdef object as_scipy(self, bint full=False):
         """
         Get a view onto this object as a `scipy.sparse.dia_matrix`.  The
         underlying data structures are exposed, such that modifications to the
-        `data`, `indices` and `indptr` buffers in the resulting object will
+        `data` and `offsets` buffers in the resulting object will
         modify this object too.
         """
         # We store a reference to the scipy matrix not only for caching this
@@ -181,8 +181,8 @@ cdef class Diag(base.Data):
         # be collected while we're alive.
         if self._scipy is not None:
             return self._scipy
-        cdef cnp.npy_intp num_diag = self.num_diag
-        cdef cnp.npy_intp size = self.size
+        cdef cnp.npy_intp num_diag = self.num_diag if not full else self._max_diag
+        cdef cnp.npy_intp size = self._size
         data = cnp.PyArray_SimpleNewFromData(2, [num_diag, size],
                                              cnp.NPY_COMPLEX128,
                                              self.data)
@@ -240,7 +240,8 @@ cpdef Diag fast_from_scipy(object sci):
     out.data = <double complex *> cnp.PyArray_GETPTR1(sci.data, 0)
     out.offsets = <base.idxint *> cnp.PyArray_GETPTR1(sci.offsets, 0)
     out.num_diag  = sci.offsets.shape[0]
-    out.size = sci.data.shape[1]
+    out._max_diag  = sci.offsets.shape[0]
+    out._size = sci.data.shape[1]
     return out
 
 
@@ -255,13 +256,14 @@ cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.
         raise ValueError("num_diag must be a positive integer.")
     cdef Diag out = Diag.__new__(Diag)
     out.shape = (rows, cols)
-    out.num_diag = num_diag
-    out.size = size
+    out.num_diag = 0
     # Python doesn't like allocating nothing.
     if size == 0:
         size += 1
     if num_diag == 0:
         num_diag += 1
+    out._max_diag = num_diag
+    out._size = size
     out.data =\
         <double complex *> PyDataMem_NEW(size * num_diag * sizeof(double complex))
     out.offsets =\
@@ -270,7 +272,7 @@ cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.
 
 
 cpdef Diag empty_like(Diag other):
-    return empty(other.shape[0], other.shape[1], other.num_diag, other.size)
+    return empty(other.shape[0], other.shape[1], other.num_diag, other._size)
 
 
 cpdef Diag zeros(base.idxint rows, base.idxint cols):
@@ -280,10 +282,9 @@ cpdef Diag zeros(base.idxint rows, base.idxint cols):
     """
     # We always allocate matrices with at least one element to ensure that we
     # actually _are_ asking for memory (Python doesn't like allocating nothing)
-    cdef Diag out = empty(rows, cols, 1, 1)
-    memset(out.data, 0, out.size * sizeof(double complex))
+    cdef Diag out = empty(rows, cols, 0, 0)
+    memset(out.data, 0, out._size * sizeof(double complex))
     out.offsets[0] = 0
-    out.num_diag = 0
     return out
 
 
@@ -297,6 +298,7 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
     for i in range(dimension):
         out.data[i] = scale
     out.offsets[0] = 0
+    out.num_diag = 1
     return out
 
 
@@ -315,33 +317,96 @@ cpdef Diag from_dense(Dense matrix):
         for col in range(matrix.shape[1]):
             out.data[(-(-col+row) -matrix.shape[1]) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
 
-    return tidyup_diag(out)
+    return tidyup_diag(out, settings.core['auto_tidyup_atol'])
 
 
 cpdef Dense to_dense(Diag matrix):
     return Dense(matrix.to_array(), copy=False)
 
 
-cpdef tidyup_diag(mat, atol=1e-5, inplace=False):
-    if inplace:
-        raise Exception()
-    data = mat.data
-    offsets = mat.offsets
-    new_offsets = []
-    diags = []
-    for diag, line in zip(offsets, data):
+cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=False):
+    cdef Diag out = matrix if inplace else matrix.copy()
+    cdef base.idxint diag=0, new_diag=0, ONE=1, start, end, col
+    cdef bint re, im, has_data
+    cdef double complex value
+    cdef int length
+
+    while diag < out.num_diag:
+        start = max(0, out.offsets[diag])
+        end = min(out._size, out.shape[0] + out.offsets[diag], out.shape[1] - out.offsets[diag])
         has_data = False
-        for val in line:
-            has_data |= abs(val) > atol
-            if has_data:
-                break
-        if not has_data:
+        for col in range(start, end):
+            re = False
+            im = False
+            if fabs(matrix.data[diag * out._size + col].real) < tol:
+                re = True
+                matrix.data[diag * out._size + col].real = 0
+            if fabs(matrix.data[diag * out._size + col].imag) < tol:
+                im = True
+                matrix.data[diag * out._size + col].imag = 0
+            has_data |= not (re & im)
+
+        if has_data and new_diag < diag:
+            length = out._size
+            blas.zcopy(&length, &out.data[diag * out._size], &ONE, &out.data[new_diag * out._size], &ONE)
+
+        if has_data:
+            new_diag += 1
+        diag += 1
+    out.num_diag = new_diag
+    return out
+
+
+cpdef Diag clean_diag(Diag matrix, bint inplace=False):
+    """
+    Sort and sum duplicates of offsets.
+    Set out of bound values to zeros.
+    """
+    cdef Diag out = matrix if inplace else matrix.copy()
+    cdef base.idxint diag=0, new_diag=0, start, end, col
+    cdef double complex ZONE=1.
+    cdef bint has_duplicate
+    cdef int length, ONE=1
+
+    # We sort using insertion sort on the offsets, summing data of duplicated.
+    # This does not scale well with large number of diagonal
+    for new_diag in range(out.num_diag):
+        smallest_offsets = out.offsets[new_diag]
+        smallest_diag = new_diag
+        comp_diag = new_diag + 1
+        has_duplicate = False
+        for comp_diag in range(new_diag + 1, out.num_diag):
+            #if out.offsets[comp_diag] == out.shape[1]:
+            #    continue
+            if out.offsets[comp_diag] < smallest_offsets:
+                smallest_offsets = out.offsets[comp_diag]
+                smallest_diag = comp_diag
+                has_duplicate = False
+            elif out.offsets[comp_diag] == smallest_offsets:
+                length = out._size
+                blas.zaxpy(&length, &ZONE, &out.data[comp_diag * out._size], &ONE, &out.data[smallest_diag * out._size], &ONE)
+                out.offsets[comp_diag] = out.shape[1]
+
+        if smallest_offsets == out.shape[1]:
+            new_diag -= 1
+            break
+        if new_diag == smallest_diag:
             continue
-        new_offsets.append(diag)
-        diags.append(line)
-    data = np.vstack(diags)
-    offsets = np.array(new_offsets)
-    return data, offsets
+        length = out._size
+        blas.zswap(&length, &out.data[new_diag * out._size], &ONE, &out.data[smallest_diag * out._size], &ONE)
+        out.offsets[smallest_diag] = out.offsets[new_diag]
+        out.offsets[new_diag] = smallest_offsets
+
+    out.num_diag = new_diag + 1
+    for diag in range(out.num_diag):
+        start = max(0, out.offsets[diag])
+        end = min(out._size, out.shape[0] + out.offsets[diag])
+        for col in range(start):
+            out.data[diag * out._size + col] = 0.
+        for col in range(end, out._size):
+            out.data[diag * out._size + col] = 0.
+
+    return out
 
 
 cdef inline base.idxint _diagonal_length(
@@ -380,11 +445,12 @@ cdef Diag diags_(
         the diagonals must be of the correct length to fit in.
     """
     out = empty(n_rows, n_cols, len(offsets), n_cols)
+    out.num_diag = len(offsets)
     for i in range(len(offsets)):
         out.offsets[i] = offsets[i]
         offset = max(offsets[i], 0)
         for col in range(len(diagonals[i])):
-            out.data[i * out.size + col + offset] = diagonals[i][col]
+            out.data[i * out._size + col + offset] = diagonals[i][col]
     return out
 
 @cython.wraparound(True)
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 211e716b29..152075b72f 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -54,8 +54,8 @@ cpdef double complex trace_diag(Diag matrix) except * nogil:
     cdef size_t diag, j
     for diag in range(matrix.num_diag):
         if matrix.offsets[diag] == 0:
-            for j in range(matrix.size):
-                trace += matrix.data[diag * matrix.size + j]
+            for j in range(matrix._size):
+                trace += matrix.data[diag * matrix._size + j]
             break
     return trace
 
@@ -89,7 +89,7 @@ cpdef double complex trace_oper_ket_diag(Diag matrix) except * nogil:
     cdef size_t stride = N + 1
     for diag in range(matrix.num_diag):
         if -matrix.offsets[diag] % stride == 0:
-            trace += matrix.data[diag * matrix.size]
+            trace += matrix.data[diag * matrix._size]
     return trace
 
 
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 9f8509e977..9a80bf117c 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -211,7 +211,7 @@ def test_empty(self, shape, density):
         ndiag = int(shape[0] * shape[1] * density) or 1
         size = np.random.randint(shape[1]) or 1
         base = dia.empty(shape[0], shape[1], ndiag, size)
-        sci = base.as_scipy()
+        sci = base.as_scipy(full=True)
         assert isinstance(base, dia.Diag)
         assert isinstance(sci, scipy.sparse.dia_matrix)
         assert base.shape == shape
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 9774643b62..912cfbbf30 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -552,6 +552,7 @@ def op_numpy(self, left, right, scale):
     specialisations = [
         pytest.param(data.add_csr, CSR, CSR, CSR),
         pytest.param(data.add_dense, Dense, Dense, Dense),
+        pytest.param(data.add_diag, Diag, Diag, Diag),
     ]
 
     # `add` has an additional scalar parameter, because the operation is
@@ -811,6 +812,7 @@ def op_numpy(self, left, right):
     specialisations = [
         pytest.param(data.sub_csr, CSR, CSR, CSR),
         pytest.param(data.sub_dense, Dense, Dense, Dense),
+        pytest.param(data.sub_diag, Diag, Diag, Diag),
     ]
 
 

From 357d8edf059955f42939b4d02a5b23f1501b18a7 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 1 May 2023 16:36:18 -0400
Subject: [PATCH 355/602] Fix from_dense and tidyup_diag + add specialisations

---
 qutip/core/data/add.pyx                   |  7 ++-
 qutip/core/data/constant.py               |  5 +-
 qutip/core/data/dia.pxd                   |  1 -
 qutip/core/data/dia.pyx                   | 56 +++++-------------
 qutip/core/data/make.py                   | 34 ++++++++++-
 qutip/core/data/matmul.pxd                |  2 +
 qutip/core/data/matmul.pyx                | 72 ++++++++++++++++++++++-
 qutip/core/data/mul.pxd                   |  6 +-
 qutip/core/data/mul.pyx                   | 41 +++++++++++--
 qutip/core/data/tidyup.pxd                |  3 +-
 qutip/core/data/tidyup.pyx                | 47 ++++++++++++++-
 qutip/core/data/trace.pyx                 |  2 +
 qutip/tests/core/data/conftest.py         | 25 ++++++--
 qutip/tests/core/data/test_convert.py     | 11 ++++
 qutip/tests/core/data/test_diag.py        | 47 ++++++++++++---
 qutip/tests/core/data/test_mathematics.py | 10 +++-
 16 files changed, 294 insertions(+), 75 deletions(-)

diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index af5c061876..673f77cacf 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -10,6 +10,7 @@ from qutip.settings import settings
 from qutip.core.data.base cimport idxint, Data
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.dia cimport Diag
+from qutip.core.data.tidyup cimport tidyup_diag
 from qutip.core.data.csr cimport (
     CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
 )
@@ -276,7 +277,7 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
                     ptr_out += out._size
                     ptr_left += left._size
 
-        elif diag_right < right.num_diag:
+        if diag_right < right.num_diag:
             for i in range(right.num_diag - diag_right):
                 out.offsets[out_diag] = right.offsets[diag_right + i]
                 if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
@@ -299,8 +300,8 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
 
     if not sorted:
         dia.clean_diag(out, True)
-    elif settings.core['auto_tidyup']:
-        dia.tidyup_diag(out, settings.core['auto_tidyup_atol'], True)
+    if settings.core['auto_tidyup']:
+        tidyup_diag(out, settings.core['auto_tidyup_atol'], True)
     return out
 
 
diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 52f23f413f..06df0fe30d 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -3,8 +3,9 @@
 # (e.g. `create`) should not be here, but should be defined within the
 # higher-level components of QuTiP instead.
 
-from . import csr, dense
+from . import csr, dense, dia
 from .csr import CSR
+from .dia import Diag
 from .dense import Dense
 from .base import Data
 from .dispatch import Dispatcher as _Dispatcher
@@ -38,6 +39,7 @@
     """
 zeros.add_specialisations([
     (CSR, csr.zeros),
+    (Diag, dia.zeros),
     (Dense, dense.zeros),
 ], _defer=True)
 
@@ -68,6 +70,7 @@
     """
 identity.add_specialisations([
     (CSR, csr.identity),
+    (Diag, dia.identity),
     (Dense, dense.identity),
 ], _defer=True)
 
diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index 379aa549e0..e8d0b5b276 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -33,5 +33,4 @@ cpdef Diag zeros(base.idxint rows, base.idxint cols)
 cpdef Diag identity(base.idxint dimension, double complex scale=*)
 cpdef Diag from_dense(Dense matrix)
 cpdef Dense to_dense(Diag matrix)
-cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=*)
 cpdef Diag clean_diag(Diag matrix, bint inplace=*)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 1d97d23537..394918f5da 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -27,7 +27,7 @@ from scipy.linalg cimport cython_blas as blas
 from qutip.core.data cimport base, Dense
 from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag
 from qutip.core.data.trace import trace_diag
-# from qutip.core.data.tidyup import tidyup_diag
+from qutip.core.data.tidyup import tidyup_diag
 from .base import idxint_dtype
 from qutip.settings import settings
 
@@ -302,20 +302,22 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
     return out
 
 
+@cython.boundscheck(True)
 cpdef Diag from_dense(Dense matrix):
     # Assume worst-case scenario for non-zero.
     cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1, matrix.shape[1])
     cdef size_t diag_, ptr_in, ptr_out=0, stride
     cdef row, col
 
+    out.num_diag = matrix.shape[0] + matrix.shape[1] - 1
     for i in range(matrix.shape[0] + matrix.shape[1] - 1):
         out.offsets[i] = i -matrix.shape[0] + 1
-    strideR = matrix.shape[0] if matrix.fortran else 1
-    strideC = matrix.shape[1] if not matrix.fortran else 1
+    strideR = matrix.shape[1] if matrix.fortran else 1
+    strideC = matrix.shape[0] if not matrix.fortran else 1
 
     for row in range(matrix.shape[0]):
         for col in range(matrix.shape[1]):
-            out.data[(-(-col+row) -matrix.shape[1]) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
+            out.data[(col - row + matrix.shape[0] - 1) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
 
     return tidyup_diag(out, settings.core['auto_tidyup_atol'])
 
@@ -324,39 +326,6 @@ cpdef Dense to_dense(Diag matrix):
     return Dense(matrix.to_array(), copy=False)
 
 
-cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=False):
-    cdef Diag out = matrix if inplace else matrix.copy()
-    cdef base.idxint diag=0, new_diag=0, ONE=1, start, end, col
-    cdef bint re, im, has_data
-    cdef double complex value
-    cdef int length
-
-    while diag < out.num_diag:
-        start = max(0, out.offsets[diag])
-        end = min(out._size, out.shape[0] + out.offsets[diag], out.shape[1] - out.offsets[diag])
-        has_data = False
-        for col in range(start, end):
-            re = False
-            im = False
-            if fabs(matrix.data[diag * out._size + col].real) < tol:
-                re = True
-                matrix.data[diag * out._size + col].real = 0
-            if fabs(matrix.data[diag * out._size + col].imag) < tol:
-                im = True
-                matrix.data[diag * out._size + col].imag = 0
-            has_data |= not (re & im)
-
-        if has_data and new_diag < diag:
-            length = out._size
-            blas.zcopy(&length, &out.data[diag * out._size], &ONE, &out.data[new_diag * out._size], &ONE)
-
-        if has_data:
-            new_diag += 1
-        diag += 1
-    out.num_diag = new_diag
-    return out
-
-
 cpdef Diag clean_diag(Diag matrix, bint inplace=False):
     """
     Sort and sum duplicates of offsets.
@@ -364,7 +333,7 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
     """
     cdef Diag out = matrix if inplace else matrix.copy()
     cdef base.idxint diag=0, new_diag=0, start, end, col
-    cdef double complex ZONE=1.
+    cdef double complex zONE=1.
     cdef bint has_duplicate
     cdef int length, ONE=1
 
@@ -376,15 +345,17 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
         comp_diag = new_diag + 1
         has_duplicate = False
         for comp_diag in range(new_diag + 1, out.num_diag):
-            #if out.offsets[comp_diag] == out.shape[1]:
-            #    continue
             if out.offsets[comp_diag] < smallest_offsets:
                 smallest_offsets = out.offsets[comp_diag]
                 smallest_diag = comp_diag
                 has_duplicate = False
             elif out.offsets[comp_diag] == smallest_offsets:
                 length = out._size
-                blas.zaxpy(&length, &ZONE, &out.data[comp_diag * out._size], &ONE, &out.data[smallest_diag * out._size], &ONE)
+                blas.zaxpy(
+                    &length, &zONE,
+                    &out.data[comp_diag * out._size], &ONE,
+                    &out.data[smallest_diag * out._size], &ONE
+                )
                 out.offsets[comp_diag] = out.shape[1]
 
         if smallest_offsets == out.shape[1]:
@@ -406,6 +377,9 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
         for col in range(end, out._size):
             out.data[diag * out._size + col] = 0.
 
+    if out._scipy is not None:
+        out._scipy.data = out._scipy.data[:out.num_diag]
+        out._scipy.offsets = out._scipy.offsets[:out.num_diag]
     return out
 
 
diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
index 8b34d6565c..42083c83f6 100644
--- a/qutip/core/data/make.py
+++ b/qutip/core/data/make.py
@@ -1,7 +1,11 @@
 from .dispatch import Dispatcher as _Dispatcher
-from . import csr, dense, CSR, Dense
+from . import csr, dense, dia, CSR, Dense, Diag
+import numpy as np
 
-__all__ = ['diag', 'one_element_csr', 'one_element_dense', 'one_element']
+__all__ = [
+    'diag',
+    'one_element_csr', 'one_element_dense', 'one_element_diag', 'one_element'
+]
 
 
 def _diag_signature(diagonals, offsets=0, shape=None):
@@ -36,6 +40,7 @@ def _diag_signature(diagonals, offsets=0, shape=None):
 diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
 diag.add_specialisations([
     (CSR, csr.diags),
+    (Diag, dia.diags),
     (Dense, dense.diags),
 ], _defer=True)
 
@@ -93,9 +98,34 @@ def one_element_dense(shape, position, value=1.0):
     return data
 
 
+def one_element_diag(shape, position, value=1.0):
+    """
+    Create a matrix with only one nonzero element.
+
+    Parameters
+    ----------
+    shape : tuple
+        The shape of the output as (``rows``, ``columns``).
+
+    position : tuple
+        The position of the non zero in the matrix as (``rows``, ``columns``).
+
+    value : complex, optional
+        The value of the non-null element.
+    """
+    if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
+        raise ValueError("Position of the elements out of bound: " +
+                         str(position) + " in " + str(shape))
+    data = np.zeros((1 ,shape[1]), dtype=complex)
+    data[0, position[1]] = value
+    offsets = np.array([position[1]-position[0]])
+    return Diag((data, offsets), copy=False, shape=shape)
+
+
 one_element = _Dispatcher(one_element_dense, name='one_element',
                           inputs=(), out=True)
 one_element.add_specialisations([
     (CSR, one_element_csr),
     (Dense, one_element_dense),
+    (Diag, one_element_diag),
 ], _defer=True)
diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
index 54d21798d0..3ad13768fe 100644
--- a/qutip/core/data/matmul.pxd
+++ b/qutip/core/data/matmul.pxd
@@ -2,6 +2,7 @@
 
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.dia cimport Diag
 from qutip.core.data.base cimport Data
 
 cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
@@ -12,3 +13,4 @@ cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense
 
 cpdef Dense multiply_dense(Dense left, Dense right)
 cpdef CSR multiply_csr(CSR left, CSR right)
+cpdef Diag multiply_diag(Diag left, Diag right)
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 8c6de18c9a..a0a84c60d8 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -19,7 +19,9 @@ from qutip.core.data.base import idxint_dtype
 from qutip.core.data.base cimport idxint, Data
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.csr cimport CSR
-from qutip.core.data cimport csr, dense
+from qutip.core.data.dia cimport Diag
+from qutip.core.data.tidyup cimport tidyup_diag
+from qutip.core.data cimport csr, dense, dia
 from qutip.core.data.add cimport iadd_dense, add_csr
 from qutip.core.data.dense import OrderEfficiencyWarning
 
@@ -40,7 +42,7 @@ cdef extern from "src/matmul_csr_vector.hpp" nogil:
 
 __all__ = [
     'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
-    'multiply', 'multiply_csr', 'multiply_dense',
+    'multiply', 'multiply_csr', 'multiply_dense', 'multiply_diag',
 ]
 
 
@@ -372,6 +374,71 @@ cpdef CSR multiply_csr(CSR left, CSR right):
     return out
 
 
+cpdef Diag multiply_diag(Diag left, Diag right):
+    if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
+        raise ValueError(
+            "incompatible matrix shapes "
+            + str(left.shape)
+            + " and "
+            + str(right.shape)
+        )
+    cdef idxint diag_left=0, diag_right=0, out_diag=0, col
+    cdef bint sorted=True
+    cdef Diag out = dia.empty(left.shape[0], left.shape[1], min(left.num_diag, right.num_diag), max(left._size, right._size))
+    cdef int length, size_left = left._size, size_right = right._size
+
+    with nogil:
+      for diag_left in range(1, left.num_diag):
+          if left.offsets[diag_left-1] > left.offsets[diag_left]:
+              sorted = False
+              continue
+      if sorted:
+          for diag_right in range(1, right.num_diag):
+              if right.offsets[diag_right-1] > right.offsets[diag_right]:
+                  sorted = False
+                  continue
+
+      if sorted:
+        diag_left = 0
+        diag_right = 0
+        while diag_left < left.num_diag and diag_right < right.num_diag:
+            if left.offsets[diag_left] == right.offsets[diag_right]:
+                out.offsets[out_diag] = left.offsets[diag_left]
+                for col in range(out._size):
+                    if col >= left._size or col >= right._size:
+                        out.data[out_diag * out._size + col] = 0
+                    else:
+                        out.data[out_diag * out._size + col] = (
+                            left.data[diag_left * left._size + col] *
+                            right.data[diag_right * right._size + col]
+                        )
+                out_diag += 1
+                diag_left += 1
+                diag_right += 1
+            elif left.offsets[diag_left] < right.offsets[diag_right]:
+                diag_left += 1
+            else:
+                diag_right += 1
+
+      else:
+        for diag_left in range(left.num_diag):
+          for diag_right in range(right.num_diag):
+            if left.offsets[diag_left] == right.offsets[diag_right]:
+                out.offsets[out_diag] = left.offsets[diag_left]
+                for col in range(size_right):
+                    out.data[out_diag * out._size + col] = (
+                        left.data[diag_left * left._size + col] *
+                        right.data[diag_right * right._size + col]
+                    )
+                out_diag += 1
+                break
+      out.num_diag = out_diag
+
+    if settings.core['auto_tidyup']:
+        tidyup_diag(out, settings.core['auto_tidyup_atol'], True)
+    return out
+
+
 cpdef Dense multiply_dense(Dense left, Dense right):
     """Element-wise multiplication of Dense matrices."""
     if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
@@ -448,6 +515,7 @@ multiply.__doc__ =\
 multiply.add_specialisations([
     (CSR, CSR, CSR, multiply_csr),
     (Dense, Dense, Dense, multiply_dense),
+    (Diag, Diag, Diag, multiply_diag),
 ], _defer=True)
 
 
diff --git a/qutip/core/data/mul.pxd b/qutip/core/data/mul.pxd
index 2c29259631..2507a74edd 100644
--- a/qutip/core/data/mul.pxd
+++ b/qutip/core/data/mul.pxd
@@ -1,6 +1,6 @@
 #cython: language_level=3
 
-from qutip.core.data cimport CSR, Dense, Data
+from qutip.core.data cimport CSR, Dense, Data, Diag
 
 cpdef CSR imul_csr(CSR matrix, double complex value)
 cpdef CSR mul_csr(CSR matrix, double complex value)
@@ -10,4 +10,8 @@ cpdef Dense imul_dense(Dense matrix, double complex value)
 cpdef Dense mul_dense(Dense matrix, double complex value)
 cpdef Dense neg_dense(Dense matrix)
 
+cpdef Diag imul_diag(Diag matrix, double complex value)
+cpdef Diag mul_diag(Diag matrix, double complex value)
+cpdef Diag neg_diag(Diag matrix)
+
 cpdef Data imul_data(Data matrix, double complex value)
diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 9d42e4a9ea..68a06c7d12 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -1,13 +1,13 @@
 #cython: language_level=3
 #cython: boundscheck=False, wrapround=False, initializedcheck=False
 
-from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data
+from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data, Diag, dia
 from scipy.linalg.cython_blas cimport zscal
 
 __all__ = [
-    'mul', 'mul_csr', 'mul_dense',
-    'imul', 'imul_csr', 'imul_dense', 'imul_data',
-    'neg', 'neg_csr', 'neg_dense',
+    'mul', 'mul_csr', 'mul_dense', 'mul_diag',
+    'imul', 'imul_csr', 'imul_dense', 'imul_diag', 'imul_data',
+    'neg', 'neg_csr', 'neg_dense', 'neg_diag',
 ]
 
 
@@ -39,6 +39,37 @@ cpdef CSR neg_csr(CSR matrix):
     return out
 
 
+cpdef Diag imul_diag(Diag matrix, double complex value):
+    """Multiply this Diag `matrix` by a complex scalar `value`."""
+    cdef idxint l = matrix.num_diag * matrix._size
+    cdef int ONE=1
+    zscal(&l, &value, matrix.data, &ONE)
+    return matrix
+
+cpdef Diag mul_diag(Diag matrix, double complex value):
+    """Multiply this Diag `matrix` by a complex scalar `value`."""
+    if value == 0:
+        return dia.zeros(matrix.shape[0], matrix.shape[1])
+    cdef Diag out = dia.empty_like(matrix)
+    cdef idxint ptr, diag, l = matrix.num_diag * matrix._size
+    with nogil:
+        for ptr in range(l):
+            out.data[ptr] = value * matrix.data[ptr]
+        for ptr in range(matrix.num_diag):
+            out.offsets[ptr] = matrix.offsets[ptr]
+        out.num_diag = matrix.num_diag
+    return out
+
+cpdef Diag neg_diag(Diag matrix):
+    """Unary negation of this Diag `matrix`.  Return a new object."""
+    cdef Diag out = matrix.copy()
+    cdef idxint ptr, l = matrix.num_diag * matrix._size
+    with nogil:
+        for ptr in range(l):
+            out.data[ptr] = -matrix.data[ptr]
+    return out
+
+
 cpdef Dense imul_dense(Dense matrix, double complex value):
     """Multiply this Dense `matrix` by a complex scalar `value`."""
     cdef size_t ptr
@@ -130,5 +161,7 @@ cpdef Data imul_data(Data matrix, double complex value):
         return imul_csr(matrix, value)
     elif type(matrix) is Dense:
         return imul_dense(matrix, value)
+    elif type(matrix) is Diag:
+        return imul_diag(matrix, value)
     else:
         return imul(matrix, value)
diff --git a/qutip/core/data/tidyup.pxd b/qutip/core/data/tidyup.pxd
index 4444714507..63b3ebdf54 100644
--- a/qutip/core/data/tidyup.pxd
+++ b/qutip/core/data/tidyup.pxd
@@ -1,7 +1,8 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from qutip.core.data cimport CSR, Dense
+from qutip.core.data cimport CSR, Dense, Diag
 
 cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
 cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
+cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=*)
diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
index a905dbb0a6..d5e0258860 100644
--- a/qutip/core/data/tidyup.pyx
+++ b/qutip/core/data/tidyup.pyx
@@ -4,15 +4,16 @@
 from libc.math cimport fabs
 
 cimport numpy as cnp
+from scipy.linalg cimport cython_blas as blas
 
-from qutip.core.data cimport csr, dense, CSR, Dense
+from qutip.core.data cimport csr, dense, CSR, Dense, dia, Diag, base
 
 cdef extern from "<complex>" namespace "std" nogil:
     # abs is templated such that Cython treats std::abs as complex->complex
     double abs(double complex x)
 
 __all__ = [
-    'tidyup', 'tidyup_csr', 'tidyup_dense',
+    'tidyup', 'tidyup_csr', 'tidyup_dense', 'tidyup_diag',
 ]
 
 
@@ -55,6 +56,47 @@ cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
     return out
 
 
+cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=True):
+    cdef Diag out = matrix if inplace else matrix.copy()
+    cdef base.idxint diag=0, new_diag=0, ONE=1, start, end, col
+    cdef bint re, im, has_data
+    cdef double complex value
+    cdef int length
+
+    while diag < out.num_diag:
+        start = max(0, out.offsets[diag])
+        end = min(out._size, out.shape[0] + out.offsets[diag])
+        has_data = False
+        for col in range(start, end):
+            re = False
+            im = False
+            if fabs(out.data[diag * out._size + col].real) < tol:
+                re = True
+                out.data[diag * out._size + col].real = 0
+            if fabs(out.data[diag * out._size + col].imag) < tol:
+                im = True
+                out.data[diag * out._size + col].imag = 0
+            has_data |= not (re & im)
+
+        if has_data and new_diag < diag:
+            length = out._size
+            blas.zcopy(
+                &length,
+                &out.data[diag * out._size], &ONE,
+                &out.data[new_diag * out._size], &ONE
+            )
+            out.offsets[new_diag] = out.offsets[diag]
+
+        if has_data:
+            new_diag += 1
+        diag += 1
+    out.num_diag = new_diag
+    if out._scipy is not None:
+        out._scipy.data = out._scipy.data[:new_diag]
+        out._scipy.offsets = out._scipy.offsets[:new_diag]
+    return out
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -101,6 +143,7 @@ tidyup.__doc__ =\
 tidyup.add_specialisations([
     (CSR, tidyup_csr),
     (Dense, tidyup_dense),
+    (Diag, tidyup_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 152075b72f..4f8b6b1ec8 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -109,6 +109,7 @@ trace.__doc__ =\
     """Compute the trace (sum of digaonal elements) of a square matrix."""
 trace.add_specialisations([
     (CSR, trace_csr),
+    (Diag, trace_diag),
     (Dense, trace_dense),
 ], _defer=True)
 
@@ -125,6 +126,7 @@ trace_oper_ket.__doc__ =\
     """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
 trace_oper_ket.add_specialisations([
     (CSR, trace_oper_ket_csr),
+    (Diag, trace_oper_ket_diag),
     (Dense, trace_oper_ket_dense),
 ], _defer=True)
 
diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
index d64f61e837..ef2025e583 100644
--- a/qutip/tests/core/data/conftest.py
+++ b/qutip/tests/core/data/conftest.py
@@ -28,17 +28,30 @@ def shuffle_indices_scipy_csr(matrix):
     return out
 
 
-def random_scipy_dia(shape, density):
+def random_scipy_dia(shape, density, sort=False):
     """
     Generate a random scipy dia matrix with the given shape, density.
     """
     num_diag = int(density * (shape[0] + shape[1] - 1)) or 1
     offsets = []
     data = []
-    for diag in np.random.choice(np.arange(-shape[0] + 1, shape[1]), num_diag, replace=False):
+    diags = np.random.choice(
+        np.arange(-shape[0] + 1, shape[1]),
+        num_diag,
+        replace=False
+    )
+    for diag in diags:
         offsets.append(diag)
-        num_elements = min(shape[0], shape[1], shape[0] + diag, shape[1] - diag)
-        data.append(np.random.rand(num_elements) + 1j*np.random.rand(num_elements))
+        num_elements = min(
+            shape[0], shape[1], shape[0] + diag, shape[1] - diag
+        )
+        data.append(
+            np.random.rand(num_elements) + 1j*np.random.rand(num_elements)
+        )
+    if sort:
+        order = np.argsort(offsets)
+        offsets = [offsets[i] for i in order]
+        data = [data[i] for i in order]
     return scipy.sparse.diags(data, offsets, shape=shape).todia()
 
 
@@ -80,6 +93,6 @@ def random_dense(shape, fortran):
     return qutip.core.data.Dense(random_numpy_dense(shape, fortran))
 
 
-def random_diag(shape, density):
+def random_diag(shape, density, sort=False):
     """Generate a random qutip Diag matrix of the given shape and density"""
-    return qutip.core.data.Diag(random_scipy_dia(shape, density))
+    return qutip.core.data.Diag(random_scipy_dia(shape, density, sort))
diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
index a7be4e6de9..bc38bfc957 100644
--- a/qutip/tests/core/data/test_convert.py
+++ b/qutip/tests/core/data/test_convert.py
@@ -14,11 +14,16 @@ def test_init_empty_data():
 @pytest.mark.parametrize(['base', 'dtype'], [
     pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
     pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
+    pytest.param(data.dia.zeros(2, 2), data.Diag, id='data.Diag'),
     pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
                  id='array'),
     pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
                  id='sparse'),
+    pytest.param(sparse.eye(10, dtype=np.complex128, format='dia'), data.Diag,
+                 id='diag'),
     pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
+    pytest.param(sparse.eye(10, dtype=float, format='dia'), data.Diag,
+                 id='diag'),
     pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
                  id='sparse'),
 ])
@@ -35,6 +40,9 @@ def test_create(base, dtype):
     pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
     pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
     pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
+    pytest.param('Diag', data.dia.zeros(2, 2), id='from Diag STR'),
+    pytest.param('dia', data.dia.zeros(2, 2), id='from Diag str'),
+    pytest.param(data.Diag, data.dia.zeros(2, 2), id='from Diag type'),
 ])
 @pytest.mark.parametrize(['to_', 'dtype'], [
     pytest.param('dense', data.Dense, id='to Dense str'),
@@ -43,6 +51,9 @@ def test_create(base, dtype):
     pytest.param('csr', data.CSR, id='to CSR str'),
     pytest.param('CSR', data.CSR, id='to CSR STR'),
     pytest.param(data.CSR, data.CSR, id='to CSR type'),
+    pytest.param('Diag', data.Diag, id='to Diag STR'),
+    pytest.param('dia', data.Diag, id='to Diag str'),
+    pytest.param(data.Diag, data.Diag, id='to Diag type'),
 ])
 def test_converters(from_, base, to_, dtype):
     converter = data.to[to_, from_]
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 9a80bf117c..3b4d3fe141 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -2,8 +2,8 @@
 import scipy.sparse
 import pytest
 
-from qutip.core import data
-from qutip.core.data import dense, dia
+from qutip.core import data, qeye, CoreOptions
+from qutip.core.data import dia
 
 from . import conftest
 
@@ -284,7 +284,7 @@ def test_diags(self, diagonals, offsets, shape):
         assert base.shape == shape
         np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
 
-    """
+
     @pytest.mark.parametrize(['shape', 'position', 'value'], [
         pytest.param((1, 1), (0, 0), None, id='minimal'),
         pytest.param((10, 10), (5, 5), 1.j, id='on diagonal'),
@@ -298,12 +298,12 @@ def test_diags(self, diagonals, offsets, shape):
     def test_one_element(self, shape, position, value):
         test = np.zeros(shape, dtype=np.complex128)
         if value is None:
-            base = data.one_element_dense(shape, position)
+            base = data.one_element_diag(shape, position)
             test[position] = 1.0+0.0j
         else:
-            base = data.one_element_dense(shape, position, value)
+            base = data.one_element_diag(shape, position, value)
             test[position] = value
-        assert isinstance(base, data.Dense)
+        assert isinstance(base, data.Diag)
         assert base.shape == shape
         assert np.allclose(base.to_array(), test, atol=1e-10)
 
@@ -315,7 +315,38 @@ def test_one_element(self, shape, position, value):
     ])
     def test_one_element_error(self, shape, position, value):
         with pytest.raises(ValueError) as exc:
-            base = data.one_element_dense(shape, position, value)
+            base = data.one_element_diag(shape, position, value)
         assert str(exc.value).startswith("Position of the elements"
                                          " out of bound: ")
-    """
+
+
+def test_tidyup(data_diag):
+    before = data_diag.to_array()
+    sp_before = data_diag.as_scipy().toarray()
+    largest = max(np.abs(before.real).max(), np.abs(before.imag).max())
+    min_r = np.abs(before.real[np.abs(before.real) > 0]).min()
+    min_i = np.abs(before.imag[np.abs(before.imag) > 0]).min()
+    smallest = min(min_r, min_i)
+    print(largest, smallest)
+    if largest == smallest:
+        return
+    tol = (largest + smallest) / 2
+    tidy = data.tidyup_diag(data_diag, tol, False)
+    # Inplace=False, does not modify the original
+    np.testing.assert_array_equal(data_diag.to_array(), before)
+    np.testing.assert_array_equal(data_diag.as_scipy().toarray(), sp_before)
+    # Is tidyup
+    assert not np.allclose(tidy.to_array(), before)
+    assert not np.allclose(tidy.as_scipy().toarray(), sp_before)
+
+    data.tidyup_diag(data_diag, tol, True)
+    assert not np.allclose(data_diag.to_array(), before)
+    assert not np.allclose(data_diag.as_scipy().toarray(), sp_before)
+
+
+def test_autotidyup():
+    small = qeye(1) * 1e-5
+    with CoreOptions(auto_tidyup_atol=1e-3):
+        assert (small + small).tr() == 0
+    with CoreOptions(auto_tidyup_atol=1e-3, auto_tidyup=False):
+        assert (small + small).tr() == 2e-5
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 912cfbbf30..a37e099710 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -164,15 +164,16 @@ def cases_diag(shape):
     Return a list of generators of the different special cases for Dense
     matrices of a given shape.
     """
-    def factory(density):
-        return lambda: conftest.random_diag(shape, density)
+    def factory(density, sort=False):
+        return lambda: conftest.random_diag(shape, density, sort)
 
     def zero_factory():
         return lambda: data.dia.zeros(shape[0], shape[1])
 
     return [
         pytest.param(factory(0.001), id="sparse"),
-        pytest.param(factory(0.8), id="filled"),
+        pytest.param(factory(0.8, True), id="filled,sorted"),
+        pytest.param(factory(0.8, False), id="filled,unsorted"),
         pytest.param(zero_factory(), id="zero"),
     ]
 
@@ -780,6 +781,7 @@ def op_numpy(self, left, right):
     specialisations = [
         pytest.param(data.multiply_csr, CSR, CSR, CSR),
         pytest.param(data.multiply_dense, Dense, Dense, Dense),
+        pytest.param(data.multiply_diag, Diag, Diag, Diag),
     ]
 
 
@@ -790,6 +792,7 @@ def op_numpy(self, matrix, scalar):
     specialisations = [
         pytest.param(data.mul_csr, CSR, CSR),
         pytest.param(data.mul_dense, Dense, Dense),
+        pytest.param(data.mul_diag, Diag, Diag),
     ]
 
 
@@ -800,6 +803,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.neg_csr, CSR, CSR),
         pytest.param(data.neg_dense, Dense, Dense),
+        pytest.param(data.neg_diag, Diag, Diag),
     ]
 
 

From 890849610aeaa903a674f76a7695807aa22d0143 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 2 May 2023 17:00:07 -0400
Subject: [PATCH 356/602] add matmul_diag and matmul_diag_dense draft

---
 qutip/core/data/matmul.pxd                |  2 +
 qutip/core/data/matmul.pyx                | 76 ++++++++++++++++++++++-
 qutip/tests/core/data/test_mathematics.py |  2 +
 3 files changed, 79 insertions(+), 1 deletion(-)

diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
index 3ad13768fe..bdb7c362e3 100644
--- a/qutip/core/data/matmul.pxd
+++ b/qutip/core/data/matmul.pxd
@@ -8,6 +8,8 @@ from qutip.core.data.base cimport Data
 cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
 cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
 cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
+cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=*)
+cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=*, Dense out=*)
 cdef Dense matmul_data_dense(Data left, Dense right)
 cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
 
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index a0a84c60d8..8b44d602dd 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -3,6 +3,7 @@
 
 from libc.string cimport memset, memcpy
 from libc.math cimport fabs
+from libcpp.algorithm cimport lower_bound
 
 import warnings
 from qutip.settings import settings
@@ -41,7 +42,8 @@ cdef extern from "src/matmul_csr_vector.hpp" nogil:
         T nrows)
 
 __all__ = [
-    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_csr_dense_dense',
+    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_diag',
+    'matmul_csr_dense_dense', 'matmul_diag_dense_dense',
     'multiply', 'multiply_csr', 'multiply_dense', 'multiply_diag',
 ]
 
@@ -311,6 +313,78 @@ cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense
     return out
 
 
+#TODO: optimize, cdef types etc.
+cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=1):
+    _check_shape(left, right, None)
+    # We could probably do faster than this without the gil etc.
+    npoffsets = np.unique(np.add.outer(left.as_scipy().offsets, right.as_scipy().offsets))
+    npoffsets = npoffsets[np.logical_and(npoffsets > -left.shape[0], npoffsets < right.shape[1])]
+    cdef idxint[:] offsets = npoffsets
+    if len(npoffsets) == 0:
+        return dia.zeros(left.shape[0], right.shape[1])
+    cdef idxint *ptr = &offsets[0]
+    cdef idxint num_diag = offsets.shape[0], diag_out, diag_left, diag_right, off_out
+    npdata = np.zeros((num_diag, right.shape[1]), dtype=complex)
+    cdef double complex[:, ::1] data = npdata
+
+    for diag_left in range(left.num_diag):
+      for diag_right in range(right.num_diag):
+        off_out = left.offsets[diag_left] + right.offsets[diag_right]
+        if off_out <= -left.shape[0] or off_out >= right.shape[1]:
+          continue
+        diag_out = <idxint> (lower_bound(ptr, ptr + num_diag, off_out) - ptr)
+
+        start_left = max(0, left.offsets[diag_left]) + right.offsets[diag_right]
+        start_right = max(0, right.offsets[diag_right])
+        start_out = max(0, off_out)
+        end_left = min(left._size, left.shape[0] + left.offsets[diag_left]) + right.offsets[diag_right]
+        end_right = min(right._size, right.shape[0] + right.offsets[diag_right])
+        end_out = min(right.shape[1], left.shape[0] + off_out)
+        start = max(start_left, start_right, start_out)
+        end = min(end_left, end_right, end_out)
+
+        for col in range(start, end):
+            data[diag_out, col] += (
+              scale
+              * left.data[diag_left * left._size + col - right.offsets[diag_right]]
+              * right.data[diag_right * right._size + col]
+            )
+    return Diag((npdata, npoffsets), shape=(left.shape[0], right.shape[1]), copy=False)
+
+
+#TODO: optimize, set types etc.
+cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=1, Dense out=None):
+    _check_shape(left, right, out)
+    cdef Dense tmp = None
+    if out is None:
+        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
+    #
+    strideR_in = right.shape[1] if right.fortran else 1
+    strideC_in = right.shape[0] if not right.fortran else 1
+    strideR_out = out.shape[1] if out.fortran else 1
+    strideC_out = out.shape[0] if not out.fortran else 1
+
+    for col in range(right.shape[1]):
+      for diag in range(left.num_diag):
+        start_left = max(0, left.offsets[diag])
+        end_left = min(left._size, left.shape[0] + left.offsets[diag])
+        start_out = max(0, -left.offsets[diag])
+        end_out = min(left._size, left.shape[1] - left.offsets[diag])
+        length = min(end_left-start_left, end_out-start_out)
+        for i in range(length):
+          idx = (start_out + i) * strideR_out + col * strideC_in
+          if idx >= out.shape[0] * out.shape[1] or idx < 0:
+            print("out of bound", i, col, start_out, strideR_out, strideC_in, idx)
+            print(start_left, end_left, start_out, end_out, length)
+            continue
+          out.data[(start_out + i) * strideR_out + col * strideC_in] += (
+            scale
+            * left.data[diag * left._size + i + start_left]
+            * out.data[(start_left + i) * strideR_in + col * strideC_in]
+          )
+    return out
+
+
 cpdef CSR multiply_csr(CSR left, CSR right):
     """Element-wise multiplication of CSR matrices."""
     if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index a37e099710..0851ed34a7 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -769,6 +769,8 @@ def op_numpy(self, left, right):
         pytest.param(data.matmul_csr, CSR, CSR, CSR),
         pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
         pytest.param(data.matmul_dense, Dense, Dense, Dense),
+        pytest.param(data.matmul_diag, Diag, Diag, Diag),
+        pytest.param(data.matmul_diag_dense_dense, Diag, Dense, Dense),
     ]
 
 

From 138877596c69dc48a3711349703405fb62dcef49 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 3 May 2023 09:54:47 -0400
Subject: [PATCH 357/602] matmul_diag_dense works

---
 qutip/core/data/matmul.pyx | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 8b44d602dd..0997ccdf07 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -355,32 +355,26 @@ cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=1):
 #TODO: optimize, set types etc.
 cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=1, Dense out=None):
     _check_shape(left, right, out)
-    cdef Dense tmp = None
     if out is None:
         out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
     #
-    strideR_in = right.shape[1] if right.fortran else 1
-    strideC_in = right.shape[0] if not right.fortran else 1
-    strideR_out = out.shape[1] if out.fortran else 1
-    strideC_out = out.shape[0] if not out.fortran else 1
+    strideR_in = right.shape[1] if not right.fortran else 1
+    strideC_in = right.shape[0] if right.fortran else 1
+    strideR_out = out.shape[1] if not out.fortran else 1
+    strideC_out = out.shape[0] if out.fortran else 1
 
     for col in range(right.shape[1]):
       for diag in range(left.num_diag):
         start_left = max(0, left.offsets[diag])
         end_left = min(left._size, left.shape[0] + left.offsets[diag])
         start_out = max(0, -left.offsets[diag])
-        end_out = min(left._size, left.shape[1] - left.offsets[diag])
-        length = min(end_left-start_left, end_out-start_out)
+        end_out = min(left.shape[0], left.shape[1] - left.offsets[diag])
+        length = min(end_left - start_left, end_out - start_out)
         for i in range(length):
-          idx = (start_out + i) * strideR_out + col * strideC_in
-          if idx >= out.shape[0] * out.shape[1] or idx < 0:
-            print("out of bound", i, col, start_out, strideR_out, strideC_in, idx)
-            print(start_left, end_left, start_out, end_out, length)
-            continue
-          out.data[(start_out + i) * strideR_out + col * strideC_in] += (
+          out.data[(start_out + i) * strideR_out + col * strideC_out] += (
             scale
             * left.data[diag * left._size + i + start_left]
-            * out.data[(start_left + i) * strideR_in + col * strideC_in]
+            * right.data[(start_left + i) * strideR_in + col * strideC_in]
           )
     return out
 

From 3be1a9b5c2add8f8753c597b6560a9516c8b5862 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 3 May 2023 12:05:25 -0400
Subject: [PATCH 358/602] expect squeleton

---
 qutip/core/data/matmul.pyx | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 0997ccdf07..5decd882e5 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -596,6 +596,8 @@ cdef Dense matmul_data_dense(Data left, Dense right):
         out = matmul_csr_dense_dense(left, right)
     elif type(left) is Dense:
         out = matmul_dense(left, right)
+    elif type(left) is Diag:
+        out = matmul_diag_dense_dense(left, right)
     else:
         out = matmul(left, right)
     return out
@@ -604,6 +606,8 @@ cdef Dense matmul_data_dense(Data left, Dense right):
 cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
     if type(left) is CSR:
         matmul_csr_dense_dense(left, right, scale, out)
+    elif type(left) is Diag:
+        matmul_diag_dense_dense(left, right, scale, out)
     elif type(left) is Dense:
         matmul_dense(left, right, scale, out)
     else:

From d9fcbc2264788daf383fa26a3bbe3e25887c857e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 3 May 2023 16:23:38 -0400
Subject: [PATCH 359/602] expect_diag

---
 qutip/core/data/expect.pxd           |  5 +-
 qutip/core/data/expect.pyx           | 75 ++++++++++++++++++++++++++--
 qutip/tests/core/data/test_expect.py |  4 +-
 3 files changed, 79 insertions(+), 5 deletions(-)

diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
index 4e7d2af104..f6fcbb8071 100644
--- a/qutip/core/data/expect.pxd
+++ b/qutip/core/data/expect.pxd
@@ -1,7 +1,7 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from qutip.core.data cimport CSR, Dense, Data
+from qutip.core.data cimport CSR, Dense, Data, Diag
 
 cpdef double complex expect_csr(CSR op, CSR state) nogil except *
 cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
@@ -12,5 +12,8 @@ cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
 cpdef double complex expect_dense(Dense op, Dense state) nogil except *
 cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
 
+cpdef double complex expect_diag(Diag op, Diag state) except *
+#cpdef double complex expect_dense(Dense op, Dense state) nogil except *
+
 cdef double complex expect_data_dense(Data op, Dense state) except *
 cdef double complex expect_super_data_dense(Data op, Dense state) except *
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 1ab6c9ce2f..b5f2c20d20 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -12,10 +12,11 @@ cdef extern from "<complex>" namespace "std" nogil:
     double complex conj(double complex x)
 
 from qutip.core.data.base cimport idxint, Data
-from qutip.core.data cimport csr, CSR, Dense
+from qutip.core.data cimport csr, CSR, Dense, Diag
 
 __all__ = [
-    'expect', 'expect_csr', 'expect_csr_dense', 'expect_dense',
+    'expect', 'expect_csr', 'expect_dense', 'expect_diag',
+    'expect_csr_dense', 'expect_diag_dense',
     'expect_super', 'expect_super_csr',
     'expect_super_csr_dense', 'expect_super_dense',
 ]
@@ -32,7 +33,7 @@ cdef void _check_shape_ket(Data op, Data state) nogil except *:
 cdef void _check_shape_dm(Data op, Data state) nogil except *:
     if (
         op.shape[1] != state.shape[0]  # Matrix multiplication
-        or state.shape[0] != state.shape[1]  # State is square 
+        or state.shape[0] != state.shape[1]  # State is square
         or op.shape[0] != op.shape[1]  # Op is square
     ):
         raise ValueError("incorrect input shapes "
@@ -249,6 +250,74 @@ cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
     return out
 
 
+cpdef double complex expect_diag(Diag op, Diag state) except *:
+    cdef double complex expect = 0.
+    if state.shape[1] == 1:
+        _check_shape_ket(op, state)
+        # Since the ket is sparse and possibly unsorted. Taking the n'th
+        # element of the state require a loop on the diags. Thus 3 loops are
+        # needed.
+        for diag_ket in range(state.num_diag):
+          if -state.offsets[diag_ket] >= op._size:
+            continue
+          for diag_bra in range(state.num_diag):
+            for diag_op in range(op.num_diag):
+              if state.offsets[diag_ket] - state.offsets[diag_bra] + op.offsets[diag_op] == 0:
+                expect += (
+                  conj(state.data[diag_bra * state._size])
+                  * state.data[diag_ket * state._size]
+                  * op.data[diag_op * op._size - state.offsets[diag_ket]]
+                )
+    else:
+      _check_shape_dm(op, state)
+      for diag_op in range(op.num_diag):
+        for diag_state in range(state.num_diag):
+          if op.offsets[diag_op] == -state.offsets[diag_state]:
+
+            start_op = max(0, op.offsets[diag_op])
+            start_state = max(0, state.offsets[diag_state])
+            end_op = min(op._size, op.shape[0] + op.offsets[diag_op])
+            end_state = min(state._size, state.shape[0] + state.offsets[diag_state])
+            length = min(end_op - start_op, end_state - start_state)
+
+            for i in range(length):
+              expect += (
+                op.data[diag_op * op._size + i + start_op]
+                * state.data[diag_state * state._size + i + start_state]
+              )
+    return expect
+
+
+cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
+    cdef double complex expect = 0.
+    cdef idxint i, diag_op, start_op, end_op, strideR, stride, start_state
+    if state.shape[1] == 1:
+        _check_shape_ket(op, state)
+        for diag_op in range(op.num_diag):
+            start_op = max(0, op.offsets[diag_op])
+            end_op = min(op._size, op.shape[0] + op.offsets[diag_op])
+            for i in range(start_op, end_op):
+                expect += (
+                  op.data[diag_op * op._size + i]
+                  * state.data[i]
+                  * conj(state.data[i - op.offsets[diag_op]])
+                )
+    else:
+      _check_shape_dm(op, state)
+      stride = state.shape[0] + 1
+      strideR = state.shape[0] if state.fortran else 1
+      for diag_op in range(op.num_diag):
+        start_op = max(0, op.offsets[diag_op])
+        end_op = min(op._size, op.shape[0] + op.offsets[diag_op])
+        start_state = -op.offsets[diag_op] * strideR
+        for i in range(start_op, end_op):
+          expect += (
+            op.data[diag_op * op._size + i]
+            * state.data[start_state + i * stride]
+          )
+    return expect
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
index 256a703a89..804e0f529d 100644
--- a/qutip/tests/core/data/test_expect.py
+++ b/qutip/tests/core/data/test_expect.py
@@ -5,7 +5,7 @@
 import pytest
 import numpy as np
 from qutip import data
-from qutip.core.data import CSR, Dense
+from qutip.core.data import CSR, Dense, Diag
 from itertools import product
 
 
@@ -39,6 +39,8 @@ def op_numpy(self, op, state):
         pytest.param(data.expect_csr, CSR, CSR, complex),
         pytest.param(data.expect_dense, Dense, Dense, complex),
         pytest.param(data.expect_csr_dense, CSR, Dense, complex),
+        pytest.param(data.expect_diag, Diag, Diag, complex),
+        pytest.param(data.expect_diag_dense, Diag, Dense, complex),
     ]
 
 

From 663b8cc541f0b84524c7d030303c388b0d0fa65d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 3 May 2023 17:32:45 -0400
Subject: [PATCH 360/602] expect_super_diag

---
 qutip/core/data/dia.pyx              |  4 +--
 qutip/core/data/expect.pxd           |  5 +++-
 qutip/core/data/expect.pyx           | 38 +++++++++++++++++++++++++---
 qutip/tests/core/data/test_expect.py |  2 ++
 4 files changed, 43 insertions(+), 6 deletions(-)

diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 394918f5da..b3f16adb43 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -312,8 +312,8 @@ cpdef Diag from_dense(Dense matrix):
     out.num_diag = matrix.shape[0] + matrix.shape[1] - 1
     for i in range(matrix.shape[0] + matrix.shape[1] - 1):
         out.offsets[i] = i -matrix.shape[0] + 1
-    strideR = matrix.shape[1] if matrix.fortran else 1
-    strideC = matrix.shape[0] if not matrix.fortran else 1
+    strideR = 1 if matrix.fortran else matrix.shape[1]
+    strideC = 1 if not matrix.fortran else matrix.shape[0]
 
     for row in range(matrix.shape[0]):
         for col in range(matrix.shape[1]):
diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
index f6fcbb8071..05d33a248f 100644
--- a/qutip/core/data/expect.pxd
+++ b/qutip/core/data/expect.pxd
@@ -13,7 +13,10 @@ cpdef double complex expect_dense(Dense op, Dense state) nogil except *
 cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
 
 cpdef double complex expect_diag(Diag op, Diag state) except *
-#cpdef double complex expect_dense(Dense op, Dense state) nogil except *
+cpdef double complex expect_super_diag(Diag op, Diag state) except *
+
+cpdef double complex expect_diag_dense(Diag op, Dense state) except *
+cpdef double complex expect_super_diag_dense(Diag op, Dense state) except *
 
 cdef double complex expect_data_dense(Data op, Dense state) except *
 cdef double complex expect_super_data_dense(Data op, Dense state) except *
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index b5f2c20d20..2b00fe9a53 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -17,8 +17,8 @@ from qutip.core.data cimport csr, CSR, Dense, Diag
 __all__ = [
     'expect', 'expect_csr', 'expect_dense', 'expect_diag',
     'expect_csr_dense', 'expect_diag_dense',
-    'expect_super', 'expect_super_csr',
-    'expect_super_csr_dense', 'expect_super_dense',
+    'expect_super', 'expect_super_csr', 'expect_super_diag', 'expect_super_dense',
+    'expect_super_csr_dense', 'expect_super_diag_dense',
 ]
 
 cdef void _check_shape_ket(Data op, Data state) nogil except *:
@@ -122,7 +122,7 @@ cpdef double complex expect_csr(CSR op, CSR state) nogil except *:
     if state.shape[1] == 1:
         return _expect_csr_ket(op, state)
     return _expect_csr_dm(op, state)
-
+'expect_super_dense',
 cdef double complex _expect_csr_dense_ket(CSR op, Dense state) nogil except *:
     _check_shape_ket(op, state)
     cdef double complex out=0, sum
@@ -318,6 +318,38 @@ cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
     return expect
 
 
+cpdef double complex expect_super_diag(Diag op, Diag state) except *:
+    cdef double complex expect = 0.
+    _check_shape_super(op, state)
+    cdef idxint diag_op, diag_right
+    cdef idxint stride = <size_t> sqrt(state.shape[0]) + 1
+    for diag_op in range(op.num_diag):
+      for diag_state in range(state.num_diag):
+        if (
+            -state.offsets[diag_state] < op._size
+            and -op.offsets[diag_op] - state.offsets[diag_state] >= 0
+            and (-op.offsets[diag_op] - state.offsets[diag_state]) % stride == 0
+        ):
+            expect += state.data[diag_state * state._size] * op.data[diag_op * op._size - state.offsets[diag_state]]
+
+    return expect
+
+
+cpdef double complex expect_super_diag_dense(Diag op, Dense state) except *:
+    cdef double complex expect = 0.
+    _check_shape_super(op, state)
+    cdef idxint col, diag_op, start, end
+    cdef idxint stride = <size_t> sqrt(state.shape[0]) + 1
+    for diag_op in range(op.num_diag):
+      start = max(0, op.offsets[diag_op])
+      end = min(op._size, op.shape[0] + op.offsets[diag_op])
+      col = (((start - op.offsets[diag_op] - 1) // stride) + 1) * stride + op.offsets[diag_op]
+      while col < end:
+        expect += op.data[diag_op * op._size + col] * state.data[col]
+        col += stride
+    return expect
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
index 804e0f529d..babfbb47cb 100644
--- a/qutip/tests/core/data/test_expect.py
+++ b/qutip/tests/core/data/test_expect.py
@@ -66,4 +66,6 @@ def op_numpy(self, op, state):
         pytest.param(data.expect_super_dense, Dense, Dense, complex),
         pytest.param(data.expect_super_csr, CSR, CSR, complex),
         pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
+        pytest.param(data.expect_super_diag, Diag, Diag, complex),
+        pytest.param(data.expect_super_diag_dense, Diag, Dense, complex),
     ]

From 861eb7d92c4f278368a4a3cf0c26feae079457c0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 4 May 2023 14:49:00 -0400
Subject: [PATCH 361/602] rm _size, add project add properties

---
 qutip/core/data/add.pyx                   |  55 ++++------
 qutip/core/data/adjoint.pyx               |  26 +++--
 qutip/core/data/dia.pxd                   |   4 +-
 qutip/core/data/dia.pyx                   |  82 +++++++--------
 qutip/core/data/expect.pyx                |  36 ++++---
 qutip/core/data/matmul.pyx                | 120 ++++++++++++----------
 qutip/core/data/mul.pyx                   |   9 +-
 qutip/core/data/project.pyx               |  67 +++++++++++-
 qutip/core/data/properties.pyx            |  89 +++++++++++++++-
 qutip/core/data/tidyup.pyx                |  16 +--
 qutip/core/data/trace.pyx                 |   6 +-
 qutip/tests/core/data/test_diag.py        |  26 ++++-
 qutip/tests/core/data/test_mathematics.py |   1 +
 qutip/tests/core/data/test_properties.py  |   2 +-
 14 files changed, 347 insertions(+), 192 deletions(-)

diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index 673f77cacf..d9beff20e9 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -226,8 +226,8 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
     cdef double complex *ptr_left
     cdef double complex *ptr_right
     cdef bint sorted=True
-    cdef Diag out = dia.empty(left.shape[0], left.shape[1], left.num_diag + right.num_diag, max(left._size, right._size))
-    cdef int length, size_left = left._size, size_right = right._size
+    cdef Diag out = dia.empty(left.shape[0], left.shape[1], left.num_diag + right.num_diag)
+    cdef int length, size=left.shape[1]
 
     ptr_out = out.data
     ptr_left = left.data
@@ -237,29 +237,27 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
         while diag_left < left.num_diag and diag_right < right.num_diag:
             if left.offsets[diag_left] == right.offsets[diag_right]:
                 out.offsets[out_diag] = left.offsets[diag_left]
-                blas.zcopy(&size_left, ptr_left, &_ONE, ptr_out, &_ONE)
-                blas.zaxpy(&size_right, &scale, ptr_right, &_ONE, ptr_out, &_ONE)
-                ptr_left += size_left
+                blas.zcopy(&size, ptr_left, &_ONE, ptr_out, &_ONE)
+                blas.zaxpy(&size, &scale, ptr_right, &_ONE, ptr_out, &_ONE)
+                ptr_left += size
                 diag_left += 1
-                ptr_right += size_right
+                ptr_right += size
                 diag_right += 1
             elif left.offsets[diag_left] <= right.offsets[diag_right]:
                 out.offsets[out_diag] = left.offsets[diag_left]
-                length = min(out._size, size_left)
-                blas.zcopy(&length, ptr_left, &_ONE, ptr_out, &_ONE)
-                ptr_left += size_left
+                blas.zcopy(&size, ptr_left, &_ONE, ptr_out, &_ONE)
+                ptr_left += size
                 diag_left += 1
             else:
                 out.offsets[out_diag] = right.offsets[diag_right]
-                length = min(out._size, size_right)
-                blas.zcopy(&length, ptr_right, &_ONE, ptr_out, &_ONE)
+                blas.zcopy(&size, ptr_right, &_ONE, ptr_out, &_ONE)
                 if scale != 1:
-                    blas.zscal(&length, &scale, ptr_out, &_ONE)
-                ptr_right += size_right
+                    blas.zscal(&size, &scale, ptr_out, &_ONE)
+                ptr_right += size
                 diag_right += 1
             if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
                 sorted=False
-            ptr_out += out._size
+            ptr_out += size
             out_diag += 1
 
         if diag_left < left.num_diag:
@@ -268,14 +266,10 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
                 if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
                     sorted=False
                 out_diag += 1
-            if left._size == out._size:
-                length = left._size * (left.num_diag - diag_left)
-                blas.zcopy(&length, ptr_left, &_ONE, ptr_out, &_ONE)
-            else:
-                for i in range(left.num_diag - diag_left):
-                    blas.zcopy(&size_left, ptr_left, &_ONE, ptr_out, &_ONE)
-                    ptr_out += out._size
-                    ptr_left += left._size
+
+            length = size * (left.num_diag - diag_left)
+            blas.zcopy(&length, ptr_left, &_ONE, ptr_out, &_ONE)
+
 
         if diag_right < right.num_diag:
             for i in range(right.num_diag - diag_right):
@@ -283,18 +277,11 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
                 if out_diag != 0 and out.offsets[out_diag-1] >= out.offsets[out_diag]:
                     sorted=False
                 out_diag += 1
-            if right._size == out._size:
-                length = right._size * (right.num_diag - diag_right)
-                blas.zcopy(&length, ptr_right, &_ONE, ptr_out, &_ONE)
-                if scale != 1:
-                    blas.zscal(&length, &scale, ptr_out, &_ONE)
-            else:
-                for i in range(right.num_diag - diag_right):
-                    blas.zcopy(&size_right, ptr_right, &_ONE, ptr_out, &_ONE)
-                    if scale != 1:
-                        blas.zscal(&size_right, &scale, ptr_out, &_ONE)
-                    ptr_out += out._size
-                    ptr_right += right._size
+
+            length = size * (right.num_diag - diag_right)
+            blas.zcopy(&length, ptr_right, &_ONE, ptr_out, &_ONE)
+            if scale != 1:
+                blas.zscal(&length, &scale, ptr_out, &_ONE)
 
         out.num_diag = out_diag
 
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index 31e58be706..feb65dec62 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -111,7 +111,7 @@ cpdef Dense conj_dense(Dense matrix):
 
 
 cpdef Diag adjoint_diag(Diag matrix):
-    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag, matrix.shape[0])
+    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag)
     cdef size_t i, new_i,
     cdef idxint new_offset, j
     with nogil:
@@ -119,18 +119,16 @@ cpdef Diag adjoint_diag(Diag matrix):
         for i in range(matrix.num_diag):
             new_i = matrix.num_diag - i - 1
             new_offset = out.offsets[new_i] = -matrix.offsets[i]
-            for j in range(out._size):
-                if (j < new_offset):
-                    out.data[new_i * out._size + j] = 0.
-                elif (j - new_offset >= matrix._size):
-                    out.data[new_i * out._size + j] = 0.
+            for j in range(out.shape[1]):
+                if (j < new_offset) or (j - new_offset >= matrix.shape[1]):
+                    out.data[new_i * out.shape[1] + j] = 0.
                 else:
-                    out.data[new_i * out._size + j] = _conj(matrix.data[i * matrix._size + j - new_offset])
+                    out.data[new_i * out.shape[1] + j] = _conj(matrix.data[i * matrix.shape[1] + j - new_offset])
     return out
 
 
 cpdef Diag transpose_diag(Diag matrix):
-    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag, matrix.shape[0])
+    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag)
     cdef size_t i, new_i,
     cdef idxint new_offset, j
     with nogil:
@@ -138,11 +136,11 @@ cpdef Diag transpose_diag(Diag matrix):
         for i in range(matrix.num_diag):
             new_i = matrix.num_diag - i - 1
             new_offset = out.offsets[new_i] = -matrix.offsets[i]
-            for j in range(out._size):
-                if (j < new_offset) or (j - new_offset >= matrix._size):
-                    out.data[new_i * out._size + j] = 0.
+            for j in range(out.shape[1]):
+                if (j < new_offset) or (j - new_offset >= matrix.shape[1]):
+                    out.data[new_i * out.shape[1] + j] = 0.
                 else:
-                    out.data[new_i * out._size + j] = matrix.data[i * matrix._size + j - new_offset]
+                    out.data[new_i * out.shape[1] + j] = matrix.data[i * matrix.shape[1] + j - new_offset]
     return out
 
 
@@ -153,8 +151,8 @@ cpdef Diag conj_diag(Diag matrix):
         out.num_diag = matrix.num_diag
         for i in range(matrix.num_diag):
             out.offsets[i] = matrix.offsets[i]
-            for j in range(matrix._size):
-                out.data[i * matrix._size + j] = _conj(matrix.data[i * matrix._size + j])
+            for j in range(matrix.shape[1]):
+                out.data[i * matrix.shape[1] + j] = _conj(matrix.data[i * matrix.shape[1] + j])
     return out
 
 
diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index e8d0b5b276..c6d40b2488 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -16,7 +16,7 @@ from qutip.core.data.dense cimport Dense
 cdef class Diag(base.Data):
     cdef double complex *data
     cdef base.idxint *offsets
-    cdef readonly size_t num_diag, _size, _max_diag
+    cdef readonly size_t num_diag, _max_diag
     cdef object _scipy
     cdef bint _deallocate
     cpdef Diag copy(Diag self)
@@ -27,7 +27,7 @@ cdef class Diag(base.Data):
     cpdef Diag transpose(Diag self)
 
 cpdef Diag fast_from_scipy(object sci)
-cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.idxint size)
+cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag)
 cpdef Diag empty_like(Diag other)
 cpdef Diag zeros(base.idxint rows, base.idxint cols)
 cpdef Diag identity(base.idxint dimension, double complex scale=*)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index b3f16adb43..70d4a716e1 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -90,12 +90,8 @@ cdef class Diag(base.Data):
         data = np.array(arg[0], dtype=np.complex128, copy=copy, order='C')
         offsets = np.array(arg[1], dtype=idxint_dtype, copy=copy, order='C')
 
-        self._deallocate = False
-        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
-        self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
         self.num_diag = offsets.shape[0]
         self._max_diag = self.num_diag
-        self._size = data.shape[1]
 
         if shape is None:
             warnings.warn("instantiating Diag matrix of unknown shape")
@@ -103,11 +99,11 @@ cdef class Diag(base.Data):
             ncols = 0
             for i in range(self.num_diag):
                 pre, post = _count_element(data[i], data.shape[1])
-                if self.offsets[i] >= 0:
+                if offsets[i] >= 0:
                     row = post
-                    col = post + self.offsets[i]
+                    col = post + offsets[i]
                 else:
-                    row = pre - self.offsets[i]
+                    row = pre - offsets[i]
                     col = pre
                 nrows = nrows if nrows > row else row
                 ncols = ncols if ncols > col else col
@@ -116,13 +112,25 @@ cdef class Diag(base.Data):
             if not isinstance(shape, tuple):
                 raise TypeError("shape must be a 2-tuple of positive ints")
             if not (len(shape) == 2
-                    and isinstance(shape[0], int)
-                    and isinstance(shape[1], int)
+                    and isinstance(shape[0], numbers.Integral)
+                    and isinstance(shape[1], numbers.Integral)
                     and shape[0] > 0
                     and shape[1] > 0):
                 raise ValueError("shape must be a 2-tuple of positive ints")
             self.shape = shape
 
+        # Scipy support ``data`` with diag of any length. They can be sorter if
+        # the last columns are empty or have extra unused columns at the end.
+        if data.shape[1] != self.shape[1]:
+            new_data = np.zeros((self.num_diag, self.shape[1]), dtype=np.complex128, order='C')
+            copy_length = min(data.shape[1], self.shape[1])
+            new_data[:, :copy_length] = data[:, :copy_length]
+            data = new_data
+
+        self._deallocate = False
+        self.data = <double complex *> cnp.PyArray_GETPTR1(data, 0)
+        self.offsets = <base.idxint *> cnp.PyArray_GETPTR1(offsets, 0)
+
         self._scipy = _dia_matrix(data, offsets, self.shape)
         if tidyup:
             tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
@@ -144,7 +152,7 @@ cdef class Diag(base.Data):
         """
         cdef Diag out = empty_like(self)
         out.num_diag = self.num_diag
-        memcpy(out.data, self.data, self.num_diag * self._size * sizeof(double complex))
+        memcpy(out.data, self.data, self.num_diag * self.shape[1] * sizeof(double complex))
         memcpy(out.offsets, self.offsets, self.num_diag * sizeof(base.idxint))
 
         return out
@@ -158,14 +166,13 @@ cdef class Diag(base.Data):
         cdef cnp.npy_intp *dims = [self.shape[0], self.shape[1]]
         cdef object out = cnp.PyArray_ZEROS(2, dims, cnp.NPY_COMPLEX128, 0)
         cdef size_t col, i, nrows = self.shape[0]
-        cdef base.idxint diag, size
-        size = min(self._size, self.shape[1])
+        cdef base.idxint diag
         for i in range(self.num_diag):
             diag = self.offsets[i]
-            for col in range(size):
+            for col in range(self.shape[1]):
                 if col - diag < 0 or col - diag >= nrows:
                     continue
-                out[(col-diag), col] = self.data[i * self._size + col]
+                out[(col-diag), col] = self.data[i * self.shape[1] + col]
         return out
 
     cpdef object as_scipy(self, bint full=False):
@@ -182,7 +189,7 @@ cdef class Diag(base.Data):
         if self._scipy is not None:
             return self._scipy
         cdef cnp.npy_intp num_diag = self.num_diag if not full else self._max_diag
-        cdef cnp.npy_intp size = self._size
+        cdef cnp.npy_intp size = self.shape[1]
         data = cnp.PyArray_SimpleNewFromData(2, [num_diag, size],
                                              cnp.NPY_COMPLEX128,
                                              self.data)
@@ -241,11 +248,10 @@ cpdef Diag fast_from_scipy(object sci):
     out.offsets = <base.idxint *> cnp.PyArray_GETPTR1(sci.offsets, 0)
     out.num_diag  = sci.offsets.shape[0]
     out._max_diag  = sci.offsets.shape[0]
-    out._size = sci.data.shape[1]
     return out
 
 
-cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.idxint size):
+cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
     """
     Allocate an empty Diag matrix of the given shape, ``with num_diag``
     diagonals.
@@ -258,21 +264,18 @@ cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag, base.
     out.shape = (rows, cols)
     out.num_diag = 0
     # Python doesn't like allocating nothing.
-    if size == 0:
-        size += 1
     if num_diag == 0:
         num_diag += 1
     out._max_diag = num_diag
-    out._size = size
     out.data =\
-        <double complex *> PyDataMem_NEW(size * num_diag * sizeof(double complex))
+        <double complex *> PyDataMem_NEW(cols * num_diag * sizeof(double complex))
     out.offsets =\
         <base.idxint *> PyDataMem_NEW(num_diag * sizeof(base.idxint))
     return out
 
 
 cpdef Diag empty_like(Diag other):
-    return empty(other.shape[0], other.shape[1], other.num_diag, other._size)
+    return empty(other.shape[0], other.shape[1], other.num_diag)
 
 
 cpdef Diag zeros(base.idxint rows, base.idxint cols):
@@ -282,8 +285,8 @@ cpdef Diag zeros(base.idxint rows, base.idxint cols):
     """
     # We always allocate matrices with at least one element to ensure that we
     # actually _are_ asking for memory (Python doesn't like allocating nothing)
-    cdef Diag out = empty(rows, cols, 0, 0)
-    memset(out.data, 0, out._size * sizeof(double complex))
+    cdef Diag out = empty(rows, cols, 0)
+    memset(out.data, 0, out.shape[1] * sizeof(double complex))
     out.offsets[0] = 0
     return out
 
@@ -294,7 +297,7 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
     the diagonal.  By default this will be the identity matrix, but if `scale`
     is passed, then the result will be `scale` times the identity.
     """
-    cdef Diag out = empty(dimension, dimension, 1, dimension)
+    cdef Diag out = empty(dimension, dimension, 1)
     for i in range(dimension):
         out.data[i] = scale
     out.offsets[0] = 0
@@ -303,9 +306,8 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
 
 
 @cython.boundscheck(True)
-cpdef Diag from_dense(Dense matrix):
-    # Assume worst-case scenario for non-zero.
-    cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1, matrix.shape[1])
+cpdef Diag from_dense(Dense matrix, double tol=1e-16):
+    cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
     cdef size_t diag_, ptr_in, ptr_out=0, stride
     cdef row, col
 
@@ -319,7 +321,7 @@ cpdef Diag from_dense(Dense matrix):
         for col in range(matrix.shape[1]):
             out.data[(col - row + matrix.shape[0] - 1) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
 
-    return tidyup_diag(out, settings.core['auto_tidyup_atol'])
+    return tidyup_diag(out, tol)
 
 
 cpdef Dense to_dense(Diag matrix):
@@ -335,7 +337,7 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
     cdef base.idxint diag=0, new_diag=0, start, end, col
     cdef double complex zONE=1.
     cdef bint has_duplicate
-    cdef int length, ONE=1
+    cdef int length=out.shape[1], ONE=1
 
     # We sort using insertion sort on the offsets, summing data of duplicated.
     # This does not scale well with large number of diagonal
@@ -350,11 +352,10 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
                 smallest_diag = comp_diag
                 has_duplicate = False
             elif out.offsets[comp_diag] == smallest_offsets:
-                length = out._size
                 blas.zaxpy(
                     &length, &zONE,
-                    &out.data[comp_diag * out._size], &ONE,
-                    &out.data[smallest_diag * out._size], &ONE
+                    &out.data[comp_diag * out.shape[1]], &ONE,
+                    &out.data[smallest_diag * out.shape[1]], &ONE
                 )
                 out.offsets[comp_diag] = out.shape[1]
 
@@ -363,19 +364,18 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
             break
         if new_diag == smallest_diag:
             continue
-        length = out._size
-        blas.zswap(&length, &out.data[new_diag * out._size], &ONE, &out.data[smallest_diag * out._size], &ONE)
+        blas.zswap(&length, &out.data[new_diag * out.shape[1]], &ONE, &out.data[smallest_diag * out.shape[1]], &ONE)
         out.offsets[smallest_diag] = out.offsets[new_diag]
         out.offsets[new_diag] = smallest_offsets
 
     out.num_diag = new_diag + 1
     for diag in range(out.num_diag):
         start = max(0, out.offsets[diag])
-        end = min(out._size, out.shape[0] + out.offsets[diag])
+        end = min(out.shape[1], out.shape[0] + out.offsets[diag])
         for col in range(start):
-            out.data[diag * out._size + col] = 0.
-        for col in range(end, out._size):
-            out.data[diag * out._size + col] = 0.
+            out.data[diag * out.shape[1] + col] = 0.
+        for col in range(end, out.shape[1]):
+            out.data[diag * out.shape[1] + col] = 0.
 
     if out._scipy is not None:
         out._scipy.data = out._scipy.data[:out.num_diag]
@@ -418,13 +418,13 @@ cdef Diag diags_(
         The shape of the output.  The result does not need to be square, but
         the diagonals must be of the correct length to fit in.
     """
-    out = empty(n_rows, n_cols, len(offsets), n_cols)
+    out = empty(n_rows, n_cols, len(offsets))
     out.num_diag = len(offsets)
     for i in range(len(offsets)):
         out.offsets[i] = offsets[i]
         offset = max(offsets[i], 0)
         for col in range(len(diagonals[i])):
-            out.data[i * out._size + col + offset] = diagonals[i][col]
+            out.data[i * out.shape[1] + col + offset] = diagonals[i][col]
     return out
 
 @cython.wraparound(True)
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index 2b00fe9a53..e6060a6192 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -258,15 +258,15 @@ cpdef double complex expect_diag(Diag op, Diag state) except *:
         # element of the state require a loop on the diags. Thus 3 loops are
         # needed.
         for diag_ket in range(state.num_diag):
-          if -state.offsets[diag_ket] >= op._size:
+          if -state.offsets[diag_ket] >= op.shape[1]:
             continue
           for diag_bra in range(state.num_diag):
             for diag_op in range(op.num_diag):
               if state.offsets[diag_ket] - state.offsets[diag_bra] + op.offsets[diag_op] == 0:
                 expect += (
-                  conj(state.data[diag_bra * state._size])
-                  * state.data[diag_ket * state._size]
-                  * op.data[diag_op * op._size - state.offsets[diag_ket]]
+                  conj(state.data[diag_bra * state.shape[1]])
+                  * state.data[diag_ket * state.shape[1]]
+                  * op.data[diag_op * op.shape[1] - state.offsets[diag_ket]]
                 )
     else:
       _check_shape_dm(op, state)
@@ -276,14 +276,14 @@ cpdef double complex expect_diag(Diag op, Diag state) except *:
 
             start_op = max(0, op.offsets[diag_op])
             start_state = max(0, state.offsets[diag_state])
-            end_op = min(op._size, op.shape[0] + op.offsets[diag_op])
-            end_state = min(state._size, state.shape[0] + state.offsets[diag_state])
+            end_op = min(op.shape[1], op.shape[0] + op.offsets[diag_op])
+            end_state = min(state.shape[1], state.shape[0] + state.offsets[diag_state])
             length = min(end_op - start_op, end_state - start_state)
 
             for i in range(length):
               expect += (
-                op.data[diag_op * op._size + i + start_op]
-                * state.data[diag_state * state._size + i + start_state]
+                op.data[diag_op * op.shape[1] + i + start_op]
+                * state.data[diag_state * state.shape[1] + i + start_state]
               )
     return expect
 
@@ -295,10 +295,10 @@ cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
         _check_shape_ket(op, state)
         for diag_op in range(op.num_diag):
             start_op = max(0, op.offsets[diag_op])
-            end_op = min(op._size, op.shape[0] + op.offsets[diag_op])
+            end_op = min(op.shape[1], op.shape[0] + op.offsets[diag_op])
             for i in range(start_op, end_op):
                 expect += (
-                  op.data[diag_op * op._size + i]
+                  op.data[diag_op * op.shape[1] + i]
                   * state.data[i]
                   * conj(state.data[i - op.offsets[diag_op]])
                 )
@@ -308,11 +308,11 @@ cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
       strideR = state.shape[0] if state.fortran else 1
       for diag_op in range(op.num_diag):
         start_op = max(0, op.offsets[diag_op])
-        end_op = min(op._size, op.shape[0] + op.offsets[diag_op])
+        end_op = min(op.shape[1], op.shape[0] + op.offsets[diag_op])
         start_state = -op.offsets[diag_op] * strideR
         for i in range(start_op, end_op):
           expect += (
-            op.data[diag_op * op._size + i]
+            op.data[diag_op * op.shape[1] + i]
             * state.data[start_state + i * stride]
           )
     return expect
@@ -326,11 +326,11 @@ cpdef double complex expect_super_diag(Diag op, Diag state) except *:
     for diag_op in range(op.num_diag):
       for diag_state in range(state.num_diag):
         if (
-            -state.offsets[diag_state] < op._size
+            -state.offsets[diag_state] < op.shape[1]
             and -op.offsets[diag_op] - state.offsets[diag_state] >= 0
             and (-op.offsets[diag_op] - state.offsets[diag_state]) % stride == 0
         ):
-            expect += state.data[diag_state * state._size] * op.data[diag_op * op._size - state.offsets[diag_state]]
+            expect += state.data[diag_state * state.shape[1]] * op.data[diag_op * op.shape[1] - state.offsets[diag_state]]
 
     return expect
 
@@ -342,10 +342,10 @@ cpdef double complex expect_super_diag_dense(Diag op, Dense state) except *:
     cdef idxint stride = <size_t> sqrt(state.shape[0]) + 1
     for diag_op in range(op.num_diag):
       start = max(0, op.offsets[diag_op])
-      end = min(op._size, op.shape[0] + op.offsets[diag_op])
+      end = min(op.shape[1], op.shape[0] + op.offsets[diag_op])
       col = (((start - op.offsets[diag_op] - 1) // stride) + 1) * stride + op.offsets[diag_op]
       while col < end:
-        expect += op.data[diag_op * op._size + col] * state.data[col]
+        expect += op.data[diag_op * op.shape[1] + col] * state.data[col]
         col += stride
     return expect
 
@@ -377,6 +377,8 @@ expect.add_specialisations([
     (CSR, CSR, expect_csr),
     (CSR, Dense, expect_csr_dense),
     (Dense, Dense, expect_dense),
+    (Diag, Dense, expect_diag_dense),
+    (Diag, Diag, expect_diag),
 ], _defer=True)
 
 expect_super = _Dispatcher(
@@ -399,6 +401,8 @@ expect_super.add_specialisations([
     (CSR, CSR, expect_super_csr),
     (CSR, Dense, expect_super_csr_dense),
     (Dense, Dense, expect_super_dense),
+    (Diag, Dense, expect_super_diag_dense),
+    (Diag, Diag, expect_super_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 5decd882e5..6fd9239c33 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -313,69 +313,74 @@ cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense
     return out
 
 
-#TODO: optimize, cdef types etc.
+#TODO: optimize: not rely on numpy for unique offsets.
 cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=1):
     _check_shape(left, right, None)
-    # We could probably do faster than this without the gil etc.
+    # We could probably do faster than this...
     npoffsets = np.unique(np.add.outer(left.as_scipy().offsets, right.as_scipy().offsets))
     npoffsets = npoffsets[np.logical_and(npoffsets > -left.shape[0], npoffsets < right.shape[1])]
     cdef idxint[:] offsets = npoffsets
     if len(npoffsets) == 0:
         return dia.zeros(left.shape[0], right.shape[1])
     cdef idxint *ptr = &offsets[0]
-    cdef idxint num_diag = offsets.shape[0], diag_out, diag_left, diag_right, off_out
+    cdef size_t num_diag = offsets.shape[0], diag_out, diag_left, diag_right
+    cdef idxint start_left, end_left, start_out, end_out, start, end, col, off_out
     npdata = np.zeros((num_diag, right.shape[1]), dtype=complex)
     cdef double complex[:, ::1] data = npdata
 
-    for diag_left in range(left.num_diag):
-      for diag_right in range(right.num_diag):
-        off_out = left.offsets[diag_left] + right.offsets[diag_right]
-        if off_out <= -left.shape[0] or off_out >= right.shape[1]:
-          continue
-        diag_out = <idxint> (lower_bound(ptr, ptr + num_diag, off_out) - ptr)
-
-        start_left = max(0, left.offsets[diag_left]) + right.offsets[diag_right]
-        start_right = max(0, right.offsets[diag_right])
-        start_out = max(0, off_out)
-        end_left = min(left._size, left.shape[0] + left.offsets[diag_left]) + right.offsets[diag_right]
-        end_right = min(right._size, right.shape[0] + right.offsets[diag_right])
-        end_out = min(right.shape[1], left.shape[0] + off_out)
-        start = max(start_left, start_right, start_out)
-        end = min(end_left, end_right, end_out)
-
-        for col in range(start, end):
-            data[diag_out, col] += (
-              scale
-              * left.data[diag_left * left._size + col - right.offsets[diag_right]]
-              * right.data[diag_right * right._size + col]
-            )
+    with nogil:
+      for diag_left in range(left.num_diag):
+        for diag_right in range(right.num_diag):
+          off_out = left.offsets[diag_left] + right.offsets[diag_right]
+          if off_out <= -left.shape[0] or off_out >= right.shape[1]:
+            continue
+          diag_out = <idxint> (lower_bound(ptr, ptr + num_diag, off_out) - ptr)
+
+          start_left = max(0, left.offsets[diag_left]) + right.offsets[diag_right]
+          start_right = max(0, right.offsets[diag_right])
+          start_out = max(0, off_out)
+          end_left = min(left.shape[1], left.shape[0] + left.offsets[diag_left]) + right.offsets[diag_right]
+          end_right = min(right.shape[1], right.shape[0] + right.offsets[diag_right])
+          end_out = min(right.shape[1], left.shape[0] + off_out)
+          start = max(start_left, start_right, start_out)
+          end = min(end_left, end_right, end_out)
+
+          for col in range(start, end):
+              data[diag_out, col] += (
+                scale
+                * left.data[diag_left * left.shape[1] + col - right.offsets[diag_right]]
+                * right.data[diag_right * right.shape[1] + col]
+              )
     return Diag((npdata, npoffsets), shape=(left.shape[0], right.shape[1]), copy=False)
 
 
-#TODO: optimize, set types etc.
 cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=1, Dense out=None):
     _check_shape(left, right, out)
     if out is None:
         out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
-    #
-    strideR_in = right.shape[1] if not right.fortran else 1
-    strideC_in = right.shape[0] if right.fortran else 1
-    strideR_out = out.shape[1] if not out.fortran else 1
-    strideC_out = out.shape[0] if out.fortran else 1
-
-    for col in range(right.shape[1]):
-      for diag in range(left.num_diag):
-        start_left = max(0, left.offsets[diag])
-        end_left = min(left._size, left.shape[0] + left.offsets[diag])
-        start_out = max(0, -left.offsets[diag])
-        end_out = min(left.shape[0], left.shape[1] - left.offsets[diag])
-        length = min(end_left - start_left, end_out - start_out)
-        for i in range(length):
-          out.data[(start_out + i) * strideR_out + col * strideC_out] += (
-            scale
-            * left.data[diag * left._size + i + start_left]
-            * right.data[(start_left + i) * strideR_in + col * strideC_in]
-          )
+    cdef idxint start_left, end_left, start_out, end_out, length, i
+    cdef idxint col, strideR_in, strideC_in, strideR_out, strideC_out
+    cdef size_t diag
+
+    with nogil:
+        strideR_in = right.shape[1] if not right.fortran else 1
+        strideC_in = right.shape[0] if right.fortran else 1
+        strideR_out = out.shape[1] if not out.fortran else 1
+        strideC_out = out.shape[0] if out.fortran else 1
+
+        for col in range(right.shape[1]):
+          for diag in range(left.num_diag):
+            start_left = max(0, left.offsets[diag])
+            end_left = min(left.shape[1], left.shape[0] + left.offsets[diag])
+            start_out = max(0, -left.offsets[diag])
+            end_out = min(left.shape[0], left.shape[1] - left.offsets[diag])
+            length = min(end_left - start_left, end_out - start_out)
+            for i in range(length):
+              out.data[(start_out + i) * strideR_out + col * strideC_out] += (
+                scale
+                * left.data[diag * left.shape[1] + i + start_left]
+                * right.data[(start_left + i) * strideR_in + col * strideC_in]
+              )
     return out
 
 
@@ -452,8 +457,7 @@ cpdef Diag multiply_diag(Diag left, Diag right):
         )
     cdef idxint diag_left=0, diag_right=0, out_diag=0, col
     cdef bint sorted=True
-    cdef Diag out = dia.empty(left.shape[0], left.shape[1], min(left.num_diag, right.num_diag), max(left._size, right._size))
-    cdef int length, size_left = left._size, size_right = right._size
+    cdef Diag out = dia.empty(left.shape[0], left.shape[1], min(left.num_diag, right.num_diag))
 
     with nogil:
       for diag_left in range(1, left.num_diag):
@@ -472,13 +476,13 @@ cpdef Diag multiply_diag(Diag left, Diag right):
         while diag_left < left.num_diag and diag_right < right.num_diag:
             if left.offsets[diag_left] == right.offsets[diag_right]:
                 out.offsets[out_diag] = left.offsets[diag_left]
-                for col in range(out._size):
-                    if col >= left._size or col >= right._size:
-                        out.data[out_diag * out._size + col] = 0
+                for col in range(out.shape[1]):
+                    if col >= left.shape[1] or col >= right.shape[1]:
+                        out.data[out_diag * out.shape[1] + col] = 0
                     else:
-                        out.data[out_diag * out._size + col] = (
-                            left.data[diag_left * left._size + col] *
-                            right.data[diag_right * right._size + col]
+                        out.data[out_diag * out.shape[1] + col] = (
+                            left.data[diag_left * left.shape[1] + col] *
+                            right.data[diag_right * right.shape[1] + col]
                         )
                 out_diag += 1
                 diag_left += 1
@@ -493,10 +497,10 @@ cpdef Diag multiply_diag(Diag left, Diag right):
           for diag_right in range(right.num_diag):
             if left.offsets[diag_left] == right.offsets[diag_right]:
                 out.offsets[out_diag] = left.offsets[diag_left]
-                for col in range(size_right):
-                    out.data[out_diag * out._size + col] = (
-                        left.data[diag_left * left._size + col] *
-                        right.data[diag_right * right._size + col]
+                for col in range(right.shape[1]):
+                    out.data[out_diag * out.shape[1] + col] = (
+                        left.data[diag_left * left.shape[1] + col] *
+                        right.data[diag_right * right.shape[1] + col]
                     )
                 out_diag += 1
                 break
@@ -565,6 +569,8 @@ matmul.add_specialisations([
     (CSR, CSR, CSR, matmul_csr),
     (CSR, Dense, Dense, matmul_csr_dense_dense),
     (Dense, Dense, Dense, matmul_dense),
+    (Diag, Diag, Diag, matmul_diag),
+    (Diag, Dense, Dense, matmul_diag_dense_dense),
 ], _defer=True)
 
 
diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 68a06c7d12..4cc9663be6 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -41,7 +41,7 @@ cpdef CSR neg_csr(CSR matrix):
 
 cpdef Diag imul_diag(Diag matrix, double complex value):
     """Multiply this Diag `matrix` by a complex scalar `value`."""
-    cdef idxint l = matrix.num_diag * matrix._size
+    cdef idxint l = matrix.num_diag * matrix.shape[1]
     cdef int ONE=1
     zscal(&l, &value, matrix.data, &ONE)
     return matrix
@@ -51,7 +51,7 @@ cpdef Diag mul_diag(Diag matrix, double complex value):
     if value == 0:
         return dia.zeros(matrix.shape[0], matrix.shape[1])
     cdef Diag out = dia.empty_like(matrix)
-    cdef idxint ptr, diag, l = matrix.num_diag * matrix._size
+    cdef idxint ptr, diag, l = matrix.num_diag * matrix.shape[1]
     with nogil:
         for ptr in range(l):
             out.data[ptr] = value * matrix.data[ptr]
@@ -63,7 +63,7 @@ cpdef Diag mul_diag(Diag matrix, double complex value):
 cpdef Diag neg_diag(Diag matrix):
     """Unary negation of this Diag `matrix`.  Return a new object."""
     cdef Diag out = matrix.copy()
-    cdef idxint ptr, l = matrix.num_diag * matrix._size
+    cdef idxint ptr, l = matrix.num_diag * matrix.shape[1]
     with nogil:
         for ptr in range(l):
             out.data[ptr] = -matrix.data[ptr]
@@ -114,6 +114,7 @@ mul.__doc__ =\
     """Multiply a matrix element-wise by a scalar."""
 mul.add_specialisations([
     (CSR, CSR, mul_csr),
+    (Diag, Diag, mul_diag),
     (Dense, Dense, mul_dense),
 ], _defer=True)
 
@@ -134,6 +135,7 @@ imul.__doc__ =\
     """Multiply inplace a matrix element-wise by a scalar."""
 imul.add_specialisations([
     (CSR, CSR, imul_csr),
+    (Diag, Diag, imul_diag),
     (Dense, Dense, imul_dense),
 ], _defer=True)
 
@@ -150,6 +152,7 @@ neg.__doc__ =\
     """Unary element-wise negation of a matrix."""
 neg.add_specialisations([
     (CSR, CSR, neg_csr),
+    (Diag, Diag, neg_diag),
     (Dense, Dense, neg_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
index 9d086fa2c7..4b096f8c69 100644
--- a/qutip/core/data/project.pyx
+++ b/qutip/core/data/project.pyx
@@ -1,17 +1,17 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from libc.string cimport memcpy
+from libc.string cimport memcpy, memset
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, Dense
+from qutip.core.data cimport csr, dense, Dense, dia, Diag
 from qutip.core.data.csr cimport CSR
 
 cdef extern from "<complex>" namespace "std" nogil:
     double complex conj(double complex x)
 
 __all__ = [
-    'project', 'project_csr', 'project_dense',
+    'project', 'project_csr', 'project_dense', 'project_diag',
 ]
 
 
@@ -67,6 +67,7 @@ cdef void _project_bra_csr(CSR bra, CSR out) nogil:
     for row_out in range(row_out, out.shape[0]):
         out.row_index[row_out + 1] = cur
 
+
 cpdef CSR project_csr(CSR state):
     """
     Calculate the projection |state><state|.  The shape of `state` will be used
@@ -89,6 +90,7 @@ cpdef CSR project_csr(CSR state):
         return out
     raise ValueError("state must be a ket or a bra.")
 
+
 cpdef Dense project_dense(Dense state):
     """
     Calculate the projection |state><state|.  The shape of `state` will be used
@@ -96,7 +98,7 @@ cpdef Dense project_dense(Dense state):
     function will be identical is passed `state` or `adjoint(state)`.
     """
     cdef Dense out
-    cdef size_t size, i
+    cdef size_t size, i, j
     cdef bint fortran
     if state.shape[1] == 1:
         size = state.shape[0]
@@ -113,6 +115,62 @@ cpdef Dense project_dense(Dense state):
     return out
 
 
+cpdef Diag project_diag(Diag state):
+    """
+    Calculate the projection |state><state|.  The shape of `state` will be used
+    to determine if it has been supplied as a ket or a bra.  The result of this
+    function will be identical is passed `state` or `adjoint(state)`.
+    """
+    cdef Diag out
+    cdef size_t size, i, j, k, num_diag=0, max_diag
+    if state.shape[1] == 1:
+        size = state.shape[0]
+    elif state.shape[0] == 1:
+        size = state.shape[1]
+    else:
+        raise ValueError("state must be a ket or a bra.")
+
+    max_diag = state.num_diag * state.num_diag - state.num_diag + 1
+    out = dia.empty(size, size, max_diag)
+    memset(out.data, 0, max_diag * out.shape[1] * sizeof(double complex))
+
+    if state.shape[1] == 1:
+        for i in range(state.num_diag):
+            for j in range(state.num_diag):
+                k = 0
+                out_offset = (state.offsets[i] - state.offsets[j])
+                while k < num_diag:
+                    if out_offset == out.offsets[k]:
+                        num_diag -= 1
+                        break
+                    k += 1
+                num_diag += 1
+                out.offsets[k] = out_offset
+
+                out.data[k * size + abs(state.offsets[j])] = (
+                    state.data[i] * conj(state.data[j])
+                )
+    else:
+        for i in range(state.num_diag):
+            for j in range(state.num_diag):
+                k = 0
+                out_offset = (state.offsets[i] - state.offsets[j])
+                while k < num_diag:
+                    if out_offset == out.offsets[k]:
+                        num_diag -= 1
+                        break
+                    k += 1
+                num_diag += 1
+                out.offsets[k] = out_offset
+
+                out.data[k * size + abs(state.offsets[i])] = (
+                    state.data[i * state.shape[1] + abs(state.offsets[i])]
+                    * conj(state.data[j * state.shape[1] + abs(state.offsets[j])])
+                )
+
+    out.num_diag = num_diag
+    return out
+
 
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
@@ -138,6 +196,7 @@ project.__doc__ =\
     """
 project.add_specialisations([
     (CSR, CSR, project_csr),
+    (Diag, Diag, project_diag),
     (Dense, Dense, project_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
index 97509fda8c..849673737c 100644
--- a/qutip/core/data/properties.pyx
+++ b/qutip/core/data/properties.pyx
@@ -7,7 +7,7 @@ from cpython cimport mem
 from qutip.settings import settings
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense
+from qutip.core.data cimport csr, dense, CSR, Dense, Diag
 from qutip.core.data.adjoint cimport transpose_csr
 
 cdef extern from *:
@@ -15,9 +15,9 @@ cdef extern from *:
     void *PyMem_Calloc(size_t nelem, size_t elsize)
 
 __all__ = [
-    'isherm', 'isherm_csr', 'isherm_dense',
-    'isdiag', 'isdiag_csr', 'isdiag_dense',
-    'iszero', 'iszero_csr', 'iszero_dense',
+    'isherm', 'isherm_csr', 'isherm_dense', 'isherm_diag',
+    'isdiag', 'isdiag_csr', 'isdiag_dense', 'isdiag_diag',
+    'iszero', 'iszero_csr', 'iszero_dense', 'iszero_diag',
 ]
 
 cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
@@ -79,6 +79,7 @@ cdef bint _isherm_csr_full(CSR matrix, double tol) except 2:
                 return False
     return True
 
+
 cpdef bint isherm_csr(CSR matrix, double tol=-1):
     """
     Determine whether an input CSR matrix is Hermitian up to a given
@@ -144,6 +145,50 @@ cpdef bint isherm_csr(CSR matrix, double tol=-1):
         mem.PyMem_Free(out_row_index)
 
 
+cpdef bint isherm_diag(Diag matrix, double tol=-1) nogil:
+    cdef double complex val, valT
+    cdef size_t diag, other_diag, col, start, end, other_start
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    if matrix.shape[0] != matrix.shape[1]:
+        return False
+    for diag in range(matrix.num_diag):
+        if matrix.offsets[diag] == 0:
+            for col in range(matrix.shape[1]):
+                val = valT = matrix.data[diag * matrix.shape[1] + col]
+                if not _conj_feq(val, valT, tol):
+                    return False
+            continue
+        other_diag = 0
+        while other_diag < matrix.num_diag:
+            if matrix.offsets[diag] == -matrix.offsets[other_diag]:
+                break
+            other_diag += 1
+
+        if other_diag < diag:
+            continue
+
+        start = max(0, matrix.offsets[diag])
+        end = min(matrix.shape[1], matrix.shape[0] + matrix.offsets[diag])
+
+        if other_diag == matrix.num_diag:
+            # No matching diag, should be 0
+            for col in range(start, end):
+                val = matrix.data[diag * matrix.shape[1] + col]
+                if not _feq_zero(val, tol):
+                    return False
+            continue
+
+        other_start = max(0, matrix.offsets[other_diag])
+        for col in range(end - start):
+            val = matrix.data[diag * matrix.shape[1] + col + start]
+            valT = matrix.data[other_diag * matrix.shape[1] + col + other_start]
+            if not _conj_feq(val, valT, tol):
+                return False
+    return True
+
+
 cpdef bint isherm_dense(Dense matrix, double tol=-1):
     """
     Determine whether an input Dense matrix is Hermitian up to a given
@@ -177,6 +222,23 @@ cpdef bint isherm_dense(Dense matrix, double tol=-1):
     return True
 
 
+cpdef bint isdiag_diag(Diag matrix, double tol=-1) nogil:
+    cdef size_t diag, start, end, col
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    cdef double tolsq = tol*tol
+    for diag in range(matrix.num_diag):
+        if matrix.offsets[diag] == 0:
+            continue
+        start = max(0, matrix.offsets[diag])
+        end = min(matrix.shape[1], matrix.shape[0] + matrix.offsets[diag])
+        for col in range(start, end):
+            if _abssq(matrix.data[diag * matrix.shape[1] + col]) > tolsq:
+                return False
+    return True
+
+
 cpdef bint isdiag_csr(CSR matrix) nogil:
     cdef size_t row, ptr_start, ptr_end=matrix.row_index[0]
     for row in range(matrix.shape[0]):
@@ -199,6 +261,21 @@ cpdef bint isdiag_dense(Dense matrix) nogil:
     return True
 
 
+cpdef bint iszero_diag(Diag matrix, double tol=-1) nogil:
+    cdef size_t diag, start, end, col
+    if tol < 0:
+        with gil:
+            tol = settings.core["atol"]
+    cdef double tolsq = tol*tol
+    for diag in range(matrix.num_diag):
+        start = max(0, matrix.offsets[diag])
+        end = min(matrix.shape[1], matrix.shape[0] + matrix.offsets[diag])
+        for col in range(start, end):
+            if _abssq(matrix.data[diag * matrix.shape[1] + col]) > tolsq:
+                return False
+    return True
+
+
 cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
     cdef size_t ptr
     if tol < 0:
@@ -210,6 +287,7 @@ cpdef bint iszero_csr(CSR matrix, double tol=-1) nogil:
             return False
     return True
 
+
 cpdef bint iszero_dense(Dense matrix, double tol=-1) nogil:
     cdef size_t ptr
     if tol < 0:
@@ -256,6 +334,7 @@ isherm.__doc__ =\
     """
 isherm.add_specialisations([
     (Dense, isherm_dense),
+    (Diag, isherm_diag),
     (CSR, isherm_csr),
 ], _defer=True)
 
@@ -279,6 +358,7 @@ isdiag.__doc__ =\
     """
 isdiag.add_specialisations([
     (Dense, isdiag_dense),
+    (Diag, isdiag_diag),
     (CSR, isdiag_csr),
 ], _defer=True)
 
@@ -313,6 +393,7 @@ iszero.__doc__ =\
     """
 iszero.add_specialisations([
     (CSR, iszero_csr),
+    (Diag, iszero_diag),
     (Dense, iszero_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
index d5e0258860..e72e9671a7 100644
--- a/qutip/core/data/tidyup.pyx
+++ b/qutip/core/data/tidyup.pyx
@@ -65,25 +65,25 @@ cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=True):
 
     while diag < out.num_diag:
         start = max(0, out.offsets[diag])
-        end = min(out._size, out.shape[0] + out.offsets[diag])
+        end = min(out.shape[1], out.shape[0] + out.offsets[diag])
         has_data = False
         for col in range(start, end):
             re = False
             im = False
-            if fabs(out.data[diag * out._size + col].real) < tol:
+            if fabs(out.data[diag * out.shape[1] + col].real) < tol:
                 re = True
-                out.data[diag * out._size + col].real = 0
-            if fabs(out.data[diag * out._size + col].imag) < tol:
+                out.data[diag * out.shape[1] + col].real = 0
+            if fabs(out.data[diag * out.shape[1] + col].imag) < tol:
                 im = True
-                out.data[diag * out._size + col].imag = 0
+                out.data[diag * out.shape[1] + col].imag = 0
             has_data |= not (re & im)
 
         if has_data and new_diag < diag:
-            length = out._size
+            length = out.shape[1]
             blas.zcopy(
                 &length,
-                &out.data[diag * out._size], &ONE,
-                &out.data[new_diag * out._size], &ONE
+                &out.data[diag * out.shape[1]], &ONE,
+                &out.data[new_diag * out.shape[1]], &ONE
             )
             out.offsets[new_diag] = out.offsets[diag]
 
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 4f8b6b1ec8..246919308d 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -54,8 +54,8 @@ cpdef double complex trace_diag(Diag matrix) except * nogil:
     cdef size_t diag, j
     for diag in range(matrix.num_diag):
         if matrix.offsets[diag] == 0:
-            for j in range(matrix._size):
-                trace += matrix.data[diag * matrix._size + j]
+            for j in range(matrix.shape[1]):
+                trace += matrix.data[diag * matrix.shape[1] + j]
             break
     return trace
 
@@ -89,7 +89,7 @@ cpdef double complex trace_oper_ket_diag(Diag matrix) except * nogil:
     cdef size_t stride = N + 1
     for diag in range(matrix.num_diag):
         if -matrix.offsets[diag] % stride == 0:
-            trace += matrix.data[diag * matrix._size]
+            trace += matrix.data[diag * matrix.shape[1]]
     return trace
 
 
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 3b4d3fe141..7c3b64a902 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -3,7 +3,7 @@
 import pytest
 
 from qutip.core import data, qeye, CoreOptions
-from qutip.core.data import dia
+from qutip.core.data import dia, Dense, Diag
 
 from . import conftest
 
@@ -193,7 +193,7 @@ def test_as_scipy_is_correct_result(self, scipy_dia):
 
     def test_as_scipy_of_uninitialised_is_empty(self, shape):
         ndiag = 0
-        base = dia.empty(shape[0], shape[1], ndiag, shape[1])
+        base = dia.empty(shape[0], shape[1], ndiag)
         sci = base.as_scipy()
         assert len(sci.data) == 0
         assert len(sci.offsets) == 0
@@ -205,17 +205,33 @@ def test_to_array_is_correct_result(self, data_diag):
         # mathematics, so they should be _identical_.
         assert np.all(test_array == data_diag.as_scipy().toarray())
 
+    def test_to_dense(self, data_diag):
+        data_dense = dia.to_dense(data_diag)
+        assert isinstance(data_dense, Dense)
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(data_dense.to_array() == data_diag.as_scipy().toarray())
+        assert np.all(data_dense.to_array() == data_diag.to_array())
+
+    def test_from_dense(self, scipy_dia):
+        dense = Dense(scipy_dia.toarray())
+        data_diag = dia.from_dense(dense)
+        assert isinstance(data_diag, Diag)
+        # It's not enough to be accurate within a tolerance here - there's no
+        # mathematics, so they should be _identical_.
+        assert np.all(data_diag.to_array() == data_diag.as_scipy().toarray())
+        assert np.all(data_diag.to_array() == data_diag.to_array())
+
 
 class TestFactoryMethods:
     def test_empty(self, shape, density):
         ndiag = int(shape[0] * shape[1] * density) or 1
-        size = np.random.randint(shape[1]) or 1
-        base = dia.empty(shape[0], shape[1], ndiag, size)
+        base = dia.empty(shape[0], shape[1], ndiag)
         sci = base.as_scipy(full=True)
         assert isinstance(base, dia.Diag)
         assert isinstance(sci, scipy.sparse.dia_matrix)
         assert base.shape == shape
-        assert sci.data.shape == (ndiag, size)
+        assert sci.data.shape == (ndiag, shape[1])
         assert sci.offsets.shape == (ndiag,)
 
     def test_zeros(self, shape):
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 0851ed34a7..f7dbbb305b 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -941,6 +941,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.project_csr, CSR, CSR),
+        pytest.param(data.project_diag, Diag, Diag),
         pytest.param(data.project_dense, Dense, Dense),
     ]
 
diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
index de844baec7..8aeaa048a4 100644
--- a/qutip/tests/core/data/test_properties.py
+++ b/qutip/tests/core/data/test_properties.py
@@ -4,7 +4,7 @@
 from qutip import data as _data
 
 
-@pytest.fixture(params=[_data.CSR, _data.Dense], ids=["CSR", "Dense"])
+@pytest.fixture(params=[_data.CSR, _data.Dense, _data.Diag], ids=["CSR", "Dense", "Diag"])
 def datatype(request):
     return request.param
 

From f7e7e089bdf6dd9edec9a8a7d89c4a2c724ac470 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 4 May 2023 15:09:38 -0400
Subject: [PATCH 362/602] dia.from_dense use auto_tidyup

---
 qutip/core/data/dia.pyx                  |  7 +++++--
 qutip/tests/core/data/test_properties.py | 16 ++++++++++------
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 70d4a716e1..c40a03c9de 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -306,7 +306,7 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
 
 
 @cython.boundscheck(True)
-cpdef Diag from_dense(Dense matrix, double tol=1e-16):
+cpdef Diag from_dense(Dense matrix):
     cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
     cdef size_t diag_, ptr_in, ptr_out=0, stride
     cdef row, col
@@ -321,7 +321,10 @@ cpdef Diag from_dense(Dense matrix, double tol=1e-16):
         for col in range(matrix.shape[1]):
             out.data[(col - row + matrix.shape[0] - 1) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
 
-    return tidyup_diag(out, tol)
+    if settings.core["auto_tidyup"]:
+        tidyup_diag(out, settings.core["auto_tidyup_atol"], True)
+
+    return out
 
 
 cpdef Dense to_dense(Diag matrix):
diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
index 8aeaa048a4..70e956ac20 100644
--- a/qutip/tests/core/data/test_properties.py
+++ b/qutip/tests/core/data/test_properties.py
@@ -2,7 +2,7 @@
 import pytest
 
 from qutip import data as _data
-
+from qutip import CoreOptions
 
 @pytest.fixture(params=[_data.CSR, _data.Dense, _data.Diag], ids=["CSR", "Dense", "Diag"])
 def datatype(request):
@@ -73,9 +73,11 @@ def test_compare_implicit_zero_structure(self, datatype):
         zeros.
         """
 
-        base = _data.to(
-            datatype, _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
-        )
+        with CoreOptions(auto_tidyup=False):
+            base = _data.to(
+                datatype,
+                _data.create(np.array([[1, self.tol * 1e-3j], [0, 1]]))
+            )
         # If this first line fails, the zero has been stored explicitly and so
         # the test is invalid.
         assert np.count_nonzero(base.to_array()) == 3
@@ -127,7 +129,8 @@ def test_compare_implicit_zero_random(self, datatype, density):
         base[np.random.rand(n, n) > density] = 0
         np.fill_diagonal(base, self.tol * 1000)
         nnz = np.count_nonzero(base)
-        base = _data.to(datatype, _data.create(base))
+        with CoreOptions(auto_tidyup=False):
+            base = _data.to(datatype, _data.create(base))
         assert np.count_nonzero(base.to_array()) == nnz
         assert _data.isherm(base, tol=self.tol)
         assert _data.isherm(base.transpose(), tol=self.tol)
@@ -143,7 +146,8 @@ def test_compare_implicit_zero_random(self, datatype, density):
             base[np.random.rand(n, n) > density] = 0
             np.fill_diagonal(base, self.tol * 1000)
             nnz = np.count_nonzero(base)
-        base = _data.to(datatype, _data.create(base))
+        with CoreOptions(auto_tidyup=False):
+            base = _data.to(datatype, _data.create(base))
         assert np.count_nonzero(base.to_array()) == nnz
         assert not _data.isherm(base, tol=self.tol)
         assert not _data.isherm(base.transpose(), tol=self.tol)

From 7d1dfde69505fb2b3894f275a3b051866e4b860e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 8 May 2023 16:08:52 -0400
Subject: [PATCH 363/602] Add kron and expm

---
 qutip/core/data/dia.pyx                   |  3 +
 qutip/core/data/expm.py                   | 34 ++++++++++-
 qutip/core/data/kron.pyx                  | 73 ++++++++++++++++++++++-
 qutip/tests/core/data/test_mathematics.py |  2 +
 4 files changed, 108 insertions(+), 4 deletions(-)

diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index c40a03c9de..5b1a88e39d 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -342,6 +342,9 @@ cpdef Diag clean_diag(Diag matrix, bint inplace=False):
     cdef bint has_duplicate
     cdef int length=out.shape[1], ONE=1
 
+    if out.num_diag == 0:
+        return out
+
     # We sort using insertion sort on the offsets, summing data of duplicated.
     # This does not scale well with large number of diagonal
     for new_diag in range(out.num_diag):
diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index 1a24e983be..aa969f56bb 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -4,12 +4,14 @@
 
 from .dense import Dense
 from .csr import CSR
-from .properties import isdiag_csr
+from .dia import Diag
+from . import dia
+from .properties import isdiag_csr, isdiag_diag
 from qutip.settings import settings
 from .base import idxint_dtype
 
 __all__ = [
-    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense',
+    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense', 'expm_diag',
     'logm', 'logm_dense',
 ]
 
@@ -37,6 +39,33 @@ def expm_csr(matrix: CSR) -> CSR:
                tidyup=settings.core['auto_tidyup'])
 
 
+def expm_diag(matrix: Diag) -> Diag:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("can only exponentiate square matrix")
+    if matrix.num_diag == 0:
+        out = dia.identity(matrix.shape[0])
+    elif matrix.num_diag > 1:
+        csc = matrix.as_scipy().tocsc()
+        out = Diag(scipy.sparse.linalg.expm(csc).todia(),
+                   tidyup=settings.core['auto_tidyup'], copy=False)
+    elif isdiag_diag(matrix):
+        matrix_sci = matrix.as_scipy()
+        data = np.exp(matrix_sci.data[0, :])
+        out = dia.diags(data, shape=matrix.shape)
+    else:
+        # Only one diag, this would be better implemented in cython
+        tmp = matrix
+        out = dia.identity(matrix.shape[0])
+        n = 1
+        fact = 1
+        while tmp.num_diag and n < matrix.shape[0]:
+            out = out + tmp * 1 / fact
+            n += 1
+            fact *= n
+            tmp = tmp @ matrix
+    return out
+
+
 def expm_csr_dense(matrix: CSR) -> Dense:
     if matrix.shape[0] != matrix.shape[1]:
         raise ValueError("can only exponentiate square matrix")
@@ -67,6 +96,7 @@ def expm_dense(matrix: Dense) -> Dense:
     (CSR, CSR, expm_csr),
     (CSR, Dense, expm_csr_dense),
     (Dense, Dense, expm_dense),
+    (Diag, Diag, expm_diag),
 ], _defer=True)
 
 
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index 262d74add7..d7e382715f 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -2,15 +2,17 @@
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
 cimport cython
+from libc.string cimport memset
 
 from qutip.core.data.base cimport idxint
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data cimport csr
+from qutip.core.data.dia cimport Diag
+from qutip.core.data cimport csr, dia
 import numpy
 
 __all__ = [
-    'kron', 'kron_csr', 'kron_dense'
+    'kron', 'kron_csr', 'kron_dense', 'kron_diag',
 ]
 
 
@@ -65,6 +67,72 @@ cpdef CSR kron_csr(CSR left, CSR right):
     return out
 
 
+cdef inline void _vec_kron(double complex * ptr_l, double complex * ptr_r, double complex * ptr_out, idxint size_l, idxint size_r) nogil:
+    cdef idxint i, j
+    for i in range(size_l):
+        for j in range(size_r):
+            ptr_out[i*size_r+j] = ptr_l[i] * ptr_r[j]
+
+
+cpdef Diag kron_diag(Diag left, Diag right):
+    cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
+    cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
+    cdef idxint nrows=_mul_checked(nrows_l, nrows_r)
+    cdef idxint ncols=_mul_checked(ncols_l, ncols_r)
+    cdef idxint max_diag=_mul_checked(right.num_diag, left.num_diag)
+    cdef idxint num_diag=0, diag_left, diag_right, delta, col_left, col_right
+    cdef idxint start_left, end_left, start_right, end_right
+    cdef Diag out
+
+    if right.shape[0] == right.shape[1]:
+        out = dia.empty(nrows, ncols, max_diag)
+        for diag_left in range(left.num_diag):
+            for diag_right in range(right.num_diag):
+                out.offsets[num_diag] = (
+                    left.offsets[diag_left] * right.shape[0]
+                    + right.offsets[diag_right]
+                )
+                _vec_kron(
+                    left.data + (diag_left * ncols_l),
+                    right.data + (diag_right * ncols_r),
+                    out.data + (num_diag * ncols),
+                    left.shape[1], right.shape[1]
+                )
+                num_diag += 1
+
+    else:
+        out = dia.empty(nrows, ncols, _mul_checked(max_diag, ncols_l))
+        delta = right.shape[0] - right.shape[1]
+        for diag_left in range(left.num_diag):
+            for diag_right in range(right.num_diag):
+                start_left = max(0, left.offsets[diag_left])
+                end_left = min(left.shape[1], left.shape[0] + left.offsets[diag_left])
+                for col_left in range(start_left, end_left):
+                    memset(
+                        out.data + (num_diag * out.shape[1]), 0,
+                        out.shape[1] * sizeof(double complex)
+                    )
+
+                    out.offsets[num_diag] = (
+                        left.offsets[diag_left] * right.shape[0]
+                        + right.offsets[diag_right]
+                        - col_left * delta
+                    )
+
+                    start_right = max(0, right.offsets[diag_right])
+                    end_right = min(right.shape[1], right.shape[0] + right.offsets[diag_right])
+                    for col_right in range(start_right, end_right):
+                        out.data[num_diag * out.shape[1] + col_left * right.shape[1] + col_right] = (
+                            right.data[diag_right * right.shape[1] + col_right]
+                            * left.data[diag_left * left.shape[1] + col_left]
+                        )
+                    num_diag += 1
+
+    out.num_diag = num_diag
+    out = dia.clean_diag(out, True)
+    return out
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -86,6 +154,7 @@ kron.__doc__ =\
 kron.add_specialisations([
     (CSR, CSR, CSR, kron_csr),
     (Dense, Dense, Dense, kron_dense),
+    (Diag, Diag, Diag, kron_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index f7dbbb305b..87461503bf 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -756,6 +756,7 @@ def op_numpy(self, left, right):
     specialisations = [
         pytest.param(data.kron_csr, CSR, CSR, CSR),
         pytest.param(data.kron_dense, Dense, Dense, Dense),
+        pytest.param(data.kron_diag, Diag, Diag, Diag),
     ]
 
 
@@ -897,6 +898,7 @@ def op_numpy(self, matrix):
         pytest.param(data.expm_csr, CSR, CSR),
         pytest.param(data.expm_csr_dense, CSR, Dense),
         pytest.param(data.expm_dense, Dense, Dense),
+        pytest.param(data.expm_diag, Diag, Diag),
     ]
 
 

From bf4dbe9f7b087e0c97ca8a8b17bd587f1a238de5 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 9 May 2023 13:52:21 -0400
Subject: [PATCH 364/602] add pow and inner

---
 qutip/core/data/expect.pyx                |  8 +-
 qutip/core/data/expm.py                   | 27 ++++---
 qutip/core/data/inner.pyx                 | 90 ++++++++++++++++++++++-
 qutip/core/data/pow.pyx                   | 35 ++++++++-
 qutip/tests/core/data/test_mathematics.py |  3 +
 5 files changed, 145 insertions(+), 18 deletions(-)

diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index e6060a6192..bc55e1ed8d 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -252,14 +252,16 @@ cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
 
 cpdef double complex expect_diag(Diag op, Diag state) except *:
     cdef double complex expect = 0.
+    cdef idxint diag_bra, diag_op, diag_ket, i, length
+    cdef idxint start_op, start_state, end_op, end_state
     if state.shape[1] == 1:
         _check_shape_ket(op, state)
         # Since the ket is sparse and possibly unsorted. Taking the n'th
         # element of the state require a loop on the diags. Thus 3 loops are
         # needed.
         for diag_ket in range(state.num_diag):
-          if -state.offsets[diag_ket] >= op.shape[1]:
-            continue
+          #if -state.offsets[diag_ket] >= op.shape[1]:
+          #  continue
           for diag_bra in range(state.num_diag):
             for diag_op in range(op.num_diag):
               if state.offsets[diag_ket] - state.offsets[diag_bra] + op.offsets[diag_op] == 0:
@@ -321,7 +323,7 @@ cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
 cpdef double complex expect_super_diag(Diag op, Diag state) except *:
     cdef double complex expect = 0.
     _check_shape_super(op, state)
-    cdef idxint diag_op, diag_right
+    cdef idxint diag_op, diag_state
     cdef idxint stride = <size_t> sqrt(state.shape[0]) + 1
     for diag_op in range(op.num_diag):
       for diag_state in range(state.num_diag):
diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index aa969f56bb..36982b7479 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -53,16 +53,23 @@ def expm_diag(matrix: Diag) -> Diag:
         data = np.exp(matrix_sci.data[0, :])
         out = dia.diags(data, shape=matrix.shape)
     else:
-        # Only one diag, this would be better implemented in cython
-        tmp = matrix
-        out = dia.identity(matrix.shape[0])
-        n = 1
-        fact = 1
-        while tmp.num_diag and n < matrix.shape[0]:
-            out = out + tmp * 1 / fact
-            n += 1
-            fact *= n
-            tmp = tmp @ matrix
+        mat = matrix.as_scipy()
+        size = matrix.shape[0]
+        offset = mat.offsets[0]
+        n_offset = offset
+        a_offset = abs(offset)
+        data = mat.data[0, max(0, offset): min(size, size + offset)]
+        data_0 = data
+        out_oufsets = np.arange(0, size, a_offset, dtype=idxint_dtype)
+        out_oufsets *= np.sign(offset)
+        out_data = np.zeros((len(out_oufsets), size), dtype=complex)
+        out_data[0, :] += 1.
+        for i in range(1, len(out_oufsets)):
+            out_data[i, max(0, n_offset): min(size, size + n_offset)] = data
+            data = data_0[:-abs(n_offset)] * data[a_offset:] / (i+1)
+            n_offset += offset
+        out = Diag((out_data, out_oufsets), shape=matrix.shape, copy=False)
+
     return out
 
 
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index 14b35a403c..afde68061c 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -8,11 +8,12 @@ from qutip.core.data.base cimport idxint, Data
 from qutip.core.data cimport csr, dense
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.dia cimport Diag
 from qutip.core.data.matmul cimport matmul_dense
 
 __all__ = [
-    'inner', 'inner_csr', 'inner_dense',
-    'inner_op', 'inner_op_csr', 'inner_op_dense',
+    'inner', 'inner_csr', 'inner_dense', 'inner_diag',
+    'inner_op', 'inner_op_csr', 'inner_op_dense', 'inner_op_diag',
 ]
 
 
@@ -90,6 +91,45 @@ cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) no
         return _inner_csr_bra_ket(left, right)
     return _inner_csr_ket_ket(left, right)
 
+cpdef double complex inner_diag(Diag left, Diag right, bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner(left, right)
+    cdef double complex inner = 0.
+    cdef idxint diag_left, diag_right
+    cdef bint is_ket
+    if right.shape[0] == 1:
+        is_ket = scalar_is_ket
+    else:
+        is_ket = left.shape[0] == right.shape[0]
+
+    if is_ket:
+      for diag_right in range(right.num_diag):
+        for diag_left in range(left.num_diag):
+          if left.offsets[diag_left] - right.offsets[diag_right] == 0:
+            inner += (
+              conj(left.data[diag_left * left.shape[1]])
+              * right.data[diag_right * right.shape[1]]
+            )
+    else:
+      for diag_right in range(right.num_diag):
+        for diag_left in range(left.num_diag):
+          if left.offsets[diag_left] + right.offsets[diag_right] == 0:
+            inner += (
+              left.data[diag_left * left.shape[1] + left.offsets[diag_left]]
+              * right.data[diag_right * right.shape[1]]
+            )
+
+    return inner
+
 cpdef double complex inner_dense(Dense left, Dense right, bint scalar_is_ket=False) nogil except *:
     """
     Compute the complex inner product <left|right>.  The shape of `left` is
@@ -149,6 +189,50 @@ cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
         out += conj(left.data[ptr_l]) * sum
     return out
 
+cpdef double complex inner_op_diag(Diag left, Diag op, Diag right,
+                                   bint scalar_is_ket=False) nogil except *:
+    """
+    Compute the complex inner product <left|op|right>.  The shape of `left` is
+    used to determine if it has been supplied as a ket or a bra.  The result of
+    this function will be identical if passed `left` or `adjoint(left)`.
+
+    The parameter `scalar_is_ket` is only intended for the case where `left`
+    and `right` are both of shape (1, 1).  In this case, `left` will be assumed
+    to be a ket unless `scalar_is_ket` is False.  This parameter is ignored at
+    all other times.
+    """
+    _check_shape_inner_op(left, op, right)
+    cdef double complex inner = 0., val
+    cdef idxint diag_left, diag_op, diag_right
+    cdef int is_ket
+    if op.shape[0] == 1:
+        is_ket = scalar_is_ket
+    else:
+        is_ket = left.shape[0] == op.shape[0]
+
+    if is_ket:
+      for diag_right in range(right.num_diag):
+        for diag_left in range(left.num_diag):
+          for diag_op in range(op.num_diag):
+            if -left.offsets[diag_left] + right.offsets[diag_right] + op.offsets[diag_op] == 0:
+              inner += (
+                conj(left.data[diag_left])
+                * right.data[diag_right]
+                * op.data[diag_op * op.shape[1] - right.offsets[diag_right]]
+              )
+    else:
+      for diag_right in range(right.num_diag):
+        for diag_left in range(left.num_diag):
+          for diag_op in range(op.num_diag):
+            if left.offsets[diag_left] + right.offsets[diag_right] + op.offsets[diag_op] == 0:
+              inner += (
+                left.data[diag_left * left.shape[1] + left.offsets[diag_left]]
+                * right.data[diag_right]
+                * op.data[diag_op * op.shape[1] - right.offsets[diag_right]]
+              )
+
+    return inner
+
 cpdef double complex inner_op_csr(CSR left, CSR op, CSR right,
                                   bint scalar_is_ket=False) nogil except *:
     """
@@ -231,6 +315,7 @@ inner.__doc__ =\
     """
 inner.add_specialisations([
     (CSR, CSR, inner_csr),
+    (Diag, Diag, inner_diag),
     (Dense, Dense, inner_dense),
 ], _defer=True)
 
@@ -280,6 +365,7 @@ inner_op.__doc__ =\
     """
 inner_op.add_specialisations([
     (CSR, CSR, CSR, inner_op_csr),
+    (Diag, Diag, Diag, inner_op_diag),
     (Dense, Dense, Dense, inner_op_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
index d530c44080..f5f05f5bdd 100644
--- a/qutip/core/data/pow.pyx
+++ b/qutip/core/data/pow.pyx
@@ -3,14 +3,15 @@
 
 cimport cython
 
-from qutip.core.data cimport csr, dense
+from qutip.core.data cimport csr, dense, dia
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.matmul cimport matmul_csr
+from qutip.core.data.dia cimport Diag
+from qutip.core.data.matmul cimport matmul_csr, matmul_diag
 import numpy as np
 
 __all__ = [
-    'pow', 'pow_csr', 'pow_dense',
+    'pow', 'pow_csr', 'pow_dense', 'pow_diag',
 ]
 
 
@@ -41,6 +42,33 @@ cpdef CSR pow_csr(CSR matrix, unsigned long long n):
     return out
 
 
+@cython.nonecheck(False)
+@cython.cdivision(True)
+cpdef Diag pow_diag(Diag matrix, unsigned long long n):
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("matrix power only works with square matrices")
+    if n == 0:
+        return dia.identity(matrix.shape[0])
+    if n == 1:
+        return matrix.copy()
+    # We do the matrix power in terms of powers of two, so we can do it
+    # ceil(lg(n)) + bits(n) - 1 matrix mulitplications, where `bits` is the
+    # number of set bits in the input.
+    #
+    # We don't have to do matrix.copy() or pow.copy() here, because we've
+    # guaranteed that we won't be returning without at least one matrix
+    # multiplcation, which will allocate a new matrix.
+    cdef Diag pow = matrix
+    cdef Diag out = pow if n & 1 else None
+    n >>= 1
+    while n:
+        pow = matmul_diag(pow, pow)
+        if n & 1:
+            out = pow if out is None else matmul_diag(out, pow)
+        n >>= 1
+    return out
+
+
 cpdef Dense pow_dense(Dense matrix, unsigned long long n):
     if matrix.shape[0] != matrix.shape[1]:
         raise ValueError("matrix power only works with square matrices")
@@ -81,6 +109,7 @@ pow.__doc__ =\
 pow.add_specialisations([
     (CSR, CSR, pow_csr),
     (Dense, Dense, pow_dense),
+    (Diag, Diag, pow_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 87461503bf..c936dc05b0 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -638,6 +638,7 @@ def op_numpy(self, left, right, scalar_is_ket=False):
 
     specialisations = [
         pytest.param(data.inner_csr, CSR, CSR, complex),
+        pytest.param(data.inner_diag, Diag, Diag, complex),
         pytest.param(data.inner_dense, Dense, Dense, complex),
     ]
 
@@ -708,6 +709,7 @@ def op_numpy(self, left, mid, right, scalar_is_ket=False):
 
     specialisations = [
         pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
+        pytest.param(data.inner_op_diag, Diag, Diag, Diag, complex),
         pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
     ]
 
@@ -866,6 +868,7 @@ def op_numpy(self, matrix, n):
     specialisations = [
         pytest.param(data.pow_csr, CSR, CSR),
         pytest.param(data.pow_dense, Dense, Dense),
+        pytest.param(data.pow_diag, Diag, Diag),
     ]
 
     @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])

From 6023da86a9a64d0146643ea63e351b40244a458d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 9 May 2023 16:22:19 -0400
Subject: [PATCH 365/602] add extract_diag

---
 qutip/core/data/extract.py    | 31 ++++++++++++++++++++++++++++---
 qutip/tests/core/test_qobj.py | 12 ++++++++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index b7c71bc2fa..302ce05262 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -1,4 +1,4 @@
-from . import dense, csr, Dense, CSR
+from . import Dense, CSR, Diag
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 try:
@@ -36,7 +36,7 @@ def extract_dense(matrix, format=None, copy=True):
 
 def extract_csr(matrix, format=None, copy=True):
     """
-    Return the scipy's object ``csr_array``.
+    Return the scipy's object ``csr_matrix``.
 
     Parameters
     ----------
@@ -45,7 +45,6 @@ def extract_csr(matrix, format=None, copy=True):
 
     format : str, {"csr_matrix"}
         Type of the output.
-        "csr_array" is available with scipy >= 1.8
 
     copy : bool, default: True
         Whether to pass a copy of the object or not.
@@ -60,6 +59,31 @@ def extract_csr(matrix, format=None, copy=True):
     return csr_mat
 
 
+def extract_diag(matrix, format=None, copy=True):
+    """
+    Return the scipy's object ``dia_array``.
+
+    Parameters
+    ----------
+    matrix : Data
+        The matrix to convert to common type.
+
+    format : str, {"dia_matrix"}
+        Type of the output.
+
+    copy : bool, default: True
+        Whether to pass a copy of the object or not.
+    """
+    if format not in [None, "scipy_dia", "dia_matrix"]:
+        raise ValueError(
+            "Diag can only be extracted to 'dia_matrix'"
+        )
+    dia_mat = matrix.as_scipy()
+    if copy:
+        dia_mat = dia_mat.copy()
+    return dia_mat
+
+
 extract = _Dispatcher(
     _inspect.Signature([
         _inspect.Parameter('matrix', _inspect.Parameter.POSITIONAL_ONLY),
@@ -95,6 +119,7 @@ def extract_csr(matrix, format=None, copy=True):
     """
 extract.add_specialisations([
     (CSR, extract_csr),
+    (Diag, extract_diag),
     (Dense, extract_dense),
 ], _defer=True)
 
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 2668056b0e..924cd71f5f 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1255,3 +1255,15 @@ def test_data_as():
     with pytest.raises(ValueError) as err:
         qobj.data_as("csr_matrix")
     assert "ndarray" in str(err.value)
+
+    qobj = qutip.qeye(2, dtype="Diag")
+
+    assert scipy.sparse.isspmatrix_dia(qobj.data_as("dia_matrix"))
+    assert scipy.sparse.isspmatrix_dia(qobj.data_as(copy=False))
+
+    qobj.data_as(copy=False).data[:, 0] = 0
+    qobj.data_as(copy=True).data[:, 0] = 2
+    assert qobj == qutip.num(2, dtype="Diag")
+    with pytest.raises(ValueError) as err:
+        qobj.data_as("ndarray")
+    assert "dia_matrix" in str(err.value)

From 304510bdc78eacc71ceee32125b45695d28413e4 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 10 May 2023 15:54:00 -0400
Subject: [PATCH 366/602] Add norm + all tests passes

---
 qutip/core/data/dia.pyx            |  1 +
 qutip/core/data/norm.pxd           | 11 ++++++-
 qutip/core/data/norm.pyx           | 46 +++++++++++++++++++++++++++++-
 qutip/tests/core/data/test_norm.py |  6 +++-
 4 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 5b1a88e39d..e9b0263dd8 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -308,6 +308,7 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
 @cython.boundscheck(True)
 cpdef Diag from_dense(Dense matrix):
     cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
+    memset(out.data, 0, out._max_diag * out.shape[1] * sizeof(double complex))
     cdef size_t diag_, ptr_in, ptr_out=0, stride
     cdef row, col
 
diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
index 5e1b7ebe0d..4b4e677d68 100644
--- a/qutip/core/data/norm.pxd
+++ b/qutip/core/data/norm.pxd
@@ -1,7 +1,7 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from qutip.core.data cimport CSR, Dense, Data
+from qutip.core.data cimport CSR, Dense, Data, Diag
 
 cpdef double one_csr(CSR matrix) except -1
 cpdef double trace_csr(CSR matrix) except -1
@@ -12,4 +12,13 @@ cpdef double l2_csr(CSR matrix) nogil except -1
 cpdef double frobenius_dense(Dense matrix) nogil
 cpdef double l2_dense(Dense matrix) nogil except -1
 
+cpdef double one_diag(Diag matrix) except -1
+cpdef double max_diag(Diag matrix) nogil
+cpdef double frobenius_diag(Diag matrix) nogil
+cpdef double l2_diag(Diag matrix) except -1 nogil
+
 cpdef double frobenius_data(Data state)
+
+cdef inline int int_max(int a, int b) nogil:
+    # Name collision between the ``max`` builtin and norm.max
+    return b if b > a else a
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 7f0611ad78..3d91095c0d 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -7,8 +7,9 @@ from cpython cimport mem
 
 from scipy.linalg cimport cython_blas as blas
 import scipy
+import numpy as np
 
-from qutip.core.data cimport CSR, Dense, csr, dense, Data
+from qutip.core.data cimport CSR, Dense, csr, Data, Diag
 
 from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
 from qutip.core.data.matmul cimport matmul_csr
@@ -133,6 +134,45 @@ cpdef double l2_dense(Dense matrix) nogil except -1:
         raise ValueError("L2 norm is only defined on vectors")
     return frobenius_dense(matrix)
 
+cpdef double frobenius_diag(Diag matrix) nogil:
+    cdef int offset, diag, start, end, col=1
+    cdef double total=0, cur
+    for diag in range(matrix.num_diag):
+        offset = matrix.offsets[diag]
+        start = int_max(0, offset)
+        end = min(matrix.shape[1], matrix.shape[0] + offset)
+        for col in range(start, end):
+            total += abssq(matrix.data[diag * matrix.shape[1] + col])
+    return math.sqrt(total)
+
+cpdef double l2_diag(Diag matrix) except -1 nogil:
+    if matrix.shape[0] != 1 and matrix.shape[1] != 1:
+        raise ValueError("L2 norm is only defined on vectors")
+    return frobenius_diag(matrix)
+
+cpdef double max_diag(Diag matrix) nogil:
+    cdef int offset, diag, start, end, col=1
+    cdef double total=0, cur
+    for diag in range(matrix.num_diag):
+        offset = matrix.offsets[diag]
+        start = int_max(0, offset)
+        end = min(matrix.shape[1], matrix.shape[0] + offset)
+        for col in range(start, end):
+            cur = abssq(matrix.data[diag * matrix.shape[1] + col])
+            total = cur if cur > total else total
+    return math.sqrt(total)
+
+cpdef double one_diag(Diag matrix) except -1:
+    cdef int offset, diag, start, end, col=1
+    cols_one = np.zeros(matrix.shape[1], dtype=float)
+    for diag in range(matrix.num_diag):
+        offset = matrix.offsets[diag]
+        start = int_max(0, offset)
+        end = min(matrix.shape[1], matrix.shape[0] + offset)
+        for col in range(start, end):
+            cols_one[col] += abs(matrix.data[diag * matrix.shape[1] + col])
+    return np.max(cols_one)
+
 
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
@@ -154,6 +194,7 @@ l2.__doc__ =\
     """
 l2.add_specialisations([
     (Dense, l2_dense),
+    (Diag, l2_diag),
     (CSR, l2_csr),
 ], _defer=True)
 
@@ -171,6 +212,7 @@ frobenius.__doc__ =\
     """
 frobenius.add_specialisations([
     (Dense, frobenius_dense),
+    (Diag, frobenius_diag),
     (CSR, frobenius_csr),
 ], _defer=True)
 
@@ -183,6 +225,7 @@ max.__doc__ =\
     """
 max.add_specialisations([
     (Dense, max_dense),
+    (Diag, max_diag),
     (CSR, max_csr),
 ], _defer=True)
 
@@ -195,6 +238,7 @@ one.__doc__ =\
     """
 one.add_specialisations([
     (Dense, one_dense),
+    (Diag, one_diag),
     (CSR, one_csr),
 ], _defer=True)
 
diff --git a/qutip/tests/core/data/test_norm.py b/qutip/tests/core/data/test_norm.py
index d285bb3ebf..423f958289 100644
--- a/qutip/tests/core/data/test_norm.py
+++ b/qutip/tests/core/data/test_norm.py
@@ -3,7 +3,7 @@
 import scipy.linalg
 import pytest
 from qutip import data
-from qutip.core.data import CSR, Dense
+from qutip.core.data import CSR, Dense, Diag
 import numbers
 
 
@@ -13,6 +13,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.norm.one_csr, CSR, numbers.Number),
+        pytest.param(data.norm.one_diag, Diag, numbers.Number),
         pytest.param(data.norm.one_dense, Dense, numbers.Number),
     ]
 
@@ -23,6 +24,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
+        pytest.param(data.norm.frobenius_diag, Diag, numbers.Number),
         pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
     ]
 
@@ -35,6 +37,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.norm.max_csr, CSR, numbers.Number),
+        pytest.param(data.norm.max_diag, Diag, numbers.Number),
         pytest.param(data.norm.max_dense, Dense, numbers.Number),
     ]
 
@@ -55,6 +58,7 @@ def op_numpy(self, matrix):
     ]
     specialisations = [
         pytest.param(data.norm.l2_csr, CSR, numbers.Number),
+        pytest.param(data.norm.l2_diag, Diag, numbers.Number),
         pytest.param(data.norm.l2_dense, Dense, numbers.Number),
     ]
 

From 186900c4dc1449846af50a19760dd57b4eeacff0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 10 May 2023 16:28:11 -0400
Subject: [PATCH 367/602] add solve

---
 qutip/core/data/solve.py             | 15 ++++++++++-----
 qutip/tests/core/data/test_linalg.py |  8 +++++---
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index e809608e6b..a13edcb09b 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -1,9 +1,10 @@
-from qutip.core.data import CSR, Data, csr, Dense
+from qutip.core.data import CSR, Data, csr, Dense, Diag
 import qutip.core.data as _data
 import scipy.sparse.linalg as splinalg
 import numpy as np
 from qutip.settings import settings
 import warnings
+from typing import Union
 
 if settings.has_mkl:
     from qutip._mkl.spsolve import mkl_spsolve
@@ -11,7 +12,7 @@
     mkl_spsolve = None
 
 
-__all__ = ["solve_csr_dense", "solve_dense", "solve"]
+__all__ = ["solve_csr_dense", "solve_diag_dense", "solve_dense", "solve"]
 
 
 def _splu(A, B, **kwargs):
@@ -19,7 +20,7 @@ def _splu(A, B, **kwargs):
     return lu.solve(B)
 
 
-def solve_csr_dense(matrix: CSR, target: Dense, method=None,
+def solve_csr_dense(matrix: Union[CSR, Diag], target: Dense, method=None,
                     options: dict={}) -> Dense:
     """
     Solve ``Ax=b`` for ``x``.
@@ -27,7 +28,7 @@ def solve_csr_dense(matrix: CSR, target: Dense, method=None,
     Parameters:
     -----------
 
-    matrix : CSR
+    matrix : CSR, Diag
         The matrix ``A``.
 
     target : Data
@@ -79,7 +80,7 @@ def solve_csr_dense(matrix: CSR, target: Dense, method=None,
 
     options = options.copy()
     M = matrix.as_scipy()
-    if options.pop("csc", False):
+    if options.pop("csc", False) or isinstance(matrix, Diag):
         M = M.tocsc()
 
     with warnings.catch_warnings():
@@ -112,6 +113,9 @@ def solve_csr_dense(matrix: CSR, target: Dense, method=None,
     return Dense(out, copy=False)
 
 
+solve_diag_dense = solve_csr_dense
+
+
 def solve_dense(matrix: Dense, target: Data, method=None,
                 options: dict={}) -> Dense:
     """
@@ -218,6 +222,7 @@ def solve_dense(matrix: Dense, target: Data, method=None,
 """
 solve.add_specialisations([
     (CSR, Dense, Dense, solve_csr_dense),
+    (Diag, Dense, Dense, solve_diag_dense),
     (Dense, Dense, Dense, solve_dense),
 ], _defer=True)
 
diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index 1d553fcd9f..c36c120bba 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -3,9 +3,10 @@
 import scipy
 import pytest
 import qutip
+import warnings
 
 from qutip.core import data as _data
-from qutip.core.data import Data, Dense, CSR
+from qutip.core.data import Data, Dense, CSR, Diag
 
 
 skip_no_mkl = pytest.mark.skipif(
@@ -36,12 +37,13 @@ def _gen_ket(self, N, dtype):
             "spsolve", "splu", "gmres", "lsqr", "solve", "lstsq", "mkl_spsolve"
         ]
     )
-    def test_mathematically_correct_CSR(self, method, opt):
+    @pytest.mark.parametrize('dtype', [CSR, Diag])
+    def test_mathematically_correct_sparse(self, method, opt, dtype):
         """
         Test that the binary operation is mathematically correct for all the
         known type specialisations.
         """
-        A = self._gen_op(10, CSR)
+        A = self._gen_op(10, dtype)
         b = self._gen_ket(10, Dense)
         expected = self.op_numpy(A.to_array(), b.to_array())
         test = _data.solve_csr_dense(A, b, method, opt)

From 0d5b8e0d52ec1da81c45ff5cbd87207a466dc4fb Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Thu, 11 May 2023 15:57:49 +0900
Subject: [PATCH 368/602] Added link to where tutorial notebook will be

---
 doc/guide/dynamics/dynamics-monte.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index ea03ccd5bf..000c61e7dc 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -303,7 +303,7 @@ The only difference is how the collapse operators and rate functions should be d
 Note that we give the actual rate and not its square root, and that ``nm_mcsolve`` automatically computes associated jump rates :math:`\Gamma_n(t)\geq0` appropriate for simulation.
 
 We conclude with a simple example demonstrating the usage of the ``nm_mcsolve`` function.
-For more elaborate, physically motivated examples, we refer to the accompanying tutorial notebook [TODO].
+For more elaborate, physically motivated examples, we refer to the `accompanying tutorial notebook <https://github.com/qutip/qutip-tutorials/blob/main/tutorials-v5/time-evolution/013_nonmarkovian_monte_carlo.md>`_.
 
 
 .. plot::

From bed472c63bfa6040b327f0a3910ff9840ca67f00 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 11 May 2023 11:30:33 -0400
Subject: [PATCH 369/602] Robust kron

---
 qutip/core/data/kron.pyx                  | 24 +++++++++++++++++------
 qutip/tests/core/data/test_diag.py        |  2 +-
 qutip/tests/core/data/test_mathematics.py |  2 ++
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index d7e382715f..b849d148d0 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -67,11 +67,15 @@ cpdef CSR kron_csr(CSR left, CSR right):
     return out
 
 
-cdef inline void _vec_kron(double complex * ptr_l, double complex * ptr_r, double complex * ptr_out, idxint size_l, idxint size_r) nogil:
+cdef inline void _vec_kron(
+    double complex * ptr_l, double complex * ptr_r, double complex * ptr_out,
+    idxint size_l, idxint size_r, idxint step
+):
     cdef idxint i, j
+    print(size_l, size_r, step)
     for i in range(size_l):
         for j in range(size_r):
-            ptr_out[i*size_r+j] = ptr_l[i] * ptr_r[j]
+            ptr_out[i*step+j] = ptr_l[i] * ptr_r[j]
 
 
 cpdef Diag kron_diag(Diag left, Diag right):
@@ -86,17 +90,25 @@ cpdef Diag kron_diag(Diag left, Diag right):
 
     if right.shape[0] == right.shape[1]:
         out = dia.empty(nrows, ncols, max_diag)
+        memset(
+            out.data, 0,
+            max_diag * out.shape[1] * sizeof(double complex)
+        )
         for diag_left in range(left.num_diag):
             for diag_right in range(right.num_diag):
                 out.offsets[num_diag] = (
                     left.offsets[diag_left] * right.shape[0]
                     + right.offsets[diag_right]
                 )
+                start_left = max(0, left.offsets[diag_left])
+                end_left = min(left.shape[1], left.offsets[diag_left] + left.shape[0])
                 _vec_kron(
-                    left.data + (diag_left * ncols_l),
-                    right.data + (diag_right * ncols_r),
-                    out.data + (num_diag * ncols),
-                    left.shape[1], right.shape[1]
+                    left.data + (diag_left * ncols_l) + max(0, left.offsets[diag_left]),
+                    right.data + (diag_right * ncols_r) + max(0, right.offsets[diag_right]),
+                    out.data + (num_diag * ncols) + max(0, left.offsets[diag_left]) * right.shape[0] + max(0, right.offsets[diag_right]),
+                    end_left - start_left,
+                    right.shape[1] - abs(right.offsets[diag_right]),
+                    right.shape[1]
                 )
                 num_diag += 1
 
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 7c3b64a902..585fcb60af 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -83,7 +83,7 @@ def test_init_from_tuple_allowed_dtypes(self, d_type, o_type):
         the correct type.
         """
         sci = _valid_scipy()
-        data = sci.data.astype(d_type, casting='unsafe')
+        data = sci.data.real.astype(d_type, casting='unsafe')
         offsets = sci.offsets.astype(o_type, casting='unsafe')
         scipy_dia = scipy.sparse.dia_matrix((data, offsets), shape=sci.shape)
         out = dia.Diag((data, offsets), shape=sci.shape)
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index c936dc05b0..73c5543539 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -891,6 +891,8 @@ def test_incorrect_shape_raises(self, op, data_m):
             op(data_m(), 10)
 
 
+# Scipy complain went creating full dia matrix.
+@pytest.mark.filterwarnings("ignore:Constructing a DIA matrix")
 class TestExpm(UnaryOpMixin):
     def op_numpy(self, matrix):
         return scipy.linalg.expm(matrix)

From 0358b012ad87db6109486bbfdaa810f06e7b916f Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Fri, 12 May 2023 20:56:21 +0900
Subject: [PATCH 370/602] nm_mcsolve: added more tests

---
 qutip/tests/solver/test_nm_mcsolve.py | 50 +++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index a478f79afc..ba524a8fa4 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -62,6 +62,56 @@ def test_rough_agreement_with_mesolve_for_negative_rates():
     )
 
 
+def test_completeness_relation():
+    """
+    NonMarkovianMCSolver guarantees that the operators in solver.ops
+    satisfy the completeness relation ``sum(Li.dag() * Li) = a*I`` where a is a
+    constant and I the identity.
+    """
+    # some arbitrary H
+    H = qutip.sigmaz()
+    ground_state = qutip.basis(2, 1)
+    # test using all combinations of the following operators
+    from itertools import combinations
+    all_ops_and_rates = [
+        (qutip.sigmap(), 1),
+        (qutip.sigmam(), 1),
+        (qutip.sigmaz(), 1),
+        (1j * qutip.qeye(2), 1),
+    ]
+    # empty ops_and_rates not allowed
+    for n in range(1, len(all_ops_and_rates) + 1):
+        for ops_and_rates in combinations(all_ops_and_rates, n):
+            solver = NonMarkovianMCSolver(H, ops_and_rates)
+            op = sum((L.dag() * L) for L in solver.ops)
+            a_candidate = qutip.expect(op, ground_state)
+            assert op == a_candidate * qutip.qeye(op.dims[0])
+
+
+def test_solver_pickleable():
+    """
+    NonMarkovianMCSolver objects must be pickleable for multiprocessing.
+    """
+    import pickle
+    # arbitrary Hamiltonian and Lindblad operator
+    H = qutip.sigmaz()
+    L = qutip.sigmam()
+    # try various types of coefficient functions
+    rates = [
+        0,
+        _return_constant,
+        "sin(t)",
+    ]
+    args = [
+        None,
+        {'constant': 1},
+        None,
+    ]
+    for rate, arg in zip(rates, args):
+        solver = NonMarkovianMCSolver(H, [(L, rate)], args=arg)
+        pickle.dumps(solver)
+
+
 def _return_constant(t, args):
     return args['constant']
 

From d8a920d976143e1703dec45364bfb5f060ea60ea Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 12 May 2023 12:58:59 -0400
Subject: [PATCH 371/602] Update gitignore to include c++ src

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index e9cd9d2670..399d4c4af0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,6 +29,7 @@ rhs*.pyx
 
 qutip/cy/*.c
 *.cpp
+!qutip/data/src/*.cpp
 *.dat
 qutip/core/*.h
 

From f72d15019d94335b2a777c8770f2aa06f5e88441 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 12 May 2023 13:03:03 -0400
Subject: [PATCH 372/602] Faster matmul diag using vectorization

---
 .gitignore                                 |  2 +-
 qutip/core/data/matmul.pyx                 | 63 ++++++++++++++++++----
 qutip/core/data/src/matmul_diag_vector.cpp | 42 +++++++++++++++
 qutip/core/data/src/matmul_diag_vector.hpp | 16 ++++++
 setup.py                                   |  1 +
 5 files changed, 113 insertions(+), 11 deletions(-)
 create mode 100644 qutip/core/data/src/matmul_diag_vector.cpp
 create mode 100644 qutip/core/data/src/matmul_diag_vector.hpp

diff --git a/.gitignore b/.gitignore
index 399d4c4af0..619d39250c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,7 +29,7 @@ rhs*.pyx
 
 qutip/cy/*.c
 *.cpp
-!qutip/data/src/*.cpp
+!qutip/core/data/src/*.cpp
 *.dat
 qutip/core/*.h
 
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 6fd9239c33..f5da40ba0c 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -24,6 +24,7 @@ from qutip.core.data.dia cimport Diag
 from qutip.core.data.tidyup cimport tidyup_diag
 from qutip.core.data cimport csr, dense, dia
 from qutip.core.data.add cimport iadd_dense, add_csr
+from qutip.core.data.mul cimport imul_dense
 from qutip.core.data.dense import OrderEfficiencyWarning
 
 cnp.import_array()
@@ -41,6 +42,12 @@ cdef extern from "src/matmul_csr_vector.hpp" nogil:
         double complex *vec, double complex scale, double complex *out,
         T nrows)
 
+cdef extern from "src/matmul_diag_vector.hpp" nogil:
+    void _matmul_diag_vector[T](
+        double complex *data, double complex *vec, double complex *out,
+        T length, double complex scale)
+
+
 __all__ = [
     'matmul', 'matmul_csr', 'matmul_dense', 'matmul_diag',
     'matmul_csr_dense_dense', 'matmul_diag_dense_dense',
@@ -356,18 +363,46 @@ cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=1):
 
 cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=1, Dense out=None):
     _check_shape(left, right, out)
-    if out is None:
-        out = dense.zeros(left.shape[0], right.shape[1], right.fortran)
-    cdef idxint start_left, end_left, start_out, end_out, length, i
+    cdef Dense tmp
+    if out is not None and scale == 1.:
+        tmp = out
+        out = None
+    else:
+        tmp = dense.zeros(left.shape[0], right.shape[1], right.fortran)
+
+    cdef idxint start_left, end_left, start_out, end_out, length, i, start_right
     cdef idxint col, strideR_in, strideC_in, strideR_out, strideC_out
     cdef size_t diag
 
     with nogil:
-        strideR_in = right.shape[1] if not right.fortran else 1
-        strideC_in = right.shape[0] if right.fortran else 1
-        strideR_out = out.shape[1] if not out.fortran else 1
-        strideC_out = out.shape[0] if out.fortran else 1
+      strideR_in = right.shape[1] if not right.fortran else 1
+      strideC_in = right.shape[0] if right.fortran else 1
+      strideR_out = tmp.shape[1] if not tmp.fortran else 1
+      strideC_out = tmp.shape[0] if tmp.fortran else 1
 
+      if (strideR_in == 1) and (strideR_out == 1):
+        for col in range(right.shape[1]):
+          for diag in range(left.num_diag):
+            start_left = max(0, left.offsets[diag])
+            end_left = min(left.shape[1], left.shape[0] + left.offsets[diag])
+            start_out = max(0, -left.offsets[diag])
+            end_out = min(left.shape[0], left.shape[1] - left.offsets[diag])
+            length = min(end_left - start_left, end_out - start_out)
+            start_right = start_left + col * strideC_in
+            start_left += diag * left.shape[1]
+            start_out += col * strideC_out
+            _matmul_diag_vector(
+                left.data + start_left,
+                right.data + start_right,
+                tmp.data + start_out,
+                length, 1.
+            )
+            # for i in range(length):
+            #   tmp.data[start_out + i] += (
+            #     left.data[start_left + i] * right.data[start_right + i]
+            #   )
+
+      else:
         for col in range(right.shape[1]):
           for diag in range(left.num_diag):
             start_left = max(0, left.offsets[diag])
@@ -376,11 +411,19 @@ cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale
             end_out = min(left.shape[0], left.shape[1] - left.offsets[diag])
             length = min(end_left - start_left, end_out - start_out)
             for i in range(length):
-              out.data[(start_out + i) * strideR_out + col * strideC_out] += (
-                scale
-                * left.data[diag * left.shape[1] + i + start_left]
+              tmp.data[(start_out + i) * strideR_out + col * strideC_out] += (
+                left.data[diag * left.shape[1] + i + start_left]
                 * right.data[(start_left + i) * strideR_in + col * strideC_in]
               )
+
+    if out is None and scale == 1.:
+        out = tmp
+    elif out is None:
+        imul_dense(tmp, scale)
+        out = tmp
+    else:
+        iadd_dense(out, tmp, scale)
+
     return out
 
 
diff --git a/qutip/core/data/src/matmul_diag_vector.cpp b/qutip/core/data/src/matmul_diag_vector.cpp
new file mode 100644
index 0000000000..a57654fc26
--- /dev/null
+++ b/qutip/core/data/src/matmul_diag_vector.cpp
@@ -0,0 +1,42 @@
+#include <complex>
+
+#include "matmul_diag_vector.hpp"
+
+template <typename IntT>
+void _matmul_diag_vector(
+        const std::complex<double> * _RESTRICT data,
+        const std::complex<double> * _RESTRICT vec,
+        std::complex<double> * _RESTRICT out,
+        const IntT length,
+        const std::complex<double> scale
+){
+    const double * data_dbl = reinterpret_cast<const double *>(data);
+    const double * vec_dbl = reinterpret_cast<const double *>(vec);
+    double * out_dbl = reinterpret_cast<double *>(out);
+    // Gcc does not vectorize complex automatically?
+    for (IntT i=0; i<length*2; i+=2){
+        out_dbl[i] += data_dbl[i] * vec_dbl[i];
+        out_dbl[i] -= data_dbl[i+1] * vec_dbl[i+1];
+        out_dbl[i+1] += data_dbl[i] * vec_dbl[i+1];
+        out_dbl[i+1] += data_dbl[i+1] * vec_dbl[i];
+    }
+}
+
+template void _matmul_diag_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        std::complex<double> * _RESTRICT,
+        const int,
+        const std::complex<double>);
+template void _matmul_diag_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        std::complex<double> * _RESTRICT,
+        const long,
+        const std::complex<double>);
+template void _matmul_diag_vector<>(
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        std::complex<double> * _RESTRICT,
+        const long long,
+        const std::complex<double>);
diff --git a/qutip/core/data/src/matmul_diag_vector.hpp b/qutip/core/data/src/matmul_diag_vector.hpp
new file mode 100644
index 0000000000..0db3ce6271
--- /dev/null
+++ b/qutip/core/data/src/matmul_diag_vector.hpp
@@ -0,0 +1,16 @@
+#include <complex>
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+# define _RESTRICT __restrict
+#else
+# define _RESTRICT
+#endif
+
+template <typename IntT>
+void _matmul_diag_vector(
+        const std::complex<double> * _RESTRICT data,
+        const std::complex<double> * _RESTRICT vec,
+        std::complex<double> * _RESTRICT out,
+        const IntT length,
+        const std::complex<double> scale
+);
diff --git a/setup.py b/setup.py
index 0bf5b8def4..78312b5504 100755
--- a/setup.py
+++ b/setup.py
@@ -214,6 +214,7 @@ def _extension_extra_sources():
     extra_sources = {
         'qutip.core.data.matmul': [
             'qutip/core/data/src/matmul_csr_vector.cpp',
+            'qutip/core/data/src/matmul_diag_vector.cpp',
         ],
     }
     out = collections.defaultdict(list)

From a9acc4602cc3cad015362c3fba659ec2b5c40cdf Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Mon, 15 May 2023 14:04:13 +0900
Subject: [PATCH 373/602] Test loading pickled solver

---
 qutip/tests/solver/test_nm_mcsolve.py | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index ba524a8fa4..1359a62108 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -7,7 +7,7 @@
 from qutip.solver.nm_mcsolve import nm_mcsolve, NonMarkovianMCSolver
 
 
-def test_rough_agreement_with_mesolve_for_negative_rates():
+def test_agreement_with_mesolve_for_negative_rates():
     """
     A rough test that nm_mcsolve agress with mesolve in the
     presence of negative rates.
@@ -109,7 +109,22 @@ def test_solver_pickleable():
     ]
     for rate, arg in zip(rates, args):
         solver = NonMarkovianMCSolver(H, [(L, rate)], args=arg)
-        pickle.dumps(solver)
+        jar = pickle.dumps(solver)
+
+        loaded_solver = pickle.loads(jar)
+        assert len(solver.ops) == len(loaded_solver.ops)
+        for i in range(len(solver.ops)):
+            assert solver.ops[i] == loaded_solver.ops[i]
+            _assert_functions_equal(lambda t: solver.rate(t, i),
+                                    lambda t: loaded_solver.rate(t, i))
+        _assert_functions_equal(solver.rate_shift, loaded_solver.rate_shift)
+
+
+def _assert_functions_equal(f1, f2):
+    times = np.linspace(0, 1)
+    values1 = [f1(t) for t in times]
+    values2 = [f2(t) for t in times]
+    np.testing.assert_allclose(values1, values2)
 
 
 def _return_constant(t, args):

From f13dded038d4aee569d7982caa53830dd7f141eb Mon Sep 17 00:00:00 2001
From: Paul Menczel <paul@menczel.net>
Date: Mon, 15 May 2023 15:29:15 +0900
Subject: [PATCH 374/602] Fixed bug in docs (top-level functions in plot
 directives are not pickleable, apparently)

---
 doc/guide/dynamics/dynamics-monte.rst | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index bcbf01231b..a2989b4835 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -341,7 +341,6 @@ For more elaborate, physically motivated examples, we refer to the `accompanying
     :context: reset
 
     import qutip as qt
-    import numpy as np
 
     times = np.linspace(0, 1, 201)
     psi0 = qt.basis(2, 1)
@@ -349,25 +348,24 @@ For more elaborate, physically motivated examples, we refer to the `accompanying
     H = a0.dag() * a0
 
     # Rate functions
-    kappa = 1.0 / 0.129
-    nth = 0.063
-    def gamma1(t):
-            return kappa * nth
-    def gamma2(t): # becomes negative at times
-            return kappa * (nth+1) + 12 * np.exp(-2*t**3) * (-np.sin(15*t)**2)
+    gamma1 = "kappa * nth"
+    gamma2 = "kappa * (nth+1) + 12 * np.exp(-2*t**3) * (-np.sin(15*t)**2)"
+    # gamma2 becomes negative during some time intervals
 
     # nm_mcsolve integration
     ops_and_rates = []
     ops_and_rates.append([a0.dag(), gamma1])
     ops_and_rates.append([a0,       gamma2])
     MCSol = qt.nm_mcsolve(H, psi0, times, ops_and_rates,
+                          args={'kappa': 1.0 / 0.129, 'nth': 0.063},
                           e_ops=[a0.dag() * a0, a0 * a0.dag()],
                           options={'map': 'parallel'}, ntraj=2500)
 
     # mesolve integration for comparison
     d_ops = [[qt.lindblad_dissipator(a0.dag(), a0.dag()), gamma1],
              [qt.lindblad_dissipator(a0, a0),             gamma2]]
-    MESol = qt.mesolve(H, psi0, times, d_ops, e_ops=[a0.dag() * a0, a0 * a0.dag()])
+    MESol = qt.mesolve(H, psi0, times, d_ops, e_ops=[a0.dag() * a0, a0 * a0.dag()],
+                       args={'kappa': 1.0 / 0.129, 'nth': 0.063})
 
     plt.figure()
     plt.plot(times, MCSol.expect[0], 'g',

From 6d8246859166a5bfcc3706617c09d58526c94896 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 16 May 2023 16:31:49 -0400
Subject: [PATCH 375/602] CSR <-> Diag converters

---
 qutip/core/data/__init__.py           |  4 +++-
 qutip/core/data/csr.pxd               |  2 ++
 qutip/core/data/csr.pyx               | 28 ++++++++++++++++++++++++++-
 qutip/core/data/dense.pxd             |  4 +++-
 qutip/core/data/dense.pyx             |  6 +++++-
 qutip/core/data/dia.pxd               |  3 ++-
 qutip/core/data/dia.pyx               | 21 +++++++++++++++-----
 qutip/core/data/extract.py            |  2 +-
 qutip/tests/core/data/test_convert.py | 15 ++++++++++++++
 9 files changed, 74 insertions(+), 11 deletions(-)

diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index 386c9b6750..60f8125f97 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -39,7 +39,9 @@
     (Dense, CSR, dense.from_csr, 1),
     (CSR, Dense, csr.from_dense, 1.4),
     (Diag, Dense, dia.from_dense, 1.4),
-    (Dense, Diag, dia.to_dense, 1),
+    (Dense, Diag, dense.from_diag, 1.2),
+    (Diag, CSR, dia.from_csr, 1),
+    (CSR, Diag, csr.from_diag, 1),
 ])
 to.register_aliases(['csr', 'CSR'], CSR)
 to.register_aliases(['Dense', 'dense'], Dense)
diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
index 65dcd3193c..0dea011964 100644
--- a/qutip/core/data/csr.pxd
+++ b/qutip/core/data/csr.pxd
@@ -12,6 +12,7 @@ cimport numpy as cnp
 
 from qutip.core.data cimport base
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.dia cimport Diag
 
 cdef class CSR(base.Data):
     cdef double complex *data
@@ -161,6 +162,7 @@ cpdef CSR from_dense(Dense matrix)
 cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
                            base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
                            double tol=*)
+cpdef CSR from_diag(Diag matrix)
 
 cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
                           base.idxint n_blocks, base.idxint block_size)
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 6cf30b06e6..71fbbedc0a 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -24,7 +24,7 @@ except ImportError:
     from scipy.sparse._data import _data_matrix as scipy_data_matrix
 from scipy.linalg cimport cython_blas as blas
 
-from qutip.core.data cimport base, Dense
+from qutip.core.data cimport base, Dense, Diag
 from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
 from qutip.core.data.trace cimport trace_csr
 from qutip.core.data.tidyup cimport tidyup_csr
@@ -639,6 +639,32 @@ cdef CSR from_coo_pointers(
     return out
 
 
+cpdef CSR from_diag(Diag matrix):
+    if matrix.num_diag == 0:
+        return zeros(*matrix.shape)
+    mat = matrix.as_scipy()
+    ordered = np.argsort(mat.offsets)
+    nnz = len(mat.offsets) * max(mat.shape)
+    ptrs = np.zeros(mat.shape[0]+1, dtype=idxint_dtype)
+    indices = np.zeros(nnz, dtype=idxint_dtype)
+    data = np.zeros(nnz, dtype=complex)
+
+    ptr = 0
+    for row in range(mat.shape[0]):
+        for idx in ordered:
+            off = mat.offsets[idx]
+            if off + row < 0:
+                continue
+            elif off + row >= mat.shape[1]:
+                break
+            indices[ptr] = off + row
+            data[ptr] = mat.data[idx, off + row]
+            ptr += 1
+        ptrs[row + 1] = ptr
+
+    return CSR((data, indices, ptrs), matrix.shape, copy=False)
+
+
 cdef inline base.idxint _diagonal_length(
     base.idxint offset, base.idxint n_rows, base.idxint n_cols,
 ) nogil:
diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
index 6be9468a4c..c39145f441 100644
--- a/qutip/core/data/dense.pxd
+++ b/qutip/core/data/dense.pxd
@@ -3,7 +3,8 @@
 cimport numpy as cnp
 
 from . cimport base
-from .csr cimport CSR
+from qutip.core.data.csr cimport CSR
+from qutip.core.data.dia cimport Diag
 
 cdef class Dense(base.Data):
     cdef double complex *data
@@ -28,3 +29,4 @@ cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
 cpdef Dense identity(base.idxint dimension, double complex scale=*,
                      bint fortran=*)
 cpdef Dense from_csr(CSR matrix, bint fortran=*)
+cpdef Dense from_diag(Diag matrix)
diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
index 38c32f5bb8..02c902afdb 100644
--- a/qutip/core/data/dense.pyx
+++ b/qutip/core/data/dense.pyx
@@ -11,7 +11,7 @@ cimport numpy as cnp
 from scipy.linalg cimport cython_blas as blas
 
 from .base import EfficiencyWarning
-from qutip.core.data cimport base, CSR
+from qutip.core.data cimport base, CSR, Diag
 from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
 from qutip.core.data.trace cimport trace_dense
 
@@ -303,6 +303,10 @@ cpdef Dense from_csr(CSR matrix, bint fortran=False):
     return out
 
 
+cpdef Dense from_diag(Diag matrix):
+    return Dense(matrix.to_array(), copy=False)
+
+
 cdef inline base.idxint _diagonal_length(
     base.idxint offset, base.idxint n_rows, base.idxint n_cols,
 ) nogil:
diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index c6d40b2488..a71029b1b7 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -12,6 +12,7 @@
 
 from qutip.core.data cimport base
 from qutip.core.data.dense cimport Dense
+from qutip.core.data.csr cimport CSR
 
 cdef class Diag(base.Data):
     cdef double complex *data
@@ -32,5 +33,5 @@ cpdef Diag empty_like(Diag other)
 cpdef Diag zeros(base.idxint rows, base.idxint cols)
 cpdef Diag identity(base.idxint dimension, double complex scale=*)
 cpdef Diag from_dense(Dense matrix)
-cpdef Dense to_dense(Diag matrix)
+cpdef Diag from_csr(CSR matrix)
 cpdef Diag clean_diag(Diag matrix, bint inplace=*)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index e9b0263dd8..e727d7b64c 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -16,7 +16,7 @@ import warnings
 import numpy as np
 cimport numpy as cnp
 import scipy.sparse
-from scipy.sparse import dia_array as scipy_dia_array
+from scipy.sparse import dia_matrix as scipy_dia_matrix
 try:
     from scipy.sparse.data import _data_matrix as scipy_data_matrix
 except ImportError:
@@ -24,7 +24,7 @@ except ImportError:
     from scipy.sparse._data import _data_matrix as scipy_data_matrix
 from scipy.linalg cimport cython_blas as blas
 
-from qutip.core.data cimport base, Dense
+from qutip.core.data cimport base, Dense, CSR
 from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag
 from qutip.core.data.trace import trace_diag
 from qutip.core.data.tidyup import tidyup_diag
@@ -46,7 +46,7 @@ cdef object _dia_matrix(data, offsets, shape):
     because this takes tens of microseconds, and we already know we're in
     a sensible format.
     """
-    cdef object out = scipy_dia_array.__new__(scipy_dia_array)
+    cdef object out = scipy_dia_matrix.__new__(scipy_dia_matrix)
     # `_data_matrix` is the first object in the inheritance chain which
     # doesn't have a really slow __init__.
     scipy_data_matrix.__init__(out)
@@ -328,8 +328,19 @@ cpdef Diag from_dense(Dense matrix):
     return out
 
 
-cpdef Dense to_dense(Diag matrix):
-    return Dense(matrix.to_array(), copy=False)
+cpdef Diag from_csr(CSR matrix):
+    out_diag = set()
+    for row in range(matrix.shape[0]):
+        for ptr in range(matrix.row_index[row], matrix.row_index[row+1]):
+            out_diag.add(matrix.col_index[ptr] - row)
+    data = np.zeros((len(out_diag), matrix.shape[1]), dtype=complex)
+    diags = np.sort(np.fromiter(out_diag, idxint_dtype, len(out_diag)))
+    for row in range(matrix.shape[0]):
+        for ptr in range(matrix.row_index[row], matrix.row_index[row+1]):
+            diag = matrix.col_index[ptr] - row
+            idx = np.searchsorted(diags, diag)
+            data[idx, matrix.col_index[ptr]] = matrix.data[ptr]
+    return Diag((data, diags), shape=matrix.shape, copy=False)
 
 
 cpdef Diag clean_diag(Diag matrix, bint inplace=False):
diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index 302ce05262..7dbe07fac2 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -61,7 +61,7 @@ def extract_csr(matrix, format=None, copy=True):
 
 def extract_diag(matrix, format=None, copy=True):
     """
-    Return the scipy's object ``dia_array``.
+    Return the scipy's object ``dia_matrix``.
 
     Parameters
     ----------
diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
index bc38bfc957..b2cecbc28d 100644
--- a/qutip/tests/core/data/test_convert.py
+++ b/qutip/tests/core/data/test_convert.py
@@ -2,6 +2,7 @@
 import pytest
 from scipy import sparse
 from qutip import data
+from .test_mathematics import UnaryOpMixin
 
 
 def test_init_empty_data():
@@ -87,3 +88,17 @@ def test_parse_error(input, error, msg):
     with pytest.raises(error) as exc:
         data.to.parse(input)
     assert str(exc.value) == msg
+
+
+class TestConvert(UnaryOpMixin):
+    def op_numpy(self, mat):
+        return mat
+
+    specialisations = [
+        pytest.param(data.dense.from_csr, data.CSR, data.Dense),
+        pytest.param(data.dense.from_diag, data.Diag, data.Dense),
+        pytest.param(data.csr.from_dense, data.Dense, data.CSR),
+        pytest.param(data.csr.from_diag, data.Diag, data.CSR),
+        pytest.param(data.dia.from_dense, data.Dense, data.Diag),
+        pytest.param(data.dia.from_csr, data.CSR, data.Diag),
+    ]

From e41a00b3c103819caa511a40128c4e3f3ba8b573 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 17 May 2023 13:55:59 -0400
Subject: [PATCH 376/602] add reshape

---
 qutip/core/data/reshape.pxd           |  6 +++-
 qutip/core/data/reshape.pyx           | 47 ++++++++++++++++++++++-----
 qutip/tests/core/data/test_reshape.py |  7 +++-
 3 files changed, 50 insertions(+), 10 deletions(-)

diff --git a/qutip/core/data/reshape.pxd b/qutip/core/data/reshape.pxd
index 4efae3a0e4..f3d817a533 100644
--- a/qutip/core/data/reshape.pxd
+++ b/qutip/core/data/reshape.pxd
@@ -1,12 +1,16 @@
 #cython: language_level=3
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport CSR, Dense
+from qutip.core.data cimport CSR, Dense, Diag
 
 cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
 cpdef CSR column_stack_csr(CSR matrix)
 cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
 
+cpdef Diag reshape_diag(Diag matrix, idxint n_rows_out, idxint n_cols_out)
+cpdef Diag column_stack_diag(Diag matrix)
+cpdef Diag column_unstack_diag(Diag matrix, idxint rows)
+
 cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
 cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
 cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=*)
diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
index 6f18271005..8e765d2340 100644
--- a/qutip/core/data/reshape.pyx
+++ b/qutip/core/data/reshape.pyx
@@ -8,13 +8,13 @@ cimport cython
 import warnings
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense, Data
+from qutip.core.data cimport csr, dense, CSR, Dense, Data, Diag
 
 __all__ = [
-    'reshape', 'reshape_csr', 'reshape_dense',
-    'column_stack', 'column_stack_csr', 'column_stack_dense',
-    'column_unstack', 'column_unstack_csr', 'column_unstack_dense',
-    'split_columns', 'split_columns_dense', 'split_columns_csr',
+    'reshape', 'reshape_csr', 'reshape_dense', 'reshape_diag',
+    'column_stack', 'column_stack_csr', 'column_stack_dense', 'column_stack_diag',
+    'column_unstack', 'column_unstack_csr', 'column_unstack_dense', 'column_unstack_diag',
+    'split_columns', 'split_columns_dense', 'split_columns_csr', 'split_columns_diag',
 ]
 
 
@@ -74,6 +74,14 @@ cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
     return out
 
 
+cpdef Diag reshape_diag(Diag matrix, idxint n_rows_out, idxint n_cols_out):
+    _reshape_check_input(matrix, n_rows_out, n_cols_out)
+    # Once reshaped, diagonals are no longer ligned up.
+    return Diag(
+        matrix.as_scipy().reshape((n_rows_out, n_cols_out)).todia(), copy=False
+    )
+
+
 cpdef CSR column_stack_csr(CSR matrix):
     if matrix.shape[1] == 1:
         return matrix.copy()
@@ -94,6 +102,12 @@ cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
     return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
 
 
+cpdef Diag column_stack_diag(Diag matrix):
+    if matrix.shape[1] == 1:
+        return matrix.copy()
+    return reshape_diag(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+
+
 cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
     if matrix.shape[1] != 1:
         raise ValueError("input is not a single column")
@@ -108,6 +122,7 @@ cpdef CSR column_unstack_csr(CSR matrix, idxint rows):
     cdef idxint cols = matrix.shape[0] // rows
     return reshape_csr(matrix, cols, rows).transpose()
 
+
 cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
     _column_unstack_check_shape(matrix, rows)
     cdef idxint cols = matrix.shape[0] // rows
@@ -121,15 +136,27 @@ cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
     return out
 
 
+cpdef Diag column_unstack_diag(Diag matrix, idxint rows):
+    _column_unstack_check_shape(matrix, rows)
+    cdef idxint cols = matrix.shape[0] // rows
+    return reshape_diag(matrix, cols, rows).transpose()
+
+
 cpdef list split_columns_dense(Dense matrix, copy=True):
     return [Dense(matrix.as_ndarray()[:, k], copy=copy)
             for k in range(matrix.shape[1])]
 
+
 cpdef list split_columns_csr(CSR matrix, copy=True):
     return [CSR(matrix.as_scipy()[:, k], copy=copy)
             for k in range(matrix.shape[1])]
 
 
+cpdef list split_columns_diag(Diag matrix, copy=None):
+    as_array = matrix.to_array()
+    return [Dense(as_array[:, k], copy=False) for k in range(matrix.shape[1])]
+
+
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 
@@ -160,6 +187,7 @@ reshape.__doc__ =\
 reshape.add_specialisations([
     (CSR, CSR, reshape_csr),
     (Dense, Dense, reshape_dense),
+    (Diag, Diag, reshape_diag),
 ], _defer=True)
 
 
@@ -204,6 +232,7 @@ column_stack.__doc__ =\
 column_stack.add_specialisations([
     (CSR, CSR, column_stack_csr),
     (Dense, Dense, column_stack_dense),
+    (Diag, Diag, column_stack_diag),
 ], _defer=True)
 
 column_unstack = _Dispatcher(
@@ -244,6 +273,7 @@ column_unstack.__doc__ =\
 column_unstack.add_specialisations([
     (CSR, CSR, column_unstack_csr),
     (Dense, Dense, column_unstack_dense),
+    (Diag, Diag, column_unstack_diag),
 ], _defer=True)
 
 
@@ -268,9 +298,9 @@ split_columns.__doc__ =\
     matrix : Data
         The matrix to unstack the columns of.
 
-    copy : bool, optional
-        The number of rows there should be in the output matrix.  This must
-        divide into the total number of elements in the input.
+    copy : bool, optional [True]
+        Whether to return copy of the data or a view.
+        View may not be a possible in all cases.
 
     Returns
     -------
@@ -280,6 +310,7 @@ split_columns.__doc__ =\
 split_columns.add_specialisations([
     (CSR, split_columns_csr),
     (Dense, split_columns_dense),
+    (Diag, split_columns_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/tests/core/data/test_reshape.py b/qutip/tests/core/data/test_reshape.py
index e86b327c8f..700943842d 100644
--- a/qutip/tests/core/data/test_reshape.py
+++ b/qutip/tests/core/data/test_reshape.py
@@ -2,7 +2,7 @@
 import pytest
 import numpy as np
 from qutip import data
-from qutip.core.data import CSR, Dense
+from qutip.core.data import CSR, Dense, Diag
 
 
 class TestSplitColumns(UnaryOpMixin):
@@ -11,10 +11,12 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.split_columns_csr, CSR, list),
+        pytest.param(data.split_columns_diag, Diag, list),
         pytest.param(data.split_columns_dense, Dense, list),
     ]
 
 
+@pytest.mark.filterwarnings("ignore:Constructing a DIA matrix")
 class TestColumnStack(UnaryOpMixin):
     def op_numpy(self, matrix):
         out_shape = (matrix.shape[0]*matrix.shape[1], 1)
@@ -22,6 +24,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.column_stack_csr, CSR, CSR),
+        pytest.param(data.column_stack_diag, Diag, Diag),
         pytest.param(data.column_stack_dense, Dense, Dense),
     ]
 
@@ -43,6 +46,7 @@ def op_numpy(self, matrix, rows):
 
     specialisations = [
         pytest.param(data.column_unstack_csr, CSR, CSR),
+        pytest.param(data.column_unstack_diag, Diag, Diag),
         pytest.param(data.column_unstack_dense, Dense, Dense),
     ]
 
@@ -92,6 +96,7 @@ def op_numpy(self, matrix, rows, columns):
 
     specialisations = [
         pytest.param(data.reshape_dense, Dense, Dense),
+        pytest.param(data.reshape_diag, Diag, Diag),
         pytest.param(data.reshape_csr, CSR, CSR),
     ]
 

From 379ee6b7098e16a465848d9d5483df3d255e23ec Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 17 May 2023 18:29:39 -0400
Subject: [PATCH 377/602] ptrace_diag try

---
 qutip/core/data/dia.pyx              |  2 +-
 qutip/core/data/ptrace.pyx           | 41 ++++++++++++++++++++++++++--
 qutip/tests/core/data/test_ptrace.py |  3 +-
 3 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index e727d7b64c..85340c24cb 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -121,7 +121,7 @@ cdef class Diag(base.Data):
 
         # Scipy support ``data`` with diag of any length. They can be sorter if
         # the last columns are empty or have extra unused columns at the end.
-        if data.shape[1] != self.shape[1]:
+        if data.shape[0] != 0 and data.shape[1] != self.shape[1]:
             new_data = np.zeros((self.num_diag, self.shape[1]), dtype=np.complex128, order='C')
             copy_length = min(data.shape[1], self.shape[1])
             new_data[:, :copy_length] = data[:, :copy_length]
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 3dfb6b0a4c..3f1b552063 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -6,15 +6,16 @@ import numbers
 import numpy as np
 
 cimport numpy as cnp
+cimport cython
 
-from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data
+from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data, Diag, dia
 from qutip.core.data.base import idxint_dtype
 from qutip.settings import settings
 
 cnp.import_array()
 
 __all__ = [
-    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense',
+    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense', 'ptrace_diag',
 ]
 
 cdef tuple _parse_inputs(object dims, object sel, tuple shape):
@@ -121,6 +122,41 @@ cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
                                  size, size, p, tol)
 
 
+#TODO: cythonize
+@cython.wraparound(True)
+@cython.boundscheck(True)
+@cython.initializedcheck(True)
+def ptrace_diag(matrix, dims, sel):
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
+
+    if len(sel) == len(dims):
+        return matrix.copy()
+
+    mat = matrix.as_scipy()
+    cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
+    cdef idxint pos[2]
+    size = _populate_tensor_table(dims, sel, tensor_table)
+    offsets = []
+    data = []
+    for i, offset in enumerate(mat.offsets):
+        _i2_k_t(offset, tensor_table, pos)
+        print(pos[0], pos[1])
+        if pos[1] == 0:
+            offsets.append(pos[0])
+            data.append([0.] * size)
+            for col in range(mat.shape[1]):
+                _i2_k_t(col, tensor_table, pos)
+                data[-1][pos[0]] += mat.data[i, col]
+    if len(offsets) == 0:
+        return dia.zeros(size, size)
+    data = np.array(data, dtype=complex)
+    offsets = np.array(offsets, dtype=idxint_dtype)
+    print(data.shape, data.dtype)
+    print(offsets.shape, offsets.dtype)
+    print(size)
+    return Diag((data, offsets), shape=(size, size), copy=False)
+
+
 cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):
     dims, sel = _parse_inputs(dims, sel, matrix.shape)
 
@@ -211,6 +247,7 @@ ptrace.add_specialisations([
     (CSR, CSR, ptrace_csr),
     (CSR, Dense, ptrace_csr_dense),
     (Dense, Dense, ptrace_dense),
+    (Diag, Diag, ptrace_diag),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/tests/core/data/test_ptrace.py b/qutip/tests/core/data/test_ptrace.py
index 84fd41015d..3798885a6b 100644
--- a/qutip/tests/core/data/test_ptrace.py
+++ b/qutip/tests/core/data/test_ptrace.py
@@ -3,7 +3,7 @@
 import scipy.linalg
 import pytest
 from qutip import data
-from qutip.core.data import CSR, Dense
+from qutip.core.data import CSR, Dense, Diag
 
 
 class TestPtrace(testing.UnaryOpMixin):
@@ -38,6 +38,7 @@ def op_numpy(self, matrix, dims, sel):
         pytest.param(data.ptrace_csr, CSR, CSR),
         pytest.param(data.ptrace_csr_dense, CSR, Dense),
         pytest.param(data.ptrace_dense, Dense, Dense),
+        pytest.param(data.ptrace_diag, Diag, Diag),
     ]
 
     @pytest.mark.parametrize(

From ee69e5b08227553159d1e63c7cb521cd498f43c6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 18 May 2023 10:51:36 -0400
Subject: [PATCH 378/602] diag ptrace still has issues

---
 qutip/core/data/ptrace.pyx | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 3f1b552063..3188818743 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -140,11 +140,13 @@ def ptrace_diag(matrix, dims, sel):
     data = []
     for i, offset in enumerate(mat.offsets):
         _i2_k_t(offset, tensor_table, pos)
-        print(pos[0], pos[1])
+        print(offset, pos[0], pos[1])
         if pos[1] == 0:
             offsets.append(pos[0])
             data.append([0.] * size)
-            for col in range(mat.shape[1]):
+            start = max(0, offset)
+            end = min(matrix.shape[0] + offset, matrix.shape[1])
+            for col in range(start, end):
                 _i2_k_t(col, tensor_table, pos)
                 data[-1][pos[0]] += mat.data[i, col]
     if len(offsets) == 0:
@@ -154,7 +156,9 @@ def ptrace_diag(matrix, dims, sel):
     print(data.shape, data.dtype)
     print(offsets.shape, offsets.dtype)
     print(size)
-    return Diag((data, offsets), shape=(size, size), copy=False)
+    out = Diag((data, offsets), shape=(size, size), copy=False)
+    out = dia.clean_diag(out, True)
+    return out
 
 
 cpdef Dense ptrace_csr_dense(CSR matrix, object dims, object sel):

From e3d45a55eb8e28845301c9d507742a6dcd87c20f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 23 May 2023 06:12:12 +0000
Subject: [PATCH 379/602] Bump requests from 2.28.2 to 2.31.0 in /doc

Bumps [requests](https://github.com/psf/requests) from 2.28.2 to 2.31.0.
- [Release notes](https://github.com/psf/requests/releases)
- [Changelog](https://github.com/psf/requests/blob/main/HISTORY.md)
- [Commits](https://github.com/psf/requests/compare/v2.28.2...v2.31.0)

---
updated-dependencies:
- dependency-name: requests
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 doc/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index 7ecdc09f42..c6b86832c8 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -28,7 +28,7 @@ Pygments==2.14.0
 pyparsing==3.0.9
 python-dateutil==2.8.2
 pytz==2023.3
-requests==2.28.2
+requests==2.31.0
 scipy==1.10.1
 six==1.16.0
 snowballstemmer==2.2.0

From f2a1628d3cda4213ff27151e4da975b3aedcb980 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 16:24:36 -0700
Subject: [PATCH 380/602] added fcreate and fdestroy and tests

---
 qutip/core/operators.py            | 77 +++++++++++++++++++++++++++++-
 qutip/tests/core/test_operators.py | 20 ++++++++
 2 files changed, 96 insertions(+), 1 deletion(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 3ee4292efb..7b48361588 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -5,7 +5,7 @@
 
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'qeye', 'qeye_like', 'identity', 'position',
+           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like', 'identity', 'position',
            'momentum', 'num', 'squeeze', 'squeezing', 'swap', 'displace',
            'commutator', 'qutrit_ops', 'qdiags', 'phase', 'qzero',
            'qzero_like', 'enr_destroy', 'enr_identity', 'charge', 'tunneling',
@@ -18,6 +18,7 @@
 
 from . import data as _data
 from .qobj import Qobj
+from .tensor import tensor
 from .dimensions import flatten
 from .. import settings
 
@@ -470,6 +471,80 @@ def create(N, offset=0, *, dtype=None):
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
     return qdiags(data, -1, dtype=dtype)
 
+def fdestroy(N, site=0):
+    """
+    Fermionic destruction operator.
+    We use the Jordan-Wigner transformation to construct this:
+    a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x - i\sigma_y}{2}) \otimes I^{\otimes N-j-1}
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    site : int (default 0)
+        The site in Fock space to add a fermion to. Corresponds to j in the above JW transform.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for destruction operator.
+
+    Examples
+    --------
+    >>> fdestroy(2) # doctest: +SKIP
+    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4), type='oper', isherm=False
+    Qobj data =
+    [[0. 0. 1. 0.]
+    [0. 0. 0. 1.]
+    [0. 0. 0. 0.]
+    [0. 0. 0. 0.]]
+    """
+    if site == 0:
+        return tensor([destroy(2), *[identity(2)*(N-1)]])
+    else:
+        if N-site-1 > 0:
+            return tensor([*[sigmaz()*site], destroy(2), *[identity(2)*(N-site-1)]])
+        else:
+            return tensor([*[sigmaz()*site], destroy(2)])
+
+def fcreate(N, site=0):
+    """
+    Fermionic creation operator.
+    We use the Jordan-Wigner transformation to construct this:
+    a^{\dagger}_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x + i\sigma_y}{2}) \otimes I^{\otimes N-k-1}
+
+    Parameters
+    ----------
+    N : int
+        Dimension of Hilbert space.
+
+    site : int (default 0)
+        The site in Fock space to add a fermion to. Corresponds to j in the above JW transform.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for raising operator.
+
+    Examples
+    --------
+    >>> fcreate(2) # doctest: +SKIP
+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False
+    Qobj data =
+    [[0. 0. 0. 0.]
+    [0. 0. 0. 0.]
+    [1. 0. 0. 0.]
+    [0. 1. 0. 0.]]
+    """
+    if site == 0:
+        return tensor([create(2), *[identity(2)*(N-1)]])
+    else:
+        if N-site-1 > 0:
+            return tensor([*[sigmaz()*site], create(2), *[identity(2)*(N-site-1)]])
+        else:
+            return tensor([*[sigmaz()*site], create(2)])
+
 
 def _implicit_tensor_dimensions(dimensions):
     """
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index 58f3f665b1..977a75f92a 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -251,6 +251,8 @@ def _id_func(val):
     (qutip.spin_Jp, (1,)),
     (qutip.destroy, (5,)),
     (qutip.create, (5,)),
+    (qutip.fdestroy, (5,))
+    (qutip.fcreate, (5,))
     (qutip.qzero, (5,)),
     (qutip.qeye, (5,)),
     (qutip.position, (5,)),
@@ -342,3 +344,21 @@ def test_qzero_like(dims, superrep, dtype):
     opevo = qutip.QobjEvo(op)
     new = qutip.qzero_like(op)
     assert new == expected
+
+@pytest.mark.parametrize('N', [2,3,4,5])
+def test_fcreate_fdestroy(N,size):
+    I = qutip.tensor([qutip.identity(2), *[qutip.identity(2)*(N-1)]])
+    zero_tensor = 0*I
+    for size_0 in range(N):
+        c_0 = qutip.fcreate(N, size_0)
+        d_0 = qutip.fdestroy(N, size_0)
+        for size_1 in range(N):
+            c_1 = qutip.fcreate(N, size_1)
+            d_1 = qutip.fdestroy(N, size_1)
+            assert qutip.anticommutator(c_0,c_1) == zero_tensor
+            if size_0 == size_1:
+                assert qutip.anticommutator(c_0,d_1) == I
+            else:
+                assert qutip.anticommutator(c_0,d_1) == 0
+
+    assert qutip.commutator(I, c_0) == zero_tensor
\ No newline at end of file

From 4a4f51435727788fc3d860d83cd4b2f886574f7f Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 17:31:04 -0700
Subject: [PATCH 381/602] added tests and documentation

---
 qutip/core/operators.py            | 24 +++++++++++++-----------
 qutip/tests/core/test_operators.py | 10 ++++++----
 2 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 7b48361588..6dd2f32024 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -471,11 +471,12 @@ def create(N, offset=0, *, dtype=None):
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
     return qdiags(data, -1, dtype=dtype)
 
-def fdestroy(N, site=0):
+def fdestroy(N, site=0, Opers = None):
     """
     Fermionic destruction operator.
-    We use the Jordan-Wigner transformation to construct this:
-    a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x - i\sigma_y}{2}) \otimes I^{\otimes N-j-1}
+    We use the Jordan-Wigner transformation, making use of the so-called Jordan-Wigner ZZ..Z strings,
+    to construct this as follows (in Latex):
+    $$a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x + i\sigma_y}{2}) \otimes I^{\otimes N-j-1}$$
 
     Parameters
     ----------
@@ -501,18 +502,19 @@ def fdestroy(N, site=0):
     [0. 0. 0. 0.]]
     """
     if site == 0:
-        return tensor([destroy(2), *[identity(2)*(N-1)]])
+        return tensor([destroy(2), *([identity(2)]*(N-1))])
     else:
         if N-site-1 > 0:
-            return tensor([*[sigmaz()*site], destroy(2), *[identity(2)*(N-site-1)]])
+            return tensor([*([sigmaz()]*site), destroy(2), *([identity(2)]*(N-site-1))])
         else:
-            return tensor([*[sigmaz()*site], destroy(2)])
+            return tensor([*([sigmaz()]*site), destroy(2)])
 
 def fcreate(N, site=0):
     """
     Fermionic creation operator.
-    We use the Jordan-Wigner transformation to construct this:
-    a^{\dagger}_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x + i\sigma_y}{2}) \otimes I^{\otimes N-k-1}
+    We use the Jordan-Wigner transformation, making use of the so-called Jordan-Wigner ZZ..Z strings,
+    to construct this as follows (in Latex):
+    $$a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x - i\sigma_y}{2}) \otimes I^{\otimes N-j-1}$$
 
     Parameters
     ----------
@@ -538,12 +540,12 @@ def fcreate(N, site=0):
     [0. 1. 0. 0.]]
     """
     if site == 0:
-        return tensor([create(2), *[identity(2)*(N-1)]])
+        return tensor([create(2), *([identity(2)]*(N-1))])
     else:
         if N-site-1 > 0:
-            return tensor([*[sigmaz()*site], create(2), *[identity(2)*(N-site-1)]])
+            return tensor([*([sigmaz()]*site), create(2), *([identity(2)]*(N-site-1))])
         else:
-            return tensor([*[sigmaz()*site], create(2)])
+            return tensor([*([sigmaz()]*site), create(2)])
 
 
 def _implicit_tensor_dimensions(dimensions):
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index 977a75f92a..d7c0298dcc 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -346,8 +346,8 @@ def test_qzero_like(dims, superrep, dtype):
     assert new == expected
 
 @pytest.mark.parametrize('N', [2,3,4,5])
-def test_fcreate_fdestroy(N,size):
-    I = qutip.tensor([qutip.identity(2), *[qutip.identity(2)*(N-1)]])
+def test_fcreate_fdestroy(N):
+    I = qutip.tensor([*([qutip.identity(2)]*(N))])
     zero_tensor = 0*I
     for size_0 in range(N):
         c_0 = qutip.fcreate(N, size_0)
@@ -356,9 +356,11 @@ def test_fcreate_fdestroy(N,size):
             c_1 = qutip.fcreate(N, size_1)
             d_1 = qutip.fdestroy(N, size_1)
             assert qutip.anticommutator(c_0,c_1) == zero_tensor
+            assert qutip.anticommutator(d_0,d_1) == zero_tensor
             if size_0 == size_1:
                 assert qutip.anticommutator(c_0,d_1) == I
+                assert qutip.anticommutator(c_1,d_0) == I
             else:
-                assert qutip.anticommutator(c_0,d_1) == 0
-
+                assert qutip.anticommutator(c_0,d_1) == zero_tensor
+                assert qutip.anticommutator(c_1,d_0) == zero_tensor
     assert qutip.commutator(I, c_0) == zero_tensor
\ No newline at end of file

From 2e9970bdb75ec5e4adcae189e319f88607e51e00 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 17:48:00 -0700
Subject: [PATCH 382/602] fixing syntax with pycodestyle

---
 qutip/core/operators.py            | 10 ++++++----
 qutip/tests/core/test_operators.py | 19 ++++++++++---------
 2 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 6dd2f32024..f63a9474a7 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -136,11 +136,11 @@ def jmat(j, which=None, *, dtype=None):
         return Qobj(_jplus(j, dtype=dtype).adjoint(), dims=dims, type='oper',
                     isherm=False, isunitary=False, copy=False)
     if which == 'x':
-        A =  _jplus(j, dtype=dtype)
+        A = _jplus(j, dtype=dtype)
         return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
                     isherm=True, isunitary=False, copy=False) * 0.5
     if which == 'y':
-        A =  _data.mul(_jplus(j, dtype=dtype), -0.5j)
+        A = _data.mul(_jplus(j, dtype=dtype), -0.5j)
         return Qobj(_data.add(A, A.adjoint()), dims=dims, type='oper',
                     isherm=True, isunitary=False, copy=False)
     if which == 'z':
@@ -471,12 +471,13 @@ def create(N, offset=0, *, dtype=None):
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
     return qdiags(data, -1, dtype=dtype)
 
-def fdestroy(N, site=0, Opers = None):
+
+def fdestroy(N, site=0, Opers=None):
     """
     Fermionic destruction operator.
     We use the Jordan-Wigner transformation, making use of the so-called Jordan-Wigner ZZ..Z strings,
     to construct this as follows (in Latex):
-    $$a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x + i\sigma_y}{2}) \otimes I^{\otimes N-j-1}$$
+    a_j = sigma_z^{otimes j} otimes (frac{sigma_x + i sigma_y}{2}) otimes I^{otimes N-j-1}
 
     Parameters
     ----------
@@ -509,6 +510,7 @@ def fdestroy(N, site=0, Opers = None):
         else:
             return tensor([*([sigmaz()]*site), destroy(2)])
 
+
 def fcreate(N, site=0):
     """
     Fermionic creation operator.
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index d7c0298dcc..c8f1eb5484 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -345,9 +345,10 @@ def test_qzero_like(dims, superrep, dtype):
     new = qutip.qzero_like(op)
     assert new == expected
 
-@pytest.mark.parametrize('N', [2,3,4,5])
+
+@pytest.mark.parametrize('N', [2, 3, 4, 5])
 def test_fcreate_fdestroy(N):
-    I = qutip.tensor([*([qutip.identity(2)]*(N))])
+    identity = qutip.tensor([*([qutip.identity(2)]*(N))])
     zero_tensor = 0*I
     for size_0 in range(N):
         c_0 = qutip.fcreate(N, size_0)
@@ -355,12 +356,12 @@ def test_fcreate_fdestroy(N):
         for size_1 in range(N):
             c_1 = qutip.fcreate(N, size_1)
             d_1 = qutip.fdestroy(N, size_1)
-            assert qutip.anticommutator(c_0,c_1) == zero_tensor
-            assert qutip.anticommutator(d_0,d_1) == zero_tensor
+            assert qutip.anticommutator(c_0, c_1) == zero_tensor
+            assert qutip.anticommutator(d_0, d_1) == zero_tensor
             if size_0 == size_1:
-                assert qutip.anticommutator(c_0,d_1) == I
-                assert qutip.anticommutator(c_1,d_0) == I
+                assert qutip.anticommutator(c_0, d_1) == identity
+                assert qutip.anticommutator(c_1, d_0) == identity
             else:
-                assert qutip.anticommutator(c_0,d_1) == zero_tensor
-                assert qutip.anticommutator(c_1,d_0) == zero_tensor
-    assert qutip.commutator(I, c_0) == zero_tensor
\ No newline at end of file
+                assert qutip.anticommutator(c_0, d_1) == zero_tensor
+                assert qutip.anticommutator(c_1, d_0) == zero_tensor
+    assert qutip.commutator(identity, c_0) == zero_tensor

From 594d934b6fc00317de616bc12b861df22f7eceda Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 17:51:38 -0700
Subject: [PATCH 383/602] added doc/changes file

---
 doc/changes/2158.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2158.feature

diff --git a/doc/changes/2158.feature b/doc/changes/2158.feature
new file mode 100644
index 0000000000..f42fe54274
--- /dev/null
+++ b/doc/changes/2158.feature
@@ -0,0 +1 @@
+added fermionic annihilation and creation operators a
\ No newline at end of file

From 56472e6a4988a2705a2d7176cf6ce527dcb73c00 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 18:07:42 -0700
Subject: [PATCH 384/602] fixing pep8 issues

---
 doc/changes/{2158.feature => 2167.feature} |  0
 qutip/core/operators.py                    | 29 ++++++++++++----------
 2 files changed, 16 insertions(+), 13 deletions(-)
 rename doc/changes/{2158.feature => 2167.feature} (100%)

diff --git a/doc/changes/2158.feature b/doc/changes/2167.feature
similarity index 100%
rename from doc/changes/2158.feature
rename to doc/changes/2167.feature
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index f63a9474a7..177bd3d846 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -5,11 +5,11 @@
 
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like', 'identity', 'position',
-           'momentum', 'num', 'squeeze', 'squeezing', 'swap', 'displace',
-           'commutator', 'qutrit_ops', 'qdiags', 'phase', 'qzero',
-           'qzero_like', 'enr_destroy', 'enr_identity', 'charge', 'tunneling',
-           'qft']
+           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like', 
+           'identity', 'position', 'momentum', 'num', 'squeeze', 'squeezing',
+           'swap', 'displace', 'commutator', 'qutrit_ops', 'qdiags', 'phase', 
+           'qzero', 'qzero_like', 'enr_destroy', 'enr_identity', 'charge', 
+           'tunneling','qft']
 
 import numbers
 
@@ -475,9 +475,12 @@ def create(N, offset=0, *, dtype=None):
 def fdestroy(N, site=0, Opers=None):
     """
     Fermionic destruction operator.
-    We use the Jordan-Wigner transformation, making use of the so-called Jordan-Wigner ZZ..Z strings,
+    We use the Jordan-Wigner transformation, 
+    making use of the so-called Jordan-Wigner ZZ..Z strings,
     to construct this as follows (in Latex):
-    a_j = sigma_z^{otimes j} otimes (frac{sigma_x + i sigma_y}{2}) otimes I^{otimes N-j-1}
+    a_j = sigma_z^{otimes j} 
+          otimes (frac{sigma_x + i sigma_y}{2}) 
+          otimes I^{otimes N-j-1}
 
     Parameters
     ----------
@@ -485,7 +488,8 @@ def fdestroy(N, site=0, Opers=None):
         Dimension of Hilbert space.
 
     site : int (default 0)
-        The site in Fock space to add a fermion to. Corresponds to j in the above JW transform.
+        The site in Fock space to add a fermion to. 
+        Corresponds to j in the above JW transform.
 
     Returns
     -------
@@ -495,7 +499,8 @@ def fdestroy(N, site=0, Opers=None):
     Examples
     --------
     >>> fdestroy(2) # doctest: +SKIP
-    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4), type='oper', isherm=False
+    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4), 
+    type='oper', isherm=False
     Qobj data =
     [[0. 0. 1. 0.]
     [0. 0. 0. 1.]
@@ -506,7 +511,8 @@ def fdestroy(N, site=0, Opers=None):
         return tensor([destroy(2), *([identity(2)]*(N-1))])
     else:
         if N-site-1 > 0:
-            return tensor([*([sigmaz()]*site), destroy(2), *([identity(2)]*(N-site-1))])
+            return tensor([*([sigmaz()]*site), destroy(2), 
+                           *([identity(2)]*(N-site-1))])
         else:
             return tensor([*([sigmaz()]*site), destroy(2)])
 
@@ -514,9 +520,6 @@ def fdestroy(N, site=0, Opers=None):
 def fcreate(N, site=0):
     """
     Fermionic creation operator.
-    We use the Jordan-Wigner transformation, making use of the so-called Jordan-Wigner ZZ..Z strings,
-    to construct this as follows (in Latex):
-    $$a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x - i\sigma_y}{2}) \otimes I^{\otimes N-j-1}$$
 
     Parameters
     ----------

From 0c337c71916d1c090e7cecdd1e2214d73c04e2f6 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 18:09:05 -0700
Subject: [PATCH 385/602] fixing typo

---
 doc/changes/{2167.feature => 2166.feature} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename doc/changes/{2167.feature => 2166.feature} (100%)

diff --git a/doc/changes/2167.feature b/doc/changes/2166.feature
similarity index 100%
rename from doc/changes/2167.feature
rename to doc/changes/2166.feature

From b333a9e43819fc99ec46368018c247d9af6af8db Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Fri, 26 May 2023 18:15:18 -0700
Subject: [PATCH 386/602] fixed pep8 issues

---
 qutip/core/operators.py | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 177bd3d846..c46e514b9d 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -5,11 +5,11 @@
 
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like', 
+           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like',
            'identity', 'position', 'momentum', 'num', 'squeeze', 'squeezing',
-           'swap', 'displace', 'commutator', 'qutrit_ops', 'qdiags', 'phase', 
-           'qzero', 'qzero_like', 'enr_destroy', 'enr_identity', 'charge', 
-           'tunneling','qft']
+           'swap', 'displace', 'commutator', 'qutrit_ops', 'qdiags', 'phase',
+           'qzero', 'qzero_like', 'enr_destroy', 'enr_identity', 'charge',
+           'tunneling', 'qft']
 
 import numbers
 
@@ -472,14 +472,14 @@ def create(N, offset=0, *, dtype=None):
     return qdiags(data, -1, dtype=dtype)
 
 
-def fdestroy(N, site=0, Opers=None):
+def fdestroy(N, site=0):
     """
     Fermionic destruction operator.
-    We use the Jordan-Wigner transformation, 
+    We use the Jordan-Wigner transformation,
     making use of the so-called Jordan-Wigner ZZ..Z strings,
     to construct this as follows (in Latex):
-    a_j = sigma_z^{otimes j} 
-          otimes (frac{sigma_x + i sigma_y}{2}) 
+    a_j = sigma_z^{otimes j}
+          otimes (frac{sigma_x + i sigma_y}{2})
           otimes I^{otimes N-j-1}
 
     Parameters
@@ -488,7 +488,7 @@ def fdestroy(N, site=0, Opers=None):
         Dimension of Hilbert space.
 
     site : int (default 0)
-        The site in Fock space to add a fermion to. 
+        The site in Fock space to add a fermion to.
         Corresponds to j in the above JW transform.
 
     Returns
@@ -499,7 +499,7 @@ def fdestroy(N, site=0, Opers=None):
     Examples
     --------
     >>> fdestroy(2) # doctest: +SKIP
-    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4), 
+    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4),
     type='oper', isherm=False
     Qobj data =
     [[0. 0. 1. 0.]
@@ -511,7 +511,7 @@ def fdestroy(N, site=0, Opers=None):
         return tensor([destroy(2), *([identity(2)]*(N-1))])
     else:
         if N-site-1 > 0:
-            return tensor([*([sigmaz()]*site), destroy(2), 
+            return tensor([*([sigmaz()]*site), destroy(2),
                            *([identity(2)]*(N-site-1))])
         else:
             return tensor([*([sigmaz()]*site), destroy(2)])
@@ -527,7 +527,8 @@ def fcreate(N, site=0):
         Dimension of Hilbert space.
 
     site : int (default 0)
-        The site in Fock space to add a fermion to. Corresponds to j in the above JW transform.
+        The site in Fock space to add a fermion to.
+        Corresponds to j in the above JW transform.
 
     Returns
     -------
@@ -537,7 +538,8 @@ def fcreate(N, site=0):
     Examples
     --------
     >>> fcreate(2) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False
+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4),
+    type = oper, isherm = False
     Qobj data =
     [[0. 0. 0. 0.]
     [0. 0. 0. 0.]
@@ -548,7 +550,8 @@ def fcreate(N, site=0):
         return tensor([create(2), *([identity(2)]*(N-1))])
     else:
         if N-site-1 > 0:
-            return tensor([*([sigmaz()]*site), create(2), *([identity(2)]*(N-site-1))])
+            return tensor([*([sigmaz()]*site), create(2),
+                           *([identity(2)]*(N-site-1))])
         else:
             return tensor([*([sigmaz()]*site), create(2)])
 

From 3b2d24dff188e83c258efc456a6154821db684ca Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Sat, 27 May 2023 13:16:35 -0700
Subject: [PATCH 387/602] refactored fermionic operators

---
 doc/changes/2166.feature           |  5 +-
 qutip/core/operators.py            | 96 ++++++++++++++++++++----------
 qutip/tests/core/test_operators.py | 24 ++++----
 3 files changed, 80 insertions(+), 45 deletions(-)

diff --git a/doc/changes/2166.feature b/doc/changes/2166.feature
index f42fe54274..f10db8a251 100644
--- a/doc/changes/2166.feature
+++ b/doc/changes/2166.feature
@@ -1 +1,4 @@
-added fermionic annihilation and creation operators a
\ No newline at end of file
+added fermionic annihilation and creation operators.
+
+Closely followed the protocol proposed in the following `source
+<https://github.com/qutip/qutip/issues/863>`_.
\ No newline at end of file
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index c46e514b9d..6a80fa03f0 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -5,11 +5,11 @@
 
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like',
-           'identity', 'position', 'momentum', 'num', 'squeeze', 'squeezing',
-           'swap', 'displace', 'commutator', 'qutrit_ops', 'qdiags', 'phase',
-           'qzero', 'qzero_like', 'enr_destroy', 'enr_identity', 'charge',
-           'tunneling', 'qft']
+           'destroy', 'create', 'f_op', 'fdestroy', 'fcreate', 'qeye',
+           'qeye_like', 'identity', 'position', 'momentum', 'num', 'squeeze',
+           'squeezing', 'swap', 'displace', 'commutator', 'qutrit_ops',
+           'qdiags', 'phase','qzero', 'qzero_like', 'enr_destroy',
+           'enr_identity', 'charge', 'tunneling', 'qft']
 
 import numbers
 
@@ -18,7 +18,6 @@
 
 from . import data as _data
 from .qobj import Qobj
-from .tensor import tensor
 from .dimensions import flatten
 from .. import settings
 
@@ -472,11 +471,11 @@ def create(N, offset=0, *, dtype=None):
     return qdiags(data, -1, dtype=dtype)
 
 
-def fdestroy(N, site=0):
+def fdestroy(n_sites, site):
     """
     Fermionic destruction operator.
     We use the Jordan-Wigner transformation,
-    making use of the so-called Jordan-Wigner ZZ..Z strings,
+    making use of the Jordan-Wigner ZZ..Z strings,
     to construct this as follows (in Latex):
     a_j = sigma_z^{otimes j}
           otimes (frac{sigma_x + i sigma_y}{2})
@@ -484,8 +483,8 @@ def fdestroy(N, site=0):
 
     Parameters
     ----------
-    N : int
-        Dimension of Hilbert space.
+    n_sites : int
+        Number of sites in Fock space.
 
     site : int (default 0)
         The site in Fock space to add a fermion to.
@@ -499,7 +498,7 @@ def fdestroy(N, site=0):
     Examples
     --------
     >>> fdestroy(2) # doctest: +SKIP
-    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4),
+    Quantum object: dims=[[2 2], [2 2]], shape=(4, 4), \
     type='oper', isherm=False
     Qobj data =
     [[0. 0. 1. 0.]
@@ -507,26 +506,18 @@ def fdestroy(N, site=0):
     [0. 0. 0. 0.]
     [0. 0. 0. 0.]]
     """
-    if site == 0:
-        return tensor([destroy(2), *([identity(2)]*(N-1))])
-    else:
-        if N-site-1 > 0:
-            return tensor([*([sigmaz()]*site), destroy(2),
-                           *([identity(2)]*(N-site-1))])
-        else:
-            return tensor([*([sigmaz()]*site), destroy(2)])
+    return f_op(n_sites, site, 'destruction')
 
 
-def fcreate(N, site=0):
-    """
-    Fermionic creation operator.
+def fcreate(n_sites, site):
+    """ Builds a fermionic creation operator.
 
     Parameters
     ----------
-    N : int
-        Dimension of Hilbert space.
+    n_sites : int
+        Number of sites in Fock space.
 
-    site : int (default 0)
+    site : int
         The site in Fock space to add a fermion to.
         Corresponds to j in the above JW transform.
 
@@ -538,7 +529,7 @@ def fcreate(N, site=0):
     Examples
     --------
     >>> fcreate(2) # doctest: +SKIP
-    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4),
+    Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), \
     type = oper, isherm = False
     Qobj data =
     [[0. 0. 0. 0.]
@@ -546,14 +537,55 @@ def fcreate(N, site=0):
     [1. 0. 0. 0.]
     [0. 1. 0. 0.]]
     """
+    return f_op(n_sites, site, 'creation')
+
+def f_op(n_sites, site, action):
+    """ Makes fermionic creation and destruction operators.
+    We use the Jordan-Wigner transformation,
+    making use of the Jordan-Wigner ZZ..Z strings,
+    to construct this as follows (in Latex):
+    a_j = sigma_z^{otimes j}
+          otimes (frac{sigma_x \pm i sigma_y}{2})
+          otimes I^{otimes N-j-1}
+
+    Parameters
+    ----------
+    action : str
+        The type of operator to build.
+        Can only be 'creation' or 'destruction'
+    
+    n_sites : int
+        Number of sites in Fock space.
+
+    site : int
+        The site in Fock space to create/destroy a fermion on.
+        Corresponds to j in the above JW transform.
+
+    Returns
+    -------
+    oper : qobj
+        Qobj for destruction operator.
+    """
+    from .tensor import tensor
+    # sanity check
+    if site >= n_sites:
+        raise ValueError(f'The specified site {site} is not in \
+                         the range of {n_sites} sites.')
+    if action.lower() == 'creation':
+        operator = create(2)
+    elif action.lower() == 'destruction':
+        operator = destroy(2)
+    else:
+        raise TypeError("Unknown operator '%s'. `action` must be \
+                        either 'creation' or 'destruction.'" % action)
+
     if site == 0:
-        return tensor([create(2), *([identity(2)]*(N-1))])
+        return tensor([operator, *([identity(2)]*(n_sites-1))])
+    elif n_sites-site-1 > 0:
+        return tensor([*([sigmaz()]*site), operator,
+                           *([identity(2)]*(n_sites-site-1))])
     else:
-        if N-site-1 > 0:
-            return tensor([*([sigmaz()]*site), create(2),
-                           *([identity(2)]*(N-site-1))])
-        else:
-            return tensor([*([sigmaz()]*site), create(2)])
+        return tensor([*([sigmaz()]*site), operator])
 
 
 def _implicit_tensor_dimensions(dimensions):
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index c8f1eb5484..d174ef5076 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -251,8 +251,8 @@ def _id_func(val):
     (qutip.spin_Jp, (1,)),
     (qutip.destroy, (5,)),
     (qutip.create, (5,)),
-    (qutip.fdestroy, (5,))
-    (qutip.fcreate, (5,))
+    (qutip.fdestroy, (5,0))
+    (qutip.fcreate, (5,0))
     (qutip.qzero, (5,)),
     (qutip.qeye, (5,)),
     (qutip.position, (5,)),
@@ -346,19 +346,19 @@ def test_qzero_like(dims, superrep, dtype):
     assert new == expected
 
 
-@pytest.mark.parametrize('N', [2, 3, 4, 5])
-def test_fcreate_fdestroy(N):
+@pytest.mark.parametrize('n_sites', [2, 3, 4, 5])
+def test_fcreate_fdestroy(n_sites):
     identity = qutip.tensor([*([qutip.identity(2)]*(N))])
-    zero_tensor = 0*I
-    for size_0 in range(N):
-        c_0 = qutip.fcreate(N, size_0)
-        d_0 = qutip.fdestroy(N, size_0)
-        for size_1 in range(N):
-            c_1 = qutip.fcreate(N, size_1)
-            d_1 = qutip.fdestroy(N, size_1)
+    zero_tensor = 0*identity
+    for site_0 in range(n_sites):
+        c_0 = qutip.fcreate(n_sites, site_0)
+        d_0 = qutip.fdestroy(n_sites, site_0)
+        for site_1 in range(n_sites):
+            c_1 = qutip.fcreate(n_sites, site_1)
+            d_1 = qutip.fdestroy(n_sites, site_1)
             assert qutip.anticommutator(c_0, c_1) == zero_tensor
             assert qutip.anticommutator(d_0, d_1) == zero_tensor
-            if size_0 == size_1:
+            if site_0 == site_1:
                 assert qutip.anticommutator(c_0, d_1) == identity
                 assert qutip.anticommutator(c_1, d_0) == identity
             else:

From e799eb9d6c8bcef30cd8792dd35965c942038023 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Sat, 27 May 2023 13:20:30 -0700
Subject: [PATCH 388/602] pep8 fixes

---
 qutip/core/operators.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 6a80fa03f0..faa101ea72 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -8,7 +8,7 @@
            'destroy', 'create', 'f_op', 'fdestroy', 'fcreate', 'qeye',
            'qeye_like', 'identity', 'position', 'momentum', 'num', 'squeeze',
            'squeezing', 'swap', 'displace', 'commutator', 'qutrit_ops',
-           'qdiags', 'phase','qzero', 'qzero_like', 'enr_destroy',
+           'qdiags', 'phase', 'qzero', 'qzero_like', 'enr_destroy',
            'enr_identity', 'charge', 'tunneling', 'qft']
 
 import numbers
@@ -539,13 +539,14 @@ def fcreate(n_sites, site):
     """
     return f_op(n_sites, site, 'creation')
 
+
 def f_op(n_sites, site, action):
     """ Makes fermionic creation and destruction operators.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
     to construct this as follows (in Latex):
     a_j = sigma_z^{otimes j}
-          otimes (frac{sigma_x \pm i sigma_y}{2})
+          otimes (frac{sigma_x pm i sigma_y}{2})
           otimes I^{otimes N-j-1}
 
     Parameters
@@ -553,7 +554,7 @@ def f_op(n_sites, site, action):
     action : str
         The type of operator to build.
         Can only be 'creation' or 'destruction'
-    
+
     n_sites : int
         Number of sites in Fock space.
 
@@ -583,7 +584,7 @@ def f_op(n_sites, site, action):
         return tensor([operator, *([identity(2)]*(n_sites-1))])
     elif n_sites-site-1 > 0:
         return tensor([*([sigmaz()]*site), operator,
-                           *([identity(2)]*(n_sites-site-1))])
+                       *([identity(2)]*(n_sites-site-1))])
     else:
         return tensor([*([sigmaz()]*site), operator])
 

From 7f2ba5108e253cc0608ba743f42193930472d887 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Sat, 27 May 2023 17:34:50 -0700
Subject: [PATCH 389/602] passing dtype to f_ops

---
 qutip/core/operators.py            | 31 ++++++++++++++++++------------
 qutip/tests/core/test_operators.py | 18 ++++++++---------
 2 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index faa101ea72..79160a4ad1 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -471,7 +471,7 @@ def create(N, offset=0, *, dtype=None):
     return qdiags(data, -1, dtype=dtype)
 
 
-def fdestroy(n_sites, site):
+def fdestroy(n_sites, site, dtype = None):
     """
     Fermionic destruction operator.
     We use the Jordan-Wigner transformation,
@@ -506,10 +506,10 @@ def fdestroy(n_sites, site):
     [0. 0. 0. 0.]
     [0. 0. 0. 0.]]
     """
-    return f_op(n_sites, site, 'destruction')
+    return f_op(n_sites, site, 'destruction', dtype)
 
 
-def fcreate(n_sites, site):
+def fcreate(n_sites, site, dtype = None):
     """ Builds a fermionic creation operator.
 
     Parameters
@@ -537,10 +537,10 @@ def fcreate(n_sites, site):
     [1. 0. 0. 0.]
     [0. 1. 0. 0.]]
     """
-    return f_op(n_sites, site, 'creation')
+    return f_op(n_sites, site, 'creation', dtype = dtype)
 
 
-def f_op(n_sites, site, action):
+def f_op(n_sites, site, action, dtype = None):
     """ Makes fermionic creation and destruction operators.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
@@ -567,26 +567,33 @@ def f_op(n_sites, site, action):
     oper : qobj
         Qobj for destruction operator.
     """
+    # get `tensor` and sigma z objects
     from .tensor import tensor
+    s_z = 2 * jmat(0.5, 'z', dtype = dtype)
+
     # sanity check
     if site >= n_sites:
         raise ValueError(f'The specified site {site} is not in \
                          the range of {n_sites} sites.')
+    
+    # figure out which operator to build
     if action.lower() == 'creation':
-        operator = create(2)
+        operator = create(2, dtype = dtype)
     elif action.lower() == 'destruction':
-        operator = destroy(2)
+        operator = destroy(2, dtype = dtype)
     else:
         raise TypeError("Unknown operator '%s'. `action` must be \
                         either 'creation' or 'destruction.'" % action)
-
+    
+    
+    # build operator
     if site == 0:
-        return tensor([operator, *([identity(2)]*(n_sites-1))])
+        return tensor([operator, *([identity(2, dtype = dtype)]*(n_sites-1))])
     elif n_sites-site-1 > 0:
-        return tensor([*([sigmaz()]*site), operator,
-                       *([identity(2)]*(n_sites-site-1))])
+        return tensor([*([s_z]*site), operator,
+                       *([identity(2, dtype = dtype)]*(n_sites-site-1))])
     else:
-        return tensor([*([sigmaz()]*site), operator])
+        return tensor([*([s_z]*site), operator])
 
 
 def _implicit_tensor_dimensions(dimensions):
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index d174ef5076..be23e04bbb 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -251,8 +251,8 @@ def _id_func(val):
     (qutip.spin_Jp, (1,)),
     (qutip.destroy, (5,)),
     (qutip.create, (5,)),
-    (qutip.fdestroy, (5,0))
-    (qutip.fcreate, (5,0))
+    (qutip.fdestroy, (5,0)),
+    (qutip.fcreate, (5,0)),
     (qutip.qzero, (5,)),
     (qutip.qeye, (5,)),
     (qutip.position, (5,)),
@@ -348,7 +348,7 @@ def test_qzero_like(dims, superrep, dtype):
 
 @pytest.mark.parametrize('n_sites', [2, 3, 4, 5])
 def test_fcreate_fdestroy(n_sites):
-    identity = qutip.tensor([*([qutip.identity(2)]*(N))])
+    identity = qutip.tensor([*([qutip.identity(2)]*(n_sites))])
     zero_tensor = 0*identity
     for site_0 in range(n_sites):
         c_0 = qutip.fcreate(n_sites, site_0)
@@ -356,12 +356,12 @@ def test_fcreate_fdestroy(n_sites):
         for site_1 in range(n_sites):
             c_1 = qutip.fcreate(n_sites, site_1)
             d_1 = qutip.fdestroy(n_sites, site_1)
-            assert qutip.anticommutator(c_0, c_1) == zero_tensor
-            assert qutip.anticommutator(d_0, d_1) == zero_tensor
+            assert qutip.commutator(c_0, c_1, 'anti') == zero_tensor
+            assert qutip.commutator(d_0, d_1, 'anti') == zero_tensor
             if site_0 == site_1:
-                assert qutip.anticommutator(c_0, d_1) == identity
-                assert qutip.anticommutator(c_1, d_0) == identity
+                assert qutip.commutator(c_0, d_1, 'anti') == identity
+                assert qutip.commutator(c_1, d_0, 'anti') == identity
             else:
-                assert qutip.anticommutator(c_0, d_1) == zero_tensor
-                assert qutip.anticommutator(c_1, d_0) == zero_tensor
+                assert qutip.commutator(c_0, d_1, 'anti') == zero_tensor
+                assert qutip.commutator(c_1, d_0, 'anti') == zero_tensor
     assert qutip.commutator(identity, c_0) == zero_tensor

From bb95b0754a6fbe35a23eaa7f6abc79b2325d3260 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Sat, 27 May 2023 17:41:09 -0700
Subject: [PATCH 390/602] fix pep8 issues

---
 qutip/core/operators.py | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 79160a4ad1..25623db48f 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -471,7 +471,7 @@ def create(N, offset=0, *, dtype=None):
     return qdiags(data, -1, dtype=dtype)
 
 
-def fdestroy(n_sites, site, dtype = None):
+def fdestroy(n_sites, site, dtype=None):
     """
     Fermionic destruction operator.
     We use the Jordan-Wigner transformation,
@@ -506,10 +506,10 @@ def fdestroy(n_sites, site, dtype = None):
     [0. 0. 0. 0.]
     [0. 0. 0. 0.]]
     """
-    return f_op(n_sites, site, 'destruction', dtype)
+    return f_op(n_sites, site, 'destruction', dtype=dtype)
 
 
-def fcreate(n_sites, site, dtype = None):
+def fcreate(n_sites, site, dtype=None):
     """ Builds a fermionic creation operator.
 
     Parameters
@@ -537,10 +537,10 @@ def fcreate(n_sites, site, dtype = None):
     [1. 0. 0. 0.]
     [0. 1. 0. 0.]]
     """
-    return f_op(n_sites, site, 'creation', dtype = dtype)
+    return f_op(n_sites, site, 'creation', dtype=dtype)
 
 
-def f_op(n_sites, site, action, dtype = None):
+def f_op(n_sites, site, action, dtype=None):
     """ Makes fermionic creation and destruction operators.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
@@ -569,29 +569,28 @@ def f_op(n_sites, site, action, dtype = None):
     """
     # get `tensor` and sigma z objects
     from .tensor import tensor
-    s_z = 2 * jmat(0.5, 'z', dtype = dtype)
+    s_z = 2 * jmat(0.5, 'z', dtype=dtype)
 
     # sanity check
     if site >= n_sites:
         raise ValueError(f'The specified site {site} is not in \
                          the range of {n_sites} sites.')
-    
+
     # figure out which operator to build
     if action.lower() == 'creation':
-        operator = create(2, dtype = dtype)
+        operator = create(2, dtype=dtype)
     elif action.lower() == 'destruction':
-        operator = destroy(2, dtype = dtype)
+        operator = destroy(2, dtype=dtype)
     else:
         raise TypeError("Unknown operator '%s'. `action` must be \
                         either 'creation' or 'destruction.'" % action)
-    
-    
+
     # build operator
     if site == 0:
-        return tensor([operator, *([identity(2, dtype = dtype)]*(n_sites-1))])
+        return tensor([operator, *([identity(2, dtype=dtype)]*(n_sites-1))])
     elif n_sites-site-1 > 0:
         return tensor([*([s_z]*site), operator,
-                       *([identity(2, dtype = dtype)]*(n_sites-site-1))])
+                       *([identity(2, dtype=dtype)]*(n_sites-site-1))])
     else:
         return tensor([*([s_z]*site), operator])
 

From f0b7801fa5bab68e61d54a09e8ba384d2f5033e4 Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Sun, 28 May 2023 21:40:49 +0200
Subject: [PATCH 391/602] add inherited members to solvers

---
 doc/apidoc/classes.rst | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index 0d3e59e158..9474857686 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -46,18 +46,25 @@ Solvers
 
 .. autoclass:: qutip.solver.sesolve.SESolver
     :members:
-
+    
 .. autoclass:: qutip.solver.mesolve.MESolver
     :members:
-
+    :inherited-members:
+    :show-inheritance:
+      
 .. autoclass:: qutip.solver.brmesolve.BRSolver
     :members:
 
+
 .. autoclass:: qutip.solver.stochastic.SMESolver
     :members:
+    :inherited-members:
+    :show-inheritance:
 
 .. autoclass:: qutip.solver.stochastic.SSESolver
     :members:
+    :inherited-members:
+    :show-inheritance:
 
 
 
@@ -71,6 +78,8 @@ Monte Carlo Solvers
 
 .. autoclass:: qutip.solver.nm_mcsolve.NonMarkovianMCSolver
     :members:
+    :inherited-members:
+    :show-inheritance:
 
 
 .. _classes-non_markov_heom:

From 18d3d39ebca6d1cff6314eee6c5a82a4a37f6896 Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Sun, 28 May 2023 21:55:45 +0200
Subject: [PATCH 392/602] add changelog

---
 doc/changes/2163.doc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2163.doc

diff --git a/doc/changes/2163.doc b/doc/changes/2163.doc
new file mode 100644
index 0000000000..3afab10102
--- /dev/null
+++ b/doc/changes/2163.doc
@@ -0,0 +1 @@
+added inherited members to API doc of solvers: MESolver, SMESolver, SSESolver, NonMarkovianMCSolver
\ No newline at end of file

From 4455cdb300c9d2587069f5be783f666a2e84f1ed Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Mon, 29 May 2023 01:49:27 +0200
Subject: [PATCH 393/602] fix log PR number

---
 doc/changes/2163.doc | 1 -
 doc/changes/2167.doc | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)
 delete mode 100644 doc/changes/2163.doc
 create mode 100644 doc/changes/2167.doc

diff --git a/doc/changes/2163.doc b/doc/changes/2163.doc
deleted file mode 100644
index 3afab10102..0000000000
--- a/doc/changes/2163.doc
+++ /dev/null
@@ -1 +0,0 @@
-added inherited members to API doc of solvers: MESolver, SMESolver, SSESolver, NonMarkovianMCSolver
\ No newline at end of file
diff --git a/doc/changes/2167.doc b/doc/changes/2167.doc
new file mode 100644
index 0000000000..5ca6dd1e25
--- /dev/null
+++ b/doc/changes/2167.doc
@@ -0,0 +1 @@
+added inherited members to API doc of MESolver, SMESolver, SSESolver, NonMarkovianMCSolver
\ No newline at end of file

From 2e40e3e7e53fee2469e1fcd909073c01e3ce4892 Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Mon, 29 May 2023 18:50:06 +0200
Subject: [PATCH 394/602] change cls for class in docstring of solver_base

---
 qutip/solver/solver_base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index a87c7f674d..cd060a1021 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -110,7 +110,7 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
 
         For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
         ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :cls:`Result`. The evolution method and stored
+        expectation values in a :class:`Result`. The evolution method and stored
         results are determined by ``options``.
 
         Parameters

From 994cb3006a30e1204cd47f6e37f5f4fac8fa1fda Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Mon, 29 May 2023 18:55:18 +0200
Subject: [PATCH 395/602] fix line too long

---
 qutip/solver/solver_base.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index cd060a1021..a717c077f5 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -110,8 +110,8 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
 
         For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
         ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :class:`Result`. The evolution method and stored
-        results are determined by ``options``.
+        expectation values in a :class:`Result`. The evolution method and 
+        stored results are determined by ``options``.
 
         Parameters
         ----------

From c0d33aed68c06f99d29a2401a0118cf1003e187c Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Mon, 29 May 2023 19:02:16 +0200
Subject: [PATCH 396/602] remove trailing space

---
 qutip/solver/solver_base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/solver/solver_base.py b/qutip/solver/solver_base.py
index a717c077f5..028eb448f3 100644
--- a/qutip/solver/solver_base.py
+++ b/qutip/solver/solver_base.py
@@ -110,7 +110,7 @@ def run(self, state0, tlist, *, args=None, e_ops=None):
 
         For a ``state0`` at time ``tlist[0]`` do the evolution as directed by
         ``rhs`` and for each time in ``tlist`` store the state and/or
-        expectation values in a :class:`Result`. The evolution method and 
+        expectation values in a :class:`Result`. The evolution method and
         stored results are determined by ``options``.
 
         Parameters

From 2b0a7ed6f1631af36777e53a55eb02308d9fa623 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 29 May 2023 16:11:23 -0400
Subject: [PATCH 397/602] ptrace_diag

---
 qutip/core/data/kron.pyx           |  1 -
 qutip/core/data/ptrace.pyx         | 40 ++++++++++++++----------------
 qutip/tests/core/data/test_diag.py | 17 -------------
 3 files changed, 18 insertions(+), 40 deletions(-)

diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index b849d148d0..efac2f7d42 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -72,7 +72,6 @@ cdef inline void _vec_kron(
     idxint size_l, idxint size_r, idxint step
 ):
     cdef idxint i, j
-    print(size_l, size_r, step)
     for i in range(size_l):
         for j in range(size_r):
             ptr_out[i*step+j] = ptr_l[i] * ptr_r[j]
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 3188818743..f4b64bb6a7 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -127,35 +127,31 @@ cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
 @cython.boundscheck(True)
 @cython.initializedcheck(True)
 def ptrace_diag(matrix, dims, sel):
-    dims, sel = _parse_inputs(dims, sel, matrix.shape)
-
     if len(sel) == len(dims):
         return matrix.copy()
-
+    dims, sel = _parse_inputs(dims, sel, matrix.shape)
     mat = matrix.as_scipy()
     cdef idxint[:, ::1] tensor_table = np.zeros((dims.shape[0], 3), dtype=idxint_dtype)
-    cdef idxint pos[2]
+    cdef idxint pos_row[2]
+    cdef idxint pos_col[2]
     size = _populate_tensor_table(dims, sel, tensor_table)
-    offsets = []
-    data = []
+    data = {}
     for i, offset in enumerate(mat.offsets):
-        _i2_k_t(offset, tensor_table, pos)
-        print(offset, pos[0], pos[1])
-        if pos[1] == 0:
-            offsets.append(pos[0])
-            data.append([0.] * size)
-            start = max(0, offset)
-            end = min(matrix.shape[0] + offset, matrix.shape[1])
-            for col in range(start, end):
-                _i2_k_t(col, tensor_table, pos)
-                data[-1][pos[0]] += mat.data[i, col]
-    if len(offsets) == 0:
+        start = max(0, offset)
+        end = min(matrix.shape[0] + offset, matrix.shape[1])
+        for col in range(start, end):
+            _i2_k_t(col - offset, tensor_table, pos_row)
+            _i2_k_t(col, tensor_table, pos_col)
+            if pos_row[1] == pos_col[1]:
+                new_offset = pos_col[0] - pos_row[0]
+                if new_offset not in data:
+                    data[new_offset] = np.zeros(size, dtype=complex)
+                data[new_offset][pos_col[0]] += mat.data[i, col]
+
+    if len(data) == 0:
         return dia.zeros(size, size)
-    data = np.array(data, dtype=complex)
-    offsets = np.array(offsets, dtype=idxint_dtype)
-    print(data.shape, data.dtype)
-    print(offsets.shape, offsets.dtype)
-    print(size)
+    offsets = np.array(list(data.keys()), dtype=idxint_dtype)
+    data = np.array(list(data.values()), dtype=complex)
     out = Diag((data, offsets), shape=(size, size), copy=False)
     out = dia.clean_diag(out, True)
     return out
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 585fcb60af..43c5318311 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -205,23 +205,6 @@ def test_to_array_is_correct_result(self, data_diag):
         # mathematics, so they should be _identical_.
         assert np.all(test_array == data_diag.as_scipy().toarray())
 
-    def test_to_dense(self, data_diag):
-        data_dense = dia.to_dense(data_diag)
-        assert isinstance(data_dense, Dense)
-        # It's not enough to be accurate within a tolerance here - there's no
-        # mathematics, so they should be _identical_.
-        assert np.all(data_dense.to_array() == data_diag.as_scipy().toarray())
-        assert np.all(data_dense.to_array() == data_diag.to_array())
-
-    def test_from_dense(self, scipy_dia):
-        dense = Dense(scipy_dia.toarray())
-        data_diag = dia.from_dense(dense)
-        assert isinstance(data_diag, Diag)
-        # It's not enough to be accurate within a tolerance here - there's no
-        # mathematics, so they should be _identical_.
-        assert np.all(data_diag.to_array() == data_diag.as_scipy().toarray())
-        assert np.all(data_diag.to_array() == data_diag.to_array())
-
 
 class TestFactoryMethods:
     def test_empty(self, shape, density):

From 8a37ac818cf05ccb24421e5eefc9a8caeca74cf8 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 30 May 2023 10:56:52 -0400
Subject: [PATCH 398/602] Better ptrace

---
 qutip/core/data/ptrace.pyx | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index f4b64bb6a7..31ae79b3d2 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -123,9 +123,6 @@ cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
 
 
 #TODO: cythonize
-@cython.wraparound(True)
-@cython.boundscheck(True)
-@cython.initializedcheck(True)
 def ptrace_diag(matrix, dims, sel):
     if len(sel) == len(dims):
         return matrix.copy()

From fe7fb4efab600eb66e2164f905153bb75d060bdc Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 30 May 2023 11:45:35 -0400
Subject: [PATCH 399/602] Add warning for missing Filelock

---
 qutip/core/coefficient.py            | 10 ++++++++++
 qutip/tests/core/test_coefficient.py | 12 +++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/qutip/core/coefficient.py b/qutip/core/coefficient.py
index b485432d92..0c6ed689be 100644
--- a/qutip/core/coefficient.py
+++ b/qutip/core/coefficient.py
@@ -199,6 +199,9 @@ def const(value):
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 # %%%%%%%%%      Everything under this is for string compilation      %%%%%%%%%
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+WARN_MISSING_MODULE = [0]
+
+
 class CompilationOptions(QutipOptions):
     """
     Compilation options:
@@ -259,6 +262,7 @@ class CompilationOptions(QutipOptions):
         _use_cython = True
     except ImportError:
         _use_cython = False
+        WARN_MISSING_MODULE[0] = 1
 
     _options = {
         "use_cython": _use_cython,
@@ -369,6 +373,12 @@ def coeff_from_str(base, args, args_ctypes, compile_opt=None, **_):
     coeff = None
     # Do we compile?
     if not compile_opt['use_cython']:
+        if WARN_MISSING_MODULE[0]:
+            warnings.warn(
+                "Both `cython` and `filelock` are required for compilation of "
+                "string coefficents. Falling back on `eval`.")
+            # Only warns once.
+            WARN_MISSING_MODULE[0] = 0
         return StrFunctionCoefficient(base, args)
     # Parsing tries to make the code in common pattern
     parsed, variables, constants, raw = try_parse(base, args,
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 9738181d39..99eb7ea308 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -6,9 +6,11 @@
 from functools import partial
 from qutip.core.coefficient import (coefficient, norm, conj, const,
                                     CompilationOptions, Coefficient,
-                                    clean_compiled_coefficient
+                                    clean_compiled_coefficient,
+                                    WARN_MISSING_MODULE,
                                     )
 
+
 # Ensure the latest version is tested
 clean_compiled_coefficient(True)
 
@@ -239,6 +241,14 @@ def test_CoeffOptions():
         assert not isinstance(coeff1, coeff2.__class__)
 
 
+def test_warn_no_cython():
+    option = CompilationOptions(use_cython=False)
+    WARN_MISSING_MODULE[0] = 1
+    with pytest.warns(
+        UserWarning, match="`cython` and `filelock` are required"
+    ):
+        coefficient("t", compile_opt=option)
+
 @pytest.mark.requires_cython
 @pytest.mark.parametrize(['codestring', 'args', 'reference'], [
     pytest.param("cos(2*t)*cos(t*w1) + sin(w1*w2/2*t)*sin(t*w2)"

From 1aa2297020ef6792dd86657f524c943d60787ab1 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 30 May 2023 14:00:24 -0400
Subject: [PATCH 400/602] Filter missing cython warning

---
 qutip/tests/solver/test_integrator.py | 1 +
 qutip/tests/solver/test_mesolve.py    | 1 +
 qutip/tests/solver/test_sesolve.py    | 1 +
 3 files changed, 3 insertions(+)

diff --git a/qutip/tests/solver/test_integrator.py b/qutip/tests/solver/test_integrator.py
index 8779ea76a2..daedf01599 100644
--- a/qutip/tests/solver/test_integrator.py
+++ b/qutip/tests/solver/test_integrator.py
@@ -90,6 +90,7 @@ def test_mc_integration_mixed(self, start, mc_method):
         )
 
 
+@pytest.mark.filterwarnings("ignore:Both `cython` and `filelock`")
 class TestIntegrator(TestIntegratorCte):
     _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
     se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
diff --git a/qutip/tests/solver/test_mesolve.py b/qutip/tests/solver/test_mesolve.py
index 6f6bbab6c7..6684e00c1b 100644
--- a/qutip/tests/solver/test_mesolve.py
+++ b/qutip/tests/solver/test_mesolve.py
@@ -20,6 +20,7 @@ def fidelitycheck(out1, out2, rho0vec):
     return fid
 
 
+@pytest.mark.filterwarnings("ignore:Both `cython` and `filelock`")
 class TestMESolveDecay:
     N = 10
     a = qutip.destroy(N)
diff --git a/qutip/tests/solver/test_sesolve.py b/qutip/tests/solver/test_sesolve.py
index 5ca744f973..48a8cf1246 100644
--- a/qutip/tests/solver/test_sesolve.py
+++ b/qutip/tests/solver/test_sesolve.py
@@ -15,6 +15,7 @@ def _analytic(t, alpha):
     return ((1 - np.exp(-alpha * t)) / alpha)
 
 
+@pytest.mark.filterwarnings("ignore:Both `cython` and `filelock`")
 class TestSeSolve():
     H0 = 0.2 * np.pi * qutip.sigmaz()
     H1 = np.pi * qutip.sigmax()

From 0d3b59a7cb4db97aebc257215cfdc0e97a50b12e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 30 May 2023 14:38:05 -0400
Subject: [PATCH 401/602] Add mention to filelock in the documentation

---
 doc/guide/dynamics/dynamics-time.rst  | 6 +++---
 qutip/tests/conftest.py               | 1 +
 qutip/tests/solver/test_integrator.py | 5 ++++-
 qutip/tests/solver/test_mesolve.py    | 6 +++++-
 qutip/tests/solver/test_sesolve.py    | 6 +++++-
 5 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-time.rst b/doc/guide/dynamics/dynamics-time.rst
index 6be4dc5154..4885803a65 100644
--- a/doc/guide/dynamics/dynamics-time.rst
+++ b/doc/guide/dynamics/dynamics-time.rst
@@ -342,10 +342,10 @@ Any function or method that can be called by ``f(t, args)``, ``f(t, **args)`` is
 **String coefficients** :
 Use a string containing a simple Python expression.
 The variable ``t``, common mathematical functions such as ``sin`` or ``exp`` an variable in args will be available.
-If available, the string will be compiled using cython, fixing variable type when possible, allowing slightly faster excution than function.
+If available, the string will be compiled using cython, fixing variable type when possible, allowing slightly faster execution than function.
 While the speed up is usually very small, in long evolution, numerous calls to the functions are made and it's can accumulate.
 From version 5, compilation of the coefficient is done only once and saved between sessions.
-When Cython is not available, the code will be executed in python with the same environment.
+When either the cython or filelock modules are not available, the code will be executed in python using ``exec`` with the same environment .
 This, however, as no advantage over using python function.
 
 
@@ -439,4 +439,4 @@ In QuTiP 4.4 to 4.7, it was possible to request that the solver pass the state,
 .. plot::
     :context: reset
     :include-source: false
-    :nofigs:
\ No newline at end of file
+    :nofigs:
diff --git a/qutip/tests/conftest.py b/qutip/tests/conftest.py
index 49d4add02a..2ac625ee47 100644
--- a/qutip/tests/conftest.py
+++ b/qutip/tests/conftest.py
@@ -28,6 +28,7 @@ def _skip_cython_tests_if_unavailable(item):
         # importorskip rather than mark.skipif because this way we get pytest's
         # version-handling semantics.
         pytest.importorskip('Cython', minversion='0.14')
+        pytest.importorskip('filelock')
 
 
 @pytest.hookimpl(trylast=True)
diff --git a/qutip/tests/solver/test_integrator.py b/qutip/tests/solver/test_integrator.py
index daedf01599..e87f334ba6 100644
--- a/qutip/tests/solver/test_integrator.py
+++ b/qutip/tests/solver/test_integrator.py
@@ -8,6 +8,10 @@
 from numpy.testing import assert_allclose
 import pytest
 
+# Deactivate warning for test without cython
+from qutip.core.coefficient import WARN_MISSING_MODULE
+WARN_MISSING_MODULE[0] = 0
+
 
 class TestIntegratorCte():
     _analytical_se = lambda _, t: np.cos(t * np.pi)
@@ -90,7 +94,6 @@ def test_mc_integration_mixed(self, start, mc_method):
         )
 
 
-@pytest.mark.filterwarnings("ignore:Both `cython` and `filelock`")
 class TestIntegrator(TestIntegratorCte):
     _analytical_se = lambda _, t: np.cos(t**2/2 * np.pi)
     se_system = qutip.QobjEvo([-1j * qutip.sigmax() * np.pi, "t"])
diff --git a/qutip/tests/solver/test_mesolve.py b/qutip/tests/solver/test_mesolve.py
index 6684e00c1b..7a72a02f64 100644
--- a/qutip/tests/solver/test_mesolve.py
+++ b/qutip/tests/solver/test_mesolve.py
@@ -7,6 +7,11 @@
 import pickle
 import pytest
 
+# Deactivate warning for test without cython
+from qutip.core.coefficient import WARN_MISSING_MODULE
+WARN_MISSING_MODULE[0] = 0
+
+
 all_ode_method = [
     method for method, integrator in MESolver.avail_integrators().items()
     if integrator.support_time_dependant
@@ -20,7 +25,6 @@ def fidelitycheck(out1, out2, rho0vec):
     return fid
 
 
-@pytest.mark.filterwarnings("ignore:Both `cython` and `filelock`")
 class TestMESolveDecay:
     N = 10
     a = qutip.destroy(N)
diff --git a/qutip/tests/solver/test_sesolve.py b/qutip/tests/solver/test_sesolve.py
index 48a8cf1246..12e0e23754 100644
--- a/qutip/tests/solver/test_sesolve.py
+++ b/qutip/tests/solver/test_sesolve.py
@@ -6,6 +6,11 @@
 from qutip.solver.krylovsolve import krylovsolve
 from qutip.solver.solver_base import Solver
 
+# Deactivate warning for test without cython
+from qutip.core.coefficient import WARN_MISSING_MODULE
+WARN_MISSING_MODULE[0] = 0
+
+
 all_ode_method = [
     method for method, integrator in SESolver.avail_integrators().items()
     if integrator.support_time_dependant
@@ -15,7 +20,6 @@ def _analytic(t, alpha):
     return ((1 - np.exp(-alpha * t)) / alpha)
 
 
-@pytest.mark.filterwarnings("ignore:Both `cython` and `filelock`")
 class TestSeSolve():
     H0 = 0.2 * np.pi * qutip.sigmaz()
     H1 = np.pi * qutip.sigmax()

From 2ea58559a09758427589a7d42a847e3b1fd0f799 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Tue, 30 May 2023 16:15:35 -0700
Subject: [PATCH 402/602] making _f_op private/fixing docstring

---
 qutip/core/operators.py | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 25623db48f..538ab57969 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -5,11 +5,11 @@
 
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
-           'destroy', 'create', 'f_op', 'fdestroy', 'fcreate', 'qeye',
-           'qeye_like', 'identity', 'position', 'momentum', 'num', 'squeeze',
-           'squeezing', 'swap', 'displace', 'commutator', 'qutrit_ops',
-           'qdiags', 'phase', 'qzero', 'qzero_like', 'enr_destroy',
-           'enr_identity', 'charge', 'tunneling', 'qft']
+           'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like',
+           'identity', 'position', 'momentum', 'num', 'squeeze','squeezing',
+           'swap', 'displace', 'commutator', 'qutrit_ops', 'qdiags', 'phase',
+           'qzero', 'qzero_like', 'enr_destroy','enr_identity', 'charge',
+           'tunneling', 'qft']
 
 import numbers
 
@@ -506,11 +506,19 @@ def fdestroy(n_sites, site, dtype=None):
     [0. 0. 0. 0.]
     [0. 0. 0. 0.]]
     """
-    return f_op(n_sites, site, 'destruction', dtype=dtype)
+    return _f_op(n_sites, site, 'destruction', dtype=dtype)
 
 
 def fcreate(n_sites, site, dtype=None):
-    """ Builds a fermionic creation operator.
+    """
+    Fermionic creation operator.
+    We use the Jordan-Wigner transformation,
+    making use of the Jordan-Wigner ZZ..Z strings,
+    to construct this as follows (in Latex):
+    a_j = sigma_z^{otimes j}
+          otimes (frac{sigma_x - i sigma_y}{2})
+          otimes I^{otimes N-j-1}
+
 
     Parameters
     ----------
@@ -537,10 +545,10 @@ def fcreate(n_sites, site, dtype=None):
     [1. 0. 0. 0.]
     [0. 1. 0. 0.]]
     """
-    return f_op(n_sites, site, 'creation', dtype=dtype)
+    return _f_op(n_sites, site, 'creation', dtype=dtype)
 
 
-def f_op(n_sites, site, action, dtype=None):
+def _f_op(n_sites, site, action, dtype=None):
     """ Makes fermionic creation and destruction operators.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,

From fb7ec127afe0fbfeb4485cbf3ad9ba7b9507fe64 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Tue, 30 May 2023 16:24:23 -0700
Subject: [PATCH 403/602] fixing pep8 error

---
 qutip/core/operators.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 538ab57969..d02dca3161 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -6,9 +6,9 @@
 __all__ = ['jmat', 'spin_Jx', 'spin_Jy', 'spin_Jz', 'spin_Jm', 'spin_Jp',
            'spin_J_set', 'sigmap', 'sigmam', 'sigmax', 'sigmay', 'sigmaz',
            'destroy', 'create', 'fdestroy', 'fcreate', 'qeye', 'qeye_like',
-           'identity', 'position', 'momentum', 'num', 'squeeze','squeezing',
+           'identity', 'position', 'momentum', 'num', 'squeeze', 'squeezing',
            'swap', 'displace', 'commutator', 'qutrit_ops', 'qdiags', 'phase',
-           'qzero', 'qzero_like', 'enr_destroy','enr_identity', 'charge',
+           'qzero', 'qzero_like', 'enr_destroy', 'enr_identity', 'charge',
            'tunneling', 'qft']
 
 import numbers

From ea653fed4691d65ec8da3909dd9aa84ea765479f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 31 May 2023 13:26:36 -0400
Subject: [PATCH 404/602] Add signal check in our runge_kutta integrator

---
 qutip/core/data/norm.pxd                |  2 +-
 qutip/core/data/norm.pyx                |  2 +-
 qutip/solver/integrator/explicit_rk.pxd | 14 +++++++-------
 qutip/solver/integrator/explicit_rk.pyx | 16 +++++++++-------
 qutip/solver/sode/_sode.pyx             | 12 ++++++------
 5 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
index 5e1b7ebe0d..2d9de1b8dc 100644
--- a/qutip/core/data/norm.pxd
+++ b/qutip/core/data/norm.pxd
@@ -12,4 +12,4 @@ cpdef double l2_csr(CSR matrix) nogil except -1
 cpdef double frobenius_dense(Dense matrix) nogil
 cpdef double l2_dense(Dense matrix) nogil except -1
 
-cpdef double frobenius_data(Data state)
+cpdef double frobenius_data(Data state) except -1
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 7f0611ad78..e3398f0348 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -220,7 +220,7 @@ trace.add_specialisations([
 ], _defer=True)
 
 
-cpdef double frobenius_data(Data state):
+cpdef double frobenius_data(Data state) except -1:
     if type(state) is Dense:
         return frobenius_dense(state)
     elif type(state) is CSR:
diff --git a/qutip/solver/integrator/explicit_rk.pxd b/qutip/solver/integrator/explicit_rk.pxd
index 46bbcf9712..b653850c88 100644
--- a/qutip/solver/integrator/explicit_rk.pxd
+++ b/qutip/solver/integrator/explicit_rk.pxd
@@ -39,24 +39,24 @@ cdef class Explicit_RungeKutta:
     cdef double [:, ::1] a
     cdef double [:, ::1] bi
 
-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=*)
+    cpdef void integrate(Explicit_RungeKutta self, double t, bint step=*) except *
 
-    cpdef void set_initial_value(self, Data y0, double t)
+    cpdef void set_initial_value(self, Data y0, double t) except *
 
-    cdef int _step_in_err(self, double t, int max_step)
+    cdef int _step_in_err(self, double t, int max_step) except -1
 
-    cdef double _compute_step(self, double dt)
+    cdef double _compute_step(self, double dt) except -1
 
-    cdef double _error(self, Data y_new, double dt)
+    cdef double _error(self, Data y_new, double dt) except -1
 
-    cdef void _prep_dense_out(self)
+    cdef void _prep_dense_out(self) except *
 
     cdef Data _interpolate_step(self, double t, Data out)
 
     cdef inline Data _accumulate(self, Data target, double[:] factors,
                                  double dt, int size)
 
-    cdef double _estimate_first_step(self, double t, Data y0)
+    cdef double _estimate_first_step(self, double t, Data y0) except -1
 
     cdef double _get_timestep(self, double t)
 
diff --git a/qutip/solver/integrator/explicit_rk.pyx b/qutip/solver/integrator/explicit_rk.pyx
index c5758405c1..33749a90b7 100644
--- a/qutip/solver/integrator/explicit_rk.pyx
+++ b/qutip/solver/integrator/explicit_rk.pyx
@@ -11,6 +11,7 @@ from qutip.core.data.tidyup import tidyup_csr
 from qutip.core.data.norm import frobenius_data
 from .verner7efficient import vern7_coeff
 from .verner9efficient import vern9_coeff
+from cpython.exc cimport PyErr_CheckSignals
 cimport cython
 import numpy as np
 
@@ -198,7 +199,7 @@ cdef class Explicit_RungeKutta:
         self.b_factor_np = np.empty(self.rk_extra_step, dtype=np.float64)
         self.b_factor = self.b_factor_np
 
-    cpdef void set_initial_value(self, Data y0, double t):
+    cpdef void set_initial_value(self, Data y0, double t) except *:
         """
         Set the initial state and time of the integration.
         """
@@ -222,7 +223,7 @@ cdef class Explicit_RungeKutta:
         else:
             self._dt_safe = self.first_step
 
-    cdef double _estimate_first_step(self, double t, Data y0):
+    cdef double _estimate_first_step(self, double t, Data y0) except -1:
         if not self.adaptative_step:
             return 0.
 
@@ -265,7 +266,7 @@ cdef class Explicit_RungeKutta:
             dt = max(self.min_step, dt)
         return dt
 
-    cpdef integrate(Explicit_RungeKutta self, double t, bint step=False):
+    cpdef void integrate(Explicit_RungeKutta self, double t, bint step=False) except *:
         """
         Do the integration to t.
         If ``step`` is True, it will make a maximum 1 step and may not reach
@@ -300,6 +301,7 @@ cdef class Explicit_RungeKutta:
             self._t_prev = self._t_front
             self._norm_prev = self._norm_front
             nsteps_left -= self._step_in_err(t, nsteps_left)
+            PyErr_CheckSignals()
             if step:
                 break
 
@@ -316,7 +318,7 @@ cdef class Explicit_RungeKutta:
             self._t = self._t_front
             self._y = copy_to(self._y_front, self._y)
 
-    cdef int _step_in_err(self, double t, int max_step):
+    cdef int _step_in_err(self, double t, int max_step) except -1:
         """
         Do compute one step, repeating until the error is within tolerance.
         """
@@ -338,7 +340,7 @@ cdef class Explicit_RungeKutta:
                 break
         return nsteps
 
-    cdef double _compute_step(self, double dt):
+    cdef double _compute_step(self, double dt) except -1:
         """
         Do compute one step with fixed ``dt``, return the error.
         Use (_t_prev, _y_prev) to create (_t_front, _y_front)
@@ -368,7 +370,7 @@ cdef class Explicit_RungeKutta:
 
         return self._error(self._y_front, dt)
 
-    cdef double _error(self, Data y_new, double dt):
+    cdef double _error(self, Data y_new, double dt) except -1:
         """ Compute the normalized error. (error/tol) """
         if not self.adaptative_step:
             return 0.
@@ -378,7 +380,7 @@ cdef class Explicit_RungeKutta:
         return frobenius_data(self._y_temp) / (self.atol +
                 max(self._norm_prev, self._norm_front) * self.rtol)
 
-    cdef void _prep_dense_out(self):
+    cdef void _prep_dense_out(self) except *:
         """
         Compute derivative for the interpolation step.
         """
diff --git a/qutip/solver/sode/_sode.pyx b/qutip/solver/sode/_sode.pyx
index eb2052b44f..d528228d87 100644
--- a/qutip/solver/sode/_sode.pyx
+++ b/qutip/solver/sode/_sode.pyx
@@ -27,7 +27,7 @@ cdef class Euler:
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef step(self, double t, Data state, double dt, double[:, :] dW):
+    cdef Data step(self, double t, Data state, double dt, double[:, :] dW):
         """
         Integration scheme:
         Basic Euler order 0.5
@@ -50,7 +50,7 @@ cdef class Platen(Euler):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef step(self, double t, Data state, double dt, double[:, :] dW):
+    cdef Data step(self, double t, Data state, double dt, double[:, :] dW):
         """
         Platen rhs function for both master eq and schrodinger eq.
         dV = -iH* (V+Vt)/2 * dt + (d1(V)+d1(Vt))/2 * dt
@@ -109,7 +109,7 @@ cdef class Explicit15(Euler):
     @cython.boundscheck(False)
     @cython.wraparound(False)
     @cython.cdivision(True)
-    cdef step(self, double t, Data state, double dt, double[:, :] dW):
+    cdef Data step(self, double t, Data state, double dt, double[:, :] dW):
         """
         Chapter 11.2 Eq. (2.13)
         Numerical Solution of Stochastic Differential Equations
@@ -254,7 +254,7 @@ cdef class Milstein:
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
+    cdef Data step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
         """
         Chapter 10.3 Eq. (3.12)
         Numerical Solution of Stochastic Differential Equations
@@ -311,7 +311,7 @@ cdef class PredCorr:
 
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
+    cdef Data step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
         """
         Chapter 15.5 Eq. (5.4)
         Numerical Solution of Stochastic Differential Equations
@@ -352,7 +352,7 @@ cdef class PredCorr:
 cdef class Taylor15(Milstein):
     @cython.boundscheck(False)
     @cython.wraparound(False)
-    cdef step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
+    cdef Data step(self, double t, Dense state, double dt, double[:, :] dW, Dense out):
         """
         Chapter 10.4 Eq. (4.6),
         Numerical Solution of Stochastic Differential Equations

From 801091614daf95312cc4fcaf7eab1877a8a06046 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 31 May 2023 15:07:39 -0400
Subject: [PATCH 405/602] store link to data in qobjevo

---
 qutip/core/cy/_element.pxd | 1 +
 qutip/core/cy/_element.pyx | 6 ++++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/qutip/core/cy/_element.pxd b/qutip/core/cy/_element.pxd
index 46f869b266..745df68e9d 100644
--- a/qutip/core/cy/_element.pxd
+++ b/qutip/core/cy/_element.pxd
@@ -6,6 +6,7 @@ from qutip.core.data.base cimport idxint
 from libcpp cimport bool
 
 cdef class _BaseElement:
+    cdef Data _data
     cpdef Data data(self, t)
     cpdef object qobj(self, t)
     cpdef object coeff(self, t)
diff --git a/qutip/core/cy/_element.pyx b/qutip/core/cy/_element.pyx
index 999d51d06d..7400cba74b 100644
--- a/qutip/core/cy/_element.pyx
+++ b/qutip/core/cy/_element.pyx
@@ -273,6 +273,7 @@ cdef class _ConstantElement(_BaseElement):
     """
     def __init__(self, qobj):
         self._qobj = qobj
+        self._data = self._qobj.data
 
     def __mul__(left, right):
         if type(left) is _ConstantElement:
@@ -290,7 +291,7 @@ cdef class _ConstantElement(_BaseElement):
         return NotImplemented
 
     cpdef Data data(self, t):
-        return self._qobj.data
+        return self._data
 
     cpdef object qobj(self, t):
         return self._qobj
@@ -318,6 +319,7 @@ cdef class _EvoElement(_BaseElement):
     """
     def __init__(self, qobj, coefficient):
         self._qobj = qobj
+        self._data = self._qobj.data
         self._coefficient = coefficient
 
     def __mul__(left, right):
@@ -343,7 +345,7 @@ cdef class _EvoElement(_BaseElement):
         return _EvoElement(left._qobj * right._qobj, coefficient)
 
     cpdef Data data(self, t):
-        return self._qobj.data
+        return self._data
 
     cpdef object qobj(self, t):
         return self._qobj

From bea7ba6ba699e12a9bfa51c6826a6189277236dc Mon Sep 17 00:00:00 2001
From: EmilianoG-byte <57567043+EmilianoG-byte@users.noreply.github.com>
Date: Wed, 31 May 2023 23:29:27 +0200
Subject: [PATCH 406/602] add inherited methods to se, mc and br solvers

---
 doc/apidoc/classes.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index 9474857686..32a8d2ae58 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -46,6 +46,8 @@ Solvers
 
 .. autoclass:: qutip.solver.sesolve.SESolver
     :members:
+    :inherited-members:
+    :show-inheritance:
     
 .. autoclass:: qutip.solver.mesolve.MESolver
     :members:
@@ -54,6 +56,8 @@ Solvers
       
 .. autoclass:: qutip.solver.brmesolve.BRSolver
     :members:
+    :inherited-members:
+    :show-inheritance:
 
 
 .. autoclass:: qutip.solver.stochastic.SMESolver
@@ -75,6 +79,8 @@ Monte Carlo Solvers
 
 .. autoclass:: qutip.solver.mcsolve.MCSolver
     :members:
+    :inherited-members:
+    :show-inheritance:
 
 .. autoclass:: qutip.solver.nm_mcsolve.NonMarkovianMCSolver
     :members:

From 9a77a4c9b5d764bf7d9a924e3c87ca4559d375c9 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Wed, 31 May 2023 18:46:10 -0700
Subject: [PATCH 407/602] fixed eqns in docstring and put new functions in docs

---
 doc/apidoc/functions.rst           |  2 +-
 qutip/core/operators.py            | 38 +++++++++++++++++-------------
 qutip/tests/core/test_operators.py |  8 +++----
 3 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 56723d52df..43e00a41a2 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -18,7 +18,7 @@ Quantum Operators
 -----------------
 
 .. automodule:: qutip.core.operators
-    :members: charge, commutator, create, destroy, displace, enr_destroy, enr_identity, jmat, num, qeye, identity, momentum, phase, position, qdiags, qutrit_ops, qzero, sigmam, sigmap, sigmax, sigmay, sigmaz, spin_Jx, spin_Jy, spin_Jz, spin_Jm, spin_Jp, squeeze, squeezing, tunneling
+    :members: charge, commutator, create, destroy, displace, enr_destroy, enr_identity, fcreate, fdestroy, jmat, num, qeye, identity, momentum, phase, position, qdiags, qutrit_ops, qzero, sigmam, sigmap, sigmax, sigmay, sigmaz, spin_Jx, spin_Jy, spin_Jz, spin_Jm, spin_Jp, squeeze, squeezing, tunneling
 
 
 .. _functions-rand:
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index d02dca3161..4556a437f5 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -476,10 +476,11 @@ def fdestroy(n_sites, site, dtype=None):
     Fermionic destruction operator.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
-    to construct this as follows (in Latex):
-    a_j = sigma_z^{otimes j}
-          otimes (frac{sigma_x + i sigma_y}{2})
-          otimes I^{otimes N-j-1}
+    to construct this as follows:
+    .. math::
+        a_j = \\sigma_z^{\\otimes j} \\otimes 
+        (\\frac{\\sigma_x + i \\sigma_y}{2}) 
+        \\otimes I^{\\otimes N-j-1}
 
     Parameters
     ----------
@@ -514,10 +515,12 @@ def fcreate(n_sites, site, dtype=None):
     Fermionic creation operator.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
-    to construct this as follows (in Latex):
-    a_j = sigma_z^{otimes j}
-          otimes (frac{sigma_x - i sigma_y}{2})
-          otimes I^{otimes N-j-1}
+    to construct this as follows:
+
+    .. math::
+        a_j = \\sigma_z^{\\otimes j} 
+        \\otimes (frac{sigma_x - i sigma_y}{2}) 
+        \\otimes I^{\\otimes N-j-1}
 
 
     Parameters
@@ -580,7 +583,13 @@ def _f_op(n_sites, site, action, dtype=None):
     s_z = 2 * jmat(0.5, 'z', dtype=dtype)
 
     # sanity check
-    if site >= n_sites:
+    if site < 0:
+        raise ValueError(f'The specified site {site} cannot be \
+                         less than 0.')
+    elif 0 >= n_sites:
+        raise ValueError(f'The specified number of sites {n_sites} \
+                         cannot be equal to or less than 0.')
+    elif site >= n_sites:
         raise ValueError(f'The specified site {site} is not in \
                          the range of {n_sites} sites.')
 
@@ -593,14 +602,9 @@ def _f_op(n_sites, site, action, dtype=None):
         raise TypeError("Unknown operator '%s'. `action` must be \
                         either 'creation' or 'destruction.'" % action)
 
-    # build operator
-    if site == 0:
-        return tensor([operator, *([identity(2, dtype=dtype)]*(n_sites-1))])
-    elif n_sites-site-1 > 0:
-        return tensor([*([s_z]*site), operator,
-                       *([identity(2, dtype=dtype)]*(n_sites-site-1))])
-    else:
-        return tensor([*([s_z]*site), operator])
+    eye = identity(2, dtype=dtype)
+    opers = [s_z] * site + [operator] + [eye * (n_sites - site - 1)]
+    return tensor(opers)
 
 
 def _implicit_tensor_dimensions(dimensions):
diff --git a/qutip/tests/core/test_operators.py b/qutip/tests/core/test_operators.py
index be23e04bbb..5a887280cf 100644
--- a/qutip/tests/core/test_operators.py
+++ b/qutip/tests/core/test_operators.py
@@ -251,8 +251,8 @@ def _id_func(val):
     (qutip.spin_Jp, (1,)),
     (qutip.destroy, (5,)),
     (qutip.create, (5,)),
-    (qutip.fdestroy, (5,0)),
-    (qutip.fcreate, (5,0)),
+    (qutip.fdestroy, (5, 0)),
+    (qutip.fcreate, (5, 0)),
     (qutip.qzero, (5,)),
     (qutip.qeye, (5,)),
     (qutip.position, (5,)),
@@ -348,8 +348,8 @@ def test_qzero_like(dims, superrep, dtype):
 
 @pytest.mark.parametrize('n_sites', [2, 3, 4, 5])
 def test_fcreate_fdestroy(n_sites):
-    identity = qutip.tensor([*([qutip.identity(2)]*(n_sites))])
-    zero_tensor = 0*identity
+    identity = qutip.identity([2] * n_sites)
+    zero_tensor = qutip.qzero([2] * n_sites)
     for site_0 in range(n_sites):
         c_0 = qutip.fcreate(n_sites, site_0)
         d_0 = qutip.fdestroy(n_sites, site_0)

From 13ef3f9a9a811a24003dc423db9c931a8175956a Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Thu, 1 Jun 2023 14:11:14 -0700
Subject: [PATCH 408/602] fixing bugs

---
 qutip/core/operators.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 4556a437f5..276dd284cb 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -477,7 +477,9 @@ def fdestroy(n_sites, site, dtype=None):
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
     to construct this as follows:
+
     .. math::
+
         a_j = \\sigma_z^{\\otimes j} \\otimes 
         (\\frac{\\sigma_x + i \\sigma_y}{2}) 
         \\otimes I^{\\otimes N-j-1}
@@ -518,6 +520,7 @@ def fcreate(n_sites, site, dtype=None):
     to construct this as follows:
 
     .. math::
+
         a_j = \\sigma_z^{\\otimes j} 
         \\otimes (frac{sigma_x - i sigma_y}{2}) 
         \\otimes I^{\\otimes N-j-1}
@@ -555,10 +558,13 @@ def _f_op(n_sites, site, action, dtype=None):
     """ Makes fermionic creation and destruction operators.
     We use the Jordan-Wigner transformation,
     making use of the Jordan-Wigner ZZ..Z strings,
-    to construct this as follows (in Latex):
-    a_j = sigma_z^{otimes j}
-          otimes (frac{sigma_x pm i sigma_y}{2})
-          otimes I^{otimes N-j-1}
+    to construct this as follows:
+
+    .. math::
+
+        a_j = \\sigma_z^{\\otimes j} 
+        \\otimes (frac{sigma_x - i sigma_y}{2}) 
+        \\otimes I^{\\otimes N-j-1}
 
     Parameters
     ----------
@@ -603,7 +609,7 @@ def _f_op(n_sites, site, action, dtype=None):
                         either 'creation' or 'destruction.'" % action)
 
     eye = identity(2, dtype=dtype)
-    opers = [s_z] * site + [operator] + [eye * (n_sites - site - 1)]
+    opers = [s_z] * site + [operator] + [eye] * (n_sites - site - 1)
     return tensor(opers)
 
 

From f0c0919c7157364dac7241a5289469cb5ce81736 Mon Sep 17 00:00:00 2001
From: Nikhil Harle <nikhil.calvin@gmail.com>
Date: Thu, 1 Jun 2023 14:13:45 -0700
Subject: [PATCH 409/602] fixing pep8 errors

---
 qutip/core/operators.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 276dd284cb..7dc8935b4b 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -480,8 +480,8 @@ def fdestroy(n_sites, site, dtype=None):
 
     .. math::
 
-        a_j = \\sigma_z^{\\otimes j} \\otimes 
-        (\\frac{\\sigma_x + i \\sigma_y}{2}) 
+        a_j = \\sigma_z^{\\otimes j} \\otimes
+        (\\frac{\\sigma_x + i \\sigma_y}{2})
         \\otimes I^{\\otimes N-j-1}
 
     Parameters
@@ -521,8 +521,8 @@ def fcreate(n_sites, site, dtype=None):
 
     .. math::
 
-        a_j = \\sigma_z^{\\otimes j} 
-        \\otimes (frac{sigma_x - i sigma_y}{2}) 
+        a_j = \\sigma_z^{\\otimes j}
+        \\otimes (frac{sigma_x - i sigma_y}{2})
         \\otimes I^{\\otimes N-j-1}
 
 
@@ -562,8 +562,8 @@ def _f_op(n_sites, site, action, dtype=None):
 
     .. math::
 
-        a_j = \\sigma_z^{\\otimes j} 
-        \\otimes (frac{sigma_x - i sigma_y}{2}) 
+        a_j = \\sigma_z^{\\otimes j}
+        \\otimes (frac{sigma_x \\pm i sigma_y}{2})
         \\otimes I^{\\otimes N-j-1}
 
     Parameters

From 0e48b29cd84a2267bd151da3ea156c4949018fea Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 2 Jun 2023 20:06:06 +0900
Subject: [PATCH 410/602] add class Color

---
 qutip/__init__.py      | 2 ++
 qutip/visualization.py | 7 ++-----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/qutip/__init__.py b/qutip/__init__.py
index fc7f65b409..e7d1413f5e 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -5,6 +5,8 @@
 from qutip.settings import settings
 import qutip.version
 from qutip.version import version as __version__
+import qutip.color
+from qutip.color import color
 
 # -----------------------------------------------------------------------------
 # Look to see if we are running with OPENMP
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 27fe62c60a..b7c8adfb2e 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -20,7 +20,7 @@
 from packaging.version import parse as parse_version
 
 from . import (
-    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
+    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings, color
 )
 from .core.dimensions import flatten
 from .core.superop_reps import _to_superpauli, isqubitdims
@@ -243,10 +243,7 @@ def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
     # Apply default colormaps.
     # TODO: abstract this away into something that makes default
     #       colormaps.
-    cmap = (
-        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
-        if cmap is None else cmap
-    )
+    cmap = color.cmap
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):

From bd1a4c67d0ea55f6eb2f661843fbd887a1decfb2 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sat, 3 Jun 2023 06:17:48 +0900
Subject: [PATCH 411/602] class Color file

---
 qutip/color.py | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 qutip/color.py

diff --git a/qutip/color.py b/qutip/color.py
new file mode 100644
index 0000000000..ca79965761
--- /dev/null
+++ b/qutip/color.py
@@ -0,0 +1,29 @@
+from qutip.settings import settings
+from matplotlib import cm
+
+__all__ = ['color']
+
+
+class Color:
+    """
+    Colormap for visualization functions
+    """
+    def __init__(self):
+        self._cmap = None  # プライベート変数を定義
+
+    @property
+    def cmap(self):
+        """Set colormap corresponding to colorblind_safe"""
+        if settings.colorblind_safe:
+            self._cmap = cm.Greys_r
+        else:
+            self._cmap = cm.RdBu
+        return self._cmap
+
+    @cmap.setter
+    def cmap(self,value):
+        """Set colormap manually"""
+        self._cmap = value
+
+
+color = Color()
\ No newline at end of file

From 9365b223b56c20c3ac81c718ba79c02d11f72df3 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sat, 3 Jun 2023 06:19:54 +0900
Subject: [PATCH 412/602] delete japanese comment

---
 qutip/color.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/color.py b/qutip/color.py
index ca79965761..011e71f37f 100644
--- a/qutip/color.py
+++ b/qutip/color.py
@@ -9,7 +9,7 @@ class Color:
     Colormap for visualization functions
     """
     def __init__(self):
-        self._cmap = None  # プライベート変数を定義
+        self._cmap = None
 
     @property
     def cmap(self):

From a043efe6ad4698c55922adfe12a9dc5e743712fe Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 5 Jun 2023 07:50:52 +0900
Subject: [PATCH 413/602] merge plot spin distribution functions for 2d and 3d
 into one

---
 qutip/visualization.py | 85 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 83 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index b7c8adfb2e..3b19d5da77 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,7 +7,7 @@
            'plot_energy_levels', 'fock_distribution',
            'plot_fock_distribution', 'wigner_fock_distribution',
            'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution_2d',
+           'plot_expectation_values', 'plot_spin_distribution', 'plot_spin_distribution_2d',
            'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
            'complex_array_to_rgb', 'matrix_histogram',
            'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
@@ -1254,10 +1254,91 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
             axes[n, 0].legend()
         if ylabels:
             axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
-
     return fig, axes
 
 
+def plot_spin_distribution(P, THETA, PHI,
+                           fig=None, ax=None, figsize=(8,6),projection='2d'):
+    """
+    Plots a spin distribution (given as meshgrid data).
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    projection: string {'2d', '3d'}
+        Specify whether the spin distribution function is to be plotted as a 2D
+        projection where the surface of the unit sphere is mapped on the unit disk ('2d')
+        or surface plot ('3d').
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+    if projection == '2d':
+        if not fig and not ax:
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+        Y = (THETA - pi / 2) / (pi / 2)
+        X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
+
+        if P.min() < -1e12:
+            cmap = cm.RdBu
+        else:
+            cmap = cm.RdYlBu
+
+        ax.pcolor(X, Y, P.real, cmap=cmap)
+        ax.set_xlabel(r'$\varphi$', fontsize=18)
+        ax.set_ylabel(r'$\theta$', fontsize=18)
+
+        ax.set_xticks([-1, 0, 1])
+        ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
+        ax.set_yticks([-1, 0, 1])
+        ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
+    elif projection == '3d':
+        if not fig and not ax:
+            fig = plt.figure(figsize=figsize)
+            ax = _axes3D(fig, azim=-35, elev=35)
+        xx = sin(THETA) * cos(PHI)
+        yy = sin(THETA) * sin(PHI)
+        zz = cos(THETA)
+
+        if P.min() < -1e12:
+            cmap = cm.RdBu
+            norm = mpl.colors.Normalize(-P.max(), P.max())
+        else:
+            cmap = cm.RdYlBu
+            norm = mpl.colors.Normalize(P.min(), P.max())
+
+        ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+                        facecolors=cmap(norm(P)), linewidth=0)
+
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cb1.set_label('magnitude')
+    else:
+        raise ValueError('Unexpected value of projection keyword argument')
+    return fig, ax
+
+
 def plot_spin_distribution_2d(P, THETA, PHI,
                               fig=None, ax=None, figsize=(8, 8)):
     """

From 7b6ec74f0102fd3754b2953896b3ac312c44ca36 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 5 Jun 2023 17:50:59 +0900
Subject: [PATCH 414/602] organize arguments of hinton

---
 qutip/visualization.py | 201 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 196 insertions(+), 5 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 3b19d5da77..61d0b3311e 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,10 +7,11 @@
            'plot_energy_levels', 'fock_distribution',
            'plot_fock_distribution', 'wigner_fock_distribution',
            'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution', 'plot_spin_distribution_2d',
+           'plot_expectation_values', 'plot_spin_distribution_2d',
            'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
            'complex_array_to_rgb', 'matrix_histogram',
-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
+           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere',
+           'plot_spin_distribution', 'new_hinton']
 
 import warnings
 import itertools as it
@@ -170,6 +171,199 @@ def _cb_labels(left_dims):
     ]
 
 
+# Adopted from the SciPy Cookbook.
+def new_hinton(rho, xlabels=None, ylabels=None, label_top=True, color_style="scaled",
+           figure = None, figure_options = {}, axes = None, axes_options = {}):
+    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
+
+    Parameters
+    ----------
+    rho : qobj
+        Input density matrix or superoperator.
+
+    xlabels : list of strings or False
+        list of x labels
+
+    ylabels : list of strings or False
+        list of y labels
+
+    label_top : bool
+        If True, x-axis labels will be placed on top, otherwise
+        they will appear below the plot.
+
+    color_style : string
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"scaled"`` (default), each color is chosen by
+           passing the absolute value of the corresponding matrix
+           element into `cmap` with the sign of the real part.
+        -  If set to ``"threshold"``, each square is plotted as
+           the maximum of `cmap` for the positive real part and as
+           the minimum for the negative part of the matrix element;
+           note that this generalizes `"threshold"` to complex numbers.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    figure : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    figure_options : dict
+        dict of options to create a figure object
+
+    axes : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    axes_options : dict
+        dict of options to set to an axes object
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not a quantum object.
+
+    Examples
+    --------
+    >>> import qutip
+    >>>
+    >>> dm = qutip.rand_dm(4)
+    >>> fig, ax = qutip.hinton(dm)
+    >>> fig.show()
+    >>>
+    >>> qutip.settings.colorblind_safe = True
+    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
+    >>> fig.show()
+    >>> qutip.settings.colorblind_safe = False
+    >>>
+    >>> fig, ax = qutip.hinton(dm, color_style="phase")
+    >>> fig.show()
+    """
+
+    cmap = axes_options.pop('cmap', None)
+    if cmap is None:
+        cmap = color.cmap
+
+    if figure is None:
+        if axes is None:
+            figure, axes = plt.subplots(1, 1, **figure_options)
+        else:
+            figure = axes.get_figure()
+    else:
+        if axes is None:
+            axes = figure.add_subplots(1, 1)
+
+    axes.set(**axes_options)
+
+    # Extract plotting data W from the input.
+    if isinstance(rho, Qobj):
+        if rho.isoper:
+            W = rho.full()
+
+            # Create default labels if none are given.
+            if xlabels is None or ylabels is None:
+                labels = _cb_labels(rho.dims[0])
+                xlabels = xlabels if xlabels is not None else list(labels[0])
+                ylabels = ylabels if ylabels is not None else list(labels[1])
+
+        elif rho.isoperket:
+            W = vector_to_operator(rho).full()
+        elif rho.isoperbra:
+            W = vector_to_operator(rho.dag()).full()
+        elif rho.issuper:
+            if not isqubitdims(rho.dims):
+                raise ValueError("Hinton plots of superoperators are "
+                                 "currently only supported for qubits.")
+            # Convert to a superoperator in the Pauli basis,
+            # so that all the elements are real.
+            sqobj = _to_superpauli(rho)
+            nq = int(log2(sqobj.shape[0]) / 2)
+            W = sqobj.full().T
+            # Create default labels, too.
+            if (xlabels is None) or (ylabels is None):
+                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+                xlabels = xlabels if xlabels is not None else labels
+                ylabels = ylabels if ylabels is not None else labels
+
+        else:
+            raise ValueError(
+                "Input quantum object must be an operator or superoperator."
+            )
+    else:
+        W = rho
+
+    if not (xlabels or ylabels):
+        axes.axis('off')
+    axes.axis('equal')
+    axes.set_frame_on(False)
+
+    height, width = W.shape
+
+    w_max = 1.25 * max(abs(np.array(W)).flatten())
+    if w_max <= 0.0:
+        w_max = 1.0
+
+    # Set color_fn here.
+    if color_style == "scaled":
+        def color_fn(w):
+            w = np.abs(w) * np.sign(np.real(w))
+            return cmap(int((w + w_max) * 256 / (2 * w_max)))
+    elif color_style == "threshold":
+        def color_fn(w):
+            w = np.real(w)
+            return cmap(255 if w > 0 else 0)
+    elif color_style == "phase":
+        def color_fn(w):
+            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
+    else:
+        raise ValueError(
+            "Unknown color style {} for Hinton diagrams.".format(color_style)
+        )
+
+    axes.fill(array([0, width, width, 0]), array([0, 0, height, height]),
+            color=cmap(128))
+    for x in range(width):
+        for y in range(height):
+            _x = x + 1
+            _y = y + 1
+            _blob(
+                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
+                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=axes)
+
+    # color axis
+    vmax = np.pi if color_style == "phase" else abs(W).max()
+    norm = mpl.colors.Normalize(-vmax, vmax)
+    cax, kw = mpl.colorbar.make_axes(axes, shrink=0.75, pad=.1)
+    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+
+    # x axis
+    xtics = 0.5 + np.arange(width)
+    axes.xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xlabels:
+        nxlabels = len(xlabels)
+        if nxlabels != len(xtics):
+            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
+        axes.set_xticklabels(xlabels)
+        if label_top:
+            axes.xaxis.tick_top()
+    axes.tick_params(axis='x', labelsize=14)
+
+    # y axis
+    ytics = 0.5 + np.arange(height)
+    axes.yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if ylabels:
+        nylabels = len(ylabels)
+        if nylabels != len(ytics):
+            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
+        axes.set_yticklabels(list(reversed(ylabels)))
+    axes.tick_params(axis='y', labelsize=14)
+
+    return figure, axes
+
 # Adopted from the SciPy Cookbook.
 def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
            label_top=True, color_style="scaled"):
@@ -240,9 +434,6 @@ def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
     >>> fig.show()
     """
 
-    # Apply default colormaps.
-    # TODO: abstract this away into something that makes default
-    #       colormaps.
     cmap = color.cmap
 
     # Extract plotting data W from the input.

From 9e71b23558d678eda35c871a08c037130df394f8 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 5 Jun 2023 17:52:02 +0900
Subject: [PATCH 415/602] minor change

---
 qutip/visualization.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 61d0b3311e..1515e820a6 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -434,7 +434,10 @@ def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
     >>> fig.show()
     """
 
-    cmap = color.cmap
+    cmap = (
+        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
+        if cmap is None else cmap
+    )
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):

From 2172e749c08d757f550f242d4b72acd76cf82b75 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 5 Jun 2023 17:53:48 +0900
Subject: [PATCH 416/602] minor change2

---
 qutip/visualization.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 1515e820a6..af2f81e655 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -434,6 +434,10 @@ def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
     >>> fig.show()
     """
 
+    # Apply default colormaps.
+    # TODO: abstract this away into something that makes default
+    #       colormaps.
+
     cmap = (
         (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
         if cmap is None else cmap
@@ -1448,6 +1452,7 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
             axes[n, 0].legend()
         if ylabels:
             axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
+
     return fig, axes
 
 

From a654901947faf1e9650e1f7535502f4cee882f9d Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 7 Jun 2023 20:27:31 +0900
Subject: [PATCH 417/602] delete class Color and change arguments of new_hinton

---
 qutip/__init__.py      |  3 ---
 qutip/color.py         | 29 -----------------------------
 qutip/visualization.py | 22 ++++++++++++++--------
 3 files changed, 14 insertions(+), 40 deletions(-)
 delete mode 100644 qutip/color.py

diff --git a/qutip/__init__.py b/qutip/__init__.py
index e7d1413f5e..fb00809325 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -5,9 +5,6 @@
 from qutip.settings import settings
 import qutip.version
 from qutip.version import version as __version__
-import qutip.color
-from qutip.color import color
-
 # -----------------------------------------------------------------------------
 # Look to see if we are running with OPENMP
 #
diff --git a/qutip/color.py b/qutip/color.py
deleted file mode 100644
index 011e71f37f..0000000000
--- a/qutip/color.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from qutip.settings import settings
-from matplotlib import cm
-
-__all__ = ['color']
-
-
-class Color:
-    """
-    Colormap for visualization functions
-    """
-    def __init__(self):
-        self._cmap = None
-
-    @property
-    def cmap(self):
-        """Set colormap corresponding to colorblind_safe"""
-        if settings.colorblind_safe:
-            self._cmap = cm.Greys_r
-        else:
-            self._cmap = cm.RdBu
-        return self._cmap
-
-    @cmap.setter
-    def cmap(self,value):
-        """Set colormap manually"""
-        self._cmap = value
-
-
-color = Color()
\ No newline at end of file
diff --git a/qutip/visualization.py b/qutip/visualization.py
index af2f81e655..0efeb62fb3 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -21,7 +21,7 @@
 from packaging.version import parse as parse_version
 
 from . import (
-    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings, color
+    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
 )
 from .core.dimensions import flatten
 from .core.superop_reps import _to_superpauli, isqubitdims
@@ -46,6 +46,11 @@ def _axes3D(*args, **kwargs):
 except:
     pass
 
+def _cmap():
+    if settings.colorblind_safe:
+        return cm.Greys_r
+    else:
+        return cm.RdBu
 
 def plot_wigner_sphere(fig, ax, wigner, reflections):
     """Plots a coloured Bloch sphere.
@@ -172,8 +177,12 @@ def _cb_labels(left_dims):
 
 
 # Adopted from the SciPy Cookbook.
-def new_hinton(rho, xlabels=None, ylabels=None, label_top=True, color_style="scaled",
-           figure = None, figure_options = {}, axes = None, axes_options = {}):
+def new_hinton(rho,
+               xlabels=None, ylabels=None,
+               title = None,
+               cmap = None,
+               label_top=True, color_style="scaled",
+           figure = None, axes = None):
     """Draws a Hinton diagram for visualizing a density matrix or superoperator.
 
     Parameters
@@ -244,21 +253,18 @@ def new_hinton(rho, xlabels=None, ylabels=None, label_top=True, color_style="sca
     >>> fig.show()
     """
 
-    cmap = axes_options.pop('cmap', None)
     if cmap is None:
-        cmap = color.cmap
+        cmap = _cmap()
 
     if figure is None:
         if axes is None:
-            figure, axes = plt.subplots(1, 1, **figure_options)
+            figure, axes = plt.subplots(1, 1)
         else:
             figure = axes.get_figure()
     else:
         if axes is None:
             axes = figure.add_subplots(1, 1)
 
-    axes.set(**axes_options)
-
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):
         if rho.isoper:

From 92317c13b7afd46a6efa847774b169138526784a Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 9 Jun 2023 14:43:06 +0900
Subject: [PATCH 418/602] change logic to add label to operket and operbra

---
 qutip/visualization.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 0efeb62fb3..8496158391 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -267,7 +267,12 @@ def new_hinton(rho,
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):
-        if rho.isoper:
+        if rho.isoper or rho.isoperket or rho.isoperbra:
+            if rho.isoperket:
+                rho =  vector_to_operator(rho)
+                print("yes")
+            if rho.isoperbra:
+                rho = vector_to_operator(rho.dag())
             W = rho.full()
 
             # Create default labels if none are given.
@@ -276,10 +281,6 @@ def new_hinton(rho,
                 xlabels = xlabels if xlabels is not None else list(labels[0])
                 ylabels = ylabels if ylabels is not None else list(labels[1])
 
-        elif rho.isoperket:
-            W = vector_to_operator(rho).full()
-        elif rho.isoperbra:
-            W = vector_to_operator(rho.dag()).full()
         elif rho.issuper:
             if not isqubitdims(rho.dims):
                 raise ValueError("Hinton plots of superoperators are "

From 201e691003fd454e857ebdd29ce2a7dbfd167538 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 9 Jun 2023 20:45:35 +0900
Subject: [PATCH 419/602] add docstring for hinton superoperator

---
 qutip/visualization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 8496158391..1f676c7eef 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -189,6 +189,7 @@ def new_hinton(rho,
     ----------
     rho : qobj
         Input density matrix or superoperator.
+        NOTE: Hinton plots of superoperators are currently only supported for qubits.
 
     xlabels : list of strings or False
         list of x labels
@@ -271,7 +272,7 @@ def new_hinton(rho,
             if rho.isoperket:
                 rho =  vector_to_operator(rho)
                 print("yes")
-            if rho.isoperbra:
+            elif rho.isoperbra:
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
 

From 693541e6a5cb484a09a7a29ed0ccf5570a1ae4ef Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 12 Jun 2023 16:28:07 +0900
Subject: [PATCH 420/602] change hinton, matrix_histogram_complex and
 plot_energy_levels

---
 qutip/visualization.py | 433 ++++++++++++-----------------------------
 1 file changed, 123 insertions(+), 310 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 1f676c7eef..842cbc9e83 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -11,7 +11,7 @@
            'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
            'complex_array_to_rgb', 'matrix_histogram',
            'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere',
-           'plot_spin_distribution', 'new_hinton']
+           'plot_spin_distribution']
 
 import warnings
 import itertools as it
@@ -52,6 +52,12 @@ def _cmap():
     else:
         return cm.RdBu
 
+def _cyclic_cmap():
+    if settings.colorblind_safe:
+        return cm.twilight
+    else:
+        return complex_phase_cmap()
+
 def plot_wigner_sphere(fig, ax, wigner, reflections):
     """Plots a coloured Bloch sphere.
 
@@ -177,12 +183,8 @@ def _cb_labels(left_dims):
 
 
 # Adopted from the SciPy Cookbook.
-def new_hinton(rho,
-               xlabels=None, ylabels=None,
-               title = None,
-               cmap = None,
-               label_top=True, color_style="scaled",
-           figure = None, axes = None):
+def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True,
+           color_style="scaled", label_top=True, figure = None, axes = None):
     """Draws a Hinton diagram for visualizing a density matrix or superoperator.
 
     Parameters
@@ -191,15 +193,17 @@ def new_hinton(rho,
         Input density matrix or superoperator.
         NOTE: Hinton plots of superoperators are currently only supported for qubits.
 
-    xlabels : list of strings or False
-        list of x labels
+    xticklabels : list of strings or False
+        list of x ticklabels
 
-    ylabels : list of strings or False
-        list of y labels
+    yticklabels : list of strings or False
+        list of y ticklabels
 
-    label_top : bool
-        If True, x-axis labels will be placed on top, otherwise
-        they will appear below the plot.
+    cmap : a matplotlib colormap instance
+        Color map to use when plotting.
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached.
 
     color_style : string
         Determines how colors are assigned to each square:
@@ -214,6 +218,10 @@ def new_hinton(rho,
         -  If set to ``"phase"``, each color is chosen according to
            the angle of the corresponding matrix element.
 
+    label_top : bool
+        If True, x ticklabels will be placed on top, otherwise
+        they will appear below the plot.
+
     figure : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
@@ -254,9 +262,6 @@ def new_hinton(rho,
     >>> fig.show()
     """
 
-    if cmap is None:
-        cmap = _cmap()
-
     if figure is None:
         if axes is None:
             figure, axes = plt.subplots(1, 1)
@@ -271,16 +276,15 @@ def new_hinton(rho,
         if rho.isoper or rho.isoperket or rho.isoperbra:
             if rho.isoperket:
                 rho =  vector_to_operator(rho)
-                print("yes")
             elif rho.isoperbra:
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
 
             # Create default labels if none are given.
-            if xlabels is None or ylabels is None:
+            if xticklabels is None or yticklabels is None:
                 labels = _cb_labels(rho.dims[0])
-                xlabels = xlabels if xlabels is not None else list(labels[0])
-                ylabels = ylabels if ylabels is not None else list(labels[1])
+                xticklabels = xticklabels if xticklabels is not None else list(labels[0])
+                yticklabels = yticklabels if yticklabels is not None else list(labels[1])
 
         elif rho.issuper:
             if not isqubitdims(rho.dims):
@@ -292,10 +296,10 @@ def new_hinton(rho,
             nq = int(log2(sqobj.shape[0]) / 2)
             W = sqobj.full().T
             # Create default labels, too.
-            if (xlabels is None) or (ylabels is None):
+            if (xticklabels is None) or (yticklabels is None):
                 labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                xlabels = xlabels if xlabels is not None else labels
-                ylabels = ylabels if ylabels is not None else labels
+                xticklabels = xticklabels if xticklabels is not None else labels
+                yticklabels = yticklabels if yticklabels is not None else labels
 
         else:
             raise ValueError(
@@ -304,8 +308,9 @@ def new_hinton(rho,
     else:
         W = rho
 
-    if not (xlabels or ylabels):
+    if not (xticklabels or yticklabels):
         axes.axis('off')
+
     axes.axis('equal')
     axes.set_frame_on(False)
 
@@ -316,6 +321,8 @@ def new_hinton(rho,
         w_max = 1.0
 
     # Set color_fn here.
+    if cmap is None:
+        cmap = _cmap()
     if color_style == "scaled":
         def color_fn(w):
             w = np.abs(w) * np.sign(np.real(w))
@@ -342,20 +349,20 @@ def color_fn(w):
                 _x - 0.5, height - _y + 0.5, W[y, x], w_max,
                 min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=axes)
 
-    # color axis
-    vmax = np.pi if color_style == "phase" else abs(W).max()
-    norm = mpl.colors.Normalize(-vmax, vmax)
-    cax, kw = mpl.colorbar.make_axes(axes, shrink=0.75, pad=.1)
-    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+    if colorbar:
+        vmax = np.pi if color_style == "phase" else abs(W).max()
+        norm = mpl.colors.Normalize(-vmax, vmax)
+        cax, kw = mpl.colorbar.make_axes(axes, shrink=0.75, pad=.1)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
     # x axis
     xtics = 0.5 + np.arange(width)
     axes.xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        axes.set_xticklabels(xlabels)
+    if xticklabels:
+        nxticklabels = len(xticklabels)
+        if nxticklabels != len(xtics):
+            raise ValueError(f"got {nxticklabels} xticklabels but needed {len(xtics)}")
+        axes.set_xticklabels(xticklabels)
         if label_top:
             axes.xaxis.tick_top()
     axes.tick_params(axis='x', labelsize=14)
@@ -363,210 +370,17 @@ def color_fn(w):
     # y axis
     ytics = 0.5 + np.arange(height)
     axes.yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        axes.set_yticklabels(list(reversed(ylabels)))
+    if yticklabels:
+        nyticklabels = len(yticklabels)
+        if nyticklabels != len(ytics):
+            raise ValueError(f"got {nyticklabels} yticklabels but needed {len(ytics)}")
+        axes.set_yticklabels(list(reversed(yticklabels)))
     axes.tick_params(axis='y', labelsize=14)
 
     return figure, axes
 
-# Adopted from the SciPy Cookbook.
-def hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None,
-           label_top=True, color_style="scaled"):
-    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
-
-    Parameters
-    ----------
-    rho : qobj
-        Input density matrix or superoperator.
-
-    xlabels : list of strings or False
-        list of x labels
-
-    ylabels : list of strings or False
-        list of y labels
-
-    title : string
-        title of the plot (optional)
-
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    cmap : a matplotlib colormap instance
-        Color map to use when plotting.
-
-    label_top : bool
-        If True, x-axis labels will be placed on top, otherwise
-        they will appear below the plot.
-
-    color_style : string
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"scaled"`` (default), each color is chosen by
-           passing the absolute value of the corresponding matrix
-           element into `cmap` with the sign of the real part.
-        -  If set to ``"threshold"``, each square is plotted as
-           the maximum of `cmap` for the positive real part and as
-           the minimum for the negative part of the matrix element;
-           note that this generalizes `"threshold"` to complex numbers.
-        -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not a quantum object.
-
-    Examples
-    --------
-    >>> import qutip
-    >>>
-    >>> dm = qutip.rand_dm(4)
-    >>> fig, ax = qutip.hinton(dm)
-    >>> fig.show()
-    >>>
-    >>> qutip.settings.colorblind_safe = True
-    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
-    >>> fig.show()
-    >>> qutip.settings.colorblind_safe = False
-    >>>
-    >>> fig, ax = qutip.hinton(dm, color_style="phase")
-    >>> fig.show()
-    """
-
-    # Apply default colormaps.
-    # TODO: abstract this away into something that makes default
-    #       colormaps.
-
-    cmap = (
-        (cm.Greys_r if settings.colorblind_safe else cm.RdBu)
-        if cmap is None else cmap
-    )
-
-    # Extract plotting data W from the input.
-    if isinstance(rho, Qobj):
-        if rho.isoper:
-            W = rho.full()
-
-            # Create default labels if none are given.
-            if xlabels is None or ylabels is None:
-                labels = _cb_labels(rho.dims[0])
-                xlabels = xlabels if xlabels is not None else list(labels[0])
-                ylabels = ylabels if ylabels is not None else list(labels[1])
 
-        elif rho.isoperket:
-            W = vector_to_operator(rho).full()
-        elif rho.isoperbra:
-            W = vector_to_operator(rho.dag()).full()
-        elif rho.issuper:
-            if not isqubitdims(rho.dims):
-                raise ValueError("Hinton plots of superoperators are "
-                                 "currently only supported for qubits.")
-            # Convert to a superoperator in the Pauli basis,
-            # so that all the elements are real.
-            sqobj = _to_superpauli(rho)
-            nq = int(log2(sqobj.shape[0]) / 2)
-            W = sqobj.full().T
-            # Create default labels, too.
-            if (xlabels is None) or (ylabels is None):
-                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                xlabels = xlabels if xlabels is not None else labels
-                ylabels = ylabels if ylabels is not None else labels
-
-        else:
-            raise ValueError(
-                "Input quantum object must be an operator or superoperator."
-            )
-
-    else:
-        W = rho
-
-    if ax is None:
-        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
-    else:
-        fig = None
-
-    if not (xlabels or ylabels):
-        ax.axis('off')
-    if title:
-        ax.set_title(title)
-
-    ax.axis('equal')
-    ax.set_frame_on(False)
-
-    height, width = W.shape
-
-    w_max = 1.25 * max(abs(np.array(W)).flatten())
-    if w_max <= 0.0:
-        w_max = 1.0
-
-    # Set color_fn here.
-    if color_style == "scaled":
-        def color_fn(w):
-            w = np.abs(w) * np.sign(np.real(w))
-            return cmap(int((w + w_max) * 256 / (2 * w_max)))
-    elif color_style == "threshold":
-        def color_fn(w):
-            w = np.real(w)
-            return cmap(255 if w > 0 else 0)
-    elif color_style == "phase":
-        def color_fn(w):
-            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
-    else:
-        raise ValueError(
-            "Unknown color style {} for Hinton diagrams.".format(color_style)
-        )
-
-    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
-            color=cmap(128))
-    for x in range(width):
-        for y in range(height):
-            _x = x + 1
-            _y = y + 1
-            _blob(
-                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
-                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
-
-    # color axis
-    vmax = np.pi if color_style == "phase" else abs(W).max()
-    norm = mpl.colors.Normalize(-vmax, vmax)
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-    mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-
-    xtics = 0.5 + np.arange(width)
-    # x axis
-    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-        if label_top:
-            ax.xaxis.tick_top()
-    ax.tick_params(axis='x', labelsize=14)
-
-    # y axis
-    ytics = 0.5 + np.arange(height)
-    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(list(reversed(ylabels)))
-    ax.tick_params(axis='y', labelsize=14)
-
-    return fig, ax
-
-
-def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
+def sphereplot(theta, phi, values, fig=None, ax=None):
     """Plots a matrix of values on a sphere
 
     Parameters
@@ -621,9 +435,6 @@ def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
     # add our colorbar label
     cb1.set_label('Angle')
 
-    if save:
-        plt.savefig("sphereplot.png")
-
     return fig, ax
 
 
@@ -927,10 +738,8 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     return fig, ax
 
 
-def matrix_histogram_complex(M, xlabels=None, ylabels=None,
-                             title=None, limits=None, phase_limits=None,
-                             colorbar=True, fig=None, ax=None,
-                             threshold=None):
+def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None, colorbar=True,
+                            phase_limits=None, threshold=None, figure=None, axes=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -941,31 +750,34 @@ def matrix_histogram_complex(M, xlabels=None, ylabels=None,
     M : Matrix of Qobj
         The matrix to visualize
 
-    xlabels : list of strings
-        list of x labels
+    xticklabels : list of strings
+        list of x ticklabels
 
-    ylabels : list of strings
-        list of y labels
+    yticklabels : list of strings
+        list of y ticklabels
 
-    title : string
-        title of the plot (optional)
+    cmap : a matplotlib colormap instance
+        Color map to use when plotting.
 
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached.
 
     phase_limits : list/array with two float numbers
         The phase-axis (colorbar) limits [min, max] (optional)
 
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
     threshold: float (None)
         Threshold for when bars of smaller height should be transparent. If
         not set, all bars are colored according to the color map.
 
+    axes : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    figure : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
     Returns
     -------
-    fig, ax : tuple
+    figure, axes : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
 
@@ -1001,62 +813,58 @@ def matrix_histogram_complex(M, xlabels=None, ylabels=None,
         phase_max = pi
 
     norm = mpl.colors.Normalize(phase_min, phase_max)
-    cmap = complex_phase_cmap()
+
+    if cmap is None:
+        cmap = _cyclic_cmap()
 
     colors = cmap(norm(angle(Mvec)))
     if threshold is not None:
         colors[:, 3] = 1 * (dz > threshold)
 
-    if ax is None:
-        fig = plt.figure()
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
+    if axes is None:
+        figure = plt.figure()
+        axes = _axes3D(figure, azim=-35, elev=35)
 
-    if title:
-        ax.set_title(title)
+    axes.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
 
     # x axis
     xtics = -0.5 + np.arange(M.shape[0])
-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
-    if xlabels:
-        nxlabels = len(xlabels)
-        if nxlabels != len(xtics):
-            raise ValueError(f"got {nxlabels} xlabels but needed {len(xtics)}")
-        ax.set_xticklabels(xlabels)
-    ax.tick_params(axis='x', labelsize=12)
+    axes.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+    if xticklabels:
+        nxticklabels = len(xticklabels)
+        if nxticklabels != len(xtics):
+            raise ValueError(f"got {nxticklabels} xticklabels but needed {len(xtics)}")
+        axes.set_xticklabels(xticklabels)
+        axes.tick_params(axis='x', labelsize=12)
+    else:
+        axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
 
     # y axis
     ytics = -0.5 + np.arange(M.shape[1])
-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
-    if ylabels:
-        nylabels = len(ylabels)
-        if nylabels != len(ytics):
-            raise ValueError(f"got {nylabels} ylabels but needed {len(ytics)}")
-        ax.set_yticklabels(ylabels)
-    ax.tick_params(axis='y', labelsize=12)
-
-    # z axis
-    if limits and isinstance(limits, list):
-        ax.set_zlim3d(limits)
+    axes.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+    if yticklabels:
+        nyticklabels = len(yticklabels)
+        if nyticklabels != len(ytics):
+            raise ValueError(f"got {nyticklabels} yticklabels but needed {len(ytics)}")
+        axes.set_yticklabels(yticklabels)
+        axes.tick_params(axis='y', labelsize=12)
     else:
-        ax.set_zlim3d([0, 1])  # use min/max
-    # ax.set_zlabel('abs')
+        axes.tick_params(axis='y', which='both', left=False, labelleft=False)
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
+        cax, kw = mpl.colorbar.make_axes(axes, shrink=.75, pad=.0)
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
         cb.set_ticklabels(
             (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
         cb.set_label('arg')
 
-    return fig, ax
+    return figure, axes
 
 
-def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
-                       figsize=(8, 12), fig=None, ax=None):
+def plot_energy_levels(H_list, xticklabels=None, yticklabels=None, N=0,
+                        figure=None, axes=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
     up to N energy levels. For each element in H_list, the energy
@@ -1069,28 +877,25 @@ def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
         H_list : List of Qobj
             A list of Hamiltonians.
 
-        labels : List of string
-            A list of labels for each Hamiltonian
+        xticklabels : List of string
+            A list of xticklabels for each Hamiltonian
 
-        show_ylabels : Bool (default False)
-            Show y labels to the left of energy levels of the initial
+        yticklabels : List of string
+            A list of  yticklabels to the left of energy levels of the initial
             Hamiltonian.
 
         N : int
             The number of energy levels to plot
 
-        figsize : tuple (int,int)
-            The size of the figure (width, height).
-
-        fig : a matplotlib Figure instance
+        figure : a matplotlib Figure instance
             The Figure canvas in which the plot will be drawn.
 
-        ax : a matplotlib axes instance
+        axes : a matplotlib axes instance
             The axes context in which the plot will be drawn.
 
     Returns
     -------
-    fig, ax : tuple
+    figure, axes : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
 
@@ -1105,8 +910,14 @@ def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
     if not isinstance(H_list, list):
         raise ValueError("H_list must be a list of Qobj instances")
 
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+    if figure is None:
+        if axes is None:
+            figure, axes = plt.subplots(1, 1)
+        else:
+            figure = axes.get_figure()
+    else:
+        if axes is None:
+            axes = figure.add_subplots(1, 1)
 
     H = H_list[0]
     N = H.shape[0] if N == 0 else min(H.shape[0], N)
@@ -1117,7 +928,7 @@ def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
     x = 0
     evals0 = H.eigenenergies(eigvals=N)
     for e_idx, e in enumerate(evals0[:N]):
-        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+        axes.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
         yticks.append(e)
     xticks.append(x + 1)
     x += 2
@@ -1128,32 +939,34 @@ def plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False,
         evals1 = H.eigenenergies()
 
         for e_idx, e in enumerate(evals1[:N]):
-            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
+            axes.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
         x += 1
 
         for e_idx, e in enumerate(evals1[:N]):
-            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+            axes.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
         xticks.append(x + 1)
         x += 2
 
         evals0 = evals1
 
-    ax.set_frame_on(False)
+    axes.set_frame_on(False)
 
-    if show_ylabels:
+    if yticklabels:
         yticks = np.unique(np.around(yticks, 1))
-        ax.set_yticks(yticks)
+        axes.set_yticks(yticks)
+        axes.set_yticklabels(yticklabels)
     else:
-        ax.axes.get_yaxis().set_visible(False)
+        yticks = np.unique(np.around(yticks, 1))
+        axes.set_yticks(yticks)
 
-    if labels:
-        ax.get_xaxis().tick_bottom()
-        ax.set_xticks(xticks)
-        ax.set_xticklabels(labels, fontsize=16)
+    if xticklabels:
+        axes.get_xaxis().tick_bottom()
+        axes.set_xticks(xticks)
+        axes.set_xticklabels(xticklabels, fontsize=16)
     else:
-        ax.axes.get_xaxis().set_visible(False)
+        axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
 
-    return fig, ax
+    return figure, axes
 
 
 def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,

From b53202436f3c32260eeb627c8fe10df3bd47ff85 Mon Sep 17 00:00:00 2001
From: Andrey Rakhubovsky <rkhbvs@gmail.com>
Date: Mon, 12 Jun 2023 14:45:32 +0200
Subject: [PATCH 421/602] Capitalize Monte Carlo

---
 doc/guide/dynamics/dynamics-bloch-redfield.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-bloch-redfield.rst b/doc/guide/dynamics/dynamics-bloch-redfield.rst
index 2c705e65f1..ceaf9a997c 100644
--- a/doc/guide/dynamics/dynamics-bloch-redfield.rst
+++ b/doc/guide/dynamics/dynamics-bloch-redfield.rst
@@ -19,7 +19,7 @@ Bloch-Redfield master equation
 Introduction
 ============
 
-The Lindblad master equation introduced earlier is constructed so that it describes a physical evolution of the density matrix (i.e., trace and positivity preserving), but it does not provide a connection to any underlaying microscopic physical model.
+The Lindblad master equation introduced earlier is constructed so that it describes a physical evolution of the density matrix (i.e., trace and positivity preserving), but it does not provide a connection to any underlying microscopic physical model.
 The Lindblad operators (collapse operators) describe phenomenological processes, such as for example dephasing and spin flips, and the rates of these processes are arbitrary parameters in the model.
 In many situations the collapse operators and their corresponding rates have clear physical interpretation, such as dephasing and relaxation rates, and in those cases the Lindblad master equation is usually the method of choice.
 
@@ -310,7 +310,7 @@ Fortunately, this eigen decomposition occurs at the Hamiltonian level, as oppose
 For time-dependent Hamiltonians, the Hamiltonian itself can be passed into the solver like any other time dependent Hamiltonian, as thus we will not discuss this topic further.
 Instead, here the focus is on time-dependent bath coupling terms.
 To this end, suppose that we have a dissipative harmonic oscillator, where the white-noise dissipation rate decreases exponentially with time :math:`\kappa(t) = \kappa(0)\exp(-t)`.
-In the Lindblad or monte-carlo solvers, this could be implemented as a time-dependent collapse operator list ``c_ops = [[a, 'sqrt(kappa*exp(-t))']]``.
+In the Lindblad or Monte Carlo solvers, this could be implemented as a time-dependent collapse operator list ``c_ops = [[a, 'sqrt(kappa*exp(-t))']]``.
 In the Bloch-Redfield solver, the bath coupling terms must be Hermitian.
 As such, in this example, our coupling operator is the position operator ``a+a.dag()``.
 The complete example, and comparison to the analytic expression is:
@@ -407,4 +407,4 @@ Further examples on time-dependent Bloch-Redfield simulations can be found in th
 .. plot::
     :context: reset
     :include-source: false
-    :nofigs:
\ No newline at end of file
+    :nofigs:

From fef91292c273d85262d7fb50db1e4c7fb720ec04 Mon Sep 17 00:00:00 2001
From: Andrey Rakhubovsky <rkhbvs@gmail.com>
Date: Mon, 12 Jun 2023 15:36:31 +0200
Subject: [PATCH 422/602] Add towncrier entry

---
 doc/changes/2174.doc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2174.doc

diff --git a/doc/changes/2174.doc b/doc/changes/2174.doc
new file mode 100644
index 0000000000..59e59da319
--- /dev/null
+++ b/doc/changes/2174.doc
@@ -0,0 +1 @@
+Correct grammar in Bloch-Redfield master equation documentation

From b85d5fac0a7f61233961297a55a33e4fa3d13c70 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 16 Jun 2023 19:32:52 +0900
Subject: [PATCH 423/602] finish hinton, matrix_histogram_complex and
 plot_energy_levels

---
 qutip/visualization.py | 205 ++++++++++++++++++-----------------------
 1 file changed, 90 insertions(+), 115 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 842cbc9e83..0a37117446 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -48,7 +48,7 @@ def _axes3D(*args, **kwargs):
 
 def _cmap():
     if settings.colorblind_safe:
-        return cm.Greys_r
+        return cm.cividis
     else:
         return cm.RdBu
 
@@ -58,6 +58,37 @@ def _cyclic_cmap():
     else:
         return complex_phase_cmap()
 
+def _is_figure_and_axes(figure, axes, projection='2d'):
+    if figure is None:
+        if axes is None:
+            figure = plt.sigure()
+            if projection == '2d':
+                axes = figure.add_subplot(1, 1, 1)
+            else:
+                axes = _axes3D(figure)
+        else:
+            figure = axes.get_figure()
+    else:
+        if axes is None:
+            if projection == '2d':
+                axes = figure.add_subplot(1, 1, 1)
+            else:
+                axes = _axes3D(figure)
+
+    return figure, axes
+
+def _set_xticklabels(axes, xticklabels, xticks):
+    if len(xticks) != len(xticklabels):
+        raise ValueError(f"got {len(xticklabels)} xticklabels but needed {len(xticks)}")
+    axes.set_xticks(xticks)
+    axes.set_xticklabels(xticklabels, fontsize=14)
+
+def _set_yticklabels(axes, yticklabels, yticks):
+    if len(yticks) != len(yticklabels):
+        raise ValueError(f"got {len(yticklabels)} yticklabels but needed {len(yticks)}")
+    axes.set_yticks(yticks)
+    axes.set_yticklabels(yticklabels, fontsize=14)
+
 def plot_wigner_sphere(fig, ax, wigner, reflections):
     """Plots a coloured Bloch sphere.
 
@@ -183,8 +214,8 @@ def _cb_labels(left_dims):
 
 
 # Adopted from the SciPy Cookbook.
-def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True,
-           color_style="scaled", label_top=True, figure = None, axes = None):
+def hinton(rho, color_style="scaled", label_top=True, *,
+           xticklabels=None, yticklabels=None, cmap = None, colorbar = True, figure = None, axes = None):
     """Draws a Hinton diagram for visualizing a density matrix or superoperator.
 
     Parameters
@@ -193,18 +224,6 @@ def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True
         Input density matrix or superoperator.
         NOTE: Hinton plots of superoperators are currently only supported for qubits.
 
-    xticklabels : list of strings or False
-        list of x ticklabels
-
-    yticklabels : list of strings or False
-        list of y ticklabels
-
-    cmap : a matplotlib colormap instance
-        Color map to use when plotting.
-
-    colorbar : bool
-        Whether (True) or not (False) a colorbar should be attached.
-
     color_style : string
         Determines how colors are assigned to each square:
 
@@ -222,18 +241,24 @@ def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True
         If True, x ticklabels will be placed on top, otherwise
         they will appear below the plot.
 
+    xticklabels : list of strings or False
+        list of x ticklabels
+
+    yticklabels : list of strings or False
+        list of y ticklabels
+
+    cmap : a matplotlib colormap instance
+        Color map to use when plotting.
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached.
+
     figure : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
-    figure_options : dict
-        dict of options to create a figure object
-
     axes : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
-    axes_options : dict
-        dict of options to set to an axes object
-
     Returns
     -------
     fig, ax : tuple
@@ -262,14 +287,7 @@ def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True
     >>> fig.show()
     """
 
-    if figure is None:
-        if axes is None:
-            figure, axes = plt.subplots(1, 1)
-        else:
-            figure = axes.get_figure()
-    else:
-        if axes is None:
-            axes = figure.add_subplots(1, 1)
+    figure, axes = _is_figure_and_axes(figure, axes)
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):
@@ -279,7 +297,6 @@ def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True
             elif rho.isoperbra:
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
-
             # Create default labels if none are given.
             if xticklabels is None or yticklabels is None:
                 labels = _cb_labels(rho.dims[0])
@@ -308,12 +325,6 @@ def hinton(rho, xticklabels=None, yticklabels=None, cmap = None, colorbar = True
     else:
         W = rho
 
-    if not (xticklabels or yticklabels):
-        axes.axis('off')
-
-    axes.axis('equal')
-    axes.set_frame_on(False)
-
     height, width = W.shape
 
     w_max = 1.25 * max(abs(np.array(W)).flatten())
@@ -355,27 +366,23 @@ def color_fn(w):
         cax, kw = mpl.colorbar.make_axes(axes, shrink=0.75, pad=.1)
         mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
+    # axis
+    if not (xticklabels or yticklabels):
+        axes.axis('off')
+    axes.axis('equal')
+    axes.set_frame_on(False)
+
     # x axis
-    xtics = 0.5 + np.arange(width)
-    axes.xaxis.set_major_locator(plt.FixedLocator(xtics))
+    xticks = 0.5 + np.arange(width)
     if xticklabels:
-        nxticklabels = len(xticklabels)
-        if nxticklabels != len(xtics):
-            raise ValueError(f"got {nxticklabels} xticklabels but needed {len(xtics)}")
-        axes.set_xticklabels(xticklabels)
-        if label_top:
-            axes.xaxis.tick_top()
-    axes.tick_params(axis='x', labelsize=14)
+        _set_xticklabels(axes, xticklabels, xticks)
+    if label_top:
+        axes.xaxis.tick_top()
 
     # y axis
-    ytics = 0.5 + np.arange(height)
-    axes.yaxis.set_major_locator(plt.FixedLocator(ytics))
+    yticks = 0.5 + np.arange(height)
     if yticklabels:
-        nyticklabels = len(yticklabels)
-        if nyticklabels != len(ytics):
-            raise ValueError(f"got {nyticklabels} yticklabels but needed {len(ytics)}")
-        axes.set_yticklabels(list(reversed(yticklabels)))
-    axes.tick_params(axis='y', labelsize=14)
+        _set_yticklabels(axes, yticklabels, yticks)
 
     return figure, axes
 
@@ -533,7 +540,7 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
+def matrix_histogram(M, xlabels=None, ylabels=None,
                      colorbar=True, fig=None, ax=None, options=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
@@ -549,12 +556,6 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     ylabels : list of strings
         list of y labels
 
-    title : string
-        title of the plot (optional)
-
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
-
     ax : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
@@ -672,15 +673,11 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
     dz = np.real(M.flatten())
 
-    if isinstance(limits, list) and len(limits) == 2:
-        z_min = limits[0]
-        z_max = limits[1]
-    else:
-        z_min = min(dz)
-        z_max = max(dz)
-        if z_min == z_max:
-            z_min -= 0.1
-            z_max += 0.1
+    z_min = min(dz)
+    z_max = max(dz)
+    if z_min == z_max:
+        z_min -= 0.1
+        z_max += 0.1
 
     if default_opts['cbar_to_z']:
         norm = mpl.colors.Normalize(min(dz), max(dz))
@@ -707,9 +704,6 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
 
-    if title:
-        ax.set_title(title)
-
     # x axis
     _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
 
@@ -738,8 +732,8 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     return fig, ax
 
 
-def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None, colorbar=True,
-                            phase_limits=None, threshold=None, figure=None, axes=None):
+def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
+                             xticklabels=None, yticklabels=None, cmap = None, colorbar=True, figure=None, axes=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -750,6 +744,13 @@ def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None,
     M : Matrix of Qobj
         The matrix to visualize
 
+    phase_limits : list/array with two float numbers
+        The phase-axis (colorbar) limits [min, max] (optional)
+
+    threshold: float (None)
+        Threshold for when bars of smaller height should be transparent. If
+        not set, all bars are colored according to the color map.
+
     xticklabels : list of strings
         list of x ticklabels
 
@@ -762,13 +763,6 @@ def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None,
     colorbar : bool
         Whether (True) or not (False) a colorbar should be attached.
 
-    phase_limits : list/array with two float numbers
-        The phase-axis (colorbar) limits [min, max] (optional)
-
-    threshold: float (None)
-        Threshold for when bars of smaller height should be transparent. If
-        not set, all bars are colored according to the color map.
-
     axes : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
@@ -787,6 +781,9 @@ def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None,
         Input argument is not valid.
 
     """
+    figure, axes = _is_figure_and_axes(figure, axes, projection='3d')
+    #set angle
+    axes.view_init(azim=-35, elev=35)
 
     if isinstance(M, Qobj):
         # extract matrix data from Qobj
@@ -821,33 +818,19 @@ def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None,
     if threshold is not None:
         colors[:, 3] = 1 * (dz > threshold)
 
-    if axes is None:
-        figure = plt.figure()
-        axes = _axes3D(figure, azim=-35, elev=35)
-
     axes.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
 
     # x axis
     xtics = -0.5 + np.arange(M.shape[0])
-    axes.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
     if xticklabels:
-        nxticklabels = len(xticklabels)
-        if nxticklabels != len(xtics):
-            raise ValueError(f"got {nxticklabels} xticklabels but needed {len(xtics)}")
-        axes.set_xticklabels(xticklabels)
-        axes.tick_params(axis='x', labelsize=12)
+        _set_xticklabels(axes, xticklabels, xtics)
     else:
         axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
 
     # y axis
     ytics = -0.5 + np.arange(M.shape[1])
-    axes.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
     if yticklabels:
-        nyticklabels = len(yticklabels)
-        if nyticklabels != len(ytics):
-            raise ValueError(f"got {nyticklabels} yticklabels but needed {len(ytics)}")
-        axes.set_yticklabels(yticklabels)
-        axes.tick_params(axis='y', labelsize=12)
+        _set_xticklabels(axes, yticklabels, ytics)
     else:
         axes.tick_params(axis='y', which='both', left=False, labelleft=False)
 
@@ -863,7 +846,7 @@ def matrix_histogram_complex(M, xticklabels=None, yticklabels=None, cmap = None,
     return figure, axes
 
 
-def plot_energy_levels(H_list, xticklabels=None, yticklabels=None, N=0,
+def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
                         figure=None, axes=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
@@ -877,6 +860,9 @@ def plot_energy_levels(H_list, xticklabels=None, yticklabels=None, N=0,
         H_list : List of Qobj
             A list of Hamiltonians.
 
+        N : int
+            The number of energy levels to plot
+
         xticklabels : List of string
             A list of xticklabels for each Hamiltonian
 
@@ -884,9 +870,6 @@ def plot_energy_levels(H_list, xticklabels=None, yticklabels=None, N=0,
             A list of  yticklabels to the left of energy levels of the initial
             Hamiltonian.
 
-        N : int
-            The number of energy levels to plot
-
         figure : a matplotlib Figure instance
             The Figure canvas in which the plot will be drawn.
 
@@ -907,18 +890,12 @@ def plot_energy_levels(H_list, xticklabels=None, yticklabels=None, N=0,
 
     """
 
+    figure, axes = _is_figure_and_axes(figure, axes)
+    axes.set_frame_on(False)
+
     if not isinstance(H_list, list):
         raise ValueError("H_list must be a list of Qobj instances")
 
-    if figure is None:
-        if axes is None:
-            figure, axes = plt.subplots(1, 1)
-        else:
-            figure = axes.get_figure()
-    else:
-        if axes is None:
-            axes = figure.add_subplots(1, 1)
-
     H = H_list[0]
     N = H.shape[0] if N == 0 else min(H.shape[0], N)
 
@@ -949,21 +926,19 @@ def plot_energy_levels(H_list, xticklabels=None, yticklabels=None, N=0,
 
         evals0 = evals1
 
-    axes.set_frame_on(False)
-
     if yticklabels:
         yticks = np.unique(np.around(yticks, 1))
-        axes.set_yticks(yticks)
-        axes.set_yticklabels(yticklabels)
+        _set_yticklabels(axes, yticklabels, yticks)
     else:
+        #show eigenenergies
         yticks = np.unique(np.around(yticks, 1))
         axes.set_yticks(yticks)
 
     if xticklabels:
         axes.get_xaxis().tick_bottom()
-        axes.set_xticks(xticks)
-        axes.set_xticklabels(xticklabels, fontsize=16)
+        _set_yticklabels(axes, xticklabels, xticks)
     else:
+        #hide xtick
         axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
 
     return figure, axes

From e60820e96acd73ce09dbeec9f9ba74b19f67bfde Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 16 Jun 2023 19:57:07 +0900
Subject: [PATCH 424/602] follow pep8

---
 qutip/visualization.py | 57 ++++++++++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 19 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 0a37117446..17bca2b6c6 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -46,18 +46,21 @@ def _axes3D(*args, **kwargs):
 except:
     pass
 
+
 def _cmap():
     if settings.colorblind_safe:
         return cm.cividis
     else:
         return cm.RdBu
 
+
 def _cyclic_cmap():
     if settings.colorblind_safe:
         return cm.twilight
     else:
         return complex_phase_cmap()
 
+
 def _is_figure_and_axes(figure, axes, projection='2d'):
     if figure is None:
         if axes is None:
@@ -77,18 +80,25 @@ def _is_figure_and_axes(figure, axes, projection='2d'):
 
     return figure, axes
 
+
 def _set_xticklabels(axes, xticklabels, xticks):
     if len(xticks) != len(xticklabels):
-        raise ValueError(f"got {len(xticklabels)} xticklabels but needed {len(xticks)}")
+        raise ValueError(
+            f"got {len(xticklabels)} xticklabels but needed {len(xticks)}"
+            )
     axes.set_xticks(xticks)
     axes.set_xticklabels(xticklabels, fontsize=14)
 
+
 def _set_yticklabels(axes, yticklabels, yticks):
     if len(yticks) != len(yticklabels):
-        raise ValueError(f"got {len(yticklabels)} yticklabels but needed {len(yticks)}")
+        raise ValueError(
+            f"got {len(yticklabels)} yticklabels but needed {len(yticks)}"
+            )
     axes.set_yticks(yticks)
     axes.set_yticklabels(yticklabels, fontsize=14)
 
+
 def plot_wigner_sphere(fig, ax, wigner, reflections):
     """Plots a coloured Bloch sphere.
 
@@ -215,14 +225,16 @@ def _cb_labels(left_dims):
 
 # Adopted from the SciPy Cookbook.
 def hinton(rho, color_style="scaled", label_top=True, *,
-           xticklabels=None, yticklabels=None, cmap = None, colorbar = True, figure = None, axes = None):
+           xticklabels=None, yticklabels=None, cmap=None, colorbar=True,
+           figure=None, axes=None):
     """Draws a Hinton diagram for visualizing a density matrix or superoperator.
 
     Parameters
     ----------
     rho : qobj
         Input density matrix or superoperator.
-        NOTE: Hinton plots of superoperators are currently only supported for qubits.
+        NOTE: Hinton plots of superoperators are
+        currently only supported for qubits.
 
     color_style : string
         Determines how colors are assigned to each square:
@@ -293,15 +305,17 @@ def hinton(rho, color_style="scaled", label_top=True, *,
     if isinstance(rho, Qobj):
         if rho.isoper or rho.isoperket or rho.isoperbra:
             if rho.isoperket:
-                rho =  vector_to_operator(rho)
+                rho = vector_to_operator(rho)
             elif rho.isoperbra:
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
             # Create default labels if none are given.
             if xticklabels is None or yticklabels is None:
                 labels = _cb_labels(rho.dims[0])
-                xticklabels = xticklabels if xticklabels is not None else list(labels[0])
-                yticklabels = yticklabels if yticklabels is not None else list(labels[1])
+                if xticklabels is None:
+                    xticklabels = list(labels[0])
+                if yticklabels is None:
+                    yticklabels = list(labels[1])
 
         elif rho.issuper:
             if not isqubitdims(rho.dims):
@@ -315,8 +329,10 @@ def hinton(rho, color_style="scaled", label_top=True, *,
             # Create default labels, too.
             if (xticklabels is None) or (yticklabels is None):
                 labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                xticklabels = xticklabels if xticklabels is not None else labels
-                yticklabels = yticklabels if yticklabels is not None else labels
+                if xticklabels is None:
+                    xticklabels = labels
+                if yticklabels is None:
+                    yticklabels = labels
 
         else:
             raise ValueError(
@@ -733,7 +749,8 @@ def matrix_histogram(M, xlabels=None, ylabels=None,
 
 
 def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
-                             xticklabels=None, yticklabels=None, cmap = None, colorbar=True, figure=None, axes=None):
+                             xticklabels=None, yticklabels=None, cmap=None,
+                             colorbar=True, figure=None, axes=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -782,7 +799,7 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
 
     """
     figure, axes = _is_figure_and_axes(figure, axes, projection='3d')
-    #set angle
+    # set angle
     axes.view_init(azim=-35, elev=35)
 
     if isinstance(M, Qobj):
@@ -825,7 +842,8 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     if xticklabels:
         _set_xticklabels(axes, xticklabels, xtics)
     else:
-        axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
+        axes.tick_params(axis='x', which='both',
+                         bottom=False, labelbottom=False)
 
     # y axis
     ytics = -0.5 + np.arange(M.shape[1])
@@ -847,7 +865,7 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
 
 
 def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
-                        figure=None, axes=None):
+                       figure=None, axes=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
     up to N energy levels. For each element in H_list, the energy
@@ -930,7 +948,7 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
         yticks = np.unique(np.around(yticks, 1))
         _set_yticklabels(axes, yticklabels, yticks)
     else:
-        #show eigenenergies
+        # show eigenenergies
         yticks = np.unique(np.around(yticks, 1))
         axes.set_yticks(yticks)
 
@@ -938,8 +956,9 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
         axes.get_xaxis().tick_bottom()
         _set_yticklabels(axes, xticklabels, xticks)
     else:
-        #hide xtick
-        axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
+        # hide xtick
+        axes.tick_params(axis='x', which='both',
+                         bottom=False, labelbottom=False)
 
     return figure, axes
 
@@ -1253,7 +1272,7 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
 
 
 def plot_spin_distribution(P, THETA, PHI,
-                           fig=None, ax=None, figsize=(8,6),projection='2d'):
+                           fig=None, ax=None, figsize=(8,6), projection='2d'):
     """
     Plots a spin distribution (given as meshgrid data).
 
@@ -1280,8 +1299,8 @@ def plot_spin_distribution(P, THETA, PHI,
 
     projection: string {'2d', '3d'}
         Specify whether the spin distribution function is to be plotted as a 2D
-        projection where the surface of the unit sphere is mapped on the unit disk ('2d')
-        or surface plot ('3d').
+        projection where the surface of the unit sphere is mapped on
+        the unit disk ('2d') or surface plot ('3d').
 
     Returns
     -------

From 8fbd9f9cbdfe502b89d6f063e132a4d2284b928d Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 16 Jun 2023 20:18:21 +0900
Subject: [PATCH 425/602] follow pep8

---
 qutip/visualization.py | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 17bca2b6c6..8daeccbfb8 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -864,8 +864,7 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     return figure, axes
 
 
-def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
-                       figure=None, axes=None):
+def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None, figure=None, axes=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
     up to N energy levels. For each element in H_list, the energy
@@ -948,7 +947,7 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
         yticks = np.unique(np.around(yticks, 1))
         _set_yticklabels(axes, yticklabels, yticks)
     else:
-        # show eigenenergies
+        #show eigenenergies
         yticks = np.unique(np.around(yticks, 1))
         axes.set_yticks(yticks)
 
@@ -956,9 +955,8 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
         axes.get_xaxis().tick_bottom()
         _set_yticklabels(axes, xticklabels, xticks)
     else:
-        # hide xtick
-        axes.tick_params(axis='x', which='both',
-                         bottom=False, labelbottom=False)
+        #hide xtick
+        axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
 
     return figure, axes
 
@@ -1272,7 +1270,7 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
 
 
 def plot_spin_distribution(P, THETA, PHI,
-                           fig=None, ax=None, figsize=(8,6), projection='2d'):
+                           fig=None, ax=None, figsize=(8,6),projection='2d'):
     """
     Plots a spin distribution (given as meshgrid data).
 
@@ -1299,8 +1297,8 @@ def plot_spin_distribution(P, THETA, PHI,
 
     projection: string {'2d', '3d'}
         Specify whether the spin distribution function is to be plotted as a 2D
-        projection where the surface of the unit sphere is mapped on
-        the unit disk ('2d') or surface plot ('3d').
+        projection where the surface of the unit sphere is mapped on the unit disk ('2d')
+        or surface plot ('3d').
 
     Returns
     -------

From cd40c75cbde3d3dafce0b26e3c947f42b25c7e84 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 16 Jun 2023 20:21:36 +0900
Subject: [PATCH 426/602] bug fix

---
 qutip/visualization.py | 57 +++++++++++++++++++++---------------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 8daeccbfb8..298078b9fc 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -64,7 +64,7 @@ def _cyclic_cmap():
 def _is_figure_and_axes(figure, axes, projection='2d'):
     if figure is None:
         if axes is None:
-            figure = plt.sigure()
+            figure = plt.figure()
             if projection == '2d':
                 axes = figure.add_subplot(1, 1, 1)
             else:
@@ -81,22 +81,21 @@ def _is_figure_and_axes(figure, axes, projection='2d'):
     return figure, axes
 
 
-def _set_xticklabels(axes, xticklabels, xticks):
-    if len(xticks) != len(xticklabels):
+def _set_ticklabels(axes, ticklabels, ticks, axis):
+    if len(ticks) != len(ticklabels):
         raise ValueError(
-            f"got {len(xticklabels)} xticklabels but needed {len(xticks)}"
+            f"got {len(ticklabels)} ticklabels but needed {len(ticks)}"
             )
-    axes.set_xticks(xticks)
-    axes.set_xticklabels(xticklabels, fontsize=14)
-
-
-def _set_yticklabels(axes, yticklabels, yticks):
-    if len(yticks) != len(yticklabels):
+    if axis == 'x':
+        axes.set_xticks(ticks)
+        axes.set_xticklabels(ticklabels, fontsize=14)
+    elif axis == 'y':
+        axes.set_yticks(ticks)
+        axes.set_yticklabels(ticklabels, fontsize=14)
+    else:
         raise ValueError(
-            f"got {len(yticklabels)} yticklabels but needed {len(yticks)}"
+            "axis must be either 'x' or 'y'"
             )
-    axes.set_yticks(yticks)
-    axes.set_yticklabels(yticklabels, fontsize=14)
 
 
 def plot_wigner_sphere(fig, ax, wigner, reflections):
@@ -391,14 +390,14 @@ def color_fn(w):
     # x axis
     xticks = 0.5 + np.arange(width)
     if xticklabels:
-        _set_xticklabels(axes, xticklabels, xticks)
+        _set_ticklabels(axes, xticklabels, xticks, 'x')
     if label_top:
         axes.xaxis.tick_top()
 
     # y axis
     yticks = 0.5 + np.arange(height)
     if yticklabels:
-        _set_yticklabels(axes, yticklabels, yticks)
+        _set_ticklabels(axes, list(reversed(yticklabels)), yticks, 'y')
 
     return figure, axes
 
@@ -838,17 +837,17 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     axes.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
 
     # x axis
-    xtics = -0.5 + np.arange(M.shape[0])
+    xticks = -0.5 + np.arange(M.shape[0])
     if xticklabels:
-        _set_xticklabels(axes, xticklabels, xtics)
+        _set_ticklabels(axes, xticklabels, xticks, 'x')
     else:
         axes.tick_params(axis='x', which='both',
                          bottom=False, labelbottom=False)
 
     # y axis
-    ytics = -0.5 + np.arange(M.shape[1])
+    yticks = -0.5 + np.arange(M.shape[1])
     if yticklabels:
-        _set_xticklabels(axes, yticklabels, ytics)
+        _set_ticklabels(axes, yticklabels, yticks, 'y')
     else:
         axes.tick_params(axis='y', which='both', left=False, labelleft=False)
 
@@ -864,7 +863,8 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     return figure, axes
 
 
-def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None, figure=None, axes=None):
+def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
+                       figure=None, axes=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
     up to N energy levels. For each element in H_list, the energy
@@ -945,18 +945,19 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None, figur
 
     if yticklabels:
         yticks = np.unique(np.around(yticks, 1))
-        _set_yticklabels(axes, yticklabels, yticks)
+        _set_ticklabels(axes, yticklabels, yticks, 'y')
     else:
-        #show eigenenergies
+        # show eigenenergies
         yticks = np.unique(np.around(yticks, 1))
         axes.set_yticks(yticks)
 
     if xticklabels:
         axes.get_xaxis().tick_bottom()
-        _set_yticklabels(axes, xticklabels, xticks)
+        _set_ticklabels(axes, xticklabels, xticks, 'x')
     else:
-        #hide xtick
-        axes.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
+        # hide xtick
+        axes.tick_params(axis='x', which='both',
+                         bottom=False, labelbottom=False)
 
     return figure, axes
 
@@ -1270,7 +1271,7 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
 
 
 def plot_spin_distribution(P, THETA, PHI,
-                           fig=None, ax=None, figsize=(8,6),projection='2d'):
+                           fig=None, ax=None, figsize=(8, 6), projection='2d'):
     """
     Plots a spin distribution (given as meshgrid data).
 
@@ -1297,8 +1298,8 @@ def plot_spin_distribution(P, THETA, PHI,
 
     projection: string {'2d', '3d'}
         Specify whether the spin distribution function is to be plotted as a 2D
-        projection where the surface of the unit sphere is mapped on the unit disk ('2d')
-        or surface plot ('3d').
+        projection where the surface of the unit sphere is mapped on
+        the unit disk ('2d') or surface plot ('3d').
 
     Returns
     -------

From 5997b12dded2ddb49e32c43dfe6901f3f5c08277 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 19 Jun 2023 18:21:49 +0900
Subject: [PATCH 427/602] work on other functions

---
 qutip/visualization.py | 448 ++++++++++++++++++++---------------------
 1 file changed, 217 insertions(+), 231 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 298078b9fc..40d9ca6df4 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -61,37 +61,37 @@ def _cyclic_cmap():
         return complex_phase_cmap()
 
 
-def _is_figure_and_axes(figure, axes, projection='2d'):
-    if figure is None:
-        if axes is None:
-            figure = plt.figure()
+def _is_fig_and_ax(fig, ax, projection='2d'):
+    if fig is None:
+        if ax is None:
+            fig = plt.figure()
             if projection == '2d':
-                axes = figure.add_subplot(1, 1, 1)
+                ax = fig.add_subplot(1, 1, 1)
             else:
-                axes = _axes3D(figure)
+                ax = _axes3D(fig)
         else:
-            figure = axes.get_figure()
+            fig = ax.get_figure()
     else:
-        if axes is None:
+        if ax is None:
             if projection == '2d':
-                axes = figure.add_subplot(1, 1, 1)
+                ax = fig.add_subplot(1, 1, 1)
             else:
-                axes = _axes3D(figure)
+                ax = _axes3D(fig)
 
-    return figure, axes
+    return fig, ax
 
 
-def _set_ticklabels(axes, ticklabels, ticks, axis):
+def _set_ticklabels(ax, ticklabels, ticks, axis):
     if len(ticks) != len(ticklabels):
         raise ValueError(
             f"got {len(ticklabels)} ticklabels but needed {len(ticks)}"
             )
     if axis == 'x':
-        axes.set_xticks(ticks)
-        axes.set_xticklabels(ticklabels, fontsize=14)
+        ax.set_xticks(ticks)
+        ax.set_xticklabels(ticklabels, fontsize=14)
     elif axis == 'y':
-        axes.set_yticks(ticks)
-        axes.set_yticklabels(ticklabels, fontsize=14)
+        ax.set_yticks(ticks)
+        ax.set_yticklabels(ticklabels, fontsize=14)
     else:
         raise ValueError(
             "axis must be either 'x' or 'y'"
@@ -225,7 +225,7 @@ def _cb_labels(left_dims):
 # Adopted from the SciPy Cookbook.
 def hinton(rho, color_style="scaled", label_top=True, *,
            xticklabels=None, yticklabels=None, cmap=None, colorbar=True,
-           figure=None, axes=None):
+           fig=None, ax=None):
     """Draws a Hinton diagram for visualizing a density matrix or superoperator.
 
     Parameters
@@ -264,11 +264,11 @@ def hinton(rho, color_style="scaled", label_top=True, *,
     colorbar : bool
         Whether (True) or not (False) a colorbar should be attached.
 
-    figure : a matplotlib Figure instance
+    fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
-    axes : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
+    ax : a matplotlib axes instance
+        The ax context in which the plot will be drawn.
 
     Returns
     -------
@@ -298,7 +298,7 @@ def hinton(rho, color_style="scaled", label_top=True, *,
     >>> fig.show()
     """
 
-    figure, axes = _is_figure_and_axes(figure, axes)
+    fig, ax = _is_fig_and_ax(fig, ax)
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):
@@ -365,7 +365,7 @@ def color_fn(w):
             "Unknown color style {} for Hinton diagrams.".format(color_style)
         )
 
-    axes.fill(array([0, width, width, 0]), array([0, 0, height, height]),
+    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
             color=cmap(128))
     for x in range(width):
         for y in range(height):
@@ -373,36 +373,36 @@ def color_fn(w):
             _y = y + 1
             _blob(
                 _x - 0.5, height - _y + 0.5, W[y, x], w_max,
-                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=axes)
+                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
 
     if colorbar:
         vmax = np.pi if color_style == "phase" else abs(W).max()
         norm = mpl.colors.Normalize(-vmax, vmax)
-        cax, kw = mpl.colorbar.make_axes(axes, shrink=0.75, pad=.1)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
         mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
     # axis
     if not (xticklabels or yticklabels):
-        axes.axis('off')
-    axes.axis('equal')
-    axes.set_frame_on(False)
+        ax.axis('off')
+    ax.axis('equal')
+    ax.set_frame_on(False)
 
     # x axis
     xticks = 0.5 + np.arange(width)
     if xticklabels:
-        _set_ticklabels(axes, xticklabels, xticks, 'x')
+        _set_ticklabels(ax, xticklabels, xticks, 'x')
     if label_top:
-        axes.xaxis.tick_top()
+        ax.xaxis.tick_top()
 
     # y axis
     yticks = 0.5 + np.arange(height)
     if yticklabels:
-        _set_ticklabels(axes, list(reversed(yticklabels)), yticks, 'y')
+        _set_ticklabels(ax, list(reversed(yticklabels)), yticks, 'y')
 
-    return figure, axes
+    return fig, ax
 
 
-def sphereplot(theta, phi, values, fig=None, ax=None):
+def sphereplot(theta, phi, values, *, cmap=None, colorbar=True, fig=None, ax=None):
     """Plots a matrix of values on a sphere
 
     Parameters
@@ -416,24 +416,28 @@ def sphereplot(theta, phi, values, fig=None, ax=None):
     values : array
         Data set to be plotted
 
+    cmap : a matplotlib colormap instance
+        Color map to use when plotting.
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached.
+
     fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
     ax : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
-    save : bool {False , True}
-        Whether to save the figure or not
-
     Returns
     -------
     fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
     """
-    if fig is None or ax is None:
-        fig = plt.figure()
-        ax = _axes3D(fig)
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+    if cmap is None:
+        cmap = _cmap()
 
     thetam, phim = np.meshgrid(theta, phi)
     xx = sin(thetam) * cos(phim)
@@ -442,20 +446,22 @@ def sphereplot(theta, phi, values, fig=None, ax=None):
     r = array(abs(values))
     ph = angle(values)
     # normalize color range based on phase angles in list ph
-    nrm = mpl.colors.Normalize(ph.min(), ph.max())
+    norm = mpl.colors.Normalize(ph.min(), ph.max())
 
     # plot with facecolors set to cm.jet colormap normalized to nrm
     ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
-                    facecolors=cm.jet(nrm(ph)), linewidth=0)
-    # create new axes on plot for colorbar and shrink it a bit.
-    # pad shifts location of bar with repsect to the main plot
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+                    facecolors=cmap(norm(ph)), linewidth=0,)
+
+    if colorbar:
+        # create new axes on plot for colorbar and shrink it a bit.
+        # pad shifts location of bar with repsect to the main plot
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
 
-    # create new colorbar in axes cax with cm jet and normalized to nrm like
-    # our facecolors
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
-    # add our colorbar label
-    cb1.set_label('Angle')
+        # create new colorbar in axes cax with cm jet and normalized to nrm like
+        # our facecolors
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        # add our colorbar label
+        cb1.set_label('Angle')
 
     return fig, ax
 
@@ -749,7 +755,7 @@ def matrix_histogram(M, xlabels=None, ylabels=None,
 
 def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
                              xticklabels=None, yticklabels=None, cmap=None,
-                             colorbar=True, figure=None, axes=None):
+                             colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -779,15 +785,15 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     colorbar : bool
         Whether (True) or not (False) a colorbar should be attached.
 
-    axes : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
-
-    figure : a matplotlib Figure instance
+    fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
     Returns
     -------
-    figure, axes : tuple
+    fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
 
@@ -797,9 +803,9 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
         Input argument is not valid.
 
     """
-    figure, axes = _is_figure_and_axes(figure, axes, projection='3d')
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
     # set angle
-    axes.view_init(azim=-35, elev=35)
+    ax.view_init(azim=-35, elev=35)
 
     if isinstance(M, Qobj):
         # extract matrix data from Qobj
@@ -834,37 +840,37 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     if threshold is not None:
         colors[:, 3] = 1 * (dz > threshold)
 
-    axes.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
+    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
 
     # x axis
     xticks = -0.5 + np.arange(M.shape[0])
     if xticklabels:
-        _set_ticklabels(axes, xticklabels, xticks, 'x')
+        _set_ticklabels(ax, xticklabels, xticks, 'x')
     else:
-        axes.tick_params(axis='x', which='both',
+        ax.tick_params(axis='x', which='both',
                          bottom=False, labelbottom=False)
 
     # y axis
     yticks = -0.5 + np.arange(M.shape[1])
     if yticklabels:
-        _set_ticklabels(axes, yticklabels, yticks, 'y')
+        _set_ticklabels(ax, yticklabels, yticks, 'y')
     else:
-        axes.tick_params(axis='y', which='both', left=False, labelleft=False)
+        ax.tick_params(axis='y', which='both', left=False, labelleft=False)
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(axes, shrink=.75, pad=.0)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
         cb.set_ticklabels(
             (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
         cb.set_label('arg')
 
-    return figure, axes
+    return fig, ax
 
 
 def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
-                       figure=None, axes=None):
+                       fig=None, ax=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
     up to N energy levels. For each element in H_list, the energy
@@ -887,15 +893,15 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
             A list of  yticklabels to the left of energy levels of the initial
             Hamiltonian.
 
-        figure : a matplotlib Figure instance
+        fig : a matplotlib Figure instance
             The Figure canvas in which the plot will be drawn.
 
-        axes : a matplotlib axes instance
+        ax : a matplotlib axes instance
             The axes context in which the plot will be drawn.
 
     Returns
     -------
-    figure, axes : tuple
+    fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
 
@@ -907,8 +913,8 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
 
     """
 
-    figure, axes = _is_figure_and_axes(figure, axes)
-    axes.set_frame_on(False)
+    fig, ax = _is_fig_and_ax(fig, ax)
+    ax.set_frame_on(False)
 
     if not isinstance(H_list, list):
         raise ValueError("H_list must be a list of Qobj instances")
@@ -922,7 +928,7 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
     x = 0
     evals0 = H.eigenenergies(eigvals=N)
     for e_idx, e in enumerate(evals0[:N]):
-        axes.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+        ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
         yticks.append(e)
     xticks.append(x + 1)
     x += 2
@@ -933,11 +939,11 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
         evals1 = H.eigenenergies()
 
         for e_idx, e in enumerate(evals1[:N]):
-            axes.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
+            ax.plot([x, x + 1], np.array([evals0[e_idx], e]), 'k:')
         x += 1
 
         for e_idx, e in enumerate(evals1[:N]):
-            axes.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
+            ax.plot([x, x + 2], np.array([1, 1]) * e, 'b', linewidth=2)
         xticks.append(x + 1)
         x += 2
 
@@ -945,33 +951,30 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
 
     if yticklabels:
         yticks = np.unique(np.around(yticks, 1))
-        _set_ticklabels(axes, yticklabels, yticks, 'y')
+        _set_ticklabels(ax, yticklabels, yticks, 'y')
     else:
         # show eigenenergies
         yticks = np.unique(np.around(yticks, 1))
-        axes.set_yticks(yticks)
+        ax.set_yticks(yticks)
 
     if xticklabels:
-        axes.get_xaxis().tick_bottom()
-        _set_ticklabels(axes, xticklabels, xticks, 'x')
+        ax.get_xaxis().tick_bottom()
+        _set_ticklabels(ax, xticklabels, xticks, 'x')
     else:
         # hide xtick
-        axes.tick_params(axis='x', which='both',
+        ax.tick_params(axis='x', which='both',
                          bottom=False, labelbottom=False)
 
-    return figure, axes
+    return fig, ax
 
 
 def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
                          figsize=(8, 12), fig=None, ax=None):
     warnings.warn("Deprecated: Use plot_energy_levels")
-    return plot_energy_levels(H_list, N=N, labels=labels,
-                              show_ylabels=show_ylabels,
-                              figsize=figsize, fig=fig, ax=ax)
+    return plot_energy_levels(H_list, N=N, fig=fig, ax=ax)
 
 
-def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
-                           figsize=(8, 6), title=None, unit_y_range=True):
+def plot_fock_distribution(rho, offset=0, unit_y_range=True, *, fig=None, ax=None):
     """
     Plot the Fock distribution for a density matrix (or ket) that describes
     an oscillator mode.
@@ -981,19 +984,15 @@ def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
+    offset : int
+        Offset the fock number
+
     fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
     ax : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
-    title : string
-        An optional title for the figure.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
     Returns
     -------
     fig, ax : tuple
@@ -1001,8 +1000,7 @@ def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
         the figure.
     """
 
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
+    fig, ax = _is_fig_and_ax(fig, ax)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1011,30 +1009,24 @@ def plot_fock_distribution(rho, offset=0, fig=None, ax=None,
 
     ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
            color="green", alpha=0.6, width=0.8)
+
     if unit_y_range:
         ax.set_ylim(0, 1)
-
     ax.set_xlim(-.5 + offset, N + offset)
     ax.set_xlabel('Fock number', fontsize=12)
     ax.set_ylabel('Occupation probability', fontsize=12)
 
-    if title:
-        ax.set_title(title)
-
     return fig, ax
 
 
 def fock_distribution(rho, offset=0, fig=None, ax=None,
                       figsize=(8, 6), title=None, unit_y_range=True):
     warnings.warn("Deprecated: Use plot_fock_distribution")
-    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax,
-                                  figsize=figsize, title=title,
-                                  unit_y_range=unit_y_range)
+    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax)
 
 
-def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
-                cmap=None, alpha_max=7.5, colorbar=False,
-                method='clenshaw', projection='2d'):
+def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
+                cmap=None, colorbar=False, fig=None, ax=None):
     """
     Plot the the Wigner function for a density matrix (or ket) that describes
     an oscillator mode.
@@ -1044,33 +1036,29 @@ def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
+    alpha_max : float
+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
 
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
 
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
+    projection: string {'2d', '3d'}
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
 
     cmap : a matplotlib cmap instance
         The colormap.
 
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
     colorbar : bool
         Whether (True) or not (False) a colorbar should be attached to the
         Wigner function graph.
 
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
 
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
 
     Returns
     -------
@@ -1079,14 +1067,10 @@ def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
         the figure.
     """
 
-    if not fig and not ax:
-        if projection == '2d':
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
-        elif projection == '3d':
-            fig = plt.figure(figsize=figsize)
-            ax = fig.add_subplot(1, 1, 1, projection='3d')
-        else:
-            raise ValueError('Unexpected value of projection keyword argument')
+    if projection in ('2d','3d'):
+        fig, ax = _is_fig_and_ax(fig, ax, projection)
+    else:
+        raise ValueError('Unexpected value of projection keyword argument')
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1097,19 +1081,16 @@ def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
     W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
 
     wlim = abs(W).max()
-
+    norm = mpl.colors.Normalize(-wlim, wlim)
     if cmap is None:
-        cmap = cm.get_cmap('RdBu')
+        cmap = _cmap()
 
     if projection == '2d':
-        cf = ax.contourf(xvec, yvec, W, 100,
-                         norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-    elif projection == '3d':
+        cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap)
+    else:
         X, Y = np.meshgrid(xvec, xvec)
         cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
-                             norm=mpl.colors.Normalize(-wlim, wlim), cmap=cmap)
-    else:
-        raise ValueError('Unexpected value of projection keyword argument.')
+                             norm=norm, cmap=cmap)
 
     if xvec is not yvec:
         ax.set_ylim(xvec.min(), xvec.max())
@@ -1118,16 +1099,17 @@ def plot_wigner(rho, fig=None, ax=None, figsize=(6, 6),
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 
     if colorbar:
-        fig.colorbar(cf, ax=ax)
+        cax, kw = mpl.colorbar.make_axes(ax)
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
     ax.set_title("Wigner function", fontsize=12)
 
     return fig, ax
 
 
-def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-                                  cmap=None, alpha_max=7.5, colorbar=False,
-                                  method='iterative', projection='2d'):
+def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
+                                  projection='2d', *, cmap=None,
+                                  colorbar=False, fig=None, axes=None):
     """
     Plot the Fock distribution and the Wigner function for a density matrix
     (or ket) that describes an oscillator mode.
@@ -1137,46 +1119,63 @@ def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
+    alpha_max : float
+        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
 
-    axes : a list of two matplotlib axes instances
-        The axes context in which the plot will be drawn.
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
 
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
+    projection: string {'2d', '3d'}
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
 
     cmap : a matplotlib cmap instance
         The colormap.
 
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
     colorbar : bool
         Whether (True) or not (False) a colorbar should be attached to the
         Wigner function graph.
 
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
+    axes : a list of two matplotlib axes instances
+        The axes context in which the plot will be drawn.
+
     method : string {'iterative', 'laguerre', 'fft'}
         The method used for calculating the wigner function. See the
         documentation for qutip.wigner for details.
 
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
     Returns
     -------
-    fig, ax : tuple
+    fig, axes : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
     """
+    if fig is None and axes is not None:
+        raise ValueError("figure object is neccessary")
+    if fig is None:
+        fig = plt.figure()
+    if axes is None:
+        if projection == '2d':
+            axes = [fig.add_subplot(1, 2, 1),
+                    fig.add_subplot(1, 2, 2)]
+        elif projection == '3d':
+            axes = [fig.add_subplot(1, 2, 1),
+                fig.add_subplot(1, 2, 2, projection=projection)]
+        else:
+            raise ValueError("Unexpected value of projection keyword argument")
+    else:
+        if not isinstance(axes, list) or len(axes) != 2:
+            raise ValueError("axes must be a list of two matplotlib axes instances")
+    fig.set_size_inches(8, 4)
 
     if not fig and not axes:
         if projection == '2d':
-            fig, axes = plt.subplots(1, 2, figsize=figsize)
+            fig, axes = plt.subplots(1, 2)
         elif projection == '3d':
-            fig = plt.figure(figsize=figsize)
+            fig = plt.figure()
             axes = [fig.add_subplot(1, 2, 1),
                     fig.add_subplot(1, 2, 2, projection='3d')]
         else:
@@ -1186,9 +1185,8 @@ def plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
         rho = ket2dm(rho)
 
     plot_fock_distribution(rho, fig=fig, ax=axes[0])
-    plot_wigner(rho, fig=fig, ax=axes[1], figsize=figsize, cmap=cmap,
-                alpha_max=alpha_max, colorbar=colorbar, method=method,
-                projection=projection)
+    plot_wigner(rho, alpha_max=alpha_max, method=method, projection=projection,
+                 cmap=cmap, colorbar=colorbar, fig=fig, ax=axes[1])
 
     return fig, axes
 
@@ -1204,8 +1202,8 @@ def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
                                          method=method)
 
 
-def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
-                            fig=None, axes=None, figsize=(8, 4)):
+def plot_expectation_values(results, ylabels=None, title=None, *,
+                            fig=None, axes=None):
     """
     Visualize the results (expectation values) for an evolution solver.
     `results` is assumed to be an instance of Result, or a list of Result
@@ -1222,22 +1220,15 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
     title : string
         The title of the figure.
 
-    show_legend : bool
-        Whether or not to show the legend.
-
     fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
-    axes : a matplotlib axes instance
+    axes : (list of)  axes instances
         The axes context in which the plot will be drawn.
 
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
     Returns
     -------
-    fig, ax : tuple
+    fig, axes : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
     """
@@ -1246,11 +1237,20 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
 
     n_e_ops = max([len(result.expect) for result in results])
 
-    if not fig or not axes:
-        if not figsize:
-            figsize = (12, 3 * n_e_ops)
-        fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
-                                 figsize=figsize, squeeze=False)
+    if fig is None:
+        if axes is None:
+            fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
+                                    figsize=(12, 3 * n_e_ops), squeeze=False)
+        else:
+            raise ValueError('figure object is necessary')
+    else:
+        if axes is None:
+                axes = np.array([[fig.add_subplot(n_e_ops, 1, i+1)]
+                                 for i in range(n_e_ops)])
+        else:
+            if not isinstance(axes, list):
+                axes = [axes]
+            axes = np.array(axes)
 
     for r_idx, result in enumerate(results):
         for e_idx, e in enumerate(result.expect):
@@ -1262,16 +1262,14 @@ def plot_expectation_values(results, ylabels=[], title=None, show_legend=False,
 
     axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
     for n in range(n_e_ops):
-        if show_legend:
-            axes[n, 0].legend()
         if ylabels:
             axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
 
-    return fig, axes
+    return fig, axes.tolist()
 
 
-def plot_spin_distribution(P, THETA, PHI,
-                           fig=None, ax=None, figsize=(8, 6), projection='2d'):
+def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
+                           cmap=None, colorbar=False, fig=None, ax=None):
     """
     Plots a spin distribution (given as meshgrid data).
 
@@ -1286,69 +1284,69 @@ def plot_spin_distribution(P, THETA, PHI,
     PHI : matrix
         Meshgrid matrix for the phi coordinate.
 
+    projection: string {'2d', '3d'}
+        Specify whether the spin distribution function is to be plotted as a 2D
+        projection where the surface of the unit sphere is mapped on
+        the unit disk ('2d') or surface plot ('3d').
+
+    cmap : a matplotlib cmap instance
+        The colormap.
+
+    colorbar : bool
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
     fig : a matplotlib figure instance
         The figure canvas on which the plot will be drawn.
 
     ax : a matplotlib axis instance
         The axis context in which the plot will be drawn.
 
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    projection: string {'2d', '3d'}
-        Specify whether the spin distribution function is to be plotted as a 2D
-        projection where the surface of the unit sphere is mapped on
-        the unit disk ('2d') or surface plot ('3d').
-
     Returns
     -------
     fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
     """
+
+    if projection in ('2d', '3d'):
+        fig, ax = _is_fig_and_ax(fig, ax, projection)
+    else:
+        raise ValueError('Unexpected value of projection keyword argument')
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+        norm = mpl.colors.Normalize(-P.max(), P.max())
+    else:
+        cmap = cm.RdYlBu
+        norm = mpl.colors.Normalize(P.min(), P.max())
+
     if projection == '2d':
-        if not fig and not ax:
-            fig, ax = plt.subplots(1, 1, figsize=figsize)
         Y = (THETA - pi / 2) / (pi / 2)
         X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
 
-        if P.min() < -1e12:
-            cmap = cm.RdBu
-        else:
-            cmap = cm.RdYlBu
-
         ax.pcolor(X, Y, P.real, cmap=cmap)
         ax.set_xlabel(r'$\varphi$', fontsize=18)
         ax.set_ylabel(r'$\theta$', fontsize=18)
-
+        ax.axis('equal')
         ax.set_xticks([-1, 0, 1])
         ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
         ax.set_yticks([-1, 0, 1])
         ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-    elif projection == '3d':
-        if not fig and not ax:
-            fig = plt.figure(figsize=figsize)
-            ax = _axes3D(fig, azim=-35, elev=35)
+    else:
+        ax.view_init(azim=-35, elev=35)
+
         xx = sin(THETA) * cos(PHI)
         yy = sin(THETA) * sin(PHI)
         zz = cos(THETA)
 
-        if P.min() < -1e12:
-            cmap = cm.RdBu
-            norm = mpl.colors.Normalize(-P.max(), P.max())
-        else:
-            cmap = cm.RdYlBu
-            norm = mpl.colors.Normalize(P.min(), P.max())
-
         ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
                         facecolors=cmap(norm(P)), linewidth=0)
-
+    if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
         cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb1.set_label('magnitude')
-    else:
-        raise ValueError('Unexpected value of projection keyword argument')
+
     return fig, ax
 
 
@@ -1643,9 +1641,8 @@ def _sequence_to_latex(seq, style='ket'):
     return latex.format("".join(map(str, seq)))
 
 
-def plot_qubism(ket, theme='light', how='pairs',
-                grid_iteration=1, legend_iteration=0,
-                fig=None, ax=None, figsize=(6, 6)):
+def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
+                legend_iteration=0, *, fig=None, ax=None):
     """
     Qubism plot for pure states of many qudits.  Works best for spin chains,
     especially with even number of particles of the same dimension.  Allows to
@@ -1683,10 +1680,6 @@ def plot_qubism(ket, theme='light', how='pairs',
     ax : a matplotlib axis instance
         The axis context in which the plot will be drawn.
 
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
     Returns
     -------
     fig, ax : tuple
@@ -1706,13 +1699,12 @@ def plot_qubism(ket, theme='light', how='pairs',
        (2012), open access.
     """
 
+    fig, ax = _is_fig_and_ax(fig, ax)
+
     if not isket(ket):
         raise Exception("Qubism works only for pure states, i.e. kets.")
         # add for dm? (perhaps a separate function, plot_qubism_dm)
 
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
     dim_list = ket.dims[0]
     n = len(dim_list)
 
@@ -1809,10 +1801,8 @@ def plot_qubism(ket, theme='light', how='pairs',
     return fig, ax
 
 
-def plot_schmidt(ket, splitting=None,
-                 labels_iteration=(3, 2),
-                 theme='light',
-                 fig=None, ax=None, figsize=(6, 6)):
+def plot_schmidt(ket, splitting=None, labels_iteration=(3, 2),
+                 theme='light', *, fig=None, ax=None):
     """
     Plotting scheme related to Schmidt decomposition.
     Converts a state into a matrix (A_ij -> A_i^j),
@@ -1843,10 +1833,6 @@ def plot_schmidt(ket, splitting=None,
     ax : a matplotlib axis instance
         The axis context in which the plot will be drawn.
 
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
     Returns
     -------
     fig, ax : tuple
@@ -1854,12 +1840,12 @@ def plot_schmidt(ket, splitting=None,
         the figure.
 
     """
+
+    fig, ax = _is_fig_and_ax(fig, ax)
+
     if not isket(ket):
         raise Exception("Schmidt plot works only for pure states, i.e. kets.")
 
-    if not fig and not ax:
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
     dim_list = ket.dims[0]
 
     if splitting is None:

From 9f49d631bde8668db4e7a25a32c52b594fad0171 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 19 Jun 2023 19:02:30 +0900
Subject: [PATCH 428/602] delete repeated part

---
 qutip/visualization.py | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 40d9ca6df4..51d3f55540 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1171,16 +1171,6 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
             raise ValueError("axes must be a list of two matplotlib axes instances")
     fig.set_size_inches(8, 4)
 
-    if not fig and not axes:
-        if projection == '2d':
-            fig, axes = plt.subplots(1, 2)
-        elif projection == '3d':
-            fig = plt.figure()
-            axes = [fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2, projection='3d')]
-        else:
-            raise ValueError('Unexpected value of projection keyword argument')
-
     if isket(rho):
         rho = ket2dm(rho)
 

From 439405ab41a11bc7dd699cc07d8b5306607a1e91 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 19 Jun 2023 19:03:37 +0900
Subject: [PATCH 429/602] delete plot_spin_distribution_2d and 3d

---
 qutip/visualization.py | 117 -----------------------------------------
 1 file changed, 117 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 51d3f55540..14b4298832 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1340,123 +1340,6 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     return fig, ax
 
 
-def plot_spin_distribution_2d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 8)):
-    """
-    Plot a spin distribution function (given as meshgrid data) with a 2D
-    projection where the surface of the unit sphere is mapped on the unit disk.
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig or not ax:
-        if not figsize:
-            figsize = (8, 8)
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    Y = (THETA - pi / 2) / (pi / 2)
-    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-    else:
-        cmap = cm.RdYlBu
-
-    ax.pcolor(X, Y, P.real, cmap=cmap)
-    ax.set_xlabel(r'$\varphi$', fontsize=18)
-    ax.set_ylabel(r'$\theta$', fontsize=18)
-
-    ax.set_xticks([-1, 0, 1])
-    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
-    ax.set_yticks([-1, 0, 1])
-    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-
-    return fig, ax
-
-
-def plot_spin_distribution_3d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 6)):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    if fig is None or ax is None:
-        fig = plt.figure(figsize=figsize)
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    xx = sin(THETA) * cos(PHI)
-    yy = sin(THETA) * sin(PHI)
-    zz = cos(THETA)
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-        norm = mpl.colors.Normalize(-P.max(), P.max())
-    else:
-        cmap = cm.RdYlBu
-        norm = mpl.colors.Normalize(P.min(), P.max())
-
-    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-                    facecolors=cmap(norm(P)), linewidth=0)
-
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-    cb1.set_label('magnitude')
-
-    return fig, ax
-
-
 #
 # Qubism and other qubistic visualizations
 #

From 0bd999f14e18d8c02c4dea119081b8b8ec78f0bb Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 19 Jun 2023 19:15:02 +0900
Subject: [PATCH 430/602] fixed minor error

---
 qutip/visualization.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 14b4298832..b70004216e 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,11 +7,10 @@
            'plot_energy_levels', 'fock_distribution',
            'plot_fock_distribution', 'wigner_fock_distribution',
            'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution_2d',
-           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
+           'plot_expectation_values', 'plot_spin_distribution',
+           'plot_qubism', 'plot_schmidt',
            'complex_array_to_rgb', 'matrix_histogram',
-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere',
-           'plot_spin_distribution']
+           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
 
 import warnings
 import itertools as it

From ac72dc86f2b37d9a0b31d21207b59de00a725774 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 19 Jun 2023 20:00:13 +0900
Subject: [PATCH 431/602] revert change

---
 qutip/visualization.py | 124 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 121 insertions(+), 3 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index b70004216e..51d3f55540 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,10 +7,11 @@
            'plot_energy_levels', 'fock_distribution',
            'plot_fock_distribution', 'wigner_fock_distribution',
            'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution',
-           'plot_qubism', 'plot_schmidt',
+           'plot_expectation_values', 'plot_spin_distribution_2d',
+           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
            'complex_array_to_rgb', 'matrix_histogram',
-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere']
+           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere',
+           'plot_spin_distribution']
 
 import warnings
 import itertools as it
@@ -1339,6 +1340,123 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     return fig, ax
 
 
+def plot_spin_distribution_2d(P, THETA, PHI,
+                              fig=None, ax=None, figsize=(8, 8)):
+    """
+    Plot a spin distribution function (given as meshgrid data) with a 2D
+    projection where the surface of the unit sphere is mapped on the unit disk.
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if not fig or not ax:
+        if not figsize:
+            figsize = (8, 8)
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
+    Y = (THETA - pi / 2) / (pi / 2)
+    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+    else:
+        cmap = cm.RdYlBu
+
+    ax.pcolor(X, Y, P.real, cmap=cmap)
+    ax.set_xlabel(r'$\varphi$', fontsize=18)
+    ax.set_ylabel(r'$\theta$', fontsize=18)
+
+    ax.set_xticks([-1, 0, 1])
+    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
+    ax.set_yticks([-1, 0, 1])
+    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
+
+    return fig, ax
+
+
+def plot_spin_distribution_3d(P, THETA, PHI,
+                              fig=None, ax=None, figsize=(8, 6)):
+    """Plots a matrix of values on a sphere
+
+    Parameters
+    ----------
+    P : matrix
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate.
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate.
+
+    fig : a matplotlib figure instance
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance
+        The axis context in which the plot will be drawn.
+
+    figsize : (width, height)
+        The size of the matplotlib figure (in inches) if it is to be created
+        (that is, if no 'fig' and 'ax' arguments are passed).
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+
+    if fig is None or ax is None:
+        fig = plt.figure(figsize=figsize)
+        ax = _axes3D(fig, azim=-35, elev=35)
+
+    xx = sin(THETA) * cos(PHI)
+    yy = sin(THETA) * sin(PHI)
+    zz = cos(THETA)
+
+    if P.min() < -1e12:
+        cmap = cm.RdBu
+        norm = mpl.colors.Normalize(-P.max(), P.max())
+    else:
+        cmap = cm.RdYlBu
+        norm = mpl.colors.Normalize(P.min(), P.max())
+
+    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+                    facecolors=cmap(norm(P)), linewidth=0)
+
+    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+    cb1.set_label('magnitude')
+
+    return fig, ax
+
+
 #
 # Qubism and other qubistic visualizations
 #

From e663a5b6c66cfdee2eb48fcdc090d3fef6f2ce80 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 19 Jun 2023 10:50:19 -0400
Subject: [PATCH 432/602] Update for numpy 1.25 deprecations

---
 qutip/core/tensor.py                          | 2 +-
 qutip/tests/core/test_qobj.py                 | 6 ++----
 qutip/tests/solver/heom/test_bofin_solvers.py | 4 ++--
 qutip/tests/test_wigner.py                    | 2 +-
 4 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/qutip/core/tensor.py b/qutip/core/tensor.py
index 969d2ad842..3a3661752c 100644
--- a/qutip/core/tensor.py
+++ b/qutip/core/tensor.py
@@ -333,7 +333,7 @@ def tensor_contract(qobj, *pairs):
     # We don't need to check for tensor idxs versus dims idxs here,
     # as column- versus row-stacking will never move an index for the
     # vectorized operator spaces all the way from the left to the right.
-    l_mtx_dims, r_mtx_dims = map(np.product, map(flatten, contracted_dims))
+    l_mtx_dims, r_mtx_dims = map(np.prod, map(flatten, contracted_dims))
 
     # Reshape back into a 2D matrix.
     qmtx = qtens.reshape((l_mtx_dims, r_mtx_dims))
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 2668056b0e..5fd8206cda 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -317,11 +317,10 @@ def test_QobjMultiplication():
 
 # Allowed mul operations (scalar)
 @pytest.mark.parametrize("scalar",
-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+                         [2+2j,  np.array(2+2j)],
                          ids=[
                              "python_number",
                              "scalar_like_array_shape_0",
-                             "scalar_like_array_shape_1",
                          ])
 def test_QobjMulValidScalar(scalar):
     "Tests multiplication of Qobj times scalar."
@@ -359,11 +358,10 @@ def test_QobjMulNotValidScalar(not_scalar):
 
 # Allowed division operations (scalar)
 @pytest.mark.parametrize("scalar",
-                         [2+2j,  np.array(2+2j), np.array([2+2j])],
+                         [2+2j,  np.array(2+2j)],
                          ids=[
                              "python_number",
                              "scalar_like_array_shape_0",
-                             "scalar_like_array_shape_1",
                          ])
 def test_QobjDivisionValidScalar(scalar):
     "Tests multiplication of Qobj times scalar."
diff --git a/qutip/tests/solver/heom/test_bofin_solvers.py b/qutip/tests/solver/heom/test_bofin_solvers.py
index 72b737a91c..ad6e5f2297 100644
--- a/qutip/tests/solver/heom/test_bofin_solvers.py
+++ b/qutip/tests/solver/heom/test_bofin_solvers.py
@@ -204,7 +204,7 @@ def mk_ados(self, bath_dims, max_depth):
 
     def mk_rho_and_soln(self, ados, rho_dims):
         n_ados = len(ados.labels)
-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+        ado_soln = np.random.rand(n_ados, *[np.prod(d) for d in rho_dims])
         rho = Qobj(ado_soln[0, :], dims=rho_dims)
         return rho, ado_soln
 
@@ -1289,7 +1289,7 @@ def mk_ados(self, bath_dims, max_depth):
 
     def mk_rho_and_soln(self, ados, rho_dims):
         n_ados = len(ados.labels)
-        ado_soln = np.random.rand(n_ados, *[np.product(d) for d in rho_dims])
+        ado_soln = np.random.rand(n_ados, *[np.prod(d) for d in rho_dims])
         rho = Qobj(ado_soln[0, :], dims=rho_dims)
         return rho, ado_soln
 
diff --git a/qutip/tests/test_wigner.py b/qutip/tests/test_wigner.py
index 9ad709a546..7087ca18d8 100644
--- a/qutip/tests/test_wigner.py
+++ b/qutip/tests/test_wigner.py
@@ -225,7 +225,7 @@ def test_against_naive_implementation(self, xs, ys, g, size):
         naive = np.empty(alphas.shape, dtype=np.float64)
         for i, alpha in enumerate(alphas.flat):
             coh = qutip.coherent(size, alpha, method='analytic').full()
-            naive.flat[i] = (coh.conj().T @ state_np @ coh).real
+            naive.flat[i] = (coh.conj().T @ state_np @ coh).real[0, 0]
         naive *= (0.5*g)**2 / np.pi
         np.testing.assert_allclose(naive, qutip.qfunc(state, xs, ys, g))
         np.testing.assert_allclose(naive, qutip.QFunc(xs, ys, g)(state))

From 71e40370fb4aacd0435d529d772ea7f0d007671e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 21 Jun 2023 07:40:43 +0900
Subject: [PATCH 433/602] change doc and add towncrier

---
 doc/changes/2170.feature          |   1 +
 doc/guide/guide-visualization.rst |  11 +-
 qutip/tomography.py               |   3 +-
 qutip/visualization.py            | 187 +++++++++---------------------
 4 files changed, 64 insertions(+), 138 deletions(-)
 create mode 100644 doc/changes/2170.feature

diff --git a/doc/changes/2170.feature b/doc/changes/2170.feature
new file mode 100644
index 0000000000..10a2e0f456
--- /dev/null
+++ b/doc/changes/2170.feature
@@ -0,0 +1 @@
+changed arguments and apply colorblind_safe to functions in visualization.py by Yuji Tamakoshi
\ No newline at end of file
diff --git a/doc/guide/guide-visualization.rst b/doc/guide/guide-visualization.rst
index 0b99bf4f57..8b183ad3b1 100644
--- a/doc/guide/guide-visualization.rst
+++ b/doc/guide/guide-visualization.rst
@@ -105,11 +105,14 @@ above, so QuTiP provides a convenience function for doing this, see
 
     fig, axes = plt.subplots(1, 3, figsize=(12,3))
 
-    plot_fock_distribution(rho_coherent, fig=fig, ax=axes[0], title="Coherent state");
+    fig, axes[0] = plot_fock_distribution(rho_coherent, fig=fig, ax=axes[0]);
+    axes[0].set_title('Coherent state')
 
-    plot_fock_distribution(rho_thermal, fig=fig, ax=axes[1], title="Thermal state");
+    fig, axes[1] = plot_fock_distribution(rho_thermal, fig=fig, ax=axes[1]);
+    axes[1].set_title('Thermal state')
 
-    plot_fock_distribution(rho_fock, fig=fig, ax=axes[2], title="Fock state");
+    fig, axes[2] = plot_fock_distribution(rho_fock, fig=fig, ax=axes[2]);
+    axes[2].set_title('Fock state')
 
     fig.tight_layout()
 
@@ -309,7 +312,7 @@ let's visualize of the Jaynes-Cummings Hamiltonian:
     for inds in tomography._index_permutations([len(lbls) for lbls in lbls_list]):
        xlabels.append("".join([lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
 
-    fig, ax = matrix_histogram(H, xlabels, xlabels, limits=[-4,4])
+    fig, ax = matrix_histogram(H, xlabels, xlabels, zlims=[-4,4])
 
     ax.view_init(azim=-55, elev=45)
 
diff --git a/qutip/tomography.py b/qutip/tomography.py
index a663ee30b4..8aa0928c48 100644
--- a/qutip/tomography.py
+++ b/qutip/tomography.py
@@ -139,8 +139,9 @@ def qpt_plot_combined(chi, lbls_list, title=None,
     if not title:
         title = r"$\chi$"
 
-    matrix_histogram_complex(chi, xlabels, xlabels, title=title, ax=ax,
+    matrix_histogram_complex(chi, xlabels, xlabels, ax=ax,
                              threshold=threshold)
+    ax.set_title(title)
 
     return fig, ax
 
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 51d3f55540..d7f3387c63 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -98,7 +98,7 @@ def _set_ticklabels(ax, ticklabels, ticks, axis):
             )
 
 
-def plot_wigner_sphere(fig, ax, wigner, reflections):
+def plot_wigner_sphere(wigner, reflections=True, *, cmap=None, colorbar=True, fig=None, ax=None):
     """Plots a coloured Bloch sphere.
 
     Parameters
@@ -116,6 +116,12 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
     -----
     Special thanks to Russell P Rundle for writing this function.
     """
+
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+    if cmap is None:
+        cmap = _cmap()
+
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     ax.set_zlabel("z")
@@ -130,7 +136,7 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
     wigner = np.real(wigner)
     wigner_max = np.real(np.amax(np.abs(wigner)))
 
-    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
+    wigner_c1 = cmap((wigner + wigner_max) / (2 * wigner_max))
 
     # Plot coloured Bloch sphere:
     ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
@@ -138,11 +144,11 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
                     zorder=0.5, antialiased=None)
 
     if reflections:
-        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+        wigner_c2 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
                                  (2*wigner_max))  # bottom
-        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+        wigner_c3 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
                                  (2*wigner_max))  # side
-        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
+        wigner_c4 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
                                  (2*wigner_max))  # back
 
         # Plot bottom reflection:
@@ -167,11 +173,16 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
                         antialiased=False)
 
     # Create colourbar:
-    m = cm.ScalarMappable(cmap=cm.seismic_r)
-    m.set_array([-wigner_max, wigner_max])
-    plt.colorbar(m, shrink=0.5, aspect=10)
+    if colorbar:
+        m = cm.ScalarMappable(cmap=cmap)
+        m.set_array([-wigner_max, wigner_max])
+        plt.colorbar(m, shrink=0.5, aspect=10)
+    else:
+        norm = mpl.colors.Normalize(-wigner_max, wigner_max)
+        cax, kw = mpl.colorbar.make_axes(ax)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
-    plt.show()
+    return fig, ax
 
 
 # Adopted from the SciPy Cookbook.
@@ -561,7 +572,7 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, xlabels=None, ylabels=None,
+def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
                      colorbar=True, fig=None, ax=None, options=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
@@ -577,6 +588,9 @@ def matrix_histogram(M, xlabels=None, ylabels=None,
     ylabels : list of strings
         list of y labels
 
+    zlims : list/array with two float numbers
+        The z-axis limits [min, max] (optional)
+
     ax : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
@@ -694,11 +708,15 @@ def matrix_histogram(M, xlabels=None, ylabels=None,
     dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
     dz = np.real(M.flatten())
 
-    z_min = min(dz)
-    z_max = max(dz)
-    if z_min == z_max:
-        z_min -= 0.1
-        z_max += 0.1
+    if isinstance(zlims, list) and len(zlims) == 2:
+        z_min = zlims[0]
+        z_max = zlims[1]
+    else:
+        z_min = min(dz)
+        z_max = max(dz)
+        if z_min == z_max:
+            z_min -= 0.1
+            z_max += 0.1
 
     if default_opts['cbar_to_z']:
         norm = mpl.colors.Normalize(min(dz), max(dz))
@@ -753,7 +771,7 @@ def matrix_histogram(M, xlabels=None, ylabels=None,
     return fig, ax
 
 
-def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
+def matrix_histogram_complex(M, phase_limits=None, threshold=None, zlims=None, *,
                              xticklabels=None, yticklabels=None, cmap=None,
                              colorbar=True, fig=None, ax=None):
     """
@@ -773,6 +791,9 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
         Threshold for when bars of smaller height should be transparent. If
         not set, all bars are colored according to the color map.
 
+    zlims : list/array with two float numbers
+        The z-axis limits [min, max] (optional)
+
     xticklabels : list of strings
         list of x ticklabels
 
@@ -857,6 +878,12 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     else:
         ax.tick_params(axis='y', which='both', left=False, labelleft=False)
 
+    # z axis
+    if isinstance(zlims, list):
+        ax.set_zlim3d(zlims)
+    else:
+        ax.set_zlim3d([0, 1])
+
     # color axis
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
@@ -869,7 +896,7 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, *,
     return fig, ax
 
 
-def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
+def plot_energy_levels(H_list, N=0, hamiltonians=None, energy_levels=None, *,
                        fig=None, ax=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
@@ -886,10 +913,10 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
         N : int
             The number of energy levels to plot
 
-        xticklabels : List of string
+        hamiltonians : List of string
             A list of xticklabels for each Hamiltonian
 
-        yticklabels : List of string
+        energy_levels : List of string
             A list of  yticklabels to the left of energy levels of the initial
             Hamiltonian.
 
@@ -949,17 +976,17 @@ def plot_energy_levels(H_list, N=0, *, xticklabels=None, yticklabels=None,
 
         evals0 = evals1
 
-    if yticklabels:
+    if energy_levels:
         yticks = np.unique(np.around(yticks, 1))
-        _set_ticklabels(ax, yticklabels, yticks, 'y')
+        _set_ticklabels(ax, energy_levels, yticks, 'y')
     else:
         # show eigenenergies
         yticks = np.unique(np.around(yticks, 1))
         ax.set_yticks(yticks)
 
-    if xticklabels:
+    if hamiltonians:
         ax.get_xaxis().tick_bottom()
-        _set_ticklabels(ax, xticklabels, xticks, 'x')
+        _set_ticklabels(ax, hamiltonians, xticks, 'x')
     else:
         # hide xtick
         ax.tick_params(axis='x', which='both',
@@ -1169,7 +1196,6 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
     else:
         if not isinstance(axes, list) or len(axes) != 2:
             raise ValueError("axes must be a list of two matplotlib axes instances")
-    fig.set_size_inches(8, 4)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1342,119 +1368,14 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
 
 def plot_spin_distribution_2d(P, THETA, PHI,
                               fig=None, ax=None, figsize=(8, 8)):
-    """
-    Plot a spin distribution function (given as meshgrid data) with a 2D
-    projection where the surface of the unit sphere is mapped on the unit disk.
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if not fig or not ax:
-        if not figsize:
-            figsize = (8, 8)
-        fig, ax = plt.subplots(1, 1, figsize=figsize)
-
-    Y = (THETA - pi / 2) / (pi / 2)
-    X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-    else:
-        cmap = cm.RdYlBu
-
-    ax.pcolor(X, Y, P.real, cmap=cmap)
-    ax.set_xlabel(r'$\varphi$', fontsize=18)
-    ax.set_ylabel(r'$\theta$', fontsize=18)
-
-    ax.set_xticks([-1, 0, 1])
-    ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
-    ax.set_yticks([-1, 0, 1])
-    ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-
-    return fig, ax
+    warnings.warn("Deprecated: Use plot_spin_distribution")
+    return plot_spin_distribution(P, THETA, PHI, fig=fig, ax=ax)
 
 
 def plot_spin_distribution_3d(P, THETA, PHI,
                               fig=None, ax=None, figsize=(8, 6)):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    P : matrix
-        Distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate.
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate.
-
-    fig : a matplotlib figure instance
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance
-        The axis context in which the plot will be drawn.
-
-    figsize : (width, height)
-        The size of the matplotlib figure (in inches) if it is to be created
-        (that is, if no 'fig' and 'ax' arguments are passed).
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    if fig is None or ax is None:
-        fig = plt.figure(figsize=figsize)
-        ax = _axes3D(fig, azim=-35, elev=35)
-
-    xx = sin(THETA) * cos(PHI)
-    yy = sin(THETA) * sin(PHI)
-    zz = cos(THETA)
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-        norm = mpl.colors.Normalize(-P.max(), P.max())
-    else:
-        cmap = cm.RdYlBu
-        norm = mpl.colors.Normalize(P.min(), P.max())
-
-    ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-                    facecolors=cmap(norm(P)), linewidth=0)
-
-    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
-    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-    cb1.set_label('magnitude')
-
-    return fig, ax
+    warnings.warn("Deprecated: Use plot_spin_distribution")
+    return plot_spin_distribution(P, THETA, PHI, projection='3d', fig=fig, ax=ax)
 
 
 #

From deae31d4b67c720f15ced260fb8ccd9f17d7c524 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 03:54:48 +0900
Subject: [PATCH 434/602] change in color, matrix_histogram, plot_energy_levels

---
 qutip/visualization.py | 180 ++++++++++++++++++-----------------------
 1 file changed, 79 insertions(+), 101 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index d7f3387c63..57783cd7de 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -47,9 +47,16 @@ def _axes3D(*args, **kwargs):
     pass
 
 
-def _cmap():
+def _sequential_cmap():
     if settings.colorblind_safe:
         return cm.cividis
+    else:
+        return cm.jet
+
+
+def _diverging_cmap():
+    if settings.colorblind_safe:
+        return cm.seismic
     else:
         return cm.RdBu
 
@@ -98,7 +105,7 @@ def _set_ticklabels(ax, ticklabels, ticks, axis):
             )
 
 
-def plot_wigner_sphere(wigner, reflections=True, *, cmap=None, colorbar=True, fig=None, ax=None):
+def plot_wigner_sphere(fig, ax, wigner, reflections):
     """Plots a coloured Bloch sphere.
 
     Parameters
@@ -116,12 +123,6 @@ def plot_wigner_sphere(wigner, reflections=True, *, cmap=None, colorbar=True, fi
     -----
     Special thanks to Russell P Rundle for writing this function.
     """
-
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-
-    if cmap is None:
-        cmap = _cmap()
-
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     ax.set_zlabel("z")
@@ -136,7 +137,7 @@ def plot_wigner_sphere(wigner, reflections=True, *, cmap=None, colorbar=True, fi
     wigner = np.real(wigner)
     wigner_max = np.real(np.amax(np.abs(wigner)))
 
-    wigner_c1 = cmap((wigner + wigner_max) / (2 * wigner_max))
+    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
 
     # Plot coloured Bloch sphere:
     ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
@@ -144,11 +145,11 @@ def plot_wigner_sphere(wigner, reflections=True, *, cmap=None, colorbar=True, fi
                     zorder=0.5, antialiased=None)
 
     if reflections:
-        wigner_c2 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
                                  (2*wigner_max))  # bottom
-        wigner_c3 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
                                  (2*wigner_max))  # side
-        wigner_c4 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
                                  (2*wigner_max))  # back
 
         # Plot bottom reflection:
@@ -173,16 +174,11 @@ def plot_wigner_sphere(wigner, reflections=True, *, cmap=None, colorbar=True, fi
                         antialiased=False)
 
     # Create colourbar:
-    if colorbar:
-        m = cm.ScalarMappable(cmap=cmap)
-        m.set_array([-wigner_max, wigner_max])
-        plt.colorbar(m, shrink=0.5, aspect=10)
-    else:
-        norm = mpl.colors.Normalize(-wigner_max, wigner_max)
-        cax, kw = mpl.colorbar.make_axes(ax)
-        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+    m = cm.ScalarMappable(cmap=cm.seismic_r)
+    m.set_array([-wigner_max, wigner_max])
+    plt.colorbar(m, shrink=0.5, aspect=10)
 
-    return fig, ax
+    plt.show()
 
 
 # Adopted from the SciPy Cookbook.
@@ -243,6 +239,7 @@ def hinton(rho, color_style="scaled", label_top=True, *,
     ----------
     rho : qobj
         Input density matrix or superoperator.
+
         NOTE: Hinton plots of superoperators are
         currently only supported for qubits.
 
@@ -359,7 +356,7 @@ def hinton(rho, color_style="scaled", label_top=True, *,
 
     # Set color_fn here.
     if cmap is None:
-        cmap = _cmap()
+        cmap = _diverging_cmap()
     if color_style == "scaled":
         def color_fn(w):
             w = np.abs(w) * np.sign(np.real(w))
@@ -448,7 +445,7 @@ def sphereplot(theta, phi, values, *, cmap=None, colorbar=True, fig=None, ax=Non
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     if cmap is None:
-        cmap = _cmap()
+        cmap = _sequential_cmap()
 
     thetam, phim = np.meshgrid(theta, phi)
     xx = sin(thetam) * cos(phim)
@@ -493,7 +490,7 @@ def _get_coord_info_new(renderer):
     axis._get_coord_info = _get_coord_info_new
 
 
-def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
+def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
     """
     truncates portion of a colormap and returns the new one
     """
@@ -508,7 +505,7 @@ def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
 
 def _stick_to_planes(stick, azim, ax, M, spacing):
     """adjusts xlim and ylim in way that bars will
-    Stick to xz and yz planes
+    stick to xz and yz planes
     """
     if stick is True:
         azim = azim % 360
@@ -572,8 +569,9 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
-                     colorbar=True, fig=None, ax=None, options=None):
+def matrix_histogram(M, zlims=None, bar_opts=None, *,
+                     xtickalbels=None, yticklabels=None, zticklables=None,
+                     cmap=None, colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -582,52 +580,45 @@ def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
     M : Matrix of Qobj
         The matrix to visualize
 
-    xlabels : list of strings
+    xticklabels : list of strings
         list of x labels
 
-    ylabels : list of strings
+    yticklabels : list of strings
         list of y labels
 
+    zticklabels : list of numbers
+        A list of z-axis tick locations.
+
     zlims : list/array with two float numbers
         The z-axis limits [min, max] (optional)
 
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
+    cmap : string (default: 'jet')
+        The name of the color map to use.
 
     colorbar : bool (default: True)
         show colorbar
 
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+
     options : dict
         A dictionary containing extra options for the plot.
         The names (keys) and values of the options are
         described below:
 
-        'zticks' : list of numbers
-            A list of z-axis tick locations.
-
-        'cmap' : string (default: 'jet')
-            The name of the color map to use.
-
-        'cmap_min' : float (default: 0.0)
-            The lower bound to truncate the color map at.
-            A value in range 0 - 1. The default, 0, leaves the lower
-            bound of the map unchanged.
-
-        'cmap_max' : float (default: 1.0)
-            The upper bound to truncate the color map at.
-            A value in range 0 - 1. The default, 1, leaves the upper
-            bound of the map unchanged.
-
-        'bars_spacing' : float (default: 0.1)
+        'spacing' : float (default: 0.1)
             spacing between bars.
 
-        'bars_alpha' : float (default: 1.)
+        'alpha' : float (default: 1.)
             transparency of bars, should be in range 0 - 1
 
-        'bars_lw' : float (default: 0.5)
+        'linewidth' : float (default: 0.5)
             linewidth of bars' edges.
 
-        'bars_edgecolor' : color (default: 'k')
+        'edgecolor' : color (default: 'k')
             The colors of the bars' edges.
             Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
 
@@ -635,21 +626,12 @@ def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
             Whether to shade the dark sides of the bars (True) or not (False).
             The shading is relative to plot's source of light.
 
-        'azim' : float
-            The azimuthal viewing angle.
-
-        'elev' : float
-            The elevation viewing angle.
-
-        'proj_type' : string (default: 'ortho' if ax is not passed)
-            The type of projection ('ortho' or 'persp')
-
         'stick' : bool (default: False)
             Changes xlim and ylim in such a way that bars next to
             XZ and YZ planes will stick to those planes.
             This option has no effect if ``ax`` is passed as a parameter.
 
-        'cbar_pad' : float (default: 0.04)
+        'pad' : float (default: 0.04)
             The fraction of the original axes between the colorbar
             and the new image axes.
             (i.e. the padding between the 3D figure and the colorbar).
@@ -658,9 +640,6 @@ def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
             Whether to set the color of maximum and minimum z-values to the
             maximum and minimum colors in the colorbar (True) or not (False).
 
-        'figsize' : tuple of two numbers
-            The size of the figure.
-
     Returns :
     -------
     fig, ax : tuple
@@ -675,24 +654,22 @@ def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
     """
 
     # default options
-    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
-                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
-                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-                    'shade': False, 'azim': -35, 'elev': 35,
-                    'proj_type': 'ortho', 'stick': False,
-                    'cbar_pad': 0.04, 'cbar_to_z': False}
+    default_opts = {'spacing': 0.2,
+                    'alpha': 1., 'linewidth': 0.5, 'edgecolor': 'k',
+                    'shade': False, 'stick': False,
+                    'pad': 0.04, 'cbar_to_z': False}
 
     # update default_opts from input options
-    if options is None:
+    if bar_opts is None:
         pass
-    elif isinstance(options, dict):
+    elif isinstance(bar_opts, dict):
         # check if keys in options dict are valid
-        if set(options) - set(default_opts):
+        if set(bar_opts) - set(default_opts):
             raise ValueError("invalid key(s) found in options: "
-                             f"{', '.join(set(options) - set(default_opts))}")
+                             f"{', '.join(set(bar_opts) - set(default_opts))}")
         else:
             # updating default options
-            default_opts.update(options)
+            default_opts.update(bar_opts)
     else:
         raise ValueError("options must be a dictionary")
 
@@ -705,7 +682,7 @@ def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
     xpos = xpos.T.flatten() + 0.5
     ypos = ypos.T.flatten() + 0.5
     zpos = np.zeros(n)
-    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
+    dx = dy = (1 - default_opts['spacing']) * np.ones(n)
     dz = np.real(M.flatten())
 
     if isinstance(zlims, list) and len(zlims) == 2:
@@ -722,45 +699,42 @@ def matrix_histogram(M, xlabels=None, ylabels=None, zlims=None,
         norm = mpl.colors.Normalize(min(dz), max(dz))
     else:
         norm = mpl.colors.Normalize(z_min, z_max)
-    cmap = _truncate_colormap(default_opts['cmap'],
-                              default_opts['cmap_min'],
-                              default_opts['cmap_max'])
+
+    if cmap is None:
+        cmap = _sequential_cmap()
+
     colors = cmap(norm(dz))
 
-    if ax is None:
-        fig = plt.figure(figsize=default_opts['figsize'])
-        ax = _axes3D(fig,
-                     azim=default_opts['azim'] % 360,
-                     elev=default_opts['elev'] % 360)
-        ax.set_proj_type(default_opts['proj_type'])
+    fig, ax = _is_fig_and_ax(fig, ax)
+    ax.view_init(azim=-35, elev=35)
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
-             edgecolors=default_opts['bars_edgecolor'],
-             linewidths=default_opts['bars_lw'],
-             alpha=default_opts['bars_alpha'],
+             edgecolors=default_opts['edgecolor'],
+             linewidths=default_opts['linewidth'],
+             alpha=default_opts['alpha'],
              shade=default_opts['shade'])
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
 
     # x axis
-    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
+    _update_xaxis(default_opts['spacing'], M, ax, xtickalbels)
 
     # y axis
-    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
+    _update_yaxis(default_opts['spacing'], M, ax, yticklabels)
 
     # z axis
-    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
+    _update_zaxis(ax, z_min, z_max, zticklables)
 
     # stick to xz and yz plane
     _stick_to_planes(default_opts['stick'],
                      default_opts['azim'], ax, M,
-                     default_opts['bars_spacing'])
+                     default_opts['spacing'])
 
     # color axis
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=default_opts['cbar_pad'])
+                                         pad=default_opts['pad'])
         mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
     # removing margins
@@ -1110,7 +1084,7 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     wlim = abs(W).max()
     norm = mpl.colors.Normalize(-wlim, wlim)
     if cmap is None:
-        cmap = _cmap()
+        cmap = _diverging_cmap()
 
     if projection == '2d':
         cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap)
@@ -1329,13 +1303,13 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
         fig, ax = _is_fig_and_ax(fig, ax, projection)
     else:
         raise ValueError('Unexpected value of projection keyword argument')
-
-    if P.min() < -1e12:
-        cmap = cm.RdBu
-        norm = mpl.colors.Normalize(-P.max(), P.max())
-    else:
-        cmap = cm.RdYlBu
-        norm = mpl.colors.Normalize(P.min(), P.max())
+    if cmap is None:
+        if P.min() < -1e12:
+            cmap = _diverging_cmap()
+            norm = mpl.colors.Normalize(-P.max(), P.max())
+        else:
+            cmap = _sequential_cmap()
+            norm = mpl.colors.Normalize(P.min(), P.max())
 
     if projection == '2d':
         Y = (THETA - pi / 2) / (pi / 2)
@@ -1559,6 +1533,8 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     especially with even number of particles of the same dimension.  Allows to
     see entanglement between first 2k particles and the rest.
 
+    NOTE: colorblind_safe does not apply because of its unique colormap
+
     Parameters
     ----------
     ket : Qobj
@@ -1721,6 +1697,8 @@ def plot_schmidt(ket, splitting=None, labels_iteration=(3, 2),
 
     See also: plot_qubism with how='before_after' for a similar plot.
 
+    NOTE: colorblind_safe does not apply because of its unique colormap
+
     Parameters
     ----------
     ket : Qobj

From ec7493694620334b1dbee2d4f99f154a2c1d6995 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 04:41:27 +0900
Subject: [PATCH 435/602] change the name of arguments to represent matrix
 basis

---
 qutip/visualization.py | 89 ++++++++++++++++++++----------------------
 1 file changed, 43 insertions(+), 46 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 57783cd7de..09f6f426c8 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -230,9 +230,8 @@ def _cb_labels(left_dims):
 
 
 # Adopted from the SciPy Cookbook.
-def hinton(rho, color_style="scaled", label_top=True, *,
-           xticklabels=None, yticklabels=None, cmap=None, colorbar=True,
-           fig=None, ax=None):
+def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
+           label_top=True, *, cmap=None, colorbar=True, fig=None, ax=None):
     """Draws a Hinton diagram for visualizing a density matrix or superoperator.
 
     Parameters
@@ -243,6 +242,12 @@ def hinton(rho, color_style="scaled", label_top=True, *,
         NOTE: Hinton plots of superoperators are
         currently only supported for qubits.
 
+    x_basis : list of strings or False
+        list of x ticklabels to represent x basis of the input.
+
+    y_basis : list of strings or False
+        list of y ticklabels to represent y basis of the input.
+
     color_style : string
         Determines how colors are assigned to each square:
 
@@ -260,12 +265,6 @@ def hinton(rho, color_style="scaled", label_top=True, *,
         If True, x ticklabels will be placed on top, otherwise
         they will appear below the plot.
 
-    xticklabels : list of strings or False
-        list of x ticklabels
-
-    yticklabels : list of strings or False
-        list of y ticklabels
-
     cmap : a matplotlib colormap instance
         Color map to use when plotting.
 
@@ -317,12 +316,12 @@ def hinton(rho, color_style="scaled", label_top=True, *,
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
             # Create default labels if none are given.
-            if xticklabels is None or yticklabels is None:
+            if x_basis is None or y_basis is None:
                 labels = _cb_labels(rho.dims[0])
-                if xticklabels is None:
-                    xticklabels = list(labels[0])
-                if yticklabels is None:
-                    yticklabels = list(labels[1])
+                if x_basis is None:
+                    x_basis = list(labels[0])
+                if y_basis is None:
+                    y_basis = list(labels[1])
 
         elif rho.issuper:
             if not isqubitdims(rho.dims):
@@ -334,12 +333,12 @@ def hinton(rho, color_style="scaled", label_top=True, *,
             nq = int(log2(sqobj.shape[0]) / 2)
             W = sqobj.full().T
             # Create default labels, too.
-            if (xticklabels is None) or (yticklabels is None):
+            if (x_basis is None) or (y_basis is None):
                 labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                if xticklabels is None:
-                    xticklabels = labels
-                if yticklabels is None:
-                    yticklabels = labels
+                if x_basis is None:
+                    x_basis = labels
+                if y_basis is None:
+                    y_basis = labels
 
         else:
             raise ValueError(
@@ -390,22 +389,22 @@ def color_fn(w):
         mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
     # axis
-    if not (xticklabels or yticklabels):
+    if not (x_basis or y_basis):
         ax.axis('off')
     ax.axis('equal')
     ax.set_frame_on(False)
 
     # x axis
     xticks = 0.5 + np.arange(width)
-    if xticklabels:
-        _set_ticklabels(ax, xticklabels, xticks, 'x')
+    if x_basis:
+        _set_ticklabels(ax, x_basis, xticks, 'x')
     if label_top:
         ax.xaxis.tick_top()
 
     # y axis
     yticks = 0.5 + np.arange(height)
-    if yticklabels:
-        _set_ticklabels(ax, list(reversed(yticklabels)), yticks, 'y')
+    if y_basis:
+        _set_ticklabels(ax, list(reversed(y_basis)), yticks, 'y')
 
     return fig, ax
 
@@ -569,9 +568,8 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, zlims=None, bar_opts=None, *,
-                     xtickalbels=None, yticklabels=None, zticklables=None,
-                     cmap=None, colorbar=True, fig=None, ax=None):
+def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None,
+                     bar_opts=None, *, cmap=None, colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -580,11 +578,11 @@ def matrix_histogram(M, zlims=None, bar_opts=None, *,
     M : Matrix of Qobj
         The matrix to visualize
 
-    xticklabels : list of strings
-        list of x labels
+    x_basis : list of strings or False
+        list of x ticklabels to represent x basis of the input.
 
-    yticklabels : list of strings
-        list of y labels
+    y_basis : list of strings or False
+        list of y ticklabels to represent y basis of the input.
 
     zticklabels : list of numbers
         A list of z-axis tick locations.
@@ -718,10 +716,10 @@ def matrix_histogram(M, zlims=None, bar_opts=None, *,
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
 
     # x axis
-    _update_xaxis(default_opts['spacing'], M, ax, xtickalbels)
+    _update_xaxis(default_opts['spacing'], M, ax, x_basis)
 
     # y axis
-    _update_yaxis(default_opts['spacing'], M, ax, yticklabels)
+    _update_yaxis(default_opts['spacing'], M, ax, y_basis)
 
     # z axis
     _update_zaxis(ax, z_min, z_max, zticklables)
@@ -745,9 +743,8 @@ def matrix_histogram(M, zlims=None, bar_opts=None, *,
     return fig, ax
 
 
-def matrix_histogram_complex(M, phase_limits=None, threshold=None, zlims=None, *,
-                             xticklabels=None, yticklabels=None, cmap=None,
-                             colorbar=True, fig=None, ax=None):
+def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None, threshold=None,
+                             zlims=None, *, cmap=None, colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -758,6 +755,12 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, zlims=None, *
     M : Matrix of Qobj
         The matrix to visualize
 
+    x_basis : list of strings or False
+        list of x ticklabels to represent x basis of the input.
+
+    y_basis : list of strings or False
+        list of y ticklabels to represent y basis of the input.
+
     phase_limits : list/array with two float numbers
         The phase-axis (colorbar) limits [min, max] (optional)
 
@@ -768,12 +771,6 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, zlims=None, *
     zlims : list/array with two float numbers
         The z-axis limits [min, max] (optional)
 
-    xticklabels : list of strings
-        list of x ticklabels
-
-    yticklabels : list of strings
-        list of y ticklabels
-
     cmap : a matplotlib colormap instance
         Color map to use when plotting.
 
@@ -839,16 +836,16 @@ def matrix_histogram_complex(M, phase_limits=None, threshold=None, zlims=None, *
 
     # x axis
     xticks = -0.5 + np.arange(M.shape[0])
-    if xticklabels:
-        _set_ticklabels(ax, xticklabels, xticks, 'x')
+    if x_basis:
+        _set_ticklabels(ax, x_basis, xticks, 'x')
     else:
         ax.tick_params(axis='x', which='both',
                          bottom=False, labelbottom=False)
 
     # y axis
     yticks = -0.5 + np.arange(M.shape[1])
-    if yticklabels:
-        _set_ticklabels(ax, yticklabels, yticks, 'y')
+    if y_basis:
+        _set_ticklabels(ax, y_basis, yticks, 'y')
     else:
         ax.tick_params(axis='y', which='both', left=False, labelleft=False)
 

From 8fddbf12ed00497f18bbee97f7c3dbfa47be82a0 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 04:43:54 +0900
Subject: [PATCH 436/602] change the name of arguments to represent matrix
 basis

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 09f6f426c8..34741df6ed 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -638,7 +638,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
             Whether to set the color of maximum and minimum z-values to the
             maximum and minimum colors in the colorbar (True) or not (False).
 
-    Returns :
+    Returns
     -------
     fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce

From 459f9ce47f0769cd0aa6b39bcbc311071e5597b9 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 05:13:31 +0900
Subject: [PATCH 437/602] add projection

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 34741df6ed..3fa0d4f403 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -703,7 +703,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
 
     colors = cmap(norm(dz))
 
-    fig, ax = _is_fig_and_ax(fig, ax)
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
     ax.view_init(azim=-35, elev=35)
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,

From 7fbdd767e973df547b774da8602d1047f5ee9cea Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 05:55:57 +0900
Subject: [PATCH 438/602] add azim and elev

---
 qutip/visualization.py | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 3fa0d4f403..f4ebbf5085 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -569,7 +569,7 @@ def _update_zaxis(ax, z_min, z_max, zticks):
 
 
 def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None,
-                     bar_opts=None, *, cmap=None, colorbar=True, fig=None, ax=None):
+                     options=None, *, cmap=None, colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -607,6 +607,12 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
         The names (keys) and values of the options are
         described below:
 
+        'azim' : float
+            The azimuthal viewing angle.
+
+        'elev' : float
+            The elevation viewing angle.
+
         'spacing' : float (default: 0.1)
             spacing between bars.
 
@@ -652,22 +658,22 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
     """
 
     # default options
-    default_opts = {'spacing': 0.2,
+    default_opts = {'azim': -35, 'elev': 35, 'spacing': 0.2,
                     'alpha': 1., 'linewidth': 0.5, 'edgecolor': 'k',
                     'shade': False, 'stick': False,
                     'pad': 0.04, 'cbar_to_z': False}
 
     # update default_opts from input options
-    if bar_opts is None:
+    if options is None:
         pass
-    elif isinstance(bar_opts, dict):
+    elif isinstance(options, dict):
         # check if keys in options dict are valid
-        if set(bar_opts) - set(default_opts):
+        if set(options) - set(default_opts):
             raise ValueError("invalid key(s) found in options: "
-                             f"{', '.join(set(bar_opts) - set(default_opts))}")
+                             f"{', '.join(set(options) - set(default_opts))}")
         else:
             # updating default options
-            default_opts.update(bar_opts)
+            default_opts.update(options)
     else:
         raise ValueError("options must be a dictionary")
 
@@ -704,7 +710,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
     colors = cmap(norm(dz))
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-    ax.view_init(azim=-35, elev=35)
+    ax.view_init(azim=default_opts['azim'] % 360, elev=default_opts['elev'] % 360)
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
              edgecolors=default_opts['edgecolor'],

From 5e653d0a272a85a4fc301d72d8b04a4323a0f754 Mon Sep 17 00:00:00 2001
From: SJUW <114626049+SJUW@users.noreply.github.com>
Date: Mon, 26 Jun 2023 13:59:44 +1000
Subject: [PATCH 439/602] matrix_histogram_complex() colorbar pad to 0.05

Increase missing colorbar padding for matrix_histogram_complex() from 0 to 0.05.
---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 10295d2968..758c87e21e 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -842,7 +842,7 @@ def matrix_histogram_complex(M, xlabels=None, ylabels=None,
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.05)
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
         cb.set_ticklabels(

From 02bf1959f2b79e552ca0832213f226e37393c779 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 13:48:47 +0900
Subject: [PATCH 440/602] pep8

---
 qutip/visualization.py | 42 +++++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index f4ebbf5085..51989f897f 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -409,7 +409,8 @@ def color_fn(w):
     return fig, ax
 
 
-def sphereplot(theta, phi, values, *, cmap=None, colorbar=True, fig=None, ax=None):
+def sphereplot(theta, phi, values, *,
+               cmap=None, colorbar=True, fig=None, ax=None):
     """Plots a matrix of values on a sphere
 
     Parameters
@@ -464,7 +465,7 @@ def sphereplot(theta, phi, values, *, cmap=None, colorbar=True, fig=None, ax=Non
         # pad shifts location of bar with repsect to the main plot
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
 
-        # create new colorbar in axes cax with cm jet and normalized to nrm like
+        # create new colorbar in axes cax with cmap and normalized to nrm like
         # our facecolors
         cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         # add our colorbar label
@@ -568,8 +569,9 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None,
-                     options=None, *, cmap=None, colorbar=True, fig=None, ax=None):
+def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
+                     zlims=None, options=None, *, cmap=None,
+                     colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -710,7 +712,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
     colors = cmap(norm(dz))
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-    ax.view_init(azim=default_opts['azim'] % 360, elev=default_opts['elev'] % 360)
+    ax.view_init(azim=default_opts['azim'] % 360,
+                 elev=default_opts['elev'] % 360)
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
              edgecolors=default_opts['edgecolor'],
@@ -749,8 +752,9 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None, zlims=None
     return fig, ax
 
 
-def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None, threshold=None,
-                             zlims=None, *, cmap=None, colorbar=True, fig=None, ax=None):
+def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
+                             threshold=None, zlims=None, *, cmap=None,
+                             colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -846,7 +850,7 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None, t
         _set_ticklabels(ax, x_basis, xticks, 'x')
     else:
         ax.tick_params(axis='x', which='both',
-                         bottom=False, labelbottom=False)
+                       bottom=False, labelbottom=False)
 
     # y axis
     yticks = -0.5 + np.arange(M.shape[1])
@@ -978,7 +982,8 @@ def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
     return plot_energy_levels(H_list, N=N, fig=fig, ax=ax)
 
 
-def plot_fock_distribution(rho, offset=0, unit_y_range=True, *, fig=None, ax=None):
+def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
+                           fig=None, ax=None):
     """
     Plot the Fock distribution for a density matrix (or ket) that describes
     an oscillator mode.
@@ -1071,7 +1076,7 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
         the figure.
     """
 
-    if projection in ('2d','3d'):
+    if projection in ('2d', '3d'):
         fig, ax = _is_fig_and_ax(fig, ax, projection)
     else:
         raise ValueError('Unexpected value of projection keyword argument')
@@ -1167,19 +1172,21 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
                     fig.add_subplot(1, 2, 2)]
         elif projection == '3d':
             axes = [fig.add_subplot(1, 2, 1),
-                fig.add_subplot(1, 2, 2, projection=projection)]
+                    fig.add_subplot(1, 2, 2, projection=projection)]
         else:
             raise ValueError("Unexpected value of projection keyword argument")
     else:
         if not isinstance(axes, list) or len(axes) != 2:
-            raise ValueError("axes must be a list of two matplotlib axes instances")
+            raise ValueError(
+                "axes must be a list of two matplotlib axes instances"
+                )
 
     if isket(rho):
         rho = ket2dm(rho)
 
     plot_fock_distribution(rho, fig=fig, ax=axes[0])
     plot_wigner(rho, alpha_max=alpha_max, method=method, projection=projection,
-                 cmap=cmap, colorbar=colorbar, fig=fig, ax=axes[1])
+                cmap=cmap, colorbar=colorbar, fig=fig, ax=axes[1])
 
     return fig, axes
 
@@ -1233,13 +1240,13 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
     if fig is None:
         if axes is None:
             fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
-                                    figsize=(12, 3 * n_e_ops), squeeze=False)
+                                     figsize=(12, 3 * n_e_ops), squeeze=False)
         else:
             raise ValueError('figure object is necessary')
     else:
         if axes is None:
-                axes = np.array([[fig.add_subplot(n_e_ops, 1, i+1)]
-                                 for i in range(n_e_ops)])
+            axes = np.array([[fig.add_subplot(n_e_ops, 1, i+1)]
+                             for i in range(n_e_ops)])
         else:
             if not isinstance(axes, list):
                 axes = [axes]
@@ -1352,7 +1359,8 @@ def plot_spin_distribution_2d(P, THETA, PHI,
 def plot_spin_distribution_3d(P, THETA, PHI,
                               fig=None, ax=None, figsize=(8, 6)):
     warnings.warn("Deprecated: Use plot_spin_distribution")
-    return plot_spin_distribution(P, THETA, PHI, projection='3d', fig=fig, ax=ax)
+    return plot_spin_distribution(P, THETA, PHI, projection='3d',
+                                  fig=fig, ax=ax)
 
 
 #

From f40e18a9c916a4909e6cf11d7c80826e3d7e5cef Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 26 Jun 2023 14:04:12 +0900
Subject: [PATCH 441/602] pep8

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 51989f897f..7025686b89 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -971,7 +971,7 @@ def plot_energy_levels(H_list, N=0, hamiltonians=None, energy_levels=None, *,
     else:
         # hide xtick
         ax.tick_params(axis='x', which='both',
-                         bottom=False, labelbottom=False)
+                       bottom=False, labelbottom=False)
 
     return fig, ax
 

From 79554626c518c1f98c3b6a4e26e635ceb3a4f99a Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 27 Jun 2023 07:08:31 +0900
Subject: [PATCH 442/602] revert change to matrix_histogram to make PR
 mergiable

---
 doc/guide/guide-visualization.rst |   2 +-
 qutip/visualization.py            | 143 ++++++++++++++++--------------
 2 files changed, 77 insertions(+), 68 deletions(-)

diff --git a/doc/guide/guide-visualization.rst b/doc/guide/guide-visualization.rst
index 8b183ad3b1..6bfab3f4b8 100644
--- a/doc/guide/guide-visualization.rst
+++ b/doc/guide/guide-visualization.rst
@@ -312,7 +312,7 @@ let's visualize of the Jaynes-Cummings Hamiltonian:
     for inds in tomography._index_permutations([len(lbls) for lbls in lbls_list]):
        xlabels.append("".join([lbls_list[k][inds[k]] for k in range(len(lbls_list))]))
 
-    fig, ax = matrix_histogram(H, xlabels, xlabels, zlims=[-4,4])
+    fig, ax = matrix_histogram(H, xlabels, xlabels, limits=[-4,4])
 
     ax.view_init(azim=-55, elev=45)
 
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 7025686b89..387ba7de4d 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -490,19 +490,6 @@ def _get_coord_info_new(renderer):
     axis._get_coord_info = _get_coord_info_new
 
 
-def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
-    """
-    truncates portion of a colormap and returns the new one
-    """
-    if isinstance(cmap, str):
-        cmap = plt.get_cmap(cmap)
-    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
-        'trunc({n},{a:.2f},{b:.2f})'.format(
-            n=cmap.name, a=minval, b=maxval),
-        cmap(np.linspace(minval, maxval, n)))
-    return new_cmap
-
-
 def _stick_to_planes(stick, azim, ax, M, spacing):
     """adjusts xlim and ylim in way that bars will
     stick to xz and yz planes
@@ -569,9 +556,8 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
-                     zlims=None, options=None, *, cmap=None,
-                     colorbar=True, fig=None, ax=None):
+def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
+                     colorbar=True, fig=None, ax=None, options=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -580,51 +566,55 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
     M : Matrix of Qobj
         The matrix to visualize
 
-    x_basis : list of strings or False
-        list of x ticklabels to represent x basis of the input.
+    xlabels : list of strings
+        list of x labels
 
-    y_basis : list of strings or False
-        list of y ticklabels to represent y basis of the input.
+    ylabels : list of strings
+        list of y labels
 
-    zticklabels : list of numbers
-        A list of z-axis tick locations.
+    title : string
+        title of the plot (optional)
 
-    zlims : list/array with two float numbers
+    limits : list/array with two float numbers
         The z-axis limits [min, max] (optional)
 
-    cmap : string (default: 'jet')
-        The name of the color map to use.
-
-    colorbar : bool (default: True)
-        show colorbar
-
     ax : a matplotlib axes instance
         The axes context in which the plot will be drawn.
 
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
+    colorbar : bool (default: True)
+        show colorbar
 
     options : dict
         A dictionary containing extra options for the plot.
         The names (keys) and values of the options are
         described below:
 
-        'azim' : float
-            The azimuthal viewing angle.
+        'zticks' : list of numbers
+            A list of z-axis tick locations.
 
-        'elev' : float
-            The elevation viewing angle.
+        'cmap' : string (default: 'jet')
+            The name of the color map to use.
+
+        'cmap_min' : float (default: 0.0)
+            The lower bound to truncate the color map at.
+            A value in range 0 - 1. The default, 0, leaves the lower
+            bound of the map unchanged.
+
+        'cmap_max' : float (default: 1.0)
+            The upper bound to truncate the color map at.
+            A value in range 0 - 1. The default, 1, leaves the upper
+            bound of the map unchanged.
 
-        'spacing' : float (default: 0.1)
+        'bars_spacing' : float (default: 0.1)
             spacing between bars.
 
-        'alpha' : float (default: 1.)
+        'bars_alpha' : float (default: 1.)
             transparency of bars, should be in range 0 - 1
 
-        'linewidth' : float (default: 0.5)
+        'bars_lw' : float (default: 0.5)
             linewidth of bars' edges.
 
-        'edgecolor' : color (default: 'k')
+        'bars_edgecolor' : color (default: 'k')
             The colors of the bars' edges.
             Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
 
@@ -632,12 +622,21 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
             Whether to shade the dark sides of the bars (True) or not (False).
             The shading is relative to plot's source of light.
 
+        'azim' : float
+            The azimuthal viewing angle.
+
+        'elev' : float
+            The elevation viewing angle.
+
+        'proj_type' : string (default: 'ortho' if ax is not passed)
+            The type of projection ('ortho' or 'persp')
+
         'stick' : bool (default: False)
             Changes xlim and ylim in such a way that bars next to
             XZ and YZ planes will stick to those planes.
             This option has no effect if ``ax`` is passed as a parameter.
 
-        'pad' : float (default: 0.04)
+        'cbar_pad' : float (default: 0.04)
             The fraction of the original axes between the colorbar
             and the new image axes.
             (i.e. the padding between the 3D figure and the colorbar).
@@ -646,6 +645,9 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
             Whether to set the color of maximum and minimum z-values to the
             maximum and minimum colors in the colorbar (True) or not (False).
 
+        'figsize' : tuple of two numbers
+            The size of the figure.
+
     Returns
     -------
     fig, ax : tuple
@@ -660,10 +662,12 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
     """
 
     # default options
-    default_opts = {'azim': -35, 'elev': 35, 'spacing': 0.2,
-                    'alpha': 1., 'linewidth': 0.5, 'edgecolor': 'k',
-                    'shade': False, 'stick': False,
-                    'pad': 0.04, 'cbar_to_z': False}
+    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
+                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
+                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
+                    'shade': False, 'azim': -35, 'elev': 35,
+                    'proj_type': 'ortho', 'stick': False,
+                    'cbar_pad': 0.04, 'cbar_to_z': False}
 
     # update default_opts from input options
     if options is None:
@@ -688,12 +692,12 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
     xpos = xpos.T.flatten() + 0.5
     ypos = ypos.T.flatten() + 0.5
     zpos = np.zeros(n)
-    dx = dy = (1 - default_opts['spacing']) * np.ones(n)
+    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
     dz = np.real(M.flatten())
 
-    if isinstance(zlims, list) and len(zlims) == 2:
-        z_min = zlims[0]
-        z_max = zlims[1]
+    if isinstance(limits, list) and len(limits) == 2:
+        z_min = limits[0]
+        z_max = limits[1]
     else:
         z_min = min(dz)
         z_max = max(dz)
@@ -705,43 +709,48 @@ def matrix_histogram(M, x_basis=None, y_basis=None, zticklables=None,
         norm = mpl.colors.Normalize(min(dz), max(dz))
     else:
         norm = mpl.colors.Normalize(z_min, z_max)
-
-    if cmap is None:
-        cmap = _sequential_cmap()
-
+    cmap = _truncate_colormap(default_opts['cmap'],
+                              default_opts['cmap_min'],
+                              default_opts['cmap_max'])
     colors = cmap(norm(dz))
 
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-    ax.view_init(azim=default_opts['azim'] % 360,
-                 elev=default_opts['elev'] % 360)
+    if ax is None:
+        fig = plt.figure(figsize=default_opts['figsize'])
+        ax = _axes3D(fig,
+                     azim=default_opts['azim'] % 360,
+                     elev=default_opts['elev'] % 360)
+        ax.set_proj_type(default_opts['proj_type'])
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
-             edgecolors=default_opts['edgecolor'],
-             linewidths=default_opts['linewidth'],
-             alpha=default_opts['alpha'],
+             edgecolors=default_opts['bars_edgecolor'],
+             linewidths=default_opts['bars_lw'],
+             alpha=default_opts['bars_alpha'],
              shade=default_opts['shade'])
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
 
+    if title:
+        ax.set_title(title)
+
     # x axis
-    _update_xaxis(default_opts['spacing'], M, ax, x_basis)
+    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
 
     # y axis
-    _update_yaxis(default_opts['spacing'], M, ax, y_basis)
+    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
 
     # z axis
-    _update_zaxis(ax, z_min, z_max, zticklables)
+    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
 
     # stick to xz and yz plane
     _stick_to_planes(default_opts['stick'],
                      default_opts['azim'], ax, M,
-                     default_opts['spacing'])
+                     default_opts['bars_spacing'])
 
     # color axis
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=default_opts['pad'])
+                                         pad=default_opts['cbar_pad'])
         mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
     # removing margins
@@ -877,7 +886,7 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
     return fig, ax
 
 
-def plot_energy_levels(H_list, N=0, hamiltonians=None, energy_levels=None, *,
+def plot_energy_levels(H_list, N=0, h_labels=None, energy_levels=None, *,
                        fig=None, ax=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
@@ -894,7 +903,7 @@ def plot_energy_levels(H_list, N=0, hamiltonians=None, energy_levels=None, *,
         N : int
             The number of energy levels to plot
 
-        hamiltonians : List of string
+        h_lables : List of string
             A list of xticklabels for each Hamiltonian
 
         energy_levels : List of string
@@ -965,9 +974,9 @@ def plot_energy_levels(H_list, N=0, hamiltonians=None, energy_levels=None, *,
         yticks = np.unique(np.around(yticks, 1))
         ax.set_yticks(yticks)
 
-    if hamiltonians:
+    if h_labels:
         ax.get_xaxis().tick_bottom()
-        _set_ticklabels(ax, hamiltonians, xticks, 'x')
+        _set_ticklabels(ax, h_labels, xticks, 'x')
     else:
         # hide xtick
         ax.tick_params(axis='x', which='both',

From 9f4c0e4d9b97e0879f155472dcbc031bd7e855d1 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 27 Jun 2023 07:31:58 +0900
Subject: [PATCH 443/602] bugfix

---
 qutip/visualization.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 387ba7de4d..0ad5c4c543 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -490,6 +490,19 @@ def _get_coord_info_new(renderer):
     axis._get_coord_info = _get_coord_info_new
 
 
+def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
+    """
+    truncates portion of a colormap and returns the new one
+    """
+    if isinstance(cmap, str):
+        cmap = plt.get_cmap(cmap)
+    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
+        'trunc({n},{a:.2f},{b:.2f})'.format(
+            n=cmap.name, a=minval, b=maxval),
+        cmap(np.linspace(minval, maxval, n)))
+    return new_cmap
+
+
 def _stick_to_planes(stick, azim, ax, M, spacing):
     """adjusts xlim and ylim in way that bars will
     stick to xz and yz planes

From b724b6e3d9d68fdb29768846e82d1b5939d4a263 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 27 Jun 2023 10:28:14 +0900
Subject: [PATCH 444/602] edit docstring and sort arguments

---
 qutip/visualization.py | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 0ad5c4c543..aa51b63d2a 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -47,11 +47,11 @@ def _axes3D(*args, **kwargs):
     pass
 
 
-def _sequential_cmap():
+def _cyclic_cmap():
     if settings.colorblind_safe:
-        return cm.cividis
+        return cm.twilight
     else:
-        return cm.jet
+        return complex_phase_cmap()
 
 
 def _diverging_cmap():
@@ -61,11 +61,11 @@ def _diverging_cmap():
         return cm.RdBu
 
 
-def _cyclic_cmap():
+def _sequential_cmap():
     if settings.colorblind_safe:
-        return cm.twilight
+        return cm.cividis
     else:
-        return complex_phase_cmap()
+        return cm.jet
 
 
 def _is_fig_and_ax(fig, ax, projection='2d'):
@@ -899,7 +899,7 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
     return fig, ax
 
 
-def plot_energy_levels(H_list, N=0, h_labels=None, energy_levels=None, *,
+def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
                        fig=None, ax=None):
     """
     Plot the energy level diagrams for a list of Hamiltonians. Include
@@ -913,9 +913,6 @@ def plot_energy_levels(H_list, N=0, h_labels=None, energy_levels=None, *,
         H_list : List of Qobj
             A list of Hamiltonians.
 
-        N : int
-            The number of energy levels to plot
-
         h_lables : List of string
             A list of xticklabels for each Hamiltonian
 
@@ -923,6 +920,9 @@ def plot_energy_levels(H_list, N=0, h_labels=None, energy_levels=None, *,
             A list of  yticklabels to the left of energy levels of the initial
             Hamiltonian.
 
+        N : int
+            The number of energy levels to plot
+
         fig : a matplotlib Figure instance
             The Figure canvas in which the plot will be drawn.
 
@@ -1018,6 +1018,9 @@ def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
     offset : int
         Offset the fock number
 
+    unit_y_range : bool
+        Set y-axis limits [0, 1] or not
+
     fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
 
@@ -1174,10 +1177,6 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
     axes : a list of two matplotlib axes instances
         The axes context in which the plot will be drawn.
 
-    method : string {'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
     Returns
     -------
     fig, axes : tuple

From e07d26cc2443f5ade4d9db7a5a929410a9102cad Mon Sep 17 00:00:00 2001
From: SJUW <114626049+SJUW@users.noreply.github.com>
Date: Thu, 29 Jun 2023 09:17:25 +1000
Subject: [PATCH 445/602] Create 2181.bugfix

---
 doc/changes/2181.bugfix | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2181.bugfix

diff --git a/doc/changes/2181.bugfix b/doc/changes/2181.bugfix
new file mode 100644
index 0000000000..5beb8f3024
--- /dev/null
+++ b/doc/changes/2181.bugfix
@@ -0,0 +1 @@
+Increase missing colorbar padding for matrix_histogram_complex() from 0 to 0.05.

From e9c17033a5aefda99394ad8ef712be505ce9a791 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 30 Jun 2023 19:36:49 +0900
Subject: [PATCH 446/602] delete zlim option in matrix_histogram_complex to
 follow pep8

---
 qutip/visualization.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index aa51b63d2a..58df092e9e 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -775,8 +775,8 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
 
 
 def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
-                             threshold=None, zlims=None, *, cmap=None,
-                             colorbar=True, fig=None, ax=None):
+                             threshold=None, *, cmap=None, colorbar=True,
+                             fig=None, ax=None):
     """
     Draw a histogram for the amplitudes of matrix M, using the argument
     of each element for coloring the bars, with the given x and y labels
@@ -800,9 +800,6 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
         Threshold for when bars of smaller height should be transparent. If
         not set, all bars are colored according to the color map.
 
-    zlims : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
-
     cmap : a matplotlib colormap instance
         Color map to use when plotting.
 
@@ -881,15 +878,12 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
     else:
         ax.tick_params(axis='y', which='both', left=False, labelleft=False)
 
-    # z axis
-    if isinstance(zlims, list):
-        ax.set_zlim3d(zlims)
-    else:
-        ax.set_zlim3d([0, 1])
+    # limit z axis by default
+    ax.set_zlim3d([0, max(max(dz), 1)])
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.05)
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
         cb.set_ticklabels(

From 21fa48bdbfaed084c59a9106602081589312e1ff Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 30 Jun 2023 19:55:47 +0900
Subject: [PATCH 447/602] change note format

---
 qutip/visualization.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 58df092e9e..ae04e418c5 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -239,8 +239,9 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
     rho : qobj
         Input density matrix or superoperator.
 
-        NOTE: Hinton plots of superoperators are
-        currently only supported for qubits.
+    .. note::
+
+        Hinton plots of superoperators are currently only supported for qubits.
 
     x_basis : list of strings or False
         list of x ticklabels to represent x basis of the input.
@@ -1559,7 +1560,9 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     especially with even number of particles of the same dimension.  Allows to
     see entanglement between first 2k particles and the rest.
 
-    NOTE: colorblind_safe does not apply because of its unique colormap
+    .. note::
+
+        colorblind_safe does not apply because of its unique colormap
 
     Parameters
     ----------
@@ -1723,7 +1726,9 @@ def plot_schmidt(ket, splitting=None, labels_iteration=(3, 2),
 
     See also: plot_qubism with how='before_after' for a similar plot.
 
-    NOTE: colorblind_safe does not apply because of its unique colormap
+    .. note::
+
+        colorblind_safe does not apply because of its unique colormap
 
     Parameters
     ----------

From 1dabc310d66a3a31528444ecc1a7f6e9f513bec6 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 30 Jun 2023 21:06:19 +0900
Subject: [PATCH 448/602] fix bugs when the size of axes varies

---
 qutip/visualization.py | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index ae04e418c5..f7b8807004 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1255,33 +1255,34 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
 
     if fig is None:
         if axes is None:
-            fig, axes = plt.subplots(n_e_ops, 1, sharex=True,
-                                     figsize=(12, 3 * n_e_ops), squeeze=False)
+            fig, axes = plt.subplots(n_e_ops, 1, sharex=True)
         else:
             raise ValueError('figure object is necessary')
     else:
         if axes is None:
-            axes = np.array([[fig.add_subplot(n_e_ops, 1, i+1)]
+            axes = np.array([fig.add_subplot(n_e_ops, 1, i+1)
                              for i in range(n_e_ops)])
-        else:
-            if not isinstance(axes, list):
-                axes = [axes]
-            axes = np.array(axes)
+
+    # create np.ndarray if axes is one axes object or list
+    if not isinstance(axes, np.ndarray):
+        if not isinstance(axes, list):
+            axes = [axes]
+        axes = np.array(axes)
 
     for r_idx, result in enumerate(results):
         for e_idx, e in enumerate(result.expect):
-            axes[e_idx, 0].plot(result.times, e,
+            axes[e_idx].plot(result.times, e,
                                 label="%s [%d]" % (result.solver, e_idx))
 
     if title:
         fig.suptitle(title)
 
-    axes[n_e_ops - 1, 0].set_xlabel("time", fontsize=12)
+    axes[n_e_ops - 1].set_xlabel("time", fontsize=12)
     for n in range(n_e_ops):
         if ylabels:
-            axes[n, 0].set_ylabel(ylabels[n], fontsize=12)
+            axes[n].set_ylabel(ylabels[n], fontsize=12)
 
-    return fig, axes.tolist()
+    return fig, axes
 
 
 def plot_spin_distribution(P, THETA, PHI, projection='2d', *,

From c372c75ff0ba39382384b5fea0502b30f3447eb8 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 30 Jun 2023 21:25:42 +0900
Subject: [PATCH 449/602] pep8

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index f7b8807004..a82c2baab4 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1272,7 +1272,7 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
     for r_idx, result in enumerate(results):
         for e_idx, e in enumerate(result.expect):
             axes[e_idx].plot(result.times, e,
-                                label="%s [%d]" % (result.solver, e_idx))
+                             label="%s [%d]" % (result.solver, e_idx))
 
     if title:
         fig.suptitle(title)

From 60ea3d36f02fa59225c7cd807b2fa9951961bf35 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 30 Jun 2023 22:05:35 +0900
Subject: [PATCH 450/602] fig, axes objects

---
 qutip/visualization.py | 39 +++++++++++++++++----------------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index a82c2baab4..5064618997 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1175,27 +1175,26 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
     Returns
     -------
     fig, axes : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
+        A tuple of the matplotlib figure and array of axes objects used to produce
         the figure.
     """
-    if fig is None and axes is not None:
-        raise ValueError("figure object is neccessary")
-    if fig is None:
-        fig = plt.figure()
     if axes is None:
+        if fig is None:
+            fig = plt.figure()
         if projection == '2d':
-            axes = [fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2)]
+            axes = np.array([fig.add_subplot(1, 2, 1),
+                    fig.add_subplot(1, 2, 2)])
         elif projection == '3d':
-            axes = [fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2, projection=projection)]
+            axes = np.array([fig.add_subplot(1, 2, 1),
+                    fig.add_subplot(1, 2, 2, projection=projection)])
         else:
-            raise ValueError("Unexpected value of projection keyword argument")
-    else:
-        if not isinstance(axes, list) or len(axes) != 2:
             raise ValueError(
-                "axes must be a list of two matplotlib axes instances"
+                "Unexpected value of projection keyword argument"
                 )
+    if not isinstance(axes, np.ndarray) or len(axes) != 2:
+        raise ValueError(
+            "axes must be a np.array of two matplotlib axes instances"
+            )
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1253,15 +1252,11 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
 
     n_e_ops = max([len(result.expect) for result in results])
 
-    if fig is None:
-        if axes is None:
-            fig, axes = plt.subplots(n_e_ops, 1, sharex=True)
-        else:
-            raise ValueError('figure object is necessary')
-    else:
-        if axes is None:
-            axes = np.array([fig.add_subplot(n_e_ops, 1, i+1)
-                             for i in range(n_e_ops)])
+    if axes is None:
+        if fig is None:
+            fig = plt.figure()
+        axes = np.array([fig.add_subplot(n_e_ops, 1, i+1)
+                            for i in range(n_e_ops)])
 
     # create np.ndarray if axes is one axes object or list
     if not isinstance(axes, np.ndarray):

From b2b78801c3fe4bb43d650982a04e58413d349f7b Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 30 Jun 2023 22:14:10 +0900
Subject: [PATCH 451/602] pep8

---
 qutip/visualization.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 5064618997..a65453a8a3 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1175,18 +1175,18 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
     Returns
     -------
     fig, axes : tuple
-        A tuple of the matplotlib figure and array of axes objects used to produce
-        the figure.
+        A tuple of the matplotlib figure and array of axes objects
+        used to produce the figure.
     """
     if axes is None:
         if fig is None:
             fig = plt.figure()
         if projection == '2d':
             axes = np.array([fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2)])
+                             fig.add_subplot(1, 2, 2)])
         elif projection == '3d':
             axes = np.array([fig.add_subplot(1, 2, 1),
-                    fig.add_subplot(1, 2, 2, projection=projection)])
+                             fig.add_subplot(1, 2, 2, projection='3d')])
         else:
             raise ValueError(
                 "Unexpected value of projection keyword argument"
@@ -1244,8 +1244,8 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
     Returns
     -------
     fig, axes : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+        A tuple of the matplotlib figure and array of axes instances
+        used to produce the figure.
     """
     if not isinstance(results, list):
         results = [results]
@@ -1256,7 +1256,7 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
         if fig is None:
             fig = plt.figure()
         axes = np.array([fig.add_subplot(n_e_ops, 1, i+1)
-                            for i in range(n_e_ops)])
+                         for i in range(n_e_ops)])
 
     # create np.ndarray if axes is one axes object or list
     if not isinstance(axes, np.ndarray):

From 047f30cbabcb7531d605a2930cb610bf186635c9 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Mon, 3 Jul 2023 10:51:59 -0400
Subject: [PATCH 452/602] Add warnings at import

---
 .coveragerc                             | 2 +-
 qutip/legacy/__init__.py                | 5 +++++
 qutip/legacy/nonmarkov/memorycascade.py | 3 +++
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/.coveragerc b/.coveragerc
index cbb865cd58..48390eb696 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -5,7 +5,7 @@ omit =
     */qutip/tests/*
     # Tool for tests
     */qutip/solver/sode/_noise.py
-    # Feature we want to remove, hiding them while waiting to see if users will complain.
+    # Feature we know are not fully tested.
     */qutip/legacy/*
 
 [report]
diff --git a/qutip/legacy/__init__.py b/qutip/legacy/__init__.py
index e69de29bb2..918689196a 100644
--- a/qutip/legacy/__init__.py
+++ b/qutip/legacy/__init__.py
@@ -0,0 +1,5 @@
+import warnings
+warnings.warn("Function in legacy are untested.")
+del warnings
+
+from .nonmarkov.memorycascade import MemoryCascade
diff --git a/qutip/legacy/nonmarkov/memorycascade.py b/qutip/legacy/nonmarkov/memorycascade.py
index 33e510e0d4..0cdf18cd3b 100644
--- a/qutip/legacy/nonmarkov/memorycascade.py
+++ b/qutip/legacy/nonmarkov/memorycascade.py
@@ -32,6 +32,9 @@
 )
 
 
+__all__ = ["MemoryCascade"]
+
+
 class MemoryCascade:
     """Class for running memory cascade simulations of open quantum systems
     with time-delayed coherent feedback.

From 2e879b14762c84c16dc2fef39ef31bde9ff64d4f Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 19:30:13 +0900
Subject: [PATCH 453/602] delete all deprecated functions

---
 qutip/visualization.py | 43 +++---------------------------------------
 1 file changed, 3 insertions(+), 40 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index a65453a8a3..d031cc244c 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -196,8 +196,7 @@ def _blob(x, y, w, w_max, area, color_fn, ax=None):
     else:
         handle = plt
 
-    handle.fill(xcorners, ycorners,
-             color=color_fn(w))
+    handle.fill(xcorners, ycorners, color=color_fn(w))
 
 
 def _cb_labels(left_dims):
@@ -232,7 +231,7 @@ def _cb_labels(left_dims):
 # Adopted from the SciPy Cookbook.
 def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
            label_top=True, *, cmap=None, colorbar=True, fig=None, ax=None):
-    """Draws a Hinton diagram for visualizing a density matrix or superoperator.
+    """Draws a Hinton diagram to visualize a density matrix or superoperator.
 
     Parameters
     ----------
@@ -464,7 +463,7 @@ def sphereplot(theta, phi, values, *,
     if colorbar:
         # create new axes on plot for colorbar and shrink it a bit.
         # pad shifts location of bar with repsect to the main plot
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.05)
 
         # create new colorbar in axes cax with cmap and normalized to nrm like
         # our facecolors
@@ -993,12 +992,6 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
     return fig, ax
 
 
-def energy_level_diagram(H_list, N=0, labels=None, show_ylabels=False,
-                         figsize=(8, 12), fig=None, ax=None):
-    warnings.warn("Deprecated: Use plot_energy_levels")
-    return plot_energy_levels(H_list, N=N, fig=fig, ax=ax)
-
-
 def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
                            fig=None, ax=None):
     """
@@ -1048,12 +1041,6 @@ def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
     return fig, ax
 
 
-def fock_distribution(rho, offset=0, fig=None, ax=None,
-                      figsize=(8, 6), title=None, unit_y_range=True):
-    warnings.warn("Deprecated: Use plot_fock_distribution")
-    return plot_fock_distribution(rho, offset=offset, fig=fig, ax=ax)
-
-
 def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
                 cmap=None, colorbar=False, fig=None, ax=None):
     """
@@ -1206,17 +1193,6 @@ def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
     return fig, axes
 
 
-def wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4),
-                             cmap=None, alpha_max=7.5, colorbar=False,
-                             method='iterative'):
-    warnings.warn("Deprecated: Use plot_wigner_fock_distribution")
-    return plot_wigner_fock_distribution(rho, fig=fig, axes=axes,
-                                         figsize=figsize, cmap=cmap,
-                                         alpha_max=alpha_max,
-                                         colorbar=colorbar,
-                                         method=method)
-
-
 def plot_expectation_values(results, ylabels=None, title=None, *,
                             fig=None, axes=None):
     """
@@ -1362,19 +1338,6 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     return fig, ax
 
 
-def plot_spin_distribution_2d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 8)):
-    warnings.warn("Deprecated: Use plot_spin_distribution")
-    return plot_spin_distribution(P, THETA, PHI, fig=fig, ax=ax)
-
-
-def plot_spin_distribution_3d(P, THETA, PHI,
-                              fig=None, ax=None, figsize=(8, 6)):
-    warnings.warn("Deprecated: Use plot_spin_distribution")
-    return plot_spin_distribution(P, THETA, PHI, projection='3d',
-                                  fig=fig, ax=ax)
-
-
 #
 # Qubism and other qubistic visualizations
 #

From 249235e19ce255d6a6f0cced0e35f7ed900c7ff2 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 19:42:46 +0900
Subject: [PATCH 454/602] sort import modules and delete plot_wigner_fock

---
 qutip/visualization.py | 153 +++--------------------------------------
 1 file changed, 8 insertions(+), 145 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index d031cc244c..131825f4a8 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -3,15 +3,12 @@
 visualizations of quantum states and processes.
 """
 
-__all__ = ['hinton', 'sphereplot', 'energy_level_diagram',
-           'plot_energy_levels', 'fock_distribution',
-           'plot_fock_distribution', 'wigner_fock_distribution',
-           'plot_wigner_fock_distribution', 'plot_wigner',
-           'plot_expectation_values', 'plot_spin_distribution_2d',
-           'plot_spin_distribution_3d', 'plot_qubism', 'plot_schmidt',
-           'complex_array_to_rgb', 'matrix_histogram',
-           'matrix_histogram_complex', 'sphereplot', 'plot_wigner_sphere',
-           'plot_spin_distribution']
+__all__ = ['plot_wigner_sphere', 'hinton', 'sphereplot',
+           'matrix_histogram', 'matrix_histogram_complex',
+           'plot_energy_levels', 'plot_fock_distribution',
+           'plot_wigner', 'plot_expectation_values',
+           'plot_spin_distribution' 'complex_array_to_rgb',
+           'plot_qubism', 'plot_schmidt']
 
 import warnings
 import itertools as it
@@ -1083,10 +1080,9 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
         the figure.
     """
 
-    if projection in ('2d', '3d'):
-        fig, ax = _is_fig_and_ax(fig, ax, projection)
-    else:
+    if projection not in ('2d', '3d'):
         raise ValueError('Unexpected value of projection keyword argument')
+    fig, ax = _is_fig_and_ax(fig, ax, projection)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1123,139 +1119,6 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     return fig, ax
 
 
-def plot_wigner_fock_distribution(rho, alpha_max=7.5, method='iterative',
-                                  projection='2d', *, cmap=None,
-                                  colorbar=False, fig=None, axes=None):
-    """
-    Plot the Fock distribution and the Wigner function for a density matrix
-    (or ket) that describes an oscillator mode.
-
-    Parameters
-    ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
-
-    alpha_max : float
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
-
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
-    projection: string {'2d', '3d'}
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
-    cmap : a matplotlib cmap instance
-        The colormap.
-
-    colorbar : bool
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    axes : a list of two matplotlib axes instances
-        The axes context in which the plot will be drawn.
-
-    Returns
-    -------
-    fig, axes : tuple
-        A tuple of the matplotlib figure and array of axes objects
-        used to produce the figure.
-    """
-    if axes is None:
-        if fig is None:
-            fig = plt.figure()
-        if projection == '2d':
-            axes = np.array([fig.add_subplot(1, 2, 1),
-                             fig.add_subplot(1, 2, 2)])
-        elif projection == '3d':
-            axes = np.array([fig.add_subplot(1, 2, 1),
-                             fig.add_subplot(1, 2, 2, projection='3d')])
-        else:
-            raise ValueError(
-                "Unexpected value of projection keyword argument"
-                )
-    if not isinstance(axes, np.ndarray) or len(axes) != 2:
-        raise ValueError(
-            "axes must be a np.array of two matplotlib axes instances"
-            )
-
-    if isket(rho):
-        rho = ket2dm(rho)
-
-    plot_fock_distribution(rho, fig=fig, ax=axes[0])
-    plot_wigner(rho, alpha_max=alpha_max, method=method, projection=projection,
-                cmap=cmap, colorbar=colorbar, fig=fig, ax=axes[1])
-
-    return fig, axes
-
-
-def plot_expectation_values(results, ylabels=None, title=None, *,
-                            fig=None, axes=None):
-    """
-    Visualize the results (expectation values) for an evolution solver.
-    `results` is assumed to be an instance of Result, or a list of Result
-    instances.
-
-    Parameters
-    ----------
-    results : (list of) :class:`qutip.solver.Result`
-        List of results objects returned by any of the QuTiP evolution solvers.
-
-    ylabels : list of strings
-        The y-axis labels. List should be of the same length as `results`.
-
-    title : string
-        The title of the figure.
-
-    fig : a matplotlib Figure instance
-        The Figure canvas in which the plot will be drawn.
-
-    axes : (list of)  axes instances
-        The axes context in which the plot will be drawn.
-
-    Returns
-    -------
-    fig, axes : tuple
-        A tuple of the matplotlib figure and array of axes instances
-        used to produce the figure.
-    """
-    if not isinstance(results, list):
-        results = [results]
-
-    n_e_ops = max([len(result.expect) for result in results])
-
-    if axes is None:
-        if fig is None:
-            fig = plt.figure()
-        axes = np.array([fig.add_subplot(n_e_ops, 1, i+1)
-                         for i in range(n_e_ops)])
-
-    # create np.ndarray if axes is one axes object or list
-    if not isinstance(axes, np.ndarray):
-        if not isinstance(axes, list):
-            axes = [axes]
-        axes = np.array(axes)
-
-    for r_idx, result in enumerate(results):
-        for e_idx, e in enumerate(result.expect):
-            axes[e_idx].plot(result.times, e,
-                             label="%s [%d]" % (result.solver, e_idx))
-
-    if title:
-        fig.suptitle(title)
-
-    axes[n_e_ops - 1].set_xlabel("time", fontsize=12)
-    for n in range(n_e_ops):
-        if ylabels:
-            axes[n].set_ylabel(ylabels[n], fontsize=12)
-
-    return fig, axes
-
-
 def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
                            cmap=None, colorbar=False, fig=None, ax=None):
     """

From 813e47401fd32b0e1f301f533fc4ff757906ea0d Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 19:46:03 +0900
Subject: [PATCH 455/602] add plot_expectation_values which is mistakenly
 deleted

---
 qutip/visualization.py | 57 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 131825f4a8..60f2334d83 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1119,6 +1119,63 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     return fig, ax
 
 
+def plot_expectation_values(results, ylabels=None, title=None, *,
+                            fig=None, axes=None):
+    """
+    Visualize the results (expectation values) for an evolution solver.
+    `results` is assumed to be an instance of Result, or a list of Result
+    instances.
+    Parameters
+    ----------
+    results : (list of) :class:`qutip.solver.Result`
+        List of results objects returned by any of the QuTiP evolution solvers.
+    ylabels : list of strings
+        The y-axis labels. List should be of the same length as `results`.
+    title : string
+        The title of the figure.
+    fig : a matplotlib Figure instance
+        The Figure canvas in which the plot will be drawn.
+    axes : (list of)  axes instances
+        The axes context in which the plot will be drawn.
+    Returns
+    -------
+    fig, axes : tuple
+        A tuple of the matplotlib figure and array of axes instances
+        used to produce the figure.
+    """
+    if not isinstance(results, list):
+        results = [results]
+
+    n_e_ops = max([len(result.expect) for result in results])
+
+    if axes is None:
+        if fig is None:
+            fig = plt.figure()
+        axes = np.array([fig.add_subplot(n_e_ops, 1, i+1)
+                         for i in range(n_e_ops)])
+
+    # create np.ndarray if axes is one axes object or list
+    if not isinstance(axes, np.ndarray):
+        if not isinstance(axes, list):
+            axes = [axes]
+        axes = np.array(axes)
+
+    for r_idx, result in enumerate(results):
+        for e_idx, e in enumerate(result.expect):
+            axes[e_idx].plot(result.times, e,
+                             label="%s [%d]" % (result.solver, e_idx))
+
+    if title:
+        fig.suptitle(title)
+
+    axes[n_e_ops - 1].set_xlabel("time", fontsize=12)
+    for n in range(n_e_ops):
+        if ylabels:
+            axes[n].set_ylabel(ylabels[n], fontsize=12)
+
+    return fig, axes
+
+
 def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
                            cmap=None, colorbar=False, fig=None, ax=None):
     """

From 57770cb22c4b6d067e3b951014dfab2c69972c2e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 19:47:22 +0900
Subject: [PATCH 456/602] remove title

---
 qutip/visualization.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 60f2334d83..180b278591 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1119,7 +1119,7 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     return fig, ax
 
 
-def plot_expectation_values(results, ylabels=None, title=None, *,
+def plot_expectation_values(results, ylabels=None, *,
                             fig=None, axes=None):
     """
     Visualize the results (expectation values) for an evolution solver.
@@ -1131,8 +1131,7 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
         List of results objects returned by any of the QuTiP evolution solvers.
     ylabels : list of strings
         The y-axis labels. List should be of the same length as `results`.
-    title : string
-        The title of the figure.
+
     fig : a matplotlib Figure instance
         The Figure canvas in which the plot will be drawn.
     axes : (list of)  axes instances
@@ -1165,9 +1164,6 @@ def plot_expectation_values(results, ylabels=None, title=None, *,
             axes[e_idx].plot(result.times, e,
                              label="%s [%d]" % (result.solver, e_idx))
 
-    if title:
-        fig.suptitle(title)
-
     axes[n_e_ops - 1].set_xlabel("time", fontsize=12)
     for n in range(n_e_ops):
         if ylabels:

From 0c8ab129188c275ebccfa104a3919cf66c83c708 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 19:53:06 +0900
Subject: [PATCH 457/602] change positions of parentheses

---
 qutip/visualization.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 180b278591..cabf5e6c7a 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -89,7 +89,7 @@ def _set_ticklabels(ax, ticklabels, ticks, axis):
     if len(ticks) != len(ticklabels):
         raise ValueError(
             f"got {len(ticklabels)} ticklabels but needed {len(ticks)}"
-            )
+        )
     if axis == 'x':
         ax.set_xticks(ticks)
         ax.set_xticklabels(ticklabels, fontsize=14)
@@ -99,7 +99,7 @@ def _set_ticklabels(ax, ticklabels, ticks, axis):
     else:
         raise ValueError(
             "axis must be either 'x' or 'y'"
-            )
+        )
 
 
 def plot_wigner_sphere(fig, ax, wigner, reflections):

From abf922820e6473b78c60dea577a871a40f217b2d Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 20:14:45 +0900
Subject: [PATCH 458/602] set default values

---
 qutip/visualization.py | 127 +++++++++++++++++++++--------------------
 1 file changed, 65 insertions(+), 62 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index cabf5e6c7a..5f717f9a48 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -239,13 +239,13 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
         Hinton plots of superoperators are currently only supported for qubits.
 
-    x_basis : list of strings or False
+    x_basis : list of strings, optional
         list of x ticklabels to represent x basis of the input.
 
-    y_basis : list of strings or False
+    y_basis : list of strings, optional
         list of y ticklabels to represent y basis of the input.
 
-    color_style : string
+    color_style : string, default="scaled"
         Determines how colors are assigned to each square:
 
         -  If set to ``"scaled"`` (default), each color is chosen by
@@ -258,20 +258,20 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
         -  If set to ``"phase"``, each color is chosen according to
            the angle of the corresponding matrix element.
 
-    label_top : bool
+    label_top : bool, default=True
         If True, x ticklabels will be placed on top, otherwise
         they will appear below the plot.
 
-    cmap : a matplotlib colormap instance
+    cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 
-    colorbar : bool
+    colorbar : bool, default=True
         Whether (True) or not (False) a colorbar should be attached.
 
-    fig : a matplotlib Figure instance
+    fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
-    ax : a matplotlib axes instance
+    ax : a matplotlib axes instance, optional
         The ax context in which the plot will be drawn.
 
     Returns
@@ -421,16 +421,16 @@ def sphereplot(theta, phi, values, *,
     values : array
         Data set to be plotted
 
-    cmap : a matplotlib colormap instance
+    cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 
-    colorbar : bool
+    colorbar : bool, default=True
         Whether (True) or not (False) a colorbar should be attached.
 
-    fig : a matplotlib Figure instance
+    fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
-    ax : a matplotlib axes instance
+    ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
     Returns
@@ -784,29 +784,29 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
     M : Matrix of Qobj
         The matrix to visualize
 
-    x_basis : list of strings or False
+    x_basis : list of strings or False, optional
         list of x ticklabels to represent x basis of the input.
 
-    y_basis : list of strings or False
+    y_basis : list of strings or False, optional
         list of y ticklabels to represent y basis of the input.
 
-    phase_limits : list/array with two float numbers
+    phase_limits : list/array with two float numbers, optional
         The phase-axis (colorbar) limits [min, max] (optional)
 
-    threshold: float (None)
+    threshold: float, optional
         Threshold for when bars of smaller height should be transparent. If
         not set, all bars are colored according to the color map.
 
-    cmap : a matplotlib colormap instance
+    cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 
-    colorbar : bool
+    colorbar : bool, optional
         Whether (True) or not (False) a colorbar should be attached.
 
-    fig : a matplotlib Figure instance
+    fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
-    ax : a matplotlib axes instance
+    ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
     Returns
@@ -904,20 +904,20 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
         H_list : List of Qobj
             A list of Hamiltonians.
 
-        h_lables : List of string
+        h_lables : List of string, optional
             A list of xticklabels for each Hamiltonian
 
-        energy_levels : List of string
+        energy_levels : List of string, optional
             A list of  yticklabels to the left of energy levels of the initial
             Hamiltonian.
 
-        N : int
+        N : int, default=0
             The number of energy levels to plot
 
-        fig : a matplotlib Figure instance
+        fig : a matplotlib Figure instance, optional
             The Figure canvas in which the plot will be drawn.
 
-        ax : a matplotlib axes instance
+        ax : a matplotlib axes instance, optional
             The axes context in which the plot will be drawn.
 
     Returns
@@ -1000,16 +1000,16 @@ def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
-    offset : int
+    offset : int, default=0
         Offset the fock number
 
-    unit_y_range : bool
+    unit_y_range : bool, default=True
         Set y-axis limits [0, 1] or not
 
-    fig : a matplotlib Figure instance
+    fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
-    ax : a matplotlib axes instance
+    ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
     Returns
@@ -1049,28 +1049,28 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
-    alpha_max : float
+    alpha_max : float, default=7.5
         The span of the x and y coordinates (both [-alpha_max, alpha_max]).
 
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}, default='clenshaw'
         The method used for calculating the wigner function. See the
         documentation for qutip.wigner for details.
 
-    projection: string {'2d', '3d'}
+    projection: string {'2d', '3d'}, default='2d'
         Specify whether the Wigner function is to be plotted as a
         contour graph ('2d') or surface plot ('3d').
 
-    cmap : a matplotlib cmap instance
+    cmap : a matplotlib cmap instance, optional
         The colormap.
 
-    colorbar : bool
+    colorbar : bool, default=False
         Whether (True) or not (False) a colorbar should be attached to the
         Wigner function graph.
 
-    fig : a matplotlib Figure instance
+    fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
-    ax : a matplotlib axes instance
+    ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
     Returns
@@ -1129,13 +1129,16 @@ def plot_expectation_values(results, ylabels=None, *,
     ----------
     results : (list of) :class:`qutip.solver.Result`
         List of results objects returned by any of the QuTiP evolution solvers.
-    ylabels : list of strings
+
+    ylabels : list of strings, optional
         The y-axis labels. List should be of the same length as `results`.
 
-    fig : a matplotlib Figure instance
+    fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
-    axes : (list of)  axes instances
+
+    axes : (list of)  axes instances, optional
         The axes context in which the plot will be drawn.
+
     Returns
     -------
     fig, axes : tuple
@@ -1188,22 +1191,22 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     PHI : matrix
         Meshgrid matrix for the phi coordinate.
 
-    projection: string {'2d', '3d'}
+    projection: string {'2d', '3d'}, default='2d'
         Specify whether the spin distribution function is to be plotted as a 2D
         projection where the surface of the unit sphere is mapped on
         the unit disk ('2d') or surface plot ('3d').
 
-    cmap : a matplotlib cmap instance
+    cmap : a matplotlib cmap instance, optional
         The colormap.
 
-    colorbar : bool
+    colorbar : bool, default=False
         Whether (True) or not (False) a colorbar should be attached to the
         Wigner function graph.
 
-    fig : a matplotlib figure instance
+    fig : a matplotlib figure instance, optional
         The figure canvas on which the plot will be drawn.
 
-    ax : a matplotlib axis instance
+    ax : a matplotlib axis instance, optional
         The axis context in which the plot will be drawn.
 
     Returns
@@ -1273,10 +1276,10 @@ def complex_array_to_rgb(X, theme='light', rmax=None):
     X : array
         Array (of any dimension) of complex numbers.
 
-    theme : 'light' (default) or 'dark'
+    theme : 'light' or 'dark', default='light'
         Set coloring theme for mapping complex values into colors.
 
-    rmax : float
+    rmax : float, optional
         Maximal abs value for color normalization.
         If None (default), uses np.abs(X).max().
 
@@ -1444,31 +1447,31 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     ket : Qobj
         Pure state for plotting.
 
-    theme : 'light' (default) or 'dark'
+    theme : 'light' or 'dark', default='light'
         Set coloring theme for mapping complex values into colors.
         See: complex_array_to_rgb.
 
-    how : 'pairs' (default), 'pairs_skewed' or 'before_after'
+    how : 'pairs', 'pairs_skewed' or 'before_after', default='pairs'
         Type of Qubism plotting.  Options:
 
         - 'pairs' - typical coordinates,
         - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
         - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
 
-    grid_iteration : int (default 1)
+    grid_iteration : int, default=1
         Helper lines to be drawn on plot.
         Show tiles for 2*grid_iteration particles vs all others.
 
-    legend_iteration : int (default 0) or 'grid_iteration' or 'all'
+    legend_iteration : int or 'grid_iteration' or 'all', default=0
         Show labels for first ``2*legend_iteration`` particles.  Option
         'grid_iteration' sets the same number of particles as for
         grid_iteration.  Option 'all' makes label for all particles.  Typically
         it should be 0, 1, 2 or perhaps 3.
 
-    fig : a matplotlib figure instance
+    fig : a matplotlib figure instance, optional
         The figure canvas on which the plot will be drawn.
 
-    ax : a matplotlib axis instance
+    ax : a matplotlib axis instance, optional
         The axis context in which the plot will be drawn.
 
     Returns
@@ -1592,8 +1595,8 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     return fig, ax
 
 
-def plot_schmidt(ket, splitting=None, labels_iteration=(3, 2),
-                 theme='light', *, fig=None, ax=None):
+def plot_schmidt(ket, theme='light', splitting=None,
+                 labels_iteration=(3, 2), *, fig=None, ax=None):
     """
     Plotting scheme related to Schmidt decomposition.
     Converts a state into a matrix (A_ij -> A_i^j),
@@ -1610,22 +1613,22 @@ def plot_schmidt(ket, splitting=None, labels_iteration=(3, 2),
     ket : Qobj
         Pure state for plotting.
 
-    splitting : int
-        Plot for a number of first particles versus the rest.
-        If not given, it is (number of particles + 1) // 2.
-
-    theme : 'light' (default) or 'dark'
+    theme : 'light' or 'dark', default='light'
         Set coloring theme for mapping complex values into colors.
         See: complex_array_to_rgb.
 
-    labels_iteration : int or pair of ints (default (3,2))
+    splitting : int, optional
+        Plot for a number of first particles versus the rest.
+        If not given, it is (number of particles + 1) // 2.
+
+    labels_iteration : int or pair of ints, default=(3,2)
         Number of particles to be shown as tick labels,
         for first (vertical) and last (horizontal) particles, respectively.
 
-    fig : a matplotlib figure instance
+    fig : a matplotlib figure instance, optional
         The figure canvas on which the plot will be drawn.
 
-    ax : a matplotlib axis instance
+    ax : a matplotlib axis instance, optional
         The axis context in which the plot will be drawn.
 
     Returns

From 0c0414988a2444d7c9d431e1d04275708f015f31 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 20:28:13 +0900
Subject: [PATCH 459/602] use cyclic cmap for phase plot

---
 qutip/visualization.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 5f717f9a48..3c78d9c22b 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -351,17 +351,24 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
         w_max = 1.0
 
     # Set color_fn here.
-    if cmap is None:
-        cmap = _diverging_cmap()
     if color_style == "scaled":
+        if cmap is None:
+            cmap = _diverging_cmap()
+
         def color_fn(w):
             w = np.abs(w) * np.sign(np.real(w))
             return cmap(int((w + w_max) * 256 / (2 * w_max)))
     elif color_style == "threshold":
+        if cmap is None:
+            cmap = _diverging_cmap()
+
         def color_fn(w):
             w = np.real(w)
             return cmap(255 if w > 0 else 0)
     elif color_style == "phase":
+        if cmap is None:
+            cmap = _cyclic_cmap()
+
         def color_fn(w):
             return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
     else:
@@ -1052,7 +1059,8 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     alpha_max : float, default=7.5
         The span of the x and y coordinates (both [-alpha_max, alpha_max]).
 
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'}, default='clenshaw'
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
+        default='clenshaw'
         The method used for calculating the wigner function. See the
         documentation for qutip.wigner for details.
 

From 3d86ec639103644c64c45f12c78b5e6597139bfe Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 20:36:18 +0900
Subject: [PATCH 460/602] add range for theta and phi in sphereplot

---
 qutip/visualization.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 3c78d9c22b..7c7af674b5 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,7 +7,7 @@
            'matrix_histogram', 'matrix_histogram_complex',
            'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
-           'plot_spin_distribution' 'complex_array_to_rgb',
+           'plot_spin_distribution', 'complex_array_to_rgb',
            'plot_qubism', 'plot_schmidt']
 
 import warnings
@@ -420,10 +420,10 @@ def sphereplot(theta, phi, values, *,
     Parameters
     ----------
     theta : float
-        Angle with respect to z-axis
+        Angle with respect to z-axis. Its range is between 0 and pi
 
     phi : float
-        Angle in x-y plane
+        Angle in x-y plane. Its range is between 0 and 2*pi
 
     values : array
         Data set to be plotted

From 4e201728f3fb1193e7db95e965e308373fd0171e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 20:50:49 +0900
Subject: [PATCH 461/602] add range for plot_spin_distribution

---
 qutip/visualization.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 7c7af674b5..c12b9114f8 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1194,10 +1194,10 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
         Distribution values as a meshgrid matrix.
 
     THETA : matrix
-        Meshgrid matrix for the theta coordinate.
+        Meshgrid matrix for the theta coordinate. Its range is between 0 and pi
 
     PHI : matrix
-        Meshgrid matrix for the phi coordinate.
+        Meshgrid matrix for the phi coordinate. Its range is between 0 and 2*pi
 
     projection: string {'2d', '3d'}, default='2d'
         Specify whether the spin distribution function is to be plotted as a 2D

From 11fcab9318280710aff3e5b8a6a03b2d06eb77a2 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 21:24:53 +0900
Subject: [PATCH 462/602] add color for plot_fock_distribution

---
 qutip/visualization.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index c12b9114f8..7550d48a6c 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -996,7 +996,7 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
     return fig, ax
 
 
-def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
+def plot_fock_distribution(rho, color="green", offset=0, unit_y_range=True, *,
                            fig=None, ax=None):
     """
     Plot the Fock distribution for a density matrix (or ket) that describes
@@ -1007,8 +1007,11 @@ def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
+    color: color or list of colors, default="green"
+        The colors of the bar faces.
+
     offset : int, default=0
-        Offset the fock number
+        Offset the fock number.
 
     unit_y_range : bool, default=True
         Set y-axis limits [0, 1] or not
@@ -1034,7 +1037,7 @@ def plot_fock_distribution(rho, offset=0, unit_y_range=True, *,
     N = rho.shape[0]
 
     ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
-           color="green", alpha=0.6, width=0.8)
+           color=color, alpha=0.6, width=0.8)
 
     if unit_y_range:
         ax.set_ylim(0, 1)

From b97b5163cf91e2b4e01659ca90064a00c77821fc Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 21:37:05 +0900
Subject: [PATCH 463/602] add pad

---
 qutip/visualization.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 7550d48a6c..f025852922 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1122,7 +1122,7 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax)
+        cax, kw = mpl.colorbar.make_axes(ax, pad=.1)
         cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
     ax.set_title("Wigner function", fontsize=12)
@@ -1261,7 +1261,7 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
         ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
                         facecolors=cmap(norm(P)), linewidth=0)
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
         cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb1.set_label('magnitude')
 

From 8e4d75964513a565d94ca6ae06b894be5591fe32 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 22:24:42 +0900
Subject: [PATCH 464/602] add default ticklabels in matrix_histogram_complex

---
 qutip/visualization.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index f025852922..76dfae5f6f 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -833,6 +833,15 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
     ax.view_init(azim=-35, elev=35)
 
     if isinstance(M, Qobj):
+        try:
+            if x_basis is None or y_basis is None:
+                labels = _cb_labels(M.dims[0])
+                if x_basis is None:
+                    x_basis = list(labels[0])
+                if y_basis is None:
+                    y_basis = list(labels[1])
+        except Exception:
+            pass
         # extract matrix data from Qobj
         M = M.full()
 
@@ -887,7 +896,7 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.05)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.1)
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
         cb.set_ticklabels(

From 39498f2e387850404768fbdb975b8053cdf62511 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 22:54:53 +0900
Subject: [PATCH 465/602] make function to follow pep8

---
 qutip/visualization.py | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 76dfae5f6f..58c3c69fbf 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -225,6 +225,18 @@ def _cb_labels(left_dims):
     ]
 
 
+def _default_cb_labels(x_labels, y_labels, matrix):
+    """
+    Creates default plot labels for matrix elements in the computational basis.
+    """
+    labels = _cb_labels(matrix.dims[0])
+    if x_labels is None:
+        x_labels = list(labels[0])
+    if y_labels is None:
+        y_labels = list(labels[1])
+    return x_labels, y_labels
+
+
 # Adopted from the SciPy Cookbook.
 def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
            label_top=True, *, cmap=None, colorbar=True, fig=None, ax=None):
@@ -313,12 +325,7 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
             # Create default labels if none are given.
-            if x_basis is None or y_basis is None:
-                labels = _cb_labels(rho.dims[0])
-                if x_basis is None:
-                    x_basis = list(labels[0])
-                if y_basis is None:
-                    y_basis = list(labels[1])
+            x_basis, y_basis = _default_cb_labels(x_basis, y_basis, rho)
 
         elif rho.issuper:
             if not isqubitdims(rho.dims):
@@ -834,12 +841,7 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
 
     if isinstance(M, Qobj):
         try:
-            if x_basis is None or y_basis is None:
-                labels = _cb_labels(M.dims[0])
-                if x_basis is None:
-                    x_basis = list(labels[0])
-                if y_basis is None:
-                    y_basis = list(labels[1])
+            x_basis, y_basis = _default_cb_labels(x_basis, y_basis, M)
         except Exception:
             pass
         # extract matrix data from Qobj

From 18f26f33cc9ac905c37739150952a9e4cda2437e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 4 Jul 2023 23:28:14 +0900
Subject: [PATCH 466/602] delete deprecated functions and add new functions in
 apidoc

---
 doc/apidoc/functions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 43e00a41a2..0fa0b54b66 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -235,7 +235,7 @@ Graphs and Visualization
 ------------------------
 
 .. automodule:: qutip.visualization
-    :members: hinton, matrix_histogram, matrix_histogram_complex, plot_energy_levels, plot_fock_distribution, plot_wigner_fock_distribution, plot_wigner, sphereplot, plot_schmidt, plot_qubism, plot_expectation_values, plot_spin_distribution_2d, plot_spin_distribution_3d, plot_wigner_sphere
+    :members: hinton, matrix_histogram, matrix_histogram_complex, plot_energy_levels, plot_fock_distribution, plot_wigner, sphereplot, plot_schmidt, plot_qubism, plot_expectation_values, plot_wigner_sphere, plot_spin_distribution
     :undoc-members:
 
 .. automodule:: qutip.orbital

From 0d0e92b4e67a356efc3a7299ba8a8ea2c3cba43f Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 5 Jul 2023 19:39:01 +0900
Subject: [PATCH 467/602] delete alpha and add xvec and yvec

---
 qutip/visualization.py | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 97885e8040..a5b49b1f4b 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -1059,8 +1059,9 @@ def plot_fock_distribution(rho, color="green", offset=0, unit_y_range=True, *,
     return fig, ax
 
 
-def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
-                cmap=None, colorbar=False, fig=None, ax=None):
+def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
+                projection='2d', *, cmap=None, colorbar=False,
+                fig=None, ax=None):
     """
     Plot the the Wigner function for a density matrix (or ket) that describes
     an oscillator mode.
@@ -1070,8 +1071,12 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     rho : :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
-    alpha_max : float, default=7.5
-        The span of the x and y coordinates (both [-alpha_max, alpha_max]).
+    xvec : array_like, optional
+        x-coordinates at which to calculate the Wigner function.
+
+    yvec : array_like, optional
+        y-coordinates at which to calculate the Wigner function.  Does not
+        apply to the 'fft' method.
 
     method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
         default='clenshaw'
@@ -1109,10 +1114,14 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     if isket(rho):
         rho = ket2dm(rho)
 
-    xvec = np.linspace(-alpha_max, alpha_max, 200)
-    W0 = wigner(rho, xvec, xvec, method=method)
+    if xvec is None:
+        xvec = np.linspace(-7.5, 7.5, 200)
+    if yvec is None:
+        yvec = np.linspace(-7.5, 7.5, 200)
+
+    W0 = wigner(rho, xvec, yvec, method=method)
 
-    W, yvec = W0 if isinstance(W0, tuple) else (W0, xvec)
+    W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
 
     wlim = abs(W).max()
     norm = mpl.colors.Normalize(-wlim, wlim)
@@ -1122,13 +1131,10 @@ def plot_wigner(rho, alpha_max=7.5, method='clenshaw', projection='2d', *,
     if projection == '2d':
         cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap)
     else:
-        X, Y = np.meshgrid(xvec, xvec)
+        X, Y = np.meshgrid(xvec, yvec)
         cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
                              norm=norm, cmap=cmap)
 
-    if xvec is not yvec:
-        ax.set_ylim(xvec.min(), xvec.max())
-
     ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 

From cbf8671be063f8b35b679352e11e4ad323288776 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 5 Jul 2023 20:21:20 +0900
Subject: [PATCH 468/602] replace offset with fock_numbers(xticklabels)

---
 qutip/visualization.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index a5b49b1f4b..e4007e2b9f 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -85,17 +85,17 @@ def _is_fig_and_ax(fig, ax, projection='2d'):
     return fig, ax
 
 
-def _set_ticklabels(ax, ticklabels, ticks, axis):
+def _set_ticklabels(ax, ticklabels, ticks, axis, fontsize=14):
     if len(ticks) != len(ticklabels):
         raise ValueError(
             f"got {len(ticklabels)} ticklabels but needed {len(ticks)}"
         )
     if axis == 'x':
         ax.set_xticks(ticks)
-        ax.set_xticklabels(ticklabels, fontsize=14)
+        ax.set_xticklabels(ticklabels, fontsize=fontsize)
     elif axis == 'y':
         ax.set_yticks(ticks)
-        ax.set_yticklabels(ticklabels, fontsize=14)
+        ax.set_yticklabels(ticklabels, fontsize=fontsize)
     else:
         raise ValueError(
             "axis must be either 'x' or 'y'"
@@ -1007,22 +1007,22 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
     return fig, ax
 
 
-def plot_fock_distribution(rho, color="green", offset=0, unit_y_range=True, *,
-                           fig=None, ax=None):
+def plot_fock_distribution(rho, fock_numbers=None, color="green",
+                           unit_y_range=True, *, fig=None, ax=None):
     """
     Plot the Fock distribution for a density matrix (or ket) that describes
     an oscillator mode.
 
     Parameters
     ----------
-    rho : :class:`qutip.Qobj`
+    rho :`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
-    color: color or list of colors, default="green"
-        The colors of the bar faces.
+    fock_numbers : list of strings, optional
+        list of x ticklabels to represent fock numbers
 
-    offset : int, default=0
-        Offset the fock number.
+    color : color or list of colors, default="green"
+        The colors of the bar faces.
 
     unit_y_range : bool, default=True
         Set y-axis limits [0, 1] or not
@@ -1047,12 +1047,15 @@ def plot_fock_distribution(rho, color="green", offset=0, unit_y_range=True, *,
 
     N = rho.shape[0]
 
-    ax.bar(np.arange(offset, offset + N), np.real(rho.diag()),
+    ax.bar(np.arange(N), np.real(rho.diag()),
            color=color, alpha=0.6, width=0.8)
 
+    if fock_numbers:
+        _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
+
     if unit_y_range:
         ax.set_ylim(0, 1)
-    ax.set_xlim(-.5 + offset, N + offset)
+    ax.set_xlim(-.5, N)
     ax.set_xlabel('Fock number', fontsize=12)
     ax.set_ylabel('Occupation probability', fontsize=12)
 

From 9e4bb6c6a4394e89c541c3059a2aad0b483264ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 5 Jul 2023 17:00:19 -0400
Subject: [PATCH 469/602] Update qutip/core/data/convert.pyx

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/data/convert.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index 3d14e563da..7f500c175c 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -70,7 +70,7 @@ cdef class _converter:
                 + ">")
 
 
-def dummyconverter(arg):
+def identity_converter(arg):
     return arg
 
 

From 932ad810751091448833e8525de5af2876990bdd Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 5 Jul 2023 17:51:57 -0400
Subject: [PATCH 470/602] Use Epsilon instead of an arbitrary small number

---
 qutip/core/data/convert.pyx            | 44 +++++++++++++++++++++++---
 qutip/core/data/dispatch.pyx           |  7 ++--
 qutip/tests/core/data/test_dispatch.py | 28 ++++++++--------
 3 files changed, 58 insertions(+), 21 deletions(-)

diff --git a/qutip/core/data/convert.pyx b/qutip/core/data/convert.pyx
index 7f500c175c..d2681551b1 100644
--- a/qutip/core/data/convert.pyx
+++ b/qutip/core/data/convert.pyx
@@ -24,6 +24,44 @@ from qutip.core.data.base cimport Data
 __all__ = ['to', 'create']
 
 
+class _Epsilon:
+    """
+    Constant for an small weight non-null weight.
+    Use to set `Data` specialisation just over direct specialisation.
+    """
+    def __repr__(self):
+        return "EPSILON"
+
+    def __eq__(self, other):
+        if isinstance(other, _Epsilon):
+            return True
+        return NotImplemented
+
+    def __add__(self, other):
+        if isinstance(other, _Epsilon):
+            return self
+        return other
+
+    def __radd__(self, other):
+        if isinstance(other, _Epsilon):
+            return self
+        return other
+
+    def __lt__(self, other):
+        """ positive number > _Epsilon > 0 """
+        if isinstance(other, _Epsilon):
+            return False
+        return other > 0.
+
+    def __gt__(self, other):
+        if isinstance(other, _Epsilon):
+            return False
+        return other <= 0.
+
+
+EPSILON = _Epsilon()
+
+
 def _raise_if_unconnected(dtype_list, weights):
     unconnected = {}
     for i, type_ in enumerate(dtype_list):
@@ -152,7 +190,6 @@ cdef class _to:
     cdef dict _convert
     cdef readonly dict weight
     cdef readonly dict _str2type
-    cdef readonly float anydataweight
 
     def __init__(self):
         self._direct_convert = {}
@@ -161,7 +198,6 @@ cdef class _to:
         self.weight = {}
         self.dispatchers = []
         self._str2type = {}
-        self.anydataweight = 0.001
 
     def add_conversions(self, converters):
         """
@@ -269,9 +305,9 @@ cdef class _to:
                     _converter(convert[::-1], to_t, from_t)
         for dtype in self.dtypes:
             self.weight[(dtype, Data)] = 1.
-            self.weight[(Data, dtype)] = self.anydataweight
+            self.weight[(Data, dtype)] = EPSILON
             self._convert[(dtype, Data)] = _partial_converter(self, dtype)
-            self._convert[(Data, dtype)] = dummyconverter
+            self._convert[(Data, dtype)] = identity_converter
         for dispatcher in self.dispatchers:
             dispatcher.rebuild_lookup()
 
diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index 10132877fc..60deb4f69d 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -7,6 +7,7 @@ import itertools
 import warnings
 
 from .convert import to as _to
+from .convert import EPSILON
 
 cimport cython
 from libc cimport math
@@ -33,9 +34,9 @@ cdef double _conversion_weight(tuple froms, tuple tos, dict weight_map, bint out
         )
     if out:
         n = n - 1
-        weight += weight_map[froms[n], tos[n]]
+        weight = weight + weight_map[froms[n], tos[n]]
     for i in range(n):
-        weight += weight_map[tos[i], froms[i]]
+        weight = weight + weight_map[tos[i], froms[i]]
     return weight
 
 
@@ -307,7 +308,7 @@ cdef class Dispatcher:
         if cur == math.INFINITY:
             raise ValueError("No valid specialisations found")
 
-        if weight <= 0.01 and not (output and types[-1] is Data):
+        if weight in [EPSILON, 0.] and not (output and types[-1] is Data):
             self._lookup[in_types] = function
         else:
             if output:
diff --git a/qutip/tests/core/data/test_dispatch.py b/qutip/tests/core/data/test_dispatch.py
index e45f351ff1..c697564c73 100644
--- a/qutip/tests/core/data/test_dispatch.py
+++ b/qutip/tests/core/data/test_dispatch.py
@@ -77,29 +77,29 @@ def f(a=None, b=None, c=None, /):
         if not output:
             out = dispatched(*ins)
             out = dispatched[in_types](*ins)
-            continue
 
-        out = dispatched(*ins)
-        assert out is not None
+        else:
+            out = dispatched(*ins)
+            assert out is not None
 
-        out = dispatched[in_types](*ins)
-        assert out is not None
+            out = dispatched[in_types](*ins)
+            assert out is not None
 
-        if output:
-            for out_dtype in _data.to.dtypes:
+            if output:
+                for out_dtype in _data.to.dtypes:
 
-                out = dispatched[in_types + (out_dtype,)](*ins)
-                if output:
-                    assert isinstance(out, out_dtype)
+                    out = dispatched[in_types + (out_dtype,)](*ins)
+                    if output:
+                        assert isinstance(out, out_dtype)
 
-                out = dispatched(*ins, dtype=out_dtype)
-                if output:
-                    assert isinstance(out, out_dtype)
+                    out = dispatched(*ins, dtype=out_dtype)
+                    if output:
+                        assert isinstance(out, out_dtype)
 
 
 def test_Data_low_priority_one_dispatch():
     class func():
-        __name__ = ""
+        __name__ = "dummy name"
         def __call__(self, a, /):
             return _data.zeros[_data.Dense](1, 1)
 

From e98bb7b6596ea8e1ff94279fcec106f29e326fcb Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 7 Jul 2023 21:37:30 +0900
Subject: [PATCH 471/602] change the way to make labels in
 matrix_histogram_complex and delete default_cb_labels

---
 qutip/visualization.py | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index e4007e2b9f..d98f007a7f 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -225,18 +225,6 @@ def _cb_labels(left_dims):
     ]
 
 
-def _default_cb_labels(x_labels, y_labels, matrix):
-    """
-    Creates default plot labels for matrix elements in the computational basis.
-    """
-    labels = _cb_labels(matrix.dims[0])
-    if x_labels is None:
-        x_labels = list(labels[0])
-    if y_labels is None:
-        y_labels = list(labels[1])
-    return x_labels, y_labels
-
-
 # Adopted from the SciPy Cookbook.
 def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
            label_top=True, *, cmap=None, colorbar=True, fig=None, ax=None):
@@ -325,7 +313,12 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
                 rho = vector_to_operator(rho.dag())
             W = rho.full()
             # Create default labels if none are given.
-            x_basis, y_basis = _default_cb_labels(x_basis, y_basis, rho)
+            if x_basis is None or y_basis is None:
+                labels = _cb_labels(rho.dims[0])
+                if x_basis is None:
+                    x_basis = list(labels[0])
+                if y_basis is None:
+                    y_basis = list(labels[1])
 
         elif rho.issuper:
             if not isqubitdims(rho.dims):
@@ -840,10 +833,10 @@ def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
     ax.view_init(azim=-35, elev=35)
 
     if isinstance(M, Qobj):
-        try:
-            x_basis, y_basis = _default_cb_labels(x_basis, y_basis, M)
-        except Exception:
-            pass
+        if x_basis is None:
+            x_basis = list(_cb_labels([M.shape[0]])[0])
+        if y_basis is None:
+            y_basis = list(_cb_labels([M.shape[1]])[1])
         # extract matrix data from Qobj
         M = M.full()
 

From 758dd8a40ce25daba35aad218a99c912a9ba7e28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Fri, 7 Jul 2023 11:00:01 -0400
Subject: [PATCH 472/602] Update .coveragerc

---
 .coveragerc | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index 48390eb696..bcb36fe5de 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -5,8 +5,6 @@ omit =
     */qutip/tests/*
     # Tool for tests
     */qutip/solver/sode/_noise.py
-    # Feature we know are not fully tested.
-    */qutip/legacy/*
 
 [report]
 exclude_lines =

From 558031607a811710147feee3aa7b4d7bcb328bf6 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 9 Jul 2023 10:52:18 +0900
Subject: [PATCH 473/602] pytest for visualization.py

---
 qutip/tests/test_visualization.py | 49 +++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 qutip/tests/test_visualization.py

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
new file mode 100644
index 0000000000..a54e467fd5
--- /dev/null
+++ b/qutip/tests/test_visualization.py
@@ -0,0 +1,49 @@
+import pytest
+import qutip
+import matplotlib as mpl
+
+
+@pytest.mark.parametrize('rho, x_basis, y_basis, color_style,\
+           label_top, cmap, colorbar, fig, ax', [
+    (qutip.rand_dm(5), None, None, "scaled", True, None, None, None, None),
+    (qutip.operator_to_vector(qutip.rand_dm(5)),
+     None, None, "scaled", True, None, None, None, None),
+    (qutip.operator_to_vector(qutip.rand_dm(5)).dag(),
+     None, None, "scaled", True, None, None, None, None),
+    (qutip.spre(qutip.rand_dm(4)),
+     None, None, "scaled", True, None, None, None, None),
+    (qutip.rand_dm(5),
+     [1, 2, 3, 4, 5], None, "scaled", True, None, None, None, None),
+    (qutip.rand_dm(5),
+     None, [1, 2, 3, 4, 5], "scaled", True, None, None, None, None),
+    (qutip.rand_dm(5), None, None, "scaled", True, None, None, None, None),
+    (qutip.rand_dm(5), None, None, "threshold", True, None, None, None, None),
+    (qutip.rand_dm(5), None, None, "phase", True, None, None, None, None),
+])
+def test_hinton(rho, x_basis, y_basis, color_style,
+                label_top, cmap, colorbar, fig, ax):
+    fig, ax = qutip.hinton(rho, x_basis, y_basis, color_style,
+                           label_top, cmap=cmap, colorbar=colorbar,
+                           fig=fig, ax=ax)
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('rho, x_basis, y_basis, color_style,\
+           label_top, cmap, colorbar, fig, ax, expected', [
+    (qutip.basis(2, 0), None, None, "scaled", True, None, None,
+     None, None, "Input quantum object must be an operator or superoperator."),
+    (qutip.rand_dm(5), None, None, "color_style", True, None, None,
+     None, None, "Unknown color style color_style for Hinton diagrams."),
+    (qutip.spre(qutip.rand_dm(5)),
+     None, None, "scaled", True, None, None, None, None,
+     "Hinton plots of superoperators are currently only supported for qubits.")
+])
+def test_hinton_ValueError(rho, x_basis, y_basis, color_style,
+                           label_top, cmap, colorbar, fig, ax, expected):
+    with pytest.raises(ValueError) as exc_info:
+        fig, ax = qutip.hinton(rho, x_basis, y_basis, color_style,
+                               label_top, cmap=cmap, colorbar=colorbar,
+                               fig=fig, ax=ax)
+    assert str(exc_info.value) == expected

From 7fef759645f934fdb0fff39eab0d1279275c9f52 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 12:38:11 +0900
Subject: [PATCH 474/602] make plot_wigner_sphere user-friendly

---
 qutip/visualization.py | 44 ++++++++++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index d98f007a7f..f82fb2c552 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -102,7 +102,8 @@ def _set_ticklabels(ax, ticklabels, ticks, axis, fontsize=14):
         )
 
 
-def plot_wigner_sphere(fig, ax, wigner, reflections):
+def plot_wigner_sphere(wigner, reflections, *, cmap=None,
+                       colorbar=True, fig=None, ax=None):
     """Plots a coloured Bloch sphere.
 
     Parameters
@@ -116,10 +117,28 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
     reflections : bool
         If the reflections of the sphere should be plotted as well.
 
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The ax context in which the plot will be drawn.
+
     Notes
     -----
     Special thanks to Russell P Rundle for writing this function.
     """
+
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+    if cmap is None:
+        cmap = _diverging_cmap()
+    print(cmap)
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     ax.set_zlabel("z")
@@ -134,7 +153,7 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
     wigner = np.real(wigner)
     wigner_max = np.real(np.amax(np.abs(wigner)))
 
-    wigner_c1 = cm.seismic_r((wigner + wigner_max) / (2 * wigner_max))
+    wigner_c1 = cmap((wigner + wigner_max) / (2 * wigner_max))
 
     # Plot coloured Bloch sphere:
     ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
@@ -142,12 +161,12 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
                     zorder=0.5, antialiased=None)
 
     if reflections:
-        wigner_c2 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # bottom
-        wigner_c3 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # side
-        wigner_c4 = cm.seismic_r((wigner[0:steps, 0:steps]+wigner_max) /
-                                 (2*wigner_max))  # back
+        wigner_c2 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+                         (2*wigner_max))  # bottom
+        wigner_c3 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+                         (2*wigner_max))  # side
+        wigner_c4 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+                         (2*wigner_max))  # back
 
         # Plot bottom reflection:
         ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
@@ -171,11 +190,12 @@ def plot_wigner_sphere(fig, ax, wigner, reflections):
                         antialiased=False)
 
     # Create colourbar:
-    m = cm.ScalarMappable(cmap=cm.seismic_r)
-    m.set_array([-wigner_max, wigner_max])
-    plt.colorbar(m, shrink=0.5, aspect=10)
+    if colorbar:
+        norm = mpl.colors.Normalize(-wigner_max, wigner_max)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
-    plt.show()
+    return fig, ax
 
 
 # Adopted from the SciPy Cookbook.

From 441ccd52a8845a8f854ee5c7f5e530db59285e89 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 12:45:19 +0900
Subject: [PATCH 475/602] minor bagfix

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index f82fb2c552..4921fc29f3 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -138,7 +138,7 @@ def plot_wigner_sphere(wigner, reflections, *, cmap=None,
 
     if cmap is None:
         cmap = _diverging_cmap()
-    print(cmap)
+
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     ax.set_zlabel("z")

From 10ef55778ac59095cefa724ce20a673aa6fa70a4 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 13:31:35 +0900
Subject: [PATCH 476/602] delete arguments which users can set

---
 qutip/visualization.py | 71 +++++++++++++-----------------------------
 1 file changed, 22 insertions(+), 49 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 4921fc29f3..4be89ff8d1 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -514,19 +514,6 @@ def _get_coord_info_new(renderer):
     axis._get_coord_info = _get_coord_info_new
 
 
-def _truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
-    """
-    truncates portion of a colormap and returns the new one
-    """
-    if isinstance(cmap, str):
-        cmap = plt.get_cmap(cmap)
-    new_cmap = mpl.colors.LinearSegmentedColormap.from_list(
-        'trunc({n},{a:.2f},{b:.2f})'.format(
-            n=cmap.name, a=minval, b=maxval),
-        cmap(np.linspace(minval, maxval, n)))
-    return new_cmap
-
-
 def _stick_to_planes(stick, azim, ax, M, spacing):
     """adjusts xlim and ylim in way that bars will
     stick to xz and yz planes
@@ -593,7 +580,7 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
+def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, *, cmap=None,
                      colorbar=True, fig=None, ax=None, options=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
@@ -603,24 +590,27 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     M : Matrix of Qobj
         The matrix to visualize
 
-    xlabels : list of strings
+    x_basis : list of strings
         list of x labels
 
-    ylabels : list of strings
+    y_basis : list of strings
         list of y labels
 
-    title : string
-        title of the plot (optional)
-
     limits : list/array with two float numbers
         The z-axis limits [min, max] (optional)
 
-    ax : a matplotlib axes instance
-        The axes context in which the plot will be drawn.
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
 
     colorbar : bool (default: True)
         show colorbar
 
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance
+        The axes context in which the plot will be drawn.
+
     options : dict
         A dictionary containing extra options for the plot.
         The names (keys) and values of the options are
@@ -629,19 +619,6 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
         'zticks' : list of numbers
             A list of z-axis tick locations.
 
-        'cmap' : string (default: 'jet')
-            The name of the color map to use.
-
-        'cmap_min' : float (default: 0.0)
-            The lower bound to truncate the color map at.
-            A value in range 0 - 1. The default, 0, leaves the lower
-            bound of the map unchanged.
-
-        'cmap_max' : float (default: 1.0)
-            The upper bound to truncate the color map at.
-            A value in range 0 - 1. The default, 1, leaves the upper
-            bound of the map unchanged.
-
         'bars_spacing' : float (default: 0.1)
             spacing between bars.
 
@@ -682,9 +659,6 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
             Whether to set the color of maximum and minimum z-values to the
             maximum and minimum colors in the colorbar (True) or not (False).
 
-        'figsize' : tuple of two numbers
-            The size of the figure.
-
     Returns
     -------
     fig, ax : tuple
@@ -699,11 +673,10 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     """
 
     # default options
-    default_opts = {'figsize': None, 'cmap': 'jet', 'cmap_min': 0.,
-                    'cmap_max': 1., 'zticks': None, 'bars_spacing': 0.2,
+    default_opts = { 'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
                     'shade': False, 'azim': -35, 'elev': 35,
-                    'proj_type': 'ortho', 'stick': False,
+                    'stick': False,
                     'cbar_pad': 0.04, 'cbar_to_z': False}
 
     # update default_opts from input options
@@ -746,9 +719,11 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
         norm = mpl.colors.Normalize(min(dz), max(dz))
     else:
         norm = mpl.colors.Normalize(z_min, z_max)
-    cmap = _truncate_colormap(default_opts['cmap'],
-                              default_opts['cmap_min'],
-                              default_opts['cmap_max'])
+
+    if cmap is None:
+        # change later
+        cmap = _sequential_cmap()
+
     colors = cmap(norm(dz))
 
     if ax is None:
@@ -756,7 +731,8 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
         ax = _axes3D(fig,
                      azim=default_opts['azim'] % 360,
                      elev=default_opts['elev'] % 360)
-        ax.set_proj_type(default_opts['proj_type'])
+
+    ax.set_proj_type('ortho')
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
              edgecolors=default_opts['bars_edgecolor'],
@@ -767,14 +743,11 @@ def matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None,
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
 
-    if title:
-        ax.set_title(title)
-
     # x axis
-    _update_xaxis(default_opts['bars_spacing'], M, ax, xlabels)
+    _update_xaxis(default_opts['bars_spacing'], M, ax, x_basis)
 
     # y axis
-    _update_yaxis(default_opts['bars_spacing'], M, ax, ylabels)
+    _update_yaxis(default_opts['bars_spacing'], M, ax, y_basis)
 
     # z axis
     _update_zaxis(ax, z_min, z_max, default_opts['zticks'])

From eb9cfcd0e9daad9488f2d49e075e4a6d61c8d33e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 16:18:08 +0900
Subject: [PATCH 477/602] change matrix_histogram

---
 qutip/visualization.py | 102 +++++++++++++++++++++++++++++++++--------
 1 file changed, 82 insertions(+), 20 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 4be89ff8d1..fba2ee8fe7 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -580,7 +580,7 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, *, cmap=None,
+def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=None, bar_style='real', color_style='real', *, cmap=None,
                      colorbar=True, fig=None, ax=None, options=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
@@ -596,8 +596,35 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, *, cmap=None,
     y_basis : list of strings
         list of y labels
 
-    limits : list/array with two float numbers
-        The z-axis limits [min, max] (optional)
+    limits : list/array with two float numbers, optional
+        The z-axis limits [min, max]
+
+    bar_style : string, default="real"
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"real"`` (default), each bar is plotted
+           as the real part of the corresponding matrix element
+        -  If set to ``"img"``, each bar is plotted
+           as the imaginary part of the corresponding matrix element
+        -  If set to ``"abs"``, each bar is plotted
+           as the absolute value of the corresponding matrix element
+        -  If set to ``"phase"`` (default), each bar is plotted
+           as the angle of the corresponding matrix element
+
+    color_limits : list/array with two float numbers, optional
+        The limits of colorbar [min, max]
+
+    color_style : string, default="real"
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"real"`` (default), each color is chosen
+           according to the real part of the corresponding matrix element.
+        -  If set to ``"img"``, each color is chosen according to
+           the imaginary part of the corresponding matrix element.
+        -  If set to ``"abs"``, each color is chosen according to
+           the absolute value of the corresponding matrix element.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
 
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
@@ -694,6 +721,10 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, *, cmap=None,
         raise ValueError("options must be a dictionary")
 
     if isinstance(M, Qobj):
+        if x_basis is None:
+            x_basis = list(_cb_labels([M.shape[0]])[0])
+        if y_basis is None:
+            y_basis = list(_cb_labels([M.shape[1]])[1])
         # extract matrix data from Qobj
         M = M.full()
 
@@ -703,38 +734,64 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, *, cmap=None,
     ypos = ypos.T.flatten() + 0.5
     zpos = np.zeros(n)
     dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
-    dz = np.real(M.flatten())
+
+    if bar_style == 'real':
+        bar_M = np.real(M.flatten())
+    elif bar_style == 'imag':
+        bar_M = np.imag(M.flatten())
+    elif bar_style == 'abs':
+        bar_M = np.abs(M.flatten())
+    else:
+        bar_M = angle(M.flatten())
 
     if isinstance(limits, list) and len(limits) == 2:
         z_min = limits[0]
         z_max = limits[1]
     else:
-        z_min = min(dz)
-        z_max = max(dz)
+        z_min = min(bar_M)
+        z_max = max(bar_M)
         if z_min == z_max:
             z_min -= 0.1
             z_max += 0.1
 
-    if default_opts['cbar_to_z']:
-        norm = mpl.colors.Normalize(min(dz), max(dz))
+    if color_style == 'real':
+        color_M = np.real(M.flatten())
+    elif color_style == 'imag':
+        color_M = np.imag(M.flatten())
+    elif color_style == 'abs':
+        color_M = np.abs(M.flatten())
+    else:
+        color_M = angle(M.flatten())
+
+    if isinstance(color_limits, list) and len(color_limits) == 2:
+        c_min = color_limits[0]
+        c_max = color_limits[1]
     else:
-        norm = mpl.colors.Normalize(z_min, z_max)
+        if color_style == 'phase':
+            c_min = -pi
+            c_max = pi
+        else:
+            c_min = min(color_M)
+            c_max = max(color_M)
+
+        if c_min == c_max:
+            c_min -= 0.1
+            c_max += 0.1
+
+    norm = mpl.colors.Normalize(c_min, c_max)
 
     if cmap is None:
         # change later
-        cmap = _sequential_cmap()
-
-    colors = cmap(norm(dz))
+        if color_style == 'phase':
+            cmap = _cyclic_cmap()
+        else:
+            cmap = _sequential_cmap()
 
-    if ax is None:
-        fig = plt.figure(figsize=default_opts['figsize'])
-        ax = _axes3D(fig,
-                     azim=default_opts['azim'] % 360,
-                     elev=default_opts['elev'] % 360)
+    colors = cmap(norm(color_M))
 
-    ax.set_proj_type('ortho')
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors,
+    ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
              edgecolors=default_opts['bars_edgecolor'],
              linewidths=default_opts['bars_lw'],
              alpha=default_opts['bars_alpha'],
@@ -761,7 +818,12 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, *, cmap=None,
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
                                          pad=default_opts['cbar_pad'])
-        mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+
+        if color_style == 'phase' and color_limits is None:
+            cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+            cb.set_ticklabels(
+                (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
 
     # removing margins
     _remove_margins(ax.xaxis)

From 9bd647b6f0a5574e50fe4cabf09f005ab283efbb Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 16:51:05 +0900
Subject: [PATCH 478/602] change matrix_histogram; change arguments to follow
 pep8

---
 qutip/visualization.py | 107 +++++++++++++++++++++--------------------
 1 file changed, 55 insertions(+), 52 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index fba2ee8fe7..bfe1c7477d 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -580,8 +580,8 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=None, bar_style='real', color_style='real', *, cmap=None,
-                     colorbar=True, fig=None, ax=None, options=None):
+def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
+                     colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -591,40 +591,10 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
         The matrix to visualize
 
     x_basis : list of strings
-        list of x labels
+        list of x ticklabels
 
     y_basis : list of strings
-        list of y labels
-
-    limits : list/array with two float numbers, optional
-        The z-axis limits [min, max]
-
-    bar_style : string, default="real"
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"real"`` (default), each bar is plotted
-           as the real part of the corresponding matrix element
-        -  If set to ``"img"``, each bar is plotted
-           as the imaginary part of the corresponding matrix element
-        -  If set to ``"abs"``, each bar is plotted
-           as the absolute value of the corresponding matrix element
-        -  If set to ``"phase"`` (default), each bar is plotted
-           as the angle of the corresponding matrix element
-
-    color_limits : list/array with two float numbers, optional
-        The limits of colorbar [min, max]
-
-    color_style : string, default="real"
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"real"`` (default), each color is chosen
-           according to the real part of the corresponding matrix element.
-        -  If set to ``"img"``, each color is chosen according to
-           the imaginary part of the corresponding matrix element.
-        -  If set to ``"abs"``, each color is chosen according to
-           the absolute value of the corresponding matrix element.
-        -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
+        list of y ticklabels
 
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
@@ -643,6 +613,36 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
         The names (keys) and values of the options are
         described below:
 
+        'limits' : list/array with two float numbers, optional
+            The z-axis limits [min, max]
+
+        'bar_style' : string, default="real"
+            Determines how colors are assigned to each square:
+
+            -  If set to ``"real"`` (default), each bar is plotted
+            as the real part of the corresponding matrix element
+            -  If set to ``"img"``, each bar is plotted
+            as the imaginary part of the corresponding matrix element
+            -  If set to ``"abs"``, each bar is plotted
+            as the absolute value of the corresponding matrix element
+            -  If set to ``"phase"`` (default), each bar is plotted
+            as the angle of the corresponding matrix element
+
+        'color_limits' : list/array with two float numbers, optional
+            The limits of colorbar [min, max]
+
+        'color_style' : string, default="real"
+            Determines how colors are assigned to each square:
+
+            -  If set to ``"real"`` (default), each color is chosen
+            according to the real part of the corresponding matrix element.
+            -  If set to ``"img"``, each color is chosen according to
+            the imaginary part of the corresponding matrix element.
+            -  If set to ``"abs"``, each color is chosen according to
+            the absolute value of the corresponding matrix element.
+            -  If set to ``"phase"``, each color is chosen according to
+            the angle of the corresponding matrix element.
+
         'zticks' : list of numbers
             A list of z-axis tick locations.
 
@@ -700,10 +700,10 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
     """
 
     # default options
-    default_opts = { 'zticks': None, 'bars_spacing': 0.2,
+    default_opts = {'limits': None, 'bar_style': 'real', 'color_limits': None,
+                    'color_style': 'real', 'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-                    'shade': False, 'azim': -35, 'elev': 35,
-                    'stick': False,
+                    'shade': False, 'azim': -35, 'elev': 35, 'stick': False,
                     'cbar_pad': 0.04, 'cbar_to_z': False}
 
     # update default_opts from input options
@@ -735,18 +735,19 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
     zpos = np.zeros(n)
     dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
 
-    if bar_style == 'real':
+    if default_opts['bar_style'] == 'real':
         bar_M = np.real(M.flatten())
-    elif bar_style == 'imag':
+    elif default_opts['bar_style'] == 'imag':
         bar_M = np.imag(M.flatten())
-    elif bar_style == 'abs':
+    elif default_opts['bar_style'] == 'abs':
         bar_M = np.abs(M.flatten())
     else:
         bar_M = angle(M.flatten())
 
-    if isinstance(limits, list) and len(limits) == 2:
-        z_min = limits[0]
-        z_max = limits[1]
+    if isinstance(default_opts['limits'], list) and \
+            len(default_opts['limits']) == 2:
+        z_min = default_opts['limits'][0]
+        z_max = default_opts['limits'][1]
     else:
         z_min = min(bar_M)
         z_max = max(bar_M)
@@ -754,20 +755,21 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
             z_min -= 0.1
             z_max += 0.1
 
-    if color_style == 'real':
+    if default_opts['color_style'] == 'real':
         color_M = np.real(M.flatten())
-    elif color_style == 'imag':
+    elif default_opts['color_style'] == 'imag':
         color_M = np.imag(M.flatten())
-    elif color_style == 'abs':
+    elif default_opts['color_style'] == 'abs':
         color_M = np.abs(M.flatten())
     else:
         color_M = angle(M.flatten())
 
-    if isinstance(color_limits, list) and len(color_limits) == 2:
-        c_min = color_limits[0]
-        c_max = color_limits[1]
+    if isinstance(default_opts['color_limits'], list) and \
+            len(default_opts['color_limits']) == 2:
+        c_min = default_opts['color_limits'][0]
+        c_max = default_opts['color_limits'][1]
     else:
-        if color_style == 'phase':
+        if default_opts['color_style'] == 'phase':
             c_min = -pi
             c_max = pi
         else:
@@ -782,7 +784,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
 
     if cmap is None:
         # change later
-        if color_style == 'phase':
+        if default_opts['color_style'] == 'phase':
             cmap = _cyclic_cmap()
         else:
             cmap = _sequential_cmap()
@@ -820,7 +822,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, color_limits=No
                                          pad=default_opts['cbar_pad'])
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
-        if color_style == 'phase' and color_limits is None:
+        if default_opts['color_style'] == 'phase' and \
+                default_opts['color_limits'] is None:
             cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
             cb.set_ticklabels(
                 (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))

From 81e6b899ee30a48e9153580cf3d20ace9463ca8f Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 16:54:40 +0900
Subject: [PATCH 479/602] add threshold

---
 qutip/visualization.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index bfe1c7477d..b3b2c45bb5 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -686,6 +686,9 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
             Whether to set the color of maximum and minimum z-values to the
             maximum and minimum colors in the colorbar (True) or not (False).
 
+        'threshold': float, optional
+            Threshold for when bars of smaller height should be transparent. If
+            not set, all bars are colored according to the color map.
     Returns
     -------
     fig, ax : tuple
@@ -704,7 +707,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
                     'color_style': 'real', 'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
                     'shade': False, 'azim': -35, 'elev': 35, 'stick': False,
-                    'cbar_pad': 0.04, 'cbar_to_z': False}
+                    'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
 
     # update default_opts from input options
     if options is None:
@@ -791,6 +794,9 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
 
     colors = cmap(norm(color_M))
 
+    if default_opts['threshold'] is not None:
+        colors[:, 3] = 1 * (color_M > default_opts['threshold'])
+
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,

From b5f481f87a10a75bca2c5861ad1d8fbb46c0bb45 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 18:17:46 +0900
Subject: [PATCH 480/602] add colorbar label

---
 qutip/visualization.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index b3b2c45bb5..a9f44c80e1 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -828,11 +828,18 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
                                          pad=default_opts['cbar_pad'])
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
-        if default_opts['color_style'] == 'phase' and \
-                default_opts['color_limits'] is None:
-            cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-            cb.set_ticklabels(
-                (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
+        if default_opts['color_style'] == 'real':
+            cb.set_label('real')
+        elif default_opts['color_style'] == 'img':
+            cb.set_label('imaginary')
+        elif default_opts['color_style'] == 'abs':
+            cb.set_label('absolute')
+        else:
+            cb.set_label('arg')
+            if default_opts['color_limits'] is None:
+                cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+                cb.set_ticklabels(
+                    (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
 
     # removing margins
     _remove_margins(ax.xaxis)

From ab5f0e508473df9ad11945b5fba5bcfece92610e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 18:21:22 +0900
Subject: [PATCH 481/602] add azim and elev

---
 qutip/visualization.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index a9f44c80e1..4c915972fd 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -821,6 +821,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
     _stick_to_planes(default_opts['stick'],
                      default_opts['azim'], ax, M,
                      default_opts['bars_spacing'])
+    ax.view_init(azim=default_opts['azim'], elev=default_opts['elev'])
 
     # color axis
     if colorbar:

From c68282323fd43d7bd106698d205ce69709e883b8 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 18:44:05 +0900
Subject: [PATCH 482/602] refactoring

---
 qutip/visualization.py | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 4c915972fd..35e83cee08 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -580,6 +580,17 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
+def _get_matrix_components(option, M):
+    if option == 'real':
+        return np.real(M.flatten())
+    elif option == 'imag':
+        return np.imag(M.flatten())
+    elif option == 'abs':
+        return np.abs(M.flatten())
+    else:
+        return angle(M.flatten())
+
+
 def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
                      colorbar=True, fig=None, ax=None):
     """
@@ -738,14 +749,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
     zpos = np.zeros(n)
     dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
 
-    if default_opts['bar_style'] == 'real':
-        bar_M = np.real(M.flatten())
-    elif default_opts['bar_style'] == 'imag':
-        bar_M = np.imag(M.flatten())
-    elif default_opts['bar_style'] == 'abs':
-        bar_M = np.abs(M.flatten())
-    else:
-        bar_M = angle(M.flatten())
+    bar_M = _get_matrix_components(default_opts['bar_style'], M)
 
     if isinstance(default_opts['limits'], list) and \
             len(default_opts['limits']) == 2:
@@ -758,14 +762,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
             z_min -= 0.1
             z_max += 0.1
 
-    if default_opts['color_style'] == 'real':
-        color_M = np.real(M.flatten())
-    elif default_opts['color_style'] == 'imag':
-        color_M = np.imag(M.flatten())
-    elif default_opts['color_style'] == 'abs':
-        color_M = np.abs(M.flatten())
-    else:
-        color_M = angle(M.flatten())
+    color_M = _get_matrix_components(default_opts['color_style'], M)
 
     if isinstance(default_opts['color_limits'], list) and \
             len(default_opts['color_limits']) == 2:

From 0351ee53d0fc4e5088b38580946eb7376cc45b59 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 18:59:07 +0900
Subject: [PATCH 483/602] reflection is optional

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 35e83cee08..df30c33e86 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -102,7 +102,7 @@ def _set_ticklabels(ax, ticklabels, ticks, axis, fontsize=14):
         )
 
 
-def plot_wigner_sphere(wigner, reflections, *, cmap=None,
+def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
                        colorbar=True, fig=None, ax=None):
     """Plots a coloured Bloch sphere.
 

From 65731c80d54b4e904f264c74da5b7108825f87e8 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 10 Jul 2023 19:04:05 +0900
Subject: [PATCH 484/602] edit docstring

---
 qutip/visualization.py | 48 +++++++++++++++++++++---------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index df30c33e86..c1ad3303dc 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -108,13 +108,10 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
 
     Parameters
     ----------
-    fig : :obj:`matplotlib.figure.Figure`
-        An instance of :obj:`~matplotlib.figure.Figure`.
-    ax : :obj:`matplotlib.axes.Axes`
-        An axes instance in the given figure.
     wigner : list of float
         The wigner transformation at `steps` different theta and phi.
-    reflections : bool
+
+    reflections : bool, default=False
         If the reflections of the sphere should be plotted as well.
 
     cmap : a matplotlib colormap instance, optional
@@ -129,6 +126,12 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     ax : a matplotlib axes instance, optional
         The ax context in which the plot will be drawn.
 
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
     Notes
     -----
     Special thanks to Russell P Rundle for writing this function.
@@ -601,25 +604,25 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
     M : Matrix of Qobj
         The matrix to visualize
 
-    x_basis : list of strings
+    x_basis : list of strings, optional
         list of x ticklabels
 
-    y_basis : list of strings
+    y_basis : list of strings, optional
         list of y ticklabels
 
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 
-    colorbar : bool (default: True)
+    colorbar : bool, default=True
         show colorbar
 
     fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
-    ax : a matplotlib axes instance
+    ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
-    options : dict
+    options : dict, optional
         A dictionary containing extra options for the plot.
         The names (keys) and values of the options are
         described below:
@@ -654,46 +657,43 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
             -  If set to ``"phase"``, each color is chosen according to
             the angle of the corresponding matrix element.
 
-        'zticks' : list of numbers
+        'zticks' : list of numbers, optional
             A list of z-axis tick locations.
 
-        'bars_spacing' : float (default: 0.1)
+        'bars_spacing' : float, default=0.1
             spacing between bars.
 
-        'bars_alpha' : float (default: 1.)
+        'bars_alpha' : float, default=1.
             transparency of bars, should be in range 0 - 1
 
-        'bars_lw' : float (default: 0.5)
+        'bars_lw' : float, default=0.5
             linewidth of bars' edges.
 
-        'bars_edgecolor' : color (default: 'k')
+        'bars_edgecolor' : color, default='k'
             The colors of the bars' edges.
             Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
 
-        'shade' : bool (default: True)
+        'shade' : bool, default=True
             Whether to shade the dark sides of the bars (True) or not (False).
             The shading is relative to plot's source of light.
 
-        'azim' : float
+        'azim' : float, default=-35
             The azimuthal viewing angle.
 
-        'elev' : float
+        'elev' : float, default=35
             The elevation viewing angle.
 
-        'proj_type' : string (default: 'ortho' if ax is not passed)
-            The type of projection ('ortho' or 'persp')
-
-        'stick' : bool (default: False)
+        'stick' : bool, default=False
             Changes xlim and ylim in such a way that bars next to
             XZ and YZ planes will stick to those planes.
             This option has no effect if ``ax`` is passed as a parameter.
 
-        'cbar_pad' : float (default: 0.04)
+        'cbar_pad' : float, default=0.04
             The fraction of the original axes between the colorbar
             and the new image axes.
             (i.e. the padding between the 3D figure and the colorbar).
 
-        'cbar_to_z' : bool (default: False)
+        'cbar_to_z' : bool, default=False
             Whether to set the color of maximum and minimum z-values to the
             maximum and minimum colors in the colorbar (True) or not (False).
 

From 36cb02196c93707996fd84a31c30464e29823c8b Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 13:51:37 +0900
Subject: [PATCH 485/602] update arguments and error status

---
 qutip/visualization.py | 108 +++++++++++++++++++++--------------------
 1 file changed, 55 insertions(+), 53 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index c1ad3303dc..d577fa3f8a 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -583,19 +583,22 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     ax.set_zlim3d([min(z_min, 0), z_max])
 
 
-def _get_matrix_components(option, M):
+def _get_matrix_components(option, M, argument):
     if option == 'real':
         return np.real(M.flatten())
-    elif option == 'imag':
+    elif option == 'img':
         return np.imag(M.flatten())
     elif option == 'abs':
         return np.abs(M.flatten())
-    else:
+    elif option == 'phase':
         return angle(M.flatten())
+    else:
+        raise ValueError(f"got an unexpected argument, {option} for {argument}")
 
 
-def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
-                     colorbar=True, fig=None, ax=None):
+def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, bar_style=None,
+                     color_limits=None, color_style=None, options=None, *,
+                     cmap=None, colorbar=True, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -610,6 +613,36 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
     y_basis : list of strings, optional
         list of y ticklabels
 
+    limits : list/array with two float numbers, optional
+        The z-axis limits [min, max]
+
+    bar_style : string, default="real"
+
+        -  If set to ``"real"`` (default), each bar is plotted
+        as the real part of the corresponding matrix element
+        Determines how colors are assigned to each square:
+        -  If set to ``"img"``, each bar is plotted
+        as the imaginary part of the corresponding matrix element
+        -  If set to ``"abs"``, each bar is plotted
+        as the absolute value of the corresponding matrix element
+        -  If set to ``"phase"`` (default), each bar is plotted
+        as the angle of the corresponding matrix element
+
+    color_limits : list/array with two float numbers, optional
+        The limits of colorbar [min, max]
+
+    color_style : string, default="real"
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"real"`` (default), each color is chosen
+        according to the real part of the corresponding matrix element.
+        -  If set to ``"img"``, each color is chosen according to
+        the imaginary part of the corresponding matrix element.
+        -  If set to ``"abs"``, each color is chosen according to
+        the absolute value of the corresponding matrix element.
+        -  If set to ``"phase"``, each color is chosen according to
+            the angle of the corresponding matrix element.
+
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 
@@ -627,36 +660,6 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
         The names (keys) and values of the options are
         described below:
 
-        'limits' : list/array with two float numbers, optional
-            The z-axis limits [min, max]
-
-        'bar_style' : string, default="real"
-            Determines how colors are assigned to each square:
-
-            -  If set to ``"real"`` (default), each bar is plotted
-            as the real part of the corresponding matrix element
-            -  If set to ``"img"``, each bar is plotted
-            as the imaginary part of the corresponding matrix element
-            -  If set to ``"abs"``, each bar is plotted
-            as the absolute value of the corresponding matrix element
-            -  If set to ``"phase"`` (default), each bar is plotted
-            as the angle of the corresponding matrix element
-
-        'color_limits' : list/array with two float numbers, optional
-            The limits of colorbar [min, max]
-
-        'color_style' : string, default="real"
-            Determines how colors are assigned to each square:
-
-            -  If set to ``"real"`` (default), each color is chosen
-            according to the real part of the corresponding matrix element.
-            -  If set to ``"img"``, each color is chosen according to
-            the imaginary part of the corresponding matrix element.
-            -  If set to ``"abs"``, each color is chosen according to
-            the absolute value of the corresponding matrix element.
-            -  If set to ``"phase"``, each color is chosen according to
-            the angle of the corresponding matrix element.
-
         'zticks' : list of numbers, optional
             A list of z-axis tick locations.
 
@@ -714,8 +717,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
     """
 
     # default options
-    default_opts = {'limits': None, 'bar_style': 'real', 'color_limits': None,
-                    'color_style': 'real', 'zticks': None, 'bars_spacing': 0.2,
+    default_opts = {'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
                     'shade': False, 'azim': -35, 'elev': 35, 'stick': False,
                     'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
@@ -749,12 +751,12 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
     zpos = np.zeros(n)
     dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
 
-    bar_M = _get_matrix_components(default_opts['bar_style'], M)
+    bar_M = _get_matrix_components(bar_style, M, 'bar_style')
 
-    if isinstance(default_opts['limits'], list) and \
-            len(default_opts['limits']) == 2:
-        z_min = default_opts['limits'][0]
-        z_max = default_opts['limits'][1]
+    if isinstance(limits, list) and \
+            len(limits) == 2:
+        z_min = limits[0]
+        z_max = limits[1]
     else:
         z_min = min(bar_M)
         z_max = max(bar_M)
@@ -762,14 +764,14 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
             z_min -= 0.1
             z_max += 0.1
 
-    color_M = _get_matrix_components(default_opts['color_style'], M)
+    color_M = _get_matrix_components(color_style, M, 'color_style')
 
-    if isinstance(default_opts['color_limits'], list) and \
-            len(default_opts['color_limits']) == 2:
-        c_min = default_opts['color_limits'][0]
-        c_max = default_opts['color_limits'][1]
+    if isinstance(color_limits, list) and \
+            len(color_limits) == 2:
+        c_min = color_limits[0]
+        c_max = color_limits[1]
     else:
-        if default_opts['color_style'] == 'phase':
+        if color_style == 'phase':
             c_min = -pi
             c_max = pi
         else:
@@ -784,7 +786,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
 
     if cmap is None:
         # change later
-        if default_opts['color_style'] == 'phase':
+        if color_style == 'phase':
             cmap = _cyclic_cmap()
         else:
             cmap = _sequential_cmap()
@@ -826,15 +828,15 @@ def matrix_histogram(M, x_basis=None, y_basis=None, options=None, *, cmap=None,
                                          pad=default_opts['cbar_pad'])
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
-        if default_opts['color_style'] == 'real':
+        if color_style == 'real':
             cb.set_label('real')
-        elif default_opts['color_style'] == 'img':
+        elif color_style == 'img':
             cb.set_label('imaginary')
-        elif default_opts['color_style'] == 'abs':
+        elif color_style == 'abs':
             cb.set_label('absolute')
         else:
             cb.set_label('arg')
-            if default_opts['color_limits'] is None:
+            if color_limits is None:
                 cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
                 cb.set_ticklabels(
                     (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))

From 394ab6d0042ca28384b3820263e8d2bc46a84006 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 13:53:09 +0900
Subject: [PATCH 486/602] minor change

---
 qutip/visualization.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index d577fa3f8a..2c2cdde30d 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -593,12 +593,14 @@ def _get_matrix_components(option, M, argument):
     elif option == 'phase':
         return angle(M.flatten())
     else:
-        raise ValueError(f"got an unexpected argument, {option} for {argument}")
+        raise ValueError(f"got an unexpected argument, \
+                         {option} for {argument}")
 
 
-def matrix_histogram(M, x_basis=None, y_basis=None, limits=None, bar_style=None,
-                     color_limits=None, color_style=None, options=None, *,
-                     cmap=None, colorbar=True, fig=None, ax=None):
+def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
+                     bar_style=None, color_limits=None, color_style=None,
+                     options=None, *, cmap=None, colorbar=True,
+                     fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 

From 0959610bfe64c27ee931106dd38655e736e2a660 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 14:36:06 +0900
Subject: [PATCH 487/602] change the way to parametrize

---
 qutip/tests/test_visualization.py | 75 ++++++++++++++++---------------
 1 file changed, 40 insertions(+), 35 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index a54e467fd5..f3b8ac51ba 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -3,47 +3,52 @@
 import matplotlib as mpl
 
 
-@pytest.mark.parametrize('rho, x_basis, y_basis, color_style,\
-           label_top, cmap, colorbar, fig, ax', [
-    (qutip.rand_dm(5), None, None, "scaled", True, None, None, None, None),
-    (qutip.operator_to_vector(qutip.rand_dm(5)),
-     None, None, "scaled", True, None, None, None, None),
-    (qutip.operator_to_vector(qutip.rand_dm(5)).dag(),
-     None, None, "scaled", True, None, None, None, None),
-    (qutip.spre(qutip.rand_dm(4)),
-     None, None, "scaled", True, None, None, None, None),
-    (qutip.rand_dm(5),
-     [1, 2, 3, 4, 5], None, "scaled", True, None, None, None, None),
-    (qutip.rand_dm(5),
-     None, [1, 2, 3, 4, 5], "scaled", True, None, None, None, None),
-    (qutip.rand_dm(5), None, None, "scaled", True, None, None, None, None),
-    (qutip.rand_dm(5), None, None, "threshold", True, None, None, None, None),
-    (qutip.rand_dm(5), None, None, "phase", True, None, None, None, None),
+def to_oper_bra(oper):
+    return qutip.operator_to_vector(oper).dag()
+
+
+def to_oper(oper):
+    return oper
+
+
+@pytest.mark.parametrize('transform, args', [
+    (to_oper, {}),
+    (qutip.operator_to_vector, {}),
+    (to_oper_bra, {}),
+    (qutip.spre, {}),
+    (to_oper, {'x_basis': [0, 1, 2, 3]}),
+    (to_oper, {'y_basis': [0, 1, 2, 3]}),
+    (to_oper, {'color_style': 'threshold'}),
+    (to_oper, {'color_style': 'phase'}),
+    (to_oper, {'colorbar': False}),
 ])
-def test_hinton(rho, x_basis, y_basis, color_style,
-                label_top, cmap, colorbar, fig, ax):
-    fig, ax = qutip.hinton(rho, x_basis, y_basis, color_style,
-                           label_top, cmap=cmap, colorbar=colorbar,
-                           fig=fig, ax=ax)
+def test_hinton(transform, args):
+    rho = transform(qutip.rand_dm(4))
+    fig, ax = qutip.hinton(rho, **args)
 
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
 
 
-@pytest.mark.parametrize('rho, x_basis, y_basis, color_style,\
-           label_top, cmap, colorbar, fig, ax, expected', [
-    (qutip.basis(2, 0), None, None, "scaled", True, None, None,
-     None, None, "Input quantum object must be an operator or superoperator."),
-    (qutip.rand_dm(5), None, None, "color_style", True, None, None,
-     None, None, "Unknown color style color_style for Hinton diagrams."),
-    (qutip.spre(qutip.rand_dm(5)),
-     None, None, "scaled", True, None, None, None, None,
+@pytest.mark.parametrize('transform, args, error_message', [
+    (to_oper, {},
+     "Input quantum object must be an operator or superoperator.")
+])
+def test_hinton_ValueError0(transform, args, error_message):
+    rho = transform(qutip.basis(2, 0))
+    with pytest.raises(ValueError) as exc_info:
+        fig, ax = qutip.hinton(rho, **args)
+    assert str(exc_info.value) == error_message
+
+
+@pytest.mark.parametrize('transform, args, error_message', [
+    (to_oper, {'color_style': 'color_style'},
+     "Unknown color style color_style for Hinton diagrams."),
+    (qutip.spre, {},
      "Hinton plots of superoperators are currently only supported for qubits.")
 ])
-def test_hinton_ValueError(rho, x_basis, y_basis, color_style,
-                           label_top, cmap, colorbar, fig, ax, expected):
+def test_hinton_ValueError1(transform, args, error_message):
+    rho = transform(qutip.rand_dm(5))
     with pytest.raises(ValueError) as exc_info:
-        fig, ax = qutip.hinton(rho, x_basis, y_basis, color_style,
-                               label_top, cmap=cmap, colorbar=colorbar,
-                               fig=fig, ax=ax)
-    assert str(exc_info.value) == expected
+        fig, ax = qutip.hinton(rho, **args)
+    assert str(exc_info.value) == error_message

From 27ab9e919cd82332dd43ed61d85c75593e8d9dff Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 19:36:03 +0900
Subject: [PATCH 488/602] add default values

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 2c2cdde30d..5d5c7ff0ad 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -598,7 +598,7 @@ def _get_matrix_components(option, M, argument):
 
 
 def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
-                     bar_style=None, color_limits=None, color_style=None,
+                     bar_style='real', color_limits=None, color_style='real',
                      options=None, *, cmap=None, colorbar=True,
                      fig=None, ax=None):
     """

From 062c1fa071ab467fc0bb0c73f5b390eda1fcdefe Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 20:06:28 +0900
Subject: [PATCH 489/602] update on threshold option

---
 qutip/visualization.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 5d5c7ff0ad..23b75dec1a 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -721,7 +721,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     # default options
     default_opts = {'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-                    'shade': False, 'azim': -35, 'elev': 35, 'stick': False,
+                    'shade': True, 'azim': -35, 'elev': 35, 'stick': False,
                     'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
 
     # update default_opts from input options
@@ -796,14 +796,16 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     colors = cmap(norm(color_M))
 
     if default_opts['threshold'] is not None:
-        colors[:, 3] = 1 * (color_M > default_opts['threshold'])
+        colors[:, 3] = 1 * (bar_M >= default_opts['threshold']) * default_opts['bars_alpha']
+
+        idx, = np.where(bar_M < default_opts['threshold'])
+        bar_M[idx] = 0
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
              edgecolors=default_opts['bars_edgecolor'],
              linewidths=default_opts['bars_lw'],
-             alpha=default_opts['bars_alpha'],
              shade=default_opts['shade'])
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0

From d6cd8da718ee002cc62d2b91f0306c5d653f5aa8 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 20:07:43 +0900
Subject: [PATCH 490/602] pep8

---
 qutip/visualization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 23b75dec1a..a3ccb36370 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -796,7 +796,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     colors = cmap(norm(color_M))
 
     if default_opts['threshold'] is not None:
-        colors[:, 3] = 1 * (bar_M >= default_opts['threshold']) * default_opts['bars_alpha']
+        colors[:, 3] = 1 * (bar_M >= default_opts['threshold']) * \
+            default_opts['bars_alpha']
 
         idx, = np.where(bar_M < default_opts['threshold'])
         bar_M[idx] = 0

From a0feb2deb8d0d93cbedab94c96ca384ad6d72cb5 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 20:34:08 +0900
Subject: [PATCH 491/602] minor fix

---
 qutip/visualization.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index a3ccb36370..f915658f83 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -795,9 +795,10 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     colors = cmap(norm(color_M))
 
+    colors[:, 3] *= default_opts['bars_alpha']
+
     if default_opts['threshold'] is not None:
-        colors[:, 3] = 1 * (bar_M >= default_opts['threshold']) * \
-            default_opts['bars_alpha']
+        colors[:, 3] = 1 * (bar_M >= default_opts['threshold'])
 
         idx, = np.where(bar_M < default_opts['threshold'])
         bar_M[idx] = 0

From b4c005b9ab16ababc9b584c4d7f38812a51f8d9b Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 11 Jul 2023 20:48:04 +0900
Subject: [PATCH 492/602] minor fix

---
 qutip/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index f915658f83..75a4f464cd 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -795,7 +795,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     colors = cmap(norm(color_M))
 
-    colors[:, 3] *= default_opts['bars_alpha']
+    colors[:, 3] = default_opts['bars_alpha']
 
     if default_opts['threshold'] is not None:
         colors[:, 3] = 1 * (bar_M >= default_opts['threshold'])

From 6ada27eecaeaf5e5d80c930894445f77da08129b Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 12 Jul 2023 19:58:40 +0900
Subject: [PATCH 493/602] replace matrix_histogram_complex with
 matrix_histogram

---
 qutip/tomography.py    |  16 ++---
 qutip/visualization.py | 137 +++--------------------------------------
 2 files changed, 16 insertions(+), 137 deletions(-)

diff --git a/qutip/tomography.py b/qutip/tomography.py
index 72d3d0d3c8..a876f353bb 100644
--- a/qutip/tomography.py
+++ b/qutip/tomography.py
@@ -3,7 +3,7 @@
 from numpy import hstack, real, imag
 import scipy.linalg as la
 from . import tensor, spre, spost, stack_columns, unstack_columns
-from .visualization import matrix_histogram, matrix_histogram_complex
+from .visualization import matrix_histogram
 import itertools
 
 try:
@@ -71,10 +71,11 @@ def qpt_plot(chi, lbls_list, title=None, fig=None, axes=None):
         xlabels.append("".join([lbls_list[k][inds[k]]
                                 for k in range(len(lbls_list))]))
 
-    matrix_histogram(real(chi), xlabels, xlabels,
-                     title=r"real($\chi$)", limits=[-1, 1], ax=axes[0])
-    matrix_histogram(imag(chi), xlabels, xlabels,
-                     title=r"imag($\chi$)", limits=[-1, 1], ax=axes[1])
+    matrix_histogram(real(chi), xlabels, xlabels, limits=[-1, 1], ax=axes[0])
+    axes[0].set_title(r"real($\chi$)")
+
+    matrix_histogram(imag(chi), xlabels, xlabels, limits=[-1, 1], ax=axes[1])
+    axes[1].set_title(r"imag($\chi$)")
 
     if title and fig:
         fig.suptitle(title)
@@ -132,8 +133,9 @@ def qpt_plot_combined(chi, lbls_list, title=None,
     if not title:
         title = r"$\chi$"
 
-    matrix_histogram_complex(chi, xlabels, xlabels, ax=ax,
-                             threshold=threshold)
+    matrix_histogram(chi, xlabels, xlabels, bar_style='abs',
+                     color_style='phase',
+                     options={'threshold':threshold}, ax=ax)
     ax.set_title(title)
 
     return fig, ax
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 75a4f464cd..6704faaf84 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -272,14 +272,14 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
         Determines how colors are assigned to each square:
 
         -  If set to ``"scaled"`` (default), each color is chosen by
-           passing the absolute value of the corresponding matrix
-           element into `cmap` with the sign of the real part.
+        passing the absolute value of the corresponding matrix
+        element into `cmap` with the sign of the real part.
         -  If set to ``"threshold"``, each square is plotted as
-           the maximum of `cmap` for the positive real part and as
-           the minimum for the negative part of the matrix element;
-           note that this generalizes `"threshold"` to complex numbers.
+        the maximum of `cmap` for the positive real part and as
+        the minimum for the negative part of the matrix element;
+        note that this generalizes `"threshold"` to complex numbers.
         -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
+        the angle of the corresponding matrix element.
 
     label_top : bool, default=True
         If True, x ticklabels will be placed on top, otherwise
@@ -643,7 +643,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         -  If set to ``"abs"``, each color is chosen according to
         the absolute value of the corresponding matrix element.
         -  If set to ``"phase"``, each color is chosen according to
-            the angle of the corresponding matrix element.
+        the angle of the corresponding matrix element.
 
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
@@ -855,129 +855,6 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     return fig, ax
 
 
-def matrix_histogram_complex(M, x_basis=None, y_basis=None, phase_limits=None,
-                             threshold=None, *, cmap=None, colorbar=True,
-                             fig=None, ax=None):
-    """
-    Draw a histogram for the amplitudes of matrix M, using the argument
-    of each element for coloring the bars, with the given x and y labels
-    and title.
-
-    Parameters
-    ----------
-    M : Matrix of Qobj
-        The matrix to visualize
-
-    x_basis : list of strings or False, optional
-        list of x ticklabels to represent x basis of the input.
-
-    y_basis : list of strings or False, optional
-        list of y ticklabels to represent y basis of the input.
-
-    phase_limits : list/array with two float numbers, optional
-        The phase-axis (colorbar) limits [min, max] (optional)
-
-    threshold: float, optional
-        Threshold for when bars of smaller height should be transparent. If
-        not set, all bars are colored according to the color map.
-
-    cmap : a matplotlib colormap instance, optional
-        Color map to use when plotting.
-
-    colorbar : bool, optional
-        Whether (True) or not (False) a colorbar should be attached.
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The axes context in which the plot will be drawn.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not valid.
-
-    """
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-    # set angle
-    ax.view_init(azim=-35, elev=35)
-
-    if isinstance(M, Qobj):
-        if x_basis is None:
-            x_basis = list(_cb_labels([M.shape[0]])[0])
-        if y_basis is None:
-            y_basis = list(_cb_labels([M.shape[1]])[1])
-        # extract matrix data from Qobj
-        M = M.full()
-
-    n = np.size(M)
-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-    xpos = xpos.T.flatten() - 0.5
-    ypos = ypos.T.flatten() - 0.5
-    zpos = np.zeros(n)
-    dx = dy = 0.8 * np.ones(n)
-    Mvec = M.flatten()
-    dz = abs(Mvec)
-
-    # make small numbers real, to avoid random colors
-    idx, = np.where(abs(Mvec) < 0.001)
-    Mvec[idx] = abs(Mvec[idx])
-
-    if phase_limits:  # check that limits is a list type
-        phase_min = phase_limits[0]
-        phase_max = phase_limits[1]
-    else:
-        phase_min = -pi
-        phase_max = pi
-
-    norm = mpl.colors.Normalize(phase_min, phase_max)
-
-    if cmap is None:
-        cmap = _cyclic_cmap()
-
-    colors = cmap(norm(angle(Mvec)))
-    if threshold is not None:
-        colors[:, 3] = 1 * (dz > threshold)
-
-    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)
-
-    # x axis
-    xticks = -0.5 + np.arange(M.shape[0])
-    if x_basis:
-        _set_ticklabels(ax, x_basis, xticks, 'x')
-    else:
-        ax.tick_params(axis='x', which='both',
-                       bottom=False, labelbottom=False)
-
-    # y axis
-    yticks = -0.5 + np.arange(M.shape[1])
-    if y_basis:
-        _set_ticklabels(ax, y_basis, yticks, 'y')
-    else:
-        ax.tick_params(axis='y', which='both', left=False, labelleft=False)
-
-    # limit z axis by default
-    ax.set_zlim3d([0, max(max(dz), 1)])
-
-    # color axis
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.05)
-        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-        cb.set_ticklabels(
-            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
-        cb.set_label('arg')
-
-    return fig, ax
-
-
 def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
                        fig=None, ax=None):
     """

From 1e0d02ff17ce0335fa4802d110eb7893d83e1ff3 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 12 Jul 2023 20:11:46 +0900
Subject: [PATCH 494/602] bugfix

---
 qutip/visualization.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 6704faaf84..403e439cb2 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -4,8 +4,7 @@
 """
 
 __all__ = ['plot_wigner_sphere', 'hinton', 'sphereplot',
-           'matrix_histogram', 'matrix_histogram_complex',
-           'plot_energy_levels', 'plot_fock_distribution',
+           'matrix_histogram', 'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
            'plot_spin_distribution', 'complex_array_to_rgb',
            'plot_qubism', 'plot_schmidt']

From 477926e25ccc6ec1b325be7819d776e3b4d4a0bf Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 12 Jul 2023 20:14:56 +0900
Subject: [PATCH 495/602] towncrier

---
 doc/changes/2193.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2193.feature

diff --git a/doc/changes/2193.feature b/doc/changes/2193.feature
new file mode 100644
index 0000000000..6d487ad604
--- /dev/null
+++ b/doc/changes/2193.feature
@@ -0,0 +1 @@
+changed arguments and applied colorblind_safe to plot_wigner_sphere and matrix_histogram in visualization.py by Yuji Tamakoshi
\ No newline at end of file

From 330f067ef6e30cd9976f5f12ca482c77dad0467e Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 12 Jul 2023 21:38:55 +0900
Subject: [PATCH 496/602] add pytests

---
 qutip/tests/test_visualization.py | 127 ++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index f3b8ac51ba..42be54b7f4 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -1,6 +1,8 @@
 import pytest
 import qutip
+import numpy as np
 import matplotlib as mpl
+import matplotlib.pyplot as plt
 
 
 def to_oper_bra(oper):
@@ -24,7 +26,9 @@ def to_oper(oper):
 ])
 def test_hinton(transform, args):
     rho = transform(qutip.rand_dm(4))
+
     fig, ax = qutip.hinton(rho, **args)
+    plt.close()
 
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
@@ -52,3 +56,126 @@ def test_hinton_ValueError1(transform, args, error_message):
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.hinton(rho, **args)
     assert str(exc_info.value) == error_message
+
+
+@pytest.mark.parametrize('args', [
+    ({'cmap': mpl.cm.cividis}),
+    ({'colorbar': False}),
+])
+def test_sphereplot(args):
+    theta = np.linspace(0, np.pi, 90)
+    phi = np.linspace(0, 2 * np.pi, 60)
+
+    fig, ax = qutip.sphereplot(theta, phi,
+                               qutip.orbital(theta, phi, qutip.basis(3, 0)).T,
+                               **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('args', [
+    ({'h_labels': ['H0', 'H0+Hint']}),
+    ({'energy_levels': [-2, 0, 2]}),
+])
+def test_plot_energy_levels(args):
+    H0 = qutip.tensor(qutip.sigmaz(), qutip.identity(2)) + \
+        qutip.tensor(qutip.identity(2), qutip.sigmaz())
+    Hint = 0.1 * qutip.tensor(qutip.sigmax(), qutip.sigmax())
+
+    fig, ax = qutip.plot_energy_levels([H0, Hint], **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_plot_energy_levels_ValueError():
+    with pytest.raises(ValueError) as exc_info:
+        fig, ax = qutip.plot_energy_levels(1)
+    assert str(exc_info.value) == "H_list must be a list of Qobj instances"
+
+
+@pytest.mark.parametrize('rho_type, args', [
+    ('oper', {}),
+    ('ket', {}),
+    ('oper', {'fock_numbers': [0, 1, 2, 3]}),
+    ('oper', {'unit_y_range': False}),
+])
+def test_plot_fock_distribution(rho_type, args):
+    if rho_type == 'oper':
+        rho = qutip.rand_dm(4)
+    else:
+        rho = qutip.basis(2, 0)
+
+    fig, ax = qutip.plot_fock_distribution(rho, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('rho_type, args', [
+    ('oper', {}),
+    ('ket', {}),
+    ('oper', {'xvec': np.linspace(-1, 1, 100)}),
+    ('oper', {'yvec': np.linspace(-1, 1, 100)}),
+    ('oper', {'method': 'fft'}),
+    ('oper', {'projection': '3d'}),
+    ('oper', {'colorbar': True})
+])
+def test_plot_wigner(rho_type, args):
+    if rho_type == 'oper':
+        rho = qutip.rand_dm(4)
+    else:
+        rho = qutip.basis(2, 0)
+
+    fig, ax = qutip.plot_wigner(rho, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_plot_wigner_ValueError():
+    with pytest.raises(ValueError) as exc_info:
+        rho = qutip.rand_dm(4)
+
+        fig, ax = qutip.plot_wigner(rho, projection=1)
+        plt.close()
+    text = "Unexpected value of projection keyword argument"
+    assert str(exc_info.value) == text
+
+
+@pytest.mark.parametrize('n_of_results, n_of_e_ops, one_axes, args', [
+    (1, 3, False, {}),
+    (1, 3, False, {'ylabels': [1, 2, 3]}),
+    (1, 1, True, {}),
+    (2, 3, False, {}),
+])
+def test_plot_expectation_values(n_of_results, n_of_e_ops, one_axes, args):
+    H = qutip.sigmaz() + 0.3 * qutip.sigmay()
+    e_ops = [qutip.sigmax(), qutip.sigmay(), qutip.sigmaz()]
+    times = np.linspace(0, 10, 100)
+    psi0 = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
+    result = qutip.mesolve(H, psi0, times, [], e_ops[:n_of_e_ops])
+
+    if n_of_results == 1:
+        results = result
+    else:
+        results = [result, result]
+
+    if one_axes:
+        fig = plt.figure()
+        axes = fig.add_subplot(111)
+    else:
+        fig = None
+        axes = None
+
+    fig, axes = qutip.plot_expectation_values(results, **args,
+                                              fig=fig, axes=axes)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(axes, np.ndarray)

From 8a5c8ea9703d75270cddc4bb83b652d97a025c93 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Thu, 13 Jul 2023 20:38:23 +0900
Subject: [PATCH 497/602] add pytests

---
 qutip/tests/test_visualization.py | 106 +++++++++++++++++++++++++++++-
 1 file changed, 105 insertions(+), 1 deletion(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 42be54b7f4..3e53deef4a 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -139,12 +139,12 @@ def test_plot_wigner(rho_type, args):
 
 
 def test_plot_wigner_ValueError():
+    text = "Unexpected value of projection keyword argument"
     with pytest.raises(ValueError) as exc_info:
         rho = qutip.rand_dm(4)
 
         fig, ax = qutip.plot_wigner(rho, projection=1)
         plt.close()
-    text = "Unexpected value of projection keyword argument"
     assert str(exc_info.value) == text
 
 
@@ -179,3 +179,107 @@ def test_plot_expectation_values(n_of_results, n_of_e_ops, one_axes, args):
 
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(axes, np.ndarray)
+
+
+@pytest.mark.parametrize('color, args', [
+    ('sequential', {}),
+    ('diverging', {}),
+    ('sequential', {'projection': '3d'}),
+    ('sequential', {'colorbar': True})
+])
+def test_plot_spin_distribution(color, args):
+    j = 5
+    psi = qutip.spin_state(j, -j)
+    psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
+                              np.random.rand() * 2 * np.pi)
+    rho = qutip.ket2dm(psi)
+    theta = np.linspace(0, np.pi, 50)
+    phi = np.linspace(0, 2 * np.pi, 50)
+    Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
+    if color == 'diverging':
+        Q *= -1e12
+        Q[0, 0] = -1e13
+
+    fig, ax = qutip.plot_spin_distribution(Q, THETA, PHI, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_plot_spin_distribution_ValueError():
+    text = "Unexpected value of projection keyword argument"
+    j = 5
+    psi = qutip.spin_state(j, -j)
+    psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
+                              np.random.rand() * 2 * np.pi)
+    rho = qutip.ket2dm(psi)
+    theta = np.linspace(0, np.pi, 50)
+    phi = np.linspace(0, 2 * np.pi, 50)
+    Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
+    with pytest.raises(ValueError) as exc_info:
+        fig, ax = qutip.plot_spin_distribution(Q, THETA, PHI, projection=1)
+    assert str(exc_info.value) == text
+
+
+@pytest.mark.parametrize('dims, args', [
+    (2, {}),
+    (3, {}),
+    (2, {'how': 'pairs'}),
+    (2, {'how': 'pairs_skewed'}),
+    (2, {'how': 'before_after'}),
+    (2, {'legend_iteration': 'all'}),
+    (2, {'legend_iteration': 'grid_iteration'}),
+    (2, {'legend_iteration': 1, 'how': 'before_after'}),
+    (2, {'legend_iteration': 1, 'how': 'pairs'}),
+])
+def test_plot_qubism(dims, args):
+    if dims == 2:
+        state = qutip.ket("01")
+    else:
+        state = qutip.ket("010")
+
+    fig, ax = qutip.plot_qubism(state, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('ket, args, expected', [
+    (False, {}, "Qubism works only for pure states, i.e. kets."),
+    (True, {'how': 'error'}, "No such 'how'."),
+    (True, {'legend_iteration': 'error'}, "No such option for " +
+     "legend_iteration keyword argument. " +
+     "Use 'all', 'grid_iteration' or an integer."),
+])
+def test_plot_qubism_Error(ket, args, expected):
+    if ket:
+        state = qutip.ket("01")
+    else:
+        state = qutip.bra("01")
+    with pytest.raises(Exception) as exc_info:
+        fig, ax = qutip.plot_qubism(state, **args)
+    assert str(exc_info.value) == expected
+
+
+@pytest.mark.parametrize('args', [
+    ({'splitting': None}),
+    ({'labels_iteration': 1}),
+])
+def test_plot_schmidt(args):
+    state = qutip.ket("01")
+
+    fig, ax = qutip.plot_schmidt(state, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_plot_schmidt_Error():
+    state = qutip.bra("01")
+    text = "Schmidt plot works only for pure states, i.e. kets."
+    with pytest.raises(Exception) as exc_info:
+        fig, ax = qutip.plot_schmidt(state)
+    assert str(exc_info.value) == text

From cc953e6f5eca3531ebe692c06108a36ae0ed86a3 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Thu, 13 Jul 2023 20:58:41 +0900
Subject: [PATCH 498/602] delete matrix_histogram_complex from text

---
 doc/apidoc/functions.rst          | 2 +-
 doc/guide/guide-visualization.rst | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 0fa0b54b66..4ec12d8bb0 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -235,7 +235,7 @@ Graphs and Visualization
 ------------------------
 
 .. automodule:: qutip.visualization
-    :members: hinton, matrix_histogram, matrix_histogram_complex, plot_energy_levels, plot_fock_distribution, plot_wigner, sphereplot, plot_schmidt, plot_qubism, plot_expectation_values, plot_wigner_sphere, plot_spin_distribution
+    :members: hinton, matrix_histogram, plot_energy_levels, plot_fock_distribution, plot_wigner, sphereplot, plot_schmidt, plot_qubism, plot_expectation_values, plot_wigner_sphere, plot_spin_distribution
     :undoc-members:
 
 .. automodule:: qutip.orbital
diff --git a/doc/guide/guide-visualization.rst b/doc/guide/guide-visualization.rst
index 6bfab3f4b8..2b91b30ebb 100644
--- a/doc/guide/guide-visualization.rst
+++ b/doc/guide/guide-visualization.rst
@@ -281,10 +281,9 @@ structure and relative importance of various elements.
 
 QuTiP offers a few functions for quickly visualizing matrix data in the
 form of histograms, :func:`qutip.visualization.matrix_histogram` and
-:func:`qutip.visualization.matrix_histogram_complex`, and as Hinton diagram of weighted
-squares, :func:`qutip.visualization.hinton`. These functions takes a
-:class:`qutip.Qobj` as first argument, and optional arguments to, for
-example, set the axis labels and figure title (see the function's documentation
+as Hinton diagram of weighted squares, :func:`qutip.visualization.hinton`.
+These functions takes a :class:`qutip.Qobj` as first argument, and optional arguments to,
+for example, set the axis labels and figure title (see the function's documentation
 for details).
 
 For example, to illustrate the use of :func:`qutip.visualization.matrix_histogram`,

From 5991da7aa0afcae9afceb87f6f7ef799591fb992 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Thu, 13 Jul 2023 21:03:20 +0900
Subject: [PATCH 499/602] pep8

---
 qutip/tomography.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tomography.py b/qutip/tomography.py
index a876f353bb..ebff6a0c68 100644
--- a/qutip/tomography.py
+++ b/qutip/tomography.py
@@ -135,7 +135,7 @@ def qpt_plot_combined(chi, lbls_list, title=None,
 
     matrix_histogram(chi, xlabels, xlabels, bar_style='abs',
                      color_style='phase',
-                     options={'threshold':threshold}, ax=ax)
+                     options={'threshold': threshold}, ax=ax)
     ax.set_title(title)
 
     return fig, ax

From e9e776ceeffd68f87a631c07c5a340b8968be265 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Thu, 13 Jul 2023 22:00:47 +0900
Subject: [PATCH 500/602] docstring warning

---
 qutip/visualization.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 403e439cb2..7edf5000fe 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -257,9 +257,9 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
     rho : qobj
         Input density matrix or superoperator.
 
-    .. note::
+        .. note::
 
-        Hinton plots of superoperators are currently only supported for qubits.
+            Hinton plots of superoperators are currently only supported for qubits.
 
     x_basis : list of strings, optional
         list of x ticklabels to represent x basis of the input.
@@ -268,6 +268,7 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
         list of y ticklabels to represent y basis of the input.
 
     color_style : string, default="scaled"
+
         Determines how colors are assigned to each square:
 
         -  If set to ``"scaled"`` (default), each color is chosen by

From 528b4f6ee6e4a7dcbbe4175e1463b5b90d458769 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 13 Jul 2023 14:16:03 -0400
Subject: [PATCH 501/602] Remove solve folder

---
 doc/apidoc/classes.rst                        |   8 +-
 doc/apidoc/functions.rst                      |   2 +-
 qutip/__init__.py                             |   2 +-
 qutip/{solve => piqs}/__init__.py             |   0
 qutip/{solve => piqs}/_piqs.pyx               |   0
 qutip/{solve => piqs}/piqs.py                 |  20 +-
 qutip/solve/optionsclass.py                   | 263 -----
 qutip/solve/solver.py                         | 922 ------------------
 qutip/tests/{solve => piqs}/__init__.py       |   0
 qutip/tests/{solve => piqs}/test_piqs.py      |   6 +-
 .../{solve => solver}/test_qubit_evolution.py |   0
 11 files changed, 18 insertions(+), 1205 deletions(-)
 rename qutip/{solve => piqs}/__init__.py (100%)
 rename qutip/{solve => piqs}/_piqs.pyx (100%)
 rename qutip/{solve => piqs}/piqs.py (99%)
 delete mode 100644 qutip/solve/optionsclass.py
 delete mode 100644 qutip/solve/solver.py
 rename qutip/tests/{solve => piqs}/__init__.py (100%)
 rename qutip/tests/{solve => piqs}/test_piqs.py (99%)
 rename qutip/tests/{solve => solver}/test_qubit_evolution.py (100%)

diff --git a/doc/apidoc/classes.rst b/doc/apidoc/classes.rst
index afffcc779f..270e6c4acc 100644
--- a/doc/apidoc/classes.rst
+++ b/doc/apidoc/classes.rst
@@ -48,12 +48,12 @@ Solvers
     :members:
     :inherited-members:
     :show-inheritance:
-    
+
 .. autoclass:: qutip.solver.mesolve.MESolver
     :members:
     :inherited-members:
     :show-inheritance:
-      
+
 .. autoclass:: qutip.solver.brmesolve.BRSolver
     :members:
     :inherited-members:
@@ -212,10 +212,10 @@ Solver Options and Results
 Permutational Invariance
 ------------------------
 
-.. autoclass:: qutip.solve.piqs.Dicke
+.. autoclass:: qutip.piqs.piqs.Dicke
     :members:
 
-.. autoclass:: qutip.solve.piqs.Pim
+.. autoclass:: qutip.piqs.piqs.Pim
     :members:
 
 .. _classes-distributions:
diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 0fa0b54b66..e5cb1edad8 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -217,7 +217,7 @@ Scattering in Quantum Optical Systems
 Permutational Invariance
 ------------------------
 
-.. automodule:: qutip.solve.piqs
+.. automodule:: qutip.piqs.piqs
     :members: num_dicke_states, num_dicke_ladders, num_tls, isdiagonal, dicke_blocks, dicke_blocks_full, dicke_function_trace, purity_dicke, entropy_vn_dicke, state_degeneracy, m_degeneracy, energy_degeneracy, ap, am, spin_algebra, jspin, collapse_uncoupled, dicke_basis, dicke, excited, superradiant, css, ghz, ground, identity_uncoupled, block_matrix, tau_column,
 
 
diff --git a/qutip/__init__.py b/qutip/__init__.py
index e9083f4ba9..ccd47ddc1b 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -33,7 +33,7 @@
 from .core import *
 from .solver import *
 from .solver import nonmarkov
-import qutip.solve.piqs as piqs
+import qutip.piqs.piqs as piqs
 
 # graphics
 from .bloch import *
diff --git a/qutip/solve/__init__.py b/qutip/piqs/__init__.py
similarity index 100%
rename from qutip/solve/__init__.py
rename to qutip/piqs/__init__.py
diff --git a/qutip/solve/_piqs.pyx b/qutip/piqs/_piqs.pyx
similarity index 100%
rename from qutip/solve/_piqs.pyx
rename to qutip/piqs/_piqs.pyx
diff --git a/qutip/solve/piqs.py b/qutip/piqs/piqs.py
similarity index 99%
rename from qutip/solve/piqs.py
rename to qutip/piqs/piqs.py
index 2784e986cb..a8f14e7668 100644
--- a/qutip/solve/piqs.py
+++ b/qutip/piqs/piqs.py
@@ -22,7 +22,6 @@
     sigmap, sigmam,
 )
 from ..entropy import entropy_vn
-from .solver import SolverOptions, Result
 from ._piqs import Dicke as _Dicke
 from ._piqs import (
     jmm1_dictionary,
@@ -314,12 +313,16 @@ def purity_dicke(rho):
     return dicke_function_trace(f, rho)
 
 
+class Result:
+    pass
+
+
 class Dicke(object):
     """The Dicke class which builds the Lindbladian and Liouvillian matrix.
 
     Examples
     --------
-    >>> from piqs import Dicke, jspin
+    >>> from qutip.piqs import Dicke, jspin
     >>> N = 2
     >>> jx, jy, jz = jspin(N)
     >>> jp = jspin(N, "+")
@@ -499,7 +502,7 @@ def liouvillian(self):
             liouv = lindblad + hamiltonian_superoperator
         return liouv
 
-    def pisolve(self, initial_state, tlist, options=None):
+    def pisolve(self, initial_state, tlist):
         """
         Solve for diagonal Hamiltonians and initial states faster.
 
@@ -512,13 +515,10 @@ def pisolve(self, initial_state, tlist, options=None):
         tlist: ndarray
             A 1D numpy array of list of timesteps to integrate
 
-        options : :class:`qutip.solver.SolverOptions`
-            The options for the solver.
-
         Returns
         =======
         result: list
-            A dictionary of the type `qutip.solver.Result` which holds the
+            A dictionary of the type `qutip.piqs.Result` which holds the
             results of the evolution.
         """
         if isdiagonal(initial_state) == False:
@@ -546,7 +546,7 @@ def pisolve(self, initial_state, tlist, options=None):
             self.collective_pumping,
             self.collective_dephasing,
         )
-        result = pim.solve(initial_state, tlist, options=None)
+        result = pim.solve(initial_state, tlist)
         return result
 
     def c_ops(self):
@@ -1789,12 +1789,10 @@ def coefficient_matrix(self):
                     sparse_M[k, int(current_col)] = taus[tau]
         return sparse_M.tocsr()
 
-    def solve(self, rho0, tlist, options=None):
+    def solve(self, rho0, tlist):
         """
         Solve the ODE for the evolution of diagonal states and Hamiltonians.
         """
-        if options is None:
-            options = SolverOptions()
         output = Result()
         output.solver = "pisolve"
         output.times = tlist
diff --git a/qutip/solve/optionsclass.py b/qutip/solve/optionsclass.py
deleted file mode 100644
index b82de81217..0000000000
--- a/qutip/solve/optionsclass.py
+++ /dev/null
@@ -1,263 +0,0 @@
-
-
-class AllOptions:
-    """
-    Class that serve as the parent of all other options class.
-    """
-    # Temporary patch to make changes in solver's options minimal.
-    # TODO: Follow up PR based on #1812 should replace this.
-    def __init__(self):
-        self._isDefault = True
-        self._children = []
-        self._fullname = "qutip.settings"
-        self._defaultInstance = self
-
-    def _all_children(self):
-        optcls = []
-        for child in self._children:
-            optcls += child._all_children()
-        return optcls
-
-
-alloptions = AllOptions()
-
-
-def optionsclass(name, parent=alloptions):
-    """
-    Use as a decorator to register the options class to `qutip.settings`.
-    The default will be in added to qutip.setting.[parent].name.
-
-    The options class should contain an `options` dictionary containing the
-    option and their default value. Readonly settings can be defined in
-    `read_only_options` dict.
-
-    ```
-    >>> import qutip
-    >>> @qutip.optionsclass("myopt", parent=qutip.settings.solver)
-    >>> class MyOpt():
-    >>>     options = {"opt1": True}
-    >>>     read_only_options = {"hidden": 1}
-
-    >>> qutip.settings.solver.myopt['opt1'] = False
-    >>> qutip.settings.solver.myopt['hidden']
-    1
-
-    >>> qutip.settings.solver.myopt['hidden'] = 2
-    KeyError: "'hidden': Read-only value"
-
-    >>> print(qutip.settings.solver.myopt)
-    qutip.settings.solver.myopt:
-    opt1   : False
-    hidden : 1
-
-    print(MyOpt(opt1=2))
-    qutip.settings.solver.myopt:
-    opt1   : 2
-    hidden : 1
-    ```
-
-    It add the methods:
-        __init__(file=None, *, option=None... )
-            Allow to create from data in files or from defaults with attributes
-            overwritten by keywords.
-        __repr__():
-            Make a clean print for all 'options' and 'read_only_options'.
-        __getitem__(), __setitem__():
-            Pass through to 'self.options' and 'self.read_only_options'.
-            Option in 'self.read_only_options' can not be set.
-        save(file='qutiprc'):
-            Save the object in a file. 'qutiprc' file is loaded as default when
-            loading qutip.
-        load(file):
-            Overwrite with options previously saved.
-            Loaded options will have the same type as the default from one of:
-                (bool, int, float, complex, str, object)
-        reset():
-            If used on an instance, reset to the default in qutip.settings.
-            If used from qutip.settings..., go back to qutip's defaults.
-
-    """
-    # The real work is in _QtOptionsMaker
-    if isinstance(name, str):
-        # Called as
-        # @QtOptionsClass(name)
-        # class Options:
-        return _QtOptionsMaker(name, parent)
-    else:
-        # Called as
-        # @QtOptionsClass
-        # class Options:
-        return _QtOptionsMaker(name.__name__, parent)(name)
-
-
-class _QtOptionsMaker:
-    """
-    Apply the `optionsclass` decorator.
-    """
-    def __init__(self, name, parent):
-        self.name = name
-        self.parent = parent
-
-    def __call__(self, cls):
-        if hasattr(cls, "_isDefault"):
-            # Already a QtOptionsClass
-            return
-
-        if not hasattr(cls, "read_only_options"):
-            cls.read_only_options = {}
-        # type to used when loading from file.
-        cls._types = {key: type(val) for key, val in cls.options.items()}
-        # Name in settings and in files
-        cls._name = self.name
-        # Name when printing
-        cls._fullname = ".".join([self.parent._fullname, self.name])
-        # Is this instance the default for the other.
-        cls._isDefault = False
-        # Children in the settings tree
-        cls._children = []
-        # Build the default instance
-        # Do it before setting __init__ since it use this default
-        self._make_default(cls)
-
-        cls.__init__ = _make_init(cls.options)
-        cls.__repr__ = _repr
-        cls.__getitem__ = _getitem
-        cls.__setitem__ = _setitem
-        cls.__contains__ = _contains
-        cls.reset = _reset
-        cls.save = _save
-        cls.load = _load
-        cls._all_children = _all_children
-
-        return cls
-
-    def _make_default(self, cls):
-        """ Create the default and add it to the parent.
-        """
-        default = cls()
-        default.options = cls.options.copy()
-        default._isDefault = True
-        default._children = []
-        # The parent has the child twice: attribute and in a list.
-        self.parent._defaultInstance._children.append(default)
-        setattr(self.parent._defaultInstance, self.name, default)
-        cls._defaultInstance = default
-
-
-def _make_init(all_set):
-    attributes_kw = ",\n             ".join(["{}=None".format(key)
-                    for key in all_set])
-    attributes_set = "".join(["    if {0} is not None:\n"
-                              "        self.options['{0}'] = {0}\n".format(key)
-                     for key in all_set])
-    code = f"""
-def __init__(self, file='', *,
-             {attributes_kw},
-             _child_instance=False,
-             **kwargs):
-    self.options = self._defaultInstance.options.copy()
-{attributes_set}
-    if file:
-        self.load(file)
-    if hasattr(self, "extra_options"):
-        other_kw = dict()
-        for kw in kwargs:
-            if kw in self.extra_options:
-                self.options[kw] = kwargs[kw]
-            else:
-                other_kw[kw] = kwargs[kw]
-        kwargs = other_kw
-    self._children = []
-    for child in self._defaultInstance._children:
-        self._children.append(child.__class__(file, _child_instance=True,
-                                              **kwargs))
-        setattr(self, child._name, self._children[-1])
-        kwargs = self._children[-1].left_over_kwargs
-    if _child_instance:
-        self.left_over_kwargs = kwargs
-    elif kwargs:
-        raise KeyError("Unknown options: " +
-                       " ,".join(str(key) for key in kwargs))
-"""
-    ns = {}
-    exec(code, globals(), ns)
-    return ns["__init__"]
-
-
-def _repr(self, _recursive=True):
-    out = self._fullname + ":\n"
-    longest = max(len(key) for key in self.options)
-    if self.read_only_options:
-        longest_readonly = max(len(key) for key in self.read_only_options)
-        longest = max((longest, longest_readonly))
-    for key, val in self.options.items():
-        if isinstance(val, str):
-            out += "{:{width}} : '{}'\n".format(key, val,
-                                                width=longest)
-        else:
-            out += "{:{width}} : {}\n".format(key, val,
-                                              width=longest)
-    for key, val in self.read_only_options.items():
-        out += "{:{width}} : {}\n".format(key, val,
-                                          width=longest)
-    out += "\n"
-    if _recursive:
-         out += "".join([child.__repr__(_recursive)
-                         for child in self._children])
-    return out
-
-
-def _reset(self, _recursive=False):
-    """Reset instance to the default value or the default to Qutip's default"""
-    if self._isDefault:
-        self.options = self.__class__.options.copy()
-        if _recursive:
-            for child in self._children:
-                child.reset()
-    else:
-        self.options = self._defaultInstance.options.copy()
-
-
-def _all_children(self):
-    optcls = [self]
-    for child in self._children:
-         optcls += child._all_children()
-    return optcls
-
-
-def _save(self, file="qutiprc", _recursive=False):
-    """Save to desired file. 'qutiprc' if not specified"""
-    import qutip.configrc as qrc
-    if _recursive:
-        optcls = self._all_children()
-    else:
-        optcls = [self]
-    qrc.write_rc_object(file, optcls)
-
-
-def _load(self, file="qutiprc", _recursive=False):
-    """Load from desired file. 'qutiprc' if not specified"""
-    import qutip.configrc as qrc
-    if _recursive:
-        optcls = self._all_children()
-    else:
-        optcls = [self]
-    qrc.load_rc_object(file, optcls)
-
-
-def _contains(self, key):
-    return key in self.read_only_options or key in self.options
-
-
-def _getitem(self, key):
-    # Let the dict catch the KeyError
-    if key in self.read_only_options:
-        return self.read_only_options[key]
-    return self.options[key]
-
-
-def _setitem(self, key, value):
-    # Let the dict catch the KeyError
-    if key in self.read_only_options:
-        raise KeyError(f"'{key}': Read-only value")
-    self.options[key] = value
diff --git a/qutip/solve/solver.py b/qutip/solve/solver.py
deleted file mode 100644
index 08a53fb64e..0000000000
--- a/qutip/solve/solver.py
+++ /dev/null
@@ -1,922 +0,0 @@
-from __future__ import print_function
-
-__all__ = ['SolverOptions', 'ExpectOps']
-
-import os
-import sys
-import warnings
-import datetime
-import numpy as np
-from collections import OrderedDict
-from types import FunctionType, BuiltinFunctionType
-
-from .. import __version__, Qobj, QobjEvo
-from .optionsclass import optionsclass
-from ..core import data as _data
-
-solver_safe = {}
-
-
-class SolverSystem():
-    pass
-
-
-class ExpectOps:
-    """
-        Contain and compute expectation values
-    """
-    def __init__(self, e_ops=[], super_=False):
-        # take care of expectation values, if any
-        self.isfunc = False
-        self.e_ops_dict = False
-        self.raw_e_ops = e_ops
-        self.e_ops_qoevo = []
-        self.e_num = 0
-        self.e_ops_isherm = []
-
-        if isinstance(e_ops, (Qobj, QobjEvo)):
-            e_ops = [e_ops]
-        elif isinstance(e_ops, dict):
-            self.e_ops_dict = e_ops
-            e_ops = [e for e in e_ops.values()]
-
-        self.e_ops = e_ops
-        if isinstance(e_ops, list):
-            self.e_num = len(e_ops)
-            self.e_ops_isherm = [e.isherm for e in e_ops]
-            if not super_:
-                self.e_ops_qoevo = np.array([QobjEvo(e) for e in e_ops],
-                                            dtype=object)
-            else:
-                self.e_ops_qoevo = np.array([QobjEvo(spre(e)) for e in e_ops],
-                                            dtype=object)
-        elif callable(e_ops):
-            self.isfunc = True
-            self.e_num = 1
-
-    def init(self, tlist):
-        self.tlist = tlist
-        if self.isfunc:
-            self.raw_out = []
-        else:
-            self.raw_out = np.zeros((self.e_num, len(tlist)), dtype=complex)
-
-    def check_dims(self, dims):
-        if not self.isfunc:
-            for op in self.e_ops_qoevo:
-                if isinstance(op, QobjEvo) and op.dims[1] != dims[0]:
-                    raise TypeError(f"e_ops dims ({op.dims}) are not "
-                                    f"compatible with the system's ({dims})")
-
-    def copy(self):
-        out = ExpectOps.__new__(ExpectOps)
-        out.isfunc = self.isfunc
-        out.e_ops_dict = self.e_ops_dict
-        out.raw_e_ops = self.raw_e_ops
-        out.e_ops = self.e_ops
-        out.e_num = self.e_num
-        out.e_ops_isherm = self.e_ops_isherm
-        out.e_ops_qoevo = self.e_ops_qoevo
-        return out
-
-    def step(self, iter_, state):
-        if self.isfunc:
-            self.raw_out.append(self.e_ops(t, state))
-        else:
-            state = _data.dense.fast_from_numpy(state)
-            t = self.tlist[iter_]
-            for ii in range(self.e_num):
-                if isinstance(self.e_ops_qoevo[ii], QobjEvo):
-                    self.raw_out[ii, iter_] = \
-                        self.e_ops_qoevo[ii].expect_data(t, state)
-                elif callable(self.e_ops_qoevo[ii]):
-                    self.raw_out[ii, iter_] = \
-                        self.e_ops_qoevo[ii](t, state)
-
-    def finish(self):
-        if self.isfunc:
-            result = self.raw_out
-        else:
-            result = []
-            for ii in range(self.e_num):
-                if self.e_ops_isherm[ii]:
-                    result.append(np.real(self.raw_out[ii, :]))
-                else:
-                    result.append(self.raw_out[ii, :])
-            if self.e_ops_dict:
-                result = {e: result[n]
-                          for n, e in enumerate(self.e_ops_dict.keys())}
-        return result
-
-    def __eq__(self, other):
-        if isinstance(other, ExpectOps):
-            other = other.raw_e_ops
-        return self.raw_e_ops == other
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __bool__(self):
-        return bool(self.e_num)
-
-
-@optionsclass("solver")
-class SolverOptions:
-    """
-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-    constructor::
-
-        opts = SolverOptions(order=10, ...)
-
-    or by changing the class attributes after creation::
-
-        opts = SolverOptions()
-        opts.order = 10
-
-    Returns options class to be used as options in evolution solvers.
-
-    The default can be changed by::
-
-        qutip.settings.solver['order'] = 10
-
-    Supported options:
-
-        atol : float {1e-8}
-            Absolute tolerance.
-        rtol : float {1e-6}
-            Relative tolerance.
-        method : str {'adams','bdf'}
-            Integration method.
-        order : int {12}
-            Order of integrator (<=12 'adams', <=5 'bdf')
-        nsteps : int {2500}
-            Max. number of internal steps/call.
-        first_step : float {0}
-            Size of initial step (0 = automatic).
-        min_step : float {0}
-            Minimum step size (0 = automatic).
-        max_step : float {0}
-            Maximum step size (0 = automatic)
-        tidy : bool {True,False}
-            Tidyup Hamiltonian and initial state by removing small terms.
-        average_states : bool {False}
-            Average states values over trajectories in stochastic solvers.
-        average_expect : bool {True}
-            Average expectation values over trajectories for stochastic solvers.
-        ntraj : int {500}
-            Number of trajectories in stochastic solvers.
-        store_final_state : bool {False, True}
-            Whether or not to store the final state of the evolution in the
-            result class.
-        store_states : bool {False, True}
-            Whether or not to store the state vectors or density matrices in the
-            result class, even if expectation values operators are given. If no
-            expectation are provided, then states are stored by default and this
-            option has no effect.
-    """
-    options = {
-        # Absolute tolerance (default = 1e-8)
-        "atol": 1e-8,
-        # Relative tolerance (default = 1e-6)
-        "rtol": 1e-6,
-        # Integration method (default = 'adams', for stiff 'bdf')
-        "method": 'adams',
-        # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf')
-        "order": 12,
-        # Max. number of internal steps/call
-        "nsteps": 1000,
-        # Size of initial step (0 = determined by solver)
-        "first_step": 0,
-        # Max step size (0 = determined by solver)
-        "max_step": 0,
-        # Minimal step size (0 = determined by solver)
-        "min_step": 0,
-        # Average expectation values over trajectories (default = True)
-        "average_expect": True,
-        # average expectation values
-        "average_states": False,
-        # tidyup Hamiltonian before calculation (default = True)
-        "tidy": True,
-        # Number of trajectories (default = 500)
-        "ntraj": 500,
-        "gui": False,
-        # store final state?
-        "store_final_state": False,
-        # store states even if expectation operators are given?
-        "store_states": False,
-        # average mcsolver density matricies assuming steady state evolution
-        "steady_state_average": False,
-        # Normalize output of solvers
-        # (turned off for batch unitary propagator mode)
-        "normalize_output": True
-    }
-
-
-@optionsclass("mcsolve", SolverOptions)
-class McOptions:
-    """
-    Class of options for evolution solvers such as :func:`qutip.mesolve` and
-    :func:`qutip.mcsolve`. Options can be specified either as arguments to the
-    constructor::
-
-        opts = SolverOptions(norm_tol=1e-3, ...)
-
-    or by changing the class attributes after creation::
-
-        opts = SolverOptions()
-        opts.['norm_tol'] = 1e-3
-
-    Returns options class to be used as options in evolution solvers.
-
-    The default can be changed by::
-
-        qutip.settings.options.montecarlo['norm_tol'] = 1e-3
-
-    Options
-    -------
-
-    norm_tol : float {1e-4}
-        Tolerance used when finding wavefunction norm in mcsolve.
-    norm_t_tol : float {1e-6}
-        Tolerance used when finding wavefunction time in mcsolve.
-    norm_steps : int {5}
-        Max. number of steps used to find wavefunction norm to within norm_tol
-        in mcsolve.
-    mc_corr_eps : float {1e-10}
-        Arbitrarily small value for eliminating any divide-by-zero errors in
-        correlation calculations when using mcsolve.
-    """
-    options = {
-        # Tolerance for wavefunction norm (mcsolve only)
-        "norm_tol": 1e-4,
-        # Tolerance for collapse time precision (mcsolve only)
-        "norm_t_tol": 1e-6,
-        # Max. number of steps taken to find wavefunction norm to within
-        # norm_tol (mcsolve only)
-        "norm_steps": 5,
-        # small value in mc solver for computing correlations
-        "mc_corr_eps": 1e-10,
-    }
-
-
-class Result():
-    """Class for storing simulation results from any of the dynamics solvers.
-
-    Attributes
-    ----------
-
-    solver : str
-        Which solver was used [e.g., 'mesolve', 'mcsolve', 'brmesolve', ...]
-    times : list/array
-        Times at which simulation data was collected.
-    expect : list/array
-        Expectation values (if requested) for simulation.
-    states : array
-        State of the simulation (density matrix or ket) evaluated at ``times``.
-    num_expect : int
-        Number of expectation value operators in simulation.
-    num_collapse : int
-        Number of collapse operators in simualation.
-    ntraj : int/list
-        Number of trajectories (for stochastic solvers). A list indicates
-        that averaging of expectation values was done over a subset of total
-        number of trajectories.
-    col_times : list
-        Times at which state collpase occurred. Only for Monte Carlo solver.
-    col_which : list
-        Which collapse operator was responsible for each collapse in
-        ``col_times``. Only for Monte Carlo solver.
-
-    """
-    def __init__(self):
-        self.solver = None
-        self.times = None
-        self.states = []
-        self.expect = []
-        self.num_expect = 0
-        self.num_collapse = 0
-        self.ntraj = None
-        self.seeds = None
-        self.col_times = None
-        self.col_which = None
-
-    def __str__(self):
-        s = "Result object "
-        if self.solver:
-            s += "with " + self.solver + " data.\n"
-        else:
-            s += "missing solver information.\n"
-        s += "-" * (len(s) - 1) + "\n"
-        if self.states is not None and len(self.states) > 0:
-            s += "states = True\n"
-        elif self.expect is not None and len(self.expect) > 0:
-            s += "expect = True\nnum_expect = " + str(self.num_expect) + ", "
-        else:
-            s += "states = True, expect = True\n" + \
-                "num_expect = " + str(self.num_expect) + ", "
-        s += "num_collapse = " + str(self.num_collapse)
-        if self.solver == 'mcsolve':
-            s += ", ntraj = " + str(self.ntraj)
-        return s
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __getstate__(self):
-        # defines what happens when Qobj object gets pickled
-        self.__dict__.update({'qutip_version': __version__[:5]})
-        return self.__dict__
-
-    def __setstate__(self, state):
-        # defines what happens when loading a pickled Qobj
-        if 'qutip_version' in state.keys():
-            del state['qutip_version']
-        (self.__dict__).update(state)
-
-
-# %%%%%%%%%%% remove ?
-class SolverConfiguration():
-    def __init__(self):
-
-        self.cgen_num = 0
-
-        self.reset()
-
-    def reset(self):
-        # General stuff
-        self.tlist = None       # evaluations times
-        self.ntraj = None       # number / list of trajectories
-        self.options = None     # options for solvers
-        self.norm_tol = None    # tolerance for wavefunction norm
-        self.norm_steps = None  # max. number of steps to take in finding
-        # Initial state stuff
-        self.psi0 = None        # initial state
-        self.psi0_dims = None   # initial state dims
-        self.psi0_shape = None  # initial state shape
-
-        # flags for setting time-dependence, collapse ops, and number of times
-        # codegen has been run
-        self.cflag = 0     # Flag signaling collapse operators
-        self.tflag = 0     # Flag signaling time-dependent problem
-
-        self.soft_reset()
-
-    def soft_reset(self):
-        # Hamiltonian stuff
-        self.h_td_inds = []  # indicies of time-dependent Hamiltonian operators
-        self.h_tdterms = []  # List of td strs and funcs
-        self.h_data = None   # List of sparse matrix data
-        self.h_ind = None    # List of sparse matrix indices
-        self.h_ptr = None    # List of sparse matrix ptrs
-
-        # Expectation operator stuff
-        self.e_num = 0        # number of expect ops
-        self.e_ops_data = []  # expect op data
-        self.e_ops_ind = []   # expect op indices
-        self.e_ops_ptr = []   # expect op indptrs
-        self.e_ops_isherm = []  # expect op isherm
-
-        # Collapse operator stuff
-        self.c_num = 0          # number of collapse ops
-        self.c_const_inds = []  # indicies of constant collapse operators
-        self.c_td_inds = []     # indicies of time-dependent collapse operators
-        self.c_ops_data = []    # collapse op data
-        self.c_ops_ind = []     # collapse op indices
-        self.c_ops_ptr = []     # collapse op indptrs
-        self.c_args = []        # store args for time-dependent collapse func.
-
-        # Norm collapse operator stuff
-        self.n_ops_data = []  # norm collapse op data
-        self.n_ops_ind = []   # norm collapse op indices
-        self.n_ops_ptr = []   # norm collapse op indptrs
-
-        # holds executable strings for time-dependent collapse evaluation
-        self.col_expect_code = None
-        self.col_spmv_code = None
-
-        # hold stuff for function list based time dependence
-        self.h_td_inds = []
-        self.h_td_data = []
-        self.h_td_ind = []
-        self.h_td_ptr = []
-        self.h_funcs = None
-        self.h_func_args = None
-        self.c_funcs = None
-        self.c_func_args = None
-
-        # time-dependent (TD) function stuff
-        self.tdfunc = None     # Placeholder for TD RHS function.
-        self.tdname = None     # Name of td .pyx file
-        self.colspmv = None    # Placeholder for TD col-spmv function.
-        self.colexpect = None  # Placeholder for TD col_expect function.
-        self.string = None     # Holds string of variables passed to td solver
-
-
-def _format_time(t, tt=None, ttt=None):
-    time_str = str(datetime.timedelta(seconds=t))
-    if tt is not None and ttt is not None:
-        sect_percent = 100*t/tt
-        solve_percent = 100*t/ttt
-        time_str += " ({:03.2f}% section, {:03.2f}% total)".format(
-                                            sect_percent, solve_percent)
-    elif tt is not None:
-        sect_percent = 100*t/tt
-        time_str += " ({:03.2f}% section)".format(sect_percent)
-
-    elif ttt is not None:
-        solve_percent = 100*t/ttt
-        time_str += " ({:03.2f}% total)".format(solve_percent)
-
-    return time_str
-
-
-class Stats:
-    """
-    Statistical information on the solver performance
-    Statistics can be grouped into sections.
-    If no section names are given in the the contructor, then all statistics
-    will be added to one section 'main'
-
-    Parameters
-    ----------
-    section_names : list
-        list of keys that will be used as keys for the sections
-        These keys will also be used as names for the sections
-        The text in the output can be overidden by setting the header property
-        of the section
-        If no names are given then one section called 'main' is created
-
-    Attributes
-    ----------
-    sections : OrderedDict of _StatsSection
-        These are the sections that are created automatically on instantiation
-        or added using add_section
-
-    header : string
-        Some text that will be used as the heading in the report
-        By default there is None
-
-    total_time : float
-        Time in seconds for the solver to complete processing
-        Can be None, meaning that total timing percentages will be reported
-    """
-
-    def __init__(self, section_names=None):
-        self._def_section_name = 'main'
-        self.sections = OrderedDict()
-        self.total_time = None
-        self.header = None
-        if isinstance(section_names, list):
-            c = 0
-            for name in section_names:
-                self.sections[name] = _StatsSection(name, self)
-                if c == 0:
-                    self._def_section_name = name
-                c += 1
-
-        else:
-            self.sections[self._def_section_name] = \
-                        _StatsSection(self._def_section_name)
-
-    def _get_section(self, section):
-        if section is None:
-            return self.sections[self._def_section_name]
-        elif isinstance(section, _StatsSection):
-            return section
-        else:
-            sect = self.sections.get(section, None)
-            if sect is None:
-                raise ValueError("Unknown section {}".format(section))
-            else:
-                return sect
-
-    def add_section(self, name):
-        """
-        Add another section with the given name
-
-        Parameters
-        ----------
-        name : string
-            will be used as key for sections dict
-            will also be the header for the section
-
-        Returns
-        -------
-        section : :class:`_StatsSection`
-            The new section
-        """
-        sect = _StatsSection(name, self)
-        self.sections[name] = sect
-        return sect
-
-    def add_count(self, key, value, section=None):
-        """
-        Add value to count. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be an integer
-
-        Parameters
-        ----------
-        key : string
-            key for the section.counts dictionary
-            reusing a key will result in numerical addition of value
-
-        value : int
-            Initial value of the count, or added to an existing count
-
-        section : string or :class:`_StatsSection`
-            Section which to add the count to.
-            If None given, the default (first) section will be used
-        """
-
-        self._get_section(section).add_count(key, value)
-
-    def add_timing(self, key, value, section=None):
-        """
-        Add value to timing. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be a float, and given in seconds.
-
-        Parameters
-        ----------
-        key : string
-            key for the section.timings dictionary
-            reusing a key will result in numerical addition of value
-
-        value : int
-            Initial value of the timing, or added to an existing timing
-
-        section: string or `class` : _StatsSection
-            Section which to add the timing to.
-            If None given, the default (first) section will be used
-        """
-        self._get_section(section).add_timing(key, value)
-
-    def add_message(self, key, value, section=None, sep=";"):
-        """
-        Add value to message. If key does not already exist in section then
-        it is created with this value.
-        If key already exists the value is added to the message
-        The value will be converted to a string
-
-        Parameters
-        ----------
-        key : string
-            key for the section.messages dictionary
-            reusing a key will result in concatenation of value
-
-        value : int
-            Initial value of the message, or added to an existing message
-
-        sep : string
-            Message will be prefixed with this string when concatenating
-
-        section: string or `class` : _StatsSection
-            Section which to add the message to.
-            If None given, the default (first) section will be used
-        """
-        self._get_section(section).add_message(key, value, sep=sep)
-
-    def set_total_time(self, value, section=None):
-        """
-        Sets the total time for the complete solve or for a specific section
-        value is expected to be a float, and given in seconds
-
-        Parameters
-        ----------
-        value : float
-            Time in seconds to complete the solver section
-
-        section : string or `class` : _StatsSection
-            Section which to set the total_time for
-            If None given, the total_time for complete solve is set
-        """
-        if not isinstance(value, float):
-            try:
-                value = float(value)
-            except:
-                raise TypeError("value is expected to be a float")
-
-        if section is None:
-            self.total_time = value
-        else:
-            sect = self._get_section(section)
-            sect.total_time = value
-
-    def report(self, output=sys.stdout):
-        """
-        Report the counts, timings and messages from the sections.
-        Sections are reported in the order that the names were supplied
-        in the constructor.
-        The counts, timings and messages are reported in the order that they
-        are added to the sections
-        The output can be written to anything that supports a write method,
-        e.g. a file or the console (default)
-        The output is intended to in markdown format
-
-        Parameters
-        ----------
-        output : stream
-            file or console stream - anything that support write - where
-            the output will be written
-        """
-
-        if not hasattr(output, 'write'):
-            raise TypeError("output must have a write method")
-
-        if self.header:
-            output.write("{}\n{}\n".format(self.header,
-                                     ("="*len(self.header))))
-        for name, sect in self.sections.items():
-            sect.report(output)
-
-        if self.total_time is not None:
-            output.write("\nSummary\n-------\n")
-            output.write("{}\t solver total time\n".format(
-                                            _format_time(self.total_time)))
-
-    def clear(self):
-        """
-        Clear counts, timings and messages from all sections
-        """
-        for sect in self.sections.values():
-            sect.clear()
-        self.total_time = None
-
-
-class _StatsSection(object):
-    """
-    Not intended to be directly instantiated
-    This is the type for the SolverStats.sections values
-
-    The method parameter descriptions are the same as for those the parent
-    with the same method name
-
-    Parameters
-    ----------
-    name : string
-        key for the parent sections dictionary
-        will also be used as the header
-
-    parent : `class` :  SolverStats
-        The container for all the sections
-
-    Attributes
-    ----------
-    name : string
-        key for the parent sections dictionary
-        will also be used as the header
-
-    parent : `class` :  SolverStats
-        The container for all the sections
-
-    header : string
-        Used as heading for section in report
-
-    counts : OrderedDict
-        The integer type statistics for the stats section
-
-    timings : OrderedDict
-        The timing type statistics for the stats section
-        Expected to contain float values representing values in seconds
-
-    messages : OrderedDict
-        Text type output to be reported
-
-    total_time : float
-        Total time for processing in the section
-        Can be None, meaning that section timing percentages will be reported
-    """
-    def __init__(self, name, parent):
-        self.parent = parent
-        self.header = str(name)
-        self.name = name
-        self.counts = OrderedDict()
-        self.timings = OrderedDict()
-        self.messages = OrderedDict()
-        self.total_time = None
-
-    def add_count(self, key, value):
-        """
-        Add value to count. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the given value
-        value is expected to be an integer
-        """
-        if not isinstance(value, int):
-            try:
-                value = int(value)
-            except:
-                raise TypeError("value is expected to be an integer")
-
-        if key in self.counts:
-            self.counts[key] += value
-        else:
-            self.counts[key] = value
-
-    def add_timing(self, key, value):
-        """
-        Add value to timing. If key does not already exist in section then
-        it is created with this value.
-        If key already exists it is increased by the give value
-        value is expected to be a float, and given in seconds.
-        """
-        if not isinstance(value, float):
-            try:
-                value = float(value)
-            except:
-                raise TypeError("value is expected to be a float")
-
-        if key in self.timings:
-            self.timings[key] += value
-        else:
-            self.timings[key] = value
-
-    def add_message(self, key, value, sep=";"):
-        """
-        Add value to message. If key does not already exist in section then
-        it is created with this value.
-        If key already exists the value is added to the message
-        The value will be converted to a string
-        """
-        value = str(value)
-
-        if key in self.messages:
-            if sep is not None:
-                try:
-                    value = sep + value
-                except:
-                    TypeError("It is not possible to concatenate the value "
-                              "with the given seperator")
-            self.messages[key] += value
-        else:
-            self.messages[key] = value
-
-    def report(self, output=sys.stdout):
-        """
-        Report the counts, timings and messages for this section.
-        Note the percentage of the section and solver total times will be
-        given if the parent and or section total_time is set
-        """
-        if self.header:
-            output.write("\n{}\n{}\n".format(self.header,
-                                     ("-"*len(self.header))))
-
-        # TODO: Make the timings and counts ouput in a table format
-        #       Generally make more pretty
-
-        # Report timings
-        try:
-            ttt = self.parent.total_time
-        except:
-            ttt = None
-
-        tt = self.total_time
-
-        output.write("### Timings:\n")
-        for key, value in self.timings.items():
-            l = " - {}\t{}\n".format(_format_time(value, tt, ttt), key)
-            output.write(l)
-        if tt is not None:
-            output.write(" - {}\t{} total time\n".format(_format_time(tt),
-                                                     self.name))
-
-        # Report counts
-        output.write("### Counts:\n")
-        for key, value in self.counts.items():
-            l = " - {}\t{}\n".format(value, key)
-            output.write(l)
-
-        # Report messages
-        output.write("### Messages:\n")
-        for key, value in self.messages.items():
-            l = " - {}:\t{}\n".format(key, value)
-            output.write(l)
-
-
-    def clear(self):
-        """
-        Clear counts, timings and messages from this section
-        """
-        self.counts.clear()
-        self.timings.clear()
-        self.messages.clear()
-        self.total_time = None
-
-
-def _solver_safety_check(H, state=None, c_ops=[], e_ops=[], args={}):
-    # Input is std Qobj (Hamiltonian or Liouvillian)
-    if isinstance(H, Qobj):
-        Hdims = H.dims
-        Htype = H.type
-        _structure_check(Hdims, Htype, state)
-    # Input H is function
-    elif isinstance(H, (FunctionType, BuiltinFunctionType)):
-        Hdims = H(0,args).dims
-        Htype = H(0,args).type
-        _structure_check(Hdims, Htype, state)
-    # Input is td-list
-    elif isinstance(H, list):
-        if isinstance(H[0], Qobj):
-            Hdims = H[0].dims
-            Htype = H[0].type
-        elif isinstance(H[0], list):
-            Hdims = H[0][0].dims
-            Htype = H[0][0].type
-        elif isinstance(H[0], (FunctionType, BuiltinFunctionType)):
-            Hdims = H[0](0,args).dims
-            Htype = H[0](0,args).type
-        else:
-            raise Exception('Invalid td-list element.')
-        # Check all operators in list
-        for ii in range(len(H)):
-            if isinstance(H[ii], Qobj):
-                _temp_dims = H[ii].dims
-                _temp_type = H[ii].type
-            elif isinstance(H[ii], list):
-                _temp_dims = H[ii][0].dims
-                _temp_type = H[ii][0].type
-            elif isinstance(H[ii], (FunctionType, BuiltinFunctionType)):
-                _temp_dims = H[ii](0,args).dims
-                _temp_type = H[ii](0,args).type
-            else:
-                raise Exception('Invalid td-list element.')
-            _structure_check(_temp_dims,_temp_type,state)
-
-    else:
-        raise Exception('Invalid time-dependent format.')
-
-
-    for ii in range(len(c_ops)):
-        do_tests = True
-        if isinstance(c_ops[ii], Qobj):
-            _temp_state = c_ops[ii]
-        elif isinstance(c_ops[ii], list):
-            if isinstance(c_ops[ii][0], Qobj):
-                _temp_state = c_ops[ii][0]
-            elif isinstance(c_ops[ii][0], tuple):
-                do_tests = False
-                for kk in range(len(c_ops[ii][0])):
-                    _temp_state = c_ops[ii][0][kk]
-                    _structure_check(Hdims, Htype, _temp_state)
-        else:
-            raise Exception('Invalid td-list element.')
-        if do_tests:
-            _structure_check(Hdims, Htype, _temp_state)
-
-    if isinstance(e_ops, list):
-        for ii in range(len(e_ops)):
-            if isinstance(e_ops[ii], Qobj):
-                _temp_state = e_ops[ii]
-            elif isinstance(e_ops[ii], list):
-                _temp_state = e_ops[ii][0]
-            else:
-                raise Exception('Invalid td-list element.')
-            _structure_check(Hdims,Htype,_temp_state)
-    elif isinstance(e_ops, FunctionType):
-        pass
-    else:
-        raise Exception('Invalid e_ops specification.')
-
-
-def _structure_check(Hdims, Htype, state):
-    if state is not None:
-        # Input state is a ket vector
-        if state.type == 'ket':
-            # Input is Hamiltonian
-            if Htype == 'oper':
-                if Hdims[1] != state.dims[0]:
-                    raise Exception('Input operator and ket do not '
-                                    'share same structure.')
-            # Input is super and state is ket
-            elif Htype == 'super':
-                if Hdims[1][1] != state.dims[0]:
-                    raise Exception('Input operator and ket do not '
-                                    'share same structure.')
-            else:
-                raise Exception('Invalid input operator.')
-        # Input state is a density matrix
-        elif state.type == 'oper':
-            # Input is Hamiltonian and state is density matrix
-            if Htype == 'oper':
-                if Hdims[1] != state.dims[0]:
-                    raise Exception('Input operators do not '
-                                    'share same structure.')
-            # Input is super op. and state is density matrix
-            elif Htype == 'super':
-                if Hdims[1] != state.dims:
-                    raise Exception('Input operators do not '
-                                    'share same structure.')
-
-
-#
-# create a global instance of the SolverConfiguration class
-#
-config = SolverConfiguration()
-
-# for backwards compatibility
-# Odeoptions = Options
-# Odedata = Result
diff --git a/qutip/tests/solve/__init__.py b/qutip/tests/piqs/__init__.py
similarity index 100%
rename from qutip/tests/solve/__init__.py
rename to qutip/tests/piqs/__init__.py
diff --git a/qutip/tests/solve/test_piqs.py b/qutip/tests/piqs/test_piqs.py
similarity index 99%
rename from qutip/tests/solve/test_piqs.py
rename to qutip/tests/piqs/test_piqs.py
index d2cdb00047..54e17b91bd 100644
--- a/qutip/tests/solve/test_piqs.py
+++ b/qutip/tests/piqs/test_piqs.py
@@ -11,7 +11,7 @@
 )
 from scipy.sparse import block_diag
 from qutip import Qobj, entropy_vn, sigmax, sigmaz
-from qutip.solve._piqs import (
+from qutip.piqs._piqs import (
     get_blocks,
     j_min,
     j_vals,
@@ -21,8 +21,8 @@
     get_index,
     jmm1_dictionary,
 )
-from qutip.solve._piqs import Dicke as _Dicke
-from qutip.solve.piqs import *
+from qutip.piqs._piqs import Dicke as _Dicke
+from qutip.piqs.piqs import *
 
 import sys
 import unittest
diff --git a/qutip/tests/solve/test_qubit_evolution.py b/qutip/tests/solver/test_qubit_evolution.py
similarity index 100%
rename from qutip/tests/solve/test_qubit_evolution.py
rename to qutip/tests/solver/test_qubit_evolution.py

From 89ab584b7757badf09a718fb5d144a5980ae11f2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 13 Jul 2023 15:16:50 -0400
Subject: [PATCH 502/602] Rename diag to dia

---
 qutip/core/data/__init__.pxd              |  2 +-
 qutip/core/data/__init__.py               | 14 ++---
 qutip/core/data/add.pxd                   |  6 +-
 qutip/core/data/add.pyx                   | 24 ++++----
 qutip/core/data/adjoint.pxd               |  8 +--
 qutip/core/data/adjoint.pyx               | 26 ++++----
 qutip/core/data/constant.py               |  6 +-
 qutip/core/data/csr.pxd                   |  4 +-
 qutip/core/data/csr.pyx                   |  4 +-
 qutip/core/data/dense.pxd                 |  4 +-
 qutip/core/data/dense.pyx                 |  4 +-
 qutip/core/data/dia.pxd                   | 30 ++++-----
 qutip/core/data/dia.pyx                   | 74 +++++++++++------------
 qutip/core/data/expect.pxd                | 10 +--
 qutip/core/data/expect.pyx                | 26 ++++----
 qutip/core/data/expm.py                   | 16 ++---
 qutip/core/data/extract.py                | 11 ++--
 qutip/core/data/inner.pyx                 | 14 ++---
 qutip/core/data/kron.pyx                  | 12 ++--
 qutip/core/data/make.py                   | 12 ++--
 qutip/core/data/matmul.pxd                |  8 +--
 qutip/core/data/matmul.pyx                | 36 +++++------
 qutip/core/data/mul.pxd                   |  8 +--
 qutip/core/data/mul.pyx                   | 34 +++++------
 qutip/core/data/norm.pxd                  | 10 +--
 qutip/core/data/norm.pyx                  | 20 +++---
 qutip/core/data/pow.pyx                   | 18 +++---
 qutip/core/data/project.pyx               | 10 +--
 qutip/core/data/properties.pxd            |  6 +-
 qutip/core/data/properties.pyx            | 20 +++---
 qutip/core/data/ptrace.pyx                | 12 ++--
 qutip/core/data/reshape.pxd               |  8 +--
 qutip/core/data/reshape.pyx               | 32 +++++-----
 qutip/core/data/solve.py                  | 14 ++---
 qutip/core/data/tidyup.pxd                |  4 +-
 qutip/core/data/tidyup.pyx                | 10 +--
 qutip/core/data/trace.pxd                 |  6 +-
 qutip/core/data/trace.pyx                 | 14 ++---
 qutip/tests/core/data/conftest.py         |  4 +-
 qutip/tests/core/data/test_convert.py     | 26 ++++----
 qutip/tests/core/data/test_diag.py        | 40 ++++++------
 qutip/tests/core/data/test_expect.py      | 10 +--
 qutip/tests/core/data/test_linalg.py      |  4 +-
 qutip/tests/core/data/test_mathematics.py | 42 ++++++-------
 qutip/tests/core/data/test_norm.py        | 10 +--
 qutip/tests/core/data/test_properties.py  |  2 +-
 qutip/tests/core/data/test_ptrace.py      |  4 +-
 qutip/tests/core/data/test_reshape.py     | 10 +--
 qutip/tests/core/test_qobj.py             |  4 +-
 49 files changed, 370 insertions(+), 363 deletions(-)

diff --git a/qutip/core/data/__init__.pxd b/qutip/core/data/__init__.pxd
index cbd9ce5856..9e1a83faba 100644
--- a/qutip/core/data/__init__.pxd
+++ b/qutip/core/data/__init__.pxd
@@ -5,7 +5,7 @@ from qutip.core.data cimport dense, csr
 from qutip.core.data.base cimport Data, idxint
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.csr cimport CSR
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 
 from qutip.core.data.add cimport *
 from qutip.core.data.adjoint cimport *
diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index 60f8125f97..876291cf17 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -3,7 +3,7 @@
 from . import dense, csr
 from .dense import Dense
 from .csr import CSR
-from .dia import Diag
+from .dia import Dia
 from .base import Data
 
 from .add import *
@@ -38,14 +38,14 @@
 to.add_conversions([
     (Dense, CSR, dense.from_csr, 1),
     (CSR, Dense, csr.from_dense, 1.4),
-    (Diag, Dense, dia.from_dense, 1.4),
-    (Dense, Diag, dense.from_diag, 1.2),
-    (Diag, CSR, dia.from_csr, 1),
-    (CSR, Diag, csr.from_diag, 1),
+    (Dia, Dense, dia.from_dense, 1.4),
+    (Dense, Dia, dense.from_dia, 1.2),
+    (Dia, CSR, dia.from_csr, 1),
+    (CSR, Dia, csr.from_dia, 1),
 ])
 to.register_aliases(['csr', 'CSR'], CSR)
 to.register_aliases(['Dense', 'dense'], Dense)
-to.register_aliases(['Diag', 'dia', 'diag'], Diag)
+to.register_aliases(['Dia', 'dia', 'diag'], Dia)
 
 
 from . import _creator_utils
@@ -53,7 +53,7 @@
 create.add_creators([
     (_creator_utils.is_data, _creator_utils.data_copy, 100),
     (_creator_utils.isspmatrix_csr, CSR, 80),
-    (_creator_utils.isspmatrix_dia, Diag, 80),
+    (_creator_utils.isspmatrix_dia, Dia, 80),
     (_creator_utils.is_nparray, Dense, 80),
     (_creator_utils.issparse, CSR, 20),
     (_creator_utils.true, Dense, -np.inf),
diff --git a/qutip/core/data/add.pxd b/qutip/core/data/add.pxd
index 1c207062ed..dbed69900a 100644
--- a/qutip/core/data/add.pxd
+++ b/qutip/core/data/add.pxd
@@ -2,14 +2,14 @@
 
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 
 cdef void add_dense_eq_order_inplace(Dense left, Dense right, double complex scale)
 cpdef CSR add_csr(CSR left, CSR right, double complex scale=*)
 cpdef Dense add_dense(Dense left, Dense right, double complex scale=*)
-cpdef Diag add_diag(Diag left, Diag right, double complex scale=*)
+cpdef Dia add_dia(Dia left, Dia right, double complex scale=*)
 cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=*)
 
 cpdef CSR sub_csr(CSR left, CSR right)
 cpdef Dense sub_dense(Dense left, Dense right)
-cpdef Diag sub_diag(Diag left, Diag right)
+cpdef Dia sub_dia(Dia left, Dia right)
diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index d9beff20e9..1bae1a3e09 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -9,8 +9,8 @@ from qutip.settings import settings
 
 from qutip.core.data.base cimport idxint, Data
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
-from qutip.core.data.tidyup cimport tidyup_diag
+from qutip.core.data.dia cimport Dia
+from qutip.core.data.tidyup cimport tidyup_dia
 from qutip.core.data.csr cimport (
     CSR, Accumulator, acc_alloc, acc_free, acc_scatter, acc_gather, acc_reset,
 )
@@ -25,8 +25,8 @@ cdef extern from *:
 
 
 __all__ = [
-    'add', 'add_csr', 'add_dense', 'iadd_dense', 'add_diag',
-    'sub', 'sub_csr', 'sub_dense', 'sub_diag',
+    'add', 'add_csr', 'add_dense', 'iadd_dense', 'add_dia',
+    'sub', 'sub_csr', 'sub_dense', 'sub_dia',
 ]
 
 
@@ -219,14 +219,14 @@ cpdef Dense iadd_dense(Dense left, Dense right, double complex scale=1):
     return left
 
 
-cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
+cpdef Dia add_dia(Dia left, Dia right, double complex scale=1):
     _check_shape(left, right)
     cdef idxint diag_left=0, diag_right=0, out_diag=0, i
     cdef double complex *ptr_out,
     cdef double complex *ptr_left
     cdef double complex *ptr_right
     cdef bint sorted=True
-    cdef Diag out = dia.empty(left.shape[0], left.shape[1], left.num_diag + right.num_diag)
+    cdef Dia out = dia.empty(left.shape[0], left.shape[1], left.num_diag + right.num_diag)
     cdef int length, size=left.shape[1]
 
     ptr_out = out.data
@@ -286,9 +286,9 @@ cpdef Diag add_diag(Diag left, Diag right, double complex scale=1):
         out.num_diag = out_diag
 
     if not sorted:
-        dia.clean_diag(out, True)
+        dia.clean_dia(out, True)
     if settings.core['auto_tidyup']:
-        tidyup_diag(out, settings.core['auto_tidyup_atol'], True)
+        tidyup_dia(out, settings.core['auto_tidyup_atol'], True)
     return out
 
 
@@ -300,8 +300,8 @@ cpdef Dense sub_dense(Dense left, Dense right):
     return add_dense(left, right, -1)
 
 
-cpdef Diag sub_diag(Diag left, Diag right):
-    return add_diag(left, right, -1)
+cpdef Dia sub_dia(Dia left, Dia right):
+    return add_dia(left, right, -1)
 
 
 from .dispatch import Dispatcher as _Dispatcher
@@ -329,7 +329,7 @@ add.__doc__ =\
 add.add_specialisations([
     (Dense, Dense, Dense, add_dense),
     (CSR, CSR, CSR, add_csr),
-    (Diag, Diag, Diag, add_diag),
+    (Dia, Dia, Dia, add_dia),
 ], _defer=True)
 
 sub = _Dispatcher(
@@ -351,7 +351,7 @@ sub.__doc__ =\
 sub.add_specialisations([
     (Dense, Dense, Dense, sub_dense),
     (CSR, CSR, CSR, sub_csr),
-    (Diag, Diag, Diag, sub_diag),
+    (Dia, Dia, Dia, sub_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/adjoint.pxd b/qutip/core/data/adjoint.pxd
index 4e61c1a24e..9330a9b2f9 100644
--- a/qutip/core/data/adjoint.pxd
+++ b/qutip/core/data/adjoint.pxd
@@ -2,7 +2,7 @@
 
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 
 cpdef CSR adjoint_csr(CSR matrix)
 cpdef CSR transpose_csr(CSR matrix)
@@ -12,6 +12,6 @@ cpdef Dense adjoint_dense(Dense matrix)
 cpdef Dense transpose_dense(Dense matrix)
 cpdef Dense conj_dense(Dense matrix)
 
-cpdef Diag adjoint_diag(Diag matrix)
-cpdef Diag transpose_diag(Diag matrix)
-cpdef Diag conj_diag(Diag matrix)
+cpdef Dia adjoint_dia(Dia matrix)
+cpdef Dia transpose_dia(Dia matrix)
+cpdef Dia conj_dia(Dia matrix)
diff --git a/qutip/core/data/adjoint.pyx b/qutip/core/data/adjoint.pyx
index feb65dec62..68ee57637e 100644
--- a/qutip/core/data/adjoint.pyx
+++ b/qutip/core/data/adjoint.pyx
@@ -8,7 +8,7 @@ cimport cython
 from qutip.core.data.base cimport idxint
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 from qutip.core.data cimport csr, dense, dia
 
 # Import std::conj as `_conj` to avoid clashing with our 'conj' dispatcher.
@@ -16,9 +16,9 @@ cdef extern from "<complex>" namespace "std" nogil:
     double complex _conj "conj"(double complex x)
 
 __all__ = [
-    'adjoint', 'adjoint_csr', 'adjoint_dense', 'adjoint_diag',
-    'conj', 'conj_csr', 'conj_dense', 'conj_diag',
-    'transpose', 'transpose_csr', 'transpose_dense', 'transpose_diag',
+    'adjoint', 'adjoint_csr', 'adjoint_dense', 'adjoint_dia',
+    'conj', 'conj_csr', 'conj_dense', 'conj_dia',
+    'transpose', 'transpose_csr', 'transpose_dense', 'transpose_dia',
 ]
 
 
@@ -110,8 +110,8 @@ cpdef Dense conj_dense(Dense matrix):
     return out
 
 
-cpdef Diag adjoint_diag(Diag matrix):
-    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag)
+cpdef Dia adjoint_dia(Dia matrix):
+    cdef Dia out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag)
     cdef size_t i, new_i,
     cdef idxint new_offset, j
     with nogil:
@@ -127,8 +127,8 @@ cpdef Diag adjoint_diag(Diag matrix):
     return out
 
 
-cpdef Diag transpose_diag(Diag matrix):
-    cdef Diag out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag)
+cpdef Dia transpose_dia(Dia matrix):
+    cdef Dia out = dia.empty(matrix.shape[1], matrix.shape[0], matrix.num_diag)
     cdef size_t i, new_i,
     cdef idxint new_offset, j
     with nogil:
@@ -144,8 +144,8 @@ cpdef Diag transpose_diag(Diag matrix):
     return out
 
 
-cpdef Diag conj_diag(Diag matrix):
-    cdef Diag out = dia.empty_like(matrix)
+cpdef Dia conj_dia(Dia matrix):
+    cdef Dia out = dia.empty_like(matrix)
     cdef size_t i, j
     with nogil:
         out.num_diag = matrix.num_diag
@@ -172,7 +172,7 @@ adjoint.__doc__ = """Hermitian adjoint (matrix conjugate transpose)."""
 adjoint.add_specialisations([
     (Dense, Dense, adjoint_dense),
     (CSR, CSR, adjoint_csr),
-    (Diag, Diag, adjoint_diag),
+    (Dia, Dia, adjoint_dia),
 ], _defer=True)
 
 transpose = _Dispatcher(
@@ -188,7 +188,7 @@ transpose.__doc__ = """Transpose of a matrix."""
 transpose.add_specialisations([
     (Dense, Dense, transpose_dense),
     (CSR, CSR, transpose_csr),
-    (Diag, Diag, transpose_diag),
+    (Dia, Dia, transpose_dia),
 ], _defer=True)
 
 conj = _Dispatcher(
@@ -204,7 +204,7 @@ conj.__doc__ = """Element-wise conjugation of a matrix."""
 conj.add_specialisations([
     (Dense, Dense, conj_dense),
     (CSR, CSR, conj_csr),
-    (Diag, Diag, conj_diag),
+    (Dia, Dia, conj_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/constant.py b/qutip/core/data/constant.py
index 06df0fe30d..54b64c824d 100644
--- a/qutip/core/data/constant.py
+++ b/qutip/core/data/constant.py
@@ -5,7 +5,7 @@
 
 from . import csr, dense, dia
 from .csr import CSR
-from .dia import Diag
+from .dia import Dia
 from .dense import Dense
 from .base import Data
 from .dispatch import Dispatcher as _Dispatcher
@@ -39,7 +39,7 @@
     """
 zeros.add_specialisations([
     (CSR, csr.zeros),
-    (Diag, dia.zeros),
+    (Dia, dia.zeros),
     (Dense, dense.zeros),
 ], _defer=True)
 
@@ -70,7 +70,7 @@
     """
 identity.add_specialisations([
     (CSR, csr.identity),
-    (Diag, dia.identity),
+    (Dia, dia.identity),
     (Dense, dense.identity),
 ], _defer=True)
 
diff --git a/qutip/core/data/csr.pxd b/qutip/core/data/csr.pxd
index 0dea011964..4c813564ef 100644
--- a/qutip/core/data/csr.pxd
+++ b/qutip/core/data/csr.pxd
@@ -12,7 +12,7 @@ cimport numpy as cnp
 
 from qutip.core.data cimport base
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 
 cdef class CSR(base.Data):
     cdef double complex *data
@@ -162,7 +162,7 @@ cpdef CSR from_dense(Dense matrix)
 cdef CSR from_coo_pointers(base.idxint *rows, base.idxint *cols, double complex *data,
                            base.idxint n_rows, base.idxint n_cols, base.idxint nnz,
                            double tol=*)
-cpdef CSR from_diag(Diag matrix)
+cpdef CSR from_dia(Dia matrix)
 
 cpdef CSR _from_csr_blocks(base.idxint[:] block_rows, base.idxint[:] block_cols, CSR[:] block_ops,
                           base.idxint n_blocks, base.idxint block_size)
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 71fbbedc0a..0b7d105b87 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -24,7 +24,7 @@ except ImportError:
     from scipy.sparse._data import _data_matrix as scipy_data_matrix
 from scipy.linalg cimport cython_blas as blas
 
-from qutip.core.data cimport base, Dense, Diag
+from qutip.core.data cimport base, Dense, Dia
 from qutip.core.data.adjoint cimport adjoint_csr, transpose_csr, conj_csr
 from qutip.core.data.trace cimport trace_csr
 from qutip.core.data.tidyup cimport tidyup_csr
@@ -639,7 +639,7 @@ cdef CSR from_coo_pointers(
     return out
 
 
-cpdef CSR from_diag(Diag matrix):
+cpdef CSR from_dia(Dia matrix):
     if matrix.num_diag == 0:
         return zeros(*matrix.shape)
     mat = matrix.as_scipy()
diff --git a/qutip/core/data/dense.pxd b/qutip/core/data/dense.pxd
index c39145f441..f509def92b 100644
--- a/qutip/core/data/dense.pxd
+++ b/qutip/core/data/dense.pxd
@@ -4,7 +4,7 @@ cimport numpy as cnp
 
 from . cimport base
 from qutip.core.data.csr cimport CSR
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 
 cdef class Dense(base.Data):
     cdef double complex *data
@@ -29,4 +29,4 @@ cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=*)
 cpdef Dense identity(base.idxint dimension, double complex scale=*,
                      bint fortran=*)
 cpdef Dense from_csr(CSR matrix, bint fortran=*)
-cpdef Dense from_diag(Diag matrix)
+cpdef Dense from_dia(Dia matrix)
diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
index 02c902afdb..0c75a463a5 100644
--- a/qutip/core/data/dense.pyx
+++ b/qutip/core/data/dense.pyx
@@ -11,7 +11,7 @@ cimport numpy as cnp
 from scipy.linalg cimport cython_blas as blas
 
 from .base import EfficiencyWarning
-from qutip.core.data cimport base, CSR, Diag
+from qutip.core.data cimport base, CSR, Dia
 from qutip.core.data.adjoint cimport adjoint_dense, transpose_dense, conj_dense
 from qutip.core.data.trace cimport trace_dense
 
@@ -303,7 +303,7 @@ cpdef Dense from_csr(CSR matrix, bint fortran=False):
     return out
 
 
-cpdef Dense from_diag(Diag matrix):
+cpdef Dense from_dia(Dia matrix):
     return Dense(matrix.to_array(), copy=False)
 
 
diff --git a/qutip/core/data/dia.pxd b/qutip/core/data/dia.pxd
index a71029b1b7..34bc36eadd 100644
--- a/qutip/core/data/dia.pxd
+++ b/qutip/core/data/dia.pxd
@@ -14,24 +14,24 @@ from qutip.core.data cimport base
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.csr cimport CSR
 
-cdef class Diag(base.Data):
+cdef class Dia(base.Data):
     cdef double complex *data
     cdef base.idxint *offsets
     cdef readonly size_t num_diag, _max_diag
     cdef object _scipy
     cdef bint _deallocate
-    cpdef Diag copy(Diag self)
-    cpdef object as_scipy(Diag self, bint full=*)
-    cpdef double complex trace(Diag self)
-    cpdef Diag adjoint(Diag self)
-    cpdef Diag conj(Diag self)
-    cpdef Diag transpose(Diag self)
+    cpdef Dia copy(Dia self)
+    cpdef object as_scipy(Dia self, bint full=*)
+    cpdef double complex trace(Dia self)
+    cpdef Dia adjoint(Dia self)
+    cpdef Dia conj(Dia self)
+    cpdef Dia transpose(Dia self)
 
-cpdef Diag fast_from_scipy(object sci)
-cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag)
-cpdef Diag empty_like(Diag other)
-cpdef Diag zeros(base.idxint rows, base.idxint cols)
-cpdef Diag identity(base.idxint dimension, double complex scale=*)
-cpdef Diag from_dense(Dense matrix)
-cpdef Diag from_csr(CSR matrix)
-cpdef Diag clean_diag(Diag matrix, bint inplace=*)
+cpdef Dia fast_from_scipy(object sci)
+cpdef Dia empty(base.idxint rows, base.idxint cols, base.idxint num_diag)
+cpdef Dia empty_like(Dia other)
+cpdef Dia zeros(base.idxint rows, base.idxint cols)
+cpdef Dia identity(base.idxint dimension, double complex scale=*)
+cpdef Dia from_dense(Dense matrix)
+cpdef Dia from_csr(CSR matrix)
+cpdef Dia clean_dia(Dia matrix, bint inplace=*)
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 85340c24cb..3aaffe3036 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -25,9 +25,9 @@ except ImportError:
 from scipy.linalg cimport cython_blas as blas
 
 from qutip.core.data cimport base, Dense, CSR
-from qutip.core.data.adjoint import adjoint_diag, transpose_diag, conj_diag
-from qutip.core.data.trace import trace_diag
-from qutip.core.data.tidyup import tidyup_diag
+from qutip.core.data.adjoint import adjoint_dia, transpose_dia, conj_dia
+from qutip.core.data.trace import trace_dia
+from qutip.core.data.tidyup import tidyup_dia
 from .base import idxint_dtype
 from qutip.settings import settings
 
@@ -38,7 +38,7 @@ cdef extern from *:
     void *PyDataMem_NEW(size_t size)
     void PyDataMem_FREE(void *ptr)
 
-__all__ = ['Diag']
+__all__ = ['Dia']
 
 cdef object _dia_matrix(data, offsets, shape):
     """
@@ -65,7 +65,7 @@ cdef tuple _count_element(complex[:] line, size_t length):
     return (post, length - pre)
 
 
-cdef class Diag(base.Data):
+cdef class Dia(base.Data):
     def __cinit__(self, *args, **kwargs):
         self._deallocate = True
 
@@ -94,7 +94,7 @@ cdef class Diag(base.Data):
         self._max_diag = self.num_diag
 
         if shape is None:
-            warnings.warn("instantiating Diag matrix of unknown shape")
+            warnings.warn("instantiating Dia matrix of unknown shape")
             nrows = 0
             ncols = 0
             for i in range(self.num_diag):
@@ -133,12 +133,12 @@ cdef class Diag(base.Data):
 
         self._scipy = _dia_matrix(data, offsets, self.shape)
         if tidyup:
-            tidyup_diag(self, settings.core['auto_tidyup_atol'], True)
+            tidyup_dia(self, settings.core['auto_tidyup_atol'], True)
 
     def __reduce__(self):
         return (fast_from_scipy, (self.as_scipy(),))
 
-    cpdef Diag copy(self):
+    cpdef Dia copy(self):
         """
         Return a complete (deep) copy of this object.
 
@@ -150,7 +150,7 @@ cdef class Diag(base.Data):
         unnecessary speed penalty for users who do not need it (including
         low-level C code).
         """
-        cdef Diag out = empty_like(self)
+        cdef Dia out = empty_like(self)
         out.num_diag = self.num_diag
         memcpy(out.data, self.data, self.num_diag * self.shape[1] * sizeof(double complex))
         memcpy(out.offsets, self.offsets, self.num_diag * sizeof(base.idxint))
@@ -203,20 +203,20 @@ cdef class Diag(base.Data):
         return self._scipy
 
     cpdef double complex trace(self):
-        return trace_diag(self)
+        return trace_dia(self)
 
-    cpdef Diag adjoint(self):
-        return adjoint_diag(self)
+    cpdef Dia adjoint(self):
+        return adjoint_dia(self)
 
-    cpdef Diag conj(self):
-        return conj_diag(self)
+    cpdef Dia conj(self):
+        return conj_dia(self)
 
-    cpdef Diag transpose(self):
-        return transpose_diag(self)
+    cpdef Dia transpose(self):
+        return transpose_dia(self)
 
     def __repr__(self):
         return "".join([
-            "Diag(shape=", str(self.shape), ", num_diag=", str(self.num_diag), ")",
+            "Dia(shape=", str(self.shape), ", num_diag=", str(self.num_diag), ")",
         ])
 
     def __str__(self):
@@ -234,13 +234,13 @@ cdef class Diag(base.Data):
             PyDataMem_FREE(self.offsets)
 
 
-cpdef Diag fast_from_scipy(object sci):
+cpdef Dia fast_from_scipy(object sci):
     """
     Fast path construction from scipy.sparse.csr_matrix.  This does _no_ type
     checking on any of the inputs, and should consequently be considered very
     unsafe.  This is primarily for use in the unpickling operation.
     """
-    cdef Diag out = Diag.__new__(Diag)
+    cdef Dia out = Dia.__new__(Dia)
     out.shape = sci.shape
     out._deallocate = False
     out._scipy = sci
@@ -251,16 +251,16 @@ cpdef Diag fast_from_scipy(object sci):
     return out
 
 
-cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
+cpdef Dia empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
     """
-    Allocate an empty Diag matrix of the given shape, ``with num_diag``
+    Allocate an empty Dia matrix of the given shape, ``with num_diag``
     diagonals.
 
     This does not initialise any of the memory returned.
     """
     if num_diag < 0:
         raise ValueError("num_diag must be a positive integer.")
-    cdef Diag out = Diag.__new__(Diag)
+    cdef Dia out = Dia.__new__(Dia)
     out.shape = (rows, cols)
     out.num_diag = 0
     # Python doesn't like allocating nothing.
@@ -274,30 +274,30 @@ cpdef Diag empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
     return out
 
 
-cpdef Diag empty_like(Diag other):
+cpdef Dia empty_like(Dia other):
     return empty(other.shape[0], other.shape[1], other.num_diag)
 
 
-cpdef Diag zeros(base.idxint rows, base.idxint cols):
+cpdef Dia zeros(base.idxint rows, base.idxint cols):
     """
     Allocate the zero matrix with a given shape.  There will not be any room in
     the `data` and `col_index` buffers to add new elements.
     """
     # We always allocate matrices with at least one element to ensure that we
     # actually _are_ asking for memory (Python doesn't like allocating nothing)
-    cdef Diag out = empty(rows, cols, 0)
+    cdef Dia out = empty(rows, cols, 0)
     memset(out.data, 0, out.shape[1] * sizeof(double complex))
     out.offsets[0] = 0
     return out
 
 
-cpdef Diag identity(base.idxint dimension, double complex scale=1):
+cpdef Dia identity(base.idxint dimension, double complex scale=1):
     """
     Return a square matrix of the specified dimension, with a constant along
     the diagonal.  By default this will be the identity matrix, but if `scale`
     is passed, then the result will be `scale` times the identity.
     """
-    cdef Diag out = empty(dimension, dimension, 1)
+    cdef Dia out = empty(dimension, dimension, 1)
     for i in range(dimension):
         out.data[i] = scale
     out.offsets[0] = 0
@@ -306,8 +306,8 @@ cpdef Diag identity(base.idxint dimension, double complex scale=1):
 
 
 @cython.boundscheck(True)
-cpdef Diag from_dense(Dense matrix):
-    cdef Diag out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
+cpdef Dia from_dense(Dense matrix):
+    cdef Dia out = empty(matrix.shape[0], matrix.shape[1], matrix.shape[0] + matrix.shape[1] - 1)
     memset(out.data, 0, out._max_diag * out.shape[1] * sizeof(double complex))
     cdef size_t diag_, ptr_in, ptr_out=0, stride
     cdef row, col
@@ -323,12 +323,12 @@ cpdef Diag from_dense(Dense matrix):
             out.data[(col - row + matrix.shape[0] - 1) * out.shape[1] + col] = matrix.data[row * strideR + col * strideC]
 
     if settings.core["auto_tidyup"]:
-        tidyup_diag(out, settings.core["auto_tidyup_atol"], True)
+        tidyup_dia(out, settings.core["auto_tidyup_atol"], True)
 
     return out
 
 
-cpdef Diag from_csr(CSR matrix):
+cpdef Dia from_csr(CSR matrix):
     out_diag = set()
     for row in range(matrix.shape[0]):
         for ptr in range(matrix.row_index[row], matrix.row_index[row+1]):
@@ -340,15 +340,15 @@ cpdef Diag from_csr(CSR matrix):
             diag = matrix.col_index[ptr] - row
             idx = np.searchsorted(diags, diag)
             data[idx, matrix.col_index[ptr]] = matrix.data[ptr]
-    return Diag((data, diags), shape=matrix.shape, copy=False)
+    return Dia((data, diags), shape=matrix.shape, copy=False)
 
 
-cpdef Diag clean_diag(Diag matrix, bint inplace=False):
+cpdef Dia clean_dia(Dia matrix, bint inplace=False):
     """
     Sort and sum duplicates of offsets.
     Set out of bound values to zeros.
     """
-    cdef Diag out = matrix if inplace else matrix.copy()
+    cdef Dia out = matrix if inplace else matrix.copy()
     cdef base.idxint diag=0, new_diag=0, start, end, col
     cdef double complex zONE=1.
     cdef bint has_duplicate
@@ -409,12 +409,12 @@ cdef inline base.idxint _diagonal_length(
     return n_cols if offset > n_cols - n_rows else n_rows + offset
 
 
-cdef Diag diags_(
+cdef Dia diags_(
     list diagonals, base.idxint[:] offsets,
     base.idxint n_rows, base.idxint n_cols,
 ):
     """
-    Construct a Diag matrix from a list of diagonals and their offsets.  The
+    Construct a Dia matrix from a list of diagonals and their offsets.  The
     offsets are assumed to be in sorted order.  This is the C-only interface to
     diag.diags, and inputs are not sanity checked (use the Python interface for
     that).
@@ -448,7 +448,7 @@ cdef Diag diags_(
 @cython.wraparound(True)
 def diags(diagonals, offsets=None, shape=None):
     """
-    Construct a Diag matrix from diagonals and their offsets.  Using this
+    Construct a Dia matrix from diagonals and their offsets.  Using this
     function in single-argument form produces a square matrix with the given
     values on the main diagonal.
 
diff --git a/qutip/core/data/expect.pxd b/qutip/core/data/expect.pxd
index 05d33a248f..f5fd985162 100644
--- a/qutip/core/data/expect.pxd
+++ b/qutip/core/data/expect.pxd
@@ -1,7 +1,7 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from qutip.core.data cimport CSR, Dense, Data, Diag
+from qutip.core.data cimport CSR, Dense, Data, Dia
 
 cpdef double complex expect_csr(CSR op, CSR state) nogil except *
 cpdef double complex expect_super_csr(CSR op, CSR state) nogil except *
@@ -12,11 +12,11 @@ cpdef double complex expect_super_csr_dense(CSR op, Dense state) nogil except *
 cpdef double complex expect_dense(Dense op, Dense state) nogil except *
 cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *
 
-cpdef double complex expect_diag(Diag op, Diag state) except *
-cpdef double complex expect_super_diag(Diag op, Diag state) except *
+cpdef double complex expect_dia(Dia op, Dia state) except *
+cpdef double complex expect_super_dia(Dia op, Dia state) except *
 
-cpdef double complex expect_diag_dense(Diag op, Dense state) except *
-cpdef double complex expect_super_diag_dense(Diag op, Dense state) except *
+cpdef double complex expect_dia_dense(Dia op, Dense state) except *
+cpdef double complex expect_super_dia_dense(Dia op, Dense state) except *
 
 cdef double complex expect_data_dense(Data op, Dense state) except *
 cdef double complex expect_super_data_dense(Data op, Dense state) except *
diff --git a/qutip/core/data/expect.pyx b/qutip/core/data/expect.pyx
index bc55e1ed8d..42f47f1215 100644
--- a/qutip/core/data/expect.pyx
+++ b/qutip/core/data/expect.pyx
@@ -12,13 +12,13 @@ cdef extern from "<complex>" namespace "std" nogil:
     double complex conj(double complex x)
 
 from qutip.core.data.base cimport idxint, Data
-from qutip.core.data cimport csr, CSR, Dense, Diag
+from qutip.core.data cimport csr, CSR, Dense, Dia
 
 __all__ = [
-    'expect', 'expect_csr', 'expect_dense', 'expect_diag',
-    'expect_csr_dense', 'expect_diag_dense',
-    'expect_super', 'expect_super_csr', 'expect_super_diag', 'expect_super_dense',
-    'expect_super_csr_dense', 'expect_super_diag_dense',
+    'expect', 'expect_csr', 'expect_dense', 'expect_dia',
+    'expect_csr_dense', 'expect_dia_dense',
+    'expect_super', 'expect_super_csr', 'expect_super_dia', 'expect_super_dense',
+    'expect_super_csr_dense', 'expect_super_dia_dense',
 ]
 
 cdef void _check_shape_ket(Data op, Data state) nogil except *:
@@ -250,7 +250,7 @@ cpdef double complex expect_super_dense(Dense op, Dense state) nogil except *:
     return out
 
 
-cpdef double complex expect_diag(Diag op, Diag state) except *:
+cpdef double complex expect_dia(Dia op, Dia state) except *:
     cdef double complex expect = 0.
     cdef idxint diag_bra, diag_op, diag_ket, i, length
     cdef idxint start_op, start_state, end_op, end_state
@@ -290,7 +290,7 @@ cpdef double complex expect_diag(Diag op, Diag state) except *:
     return expect
 
 
-cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
+cpdef double complex expect_dia_dense(Dia op, Dense state) except *:
     cdef double complex expect = 0.
     cdef idxint i, diag_op, start_op, end_op, strideR, stride, start_state
     if state.shape[1] == 1:
@@ -320,7 +320,7 @@ cpdef double complex expect_diag_dense(Diag op, Dense state) except *:
     return expect
 
 
-cpdef double complex expect_super_diag(Diag op, Diag state) except *:
+cpdef double complex expect_super_dia(Dia op, Dia state) except *:
     cdef double complex expect = 0.
     _check_shape_super(op, state)
     cdef idxint diag_op, diag_state
@@ -337,7 +337,7 @@ cpdef double complex expect_super_diag(Diag op, Diag state) except *:
     return expect
 
 
-cpdef double complex expect_super_diag_dense(Diag op, Dense state) except *:
+cpdef double complex expect_super_dia_dense(Dia op, Dense state) except *:
     cdef double complex expect = 0.
     _check_shape_super(op, state)
     cdef idxint col, diag_op, start, end
@@ -379,8 +379,8 @@ expect.add_specialisations([
     (CSR, CSR, expect_csr),
     (CSR, Dense, expect_csr_dense),
     (Dense, Dense, expect_dense),
-    (Diag, Dense, expect_diag_dense),
-    (Diag, Diag, expect_diag),
+    (Dia, Dense, expect_dia_dense),
+    (Dia, Dia, expect_dia),
 ], _defer=True)
 
 expect_super = _Dispatcher(
@@ -403,8 +403,8 @@ expect_super.add_specialisations([
     (CSR, CSR, expect_super_csr),
     (CSR, Dense, expect_super_csr_dense),
     (Dense, Dense, expect_super_dense),
-    (Diag, Dense, expect_super_diag_dense),
-    (Diag, Diag, expect_super_diag),
+    (Dia, Dense, expect_super_dia_dense),
+    (Dia, Dia, expect_super_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index 36982b7479..970767d540 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -4,14 +4,14 @@
 
 from .dense import Dense
 from .csr import CSR
-from .dia import Diag
+from .dia import Dia
 from . import dia
-from .properties import isdiag_csr, isdiag_diag
+from .properties import isdiag_csr, isdiag_dia
 from qutip.settings import settings
 from .base import idxint_dtype
 
 __all__ = [
-    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense', 'expm_diag',
+    'expm', 'expm_csr', 'expm_csr_dense', 'expm_dense', 'expm_dia',
     'logm', 'logm_dense',
 ]
 
@@ -39,16 +39,16 @@ def expm_csr(matrix: CSR) -> CSR:
                tidyup=settings.core['auto_tidyup'])
 
 
-def expm_diag(matrix: Diag) -> Diag:
+def expm_dia(matrix: Dia) -> Dia:
     if matrix.shape[0] != matrix.shape[1]:
         raise ValueError("can only exponentiate square matrix")
     if matrix.num_diag == 0:
         out = dia.identity(matrix.shape[0])
     elif matrix.num_diag > 1:
         csc = matrix.as_scipy().tocsc()
-        out = Diag(scipy.sparse.linalg.expm(csc).todia(),
+        out = Dia(scipy.sparse.linalg.expm(csc).todia(),
                    tidyup=settings.core['auto_tidyup'], copy=False)
-    elif isdiag_diag(matrix):
+    elif isdiag_dia(matrix):
         matrix_sci = matrix.as_scipy()
         data = np.exp(matrix_sci.data[0, :])
         out = dia.diags(data, shape=matrix.shape)
@@ -68,7 +68,7 @@ def expm_diag(matrix: Diag) -> Diag:
             out_data[i, max(0, n_offset): min(size, size + n_offset)] = data
             data = data_0[:-abs(n_offset)] * data[a_offset:] / (i+1)
             n_offset += offset
-        out = Diag((out_data, out_oufsets), shape=matrix.shape, copy=False)
+        out = Dia((out_data, out_oufsets), shape=matrix.shape, copy=False)
 
     return out
 
@@ -103,7 +103,7 @@ def expm_dense(matrix: Dense) -> Dense:
     (CSR, CSR, expm_csr),
     (CSR, Dense, expm_csr_dense),
     (Dense, Dense, expm_dense),
-    (Diag, Diag, expm_diag),
+    (Dia, Dia, expm_dia),
 ], _defer=True)
 
 
diff --git a/qutip/core/data/extract.py b/qutip/core/data/extract.py
index 7dbe07fac2..a5bbfeecb1 100644
--- a/qutip/core/data/extract.py
+++ b/qutip/core/data/extract.py
@@ -1,4 +1,4 @@
-from . import Dense, CSR, Diag
+from . import Dense, CSR, Dia
 from .dispatch import Dispatcher as _Dispatcher
 import inspect as _inspect
 try:
@@ -8,6 +8,9 @@
 from scipy.sparse import csr_matrix
 
 
+__all__ = ["extract"]
+
+
 def extract_dense(matrix, format=None, copy=True):
     """
     Return an array representation of the Dense data object.
@@ -59,7 +62,7 @@ def extract_csr(matrix, format=None, copy=True):
     return csr_mat
 
 
-def extract_diag(matrix, format=None, copy=True):
+def extract_dia(matrix, format=None, copy=True):
     """
     Return the scipy's object ``dia_matrix``.
 
@@ -76,7 +79,7 @@ def extract_diag(matrix, format=None, copy=True):
     """
     if format not in [None, "scipy_dia", "dia_matrix"]:
         raise ValueError(
-            "Diag can only be extracted to 'dia_matrix'"
+            "Dia can only be extracted to 'dia_matrix'"
         )
     dia_mat = matrix.as_scipy()
     if copy:
@@ -119,7 +122,7 @@ def extract_diag(matrix, format=None, copy=True):
     """
 extract.add_specialisations([
     (CSR, extract_csr),
-    (Diag, extract_diag),
+    (Dia, extract_dia),
     (Dense, extract_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/inner.pyx b/qutip/core/data/inner.pyx
index afde68061c..a708dd6890 100644
--- a/qutip/core/data/inner.pyx
+++ b/qutip/core/data/inner.pyx
@@ -8,12 +8,12 @@ from qutip.core.data.base cimport idxint, Data
 from qutip.core.data cimport csr, dense
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 from qutip.core.data.matmul cimport matmul_dense
 
 __all__ = [
-    'inner', 'inner_csr', 'inner_dense', 'inner_diag',
-    'inner_op', 'inner_op_csr', 'inner_op_dense', 'inner_op_diag',
+    'inner', 'inner_csr', 'inner_dense', 'inner_dia',
+    'inner_op', 'inner_op_csr', 'inner_op_dense', 'inner_op_dia',
 ]
 
 
@@ -91,7 +91,7 @@ cpdef double complex inner_csr(CSR left, CSR right, bint scalar_is_ket=False) no
         return _inner_csr_bra_ket(left, right)
     return _inner_csr_ket_ket(left, right)
 
-cpdef double complex inner_diag(Diag left, Diag right, bint scalar_is_ket=False) nogil except *:
+cpdef double complex inner_dia(Dia left, Dia right, bint scalar_is_ket=False) nogil except *:
     """
     Compute the complex inner product <left|right>.  The shape of `left` is
     used to determine if it has been supplied as a ket or a bra.  The result of
@@ -189,7 +189,7 @@ cdef double complex _inner_op_csr_ket_ket(CSR left, CSR op, CSR right) nogil:
         out += conj(left.data[ptr_l]) * sum
     return out
 
-cpdef double complex inner_op_diag(Diag left, Diag op, Diag right,
+cpdef double complex inner_op_dia(Dia left, Dia op, Dia right,
                                    bint scalar_is_ket=False) nogil except *:
     """
     Compute the complex inner product <left|op|right>.  The shape of `left` is
@@ -315,7 +315,7 @@ inner.__doc__ =\
     """
 inner.add_specialisations([
     (CSR, CSR, inner_csr),
-    (Diag, Diag, inner_diag),
+    (Dia, Dia, inner_dia),
     (Dense, Dense, inner_dense),
 ], _defer=True)
 
@@ -365,7 +365,7 @@ inner_op.__doc__ =\
     """
 inner_op.add_specialisations([
     (CSR, CSR, CSR, inner_op_csr),
-    (Diag, Diag, Diag, inner_op_diag),
+    (Dia, Dia, Dia, inner_op_dia),
     (Dense, Dense, Dense, inner_op_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index efac2f7d42..b1d4db4fd6 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -7,12 +7,12 @@ from libc.string cimport memset
 from qutip.core.data.base cimport idxint
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 from qutip.core.data cimport csr, dia
 import numpy
 
 __all__ = [
-    'kron', 'kron_csr', 'kron_dense', 'kron_diag',
+    'kron', 'kron_csr', 'kron_dense', 'kron_dia',
 ]
 
 
@@ -77,7 +77,7 @@ cdef inline void _vec_kron(
             ptr_out[i*step+j] = ptr_l[i] * ptr_r[j]
 
 
-cpdef Diag kron_diag(Diag left, Diag right):
+cpdef Dia kron_dia(Dia left, Dia right):
     cdef idxint nrows_l=left.shape[0], nrows_r=right.shape[0]
     cdef idxint ncols_l=left.shape[1], ncols_r=right.shape[1]
     cdef idxint nrows=_mul_checked(nrows_l, nrows_r)
@@ -85,7 +85,7 @@ cpdef Diag kron_diag(Diag left, Diag right):
     cdef idxint max_diag=_mul_checked(right.num_diag, left.num_diag)
     cdef idxint num_diag=0, diag_left, diag_right, delta, col_left, col_right
     cdef idxint start_left, end_left, start_right, end_right
-    cdef Diag out
+    cdef Dia out
 
     if right.shape[0] == right.shape[1]:
         out = dia.empty(nrows, ncols, max_diag)
@@ -140,7 +140,7 @@ cpdef Diag kron_diag(Diag left, Diag right):
                     num_diag += 1
 
     out.num_diag = num_diag
-    out = dia.clean_diag(out, True)
+    out = dia.clean_dia(out, True)
     return out
 
 
@@ -165,7 +165,7 @@ kron.__doc__ =\
 kron.add_specialisations([
     (CSR, CSR, CSR, kron_csr),
     (Dense, Dense, Dense, kron_dense),
-    (Diag, Diag, Diag, kron_diag),
+    (Dia, Dia, Dia, kron_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
index 42083c83f6..a146641622 100644
--- a/qutip/core/data/make.py
+++ b/qutip/core/data/make.py
@@ -1,10 +1,10 @@
 from .dispatch import Dispatcher as _Dispatcher
-from . import csr, dense, dia, CSR, Dense, Diag
+from . import csr, dense, dia, CSR, Dense, Dia
 import numpy as np
 
 __all__ = [
     'diag',
-    'one_element_csr', 'one_element_dense', 'one_element_diag', 'one_element'
+    'one_element_csr', 'one_element_dense', 'one_element_dia', 'one_element'
 ]
 
 
@@ -40,7 +40,7 @@ def _diag_signature(diagonals, offsets=0, shape=None):
 diag = _Dispatcher(_diag_signature, name='diag', inputs=(), out=True)
 diag.add_specialisations([
     (CSR, csr.diags),
-    (Diag, dia.diags),
+    (Dia, dia.diags),
     (Dense, dense.diags),
 ], _defer=True)
 
@@ -98,7 +98,7 @@ def one_element_dense(shape, position, value=1.0):
     return data
 
 
-def one_element_diag(shape, position, value=1.0):
+def one_element_dia(shape, position, value=1.0):
     """
     Create a matrix with only one nonzero element.
 
@@ -119,7 +119,7 @@ def one_element_diag(shape, position, value=1.0):
     data = np.zeros((1 ,shape[1]), dtype=complex)
     data[0, position[1]] = value
     offsets = np.array([position[1]-position[0]])
-    return Diag((data, offsets), copy=False, shape=shape)
+    return Dia((data, offsets), copy=False, shape=shape)
 
 
 one_element = _Dispatcher(one_element_dense, name='one_element',
@@ -127,5 +127,5 @@ def one_element_diag(shape, position, value=1.0):
 one_element.add_specialisations([
     (CSR, one_element_csr),
     (Dense, one_element_dense),
-    (Diag, one_element_diag),
+    (Dia, one_element_dia),
 ], _defer=True)
diff --git a/qutip/core/data/matmul.pxd b/qutip/core/data/matmul.pxd
index bdb7c362e3..2df6e7bf25 100644
--- a/qutip/core/data/matmul.pxd
+++ b/qutip/core/data/matmul.pxd
@@ -2,17 +2,17 @@
 
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
+from qutip.core.data.dia cimport Dia
 from qutip.core.data.base cimport Data
 
 cpdef CSR matmul_csr(CSR left, CSR right, double complex scale=*, CSR out=*)
 cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=*, Dense out=*)
 cpdef Dense matmul_csr_dense_dense(CSR left, Dense right, double complex scale=*, Dense out=*)
-cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=*)
-cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=*, Dense out=*)
+cpdef Dia matmul_dia(Dia left, Dia right, double complex scale=*)
+cpdef Dense matmul_dia_dense_dense(Dia left, Dense right, double complex scale=*, Dense out=*)
 cdef Dense matmul_data_dense(Data left, Dense right)
 cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out)
 
 cpdef Dense multiply_dense(Dense left, Dense right)
 cpdef CSR multiply_csr(CSR left, CSR right)
-cpdef Diag multiply_diag(Diag left, Diag right)
+cpdef Dia multiply_dia(Dia left, Dia right)
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index f5da40ba0c..1fc39c85c3 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -20,8 +20,8 @@ from qutip.core.data.base import idxint_dtype
 from qutip.core.data.base cimport idxint, Data
 from qutip.core.data.dense cimport Dense
 from qutip.core.data.csr cimport CSR
-from qutip.core.data.dia cimport Diag
-from qutip.core.data.tidyup cimport tidyup_diag
+from qutip.core.data.dia cimport Dia
+from qutip.core.data.tidyup cimport tidyup_dia
 from qutip.core.data cimport csr, dense, dia
 from qutip.core.data.add cimport iadd_dense, add_csr
 from qutip.core.data.mul cimport imul_dense
@@ -49,9 +49,9 @@ cdef extern from "src/matmul_diag_vector.hpp" nogil:
 
 
 __all__ = [
-    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_diag',
-    'matmul_csr_dense_dense', 'matmul_diag_dense_dense',
-    'multiply', 'multiply_csr', 'multiply_dense', 'multiply_diag',
+    'matmul', 'matmul_csr', 'matmul_dense', 'matmul_dia',
+    'matmul_csr_dense_dense', 'matmul_dia_dense_dense',
+    'multiply', 'multiply_csr', 'multiply_dense', 'multiply_dia',
 ]
 
 
@@ -321,7 +321,7 @@ cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense
 
 
 #TODO: optimize: not rely on numpy for unique offsets.
-cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=1):
+cpdef Dia matmul_dia(Dia left, Dia right, double complex scale=1):
     _check_shape(left, right, None)
     # We could probably do faster than this...
     npoffsets = np.unique(np.add.outer(left.as_scipy().offsets, right.as_scipy().offsets))
@@ -358,10 +358,10 @@ cpdef Diag matmul_diag(Diag left, Diag right, double complex scale=1):
                 * left.data[diag_left * left.shape[1] + col - right.offsets[diag_right]]
                 * right.data[diag_right * right.shape[1] + col]
               )
-    return Diag((npdata, npoffsets), shape=(left.shape[0], right.shape[1]), copy=False)
+    return Dia((npdata, npoffsets), shape=(left.shape[0], right.shape[1]), copy=False)
 
 
-cpdef Dense matmul_diag_dense_dense(Diag left, Dense right, double complex scale=1, Dense out=None):
+cpdef Dense matmul_dia_dense_dense(Dia left, Dense right, double complex scale=1, Dense out=None):
     _check_shape(left, right, out)
     cdef Dense tmp
     if out is not None and scale == 1.:
@@ -490,7 +490,7 @@ cpdef CSR multiply_csr(CSR left, CSR right):
     return out
 
 
-cpdef Diag multiply_diag(Diag left, Diag right):
+cpdef Dia multiply_dia(Dia left, Dia right):
     if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
         raise ValueError(
             "incompatible matrix shapes "
@@ -500,7 +500,7 @@ cpdef Diag multiply_diag(Diag left, Diag right):
         )
     cdef idxint diag_left=0, diag_right=0, out_diag=0, col
     cdef bint sorted=True
-    cdef Diag out = dia.empty(left.shape[0], left.shape[1], min(left.num_diag, right.num_diag))
+    cdef Dia out = dia.empty(left.shape[0], left.shape[1], min(left.num_diag, right.num_diag))
 
     with nogil:
       for diag_left in range(1, left.num_diag):
@@ -550,7 +550,7 @@ cpdef Diag multiply_diag(Diag left, Diag right):
       out.num_diag = out_diag
 
     if settings.core['auto_tidyup']:
-        tidyup_diag(out, settings.core['auto_tidyup_atol'], True)
+        tidyup_dia(out, settings.core['auto_tidyup_atol'], True)
     return out
 
 
@@ -612,8 +612,8 @@ matmul.add_specialisations([
     (CSR, CSR, CSR, matmul_csr),
     (CSR, Dense, Dense, matmul_csr_dense_dense),
     (Dense, Dense, Dense, matmul_dense),
-    (Diag, Diag, Diag, matmul_diag),
-    (Diag, Dense, Dense, matmul_diag_dense_dense),
+    (Dia, Dia, Dia, matmul_dia),
+    (Dia, Dense, Dense, matmul_dia_dense_dense),
 ], _defer=True)
 
 
@@ -632,7 +632,7 @@ multiply.__doc__ =\
 multiply.add_specialisations([
     (CSR, CSR, CSR, multiply_csr),
     (Dense, Dense, Dense, multiply_dense),
-    (Diag, Diag, Diag, multiply_diag),
+    (Dia, Dia, Dia, multiply_dia),
 ], _defer=True)
 
 
@@ -645,8 +645,8 @@ cdef Dense matmul_data_dense(Data left, Dense right):
         out = matmul_csr_dense_dense(left, right)
     elif type(left) is Dense:
         out = matmul_dense(left, right)
-    elif type(left) is Diag:
-        out = matmul_diag_dense_dense(left, right)
+    elif type(left) is Dia:
+        out = matmul_dia_dense_dense(left, right)
     else:
         out = matmul(left, right)
     return out
@@ -655,8 +655,8 @@ cdef Dense matmul_data_dense(Data left, Dense right):
 cdef void imatmul_data_dense(Data left, Dense right, double complex scale, Dense out):
     if type(left) is CSR:
         matmul_csr_dense_dense(left, right, scale, out)
-    elif type(left) is Diag:
-        matmul_diag_dense_dense(left, right, scale, out)
+    elif type(left) is Dia:
+        matmul_dia_dense_dense(left, right, scale, out)
     elif type(left) is Dense:
         matmul_dense(left, right, scale, out)
     else:
diff --git a/qutip/core/data/mul.pxd b/qutip/core/data/mul.pxd
index 2507a74edd..6e7b560eef 100644
--- a/qutip/core/data/mul.pxd
+++ b/qutip/core/data/mul.pxd
@@ -1,6 +1,6 @@
 #cython: language_level=3
 
-from qutip.core.data cimport CSR, Dense, Data, Diag
+from qutip.core.data cimport CSR, Dense, Data, Dia
 
 cpdef CSR imul_csr(CSR matrix, double complex value)
 cpdef CSR mul_csr(CSR matrix, double complex value)
@@ -10,8 +10,8 @@ cpdef Dense imul_dense(Dense matrix, double complex value)
 cpdef Dense mul_dense(Dense matrix, double complex value)
 cpdef Dense neg_dense(Dense matrix)
 
-cpdef Diag imul_diag(Diag matrix, double complex value)
-cpdef Diag mul_diag(Diag matrix, double complex value)
-cpdef Diag neg_diag(Diag matrix)
+cpdef Dia imul_dia(Dia matrix, double complex value)
+cpdef Dia mul_dia(Dia matrix, double complex value)
+cpdef Dia neg_dia(Dia matrix)
 
 cpdef Data imul_data(Data matrix, double complex value)
diff --git a/qutip/core/data/mul.pyx b/qutip/core/data/mul.pyx
index 4cc9663be6..d81e68882c 100644
--- a/qutip/core/data/mul.pyx
+++ b/qutip/core/data/mul.pyx
@@ -1,13 +1,13 @@
 #cython: language_level=3
 #cython: boundscheck=False, wrapround=False, initializedcheck=False
 
-from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data, Diag, dia
+from qutip.core.data cimport idxint, csr, CSR, dense, Dense, Data, Dia, dia
 from scipy.linalg.cython_blas cimport zscal
 
 __all__ = [
-    'mul', 'mul_csr', 'mul_dense', 'mul_diag',
-    'imul', 'imul_csr', 'imul_dense', 'imul_diag', 'imul_data',
-    'neg', 'neg_csr', 'neg_dense', 'neg_diag',
+    'mul', 'mul_csr', 'mul_dense', 'mul_dia',
+    'imul', 'imul_csr', 'imul_dense', 'imul_dia', 'imul_data',
+    'neg', 'neg_csr', 'neg_dense', 'neg_dia',
 ]
 
 
@@ -39,18 +39,18 @@ cpdef CSR neg_csr(CSR matrix):
     return out
 
 
-cpdef Diag imul_diag(Diag matrix, double complex value):
-    """Multiply this Diag `matrix` by a complex scalar `value`."""
+cpdef Dia imul_dia(Dia matrix, double complex value):
+    """Multiply this Dia `matrix` by a complex scalar `value`."""
     cdef idxint l = matrix.num_diag * matrix.shape[1]
     cdef int ONE=1
     zscal(&l, &value, matrix.data, &ONE)
     return matrix
 
-cpdef Diag mul_diag(Diag matrix, double complex value):
-    """Multiply this Diag `matrix` by a complex scalar `value`."""
+cpdef Dia mul_dia(Dia matrix, double complex value):
+    """Multiply this Dia `matrix` by a complex scalar `value`."""
     if value == 0:
         return dia.zeros(matrix.shape[0], matrix.shape[1])
-    cdef Diag out = dia.empty_like(matrix)
+    cdef Dia out = dia.empty_like(matrix)
     cdef idxint ptr, diag, l = matrix.num_diag * matrix.shape[1]
     with nogil:
         for ptr in range(l):
@@ -60,9 +60,9 @@ cpdef Diag mul_diag(Diag matrix, double complex value):
         out.num_diag = matrix.num_diag
     return out
 
-cpdef Diag neg_diag(Diag matrix):
-    """Unary negation of this Diag `matrix`.  Return a new object."""
-    cdef Diag out = matrix.copy()
+cpdef Dia neg_dia(Dia matrix):
+    """Unary negation of this Dia `matrix`.  Return a new object."""
+    cdef Dia out = matrix.copy()
     cdef idxint ptr, l = matrix.num_diag * matrix.shape[1]
     with nogil:
         for ptr in range(l):
@@ -114,7 +114,7 @@ mul.__doc__ =\
     """Multiply a matrix element-wise by a scalar."""
 mul.add_specialisations([
     (CSR, CSR, mul_csr),
-    (Diag, Diag, mul_diag),
+    (Dia, Dia, mul_dia),
     (Dense, Dense, mul_dense),
 ], _defer=True)
 
@@ -135,7 +135,7 @@ imul.__doc__ =\
     """Multiply inplace a matrix element-wise by a scalar."""
 imul.add_specialisations([
     (CSR, CSR, imul_csr),
-    (Diag, Diag, imul_diag),
+    (Dia, Dia, imul_dia),
     (Dense, Dense, imul_dense),
 ], _defer=True)
 
@@ -152,7 +152,7 @@ neg.__doc__ =\
     """Unary element-wise negation of a matrix."""
 neg.add_specialisations([
     (CSR, CSR, neg_csr),
-    (Diag, Diag, neg_diag),
+    (Dia, Dia, neg_dia),
     (Dense, Dense, neg_dense),
 ], _defer=True)
 
@@ -164,7 +164,7 @@ cpdef Data imul_data(Data matrix, double complex value):
         return imul_csr(matrix, value)
     elif type(matrix) is Dense:
         return imul_dense(matrix, value)
-    elif type(matrix) is Diag:
-        return imul_diag(matrix, value)
+    elif type(matrix) is Dia:
+        return imul_dia(matrix, value)
     else:
         return imul(matrix, value)
diff --git a/qutip/core/data/norm.pxd b/qutip/core/data/norm.pxd
index 4b4e677d68..eaf91a152c 100644
--- a/qutip/core/data/norm.pxd
+++ b/qutip/core/data/norm.pxd
@@ -1,7 +1,7 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from qutip.core.data cimport CSR, Dense, Data, Diag
+from qutip.core.data cimport CSR, Dense, Data, Dia
 
 cpdef double one_csr(CSR matrix) except -1
 cpdef double trace_csr(CSR matrix) except -1
@@ -12,10 +12,10 @@ cpdef double l2_csr(CSR matrix) nogil except -1
 cpdef double frobenius_dense(Dense matrix) nogil
 cpdef double l2_dense(Dense matrix) nogil except -1
 
-cpdef double one_diag(Diag matrix) except -1
-cpdef double max_diag(Diag matrix) nogil
-cpdef double frobenius_diag(Diag matrix) nogil
-cpdef double l2_diag(Diag matrix) except -1 nogil
+cpdef double one_dia(Dia matrix) except -1
+cpdef double max_dia(Dia matrix) nogil
+cpdef double frobenius_dia(Dia matrix) nogil
+cpdef double l2_dia(Dia matrix) except -1 nogil
 
 cpdef double frobenius_data(Data state)
 
diff --git a/qutip/core/data/norm.pyx b/qutip/core/data/norm.pyx
index 3d91095c0d..c6f3ad2e5b 100644
--- a/qutip/core/data/norm.pyx
+++ b/qutip/core/data/norm.pyx
@@ -9,7 +9,7 @@ from scipy.linalg cimport cython_blas as blas
 import scipy
 import numpy as np
 
-from qutip.core.data cimport CSR, Dense, csr, Data, Diag
+from qutip.core.data cimport CSR, Dense, csr, Data, Dia
 
 from qutip.core.data.adjoint cimport adjoint_csr, adjoint_dense
 from qutip.core.data.matmul cimport matmul_csr
@@ -134,7 +134,7 @@ cpdef double l2_dense(Dense matrix) nogil except -1:
         raise ValueError("L2 norm is only defined on vectors")
     return frobenius_dense(matrix)
 
-cpdef double frobenius_diag(Diag matrix) nogil:
+cpdef double frobenius_dia(Dia matrix) nogil:
     cdef int offset, diag, start, end, col=1
     cdef double total=0, cur
     for diag in range(matrix.num_diag):
@@ -145,12 +145,12 @@ cpdef double frobenius_diag(Diag matrix) nogil:
             total += abssq(matrix.data[diag * matrix.shape[1] + col])
     return math.sqrt(total)
 
-cpdef double l2_diag(Diag matrix) except -1 nogil:
+cpdef double l2_dia(Dia matrix) except -1 nogil:
     if matrix.shape[0] != 1 and matrix.shape[1] != 1:
         raise ValueError("L2 norm is only defined on vectors")
-    return frobenius_diag(matrix)
+    return frobenius_dia(matrix)
 
-cpdef double max_diag(Diag matrix) nogil:
+cpdef double max_dia(Dia matrix) nogil:
     cdef int offset, diag, start, end, col=1
     cdef double total=0, cur
     for diag in range(matrix.num_diag):
@@ -162,7 +162,7 @@ cpdef double max_diag(Diag matrix) nogil:
             total = cur if cur > total else total
     return math.sqrt(total)
 
-cpdef double one_diag(Diag matrix) except -1:
+cpdef double one_dia(Dia matrix) except -1:
     cdef int offset, diag, start, end, col=1
     cols_one = np.zeros(matrix.shape[1], dtype=float)
     for diag in range(matrix.num_diag):
@@ -194,7 +194,7 @@ l2.__doc__ =\
     """
 l2.add_specialisations([
     (Dense, l2_dense),
-    (Diag, l2_diag),
+    (Dia, l2_dia),
     (CSR, l2_csr),
 ], _defer=True)
 
@@ -212,7 +212,7 @@ frobenius.__doc__ =\
     """
 frobenius.add_specialisations([
     (Dense, frobenius_dense),
-    (Diag, frobenius_diag),
+    (Dia, frobenius_dia),
     (CSR, frobenius_csr),
 ], _defer=True)
 
@@ -225,7 +225,7 @@ max.__doc__ =\
     """
 max.add_specialisations([
     (Dense, max_dense),
-    (Diag, max_diag),
+    (Dia, max_dia),
     (CSR, max_csr),
 ], _defer=True)
 
@@ -238,7 +238,7 @@ one.__doc__ =\
     """
 one.add_specialisations([
     (Dense, one_dense),
-    (Diag, one_diag),
+    (Dia, one_dia),
     (CSR, one_csr),
 ], _defer=True)
 
diff --git a/qutip/core/data/pow.pyx b/qutip/core/data/pow.pyx
index f5f05f5bdd..7fc6d4568e 100644
--- a/qutip/core/data/pow.pyx
+++ b/qutip/core/data/pow.pyx
@@ -6,12 +6,12 @@ cimport cython
 from qutip.core.data cimport csr, dense, dia
 from qutip.core.data.csr cimport CSR
 from qutip.core.data.dense cimport Dense
-from qutip.core.data.dia cimport Diag
-from qutip.core.data.matmul cimport matmul_csr, matmul_diag
+from qutip.core.data.dia cimport Dia
+from qutip.core.data.matmul cimport matmul_csr, matmul_dia
 import numpy as np
 
 __all__ = [
-    'pow', 'pow_csr', 'pow_dense', 'pow_diag',
+    'pow', 'pow_csr', 'pow_dense', 'pow_dia',
 ]
 
 
@@ -44,7 +44,7 @@ cpdef CSR pow_csr(CSR matrix, unsigned long long n):
 
 @cython.nonecheck(False)
 @cython.cdivision(True)
-cpdef Diag pow_diag(Diag matrix, unsigned long long n):
+cpdef Dia pow_dia(Dia matrix, unsigned long long n):
     if matrix.shape[0] != matrix.shape[1]:
         raise ValueError("matrix power only works with square matrices")
     if n == 0:
@@ -58,13 +58,13 @@ cpdef Diag pow_diag(Diag matrix, unsigned long long n):
     # We don't have to do matrix.copy() or pow.copy() here, because we've
     # guaranteed that we won't be returning without at least one matrix
     # multiplcation, which will allocate a new matrix.
-    cdef Diag pow = matrix
-    cdef Diag out = pow if n & 1 else None
+    cdef Dia pow = matrix
+    cdef Dia out = pow if n & 1 else None
     n >>= 1
     while n:
-        pow = matmul_diag(pow, pow)
+        pow = matmul_dia(pow, pow)
         if n & 1:
-            out = pow if out is None else matmul_diag(out, pow)
+            out = pow if out is None else matmul_dia(out, pow)
         n >>= 1
     return out
 
@@ -109,7 +109,7 @@ pow.__doc__ =\
 pow.add_specialisations([
     (CSR, CSR, pow_csr),
     (Dense, Dense, pow_dense),
-    (Diag, Diag, pow_diag),
+    (Dia, Dia, pow_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/project.pyx b/qutip/core/data/project.pyx
index 4b096f8c69..45fa7ac956 100644
--- a/qutip/core/data/project.pyx
+++ b/qutip/core/data/project.pyx
@@ -4,14 +4,14 @@
 from libc.string cimport memcpy, memset
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, Dense, dia, Diag
+from qutip.core.data cimport csr, dense, Dense, dia, Dia
 from qutip.core.data.csr cimport CSR
 
 cdef extern from "<complex>" namespace "std" nogil:
     double complex conj(double complex x)
 
 __all__ = [
-    'project', 'project_csr', 'project_dense', 'project_diag',
+    'project', 'project_csr', 'project_dense', 'project_dia',
 ]
 
 
@@ -115,13 +115,13 @@ cpdef Dense project_dense(Dense state):
     return out
 
 
-cpdef Diag project_diag(Diag state):
+cpdef Dia project_dia(Dia state):
     """
     Calculate the projection |state><state|.  The shape of `state` will be used
     to determine if it has been supplied as a ket or a bra.  The result of this
     function will be identical is passed `state` or `adjoint(state)`.
     """
-    cdef Diag out
+    cdef Dia out
     cdef size_t size, i, j, k, num_diag=0, max_diag
     if state.shape[1] == 1:
         size = state.shape[0]
@@ -196,7 +196,7 @@ project.__doc__ =\
     """
 project.add_specialisations([
     (CSR, CSR, project_csr),
-    (Diag, Diag, project_diag),
+    (Dia, Dia, project_dia),
     (Dense, Dense, project_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/properties.pxd b/qutip/core/data/properties.pxd
index 57424d9638..f7913cae67 100644
--- a/qutip/core/data/properties.pxd
+++ b/qutip/core/data/properties.pxd
@@ -1,8 +1,12 @@
 #cython: language_level=3
 
-from qutip.core.data cimport CSR, Dense
+from qutip.core.data cimport CSR, Dense, Dia
 
 cpdef bint isherm_csr(CSR matrix, double tol=*)
 cpdef bint isdiag_csr(CSR matrix) nogil
 cpdef bint iszero_csr(CSR matrix, double tol=*) nogil
 cpdef bint iszero_dense(Dense matrix, double tol=*) nogil
+
+cpdef bint isherm_dia(Dia matrix, double tol=*) nogil
+cpdef bint isdiag_dia(Dia matrix, double tol=*) nogil
+cpdef bint iszero_dia(Dia matrix, double tol=*) nogil
diff --git a/qutip/core/data/properties.pyx b/qutip/core/data/properties.pyx
index 849673737c..1a6e25d35b 100644
--- a/qutip/core/data/properties.pyx
+++ b/qutip/core/data/properties.pyx
@@ -7,7 +7,7 @@ from cpython cimport mem
 from qutip.settings import settings
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense, Diag
+from qutip.core.data cimport csr, dense, CSR, Dense, Dia
 from qutip.core.data.adjoint cimport transpose_csr
 
 cdef extern from *:
@@ -15,9 +15,9 @@ cdef extern from *:
     void *PyMem_Calloc(size_t nelem, size_t elsize)
 
 __all__ = [
-    'isherm', 'isherm_csr', 'isherm_dense', 'isherm_diag',
-    'isdiag', 'isdiag_csr', 'isdiag_dense', 'isdiag_diag',
-    'iszero', 'iszero_csr', 'iszero_dense', 'iszero_diag',
+    'isherm', 'isherm_csr', 'isherm_dense', 'isherm_dia',
+    'isdiag', 'isdiag_csr', 'isdiag_dense', 'isdiag_dia',
+    'iszero', 'iszero_csr', 'iszero_dense', 'iszero_dia',
 ]
 
 cdef inline bint _conj_feq(double complex a, double complex b, double tol) nogil:
@@ -145,7 +145,7 @@ cpdef bint isherm_csr(CSR matrix, double tol=-1):
         mem.PyMem_Free(out_row_index)
 
 
-cpdef bint isherm_diag(Diag matrix, double tol=-1) nogil:
+cpdef bint isherm_dia(Dia matrix, double tol=-1) nogil:
     cdef double complex val, valT
     cdef size_t diag, other_diag, col, start, end, other_start
     if tol < 0:
@@ -222,7 +222,7 @@ cpdef bint isherm_dense(Dense matrix, double tol=-1):
     return True
 
 
-cpdef bint isdiag_diag(Diag matrix, double tol=-1) nogil:
+cpdef bint isdiag_dia(Dia matrix, double tol=-1) nogil:
     cdef size_t diag, start, end, col
     if tol < 0:
         with gil:
@@ -261,7 +261,7 @@ cpdef bint isdiag_dense(Dense matrix) nogil:
     return True
 
 
-cpdef bint iszero_diag(Diag matrix, double tol=-1) nogil:
+cpdef bint iszero_dia(Dia matrix, double tol=-1) nogil:
     cdef size_t diag, start, end, col
     if tol < 0:
         with gil:
@@ -334,7 +334,7 @@ isherm.__doc__ =\
     """
 isherm.add_specialisations([
     (Dense, isherm_dense),
-    (Diag, isherm_diag),
+    (Dia, isherm_dia),
     (CSR, isherm_csr),
 ], _defer=True)
 
@@ -358,7 +358,7 @@ isdiag.__doc__ =\
     """
 isdiag.add_specialisations([
     (Dense, isdiag_dense),
-    (Diag, isdiag_diag),
+    (Dia, isdiag_dia),
     (CSR, isdiag_csr),
 ], _defer=True)
 
@@ -393,7 +393,7 @@ iszero.__doc__ =\
     """
 iszero.add_specialisations([
     (CSR, iszero_csr),
-    (Diag, iszero_diag),
+    (Dia, iszero_dia),
     (Dense, iszero_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 31ae79b3d2..3b124af448 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -8,14 +8,14 @@ import numpy as np
 cimport numpy as cnp
 cimport cython
 
-from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data, Diag, dia
+from qutip.core.data cimport csr, dense, idxint, CSR, Dense, Data, Dia, dia
 from qutip.core.data.base import idxint_dtype
 from qutip.settings import settings
 
 cnp.import_array()
 
 __all__ = [
-    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense', 'ptrace_diag',
+    'ptrace', 'ptrace_csr', 'ptrace_dense', 'ptrace_csr_dense', 'ptrace_dia',
 ]
 
 cdef tuple _parse_inputs(object dims, object sel, tuple shape):
@@ -123,7 +123,7 @@ cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
 
 
 #TODO: cythonize
-def ptrace_diag(matrix, dims, sel):
+def ptrace_dia(matrix, dims, sel):
     if len(sel) == len(dims):
         return matrix.copy()
     dims, sel = _parse_inputs(dims, sel, matrix.shape)
@@ -149,8 +149,8 @@ def ptrace_diag(matrix, dims, sel):
         return dia.zeros(size, size)
     offsets = np.array(list(data.keys()), dtype=idxint_dtype)
     data = np.array(list(data.values()), dtype=complex)
-    out = Diag((data, offsets), shape=(size, size), copy=False)
-    out = dia.clean_diag(out, True)
+    out = Dia((data, offsets), shape=(size, size), copy=False)
+    out = dia.clean_dia(out, True)
     return out
 
 
@@ -244,7 +244,7 @@ ptrace.add_specialisations([
     (CSR, CSR, ptrace_csr),
     (CSR, Dense, ptrace_csr_dense),
     (Dense, Dense, ptrace_dense),
-    (Diag, Diag, ptrace_diag),
+    (Dia, Dia, ptrace_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/reshape.pxd b/qutip/core/data/reshape.pxd
index f3d817a533..e8118b3495 100644
--- a/qutip/core/data/reshape.pxd
+++ b/qutip/core/data/reshape.pxd
@@ -1,15 +1,15 @@
 #cython: language_level=3
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport CSR, Dense, Diag
+from qutip.core.data cimport CSR, Dense, Dia
 
 cpdef CSR reshape_csr(CSR matrix, idxint n_rows_out, idxint n_cols_out)
 cpdef CSR column_stack_csr(CSR matrix)
 cpdef CSR column_unstack_csr(CSR matrix, idxint rows)
 
-cpdef Diag reshape_diag(Diag matrix, idxint n_rows_out, idxint n_cols_out)
-cpdef Diag column_stack_diag(Diag matrix)
-cpdef Diag column_unstack_diag(Diag matrix, idxint rows)
+cpdef Dia reshape_dia(Dia matrix, idxint n_rows_out, idxint n_cols_out)
+cpdef Dia column_stack_dia(Dia matrix)
+cpdef Dia column_unstack_dia(Dia matrix, idxint rows)
 
 cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out)
 cpdef Dense column_stack_dense(Dense matrix, bint inplace=*)
diff --git a/qutip/core/data/reshape.pyx b/qutip/core/data/reshape.pyx
index 8e765d2340..4b9683ac60 100644
--- a/qutip/core/data/reshape.pyx
+++ b/qutip/core/data/reshape.pyx
@@ -8,13 +8,13 @@ cimport cython
 import warnings
 
 from qutip.core.data.base cimport idxint
-from qutip.core.data cimport csr, dense, CSR, Dense, Data, Diag
+from qutip.core.data cimport csr, dense, CSR, Dense, Data, Dia
 
 __all__ = [
-    'reshape', 'reshape_csr', 'reshape_dense', 'reshape_diag',
-    'column_stack', 'column_stack_csr', 'column_stack_dense', 'column_stack_diag',
-    'column_unstack', 'column_unstack_csr', 'column_unstack_dense', 'column_unstack_diag',
-    'split_columns', 'split_columns_dense', 'split_columns_csr', 'split_columns_diag',
+    'reshape', 'reshape_csr', 'reshape_dense', 'reshape_dia',
+    'column_stack', 'column_stack_csr', 'column_stack_dense', 'column_stack_dia',
+    'column_unstack', 'column_unstack_csr', 'column_unstack_dense', 'column_unstack_dia',
+    'split_columns', 'split_columns_dense', 'split_columns_csr', 'split_columns_dia',
 ]
 
 
@@ -74,10 +74,10 @@ cpdef Dense reshape_dense(Dense matrix, idxint n_rows_out, idxint n_cols_out):
     return out
 
 
-cpdef Diag reshape_diag(Diag matrix, idxint n_rows_out, idxint n_cols_out):
+cpdef Dia reshape_dia(Dia matrix, idxint n_rows_out, idxint n_cols_out):
     _reshape_check_input(matrix, n_rows_out, n_cols_out)
     # Once reshaped, diagonals are no longer ligned up.
-    return Diag(
+    return Dia(
         matrix.as_scipy().reshape((n_rows_out, n_cols_out)).todia(), copy=False
     )
 
@@ -102,10 +102,10 @@ cpdef Dense column_stack_dense(Dense matrix, bint inplace=False):
     return reshape_dense(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
 
 
-cpdef Diag column_stack_diag(Diag matrix):
+cpdef Dia column_stack_dia(Dia matrix):
     if matrix.shape[1] == 1:
         return matrix.copy()
-    return reshape_diag(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
+    return reshape_dia(matrix.transpose(), matrix.shape[0]*matrix.shape[1], 1)
 
 
 cdef void _column_unstack_check_shape(Data matrix, idxint rows) except *:
@@ -136,10 +136,10 @@ cpdef Dense column_unstack_dense(Dense matrix, idxint rows, bint inplace=False):
     return out
 
 
-cpdef Diag column_unstack_diag(Diag matrix, idxint rows):
+cpdef Dia column_unstack_dia(Dia matrix, idxint rows):
     _column_unstack_check_shape(matrix, rows)
     cdef idxint cols = matrix.shape[0] // rows
-    return reshape_diag(matrix, cols, rows).transpose()
+    return reshape_dia(matrix, cols, rows).transpose()
 
 
 cpdef list split_columns_dense(Dense matrix, copy=True):
@@ -152,7 +152,7 @@ cpdef list split_columns_csr(CSR matrix, copy=True):
             for k in range(matrix.shape[1])]
 
 
-cpdef list split_columns_diag(Diag matrix, copy=None):
+cpdef list split_columns_dia(Dia matrix, copy=None):
     as_array = matrix.to_array()
     return [Dense(as_array[:, k], copy=False) for k in range(matrix.shape[1])]
 
@@ -187,7 +187,7 @@ reshape.__doc__ =\
 reshape.add_specialisations([
     (CSR, CSR, reshape_csr),
     (Dense, Dense, reshape_dense),
-    (Diag, Diag, reshape_diag),
+    (Dia, Dia, reshape_dia),
 ], _defer=True)
 
 
@@ -232,7 +232,7 @@ column_stack.__doc__ =\
 column_stack.add_specialisations([
     (CSR, CSR, column_stack_csr),
     (Dense, Dense, column_stack_dense),
-    (Diag, Diag, column_stack_diag),
+    (Dia, Dia, column_stack_dia),
 ], _defer=True)
 
 column_unstack = _Dispatcher(
@@ -273,7 +273,7 @@ column_unstack.__doc__ =\
 column_unstack.add_specialisations([
     (CSR, CSR, column_unstack_csr),
     (Dense, Dense, column_unstack_dense),
-    (Diag, Diag, column_unstack_diag),
+    (Dia, Dia, column_unstack_dia),
 ], _defer=True)
 
 
@@ -310,7 +310,7 @@ split_columns.__doc__ =\
 split_columns.add_specialisations([
     (CSR, split_columns_csr),
     (Dense, split_columns_dense),
-    (Diag, split_columns_diag),
+    (Dia, split_columns_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/solve.py b/qutip/core/data/solve.py
index a13edcb09b..31fc6c9659 100644
--- a/qutip/core/data/solve.py
+++ b/qutip/core/data/solve.py
@@ -1,4 +1,4 @@
-from qutip.core.data import CSR, Data, csr, Dense, Diag
+from qutip.core.data import CSR, Data, csr, Dense, Dia
 import qutip.core.data as _data
 import scipy.sparse.linalg as splinalg
 import numpy as np
@@ -12,7 +12,7 @@
     mkl_spsolve = None
 
 
-__all__ = ["solve_csr_dense", "solve_diag_dense", "solve_dense", "solve"]
+__all__ = ["solve_csr_dense", "solve_dia_dense", "solve_dense", "solve"]
 
 
 def _splu(A, B, **kwargs):
@@ -20,7 +20,7 @@ def _splu(A, B, **kwargs):
     return lu.solve(B)
 
 
-def solve_csr_dense(matrix: Union[CSR, Diag], target: Dense, method=None,
+def solve_csr_dense(matrix: Union[CSR, Dia], target: Dense, method=None,
                     options: dict={}) -> Dense:
     """
     Solve ``Ax=b`` for ``x``.
@@ -28,7 +28,7 @@ def solve_csr_dense(matrix: Union[CSR, Diag], target: Dense, method=None,
     Parameters:
     -----------
 
-    matrix : CSR, Diag
+    matrix : CSR, Dia
         The matrix ``A``.
 
     target : Data
@@ -80,7 +80,7 @@ def solve_csr_dense(matrix: Union[CSR, Diag], target: Dense, method=None,
 
     options = options.copy()
     M = matrix.as_scipy()
-    if options.pop("csc", False) or isinstance(matrix, Diag):
+    if options.pop("csc", False) or isinstance(matrix, Dia):
         M = M.tocsc()
 
     with warnings.catch_warnings():
@@ -113,7 +113,7 @@ def solve_csr_dense(matrix: Union[CSR, Diag], target: Dense, method=None,
     return Dense(out, copy=False)
 
 
-solve_diag_dense = solve_csr_dense
+solve_dia_dense = solve_csr_dense
 
 
 def solve_dense(matrix: Dense, target: Data, method=None,
@@ -222,7 +222,7 @@ def solve_dense(matrix: Dense, target: Data, method=None,
 """
 solve.add_specialisations([
     (CSR, Dense, Dense, solve_csr_dense),
-    (Diag, Dense, Dense, solve_diag_dense),
+    (Dia, Dense, Dense, solve_dia_dense),
     (Dense, Dense, Dense, solve_dense),
 ], _defer=True)
 
diff --git a/qutip/core/data/tidyup.pxd b/qutip/core/data/tidyup.pxd
index 63b3ebdf54..c1c6acc264 100644
--- a/qutip/core/data/tidyup.pxd
+++ b/qutip/core/data/tidyup.pxd
@@ -1,8 +1,8 @@
 #cython: language_level=3
 #cython: boundscheck=False, wraparound=False, initializedcheck=False
 
-from qutip.core.data cimport CSR, Dense, Diag
+from qutip.core.data cimport CSR, Dense, Dia
 
 cpdef CSR tidyup_csr(CSR matrix, double tol, bint inplace=*)
 cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=*)
-cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=*)
+cpdef Dia tidyup_dia(Dia matrix, double tol, bint inplace=*)
diff --git a/qutip/core/data/tidyup.pyx b/qutip/core/data/tidyup.pyx
index e72e9671a7..ee9d7c8dc7 100644
--- a/qutip/core/data/tidyup.pyx
+++ b/qutip/core/data/tidyup.pyx
@@ -6,14 +6,14 @@ from libc.math cimport fabs
 cimport numpy as cnp
 from scipy.linalg cimport cython_blas as blas
 
-from qutip.core.data cimport csr, dense, CSR, Dense, dia, Diag, base
+from qutip.core.data cimport csr, dense, CSR, Dense, dia, Dia, base
 
 cdef extern from "<complex>" namespace "std" nogil:
     # abs is templated such that Cython treats std::abs as complex->complex
     double abs(double complex x)
 
 __all__ = [
-    'tidyup', 'tidyup_csr', 'tidyup_dense', 'tidyup_diag',
+    'tidyup', 'tidyup_csr', 'tidyup_dense', 'tidyup_dia',
 ]
 
 
@@ -56,8 +56,8 @@ cpdef Dense tidyup_dense(Dense matrix, double tol, bint inplace=True):
     return out
 
 
-cpdef Diag tidyup_diag(Diag matrix, double tol, bint inplace=True):
-    cdef Diag out = matrix if inplace else matrix.copy()
+cpdef Dia tidyup_dia(Dia matrix, double tol, bint inplace=True):
+    cdef Dia out = matrix if inplace else matrix.copy()
     cdef base.idxint diag=0, new_diag=0, ONE=1, start, end, col
     cdef bint re, im, has_data
     cdef double complex value
@@ -143,7 +143,7 @@ tidyup.__doc__ =\
 tidyup.add_specialisations([
     (CSR, tidyup_csr),
     (Dense, tidyup_dense),
-    (Diag, tidyup_diag),
+    (Dia, tidyup_dia),
 ], _defer=True)
 
 del _inspect, _Dispatcher
diff --git a/qutip/core/data/trace.pxd b/qutip/core/data/trace.pxd
index 25532dfc70..c86239a7a7 100644
--- a/qutip/core/data/trace.pxd
+++ b/qutip/core/data/trace.pxd
@@ -1,11 +1,11 @@
 #cython: language_level=3
 
-from qutip.core.data cimport CSR, Dense, Diag
+from qutip.core.data cimport CSR, Dense, Dia
 
 cpdef double complex trace_csr(CSR matrix) nogil except *
 cpdef double complex trace_dense(Dense matrix) nogil except *
-cpdef double complex trace_diag(Diag matrix) except * nogil
+cpdef double complex trace_dia(Dia matrix) except * nogil
 
 cpdef double complex trace_oper_ket_csr(CSR matrix) nogil except *
 cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *
-cpdef double complex trace_oper_ket_diag(Diag matrix) except * nogil
+cpdef double complex trace_oper_ket_dia(Dia matrix) except * nogil
diff --git a/qutip/core/data/trace.pyx b/qutip/core/data/trace.pyx
index 246919308d..6c40ea9b81 100644
--- a/qutip/core/data/trace.pyx
+++ b/qutip/core/data/trace.pyx
@@ -4,12 +4,12 @@
 cimport cython
 from libc.math cimport sqrt
 
-from qutip.core.data cimport Data, CSR, Dense, Diag
+from qutip.core.data cimport Data, CSR, Dense, Dia
 from qutip.core.data cimport base
 
 __all__ = [
-    'trace', 'trace_csr', 'trace_dense', 'trace_diag',
-    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense', 'trace_oper_ket_diag',
+    'trace', 'trace_csr', 'trace_dense', 'trace_dia',
+    'trace_oper_ket', 'trace_oper_ket_csr', 'trace_oper_ket_dense', 'trace_oper_ket_dia',
 ]
 
 
@@ -48,7 +48,7 @@ cpdef double complex trace_dense(Dense matrix) nogil except *:
         ptr += stride
     return trace
 
-cpdef double complex trace_diag(Diag matrix) except * nogil:
+cpdef double complex trace_dia(Dia matrix) except * nogil:
     _check_shape(matrix)
     cdef double complex trace = 0
     cdef size_t diag, j
@@ -81,7 +81,7 @@ cpdef double complex trace_oper_ket_dense(Dense matrix) nogil except *:
         trace += matrix.data[ptr * stride]
     return trace
 
-cpdef double complex trace_oper_ket_diag(Diag matrix) except * nogil:
+cpdef double complex trace_oper_ket_dia(Dia matrix) except * nogil:
     cdef size_t N = <size_t>sqrt(matrix.shape[0])
     _check_shape_oper_ket(N, matrix)
     cdef double complex trace = 0
@@ -109,7 +109,7 @@ trace.__doc__ =\
     """Compute the trace (sum of digaonal elements) of a square matrix."""
 trace.add_specialisations([
     (CSR, trace_csr),
-    (Diag, trace_diag),
+    (Dia, trace_dia),
     (Dense, trace_dense),
 ], _defer=True)
 
@@ -126,7 +126,7 @@ trace_oper_ket.__doc__ =\
     """Compute the trace (sum of digaonal elements) of a stacked square matrix ."""
 trace_oper_ket.add_specialisations([
     (CSR, trace_oper_ket_csr),
-    (Diag, trace_oper_ket_diag),
+    (Dia, trace_oper_ket_dia),
     (Dense, trace_oper_ket_dense),
 ], _defer=True)
 
diff --git a/qutip/tests/core/data/conftest.py b/qutip/tests/core/data/conftest.py
index ef2025e583..b4348eaa46 100644
--- a/qutip/tests/core/data/conftest.py
+++ b/qutip/tests/core/data/conftest.py
@@ -94,5 +94,5 @@ def random_dense(shape, fortran):
 
 
 def random_diag(shape, density, sort=False):
-    """Generate a random qutip Diag matrix of the given shape and density"""
-    return qutip.core.data.Diag(random_scipy_dia(shape, density, sort))
+    """Generate a random qutip Dia matrix of the given shape and density"""
+    return qutip.core.data.Dia(random_scipy_dia(shape, density, sort))
diff --git a/qutip/tests/core/data/test_convert.py b/qutip/tests/core/data/test_convert.py
index b2cecbc28d..917003dced 100644
--- a/qutip/tests/core/data/test_convert.py
+++ b/qutip/tests/core/data/test_convert.py
@@ -15,15 +15,15 @@ def test_init_empty_data():
 @pytest.mark.parametrize(['base', 'dtype'], [
     pytest.param(data.dense.zeros(2, 2), data.Dense, id='data.Dense'),
     pytest.param(data.csr.zeros(2, 2), data.CSR, id='data.CSR'),
-    pytest.param(data.dia.zeros(2, 2), data.Diag, id='data.Diag'),
+    pytest.param(data.dia.zeros(2, 2), data.Dia, id='data.Dia'),
     pytest.param(np.zeros((10, 10), dtype=np.complex128), data.Dense,
                  id='array'),
     pytest.param(sparse.eye(10, dtype=np.complex128, format='csr'), data.CSR,
                  id='sparse'),
-    pytest.param(sparse.eye(10, dtype=np.complex128, format='dia'), data.Diag,
+    pytest.param(sparse.eye(10, dtype=np.complex128, format='dia'), data.Dia,
                  id='diag'),
     pytest.param(np.zeros((10, 10), dtype=np.int32), data.Dense, id='array'),
-    pytest.param(sparse.eye(10, dtype=float, format='dia'), data.Diag,
+    pytest.param(sparse.eye(10, dtype=float, format='dia'), data.Dia,
                  id='diag'),
     pytest.param(sparse.eye(10, dtype=float, format='csr'), data.CSR,
                  id='sparse'),
@@ -41,9 +41,9 @@ def test_create(base, dtype):
     pytest.param('csr', data.csr.zeros(2, 2), id='from CSR str'),
     pytest.param('CSR', data.csr.zeros(2, 2), id='from CSR STR'),
     pytest.param(data.CSR, data.csr.zeros(2, 2), id='from CSR type'),
-    pytest.param('Diag', data.dia.zeros(2, 2), id='from Diag STR'),
-    pytest.param('dia', data.dia.zeros(2, 2), id='from Diag str'),
-    pytest.param(data.Diag, data.dia.zeros(2, 2), id='from Diag type'),
+    pytest.param('Dia', data.dia.zeros(2, 2), id='from Dia STR'),
+    pytest.param('dia', data.dia.zeros(2, 2), id='from Dia str'),
+    pytest.param(data.Dia, data.dia.zeros(2, 2), id='from Dia type'),
 ])
 @pytest.mark.parametrize(['to_', 'dtype'], [
     pytest.param('dense', data.Dense, id='to Dense str'),
@@ -52,9 +52,9 @@ def test_create(base, dtype):
     pytest.param('csr', data.CSR, id='to CSR str'),
     pytest.param('CSR', data.CSR, id='to CSR STR'),
     pytest.param(data.CSR, data.CSR, id='to CSR type'),
-    pytest.param('Diag', data.Diag, id='to Diag STR'),
-    pytest.param('dia', data.Diag, id='to Diag str'),
-    pytest.param(data.Diag, data.Diag, id='to Diag type'),
+    pytest.param('Dia', data.Dia, id='to Dia STR'),
+    pytest.param('dia', data.Dia, id='to Dia str'),
+    pytest.param(data.Dia, data.Dia, id='to Dia type'),
 ])
 def test_converters(from_, base, to_, dtype):
     converter = data.to[to_, from_]
@@ -96,9 +96,9 @@ def op_numpy(self, mat):
 
     specialisations = [
         pytest.param(data.dense.from_csr, data.CSR, data.Dense),
-        pytest.param(data.dense.from_diag, data.Diag, data.Dense),
+        pytest.param(data.dense.from_dia, data.Dia, data.Dense),
         pytest.param(data.csr.from_dense, data.Dense, data.CSR),
-        pytest.param(data.csr.from_diag, data.Diag, data.CSR),
-        pytest.param(data.dia.from_dense, data.Dense, data.Diag),
-        pytest.param(data.dia.from_csr, data.CSR, data.Diag),
+        pytest.param(data.csr.from_dia, data.Dia, data.CSR),
+        pytest.param(data.dia.from_dense, data.Dense, data.Dia),
+        pytest.param(data.dia.from_csr, data.CSR, data.Dia),
     ]
diff --git a/qutip/tests/core/data/test_diag.py b/qutip/tests/core/data/test_diag.py
index 43c5318311..4cd77ff317 100644
--- a/qutip/tests/core/data/test_diag.py
+++ b/qutip/tests/core/data/test_diag.py
@@ -3,7 +3,7 @@
 import pytest
 
 from qutip.core import data, qeye, CoreOptions
-from qutip.core.data import dia, Dense, Diag
+from qutip.core.data import dia, Dense, Dia
 
 from . import conftest
 
@@ -39,7 +39,7 @@ def scipy_dia(shape, density):
 
 
 def _valid_scipy():
-    """Arbitrary valid scipy Diag"""
+    """Arbitrary valid scipy Dia"""
     return conftest.random_scipy_dia((10, 10), 0.5)
 
 
@@ -59,7 +59,7 @@ def data_diag(shape, density):
 class TestClassMethods:
     def test_init_from_scipy(self, scipy_dia):
         """Test that __init__ can accept a scipy dia matrix."""
-        out = dia.Diag(scipy_dia)
+        out = dia.Dia(scipy_dia)
         assert out.shape == scipy_dia.shape
         assert (out.as_scipy() - scipy_dia).nnz == 0
 
@@ -69,7 +69,7 @@ def test_init_from_tuple(self, scipy_dia):
         the as_scipy() method succeeds.
         """
         arg = (scipy_dia.data, scipy_dia.offsets)
-        out = dia.Diag(arg, shape=scipy_dia.shape)
+        out = dia.Dia(arg, shape=scipy_dia.shape)
         assert out.shape == scipy_dia.shape
         assert (out.as_scipy() - scipy_dia).nnz == 0
 
@@ -86,7 +86,7 @@ def test_init_from_tuple_allowed_dtypes(self, d_type, o_type):
         data = sci.data.real.astype(d_type, casting='unsafe')
         offsets = sci.offsets.astype(o_type, casting='unsafe')
         scipy_dia = scipy.sparse.dia_matrix((data, offsets), shape=sci.shape)
-        out = dia.Diag((data, offsets), shape=sci.shape)
+        out = dia.Dia((data, offsets), shape=sci.shape)
         out_scipy = out.as_scipy()
         assert out.shape == scipy_dia.shape
         assert out_scipy.data.dtype == np.complex128
@@ -125,14 +125,14 @@ def test_init_from_wrong_input(self, arg, kwargs, error):
         Test that the __init__ method raises a suitable error when passed
         incorrectly formatted inputs.
 
-        This test also serves as a *partial* check that Diag safely handles
+        This test also serves as a *partial* check that Dia safely handles
         deallocation in the presence of exceptions in its __init__ method.  If
         the tests segfault, it's quite likely that the memory management isn't
         being done correctly in the hand-off us setting our data buffers up and
         marking the numpy actually owns the data.
         """
         with pytest.raises(error):
-            dia.Diag(arg, **kwargs)
+            dia.Dia(arg, **kwargs)
 
     def test_copy_returns_a_correct_copy(self, data_diag):
         """
@@ -168,12 +168,12 @@ def test_as_scipy_of_dia_from_scipy_is_different(self, scipy_dia):
         Test that we produce a new scipy matrix, regardless of how we have
         initialised the type.
         """
-        assert dia.Diag(scipy_dia).as_scipy() is not scipy_dia
+        assert dia.Dia(scipy_dia).as_scipy() is not scipy_dia
 
     def test_as_scipy_of_copy_is_different(self, data_diag):
         """
         Test that as_scipy() does not return the same array, or the same views
-        if it's not the same input matrix.  We don't want two Diag matrices to
+        if it's not the same input matrix.  We don't want two Dia matrices to
         be linked.
         """
         original = data_diag.as_scipy()
@@ -187,7 +187,7 @@ def test_as_scipy_is_correct_result(self, scipy_dia):
         Test that as_scipy is actually giving the matrix we expect for a given
         input.
         """
-        data_diag = dia.Diag(scipy_dia)
+        data_diag = dia.Dia(scipy_dia)
         assert isinstance(data_diag.as_scipy(), scipy.sparse.dia_matrix)
         assert (data_diag.as_scipy() - scipy_dia).nnz == 0
 
@@ -211,7 +211,7 @@ def test_empty(self, shape, density):
         ndiag = int(shape[0] * shape[1] * density) or 1
         base = dia.empty(shape[0], shape[1], ndiag)
         sci = base.as_scipy(full=True)
-        assert isinstance(base, dia.Diag)
+        assert isinstance(base, dia.Dia)
         assert isinstance(sci, scipy.sparse.dia_matrix)
         assert base.shape == shape
         assert sci.data.shape == (ndiag, shape[1])
@@ -220,7 +220,7 @@ def test_empty(self, shape, density):
     def test_zeros(self, shape):
         base = dia.zeros(shape[0], shape[1])
         sci = base.as_scipy()
-        assert isinstance(base, dia.Diag)
+        assert isinstance(base, dia.Dia)
         assert base.shape == shape
         assert sci.nnz == 0
         assert np.all(base.to_array() == 0)
@@ -240,7 +240,7 @@ def test_identity(self, dimension, scale):
                                       dtype=np.complex128, format='dia')
         if scale is not None:
             scipy_test *= scale
-        assert isinstance(base, dia.Diag)
+        assert isinstance(base, dia.Dia)
         assert base.shape == (dimension, dimension)
         assert sci.nnz == dimension
         assert (sci - scipy_test).nnz == 0
@@ -279,7 +279,7 @@ def test_diags(self, diagonals, offsets, shape):
         test = np.zeros(shape, dtype=np.complex128)
         for diagonal, offset in zip(diagonals, offsets):
             test[np.where(np.eye(*shape, k=offset) == 1)] += diagonal
-        assert isinstance(base, dia.Diag)
+        assert isinstance(base, dia.Dia)
         assert base.shape == shape
         np.testing.assert_allclose(base.to_array(), test, rtol=1e-10)
 
@@ -297,12 +297,12 @@ def test_diags(self, diagonals, offsets, shape):
     def test_one_element(self, shape, position, value):
         test = np.zeros(shape, dtype=np.complex128)
         if value is None:
-            base = data.one_element_diag(shape, position)
+            base = data.one_element_dia(shape, position)
             test[position] = 1.0+0.0j
         else:
-            base = data.one_element_diag(shape, position, value)
+            base = data.one_element_dia(shape, position, value)
             test[position] = value
-        assert isinstance(base, data.Diag)
+        assert isinstance(base, data.Dia)
         assert base.shape == shape
         assert np.allclose(base.to_array(), test, atol=1e-10)
 
@@ -314,7 +314,7 @@ def test_one_element(self, shape, position, value):
     ])
     def test_one_element_error(self, shape, position, value):
         with pytest.raises(ValueError) as exc:
-            base = data.one_element_diag(shape, position, value)
+            base = data.one_element_dia(shape, position, value)
         assert str(exc.value).startswith("Position of the elements"
                                          " out of bound: ")
 
@@ -330,7 +330,7 @@ def test_tidyup(data_diag):
     if largest == smallest:
         return
     tol = (largest + smallest) / 2
-    tidy = data.tidyup_diag(data_diag, tol, False)
+    tidy = data.tidyup_dia(data_diag, tol, False)
     # Inplace=False, does not modify the original
     np.testing.assert_array_equal(data_diag.to_array(), before)
     np.testing.assert_array_equal(data_diag.as_scipy().toarray(), sp_before)
@@ -338,7 +338,7 @@ def test_tidyup(data_diag):
     assert not np.allclose(tidy.to_array(), before)
     assert not np.allclose(tidy.as_scipy().toarray(), sp_before)
 
-    data.tidyup_diag(data_diag, tol, True)
+    data.tidyup_dia(data_diag, tol, True)
     assert not np.allclose(data_diag.to_array(), before)
     assert not np.allclose(data_diag.as_scipy().toarray(), sp_before)
 
diff --git a/qutip/tests/core/data/test_expect.py b/qutip/tests/core/data/test_expect.py
index babfbb47cb..c4cadd9ad0 100644
--- a/qutip/tests/core/data/test_expect.py
+++ b/qutip/tests/core/data/test_expect.py
@@ -5,7 +5,7 @@
 import pytest
 import numpy as np
 from qutip import data
-from qutip.core.data import CSR, Dense, Diag
+from qutip.core.data import CSR, Dense, Dia
 from itertools import product
 
 
@@ -39,8 +39,8 @@ def op_numpy(self, op, state):
         pytest.param(data.expect_csr, CSR, CSR, complex),
         pytest.param(data.expect_dense, Dense, Dense, complex),
         pytest.param(data.expect_csr_dense, CSR, Dense, complex),
-        pytest.param(data.expect_diag, Diag, Diag, complex),
-        pytest.param(data.expect_diag_dense, Diag, Dense, complex),
+        pytest.param(data.expect_dia, Dia, Dia, complex),
+        pytest.param(data.expect_dia_dense, Dia, Dense, complex),
     ]
 
 
@@ -66,6 +66,6 @@ def op_numpy(self, op, state):
         pytest.param(data.expect_super_dense, Dense, Dense, complex),
         pytest.param(data.expect_super_csr, CSR, CSR, complex),
         pytest.param(data.expect_super_csr_dense, CSR, Dense, complex),
-        pytest.param(data.expect_super_diag, Diag, Diag, complex),
-        pytest.param(data.expect_super_diag_dense, Diag, Dense, complex),
+        pytest.param(data.expect_super_dia, Dia, Dia, complex),
+        pytest.param(data.expect_super_dia_dense, Dia, Dense, complex),
     ]
diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index c36c120bba..a731b8b5ea 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -6,7 +6,7 @@
 import warnings
 
 from qutip.core import data as _data
-from qutip.core.data import Data, Dense, CSR, Diag
+from qutip.core.data import Data, Dense, CSR, Dia
 
 
 skip_no_mkl = pytest.mark.skipif(
@@ -37,7 +37,7 @@ def _gen_ket(self, N, dtype):
             "spsolve", "splu", "gmres", "lsqr", "solve", "lstsq", "mkl_spsolve"
         ]
     )
-    @pytest.mark.parametrize('dtype', [CSR, Diag])
+    @pytest.mark.parametrize('dtype', [CSR, Dia])
     def test_mathematically_correct_sparse(self, method, opt, dtype):
         """
         Test that the binary operation is mathematically correct for all the
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 73c5543539..e2c2f73a88 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -4,7 +4,7 @@
 import pytest
 
 from qutip.core import data
-from qutip.core.data import Data, Dense, CSR, Diag
+from qutip.core.data import Data, Dense, CSR, Dia
 
 from . import conftest
 
@@ -183,13 +183,13 @@ def zero_factory():
 # getting just a single case from each.
 _ALL_CASES = {
     CSR: cases_csr,
-    Diag: cases_diag,
+    Dia: cases_diag,
     Dense: cases_dense,
 }
 _RANDOM = {
     CSR: lambda shape: [lambda: conftest.random_csr(shape, 0.5, True)],
     Dense: lambda shape: [lambda: conftest.random_dense(shape, False)],
-    Diag: lambda shape: [lambda: conftest.random_diag(shape, 0.5)],
+    Dia: lambda shape: [lambda: conftest.random_diag(shape, 0.5)],
 }
 
 
@@ -553,7 +553,7 @@ def op_numpy(self, left, right, scale):
     specialisations = [
         pytest.param(data.add_csr, CSR, CSR, CSR),
         pytest.param(data.add_dense, Dense, Dense, Dense),
-        pytest.param(data.add_diag, Diag, Diag, Diag),
+        pytest.param(data.add_dia, Dia, Dia, Dia),
     ]
 
     # `add` has an additional scalar parameter, because the operation is
@@ -590,7 +590,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.adjoint_csr, CSR, CSR),
         pytest.param(data.adjoint_dense, Dense, Dense),
-        pytest.param(data.adjoint_diag, Diag, Diag),
+        pytest.param(data.adjoint_dia, Dia, Dia),
     ]
 
 
@@ -601,7 +601,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.conj_csr, CSR, CSR),
         pytest.param(data.conj_dense, Dense, Dense),
-        pytest.param(data.conj_diag, Diag, Diag),
+        pytest.param(data.conj_dia, Dia, Dia),
     ]
 
 
@@ -638,7 +638,7 @@ def op_numpy(self, left, right, scalar_is_ket=False):
 
     specialisations = [
         pytest.param(data.inner_csr, CSR, CSR, complex),
-        pytest.param(data.inner_diag, Diag, Diag, complex),
+        pytest.param(data.inner_dia, Dia, Dia, complex),
         pytest.param(data.inner_dense, Dense, Dense, complex),
     ]
 
@@ -709,7 +709,7 @@ def op_numpy(self, left, mid, right, scalar_is_ket=False):
 
     specialisations = [
         pytest.param(data.inner_op_csr, CSR, CSR, CSR, complex),
-        pytest.param(data.inner_op_diag, Diag, Diag, Diag, complex),
+        pytest.param(data.inner_op_dia, Dia, Dia, Dia, complex),
         pytest.param(data.inner_op_dense, Dense, Dense, Dense, complex),
     ]
 
@@ -758,7 +758,7 @@ def op_numpy(self, left, right):
     specialisations = [
         pytest.param(data.kron_csr, CSR, CSR, CSR),
         pytest.param(data.kron_dense, Dense, Dense, Dense),
-        pytest.param(data.kron_diag, Diag, Diag, Diag),
+        pytest.param(data.kron_dia, Dia, Dia, Dia),
     ]
 
 
@@ -772,8 +772,8 @@ def op_numpy(self, left, right):
         pytest.param(data.matmul_csr, CSR, CSR, CSR),
         pytest.param(data.matmul_csr_dense_dense, CSR, Dense, Dense),
         pytest.param(data.matmul_dense, Dense, Dense, Dense),
-        pytest.param(data.matmul_diag, Diag, Diag, Diag),
-        pytest.param(data.matmul_diag_dense_dense, Diag, Dense, Dense),
+        pytest.param(data.matmul_dia, Dia, Dia, Dia),
+        pytest.param(data.matmul_dia_dense_dense, Dia, Dense, Dense),
     ]
 
 
@@ -786,7 +786,7 @@ def op_numpy(self, left, right):
     specialisations = [
         pytest.param(data.multiply_csr, CSR, CSR, CSR),
         pytest.param(data.multiply_dense, Dense, Dense, Dense),
-        pytest.param(data.multiply_diag, Diag, Diag, Diag),
+        pytest.param(data.multiply_dia, Dia, Dia, Dia),
     ]
 
 
@@ -797,7 +797,7 @@ def op_numpy(self, matrix, scalar):
     specialisations = [
         pytest.param(data.mul_csr, CSR, CSR),
         pytest.param(data.mul_dense, Dense, Dense),
-        pytest.param(data.mul_diag, Diag, Diag),
+        pytest.param(data.mul_dia, Dia, Dia),
     ]
 
 
@@ -808,7 +808,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.neg_csr, CSR, CSR),
         pytest.param(data.neg_dense, Dense, Dense),
-        pytest.param(data.neg_diag, Diag, Diag),
+        pytest.param(data.neg_dia, Dia, Dia),
     ]
 
 
@@ -821,7 +821,7 @@ def op_numpy(self, left, right):
     specialisations = [
         pytest.param(data.sub_csr, CSR, CSR, CSR),
         pytest.param(data.sub_dense, Dense, Dense, Dense),
-        pytest.param(data.sub_diag, Diag, Diag, Diag),
+        pytest.param(data.sub_dia, Dia, Dia, Dia),
     ]
 
 
@@ -834,7 +834,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.trace_csr, CSR, complex),
         pytest.param(data.trace_dense, Dense, complex),
-        pytest.param(data.trace_diag, Diag, complex),
+        pytest.param(data.trace_dia, Dia, complex),
     ]
 
 
@@ -855,7 +855,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.trace_oper_ket_csr, CSR, complex),
         pytest.param(data.trace_oper_ket_dense, Dense, complex),
-        pytest.param(data.trace_oper_ket_diag, Diag, complex),
+        pytest.param(data.trace_oper_ket_dia, Dia, complex),
     ]
 
 
@@ -868,7 +868,7 @@ def op_numpy(self, matrix, n):
     specialisations = [
         pytest.param(data.pow_csr, CSR, CSR),
         pytest.param(data.pow_dense, Dense, Dense),
-        pytest.param(data.pow_diag, Diag, Diag),
+        pytest.param(data.pow_dia, Dia, Dia),
     ]
 
     @pytest.mark.parametrize("n", [0, 1, 10], ids=["n_0", "n_1", "n_10"])
@@ -903,7 +903,7 @@ def op_numpy(self, matrix):
         pytest.param(data.expm_csr, CSR, CSR),
         pytest.param(data.expm_csr_dense, CSR, Dense),
         pytest.param(data.expm_dense, Dense, Dense),
-        pytest.param(data.expm_diag, Diag, Diag),
+        pytest.param(data.expm_dia, Dia, Dia),
     ]
 
 
@@ -925,7 +925,7 @@ def op_numpy(self, matrix):
     specialisations = [
         pytest.param(data.transpose_csr, CSR, CSR),
         pytest.param(data.transpose_dense, Dense, Dense),
-        pytest.param(data.transpose_diag, Diag, Diag),
+        pytest.param(data.transpose_dia, Dia, Dia),
     ]
 
 
@@ -948,7 +948,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.project_csr, CSR, CSR),
-        pytest.param(data.project_diag, Diag, Diag),
+        pytest.param(data.project_dia, Dia, Dia),
         pytest.param(data.project_dense, Dense, Dense),
     ]
 
diff --git a/qutip/tests/core/data/test_norm.py b/qutip/tests/core/data/test_norm.py
index 423f958289..cfc8ffbb4e 100644
--- a/qutip/tests/core/data/test_norm.py
+++ b/qutip/tests/core/data/test_norm.py
@@ -3,7 +3,7 @@
 import scipy.linalg
 import pytest
 from qutip import data
-from qutip.core.data import CSR, Dense, Diag
+from qutip.core.data import CSR, Dense, Dia
 import numbers
 
 
@@ -13,7 +13,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.norm.one_csr, CSR, numbers.Number),
-        pytest.param(data.norm.one_diag, Diag, numbers.Number),
+        pytest.param(data.norm.one_dia, Dia, numbers.Number),
         pytest.param(data.norm.one_dense, Dense, numbers.Number),
     ]
 
@@ -24,7 +24,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.norm.frobenius_csr, CSR, numbers.Number),
-        pytest.param(data.norm.frobenius_diag, Diag, numbers.Number),
+        pytest.param(data.norm.frobenius_dia, Dia, numbers.Number),
         pytest.param(data.norm.frobenius_dense, Dense, numbers.Number),
     ]
 
@@ -37,7 +37,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.norm.max_csr, CSR, numbers.Number),
-        pytest.param(data.norm.max_diag, Diag, numbers.Number),
+        pytest.param(data.norm.max_dia, Dia, numbers.Number),
         pytest.param(data.norm.max_dense, Dense, numbers.Number),
     ]
 
@@ -58,7 +58,7 @@ def op_numpy(self, matrix):
     ]
     specialisations = [
         pytest.param(data.norm.l2_csr, CSR, numbers.Number),
-        pytest.param(data.norm.l2_diag, Diag, numbers.Number),
+        pytest.param(data.norm.l2_dia, Dia, numbers.Number),
         pytest.param(data.norm.l2_dense, Dense, numbers.Number),
     ]
 
diff --git a/qutip/tests/core/data/test_properties.py b/qutip/tests/core/data/test_properties.py
index 70e956ac20..88697ee152 100644
--- a/qutip/tests/core/data/test_properties.py
+++ b/qutip/tests/core/data/test_properties.py
@@ -4,7 +4,7 @@
 from qutip import data as _data
 from qutip import CoreOptions
 
-@pytest.fixture(params=[_data.CSR, _data.Dense, _data.Diag], ids=["CSR", "Dense", "Diag"])
+@pytest.fixture(params=[_data.CSR, _data.Dense, _data.Dia], ids=["CSR", "Dense", "Dia"])
 def datatype(request):
     return request.param
 
diff --git a/qutip/tests/core/data/test_ptrace.py b/qutip/tests/core/data/test_ptrace.py
index 3798885a6b..74d25e8986 100644
--- a/qutip/tests/core/data/test_ptrace.py
+++ b/qutip/tests/core/data/test_ptrace.py
@@ -3,7 +3,7 @@
 import scipy.linalg
 import pytest
 from qutip import data
-from qutip.core.data import CSR, Dense, Diag
+from qutip.core.data import CSR, Dense, Dia
 
 
 class TestPtrace(testing.UnaryOpMixin):
@@ -38,7 +38,7 @@ def op_numpy(self, matrix, dims, sel):
         pytest.param(data.ptrace_csr, CSR, CSR),
         pytest.param(data.ptrace_csr_dense, CSR, Dense),
         pytest.param(data.ptrace_dense, Dense, Dense),
-        pytest.param(data.ptrace_diag, Diag, Diag),
+        pytest.param(data.ptrace_dia, Dia, Dia),
     ]
 
     @pytest.mark.parametrize(
diff --git a/qutip/tests/core/data/test_reshape.py b/qutip/tests/core/data/test_reshape.py
index 700943842d..5f23b06b83 100644
--- a/qutip/tests/core/data/test_reshape.py
+++ b/qutip/tests/core/data/test_reshape.py
@@ -2,7 +2,7 @@
 import pytest
 import numpy as np
 from qutip import data
-from qutip.core.data import CSR, Dense, Diag
+from qutip.core.data import CSR, Dense, Dia
 
 
 class TestSplitColumns(UnaryOpMixin):
@@ -11,7 +11,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.split_columns_csr, CSR, list),
-        pytest.param(data.split_columns_diag, Diag, list),
+        pytest.param(data.split_columns_dia, Dia, list),
         pytest.param(data.split_columns_dense, Dense, list),
     ]
 
@@ -24,7 +24,7 @@ def op_numpy(self, matrix):
 
     specialisations = [
         pytest.param(data.column_stack_csr, CSR, CSR),
-        pytest.param(data.column_stack_diag, Diag, Diag),
+        pytest.param(data.column_stack_dia, Dia, Dia),
         pytest.param(data.column_stack_dense, Dense, Dense),
     ]
 
@@ -46,7 +46,7 @@ def op_numpy(self, matrix, rows):
 
     specialisations = [
         pytest.param(data.column_unstack_csr, CSR, CSR),
-        pytest.param(data.column_unstack_diag, Diag, Diag),
+        pytest.param(data.column_unstack_dia, Dia, Dia),
         pytest.param(data.column_unstack_dense, Dense, Dense),
     ]
 
@@ -96,7 +96,7 @@ def op_numpy(self, matrix, rows, columns):
 
     specialisations = [
         pytest.param(data.reshape_dense, Dense, Dense),
-        pytest.param(data.reshape_diag, Diag, Diag),
+        pytest.param(data.reshape_dia, Dia, Dia),
         pytest.param(data.reshape_csr, CSR, CSR),
     ]
 
diff --git a/qutip/tests/core/test_qobj.py b/qutip/tests/core/test_qobj.py
index 924cd71f5f..ebb011b6ca 100644
--- a/qutip/tests/core/test_qobj.py
+++ b/qutip/tests/core/test_qobj.py
@@ -1256,14 +1256,14 @@ def test_data_as():
         qobj.data_as("csr_matrix")
     assert "ndarray" in str(err.value)
 
-    qobj = qutip.qeye(2, dtype="Diag")
+    qobj = qutip.qeye(2, dtype="Dia")
 
     assert scipy.sparse.isspmatrix_dia(qobj.data_as("dia_matrix"))
     assert scipy.sparse.isspmatrix_dia(qobj.data_as(copy=False))
 
     qobj.data_as(copy=False).data[:, 0] = 0
     qobj.data_as(copy=True).data[:, 0] = 2
-    assert qobj == qutip.num(2, dtype="Diag")
+    assert qobj == qutip.num(2, dtype="Dia")
     with pytest.raises(ValueError) as err:
         qobj.data_as("ndarray")
     assert "dia_matrix" in str(err.value)

From 28dbdaa8e25b28e78ca6ffd537f3287d14385d33 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 19:22:48 +0900
Subject: [PATCH 503/602] hide warning

---
 qutip/tests/test_visualization.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 3e53deef4a..8036abbd8f 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -181,6 +181,7 @@ def test_plot_expectation_values(n_of_results, n_of_e_ops, one_axes, args):
     assert isinstance(axes, np.ndarray)
 
 
+@pytest.mark.filterwarnings("ignore:The input coordinates to pcolor:UserWarning")
 @pytest.mark.parametrize('color, args', [
     ('sequential', {}),
     ('diverging', {}),

From a5033be9323517c4897e3d32255f20f6d47aadf3 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 19:25:32 +0900
Subject: [PATCH 504/602] add doc

---
 doc/changes/2192.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2192.misc

diff --git a/doc/changes/2192.misc b/doc/changes/2192.misc
new file mode 100644
index 0000000000..4bd1ebbca6
--- /dev/null
+++ b/doc/changes/2192.misc
@@ -0,0 +1 @@
+add pytest for visualization.py

From bd244b66e12b9dd032c1704577de3cb5119bb572 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 20:33:20 +0900
Subject: [PATCH 505/602] add pytest

---
 qutip/tests/test_visualization.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 8036abbd8f..f5162885ea 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -264,6 +264,17 @@ def test_plot_qubism_Error(ket, args, expected):
     assert str(exc_info.value) == expected
 
 
+
+def test_plot_qubism_mock(monkeypatch: pytest.MonkeyPatch):
+    text = "For 'pairs_skewed' pairs of dimensions need to be the same."
+    def mock_func(ket, kwarg):
+        return ket
+    monkeypatch.setattr("qutip.visualization.tensor", mock_func)
+    with pytest.raises(Exception) as exc_info:
+        qutip.plot_qubism(qutip.ket("010"), how='pairs_skewed')
+    assert str(exc_info.value) == text
+
+
 @pytest.mark.parametrize('args', [
     ({'splitting': None}),
     ({'labels_iteration': 1}),

From 0c5175a4f3374ef0d13d259d157cd9dcf03d5c3f Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 20:35:27 +0900
Subject: [PATCH 506/602] pep8

---
 qutip/tests/test_visualization.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index f5162885ea..2647aa6439 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -181,7 +181,9 @@ def test_plot_expectation_values(n_of_results, n_of_e_ops, one_axes, args):
     assert isinstance(axes, np.ndarray)
 
 
-@pytest.mark.filterwarnings("ignore:The input coordinates to pcolor:UserWarning")
+@pytest.mark.filterwarnings(
+    "ignore:The input coordinates to pcolor:UserWarning"
+    )
 @pytest.mark.parametrize('color, args', [
     ('sequential', {}),
     ('diverging', {}),
@@ -264,9 +266,9 @@ def test_plot_qubism_Error(ket, args, expected):
     assert str(exc_info.value) == expected
 
 
-
 def test_plot_qubism_mock(monkeypatch: pytest.MonkeyPatch):
     text = "For 'pairs_skewed' pairs of dimensions need to be the same."
+
     def mock_func(ket, kwarg):
         return ket
     monkeypatch.setattr("qutip.visualization.tensor", mock_func)

From eed69ab9a4a7d2e6d4787d33e7a1f5f93c3e0994 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 20:48:40 +0900
Subject: [PATCH 507/602] add indentation

---
 qutip/visualization.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 7edf5000fe..dbd0468377 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -272,14 +272,14 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
         Determines how colors are assigned to each square:
 
         -  If set to ``"scaled"`` (default), each color is chosen by
-        passing the absolute value of the corresponding matrix
-        element into `cmap` with the sign of the real part.
+            passing the absolute value of the corresponding matrix
+            element into `cmap` with the sign of the real part.
         -  If set to ``"threshold"``, each square is plotted as
-        the maximum of `cmap` for the positive real part and as
-        the minimum for the negative part of the matrix element;
-        note that this generalizes `"threshold"` to complex numbers.
+            the maximum of `cmap` for the positive real part and as
+            the minimum for the negative part of the matrix element;
+            note that this generalizes `"threshold"` to complex numbers.
         -  If set to ``"phase"``, each color is chosen according to
-        the angle of the corresponding matrix element.
+            the angle of the corresponding matrix element.
 
     label_top : bool, default=True
         If True, x ticklabels will be placed on top, otherwise

From 03256ef592b03dd1fd19f4a07c5bd5b2c5dab1d1 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 21:38:31 +0900
Subject: [PATCH 508/602] indent

---
 qutip/visualization.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index dbd0468377..3e3f97b48c 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -621,14 +621,14 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     bar_style : string, default="real"
 
         -  If set to ``"real"`` (default), each bar is plotted
-        as the real part of the corresponding matrix element
-        Determines how colors are assigned to each square:
+            as the real part of the corresponding matrix element
+            Determines how colors are assigned to each square:
         -  If set to ``"img"``, each bar is plotted
-        as the imaginary part of the corresponding matrix element
+            as the imaginary part of the corresponding matrix element
         -  If set to ``"abs"``, each bar is plotted
-        as the absolute value of the corresponding matrix element
+            as the absolute value of the corresponding matrix element
         -  If set to ``"phase"`` (default), each bar is plotted
-        as the angle of the corresponding matrix element
+            as the angle of the corresponding matrix element
 
     color_limits : list/array with two float numbers, optional
         The limits of colorbar [min, max]
@@ -637,13 +637,13 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         Determines how colors are assigned to each square:
 
         -  If set to ``"real"`` (default), each color is chosen
-        according to the real part of the corresponding matrix element.
+            according to the real part of the corresponding matrix element.
         -  If set to ``"img"``, each color is chosen according to
-        the imaginary part of the corresponding matrix element.
+            the imaginary part of the corresponding matrix element.
         -  If set to ``"abs"``, each color is chosen according to
-        the absolute value of the corresponding matrix element.
+            the absolute value of the corresponding matrix element.
         -  If set to ``"phase"``, each color is chosen according to
-        the angle of the corresponding matrix element.
+            the angle of the corresponding matrix element.
 
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.

From b2cdd69f61d853a678b2cafd493779735294e921 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Fri, 14 Jul 2023 22:03:07 +0900
Subject: [PATCH 509/602] pep8

---
 qutip/visualization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 3e3f97b48c..0e8a4873de 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -259,7 +259,8 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
         .. note::
 
-            Hinton plots of superoperators are currently only supported for qubits.
+            Hinton plots of superoperators are currently only
+            supported for qubits.
 
     x_basis : list of strings, optional
         list of x ticklabels to represent x basis of the input.

From f3cd5bd297891af0d761d26c6f2b66ccf8cd192f Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Jul 2023 10:12:11 -0400
Subject: [PATCH 510/602] Change operators default dtype

---
 qutip/core/data/__init__.py |  2 +-
 qutip/core/operators.py     | 14 +++++++-------
 qutip/core/states.py        |  6 +++---
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/qutip/core/data/__init__.py b/qutip/core/data/__init__.py
index 876291cf17..e546d947ce 100644
--- a/qutip/core/data/__init__.py
+++ b/qutip/core/data/__init__.py
@@ -45,7 +45,7 @@
 ])
 to.register_aliases(['csr', 'CSR'], CSR)
 to.register_aliases(['Dense', 'dense'], Dense)
-to.register_aliases(['Dia', 'dia', 'diag'], Dia)
+to.register_aliases(['DIA', 'Dia', 'dia', 'diag'], Dia)
 
 
 from . import _creator_utils
diff --git a/qutip/core/operators.py b/qutip/core/operators.py
index 7dc8935b4b..f51f1de878 100644
--- a/qutip/core/operators.py
+++ b/qutip/core/operators.py
@@ -61,7 +61,7 @@ def qdiags(diagonals, offsets=None, dims=None, shape=None, *,
      [ 0.          0.          0.          0.        ]]
 
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     offsets = [0] if offsets is None else offsets
     data = _data.diag[dtype](diagonals, offsets, shape)
     return Qobj(data, dims=dims, type='oper', copy=False)
@@ -421,7 +421,7 @@ def destroy(N, offset=0, *, dtype=None):
      [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
      [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     if not isinstance(N, (int, np.integer)):  # raise error if N not integer
         raise ValueError("Hilbert space dimension must be integer value")
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
@@ -464,7 +464,7 @@ def create(N, offset=0, *, dtype=None):
      [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
      [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     if not isinstance(N, (int, np.integer)):  # raise error if N not integer
         raise ValueError("Hilbert space dimension must be integer value")
     data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex))
@@ -736,7 +736,7 @@ def qeye(dimensions, *, dtype=None):
      [0. 0. 0. 1.]]
 
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     size, dimensions = _implicit_tensor_dimensions(dimensions)
     type_ = 'super' if isinstance(dimensions[0][0], list) else 'oper'
     return Qobj(_data.identity[dtype](size), dims=dimensions, type=type_,
@@ -860,7 +860,7 @@ def num(N, offset=0, *, dtype=None):
      [0 0 2 0]
      [0 0 0 3]]
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     data = np.arange(offset, offset + N, dtype=complex)
     return qdiags(data, 0, dtype=dtype)
 
@@ -1152,7 +1152,7 @@ def enr_identity(dims, excitations, *, dtype=None):
         exication-number-restricted state space defined by `dims` and
         `exciations`.
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     from .states import enr_state_dictionaries
     nstates, _, _ = enr_state_dictionaries(dims, excitations)
     return Qobj(_data.identity[dtype](nstates),
@@ -1193,7 +1193,7 @@ def charge(Nmax, Nmin=None, frac=1, *, dtype=None):
     .. versionadded:: 3.2
 
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     if Nmin is None:
         Nmin = -Nmax
     diag = frac * np.arange(Nmin, Nmax+1, dtype=float)
diff --git a/qutip/core/states.py b/qutip/core/states.py
index c030e33d0b..a3c310998a 100644
--- a/qutip/core/states.py
+++ b/qutip/core/states.py
@@ -342,7 +342,7 @@ def fock_dm(dimensions, n=None, offset=None, *, dtype=None):
       [ 0.+0.j  0.+0.j  0.+0.j]]
 
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     return basis(dimensions, n, offset=offset, dtype=dtype).proj()
 
 
@@ -446,7 +446,7 @@ def thermal_dm(N, n, method='operator', *, dtype=None):
     if truncated too aggressively.
 
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     if n == 0:
         return fock_dm(N, 0, dtype=dtype)
     else:
@@ -487,7 +487,7 @@ def maximally_mixed_dm(N, *, dtype=None):
     dm : qobj
         Thermal state density matrix.
     """
-    dtype = dtype or settings.core["default_dtype"] or _data.CSR
+    dtype = dtype or settings.core["default_dtype"] or _data.Dia
     if not isinstance(N, numbers.Integral) or N <= 0:
         raise ValueError("N must be integer N > 0")
     return Qobj(_data.identity[dtype](N, scale=1/N), dims=[[N], [N]],

From 46272c6eaf32a5a1af6a5cf8d1dade3274e682a2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 14 Jul 2023 10:33:16 -0400
Subject: [PATCH 511/602] Remove comments

---
 qutip/core/data/_creator_utils.py | 9 ++++++++-
 qutip/core/data/matmul.pyx        | 4 ----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/qutip/core/data/_creator_utils.py b/qutip/core/data/_creator_utils.py
index c90b2aa8e6..da3841c756 100644
--- a/qutip/core/data/_creator_utils.py
+++ b/qutip/core/data/_creator_utils.py
@@ -8,7 +8,14 @@
 from .base import Data
 from .dense import Dense
 
-__all__ = ['is_data', 'is_nparray', 'data_copy', 'isspmatrix_csr', 'issparse']
+__all__ = [
+    'data_copy',
+    'is_data',
+    'is_nparray',
+    'isspmatrix_csr',
+    'isspmatrix_dia',
+    'issparse'
+]
 
 
 def is_data(arg):
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 1fc39c85c3..fce32f1b09 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -397,10 +397,6 @@ cpdef Dense matmul_dia_dense_dense(Dia left, Dense right, double complex scale=1
                 tmp.data + start_out,
                 length, 1.
             )
-            # for i in range(length):
-            #   tmp.data[start_out + i] += (
-            #     left.data[start_left + i] * right.data[start_right + i]
-            #   )
 
       else:
         for col in range(right.shape[1]):

From f2ed289623a1232c45c3c93232e67f912c1f9e3a Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Fri, 14 Jul 2023 17:00:47 -0400
Subject: [PATCH 512/602] Dia understood as sparse in eigen, brtools, etc.

---
 qutip/core/_brtools.pyx              |  2 +-
 qutip/core/qobj.py                   |  4 ++--
 qutip/solver/steadystate.py          | 17 +++++++++--------
 qutip/tests/core/test_brtools.py     |  4 ++--
 qutip/tests/core/test_coefficient.py |  2 +-
 5 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
index 14710ffea8..623017eec8 100644
--- a/qutip/core/_brtools.pyx
+++ b/qutip/core/_brtools.pyx
@@ -201,7 +201,7 @@ cdef class _EigenBasisTransform:
     def __init__(self, QobjEvo oper, bint sparse=False):
         if oper.dims[0] != oper.dims[1]:
             raise ValueError
-        if type(oper(0).data) is _data.CSR and not sparse:
+        if type(oper(0).data) in [_data.CSR, _data.Dia] and not sparse:
             oper = oper.to(Dense)
         self.oper = oper
         self.isconstant = oper.isconstant
diff --git a/qutip/core/qobj.py b/qutip/core/qobj.py
index 72cebf9d74..2560a90b54 100644
--- a/qutip/core/qobj.py
+++ b/qutip/core/qobj.py
@@ -1558,7 +1558,7 @@ def eigenstates(self, sparse=False, sort='low', eigvals=0,
                                           isherm=self._isherm,
                                           sort=sort, eigvals=eigvals, tol=tol,
                                           maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
+        elif isinstance(self.data, (_data.CSR, _data.Dia)):
             evals, evecs = _data.eigs(_data.to(_data.Dense, self.data),
                                       isherm=self._isherm,
                                       sort=sort, eigvals=eigvals)
@@ -1623,7 +1623,7 @@ def eigenenergies(self, sparse=False, sort='low',
                                   isherm=self._isherm,
                                   sort=sort, eigvals=eigvals,
                                   tol=tol, maxiter=maxiter)
-        elif isinstance(self.data, _data.CSR):
+        elif isinstance(self.data, (_data.CSR, _data.Dia)):
             return _data.eigs(_data.to(_data.Dense, self.data),
                               vecs=False, isherm=self._isherm,
                               sort=sort, eigvals=eigvals)
diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
index 60e027792b..5d7b963081 100644
--- a/qutip/solver/steadystate.py
+++ b/qutip/solver/steadystate.py
@@ -215,16 +215,16 @@ def _steadystate_direct(A, weight, **kw):
         if isinstance(L, _data.CSR):
             L, b = _permute_wbm(L, b)
         else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+            warn("Only CSR matrice can be permuted.", RuntimeWarning)
     use_rcm = False
     if kw.pop("use_rcm", False):
         if isinstance(L, _data.CSR):
             L, b, perm = _permute_rcm(L, b)
             use_rcm = True
         else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+            warn("Only CSR matrice can be permuted.", RuntimeWarning)
     if kw.pop("use_precond", False):
-        if isinstance(L, _data.CSR):
+        if isinstance(L, (_data.CSR, _data.Dia)):
             kw["M"] = _compute_precond(L, kw)
         else:
             warn("Only sparse solver use preconditioners.", RuntimeWarning)
@@ -271,16 +271,16 @@ def _steadystate_power(A, **kw):
         if isinstance(L, _data.CSR):
             L, y = _permute_wbm(L, y)
         else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+            warn("Only CSR matrice can be permuted.", RuntimeWarning)
     use_rcm = False
     if kw.pop("use_rcm", False):
         if isinstance(L, _data.CSR):
             L, y, perm = _permute_rcm(L, y)
             use_rcm = True
         else:
-            warn("Only sparse matrice can be permuted.", RuntimeWarning)
+            warn("Only CSR matrice can be permuted.", RuntimeWarning)
     if kw.pop("use_precond", False):
-        if isinstance(L, _data.CSR):
+        if isinstance(L, (_data.CSR, _data.Dia)):
             kw["M"] = _compute_precond(L, kw)
         else:
             warn("Only sparse solver use preconditioners.", RuntimeWarning)
@@ -504,8 +504,9 @@ def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
         LI = _data.Dense(scipy.linalg.pinv(A.to_array()), copy=False)
         LIQ = _data.matmul(LI, Q)
     elif method == "spilu":
-        if not isinstance(A, _data.CSR):
-            raise TypeError("'spilu' method can only be used with sparse data")
+        if not isinstance(A, (_data.CSR, _data.Dia)):
+            warn("'spilu' method can only be used with sparse data.")
+            A = _data.to(_data.CSR, A)
         ILU = scipy.sparse.linalg.spilu(A.as_scipy().tocsc(), **kwargs)
         LIQ = _data.Dense(ILU.solve(Q.to_array()))
     else:
diff --git a/qutip/tests/core/test_brtools.py b/qutip/tests/core/test_brtools.py
index 527ca89778..117b5b81bd 100644
--- a/qutip/tests/core/test_brtools.py
+++ b/qutip/tests/core/test_brtools.py
@@ -147,7 +147,7 @@ def test_br_term_linbblad_comp(func):
     diag = H.eigenenergies()
     skew =  np.einsum('i,j->ji', np.ones(N), diag) - diag * np.ones((N, N))
     spectrum = (skew > 0) * 1.
-    computation = func(A_op.data, spectrum, skew, 2).to_array()
+    computation = func(A_op.data, spectrum, skew, 1.5).to_array()
     lindblad = qutip.lindblad_dissipator(a).full()
     np.testing.assert_allclose(computation, lindblad, rtol=1e-14, atol=1e-14)
 
@@ -333,4 +333,4 @@ def test_bloch_redfield_tensor_spectral_callable():
         fock_basis=False
     )
     assert isinstance(R_eigs, qutip.Qobj)
-    assert isinstance(evecs, qutip.Qobj)
\ No newline at end of file
+    assert isinstance(evecs, qutip.Qobj)
diff --git a/qutip/tests/core/test_coefficient.py b/qutip/tests/core/test_coefficient.py
index 99eb7ea308..bb5204c611 100644
--- a/qutip/tests/core/test_coefficient.py
+++ b/qutip/tests/core/test_coefficient.py
@@ -294,7 +294,7 @@ def test_advance_use():
 from qutip.core.data cimport CSR
 from qutip.core.data.expect cimport expect_csr
 """)
-    csr = qutip.num(3).data
+    csr = qutip.num(3, dtype="CSR").data
     coeff = coefficient("expect_csr(op, op)",
                         args={"op": csr},
                         args_ctypes={"op": "CSR"},

From f996c0f05a36839b8bd75921851f08989ae2ca77 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 16 Jul 2023 17:00:19 +0900
Subject: [PATCH 513/602] add pytest

---
 qutip/tests/test_visualization.py | 54 +++++++++++++++++++++++++++++++
 qutip/visualization.py            |  6 ++--
 2 files changed, 57 insertions(+), 3 deletions(-)
 create mode 100644 qutip/tests/test_visualization.py

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
new file mode 100644
index 0000000000..a2b1dbd08f
--- /dev/null
+++ b/qutip/tests/test_visualization.py
@@ -0,0 +1,54 @@
+import pytest
+import qutip
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+
+@pytest.mark.parametrize('args', [
+    ({'reflections': True}),
+    ({'cmap': mpl.cm.cividis}),
+    ({'colorbar': False}),
+])
+def test_plot_wigner_sphere(args):
+    psi = qutip.rand_ket(5)
+    wigner = qutip.wigner_transform(psi, 2, False, 50, ["x"])
+
+    fig, ax = qutip.plot_wigner_sphere(wigner, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('args', [
+    ({}),
+    ({'options': {'zticks': [1]}}),
+    ({'x_basis': [1, 2, 3, 4, 5]}),
+    ({'y_basis': [1, 2, 3, 4, 5]}),
+    ({'limits': [0, 1]}),
+    ({'color_limits': [0, 1]}),
+    ({'color_style': 'phase'}),
+    ({'options': {'threshold': 0.1}}),
+    ({'color_style': 'real', 'colorbar': True}),
+    ({'color_style': 'img', 'colorbar': True}),
+    ({'color_style': 'abs', 'colorbar': True}),
+    ({'color_style': 'phase', 'colorbar': True}),
+    ({'color_limits': [0, 1], 'color_style': 'phase', 'colorbar': True})
+])
+def test_matrix_histogram(args):
+    rho = qutip.rand_dm(5)
+
+    fig, ax = qutip.matrix_histogram(rho, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_matrix_histogram_ValueError():
+    text = "options must be a dictionary"
+    with pytest.raises(ValueError) as exc_info:
+        fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
+                                         options='error')
+    assert str(exc_info.value) == text
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 0e8a4873de..1b40b1db02 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -543,7 +543,7 @@ def _update_yaxis(spacing, M, ax, ylabels):
     updates the y-axis
     """
     ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-    ax.axes.w_yaxis.set_major_locator(plt.FixedLocator(ytics))
+    ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
     if ylabels:
         nylabels = len(ylabels)
         if nylabels != len(ytics):
@@ -561,7 +561,7 @@ def _update_xaxis(spacing, M, ax, xlabels):
     updates the x-axis
     """
     xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
-    ax.axes.w_xaxis.set_major_locator(plt.FixedLocator(xtics))
+    ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
     if xlabels:
         nxlabels = len(xlabels)
         if nxlabels != len(xtics):
@@ -578,7 +578,7 @@ def _update_zaxis(ax, z_min, z_max, zticks):
     """
     updates the z-axis
     """
-    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
+    ax.zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
     if isinstance(zticks, list):
         ax.set_zticks(zticks)
     ax.set_zlim3d([min(z_min, 0), z_max])

From e652b3faa7e292bd78cd2c5eabc73daa895164d7 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 16 Jul 2023 18:45:25 +0900
Subject: [PATCH 514/602] add pytest

---
 qutip/tests/test_visualization.py | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index a2b1dbd08f..ef2605201d 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -46,9 +46,25 @@ def test_matrix_histogram(args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
-def test_matrix_histogram_ValueError():
+def test_matrix_histogram_zeros():
+    rho = qutip.Qobj([[0, 0], [0, 0]])
+
+    fig, ax = qutip.matrix_histogram(rho)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('args, expected', [
+    ({'options': 'error'}, ("options must be a dictionary")),
+    ({'options': {'e1': '1', 'e2': '2'}},
+     ("invalid key(s) found in options: e1, e2",
+      "invalid key(s) found in options: e2, e1")),
+])
+def test_matrix_histogram_ValueError(args, expected):
     text = "options must be a dictionary"
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
-                                         options='error')
-    assert str(exc_info.value) == text
+                                         **args)
+    assert str(exc_info.value) in expected

From 070e0e469fa40305e46b93abd1a7a13053b01e5d Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 16 Jul 2023 20:01:37 +0900
Subject: [PATCH 515/602] add pytest

---
 qutip/tests/test_visualization.py | 95 ++++++++++++++++++++++++++++++-
 1 file changed, 94 insertions(+), 1 deletion(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 2647aa6439..72f294517e 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -5,6 +5,81 @@
 import matplotlib.pyplot as plt
 
 
+def test_cyclic():
+    qutip.settings.colorblind_safe = True
+    rho = qutip.rand_dm(5)
+    fig, ax = qutip.hinton(rho, color_style='phase')
+    plt.close()
+    qutip.settings.colorblind_safe = False
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_diverging():
+    qutip.settings.colorblind_safe = True
+    rho = qutip.rand_dm(5)
+    fig, ax = qutip.hinton(rho)
+    plt.close()
+    qutip.settings.colorblind_safe = False
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_sequential():
+    qutip.settings.colorblind_safe = True
+    theta = np.linspace(0, np.pi, 90)
+    phi = np.linspace(0, 2 * np.pi, 60)
+
+    fig, ax = qutip.sphereplot(theta, phi,
+                               qutip.orbital(theta, phi, qutip.basis(3, 0)).T)
+    plt.close()
+    qutip.settings.colorblind_safe = False
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+@pytest.mark.parametrize('f, a, projection', [
+    (True, True, '2d'),
+    (True, True, '3d'),
+    (True, False, '2d'),
+    (True, False, '3d'),
+    (False, True, '2d'),
+    (False, True, '3d'),
+    (False, False, '2d'),
+    (False, False, '3d'),
+])
+def test_is_fig_and_ax(f, a, projection):
+    rho = qutip.rand_dm(5)
+
+    fig = plt.figure()
+    ax = None
+    if a:
+        if projection == '2d':
+            ax = fig.add_subplot(111)
+        else:
+            ax = fig.add_subplot(111, projection='3d')
+    if f is None:
+        fig = None
+
+    rho = qutip.rand_dm(5)
+    fig, ax = qutip.plot_wigner(rho, projection=projection,
+                                fig=fig, ax=ax)
+    plt.close()
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
+def test_set_ticklabels():
+    rho = qutip.rand_dm(5)
+    text = "got 1 ticklabels but needed 5"
+    with pytest.raises(Exception) as exc_info:
+        fig, ax = qutip.hinton(rho, x_basis=[1])
+    assert str(exc_info.value) == text
+
+
 def to_oper_bra(oper):
     return qutip.operator_to_vector(oper).dag()
 
@@ -34,6 +109,14 @@ def test_hinton(transform, args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_hinton1():
+    fig, ax = qutip.hinton(np.zeros((3, 3)))
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
 @pytest.mark.parametrize('transform, args, error_message', [
     (to_oper, {},
      "Input quantum object must be an operator or superoperator.")
@@ -183,7 +266,7 @@ def test_plot_expectation_values(n_of_results, n_of_e_ops, one_axes, args):
 
 @pytest.mark.filterwarnings(
     "ignore:The input coordinates to pcolor:UserWarning"
-    )
+)
 @pytest.mark.parametrize('color, args', [
     ('sequential', {}),
     ('diverging', {}),
@@ -225,6 +308,16 @@ def test_plot_spin_distribution_ValueError():
     assert str(exc_info.value) == text
 
 
+@pytest.mark.parametrize('args', [
+    ({}),
+    ({'theme': 'dark'}),
+])
+def test_complex_array_to_rgb(args):
+    Y = qutip.complex_array_to_rgb(np.zeros((3, 3)), **args)
+
+    assert isinstance(Y, np.ndarray)
+
+
 @pytest.mark.parametrize('dims, args', [
     (2, {}),
     (3, {}),

From 10cd3909dd00000bdc9619537351b74e88a7abd3 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 16 Jul 2023 20:25:46 +0900
Subject: [PATCH 516/602] add pytest

---
 qutip/tests/test_visualization.py | 58 +++++++++++++++++++++++++++++++
 qutip/visualization.py            |  4 +--
 2 files changed, 60 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index ef2605201d..f4f37fb9b0 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -21,6 +21,64 @@ def test_plot_wigner_sphere(args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+@pytest.mark.parametrize('response', [
+    ('normal'),
+    ('error')
+])
+def test_update_yaxis(response):
+    if response == 'normal':
+        fig, ax = qutip.hinton(np.zeros((3, 3)))
+        assert isinstance(fig, mpl.figure.Figure)
+        assert isinstance(ax, mpl.axes.Axes)
+    else:
+        text = "got 1 ylabels but needed 5"
+        with pytest.raises(ValueError) as exc_info:
+            fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
+                                             y_basis=[1])
+        assert str(exc_info.value) == text
+
+
+@pytest.mark.parametrize('response', [
+    ('normal'),
+    ('error')
+])
+def test_update_xaxis(response):
+    if response == 'normal':
+        fig, ax = qutip.hinton(np.zeros((3, 3)))
+        assert isinstance(fig, mpl.figure.Figure)
+        assert isinstance(ax, mpl.axes.Axes)
+    else:
+        text = "got 1 xlabels but needed 5"
+        with pytest.raises(ValueError) as exc_info:
+            fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
+                                             x_basis=[1])
+        assert str(exc_info.value) == text
+
+
+def test_get_matrix_components():
+    text = "got an unexpected argument, error for bar_style"
+    with pytest.raises(ValueError) as exc_info:
+        fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
+                                         bar_style='error')
+    assert str(exc_info.value) == text
+
+
+@pytest.mark.parametrize('args', [
+    ({'options': {'stick': True, 'azim': 45}}),
+    ({'options': {'stick': True, 'azim': 135}}),
+    ({'options': {'stick': True, 'azim': 225}}),
+    ({'options': {'stick': True, 'azim': 315}}),
+])
+def test_matrix_histogram(args):
+    rho = qutip.rand_dm(5)
+
+    fig, ax = qutip.matrix_histogram(rho, **args)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
+
 @pytest.mark.parametrize('args', [
     ({}),
     ({'options': {'zticks': [1]}}),
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 1b40b1db02..1522c78e3b 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -594,8 +594,8 @@ def _get_matrix_components(option, M, argument):
     elif option == 'phase':
         return angle(M.flatten())
     else:
-        raise ValueError(f"got an unexpected argument, \
-                         {option} for {argument}")
+        raise ValueError("got an unexpected argument, "
+                         f"{option} for {argument}")
 
 
 def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,

From be35c0d9107ff5e63e2c9799e756f52d47205e9b Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 16 Jul 2023 20:58:34 +0900
Subject: [PATCH 517/602] add pytest

---
 qutip/tests/test_visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 72f294517e..3e4a6d54da 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -61,7 +61,7 @@ def test_is_fig_and_ax(f, a, projection):
             ax = fig.add_subplot(111)
         else:
             ax = fig.add_subplot(111, projection='3d')
-    if f is None:
+    if not f:
         fig = None
 
     rho = qutip.rand_dm(5)

From fef43f4f0301bd2b14868fc98b7135e6f017dd87 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 16 Jul 2023 21:26:48 +0900
Subject: [PATCH 518/602] add pytest

---
 qutip/tests/test_visualization.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index f4f37fb9b0..48e6b06b04 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -27,7 +27,7 @@ def test_plot_wigner_sphere(args):
 ])
 def test_update_yaxis(response):
     if response == 'normal':
-        fig, ax = qutip.hinton(np.zeros((3, 3)))
+        fig, ax = qutip.matrix_histogram(np.zeros((3, 3)))
         assert isinstance(fig, mpl.figure.Figure)
         assert isinstance(ax, mpl.axes.Axes)
     else:
@@ -44,7 +44,7 @@ def test_update_yaxis(response):
 ])
 def test_update_xaxis(response):
     if response == 'normal':
-        fig, ax = qutip.hinton(np.zeros((3, 3)))
+        fig, ax = qutip.matrix_histogram(np.zeros((3, 3)))
         assert isinstance(fig, mpl.figure.Figure)
         assert isinstance(ax, mpl.axes.Axes)
     else:

From 87d9023819797a7113bfbbb113cef14a8cd2fae7 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 17 Jul 2023 18:17:50 +0900
Subject: [PATCH 519/602] bugfix

---
 qutip/visualization.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 1522c78e3b..9a8cee54cc 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -542,7 +542,7 @@ def _update_yaxis(spacing, M, ax, ylabels):
     """
     updates the y-axis
     """
-    ytics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+    ytics = [y + (1 - (spacing / 2)) for y in range(M.shape[1])]
     ax.yaxis.set_major_locator(plt.FixedLocator(ytics))
     if ylabels:
         nylabels = len(ylabels)
@@ -560,7 +560,7 @@ def _update_xaxis(spacing, M, ax, xlabels):
     """
     updates the x-axis
     """
-    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[1])]
+    xtics = [x + (1 - (spacing / 2)) for x in range(M.shape[0])]
     ax.xaxis.set_major_locator(plt.FixedLocator(xtics))
     if xlabels:
         nxlabels = len(xlabels)

From c24db0816ebccf11cbbd024c0317ac9a1653ecfb Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 17 Jul 2023 18:41:18 +0900
Subject: [PATCH 520/602] add pytest

---
 qutip/tests/test_visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 48e6b06b04..7d793f576a 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -69,7 +69,7 @@ def test_get_matrix_components():
     ({'options': {'stick': True, 'azim': 225}}),
     ({'options': {'stick': True, 'azim': 315}}),
 ])
-def test_matrix_histogram(args):
+def test_stick_to_planes(args):
     rho = qutip.rand_dm(5)
 
     fig, ax = qutip.matrix_histogram(rho, **args)

From 385746c25d245a6c9600461e5e9ab22f6b1275b3 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 17 Jul 2023 21:58:22 +0900
Subject: [PATCH 521/602] edit for review

---
 qutip/tests/test_visualization.py | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 3e4a6d54da..6150dde626 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -117,15 +117,12 @@ def test_hinton1():
     assert isinstance(ax, mpl.axes.Axes)
 
 
-@pytest.mark.parametrize('transform, args, error_message', [
-    (to_oper, {},
-     "Input quantum object must be an operator or superoperator.")
-])
-def test_hinton_ValueError0(transform, args, error_message):
-    rho = transform(qutip.basis(2, 0))
+def test_hinton_ValueError0():
+    text = "Input quantum object must be an operator or superoperator."
+    rho = qutip.basis(2, 0)
     with pytest.raises(ValueError) as exc_info:
-        fig, ax = qutip.hinton(rho, **args)
-    assert str(exc_info.value) == error_message
+        fig, ax = qutip.hinton(rho)
+    assert str(exc_info.value) == text
 
 
 @pytest.mark.parametrize('transform, args, error_message', [
@@ -359,14 +356,12 @@ def test_plot_qubism_Error(ket, args, expected):
     assert str(exc_info.value) == expected
 
 
-def test_plot_qubism_mock(monkeypatch: pytest.MonkeyPatch):
+def test_plot_qubism_dimension():
     text = "For 'pairs_skewed' pairs of dimensions need to be the same."
 
-    def mock_func(ket, kwarg):
-        return ket
-    monkeypatch.setattr("qutip.visualization.tensor", mock_func)
+    ket = qutip.basis(3) & qutip.basis(2)
     with pytest.raises(Exception) as exc_info:
-        qutip.plot_qubism(qutip.ket("010"), how='pairs_skewed')
+        qutip.plot_qubism(ket, how='pairs_skewed')
     assert str(exc_info.value) == text
 
 

From b7eaa5641bdf175c77802bdf1b0d91784fea007d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 17 Jul 2023 10:45:33 -0400
Subject: [PATCH 522/602] Add conversion

---
 qutip/solver/steadystate.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/steadystate.py b/qutip/solver/steadystate.py
index 5d7b963081..41fe9e4b63 100644
--- a/qutip/solver/steadystate.py
+++ b/qutip/solver/steadystate.py
@@ -469,7 +469,7 @@ def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
         method = "splu" if sparse else "pinv"
     sparse_solvers = ["splu", "mkl_spsolve", "spilu"]
     dense_solvers = ["solve", "lstsq", "pinv"]
-    if isinstance(L.data, _data.CSR) and method in dense_solvers:
+    if isinstance(L.data, (_data.CSR, _data.Dia)) and method in dense_solvers:
         L = L.to("dense")
     elif isinstance(L.data, _data.Dense) and method in sparse_solvers:
         L = L.to("csr")
@@ -488,7 +488,7 @@ def pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False,
     if w in [None, 0.0]:
         L += 1e-15j
     else:
-        L += 1.0j*w
+        L += 1.0j * w
 
     use_rcm = use_rcm and isinstance(L.data, _data.CSR)
 

From 58b1c031a2a5cfd602f5a3238083ace15227202b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 17 Jul 2023 11:50:07 -0400
Subject: [PATCH 523/602] mkl_solve only available for CSR

---
 qutip/tests/core/data/test_linalg.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index a731b8b5ea..474e8ca366 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -43,6 +43,7 @@ def test_mathematically_correct_sparse(self, method, opt, dtype):
         Test that the binary operation is mathematically correct for all the
         known type specialisations.
         """
+        pytest.skipif(dtype is Dia and method == "mkl_spsolve")
         A = self._gen_op(10, dtype)
         b = self._gen_ket(10, Dense)
         expected = self.op_numpy(A.to_array(), b.to_array())

From 6c2b696862a599e100609fa3e2291e98a24f1eb6 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 17 Jul 2023 12:11:57 -0400
Subject: [PATCH 524/602] Set version requirement to exclude cython 3

---
 pyproject.toml   | 2 +-
 requirements.txt | 2 +-
 setup.cfg        | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index f854fa46f5..7d2c629b6d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,7 @@ requires = [
     "setuptools",
     "packaging",
     "wheel",
-    "cython>=0.29.20",
+    "cython>=0.29.20,<3.0.0",
     # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
     # the recommended way to build against numpy's C API:
     "oldest-supported-numpy",
diff --git a/requirements.txt b/requirements.txt
index 41d2c09a1b..ce206d79dd 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
-cython>=0.29.20
+cython>=0.29.20,<3.0.0
 numpy>=1.16.6
 scipy>=1.5
 packaging
diff --git a/setup.cfg b/setup.cfg
index 1eb1f11cd2..c9297d3aec 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -37,7 +37,7 @@ install_requires =
 setup_requires =
     numpy>=1.13.3
     scipy>=1.0
-    cython>=0.29.20
+    cython>=0.29.20,<3.0.0
     packaging
 
 [options.packages.find]
@@ -46,7 +46,7 @@ include = qutip*
 [options.extras_require]
 graphics = matplotlib>=1.2.1
 runtime_compilation =
-    cython>=0.29.20
+    cython>=0.29.20,<3.0.0
     filelock
 semidefinite =
     cvxpy>=1.0

From c90c0b94a22d8900ba8e8e69a71c4a6185364426 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 17 Jul 2023 18:23:49 -0400
Subject: [PATCH 525/602] optimize dia dense matmul

---
 qutip/core/data/matmul.pyx                 | 99 +++++++++++++++++++++-
 qutip/core/data/src/matmul_diag_vector.cpp | 42 +++++++++
 qutip/core/data/src/matmul_diag_vector.hpp | 10 +++
 qutip/tests/core/data/test_mathematics.py  |  1 +
 4 files changed, 150 insertions(+), 2 deletions(-)

diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index fce32f1b09..36f409693f 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -3,6 +3,7 @@
 
 from libc.string cimport memset, memcpy
 from libc.math cimport fabs
+from libc.stdlib cimport abs
 from libcpp.algorithm cimport lower_bound
 
 import warnings
@@ -46,11 +47,14 @@ cdef extern from "src/matmul_diag_vector.hpp" nogil:
     void _matmul_diag_vector[T](
         double complex *data, double complex *vec, double complex *out,
         T length, double complex scale)
+    void _matmul_diag_block[T](
+        double complex *data, double complex *vec, double complex *out,
+        T length, T width)
 
 
 __all__ = [
     'matmul', 'matmul_csr', 'matmul_dense', 'matmul_dia',
-    'matmul_csr_dense_dense', 'matmul_dia_dense_dense',
+    'matmul_csr_dense_dense', 'matmul_dia_dense_dense', 'matmul_dense_dia_dense',
     'multiply', 'multiply_csr', 'multiply_dense', 'multiply_dia',
 ]
 
@@ -380,7 +384,22 @@ cpdef Dense matmul_dia_dense_dense(Dia left, Dense right, double complex scale=1
       strideR_out = tmp.shape[1] if not tmp.fortran else 1
       strideC_out = tmp.shape[0] if tmp.fortran else 1
 
-      if (strideR_in == 1) and (strideR_out == 1):
+      if (
+        (left.shape[0] == left.shape[1])
+        and (strideC_in == 1)
+        and (strideC_out == 1)
+      ):
+          #Fast track for easy case
+          for diag in range(left.num_diag):
+              _matmul_diag_block(
+                  right.data + max(0, left.offsets[diag]) * strideR_in,
+                  left.data + diag * left.shape[1] + max(0, left.offsets[diag]),
+                  tmp.data + max(0, -left.offsets[diag]) * strideR_out,
+                  left.shape[1] - abs(left.offsets[diag]),
+                  right.shape[1]
+              )
+
+      elif (strideR_in == 1) and (strideR_out == 1):
         for col in range(right.shape[1]):
           for diag in range(left.num_diag):
             start_left = max(0, left.offsets[diag])
@@ -423,6 +442,81 @@ cpdef Dense matmul_dia_dense_dense(Dia left, Dense right, double complex scale=1
     return out
 
 
+cpdef Dense matmul_dense_dia_dense(Dense left, Dia right, double complex scale=1, Dense out=None):
+    _check_shape(left, right, out)
+    cdef Dense tmp
+    if out is not None and scale == 1.:
+        tmp = out
+        out = None
+    else:
+        tmp = dense.zeros(left.shape[0], right.shape[1], left.fortran)
+
+    cdef idxint start_left, end_right, start_out, end_out, length, i, start_right
+    cdef idxint row, strideR_in, strideC_in, strideR_out, strideC_out
+    cdef size_t diag
+
+    with nogil:
+      strideR_in = left.shape[1] if not left.fortran else 1
+      strideC_in = left.shape[0] if left.fortran else 1
+      strideR_out = tmp.shape[1] if not tmp.fortran else 1
+      strideC_out = tmp.shape[0] if tmp.fortran else 1
+
+      if (
+        (right.shape[0] == right.shape[1])
+        and (strideR_in == 1)
+        and (strideR_out == 1)
+      ):
+          #Fast track for easy case
+          for diag in range(right.num_diag):
+              _matmul_diag_block(
+                  left.data + max(0, -right.offsets[diag]) * strideC_in,
+                  right.data + diag * right.shape[1] + max(0, right.offsets[diag]),
+                  tmp.data + max(0, right.offsets[diag]) * strideC_out,
+                  right.shape[1] - abs(right.offsets[diag]),
+                  left.shape[0]
+              )
+
+      elif (strideC_in == 1) and (strideC_out == 1):
+        for row in range(left.shape[0]):
+          for diag in range(right.num_diag):
+            start_right = max(0, right.offsets[diag])
+            end_right = min(right.shape[1], right.shape[0] + right.offsets[diag])
+            start_out = max(0, right.offsets[diag])
+            length = end_right - start_right
+            start_left = max(0, -right.offsets[diag]) + row * strideR_in
+            start_right += diag * right.shape[1]
+            start_out = max(0, right.offsets[diag]) + row * strideR_out
+            _matmul_diag_vector(
+                right.data + start_right,
+                left.data + start_left,
+                tmp.data + start_out,
+                length, 1.
+            )
+
+      else:
+        for row in range(left.shape[0]):
+          for diag in range(right.num_diag):
+            start_right = max(0, right.offsets[diag])
+            end_right = min(right.shape[1], right.shape[0] + right.offsets[diag])
+            start_left = max(0, -right.offsets[diag])
+            length = end_right - start_right
+            for i in range(length):
+              tmp.data[(start_right + i) * strideC_out + row * strideR_out] += (
+                right.data[diag * right.shape[1] + i + start_right]
+                * left.data[(start_left + i) * strideC_in + row * strideR_in]
+              )
+
+    if out is None and scale == 1.:
+        out = tmp
+    elif out is None:
+        imul_dense(tmp, scale)
+        out = tmp
+    else:
+        iadd_dense(out, tmp, scale)
+
+    return out
+
+
 cpdef CSR multiply_csr(CSR left, CSR right):
     """Element-wise multiplication of CSR matrices."""
     if left.shape[0] != right.shape[0] or left.shape[1] != right.shape[1]:
@@ -610,6 +704,7 @@ matmul.add_specialisations([
     (Dense, Dense, Dense, matmul_dense),
     (Dia, Dia, Dia, matmul_dia),
     (Dia, Dense, Dense, matmul_dia_dense_dense),
+    (Dense, Dia, Dense, matmul_dense_dia_dense),
 ], _defer=True)
 
 
diff --git a/qutip/core/data/src/matmul_diag_vector.cpp b/qutip/core/data/src/matmul_diag_vector.cpp
index a57654fc26..fbbf370b2e 100644
--- a/qutip/core/data/src/matmul_diag_vector.cpp
+++ b/qutip/core/data/src/matmul_diag_vector.cpp
@@ -40,3 +40,45 @@ template void _matmul_diag_vector<>(
         std::complex<double> * _RESTRICT,
         const long long,
         const std::complex<double>);
+
+template <typename IntT>
+void _matmul_diag_block(
+        const std::complex<double> * _RESTRICT data,
+        const std::complex<double> * _RESTRICT vec,
+        std::complex<double> * _RESTRICT out,
+        const IntT length,
+        const IntT width
+){
+    const double * data_dbl = reinterpret_cast<const double *>(data);
+    const double * vec_dbl = reinterpret_cast<const double *>(vec);
+    double * out_dbl = reinterpret_cast<double *>(out);
+    IntT ptr = 0;
+    // Gcc does not vectorize complex automatically?
+    for (IntT i=0; i<length; i++)
+      for (IntT j=0; j<width; j++){
+        out_dbl[ptr] += data_dbl[ptr] * vec_dbl[2*i];
+        out_dbl[ptr] -= data_dbl[ptr+1] * vec_dbl[2*i+1];
+        out_dbl[ptr+1] += data_dbl[ptr] * vec_dbl[2*i+1];
+        out_dbl[ptr+1] += data_dbl[ptr+1] * vec_dbl[2*i];
+        ptr+=2;
+    }
+}
+
+template void _matmul_diag_block<>(
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        std::complex<double> * _RESTRICT,
+        const int,
+        const int);
+template void _matmul_diag_block<>(
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        std::complex<double> * _RESTRICT,
+        const long,
+        const long);
+template void _matmul_diag_block<>(
+        const std::complex<double> * _RESTRICT,
+        const std::complex<double> * _RESTRICT,
+        std::complex<double> * _RESTRICT,
+        const long long,
+        const long long);
diff --git a/qutip/core/data/src/matmul_diag_vector.hpp b/qutip/core/data/src/matmul_diag_vector.hpp
index 0db3ce6271..f8e79aa624 100644
--- a/qutip/core/data/src/matmul_diag_vector.hpp
+++ b/qutip/core/data/src/matmul_diag_vector.hpp
@@ -14,3 +14,13 @@ void _matmul_diag_vector(
         const IntT length,
         const std::complex<double> scale
 );
+
+
+template <typename IntT>
+void _matmul_diag_block(
+        const std::complex<double> * _RESTRICT data,
+        const std::complex<double> * _RESTRICT vec,
+        std::complex<double> * _RESTRICT out,
+        const IntT length,
+        const IntT width
+);
diff --git a/qutip/tests/core/data/test_mathematics.py b/qutip/tests/core/data/test_mathematics.py
index 71d5c97717..8d30aa9763 100644
--- a/qutip/tests/core/data/test_mathematics.py
+++ b/qutip/tests/core/data/test_mathematics.py
@@ -790,6 +790,7 @@ def op_numpy(self, left, right):
         pytest.param(data.matmul_dense, Dense, Dense, Dense),
         pytest.param(data.matmul_dia, Dia, Dia, Dia),
         pytest.param(data.matmul_dia_dense_dense, Dia, Dense, Dense),
+        pytest.param(data.matmul_dense_dia_dense, Dense, Dia, Dense),
     ]
 
 

From 18eeb464a6a7ed852a3fdd3d414f31b70033b2ee Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Mon, 17 Jul 2023 19:23:51 -0400
Subject: [PATCH 526/602] skipif to if skip

---
 qutip/tests/core/data/test_linalg.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index 474e8ca366..5fa6acf8e7 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -43,7 +43,8 @@ def test_mathematically_correct_sparse(self, method, opt, dtype):
         Test that the binary operation is mathematically correct for all the
         known type specialisations.
         """
-        pytest.skipif(dtype is Dia and method == "mkl_spsolve")
+        if dtype is Dia and method == "mkl_spsolve":
+            pytest.mark.skip("mkl is not supported for dia matrix")
         A = self._gen_op(10, dtype)
         b = self._gen_ket(10, Dense)
         expected = self.op_numpy(A.to_array(), b.to_array())

From 37add2e3b209fbfd1b14d2a84a43a0e9bd0d0cc6 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 18 Jul 2023 20:11:58 +0900
Subject: [PATCH 527/602] changes for review

---
 qutip/visualization.py | 70 ++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 36 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 9a8cee54cc..5816ead17b 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -273,14 +273,14 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
         Determines how colors are assigned to each square:
 
         -  If set to ``"scaled"`` (default), each color is chosen by
-            passing the absolute value of the corresponding matrix
-            element into `cmap` with the sign of the real part.
+           passing the absolute value of the corresponding matrix
+           element into `cmap` with the sign of the real part.
         -  If set to ``"threshold"``, each square is plotted as
-            the maximum of `cmap` for the positive real part and as
-            the minimum for the negative part of the matrix element;
-            note that this generalizes `"threshold"` to complex numbers.
+           the maximum of `cmap` for the positive real part and as
+           the minimum for the negative part of the matrix element;
+           note that this generalizes `"threshold"` to complex numbers.
         -  If set to ``"phase"``, each color is chosen according to
-            the angle of the corresponding matrix element.
+           the angle of the corresponding matrix element.
 
     label_top : bool, default=True
         If True, x ticklabels will be placed on top, otherwise
@@ -600,7 +600,7 @@ def _get_matrix_components(option, M, argument):
 
 def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                      bar_style='real', color_limits=None, color_style='real',
-                     options=None, *, cmap=None, colorbar=True,
+                     options={}, *, cmap=None, colorbar=True,
                      fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
@@ -622,14 +622,13 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     bar_style : string, default="real"
 
         -  If set to ``"real"`` (default), each bar is plotted
-            as the real part of the corresponding matrix element
-            Determines how colors are assigned to each square:
+           as the real part of the corresponding matrix element
         -  If set to ``"img"``, each bar is plotted
-            as the imaginary part of the corresponding matrix element
+           as the imaginary part of the corresponding matrix element
         -  If set to ``"abs"``, each bar is plotted
-            as the absolute value of the corresponding matrix element
+           as the absolute value of the corresponding matrix element
         -  If set to ``"phase"`` (default), each bar is plotted
-            as the angle of the corresponding matrix element
+           as the angle of the corresponding matrix element
 
     color_limits : list/array with two float numbers, optional
         The limits of colorbar [min, max]
@@ -638,13 +637,13 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         Determines how colors are assigned to each square:
 
         -  If set to ``"real"`` (default), each color is chosen
-            according to the real part of the corresponding matrix element.
+           according to the real part of the corresponding matrix element.
         -  If set to ``"img"``, each color is chosen according to
-            the imaginary part of the corresponding matrix element.
+           the imaginary part of the corresponding matrix element.
         -  If set to ``"abs"``, each color is chosen according to
-            the absolute value of the corresponding matrix element.
+           the absolute value of the corresponding matrix element.
         -  If set to ``"phase"``, each color is chosen according to
-            the angle of the corresponding matrix element.
+           the angle of the corresponding matrix element.
 
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
@@ -658,7 +657,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
-    options : dict, optional
+    options : dict, defaut={}
         A dictionary containing extra options for the plot.
         The names (keys) and values of the options are
         described below:
@@ -726,9 +725,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                     'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
 
     # update default_opts from input options
-    if options is None:
-        pass
-    elif isinstance(options, dict):
+    if isinstance(options, dict):
         # check if keys in options dict are valid
         if set(options) - set(default_opts):
             raise ValueError("invalid key(s) found in options: "
@@ -736,6 +733,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         else:
             # updating default options
             default_opts.update(options)
+            options = default_opts
     else:
         raise ValueError("options must be a dictionary")
 
@@ -752,7 +750,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     xpos = xpos.T.flatten() + 0.5
     ypos = ypos.T.flatten() + 0.5
     zpos = np.zeros(n)
-    dx = dy = (1 - default_opts['bars_spacing']) * np.ones(n)
+    dx = dy = (1 - options['bars_spacing']) * np.ones(n)
 
     bar_M = _get_matrix_components(bar_style, M, 'bar_style')
 
@@ -796,43 +794,43 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     colors = cmap(norm(color_M))
 
-    colors[:, 3] = default_opts['bars_alpha']
+    colors[:, 3] = options['bars_alpha']
 
-    if default_opts['threshold'] is not None:
-        colors[:, 3] = 1 * (bar_M >= default_opts['threshold'])
+    if options['threshold'] is not None:
+        colors[:, 3] *= 1 * (bar_M >= options['threshold'])
 
-        idx, = np.where(bar_M < default_opts['threshold'])
+        idx, = np.where(bar_M < options['threshold'])
         bar_M[idx] = 0
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
-             edgecolors=default_opts['bars_edgecolor'],
-             linewidths=default_opts['bars_lw'],
-             shade=default_opts['shade'])
+             edgecolors=options['bars_edgecolor'],
+             linewidths=options['bars_lw'],
+             shade=options['shade'])
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
 
     # x axis
-    _update_xaxis(default_opts['bars_spacing'], M, ax, x_basis)
+    _update_xaxis(options['bars_spacing'], M, ax, x_basis)
 
     # y axis
-    _update_yaxis(default_opts['bars_spacing'], M, ax, y_basis)
+    _update_yaxis(options['bars_spacing'], M, ax, y_basis)
 
     # z axis
-    _update_zaxis(ax, z_min, z_max, default_opts['zticks'])
+    _update_zaxis(ax, z_min, z_max, options['zticks'])
 
     # stick to xz and yz plane
-    _stick_to_planes(default_opts['stick'],
-                     default_opts['azim'], ax, M,
-                     default_opts['bars_spacing'])
-    ax.view_init(azim=default_opts['azim'], elev=default_opts['elev'])
+    _stick_to_planes(options['stick'],
+                     options['azim'], ax, M,
+                     options['bars_spacing'])
+    ax.view_init(azim=options['azim'], elev=options['elev'])
 
     # color axis
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=default_opts['cbar_pad'])
+                                         pad=options['cbar_pad'])
         cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
         if color_style == 'real':

From d95a1a73482078bc4d14b96c5a95d410f0d9cfc0 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 18 Jul 2023 20:42:13 +0900
Subject: [PATCH 528/602] resolve conflict

---
 qutip/tests/test_visualization.py | 50 ++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 731432a92e..a6582af9b6 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -8,8 +8,10 @@
 def test_cyclic():
     qutip.settings.colorblind_safe = True
     rho = qutip.rand_dm(5)
+
     fig, ax = qutip.hinton(rho, color_style='phase')
     plt.close()
+
     qutip.settings.colorblind_safe = False
 
     assert isinstance(fig, mpl.figure.Figure)
@@ -19,8 +21,10 @@ def test_cyclic():
 def test_diverging():
     qutip.settings.colorblind_safe = True
     rho = qutip.rand_dm(5)
+
     fig, ax = qutip.hinton(rho)
     plt.close()
+
     qutip.settings.colorblind_safe = False
 
     assert isinstance(fig, mpl.figure.Figure)
@@ -35,6 +39,7 @@ def test_sequential():
     fig, ax = qutip.sphereplot(theta, phi,
                                qutip.orbital(theta, phi, qutip.basis(3, 0)).T)
     plt.close()
+
     qutip.settings.colorblind_safe = False
 
     assert isinstance(fig, mpl.figure.Figure)
@@ -64,10 +69,10 @@ def test_is_fig_and_ax(f, a, projection):
     if not f:
         fig = None
 
-    rho = qutip.rand_dm(5)
     fig, ax = qutip.plot_wigner(rho, projection=projection,
                                 fig=fig, ax=ax)
     plt.close()
+
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
 
@@ -75,6 +80,7 @@ def test_is_fig_and_ax(f, a, projection):
 def test_set_ticklabels():
     rho = qutip.rand_dm(5)
     text = "got 1 ticklabels but needed 5"
+
     with pytest.raises(Exception) as exc_info:
         fig, ax = qutip.hinton(rho, x_basis=[1])
     assert str(exc_info.value) == text
@@ -90,7 +96,11 @@ def test_plot_wigner_sphere(args):
     wigner = qutip.wigner_transform(psi, 2, False, 50, ["x"])
 
     fig, ax = qutip.plot_wigner_sphere(wigner, **args)
-  
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ax, mpl.axes.Axes)
+
 
 def to_oper_bra(oper):
     return qutip.operator_to_vector(oper).dag()
@@ -132,6 +142,7 @@ def test_hinton1():
 def test_hinton_ValueError0():
     text = "Input quantum object must be an operator or superoperator."
     rho = qutip.basis(2, 0)
+
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.hinton(rho)
     assert str(exc_info.value) == text
@@ -145,6 +156,7 @@ def test_hinton_ValueError0():
 ])
 def test_hinton_ValueError1(transform, args, error_message):
     rho = transform(qutip.rand_dm(5))
+
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.hinton(rho, **args)
     assert str(exc_info.value) == error_message
@@ -174,13 +186,17 @@ def test_sphereplot(args):
 def test_update_yaxis(response):
     if response == 'normal':
         fig, ax = qutip.matrix_histogram(np.zeros((3, 3)))
+        plt.close()
+
         assert isinstance(fig, mpl.figure.Figure)
         assert isinstance(ax, mpl.axes.Axes)
     else:
         text = "got 1 ylabels but needed 5"
+
         with pytest.raises(ValueError) as exc_info:
             fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
                                              y_basis=[1])
+
         assert str(exc_info.value) == text
 
 
@@ -191,10 +207,13 @@ def test_update_yaxis(response):
 def test_update_xaxis(response):
     if response == 'normal':
         fig, ax = qutip.matrix_histogram(np.zeros((3, 3)))
+        plt.close()
+
         assert isinstance(fig, mpl.figure.Figure)
         assert isinstance(ax, mpl.axes.Axes)
     else:
         text = "got 1 xlabels but needed 5"
+
         with pytest.raises(ValueError) as exc_info:
             fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
                                              x_basis=[1])
@@ -203,6 +222,7 @@ def test_update_xaxis(response):
 
 def test_get_matrix_components():
     text = "got an unexpected argument, error for bar_style"
+
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
                                          bar_style='error')
@@ -219,9 +239,11 @@ def test_stick_to_planes(args):
     rho = qutip.rand_dm(5)
 
     fig, ax = qutip.matrix_histogram(rho, **args)
+    plt.close()
+
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
-    
+
 
 @pytest.mark.parametrize('args', [
     ({}),
@@ -242,18 +264,22 @@ def test_matrix_histogram(args):
     rho = qutip.rand_dm(5)
 
     fig, ax = qutip.matrix_histogram(rho, **args)
+    plt.close()
+
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
-    
+
 
 def test_matrix_histogram_zeros():
     rho = qutip.Qobj([[0, 0], [0, 0]])
 
     fig, ax = qutip.matrix_histogram(rho)
+    plt.close()
+
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
 
-    
+
 @pytest.mark.parametrize('args, expected', [
     ({'options': 'error'}, ("options must be a dictionary")),
     ({'options': {'e1': '1', 'e2': '2'}},
@@ -262,11 +288,12 @@ def test_matrix_histogram_zeros():
 ])
 def test_matrix_histogram_ValueError(args, expected):
     text = "options must be a dictionary"
+
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
                                          **args)
     assert str(exc_info.value) in expected
-    
+
 
 @pytest.mark.parametrize('args', [
     ({'h_labels': ['H0', 'H0+Hint']}),
@@ -337,7 +364,6 @@ def test_plot_wigner_ValueError():
         rho = qutip.rand_dm(4)
 
         fig, ax = qutip.plot_wigner(rho, projection=1)
-        plt.close()
     assert str(exc_info.value) == text
 
 
@@ -413,6 +439,7 @@ def test_plot_spin_distribution_ValueError():
     theta = np.linspace(0, np.pi, 50)
     phi = np.linspace(0, 2 * np.pi, 50)
     Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
+
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.plot_spin_distribution(Q, THETA, PHI, projection=1)
     assert str(exc_info.value) == text
@@ -424,6 +451,7 @@ def test_plot_spin_distribution_ValueError():
 ])
 def test_complex_array_to_rgb(args):
     Y = qutip.complex_array_to_rgb(np.zeros((3, 3)), **args)
+    plt.close()
 
     assert isinstance(Y, np.ndarray)
 
@@ -451,7 +479,7 @@ def test_plot_qubism(dims, args):
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
 
-   
+
 @pytest.mark.parametrize('ket, args, expected', [
     (False, {}, "Qubism works only for pure states, i.e. kets."),
     (True, {'how': 'error'}, "No such 'how'."),
@@ -464,6 +492,7 @@ def test_plot_qubism_Error(ket, args, expected):
         state = qutip.ket("01")
     else:
         state = qutip.bra("01")
+
     with pytest.raises(Exception) as exc_info:
         fig, ax = qutip.plot_qubism(state, **args)
     assert str(exc_info.value) == expected
@@ -473,6 +502,7 @@ def test_plot_qubism_dimension():
     text = "For 'pairs_skewed' pairs of dimensions need to be the same."
 
     ket = qutip.basis(3) & qutip.basis(2)
+
     with pytest.raises(Exception) as exc_info:
         qutip.plot_qubism(ket, how='pairs_skewed')
     assert str(exc_info.value) == text
@@ -491,11 +521,11 @@ def test_plot_schmidt(args):
     assert isinstance(fig, mpl.figure.Figure)
     assert isinstance(ax, mpl.axes.Axes)
 
-    
+
 def test_plot_schmidt_Error():
     state = qutip.bra("01")
     text = "Schmidt plot works only for pure states, i.e. kets."
+
     with pytest.raises(Exception) as exc_info:
         fig, ax = qutip.plot_schmidt(state)
     assert str(exc_info.value) == text
-

From cdacc65fb342b2da84087fea26c769d7632f8a48 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 18 Jul 2023 10:32:09 -0400
Subject: [PATCH 529/602] Fix seed

---
 qutip/tests/solver/test_results.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/qutip/tests/solver/test_results.py b/qutip/tests/solver/test_results.py
index 3aa46982c9..a4830460ef 100644
--- a/qutip/tests/solver/test_results.py
+++ b/qutip/tests/solver/test_results.py
@@ -170,6 +170,8 @@ def e_op_num(t, state):
 class TestMultiTrajResult:
     def _fill_trajectories(self, multiresult, N, ntraj,
                            collapse=False, noise=0, dm=False):
+        # Fix the seed to avoid failing due to bad luck
+        np.random.seed(1)
         for _ in range(ntraj):
             result = Result(multiresult._raw_ops, multiresult.options)
             result.collapse = []

From 22f94faa645b42ff74d0e61a7ce8cf950f33fc2f Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Wed, 19 Jul 2023 17:28:58 +0900
Subject: [PATCH 530/602] add indent

---
 qutip/visualization.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 5816ead17b..51ab52f17b 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -705,6 +705,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         'threshold': float, optional
             Threshold for when bars of smaller height should be transparent. If
             not set, all bars are colored according to the color map.
+
     Returns
     -------
     fig, ax : tuple

From 37e38103ee69bbc0d184949afee3d6759e7ab29e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Wed, 19 Jul 2023 14:35:34 -0400
Subject: [PATCH 531/602] fix skip test

---
 qutip/tests/core/data/test_linalg.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/core/data/test_linalg.py b/qutip/tests/core/data/test_linalg.py
index 5fa6acf8e7..56a1bb2b6b 100644
--- a/qutip/tests/core/data/test_linalg.py
+++ b/qutip/tests/core/data/test_linalg.py
@@ -44,7 +44,7 @@ def test_mathematically_correct_sparse(self, method, opt, dtype):
         known type specialisations.
         """
         if dtype is Dia and method == "mkl_spsolve":
-            pytest.mark.skip("mkl is not supported for dia matrix")
+            pytest.skip("mkl is not supported for dia matrix")
         A = self._gen_op(10, dtype)
         b = self._gen_ket(10, Dense)
         expected = self.op_numpy(A.to_array(), b.to_array())

From 2e9d45226f7ecd367475624f5fe0e049973f7b35 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 20 Jul 2023 12:18:17 +0000
Subject: [PATCH 532/602] Bump pygments from 2.14.0 to 2.15.0 in /doc

Bumps [pygments](https://github.com/pygments/pygments) from 2.14.0 to 2.15.0.
- [Release notes](https://github.com/pygments/pygments/releases)
- [Changelog](https://github.com/pygments/pygments/blob/master/CHANGES)
- [Commits](https://github.com/pygments/pygments/compare/2.14.0...2.15.0)

---
updated-dependencies:
- dependency-name: pygments
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 doc/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index c6b86832c8..620f971a0f 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -24,7 +24,7 @@ pickleshare==0.7.5
 Pillow==9.4.0
 prompt-toolkit==3.0.38
 ptyprocess==0.7.0
-Pygments==2.14.0
+Pygments==2.15.0
 pyparsing==3.0.9
 python-dateutil==2.8.2
 pytz==2023.3

From d6a845c7180d5c4f43c256e0cc25aa94ae85f193 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Thu, 20 Jul 2023 16:07:43 -0400
Subject: [PATCH 533/602] Add towncrier entry

---
 doc/changes/2196.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2196.feature

diff --git a/doc/changes/2196.feature b/doc/changes/2196.feature
new file mode 100644
index 0000000000..0113111d59
--- /dev/null
+++ b/doc/changes/2196.feature
@@ -0,0 +1 @@
+Add Dia data layer

From 5ed3d45e00307c2f3929579c34b28e10220ea036 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 24 Jul 2023 15:02:35 +0900
Subject: [PATCH 534/602] add animation functions

---
 qutip/visualization.py | 203 ++++++++++++++++++++++++++++++++---------
 1 file changed, 161 insertions(+), 42 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 51ab52f17b..c56aa5f53d 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,13 +7,18 @@
            'matrix_histogram', 'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
            'plot_spin_distribution', 'complex_array_to_rgb',
-           'plot_qubism', 'plot_schmidt']
+           'plot_qubism', 'plot_schmidt', 'anim_matrix_histogram',
+           'anim_fock_distribution', 'anim_wigner']
 
 import warnings
 import itertools as it
 import numpy as np
-from numpy import pi, array, sin, cos, angle, log2
+import os
 
+from numpy import pi, array, sin, cos, angle, log2
+from functools import partial
+from IPython.display import HTML
+from base64 import b64encode
 from packaging.version import parse as parse_version
 
 from . import (
@@ -26,6 +31,7 @@
 
 try:
     import matplotlib.pyplot as plt
+    import matplotlib.animation as animation
     import matplotlib as mpl
     from matplotlib import cm
     from mpl_toolkits.mplot3d import Axes3D
@@ -64,7 +70,7 @@ def _sequential_cmap():
         return cm.jet
 
 
-def _is_fig_and_ax(fig, ax, projection='2d'):
+def _same_fig_and_ax(fig, ax, projection='2d'):
     if fig is None:
         if ax is None:
             fig = plt.figure()
@@ -136,7 +142,7 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     Special thanks to Russell P Rundle for writing this function.
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+    fig, ax = _same_fig_and_ax(fig, ax, projection='3d')
 
     if cmap is None:
         cmap = _diverging_cmap()
@@ -326,7 +332,7 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
     >>> fig.show()
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax)
+    fig, ax = _same_fig_and_ax(fig, ax)
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):
@@ -470,7 +476,7 @@ def sphereplot(theta, phi, values, *,
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
     """
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+    fig, ax = _same_fig_and_ax(fig, ax, projection='3d')
 
     if cmap is None:
         cmap = _sequential_cmap()
@@ -600,8 +606,8 @@ def _get_matrix_components(option, M, argument):
 
 def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                      bar_style='real', color_limits=None, color_style='real',
-                     options={}, *, cmap=None, colorbar=True,
-                     fig=None, ax=None):
+                     options=None, *, cmap=None, colorbar=True,
+                     colorbar_opts=None, fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -657,7 +663,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
-    options : dict, defaut={}
+    options : dict, optional
         A dictionary containing extra options for the plot.
         The names (keys) and values of the options are
         described below:
@@ -693,15 +699,6 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             XZ and YZ planes will stick to those planes.
             This option has no effect if ``ax`` is passed as a parameter.
 
-        'cbar_pad' : float, default=0.04
-            The fraction of the original axes between the colorbar
-            and the new image axes.
-            (i.e. the padding between the 3D figure and the colorbar).
-
-        'cbar_to_z' : bool, default=False
-            Whether to set the color of maximum and minimum z-values to the
-            maximum and minimum colors in the colorbar (True) or not (False).
-
         'threshold': float, optional
             Threshold for when bars of smaller height should be transparent. If
             not set, all bars are colored according to the color map.
@@ -719,13 +716,19 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     """
 
+    if colorbar_opts is None:
+        colorbar_opts = dict()
+
     # default options
     default_opts = {'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
                     'shade': True, 'azim': -35, 'elev': 35, 'stick': False,
-                    'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
+                    'cbar_pad': 0.04, 'threshold': None}
 
     # update default_opts from input options
+    if options is None:
+        options = dict()
+
     if isinstance(options, dict):
         # check if keys in options dict are valid
         if set(options) - set(default_opts):
@@ -785,6 +788,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             c_max += 0.1
 
     norm = mpl.colors.Normalize(c_min, c_max)
+    colorbar_opts['norm'] = norm
 
     if cmap is None:
         # change later
@@ -793,6 +797,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         else:
             cmap = _sequential_cmap()
 
+    colorbar_opts['cmap'] = cmap
+
     colors = cmap(norm(color_M))
 
     colors[:, 3] = options['bars_alpha']
@@ -803,7 +809,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         idx, = np.where(bar_M < options['threshold'])
         bar_M[idx] = 0
 
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+    fig, ax = _same_fig_and_ax(fig, ax, projection='3d')
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
              edgecolors=options['bars_edgecolor'],
@@ -830,21 +836,20 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=options['cbar_pad'])
-        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cax, kw = mpl.colorbar.make_axes(ax, **colorbar_opts)
+        cbar = mpl.colorbar.ColorbarBase(cax, **kw)
 
         if color_style == 'real':
-            cb.set_label('real')
+            cbar.set_label('real')
         elif color_style == 'img':
-            cb.set_label('imaginary')
+            cbar.set_label('imaginary')
         elif color_style == 'abs':
-            cb.set_label('absolute')
+            cbar.set_label('absolute')
         else:
-            cb.set_label('arg')
+            cbar.set_label('arg')
             if color_limits is None:
-                cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-                cb.set_ticklabels(
+                cbar.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+                cbar.set_ticklabels(
                     (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
 
     # removing margins
@@ -899,7 +904,7 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
 
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax)
+    fig, ax = _same_fig_and_ax(fig, ax)
     ax.set_frame_on(False)
 
     if not isinstance(H_list, list):
@@ -987,7 +992,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
         the figure.
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax)
+    fig, ax = _same_fig_and_ax(fig, ax)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -997,8 +1002,9 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
     ax.bar(np.arange(N), np.real(rho.diag()),
            color=color, alpha=0.6, width=0.8)
 
-    if fock_numbers:
-        _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
+    if fock_numbers is None:
+        fock_numbers = np.arange(N)
+    _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
 
     if unit_y_range:
         ax.set_ylim(0, 1)
@@ -1011,7 +1017,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
 
 def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
                 projection='2d', *, cmap=None, colorbar=False,
-                fig=None, ax=None):
+                color_limits=None, colorbar_opts=None, fig=None, ax=None):
     """
     Plot the the Wigner function for a density matrix (or ket) that describes
     an oscillator mode.
@@ -1028,6 +1034,9 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         y-coordinates at which to calculate the Wigner function.  Does not
         apply to the 'fft' method.
 
+    color_limits : list/array with two float numbers, optional
+        The limits of colorbar [min, max]
+
     method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
         default='clenshaw'
         The method used for calculating the wigner function. See the
@@ -1044,6 +1053,9 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         Whether (True) or not (False) a colorbar should be attached to the
         Wigner function graph.
 
+    colorbar_opts : dict, optional
+        Options for the colorbar axes and the colorbar instance.
+
     fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
@@ -1057,9 +1069,15 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         the figure.
     """
 
+    if colorbar_opts is None:
+        colorbar_opts = dict()
+
+    if not isinstance(colorbar_opts, dict):
+        raise ValueError('colorbar_opts must be a dictionary')
+
     if projection not in ('2d', '3d'):
         raise ValueError('Unexpected value of projection keyword argument')
-    fig, ax = _is_fig_and_ax(fig, ax, projection)
+    fig, ax = _same_fig_and_ax(fig, ax, projection)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1073,10 +1091,18 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
 
-    wlim = abs(W).max()
-    norm = mpl.colors.Normalize(-wlim, wlim)
+    if isinstance(color_limits, list) and \
+            len(color_limits) == 2:
+        norm = mpl.colors.Normalize(color_limits[0], color_limits[1])
+    else:
+        wlim = abs(W).max()
+        norm = mpl.colors.Normalize(-wlim, wlim)
+
+    colorbar_opts['norm'] = norm
+
     if cmap is None:
         cmap = _diverging_cmap()
+        colorbar_opts['cmap'] = cmap
 
     if projection == '2d':
         cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap)
@@ -1089,8 +1115,8 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, pad=.1)
-        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cax, kw = mpl.colorbar.make_axes(ax, **colorbar_opts)
+        cbar = mpl.colorbar.ColorbarBase(cax, **kw)
 
     ax.set_title("Wigner function", fontsize=12)
 
@@ -1195,7 +1221,7 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     """
 
     if projection in ('2d', '3d'):
-        fig, ax = _is_fig_and_ax(fig, ax, projection)
+        fig, ax = _same_fig_and_ax(fig, ax, projection)
     else:
         raise ValueError('Unexpected value of projection keyword argument')
     if cmap is None:
@@ -1471,7 +1497,7 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
        (2012), open access.
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax)
+    fig, ax = _same_fig_and_ax(fig, ax)
 
     if not isket(ket):
         raise Exception("Qubism works only for pure states, i.e. kets.")
@@ -1617,7 +1643,7 @@ def plot_schmidt(ket, theme='light', splitting=None,
 
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax)
+    fig, ax = _same_fig_and_ax(fig, ax)
 
     if not isket(ket):
         raise Exception("Schmidt plot works only for pure states, i.e. kets.")
@@ -1670,3 +1696,96 @@ def plot_schmidt(ket, theme='light', splitting=None,
               extent=(0, size_x, 0, size_y))
 
     return fig, ax
+
+
+def _same_fig(fig, func_options):
+    if fig is None:
+        if 'fig' not in func_options.keys():
+            fig = plt.figure()
+            func_options['fig'] = fig
+        else:
+            fig = func_options['fig']
+    else:
+        if 'fig' not in func_options.keys():
+            func_options['fig'] = fig
+        else:
+            error = "fig and func_options['fig'] must be the same"
+            if fig != func_options['fig']:
+                raise ValueError(error)
+
+    return fig, func_options
+
+
+def _is_options(options, arg_name):
+    if options is None:
+        options = dict()
+
+    if not isinstance(options, dict):
+        raise TypeError(str(arg_name) + " must be a dict")
+
+    return options
+
+
+def _delete_axes(fig):
+    for ax in fig.axes:
+        fig.delaxes(ax)
+
+
+def _default_setup(ax, frame):
+    return ax
+
+
+def make_html_video(ani):
+    file_name = 'animation_for_video.mp4'
+    ani.save(file_name, fps=10)
+    video = open(file_name, "rb").read()
+    os.remove(file_name)
+    video_encoded = b64encode(video).decode("ascii")
+    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
+        video_encoded)
+
+    return ani, HTML(video_tag)
+
+
+def _make_anim(func_to_anim, list_of_obj, setup_ax=None,
+               func_options=None, anim_options=None, fig=None):
+
+    func_options = _is_options(func_options, "func_options")
+
+    anim_options = _is_options(anim_options, "anim_options")
+    if 'frames' not in anim_options.keys():
+        anim_options['frames'] = len(list_of_obj)
+
+    fig, func_options = _same_fig(fig, func_options)
+
+    if setup_ax is None:
+        setup_ax = _default_setup
+
+    def func(frame, list_of_obj, func_options):
+        _delete_axes(fig)
+        _, ax = func_to_anim(list_of_obj[frame], **func_options)
+        ax = setup_ax(ax, frame)
+
+    update = partial(func, list_of_obj=list_of_obj, func_options=func_options)
+    ani = animation.FuncAnimation(fig, update, **anim_options)
+    plt.close()
+
+    return make_html_video(ani)
+
+
+def anim_wigner(rhos, setup_ax=None, func_options=None,
+                anim_options=None, fig=None):
+    return _make_anim(plot_wigner, rhos, setup_ax, func_options,
+                      anim_options, fig)
+
+
+def anim_fock_distribution(rhos, setup_ax=None, func_options=None,
+                           anim_options=None, fig=None):
+    return _make_anim(plot_fock_distribution, rhos, setup_ax, func_options,
+                      anim_options, fig)
+
+
+def anim_matrix_histogram(rhos, setup_ax=None, func_options=None,
+                          anim_options=None, fig=None):
+    return _make_anim(matrix_histogram, rhos, setup_ax, func_options,
+                      anim_options, fig)

From 865821b0a85dca9ebe20fe03455d30533260d271 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Tue, 25 Jul 2023 21:32:23 +0900
Subject: [PATCH 535/602] sample commit

---
 qutip/__init__.py      |   1 +
 qutip/animation.py     | 201 +++++++++++++++++++++++++++++++++++++++++
 qutip/visualization.py | 160 ++++----------------------------
 3 files changed, 222 insertions(+), 140 deletions(-)
 create mode 100644 qutip/animation.py

diff --git a/qutip/__init__.py b/qutip/__init__.py
index ccd47ddc1b..534d51b795 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -38,6 +38,7 @@
 # graphics
 from .bloch import *
 from .visualization import *
+from .animation import *
 from .orbital import *
 from .bloch3d import *
 from .matplotlib_utilities import *
diff --git a/qutip/animation.py b/qutip/animation.py
new file mode 100644
index 0000000000..92a560ccd0
--- /dev/null
+++ b/qutip/animation.py
@@ -0,0 +1,201 @@
+"""
+Functions for creating animations of results of quantum dynamics simulations,
+visualizations of quantum states and processes.
+"""
+
+__all__ = ['anim_wigner']
+
+import warnings
+import itertools as it
+import numpy as np
+from numpy import pi, array, sin, cos, angle, log2
+
+from packaging.version import parse as parse_version
+
+from . import (
+    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
+)
+from .core.dimensions import flatten
+from .core.superop_reps import _to_superpauli, isqubitdims
+from .wigner import wigner
+from .matplotlib_utilities import complex_phase_cmap
+
+try:
+    import matplotlib.pyplot as plt
+    import matplotlib as mpl
+    from matplotlib import cm
+    from mpl_toolkits.mplot3d import Axes3D
+
+    # Define a custom _axes3D function based on the matplotlib version.
+    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
+    if parse_version(mpl.__version__) >= parse_version('3.4'):
+        def _axes3D(fig, *args, **kwargs):
+            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
+            return fig.add_axes(ax)
+    else:
+        def _axes3D(*args, **kwargs):
+            return Axes3D(*args, **kwargs)
+except:
+    pass
+
+import os
+from functools import partial
+from IPython.display import HTML
+from base64 import b64encode
+import matplotlib.animation as animation
+from qutip import plot_wigner
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+from . import matrix_histogram, plot_wigner
+
+
+def _same_fig(fig, func_options):
+    if fig is None:
+        if 'fig' not in func_options.keys():
+            fig = plt.figure()
+            func_options['fig'] = fig
+        else:
+            fig = func_options['fig']
+    else:
+        if 'fig' not in func_options.keys():
+            func_options['fig'] = fig
+        else:
+            error = "fig and func_options['fig'] must be the same"
+            if fig != func_options['fig']:
+                raise ValueError(error)
+
+    return fig, func_options
+
+
+def _is_options(options, arg_name):
+    if options is None:
+        options = dict()
+
+    if not isinstance(options, dict):
+        raise TypeError(str(arg_name) + " must be a dict")
+
+    return options
+
+
+def _delete_axes(fig):
+    for ax in fig.axes:
+        fig.delaxes(ax)
+
+
+def _default_setup(ax, frame):
+    return ax
+
+
+def make_html_video(ani):
+    file_name = 'animation_for_video.mp4'
+    ani.save(file_name, fps=10)
+    video = open(file_name, "rb").read()
+    os.remove(file_name)
+    video_encoded = b64encode(video).decode("ascii")
+    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
+        video_encoded)
+
+    return ani, HTML(video_tag)
+
+
+def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
+                projection='2d', *, cmap=None, colorbar=False,
+                fig=None, ax=None):
+    """
+    Plot the the Wigner function for a density matrix (or ket) that describes
+    an oscillator mode.
+
+    Parameters
+    ----------
+    rho : :class:`qutip.Qobj`
+        The density matrix (or ket) of the state to visualize.
+
+    xvec : array_like, optional
+        x-coordinates at which to calculate the Wigner function.
+
+    yvec : array_like, optional
+        y-coordinates at which to calculate the Wigner function.  Does not
+        apply to the 'fft' method.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
+        default='clenshaw'
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}, default='2d'
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    cmap : a matplotlib cmap instance, optional
+        The colormap.
+
+    colorbar : bool, default=False
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if projection not in ('2d', '3d'):
+        raise ValueError('Unexpected value of projection keyword argument')
+    if projection == '2d':
+        fig = plt.figure()
+        ax = fig.add_subplot(111)
+    else:
+        fig = plt.figure()
+        ax = fig.add_subplot(111, projection='3d')
+
+    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
+    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+    ax.set_title("Wigner function", fontsize=12)
+    wlim = -1
+    Ws = list()
+    artist_list = list()
+
+    for rho in rhos:
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        if xvec is None:
+            xvec = np.linspace(-7.5, 7.5, 200)
+        if yvec is None:
+            yvec = np.linspace(-7.5, 7.5, 200)
+
+        W0 = wigner(rho, xvec, yvec, method=method)
+
+        W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
+        Ws.append(W)
+
+        wlim = max(abs(W).max(), wlim)
+
+    norm = mpl.colors.Normalize(-wlim, wlim)
+    if cmap is None:
+        cmap = mpl.cm.RdBu
+
+    for W in Ws:
+        if projection == '2d':
+            cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap).collections
+        else:
+            X, Y = np.meshgrid(xvec, yvec)
+            cf = [ax.plot_surface(X, Y, W, rstride=5, cstride=5, linewidth=0.5,
+                                norm=norm, cmap=cmap)]
+        artist_list.append(cf)
+
+
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, pad=.1)
+        cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50, blit=True,
+                                repeat_delay=1000)
+    return make_html_video(ani)
diff --git a/qutip/visualization.py b/qutip/visualization.py
index c56aa5f53d..87a61fb521 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,18 +7,13 @@
            'matrix_histogram', 'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
            'plot_spin_distribution', 'complex_array_to_rgb',
-           'plot_qubism', 'plot_schmidt', 'anim_matrix_histogram',
-           'anim_fock_distribution', 'anim_wigner']
+           'plot_qubism', 'plot_schmidt']
 
 import warnings
 import itertools as it
 import numpy as np
-import os
-
 from numpy import pi, array, sin, cos, angle, log2
-from functools import partial
-from IPython.display import HTML
-from base64 import b64encode
+
 from packaging.version import parse as parse_version
 
 from . import (
@@ -31,7 +26,6 @@
 
 try:
     import matplotlib.pyplot as plt
-    import matplotlib.animation as animation
     import matplotlib as mpl
     from matplotlib import cm
     from mpl_toolkits.mplot3d import Axes3D
@@ -70,7 +64,7 @@ def _sequential_cmap():
         return cm.jet
 
 
-def _same_fig_and_ax(fig, ax, projection='2d'):
+def _is_fig_and_ax(fig, ax, projection='2d'):
     if fig is None:
         if ax is None:
             fig = plt.figure()
@@ -142,7 +136,7 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     Special thanks to Russell P Rundle for writing this function.
     """
 
-    fig, ax = _same_fig_and_ax(fig, ax, projection='3d')
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     if cmap is None:
         cmap = _diverging_cmap()
@@ -332,7 +326,7 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
     >>> fig.show()
     """
 
-    fig, ax = _same_fig_and_ax(fig, ax)
+    fig, ax = _is_fig_and_ax(fig, ax)
 
     # Extract plotting data W from the input.
     if isinstance(rho, Qobj):
@@ -476,7 +470,7 @@ def sphereplot(theta, phi, values, *,
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
     """
-    fig, ax = _same_fig_and_ax(fig, ax, projection='3d')
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     if cmap is None:
         cmap = _sequential_cmap()
@@ -809,7 +803,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         idx, = np.where(bar_M < options['threshold'])
         bar_M[idx] = 0
 
-    fig, ax = _same_fig_and_ax(fig, ax, projection='3d')
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
              edgecolors=options['bars_edgecolor'],
@@ -904,7 +898,7 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
 
     """
 
-    fig, ax = _same_fig_and_ax(fig, ax)
+    fig, ax = _is_fig_and_ax(fig, ax)
     ax.set_frame_on(False)
 
     if not isinstance(H_list, list):
@@ -992,7 +986,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
         the figure.
     """
 
-    fig, ax = _same_fig_and_ax(fig, ax)
+    fig, ax = _is_fig_and_ax(fig, ax)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1002,9 +996,8 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
     ax.bar(np.arange(N), np.real(rho.diag()),
            color=color, alpha=0.6, width=0.8)
 
-    if fock_numbers is None:
-        fock_numbers = np.arange(N)
-    _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
+    if fock_numbers:
+        _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
 
     if unit_y_range:
         ax.set_ylim(0, 1)
@@ -1017,7 +1010,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
 
 def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
                 projection='2d', *, cmap=None, colorbar=False,
-                color_limits=None, colorbar_opts=None, fig=None, ax=None):
+                fig=None, ax=None):
     """
     Plot the the Wigner function for a density matrix (or ket) that describes
     an oscillator mode.
@@ -1034,9 +1027,6 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         y-coordinates at which to calculate the Wigner function.  Does not
         apply to the 'fft' method.
 
-    color_limits : list/array with two float numbers, optional
-        The limits of colorbar [min, max]
-
     method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
         default='clenshaw'
         The method used for calculating the wigner function. See the
@@ -1053,9 +1043,6 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         Whether (True) or not (False) a colorbar should be attached to the
         Wigner function graph.
 
-    colorbar_opts : dict, optional
-        Options for the colorbar axes and the colorbar instance.
-
     fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
@@ -1069,15 +1056,9 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         the figure.
     """
 
-    if colorbar_opts is None:
-        colorbar_opts = dict()
-
-    if not isinstance(colorbar_opts, dict):
-        raise ValueError('colorbar_opts must be a dictionary')
-
     if projection not in ('2d', '3d'):
         raise ValueError('Unexpected value of projection keyword argument')
-    fig, ax = _same_fig_and_ax(fig, ax, projection)
+    fig, ax = _is_fig_and_ax(fig, ax, projection)
 
     if isket(rho):
         rho = ket2dm(rho)
@@ -1091,18 +1072,10 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
 
-    if isinstance(color_limits, list) and \
-            len(color_limits) == 2:
-        norm = mpl.colors.Normalize(color_limits[0], color_limits[1])
-    else:
-        wlim = abs(W).max()
-        norm = mpl.colors.Normalize(-wlim, wlim)
-
-    colorbar_opts['norm'] = norm
-
+    wlim = abs(W).max()
+    norm = mpl.colors.Normalize(-wlim, wlim)
     if cmap is None:
         cmap = _diverging_cmap()
-        colorbar_opts['cmap'] = cmap
 
     if projection == '2d':
         cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap)
@@ -1115,8 +1088,8 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, **colorbar_opts)
-        cbar = mpl.colorbar.ColorbarBase(cax, **kw)
+        cax, kw = mpl.colorbar.make_axes(ax, pad=.1)
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
     ax.set_title("Wigner function", fontsize=12)
 
@@ -1221,7 +1194,7 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     """
 
     if projection in ('2d', '3d'):
-        fig, ax = _same_fig_and_ax(fig, ax, projection)
+        fig, ax = _is_fig_and_ax(fig, ax, projection)
     else:
         raise ValueError('Unexpected value of projection keyword argument')
     if cmap is None:
@@ -1497,7 +1470,7 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
        (2012), open access.
     """
 
-    fig, ax = _same_fig_and_ax(fig, ax)
+    fig, ax = _is_fig_and_ax(fig, ax)
 
     if not isket(ket):
         raise Exception("Qubism works only for pure states, i.e. kets.")
@@ -1643,7 +1616,7 @@ def plot_schmidt(ket, theme='light', splitting=None,
 
     """
 
-    fig, ax = _same_fig_and_ax(fig, ax)
+    fig, ax = _is_fig_and_ax(fig, ax)
 
     if not isket(ket):
         raise Exception("Schmidt plot works only for pure states, i.e. kets.")
@@ -1696,96 +1669,3 @@ def plot_schmidt(ket, theme='light', splitting=None,
               extent=(0, size_x, 0, size_y))
 
     return fig, ax
-
-
-def _same_fig(fig, func_options):
-    if fig is None:
-        if 'fig' not in func_options.keys():
-            fig = plt.figure()
-            func_options['fig'] = fig
-        else:
-            fig = func_options['fig']
-    else:
-        if 'fig' not in func_options.keys():
-            func_options['fig'] = fig
-        else:
-            error = "fig and func_options['fig'] must be the same"
-            if fig != func_options['fig']:
-                raise ValueError(error)
-
-    return fig, func_options
-
-
-def _is_options(options, arg_name):
-    if options is None:
-        options = dict()
-
-    if not isinstance(options, dict):
-        raise TypeError(str(arg_name) + " must be a dict")
-
-    return options
-
-
-def _delete_axes(fig):
-    for ax in fig.axes:
-        fig.delaxes(ax)
-
-
-def _default_setup(ax, frame):
-    return ax
-
-
-def make_html_video(ani):
-    file_name = 'animation_for_video.mp4'
-    ani.save(file_name, fps=10)
-    video = open(file_name, "rb").read()
-    os.remove(file_name)
-    video_encoded = b64encode(video).decode("ascii")
-    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
-        video_encoded)
-
-    return ani, HTML(video_tag)
-
-
-def _make_anim(func_to_anim, list_of_obj, setup_ax=None,
-               func_options=None, anim_options=None, fig=None):
-
-    func_options = _is_options(func_options, "func_options")
-
-    anim_options = _is_options(anim_options, "anim_options")
-    if 'frames' not in anim_options.keys():
-        anim_options['frames'] = len(list_of_obj)
-
-    fig, func_options = _same_fig(fig, func_options)
-
-    if setup_ax is None:
-        setup_ax = _default_setup
-
-    def func(frame, list_of_obj, func_options):
-        _delete_axes(fig)
-        _, ax = func_to_anim(list_of_obj[frame], **func_options)
-        ax = setup_ax(ax, frame)
-
-    update = partial(func, list_of_obj=list_of_obj, func_options=func_options)
-    ani = animation.FuncAnimation(fig, update, **anim_options)
-    plt.close()
-
-    return make_html_video(ani)
-
-
-def anim_wigner(rhos, setup_ax=None, func_options=None,
-                anim_options=None, fig=None):
-    return _make_anim(plot_wigner, rhos, setup_ax, func_options,
-                      anim_options, fig)
-
-
-def anim_fock_distribution(rhos, setup_ax=None, func_options=None,
-                           anim_options=None, fig=None):
-    return _make_anim(plot_fock_distribution, rhos, setup_ax, func_options,
-                      anim_options, fig)
-
-
-def anim_matrix_histogram(rhos, setup_ax=None, func_options=None,
-                          anim_options=None, fig=None):
-    return _make_anim(matrix_histogram, rhos, setup_ax, func_options,
-                      anim_options, fig)

From 0de7345135f076f3a26577be4b8dbe98ae19e22b Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Tue, 25 Jul 2023 13:01:22 -0400
Subject: [PATCH 536/602] Fix pep8

---
 qutip/core/data/expm.py    | 6 ++++--
 qutip/core/data/make.py    | 2 +-
 qutip/core/data/matmul.pyx | 1 -
 qutip/core/data/ptrace.pyx | 1 -
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/qutip/core/data/expm.py b/qutip/core/data/expm.py
index 970767d540..22e69ba5f2 100644
--- a/qutip/core/data/expm.py
+++ b/qutip/core/data/expm.py
@@ -46,8 +46,10 @@ def expm_dia(matrix: Dia) -> Dia:
         out = dia.identity(matrix.shape[0])
     elif matrix.num_diag > 1:
         csc = matrix.as_scipy().tocsc()
-        out = Dia(scipy.sparse.linalg.expm(csc).todia(),
-                   tidyup=settings.core['auto_tidyup'], copy=False)
+        out = Dia(
+            scipy.sparse.linalg.expm(csc).todia(),
+            tidyup=settings.core['auto_tidyup'], copy=False
+        )
     elif isdiag_dia(matrix):
         matrix_sci = matrix.as_scipy()
         data = np.exp(matrix_sci.data[0, :])
diff --git a/qutip/core/data/make.py b/qutip/core/data/make.py
index a146641622..39c5247169 100644
--- a/qutip/core/data/make.py
+++ b/qutip/core/data/make.py
@@ -116,7 +116,7 @@ def one_element_dia(shape, position, value=1.0):
     if not (0 <= position[0] < shape[0] and 0 <= position[1] < shape[1]):
         raise ValueError("Position of the elements out of bound: " +
                          str(position) + " in " + str(shape))
-    data = np.zeros((1 ,shape[1]), dtype=complex)
+    data = np.zeros((1, shape[1]), dtype=complex)
     data[0, position[1]] = value
     offsets = np.array([position[1]-position[0]])
     return Dia((data, offsets), copy=False, shape=shape)
diff --git a/qutip/core/data/matmul.pyx b/qutip/core/data/matmul.pyx
index 36f409693f..a0560052e9 100644
--- a/qutip/core/data/matmul.pyx
+++ b/qutip/core/data/matmul.pyx
@@ -324,7 +324,6 @@ cpdef Dense matmul_dense(Dense left, Dense right, double complex scale=1, Dense
     return out
 
 
-#TODO: optimize: not rely on numpy for unique offsets.
 cpdef Dia matmul_dia(Dia left, Dia right, double complex scale=1):
     _check_shape(left, right, None)
     # We could probably do faster than this...
diff --git a/qutip/core/data/ptrace.pyx b/qutip/core/data/ptrace.pyx
index 3b124af448..00765608c7 100644
--- a/qutip/core/data/ptrace.pyx
+++ b/qutip/core/data/ptrace.pyx
@@ -122,7 +122,6 @@ cpdef CSR ptrace_csr(CSR matrix, object dims, object sel):
                                  size, size, p, tol)
 
 
-#TODO: cythonize
 def ptrace_dia(matrix, dims, sel):
     if len(sel) == len(dims):
         return matrix.copy()

From b283a0773d41167075ab612e660f4bdfba27faad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 25 Jul 2023 20:43:10 +0000
Subject: [PATCH 537/602] Bump certifi from 2022.12.7 to 2023.7.22 in /doc

Bumps [certifi](https://github.com/certifi/python-certifi) from 2022.12.7 to 2023.7.22.
- [Commits](https://github.com/certifi/python-certifi/compare/2022.12.07...2023.07.22)

---
updated-dependencies:
- dependency-name: certifi
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 doc/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index 620f971a0f..68e490ddb4 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -1,7 +1,7 @@
 alabaster==0.7.13
 Babel==2.12.1
 backcall==0.2.0
-certifi==2022.12.7
+certifi==2023.7.22
 chardet==4.0.0
 cycler==0.10.0
 Cython==0.29.33

From 0b27777edefc302c109b12fdea7fd472f55cb4bb Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Thu, 27 Jul 2023 19:45:56 +0900
Subject: [PATCH 538/602] add animations

---
 qutip/animation.py     | 409 +++++++++++++++++++++++++++++++++++------
 qutip/visualization.py |  41 +++--
 2 files changed, 376 insertions(+), 74 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index 92a560ccd0..7e4ef8532b 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -3,7 +3,7 @@
 visualizations of quantum states and processes.
 """
 
-__all__ = ['anim_wigner']
+__all__ = ['anim_wigner', 'anim_matrix_histogram']
 
 import warnings
 import itertools as it
@@ -46,51 +46,31 @@ def _axes3D(*args, **kwargs):
 from qutip import plot_wigner
 import matplotlib.pyplot as plt
 import matplotlib as mpl
-from . import matrix_histogram, plot_wigner
+from .visualization import *
 
 
-def _same_fig(fig, func_options):
-    if fig is None:
-        if 'fig' not in func_options.keys():
-            fig = plt.figure()
-            func_options['fig'] = fig
-        else:
-            fig = func_options['fig']
-    else:
-        if 'fig' not in func_options.keys():
-            func_options['fig'] = fig
-        else:
-            error = "fig and func_options['fig'] must be the same"
-            if fig != func_options['fig']:
-                raise ValueError(error)
-
-    return fig, func_options
-
-
-def _is_options(options, arg_name):
+def _is_options(options, keyward):
     if options is None:
         options = dict()
 
     if not isinstance(options, dict):
-        raise TypeError(str(arg_name) + " must be a dict")
+        raise ValueError(str(keyward) + ' must be a dict')
 
     return options
 
 
-def _delete_axes(fig):
-    for ax in fig.axes:
-        fig.delaxes(ax)
-
+def make_html_video(ani, save_options=None):
+    save_options = _is_options(save_options, 'save_options')
+    if 'name' not in save_options.keys():
+        save_options['name'] = 'animation'
+    if 'writer' not in save_options.keys():
+        save_options['writer'] = None
+    if 'codec' not in save_options.keys():
+        save_options['codec'] = None
 
-def _default_setup(ax, frame):
-    return ax
-
-
-def make_html_video(ani):
-    file_name = 'animation_for_video.mp4'
-    ani.save(file_name, fps=10)
-    video = open(file_name, "rb").read()
-    os.remove(file_name)
+    ani.save(save_options['name'] + '.mp4', fps=10,
+             writer=save_options['writer'], codec=save_options['codec'])
+    video = open(save_options['name'] + '.mp4', "rb").read()
     video_encoded = b64encode(video).decode("ascii")
     video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
         video_encoded)
@@ -100,15 +80,15 @@ def make_html_video(ani):
 
 def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
                 projection='2d', *, cmap=None, colorbar=False,
-                fig=None, ax=None):
+                fig=None, ax=None, save_options=None):
     """
-    Plot the the Wigner function for a density matrix (or ket) that describes
-    an oscillator mode.
+    Plot the time evolution of the Wigner function for density matrices (or kets)
+    that describes an oscillator mode.
 
     Parameters
     ----------
-    rho : :class:`qutip.Qobj`
-        The density matrix (or ket) of the state to visualize.
+    rhos : list of `qutip.Qobj`
+        List of density matrices (or kets) to visualize.
 
     xvec : array_like, optional
         x-coordinates at which to calculate the Wigner function.
@@ -139,6 +119,20 @@ def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
     ax : a matplotlib axes instance, optional
         The axes context in which the plot will be drawn.
 
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
     Returns
     -------
     fig, ax : tuple
@@ -146,22 +140,14 @@ def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
         the figure.
     """
 
-    if projection not in ('2d', '3d'):
-        raise ValueError('Unexpected value of projection keyword argument')
-    if projection == '2d':
-        fig = plt.figure()
-        ax = fig.add_subplot(111)
-    else:
-        fig = plt.figure()
-        ax = fig.add_subplot(111, projection='3d')
-
-    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
-    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
-    ax.set_title("Wigner function", fontsize=12)
-    wlim = -1
+    wlim = 0
     Ws = list()
     artist_list = list()
 
+    if projection not in ('2d', '3d'):
+        raise ValueError('Unexpected value of projection keyword argument')
+    fig, ax = _is_fig_and_ax(fig, ax, projection)
+
     for rho in rhos:
         if isket(rho):
             rho = ket2dm(rho)
@@ -191,11 +177,320 @@ def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
                                 norm=norm, cmap=cmap)]
         artist_list.append(cf)
 
+    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
+    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, pad=.1)
+        if projection == '2d':
+            shrink = 1
+        else:
+            shrink = .75
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
         cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50, blit=True,
-                                repeat_delay=1000)
-    return make_html_video(ani)
+    ax.set_title("Wigner function", fontsize=12)
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
+
+
+def anim_matrix_histogram(Ms, x_basis=None, y_basis=None, limits=None,
+                          bar_style='real', color_limits=None,
+                          color_style='real', options=None, *,
+                          cmap=None, colorbar=True, fig=None, ax=None,
+                          save_options=None):
+    """
+    Draw a histogram for the matrix M, with the given x and y labels and title.
+
+    Parameters
+    ----------
+    Ms : list of matrices of Qobj
+        list of matrices to visualize
+
+    x_basis : list of strings, optional
+        list of x ticklabels
+
+    y_basis : list of strings, optional
+        list of y ticklabels
+
+    limits : list/array with two float numbers, optional
+        The z-axis limits [min, max]
+
+    bar_style : string, default="real"
+
+        -  If set to ``"real"`` (default), each bar is plotted
+           as the real part of the corresponding matrix element
+        -  If set to ``"img"``, each bar is plotted
+           as the imaginary part of the corresponding matrix element
+        -  If set to ``"abs"``, each bar is plotted
+           as the absolute value of the corresponding matrix element
+        -  If set to ``"phase"`` (default), each bar is plotted
+           as the angle of the corresponding matrix element
+
+    color_limits : list/array with two float numbers, optional
+        The limits of colorbar [min, max]
+
+    color_style : string, default="real"
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"real"`` (default), each color is chosen
+           according to the real part of the corresponding matrix element.
+        -  If set to ``"img"``, each color is chosen according to
+           the imaginary part of the corresponding matrix element.
+        -  If set to ``"abs"``, each color is chosen according to
+           the absolute value of the corresponding matrix element.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        show colorbar
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    options : dict, optional
+        A dictionary containing extra options for the plot.
+        The names (keys) and values of the options are
+        described below:
+
+        'zticks' : list of numbers, optional
+            A list of z-axis tick locations.
+
+        'bars_spacing' : float, default=0.1
+            spacing between bars.
+
+        'bars_alpha' : float, default=1.
+            transparency of bars, should be in range 0 - 1
+
+        'bars_lw' : float, default=0.5
+            linewidth of bars' edges.
+
+        'bars_edgecolor' : color, default='k'
+            The colors of the bars' edges.
+            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
+
+        'shade' : bool, default=True
+            Whether to shade the dark sides of the bars (True) or not (False).
+            The shading is relative to plot's source of light.
+
+        'azim' : float, default=-35
+            The azimuthal viewing angle.
+
+        'elev' : float, default=35
+            The elevation viewing angle.
+
+        'stick' : bool, default=False
+            Changes xlim and ylim in such a way that bars next to
+            XZ and YZ planes will stick to those planes.
+            This option has no effect if ``ax`` is passed as a parameter.
+
+        'cbar_pad' : float, default=0.04
+            The fraction of the original axes between the colorbar
+            and the new image axes.
+            (i.e. the padding between the 3D figure and the colorbar).
+
+        'cbar_to_z' : bool, default=False
+            Whether to set the color of maximum and minimum z-values to the
+            maximum and minimum colors in the colorbar (True) or not (False).
+
+        'threshold': float, optional
+            Threshold for when bars of smaller height should be transparent. If
+            not set, all bars are colored according to the color map.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not valid.
+
+    """
+
+    # default options
+    default_opts = {'zticks': None, 'bars_spacing': 0.2,
+                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
+                    'shade': True, 'azim': -35, 'elev': 35, 'stick': False,
+                    'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
+
+    # update default_opts from input options
+    if options is None:
+        options = dict()
+
+    if isinstance(options, dict):
+        # check if keys in options dict are valid
+        if set(options) - set(default_opts):
+            raise ValueError("invalid key(s) found in options: "
+                             f"{', '.join(set(options) - set(default_opts))}")
+        else:
+            # updating default options
+            default_opts.update(options)
+            options = default_opts
+    else:
+        raise ValueError("options must be a dictionary")
+
+    _bars_and_colors = list()
+    for i in range(len(Ms)):
+        M = Ms[i]
+        if isinstance(M, Qobj):
+            if x_basis is None:
+                x_basis = list(_cb_labels([M.shape[0]])[0])
+            if y_basis is None:
+                y_basis = list(_cb_labels([M.shape[1]])[1])
+            # extract matrix data from Qobj
+            M = M.full()
+
+        n = np.size(M)
+        xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+        xpos = xpos.T.flatten() + 0.5
+        ypos = ypos.T.flatten() + 0.5
+        zpos = np.zeros(n)
+        dx = dy = (1 - options['bars_spacing']) * np.ones(n)
+
+        bar_M = _get_matrix_components(bar_style, M, 'bar_style')
+
+        if isinstance(limits, list) and \
+                len(limits) == 2:
+            z_min = limits[0]
+            z_max = limits[1]
+        else:
+            if i == 0:
+                z_min = min(bar_M)
+                z_max = max(bar_M)
+            else:
+                z_min = min(min(bar_M), z_min)
+                z_max = max(max(bar_M), z_max)
+
+            if z_min == z_max:
+                z_min -= 0.1
+                z_max += 0.1
+
+        color_M = _get_matrix_components(color_style, M, 'color_style')
+
+        if isinstance(color_limits, list) and \
+                len(color_limits) == 2:
+            c_min = color_limits[0]
+            c_max = color_limits[1]
+        else:
+            if color_style == 'phase':
+                c_min = -pi
+                c_max = pi
+            else:
+                if i == 0:
+                    c_min = min(color_M)
+                    c_max = max(color_M)
+                else:
+                    c_min = min(min(color_M), c_min)
+                    c_max = max(max(color_M), c_max)
+
+            if c_min == c_max:
+                c_min -= 0.1
+                c_max += 0.1
+        _bars_and_colors.append((bar_M, color_M))
+    norm = mpl.colors.Normalize(c_min, c_max)
+
+    if cmap is None:
+        # change later
+        if color_style == 'phase':
+            cmap = _cyclic_cmap()
+        else:
+            cmap = _sequential_cmap()
+
+    artist_list = list()
+    for bar_M, color_M in _bars_and_colors:
+        colors = cmap(norm(color_M))
+
+        colors[:, 3] = options['bars_alpha']
+
+        if options['threshold'] is not None:
+            colors[:, 3] *= 1 * (bar_M >= options['threshold'])
+
+            idx, = np.where(bar_M < options['threshold'])
+            bar_M[idx] = 0
+
+        fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+        artist = ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
+                          edgecolors=options['bars_edgecolor'],
+                          linewidths=options['bars_lw'],
+                          shade=options['shade'])
+        artist_list.append([artist])
+
+    # remove vertical lines on xz and yz plane
+    ax.yaxis._axinfo["grid"]['linewidth'] = 0
+    ax.xaxis._axinfo["grid"]['linewidth'] = 0
+
+    # x axis
+    _update_xaxis(options['bars_spacing'], M, ax, x_basis)
+
+    # y axis
+    _update_yaxis(options['bars_spacing'], M, ax, y_basis)
+
+    # z axis
+    _update_zaxis(ax, z_min, z_max, options['zticks'])
+
+    # stick to xz and yz plane
+    _stick_to_planes(options['stick'],
+                     options['azim'], ax, M,
+                     options['bars_spacing'])
+    ax.view_init(azim=options['azim'], elev=options['elev'])
+
+    # color axis
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
+                                         pad=options['cbar_pad'])
+        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+
+        if color_style == 'real':
+            cb.set_label('real')
+        elif color_style == 'img':
+            cb.set_label('imaginary')
+        elif color_style == 'abs':
+            cb.set_label('absolute')
+        else:
+            cb.set_label('arg')
+            if color_limits is None:
+                cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+                cb.set_ticklabels(
+                    (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
+
+    # removing margins
+    _remove_margins(ax.xaxis)
+    _remove_margins(ax.yaxis)
+    _remove_margins(ax.zaxis)
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+    print(z_min, z_max)
+    return fig, ani, html_video
\ No newline at end of file
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 87a61fb521..db39b54550 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,7 +7,10 @@
            'matrix_histogram', 'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
            'plot_spin_distribution', 'complex_array_to_rgb',
-           'plot_qubism', 'plot_schmidt']
+           'plot_qubism', 'plot_schmidt', '_cyclic_cmap', '_diverging_cmap',
+           '_sequential_cmap', '_is_fig_and_ax', '_cb_labels',
+           '_get_matrix_components', '_update_xaxis', '_update_yaxis',
+           '_update_zaxis', '_stick_to_planes', '_remove_margins']
 
 import warnings
 import itertools as it
@@ -601,7 +604,7 @@ def _get_matrix_components(option, M, argument):
 def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                      bar_style='real', color_limits=None, color_style='real',
                      options=None, *, cmap=None, colorbar=True,
-                     colorbar_opts=None, fig=None, ax=None):
+                     fig=None, ax=None):
     """
     Draw a histogram for the matrix M, with the given x and y labels and title.
 
@@ -693,6 +696,15 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             XZ and YZ planes will stick to those planes.
             This option has no effect if ``ax`` is passed as a parameter.
 
+        'cbar_pad' : float, default=0.04
+            The fraction of the original axes between the colorbar
+            and the new image axes.
+            (i.e. the padding between the 3D figure and the colorbar).
+
+        'cbar_to_z' : bool, default=False
+            Whether to set the color of maximum and minimum z-values to the
+            maximum and minimum colors in the colorbar (True) or not (False).
+
         'threshold': float, optional
             Threshold for when bars of smaller height should be transparent. If
             not set, all bars are colored according to the color map.
@@ -710,14 +722,11 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     """
 
-    if colorbar_opts is None:
-        colorbar_opts = dict()
-
     # default options
     default_opts = {'zticks': None, 'bars_spacing': 0.2,
                     'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
                     'shade': True, 'azim': -35, 'elev': 35, 'stick': False,
-                    'cbar_pad': 0.04, 'threshold': None}
+                    'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
 
     # update default_opts from input options
     if options is None:
@@ -782,7 +791,6 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             c_max += 0.1
 
     norm = mpl.colors.Normalize(c_min, c_max)
-    colorbar_opts['norm'] = norm
 
     if cmap is None:
         # change later
@@ -791,8 +799,6 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         else:
             cmap = _sequential_cmap()
 
-    colorbar_opts['cmap'] = cmap
-
     colors = cmap(norm(color_M))
 
     colors[:, 3] = options['bars_alpha']
@@ -830,20 +836,21 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     # color axis
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, **colorbar_opts)
-        cbar = mpl.colorbar.ColorbarBase(cax, **kw)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
+                                         pad=options['cbar_pad'])
+        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
         if color_style == 'real':
-            cbar.set_label('real')
+            cb.set_label('real')
         elif color_style == 'img':
-            cbar.set_label('imaginary')
+            cb.set_label('imaginary')
         elif color_style == 'abs':
-            cbar.set_label('absolute')
+            cb.set_label('absolute')
         else:
-            cbar.set_label('arg')
+            cb.set_label('arg')
             if color_limits is None:
-                cbar.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-                cbar.set_ticklabels(
+                cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
+                cb.set_ticklabels(
                     (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
 
     # removing margins

From 90cdf5528058d78ef554d98b618048a2d00d6dae Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Thu, 27 Jul 2023 20:34:48 +0900
Subject: [PATCH 539/602] add anim_fock

---
 qutip/animation.py     | 92 +++++++++++++++++++++++++++++++++++++++---
 qutip/visualization.py |  3 +-
 2 files changed, 88 insertions(+), 7 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index 7e4ef8532b..2d80839916 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -3,7 +3,7 @@
 visualizations of quantum states and processes.
 """
 
-__all__ = ['anim_wigner', 'anim_matrix_histogram']
+__all__ = ['anim_wigner', 'anim_matrix_histogram', 'anim_fock_distribution']
 
 import warnings
 import itertools as it
@@ -82,8 +82,8 @@ def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
                 projection='2d', *, cmap=None, colorbar=False,
                 fig=None, ax=None, save_options=None):
     """
-    Plot the time evolution of the Wigner function for density matrices (or kets)
-    that describes an oscillator mode.
+    Plot the time evolution of the Wigner function for density matrices
+    (or kets) hat describes an oscillator mode.
 
     Parameters
     ----------
@@ -170,11 +170,12 @@ class to use, such as 'ffmpeg'.
 
     for W in Ws:
         if projection == '2d':
-            cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap).collections
+            cf = ax.contourf(xvec, yvec, W, 100, norm=norm,
+                             cmap=cmap).collections
         else:
             X, Y = np.meshgrid(xvec, yvec)
             cf = [ax.plot_surface(X, Y, W, rstride=5, cstride=5, linewidth=0.5,
-                                norm=norm, cmap=cmap)]
+                                  norm=norm, cmap=cmap)]
         artist_list.append(cf)
 
     ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
@@ -493,4 +494,83 @@ class to use, such as 'ffmpeg'.
 
     ani, html_video = make_html_video(ani, save_options)
     print(z_min, z_max)
-    return fig, ani, html_video
\ No newline at end of file
+    return fig, ani, html_video
+
+
+def anim_fock_distribution(rhos, fock_numbers=None, color="green",
+                           unit_y_range=True, *, fig=None, ax=None,
+                           save_options=None):
+    """
+    Plot the Fock distribution for a density matrix (or ket) that describes
+    an oscillator mode.
+
+    Parameters
+    ----------
+    rhos : list of `qutip.Qobj`
+        The density matrices (or kets) to visualize.
+
+    fock_numbers : list of strings, optional
+        list of x ticklabels to represent fock numbers
+
+    color : color or list of colors, default="green"
+        The colors of the bar faces.
+
+    unit_y_range : bool, default=True
+        Set y-axis limits [0, 1] or not
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    fig, ax = _is_fig_and_ax(fig, ax)
+
+    artist_list = list()
+    for rho in rhos:
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        N = rho.shape[0]
+
+        artist = ax.bar(np.arange(N), np.real(rho.diag()),
+                        color=color, alpha=0.6, width=0.8).patches
+        artist_list.append(artist)
+
+    if fock_numbers:
+        _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
+
+    if unit_y_range:
+        ax.set_ylim(0, 1)
+    ax.set_xlim(-.5, N)
+    ax.set_xlabel('Fock number', fontsize=12)
+    ax.set_ylabel('Occupation probability', fontsize=12)
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
diff --git a/qutip/visualization.py b/qutip/visualization.py
index db39b54550..0802b472c7 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -10,7 +10,8 @@
            'plot_qubism', 'plot_schmidt', '_cyclic_cmap', '_diverging_cmap',
            '_sequential_cmap', '_is_fig_and_ax', '_cb_labels',
            '_get_matrix_components', '_update_xaxis', '_update_yaxis',
-           '_update_zaxis', '_stick_to_planes', '_remove_margins']
+           '_update_zaxis', '_stick_to_planes', '_remove_margins',
+           '_set_ticklabels']
 
 import warnings
 import itertools as it

From d4f6f6fe329c7204ac8fbc0761f87ce09d60f39f Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 30 Jul 2023 17:11:52 +0900
Subject: [PATCH 540/602] add animation

---
 qutip/animation.py     | 1001 +++++++++++++++++++++++++++++++++++++---
 qutip/visualization.py |    5 +-
 2 files changed, 942 insertions(+), 64 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index 2d80839916..7c49adba56 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -3,7 +3,10 @@
 visualizations of quantum states and processes.
 """
 
-__all__ = ['anim_wigner', 'anim_matrix_histogram', 'anim_fock_distribution']
+__all__ = ['anim_wigner_sphere', 'anim_hinton', 'anim_sphereplot',
+           'anim_matrix_histogram', 'anim_fock_distribution',
+           'anim_wigner', 'anim_spin_distribution', 'anim_qubism',
+           'plot_schmidt']
 
 import warnings
 import itertools as it
@@ -78,46 +81,194 @@ def make_html_video(ani, save_options=None):
     return ani, HTML(video_tag)
 
 
-def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
-                projection='2d', *, cmap=None, colorbar=False,
-                fig=None, ax=None, save_options=None):
+def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
+                       colorbar=True, fig=None, ax=None,
+                       save_options=None):
+    """Plots a coloured Bloch sphere.
+
+    Parameters
+    ----------
+    wigners : list of wigner functions
+        The wigner transformation at `steps` different theta and phi.
+
+    reflections : bool, default=False
+        If the reflections of the sphere should be plotted as well.
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The ax context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Notes
+    -----
+    Special thanks to Russell P Rundle for writing this function.
     """
-    Plot the time evolution of the Wigner function for density matrices
-    (or kets) hat describes an oscillator mode.
+
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+    if cmap is None:
+        cmap = _diverging_cmap()
+
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+    wigner_max = 0
+    for wigner in wigners:
+        wigner_max = max(np.real(np.amax(np.abs(wigner))), wigner_max)
+
+    artist_list = list()
+    for wigner in wigners:
+        steps = len(wigner)
+
+        theta = np.linspace(0, np.pi, steps)
+        phi = np.linspace(0, 2 * np.pi, steps)
+        x = np.outer(np.sin(theta), np.cos(phi))
+        y = np.outer(np.sin(theta), np.sin(phi))
+        z = np.outer(np.cos(theta), np.ones(steps))
+        wigner = np.real(wigner)
+
+        wigner_c1 = cmap((wigner + wigner_max) / (2 * wigner_max))
+
+        artist = list()
+        # Plot coloured Bloch sphere:
+        artist.append(ax.plot_surface(x, y, z, facecolors=wigner_c1,
+                                      vmin=-wigner_max, vmax=wigner_max,
+                                      rcount=steps, ccount=steps, linewidth=0,
+                                      zorder=0.5, antialiased=None))
+
+        if reflections:
+            wigner_c2 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+                             (2*wigner_max))  # bottom
+            wigner_c3 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+                             (2*wigner_max))  # side
+            wigner_c4 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
+                             (2*wigner_max))  # back
+
+            # Plot bottom reflection:
+            artist.append(ax.plot_surface(x[0:steps, 0:steps],
+                                          y[0:steps, 0:steps],
+                                          -1.5*np.ones((steps, steps)),
+                                          facecolors=wigner_c2,
+                                          vmin=-wigner_max, vmax=wigner_max,
+                                          rcount=steps/2, ccount=steps/2,
+                                          linewidth=0, zorder=0.5,
+                                          antialiased=False))
+
+            # Plot side reflection:
+            artist.append(ax.plot_surface(-1.5*np.ones((steps, steps)),
+                                          y[0:steps, 0:steps],
+                                          z[0:steps, 0:steps],
+                                          facecolors=wigner_c3,
+                                          vmin=-wigner_max, vmax=wigner_max,
+                                          rcount=steps/2, ccount=steps/2,
+                                          linewidth=0, zorder=0.5,
+                                          antialiased=False))
+
+            # Plot back reflection:
+            artist.append(ax.plot_surface(x[0:steps, 0:steps],
+                                          1.5*np.ones((steps, steps)),
+                                          z[0:steps, 0:steps],
+                                          facecolors=wigner_c4,
+                                          vmin=-wigner_max, vmax=wigner_max,
+                                          rcount=steps/2, ccount=steps/2,
+                                          linewidth=0, zorder=0.5,
+                                          antialiased=False))
+        artist_list.append(artist)
+
+    # Create colourbar:
+    if colorbar:
+        norm = mpl.colors.Normalize(-wigner_max, wigner_max)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
+
+
+# Adopted from the SciPy Cookbook.
+def anim_hinton(rhos, x_basis=None, y_basis=None, color_style="scaled",
+                label_top=True, *, cmap=None, colorbar=True, fig=None,
+                ax=None, save_options=None):
+    """Draws a Hinton diagram to visualize a density matrix or superoperator.
 
     Parameters
     ----------
-    rhos : list of `qutip.Qobj`
-        List of density matrices (or kets) to visualize.
+    rhos : list of qobj
+        List of input density matrices or superoperators.
 
-    xvec : array_like, optional
-        x-coordinates at which to calculate the Wigner function.
+        .. note::
 
-    yvec : array_like, optional
-        y-coordinates at which to calculate the Wigner function.  Does not
-        apply to the 'fft' method.
+            Hinton plots of superoperators are currently only
+            supported for qubits.
 
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
-        default='clenshaw'
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
+    x_basis : list of strings, optional
+        list of x ticklabels to represent x basis of the input.
 
-    projection: string {'2d', '3d'}, default='2d'
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
+    y_basis : list of strings, optional
+        list of y ticklabels to represent y basis of the input.
 
-    cmap : a matplotlib cmap instance, optional
-        The colormap.
+    color_style : string, default="scaled"
 
-    colorbar : bool, default=False
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"scaled"`` (default), each color is chosen by
+           passing the absolute value of the corresponding matrix
+           element into `cmap` with the sign of the real part.
+        -  If set to ``"threshold"``, each square is plotted as
+           the maximum of `cmap` for the positive real part and as
+           the minimum for the negative part of the matrix element;
+           note that this generalizes `"threshold"` to complex numbers.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    label_top : bool, default=True
+        If True, x ticklabels will be placed on top, otherwise
+        they will appear below the plot.
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
 
     fig : a matplotlib Figure instance, optional
         The Figure canvas in which the plot will be drawn.
 
     ax : a matplotlib axes instance, optional
-        The axes context in which the plot will be drawn.
+        The ax context in which the plot will be drawn.
 
     save_options : dict, optional
         A dictionary containing options to save the animation.
@@ -138,58 +289,240 @@ class to use, such as 'ffmpeg'.
     fig, ax : tuple
         A tuple of the matplotlib figure and axes instances used to produce
         the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not a quantum object.
+
+    Examples
+    --------
+    >>> import qutip
+    >>>
+    >>> dm = qutip.rand_dm(4)
+    >>> fig, ax = qutip.hinton(dm)
+    >>> fig.show()
+    >>>
+    >>> qutip.settings.colorblind_safe = True
+    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
+    >>> fig.show()
+    >>> qutip.settings.colorblind_safe = False
+    >>>
+    >>> fig, ax = qutip.hinton(dm, color_style="phase")
+    >>> fig.show()
     """
 
-    wlim = 0
+    fig, ax = _is_fig_and_ax(fig, ax)
+
     Ws = list()
+    w_max = 0
+    for rho in rhos:
+        # Extract plotting data W from the input.
+        if isinstance(rho, Qobj):
+            if rho.isoper or rho.isoperket or rho.isoperbra:
+                if rho.isoperket:
+                    rho = vector_to_operator(rho)
+                elif rho.isoperbra:
+                    rho = vector_to_operator(rho.dag())
+                W = rho.full()
+                # Create default labels if none are given.
+                if x_basis is None or y_basis is None:
+                    labels = _cb_labels(rho.dims[0])
+                    if x_basis is None:
+                        x_basis = list(labels[0])
+                    if y_basis is None:
+                        y_basis = list(labels[1])
+
+            elif rho.issuper:
+                if not isqubitdims(rho.dims):
+                    raise ValueError("Hinton plots of superoperators are "
+                                     "currently only supported for qubits.")
+                # Convert to a superoperator in the Pauli basis,
+                # so that all the elements are real.
+                sqobj = _to_superpauli(rho)
+                nq = int(log2(sqobj.shape[0]) / 2)
+                W = sqobj.full().T
+                # Create default labels, too.
+                if (x_basis is None) or (y_basis is None):
+                    labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+                    if x_basis is None:
+                        x_basis = labels
+                    if y_basis is None:
+                        y_basis = labels
+
+            else:
+                raise ValueError(
+                    "Input quantum object must be "
+                    "an operator or superoperator.")
+        else:
+            W = rho
+        Ws.append(W)
+
+        height, width = W.shape
+
+        w_max = max(1.25 * max(abs(np.array(W)).flatten()), w_max)
+        if w_max <= 0.0:
+            w_max = 1.0
+
+    # Set color_fn here.
+    if color_style == "scaled":
+        if cmap is None:
+            cmap = _diverging_cmap()
+
+        def color_fn(w):
+            w = np.abs(w) * np.sign(np.real(w))
+            return cmap(int((w + w_max) * 256 / (2 * w_max)))
+    elif color_style == "threshold":
+        if cmap is None:
+            cmap = _diverging_cmap()
+
+        def color_fn(w):
+            w = np.real(w)
+            return cmap(255 if w > 0 else 0)
+    elif color_style == "phase":
+        if cmap is None:
+            cmap = _cyclic_cmap()
+
+        def color_fn(w):
+            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
+    else:
+        raise ValueError(
+            "Unknown color style {} for Hinton diagrams.".format(color_style)
+        )
+
     artist_list = list()
+    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
+            color=cmap(128))
+    for W in Ws:
+        artist = list()
+        for x in range(width):
+            for y in range(height):
+                _x = x + 1
+                _y = y + 1
+                artist += _blob(_x - 0.5, height - _y + 0.5, W[y, x],
+                                w_max, min(1, abs(W[y, x]) / w_max),
+                                color_fn=color_fn, ax=ax)
+        artist_list.append(artist)
 
-    if projection not in ('2d', '3d'):
-        raise ValueError('Unexpected value of projection keyword argument')
-    fig, ax = _is_fig_and_ax(fig, ax, projection)
+    if colorbar:
+        vmax = np.pi if color_style == "phase" else w_max
+        norm = mpl.colors.Normalize(-vmax, vmax)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
-    for rho in rhos:
-        if isket(rho):
-            rho = ket2dm(rho)
+    # axis
+    if not (x_basis or y_basis):
+        ax.axis('off')
+    ax.axis('equal')
+    ax.set_frame_on(False)
 
-        if xvec is None:
-            xvec = np.linspace(-7.5, 7.5, 200)
-        if yvec is None:
-            yvec = np.linspace(-7.5, 7.5, 200)
+    # x axis
+    xticks = 0.5 + np.arange(width)
+    if x_basis:
+        _set_ticklabels(ax, x_basis, xticks, 'x')
+    if label_top:
+        ax.xaxis.tick_top()
 
-        W0 = wigner(rho, xvec, yvec, method=method)
+    # y axis
+    yticks = 0.5 + np.arange(height)
+    if y_basis:
+        _set_ticklabels(ax, list(reversed(y_basis)), yticks, 'y')
 
-        W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
-        Ws.append(W)
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
 
-        wlim = max(abs(W).max(), wlim)
+    ani, html_video = make_html_video(ani, save_options)
 
-    norm = mpl.colors.Normalize(-wlim, wlim)
-    if cmap is None:
-        cmap = mpl.cm.RdBu
+    return fig, ani, html_video
 
-    for W in Ws:
-        if projection == '2d':
-            cf = ax.contourf(xvec, yvec, W, 100, norm=norm,
-                             cmap=cmap).collections
-        else:
-            X, Y = np.meshgrid(xvec, yvec)
-            cf = [ax.plot_surface(X, Y, W, rstride=5, cstride=5, linewidth=0.5,
-                                  norm=norm, cmap=cmap)]
-        artist_list.append(cf)
 
-    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
-    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+def anim_sphereplot(theta, phi, V, *, cmap=None, colorbar=True,
+                    fig=None, ax=None, save_options=None):
+    """Plots a matrix of values on a sphere
+
+    Parameters
+    ----------
+    theta : float
+        Angle with respect to z-axis. Its range is between 0 and pi
+
+    phi : float
+        Angle in x-y plane. Its range is between 0 and 2*pi
+
+    V : list
+        List of data sets to be plotted
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+    if cmap is None:
+        cmap = _sequential_cmap()
+
+    thetam, phim = np.meshgrid(theta, phi)
+    xx = sin(thetam) * cos(phim)
+    yy = sin(thetam) * sin(phim)
+    zz = cos(thetam)
+    min_ph = pi
+    max_ph = -pi
+
+    r_and_ph = list()
+    for values in V:
+        r = array(abs(values))
+        ph = angle(values)
+        min_ph = min(min_ph, ph.min())
+        max_ph = max(max_ph, ph.max())
+        r_and_ph.append((r, ph))
+    # normalize color range based on phase angles in list ph
+    norm = mpl.colors.Normalize(min_ph, max_ph)
+
+    # plot with facecolors set to cm.jet colormap normalized to nrm
+    artist_list = list()
+    for r, ph in r_and_ph:
+        artist = [ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
+                                  facecolors=cmap(norm(ph)), linewidth=0,)]
+        artist_list.append(artist)
 
     if colorbar:
-        if projection == '2d':
-            shrink = 1
-        else:
-            shrink = .75
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
-        cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        # create new axes on plot for colorbar and shrink it a bit.
+        # pad shifts location of bar with repsect to the main plot
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.05)
 
-    ax.set_title("Wigner function", fontsize=12)
+        # create new colorbar in axes cax with cmap and normalized to nrm like
+        # our facecolors
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        # add our colorbar label
+        cb1.set_label('Angle')
 
     ani = animation.ArtistAnimation(fig, artist_list, interval=50,
                                     blit=True, repeat_delay=1000)
@@ -574,3 +907,547 @@ class to use, such as 'ffmpeg'.
     ani, html_video = make_html_video(ani, save_options)
 
     return fig, ani, html_video
+
+
+def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
+                projection='2d', *, cmap=None, colorbar=False,
+                fig=None, ax=None, save_options=None):
+    """
+    Plot the time evolution of the Wigner function for density matrices
+    (or kets) hat describes an oscillator mode.
+
+    Parameters
+    ----------
+    rhos : list of `qutip.Qobj`
+        List of density matrices (or kets) to visualize.
+
+    xvec : array_like, optional
+        x-coordinates at which to calculate the Wigner function.
+
+    yvec : array_like, optional
+        y-coordinates at which to calculate the Wigner function.  Does not
+        apply to the 'fft' method.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
+        default='clenshaw'
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}, default='2d'
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    cmap : a matplotlib cmap instance, optional
+        The colormap.
+
+    colorbar : bool, default=False
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    wlim = 0
+    Ws = list()
+    artist_list = list()
+
+    if projection not in ('2d', '3d'):
+        raise ValueError('Unexpected value of projection keyword argument')
+    fig, ax = _is_fig_and_ax(fig, ax, projection)
+
+    for rho in rhos:
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        if xvec is None:
+            xvec = np.linspace(-7.5, 7.5, 200)
+        if yvec is None:
+            yvec = np.linspace(-7.5, 7.5, 200)
+
+        W0 = wigner(rho, xvec, yvec, method=method)
+
+        W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
+        Ws.append(W)
+
+        wlim = max(abs(W).max(), wlim)
+
+    norm = mpl.colors.Normalize(-wlim, wlim)
+    if cmap is None:
+        cmap = mpl.cm.RdBu
+
+    for W in Ws:
+        if projection == '2d':
+            cf = ax.contourf(xvec, yvec, W, 100, norm=norm,
+                             cmap=cmap).collections
+        else:
+            X, Y = np.meshgrid(xvec, yvec)
+            cf = [ax.plot_surface(X, Y, W, rstride=5, cstride=5, linewidth=0.5,
+                                  norm=norm, cmap=cmap)]
+        artist_list.append(cf)
+
+    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
+    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+
+    if colorbar:
+        if projection == '2d':
+            shrink = 1
+        else:
+            shrink = .75
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
+        cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+
+    ax.set_title("Wigner function", fontsize=12)
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
+
+
+def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
+                           cmap=None, colorbar=False, fig=None,
+                           ax=None, save_options=None):
+    """
+    Plots a spin distribution (given as meshgrid data).
+
+    Parameters
+    ----------
+    Ps : matrices
+        List of distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate. Its range is between 0 and pi
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate. Its range is between 0 and 2*pi
+
+    projection: string {'2d', '3d'}, default='2d'
+        Specify whether the spin distribution function is to be plotted as a 2D
+        projection where the surface of the unit sphere is mapped on
+        the unit disk ('2d') or surface plot ('3d').
+
+    cmap : a matplotlib cmap instance, optional
+        The colormap.
+
+    colorbar : bool, default=False
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    fig : a matplotlib figure instance, optional
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance, optional
+        The axis context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+    """
+
+    if projection in ('2d', '3d'):
+        fig, ax = _is_fig_and_ax(fig, ax, projection)
+    else:
+        raise ValueError('Unexpected value of projection keyword argument')
+    min_P = Ps[0].min()
+    max_P = Ps[0].max()
+    for P in Ps:
+        min_P = min(min_P, P.min())
+        max_P = max(max_P, P.max())
+
+    if cmap is None:
+        if min_P < -1e12:
+            cmap = _diverging_cmap()
+            norm = mpl.colors.Normalize(-max_P, max_P)
+        else:
+            cmap = _sequential_cmap()
+            norm = mpl.colors.Normalize(min_P, max_P)
+
+    artist_list = list()
+    if projection == '2d':
+        Y = (THETA - pi / 2) / (pi / 2)
+        X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
+        for P in Ps:
+            artist_list.append([ax.pcolor(X, Y, P.real, cmap=cmap)])
+        ax.set_xlabel(r'$\varphi$', fontsize=18)
+        ax.set_ylabel(r'$\theta$', fontsize=18)
+        ax.axis('equal')
+        ax.set_xticks([-1, 0, 1])
+        ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
+        ax.set_yticks([-1, 0, 1])
+        ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
+    else:
+        ax.view_init(azim=-35, elev=35)
+
+        xx = sin(THETA) * cos(PHI)
+        yy = sin(THETA) * sin(PHI)
+        zz = cos(THETA)
+        for P in Ps:
+            artist = [ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+                      facecolors=cmap(norm(P)), linewidth=0)]
+            artist_list.append(artist)
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cb1.set_label('magnitude')
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
+
+
+def anim_qubism(kets, theme='light', how='pairs', grid_iteration=1,
+                legend_iteration=0, *, fig=None, ax=None, save_options=None):
+    """
+    Qubism plot for pure states of many qudits.  Works best for spin chains,
+    especially with even number of particles of the same dimension.  Allows to
+    see entanglement between first 2k particles and the rest.
+
+    .. note::
+
+        colorblind_safe does not apply because of its unique colormap
+
+    Parameters
+    ----------
+    kets : list of Qobj
+        list of pure states for plotting.
+
+    theme : 'light' or 'dark', default='light'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    how : 'pairs', 'pairs_skewed' or 'before_after', default='pairs'
+        Type of Qubism plotting.  Options:
+
+        - 'pairs' - typical coordinates,
+        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
+        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
+
+    grid_iteration : int, default=1
+        Helper lines to be drawn on plot.
+        Show tiles for 2*grid_iteration particles vs all others.
+
+    legend_iteration : int or 'grid_iteration' or 'all', default=0
+        Show labels for first ``2*legend_iteration`` particles.  Option
+        'grid_iteration' sets the same number of particles as for
+        grid_iteration.  Option 'all' makes label for all particles.  Typically
+        it should be 0, 1, 2 or perhaps 3.
+
+    fig : a matplotlib figure instance, optional
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance, optional
+        The axis context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    Notes
+    -----
+    See also [1]_.
+
+    References
+    ----------
+    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
+       and G. Sierra, *Qubism: self-similar visualization of many-body
+       wavefunctions*, `New J. Phys. 14 053028
+       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
+       (2012), open access.
+    """
+
+    fig, ax = _is_fig_and_ax(fig, ax)
+
+    artist_list = list()
+    for ket in kets:
+        if not isket(ket):
+            raise Exception("Qubism works only for pure states, i.e. kets.")
+            # add for dm? (perhaps a separate function, plot_qubism_dm)
+
+        dim_list = ket.dims[0]
+        n = len(dim_list)
+
+        # for odd number of particles - pixels are rectangular
+        if n % 2 == 1:
+            ket = tensor(ket, Qobj([1] * dim_list[-1]))
+            dim_list = ket.dims[0]
+            n += 1
+
+        ketdata = ket.full()
+
+        if how == 'pairs':
+            dim_list_y = dim_list[::2]
+            dim_list_x = dim_list[1::2]
+        elif how == 'pairs_skewed':
+            dim_list_y = dim_list[::2]
+            dim_list_x = dim_list[1::2]
+            if dim_list_x != dim_list_y:
+                raise Exception("For 'pairs_skewed' pairs " +
+                                "of dimensions need to be the same.")
+        elif how == 'before_after':
+            dim_list_y = list(reversed(dim_list[:(n // 2)]))
+            dim_list_x = dim_list[(n // 2):]
+        else:
+            raise Exception("No such 'how'.")
+
+        size_x = np.prod(dim_list_x)
+        size_y = np.prod(dim_list_y)
+
+        qub = np.zeros([size_x, size_y], dtype=complex)
+        for i in range(ketdata.size):
+            qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
+        qub = qub.transpose()
+
+        quadrants_x = np.prod(dim_list_x[:grid_iteration])
+        quadrants_y = np.prod(dim_list_y[:grid_iteration])
+
+        ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
+        ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+
+        ax.set_xticks(ticks_x)
+        ax.set_xticklabels([""] * (quadrants_x - 1))
+        ax.set_yticks(ticks_y)
+        ax.set_yticklabels([""] * (quadrants_y - 1))
+        theme2color_of_lines = {'light': '#000000',
+                                'dark': '#FFFFFF'}
+        ax.grid(True, color=theme2color_of_lines[theme])
+        artist = [ax.imshow(complex_array_to_rgb(qub, theme=theme),
+                  interpolation="none",
+                  extent=(0, size_x, 0, size_y))]
+        artist_list.append(artist)
+
+    if legend_iteration == 'all':
+        label_n = n // 2
+    elif legend_iteration == 'grid_iteration':
+        label_n = grid_iteration
+    else:
+        try:
+            label_n = int(legend_iteration)
+        except:
+            raise Exception("No such option for legend_iteration keyword " +
+                            "argument. Use 'all', 'grid_iteration' or an " +
+                            "integer.")
+
+    if label_n:
+
+        if how == 'before_after':
+            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
+                + dim_list_x[:label_n]
+        else:
+            dim_list_small = []
+            for j in range(label_n):
+                dim_list_small.append(dim_list_y[j])
+                dim_list_small.append(dim_list_x[j])
+
+        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
+        shift_x = 0.5 * scale_x
+        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
+        shift_y = 0.5 * scale_y
+
+        bbox = ax.get_window_extent().transformed(
+            fig.dpi_scale_trans.inverted())
+        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
+        opts = {'fontsize': fontsize,
+                'color': theme2color_of_lines[theme],
+                'horizontalalignment': 'center',
+                'verticalalignment': 'center'}
+        for i in range(np.prod(dim_list_small)):
+            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
+            seq = _index_to_sequence(i, dim_list=dim_list_small)
+            ax.text(scale_x * x + shift_x,
+                    size_y - (scale_y * y + shift_y),
+                    _sequence_to_latex(seq),
+                    **opts)
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
+
+
+def anim_schmidt(kets, theme='light', splitting=None,
+                 labels_iteration=(3, 2), *, fig=None, ax=None,
+                 save_options=None):
+    """
+    Plotting scheme related to Schmidt decomposition.
+    Converts a state into a matrix (A_ij -> A_i^j),
+    where rows are first particles and columns - last.
+
+    See also: plot_qubism with how='before_after' for a similar plot.
+
+    .. note::
+
+        colorblind_safe does not apply because of its unique colormap
+
+    Parameters
+    ----------
+    kets : list of Qobj
+        list of pure state for plotting.
+
+    theme : 'light' or 'dark', default='light'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    splitting : int, optional
+        Plot for a number of first particles versus the rest.
+        If not given, it is (number of particles + 1) // 2.
+
+    labels_iteration : int or pair of ints, default=(3,2)
+        Number of particles to be shown as tick labels,
+        for first (vertical) and last (horizontal) particles, respectively.
+
+    fig : a matplotlib figure instance, optional
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance, optional
+        The axis context in which the plot will be drawn.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation'
+            The output filename, e.g., :file:`mymovie.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    fig, ax : tuple
+        A tuple of the matplotlib figure and axes instances used to produce
+        the figure.
+
+    """
+
+    fig, ax = _is_fig_and_ax(fig, ax)
+
+    artist_list = list()
+    for ket in kets:
+        if not isket(ket):
+            err = "Schmidt plot works only for pure states, i.e. kets."
+            raise Exception(err)
+
+        dim_list = ket.dims[0]
+
+        if splitting is None:
+            splitting = (len(dim_list) + 1) // 2
+
+        if isinstance(labels_iteration, int):
+            labels_iteration = labels_iteration, labels_iteration
+
+        ketdata = ket.full()
+
+        dim_list_y = dim_list[:splitting]
+        dim_list_x = dim_list[splitting:]
+
+        size_x = np.prod(dim_list_x)
+        size_y = np.prod(dim_list_y)
+
+        ketdata = ketdata.reshape((size_y, size_x))
+
+        artist = [ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
+                            interpolation="none",
+                            extent=(0, size_x, 0, size_y))]
+        artist_list.append(artist)
+
+    dim_list_small_x = dim_list_x[:labels_iteration[1]]
+    dim_list_small_y = dim_list_y[:labels_iteration[0]]
+
+    quadrants_x = np.prod(dim_list_small_x)
+    quadrants_y = np.prod(dim_list_small_y)
+
+    ticks_x = [size_x / quadrants_x * (i + 0.5)
+               for i in range(quadrants_x)]
+    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
+               for i in range(quadrants_y)]
+
+    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
+                                                      dim_list=dim_list_x))
+                for i in range(quadrants_x)]
+    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
+                                                      dim_list=dim_list_y))
+                for i in range(quadrants_y)]
+
+    ax.set_xticks(ticks_x)
+    ax.set_xticklabels(labels_x)
+    ax.set_yticks(ticks_y)
+    ax.set_yticklabels(labels_y)
+    ax.set_xlabel("last particles")
+    ax.set_ylabel("first particles")
+
+    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                    blit=True, repeat_delay=1000)
+    plt.close()
+
+    ani, html_video = make_html_video(ani, save_options)
+
+    return fig, ani, html_video
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 0802b472c7..6e5be6ddec 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -11,7 +11,8 @@
            '_sequential_cmap', '_is_fig_and_ax', '_cb_labels',
            '_get_matrix_components', '_update_xaxis', '_update_yaxis',
            '_update_zaxis', '_stick_to_planes', '_remove_margins',
-           '_set_ticklabels']
+           '_set_ticklabels', '_blob', '_sequence_to_latex',
+           '_index_to_sequence', '_to_qubism_index_pair']
 
 import warnings
 import itertools as it
@@ -219,7 +220,7 @@ def _blob(x, y, w, w_max, area, color_fn, ax=None):
     else:
         handle = plt
 
-    handle.fill(xcorners, ycorners, color=color_fn(w))
+    return handle.fill(xcorners, ycorners, color=color_fn(w))
 
 
 def _cb_labels(left_dims):

From c0fb1a447886d1d4a563880a9087b6695c82a555 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 30 Jul 2023 17:13:24 +0900
Subject: [PATCH 541/602] add doc

---
 doc/changes/2203.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2203.feature

diff --git a/doc/changes/2203.feature b/doc/changes/2203.feature
new file mode 100644
index 0000000000..d941d6cbc5
--- /dev/null
+++ b/doc/changes/2203.feature
@@ -0,0 +1 @@
+add animation
\ No newline at end of file

From 689aa8fcf066f9967bd60231bee175ad8bde990b Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 30 Jul 2023 17:16:00 +0900
Subject: [PATCH 542/602] delete an inner function

---
 qutip/animation.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index 7c49adba56..e65dad83ec 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -52,18 +52,12 @@ def _axes3D(*args, **kwargs):
 from .visualization import *
 
 
-def _is_options(options, keyward):
-    if options is None:
-        options = dict()
-
-    if not isinstance(options, dict):
-        raise ValueError(str(keyward) + ' must be a dict')
-
-    return options
-
-
 def make_html_video(ani, save_options=None):
-    save_options = _is_options(save_options, 'save_options')
+    if save_options is None:
+        save_options = dict()
+    if not isinstance(save_options, dict):
+        raise ValueError('save_options must be a dict')
+
     if 'name' not in save_options.keys():
         save_options['name'] = 'animation'
     if 'writer' not in save_options.keys():

From 6e006235cb1fd5584337296e47f4f211da18a169 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 2 Aug 2023 17:59:21 -0400
Subject: [PATCH 543/602] Update qutip/core/_brtools.pyx

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/core/_brtools.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/core/_brtools.pyx b/qutip/core/_brtools.pyx
index 623017eec8..e59b29838a 100644
--- a/qutip/core/_brtools.pyx
+++ b/qutip/core/_brtools.pyx
@@ -201,7 +201,7 @@ cdef class _EigenBasisTransform:
     def __init__(self, QobjEvo oper, bint sparse=False):
         if oper.dims[0] != oper.dims[1]:
             raise ValueError
-        if type(oper(0).data) in [_data.CSR, _data.Dia] and not sparse:
+        if type(oper(0).data) in (_data.CSR, _data.Dia) and not sparse:
             oper = oper.to(Dense)
         self.oper = oper
         self.isconstant = oper.isconstant

From d849d418128c3fd055f2b86e35b1deb005bcef24 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 6 Aug 2023 09:58:38 +0900
Subject: [PATCH 544/602] add animation

---
 qutip/__init__.py      |    1 -
 qutip/animation.py     | 1447 ----------------------------------------
 qutip/visualization.py |  820 ++++++++++++++---------
 3 files changed, 519 insertions(+), 1749 deletions(-)
 delete mode 100644 qutip/animation.py

diff --git a/qutip/__init__.py b/qutip/__init__.py
index 534d51b795..ccd47ddc1b 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -38,7 +38,6 @@
 # graphics
 from .bloch import *
 from .visualization import *
-from .animation import *
 from .orbital import *
 from .bloch3d import *
 from .matplotlib_utilities import *
diff --git a/qutip/animation.py b/qutip/animation.py
deleted file mode 100644
index e65dad83ec..0000000000
--- a/qutip/animation.py
+++ /dev/null
@@ -1,1447 +0,0 @@
-"""
-Functions for creating animations of results of quantum dynamics simulations,
-visualizations of quantum states and processes.
-"""
-
-__all__ = ['anim_wigner_sphere', 'anim_hinton', 'anim_sphereplot',
-           'anim_matrix_histogram', 'anim_fock_distribution',
-           'anim_wigner', 'anim_spin_distribution', 'anim_qubism',
-           'plot_schmidt']
-
-import warnings
-import itertools as it
-import numpy as np
-from numpy import pi, array, sin, cos, angle, log2
-
-from packaging.version import parse as parse_version
-
-from . import (
-    Qobj, isket, ket2dm, tensor, vector_to_operator, to_super, settings
-)
-from .core.dimensions import flatten
-from .core.superop_reps import _to_superpauli, isqubitdims
-from .wigner import wigner
-from .matplotlib_utilities import complex_phase_cmap
-
-try:
-    import matplotlib.pyplot as plt
-    import matplotlib as mpl
-    from matplotlib import cm
-    from mpl_toolkits.mplot3d import Axes3D
-
-    # Define a custom _axes3D function based on the matplotlib version.
-    # The auto_add_to_figure keyword is new for matplotlib>=3.4.
-    if parse_version(mpl.__version__) >= parse_version('3.4'):
-        def _axes3D(fig, *args, **kwargs):
-            ax = Axes3D(fig, *args, auto_add_to_figure=False, **kwargs)
-            return fig.add_axes(ax)
-    else:
-        def _axes3D(*args, **kwargs):
-            return Axes3D(*args, **kwargs)
-except:
-    pass
-
-import os
-from functools import partial
-from IPython.display import HTML
-from base64 import b64encode
-import matplotlib.animation as animation
-from qutip import plot_wigner
-import matplotlib.pyplot as plt
-import matplotlib as mpl
-from .visualization import *
-
-
-def make_html_video(ani, save_options=None):
-    if save_options is None:
-        save_options = dict()
-    if not isinstance(save_options, dict):
-        raise ValueError('save_options must be a dict')
-
-    if 'name' not in save_options.keys():
-        save_options['name'] = 'animation'
-    if 'writer' not in save_options.keys():
-        save_options['writer'] = None
-    if 'codec' not in save_options.keys():
-        save_options['codec'] = None
-
-    ani.save(save_options['name'] + '.mp4', fps=10,
-             writer=save_options['writer'], codec=save_options['codec'])
-    video = open(save_options['name'] + '.mp4', "rb").read()
-    video_encoded = b64encode(video).decode("ascii")
-    video_tag = '<video controls src="data:video/x-m4v;base64,{0}">'.format(
-        video_encoded)
-
-    return ani, HTML(video_tag)
-
-
-def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
-                       colorbar=True, fig=None, ax=None,
-                       save_options=None):
-    """Plots a coloured Bloch sphere.
-
-    Parameters
-    ----------
-    wigners : list of wigner functions
-        The wigner transformation at `steps` different theta and phi.
-
-    reflections : bool, default=False
-        If the reflections of the sphere should be plotted as well.
-
-    cmap : a matplotlib colormap instance, optional
-        Color map to use when plotting.
-
-    colorbar : bool, default=True
-        Whether (True) or not (False) a colorbar should be attached.
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The ax context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Notes
-    -----
-    Special thanks to Russell P Rundle for writing this function.
-    """
-
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-
-    if cmap is None:
-        cmap = _diverging_cmap()
-
-    ax.set_xlabel("x")
-    ax.set_ylabel("y")
-    ax.set_zlabel("z")
-
-    wigner_max = 0
-    for wigner in wigners:
-        wigner_max = max(np.real(np.amax(np.abs(wigner))), wigner_max)
-
-    artist_list = list()
-    for wigner in wigners:
-        steps = len(wigner)
-
-        theta = np.linspace(0, np.pi, steps)
-        phi = np.linspace(0, 2 * np.pi, steps)
-        x = np.outer(np.sin(theta), np.cos(phi))
-        y = np.outer(np.sin(theta), np.sin(phi))
-        z = np.outer(np.cos(theta), np.ones(steps))
-        wigner = np.real(wigner)
-
-        wigner_c1 = cmap((wigner + wigner_max) / (2 * wigner_max))
-
-        artist = list()
-        # Plot coloured Bloch sphere:
-        artist.append(ax.plot_surface(x, y, z, facecolors=wigner_c1,
-                                      vmin=-wigner_max, vmax=wigner_max,
-                                      rcount=steps, ccount=steps, linewidth=0,
-                                      zorder=0.5, antialiased=None))
-
-        if reflections:
-            wigner_c2 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
-                             (2*wigner_max))  # bottom
-            wigner_c3 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
-                             (2*wigner_max))  # side
-            wigner_c4 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
-                             (2*wigner_max))  # back
-
-            # Plot bottom reflection:
-            artist.append(ax.plot_surface(x[0:steps, 0:steps],
-                                          y[0:steps, 0:steps],
-                                          -1.5*np.ones((steps, steps)),
-                                          facecolors=wigner_c2,
-                                          vmin=-wigner_max, vmax=wigner_max,
-                                          rcount=steps/2, ccount=steps/2,
-                                          linewidth=0, zorder=0.5,
-                                          antialiased=False))
-
-            # Plot side reflection:
-            artist.append(ax.plot_surface(-1.5*np.ones((steps, steps)),
-                                          y[0:steps, 0:steps],
-                                          z[0:steps, 0:steps],
-                                          facecolors=wigner_c3,
-                                          vmin=-wigner_max, vmax=wigner_max,
-                                          rcount=steps/2, ccount=steps/2,
-                                          linewidth=0, zorder=0.5,
-                                          antialiased=False))
-
-            # Plot back reflection:
-            artist.append(ax.plot_surface(x[0:steps, 0:steps],
-                                          1.5*np.ones((steps, steps)),
-                                          z[0:steps, 0:steps],
-                                          facecolors=wigner_c4,
-                                          vmin=-wigner_max, vmax=wigner_max,
-                                          rcount=steps/2, ccount=steps/2,
-                                          linewidth=0, zorder=0.5,
-                                          antialiased=False))
-        artist_list.append(artist)
-
-    # Create colourbar:
-    if colorbar:
-        norm = mpl.colors.Normalize(-wigner_max, wigner_max)
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-# Adopted from the SciPy Cookbook.
-def anim_hinton(rhos, x_basis=None, y_basis=None, color_style="scaled",
-                label_top=True, *, cmap=None, colorbar=True, fig=None,
-                ax=None, save_options=None):
-    """Draws a Hinton diagram to visualize a density matrix or superoperator.
-
-    Parameters
-    ----------
-    rhos : list of qobj
-        List of input density matrices or superoperators.
-
-        .. note::
-
-            Hinton plots of superoperators are currently only
-            supported for qubits.
-
-    x_basis : list of strings, optional
-        list of x ticklabels to represent x basis of the input.
-
-    y_basis : list of strings, optional
-        list of y ticklabels to represent y basis of the input.
-
-    color_style : string, default="scaled"
-
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"scaled"`` (default), each color is chosen by
-           passing the absolute value of the corresponding matrix
-           element into `cmap` with the sign of the real part.
-        -  If set to ``"threshold"``, each square is plotted as
-           the maximum of `cmap` for the positive real part and as
-           the minimum for the negative part of the matrix element;
-           note that this generalizes `"threshold"` to complex numbers.
-        -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
-
-    label_top : bool, default=True
-        If True, x ticklabels will be placed on top, otherwise
-        they will appear below the plot.
-
-    cmap : a matplotlib colormap instance, optional
-        Color map to use when plotting.
-
-    colorbar : bool, default=True
-        Whether (True) or not (False) a colorbar should be attached.
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The ax context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not a quantum object.
-
-    Examples
-    --------
-    >>> import qutip
-    >>>
-    >>> dm = qutip.rand_dm(4)
-    >>> fig, ax = qutip.hinton(dm)
-    >>> fig.show()
-    >>>
-    >>> qutip.settings.colorblind_safe = True
-    >>> fig, ax = qutip.hinton(dm, color_style="threshold")
-    >>> fig.show()
-    >>> qutip.settings.colorblind_safe = False
-    >>>
-    >>> fig, ax = qutip.hinton(dm, color_style="phase")
-    >>> fig.show()
-    """
-
-    fig, ax = _is_fig_and_ax(fig, ax)
-
-    Ws = list()
-    w_max = 0
-    for rho in rhos:
-        # Extract plotting data W from the input.
-        if isinstance(rho, Qobj):
-            if rho.isoper or rho.isoperket or rho.isoperbra:
-                if rho.isoperket:
-                    rho = vector_to_operator(rho)
-                elif rho.isoperbra:
-                    rho = vector_to_operator(rho.dag())
-                W = rho.full()
-                # Create default labels if none are given.
-                if x_basis is None or y_basis is None:
-                    labels = _cb_labels(rho.dims[0])
-                    if x_basis is None:
-                        x_basis = list(labels[0])
-                    if y_basis is None:
-                        y_basis = list(labels[1])
-
-            elif rho.issuper:
-                if not isqubitdims(rho.dims):
-                    raise ValueError("Hinton plots of superoperators are "
-                                     "currently only supported for qubits.")
-                # Convert to a superoperator in the Pauli basis,
-                # so that all the elements are real.
-                sqobj = _to_superpauli(rho)
-                nq = int(log2(sqobj.shape[0]) / 2)
-                W = sqobj.full().T
-                # Create default labels, too.
-                if (x_basis is None) or (y_basis is None):
-                    labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                    if x_basis is None:
-                        x_basis = labels
-                    if y_basis is None:
-                        y_basis = labels
-
-            else:
-                raise ValueError(
-                    "Input quantum object must be "
-                    "an operator or superoperator.")
-        else:
-            W = rho
-        Ws.append(W)
-
-        height, width = W.shape
-
-        w_max = max(1.25 * max(abs(np.array(W)).flatten()), w_max)
-        if w_max <= 0.0:
-            w_max = 1.0
-
-    # Set color_fn here.
-    if color_style == "scaled":
-        if cmap is None:
-            cmap = _diverging_cmap()
-
-        def color_fn(w):
-            w = np.abs(w) * np.sign(np.real(w))
-            return cmap(int((w + w_max) * 256 / (2 * w_max)))
-    elif color_style == "threshold":
-        if cmap is None:
-            cmap = _diverging_cmap()
-
-        def color_fn(w):
-            w = np.real(w)
-            return cmap(255 if w > 0 else 0)
-    elif color_style == "phase":
-        if cmap is None:
-            cmap = _cyclic_cmap()
-
-        def color_fn(w):
-            return cmap(int(255 * (np.angle(w) / 2 / np.pi + 0.5)))
-    else:
-        raise ValueError(
-            "Unknown color style {} for Hinton diagrams.".format(color_style)
-        )
-
-    artist_list = list()
-    ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
-            color=cmap(128))
-    for W in Ws:
-        artist = list()
-        for x in range(width):
-            for y in range(height):
-                _x = x + 1
-                _y = y + 1
-                artist += _blob(_x - 0.5, height - _y + 0.5, W[y, x],
-                                w_max, min(1, abs(W[y, x]) / w_max),
-                                color_fn=color_fn, ax=ax)
-        artist_list.append(artist)
-
-    if colorbar:
-        vmax = np.pi if color_style == "phase" else w_max
-        norm = mpl.colors.Normalize(-vmax, vmax)
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-
-    # axis
-    if not (x_basis or y_basis):
-        ax.axis('off')
-    ax.axis('equal')
-    ax.set_frame_on(False)
-
-    # x axis
-    xticks = 0.5 + np.arange(width)
-    if x_basis:
-        _set_ticklabels(ax, x_basis, xticks, 'x')
-    if label_top:
-        ax.xaxis.tick_top()
-
-    # y axis
-    yticks = 0.5 + np.arange(height)
-    if y_basis:
-        _set_ticklabels(ax, list(reversed(y_basis)), yticks, 'y')
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-def anim_sphereplot(theta, phi, V, *, cmap=None, colorbar=True,
-                    fig=None, ax=None, save_options=None):
-    """Plots a matrix of values on a sphere
-
-    Parameters
-    ----------
-    theta : float
-        Angle with respect to z-axis. Its range is between 0 and pi
-
-    phi : float
-        Angle in x-y plane. Its range is between 0 and 2*pi
-
-    V : list
-        List of data sets to be plotted
-
-    cmap : a matplotlib colormap instance, optional
-        Color map to use when plotting.
-
-    colorbar : bool, default=True
-        Whether (True) or not (False) a colorbar should be attached.
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The axes context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-
-    if cmap is None:
-        cmap = _sequential_cmap()
-
-    thetam, phim = np.meshgrid(theta, phi)
-    xx = sin(thetam) * cos(phim)
-    yy = sin(thetam) * sin(phim)
-    zz = cos(thetam)
-    min_ph = pi
-    max_ph = -pi
-
-    r_and_ph = list()
-    for values in V:
-        r = array(abs(values))
-        ph = angle(values)
-        min_ph = min(min_ph, ph.min())
-        max_ph = max(max_ph, ph.max())
-        r_and_ph.append((r, ph))
-    # normalize color range based on phase angles in list ph
-    norm = mpl.colors.Normalize(min_ph, max_ph)
-
-    # plot with facecolors set to cm.jet colormap normalized to nrm
-    artist_list = list()
-    for r, ph in r_and_ph:
-        artist = [ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
-                                  facecolors=cmap(norm(ph)), linewidth=0,)]
-        artist_list.append(artist)
-
-    if colorbar:
-        # create new axes on plot for colorbar and shrink it a bit.
-        # pad shifts location of bar with repsect to the main plot
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.05)
-
-        # create new colorbar in axes cax with cmap and normalized to nrm like
-        # our facecolors
-        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-        # add our colorbar label
-        cb1.set_label('Angle')
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-def anim_matrix_histogram(Ms, x_basis=None, y_basis=None, limits=None,
-                          bar_style='real', color_limits=None,
-                          color_style='real', options=None, *,
-                          cmap=None, colorbar=True, fig=None, ax=None,
-                          save_options=None):
-    """
-    Draw a histogram for the matrix M, with the given x and y labels and title.
-
-    Parameters
-    ----------
-    Ms : list of matrices of Qobj
-        list of matrices to visualize
-
-    x_basis : list of strings, optional
-        list of x ticklabels
-
-    y_basis : list of strings, optional
-        list of y ticklabels
-
-    limits : list/array with two float numbers, optional
-        The z-axis limits [min, max]
-
-    bar_style : string, default="real"
-
-        -  If set to ``"real"`` (default), each bar is plotted
-           as the real part of the corresponding matrix element
-        -  If set to ``"img"``, each bar is plotted
-           as the imaginary part of the corresponding matrix element
-        -  If set to ``"abs"``, each bar is plotted
-           as the absolute value of the corresponding matrix element
-        -  If set to ``"phase"`` (default), each bar is plotted
-           as the angle of the corresponding matrix element
-
-    color_limits : list/array with two float numbers, optional
-        The limits of colorbar [min, max]
-
-    color_style : string, default="real"
-        Determines how colors are assigned to each square:
-
-        -  If set to ``"real"`` (default), each color is chosen
-           according to the real part of the corresponding matrix element.
-        -  If set to ``"img"``, each color is chosen according to
-           the imaginary part of the corresponding matrix element.
-        -  If set to ``"abs"``, each color is chosen according to
-           the absolute value of the corresponding matrix element.
-        -  If set to ``"phase"``, each color is chosen according to
-           the angle of the corresponding matrix element.
-
-    cmap : a matplotlib colormap instance, optional
-        Color map to use when plotting.
-
-    colorbar : bool, default=True
-        show colorbar
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The axes context in which the plot will be drawn.
-
-    options : dict, optional
-        A dictionary containing extra options for the plot.
-        The names (keys) and values of the options are
-        described below:
-
-        'zticks' : list of numbers, optional
-            A list of z-axis tick locations.
-
-        'bars_spacing' : float, default=0.1
-            spacing between bars.
-
-        'bars_alpha' : float, default=1.
-            transparency of bars, should be in range 0 - 1
-
-        'bars_lw' : float, default=0.5
-            linewidth of bars' edges.
-
-        'bars_edgecolor' : color, default='k'
-            The colors of the bars' edges.
-            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
-
-        'shade' : bool, default=True
-            Whether to shade the dark sides of the bars (True) or not (False).
-            The shading is relative to plot's source of light.
-
-        'azim' : float, default=-35
-            The azimuthal viewing angle.
-
-        'elev' : float, default=35
-            The elevation viewing angle.
-
-        'stick' : bool, default=False
-            Changes xlim and ylim in such a way that bars next to
-            XZ and YZ planes will stick to those planes.
-            This option has no effect if ``ax`` is passed as a parameter.
-
-        'cbar_pad' : float, default=0.04
-            The fraction of the original axes between the colorbar
-            and the new image axes.
-            (i.e. the padding between the 3D figure and the colorbar).
-
-        'cbar_to_z' : bool, default=False
-            Whether to set the color of maximum and minimum z-values to the
-            maximum and minimum colors in the colorbar (True) or not (False).
-
-        'threshold': float, optional
-            Threshold for when bars of smaller height should be transparent. If
-            not set, all bars are colored according to the color map.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Raises
-    ------
-    ValueError
-        Input argument is not valid.
-
-    """
-
-    # default options
-    default_opts = {'zticks': None, 'bars_spacing': 0.2,
-                    'bars_alpha': 1., 'bars_lw': 0.5, 'bars_edgecolor': 'k',
-                    'shade': True, 'azim': -35, 'elev': 35, 'stick': False,
-                    'cbar_pad': 0.04, 'cbar_to_z': False, 'threshold': None}
-
-    # update default_opts from input options
-    if options is None:
-        options = dict()
-
-    if isinstance(options, dict):
-        # check if keys in options dict are valid
-        if set(options) - set(default_opts):
-            raise ValueError("invalid key(s) found in options: "
-                             f"{', '.join(set(options) - set(default_opts))}")
-        else:
-            # updating default options
-            default_opts.update(options)
-            options = default_opts
-    else:
-        raise ValueError("options must be a dictionary")
-
-    _bars_and_colors = list()
-    for i in range(len(Ms)):
-        M = Ms[i]
-        if isinstance(M, Qobj):
-            if x_basis is None:
-                x_basis = list(_cb_labels([M.shape[0]])[0])
-            if y_basis is None:
-                y_basis = list(_cb_labels([M.shape[1]])[1])
-            # extract matrix data from Qobj
-            M = M.full()
-
-        n = np.size(M)
-        xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-        xpos = xpos.T.flatten() + 0.5
-        ypos = ypos.T.flatten() + 0.5
-        zpos = np.zeros(n)
-        dx = dy = (1 - options['bars_spacing']) * np.ones(n)
-
-        bar_M = _get_matrix_components(bar_style, M, 'bar_style')
-
-        if isinstance(limits, list) and \
-                len(limits) == 2:
-            z_min = limits[0]
-            z_max = limits[1]
-        else:
-            if i == 0:
-                z_min = min(bar_M)
-                z_max = max(bar_M)
-            else:
-                z_min = min(min(bar_M), z_min)
-                z_max = max(max(bar_M), z_max)
-
-            if z_min == z_max:
-                z_min -= 0.1
-                z_max += 0.1
-
-        color_M = _get_matrix_components(color_style, M, 'color_style')
-
-        if isinstance(color_limits, list) and \
-                len(color_limits) == 2:
-            c_min = color_limits[0]
-            c_max = color_limits[1]
-        else:
-            if color_style == 'phase':
-                c_min = -pi
-                c_max = pi
-            else:
-                if i == 0:
-                    c_min = min(color_M)
-                    c_max = max(color_M)
-                else:
-                    c_min = min(min(color_M), c_min)
-                    c_max = max(max(color_M), c_max)
-
-            if c_min == c_max:
-                c_min -= 0.1
-                c_max += 0.1
-        _bars_and_colors.append((bar_M, color_M))
-    norm = mpl.colors.Normalize(c_min, c_max)
-
-    if cmap is None:
-        # change later
-        if color_style == 'phase':
-            cmap = _cyclic_cmap()
-        else:
-            cmap = _sequential_cmap()
-
-    artist_list = list()
-    for bar_M, color_M in _bars_and_colors:
-        colors = cmap(norm(color_M))
-
-        colors[:, 3] = options['bars_alpha']
-
-        if options['threshold'] is not None:
-            colors[:, 3] *= 1 * (bar_M >= options['threshold'])
-
-            idx, = np.where(bar_M < options['threshold'])
-            bar_M[idx] = 0
-
-        fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-
-        artist = ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
-                          edgecolors=options['bars_edgecolor'],
-                          linewidths=options['bars_lw'],
-                          shade=options['shade'])
-        artist_list.append([artist])
-
-    # remove vertical lines on xz and yz plane
-    ax.yaxis._axinfo["grid"]['linewidth'] = 0
-    ax.xaxis._axinfo["grid"]['linewidth'] = 0
-
-    # x axis
-    _update_xaxis(options['bars_spacing'], M, ax, x_basis)
-
-    # y axis
-    _update_yaxis(options['bars_spacing'], M, ax, y_basis)
-
-    # z axis
-    _update_zaxis(ax, z_min, z_max, options['zticks'])
-
-    # stick to xz and yz plane
-    _stick_to_planes(options['stick'],
-                     options['azim'], ax, M,
-                     options['bars_spacing'])
-    ax.view_init(azim=options['azim'], elev=options['elev'])
-
-    # color axis
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
-                                         pad=options['cbar_pad'])
-        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-
-        if color_style == 'real':
-            cb.set_label('real')
-        elif color_style == 'img':
-            cb.set_label('imaginary')
-        elif color_style == 'abs':
-            cb.set_label('absolute')
-        else:
-            cb.set_label('arg')
-            if color_limits is None:
-                cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
-                cb.set_ticklabels(
-                    (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
-
-    # removing margins
-    _remove_margins(ax.xaxis)
-    _remove_margins(ax.yaxis)
-    _remove_margins(ax.zaxis)
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-    print(z_min, z_max)
-    return fig, ani, html_video
-
-
-def anim_fock_distribution(rhos, fock_numbers=None, color="green",
-                           unit_y_range=True, *, fig=None, ax=None,
-                           save_options=None):
-    """
-    Plot the Fock distribution for a density matrix (or ket) that describes
-    an oscillator mode.
-
-    Parameters
-    ----------
-    rhos : list of `qutip.Qobj`
-        The density matrices (or kets) to visualize.
-
-    fock_numbers : list of strings, optional
-        list of x ticklabels to represent fock numbers
-
-    color : color or list of colors, default="green"
-        The colors of the bar faces.
-
-    unit_y_range : bool, default=True
-        Set y-axis limits [0, 1] or not
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The axes context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    fig, ax = _is_fig_and_ax(fig, ax)
-
-    artist_list = list()
-    for rho in rhos:
-        if isket(rho):
-            rho = ket2dm(rho)
-
-        N = rho.shape[0]
-
-        artist = ax.bar(np.arange(N), np.real(rho.diag()),
-                        color=color, alpha=0.6, width=0.8).patches
-        artist_list.append(artist)
-
-    if fock_numbers:
-        _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
-
-    if unit_y_range:
-        ax.set_ylim(0, 1)
-    ax.set_xlim(-.5, N)
-    ax.set_xlabel('Fock number', fontsize=12)
-    ax.set_ylabel('Occupation probability', fontsize=12)
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
-                projection='2d', *, cmap=None, colorbar=False,
-                fig=None, ax=None, save_options=None):
-    """
-    Plot the time evolution of the Wigner function for density matrices
-    (or kets) hat describes an oscillator mode.
-
-    Parameters
-    ----------
-    rhos : list of `qutip.Qobj`
-        List of density matrices (or kets) to visualize.
-
-    xvec : array_like, optional
-        x-coordinates at which to calculate the Wigner function.
-
-    yvec : array_like, optional
-        y-coordinates at which to calculate the Wigner function.  Does not
-        apply to the 'fft' method.
-
-    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
-        default='clenshaw'
-        The method used for calculating the wigner function. See the
-        documentation for qutip.wigner for details.
-
-    projection: string {'2d', '3d'}, default='2d'
-        Specify whether the Wigner function is to be plotted as a
-        contour graph ('2d') or surface plot ('3d').
-
-    cmap : a matplotlib cmap instance, optional
-        The colormap.
-
-    colorbar : bool, default=False
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    fig : a matplotlib Figure instance, optional
-        The Figure canvas in which the plot will be drawn.
-
-    ax : a matplotlib axes instance, optional
-        The axes context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    wlim = 0
-    Ws = list()
-    artist_list = list()
-
-    if projection not in ('2d', '3d'):
-        raise ValueError('Unexpected value of projection keyword argument')
-    fig, ax = _is_fig_and_ax(fig, ax, projection)
-
-    for rho in rhos:
-        if isket(rho):
-            rho = ket2dm(rho)
-
-        if xvec is None:
-            xvec = np.linspace(-7.5, 7.5, 200)
-        if yvec is None:
-            yvec = np.linspace(-7.5, 7.5, 200)
-
-        W0 = wigner(rho, xvec, yvec, method=method)
-
-        W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
-        Ws.append(W)
-
-        wlim = max(abs(W).max(), wlim)
-
-    norm = mpl.colors.Normalize(-wlim, wlim)
-    if cmap is None:
-        cmap = mpl.cm.RdBu
-
-    for W in Ws:
-        if projection == '2d':
-            cf = ax.contourf(xvec, yvec, W, 100, norm=norm,
-                             cmap=cmap).collections
-        else:
-            X, Y = np.meshgrid(xvec, yvec)
-            cf = [ax.plot_surface(X, Y, W, rstride=5, cstride=5, linewidth=0.5,
-                                  norm=norm, cmap=cmap)]
-        artist_list.append(cf)
-
-    ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
-    ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
-
-    if colorbar:
-        if projection == '2d':
-            shrink = 1
-        else:
-            shrink = .75
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
-        cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-
-    ax.set_title("Wigner function", fontsize=12)
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
-                           cmap=None, colorbar=False, fig=None,
-                           ax=None, save_options=None):
-    """
-    Plots a spin distribution (given as meshgrid data).
-
-    Parameters
-    ----------
-    Ps : matrices
-        List of distribution values as a meshgrid matrix.
-
-    THETA : matrix
-        Meshgrid matrix for the theta coordinate. Its range is between 0 and pi
-
-    PHI : matrix
-        Meshgrid matrix for the phi coordinate. Its range is between 0 and 2*pi
-
-    projection: string {'2d', '3d'}, default='2d'
-        Specify whether the spin distribution function is to be plotted as a 2D
-        projection where the surface of the unit sphere is mapped on
-        the unit disk ('2d') or surface plot ('3d').
-
-    cmap : a matplotlib cmap instance, optional
-        The colormap.
-
-    colorbar : bool, default=False
-        Whether (True) or not (False) a colorbar should be attached to the
-        Wigner function graph.
-
-    fig : a matplotlib figure instance, optional
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance, optional
-        The axis context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-    """
-
-    if projection in ('2d', '3d'):
-        fig, ax = _is_fig_and_ax(fig, ax, projection)
-    else:
-        raise ValueError('Unexpected value of projection keyword argument')
-    min_P = Ps[0].min()
-    max_P = Ps[0].max()
-    for P in Ps:
-        min_P = min(min_P, P.min())
-        max_P = max(max_P, P.max())
-
-    if cmap is None:
-        if min_P < -1e12:
-            cmap = _diverging_cmap()
-            norm = mpl.colors.Normalize(-max_P, max_P)
-        else:
-            cmap = _sequential_cmap()
-            norm = mpl.colors.Normalize(min_P, max_P)
-
-    artist_list = list()
-    if projection == '2d':
-        Y = (THETA - pi / 2) / (pi / 2)
-        X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-        for P in Ps:
-            artist_list.append([ax.pcolor(X, Y, P.real, cmap=cmap)])
-        ax.set_xlabel(r'$\varphi$', fontsize=18)
-        ax.set_ylabel(r'$\theta$', fontsize=18)
-        ax.axis('equal')
-        ax.set_xticks([-1, 0, 1])
-        ax.set_xticklabels([r'$0$', r'$\pi$', r'$2\pi$'], fontsize=18)
-        ax.set_yticks([-1, 0, 1])
-        ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
-    else:
-        ax.view_init(azim=-35, elev=35)
-
-        xx = sin(THETA) * cos(PHI)
-        yy = sin(THETA) * sin(PHI)
-        zz = cos(THETA)
-        for P in Ps:
-            artist = [ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-                      facecolors=cmap(norm(P)), linewidth=0)]
-            artist_list.append(artist)
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
-        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-        cb1.set_label('magnitude')
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-def anim_qubism(kets, theme='light', how='pairs', grid_iteration=1,
-                legend_iteration=0, *, fig=None, ax=None, save_options=None):
-    """
-    Qubism plot for pure states of many qudits.  Works best for spin chains,
-    especially with even number of particles of the same dimension.  Allows to
-    see entanglement between first 2k particles and the rest.
-
-    .. note::
-
-        colorblind_safe does not apply because of its unique colormap
-
-    Parameters
-    ----------
-    kets : list of Qobj
-        list of pure states for plotting.
-
-    theme : 'light' or 'dark', default='light'
-        Set coloring theme for mapping complex values into colors.
-        See: complex_array_to_rgb.
-
-    how : 'pairs', 'pairs_skewed' or 'before_after', default='pairs'
-        Type of Qubism plotting.  Options:
-
-        - 'pairs' - typical coordinates,
-        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
-        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
-
-    grid_iteration : int, default=1
-        Helper lines to be drawn on plot.
-        Show tiles for 2*grid_iteration particles vs all others.
-
-    legend_iteration : int or 'grid_iteration' or 'all', default=0
-        Show labels for first ``2*legend_iteration`` particles.  Option
-        'grid_iteration' sets the same number of particles as for
-        grid_iteration.  Option 'all' makes label for all particles.  Typically
-        it should be 0, 1, 2 or perhaps 3.
-
-    fig : a matplotlib figure instance, optional
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance, optional
-        The axis context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    Notes
-    -----
-    See also [1]_.
-
-    References
-    ----------
-    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
-       and G. Sierra, *Qubism: self-similar visualization of many-body
-       wavefunctions*, `New J. Phys. 14 053028
-       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
-       (2012), open access.
-    """
-
-    fig, ax = _is_fig_and_ax(fig, ax)
-
-    artist_list = list()
-    for ket in kets:
-        if not isket(ket):
-            raise Exception("Qubism works only for pure states, i.e. kets.")
-            # add for dm? (perhaps a separate function, plot_qubism_dm)
-
-        dim_list = ket.dims[0]
-        n = len(dim_list)
-
-        # for odd number of particles - pixels are rectangular
-        if n % 2 == 1:
-            ket = tensor(ket, Qobj([1] * dim_list[-1]))
-            dim_list = ket.dims[0]
-            n += 1
-
-        ketdata = ket.full()
-
-        if how == 'pairs':
-            dim_list_y = dim_list[::2]
-            dim_list_x = dim_list[1::2]
-        elif how == 'pairs_skewed':
-            dim_list_y = dim_list[::2]
-            dim_list_x = dim_list[1::2]
-            if dim_list_x != dim_list_y:
-                raise Exception("For 'pairs_skewed' pairs " +
-                                "of dimensions need to be the same.")
-        elif how == 'before_after':
-            dim_list_y = list(reversed(dim_list[:(n // 2)]))
-            dim_list_x = dim_list[(n // 2):]
-        else:
-            raise Exception("No such 'how'.")
-
-        size_x = np.prod(dim_list_x)
-        size_y = np.prod(dim_list_y)
-
-        qub = np.zeros([size_x, size_y], dtype=complex)
-        for i in range(ketdata.size):
-            qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
-        qub = qub.transpose()
-
-        quadrants_x = np.prod(dim_list_x[:grid_iteration])
-        quadrants_y = np.prod(dim_list_y[:grid_iteration])
-
-        ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
-        ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
-
-        ax.set_xticks(ticks_x)
-        ax.set_xticklabels([""] * (quadrants_x - 1))
-        ax.set_yticks(ticks_y)
-        ax.set_yticklabels([""] * (quadrants_y - 1))
-        theme2color_of_lines = {'light': '#000000',
-                                'dark': '#FFFFFF'}
-        ax.grid(True, color=theme2color_of_lines[theme])
-        artist = [ax.imshow(complex_array_to_rgb(qub, theme=theme),
-                  interpolation="none",
-                  extent=(0, size_x, 0, size_y))]
-        artist_list.append(artist)
-
-    if legend_iteration == 'all':
-        label_n = n // 2
-    elif legend_iteration == 'grid_iteration':
-        label_n = grid_iteration
-    else:
-        try:
-            label_n = int(legend_iteration)
-        except:
-            raise Exception("No such option for legend_iteration keyword " +
-                            "argument. Use 'all', 'grid_iteration' or an " +
-                            "integer.")
-
-    if label_n:
-
-        if how == 'before_after':
-            dim_list_small = list(reversed(dim_list_y[-label_n:])) \
-                + dim_list_x[:label_n]
-        else:
-            dim_list_small = []
-            for j in range(label_n):
-                dim_list_small.append(dim_list_y[j])
-                dim_list_small.append(dim_list_x[j])
-
-        scale_x = float(size_x) / np.prod(dim_list_x[:label_n])
-        shift_x = 0.5 * scale_x
-        scale_y = float(size_y) / np.prod(dim_list_y[:label_n])
-        shift_y = 0.5 * scale_y
-
-        bbox = ax.get_window_extent().transformed(
-            fig.dpi_scale_trans.inverted())
-        fontsize = 35 * bbox.width / np.prod(dim_list_x[:label_n]) / label_n
-        opts = {'fontsize': fontsize,
-                'color': theme2color_of_lines[theme],
-                'horizontalalignment': 'center',
-                'verticalalignment': 'center'}
-        for i in range(np.prod(dim_list_small)):
-            x, y = _to_qubism_index_pair(i, dim_list_small, how=how)
-            seq = _index_to_sequence(i, dim_list=dim_list_small)
-            ax.text(scale_x * x + shift_x,
-                    size_y - (scale_y * y + shift_y),
-                    _sequence_to_latex(seq),
-                    **opts)
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
-
-
-def anim_schmidt(kets, theme='light', splitting=None,
-                 labels_iteration=(3, 2), *, fig=None, ax=None,
-                 save_options=None):
-    """
-    Plotting scheme related to Schmidt decomposition.
-    Converts a state into a matrix (A_ij -> A_i^j),
-    where rows are first particles and columns - last.
-
-    See also: plot_qubism with how='before_after' for a similar plot.
-
-    .. note::
-
-        colorblind_safe does not apply because of its unique colormap
-
-    Parameters
-    ----------
-    kets : list of Qobj
-        list of pure state for plotting.
-
-    theme : 'light' or 'dark', default='light'
-        Set coloring theme for mapping complex values into colors.
-        See: complex_array_to_rgb.
-
-    splitting : int, optional
-        Plot for a number of first particles versus the rest.
-        If not given, it is (number of particles + 1) // 2.
-
-    labels_iteration : int or pair of ints, default=(3,2)
-        Number of particles to be shown as tick labels,
-        for first (vertical) and last (horizontal) particles, respectively.
-
-    fig : a matplotlib figure instance, optional
-        The figure canvas on which the plot will be drawn.
-
-    ax : a matplotlib axis instance, optional
-        The axis context in which the plot will be drawn.
-
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
-
-        'name' : str, default='animation'
-            The output filename, e.g., :file:`mymovie.mp4`.
-
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
-
-    Returns
-    -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
-
-    """
-
-    fig, ax = _is_fig_and_ax(fig, ax)
-
-    artist_list = list()
-    for ket in kets:
-        if not isket(ket):
-            err = "Schmidt plot works only for pure states, i.e. kets."
-            raise Exception(err)
-
-        dim_list = ket.dims[0]
-
-        if splitting is None:
-            splitting = (len(dim_list) + 1) // 2
-
-        if isinstance(labels_iteration, int):
-            labels_iteration = labels_iteration, labels_iteration
-
-        ketdata = ket.full()
-
-        dim_list_y = dim_list[:splitting]
-        dim_list_x = dim_list[splitting:]
-
-        size_x = np.prod(dim_list_x)
-        size_y = np.prod(dim_list_y)
-
-        ketdata = ketdata.reshape((size_y, size_x))
-
-        artist = [ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
-                            interpolation="none",
-                            extent=(0, size_x, 0, size_y))]
-        artist_list.append(artist)
-
-    dim_list_small_x = dim_list_x[:labels_iteration[1]]
-    dim_list_small_y = dim_list_y[:labels_iteration[0]]
-
-    quadrants_x = np.prod(dim_list_small_x)
-    quadrants_y = np.prod(dim_list_small_y)
-
-    ticks_x = [size_x / quadrants_x * (i + 0.5)
-               for i in range(quadrants_x)]
-    ticks_y = [size_y / quadrants_y * (quadrants_y - i - 0.5)
-               for i in range(quadrants_y)]
-
-    labels_x = [_sequence_to_latex(_index_to_sequence(i*size_x // quadrants_x,
-                                                      dim_list=dim_list_x))
-                for i in range(quadrants_x)]
-    labels_y = [_sequence_to_latex(_index_to_sequence(i*size_y // quadrants_y,
-                                                      dim_list=dim_list_y))
-                for i in range(quadrants_y)]
-
-    ax.set_xticks(ticks_x)
-    ax.set_xticklabels(labels_x)
-    ax.set_yticks(ticks_y)
-    ax.set_yticklabels(labels_y)
-    ax.set_xlabel("last particles")
-    ax.set_ylabel("first particles")
-
-    ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                    blit=True, repeat_delay=1000)
-    plt.close()
-
-    ani, html_video = make_html_video(ani, save_options)
-
-    return fig, ani, html_video
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 6e5be6ddec..865a96b346 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,17 +7,14 @@
            'matrix_histogram', 'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
            'plot_spin_distribution', 'complex_array_to_rgb',
-           'plot_qubism', 'plot_schmidt', '_cyclic_cmap', '_diverging_cmap',
-           '_sequential_cmap', '_is_fig_and_ax', '_cb_labels',
-           '_get_matrix_components', '_update_xaxis', '_update_yaxis',
-           '_update_zaxis', '_stick_to_planes', '_remove_margins',
-           '_set_ticklabels', '_blob', '_sequence_to_latex',
-           '_index_to_sequence', '_to_qubism_index_pair']
+           'plot_qubism', 'plot_schmidt', 'make_html_video']
 
 import warnings
 import itertools as it
 import numpy as np
+import mimetypes
 from numpy import pi, array, sin, cos, angle, log2
+from IPython.display import HTML
 
 from packaging.version import parse as parse_version
 
@@ -32,6 +29,7 @@
 try:
     import matplotlib.pyplot as plt
     import matplotlib as mpl
+    import matplotlib.animation as animation
     from matplotlib import cm
     from mpl_toolkits.mplot3d import Axes3D
 
@@ -106,13 +104,60 @@ def _set_ticklabels(ax, ticklabels, ticks, axis, fontsize=14):
         )
 
 
+def make_html_video(ani, save_options=None):
+    """Plots a coloured Bloch sphere.
+
+    Parameters
+    ----------
+    ani : ArtistAnimation
+        The ArtistAnimation instance to be converted to HTML content.
+
+    save_options : dict, optional
+        A dictionary containing options to save the animation.
+
+        'name' : str, default='animation.mp4'
+            The output filename, e.g., :file:`animation.mp4`.
+
+        'writer' : `MovieWriter` or str, optional
+            A `MovieWriter` instance to use or a key that identifies a
+            class to use, such as 'ffmpeg'.
+
+        'codec' : str, optional
+            The video codec to use.  Not all codecs are supported by a given
+            `MovieWriter`.
+
+    Returns
+    -------
+    html : IPython.core.display.HTML
+        html video to display the animation
+    """
+    if save_options is None:
+        save_options = dict()
+    if not isinstance(save_options, dict):
+        raise ValueError('save_options must be a dict')
+
+    if 'file_path' not in save_options.keys():
+        save_options['file_path'] = 'animation.mp4'
+    if 'writer' not in save_options.keys():
+        save_options['writer'] = None
+    if 'codec' not in save_options.keys():
+        save_options['codec'] = None
+
+    ani.save(save_options['file_path'], fps=10,
+             writer=save_options['writer'], codec=save_options['codec'])
+    tag = mimetypes.guess_type(save_options['file_path'])[0].split('/')[0]
+    video_tag = '<'+tag+' controls src="'+save_options['file_path']+'" />'
+    html = HTML(video_tag)
+    return html
+
+
 def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
                        colorbar=True, fig=None, ax=None):
-    """Plots a coloured Bloch sphere.
+    """Plot or animate a coloured Bloch sphere.
 
     Parameters
     ----------
-    wigner : list of float
+    wigner : a wigner transformation or a list of transformations.
         The wigner transformation at `steps` different theta and phi.
 
     reflections : bool, default=False
@@ -132,9 +177,9 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
 
     Notes
     -----
@@ -150,59 +195,80 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     ax.set_ylabel("y")
     ax.set_zlabel("z")
 
-    steps = len(wigner)
-
-    theta = np.linspace(0, np.pi, steps)
-    phi = np.linspace(0, 2 * np.pi, steps)
-    x = np.outer(np.sin(theta), np.cos(phi))
-    y = np.outer(np.sin(theta), np.sin(phi))
-    z = np.outer(np.cos(theta), np.ones(steps))
-    wigner = np.real(wigner)
-    wigner_max = np.real(np.amax(np.abs(wigner)))
-
-    wigner_c1 = cmap((wigner + wigner_max) / (2 * wigner_max))
-
-    # Plot coloured Bloch sphere:
-    ax.plot_surface(x, y, z, facecolors=wigner_c1, vmin=-wigner_max,
-                    vmax=wigner_max, rcount=steps, ccount=steps, linewidth=0,
-                    zorder=0.5, antialiased=None)
-
-    if reflections:
-        wigner_c2 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
-                         (2*wigner_max))  # bottom
-        wigner_c3 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
-                         (2*wigner_max))  # side
-        wigner_c4 = cmap((wigner[0:steps, 0:steps]+wigner_max) /
-                         (2*wigner_max))  # back
-
-        # Plot bottom reflection:
-        ax.plot_surface(x[0:steps, 0:steps], y[0:steps, 0:steps],
-                        -1.5*np.ones((steps, steps)), facecolors=wigner_c2,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-        # Plot side reflection:
-        ax.plot_surface(-1.5*np.ones((steps, steps)), y[0:steps, 0:steps],
-                        z[0:steps, 0:steps], facecolors=wigner_c3,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
-
-        # Plot back reflection:
-        ax.plot_surface(x[0:steps, 0:steps], 1.5*np.ones((steps, steps)),
-                        z[0:steps, 0:steps], facecolors=wigner_c4,
-                        vmin=-wigner_max, vmax=wigner_max, rcount=steps/2,
-                        ccount=steps/2, linewidth=0, zorder=0.5,
-                        antialiased=False)
+    if not isinstance(wigner, list):
+        wigners = [wigner]
+    else:
+        wigners = wigner
+
+    wigner_max = 0
+    for wigner in wigners:
+        wigner_max = max(np.real(np.amax(np.abs(wigner))), wigner_max)
+
+    norm = mpl.colors.Normalize(-wigner_max, wigner_max)
+
+    artist_list = list()
+    for wigner in wigners:
+        steps = len(wigner)
+
+        theta = np.linspace(0, np.pi, steps)
+        phi = np.linspace(0, 2 * np.pi, steps)
+        x = np.outer(np.sin(theta), np.cos(phi))
+        y = np.outer(np.sin(theta), np.sin(phi))
+        z = np.outer(np.cos(theta), np.ones(steps))
+        wigner = np.real(wigner)
+
+        artist = list()
+        # Plot coloured Bloch sphere:
+        artist.append(ax.plot_surface(x, y, z, facecolors=cmap(norm(wigner)),
+                                      rcount=steps, ccount=steps, linewidth=0,
+                                      zorder=0.5, antialiased=None))
+
+        if reflections:
+            side_color = cmap(norm(wigner[0:steps, 0:steps]))
+
+            # Plot bottom reflection:
+            artist.append(ax.plot_surface(x[0:steps, 0:steps],
+                                          y[0:steps, 0:steps],
+                                          -1.5*np.ones((steps, steps)),
+                                          facecolors=side_color,
+                                          rcount=steps/2, ccount=steps/2,
+                                          linewidth=0, zorder=0.5,
+                                          antialiased=False))
+
+            # Plot side reflection:
+            artist.append(ax.plot_surface(-1.5*np.ones((steps, steps)),
+                                          y[0:steps, 0:steps],
+                                          z[0:steps, 0:steps],
+                                          facecolors=side_color,
+                                          rcount=steps/2, ccount=steps/2,
+                                          linewidth=0, zorder=0.5,
+                                          antialiased=False))
+
+            # Plot back reflection:
+            artist.append(ax.plot_surface(x[0:steps, 0:steps],
+                                          1.5*np.ones((steps, steps)),
+                                          z[0:steps, 0:steps],
+                                          facecolors=side_color,
+                                          rcount=steps/2, ccount=steps/2,
+                                          linewidth=0, zorder=0.5,
+                                          antialiased=False))
+        artist_list.append(artist)
 
     # Create colourbar:
     if colorbar:
-        norm = mpl.colors.Normalize(-wigner_max, wigner_max)
         cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
         mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
 
-    return fig, ax
+    if len(wigners) == 1:
+        output = ax
+
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        plt.close()
+        output = ani
+
+    return fig, output
 
 
 # Adopted from the SciPy Cookbook.
@@ -259,7 +325,7 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
     Parameters
     ----------
-    rho : qobj
+    rho : qobj or a list of qobj instances
         Input density matrix or superoperator.
 
         .. note::
@@ -305,9 +371,9 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
 
     Raises
     ------
@@ -333,51 +399,61 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
     fig, ax = _is_fig_and_ax(fig, ax)
 
-    # Extract plotting data W from the input.
-    if isinstance(rho, Qobj):
-        if rho.isoper or rho.isoperket or rho.isoperbra:
-            if rho.isoperket:
-                rho = vector_to_operator(rho)
-            elif rho.isoperbra:
-                rho = vector_to_operator(rho.dag())
-            W = rho.full()
-            # Create default labels if none are given.
-            if x_basis is None or y_basis is None:
-                labels = _cb_labels(rho.dims[0])
-                if x_basis is None:
-                    x_basis = list(labels[0])
-                if y_basis is None:
-                    y_basis = list(labels[1])
-
-        elif rho.issuper:
-            if not isqubitdims(rho.dims):
-                raise ValueError("Hinton plots of superoperators are "
-                                 "currently only supported for qubits.")
-            # Convert to a superoperator in the Pauli basis,
-            # so that all the elements are real.
-            sqobj = _to_superpauli(rho)
-            nq = int(log2(sqobj.shape[0]) / 2)
-            W = sqobj.full().T
-            # Create default labels, too.
-            if (x_basis is None) or (y_basis is None):
-                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                if x_basis is None:
-                    x_basis = labels
-                if y_basis is None:
-                    y_basis = labels
+    Ws = list()
+    w_max = 0
 
-        else:
-            raise ValueError(
-                "Input quantum object must be an operator or superoperator."
-            )
+    if not isinstance(rho, list):
+        rhos = [rho]
     else:
-        W = rho
+        rhos = rho
+
+    for rho in rhos:
+        # Extract plotting data W from the input.
+        if isinstance(rho, Qobj):
+            if rho.isoper or rho.isoperket or rho.isoperbra:
+                if rho.isoperket:
+                    rho = vector_to_operator(rho)
+                elif rho.isoperbra:
+                    rho = vector_to_operator(rho.dag())
+                W = rho.full()
+                # Create default labels if none are given.
+                if x_basis is None or y_basis is None:
+                    labels = _cb_labels(rho.dims[0])
+                    if x_basis is None:
+                        x_basis = list(labels[0])
+                    if y_basis is None:
+                        y_basis = list(labels[1])
+
+            elif rho.issuper:
+                if not isqubitdims(rho.dims):
+                    raise ValueError("Hinton plots of superoperators are "
+                                     "currently only supported for qubits.")
+                # Convert to a superoperator in the Pauli basis,
+                # so that all the elements are real.
+                sqobj = _to_superpauli(rho)
+                nq = int(log2(sqobj.shape[0]) / 2)
+                W = sqobj.full().T
+                # Create default labels, too.
+                if (x_basis is None) or (y_basis is None):
+                    labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+                    if x_basis is None:
+                        x_basis = labels
+                    if y_basis is None:
+                        y_basis = labels
+
+            else:
+                raise ValueError(
+                    "Input quantum object must be "
+                    "an operator or superoperator.")
+        else:
+            W = rho
+        Ws.append(W)
 
-    height, width = W.shape
+        height, width = W.shape
 
-    w_max = 1.25 * max(abs(np.array(W)).flatten())
-    if w_max <= 0.0:
-        w_max = 1.0
+        w_max = max(1.25 * max(abs(np.array(W)).flatten()), w_max)
+        if w_max <= 0.0:
+            w_max = 1.0
 
     # Set color_fn here.
     if color_style == "scaled":
@@ -405,18 +481,22 @@ def color_fn(w):
             "Unknown color style {} for Hinton diagrams.".format(color_style)
         )
 
+    artist_list = list()
     ax.fill(array([0, width, width, 0]), array([0, 0, height, height]),
             color=cmap(128))
-    for x in range(width):
-        for y in range(height):
-            _x = x + 1
-            _y = y + 1
-            _blob(
-                _x - 0.5, height - _y + 0.5, W[y, x], w_max,
-                min(1, abs(W[y, x]) / w_max), color_fn=color_fn, ax=ax)
+    for W in Ws:
+        artist = list()
+        for x in range(width):
+            for y in range(height):
+                _x = x + 1
+                _y = y + 1
+                artist += _blob(_x - 0.5, height - _y + 0.5, W[y, x],
+                                w_max, min(1, abs(W[y, x]) / w_max),
+                                color_fn=color_fn, ax=ax)
+        artist_list.append(artist)
 
     if colorbar:
-        vmax = np.pi if color_style == "phase" else abs(W).max()
+        vmax = np.pi if color_style == "phase" else w_max
         norm = mpl.colors.Normalize(-vmax, vmax)
         cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
         mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
@@ -439,7 +519,12 @@ def color_fn(w):
     if y_basis:
         _set_ticklabels(ax, list(reversed(y_basis)), yticks, 'y')
 
-    return fig, ax
+    if len(rhos) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 def sphereplot(theta, phi, values, *,
@@ -454,7 +539,7 @@ def sphereplot(theta, phi, values, *,
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    values : array
+    values : array or list of array instances
         Data set to be plotted
 
     cmap : a matplotlib colormap instance, optional
@@ -471,10 +556,11 @@ def sphereplot(theta, phi, values, *,
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
     """
+
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
     if cmap is None:
@@ -484,14 +570,30 @@ def sphereplot(theta, phi, values, *,
     xx = sin(thetam) * cos(phim)
     yy = sin(thetam) * sin(phim)
     zz = cos(thetam)
-    r = array(abs(values))
-    ph = angle(values)
+    min_ph = pi
+    max_ph = -pi
+
+    r_and_ph = list()
+    if not isinstance(values, list):
+        V = [values]
+    else:
+        V = values
+
+    for values in V:
+        r = array(abs(values))
+        ph = angle(values)
+        min_ph = min(min_ph, ph.min())
+        max_ph = max(max_ph, ph.max())
+        r_and_ph.append((r, ph))
     # normalize color range based on phase angles in list ph
-    norm = mpl.colors.Normalize(ph.min(), ph.max())
+    norm = mpl.colors.Normalize(min_ph, max_ph)
 
     # plot with facecolors set to cm.jet colormap normalized to nrm
-    ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
-                    facecolors=cmap(norm(ph)), linewidth=0,)
+    artist_list = list()
+    for r, ph in r_and_ph:
+        artist = [ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
+                                  facecolors=cmap(norm(ph)), linewidth=0,)]
+        artist_list.append(artist)
 
     if colorbar:
         # create new axes on plot for colorbar and shrink it a bit.
@@ -504,7 +606,12 @@ def sphereplot(theta, phi, values, *,
         # add our colorbar label
         cb1.set_label('Angle')
 
-    return fig, ax
+    if len(V) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 def _remove_margins(axis):
@@ -612,7 +719,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     Parameters
     ----------
-    M : Matrix of Qobj
+    M : Matrix of Qobj or list of matrices
         The matrix to visualize
 
     x_basis : list of strings, optional
@@ -713,9 +820,9 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
 
     Raises
     ------
@@ -746,52 +853,69 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     else:
         raise ValueError("options must be a dictionary")
 
-    if isinstance(M, Qobj):
-        if x_basis is None:
-            x_basis = list(_cb_labels([M.shape[0]])[0])
-        if y_basis is None:
-            y_basis = list(_cb_labels([M.shape[1]])[1])
-        # extract matrix data from Qobj
-        M = M.full()
-
-    n = np.size(M)
-    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-    xpos = xpos.T.flatten() + 0.5
-    ypos = ypos.T.flatten() + 0.5
-    zpos = np.zeros(n)
-    dx = dy = (1 - options['bars_spacing']) * np.ones(n)
-
-    bar_M = _get_matrix_components(bar_style, M, 'bar_style')
-
-    if isinstance(limits, list) and \
-            len(limits) == 2:
-        z_min = limits[0]
-        z_max = limits[1]
-    else:
-        z_min = min(bar_M)
-        z_max = max(bar_M)
-        if z_min == z_max:
-            z_min -= 0.1
-            z_max += 0.1
-
-    color_M = _get_matrix_components(color_style, M, 'color_style')
-
-    if isinstance(color_limits, list) and \
-            len(color_limits) == 2:
-        c_min = color_limits[0]
-        c_max = color_limits[1]
+    if not isinstance(M, list):
+        Ms = [M]
     else:
-        if color_style == 'phase':
-            c_min = -pi
-            c_max = pi
+        Ms = M
+
+    _bars_and_colors = list()
+    for i in range(len(Ms)):
+        M = Ms[i]
+        if isinstance(M, Qobj):
+            if x_basis is None:
+                x_basis = list(_cb_labels([M.shape[0]])[0])
+            if y_basis is None:
+                y_basis = list(_cb_labels([M.shape[1]])[1])
+            # extract matrix data from Qobj
+            M = M.full()
+
+        n = np.size(M)
+        xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+        xpos = xpos.T.flatten() + 0.5
+        ypos = ypos.T.flatten() + 0.5
+        zpos = np.zeros(n)
+        dx = dy = (1 - options['bars_spacing']) * np.ones(n)
+
+        bar_M = _get_matrix_components(bar_style, M, 'bar_style')
+
+        if isinstance(limits, list) and \
+                len(limits) == 2:
+            z_min = limits[0]
+            z_max = limits[1]
         else:
-            c_min = min(color_M)
-            c_max = max(color_M)
+            if i == 0:
+                z_min = min(bar_M)
+                z_max = max(bar_M)
+            else:
+                z_min = min(min(bar_M), z_min)
+                z_max = max(max(bar_M), z_max)
+
+            if z_min == z_max:
+                z_min -= 0.1
+                z_max += 0.1
 
-        if c_min == c_max:
-            c_min -= 0.1
-            c_max += 0.1
+        color_M = _get_matrix_components(color_style, M, 'color_style')
 
+        if isinstance(color_limits, list) and \
+                len(color_limits) == 2:
+            c_min = color_limits[0]
+            c_max = color_limits[1]
+        else:
+            if color_style == 'phase':
+                c_min = -pi
+                c_max = pi
+            else:
+                if i == 0:
+                    c_min = min(color_M)
+                    c_max = max(color_M)
+                else:
+                    c_min = min(min(color_M), c_min)
+                    c_max = max(max(color_M), c_max)
+
+            if c_min == c_max:
+                c_min -= 0.1
+                c_max += 0.1
+        _bars_and_colors.append((bar_M, color_M))
     norm = mpl.colors.Normalize(c_min, c_max)
 
     if cmap is None:
@@ -801,22 +925,26 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         else:
             cmap = _sequential_cmap()
 
-    colors = cmap(norm(color_M))
+    artist_list = list()
+    for bar_M, color_M in _bars_and_colors:
+        colors = cmap(norm(color_M))
 
-    colors[:, 3] = options['bars_alpha']
+        colors[:, 3] = options['bars_alpha']
 
-    if options['threshold'] is not None:
-        colors[:, 3] *= 1 * (bar_M >= options['threshold'])
+        if options['threshold'] is not None:
+            colors[:, 3] *= 1 * (bar_M >= options['threshold'])
 
-        idx, = np.where(bar_M < options['threshold'])
-        bar_M[idx] = 0
+            idx, = np.where(bar_M < options['threshold'])
+            bar_M[idx] = 0
 
-    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+        fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
+        artist = ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
+                          edgecolors=options['bars_edgecolor'],
+                          linewidths=options['bars_lw'],
+                          shade=options['shade'])
+        artist_list.append([artist])
 
-    ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
-             edgecolors=options['bars_edgecolor'],
-             linewidths=options['bars_lw'],
-             shade=options['shade'])
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
@@ -860,7 +988,12 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     _remove_margins(ax.yaxis)
     _remove_margins(ax.zaxis)
 
-    return fig, ax
+    if len(Ms) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
@@ -970,7 +1103,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
 
     Parameters
     ----------
-    rho :`qutip.Qobj`
+    rho : `qutip.Qobj` or list of `qutip.Qobj` instances
         The density matrix (or ket) of the state to visualize.
 
     fock_numbers : list of strings, optional
@@ -990,20 +1123,29 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
     """
 
     fig, ax = _is_fig_and_ax(fig, ax)
 
-    if isket(rho):
-        rho = ket2dm(rho)
+    if not isinstance(rho, list):
+        rhos = [rho]
+    else:
+        rhos = rho
 
-    N = rho.shape[0]
+    artist_list = list()
 
-    ax.bar(np.arange(N), np.real(rho.diag()),
-           color=color, alpha=0.6, width=0.8)
+    for rho in rhos:
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        N = rho.shape[0]
+
+        artist = ax.bar(np.arange(N), np.real(rho.diag()),
+                        color=color, alpha=0.6, width=0.8).patches
+        artist_list.append(artist)
 
     if fock_numbers:
         _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
@@ -1014,7 +1156,12 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
     ax.set_xlabel('Fock number', fontsize=12)
     ax.set_ylabel('Occupation probability', fontsize=12)
 
-    return fig, ax
+    if len(rhos) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
@@ -1026,7 +1173,7 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     Parameters
     ----------
-    rho : :class:`qutip.Qobj`
+    rho : `qutip.Qobj` or list of `qutip.Qobj` instances
         The density matrix (or ket) of the state to visualize.
 
     xvec : array_like, optional
@@ -1060,49 +1207,73 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
     """
 
+    wlim = 0
+    Ws = list()
+    artist_list = list()
+
     if projection not in ('2d', '3d'):
         raise ValueError('Unexpected value of projection keyword argument')
     fig, ax = _is_fig_and_ax(fig, ax, projection)
 
-    if isket(rho):
-        rho = ket2dm(rho)
+    if not isinstance(rho, list):
+        rhos = [rho]
+    else:
+        rhos = rho
+
+    for rho in rhos:
+        if isket(rho):
+            rho = ket2dm(rho)
+
+        if xvec is None:
+            xvec = np.linspace(-7.5, 7.5, 200)
+        if yvec is None:
+            yvec = np.linspace(-7.5, 7.5, 200)
 
-    if xvec is None:
-        xvec = np.linspace(-7.5, 7.5, 200)
-    if yvec is None:
-        yvec = np.linspace(-7.5, 7.5, 200)
+        W0 = wigner(rho, xvec, yvec, method=method)
 
-    W0 = wigner(rho, xvec, yvec, method=method)
+        W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
+        Ws.append(W)
 
-    W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
+        wlim = max(abs(W).max(), wlim)
 
-    wlim = abs(W).max()
     norm = mpl.colors.Normalize(-wlim, wlim)
     if cmap is None:
-        cmap = _diverging_cmap()
+        cmap = mpl.cm.RdBu
 
-    if projection == '2d':
-        cf = ax.contourf(xvec, yvec, W, 100, norm=norm, cmap=cmap)
-    else:
-        X, Y = np.meshgrid(xvec, yvec)
-        cf = ax.plot_surface(X, Y, W0, rstride=5, cstride=5, linewidth=0.5,
-                             norm=norm, cmap=cmap)
+    for W in Ws:
+        if projection == '2d':
+            cf = ax.contourf(xvec, yvec, W, 100, norm=norm,
+                             cmap=cmap).collections
+        else:
+            X, Y = np.meshgrid(xvec, yvec)
+            cf = [ax.plot_surface(X, Y, W, rstride=5, cstride=5, linewidth=0.5,
+                                  norm=norm, cmap=cmap)]
+        artist_list.append(cf)
 
     ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
 
     if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, pad=.1)
-        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        if projection == '2d':
+            shrink = 1
+        else:
+            shrink = .75
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
+        cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
 
     ax.set_title("Wigner function", fontsize=12)
 
-    return fig, ax
+    if len(rhos) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 def plot_expectation_values(results, ylabels=None, *,
@@ -1197,28 +1368,41 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
     """
 
     if projection in ('2d', '3d'):
         fig, ax = _is_fig_and_ax(fig, ax, projection)
     else:
         raise ValueError('Unexpected value of projection keyword argument')
+
+    if not isinstance(P, list):
+        Ps = [P]
+    else:
+        Ps = P
+
+    min_P = Ps[0].min()
+    max_P = Ps[0].max()
+    for P in Ps:
+        min_P = min(min_P, P.min())
+        max_P = max(max_P, P.max())
+
     if cmap is None:
-        if P.min() < -1e12:
+        if min_P < -1e12:
             cmap = _diverging_cmap()
-            norm = mpl.colors.Normalize(-P.max(), P.max())
+            norm = mpl.colors.Normalize(-max_P, max_P)
         else:
             cmap = _sequential_cmap()
-            norm = mpl.colors.Normalize(P.min(), P.max())
+            norm = mpl.colors.Normalize(min_P, max_P)
 
+    artist_list = list()
     if projection == '2d':
         Y = (THETA - pi / 2) / (pi / 2)
         X = (pi - PHI) / pi * np.sqrt(cos(THETA - pi / 2))
-
-        ax.pcolor(X, Y, P.real, cmap=cmap)
+        for P in Ps:
+            artist_list.append([ax.pcolor(X, Y, P.real, cmap=cmap)])
         ax.set_xlabel(r'$\varphi$', fontsize=18)
         ax.set_ylabel(r'$\theta$', fontsize=18)
         ax.axis('equal')
@@ -1232,15 +1416,21 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
         xx = sin(THETA) * cos(PHI)
         yy = sin(THETA) * sin(PHI)
         zz = cos(THETA)
-
-        ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
-                        facecolors=cmap(norm(P)), linewidth=0)
+        for P in Ps:
+            artist = [ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
+                      facecolors=cmap(norm(P)), linewidth=0)]
+            artist_list.append(artist)
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
         cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
         cb1.set_label('magnitude')
 
-    return fig, ax
+    if len(Ps) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 #
@@ -1430,7 +1620,7 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
 
     Parameters
     ----------
-    ket : Qobj
+    ket : Qobj or list of Qobj instances
         Pure state for plotting.
 
     theme : 'light' or 'dark', default='light'
@@ -1462,9 +1652,9 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
 
     Notes
     -----
@@ -1481,60 +1671,68 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
 
     fig, ax = _is_fig_and_ax(fig, ax)
 
-    if not isket(ket):
-        raise Exception("Qubism works only for pure states, i.e. kets.")
-        # add for dm? (perhaps a separate function, plot_qubism_dm)
-
-    dim_list = ket.dims[0]
-    n = len(dim_list)
-
-    # for odd number of particles - pixels are rectangular
-    if n % 2 == 1:
-        ket = tensor(ket, Qobj([1] * dim_list[-1]))
-        dim_list = ket.dims[0]
-        n += 1
-
-    ketdata = ket.full()
-
-    if how == 'pairs':
-        dim_list_y = dim_list[::2]
-        dim_list_x = dim_list[1::2]
-    elif how == 'pairs_skewed':
-        dim_list_y = dim_list[::2]
-        dim_list_x = dim_list[1::2]
-        if dim_list_x != dim_list_y:
-            raise Exception("For 'pairs_skewed' pairs " +
-                            "of dimensions need to be the same.")
-    elif how == 'before_after':
-        dim_list_y = list(reversed(dim_list[:(n // 2)]))
-        dim_list_x = dim_list[(n // 2):]
+    if not isinstance(ket, list):
+        kets = [ket]
     else:
-        raise Exception("No such 'how'.")
-
-    size_x = np.prod(dim_list_x)
-    size_y = np.prod(dim_list_y)
-
-    qub = np.zeros([size_x, size_y], dtype=complex)
-    for i in range(ketdata.size):
-        qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
-    qub = qub.transpose()
+        kets = ket
 
-    quadrants_x = np.prod(dim_list_x[:grid_iteration])
-    quadrants_y = np.prod(dim_list_y[:grid_iteration])
+    artist_list = list()
+    for ket in kets:
+        if not isket(ket):
+            raise Exception("Qubism works only for pure states, i.e. kets.")
+            # add for dm? (perhaps a separate function, plot_qubism_dm)
 
-    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
-    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+        dim_list = ket.dims[0]
+        n = len(dim_list)
 
-    ax.set_xticks(ticks_x)
-    ax.set_xticklabels([""] * (quadrants_x - 1))
-    ax.set_yticks(ticks_y)
-    ax.set_yticklabels([""] * (quadrants_y - 1))
-    theme2color_of_lines = {'light': '#000000',
-                            'dark': '#FFFFFF'}
-    ax.grid(True, color=theme2color_of_lines[theme])
-    ax.imshow(complex_array_to_rgb(qub, theme=theme),
-              interpolation="none",
-              extent=(0, size_x, 0, size_y))
+        # for odd number of particles - pixels are rectangular
+        if n % 2 == 1:
+            ket = tensor(ket, Qobj([1] * dim_list[-1]))
+            dim_list = ket.dims[0]
+            n += 1
+
+        ketdata = ket.full()
+
+        if how == 'pairs':
+            dim_list_y = dim_list[::2]
+            dim_list_x = dim_list[1::2]
+        elif how == 'pairs_skewed':
+            dim_list_y = dim_list[::2]
+            dim_list_x = dim_list[1::2]
+            if dim_list_x != dim_list_y:
+                raise Exception("For 'pairs_skewed' pairs " +
+                                "of dimensions need to be the same.")
+        elif how == 'before_after':
+            dim_list_y = list(reversed(dim_list[:(n // 2)]))
+            dim_list_x = dim_list[(n // 2):]
+        else:
+            raise Exception("No such 'how'.")
+
+        size_x = np.prod(dim_list_x)
+        size_y = np.prod(dim_list_y)
+
+        qub = np.zeros([size_x, size_y], dtype=complex)
+        for i in range(ketdata.size):
+            qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
+        qub = qub.transpose()
+
+        quadrants_x = np.prod(dim_list_x[:grid_iteration])
+        quadrants_y = np.prod(dim_list_y[:grid_iteration])
+
+        ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
+        ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+
+        ax.set_xticks(ticks_x)
+        ax.set_xticklabels([""] * (quadrants_x - 1))
+        ax.set_yticks(ticks_y)
+        ax.set_yticklabels([""] * (quadrants_y - 1))
+        theme2color_of_lines = {'light': '#000000',
+                                'dark': '#FFFFFF'}
+        ax.grid(True, color=theme2color_of_lines[theme])
+        artist = [ax.imshow(complex_array_to_rgb(qub, theme=theme),
+                  interpolation="none",
+                  extent=(0, size_x, 0, size_y))]
+        artist_list.append(artist)
 
     if legend_iteration == 'all':
         label_n = n // 2
@@ -1578,7 +1776,12 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
                     size_y - (scale_y * y + shift_y),
                     _sequence_to_latex(seq),
                     **opts)
-    return fig, ax
+    if len(kets) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani
 
 
 def plot_schmidt(ket, theme='light', splitting=None,
@@ -1619,34 +1822,48 @@ def plot_schmidt(ket, theme='light', splitting=None,
 
     Returns
     -------
-    fig, ax : tuple
-        A tuple of the matplotlib figure and axes instances used to produce
-        the figure.
+    fig, output : tuple
+        A tuple of the matplotlib figure and the axes instance or animation
+        instance used to produce the figure.
 
     """
 
     fig, ax = _is_fig_and_ax(fig, ax)
 
-    if not isket(ket):
-        raise Exception("Schmidt plot works only for pure states, i.e. kets.")
+    if not isinstance(ket, list):
+        kets = [ket]
+    else:
+        kets = ket
 
-    dim_list = ket.dims[0]
+    artist_list = list()
 
-    if splitting is None:
-        splitting = (len(dim_list) + 1) // 2
+    for ket in kets:
+        if not isket(ket):
+            err = "Schmidt plot works only for pure states, i.e. kets."
+            raise Exception(err)
 
-    if isinstance(labels_iteration, int):
-        labels_iteration = labels_iteration, labels_iteration
+        dim_list = ket.dims[0]
+
+        if splitting is None:
+            splitting = (len(dim_list) + 1) // 2
+
+        if isinstance(labels_iteration, int):
+            labels_iteration = labels_iteration, labels_iteration
+
+        ketdata = ket.full()
 
-    ketdata = ket.full()
+        dim_list_y = dim_list[:splitting]
+        dim_list_x = dim_list[splitting:]
 
-    dim_list_y = dim_list[:splitting]
-    dim_list_x = dim_list[splitting:]
+        size_x = np.prod(dim_list_x)
+        size_y = np.prod(dim_list_y)
 
-    size_x = np.prod(dim_list_x)
-    size_y = np.prod(dim_list_y)
+        ketdata = ketdata.reshape((size_y, size_x))
 
-    ketdata = ketdata.reshape((size_y, size_x))
+        artist = [ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
+                            interpolation="none",
+                            extent=(0, size_x, 0, size_y))]
+        artist_list.append(artist)
 
     dim_list_small_x = dim_list_x[:labels_iteration[1]]
     dim_list_small_y = dim_list_y[:labels_iteration[0]]
@@ -1673,8 +1890,9 @@ def plot_schmidt(ket, theme='light', splitting=None,
     ax.set_xlabel("last particles")
     ax.set_ylabel("first particles")
 
-    ax.imshow(complex_array_to_rgb(ketdata, theme=theme),
-              interpolation="none",
-              extent=(0, size_x, 0, size_y))
-
-    return fig, ax
+    if len(kets) == 1:
+        return fig, ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        return fig, ani

From 8dda154d010c2fa502b4ecd22a6e6e3f1cd41d58 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 6 Aug 2023 11:49:05 +0900
Subject: [PATCH 545/602] add test

---
 qutip/tests/test_visualization.py | 132 ++++++++++++++++++++++++++++++
 qutip/visualization.py            |  63 ++++++--------
 2 files changed, 155 insertions(+), 40 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index a6582af9b6..90138445b5 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -3,6 +3,21 @@
 import numpy as np
 import matplotlib as mpl
 import matplotlib.pyplot as plt
+import os
+import shutil
+import IPython
+
+
+def setup_module(module):
+    """ setup any state specific to the execution of the given module."""
+    os.mkdir('animation')
+
+
+def teardown_module(module):
+    """teardown any state that was previously setup with a setup_module
+    method.
+    """
+    shutil.rmtree('animation')
 
 
 def test_cyclic():
@@ -86,6 +101,17 @@ def test_set_ticklabels():
     assert str(exc_info.value) == text
 
 
+def test_make_html_video():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.plot_wigner(rhos)
+    html = qutip.make_html_video(ani, './animation/ani.gif')
+    plt.close()
+
+    assert isinstance(html, IPython.core.display.HTML)
+
+
 @pytest.mark.parametrize('args', [
     ({'reflections': True}),
     ({'cmap': mpl.cm.cividis}),
@@ -102,6 +128,17 @@ def test_plot_wigner_sphere(args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_plot_wigner_sphere_anim():
+    psi = qutip.rand_ket(5)
+    wigner = qutip.wigner_transform(psi, 2, False, 50, ["x"])
+
+    fig, ani = qutip.plot_wigner_sphere([wigner]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 def to_oper_bra(oper):
     return qutip.operator_to_vector(oper).dag()
 
@@ -139,6 +176,17 @@ def test_hinton1():
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_hinton_anim():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.hinton(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 def test_hinton_ValueError0():
     text = "Input quantum object must be an operator or superoperator."
     rho = qutip.basis(2, 0)
@@ -179,6 +227,17 @@ def test_sphereplot(args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_sphereplot_anim():
+    theta = np.linspace(0, np.pi, 90)
+    phi = np.linspace(0, 2 * np.pi, 60)
+    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    fig, ani = qutip.sphereplot(theta, phi, [values]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 @pytest.mark.parametrize('response', [
     ('normal'),
     ('error')
@@ -280,6 +339,17 @@ def test_matrix_histogram_zeros():
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_matrix_histogram_anim():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.matrix_histogram(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 @pytest.mark.parametrize('args, expected', [
     ({'options': 'error'}, ("options must be a dictionary")),
     ({'options': {'e1': '1', 'e2': '2'}},
@@ -336,6 +406,17 @@ def test_plot_fock_distribution(rho_type, args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_plot_fock_distribution_anim():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.plot_fock_distribution(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 @pytest.mark.parametrize('rho_type, args', [
     ('oper', {}),
     ('ket', {}),
@@ -358,6 +439,17 @@ def test_plot_wigner(rho_type, args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_plot_wigner_anim():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.plot_wigner(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 def test_plot_wigner_ValueError():
     text = "Unexpected value of projection keyword argument"
     with pytest.raises(ValueError) as exc_info:
@@ -429,6 +521,26 @@ def test_plot_spin_distribution(color, args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+@pytest.mark.filterwarnings(
+    "ignore:The input coordinates to pcolor:UserWarning"
+)
+def test_plot_spin_distribution_anim():
+    j = 5
+    psi = qutip.spin_state(j, -j)
+    psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
+                              np.random.rand() * 2 * np.pi)
+    rho = qutip.ket2dm(psi)
+    theta = np.linspace(0, np.pi, 50)
+    phi = np.linspace(0, 2 * np.pi, 50)
+    Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
+
+    fig, ani = qutip.plot_spin_distribution([Q]*2, THETA, PHI)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 def test_plot_spin_distribution_ValueError():
     text = "Unexpected value of projection keyword argument"
     j = 5
@@ -480,6 +592,16 @@ def test_plot_qubism(dims, args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_plot_qubism_anim():
+    state = qutip.ket("01")
+
+    fig, ani = qutip.plot_qubism([state]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 @pytest.mark.parametrize('ket, args, expected', [
     (False, {}, "Qubism works only for pure states, i.e. kets."),
     (True, {'how': 'error'}, "No such 'how'."),
@@ -522,6 +644,16 @@ def test_plot_schmidt(args):
     assert isinstance(ax, mpl.axes.Axes)
 
 
+def test_plot_schmidt_anim():
+    state = qutip.ket("01")
+
+    fig, ani = qutip.plot_schmidt([state]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 def test_plot_schmidt_Error():
     state = qutip.bra("01")
     text = "Schmidt plot works only for pure states, i.e. kets."
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 865a96b346..8313a528a0 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -104,7 +104,7 @@ def _set_ticklabels(ax, ticklabels, ticks, axis, fontsize=14):
         )
 
 
-def make_html_video(ani, save_options=None):
+def make_html_video(ani, file_path, writer=None, codec=None):
     """Plots a coloured Bloch sphere.
 
     Parameters
@@ -112,41 +112,26 @@ def make_html_video(ani, save_options=None):
     ani : ArtistAnimation
         The ArtistAnimation instance to be converted to HTML content.
 
-    save_options : dict, optional
-        A dictionary containing options to save the animation.
+    'file_path' : str
+        The output file path, e.g., :file:`./animation.mp4`.
 
-        'name' : str, default='animation.mp4'
-            The output filename, e.g., :file:`animation.mp4`.
+    'writer' : `MovieWriter` or str, optional
+        A `MovieWriter` instance to use or a key that identifies a
+        class to use, such as 'ffmpeg'.
 
-        'writer' : `MovieWriter` or str, optional
-            A `MovieWriter` instance to use or a key that identifies a
-            class to use, such as 'ffmpeg'.
-
-        'codec' : str, optional
-            The video codec to use.  Not all codecs are supported by a given
-            `MovieWriter`.
+    'codec' : str, optional
+        The video codec to use.  Not all codecs are supported by a given
+        `MovieWriter`.
 
     Returns
     -------
     html : IPython.core.display.HTML
         html video to display the animation
     """
-    if save_options is None:
-        save_options = dict()
-    if not isinstance(save_options, dict):
-        raise ValueError('save_options must be a dict')
-
-    if 'file_path' not in save_options.keys():
-        save_options['file_path'] = 'animation.mp4'
-    if 'writer' not in save_options.keys():
-        save_options['writer'] = None
-    if 'codec' not in save_options.keys():
-        save_options['codec'] = None
-
-    ani.save(save_options['file_path'], fps=10,
-             writer=save_options['writer'], codec=save_options['codec'])
-    tag = mimetypes.guess_type(save_options['file_path'])[0].split('/')[0]
-    video_tag = '<'+tag+' controls src="'+save_options['file_path']+'" />'
+
+    ani.save(file_path, fps=10, writer=writer, codec=codec)
+    tag = mimetypes.guess_type(file_path)[0].split('/')[0]
+    video_tag = '<'+tag+' controls src="'+file_path+'" />'
     html = HTML(video_tag)
     return html
 
@@ -417,12 +402,11 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
                     rho = vector_to_operator(rho.dag())
                 W = rho.full()
                 # Create default labels if none are given.
-                if x_basis is None or y_basis is None:
-                    labels = _cb_labels(rho.dims[0])
-                    if x_basis is None:
-                        x_basis = list(labels[0])
-                    if y_basis is None:
-                        y_basis = list(labels[1])
+                labels = _cb_labels(rho.dims[0])
+                if x_basis is None:
+                    x_basis = list(labels[0])
+                if y_basis is None:
+                    y_basis = list(labels[1])
 
             elif rho.issuper:
                 if not isqubitdims(rho.dims):
@@ -434,12 +418,11 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
                 nq = int(log2(sqobj.shape[0]) / 2)
                 W = sqobj.full().T
                 # Create default labels, too.
-                if (x_basis is None) or (y_basis is None):
-                    labels = list(map("".join, it.product("IXYZ", repeat=nq)))
-                    if x_basis is None:
-                        x_basis = labels
-                    if y_basis is None:
-                        y_basis = labels
+                labels = list(map("".join, it.product("IXYZ", repeat=nq)))
+                if x_basis is None:
+                    x_basis = labels
+                if y_basis is None:
+                    y_basis = labels
 
             else:
                 raise ValueError(

From c1f72fcfb2c09b12719662d846d728989e15af0c Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Sun, 6 Aug 2023 11:50:13 +0900
Subject: [PATCH 546/602] doc

---
 qutip/visualization.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 8313a528a0..22113a97b4 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -112,14 +112,14 @@ def make_html_video(ani, file_path, writer=None, codec=None):
     ani : ArtistAnimation
         The ArtistAnimation instance to be converted to HTML content.
 
-    'file_path' : str
+    file_path : str
         The output file path, e.g., :file:`./animation.mp4`.
 
-    'writer' : `MovieWriter` or str, optional
+    writer : `MovieWriter` or str, optional
         A `MovieWriter` instance to use or a key that identifies a
         class to use, such as 'ffmpeg'.
 
-    'codec' : str, optional
+    codec : str, optional
         The video codec to use.  Not all codecs are supported by a given
         `MovieWriter`.
 

From 475c7a9f798f2516a78b096df576740e7a07c3c1 Mon Sep 17 00:00:00 2001
From: tamakoshi <tamakosiy@gmail.com>
Date: Mon, 7 Aug 2023 14:21:33 +0900
Subject: [PATCH 547/602] delete plt.close

---
 qutip/visualization.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 22113a97b4..b540e1b635 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -250,7 +250,6 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     else:
         ani = animation.ArtistAnimation(fig, artist_list, interval=50,
                                         blit=True, repeat_delay=1000)
-        plt.close()
         output = ani
 
     return fig, output

From 581c1c2f01db898cb22554db33f3a161b3222b5a Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 8 Aug 2023 07:12:11 +0900
Subject: [PATCH 548/602] sort code

---
 qutip/visualization.py | 301 +++++++++++++++++++++--------------------
 1 file changed, 153 insertions(+), 148 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index b540e1b635..282982623d 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -172,29 +172,24 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     """
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-
-    if cmap is None:
-        cmap = _diverging_cmap()
-
-    ax.set_xlabel("x")
-    ax.set_ylabel("y")
-    ax.set_zlabel("z")
-
+    
     if not isinstance(wigner, list):
         wigners = [wigner]
     else:
         wigners = wigner
 
-    wigner_max = 0
+    wigner_max = np.real(np.amax(np.abs(wigners[0])))
     for wigner in wigners:
         wigner_max = max(np.real(np.amax(np.abs(wigner))), wigner_max)
 
     norm = mpl.colors.Normalize(-wigner_max, wigner_max)
 
+    if cmap is None:
+        cmap = _diverging_cmap()
+
     artist_list = list()
     for wigner in wigners:
-        steps = len(wigner)
-
+        steps = len(wigners)
         theta = np.linspace(0, np.pi, steps)
         phi = np.linspace(0, 2 * np.pi, steps)
         x = np.outer(np.sin(theta), np.cos(phi))
@@ -239,19 +234,22 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
                                           antialiased=False))
         artist_list.append(artist)
 
-    # Create colourbar:
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-
     if len(wigners) == 1:
         output = ax
-
     else:
         ani = animation.ArtistAnimation(fig, artist_list, interval=50,
                                         blit=True, repeat_delay=1000)
         output = ani
 
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+    # Create colourbar:
+    if colorbar:
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+
     return fig, output
 
 
@@ -383,14 +381,13 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
     fig, ax = _is_fig_and_ax(fig, ax)
 
-    Ws = list()
-    w_max = 0
-
     if not isinstance(rho, list):
         rhos = [rho]
     else:
         rhos = rho
 
+    Ws = list()
+    w_max = 0
     for rho in rhos:
         # Extract plotting data W from the input.
         if isinstance(rho, Qobj):
@@ -477,11 +474,12 @@ def color_fn(w):
                                 color_fn=color_fn, ax=ax)
         artist_list.append(artist)
 
-    if colorbar:
-        vmax = np.pi if color_style == "phase" else w_max
-        norm = mpl.colors.Normalize(-vmax, vmax)
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
-        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+    if len(rhos) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
 
     # axis
     if not (x_basis or y_basis):
@@ -501,12 +499,13 @@ def color_fn(w):
     if y_basis:
         _set_ticklabels(ax, list(reversed(y_basis)), yticks, 'y')
 
-    if len(rhos) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+    if colorbar:
+        vmax = np.pi if color_style == "phase" else w_max
+        norm = mpl.colors.Normalize(-vmax, vmax)
+        cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
+        mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
+  
+    return fig, output
 
 
 def sphereplot(theta, phi, values, *,
@@ -545,38 +544,45 @@ def sphereplot(theta, phi, values, *,
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
 
-    if cmap is None:
-        cmap = _sequential_cmap()
-
-    thetam, phim = np.meshgrid(theta, phi)
-    xx = sin(thetam) * cos(phim)
-    yy = sin(thetam) * sin(phim)
-    zz = cos(thetam)
-    min_ph = pi
-    max_ph = -pi
-
-    r_and_ph = list()
     if not isinstance(values, list):
         V = [values]
     else:
         V = values
 
+    r_and_ph = list()
+    min_ph = pi
+    max_ph = -pi
     for values in V:
         r = array(abs(values))
         ph = angle(values)
         min_ph = min(min_ph, ph.min())
         max_ph = max(max_ph, ph.max())
         r_and_ph.append((r, ph))
+
     # normalize color range based on phase angles in list ph
     norm = mpl.colors.Normalize(min_ph, max_ph)
 
+    if cmap is None:
+        cmap = _sequential_cmap()
+
     # plot with facecolors set to cm.jet colormap normalized to nrm
+    thetam, phim = np.meshgrid(theta, phi)
+    xx = sin(thetam) * cos(phim)
+    yy = sin(thetam) * sin(phim)
+    zz = cos(thetam)
     artist_list = list()
     for r, ph in r_and_ph:
         artist = [ax.plot_surface(r * xx, r * yy, r * zz, rstride=1, cstride=1,
                                   facecolors=cmap(norm(ph)), linewidth=0,)]
         artist_list.append(artist)
 
+    if len(V) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
+
     if colorbar:
         # create new axes on plot for colorbar and shrink it a bit.
         # pad shifts location of bar with repsect to the main plot
@@ -588,12 +594,7 @@ def sphereplot(theta, phi, values, *,
         # add our colorbar label
         cb1.set_label('Angle')
 
-    if len(V) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+    return fig, output
 
 
 def _remove_margins(axis):
@@ -835,12 +836,13 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     else:
         raise ValueError("options must be a dictionary")
 
+    fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
+
     if not isinstance(M, list):
         Ms = [M]
     else:
         Ms = M
 
-    _bars_and_colors = list()
     for i in range(len(Ms)):
         M = Ms[i]
         if isinstance(M, Qobj):
@@ -851,13 +853,6 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             # extract matrix data from Qobj
             M = M.full()
 
-        n = np.size(M)
-        xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
-        xpos = xpos.T.flatten() + 0.5
-        ypos = ypos.T.flatten() + 0.5
-        zpos = np.zeros(n)
-        dx = dy = (1 - options['bars_spacing']) * np.ones(n)
-
         bar_M = _get_matrix_components(bar_style, M, 'bar_style')
 
         if isinstance(limits, list) and \
@@ -865,12 +860,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             z_min = limits[0]
             z_max = limits[1]
         else:
-            if i == 0:
-                z_min = min(bar_M)
-                z_max = max(bar_M)
-            else:
-                z_min = min(min(bar_M), z_min)
-                z_max = max(max(bar_M), z_max)
+            z_min = min(bar_M) if i==0 else min(min(bar_M), z_min)
+            z_max = max(bar_M) if i==0 else max(max(bar_M), z_max)
 
             if z_min == z_max:
                 z_min -= 0.1
@@ -887,17 +878,13 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                 c_min = -pi
                 c_max = pi
             else:
-                if i == 0:
-                    c_min = min(color_M)
-                    c_max = max(color_M)
-                else:
-                    c_min = min(min(color_M), c_min)
-                    c_max = max(max(color_M), c_max)
+                c_min = min(color_M) if i==0 else min(min(color_M), c_min)
+                c_max = min(color_M) if i==0 else max(max(color_M), c_max)
 
             if c_min == c_max:
                 c_min -= 0.1
                 c_max += 0.1
-        _bars_and_colors.append((bar_M, color_M))
+
     norm = mpl.colors.Normalize(c_min, c_max)
 
     if cmap is None:
@@ -908,7 +895,17 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             cmap = _sequential_cmap()
 
     artist_list = list()
-    for bar_M, color_M in _bars_and_colors:
+    for M in Ms:
+
+        if isinstance(M, Qobj):
+            M = M.full()
+
+        n = np.size(M)
+        xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
+        xpos = xpos.T.flatten() + 0.5
+        ypos = ypos.T.flatten() + 0.5
+        zpos = np.zeros(n)
+        dx = dy = (1 - options['bars_spacing']) * np.ones(n)
         colors = cmap(norm(color_M))
 
         colors[:, 3] = options['bars_alpha']
@@ -919,14 +916,19 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             idx, = np.where(bar_M < options['threshold'])
             bar_M[idx] = 0
 
-        fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-
         artist = ax.bar3d(xpos, ypos, zpos, dx, dy, bar_M, color=colors,
                           edgecolors=options['bars_edgecolor'],
                           linewidths=options['bars_lw'],
                           shade=options['shade'])
         artist_list.append([artist])
 
+    if len(Ms) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
+
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
     ax.xaxis._axinfo["grid"]['linewidth'] = 0
@@ -946,6 +948,11 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                      options['bars_spacing'])
     ax.view_init(azim=options['azim'], elev=options['elev'])
 
+    # removing margins
+    _remove_margins(ax.xaxis)
+    _remove_margins(ax.yaxis)
+    _remove_margins(ax.zaxis)
+
     # color axis
     if colorbar:
         cax, kw = mpl.colorbar.make_axes(ax, shrink=.75,
@@ -965,17 +972,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                 cb.set_ticklabels(
                     (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
 
-    # removing margins
-    _remove_margins(ax.xaxis)
-    _remove_margins(ax.yaxis)
-    _remove_margins(ax.zaxis)
-
-    if len(Ms) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+    return fig, output
 
 
 def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
@@ -1022,18 +1019,15 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
 
     """
 
-    fig, ax = _is_fig_and_ax(fig, ax)
-    ax.set_frame_on(False)
-
     if not isinstance(H_list, list):
         raise ValueError("H_list must be a list of Qobj instances")
 
+    fig, ax = _is_fig_and_ax(fig, ax)
+
     H = H_list[0]
     N = H.shape[0] if N == 0 else min(H.shape[0], N)
-
     xticks = []
     yticks = []
-
     x = 0
     evals0 = H.eigenenergies(eigvals=N)
     for e_idx, e in enumerate(evals0[:N]):
@@ -1058,6 +1052,8 @@ def plot_energy_levels(H_list, h_labels=None, energy_levels=None, N=0, *,
 
         evals0 = evals1
 
+    ax.set_frame_on(False)
+
     if energy_levels:
         yticks = np.unique(np.around(yticks, 1))
         _set_ticklabels(ax, energy_levels, yticks, 'y')
@@ -1118,7 +1114,6 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
         rhos = rho
 
     artist_list = list()
-
     for rho in rhos:
         if isket(rho):
             rho = ket2dm(rho)
@@ -1129,21 +1124,24 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
                         color=color, alpha=0.6, width=0.8).patches
         artist_list.append(artist)
 
+    if len(rhos) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
+
     if fock_numbers:
         _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
 
     if unit_y_range:
         ax.set_ylim(0, 1)
+        
     ax.set_xlim(-.5, N)
     ax.set_xlabel('Fock number', fontsize=12)
     ax.set_ylabel('Occupation probability', fontsize=12)
 
-    if len(rhos) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+    return fig, output
 
 
 def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
@@ -1194,12 +1192,9 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         instance used to produce the figure.
     """
 
-    wlim = 0
-    Ws = list()
-    artist_list = list()
-
     if projection not in ('2d', '3d'):
         raise ValueError('Unexpected value of projection keyword argument')
+
     fig, ax = _is_fig_and_ax(fig, ax, projection)
 
     if not isinstance(rho, list):
@@ -1207,15 +1202,14 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
     else:
         rhos = rho
 
+    wlim = 0
+    Ws = list()
+    xvec = np.linspace(-7.5, 7.5, 200) if xvec is None else xvec
+    yvec = np.linspace(-7.5, 7.5, 200) if yvec is None else yvec
     for rho in rhos:
         if isket(rho):
             rho = ket2dm(rho)
 
-        if xvec is None:
-            xvec = np.linspace(-7.5, 7.5, 200)
-        if yvec is None:
-            yvec = np.linspace(-7.5, 7.5, 200)
-
         W0 = wigner(rho, xvec, yvec, method=method)
 
         W, yvec = W0 if isinstance(W0, tuple) else (W0, yvec)
@@ -1224,9 +1218,11 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         wlim = max(abs(W).max(), wlim)
 
     norm = mpl.colors.Normalize(-wlim, wlim)
+
     if cmap is None:
-        cmap = mpl.cm.RdBu
+        cmap = _diverging_cmap()
 
+    artist_list = list()
     for W in Ws:
         if projection == '2d':
             cf = ax.contourf(xvec, yvec, W, 100, norm=norm,
@@ -1237,8 +1233,16 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
                                   norm=norm, cmap=cmap)]
         artist_list.append(cf)
 
+    if len(rhos) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
+
     ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
+    ax.set_title("Wigner function", fontsize=12)
 
     if colorbar:
         if projection == '2d':
@@ -1247,15 +1251,8 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
             shrink = .75
         cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
         cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-
-    ax.set_title("Wigner function", fontsize=12)
-
-    if len(rhos) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+    
+    return fig, output
 
 
 def plot_expectation_values(results, ylabels=None, *,
@@ -1301,7 +1298,7 @@ def plot_expectation_values(results, ylabels=None, *,
             axes = [axes]
         axes = np.array(axes)
 
-    for r_idx, result in enumerate(results):
+    for _, result in enumerate(results):
         for e_idx, e in enumerate(result.expect):
             axes[e_idx].plot(result.times, e,
                              label="%s [%d]" % (result.solver, e_idx))
@@ -1393,8 +1390,6 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
         ax.set_yticks([-1, 0, 1])
         ax.set_yticklabels([r'$\pi$', r'$\pi/2$', r'$0$'], fontsize=18)
     else:
-        ax.view_init(azim=-35, elev=35)
-
         xx = sin(THETA) * cos(PHI)
         yy = sin(THETA) * sin(PHI)
         zz = cos(THETA)
@@ -1402,17 +1397,21 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
             artist = [ax.plot_surface(xx, yy, zz, rstride=1, cstride=1,
                       facecolors=cmap(norm(P)), linewidth=0)]
             artist_list.append(artist)
-    if colorbar:
-        cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
-        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-        cb1.set_label('magnitude')
+        ax.view_init(azim=-35, elev=35)
 
     if len(Ps) == 1:
-        return fig, ax
+        output = ax
     else:
         ani = animation.ArtistAnimation(fig, artist_list, interval=50,
                                         blit=True, repeat_delay=1000)
-        return fig, ani
+        output = ani
+
+    if colorbar:
+        cax, _ = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
+        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
+        cb1.set_label('magnitude')
+
+    return fig, output
 
 
 #
@@ -1698,24 +1697,32 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
             qub[_to_qubism_index_pair(i, dim_list, how=how)] = ketdata[i, 0]
         qub = qub.transpose()
 
-        quadrants_x = np.prod(dim_list_x[:grid_iteration])
-        quadrants_y = np.prod(dim_list_y[:grid_iteration])
-
-        ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
-        ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
-
-        ax.set_xticks(ticks_x)
-        ax.set_xticklabels([""] * (quadrants_x - 1))
-        ax.set_yticks(ticks_y)
-        ax.set_yticklabels([""] * (quadrants_y - 1))
-        theme2color_of_lines = {'light': '#000000',
-                                'dark': '#FFFFFF'}
-        ax.grid(True, color=theme2color_of_lines[theme])
         artist = [ax.imshow(complex_array_to_rgb(qub, theme=theme),
                   interpolation="none",
                   extent=(0, size_x, 0, size_y))]
         artist_list.append(artist)
 
+    if len(kets) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
+
+    quadrants_x = np.prod(dim_list_x[:grid_iteration])
+    quadrants_y = np.prod(dim_list_y[:grid_iteration])
+
+    ticks_x = [size_x // quadrants_x * i for i in range(1, quadrants_x)]
+    ticks_y = [size_y // quadrants_y * i for i in range(1, quadrants_y)]
+
+    ax.set_xticks(ticks_x)
+    ax.set_xticklabels([""] * (quadrants_x - 1))
+    ax.set_yticks(ticks_y)
+    ax.set_yticklabels([""] * (quadrants_y - 1))
+    theme2color_of_lines = {'light': '#000000',
+                            'dark': '#FFFFFF'}
+    ax.grid(True, color=theme2color_of_lines[theme])
+
     if legend_iteration == 'all':
         label_n = n // 2
     elif legend_iteration == 'grid_iteration':
@@ -1758,12 +1765,8 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
                     size_y - (scale_y * y + shift_y),
                     _sequence_to_latex(seq),
                     **opts)
-    if len(kets) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+
+    return fig, output
 
 
 def plot_schmidt(ket, theme='light', splitting=None,
@@ -1847,6 +1850,13 @@ def plot_schmidt(ket, theme='light', splitting=None,
                             extent=(0, size_x, 0, size_y))]
         artist_list.append(artist)
 
+    if len(kets) == 1:
+        output = ax
+    else:
+        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                        blit=True, repeat_delay=1000)
+        output = ani
+
     dim_list_small_x = dim_list_x[:labels_iteration[1]]
     dim_list_small_y = dim_list_y[:labels_iteration[0]]
 
@@ -1872,9 +1882,4 @@ def plot_schmidt(ket, theme='light', splitting=None,
     ax.set_xlabel("last particles")
     ax.set_ylabel("first particles")
 
-    if len(kets) == 1:
-        return fig, ax
-    else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        return fig, ani
+    return fig, output

From 7c32a0f206ae8d9f4fe06a958c8b86743fc4c51b Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 8 Aug 2023 07:16:57 +0900
Subject: [PATCH 549/602] pep8

---
 qutip/visualization.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/qutip/visualization.py b/qutip/visualization.py
index 282982623d..e151fbc1e7 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -172,7 +172,7 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     """
 
     fig, ax = _is_fig_and_ax(fig, ax, projection='3d')
-    
+
     if not isinstance(wigner, list):
         wigners = [wigner]
     else:
@@ -504,7 +504,7 @@ def color_fn(w):
         norm = mpl.colors.Normalize(-vmax, vmax)
         cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1)
         mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap)
-  
+
     return fig, output
 
 
@@ -860,8 +860,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
             z_min = limits[0]
             z_max = limits[1]
         else:
-            z_min = min(bar_M) if i==0 else min(min(bar_M), z_min)
-            z_max = max(bar_M) if i==0 else max(max(bar_M), z_max)
+            z_min = min(bar_M) if i == 0 else min(min(bar_M), z_min)
+            z_max = max(bar_M) if i == 0 else max(max(bar_M), z_max)
 
             if z_min == z_max:
                 z_min -= 0.1
@@ -878,8 +878,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
                 c_min = -pi
                 c_max = pi
             else:
-                c_min = min(color_M) if i==0 else min(min(color_M), c_min)
-                c_max = min(color_M) if i==0 else max(max(color_M), c_max)
+                c_min = min(color_M) if i == 0 else min(min(color_M), c_min)
+                c_max = min(color_M) if i == 0 else max(max(color_M), c_max)
 
             if c_min == c_max:
                 c_min -= 0.1
@@ -1136,7 +1136,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
 
     if unit_y_range:
         ax.set_ylim(0, 1)
-        
+
     ax.set_xlim(-.5, N)
     ax.set_xlabel('Fock number', fontsize=12)
     ax.set_ylabel('Occupation probability', fontsize=12)
@@ -1251,7 +1251,7 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
             shrink = .75
         cax, kw = mpl.colorbar.make_axes(ax, shrink=shrink, pad=.1)
         cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
-    
+
     return fig, output
 
 

From 8c75e3e78cad6249fd1876fe93a142120329fc57 Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Sun, 13 Aug 2023 18:05:29 +0900
Subject: [PATCH 550/602] assert shape

---
 qutip/tests/test_visualization.py |  9 +++++++++
 qutip/visualization.py            | 30 +++++++++++++++++++++++++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 90138445b5..0944b35a17 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -101,6 +101,15 @@ def test_set_ticklabels():
     assert str(exc_info.value) == text
 
 
+def test_equal_shape():
+    rhos = [qutip.rand_dm(5)]*2 + [qutip.rand_dm(4)]
+    text = "All inputs should have the same shape."
+
+    with pytest.raises(Exception) as exc_info:
+        fig, ax = qutip.hinton(rhos)
+    assert str(exc_info.value) == text
+
+
 def test_make_html_video():
     rho = qutip.rand_dm(5)
     rhos = [rho]*2
diff --git a/qutip/visualization.py b/qutip/visualization.py
index e151fbc1e7..4950da776c 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -104,6 +104,14 @@ def _set_ticklabels(ax, ticklabels, ticks, axis, fontsize=14):
         )
 
 
+def _equal_shape(matrices):
+    first_shape = matrices[0].shape
+
+    text = "All inputs should have the same shape."
+    if not all(matrix.shape == first_shape for matrix in matrices):
+        raise ValueError(text)
+
+
 def make_html_video(ani, file_path, writer=None, codec=None):
     """Plots a coloured Bloch sphere.
 
@@ -178,6 +186,8 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     else:
         wigners = wigner
 
+    _equal_shape(wigners)
+
     wigner_max = np.real(np.amax(np.abs(wigners[0])))
     for wigner in wigners:
         wigner_max = max(np.real(np.amax(np.abs(wigner))), wigner_max)
@@ -386,6 +396,8 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
     else:
         rhos = rho
 
+    _equal_shape(rhos)
+
     Ws = list()
     w_max = 0
     for rho in rhos:
@@ -549,6 +561,8 @@ def sphereplot(theta, phi, values, *,
     else:
         V = values
 
+    _equal_shape(V)
+
     r_and_ph = list()
     min_ph = pi
     max_ph = -pi
@@ -843,6 +857,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     else:
         Ms = M
 
+    _equal_shape(Ms)
+
     for i in range(len(Ms)):
         M = Ms[i]
         if isinstance(M, Qobj):
@@ -900,6 +916,9 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
         if isinstance(M, Qobj):
             M = M.full()
 
+        bar_M = _get_matrix_components(bar_style, M, 'bar_style')
+        color_M = _get_matrix_components(color_style, M, 'color_style')
+
         n = np.size(M)
         xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
         xpos = xpos.T.flatten() + 0.5
@@ -1113,6 +1132,8 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
     else:
         rhos = rho
 
+    _equal_shape(rhos)
+
     artist_list = list()
     for rho in rhos:
         if isket(rho):
@@ -1202,6 +1223,8 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
     else:
         rhos = rho
 
+    _equal_shape(rhos)
+
     wlim = 0
     Ws = list()
     xvec = np.linspace(-7.5, 7.5, 200) if xvec is None else xvec
@@ -1242,7 +1265,6 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
-    ax.set_title("Wigner function", fontsize=12)
 
     if colorbar:
         if projection == '2d':
@@ -1362,6 +1384,8 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     else:
         Ps = P
 
+    _equal_shape(Ps)
+
     min_P = Ps[0].min()
     max_P = Ps[0].max()
     for P in Ps:
@@ -1657,6 +1681,8 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     else:
         kets = ket
 
+    _equal_shape(kets)
+
     artist_list = list()
     for ket in kets:
         if not isket(ket):
@@ -1820,6 +1846,8 @@ def plot_schmidt(ket, theme='light', splitting=None,
     else:
         kets = ket
 
+    _equal_shape(kets)
+
     artist_list = list()
 
     for ket in kets:

From e276ddec788cc7c56b5b8152e327f62d9809479f Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 15 Aug 2023 13:59:43 +0900
Subject: [PATCH 551/602] fix issues suggested

---
 qutip/tests/test_visualization.py | 12 -----
 qutip/visualization.py            | 83 ++++++++-----------------------
 2 files changed, 20 insertions(+), 75 deletions(-)

diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 0944b35a17..c978490472 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -5,7 +5,6 @@
 import matplotlib.pyplot as plt
 import os
 import shutil
-import IPython
 
 
 def setup_module(module):
@@ -110,17 +109,6 @@ def test_equal_shape():
     assert str(exc_info.value) == text
 
 
-def test_make_html_video():
-    rho = qutip.rand_dm(5)
-    rhos = [rho]*2
-
-    fig, ani = qutip.plot_wigner(rhos)
-    html = qutip.make_html_video(ani, './animation/ani.gif')
-    plt.close()
-
-    assert isinstance(html, IPython.core.display.HTML)
-
-
 @pytest.mark.parametrize('args', [
     ({'reflections': True}),
     ({'cmap': mpl.cm.cividis}),
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 4950da776c..f20f1b9df5 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -7,14 +7,12 @@
            'matrix_histogram', 'plot_energy_levels', 'plot_fock_distribution',
            'plot_wigner', 'plot_expectation_values',
            'plot_spin_distribution', 'complex_array_to_rgb',
-           'plot_qubism', 'plot_schmidt', 'make_html_video']
+           'plot_qubism', 'plot_schmidt']
 
 import warnings
 import itertools as it
 import numpy as np
-import mimetypes
 from numpy import pi, array, sin, cos, angle, log2
-from IPython.display import HTML
 
 from packaging.version import parse as parse_version
 
@@ -112,38 +110,6 @@ def _equal_shape(matrices):
         raise ValueError(text)
 
 
-def make_html_video(ani, file_path, writer=None, codec=None):
-    """Plots a coloured Bloch sphere.
-
-    Parameters
-    ----------
-    ani : ArtistAnimation
-        The ArtistAnimation instance to be converted to HTML content.
-
-    file_path : str
-        The output file path, e.g., :file:`./animation.mp4`.
-
-    writer : `MovieWriter` or str, optional
-        A `MovieWriter` instance to use or a key that identifies a
-        class to use, such as 'ffmpeg'.
-
-    codec : str, optional
-        The video codec to use.  Not all codecs are supported by a given
-        `MovieWriter`.
-
-    Returns
-    -------
-    html : IPython.core.display.HTML
-        html video to display the animation
-    """
-
-    ani.save(file_path, fps=10, writer=writer, codec=codec)
-    tag = mimetypes.guess_type(file_path)[0].split('/')[0]
-    video_tag = '<'+tag+' controls src="'+file_path+'" />'
-    html = HTML(video_tag)
-    return html
-
-
 def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
                        colorbar=True, fig=None, ax=None):
     """Plot or animate a coloured Bloch sphere.
@@ -199,7 +165,7 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
 
     artist_list = list()
     for wigner in wigners:
-        steps = len(wigners)
+        steps = len(wigner)
         theta = np.linspace(0, np.pi, steps)
         phi = np.linspace(0, 2 * np.pi, steps)
         x = np.outer(np.sin(theta), np.cos(phi))
@@ -247,9 +213,8 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
     if len(wigners) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     ax.set_xlabel("x")
     ax.set_ylabel("y")
@@ -489,9 +454,8 @@ def color_fn(w):
     if len(rhos) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     # axis
     if not (x_basis or y_basis):
@@ -593,9 +557,8 @@ def sphereplot(theta, phi, values, *,
     if len(V) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     if colorbar:
         # create new axes on plot for colorbar and shrink it a bit.
@@ -944,9 +907,8 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     if len(Ms) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     # remove vertical lines on xz and yz plane
     ax.yaxis._axinfo["grid"]['linewidth'] = 0
@@ -1148,9 +1110,8 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
     if len(rhos) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     if fock_numbers:
         _set_ticklabels(ax, fock_numbers, np.arange(N), 'x', fontsize=12)
@@ -1259,9 +1220,8 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
     if len(rhos) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     ax.set_xlabel(r'$\rm{Re}(\alpha)$', fontsize=12)
     ax.set_ylabel(r'$\rm{Im}(\alpha)$', fontsize=12)
@@ -1426,9 +1386,8 @@ def plot_spin_distribution(P, THETA, PHI, projection='2d', *,
     if len(Ps) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     if colorbar:
         cax, _ = mpl.colorbar.make_axes(ax, shrink=.66, pad=.1)
@@ -1731,9 +1690,8 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     if len(kets) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     quadrants_x = np.prod(dim_list_x[:grid_iteration])
     quadrants_y = np.prod(dim_list_y[:grid_iteration])
@@ -1881,9 +1839,8 @@ def plot_schmidt(ket, theme='light', splitting=None,
     if len(kets) == 1:
         output = ax
     else:
-        ani = animation.ArtistAnimation(fig, artist_list, interval=50,
-                                        blit=True, repeat_delay=1000)
-        output = ani
+        output = animation.ArtistAnimation(fig, artist_list, interval=50,
+                                           blit=True, repeat_delay=1000)
 
     dim_list_small_x = dim_list_x[:labels_iteration[1]]
     dim_list_small_y = dim_list_y[:labels_iteration[0]]

From f13001b877092f60e1795a70aed59c5113c6bdb0 Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 15 Aug 2023 14:24:07 +0900
Subject: [PATCH 552/602] animation.py

---
 qutip/__init__.py      |  1 +
 qutip/animation.py     | 53 ++++++++++++++++++++++++++++++++++++++++++
 qutip/visualization.py |  2 +-
 3 files changed, 55 insertions(+), 1 deletion(-)
 create mode 100644 qutip/animation.py

diff --git a/qutip/__init__.py b/qutip/__init__.py
index ccd47ddc1b..534d51b795 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -38,6 +38,7 @@
 # graphics
 from .bloch import *
 from .visualization import *
+from .animation import *
 from .orbital import *
 from .bloch3d import *
 from .matplotlib_utilities import *
diff --git a/qutip/animation.py b/qutip/animation.py
new file mode 100644
index 0000000000..1547c57d02
--- /dev/null
+++ b/qutip/animation.py
@@ -0,0 +1,53 @@
+"""
+Functions to animate results of quantum dynamics simulations,
+"""
+__all__ = ['anim_wigner_sphere']
+
+from . import plot_wigner_sphere
+
+try:
+    import matplotlib.pyplot as plt
+except Exception:
+    pass
+
+
+def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
+                       colorbar=True, fig=None, ax=None):
+    """Animate a coloured Bloch sphere.
+
+    Parameters
+    ----------
+    wigner : a list of transformations.
+        The wigner transformation at `steps` different theta and phi.
+
+    reflections : bool, default=False
+        If the reflections of the sphere should be plotted as well.
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The ax context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, output : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+
+    Notes
+    -----
+    Special thanks to Russell P Rundle for writing this function.
+    """
+
+    fig, ani = plot_wigner_sphere(wigners, reflections, cmap=cmap,
+                                  colorbar=colorbar, fig=fig, ax=ax)
+    plt.close(fig)
+
+    return fig, ani
diff --git a/qutip/visualization.py b/qutip/visualization.py
index f20f1b9df5..f8c8dcb41f 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -116,7 +116,7 @@ def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
 
     Parameters
     ----------
-    wigner : a wigner transformation or a list of transformations.
+    wigner : a wigner transformation
         The wigner transformation at `steps` different theta and phi.
 
     reflections : bool, default=False

From ddda95f07b6803f89920e4f70f81ea0945c76dd8 Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 15 Aug 2023 20:16:52 +0900
Subject: [PATCH 553/602] wrapper

---
 qutip/animation.py     | 524 ++++++++++++++++++++++++++++++++++++++++-
 qutip/visualization.py |  14 +-
 2 files changed, 528 insertions(+), 10 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index 1547c57d02..b2eda3087f 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -1,9 +1,13 @@
 """
 Functions to animate results of quantum dynamics simulations,
 """
-__all__ = ['anim_wigner_sphere']
+__all__ = ['anim_wigner_sphere', 'anim_hinton', 'anim_sphereplot',
+           'anim_matrix_histogram', 'anim_fock_distribution', 'anim_wigner',
+           'anim_spin_distribution', 'anim_qubism', 'anim_schmidt']
 
-from . import plot_wigner_sphere
+from . import (plot_wigner_sphere, hinton, sphereplot, matrix_histogram,
+               plot_fock_distribution, plot_wigner, plot_spin_distribution,
+               plot_qubism, plot_schmidt)
 
 try:
     import matplotlib.pyplot as plt
@@ -37,7 +41,7 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
 
     Returns
     -------
-    fig, output : tuple
+    fig, ani : tuple
         A tuple of the matplotlib figure and the animation instance
         used to produce the figure.
 
@@ -51,3 +55,517 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
     plt.close(fig)
 
     return fig, ani
+
+
+def anim_hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
+                label_top=True, *, cmap=None, colorbar=True,
+                fig=None, ax=None):
+    """Draws an animation of Hinton diagram.
+
+    Parameters
+    ----------
+    rho : a list of qobj instances
+        Input density matrix or superoperator.
+
+        .. note::
+
+            Hinton plots of superoperators are currently only
+            supported for qubits.
+
+    x_basis : list of strings, optional
+        list of x ticklabels to represent x basis of the input.
+
+    y_basis : list of strings, optional
+        list of y ticklabels to represent y basis of the input.
+
+    color_style : string, default="scaled"
+
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"scaled"`` (default), each color is chosen by
+           passing the absolute value of the corresponding matrix
+           element into `cmap` with the sign of the real part.
+        -  If set to ``"threshold"``, each square is plotted as
+           the maximum of `cmap` for the positive real part and as
+           the minimum for the negative part of the matrix element;
+           note that this generalizes `"threshold"` to complex numbers.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    label_top : bool, default=True
+        If True, x ticklabels will be placed on top, otherwise
+        they will appear below the plot.
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The ax context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not a quantum object.
+
+    """
+
+    fig, ani = hinton(rho, x_basis, y_basis, color_style, label_top,
+                      cmap=cmap, colorbar=colorbar, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_sphereplot(theta, phi, values, *, cmap=None,
+                    colorbar=True, fig=None, ax=None):
+    """animation of a matrices of values on a sphere
+
+    Parameters
+    ----------
+    theta : float
+        Angle with respect to z-axis. Its range is between 0 and pi
+
+    phi : float
+        Angle in x-y plane. Its range is between 0 and 2*pi
+
+    values : list of array instances
+        Data set to be plotted
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        Whether (True) or not (False) a colorbar should be attached.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+    """
+
+    fig, ani = sphereplot(theta, phi, values, cmap=cmap,
+                          colorbar=colorbar, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
+                          bar_style='real', color_limits=None,
+                          color_style='real', options=None, *, cmap=None,
+                          colorbar=True, fig=None, ax=None):
+    """
+    Draw an animation of a histogram for the matrix M,
+    with the given x and y labels.
+
+    Parameters
+    ----------
+    M : list of matrices
+        The matrix to visualize
+
+    x_basis : list of strings, optional
+        list of x ticklabels
+
+    y_basis : list of strings, optional
+        list of y ticklabels
+
+    limits : list/array with two float numbers, optional
+        The z-axis limits [min, max]
+
+    bar_style : string, default="real"
+
+        -  If set to ``"real"`` (default), each bar is plotted
+           as the real part of the corresponding matrix element
+        -  If set to ``"img"``, each bar is plotted
+           as the imaginary part of the corresponding matrix element
+        -  If set to ``"abs"``, each bar is plotted
+           as the absolute value of the corresponding matrix element
+        -  If set to ``"phase"`` (default), each bar is plotted
+           as the angle of the corresponding matrix element
+
+    color_limits : list/array with two float numbers, optional
+        The limits of colorbar [min, max]
+
+    color_style : string, default="real"
+        Determines how colors are assigned to each square:
+
+        -  If set to ``"real"`` (default), each color is chosen
+           according to the real part of the corresponding matrix element.
+        -  If set to ``"img"``, each color is chosen according to
+           the imaginary part of the corresponding matrix element.
+        -  If set to ``"abs"``, each color is chosen according to
+           the absolute value of the corresponding matrix element.
+        -  If set to ``"phase"``, each color is chosen according to
+           the angle of the corresponding matrix element.
+
+    cmap : a matplotlib colormap instance, optional
+        Color map to use when plotting.
+
+    colorbar : bool, default=True
+        show colorbar
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    options : dict, optional
+        A dictionary containing extra options for the plot.
+        The names (keys) and values of the options are
+        described below:
+
+        'zticks' : list of numbers, optional
+            A list of z-axis tick locations.
+
+        'bars_spacing' : float, default=0.1
+            spacing between bars.
+
+        'bars_alpha' : float, default=1.
+            transparency of bars, should be in range 0 - 1
+
+        'bars_lw' : float, default=0.5
+            linewidth of bars' edges.
+
+        'bars_edgecolor' : color, default='k'
+            The colors of the bars' edges.
+            Examples: 'k', (0.1, 0.2, 0.5) or '#0f0f0f80'.
+
+        'shade' : bool, default=True
+            Whether to shade the dark sides of the bars (True) or not (False).
+            The shading is relative to plot's source of light.
+
+        'azim' : float, default=-35
+            The azimuthal viewing angle.
+
+        'elev' : float, default=35
+            The elevation viewing angle.
+
+        'stick' : bool, default=False
+            Changes xlim and ylim in such a way that bars next to
+            XZ and YZ planes will stick to those planes.
+            This option has no effect if ``ax`` is passed as a parameter.
+
+        'cbar_pad' : float, default=0.04
+            The fraction of the original axes between the colorbar
+            and the new image axes.
+            (i.e. the padding between the 3D figure and the colorbar).
+
+        'cbar_to_z' : bool, default=False
+            Whether to set the color of maximum and minimum z-values to the
+            maximum and minimum colors in the colorbar (True) or not (False).
+
+        'threshold': float, optional
+            Threshold for when bars of smaller height should be transparent. If
+            not set, all bars are colored according to the color map.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+
+    Raises
+    ------
+    ValueError
+        Input argument is not valid.
+
+    """
+
+    fig, ani = matrix_histogram(M, x_basis, y_basis, limits, bar_style,
+                                color_limits, color_style, options, cmap=cmap,
+                                colorbar=colorbar, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_fock_distribution(rho, fock_numbers=None, color="green",
+                           unit_y_range=True, *, fig=None, ax=None):
+    """
+    Animation of the Fock distribution for a density matrix (or ket)
+    that describes an oscillator mode.
+
+    Parameters
+    ----------
+    rho : list of `qutip.Qobj` instances
+        The density matrix (or ket) of the state to visualize.
+
+    fock_numbers : list of strings, optional
+        list of x ticklabels to represent fock numbers
+
+    color : color or list of colors, default="green"
+        The colors of the bar faces.
+
+    unit_y_range : bool, default=True
+        Set y-axis limits [0, 1] or not
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+    """
+
+    fig, ani = plot_fock_distribution(rho, fock_numbers, color,
+                                      unit_y_range, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_wigner(rho, xvec=None, yvec=None, method='clenshaw',
+                projection='2d', *, cmap=None, colorbar=False,
+                fig=None, ax=None):
+    """
+    Animation of the Wigner function for a density matrix (or ket)
+    that describes an oscillator mode.
+
+    Parameters
+    ----------
+    rho : list of `qutip.Qobj` instances
+        The density matrix (or ket) of the state to visualize.
+
+    xvec : array_like, optional
+        x-coordinates at which to calculate the Wigner function.
+
+    yvec : array_like, optional
+        y-coordinates at which to calculate the Wigner function.  Does not
+        apply to the 'fft' method.
+
+    method : string {'clenshaw', 'iterative', 'laguerre', 'fft'},
+        default='clenshaw'
+        The method used for calculating the wigner function. See the
+        documentation for qutip.wigner for details.
+
+    projection: string {'2d', '3d'}, default='2d'
+        Specify whether the Wigner function is to be plotted as a
+        contour graph ('2d') or surface plot ('3d').
+
+    cmap : a matplotlib cmap instance, optional
+        The colormap.
+
+    colorbar : bool, default=False
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    fig : a matplotlib Figure instance, optional
+        The Figure canvas in which the plot will be drawn.
+
+    ax : a matplotlib axes instance, optional
+        The axes context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+    """
+
+    fig, ani = plot_wigner(rho, xvec, yvec, method, projection,
+                           cmap=cmap, colorbar=colorbar, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_spin_distribution(P, THETA, PHI, projection='2d', *,
+                           cmap=None, colorbar=False, fig=None, ax=None):
+    """
+    animation of a spin distribution (given as meshgrid data).
+
+    Parameters
+    ----------
+    P : list of matrices
+        Distribution values as a meshgrid matrix.
+
+    THETA : matrix
+        Meshgrid matrix for the theta coordinate. Its range is between 0 and pi
+
+    PHI : matrix
+        Meshgrid matrix for the phi coordinate. Its range is between 0 and 2*pi
+
+    projection: string {'2d', '3d'}, default='2d'
+        Specify whether the spin distribution function is to be plotted as a 2D
+        projection where the surface of the unit sphere is mapped on
+        the unit disk ('2d') or surface plot ('3d').
+
+    cmap : a matplotlib cmap instance, optional
+        The colormap.
+
+    colorbar : bool, default=False
+        Whether (True) or not (False) a colorbar should be attached to the
+        Wigner function graph.
+
+    fig : a matplotlib figure instance, optional
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance, optional
+        The axis context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+    """
+
+    fig, ani = plot_spin_distribution(P, THETA, PHI, projection, cmap=cmap,
+                                      colorbar=colorbar, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_qubism(ket, theme='light', how='pairs', grid_iteration=1,
+                legend_iteration=0, *, fig=None, ax=None):
+    """
+    Animation of Qubism plot for pure states of many qudits.
+    Works best for spin chains, especially with even number of particles
+    of the same dimension.  Allows to see entanglement between first
+    2k particles and the rest.
+
+    .. note::
+
+        colorblind_safe does not apply because of its unique colormap
+
+    Parameters
+    ----------
+    ket : list of Qobj instances
+        Pure states for animation.
+
+    theme : 'light' or 'dark', default='light'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    how : 'pairs', 'pairs_skewed' or 'before_after', default='pairs'
+        Type of Qubism plotting.  Options:
+
+        - 'pairs' - typical coordinates,
+        - 'pairs_skewed' - for ferromagnetic/antriferromagnetic plots,
+        - 'before_after' - related to Schmidt plot (see also: plot_schmidt).
+
+    grid_iteration : int, default=1
+        Helper lines to be drawn on plot.
+        Show tiles for 2*grid_iteration particles vs all others.
+
+    legend_iteration : int or 'grid_iteration' or 'all', default=0
+        Show labels for first ``2*legend_iteration`` particles.  Option
+        'grid_iteration' sets the same number of particles as for
+        grid_iteration.  Option 'all' makes label for all particles.  Typically
+        it should be 0, 1, 2 or perhaps 3.
+
+    fig : a matplotlib figure instance, optional
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance, optional
+        The axis context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+
+    Notes
+    -----
+    See also [1]_.
+
+    References
+    ----------
+    .. [1] J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein
+       and G. Sierra, *Qubism: self-similar visualization of many-body
+       wavefunctions*, `New J. Phys. 14 053028
+       <https://dx.doi.org/10.1088/1367-2630/14/5/053028>`_, arXiv:1112.3560
+       (2012), open access.
+    """
+
+    fig, ani = plot_qubism(ket, theme, how, grid_iteration,
+                           legend_iteration, fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
+
+
+def anim_schmidt(ket, theme='light', splitting=None,
+                 labels_iteration=(3, 2), *, fig=None, ax=None):
+    """
+    Animation of Schmidt decomposition.
+    Converts a state into a matrix (A_ij -> A_i^j),
+    where rows are first particles and columns - last.
+
+    See also: plot_qubism with how='before_after' for a similar plot.
+
+    .. note::
+
+        colorblind_safe does not apply because of its unique colormap
+
+    Parameters
+    ----------
+    ket : list of Qobj
+        Pure states for animation.
+
+    theme : 'light' or 'dark', default='light'
+        Set coloring theme for mapping complex values into colors.
+        See: complex_array_to_rgb.
+
+    splitting : int, optional
+        Plot for a number of first particles versus the rest.
+        If not given, it is (number of particles + 1) // 2.
+
+    labels_iteration : int or pair of ints, default=(3,2)
+        Number of particles to be shown as tick labels,
+        for first (vertical) and last (horizontal) particles, respectively.
+
+    fig : a matplotlib figure instance, optional
+        The figure canvas on which the plot will be drawn.
+
+    ax : a matplotlib axis instance, optional
+        The axis context in which the plot will be drawn.
+
+    Returns
+    -------
+    fig, ani : tuple
+        A tuple of the matplotlib figure and the animation instance
+        used to produce the figure.
+
+    """
+
+    fig, ani = plot_schmidt(ket, theme, splitting, labels_iteration,
+                            fig=fig, ax=ax)
+
+    plt.close(fig)
+
+    return fig, ani
diff --git a/qutip/visualization.py b/qutip/visualization.py
index f8c8dcb41f..6797baeded 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -112,7 +112,7 @@ def _equal_shape(matrices):
 
 def plot_wigner_sphere(wigner, reflections=False, *, cmap=None,
                        colorbar=True, fig=None, ax=None):
-    """Plot or animate a coloured Bloch sphere.
+    """Plots a coloured Bloch sphere.
 
     Parameters
     ----------
@@ -282,7 +282,7 @@ def hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
     Parameters
     ----------
-    rho : qobj or a list of qobj instances
+    rho : qobj
         Input density matrix or superoperator.
 
         .. note::
@@ -496,7 +496,7 @@ def sphereplot(theta, phi, values, *,
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    values : array or list of array instances
+    values : array
         Data set to be plotted
 
     cmap : a matplotlib colormap instance, optional
@@ -679,7 +679,7 @@ def matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     Parameters
     ----------
-    M : Matrix of Qobj or list of matrices
+    M : Matrix of Qobj
         The matrix to visualize
 
     x_basis : list of strings, optional
@@ -1062,7 +1062,7 @@ def plot_fock_distribution(rho, fock_numbers=None, color="green",
 
     Parameters
     ----------
-    rho : `qutip.Qobj` or list of `qutip.Qobj` instances
+    rho : `qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
     fock_numbers : list of strings, optional
@@ -1135,7 +1135,7 @@ def plot_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     Parameters
     ----------
-    rho : `qutip.Qobj` or list of `qutip.Qobj` instances
+    rho : `qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
     xvec : array_like, optional
@@ -1584,7 +1584,7 @@ def plot_qubism(ket, theme='light', how='pairs', grid_iteration=1,
 
     Parameters
     ----------
-    ket : Qobj or list of Qobj instances
+    ket : Qobj
         Pure state for plotting.
 
     theme : 'light' or 'dark', default='light'

From 30be73f93be2b24d52d3d17dc1af6b621b6221c9 Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 15 Aug 2023 20:24:03 +0900
Subject: [PATCH 554/602] change arg names

---
 qutip/animation.py | 48 +++++++++++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index b2eda3087f..20be7a07bf 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -21,7 +21,7 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
 
     Parameters
     ----------
-    wigner : a list of transformations.
+    wigners : a list of transformations.
         The wigner transformation at `steps` different theta and phi.
 
     reflections : bool, default=False
@@ -57,14 +57,14 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
     return fig, ani
 
 
-def anim_hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
+def anim_hinton(rhos, x_basis=None, y_basis=None, color_style="scaled",
                 label_top=True, *, cmap=None, colorbar=True,
                 fig=None, ax=None):
     """Draws an animation of Hinton diagram.
 
     Parameters
     ----------
-    rho : a list of qobj instances
+    rhos : a list of qobj instances
         Input density matrix or superoperator.
 
         .. note::
@@ -121,7 +121,7 @@ def anim_hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
 
     """
 
-    fig, ani = hinton(rho, x_basis, y_basis, color_style, label_top,
+    fig, ani = hinton(rhos, x_basis, y_basis, color_style, label_top,
                       cmap=cmap, colorbar=colorbar, fig=fig, ax=ax)
 
     plt.close(fig)
@@ -129,7 +129,7 @@ def anim_hinton(rho, x_basis=None, y_basis=None, color_style="scaled",
     return fig, ani
 
 
-def anim_sphereplot(theta, phi, values, *, cmap=None,
+def anim_sphereplot(theta, phi, V, *, cmap=None,
                     colorbar=True, fig=None, ax=None):
     """animation of a matrices of values on a sphere
 
@@ -141,7 +141,7 @@ def anim_sphereplot(theta, phi, values, *, cmap=None,
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    values : list of array instances
+    V : list of array instances
         Data set to be plotted
 
     cmap : a matplotlib colormap instance, optional
@@ -163,7 +163,7 @@ def anim_sphereplot(theta, phi, values, *, cmap=None,
         used to produce the figure.
     """
 
-    fig, ani = sphereplot(theta, phi, values, cmap=cmap,
+    fig, ani = sphereplot(theta, phi, V, cmap=cmap,
                           colorbar=colorbar, fig=fig, ax=ax)
 
     plt.close(fig)
@@ -171,7 +171,7 @@ def anim_sphereplot(theta, phi, values, *, cmap=None,
     return fig, ani
 
 
-def anim_matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
+def anim_matrix_histogram(Ms, x_basis=None, y_basis=None, limits=None,
                           bar_style='real', color_limits=None,
                           color_style='real', options=None, *, cmap=None,
                           colorbar=True, fig=None, ax=None):
@@ -181,7 +181,7 @@ def anim_matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     Parameters
     ----------
-    M : list of matrices
+    Ms : list of matrices
         The matrix to visualize
 
     x_basis : list of strings, optional
@@ -293,7 +293,7 @@ def anim_matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
 
     """
 
-    fig, ani = matrix_histogram(M, x_basis, y_basis, limits, bar_style,
+    fig, ani = matrix_histogram(Ms, x_basis, y_basis, limits, bar_style,
                                 color_limits, color_style, options, cmap=cmap,
                                 colorbar=colorbar, fig=fig, ax=ax)
 
@@ -302,7 +302,7 @@ def anim_matrix_histogram(M, x_basis=None, y_basis=None, limits=None,
     return fig, ani
 
 
-def anim_fock_distribution(rho, fock_numbers=None, color="green",
+def anim_fock_distribution(rhos, fock_numbers=None, color="green",
                            unit_y_range=True, *, fig=None, ax=None):
     """
     Animation of the Fock distribution for a density matrix (or ket)
@@ -310,7 +310,7 @@ def anim_fock_distribution(rho, fock_numbers=None, color="green",
 
     Parameters
     ----------
-    rho : list of `qutip.Qobj` instances
+    rhos : list of `qutip.Qobj` instances
         The density matrix (or ket) of the state to visualize.
 
     fock_numbers : list of strings, optional
@@ -335,7 +335,7 @@ def anim_fock_distribution(rho, fock_numbers=None, color="green",
         used to produce the figure.
     """
 
-    fig, ani = plot_fock_distribution(rho, fock_numbers, color,
+    fig, ani = plot_fock_distribution(rhos, fock_numbers, color,
                                       unit_y_range, fig=fig, ax=ax)
 
     plt.close(fig)
@@ -343,7 +343,7 @@ def anim_fock_distribution(rho, fock_numbers=None, color="green",
     return fig, ani
 
 
-def anim_wigner(rho, xvec=None, yvec=None, method='clenshaw',
+def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
                 projection='2d', *, cmap=None, colorbar=False,
                 fig=None, ax=None):
     """
@@ -352,7 +352,7 @@ def anim_wigner(rho, xvec=None, yvec=None, method='clenshaw',
 
     Parameters
     ----------
-    rho : list of `qutip.Qobj` instances
+    rhos : list of `qutip.Qobj` instances
         The density matrix (or ket) of the state to visualize.
 
     xvec : array_like, optional
@@ -391,7 +391,7 @@ def anim_wigner(rho, xvec=None, yvec=None, method='clenshaw',
         used to produce the figure.
     """
 
-    fig, ani = plot_wigner(rho, xvec, yvec, method, projection,
+    fig, ani = plot_wigner(rhos, xvec, yvec, method, projection,
                            cmap=cmap, colorbar=colorbar, fig=fig, ax=ax)
 
     plt.close(fig)
@@ -399,14 +399,14 @@ def anim_wigner(rho, xvec=None, yvec=None, method='clenshaw',
     return fig, ani
 
 
-def anim_spin_distribution(P, THETA, PHI, projection='2d', *,
+def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
                            cmap=None, colorbar=False, fig=None, ax=None):
     """
     animation of a spin distribution (given as meshgrid data).
 
     Parameters
     ----------
-    P : list of matrices
+    Ps : list of matrices
         Distribution values as a meshgrid matrix.
 
     THETA : matrix
@@ -440,7 +440,7 @@ def anim_spin_distribution(P, THETA, PHI, projection='2d', *,
         used to produce the figure.
     """
 
-    fig, ani = plot_spin_distribution(P, THETA, PHI, projection, cmap=cmap,
+    fig, ani = plot_spin_distribution(Ps, THETA, PHI, projection, cmap=cmap,
                                       colorbar=colorbar, fig=fig, ax=ax)
 
     plt.close(fig)
@@ -448,7 +448,7 @@ def anim_spin_distribution(P, THETA, PHI, projection='2d', *,
     return fig, ani
 
 
-def anim_qubism(ket, theme='light', how='pairs', grid_iteration=1,
+def anim_qubism(kets, theme='light', how='pairs', grid_iteration=1,
                 legend_iteration=0, *, fig=None, ax=None):
     """
     Animation of Qubism plot for pure states of many qudits.
@@ -462,7 +462,7 @@ def anim_qubism(ket, theme='light', how='pairs', grid_iteration=1,
 
     Parameters
     ----------
-    ket : list of Qobj instances
+    kets : list of Qobj instances
         Pure states for animation.
 
     theme : 'light' or 'dark', default='light'
@@ -511,7 +511,7 @@ def anim_qubism(ket, theme='light', how='pairs', grid_iteration=1,
        (2012), open access.
     """
 
-    fig, ani = plot_qubism(ket, theme, how, grid_iteration,
+    fig, ani = plot_qubism(kets, theme, how, grid_iteration,
                            legend_iteration, fig=fig, ax=ax)
 
     plt.close(fig)
@@ -519,7 +519,7 @@ def anim_qubism(ket, theme='light', how='pairs', grid_iteration=1,
     return fig, ani
 
 
-def anim_schmidt(ket, theme='light', splitting=None,
+def anim_schmidt(kets, theme='light', splitting=None,
                  labels_iteration=(3, 2), *, fig=None, ax=None):
     """
     Animation of Schmidt decomposition.
@@ -563,7 +563,7 @@ def anim_schmidt(ket, theme='light', splitting=None,
 
     """
 
-    fig, ani = plot_schmidt(ket, theme, splitting, labels_iteration,
+    fig, ani = plot_schmidt(kets, theme, splitting, labels_iteration,
                             fig=fig, ax=ax)
 
     plt.close(fig)

From 10b8bdaad944e41b85b8719b6a4578b2fc64452f Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Wed, 16 Aug 2023 03:41:54 +0900
Subject: [PATCH 555/602] add tests

---
 qutip/tests/test_animation.py     | 111 ++++++++++++++++++++++++++++++
 qutip/tests/test_visualization.py |  14 ----
 2 files changed, 111 insertions(+), 14 deletions(-)
 create mode 100644 qutip/tests/test_animation.py

diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
new file mode 100644
index 0000000000..986728019c
--- /dev/null
+++ b/qutip/tests/test_animation.py
@@ -0,0 +1,111 @@
+import pytest
+import qutip
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+
+def test_anim_wigner_sphere():
+    psi = qutip.rand_ket(5)
+    wigner = qutip.wigner_transform(psi, 2, False, 50, ["x"])
+
+    fig, ani = qutip.anim_wigner_sphere([wigner]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_hinton():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.anim_hinton(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_sphereplot():
+    theta = np.linspace(0, np.pi, 90)
+    phi = np.linspace(0, 2 * np.pi, 60)
+    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    fig, ani = qutip.anim_sphereplot(theta, phi, [values]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_matrix_histogram():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.anim_matrix_histogram(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_fock_distribution():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.anim_fock_distribution(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_wigner():
+    rho = qutip.rand_dm(5)
+    rhos = [rho]*2
+
+    fig, ani = qutip.anim_wigner(rhos)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+@pytest.mark.filterwarnings(
+    "ignore:The input coordinates to pcolor:UserWarning"
+)
+def test_anim_spin_distribution():
+    j = 5
+    psi = qutip.spin_state(j, -j)
+    psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
+                              np.random.rand() * 2 * np.pi)
+    rho = qutip.ket2dm(psi)
+    theta = np.linspace(0, np.pi, 50)
+    phi = np.linspace(0, 2 * np.pi, 50)
+    Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
+
+    fig, ani = qutip.anim_spin_distribution([Q]*2, THETA, PHI)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_qubism():
+    state = qutip.ket("01")
+
+    fig, ani = qutip.anim_qubism([state]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
+def test_anim_schmidt():
+    state = qutip.ket("01")
+
+    fig, ani = qutip.anim_schmidt([state]*2)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index c978490472..92962472f2 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -3,20 +3,6 @@
 import numpy as np
 import matplotlib as mpl
 import matplotlib.pyplot as plt
-import os
-import shutil
-
-
-def setup_module(module):
-    """ setup any state specific to the execution of the given module."""
-    os.mkdir('animation')
-
-
-def teardown_module(module):
-    """teardown any state that was previously setup with a setup_module
-    method.
-    """
-    shutil.rmtree('animation')
 
 
 def test_cyclic():

From bef567e3db81c87bd6e64e66d1aa23bdc7a995ef Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 16 Aug 2023 11:56:27 -0400
Subject: [PATCH 556/602] Comment __module__ overwrite

---
 qutip/core/data/dispatch.pyx | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/qutip/core/data/dispatch.pyx b/qutip/core/data/dispatch.pyx
index e8abebd7bc..fba96f8c11 100644
--- a/qutip/core/data/dispatch.pyx
+++ b/qutip/core/data/dispatch.pyx
@@ -257,7 +257,7 @@ cdef class _constructed_specialisation:
     cdef str _short_name
     cdef public str __doc__
     cdef public str __name__
-    cdef public str __module__
+    # cdef public str __module__
     cdef public object __signature__
     cdef readonly str __text_signature__
     cdef readonly bint direct
@@ -271,7 +271,7 @@ cdef class _constructed_specialisation:
             + "_"
             + "_".join([x.__name__ for x in types])
         )
-        self.__module__ = dispatcher.__module__
+        # self.__module__ = dispatcher.__module__
         self.__signature__ = dispatcher.__signature__
         self.__text_signature__ = dispatcher.__text_signature__
         self._parameters = dispatcher._parameters
@@ -338,7 +338,7 @@ cdef class Dispatcher:
     cdef readonly bint output
     cdef public str __doc__
     cdef public str __name__
-    cdef public str __module__
+    # cdef public str __module__
     cdef public object __signature__
     cdef readonly str __text_signature__
 
@@ -380,6 +380,10 @@ cdef class Dispatcher:
             this.  If not given and `signature_source` is _not_ an instance of
             `inspect.Signature`, then we will attempt to read `__module__` from
             there instead.
+
+            .. note::
+
+                Commented for now because of a bug in cython 3 (cython#5472)
         """
         if isinstance(inputs, str):
             inputs = (inputs,)
@@ -401,10 +405,10 @@ cdef class Dispatcher:
             self.__name__ = signature_source.__name__
         else:
             self.__name__ = 'dispatcher'
-        if module is not None:
-            self.__module__ = module
-        elif not isinstance(signature_source, inspect.Signature):
-            self.__module__ = signature_source.__module__
+        # if module is not None:
+        #     self.__module__ = module
+        # elif not isinstance(signature_source, inspect.Signature):
+        #     self.__module__ = signature_source.__module__
         self.__text_signature__ = self.__name__ + str(self.__signature__)
         if not isinstance(signature_source, inspect.Signature):
             self.__doc__ = inspect.getdoc(signature_source)

From b83f98032ca2e6802eeb4ad2bc8fe8cfa1cedd62 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 16 Aug 2023 13:40:56 -0400
Subject: [PATCH 557/602] Add towncrier

---
 doc/changes/2151.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2151.misc

diff --git a/doc/changes/2151.misc b/doc/changes/2151.misc
new file mode 100644
index 0000000000..723707dd37
--- /dev/null
+++ b/doc/changes/2151.misc
@@ -0,0 +1 @@
+Enable cython 3

From 6e05e97df2eae7341dbdda86097e1ba9da1e20c0 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 16 Aug 2023 16:03:58 -0400
Subject: [PATCH 558/602] Remove version limitation

---
 .github/workflows/tests.yml | 7 ++++---
 pyproject.toml              | 2 +-
 requirements.txt            | 2 +-
 setup.cfg                   | 4 ++--
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 2f232226a9..096e5cb593 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -51,6 +51,7 @@ jobs:
             numpy-requirement: ">=1.20,<1.21"
             scipy-requirement: ">=1.5,<1.6"
             condaforge: 1
+            oldcython: 1
 
           # No MKL runs.  MKL is now the default for conda installations, but
           # not necessarily for pip.
@@ -73,7 +74,7 @@ jobs:
             os: ubuntu-latest
             python-version: "3.10"
             condaforge: 1
-            cython3: 1
+            oldcython: 1
 
           # Python 3.11 and latest numpy
           # Use conda-forge to provide Python 3.11 and latest numpy
@@ -116,8 +117,8 @@ jobs:
           if [[ -z "${{ matrix.nocython }}" ]]; then
             QUTIP_TARGET="$QUTIP_TARGET,runtime_compilation"
           fi
-          if [[ "${{ matrix.cython3 }}" ]]; then
-            pip install cython --pre --upgrade
+          if [[ "${{ matrix.oldcython }}" ]]; then
+            pip install cython==0.29.36
           fi
           export CI_QUTIP_WITH_OPENMP=${{ matrix.openmp }}
           if [[ -z "${{ matrix.nomkl }}" ]]; then
diff --git a/pyproject.toml b/pyproject.toml
index 7d2c629b6d..f854fa46f5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,7 @@ requires = [
     "setuptools",
     "packaging",
     "wheel",
-    "cython>=0.29.20,<3.0.0",
+    "cython>=0.29.20",
     # See https://numpy.org/doc/stable/user/depending_on_numpy.html for
     # the recommended way to build against numpy's C API:
     "oldest-supported-numpy",
diff --git a/requirements.txt b/requirements.txt
index ce206d79dd..41d2c09a1b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
-cython>=0.29.20,<3.0.0
+cython>=0.29.20
 numpy>=1.16.6
 scipy>=1.5
 packaging
diff --git a/setup.cfg b/setup.cfg
index c9297d3aec..1eb1f11cd2 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -37,7 +37,7 @@ install_requires =
 setup_requires =
     numpy>=1.13.3
     scipy>=1.0
-    cython>=0.29.20,<3.0.0
+    cython>=0.29.20
     packaging
 
 [options.packages.find]
@@ -46,7 +46,7 @@ include = qutip*
 [options.extras_require]
 graphics = matplotlib>=1.2.1
 runtime_compilation =
-    cython>=0.29.20,<3.0.0
+    cython>=0.29.20
     filelock
 semidefinite =
     cvxpy>=1.0

From 86afea6d39631354605e98e085e737f318834b3e Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Fri, 18 Aug 2023 12:08:17 +0900
Subject: [PATCH 559/602] Result, delete plt.close() and doc

---
 doc/apidoc/functions.rst      |  3 ++
 qutip/animation.py            | 62 ++++++++++++++++++++---------------
 qutip/tests/test_animation.py | 12 +++++++
 3 files changed, 50 insertions(+), 27 deletions(-)

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 43ef88a18d..990c713e39 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -238,6 +238,9 @@ Graphs and Visualization
     :members: hinton, matrix_histogram, plot_energy_levels, plot_fock_distribution, plot_wigner, sphereplot, plot_schmidt, plot_qubism, plot_expectation_values, plot_wigner_sphere, plot_spin_distribution
     :undoc-members:
 
+.. automodule:: qutip.animation
+    :members: anim_hinton, anim_matrix_histogram, anim_fock_distribution, anim_wigner, anim_sphereplot, anim_schmidt, anim_qubism, anim_wigner_sphere, anim_spin_distribution
+
 .. automodule:: qutip.orbital
     :members: orbital
 
diff --git a/qutip/animation.py b/qutip/animation.py
index 20be7a07bf..d59633afc0 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -8,6 +8,7 @@
 from . import (plot_wigner_sphere, hinton, sphereplot, matrix_histogram,
                plot_fock_distribution, plot_wigner, plot_spin_distribution,
                plot_qubism, plot_schmidt)
+from .solver import Result
 
 try:
     import matplotlib.pyplot as plt
@@ -15,13 +16,19 @@
     pass
 
 
+def _result_state(obj):
+    if isinstance(obj, Result):
+        return obj.states
+    return obj
+
+
 def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
                        colorbar=True, fig=None, ax=None):
     """Animate a coloured Bloch sphere.
 
     Parameters
     ----------
-    wigners : a list of transformations.
+    wigners : a list of transformations or :class:`qutip.solver.Result`
         The wigner transformation at `steps` different theta and phi.
 
     reflections : bool, default=False
@@ -50,9 +57,10 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
     Special thanks to Russell P Rundle for writing this function.
     """
 
+    wigners = _result_state(wigners)
+
     fig, ani = plot_wigner_sphere(wigners, reflections, cmap=cmap,
                                   colorbar=colorbar, fig=fig, ax=ax)
-    plt.close(fig)
 
     return fig, ani
 
@@ -64,7 +72,7 @@ def anim_hinton(rhos, x_basis=None, y_basis=None, color_style="scaled",
 
     Parameters
     ----------
-    rhos : a list of qobj instances
+    rhos : :class:`qutip.solver.Result` or list of :class:`qutip.Qobj`
         Input density matrix or superoperator.
 
         .. note::
@@ -121,11 +129,11 @@ def anim_hinton(rhos, x_basis=None, y_basis=None, color_style="scaled",
 
     """
 
+    rhos = _result_state(rhos)
+
     fig, ani = hinton(rhos, x_basis, y_basis, color_style, label_top,
                       cmap=cmap, colorbar=colorbar, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
@@ -141,7 +149,7 @@ def anim_sphereplot(theta, phi, V, *, cmap=None,
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    V : list of array instances
+    V : list of array instances or :class:`qutip.solver.Result`
         Data set to be plotted
 
     cmap : a matplotlib colormap instance, optional
@@ -163,11 +171,11 @@ def anim_sphereplot(theta, phi, V, *, cmap=None,
         used to produce the figure.
     """
 
+    V = _result_state(V)
+
     fig, ani = sphereplot(theta, phi, V, cmap=cmap,
                           colorbar=colorbar, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
@@ -181,7 +189,7 @@ def anim_matrix_histogram(Ms, x_basis=None, y_basis=None, limits=None,
 
     Parameters
     ----------
-    Ms : list of matrices
+    Ms : list of matrices or :class:`qutip.solver.Result`
         The matrix to visualize
 
     x_basis : list of strings, optional
@@ -293,12 +301,12 @@ def anim_matrix_histogram(Ms, x_basis=None, y_basis=None, limits=None,
 
     """
 
+    Ms = _result_state(Ms)
+
     fig, ani = matrix_histogram(Ms, x_basis, y_basis, limits, bar_style,
                                 color_limits, color_style, options, cmap=cmap,
                                 colorbar=colorbar, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
@@ -310,7 +318,7 @@ def anim_fock_distribution(rhos, fock_numbers=None, color="green",
 
     Parameters
     ----------
-    rhos : list of `qutip.Qobj` instances
+    rhos : :class:`qutip.solver.Result` or list of :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
     fock_numbers : list of strings, optional
@@ -335,11 +343,11 @@ def anim_fock_distribution(rhos, fock_numbers=None, color="green",
         used to produce the figure.
     """
 
+    rhos = _result_state(rhos)
+
     fig, ani = plot_fock_distribution(rhos, fock_numbers, color,
                                       unit_y_range, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
@@ -352,7 +360,7 @@ def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
 
     Parameters
     ----------
-    rhos : list of `qutip.Qobj` instances
+    rhos : :class:`qutip.solver.Result` or list of :class:`qutip.Qobj`
         The density matrix (or ket) of the state to visualize.
 
     xvec : array_like, optional
@@ -391,22 +399,22 @@ def anim_wigner(rhos, xvec=None, yvec=None, method='clenshaw',
         used to produce the figure.
     """
 
+    rhos = _result_state(rhos)
+
     fig, ani = plot_wigner(rhos, xvec, yvec, method, projection,
                            cmap=cmap, colorbar=colorbar, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
 def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
                            cmap=None, colorbar=False, fig=None, ax=None):
     """
-    animation of a spin distribution (given as meshgrid data).
+    Animation of a spin distribution (given as meshgrid data).
 
     Parameters
     ----------
-    Ps : list of matrices
+    Ps : list of matrices or :class:`qutip.solver.Result`
         Distribution values as a meshgrid matrix.
 
     THETA : matrix
@@ -440,11 +448,11 @@ def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
         used to produce the figure.
     """
 
+    Ps = _result_state(Ps)
+
     fig, ani = plot_spin_distribution(Ps, THETA, PHI, projection, cmap=cmap,
                                       colorbar=colorbar, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
@@ -462,7 +470,7 @@ def anim_qubism(kets, theme='light', how='pairs', grid_iteration=1,
 
     Parameters
     ----------
-    kets : list of Qobj instances
+    kets : :class:`qutip.solver.Result` or list of :class:`qutip.Qobj`
         Pure states for animation.
 
     theme : 'light' or 'dark', default='light'
@@ -511,11 +519,11 @@ def anim_qubism(kets, theme='light', how='pairs', grid_iteration=1,
        (2012), open access.
     """
 
+    kets = _result_state(kets)
+
     fig, ani = plot_qubism(kets, theme, how, grid_iteration,
                            legend_iteration, fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
 
 
@@ -534,7 +542,7 @@ def anim_schmidt(kets, theme='light', splitting=None,
 
     Parameters
     ----------
-    ket : list of Qobj
+    ket : :class:`qutip.solver.Result` or list of :class:`qutip.Qobj`
         Pure states for animation.
 
     theme : 'light' or 'dark', default='light'
@@ -563,9 +571,9 @@ def anim_schmidt(kets, theme='light', splitting=None,
 
     """
 
+    kets = _result_state(kets)
+
     fig, ani = plot_schmidt(kets, theme, splitting, labels_iteration,
                             fig=fig, ax=ax)
 
-    plt.close(fig)
-
     return fig, ani
diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
index 986728019c..a1c6280dff 100644
--- a/qutip/tests/test_animation.py
+++ b/qutip/tests/test_animation.py
@@ -5,6 +5,18 @@
 import matplotlib.pyplot as plt
 
 
+def test_result_state():
+    H = qutip.rand_dm(2)
+    tlist = np.linspace(0, 3*np.pi, 2)
+    results = qutip.mesolve(H, H, tlist, [], [])
+
+    fig, ani = qutip.anim_fock_distribution(results)
+    plt.close()
+
+    assert isinstance(fig, mpl.figure.Figure)
+    assert isinstance(ani, mpl.animation.ArtistAnimation)
+
+
 def test_anim_wigner_sphere():
     psi = qutip.rand_ket(5)
     wigner = qutip.wigner_transform(psi, 2, False, 50, ["x"])

From e70da5eea3b6aee3c0008caf64e06056cdfe2608 Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Sun, 20 Aug 2023 10:02:02 +0900
Subject: [PATCH 560/602] fix assertion

---
 qutip/animation.py            | 23 ++++++++---------------
 qutip/tests/test_animation.py | 14 +++++++++++++-
 2 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index d59633afc0..c9b97aab55 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -10,15 +10,14 @@
                plot_qubism, plot_schmidt)
 from .solver import Result
 
-try:
-    import matplotlib.pyplot as plt
-except Exception:
-    pass
-
 
 def _result_state(obj):
     if isinstance(obj, Result):
-        return obj.states
+        obj = obj.states
+        if len(obj) == 0:
+            raise ValueError('Nothing to visualize. You might forget '
+                             'to set options={"store_states": True}.')
+
     return obj
 
 
@@ -28,7 +27,7 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
 
     Parameters
     ----------
-    wigners : a list of transformations or :class:`qutip.solver.Result`
+    wigners : list of transformations
         The wigner transformation at `steps` different theta and phi.
 
     reflections : bool, default=False
@@ -57,8 +56,6 @@ def anim_wigner_sphere(wigners, reflections=False, *, cmap=None,
     Special thanks to Russell P Rundle for writing this function.
     """
 
-    wigners = _result_state(wigners)
-
     fig, ani = plot_wigner_sphere(wigners, reflections, cmap=cmap,
                                   colorbar=colorbar, fig=fig, ax=ax)
 
@@ -149,7 +146,7 @@ def anim_sphereplot(theta, phi, V, *, cmap=None,
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    V : list of array instances or :class:`qutip.solver.Result`
+    V : list of array instances
         Data set to be plotted
 
     cmap : a matplotlib colormap instance, optional
@@ -171,8 +168,6 @@ def anim_sphereplot(theta, phi, V, *, cmap=None,
         used to produce the figure.
     """
 
-    V = _result_state(V)
-
     fig, ani = sphereplot(theta, phi, V, cmap=cmap,
                           colorbar=colorbar, fig=fig, ax=ax)
 
@@ -414,7 +409,7 @@ def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
 
     Parameters
     ----------
-    Ps : list of matrices or :class:`qutip.solver.Result`
+    Ps : list of matrices
         Distribution values as a meshgrid matrix.
 
     THETA : matrix
@@ -448,8 +443,6 @@ def anim_spin_distribution(Ps, THETA, PHI, projection='2d', *,
         used to produce the figure.
     """
 
-    Ps = _result_state(Ps)
-
     fig, ani = plot_spin_distribution(Ps, THETA, PHI, projection, cmap=cmap,
                                       colorbar=colorbar, fig=fig, ax=ax)
 
diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
index a1c6280dff..fb0050aa20 100644
--- a/qutip/tests/test_animation.py
+++ b/qutip/tests/test_animation.py
@@ -17,6 +17,19 @@ def test_result_state():
     assert isinstance(ani, mpl.animation.ArtistAnimation)
 
 
+def test_result_state_ValueError():
+    H = qutip.rand_dm(2)
+    tlist = np.linspace(0, 3*np.pi, 2)
+    results = qutip.mesolve(H, H, tlist, [], [],
+                            options={"store_states": False})
+
+    text = 'Nothing to visualize. You might forget ' +\
+           'to set options={"store_states": True}.'
+    with pytest.raises(ValueError) as exc_info:
+        fig, ani = qutip.anim_fock_distribution(results)
+    assert str(exc_info.value) == text
+
+
 def test_anim_wigner_sphere():
     psi = qutip.rand_ket(5)
     wigner = qutip.wigner_transform(psi, 2, False, 50, ["x"])
@@ -91,7 +104,6 @@ def test_anim_spin_distribution():
     psi = qutip.spin_state(j, -j)
     psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
                               np.random.rand() * 2 * np.pi)
-    rho = qutip.ket2dm(psi)
     theta = np.linspace(0, np.pi, 50)
     phi = np.linspace(0, 2 * np.pi, 50)
     Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)

From 499d44dc53505c56d08cefb03f34f55eee0ee009 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Sun, 20 Aug 2023 22:21:23 -0400
Subject: [PATCH 561/602] improved sampling algorithm for mcsolve working in
 initial tests

---
 qutip/solver/mcsolve.py   |  67 ++++++++++++++++++++--
 qutip/solver/multitraj.py |  79 +++++++++++++++++++++++++-
 qutip/solver/result.py    | 114 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 255 insertions(+), 5 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index a68b92561a..cc11f74bfc 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -2,16 +2,17 @@
 
 import numpy as np
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
-from .multitraj import MultiTrajSolver
+from .multitraj import MultiTrajSolver, MultiTrajSolverImprovedSampling
 from .solver_base import Solver, Integrator
-from .result import McResult, McTrajectoryResult
+from .result import McResult, McTrajectoryResult, McResultImprovedSampling
 from .mesolve import mesolve, MESolver
 import qutip.core.data as _data
 from time import time
 
 
 def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
-            args=None, options=None, seeds=None, target_tol=None, timeout=None):
+            args=None, options=None, seeds=None, target_tol=None, timeout=None,
+            improved_sampling=False):
     r"""
     Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
     given Hamiltonian and sets of collapse operators. Options for the
@@ -116,6 +117,10 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
         Maximum time for the evolution in second. When reached, no more
         trajectories will be computed.
 
+    improved_sampling: Bool
+        Whether to use the improved sampling algorithm from Abdelhafez et al.
+        PRA (2019)
+
     Returns
     -------
     results : :class:`qutip.solver.McResult`
@@ -148,8 +153,11 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
             "ntraj must be an integer. "
             "A list of numbers is not longer supported."
         )
+    if not improved_sampling:
+        mc = MCSolver(H, c_ops, options=options)
+    else:
+        mc = MCSolverImprovedSampling(H, c_ops, options=options)
 
-    mc = MCSolver(H, c_ops, options=options)
     result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
                     seed=seeds, target_tol=target_tol, timeout=timeout)
     return result
@@ -314,6 +322,35 @@ def integrator_options(self):
         return self._integrator.integrator_options
 
 
+class MCIntegratorImprovedSampling(MCIntegrator):
+    def __init__(self, integrator, c_ops, n_ops, options=None):
+        super().__init__(integrator, c_ops, n_ops, options=options)
+
+    def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
+        """
+        see the overidden function for additional details.
+            The parameters introduced here are:
+
+        no_jump: Bool
+            whether or not to sample the no-jump trajectory. If so, the "random number"
+            should be set to zero
+
+        jump_prob_floor: float
+            if no_jump == False, this is set to the no-jump probability. This setting
+            ensures that we sample a trajectory with jumps
+
+        generator : numpy.random.generator
+            Random number generator.
+        """
+        super().set_state(t, state0, generator)
+        if no_jump:
+            self.target_norm = 0.0
+        else:
+            self.target_norm = (
+                    self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
+            )
+
+
 # -----------------------------------------------------------------------------
 # MONTE CARLO CLASS
 # -----------------------------------------------------------------------------
@@ -518,3 +555,25 @@ def avail_integrators(cls):
             **Solver.avail_integrators(),
             **cls._avail_integrators,
         }
+
+
+class MCSolverImprovedSampling(MultiTrajSolverImprovedSampling, MCSolver):
+    name = "mcsolve improved sampling"
+    resultclass = McResultImprovedSampling
+    trajectory_resultclass = McTrajectoryResult
+    mc_integrator_class = MCIntegratorImprovedSampling
+
+    def __init__(self, H, c_ops, *, options=None):
+        MCSolver.__init__(self, H, c_ops, options=options)
+
+    def _run_one_traj(
+        self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
+    ):
+        """
+        See the overridden function for additional details.
+        """
+        seed, result = super()._run_one_traj(
+            seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor
+        )
+        result.collapse = self._integrator.collapses
+        return seed, result
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index e9fdd1d672..7a4798cb9c 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -1,4 +1,4 @@
-from .result import Result, MultiTrajResult
+from .result import Result, MultiTrajResult, MultiTrajResultImprovedSampling
 from .parallel import _get_map
 from time import time
 from .solver_base import Solver
@@ -254,3 +254,80 @@ def _get_generator(self, seed):
     @classmethod
     def avail_integrators(cls):
         return cls._avail_integrators
+
+
+class MultiTrajSolverImprovedSampling(MultiTrajSolver):
+    name = "multi trajectory efficient"
+    resultclass = MultiTrajResultImprovedSampling
+    trajectory_resultclass = Result
+
+    def __init__(self, rhs, *, options=None):
+        super().__init__(rhs, options=options)
+
+    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
+        """
+        Run one trajectory and return the result. Here
+        """
+        if no_jump:
+            init_setting = self.options["store_final_state"]
+            self.options["store_final_state"] = True
+        result = self.trajectory_resultclass(e_ops, self.options)
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
+        result.add(tlist[0], self._restore_state(state, copy=False))
+        for t in tlist[1:]:
+            t, state = self._integrator.integrate(t, copy=False)
+            result.add(t, self._restore_state(state, copy=False))
+        if no_jump:
+            self.options["store_final_state"] = init_setting
+        return seed, result
+
+    def run(self, state, tlist, ntraj=1, *,
+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+        """
+        Do the evolution of the Quantum system.
+        See the overridden method for further details. The modification here is to sample
+        the no-jump trajectory first. Then, the no-jump probability is used as a lower-bound
+        for random numbers in future monte carlo runs
+        """
+        start_time = time()
+        self._argument(args)
+        stats = self._initialize_stats()
+        seeds = self._read_seed(seed, ntraj)
+
+        result = self.resultclass(
+            e_ops, self.options, solver=self.name, stats=stats
+        )
+        result.add_end_condition(ntraj, target_tol)
+
+        map_func = _get_map[self.options['map']]
+        map_kw = {
+            'timeout': timeout,
+            'job_timeout': self.options['job_timeout'],
+            'num_cpus': self.options['num_cpus'],
+        }
+        state0 = self._prepare_state(state)
+        stats['preparation time'] += time() - start_time
+
+        # first run the no-jump trajectory
+        start_time = time()
+        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist, e_ops, no_jump=True)
+        _, state, _ = self._integrator.get_state(copy=False)
+        no_jump_prob = self._integrator._prob_func(state)
+        result.no_jump_prob = no_jump_prob
+        result.add((seed0, no_jump_result), no_jump=True)
+        result.stats['no jump run time'] = time() - start_time
+
+        # run the remaining trajectories with the random number floor set to the
+        # no jump probability such that we only sample trajectories with jumps
+        start_time = time()
+        # implied here that no_jump=False for result.add
+        map_func(
+            self._run_one_traj, seeds[1:],
+            (state0, tlist, e_ops, False, no_jump_prob),
+            reduce_func=result.add, map_kw=map_kw,
+            progress_bar=self.options["progress_bar"],
+            progress_bar_kwargs=self.options["progress_kwargs"]
+        )
+        result.stats['run time'] = time() - start_time
+        return result
\ No newline at end of file
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 037322ca0a..4bbfca560c 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -866,6 +866,111 @@ def __add__(self, other):
         return new
 
 
+class MultiTrajResultImprovedSampling(MultiTrajResult):
+    def __init__(self, e_ops, options, **kw):
+        super().__init__(e_ops, options, **kw)
+        self._sum_expect_jump = None
+        self._sum_expect_no_jump = None
+        self._sum2_expect_jump = None
+        self._sum2_expect_no_jump = None
+        self.no_jump_prob = None
+
+    def _store_trajectory(self, trajectory, no_jump=False):
+        super()._store_trajectory(trajectory)
+
+    def _reduce_states(self, trajectory, no_jump=False):
+        # TODO this probably also needs to be changed
+        super()._reduce_states(trajectory)
+
+    def _increment_traj(self, trajectory, no_jump=False):
+        super()._increment_traj(trajectory)
+
+    def _reduce_final_state(self, trajectory, no_jump=False):
+        super()._reduce_final_state(trajectory)
+
+    def _add_first_traj(self, trajectory):
+        """
+        Read the first trajectory, intitializing needed data.
+        """
+
+        super()._add_first_traj(trajectory)
+        self._sum_expect_jump = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum2_expect_jump = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum_expect_no_jump = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum2_expect_no_jump = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        del self._sum_expect
+        del self._sum2_expect
+
+    def _reduce_expect(self, trajectory, no_jump=False):
+        """
+        Compute the average of the expectation values and store it in it's
+        multiple formats for the no-jump trajectory
+        """
+        for i, k in enumerate(self._raw_ops):
+            expect_traj = trajectory.expect[i]
+
+            if no_jump:
+                self._sum_expect_no_jump[i] += expect_traj * self.no_jump_prob
+                self._sum2_expect_no_jump[i] += expect_traj**2 * self.no_jump_prob
+                # no jump trajectory will always be the first one
+                avg = self._sum_expect_no_jump[i]
+                avg2 = self._sum2_expect_no_jump[i]
+            else:
+                self._sum_expect_jump[i] += expect_traj * (1 - self.no_jump_prob)
+                self._sum2_expect_jump[i] += expect_traj ** 2 * (1 - self.no_jump_prob)
+                avg = self._sum_expect_no_jump[i] + self._sum_expect_jump[i] / (self.num_trajectories - 1)
+                avg2 = self._sum2_expect_no_jump[i] + self._sum2_expect_jump[i] / (self.num_trajectories - 1)
+
+            self.average_e_data[k] = list(avg)
+
+            # mean(expect**2) - mean(expect)**2 can something be very small
+            # negative (-1e-15) which raise an error for float sqrt.
+            self.std_e_data[k] = list(np.sqrt(np.abs(avg2 - np.abs(avg**2))))
+
+            if self.runs_e_data:
+                self.runs_e_data[k].append(trajectory.e_data[k])
+
+    @property
+    def average_states(self):
+        """
+        States averages as density matrices.
+        """
+        # TODO this needs to be changed
+        if self._sum_states is None:
+            return None
+        return [final / self.num_trajectories for final in self._sum_states]
+
+    @property
+    def average_final_state(self):
+        """
+        Last states of each trajectories averaged into a density matrix.
+        """
+        # TODO this needs to be changed
+        if self._sum_final_states is None:
+            return None
+        return self._sum_final_states / self.num_trajectories
+
+    def add(self, trajectory_info, no_jump=False):
+        seed, trajectory = trajectory_info
+        self.seeds.append(seed)
+
+        for op in self._state_processors:
+            op(trajectory, no_jump)
+
+        return self._early_finish_check()
+
+    def __add__(self, other):
+        raise NotImplemented
+
+
 class McTrajectoryResult(Result):
     """
     Result class used by the :class:`qutip.MCSolver` for single trajectories.
@@ -982,6 +1087,15 @@ def runs_photocurrent(self):
         return measurements
 
 
+class McResultImprovedSampling(MultiTrajResultImprovedSampling, McResult):
+    """McResult class using the MultiTrajResultImprovedSampling functionality"""
+    def __init__(self, e_ops, options, **kw):
+        MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops, options=options, **kw)
+
+    def _add_collapse(self, trajectory, no_jump=False):
+        super()._add_collapse(trajectory)
+
+
 class NmmcTrajectoryResult(McTrajectoryResult):
     """
     Result class used by the :class:`qutip.NonMarkovianMCSolver` for single

From 956f2f2e4f7e675fb06aa02a7914da1f4921efa1 Mon Sep 17 00:00:00 2001
From: Yuji TAMAKOSHI <72233550+tamakoshi2001@users.noreply.github.com>
Date: Mon, 21 Aug 2023 20:36:00 +0900
Subject: [PATCH 562/602] Update qutip/animation.py
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

update document

Co-authored-by: Eric Giguère <eric.giguere@calculquebec.ca>
---
 qutip/animation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index c9b97aab55..384efb61ea 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -15,7 +15,7 @@ def _result_state(obj):
     if isinstance(obj, Result):
         obj = obj.states
         if len(obj) == 0:
-            raise ValueError('Nothing to visualize. You might forget '
+            raise ValueError('Nothing to visualize. You might have forgotten '
                              'to set options={"store_states": True}.')
 
     return obj

From 8c0fb0cd42f50924322685bb36a52bb3458f6db9 Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Mon, 21 Aug 2023 21:10:55 +0900
Subject: [PATCH 563/602] update assertion text

---
 qutip/tests/test_animation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
index fb0050aa20..1545def440 100644
--- a/qutip/tests/test_animation.py
+++ b/qutip/tests/test_animation.py
@@ -23,7 +23,7 @@ def test_result_state_ValueError():
     results = qutip.mesolve(H, H, tlist, [], [],
                             options={"store_states": False})
 
-    text = 'Nothing to visualize. You might forget ' +\
+    text = 'Nothing to visualize. You might have forgotten ' +\
            'to set options={"store_states": True}.'
     with pytest.raises(ValueError) as exc_info:
         fig, ani = qutip.anim_fock_distribution(results)

From 9101b7472d704229fbe861cee051f564150cd196 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 09:21:11 -0400
Subject: [PATCH 564/602] avoid code duplication by utilizing existing classes,
 taking care not to perturb default functionality. Also ensure state averages
 calculated correctly

---
 qutip/solver/mcsolve.py   | 55 ++++++++++--------------
 qutip/solver/multitraj.py | 88 +++++++++++++--------------------------
 qutip/solver/result.py    | 55 ++++++++++++++++++------
 3 files changed, 94 insertions(+), 104 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index cc11f74bfc..dd26b6c0b2 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -179,7 +179,7 @@ def __init__(self, integrator, c_ops, n_ops, options=None):
         self._is_set = False
         self.issuper = c_ops[0].issuper
 
-    def set_state(self, t, state0, generator):
+    def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
         """
         Set the state of the ODE solver.
 
@@ -193,10 +193,23 @@ def set_state(self, t, state0, generator):
 
         generator : numpy.random.generator
             Random number generator.
+
+        no_jump: Bool
+            whether or not to sample the no-jump trajectory. If so, the "random number"
+            should be set to zero
+
+        jump_prob_floor: float
+            if no_jump == False, this is set to the no-jump probability. This setting
+            ensures that we sample a trajectory with jumps
         """
         self.collapses = []
         self._generator = generator
-        self.target_norm = self._generator.random()
+        if no_jump:
+            self.target_norm = 0.0
+        else:
+            self.target_norm = (
+                    self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
+            )
         self._integrator.set_state(t, state0)
         self._is_set = True
 
@@ -306,6 +319,9 @@ def _do_collapse(self, collapse_time, state):
         else:
             state_new = _data.mul(state_new, 1 / new_norm)
             self.collapses.append((collapse_time, which))
+            # this does not need to be modified for improved sampling:
+            # as noted in Abdelhafez PRA (2019),
+            # after a jump we reset to the full range [0, 1)
             self.target_norm = self._generator.random()
         self._integrator.set_state(collapse_time, state_new)
 
@@ -322,35 +338,6 @@ def integrator_options(self):
         return self._integrator.integrator_options
 
 
-class MCIntegratorImprovedSampling(MCIntegrator):
-    def __init__(self, integrator, c_ops, n_ops, options=None):
-        super().__init__(integrator, c_ops, n_ops, options=options)
-
-    def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
-        """
-        see the overidden function for additional details.
-            The parameters introduced here are:
-
-        no_jump: Bool
-            whether or not to sample the no-jump trajectory. If so, the "random number"
-            should be set to zero
-
-        jump_prob_floor: float
-            if no_jump == False, this is set to the no-jump probability. This setting
-            ensures that we sample a trajectory with jumps
-
-        generator : numpy.random.generator
-            Random number generator.
-        """
-        super().set_state(t, state0, generator)
-        if no_jump:
-            self.target_norm = 0.0
-        else:
-            self.target_norm = (
-                    self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
-            )
-
-
 # -----------------------------------------------------------------------------
 # MONTE CARLO CLASS
 # -----------------------------------------------------------------------------
@@ -454,7 +441,7 @@ def _argument(self, args):
         for n_op in self._n_ops:
             n_op.arguments(args)
 
-    def _run_one_traj(self, seed, state, tlist, e_ops):
+    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
@@ -462,7 +449,7 @@ def _run_one_traj(self, seed, state, tlist, e_ops):
         # multiprocessing, but will fail with multithreading.
         # If a thread base parallel map is created, eahc trajectory should use
         # a copy of the integrator.
-        seed, result = super()._run_one_traj(seed, state, tlist, e_ops)
+        seed, result = super()._run_one_traj(seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
         result.collapse = self._integrator.collapses
         return seed, result
 
@@ -561,7 +548,7 @@ class MCSolverImprovedSampling(MultiTrajSolverImprovedSampling, MCSolver):
     name = "mcsolve improved sampling"
     resultclass = McResultImprovedSampling
     trajectory_resultclass = McTrajectoryResult
-    mc_integrator_class = MCIntegratorImprovedSampling
+    mc_integrator_class = MCIntegrator
 
     def __init__(self, H, c_ops, *, options=None):
         MCSolver.__init__(self, H, c_ops, options=options)
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 7a4798cb9c..df1b9abece 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -102,6 +102,28 @@ def step(self, t, *, args=None, copy=True):
         _, state = self._integrator.integrate(t, copy=False)
         return self._restore_state(state, copy=copy)
 
+    def _initialize_run(self, state, ntraj=1, *,
+                        args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+        start_time = time()
+        self._argument(args)
+        stats = self._initialize_stats()
+        seeds = self._read_seed(seed, ntraj)
+
+        result = self.resultclass(
+            e_ops, self.options, solver=self.name, stats=stats
+        )
+        result.add_end_condition(ntraj, target_tol)
+
+        map_func = _get_map[self.options['map']]
+        map_kw = {
+            'timeout': timeout,
+            'job_timeout': self.options['job_timeout'],
+            'num_cpus': self.options['num_cpus'],
+        }
+        state0 = self._prepare_state(state)
+        stats['preparation time'] += time() - start_time
+        return stats, seeds, result, map_func, map_kw, state0
+
     def run(self, state, tlist, ntraj=1, *,
             args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
         """
@@ -163,25 +185,9 @@ def run(self, state, tlist, ntraj=1, *,
             The simulation will end when the first end condition is reached
             between ``ntraj``, ``timeout`` and ``target_tol``.
         """
-        start_time = time()
-        self._argument(args)
-        stats = self._initialize_stats()
-        seeds = self._read_seed(seed, ntraj)
-
-        result = self.resultclass(
-            e_ops, self.options, solver=self.name, stats=stats
-        )
-        result.add_end_condition(ntraj, target_tol)
-
-        map_func = _get_map[self.options['map']]
-        map_kw = {
-            'timeout': timeout,
-            'job_timeout': self.options['job_timeout'],
-            'num_cpus': self.options['num_cpus'],
-        }
-        state0 = self._prepare_state(state)
-        stats['preparation time'] += time() - start_time
-
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
+                                                                              args=args, e_ops=e_ops, timeout=timeout,
+                                                                              target_tol=target_tol, seed=seed)
         start_time = time()
         map_func(
             self._run_one_traj, seeds,
@@ -193,13 +199,13 @@ def run(self, state, tlist, ntraj=1, *,
         result.stats['run time'] = time() - start_time
         return result
 
-    def _run_one_traj(self, seed, state, tlist, e_ops):
+    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
         result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator)
+        self._integrator.set_state(tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
         result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
@@ -264,24 +270,6 @@ class MultiTrajSolverImprovedSampling(MultiTrajSolver):
     def __init__(self, rhs, *, options=None):
         super().__init__(rhs, options=options)
 
-    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
-        """
-        Run one trajectory and return the result. Here
-        """
-        if no_jump:
-            init_setting = self.options["store_final_state"]
-            self.options["store_final_state"] = True
-        result = self.trajectory_resultclass(e_ops, self.options)
-        generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
-        result.add(tlist[0], self._restore_state(state, copy=False))
-        for t in tlist[1:]:
-            t, state = self._integrator.integrate(t, copy=False)
-            result.add(t, self._restore_state(state, copy=False))
-        if no_jump:
-            self.options["store_final_state"] = init_setting
-        return seed, result
-
     def run(self, state, tlist, ntraj=1, *,
             args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
         """
@@ -290,25 +278,9 @@ def run(self, state, tlist, ntraj=1, *,
         the no-jump trajectory first. Then, the no-jump probability is used as a lower-bound
         for random numbers in future monte carlo runs
         """
-        start_time = time()
-        self._argument(args)
-        stats = self._initialize_stats()
-        seeds = self._read_seed(seed, ntraj)
-
-        result = self.resultclass(
-            e_ops, self.options, solver=self.name, stats=stats
-        )
-        result.add_end_condition(ntraj, target_tol)
-
-        map_func = _get_map[self.options['map']]
-        map_kw = {
-            'timeout': timeout,
-            'job_timeout': self.options['job_timeout'],
-            'num_cpus': self.options['num_cpus'],
-        }
-        state0 = self._prepare_state(state)
-        stats['preparation time'] += time() - start_time
-
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
+                                                                              args=args, e_ops=e_ops, timeout=timeout,
+                                                                              target_tol=target_tol, seed=seed)
         # first run the no-jump trajectory
         start_time = time()
         seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist, e_ops, no_jump=True)
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 4bbfca560c..8ed90b169d 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -485,7 +485,6 @@ def _add_first_traj(self, trajectory):
         self.times = trajectory.times
 
         if trajectory.states:
-            state = trajectory.states[0]
             self._sum_states = [qzero_like(self._to_dm(state))
                                 for state in trajectory.states]
         if trajectory.final_state:
@@ -869,24 +868,44 @@ def __add__(self, other):
 class MultiTrajResultImprovedSampling(MultiTrajResult):
     def __init__(self, e_ops, options, **kw):
         super().__init__(e_ops, options, **kw)
-        self._sum_expect_jump = None
         self._sum_expect_no_jump = None
-        self._sum2_expect_jump = None
+        self._sum_expect_jump = None
         self._sum2_expect_no_jump = None
+        self._sum2_expect_jump = None
+
+        self._sum_states_no_jump = None
+        self._sum_states_jump = None
+        self._sum_final_states_no_jump = None
+        self._sum_final_states_jump = None
+
         self.no_jump_prob = None
 
     def _store_trajectory(self, trajectory, no_jump=False):
         super()._store_trajectory(trajectory)
 
     def _reduce_states(self, trajectory, no_jump=False):
-        # TODO this probably also needs to be changed
-        super()._reduce_states(trajectory)
+        if no_jump:
+            self._sum_states_no_jump = [
+                accu + self._to_dm(state)
+                for accu, state
+                in zip(self._sum_states_no_jump, trajectory.states)
+            ]
+        else:
+            self._sum_states_jump = [
+                accu + self._to_dm(state)
+                for accu, state
+                in zip(self._sum_states_jump, trajectory.states)
+            ]
 
     def _increment_traj(self, trajectory, no_jump=False):
         super()._increment_traj(trajectory)
 
     def _reduce_final_state(self, trajectory, no_jump=False):
-        super()._reduce_final_state(trajectory)
+        dm_final_state = self._to_dm(trajectory.final_state)
+        if no_jump:
+            self._sum_final_states_no_jump += dm_final_state
+        else:
+            self._sum_final_states_jump += dm_final_state
 
     def _add_first_traj(self, trajectory):
         """
@@ -894,6 +913,17 @@ def _add_first_traj(self, trajectory):
         """
 
         super()._add_first_traj(trajectory)
+        if trajectory.states:
+            del self._sum_states
+            self._sum_states_no_jump = [qzero_like(self._to_dm(state))
+                                        for state in trajectory.states]
+            self._sum_states_jump = [qzero_like(self._to_dm(state))
+                                     for state in trajectory.states]
+        if trajectory.final_state:
+            state = trajectory.final_state
+            del self._sum_final_states
+            self._sum_final_states_no_jump = qzero_like(self._to_dm(state))
+            self._sum_final_states_jump = qzero_like(self._to_dm(state))
         self._sum_expect_jump = [
             np.zeros_like(expect) for expect in trajectory.expect
         ]
@@ -943,20 +973,21 @@ def average_states(self):
         """
         States averages as density matrices.
         """
-        # TODO this needs to be changed
-        if self._sum_states is None:
+        if self._sum_states_no_jump is None:
             return None
-        return [final / self.num_trajectories for final in self._sum_states]
+        p = self.no_jump_prob
+        avg_jump_states = [final / (self.num_trajectories - 1) for final in self._sum_states_jump]
+        return p * self._sum_states_no_jump + (1 - p) * avg_jump_states
 
     @property
     def average_final_state(self):
         """
         Last states of each trajectories averaged into a density matrix.
         """
-        # TODO this needs to be changed
-        if self._sum_final_states is None:
+        if self._sum_final_states_no_jump is None:
             return None
-        return self._sum_final_states / self.num_trajectories
+        p = self.no_jump_prob
+        return p * self._sum_final_states_no_jump + (1 - p) * self._sum_final_states_jump / self.num_trajectories
 
     def add(self, trajectory_info, no_jump=False):
         seed, trajectory = trajectory_info

From f0347054a531660ba9ce3effa12842de5bf513e5 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 09:23:42 -0400
Subject: [PATCH 565/602] black

---
 qutip/solver/mcsolve.py   | 109 +++++++++++++----------
 qutip/solver/multitraj.py | 129 +++++++++++++++++++--------
 qutip/solver/result.py    | 177 +++++++++++++++++++-------------------
 3 files changed, 243 insertions(+), 172 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index dd26b6c0b2..b70148fe01 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,4 +1,4 @@
-__all__ = ['mcsolve', "MCSolver"]
+__all__ = ["mcsolve", "MCSolver"]
 
 import numpy as np
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
@@ -10,9 +10,21 @@
 from time import time
 
 
-def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
-            args=None, options=None, seeds=None, target_tol=None, timeout=None,
-            improved_sampling=False):
+def mcsolve(
+    H,
+    state,
+    tlist,
+    c_ops=(),
+    e_ops=None,
+    ntraj=500,
+    *,
+    args=None,
+    options=None,
+    seeds=None,
+    target_tol=None,
+    timeout=None,
+    improved_sampling=False,
+):
     r"""
     Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
     given Hamiltonian and sets of collapse operators. Options for the
@@ -141,25 +153,28 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
         if options is None:
             options = {}
         options = {
-            key: options[key]
-            for key in options
-            if key in MESolver.solver_options
+            key: options[key] for key in options if key in MESolver.solver_options
         }
-        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
-                       options=options)
+        return mesolve(H, state, tlist, e_ops=e_ops, args=args, options=options)
 
     if isinstance(ntraj, (list, tuple)):
         raise TypeError(
-            "ntraj must be an integer. "
-            "A list of numbers is not longer supported."
+            "ntraj must be an integer. " "A list of numbers is not longer supported."
         )
     if not improved_sampling:
         mc = MCSolver(H, c_ops, options=options)
     else:
         mc = MCSolverImprovedSampling(H, c_ops, options=options)
 
-    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
-                    seed=seeds, target_tol=target_tol, timeout=timeout)
+    result = mc.run(
+        state,
+        tlist=tlist,
+        ntraj=ntraj,
+        e_ops=e_ops,
+        seed=seeds,
+        target_tol=target_tol,
+        timeout=timeout,
+    )
     return result
 
 
@@ -167,6 +182,7 @@ class MCIntegrator:
     """
     Integrator like object for mcsolve trajectory.
     """
+
     name = "mcsolve"
 
     def __init__(self, integrator, c_ops, n_ops, options=None):
@@ -208,7 +224,7 @@ def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
             self.target_norm = 0.0
         else:
             self.target_norm = (
-                    self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
+                self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
             )
         self._integrator.set_state(t, state0)
         self._is_set = True
@@ -223,11 +239,10 @@ def integrate(self, t, copy=False):
             t_step, state = self._integrator.mcstep(t, copy=False)
             norm = self._prob_func(state)
             if norm <= self.target_norm:
-                t_col, state = self._find_collapse_time(norm_old, norm,
-                                                        t_old, t_step)
+                t_col, state = self._find_collapse_time(norm_old, norm, t_old, t_step)
                 self._do_collapse(t_col, state)
                 t_old, y_old = self._integrator.get_state(copy=False)
-                norm_old = 1.
+                norm_old = 1.0
             else:
                 t_old, y_old = t_step, state
                 norm_old = norm
@@ -244,7 +259,7 @@ def reset(self, hard=False):
     def _prob_func(self, state):
         if self.issuper:
             return _data.trace_oper_ket(state).real
-        return _data.norm.l2(state)**2
+        return _data.norm.l2(state) ** 2
 
     def _norm_func(self, state):
         if self.issuper:
@@ -254,28 +269,27 @@ def _norm_func(self, state):
     def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
         """Find the time of the collapse and state just before it."""
         tries = 0
-        while tries < self.options['norm_steps']:
+        while tries < self.options["norm_steps"]:
             tries += 1
-            if (t_final - t_prev) < self.options['norm_t_tol']:
+            if (t_final - t_prev) < self.options["norm_t_tol"]:
                 t_guess = t_final
                 _, state = self._integrator.get_state()
                 break
-            t_guess = (
-                t_prev
-                + ((t_final - t_prev)
-                   * np.log(norm_old / self.target_norm)
-                   / np.log(norm_old / norm))
+            t_guess = t_prev + (
+                (t_final - t_prev)
+                * np.log(norm_old / self.target_norm)
+                / np.log(norm_old / norm)
             )
-            if (t_guess - t_prev) < self.options['norm_t_tol']:
-                t_guess = t_prev + self.options['norm_t_tol']
+            if (t_guess - t_prev) < self.options["norm_t_tol"]:
+                t_guess = t_prev + self.options["norm_t_tol"]
             _, state = self._integrator.mcstep(t_guess, copy=False)
             norm2_guess = self._prob_func(state)
             if (
-                np.abs(self.target_norm - norm2_guess) <
-                self.options['norm_tol'] * self.target_norm
+                np.abs(self.target_norm - norm2_guess)
+                < self.options["norm_tol"] * self.target_norm
             ):
                 break
-            elif (norm2_guess < self.target_norm):
+            elif norm2_guess < self.target_norm:
                 # t_guess is still > t_jump
                 t_final = t_guess
                 norm = norm2_guess
@@ -284,11 +298,12 @@ def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
                 t_prev = t_guess
                 norm_old = norm2_guess
 
-        if tries >= self.options['norm_steps']:
+        if tries >= self.options["norm_steps"]:
             raise RuntimeError(
                 "Could not find the collapse time within desired tolerance. "
                 "Increase accuracy of the ODE solver or lower the tolerance "
-                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
+                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'."
+            )
 
         return t_guess, state
 
@@ -308,12 +323,11 @@ def _do_collapse(self, collapse_time, state):
             for i, n_op in enumerate(self._n_ops):
                 probs[i] = n_op.expect_data(collapse_time, state).real
             probs = np.cumsum(probs)
-            which = np.searchsorted(probs,
-                                    probs[-1] * self._generator.random())
+            which = np.searchsorted(probs, probs[-1] * self._generator.random())
 
         state_new = self._c_ops[which].matmul_data(collapse_time, state)
         new_norm = self._norm_func(state_new)
-        if new_norm < self.options['mc_corr_eps']:
+        if new_norm < self.options["mc_corr_eps"]:
             # This happen when the collapse is caused by numerical error
             state_new = _data.mul(state, 1 / self._norm_func(state))
         else:
@@ -416,9 +430,8 @@ def _restore_state(self, data, *, copy=True):
         """
         Retore the Qobj state from its data.
         """
-        if self._state_metadata['dims'] == self.rhs.dims[1]:
-            state = Qobj(unstack_columns(data),
-                         **self._state_metadata, copy=False)
+        if self._state_metadata["dims"] == self.rhs.dims[1]:
+            state = Qobj(unstack_columns(data), **self._state_metadata, copy=False)
         else:
             state = Qobj(data, **self._state_metadata, copy=copy)
 
@@ -426,11 +439,13 @@ def _restore_state(self, data, *, copy=True):
 
     def _initialize_stats(self):
         stats = super()._initialize_stats()
-        stats.update({
-            "method": self.options["method"],
-            "solver": "Master Equation Evolution",
-            "num_collapse": self._num_collapse,
-        })
+        stats.update(
+            {
+                "method": self.options["method"],
+                "solver": "Master Equation Evolution",
+                "num_collapse": self._num_collapse,
+            }
+        )
         return stats
 
     def _argument(self, args):
@@ -441,7 +456,9 @@ def _argument(self, args):
         for n_op in self._n_ops:
             n_op.arguments(args)
 
-    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
+    def _run_one_traj(
+        self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
+    ):
         """
         Run one trajectory and return the result.
         """
@@ -449,7 +466,9 @@ def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floo
         # multiprocessing, but will fail with multithreading.
         # If a thread base parallel map is created, eahc trajectory should use
         # a copy of the integrator.
-        seed, result = super()._run_one_traj(seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
+        seed, result = super()._run_one_traj(
+            seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor
+        )
         result.collapse = self._integrator.collapses
         return seed, result
 
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index df1b9abece..ecab21e703 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -26,6 +26,7 @@ class MultiTrajSolver(Solver):
     options : dict
         Options for the solver.
     """
+
     name = "generic multi trajectory"
     resultclass = MultiTrajResult
     trajectory_resultclass = Result
@@ -102,30 +103,47 @@ def step(self, t, *, args=None, copy=True):
         _, state = self._integrator.integrate(t, copy=False)
         return self._restore_state(state, copy=copy)
 
-    def _initialize_run(self, state, ntraj=1, *,
-                        args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+    def _initialize_run(
+        self,
+        state,
+        ntraj=1,
+        *,
+        args=None,
+        e_ops=(),
+        timeout=None,
+        target_tol=None,
+        seed=None
+    ):
         start_time = time()
         self._argument(args)
         stats = self._initialize_stats()
         seeds = self._read_seed(seed, ntraj)
 
-        result = self.resultclass(
-            e_ops, self.options, solver=self.name, stats=stats
-        )
+        result = self.resultclass(e_ops, self.options, solver=self.name, stats=stats)
         result.add_end_condition(ntraj, target_tol)
 
-        map_func = _get_map[self.options['map']]
+        map_func = _get_map[self.options["map"]]
         map_kw = {
-            'timeout': timeout,
-            'job_timeout': self.options['job_timeout'],
-            'num_cpus': self.options['num_cpus'],
+            "timeout": timeout,
+            "job_timeout": self.options["job_timeout"],
+            "num_cpus": self.options["num_cpus"],
         }
         state0 = self._prepare_state(state)
-        stats['preparation time'] += time() - start_time
+        stats["preparation time"] += time() - start_time
         return stats, seeds, result, map_func, map_kw, state0
 
-    def run(self, state, tlist, ntraj=1, *,
-            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+    def run(
+        self,
+        state,
+        tlist,
+        ntraj=1,
+        *,
+        args=None,
+        e_ops=(),
+        timeout=None,
+        target_tol=None,
+        seed=None
+    ):
         """
         Do the evolution of the Quantum system.
 
@@ -185,27 +203,39 @@ def run(self, state, tlist, ntraj=1, *,
             The simulation will end when the first end condition is reached
             between ``ntraj``, ``timeout`` and ``target_tol``.
         """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
-                                                                              args=args, e_ops=e_ops, timeout=timeout,
-                                                                              target_tol=target_tol, seed=seed)
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
+            state,
+            ntraj,
+            args=args,
+            e_ops=e_ops,
+            timeout=timeout,
+            target_tol=target_tol,
+            seed=seed,
+        )
         start_time = time()
         map_func(
-            self._run_one_traj, seeds,
+            self._run_one_traj,
+            seeds,
             (state0, tlist, e_ops),
-            reduce_func=result.add, map_kw=map_kw,
+            reduce_func=result.add,
+            map_kw=map_kw,
             progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"]
+            progress_bar_kwargs=self.options["progress_kwargs"],
         )
-        result.stats['run time'] = time() - start_time
+        result.stats["run time"] = time() - start_time
         return result
 
-    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
+    def _run_one_traj(
+        self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
+    ):
         """
         Run one trajectory and return the result.
         """
         result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
+        self._integrator.set_state(
+            tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor
+        )
         result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
@@ -225,8 +255,11 @@ def _read_seed(self, seed, ntraj):
             seeds = np.random.SeedSequence(seed).spawn(ntraj)
         elif len(seed) >= ntraj:
             seeds = [
-                seed_ if (isinstance(seed_, np.random.SeedSequence)
-                          or hasattr(seed_, 'random'))
+                seed_
+                if (
+                    isinstance(seed_, np.random.SeedSequence)
+                    or hasattr(seed_, "random")
+                )
                 else np.random.SeedSequence(seed_)
                 for seed_ in seed[:ntraj]
             ]
@@ -245,13 +278,13 @@ def _get_generator(self, seed):
         If the ``seed`` has a ``random`` method, it will be used as the
         generator.
         """
-        if hasattr(seed, 'random'):
+        if hasattr(seed, "random"):
             # We check for the method, not the type to accept pseudo non-random
             # generator for debug/testing purpose.
             return seed
 
-        if self.options['bitgenerator']:
-            bit_gen = getattr(np.random, self.options['bitgenerator'])
+        if self.options["bitgenerator"]:
+            bit_gen = getattr(np.random, self.options["bitgenerator"])
             generator = np.random.Generator(bit_gen(seed))
         else:
             generator = np.random.default_rng(seed)
@@ -270,36 +303,56 @@ class MultiTrajSolverImprovedSampling(MultiTrajSolver):
     def __init__(self, rhs, *, options=None):
         super().__init__(rhs, options=options)
 
-    def run(self, state, tlist, ntraj=1, *,
-            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+    def run(
+        self,
+        state,
+        tlist,
+        ntraj=1,
+        *,
+        args=None,
+        e_ops=(),
+        timeout=None,
+        target_tol=None,
+        seed=None
+    ):
         """
         Do the evolution of the Quantum system.
         See the overridden method for further details. The modification here is to sample
         the no-jump trajectory first. Then, the no-jump probability is used as a lower-bound
         for random numbers in future monte carlo runs
         """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
-                                                                              args=args, e_ops=e_ops, timeout=timeout,
-                                                                              target_tol=target_tol, seed=seed)
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
+            state,
+            ntraj,
+            args=args,
+            e_ops=e_ops,
+            timeout=timeout,
+            target_tol=target_tol,
+            seed=seed,
+        )
         # first run the no-jump trajectory
         start_time = time()
-        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist, e_ops, no_jump=True)
+        seed0, no_jump_result = self._run_one_traj(
+            seeds[0], state0, tlist, e_ops, no_jump=True
+        )
         _, state, _ = self._integrator.get_state(copy=False)
         no_jump_prob = self._integrator._prob_func(state)
         result.no_jump_prob = no_jump_prob
         result.add((seed0, no_jump_result), no_jump=True)
-        result.stats['no jump run time'] = time() - start_time
+        result.stats["no jump run time"] = time() - start_time
 
         # run the remaining trajectories with the random number floor set to the
         # no jump probability such that we only sample trajectories with jumps
         start_time = time()
         # implied here that no_jump=False for result.add
         map_func(
-            self._run_one_traj, seeds[1:],
+            self._run_one_traj,
+            seeds[1:],
             (state0, tlist, e_ops, False, no_jump_prob),
-            reduce_func=result.add, map_kw=map_kw,
+            reduce_func=result.add,
+            map_kw=map_kw,
             progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"]
+            progress_bar_kwargs=self.options["progress_kwargs"],
         )
-        result.stats['run time'] = time() - start_time
-        return result
\ No newline at end of file
+        result.stats["run time"] = time() - start_time
+        return result
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 8ed90b169d..892fea52f8 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -15,6 +15,7 @@ class _QobjExpectEop:
     op : :obj:`~Qobj`
         The expectation value operator.
     """
+
     def __init__(self, op):
         self.op = op
 
@@ -45,6 +46,7 @@ class ExpectOp:
     op : object
         The original object used to define the e_op operation.
     """
+
     def __init__(self, op, f, append):
         self.op = op
         self._f = f
@@ -69,6 +71,7 @@ class _BaseResult:
     """
     Common method for all ``Result``.
     """
+
     def __init__(self, options, *, solver=None, stats=None):
         self.solver = solver
         if stats is None:
@@ -81,7 +84,7 @@ def __init__(self, options, *, solver=None, stats=None):
         self.options = options
 
     def _e_ops_to_dict(self, e_ops):
-        """ Convert the supplied e_ops to a dictionary of Eop instances. """
+        """Convert the supplied e_ops to a dictionary of Eop instances."""
         if e_ops is None:
             e_ops = {}
         elif isinstance(e_ops, (list, tuple)):
@@ -194,6 +197,7 @@ class Result(_BaseResult):
     options : dict
         The options for this result class.
     """
+
     def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
         super().__init__(options, solver=solver, stats=stats)
         raw_ops = self._e_ops_to_dict(e_ops)
@@ -238,8 +242,8 @@ def _post_init(self):
         Sub-class ``.post_init()`` implementation may take additional keyword
         arguments if required.
         """
-        store_states = self.options['store_states']
-        store_final_state = self.options['store_final_state']
+        store_states = self.options["store_states"]
+        store_final_state = self.options["store_final_state"]
 
         if store_states is None:
             store_states = len(self.e_ops) == 0
@@ -250,17 +254,17 @@ def _post_init(self):
             self.add_processor(self._store_final_state, requires_copy=True)
 
     def _store_state(self, t, state):
-        """ Processor that stores a state in ``.states``. """
+        """Processor that stores a state in ``.states``."""
         self.states.append(state)
 
     def _store_final_state(self, t, state):
-        """ Processor that writes the state to ``.final_state``. """
+        """Processor that writes the state to ``.final_state``."""
         self.final_state = state
 
     def _pre_copy(self, state):
-        """ Return a copy of the state. Sub-classes may override this to
-            copy a state in different manner or to skip making a copy
-            altogether if a copy is not necessary.
+        """Return a copy of the state. Sub-classes may override this to
+        copy a state in different manner or to skip making a copy
+        altogether if a copy is not necessary.
         """
         return state.copy()
 
@@ -306,10 +310,7 @@ def __repr__(self):
         ]
         if self.stats:
             lines.append("  Solver stats:")
-            lines.extend(
-                f"    {k}: {v!r}"
-                for k, v in self.stats.items()
-            )
+            lines.extend(f"    {k}: {v!r}" for k, v in self.stats.items())
         if self.times:
             lines.append(
                 f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
@@ -450,6 +451,7 @@ class MultiTrajResult(_BaseResult):
     options : :obj:`~SolverResultsOptions`
         The options for this result class.
     """
+
     def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
         super().__init__(options, solver=solver, stats=stats)
         self._raw_ops = self._e_ops_to_dict(e_ops)
@@ -474,7 +476,7 @@ def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
 
     @staticmethod
     def _to_dm(state):
-        if state.type == 'ket':
+        if state.type == "ket":
             state = state.proj()
         return state
 
@@ -485,28 +487,24 @@ def _add_first_traj(self, trajectory):
         self.times = trajectory.times
 
         if trajectory.states:
-            self._sum_states = [qzero_like(self._to_dm(state))
-                                for state in trajectory.states]
+            self._sum_states = [
+                qzero_like(self._to_dm(state)) for state in trajectory.states
+            ]
         if trajectory.final_state:
             state = trajectory.final_state
             self._sum_final_states = qzero_like(self._to_dm(state))
 
-        self._sum_expect = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
-        self._sum2_expect = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
+        self._sum_expect = [np.zeros_like(expect) for expect in trajectory.expect]
+        self._sum2_expect = [np.zeros_like(expect) for expect in trajectory.expect]
 
         self.e_ops = trajectory.e_ops
 
         self.average_e_data = {
             k: list(avg_expect)
-            for k, avg_expect
-            in zip(self._raw_ops, self._sum_expect)
+            for k, avg_expect in zip(self._raw_ops, self._sum_expect)
         }
         self.e_data = self.average_e_data
-        if self.options['keep_runs_results']:
+        if self.options["keep_runs_results"]:
             self.runs_e_data = {k: [] for k in self._raw_ops}
             self.e_data = self.runs_e_data
 
@@ -516,8 +514,7 @@ def _store_trajectory(self, trajectory):
     def _reduce_states(self, trajectory):
         self._sum_states = [
             accu + self._to_dm(state)
-            for accu, state
-            in zip(self._sum_states, trajectory.states)
+            for accu, state in zip(self._sum_states, trajectory.states)
         ]
 
     def _reduce_final_state(self, trajectory):
@@ -564,7 +561,7 @@ def _fixed_end(self):
         """
         ntraj_left = self._target_ntraj - self.num_trajectories
         if ntraj_left == 0:
-            self.stats['end_condition'] = 'ntraj reached'
+            self.stats["end_condition"] = "ntraj reached"
         return ntraj_left
 
     def _target_tolerance_end(self):
@@ -577,25 +574,23 @@ def _target_tolerance_end(self):
             return np.inf
         avg = np.array(self._sum_expect) / self.num_trajectories
         avg2 = np.array(self._sum2_expect) / self.num_trajectories
-        target = np.array([
-            atol + rtol * mean
-            for mean, (atol, rtol)
-            in zip(avg, self._target_tols)
-        ])
-        target_ntraj = np.max((avg2 - abs(avg)**2) / target**2 + 1)
+        target = np.array(
+            [atol + rtol * mean for mean, (atol, rtol) in zip(avg, self._target_tols)]
+        )
+        target_ntraj = np.max((avg2 - abs(avg) ** 2) / target**2 + 1)
 
         self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
         if (self._estimated_ntraj - self.num_trajectories) <= 0:
-            self.stats['end_condition'] = 'target tolerance reached'
+            self.stats["end_condition"] = "target tolerance reached"
         return self._estimated_ntraj - self.num_trajectories
 
     def _post_init(self):
         self.num_trajectories = 0
         self._target_ntraj = None
 
-        store_states = self.options['store_states']
-        store_final_state = self.options['store_final_state']
-        store_traj = self.options['keep_runs_results']
+        store_states = self.options["store_states"]
+        store_final_state = self.options["store_final_state"]
+        store_traj = self.options["keep_runs_results"]
 
         self.add_processor(self._increment_traj)
         if store_traj:
@@ -610,7 +605,7 @@ def _post_init(self):
             self.add_processor(self._reduce_expect)
 
         self._early_finish_check = self._no_end
-        self.stats['end_condition'] = 'unknown'
+        self.stats["end_condition"] = "unknown"
 
     def add(self, trajectory_info):
         """
@@ -666,7 +661,7 @@ def add_end_condition(self, ntraj, target_tol=None):
             Error estimation is done with jackknife resampling.
         """
         self._target_ntraj = ntraj
-        self.stats['end_condition'] = 'timeout'
+        self.stats["end_condition"] = "timeout"
 
         if target_tol is None:
             self._early_finish_check = self._fixed_end
@@ -681,14 +676,16 @@ def add_end_condition(self, ntraj, target_tol=None):
 
         targets = np.array(target_tol)
         if targets.ndim == 0:
-            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
+            self._target_tols = np.array([(target_tol, 0.0)] * num_e_ops)
         elif targets.shape == (2,):
             self._target_tols = np.ones((num_e_ops, 2)) * targets
         elif targets.shape == (num_e_ops, 2):
             self._target_tols = targets
         else:
-            raise ValueError("target_tol must be a number, a pair of (atol, "
-                             "rtol) or a list of (atol, rtol) for each e_ops")
+            raise ValueError(
+                "target_tol must be a number, a pair of (atol, "
+                "rtol) or a list of (atol, rtol) for each e_ops"
+            )
 
         self._early_finish_check = self._target_tolerance_end
 
@@ -786,10 +783,7 @@ def __repr__(self):
         ]
         if self.stats:
             lines.append("  Solver stats:")
-            lines.extend(
-                f"    {k}: {v!r}"
-                for k, v in self.stats.items()
-            )
+            lines.extend(f"    {k}: {v!r}" for k, v in self.stats.items())
         if self.times:
             lines.append(
                 f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
@@ -817,8 +811,9 @@ def __add__(self, other):
             raise ValueError("Shared `e_ops` is required to merge results")
         if self.times != other.times:
             raise ValueError("Shared `times` are is required to merge results")
-        new = self.__class__(self._raw_ops, self.options,
-                             solver=self.solver, stats=self.stats)
+        new = self.__class__(
+            self._raw_ops, self.options, solver=self.solver, stats=self.stats
+        )
         if self.trajectories and other.trajectories:
             new.trajectories = self.trajectories + other.trajectories
         new.num_trajectories = self.num_trajectories + other.num_trajectories
@@ -828,13 +823,8 @@ def __add__(self, other):
         if self._sum_states is not None and other._sum_states is not None:
             new._sum_states = self._sum_states + other._sum_states
 
-        if (
-            self._sum_final_states is not None
-            and other._sum_final_states is not None
-        ):
-            new._sum_final_states = (
-                self._sum_final_states + other._sum_final_states
-            )
+        if self._sum_final_states is not None and other._sum_final_states is not None:
+            new._sum_final_states = self._sum_final_states + other._sum_final_states
         new._target_tols = None
 
         new._sum_expect = []
@@ -844,8 +834,7 @@ def __add__(self, other):
 
         for i, k in enumerate(self._raw_ops):
             new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
-            new._sum2_expect.append(self._sum2_expect[i]
-                                    + other._sum2_expect[i])
+            new._sum2_expect.append(self._sum2_expect[i] + other._sum2_expect[i])
 
             avg = new._sum_expect[i] / new.num_trajectories
             avg2 = new._sum2_expect[i] / new.num_trajectories
@@ -860,7 +849,7 @@ def __add__(self, other):
                 new.e_data = new.runs_e_data
 
         new.stats["run time"] += other.stats["run time"]
-        new.stats['end_condition'] = "Merged results"
+        new.stats["end_condition"] = "Merged results"
 
         return new
 
@@ -887,14 +876,12 @@ def _reduce_states(self, trajectory, no_jump=False):
         if no_jump:
             self._sum_states_no_jump = [
                 accu + self._to_dm(state)
-                for accu, state
-                in zip(self._sum_states_no_jump, trajectory.states)
+                for accu, state in zip(self._sum_states_no_jump, trajectory.states)
             ]
         else:
             self._sum_states_jump = [
                 accu + self._to_dm(state)
-                for accu, state
-                in zip(self._sum_states_jump, trajectory.states)
+                for accu, state in zip(self._sum_states_jump, trajectory.states)
             ]
 
     def _increment_traj(self, trajectory, no_jump=False):
@@ -915,21 +902,19 @@ def _add_first_traj(self, trajectory):
         super()._add_first_traj(trajectory)
         if trajectory.states:
             del self._sum_states
-            self._sum_states_no_jump = [qzero_like(self._to_dm(state))
-                                        for state in trajectory.states]
-            self._sum_states_jump = [qzero_like(self._to_dm(state))
-                                     for state in trajectory.states]
+            self._sum_states_no_jump = [
+                qzero_like(self._to_dm(state)) for state in trajectory.states
+            ]
+            self._sum_states_jump = [
+                qzero_like(self._to_dm(state)) for state in trajectory.states
+            ]
         if trajectory.final_state:
             state = trajectory.final_state
             del self._sum_final_states
             self._sum_final_states_no_jump = qzero_like(self._to_dm(state))
             self._sum_final_states_jump = qzero_like(self._to_dm(state))
-        self._sum_expect_jump = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
-        self._sum2_expect_jump = [
-            np.zeros_like(expect) for expect in trajectory.expect
-        ]
+        self._sum_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
+        self._sum2_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
         self._sum_expect_no_jump = [
             np.zeros_like(expect) for expect in trajectory.expect
         ]
@@ -955,9 +940,13 @@ def _reduce_expect(self, trajectory, no_jump=False):
                 avg2 = self._sum2_expect_no_jump[i]
             else:
                 self._sum_expect_jump[i] += expect_traj * (1 - self.no_jump_prob)
-                self._sum2_expect_jump[i] += expect_traj ** 2 * (1 - self.no_jump_prob)
-                avg = self._sum_expect_no_jump[i] + self._sum_expect_jump[i] / (self.num_trajectories - 1)
-                avg2 = self._sum2_expect_no_jump[i] + self._sum2_expect_jump[i] / (self.num_trajectories - 1)
+                self._sum2_expect_jump[i] += expect_traj**2 * (1 - self.no_jump_prob)
+                avg = self._sum_expect_no_jump[i] + self._sum_expect_jump[i] / (
+                    self.num_trajectories - 1
+                )
+                avg2 = self._sum2_expect_no_jump[i] + self._sum2_expect_jump[i] / (
+                    self.num_trajectories - 1
+                )
 
             self.average_e_data[k] = list(avg)
 
@@ -976,7 +965,9 @@ def average_states(self):
         if self._sum_states_no_jump is None:
             return None
         p = self.no_jump_prob
-        avg_jump_states = [final / (self.num_trajectories - 1) for final in self._sum_states_jump]
+        avg_jump_states = [
+            final / (self.num_trajectories - 1) for final in self._sum_states_jump
+        ]
         return p * self._sum_states_no_jump + (1 - p) * avg_jump_states
 
     @property
@@ -987,7 +978,10 @@ def average_final_state(self):
         if self._sum_final_states_no_jump is None:
             return None
         p = self.no_jump_prob
-        return p * self._sum_final_states_no_jump + (1 - p) * self._sum_final_states_jump / self.num_trajectories
+        return (
+            p * self._sum_final_states_no_jump
+            + (1 - p) * self._sum_final_states_jump / self.num_trajectories
+        )
 
     def add(self, trajectory_info, no_jump=False):
         seed, trajectory = trajectory_info
@@ -1008,8 +1002,7 @@ class McTrajectoryResult(Result):
     """
 
     def __init__(self, e_ops, options, *args, **kwargs):
-        super().__init__(e_ops, {**options, "normalize_output": False},
-                         *args, **kwargs)
+        super().__init__(e_ops, {**options, "normalize_output": False}, *args, **kwargs)
 
 
 class McResult(MultiTrajResult):
@@ -1049,6 +1042,7 @@ class McResult(MultiTrajResult):
         For each runs, a list of every collapse as a tuple of the time it
         happened and the corresponding ``c_ops`` index.
     """
+
     # Collapse are only produced by mcsolve.
 
     def _add_collapse(self, trajectory):
@@ -1068,7 +1062,7 @@ def col_times(self):
         out = []
         for col_ in self.collapse:
             col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[0])
+            col = [] if len(col) == 0 else col[0]
             out.append(col)
         return out
 
@@ -1080,7 +1074,7 @@ def col_which(self):
         out = []
         for col_ in self.collapse:
             col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[1])
+            col = [] if len(col) == 0 else col[1]
             out.append(col)
         return out
 
@@ -1111,17 +1105,22 @@ def runs_photocurrent(self):
             cols = [[] for _ in range(self.num_c_ops)]
             for t, which in collapses:
                 cols[which].append(t)
-            measurements.append([
-                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
-                for i in range(self.num_c_ops)
-            ])
+            measurements.append(
+                [
+                    np.histogram(cols[i], tlist)[0] / np.diff(tlist)
+                    for i in range(self.num_c_ops)
+                ]
+            )
         return measurements
 
 
 class McResultImprovedSampling(MultiTrajResultImprovedSampling, McResult):
     """McResult class using the MultiTrajResultImprovedSampling functionality"""
+
     def __init__(self, e_ops, options, **kw):
-        MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops, options=options, **kw)
+        MultiTrajResultImprovedSampling.__init__(
+            self, e_ops=e_ops, options=options, **kw
+        )
 
     def _add_collapse(self, trajectory, no_jump=False):
         super()._add_collapse(trajectory)
@@ -1216,15 +1215,15 @@ def _add_first_traj(self, trajectory):
     def _add_trace(self, trajectory):
         new_trace = np.array(trajectory.trace)
         self._sum_trace += new_trace
-        self._sum2_trace += np.abs(new_trace)**2
+        self._sum2_trace += np.abs(new_trace) ** 2
 
         avg = self._sum_trace / self.num_trajectories
         avg2 = self._sum2_trace / self.num_trajectories
 
         self.average_trace = avg
-        self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg)**2))
+        self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg) ** 2))
 
-        if self.options['keep_runs_results']:
+        if self.options["keep_runs_results"]:
             self.runs_trace.append(trajectory.trace)
 
     @property

From 124eabc724383889d753c9d01445f28414b86915 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 10:34:07 -0400
Subject: [PATCH 566/602] small bug fixes in average_states, added tests
 leveraging existing mcsolve tests

---
 qutip/solver/result.py             | 21 ++++++----
 qutip/tests/solver/test_mcsolve.py | 65 ++++++++++++++++++++----------
 2 files changed, 58 insertions(+), 28 deletions(-)

diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 892fea52f8..206b55e5ad 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -564,6 +564,11 @@ def _fixed_end(self):
             self.stats["end_condition"] = "ntraj reached"
         return ntraj_left
 
+    def _average_computer(self):
+        avg = np.array(self._sum_expect) / self.num_trajectories
+        avg2 = np.array(self._sum2_expect) / self.num_trajectories
+        return avg, avg2
+
     def _target_tolerance_end(self):
         """
         Compute the error on the expectation values using jackknife resampling.
@@ -572,8 +577,7 @@ def _target_tolerance_end(self):
         """
         if self.num_trajectories <= 1:
             return np.inf
-        avg = np.array(self._sum_expect) / self.num_trajectories
-        avg2 = np.array(self._sum2_expect) / self.num_trajectories
+        avg, avg2 = self._average_computer()
         target = np.array(
             [atol + rtol * mean for mean, (atol, rtol) in zip(avg, self._target_tols)]
         )
@@ -894,6 +898,11 @@ def _reduce_final_state(self, trajectory, no_jump=False):
         else:
             self._sum_final_states_jump += dm_final_state
 
+    def _average_computer(self):
+        avg = np.array(self._sum_expect_jump) / (self.num_trajectories - 1)
+        avg2 = np.array(self._sum2_expect_jump) / (self.num_trajectories - 1)
+        return avg, avg2
+
     def _add_first_traj(self, trajectory):
         """
         Read the first trajectory, intitializing needed data.
@@ -965,10 +974,8 @@ def average_states(self):
         if self._sum_states_no_jump is None:
             return None
         p = self.no_jump_prob
-        avg_jump_states = [
-            final / (self.num_trajectories - 1) for final in self._sum_states_jump
-        ]
-        return p * self._sum_states_no_jump + (1 - p) * avg_jump_states
+        return [p * final_no_jump + (1 - p) * final_jump / (self.num_trajectories - 1)
+                for final_no_jump, final_jump in zip(self._sum_states_no_jump, self._sum_states_jump)]
 
     @property
     def average_final_state(self):
@@ -980,7 +987,7 @@ def average_final_state(self):
         p = self.no_jump_prob
         return (
             p * self._sum_final_states_no_jump
-            + (1 - p) * self._sum_final_states_jump / self.num_trajectories
+            + (1 - p) * self._sum_final_states_jump / (self.num_trajectories - 1)
         )
 
     def add(self, trajectory_info, no_jump=False):
diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index be5b5b3bad..1be030d451 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -56,8 +56,13 @@ def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
                          options=options, target_tol=0.05)
+        result_improved_sampling = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+                         options=options, improved_sampling=True)
         self._assert_expect(result, expected, tol)
         self._assert_states(result, expected, tol)
+        self._assert_expect(result_improved_sampling, expected, tol)
+        self._assert_states(result_improved_sampling, expected, tol)
 
 
 class TestNoCollapse(StatesAndExpectOutputCase):
@@ -93,13 +98,21 @@ def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
                          options=options)
+        result_improved_sampling = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
+                         options=options, improved_sampling=True)
         self._assert_states(result, expected, tol)
+        self._assert_states(result_improved_sampling, expected, tol)
 
     def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
                          options={'map': 'serial'})
+        result_improved_sampling = mcsolve(hamiltonian, self.state, self.times, args=args,
+                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
+                         options={'map': 'serial'}, improved_sampling=True)
         self._assert_expect(result, expected, tol)
+        self._assert_expect(result_improved_sampling, expected, tol)
 
 
 class TestConstantCollapse(StatesAndExpectOutputCase):
@@ -168,8 +181,9 @@ def test_stored_collapse_operators_and_times():
     assert all(col in [0, 1] for col in result.col_which[0])
 
 
-@pytest.mark.parametrize('keep_runs_results', [True, False])
-def test_states_outputs(keep_runs_results):
+@pytest.mark.parametrize("keep_runs_results, improved_sampling",
+                         [(True, True), (True, False), (False, True), (False, False)])
+def test_states_outputs(keep_runs_results, improved_sampling):
     # We're just testing the output value, so it's important whether certain
     # things are complex or real, but not what the magnitudes of constants are.
     focks = 5
@@ -183,7 +197,7 @@ def test_states_outputs(keep_runs_results):
     c_ops = [a, sm]
     data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
                    options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'})
+                            'map': 'serial'}, improved_sampling=improved_sampling)
 
     assert len(data.average_states) == len(times)
     assert isinstance(data.average_states[0], qutip.Qobj)
@@ -224,8 +238,9 @@ def test_states_outputs(keep_runs_results):
     assert data.stats['end_condition'] == "ntraj reached"
 
 
-@pytest.mark.parametrize('keep_runs_results', [True, False])
-def test_expectation_outputs(keep_runs_results):
+@pytest.mark.parametrize("keep_runs_results, improved_sampling",
+                         [(True, True), (True, False), (False, True), (False, False)])
+def test_expectation_outputs(keep_runs_results, improved_sampling):
     # We're just testing the output value, so it's important whether certain
     # things are complex or real, but not what the magnitudes of constants are.
     focks = 5
@@ -240,7 +255,7 @@ def test_expectation_outputs(keep_runs_results):
     e_ops = [a.dag()*a, sm.dag()*sm, a]
     data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
                    options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'})
+                            'map': 'serial'}, improved_sampling=improved_sampling)
     assert isinstance(data.average_expect[0][1], float)
     assert isinstance(data.average_expect[1][1], float)
     assert isinstance(data.average_expect[2][1], complex)
@@ -283,9 +298,10 @@ class TestSeeds:
         np.sqrt(2*dampings[2]) * qutip.tensor(qutip.qeye(sizes[:2]), a[2]),
     ]
 
-    def test_seeds_can_be_reused(self):
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_seeds_can_be_reused(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
         first = mcsolve(*args, **kwargs)
         second = mcsolve(*args, seeds=first.seeds, **kwargs)
         for first_t, second_t in zip(first.col_times, second.col_times):
@@ -293,9 +309,10 @@ def test_seeds_can_be_reused(self):
         for first_w, second_w in zip(first.col_which, second.col_which):
             np.testing.assert_equal(first_w, second_w)
 
-    def test_seeds_are_not_reused_by_default(self):
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_seeds_are_not_reused_by_default(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
         first = mcsolve(*args, **kwargs)
         second = mcsolve(*args, **kwargs)
         assert not all(np.array_equal(first_t, second_t)
@@ -305,24 +322,28 @@ def test_seeds_are_not_reused_by_default(self):
                        for first_w, second_w in zip(first.col_which,
                                                     second.col_which))
 
-    @pytest.mark.parametrize('seed', [1, np.random.SeedSequence(2)])
-    def test_seed_type(self, seed):
+    @pytest.mark.parametrize('seed, improved_sampling',
+                             [(1, True), (np.random.SeedSequence(2), False),
+                              (1, False), (np.random.SeedSequence(2), True)])
+    def test_seed_type(self, seed, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
         first = mcsolve(*args, seeds=copy(seed), **kwargs)
         second = mcsolve(*args, seeds=copy(seed), **kwargs)
         for f_seed, s_seed in zip(first.seeds, second.seeds):
             assert f_seed.state == s_seed.state
 
-    def test_bad_seed(self):
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_bad_seed(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
         with pytest.raises(ValueError):
             first = mcsolve(*args, seeds=[1], **kwargs)
 
-    def test_generator(self):
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_generator(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
         first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
                         **kwargs)
         second = mcsolve(*args, seeds=1, **kwargs)
@@ -348,7 +369,8 @@ def test_stepping(self):
         assert state_1 == state_2
 
 
-def test_timeout():
+@pytest.mark.parametrize("improved_sampling", [True, False])
+def test_timeout(improved_sampling):
     size = 10
     ntraj = 1000
     a = qutip.destroy(size)
@@ -360,11 +382,12 @@ def test_timeout():
     c_ops = np.sqrt(coupling * (n_th + 1)) * a
     e_ops = [qutip.num(size)]
     res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                  options={'map': 'serial'}, timeout=1e-6)
+                  options={'map': 'serial'}, timeout=1e-6, improved_sampling=improved_sampling)
     assert res.stats['end_condition'] == 'timeout'
 
 
-def test_super_H():
+@pytest.mark.parametrize("improved_sampling", [True, False])
+def test_super_H(improved_sampling):
     size = 10
     ntraj = 1000
     a = qutip.destroy(size)
@@ -379,7 +402,7 @@ def test_super_H():
     mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
                           target_tol=0.1, options={'map': 'serial'})
     mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
-                 target_tol=0.1, options={'map': 'serial'})
+                 target_tol=0.1, options={'map': 'serial'}, improved_sampling=improved_sampling)
     np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
 
 

From 5284162e6302a9a4422c1d71032ab34070e58587 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 12:01:48 -0400
Subject: [PATCH 567/602] docstrings, updated user guide

---
 doc/biblio.rst                        |  5 +++-
 doc/guide/dynamics/dynamics-monte.rst | 14 ++++++++++++
 qutip/solver/mcsolve.py               |  8 ++++---
 qutip/solver/multitraj.py             |  4 ++++
 qutip/solver/result.py                | 33 +++++++++++++++------------
 5 files changed, 45 insertions(+), 19 deletions(-)

diff --git a/doc/biblio.rst b/doc/biblio.rst
index b19a97ce94..248e492fa4 100644
--- a/doc/biblio.rst
+++ b/doc/biblio.rst
@@ -73,4 +73,7 @@ Bibliography
     N Khaneja et. al. *Optimal control of coupled spin dynamics: Design of NMR pulse sequences by gradient ascent algorithms.* J. Magn. Reson. **172**, 296–305 (2005). :doi:`10.1016/j.jmr.2004.11.004`
 
 .. [Donvil22]
-    B. Donvil, P. Muratore-Ginanneschi, *Quantum trajectory framework for general time-local master equations*, Nat Commun **13**, 4140 (2022). :doi:`10.1038/s41467-022-31533-8`.
\ No newline at end of file
+    B. Donvil, P. Muratore-Ginanneschi, *Quantum trajectory framework for general time-local master equations*, Nat Commun **13**, 4140 (2022). :doi:`10.1038/s41467-022-31533-8`.
+
+.. [Abd19]
+    M. Abdelhafez, D. I. Schuster, J. Koch, *Gradient-based optimal control of open quantum systems using quantumtrajectories and automatic differentiation*, Phys. Rev. A **99**, 052327 (2019). :doi:`10.1103/PhysRevA.99.052327`.
\ No newline at end of file
diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index a2989b4835..e5112e0773 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -148,6 +148,20 @@ Now, the Monte Carlo solver will calculate expectation values for both operators
 
 
 
+Using the Improved Sampling Algorithm
+-------------------------------------
+
+Oftentimes, quantum jumps are rare. This is especially true in the context of simulating gates
+for quantum information purposes, where typical gate times are orders of magnitude smaller than
+typical timescales for decoherence. In this case, using the standard monte-carlo sampling algorithm,
+we often repeatedly sample the no-jump trajectory. We can thus reduce the number of required runs
+by only sampling the no-jump trajectory once. We then extract the no-jump probability :math:`p`,
+and for all future runs we only sample random numbers :math:`r_1` where :math:`r_1>p`, thus ensuring
+that a jump will occur. When it comes time to compute expectation values, we weight the no-jump
+trajectory by :math:`p` and the jump trajectories by :math:`1-p`. This algorithm is described
+in [Abd19]_.
+
+
 .. _monte-reuse:
 
 Reusing Hamiltonian Data
diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index b70148fe01..ac1d5dfae2 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -564,6 +564,11 @@ def avail_integrators(cls):
 
 
 class MCSolverImprovedSampling(MultiTrajSolverImprovedSampling, MCSolver):
+    r"""
+    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
+    given Hamiltonian and sets of collapse operators using the improved
+    sampling algorithm. See MCSolver for further details and documentation
+    """
     name = "mcsolve improved sampling"
     resultclass = McResultImprovedSampling
     trajectory_resultclass = McTrajectoryResult
@@ -575,9 +580,6 @@ def __init__(self, H, c_ops, *, options=None):
     def _run_one_traj(
         self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
     ):
-        """
-        See the overridden function for additional details.
-        """
         seed, result = super()._run_one_traj(
             seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor
         )
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index ecab21e703..d1e38e1a60 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -296,6 +296,10 @@ def avail_integrators(cls):
 
 
 class MultiTrajSolverImprovedSampling(MultiTrajSolver):
+    """
+    Class for multi-trajectory evolutions using the improved sampling algorithm.
+    See docstring for MultiTrajSolver for further documentation
+    """
     name = "multi trajectory efficient"
     resultclass = MultiTrajResultImprovedSampling
     trajectory_resultclass = Result
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 206b55e5ad..b0400cf3b6 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -859,6 +859,12 @@ def __add__(self, other):
 
 
 class MultiTrajResultImprovedSampling(MultiTrajResult):
+    """
+    See docstring for MultiTrajResult for all relevant documentation.
+    This child class computes expectation values and sums of states, etc
+    using the improved sampling algorithm, which samples the no-jump trajectory
+    first and then only samples jump trajectories afterwards.
+    """
     def __init__(self, e_ops, options, **kw):
         super().__init__(e_ops, options, **kw)
         self._sum_expect_no_jump = None
@@ -904,10 +910,6 @@ def _average_computer(self):
         return avg, avg2
 
     def _add_first_traj(self, trajectory):
-        """
-        Read the first trajectory, intitializing needed data.
-        """
-
         super()._add_first_traj(trajectory)
         if trajectory.states:
             del self._sum_states
@@ -922,34 +924,35 @@ def _add_first_traj(self, trajectory):
             del self._sum_final_states
             self._sum_final_states_no_jump = qzero_like(self._to_dm(state))
             self._sum_final_states_jump = qzero_like(self._to_dm(state))
-        self._sum_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
-        self._sum2_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
         self._sum_expect_no_jump = [
             np.zeros_like(expect) for expect in trajectory.expect
         ]
         self._sum2_expect_no_jump = [
             np.zeros_like(expect) for expect in trajectory.expect
         ]
+        self._sum_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
+        self._sum2_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
         del self._sum_expect
         del self._sum2_expect
 
     def _reduce_expect(self, trajectory, no_jump=False):
         """
-        Compute the average of the expectation values and store it in it's
-        multiple formats for the no-jump trajectory
+        Compute the average of the expectation values appropriately
+        weighting the jump and no-jump trajectories
         """
         for i, k in enumerate(self._raw_ops):
             expect_traj = trajectory.expect[i]
-
+            p = self.no_jump_prob
             if no_jump:
-                self._sum_expect_no_jump[i] += expect_traj * self.no_jump_prob
-                self._sum2_expect_no_jump[i] += expect_traj**2 * self.no_jump_prob
-                # no jump trajectory will always be the first one
+                self._sum_expect_no_jump[i] += expect_traj * p
+                self._sum2_expect_no_jump[i] += expect_traj**2 * p
+                # no jump trajectory will always be the first one, no need
+                # to worry about including jump trajectories
                 avg = self._sum_expect_no_jump[i]
                 avg2 = self._sum2_expect_no_jump[i]
             else:
-                self._sum_expect_jump[i] += expect_traj * (1 - self.no_jump_prob)
-                self._sum2_expect_jump[i] += expect_traj**2 * (1 - self.no_jump_prob)
+                self._sum_expect_jump[i] += expect_traj * (1 - p)
+                self._sum2_expect_jump[i] += expect_traj**2 * (1 - p)
                 avg = self._sum_expect_no_jump[i] + self._sum_expect_jump[i] / (
                     self.num_trajectories - 1
                 )
@@ -980,7 +983,7 @@ def average_states(self):
     @property
     def average_final_state(self):
         """
-        Last states of each trajectories averaged into a density matrix.
+        Last states of each trajectory averaged into a density matrix.
         """
         if self._sum_final_states_no_jump is None:
             return None

From 1fff8043496d6e0ad66d25bad6efb8bba04c16d2 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 12:47:32 -0400
Subject: [PATCH 568/602] small additions to docs

---
 doc/guide/dynamics/dynamics-monte.rst | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index e5112e0773..7457aad744 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -159,7 +159,16 @@ by only sampling the no-jump trajectory once. We then extract the no-jump probab
 and for all future runs we only sample random numbers :math:`r_1` where :math:`r_1>p`, thus ensuring
 that a jump will occur. When it comes time to compute expectation values, we weight the no-jump
 trajectory by :math:`p` and the jump trajectories by :math:`1-p`. This algorithm is described
-in [Abd19]_.
+in [Abd19]_. This algorithm can be utilized by setting the flag ``improved_sampling=True`` in the call to
+``mcsolve``:
+
+.. plot::
+    :context: close-figs
+
+    data = mcsolve(H, psi0, times, [np.sqrt(0.1) * a], e_ops=[a.dag() * a, sm.dag() * sm], improved_sampling=True)
+
+where in this case the first run samples the no-jump trajectory, and the remaining 499 trajectories are all
+guaranteed to include (at least) one jump.
 
 
 .. _monte-reuse:

From f29d6b83c3f3a5f69f4607aed26dac6e0ab42f6b Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 12:56:42 -0400
Subject: [PATCH 569/602] added towncrier changelog

---
 doc/changes/2218.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2218.feature

diff --git a/doc/changes/2218.feature b/doc/changes/2218.feature
new file mode 100644
index 0000000000..f0c0268037
--- /dev/null
+++ b/doc/changes/2218.feature
@@ -0,0 +1 @@
+Improved sampling algorithm for mcsolve
\ No newline at end of file

From 8ea0c56f918c8032e6ba227d57eba69678fb2575 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 16:29:39 -0400
Subject: [PATCH 570/602] better parametrization of tests

---
 qutip/tests/solver/test_mcsolve.py | 31 ++++++++++++------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index 1be030d451..32ca173056 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -93,26 +93,20 @@ def pytest_generate_tests(self, metafunc):
     # runtimes shorter.  The known-good cases are still tested in the other
     # test cases, this is just testing the single-output behaviour.
 
-    def test_states_only(self, hamiltonian, args, c_ops, expected, tol):
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_states_only(self, hamiltonian, args, c_ops, expected, tol, improved_sampling):
         options = {"store_states": True, "map": "serial"}
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
-                         options=options)
-        result_improved_sampling = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
-                         options=options, improved_sampling=True)
+                         options=options, improved_sampling=improved_sampling)
         self._assert_states(result, expected, tol)
-        self._assert_states(result_improved_sampling, expected, tol)
 
-    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol, improved_sampling):
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options={'map': 'serial'})
-        result_improved_sampling = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options={'map': 'serial'}, improved_sampling=True)
+                         options={'map': 'serial'}, improved_sampling=improved_sampling)
         self._assert_expect(result, expected, tol)
-        self._assert_expect(result_improved_sampling, expected, tol)
 
 
 class TestConstantCollapse(StatesAndExpectOutputCase):
@@ -181,8 +175,8 @@ def test_stored_collapse_operators_and_times():
     assert all(col in [0, 1] for col in result.col_which[0])
 
 
-@pytest.mark.parametrize("keep_runs_results, improved_sampling",
-                         [(True, True), (True, False), (False, True), (False, False)])
+@pytest.mark.parametrize("improved_sampling", [True, False])
+@pytest.mark.parametrize("keep_runs_results", [True, False])
 def test_states_outputs(keep_runs_results, improved_sampling):
     # We're just testing the output value, so it's important whether certain
     # things are complex or real, but not what the magnitudes of constants are.
@@ -238,8 +232,8 @@ def test_states_outputs(keep_runs_results, improved_sampling):
     assert data.stats['end_condition'] == "ntraj reached"
 
 
-@pytest.mark.parametrize("keep_runs_results, improved_sampling",
-                         [(True, True), (True, False), (False, True), (False, False)])
+@pytest.mark.parametrize("improved_sampling", [True, False])
+@pytest.mark.parametrize("keep_runs_results", [True, False])
 def test_expectation_outputs(keep_runs_results, improved_sampling):
     # We're just testing the output value, so it's important whether certain
     # things are complex or real, but not what the magnitudes of constants are.
@@ -322,9 +316,8 @@ def test_seeds_are_not_reused_by_default(self, improved_sampling):
                        for first_w, second_w in zip(first.col_which,
                                                     second.col_which))
 
-    @pytest.mark.parametrize('seed, improved_sampling',
-                             [(1, True), (np.random.SeedSequence(2), False),
-                              (1, False), (np.random.SeedSequence(2), True)])
+    @pytest.mark.parametrize("seed", [1, np.random.SeedSequence(2)])
+    @pytest.mark.parametrize("improved_sampling", [True, False])
     def test_seed_type(self, seed, improved_sampling):
         args = (self.H, self.state, self.times)
         kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}

From be9a6e91bbbccca63253a0747e2e35ebf430ad5c Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 16:37:27 -0400
Subject: [PATCH 571/602] Revert "black"

This reverts commit f0347054
---
 qutip/solver/mcsolve.py   | 109 +++++++++++----------------
 qutip/solver/multitraj.py | 129 ++++++++++---------------------
 qutip/solver/result.py    | 154 ++++++++++++++++++++------------------
 3 files changed, 166 insertions(+), 226 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index ac1d5dfae2..0d15ba50da 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,4 +1,4 @@
-__all__ = ["mcsolve", "MCSolver"]
+__all__ = ['mcsolve', "MCSolver"]
 
 import numpy as np
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
@@ -10,21 +10,9 @@
 from time import time
 
 
-def mcsolve(
-    H,
-    state,
-    tlist,
-    c_ops=(),
-    e_ops=None,
-    ntraj=500,
-    *,
-    args=None,
-    options=None,
-    seeds=None,
-    target_tol=None,
-    timeout=None,
-    improved_sampling=False,
-):
+def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
+            args=None, options=None, seeds=None, target_tol=None, timeout=None,
+            improved_sampling=False):
     r"""
     Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
     given Hamiltonian and sets of collapse operators. Options for the
@@ -153,28 +141,25 @@ def mcsolve(
         if options is None:
             options = {}
         options = {
-            key: options[key] for key in options if key in MESolver.solver_options
+            key: options[key]
+            for key in options
+            if key in MESolver.solver_options
         }
-        return mesolve(H, state, tlist, e_ops=e_ops, args=args, options=options)
+        return mesolve(H, state, tlist, e_ops=e_ops, args=args,
+                       options=options)
 
     if isinstance(ntraj, (list, tuple)):
         raise TypeError(
-            "ntraj must be an integer. " "A list of numbers is not longer supported."
+            "ntraj must be an integer. "
+            "A list of numbers is not longer supported."
         )
     if not improved_sampling:
         mc = MCSolver(H, c_ops, options=options)
     else:
         mc = MCSolverImprovedSampling(H, c_ops, options=options)
 
-    result = mc.run(
-        state,
-        tlist=tlist,
-        ntraj=ntraj,
-        e_ops=e_ops,
-        seed=seeds,
-        target_tol=target_tol,
-        timeout=timeout,
-    )
+    result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
+                    seed=seeds, target_tol=target_tol, timeout=timeout)
     return result
 
 
@@ -182,7 +167,6 @@ class MCIntegrator:
     """
     Integrator like object for mcsolve trajectory.
     """
-
     name = "mcsolve"
 
     def __init__(self, integrator, c_ops, n_ops, options=None):
@@ -224,7 +208,7 @@ def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
             self.target_norm = 0.0
         else:
             self.target_norm = (
-                self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
+                    self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
             )
         self._integrator.set_state(t, state0)
         self._is_set = True
@@ -239,10 +223,11 @@ def integrate(self, t, copy=False):
             t_step, state = self._integrator.mcstep(t, copy=False)
             norm = self._prob_func(state)
             if norm <= self.target_norm:
-                t_col, state = self._find_collapse_time(norm_old, norm, t_old, t_step)
+                t_col, state = self._find_collapse_time(norm_old, norm,
+                                                        t_old, t_step)
                 self._do_collapse(t_col, state)
                 t_old, y_old = self._integrator.get_state(copy=False)
-                norm_old = 1.0
+                norm_old = 1.
             else:
                 t_old, y_old = t_step, state
                 norm_old = norm
@@ -259,7 +244,7 @@ def reset(self, hard=False):
     def _prob_func(self, state):
         if self.issuper:
             return _data.trace_oper_ket(state).real
-        return _data.norm.l2(state) ** 2
+        return _data.norm.l2(state)**2
 
     def _norm_func(self, state):
         if self.issuper:
@@ -269,27 +254,28 @@ def _norm_func(self, state):
     def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
         """Find the time of the collapse and state just before it."""
         tries = 0
-        while tries < self.options["norm_steps"]:
+        while tries < self.options['norm_steps']:
             tries += 1
-            if (t_final - t_prev) < self.options["norm_t_tol"]:
+            if (t_final - t_prev) < self.options['norm_t_tol']:
                 t_guess = t_final
                 _, state = self._integrator.get_state()
                 break
-            t_guess = t_prev + (
-                (t_final - t_prev)
-                * np.log(norm_old / self.target_norm)
-                / np.log(norm_old / norm)
+            t_guess = (
+                t_prev
+                + ((t_final - t_prev)
+                   * np.log(norm_old / self.target_norm)
+                   / np.log(norm_old / norm))
             )
-            if (t_guess - t_prev) < self.options["norm_t_tol"]:
-                t_guess = t_prev + self.options["norm_t_tol"]
+            if (t_guess - t_prev) < self.options['norm_t_tol']:
+                t_guess = t_prev + self.options['norm_t_tol']
             _, state = self._integrator.mcstep(t_guess, copy=False)
             norm2_guess = self._prob_func(state)
             if (
-                np.abs(self.target_norm - norm2_guess)
-                < self.options["norm_tol"] * self.target_norm
+                np.abs(self.target_norm - norm2_guess) <
+                self.options['norm_tol'] * self.target_norm
             ):
                 break
-            elif norm2_guess < self.target_norm:
+            elif (norm2_guess < self.target_norm):
                 # t_guess is still > t_jump
                 t_final = t_guess
                 norm = norm2_guess
@@ -298,12 +284,11 @@ def _find_collapse_time(self, norm_old, norm, t_prev, t_final):
                 t_prev = t_guess
                 norm_old = norm2_guess
 
-        if tries >= self.options["norm_steps"]:
+        if tries >= self.options['norm_steps']:
             raise RuntimeError(
                 "Could not find the collapse time within desired tolerance. "
                 "Increase accuracy of the ODE solver or lower the tolerance "
-                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'."
-            )
+                "with the options 'norm_steps', 'norm_tol', 'norm_t_tol'.")
 
         return t_guess, state
 
@@ -323,11 +308,12 @@ def _do_collapse(self, collapse_time, state):
             for i, n_op in enumerate(self._n_ops):
                 probs[i] = n_op.expect_data(collapse_time, state).real
             probs = np.cumsum(probs)
-            which = np.searchsorted(probs, probs[-1] * self._generator.random())
+            which = np.searchsorted(probs,
+                                    probs[-1] * self._generator.random())
 
         state_new = self._c_ops[which].matmul_data(collapse_time, state)
         new_norm = self._norm_func(state_new)
-        if new_norm < self.options["mc_corr_eps"]:
+        if new_norm < self.options['mc_corr_eps']:
             # This happen when the collapse is caused by numerical error
             state_new = _data.mul(state, 1 / self._norm_func(state))
         else:
@@ -430,8 +416,9 @@ def _restore_state(self, data, *, copy=True):
         """
         Retore the Qobj state from its data.
         """
-        if self._state_metadata["dims"] == self.rhs.dims[1]:
-            state = Qobj(unstack_columns(data), **self._state_metadata, copy=False)
+        if self._state_metadata['dims'] == self.rhs.dims[1]:
+            state = Qobj(unstack_columns(data),
+                         **self._state_metadata, copy=False)
         else:
             state = Qobj(data, **self._state_metadata, copy=copy)
 
@@ -439,13 +426,11 @@ def _restore_state(self, data, *, copy=True):
 
     def _initialize_stats(self):
         stats = super()._initialize_stats()
-        stats.update(
-            {
-                "method": self.options["method"],
-                "solver": "Master Equation Evolution",
-                "num_collapse": self._num_collapse,
-            }
-        )
+        stats.update({
+            "method": self.options["method"],
+            "solver": "Master Equation Evolution",
+            "num_collapse": self._num_collapse,
+        })
         return stats
 
     def _argument(self, args):
@@ -456,9 +441,7 @@ def _argument(self, args):
         for n_op in self._n_ops:
             n_op.arguments(args)
 
-    def _run_one_traj(
-        self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
-    ):
+    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
@@ -466,9 +449,7 @@ def _run_one_traj(
         # multiprocessing, but will fail with multithreading.
         # If a thread base parallel map is created, eahc trajectory should use
         # a copy of the integrator.
-        seed, result = super()._run_one_traj(
-            seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor
-        )
+        seed, result = super()._run_one_traj(seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
         result.collapse = self._integrator.collapses
         return seed, result
 
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index d1e38e1a60..4f692b950f 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -26,7 +26,6 @@ class MultiTrajSolver(Solver):
     options : dict
         Options for the solver.
     """
-
     name = "generic multi trajectory"
     resultclass = MultiTrajResult
     trajectory_resultclass = Result
@@ -103,47 +102,30 @@ def step(self, t, *, args=None, copy=True):
         _, state = self._integrator.integrate(t, copy=False)
         return self._restore_state(state, copy=copy)
 
-    def _initialize_run(
-        self,
-        state,
-        ntraj=1,
-        *,
-        args=None,
-        e_ops=(),
-        timeout=None,
-        target_tol=None,
-        seed=None
-    ):
+    def _initialize_run(self, state, ntraj=1, *,
+                        args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
         start_time = time()
         self._argument(args)
         stats = self._initialize_stats()
         seeds = self._read_seed(seed, ntraj)
 
-        result = self.resultclass(e_ops, self.options, solver=self.name, stats=stats)
+        result = self.resultclass(
+            e_ops, self.options, solver=self.name, stats=stats
+        )
         result.add_end_condition(ntraj, target_tol)
 
-        map_func = _get_map[self.options["map"]]
+        map_func = _get_map[self.options['map']]
         map_kw = {
-            "timeout": timeout,
-            "job_timeout": self.options["job_timeout"],
-            "num_cpus": self.options["num_cpus"],
+            'timeout': timeout,
+            'job_timeout': self.options['job_timeout'],
+            'num_cpus': self.options['num_cpus'],
         }
         state0 = self._prepare_state(state)
-        stats["preparation time"] += time() - start_time
+        stats['preparation time'] += time() - start_time
         return stats, seeds, result, map_func, map_kw, state0
 
-    def run(
-        self,
-        state,
-        tlist,
-        ntraj=1,
-        *,
-        args=None,
-        e_ops=(),
-        timeout=None,
-        target_tol=None,
-        seed=None
-    ):
+    def run(self, state, tlist, ntraj=1, *,
+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
         """
         Do the evolution of the Quantum system.
 
@@ -203,39 +185,27 @@ def run(
             The simulation will end when the first end condition is reached
             between ``ntraj``, ``timeout`` and ``target_tol``.
         """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
-            state,
-            ntraj,
-            args=args,
-            e_ops=e_ops,
-            timeout=timeout,
-            target_tol=target_tol,
-            seed=seed,
-        )
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
+                                                                              args=args, e_ops=e_ops, timeout=timeout,
+                                                                              target_tol=target_tol, seed=seed)
         start_time = time()
         map_func(
-            self._run_one_traj,
-            seeds,
+            self._run_one_traj, seeds,
             (state0, tlist, e_ops),
-            reduce_func=result.add,
-            map_kw=map_kw,
+            reduce_func=result.add, map_kw=map_kw,
             progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"],
+            progress_bar_kwargs=self.options["progress_kwargs"]
         )
-        result.stats["run time"] = time() - start_time
+        result.stats['run time'] = time() - start_time
         return result
 
-    def _run_one_traj(
-        self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
-    ):
+    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
         result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
-        self._integrator.set_state(
-            tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor
-        )
+        self._integrator.set_state(tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
         result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
@@ -255,11 +225,8 @@ def _read_seed(self, seed, ntraj):
             seeds = np.random.SeedSequence(seed).spawn(ntraj)
         elif len(seed) >= ntraj:
             seeds = [
-                seed_
-                if (
-                    isinstance(seed_, np.random.SeedSequence)
-                    or hasattr(seed_, "random")
-                )
+                seed_ if (isinstance(seed_, np.random.SeedSequence)
+                          or hasattr(seed_, 'random'))
                 else np.random.SeedSequence(seed_)
                 for seed_ in seed[:ntraj]
             ]
@@ -278,13 +245,13 @@ def _get_generator(self, seed):
         If the ``seed`` has a ``random`` method, it will be used as the
         generator.
         """
-        if hasattr(seed, "random"):
+        if hasattr(seed, 'random'):
             # We check for the method, not the type to accept pseudo non-random
             # generator for debug/testing purpose.
             return seed
 
-        if self.options["bitgenerator"]:
-            bit_gen = getattr(np.random, self.options["bitgenerator"])
+        if self.options['bitgenerator']:
+            bit_gen = getattr(np.random, self.options['bitgenerator'])
             generator = np.random.Generator(bit_gen(seed))
         else:
             generator = np.random.default_rng(seed)
@@ -307,56 +274,36 @@ class MultiTrajSolverImprovedSampling(MultiTrajSolver):
     def __init__(self, rhs, *, options=None):
         super().__init__(rhs, options=options)
 
-    def run(
-        self,
-        state,
-        tlist,
-        ntraj=1,
-        *,
-        args=None,
-        e_ops=(),
-        timeout=None,
-        target_tol=None,
-        seed=None
-    ):
+    def run(self, state, tlist, ntraj=1, *,
+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
         """
         Do the evolution of the Quantum system.
         See the overridden method for further details. The modification here is to sample
         the no-jump trajectory first. Then, the no-jump probability is used as a lower-bound
         for random numbers in future monte carlo runs
         """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
-            state,
-            ntraj,
-            args=args,
-            e_ops=e_ops,
-            timeout=timeout,
-            target_tol=target_tol,
-            seed=seed,
-        )
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
+                                                                              args=args, e_ops=e_ops, timeout=timeout,
+                                                                              target_tol=target_tol, seed=seed)
         # first run the no-jump trajectory
         start_time = time()
-        seed0, no_jump_result = self._run_one_traj(
-            seeds[0], state0, tlist, e_ops, no_jump=True
-        )
+        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist, e_ops, no_jump=True)
         _, state, _ = self._integrator.get_state(copy=False)
         no_jump_prob = self._integrator._prob_func(state)
         result.no_jump_prob = no_jump_prob
         result.add((seed0, no_jump_result), no_jump=True)
-        result.stats["no jump run time"] = time() - start_time
+        result.stats['no jump run time'] = time() - start_time
 
         # run the remaining trajectories with the random number floor set to the
         # no jump probability such that we only sample trajectories with jumps
         start_time = time()
         # implied here that no_jump=False for result.add
         map_func(
-            self._run_one_traj,
-            seeds[1:],
+            self._run_one_traj, seeds[1:],
             (state0, tlist, e_ops, False, no_jump_prob),
-            reduce_func=result.add,
-            map_kw=map_kw,
+            reduce_func=result.add, map_kw=map_kw,
             progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"],
+            progress_bar_kwargs=self.options["progress_kwargs"]
         )
-        result.stats["run time"] = time() - start_time
-        return result
+        result.stats['run time'] = time() - start_time
+        return result
\ No newline at end of file
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index b0400cf3b6..007216a7e7 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -15,7 +15,6 @@ class _QobjExpectEop:
     op : :obj:`~Qobj`
         The expectation value operator.
     """
-
     def __init__(self, op):
         self.op = op
 
@@ -46,7 +45,6 @@ class ExpectOp:
     op : object
         The original object used to define the e_op operation.
     """
-
     def __init__(self, op, f, append):
         self.op = op
         self._f = f
@@ -71,7 +69,6 @@ class _BaseResult:
     """
     Common method for all ``Result``.
     """
-
     def __init__(self, options, *, solver=None, stats=None):
         self.solver = solver
         if stats is None:
@@ -84,7 +81,7 @@ def __init__(self, options, *, solver=None, stats=None):
         self.options = options
 
     def _e_ops_to_dict(self, e_ops):
-        """Convert the supplied e_ops to a dictionary of Eop instances."""
+        """ Convert the supplied e_ops to a dictionary of Eop instances. """
         if e_ops is None:
             e_ops = {}
         elif isinstance(e_ops, (list, tuple)):
@@ -197,7 +194,6 @@ class Result(_BaseResult):
     options : dict
         The options for this result class.
     """
-
     def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
         super().__init__(options, solver=solver, stats=stats)
         raw_ops = self._e_ops_to_dict(e_ops)
@@ -242,8 +238,8 @@ def _post_init(self):
         Sub-class ``.post_init()`` implementation may take additional keyword
         arguments if required.
         """
-        store_states = self.options["store_states"]
-        store_final_state = self.options["store_final_state"]
+        store_states = self.options['store_states']
+        store_final_state = self.options['store_final_state']
 
         if store_states is None:
             store_states = len(self.e_ops) == 0
@@ -254,17 +250,17 @@ def _post_init(self):
             self.add_processor(self._store_final_state, requires_copy=True)
 
     def _store_state(self, t, state):
-        """Processor that stores a state in ``.states``."""
+        """ Processor that stores a state in ``.states``. """
         self.states.append(state)
 
     def _store_final_state(self, t, state):
-        """Processor that writes the state to ``.final_state``."""
+        """ Processor that writes the state to ``.final_state``. """
         self.final_state = state
 
     def _pre_copy(self, state):
-        """Return a copy of the state. Sub-classes may override this to
-        copy a state in different manner or to skip making a copy
-        altogether if a copy is not necessary.
+        """ Return a copy of the state. Sub-classes may override this to
+            copy a state in different manner or to skip making a copy
+            altogether if a copy is not necessary.
         """
         return state.copy()
 
@@ -310,7 +306,10 @@ def __repr__(self):
         ]
         if self.stats:
             lines.append("  Solver stats:")
-            lines.extend(f"    {k}: {v!r}" for k, v in self.stats.items())
+            lines.extend(
+                f"    {k}: {v!r}"
+                for k, v in self.stats.items()
+            )
         if self.times:
             lines.append(
                 f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
@@ -451,7 +450,6 @@ class MultiTrajResult(_BaseResult):
     options : :obj:`~SolverResultsOptions`
         The options for this result class.
     """
-
     def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
         super().__init__(options, solver=solver, stats=stats)
         self._raw_ops = self._e_ops_to_dict(e_ops)
@@ -476,7 +474,7 @@ def __init__(self, e_ops, options, *, solver=None, stats=None, **kw):
 
     @staticmethod
     def _to_dm(state):
-        if state.type == "ket":
+        if state.type == 'ket':
             state = state.proj()
         return state
 
@@ -487,24 +485,28 @@ def _add_first_traj(self, trajectory):
         self.times = trajectory.times
 
         if trajectory.states:
-            self._sum_states = [
-                qzero_like(self._to_dm(state)) for state in trajectory.states
-            ]
+            self._sum_states = [qzero_like(self._to_dm(state))
+                                for state in trajectory.states]
         if trajectory.final_state:
             state = trajectory.final_state
             self._sum_final_states = qzero_like(self._to_dm(state))
 
-        self._sum_expect = [np.zeros_like(expect) for expect in trajectory.expect]
-        self._sum2_expect = [np.zeros_like(expect) for expect in trajectory.expect]
+        self._sum_expect = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum2_expect = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
 
         self.e_ops = trajectory.e_ops
 
         self.average_e_data = {
             k: list(avg_expect)
-            for k, avg_expect in zip(self._raw_ops, self._sum_expect)
+            for k, avg_expect
+            in zip(self._raw_ops, self._sum_expect)
         }
         self.e_data = self.average_e_data
-        if self.options["keep_runs_results"]:
+        if self.options['keep_runs_results']:
             self.runs_e_data = {k: [] for k in self._raw_ops}
             self.e_data = self.runs_e_data
 
@@ -514,7 +516,8 @@ def _store_trajectory(self, trajectory):
     def _reduce_states(self, trajectory):
         self._sum_states = [
             accu + self._to_dm(state)
-            for accu, state in zip(self._sum_states, trajectory.states)
+            for accu, state
+            in zip(self._sum_states, trajectory.states)
         ]
 
     def _reduce_final_state(self, trajectory):
@@ -561,7 +564,7 @@ def _fixed_end(self):
         """
         ntraj_left = self._target_ntraj - self.num_trajectories
         if ntraj_left == 0:
-            self.stats["end_condition"] = "ntraj reached"
+            self.stats['end_condition'] = 'ntraj reached'
         return ntraj_left
 
     def _average_computer(self):
@@ -578,23 +581,25 @@ def _target_tolerance_end(self):
         if self.num_trajectories <= 1:
             return np.inf
         avg, avg2 = self._average_computer()
-        target = np.array(
-            [atol + rtol * mean for mean, (atol, rtol) in zip(avg, self._target_tols)]
-        )
+        target = np.array([
+            atol + rtol * mean
+            for mean, (atol, rtol)
+            in zip(avg, self._target_tols)
+        ])
         target_ntraj = np.max((avg2 - abs(avg) ** 2) / target**2 + 1)
 
         self._estimated_ntraj = min(target_ntraj, self._target_ntraj)
         if (self._estimated_ntraj - self.num_trajectories) <= 0:
-            self.stats["end_condition"] = "target tolerance reached"
+            self.stats['end_condition'] = 'target tolerance reached'
         return self._estimated_ntraj - self.num_trajectories
 
     def _post_init(self):
         self.num_trajectories = 0
         self._target_ntraj = None
 
-        store_states = self.options["store_states"]
-        store_final_state = self.options["store_final_state"]
-        store_traj = self.options["keep_runs_results"]
+        store_states = self.options['store_states']
+        store_final_state = self.options['store_final_state']
+        store_traj = self.options['keep_runs_results']
 
         self.add_processor(self._increment_traj)
         if store_traj:
@@ -609,7 +614,7 @@ def _post_init(self):
             self.add_processor(self._reduce_expect)
 
         self._early_finish_check = self._no_end
-        self.stats["end_condition"] = "unknown"
+        self.stats['end_condition'] = 'unknown'
 
     def add(self, trajectory_info):
         """
@@ -665,7 +670,7 @@ def add_end_condition(self, ntraj, target_tol=None):
             Error estimation is done with jackknife resampling.
         """
         self._target_ntraj = ntraj
-        self.stats["end_condition"] = "timeout"
+        self.stats['end_condition'] = 'timeout'
 
         if target_tol is None:
             self._early_finish_check = self._fixed_end
@@ -680,16 +685,14 @@ def add_end_condition(self, ntraj, target_tol=None):
 
         targets = np.array(target_tol)
         if targets.ndim == 0:
-            self._target_tols = np.array([(target_tol, 0.0)] * num_e_ops)
+            self._target_tols = np.array([(target_tol, 0.)] * num_e_ops)
         elif targets.shape == (2,):
             self._target_tols = np.ones((num_e_ops, 2)) * targets
         elif targets.shape == (num_e_ops, 2):
             self._target_tols = targets
         else:
-            raise ValueError(
-                "target_tol must be a number, a pair of (atol, "
-                "rtol) or a list of (atol, rtol) for each e_ops"
-            )
+            raise ValueError("target_tol must be a number, a pair of (atol, "
+                             "rtol) or a list of (atol, rtol) for each e_ops")
 
         self._early_finish_check = self._target_tolerance_end
 
@@ -787,7 +790,10 @@ def __repr__(self):
         ]
         if self.stats:
             lines.append("  Solver stats:")
-            lines.extend(f"    {k}: {v!r}" for k, v in self.stats.items())
+            lines.extend(
+                f"    {k}: {v!r}"
+                for k, v in self.stats.items()
+            )
         if self.times:
             lines.append(
                 f"  Time interval: [{self.times[0]}, {self.times[-1]}]"
@@ -815,9 +821,8 @@ def __add__(self, other):
             raise ValueError("Shared `e_ops` is required to merge results")
         if self.times != other.times:
             raise ValueError("Shared `times` are is required to merge results")
-        new = self.__class__(
-            self._raw_ops, self.options, solver=self.solver, stats=self.stats
-        )
+        new = self.__class__(self._raw_ops, self.options,
+                             solver=self.solver, stats=self.stats)
         if self.trajectories and other.trajectories:
             new.trajectories = self.trajectories + other.trajectories
         new.num_trajectories = self.num_trajectories + other.num_trajectories
@@ -827,8 +832,13 @@ def __add__(self, other):
         if self._sum_states is not None and other._sum_states is not None:
             new._sum_states = self._sum_states + other._sum_states
 
-        if self._sum_final_states is not None and other._sum_final_states is not None:
-            new._sum_final_states = self._sum_final_states + other._sum_final_states
+        if (
+            self._sum_final_states is not None
+            and other._sum_final_states is not None
+        ):
+            new._sum_final_states = (
+                self._sum_final_states + other._sum_final_states
+            )
         new._target_tols = None
 
         new._sum_expect = []
@@ -838,7 +848,8 @@ def __add__(self, other):
 
         for i, k in enumerate(self._raw_ops):
             new._sum_expect.append(self._sum_expect[i] + other._sum_expect[i])
-            new._sum2_expect.append(self._sum2_expect[i] + other._sum2_expect[i])
+            new._sum2_expect.append(self._sum2_expect[i]
+                                    + other._sum2_expect[i])
 
             avg = new._sum_expect[i] / new.num_trajectories
             avg2 = new._sum2_expect[i] / new.num_trajectories
@@ -853,7 +864,7 @@ def __add__(self, other):
                 new.e_data = new.runs_e_data
 
         new.stats["run time"] += other.stats["run time"]
-        new.stats["end_condition"] = "Merged results"
+        new.stats['end_condition'] = "Merged results"
 
         return new
 
@@ -886,12 +897,14 @@ def _reduce_states(self, trajectory, no_jump=False):
         if no_jump:
             self._sum_states_no_jump = [
                 accu + self._to_dm(state)
-                for accu, state in zip(self._sum_states_no_jump, trajectory.states)
+                for accu, state
+                in zip(self._sum_states_no_jump, trajectory.states)
             ]
         else:
             self._sum_states_jump = [
                 accu + self._to_dm(state)
-                for accu, state in zip(self._sum_states_jump, trajectory.states)
+                for accu, state
+                in zip(self._sum_states_jump, trajectory.states)
             ]
 
     def _increment_traj(self, trajectory, no_jump=False):
@@ -913,17 +926,21 @@ def _add_first_traj(self, trajectory):
         super()._add_first_traj(trajectory)
         if trajectory.states:
             del self._sum_states
-            self._sum_states_no_jump = [
-                qzero_like(self._to_dm(state)) for state in trajectory.states
-            ]
-            self._sum_states_jump = [
-                qzero_like(self._to_dm(state)) for state in trajectory.states
-            ]
+            self._sum_states_no_jump = [qzero_like(self._to_dm(state))
+                                        for state in trajectory.states]
+            self._sum_states_jump = [qzero_like(self._to_dm(state))
+                                     for state in trajectory.states]
         if trajectory.final_state:
             state = trajectory.final_state
             del self._sum_final_states
             self._sum_final_states_no_jump = qzero_like(self._to_dm(state))
             self._sum_final_states_jump = qzero_like(self._to_dm(state))
+        self._sum_expect_jump = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
+        self._sum2_expect_jump = [
+            np.zeros_like(expect) for expect in trajectory.expect
+        ]
         self._sum_expect_no_jump = [
             np.zeros_like(expect) for expect in trajectory.expect
         ]
@@ -1012,7 +1029,8 @@ class McTrajectoryResult(Result):
     """
 
     def __init__(self, e_ops, options, *args, **kwargs):
-        super().__init__(e_ops, {**options, "normalize_output": False}, *args, **kwargs)
+        super().__init__(e_ops, {**options, "normalize_output": False},
+                         *args, **kwargs)
 
 
 class McResult(MultiTrajResult):
@@ -1052,7 +1070,6 @@ class McResult(MultiTrajResult):
         For each runs, a list of every collapse as a tuple of the time it
         happened and the corresponding ``c_ops`` index.
     """
-
     # Collapse are only produced by mcsolve.
 
     def _add_collapse(self, trajectory):
@@ -1072,7 +1089,7 @@ def col_times(self):
         out = []
         for col_ in self.collapse:
             col = list(zip(*col_))
-            col = [] if len(col) == 0 else col[0]
+            col = ([] if len(col) == 0 else col[0])
             out.append(col)
         return out
 
@@ -1084,7 +1101,7 @@ def col_which(self):
         out = []
         for col_ in self.collapse:
             col = list(zip(*col_))
-            col = [] if len(col) == 0 else col[1]
+            col = ([] if len(col) == 0 else col[1])
             out.append(col)
         return out
 
@@ -1115,22 +1132,17 @@ def runs_photocurrent(self):
             cols = [[] for _ in range(self.num_c_ops)]
             for t, which in collapses:
                 cols[which].append(t)
-            measurements.append(
-                [
-                    np.histogram(cols[i], tlist)[0] / np.diff(tlist)
-                    for i in range(self.num_c_ops)
-                ]
-            )
+            measurements.append([
+                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
+                for i in range(self.num_c_ops)
+            ])
         return measurements
 
 
 class McResultImprovedSampling(MultiTrajResultImprovedSampling, McResult):
     """McResult class using the MultiTrajResultImprovedSampling functionality"""
-
     def __init__(self, e_ops, options, **kw):
-        MultiTrajResultImprovedSampling.__init__(
-            self, e_ops=e_ops, options=options, **kw
-        )
+        MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops, options=options, **kw)
 
     def _add_collapse(self, trajectory, no_jump=False):
         super()._add_collapse(trajectory)
@@ -1225,15 +1237,15 @@ def _add_first_traj(self, trajectory):
     def _add_trace(self, trajectory):
         new_trace = np.array(trajectory.trace)
         self._sum_trace += new_trace
-        self._sum2_trace += np.abs(new_trace) ** 2
+        self._sum2_trace += np.abs(new_trace)**2
 
         avg = self._sum_trace / self.num_trajectories
         avg2 = self._sum2_trace / self.num_trajectories
 
         self.average_trace = avg
-        self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg) ** 2))
+        self.std_trace = np.sqrt(np.abs(avg2 - np.abs(avg)**2))
 
-        if self.options["keep_runs_results"]:
+        if self.options['keep_runs_results']:
             self.runs_trace.append(trajectory.trace)
 
     @property

From 3a43fd027f8f38e996bb75cdf8a8ecf170f429da Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Mon, 21 Aug 2023 17:37:39 -0400
Subject: [PATCH 572/602] eliminated unnecesary function in
 MCSolverImprovedSampling, more consistent line breaking (80), check for
 self.num_trajectories==1 instead of a no-jump flag since the no jump is
 always first

---
 qutip/solver/mcsolve.py   | 17 +++++-------
 qutip/solver/multitraj.py | 40 ++++++++++++++++++---------
 qutip/solver/result.py    | 57 +++++++++++++++++----------------------
 3 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 0d15ba50da..8342f66512 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -441,7 +441,8 @@ def _argument(self, args):
         for n_op in self._n_ops:
             n_op.arguments(args)
 
-    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
+    def _run_one_traj(self, seed, state, tlist, e_ops,
+                      no_jump=False, jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
@@ -449,7 +450,10 @@ def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floo
         # multiprocessing, but will fail with multithreading.
         # If a thread base parallel map is created, eahc trajectory should use
         # a copy of the integrator.
-        seed, result = super()._run_one_traj(seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
+        seed, result = super()._run_one_traj(
+            seed, state, tlist, e_ops,
+            no_jump=no_jump, jump_prob_floor=jump_prob_floor
+        )
         result.collapse = self._integrator.collapses
         return seed, result
 
@@ -557,12 +561,3 @@ class MCSolverImprovedSampling(MultiTrajSolverImprovedSampling, MCSolver):
 
     def __init__(self, H, c_ops, *, options=None):
         MCSolver.__init__(self, H, c_ops, options=options)
-
-    def _run_one_traj(
-        self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0
-    ):
-        seed, result = super()._run_one_traj(
-            seed, state, tlist, e_ops, no_jump=no_jump, jump_prob_floor=jump_prob_floor
-        )
-        result.collapse = self._integrator.collapses
-        return seed, result
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 4f692b950f..e78dc67660 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -102,8 +102,8 @@ def step(self, t, *, args=None, copy=True):
         _, state = self._integrator.integrate(t, copy=False)
         return self._restore_state(state, copy=copy)
 
-    def _initialize_run(self, state, ntraj=1, *,
-                        args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+    def _initialize_run(self, state, ntraj=1, args=None, e_ops=(),
+                        timeout=None, target_tol=None, seed=None):
         start_time = time()
         self._argument(args)
         stats = self._initialize_stats()
@@ -185,9 +185,15 @@ def run(self, state, tlist, ntraj=1, *,
             The simulation will end when the first end condition is reached
             between ``ntraj``, ``timeout`` and ``target_tol``.
         """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
-                                                                              args=args, e_ops=e_ops, timeout=timeout,
-                                                                              target_tol=target_tol, seed=seed)
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
+            state,
+            ntraj,
+            args=args,
+            e_ops=e_ops,
+            timeout=timeout,
+            target_tol=target_tol,
+            seed=seed,
+        )
         start_time = time()
         map_func(
             self._run_one_traj, seeds,
@@ -199,13 +205,15 @@ def run(self, state, tlist, ntraj=1, *,
         result.stats['run time'] = time() - start_time
         return result
 
-    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False, jump_prob_floor=0.0):
+    def _run_one_traj(self, seed, state, tlist, e_ops,
+                      no_jump=False, jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
         result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator, no_jump=no_jump, jump_prob_floor=jump_prob_floor)
+        self._integrator.set_state(tlist[0], state, generator,
+                                   no_jump=no_jump, jump_prob_floor=jump_prob_floor)
         result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
@@ -282,22 +290,28 @@ def run(self, state, tlist, ntraj=1, *,
         the no-jump trajectory first. Then, the no-jump probability is used as a lower-bound
         for random numbers in future monte carlo runs
         """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(state, ntraj,
-                                                                              args=args, e_ops=e_ops, timeout=timeout,
-                                                                              target_tol=target_tol, seed=seed)
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
+            state,
+            ntraj,
+            args=args,
+            e_ops=e_ops,
+            timeout=timeout,
+            target_tol=target_tol,
+            seed=seed,
+        )
         # first run the no-jump trajectory
         start_time = time()
-        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist, e_ops, no_jump=True)
+        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist,
+                                                   e_ops, no_jump=True)
         _, state, _ = self._integrator.get_state(copy=False)
         no_jump_prob = self._integrator._prob_func(state)
         result.no_jump_prob = no_jump_prob
-        result.add((seed0, no_jump_result), no_jump=True)
+        result.add((seed0, no_jump_result))
         result.stats['no jump run time'] = time() - start_time
 
         # run the remaining trajectories with the random number floor set to the
         # no jump probability such that we only sample trajectories with jumps
         start_time = time()
-        # implied here that no_jump=False for result.add
         map_func(
             self._run_one_traj, seeds[1:],
             (state0, tlist, e_ops, False, no_jump_prob),
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 007216a7e7..1934a46eb2 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -890,11 +890,8 @@ def __init__(self, e_ops, options, **kw):
 
         self.no_jump_prob = None
 
-    def _store_trajectory(self, trajectory, no_jump=False):
-        super()._store_trajectory(trajectory)
-
-    def _reduce_states(self, trajectory, no_jump=False):
-        if no_jump:
+    def _reduce_states(self, trajectory):
+        if self.num_trajectories == 1:
             self._sum_states_no_jump = [
                 accu + self._to_dm(state)
                 for accu, state
@@ -907,12 +904,9 @@ def _reduce_states(self, trajectory, no_jump=False):
                 in zip(self._sum_states_jump, trajectory.states)
             ]
 
-    def _increment_traj(self, trajectory, no_jump=False):
-        super()._increment_traj(trajectory)
-
-    def _reduce_final_state(self, trajectory, no_jump=False):
+    def _reduce_final_state(self, trajectory):
         dm_final_state = self._to_dm(trajectory.final_state)
-        if no_jump:
+        if self.num_trajectories == 1:
             self._sum_final_states_no_jump += dm_final_state
         else:
             self._sum_final_states_jump += dm_final_state
@@ -947,12 +941,14 @@ def _add_first_traj(self, trajectory):
         self._sum2_expect_no_jump = [
             np.zeros_like(expect) for expect in trajectory.expect
         ]
-        self._sum_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
-        self._sum2_expect_jump = [np.zeros_like(expect) for expect in trajectory.expect]
+        self._sum_expect_jump = [np.zeros_like(expect)
+                                 for expect in trajectory.expect]
+        self._sum2_expect_jump = [np.zeros_like(expect)
+                                  for expect in trajectory.expect]
         del self._sum_expect
         del self._sum2_expect
 
-    def _reduce_expect(self, trajectory, no_jump=False):
+    def _reduce_expect(self, trajectory):
         """
         Compute the average of the expectation values appropriately
         weighting the jump and no-jump trajectories
@@ -960,7 +956,7 @@ def _reduce_expect(self, trajectory, no_jump=False):
         for i, k in enumerate(self._raw_ops):
             expect_traj = trajectory.expect[i]
             p = self.no_jump_prob
-            if no_jump:
+            if self.num_trajectories == 1:
                 self._sum_expect_no_jump[i] += expect_traj * p
                 self._sum2_expect_no_jump[i] += expect_traj**2 * p
                 # no jump trajectory will always be the first one, no need
@@ -970,12 +966,12 @@ def _reduce_expect(self, trajectory, no_jump=False):
             else:
                 self._sum_expect_jump[i] += expect_traj * (1 - p)
                 self._sum2_expect_jump[i] += expect_traj**2 * (1 - p)
-                avg = self._sum_expect_no_jump[i] + self._sum_expect_jump[i] / (
-                    self.num_trajectories - 1
-                )
-                avg2 = self._sum2_expect_no_jump[i] + self._sum2_expect_jump[i] / (
-                    self.num_trajectories - 1
-                )
+                avg = (self._sum_expect_no_jump[i]
+                       + self._sum_expect_jump[i]
+                       / (self.num_trajectories - 1))
+                avg2 = (self._sum2_expect_no_jump[i]
+                        + self._sum2_expect_jump[i]
+                        / (self.num_trajectories - 1))
 
             self.average_e_data[k] = list(avg)
 
@@ -994,8 +990,10 @@ def average_states(self):
         if self._sum_states_no_jump is None:
             return None
         p = self.no_jump_prob
-        return [p * final_no_jump + (1 - p) * final_jump / (self.num_trajectories - 1)
-                for final_no_jump, final_jump in zip(self._sum_states_no_jump, self._sum_states_jump)]
+        return [p * final_no_jump
+                + (1 - p) * final_jump / (self.num_trajectories - 1)
+                for final_no_jump, final_jump in
+                zip(self._sum_states_no_jump, self._sum_states_jump)]
 
     @property
     def average_final_state(self):
@@ -1007,18 +1005,10 @@ def average_final_state(self):
         p = self.no_jump_prob
         return (
             p * self._sum_final_states_no_jump
-            + (1 - p) * self._sum_final_states_jump / (self.num_trajectories - 1)
+            + (1 - p) * self._sum_final_states_jump
+            / (self.num_trajectories - 1)
         )
 
-    def add(self, trajectory_info, no_jump=False):
-        seed, trajectory = trajectory_info
-        self.seeds.append(seed)
-
-        for op in self._state_processors:
-            op(trajectory, no_jump)
-
-        return self._early_finish_check()
-
     def __add__(self, other):
         raise NotImplemented
 
@@ -1142,7 +1132,8 @@ def runs_photocurrent(self):
 class McResultImprovedSampling(MultiTrajResultImprovedSampling, McResult):
     """McResult class using the MultiTrajResultImprovedSampling functionality"""
     def __init__(self, e_ops, options, **kw):
-        MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops, options=options, **kw)
+        MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops,
+                                                 options=options, **kw)
 
     def _add_collapse(self, trajectory, no_jump=False):
         super()._add_collapse(trajectory)

From 63821f67ed199880f45780eb584def7cd95660cb Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 22 Aug 2023 18:12:18 +0900
Subject: [PATCH 573/602] sort args of sphereplot

---
 qutip/animation.py                | 10 +++++-----
 qutip/tests/test_animation.py     |  2 +-
 qutip/tests/test_visualization.py | 20 +++++---------------
 qutip/visualization.py            |  8 ++++----
 4 files changed, 15 insertions(+), 25 deletions(-)

diff --git a/qutip/animation.py b/qutip/animation.py
index 384efb61ea..326d73ea59 100644
--- a/qutip/animation.py
+++ b/qutip/animation.py
@@ -134,21 +134,21 @@ def anim_hinton(rhos, x_basis=None, y_basis=None, color_style="scaled",
     return fig, ani
 
 
-def anim_sphereplot(theta, phi, V, *, cmap=None,
+def anim_sphereplot(V, theta, phi, *, cmap=None,
                     colorbar=True, fig=None, ax=None):
     """animation of a matrices of values on a sphere
 
     Parameters
     ----------
+    V : list of array instances
+        Data set to be plotted
+
     theta : float
         Angle with respect to z-axis. Its range is between 0 and pi
 
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    V : list of array instances
-        Data set to be plotted
-
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 
@@ -168,7 +168,7 @@ def anim_sphereplot(theta, phi, V, *, cmap=None,
         used to produce the figure.
     """
 
-    fig, ani = sphereplot(theta, phi, V, cmap=cmap,
+    fig, ani = sphereplot(V, theta, phi, cmap=cmap,
                           colorbar=colorbar, fig=fig, ax=ax)
 
     return fig, ani
diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
index 1545def440..533bc9d3e9 100644
--- a/qutip/tests/test_animation.py
+++ b/qutip/tests/test_animation.py
@@ -56,7 +56,7 @@ def test_anim_sphereplot():
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
     values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
-    fig, ani = qutip.anim_sphereplot(theta, phi, [values]*2)
+    fig, ani = qutip.anim_sphereplot([values]*2, theta, phi)
     plt.close()
 
     assert isinstance(fig, mpl.figure.Figure)
diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 92962472f2..248c146b04 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -35,9 +35,8 @@ def test_sequential():
     qutip.settings.colorblind_safe = True
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
-
-    fig, ax = qutip.sphereplot(theta, phi,
-                               qutip.orbital(theta, phi, qutip.basis(3, 0)).T)
+    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    fig, ax = qutip.sphereplot(values, theta, phi)
     plt.close()
 
     qutip.settings.colorblind_safe = False
@@ -200,10 +199,8 @@ def test_hinton_ValueError1(transform, args, error_message):
 def test_sphereplot(args):
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
-
-    fig, ax = qutip.sphereplot(theta, phi,
-                               qutip.orbital(theta, phi, qutip.basis(3, 0)).T,
-                               **args)
+    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    fig, ax = qutip.sphereplot(values, theta, phi, **args)
     plt.close()
 
     assert isinstance(fig, mpl.figure.Figure)
@@ -214,7 +211,7 @@ def test_sphereplot_anim():
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
     values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
-    fig, ani = qutip.sphereplot(theta, phi, [values]*2)
+    fig, ani = qutip.sphereplot([values]*2, theta, phi)
     plt.close()
 
     assert isinstance(fig, mpl.figure.Figure)
@@ -340,7 +337,6 @@ def test_matrix_histogram_anim():
       "invalid key(s) found in options: e2, e1")),
 ])
 def test_matrix_histogram_ValueError(args, expected):
-    text = "options must be a dictionary"
 
     with pytest.raises(ValueError) as exc_info:
         fig, ax = qutip.matrix_histogram(qutip.rand_dm(5),
@@ -486,10 +482,8 @@ def test_plot_expectation_values(n_of_results, n_of_e_ops, one_axes, args):
 ])
 def test_plot_spin_distribution(color, args):
     j = 5
-    psi = qutip.spin_state(j, -j)
     psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
                               np.random.rand() * 2 * np.pi)
-    rho = qutip.ket2dm(psi)
     theta = np.linspace(0, np.pi, 50)
     phi = np.linspace(0, 2 * np.pi, 50)
     Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
@@ -509,10 +503,8 @@ def test_plot_spin_distribution(color, args):
 )
 def test_plot_spin_distribution_anim():
     j = 5
-    psi = qutip.spin_state(j, -j)
     psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
                               np.random.rand() * 2 * np.pi)
-    rho = qutip.ket2dm(psi)
     theta = np.linspace(0, np.pi, 50)
     phi = np.linspace(0, 2 * np.pi, 50)
     Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
@@ -527,10 +519,8 @@ def test_plot_spin_distribution_anim():
 def test_plot_spin_distribution_ValueError():
     text = "Unexpected value of projection keyword argument"
     j = 5
-    psi = qutip.spin_state(j, -j)
     psi = qutip.spin_coherent(j, np.random.rand() * np.pi,
                               np.random.rand() * 2 * np.pi)
-    rho = qutip.ket2dm(psi)
     theta = np.linspace(0, np.pi, 50)
     phi = np.linspace(0, 2 * np.pi, 50)
     Q, THETA, PHI = qutip.spin_q_function(psi, theta, phi)
diff --git a/qutip/visualization.py b/qutip/visualization.py
index 6797baeded..32cb6e401c 100644
--- a/qutip/visualization.py
+++ b/qutip/visualization.py
@@ -484,21 +484,21 @@ def color_fn(w):
     return fig, output
 
 
-def sphereplot(theta, phi, values, *,
+def sphereplot(values, theta, phi, *,
                cmap=None, colorbar=True, fig=None, ax=None):
     """Plots a matrix of values on a sphere
 
     Parameters
     ----------
+    values : array
+        Data set to be plotted
+
     theta : float
         Angle with respect to z-axis. Its range is between 0 and pi
 
     phi : float
         Angle in x-y plane. Its range is between 0 and 2*pi
 
-    values : array
-        Data set to be plotted
-
     cmap : a matplotlib colormap instance, optional
         Color map to use when plotting.
 

From de289aa95535406656916ed978eb1db775c1b62d Mon Sep 17 00:00:00 2001
From: tamakoshi2001 <tamakosiy@gmail.com>
Date: Tue, 22 Aug 2023 18:21:01 +0900
Subject: [PATCH 574/602] add doc

---
 doc/changes/2219.misc | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2219.misc

diff --git a/doc/changes/2219.misc b/doc/changes/2219.misc
new file mode 100644
index 0000000000..8c2fed6938
--- /dev/null
+++ b/doc/changes/2219.misc
@@ -0,0 +1 @@
+sort args of sphereplot and looks similar to those of plot_spin_distribution

From 9dc74d08bbc628567bbf1859e3ca8c3e610f4fba Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Wed, 23 Aug 2023 10:28:41 -0400
Subject: [PATCH 575/602] added public classes to __all__, ensured compliance
 with pycodestyle

---
 qutip/solver/mcsolve.py   | 17 ++++++++++-------
 qutip/solver/multitraj.py | 23 +++++++++++++----------
 qutip/solver/result.py    |  5 +++--
 3 files changed, 26 insertions(+), 19 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 8342f66512..83b509d520 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,4 +1,4 @@
-__all__ = ['mcsolve', "MCSolver"]
+__all__ = ['mcsolve', "MCSolver", "MCSolverImprovedSampling"]
 
 import numpy as np
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
@@ -179,7 +179,8 @@ def __init__(self, integrator, c_ops, n_ops, options=None):
         self._is_set = False
         self.issuper = c_ops[0].issuper
 
-    def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
+    def set_state(self, t, state0, generator,
+                  no_jump=False, jump_prob_floor=0.0):
         """
         Set the state of the ODE solver.
 
@@ -195,12 +196,13 @@ def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
             Random number generator.
 
         no_jump: Bool
-            whether or not to sample the no-jump trajectory. If so, the "random number"
-            should be set to zero
+            whether or not to sample the no-jump trajectory.
+            If so, the "random number" should be set to zero
 
         jump_prob_floor: float
-            if no_jump == False, this is set to the no-jump probability. This setting
-            ensures that we sample a trajectory with jumps
+            if no_jump == False, this is set to the no-jump
+            probability. This setting ensures that we sample
+            a trajectory with jumps
         """
         self.collapses = []
         self._generator = generator
@@ -208,7 +210,8 @@ def set_state(self, t, state0, generator, no_jump=False, jump_prob_floor=0.0):
             self.target_norm = 0.0
         else:
             self.target_norm = (
-                    self._generator.random() * (1 - jump_prob_floor) + jump_prob_floor
+                    self._generator.random() * (1 - jump_prob_floor)
+                    + jump_prob_floor
             )
         self._integrator.set_state(t, state0)
         self._is_set = True
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index e78dc67660..8ce23bd243 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -4,7 +4,7 @@
 from .solver_base import Solver
 import numpy as np
 
-__all__ = ["MultiTrajSolver"]
+__all__ = ["MultiTrajSolver", "MultiTrajSolverImprovedSampling"]
 
 
 class MultiTrajSolver(Solver):
@@ -213,7 +213,8 @@ def _run_one_traj(self, seed, state, tlist, e_ops,
         result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
         self._integrator.set_state(tlist[0], state, generator,
-                                   no_jump=no_jump, jump_prob_floor=jump_prob_floor)
+                                   no_jump=no_jump,
+                                   jump_prob_floor=jump_prob_floor)
         result.add(tlist[0], self._restore_state(state, copy=False))
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
@@ -272,8 +273,8 @@ def avail_integrators(cls):
 
 class MultiTrajSolverImprovedSampling(MultiTrajSolver):
     """
-    Class for multi-trajectory evolutions using the improved sampling algorithm.
-    See docstring for MultiTrajSolver for further documentation
+    Class for multi-trajectory evolutions using the improved sampling
+    algorithm. See docstring for MultiTrajSolver for further documentation
     """
     name = "multi trajectory efficient"
     resultclass = MultiTrajResultImprovedSampling
@@ -286,9 +287,10 @@ def run(self, state, tlist, ntraj=1, *,
             args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
         """
         Do the evolution of the Quantum system.
-        See the overridden method for further details. The modification here is to sample
-        the no-jump trajectory first. Then, the no-jump probability is used as a lower-bound
-        for random numbers in future monte carlo runs
+        See the overridden method for further details. The modification
+        here is to sample the no-jump trajectory first. Then, the no-jump
+        probability is used as a lower-bound for random numbers in future
+        monte carlo runs
         """
         stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
             state,
@@ -309,8 +311,9 @@ def run(self, state, tlist, ntraj=1, *,
         result.add((seed0, no_jump_result))
         result.stats['no jump run time'] = time() - start_time
 
-        # run the remaining trajectories with the random number floor set to the
-        # no jump probability such that we only sample trajectories with jumps
+        # run the remaining trajectories with the random number floor
+        # set to the no jump probability such that we only sample
+        # trajectories with jumps
         start_time = time()
         map_func(
             self._run_one_traj, seeds[1:],
@@ -320,4 +323,4 @@ def run(self, state, tlist, ntraj=1, *,
             progress_bar_kwargs=self.options["progress_kwargs"]
         )
         result.stats['run time'] = time() - start_time
-        return result
\ No newline at end of file
+        return result
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 1934a46eb2..7ae5bd9841 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -2,7 +2,8 @@
 import numpy as np
 from ..core import Qobj, QobjEvo, expect, isket, ket2dm, qzero, qzero_like
 
-__all__ = ["Result", "MultiTrajResult", "McResult", "NmmcResult"]
+__all__ = ["Result", "MultiTrajResult", "McResult", "NmmcResult",
+           "MultiTrajResultImprovedSampling"]
 
 
 class _QobjExpectEop:
@@ -1130,7 +1131,7 @@ def runs_photocurrent(self):
 
 
 class McResultImprovedSampling(MultiTrajResultImprovedSampling, McResult):
-    """McResult class using the MultiTrajResultImprovedSampling functionality"""
+    """McResult class using MultiTrajResultImprovedSampling"""
     def __init__(self, e_ops, options, **kw):
         MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops,
                                                  options=options, **kw)

From 41e845e46bd7d525c9565f69644237d5de9b4b68 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Thu, 24 Aug 2023 14:42:23 -0400
Subject: [PATCH 576/602] Moved improved_sampling into options, merged
 MCSolverImprovedSampling into MCSolver, eliminated
 MultiTrajSolverImprovedSampling and moved that functionality into MCSolver,
 MultiTrajResultImprovedSampling -> McResultImprovedSampling, fixed
 photocurrent computation, fixed tests (mostly adding improved_sampling as a
 key in options, some pep8 stuff)

---
 qutip/solver/mcsolve.py            | 114 +++++++++-----
 qutip/solver/multitraj.py          |  79 ++--------
 qutip/solver/result.py             | 239 +++++++++++++++--------------
 qutip/tests/solver/test_mcsolve.py |  71 +++++----
 4 files changed, 257 insertions(+), 246 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 83b509d520..4d198488dd 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -1,8 +1,8 @@
-__all__ = ['mcsolve', "MCSolver", "MCSolverImprovedSampling"]
+__all__ = ['mcsolve', "MCSolver"]
 
 import numpy as np
 from ..core import QobjEvo, spre, spost, Qobj, unstack_columns
-from .multitraj import MultiTrajSolver, MultiTrajSolverImprovedSampling
+from .multitraj import MultiTrajSolver
 from .solver_base import Solver, Integrator
 from .result import McResult, McTrajectoryResult, McResultImprovedSampling
 from .mesolve import mesolve, MESolver
@@ -11,8 +11,7 @@
 
 
 def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
-            args=None, options=None, seeds=None, target_tol=None, timeout=None,
-            improved_sampling=False):
+            args=None, options=None, seeds=None, target_tol=None, timeout=None):
     r"""
     Monte Carlo evolution of a state vector :math:`|\psi \rangle` for a
     given Hamiltonian and sets of collapse operators. Options for the
@@ -96,6 +95,9 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
         - max_step : float, [0]
           Maximum lenght of one internal step. When using pulses, it should be
           less than half the width of the thinnest pulse.
+        - improved_sampling : Bool
+          Whether to use the improved sampling algorithm from Abdelhafez et al.
+          PRA (2019)
 
     seeds : int, SeedSequence, list, [optional]
         Seed for the random number generator. It can be a single seed used to
@@ -117,10 +119,6 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
         Maximum time for the evolution in second. When reached, no more
         trajectories will be computed.
 
-    improved_sampling: Bool
-        Whether to use the improved sampling algorithm from Abdelhafez et al.
-        PRA (2019)
-
     Returns
     -------
     results : :class:`qutip.solver.McResult`
@@ -153,10 +151,7 @@ def mcsolve(H, state, tlist, c_ops=(), e_ops=None, ntraj=500, *,
             "ntraj must be an integer. "
             "A list of numbers is not longer supported."
         )
-    if not improved_sampling:
-        mc = MCSolver(H, c_ops, options=options)
-    else:
-        mc = MCSolverImprovedSampling(H, c_ops, options=options)
+    mc = MCSolver(H, c_ops, options=options)
 
     result = mc.run(state, tlist=tlist, ntraj=ntraj, e_ops=e_ops,
                     seed=seeds, target_tol=target_tol, timeout=timeout)
@@ -385,6 +380,7 @@ class MCSolver(MultiTrajSolver):
         "norm_steps": 5,
         "norm_t_tol": 1e-6,
         "norm_tol": 1e-4,
+        "improved_sampling": False,
     }
 
     def __init__(self, H, c_ops, *, options=None):
@@ -412,6 +408,9 @@ def __init__(self, H, c_ops, *, options=None):
                 rhs -= 0.5 * n_op
 
         self._num_collapse = len(self._c_ops)
+        self.options = options
+        if self.options["improved_sampling"]:
+            self.resultclass = McResultImprovedSampling
 
         super().__init__(rhs, options=options)
 
@@ -444,22 +443,74 @@ def _argument(self, args):
         for n_op in self._n_ops:
             n_op.arguments(args)
 
-    def _run_one_traj(self, seed, state, tlist, e_ops,
-                      no_jump=False, jump_prob_floor=0.0):
+    def _initialize_run_one_traj(self, seed, state, tlist, e_ops,
+                                 no_jump=False, jump_prob_floor=0.0):
+        result = self.trajectory_resultclass(e_ops, self.options)
+        generator = self._get_generator(seed)
+        self._integrator.set_state(tlist[0], state, generator,
+                                   no_jump=no_jump,
+                                   jump_prob_floor=jump_prob_floor)
+        result.add(tlist[0], self._restore_state(state, copy=False))
+        return result
+
+    def _run_one_traj(self, seed, state, tlist, e_ops, no_jump=False,
+                      jump_prob_floor=0.0):
         """
         Run one trajectory and return the result.
         """
-        # The integrators is reused, but non-reentrant. They are are fine for
-        # multiprocessing, but will fail with multithreading.
-        # If a thread base parallel map is created, eahc trajectory should use
-        # a copy of the integrator.
-        seed, result = super()._run_one_traj(
-            seed, state, tlist, e_ops,
-            no_jump=no_jump, jump_prob_floor=jump_prob_floor
-        )
+        result = self._initialize_run_one_traj(seed, state, tlist, e_ops,
+                                               no_jump=no_jump,
+                                               jump_prob_floor=jump_prob_floor)
+        seed, result = self._integrate_one_traj(seed, tlist, result)
         result.collapse = self._integrator.collapses
         return seed, result
 
+    def run(self, state, tlist, ntraj=1, *,
+            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
+        """
+        Do the evolution of the Quantum system.
+        See the overridden method for further details. The modification
+        here is to sample the no-jump trajectory first. Then, the no-jump
+        probability is used as a lower-bound for random numbers in future
+        monte carlo runs
+        """
+        if not self.options["improved_sampling"]:
+            return super().run(state, tlist, ntraj=ntraj, args=args,
+                               e_ops=e_ops, timeout=timeout,
+                               target_tol=target_tol, seed=seed)
+        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
+            state,
+            ntraj,
+            args=args,
+            e_ops=e_ops,
+            timeout=timeout,
+            target_tol=target_tol,
+            seed=seed,
+        )
+        # first run the no-jump trajectory
+        start_time = time()
+        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist,
+                                                   e_ops, no_jump=True)
+        _, state, _ = self._integrator.get_state(copy=False)
+        no_jump_prob = self._integrator._prob_func(state)
+        result.no_jump_prob = no_jump_prob
+        result.add((seed0, no_jump_result))
+        result.stats['no jump run time'] = time() - start_time
+
+        # run the remaining trajectories with the random number floor
+        # set to the no jump probability such that we only sample
+        # trajectories with jumps
+        start_time = time()
+        map_func(
+            self._run_one_traj, seeds[1:],
+            (state0, tlist, e_ops, False, no_jump_prob),
+            reduce_func=result.add, map_kw=map_kw,
+            progress_bar=self.options["progress_bar"],
+            progress_bar_kwargs=self.options["progress_kwargs"]
+        )
+        result.stats['run time'] = time() - start_time
+        return result
+
     def _get_integrator(self):
         _time_start = time()
         method = self.options["method"]
@@ -534,6 +585,10 @@ def options(self):
 
         norm_steps: int
             Maximum number of tries to find the collapse.
+
+        improved_sampling: Bool
+            Whether to use the improved sampling algorithm
+            of Abdelhafez et al. PRA (2019)
         """
         return self._options
 
@@ -549,18 +604,3 @@ def avail_integrators(cls):
             **Solver.avail_integrators(),
             **cls._avail_integrators,
         }
-
-
-class MCSolverImprovedSampling(MultiTrajSolverImprovedSampling, MCSolver):
-    r"""
-    Monte Carlo Solver of a state vector :math:`|\psi \rangle` for a
-    given Hamiltonian and sets of collapse operators using the improved
-    sampling algorithm. See MCSolver for further details and documentation
-    """
-    name = "mcsolve improved sampling"
-    resultclass = McResultImprovedSampling
-    trajectory_resultclass = McTrajectoryResult
-    mc_integrator_class = MCIntegrator
-
-    def __init__(self, H, c_ops, *, options=None):
-        MCSolver.__init__(self, H, c_ops, options=options)
diff --git a/qutip/solver/multitraj.py b/qutip/solver/multitraj.py
index 8ce23bd243..e422413afc 100644
--- a/qutip/solver/multitraj.py
+++ b/qutip/solver/multitraj.py
@@ -1,10 +1,10 @@
-from .result import Result, MultiTrajResult, MultiTrajResultImprovedSampling
+from .result import Result, MultiTrajResult
 from .parallel import _get_map
 from time import time
 from .solver_base import Solver
 import numpy as np
 
-__all__ = ["MultiTrajSolver", "MultiTrajSolverImprovedSampling"]
+__all__ = ["MultiTrajSolver"]
 
 
 class MultiTrajSolver(Solver):
@@ -205,17 +205,21 @@ def run(self, state, tlist, ntraj=1, *,
         result.stats['run time'] = time() - start_time
         return result
 
-    def _run_one_traj(self, seed, state, tlist, e_ops,
-                      no_jump=False, jump_prob_floor=0.0):
-        """
-        Run one trajectory and return the result.
-        """
+    def _initialize_run_one_traj(self, seed, state, tlist, e_ops):
         result = self.trajectory_resultclass(e_ops, self.options)
         generator = self._get_generator(seed)
-        self._integrator.set_state(tlist[0], state, generator,
-                                   no_jump=no_jump,
-                                   jump_prob_floor=jump_prob_floor)
+        self._integrator.set_state(tlist[0], state, generator)
         result.add(tlist[0], self._restore_state(state, copy=False))
+        return result
+
+    def _run_one_traj(self, seed, state, tlist, e_ops):
+        """
+        Run one trajectory and return the result.
+        """
+        result = self._initialize_run_one_traj(seed, state, tlist, e_ops)
+        return self._integrate_one_traj(seed, tlist, result)
+
+    def _integrate_one_traj(self, seed, tlist, result):
         for t in tlist[1:]:
             t, state = self._integrator.integrate(t, copy=False)
             result.add(t, self._restore_state(state, copy=False))
@@ -269,58 +273,3 @@ def _get_generator(self, seed):
     @classmethod
     def avail_integrators(cls):
         return cls._avail_integrators
-
-
-class MultiTrajSolverImprovedSampling(MultiTrajSolver):
-    """
-    Class for multi-trajectory evolutions using the improved sampling
-    algorithm. See docstring for MultiTrajSolver for further documentation
-    """
-    name = "multi trajectory efficient"
-    resultclass = MultiTrajResultImprovedSampling
-    trajectory_resultclass = Result
-
-    def __init__(self, rhs, *, options=None):
-        super().__init__(rhs, options=options)
-
-    def run(self, state, tlist, ntraj=1, *,
-            args=None, e_ops=(), timeout=None, target_tol=None, seed=None):
-        """
-        Do the evolution of the Quantum system.
-        See the overridden method for further details. The modification
-        here is to sample the no-jump trajectory first. Then, the no-jump
-        probability is used as a lower-bound for random numbers in future
-        monte carlo runs
-        """
-        stats, seeds, result, map_func, map_kw, state0 = self._initialize_run(
-            state,
-            ntraj,
-            args=args,
-            e_ops=e_ops,
-            timeout=timeout,
-            target_tol=target_tol,
-            seed=seed,
-        )
-        # first run the no-jump trajectory
-        start_time = time()
-        seed0, no_jump_result = self._run_one_traj(seeds[0], state0, tlist,
-                                                   e_ops, no_jump=True)
-        _, state, _ = self._integrator.get_state(copy=False)
-        no_jump_prob = self._integrator._prob_func(state)
-        result.no_jump_prob = no_jump_prob
-        result.add((seed0, no_jump_result))
-        result.stats['no jump run time'] = time() - start_time
-
-        # run the remaining trajectories with the random number floor
-        # set to the no jump probability such that we only sample
-        # trajectories with jumps
-        start_time = time()
-        map_func(
-            self._run_one_traj, seeds[1:],
-            (state0, tlist, e_ops, False, no_jump_prob),
-            reduce_func=result.add, map_kw=map_kw,
-            progress_bar=self.options["progress_bar"],
-            progress_bar_kwargs=self.options["progress_kwargs"]
-        )
-        result.stats['run time'] = time() - start_time
-        return result
diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 7ae5bd9841..714f73328d 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -3,7 +3,7 @@
 from ..core import Qobj, QobjEvo, expect, isket, ket2dm, qzero, qzero_like
 
 __all__ = ["Result", "MultiTrajResult", "McResult", "NmmcResult",
-           "MultiTrajResultImprovedSampling"]
+           "McTrajectoryResult", "McResultImprovedSampling"]
 
 
 class _QobjExpectEop:
@@ -870,15 +870,131 @@ def __add__(self, other):
         return new
 
 
-class MultiTrajResultImprovedSampling(MultiTrajResult):
+class McTrajectoryResult(Result):
+    """
+    Result class used by the :class:`qutip.MCSolver` for single trajectories.
+    """
+
+    def __init__(self, e_ops, options, *args, **kwargs):
+        super().__init__(e_ops, {**options, "normalize_output": False},
+                         *args, **kwargs)
+
+
+class McResult(MultiTrajResult):
+    """
+    Class for storing Monte-Carlo solver results.
+
+    Parameters
+    ----------
+    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
+        The ``e_ops`` parameter defines the set of values to record at
+        each time step ``t``. If an element is a :obj:`~Qobj` or
+        :obj:`~QobjEvo` the value recorded is the expectation value of that
+        operator given the state at ``t``. If the element is a function, ``f``,
+        the value recorded is ``f(t, state)``.
+
+        The values are recorded in the ``.expect`` attribute of this result
+        object. ``.expect`` is a list, where each item contains the values
+        of the corresponding ``e_op``.
+
+    options : :obj:`~SolverResultsOptions`
+        The options for this result class.
+
+    solver : str or None
+        The name of the solver generating these results.
+
+    stats : dict
+        The stats generated by the solver while producing these results. Note
+        that the solver may update the stats directly while producing results.
+        Must include a value for "num_collapse".
+
+    kw : dict
+        Additional parameters specific to a result sub-class.
+
+    Properties
+    ----------
+    collapse : list
+        For each runs, a list of every collapse as a tuple of the time it
+        happened and the corresponding ``c_ops`` index.
     """
-    See docstring for MultiTrajResult for all relevant documentation.
-    This child class computes expectation values and sums of states, etc
+    # Collapse are only produced by mcsolve.
+
+    def _add_collapse(self, trajectory):
+        self.collapse.append(trajectory.collapse)
+
+    def _post_init(self):
+        super()._post_init()
+        self.num_c_ops = self.stats["num_collapse"]
+        self.collapse = []
+        self.add_processor(self._add_collapse)
+
+    @property
+    def col_times(self):
+        """
+        List of the times of the collapses for each runs.
+        """
+        out = []
+        for col_ in self.collapse:
+            col = list(zip(*col_))
+            col = ([] if len(col) == 0 else col[0])
+            out.append(col)
+        return out
+
+    @property
+    def col_which(self):
+        """
+        List of the indexes of the collapses for each runs.
+        """
+        out = []
+        for col_ in self.collapse:
+            col = list(zip(*col_))
+            col = ([] if len(col) == 0 else col[1])
+            out.append(col)
+        return out
+
+    @property
+    def photocurrent(self):
+        """
+        Average photocurrent or measurement of the evolution.
+        """
+        cols = [[] for _ in range(self.num_c_ops)]
+        tlist = self.times
+        for collapses in self.collapse:
+            for t, which in collapses:
+                cols[which].append(t)
+        mesurement = [
+            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
+            for i in range(self.num_c_ops)
+        ]
+        return mesurement
+
+    @property
+    def runs_photocurrent(self):
+        """
+        Photocurrent or measurement of each runs.
+        """
+        tlist = self.times
+        measurements = []
+        for collapses in self.collapse:
+            cols = [[] for _ in range(self.num_c_ops)]
+            for t, which in collapses:
+                cols[which].append(t)
+            measurements.append([
+                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
+                for i in range(self.num_c_ops)
+            ])
+        return measurements
+
+
+class McResultImprovedSampling(McResult, MultiTrajResult):
+    """
+    See docstring for McResult and MultiTrajResult for all relevant documentation.
+    This class computes expectation values and sums of states, etc
     using the improved sampling algorithm, which samples the no-jump trajectory
     first and then only samples jump trajectories afterwards.
     """
     def __init__(self, e_ops, options, **kw):
-        super().__init__(e_ops, options, **kw)
+        MultiTrajResult.__init__(self, e_ops=e_ops, options=options, **kw)
         self._sum_expect_no_jump = None
         self._sum_expect_jump = None
         self._sum2_expect_no_jump = None
@@ -1013,89 +1129,6 @@ def average_final_state(self):
     def __add__(self, other):
         raise NotImplemented
 
-
-class McTrajectoryResult(Result):
-    """
-    Result class used by the :class:`qutip.MCSolver` for single trajectories.
-    """
-
-    def __init__(self, e_ops, options, *args, **kwargs):
-        super().__init__(e_ops, {**options, "normalize_output": False},
-                         *args, **kwargs)
-
-
-class McResult(MultiTrajResult):
-    """
-    Class for storing Monte-Carlo solver results.
-
-    Parameters
-    ----------
-    e_ops : :obj:`~Qobj`, :obj:`~QobjEvo`, function or list or dict of these
-        The ``e_ops`` parameter defines the set of values to record at
-        each time step ``t``. If an element is a :obj:`~Qobj` or
-        :obj:`~QobjEvo` the value recorded is the expectation value of that
-        operator given the state at ``t``. If the element is a function, ``f``,
-        the value recorded is ``f(t, state)``.
-
-        The values are recorded in the ``.expect`` attribute of this result
-        object. ``.expect`` is a list, where each item contains the values
-        of the corresponding ``e_op``.
-
-    options : :obj:`~SolverResultsOptions`
-        The options for this result class.
-
-    solver : str or None
-        The name of the solver generating these results.
-
-    stats : dict
-        The stats generated by the solver while producing these results. Note
-        that the solver may update the stats directly while producing results.
-        Must include a value for "num_collapse".
-
-    kw : dict
-        Additional parameters specific to a result sub-class.
-
-    Properties
-    ----------
-    collapse : list
-        For each runs, a list of every collapse as a tuple of the time it
-        happened and the corresponding ``c_ops`` index.
-    """
-    # Collapse are only produced by mcsolve.
-
-    def _add_collapse(self, trajectory):
-        self.collapse.append(trajectory.collapse)
-
-    def _post_init(self):
-        super()._post_init()
-        self.num_c_ops = self.stats["num_collapse"]
-        self.collapse = []
-        self.add_processor(self._add_collapse)
-
-    @property
-    def col_times(self):
-        """
-        List of the times of the collapses for each runs.
-        """
-        out = []
-        for col_ in self.collapse:
-            col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[0])
-            out.append(col)
-        return out
-
-    @property
-    def col_which(self):
-        """
-        List of the indexes of the collapses for each runs.
-        """
-        out = []
-        for col_ in self.collapse:
-            col = list(zip(*col_))
-            col = ([] if len(col) == 0 else col[1])
-            out.append(col)
-        return out
-
     @property
     def photocurrent(self):
         """
@@ -1107,38 +1140,12 @@ def photocurrent(self):
             for t, which in collapses:
                 cols[which].append(t)
         mesurement = [
-            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / self.num_trajectories
+            (1 - self.no_jump_prob) *
+            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / (self.num_trajectories - 1)
             for i in range(self.num_c_ops)
         ]
         return mesurement
 
-    @property
-    def runs_photocurrent(self):
-        """
-        Photocurrent or measurement of each runs.
-        """
-        tlist = self.times
-        measurements = []
-        for collapses in self.collapse:
-            cols = [[] for _ in range(self.num_c_ops)]
-            for t, which in collapses:
-                cols[which].append(t)
-            measurements.append([
-                np.histogram(cols[i], tlist)[0] / np.diff(tlist)
-                for i in range(self.num_c_ops)
-            ])
-        return measurements
-
-
-class McResultImprovedSampling(MultiTrajResultImprovedSampling, McResult):
-    """McResult class using MultiTrajResultImprovedSampling"""
-    def __init__(self, e_ops, options, **kw):
-        MultiTrajResultImprovedSampling.__init__(self, e_ops=e_ops,
-                                                 options=options, **kw)
-
-    def _add_collapse(self, trajectory, no_jump=False):
-        super()._add_collapse(trajectory)
-
 
 class NmmcTrajectoryResult(McTrajectoryResult):
     """
diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index 32ca173056..d4cbeb4ca8 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -5,6 +5,7 @@
 from qutip.solver.mcsolve import mcsolve, MCSolver
 from qutip.solver.solver_base import Solver
 
+
 def _return_constant(t, args):
     return args['constant']
 
@@ -51,18 +52,16 @@ def _assert_expect(self, result, expected, tol):
         for test, expected_part in zip(result.expect, expected):
             np.testing.assert_allclose(test, expected_part, rtol=tol)
 
-    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
-        options = {"store_states": True, "map": "serial"}
+    @pytest.mark.parametrize("improved_sampling", [True, False])
+    def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol,
+                               improved_sampling):
+        options = {"store_states": True, "map": "serial",
+                   "improved_sampling": improved_sampling}
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
                          options=options, target_tol=0.05)
-        result_improved_sampling = mcsolve(hamiltonian, self.state, self.times, args=args,
-                         c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options=options, improved_sampling=True)
         self._assert_expect(result, expected, tol)
         self._assert_states(result, expected, tol)
-        self._assert_expect(result_improved_sampling, expected, tol)
-        self._assert_states(result_improved_sampling, expected, tol)
 
 
 class TestNoCollapse(StatesAndExpectOutputCase):
@@ -78,7 +77,7 @@ def pytest_generate_tests(self, metafunc):
             (self.h, "Qobj"),
             ([self.h], "list"),
             (qutip.QobjEvo([self.h, [self.h, _return_constant]],
-                           args= {'constant': 0}), "QobjEvo"),
+                           args={'constant': 0}), "QobjEvo"),
             (callable_qobj(self.h), "callable"),
         ]
         cases = [pytest.param(hamiltonian, {}, [], [expect], tol, id=id)
@@ -94,18 +93,22 @@ def pytest_generate_tests(self, metafunc):
     # test cases, this is just testing the single-output behaviour.
 
     @pytest.mark.parametrize("improved_sampling", [True, False])
-    def test_states_only(self, hamiltonian, args, c_ops, expected, tol, improved_sampling):
-        options = {"store_states": True, "map": "serial"}
+    def test_states_only(self, hamiltonian, args, c_ops, expected, tol,
+                         improved_sampling):
+        options = {"store_states": True, "map": "serial",
+                   "improved_sampling": improved_sampling}
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=[], ntraj=self.ntraj,
-                         options=options, improved_sampling=improved_sampling)
+                         options=options)
         self._assert_states(result, expected, tol)
 
     @pytest.mark.parametrize("improved_sampling", [True, False])
-    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol, improved_sampling):
+    def test_expect_only(self, hamiltonian, args, c_ops, expected, tol,
+                         improved_sampling):
+        options = {'map': 'serial', "improved_sampling": improved_sampling}
         result = mcsolve(hamiltonian, self.state, self.times, args=args,
                          c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
-                         options={'map': 'serial'}, improved_sampling=improved_sampling)
+                         options=options)
         self._assert_expect(result, expected, tol)
 
 
@@ -191,7 +194,8 @@ def test_states_outputs(keep_runs_results, improved_sampling):
     c_ops = [a, sm]
     data = mcsolve(H, state, times, c_ops, ntraj=ntraj,
                    options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'}, improved_sampling=improved_sampling)
+                            'map': 'serial',
+                            "improved_sampling": improved_sampling})
 
     assert len(data.average_states) == len(times)
     assert isinstance(data.average_states[0], qutip.Qobj)
@@ -205,7 +209,7 @@ def test_states_outputs(keep_runs_results, improved_sampling):
     assert isinstance(data.photocurrent[0][1], float)
     assert isinstance(data.photocurrent[1][1], float)
     assert (np.array(data.runs_photocurrent).shape
-        == (ntraj, len(c_ops), len(times)-1))
+            == (ntraj, len(c_ops), len(times)-1))
 
     if keep_runs_results:
         assert len(data.runs_states) == ntraj
@@ -249,7 +253,8 @@ def test_expectation_outputs(keep_runs_results, improved_sampling):
     e_ops = [a.dag()*a, sm.dag()*sm, a]
     data = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
                    options={"keep_runs_results": keep_runs_results,
-                            'map': 'serial'}, improved_sampling=improved_sampling)
+                            'map': 'serial',
+                            "improved_sampling": improved_sampling})
     assert isinstance(data.average_expect[0][1], float)
     assert isinstance(data.average_expect[1][1], float)
     assert isinstance(data.average_expect[2][1], complex)
@@ -295,7 +300,8 @@ class TestSeeds:
     @pytest.mark.parametrize("improved_sampling", [True, False])
     def test_seeds_can_be_reused(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj,
+                  "options": {"improved_sampling": improved_sampling}}
         first = mcsolve(*args, **kwargs)
         second = mcsolve(*args, seeds=first.seeds, **kwargs)
         for first_t, second_t in zip(first.col_times, second.col_times):
@@ -306,7 +312,8 @@ def test_seeds_can_be_reused(self, improved_sampling):
     @pytest.mark.parametrize("improved_sampling", [True, False])
     def test_seeds_are_not_reused_by_default(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj,
+                  "options": {"improved_sampling": improved_sampling}}
         first = mcsolve(*args, **kwargs)
         second = mcsolve(*args, **kwargs)
         assert not all(np.array_equal(first_t, second_t)
@@ -320,7 +327,8 @@ def test_seeds_are_not_reused_by_default(self, improved_sampling):
     @pytest.mark.parametrize("improved_sampling", [True, False])
     def test_seed_type(self, seed, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj,
+                  "options": {"improved_sampling": improved_sampling}}
         first = mcsolve(*args, seeds=copy(seed), **kwargs)
         second = mcsolve(*args, seeds=copy(seed), **kwargs)
         for f_seed, s_seed in zip(first.seeds, second.seeds):
@@ -329,15 +337,18 @@ def test_seed_type(self, seed, improved_sampling):
     @pytest.mark.parametrize("improved_sampling", [True, False])
     def test_bad_seed(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj,
+                  "options": {"improved_sampling": improved_sampling}}
         with pytest.raises(ValueError):
             first = mcsolve(*args, seeds=[1], **kwargs)
 
     @pytest.mark.parametrize("improved_sampling", [True, False])
     def test_generator(self, improved_sampling):
         args = (self.H, self.state, self.times)
-        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj, "improved_sampling": improved_sampling}
-        first = mcsolve(*args, seeds=1, options={'bitgenerator': 'MT19937'},
+        kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
+        first = mcsolve(*args, seeds=1,
+                        options={'bitgenerator': 'MT19937',
+                                 "improved_sampling": improved_sampling},
                         **kwargs)
         second = mcsolve(*args, seeds=1, **kwargs)
         for f_seed, s_seed in zip(first.seeds, second.seeds):
@@ -355,10 +366,10 @@ def test_stepping(self):
         H = qutip.num(size)
         mcsolver = MCSolver(H, a, options={'map': 'serial'})
         mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-        state_1 = mcsolver.step(1, args={'alpha':1})
+        state_1 = mcsolver.step(1, args={'alpha': 1})
 
         mcsolver.start(qutip.basis(size, size-1), 0, seed=5)
-        state_2 = mcsolver.step(1, args={'alpha':1})
+        state_2 = mcsolver.step(1, args={'alpha': 1})
         assert state_1 == state_2
 
 
@@ -375,7 +386,9 @@ def test_timeout(improved_sampling):
     c_ops = np.sqrt(coupling * (n_th + 1)) * a
     e_ops = [qutip.num(size)]
     res = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
-                  options={'map': 'serial'}, timeout=1e-6, improved_sampling=improved_sampling)
+                  options={'map': 'serial',
+                           "improved_sampling": improved_sampling},
+                  timeout=1e-6)
     assert res.stats['end_condition'] == 'timeout'
 
 
@@ -395,13 +408,15 @@ def test_super_H(improved_sampling):
     mc_expected = mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj,
                           target_tol=0.1, options={'map': 'serial'})
     mc = mcsolve(qutip.liouvillian(H), state, times, c_ops, e_ops, ntraj=ntraj,
-                 target_tol=0.1, options={'map': 'serial'}, improved_sampling=improved_sampling)
+                 target_tol=0.1,
+                 options={'map': 'serial',
+                          "improved_sampling": improved_sampling})
     np.testing.assert_allclose(mc_expected.expect[0], mc.expect[0], atol=0.5)
 
 
 def test_MCSolver_run():
     size = 10
-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling': 0})
     H = qutip.num(size)
     solver = MCSolver(H, a)
     solver.options = {'store_final_state': True}
@@ -421,7 +436,7 @@ def test_MCSolver_run():
 
 def test_MCSolver_stepping():
     size = 10
-    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling':0})
+    a = qutip.QobjEvo([qutip.destroy(size), 'coupling'], args={'coupling': 0})
     H = qutip.num(size)
     solver = MCSolver(H, a)
     solver.start(qutip.basis(size, size-1), 0, seed=0)

From 7b3164f8c53fe7247318929a7245cf0f07fb4145 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 24 Aug 2023 15:39:40 -0400
Subject: [PATCH 577/602] Remove three_level_atom

---
 doc/QuTiP_tree_plot/qutip-structure.py |  1 -
 doc/apidoc/functions.rst               |  8 ---
 qutip/__init__.py                      |  1 -
 qutip/tests/test_three_level.py        | 24 ---------
 qutip/three_level_atom.py              | 74 --------------------------
 5 files changed, 108 deletions(-)
 delete mode 100644 qutip/tests/test_three_level.py
 delete mode 100644 qutip/three_level_atom.py

diff --git a/doc/QuTiP_tree_plot/qutip-structure.py b/doc/QuTiP_tree_plot/qutip-structure.py
index cf18a9f171..7234598fba 100755
--- a/doc/QuTiP_tree_plot/qutip-structure.py
+++ b/doc/QuTiP_tree_plot/qutip-structure.py
@@ -47,7 +47,6 @@
     # States
     ("#007143", {
         "states", "continuous_variables", "qstate", "random_objects",
-        "three_level_atom",
     }),
     # QIP
     ("#36d695", {"measurement"}),
diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index 990c713e39..fb6c591482 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -37,14 +37,6 @@ Random Operators and States
     :members: rand_dm, rand_herm, rand_ket, rand_stochastic, rand_unitary, rand_super, rand_super_bcsz
 
 
-Three-Level Atoms
------------------
-
-.. automodule:: qutip.three_level_atom
-    :members: three_level_basis, three_level_ops
-    :undoc-members:
-
-
 Superoperators and Liouvillians
 -------------------------------
 
diff --git a/qutip/__init__.py b/qutip/__init__.py
index 534d51b795..dbdc922732 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -52,7 +52,6 @@
 from .partial_transpose import *
 from .continuous_variables import *
 from .distributions import *
-from .three_level_atom import *
 
 
 # utilities
diff --git a/qutip/tests/test_three_level.py b/qutip/tests/test_three_level.py
deleted file mode 100644
index 92b9ca05e1..0000000000
--- a/qutip/tests/test_three_level.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import numpy as np
-from numpy.testing import assert_equal
-from qutip import basis
-from qutip.three_level_atom import *
-
-
-three_states = three_level_basis()
-three_check = np.empty((3,), dtype=object)
-three_check[:] = [basis(3, 0), basis(3, 1), basis(3, 2)]
-three_ops = three_level_ops()
-
-
-def testThreeStates():
-    "Three-level atom: States"
-    assert_equal(np.all(three_states == three_check), True)
-
-
-def testThreeOps():
-    "Three-level atom: Operators"
-    assert_equal((three_ops[0]*three_states[0]).full(), three_check[0].full())
-    assert_equal((three_ops[1]*three_states[1]).full(), three_check[1].full())
-    assert_equal((three_ops[2]*three_states[2]).full(), three_check[2].full())
-    assert_equal((three_ops[3]*three_states[1]).full(), three_check[0].full())
-    assert_equal((three_ops[4]*three_states[1]).full(), three_check[2].full())
diff --git a/qutip/three_level_atom.py b/qutip/three_level_atom.py
deleted file mode 100644
index eee506ef56..0000000000
--- a/qutip/three_level_atom.py
+++ /dev/null
@@ -1,74 +0,0 @@
-r'''
-This module provides functions that are useful for simulating the
-three level atom with QuTiP.  A three level atom (qutrit) has three states,
-which are linked by dipole transitions so that 1 <-> 2 <-> 3.
-Depending on there relative energies they are in the ladder, lambda or
-vee configuration. The structure of the relevant operators is the same
-for any of the three configurations::
-
-    Ladder:          Lambda:                 Vee:
-                                |two>                       |three>
-      -------|three>           -------                      -------
-         |                       / \             |one>         /
-         |                      /   \           -------       /
-         |                     /     \             \         /
-      -------|two>            /       \             \       /
-         |                   /         \             \     /
-         |                  /           \             \   /
-         |                 /        --------           \ /
-      -------|one>      -------      |three>         -------
-                         |one>                       |two>
-
-References
-----------
-The naming of qutip operators follows the convention in [1]_ .
-
-.. [1] Shore, B. W., "The Theory of Coherent Atomic Excitation",
-   Wiley, 1990.
-
-Notes
------
-Contributed by Markus Baden, Oct. 07, 2011
-
-'''
-
-__all__ = ['three_level_basis', 'three_level_ops']
-
-import numpy as np
-from . import qutrit_basis
-
-
-def three_level_basis():
-    ''' Basis states for a three level atom.
-
-    Returns
-    -------
-    states : np.array
-        :obj:`numpy.ndarray` of three level atom basis vectors.
-    '''
-    # A three level atom has the same representation as a qutrit, i.e.
-    # three states
-    return qutrit_basis()
-
-
-def three_level_ops():
-    """
-    Operators for a three level system (qutrit)
-
-    Returns
-    -------
-    ops : np.array
-        :obj:`numpy.ndarray` of three level operators.
-    """
-    out = np.empty((5,), dtype=object)
-    one, two, three = qutrit_basis()
-    # Note that the three level operators are different
-    # from the qutrit operators. A three level atom only
-    # has transitions 1 <-> 2 <-> 3, so we define the
-    # operators seperately from the qutrit code
-    out[0] = one * one.dag()
-    out[1] = two * two.dag()
-    out[2] = three * three.dag()
-    out[3] = one * two.dag()
-    out[4] = three * two.dag()
-    return out

From 7e181d513b8d2dfd98977542b42e81bff0439a71 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Thu, 24 Aug 2023 15:45:39 -0400
Subject: [PATCH 578/602] updated documentation with an example plot showing
 usage of improved_sampling

---
 doc/guide/dynamics/dynamics-monte.rst | 35 +++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index 7457aad744..30f712d90d 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -159,17 +159,48 @@ by only sampling the no-jump trajectory once. We then extract the no-jump probab
 and for all future runs we only sample random numbers :math:`r_1` where :math:`r_1>p`, thus ensuring
 that a jump will occur. When it comes time to compute expectation values, we weight the no-jump
 trajectory by :math:`p` and the jump trajectories by :math:`1-p`. This algorithm is described
-in [Abd19]_. This algorithm can be utilized by setting the flag ``improved_sampling=True`` in the call to
+in [Abd19]_ and can be utilized by setting the option ``"improved_sampling"`` in the call to
 ``mcsolve``:
 
 .. plot::
     :context: close-figs
 
-    data = mcsolve(H, psi0, times, [np.sqrt(0.1) * a], e_ops=[a.dag() * a, sm.dag() * sm], improved_sampling=True)
+    data = mcsolve(H, psi0, times, [np.sqrt(0.1) * a], e_ops=[a.dag() * a, sm.dag() * sm],options={"improved_sampling": True})
 
 where in this case the first run samples the no-jump trajectory, and the remaining 499 trajectories are all
 guaranteed to include (at least) one jump.
 
+The power of this algorithm is most obvious when considering systems that rarely undergo jumps.
+For instance, consider the following T1 simulation of a qubit with a lifetime of 100 microseconds (assuming time is in
+units of nanoseconds)
+
+
+.. plot::
+    :context: close-figs
+
+    times = np.linspace(0.0, 300.0, 100)
+    psi0 = fock(2, 1)
+    sm = fock(2, 0) * fock(2, 1).dag()
+    omega = 2.0 * np.pi * 1.0
+    H0 = -0.5 * omega * sigmaz()
+    gamma = 2.0 * np.pi * 0.00001
+    data = mcsolve([H0], psi0, times, [np.sqrt(gamma) * sm], [sm.dag() * sm], ntraj=100)
+    data_imp = mcsolve([H0], psi0, times, [np.sqrt(gamma) * sm], [sm.dag() * sm],ntraj=100, options={"improved_sampling": True})
+
+    plt.figure()
+    plt.plot(times, data.expect[0], label="original")
+    plt.plot(times, data_imp.expect[0], label="improved sampling")
+    plt.plot(times, np.exp(-gamma * times), label=r"$\exp(-\gamma t)$")
+    plt.title('Monte Carlo: improved sampling algorithm')
+    plt.xlabel("time [ns]")
+    plt.ylabel(r"$p_{1}$")
+    plt.legend()
+    plt.show()
+
+
+The original sampling algorithm samples the no-jump trajectory on average ``97.8\%" of the time, while the improved
+sampling algorithm only does so once.
+
 
 .. _monte-reuse:
 

From 7198a458291c6f81692053a07e5bbc17b64e853b Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Thu, 24 Aug 2023 15:55:43 -0400
Subject: [PATCH 579/602] small docs bug fix

---
 doc/guide/dynamics/dynamics-monte.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index 30f712d90d..8707677f9b 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -198,7 +198,7 @@ units of nanoseconds)
     plt.show()
 
 
-The original sampling algorithm samples the no-jump trajectory on average ``97.8\%" of the time, while the improved
+The original sampling algorithm samples the no-jump trajectory on average 97.8% of the time, while the improved
 sampling algorithm only does so once.
 
 

From 43137411446c31d70185ed4bdaaf551807ca9cbe Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 24 Aug 2023 16:17:16 -0400
Subject: [PATCH 580/602] Add towncrier entry

---
 doc/changes/2221.removal | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2221.removal

diff --git a/doc/changes/2221.removal b/doc/changes/2221.removal
new file mode 100644
index 0000000000..8574d986ec
--- /dev/null
+++ b/doc/changes/2221.removal
@@ -0,0 +1 @@
+Deprecate three_level_atom

From b38134e6f2ab6db9f6dd7174f4ba630320e393ec Mon Sep 17 00:00:00 2001
From: Daniel Weiss <32396142+dkweiss31@users.noreply.github.com>
Date: Thu, 24 Aug 2023 20:44:39 -0400
Subject: [PATCH 581/602] Update doc/guide/dynamics/dynamics-monte.rst
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Eric Giguère <eric.giguere@calculquebec.ca>
---
 doc/guide/dynamics/dynamics-monte.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index 8707677f9b..b85bf1245b 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -165,7 +165,7 @@ in [Abd19]_ and can be utilized by setting the option ``"improved_sampling"`` in
 .. plot::
     :context: close-figs
 
-    data = mcsolve(H, psi0, times, [np.sqrt(0.1) * a], e_ops=[a.dag() * a, sm.dag() * sm],options={"improved_sampling": True})
+    data = mcsolve(H, psi0, times, [np.sqrt(0.1) * a], e_ops=[a.dag() * a, sm.dag() * sm], options={"improved_sampling": True})
 
 where in this case the first run samples the no-jump trajectory, and the remaining 499 trajectories are all
 guaranteed to include (at least) one jump.

From 96d7ad65b67759fbe505f4dfadea9a6221ec3f16 Mon Sep 17 00:00:00 2001
From: Daniel Weiss <32396142+dkweiss31@users.noreply.github.com>
Date: Thu, 24 Aug 2023 20:44:58 -0400
Subject: [PATCH 582/602] Update qutip/solver/result.py
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Eric Giguère <eric.giguere@calculquebec.ca>
---
 qutip/solver/result.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/result.py b/qutip/solver/result.py
index 714f73328d..7544d09761 100644
--- a/qutip/solver/result.py
+++ b/qutip/solver/result.py
@@ -1140,8 +1140,8 @@ def photocurrent(self):
             for t, which in collapses:
                 cols[which].append(t)
         mesurement = [
-            (1 - self.no_jump_prob) *
-            np.histogram(cols[i], tlist)[0] / np.diff(tlist) / (self.num_trajectories - 1)
+            (1 - self.no_jump_prob) / (self.num_trajectories - 1) *
+            np.histogram(cols[i], tlist)[0] / np.diff(tlist)
             for i in range(self.num_c_ops)
         ]
         return mesurement

From f18e078ad6e56461d88e4c4053e971c710c7e9ec Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Thu, 24 Aug 2023 20:49:33 -0400
Subject: [PATCH 583/602] using decorator @property to set resultclass based on
 self.options["improved_sampling"]

---
 qutip/solver/mcsolve.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/qutip/solver/mcsolve.py b/qutip/solver/mcsolve.py
index 4d198488dd..9682d73437 100644
--- a/qutip/solver/mcsolve.py
+++ b/qutip/solver/mcsolve.py
@@ -362,7 +362,6 @@ class MCSolver(MultiTrajSolver):
         Options for the evolution.
     """
     name = "mcsolve"
-    resultclass = McResult
     trajectory_resultclass = McTrajectoryResult
     mc_integrator_class = MCIntegrator
     solver_options = {
@@ -409,8 +408,6 @@ def __init__(self, H, c_ops, *, options=None):
 
         self._num_collapse = len(self._c_ops)
         self.options = options
-        if self.options["improved_sampling"]:
-            self.resultclass = McResultImprovedSampling
 
         super().__init__(rhs, options=options)
 
@@ -527,6 +524,13 @@ def _get_integrator(self):
         self._init_integrator_time = time() - _time_start
         return mc_integrator
 
+    @property
+    def resultclass(self):
+        if self.options["improved_sampling"]:
+            return McResultImprovedSampling
+        else:
+            return McResult
+
     @property
     def options(self):
         """

From 2984036ffb76581764ee4dcb33204258976cd538 Mon Sep 17 00:00:00 2001
From: Danny <dkweiss@u.northwestern.edu>
Date: Thu, 24 Aug 2023 22:10:38 -0400
Subject: [PATCH 584/602] small clarity changes to docs

---
 doc/guide/dynamics/dynamics-monte.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/guide/dynamics/dynamics-monte.rst b/doc/guide/dynamics/dynamics-monte.rst
index b85bf1245b..5dda6b35eb 100644
--- a/doc/guide/dynamics/dynamics-monte.rst
+++ b/doc/guide/dynamics/dynamics-monte.rst
@@ -171,8 +171,8 @@ where in this case the first run samples the no-jump trajectory, and the remaini
 guaranteed to include (at least) one jump.
 
 The power of this algorithm is most obvious when considering systems that rarely undergo jumps.
-For instance, consider the following T1 simulation of a qubit with a lifetime of 100 microseconds (assuming time is in
-units of nanoseconds)
+For instance, consider the following T1 simulation of a qubit with a lifetime of 10 microseconds
+(assuming time is in units of nanoseconds)
 
 
 .. plot::
@@ -183,7 +183,7 @@ units of nanoseconds)
     sm = fock(2, 0) * fock(2, 1).dag()
     omega = 2.0 * np.pi * 1.0
     H0 = -0.5 * omega * sigmaz()
-    gamma = 2.0 * np.pi * 0.00001
+    gamma = 1/10000
     data = mcsolve([H0], psi0, times, [np.sqrt(gamma) * sm], [sm.dag() * sm], ntraj=100)
     data_imp = mcsolve([H0], psi0, times, [np.sqrt(gamma) * sm], [sm.dag() * sm],ntraj=100, options={"improved_sampling": True})
 
@@ -198,7 +198,7 @@ units of nanoseconds)
     plt.show()
 
 
-The original sampling algorithm samples the no-jump trajectory on average 97.8% of the time, while the improved
+The original sampling algorithm samples the no-jump trajectory on average 96.7% of the time, while the improved
 sampling algorithm only does so once.
 
 

From 2c560e5034a304767bcc7f03781a7d87d1372cd2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 11:06:56 -0400
Subject: [PATCH 585/602] Add early termination in map functions according to
 reduce_map output

---
 qutip/solver/parallel.py            | 36 ++++++++++++++++++++++-------
 qutip/tests/solver/test_parallel.py | 20 ++++++++++++++++
 2 files changed, 48 insertions(+), 8 deletions(-)

diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
index 57d0ed175b..c5a0eaf8a7 100644
--- a/qutip/solver/parallel.py
+++ b/qutip/solver/parallel.py
@@ -1,6 +1,7 @@
 """
 This module provides functions for parallel execution of loops and function
-mappings, using the builtin Python module multiprocessing or the loky parallel execution library.
+mappings, using the builtin Python module multiprocessing or the loky parallel
+execution library.
 """
 __all__ = ['parallel_map', 'serial_map', 'loky_pmap']
 
@@ -70,7 +71,9 @@ def serial_map(task, values, task_args=None, task_kwargs=None,
         The optional additional keyword argument to the ``task`` function.
     reduce_func : func (optional)
         If provided, it will be called with the output of each tasks instead of
-        storing a them in a list.
+        storing a them in a list. It should return None or a number.
+        When returning a number, it represent the estimation of the number of
+        task left. On a return >= 0, the map will end early.
     progress_bar : string
         Progress bar options's string for showing progress.
     progress_bar_kwargs : dict
@@ -94,6 +97,7 @@ def serial_map(task, values, task_args=None, task_kwargs=None,
     if task_kwargs is None:
         task_kwargs = {}
     map_kw = _read_map_kw(map_kw)
+    remaining_ntraj = None
     progress_bar = progress_bars[progress_bar](
         len(values), **progress_bar_kwargs
     )
@@ -115,9 +119,11 @@ def serial_map(task, values, task_args=None, task_kwargs=None,
                 errors[n] = err
         else:
             if reduce_func is not None:
-                reduce_func(result)
+                remaining_ntraj = reduce_func(result)
             else:
                 results[n] = result
+        if remaining_ntraj is not None and remaining_ntraj <= 0:
+            end_time = 0
     progress_bar.finished()
 
     if errors:
@@ -149,7 +155,9 @@ def parallel_map(task, values, task_args=None, task_kwargs=None,
     reduce_func : func (optional)
         If provided, it will be called with the output of each tasks instead of
         storing a them in a list. Note that the order in which results are
-        passed to ``reduce_func`` is not defined.
+        passed to ``reduce_func`` is not defined. It should return None or a
+        number. When returning a number, it represent the estimation of the
+        number of task left. On a return >= 0, the map will end early.
     progress_bar : string
         Progress bar options's string for showing progress.
     progress_bar_kwargs : dict
@@ -183,6 +191,7 @@ def parallel_map(task, values, task_args=None, task_kwargs=None,
     )
 
     errors = {}
+    finished = []
     if reduce_func is not None:
         results = None
         result_func = lambda i, value: reduce_func(value)
@@ -196,7 +205,9 @@ def _done_callback(future):
                 result = future.result()
             except Exception as e:
                 errors[future._i] = e
-        result_func(future._i, result)
+        remaining_ntraj = result_func(future._i, result)
+        if remaining_ntraj is not None and remaining_ntraj <= 0:
+            finished.append(True)
         progress_bar.update()
 
     if sys.version_info >= (3, 7):
@@ -226,7 +237,11 @@ def _done_callback(future):
                         timeout=timeout,
                         return_when=concurrent.futures.FIRST_COMPLETED,
                     )
-                if time.time() >= end_time or (errors and map_kw['fail_fast']):
+                if (
+                    time.time() >= end_time
+                    or (errors and map_kw['fail_fast'])
+                    or finished
+                ):
                     # no time left, exit the loop
                     break
                 while len(waiting) < map_kw['num_cpus'] and i < len(values):
@@ -284,7 +299,9 @@ def loky_pmap(task, values, task_args=None, task_kwargs=None,
         The optional additional keyword argument to the ``task`` function.
     reduce_func : func (optional)
         If provided, it will be called with the output of each tasks instead of
-        storing a them in a list.
+        storing a them in a list. It should return None or a number.  When
+        returning a number, it represent the estimation of the number of task
+        left. On a return >= 0, the map will end early.
     progress_bar : string
         Progress bar options's string for showing progress.
     progress_bar_kwargs : dict
@@ -321,6 +338,7 @@ def loky_pmap(task, values, task_args=None, task_kwargs=None,
     end_time = map_kw['timeout'] + time.time()
     job_time = map_kw['job_timeout']
     results = None
+    remaining_ntraj = None
     errors = {}
     if reduce_func is None:
         results = [None] * len(values)
@@ -340,10 +358,12 @@ def loky_pmap(task, values, task_args=None, task_kwargs=None,
                     errors[n] = err
             else:
                 if reduce_func is not None:
-                    reduce_func(result)
+                    remaining_ntraj = reduce_func(result)
                 else:
                     results[n] = result
             progress_bar.update()
+            if remaining_ntraj is not None and remaining_ntraj <= 0:
+                break
 
     except KeyboardInterrupt as e:
         [job.cancel() for job in jobs]
diff --git a/qutip/tests/solver/test_parallel.py b/qutip/tests/solver/test_parallel.py
index 416369175e..bb53496edb 100644
--- a/qutip/tests/solver/test_parallel.py
+++ b/qutip/tests/solver/test_parallel.py
@@ -119,3 +119,23 @@ def test_map_store_error(map):
             assert result == n
         else:
             assert result is None
+
+
+@pytest.mark.parametrize('map', [
+    pytest.param(parallel_map, id='parallel_map'),
+    pytest.param(loky_pmap, id='loky_pmap'),
+    pytest.param(serial_map, id='serial_map'),
+])
+def test_map_early_end(map):
+    if map is loky_pmap:
+        loky = pytest.importorskip("loky")
+
+    results = []
+
+    def reduce_func(result):
+        results.append(result)
+        return 5 - len(results)
+
+    map(_func1, range(100), reduce_func=reduce_func)
+
+    assert len(results) < 100

From 7d789a6886111b124ec22b6f87e93af8b7784db4 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 11:30:39 -0400
Subject: [PATCH 586/602] Add towncrier entry

---
 doc/changes/2222.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2222.feature

diff --git a/doc/changes/2222.feature b/doc/changes/2222.feature
new file mode 100644
index 0000000000..a216bb0545
--- /dev/null
+++ b/doc/changes/2222.feature
@@ -0,0 +1 @@
+Add early end of support in map functions.

From 3ef20446b31e813c399e0e182a523f4cb4e0ced7 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 14:02:14 -0400
Subject: [PATCH 587/602] Deprecate orbital

---
 doc/apidoc/functions.rst          |  2 -
 qutip/__init__.py                 |  7 ++-
 qutip/orbital.py                  | 81 -------------------------------
 qutip/tests/test_animation.py     |  3 +-
 qutip/tests/test_orbital.py       | 55 ---------------------
 qutip/tests/test_visualization.py | 10 ++--
 6 files changed, 15 insertions(+), 143 deletions(-)
 delete mode 100644 qutip/orbital.py
 delete mode 100644 qutip/tests/test_orbital.py

diff --git a/doc/apidoc/functions.rst b/doc/apidoc/functions.rst
index fb6c591482..3c781b4200 100644
--- a/doc/apidoc/functions.rst
+++ b/doc/apidoc/functions.rst
@@ -233,8 +233,6 @@ Graphs and Visualization
 .. automodule:: qutip.animation
     :members: anim_hinton, anim_matrix_histogram, anim_fock_distribution, anim_wigner, anim_sphereplot, anim_schmidt, anim_qubism, anim_wigner_sphere, anim_spin_distribution
 
-.. automodule:: qutip.orbital
-    :members: orbital
 
 .. automodule:: qutip.matplotlib_utilities
    :members: wigner_cmap, complex_phase_cmap
diff --git a/qutip/__init__.py b/qutip/__init__.py
index dbdc922732..7afac3ce81 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -39,7 +39,6 @@
 from .bloch import *
 from .visualization import *
 from .animation import *
-from .orbital import *
 from .bloch3d import *
 from .matplotlib_utilities import *
 
@@ -60,6 +59,12 @@
 from .about import *
 from .cite import *
 
+
+def orbital(*_, **_):
+    raise NotImplementedError(
+        "'orbital was removed. Use scipy.special.sph_harm instead'"
+    )
+
 # -----------------------------------------------------------------------------
 # Clean name space
 #
diff --git a/qutip/orbital.py b/qutip/orbital.py
deleted file mode 100644
index 209b65b406..0000000000
--- a/qutip/orbital.py
+++ /dev/null
@@ -1,81 +0,0 @@
-__all__ = ['orbital']
-
-import numpy as np
-from scipy.special import sph_harm
-
-
-def orbital(theta, phi, *args):
-    r"""Calculates an angular wave function on a sphere.
-    ``psi = orbital(theta,phi,ket1,ket2,...)`` calculates
-    the angular wave function on a sphere at the mesh of points
-    defined by theta and phi which is
-    :math:`\sum_{lm} c_{lm} Y_{lm}(theta,phi)` where :math:`C_{lm}` are the
-    coefficients specified by the list of kets. Each ket has 2l+1 components
-    for some integer l. The first entry of the ket defines the coefficient
-    c_{l,-l}, while the last entry of the ket defines the
-    coefficient c_{l, l}.
-
-    Parameters
-    ----------
-    theta : int/float/list/array
-        Polar angles in [0, pi]
-
-    phi : int/float/list/array
-        Azimuthal angles in [0, 2*pi]
-
-    args : list/array
-        ``list`` of ket vectors.
-
-    Returns
-    -------
-    ``array`` for angular wave function evaluated at all
-              possible combinations of theta and phi
-
-    """
-    if isinstance(args[0], list):
-        # use the list in args[0]
-        args = args[0]
-
-    # convert to numpy array
-    theta = np.atleast_1d(theta)
-    phi = np.atleast_1d(phi)
-    # check that arrays are only 1D
-    if len(theta.shape) != 1:
-        raise ValueError('Polar angles theta must be 1D list')
-    if len(phi.shape) != 1:
-        raise ValueError('Azimuthal angles phi must be 1D list')
-
-    # make meshgrid
-    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
-    # setup empty wavefunction
-    psi = np.zeros([theta.shape[0], phi.shape[0]], dtype=complex)
-    # iterate through provided kets
-    for k in range(len(args)):
-        ket = args[k]
-        if ket.type == 'bra':
-            ket = ket.conj()
-        elif not ket.type == 'ket':
-            raise TypeError('Invalid type for input ket in orbital')
-        # Extract l value from the state
-        l = (ket.shape[0] - 1) / 2.0
-        if l != np.floor(l):
-            raise ValueError(
-                'Kets must have odd number of components in orbital')
-        l = int(l)
-        # get factors from ket
-        factors = ket.full()
-        # iterate through the possible m
-
-        for i in range(len(factors)):
-            # set correct m
-            m = i - l
-            # calculate spherical harmonics
-            # note that theta and phi are interchanged in scipy implementation
-            res = sph_harm(m, l, phi_mesh, theta_mesh)
-            psi += factors[i] * res
-
-    # flatten output if only one row
-    if psi.shape[1] == 1:
-        psi = psi.flatten()
-
-    return psi
diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
index 533bc9d3e9..de969b55c4 100644
--- a/qutip/tests/test_animation.py
+++ b/qutip/tests/test_animation.py
@@ -55,7 +55,8 @@ def test_anim_hinton():
 def test_anim_sphereplot():
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
-    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+    values = sph_harm(-1, 2, phi_mesh, theta_mesh).T
     fig, ani = qutip.anim_sphereplot([values]*2, theta, phi)
     plt.close()
 
diff --git a/qutip/tests/test_orbital.py b/qutip/tests/test_orbital.py
deleted file mode 100644
index e5a1829766..0000000000
--- a/qutip/tests/test_orbital.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import pytest
-from scipy.special import sph_harm
-from qutip.orbital import orbital
-import qutip
-import numpy as np
-
-
-def test_orbital_single_ket():
-    """ Checks output for a single ket as input"""
-    # setup mesh for theta and phi
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    for theta, phi in zip(theta_list, phi_list):
-        # set l and m
-        for l in range(0, 5):
-            for m in range(-l, l + 1):
-                q = qutip.basis(2 * l + 1, l + m)
-                # check that outputs are the same,
-                # note that theta and phi are interchanged for scipy
-                assert sph_harm(m, l, phi, theta) == orbital(theta, phi, q)
-
-
-def test_orbital_multiple_ket():
-    """ Checks if the combination of multiple kets works """
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    l, m = 5, 2
-    q1 = qutip.basis(2 * l + 1, l + m)
-    l, m = 3, -1
-    q2 = qutip.basis(2 * l + 1, l + m)
-    for theta, phi in zip(theta_list, phi_list):
-        exp = sph_harm(2, 5, phi, theta) + sph_harm(-1, 3, phi, theta)
-        assert orbital(theta, phi, q1, q2) ==  exp
-
-
-def test_orbital_explicit():
-    """ Checks explicit configurations of orbital functions"""
-    theta_list = np.linspace(0, np.pi, num=50)
-    phi_list = np.linspace(0, 2 * np.pi, num=100)
-    # Constant function
-    l, m = 0, 0
-    q = qutip.basis(2 * l + 1, l + m)
-    assert orbital(0, 0, q) == 0.5 * np.sqrt(1 / np.pi)
-    # cosine function
-    l, m = 1, 0
-    q = qutip.basis(2 * l + 1, l + m)
-    assert np.allclose(orbital(theta_list, 0, q),
-                       0.5 * np.sqrt(3 / np.pi) * np.cos(theta_list))
-    # cosine with phase
-    l, m = 1, 1
-    q = qutip.basis(2 * l + 1, l + m)
-    phi_mesh, theta_mesh = np.meshgrid(phi_list, theta_list)
-    assert np.allclose(orbital(theta_list, phi_list, q),
-                       -0.5 * np.sqrt(3 / (2 * np.pi)) * np.sin(
-                           theta_mesh) * np.exp(1j * phi_mesh))
diff --git a/qutip/tests/test_visualization.py b/qutip/tests/test_visualization.py
index 248c146b04..b4c2a7e365 100644
--- a/qutip/tests/test_visualization.py
+++ b/qutip/tests/test_visualization.py
@@ -3,6 +3,7 @@
 import numpy as np
 import matplotlib as mpl
 import matplotlib.pyplot as plt
+from scipy.special import sph_harm
 
 
 def test_cyclic():
@@ -35,7 +36,8 @@ def test_sequential():
     qutip.settings.colorblind_safe = True
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
-    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+    values = sph_harm(-1, 2, phi_mesh, theta_mesh).T
     fig, ax = qutip.sphereplot(values, theta, phi)
     plt.close()
 
@@ -199,7 +201,8 @@ def test_hinton_ValueError1(transform, args, error_message):
 def test_sphereplot(args):
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
-    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+    values = sph_harm(-1, 2, phi_mesh, theta_mesh).T
     fig, ax = qutip.sphereplot(values, theta, phi, **args)
     plt.close()
 
@@ -210,7 +213,8 @@ def test_sphereplot(args):
 def test_sphereplot_anim():
     theta = np.linspace(0, np.pi, 90)
     phi = np.linspace(0, 2 * np.pi, 60)
-    values = qutip.orbital(theta, phi, qutip.basis(3, 0)).T
+    phi_mesh, theta_mesh = np.meshgrid(phi, theta)
+    values = sph_harm(-1, 2, phi_mesh, theta_mesh).T
     fig, ani = qutip.sphereplot([values]*2, theta, phi)
     plt.close()
 

From f4e47162d0d6bb00c49ab802fc0f3522581a6906 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 14:18:07 -0400
Subject: [PATCH 588/602] Add towncrier

---
 doc/changes/2223.removal | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2223.removal

diff --git a/doc/changes/2223.removal b/doc/changes/2223.removal
new file mode 100644
index 0000000000..e49ae0499f
--- /dev/null
+++ b/doc/changes/2223.removal
@@ -0,0 +1 @@
+Deprecate orbital

From 789fe7d835f09a5df5c876c3c4588d676f66db7d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 14:35:28 -0400
Subject: [PATCH 589/602] Update existing tests

---
 qutip/tests/solver/test_mcsolve.py    | 2 +-
 qutip/tests/solver/test_nm_mcsolve.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index d4cbeb4ca8..b3818cf502 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -431,7 +431,7 @@ def test_MCSolver_run():
         e_ops=[qutip.qeye(size)], args={'coupling': 1},
         ntraj=1000, target_tol=0.1
     )
-    assert res.num_trajectories == 1001
+    assert 1 < res.num_trajectories and res.num_trajectories < 1001
 
 
 def test_MCSolver_stepping():
diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index 1359a62108..7759cbf2b4 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -598,7 +598,7 @@ def test_NonMarkovianMCSolver_run():
         e_ops=[qutip.qeye(size)], args={'coupling': 1},
         ntraj=1000, target_tol=0.1
     )
-    assert res.num_trajectories == 1001
+    assert 1 < res.num_trajectories and res.num_trajectories < 1001
 
 
 def test_NonMarkovianMCSolver_stepping():

From 32a31f92b396c1c179e2fd9163e479ad643d902e Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 14:36:31 -0400
Subject: [PATCH 590/602] pep8

---
 qutip/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutip/__init__.py b/qutip/__init__.py
index 7afac3ce81..eaefb92519 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -65,6 +65,7 @@ def orbital(*_, **_):
         "'orbital was removed. Use scipy.special.sph_harm instead'"
     )
 
+
 # -----------------------------------------------------------------------------
 # Clean name space
 #

From 9811c9b790063699465674cda307446a33821431 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 14:51:01 -0400
Subject: [PATCH 591/602] Fix args name

---
 qutip/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/__init__.py b/qutip/__init__.py
index eaefb92519..0362e7159c 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -60,7 +60,7 @@
 from .cite import *
 
 
-def orbital(*_, **_):
+def orbital(*_, **__):
     raise NotImplementedError(
         "'orbital was removed. Use scipy.special.sph_harm instead'"
     )

From 93b6921b1b4eb3a1800acf7bde0f0161c845ffe2 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@gmail.com>
Date: Thu, 31 Aug 2023 14:55:30 -0400
Subject: [PATCH 592/602] Fix import

---
 qutip/tests/test_animation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutip/tests/test_animation.py b/qutip/tests/test_animation.py
index de969b55c4..676e7473a4 100644
--- a/qutip/tests/test_animation.py
+++ b/qutip/tests/test_animation.py
@@ -3,7 +3,7 @@
 import numpy as np
 import matplotlib as mpl
 import matplotlib.pyplot as plt
-
+from scipy.special import sph_harm
 
 def test_result_state():
     H = qutip.rand_dm(2)

From 9c514ac05d1d9d36b17d52e83b265868276c7cd4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Thu, 31 Aug 2023 15:56:16 -0400
Subject: [PATCH 593/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 qutip/solver/parallel.py              | 6 +++---
 qutip/tests/solver/test_mcsolve.py    | 2 +-
 qutip/tests/solver/test_nm_mcsolve.py | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/qutip/solver/parallel.py b/qutip/solver/parallel.py
index c5a0eaf8a7..83bf727a0a 100644
--- a/qutip/solver/parallel.py
+++ b/qutip/solver/parallel.py
@@ -73,7 +73,7 @@ def serial_map(task, values, task_args=None, task_kwargs=None,
         If provided, it will be called with the output of each tasks instead of
         storing a them in a list. It should return None or a number.
         When returning a number, it represent the estimation of the number of
-        task left. On a return >= 0, the map will end early.
+        task left. On a return <= 0, the map will end early.
     progress_bar : string
         Progress bar options's string for showing progress.
     progress_bar_kwargs : dict
@@ -157,7 +157,7 @@ def parallel_map(task, values, task_args=None, task_kwargs=None,
         storing a them in a list. Note that the order in which results are
         passed to ``reduce_func`` is not defined. It should return None or a
         number. When returning a number, it represent the estimation of the
-        number of task left. On a return >= 0, the map will end early.
+        number of task left. On a return <= 0, the map will end early.
     progress_bar : string
         Progress bar options's string for showing progress.
     progress_bar_kwargs : dict
@@ -301,7 +301,7 @@ def loky_pmap(task, values, task_args=None, task_kwargs=None,
         If provided, it will be called with the output of each tasks instead of
         storing a them in a list. It should return None or a number.  When
         returning a number, it represent the estimation of the number of task
-        left. On a return >= 0, the map will end early.
+        left. On a return <= 0, the map will end early.
     progress_bar : string
         Progress bar options's string for showing progress.
     progress_bar_kwargs : dict
diff --git a/qutip/tests/solver/test_mcsolve.py b/qutip/tests/solver/test_mcsolve.py
index b3818cf502..7a14089a29 100644
--- a/qutip/tests/solver/test_mcsolve.py
+++ b/qutip/tests/solver/test_mcsolve.py
@@ -431,7 +431,7 @@ def test_MCSolver_run():
         e_ops=[qutip.qeye(size)], args={'coupling': 1},
         ntraj=1000, target_tol=0.1
     )
-    assert 1 < res.num_trajectories and res.num_trajectories < 1001
+    assert 1 < res.num_trajectories < 1001
 
 
 def test_MCSolver_stepping():
diff --git a/qutip/tests/solver/test_nm_mcsolve.py b/qutip/tests/solver/test_nm_mcsolve.py
index 7759cbf2b4..e47b638e4b 100644
--- a/qutip/tests/solver/test_nm_mcsolve.py
+++ b/qutip/tests/solver/test_nm_mcsolve.py
@@ -598,7 +598,7 @@ def test_NonMarkovianMCSolver_run():
         e_ops=[qutip.qeye(size)], args={'coupling': 1},
         ntraj=1000, target_tol=0.1
     )
-    assert 1 < res.num_trajectories and res.num_trajectories < 1001
+    assert 1 < res.num_trajectories < 1001
 
 
 def test_NonMarkovianMCSolver_stepping():

From afebd72ab070e6d43ecd47f07a3ef0d47c6fb45f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Thu, 31 Aug 2023 15:58:11 -0400
Subject: [PATCH 594/602] Update qutip/__init__.py

---
 qutip/__init__.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/qutip/__init__.py b/qutip/__init__.py
index 0362e7159c..ff8d76a7e8 100644
--- a/qutip/__init__.py
+++ b/qutip/__init__.py
@@ -59,13 +59,6 @@
 from .about import *
 from .cite import *
 
-
-def orbital(*_, **__):
-    raise NotImplementedError(
-        "'orbital was removed. Use scipy.special.sph_harm instead'"
-    )
-
-
 # -----------------------------------------------------------------------------
 # Clean name space
 #

From 350a0f8097833f3e43014e70d8e0a768133fbdff Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 1 Sep 2023 16:52:51 -0400
Subject: [PATCH 595/602] Add memory overflow checks

---
 qutip/core/data/add.pyx   | 6 ------
 qutip/core/data/csr.pyx   | 3 +++
 qutip/core/data/dense.pyx | 5 +++++
 qutip/core/data/dia.pyx   | 2 ++
 qutip/core/data/kron.pyx  | 4 +++-
 5 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/qutip/core/data/add.pyx b/qutip/core/data/add.pyx
index 3df8f9938e..45515af87a 100644
--- a/qutip/core/data/add.pyx
+++ b/qutip/core/data/add.pyx
@@ -18,12 +18,6 @@ from qutip.core.data cimport csr, dense, dia
 
 cnp.import_array()
 
-cdef extern from *:
-    void *PyDataMem_NEW(size_t size)
-    void *PyDataMem_NEW_ZEROED(size_t size, size_t elsize)
-    void PyDataMem_FREE(void *ptr)
-
-
 __all__ = [
     'add', 'add_csr', 'add_dense', 'iadd_dense', 'add_dia',
     'sub', 'sub_csr', 'sub_dense', 'sub_dia',
diff --git a/qutip/core/data/csr.pyx b/qutip/core/data/csr.pyx
index 0b7d105b87..182c79714b 100644
--- a/qutip/core/data/csr.pyx
+++ b/qutip/core/data/csr.pyx
@@ -530,6 +530,9 @@ cpdef CSR empty(base.idxint rows, base.idxint cols, base.idxint size):
         <base.idxint *> PyDataMem_NEW(size * sizeof(base.idxint))
     out.row_index =\
         <base.idxint *> PyDataMem_NEW(row_size * sizeof(base.idxint))
+    if not out.data: raise MemoryError()
+    if not out.col_index: raise MemoryError()
+    if not out.row_index: raise MemoryError()
     # Set the number of non-zero elements to 0.
     out.row_index[rows] = 0
     return out
diff --git a/qutip/core/data/dense.pyx b/qutip/core/data/dense.pyx
index 0c75a463a5..1fc7f35670 100644
--- a/qutip/core/data/dense.pyx
+++ b/qutip/core/data/dense.pyx
@@ -120,6 +120,7 @@ cdef class Dense(base.Data):
         cdef Dense out = Dense.__new__(Dense)
         cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
         cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+        if not ptr: raise MemoryError()
         memcpy(ptr, self.data, size)
         out.shape = self.shape
         out.data = ptr
@@ -162,6 +163,7 @@ cdef class Dense(base.Data):
         """
         cdef size_t size = self.shape[0]*self.shape[1]*sizeof(double complex)
         cdef double complex *ptr = <double complex *> PyDataMem_NEW(size)
+        if not ptr: raise MemoryError()
         memcpy(ptr, self.data, size)
         cdef object out =\
             cnp.PyArray_SimpleNewFromData(2, [self.shape[0], self.shape[1]],
@@ -244,6 +246,7 @@ cpdef Dense empty(base.idxint rows, base.idxint cols, bint fortran=True):
     cdef Dense out = Dense.__new__(Dense)
     out.shape = (rows, cols)
     out.data = <double complex *> PyDataMem_NEW(rows * cols * sizeof(double complex))
+    if not out.data: raise MemoryError()
     out._deallocate = True
     out.fortran = fortran
     return out
@@ -264,6 +267,7 @@ cpdef Dense zeros(base.idxint rows, base.idxint cols, bint fortran=True):
     out.shape = (rows, cols)
     out.data =\
         <double complex *> PyDataMem_NEW_ZEROED(rows * cols, sizeof(double complex))
+    if not out.data: raise MemoryError()
     out.fortran = fortran
     out._deallocate = True
     return out
@@ -290,6 +294,7 @@ cpdef Dense from_csr(CSR matrix, bint fortran=False):
         <double complex *>
         PyDataMem_NEW_ZEROED(out.shape[0]*out.shape[1], sizeof(double complex))
     )
+    if not out.data: raise MemoryError()
     out.fortran = fortran
     out._deallocate = True
     cdef size_t row, ptr_in, ptr_out, row_stride, col_stride
diff --git a/qutip/core/data/dia.pyx b/qutip/core/data/dia.pyx
index 3aaffe3036..2b37d09159 100644
--- a/qutip/core/data/dia.pyx
+++ b/qutip/core/data/dia.pyx
@@ -271,6 +271,8 @@ cpdef Dia empty(base.idxint rows, base.idxint cols, base.idxint num_diag):
         <double complex *> PyDataMem_NEW(cols * num_diag * sizeof(double complex))
     out.offsets =\
         <base.idxint *> PyDataMem_NEW(num_diag * sizeof(base.idxint))
+    if not out.data: raise MemoryError()
+    if not out.offsets: raise MemoryError()
     return out
 
 
diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index 10f95f083f..e945100284 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -114,7 +114,9 @@ cpdef Dia kron_dia(Dia left, Dia right):
                 num_diag += 1
 
     else:
-        out = dia.empty(nrows, ncols, _mul_checked(max_diag, ncols_l))
+        max_diag = _mul_checked(max_diag, ncols_l)
+        max_diag = min(max_diag, nrows + ncols - 1)
+        out = dia.empty(nrows, ncols, max_diag)
         delta = right.shape[0] - right.shape[1]
         for diag_left in range(left.num_diag):
             for diag_right in range(right.num_diag):

From 8585352a00c45e1f21e778cfbd11235469bde239 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Fri, 1 Sep 2023 20:11:40 -0400
Subject: [PATCH 596/602] Fallback on dense operation

---
 qutip/core/data/kron.pyx | 65 +++++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/qutip/core/data/kron.pyx b/qutip/core/data/kron.pyx
index e945100284..fb3d3d69c6 100644
--- a/qutip/core/data/kron.pyx
+++ b/qutip/core/data/kron.pyx
@@ -10,6 +10,7 @@ from qutip.core.data.dense cimport Dense
 from .adjoint import transpose
 from qutip.core.data.dia cimport Dia
 from qutip.core.data cimport csr, dia
+from qutip.core.data.convert import to as _to
 import numpy
 
 __all__ = [
@@ -112,38 +113,48 @@ cpdef Dia kron_dia(Dia left, Dia right):
                     right.shape[1]
                 )
                 num_diag += 1
+        out.num_diag = num_diag
 
     else:
         max_diag = _mul_checked(max_diag, ncols_l)
-        max_diag = min(max_diag, nrows + ncols - 1)
-        out = dia.empty(nrows, ncols, max_diag)
-        delta = right.shape[0] - right.shape[1]
-        for diag_left in range(left.num_diag):
-            for diag_right in range(right.num_diag):
-                start_left = max(0, left.offsets[diag_left])
-                end_left = min(left.shape[1], left.shape[0] + left.offsets[diag_left])
-                for col_left in range(start_left, end_left):
-                    memset(
-                        out.data + (num_diag * out.shape[1]), 0,
-                        out.shape[1] * sizeof(double complex)
-                    )
-
-                    out.offsets[num_diag] = (
-                        left.offsets[diag_left] * right.shape[0]
-                        + right.offsets[diag_right]
-                        - col_left * delta
-                    )
-
-                    start_right = max(0, right.offsets[diag_right])
-                    end_right = min(right.shape[1], right.shape[0] + right.offsets[diag_right])
-                    for col_right in range(start_right, end_right):
-                        out.data[num_diag * out.shape[1] + col_left * right.shape[1] + col_right] = (
-                            right.data[diag_right * right.shape[1] + col_right]
-                            * left.data[diag_left * left.shape[1] + col_left]
+        if max_diag < nrows:
+            out = dia.empty(nrows, ncols, max_diag)
+            delta = right.shape[0] - right.shape[1]
+            for diag_left in range(left.num_diag):
+                for diag_right in range(right.num_diag):
+                    start_left = max(0, left.offsets[diag_left])
+                    end_left = min(left.shape[1], left.shape[0] + left.offsets[diag_left])
+                    for col_left in range(start_left, end_left):
+                        memset(
+                            out.data + (num_diag * out.shape[1]), 0,
+                            out.shape[1] * sizeof(double complex)
                         )
-                    num_diag += 1
 
-    out.num_diag = num_diag
+                        out.offsets[num_diag] = (
+                            left.offsets[diag_left] * right.shape[0]
+                            + right.offsets[diag_right]
+                            - col_left * delta
+                        )
+
+                        start_right = max(0, right.offsets[diag_right])
+                        end_right = min(right.shape[1], right.shape[0] + right.offsets[diag_right])
+                        for col_right in range(start_right, end_right):
+                            out.data[num_diag * out.shape[1] + col_left * right.shape[1] + col_right] = (
+                                right.data[diag_right * right.shape[1] + col_right]
+                                * left.data[diag_left * left.shape[1] + col_left]
+                            )
+                        num_diag += 1
+            out.num_diag = num_diag
+
+        else:
+            # The output is not sparse enough ant the empty data array would be
+            # larger than the dense array.
+            # Fallback on dense operation
+            left_dense = _to(Dense, left)
+            right_dense = _to(Dense, right)
+            out_dense = kron_dense(left_dense, right_dense)
+            out = _to(Dia, out_dense)
+
     out = dia.clean_dia(out, True)
     return out
 

From 9cb54177e965e2e7ad06e59fec58bf909bb1ee88 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Tue, 5 Sep 2023 09:06:07 -0400
Subject: [PATCH 597/602] Add towncrier

---
 doc/changes/2224.bugfix | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 doc/changes/2224.bugfix

diff --git a/doc/changes/2224.bugfix b/doc/changes/2224.bugfix
new file mode 100644
index 0000000000..12b9abfbc3
--- /dev/null
+++ b/doc/changes/2224.bugfix
@@ -0,0 +1 @@
+Raise on insufficient memory.

From 99c286403597e4208ece3b1e88b0b52baa34a04d Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 6 Sep 2023 10:35:44 -0400
Subject: [PATCH 598/602] Fix fsesolve fallback

---
 qutip/solver/floquet.py            | 3 +--
 qutip/tests/solver/test_floquet.py | 8 ++++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/qutip/solver/floquet.py b/qutip/solver/floquet.py
index 688315d19a..61c139d349 100644
--- a/qutip/solver/floquet.py
+++ b/qutip/solver/floquet.py
@@ -659,14 +659,13 @@ def fmmesolve(
         the expectation values for the times specified by `tlist`, and/or the
         state density matrices corresponding to the times.
     """
-    if c_ops is None:
+    if c_ops is None and rho0.isket:
         return fsesolve(
             H,
             rho0,
             tlist,
             e_ops=e_ops,
             T=T,
-            w_th=w_th,
             args=args,
             options=options,
         )
diff --git a/qutip/tests/solver/test_floquet.py b/qutip/tests/solver/test_floquet.py
index be90e6fab2..679a3cba80 100644
--- a/qutip/tests/solver/test_floquet.py
+++ b/qutip/tests/solver/test_floquet.py
@@ -331,3 +331,11 @@ def noise_spectrum(omega):
                       * (array_ana_E1[idx] - delta / 2))
             assert (min(abs(Xs - Xpm_m1)) < 1e-4)
             idx += 1
+
+
+def test_fsesolve_fallback():
+    H = [sigmaz(), lambda t: np.sin(t * 2 * np.pi)]
+    psi0 = rand_ket(2)
+    ffstate = fmmesolve(H, psi0, [0, 1], T=1.).final_state
+    fstate = sesolve(H, psi0, [0, 1]).final_state
+    assert (ffstate - fstate).norm() < 1e-5

From 5a3a866e66c8b2d090420787b620841ba59c1116 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 6 Sep 2023 14:13:02 -0400
Subject: [PATCH 599/602] Create 5.0.0a2 changelog

---
 doc/changelog.rst        | 79 ++++++++++++++++++++++++++++++++++++++++
 doc/changes/1951.feature |  1 -
 doc/changes/1952.bugfix  |  1 -
 doc/changes/1981.feature |  1 -
 doc/changes/1982.misc    |  1 -
 doc/changes/1984.doc     |  1 -
 doc/changes/1991.feature |  1 -
 doc/changes/2032.bugfix  |  1 -
 doc/changes/2070.feature |  1 -
 doc/changes/2103.misc    |  1 -
 doc/changes/2105.misc    |  1 -
 doc/changes/2107.bugfix  |  1 -
 doc/changes/2110.misc    |  1 -
 doc/changes/2111.feature |  1 -
 doc/changes/2112.misc    |  1 -
 doc/changes/2113.feature |  1 -
 doc/changes/2114.misc    |  2 -
 doc/changes/2116.removal |  1 -
 doc/changes/2119.misc    |  1 -
 doc/changes/2120.removal |  1 -
 doc/changes/2126.feature |  1 -
 doc/changes/2128.feature |  1 -
 doc/changes/2131.feature |  1 -
 doc/changes/2135.misc    |  1 -
 doc/changes/2136.doc     |  1 -
 doc/changes/2138.misc    |  1 -
 doc/changes/2141.feature |  1 -
 doc/changes/2142.misc    |  1 -
 doc/changes/2150.misc    |  1 -
 doc/changes/2151.misc    |  1 -
 doc/changes/2153.feature |  1 -
 doc/changes/2157.feature |  1 -
 doc/changes/2166.feature |  4 --
 doc/changes/2167.doc     |  1 -
 doc/changes/2170.feature |  1 -
 doc/changes/2174.doc     |  1 -
 doc/changes/2181.bugfix  |  1 -
 doc/changes/2192.misc    |  1 -
 doc/changes/2193.feature |  1 -
 doc/changes/2196.feature |  1 -
 doc/changes/2203.feature |  1 -
 doc/changes/2218.feature |  1 -
 doc/changes/2219.misc    |  1 -
 doc/changes/2221.removal |  1 -
 doc/changes/2222.feature |  1 -
 doc/changes/2223.removal |  1 -
 doc/changes/2224.bugfix  |  1 -
 47 files changed, 79 insertions(+), 50 deletions(-)
 delete mode 100644 doc/changes/1951.feature
 delete mode 100644 doc/changes/1952.bugfix
 delete mode 100644 doc/changes/1981.feature
 delete mode 100644 doc/changes/1982.misc
 delete mode 100644 doc/changes/1984.doc
 delete mode 100644 doc/changes/1991.feature
 delete mode 100644 doc/changes/2032.bugfix
 delete mode 100644 doc/changes/2070.feature
 delete mode 100644 doc/changes/2103.misc
 delete mode 100644 doc/changes/2105.misc
 delete mode 100644 doc/changes/2107.bugfix
 delete mode 100644 doc/changes/2110.misc
 delete mode 100644 doc/changes/2111.feature
 delete mode 100644 doc/changes/2112.misc
 delete mode 100644 doc/changes/2113.feature
 delete mode 100644 doc/changes/2114.misc
 delete mode 100644 doc/changes/2116.removal
 delete mode 100644 doc/changes/2119.misc
 delete mode 100644 doc/changes/2120.removal
 delete mode 100644 doc/changes/2126.feature
 delete mode 100644 doc/changes/2128.feature
 delete mode 100644 doc/changes/2131.feature
 delete mode 100644 doc/changes/2135.misc
 delete mode 100644 doc/changes/2136.doc
 delete mode 100644 doc/changes/2138.misc
 delete mode 100644 doc/changes/2141.feature
 delete mode 100644 doc/changes/2142.misc
 delete mode 100644 doc/changes/2150.misc
 delete mode 100644 doc/changes/2151.misc
 delete mode 100644 doc/changes/2153.feature
 delete mode 100644 doc/changes/2157.feature
 delete mode 100644 doc/changes/2166.feature
 delete mode 100644 doc/changes/2167.doc
 delete mode 100644 doc/changes/2170.feature
 delete mode 100644 doc/changes/2174.doc
 delete mode 100644 doc/changes/2181.bugfix
 delete mode 100644 doc/changes/2192.misc
 delete mode 100644 doc/changes/2193.feature
 delete mode 100644 doc/changes/2196.feature
 delete mode 100644 doc/changes/2203.feature
 delete mode 100644 doc/changes/2218.feature
 delete mode 100644 doc/changes/2219.misc
 delete mode 100644 doc/changes/2221.removal
 delete mode 100644 doc/changes/2222.feature
 delete mode 100644 doc/changes/2223.removal
 delete mode 100644 doc/changes/2224.bugfix

diff --git a/doc/changelog.rst b/doc/changelog.rst
index 318c2ec86b..16fbae0690 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -6,6 +6,85 @@ Change Log
 
 .. towncrier release notes start
 
+QuTiP 5.0.0a2 (2023-09-06)
+==========================
+
+Features
+--------
+
+- Add support for different spectra types for bloch_redfield_tensor (#1951)
+- Improve qutip import times by setting logger names explicitly. (#1981, by Pieter Eendebak)
+- Change the order of parameters in expand_operator (#1991)
+- Add `svn` and `solve` to dispatched (#2002)
+- Added nm_mcsolve to provide support for Monte-Carlo simulations of master equations with possibly negative rates. The method implemented here is described in arXiv:2209.08958 [quant-ph]. (#2070 by pmenczel)
+- Add support for combining bosinic and fermionic HEOM baths (#2089)
+- Added __repr__ to QobjEvo (#2111 by lklivingstone)
+- Improve print(qutip.settings) by make it shorter (#2113 by tamakoshi2001)
+- Create the `trace_oper_ket` operation (#2126)
+- Speed up the construction of the RHS of the HEOM solver by a factor of 4x by converting the final step to Cython. (#2128)
+- Rewrite the stochastic solver to use the v5 solver interface. (#2131)
+- Add `Qobj.get` to extract underlying data in original format. (#2141)
+- Add qeye_like and qzero_like (#2153)
+- Add capacity to dispatch on ``Data`` (#2157)
+- added fermionic annihilation and creation operators.
+  Closely followed the protocol proposed in the following `source
+  <https://github.com/qutip/qutip/issues/863>`_. (#2166 by khnikhil)
+- changed arguments and apply colorblind_safe to functions in visualization.py (#2170 by Yuji Tamakoshi)
+- changed arguments and applied colorblind_safe to plot_wigner_sphere and matrix_histogram in visualization.py (#2193 by Yuji Tamakoshi)
+- Add Dia data layer (#2196)
+- add animation (#2203 by Yuji Tamakoshi)
+- Improved sampling algorithm for mcsolve (#2218 by Daniel Weiss)
+- Add early end of support in map functions. (#2222)
+
+
+
+Bug Fixes
+---------
+
+- Add missing state transformation to floquet_markov_mesolve (#1952 by christian512)
+- Added default _isherm value (True) for momentum and position operators. (#2032 by Asier Galicia)
+- Changed qutip-notebooks to qutip-tutorials and fixed the typo in the link redirecting to the changelog section in the PR template. (#2107 by Valan Baptist Mathuranayagam)
+- Increase missing colorbar padding for matrix_histogram_complex() from 0 to 0.05. (#2181 by SJUW)
+- Raise error on insufficient memory. (#2224)
+
+
+Removals
+--------
+
+- Remove qutip.control and replace with qutip_qtrl. (#2116)
+- Deleted _solve in countstat.py and used _data.solve. (#2120 by Yuji Tamakoshi)
+- Deprecate three_level_atom (#2221)
+- Deprecate orbital (#2223)
+
+
+Documentation
+-------------
+
+- Add a guide on Superoperators, Pauli Basis and Channel Contraction. (#1984 by christian512)
+- added info about sec_cutoff to the documentation (#2136 by Gerardo Jose Suarez)
+- added inherited members to API doc of MESolver, SMESolver, SSESolver, NonMarkovianMCSolver (#2167 by Cristian Emiliano Godinez Ramirez)
+- Correct grammar in Bloch-Redfield master equation documentation (#2174 by Andrey Rakhubovsky)
+
+
+Miscellaneous
+-------------
+
+- Update scipy version requirement to 1.5+ (#1982 by Pieter Eendebak)
+- added __all__ to qutip/measurements.py and qutip/core/semidefinite.py (#2103 by Rushiraj Gadhvi)
+- Restore towncrier check (#2105)
+- qutip.ipynbtools.version_table() can now be called without Cython installed (#2110 by Rushiraj Gadhvi)
+- Moved HTMLProgressBar from qutip/ipynbtools.py to qutip/ui/progressbar.py (#2112 by Harsh Khilawala)
+- Added new argument bc_type to take boundary conditions when creating QobjEvo (#2114 by Avatar Srinidhi P V )
+- Remove Windows build warning suppression. (#2119)
+- Optimize dispatcher by dispatching on positional only args. (#2135)
+- Clean semidefinite (#2138)
+- Migrate `transfertensor.py` to solver (#2142)
+- Add a test for progress_bar (#2150)
+- Enable cython 3 (#2151)
+- add pytest for visualization.py (#2192 by Yuji Tamakoshi)
+- sort args of sphereplot and looks similar to those of plot_spin_distribution (#2219 by Yuji Tamakoshi)
+
+
 Version 5.0.0a1 (February 7, 2023)
 ++++++++++++++++++++++++++++++++++
 
diff --git a/doc/changes/1951.feature b/doc/changes/1951.feature
deleted file mode 100644
index a0315722eb..0000000000
--- a/doc/changes/1951.feature
+++ /dev/null
@@ -1 +0,0 @@
-Add support for different spectra types for bloch_redfield_tensor
\ No newline at end of file
diff --git a/doc/changes/1952.bugfix b/doc/changes/1952.bugfix
deleted file mode 100644
index 01b1506516..0000000000
--- a/doc/changes/1952.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Add missing state transformation to floquet_markov_mesolve
\ No newline at end of file
diff --git a/doc/changes/1981.feature b/doc/changes/1981.feature
deleted file mode 100644
index f875ad9774..0000000000
--- a/doc/changes/1981.feature
+++ /dev/null
@@ -1 +0,0 @@
-Improve qutip import times by setting logger names explicitly.
diff --git a/doc/changes/1982.misc b/doc/changes/1982.misc
deleted file mode 100644
index d1a5b4f07b..0000000000
--- a/doc/changes/1982.misc
+++ /dev/null
@@ -1 +0,0 @@
-Update scipy version requirement to 1.5+
diff --git a/doc/changes/1984.doc b/doc/changes/1984.doc
deleted file mode 100644
index e3fc5ea797..0000000000
--- a/doc/changes/1984.doc
+++ /dev/null
@@ -1 +0,0 @@
-Add a guide on Superoperators, Pauli Basis and Channel Contraction.
diff --git a/doc/changes/1991.feature b/doc/changes/1991.feature
deleted file mode 100644
index fca40f0011..0000000000
--- a/doc/changes/1991.feature
+++ /dev/null
@@ -1 +0,0 @@
-Change the order of parameters in expand_operator
diff --git a/doc/changes/2032.bugfix b/doc/changes/2032.bugfix
deleted file mode 100644
index 8cf71d67e7..0000000000
--- a/doc/changes/2032.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Added default _isherm value (True) for momentum and position operators.
diff --git a/doc/changes/2070.feature b/doc/changes/2070.feature
deleted file mode 100644
index 5a97836272..0000000000
--- a/doc/changes/2070.feature
+++ /dev/null
@@ -1 +0,0 @@
-Added nm_mcsolve to provide support for Monte-Carlo simulations of master equations with possibly negative rates. The method implemented here is described in arXiv:2209.08958 [quant-ph].
diff --git a/doc/changes/2103.misc b/doc/changes/2103.misc
deleted file mode 100644
index aff1b7eb93..0000000000
--- a/doc/changes/2103.misc
+++ /dev/null
@@ -1 +0,0 @@
-added __all__ to qutip/measurements.py and qutip/core/semidefinite.py
\ No newline at end of file
diff --git a/doc/changes/2105.misc b/doc/changes/2105.misc
deleted file mode 100644
index 9448f7cb05..0000000000
--- a/doc/changes/2105.misc
+++ /dev/null
@@ -1 +0,0 @@
-Restore towncrier check
diff --git a/doc/changes/2107.bugfix b/doc/changes/2107.bugfix
deleted file mode 100644
index 85e2b12df6..0000000000
--- a/doc/changes/2107.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Changed qutip-notebooks to qutip-tutorials and fixed the typo in the link redirecting to the changelog section in the PR template.
\ No newline at end of file
diff --git a/doc/changes/2110.misc b/doc/changes/2110.misc
deleted file mode 100644
index 5ae2b8c700..0000000000
--- a/doc/changes/2110.misc
+++ /dev/null
@@ -1 +0,0 @@
-qutip.ipynbtools.version_table() can now be called without Cython installed
diff --git a/doc/changes/2111.feature b/doc/changes/2111.feature
deleted file mode 100644
index cd77a2093b..0000000000
--- a/doc/changes/2111.feature
+++ /dev/null
@@ -1 +0,0 @@
-Added __repr__ to QobjEvo
\ No newline at end of file
diff --git a/doc/changes/2112.misc b/doc/changes/2112.misc
deleted file mode 100644
index aea5f7bce7..0000000000
--- a/doc/changes/2112.misc
+++ /dev/null
@@ -1 +0,0 @@
-Moved HTMLProgressBar from qutip/ipynbtools.py to qutip/ui/progressbar.py
\ No newline at end of file
diff --git a/doc/changes/2113.feature b/doc/changes/2113.feature
deleted file mode 100644
index 5a18cdf084..0000000000
--- a/doc/changes/2113.feature
+++ /dev/null
@@ -1 +0,0 @@
-Improve print(qutip.settings) by make it shorter
\ No newline at end of file
diff --git a/doc/changes/2114.misc b/doc/changes/2114.misc
deleted file mode 100644
index 77a7c22f81..0000000000
--- a/doc/changes/2114.misc
+++ /dev/null
@@ -1,2 +0,0 @@
-Added new argument bc_type to take boundary conditions when creating QobjEvo
-
diff --git a/doc/changes/2116.removal b/doc/changes/2116.removal
deleted file mode 100644
index d6b46e7a03..0000000000
--- a/doc/changes/2116.removal
+++ /dev/null
@@ -1 +0,0 @@
-Remove qutip.control and replace with qutip_qtrl.
diff --git a/doc/changes/2119.misc b/doc/changes/2119.misc
deleted file mode 100644
index 221d3d2ca9..0000000000
--- a/doc/changes/2119.misc
+++ /dev/null
@@ -1 +0,0 @@
-Remove Windows build warning suppression.
diff --git a/doc/changes/2120.removal b/doc/changes/2120.removal
deleted file mode 100644
index bf31f96af5..0000000000
--- a/doc/changes/2120.removal
+++ /dev/null
@@ -1 +0,0 @@
-Deleted _solve in countstat.py and used _data.solve.
\ No newline at end of file
diff --git a/doc/changes/2126.feature b/doc/changes/2126.feature
deleted file mode 100644
index f44b697b24..0000000000
--- a/doc/changes/2126.feature
+++ /dev/null
@@ -1 +0,0 @@
-Create the `trace_oper_ket` operation
diff --git a/doc/changes/2128.feature b/doc/changes/2128.feature
deleted file mode 100644
index 832155250b..0000000000
--- a/doc/changes/2128.feature
+++ /dev/null
@@ -1 +0,0 @@
-Speed up the construction of the RHS of the HEOM solver by a factor of 4x by converting the final step to Cython.
diff --git a/doc/changes/2131.feature b/doc/changes/2131.feature
deleted file mode 100644
index 38eeee6577..0000000000
--- a/doc/changes/2131.feature
+++ /dev/null
@@ -1 +0,0 @@
-Rewrite the stochastic solver to use the v5 solver interface.
diff --git a/doc/changes/2135.misc b/doc/changes/2135.misc
deleted file mode 100644
index e3a05416b7..0000000000
--- a/doc/changes/2135.misc
+++ /dev/null
@@ -1 +0,0 @@
-Optimize dispatcher by dispatching on positional only args.
diff --git a/doc/changes/2136.doc b/doc/changes/2136.doc
deleted file mode 100644
index 485f7a053f..0000000000
--- a/doc/changes/2136.doc
+++ /dev/null
@@ -1 +0,0 @@
-added info about sec_cutoff to the documentation 
\ No newline at end of file
diff --git a/doc/changes/2138.misc b/doc/changes/2138.misc
deleted file mode 100644
index 556c742378..0000000000
--- a/doc/changes/2138.misc
+++ /dev/null
@@ -1 +0,0 @@
-Clean semidefinite
diff --git a/doc/changes/2141.feature b/doc/changes/2141.feature
deleted file mode 100644
index 3e40499694..0000000000
--- a/doc/changes/2141.feature
+++ /dev/null
@@ -1 +0,0 @@
-Add `Qobj.get` to extract underlying data in original format.
diff --git a/doc/changes/2142.misc b/doc/changes/2142.misc
deleted file mode 100644
index ad02786d77..0000000000
--- a/doc/changes/2142.misc
+++ /dev/null
@@ -1 +0,0 @@
-Migrate `transfertensor.py` to solver
diff --git a/doc/changes/2150.misc b/doc/changes/2150.misc
deleted file mode 100644
index 41f6e5b702..0000000000
--- a/doc/changes/2150.misc
+++ /dev/null
@@ -1 +0,0 @@
-Add a test for progress_bar
diff --git a/doc/changes/2151.misc b/doc/changes/2151.misc
deleted file mode 100644
index 723707dd37..0000000000
--- a/doc/changes/2151.misc
+++ /dev/null
@@ -1 +0,0 @@
-Enable cython 3
diff --git a/doc/changes/2153.feature b/doc/changes/2153.feature
deleted file mode 100644
index 84f539b86f..0000000000
--- a/doc/changes/2153.feature
+++ /dev/null
@@ -1 +0,0 @@
-Add qeye_like and qzero_like
diff --git a/doc/changes/2157.feature b/doc/changes/2157.feature
deleted file mode 100644
index dc5af0dc4f..0000000000
--- a/doc/changes/2157.feature
+++ /dev/null
@@ -1 +0,0 @@
-Add capacity to dispatch on ``Data``
diff --git a/doc/changes/2166.feature b/doc/changes/2166.feature
deleted file mode 100644
index f10db8a251..0000000000
--- a/doc/changes/2166.feature
+++ /dev/null
@@ -1,4 +0,0 @@
-added fermionic annihilation and creation operators.
-
-Closely followed the protocol proposed in the following `source
-<https://github.com/qutip/qutip/issues/863>`_.
\ No newline at end of file
diff --git a/doc/changes/2167.doc b/doc/changes/2167.doc
deleted file mode 100644
index 5ca6dd1e25..0000000000
--- a/doc/changes/2167.doc
+++ /dev/null
@@ -1 +0,0 @@
-added inherited members to API doc of MESolver, SMESolver, SSESolver, NonMarkovianMCSolver
\ No newline at end of file
diff --git a/doc/changes/2170.feature b/doc/changes/2170.feature
deleted file mode 100644
index 10a2e0f456..0000000000
--- a/doc/changes/2170.feature
+++ /dev/null
@@ -1 +0,0 @@
-changed arguments and apply colorblind_safe to functions in visualization.py by Yuji Tamakoshi
\ No newline at end of file
diff --git a/doc/changes/2174.doc b/doc/changes/2174.doc
deleted file mode 100644
index 59e59da319..0000000000
--- a/doc/changes/2174.doc
+++ /dev/null
@@ -1 +0,0 @@
-Correct grammar in Bloch-Redfield master equation documentation
diff --git a/doc/changes/2181.bugfix b/doc/changes/2181.bugfix
deleted file mode 100644
index 5beb8f3024..0000000000
--- a/doc/changes/2181.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Increase missing colorbar padding for matrix_histogram_complex() from 0 to 0.05.
diff --git a/doc/changes/2192.misc b/doc/changes/2192.misc
deleted file mode 100644
index 4bd1ebbca6..0000000000
--- a/doc/changes/2192.misc
+++ /dev/null
@@ -1 +0,0 @@
-add pytest for visualization.py
diff --git a/doc/changes/2193.feature b/doc/changes/2193.feature
deleted file mode 100644
index 6d487ad604..0000000000
--- a/doc/changes/2193.feature
+++ /dev/null
@@ -1 +0,0 @@
-changed arguments and applied colorblind_safe to plot_wigner_sphere and matrix_histogram in visualization.py by Yuji Tamakoshi
\ No newline at end of file
diff --git a/doc/changes/2196.feature b/doc/changes/2196.feature
deleted file mode 100644
index 0113111d59..0000000000
--- a/doc/changes/2196.feature
+++ /dev/null
@@ -1 +0,0 @@
-Add Dia data layer
diff --git a/doc/changes/2203.feature b/doc/changes/2203.feature
deleted file mode 100644
index d941d6cbc5..0000000000
--- a/doc/changes/2203.feature
+++ /dev/null
@@ -1 +0,0 @@
-add animation
\ No newline at end of file
diff --git a/doc/changes/2218.feature b/doc/changes/2218.feature
deleted file mode 100644
index f0c0268037..0000000000
--- a/doc/changes/2218.feature
+++ /dev/null
@@ -1 +0,0 @@
-Improved sampling algorithm for mcsolve
\ No newline at end of file
diff --git a/doc/changes/2219.misc b/doc/changes/2219.misc
deleted file mode 100644
index 8c2fed6938..0000000000
--- a/doc/changes/2219.misc
+++ /dev/null
@@ -1 +0,0 @@
-sort args of sphereplot and looks similar to those of plot_spin_distribution
diff --git a/doc/changes/2221.removal b/doc/changes/2221.removal
deleted file mode 100644
index 8574d986ec..0000000000
--- a/doc/changes/2221.removal
+++ /dev/null
@@ -1 +0,0 @@
-Deprecate three_level_atom
diff --git a/doc/changes/2222.feature b/doc/changes/2222.feature
deleted file mode 100644
index a216bb0545..0000000000
--- a/doc/changes/2222.feature
+++ /dev/null
@@ -1 +0,0 @@
-Add early end of support in map functions.
diff --git a/doc/changes/2223.removal b/doc/changes/2223.removal
deleted file mode 100644
index e49ae0499f..0000000000
--- a/doc/changes/2223.removal
+++ /dev/null
@@ -1 +0,0 @@
-Deprecate orbital
diff --git a/doc/changes/2224.bugfix b/doc/changes/2224.bugfix
deleted file mode 100644
index 12b9abfbc3..0000000000
--- a/doc/changes/2224.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Raise on insufficient memory.

From 89e9934ca8fde4823fea156656c20e2cf50a86fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eric=20Gigu=C3=A8re?= <eric.giguere@calculquebec.ca>
Date: Wed, 6 Sep 2023 16:18:12 -0400
Subject: [PATCH 600/602] Apply suggestions from code review

Co-authored-by: Simon Cross <hodgestar+github@gmail.com>
---
 doc/changelog.rst | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/doc/changelog.rst b/doc/changelog.rst
index 16fbae0690..f2c78d31a7 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -26,15 +26,13 @@ Features
 - Add `Qobj.get` to extract underlying data in original format. (#2141)
 - Add qeye_like and qzero_like (#2153)
 - Add capacity to dispatch on ``Data`` (#2157)
-- added fermionic annihilation and creation operators.
-  Closely followed the protocol proposed in the following `source
-  <https://github.com/qutip/qutip/issues/863>`_. (#2166 by khnikhil)
-- changed arguments and apply colorblind_safe to functions in visualization.py (#2170 by Yuji Tamakoshi)
-- changed arguments and applied colorblind_safe to plot_wigner_sphere and matrix_histogram in visualization.py (#2193 by Yuji Tamakoshi)
-- Add Dia data layer (#2196)
-- add animation (#2203 by Yuji Tamakoshi)
+- Added fermionic annihilation and creation operators. (#2166 by khnikhil)
+- Changed arguments and applied colorblind_safe to functions in visualization.py (#2170 by Yuji Tamakoshi)
+- Changed arguments and applied colorblind_safe to plot_wigner_sphere and matrix_histogram in visualization.py (#2193 by Yuji Tamakoshi)
+- Added Dia data layer which represents operators as multi-diagonal matrices. (#2196)
+- Added support for animated plots. (#2203 by Yuji Tamakoshi)
 - Improved sampling algorithm for mcsolve (#2218 by Daniel Weiss)
-- Add early end of support in map functions. (#2222)
+- Added support for early termination of map functions. (#2222)
 
 
 
@@ -61,16 +59,16 @@ Documentation
 -------------
 
 - Add a guide on Superoperators, Pauli Basis and Channel Contraction. (#1984 by christian512)
-- added info about sec_cutoff to the documentation (#2136 by Gerardo Jose Suarez)
-- added inherited members to API doc of MESolver, SMESolver, SSESolver, NonMarkovianMCSolver (#2167 by Cristian Emiliano Godinez Ramirez)
-- Correct grammar in Bloch-Redfield master equation documentation (#2174 by Andrey Rakhubovsky)
+- Added information on sec_cutoff to the documentation (#2136 by Gerardo Jose Suarez)
+- Added inherited members to API doc of MESolver, SMESolver, SSESolver, NonMarkovianMCSolver (#2167 by Cristian Emiliano Godinez Ramirez)
+- Corrected grammar in Bloch-Redfield master equation documentation (#2174 by Andrey Rakhubovsky)
 
 
 Miscellaneous
 -------------
 
 - Update scipy version requirement to 1.5+ (#1982 by Pieter Eendebak)
-- added __all__ to qutip/measurements.py and qutip/core/semidefinite.py (#2103 by Rushiraj Gadhvi)
+- Added __all__ to qutip/measurements.py and qutip/core/semidefinite.py (#2103 by Rushiraj Gadhvi)
 - Restore towncrier check (#2105)
 - qutip.ipynbtools.version_table() can now be called without Cython installed (#2110 by Rushiraj Gadhvi)
 - Moved HTMLProgressBar from qutip/ipynbtools.py to qutip/ui/progressbar.py (#2112 by Harsh Khilawala)
@@ -81,8 +79,8 @@ Miscellaneous
 - Migrate `transfertensor.py` to solver (#2142)
 - Add a test for progress_bar (#2150)
 - Enable cython 3 (#2151)
-- add pytest for visualization.py (#2192 by Yuji Tamakoshi)
-- sort args of sphereplot and looks similar to those of plot_spin_distribution (#2219 by Yuji Tamakoshi)
+- Added tests for visualization.py (#2192 by Yuji Tamakoshi)
+- Sorted arguments of sphereplot so that the order is similar to those of plot_spin_distribution (#2219 by Yuji Tamakoshi)
 
 
 Version 5.0.0a1 (February 7, 2023)

From b2cfdc428419fbfa7a638781727e1df699069e72 Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 6 Sep 2023 16:32:16 -0400
Subject: [PATCH 601/602] Add last bug entry

---
 doc/changelog.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/changelog.rst b/doc/changelog.rst
index f2c78d31a7..ad63be5726 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -44,6 +44,7 @@ Bug Fixes
 - Changed qutip-notebooks to qutip-tutorials and fixed the typo in the link redirecting to the changelog section in the PR template. (#2107 by Valan Baptist Mathuranayagam)
 - Increase missing colorbar padding for matrix_histogram_complex() from 0 to 0.05. (#2181 by SJUW)
 - Raise error on insufficient memory. (#2224)
+- Fixed fallback to fsesolve call in fmmesolve (#2225)
 
 
 Removals

From dfc28754bbfb0b71e2691d584acab2ffcd2a8bec Mon Sep 17 00:00:00 2001
From: Eric Giguere <eric.giguere@calculquebec.ca>
Date: Wed, 6 Sep 2023 17:13:03 -0400
Subject: [PATCH 602/602] Update version

---
 VERSION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/VERSION b/VERSION
index f1cb422421..d51bd13201 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-5.0.0a1
+5.0.0a2